/*
* Create <tlv> for ...
*/
static void
create_tlv_for_index_hello(olsr_pktbuf_t *buf,
BASE_ADDRESS *base,
olsr_u32_t index, olsr_u8_t tlv_type, olsr_u8_t tlv_value)
{
switch (tlv_type)
{
case Link_Status:
if (base->data[index].link_status == tlv_value)
create_simple_tlv(buf, tlv_type, SINGLE_INDEX, 1, 0, 0, &tlv_value);
break;
case Other_Neigh:
if(base->data[index].other_neigh == tlv_value)
create_simple_tlv(buf, tlv_type, SINGLE_INDEX, 1, 0, 0, &tlv_value);
break;
case Other_If:
if (base->data[index].other_if== tlv_value)
create_simple_tlv(buf, tlv_type, (SINGLE_INDEX | NO_VALUE), 1, 0, 0, &tlv_value);
break;
case MPR_Selection:
if (base->data[index].MPR_Selection == tlv_value)
create_simple_tlv(buf, tlv_type, (SINGLE_INDEX | NO_VALUE), 1, 0, 0, &tlv_value);
break;
default:
olsr_error("%s\n", __FUNCTION__);
}
}
/* change output from stdout to anything */
void set_std_handler(const char *handler){
if( (std_handler = fopen(handler,"w")) == NULL)
olsr_error("fopen()");
return;
}
void print_mpr_set_per_interface(struct olsrv2* olsr, OLSR_LIST *MPR_set)
{
OLSR_LIST_ENTRY *tmp = NULL;
OLSR_MPR_TUPLE *data = NULL;
tmp = MPR_set->head;
if (tmp == NULL){
olsr_printf( "--- MPR Set per Interface ---\n");
olsr_printf( "no entry.\n");
olsr_printf( "-----------------------------\n");
}else{
if (olsr->olsr_cnf->ip_version == AF_INET){
char str1[INET_ADDRSTRLEN], str2[INET_ADDRSTRLEN];
olsr_printf( "------------ MPR Set per Interface ------------\n");
olsr_printf( "%-20s %-16s\n", "local_iface_addr", "MPR_if_addr");
olsr_printf( "-----------------------------------------------\n");
while (tmp != NULL){
data = (OLSR_MPR_TUPLE *)tmp->data;
//inet_ntop(AF_INET, &data->local_iface_addr.v4, str1, sizeof(str1));
//inet_ntop(AF_INET, &data->MPR_if_addr.v4, str2, sizeof(str2));
ConvertIpv4AddressToString(data->local_iface_addr.v4, str1);
ConvertIpv4AddressToString(data->MPR_if_addr.v4, str2);
olsr_printf( "%-20s %-16s\n", str1, str2);
tmp = tmp->next;
}
olsr_printf( "----------------------------------------------\n");
}
else if (olsr->olsr_cnf->ip_version == AF_INET6){
char str1[INET6_ADDRSTRLEN], str2[INET6_ADDRSTRLEN];
olsr_printf( "--------------------------- MPR Set per Interface ---------------------------\n");
olsr_printf( "%-46s %-46s\n", "local_iface_addr", "MPR_if_addr");
olsr_printf( "-----------------------------------------------------------------------------\n");
while (tmp != NULL){
data = (OLSR_MPR_TUPLE *)tmp->data;
//inet_ntop(AF_INET6,
// data->local_iface_addr.v6.s6_addr, str1, sizeof(str1));
//inet_ntop(AF_INET6,
// data->MPR_if_addr.v6.s6_addr, str2, sizeof(str2));
ConvertIpv6AddressToString(&data->local_iface_addr.v6, str1, (olsr_bool)false);
ConvertIpv6AddressToString(&data->MPR_if_addr.v6, str2, (olsr_bool)false);
olsr_printf( "%-46s %-46s\n", str1, str2);
tmp = tmp->next;
}
olsr_printf( "-----------------------------------------------------------------------------\n");
}
else{
olsr_error("Un known ip_version");
assert(OLSR_FALSE);
}
}
}
void print_relay_set(struct olsrv2 *olsr)
{
OLSR_LIST_ENTRY *tmp = NULL;
OLSR_RELAY_TUPLE *data = NULL;
if(olsr->olsr_cnf->debug_level < 2)
return;
tmp = olsr->relay_set.head;
if(tmp == NULL){
olsr_printf("--- Relay Set ---\n");
olsr_printf("no entry.\n");
olsr_printf("----------------------------\n");
}else{
if(olsr->olsr_cnf->ip_version == AF_INET){
char str[INET_ADDRSTRLEN];
olsr_printf("-------------- Relay Neighbor Set --------------\n");
olsr_printf("%-16s\n", "RS_if_addr");
olsr_printf("--------------------------------------------------\n");
while(tmp != NULL){
data = (OLSR_RELAY_TUPLE *)tmp->data;
//WIN FIX: Need to resolve this
//inet_ntop(AF_INET, &data->RS_if_addr.v4, str, sizeof(str));
ConvertIpv4AddressToString(data->RS_if_addr.v4, str);
olsr_printf("%-16s\n", str);
tmp = tmp->next;
}
olsr_printf("--------------------------------------------------\n");
}
else if(olsr->olsr_cnf->ip_version == AF_INET6){
char str[INET6_ADDRSTRLEN];
olsr_printf("---------------------------- Relay Set ------------------------------\n");
olsr_printf("%-46s\n", "RS_if_addr");
olsr_printf("--------------------------------------------------------------------------------\n");
while(tmp != NULL){
data = (OLSR_RELAY_TUPLE *)tmp->data;
//WIN FIX: Need to resolve this
//inet_ntop(AF_INET6, data->RS_if_addr.v6.s6_addr, str, sizeof(str));
ConvertIpv6AddressToString(&data->RS_if_addr.v6, str, OLSR_FALSE);
olsr_printf("%-46s\n", str);
tmp = tmp->next;
}
olsr_printf("--------------------------------------------------------------------------------\n");
}
else{
olsr_error("Un known ip_version");
assert(OLSR_FALSE);
}
}
}
void print_mprN2(struct olsrv2* olsr, OLSR_LIST *N2)
{
OLSR_LIST_ENTRY *tmp = NULL;
OLSR_MPR_N_TUPLE *data = NULL;
tmp = N2->head;
if (tmp == NULL){
olsr_printf( "--- MPR N2 ---\n");
olsr_printf( "no entry.\n");
olsr_printf( "--------------\n");
}else{
if (olsr->olsr_cnf->ip_version == AF_INET){
char str[INET_ADDRSTRLEN];
olsr_printf( "----- MPR N2 -----\n");
olsr_printf( "%-16s\n", "MPR_N2_if_addr");
olsr_printf( "------------------\n");
while (tmp != NULL){
data = (OLSR_MPR_N_TUPLE *)tmp->data;
//inet_ntop(AF_INET, &data->addr.v4, str, sizeof(str));
ConvertIpv4AddressToString(data->addr.v4, str);
olsr_printf( "%-16s\n", str);
tmp = tmp->next;
}
olsr_printf( "------------------\n");
}
else if (olsr->olsr_cnf->ip_version == AF_INET6){
char str[INET6_ADDRSTRLEN];
olsr_printf( "------------------- MPR N2 -------------------\n");
olsr_printf( "%-46s\n", "MPR_N2_if_addr");
olsr_printf( "----------------------------------------------\n");
while (tmp != NULL){
data = (OLSR_MPR_N_TUPLE *)tmp->data;
//inet_ntop(AF_INET6, data->addr.v6.s6_addr, str, sizeof(str));
ConvertIpv6AddressToString(&data->addr.v6, str, (olsr_bool)false);
olsr_printf( "%-46s\n", str);
tmp = tmp->next;
}
olsr_printf( "----------------------------------------------\n");
}
else{
olsr_error("Un known ip_version");
assert(OLSR_FALSE);
}
}
}
void delete_association_set_for_addr(struct olsrv2 *olsr,
OLSR_LIST *iface_list){
OLSR_LOCAL_INTERFACE_BLOCK_ENTRY *local_iface_data = NULL;
OLSR_ASSOCIATION_TUPLE *associ_data = NULL, *associ_list_data = NULL;
OLSR_LIST *retList = NULL;
OLSR_LIST_ENTRY *entry = NULL,*list_entry = NULL;
int i, tmp_index;
entry = iface_list->head;
while(entry){
local_iface_data = (OLSR_LOCAL_INTERFACE_BLOCK_ENTRY *)entry->data;
retList = search_association_set_for_addr(olsr,
&local_iface_data->iface_addr);
if(retList){
if(retList->numEntry != 1){
olsr_error("delete_association_set_for_addr");
}
associ_data = (OLSR_ASSOCIATION_TUPLE *)retList->head->data;
OLSR_DeleteList_Search(retList);
for(i = 0; i < associ_data->num_NAlist; i++) {
list_entry = (OLSR_LIST_ENTRY *)associ_data->NA_list[i];
associ_list_data = (OLSR_ASSOCIATION_TUPLE *)list_entry->data;
tmp_index = olsr_hashing(olsr,&associ_list_data->NA_iface_addr);
free(associ_list_data->NA_list);
OLSR_DeleteListEntry(&olsr->associ_set[tmp_index].list, list_entry);
}
free(associ_data->NA_list);
if(OLSR_DeleteListHandler((void* )olsr,
&olsr->associ_set[olsr_hashing(olsr,&associ_data->NA_iface_addr)].list,
(void* )&local_iface_data->iface_addr,
&delete_association_set_for_addr_handler)){
olsr->change_associ_set = OLSR_TRUE;
}
}//if
entry = entry->next;
}//while
}
void print_proc_set(struct olsrv2 *olsr)
{
OLSR_LIST_ENTRY *tmp = NULL;
OLSR_PROC_TUPLE *data = NULL;
struct olsrd_config* olsr_cnf = olsr->olsr_cnf;
int i;
if (olsr_cnf->debug_level < 2)
return;
olsr_printf("--- Processed Set ---\n");
//struct olsrv2
for (i=0; i<HASHSIZE; i++)
{
tmp = olsr->proc_set[i].list.head;
if (tmp != NULL){
if (olsr_cnf->ip_version == AF_INET){
char str[INET_ADDRSTRLEN];
olsr_printf("%-16s %-12s %-12s\n", "P_addr", "P_seq_number", "P_time");
while (tmp != NULL){
char time[30];
data = (OLSR_PROC_TUPLE *)tmp->data;
//WIN FIX: Need to resolve this
//inet_ntop(AF_INET, &data->P_addr.v4, str, sizeof(str));
ConvertIpv4AddressToString(data->P_addr.v4, str);
qualnet_print_clock_in_second(data->P_time, time);
olsr_printf("%-16s %-12d %s [sec]\n", str, data->P_seq_number, time);
tmp = tmp->next;
}
}
else if (olsr_cnf->ip_version == AF_INET6){
char str[INET6_ADDRSTRLEN];
olsr_printf("%-46s %-12s %-12s\n", "P_addr", "P_seq_number", "P_time");
while (tmp != NULL){
char time[30];
data = (OLSR_PROC_TUPLE *)tmp->data;
//WIN FIX: Need to resolve this
//inet_ntop(AF_INET6, data->P_addr.v6.s6_addr, str, sizeof(str));
ConvertIpv6AddressToString(&data->P_addr.v6, str, OLSR_FALSE);
qualnet_print_clock_in_second(data->P_time, time);
olsr_printf("%-46s %-12d %s [sec]\n", str, data->P_seq_number, time);
tmp = tmp->next;
}
}
else{
olsr_error("Un known ip_version");
assert(OLSR_FALSE);
}
}
}
olsr_printf("-------------------\n");
}
void print_mprN(struct olsrv2* olsr, OLSR_LIST *N)
{
OLSR_LIST_ENTRY *tmp = NULL;
OLSR_MPR_N_TUPLE *data = NULL;
tmp = N->head;
if (tmp == NULL){
olsr_printf("--- MPR N ---\n");
olsr_printf("no entry.\n");
olsr_printf("--------------\n");
}else{
if (olsr->olsr_cnf->ip_version == AF_INET){
char str[INET_ADDRSTRLEN];
olsr_printf("------------------------ MPR N -----------------------\n");
olsr_printf("%-16s %-12s %-12s %-12s\n",
"MPR_N_if_addr", "D", "reachability", "willingness");
olsr_printf("------------------------------------------------------\n");
while (tmp != NULL){
data = (OLSR_MPR_N_TUPLE *)tmp->data;
//inet_ntop(AF_INET, &data->addr.v4, str, sizeof(str));
//yowada
ConvertIpv4AddressToString(data->addr.v4, str);
olsr_printf("%-16s %-12u %-12u %-12u\n",
str,
data->D,
data->reachability,
data->willingness);
tmp = tmp->next;
}
olsr_printf("------------------------------------------------------\n");
}
else if (olsr->olsr_cnf->ip_version == AF_INET6){
char str[INET6_ADDRSTRLEN];
olsr_printf("--------------------------------------- MPR N --------------------------------------\n");
olsr_printf("%-46s %-12s %-12s %-12s\n",
"MPR_N_if_addr", "D", "reachability", "willingness");
olsr_printf("------------------------------------------------------------------------------------\n");
while (tmp != NULL){
data = (OLSR_MPR_N_TUPLE *)tmp->data;
//inet_ntop(AF_INET6, data->addr.v6.s6_addr, str, sizeof(str));
ConvertIpv6AddressToString(&data->addr.v6, str, OLSR_FALSE);
olsr_printf("%-46s %-12u %-12u %-12u\n",
str,
data->D,
data->reachability,
data->willingness);
tmp = tmp->next;
}
olsr_printf("------------------------------------------------------------------------------------\n");
}
else{
olsr_error("Un known ip_version");
assert(OLSR_FALSE);
}
}
}
OLSR_LIST *proc_mpr_set_per_interface(struct olsrv2 *olsr,
union olsr_ip_addr *local_iface_addr)
{
OLSR_LIST *MPR_set = NULL, N, N2;
OLSR_LIST *retList = NULL;
OLSR_LIST_ENTRY *tmp = NULL, *retList_tmp = NULL;
OLSR_LINK_TUPLE *link_data = NULL;
OLSR_2NEIGH_TUPLE *two_neigh_data = NULL;
OLSR_MPR_N_TUPLE *mpr_n_data = NULL;
OLSR_MPR_N2_TUPLE *mpr_n2_data = NULL;
int hash_index;
olsr_time_t time;
get_current_time(olsr, &time);
if (DEBUG_OLSRV2)
{
olsr_printf("\n[Start MPR selection per interface]\n");
}
//Init MPR set
MPR_set = (OLSR_LIST *)olsr_malloc(sizeof(OLSR_LIST), __FUNCTION__);
OLSR_InitList(MPR_set);
//Create MPR N
// N - the set of such neighbor interfaces
if (DEBUG_OLSRV2)
{
olsr_printf("[Create N]\n");
olsr_printf("[Appendix A.2]\n");
}
OLSR_InitList(&N);
tmp = olsr->link_set.head;
while (tmp != NULL){
link_data = (OLSR_LINK_TUPLE *)tmp->data;
if (link_data->L_willingness > WILL_NEVER &&
get_link_status(time,
link_data->L_SYM_time,
link_data->L_ASYM_time,
link_data->L_LOST_LINK_time) == SYMMETRIC){
if (equal_ip_addr(olsr, &link_data->L_local_iface_addr,
local_iface_addr)){
if (search_mprN_for_exist(olsr, &N, &link_data->L_neighbor_iface_addr)
== OLSR_FALSE){
// Calculate D(y), where y is a member of N, for all interfaces in N.
int retNum = check_2neigh_set_for_mpr_n_exist_num_entry(olsr, local_iface_addr,
&link_data->L_neighbor_iface_addr);
if (retNum > 0){
insert_mprN(&N, &link_data->L_neighbor_iface_addr,
/*retList->numEntry*/retNum, 0,
link_data->L_willingness);
}
}
}
}
tmp = tmp->next;
}
//print_mprN(olsr, &N);
//Create MPR N2
// N2 - the set of such 2-hop neighbor interfaces
if (DEBUG_OLSRV2)
{
olsr_printf("[Create N2]\n");
}
OLSR_InitList(&N2);
for (hash_index = 0; hash_index < HASHSIZE; hash_index++)
{
tmp = olsr->two_neigh_set[hash_index].list.head;
while (tmp != NULL){
two_neigh_data = (OLSR_2NEIGH_TUPLE *)tmp->data;
if (search_mprN_for_exist(olsr, &N, &two_neigh_data->N2_neighbor_iface_addr)
== OLSR_TRUE &&
search_association_set_for_addr_exist(olsr, &two_neigh_data->N2_2hop_iface_addr)
== OLSR_FALSE){
if (equal_ip_addr(olsr, &two_neigh_data->N2_local_iface_addr,
local_iface_addr)){
if (search_mprN_for_exist(olsr, &N, &two_neigh_data->N2_2hop_iface_addr)
== OLSR_TRUE){
tmp = tmp->next;
continue;
}
if (search_mprN2_for_exist(olsr, &N2, &two_neigh_data->N2_2hop_iface_addr) == OLSR_FALSE)
{
insert_mprN2(&N2, &two_neigh_data->N2_2hop_iface_addr);
}
}
}
tmp = tmp->next;
}
}
//print_mprN2(olsr, &N2);
//Appendix A.1
// Start with an MPR set made of all members of N with N_willingness
// equal to WILL_ALWAYS
if (DEBUG_OLSRV2)
{
olsr_printf("[Appendix A.1]\n");
}
tmp = N.head;
while (tmp != NULL){
mpr_n_data = (OLSR_MPR_N_TUPLE *)tmp->data;
if (mpr_n_data->willingness == WILL_ALWAYS)
insert_mpr_set_per_interface(MPR_set, local_iface_addr, &mpr_n_data->addr);
tmp = tmp->next;
}
update_mprN2(olsr,
&N2, MPR_set, local_iface_addr);
//print_mprN2(olsr, &N2);
//Appendix A.3
// Add to the MPR set those interfaces in N, which are the *only*
// nodes to provide reachability to an interface in N2. For
// example, if interface B in N2 can be reached only through a
// symmetric link to interface A in N, then add interface B to the
// MPR set. Remove the interfaces from N2 which are now covered by
// a interface in the MPR set.
if (DEBUG_OLSRV2)
{
olsr_printf("[Appendix A.3]\n");
}
tmp = N2.head;
while (tmp != NULL){
mpr_n2_data = (OLSR_MPR_N2_TUPLE *)tmp->data;
retList =
search_2neigh_set_for_mpr_n2(olsr,
local_iface_addr,
&mpr_n2_data->addr);
if (retList != NULL){
if (retList->numEntry == 1){
two_neigh_data = (OLSR_2NEIGH_TUPLE *)retList->head->data;
insert_mpr_set_per_interface(MPR_set,
local_iface_addr,
&two_neigh_data->N2_neighbor_iface_addr);
update_mprN2_locally(olsr,
&N2,
local_iface_addr,
&two_neigh_data->N2_neighbor_iface_addr);
tmp = N2.head;
OLSR_DeleteList_Search(retList);
continue;
}
OLSR_DeleteList_Search(retList);
}
tmp = tmp->next;
}
//print_mprN2(olsr, &N2);
//Appendix A.4
// While there exist interfaces in N2 which are not covered by at
// least one interface in the MPR set:
if (DEBUG_OLSRV2)
{
olsr_printf("[Appendix A.4]\n");
}
while (N2.head != NULL){
//Appendix A.4.1
// For each interface in N, calculate the reachability, i.e.,
// the number of interfaces in N2 which are not yet covered by
// at least one node in the MPR set, and which are reachable
// through this neighbor interface;
//OLSR_LIST *ret;
olsr_u32_t max_willingness, max_reachability, max_D;
olsr_u32_t i;
union olsr_ip_addr mpr_addr;
union olsr_ip_addr random_mpr[OLSR_MAX_DUPLICATE_MPR];
memset(&mpr_addr, 0, sizeof(olsr_ip_addr));
if (DEBUG_OLSRV2)
{
olsr_printf("[Appendix A.4.1]\n");
}
tmp = N.head;
while (tmp != NULL){
mpr_n_data = (OLSR_MPR_N_TUPLE *)tmp->data;
mpr_n_data->reachability = 0;
retList =
search_2neigh_set_for_mpr_n(olsr,
local_iface_addr,
&mpr_n_data->addr);
if (retList != NULL){
retList_tmp = retList->head;
while (retList_tmp != NULL){
two_neigh_data = (OLSR_2NEIGH_TUPLE *)retList_tmp->data;
if (search_mprN2_for_exist(olsr, &N2, &two_neigh_data->N2_2hop_iface_addr)
== OLSR_TRUE){
mpr_n_data->reachability++;
}
retList_tmp = retList_tmp->next;
}
OLSR_DeleteList_Search(retList);
}
tmp = tmp->next;
}
//print_mprN(olsr, &N);
//Appendix A.4.2(XXX)
// Select as a MPR the interface with highest N_willingness
// among the interfaces in N with non-zero reachability.
// In case of multiple choice select the interface which provides
// reachability to the maximum number of interfaces in N2.
// In case of multiple interfaces providing the same amount of
// reachability, select the interface as MPR whose D(y) is
// greater.
// Remove the interfaces from N2 which are now covered by an interface in the MPR set.
tmp = N.head;
max_willingness = WILL_NEVER; //0
max_reachability = 0;
max_D = 0;
i = 0;
while (tmp != NULL){
mpr_n_data = (OLSR_MPR_N_TUPLE *)tmp->data;
if (mpr_n_data->reachability == 0){
tmp = tmp->next;
continue;
}
//check willingness
if (mpr_n_data->willingness > max_willingness){
max_willingness = mpr_n_data->willingness;
max_reachability = mpr_n_data->reachability;
max_D = mpr_n_data->D;
i = 0;
mpr_addr = mpr_n_data->addr;
}
else if (mpr_n_data->willingness == max_willingness){
//check reachability
if (mpr_n_data->reachability > max_reachability){
max_reachability = mpr_n_data->reachability;
max_D = mpr_n_data->D;
i = 0;
mpr_addr = mpr_n_data->addr;
}
else if (mpr_n_data->reachability == max_reachability){
//check D(y)
if (mpr_n_data->D > max_D){
max_D = mpr_n_data->D;
i = 0;
mpr_addr = mpr_n_data->addr;
}
else if (mpr_n_data->D == max_D){
if (i == 0){
random_mpr[i++] = mpr_addr;
}
if (i < OLSR_MAX_DUPLICATE_MPR){
random_mpr[i++] = mpr_n_data->addr;
}
}
}
}
tmp = tmp->next;
}// ....now checked duplication
if (max_willingness == WILL_NEVER){
olsr_error("MPR selection is wrong "
"there is no MPR which have available willingness, "
"or non-zero-reachability");
}
if (i != 0){
i = (olsr_u32_t)(random(olsr)%i);
mpr_addr = random_mpr[i];
}
insert_mpr_set_per_interface(MPR_set,
local_iface_addr,
&mpr_addr);
update_mprN2_locally(olsr,
&N2,
local_iface_addr,
&mpr_addr);
//print_mpr_set_per_interface(olsr, MPR_set);
}
//print_mpr_set_per_interface(olsr, MPR_set);
if (DEBUG_OLSRV2)
{
olsr_printf("[Complete MPR selection per interface]\n\n");
}
OLSR_DeleteList_Static(&N);
OLSR_DeleteList_Static(&N2);
return MPR_set;
}
void print_routing_set(struct olsrv2 *olsr)
{
OLSR_LIST_ENTRY *tmp = NULL;
OLSR_ROUTING_TUPLE *data = NULL;
int i;
if (olsr->olsr_cnf->debug_level < 2)
return;
olsr_printf("--- Routing Set ---\n");
olsr_printf("%-17s %-17s %-12s %-16s %-10s\n",
"R_dest_iface_addr", "R_next_iface_addr", "R_dist", "R_iface_addr", "R_prefix");
for (i=0; i<HASHSIZE; i++)
{
tmp = olsr->routing_set[i].list.head;
if (tmp == NULL){
}else{
if (olsr->olsr_cnf->ip_version == AF_INET){
char str1[INET_ADDRSTRLEN], str2[INET_ADDRSTRLEN], str3[INET_ADDRSTRLEN];
while (tmp){
data = (OLSR_ROUTING_TUPLE *)tmp->data;
//WIN FIX: Need to resolve this
//inet_ntop(AF_INET, &data->R_dest_iface_addr.v4, str1, sizeof(str1));
//inet_ntop(AF_INET, &data->R_next_iface_addr.v4, str2, sizeof(str2));
//inet_ntop(AF_INET, &data->R_iface_addr.v4, str3, sizeof(str3));
ConvertIpv4AddressToString(data->R_dest_iface_addr.v4, str1);
ConvertIpv4AddressToString(data->R_next_iface_addr.v4, str2);
ConvertIpv4AddressToString(data->R_iface_addr.v4, str3);
olsr_printf("%-17s %-17s %-12d %-16s %-10d\n",
str1,
str2,
data->R_dist,
str3,
data->R_prefix_length);
tmp = tmp->next;
}
}
else if (olsr->olsr_cnf->ip_version == AF_INET6){
char str1[INET6_ADDRSTRLEN], str2[INET6_ADDRSTRLEN], str3[INET6_ADDRSTRLEN];
olsr_printf("%-46s %-46s %-12s %-46s %-10s\n",
"R_dest_iface_addr", "R_next_iface_addr", "R_dist", "R_iface_addr", "R_prefix");
while (tmp){
data = (OLSR_ROUTING_TUPLE *)tmp->data;
//WIN FIX: Need to resolve this
//inet_ntop(AF_INET6, data->R_dest_iface_addr.v6.s6_addr, str1, sizeof(str1));
//inet_ntop(AF_INET6, data->R_next_iface_addr.v6.s6_addr, str2, sizeof(str2));
//inet_ntop(AF_INET6, data->R_iface_addr.v6.s6_addr, str3, sizeof(str3));
ConvertIpv6AddressToString(&data->R_dest_iface_addr.v6, str1, OLSR_FALSE);
ConvertIpv6AddressToString(&data->R_next_iface_addr.v6, str2, OLSR_FALSE);
ConvertIpv6AddressToString(&data->R_iface_addr.v6, str3, OLSR_FALSE);
olsr_printf("%-46s %-46s %-12d %-46s %-10d\n",
str1,
str2,
data->R_dist,
str3,
data->R_prefix_length);
tmp = tmp->next;
}
}
else{
olsr_error("Un known ip_version");
assert(OLSR_FALSE);
}
}
}
olsr_printf("-------------------\n");
}
static void create_tlv_by_list(void *olsr, OLSR_LIST *tlv_block,
OLSR_LIST *block,
olsr_u8_t tlv_type,
olsr_u8_t tlv_value)
{
BASE_TLV base_tlv;
OLSR_LIST_ENTRY *tmp = NULL;
BLOCK_DATA *data = NULL, *next_data = NULL;
olsr_u8_t index_start, index_stop;
olsr_u32_t index = 0;
olsr_bool flag_A;
index_start = index_stop = 0;
flag_A = OLSR_FALSE;
tmp = block->head;
while (tmp)
{
data = (BLOCK_DATA *)tmp->data;
switch (tlv_type)
{
case Link_Status:
{
if (data->link_status == tlv_value)
{
if (!flag_A)
{
index_start = (olsr_u8_t)index;
flag_A = OLSR_TRUE;
}
index_stop = (olsr_u8_t)index;
if (flag_A)
{
if (index == block->numEntry - 1)
{
base_tlv.tlv_type = tlv_type;
base_tlv.tlv_semantics = ALL_ZERO;
base_tlv.tlv_length = sizeof(olsr_u8_t);
base_tlv.index_start = index_start;
base_tlv.index_stop = index_stop;
base_tlv.value =
(olsr_u8_t *)olsr_malloc(base_tlv.tlv_length, __FUNCTION__);
memcpy(base_tlv.value, &tlv_value,
base_tlv.tlv_length);
if(index_start == 0)
base_tlv.tlv_semantics |= NO_INDEX;
else if(index_start == index_stop)
base_tlv.tlv_semantics |= SINGLE_INDEX;
OLSR_InsertList( tlv_block, &base_tlv,
sizeof(BASE_TLV));
flag_A = OLSR_FALSE;
}
else if (index < block->numEntry - 1)
{
next_data = (BLOCK_DATA *)tmp->next->data;
if (next_data->link_status != tlv_value)
{
base_tlv.tlv_type = tlv_type;
base_tlv.tlv_semantics = ALL_ZERO;
base_tlv.tlv_length = sizeof(olsr_u8_t);
base_tlv.index_start = index_start;
base_tlv.index_stop = index_stop;
base_tlv.value =
(olsr_u8_t *)olsr_malloc(base_tlv.tlv_length, __FUNCTION__);
memcpy(base_tlv.value, &tlv_value,
base_tlv.tlv_length);
if(index_start == index_stop)
base_tlv.tlv_semantics |= SINGLE_INDEX;
OLSR_InsertList( tlv_block, &base_tlv,
sizeof(BASE_TLV));
flag_A = OLSR_FALSE;
}
}
}
}
break;
}
case Other_If:
{
if (data->other_if == tlv_value)
{
if (!flag_A)
{
index_start = (olsr_u8_t)index;
flag_A = OLSR_TRUE;
}
index_stop = (olsr_u8_t)index;
if (flag_A)
{
if (index == block->numEntry - 1)
{
base_tlv.tlv_type = tlv_type;
base_tlv.tlv_semantics = NO_VALUE;
base_tlv.tlv_length = 0;
base_tlv.index_start = index_start;
base_tlv.index_stop = index_stop;
base_tlv.value = NULL;
if(index_start == index_stop)
base_tlv.tlv_semantics |= SINGLE_INDEX;
else if(index_start == 0)
base_tlv.tlv_semantics |= NO_INDEX;
OLSR_InsertList( tlv_block, &base_tlv,
sizeof(BASE_TLV));
flag_A = OLSR_FALSE;
}
else if (index < block->numEntry - 1)
{
next_data = (BLOCK_DATA *)tmp->next->data;
if (next_data->other_if != tlv_value)
{
base_tlv.tlv_type = tlv_type;
base_tlv.tlv_semantics = NO_VALUE;
base_tlv.tlv_length = 0;
base_tlv.index_start = index_start;
base_tlv.index_stop = index_stop;
base_tlv.value = NULL;
if(index_start == index_stop)
base_tlv.tlv_semantics |= SINGLE_INDEX;
OLSR_InsertList( tlv_block, &base_tlv,
sizeof(BASE_TLV));
flag_A = OLSR_FALSE;
}
}
}
}
break;
}
case MPR_Selection:
{
if (data->MPR_Selection == tlv_value)
{
if (!flag_A)
{
index_start = (olsr_u8_t)index;
flag_A = OLSR_TRUE;
}
index_stop = (olsr_u8_t)index;
if (flag_A)
{
if (index == block->numEntry - 1)
{
base_tlv.tlv_type = tlv_type;
base_tlv.tlv_semantics = NO_VALUE;
base_tlv.tlv_length = 0;
base_tlv.index_start = index_start;
base_tlv.index_stop = index_stop;
base_tlv.value = NULL;
if(index_start == index_stop)
base_tlv.tlv_semantics |= SINGLE_INDEX;
else if(index_start == 0)
base_tlv.tlv_semantics |= NO_INDEX;
OLSR_InsertList( tlv_block, &base_tlv,
sizeof(BASE_TLV));
flag_A = OLSR_FALSE;
}
else if (index < block->numEntry - 1)
{
next_data = (BLOCK_DATA *)tmp->next->data;
if (next_data->MPR_Selection != tlv_value)
{
base_tlv.tlv_type = tlv_type;
base_tlv.tlv_semantics = NO_VALUE;
base_tlv.tlv_length = 0;
base_tlv.index_start = index_start;
base_tlv.index_stop = index_stop;
base_tlv.value = NULL;
if(index_start == index_stop)
base_tlv.tlv_semantics |= SINGLE_INDEX;
OLSR_InsertList( tlv_block, &base_tlv,
sizeof(BASE_TLV));
flag_A = OLSR_FALSE;
}
}
}
}
break;
}
case PREFIX_LENGTH:
{
if (data->Prefix_Length == tlv_value)
{
if (!flag_A)
{
index_start = (olsr_u8_t)index;
flag_A = OLSR_TRUE;
}
index_stop = (olsr_u8_t)index;
if (flag_A)
{
if (index == block->numEntry - 1)
{
base_tlv.tlv_type = tlv_type;
base_tlv.tlv_semantics = ALL_ZERO;
base_tlv.tlv_length = sizeof(olsr_u8_t);
base_tlv.index_start = index_start;
base_tlv.index_stop = index_stop;
base_tlv.value =
(olsr_u8_t *)olsr_malloc(base_tlv.tlv_length, __FUNCTION__);
memcpy(base_tlv.value, &tlv_value,
base_tlv.tlv_length);
if(index_start == index_stop)
base_tlv.tlv_semantics |= SINGLE_INDEX;
else if(index_start == 0)
base_tlv.tlv_semantics |= NO_INDEX;
OLSR_InsertList( tlv_block, &base_tlv,
sizeof(BASE_TLV));
flag_A = OLSR_FALSE;
}
else if (index < block->numEntry - 1)
{
next_data = (BLOCK_DATA *)tmp->next->data;
if (next_data->Prefix_Length != tlv_value)
{
base_tlv.tlv_type = tlv_type;
base_tlv.tlv_semantics = ALL_ZERO;
base_tlv.tlv_length = sizeof(olsr_u8_t);
base_tlv.index_start = index_start;
base_tlv.index_stop = index_stop;
base_tlv.value =
(olsr_u8_t *)olsr_malloc(base_tlv.tlv_length, __FUNCTION__);
memcpy(base_tlv.value, &tlv_value,
base_tlv.tlv_length);
if(index_start == index_stop)
base_tlv.tlv_semantics |= SINGLE_INDEX;
OLSR_InsertList( tlv_block, &base_tlv,
sizeof(BASE_TLV));
flag_A = OLSR_FALSE;
}
}
}
}
break;
}
default:
olsr_error("%s\n", __FUNCTION__);
}
index++;
tmp = tmp->next;
}
}
//create multivalue tlv
void
create_hello_addr_tlv_by_multivalue(void *olsr, OLSR_LIST *tlv_block,
OLSR_LIST *block,
olsr_u8_t tlv_type)
{
BASE_TLV base_tlv;
OLSR_LIST_ENTRY *entry;
BLOCK_DATA *data, *next_data;
olsr_u8_t index_start, index_stop;
olsr_u32_t index, tlv_length;
olsr_bool set_index_start;
//Static Fix
//static olsr_pktbuf_t *buf = NULL;
olsr_pktbuf_t *buf = NULL;
index_start = index_stop = index =0;
tlv_length = 0;
set_index_start = OLSR_FALSE;
buf = olsr_pktbuf_alloc_with_capa(255 * sizeof(olsr_u8_t));
olsr_pktbuf_clear(buf);
entry = block->head;
while(entry){
data = (BLOCK_DATA *)entry->data;
switch(tlv_type){
case Link_Status:
{
if(data->link_status != 255){
//check index_start set or not
if(set_index_start == OLSR_FALSE){
index_start = index;
set_index_start = OLSR_TRUE;
}
index_stop = index;
tlv_length += sizeof(olsr_u8_t);
olsr_pktbuf_append_u8(buf, data->link_status);
//last addr
if(index == block->numEntry -1){
base_tlv.tlv_type = tlv_type;
base_tlv.tlv_semantics = MULTI_VALUE;
base_tlv.tlv_length = tlv_length;
base_tlv.index_start = index_start;
base_tlv.index_stop = index_stop;
//check semantics
if(index_start == 0){
base_tlv.tlv_semantics |= NO_INDEX;
}else if(index_start == index_stop){
base_tlv.tlv_semantics |= SINGLE_INDEX;
}
//set value
base_tlv.value = (olsr_u8_t *)olsr_malloc(tlv_length, __FUNCTION__);
memcpy(base_tlv.value, buf->data, tlv_length);
//insert list
OLSR_InsertList( tlv_block, &base_tlv, sizeof(BASE_TLV));
set_index_start = OLSR_FALSE;
olsr_pktbuf_clear(buf);
tlv_length =0;
}else if (index < block->numEntry -1){
next_data = (BLOCK_DATA *)entry->next->data;
if(next_data->link_status == 255){
base_tlv.tlv_type = tlv_type;
base_tlv.tlv_semantics = MULTI_VALUE;
base_tlv.tlv_length = tlv_length;
base_tlv.index_start = index_start;
base_tlv.index_stop = index_stop;
//check semantics
if(index_start == index_stop){
base_tlv.tlv_semantics |= SINGLE_INDEX;
}
//set value
base_tlv.value = (olsr_u8_t *)olsr_malloc(tlv_length, __FUNCTION__);
memcpy(base_tlv.value, buf->data, tlv_length);
//insert list
OLSR_InsertList( tlv_block, &base_tlv, sizeof(BASE_TLV));
set_index_start = OLSR_FALSE;
olsr_pktbuf_clear(buf);
tlv_length = 0;
}
}//if else if
}//link_status != 255
}//case
break;
case PREFIX_LENGTH:
{
if(data->Prefix_Length != 255){
//check index_start set or not
if(set_index_start == OLSR_FALSE){
index_start = index;
set_index_start = OLSR_TRUE;
}
index_stop = index;
tlv_length += sizeof(olsr_u8_t);
olsr_pktbuf_append_u8(buf, data->Prefix_Length);
//last addr
if(index == block->numEntry -1){
base_tlv.tlv_type = tlv_type;
base_tlv.tlv_semantics = MULTI_VALUE;
base_tlv.tlv_length = tlv_length;
base_tlv.index_start = index_start;
base_tlv.index_stop = index_stop;
//check semantics
if(index_start == 0){
base_tlv.tlv_semantics |= NO_INDEX;
}else if(index_start == index_stop){
base_tlv.tlv_semantics |= SINGLE_INDEX;
}
//set value
base_tlv.value = (olsr_u8_t *)olsr_malloc(tlv_length, __FUNCTION__);
memcpy(base_tlv.value, buf->data, tlv_length);
//insert list
OLSR_InsertList( tlv_block, &base_tlv, sizeof(BASE_TLV));
set_index_start = OLSR_FALSE;
olsr_pktbuf_clear(buf);
tlv_length =0;
}else if (index < block->numEntry -1){
next_data = (BLOCK_DATA *)entry->next->data;
if(next_data->Prefix_Length == 255){
base_tlv.tlv_type = tlv_type;
base_tlv.tlv_semantics = MULTI_VALUE;
base_tlv.tlv_length = tlv_length;
base_tlv.index_start = index_start;
base_tlv.index_stop = index_stop;
//check semantics
if(index_start == index_stop){
base_tlv.tlv_semantics |= SINGLE_INDEX;
}
//set value
base_tlv.value = (olsr_u8_t *)olsr_malloc(tlv_length, __FUNCTION__);
memcpy(base_tlv.value, buf->data, tlv_length);
//insert list
OLSR_InsertList( tlv_block, &base_tlv, sizeof(BASE_TLV));
set_index_start = OLSR_FALSE;
olsr_pktbuf_clear(buf);
tlv_length = 0;
}
}//if else if
}//Prefix_LENGTH != 255
}//case
break;
default:
olsr_error("%s\n", __FUNCTION__);
}//switch
index++;
entry = entry->next;
}
olsr_pktbuf_free(&buf);
//free(buf->data);
//free(buf);
}
static olsr_bool
process_hello(struct olsrv2 *olsr, struct hello_message *hello,
union olsr_ip_addr *in_if,
union olsr_ip_addr *from_addr)
{
struct hello_neighbor *hello_neigh = NULL;
OLSR_LIST* retList = NULL;
OLSR_LIST_ENTRY *entry = NULL;
OLSR_LOCAL_INTERFACE_BLOCK_ENTRY *local_entry = NULL;
OLSR_SYMMETRIC_NEIGHBOR_TUPLE *sym_data = NULL;
olsr_time_t time;
olsr_bool change_assn = OLSR_FALSE, selected_mpr = OLSR_FALSE;
//codexxx
// before processing hello message add the queue length of the corresponding originator to the OLSR_LIST "queue_set"
olsr_bool IPfound = OLSR_FALSE;
struct queue_info *queueInf = NULL, *tempo= NULL ;
OLSR_LIST_ENTRY *queueEntry = NULL;
queueInf = (queue_info *)olsr_malloc(sizeof(queue_info), __FUNCTION__);
queueInf->orig_IP = hello->orig_addr ;
queueInf->Qlength = hello->queuelength;
if(olsr->queue_set.numEntry == 0)
{ // insert to the list directly
OLSR_InsertList(&olsr->queue_set,queueInf,sizeof(queue_info));
}else{ // liste deja contient des element ...donc trouver si deja existe
queueEntry = olsr->queue_set.head ;
while(queueEntry != NULL) /////
{
tempo = (queue_info *)queueEntry->data ;
if(!cmp_ip_addr(olsr,&tempo->orig_IP,&queueInf->orig_IP)) ////
{ // on a trouver cet originator IP ds la liste alors update le queue et sortir de la boucle
tempo->Qlength = queueInf->Qlength;
IPfound = OLSR_TRUE;
break;
}
queueEntry = queueEntry->next ;
}
if(IPfound == OLSR_FALSE)
{ // cet IP n'existe pas deja dans la liste => l'introduire
OLSR_InsertList(&olsr->queue_set,queueInf,sizeof(queue_info));
}
}
//end codexxx
if (own_ip_addr(olsr, &hello->source_addr))
{ // wiss: ma3neta el source address byetaba2 ma3 wa7ed men el intrface address taba3 node
if(DEBUG_OLSRV2){
char* paddr = olsr_niigata_ip_to_string(olsr, &olsr->main_addr);
olsr_printf("Received Hello, but this Hello is sent from ME!!\n[%s]",paddr);
free(paddr);
}
return OLSR_FALSE; // wiss: betla3 men process_hello
}
if(search_link_set_local_for_exist(olsr,
in_if,
&hello->source_addr) == OLSR_FALSE){ // wiss:ma la2a bel olsr linkset entry 3enda local_if= "in_if" w neigbor_if=&hello->source_addr
// wiss: ma la2a jar 3endou ip hello->source_addr ma3neta el link da3
proc_link_set(olsr,
in_if,
&hello->source_addr,
LOST,
hello->willingness,
hello->vtime,
hello->htime);
}
// neighbor address
hello_neigh = hello->neighbors;
while (hello_neigh){
if(equal_ip_addr(olsr,
&hello_neigh->address,
in_if
))
{ // wiss: hello_neigh->address, byetaba2 ma3 in_if
proc_link_set(olsr,
in_if,
&hello->source_addr,
hello_neigh->status,
hello->willingness,
hello->vtime,
hello->htime);
//update symmetric neighbor set
proc_symmetric_neighbor_set(olsr,
in_if,
hello_neigh->status,
hello);
break; // wiss : so iza fet hon ya3ni la2a el neighbor so break... so iza ma la2an byente2el 3al neigh->next
}
hello_neigh = hello_neigh->next;
}
//update neighbor address association set
proc_association_set(olsr, &hello->local_iface_list, hello->vtime);
hello_neigh = hello->neighbors;
while (hello_neigh){
//process 2hop Neighbor set
proc_2neigh_set(olsr,
in_if,
&hello->source_addr,
&hello_neigh->address,
hello_neigh->status,
hello_neigh->other_neigh,
hello->vtime);
//check: own interfaces is selected MPR by source nodes.
if(selected_mpr == OLSR_FALSE &&
own_ip_addr(olsr, &hello_neigh->address) == OLSR_TRUE &&
hello_neigh->is_mpr == OLSR_TRUE) {
selected_mpr = OLSR_TRUE;
}
//next pointer
hello_neigh = hello_neigh->next;
}
//update mpr selector set , relay set, advertise neighbor set
if(selected_mpr == OLSR_TRUE) {
entry = hello->local_iface_list.head;
while(entry) {
local_entry = (OLSR_LOCAL_INTERFACE_BLOCK_ENTRY *)entry->data;
retList = search_symmetric_neighbor_set(olsr,
in_if,
&local_entry->iface_addr);
if(retList) {
if(retList->numEntry != 1) {
olsr_error("process_hello():5");
}
get_current_time(olsr, &time);
sym_data = (OLSR_SYMMETRIC_NEIGHBOR_TUPLE *)retList->head->data;
OLSR_DeleteList_Search(retList);
if(get_neighbor_status(&time, &sym_data->N_time) == SYMMETRIC) {
proc_mpr_selector_set(olsr, &local_entry->iface_addr);
if(olsr->change_mpr_selector_set) {
if(proc_adv_neigh_set(olsr, &local_entry->iface_addr)){
proc_relay_set(olsr, &local_entry->iface_addr);
change_assn = OLSR_TRUE;
}
}
}//if(get_neigh...)
}
//next entry
entry = entry->next;
}//while
}
else{ // wiss: ici selected_mpr==false
entry = hello->local_iface_list.head;
while(entry) {
local_entry = (OLSR_LOCAL_INTERFACE_BLOCK_ENTRY *)entry->data;
delete_mpr_selector_set(olsr, &local_entry->iface_addr);
if(olsr->change_mpr_selector_set) {
delete_adv_neigh_set(olsr, &local_entry->iface_addr);
if(olsr->change_adv_neigh_set) {
change_assn = OLSR_TRUE;
delete_relay_set(olsr, &local_entry->iface_addr);
}
}
//next entry
entry = entry->next;
}//while
}
/* if I am selecetd as MPR by someone,
I_am_MPR_flag turns ON and send TC message every TC_INTERVAL */
if (olsr->I_am_MPR_flag == OLSR_FALSE &&
olsr->adv_neigh_set.head != NULL){
olsr->I_am_MPR_flag = OLSR_TRUE;
}
if(DEBUG_OLSRV2)
{
olsr_printf("\tassn[%d]\n", get_local_assn(olsr));
}
if (change_assn == OLSR_TRUE)
increment_local_assn(olsr);
return OLSR_TRUE;
}
static olsr_bool
tc_change_structure(struct olsrv2 *olsr, struct tc_message *tc_msg,
struct message_header *m, union olsr_ip_addr *source)
{
struct address_tuple *tmp_addr_entry = NULL;
struct tlv_tuple *tlv_entry = NULL;
struct tc_mpr_addr *mpr_entry = NULL;
int i;
ATTACHED_NETWORK *attached_net_entry = NULL;
OLSR_LOCAL_INTERFACE_BLOCK_ENTRY local_iface_entry;
// initialize
memset(tc_msg, 0, sizeof(struct tc_message));
// fill ipv4 header informations
tlv_entry = get_msg_tlv(olsr, Validity_Time);
if(tlv_entry->length == 1)
tc_msg->vtime = me_to_double((olsr_u8_t)tlv_entry->value);
else// greater than 3 byte
tc_msg->vtime = get_validity_time_from_hop(tlv_entry, m->hop_count);
olsr_ip_copy(olsr, &tc_msg->source_addr, source);
olsr_ip_copy(olsr, &tc_msg->originator, &m->orig_addr);
tc_msg->message_seq_number = m->message_seq_num;
tc_msg->hop_count = m->hop_count;
tc_msg->ttl = m->ttl;
if ((tlv_entry = get_msg_tlv(olsr, Content_Sequence_Number)) == NULL){
olsr_error("This Message include no ASSN\n");
}else{//assume that assn is less equal than 4byte
tc_msg->assn = (olsr_u16_t)tlv_entry->value;
}
/*
//codexxx'
tlv_entry = get_msg_tlv(olsr, queuelen);
tc_msg->queuelength = (olsr_u8_t)tlv_entry->value;
//end codexxx'
*/
if(proc_assn_history_set(olsr, &tc_msg->originator, tc_msg->assn)){
free_all_address_entries(olsr);
free_message_tlv(olsr);
olsr_free_tc_packet(tc_msg);
return OLSR_FALSE;
}
//local interface block
OLSR_InitList(&tc_msg->local_iface_list);
tmp_addr_entry = olsr->local_interface_block_entry;
while(tmp_addr_entry) {
olsr_ip_copy(olsr, &local_iface_entry.iface_addr, &tmp_addr_entry->ip_addr);
local_iface_entry.other_if = OLSR_FALSE;
tlv_entry = tmp_addr_entry->addr_tlv;
while(tlv_entry) {
switch(tlv_entry->type){
case Other_If:
if(tlv_entry->value == OLSR_TRUE)
local_iface_entry.other_if = OLSR_TRUE;
break;
default:
break;
}
tlv_entry = tlv_entry->next;
}
OLSR_InsertList(&tc_msg->local_iface_list, &local_iface_entry,
sizeof(OLSR_LOCAL_INTERFACE_BLOCK_ENTRY));
tmp_addr_entry= tmp_addr_entry->next;
}
// all mpr selector : advertized by tc
tc_msg->mpr_selector_address = NULL;
tc_msg->attached_net_addr = NULL;
for (i = 0; i < olsr->num_of_addr_tlv_block_entries; ++i){
tmp_addr_entry = olsr->addr_tlv_block_entries[i];
tlv_entry = NULL;
while (tmp_addr_entry){
//attached network address
if((tlv_entry = have_attached_network_tlv(tmp_addr_entry->addr_tlv)) != NULL)
{
attached_net_entry = (ATTACHED_NETWORK *)olsr_malloc( sizeof(ATTACHED_NETWORK), __FUNCTION__);
memset(attached_net_entry, 0 , sizeof(ATTACHED_NETWORK));
attached_net_entry->next = NULL;
olsr_ip_copy(olsr, &attached_net_entry->network_addr, &tmp_addr_entry->ip_addr);
attached_net_entry->prefix_length = (olsr_u8_t)tlv_entry->value;
//queue
if(tc_msg->attached_net_addr == NULL)
tc_msg->attached_net_addr = attached_net_entry;
else{
attached_net_entry->next = tc_msg->attached_net_addr;
tc_msg->attached_net_addr = attached_net_entry;
}
tmp_addr_entry = tmp_addr_entry->next;
continue;
}
mpr_entry = (struct tc_mpr_addr *)olsr_malloc(sizeof(struct tc_mpr_addr), __FUNCTION__);
memset(mpr_entry, 0, sizeof(struct tc_mpr_addr));
olsr_ip_copy(olsr, &mpr_entry->address, &tmp_addr_entry->ip_addr);
if (tc_msg->mpr_selector_address == NULL){//first
tc_msg->mpr_selector_address = mpr_entry;
mpr_entry->next = NULL;
}else{
mpr_entry->next = tc_msg->mpr_selector_address;
tc_msg->mpr_selector_address = mpr_entry;
}
tmp_addr_entry = tmp_addr_entry->next;
}
}//for
debug_code(print_tc_message(olsr, tc_msg));
//free address tlv & message tlv
free_all_address_entries(olsr);
free_message_tlv(olsr);
return OLSR_TRUE;
}
