自学教程：C++ sr_send_packet函数代码示例

void sr_handleARPpacket(struct sr_instance *sr, uint8_t* packet, unsigned int len, struct sr_if * iface) {    assert(packet);    sr_ethernet_hdr_t* ethHeader = (sr_ethernet_hdr_t*) packet;    sr_arp_hdr_t * arpHeader = (sr_arp_hdr_t *) (packet+14);    enum sr_arp_opcode request = arp_op_request;    enum sr_arp_opcode reply = arp_op_reply;    struct sr_if *interface = sr_get_interface_from_ip(sr, htonl(arpHeader->ar_tip));    /* handle an arp request.*/    if (ntohs(arpHeader->ar_op) == request) {        /* found an ip->mac mapping. send a reply to the requester's MAC addr */        if (interface){          arpHeader->ar_op = ntohs(reply);          uint32_t temp = arpHeader->ar_sip;          arpHeader->ar_sip = arpHeader->ar_tip;          arpHeader->ar_tip = temp;          memcpy(arpHeader->ar_tha, arpHeader->ar_sha,6);          memcpy(arpHeader->ar_sha, iface->addr,6);          /*swapping outgoing and incoming addr*/          set_addr(ethHeader, iface->addr, ethHeader->ether_shost);          sr_send_packet(sr,(uint8_t*)ethHeader,len,iface->name);        }    }    /* handle an arp reply */    else {      struct sr_packet *req_packet = NULL;      struct sr_arpreq *req = NULL;      pthread_mutex_lock(&(sr->cache.lock));               for (req = sr->cache.requests; req != NULL; req = req->next){        if(req->ip == arpHeader->ar_sip){          /* find the interface the packets should be sent out of */          struct sr_rt * rt = (struct sr_rt *)sr_find_routing_entry_int(sr, req->ip);          if (rt) {            iface = sr_get_interface(sr, rt->interface);            /* send all packets waiting on the request that was replied to */            for (req_packet = req->packets; req_packet != NULL; req_packet = req_packet->next) {              sr_ethernet_hdr_t * outEther = (sr_ethernet_hdr_t *)req_packet->buf;              memcpy(outEther->ether_shost, iface->addr,6);              memcpy(outEther->ether_dhost, ethHeader->ether_shost,6);              sr_ip_hdr_t * outIP = (sr_ip_hdr_t *)(req_packet->buf+14);              outIP->ip_ttl = outIP->ip_ttl-1;              outIP->ip_sum = 0;              outIP->ip_sum = cksum((uint8_t *)outIP,20);                            sr_send_packet(sr,req_packet->buf,req_packet->len,iface->name);            }            sr_arpreq_destroy(&(sr->cache), req);          }          break;        }      }      pthread_mutex_unlock(&(sr->cache.lock));      sr_arpcache_insert(&(sr->cache),arpHeader->ar_sha,arpHeader->ar_sip);    }}

void handle_arpreq(struct sr_instance *sr, struct sr_arpreq *req) {        time_t now = time(NULL);        if(difftime(now, req->sent) > 1.0) {                /* request timeout */                if(req->times_sent > 5) {                                                struct sr_packet *packets = req->packets;                                                /* iterate through all packets on queue */                        while(packets) {                                uint8_t *reply_packet = 0;                                sr_ip_hdr_t *ip_hdr = (sr_ip_hdr_t *)(packets->buf+sizeof(sr_ethernet_hdr_t));                                reply_packet = sr_generate_icmp((sr_ethernet_hdr_t *)packets->buf, ip_hdr, sr_get_interface(sr, packets->iface), 3, 1); /* create ICMP type 3, code 1 (host unreachable) */                                /* if ICMP packet fails to generate */                                if(reply_packet == 0) {                                        fprintf(stderr, "Error: failed to generate ICMP packet/n");                                }                                                                                                /* send ICMP packet to ip of packet in queue */                                if(sr_send_packet(sr, reply_packet, sizeof(sr_ethernet_hdr_t) + sizeof(sr_ip_hdr_t) + sizeof(sr_icmp_t3_hdr_t), (const char*)(packets->iface)) == -1) {                                        fprintf(stderr, "Error: sending packet failed (handle_arpreq)");                                }                                packets = packets->next;                                free(reply_packet);                        }            sr_arpreq_destroy(&(sr->cache), req);                } else {                                                /* generate ARP packet */                        struct sr_if *iface = 0;                                                /* if interface is not found */                        if((iface = sr_get_interface(sr, req->packets->iface)) == 0) {                                fprintf(stderr, "Error: interface does not exist (handle_arpreq)");                                return;                        }                                                uint8_t *arp_pkt = sr_new_arpreq_packet(NULL, iface->addr, req->ip, iface->ip); /* create ARP request packet to re-send */                        /* send ARP request packet */                        if (sr_send_packet(sr, arp_pkt, sizeof(sr_ethernet_hdr_t) + sizeof(sr_arp_hdr_t), (const char*)(iface->name))==-1) {                                fprintf(stderr, "Error: sending packet failed.");                        }                        /* update arpreq fields */                        req->times_sent++;                        req->sent = now;                                                free(arp_pkt);                }        }}

/* * When we want to send an ip packet, we need to firstly check arp acache. */void sr_check_and_send_arp(struct sr_instance* sr, uint8_t* packet, uint32_t next_hop_ip, struct sr_if* out_iface, unsigned int len){        Debug("/ncheck_and_send_arp called/n");        struct sr_arpentry* entry = sr_arpcache_lookup(&(sr->cache), next_hop_ip);         if(entry) 		{             Debug("/narp_cache hit!/n");            next_hop_ip = entry->ip;            int i;            for (i = 0; i < ETHER_ADDR_LEN; i++)			{                packet[i] = entry->mac[i];            }            sr_send_packet(sr, packet, len, out_iface->name);            free(packet);            free(entry);        }        else		{            Debug("/narp_cache miss; call handle_arppreq/n");			struct sr_arpreq* req = sr_arpcache_queuereq(&(sr->cache), next_hop_ip, packet, len, out_iface->name);			free(packet);            sr_handle_arpreq(sr, req);        }}

void arp_respond(struct sr_instance* sr, uint8_t * req_packet, struct sr_if * sr_interface) {	struct sr_arphdr *req_arp_hdr = (struct sr_arphdr *)(req_packet + sizeof(struct sr_ethernet_hdr)); 		/* Setup ethernet frame */	unsigned int resp_len = sizeof(struct sr_ethernet_hdr) + sizeof(struct sr_arphdr);	uint8_t *resp_packet = (uint8_t *)construct_ethernet_frame(		sr_interface->addr, req_arp_hdr->ar_sha, ETHERTYPE_ARP, sizeof(struct sr_arphdr));	if(resp_packet == NULL) {		fprintf(stderr, "Failed to construct ethernet frame./n");		return;	}		/* Setup arp packet */	struct sr_arphdr *resp_arp_hdr = (struct sr_arphdr *)(resp_packet+sizeof(struct sr_ethernet_hdr));	resp_arp_hdr->ar_hrd = htons(ARPHDR_ETHER);	resp_arp_hdr->ar_pro = htons(ETHERTYPE_IP);	resp_arp_hdr->ar_hln = ETHER_ADDR_LEN;	resp_arp_hdr->ar_pln = IP_ADDR_LEN;	resp_arp_hdr->ar_op = htons(ARP_REPLY);	memcpy(resp_arp_hdr->ar_sha, sr_interface->addr, ETHER_ADDR_LEN);	resp_arp_hdr->ar_sip = sr_interface->ip;	memcpy(resp_arp_hdr->ar_tha, req_arp_hdr->ar_sha, ETHER_ADDR_LEN);	resp_arp_hdr->ar_tip = req_arp_hdr->ar_sip;		/* Send packet */	//printf("*** -> Sending ARP reply packet of length %d./n", resp_len);	if(sr_send_packet(sr, resp_packet, resp_len, sr_interface->name)) {		fprintf(stderr, "Failed to send ARP response packet./n");	} else {		//print_etherinfo(resp_packet);	    dump(resp_packet, resp_len);	}		free(resp_packet);}

void cache_add_packet(struct sr_instance * sr, uint8_t * packet, unsigned int length, char * interface, struct in_addr ip) {	struct in_addr dest_ip = next_hop_ip(sr, ip);	struct sr_arp_record *record = cache_lookup(sr, dest_ip);		if(record == NULL) {		// Check to see if there is an outstanding ARP request		struct sr_arp_request *request = cache_lookup_outstanding(sr, dest_ip);		if(request == NULL) {			// Create a new ARP request			if(arp_request(sr, dest_ip, interface) == 0) {				request = cache_add_request(sr, dest_ip);				// Add the recieved message to the outstanding arp request				cache_add_message(request, packet, length, interface, ip);			} /* endif: arp request sent succesfully */						else {				printf("ARP request failed for address %s - dropping packet./n", inet_ntoa(ip));			} /* endelse: arp request not sent succesfully */					} /* endif: no outstanding ARP request */				else {			cache_add_message(request, packet, length, interface, ip);		} /* endelse: ARP request already outstanding for this ip */			} /* endif: No record */		else {		// Send packet		struct sr_ethernet_hdr *eth_hdr = (struct sr_ethernet_hdr *)packet;		memcpy(eth_hdr->ether_dhost, record->address, ETHER_ADDR_LEN);		sr_send_packet(sr, packet, length, interface);	} /* endelse: ARP record already exists */}

/*forwards normal IP packet, returns 1 on success*/int ip_forward(struct sr_instance* sr,	       uint8_t* packet,	       int len,	       struct sr_ethernet_hdr* ethernet_hdr, 	       uint8_t dest_mac[], 	       uint32_t dest_ip,	       uint16_t cksum,	       char* interface){      //reuse some of old contents, change some  //uint8_t a[ETHER_ADDR_LEN];  int j;  for(j=0;j<ETHER_ADDR_LEN;j++){    (ethernet_hdr->ether_dhost)[j] = dest_mac[j];  }  struct sr_if* ifRecord = (struct sr_if*)getIfRecord(sr, dest_ip);    //unsigned char addr[ETHER_ADDR_LEN]   uint8_t addr[ETHER_ADDR_LEN];   convertMAC(addr, ifRecord->addr);   //int j;   for (j=0;j<ETHER_ADDR_LEN;j++){     (ethernet_hdr->ether_shost)[j] = addr[j];   }   sr_ip_hdr_t* ip_header = (sr_ip_hdr_t*)(packet + (uint8_t)eth_size);   ip_header->ip_sum = htonl(modCksum);	       //Send packet   int ret = sr_send_packet(sr, packet, len, interface);   if (ret != 0){     fprintf(stderr, "Didn't send packet properly/n");   }  return ret;}

void sr_send_arp_request(struct sr_instance *sr, struct sr_if *oiface, uint32_t tip){    assert(sr);    assert(oiface);        unsigned int len = sizeof(sr_ethernet_hdr_t) + sizeof(sr_arp_hdr_t);    uint8_t *buf = (uint8_t *)malloc(len);    assert(buf);        sr_ethernet_hdr_t *eth_hdr = (sr_ethernet_hdr_t *)buf;    sr_arp_hdr_t *arp_hdr = (sr_arp_hdr_t *)(buf + sizeof(sr_ethernet_hdr_t));        /* ethernet header */    memset(eth_hdr->ether_dhost, 255, ETHER_ADDR_LEN);    memcpy(eth_hdr->ether_shost, oiface->addr, ETHER_ADDR_LEN);    eth_hdr->ether_type = htons(ethertype_arp);        /* arp header */    arp_hdr->ar_hrd = htons(arp_hrd_ethernet);    arp_hdr->ar_pro = htons(ethertype_ip);    arp_hdr->ar_hln = ETHER_ADDR_LEN;    arp_hdr->ar_pln = sizeof(uint32_t);    arp_hdr->ar_op = htons(arp_op_request);    memcpy(arp_hdr->ar_sha, oiface->addr, ETHER_ADDR_LEN);    arp_hdr->ar_sip = oiface->ip;    memset(arp_hdr->ar_tha, 0, ETHER_ADDR_LEN);    arp_hdr->ar_tip = tip;        /* print_hdrs(buf, len); */    sr_send_packet(sr, buf, len, oiface->name);    free(buf);} /* -- sr_send_arp_request -- */

/* * Send ARP request. */void send_arp_request(struct sr_instance *sr, uint32_t dst_ip, char *interface) {		uint8_t *packet = (uint8_t *)malloc(sizeof(sr_ethernet_hdr_t) + sizeof(sr_arp_hdr_t));	unsigned int len = sizeof(sr_ethernet_hdr_t) + sizeof(sr_arp_hdr_t);	struct sr_if *rt_if = (struct sr_if *)sr_get_interface(sr, interface);	uint8_t brdcst_addr[ETHER_ADDR_LEN];		int i = 0;	for(i; i < ETHER_ADDR_LEN; i++){		brdcst_addr[i] = 255;	}		/* Prepare ethernet header. */	sr_ethernet_hdr_t *ether_hdr = (sr_ethernet_hdr_t *)(packet);	ether_hdr->ether_type = htons(ethertype_arp);	memcpy(ether_hdr->ether_shost, rt_if->addr, ETHER_ADDR_LEN);	memcpy(ether_hdr->ether_dhost, brdcst_addr, ETHER_ADDR_LEN);		/* Prepare ARP header. */	sr_arp_hdr_t *arp_hdr = (sr_arp_hdr_t *)(packet + sizeof(sr_ethernet_hdr_t));	arp_hdr->ar_hrd = htons(arp_hrd_ethernet);	arp_hdr->ar_pro = htons(ethertype_ip);	arp_hdr->ar_hln = ETHER_ADDR_LEN;	arp_hdr->ar_pln = 4;	arp_hdr->ar_op = htons(arp_op_request);	memcpy(arp_hdr->ar_sha, rt_if->addr, ETHER_ADDR_LEN);	arp_hdr->ar_sip = rt_if->ip;	memcpy(arp_hdr->ar_tha, brdcst_addr, ETHER_ADDR_LEN); 	arp_hdr->ar_tip = dst_ip;		/* Send the packet. */	sr_send_packet(sr, packet, len, interface);}

void sr_send_arpreq(struct sr_instance *sr, uint32_t ip, struct sr_if* iface) {    assert(iface);    const int pktlen = sizeof(sr_ethernet_hdr_t) + sizeof(sr_arp_hdr_t);    uint8_t* pktbuf = calloc(1, pktlen);    sr_fill_eth(pktbuf, NULL, iface->addr, ethertype_arp);    /* Fill ARP Request */    sr_arp_hdr_t *arp_hdr = (sr_arp_hdr_t *)(pktbuf + sizeof(sr_ethernet_hdr_t));    arp_hdr->ar_hrd = htons(1);         /* Hardware type : Ethernet(1) */    arp_hdr->ar_pro = htons(0x0800);    /* Protocol type : ARP (0x0800) */    arp_hdr->ar_hln = ETHER_ADDR_LEN;    arp_hdr->ar_pln = 4;    arp_hdr->ar_op  = htons(arp_op_request);    /* sender hardware address */    memcpy(arp_hdr->ar_sha, iface->addr, ETHER_ADDR_LEN);    arp_hdr->ar_sip = iface->ip;    /* sender ip address */    /* target hardware address */    memset(arp_hdr->ar_tha, 0, ETHER_ADDR_LEN);    arp_hdr->ar_tip = ip;           /* target ip address */    /* Send ARP Request */    sr_send_packet(sr, pktbuf, pktlen, iface->name);    free(pktbuf);}

/*--------------------------------------------------------------------- * Method: handle_arp_request * Scope: local * * Handles an ARP request sent to an interface. * *---------------------------------------------------------------------*/static void handle_arp_request(struct sr_instance *sr, struct sr_ethernet_hdr *ethernet_header,        struct sr_arphdr *arp_header, char *interface) {    printf("/tIt's an ARP request!/n");    // Get the interface address    struct sr_if* iface = sr_get_interface(sr, interface);    if ( iface == 0 ) {        fprintf( stderr, "** Error, interface %s, does not exist/n", interface);    }    // Create ARP reply :)    struct sr_arphdr arp_reply;    memcpy(&arp_reply, arp_header, sizeof(struct sr_arphdr));    arp_reply.ar_op = htons(ARP_REPLY);    memcpy(&arp_reply.ar_sha, iface->addr, ETHER_ADDR_LEN);    memcpy(&arp_reply.ar_tha, arp_header->ar_sha, ETHER_ADDR_LEN);    memcpy(&arp_reply.ar_sip, &(arp_header->ar_tip), sizeof(uint32_t));    memcpy(&arp_reply.ar_tip, &(arp_header->ar_sip), sizeof(uint32_t));    // Send the reply    uint8_t *buffer = pack_ethernet_packet(ethernet_header->ether_shost, iface->addr,            ETHERTYPE_ARP, (uint8_t *) &arp_reply, sizeof(struct sr_arphdr));    sr_send_packet(sr, buffer, sizeof(struct sr_ethernet_hdr) + sizeof(struct sr_arphdr),            interface);}

void ARP_request_send(struct sr_instance* sr,uint32_t gateway_IP,struct sr_if* interface){	/* Build both ethernet and ARP header for the request packet */	uint8_t* packet = (uint8_t*)malloc(sizeof(sr_ethernet_hdr_t) + sizeof(sr_arp_hdr_t));		/* Build ethernet header */	sr_ethernet_hdr_t* new_eth = (sr_ethernet_hdr_t*)packet;		memcpy(new_eth->ether_shost,interface->addr,sizeof(uint8_t)*6);	memset(new_eth->ether_dhost,255,sizeof(uint8_t)*6);	new_eth->ether_type = htons(ARP_PROTOCOL);	/* Build ARP header */	sr_arp_hdr_t* arp_reply_structure = (sr_arp_hdr_t*)(packet+sizeof(sr_ethernet_hdr_t));		arp_reply_structure->ar_op = htons(0x0001);	memcpy(arp_reply_structure->ar_sha,interface->addr,sizeof(uint8_t)*6);	bzero(arp_reply_structure->ar_tha,sizeof(uint8_t)*6);	arp_reply_structure->ar_sip = interface->ip;	arp_reply_structure->ar_tip = gateway_IP;	arp_reply_structure->ar_pro = htons(0x0800);	arp_reply_structure->ar_pln = 0x04;	arp_reply_structure->ar_hrd = htons(0x0001);	arp_reply_structure->ar_hln = 0x06;		/* Now everything is complete */	/* Now send the packet */	sr_send_packet(sr,packet,sizeof(sr_ethernet_hdr_t)+sizeof(sr_arp_hdr_t),interface->name);}

void sr_send_arpreply(struct sr_instance* sr,   sr_arp_hdr_t *arp_req,  struct sr_if* iface) {  const int pktlen = sizeof(sr_ethernet_hdr_t) + sizeof(sr_arp_hdr_t);  uint8_t pktbuf[pktlen];  sr_fill_eth(pktbuf, arp_req->ar_sha, iface->addr, ethertype_arp);  /* Fill ARP Reply */  sr_arp_hdr_t *arp_hdr = (sr_arp_hdr_t *)(pktbuf + sizeof(sr_ethernet_hdr_t));  arp_hdr->ar_hrd = htons(1);         /* Hardware type : Ethernet(1) */  arp_hdr->ar_pro = htons(0x0800);    /* Protocol type : ARP (0x0800) */  arp_hdr->ar_hln = ETHER_ADDR_LEN;  arp_hdr->ar_pln = 4;  arp_hdr->ar_op  = htons(arp_op_reply);  /* sender hardware address */  memcpy(arp_hdr->ar_sha, iface->addr, ETHER_ADDR_LEN);  arp_hdr->ar_sip = iface->ip; /* sender ip address */  /* target hardware address */  memcpy(arp_hdr->ar_tha, arp_req->ar_sha, ETHER_ADDR_LEN);  arp_hdr->ar_tip = arp_req->ar_sip;     /* target ip address */  /* Send ARP Reply */  sr_send_packet(sr, pktbuf, pktlen, iface->name);}

/* Tries to find ip address in arp cache. If found, sends ethernet frame. If not found,adds packet to arp queue */void sr_attempt_send(struct sr_instance *sr, uint32_t ip_dest,                                         uint8_t *frame,                                                  unsigned int frame_len,                                       char *iface){   struct sr_arpentry *entry = sr_arpcache_lookup(&(sr->cache), ip_dest);   if (entry){        unsigned char *mac_address = entry->mac;        memcpy( ((sr_ethernet_hdr_t *)frame)->ether_dhost, mac_address, ETHER_ADDR_LEN);        //free packet??        sr_send_packet(sr, frame, frame_len, iface);        free(entry);   }else{        fprintf(stderr, "Couldn't find entry for: ");        print_addr_ip_int(ntohl(ip_dest));       struct sr_arpreq *req = sr_arpcache_queuereq(&(sr->cache), ip_dest, frame, frame_len, iface);       sr_handle_arpreq(sr, req);   }}

void sr_icmp_echo_reply(struct sr_instance *sr, uint8_t * packet,			unsigned int len, char* interface,			struct sr_ethernet_hdr *e_hdr,			struct ip *ip_hdr, struct sr_icmphdr *icmp_hdr){  /* Ethernet header */  uint8_t addr_tmp[6];  memcpy(addr_tmp, e_hdr->ether_dhost, 6);  memcpy(e_hdr->ether_dhost, e_hdr->ether_shost, 6);  memcpy(e_hdr->ether_shost, addr_tmp, 6);  /* IP header */  struct in_addr ip_addr_tmp = ip_hdr->ip_src;  ip_hdr->ip_src = ip_hdr->ip_dst;  ip_hdr->ip_dst = ip_addr_tmp;  ip_hdr->ip_sum = 0;  ip_hdr->ip_sum = checksum(ip_hdr, sizeof(struct ip));  /* ICMP header */  icmp_hdr->icmp_type = 0x0;  icmp_hdr->icmp_chksum = 0x0;  icmp_hdr->icmp_chksum = checksum((uint16_t *)icmp_hdr,					ntohs(ip_hdr->ip_len) - 20);  int success = sr_send_packet(sr, packet, len, interface);  if (success != 0) {    fprintf(stderr, "%s: Sending packet failed!/n", __func__);  }}

void arpq_packets_icmpsend(struct sr_instance *sr, struct packetq *arpq_packets){    struct queued_packet *current_packet = arpq_packets->first;    struct frame_t *ICMP_err;        while(current_packet){        //first, make sure current packet isn't an ICMP error message itself        if (current_packet->outgoing->ip_header->ip_p == IPPROTO_ICMP){            current_packet->outgoing->icmp_header = ((void *) current_packet->outgoing->ip_header +                                                      current_packet->outgoing->ip_hl);            uint8_t code = current_packet->outgoing->icmp_header->icmp_type;            if (code == DEST_UNREACH || code == TIME_EXCEEDED || code == 12 || code == 31)                //12 and 31 indicate bad IP header and datagram conversion error, respectively                continue;        }        //get back old info so we can send it back the way it came        current_packet->outgoing->iface = current_packet->from_iface;        memcpy(current_packet->outgoing->from_MAC, current_packet->from_MAC, ETHER_ADDR_LEN);                ICMP_err = generate_icmp_error(current_packet->outgoing, DEST_UNREACH, HOST_UNREACH);                printf("sending Host Unreachable packets/n");        sr_send_packet(sr, (uint8_t *)current_packet->outgoing->frame,                        current_packet->outgoing->len,                        current_packet->from_iface->name);                destroy_frame_t(ICMP_err);        current_packet = current_packet->next;    }}

/*Expects entire ethernet frame and ARP header still in network order. */void handle_arp_reply(struct sr_instance *sr, uint8_t *pkt) {  struct sr_if *requested_inf = find_interface_with_ip(sr, ntohl(get_arp_hdr(pkt)->ar_tip));  if (!requested_inf) {    /*Only cache entry if the target IP is one of the router's addresses*/    return;  }  struct sr_arpreq *arpreq = sr_arpcache_insert(&(sr->cache), get_arp_hdr(pkt)->ar_sha, get_arp_hdr(pkt)->ar_sip);  if (arpreq) {    struct sr_packet *outgoing_pkt = arpreq->packets;    while (outgoing_pkt) {      sr_ethernet_hdr_t *eth_hdr = get_ethernet_hdr(outgoing_pkt->buf);            sr_arp_hdr_t *incoming_arp_hdr = get_arp_hdr(pkt);            memcpy(eth_hdr->ether_dhost, incoming_arp_hdr->ar_sha, ETHER_ADDR_LEN);      sr_send_packet(sr, outgoing_pkt->buf, outgoing_pkt->len, outgoing_pkt->iface);      outgoing_pkt = outgoing_pkt->next;    }    free(pkt);    sr_arpreq_destroy(&(sr->cache), arpreq);  }}

void sr_handle_arpreq(struct sr_instance *sr, struct sr_arpreq *req) {	time_t curtime = time(NULL);	if (difftime(curtime, req->sent) < 1.0) return;	if (req->times_sent <= 4) {		/* Find out which interface it's on */		char *interface = req->packets->iface;		struct sr_if* iface = sr_get_interface(sr, interface);		/* Allocate a new packet */		size_t out_len = ARP_REPLY_SIZE;		uint8_t *packet_out = malloc(out_len);		/* ====== Headers ====== */		/* Allow easy access to the headers */		sr_ethernet_hdr_t *eth_header_out = (sr_ethernet_hdr_t*) packet_out;		sr_arp_hdr_t *arp_header_out = 				(sr_arp_hdr_t*) (packet_out + ARP_HEAD_OFF);		/* Create the ethernet header */		char bcast_addr[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};		memcpy(eth_header_out->ether_dhost, bcast_addr, 				ETHER_ADDR_LEN);		memcpy(eth_header_out->ether_shost, iface->addr, 				ETHER_ADDR_LEN);		eth_header_out->ether_type = htons(ethertype_arp);		/* ====== Body ====== */		/* Create the ARP packet */		arp_header_out->ar_hrd = htons(0x1);		arp_header_out->ar_pro = htons(ethertype_ip);		arp_header_out->ar_hln = ETHER_ADDR_LEN;		arp_header_out->ar_pln = IP_ADDR_LEN;		arp_header_out->ar_op = htons(arp_op_request);		memcpy(arp_header_out->ar_sha, iface->addr, ETHER_ADDR_LEN);		arp_header_out->ar_sip = iface->ip;		char zeroes[] = {0,0,0,0,0,0};		memcpy(arp_header_out->ar_tha, 				zeroes, ETHER_ADDR_LEN);		arp_header_out->ar_tip = req->ip;		/* Send the packet */		sr_send_packet(sr, packet_out, out_len, interface);		free(packet_out);		return;	} else {		struct sr_packet *packet = req->packets;		while (packet) {			struct sr_packet *next = packet->next;			send_icmp_error(sr, packet->buf, packet->len, packet->iface, 3, 1);			packet = next;		}		sr_arpreq_destroy(&(sr->cache), req);	}	return;}

/*sends packet, checks any errors and frees buffer */void sendPacket(struct sr_instance* sr, uint8_t* buf, char* iface, int len){  //send out icmp packet now  //Send packet  int ret = sr_send_packet(sr, buf, len, iface);  if (ret != 0){    fprintf(stderr, "Didn't send packet properly/n");  }  free(buf); }

int sr_integ_low_level_output(struct sr_instance* sr /* borrowed */,                             uint8_t* buf /* borrowed */ ,                             unsigned int len,                             const char* iface /* borrowed */){#ifdef _CPUMODE_    return sr_cpu_output(sr, buf /*lent*/, len, iface);#else    return sr_send_packet(sr, buf /*lent*/, len, iface);#endif /* _CPUMODE_ */} /* -- sr_vns_integ_output -- */

int sr_handle_arpreq(struct sr_instance *sr, struct sr_arpreq *request){   time_t now = get_now(&now);   struct sr_packet * packetptr = request->packets;   int i;   if(difftime(now, request->sent) > 1.0){      if(request->times_sent >= 5){         while(packetptr != NULL){             icmp_send_reply(sr, (uint8_t *)packetptr, packetptr->len, packetptr->iface, 3, 1); /* send unreachable */             packetptr = packetptr->next;         }         sr_arpreq_destroy(&(sr->cache), request);         return -1;      }else{           struct sr_rt* entry;           struct sr_rt* routing = sr->routing_table;           for(entry = routing; entry != NULL; entry = routing->next){             struct sr_if * interface2 = sr_get_interface(sr, entry->interface);             /*create arp packet*/             enum sr_arp_opcode opcode = arp_op_request;             struct sr_packet *raw = malloc(sizeof(struct sr_arp_hdr) + ETHER_HDR_LEN);             /* may need to memset here*/             struct sr_ethernet_hdr *eth = (struct sr_ethernet_hdr *)raw;             struct sr_arp_hdr *req = (struct sr_arp_hdr *)(raw + ETHER_HDR_LEN);             req->ar_hrd = 0;             req->ar_pro = 0;             req->ar_hln = 0;             req->ar_pln = 0;             req->ar_op = opcode;             req->ar_sip = sr->sr_addr.sin_addr.s_addr;             req->ar_tip = request->ip;             for (i = 0; i < ETHER_ADDR_LEN; i++){                 req->ar_tha[i] = 0xff;                 req->ar_sha[i] = interface2->addr[i];                 eth->ether_dhost[i] = 0xff;                 eth->ether_shost[i] = interface2->addr[i];             }             /*send packet to the interface on routing_table*/             sr_send_packet(sr, (uint8_t *)raw, sizeof(struct sr_arp_hdr) + ETHER_HDR_LEN, request->packets->iface);             free(raw);            }         request->sent = now;         request->times_sent++;      }   }   return 0;}

void handle_arpreq(struct sr_instance *sr, struct sr_arpreq *req) {	time_t now = time(NULL);	if (difftime(now, req->sent) >= 0.9) {		if (req->times_sent >= 5) {			struct sr_packet *pkt_pending = req->packets;			struct sr_if *interface = sr_get_interface(sr, pkt_pending->iface);			while (pkt_pending) {				icmp_handler(sr, pkt_pending->buf, 0, interface->ip, HOST_UNREACHABLE);				pkt_pending = pkt_pending->next;			}			sr_arpreq_destroy(&(sr->cache), req);		}		else {			int packet_len = sizeof(sr_ethernet_hdr_t) + sizeof(sr_arp_hdr_t);			uint8_t *pkt = malloc(packet_len);			struct sr_ethernet_hdr *eth_hdr = (struct sr_ethernet_hdr *)pkt;			struct sr_if *interface = sr_get_interface(sr, req->packets->iface);			uint8_t hrd_addr[ETHER_ADDR_LEN] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};			enum sr_ethertype eth_arp = ethertype_arp;			enum sr_ethertype eth_ip = ethertype_ip;			memcpy(eth_hdr->ether_dhost, hrd_addr, ETHER_ADDR_LEN);			memcpy(eth_hdr->ether_shost, interface->addr, ETHER_ADDR_LEN);			eth_hdr->ether_type = htons(eth_arp);			struct sr_arp_hdr *arp_hdr = (struct sr_arp_hdr *)(sizeof(sr_ethernet_hdr_t) + pkt);			enum sr_arp_hrd_fmt hrd_eth = arp_hrd_ethernet;			enum sr_arp_opcode arp_op_req = arp_op_request;			arp_hdr->ar_hrd = htons(hrd_eth);			arp_hdr->ar_pro = htons(eth_ip);			arp_hdr->ar_hln = ETHER_ADDR_LEN;			arp_hdr->ar_pln = 4;			arp_hdr->ar_op = htons(arp_op_req);			arp_hdr->ar_sip = interface->ip;			arp_hdr->ar_tip = req->ip;			memcpy(arp_hdr->ar_sha, interface->addr, ETHER_ADDR_LEN);			memcpy(arp_hdr->ar_tha, hrd_addr, ETHER_ADDR_LEN);			printf("Sending Packets.. [3]./n");			sr_send_packet(sr, pkt, packet_len, interface->name);			free(pkt);			req->sent = now;			req->times_sent++;		}	}}

void handle_arp_reply(struct sr_instance *sr, uint8_t* ethernet_data_addr, struct sr_if* in_f){  printf("in handle arp reply/n");/*  The ARP reply processing code should move entries from the ARP request   queue to the ARP cache:   # When servicing an arp reply that gives us an IP->MAC mapping   req = arpcache_insert(ip, mac)   if req:       send all packets on the req->packets linked list       arpreq_destroy(req)*/  /*Loop through sr_cache requests and look for an IP match to the ARP header source IP*/  sr_arp_hdr_t *arp_header = (sr_arp_hdr_t *) ethernet_data_addr;  struct sr_arpreq *req_ptr = sr_arpcache_insert(&(sr->cache), arp_header->ar_sha, arp_header->ar_sip);  /*If the IP in the reply matched something in our request queue*/  if (req_ptr) {    struct sr_packet *req_pkts = req_ptr->packets;    struct sr_packet *req_pkt_ptr = req_pkts;    for (; req_pkt_ptr; req_pkt_ptr = req_pkt_ptr->next) {      sr_ethernet_hdr_t *packet_eth_hdr = (sr_ethernet_hdr_t *) req_pkts->buf;      sr_ip_hdr_t *packet_ip_hdr = (sr_ip_hdr_t *) (req_pkts->buf + sizeof(sr_ethernet_hdr_t));      /*ret_if will be populated if this was originally an echo request, else 0*/      struct sr_if* ret_if = sr_get_interface_from_ip(sr, packet_ip_hdr->ip_dst);            if (ret_if) {        /*Doesn't have a code so just passing 0 as code*/        send_icmp_echo_reply(sr, (uint8_t *) packet_eth_hdr, req_pkt_ptr->len, in_f, arp_header->ar_sha, echo_reply_type, 0);      }            else {        memcpy(packet_eth_hdr->ether_dhost, arp_header->ar_sha, ETHER_ADDR_LEN);        sr_send_packet(sr, (uint8_t *) packet_eth_hdr, req_pkt_ptr->len, in_f->name);      }     }    sr_arpreq_destroy(&(sr->cache), req_ptr);  }  /*Otherwise do nothing, the reply wasn't about anything in our queue*/}

/*Returns 0 on success and error code on fail*/int sr_handlearp(struct sr_instance** sr, uint8_t** ethernet_data_addr, struct sr_if* in_f, unsigned int len){  uint8_t *eth_pkt_buf;  uint8_t *arp_pkt_buf; /* ARP packet buffer */  struct sr_if* ret_if; /* return interface */  printf("sr_handlearp");  sr_arp_hdr_t* arp_header_buffer = (sr_arp_hdr_t*)*ethernet_data_addr;  ntoh_arp_hdr(&arp_header_buffer); /* converts header members into host byte order where appropriate */  /* Recieved ARP request! Reply to request. */  if(arp_header_buffer->ar_op == arp_op_request) {    if ((ret_if = sr_get_interface_from_ip(*sr, arp_header_buffer->ar_tip))) { /* Target IP is IP of a Router Interface*/             /* Send an ARP reply (uint8_t*) */      /* Create reply frame */      eth_pkt_buf = (uint8_t *) malloc(sizeof(sr_ethernet_hdr_t) + sizeof(sr_arp_hdr_t)); /* Allocate mem for reply packet buffer */      sr_ethernet_hdr_t *req_reply_eth_header = (sr_ethernet_hdr_t *) eth_pkt_buf;      /* Build Ethernet Header */      memcpy(req_reply_eth_header->ether_dhost, arp_header_buffer->ar_sha, ETHER_ADDR_LEN);      memcpy(req_reply_eth_header->ether_shost, in_f->addr, ETHER_ADDR_LEN);      req_reply_eth_header->ether_type = ethertype_arp;      /* Convert to network byte ordering */      hton_eth_hdr(&req_reply_eth_header);      /* Get the Arp Buffer and Build the Arp packet*/      arp_pkt_buf = eth_pkt_buf + sizeof(sr_ethernet_hdr_t);      sr_create_arp_packet(&arp_pkt_buf, arp_header_buffer, ret_if); /* Create arp packet to be sent as ARP reply, fill arp_pkt_buf with ARP reply header data */            /* Send the ARP reply packet */      sr_send_packet(*sr, eth_pkt_buf, sizeof(sr_ethernet_hdr_t) + sizeof(sr_arp_hdr_t), in_f->name);      free(eth_pkt_buf);    } else { /* Target IP is *NOT* IP of a Router Interface */      /* I'm not sure what to do here yet MAYBE NOTHING?!*/    }  }  else if (arp_header_buffer->ar_op == arp_op_reply) {    handle_arp_reply(*sr, *ethernet_data_addr, in_f);  }    return 0;}

/* prepare arp into ethernet frame and send it */int boardcast_arpreq(struct sr_instance *sr, struct sr_arpreq *arp_req){    struct sr_if *o_interface;    /*first package the arp package header first...*/    o_interface = sr_get_interface(sr, arp_req->packets->iface);    struct sr_arp_hdr arp_hdr;    uint8_t *arp_package;    uint8_t *e_pack;    arp_hdr.ar_hrd = sr_arp_hrd_fmt hfmt = arp_hrd_ethernet;             /* format of hardware address   */    arp_hdr.ar_pro = 0X800;            /*from http:/*www.networksorcery.com/enp/protocol/arp.htm#Protocol%20address%20length*/    arp_hdr.ar_hln = ETHER_ADDR_LEN = 8; /*from http:/*www.networksorcery.com/enp/protocol/arp.htm#Protocol%20address%20length*/    arp_hdr.ar_pln = 8;             /*from http:/*www.networksorcery.com/enp/protocol/arp.htm#Protocol%20address%20length*/    sr_arp_opcode code = arp_op_request;    arp_hdr.ar_op = code;              /* ARP opcode (command)         */    memcpy(arp_hdr.ar_sha, o_interface->addr, ETHER_ADDR_LEN); /* sender hardware address      */    arp_hdr.ar_sip = o_interface.ip;             /* sender IP address            */    arp_hdr.ar_tip = arp_req.ip;                 /* target IP address            */    /*copy everything into the arp_header*/    arp_package = malloc(sizeof(sr_arp_hdr_t));    print_hdr_arp(arp_package);    memcpy(arp_package, &apr_hdr, sizeof(sr_arp_hdr_t));    /*then package the ethernet header along with the arp header...*/    e_pack = eth_hdr_package(uint8_t  ether_dhost, sr, o_interface->addr, arp_package, sizeof(struct sr_arp_hdr));    print_hdr_eth(e_pack);    /*send it out*/    sr_send_packet(sr, e_pack, sizeof(struct sr_arp_hdr) + sizeof(struct sr_ethernet_hdr), o_interface);/* build the ethernet frame to be broadcast */int eth_hdr_package(uint8_t  ether_dhost, uint8_t  ether_shost, uint16_t ether_type, uint8_t *content, int len){    uint8_t *output;    int total_length;    struct sr_ethernet_hdr e_hdr;    /*first step is to create a ethernet header...*/    memcpy(e_hdr.ether_dhost,ether_dhost,ETHER_ADDR_LEN); /* destination ethernet address */    memcpy(e_hdr.ether_shost,ether_shost,ETHER_ADDR_LEN); /* source ethernet address */    e_hdr.ether_type = ether_type;    /*calculate the length of the entire thing...*/    total_length = sizeof(sr_ethernet_hdr_t) + len;    /*put everything together*/    output = malloc(total_length);    /*put the ethernet header in the front*/    memcpy(output, &e_hdr, sizeof(sr_ethernet_hdr_t));    memcpy(output + sizeof(sr_ethernet_hdr_t), content,len);    return output;    }

void handle_arpreq(struct sr_instance* sr, struct sr_arpreq *cache_req_ptr) {  char *iface_name = cache_req_ptr->packets->iface;  struct sr_if *interface = sr_get_interface(sr, iface_name);  /*Only broadcast if this hasn't been sent out before:    *Otherwise, our packet has been added to the end of the   * request's linkedlist in the cache: do nothing*/  if (difftime(time(0), cache_req_ptr->sent) > 1.0) {    if (cache_req_ptr->times_sent >= 5) {      struct sr_packet *req_pkt_ptr = cache_req_ptr->packets;      for (; req_pkt_ptr; req_pkt_ptr = req_pkt_ptr->next) {        send_icmp(sr, req_pkt_ptr->buf, req_pkt_ptr->len, interface, dest_host_unreach_type, dest_host_unreach_code);      }      sr_arpreq_destroy(&(sr->cache), cache_req_ptr);    }    else {      /*Create space for the request*/      uint8_t* eth_pkt_buf = (uint8_t *) malloc(sizeof(sr_ethernet_hdr_t) + sizeof(sr_arp_hdr_t));      uint8_t* arp_pkt_buf;      /*Pointers to where different header structs start in the packet*/      sr_ethernet_hdr_t* req_eth_header = (sr_ethernet_hdr_t*) eth_pkt_buf; /* Allocate mem for reply packet buffer */            /* Copy addresses and type into the ethernet header */      uint8_t broadcast_addr[ETHER_ADDR_LEN] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };      memcpy(req_eth_header->ether_dhost, broadcast_addr, ETHER_ADDR_LEN);      memcpy(req_eth_header->ether_shost, interface->addr, ETHER_ADDR_LEN);      req_eth_header->ether_type = ethertype_arp;            /* Convert to network byte ordering */      hton_eth_hdr(&req_eth_header);      /* Get the Arp Buffer and Build the Arp packet*/      arp_pkt_buf = eth_pkt_buf + sizeof(sr_ethernet_hdr_t);      sr_create_arp_req_packet(arp_pkt_buf, cache_req_ptr, interface);      /* Send the ARP request packet */      sr_send_packet(sr, eth_pkt_buf, sizeof(sr_ethernet_hdr_t) + sizeof(sr_arp_hdr_t),        interface->name);      cache_req_ptr->sent = time(0);      cache_req_ptr->times_sent++;      free(eth_pkt_buf);    }  }}

void sr_icmp_ttl_exceeded(struct sr_instance *sr, uint8_t * packet,			  unsigned int len, char* interface,			  struct sr_ethernet_hdr *e_hdr, struct ip *ip_hdr){  struct sr_if *iface = sr_get_interface(sr, interface);    /* Send ICMP time exceeded message. This is     need for traceroute to work. */  uint8_t *new_pkt = (uint8_t *) calloc(1, 70);  struct sr_ethernet_hdr *new_e_hdr = (struct sr_ethernet_hdr *) new_pkt;  struct ip *new_ip_hdr = (struct ip *) (new_pkt + 14);  struct sr_icmphdr *new_icmp_hdr = (struct sr_icmphdr *) (new_pkt + 34);  /* ethernet header */  memcpy(new_e_hdr->ether_dhost, e_hdr->ether_shost, 6);  memcpy(new_e_hdr->ether_shost, e_hdr->ether_dhost, 6);  new_e_hdr->ether_type = htons(0x0800);  /* IP header */  new_ip_hdr->ip_hl = 5;  new_ip_hdr->ip_v = 4;  new_ip_hdr->ip_tos = 0;  new_ip_hdr->ip_len = htons(56);  new_ip_hdr->ip_id = ip_hdr->ip_id;  new_ip_hdr->ip_off = ip_hdr->ip_off;  new_ip_hdr->ip_ttl = 64;  new_ip_hdr->ip_p = 1;  new_ip_hdr->ip_src.s_addr = iface->ip;  new_ip_hdr->ip_dst = ip_hdr->ip_src;  new_ip_hdr->ip_sum = 0;  new_ip_hdr->ip_sum = checksum(new_ip_hdr, 20);  /* ICMP ttl exceeded: type: 11, code: 0 */  new_icmp_hdr->icmp_type = 11;  new_icmp_hdr->icmp_code = 0;  new_icmp_hdr->id = 0;  new_icmp_hdr->seqno = 0;  memcpy(new_pkt+42, ip_hdr, 28);  new_icmp_hdr->icmp_chksum = 0;  new_icmp_hdr->icmp_chksum = checksum((uint16_t *)new_icmp_hdr, 36);  int success = sr_send_packet(sr, new_pkt, 70, interface);  if (success != 0) {    fprintf(stderr, "%s: Sending packet failed!/n", __func__);  }}

/* * Send an ICMP Error. */void send_icmp_error(uint8_t type, uint8_t code, struct sr_instance *sr, 					char *interface, unsigned int len, uint8_t *pkt) {		int new_len = sizeof(sr_ethernet_hdr_t) + sizeof(sr_ip_hdr_t) + sizeof(sr_icmp_t3_hdr_t);	uint8_t *packet = (uint8_t *) malloc(new_len);	struct sr_if *rt_if = (struct sr_if *)malloc(sizeof(struct sr_if));	rt_if = (struct sr_if *)sr_get_interface(sr, interface);		/* Prepare ethernet header. */	sr_ethernet_hdr_t *ether_hdr = (sr_ethernet_hdr_t *) pkt;	sr_ethernet_hdr_t *ether_newhdr = (sr_ethernet_hdr_t *) packet;	ether_newhdr->ether_type = htons(ethertype_ip);	memcpy(ether_newhdr->ether_shost, rt_if->addr, ETHER_ADDR_LEN);	memcpy(ether_newhdr->ether_dhost, ether_hdr->ether_shost, ETHER_ADDR_LEN); 			/* Prepare IP header. */	sr_ip_hdr_t *ip_hdr = (sr_ip_hdr_t *)(pkt + sizeof(sr_ethernet_hdr_t));	sr_ip_hdr_t *ip_newhdr = (sr_ip_hdr_t *)(packet + sizeof(sr_ethernet_hdr_t));	memcpy(ip_newhdr, ip_hdr, sizeof(sr_ip_hdr_t));	ip_newhdr->ip_src = rt_if->ip;	ip_newhdr->ip_dst = ip_hdr->ip_src;	ip_newhdr->ip_len = htons(56);	ip_newhdr->ip_id = 0;	ip_newhdr->ip_hl = 5;	ip_newhdr->ip_off = 0;	ip_newhdr->ip_ttl = 64;	ip_newhdr->ip_p = ip_protocol_icmp;	ip_newhdr->ip_sum = 0;	ip_newhdr->ip_sum = cksum(packet + sizeof(sr_ethernet_hdr_t), sizeof(sr_ip_hdr_t));									/* Prepare the ICMP t3 header. */	sr_icmp_t3_hdr_t *icmp_t3_hdr = (sr_icmp_t3_hdr_t *)(packet + 									sizeof(sr_ethernet_hdr_t) + 									sizeof(sr_ip_hdr_t));	icmp_t3_hdr->icmp_type = type;	icmp_t3_hdr->icmp_code = code;	icmp_t3_hdr->icmp_sum = 0;	memcpy(icmp_t3_hdr->data,  ip_hdr, 20);	memcpy(icmp_t3_hdr->data + 20, pkt + sizeof(sr_ethernet_hdr_t) + sizeof(sr_ip_hdr_t), 8); 	icmp_t3_hdr->icmp_sum = cksum(packet + sizeof(sr_ethernet_hdr_t) + sizeof(sr_ip_hdr_t), 							sizeof(sr_icmp_t3_hdr_t));		/* Send the ICMP error packet. */	sr_send_packet(sr, packet, new_len, interface);}

void sr_icmp_port_unreach(struct sr_instance *sr, uint8_t * packet,			  unsigned int len, char* interface,			  struct sr_ethernet_hdr *e_hdr, struct ip *ip_hdr){  /* 70: minimum length for ICMP port unreachable reply. */  uint8_t *new_pkt = (uint8_t *) calloc(1, 70); // hardcoded constant! anyway...      struct sr_ethernet_hdr *new_e_hdr = (struct sr_ethernet_hdr *) new_pkt;  struct ip *new_ip_hdr = (struct ip *) (new_pkt + 14);  struct sr_icmphdr *new_icmp_hdr = (struct sr_icmphdr *) (new_pkt + 34);  /* ethernet header */  memcpy(new_e_hdr->ether_dhost, e_hdr->ether_shost, 6);  memcpy(new_e_hdr->ether_shost, e_hdr->ether_dhost, 6);  new_e_hdr->ether_type = htons(0x0800);  /* IP header */  new_ip_hdr->ip_hl = 5;  new_ip_hdr->ip_v = 4;  new_ip_hdr->ip_tos = 0;  new_ip_hdr->ip_len = htons(56); // hardcoded constant! anyway...  new_ip_hdr->ip_id = ip_hdr->ip_id;  new_ip_hdr->ip_off = ip_hdr->ip_off;  new_ip_hdr->ip_ttl = 64;  new_ip_hdr->ip_p = 1;  new_ip_hdr->ip_src = ip_hdr->ip_dst;  new_ip_hdr->ip_dst = ip_hdr->ip_src;  new_ip_hdr->ip_sum = 0;  new_ip_hdr->ip_sum = checksum(new_ip_hdr, 20);  /* ICMP port unreachable */  new_icmp_hdr->icmp_type = 3;  new_icmp_hdr->icmp_code = 3;  new_icmp_hdr->id = 0;  new_icmp_hdr->seqno = 0;  memcpy(new_pkt+42, ip_hdr, 28);  new_icmp_hdr->icmp_chksum = 0;  new_icmp_hdr->icmp_chksum = checksum((uint16_t *)new_icmp_hdr, 36);  int success = sr_send_packet(sr, new_pkt, 70, interface);  if (success != 0) {    fprintf(stderr, "%s: Sending packet failed!/n", __func__);  }}

/*  Send a host unreachable ICMP to the given source address*/void send_echo_reply(uint8_t source_addr, uint8_t *packet, struct sr_instance *sr){    /*Allocate a buffer to hold the packet*/  uint8_t *buf = malloc(sizeof(sr_ethernet_hdr_t) + sizeof(sr_ip_hdr_t) + sizeof(sr_icmp_hdr_t));    /*Create and send the host unreachable ICMP TO source, telling them that dest was unreachable*/  /*First have to create the ICMP packet*/  sr_icmp_t3_hdr_t *icmp_packet = (sr_icmp_hdr_t *)(buf + sizeof(sr_ip_hdr_t) + sizeof(sr_ethernet_hdr_t));  icmp_packet->icmp_type = 1;  icmp_packet->icmp_code = 1;  icmp_packet->icmp_sum = 0;  icmp_packet->icmp_sum = cksum((const void *)(icmp_packet.icmp_type + icmp_packet.icmp_code), 2);  print_hdr_icmp(icmp_packet);  /*Have to craft data.  Data will be the original packet header plus the first 8 bytes of the packet content.*/  memcpy(icmp_packet->data, packet, ICMP_DATA_SIZE);    /*Now have to form the ip packet to encase the icmp content*/  sr_ip_hdr_t *ip_packet = (sr_ip_hdr_t *)(buf + sizeof(sr_ethernet_hdr_t));  ip_packet->ip_p = 1;  ip_packet->ip_tos;            /* type of service */  ip_packet->ip_len;            /* total length */  ip_packet->ip_id;         /* identification */  ip_packet->ip_off;            /* fragment offset field */  ip_packet->ip_ttl;            /* time to live */  ip_packet->ip_p = 1;          /* protocol */  ip_packet->ip_sum;            /* checksum */  ip_packet->ip_src = sr->if_list[0]->ip;  /*Assign the packet source to one of the router's interfaces*/  ip_packet->ip_dst = get_ip_addr(packet);  /*set the packet destination to the original source IP*/  print_hdr_ip(ip_packet);  memcpy((void *)arp_packet->ar_sha, (void *)sender_eth, ETHER_ADDR_LEN);  /*Now make an ethernet frame to wrap the IP packet with the ICMP packet*/  sr_ethernet_hdr_t *ether_packet = (sr_ethernet_hdr_t *)(buf);  ether_packet->ether_dhost = source_addr;  /*Set ethernet destination*/  ether_packet->ether_shost = sr->if_list[0]->addr;  /*Set ethernet source*/  ether_packet->ether_type = sr_ethertype.ethertype_ip;  print_hdr_eth(ether_packet);  print_hdr_icmp(uint8_t *buf);  /*Now send off the packet*/  int size = 32+20+8+28; /*Size of the packet. Ether header = 32, ip header = 20, ICMP header = 8, ICMP data = 28.*/  sr_send_packet(sr, buf, size, sr->if_list);  }

int send_arp_response(struct sr_instance * sr, struct sr_if * assoc_iface, uint8_t * packet, unsigned int len) {      int res;       /* we have a MAC address */      uint8_t newpacket[len];      memcpy(newpacket, packet, len);      struct sr_arp_hdr * new_arp_hdr = (sr_arp_hdr_t *)(newpacket + sizeof(sr_ethernet_hdr_t));      struct sr_ethernet_hdr* ether_hdr = (struct sr_ethernet_hdr *) newpacket;      /* send it back to whoever sent it (ethernet) */      memcpy(ether_hdr->ether_dhost, ether_hdr->ether_shost, ETHER_ADDR_LEN);      /* make sure the ethernet packet header is updated with the new mac */      memcpy(ether_hdr->ether_shost, assoc_iface->addr, ETHER_ADDR_LEN);      /* take the old sender address and make it the target */      memcpy(new_arp_hdr->ar_tha, new_arp_hdr->ar_sha, ETHER_ADDR_LEN);      /* load in the discovered MAC address as the sender address */      memcpy(new_arp_hdr->ar_sha, assoc_iface->addr, ETHER_ADDR_LEN);      uint32_t temp = new_arp_hdr->ar_tip;      /* send it back to the IP we got it from */      new_arp_hdr->ar_tip = new_arp_hdr->ar_sip;      /* replace IP with what it was sent to */      new_arp_hdr->ar_sip = temp;      /* set arp op to reply */      new_arp_hdr->ar_op = htons(arp_op_reply);          res = sr_send_packet(sr, newpacket, len, assoc_iface->name);      if (res != 0) {                      return -1;      }      return 0;}