diff options
41 files changed, 4241 insertions, 173 deletions
diff --git a/.github/workflows/multi-arch-test-build.yml b/.github/workflows/multi-arch-test-build.yml index f254a8d..3e3a742 100644 --- a/.github/workflows/multi-arch-test-build.yml +++ b/.github/workflows/multi-arch-test-build.yml @@ -83,7 +83,7 @@ jobs: echo "PACKAGES=$PACKAGES" >> $GITHUB_ENV - name: Build - uses: openwrt/gh-action-sdk@v1 + uses: openwrt/gh-action-sdk@v4 env: ARCH: ${{ matrix.arch }}-${{ env.BRANCH }} FEEDNAME: packages_ci @@ -116,7 +116,7 @@ jobs: run: | docker build -t test-container --build-arg ARCH .github/workflows/ env: - ARCH: ${{ matrix.arch }} + ARCH: ${{ matrix.arch }}-${{ env.BRANCH }} - name: Test via Docker container if: ${{ matrix.runtime_test }} diff --git a/babeld/Makefile b/babeld/Makefile index 056ce43..2717c96 100644 --- a/babeld/Makefile +++ b/babeld/Makefile @@ -8,12 +8,12 @@ include $(TOPDIR)/rules.mk PKG_NAME:=babeld -PKG_VERSION:=1.10 +PKG_VERSION:=1.12.1 PKG_RELEASE:=$(AUTORELEASE) PKG_SOURCE:=$(PKG_NAME)-$(PKG_VERSION).tar.gz PKG_SOURCE_URL:=https://www.irif.fr/~jch/software/files/ -PKG_HASH:=a5f54a08322640e97399bf4d1411a34319e6e277fbb6fc4966f38a17d72a8dea +PKG_HASH:=9ab59d7ac741f3630df23f9c3b67c60294d8b34ab622398f9b89773a878ecb1e PKG_MAINTAINER:=Gabriel Kerneis <gabriel@kerneis.info>, \ Baptiste Jonglez <openwrt-pkg@bitsofnetworks.org>, \ @@ -37,7 +37,7 @@ define Package/babeld/description with fast convergence properties. It is based on the ideas in DSDV, AODV and Cisco's EIGRP, but is designed to work well not only in wired networks but also in wireless mesh networks, and has been extended with support for - overlay networks. Babel is in the process of becoming an IETF Standard. + overlay networks. Babel is an IETF standard protocol (RFC 8966). endef define Package/babeld/conffiles diff --git a/babeld/patches/600-add-ubus.patch b/babeld/patches/600-add-ubus.patch index 252a299..469b6e8 100644 --- a/babeld/patches/600-add-ubus.patch +++ b/babeld/patches/600-add-ubus.patch @@ -9,7 +9,7 @@ struct timeval now; unsigned char myid[8]; -@@ -518,6 +520,9 @@ main(int argc, char **argv) +@@ -521,6 +523,9 @@ main(int argc, char **argv) } } @@ -19,7 +19,7 @@ init_signals(); rc = resize_receive_buffer(1500); if(rc < 0) -@@ -613,6 +618,8 @@ main(int argc, char **argv) +@@ -616,6 +621,8 @@ main(int argc, char **argv) FD_SET(local_sockets[i].fd, &readfds); maxfd = MAX(maxfd, local_sockets[i].fd); } @@ -28,7 +28,7 @@ rc = select(maxfd + 1, &readfds, NULL, NULL, &tv); if(rc < 0) { if(errno != EINTR) { -@@ -680,6 +687,9 @@ main(int argc, char **argv) +@@ -684,6 +691,9 @@ main(int argc, char **argv) i++; } @@ -48,8 +48,8 @@ +echo "#define BABELD_VERSION \"$version-ubus-mod\"" --- a/configuration.c +++ b/configuration.c -@@ -41,6 +41,8 @@ THE SOFTWARE. - #include "kernel.h" +@@ -42,6 +42,8 @@ THE SOFTWARE. + #include "hmac.h" #include "configuration.h" +#include "ubus.h" @@ -57,7 +57,7 @@ static struct filter *input_filters = NULL; static struct filter *output_filters = NULL; static struct filter *redistribute_filters = NULL; -@@ -849,7 +851,8 @@ parse_option(int c, gnc_t gnc, void *clo +@@ -1036,7 +1038,8 @@ parse_option(int c, gnc_t gnc, void *clo strcmp(token, "daemonise") == 0 || strcmp(token, "skip-kernel-setup") == 0 || strcmp(token, "ipv6-subtrees") == 0 || @@ -67,7 +67,7 @@ int b; c = getbool(c, &b, gnc, closure); if(c < -1) -@@ -867,6 +870,8 @@ parse_option(int c, gnc_t gnc, void *clo +@@ -1054,6 +1057,8 @@ parse_option(int c, gnc_t gnc, void *clo has_ipv6_subtrees = b; else if(strcmp(token, "reflect-kernel-metric") == 0) reflect_kernel_metric = b; @@ -116,16 +116,17 @@ static void --- a/Makefile +++ b/Makefile -@@ -10,10 +10,10 @@ CFLAGS = $(CDEBUGFLAGS) $(DEFINES) $(EXT - LDLIBS = -lrt +@@ -11,11 +11,11 @@ LDLIBS = -lrt SRCS = babeld.c net.c kernel.c util.c interface.c source.c neighbour.c \ -- route.c xroute.c message.c resend.c configuration.c local.c -+ route.c xroute.c message.c resend.c configuration.c local.c ubus.c + route.c xroute.c message.c resend.c configuration.c local.c \ +- hmac.c rfc6234/sha224-256.c BLAKE2/ref/blake2s-ref.c ++ hmac.c ubus.c rfc6234/sha224-256.c BLAKE2/ref/blake2s-ref.c OBJS = babeld.o net.o kernel.o util.o interface.o source.o neighbour.o \ -- route.o xroute.o message.o resend.o configuration.o local.o -+ route.o xroute.o message.o resend.o configuration.o local.o ubus.o + route.o xroute.o message.o resend.o configuration.o local.o \ +- hmac.o rfc6234/sha224-256.o BLAKE2/ref/blake2s-ref.o ++ hmac.o ubus.o rfc6234/sha224-256.o BLAKE2/ref/blake2s-ref.o babeld: $(OBJS) $(CC) $(CFLAGS) $(LDFLAGS) -o babeld $(OBJS) $(LDLIBS) diff --git a/babeld/src/ubus.c b/babeld/src/ubus.c index c1a4945..dec71a1 100644 --- a/babeld/src/ubus.c +++ b/babeld/src/ubus.c @@ -2,10 +2,10 @@ #include <stdlib.h> #include <sys/select.h> -#include <libubus.h> #include <libubox/blob.h> #include <libubox/blobmsg.h> #include <libubox/list.h> +#include <libubus.h> #include <arpa/inet.h> #include <net/if.h> @@ -54,6 +54,95 @@ struct neighbour_list_entry { struct neighbour *neighbour; }; +// Definition of interface function enums (to be used with ubox's blobmsg +// helpers). +enum { INTERFACE_IFNAME, __INTERFACE_MAX }; + +// Definition of interface parsing (to be used with ubox's blobmsg helpers). +static const struct blobmsg_policy interface_policy[__INTERFACE_MAX] = { + [INTERFACE_IFNAME] = {"ifname", BLOBMSG_TYPE_STRING}, +}; + +// Definition of filter function enums (to be used with ubox's blobmsg +// helpers). +enum { FILTER_IFNAME, FILTER_TYPE, FILTER_METRIC, __FILTER_MAX }; + +// Definition of filter parsing (to be used with ubox's blobmsg helpers). +static const struct blobmsg_policy filter_policy[__FILTER_MAX] = { + [FILTER_IFNAME] = {"ifname", BLOBMSG_TYPE_STRING}, + [FILTER_TYPE] = {"type", BLOBMSG_TYPE_INT32}, + [FILTER_METRIC] = {"metric", BLOBMSG_TYPE_INT32}, +}; + +// Adds a filter (ubus equivalent to "filter"-function). +static int babeld_ubus_add_filter(struct ubus_context *ctx_local, + struct ubus_object *obj, + struct ubus_request_data *req, + const char *method, struct blob_attr *msg) { + struct blob_attr *tb[__FILTER_MAX]; + struct blob_buf b = {0}; + struct filter *filter = NULL; + char *ifname; + int metric, type; + + blobmsg_parse(filter_policy, __FILTER_MAX, tb, blob_data(msg), blob_len(msg)); + + if (!tb[FILTER_IFNAME]) + return UBUS_STATUS_INVALID_ARGUMENT; + + if (!tb[FILTER_TYPE]) + return UBUS_STATUS_INVALID_ARGUMENT; + + type = blobmsg_get_u32(tb[FILTER_TYPE]); + + if (tb[FILTER_METRIC]) + metric = blobmsg_get_u32(tb[FILTER_METRIC]); + + filter = calloc(1, sizeof(struct filter)); + if (filter == NULL) + return UBUS_STATUS_UNKNOWN_ERROR; + + filter->af = AF_INET6; + filter->proto = 0; + filter->plen_le = 128; + filter->src_plen_le = 128; + filter->action.add_metric = metric; + + ifname = blobmsg_get_string(tb[FILTER_IFNAME]); + filter->ifname = strdup(ifname); + filter->ifindex = if_nametoindex(filter->ifname); + + add_filter(filter, type); + + return UBUS_STATUS_OK; +} + +// Adds an inteface (ubus equivalent to "interface"-function). +static int babeld_ubus_add_interface(struct ubus_context *ctx_local, + struct ubus_object *obj, + struct ubus_request_data *req, + const char *method, + struct blob_attr *msg) { + struct blob_attr *tb[__INTERFACE_MAX]; + struct blob_buf b = {0}; + struct interface *ifp = NULL; + char *ifname; + + blobmsg_parse(interface_policy, __INTERFACE_MAX, tb, blob_data(msg), + blob_len(msg)); + + if (!tb[INTERFACE_IFNAME]) + return UBUS_STATUS_INVALID_ARGUMENT; + + ifname = blobmsg_get_string(tb[INTERFACE_IFNAME]); + + ifp = add_interface(ifname, NULL); + if (ifp == NULL) + return UBUS_STATUS_UNKNOWN_ERROR; + + return UBUS_STATUS_OK; +} + // Sends a babel info message on ubus socket. static int babeld_ubus_babeld_info(struct ubus_context *ctx_local, struct ubus_object *obj, @@ -74,6 +163,8 @@ static int babeld_ubus_babeld_info(struct ubus_context *ctx_local, if (ret) fprintf(stderr, "Failed to send reply: %s\n", ubus_strerror(ret)); + blob_buf_free(&b); + return ret; } @@ -103,6 +194,8 @@ static int babeld_ubus_get_xroutes(struct ubus_context *ctx_local, LIST_HEAD(xroute_ipv4_list); LIST_HEAD(xroute_ipv6_list); + blob_buf_init(&b, 0); + xroutes = xroute_stream(); if (xroutes) { while (1) { @@ -123,7 +216,6 @@ static int babeld_ubus_get_xroutes(struct ubus_context *ctx_local, xroute_stream_done(xroutes); } - blob_buf_init(&b, 0); ipv4 = blobmsg_open_table(&b, "IPv4"); list_for_each_entry_safe(cur, tmp, &xroute_ipv4_list, list) { babeld_add_xroute_buf(cur->xroute, &b); @@ -144,6 +236,8 @@ static int babeld_ubus_get_xroutes(struct ubus_context *ctx_local, if (ret) fprintf(stderr, "Failed to send reply: %s\n", ubus_strerror(ret)); + blob_buf_free(&b); + return ret; } @@ -226,7 +320,6 @@ static int babeld_ubus_get_routes(struct ubus_context *ctx_local, route_stream_done(routes); } - blob_buf_init(&b, 0); ipv4 = blobmsg_open_table(&b, "IPv4"); list_for_each_entry_safe(cur, tmp, &route_ipv4_list, list) { babeld_add_route_buf(cur->route, &b); @@ -247,6 +340,8 @@ static int babeld_ubus_get_routes(struct ubus_context *ctx_local, if (ret) fprintf(stderr, "Failed to send reply: %s\n", ubus_strerror(ret)); + blob_buf_free(&b); + return ret; } @@ -295,8 +390,6 @@ static int babeld_ubus_get_neighbours(struct ubus_context *ctx_local, } } - blob_buf_init(&b, 0); - ipv4 = blobmsg_open_table(&b, "IPv4"); list_for_each_entry_safe(cur, tmp, &neighbour_ipv4_list, list) { babeld_add_neighbour_buf(cur->neighbour, &b); @@ -317,11 +410,15 @@ static int babeld_ubus_get_neighbours(struct ubus_context *ctx_local, if (ret) fprintf(stderr, "Failed to send reply: %s\n", ubus_strerror(ret)); + blob_buf_free(&b); + return ret; } // List of functions we expose via the ubus bus. static const struct ubus_method babeld_methods[] = { + UBUS_METHOD("add_interface", babeld_ubus_add_interface, interface_policy), + UBUS_METHOD("add_filter", babeld_ubus_add_filter, filter_policy), UBUS_METHOD_NOARG("get_info", babeld_ubus_babeld_info), UBUS_METHOD_NOARG("get_xroutes", babeld_ubus_get_xroutes), UBUS_METHOD_NOARG("get_routes", babeld_ubus_get_routes), @@ -383,6 +480,7 @@ void ubus_notify_route(struct babel_route *route, int kind) { babeld_add_route_buf(route, &b); snprintf(method, sizeof(method), "route.%s", local_kind(kind)); ubus_notify(shared_ctx, &babeld_object, method, b.head, -1); + blob_buf_free(&b); } void ubus_notify_xroute(struct xroute *xroute, int kind) { @@ -403,6 +501,7 @@ void ubus_notify_xroute(struct xroute *xroute, int kind) { babeld_add_xroute_buf(xroute, &b); snprintf(method, sizeof(method), "xroute.%s", local_kind(kind)); ubus_notify(shared_ctx, &babeld_object, method, b.head, -1); + blob_buf_free(&b); } void ubus_notify_neighbour(struct neighbour *neigh, int kind) { @@ -422,6 +521,7 @@ void ubus_notify_neighbour(struct neighbour *neigh, int kind) { babeld_add_neighbour_buf(neigh, &b); snprintf(method, sizeof(method), "neigh.%s", local_kind(kind)); ubus_notify(shared_ctx, &babeld_object, method, b.head, -1); + blob_buf_free(&b); } void babeld_ubus_receive(fd_set *readfds) { diff --git a/babeld/src/ubus.h b/babeld/src/ubus.h index 1dd5e6e..08aeb52 100644 --- a/babeld/src/ubus.h +++ b/babeld/src/ubus.h @@ -2,6 +2,13 @@ IPC integration of babeld with OpenWrt. The ubus interface offers following functions: + - add_filter '{"ifname":"eth0", "type":0, "metric":5000}' + type: + 0: FILTER_TYPE_INPUT + 1: FILTER_TYPE_OUTPUT + 2: FILTER_TYPE_REDISTRIBUTE + 3: FILTER_TYPE_INSTALL + - add_interface '{"ifname":"eth0"}' - get_info - get_neighbours - get_xroutes diff --git a/bird2/Makefile b/bird2/Makefile index 9fee377..f4c146e 100644 --- a/bird2/Makefile +++ b/bird2/Makefile @@ -7,12 +7,12 @@ include $(TOPDIR)/rules.mk PKG_NAME:=bird2 -PKG_VERSION:=2.0.8 -PKG_RELEASE:=2 +PKG_VERSION:=2.0.10 +PKG_RELEASE:=1 PKG_SOURCE:=bird-$(PKG_VERSION).tar.gz PKG_SOURCE_URL:=ftp://bird.network.cz/pub/bird -PKG_HASH:=19d2de83ee25a307b9e5b9e58797dd68766d439bcee33e3ac617ed502370e7f6 +PKG_HASH:=7ed341ddd8dc87fa9736586b3515447a8436fec442d65f4022155ab9de1ffd5a PKG_MAINTAINER:=Toke Høiland-Jørgensen <toke@toke.dk> PKG_LICENSE:=GPL-2.0-or-later diff --git a/cjdns/Makefile b/cjdns/Makefile index 23e655e..6bdcd83 100644 --- a/cjdns/Makefile +++ b/cjdns/Makefile @@ -17,12 +17,12 @@ include $(TOPDIR)/rules.mk PKG_NAME:=cjdns -PKG_VERSION:=v21 -PKG_RELEASE:=1 +PKG_VERSION:=v21.1 +PKG_RELEASE:=4 PKG_SOURCE:=$(PKG_NAME)-$(PKG_VERSION).tar.gz PKG_SOURCE_URL:=https://codeload.github.com/cjdelisle/cjdns/tar.gz/$(PKG_NAME)-$(PKG_VERSION)? -PKG_HASH:=6dfb1fe18c9689324f36c8d33e660972aac5af4579fcaa9c4730179bc8d67c69 +PKG_HASH:=a6158ce7847159aa44e86f74ccc7b6ded6910a230ed8f3830db53cda5838f0b0 PKG_BUILD_DIR:=$(BUILD_DIR)/$(PKG_NAME)-$(PKG_NAME)-$(PKG_VERSION) PKG_MAINTAINER:=William Fleurant <meshnet@protonmail.com> @@ -81,7 +81,7 @@ define Build/Compile CC="$(TARGET_CC)" \ AR="$(TARGET_AR)" \ RANLIB="$(TARGET_RANLIB)" \ - CFLAGS="$(TARGET_CFLAGS) -U_FORTIFY_SOURCE" \ + CFLAGS="$(TARGET_CFLAGS) -U_FORTIFY_SOURCE -Wno-error=array-bounds -Wno-error=stringop-overflow" \ LDFLAGS="$(TARGET_LDFLAGS)" \ SYSTEM="linux" \ TARGET_ARCH="$(CONFIG_ARCH)" \ diff --git a/cjdns/files/cjdns.defaults b/cjdns/files/cjdns.defaults index f2baf6d..b1745f1 100644 --- a/cjdns/files/cjdns.defaults +++ b/cjdns/files/cjdns.defaults @@ -23,17 +23,10 @@ EOF fi # enable auto-peering on ethernet interface lan, if existing - uci get network.lan | grep interface >/dev/null 2>&1 - if [ $? -eq 0 ]; then - uci get network.lan.type | grep bridge >/dev/null 2>&1 - if [ $? -eq 0 ]; then - # most routers will set up an ethernet bridge for the lan - ifname="br-lan" - else - # docker containers don't have permission to create bridges by default, - # so we bind to the underlying interface instead (likely eth0) - ifname=`uci get network.lan.ifname` - fi + ifname=$(uci -q get network.lan.device || \ + ([ "$(uci -q get network.lan.type)" == "bridge" ] && echo br-lan) || \ + uci -q get network.lan.ifname) + if [ -n "$ifname" ]; then uci -q batch <<-EOF >/dev/null add cjdns eth_interface set cjdns.@eth_interface[-1].beacon=2 @@ -46,7 +39,7 @@ EOF # create the network interface uci -q batch <<-EOF >/dev/null set network.cjdns=interface - set network.cjdns.ifname=tuncjdns + set network.cjdns.device=tuncjdns set network.cjdns.proto=none EOF diff --git a/cjdns/lua/cjdns/uci.lua b/cjdns/lua/cjdns/uci.lua index f4716b7..d6b6633 100644 --- a/cjdns/lua/cjdns/uci.lua +++ b/cjdns/lua/cjdns/uci.lua @@ -53,6 +53,10 @@ function UCI.get() obj.router.interface.tunDevice = config.tun_device end + cursor:foreach("cjdns", "supernodes", function(supernodes) + table.insert(obj.router.supernodes, supernodes.public_key) + end) + for i,section in pairs(obj.security) do if type(section.seccomp) == "number" then obj.security[i].seccomp = tonumber(config.seccomp) diff --git a/cjdns/patches/001-five-mins-builder-zonk.patch b/cjdns/patches/001-five-mins-builder-zonk.patch index 3128fb8..c53c62f 100644 --- a/cjdns/patches/001-five-mins-builder-zonk.patch +++ b/cjdns/patches/001-five-mins-builder-zonk.patch @@ -1,13 +1,13 @@ --- a/node_build/builder.js +++ b/node_build/builder.js -@@ -215,8 +215,8 @@ var execJs = function (js, builder, file - js = qs.join("'"); +@@ -277,8 +277,8 @@ const execJs = function (js, ctx, file, + js = '"use strict";' + qs.join("'"); - var to = setTimeout(function () { + const to = setTimeout(function () { - throw new Error("Inline JS did not return after 120 seconds [" + js + "]"); - }, 120000); + throw new Error("Inline JS did not return after 5 minutes [" + js + "]"); + }, 300000); - var REQUIRE = function (str) { - if (typeof(str) !== 'string') { + nThen(function (waitFor) { + diff --git a/cjdns/patches/010-musl-12x.patch b/cjdns/patches/010-musl-12x.patch deleted file mode 100644 index d82a144..0000000 --- a/cjdns/patches/010-musl-12x.patch +++ /dev/null @@ -1,11 +0,0 @@ ---- a/memory/Allocator.c -+++ b/memory/Allocator.c -@@ -57,7 +57,7 @@ static void unroll(struct Allocator_pvt* - struct Allocator_Allocation_pvt* allocation = context->allocations; - while (allocation && includeAllocations) { - writeUnroller(&childUnroller); -- fprintf(stderr, "%s:%ld [%lu] bytes at [0x%lx]\n", -+ fprintf(stderr, "%s:%tu [%tu] bytes at [0x%lx]\n", - allocation->fileName, - allocation->lineNum, - allocation->pub.size, diff --git a/cjdns/patches/020-prefer-python2.patch b/cjdns/patches/020-prefer-python2.patch new file mode 100644 index 0000000..5bb8624 --- /dev/null +++ b/cjdns/patches/020-prefer-python2.patch @@ -0,0 +1,11 @@ +--- a/node_build/FindPython.js ++++ b/node_build/FindPython.js +@@ -23,7 +23,7 @@ var Fs = require('fs'); + // de-prioritize because the testing script accepts ANY python3 version + // (as of this writing, we don't know what python3 versions actually work) + // whereas we know that python2.7 is the only working python2 version. +-var PYTHONS = ["python3.7", "python3", "python2.7", "python2", "python"]; ++var PYTHONS = ["python2", "python2.7", "python3.7", "python3.8", "python3.9", "python3"] + + var SCRIPT = [ + 'import sys', diff --git a/luci-app-cjdns/Makefile b/luci-app-cjdns/Makefile index 9396528..0b6485a 100644 --- a/luci-app-cjdns/Makefile +++ b/luci-app-cjdns/Makefile @@ -18,7 +18,7 @@ include $(TOPDIR)/rules.mk PKG_NAME:=luci-app-cjdns PKG_VERSION:=1.3 -PKG_RELEASE:=8 +PKG_RELEASE:=9 PKG_MAINTAINER:=William Fleurant <meshnet@protonmail.com> PKG_LICENSE:=GPL-3.0-or-later diff --git a/luci-app-cjdns/luasrc/model/cbi/cjdns/peering.lua b/luci-app-cjdns/luasrc/model/cbi/cjdns/peering.lua index 2b1fc1b..3526afe 100644 --- a/luci-app-cjdns/luasrc/model/cbi/cjdns/peering.lua +++ b/luci-app-cjdns/luasrc/model/cbi/cjdns/peering.lua @@ -70,4 +70,13 @@ eth_peers:option(Value, "address", translate("MAC address")).datatype = "macaddr eth_peers:option(Value, "public_key", translate("Public key")) eth_peers:option(Value, "password", translate("Password")) +-- Supernodes +supernodes = m:section(TypedSection, "supernodes", translate("List of Supernodes"), + translate("If none are specified they'll be taken from your peers")) +supernodes.anonymous = true +supernodes.addremove = true +supernodes.template = "cbi/tblsection" + +supernodes:option(Value, "public_key", translate("Public Key")).size = 55 + return m diff --git a/mcproxy/Makefile b/mcproxy/Makefile index ccc4457..153e17a 100644 --- a/mcproxy/Makefile +++ b/mcproxy/Makefile @@ -10,10 +10,11 @@ include $(TOPDIR)/rules.mk PKG_NAME:=mcproxy PKG_SOURCE_VERSION:=93b5ace42268160ebbfff4c61818fb15fa2d9b99 PKG_VERSION:=2017-08-24-$(PKG_SOURCE_VERSION) -PKG_RELEASE:=2 +PKG_RELEASE:=3 PKG_SOURCE_PROTO:=git PKG_SOURCE_URL:=https://github.com/mcproxy/mcproxy.git +PKG_MIRROR_HASH:=5779a78dedaef491825ada632fe6d8282067025dede41d0eede5c441893a2994 PKG_MAINTAINER:=Steven Barth <cyrus@openwrt.org> PKG_LICENSE:=GPL-2.0+ diff --git a/mcproxy/patches/0003-add-sourcefilter.patch b/mcproxy/patches/0003-add-sourcefilter.patch index 26dc98d..a47fcae 100644 --- a/mcproxy/patches/0003-add-sourcefilter.patch +++ b/mcproxy/patches/0003-add-sourcefilter.patch @@ -1,7 +1,5 @@ -Index: mcproxy-2017-08-24-93b5ace42268160ebbfff4c61818fb15fa2d9b99/mcproxy/src/utils/mc_socket.cpp -=================================================================== ---- mcproxy-2017-08-24-93b5ace42268160ebbfff4c61818fb15fa2d9b99.orig/mcproxy/src/utils/mc_socket.cpp -+++ mcproxy-2017-08-24-93b5ace42268160ebbfff4c61818fb15fa2d9b99/mcproxy/src/utils/mc_socket.cpp +--- a/mcproxy/src/utils/mc_socket.cpp ++++ b/mcproxy/src/utils/mc_socket.cpp @@ -37,6 +37,10 @@ #include <numeric> #include <unistd.h> @@ -13,10 +11,8 @@ Index: mcproxy-2017-08-24-93b5ace42268160ebbfff4c61818fb15fa2d9b99/mcproxy/src/u std::string ipAddrResolver(std::string ipAddr) { std::string str[][2] = { -Index: mcproxy-2017-08-24-93b5ace42268160ebbfff4c61818fb15fa2d9b99/mcproxy/src/utils/sourcefilter.cpp -=================================================================== --- /dev/null -+++ mcproxy-2017-08-24-93b5ace42268160ebbfff4c61818fb15fa2d9b99/mcproxy/src/utils/sourcefilter.cpp ++++ b/mcproxy/src/utils/sourcefilter.cpp @@ -0,0 +1,165 @@ +/* Get source filter. Linux version. + Copyright (C) 2004-2014 Free Software Foundation, Inc. diff --git a/mcproxy/patches/0006-block-ingress.patch b/mcproxy/patches/0006-block-ingress.patch index 5998741..730c6ce 100644 --- a/mcproxy/patches/0006-block-ingress.patch +++ b/mcproxy/patches/0006-block-ingress.patch @@ -1,7 +1,5 @@ -Index: mcproxy-2017-08-24-93b5ace42268160ebbfff4c61818fb15fa2d9b99/mcproxy/src/proxy/proxy_instance.cpp -=================================================================== ---- mcproxy-2017-08-24-93b5ace42268160ebbfff4c61818fb15fa2d9b99.orig/mcproxy/src/proxy/proxy_instance.cpp -+++ mcproxy-2017-08-24-93b5ace42268160ebbfff4c61818fb15fa2d9b99/mcproxy/src/proxy/proxy_instance.cpp +--- a/mcproxy/src/proxy/proxy_instance.cpp ++++ b/mcproxy/src/proxy/proxy_instance.cpp @@ -171,6 +171,9 @@ void proxy_instance::worker_thread() HC_LOG_TRACE(""); while (m_running) { diff --git a/mesh11sd/Makefile b/mesh11sd/Makefile new file mode 100644 index 0000000..567e06d --- /dev/null +++ b/mesh11sd/Makefile @@ -0,0 +1,63 @@ +# SPDX-License-Identifier: GPL-2.0-only +# +# This is free software, licensed under the GNU General Public License v2. +# See /LICENSE for more information. +# Copyright (C) 2022 BlueWave Projects and Services <licence@blue-wave.net> +# + +include $(TOPDIR)/rules.mk + +PKG_NAME:=mesh11sd +PKG_VERSION:=1.2.0 +PKG_RELEASE:=$(AUTORELEASE) + +PKG_MAINTAINER:=Rob White <rob@blue-wave.net> +PKG_LICENSE:=GPL-2.0-or-later +PKG_LICENSE_FILES:=LICENSE + +PKG_SOURCE:=$(PKG_NAME)-$(PKG_VERSION).tar.gz +PKG_SOURCE_URL:=https://codeload.github.com/opennds/mesh11sd/tar.gz/v$(PKG_VERSION)? +PKG_HASH:=b719eaacf63eb3684d0cd6a026f4357a4f400f2339f5d5a6cf74ba3744fe30d8 +PKG_BUILD_DIR:=$(BUILD_DIR)/mesh11sd-$(PKG_VERSION) + +include $(INCLUDE_DIR)/package.mk + +define Package/mesh11sd + SUBMENU:=Captive Portals + SECTION:=net + CATEGORY:=Network + TITLE:=Dynamic 802.11s Mesh Configuration Daemon + PKGARCH:=all + URL:=https://github.com/opennds/mesh11sd +endef + +define Package/mesh11sd/description + Mesh11sd is a dynamic parameter configuration daemon for 802.11s mesh networks. + It was originally designed to leverage 802.11s mesh networking at Captive Portal venues. + This is the open source version and it enables easy and automated mesh network operation with multiple mesh nodes. + It allows all mesh parameters supported by the wireless driver to be set in the uci config file. + Settings take effect immediately without having to restart the wireless network. + Default settings give rapid and reliable layer 2 mesh convergence. + Without mesh11sd, many mesh parameters cannot be set in the uci wireless config file as the mesh interface must be up before the parameters can be set. + Some of those that are supported, would fail to be implemented when the network is (re)started resulting in errors or dropped nodes. + The mesh11sd daemon dynamically checks configured parameters and sets them as required. + This version does not require a Captive Portal to be running. +endef + +define Package/mesh11sd/install + $(INSTALL_DIR) $(1)/usr/sbin + $(INSTALL_DIR) $(1)/etc/config + $(INSTALL_DIR) $(1)/etc/init.d + $(INSTALL_BIN) $(PKG_BUILD_DIR)/src/mesh11sd $(1)/usr/sbin + $(INSTALL_CONF) $(PKG_BUILD_DIR)/linux_openwrt/mesh11sd/files/etc/config/mesh11sd $(1)/etc/config/ + $(INSTALL_BIN) $(PKG_BUILD_DIR)/linux_openwrt/mesh11sd/files/etc/init.d/mesh11sd $(1)/etc/init.d/ +endef + +define Package/mesh11sd/conffiles +/etc/config/mesh11sd +endef + +define Build/Compile +endef + +$(eval $(call BuildPackage,mesh11sd)) diff --git a/minimalist-pcproxy/Makefile b/minimalist-pcproxy/Makefile index 8b8cf24..b00fd1d 100644 --- a/minimalist-pcproxy/Makefile +++ b/minimalist-pcproxy/Makefile @@ -9,10 +9,11 @@ include $(TOPDIR)/rules.mk PKG_NAME:=minimalist-pcproxy PKG_SOURCE_VERSION:=2d6d1b0b0a3b79a9b4a9b0a7606a84600a967bcb PKG_VERSION:=2015-01-12-$(PKG_SOURCE_VERSION) -PKG_RELEASE:=1 +PKG_RELEASE:=2 PKG_SOURCE_PROTO:=git PKG_SOURCE_URL:=https://github.com/fingon/minimalist-pcproxy.git +PKG_MIRROR_HASH:=d3e872ee6207829ef142d22d591d203e4836f6aa150167411b542e8df4af4d53 PKG_MAINTAINER:=Markus Stenberg <fingon@iki.fi> PKG_LICENSE:=GPL-2.0 diff --git a/mrd6/Makefile b/mrd6/Makefile index 8cdd8d1..e8c006e 100644 --- a/mrd6/Makefile +++ b/mrd6/Makefile @@ -8,20 +8,20 @@ include $(TOPDIR)/rules.mk PKG_NAME:=mrd6 -PKG_SOURCE_VERSION:=c805eb33255dbc0b6647d463c6c67d1c9d3105a0 -PKG_VERSION:=2013-11-30-$(PKG_SOURCE_VERSION) -PKG_RELEASE:=2 +PKG_RELEASE:=$(AUTORELEASE) PKG_SOURCE_PROTO:=git PKG_SOURCE_URL:=https://github.com/hugosantos/mrd6.git -PKG_MAINTAINER:=Steven Barth <cyrus@openwrt.org> -PKG_LICENSE:=GPL-2.0+ +PKG_SOURCE_DATE:=2013-11-30 +PKG_SOURCE_VERSION:=c805eb33255dbc0b6647d463c6c67d1c9d3105a0 +PKG_MIRROR_HASH:=976243b967c18fcbf64d26158898245264c6d03d498826b104e6c92406a8f64f -PKG_SOURCE:=$(PKG_NAME)-$(PKG_VERSION).tar.bz2 -PKG_SOURCE_SUBDIR:=$(PKG_NAME)-$(PKG_VERSION) +PKG_MAINTAINER:=Steven Barth <cyrus@openwrt.org> +PKG_LICENSE:=GPL-2.0-or-later +PKG_LICENSE_FILES:=COPYING -PKG_BUILD_PARALLEL:=1 PKG_INSTALL:=1 +PKG_BUILD_PARALLEL:=1 include $(INCLUDE_DIR)/package.mk diff --git a/naywatch/Makefile b/naywatch/Makefile index 288f162..f79890f 100644 --- a/naywatch/Makefile +++ b/naywatch/Makefile @@ -23,7 +23,12 @@ define Package/naywatch endef define Package/naywatch/description -Reboots or triggers watchdog if no link local neighbor is available. +Reboots or triggers watchdog if no link-local neighbor is available. + +Important: +Be careful when you do a sysupgrade. Stop naywatch first, and make +sure procd took control again of the watchdog. +You can do this using 'ubus call system watchdog'. Status should be "running". endef define Package/naywatch/conffiles diff --git a/naywatch/files/naywatch.config b/naywatch/files/naywatch.config index 27147a6..b25e1f2 100644 --- a/naywatch/files/naywatch.config +++ b/naywatch/files/naywatch.config @@ -1,7 +1,7 @@ config naywatch general option check_interval '50' option watchdog_timeout '60' - option use_watchdog '1' + option use_watchdog '0' option save_logs '1' list interface 'lan' list interface 'wan' diff --git a/naywatch/files/naywatch.init b/naywatch/files/naywatch.init index ac39a99..82f53c6 100644 --- a/naywatch/files/naywatch.init +++ b/naywatch/files/naywatch.init @@ -1,5 +1,7 @@ #!/bin/sh /etc/rc.common +. /usr/share/libubox/jshn.sh + USE_PROCD=1 START=95 STOP=01 @@ -58,8 +60,30 @@ stop_service() { sync && wait } +watchdog_procd_runnig() { + watch=$(ubus call system watchdog) + json_load "$watch" + json_get_var watchdogstatus status + if [[ "$watchdogstatus" == "running" ]] ; then + echo "1" + return + fi + echo "0" +} + service_stopped() { log "Naywatch Stopped!" - log "Handover Watchdog to procd again:" - ubus call system watchdog '{"magicclose":true,"stop":false}' > /dev/null + log "Try to handover watchdog to procd again." + for i in 1 2 3 4 5 6 7 8 9 10 ; do + sleep 5 + ubus call system watchdog '{"stop":false}' > /dev/null + if [[ $(watchdog_procd_runnig) == "1" ]] ; then + break + fi + done + if [[ $(watchdog_procd_runnig) == "1" ]] ; then + log "Handover sucessfully!" + else + log "Handover to procd failed! Device can reboot!" + fi } diff --git a/naywatch/files/naywatch.sh b/naywatch/files/naywatch.sh index 8eea429..73f5ff0 100644 --- a/naywatch/files/naywatch.sh +++ b/naywatch/files/naywatch.sh @@ -14,6 +14,8 @@ shift INTERFACES="$*" ACTIVE=0 +NO_NEIGHBORS_COUNT=0 +MIN_KICK=5 log() { local msg="$1" @@ -67,36 +69,42 @@ reboot_now() { no_neighbors() { log "No Neighbors Available!" + NO_NEIGHBORS_COUNT=$(($NO_NEIGHBORS_COUNT+1)) + if [ $ACTIVE -eq 0 ]; then return 0 fi - if [ $SAVE_LOGS ]; then + if [ $SAVE_LOGS -eq 1 ]; then log "Saving Logs!" write_logs fi - if [ $USE_WATCHDOG -eq 0 ]; then - reboot_now + if [ $USE_WATCHDOG -eq 0 ] && [ $NO_NEIGHBORS_COUNT -gt $MIN_KICK ]; then + reboot_now 10 fi } log "Naywatch Started!" neighbors() { + if [ $ACTIVE -eq 0 ]; then + log "Naywatch Activated!" + fi ACTIVE=1 - if [ $USE_WATCHDOG ]; then + NO_NEIGHBORS_COUNT=0 + if [ $USE_WATCHDOG -eq 1 ]; then echo 1 >&3 fi } not_active() { - if [ $USE_WATCHDOG ]; then + if [ $USE_WATCHDOG -eq 1 ]; then echo 1 >&3 fi } -if [ $USE_WATCHDOG ]; then +if [ $USE_WATCHDOG -eq 1 ]; then activate_watchdog fi diff --git a/ohybridproxy/Makefile b/ohybridproxy/Makefile index 1932f6d..f8fb816 100644 --- a/ohybridproxy/Makefile +++ b/ohybridproxy/Makefile @@ -9,7 +9,7 @@ include $(TOPDIR)/rules.mk PKG_NAME:=ohybridproxy PKG_SOURCE_VERSION:=0dfef1eb5f067250a5f24a899536879ea4fdc4c5 PKG_SOURCE_DATE:=2020-05-22 -PKG_RELEASE:=2 +PKG_RELEASE:=3 PKG_SOURCE_PROTO:=git PKG_SOURCE_URL:=https://github.com/sbyx/ohybridproxy.git @@ -24,9 +24,6 @@ PKG_BUILD_PARALLEL:=1 include $(INCLUDE_DIR)/package.mk include $(INCLUDE_DIR)/cmake.mk -# Spammy debug builds for now -CMAKE_OPTIONS += -DL_LEVEL=7 - define Package/ohybridproxy SECTION:=net CATEGORY:=Network diff --git a/olsrd/Makefile b/olsrd/Makefile index c6d193e..a3fd113 100644 --- a/olsrd/Makefile +++ b/olsrd/Makefile @@ -34,7 +34,7 @@ endef define Package/olsrd $(call Package/olsrd/template) MENU:=1 - DEPENDS:=+libpthread + DEPENDS:=+libpthread +libubus endef define Package/olsrd/conffiles diff --git a/olsrd/files/olsrd.sh b/olsrd/files/olsrd.sh index d0fe5c1..cb52d19 100644 --- a/olsrd/files/olsrd.sh +++ b/olsrd/files/olsrd.sh @@ -624,6 +624,10 @@ olsrd_write_interface() { ifnames="$ifnames \"$IFNAME\"" ifsglobal="$ifsglobal $IFNAME" fi + elif [[ "$(ip -details link show dev $interface)" == *"wireguard"* ]]; then + # wireguard interface + ifnames="$ifnames \"$interface\"" + ifsglobal="$ifsglobal $interface" else log "$funcname() Warning: Interface '$interface' not found, skipped" fi diff --git a/olsrd/files/olsrd4.init b/olsrd/files/olsrd4.init index 28a84a6..62cb66d 100644 --- a/olsrd/files/olsrd4.init +++ b/olsrd/files/olsrd4.init @@ -15,10 +15,24 @@ wait_for_network() ubus -t 15 wait_for network.interface.$1 2>/dev/null } +wait_for_wireless() +{ + local count=0 + ubus -t 15 wait_for network.wireless 2>/dev/null + while [ $count -lt 30 ]; do + if [ "$(ubus call network.wireless status | jsonfilter -e '@[*]["pending"]' | grep true | wc -l)" == "0" ]; then + break + fi + count=$((count+1)) + sleep 1 + done +} + boot() { config_load network config_foreach wait_for_network interface + wait_for_wireless rc_procd start_service } diff --git a/olsrd/files/olsrd6.init b/olsrd/files/olsrd6.init index 8f9b91a..a20e967 100644 --- a/olsrd/files/olsrd6.init +++ b/olsrd/files/olsrd6.init @@ -15,10 +15,24 @@ wait_for_network() ubus -t 15 wait_for network.interface.$1 2>/dev/null } +wait_for_wireless() +{ + local count=0 + ubus -t 15 wait_for network.wireless 2>/dev/null + while [ $count -lt 30 ]; do + if [ "$(ubus call network.wireless status | jsonfilter -e '@[*]["pending"]' | grep true | wc -l)" == "0" ]; then + break + fi + count=$((count+1)) + sleep 1 + done +} + boot() { config_load network config_foreach wait_for_network interface + wait_for_wireless rc_procd start_service } diff --git a/olsrd/patches/100-rename-avl-to-olsrd_avl.patch b/olsrd/patches/100-rename-avl-to-olsrd_avl.patch new file mode 100644 index 0000000..c1d9743 --- /dev/null +++ b/olsrd/patches/100-rename-avl-to-olsrd_avl.patch @@ -0,0 +1,3377 @@ +From 4b91b102eb6edb63472728dd3545e3dff800a5a0 Mon Sep 17 00:00:00 2001 +From: Nick Hainke <vincent@systemli.org> +Date: Sat, 15 Jan 2022 16:13:24 +0100 +Subject: [PATCH] rename avl to olsrd_avl + +--- + lib/nameservice/src/nameservice.c | 4 +- + lib/netjson/src/olsrd_netjson.c | 12 +- + lib/netjson/src/olsrd_netjson_helpers.c | 74 +++++----- + lib/netjson/src/olsrd_netjson_helpers.h | 18 +-- + src/common/{avl.c => olsrd_avl.c} | 184 ++++++++++++------------ + src/common/{avl.h => olsrd_avl.h} | 90 ++++++------ + src/duplicate_set.c | 18 +-- + src/duplicate_set.h | 12 +- + src/gateway.c | 18 +-- + src/gateway.h | 16 +-- + src/kernel_tunnel.h | 4 +- + src/linux/kernel_tunnel.c | 12 +- + src/lq_packet.c | 6 +- + src/lq_plugin.c | 14 +- + src/lq_plugin.h | 14 +- + src/olsr.c | 12 +- + src/olsr_spf.c | 36 ++--- + src/process_routes.c | 22 +-- + src/routing_table.c | 56 ++++---- + src/routing_table.h | 36 ++--- + src/scheduler.c | 30 ++-- + src/tc_set.c | 30 ++-- + src/tc_set.h | 38 ++--- + 24 files changed, 390 insertions(+), 390 deletions(-) + rename src/common/{avl.c => olsrd_avl.c} (67%) + rename src/common/{avl.h => olsrd_avl.h} (58%) +--- a/lib/nameservice/src/nameservice.c ++++ b/lib/nameservice/src/nameservice.c +@@ -1621,13 +1621,13 @@ void + lookup_defhna_latlon(union olsr_ip_addr *ip) + { + struct rt_entry *rt; +- struct avl_node *rt_tree_node; ++ struct olsrd_avl_node *rt_tree_node; + struct olsr_ip_prefix prefix; + + memset(ip, 0, sizeof(*ip)); + memset(&prefix, 0, sizeof(prefix)); + +- if (NULL != (rt_tree_node = avl_find(&routingtree, &prefix))) { ++ if (NULL != (rt_tree_node = olsrd_avl_find(&routingtree, &prefix))) { + rt = rt_tree2rt(rt_tree_node); + *ip = rt->rt_best->rtp_nexthop.gateway; + } +--- a/lib/netjson/src/olsrd_netjson.c ++++ b/lib/netjson/src/olsrd_netjson.c +@@ -52,7 +52,7 @@ + #include "info/info_types.h" + #include "info/http_headers.h" + #include "info/json_helpers.h" +-#include "common/avl.h" ++#include "common/olsrd_avl.h" + #include "olsr.h" + #include "builddata.h" + #include "routing_table.h" +@@ -161,7 +161,7 @@ void ipc_print_network_routes(struct aut + } + + void ipc_print_network_graph(struct autobuf *abuf) { +- struct avl_tree nodes; ++ struct olsrd_avl_tree nodes; + struct mid_entry mid_self; + struct node_entry * node_self; + struct tc_entry * tc; +@@ -169,7 +169,7 @@ void ipc_print_network_graph(struct auto + struct neighbor_entry * neighbor; + int idx; + +- avl_init(&nodes, (olsr_cnf->ip_version == AF_INET) ? avl_comp_ipv4 : avl_comp_ipv6); ++ olsrd_avl_init(&nodes, (olsr_cnf->ip_version == AF_INET) ? olsrd_avl_comp_ipv4 : olsrd_avl_comp_ipv6); + + /* mandatory */ + abuf_json_string(&json_session, abuf, "type", "NetworkGraph"); +@@ -226,8 +226,8 @@ void ipc_print_network_graph(struct auto + + abuf_json_mark_object(&json_session, true, true, abuf, "nodes"); + while (nodes.count > 0) { +- struct avl_node *node = avl_walk_first(&nodes); +- struct node_entry *node_entry = avlnode2node(node); ++ struct olsrd_avl_node *node = olsrd_avl_walk_first(&nodes); ++ struct node_entry *node_entry = olsrd_avlnode2node(node); + + if (!node_entry->isAlias) { + abuf_json_mark_array_entry(&json_session, true, abuf); +@@ -265,7 +265,7 @@ void ipc_print_network_graph(struct auto + netjson_cleanup_mid_self(node_self); + } + +- avl_delete(&nodes, node); ++ olsrd_avl_delete(&nodes, node); + free(node); + } + abuf_json_mark_object(&json_session, false, true, abuf, NULL); +--- a/lib/netjson/src/olsrd_netjson_helpers.c ++++ b/lib/netjson/src/olsrd_netjson_helpers.c +@@ -57,7 +57,7 @@ struct node_entry * netjson_constructMid + + node_self = olsr_malloc(sizeof(struct node_entry), "netjson NetworkGraph node - MID - self"); + memset(node_self, 0, sizeof(*node_self)); +- node_self->avl.key = &olsr_cnf->main_addr; ++ node_self->olsrd_avl.key = &olsr_cnf->main_addr; + node_self->isAlias = false; + node_self->mid = mid; + +@@ -93,7 +93,7 @@ struct node_entry * netjson_constructMid + + node_self_alias = olsr_malloc(sizeof(struct node_entry), "netjson NetworkGraph node - MID - self alias"); + memset(node_self_alias, 0, sizeof(*node_self_alias)); +- node_self_alias->avl.key = addr; ++ node_self_alias->olsrd_avl.key = addr; + node_self_alias->isAlias = true; + node_self_alias->mid = mid; + +@@ -112,7 +112,7 @@ struct node_entry * netjson_constructMid + } + + void netjson_cleanup_mid_self(struct node_entry *node_entry) { +- if (node_entry->avl.key != &olsr_cnf->main_addr) { ++ if (node_entry->olsrd_avl.key != &olsr_cnf->main_addr) { + return; + } + +@@ -123,21 +123,21 @@ void netjson_cleanup_mid_self(struct nod + } + } + +-void netjson_midIntoNodesTree(struct avl_tree *nodes, struct mid_entry *mid) { +- struct avl_node *avlnode; ++void netjson_midIntoNodesTree(struct olsrd_avl_tree *nodes, struct mid_entry *mid) { ++ struct olsrd_avl_node *olsrd_avlnode; + struct node_entry *node; + struct mid_address *alias; + +- avlnode = avl_find(nodes, &mid->main_addr); +- if (!avlnode) { ++ olsrd_avlnode = olsrd_avl_find(nodes, &mid->main_addr); ++ if (!olsrd_avlnode) { + /* the IP address is not yet known */ + + node = olsr_malloc(sizeof(struct node_entry), "netjson NetworkGraph node - MID - main"); + memset(node, 0, sizeof(*node)); +- node->avl.key = &mid->main_addr; ++ node->olsrd_avl.key = &mid->main_addr; + node->isAlias = false; + node->mid = mid; +- if (avl_insert(nodes, &node->avl, AVL_DUP_NO) == -1) { ++ if (olsrd_avl_insert(nodes, &node->olsrd_avl, OLSRD_AVL_DUP_NO) == -1) { + /* duplicate */ + free(node); + } +@@ -145,16 +145,16 @@ void netjson_midIntoNodesTree(struct avl + + alias = mid->aliases; + while (alias) { +- avlnode = avl_find(nodes, &alias->alias); +- if (!avlnode) { ++ olsrd_avlnode = olsrd_avl_find(nodes, &alias->alias); ++ if (!olsrd_avlnode) { + /* the IP address is not yet known */ + + node = olsr_malloc(sizeof(struct node_entry), "netjson NetworkGraph node - MID - alias"); + memset(node, 0, sizeof(*node)); +- node->avl.key = &alias->alias; ++ node->olsrd_avl.key = &alias->alias; + node->isAlias = true; + node->mid = mid; +- if (avl_insert(nodes, &node->avl, AVL_DUP_NO) == -1) { ++ if (olsrd_avl_insert(nodes, &node->olsrd_avl, OLSRD_AVL_DUP_NO) == -1) { + /* duplicate */ + free(node); + } +@@ -164,12 +164,12 @@ void netjson_midIntoNodesTree(struct avl + } + } + +-void netjson_tcIntoNodesTree(struct avl_tree *nodes, struct tc_entry *tc) { +- struct avl_node *avlnode; ++void netjson_tcIntoNodesTree(struct olsrd_avl_tree *nodes, struct tc_entry *tc) { ++ struct olsrd_avl_node *olsrd_avlnode; + struct node_entry *node; + +- avlnode = avl_find(nodes, &tc->addr); +- if (avlnode) { ++ olsrd_avlnode = olsrd_avl_find(nodes, &tc->addr); ++ if (olsrd_avlnode) { + /* the IP address is already known */ + return; + } +@@ -178,21 +178,21 @@ void netjson_tcIntoNodesTree(struct avl_ + + node = olsr_malloc(sizeof(struct node_entry), "netjson NetworkGraph node - TC - main"); + memset(node, 0, sizeof(*node)); +- node->avl.key = &tc->addr; ++ node->olsrd_avl.key = &tc->addr; + node->isAlias = false; + node->tc = tc; +- if (avl_insert(nodes, &node->avl, AVL_DUP_NO) == -1) { ++ if (olsrd_avl_insert(nodes, &node->olsrd_avl, OLSRD_AVL_DUP_NO) == -1) { + /* duplicate */ + free(node); + } + } + +-void netjson_tcEdgeIntoNodesTree(struct avl_tree *nodes, struct tc_edge_entry *tc_edge) { +- struct avl_node *avlnode; ++void netjson_tcEdgeIntoNodesTree(struct olsrd_avl_tree *nodes, struct tc_edge_entry *tc_edge) { ++ struct olsrd_avl_node *olsrd_avlnode; + struct node_entry *node; + +- avlnode = avl_find(nodes, &tc_edge->T_dest_addr); +- if (avlnode) { ++ olsrd_avlnode = olsrd_avl_find(nodes, &tc_edge->T_dest_addr); ++ if (olsrd_avlnode) { + /* the IP address is already known */ + return; + } +@@ -201,21 +201,21 @@ void netjson_tcEdgeIntoNodesTree(struct + + node = olsr_malloc(sizeof(struct node_entry), "netjson NetworkGraph node - TC - main"); + memset(node, 0, sizeof(*node)); +- node->avl.key = &tc_edge->T_dest_addr; ++ node->olsrd_avl.key = &tc_edge->T_dest_addr; + node->isAlias = false; + node->tc_edge = tc_edge; +- if (avl_insert(nodes, &node->avl, AVL_DUP_NO) == -1) { ++ if (olsrd_avl_insert(nodes, &node->olsrd_avl, OLSRD_AVL_DUP_NO) == -1) { + /* duplicate */ + free(node); + } + } + +-void netjson_linkIntoNodesTree(struct avl_tree *nodes, struct link_entry *link, union olsr_ip_addr *addr) { +- struct avl_node *avlnode; ++void netjson_linkIntoNodesTree(struct olsrd_avl_tree *nodes, struct link_entry *link, union olsr_ip_addr *addr) { ++ struct olsrd_avl_node *olsrd_avlnode; + struct node_entry *node; + +- avlnode = avl_find(nodes, addr); +- if (avlnode) { ++ olsrd_avlnode = olsrd_avl_find(nodes, addr); ++ if (olsrd_avlnode) { + /* the IP address is already known */ + return; + } +@@ -224,21 +224,21 @@ void netjson_linkIntoNodesTree(struct av + + node = olsr_malloc(sizeof(struct node_entry), "netjson NetworkGraph node - link"); + memset(node, 0, sizeof(*node)); +- node->avl.key = addr; ++ node->olsrd_avl.key = addr; + node->isAlias = false; + node->link = link; +- if (avl_insert(nodes, &node->avl, AVL_DUP_NO) == -1) { ++ if (olsrd_avl_insert(nodes, &node->olsrd_avl, OLSRD_AVL_DUP_NO) == -1) { + /* duplicate */ + free(node); + } + } + +-void netjson_neighborIntoNodesTree(struct avl_tree *nodes, struct neighbor_entry *neighbor) { +- struct avl_node *avlnode; ++void netjson_neighborIntoNodesTree(struct olsrd_avl_tree *nodes, struct neighbor_entry *neighbor) { ++ struct olsrd_avl_node *olsrd_avlnode; + struct node_entry *node; + +- avlnode = avl_find(nodes, &neighbor->neighbor_main_addr); +- if (avlnode) { ++ olsrd_avlnode = olsrd_avl_find(nodes, &neighbor->neighbor_main_addr); ++ if (olsrd_avlnode) { + /* the IP address is already known */ + return; + } +@@ -247,10 +247,10 @@ void netjson_neighborIntoNodesTree(struc + + node = olsr_malloc(sizeof(struct node_entry), "netjson NetworkGraph node - neighbor"); + memset(node, 0, sizeof(*node)); +- node->avl.key = &neighbor->neighbor_main_addr; ++ node->olsrd_avl.key = &neighbor->neighbor_main_addr; + node->isAlias = false; + node->neighbor = neighbor; +- if (avl_insert(nodes, &node->avl, AVL_DUP_NO) == -1) { ++ if (olsrd_avl_insert(nodes, &node->olsrd_avl, OLSRD_AVL_DUP_NO) == -1) { + /* duplicate */ + free(node); + } +--- a/lib/netjson/src/olsrd_netjson_helpers.h ++++ b/lib/netjson/src/olsrd_netjson_helpers.h +@@ -48,7 +48,7 @@ + + #include <stdbool.h> + +-#include "common/avl.h" ++#include "common/olsrd_avl.h" + #include "mid_set.h" + #include "tc_set.h" + #include "link_set.h" +@@ -56,7 +56,7 @@ + #include "olsr_types.h" + + struct node_entry { +- struct avl_node avl; ++ struct olsrd_avl_node olsrd_avl; + bool isAlias; + struct mid_entry *mid; + struct tc_entry *tc; +@@ -65,15 +65,15 @@ struct node_entry { + struct neighbor_entry *neighbor; + }; + +-/* static INLINE struct node_entry * avlnode2node(struct avl_node *ptr) */ +-AVLNODE2STRUCT(avlnode2node, struct node_entry, avl); ++/* static INLINE struct node_entry * olsrd_avlnode2node(struct olsrd_avl_node *ptr) */ ++OLSRD_AVLNODE2STRUCT(olsrd_avlnode2node, struct node_entry, olsrd_avl); + + struct node_entry * netjson_constructMidSelf(struct mid_entry *mid); + void netjson_cleanup_mid_self(struct node_entry *node_entry); +-void netjson_midIntoNodesTree(struct avl_tree *nodes, struct mid_entry *mid); +-void netjson_tcIntoNodesTree(struct avl_tree *nodes, struct tc_entry *tc); +-void netjson_tcEdgeIntoNodesTree(struct avl_tree *nodes, struct tc_edge_entry *tc_edge); +-void netjson_linkIntoNodesTree(struct avl_tree *nodes, struct link_entry *link, union olsr_ip_addr *addr); +-void netjson_neighborIntoNodesTree(struct avl_tree *nodes, struct neighbor_entry *neigh); ++void netjson_midIntoNodesTree(struct olsrd_avl_tree *nodes, struct mid_entry *mid); ++void netjson_tcIntoNodesTree(struct olsrd_avl_tree *nodes, struct tc_entry *tc); ++void netjson_tcEdgeIntoNodesTree(struct olsrd_avl_tree *nodes, struct tc_edge_entry *tc_edge); ++void netjson_linkIntoNodesTree(struct olsrd_avl_tree *nodes, struct link_entry *link, union olsr_ip_addr *addr); ++void netjson_neighborIntoNodesTree(struct olsrd_avl_tree *nodes, struct neighbor_entry *neigh); + + #endif /* LIB_NETJSON_SRC_OLSRD_NETJSON_HELPERS_H_ */ +--- a/src/common/avl.c ++++ /dev/null +@@ -1,664 +0,0 @@ +-/* +- * The olsr.org Optimized Link-State Routing daemon (olsrd) +- * +- * (c) by the OLSR project +- * +- * See our Git repository to find out who worked on this file +- * and thus is a copyright holder on it. +- * +- * All rights reserved. +- * +- * Redistribution and use in source and binary forms, with or without +- * modification, are permitted provided that the following conditions +- * are met: +- * +- * * Redistributions of source code must retain the above copyright +- * notice, this list of conditions and the following disclaimer. +- * * Redistributions in binary form must reproduce the above copyright +- * notice, this list of conditions and the following disclaimer in +- * the documentation and/or other materials provided with the +- * distribution. +- * * Neither the name of olsr.org, olsrd nor the names of its +- * contributors may be used to endorse or promote products derived +- * from this software without specific prior written permission. +- * +- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +- * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +- * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +- * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +- * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +- * POSSIBILITY OF SUCH DAMAGE. +- * +- * Visit http://www.olsr.org for more information. +- * +- * If you find this software useful feel free to make a donation +- * to the project. For more information see the website or contact +- * the copyright holders. +- * +- */ +- +-#include <stddef.h> +-#include <time.h> +-#include <string.h> +- +-#include "ipcalc.h" +-#include "common/avl.h" +-#include "net_olsr.h" +- +-/* +- * default comparison pointers +- * set to the respective compare function. +- * if avl_comp_default is set to zero, a fast +- * INLINE ipv4 comparison will be executed. +- */ +-avl_tree_comp avl_comp_default = NULL; +-avl_tree_comp avl_comp_prefix_default; +- +-int +-avl_comp_ipv4(const void *ip1, const void *ip2) +-{ +- return ip4cmp(ip1, ip2); +-} +- +-int +-avl_comp_ipv6(const void *ip1, const void *ip2) +-{ +- return ip6cmp(ip1, ip2); +-} +- +-int +-avl_comp_mac(const void *ip1, const void *ip2) +-{ +- return memcmp(ip1, ip2, 6); +-} +- +-void +-avl_init(struct avl_tree *tree, avl_tree_comp comp) +-{ +- tree->root = NULL; +- tree->first = NULL; +- tree->last = NULL; +- tree->count = 0; +- +- tree->comp = comp == avl_comp_ipv4 ? NULL : comp; +-} +- +-static struct avl_node * +-avl_find_rec_ipv4(struct avl_node *node, const void *key) +-{ +- if (*(const unsigned int *)key < *(const unsigned int *)node->key) { +- if (node->left != NULL) +- return avl_find_rec_ipv4(node->left, key); +- } +- +- else if (*(const unsigned int *)key > *(const unsigned int *)node->key) { +- if (node->right != NULL) +- return avl_find_rec_ipv4(node->right, key); +- } +- +- return node; +-} +- +-static struct avl_node * +-avl_find_rec(struct avl_node *node, const void *key, avl_tree_comp comp) +-{ +- int diff; +- +- if (NULL == comp) +- return avl_find_rec_ipv4(node, key); +- +- diff = (*comp) (key, node->key); +- +- if (diff < 0) { +- if (node->left != NULL) +- return avl_find_rec(node->left, key, comp); +- +- return node; +- } +- +- if (diff > 0) { +- if (node->right != NULL) +- return avl_find_rec(node->right, key, comp); +- +- return node; +- } +- +- return node; +-} +- +-struct avl_node * +-avl_find(struct avl_tree *tree, const void *key) +-{ +- struct avl_node *node; +- +- if (tree->root == NULL) +- return NULL; +- +- node = avl_find_rec(tree->root, key, tree->comp); +- +- if (NULL == tree->comp) { +- if (0 != ip4cmp(node->key, key)) +- return NULL; +- } +- +- else { +- if ((*tree->comp) (node->key, key) != 0) +- return NULL; +- } +- +- return node; +-} +- +-static void +-avl_rotate_right(struct avl_tree *tree, struct avl_node *node) +-{ +- struct avl_node *left, *parent; +- +- left = node->left; +- parent = node->parent; +- +- left->parent = parent; +- node->parent = left; +- +- if (parent == NULL) +- tree->root = left; +- +- else { +- if (parent->left == node) +- parent->left = left; +- +- else +- parent->right = left; +- } +- +- node->left = left->right; +- left->right = node; +- +- if (node->left != NULL) +- node->left->parent = node; +- +- node->balance += 1 - MIN(left->balance, 0); +- left->balance += 1 + MAX(node->balance, 0); +-} +- +-static void +-avl_rotate_left(struct avl_tree *tree, struct avl_node *node) +-{ +- struct avl_node *right, *parent; +- +- right = node->right; +- parent = node->parent; +- +- right->parent = parent; +- node->parent = right; +- +- if (parent == NULL) +- tree->root = right; +- +- else { +- if (parent->left == node) +- parent->left = right; +- +- else +- parent->right = right; +- } +- +- node->right = right->left; +- right->left = node; +- +- if (node->right != NULL) +- node->right->parent = node; +- +- node->balance -= 1 + MAX(right->balance, 0); +- right->balance -= 1 - MIN(node->balance, 0); +-} +- +-static void +-post_insert(struct avl_tree *tree, struct avl_node *node) +-{ +- struct avl_node *parent = node->parent; +- +- if (parent == NULL) +- return; +- +- if (node == parent->left) { +- parent->balance--; +- +- if (parent->balance == 0) +- return; +- +- if (parent->balance == -1) { +- post_insert(tree, parent); +- return; +- } +- +- if (node->balance == -1) { +- avl_rotate_right(tree, parent); +- return; +- } +- +- avl_rotate_left(tree, node); +- avl_rotate_right(tree, node->parent->parent); +- return; +- } +- +- parent->balance++; +- +- if (parent->balance == 0) +- return; +- +- if (parent->balance == 1) { +- post_insert(tree, parent); +- return; +- } +- +- if (node->balance == 1) { +- avl_rotate_left(tree, parent); +- return; +- } +- +- avl_rotate_right(tree, node); +- avl_rotate_left(tree, node->parent->parent); +-} +- +-static void +-avl_insert_before(struct avl_tree *tree, struct avl_node *pos_node, struct avl_node *node) +-{ +- if (pos_node->prev != NULL) +- pos_node->prev->next = node; +- else +- tree->first = node; +- +- node->prev = pos_node->prev; +- node->next = pos_node; +- +- pos_node->prev = node; +- +- tree->count++; +-} +- +-static void +-avl_insert_after(struct avl_tree *tree, struct avl_node *pos_node, struct avl_node *node) +-{ +- if (pos_node->next != NULL) +- pos_node->next->prev = node; +- else +- tree->last = node; +- +- node->prev = pos_node; +- node->next = pos_node->next; +- +- pos_node->next = node; +- +- tree->count++; +-} +- +-static void +-avl_remove(struct avl_tree *tree, struct avl_node *node) +-{ +- if (node->prev != NULL) +- node->prev->next = node->next; +- else +- tree->first = node->next; +- +- if (node->next != NULL) +- node->next->prev = node->prev; +- else +- tree->last = node->prev; +- +- tree->count--; +-} +- +-int +-avl_insert(struct avl_tree *tree, struct avl_node *new, int allow_duplicates) +-{ +- struct avl_node *node; +- struct avl_node *last; +- int diff; +- +- new->parent = NULL; +- +- new->left = NULL; +- new->right = NULL; +- +- new->next = NULL; +- new->prev = NULL; +- +- new->balance = 0; +- new->leader = 1; +- +- if (tree->root == NULL) { +- tree->root = new; +- tree->first = new; +- tree->last = new; +- tree->count = 1; +- return 0; +- } +- +- node = avl_find_rec(tree->root, new->key, tree->comp); +- +- last = node; +- +- while (last->next != NULL && last->next->leader == 0) +- last = last->next; +- +- if (NULL == tree->comp) +- diff = ip4cmp(new->key, node->key); +- +- else +- diff = (*tree->comp) (new->key, node->key); +- +- if (diff == 0) { +- if (allow_duplicates == AVL_DUP_NO) +- return -1; +- +- new->leader = 0; +- +- avl_insert_after(tree, last, new); +- return 0; +- } +- +- if (node->balance == 1) { +- avl_insert_before(tree, node, new); +- +- node->balance = 0; +- new->parent = node; +- node->left = new; +- return 0; +- } +- +- if (node->balance == -1) { +- avl_insert_after(tree, last, new); +- +- node->balance = 0; +- new->parent = node; +- node->right = new; +- return 0; +- } +- +- if (diff < 0) { +- avl_insert_before(tree, node, new); +- +- node->balance = -1; +- new->parent = node; +- node->left = new; +- post_insert(tree, node); +- return 0; +- } +- +- avl_insert_after(tree, last, new); +- +- node->balance = 1; +- new->parent = node; +- node->right = new; +- post_insert(tree, node); +- return 0; +-} +- +-static void +-avl_post_delete(struct avl_tree *tree, struct avl_node *node) +-{ +- struct avl_node *parent; +- +- if ((parent = node->parent) == NULL) +- return; +- +- if (node == parent->left) { +- parent->balance++; +- +- if (parent->balance == 0) { +- avl_post_delete(tree, parent); +- return; +- } +- +- if (parent->balance == 1) +- return; +- +- if (parent->right->balance == 0) { +- avl_rotate_left(tree, parent); +- return; +- } +- +- if (parent->right->balance == 1) { +- avl_rotate_left(tree, parent); +- avl_post_delete(tree, parent->parent); +- return; +- } +- +- avl_rotate_right(tree, parent->right); +- avl_rotate_left(tree, parent); +- avl_post_delete(tree, parent->parent); +- return; +- } +- +- parent->balance--; +- +- if (parent->balance == 0) { +- avl_post_delete(tree, parent); +- return; +- } +- +- if (parent->balance == -1) +- return; +- +- if (parent->left->balance == 0) { +- avl_rotate_right(tree, parent); +- return; +- } +- +- if (parent->left->balance == -1) { +- avl_rotate_right(tree, parent); +- avl_post_delete(tree, parent->parent); +- return; +- } +- +- avl_rotate_left(tree, parent->left); +- avl_rotate_right(tree, parent); +- avl_post_delete(tree, parent->parent); +-} +- +-static struct avl_node * +-avl_local_min(struct avl_node *node) +-{ +- while (node->left != NULL) +- node = node->left; +- +- return node; +-} +- +-static void +-avl_delete_worker(struct avl_tree *tree, struct avl_node *node) +-{ +- struct avl_node *parent, *min; +- +- parent = node->parent; +- +- if (node->left == NULL && node->right == NULL) { +- if (parent == NULL) { +- tree->root = NULL; +- return; +- } +- +- if (parent->left == node) { +- parent->left = NULL; +- parent->balance++; +- +- if (parent->balance == 1) +- return; +- +- if (parent->balance == 0) { +- avl_post_delete(tree, parent); +- return; +- } +- +- if (parent->right->balance == 0) { +- avl_rotate_left(tree, parent); +- return; +- } +- +- if (parent->right->balance == 1) { +- avl_rotate_left(tree, parent); +- avl_post_delete(tree, parent->parent); +- return; +- } +- +- avl_rotate_right(tree, parent->right); +- avl_rotate_left(tree, parent); +- avl_post_delete(tree, parent->parent); +- } +- else { +- parent->right = NULL; +- parent->balance--; +- +- if (parent->balance == -1) +- return; +- +- if (parent->balance == 0) { +- avl_post_delete(tree, parent); +- return; +- } +- +- if (parent->left->balance == 0) { +- avl_rotate_right(tree, parent); +- return; +- } +- +- if (parent->left->balance == -1) { +- avl_rotate_right(tree, parent); +- avl_post_delete(tree, parent->parent); +- return; +- } +- +- avl_rotate_left(tree, parent->left); +- avl_rotate_right(tree, parent); +- avl_post_delete(tree, parent->parent); +- } +- return; +- } +- +- if (node->left == NULL) { +- if (parent == NULL) { +- tree->root = node->right; +- node->right->parent = NULL; +- return; +- } +- +- node->right->parent = parent; +- +- if (parent->left == node) +- parent->left = node->right; +- +- else +- parent->right = node->right; +- +- avl_post_delete(tree, node->right); +- return; +- } +- +- if (node->right == NULL) { +- if (parent == NULL) { +- tree->root = node->left; +- node->left->parent = NULL; +- return; +- } +- +- node->left->parent = parent; +- +- if (parent->left == node) +- parent->left = node->left; +- +- else +- parent->right = node->left; +- +- avl_post_delete(tree, node->left); +- return; +- } +- +- min = avl_local_min(node->right); +- avl_delete_worker(tree, min); +- parent = node->parent; +- +- min->balance = node->balance; +- min->parent = parent; +- min->left = node->left; +- min->right = node->right; +- +- if (min->left != NULL) +- min->left->parent = min; +- +- if (min->right != NULL) +- min->right->parent = min; +- +- if (parent == NULL) { +- tree->root = min; +- return; +- } +- +- if (parent->left == node) { +- parent->left = min; +- return; +- } +- +- parent->right = min; +-} +- +-void +-avl_delete(struct avl_tree *tree, struct avl_node *node) +-{ +- struct avl_node *next; +- struct avl_node *parent; +- struct avl_node *left; +- struct avl_node *right; +- +- if (node->leader != 0) { +- next = node->next; +- +- if (next != NULL && next->leader == 0) { +- next->leader = 1; +- next->balance = node->balance; +- +- parent = node->parent; +- left = node->left; +- right = node->right; +- +- next->parent = parent; +- next->left = left; +- next->right = right; +- +- if (parent == NULL) +- tree->root = next; +- +- else { +- if (node == parent->left) +- parent->left = next; +- +- else +- parent->right = next; +- } +- +- if (left != NULL) +- left->parent = next; +- +- if (right != NULL) +- right->parent = next; +- } +- +- else +- avl_delete_worker(tree, node); +- } +- +- avl_remove(tree, node); +-} +- +-/* +- * Local Variables: +- * c-basic-offset: 2 +- * indent-tabs-mode: nil +- * End: +- */ +--- /dev/null ++++ b/src/common/olsrd_avl.c +@@ -0,0 +1,664 @@ ++/* ++ * The olsr.org Optimized Link-State Routing daemon (olsrd) ++ * ++ * (c) by the OLSR project ++ * ++ * See our Git repository to find out who worked on this file ++ * and thus is a copyright holder on it. ++ * ++ * All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * ++ * * Redistributions of source code must retain the above copyright ++ * notice, this list of conditions and the following disclaimer. ++ * * Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in ++ * the documentation and/or other materials provided with the ++ * distribution. ++ * * Neither the name of olsr.org, olsrd nor the names of its ++ * contributors may be used to endorse or promote products derived ++ * from this software without specific prior written permission. ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ++ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT ++ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS ++ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE ++ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, ++ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, ++ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; ++ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER ++ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ++ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE ++ * POSSIBILITY OF SUCH DAMAGE. ++ * ++ * Visit http://www.olsr.org for more information. ++ * ++ * If you find this software useful feel free to make a donation ++ * to the project. For more information see the website or contact ++ * the copyright holders. ++ * ++ */ ++ ++#include <stddef.h> ++#include <time.h> ++#include <string.h> ++ ++#include "ipcalc.h" ++#include "common/olsrd_avl.h" ++#include "net_olsr.h" ++ ++/* ++ * default comparison pointers ++ * set to the respective compare function. ++ * if olsrd_avl_comp_default is set to zero, a fast ++ * INLINE ipv4 comparison will be executed. ++ */ ++olsrd_avl_tree_comp olsrd_avl_comp_default = NULL; ++olsrd_avl_tree_comp olsrd_avl_comp_prefix_default; ++ ++int ++olsrd_avl_comp_ipv4(const void *ip1, const void *ip2) ++{ ++ return ip4cmp(ip1, ip2); ++} ++ ++int ++olsrd_avl_comp_ipv6(const void *ip1, const void *ip2) ++{ ++ return ip6cmp(ip1, ip2); ++} ++ ++int ++olsrd_avl_comp_mac(const void *ip1, const void *ip2) ++{ ++ return memcmp(ip1, ip2, 6); ++} ++ ++void ++olsrd_avl_init(struct olsrd_avl_tree *tree, olsrd_avl_tree_comp comp) ++{ ++ tree->root = NULL; ++ tree->first = NULL; ++ tree->last = NULL; ++ tree->count = 0; ++ ++ tree->comp = comp == olsrd_avl_comp_ipv4 ? NULL : comp; ++} ++ ++static struct olsrd_avl_node * ++olsrd_avl_find_rec_ipv4(struct olsrd_avl_node *node, const void *key) ++{ ++ if (*(const unsigned int *)key < *(const unsigned int *)node->key) { ++ if (node->left != NULL) ++ return olsrd_avl_find_rec_ipv4(node->left, key); ++ } ++ ++ else if (*(const unsigned int *)key > *(const unsigned int *)node->key) { ++ if (node->right != NULL) ++ return olsrd_avl_find_rec_ipv4(node->right, key); ++ } ++ ++ return node; ++} ++ ++static struct olsrd_avl_node * ++olsrd_avl_find_rec(struct olsrd_avl_node *node, const void *key, olsrd_avl_tree_comp comp) ++{ ++ int diff; ++ ++ if (NULL == comp) ++ return olsrd_avl_find_rec_ipv4(node, key); ++ ++ diff = (*comp) (key, node->key); ++ ++ if (diff < 0) { ++ if (node->left != NULL) ++ return olsrd_avl_find_rec(node->left, key, comp); ++ ++ return node; ++ } ++ ++ if (diff > 0) { ++ if (node->right != NULL) ++ return olsrd_avl_find_rec(node->right, key, comp); ++ ++ return node; ++ } ++ ++ return node; ++} ++ ++struct olsrd_avl_node * ++olsrd_avl_find(struct olsrd_avl_tree *tree, const void *key) ++{ ++ struct olsrd_avl_node *node; ++ ++ if (tree->root == NULL) ++ return NULL; ++ ++ node = olsrd_avl_find_rec(tree->root, key, tree->comp); ++ ++ if (NULL == tree->comp) { ++ if (0 != ip4cmp(node->key, key)) ++ return NULL; ++ } ++ ++ else { ++ if ((*tree->comp) (node->key, key) != 0) ++ return NULL; ++ } ++ ++ return node; ++} ++ ++static void ++olsrd_avl_rotate_right(struct olsrd_avl_tree *tree, struct olsrd_avl_node *node) ++{ ++ struct olsrd_avl_node *left, *parent; ++ ++ left = node->left; ++ parent = node->parent; ++ ++ left->parent = parent; ++ node->parent = left; ++ ++ if (parent == NULL) ++ tree->root = left; ++ ++ else { ++ if (parent->left == node) ++ parent->left = left; ++ ++ else ++ parent->right = left; ++ } ++ ++ node->left = left->right; ++ left->right = node; ++ ++ if (node->left != NULL) ++ node->left->parent = node; ++ ++ node->balance += 1 - MIN(left->balance, 0); ++ left->balance += 1 + MAX(node->balance, 0); ++} ++ ++static void ++olsrd_avl_rotate_left(struct olsrd_avl_tree *tree, struct olsrd_avl_node *node) ++{ ++ struct olsrd_avl_node *right, *parent; ++ ++ right = node->right; ++ parent = node->parent; ++ ++ right->parent = parent; ++ node->parent = right; ++ ++ if (parent == NULL) ++ tree->root = right; ++ ++ else { ++ if (parent->left == node) ++ parent->left = right; ++ ++ else ++ parent->right = right; ++ } ++ ++ node->right = right->left; ++ right->left = node; ++ ++ if (node->right != NULL) ++ node->right->parent = node; ++ ++ node->balance -= 1 + MAX(right->balance, 0); ++ right->balance -= 1 - MIN(node->balance, 0); ++} ++ ++static void ++post_insert(struct olsrd_avl_tree *tree, struct olsrd_avl_node *node) ++{ ++ struct olsrd_avl_node *parent = node->parent; ++ ++ if (parent == NULL) ++ return; ++ ++ if (node == parent->left) { ++ parent->balance--; ++ ++ if (parent->balance == 0) ++ return; ++ ++ if (parent->balance == -1) { ++ post_insert(tree, parent); ++ return; ++ } ++ ++ if (node->balance == -1) { ++ olsrd_avl_rotate_right(tree, parent); ++ return; ++ } ++ ++ olsrd_avl_rotate_left(tree, node); ++ olsrd_avl_rotate_right(tree, node->parent->parent); ++ return; ++ } ++ ++ parent->balance++; ++ ++ if (parent->balance == 0) ++ return; ++ ++ if (parent->balance == 1) { ++ post_insert(tree, parent); ++ return; ++ } ++ ++ if (node->balance == 1) { ++ olsrd_avl_rotate_left(tree, parent); ++ return; ++ } ++ ++ olsrd_avl_rotate_right(tree, node); ++ olsrd_avl_rotate_left(tree, node->parent->parent); ++} ++ ++static void ++olsrd_avl_insert_before(struct olsrd_avl_tree *tree, struct olsrd_avl_node *pos_node, struct olsrd_avl_node *node) ++{ ++ if (pos_node->prev != NULL) ++ pos_node->prev->next = node; ++ else ++ tree->first = node; ++ ++ node->prev = pos_node->prev; ++ node->next = pos_node; ++ ++ pos_node->prev = node; ++ ++ tree->count++; ++} ++ ++static void ++olsrd_avl_insert_after(struct olsrd_avl_tree *tree, struct olsrd_avl_node *pos_node, struct olsrd_avl_node *node) ++{ ++ if (pos_node->next != NULL) ++ pos_node->next->prev = node; ++ else ++ tree->last = node; ++ ++ node->prev = pos_node; ++ node->next = pos_node->next; ++ ++ pos_node->next = node; ++ ++ tree->count++; ++} ++ ++static void ++olsrd_avl_remove(struct olsrd_avl_tree *tree, struct olsrd_avl_node *node) ++{ ++ if (node->prev != NULL) ++ node->prev->next = node->next; ++ else ++ tree->first = node->next; ++ ++ if (node->next != NULL) ++ node->next->prev = node->prev; ++ else ++ tree->last = node->prev; ++ ++ tree->count--; ++} ++ ++int ++olsrd_avl_insert(struct olsrd_avl_tree *tree, struct olsrd_avl_node *new, int allow_duplicates) ++{ ++ struct olsrd_avl_node *node; ++ struct olsrd_avl_node *last; ++ int diff; ++ ++ new->parent = NULL; ++ ++ new->left = NULL; ++ new->right = NULL; ++ ++ new->next = NULL; ++ new->prev = NULL; ++ ++ new->balance = 0; ++ new->leader = 1; ++ ++ if (tree->root == NULL) { ++ tree->root = new; ++ tree->first = new; ++ tree->last = new; ++ tree->count = 1; ++ return 0; ++ } ++ ++ node = olsrd_avl_find_rec(tree->root, new->key, tree->comp); ++ ++ last = node; ++ ++ while (last->next != NULL && last->next->leader == 0) ++ last = last->next; ++ ++ if (NULL == tree->comp) ++ diff = ip4cmp(new->key, node->key); ++ ++ else ++ diff = (*tree->comp) (new->key, node->key); ++ ++ if (diff == 0) { ++ if (allow_duplicates == OLSRD_AVL_DUP_NO) ++ return -1; ++ ++ new->leader = 0; ++ ++ olsrd_avl_insert_after(tree, last, new); ++ return 0; ++ } ++ ++ if (node->balance == 1) { ++ olsrd_avl_insert_before(tree, node, new); ++ ++ node->balance = 0; ++ new->parent = node; ++ node->left = new; ++ return 0; ++ } ++ ++ if (node->balance == -1) { ++ olsrd_avl_insert_after(tree, last, new); ++ ++ node->balance = 0; ++ new->parent = node; ++ node->right = new; ++ return 0; ++ } ++ ++ if (diff < 0) { ++ olsrd_avl_insert_before(tree, node, new); ++ ++ node->balance = -1; ++ new->parent = node; ++ node->left = new; ++ post_insert(tree, node); ++ return 0; ++ } ++ ++ olsrd_avl_insert_after(tree, last, new); ++ ++ node->balance = 1; ++ new->parent = node; ++ node->right = new; ++ post_insert(tree, node); ++ return 0; ++} ++ ++static void ++olsrd_avl_post_delete(struct olsrd_avl_tree *tree, struct olsrd_avl_node *node) ++{ ++ struct olsrd_avl_node *parent; ++ ++ if ((parent = node->parent) == NULL) ++ return; ++ ++ if (node == parent->left) { ++ parent->balance++; ++ ++ if (parent->balance == 0) { ++ olsrd_avl_post_delete(tree, parent); ++ return; ++ } ++ ++ if (parent->balance == 1) ++ return; ++ ++ if (parent->right->balance == 0) { ++ olsrd_avl_rotate_left(tree, parent); ++ return; ++ } ++ ++ if (parent->right->balance == 1) { ++ olsrd_avl_rotate_left(tree, parent); ++ olsrd_avl_post_delete(tree, parent->parent); ++ return; ++ } ++ ++ olsrd_avl_rotate_right(tree, parent->right); ++ olsrd_avl_rotate_left(tree, parent); ++ olsrd_avl_post_delete(tree, parent->parent); ++ return; ++ } ++ ++ parent->balance--; ++ ++ if (parent->balance == 0) { ++ olsrd_avl_post_delete(tree, parent); ++ return; ++ } ++ ++ if (parent->balance == -1) ++ return; ++ ++ if (parent->left->balance == 0) { ++ olsrd_avl_rotate_right(tree, parent); ++ return; ++ } ++ ++ if (parent->left->balance == -1) { ++ olsrd_avl_rotate_right(tree, parent); ++ olsrd_avl_post_delete(tree, parent->parent); ++ return; ++ } ++ ++ olsrd_avl_rotate_left(tree, parent->left); ++ olsrd_avl_rotate_right(tree, parent); ++ olsrd_avl_post_delete(tree, parent->parent); ++} ++ ++static struct olsrd_avl_node * ++olsrd_avl_local_min(struct olsrd_avl_node *node) ++{ ++ while (node->left != NULL) ++ node = node->left; ++ ++ return node; ++} ++ ++static void ++olsrd_avl_delete_worker(struct olsrd_avl_tree *tree, struct olsrd_avl_node *node) ++{ ++ struct olsrd_avl_node *parent, *min; ++ ++ parent = node->parent; ++ ++ if (node->left == NULL && node->right == NULL) { ++ if (parent == NULL) { ++ tree->root = NULL; ++ return; ++ } ++ ++ if (parent->left == node) { ++ parent->left = NULL; ++ parent->balance++; ++ ++ if (parent->balance == 1) ++ return; ++ ++ if (parent->balance == 0) { ++ olsrd_avl_post_delete(tree, parent); ++ return; ++ } ++ ++ if (parent->right->balance == 0) { ++ olsrd_avl_rotate_left(tree, parent); ++ return; ++ } ++ ++ if (parent->right->balance == 1) { ++ olsrd_avl_rotate_left(tree, parent); ++ olsrd_avl_post_delete(tree, parent->parent); ++ return; ++ } ++ ++ olsrd_avl_rotate_right(tree, parent->right); ++ olsrd_avl_rotate_left(tree, parent); ++ olsrd_avl_post_delete(tree, parent->parent); ++ } ++ else { ++ parent->right = NULL; ++ parent->balance--; ++ ++ if (parent->balance == -1) ++ return; ++ ++ if (parent->balance == 0) { ++ olsrd_avl_post_delete(tree, parent); ++ return; ++ } ++ ++ if (parent->left->balance == 0) { ++ olsrd_avl_rotate_right(tree, parent); ++ return; ++ } ++ ++ if (parent->left->balance == -1) { ++ olsrd_avl_rotate_right(tree, parent); ++ olsrd_avl_post_delete(tree, parent->parent); ++ return; ++ } ++ ++ olsrd_avl_rotate_left(tree, parent->left); ++ olsrd_avl_rotate_right(tree, parent); ++ olsrd_avl_post_delete(tree, parent->parent); ++ } ++ return; ++ } ++ ++ if (node->left == NULL) { ++ if (parent == NULL) { ++ tree->root = node->right; ++ node->right->parent = NULL; ++ return; ++ } ++ ++ node->right->parent = parent; ++ ++ if (parent->left == node) ++ parent->left = node->right; ++ ++ else ++ parent->right = node->right; ++ ++ olsrd_avl_post_delete(tree, node->right); ++ return; ++ } ++ ++ if (node->right == NULL) { ++ if (parent == NULL) { ++ tree->root = node->left; ++ node->left->parent = NULL; ++ return; ++ } ++ ++ node->left->parent = parent; ++ ++ if (parent->left == node) ++ parent->left = node->left; ++ ++ else ++ parent->right = node->left; ++ ++ olsrd_avl_post_delete(tree, node->left); ++ return; ++ } ++ ++ min = olsrd_avl_local_min(node->right); ++ olsrd_avl_delete_worker(tree, min); ++ parent = node->parent; ++ ++ min->balance = node->balance; ++ min->parent = parent; ++ min->left = node->left; ++ min->right = node->right; ++ ++ if (min->left != NULL) ++ min->left->parent = min; ++ ++ if (min->right != NULL) ++ min->right->parent = min; ++ ++ if (parent == NULL) { ++ tree->root = min; ++ return; ++ } ++ ++ if (parent->left == node) { ++ parent->left = min; ++ return; ++ } ++ ++ parent->right = min; ++} ++ ++void ++olsrd_avl_delete(struct olsrd_avl_tree *tree, struct olsrd_avl_node *node) ++{ ++ struct olsrd_avl_node *next; ++ struct olsrd_avl_node *parent; ++ struct olsrd_avl_node *left; ++ struct olsrd_avl_node *right; ++ ++ if (node->leader != 0) { ++ next = node->next; ++ ++ if (next != NULL && next->leader == 0) { ++ next->leader = 1; ++ next->balance = node->balance; ++ ++ parent = node->parent; ++ left = node->left; ++ right = node->right; ++ ++ next->parent = parent; ++ next->left = left; ++ next->right = right; ++ ++ if (parent == NULL) ++ tree->root = next; ++ ++ else { ++ if (node == parent->left) ++ parent->left = next; ++ ++ else ++ parent->right = next; ++ } ++ ++ if (left != NULL) ++ left->parent = next; ++ ++ if (right != NULL) ++ right->parent = next; ++ } ++ ++ else ++ olsrd_avl_delete_worker(tree, node); ++ } ++ ++ olsrd_avl_remove(tree, node); ++} ++ ++/* ++ * Local Variables: ++ * c-basic-offset: 2 ++ * indent-tabs-mode: nil ++ * End: ++ */ +--- a/src/common/avl.h ++++ /dev/null +@@ -1,183 +0,0 @@ +-/* +- * The olsr.org Optimized Link-State Routing daemon (olsrd) +- * +- * (c) by the OLSR project +- * +- * See our Git repository to find out who worked on this file +- * and thus is a copyright holder on it. +- * +- * All rights reserved. +- * +- * Redistribution and use in source and binary forms, with or without +- * modification, are permitted provided that the following conditions +- * are met: +- * +- * * Redistributions of source code must retain the above copyright +- * notice, this list of conditions and the following disclaimer. +- * * Redistributions in binary form must reproduce the above copyright +- * notice, this list of conditions and the following disclaimer in +- * the documentation and/or other materials provided with the +- * distribution. +- * * Neither the name of olsr.org, olsrd nor the names of its +- * contributors may be used to endorse or promote products derived +- * from this software without specific prior written permission. +- * +- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +- * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +- * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +- * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +- * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +- * POSSIBILITY OF SUCH DAMAGE. +- * +- * Visit http://www.olsr.org for more information. +- * +- * If you find this software useful feel free to make a donation +- * to the project. For more information see the website or contact +- * the copyright holders. +- * +- */ +- +-#ifndef _AVL_H +-#define _AVL_H +- +-#include <stddef.h> +-#include "compiler.h" +-#include "defs.h" +- +-struct avl_node { +- struct avl_node *parent; +- struct avl_node *left; +- struct avl_node *right; +- struct avl_node *next; +- struct avl_node *prev; +- void *key; +- signed char balance; +- unsigned char leader; +-}; +- +-typedef int (*avl_tree_comp) (const void *, const void *); +- +-struct avl_tree { +- struct avl_node *root; +- struct avl_node *first; +- struct avl_node *last; +- unsigned int count; +- avl_tree_comp comp; +-}; +- +-#define AVL_DUP 1 +-#define AVL_DUP_NO 0 +- +-void avl_init(struct avl_tree *, avl_tree_comp); +-struct avl_node *avl_find(struct avl_tree *, const void *); +-int avl_insert(struct avl_tree *, struct avl_node *, int); +-void avl_delete(struct avl_tree *, struct avl_node *); +- +-static INLINE struct avl_node * +-avl_walk_first(struct avl_tree *tree) +-{ +- if (!tree) { +- return NULL; +- } +- +- return tree->first; +-} +-static INLINE struct avl_node * +-avl_walk_last(struct avl_tree *tree) +-{ +- if (!tree) { +- return NULL; +- } +- +- return tree->last; +-} +-static INLINE struct avl_node * +-avl_walk_next(struct avl_node *node) +-{ +- if (!node) { +- return NULL; +- } +- +- return node->next; +-} +-static INLINE struct avl_node * +-avl_walk_prev(struct avl_node *node) +-{ +- if (!node) { +- return NULL; +- } +- +- return node->prev; +-} +- +-/* and const versions*/ +-static INLINE const struct avl_node * +-avl_walk_first_c(const struct avl_tree *tree) +-{ +- if (!tree) { +- return NULL; +- } +- +- return tree->first; +-} +-static INLINE const struct avl_node * +-avl_walk_last_c(const struct avl_tree *tree) +-{ +- if (!tree) { +- return NULL; +- } +- +- return tree->last; +-} +-static INLINE const struct avl_node * +-avl_walk_next_c(const struct avl_node *node) +-{ +- if (!node) { +- return NULL; +- } +- +- return node->next; +-} +-static INLINE const struct avl_node * +-avl_walk_prev_c(const struct avl_node *node) +-{ +- if (!node) { +- return NULL; +- } +- +- return node->prev; +-} +- +-extern avl_tree_comp avl_comp_default; +-extern avl_tree_comp avl_comp_prefix_default; +-extern int avl_comp_ipv4(const void *, const void *); +-extern int avl_comp_ipv6(const void *, const void *); +-extern int avl_comp_mac(const void *, const void *); +- +-/* +- * Macro to define an INLINE function to map from a list_node offset back to the +- * base of the datastructure. That way you save an extra data pointer. +- */ +-#define AVLNODE2STRUCT(funcname, structname, avlnodename) \ +-static INLINE structname * funcname (struct avl_node *ptr)\ +-{\ +- return( \ +- ptr ? \ +- (structname *) (((size_t) ptr) - offsetof(structname, avlnodename)) : \ +- NULL); \ +-} +- +-#endif /* _AVL_H */ +- +-/* +- * Local Variables: +- * c-basic-offset: 2 +- * indent-tabs-mode: nil +- * End: +- */ +--- /dev/null ++++ b/src/common/olsrd_avl.h +@@ -0,0 +1,183 @@ ++/* ++ * The olsr.org Optimized Link-State Routing daemon (olsrd) ++ * ++ * (c) by the OLSR project ++ * ++ * See our Git repository to find out who worked on this file ++ * and thus is a copyright holder on it. ++ * ++ * All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * ++ * * Redistributions of source code must retain the above copyright ++ * notice, this list of conditions and the following disclaimer. ++ * * Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in ++ * the documentation and/or other materials provided with the ++ * distribution. ++ * * Neither the name of olsr.org, olsrd nor the names of its ++ * contributors may be used to endorse or promote products derived ++ * from this software without specific prior written permission. ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ++ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT ++ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS ++ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE ++ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, ++ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, ++ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; ++ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER ++ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ++ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE ++ * POSSIBILITY OF SUCH DAMAGE. ++ * ++ * Visit http://www.olsr.org for more information. ++ * ++ * If you find this software useful feel free to make a donation ++ * to the project. For more information see the website or contact ++ * the copyright holders. ++ * ++ */ ++ ++#ifndef _OLSRD_AVL_H ++#define _OLSRD_AVL_H ++ ++#include <stddef.h> ++#include "compiler.h" ++#include "defs.h" ++ ++struct olsrd_avl_node { ++ struct olsrd_avl_node *parent; ++ struct olsrd_avl_node *left; ++ struct olsrd_avl_node *right; ++ struct olsrd_avl_node *next; ++ struct olsrd_avl_node *prev; ++ void *key; ++ signed char balance; ++ unsigned char leader; ++}; ++ ++typedef int (*olsrd_avl_tree_comp) (const void *, const void *); ++ ++struct olsrd_avl_tree { ++ struct olsrd_avl_node *root; ++ struct olsrd_avl_node *first; ++ struct olsrd_avl_node *last; ++ unsigned int count; ++ olsrd_avl_tree_comp comp; ++}; ++ ++#define OLSRD_AVL_DUP 1 ++#define OLSRD_AVL_DUP_NO 0 ++ ++void olsrd_avl_init(struct olsrd_avl_tree *, olsrd_avl_tree_comp); ++struct olsrd_avl_node *olsrd_avl_find(struct olsrd_avl_tree *, const void *); ++int olsrd_avl_insert(struct olsrd_avl_tree *, struct olsrd_avl_node *, int); ++void olsrd_avl_delete(struct olsrd_avl_tree *, struct olsrd_avl_node *); ++ ++static INLINE struct olsrd_avl_node * ++olsrd_avl_walk_first(struct olsrd_avl_tree *tree) ++{ ++ if (!tree) { ++ return NULL; ++ } ++ ++ return tree->first; ++} ++static INLINE struct olsrd_avl_node * ++olsrd_avl_walk_last(struct olsrd_avl_tree *tree) ++{ ++ if (!tree) { ++ return NULL; ++ } ++ ++ return tree->last; ++} ++static INLINE struct olsrd_avl_node * ++olsrd_avl_walk_next(struct olsrd_avl_node *node) ++{ ++ if (!node) { ++ return NULL; ++ } ++ ++ return node->next; ++} ++static INLINE struct olsrd_avl_node * ++olsrd_avl_walk_prev(struct olsrd_avl_node *node) ++{ ++ if (!node) { ++ return NULL; ++ } ++ ++ return node->prev; ++} ++ ++/* and const versions*/ ++static INLINE const struct olsrd_avl_node * ++olsrd_avl_walk_first_c(const struct olsrd_avl_tree *tree) ++{ ++ if (!tree) { ++ return NULL; ++ } ++ ++ return tree->first; ++} ++static INLINE const struct olsrd_avl_node * ++olsrd_avl_walk_last_c(const struct olsrd_avl_tree *tree) ++{ ++ if (!tree) { ++ return NULL; ++ } ++ ++ return tree->last; ++} ++static INLINE const struct olsrd_avl_node * ++olsrd_avl_walk_next_c(const struct olsrd_avl_node *node) ++{ ++ if (!node) { ++ return NULL; ++ } ++ ++ return node->next; ++} ++static INLINE const struct olsrd_avl_node * ++olsrd_avl_walk_prev_c(const struct olsrd_avl_node *node) ++{ ++ if (!node) { ++ return NULL; ++ } ++ ++ return node->prev; ++} ++ ++extern olsrd_avl_tree_comp olsrd_avl_comp_default; ++extern olsrd_avl_tree_comp olsrd_avl_comp_prefix_default; ++extern int olsrd_avl_comp_ipv4(const void *, const void *); ++extern int olsrd_avl_comp_ipv6(const void *, const void *); ++extern int olsrd_avl_comp_mac(const void *, const void *); ++ ++/* ++ * Macro to define an INLINE function to map from a list_node offset back to the ++ * base of the datastructure. That way you save an extra data pointer. ++ */ ++#define OLSRD_AVLNODE2STRUCT(funcname, structname, olsrd_avlnodename) \ ++static INLINE structname * funcname (struct olsrd_avl_node *ptr)\ ++{\ ++ return( \ ++ ptr ? \ ++ (structname *) (((size_t) ptr) - offsetof(structname, olsrd_avlnodename)) : \ ++ NULL); \ ++} ++ ++#endif /* _OLSRD_AVL_H */ ++ ++/* ++ * Local Variables: ++ * c-basic-offset: 2 ++ * indent-tabs-mode: nil ++ * End: ++ */ +--- a/src/duplicate_set.c ++++ b/src/duplicate_set.c +@@ -45,7 +45,7 @@ + + #include "duplicate_set.h" + #include "ipcalc.h" +-#include "common/avl.h" ++#include "common/olsrd_avl.h" + #include "olsr.h" + #include "mid_set.h" + #include "scheduler.h" +@@ -53,13 +53,13 @@ + + static void olsr_cleanup_duplicate_entry(void *unused); + +-struct avl_tree duplicate_set; ++struct olsrd_avl_tree duplicate_set; + struct timer_entry *duplicate_cleanup_timer; + + void + olsr_init_duplicate_set(void) + { +- avl_init(&duplicate_set, olsr_cnf->ip_version == AF_INET ? &avl_comp_ipv4 : &avl_comp_ipv6); ++ olsrd_avl_init(&duplicate_set, olsr_cnf->ip_version == AF_INET ? &olsrd_avl_comp_ipv4 : &olsrd_avl_comp_ipv6); + + olsr_set_timer(&duplicate_cleanup_timer, DUPLICATE_CLEANUP_INTERVAL, DUPLICATE_CLEANUP_JITTER, OLSR_TIMER_PERIODIC, + &olsr_cleanup_duplicate_entry, NULL, 0); +@@ -68,7 +68,7 @@ olsr_init_duplicate_set(void) + void olsr_cleanup_duplicates(union olsr_ip_addr *orig) { + struct dup_entry *entry; + +- entry = (struct dup_entry *)avl_find(&duplicate_set, orig); ++ entry = (struct dup_entry *)olsrd_avl_find(&duplicate_set, orig); + if (entry != NULL) { + entry->too_low_counter = DUP_MAX_TOO_LOW - 2; + } +@@ -83,7 +83,7 @@ olsr_create_duplicate_entry(void *ip, ui + memcpy(&entry->ip, ip, olsr_cnf->ip_version == AF_INET ? sizeof(entry->ip.v4) : sizeof(entry->ip.v6)); + entry->seqnr = seqnr; + entry->too_low_counter = 0; +- entry->avl.key = &entry->ip; ++ entry->olsrd_avl.key = &entry->ip; + entry->array = 0; + } + return entry; +@@ -96,7 +96,7 @@ olsr_cleanup_duplicate_entry(void __attr + + OLSR_FOR_ALL_DUP_ENTRIES(entry) { + if (TIMED_OUT(entry->valid_until)) { +- avl_delete(&duplicate_set, &entry->avl); ++ olsrd_avl_delete(&duplicate_set, &entry->olsrd_avl); + free(entry); + } + } +@@ -143,11 +143,11 @@ olsr_message_is_duplicate(union olsr_mes + + valid_until = GET_TIMESTAMP(DUPLICATE_VTIME); + +- entry = (struct dup_entry *)avl_find(&duplicate_set, ip); ++ entry = (struct dup_entry *)olsrd_avl_find(&duplicate_set, ip); + if (entry == NULL) { + entry = olsr_create_duplicate_entry(ip, seqnr); + if (entry != NULL) { +- avl_insert(&duplicate_set, &entry->avl, 0); ++ olsrd_avl_insert(&duplicate_set, &entry->olsrd_avl, 0); + entry->valid_until = valid_until; + } + return false; // okay, we process this package +@@ -209,7 +209,7 @@ olsr_print_duplicate_table(void) + olsr_wallclock_string(), ipwidth, "Node IP", "DupArray", "VTime"); + + OLSR_FOR_ALL_DUP_ENTRIES(entry) { +- OLSR_PRINTF(1, "%-*s %08x %s\n", ipwidth, olsr_ip_to_string(&addrbuf, (union olsr_ip_addr *)(entry->avl.key)), ++ OLSR_PRINTF(1, "%-*s %08x %s\n", ipwidth, olsr_ip_to_string(&addrbuf, (union olsr_ip_addr *)(entry->olsrd_avl.key)), + entry->array, olsr_clock_string(entry->valid_until)); + } OLSR_FOR_ALL_DUP_ENTRIES_END(entry); + } +--- a/src/duplicate_set.h ++++ b/src/duplicate_set.h +@@ -49,7 +49,7 @@ + #include "defs.h" + #include "olsr.h" + #include "mantissa.h" +-#include "common/avl.h" ++#include "common/olsrd_avl.h" + + #define DUPLICATE_CLEANUP_INTERVAL 15000 + #define DUPLICATE_CLEANUP_JITTER 25 +@@ -57,7 +57,7 @@ + #define DUP_MAX_TOO_LOW 16 + + struct dup_entry { +- struct avl_node avl; ++ struct olsrd_avl_node olsrd_avl; + union olsr_ip_addr ip; + uint16_t seqnr; + uint16_t too_low_counter; +@@ -65,7 +65,7 @@ struct dup_entry { + uint32_t valid_until; + }; + +-AVLNODE2STRUCT(duptree2dupentry, struct dup_entry, avl); ++OLSRD_AVLNODE2STRUCT(duptree2dupentry, struct dup_entry, olsrd_avl); + + void olsr_init_duplicate_set(void); + void olsr_cleanup_duplicates(union olsr_ip_addr *orig); +@@ -80,10 +80,10 @@ void olsr_print_duplicate_table(void); + + #define OLSR_FOR_ALL_DUP_ENTRIES(dup) \ + { \ +- struct avl_node *dup_tree_node, *next_dup_tree_node; \ +- for (dup_tree_node = avl_walk_first(&duplicate_set); \ ++ struct olsrd_avl_node *dup_tree_node, *next_dup_tree_node; \ ++ for (dup_tree_node = olsrd_avl_walk_first(&duplicate_set); \ + dup_tree_node; dup_tree_node = next_dup_tree_node) { \ +- next_dup_tree_node = avl_walk_next(dup_tree_node); \ ++ next_dup_tree_node = olsrd_avl_walk_next(dup_tree_node); \ + dup = duptree2dupentry(dup_tree_node); + #define OLSR_FOR_ALL_DUP_ENTRIES_END(dup) }} + +--- a/src/gateway.c ++++ b/src/gateway.c +@@ -45,7 +45,7 @@ + + #ifdef __linux__ + +-#include "common/avl.h" ++#include "common/olsrd_avl.h" + #include "defs.h" + #include "ipcalc.h" + #include "olsr.h" +@@ -89,7 +89,7 @@ static struct olsr_ip_prefix ipv4_slash_ + static struct olsr_ip_prefix ipv4_slash_1_routes[2]; + + /** the gateway tree */ +-struct avl_tree gateway_tree; ++struct olsrd_avl_tree gateway_tree; + + /** gateway cookie */ + static struct olsr_cookie_info *gateway_entry_mem_cookie = NULL; +@@ -713,7 +713,7 @@ static void cleanup_gateway_handler(void + } + + /* remove gateway entry */ +- avl_delete(&gateway_tree, &gw->node); ++ olsrd_avl_delete(&gateway_tree, &gw->node); + olsr_cookie_free(gateway_entry_mem_cookie, gw); + } + +@@ -837,7 +837,7 @@ int olsr_init_gateways(void) { + gw_container_entry_mem_cookie = olsr_alloc_cookie("gw_container_entry_mem_cookie", OLSR_COOKIE_TYPE_MEMORY); + olsr_cookie_set_memory_size(gw_container_entry_mem_cookie, sizeof(struct gw_container_entry)); + +- avl_init(&gateway_tree, avl_comp_default); ++ olsrd_avl_init(&gateway_tree, olsrd_avl_comp_default); + + olsr_gw_list_init(&gw_list_ipv4, olsr_cnf->smart_gw_use_count); + olsr_gw_list_init(&gw_list_ipv6, olsr_cnf->smart_gw_use_count); +@@ -1078,7 +1078,7 @@ void olsr_cleanup_gateways(void) { + OLSR_FOR_ALL_GWS_END(gw); + + /* there should be no more gateways */ +- assert(!avl_walk_first(&gateway_tree)); ++ assert(!olsrd_avl_walk_first(&gateway_tree)); + assert(!current_ipv4_gw); + assert(!current_ipv6_gw); + +@@ -1244,14 +1244,14 @@ void olsr_update_gateway_entry(union ols + struct gw_container_entry * new_gw_in_list; + uint8_t *ptr; + int64_t prev_path_cost = 0; +- struct gateway_entry *gw = node2gateway(avl_find(&gateway_tree, originator)); ++ struct gateway_entry *gw = node2gateway(olsrd_avl_find(&gateway_tree, originator)); + + if (!gw) { + gw = olsr_cookie_malloc(gateway_entry_mem_cookie); + gw->originator = *originator; + gw->node.key = &gw->originator; + +- avl_insert(&gateway_tree, &gw->node, AVL_DUP_NO); ++ olsrd_avl_insert(&gateway_tree, &gw->node, OLSRD_AVL_DUP_NO); + } else if (olsr_seqno_diff(seqno, gw->seqno) <= 0) { + /* ignore older HNAs */ + return; +@@ -1353,7 +1353,7 @@ void olsr_update_gateway_entry(union ols + * gateway tree immediately, else it is removed on a delayed schedule. + */ + void olsr_delete_gateway_entry(union olsr_ip_addr *originator, uint8_t prefixlen, bool immediate) { +- olsr_delete_gateway_tree_entry(node2gateway(avl_find(&gateway_tree, originator)), prefixlen, immediate); ++ olsr_delete_gateway_tree_entry(node2gateway(olsrd_avl_find(&gateway_tree, originator)), prefixlen, immediate); + } + + /** +@@ -1526,7 +1526,7 @@ bool olsr_set_inet_gateway(struct gatewa + return true; + } + +- new_gw = node2gateway(avl_find(&gateway_tree, &chosen_gw->originator)); ++ new_gw = node2gateway(olsrd_avl_find(&gateway_tree, &chosen_gw->originator)); + if (!new_gw) { + /* the originator is not in the gateway tree, we can't set it as gateway */ + return true; +--- a/src/gateway.h ++++ b/src/gateway.h +@@ -46,7 +46,7 @@ + #ifndef GATEWAY_H_ + #define GATEWAY_H_ + +-#include "common/avl.h" ++#include "common/olsrd_avl.h" + #include "common/list.h" + #include "defs.h" + #include "olsr.h" +@@ -96,7 +96,7 @@ enum gateway_hna_fields { + + /** a gateway entry */ + struct gateway_entry { +- struct avl_node node; ++ struct olsrd_avl_node node; + union olsr_ip_addr originator; + struct olsr_ip_prefix external_prefix; + uint32_t uplink; +@@ -129,27 +129,27 @@ struct interfaceName { + #endif /* __linux__ */ + + /** +- * static INLINE struct gateway_entry * node2gateway (struct avl_node *ptr) ++ * static INLINE struct gateway_entry * node2gateway (struct olsrd_avl_node *ptr) + * + * Converts a node into a gateway entry + */ +-AVLNODE2STRUCT(node2gateway, struct gateway_entry, node); ++OLSRD_AVLNODE2STRUCT(node2gateway, struct gateway_entry, node); + + /** + * Loop over all gateway entries and put the iterated gateway entry in gw + */ + #define OLSR_FOR_ALL_GATEWAY_ENTRIES(gw) \ + { \ +- struct avl_node *gw_node, *next_gw_node; \ +- for (gw_node = avl_walk_first(&gateway_tree); \ ++ struct olsrd_avl_node *gw_node, *next_gw_node; \ ++ for (gw_node = olsrd_avl_walk_first(&gateway_tree); \ + gw_node; gw_node = next_gw_node) { \ +- next_gw_node = avl_walk_next(gw_node); \ ++ next_gw_node = olsrd_avl_walk_next(gw_node); \ + gw = node2gateway(gw_node); \ + if (gw) { + #define OLSR_FOR_ALL_GATEWAY_ENTRIES_END(gw) }}} + + /** the gateway tree */ +-extern struct avl_tree gateway_tree; ++extern struct olsrd_avl_tree gateway_tree; + + /** the list IPv4 gateways */ + extern struct gw_list gw_list_ipv4; +--- a/src/kernel_tunnel.h ++++ b/src/kernel_tunnel.h +@@ -55,7 +55,7 @@ + + #include "defs.h" + #include "olsr_types.h" +-#include "common/avl.h" ++#include "common/olsrd_avl.h" + + #define TUNNEL_ENDPOINT_IF "tunl0" + #define TUNNEL_ENDPOINT_IF6 "ip6tnl0" +@@ -67,7 +67,7 @@ + #endif + + struct olsr_iptunnel_entry { +- struct avl_node node; ++ struct olsrd_avl_node node; + union olsr_ip_addr target; + + char if_name[IF_NAMESIZE]; +--- a/src/linux/kernel_tunnel.c ++++ b/src/linux/kernel_tunnel.c +@@ -84,12 +84,12 @@ + + static bool store_iptunnel_state; + static struct olsr_cookie_info *tunnel_cookie; +-static struct avl_tree tunnel_tree; ++static struct olsrd_avl_tree tunnel_tree; + + int olsr_os_init_iptunnel(const char * dev) { + tunnel_cookie = olsr_alloc_cookie("iptunnel", OLSR_COOKIE_TYPE_MEMORY); + olsr_cookie_set_memory_size(tunnel_cookie, sizeof(struct olsr_iptunnel_entry)); +- avl_init(&tunnel_tree, avl_comp_default); ++ olsrd_avl_init(&tunnel_tree, olsrd_avl_comp_default); + + store_iptunnel_state = olsr_if_isup(dev); + if (store_iptunnel_state) { +@@ -107,7 +107,7 @@ void olsr_os_cleanup_iptunnel(const char + struct olsr_iptunnel_entry *t; + + /* kill tunnel */ +- t = (struct olsr_iptunnel_entry *)avl_walk_first(&tunnel_tree); ++ t = (struct olsr_iptunnel_entry *)olsrd_avl_walk_first(&tunnel_tree); + t->usage = 1; + + olsr_os_del_ipip_tunnel(t); +@@ -201,7 +201,7 @@ struct olsr_iptunnel_entry *olsr_os_add_ + + assert(olsr_cnf->ip_version == AF_INET6 || transportV4); + +- t = (struct olsr_iptunnel_entry *)avl_find(&tunnel_tree, target); ++ t = (struct olsr_iptunnel_entry *)olsrd_avl_find(&tunnel_tree, target); + if (t == NULL) { + int if_idx; + struct ipaddr_str buf; +@@ -228,7 +228,7 @@ struct olsr_iptunnel_entry *olsr_os_add_ + strscpy(t->if_name, name, sizeof(t->if_name)); + t->if_index = if_idx; + +- avl_insert(&tunnel_tree, &t->node, AVL_DUP_NO); ++ olsrd_avl_insert(&tunnel_tree, &t->node, OLSRD_AVL_DUP_NO); + } + + t->usage++; +@@ -253,7 +253,7 @@ void olsr_os_del_ipip_tunnel(struct olsr + olsr_if_set_state(t->if_name, false); + os_ip_tunnel(t->if_name, NULL); + +- avl_delete(&tunnel_tree, &t->node); ++ olsrd_avl_delete(&tunnel_tree, &t->node); + olsr_cookie_free(tunnel_cookie, t); + } + #endif /* __linux__ */ +--- a/src/lq_packet.c ++++ b/src/lq_packet.c +@@ -272,16 +272,16 @@ create_lq_tc(struct lq_tc_message *lq_tc + + /* Queue the neighbour entry. */ + +- // TODO: ugly hack until neighbor table is ported to avl tree ++ // TODO: ugly hack until neighbor table is ported to olsrd_avl tree + +- if (lq_tc->neigh == NULL || avl_comp_default(&lq_tc->neigh->address, &neigh->address) > 0) { ++ if (lq_tc->neigh == NULL || olsrd_avl_comp_default(&lq_tc->neigh->address, &neigh->address) > 0) { + neigh->next = lq_tc->neigh; + lq_tc->neigh = neigh; + } else { + struct tc_mpr_addr *last = lq_tc->neigh, *n = last->next; + + while (n) { +- if (avl_comp_default(&n->address, &neigh->address) > 0) { ++ if (olsrd_avl_comp_default(&n->address, &neigh->address) > 0) { + break; + } + last = n; +--- a/src/lq_plugin.c ++++ b/src/lq_plugin.c +@@ -50,7 +50,7 @@ + #include "packet.h" + #include "olsr.h" + #include "two_hop_neighbor_table.h" +-#include "common/avl.h" ++#include "common/olsrd_avl.h" + + #include "lq_plugin_default_float.h" + #include "lq_plugin_default_fpm.h" +@@ -64,17 +64,17 @@ + #include <assert.h> + #include <math.h> + +-struct avl_tree lq_handler_tree; ++struct olsrd_avl_tree lq_handler_tree; + struct lq_handler *active_lq_handler = NULL; + + /** +- * case-insensitive string comparator for avl-trees ++ * case-insensitive string comparator for olsrd_avl-trees + * @param str1 + * @param str2 + * @return + */ + int +-avl_strcasecmp(const void *str1, const void *str2) ++olsrd_avl_strcasecmp(const void *str1, const void *str2) + { + return strcasecmp(str1, str2); + } +@@ -88,7 +88,7 @@ activate_lq_handler(const char *name) + { + struct lq_handler_node *node; + +- node = (struct lq_handler_node *)avl_find(&lq_handler_tree, name); ++ node = (struct lq_handler_node *)olsrd_avl_find(&lq_handler_tree, name); + if (node == NULL) { + char buf[1024]; + snprintf(buf, sizeof(buf), "Error, unknown lq_handler '%s'", name); +@@ -106,7 +106,7 @@ activate_lq_handler(const char *name) + void + init_lq_handler_tree(void) + { +- avl_init(&lq_handler_tree, &avl_strcasecmp); ++ olsrd_avl_init(&lq_handler_tree, &olsrd_avl_strcasecmp); + register_lq_handler(&lq_etx_float_handler, LQ_ALGORITHM_ETX_FLOAT_NAME); + register_lq_handler(&lq_etx_fpm_handler, LQ_ALGORITHM_ETX_FPM_NAME); + register_lq_handler(&lq_etx_ff_handler, LQ_ALGORITHM_ETX_FF_NAME); +@@ -147,7 +147,7 @@ register_lq_handler(struct lq_handler *h + node->node.key = node->name; + node->handler = handler; + +- avl_insert(&lq_handler_tree, &node->node, false); ++ olsrd_avl_insert(&lq_handler_tree, &node->node, false); + } + + /** +--- a/src/lq_plugin.h ++++ b/src/lq_plugin.h +@@ -51,7 +51,7 @@ + #include "olsr_spf.h" + #include "lq_packet.h" + #include "packet.h" +-#include "common/avl.h" ++#include "common/olsrd_avl.h" + + #define LINK_COST_BROKEN (1u<<22) + #define ROUTE_COST_BROKEN (0xffffffffu) +@@ -97,23 +97,23 @@ struct lq_handler { + }; + + struct lq_handler_node { +- struct avl_node node; ++ struct olsrd_avl_node node; + struct lq_handler *handler; + char name[0]; + }; + +-AVLNODE2STRUCT(lq_handler_tree2lq_handler_node, struct lq_handler_node, node); ++OLSRD_AVLNODE2STRUCT(lq_handler_tree2lq_handler_node, struct lq_handler_node, node); + + #define OLSR_FOR_ALL_LQ_HANDLERS(lq) \ + { \ +- struct avl_node *lq_tree_node, *next_lq_tree_node; \ +- for (lq_tree_node = avl_walk_first(&lq_handler_tree); \ ++ struct olsrd_avl_node *lq_tree_node, *next_lq_tree_node; \ ++ for (lq_tree_node = olsrd_avl_walk_first(&lq_handler_tree); \ + lq_tree_node; lq_tree_node = next_lq_tree_node) { \ +- next_lq_tree_node = avl_walk_next(lq_tree_node); \ ++ next_lq_tree_node = olsrd_avl_walk_next(lq_tree_node); \ + lq = lq_handler_tree2lq_handler_node(lq_tree_node); + #define OLSR_FOR_ALL_LQ_HANDLERS_END(tc) }} + +-int avl_strcasecmp(const void *str1, const void *str2); ++int olsrd_avl_strcasecmp(const void *str1, const void *str2); + void init_lq_handler_tree(void); + + void register_lq_handler(struct lq_handler *handler, const char *name); +--- a/src/olsr.c ++++ b/src/olsr.c +@@ -65,7 +65,7 @@ + #include "neighbor_table.h" + #include "log.h" + #include "lq_packet.h" +-#include "common/avl.h" ++#include "common/olsrd_avl.h" + #include "net_olsr.h" + #include "lq_plugin.h" + #include "gateway.h" +@@ -260,13 +260,13 @@ olsr_init_tables(void) + changes_neighborhood = false; + changes_hna = false; + +- /* Set avl tree comparator */ ++ /* Set olsrd_avl tree comparator */ + if (olsr_cnf->ipsize == 4) { +- avl_comp_default = avl_comp_ipv4; +- avl_comp_prefix_default = avl_comp_ipv4_prefix; ++ olsrd_avl_comp_default = olsrd_avl_comp_ipv4; ++ olsrd_avl_comp_prefix_default = olsrd_avl_comp_ipv4_prefix; + } else { +- avl_comp_default = avl_comp_ipv6; +- avl_comp_prefix_default = avl_comp_ipv6_prefix; ++ olsrd_avl_comp_default = olsrd_avl_comp_ipv6; ++ olsrd_avl_comp_prefix_default = olsrd_avl_comp_ipv6_prefix; + } + + /* Initialize lq plugin set */ +--- a/src/olsr_spf.c ++++ b/src/olsr_spf.c +@@ -47,7 +47,7 @@ + * Implementation of Dijkstras algorithm. Initially all nodes + * are initialized to infinite cost. First we put ourselves + * on the heap of reachable nodes. Our heap implementation +- * is based on an AVL tree which gives interesting performance ++ * is based on an OLSRD_AVL tree which gives interesting performance + * characteristics for the frequent operations of minimum key + * extraction and re-keying. Next all neighbors of a node are + * explored and put on the heap if the cost of reaching them is +@@ -67,7 +67,7 @@ + #include "mid_set.h" + #include "hna_set.h" + #include "common/list.h" +-#include "common/avl.h" ++#include "common/olsrd_avl.h" + #include "olsr_spf.h" + #include "net_olsr.h" + #include "lq_plugin.h" +@@ -80,7 +80,7 @@ + struct timer_entry *spf_backoff_timer = NULL; + + /* +- * avl_comp_etx ++ * olsrd_avl_comp_etx + * + * compare two etx metrics. + * return 0 if there is an exact match and +@@ -89,7 +89,7 @@ struct timer_entry *spf_backoff_timer = + * after compiler optimization. + */ + static int +-avl_comp_etx(const void *etx1, const void *etx2) ++olsrd_avl_comp_etx(const void *etx1, const void *etx2) + { + if (*(const olsr_linkcost *)etx1 < *(const olsr_linkcost *)etx2) { + return -1; +@@ -108,7 +108,7 @@ avl_comp_etx(const void *etx1, const voi + * Key an existing vertex to a candidate tree. + */ + static void +-olsr_spf_add_cand_tree(struct avl_tree *tree, struct tc_entry *tc) ++olsr_spf_add_cand_tree(struct olsrd_avl_tree *tree, struct tc_entry *tc) + { + #if !defined(NODEBUG) && defined(DEBUG) + struct ipaddr_str buf; +@@ -121,7 +121,7 @@ olsr_spf_add_cand_tree(struct avl_tree * + get_linkcost_text(tc->path_cost, true, &lqbuffer)); + #endif /* DEBUG */ + +- avl_insert(tree, &tc->cand_tree_node, AVL_DUP); ++ olsrd_avl_insert(tree, &tc->cand_tree_node, OLSRD_AVL_DUP); + } + + /* +@@ -130,7 +130,7 @@ olsr_spf_add_cand_tree(struct avl_tree * + * Unkey an existing vertex from a candidate tree. + */ + static void +-olsr_spf_del_cand_tree(struct avl_tree *tree, struct tc_entry *tc) ++olsr_spf_del_cand_tree(struct olsrd_avl_tree *tree, struct tc_entry *tc) + { + + #ifdef DEBUG +@@ -142,7 +142,7 @@ olsr_spf_del_cand_tree(struct avl_tree * + get_linkcost_text(tc->path_cost, true, &lqbuffer)); + #endif /* DEBUG */ + +- avl_delete(tree, &tc->cand_tree_node); ++ olsrd_avl_delete(tree, &tc->cand_tree_node); + } + + /* +@@ -175,9 +175,9 @@ olsr_spf_add_path_list(struct list_node + * return the node with the minimum pathcost. + */ + static struct tc_entry * +-olsr_spf_extract_best(struct avl_tree *tree) ++olsr_spf_extract_best(struct olsrd_avl_tree *tree) + { +- struct avl_node *node = avl_walk_first(tree); ++ struct olsrd_avl_node *node = olsrd_avl_walk_first(tree); + + return (node ? cand_tree2tc(node) : NULL); + } +@@ -190,9 +190,9 @@ olsr_spf_extract_best(struct avl_tree *t + * path cost is better. + */ + static void +-olsr_spf_relax(struct avl_tree *cand_tree, struct tc_entry *tc) ++olsr_spf_relax(struct olsrd_avl_tree *cand_tree, struct tc_entry *tc) + { +- struct avl_node *edge_node; ++ struct olsrd_avl_node *edge_node; + olsr_linkcost new_cost; + + #ifdef DEBUG +@@ -207,7 +207,7 @@ olsr_spf_relax(struct avl_tree *cand_tre + /* + * loop through all edges of this vertex. + */ +- for (edge_node = avl_walk_first(&tc->edge_tree); edge_node; edge_node = avl_walk_next(edge_node)) { ++ for (edge_node = olsrd_avl_walk_first(&tc->edge_tree); edge_node; edge_node = olsrd_avl_walk_next(edge_node)) { + + struct tc_entry *new_tc; + struct tc_edge_entry *tc_edge = edge_tree2tc_edge(edge_node); +@@ -289,7 +289,7 @@ olsr_spf_relax(struct avl_tree *cand_tre + * on the candidate tree. + */ + static void +-olsr_spf_run_full(struct avl_tree *cand_tree, struct list_node *path_list, int *path_count) ++olsr_spf_run_full(struct olsrd_avl_tree *cand_tree, struct list_node *path_list, int *path_count) + { + struct tc_entry *tc; + +@@ -335,8 +335,8 @@ olsr_calculate_routing_table(bool force) + #ifdef SPF_PROFILING + struct timespec t1, t2, t3, t4, t5, spf_init, spf_run, route, kernel, total; + #endif /* SPF_PROFILING */ +- struct avl_tree cand_tree; +- struct avl_node *rtp_tree_node; ++ struct olsrd_avl_tree cand_tree; ++ struct olsrd_avl_node *rtp_tree_node; + struct list_node path_list; /* head of the path_list */ + struct tc_entry *tc; + struct rt_path *rtp; +@@ -362,7 +362,7 @@ olsr_calculate_routing_table(bool force) + /* + * Prepare the candidate tree and result list. + */ +- avl_init(&cand_tree, avl_comp_etx); ++ olsrd_avl_init(&cand_tree, olsrd_avl_comp_etx); + list_head_init(&path_list); + olsr_bump_routingtree_version(); + +@@ -493,7 +493,7 @@ olsr_calculate_routing_table(bool force) + * If the prefix is already in the RIB, refresh the entry such + * that olsr_delete_outdated_routes() does not purge it off. + */ +- for (rtp_tree_node = avl_walk_first(&tc->prefix_tree); rtp_tree_node; rtp_tree_node = avl_walk_next(rtp_tree_node)) { ++ for (rtp_tree_node = olsrd_avl_walk_first(&tc->prefix_tree); rtp_tree_node; rtp_tree_node = olsrd_avl_walk_next(rtp_tree_node)) { + + rtp = rtp_prefix_tree2rtp(rtp_tree_node); + +--- a/src/process_routes.c ++++ b/src/process_routes.c +@@ -48,7 +48,7 @@ + #include "olsr.h" + #include "log.h" + #include "kernel_routes.h" +-#include "common/avl.h" ++#include "common/olsrd_avl.h" + #include "net_olsr.h" + #include "tc_set.h" + #include "olsr_cookie.h" +@@ -289,13 +289,13 @@ static void + olsr_delete_outdated_routes(struct rt_entry *rt) + { + struct rt_path *rtp; +- struct avl_node *rtp_tree_node, *next_rtp_tree_node; ++ struct olsrd_avl_node *rtp_tree_node, *next_rtp_tree_node; + +- for (rtp_tree_node = avl_walk_first(&rt->rt_path_tree); rtp_tree_node != NULL; rtp_tree_node = next_rtp_tree_node) { ++ for (rtp_tree_node = olsrd_avl_walk_first(&rt->rt_path_tree); rtp_tree_node != NULL; rtp_tree_node = next_rtp_tree_node) { + /* + * pre-fetch the next node before loosing context. + */ +- next_rtp_tree_node = avl_walk_next(rtp_tree_node); ++ next_rtp_tree_node = olsrd_avl_walk_next(rtp_tree_node); + + rtp = rtp_tree2rtp(rtp_tree_node); + +@@ -305,7 +305,7 @@ olsr_delete_outdated_routes(struct rt_en + */ + if (routingtree_version != rtp->rtp_version) { + /* remove from the originator tree */ +- avl_delete(&rt->rt_path_tree, rtp_tree_node); ++ olsrd_avl_delete(&rt->rt_path_tree, rtp_tree_node); + rtp->rtp_rt = NULL; + + if (rt->rt_best == rtp) { +@@ -341,7 +341,7 @@ olsr_update_rib_routes(void) + + if (olsr_delete_kernel_route(rt) == 0) { + /*only remove if deletion was successful*/ +- avl_delete(&routingtree, &rt->rt_tree_node); ++ olsrd_avl_delete(&routingtree, &rt->rt_tree_node); + olsr_cookie_free(rt_mem_cookie, rt); + } + +@@ -370,21 +370,21 @@ olsr_delete_interface_routes(int if_inde + OLSR_FOR_ALL_RT_ENTRIES(rt) { + bool mightTrigger = false; + struct rt_path *rtp; +- struct avl_node *rtp_tree_node, *next_rtp_tree_node; ++ struct olsrd_avl_node *rtp_tree_node, *next_rtp_tree_node; + + /* run through all routing paths of route */ +- for (rtp_tree_node = avl_walk_first(&rt->rt_path_tree); rtp_tree_node != NULL; rtp_tree_node = next_rtp_tree_node) { ++ for (rtp_tree_node = olsrd_avl_walk_first(&rt->rt_path_tree); rtp_tree_node != NULL; rtp_tree_node = next_rtp_tree_node) { + /* + * pre-fetch the next node before loosing context. + */ +- next_rtp_tree_node = avl_walk_next(rtp_tree_node); ++ next_rtp_tree_node = olsrd_avl_walk_next(rtp_tree_node); + + rtp = rtp_tree2rtp(rtp_tree_node); + + /* nexthop use lost interface ? */ + if (rtp->rtp_nexthop.iif_index == if_index) { + /* remove from the originator tree */ +- avl_delete(&rt->rt_path_tree, rtp_tree_node); ++ olsrd_avl_delete(&rt->rt_path_tree, rtp_tree_node); + rtp->rtp_rt = NULL; + + if (rt->rt_best == rtp) { +@@ -397,7 +397,7 @@ olsr_delete_interface_routes(int if_inde + if (mightTrigger) { + if (!rt->rt_path_tree.count) { + /* oops, all routes are gone - flush the route head */ +- avl_delete(&routingtree, rt_tree_node); ++ olsrd_avl_delete(&routingtree, rt_tree_node); + + /* do not dequeue route because they are already gone */ + } +--- a/src/routing_table.c ++++ b/src/routing_table.c +@@ -52,7 +52,7 @@ + #include "neighbor_table.h" + #include "olsr.h" + #include "link_set.h" +-#include "common/avl.h" ++#include "common/olsrd_avl.h" + #include "olsr_spf.h" + #include "net_olsr.h" + +@@ -72,7 +72,7 @@ struct olsr_cookie_info *rtp_mem_cookie + static struct rt_path *current_inetgw = NULL; + + /* Root of our RIB */ +-struct avl_tree routingtree; ++struct olsrd_avl_tree routingtree; + + /* + * Keep a version number for detecting outdated elements +@@ -95,7 +95,7 @@ olsr_bump_routingtree_version(void) + } + + /** +- * avl_comp_ipv4_prefix ++ * olsrd_avl_comp_ipv4_prefix + * + * compare two ipv4 prefixes. + * first compare the prefixes, then +@@ -105,7 +105,7 @@ olsr_bump_routingtree_version(void) + * -1 / +1 depending on being smaller or bigger. + */ + int +-avl_comp_ipv4_prefix(const void *prefix1, const void *prefix2) ++olsrd_avl_comp_ipv4_prefix(const void *prefix1, const void *prefix2) + { + const struct olsr_ip_prefix *pfx1 = prefix1; + const struct olsr_ip_prefix *pfx2 = prefix2; +@@ -132,7 +132,7 @@ avl_comp_ipv4_prefix(const void *prefix1 + } + + /** +- * avl_comp_ipv6_prefix ++ * olsrd_avl_comp_ipv6_prefix + * + * compare two ipv6 prefixes. + * first compare the prefixes, then +@@ -142,7 +142,7 @@ avl_comp_ipv4_prefix(const void *prefix1 + * -1 / +1 depending on being smaller or bigger. + */ + int +-avl_comp_ipv6_prefix(const void *prefix1, const void *prefix2) ++olsrd_avl_comp_ipv6_prefix(const void *prefix1, const void *prefix2) + { + int res; + const struct olsr_ip_prefix *pfx1 = prefix1; +@@ -173,7 +173,7 @@ olsr_init_routing_table(void) + OLSR_PRINTF(5, "RIB: init routing tree\n"); + + /* the routing tree */ +- avl_init(&routingtree, avl_comp_prefix_default); ++ olsrd_avl_init(&routingtree, olsrd_avl_comp_prefix_default); + routingtree_version = 0; + + /* +@@ -197,13 +197,13 @@ olsr_init_routing_table(void) + struct rt_entry * + olsr_lookup_routing_table(const union olsr_ip_addr *dst) + { +- struct avl_node *rt_tree_node; ++ struct olsrd_avl_node *rt_tree_node; + struct olsr_ip_prefix prefix; + + prefix.prefix = *dst; + prefix.prefix_len = olsr_cnf->maxplen; + +- rt_tree_node = avl_find(&routingtree, &prefix); ++ rt_tree_node = olsrd_avl_find(&routingtree, &prefix); + + return rt_tree_node ? rt_tree2rt(rt_tree_node) : NULL; + } +@@ -248,10 +248,10 @@ olsr_alloc_rt_entry(struct olsr_ip_prefi + rt->rt_dst = *prefix; + + rt->rt_tree_node.key = &rt->rt_dst; +- avl_insert(&routingtree, &rt->rt_tree_node, AVL_DUP_NO); ++ olsrd_avl_insert(&routingtree, &rt->rt_tree_node, OLSRD_AVL_DUP_NO); + + /* init the originator subtree */ +- avl_init(&rt->rt_path_tree, avl_comp_default); ++ olsrd_avl_init(&rt->rt_path_tree, olsrd_avl_comp_default); + + return rt; + } +@@ -276,7 +276,7 @@ olsr_alloc_rt_path(struct tc_entry *tc, + rtp->rtp_prefix_tree_node.key = &rtp->rtp_dst; + + /* insert to the tc prefix tree */ +- avl_insert(&tc->prefix_tree, &rtp->rtp_prefix_tree_node, AVL_DUP_NO); ++ olsrd_avl_insert(&tc->prefix_tree, &rtp->rtp_prefix_tree_node, OLSRD_AVL_DUP_NO); + olsr_lock_tc_entry(tc); + + /* backlink to the owning tc entry */ +@@ -296,7 +296,7 @@ void + olsr_insert_rt_path(struct rt_path *rtp, struct tc_entry *tc, struct link_entry *link) + { + struct rt_entry *rt; +- struct avl_node *node; ++ struct olsrd_avl_node *node; + + /* + * no unreachable routes please. +@@ -315,7 +315,7 @@ olsr_insert_rt_path(struct rt_path *rtp, + /* + * first check if there is a route_entry for the prefix. + */ +- node = avl_find(&routingtree, &rtp->rtp_dst); ++ node = olsrd_avl_find(&routingtree, &rtp->rtp_dst); + + if (!node) { + +@@ -337,7 +337,7 @@ olsr_insert_rt_path(struct rt_path *rtp, + rtp->rtp_tree_node.key = &rtp->rtp_originator; + + /* insert to the route entry originator tree */ +- avl_insert(&rt->rt_path_tree, &rtp->rtp_tree_node, AVL_DUP_NO); ++ olsrd_avl_insert(&rt->rt_path_tree, &rtp->rtp_tree_node, OLSRD_AVL_DUP_NO); + + /* backlink to the owning route entry */ + rtp->rtp_rt = rt; +@@ -356,13 +356,13 @@ olsr_delete_rt_path(struct rt_path *rtp) + + /* remove from the originator tree */ + if (rtp->rtp_rt) { +- avl_delete(&rtp->rtp_rt->rt_path_tree, &rtp->rtp_tree_node); ++ olsrd_avl_delete(&rtp->rtp_rt->rt_path_tree, &rtp->rtp_tree_node); + rtp->rtp_rt = NULL; + } + + /* remove from the tc prefix tree */ + if (rtp->rtp_tc) { +- avl_delete(&rtp->rtp_tc->prefix_tree, &rtp->rtp_prefix_tree_node); ++ olsrd_avl_delete(&rtp->rtp_tc->prefix_tree, &rtp->rtp_prefix_tree_node); + olsr_unlock_tc_entry(rtp->rtp_tc); + rtp->rtp_tc = NULL; + } +@@ -498,14 +498,14 @@ void + olsr_rt_best(struct rt_entry *rt) + { + /* grab the first entry */ +- struct avl_node *node = avl_walk_first(&rt->rt_path_tree); ++ struct olsrd_avl_node *node = olsrd_avl_walk_first(&rt->rt_path_tree); + + assert(node != 0); /* should not happen */ + + rt->rt_best = rtp_tree2rtp(node); + + /* walk all remaining originator entries */ +- while ((node = avl_walk_next(node))) { ++ while ((node = olsrd_avl_walk_next(node))) { + struct rt_path *rtp = rtp_tree2rtp(node); + + if (olsr_cmp_rtp(rtp, rt->rt_best, current_inetgw)) { +@@ -541,7 +541,7 @@ olsr_insert_routing_table(union olsr_ip_ + #endif /* DEBUG */ + struct tc_entry *tc; + struct rt_path *rtp; +- struct avl_node *node; ++ struct olsrd_avl_node *node; + struct olsr_ip_prefix prefix; + + /* +@@ -567,7 +567,7 @@ olsr_insert_routing_table(union olsr_ip_ + prefix.prefix = *dst; + prefix.prefix_len = plen; + +- node = avl_find(&tc->prefix_tree, &prefix); ++ node = olsrd_avl_find(&tc->prefix_tree, &prefix); + + if (!node) { + +@@ -604,7 +604,7 @@ olsr_delete_routing_table(union olsr_ip_ + + struct tc_entry *tc; + struct rt_path *rtp; +- struct avl_node *node; ++ struct olsrd_avl_node *node; + struct olsr_ip_prefix prefix; + + /* +@@ -625,7 +625,7 @@ olsr_delete_routing_table(union olsr_ip_ + prefix.prefix = *dst; + prefix.prefix_len = plen; + +- node = avl_find(&tc->prefix_tree, &prefix); ++ node = olsrd_avl_find(&tc->prefix_tree, &prefix); + + if (node) { + rtp = rtp_prefix_tree2rtp(node); +@@ -682,16 +682,16 @@ olsr_rtp_to_string(const struct rt_path + */ + #ifndef NODEBUG + void +-olsr_print_routing_table(struct avl_tree *tree) ++olsr_print_routing_table(struct olsrd_avl_tree *tree) + { + /* The whole function makes no sense without it. */ +- struct avl_node *rt_tree_node; ++ struct olsrd_avl_node *rt_tree_node; + struct lqtextbuffer lqbuffer; + + OLSR_PRINTF(6, "ROUTING TABLE\n"); + +- for (rt_tree_node = avl_walk_first(tree); rt_tree_node != NULL; rt_tree_node = avl_walk_next(rt_tree_node)) { +- struct avl_node *rtp_tree_node; ++ for (rt_tree_node = olsrd_avl_walk_first(tree); rt_tree_node != NULL; rt_tree_node = olsrd_avl_walk_next(rt_tree_node)) { ++ struct olsrd_avl_node *rtp_tree_node; + struct ipaddr_str prefixstr, origstr, gwstr; + struct rt_entry *rt = rt_tree2rt(rt_tree_node); + +@@ -700,7 +700,7 @@ olsr_print_routing_table(struct avl_tree + olsr_ip_to_string(&origstr, &rt->rt_nexthop.gateway), olsr_ip_to_string(&gwstr, &rt->rt_best->rtp_originator)); + + /* walk the per-originator path tree of routes */ +- for (rtp_tree_node = avl_walk_first(&rt->rt_path_tree); rtp_tree_node != NULL; rtp_tree_node = avl_walk_next(rtp_tree_node)) { ++ for (rtp_tree_node = olsrd_avl_walk_first(&rt->rt_path_tree); rtp_tree_node != NULL; rtp_tree_node = olsrd_avl_walk_next(rtp_tree_node)) { + struct rt_path *rtp = rtp_tree2rtp(rtp_tree_node); + OLSR_PRINTF(6, "\tfrom %s, cost %s, metric %u, via %s, %s, v %u\n", olsr_ip_to_string(&origstr, &rtp->rtp_originator), + get_linkcost_text(rtp->rtp_metric.cost, true, &lqbuffer), rtp->rtp_metric.hops, olsr_ip_to_string(&gwstr, +--- a/src/routing_table.h ++++ b/src/routing_table.h +@@ -54,7 +54,7 @@ + #include "hna_set.h" + #include "link_set.h" + #include "olsr_cookie.h" +-#include "common/avl.h" ++#include "common/olsrd_avl.h" + #include "common/list.h" + + #define NETMASK_HOST 0xffffffff +@@ -81,15 +81,15 @@ struct rt_nexthop { + */ + struct rt_entry { + struct olsr_ip_prefix rt_dst; +- struct avl_node rt_tree_node; ++ struct olsrd_avl_node rt_tree_node; + struct rt_path *rt_best; /* shortcut to the best path */ + struct rt_nexthop rt_nexthop; /* nexthop of FIB route */ + struct rt_metric rt_metric; /* metric of FIB route */ +- struct avl_tree rt_path_tree; ++ struct olsrd_avl_tree rt_path_tree; + struct list_node rt_change_node; /* queue for kernel FIB add/chg/del */ + }; + +-AVLNODE2STRUCT(rt_tree2rt, struct rt_entry, rt_tree_node); ++OLSRD_AVLNODE2STRUCT(rt_tree2rt, struct rt_entry, rt_tree_node); + LISTNODE2STRUCT(changelist2rt, struct rt_entry, rt_change_node); + + /* +@@ -105,16 +105,16 @@ struct rt_path { + struct tc_entry *rtp_tc; /* backpointer to owning tc entry */ + struct rt_nexthop rtp_nexthop; + struct rt_metric rtp_metric; +- struct avl_node rtp_tree_node; /* global rtp node */ ++ struct olsrd_avl_node rtp_tree_node; /* global rtp node */ + union olsr_ip_addr rtp_originator; /* originator of the route */ +- struct avl_node rtp_prefix_tree_node; /* tc entry rtp node */ ++ struct olsrd_avl_node rtp_prefix_tree_node; /* tc entry rtp node */ + struct olsr_ip_prefix rtp_dst; /* the prefix */ + uint32_t rtp_version; /* for detection of outdated rt_paths */ + uint8_t rtp_origin; /* internal, MID or HNA */ + }; + +-AVLNODE2STRUCT(rtp_tree2rtp, struct rt_path, rtp_tree_node); +-AVLNODE2STRUCT(rtp_prefix_tree2rtp, struct rt_path, rtp_prefix_tree_node); ++OLSRD_AVLNODE2STRUCT(rtp_tree2rtp, struct rt_path, rtp_tree_node); ++OLSRD_AVLNODE2STRUCT(rtp_prefix_tree2rtp, struct rt_path, rtp_prefix_tree_node); + + /* + * In olsrd we have three different route types. +@@ -143,10 +143,10 @@ enum olsr_rt_origin { + */ + #define OLSR_FOR_ALL_RT_ENTRIES(rt) \ + { \ +- struct avl_node *rt_tree_node, *next_rt_tree_node; \ +- for (rt_tree_node = avl_walk_first(&routingtree); \ ++ struct olsrd_avl_node *rt_tree_node, *next_rt_tree_node; \ ++ for (rt_tree_node = olsrd_avl_walk_first(&routingtree); \ + rt_tree_node; rt_tree_node = next_rt_tree_node) { \ +- next_rt_tree_node = avl_walk_next(rt_tree_node); \ ++ next_rt_tree_node = olsrd_avl_walk_next(rt_tree_node); \ + rt = rt_tree2rt(rt_tree_node); + #define OLSR_FOR_ALL_RT_ENTRIES_END(rt) }} + +@@ -164,10 +164,10 @@ enum olsr_rt_origin { + */ + #define OLSR_FOR_ALL_HNA_RT_ENTRIES(rt) \ + { \ +- struct avl_node *rt_tree_node, *next_rt_tree_node; \ +- for (rt_tree_node = avl_walk_first(&routingtree); \ ++ struct olsrd_avl_node *rt_tree_node, *next_rt_tree_node; \ ++ for (rt_tree_node = olsrd_avl_walk_first(&routingtree); \ + rt_tree_node; rt_tree_node = next_rt_tree_node) { \ +- next_rt_tree_node = avl_walk_next(rt_tree_node); \ ++ next_rt_tree_node = olsrd_avl_walk_next(rt_tree_node); \ + rt = rt_tree2rt(rt_tree_node); \ + if (rt->rt_best->rtp_origin != OLSR_RT_ORIGIN_HNA) \ + continue; +@@ -190,7 +190,7 @@ union olsr_kernel_route { + } v6; + }; + +-extern struct avl_tree routingtree; ++extern struct olsrd_avl_tree routingtree; + extern unsigned int routingtree_version; + extern struct olsr_cookie_info *rt_mem_cookie; + +@@ -198,8 +198,8 @@ void olsr_init_routing_table(void); + + unsigned int olsr_bump_routingtree_version(void); + +-int avl_comp_ipv4_prefix(const void *, const void *); +-int avl_comp_ipv6_prefix(const void *, const void *); ++int olsrd_avl_comp_ipv4_prefix(const void *, const void *); ++int olsrd_avl_comp_ipv6_prefix(const void *, const void *); + + void olsr_rt_best(struct rt_entry *); + bool olsr_nh_change(const struct rt_nexthop *, const struct rt_nexthop *); +@@ -210,7 +210,7 @@ uint8_t olsr_fib_metric(const struct rt_ + char *olsr_rt_to_string(const struct rt_entry *); + char *olsr_rtp_to_string(const struct rt_path *); + #ifndef NODEBUG +-void olsr_print_routing_table(struct avl_tree *); ++void olsr_print_routing_table(struct olsrd_avl_tree *); + #else + #define olsr_print_routing_table(x) do { } while(0) + #endif +--- a/src/scheduler.c ++++ b/src/scheduler.c +@@ -51,7 +51,7 @@ + #include "net_os.h" + #include "mpr_selector_set.h" + #include "olsr_random.h" +-#include "common/avl.h" ++#include "common/olsrd_avl.h" + + #include <sys/times.h> + +@@ -89,29 +89,29 @@ static void poll_sockets(void); + static uint32_t calc_jitter(unsigned int rel_time, uint8_t jitter_pct, unsigned int random_val); + static void olsr_cleanup_timer(struct timer_entry *timer); + +-struct avl_tree timer_cleanup_tree; ++struct olsrd_avl_tree timer_cleanup_tree; + + struct timer_cleanup_entry { +- struct avl_node avl; ++ struct olsrd_avl_node olsrd_avl; + struct timer_entry * timer; + }; + +-/* static INLINE struct timer_cleanup_entry * node2timercleanup(struct avl_node *ptr) */ +-AVLNODE2STRUCT(node2timercleanup, struct timer_cleanup_entry, avl); ++/* static INLINE struct timer_cleanup_entry * node2timercleanup(struct olsrd_avl_node *ptr) */ ++OLSRD_AVLNODE2STRUCT(node2timercleanup, struct timer_cleanup_entry, olsrd_avl); + + /** + * Loop over all timer cleanup entries and put the iterated entry in timer + */ + #define OLSR_FOR_ALL_TIMERS_CLEANUP(timer) \ + { \ +- struct avl_node *timer_avl_node, *timer_avl_node_next; \ +- for (timer_avl_node = avl_walk_first(&timer_cleanup_tree); \ +- timer_avl_node; timer_avl_node = timer_avl_node_next) { \ +- timer_avl_node_next = avl_walk_next(timer_avl_node); \ +- timer = node2timercleanup(timer_avl_node); ++ struct olsrd_avl_node *timer_olsrd_avl_node, *timer_olsrd_avl_node_next; \ ++ for (timer_olsrd_avl_node = olsrd_avl_walk_first(&timer_cleanup_tree); \ ++ timer_olsrd_avl_node; timer_olsrd_avl_node = timer_olsrd_avl_node_next) { \ ++ timer_olsrd_avl_node_next = olsrd_avl_walk_next(timer_olsrd_avl_node); \ ++ timer = node2timercleanup(timer_olsrd_avl_node); + #define OLSR_FOR_ALL_TIMER_CLEANUP_END(timer) }} + +-static int avl_comp_timer(const void *entry1, const void *entry2) { ++static int olsrd_avl_comp_timer(const void *entry1, const void *entry2) { + if (entry1 < entry2) { + return -1; + } +@@ -638,7 +638,7 @@ olsr_init_timers(void) + last_tv = first_tv; + now_times = olsr_times(); + +- avl_init(&timer_cleanup_tree, avl_comp_timer); ++ olsrd_avl_init(&timer_cleanup_tree, olsrd_avl_comp_timer); + + for (idx = 0; idx < TIMER_WHEEL_SLOTS; idx++) { + list_head_init(&timer_wheel[idx]); +@@ -760,7 +760,7 @@ static void walk_timers_cleanup(void) { + + OLSR_FOR_ALL_TIMERS_CLEANUP(timer) { + olsr_cleanup_timer(timer->timer); +- avl_delete(&timer_cleanup_tree, &timer->avl); ++ olsrd_avl_delete(&timer_cleanup_tree, &timer->olsrd_avl); + free(timer); + } OLSR_FOR_ALL_TIMER_CLEANUP_END(slot) + } +@@ -969,9 +969,9 @@ olsr_stop_timer(struct timer_entry *time + + { + struct timer_cleanup_entry * node = olsr_malloc(sizeof(struct timer_cleanup_entry), "timer cleanup entry"); +- node->avl.key = timer; ++ node->olsrd_avl.key = timer; + node->timer = timer; +- if (avl_insert(&timer_cleanup_tree, &node->avl, AVL_DUP_NO) == -1) { ++ if (olsrd_avl_insert(&timer_cleanup_tree, &node->olsrd_avl, OLSRD_AVL_DUP_NO) == -1) { + /* duplicate */ + free(node); + } +--- a/src/tc_set.c ++++ b/src/tc_set.c +@@ -50,7 +50,7 @@ + #include "olsr.h" + #include "scheduler.h" + #include "olsr_spf.h" +-#include "common/avl.h" ++#include "common/olsrd_avl.h" + #include "lq_packet.h" + #include "net_olsr.h" + #include "lq_plugin.h" +@@ -61,7 +61,7 @@ + #include <assert.h> + + /* Root of the link state database */ +-struct avl_tree tc_tree; ++struct olsrd_avl_tree tc_tree; + struct tc_entry *tc_myself; /* Shortcut to ourselves */ + + /* Some cookies for stats keeping */ +@@ -165,14 +165,14 @@ olsr_add_tc_entry(union olsr_ip_addr *ad + /* + * Insert into the global tc tree. + */ +- avl_insert(&tc_tree, &tc->vertex_node, AVL_DUP_NO); ++ olsrd_avl_insert(&tc_tree, &tc->vertex_node, OLSRD_AVL_DUP_NO); + olsr_lock_tc_entry(tc); + + /* + * Initialize subtrees for edges and prefixes. + */ +- avl_init(&tc->edge_tree, avl_comp_default); +- avl_init(&tc->prefix_tree, avl_comp_prefix_default); ++ olsrd_avl_init(&tc->edge_tree, olsrd_avl_comp_default); ++ olsrd_avl_init(&tc->prefix_tree, olsrd_avl_comp_prefix_default); + + /* + * Add a rt_path for ourselves. +@@ -191,7 +191,7 @@ olsr_init_tc(void) + { + OLSR_PRINTF(5, "TC: init topo\n"); + +- avl_init(&tc_tree, avl_comp_default); ++ olsrd_avl_init(&tc_tree, olsrd_avl_comp_default); + + /* + * Get some cookies for getting stats to ease troubleshooting. +@@ -308,7 +308,7 @@ olsr_delete_tc_entry(struct tc_entry *tc + olsr_stop_timer(tc->validity_timer); + tc->validity_timer = NULL; + +- avl_delete(&tc_tree, &tc->vertex_node); ++ olsrd_avl_delete(&tc_tree, &tc->vertex_node); + olsr_unlock_tc_entry(tc); + } + +@@ -321,9 +321,9 @@ olsr_delete_tc_entry(struct tc_entry *tc + struct tc_entry * + olsr_lookup_tc_entry(union olsr_ip_addr *adr) + { +- struct avl_node *node; ++ struct olsrd_avl_node *node; + +- node = avl_find(&tc_tree, adr); ++ node = olsrd_avl_find(&tc_tree, adr); + + return (node ? vertex_tree2tc(node) : NULL); + } +@@ -454,7 +454,7 @@ olsr_add_tc_edge_entry(struct tc_entry * + /* + * Insert into the edge tree. + */ +- avl_insert(&tc->edge_tree, &tc_edge->edge_node, AVL_DUP_NO); ++ olsrd_avl_insert(&tc->edge_tree, &tc_edge->edge_node, OLSRD_AVL_DUP_NO); + olsr_lock_tc_entry(tc); + + /* +@@ -515,7 +515,7 @@ olsr_delete_tc_edge_entry(struct tc_edge + #endif /* DEBUG */ + + tc = tc_edge->tc; +- avl_delete(&tc->edge_tree, &tc_edge->edge_node); ++ olsrd_avl_delete(&tc->edge_tree, &tc_edge->edge_node); + olsr_unlock_tc_entry(tc); + + /* +@@ -572,7 +572,7 @@ olsr_delete_revoked_tc_edges(struct tc_e + + OLSR_FOR_ALL_TC_EDGE_ENTRIES(tc, tc_edge) { + if (!passedLowerBorder) { +- if (avl_comp_default(lower_border, &tc_edge->T_dest_addr) <= 0) { ++ if (olsrd_avl_comp_default(lower_border, &tc_edge->T_dest_addr) <= 0) { + passedLowerBorder = true; + } else { + continue; +@@ -580,7 +580,7 @@ olsr_delete_revoked_tc_edges(struct tc_e + } + + if (passedLowerBorder) { +- if (avl_comp_default(upper_border, &tc_edge->T_dest_addr) <= 0) { ++ if (olsrd_avl_comp_default(upper_border, &tc_edge->T_dest_addr) <= 0) { + break; + } + } +@@ -680,9 +680,9 @@ olsr_tc_update_edge(struct tc_entry *tc, + struct tc_edge_entry * + olsr_lookup_tc_edge(struct tc_entry *tc, union olsr_ip_addr *edge_addr) + { +- struct avl_node *edge_node; ++ struct olsrd_avl_node *edge_node; + +- edge_node = avl_find(&tc->edge_tree, edge_addr); ++ edge_node = olsrd_avl_find(&tc->edge_tree, edge_addr); + + return (edge_node ? edge_tree2tc_edge(edge_node) : NULL); + } +--- a/src/tc_set.h ++++ b/src/tc_set.h +@@ -48,7 +48,7 @@ + + #include "defs.h" + #include "packet.h" +-#include "common/avl.h" ++#include "common/olsrd_avl.h" + #include "common/list.h" + #include "scheduler.h" + +@@ -60,7 +60,7 @@ + */ + + struct tc_edge_entry { +- struct avl_node edge_node; /* edge_tree node in tc_entry */ ++ struct olsrd_avl_node edge_node; /* edge_tree node in tc_entry */ + union olsr_ip_addr T_dest_addr; /* edge_node key */ + struct tc_edge_entry *edge_inv; /* shortcut, used during SPF calculation */ + struct tc_entry *tc; /* backpointer to owning tc entry */ +@@ -69,16 +69,16 @@ struct tc_edge_entry { + uint32_t linkquality[0]; + }; + +-AVLNODE2STRUCT(edge_tree2tc_edge, struct tc_edge_entry, edge_node); ++OLSRD_AVLNODE2STRUCT(edge_tree2tc_edge, struct tc_edge_entry, edge_node); + + struct tc_entry { +- struct avl_node vertex_node; /* node keyed by ip address */ ++ struct olsrd_avl_node vertex_node; /* node keyed by ip address */ + union olsr_ip_addr addr; /* vertex_node key */ +- struct avl_node cand_tree_node; /* SPF candidate heap, node keyed by path_etx */ ++ struct olsrd_avl_node cand_tree_node; /* SPF candidate heap, node keyed by path_etx */ + olsr_linkcost path_cost; /* SPF calculated distance, cand_tree_node key */ + struct list_node path_list_node; /* SPF result list */ +- struct avl_tree edge_tree; /* subtree for edges */ +- struct avl_tree prefix_tree; /* subtree for prefixes */ ++ struct olsrd_avl_tree edge_tree; /* subtree for edges */ ++ struct olsrd_avl_tree prefix_tree; /* subtree for prefixes */ + struct link_entry *next_hop; /* SPF calculated link to the 1st hop neighbor */ + struct timer_entry *edge_gc_timer; /* used for edge garbage collection */ + struct timer_entry *validity_timer; /* tc validity time */ +@@ -102,8 +102,8 @@ struct tc_entry { + + #define OLSR_TC_VTIME_JITTER 5 /* percent */ + +-AVLNODE2STRUCT(vertex_tree2tc, struct tc_entry, vertex_node); +-AVLNODE2STRUCT(cand_tree2tc, struct tc_entry, cand_tree_node); ++OLSRD_AVLNODE2STRUCT(vertex_tree2tc, struct tc_entry, vertex_node); ++OLSRD_AVLNODE2STRUCT(cand_tree2tc, struct tc_entry, cand_tree_node); + LISTNODE2STRUCT(pathlist2tc, struct tc_entry, path_list_node); + + /* +@@ -116,32 +116,32 @@ LISTNODE2STRUCT(pathlist2tc, struct tc_e + */ + #define OLSR_FOR_ALL_TC_ENTRIES(tc) \ + { \ +- struct avl_node *tc_tree_node, *next_tc_tree_node; \ +- for (tc_tree_node = avl_walk_first(&tc_tree); \ ++ struct olsrd_avl_node *tc_tree_node, *next_tc_tree_node; \ ++ for (tc_tree_node = olsrd_avl_walk_first(&tc_tree); \ + tc_tree_node; tc_tree_node = next_tc_tree_node) { \ +- next_tc_tree_node = avl_walk_next(tc_tree_node); \ ++ next_tc_tree_node = olsrd_avl_walk_next(tc_tree_node); \ + tc = vertex_tree2tc(tc_tree_node); + #define OLSR_FOR_ALL_TC_ENTRIES_END(tc) }} + + #define OLSR_FOR_ALL_TC_EDGE_ENTRIES(tc, tc_edge) \ + { \ +- struct avl_node *tc_edge_node, *next_tc_edge_node; \ +- for (tc_edge_node = avl_walk_first(&tc->edge_tree); \ ++ struct olsrd_avl_node *tc_edge_node, *next_tc_edge_node; \ ++ for (tc_edge_node = olsrd_avl_walk_first(&tc->edge_tree); \ + tc_edge_node; tc_edge_node = next_tc_edge_node) { \ +- next_tc_edge_node = avl_walk_next(tc_edge_node); \ ++ next_tc_edge_node = olsrd_avl_walk_next(tc_edge_node); \ + tc_edge = edge_tree2tc_edge(tc_edge_node); + #define OLSR_FOR_ALL_TC_EDGE_ENTRIES_END(tc, tc_edge) }} + + #define OLSR_FOR_ALL_PREFIX_ENTRIES(tc, rtp) \ + { \ +- struct avl_node *rtp_node, *next_rtp_node; \ +- for (rtp_node = avl_walk_first(&tc->prefix_tree); \ ++ struct olsrd_avl_node *rtp_node, *next_rtp_node; \ ++ for (rtp_node = olsrd_avl_walk_first(&tc->prefix_tree); \ + rtp_node; rtp_node = next_rtp_node) { \ +- next_rtp_node = avl_walk_next(rtp_node); \ ++ next_rtp_node = olsrd_avl_walk_next(rtp_node); \ + rtp = rtp_prefix_tree2rtp(rtp_node); + #define OLSR_FOR_ALL_PREFIX_ENTRIES_END(tc, rtp) }} + +-extern struct avl_tree tc_tree; ++extern struct olsrd_avl_tree tc_tree; + extern struct tc_entry *tc_myself; + + void olsr_init_tc(void); diff --git a/olsrd/patches/101-unix-fix-meshing-with-wireguard-point-to-point-interfaces.patch b/olsrd/patches/101-unix-fix-meshing-with-wireguard-point-to-point-interfaces.patch new file mode 100644 index 0000000..caca877 --- /dev/null +++ b/olsrd/patches/101-unix-fix-meshing-with-wireguard-point-to-point-interfaces.patch @@ -0,0 +1,38 @@ +From fcb30aa4da732d279527feba01cacc7dc996d137 Mon Sep 17 00:00:00 2001 +From: Nick Hainke <vincent@systemli.org> +Date: Sun, 16 Jan 2022 00:08:56 +0100 +Subject: [PATCH] unix: fix meshing with wireguard/point-to-point interfaces + +Wireguard interfaces have no BROADCAST flag. We can also mesh on +point-to-point links. That is why we mesh now also on interfaces with +the IFF_POINTOPOINT flag enabled. + +Signed-off-by: Nick Hainke <vincent@systemli.org> +--- + src/unix/ifnet.c | 8 ++++---- + 1 file changed, 4 insertions(+), 4 deletions(-) + +--- a/src/unix/ifnet.c ++++ b/src/unix/ifnet.c +@@ -184,8 +184,8 @@ chk_if_changed(struct olsr_if *iface) + + /* Check broadcast */ + if ((olsr_cnf->ip_version == AF_INET) && !iface->cnf->ipv4_multicast.v4.s_addr && /* Skip if fixed bcast */ +- (!(ifp->int_flags & IFF_BROADCAST))) { +- OLSR_PRINTF(3, "\tNo broadcast - removing\n"); ++ ((!(ifp->int_flags & IFF_BROADCAST) && !(ifp->int_flags & IFF_POINTOPOINT)))) { ++ OLSR_PRINTF(3, "\tNo broadcast or point-to-point - removing\n"); + goto remove_interface; + } + +@@ -552,8 +552,8 @@ chk_if_up(struct olsr_if *iface, int deb + + /* Check broadcast */ + if ((olsr_cnf->ip_version == AF_INET) && !iface->cnf->ipv4_multicast.v4.s_addr && /* Skip if fixed bcast */ +- (!(ifs.int_flags & IFF_BROADCAST))) { +- OLSR_PRINTF(debuglvl, "\tNo broadcast - skipping\n"); ++ (!(ifs.int_flags & IFF_BROADCAST) && !(ifs.int_flags & IFF_POINTOPOINT))) { ++ OLSR_PRINTF(debuglvl, "\tNo broadcast or point-to-point - skipping\n"); + return 0; + } + diff --git a/olsrd/patches/102-olsrd-prevent-storm-patches.patch b/olsrd/patches/102-olsrd-prevent-storm-patches.patch new file mode 100644 index 0000000..69d5952 --- /dev/null +++ b/olsrd/patches/102-olsrd-prevent-storm-patches.patch @@ -0,0 +1,83 @@ +From 4dabd94d598dd893aaaffbd71c315923c8827a14 Mon Sep 17 00:00:00 2001 +From: Nick Hainke <vincent@systemli.org> +Date: Wed, 22 Jun 2022 14:08:04 +0200 +Subject: [PATCH] olsrd: prevent storm patches + +As described in the PR: + + Limit the positive sequence number difference which is considered valid, + and prevent network storms. + Source: https://github.com/aredn/aredn_packages/pull/5 + +Signed-off-by: Nick Hainke <vincent@systemli.org> +--- + src/duplicate_set.c | 16 ++++++++-------- + src/duplicate_set.h | 5 +++-- + 2 files changed, 11 insertions(+), 10 deletions(-) + +--- a/src/duplicate_set.c ++++ b/src/duplicate_set.c +@@ -70,7 +70,7 @@ void olsr_cleanup_duplicates(union olsr_ + + entry = (struct dup_entry *)olsrd_avl_find(&duplicate_set, orig); + if (entry != NULL) { +- entry->too_low_counter = DUP_MAX_TOO_LOW - 2; ++ entry->out_of_bounds_counter = DUP_MAX_OUT_OF_BOUNDS - 2; + } + } + +@@ -82,7 +82,7 @@ olsr_create_duplicate_entry(void *ip, ui + if (entry != NULL) { + memcpy(&entry->ip, ip, olsr_cnf->ip_version == AF_INET ? sizeof(entry->ip.v4) : sizeof(entry->ip.v6)); + entry->seqnr = seqnr; +- entry->too_low_counter = 0; ++ entry->out_of_bounds_counter = 0; + entry->olsrd_avl.key = &entry->ip; + entry->array = 0; + } +@@ -160,12 +160,12 @@ olsr_message_is_duplicate(union olsr_mes + } + + diff = olsr_seqno_diff(seqnr, entry->seqnr); +- if (diff < -31) { +- entry->too_low_counter++; ++ if (diff < -31 || diff > DUP_SEQNR_DIFF_HIGH_LIMIT) { ++ entry->out_of_bounds_counter++; + +- // client did restart with a lower number ? +- if (entry->too_low_counter > DUP_MAX_TOO_LOW) { +- entry->too_low_counter = 0; ++ // client did restart with a too low or too high number ? ++ if (entry->out_of_bounds_counter > DUP_MAX_OUT_OF_BOUNDS) { ++ entry->out_of_bounds_counter = 0; + entry->seqnr = seqnr; + entry->array = 1; + return false; /* start with a new sequence number, so NO duplicate */ +@@ -174,7 +174,7 @@ olsr_message_is_duplicate(union olsr_mes + return true; /* duplicate ! */ + } + +- entry->too_low_counter = 0; ++ entry->out_of_bounds_counter = 0; + if (diff <= 0) { + uint32_t bitmask = 1u << ((uint32_t) (-diff)); + +--- a/src/duplicate_set.h ++++ b/src/duplicate_set.h +@@ -54,13 +54,14 @@ + #define DUPLICATE_CLEANUP_INTERVAL 15000 + #define DUPLICATE_CLEANUP_JITTER 25 + #define DUPLICATE_VTIME 120000 +-#define DUP_MAX_TOO_LOW 16 ++#define DUP_MAX_OUT_OF_BOUNDS 16 ++#define DUP_SEQNR_DIFF_HIGH_LIMIT 0x2000 + + struct dup_entry { + struct olsrd_avl_node olsrd_avl; + union olsr_ip_addr ip; + uint16_t seqnr; +- uint16_t too_low_counter; ++ uint16_t out_of_bounds_counter; + uint32_t array; + uint32_t valid_until; + }; diff --git a/olsrd/patches/600-add-ubus-support.patch b/olsrd/patches/600-add-ubus-support.patch new file mode 100644 index 0000000..c43e78d --- /dev/null +++ b/olsrd/patches/600-add-ubus-support.patch @@ -0,0 +1,60 @@ +--- a/src/scheduler.c ++++ b/src/scheduler.c +@@ -59,6 +59,8 @@ + #include <assert.h> + #include <time.h> + ++#include "ubus.h" ++ + #ifdef __MACH__ + #include "mach/clock_gettime.h" + #endif +@@ -363,6 +365,8 @@ poll_sockets(void) + } + OLSR_FOR_ALL_SOCKETS_END(entry); + ++ hfd = olsrd_ubus_add_read_sock(&ibits, hfd); ++ + /* Running select on the FD set */ + do { + n = olsr_select(hfd, fdsets & SP_PR_READ ? &ibits : NULL, fdsets & SP_PR_WRITE ? &obits : NULL, NULL, &tvp); +@@ -395,6 +399,7 @@ poll_sockets(void) + } + } + OLSR_FOR_ALL_SOCKETS_END(entry); ++ olsrd_ubus_receive(&ibits); + } + + static void +--- a/src/main.c ++++ b/src/main.c +@@ -74,6 +74,8 @@ + #include "lock_file.h" + #include "cli.h" + ++#include "ubus.h" ++ + #if defined(__GLIBC__) && defined(__linux__) && !defined(__ANDROID__) && !defined(__UCLIBC__) + #define OLSR_HAVE_EXECINFO_H + #endif +@@ -771,6 +773,9 @@ int main(int argc, char *argv[]) { + signal(SIGUSR2, SIG_IGN); + #endif /* _WIN32 */ + ++ /* Adding ubus */ ++ olsrd_add_ubus(); ++ + /* Starting scheduler */ + olsr_scheduler(); + +--- a/Makefile.inc ++++ b/Makefile.inc +@@ -252,7 +252,7 @@ else + ifeq ($(OS),win32) + LDFLAGS += -Wl,-export-all-symbols + else +- LDFLAGS += -Wl,-export-dynamic ++ LDFLAGS += -Wl,-export-dynamic,-lubus,-lubox + endif + ifeq ($(NORPATH),0) + LDFLAGS += -Wl,-rpath,$(LIBDIR) diff --git a/olsrd/src/src/ubus.c b/olsrd/src/src/ubus.c new file mode 100644 index 0000000..37c2dbf --- /dev/null +++ b/olsrd/src/src/ubus.c @@ -0,0 +1,229 @@ +#include <stdbool.h> +#include <stdint.h> +#include <stdlib.h> +#include <sys/select.h> + +#include <libubox/blob.h> +#include <libubox/blobmsg.h> +#include <libubus.h> + +#include <arpa/inet.h> +#include <net/if.h> +#include <netinet/in.h> +#include <sys/ioctl.h> +#include <sys/socket.h> + +#include "defs.h" +#include "ifnet.h" +#include "interfaces.h" +#include "link_set.h" +#include "log.h" +#include "olsr.h" +#include "olsr_cfg.h" + +#include "ubus.h" + +#define MAX(a, b) ((a) > (b) ? (a) : (b)) +#define MIN(a, b) ((a) < (b) ? (a) : (b)) + +// Shared state maintained throughout calls to handle ubus messages. +static struct ubus_context *shared_ctx; + +enum { INTERFACE_IFNAME, INTERFACE_LQM, __INTERFACE_MAX }; + +static const struct blobmsg_policy interface_policy[__INTERFACE_MAX] = { + [INTERFACE_IFNAME] = {"ifname", BLOBMSG_TYPE_STRING}, + [INTERFACE_LQM] = {"lqm", BLOBMSG_TYPE_STRING}, +}; + +static int olsrd_ubus_add_interface(struct ubus_context *ctx_local, + struct ubus_object *obj, + struct ubus_request_data *req, + const char *method, struct blob_attr *msg) { + struct blob_attr *tb[__INTERFACE_MAX]; + struct blob_buf b = {0}; + union olsr_ip_addr addr; + int ret; + char *ifname, *lqm; + + blobmsg_parse(interface_policy, __INTERFACE_MAX, tb, blob_data(msg), + blob_len(msg)); + + if (!tb[INTERFACE_IFNAME]) + return UBUS_STATUS_INVALID_ARGUMENT; + + ifname = blobmsg_get_string(tb[INTERFACE_IFNAME]); + + struct interface_olsr *tmp = if_ifwithname(ifname); + if (tmp != NULL) { + return UBUS_STATUS_PERMISSION_DENIED; + } + + struct olsr_if *temp; + for (temp = olsr_cnf->interfaces; temp != NULL; temp = temp->next) { + if (strcmp(temp->name, ifname) == 0) + return UBUS_STATUS_PERMISSION_DENIED; + } + + struct olsr_if *tmp_ifs = olsr_create_olsrif(ifname, false); + tmp_ifs->cnf = + olsr_malloc(sizeof(struct if_config_options), "Set default config"); + *tmp_ifs->cnf = *olsr_cnf->interface_defaults; + + if (tb[INTERFACE_LQM]) { // add interface lqm + lqm = blobmsg_get_string(tb[INTERFACE_LQM]); + memset(&addr, 0, sizeof(addr)); + + struct olsr_lq_mult *mult = malloc(sizeof(*mult)); + if (mult == NULL) { + olsr_syslog(OLSR_LOG_ERR, "Out of memory (LQ multiplier).\n"); + return UBUS_STATUS_UNKNOWN_ERROR; + } + + double lqm_value = atof(lqm); + mult->addr = addr; + mult->value = (uint32_t)(lqm_value * LINK_LOSS_MULTIPLIER); + tmp_ifs->cnf->lq_mult = mult; + tmp_ifs->cnf->orig_lq_mult_cnt++; + } + + blob_buf_init(&b, 0); + blobmsg_add_string(&b, "adding", ifname); + + ret = ubus_send_reply(ctx_local, req, b.head); + if (ret) + olsr_syslog(OLSR_LOG_ERR, "Failed to send reply: %s\n", ubus_strerror(ret)); + + blob_buf_free(&b); + + return ret; +} + +static int olsrd_ubus_del_interface(struct ubus_context *ctx_local, + struct ubus_object *obj, + struct ubus_request_data *req, + const char *method, struct blob_attr *msg) { + struct blob_attr *tb[__INTERFACE_MAX]; + struct blob_buf b = {0}; + int ret; + char *ifname; + struct olsr_if *tmp_if, *del_if; + + blobmsg_parse(interface_policy, __INTERFACE_MAX, tb, blob_data(msg), + blob_len(msg)); + + if (!tb[INTERFACE_IFNAME]) + return UBUS_STATUS_INVALID_ARGUMENT; + + ifname = blobmsg_get_string(tb[INTERFACE_IFNAME]); + + struct interface_olsr *tmp = if_ifwithname(ifname); + + if (tmp != NULL) { + + struct olsr_if *temp = olsr_cnf->interfaces, *prev; + if (temp != NULL && (strcmp(temp->name, ifname) == 0)) { + olsr_cnf->interfaces = temp->next; + olsr_remove_interface(temp); + goto send_reply; + } + + while (temp != NULL && (strcmp(temp->name, ifname) != 0)) { + prev = temp; + temp = temp->next; + } + + if (temp == NULL) { + goto send_reply; + } + + prev->next = temp->next; + olsr_remove_interface(temp); + } else { + return UBUS_STATUS_PERMISSION_DENIED; + } + +send_reply: + + blob_buf_init(&b, 0); + blobmsg_add_string(&b, "deleting", ifname); + + ret = ubus_send_reply(ctx_local, req, b.head); + if (ret) + olsr_syslog(OLSR_LOG_ERR, "Failed to send reply: %s\n", ubus_strerror(ret)); + + blob_buf_free(&b); + + return ret; +} + +// List of functions we expose via the ubus bus. +static const struct ubus_method olsrd_methods[] = { + UBUS_METHOD("add_interface", olsrd_ubus_add_interface, interface_policy), + UBUS_METHOD("del_interface", olsrd_ubus_del_interface, interface_policy), +}; + +// Definition of the ubus object type. +static struct ubus_object_type olsrd_object_type = + UBUS_OBJECT_TYPE("olsrd", olsrd_methods); + +// Object we announce via the ubus bus. +static struct ubus_object olsrd_object = { + .name = "olsrd", + .type = &olsrd_object_type, + .methods = olsrd_methods, + .n_methods = ARRAY_SIZE(olsrd_methods), +}; + +// Registers handlers for olsrd methods in the global ubus context. +static bool ubus_init_object() { + int ret; + + ret = ubus_add_object(shared_ctx, &olsrd_object); + if (ret) { + olsr_syslog(OLSR_LOG_ERR, "Failed to add object: %s\n", ubus_strerror(ret)); + return false; + } + + return true; +} + +// Initializes the global ubus context, connecting to the bus to be able to +// receive and send messages. +static bool olsrd_ubus_init(void) { + if (shared_ctx) + return true; + + shared_ctx = ubus_connect(NULL); + if (!shared_ctx) + return false; + + return true; +} + +void olsrd_ubus_receive(fd_set *readfds) { + if (!shared_ctx) + return; + if (FD_ISSET(shared_ctx->sock.fd, readfds)) + ubus_handle_event(shared_ctx); +} + +int olsrd_ubus_add_read_sock(fd_set *readfds, int maxfd) { + if (!shared_ctx) + return maxfd; + + FD_SET(shared_ctx->sock.fd, readfds); + return MAX(maxfd, shared_ctx->sock.fd + 1); +} + +bool olsrd_add_ubus() { + if (!olsrd_ubus_init()) { + olsr_syslog(OLSR_LOG_ERR, "Failed to initialize ubus!\n"); + return false; + } + if (!ubus_init_object()) { + olsr_syslog(OLSR_LOG_ERR, "Failed to add objects to ubus!\n"); + return false; + } + return true; +} diff --git a/olsrd/src/src/ubus.h b/olsrd/src/src/ubus.h new file mode 100644 index 0000000..10bd59f --- /dev/null +++ b/olsrd/src/src/ubus.h @@ -0,0 +1,40 @@ +/* + IPC integration of olsrd with OpenWrt. + + The ubus interface offers following functions: + - add_inteface '{"ifname":"wg_51820", "lqm": "0.5"}' + - del_inteface '{"ifname":"wg_51820"}' +*/ + +#include <stdbool.h> +#include <sys/select.h> + +/** + * Initialize ubus interface. + * + * Connect to the ubus daemon and expose the ubus functions. + * + * @return if initializing ubus was successful + */ +bool olsrd_add_ubus(); + +/** + * Add ubus socket to given filedescriptor set. + * + * We need to check repeatedly if the ubus socket has something to read. + * The functions allows to add the ubus socket to the normal while(1)-loop of + * olsrd. + * + * @param readfs: the filedescriptor set + * @param maxfd: the current maximum file descriptor + * @return the maximum file descriptor + */ +int olsrd_ubus_add_read_sock(fd_set *readfds, int maxfd); + +/** + * Check and process ubus socket. + * + * If the ubus-socket signals that data is available, the ubus_handle_event is + * called. + */ +void olsrd_ubus_receive(fd_set *readfds); diff --git a/oonf-dlep-proxy/Makefile b/oonf-dlep-proxy/Makefile index 3fcb8fc..6a27005 100644 --- a/oonf-dlep-proxy/Makefile +++ b/oonf-dlep-proxy/Makefile @@ -10,24 +10,25 @@ PKG_SOURCE_URL:=https://github.com/OLSR/OONF.git PKG_SOURCE_PROTO:=git PKG_SOURCE_SUBDIR:=$(PKG_NAME)-$(PKG_VERSION) PKG_SOURCE_VERSION:=$(PKG_REV) +PKG_MIRROR_HASH:=a5413418b7ab1665758f883a652ff589de6a78ccf9201d29bc13f372cb9adeb0 CMAKE_INSTALL:=1 include $(INCLUDE_DIR)/package.mk include $(INCLUDE_DIR)/cmake.mk -CMAKE_OPTIONS=-D OONF_NO_WERROR:Bool=true \ - -D OONF_LOGGING_LEVEL:String=debug \ - -D OONF_NO_TESTING:Bool=true \ - -D UCI:Bool=true \ - -D OONF_APP_DEFAULT_CFG_HANDLER:String=uci \ - -D OONF_STATIC_PLUGINS:String="class;clock;layer2;packet_socket;socket;stream_socket;telnet;timer;viewer;os_clock;os_fd;os_interface;os_system;nl80211_listener;layer2info;systeminfo;cfg_uciloader;cfg_compact;dlep_proxy" \ - -D OONF_LIB_GIT:String=v$(PKG_VERSION)-archive \ - -D OONF_VERSION:String=$(PKG_VERSION) \ - -D INSTALL_LIB_DIR:Path=lib/oonf \ - -D INSTALL_INCLUDE_DIR:Path=include/oonf \ - -D INSTALL_CMAKE_DIR:Path=lib/oonf \ - -D CMAKE_PREFIX_PATH=$(STAGING_DIR)/usr +CMAKE_OPTIONS+=-D OONF_NO_WERROR:Bool=true \ + -D OONF_LOGGING_LEVEL:String=debug \ + -D OONF_NO_TESTING:Bool=true \ + -D UCI:Bool=true \ + -D OONF_APP_DEFAULT_CFG_HANDLER:String=uci \ + -D OONF_STATIC_PLUGINS:String="class;clock;layer2;packet_socket;socket;stream_socket;telnet;timer;viewer;os_clock;os_fd;os_interface;os_system;nl80211_listener;layer2info;systeminfo;cfg_uciloader;cfg_compact;dlep_proxy" \ + -D OONF_LIB_GIT:String=v$(PKG_VERSION)-archive \ + -D OONF_VERSION:String=$(PKG_VERSION) \ + -D INSTALL_LIB_DIR:Path=lib/oonf \ + -D INSTALL_INCLUDE_DIR:Path=include/oonf \ + -D INSTALL_CMAKE_DIR:Path=lib/oonf \ + -D CMAKE_PREFIX_PATH=$(STAGING_DIR)/usr define Package/oonf-git/template SECTION:=net diff --git a/oonf-dlep-radio/Makefile b/oonf-dlep-radio/Makefile index e2cdc4d..b195b88 100644 --- a/oonf-dlep-radio/Makefile +++ b/oonf-dlep-radio/Makefile @@ -1,47 +1,42 @@ include $(TOPDIR)/rules.mk PKG_NAME:=oonf-dlep-radio -PKG_VERSION:=v0.15.1 -PKG_REV:=bffb88b040659b237c4c91b6b42dbbb47431750e -PKG_RELEASE:=$(PKG_REV) +PKG_VERSION:=0.15.1 +PKG_RELEASE:=$(AUTORELEASE) -PKG_SOURCE:=$(PKG_NAME)-$(PKG_VERSION).tar.bz2 -PKG_SOURCE_URL:=https://github.com/OLSR/OONF.git PKG_SOURCE_PROTO:=git -PKG_SOURCE_SUBDIR:=$(PKG_NAME)-$(PKG_VERSION) -PKG_SOURCE_VERSION:=$(PKG_REV) +PKG_SOURCE_URL:=https://github.com/OLSR/OONF.git +PKG_SOURCE_DATE:=2018-03-19 +PKG_SOURCE_VERSION:=bffb88b040659b237c4c91b6b42dbbb47431750e +PKG_MIRROR_HASH:=c85bf1e38483979f44486b6ad90800535fc7039a162c536c239d897b7c68ef70 + +PKG_MAINTAINER:=Henning Rogge <hrogge@gmail.com> CMAKE_INSTALL:=1 include $(INCLUDE_DIR)/package.mk include $(INCLUDE_DIR)/cmake.mk -CMAKE_OPTIONS=-D OONF_NO_WERROR:Bool=true \ - -D OONF_LOGGING_LEVEL:String=debug \ - -D OONF_NO_TESTING:Bool=true \ - -D UCI:Bool=true \ - -D OONF_APP_DEFAULT_CFG_HANDLER:String=uci \ - -D OONF_STATIC_PLUGINS:String="class;clock;layer2;packet_socket;socket;stream_socket;telnet;timer;viewer;os_clock;os_fd;os_interface;os_system;nl80211_listener;layer2info;systeminfo;cfg_uciloader;cfg_compact;dlep_radio" \ - -D OONF_LIB_GIT:String=v$(PKG_VERSION)-archive \ - -D OONF_VERSION:String=$(PKG_VERSION) \ - -D INSTALL_LIB_DIR:Path=lib/oonf \ - -D INSTALL_INCLUDE_DIR:Path=include/oonf \ - -D INSTALL_CMAKE_DIR:Path=lib/oonf \ - -D CMAKE_PREFIX_PATH=$(STAGING_DIR)/usr - -define Package/oonf-git/template - SECTION:=net - CATEGORY:=Network - MAINTAINER:=Henning Rogge <hrogge@gmail.com> - SUBMENU:=OLSR.org network framework - URL:=http://www.olsr.org/ -endef +CMAKE_OPTIONS+=-D OONF_NO_WERROR:Bool=true \ + -D OONF_LOGGING_LEVEL:String=debug \ + -D OONF_NO_TESTING:Bool=true \ + -D UCI:Bool=true \ + -D OONF_APP_DEFAULT_CFG_HANDLER:String=uci \ + -D OONF_STATIC_PLUGINS:String="class;clock;layer2;packet_socket;socket;stream_socket;telnet;timer;viewer;os_clock;os_fd;os_interface;os_system;nl80211_listener;layer2info;systeminfo;cfg_uciloader;cfg_compact;dlep_radio" \ + -D OONF_LIB_GIT:String=v$(PKG_VERSION)-archive \ + -D OONF_VERSION:String=$(PKG_VERSION) \ + -D INSTALL_LIB_DIR:Path=lib/oonf \ + -D INSTALL_INCLUDE_DIR:Path=include/oonf \ + -D INSTALL_CMAKE_DIR:Path=lib/oonf \ + -D CMAKE_PREFIX_PATH=$(STAGING_DIR)/usr define Package/oonf-dlep-radio - $(call Package/oonf-git/template) - TITLE:= Build DLEP Radio Agent - DEPENDS:=+librt +libnl-tiny +libuci +oonf-init-scripts - VERSION:=$(PKG_VERSION) + SECTION:=net + CATEGORY:=Network + SUBMENU:=OLSR.org network framework + URL:=http://www.olsr.org/ + TITLE:=Build DLEP Radio Agent + DEPENDS:=+librt +libnl-tiny +libuci +oonf-init-scripts endef Build/Compile=$(call Build/Compile/Default,dlep_radio_static) diff --git a/oonf-olsrd2/Makefile b/oonf-olsrd2/Makefile index 474b0e4..40190ed 100644 --- a/oonf-olsrd2/Makefile +++ b/oonf-olsrd2/Makefile @@ -10,6 +10,7 @@ PKG_SOURCE_URL:=https://github.com/OLSR/OONF.git PKG_SOURCE_PROTO:=git PKG_SOURCE_SUBDIR:=$(PKG_NAME)-$(PKG_VERSION) PKG_SOURCE_VERSION:=$(PKG_REV) +PKG_MIRROR_HASH:=2e38140e804e7fc0138d0893416c4f19b1ca43bd9de066e8b028bd0d59ac9255 CMAKE_INSTALL:=1 @@ -30,19 +31,19 @@ CMAKE_OPTIONAL_PLUGINS:= $(subst $(SPACE),;,$(strip \ BUILD_TYPE:= $(if $(filter y,$(CONFIG_DEBUG)),Debug,Release) -CMAKE_OPTIONS=-D CMAKE_BUILD_TYPE:String=$(BUILD_TYPE) \ - -D OONF_NO_WERROR:Bool=true \ - -D OONF_LOGGING_LEVEL:String=debug \ - -D OONF_NO_TESTING:Bool=true \ - -D UCI:Bool=true \ - -D OONF_APP_DEFAULT_CFG_HANDLER:String=uci \ - -D OONF_STATIC_PLUGINS:String="class;clock;duplicate_set;layer2;packet_socket;rfc5444;socket;stream_socket;telnet;timer;viewer;os_clock;os_fd;os_interface;os_routing;os_system;nhdp;olsrv2;ff_dat_metric;neighbor_probing;nl80211_listener;link_config;layer2info;systeminfo;cfg_uciloader;cfg_compact;nhdpinfo;olsrv2info;netjsoninfo;${CMAKE_OPTIONAL_PLUGINS}" \ - -D OONF_LIB_GIT:String=v$(PKG_VERSION)-archive \ - -D OONF_VERSION:String=$(PKG_VERSION) \ - -D INSTALL_LIB_DIR:Path=lib/oonf \ - -D INSTALL_INCLUDE_DIR:Path=include/oonf \ - -D INSTALL_CMAKE_DIR:Path=lib/oonf \ - -D CMAKE_PREFIX_PATH=$(STAGING_DIR)/usr +CMAKE_OPTIONS+=-D CMAKE_BUILD_TYPE:String=$(BUILD_TYPE) \ + -D OONF_NO_WERROR:Bool=true \ + -D OONF_LOGGING_LEVEL:String=debug \ + -D OONF_NO_TESTING:Bool=true \ + -D UCI:Bool=true \ + -D OONF_APP_DEFAULT_CFG_HANDLER:String=uci \ + -D OONF_STATIC_PLUGINS:String="class;clock;duplicate_set;layer2;packet_socket;rfc5444;socket;stream_socket;telnet;timer;viewer;os_clock;os_fd;os_interface;os_routing;os_system;nhdp;olsrv2;ff_dat_metric;neighbor_probing;nl80211_listener;link_config;layer2info;systeminfo;cfg_uciloader;cfg_compact;nhdpinfo;olsrv2info;netjsoninfo;${CMAKE_OPTIONAL_PLUGINS}" \ + -D OONF_LIB_GIT:String=v$(PKG_VERSION)-archive \ + -D OONF_VERSION:String=$(PKG_VERSION) \ + -D INSTALL_LIB_DIR:Path=lib/oonf \ + -D INSTALL_INCLUDE_DIR:Path=include/oonf \ + -D INSTALL_CMAKE_DIR:Path=lib/oonf \ + -D CMAKE_PREFIX_PATH=$(STAGING_DIR)/usr define Package/oonf-git/template SECTION:=net diff --git a/oonf-olsrd2/patches/020-static.patch b/oonf-olsrd2/patches/020-static.patch index e1f3715..87146bf 100644 --- a/oonf-olsrd2/patches/020-static.patch +++ b/oonf-olsrd2/patches/020-static.patch @@ -1,6 +1,6 @@ --- a/src-plugins/nhdp/nhdp/nhdp.c +++ b/src-plugins/nhdp/nhdp/nhdp.c -@@ -187,9 +187,9 @@ static struct oonf_rfc5444_protocol *_protocol; +@@ -187,9 +187,9 @@ static struct oonf_rfc5444_protocol *_pr static struct netaddr _originator_v4, _originator_v6; /* logging sources for NHDP subsystem */ diff --git a/opennds/Makefile b/opennds/Makefile index 1d6d676..8775626 100644 --- a/opennds/Makefile +++ b/opennds/Makefile @@ -6,38 +6,42 @@ include $(TOPDIR)/rules.mk PKG_NAME:=opennds -PKG_FIXUP:=autoreconf -PKG_VERSION:=9.3.0 -PKG_RELEASE:=1 +PKG_VERSION:=9.8.0 +PKG_RELEASE:=2 +PKG_SOURCE:=$(PKG_NAME)-$(PKG_VERSION).tar.gz PKG_SOURCE_URL:=https://codeload.github.com/opennds/opennds/tar.gz/v$(PKG_VERSION)? -PKG_SOURCE:=opennds-$(PKG_VERSION).tar.gz -PKG_HASH:=719e128c4f08af4ad1924f8f1b1b63262c16e10f63b390a4c5c394cfc232aa20 +PKG_HASH:=11f4a48ef62007f56376c32a028f19183452c62eee6fddcb11aafe822e5ff1b4 PKG_BUILD_DIR:=$(BUILD_DIR)/openNDS-$(PKG_VERSION) PKG_MAINTAINER:=Rob White <rob@blue-wave.net> +PKG_LICENSE:=GPL-2.0-or-later +PKG_LICENSE_FILES:=COPYING + +PKG_FIXUP:=autoreconf PKG_BUILD_PARALLEL:=1 -PKG_LICENSE:=GPL-2.0+ include $(INCLUDE_DIR)/package.mk define Package/opennds - SUBMENU:=Captive Portals - SECTION:=net - CATEGORY:=Network - DEPENDS:=+libpthread +iptables-mod-ipopt +libmicrohttpd-no-ssl - TITLE:=Open public network gateway daemon - URL:=https://github.com/opennds/opennds - CONFLICTS:=nodogsplash nodogsplash2 + SUBMENU:=Captive Portals + SECTION:=net + CATEGORY:=Network + DEPENDS:=+kmod-ipt-conntrack +kmod-ipt-nat +libmicrohttpd-no-ssl + TITLE:=Open public network gateway daemon + URL:=https://github.com/opennds/opennds + CONFLICTS:=nodogsplash endef define Package/opennds/description - openNDS is a Captive Portal solution that offers an instant way to provide restricted access to the Internet. - With little or no configuration, a dynamically generated and adaptive splash page sequence is automatically served. - Internet access is granted by either a click to continue button, or after credential verification. - The package incorporates the FAS API allowing many flexible customisation options. - The creation of sophisticated third party authentication applications is fully supported. - Internet hosted https portals can be utilised to inspire maximum user confidence. + openNDS is a Captive Portal solution that offers an instant way to provide restricted access to the Internet. + With little or no configuration, a dynamically generated and adaptive splash page sequence is automatically served. + Both client driven Captive Portal Detection (CPD) and gateway driven Captive Portal Identification (CPI - RFC 8910 and RFC 8908) are supported. + Internet access is granted by either a click to continue button, or after credential verification as a result of filling in a login form. + The package incorporates the FAS API allowing many flexible customisation options. + The creation of sophisticated third party authentication applications is fully supported. + Internet hosted https portals can be implemented with no security errors, to inspire maximum user confidence. + This version requires iptables-legacy. endef define Package/opennds/install @@ -63,11 +67,11 @@ define Package/opennds/install $(CP) $(PKG_BUILD_DIR)/forward_authentication_service/PreAuth/theme_user-email-login-basic.sh $(1)/usr/lib/opennds/ $(CP) $(PKG_BUILD_DIR)/forward_authentication_service/PreAuth/theme_user-email-login-custom-placeholders.sh $(1)/usr/lib/opennds/ $(CP) $(PKG_BUILD_DIR)/forward_authentication_service/libs/get_client_interface.sh $(1)/usr/lib/opennds/ - $(CP) $(PKG_BUILD_DIR)/forward_authentication_service/libs/get_client_token.sh $(1)/usr/lib/opennds/ $(CP) $(PKG_BUILD_DIR)/forward_authentication_service/libs/client_params.sh $(1)/usr/lib/opennds/ $(CP) $(PKG_BUILD_DIR)/forward_authentication_service/libs/unescape.sh $(1)/usr/lib/opennds/ $(CP) $(PKG_BUILD_DIR)/forward_authentication_service/libs/authmon.sh $(1)/usr/lib/opennds/ $(CP) $(PKG_BUILD_DIR)/forward_authentication_service/libs/dnsconfig.sh $(1)/usr/lib/opennds/ + $(CP) $(PKG_BUILD_DIR)/forward_authentication_service/libs/download_resources.sh $(1)/usr/lib/opennds/ $(CP) $(PKG_BUILD_DIR)/forward_authentication_service/libs/post-request.php $(1)/usr/lib/opennds/ $(CP) $(PKG_BUILD_DIR)/forward_authentication_service/fas-aes/fas-aes.php $(1)/etc/opennds/ $(CP) $(PKG_BUILD_DIR)/forward_authentication_service/fas-hid/fas-hid.php $(1)/etc/opennds/ diff --git a/pimbd/Makefile b/pimbd/Makefile index a091119..a7dbed2 100644 --- a/pimbd/Makefile +++ b/pimbd/Makefile @@ -3,10 +3,11 @@ include $(TOPDIR)/rules.mk PKG_NAME:=pimbd PKG_SOURCE_VERSION:=dbf4e5913b06e3160f506df15e6a047a403a5f21 PKG_VERSION:=2018-06-19-$(PKG_SOURCE_VERSION) -PKG_RELEASE:=1 +PKG_RELEASE:=2 PKG_SOURCE_PROTO:=git PKG_SOURCE_URL:=https://github.com/Oryon/pimbd.git +PKG_MIRROR_HASH:=a08e474d7c210b084a28afe8f85e1b356a067b2f9ec643d26402680782933ae7 PKG_MAINTAINER:=Pierre Pfister <pierre.pfister@darou.fr> PKG_LICENSE:=Apache-2.0 |