config: make RA mtu configurable via UCI

[project/odhcpd.git] / src / router.c

diff --git a/src/router.c b/src/router.c
index 945151e..a31bf4e 100644 (file)
--- a/src/router.c
+++ b/src/router.c
@@ -20,6 +20,7 @@
 #include <stdlib.h>
 #include <unistd.h>
 #include <stdbool.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <stdbool.h>

+#include <arpa/inet.h>

 #include <net/route.h>
 
 #include "router.h"
 #include <net/route.h>
 
 #include "router.h"


@@ -30,14 +31,16 @@ static void forward_router_solicitation(const struct interface *iface);
 static void forward_router_advertisement(uint8_t *data, size_t len);
 
 static void handle_icmpv6(void *addr, void *data, size_t len,
 static void forward_router_advertisement(uint8_t *data, size_t len);
 
 static void handle_icmpv6(void *addr, void *data, size_t len,

-               struct interface *iface);
-static void send_router_advert(struct uloop_timeout *event);
+               struct interface *iface, void *dest);
+static void trigger_router_advert(struct uloop_timeout *event);

 static void sigusr1_refresh(int signal);
 
 static void sigusr1_refresh(int signal);
 

-static struct odhcpd_event router_event = {{.fd = -1}, handle_icmpv6};
+static struct odhcpd_event router_event = {.uloop = {.fd = -1}, .handle_dgram = handle_icmpv6, };

 
 static FILE *fp_route = NULL;
 
 static FILE *fp_route = NULL;

+#define RA_IOV_LEN 6

 
 

+#define TIME_LEFT(t1, now) ((t1) != UINT32_MAX ? (t1) - (now) : UINT32_MAX)

 
 int init_router(void)
 {
 
 int init_router(void)
 {


@@ -88,12 +91,18 @@ int init_router(void)
 
 int setup_router_interface(struct interface *iface, bool enable)
 {
 
 int setup_router_interface(struct interface *iface, bool enable)
 {

+       if (!fp_route || router_event.uloop.fd < 0)
+               return -1;
+

        struct ipv6_mreq all_nodes = {ALL_IPV6_NODES, iface->ifindex};
        struct ipv6_mreq all_routers = {ALL_IPV6_ROUTERS, iface->ifindex};
 
        uloop_timeout_cancel(&iface->timer_rs);
        iface->timer_rs.cb = NULL;
 
        struct ipv6_mreq all_nodes = {ALL_IPV6_NODES, iface->ifindex};
        struct ipv6_mreq all_routers = {ALL_IPV6_ROUTERS, iface->ifindex};
 
        uloop_timeout_cancel(&iface->timer_rs);
        iface->timer_rs.cb = NULL;
 

+       if (iface->ifindex <= 0)
+               return -1;
+

        setsockopt(router_event.uloop.fd, IPPROTO_IPV6, IPV6_DROP_MEMBERSHIP,
                        &all_nodes, sizeof(all_nodes));
        setsockopt(router_event.uloop.fd, IPPROTO_IPV6, IPV6_DROP_MEMBERSHIP,
        setsockopt(router_event.uloop.fd, IPPROTO_IPV6, IPV6_DROP_MEMBERSHIP,
                        &all_nodes, sizeof(all_nodes));
        setsockopt(router_event.uloop.fd, IPPROTO_IPV6, IPV6_DROP_MEMBERSHIP,


@@ -101,7 +110,7 @@ int setup_router_interface(struct interface *iface, bool enable)
 
        if (!enable) {
                if (iface->ra)
 
        if (!enable) {
                if (iface->ra)

-                       send_router_advert(&iface->timer_rs);
+                       trigger_router_advert(&iface->timer_rs);

        } else {
                void *mreq = &all_routers;
 
        } else {
                void *mreq = &all_routers;
 


@@ -109,8 +118,9 @@ int setup_router_interface(struct interface *iface, bool enable)
                        mreq = &all_nodes;
                        forward_router_solicitation(iface);
                } else if (iface->ra == RELAYD_SERVER && !iface->master) {
                        mreq = &all_nodes;
                        forward_router_solicitation(iface);
                } else if (iface->ra == RELAYD_SERVER && !iface->master) {

-                       iface->timer_rs.cb = send_router_advert;
-                       send_router_advert(&iface->timer_rs);
+                       iface->timer_rs.cb = trigger_router_advert;
+                       uloop_timeout_set(&iface->timer_rs, 1000);
+                       ndp_rqs_addr6_dump();

                }
 
                if (iface->ra == RELAYD_RELAY || (iface->ra == RELAYD_SERVER && !iface->master))
                }
 
                if (iface->ra == RELAYD_RELAY || (iface->ra == RELAYD_SERVER && !iface->master))


@@ -130,35 +140,39 @@ static void sigusr1_refresh(_unused int signal)
                        uloop_timeout_set(&iface->timer_rs, 1000);
 }
 
                        uloop_timeout_set(&iface->timer_rs, 1000);
 }
 

-
-// Event handler for incoming ICMPv6 packets
-static void handle_icmpv6(_unused void *addr, void *data, size_t len,
-               struct interface *iface)
+static bool router_icmpv6_valid(struct sockaddr_in6 *source, uint8_t *data, size_t len)

 {
 {

-       struct icmp6_hdr *hdr = data;
-       if ((iface->ra == RELAYD_SERVER && !iface->master)) { // Server mode
-               if (hdr->icmp6_type == ND_ROUTER_SOLICIT)
-                       send_router_advert(&iface->timer_rs);
-       } else if (iface->ra == RELAYD_RELAY) { // Relay mode
-               if (hdr->icmp6_type == ND_ROUTER_ADVERT && iface->master)
-                       forward_router_advertisement(data, len);
-               else if (hdr->icmp6_type == ND_ROUTER_SOLICIT && !iface->master)
-                       forward_router_solicitation(odhcpd_get_master_interface());
-       }
-}
+       struct icmp6_hdr *hdr = (struct icmp6_hdr *)data;
+       struct icmpv6_opt *opt, *end = (struct icmpv6_opt*)&data[len];

 
 

+       /* Hoplimit is already checked in odhcpd_receive_packets */
+       if (len < sizeof(*hdr) || hdr->icmp6_code)
+               return false;

 
 

-static bool match_route(const struct odhcpd_ipaddr *n, const struct in6_addr *addr)
-{
-       if (n->prefix <= 32)
-               return ntohl(n->addr.s6_addr32[0]) >> (32 - n->prefix) ==
-                               ntohl(addr->s6_addr32[0]) >> (32 - n->prefix);
+       switch (hdr->icmp6_type) {
+       case ND_ROUTER_ADVERT:
+               if (!IN6_IS_ADDR_LINKLOCAL(&source->sin6_addr))
+                       return false;
+
+               opt = (struct icmpv6_opt *)((struct nd_router_advert *)data + 1);
+               break;

 
 

-       if (n->addr.s6_addr32[0] != addr->s6_addr32[0])
+       case ND_ROUTER_SOLICIT:
+               opt = (struct icmpv6_opt *)((struct nd_router_solicit *)data + 1);
+               break;
+
+       default:

                return false;
                return false;

+       }

 
 

-       return ntohl(n->addr.s6_addr32[1]) >> (64 - n->prefix) ==
-                       ntohl(addr->s6_addr32[1]) >> (64 - n->prefix);
+       icmpv6_for_each_option(opt, opt, end)
+               if (opt->type == ND_OPT_SOURCE_LINKADDR &&
+                               IN6_IS_ADDR_UNSPECIFIED(&source->sin6_addr) &&
+                               hdr->icmp6_type == ND_ROUTER_SOLICIT)
+                       return false;
+
+       // Check all options parsed successfully
+       return opt == end;

 }
 
 
 }
 
 


@@ -169,7 +183,7 @@ static bool parse_routes(struct odhcpd_ipaddr *n, ssize_t len)
 
        char line[512], ifname[16];
        bool found_default = false;
 
        char line[512], ifname[16];
        bool found_default = false;

-       struct odhcpd_ipaddr p = {IN6ADDR_ANY_INIT, 0, false, 0, 0, 0};
+       struct odhcpd_ipaddr p = {IN6ADDR_ANY_INIT, 0, 0, 0, 0};

        while (fgets(line, sizeof(line), fp_route)) {
                uint32_t rflags;
                if (sscanf(line, "00000000000000000000000000000000 00 "
        while (fgets(line, sizeof(line), fp_route)) {
                uint32_t rflags;
                if (sscanf(line, "00000000000000000000000000000000 00 "


@@ -186,8 +200,8 @@ static bool parse_routes(struct odhcpd_ipaddr *n, ssize_t len)
 
                        for (ssize_t i = 0; i < len; ++i) {
                                if (n[i].prefix <= 64 && n[i].prefix >= p.prefix &&
 
                        for (ssize_t i = 0; i < len; ++i) {
                                if (n[i].prefix <= 64 && n[i].prefix >= p.prefix &&

-                                               match_route(&p, &n[i].addr)) {
-                                       n[i].prefix = p.prefix;
+                                               !odhcpd_bmemcmp(&p.addr, &n[i].addr, p.prefix)) {
+                                       n[i].dprefix = p.prefix;

                                        break;
                                }
                        }
                                        break;
                                }
                        }


@@ -198,28 +212,76 @@ static bool parse_routes(struct odhcpd_ipaddr *n, ssize_t len)
        return found_default;
 }
 
        return found_default;
 }
 

+static int calc_adv_interval(struct interface *iface, uint32_t minvalid,
+               uint32_t *maxival)
+{
+       uint32_t minival = iface->ra_mininterval;
+       int msecs;
+
+       *maxival = iface->ra_maxinterval;
+
+       if (*maxival > minvalid/3)
+               *maxival = minvalid/3;
+
+       if (*maxival > MaxRtrAdvInterval)
+               *maxival = MaxRtrAdvInterval;
+       else if (*maxival < 4)
+               *maxival = 4;
+
+       if (minival < MinRtrAdvInterval)
+               minival = MinRtrAdvInterval;
+       else if (minival > (*maxival * 3)/4)
+               minival = (*maxival >= 9 ? *maxival/3 : *maxival);
+
+       odhcpd_urandom(&msecs, sizeof(msecs));
+       msecs = (labs(msecs) % ((*maxival != minival) ? (*maxival - minival)*1000 : 500)) +
+                       minival*1000;
+
+       return msecs;
+}
+
+static uint16_t calc_ra_lifetime(struct interface *iface, uint32_t maxival)
+{
+       uint16_t lifetime = 3*maxival;
+
+       if (iface->ra_lifetime >= 0) {
+               lifetime = iface->ra_lifetime;
+               if (lifetime < maxival)
+                       lifetime = maxival;
+               else if (lifetime > 9000)
+                       lifetime = 9000;
+       }
+
+       return lifetime;
+}

 
 // Router Advert server mode
 
 // Router Advert server mode

-static void send_router_advert(struct uloop_timeout *event)
+static uint64_t send_router_advert(struct interface *iface, const struct in6_addr *from)

 {
 {

-       struct interface *iface =
-                       container_of(event, struct interface, timer_rs);
+       time_t now = odhcpd_time();
+       uint32_t mtu = iface->ra_mtu;
+       int hlim = odhcpd_get_interface_config(iface->ifname, "hop_limit");

 
 

-       int mtu = odhcpd_get_interface_mtu(iface->ifname);
-       if (mtu < 0)
-               mtu = 1500;
+       if (mtu == 0)
+                mtu = odhcpd_get_interface_config(iface->ifname, "mtu");
+
+       if (mtu < 1280)
+               mtu = 1280;

 
        struct {
                struct nd_router_advert h;
                struct icmpv6_opt lladdr;
                struct nd_opt_mtu mtu;
 
        struct {
                struct nd_router_advert h;
                struct icmpv6_opt lladdr;
                struct nd_opt_mtu mtu;

-               struct nd_opt_prefix_info prefix[RELAYD_MAX_PREFIXES];
+               struct nd_opt_prefix_info prefix[sizeof(iface->ia_addr) / sizeof(*iface->ia_addr)];

        } adv = {
                .h = {{.icmp6_type = ND_ROUTER_ADVERT, .icmp6_code = 0}, 0, 0},
                .lladdr = {ND_OPT_SOURCE_LINKADDR, 1, {0}},
                .mtu = {ND_OPT_MTU, 1, 0, htonl(mtu)},
        };
 
        } adv = {
                .h = {{.icmp6_type = ND_ROUTER_ADVERT, .icmp6_code = 0}, 0, 0},
                .lladdr = {ND_OPT_SOURCE_LINKADDR, 1, {0}},
                .mtu = {ND_OPT_MTU, 1, 0, htonl(mtu)},
        };
 

+       if (hlim > 0)
+               adv.h.nd_ra_curhoplimit = hlim;
+

        if (iface->dhcpv6)
                adv.h.nd_ra_flags_reserved = ND_RA_FLAG_OTHER;
 
        if (iface->dhcpv6)
                adv.h.nd_ra_flags_reserved = ND_RA_FLAG_OTHER;
 


@@ -233,43 +295,54 @@ static void send_router_advert(struct uloop_timeout *event)
        odhcpd_get_mac(iface, adv.lladdr.data);
 
        // If not currently shutting down
        odhcpd_get_mac(iface, adv.lladdr.data);
 
        // If not currently shutting down

-       struct odhcpd_ipaddr addrs[RELAYD_MAX_PREFIXES];
+       struct odhcpd_ipaddr addrs[RELAYD_MAX_ADDRS];

        ssize_t ipcnt = 0;
        ssize_t ipcnt = 0;

+       uint32_t minvalid = UINT32_MAX;
+       bool default_route = false;
+       bool valid_prefix = false;

 
        // If not shutdown
 
        // If not shutdown

-       if (event->cb) {
-               ipcnt = odhcpd_get_interface_addresses(iface->ifindex,
-                               addrs, ARRAY_SIZE(addrs));
+       if (iface->timer_rs.cb) {
+               ipcnt = iface->ia_addr_len;
+               memcpy(addrs, iface->ia_addr, ipcnt * sizeof(*addrs));

 
                // Check default route
 
                // Check default route

-               if (parse_routes(addrs, ipcnt) || iface->default_router > 1)
-                       adv.h.nd_ra_router_lifetime =
-                                       htons(3 * MaxRtrAdvInterval);
+               if (iface->default_router) {
+                       default_route = true;
+
+                       if (iface->default_router > 1)
+                               valid_prefix = true;
+               } else if (parse_routes(addrs, ipcnt))
+                       default_route = true;

        }
 
        // Construct Prefix Information options
        }
 
        // Construct Prefix Information options

-       bool have_public = false;

        size_t cnt = 0;
 
        size_t cnt = 0;
 

-       struct in6_addr *dns_addr = NULL;
-       uint32_t dns_time = 0;
+       struct in6_addr dns_pref, *dns_addr = &dns_pref;

        size_t dns_cnt = 1;
 
        size_t dns_cnt = 1;
 

+       odhcpd_get_interface_dns_addr(iface, &dns_pref);
+

        for (ssize_t i = 0; i < ipcnt; ++i) {
                struct odhcpd_ipaddr *addr = &addrs[i];
        for (ssize_t i = 0; i < ipcnt; ++i) {
                struct odhcpd_ipaddr *addr = &addrs[i];

-               if (addr->prefix > 64 || addr->has_class)
-                       continue; // Address not suitable
+               uint32_t preferred = 0;
+               uint32_t valid = 0;

 
 

-               if (addr->preferred > MaxPreferredTime)
-                       addr->preferred = MaxPreferredTime;
+               if (addr->prefix > 96 || addr->valid <= (uint32_t)now) {
+                       char namebuf[INET6_ADDRSTRLEN];

 
 

-               if (addr->valid > MaxValidTime)
-                       addr->valid = MaxValidTime;
+                       inet_ntop(AF_INET6, addr, namebuf, sizeof(namebuf));
+                       syslog(LOG_INFO, "Address %s (prefix %d, valid %u) not suitable as RA prefix on %s",
+                                       namebuf, addr->prefix, addr->valid, iface->ifname);
+                       continue;
+               }

 
                struct nd_opt_prefix_info *p = NULL;
                for (size_t i = 0; i < cnt; ++i) {
 
                struct nd_opt_prefix_info *p = NULL;
                for (size_t i = 0; i < cnt; ++i) {

-                       if (!memcmp(&adv.prefix[i].nd_opt_pi_prefix,
-                                       &addr->addr, 8))
+                       if (addr->prefix == adv.prefix[i].nd_opt_pi_prefix_len &&
+                                       !odhcpd_bmemcmp(&adv.prefix[i].nd_opt_pi_prefix,
+                                       &addr->addr, addr->prefix))

                                p = &adv.prefix[i];
                }
 
                                p = &adv.prefix[i];
                }
 


@@ -280,46 +353,64 @@ static void send_router_advert(struct uloop_timeout *event)
                        p = &adv.prefix[cnt++];
                }
 
                        p = &adv.prefix[cnt++];
                }
 

-               if ((addr->addr.s6_addr[0] & 0xfe) != 0xfc && addr->preferred > 0)
-                       have_public = true;
+               if (addr->preferred > (uint32_t)now) {
+                       preferred = TIME_LEFT(addr->preferred, now);
+
+                       if (iface->ra_useleasetime &&
+                                       preferred > iface->dhcpv4_leasetime)
+                               preferred = iface->dhcpv4_leasetime;
+               }
+
+               valid = TIME_LEFT(addr->valid, now);
+               if (iface->ra_useleasetime && valid > iface->dhcpv4_leasetime)
+                       valid = iface->dhcpv4_leasetime;
+
+               if (minvalid > valid)
+                       minvalid = valid;

 
 

-               memcpy(&p->nd_opt_pi_prefix, &addr->addr, 8);
+               if (!IN6_IS_ADDR_ULA(&addr->addr) || iface->default_router)
+                       valid_prefix = true;
+
+               odhcpd_bmemcpy(&p->nd_opt_pi_prefix, &addr->addr,
+                               (iface->ra_advrouter) ? 128 : addr->prefix);

                p->nd_opt_pi_type = ND_OPT_PREFIX_INFORMATION;
                p->nd_opt_pi_len = 4;
                p->nd_opt_pi_type = ND_OPT_PREFIX_INFORMATION;
                p->nd_opt_pi_len = 4;

-               p->nd_opt_pi_prefix_len = 64;
+               p->nd_opt_pi_prefix_len = (addr->prefix < 64) ? 64 : addr->prefix;

                p->nd_opt_pi_flags_reserved = 0;
                if (!iface->ra_not_onlink)
                        p->nd_opt_pi_flags_reserved |= ND_OPT_PI_FLAG_ONLINK;
                p->nd_opt_pi_flags_reserved = 0;
                if (!iface->ra_not_onlink)
                        p->nd_opt_pi_flags_reserved |= ND_OPT_PI_FLAG_ONLINK;

-               if (iface->managed < RELAYD_MANAGED_NO_AFLAG)
+               if (iface->managed < RELAYD_MANAGED_NO_AFLAG && addr->prefix <= 64)

                        p->nd_opt_pi_flags_reserved |= ND_OPT_PI_FLAG_AUTO;
                        p->nd_opt_pi_flags_reserved |= ND_OPT_PI_FLAG_AUTO;

-               p->nd_opt_pi_valid_time = htonl(addr->valid);
-               p->nd_opt_pi_preferred_time = htonl(addr->preferred);
-
-               if (addr->preferred > dns_time) {
-                       dns_time = addr->preferred;
-                       dns_addr = &addr->addr;
-               }
+               if (iface->ra_advrouter)
+                       p->nd_opt_pi_flags_reserved |= ND_OPT_PI_FLAG_RADDR;
+               p->nd_opt_pi_preferred_time = htonl(preferred);
+               p->nd_opt_pi_valid_time = htonl(valid);

        }
 
        }
 

-       if (!have_public && !iface->default_router && adv.h.nd_ra_router_lifetime) {
-               syslog(LOG_WARNING, "A default route is present but there is no public prefix "
-                               "on %s thus we don't announce a default route!", iface->ifname);
+       // Calculate periodic transmit
+       uint32_t maxival;
+       int msecs = calc_adv_interval(iface, minvalid, &maxival);
+
+       if (default_route) {
+               if (!valid_prefix) {
+                       syslog(LOG_WARNING, "A default route is present but there is no public prefix "
+                                       "on %s thus we don't announce a default route!", iface->ifname);
+                       adv.h.nd_ra_router_lifetime = 0;
+               } else
+                       adv.h.nd_ra_router_lifetime = htons(calc_ra_lifetime(iface, maxival));
+
+       } else

                adv.h.nd_ra_router_lifetime = 0;
                adv.h.nd_ra_router_lifetime = 0;

-       }

 
 

-       if (have_public && iface->deprecate_ula_if_public_avail)
-               for (size_t i = 0; i < cnt; ++i)
-                       if ((adv.prefix[i].nd_opt_pi_prefix.s6_addr[0] & 0xfe) == 0xfc)
-                               adv.prefix[i].nd_opt_pi_preferred_time = 0;
+       syslog(LOG_INFO, "Using a RA lifetime of %d seconds on %s", ntohs(adv.h.nd_ra_router_lifetime), iface->ifname);

 
        // DNS Recursive DNS
        if (iface->dns_cnt > 0) {
                dns_addr = iface->dns;
                dns_cnt = iface->dns_cnt;
 
        // DNS Recursive DNS
        if (iface->dns_cnt > 0) {
                dns_addr = iface->dns;
                dns_cnt = iface->dns_cnt;

-               dns_time = 2 * MaxRtrAdvInterval;

        }
 
        }
 

-       if (!dns_addr)
+       if (!dns_addr || IN6_IS_ADDR_UNSPECIFIED(dns_addr))

                dns_cnt = 0;
 
        struct {
                dns_cnt = 0;
 
        struct {


@@ -328,7 +419,7 @@ static void send_router_advert(struct uloop_timeout *event)
                uint8_t pad;
                uint8_t pad2;
                uint32_t lifetime;
                uint8_t pad;
                uint8_t pad2;
                uint32_t lifetime;

-       } dns = {ND_OPT_RECURSIVE_DNS, (1 + (2 * dns_cnt)), 0, 0, htonl(dns_time)};
+       } dns = {ND_OPT_RECURSIVE_DNS, (1 + (2 * dns_cnt)), 0, 0, 0};

 
 
 
 
 
 


@@ -356,11 +447,11 @@ static void send_router_advert(struct uloop_timeout *event)
                uint32_t lifetime;
                uint8_t name[];
        } *search = alloca(sizeof(*search) + search_padded);
                uint32_t lifetime;
                uint8_t name[];
        } *search = alloca(sizeof(*search) + search_padded);

+

        search->type = ND_OPT_DNS_SEARCH;
        search->len = search_len ? ((sizeof(*search) + search_padded) / 8) : 0;
        search->pad = 0;
        search->pad2 = 0;
        search->type = ND_OPT_DNS_SEARCH;
        search->len = search_len ? ((sizeof(*search) + search_padded) / 8) : 0;
        search->pad = 0;
        search->pad2 = 0;

-       search->lifetime = htonl(2 * MaxRtrAdvInterval);;

        memcpy(search->name, search_domain, search_len);
        memset(&search->name[search_len], 0, search_padded - search_len);
 
        memcpy(search->name, search_domain, search_len);
        memset(&search->name[search_len], 0, search_padded - search_len);
 


@@ -377,48 +468,91 @@ static void send_router_advert(struct uloop_timeout *event)
 
        for (ssize_t i = 0; i < ipcnt; ++i) {
                struct odhcpd_ipaddr *addr = &addrs[i];
 
        for (ssize_t i = 0; i < ipcnt; ++i) {
                struct odhcpd_ipaddr *addr = &addrs[i];

-               if (addr->prefix > 64 || addr->prefix == 0) {
+               if (addr->dprefix > 64 || addr->dprefix == 0 || addr->valid <= (uint32_t)now ||
+                               (addr->dprefix == 64 && addr->prefix == 64)) {

                        continue; // Address not suitable
                        continue; // Address not suitable

-               } else if (addr->prefix > 32) {
-                       addr->addr.s6_addr32[1] &= htonl(~((1U << (64 - addr->prefix)) - 1));
-               } else if (addr->prefix <= 32) {
-                       addr->addr.s6_addr32[0] &= htonl(~((1U << (32 - addr->prefix)) - 1));
+               } else if (addr->dprefix > 32) {
+                       addr->addr.s6_addr32[1] &= htonl(~((1U << (64 - addr->dprefix)) - 1));
+               } else if (addr->dprefix <= 32) {
+                       addr->addr.s6_addr32[0] &= htonl(~((1U << (32 - addr->dprefix)) - 1));

                        addr->addr.s6_addr32[1] = 0;
                }
 
                routes[routes_cnt].type = ND_OPT_ROUTE_INFO;
                routes[routes_cnt].len = sizeof(*routes) / 8;
                        addr->addr.s6_addr32[1] = 0;
                }
 
                routes[routes_cnt].type = ND_OPT_ROUTE_INFO;
                routes[routes_cnt].len = sizeof(*routes) / 8;

-               routes[routes_cnt].prefix = addr->prefix;
+               routes[routes_cnt].prefix = addr->dprefix;

                routes[routes_cnt].flags = 0;
                if (iface->route_preference < 0)
                        routes[routes_cnt].flags |= ND_RA_PREF_LOW;
                else if (iface->route_preference > 0)
                        routes[routes_cnt].flags |= ND_RA_PREF_HIGH;
                routes[routes_cnt].flags = 0;
                if (iface->route_preference < 0)
                        routes[routes_cnt].flags |= ND_RA_PREF_LOW;
                else if (iface->route_preference > 0)
                        routes[routes_cnt].flags |= ND_RA_PREF_HIGH;

-               routes[routes_cnt].lifetime = htonl(addr->valid);
+               routes[routes_cnt].lifetime = htonl(TIME_LEFT(addr->valid, now));

                routes[routes_cnt].addr[0] = addr->addr.s6_addr32[0];
                routes[routes_cnt].addr[1] = addr->addr.s6_addr32[1];
                routes[routes_cnt].addr[0] = addr->addr.s6_addr32[0];
                routes[routes_cnt].addr[1] = addr->addr.s6_addr32[1];

-               routes[routes_cnt].addr[2] = addr->addr.s6_addr32[2];
-               routes[routes_cnt].addr[3] = addr->addr.s6_addr32[3];
+               routes[routes_cnt].addr[2] = 0;
+               routes[routes_cnt].addr[3] = 0;

 
                ++routes_cnt;
        }
 
 
                ++routes_cnt;
        }
 

+       search->lifetime = htonl(maxival*10);
+       dns.lifetime = search->lifetime;
+
+       struct icmpv6_opt adv_interval = {
+               .type = ND_OPT_RTR_ADV_INTERVAL,
+               .len = 1,
+               .data = {0, 0, (maxival*1000) >> 24, (maxival*1000) >> 16, (maxival*1000) >> 8, maxival*1000}
+       };

 
 

-       struct iovec iov[] = {{&adv, (uint8_t*)&adv.prefix[cnt] - (uint8_t*)&adv},
+       struct iovec iov[RA_IOV_LEN] = {
+                       {&adv, (uint8_t*)&adv.prefix[cnt] - (uint8_t*)&adv},

                        {&routes, routes_cnt * sizeof(*routes)},
                        {&dns, (dns_cnt) ? sizeof(dns) : 0},
                        {dns_addr, dns_cnt * sizeof(*dns_addr)},
                        {&routes, routes_cnt * sizeof(*routes)},
                        {&dns, (dns_cnt) ? sizeof(dns) : 0},
                        {dns_addr, dns_cnt * sizeof(*dns_addr)},

-                       {search, search->len * 8}};
-       struct sockaddr_in6 all_nodes = {AF_INET6, 0, 0, ALL_IPV6_NODES, 0};
+                       {search, search->len * 8},
+                       {&adv_interval, adv_interval.len * 8}};
+       struct sockaddr_in6 dest = {AF_INET6, 0, 0, ALL_IPV6_NODES, 0};
+
+       if (from && !IN6_IS_ADDR_UNSPECIFIED(from))
+               dest.sin6_addr = *from;
+

        odhcpd_send(router_event.uloop.fd,
        odhcpd_send(router_event.uloop.fd,

-                       &all_nodes, iov, ARRAY_SIZE(iov), iface);
+                       &dest, iov, ARRAY_SIZE(iov), iface);

 
 

-       // Rearm timer
-       int msecs;
-       odhcpd_urandom(&msecs, sizeof(msecs));
-       msecs = (labs(msecs) % (1000 * (MaxRtrAdvInterval
-                       - MinRtrAdvInterval))) + (MinRtrAdvInterval * 1000);
-       uloop_timeout_set(&iface->timer_rs, msecs);
+       return msecs;
+}
+
+
+static void trigger_router_advert(struct uloop_timeout *event)
+{
+       struct interface *iface = container_of(event, struct interface, timer_rs);
+       int msecs = send_router_advert(iface, NULL);
+
+       // Rearm timer if not shut down
+       if (event->cb)
+               uloop_timeout_set(event, msecs);
+}
+
+
+// Event handler for incoming ICMPv6 packets
+static void handle_icmpv6(void *addr, void *data, size_t len,
+               struct interface *iface, _unused void *dest)
+{
+       struct icmp6_hdr *hdr = data;
+       struct sockaddr_in6 *from = addr;
+
+       if (!router_icmpv6_valid(addr, data, len))
+               return;
+
+       if ((iface->ra == RELAYD_SERVER && !iface->master)) { // Server mode
+               if (hdr->icmp6_type == ND_ROUTER_SOLICIT)
+                       send_router_advert(iface, &from->sin6_addr);
+       } else if (iface->ra == RELAYD_RELAY) { // Relay mode
+               if (hdr->icmp6_type == ND_ROUTER_ADVERT && iface->master)
+                       forward_router_advertisement(data, len);
+               else if (hdr->icmp6_type == ND_ROUTER_SOLICIT && !iface->master)
+                       forward_router_solicitation(odhcpd_get_master_interface());
+       }

 }
 
 
 }
 
 


@@ -470,7 +604,6 @@ static void forward_router_advertisement(uint8_t *data, size_t len)
        struct sockaddr_in6 all_nodes = {AF_INET6, 0, 0, ALL_IPV6_NODES, 0};
        struct iovec iov = {data, len};
 
        struct sockaddr_in6 all_nodes = {AF_INET6, 0, 0, ALL_IPV6_NODES, 0};
        struct iovec iov = {data, len};
 

-       struct odhcpd_ipaddr addr;

        struct interface *iface;
        list_for_each_entry(iface, &interfaces, head) {
                if (iface->ra != RELAYD_RELAY || iface->master)
        struct interface *iface;
        list_for_each_entry(iface, &interfaces, head) {
                if (iface->ra != RELAYD_RELAY || iface->master)


@@ -483,13 +616,14 @@ static void forward_router_advertisement(uint8_t *data, size_t len)
                // If we have to rewrite DNS entries
                if (iface->always_rewrite_dns && dns_ptr && dns_count > 0) {
                        const struct in6_addr *rewrite = iface->dns;
                // If we have to rewrite DNS entries
                if (iface->always_rewrite_dns && dns_ptr && dns_count > 0) {
                        const struct in6_addr *rewrite = iface->dns;

+                       struct in6_addr addr;

                        size_t rewrite_cnt = iface->dns_cnt;
 
                        if (rewrite_cnt == 0) {
                        size_t rewrite_cnt = iface->dns_cnt;
 
                        if (rewrite_cnt == 0) {

-                               if (odhcpd_get_interface_addresses(iface->ifindex, &addr, 1) < 1)
+                               if (odhcpd_get_interface_dns_addr(iface, &addr))

                                        continue; // Unable to comply
 
                                        continue; // Unable to comply
 

-                               rewrite = &addr.addr;
+                               rewrite = &addr;

                                rewrite_cnt = 1;
                        }
 
                                rewrite_cnt = 1;
                        }