#include "sr_ip.h"

#include "cli/helper.h"

#include "lwtcp/lwip/inet.h"

#include "sr_common.h"

#include "sr_icmp.h"

#include "sr_lwtcp_glue.h"

#include "sr_udp.h"

#include "sr_icmp_types_response.h"

#include "sr_integration.h"

#include "sr_ethernet.h"

#include "sr_rtable.h"

#include "sr_pwospf.h"

#include "sr_icmp_types_send.h"

#include <stdlib.h>

#include <string.h>

#include <arpa/inet.h>

bool fragment_check(uint16_t off) {

if(off == IP_OFFSET_DF || off == IP_OFFSET_NF)

return TRUE;

return FALSE;

}

bool check_ip_header(struct ip* header, byte* raw_header) {

// create raw header with checksum zero

byte* sum_header = (byte*) malloc_or_die(header->ip_hl * 4);

memcpy(sum_header, raw_header, header->ip_hl * 4);

uint16_t sum_zero = 0;

memcpy(sum_header + 10, &sum_zero ,2);

uint16_t len_min = IP_PACKET_MIN_LEN;

uint16_t len_max = IP_PACKET_MAX_LEN;

// find out exact failure

if(header->ip_v != IP_4_VERSION)

printf("ip version incorrect\n");

if(header->ip_hl < IP_HEADER_MIN_LEN_WORD)

printf("ip header min incorrect\n");

if(header->ip_hl > IP_HEADER_MAX_LEN_WORD)

printf("ip header max incorrect\n");

if(header->ip_len < len_min)

printf("ip header min incorrect\n");

if(header->ip_len > len_max)

printf("ip header max incorrect\n");

if(ntohs(inet_chksum((void*) sum_header, header->ip_hl * 4)) != header->ip_sum)

printf("ip header check sum failed\n");

if(header->ip_hl > IP_HEADER_MIN_LEN_WORD)

printf("ip header options present failure\n");

if(fragment_check(header->ip_off) == FALSE)

printf("ip header fragments failure\n");

// complete sanity checks

if(header->ip_v!= IP_4_VERSION || header->ip_hl != IP_HEADER_MIN_LEN_WORD || header->ip_len < len_min || header->ip_len > len_max || ntohs(inet_chksum((void*) sum_header, header->ip_hl * 4)) != header->ip_sum || fragment_check(header->ip_off) == FALSE) {

// free(sum_header);

return FALSE;

}

// free(sum_header);

return TRUE;

}

void ip_handle_packet( sr_router* router,

byte* ip_packet,

interface_t* intf ) {

printf(" ** ip_handle_packet(..) called \n");

// construct ip header

struct ip* ip_header = make_ip_header(ip_packet);

byte* ip_header_raw = (byte*) malloc_or_die(ip_header->ip_hl * 4);

memcpy(ip_header_raw, ip_packet, ip_header->ip_hl * 4);

// check if ip header is correct

bool ret = check_ip_header(ip_header, ip_header_raw);

if(ret == TRUE) {

printf(" ** ip_handle_packet(..) header sanity checks passed\n");

// display ip header

printf(" ** ip_handle_packet(..) packet contents \n");

display_ip_header(ip_header);

// get payload

uint16_t payload_len = ip_header->ip_len - (ip_header->ip_hl * 4);

printf(" ** ip_handle_packet(..) Payload size %u bytes \n", payload_len);

byte* payload = (byte*) malloc_or_die(payload_len);

memcpy(payload, ip_packet + (ip_header->ip_hl * 4), payload_len);

//free(ip_header_raw);

// check destination

printf(" ** ip_handle_packet(..) checking packet destination \n");

// check if spf broadcast packet

char* all_spf_routers = ALL_SPF_ROUTERS_IP;

if(check_packet_destination(ip_header->ip_dst, router) == TRUE || ip_header->ip_dst.s_addr == make_ip_addr(all_spf_routers)) {

printf(" ** ip_handle_packet(..) yes I'm the destination \n");

// check if ttl expired

/* if(ip_header->ip_ttl == 1) {

printf(" ** ip_handle_packet(..) ttl expired, sending ICMP ttl error message \n");

uint8_t code = ICMP_TYPE_CODE_TTL_TRANSIT;

icmp_type_ttl_send(&code, payload, (uint8_t*)&ip_header->ip_len, ip_header);

} else*/ {

// check protocol

printf(" ** ip_handle_packet(..) checking protocol \n");

check_packet_protocol(router, ip_header, payload, payload_len, intf, ip_packet);

}

} else {

printf(" ** ip_handle_packet(..) no I'm not the destination, send to ip lookup \n");

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));

ip_look_up_reply(ip_packet, ip_header, intf);

}

}

else

printf(" ** ip_handle_packet(..) header sanity checks failed\n");

//free(ip_packet);

//free(ip_header);

//free(ip_header_raw);

}

struct ip* make_ip_header(byte* ip_packet) {

struct ip* ip_header = (struct ip*) malloc_or_die(sizeof(struct ip));

byte ver_len;

memcpy(&ver_len, ip_packet, 1);

ip_header->ip_v = ver_len >> 4;

ip_header->ip_hl = ver_len & ((1 << 4) - 1);

memcpy(&ip_header->ip_tos, ip_packet + 1, 1);

memcpy(&ip_header->ip_len, ip_packet + 2 ,2);

ip_header->ip_len = ntohs(ip_header->ip_len);

memcpy(&ip_header->ip_id, ip_packet + 4 ,2);

ip_header->ip_id = ntohs(ip_header->ip_id);

memcpy(&ip_header->ip_off, ip_packet + 6 ,2);

ip_header->ip_off = ntohs(ip_header->ip_off);

memcpy(&ip_header->ip_ttl, ip_packet + 8 ,1);

memcpy(&ip_header->ip_p, ip_packet + 9 ,1);

memcpy(&ip_header->ip_sum, ip_packet + 10 ,2);

ip_header->ip_sum = ntohs(ip_header->ip_sum);

uint32_t src, dst;

memcpy(&src, ip_packet + 12 ,4);

memcpy(&dst, ip_packet + 16 ,4);

memcpy(&ip_header->ip_src, &src , 4);

memcpy(&ip_header->ip_dst, &dst ,4);

return ip_header;

}

void display_ip_header(struct ip* ip_header) {

char src[INET_ADDRSTRLEN];

char dst[INET_ADDRSTRLEN];

inet_ntop(AF_INET, &(ip_header->ip_src), src, INET_ADDRSTRLEN);

inet_ntop(AF_INET, &(ip_header->ip_dst), dst, INET_ADDRSTRLEN);

printf(" ** ver: %u, header len: %u, tos: %u, packet len: %u, id: %u, off: %u, ttl: %u, protocol: %u, checksum: %u, src: %s, dst: %s\n", ip_header->ip_v, ip_header->ip_hl, ip_header->ip_tos, ip_header->ip_len, ip_header->ip_id, ip_header->ip_off, ip_header->ip_ttl, ip_header->ip_p, ip_header->ip_sum, src, dst);

}

bool check_packet_destination(struct in_addr ip_dst, sr_router* router) {

char str[INET_ADDRSTRLEN];

inet_ntop(AF_INET, &(ip_dst), str, INET_ADDRSTRLEN);

printf(" ** dst: %s\n", str);

int i = 0;

for(i = 0; i < router->num_interfaces ; i++) {

printf(" ** intf: %s\n", quick_ip_to_string(router->interface[i].ip));

if(ip_dst.s_addr == router->interface[i].ip)

return TRUE;

}

return FALSE;

}

void check_packet_protocol(sr_router* router, struct ip* ip_header, byte* payload, uint16_t payload_len, interface_t* intf, byte* ip_packet) {

if(ip_header->ip_p == IP_PROTOCOL_ICMP) {

//icmp

printf(" ** ip_handle_packet(..) protocol: ICMP \n");

icmp_handle_packet(router, payload, payload_len, ip_header, intf);

} else if(ip_header->ip_p == IP_PROTOCOL_TCP) {

//tcp

printf(" ** ip_handle_packet(..) protocol: TCP \n");

sr_transport_input(ip_packet);

} else if(ip_header->ip_p == IP_PROTOCOL_UDP) {

//udp

printf(" ** ip_handle_packet(..) protocol: UDP \n");

//udp_handle_packet(payload, ip_header, intf);

printf(" ** ip_handle_packet(..) protocol: Error! Not supported. Dropping and sending ICMP response: port unreachable \n");

uint8_t code = ICMP_TYPE_CODE_DST_UNREACH_PORT;

icmp_type_dst_unreach_send(&code, ip_packet, (uint16_t*)&ip_header->ip_len, ip_header);

} else if(ip_header->ip_p == IP_PROTOCOL_OSPF) {

//ospf

printf(" ** ip_handle_packet(..) protocol: OSPF \n");

pwospf_handle_packet(payload,

payload_len,

ip_header,

intf,

router);

}else {

//otherwise

printf(" ** ip_handle_packet(..) protocol: Error! Not supported. Dropping and sending ICMP response \n");

uint8_t code = ICMP_TYPE_CODE_DST_UNREACH_PROTOCOL;

icmp_type_dst_unreach_send(&code, ip_packet, (uint16_t*)&ip_header->ip_len, ip_header);

}

}

void make_ip_packet_reply(byte* payload, uint16_t payload_len, struct in_addr src, struct in_addr dst, uint8_t protocol, interface_t* intf) {

printf(" ** make_ip_packet_reply(..) called \n");

struct ip* ip_header = (struct ip*) malloc_or_die(sizeof(struct ip));

ip_header->ip_v = IP_4_VERSION;

ip_header->ip_off = htons(IP_OFFSET_DF);

ip_header->ip_p = protocol;

// switching src and dst

ip_header->ip_dst = src;

ip_header->ip_src = dst;

ip_header->ip_tos = IP_TOS_DEFAULT;

ip_header->ip_id = htons(IP_ID);

ip_header->ip_ttl = IP_TTL_DEFAULT;

ip_header->ip_hl = IP_HEADER_MIN_LEN_WORD;

ip_header->ip_len = htons(payload_len + IP_HEADER_MIN_LEN);

ip_header->ip_sum = 0;

ip_header->ip_sum = htons(htons(inet_chksum((void*)ip_header, IP_HEADER_MIN_LEN)));

// generate ip packet

uint16_t packet_len = ntohs(ip_header->ip_len);

byte* ip_packet = (byte*) malloc_or_die(packet_len);

memcpy(ip_packet, ip_header, IP_HEADER_MIN_LEN);

memcpy(ip_packet + IP_HEADER_MIN_LEN, payload, payload_len);

// display generated packet len

printf(" ** make_ip_packet_reply(..) generated packet with length %u bytes\n", (ntohs(ip_header->ip_len)));

// send to ip lookup

ip_look_up_reply(ip_packet, ip_header, intf);

}

uint16_t generate_checksum_ip_header(struct ip* header, uint16_t len) {

byte* raw_header = (byte*) malloc_or_die(len);

memcpy(raw_header, header, len);

return htons(inet_chksum((void*) raw_header, len));

}

void ip_look_up(byte* ip_packet, struct ip* ip_header) {

printf(" ** ip_lookup(..) called \n");

// get ptr to global router instance

struct sr_router* subsystem = (struct sr_router*)sr_get_subsystem(get_sr());

// get dst ip object

addr_ip_t dst_ip;

memcpy(&dst_ip, &ip_header->ip_dst, 4);

// look up in routing table

route_info_t route_info = rrtable_find_route(subsystem->rtable, dst_ip);

if(route_info.intf == NULL) {

printf(" ** ip_lookup(..) Error! No route found \n");

} else {

// display output interface

printf(" ** ip_lookup(..) output interface for ip: %s\n", quick_ip_to_string(dst_ip));

display_interface(route_info.intf);

// set src ip as the ip of the output interface

memcpy(&ip_header->ip_src, &route_info.intf->ip, 4);

memcpy(ip_packet, ip_header, ip_header->ip_hl);

// check if ttl expired

if(ip_header->ip_ttl == 1) {

printf(" ** ip_lookup(..) ttl expired, sending ICMP ttl error message \n");

uint8_t code = ICMP_TYPE_CODE_TTL_TRANSIT;

uint16_t len = ntohs(ip_header->ip_len);

icmp_type_ttl_send(&code, ip_packet, &len, ip_header);

} else {

printf(" ** ip_lookup(..) decrementing ttl \n");

// create new ip header

struct ip* ip_header_ttl = (struct ip*) malloc_or_die(ip_header->ip_hl * 4);

memcpy(ip_header_ttl, ip_header, ip_header->ip_hl * 4);

// decrement ttl

ip_header_ttl->ip_ttl = ip_header_ttl->ip_ttl - 1;

// generate checksum

ip_header_ttl->ip_sum = 0;

ip_header_ttl->ip_sum = htons(htons(inet_chksum((void*)ip_header_ttl, ip_header_ttl->ip_hl * 4)));

// get payload

uint16_t payload_len = ntohs(ip_header_ttl->ip_len) - (ip_header_ttl->ip_hl * 4);

printf(" ** ip_lookup(..) Payload size %u bytes \n", payload_len);

memcpy(ip_packet, ip_header_ttl, ip_header_ttl->ip_hl * 4);

// make new ip packet

send_ip_packet(ip_packet, ip_header_ttl, route_info);

}

}

}

void send_ip_packet(byte* ip_packet, struct ip* ip_header, route_info_t route_info) {

printf(" ** send_ip_packet(..) called \n");

// display generated packet len

addr_ip_t dst_ip, src_ip;

memcpy(&dst_ip, &ip_header->ip_dst, 4);

memcpy(&src_ip, &ip_header->ip_src, 4);

if(check_if_local_subnet(dst_ip, src_ip, route_info.intf->subnet_mask) == FALSE) { // non local subnet

printf(" ** send_ip_packet(..) destination on non-local subnet\n");

// check if dst directly connected

if(route_info.ip == 0)

printf(" ** send_ip_packet(..) destination directly connected\n");

else

dst_ip = route_info.ip;

} else

printf(" ** send_ip_packet(..) destination on local subnet\n");

struct sr_router* subsystem = (struct sr_router*)sr_get_subsystem(get_sr());

arp_cache_handle_partial_frame(subsystem, route_info.intf, dst_ip, ip_packet, ntohs(ip_header->ip_len), ETHERTYPE_IP);

}

bool check_if_local_subnet(addr_ip_t dst, addr_ip_t src, addr_ip_t subnet_mask) {

addr_ip_t dst_subnet = dst & subnet_mask;

addr_ip_t src_subnet = src & subnet_mask;

if(dst_subnet == src_subnet){ // is local

return TRUE;

}

return FALSE;

}

void make_ip_packet(byte* payload, uint16_t payload_len, struct in_addr src, struct in_addr dst, uint8_t protocol) {

printf(" ** make_ip_packet(..) called \n");

struct ip* ip_header = (struct ip*) malloc_or_die(sizeof(struct ip));

ip_header->ip_v = IP_4_VERSION;

ip_header->ip_off = htons(IP_OFFSET_DF);

ip_header->ip_p = protocol;

// switching src and dst

ip_header->ip_dst = src;

ip_header->ip_src = dst;

ip_header->ip_tos = IP_TOS_DEFAULT;

ip_header->ip_id = htons(IP_ID);

ip_header->ip_ttl = IP_TTL_DEFAULT;

ip_header->ip_hl = IP_HEADER_MIN_LEN_WORD;

ip_header->ip_len = htons(payload_len + IP_HEADER_MIN_LEN);

ip_header->ip_sum = 0;

ip_header->ip_sum = htons(htons(inet_chksum((void*)ip_header, IP_HEADER_MIN_LEN)));

// generate ip packet

uint16_t packet_len = ntohs(ip_header->ip_len);

byte* ip_packet = (byte*) malloc_or_die(packet_len);

memcpy(ip_packet, ip_header, IP_HEADER_MIN_LEN);

memcpy(ip_packet + IP_HEADER_MIN_LEN, payload, payload_len);

// display generated packet len

printf(" ** make_ip_packet(..) generated packet with length %u bytes\n", (ntohs(ip_header->ip_len)));

// send to ip lookup

ip_look_up(ip_packet, ip_header);

// free payload mem

//free(payload);

}

void ip_look_up_reply(byte* ip_packet, struct ip* ip_header, interface_t* intf) {

printf(" ** ip_lookup_reply(..) called \n");

// get ptr to global router instance

struct sr_router* subsystem = (struct sr_router*)sr_get_subsystem(get_sr());

// get dst ip object

addr_ip_t dst_ip;

memcpy(&dst_ip, &ip_header->ip_dst, 4);

// look up in routing table

route_info_t route_info = rrtable_find_route(subsystem->rtable, dst_ip);

if(route_info.intf == NULL) {

printf(" ** ip_lookup_reply(..) Error! No route found \n");

} else {

// display output interface

printf(" ** ip_lookup_reply(..) output interface for ip: %s\n", quick_ip_to_string(dst_ip));

display_interface(route_info.intf);

// check if destination same as ip of the source interface and packet didn't originate from one of my interfaces

if(strcmp(route_info.intf->name, intf->name) == 0 && check_packet_source(ip_header->ip_src, subsystem) == FALSE) {

printf(" ** make_ip_packet_reply(..) error! destination interface same as source \n");

// send icmp destination host unreachable

uint8_t code = ICMP_TYPE_CODE_DST_UNREACH_HOST;

// reverse order

ip_header->ip_len = ntohs((ip_header->ip_len));

ip_header->ip_off = ntohs((ip_header->ip_off));

ip_header->ip_id = ntohs((ip_header->ip_id));

ip_header->ip_sum = ntohs((ip_header->ip_sum));

uint16_t packet_len = ip_header->ip_len;

icmp_type_dst_unreach_send(&code, ip_packet, &packet_len, ip_header);

} else {

// check if ttl expired

if(ip_header->ip_ttl == 1) {

printf(" ** ip_lookup_reply(..) ttl expired, sending ICMP ttl error message \n");

// reverse order

ip_header->ip_len = ntohs((ip_header->ip_len));

ip_header->ip_off = ntohs((ip_header->ip_off));

ip_header->ip_id = ntohs((ip_header->ip_id));

ip_header->ip_sum = ntohs((ip_header->ip_sum));

uint8_t code = ICMP_TYPE_CODE_TTL_TRANSIT;

uint16_t len = ip_header->ip_len;

icmp_type_ttl_send(&code, ip_packet, &len, ip_header);

} else {

printf(" ** ip_lookup_reply(..) decrementing ttl \n");

// create new ip header

struct ip* ip_header_ttl = (struct ip*) malloc_or_die(ip_header->ip_hl * 4);

memcpy(ip_header_ttl, ip_header, ip_header->ip_hl * 4);

// decrement ttl

ip_header_ttl->ip_ttl = ip_header_ttl->ip_ttl - 1;

// generate checksum

ip_header_ttl->ip_sum = 0;

ip_header_ttl->ip_sum = htons(htons(inet_chksum((void*)ip_header_ttl, ip_header_ttl->ip_hl * 4)));

// get payload

uint16_t payload_len = ntohs(ip_header_ttl->ip_len) - (ip_header_ttl->ip_hl * 4);

printf(" ** ip_lookup_reply(..) Payload size %u bytes \n", payload_len);

memcpy(ip_packet, ip_header_ttl, ip_header_ttl->ip_hl * 4);

// make new ip packet

send_ip_packet(ip_packet, ip_header_ttl, route_info);

}

}

}

}

bool check_packet_source(struct in_addr ip_src, sr_router* router) {

int i = 0;

for(i = 0; i < router->num_interfaces ; i++) {

if(ip_src.s_addr == router->interface[i].ip)

return TRUE;

}

return FALSE;

}