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_join_dodag(rpl_dodag_t *dodag, ipv6_addr_t *parent, uint16_t parent_rank)
{
rpl_dodag_t *my_dodag;
rpl_parent_t *preferred_parent;
my_dodag = rpl_new_dodag(dodag->instance->id, &dodag->dodag_id);
if (my_dodag == NULL) {
return;
}
preferred_parent = rpl_new_parent(dodag, parent, parent_rank);
if (preferred_parent == NULL) {
rpl_del_dodag(my_dodag);
return;
}
my_dodag->instance->joined = 1;
my_dodag->of = dodag->of;
my_dodag->mop = dodag->mop;
my_dodag->dtsn = dodag->dtsn;
my_dodag->prf = dodag->prf;
my_dodag->dio_interval_doubling = dodag->dio_interval_doubling;
my_dodag->dio_min = dodag->dio_min;
my_dodag->dio_redundancy = dodag->dio_redundancy;
my_dodag->maxrankincrease = dodag->maxrankincrease;
my_dodag->minhoprankincrease = dodag->minhoprankincrease;
my_dodag->default_lifetime = dodag->default_lifetime;
my_dodag->lifetime_unit = dodag->lifetime_unit;
my_dodag->version = dodag->version;
my_dodag->grounded = dodag->grounded;
my_dodag->joined = 1;
my_dodag->my_preferred_parent = preferred_parent;
my_dodag->node_status = (uint8_t) NORMAL_NODE;
my_dodag->my_rank = dodag->of->calc_rank(preferred_parent, dodag->my_rank);
my_dodag->dao_seq = RPL_COUNTER_INIT;
my_dodag->min_rank = my_dodag->my_rank;
DEBUG("Joint DODAG:\n");
DEBUG("\tMOP:\t%02X\n", my_dodag->mop);
DEBUG("\tminhoprankincrease :\t%04X\n", my_dodag->minhoprankincrease);
DEBUG("\tdefault_lifetime:\t%02X\n", my_dodag->default_lifetime);
DEBUG("\tgrounded:\t%02X\n", my_dodag->grounded);
DEBUG("\tmy_preferred_parent:\t%s\n",
ipv6_addr_to_str(addr_str, IPV6_MAX_ADDR_STR_LEN,
&my_dodag->my_preferred_parent->addr));
DEBUG("\tmy_preferred_parent rank\t%02X\n", my_dodag->my_preferred_parent->rank);
DEBUG("\tmy_preferred_parent lifetime\t%04X\n", my_dodag->my_preferred_parent->lifetime);
start_trickle(my_dodag->dio_min, my_dodag->dio_interval_doubling, my_dodag->dio_redundancy);
delay_dao();
}
rpl_parent_t *rpl_new_parent(rpl_dodag_t *dodag, ipv6_addr_t *address, uint16_t rank)
{
rpl_parent_t *parent;
rpl_parent_t *end;
for (parent = &parents[0], end = parents + RPL_MAX_PARENTS; parent < end; parent++) {
if (parent->used == 0) {
memset(parent, 0, sizeof(*parent));
parent->used = 1;
parent->addr = *address;
parent->rank = rank;
parent->dodag = dodag;
parent->lifetime = dodag->default_lifetime * dodag->lifetime_unit;
/* dtsn is set at the end of recv_dio function */
parent->dtsn = 0;
return parent;
}
}
rpl_delete_worst_parent();
return rpl_new_parent(dodag, address, rank);
}
void rpl_recv_DIO(void)
{
ipv6_buf = get_rpl_ipv6_buf();
rpl_dio_buf = get_rpl_dio_buf();
DEBUGF("instance %04X ", rpl_dio_buf->rpl_instanceid);
DEBUGF("rank %04X\n", byteorder_ntohs(rpl_dio_buf->rank));
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 */
DEBUGF("Not joining another DODAG!\n");
return;
}
dio_inst = rpl_new_instance(rpl_dio_buf->rpl_instanceid);
if (dio_inst == NULL) {
DEBUGF("Failed to create a new RPL instance!\n");
return;
}
}
else if (my_inst == NULL) {
DEBUGF("Not joined an instance yet\n");
}
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. */
DEBUGF("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 < (NTOHS(ipv6_buf->length) - ICMPV6_HDR_LEN)) {
DEBUGF("parsing DIO options\n");
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_ROUTE_INFO): {
len += rpl_opt_buf->length;
break;
}
case (RPL_OPT_DODAG_CONF): {
has_dodag_conf_opt = 1;
if (rpl_opt_buf->length != RPL_OPT_DODAG_CONF_LEN) {
DEBUGF("DODAG configuration is malformed.\n");
/* 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 = byteorder_ntohs(rpl_opt_dodag_conf_buf->MaxRankIncrease);
dio_dodag.minhoprankincrease = byteorder_ntohs(rpl_opt_dodag_conf_buf->MinHopRankIncrease);
dio_dodag.default_lifetime = rpl_opt_dodag_conf_buf->default_lifetime;
dio_dodag.lifetime_unit = byteorder_ntohs(rpl_opt_dodag_conf_buf->lifetime_unit);
dio_dodag.of = (struct rpl_of_t *) rpl_get_of_for_ocp(byteorder_ntohs(rpl_opt_dodag_conf_buf->ocp));
if (dio_dodag.of == NULL) {
DEBUGF("[Error] OCP from DIO is not supported! ocp: %x\n",
byteorder_ntohs(rpl_opt_dodag_conf_buf->ocp));
return;
}
len += RPL_OPT_DODAG_CONF_LEN_WITH_OPT_LEN;
break;
}
case (RPL_OPT_PREFIX_INFO): {
if (rpl_opt_buf->length != RPL_OPT_PREFIX_INFO_LEN) {
/* error malformed */
return;
}
rpl_opt_prefix_information_buf = get_rpl_opt_prefix_information_buf(len);
/* autonomous address-configuration flag */
if (rpl_opt_prefix_information_buf->flags & (1 << 6)) {
ipv6_addr_t tmp;
tmp = rpl_opt_prefix_information_buf->prefix;
if (!ipv6_addr_is_link_local(&tmp)) {
if (byteorder_ntohl(rpl_opt_prefix_information_buf->preferred_lifetime)
<= byteorder_ntohl(rpl_opt_prefix_information_buf->valid_lifetime)) {
ipv6_addr_set_by_eui64(&tmp, rpl_if_id, &tmp);
ipv6_net_if_add_addr(rpl_if_id, &tmp,
NDP_ADDR_STATE_PREFERRED,
byteorder_ntohl(rpl_opt_prefix_information_buf->valid_lifetime),
byteorder_ntohl(rpl_opt_prefix_information_buf->preferred_lifetime),
0);
dio_dodag.prefix = rpl_opt_prefix_information_buf->prefix;
dio_dodag.prefix_length = rpl_opt_prefix_information_buf->prefix_length;
dio_dodag.prefix_valid_lifetime =
byteorder_ntohl(rpl_opt_prefix_information_buf->valid_lifetime);
dio_dodag.prefix_preferred_lifetime =
byteorder_ntohl(rpl_opt_prefix_information_buf->preferred_lifetime);
dio_dodag.prefix_flags = rpl_opt_prefix_information_buf->flags;
}
}
}
len += RPL_OPT_PREFIX_INFO_LEN_WITH_OPT_LEN;
break;
}
default:
DEBUGF("[Error] Unsupported DIO option\n");
return;
}
}
/* handle packet content... */
rpl_dodag_t *my_dodag = rpl_get_joined_dodag(dio_inst->id);
if (my_dodag == NULL) {
if (!has_dodag_conf_opt) {
DEBUGF("send DIS\n");
rpl_send_DIS(&ipv6_buf->srcaddr);
}
if (byteorder_ntohs(rpl_dio_buf->rank) < ROOT_RANK) {
DEBUGF("DIO with Rank < ROOT_RANK\n");
}
if (dio_dodag.mop != RPL_DEFAULT_MOP) {
DEBUGF("Required MOP not supported\n");
}
if (dio_dodag.of == NULL) {
DEBUGF("Required objective function not supported\n");
}
if (byteorder_ntohs(rpl_dio_buf->rank) != INFINITE_RANK) {
DEBUGF("Will join DODAG\n");
rpl_join_dodag(&dio_dodag, &ipv6_buf->srcaddr, byteorder_ntohs(rpl_dio_buf->rank));
}
else {
DEBUGF("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) {
DEBUGF("[Warning] Inconsistent Dodag Version\n");
my_dodag->version = RPL_COUNTER_INCREMENT(dio_dodag.version);
trickle_reset_timer(&my_dodag->trickle);
}
else {
DEBUGF("my dodag has no preferred_parent yet - seems to be odd since I have a parent.\n");
my_dodag->version = dio_dodag.version;
rpl_global_repair(my_dodag, &ipv6_buf->srcaddr, byteorder_ntohs(rpl_dio_buf->rank));
}
return;
}
else if (RPL_COUNTER_GREATER_THAN(my_dodag->version, dio_dodag.version)) {
/* lower version number detected -> send more DIOs */
trickle_reset_timer(&my_dodag->trickle);
return;
}
}
/* version matches, DODAG matches */
if (byteorder_ntohs(rpl_dio_buf->rank) == INFINITE_RANK) {
trickle_reset_timer(&my_dodag->trickle);
}
/* We are root, all done!*/
if (my_dodag->my_rank == ROOT_RANK) {
if (byteorder_ntohs(rpl_dio_buf->rank) != INFINITE_RANK) {
trickle_increment_counter(&my_dodag->trickle);
}
return;
}
/********************* Parent Handling *********************/
rpl_parent_t *parent;
parent = rpl_find_parent(my_dodag, &ipv6_buf->srcaddr);
if (parent == NULL) {
/* add new parent candidate */
parent = rpl_new_parent(my_dodag, &ipv6_buf->srcaddr, byteorder_ntohs(rpl_dio_buf->rank));
if (parent == NULL) {
return;
}
}
else {
/* DIO OK */
trickle_increment_counter(&my_dodag->trickle);
}
/* update parent rank */
parent->rank = byteorder_ntohs(rpl_dio_buf->rank);
rpl_parent_update(my_dodag, parent);
if (my_dodag->my_preferred_parent == NULL) {
DEBUGF("My dodag has no preferred_parent yet - seems to be odd since I have a parent...\n");
}
else if (rpl_equal_id(&parent->addr, &my_dodag->my_preferred_parent->addr) &&
(parent->dtsn != rpl_dio_buf->dtsn)) {
rpl_delay_dao(my_dodag);
}
parent->dtsn = rpl_dio_buf->dtsn;
}
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 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;
}
