sr_pwospf_types.c

#include "sr_pwospf_types.h"
#include "cli/helper.h"
#include "sr_neighbor.h"
#include "sr_base_internal.h"
#include "sr_integration.h"
#include "lwtcp/lwip/inet.h"
#include "sr_ip.h"
#include "sr_neighbor_db.h"
#include "sr_dijkstra.h"
#include "sr_reroute_multipath.h"

#include <string.h>
#include <stdlib.h>

void pwospf_hello_type(struct ip* ip_header, byte* payload, uint16_t payload_len, pwospf_header_t* pwospf_header, interface_t* intf) {
   printf(" ** pwospf_hello_type(..) called \n");
   printf(" ** pwospf_hello_type(..) packet with length: %u \n", payload_len);
   // make hello packet
   pwospf_hello_packet_t* hello_packet = (pwospf_hello_packet_t*) malloc_or_die(sizeof(pwospf_hello_packet_t));
   memcpy(&hello_packet->network_mask, payload, 4);
   memcpy(&hello_packet->helloint, payload + 4, 2);
   memcpy(&hello_packet->padding, payload + 6, 2);
   // display packet
   printf(" ** pwospf_hello_type(..) displayed header contents:\n");
   display_hello_packet(hello_packet);
   // check mask and hello interval
   if(intf->subnet_mask == hello_packet->network_mask && intf->helloint == ntohs(hello_packet->helloint)) {
      printf(" ** pwospf_hello_type(..) network mask and hello interval correct\n");
      // if the interface has no neighbors
      if(intf->neighbor_list == NULL) {
         printf(" ** pwospf_hello_type(..) interface has no neighbors, adding new neighbor\n");
         add_neighbor(intf, pwospf_header->router_id, ip_header->ip_src.s_addr, hello_packet->helloint, hello_packet->network_mask);
      } else { // interface has existing neighbors
         // generate neighbor object
         neighbor_t* neighbor = make_neighbor(pwospf_header->router_id, ip_header->ip_src.s_addr, hello_packet->helloint, hello_packet->network_mask);
         // get last instance so that lsu info can be put back
         pthread_mutex_lock(&intf->neighbor_lock);
         node* ret = llist_find( intf->neighbor_list, predicate_id_neighbor_t,(void*) &pwospf_header->router_id);
         pthread_mutex_unlock(&intf->neighbor_lock);
         if( ret!= NULL) {
            neighbor_t *neighbor_ret = (neighbor_t*) ret->data;
            neighbor->last_adverts = neighbor_ret->last_adverts;
            neighbor->last_lsu_packet = neighbor_ret->last_lsu_packet;
         }
         // lock neighbor list
         pthread_mutex_lock(&intf->neighbor_lock);
         // if exists, then update, otherwise add
         intf->neighbor_list = llist_update_beginning_delete(intf->neighbor_list, predicate_neighbor_t, (void*) neighbor);
         pthread_mutex_unlock(&intf->neighbor_lock);
      }
      // update info in neighbor db
      // get instance of router 
      struct sr_instance* sr_inst = get_sr();
      struct sr_router* router = (struct sr_router*)sr_get_subsystem(sr_inst);
      update_neighbor_vertex_t_rid(router, ip_header->ip_src.s_addr, pwospf_header->router_id);
   } else {
      printf(" ** pwospf_hello_type(..) network mask or hello interval incorrect\n");
   }
}

void pwospf_lsu_type(struct ip* ip_header, byte* payload, uint16_t payload_len, pwospf_header_t* pwospf_header, interface_t* intf) {
   printf(" ** pwospf_lsu_type(..) called \n");
   printf(" ** pwospf_lsu_type(..) packet with length: %u \n", payload_len);
   struct sr_instance* sr_inst = get_sr();
   struct sr_router* router = (struct sr_router*)sr_get_subsystem(sr_inst);
   // make lsu packet
   pwospf_lsu_packet_t* lsu_packet = (pwospf_lsu_packet_t*) malloc_or_die(sizeof(pwospf_lsu_packet_t));
   memcpy(&lsu_packet->seq, payload, 2);
   memcpy(&lsu_packet->ttl, payload + 2, 2);
   memcpy(&lsu_packet->no_of_adverts, payload + 4, 4);
   // display packet
   printf(" ** pwospf_lsu_type(..) displayed header contents:\n");
   display_lsu_packet(lsu_packet);
   // calculate number of adverts
   int num_adverts = ((payload_len - 8)/sizeof(pwospf_ls_advert_t));
   printf(" ** pwospf_lsu_type(..) number of adverts: %d\n", num_adverts);
   // check if I generated the LSU
   if(pwospf_header->router_id != intf->router_id) {
      // not generated by self
      // check if neighbor ever sent hello packet
       pthread_mutex_lock(&intf->neighbor_lock);
       node* ret = llist_find( intf->neighbor_list, predicate_id_neighbor_t,(void*) &pwospf_header->router_id);
       pthread_mutex_unlock(&intf->neighbor_lock);
       if(ret != NULL) {
       // have received a hello packet from this neighbor in the recent past
          neighbor_t *neighbor = (neighbor_t*) ret->data;
          display_neighbor_t((void*) neighbor);
          // check if lsu received for first time
          if(neighbor->last_adverts == NULL) {
             printf(" ** pwospf_lsu_type(..) first lsu received from this neighbor\n");
             neighbor->last_lsu_packet = *lsu_packet;
             neighbor->last_adverts = (byte*) malloc_or_die(payload_len - 8);
             memcpy(neighbor->last_adverts, payload + 8, payload_len - 8);
             // add to list
             pthread_mutex_lock(&intf->neighbor_lock);  
             intf->neighbor_list = llist_update_beginning_delete(intf->neighbor_list, predicate_id_neighbor_t_neighbor_t, (void*) neighbor);
             pthread_mutex_unlock(&intf->neighbor_lock);
             display_neighbor_t((void*) neighbor);
             // create router entry
             router_entry_t router_entry;
             router_entry.router_id = neighbor->id;
             router_entry.area_id = 0;
             //add vertex with router entry info
             add_neighbor_vertex_t(router, router_entry);
             //create subnet entry
             subnet_entry_t* subnet_entry;
             //add adverts to db
             printf(" ** pwospf_lsu_type(..) adding adverts to neighbor db\n");
             int i;
             pwospf_ls_advert_t* ls_advert = (pwospf_ls_advert_t*) malloc_or_die(sizeof(pwospf_ls_advert_t));
             for(i = 0; i < ntohl(lsu_packet->no_of_adverts) ; i++) {
                memcpy(&ls_advert->subnet, payload + sizeof(pwospf_lsu_packet_t) + sizeof(pwospf_ls_advert_t) * i, 4);         
                memcpy(&ls_advert->mask, payload + sizeof(pwospf_lsu_packet_t) + 4 + sizeof(pwospf_ls_advert_t) * i, 4);
                memcpy(&ls_advert->router_id, payload + sizeof(pwospf_lsu_packet_t) + 8 + sizeof(pwospf_ls_advert_t) * i, 4);
                display_ls_advert(ls_advert);
                subnet_entry = create_subnet_entry_t_advert(ls_advert);
                add_subnet_entry_t(router, router_entry, subnet_entry);
             }
             // update vertices
             update_neighbor_vertex_t(router, router_entry);
             //calculate new routing table via Dijkstra
             calculate_routing_table(router);
             //check if route/multipath is enabled
             if(router->reroute_multipath_status == TRUE) {
                //run multipath
                reroute_multipath(router);
             }
             //dijkstra2(router); 
             //free(lsu_packet);
             //free(ret);
             //free(neighbor);
             //free(ls_advert);
          } else {
          // check if the previous seq was same
          if(neighbor->last_lsu_packet.seq != lsu_packet->seq) {
             // nope, new seq
             neighbor->last_lsu_packet = *lsu_packet;
             // flood to all neighbors
             pwospf_flood_lsu(ip_header, pwospf_header, lsu_packet, neighbor, intf);
             // check if content the same
             printf("last adverts :%s\n",  (char*) neighbor->last_adverts);
             printf("new: %s\n", (char*) (payload + 8));
             if(memcmp(neighbor->last_adverts, payload + 8, payload_len - 8) != 0) {
                // nope new content
                printf(" ** pwospf_lsu_type(..) new content neighbor db\n");
                if(ntohl(neighbor->last_lsu_packet.no_of_adverts) != ntohl(lsu_packet->no_of_adverts)) {
                   // free mem, as new adverts might need different memory
                   free(neighbor->last_adverts);
                   // now allocate new mem space
                   neighbor->last_adverts = (byte*) malloc_or_die(payload_len - 8);
                }
                memcpy(neighbor->last_adverts, payload + 8, payload_len - 8);
                neighbor->last_lsu_packet = *lsu_packet;
                // update packet info in neighbor list
                pthread_mutex_lock(&intf->neighbor_lock);
                intf->neighbor_list = llist_update_beginning_delete(intf->neighbor_list, predicate_id_neighbor_t_neighbor_t, (void*) neighbor);
                pthread_mutex_unlock(&intf->neighbor_lock);
                // check if entry exists in DB
                // create router entry
                router_entry_t router_entry;
                router_entry.router_id = neighbor->id;
                router_entry.area_id = 0;
                //refresh vertex with router entry info, clear previous subnets
                refresh_neighbor_vertex_t(router, router_entry);
               //create subnet entry
                subnet_entry_t* subnet_entry;

             	int i;
             	pwospf_ls_advert_t* ls_advert = (pwospf_ls_advert_t*) malloc_or_die(sizeof(pwospf_ls_advert_t));
             	if(check_neighbor_vertex_t_router_entry_t_id(router, neighbor->id) == 1) {
                   printf(" ** pwospf_lsu_type(..) neighbor already known, checking if any new adverts\n");
                   //neighbor present in db, check if any new adverts
                   for(i = 0; i < ntohl(lsu_packet->no_of_adverts) ; i++) {
                      memcpy(&ls_advert->subnet, payload + sizeof(pwospf_lsu_packet_t) + sizeof(pwospf_ls_advert_t) * i, 4);
                      memcpy(&ls_advert->mask, payload + sizeof(pwospf_lsu_packet_t) + 4
 + sizeof(pwospf_ls_advert_t) * i, 4);
                      memcpy(&ls_advert->router_id, payload + sizeof(pwospf_lsu_packet_t) + 8 + sizeof(pwospf_ls_advert_t) * i, 4);
                         display_ls_advert(ls_advert);
                         subnet_entry = create_subnet_entry_t_advert(ls_advert);
                	 add_subnet_entry_t(router, router_entry, subnet_entry);
                   }    
                   // update vertices
             	   update_neighbor_vertex_t(router, router_entry);
                } 
                  //run Djikstra's algo to calculate new routing table
                  calculate_routing_table(router);
                  //check if route/multipath is enabled
                  if(router->reroute_multipath_status == TRUE) {
                     //run multipath
                     reroute_multipath(router);
                  }
                  //dijkstra2(router);
                } else {
                     printf(" ** pwospf_lsu_type(..) error, content same as previous from this neighbor, only updating time stamp in DB\n");  
                     // update timestamp
                     // create router entry
	             router_entry_t router_entry;
                     router_entry.router_id = neighbor->id;
                     router_entry.area_id = 0;
                     update_neighbor_vertex_t_timestamp(router, router_entry);

             }
          } else {
              printf(" ** pwospf_lsu_type(..) error, seq same as previous one from this neighbor, dropping\n");
          }
       }
       } else {
          printf(" ** pwospf_lsu_type(..) error, neighbor hasn't said hello recently, dropping\n");
       }
   } else {
      //drop packet
      printf(" ** pwospf_lsu_type(..) error, LSU generated by self. dropping\n");
      //free stuff
     free(lsu_packet);
   } 
}

void display_hello_packet(pwospf_hello_packet_t* packet) {
   printf(" ** network mask: %lu, hello interval: %u, padding: %u\n", packet->network_mask, ntohs(packet->helloint), packet->padding);
}

void display_lsu_packet(pwospf_lsu_packet_t* packet) {
   printf(" ** seq: %d, ttl: %u, no. of adverts: %d\n", ntohs(packet->seq), ntohs(packet->ttl), ntohl(packet->no_of_adverts));
}

void pwospf_send_lsu() {
    printf(" ** pwospf_send_lsu(..) called\n");
    // get instance of router 
    struct sr_instance* sr_inst = get_sr();
    struct sr_router* router = (struct sr_router*)sr_get_subsystem(sr_inst);    
    int num_adverts = 0;
    byte* ls_adverts = get_ls_adverts_src(router, &num_adverts);
    int i = 0;
    node* first = NULL;
    neighbor_t* neighbor = NULL;
    printf(" ** pwospf_send_lsu(..) number of adverts: %d\n", num_adverts);
    printf(" ** pwospf_send_lsu(..) adverts:\n");
    display_neighbor_vertices_src(router);
    // now create lsu_packet
    pwospf_lsu_packet_t *lsu_packet = (pwospf_lsu_packet_t*) malloc_or_die(sizeof(pwospf_lsu_packet_t));
    //increment lsu sequence
    router->ls_info.lsu_seq = router->ls_info.lsu_seq + 1;
    lsu_packet->seq = htons(router->ls_info.lsu_seq);
    uint16_t ttl = PWOSPF_LSU_TTL;
    lsu_packet->ttl = htons(ttl);
    lsu_packet->no_of_adverts = htonl(num_adverts);
    // calculate length of entire pwospf packet
    uint16_t pwospf_packet_len = sizeof(pwospf_lsu_packet_t) + sizeof(pwospf_header_t) + sizeof(pwospf_ls_advert_t) * num_adverts;
    //make pwospf header
    pwospf_header_t* pwospf_header = (pwospf_header_t*) malloc_or_die(sizeof(pwospf_header_t));
    pwospf_header->version = PWOSPF_VER;
    pwospf_header->type = PWOSPF_TYPE_LSU;
    pwospf_header->len = htons(pwospf_packet_len);
    pwospf_header->router_id = router->ls_info.router_id;
    pwospf_header->area_id = router->ls_info.area_id;
    pwospf_header->checksum = 0;
    pwospf_header->au_type = PWOSPF_AU_TYPE;
    pwospf_header->authentication = PWOSPF_AUTHEN;
    // generate raw packet 
    byte* pwospf_packet = (byte*) malloc_or_die(pwospf_packet_len);
    memcpy(pwospf_packet, pwospf_header, sizeof(pwospf_header_t));
    memcpy(pwospf_packet + sizeof(pwospf_header_t), lsu_packet, sizeof(pwospf_lsu_packet_t));
    memcpy(pwospf_packet + sizeof(pwospf_header_t) + sizeof(pwospf_lsu_packet_t), ls_adverts, sizeof(pwospf_ls_advert_t) * num_adverts);
    // generate checksum
    pwospf_header->checksum = htons(htons(inet_chksum((void*) pwospf_packet, pwospf_packet_len)));
    memcpy(pwospf_packet, pwospf_header, sizeof(pwospf_header_t));
    free(ls_adverts);
    free(lsu_packet);
    free(pwospf_header);
    printf(" ** pwospf_send_lsu(..) pwospf packet with length %u generated\n", pwospf_packet_len);
    // now iterate through each interface
    for( i = 0; i < router->num_interfaces ; i++) {
       // now iterate this interface's neighbors list
       first = router->interface[i].neighbor_list;
       pthread_mutex_lock(&router->interface[i].neighbor_lock);
       while(first != NULL) {
          // get neighbor
          neighbor = (neighbor_t*) first->data;
          if(neighbor != NULL) {
             struct in_addr src, dst;
             src.s_addr = router->interface[i].ip;
             dst.s_addr = neighbor->ip;
             make_ip_packet(pwospf_packet, pwospf_packet_len, dst, src, IP_PROTOCOL_OSPF);
             
          }
          first = first->next;
       }
       pthread_mutex_unlock(&router->interface[i].neighbor_lock);
   }
}

void pwospf_flood_lsu(struct ip* ip_header, pwospf_header_t* pwospf_header, pwospf_lsu_packet_t* lsu_packet, neighbor_t* sending_neighbor, interface_t* intf) {
   printf(" ** pwospf_flood_lsu(..) called\n");
   // decrement ttl
   uint16_t ttl = 0;
   ttl = htons(lsu_packet->ttl);
   ttl = ttl - 1;
   ttl = ntohs(ttl);
   lsu_packet->ttl = ttl;
   pwospf_header->checksum = 0;
   uint16_t pwospf_packet_len = pwospf_header->len;
   // correct order
   pwospf_header->len = htons(pwospf_header->len);
   // generate raw packet 
   byte* pwospf_packet = (byte*) malloc_or_die(pwospf_packet_len);
   memcpy(pwospf_packet, pwospf_header, sizeof(pwospf_header_t));
   memcpy(pwospf_packet + sizeof(pwospf_header_t), lsu_packet, pwospf_packet_len - sizeof(pwospf_header_t));
   printf(" ** pwospf_flood_lsu(..) pwospf packet with len %u generated \n", pwospf_packet_len);
   // generate checksum
   pwospf_header->checksum = htons(htons(inet_chksum((void*) pwospf_packet, pwospf_packet_len)));
   memcpy(pwospf_packet, pwospf_header, sizeof(pwospf_header_t));
   // check if ttl expired
   if(lsu_packet->ttl < 1) {
      printf(" ** pwospf_flood_lsu(..) ttl expired, not flooding\n");
   } else {
      // get instance of router 
      struct sr_instance* sr_inst = get_sr();
      struct sr_router* router = (struct sr_router*)sr_get_subsystem(sr_inst);
      node* first = NULL;
      neighbor_t* neighbor = NULL;
      int i;
      // now iterate through each interface
      for( i = 0; i < router->num_interfaces ; i++) {
         // now iterate this interface's neighbors list
         first = router->interface[i].neighbor_list;
         pthread_mutex_lock(&router->interface[i].neighbor_lock);
         while(first != NULL) {
            // get neighbor
            neighbor = (neighbor_t*) first->data;
            if(neighbor != NULL) {
               // ensure that the sending neighbour is excluded
               if(neighbor->id != sending_neighbor->id) {
                  byte* ip_packet = (byte*) malloc_or_die(ip_header->ip_len);
                  ip_header->ip_dst.s_addr = neighbor->ip;
                  ip_header->ip_len = htons((ip_header->ip_len));
                  ip_header->ip_off = htons((ip_header->ip_off));
                  ip_header->ip_id = htons((ip_header->ip_id));
                  ip_header->ip_sum = htons((ip_header->ip_sum));
                  memcpy(ip_packet, ip_header, ip_header->ip_hl * 4);
                  memcpy(ip_packet + ip_header->ip_hl * 4, pwospf_packet, pwospf_packet_len);
                  ip_look_up_reply(ip_packet, ip_header, intf);
               }

            }  
          first = first->next;
         }
          pthread_mutex_unlock(&router->interface[i].neighbor_lock);
      }
   }
}

void display_ls_advert(pwospf_ls_advert_t* packet) {
   printf(" ** subnet: %s, ", quick_ip_to_string(packet->subnet));
   printf("mask: %s, ", quick_ip_to_string(packet->mask));
   printf("router_id: %s\n", quick_ip_to_string(packet->router_id));
}