ipv6_addr_t* add_address_to_interface(char* link_addr, kernel_pid_t iface_pid, uint8_t add_flags)
{
// add a global IPv6 address for the root node
uint8_t prefix_len, flags = 0;
ipv6_addr_t* ifaddr;
ipv6_addr_t addr_dec;
if (ipv6_addr_from_str(&addr_dec, link_addr) == NULL) {
puts("error: unable to parse IPv6 address.");
return NULL;
};
prefix_len = ipv6_addr_split(link_addr, '/', 64);
flags = GNRC_IPV6_NETIF_ADDR_FLAGS_NDP_AUTO | add_flags;
if ((ifaddr = gnrc_ipv6_netif_add_addr(iface_pid, &addr_dec, prefix_len, flags)) == NULL) {
printf("error: unable to add IPv6 address\n");
return NULL;
}
// Address shall be valid infinitely
gnrc_ipv6_netif_addr_get(ifaddr)->valid = UINT32_MAX;
// Address shall be preferred infinitely
gnrc_ipv6_netif_addr_get(ifaddr)->preferred = UINT32_MAX;
return ifaddr;
}
bool gnrc_ndp_internal_pi_opt_handle(kernel_pid_t iface, uint8_t icmpv6_type,
ndp_opt_pi_t *pi_opt)
{
ipv6_addr_t *prefix;
gnrc_ipv6_netif_addr_t *netif_addr;
if ((pi_opt->len != NDP_OPT_MTU_LEN)) {
DEBUG("ndp: invalid MTU option received\n");
return false;
}
if (icmpv6_type != ICMPV6_RTR_ADV || ipv6_addr_is_link_local(&pi_opt->prefix)) {
/* else discard silently */
return true;
}
prefix = gnrc_ipv6_netif_find_addr(iface, &pi_opt->prefix);
if (((prefix == NULL) ||
(gnrc_ipv6_netif_addr_get(prefix)->prefix_len != pi_opt->prefix_len)) &&
(pi_opt->valid_ltime.u32 != 0)) {
prefix = gnrc_ipv6_netif_add_addr(iface, &pi_opt->prefix,
pi_opt->prefix_len,
pi_opt->flags & NDP_OPT_PI_FLAGS_MASK);
if (prefix == NULL) {
DEBUG("ndp: could not add prefix to interface %d\n", iface);
return false;
}
}
netif_addr = gnrc_ipv6_netif_addr_get(prefix);
if (pi_opt->valid_ltime.u32 == 0) {
if (prefix != NULL) {
gnrc_ipv6_netif_remove_addr(iface, &netif_addr->addr);
}
return true;
}
netif_addr->valid = byteorder_ntohl(pi_opt->valid_ltime);
netif_addr->preferred = byteorder_ntohl(pi_opt->pref_ltime);
vtimer_remove(&netif_addr->valid_timeout);
if (netif_addr->valid != UINT32_MAX) {
vtimer_set_msg(&netif_addr->valid_timeout,
timex_set(byteorder_ntohl(pi_opt->valid_ltime), 0),
thread_getpid(), GNRC_NDP_MSG_ADDR_TIMEOUT, &netif_addr->addr);
}
/* TODO: preferred lifetime for address auto configuration */
/* on-link flag MUST stay set if it was */
netif_addr->flags &= ~NDP_OPT_PI_FLAGS_A;
netif_addr->flags |= (pi_opt->flags & NDP_OPT_PI_FLAGS_MASK);
return true;
}
static gnrc_rpl_dodag_t *_root_dodag_init(uint8_t instance_id, ipv6_addr_t *dodag_id, uint8_t mop)
{
if (gnrc_rpl_pid == KERNEL_PID_UNDEF) {
DEBUG("RPL: RPL thread not started\n");
return NULL;
}
ipv6_addr_t *configured_addr;
gnrc_ipv6_netif_addr_t *netif_addr = NULL;
gnrc_rpl_instance_t *inst = NULL;
gnrc_rpl_dodag_t *dodag = NULL;
if (instance_id == 0) {
DEBUG("RPL: instance id (%d) must be a positive number greater than zero\n", instance_id);
return NULL;
}
if (gnrc_ipv6_netif_find_by_addr(&configured_addr, dodag_id) == KERNEL_PID_UNDEF) {
DEBUG("RPL: no IPv6 address configured to match the given dodag id: %s\n",
ipv6_addr_to_str(addr_str, dodag_id, sizeof(addr_str)));
return NULL;
}
if ((netif_addr = gnrc_ipv6_netif_addr_get(configured_addr)) == NULL) {
DEBUG("RPL: no netif address found for %s\n", ipv6_addr_to_str(addr_str, configured_addr,
sizeof(addr_str)));
return NULL;
}
if (gnrc_rpl_instance_add(instance_id, &inst)) {
inst->of = (gnrc_rpl_of_t *) gnrc_rpl_get_of_for_ocp(GNRC_RPL_DEFAULT_OCP);
inst->mop = mop;
inst->min_hop_rank_inc = GNRC_RPL_DEFAULT_MIN_HOP_RANK_INCREASE;
inst->max_rank_inc = GNRC_RPL_DEFAULT_MAX_RANK_INCREASE;
}
else if (inst == NULL) {
DEBUG("RPL: could not allocate memory for a new instance with id %d", instance_id);
return NULL;
}
else if (inst->mop != mop) {
DEBUG("RPL: instance (%d) exists with another MOP", instance_id);
return NULL;
}
if (!gnrc_rpl_dodag_add(inst, dodag_id, &dodag)) {
DEBUG("RPL: DODAG with id %s exists or no memory left for a new DODAG",
ipv6_addr_to_str(addr_str, dodag_id, sizeof(addr_str)));
return NULL;
}
dodag->prefix_len = netif_addr->prefix_len;
dodag->addr_preferred = netif_addr->preferred;
dodag->addr_valid = netif_addr->valid;
return dodag;
}
bool gnrc_ndp_internal_pi_opt_handle(kernel_pid_t iface, uint8_t icmpv6_type,
ndp_opt_pi_t *pi_opt)
{
ipv6_addr_t *prefix;
gnrc_ipv6_netif_addr_t *netif_addr;
if ((pi_opt->len != NDP_OPT_PI_LEN)) {
DEBUG("ndp: invalid PI option received\n");
return false;
}
if (icmpv6_type != ICMPV6_RTR_ADV || ipv6_addr_is_link_local(&pi_opt->prefix)) {
/* else discard silently */
return true;
}
#ifdef MODULE_GNRC_SIXLOWPAN_ND
if ((gnrc_ipv6_netif_get(iface)->flags & GNRC_IPV6_NETIF_FLAGS_SIXLOWPAN) &&
(pi_opt->flags & NDP_OPT_PI_FLAGS_L)) {
/* ignore: see https://tools.ietf.org/html/rfc6775#section-5.4 */
return true;
}
#endif
prefix = gnrc_ipv6_netif_find_addr(iface, &pi_opt->prefix);
if (((prefix == NULL) ||
(gnrc_ipv6_netif_addr_get(prefix)->prefix_len != pi_opt->prefix_len)) &&
(pi_opt->valid_ltime.u32 != 0)) {
ipv6_addr_t pref_addr;
if ((gnrc_netapi_get(iface, NETOPT_IPV6_IID, 0, &pref_addr.u64[1],
sizeof(eui64_t)) < 0)) {
DEBUG("ndp: could not get IID from interface %d\n", iface);
return false;
}
ipv6_addr_init_prefix(&pref_addr, &pi_opt->prefix, pi_opt->prefix_len);
prefix = gnrc_ipv6_netif_add_addr(iface, &pref_addr,
pi_opt->prefix_len,
pi_opt->flags & NDP_OPT_PI_FLAGS_MASK);
if (prefix == NULL) {
DEBUG("ndp: could not add prefix to interface %d\n", iface);
return false;
}
#ifdef MODULE_GNRC_SIXLOWPAN_ND_ROUTER
gnrc_sixlowpan_nd_router_set_rtr_adv(gnrc_ipv6_netif_get(iface), true);
#endif
}
netif_addr = gnrc_ipv6_netif_addr_get(prefix);
if (pi_opt->valid_ltime.u32 == 0) {
if (prefix != NULL) {
gnrc_ipv6_netif_remove_addr(iface, &netif_addr->addr);
}
return true;
}
netif_addr->valid = byteorder_ntohl(pi_opt->valid_ltime);
netif_addr->preferred = byteorder_ntohl(pi_opt->pref_ltime);
if (netif_addr->valid != UINT32_MAX) {
xtimer_set_msg(&netif_addr->valid_timeout,
(byteorder_ntohl(pi_opt->valid_ltime) * SEC_IN_USEC),
&netif_addr->valid_timeout_msg, thread_getpid());
}
/* TODO: preferred lifetime for address auto configuration */
/* on-link flag MUST stay set if it was */
netif_addr->flags &= ~NDP_OPT_PI_FLAGS_A;
netif_addr->flags |= (pi_opt->flags & NDP_OPT_PI_FLAGS_MASK);
return true;
}
static int _netif_add(char *cmd_name, kernel_pid_t dev, int argc, char **argv)
{
#ifdef MODULE_GNRC_IPV6_NETIF
enum {
_UNICAST = 0,
_MULTICAST, /* multicast value just to check if given addr is mc */
_ANYCAST
} type = _UNICAST;
char *addr_str = argv[0];
ipv6_addr_t addr;
ipv6_addr_t *ifaddr;
uint8_t prefix_len, flags = 0;
if (argc > 1) {
if (strcmp(argv[0], "anycast") == 0) {
type = _ANYCAST;
addr_str = argv[1];
}
else if (strcmp(argv[0], "multicast") == 0) {
type = _MULTICAST;
addr_str = argv[1];
}
else if (strcmp(argv[0], "unicast") == 0) {
/* type already set to unicast */
addr_str = argv[1];
}
else {
_add_usage(cmd_name);
return 1;
}
}
prefix_len = _get_prefix_len(addr_str);
if (ipv6_addr_from_str(&addr, addr_str) == NULL) {
puts("error: unable to parse IPv6 address.");
return 1;
}
if ((argc > 1) && (ipv6_addr_is_multicast(&addr)) && (type != _MULTICAST)) {
puts("error: address was not a multicast address.");
return 1;
}
flags = GNRC_IPV6_NETIF_ADDR_FLAGS_NDP_AUTO;
if (type == _ANYCAST) {
flags |= GNRC_IPV6_NETIF_ADDR_FLAGS_NON_UNICAST;
}
else {
flags |= GNRC_IPV6_NETIF_ADDR_FLAGS_UNICAST;
}
if ((ifaddr = gnrc_ipv6_netif_add_addr(dev, &addr, prefix_len, flags)) == NULL) {
printf("error: unable to add IPv6 address\n");
return 1;
}
/* Address shall be valid infinitely */
gnrc_ipv6_netif_addr_get(ifaddr)->valid = UINT32_MAX;
/* Address shall be preferred infinitely */
gnrc_ipv6_netif_addr_get(ifaddr)->preferred = UINT32_MAX;
printf("success: added %s/%d to interface %" PRIkernel_pid "\n", addr_str,
prefix_len, dev);
return 0;
#else
(void)cmd_name;
(void)dev;
(void)argc;
(void)argv;
puts("error: unable to add IPv6 address.");
return 1;
#endif
}
void gnrc_rpl_recv_DIO(gnrc_rpl_dio_t *dio, kernel_pid_t iface, ipv6_addr_t *src, uint16_t len)
{
gnrc_rpl_instance_t *inst = NULL;
gnrc_rpl_dodag_t *dodag = NULL;
if (!_gnrc_rpl_check_DIO_validity(dio, len)) {
return;
}
len -= (sizeof(gnrc_rpl_dio_t) + sizeof(icmpv6_hdr_t));
if (gnrc_rpl_instance_add(dio->instance_id, &inst)) {
/* new instance and DODAG */
if (byteorder_ntohs(dio->rank) == GNRC_RPL_INFINITE_RANK) {
DEBUG("RPL: ignore INFINITE_RANK DIO when we are not yet part of this DODAG\n");
gnrc_rpl_instance_remove(inst);
return;
}
inst->mop = (dio->g_mop_prf >> GNRC_RPL_MOP_SHIFT) & GNRC_RPL_SHIFTED_MOP_MASK;
inst->of = gnrc_rpl_get_of_for_ocp(GNRC_RPL_DEFAULT_OCP);
if (iface == KERNEL_PID_UNDEF) {
iface = gnrc_ipv6_netif_find_by_addr(NULL, &ipv6_addr_all_rpl_nodes);
assert(iface != KERNEL_PID_UNDEF);
}
gnrc_rpl_dodag_init(inst, &dio->dodag_id, iface, NULL);
dodag = &inst->dodag;
DEBUG("RPL: Joined DODAG (%s).\n",
ipv6_addr_to_str(addr_str, &dio->dodag_id, sizeof(addr_str)));
gnrc_rpl_parent_t *parent = NULL;
if (!gnrc_rpl_parent_add_by_addr(dodag, src, &parent) && (parent == NULL)) {
DEBUG("RPL: Could not allocate new parent.\n");
gnrc_rpl_instance_remove(inst);
return;
}
dodag->version = dio->version_number;
dodag->grounded = dio->g_mop_prf >> GNRC_RPL_GROUNDED_SHIFT;
dodag->prf = dio->g_mop_prf & GNRC_RPL_PRF_MASK;
parent->rank = byteorder_ntohs(dio->rank);
uint32_t included_opts = 0;
if(!_parse_options(GNRC_RPL_ICMPV6_CODE_DIO, inst, (gnrc_rpl_opt_t *)(dio + 1), len,
src, &included_opts)) {
DEBUG("RPL: Error encountered during DIO option parsing - remove DODAG\n");
gnrc_rpl_instance_remove(inst);
return;
}
if (!(included_opts & (((uint32_t) 1) << GNRC_RPL_OPT_DODAG_CONF))) {
#ifndef GNRC_RPL_DODAG_CONF_OPTIONAL_ON_JOIN
DEBUG("RPL: DIO without DODAG_CONF option - remove DODAG and request new DIO\n");
gnrc_rpl_instance_remove(inst);
gnrc_rpl_send_DIS(NULL, src);
return;
#else
DEBUG("RPL: DIO without DODAG_CONF option - use default trickle parameters\n");
gnrc_rpl_send_DIS(NULL, src);
#endif
}
/* if there was no netif_addr created manually or by a PIO, then leave this DODAG */
if (!dodag->netif_addr) {
ipv6_addr_t *configured_addr;
if (!(configured_addr = gnrc_ipv6_netif_match_prefix(dodag->iface, &dodag->dodag_id))) {
DEBUG("RPL: no IPv6 address configured to match the given dodag id: %s\n",
ipv6_addr_to_str(addr_str, &(dodag->dodag_id), sizeof(addr_str)));
gnrc_rpl_instance_remove(inst);
return;
}
if (!(dodag->netif_addr = gnrc_ipv6_netif_addr_get(configured_addr))) {
DEBUG("RPL: no netif address found for %s\n",
ipv6_addr_to_str(addr_str, configured_addr, sizeof(addr_str)));
gnrc_rpl_instance_remove(inst);
return;
}
}
gnrc_rpl_delay_dao(dodag);
trickle_start(gnrc_rpl_pid, &dodag->trickle, GNRC_RPL_MSG_TYPE_TRICKLE_INTERVAL,
GNRC_RPL_MSG_TYPE_TRICKLE_CALLBACK, (1 << dodag->dio_min),
dodag->dio_interval_doubl, dodag->dio_redun);
gnrc_rpl_parent_update(dodag, parent);
return;
}
else if (inst == NULL) {
/** @todo allow target prefixes in target options to be of variable length */
bool _parse_options(int msg_type, gnrc_rpl_instance_t *inst, gnrc_rpl_opt_t *opt, uint16_t len,
ipv6_addr_t *src, uint32_t *included_opts)
{
uint16_t l = 0;
gnrc_rpl_opt_target_t *first_target = NULL;
gnrc_rpl_dodag_t *dodag = &inst->dodag;
eui64_t iid;
*included_opts = 0;
ipv6_addr_t *me;
if (!_gnrc_rpl_check_options_validity(msg_type, inst, opt, len)) {
return false;
}
while(l < len) {
switch(opt->type) {
case (GNRC_RPL_OPT_PAD1):
DEBUG("RPL: PAD1 option parsed\n");
*included_opts |= ((uint32_t) 1) << GNRC_RPL_OPT_PAD1;
l += 1;
opt = (gnrc_rpl_opt_t *) (((uint8_t *) opt) + 1);
continue;
case (GNRC_RPL_OPT_PADN):
DEBUG("RPL: PADN option parsed\n");
*included_opts |= ((uint32_t) 1) << GNRC_RPL_OPT_PADN;
break;
case (GNRC_RPL_OPT_DODAG_CONF):
DEBUG("RPL: DODAG CONF DIO option parsed\n");
*included_opts |= ((uint32_t) 1) << GNRC_RPL_OPT_DODAG_CONF;
dodag->dio_opts |= GNRC_RPL_REQ_DIO_OPT_DODAG_CONF;
gnrc_rpl_opt_dodag_conf_t *dc = (gnrc_rpl_opt_dodag_conf_t *) opt;
gnrc_rpl_of_t *of = gnrc_rpl_get_of_for_ocp(byteorder_ntohs(dc->ocp));
if (of != NULL) {
inst->of = of;
}
else {
DEBUG("RPL: Unsupported OCP 0x%02x\n", byteorder_ntohs(dc->ocp));
inst->of = gnrc_rpl_get_of_for_ocp(GNRC_RPL_DEFAULT_OCP);
}
dodag->dio_interval_doubl = dc->dio_int_doubl;
dodag->dio_min = dc->dio_int_min;
dodag->dio_redun = dc->dio_redun;
inst->max_rank_inc = byteorder_ntohs(dc->max_rank_inc);
inst->min_hop_rank_inc = byteorder_ntohs(dc->min_hop_rank_inc);
dodag->default_lifetime = dc->default_lifetime;
dodag->lifetime_unit = byteorder_ntohs(dc->lifetime_unit);
dodag->trickle.Imin = (1 << dodag->dio_min);
dodag->trickle.Imax = dodag->dio_interval_doubl;
dodag->trickle.k = dodag->dio_redun;
break;
case (GNRC_RPL_OPT_PREFIX_INFO):
DEBUG("RPL: Prefix Information DIO option parsed\n");
*included_opts |= ((uint32_t) 1) << GNRC_RPL_OPT_PREFIX_INFO;
#ifndef GNRC_RPL_WITHOUT_PIO
dodag->dio_opts |= GNRC_RPL_REQ_DIO_OPT_PREFIX_INFO;
#endif
gnrc_rpl_opt_prefix_info_t *pi = (gnrc_rpl_opt_prefix_info_t *) opt;
/* check for the auto address-configuration flag */
if ((gnrc_netapi_get(dodag->iface, NETOPT_IPV6_IID, 0, &iid, sizeof(eui64_t)) < 0)
&& !(pi->LAR_flags & GNRC_RPL_PREFIX_AUTO_ADDRESS_BIT)) {
break;
}
ipv6_addr_set_aiid(&pi->prefix, iid.uint8);
me = gnrc_ipv6_netif_add_addr(dodag->iface, &pi->prefix, pi->prefix_len, 0);
if (me) {
dodag->netif_addr = gnrc_ipv6_netif_addr_get(me);
}
break;
case (GNRC_RPL_OPT_TARGET):
DEBUG("RPL: RPL TARGET DAO option parsed\n");
*included_opts |= ((uint32_t) 1) << GNRC_RPL_OPT_TARGET;
gnrc_rpl_opt_target_t *target = (gnrc_rpl_opt_target_t *) opt;
if (first_target == NULL) {
first_target = target;
}
uint32_t fib_dst_flags = 0;
if (target->prefix_length < IPV6_ADDR_BIT_LEN) {
fib_dst_flags = ((uint32_t)(target->prefix_length) << FIB_FLAG_NET_PREFIX_SHIFT);
}
DEBUG("RPL: adding fib entry %s/%d 0x%" PRIx32 "\n",
ipv6_addr_to_str(addr_str, &(target->target), sizeof(addr_str)),
target->prefix_length,
fib_dst_flags);
fib_add_entry(&gnrc_ipv6_fib_table, dodag->iface, target->target.u8,
sizeof(ipv6_addr_t), fib_dst_flags, src->u8,
sizeof(ipv6_addr_t), FIB_FLAG_RPL_ROUTE,
(dodag->default_lifetime * dodag->lifetime_unit) *
SEC_IN_MS);
break;
case (GNRC_RPL_OPT_TRANSIT):
DEBUG("RPL: RPL TRANSIT INFO DAO option parsed\n");
*included_opts |= ((uint32_t) 1) << GNRC_RPL_OPT_TRANSIT;
gnrc_rpl_opt_transit_t *transit = (gnrc_rpl_opt_transit_t *) opt;
if (first_target == NULL) {
DEBUG("RPL: Encountered a RPL TRANSIT DAO option without "
"a preceding RPL TARGET DAO option\n");
break;
}
do {
DEBUG("RPL: updating fib entry %s/%d\n",
ipv6_addr_to_str(addr_str, &(first_target->target), sizeof(addr_str)),
first_target->prefix_length);
fib_update_entry(&gnrc_ipv6_fib_table,
first_target->target.u8,
sizeof(ipv6_addr_t), src->u8,
sizeof(ipv6_addr_t),
((transit->e_flags & GNRC_RPL_OPT_TRANSIT_E_FLAG) ?
0x0 : FIB_FLAG_RPL_ROUTE),
(transit->path_lifetime *
dodag->lifetime_unit * SEC_IN_MS));
first_target = (gnrc_rpl_opt_target_t *) (((uint8_t *) (first_target)) +
sizeof(gnrc_rpl_opt_t) + first_target->length);
}
while (first_target->type == GNRC_RPL_OPT_TARGET);
first_target = NULL;
break;
#ifdef MODULE_GNRC_RPL_P2P
case (GNRC_RPL_P2P_OPT_RDO):
gnrc_rpl_p2p_rdo_parse((gnrc_rpl_p2p_opt_rdo_t *) opt, gnrc_rpl_p2p_ext_get(dodag));
break;
#endif
}
l += opt->length + sizeof(gnrc_rpl_opt_t);
opt = (gnrc_rpl_opt_t *) (((uint8_t *) (opt + 1)) + opt->length);
}
return true;
}
