int main(int argc, char **argv)
{
/* Se prezinta etapele cronologice ale simularii unei retele de rutere prin
implementarea unui program care va fi capabil sa ruleze un algoritm de rutare SPF
(shortest path first) minimalist si sa se adapteze la schimbarile din retea in cadrul
aceluiasi algoritm si sa ruteze o serie de mesaje date ca input. Se pot adauga sau
sterge legaturi in retea */
int noRouters;
ifstream infile(argv[1]);
infile >> noRouters;
init_api(argc, argv);
init_sim(argc, argv);
loop {
trigger_events();
process_messages(noRouters);
update_routing_table(noRouters);
api_update_state();
if (api_simulation_ended())
break;
}
clean_sim();
clean_api();
return 0;
}
//helper function, since it's called in multiple locations
void update_own_interfaces(interface_t **interfaces) {
dbg(DBG_ROUTE, "route: updating routing table with own interfaces\n");
for (int i=0; interfaces[i]; i++)
{
if (interfaces[i]->sock == -1)
update_routing_table(interfaces[i]->local_virt_ip, ROUTE_INFINITY,
NULL, 0);
else
update_routing_table(interfaces[i]->local_virt_ip, 0, NULL, 0);
}
}
void
update_routing_table_with_new_route(long int *parent, long int *dist,long int source)
{
if ( nlsr->debugging )
printf("update_routing_table_with_new_route called\n");
if ( nlsr->detailed_logging )
writeLogg(__FILE__,__FUNCTION__,__LINE__,"update_routing_table_with_new_route called\n");
int i, map_element;
struct map_entry *me;
struct hashtb_enumerator ee;
struct hashtb_enumerator *e = ⅇ
hashtb_start(nlsr->rev_map, e);
map_element=hashtb_n(nlsr->rev_map);
for(i=0;i<map_element;i++)
{
me=e->data;
if(me->mapping != source)
{
char *orig_router=get_router_from_rev_map(me->mapping);
if (orig_router != NULL )
{
int next_hop_router_num=get_next_hop_from_calculation(parent,me->mapping,source);
if ( next_hop_router_num == NO_NEXT_HOP )
{
if ( nlsr->debugging )
printf ("Orig_router: %s Next Hop Face: %d \n",orig_router,NO_FACE);
if ( nlsr->detailed_logging )
writeLogg(__FILE__,__FUNCTION__,__LINE__,"Orig_router: %s Next Hop Face: %d \n",orig_router,NO_FACE);
}
else
{
char *next_hop_router=get_router_from_rev_map(next_hop_router_num);
int next_hop_face=get_next_hop_face_from_adl(next_hop_router);
update_routing_table(orig_router,next_hop_face,dist[me->mapping]);
if ( nlsr->debugging )
printf ("Orig_router: %s Next Hop Face: %d \n",orig_router,next_hop_face);
if ( nlsr->detailed_logging )
writeLogg(__FILE__,__FUNCTION__,__LINE__,"Orig_router: %s Next Hop Face: %d \n",orig_router,next_hop_face);
}
}
}
hashtb_next(e);
}
hashtb_end(e);
}
static void update_session_state(struct connman_session *session)
{
enum connman_service_state service_state;
enum connman_session_state state = CONNMAN_SESSION_STATE_DISCONNECTED;
if (session->service) {
service_state = __connman_service_get_state(session->service);
state = service_to_session_state(service_state);
session->info->state = state;
}
session->info->state = state;
DBG("session %p state %s", session, state2string(state));
update_routing_table(session);
update_nat_rules(session);
session_notify(session);
}
int main(int argc, char **argv)
{
Network network; // pastreaza informatii despre intreaga retea
init_api(argc, argv);
init_sim(&network, argv);
loop {
trigger_events(&network);
process_messages(&network);
update_routing_table(&network);
api_update_state();
if (api_simulation_ended())
break;
}
clean_sim(&network);
clean_api();
return 0;
}
void
update_routing_table_with_new_hyperbolic_route(long int dest_router_rev_map_index, long int face, double nbr_to_dest_dist)
{
if ( nlsr->debugging )
printf("update_routing_table_with_new_hyperbolic_route called\n");
if ( nlsr->detailed_logging )
writeLogg(__FILE__,__FUNCTION__,__LINE__,"update_routing_table_with_new_hyperbolic_route called\n");
char *orig_router=get_router_from_rev_map(dest_router_rev_map_index);
if (face != NO_NEXT_HOP && face != NO_FACE )
{
update_routing_table(orig_router,face,nbr_to_dest_dist);
if ( nlsr->debugging )
printf ("Orig_router: %s Next Hop Face: %ld \n",orig_router,face);
if ( nlsr->detailed_logging )
writeLogg(__FILE__,__FUNCTION__,__LINE__,"Orig_router: %s Next Hop Face: %ld \n",orig_router,face);
}
}
/**
* Main ICMP buffer handler.
*
* \param buf pointer to buffer
* \return pdTRUE OK
*/
portCHAR icmp_handle( buffer_t *buf )
{
uint8_t *dptr;
control_message_t *ptr;
uint8_t icmp_type=0, icmp_code=0;
#ifdef HAVE_ROUTING
uint8_t i=0;
#endif
debug("ICMP: handler.\r\n");
if(buf->options.type == BUFFER_CONTROL && buf) /* Control message received */
{ /* Control-message */
ptr = ( control_message_t*) buf->buf;
switch(ptr->message.ip_control.message_id)
{
#ifdef HAVE_ROUTING
case BROKEN_LINK:
debug("Control: Broken link mes create & send\r\n");
if(ptr->message.ip_control.message.broken_link_detect.reason == BROKEN_LINK_TYPE)
i = ERROR_CODE_BROKEN_LINK;
if(ptr->message.ip_control.message.broken_link_detect.reason == NO_ROUTE_TO_DESTINATION_TYPE)
i = ERROR_CODE_NO_ROUTE;
memset(buf->buf, 0, 24);
buf->buf_ptr = 0;
buf->buf_end = 24;
dptr = buf->buf;
*dptr++ = ICMP_ERROR_MESSAGE_TYPE;
*dptr++ = i;
dptr += 6;
/* Error packet destination address */
*dptr++ = 0xfe;
*dptr++ = 0x80;
dptr += 6;
if(buf->dst_sa.addr_type == ADDR_802_15_4_PAN_LONG)
{
for(i=0;i<8;i++)
{
*dptr++ = buf->dst_sa.address[7-i];
}
}
else
{
dptr += 3;
*dptr++ = 0xff;
*dptr++ = 0xfe;
dptr += 1;
*dptr++ = buf->dst_sa.address[1];
*dptr++ = buf->dst_sa.address[0];
}
buf->dst_sa.addr_type = buf->src_sa.addr_type;
buf->src_sa.addr_type = ADDR_NONE;
memcpy(buf->dst_sa.address, buf->src_sa.address, 8);
break;
#endif
default:
stack_buffer_free(buf);
buf=0;
break;
}
}
else
{
switch(buf->dir)
{
case BUFFER_DOWN:
stack_buffer_free(buf);
buf=0;
break;
case BUFFER_UP:
debug("IC:UP\r\n");
dptr = (buf->buf + buf->buf_ptr) +2;
icmp_temp_16 = *dptr++;
icmp_temp_16 += ((uint16_t) (*dptr++) << 8);
#ifndef NO_FCS
/* Check FCS first */
if(icmp_temp_16 && (ipv6_fcf(buf, NEXT_HEADER_ICMP6, 1) != 0xffff))
{
debug("ICMP: FCS fail\r\n");
stack_buffer_free(buf);
buf=0;
}
else
#endif
#ifdef HAVE_NRP
{
dptr = (buf->buf + buf->buf_ptr);
icmp_type = *dptr++;
icmp_code = *dptr++;
#ifdef AUTO_GW_RESPONSE
if(buf && icmp_type==ROUTER_SOLICICATION_TYPE)
{
buf->dst_sa.addr_type = buf->src_sa.addr_type;
buf->src_sa.addr_type = ADDR_NONE;
memcpy(buf->dst_sa.address, buf->src_sa.address, 8);
memset(buf->buf, 0, 16);
buf->buf_ptr = 0;
buf->buf_end = 16;
dptr = buf->buf + buf->buf_ptr;
*dptr++ = ROUTER_ADVRT_TYPE;
*dptr++ = ICMP_CODE;
*dptr++ = 0x00;
*dptr++ = 0x00;
*dptr++ = GENERAL_HOPLIMIT;
add_fcf(buf);
stack_buffer_push(buf);
return pdTRUE;
}
else
#endif
{
buf->from = MODULE_ICMP;
buf->to = MODULE_NRP;
stack_buffer_push(buf);
return pdTRUE;
}
}
#else
{
dptr = (buf->buf + buf->buf_ptr);
icmp_type = *dptr++;
icmp_code = *dptr++;
}
if(icmp_type != ICMP_ERROR_MESSAGE_TYPE && icmp_code != 0)
{
stack_buffer_free(buf);
buf=0;
return pdTRUE;
}
if(buf && icmp_type==ECHO_RESPONSE_TYPE)
{
dptr += 4;
buf->buf_ptr = (dptr - buf->buf);
buf->from = MODULE_ICMP;
parse_echo_response(buf);
buf=0;
}
else if(buf && icmp_type==ECHO_REQUEST_TYPE)
{
#ifndef HAVE_NRP
/* Copy source -> Destination field */
buf->dst_sa.addr_type = buf->src_sa.addr_type;
buf->src_sa.addr_type = ADDR_NONE;
memcpy(buf->dst_sa.address, buf->src_sa.address, 8);
dptr = buf->buf + buf->buf_ptr;
*dptr++ = ECHO_RESPONSE_TYPE;
*dptr++ = ICMP_CODE;
*dptr++ = 0x00;
*dptr++ = 0x00;
#else
ptr = ( control_message_t*) buf->buf;
ptr->message.ip_control.message_id = ECHO_REQ;
push_to_app(buf);
buf = 0;
#endif
}
else if(buf && icmp_type==ROUTER_ADVRT_TYPE)
{
//taskENTER_CRITICAL();
//gw_table_update(buf);
//taskEXIT_CRITICAL();
buf->buf_end = 0;
buf->buf_ptr = 0;
ptr = ( control_message_t*) buf->buf;
ptr->message.ip_control.message_id = ROUTER_DISCOVER_RESPONSE;
push_to_app(buf);
buf=0;
}
#ifdef HAVE_ROUTING
else if(buf && icmp_type == ICMP_ERROR_MESSAGE_TYPE)
{
if(icmp_code == ERROR_CODE_BROKEN_LINK || icmp_code == ERROR_CODE_NO_ROUTE)
{
dptr += 6;
for(i=0; i<16; i++)
{
ipv6_address_tmp[i] = *dptr++;
}
if(ipv6_address_tmp[0] == 0xfe && ipv6_address_tmp[1] == 0x80)
{
if((ipv6_address_tmp[12]== 0xfe && ipv6_address_tmp[11] == 0xff) && ipv6_address_tmp[13] == 0x00)
{
buf->dst_sa.addr_type=ADDR_802_15_4_PAN_SHORT;
for(i=0; i<2; i++)
{
buf->dst_sa.address[i] = ipv6_address_tmp[14+i];
}
}
else
{
buf->dst_sa.addr_type=ADDR_802_15_4_PAN_LONG;
for(i=0; i<8; i++)
{
buf->dst_sa.address[7-i] = ipv6_address_tmp[8+i];
}
}
}
memcpy(&(namomesh_info.adr),&(buf->dst_sa), sizeof(sockaddr_t) );
namomesh_info.lqi = 0;
namomesh_info.event = ROUTE_ERR;
update_routing_table(&namomesh_info);
ptr = ( control_message_t*) buf->buf;
ptr->message.ip_control.message_id = BROKEN_LINK;
push_to_app(buf);
//buf = 0;
return pdTRUE;
}
if(buf)
{
stack_buffer_free(buf);
buf=0;
return pdTRUE;
}
}
#endif /*HAVE_ROUTING*/
else if(buf && icmp_type==ROUTER_SOLICICATION_TYPE)
{
if(gateway_features)
{
buf->dst_sa.addr_type = buf->src_sa.addr_type;
buf->src_sa.addr_type = ADDR_NONE;
memcpy(buf->dst_sa.address, buf->src_sa.address, 8);
memset(buf->buf, 0, 16);
buf->buf_ptr = 0;
buf->buf_end = 16;
dptr = buf->buf + buf->buf_ptr;
*dptr++ = ROUTER_ADVRT_TYPE;
*dptr++ = ICMP_CODE;
*dptr++ = 0x00;
*dptr++ = 0x00;
*dptr++ = GENERAL_HOPLIMIT;
}
else
{
stack_buffer_free(buf);
buf=0;
return pdTRUE;
}
}
else
{
stack_buffer_free(buf);
buf=0;
}
#endif /*HAVE_NRP*/
break;
}
}
/* ICMP message build and forward */
if(buf)
{
add_fcf(buf);
stack_buffer_push(buf);
buf=0;
}
return pdTRUE;
}
void rip_handler(interface_t *interface, struct ip *packet)
{
int i;
rip_packet_t *rip_pack;
int triggerUpdate;
if (packet == NULL)
{
dbg(DBG_ROUTE, "rip_handler: received NULL packet");
return;
}
dbg(DBG_ROUTE, "rip_handler: Received packet from %s",
inet_ntoa_host(interface->remote_virt_ip));
dbg(DBG_ROUTE, ", says it's from %s\n", inet_ntoa_host(packet->ip_src));
//ip_packet_print(packet, 1);
//now deal with the packet.
triggerUpdate = 0;
//update the routing table with information directly connecting us to
//this node.
//the packet's source might be wrong, but the interface is always right
pthread_mutex_lock(&g_routeMutex);
if (update_routing_table(interface->remote_virt_ip, 1, interface, 0))
triggerUpdate = 1;
pthread_mutex_unlock(&g_routeMutex);
rip_pack = (rip_packet_t *)(packet + 1); //data starts after the header
rip_packet_ntoh(rip_pack);
if (rip_pack->command == COMMAND_REQUEST)
{
// This is a request, so send back a response
dbg(DBG_ROUTE, "route: Request received from %s.\n",
inet_ntoa_host(packet->ip_src));
announce_routes(interface);
}
else if (rip_pack->command == COMMAND_RESPONSE)
{
uint32_t cost;
struct in_addr address;
// This is a response, parse it and update
dbg(DBG_ROUTE, "route: Response received from %s:\n",
inet_ntoa_host(packet->ip_src));
pthread_mutex_lock(&g_routeMutex);
for (i=0; i < rip_pack->num_entries; i++)
{
cost = rip_pack->entries[i].cost;
address = rip_pack->entries[i].address;
int i;
int ignore=0;
for (i=0; g_interfaces[i]; ++i)
{
if (address.s_addr == g_interfaces[i]->local_virt_ip.s_addr)
{
dbg(DBG_ROUTE, " Ignoring an entry about ourselves.\n");
ignore=1;
break;
}
}
if (ignore) continue;
dbg(DBG_ROUTE, " Cost: %d. Address: %s, ", cost, inet_ntoa_host(address));
//update the routing table
//dbg(DBG_ROUTE, " ");
if (update_routing_table(address, cost+1, interface, 1))
triggerUpdate = 1;
}
pthread_mutex_unlock(&g_routeMutex);
}
else
{
dbg(DBG_ROUTE, "handleRequests: unknown RIP packet command from %s: %d\n",
inet_ntoa_host(packet->ip_src), rip_pack->command);
}
if (triggerUpdate)
trigger_update();
}
