int handle_ip_packet(struct sr_instance * sr, uint8_t * packet, unsigned int len ) {
sr_ip_hdr_t *iphdr = (sr_ip_hdr_t *)(packet + sizeof(sr_ethernet_hdr_t));
/* validate checksum. */
uint16_t checksum;
checksum = cksum(iphdr, sizeof(*iphdr));
if (checksum != 0xffff) {
return -1;
}
uint8_t * newpacket_for_ip = (uint8_t *) malloc(len);
memcpy(newpacket_for_ip, packet, len);
sr_ip_hdr_t *new_iphdr = (sr_ip_hdr_t *)(newpacket_for_ip + sizeof(sr_ethernet_hdr_t));
/* Decrement the TTL by 1, and recompute the packet
checksum over the modified header. */
/* decrement ttl */
new_iphdr->ip_ttl--;
if (new_iphdr->ip_ttl <= 0) {
/* check ttl, less than zero */
send_icmp_message(sr,packet, 11, 0);
return -1;
}
/* update checksum. */
new_iphdr->ip_sum = 0;
checksum = cksum(new_iphdr, sizeof(*new_iphdr));
new_iphdr->ip_sum = checksum;
checksum = cksum(new_iphdr, sizeof(*new_iphdr));
struct sr_if* assoc_iface = validate_ip(sr->if_list, iphdr->ip_dst);
if (assoc_iface) {
/*it's destined to one of our IPs */
/* ICMP */
uint8_t ip_proto = ip_protocol(packet + sizeof(sr_ethernet_hdr_t));
if (ip_proto == ip_protocol_icmp) {
int minlength = sizeof(sr_icmp_hdr_t) + sizeof(sr_ethernet_hdr_t) + sizeof(sr_ip_hdr_t);
if (len < minlength){
return -1;
}
struct sr_icmp_hdr * icmp_hdr = (struct sr_icmp_hdr *) (packet + sizeof(sr_ethernet_hdr_t) + sizeof(sr_ip_hdr_t));
if(icmp_hdr->icmp_type == 8){
/* is an echo request */
int res;
res = make_echo_request(&newpacket_for_ip, len);
if (res == -1){
return -1;
}
}
/* end ICMP */
} else {
/* got a udp payload to a rounter interface */
int res;
res = send_icmp_message(sr, packet, 3, 3);
if (res == -1){
return -1;
}
}
}
/* Find out which entry in the routing table has
the longest prefix match with the
destination IP address. */
struct sr_rt* best_rt = find_best_rt(sr->routing_table, ntohl(new_iphdr->ip_dst));
if (!best_rt) {
/* didn't find an interface, send an ICMP message type 3
code 0, also if there are any errors above */
int res = send_icmp_message(sr, packet, 3, 0);
if (res == -1){
return -1;
}
return 0;
}
/* found an interface */
struct sr_if * best_iface = sr_get_interface(sr, best_rt->interface);
if (!best_iface){
return -1;
}
struct sr_arpentry * forward_arp_entry = sr_arpcache_lookup(&(sr->cache), best_rt->gw.s_addr);
struct sr_ethernet_hdr * new_ether_hdr = (struct sr_ethernet_hdr * ) newpacket_for_ip;
/* ethernet -- update the source address */
memcpy(new_ether_hdr->ether_shost, best_iface->addr, ETHER_ADDR_LEN);
if (forward_arp_entry) {
/* we have a MAC address */
/* update packet */
/* ethernet -- set the dest address */
memcpy(new_ether_hdr->ether_dhost, forward_arp_entry->mac, ETHER_ADDR_LEN);
/* send packet using correct interface */
int res = 0;
res = sr_send_packet(sr, newpacket_for_ip, len, best_rt->interface);
if (res != 0) {
return -1;
}
free(forward_arp_entry);
} else {
/* we dont have a MAC address, add to arp queue */
struct sr_arpreq * arpreq;
arpreq = sr_arpcache_queuereq(&(sr->cache), best_rt->gw.s_addr, newpacket_for_ip,
len, best_rt->interface );
if (!arpreq){
return -1;
}
uint32_t ip, dest;
ip = ntohl(best_iface->ip);
dest = ntohl(best_rt->dest.s_addr);
sr_handle_arp_req(sr, arpreq);
}
return 0;
}
struct ofpbuf *
echo_request(enum ofputil_protocol proto)
{
return make_echo_request(ofputil_protocol_to_ofp_version(proto));
}
