static int send_ra(int sock, struct Interface *iface, struct in6_addr const *dest)
{
if (!iface->AdvSendAdvert) {
dlog(LOG_DEBUG, 2, "AdvSendAdvert is off for %s", iface->props.name);
return 0;
}
if (dest == NULL) {
static uint8_t const all_hosts_addr[] = { 0xff, 0x02, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 };
dest = (struct in6_addr const *)all_hosts_addr;
clock_gettime(CLOCK_MONOTONIC, &iface->times.last_multicast);
}
update_iface_times(iface);
char address_text[INET6_ADDRSTRLEN] = { "" };
inet_ntop(AF_INET6, dest, address_text, INET6_ADDRSTRLEN);
dlog(LOG_DEBUG, 5, "sending RA to %s on %s", address_text, iface->props.name);
struct safe_buffer safe_buffer = SAFE_BUFFER_INIT;
build_ra(&safe_buffer, iface);
int err = really_send(sock, dest, &iface->props, &safe_buffer);
safe_buffer_free(&safe_buffer);
if (err < 0) {
if (!iface->IgnoreIfMissing || !(errno == EINVAL || errno == ENODEV))
flog(LOG_WARNING, "sendmsg: %s", strerror(errno));
else
dlog(LOG_DEBUG, 3, "sendmsg: %s", strerror(errno));
return -1;
}
return 0;
}
int send_ra(struct Interface *iface, struct in6_addr *dest)
{
struct in6_addr all_hosts_addr = {{{0xff,0x02,0,0,0,0,0,0,0,0,0,0,0,0,0,1}}};
struct nd_router_advert *radvert;
struct AdvPrefix *prefix;
struct AdvRoute *route;
struct AdvRDNSS *rdnss;
struct AdvDNSSL *dnssl;
struct AdvLowpanCo *lowpanco;
struct AdvAbro *abroo;
struct timespec time_now;
int64_t secs_since_last_ra;
char addr_str[INET6_ADDRSTRLEN];
unsigned char buff[MSG_SIZE_SEND];
size_t buff_dest = 0;
size_t len = 0;
ssize_t err;
update_device_info(iface);
/* First we need to check that the interface hasn't been removed or deactivated */
if (check_device(iface) < 0) {
if (iface->IgnoreIfMissing) /* a bit more quiet warning message.. */
dlog(LOG_DEBUG, 4, "interface %s does not exist, ignoring the interface", iface->Name);
else {
flog(LOG_WARNING, "interface %s does not exist, ignoring the interface", iface->Name);
}
iface->HasFailed = 1;
/* not really a 'success', but we need to schedule new timers.. */
return 0;
} else {
/* check_device was successful, act if it has failed previously */
if (iface->HasFailed == 1) {
flog(LOG_WARNING, "interface %s seems to have come back up, trying to reinitialize", iface->Name);
iface->HasFailed = 0;
/*
* return -1 so timer_handler() doesn't schedule new timers,
* reload_config() will kick off new timers anyway. This avoids
* timer list corruption.
*/
reload_config();
return -1;
}
}
/* Make sure that we've joined the all-routers multicast group */
if (!disableigmp6check && check_allrouters_membership(iface) < 0)
flog(LOG_WARNING, "problem checking all-routers membership on %s", iface->Name);
if (!iface->AdvSendAdvert) {
dlog(LOG_DEBUG, 2, "AdvSendAdvert is off for %s", iface->Name);
return 0;
}
dlog(LOG_DEBUG, 3, "sending RA on %s", iface->Name);
if (dest == NULL) {
dest = (struct in6_addr *)&all_hosts_addr;
clock_gettime(CLOCK_MONOTONIC, &iface->last_multicast);
}
clock_gettime(CLOCK_MONOTONIC, &time_now);
secs_since_last_ra = timespecdiff(&time_now, &iface->last_ra_time) / 1000;
if (secs_since_last_ra < 0) {
secs_since_last_ra = 0;
flog(LOG_WARNING, "clock_gettime(CLOCK_MONOTONIC) went backwards!");
}
iface->last_ra_time = time_now;
memset(buff, 0, sizeof(buff));
radvert = (struct nd_router_advert *)buff;
send_ra_inc_len(&len, sizeof(struct nd_router_advert));
radvert->nd_ra_type = ND_ROUTER_ADVERT;
radvert->nd_ra_code = 0;
radvert->nd_ra_cksum = 0;
radvert->nd_ra_curhoplimit = iface->AdvCurHopLimit;
radvert->nd_ra_flags_reserved = (iface->AdvManagedFlag) ? ND_RA_FLAG_MANAGED : 0;
radvert->nd_ra_flags_reserved |= (iface->AdvOtherConfigFlag) ? ND_RA_FLAG_OTHER : 0;
/* Mobile IPv6 ext */
radvert->nd_ra_flags_reserved |= (iface->AdvHomeAgentFlag) ? ND_RA_FLAG_HOME_AGENT : 0;
if (iface->cease_adv) {
radvert->nd_ra_router_lifetime = 0;
} else {
/* if forwarding is disabled, send zero router lifetime */
radvert->nd_ra_router_lifetime = !check_ip6_forwarding()? htons(iface->AdvDefaultLifetime) : 0;
}
radvert->nd_ra_flags_reserved |= (iface->AdvDefaultPreference << ND_OPT_RI_PRF_SHIFT) & ND_OPT_RI_PRF_MASK;
radvert->nd_ra_reachable = htonl(iface->AdvReachableTime);
radvert->nd_ra_retransmit = htonl(iface->AdvRetransTimer);
prefix = iface->AdvPrefixList;
/*
* add prefix options
*/
while (prefix) {
if (prefix->enabled && (!prefix->DecrementLifetimesFlag || prefix->curr_preferredlft > 0)) {
struct nd_opt_prefix_info *pinfo;
pinfo = (struct nd_opt_prefix_info *)(buff + len);
send_ra_inc_len(&len, sizeof(*pinfo));
pinfo->nd_opt_pi_type = ND_OPT_PREFIX_INFORMATION;
pinfo->nd_opt_pi_len = 4;
pinfo->nd_opt_pi_prefix_len = prefix->PrefixLen;
pinfo->nd_opt_pi_flags_reserved = (prefix->AdvOnLinkFlag) ? ND_OPT_PI_FLAG_ONLINK : 0;
pinfo->nd_opt_pi_flags_reserved |= (prefix->AdvAutonomousFlag) ? ND_OPT_PI_FLAG_AUTO : 0;
/* Mobile IPv6 ext */
pinfo->nd_opt_pi_flags_reserved |= (prefix->AdvRouterAddr) ? ND_OPT_PI_FLAG_RADDR : 0;
if (iface->cease_adv && prefix->DeprecatePrefixFlag) {
/* RFC4862, 5.5.3, step e) */
if (prefix->curr_validlft < MIN_AdvValidLifetime) {
if (prefix->DecrementLifetimesFlag) {
decrement_lifetime(secs_since_last_ra,
&prefix->curr_validlft);
}
pinfo->nd_opt_pi_valid_time = htonl(prefix->curr_validlft);
} else {
pinfo->nd_opt_pi_valid_time = htonl(MIN_AdvValidLifetime);
}
pinfo->nd_opt_pi_preferred_time = 0;
} else {
if (prefix->DecrementLifetimesFlag) {
decrement_lifetime(secs_since_last_ra, &prefix->curr_validlft);
decrement_lifetime(secs_since_last_ra, &prefix->curr_preferredlft);
if (prefix->curr_preferredlft == 0)
cease_adv_pfx_msg(iface->Name, &prefix->Prefix, prefix->PrefixLen);
}
pinfo->nd_opt_pi_valid_time = htonl(prefix->curr_validlft);
pinfo->nd_opt_pi_preferred_time = htonl(prefix->curr_preferredlft);
}
pinfo->nd_opt_pi_reserved2 = 0;
memcpy(&pinfo->nd_opt_pi_prefix, &prefix->Prefix, sizeof(struct in6_addr));
print_addr(&prefix->Prefix, addr_str);
dlog(LOG_DEBUG, 5, "adding prefix %s to advert for %s with %u seconds(s) valid lifetime and %u seconds(s) preferred time",
addr_str, iface->Name, ntohl(pinfo->nd_opt_pi_valid_time), ntohl(pinfo->nd_opt_pi_preferred_time));
}
prefix = prefix->next;
}
route = iface->AdvRouteList;
/*
* add route options
*/
while (route) {
struct nd_opt_route_info_local *rinfo;
rinfo = (struct nd_opt_route_info_local *)(buff + len);
send_ra_inc_len(&len, sizeof(*rinfo));
rinfo->nd_opt_ri_type = ND_OPT_ROUTE_INFORMATION;
/* XXX: the prefixes are allowed to be sent in smaller chunks as well */
rinfo->nd_opt_ri_len = 3;
rinfo->nd_opt_ri_prefix_len = route->PrefixLen;
rinfo->nd_opt_ri_flags_reserved = (route->AdvRoutePreference << ND_OPT_RI_PRF_SHIFT) & ND_OPT_RI_PRF_MASK;
if (iface->cease_adv && route->RemoveRouteFlag) {
rinfo->nd_opt_ri_lifetime = 0;
} else {
rinfo->nd_opt_ri_lifetime = htonl(route->AdvRouteLifetime);
}
memcpy(&rinfo->nd_opt_ri_prefix, &route->Prefix, sizeof(struct in6_addr));
route = route->next;
}
rdnss = iface->AdvRDNSSList;
/*
* add rdnss options
*/
while (rdnss) {
struct nd_opt_rdnss_info_local *rdnssinfo;
rdnssinfo = (struct nd_opt_rdnss_info_local *)(buff + len);
send_ra_inc_len(&len, sizeof(*rdnssinfo) - (3 - rdnss->AdvRDNSSNumber) * sizeof(struct in6_addr));
rdnssinfo->nd_opt_rdnssi_type = ND_OPT_RDNSS_INFORMATION;
rdnssinfo->nd_opt_rdnssi_len = 1 + 2 * rdnss->AdvRDNSSNumber;
rdnssinfo->nd_opt_rdnssi_pref_flag_reserved = 0;
if (iface->cease_adv && rdnss->FlushRDNSSFlag) {
rdnssinfo->nd_opt_rdnssi_lifetime = 0;
} else {
rdnssinfo->nd_opt_rdnssi_lifetime = htonl(rdnss->AdvRDNSSLifetime);
}
memcpy(&rdnssinfo->nd_opt_rdnssi_addr1, &rdnss->AdvRDNSSAddr1, sizeof(struct in6_addr));
memcpy(&rdnssinfo->nd_opt_rdnssi_addr2, &rdnss->AdvRDNSSAddr2, sizeof(struct in6_addr));
memcpy(&rdnssinfo->nd_opt_rdnssi_addr3, &rdnss->AdvRDNSSAddr3, sizeof(struct in6_addr));
rdnss = rdnss->next;
}
dnssl = iface->AdvDNSSLList;
/*
* add dnssl options
*/
while (dnssl) {
struct nd_opt_dnssl_info_local *dnsslinfo;
int const start_len = len;
int i;
dnsslinfo = (struct nd_opt_dnssl_info_local *)(buff + len);
send_ra_inc_len(&len, sizeof(dnsslinfo->nd_opt_dnssli_type) +
sizeof(dnsslinfo->nd_opt_dnssli_len) + sizeof(dnsslinfo->nd_opt_dnssli_reserved) + sizeof(dnsslinfo->nd_opt_dnssli_lifetime)
);
dnsslinfo->nd_opt_dnssli_type = ND_OPT_DNSSL_INFORMATION;
dnsslinfo->nd_opt_dnssli_reserved = 0;
if (iface->cease_adv && dnssl->FlushDNSSLFlag) {
dnsslinfo->nd_opt_dnssli_lifetime = 0;
} else {
dnsslinfo->nd_opt_dnssli_lifetime = htonl(dnssl->AdvDNSSLLifetime);
}
for (i = 0; i < dnssl->AdvDNSSLNumber; i++) {
char *label;
int label_len;
label = dnssl->AdvDNSSLSuffixes[i];
while (label[0] != '\0') {
if (strchr(label, '.') == NULL)
label_len = strlen(label);
else
label_len = strchr(label, '.') - label;
buff_dest = len;
send_ra_inc_len(&len, 1);
buff[buff_dest] = label_len;
buff_dest = len;
send_ra_inc_len(&len, label_len);
memcpy(buff + buff_dest, label, label_len);
label += label_len;
if (label[0] == '.')
label++;
if (label[0] == '\0') {
buff_dest = len;
send_ra_inc_len(&len, 1);
buff[buff_dest] = 0;
}
}
}
dnsslinfo->nd_opt_dnssli_len = (len - start_len) / 8;
if ((len - start_len) % 8 != 0) {
send_ra_inc_len(&len, 8 - (len - start_len) % 8);
++dnsslinfo->nd_opt_dnssli_len;
}
dnssl = dnssl->next;
}
/*
* add MTU option
*/
if (iface->AdvLinkMTU != 0) {
struct nd_opt_mtu *mtu;
mtu = (struct nd_opt_mtu *)(buff + len);
send_ra_inc_len(&len, sizeof(*mtu));
mtu->nd_opt_mtu_type = ND_OPT_MTU;
mtu->nd_opt_mtu_len = 1;
mtu->nd_opt_mtu_reserved = 0;
mtu->nd_opt_mtu_mtu = htonl(iface->AdvLinkMTU);
}
/*
* add Source Link-layer Address option
*/
if (iface->AdvSourceLLAddress && iface->if_hwaddr_len > 0) {
/*
4.6.1. Source/Target Link-layer Address
0 1 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Type | Length | Link-Layer Address ...
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
Fields:
Type
1 for Source Link-layer Address
2 for Target Link-layer Address
Length The length of the option (including the type and
length fields) in units of 8 octets. For example,
the length for IEEE 802 addresses is 1 [IPv6-
ETHER].
Link-Layer Address
The variable length link-layer address.
The content and format of this field (including
byte and bit ordering) is expected to be specified
in specific documents that describe how IPv6
operates over different link layers. For instance,
[IPv6-ETHER].
*/
/* +2 for the ND_OPT_SOURCE_LINKADDR and the length (each occupy one byte) */
size_t const sllao_bytes = (iface->if_hwaddr_len / 8) + 2;
size_t const sllao_len = (sllao_bytes + 7) / 8;
uint8_t *sllao = (uint8_t *) (buff + len);
send_ra_inc_len(&len, sllao_len * 8);
*sllao++ = ND_OPT_SOURCE_LINKADDR;
*sllao++ = (uint8_t) sllao_len;
/* if_hwaddr_len is in bits, so divide by 8 to get the byte count. */
memcpy(sllao, iface->if_hwaddr, iface->if_hwaddr_len / 8);
}
/*
* Mobile IPv6 ext: Advertisement Interval Option to support
* movement detection of mobile nodes
*/
if (iface->AdvIntervalOpt) {
struct AdvInterval a_ival;
uint32_t ival;
if (iface->MaxRtrAdvInterval < Cautious_MaxRtrAdvInterval) {
ival = ((iface->MaxRtrAdvInterval + Cautious_MaxRtrAdvInterval_Leeway) * 1000);
} else {
ival = (iface->MaxRtrAdvInterval * 1000);
}
a_ival.type = ND_OPT_RTR_ADV_INTERVAL;
a_ival.length = 1;
a_ival.reserved = 0;
a_ival.adv_ival = htonl(ival);
buff_dest = len;
send_ra_inc_len(&len, sizeof(a_ival));
memcpy(buff + buff_dest, &a_ival, sizeof(a_ival));
}
/*
* Mobile IPv6 ext: Home Agent Information Option to support
* Dynamic Home Agent Address Discovery
*/
if (iface->AdvHomeAgentInfo && (iface->AdvMobRtrSupportFlag || iface->HomeAgentPreference != 0 || iface->HomeAgentLifetime != iface->AdvDefaultLifetime)) {
struct HomeAgentInfo ha_info;
ha_info.type = ND_OPT_HOME_AGENT_INFO;
ha_info.length = 1;
ha_info.flags_reserved = (iface->AdvMobRtrSupportFlag) ? ND_OPT_HAI_FLAG_SUPPORT_MR : 0;
ha_info.preference = htons(iface->HomeAgentPreference);
ha_info.lifetime = htons(iface->HomeAgentLifetime);
buff_dest = len;
send_ra_inc_len(&len, sizeof(ha_info));
memcpy(buff + buff_dest, &ha_info, sizeof(ha_info));
}
lowpanco = iface->AdvLowpanCoList;
/*
* Add 6co option
*/
if (lowpanco) {
struct nd_opt_6co *co;
co = (struct nd_opt_6co *)(buff + len);
send_ra_inc_len(&len, sizeof(*co));
co->nd_opt_6co_type = ND_OPT_6CO;
co->nd_opt_6co_len = 3;
co->nd_opt_6co_context_len = lowpanco->ContextLength;
co->nd_opt_6co_c = lowpanco->ContextCompressionFlag;
co->nd_opt_6co_cid = lowpanco->AdvContextID;
co->nd_opt_6co_valid_lifetime = lowpanco->AdvLifeTime;
co->nd_opt_6co_con_prefix = lowpanco->AdvContextPrefix;
}
abroo = iface->AdvAbroList;
/*
* Add ABRO option
*/
if (abroo) {
struct nd_opt_abro *abro;
abro = (struct nd_opt_abro *)(buff + len);
send_ra_inc_len(&len, sizeof(*abro));
abro->nd_opt_abro_type = ND_OPT_ABRO;
abro->nd_opt_abro_len = 3;
abro->nd_opt_abro_ver_low = abroo->Version[1];
abro->nd_opt_abro_ver_high = abroo->Version[0];
abro->nd_opt_abro_valid_lifetime = abroo->ValidLifeTime;
abro->nd_opt_abro_6lbr_address = abroo->LBRaddress;
}
err = really_send(dest, iface->if_index, iface->if_addr, buff, len);
if (err < 0) {
if (!iface->IgnoreIfMissing || !(errno == EINVAL || errno == ENODEV))
flog(LOG_WARNING, "sendmsg: %s", strerror(errno));
else
dlog(LOG_DEBUG, 3, "sendmsg: %s", strerror(errno));
}
return 0;
}
