src/netif/etharp.c - third_party/lwip - Git at Google

 /*
  * Copyright (c) 2001, 2002 Swedish Institute of Computer Science.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modification,
  * are permitted provided that the following conditions are met:
  *
  * 1. Redistributions of source code must retain the above copyright notice,
  *    this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright notice,
  *    this list of conditions and the following disclaimer in the documentation
  *    and/or other materials provided with the distribution.
  * 3. The name of the author may not be used to endorse or promote products
  *    derived from this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
  * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
  * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
  *
  * This file is part of the lwIP TCP/IP stack.
  *
  * Author: Adam Dunkels <adam@sics.se>
  *
  *
  */

 #include "lwip/opt.h"
 #include "lwip/debug.h"
 #include "lwip/inet.h"
 #include "netif/etharp.h"
 #include "lwip/ip.h"
 #include "lwip/stats.h"

 #if LWIP_DHCP
 #  include "lwip/dhcp.h"
 #endif


 #define ARP_MAXAGE 120  /* 120 * 10 seconds = 20 minutes. */
 #define ARP_MAXPENDING 2 /* 2 * 10 seconds = 20 seconds. */

 #define HWTYPE_ETHERNET 1

 #define ARP_REQUEST 1
 #define ARP_REPLY 2

 /* MUST be compiled with "pack structs" or equivalent! */
 PACK_STRUCT_BEGIN
 struct etharp_hdr {
   PACK_STRUCT_FIELD(struct eth_hdr ethhdr);
   PACK_STRUCT_FIELD(u16_t hwtype);
   PACK_STRUCT_FIELD(u16_t proto);
   PACK_STRUCT_FIELD(u16_t _hwlen_protolen);
   PACK_STRUCT_FIELD(u16_t opcode);
   PACK_STRUCT_FIELD(struct eth_addr shwaddr);
   PACK_STRUCT_FIELD(struct ip_addr sipaddr);
   PACK_STRUCT_FIELD(struct eth_addr dhwaddr);
   PACK_STRUCT_FIELD(struct ip_addr dipaddr);
 } PACK_STRUCT_STRUCT;
 PACK_STRUCT_END

 #define ARPH_HWLEN(hdr) (NTOHS((hdr)->_hwlen_protolen) >> 8)
 #define ARPH_PROTOLEN(hdr) (NTOHS((hdr)->_hwlen_protolen) & 0xff)


 #define ARPH_HWLEN_SET(hdr, len) (hdr)->_hwlen_protolen = HTONS(ARPH_PROTOLEN(hdr) | ((len) << 8))
 #define ARPH_PROTOLEN_SET(hdr, len) (hdr)->_hwlen_protolen = HTONS((len) | (ARPH_HWLEN(hdr) << 8))

 PACK_STRUCT_BEGIN
 struct ethip_hdr {
   PACK_STRUCT_FIELD(struct eth_hdr eth);
   PACK_STRUCT_FIELD(struct ip_hdr ip);
 };
 PACK_STRUCT_END

 enum etharp_state {
   ETHARP_STATE_EMPTY,
   ETHARP_STATE_PENDING,
   ETHARP_STATE_STABLE
 };

 struct etharp_entry {
   struct ip_addr ipaddr;
   struct eth_addr ethaddr;
   enum etharp_state state;
   struct pbuf *p;
   void *payload;
   u16_t len, tot_len;
   u8_t ctime;
 };

 static const struct eth_addr ethbroadcast = {{0xff,0xff,0xff,0xff,0xff,0xff}};
 static struct etharp_entry arp_table[ARP_TABLE_SIZE];
 static u8_t ctime;

 /*-----------------------------------------------------------------------------------*/
 void
 etharp_init(void)
 {
   u8_t i;

   for(i = 0; i < ARP_TABLE_SIZE; ++i) {
     arp_table[i].state = ETHARP_STATE_EMPTY;
   }
 }
 /*-----------------------------------------------------------------------------------*/
 void
 etharp_tmr(void)
 {
   u8_t i;

   ++ctime;
   for(i = 0; i < ARP_TABLE_SIZE; ++i) {
     if(arp_table[i].state == ETHARP_STATE_STABLE &&
        ctime - arp_table[i].ctime >= ARP_MAXAGE) {
       DEBUGF(ETHARP_DEBUG, ("etharp_timer: expired stable entry %d.\n", i));
       arp_table[i].state = ETHARP_STATE_EMPTY;
     } else if(arp_table[i].state == ETHARP_STATE_PENDING &&
 	      ctime - arp_table[i].ctime >= ARP_MAXPENDING) {
       DEBUGF(ETHARP_DEBUG, ("etharp_timer: expired pending entry %d - dequeueing %p.\n", i, arp_table[i].p));
       arp_table[i].state = ETHARP_STATE_EMPTY;
       pbuf_free(arp_table[i].p);
     }
   }
 }
 /*----------------------------------------------------------------------------------*/
 static u8_t
 find_arp_entry(void)
 {
   u8_t i, j, maxtime;

   /* Try to find an unused entry in the ARP table. */
   for(i = 0; i < ARP_TABLE_SIZE; ++i) {
     if(arp_table[i].state == ETHARP_STATE_EMPTY) {
       break;
     }
   }

   /* If no unused entry is found, we try to find the oldest entry and
      throw it away. */
   if(i == ARP_TABLE_SIZE) {
     maxtime = 0;
     j = 0;
     for(i = 0; i < ARP_TABLE_SIZE; ++i) {
       if(arp_table[i].state == ETHARP_STATE_STABLE &&
 	 ctime - arp_table[i].ctime > maxtime) {
 	maxtime = ctime - arp_table[i].ctime;
 	j = i;
       }
     }
     i = j;
   }
   return i;
 }
 /*-----------------------------------------------------------------------------------*/
 static struct pbuf *
 update_arp_entry(struct ip_addr *ipaddr, struct eth_addr *ethaddr)
 {
   u8_t i, k;
   struct pbuf *p;
   struct eth_hdr *ethhdr;

   /* Walk through the ARP mapping table and try to find an entry to
      update. If none is found, the IP -> MAC address mapping is
      inserted in the ARP table. */
   for(i = 0; i < ARP_TABLE_SIZE; ++i) {
     /* Check if the source IP address of the incoming packet matches
        the IP address in this ARP table entry. */
     if(ip_addr_cmp(ipaddr, &arp_table[i].ipaddr)) {

       /* First, check those entries that are already in use. */
       if(arp_table[i].state == ETHARP_STATE_STABLE) {
 	/* An old entry found, update this and return. */
 	for(k = 0; k < 6; ++k) {
 	  arp_table[i].ethaddr.addr[k] = ethaddr->addr[k];
 	}
 	arp_table[i].ctime = ctime;
 	return NULL;
       }
       if(arp_table[i].state == ETHARP_STATE_PENDING) {
 	/* A pending entry was found, so we fill this in and return
 	   the queued packet (if any). */
 	for(k = 0; k < 6; ++k) {
 	  arp_table[i].ethaddr.addr[k] = ethaddr->addr[k];
 	}
 	arp_table[i].ctime = ctime;
 	arp_table[i].state = ETHARP_STATE_STABLE;
 	p = arp_table[i].p;
 	if(p != NULL) {
 	  p->payload = arp_table[i].payload;
 	  p->len = arp_table[i].len;
 	  p->tot_len = arp_table[i].tot_len;
 	  arp_table[i].p = NULL;

 	  ethhdr = p->payload;

 	  for(k = 0; k < 6; ++k) {
 	    ethhdr->dest.addr[k] = ethaddr->addr[k];
 	  }

 	  ethhdr->type = htons(ETHTYPE_IP);
 	}
 	return p;
       }
     }
   }
   /* We get here if no ARP entry was found. If so, we create one. */
   i = find_arp_entry();
   if(i == ARP_TABLE_SIZE) {
     return NULL;
   }

   ip_addr_set(&arp_table[i].ipaddr, ipaddr);
   for(k = 0; k < 6; ++k) {
     arp_table[i].ethaddr.addr[k] = ethaddr->addr[k];
   }
   arp_table[i].ctime = ctime;
   arp_table[i].state = ETHARP_STATE_STABLE;
   arp_table[i].p = NULL;

   return NULL;
 }
 /*-----------------------------------------------------------------------------------*/
 struct pbuf *
 etharp_ip_input(struct netif *netif, struct pbuf *p)
 {
   struct ethip_hdr *hdr;

   hdr = p->payload;

   /* Only insert/update an entry if the source IP address of the
      incoming IP packet comes from a host on the local network. */
   if(!ip_addr_maskcmp(&(hdr->ip.src), &(netif->ip_addr), &(netif->netmask))) {
     return NULL;
   }
   DEBUGF(ETHARP_DEBUG, ("etharp_ip_input: updating ETHARP table.\n"));
   return update_arp_entry(&(hdr->ip.src), &(hdr->eth.src));
 }
 /*-----------------------------------------------------------------------------------*/
 struct pbuf *
 etharp_arp_input(struct netif *netif, struct eth_addr *ethaddr, struct pbuf *p)
 {
   struct etharp_hdr *hdr;
   u8_t i;

   if(p->tot_len < sizeof(struct etharp_hdr)) {
     DEBUGF(ETHARP_DEBUG, ("etharp_etharp_input: packet too short (%d/%d)\n", p->tot_len, sizeof(struct etharp_hdr)));
     pbuf_free(p);
     return NULL;
   }

   hdr = p->payload;

   switch(htons(hdr->opcode)) {
   case ARP_REQUEST:
     /* ARP request. If it asked for our address, we send out a
        reply. */
     DEBUGF(ETHARP_DEBUG, ("etharp_arp_input: ARP request\n"));
     if(ip_addr_cmp(&(hdr->dipaddr), &(netif->ip_addr))) {
       hdr->opcode = htons(ARP_REPLY);

       ip_addr_set(&(hdr->dipaddr), &(hdr->sipaddr));
       ip_addr_set(&(hdr->sipaddr), &(netif->ip_addr));

       for(i = 0; i < 6; ++i) {
 	hdr->dhwaddr.addr[i] = hdr->shwaddr.addr[i];
 	hdr->shwaddr.addr[i] = ethaddr->addr[i];
 	hdr->ethhdr.dest.addr[i] = hdr->dhwaddr.addr[i];
 	hdr->ethhdr.src.addr[i] = ethaddr->addr[i];
       }

       hdr->hwtype = htons(HWTYPE_ETHERNET);
       ARPH_HWLEN_SET(hdr, 6);

       hdr->proto = htons(ETHTYPE_IP);
       ARPH_PROTOLEN_SET(hdr, sizeof(struct ip_addr));

       hdr->ethhdr.type = htons(ETHTYPE_ARP);
       return p;
     }
     break;
   case ARP_REPLY:
     /* ARP reply. We insert or update the ARP table. */
     DEBUGF(ETHARP_DEBUG, ("etharp_arp_input: ARP reply\n"));
     if(ip_addr_cmp(&(hdr->dipaddr), &(netif->ip_addr))) {
 #if (LWIP_DHCP && DHCP_DOES_ARP_CHECK)
       dhcp_arp_reply(&hdr->sipaddr);
 #endif
       /* update_arp_entry() will return a pbuf that has previously been
 	 queued waiting for an ARP reply. */
       pbuf_free(p);
       p = update_arp_entry(&(hdr->sipaddr), &(hdr->shwaddr));

       return p;
     }
     break;
   default:
     DEBUGF(ETHARP_DEBUG, ("etharp_arp_input: unknown type %d\n", htons(hdr->opcode)));
     break;
   }

   pbuf_free(p);
   return NULL;
 }
 /*-----------------------------------------------------------------------------------*/
 struct pbuf *
 etharp_output(struct netif *netif, struct ip_addr *ipaddr, struct pbuf *q)
 {
   struct eth_addr *dest, *srcaddr, mcastaddr;
   struct eth_hdr *ethhdr;
   struct etharp_hdr *hdr;
   struct pbuf *p;
   u8_t i;

   srcaddr = (struct eth_addr *)netif->hwaddr;

   /* Make room for Ethernet header. */
   if(pbuf_header(q, sizeof(struct eth_hdr)) != 0) {
     /* The pbuf_header() call shouldn't fail, and we'll just bail
        out if it does.. */
     DEBUGF(ETHARP_DEBUG, ("etharp_output: could not allocate room for header.\n"));
 #ifdef LINK_STATS
     ++stats.link.lenerr;
 #endif /* LINK_STATS */
     return NULL;
   }


   dest = NULL;
   /* Construct Ethernet header. Start with looking up deciding which
      MAC address to use as a destination address. Broadcasts and
      multicasts are special, all other addresses are looked up in the
      ARP table. */
   if(ip_addr_isany(ipaddr) ||
      ip_addr_isbroadcast(ipaddr, &(netif->netmask))) {
     dest = (struct eth_addr *)&ethbroadcast;
   } else if(ip_addr_ismulticast(ipaddr)) {
     /* Hash IP multicast address to MAC address. */
     mcastaddr.addr[0] = 0x01;
     mcastaddr.addr[1] = 0x0;
     mcastaddr.addr[2] = 0x5e;
     mcastaddr.addr[3] = ip4_addr2(ipaddr) & 0x7f;
     mcastaddr.addr[4] = ip4_addr3(ipaddr);
     mcastaddr.addr[5] = ip4_addr4(ipaddr);
     dest = &mcastaddr;
   } else {
     if(!ip_addr_maskcmp(ipaddr, &(netif->ip_addr), &(netif->netmask))) {
       /* Use the IP address of the default gateway if the destination
          is on the same subnet as we are. */
       ipaddr = &(netif->gw);
     }

     /* We try to find a stable mapping. */
     for(i = 0; i < ARP_TABLE_SIZE; ++i) {
       if(arp_table[i].state == ETHARP_STATE_STABLE &&
 	 ip_addr_cmp(ipaddr, &arp_table[i].ipaddr)) {
 	dest = &arp_table[i].ethaddr;
 	break;
       }
     }
   }

   if(dest == NULL) {
     /* No destination address has been found, so we'll have to send
        out an ARP request for the IP address. The outgoing packet is
        queued unless the queue is full. */

     /* We check if we are already querying for this address. If so,
        we'll bail out. */
     for(i = 0; i < ARP_TABLE_SIZE; ++i) {
       if(arp_table[i].state == ETHARP_STATE_PENDING &&
 	 ip_addr_cmp(ipaddr, &arp_table[i].ipaddr)) {
 	DEBUGF(ETHARP_DEBUG, ("etharp_output: already queued\n"));
 	return NULL;
       }
     }

     i = find_arp_entry();

     /* If all table entries were in pending state, we won't send out any
        more ARP requests. We'll just give up. */
     if(i == ARP_TABLE_SIZE) {
       return NULL;
     }

     /* Now, i is the ARP table entry which we will fill with the new
        information. */
     ip_addr_set(&arp_table[i].ipaddr, ipaddr);
     /*    for(k = 0; k < 6; ++k) {
 	  arp_table[i].ethaddr.addr[k] = dest->addr[k];
 	  }*/
     arp_table[i].ctime = ctime;
     arp_table[i].state = ETHARP_STATE_PENDING;
 #if 1
     arp_table[i].p = q;
     arp_table[i].payload = q->payload;
     arp_table[i].len = q->len;
     arp_table[i].tot_len = q->tot_len;

     /* Because the pbuf will be queued, we'll increase the refernce
        count. */
     DEBUGF(ETHARP_DEBUG, ("etharp_output: queueing %p\n", q));
     pbuf_ref(q);
 #else
     arp_table[i].p = NULL;
 #endif /* 0 */


     /* We allocate a pbuf for the outgoing ARP request packet. */
     p = pbuf_alloc(PBUF_LINK, sizeof(struct etharp_hdr), PBUF_RAM);
     if(p == NULL) {
       /* No ARP request packet could be allocated, so we forget about
 	 the ARP table entry. */
       if(i != ARP_TABLE_SIZE) {
 	arp_table[i].state = ETHARP_STATE_EMPTY;
 	/* We decrease the reference count of the queued pbuf (which now
 	   is dequeued). */
 	DEBUGF(ETHARP_DEBUG, ("etharp_output: couldn't alloc pbuf for query, dequeueing %p\n", q));
 	pbuf_free(q);
       }
       return NULL;
     }

     hdr = p->payload;

     hdr->opcode = htons(ARP_REQUEST);

     for(i = 0; i < 6; ++i) {
       hdr->dhwaddr.addr[i] = 0x00;
       hdr->shwaddr.addr[i] = srcaddr->addr[i];
     }

     ip_addr_set(&(hdr->dipaddr), ipaddr);
     ip_addr_set(&(hdr->sipaddr), &(netif->ip_addr));

     hdr->hwtype = htons(HWTYPE_ETHERNET);
     ARPH_HWLEN_SET(hdr, 6);

     hdr->proto = htons(ETHTYPE_IP);
     ARPH_PROTOLEN_SET(hdr, sizeof(struct ip_addr));

     for(i = 0; i < 6; ++i) {
       hdr->ethhdr.dest.addr[i] = 0xff;
       hdr->ethhdr.src.addr[i] = srcaddr->addr[i];
     }

     hdr->ethhdr.type = htons(ETHTYPE_ARP);
     return p;
   } else {
     /* A valid IP->MAC address mapping was found, so we construct the
        Ethernet header for the outgoing packet. */

     ethhdr = q->payload;

     for(i = 0; i < 6; i++) {
       ethhdr->dest.addr[i] = dest->addr[i];
       ethhdr->src.addr[i] = srcaddr->addr[i];
     }

     ethhdr->type = htons(ETHTYPE_IP);

     return q;
   }


 }
 /*-----------------------------------------------------------------------------------*/
	/*
	* Copyright (c) 2001, 2002 Swedish Institute of Computer Science.
	* All rights reserved.
	*
	* Redistribution and use in source and binary forms, with or without modification,
	* are permitted provided that the following conditions are met:
	*
	* 1. Redistributions of source code must retain the above copyright notice,
	* this list of conditions and the following disclaimer.
	* 2. Redistributions in binary form must reproduce the above copyright notice,
	* this list of conditions and the following disclaimer in the documentation
	* and/or other materials provided with the distribution.
	* 3. The name of the author may not be used to endorse or promote products
	* derived from this software without specific prior written permission.
	*
	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
	* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
	* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
	* SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
	* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
	* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
	* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
	* OF SUCH DAMAGE.
	*
	* This file is part of the lwIP TCP/IP stack.
	*
	* Author: Adam Dunkels <adam@sics.se>
	*
	*
	*/

	#include "lwip/opt.h"
	#include "lwip/debug.h"
	#include "lwip/inet.h"
	#include "netif/etharp.h"
	#include "lwip/ip.h"
	#include "lwip/stats.h"

	#if LWIP_DHCP
	# include "lwip/dhcp.h"
	#endif


	#define ARP_MAXAGE 120 /* 120 * 10 seconds = 20 minutes. */
	#define ARP_MAXPENDING 2 /* 2 * 10 seconds = 20 seconds. */

	#define HWTYPE_ETHERNET 1

	#define ARP_REQUEST 1
	#define ARP_REPLY 2

	/* MUST be compiled with "pack structs" or equivalent! */
	PACK_STRUCT_BEGIN
	struct etharp_hdr {
	PACK_STRUCT_FIELD(struct eth_hdr ethhdr);
	PACK_STRUCT_FIELD(u16_t hwtype);
	PACK_STRUCT_FIELD(u16_t proto);
	PACK_STRUCT_FIELD(u16_t _hwlen_protolen);
	PACK_STRUCT_FIELD(u16_t opcode);
	PACK_STRUCT_FIELD(struct eth_addr shwaddr);
	PACK_STRUCT_FIELD(struct ip_addr sipaddr);
	PACK_STRUCT_FIELD(struct eth_addr dhwaddr);
	PACK_STRUCT_FIELD(struct ip_addr dipaddr);
	} PACK_STRUCT_STRUCT;
	PACK_STRUCT_END

	#define ARPH_HWLEN(hdr) (NTOHS((hdr)->_hwlen_protolen) >> 8)
	#define ARPH_PROTOLEN(hdr) (NTOHS((hdr)->_hwlen_protolen) & 0xff)


	#define ARPH_HWLEN_SET(hdr, len) (hdr)->_hwlen_protolen = HTONS(ARPH_PROTOLEN(hdr) \| ((len) << 8))
	#define ARPH_PROTOLEN_SET(hdr, len) (hdr)->_hwlen_protolen = HTONS((len) \| (ARPH_HWLEN(hdr) << 8))

	PACK_STRUCT_BEGIN
	struct ethip_hdr {
	PACK_STRUCT_FIELD(struct eth_hdr eth);
	PACK_STRUCT_FIELD(struct ip_hdr ip);
	};
	PACK_STRUCT_END

	enum etharp_state {
	ETHARP_STATE_EMPTY,
	ETHARP_STATE_PENDING,
	ETHARP_STATE_STABLE
	};

	struct etharp_entry {
	struct ip_addr ipaddr;
	struct eth_addr ethaddr;
	enum etharp_state state;
	struct pbuf *p;
	void *payload;
	u16_t len, tot_len;
	u8_t ctime;
	};

	static const struct eth_addr ethbroadcast = {{0xff,0xff,0xff,0xff,0xff,0xff}};
	static struct etharp_entry arp_table[ARP_TABLE_SIZE];
	static u8_t ctime;

	/-----------------------------------------------------------------------------------/
	void
	etharp_init(void)
	{
	u8_t i;

	for(i = 0; i < ARP_TABLE_SIZE; ++i) {
	arp_table[i].state = ETHARP_STATE_EMPTY;
	}
	}
	/-----------------------------------------------------------------------------------/
	void
	etharp_tmr(void)
	{
	u8_t i;

	++ctime;
	for(i = 0; i < ARP_TABLE_SIZE; ++i) {
	if(arp_table[i].state == ETHARP_STATE_STABLE &&
	ctime - arp_table[i].ctime >= ARP_MAXAGE) {
	DEBUGF(ETHARP_DEBUG, ("etharp_timer: expired stable entry %d.\n", i));
	arp_table[i].state = ETHARP_STATE_EMPTY;
	} else if(arp_table[i].state == ETHARP_STATE_PENDING &&
	ctime - arp_table[i].ctime >= ARP_MAXPENDING) {
	DEBUGF(ETHARP_DEBUG, ("etharp_timer: expired pending entry %d - dequeueing %p.\n", i, arp_table[i].p));
	arp_table[i].state = ETHARP_STATE_EMPTY;
	pbuf_free(arp_table[i].p);
	}
	}
	}
	/----------------------------------------------------------------------------------/
	static u8_t
	find_arp_entry(void)
	{
	u8_t i, j, maxtime;

	/* Try to find an unused entry in the ARP table. */
	for(i = 0; i < ARP_TABLE_SIZE; ++i) {
	if(arp_table[i].state == ETHARP_STATE_EMPTY) {
	break;
	}
	}

	/* If no unused entry is found, we try to find the oldest entry and
	throw it away. */
	if(i == ARP_TABLE_SIZE) {
	maxtime = 0;
	j = 0;
	for(i = 0; i < ARP_TABLE_SIZE; ++i) {
	if(arp_table[i].state == ETHARP_STATE_STABLE &&
	ctime - arp_table[i].ctime > maxtime) {
	maxtime = ctime - arp_table[i].ctime;
	j = i;
	}
	}
	i = j;
	}
	return i;
	}
	/-----------------------------------------------------------------------------------/
	static struct pbuf *
	update_arp_entry(struct ip_addr ipaddr, struct eth_addr ethaddr)
	{
	u8_t i, k;
	struct pbuf *p;
	struct eth_hdr *ethhdr;

	/* Walk through the ARP mapping table and try to find an entry to
	update. If none is found, the IP -> MAC address mapping is
	inserted in the ARP table. */
	for(i = 0; i < ARP_TABLE_SIZE; ++i) {
	/* Check if the source IP address of the incoming packet matches
	the IP address in this ARP table entry. */
	if(ip_addr_cmp(ipaddr, &arp_table[i].ipaddr)) {

	/* First, check those entries that are already in use. */
	if(arp_table[i].state == ETHARP_STATE_STABLE) {
	/* An old entry found, update this and return. */
	for(k = 0; k < 6; ++k) {
	arp_table[i].ethaddr.addr[k] = ethaddr->addr[k];
	}
	arp_table[i].ctime = ctime;
	return NULL;
	}
	if(arp_table[i].state == ETHARP_STATE_PENDING) {
	/* A pending entry was found, so we fill this in and return
	the queued packet (if any). */
	for(k = 0; k < 6; ++k) {
	arp_table[i].ethaddr.addr[k] = ethaddr->addr[k];
	}
	arp_table[i].ctime = ctime;
	arp_table[i].state = ETHARP_STATE_STABLE;
	p = arp_table[i].p;
	if(p != NULL) {
	p->payload = arp_table[i].payload;
	p->len = arp_table[i].len;
	p->tot_len = arp_table[i].tot_len;
	arp_table[i].p = NULL;

	ethhdr = p->payload;

	for(k = 0; k < 6; ++k) {
	ethhdr->dest.addr[k] = ethaddr->addr[k];
	}

	ethhdr->type = htons(ETHTYPE_IP);
	}
	return p;
	}
	}
	}
	/* We get here if no ARP entry was found. If so, we create one. */
	i = find_arp_entry();
	if(i == ARP_TABLE_SIZE) {
	return NULL;
	}

	ip_addr_set(&arp_table[i].ipaddr, ipaddr);
	for(k = 0; k < 6; ++k) {
	arp_table[i].ethaddr.addr[k] = ethaddr->addr[k];
	}
	arp_table[i].ctime = ctime;
	arp_table[i].state = ETHARP_STATE_STABLE;
	arp_table[i].p = NULL;

	return NULL;
	}
	/-----------------------------------------------------------------------------------/
	struct pbuf *
	etharp_ip_input(struct netif netif, struct pbuf p)
	{
	struct ethip_hdr *hdr;

	hdr = p->payload;

	/* Only insert/update an entry if the source IP address of the
	incoming IP packet comes from a host on the local network. */
	if(!ip_addr_maskcmp(&(hdr->ip.src), &(netif->ip_addr), &(netif->netmask))) {
	return NULL;
	}
	DEBUGF(ETHARP_DEBUG, ("etharp_ip_input: updating ETHARP table.\n"));
	return update_arp_entry(&(hdr->ip.src), &(hdr->eth.src));
	}
	/-----------------------------------------------------------------------------------/
	struct pbuf *
	etharp_arp_input(struct netif netif, struct eth_addr ethaddr, struct pbuf *p)
	{
	struct etharp_hdr *hdr;
	u8_t i;

	if(p->tot_len < sizeof(struct etharp_hdr)) {
	DEBUGF(ETHARP_DEBUG, ("etharp_etharp_input: packet too short (%d/%d)\n", p->tot_len, sizeof(struct etharp_hdr)));
	pbuf_free(p);
	return NULL;
	}

	hdr = p->payload;

	switch(htons(hdr->opcode)) {
	case ARP_REQUEST:
	/* ARP request. If it asked for our address, we send out a
	reply. */
	DEBUGF(ETHARP_DEBUG, ("etharp_arp_input: ARP request\n"));
	if(ip_addr_cmp(&(hdr->dipaddr), &(netif->ip_addr))) {
	hdr->opcode = htons(ARP_REPLY);

	ip_addr_set(&(hdr->dipaddr), &(hdr->sipaddr));
	ip_addr_set(&(hdr->sipaddr), &(netif->ip_addr));

	for(i = 0; i < 6; ++i) {
	hdr->dhwaddr.addr[i] = hdr->shwaddr.addr[i];
	hdr->shwaddr.addr[i] = ethaddr->addr[i];
	hdr->ethhdr.dest.addr[i] = hdr->dhwaddr.addr[i];
	hdr->ethhdr.src.addr[i] = ethaddr->addr[i];
	}

	hdr->hwtype = htons(HWTYPE_ETHERNET);
	ARPH_HWLEN_SET(hdr, 6);

	hdr->proto = htons(ETHTYPE_IP);
	ARPH_PROTOLEN_SET(hdr, sizeof(struct ip_addr));

	hdr->ethhdr.type = htons(ETHTYPE_ARP);
	return p;
	}
	break;
	case ARP_REPLY:
	/* ARP reply. We insert or update the ARP table. */
	DEBUGF(ETHARP_DEBUG, ("etharp_arp_input: ARP reply\n"));
	if(ip_addr_cmp(&(hdr->dipaddr), &(netif->ip_addr))) {
	#if (LWIP_DHCP && DHCP_DOES_ARP_CHECK)
	dhcp_arp_reply(&hdr->sipaddr);
	#endif
	/* update_arp_entry() will return a pbuf that has previously been
	queued waiting for an ARP reply. */
	pbuf_free(p);
	p = update_arp_entry(&(hdr->sipaddr), &(hdr->shwaddr));

	return p;
	}
	break;
	default:
	DEBUGF(ETHARP_DEBUG, ("etharp_arp_input: unknown type %d\n", htons(hdr->opcode)));
	break;
	}

	pbuf_free(p);
	return NULL;
	}
	/-----------------------------------------------------------------------------------/
	struct pbuf *
	etharp_output(struct netif netif, struct ip_addr ipaddr, struct pbuf *q)
	{
	struct eth_addr dest, srcaddr, mcastaddr;
	struct eth_hdr *ethhdr;
	struct etharp_hdr *hdr;
	struct pbuf *p;
	u8_t i;

	srcaddr = (struct eth_addr *)netif->hwaddr;

	/* Make room for Ethernet header. */
	if(pbuf_header(q, sizeof(struct eth_hdr)) != 0) {
	/* The pbuf_header() call shouldn't fail, and we'll just bail
	out if it does.. */
	DEBUGF(ETHARP_DEBUG, ("etharp_output: could not allocate room for header.\n"));
	#ifdef LINK_STATS
	++stats.link.lenerr;
	#endif /* LINK_STATS */
	return NULL;
	}


	dest = NULL;
	/* Construct Ethernet header. Start with looking up deciding which
	MAC address to use as a destination address. Broadcasts and
	multicasts are special, all other addresses are looked up in the
	ARP table. */
	if(ip_addr_isany(ipaddr) \|\|
	ip_addr_isbroadcast(ipaddr, &(netif->netmask))) {
	dest = (struct eth_addr *)&ethbroadcast;
	} else if(ip_addr_ismulticast(ipaddr)) {
	/* Hash IP multicast address to MAC address. */
	mcastaddr.addr[0] = 0x01;
	mcastaddr.addr[1] = 0x0;
	mcastaddr.addr[2] = 0x5e;
	mcastaddr.addr[3] = ip4_addr2(ipaddr) & 0x7f;
	mcastaddr.addr[4] = ip4_addr3(ipaddr);
	mcastaddr.addr[5] = ip4_addr4(ipaddr);
	dest = &mcastaddr;
	} else {
	if(!ip_addr_maskcmp(ipaddr, &(netif->ip_addr), &(netif->netmask))) {
	/* Use the IP address of the default gateway if the destination
	is on the same subnet as we are. */
	ipaddr = &(netif->gw);
	}

	/* We try to find a stable mapping. */
	for(i = 0; i < ARP_TABLE_SIZE; ++i) {
	if(arp_table[i].state == ETHARP_STATE_STABLE &&
	ip_addr_cmp(ipaddr, &arp_table[i].ipaddr)) {
	dest = &arp_table[i].ethaddr;
	break;
	}
	}
	}

	if(dest == NULL) {
	/* No destination address has been found, so we'll have to send
	out an ARP request for the IP address. The outgoing packet is
	queued unless the queue is full. */

	/* We check if we are already querying for this address. If so,
	we'll bail out. */
	for(i = 0; i < ARP_TABLE_SIZE; ++i) {
	if(arp_table[i].state == ETHARP_STATE_PENDING &&
	ip_addr_cmp(ipaddr, &arp_table[i].ipaddr)) {
	DEBUGF(ETHARP_DEBUG, ("etharp_output: already queued\n"));
	return NULL;
	}
	}

	i = find_arp_entry();

	/* If all table entries were in pending state, we won't send out any
	more ARP requests. We'll just give up. */
	if(i == ARP_TABLE_SIZE) {
	return NULL;
	}

	/* Now, i is the ARP table entry which we will fill with the new
	information. */
	ip_addr_set(&arp_table[i].ipaddr, ipaddr);
	/* for(k = 0; k < 6; ++k) {
	arp_table[i].ethaddr.addr[k] = dest->addr[k];
	}*/
	arp_table[i].ctime = ctime;
	arp_table[i].state = ETHARP_STATE_PENDING;
	#if 1
	arp_table[i].p = q;
	arp_table[i].payload = q->payload;
	arp_table[i].len = q->len;
	arp_table[i].tot_len = q->tot_len;

	/* Because the pbuf will be queued, we'll increase the refernce
	count. */
	DEBUGF(ETHARP_DEBUG, ("etharp_output: queueing %p\n", q));
	pbuf_ref(q);
	#else
	arp_table[i].p = NULL;
	#endif /* 0 */


	/* We allocate a pbuf for the outgoing ARP request packet. */
	p = pbuf_alloc(PBUF_LINK, sizeof(struct etharp_hdr), PBUF_RAM);
	if(p == NULL) {
	/* No ARP request packet could be allocated, so we forget about
	the ARP table entry. */
	if(i != ARP_TABLE_SIZE) {
	arp_table[i].state = ETHARP_STATE_EMPTY;
	/* We decrease the reference count of the queued pbuf (which now
	is dequeued). */
	DEBUGF(ETHARP_DEBUG, ("etharp_output: couldn't alloc pbuf for query, dequeueing %p\n", q));
	pbuf_free(q);
	}
	return NULL;
	}

	hdr = p->payload;

	hdr->opcode = htons(ARP_REQUEST);

	for(i = 0; i < 6; ++i) {
	hdr->dhwaddr.addr[i] = 0x00;
	hdr->shwaddr.addr[i] = srcaddr->addr[i];
	}

	ip_addr_set(&(hdr->dipaddr), ipaddr);
	ip_addr_set(&(hdr->sipaddr), &(netif->ip_addr));

	hdr->hwtype = htons(HWTYPE_ETHERNET);
	ARPH_HWLEN_SET(hdr, 6);

	hdr->proto = htons(ETHTYPE_IP);
	ARPH_PROTOLEN_SET(hdr, sizeof(struct ip_addr));

	for(i = 0; i < 6; ++i) {
	hdr->ethhdr.dest.addr[i] = 0xff;
	hdr->ethhdr.src.addr[i] = srcaddr->addr[i];
	}

	hdr->ethhdr.type = htons(ETHTYPE_ARP);
	return p;
	} else {
	/* A valid IP->MAC address mapping was found, so we construct the
	Ethernet header for the outgoing packet. */

	ethhdr = q->payload;

	for(i = 0; i < 6; i++) {
	ethhdr->dest.addr[i] = dest->addr[i];
	ethhdr->src.addr[i] = srcaddr->addr[i];
	}

	ethhdr->type = htons(ETHTYPE_IP);

	return q;
	}


	}
	/-----------------------------------------------------------------------------------/