#include<stdio.h>

#include<stdlib.h>

#include<iostream>

#include <sstream>

#include <vector>

#include <sys/socket.h>

#include <netinet/in.h>

#include <strings.h>

#include <sys/queue.h>

#include <unistd.h>

#include <string.h>

#include <inttypes.h>

#include <sys/select.h>

#include <arpa/inet.h>

#include <time.h>

#include <ctime>

#include <sys/time.h>

#include <fstream>

#include <string.h>

#include <sys/stat.h>

typedef unsigned long long timestamp_t;

static timestamp_t

get_timestamp ()

}

#define AUTHOR_STATEMENT "I, parushga, have read and understood the course academic integrity policy."

#define CNTRL_CONTROL_CODE_OFFSET 0x04

#define CNTRL_PAYLOAD_LEN_OFFSET 0x06

#define CONTROL_HANDLER_LIB_H_

#define CNTRL_HEADER_SIZE 8

#define CNTRL_RESP_HEADER_SIZE 8

using namespace std;

struct __attribute__((__packed__)) CONTROL_HEADER

};

struct __attribute__((__packed__)) RECV_HEADER

};

struct __attribute__((__packed__)) CONTROL_RESPONSE_HEADER

};

struct __attribute__((__packed__)) router_details

};

struct __attribute__((__packed__)) packet_structure

};

struct __attribute__((__packed__)) update_router_details

};

struct __attribute__((__packed__)) routing_update_structure

};

struct __attribute__((__packed__)) routing_table

};

struct __attribute__((__packed__)) sendFilePacketStructure

};

struct __attribute__((__packed__)) sendFileControlPayload

};

struct __attribute__((__packed__)) statistics

};

struct __attribute__((__packed__)) fillStats

};

vector<statistics> mystats;

struct node

}rt[10];

static struct timeval tout;

struct timeval test_time;

struct router_neighbour

};

int lastVal;

int numberofintervals = -1;

int recvcounter = 0;

int stats_payload_len;

int indexDestination;

int send_socket;

int indexNextHop;

uint16_t dataPortNextHop;

uint32_t destIPNextHop;

char *sendbuffer;

const char* fr_name;

char *payload;

int size;

vector <router_neighbour> router_time_vector;

struct packet_structure* snap_pkt;

struct sendFileControlPayload* send_pkt;

vector<router_neighbour> myNeighbours;

vector<int> myNeighbourHopList;

uint32_t cur_router_ip;

bool firstPacket_recv = true;

bool firstPacket_send = true;

char f_name[5];

const char *finame;

bool firstTime = true;

int countActiveRouters = 0;

string f_append;

int vectorMatrix[5][5];

int copy_vectorMatrix[5][5];

int *cost_vector;

char INF1;

char INF2;

int counter = 0;

char *last_packet_router;

char *penultimate_last_packet_router;

//Variables used in the program

fd_set master_list, watch_list;

int sock, control_socket, head_fd, router_socket, data_socket, num_routers, periodic_interval, data_port, connect_socket;

uint16_t control_port, router_port, cur_router_index = 65534;

/* Linked List for active data connections */

struct DataConn

}*connection, *conn_temp;

LIST_HEAD(DataConnsHead, DataConn) data_conn_list;

int new_data_conn(int sock_index)

}

int new_control_conn(int sock_index)

}

bool isData(int sock_index)

}

int getMaxValueInList()

}

bool isAnyChangeInRow(int index)

}

void initialiseMatrix(uint16_t routers)

}

void bellmanFordAlgorithm()

}

void remove_control_conn(int sock_index)

}

void remove_data_conn(int sockindex)

}

ssize_t recvALL(int sock_index, unsigned char *buffer, ssize_t nbytes)

}

ssize_t recvALL_C(int sock_index, char *buffer, ssize_t nbytes)

}

ssize_t sendALL(int sock_index, char *buffer, ssize_t nbytes)

}

struct routing_update_structure buildUpdatePacketStructure()

}

char* create_response_header(int sock_index, uint8_t control_code, uint8_t response_code, uint16_t payload_len)

{

// //cout<<"Creating response header"<<endl;

char *buffer;

struct CONTROL_RESPONSE_HEADER *cntrl_resp_header;

struct sockaddr_in addr;

socklen_t addr_size;

buffer = (char *) malloc(sizeof(char)*CNTRL_RESP_HEADER_SIZE);

cntrl_resp_header = (struct CONTROL_RESPONSE_HEADER *) buffer;

addr_size = sizeof(struct sockaddr_in);

getpeername(sock_index, (struct sockaddr *)&addr, &addr_size);

/* Controller IP Address */

memcpy(&(cntrl_resp_header->controller_ip_addr), &(addr.sin_addr), sizeof(struct in_addr));

/* Control Code */

cntrl_resp_header->control_code = control_code;

/* Response Code */

cntrl_resp_header->response_code = response_code;

/* Payload Length */

cntrl_resp_header->payload_len = htons(payload_len);

return buffer;

}

char* createRoutingTableVector(int payload_len)

{

//cout<<"######################################"<<endl;

//cout<<"Create routing table"<<endl;

int structlen = 0;

uint16_t next_hop;

char *buffer;

buffer = (char *) malloc(sizeof(char)*payload_len);

//cout<<"|||||||||||||||Printing routing table: "<<endl;

for(int i = 0; i< num_routers; i++)

{

struct routing_table *r_table = (struct routing_table *) (buffer + structlen);//(cntrl_response_payload + structlen);

r_table->r_id = htons(snap_pkt->router_array[i].router_id);

r_table->pad = htons(0);

if(vectorMatrix[cur_router_index][i] == 65535)

{

r_table->next_hop = htons(65535);

r_table->cost = htons(65535);

//cout<<snap_pkt->router_array[i].router_id<<"\t"<<"0"<<"\t"<<endl;

//cout<<"65535"<<"\t"<<"65535"<<"\t"<<endl;

}

else

{

if(myNeighbourHopList.at(i) == -1)

{

r_table->next_hop = htons(65535);

r_table->cost = htons(65535);

}

else

{

r_table->next_hop = htons(snap_pkt->router_array[myNeighbourHopList.at(i)].router_id);

r_table->cost = htons(vectorMatrix[cur_router_index][i]);

}

//cout<<snap_pkt->router_array[i].router_id<<"\t"<<"0"<<"\t"<<endl;

//cout<<snap_pkt->router_array[myNeighbourHopList.at(i)].router_id<<"\t"<<vectorMatrix[cur_router_index][i]<<"\t"<<endl;

}

//memcpy(cntrl_response_payload, &r_table, sizeof(r_table));

structlen = structlen + 8;

}

//cout<<"|||||||||||||||Ending printing routing table: "<<endl;

return buffer;

}

void author_response(int sock_index)

}

void init_response(int sock_index)

}

void routingTable_response(int sock_index)

}

void update_response(int sock_index)

}

void crash_response(int sock_index)

}

void send_response(int sock_index)

}

void stats_response(int sock_index, unsigned char* payload)

}

void last_data_response(int sock_index)

}

void penultimate_data_response(int sock_index)

}

unsigned char *packet;

char* get_ip(uint32_t ip)

{

unsigned char bytes[4];

bytes[0] = ip & 0xFF;

bytes[1] = (ip >> 8) & 0xFF;

bytes[2] = (ip >> 16) & 0xFF;

bytes[3] = (ip >> 24) & 0xFF;

char *IP = NULL;

asprintf(&IP, "%d.%d.%d.%d", bytes[3], bytes[2], bytes[1], bytes[0]);

//cout<<"IP: "<<IP<<endl;

return IP;

// string IPRouter(IP);

// return IPRouter;

//IP = (char)bytes[3] + "." + (char)bytes[2] + "." + (char)bytes[1] + "." + (char)bytes[0];

//return bytes[3] + "." + bytes[2] + "." + bytes[1] + "." + bytes[0];

}

void CreateYourNeighbours(int index)

}

void create_packet_structure(unsigned char *cntrl_payload)

}

int create_router_socket()

}

int create_send_socket()

}

int create_data_socket()

}

void sendUDP(int port, uint32_t ip, int sockfd, struct routing_update_structure vector)