void rpl_parent_update(rpl_parent_t *parent)
{
rpl_dodag_t *my_dodag = rpl_get_my_dodag();
uint16_t old_rank;
if (my_dodag == NULL) {
DEBUG("Not part of a dodag - this should not happen");
return;
}
old_rank = my_dodag->my_rank;
/* update Parent lifetime */
if (parent != NULL) {
parent->lifetime = my_dodag->default_lifetime * my_dodag->lifetime_unit;
}
if (rpl_find_preferred_parent() == NULL) {
rpl_local_repair();
}
if (rpl_calc_rank(old_rank, my_dodag->minhoprankincrease) !=
rpl_calc_rank(my_dodag->my_rank, my_dodag->minhoprankincrease)) {
if (my_dodag->my_rank < my_dodag->min_rank) {
my_dodag->min_rank = my_dodag->my_rank;
}
reset_trickletimer();
}
}
void send_DAO_ACK(ipv6_addr_t *destination)
{
char addr_str[IPV6_MAX_ADDR_STR_LEN];
printf("%s\n", ipv6_addr_to_str(addr_str, destination));
rpl_dodag_t *my_dodag;
my_dodag = rpl_get_my_dodag();
if (my_dodag == NULL) {
return;
}
mutex_lock(&rpl_send_mutex);
icmp_send_buf = get_rpl_send_icmpv6_buf(ipv6_ext_hdr_len);
icmp_send_buf->type = ICMPV6_TYPE_RPL_CONTROL;
icmp_send_buf->code = ICMP_CODE_DAO_ACK;
icmp_send_buf->checksum = ~icmpv6_csum(IPV6_PROTO_NUM_ICMPV6);
rpl_send_dao_ack_buf = get_rpl_send_dao_ack_buf();
rpl_send_dao_ack_buf->rpl_instanceid = my_dodag->instance->id;
rpl_send_dao_ack_buf->d_reserved = 0;
rpl_send_dao_ack_buf->dao_sequence = my_dodag->dao_seq;
rpl_send_dao_ack_buf->status = 0;
uint16_t plen = ICMPV6_HDR_LEN + DIS_BASE_LEN;
rpl_send(destination, (uint8_t *)icmp_send_buf, plen, IPV6_PROTO_NUM_ICMPV6, NULL);
mutex_unlock(&rpl_send_mutex);
}
void send_DAO_ACK(ipv6_addr_t *destination)
{
DEBUG("%s, %d: Send DAO ACK\n", __FILE__, __LINE__);
rpl_dodag_t *my_dodag;
my_dodag = rpl_get_my_dodag();
if (my_dodag == NULL) {
return;
}
mutex_lock(&rpl_send_mutex);
icmp_send_buf = get_rpl_send_icmpv6_buf(ipv6_ext_hdr_len);
icmp_send_buf->type = ICMPV6_TYPE_RPL_CONTROL;
icmp_send_buf->code = ICMP_CODE_DAO_ACK;
rpl_send_dao_ack_buf = get_rpl_send_dao_ack_buf();
rpl_send_dao_ack_buf->rpl_instanceid = my_dodag->instance->id;
rpl_send_dao_ack_buf->d_reserved = 0;
rpl_send_dao_ack_buf->dao_sequence = my_dodag->dao_seq;
rpl_send_dao_ack_buf->status = 0;
uint16_t plen = ICMPV6_HDR_LEN + DAO_ACK_LEN;
rpl_send(destination, (uint8_t *)icmp_send_buf, plen, IPV6_PROTO_NUM_ICMPV6);
mutex_unlock(&rpl_send_mutex);
}
void rpl_udp_dodag(int argc, char **argv)
{
(void) argc;
(void) argv;
printf("---------------------------\n");
rpl_dodag_t *mydodag = rpl_get_my_dodag();
if (mydodag == NULL) {
printf("Not part of a dodag\n");
printf("---------------------------\n");
return;
}
printf("Part of Dodag:\n");
printf("%s\n", ipv6_addr_to_str(addr_str, IPV6_MAX_ADDR_STR_LEN,
(&mydodag->dodag_id)));
printf("my rank: %d\n", mydodag->my_rank);
if (!is_root) {
printf("my preferred parent:\n");
printf("%s\n", ipv6_addr_to_str(addr_str, IPV6_MAX_ADDR_STR_LEN,
(&mydodag->my_preferred_parent->addr)));
}
printf("---------------------------\n");
}
void rpl_global_repair(rpl_dodag_t *dodag, ipv6_addr_t *p_addr, uint16_t rank)
{
puts("[INFO] Global repair started");
rpl_dodag_t *my_dodag = rpl_get_my_dodag();
if (my_dodag == NULL) {
printf("[Error] - no global repair possible, if not part of a DODAG\n");
return;
}
rpl_delete_all_parents();
my_dodag->version = dodag->version;
my_dodag->dtsn++;
my_dodag->my_preferred_parent = rpl_new_parent(my_dodag, p_addr, rank);
if (my_dodag->my_preferred_parent == NULL) {
printf("[Error] no more parent after global repair\n");
my_dodag->my_rank = INFINITE_RANK;
}
else {
/* Calc new Rank */
my_dodag->my_rank = my_dodag->of->calc_rank(my_dodag->my_preferred_parent,
my_dodag->my_rank);
my_dodag->min_rank = my_dodag->my_rank;
reset_trickletimer();
delay_dao();
}
printf("Migrated to DODAG Version %d. My new Rank: %d\n", my_dodag->version,
my_dodag->my_rank);
}
void rpl_send_DIO_mode(ipv6_addr_t *destination)
{
if (i_am_leaf) {
return;
}
rpl_dodag_t *mydodag;
icmp_send_buf = get_rpl_send_icmpv6_buf(ipv6_ext_hdr_len);
mydodag = rpl_get_my_dodag();
if (mydodag == NULL) {
DEBUGF("Error - trying to send DIO without being part of a dodag.\n");
return;
}
icmp_send_buf->type = ICMPV6_TYPE_RPL_CONTROL;
icmp_send_buf->code = ICMP_CODE_DIO;
rpl_send_dio_buf = get_rpl_send_dio_buf();
memset(rpl_send_dio_buf, 0, sizeof(*rpl_send_dio_buf));
DEBUGF("Sending DIO with ");
rpl_send_dio_buf->rpl_instanceid = mydodag->instance->id;
DEBUG("instance %02X ", rpl_send_dio_buf->rpl_instanceid);
rpl_send_dio_buf->version_number = mydodag->version;
rpl_send_dio_buf->rank = mydodag->my_rank;
DEBUG("rank %04X\n", rpl_send_dio_buf->rank);
rpl_send_dio_buf->g_mop_prf = (mydodag->grounded << RPL_GROUNDED_SHIFT) |
(mydodag->mop << RPL_MOP_SHIFT) | mydodag->prf;
rpl_send_dio_buf->dtsn = mydodag->dtsn;
rpl_send_dio_buf->flags = 0;
rpl_send_dio_buf->reserved = 0;
rpl_send_dio_buf->dodagid = mydodag->dodag_id;
int opt_hdr_len = 0;
/* DODAG configuration option */
rpl_send_opt_dodag_conf_buf = get_rpl_send_opt_dodag_conf_buf(DIO_BASE_LEN);
rpl_send_opt_dodag_conf_buf->type = RPL_OPT_DODAG_CONF;
rpl_send_opt_dodag_conf_buf->length = RPL_OPT_DODAG_CONF_LEN;
rpl_send_opt_dodag_conf_buf->flags_a_pcs = 0;
rpl_send_opt_dodag_conf_buf->DIOIntDoubl = mydodag->dio_interval_doubling;
rpl_send_opt_dodag_conf_buf->DIOIntMin = mydodag->dio_min;
rpl_send_opt_dodag_conf_buf->DIORedun = mydodag->dio_redundancy;
rpl_send_opt_dodag_conf_buf->MaxRankIncrease = mydodag->maxrankincrease;
rpl_send_opt_dodag_conf_buf->MinHopRankIncrease = mydodag->minhoprankincrease;
rpl_send_opt_dodag_conf_buf->ocp = mydodag->of->ocp;
DEBUGF("Building done.\n");
rpl_send_opt_dodag_conf_buf->reserved = 0;
rpl_send_opt_dodag_conf_buf->default_lifetime = mydodag->default_lifetime;
rpl_send_opt_dodag_conf_buf->lifetime_unit = mydodag->lifetime_unit;
opt_hdr_len += RPL_OPT_DODAG_CONF_LEN;
uint16_t plen = ICMPV6_HDR_LEN + DIO_BASE_LEN + opt_hdr_len;
rpl_send(destination, (uint8_t *)icmp_send_buf, plen, IPV6_PROTO_NUM_ICMPV6);
}
ipv6_addr_t *rpl_get_my_preferred_parent()
{
rpl_dodag_t *my_dodag = rpl_get_my_dodag();
if (my_dodag == NULL) {
return NULL;
}
return &my_dodag->my_preferred_parent->addr;
}
void rpl_delete_parent(rpl_parent_t *parent)
{
rpl_dodag_t *my_dodag = rpl_get_my_dodag();
if ((my_dodag != NULL) && rpl_equal_id(&my_dodag->my_preferred_parent->addr,
&parent->addr)) {
my_dodag->my_preferred_parent = NULL;
}
memset(parent, 0, sizeof(*parent));
}
void rpl_delete_all_parents(void)
{
rpl_dodag_t *my_dodag = rpl_get_my_dodag();
if (my_dodag != NULL) {
my_dodag->my_preferred_parent = NULL;
}
for (int i = 0; i < RPL_MAX_PARENTS; i++) {
memset(&parents[i], 0, sizeof(parents[i]));
}
}
void send_DIO(ipv6_addr_t *destination)
{
mutex_lock(&rpl_send_mutex);
rpl_dodag_t *mydodag;
icmp_send_buf = get_rpl_send_icmpv6_buf(ipv6_ext_hdr_len);
mydodag = rpl_get_my_dodag();
if(mydodag == NULL) {
printf("Error, trying to send DIO without being part of a dodag. This should not happen\n");
mutex_unlock(&rpl_send_mutex, 0);
return;
}
icmp_send_buf->type = ICMP_RPL_CONTROL;
icmp_send_buf->code = ICMP_CODE_DIO;
icmp_send_buf->checksum = ~icmpv6_csum(PROTO_NUM_ICMPV6);
rpl_send_dio_buf = get_rpl_send_dio_buf();
memset(rpl_send_dio_buf, 0, sizeof(*rpl_send_dio_buf));
rpl_send_dio_buf->rpl_instanceid = mydodag->instance->id;
rpl_send_dio_buf->version_number = mydodag->version;
rpl_send_dio_buf->rank = mydodag->my_rank;
rpl_send_dio_buf->g_mop_prf = (mydodag->grounded << RPL_GROUNDED_SHIFT) | (mydodag->mop << RPL_MOP_SHIFT) | mydodag->prf;
rpl_send_dio_buf->dtsn = mydodag->dtsn;
rpl_send_dio_buf->flags = 0;
rpl_send_dio_buf->reserved = 0;
rpl_send_dio_buf->dodagid = mydodag->dodag_id;
int opt_hdr_len = 0;
/* DODAG Configuration Option! */
rpl_send_opt_dodag_conf_buf = get_rpl_send_opt_dodag_conf_buf(DIO_BASE_LEN);
rpl_send_opt_dodag_conf_buf->type = RPL_OPT_DODAG_CONF;
rpl_send_opt_dodag_conf_buf->length = RPL_OPT_DODAG_CONF_LEN;
rpl_send_opt_dodag_conf_buf->flags_a_pcs = 0;
rpl_send_opt_dodag_conf_buf->DIOIntDoubl = mydodag->dio_interval_doubling;
rpl_send_opt_dodag_conf_buf->DIOIntMin = mydodag->dio_min;
rpl_send_opt_dodag_conf_buf->DIORedun = mydodag->dio_redundancy;
rpl_send_opt_dodag_conf_buf->MaxRankIncrease = mydodag->maxrankincrease;
rpl_send_opt_dodag_conf_buf->MinHopRankIncrease = mydodag->minhoprankincrease;
rpl_send_opt_dodag_conf_buf->ocp = mydodag->of->ocp;
rpl_send_opt_dodag_conf_buf->reserved = 0;
rpl_send_opt_dodag_conf_buf->default_lifetime = mydodag->default_lifetime;
rpl_send_opt_dodag_conf_buf->lifetime_unit = mydodag->lifetime_unit;
opt_hdr_len += RPL_OPT_LEN + RPL_OPT_DODAG_CONF_LEN;
uint16_t plen = ICMPV6_HDR_LEN + DIO_BASE_LEN + opt_hdr_len;
rpl_send(destination, (uint8_t *)icmp_send_buf, plen, PROTO_NUM_ICMPV6, NULL);
mutex_unlock(&rpl_send_mutex, 0);
}
rpl_parent_t *rpl_find_preferred_parent(void)
{
rpl_parent_t *best = NULL;
rpl_dodag_t *my_dodag = rpl_get_my_dodag();
if (my_dodag == NULL) {
DEBUG("Not part of a dodag\n");
return NULL;
}
for (uint8_t i = 0; i < RPL_MAX_PARENTS; i++) {
if (parents[i].used) {
if ((parents[i].rank == INFINITE_RANK) || (parents[i].lifetime <= 1)) {
DEBUG("Infinite rank, bad parent\n");
continue;
}
else if (best == NULL) {
DEBUG("possible parent\n");
best = &parents[i];
}
else {
best = my_dodag->of->which_parent(best, &parents[i]);
}
}
}
if (best == NULL) {
return NULL;
}
if (my_dodag->my_preferred_parent == NULL) {
my_dodag->my_preferred_parent = best;
}
if (!rpl_equal_id(&my_dodag->my_preferred_parent->addr, &best->addr)) {
if (my_dodag->mop != NO_DOWNWARD_ROUTES) {
/* send DAO with ZERO_LIFETIME to old parent */
send_DAO(&my_dodag->my_preferred_parent->addr, 0, false, 0);
}
my_dodag->my_preferred_parent = best;
if (my_dodag->mop != NO_DOWNWARD_ROUTES) {
delay_dao();
}
reset_trickletimer();
}
return best;
}
void rpl_local_repair(void)
{
puts("[INFO] Local Repair started");
rpl_dodag_t *my_dodag = rpl_get_my_dodag();
if (my_dodag == NULL) {
printf("[Error] - no local repair possible, if not part of a DODAG\n");
return;
}
my_dodag->my_rank = INFINITE_RANK;
my_dodag->dtsn++;
rpl_delete_all_parents();
reset_trickletimer();
}
void rpl_udp_loop(int argc, char **argv)
{
(void) argc;
(void) argv;
rpl_routing_entry_t *rtable;
rtable = rpl_get_routing_table();
rpl_dodag_t *mydodag = rpl_get_my_dodag();
if (mydodag == NULL) {
return;
}
printf("---------------------------\n");
printf("OUTPUT\n");
printf("my rank: %d\n", mydodag->my_rank);
if (!is_root) {
printf("my preferred parent:\n");
printf("%s\n", ipv6_addr_to_str(addr_str, IPV6_MAX_ADDR_STR_LEN,
(&mydodag->my_preferred_parent->addr)));
printf("parent lifetime: %d\n", mydodag->my_preferred_parent->lifetime);
}
printf("---------------------------$\n");
for (int i = 0; i < RPL_MAX_ROUTING_ENTRIES; i++) {
if (rtable[i].used) {
printf("%s\n", ipv6_addr_to_str(addr_str, IPV6_MAX_ADDR_STR_LEN,
(&rtable[i].address)));
puts("next hop");
printf("%s\n", ipv6_addr_to_str(addr_str, IPV6_MAX_ADDR_STR_LEN,
(&rtable[i].next_hop)));
printf("entry %d lifetime %d\n", i, rtable[i].lifetime);
if (!rpl_equal_id(&rtable[i].address, &rtable[i].next_hop)) {
puts("multi-hop");
}
printf("---------------------------$\n");
}
}
printf("########################\n");
}
static void *rt_timer_over(void *arg)
{
(void) arg;
rpl_routing_entry_t *rt;
while (1) {
rpl_dodag_t *my_dodag = rpl_get_my_dodag();
if (my_dodag != NULL) {
rt = rpl_get_routing_table();
for (uint8_t i = 0; i < RPL_MAX_ROUTING_ENTRIES; i++) {
if (rt[i].used) {
if (rt[i].lifetime <= 1) {
memset(&rt[i], 0, sizeof(rt[i]));
}
else {
rt[i].lifetime--;
}
}
}
/* Parent is NULL for root too */
if (my_dodag->my_preferred_parent != NULL) {
if (my_dodag->my_preferred_parent->lifetime <= 1) {
puts("parent lifetime timeout");
rpl_parent_update(NULL);
}
else {
my_dodag->my_preferred_parent->lifetime--;
}
}
}
/* Wake up every second */
vtimer_usleep(1000000);
}
return NULL;
}
void recv_rpl_dao_ack(void)
{
rpl_dodag_t *my_dodag = rpl_get_my_dodag();
if (my_dodag == NULL) {
return;
}
rpl_dao_ack_buf = get_rpl_dao_ack_buf();
if (rpl_dao_ack_buf->rpl_instanceid != my_dodag->instance->id) {
return;
}
if (rpl_dao_ack_buf->status != 0) {
return;
}
dao_ack_received();
}
void dodag(char *unused)
{
(void) unused;
printf("---------------------------\n");
rpl_dodag_t *mydodag = rpl_get_my_dodag();
if (mydodag == NULL) {
printf("Not part of a dodag\n");
printf("---------------------------$\n");
return;
}
printf("Part of Dodag:\n");
printf("%s\n", ipv6_addr_to_str(addr_str, (&mydodag->dodag_id)));
printf("my rank: %d\n", mydodag->my_rank);
if (!is_root) {
printf("my preferred parent:\n");
printf("%s\n", ipv6_addr_to_str(addr_str, (&mydodag->my_preferred_parent->addr)));
}
printf("---------------------------$\n");
}
void rpl_send_DAO_ACK_mode(ipv6_addr_t *destination)
{
rpl_dodag_t *my_dodag;
my_dodag = rpl_get_my_dodag();
if (my_dodag == NULL) {
return;
}
icmp_send_buf = get_rpl_send_icmpv6_buf(ipv6_ext_hdr_len);
icmp_send_buf->type = ICMPV6_TYPE_RPL_CONTROL;
icmp_send_buf->code = ICMP_CODE_DAO_ACK;
rpl_send_dao_ack_buf = get_rpl_send_dao_ack_buf();
rpl_send_dao_ack_buf->rpl_instanceid = my_dodag->instance->id;
rpl_send_dao_ack_buf->d_reserved = 0;
rpl_send_dao_ack_buf->dao_sequence = my_dodag->dao_seq;
rpl_send_dao_ack_buf->status = 0;
uint16_t plen = ICMPV6_HDR_LEN + DAO_ACK_LEN;
rpl_send(destination, (uint8_t *)icmp_send_buf, plen, IPV6_PROTO_NUM_ICMPV6);
}
void recv_rpl_dio(void)
{
ipv6_buf = get_rpl_ipv6_buf();
rpl_dio_buf = get_rpl_dio_buf();
int len = DIO_BASE_LEN;
rpl_instance_t *dio_inst = rpl_get_instance(rpl_dio_buf->rpl_instanceid);
rpl_instance_t *my_inst = rpl_get_my_instance();
if (dio_inst == NULL) {
if (my_inst != NULL) {
/* already part of a DODAG -> impossible to join other instance */
return;
}
dio_inst = rpl_new_instance(rpl_dio_buf->rpl_instanceid);
if (dio_inst == NULL) {
return;
}
}
else if (my_inst->id != dio_inst->id) {
/* TODO: Add support support for several instances. */
/* At the moment, nodes can only join one instance, this is
* the instance they join first.
* Instances cannot be switched later on. */
DEBUG("Ignoring instance - we are %d and got %d\n", my_inst->id, dio_inst->id);
return;
}
rpl_dodag_t dio_dodag;
memset(&dio_dodag, 0, sizeof(dio_dodag));
memcpy(&dio_dodag.dodag_id, &rpl_dio_buf->dodagid, sizeof(dio_dodag.dodag_id));
dio_dodag.dtsn = rpl_dio_buf->dtsn;
dio_dodag.mop = ((rpl_dio_buf->g_mop_prf >> RPL_MOP_SHIFT) & RPL_SHIFTED_MOP_MASK);
dio_dodag.grounded = rpl_dio_buf->g_mop_prf >> RPL_GROUNDED_SHIFT;
dio_dodag.prf = (rpl_dio_buf->g_mop_prf & RPL_PRF_MASK);
dio_dodag.version = rpl_dio_buf->version_number;
dio_dodag.instance = dio_inst;
uint8_t has_dodag_conf_opt = 0;
/* Parse until all options are consumed.
* ipv6_buf->length contains the packet length minus ipv6 and
* icmpv6 header, so only ICMPV6_HDR_LEN remains to be
* subtracted. */
while (len < (ipv6_buf->length - ICMPV6_HDR_LEN)) {
rpl_opt_buf = get_rpl_opt_buf(len);
switch (rpl_opt_buf->type) {
case (RPL_OPT_PAD1): {
len += 1;
break;
}
case (RPL_OPT_PADN): {
len += rpl_opt_buf->length + 2;
break;
}
case (RPL_OPT_DAG_METRIC_CONTAINER): {
len += rpl_opt_buf->length + 2;
break;
}
case (RPL_OPT_ROUTE_INFO): {
len += rpl_opt_buf->length + 2;
break;
}
case (RPL_OPT_DODAG_CONF): {
has_dodag_conf_opt = 1;
if (rpl_opt_buf->length != RPL_OPT_DODAG_CONF_LEN) {
/* error malformed */
return;
}
rpl_opt_dodag_conf_buf = get_rpl_opt_dodag_conf_buf(len);
dio_dodag.dio_interval_doubling = rpl_opt_dodag_conf_buf->DIOIntDoubl;
dio_dodag.dio_min = rpl_opt_dodag_conf_buf->DIOIntMin;
dio_dodag.dio_redundancy = rpl_opt_dodag_conf_buf->DIORedun;
dio_dodag.maxrankincrease = rpl_opt_dodag_conf_buf->MaxRankIncrease;
dio_dodag.minhoprankincrease = rpl_opt_dodag_conf_buf->MinHopRankIncrease;
dio_dodag.default_lifetime = rpl_opt_dodag_conf_buf->default_lifetime;
dio_dodag.lifetime_unit = rpl_opt_dodag_conf_buf->lifetime_unit;
dio_dodag.of = (struct rpl_of_t *) rpl_get_of_for_ocp(rpl_opt_dodag_conf_buf->ocp);
len += RPL_OPT_DODAG_CONF_LEN + 2;
break;
}
case (RPL_OPT_PREFIX_INFO): {
if (rpl_opt_buf->length != RPL_OPT_PREFIX_INFO_LEN) {
/* error malformed */
return;
}
len += RPL_OPT_PREFIX_INFO_LEN + 2;
break;
}
default:
DEBUG("[Error] Unsupported DIO option\n");
return;
}
}
/* handle packet content... */
rpl_dodag_t *my_dodag = rpl_get_my_dodag();
if (my_dodag == NULL) {
if (!has_dodag_conf_opt) {
DEBUG("send DIS\n");
send_DIS(&ipv6_buf->srcaddr);
return;
}
if (rpl_dio_buf->rank < ROOT_RANK) {
DEBUG("DIO with Rank < ROOT_RANK\n");
return;
}
if (dio_dodag.mop != RPL_DEFAULT_MOP) {
DEBUG("Required MOP not supported\n");
return;
}
if (dio_dodag.of == NULL) {
DEBUG("Required objective function not supported\n");
return;
}
if (rpl_dio_buf->rank != INFINITE_RANK) {
char addr_str[IPV6_MAX_ADDR_STR_LEN];
DEBUG("Will join DODAG\n");
printf("%s", ipv6_addr_to_str(addr_str, &dio_dodag.dodag_id));
rpl_join_dodag(&dio_dodag, &ipv6_buf->srcaddr, rpl_dio_buf->rank);
}
else {
DEBUG("Cannot access DODAG because of DIO with infinite rank\n");
return;
}
}
if (rpl_equal_id(&my_dodag->dodag_id, &dio_dodag.dodag_id)) {
/* "our" DODAG */
if (RPL_COUNTER_GREATER_THAN(dio_dodag.version, my_dodag->version)) {
if (my_dodag->my_rank == ROOT_RANK) {
DEBUG("[Warning] Inconsistent Dodag Version\n");
my_dodag->version = RPL_COUNTER_INCREMENT(dio_dodag.version);
reset_trickletimer();
}
else {
DEBUG("[Info] New Version of dodag %d\n", dio_dodag.version);
rpl_global_repair(&dio_dodag, &ipv6_buf->srcaddr, rpl_dio_buf->rank);
}
return;
}
else if (RPL_COUNTER_GREATER_THAN(my_dodag->version, dio_dodag.version)) {
/* ein Knoten hat noch eine kleinere Versionsnummer -> mehr DIOs senden */
reset_trickletimer();
return;
}
}
/* version matches, DODAG matches */
if (rpl_dio_buf->rank == INFINITE_RANK) {
reset_trickletimer();
}
/* We are root, all done! */
if (my_dodag->my_rank == ROOT_RANK) {
if (rpl_dio_buf->rank != INFINITE_RANK) {
trickle_increment_counter();
}
return;
}
/********************* Parent Handling *********************/
rpl_parent_t *parent;
parent = rpl_find_parent(&ipv6_buf->srcaddr);
if (parent == NULL) {
/* add new parent candidate */
parent = rpl_new_parent(my_dodag, &ipv6_buf->srcaddr, rpl_dio_buf->rank);
if (parent == NULL) {
return;
}
}
else {
/* DIO OK */
trickle_increment_counter();
}
/* update parent rank */
parent->rank = rpl_dio_buf->rank;
rpl_parent_update(parent);
if (rpl_equal_id(&parent->addr, &my_dodag->my_preferred_parent->addr) && (parent->dtsn != rpl_dio_buf->dtsn)) {
delay_dao();
}
parent->dtsn = rpl_dio_buf->dtsn;
}
void rpl_recv_DAO_mode(void)
{
rpl_dodag_t *my_dodag = rpl_get_my_dodag();
if (my_dodag == NULL) {
DEBUGF("[Error] got DAO although not a DODAG.\n");
return;
}
if (!i_am_root) {
DEBUGF("[Error] something went wrong - got a DAO.\n");
return;
}
ipv6_buf = get_rpl_ipv6_buf();
rpl_dao_buf = get_rpl_dao_buf();
int len = DAO_BASE_LEN;
uint8_t increment_seq = 0;
while (len < (NTOHS(ipv6_buf->length) - ICMPV6_HDR_LEN)) {
rpl_opt_buf = get_rpl_opt_buf(len);
switch (rpl_opt_buf->type) {
case (RPL_OPT_PAD1): {
len += 1;
break;
}
case (RPL_OPT_PADN): {
len += rpl_opt_buf->length;
break;
}
case (RPL_OPT_DAG_METRIC_CONTAINER): {
len += rpl_opt_buf->length;
break;
}
case (RPL_OPT_TARGET): {
rpl_opt_target_buf = get_rpl_opt_target_buf(len);
if (rpl_opt_target_buf->prefix_length != RPL_DODAG_ID_LEN) {
DEBUGF("prefixes are not supported yet\n");
break;
}
len += rpl_opt_target_buf->length;
rpl_opt_transit_buf = get_rpl_opt_transit_buf(len);
if (rpl_opt_transit_buf->type != RPL_OPT_TRANSIT) {
DEBUGF("[Error] - no transit information for target option type = %d\n",
rpl_opt_transit_buf->type);
break;
}
len += rpl_opt_transit_buf->length;
/* route lifetime seconds = (DAO lifetime) * (Unit Lifetime) */
DEBUGF("Target: %s\n", ipv6_addr_to_str(addr_str_mode, IPV6_MAX_ADDR_STR_LEN,
&rpl_opt_target_buf->target));
DEBUGF("Transit: %s\n", ipv6_addr_to_str(addr_str_mode, IPV6_MAX_ADDR_STR_LEN,
&rpl_opt_transit_buf->parent));
#if RPL_DEFAULT_MOP == RPL_NON_STORING_MODE
rpl_add_srh_entry(&rpl_opt_target_buf->target, &rpl_opt_transit_buf->parent,
rpl_opt_transit_buf->path_lifetime * my_dodag->lifetime_unit);
#endif
increment_seq = 1;
break;
}
case (RPL_OPT_TRANSIT): {
len += rpl_opt_buf->length;
break;
}
case (RPL_OPT_TARGET_DESC): {
len += rpl_opt_buf->length;
break;
}
default:
return;
}
}
if (increment_seq) {
RPL_COUNTER_INCREMENT(my_dodag->dao_seq);
delay_dao();
}
}
void recv_rpl_dio(void)
{
ipv6_buf = get_rpl_ipv6_buf();
rpl_dio_buf = get_rpl_dio_buf();
int len = DIO_BASE_LEN;
rpl_instance_t *dio_inst = rpl_get_instance(rpl_dio_buf->rpl_instanceid);
rpl_instance_t *my_inst = rpl_get_my_instance();
if(dio_inst == NULL) {
if(my_inst != NULL) {
/* Dieser Knoten ist schon Teil eines DODAGS -> kein beitritt zu anderer Instanz moeglich */
return;
}
dio_inst = rpl_new_instance(rpl_dio_buf->rpl_instanceid);
if(dio_inst == NULL) {
return;
}
}
else if(my_inst->id != dio_inst->id) {
printf("Andere Instanz, wir haben %d es kam aber %d\n", my_inst->id, dio_inst->id);
/* DIO von fremder Instanz ignorieren, Knoten können Momentan nur
* einer Instanz beitreten und das wird die Instanz sein, der sie als
* erstes beitreten. Danach kann die Instanz nicht mehr gewechselt
* werden Unterstützung für mehrere Instanzen könnte in Zukunft
* implementiert werden */
return;
}
rpl_dodag_t dio_dodag;
memset(&dio_dodag, 0, sizeof(dio_dodag));
memcpy(&dio_dodag.dodag_id, &rpl_dio_buf->dodagid, sizeof(dio_dodag.dodag_id));
dio_dodag.dtsn = rpl_dio_buf->dtsn;
dio_dodag.mop = ((rpl_dio_buf->g_mop_prf >> RPL_MOP_SHIFT) & RPL_SHIFTED_MOP_MASK);
dio_dodag.grounded = rpl_dio_buf->g_mop_prf >> RPL_GROUNDED_SHIFT;
dio_dodag.prf = (rpl_dio_buf->g_mop_prf & RPL_PRF_MASK);
dio_dodag.version = rpl_dio_buf->version_number;
dio_dodag.instance = dio_inst;
uint8_t has_dodag_conf_opt = 0;
/* So lange das Paket größer ist, als die DIO Größe + Größe der bisher
* verarbeiteten Optionen, sind noch weitere Optionen zu bearbeiten */
/* dabei müssen wir jedoch von der ipv6_buf->length die Größe des ICMP
* Headers abziehen weil get_rpl_opt_buf die Paketlänge OHNE ipv6 und
* icmpv6 header übergeben werden muss in ipv6_buf->length ist die
* IPV6_HDR_LEN nicht enthalten, also muss nur noch die ICMPV6_HDR_LEN
* abgezogen werden */
while(len < (ipv6_buf->length - ICMPV6_HDR_LEN)) {
rpl_opt_buf = get_rpl_opt_buf(len);
switch(rpl_opt_buf->type) {
case(RPL_OPT_PAD1): {
len += 1;
break;
}
case(RPL_OPT_PADN): {
len += rpl_opt_buf->length + 2;
break;
}
case(RPL_OPT_DAG_METRIC_CONTAINER): {
len += rpl_opt_buf->length + 2;
break;
}
case(RPL_OPT_ROUTE_INFO): {
len += rpl_opt_buf->length + 2;
break;
}
case(RPL_OPT_DODAG_CONF): {
has_dodag_conf_opt = 1;
if(rpl_opt_buf->length != RPL_OPT_DODAG_CONF_LEN) {
/* error malformed */
return;
}
rpl_opt_dodag_conf_buf = get_rpl_opt_dodag_conf_buf(len);
dio_dodag.dio_interval_doubling = rpl_opt_dodag_conf_buf->DIOIntDoubl;
dio_dodag.dio_min = rpl_opt_dodag_conf_buf->DIOIntMin;
dio_dodag.dio_redundancy = rpl_opt_dodag_conf_buf->DIORedun;
dio_dodag.maxrankincrease = rpl_opt_dodag_conf_buf->MaxRankIncrease;
dio_dodag.minhoprankincrease = rpl_opt_dodag_conf_buf->MinHopRankIncrease;
dio_dodag.default_lifetime = rpl_opt_dodag_conf_buf->default_lifetime;
dio_dodag.lifetime_unit = rpl_opt_dodag_conf_buf->lifetime_unit;
dio_dodag.of = rpl_get_of_for_ocp(rpl_opt_dodag_conf_buf->ocp);
len += RPL_OPT_DODAG_CONF_LEN + 2;
break;
}
case(RPL_OPT_PREFIX_INFO): {
if(rpl_opt_buf->length != RPL_OPT_PREFIX_INFO_LEN) {
/* error malformed */
return;
}
len += RPL_OPT_PREFIX_INFO_LEN + 2;
break;
}
default:
printf("[Error] Unsupported DIO option\n");
return;
}
}
/* handle packet content... */
rpl_dodag_t *my_dodag = rpl_get_my_dodag();
if(my_dodag == NULL) {
if(!has_dodag_conf_opt) {
puts("send DIS");
send_DIS(&ipv6_buf->srcaddr);
return;
}
if(rpl_dio_buf->rank < ROOT_RANK) {
printf("DIO with Rank < ROOT_RANK\n");
return;
}
if(dio_dodag.mop != RPL_DEFAULT_MOP) {
printf("Required MOP not supported\n");
return;
}
if(dio_dodag.of == NULL) {
printf("Required objective function not supported\n");
return;
}
if(rpl_dio_buf->rank != INFINITE_RANK) {
puts("Will join DODAG\n");
ipv6_print_addr(&dio_dodag.dodag_id);
rpl_join_dodag(&dio_dodag, &ipv6_buf->srcaddr, rpl_dio_buf->rank);
}
else {
printf("Cannot access DODAG because of DIO with infinite rank\n");
return;
}
}
if(rpl_equal_id(&my_dodag->dodag_id, &dio_dodag.dodag_id)) {
/* Mein DODAG */
if(RPL_COUNTER_GREATER_THAN(dio_dodag.version, my_dodag->version)) {
if(my_dodag->my_rank == ROOT_RANK) {
/* Jemand hat ein DIO mit einer höheren Version als der richtigen gesendet */
/* Wir erhöhen diese Version noch einmal, und machen sie zur neuen */
printf("[Warning] Inconsistent Dodag Version\n");
my_dodag->version = RPL_COUNTER_INCREMENT(dio_dodag.version);
reset_trickletimer();
}
else {
printf("[Info] New Version of dodag %d\n", dio_dodag.version);
rpl_global_repair(&dio_dodag, &ipv6_buf->srcaddr, rpl_dio_buf->rank);
}
return;
}
else if(RPL_COUNTER_GREATER_THAN(my_dodag->version, dio_dodag.version)) {
/* ein Knoten hat noch eine kleinere Versionsnummer -> mehr DIOs senden */
reset_trickletimer();
return;
}
}
/* Version stimmt, DODAG stimmt */
if(rpl_dio_buf->rank == INFINITE_RANK) {
reset_trickletimer();
}
/* Wenn wir root sind, ist nichts weiter zu tun */
if(my_dodag->my_rank == ROOT_RANK) {
if(rpl_dio_buf->rank != INFINITE_RANK) {
trickle_increment_counter();
}
return;
}
/* */
/* Parent Handling */
/* */
/* Ist Knoten bereits Parent? */
rpl_parent_t *parent;
parent = rpl_find_parent(&ipv6_buf->srcaddr);
if(parent == NULL) {
/* neuen möglichen Elternknoten hinzufuegen */
parent = rpl_new_parent(my_dodag, &ipv6_buf->srcaddr, rpl_dio_buf->rank);
if(parent == NULL) {
return;
}
}
else {
/* DIO ok */
trickle_increment_counter();
}
/* update parent rank */
parent->rank = rpl_dio_buf->rank;
rpl_parent_update(parent);
if(rpl_equal_id(&parent->addr, &my_dodag->my_preferred_parent->addr) && (parent->dtsn != rpl_dio_buf->dtsn)) {
delay_dao();
}
parent->dtsn = rpl_dio_buf->dtsn;
}
void recv_rpl_dao(void)
{
rpl_dodag_t *my_dodag = rpl_get_my_dodag();
if(my_dodag == NULL) {
printf("[Error] got DAO without beeing part of a Dodag\n");
return;
}
ipv6_buf = get_rpl_ipv6_buf();
rpl_dao_buf = get_rpl_dao_buf();
int len = DAO_BASE_LEN;
uint8_t increment_seq = 0;
while(len < (ipv6_buf->length - ICMPV6_HDR_LEN)) {
rpl_opt_buf = get_rpl_opt_buf(len);
switch(rpl_opt_buf->type) {
case(RPL_OPT_PAD1): {
len += 1;
break;
}
case(RPL_OPT_PADN): {
len += rpl_opt_buf->length + 2;
break;
}
case(RPL_OPT_DAG_METRIC_CONTAINER): {
len += rpl_opt_buf->length + 2;
break;
}
case(RPL_OPT_TARGET): {
rpl_opt_target_buf = get_rpl_opt_target_buf(len);
if(rpl_opt_target_buf->prefix_length != RPL_DODAG_ID_LEN) {
printf("prefixes are not supported yet");
break;
}
len += rpl_opt_target_buf->length + 2;
rpl_opt_transit_buf = get_rpl_opt_transit_buf(len);
if(rpl_opt_transit_buf->type != RPL_OPT_TRANSIT) {
printf("[Error] - no Transit Inforamtion to Target Option, type = %d\n", rpl_opt_transit_buf->type);
break;
}
len += rpl_opt_transit_buf->length + 2;
/* Die eigentliche Lebenszeit einer Route errechnet sich aus (Lifetime aus DAO) * (Lifetime Unit) Sekunden */
rpl_add_routing_entry(&rpl_opt_target_buf->target, &ipv6_buf->srcaddr, rpl_opt_transit_buf->path_lifetime * my_dodag->lifetime_unit);
/* puts("Updated route \n"); */
increment_seq = 1;
break;
}
case(RPL_OPT_TRANSIT): {
len += rpl_opt_buf->length + 2;
break;
}
case(RPL_OPT_TARGET_DESC): {
len += rpl_opt_buf->length + 2;
break;
}
default:
return;
}
}
send_DAO_ACK(&ipv6_buf->srcaddr);
if(increment_seq) {
RPL_COUNTER_INCREMENT(my_dodag->dao_seq);
delay_dao();
}
}
void rpl_recv_DAO_mode(void)
{
rpl_dodag_t *my_dodag = rpl_get_my_dodag();
if (my_dodag == NULL) {
DEBUG("[Error] got DAO although not a DODAG\n");
return;
}
ipv6_buf = get_rpl_ipv6_buf();
rpl_dao_buf = get_rpl_dao_buf();
DEBUG("instance %04X ", rpl_dao_buf->rpl_instanceid);
DEBUG("sequence %04X\n", rpl_dao_buf->dao_sequence);
int len = DAO_BASE_LEN;
uint8_t increment_seq = 0;
while (len < (NTOHS(ipv6_buf->length) - ICMPV6_HDR_LEN)) {
rpl_opt_buf = get_rpl_opt_buf(len);
switch (rpl_opt_buf->type) {
case (RPL_OPT_PAD1): {
len += 1;
break;
}
case (RPL_OPT_PADN): {
len += rpl_opt_buf->length;
break;
}
case (RPL_OPT_DAG_METRIC_CONTAINER): {
len += rpl_opt_buf->length;
break;
}
case (RPL_OPT_TARGET): {
rpl_opt_target_buf = get_rpl_opt_target_buf(len);
if (rpl_opt_target_buf->prefix_length != RPL_DODAG_ID_LEN) {
DEBUGF("prefixes are not supported yet\n");
break;
}
len += rpl_opt_target_buf->length;
rpl_opt_transit_buf = get_rpl_opt_transit_buf(len);
if (rpl_opt_transit_buf->type != RPL_OPT_TRANSIT) {
DEBUGF("[Error] - no transit information for target option type = %d\n",
rpl_opt_transit_buf->type);
break;
}
len += rpl_opt_transit_buf->length;
/* route lifetime seconds = (DAO lifetime) * (Unit Lifetime) */
#if RPL_MAX_ROUTING_ENTRIES != 0
DEBUG("Adding routing information: Target: %s, Source: %s, Lifetime: %u\n",
ipv6_addr_to_str(addr_str_mode, IPV6_MAX_ADDR_STR_LEN, &rpl_opt_target_buf->target),
ipv6_addr_to_str(addr_str_mode, IPV6_MAX_ADDR_STR_LEN, &ipv6_buf->srcaddr),
(rpl_opt_transit_buf->path_lifetime * my_dodag->lifetime_unit));
rpl_add_routing_entry(&rpl_opt_target_buf->target, &ipv6_buf->srcaddr,
rpl_opt_transit_buf->path_lifetime * my_dodag->lifetime_unit);
#endif
increment_seq = 1;
break;
}
case (RPL_OPT_TRANSIT): {
len += rpl_opt_buf->length;
break;
}
case (RPL_OPT_TARGET_DESC): {
len += rpl_opt_buf->length;
break;
}
default:
return;
}
}
rpl_send_DAO_ACK(&ipv6_buf->srcaddr);
if (increment_seq) {
RPL_COUNTER_INCREMENT(my_dodag->dao_seq);
rpl_delay_dao(my_dodag);
}
}
void send_DAO(ipv6_addr_t *destination, uint8_t lifetime, bool default_lifetime, uint8_t start_index)
{
if (i_am_root) {
return;
}
mutex_lock(&rpl_send_mutex);
rpl_dodag_t *my_dodag;
my_dodag = rpl_get_my_dodag();
if (destination == NULL) {
destination = &my_dodag->my_preferred_parent->addr;
}
if (default_lifetime) {
lifetime = my_dodag->default_lifetime;
}
icmp_send_buf = get_rpl_send_icmpv6_buf(ipv6_ext_hdr_len);
icmp_send_buf->type = ICMPV6_TYPE_RPL_CONTROL;
icmp_send_buf->code = ICMP_CODE_DAO;
icmp_send_buf->checksum = ~icmpv6_csum(IPV6_PROTO_NUM_ICMPV6);
if (my_dodag == NULL) {
mutex_unlock(&rpl_send_mutex);
return;
}
rpl_send_dao_buf = get_rpl_send_dao_buf();
memset(rpl_send_dao_buf, 0, sizeof(*rpl_send_dao_buf));
rpl_send_dao_buf->rpl_instanceid = my_dodag->instance->id;
rpl_send_dao_buf->k_d_flags = 0x00;
rpl_send_dao_buf->dao_sequence = my_dodag->dao_seq;
uint16_t opt_len = 0;
rpl_send_opt_target_buf = get_rpl_send_opt_target_buf(DAO_BASE_LEN);
/* add all targets from routing table as targets */
uint8_t entries = 0;
uint8_t continue_index = 0;
for (uint8_t i = start_index; i < RPL_MAX_ROUTING_ENTRIES; i++) {
if (routing_table[i].used) {
rpl_send_opt_target_buf->type = RPL_OPT_TARGET;
rpl_send_opt_target_buf->length = RPL_OPT_TARGET_LEN;
rpl_send_opt_target_buf->flags = 0x00;
rpl_send_opt_target_buf->prefix_length = RPL_DODAG_ID_LEN;
memcpy(&rpl_send_opt_target_buf->target, &routing_table[i].address, sizeof(ipv6_addr_t));
opt_len += RPL_OPT_TARGET_LEN + 2;
rpl_send_opt_transit_buf = get_rpl_send_opt_transit_buf(DAO_BASE_LEN + opt_len);
rpl_send_opt_transit_buf->type = RPL_OPT_TRANSIT;
rpl_send_opt_transit_buf->length = RPL_OPT_TRANSIT_LEN;
rpl_send_opt_transit_buf->e_flags = 0x00;
rpl_send_opt_transit_buf->path_control = 0x00; /* not used */
rpl_send_opt_transit_buf->path_sequence = 0x00; /* not used */
rpl_send_opt_transit_buf->path_lifetime = lifetime;
opt_len += RPL_OPT_TRANSIT_LEN + 2;
rpl_send_opt_target_buf = get_rpl_send_opt_target_buf(DAO_BASE_LEN + opt_len);
entries++;
}
/* Split DAO, so packages don't get too big.
* The value 5 is based on experience. */
if (entries >= 5) {
continue_index = i + 1;
break;
}
}
/* add own address */
rpl_send_opt_target_buf->type = RPL_OPT_TARGET;
rpl_send_opt_target_buf->length = RPL_OPT_TARGET_LEN;
rpl_send_opt_target_buf->flags = 0x00;
rpl_send_opt_target_buf->prefix_length = RPL_DODAG_ID_LEN;
memcpy(&rpl_send_opt_target_buf->target, &my_address, sizeof(ipv6_addr_t));
opt_len += RPL_OPT_TARGET_LEN + 2;
rpl_send_opt_transit_buf = get_rpl_send_opt_transit_buf(DAO_BASE_LEN + opt_len);
rpl_send_opt_transit_buf->type = RPL_OPT_TRANSIT;
rpl_send_opt_transit_buf->length = RPL_OPT_TRANSIT_LEN;
rpl_send_opt_transit_buf->e_flags = 0x00;
rpl_send_opt_transit_buf->path_control = 0x00;
rpl_send_opt_transit_buf->path_sequence = 0x00;
rpl_send_opt_transit_buf->path_lifetime = lifetime;
opt_len += RPL_OPT_TRANSIT_LEN + 2;
uint16_t plen = ICMPV6_HDR_LEN + DAO_BASE_LEN + opt_len;
rpl_send(destination, (uint8_t *)icmp_send_buf, plen, IPV6_PROTO_NUM_ICMPV6, NULL);
mutex_unlock(&rpl_send_mutex);
if (continue_index > 1) {
send_DAO(destination, lifetime, default_lifetime, continue_index);
}
}
void rpl_send_DAO_mode(ipv6_addr_t *destination, uint8_t lifetime, bool default_lifetime, uint8_t start_index)
{
(void) start_index;
if (i_am_root) {
return;
}
/* TODO: take advantage of start_index, by now not used in non-storing mode
start_index++;
*/
rpl_dodag_t *my_dodag;
if ((my_dodag = rpl_get_my_dodag()) == NULL) {
DEBUGF("send_DAO: Not part of a DODAG\n");
return;
}
if (destination == NULL) {
destination = &my_dodag->dodag_id;
}
if (default_lifetime) {
lifetime = my_dodag->default_lifetime;
}
icmp_send_buf = get_rpl_send_icmpv6_buf(ipv6_ext_hdr_len);
icmp_send_buf->type = ICMPV6_TYPE_RPL_CONTROL;
icmp_send_buf->code = ICMP_CODE_DAO;
rpl_send_dao_buf = get_rpl_send_dao_buf();
memset(rpl_send_dao_buf, 0, sizeof(*rpl_send_dao_buf));
rpl_send_dao_buf->rpl_instanceid = my_dodag->instance->id;
rpl_send_dao_buf->k_d_flags = 0x00;
rpl_send_dao_buf->dao_sequence = my_dodag->dao_seq;
uint16_t opt_len = 0;
rpl_send_opt_target_buf = get_rpl_send_opt_target_buf(DAO_BASE_LEN);
/* add own address */
rpl_send_opt_target_buf->type = RPL_OPT_TARGET;
rpl_send_opt_target_buf->length = RPL_OPT_TARGET_LEN;
rpl_send_opt_target_buf->flags = 0x00;
rpl_send_opt_target_buf->prefix_length = RPL_DODAG_ID_LEN;
memcpy(&rpl_send_opt_target_buf->target, &my_address, sizeof(ipv6_addr_t));
/* 18+2=20 bytes for one target-option */
opt_len += RPL_OPT_TARGET_LEN;
/* add parent */
rpl_send_opt_transit_buf = get_rpl_send_opt_transit_buf(DAO_BASE_LEN + opt_len);
rpl_send_opt_transit_buf->type = RPL_OPT_TRANSIT;
rpl_send_opt_transit_buf->length = RPL_OPT_TRANSIT_LEN;
rpl_send_opt_transit_buf->e_flags = 0x00;
rpl_send_opt_transit_buf->path_control = 0x00;
rpl_send_opt_transit_buf->path_sequence = 0x00;
rpl_send_opt_transit_buf->path_lifetime = lifetime;
memcpy(&rpl_send_opt_transit_buf->parent, rpl_get_my_preferred_parent(), sizeof(ipv6_addr_t));
DEBUGF("My pref parent is:%s\n", ipv6_addr_to_str(addr_str_mode, IPV6_MAX_ADDR_STR_LEN,
rpl_get_my_preferred_parent()));
DEBUGF("Send DAO with instance %04X and sequence %04X to %s\n",
rpl_send_dao_buf->rpl_instanceid, rpl_send_dao_buf->dao_sequence,
ipv6_addr_to_str(addr_str_mode, IPV6_MAX_ADDR_STR_LEN, destination));
/* 4+2=6 byte for one transit-option */
opt_len += RPL_OPT_TRANSIT_LEN;
uint16_t plen = ICMPV6_HDR_LEN + DAO_BASE_LEN + opt_len;
rpl_send(destination, (uint8_t *)icmp_send_buf, plen, IPV6_PROTO_NUM_ICMPV6);
}
void recv_rpl_dis(void)
{
rpl_dodag_t *my_dodag = rpl_get_my_dodag();
if (my_dodag == NULL) {
return;
}
ipv6_buf = get_rpl_ipv6_buf();
rpl_dis_buf = get_rpl_dis_buf();
int len = DIS_BASE_LEN;
while (len < (ipv6_buf->length - ICMPV6_HDR_LEN)) {
rpl_opt_buf = get_rpl_opt_buf(len);
switch (rpl_opt_buf->type) {
case (RPL_OPT_PAD1): {
len += 1;
break;
}
case (RPL_OPT_PADN): {
len += rpl_opt_buf->length + 2;
break;
}
case (RPL_OPT_SOLICITED_INFO): {
len += RPL_OPT_SOLICITED_INFO_LEN + 2;
/* extract and check */
if (rpl_opt_buf->length != RPL_OPT_SOLICITED_INFO_LEN) {
/* error malformed */
return;
}
rpl_opt_solicited_buf = get_rpl_opt_solicited_buf(len);
if (rpl_opt_solicited_buf->VID_Flags & RPL_DIS_I_MASK) {
if (my_dodag->instance->id != rpl_opt_solicited_buf->rplinstanceid) {
return;
}
}
if (rpl_opt_solicited_buf->VID_Flags & RPL_DIS_D_MASK) {
if (!rpl_equal_id(&my_dodag->dodag_id, &rpl_opt_solicited_buf->dodagid)) {
return;
}
}
if (rpl_opt_solicited_buf->VID_Flags & RPL_DIS_V_MASK) {
if (my_dodag->version != rpl_opt_solicited_buf->version) {
return;
}
}
break;
}
default:
return;
}
}
send_DIO(&ipv6_buf->srcaddr);
}
void recv_rpl_dao(void)
{
rpl_dodag_t *my_dodag = rpl_get_my_dodag();
if (my_dodag == NULL) {
DEBUG("[Error] got DAO although not a DODAG\n");
return;
}
ipv6_buf = get_rpl_ipv6_buf();
rpl_dao_buf = get_rpl_dao_buf();
int len = DAO_BASE_LEN;
uint8_t increment_seq = 0;
while (len < (ipv6_buf->length - ICMPV6_HDR_LEN)) {
rpl_opt_buf = get_rpl_opt_buf(len);
switch (rpl_opt_buf->type) {
case (RPL_OPT_PAD1): {
len += 1;
break;
}
case (RPL_OPT_PADN): {
len += rpl_opt_buf->length + 2;
break;
}
case (RPL_OPT_DAG_METRIC_CONTAINER): {
len += rpl_opt_buf->length + 2;
break;
}
case (RPL_OPT_TARGET): {
rpl_opt_target_buf = get_rpl_opt_target_buf(len);
if (rpl_opt_target_buf->prefix_length != RPL_DODAG_ID_LEN) {
DEBUG("prefixes are not supported yet");
break;
}
len += rpl_opt_target_buf->length + 2;
rpl_opt_transit_buf = get_rpl_opt_transit_buf(len);
if (rpl_opt_transit_buf->type != RPL_OPT_TRANSIT) {
DEBUG("[Error] - no transit information for target option type = %d\n", rpl_opt_transit_buf->type);
break;
}
len += rpl_opt_transit_buf->length + 2;
/* route lifetime seconds = (DAO lifetime) * (Unit Lifetime) */
rpl_add_routing_entry(&rpl_opt_target_buf->target, &ipv6_buf->srcaddr, rpl_opt_transit_buf->path_lifetime * my_dodag->lifetime_unit);
increment_seq = 1;
break;
}
case (RPL_OPT_TRANSIT): {
len += rpl_opt_buf->length + 2;
break;
}
case (RPL_OPT_TARGET_DESC): {
len += rpl_opt_buf->length + 2;
break;
}
default:
return;
}
}
send_DAO_ACK(&ipv6_buf->srcaddr);
if (increment_seq) {
RPL_COUNTER_INCREMENT(my_dodag->dao_seq);
delay_dao();
}
}
