dhcpv4: coding style fixes

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

diff --git a/src/router.c b/src/router.c
index 0b01a77..f964a82 100644 (file)
--- a/src/router.c
+++ b/src/router.c
@@ -30,14 +30,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 = {{.fd = -1}, handle_icmpv6, NULL};

 
 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 +90,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 +109,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 +117,8 @@ 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);

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


@@ -130,35 +138,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;

+       }
+
+       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;

 
 

-       return ntohl(n->addr.s6_addr32[1]) >> (64 - n->prefix) ==
-                       ntohl(addr->s6_addr32[1]) >> (64 - n->prefix);
+       // Check all options parsed successfully
+       return opt == end;

 }
 
 
 }
 
 


@@ -169,7 +181,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 +198,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 +210,33 @@ static bool parse_routes(struct odhcpd_ipaddr *n, ssize_t len)
        return found_default;
 }
 
        return found_default;
 }
 

-

 // 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();
+       int mtu = odhcpd_get_interface_config(iface->ifname, "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 < 1280)
+               mtu = 1280;

 
        struct {
                struct nd_router_advert h;
 
        struct {
                struct nd_router_advert h;

-               struct nd_opt_slla lladdr;
+               struct icmpv6_opt lladdr;

                struct nd_opt_mtu mtu;
                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)},
        };

-       adv.h.nd_ra_flags_reserved = ND_RA_FLAG_OTHER;
+
+       if (hlim > 0)
+               adv.h.nd_ra_curhoplimit = hlim;
+
+       if (iface->dhcpv6)
+               adv.h.nd_ra_flags_reserved = ND_RA_FLAG_OTHER;
+

        if (iface->managed >= RELAYD_MANAGED_MFLAG)
                adv.h.nd_ra_flags_reserved |= ND_RA_FLAG_MANAGED;
 
        if (iface->managed >= RELAYD_MANAGED_MFLAG)
                adv.h.nd_ra_flags_reserved |= ND_RA_FLAG_MANAGED;
 


@@ -227,46 +244,43 @@ static void send_router_advert(struct uloop_timeout *event)
                adv.h.nd_ra_flags_reserved |= ND_RA_PREF_LOW;
        else if (iface->route_preference > 0)
                adv.h.nd_ra_flags_reserved |= ND_RA_PREF_HIGH;
                adv.h.nd_ra_flags_reserved |= ND_RA_PREF_LOW;
        else if (iface->route_preference > 0)
                adv.h.nd_ra_flags_reserved |= ND_RA_PREF_HIGH;

-       odhcpd_get_mac(iface, adv.lladdr.addr);
+       odhcpd_get_mac(iface, adv.lladdr.data);

 
        // If not currently shutting down
 
        // If not currently shutting down

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

        ssize_t ipcnt = 0;
        ssize_t ipcnt = 0;

+       int64_t minvalid = INT64_MAX;

 
        // 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 > 1)
+                       adv.h.nd_ra_router_lifetime = htons(iface->default_router);
+               else if (parse_routes(addrs, ipcnt))
+                       adv.h.nd_ra_router_lifetime = htons(1);

        }
 
        // 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_linklocal_interface_address(iface->ifindex, &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)
+               if (addr->prefix > 96 || addr->valid <= (uint32_t)now)

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

-               if (addr->preferred > MaxPreferredTime)
-                       addr->preferred = MaxPreferredTime;
-
-               if (addr->valid > MaxValidTime)
-                       addr->valid = MaxValidTime;
-

                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];
                }
 


@@ -277,49 +291,60 @@ 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 &&
+                               minvalid > 1000LL * TIME_LEFT(addr->valid, now))
+                       minvalid = 1000LL * TIME_LEFT(addr->valid, now);

 
 

-               memcpy(&p->nd_opt_pi_prefix, &addr->addr, 8);
+               uint32_t this_lifetime = TIME_LEFT(addr->valid, now);
+               if (this_lifetime > UINT16_MAX)
+                       this_lifetime = UINT16_MAX;
+               if (((addr->addr.s6_addr[0] & 0xfe) != 0xfc || iface->default_router)
+                               && adv.h.nd_ra_router_lifetime
+                               && ntohs(adv.h.nd_ra_router_lifetime) < this_lifetime)
+                       adv.h.nd_ra_router_lifetime = htons(this_lifetime);
+
+               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_valid_time = htonl(TIME_LEFT(addr->valid, now));
+               if (addr->preferred > (uint32_t)now)
+                       p->nd_opt_pi_preferred_time = htonl(TIME_LEFT(addr->preferred, now));
+               else if (addr->valid - now < 7200)
+                       p->nd_opt_pi_valid_time = 0;

        }
 
        }
 

-       if (!have_public && !iface->default_router && adv.h.nd_ra_router_lifetime) {
+       if (!iface->default_router && adv.h.nd_ra_router_lifetime == htons(1)) {

                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;
        }
 
                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;
        }
 

-       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;
-

        // 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;
 
                dns_cnt = 0;
 

-       struct nd_opt_recursive_dns dns = {ND_OPT_RECURSIVE_DNS, (1 + (2 * dns_cnt)), 0, 0, htonl(dns_time)};
+       struct {
+               uint8_t type;
+               uint8_t len;
+               uint8_t pad;
+               uint8_t pad2;
+               uint32_t lifetime;
+       } dns = {ND_OPT_RECURSIVE_DNS, (1 + (2 * dns_cnt)), 0, 0, 0};
+

 
 
        // DNS Search options
 
 
        // DNS Search options


@@ -347,15 +372,10 @@ static void send_router_advert(struct uloop_timeout *event)
                uint8_t name[];
        } *search = alloca(sizeof(*search) + search_padded);
 
                uint8_t name[];
        } *search = alloca(sizeof(*search) + search_padded);
 

-       if (!search) {
-               syslog(LOG_ERR, "Alloca failed for dns search on interface %s", iface->ifname);
-               return;
-       }

        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);
 


@@ -372,48 +392,111 @@ 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;
        }
 

+       // Calculate periodic transmit
+       int msecs = 0;
+       uint32_t maxival = iface->ra_maxinterval * 1000;
+       uint32_t minival;
+
+       if (maxival < 4000 || maxival > MaxRtrAdvInterval * 1000)
+               maxival = MaxRtrAdvInterval * 1000;
+
+       if (maxival > minvalid / 3) {
+               maxival = minvalid / 3;
+
+               if (maxival < 4000)
+                       maxival = 4000;
+       }
+
+       minival = (maxival * 3) / 4;
+
+       search->lifetime = htonl(maxival / 100);
+       dns.lifetime = search->lifetime;
+
+       odhcpd_urandom(&msecs, sizeof(msecs));
+       msecs = (labs(msecs) % (maxival - minival)) + minival;
+
+       struct icmpv6_opt adv_interval = {
+               .type = ND_OPT_RTR_ADV_INTERVAL,
+               .len = 1,
+               .data = {0, 0, maxival >> 24, maxival >> 16, maxival >> 8, maxival}
+       };

 
 

-       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());
+       }

 }
 
 
 }
 
 


@@ -448,12 +531,11 @@ static void forward_router_advertisement(uint8_t *data, size_t len)
        icmpv6_for_each_option(opt, &adv[1], end) {
                if (opt->type == ND_OPT_SOURCE_LINKADDR) {
                        // Store address of source MAC-address
        icmpv6_for_each_option(opt, &adv[1], end) {
                if (opt->type == ND_OPT_SOURCE_LINKADDR) {
                        // Store address of source MAC-address

-                       mac_ptr = ((struct nd_opt_slla *)opt)->addr;
+                       mac_ptr = opt->data;

                } else if (opt->type == ND_OPT_RECURSIVE_DNS && opt->len > 1) {
                } else if (opt->type == ND_OPT_RECURSIVE_DNS && opt->len > 1) {

-                       struct nd_opt_recursive_dns *dns = (struct nd_opt_recursive_dns *)opt;

                        // Check if we have to rewrite DNS
                        // Check if we have to rewrite DNS

-                       dns_ptr = (struct in6_addr *)&dns[1];
-                       dns_count = (dns->len - 1) / 2;
+                       dns_ptr = (struct in6_addr*)&opt->data[6];
+                       dns_count = (opt->len - 1) / 2;

                }
        }
 
                }
        }
 


@@ -466,7 +548,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)


@@ -479,13 +560,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_linklocal_interface_address(iface->ifindex, &addr))

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

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

                                rewrite_cnt = 1;
                        }
 
                                rewrite_cnt = 1;
                        }