void insert_mprN2(OLSR_LIST *list, union olsr_ip_addr *addr)
{
OLSR_MPR_N2_TUPLE data;
data.addr = *addr;
OLSR_InsertList(list, &data, sizeof(OLSR_MPR_N2_TUPLE));
}
static void
set_forward_infomation(struct olsrv2 *olsr,
olsr_u8_t *msg,
olsr_u32_t msg_size,
unsigned char index)
{
OLSR_InsertList(&olsr->forward_info[index].msg_list, msg, msg_size);
}
void insert_relay_set(struct olsrv2 *olsr,
union olsr_ip_addr *neighbor_iface_addr)
{
OLSR_RELAY_TUPLE data;
//Fix for Solaris
//data.RS_if_addr = *neighbor_iface_addr;
olsr_ip_copy(olsr, &data.RS_if_addr, neighbor_iface_addr);
OLSR_InsertList(&olsr->relay_set, &data, sizeof(OLSR_RELAY_TUPLE));
}
void insert_routing_set(struct olsrv2 *olsr,
union olsr_ip_addr *dest_iface_addr,
const union olsr_ip_addr *next_iface_addr,
olsr_u8_t prefix_length,
olsr_u16_t dist,
const union olsr_ip_addr *iface_addr)
{
OLSR_ROUTING_TUPLE data;
//Multi path check
if (OLSR_TRUE)
{
if (search_routing_set_for_dest_exist(olsr, dest_iface_addr) == OLSR_TRUE ||//yowada add
match_local_iface_addr(olsr, dest_iface_addr) == OLSR_TRUE)
{
if (DEBUG_OLSRV2)
{
char* paddr = olsr_niigata_ip_to_string(olsr, dest_iface_addr);
olsr_printf("Route %s has already exist! hopcount = %d\n",paddr,dist);
free(paddr);
}
return;
//olsr_error("Multi path!!\n");
}
}
//Fix for Solaris
//data.R_dest_iface_addr = *dest_iface_addr;
//data.R_next_iface_addr = *next_iface_addr;
olsr_ip_copy(olsr, &data.R_dest_iface_addr, dest_iface_addr);
olsr_ip_copy(olsr, &data.R_next_iface_addr, next_iface_addr);
data.R_prefix_length = prefix_length;
data.R_dist = dist;
//data.R_iface_addr = *iface_addr;
olsr_ip_copy(olsr, &data.R_iface_addr, iface_addr);
/*
assert(equal_ip_addr(olsr_cnf->ip_version,
data.R_dest_iface_addr,
data.R_iface_addr) == OLSR_FALSE);
*/
if (equal_ip_addr(olsr,
&data.R_dest_iface_addr,
&data.R_iface_addr))
{
return;
}
OLSR_InsertList(&olsr->routing_set[olsr_hashing(olsr,&data.R_dest_iface_addr)].list,
&data, sizeof(OLSR_ROUTING_TUPLE));
/* OLSR_InsertList_Sort(&olsr->routing_set, */
/* &data, */
/* sizeof(OLSR_ROUTING_TUPLE), */
/* sort_routing_set_handler); */
}
void insert_mpr_set_per_interface(OLSR_LIST *list,
union olsr_ip_addr *local_iface_addr,
union olsr_ip_addr *MPR_if_addr)
{
OLSR_MPR_TUPLE data;
data.local_iface_addr = *local_iface_addr;
data.MPR_if_addr = *MPR_if_addr;
OLSR_InsertList(list, &data, sizeof(OLSR_MPR_TUPLE));
}
void insert_mprN(OLSR_LIST *list,
union olsr_ip_addr *addr,
olsr_u32_t D,
olsr_u32_t reachability,
olsr_u8_t willingness)
{
OLSR_MPR_N_TUPLE data;
data.addr = *addr;
data.D = D;
data.reachability = reachability;
data.willingness = willingness;
OLSR_InsertList(list, &data, sizeof(OLSR_MPR_N_TUPLE));
}
void insert_proc_set(struct olsrv2 *olsr,
union olsr_ip_addr orig_addr,
olsr_u16_t seq_number,
olsr_u8_t type)
{
OLSR_PROC_TUPLE data;
data.P_type = type;
data.P_addr = orig_addr;
data.P_seq_number = seq_number;
get_current_time(olsr, &data.P_time);
update_time(&data.P_time,(olsr_32_t)olsr->qual_cnf->duplicate_hold_time);
//struct olsrv2
OLSR_InsertList(&olsr->proc_set[olsr_hashing(olsr,&orig_addr)].list, &data, sizeof(OLSR_PROC_TUPLE));
}
void insert_topology_set(struct olsrv2 *olsr,
const union olsr_ip_addr *adv_neighbor_addr,
union olsr_ip_addr *orig_addr,
olsr_u16_t ASSN)
{
OLSR_TOPOLOGY_TUPLE data;
//Fix for Solaris
//data.T_dest_iface_addr = *adv_neighbor_addr;
//data.T_last_iface_addr = *orig_addr;
olsr_ip_copy(olsr, &data.T_dest_iface_addr, adv_neighbor_addr);
olsr_ip_copy(olsr, &data.T_last_iface_addr, orig_addr);
data.T_seq = ASSN;
get_current_time(olsr, &data.T_time);
update_time(&data.T_time,(olsr_32_t)olsr->qual_cnf->topology_hold_time);
OLSR_InsertList(&olsr->topology_set[olsr_hashing(olsr,orig_addr)].list,
&data,
sizeof(OLSR_TOPOLOGY_TUPLE));
}
void insert_routing_set_old(struct olsrv2 *olsr,
const union olsr_ip_addr *dest_iface_addr,
const union olsr_ip_addr *next_iface_addr,
olsr_u8_t prefix_length,
olsr_u16_t dist,
const union olsr_ip_addr *iface_addr)
{
OLSR_ROUTING_TUPLE data;
//Fix for Solaris
//data.R_dest_iface_addr = *dest_iface_addr;
//data.R_next_iface_addr = *next_iface_addr;
olsr_ip_copy(olsr, &data.R_dest_iface_addr, dest_iface_addr);
olsr_ip_copy(olsr, &data.R_next_iface_addr, next_iface_addr);
data.R_prefix_length = prefix_length;
data.R_dist = dist;
//data.R_iface_addr = *iface_addr;
olsr_ip_copy(olsr, &data.R_iface_addr, iface_addr);
OLSR_InsertList(&olsr->routing_set_old[olsr_hashing(olsr,&data.R_dest_iface_addr)].list,
&data, sizeof(OLSR_ROUTING_TUPLE));
}
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;
}
}
static olsr_bool
hello_change_structure(struct olsrv2 *olsr, struct hello_message *h_msg,
struct message_header *m)
{
struct address_tuple *tmp_addr_entry = NULL;
struct tlv_tuple *tlv_entry = NULL;
struct hello_neighbor *neigh = NULL;
olsr_u8_t link_status_count;
olsr_u8_t mpr_selection_count;
olsr_u8_t other_neigh_count;
//olsr_bool link_status_flag;
//olsr_bool mpr_selection_flag;
//olsr_bool other_neigh_flag;
olsr_bool add_neigh;
OLSR_LOCAL_INTERFACE_BLOCK_ENTRY local_iface_entry;
//MEMSET added for Linux
memset(&local_iface_entry, 0, sizeof(OLSR_LOCAL_INTERFACE_BLOCK_ENTRY));
int i;
//initialize
memset(h_msg, 0, sizeof(struct hello_message));
//wiss: fill validity from message tlv
tlv_entry = get_msg_tlv(olsr, Validity_Time); // byetle3 3enna men el olsr el TLV_entry yalli 3endou tlv_type "Validity_Time"
if(tlv_entry->length == 1)
h_msg->vtime = me_to_double((olsr_u8_t)tlv_entry->value);
else// greater than 3 byte
h_msg->vtime = get_validity_time_from_hop(tlv_entry, m->hop_count);
h_msg->htime = (double)h_msg->vtime/3; //wiss: ma fhemet chou hiye el htime
//olsr_ip_copy(&h_msg->source_addr, &m->orig_addr);
tmp_addr_entry = olsr->local_interface_block_entry;
olsr_ip_copy(olsr, &h_msg->source_addr, &tmp_addr_entry->ip_addr);
olsr_ip_copy(olsr, &h_msg->orig_addr, &m->orig_addr);
//olsr_printf("Source = %s\n", IP_TO_STRING(&h_msg->source_addr));
h_msg->hop_count = m->hop_count;
h_msg->ttl = m->ttl;
h_msg->message_seq_number = m->message_seq_num;
// fill willingness from message tlv
if((tlv_entry = get_msg_tlv(olsr, Willingness)) == NULL){
// default //wiss: ya3ni hon ma la2a TLV willingness donc will_default
h_msg->willingness = WILL_DEFAULT;
}else{
// assume that willingness is less equal than 4byte
h_msg->willingness = (olsr_u8_t)tlv_entry->value;
}
//codexxx
tlv_entry = get_msg_tlv(olsr, queuelen);
h_msg->queuelength = (olsr_u8_t)tlv_entry->value;
//end codexxx
//local interface block
OLSR_InitList(&h_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:
local_iface_entry.other_if = (olsr_u8_t)tlv_entry->value;
break;
default:
break;
}
tlv_entry = tlv_entry->next;
} // wiss: set local_iface_entry.other_if
OLSR_InsertList(&h_msg->local_iface_list, &local_iface_entry,
sizeof(OLSR_LOCAL_INTERFACE_BLOCK_ENTRY));
tmp_addr_entry= tmp_addr_entry->next;
}
// wiss : lahon biikoun tmalla el hello message "h_msg" bi kell el ma3loumet el lezme ella el champs "neighbors"
//test
/* olsr_ip_copy(&local_iface_entry.iface_addr, &olsr->local_interface_block_entry->ip_addr); */
/* local_iface_entry.iface_addr.v4 += 1; */
/* local_iface_entry.other_if = OLSR_FALSE; */
/* OLSR_InsertList(&h_msg->local_iface_list, &local_iface_entry, */
/* sizeof(OLSR_LOCAL_INTERFACE_BLOCK_ENTRY)); */
/* olsr_ip_copy(&local_iface_entry.iface_addr, &olsr->local_interface_block_entry->ip_addr); */
/* local_iface_entry.iface_addr.v4 += 2; */
/* local_iface_entry.other_if = OLSR_FALSE; */
/* OLSR_InsertList(&h_msg->local_iface_list, &local_iface_entry, */
/* sizeof(OLSR_LOCAL_INTERFACE_BLOCK_ENTRY)); */
// all neighbor :advertized by hello
h_msg->neighbors = NULL;
for (i = 0; i < olsr->num_of_addr_tlv_block_entries; ++i){
tmp_addr_entry = olsr->addr_tlv_block_entries[i];
while (tmp_addr_entry)
{
neigh = (struct hello_neighbor *)olsr_malloc(sizeof(struct hello_neighbor), __FUNCTION__);
memset(neigh, 0, sizeof(struct hello_neighbor));
add_neigh = OLSR_TRUE;
tlv_entry = tmp_addr_entry->addr_tlv;
link_status_count = mpr_selection_count = other_neigh_count = 0;
//link_status_flag = mpr_selection_flag = other_neigh_flag = OLSR_FALSE;
neigh->is_mpr = OLSR_FALSE;
neigh->status = 255;
neigh->other_neigh = 255;
while (tlv_entry){
switch (tlv_entry->type)
{
case Link_Status:
link_status_count++;
//link_status_flag = OLSR_TRUE;
//assume that link status is less equal than 4byte
neigh->status = (olsr_u8_t)tlv_entry->value;
break;
case MPR_Selection:
mpr_selection_count++;
//assume that mpr selection is less equal than 4byte
neigh->is_mpr = OLSR_TRUE;
break;
case Other_Neigh:
other_neigh_count ++;
//other_neigh_flag = OLSR_TRUE;
neigh->other_neigh = OLSR_TRUE;
break;
default:
//default ignore
break;
}
tlv_entry = tlv_entry->next;
}
// wiss: la hon menkoun 3abayna el fields taba3 el neigh ella el IP address
if (link_status_count > 1 || other_neigh_count > 1 || mpr_selection_count > 1)
{
if(DEBUG_OLSRV2)
{
char* paddr = olsr_niigata_ip_to_string(olsr, &neigh->address);
olsr_printf("This Neighbor %s have over 2 same tlv type\n",paddr);
free(paddr);
}
add_neigh = OLSR_FALSE; // wiss: bima ennu 3endou aktar men 2 same TLV men7ot add_neigh= false
}
if (olsr->olsr_cnf->ip_version == AF_INET){
//check inconsistency
if (neigh->is_mpr == OLSR_TRUE && neigh->status != SYMMETRIC)
{
if(DEBUG_OLSRV2)
{
olsr_printf("MPR have non symmetric link\n");
}
free(neigh);
tmp_addr_entry = tmp_addr_entry->next;
continue;
/*
free_all_address_entries(olsr);
free_message_tlv(olsr);
return OLSR_FALSE;
*/
}
// if (neigh->transmitting_iface == Other && neigh->status != SYMMETRIC)
// {
// if (DEBUG_OLSRV2){
// olsr_printf("Other Interface have non symmetric link\n");
// }
// free_all_address_entries(olsr);
// free_message_tlv(olsr);
// free(neigh);
// return OLSR_FALSE;
// }
}
//add neighbor to hello_message
if (add_neigh == OLSR_TRUE){ // wiss: bikoun true iza linkstatus count aw mpr count aw ...count <=1
//copy neigh
olsr_ip_copy(olsr, &neigh->address, &tmp_addr_entry->ip_addr);
//queue
if (h_msg->neighbors == NULL)
{
neigh->next = NULL;
h_msg->neighbors = neigh;
}
else
{
neigh->next = h_msg->neighbors;
h_msg->neighbors = neigh;
}
}else{// add_neigh == FALSE
//skip this neighbor
if(DEBUG_OLSRV2)
{
olsr_printf("Neighbor %s don't add neigh list\n");
}
free(neigh);
}
//next address advertized by hello
tmp_addr_entry = tmp_addr_entry->next;
}
}//for
if(DEBUG_OLSRV2)
{
print_hello_message(olsr, h_msg);
}
// free address tlv & message tlv
free_all_address_entries(olsr);
free_message_tlv(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;
}
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 void create_prefix_tlv_by_list(void *olsr, OLSR_LIST *tlv_block,
OLSR_LIST *block){
OLSR_LIST_ENTRY *entry = NULL;
BLOCK_DATA *data = NULL, *next_data = NULL;
BASE_TLV base_tlv;
olsr_u8_t semantics, index_start, index_stop, tlv_value;
olsr_u32_t index = 0;
olsr_bool set_index_start;
index_start = index_stop = semantics = tlv_value = 0;
set_index_start = OLSR_FALSE;
entry = block->head;
while(entry){
data = (BLOCK_DATA *)entry->data;
if(data->Prefix_Length != 255){
//check index_start set or not
if(set_index_start == OLSR_FALSE){
tlv_value = data->Prefix_Length;
index_start = (olsr_u8_t)index;
set_index_start = OLSR_TRUE;
}
index_stop = (olsr_u8_t)index;
if(index == block->numEntry -1){
//set semantics
if(index_start == 0)
semantics = NO_INDEX;
else if(index_start == index_stop)
semantics = SINGLE_INDEX;
}else{ // case index < block->numEntry -1
next_data = (BLOCK_DATA *)entry->next->data;
if(next_data->Prefix_Length == 255 || next_data->link_status != tlv_value){
//set semantics
if(index_start == index_stop)
semantics = SINGLE_INDEX;
}else{ //next entry
index++;
entry = entry->next;
continue;
}
}//if (index ==..) else if(...) & else not reachable
//set all val
base_tlv.tlv_type = PREFIX_LENGTH;
base_tlv.tlv_semantics = semantics;
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);
//inset base_tlv
OLSR_InsertList( tlv_block, &base_tlv, sizeof(BASE_TLV));
set_index_start = OLSR_FALSE;
semantics = 0;
}
index++;
entry = entry->next;
}//while
}
static void create_other_if_tlv_by_list(void *olsr, OLSR_LIST *tlv_block,
OLSR_LIST *block){
OLSR_LIST_ENTRY *entry = NULL;
BLOCK_DATA *data = NULL, *next_data = NULL;
BASE_TLV base_tlv;
olsr_u8_t semantics, index_start, index_stop, tlv_value;
olsr_u32_t index = 0;
olsr_bool set_index_start;
index_start = index_stop = semantics = 0;
set_index_start = OLSR_FALSE;
entry = block->head;
while(entry){
data = (BLOCK_DATA *)entry->data;
if(data->other_if == OLSR_TRUE){
//check index_start set or not
if(set_index_start == OLSR_FALSE){
tlv_value = data->other_if;
index_start = (olsr_u8_t)index;
set_index_start = OLSR_TRUE;
}
index_stop = (olsr_u8_t)index;
if(index == block->numEntry -1){
//set semantics
if(index_start == 0)
semantics = NO_INDEX | NO_VALUE;
else if(index_start == index_stop)
semantics = SINGLE_INDEX | NO_VALUE;
else
semantics = NO_VALUE;
}else{ // case index < block->numEntry -1
next_data = (BLOCK_DATA *)entry->next->data;
if(next_data->other_if != OLSR_TRUE){
//set semantics
if(index_start == index_stop)
semantics = SINGLE_INDEX | NO_VALUE;
else
semantics = NO_VALUE;
}else{ //next entry
index++;
entry = entry->next;
continue;
}
}//if (index ==..) else if(...) & else not reachable
//set all val
base_tlv.tlv_type = Other_If;
base_tlv.tlv_semantics = semantics;
base_tlv.tlv_length = 0;
base_tlv.index_start = index_start;
base_tlv.index_stop = index_stop;
base_tlv.value = NULL;
//inset base_tlv
OLSR_InsertList( tlv_block, &base_tlv, sizeof(BASE_TLV));
set_index_start = OLSR_FALSE;
semantics = 0;
}
index++;
entry = entry->next;
}//while
}
static void create_linkstatus_tlv_by_list(void *olsr, OLSR_LIST *tlv_block,
OLSR_LIST *block){
OLSR_LIST_ENTRY *entry = NULL;
BLOCK_DATA *data = NULL, *next_data = NULL;
BASE_TLV base_tlv;
olsr_u8_t semantics, index_start, index_stop, tlv_value;
olsr_u32_t index = 0;
olsr_bool set_index_start;
index_start = index_stop = semantics = tlv_value = 0;
set_index_start = OLSR_FALSE;
entry = block->head;
while(entry){
data = (BLOCK_DATA *)entry->data; // wiss: kell el ma3loumet ip w link status...covered w hel esas
if(data->link_status != 255){ // wiss: 255 hiye el valeur maximal bass ma ba3ref chou bye2sod fiya betsawar hayda jar mech jar el jar
//check index_start set or not
if(set_index_start == OLSR_FALSE){ //A wiss: bi fout hon bass awal marra!!
tlv_value = data->link_status;
index_start = (olsr_u8_t)index;
set_index_start = OLSR_TRUE;
}//A
index_stop = (olsr_u8_t)index;
if(index == block->numEntry -1){
//set semantics // wiss: wasal 3al niheye
if(index_start == 0)
semantics = NO_INDEX;
else if(index_start == index_stop)
semantics = SINGLE_INDEX;
}else{ //B case index < block->numEntry -1
next_data = (BLOCK_DATA *)entry->next->data;
if(next_data->link_status == 255 || next_data->link_status != tlv_value){
//set semantics // wiss: betsawar hayda jar el jar aw tghayar el link status ben entry weli ba3da
if(index_start == index_stop)
semantics = SINGLE_INDEX;
}else{ //next entry
index++;
entry = entry->next;
continue;
}
}//B if (index ==..) & else if(...) & else not reachable
//set all val
base_tlv.tlv_type = Link_Status;
base_tlv.tlv_semantics = semantics;
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);
//inset base_tlv
OLSR_InsertList( tlv_block, &base_tlv, sizeof(BASE_TLV));
set_index_start = OLSR_FALSE;
semantics = 0;
}
index++;
entry = entry->next;
}//while
// wiss: hon bel niheye betkoun tkawanet 3enna list bel data 3enna ma3loumet 3an el TLV taba3 kell addresset yalli bel list "block"
// wiss: w iza el adresset yalli wara ba3don 3endon kellon LINK_STATUS nafs el chi men7ot index start w index end
//wiss: wel semantics bi 3aber 3an 3adad el @ yalli metel ba3don wara ba3don...
}
//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);
}
