Fixed the variable types in inet_ntoa() to comply with API change.

Reported on lwip-users by Stephen Chen on february 4th 2004.

CHANGELOG

@@ -2,35 +2,39 @@ FUTURE
 
   * TODO: The lwIP source code makes some invalid assumptions on processor
     word-length, storage sizes and alignment. See the mailing lists for
-    problems with exoteric (/DSP) architectures showing these problems.
-    We still have to fix some of these issues neatly.
+    problems with exoteric architectures showing these problems.
+    Neat fixes are needed.
 
 HISTORY
 
-(HEAD)
+(STABLE-0_7 branch)
 
-  ++ Changes:
-
-  2004-04-29 Leon Woestenberg <leon.woestenberg@gmx.net>
-  * tcp*.c: Cleaned up source comment documentation for Doxygen processing.
-  * opt.h: ETHHARP_ALWAYS_INSERT option removed to comply with ARP RFC.
-  * etharp.c: update_arp_entry() only adds new ARP entries when adviced to by
-    the caller. This deprecates the ETHHARP_ALWAYS_INSERT overrule option.
+(STABLE-0_7_2)
 
   ++ Bug fixes:
 
-  2004-04-27 Leon Woestenberg <leon.woestenberg@gmx.net>
-  * etharp.c: Applied patch of bug #8708 by Toni Mountifield with a solution
-    suggested by Timmy Brolin. Fix for 32-bit processors that cannot access
-    non-aligned 32-bit words, such as soms 32-bit TCP/IP header fields. Fix
-    is to prefix the 14-bit Ethernet headers with two padding bytes.
-
   2004-04-23 Leon Woestenberg <leon.woestenberg@gmx.net>
-  * ip_addr.c: Fix in the ip_addr_isbroadcast() check.
+  * memp.c: Fixed cast in mem_malloc().
+  * sockets.c, tcp_in.c, udp.c: #ifdef SO_REUSE now #if SO_REUSE.
+  * dhcp.c: #if LWIP_DHCP fixed.
   * etharp.c: Fixed the case where the packet that initiates the ARP request
     is not queued, and gets lost. Fixed the case where the packets destination
     address is already known; we now always queue the packet and perform an ARP
     request.
+
+  2004-03-23 Leon Woestenberg <leon.woestenberg@gmx.net>
+  * tcp.c: #ifdef SO_REUSE now #if SO_REUSE.
+
+  2004-03-11 Leon Woestenberg <leon.woestenberg@gmx.net>
+  * dhcp.c: Added missing #if LWIP_DHCP #endif pair.
+
+(STABLE-0_7_1)
+
+  ++ Bug fixes:
+
+  * Fixed updating the ARP cache from a request pbuf that was recycled earlier for reply.
+  * Removed updating ARP cache using destination address (which is wrong for requests and
+    does not work for replies as those are unicast anyway).
   
 (STABLE-0_7_0)
 

doc/savannah.txt

@@ -112,8 +112,6 @@ cvs -d:ext:anoncvs@subversions.gnu.org:/cvsroot/lwip export -r STABLE-0_6_3 -d l
 Archive this directory using tar, gzip'd, bzip2'd and zip'd.
 
 tar czvf lwip-0.6.3.tar.gz lwip-0.6.3
-tar cjvf lwip-0.6.3.tar.bz2 lwip-0.6.3
-zip -r lwip-0.6.3.zip lwip-0.6.3
 
 First, make a local release directory to work in, I use "lwip-releases":
 

doc/sys_arch.txt

@@ -154,6 +154,12 @@ cc.h       - Architecture environment, some compiler specific, some
   Typedefs for the types used by lwip -
     u8_t, s8_t, u16_t, s16_t, u32_t, s32_t, mem_ptr_t
 
+  Compiler hints for packing lwip's structures -
+    PACK_STRUCT_FIELD(x)
+    PACK_STRUCT_STRUCT
+    PACK_STRUCT_BEGIN
+    PACK_STRUCT_END
+
   Platform specific diagnostic output -
     LWIP_PLATFORM_DIAG(x)    - non-fatal, print a message.
     LWIP_PLATFORM_ASSERT(x)  - fatal, print message and abandon execution.

src/api/sockets.c

@@ -37,7 +37,6 @@
 #include "lwip/arch.h"
 #include "lwip/sys.h"
 
-#define LWIP_TIMEVAL_PRIVATE
 #include "lwip/sockets.h"
 
 #define NUM_SOCKETS MEMP_NUM_NETCONN

src/core/dhcp.c

@@ -406,6 +406,7 @@ static void dhcp_t2_timeout(struct netif *netif)
 }
 
 /**
+ * Extract options from the server ACK message.
  *
  * @param netif the netif under DHCP control
  */
@@ -1239,10 +1240,10 @@ static err_t dhcp_create_request(struct netif *netif)
   dhcp->msg_out->xid = htonl(dhcp->xid);
   dhcp->msg_out->secs = 0;
   dhcp->msg_out->flags = 0;
-  dhcp->msg_out->ciaddr.addr = netif->ip_addr.addr;
-  dhcp->msg_out->yiaddr.addr = 0;
-  dhcp->msg_out->siaddr.addr = 0;
-  dhcp->msg_out->giaddr.addr = 0;
+  dhcp->msg_out->ciaddr = netif->ip_addr.addr;
+  dhcp->msg_out->yiaddr = 0;
+  dhcp->msg_out->siaddr = 0;
+  dhcp->msg_out->giaddr = 0;
   for (i = 0; i < DHCP_CHADDR_LEN; i++) {
     /* copy netif hardware address, pad with zeroes */
     dhcp->msg_out->chaddr[i] = (i < netif->hwaddr_len) ? netif->hwaddr[i] : 0/* pad byte*/;

src/core/inet.c

@@ -302,17 +302,17 @@ inet_chksum_pbuf(struct pbuf *p)
  */
 char *inet_ntoa(struct in_addr addr)
 {
-  static u8_t str[16];
+  static char str[16];
   u32_t s_addr = addr.s_addr;
-  u8_t inv[3];
-  u8_t *rp;
-  u8_t *ap;
+  char inv[3];
+  char *rp;
+  char *ap;
   u8_t rem;
   u8_t n;
   u8_t i;
 
   rp = str;
-  ap = (char *)&s_addr;
+  ap = (u8_t *)&s_addr;
   for(n = 0; n < 4; n++) {
     i = 0;
     do {

src/core/ipv4/icmp.c

@@ -72,8 +72,8 @@ icmp_input(struct pbuf *p, struct netif *inp)
   code = *(((u8_t *)p->payload)+1);
   switch (type) {
   case ICMP_ECHO:
-    /* broadcast or multicast destination address? */
-    if (ip_addr_isbroadcast(&iphdr->dest, inp) || ip_addr_ismulticast(&iphdr->dest)) {
+    if (ip_addr_isbroadcast(&iphdr->dest, &inp->netmask) ||
+       ip_addr_ismulticast(&iphdr->dest)) {
       LWIP_DEBUGF(ICMP_DEBUG, ("Smurf.\n"));
       ICMP_STATS_INC(icmp.err);
       pbuf_free(p);

src/core/ipv4/ip.c

@@ -1,10 +1,3 @@
-/* @file
- *
- * This is the IP layer implementation for incoming and outgoing IP traffic.
- * 
- * @see ip_frag.c
- *
- */
 /*
  * Copyright (c) 2001-2004 Swedish Institute of Computer Science.
  * All rights reserved.
@@ -37,8 +30,18 @@
  *
  */
 
+
+
+/* ip.c
+ *
+ * This is the code for the IP layer.
+ *
+ */
+
+
 #include "lwip/opt.h"
 
+
 #include "lwip/def.h"
 #include "lwip/mem.h"
 #include "lwip/ip.h"
@@ -60,17 +63,18 @@
 #endif /* LWIP_DHCP */
 
 
-/**
+/* ip_init:
+ *
  * Initializes the IP layer.
  */
 
 void
 ip_init(void)
 {
-  /* no initializations as of yet */
 }
 
-/**
+/* ip_route:
+ *
  * Finds the appropriate network interface for a given IP address. It
  * searches the list of network interfaces linearly. A match is found
  * if the masked IP address of the network interface equals the masked
@@ -95,7 +99,8 @@ ip_route(struct ip_addr *dest)
 }
 #if IP_FORWARD
 
-/**
+/* ip_forward:
+ *
  * Forwards an IP packet. It finds an appropriate route for the
  * packet, decrements the TTL value of the packet, adjusts the
  * checksum and outputs the packet on the appropriate interface.
@@ -116,7 +121,7 @@ ip_forward(struct pbuf *p, struct ip_hdr *iphdr, struct netif *inp)
     return;
   }
   /* Do not forward packets onto the same network interface on which
-   * they arrived. */
+     they arrived. */
   if (netif == inp) {
     LWIP_DEBUGF(IP_DEBUG, ("ip_forward: not bouncing packets back on incoming interface.\n"));
     snmp_inc_ipnoroutes();
@@ -155,7 +160,8 @@ ip_forward(struct pbuf *p, struct ip_hdr *iphdr, struct netif *inp)
 }
 #endif /* IP_FORWARD */
 
-/**
+/* ip_input:
+ *
  * This function is called by the network interface device driver when
  * an IP packet is received. The function does the basic checks of the
  * IP header such as packet size being at least larger than the header
@@ -203,7 +209,6 @@ ip_input(struct pbuf *p, struct netif *inp) {
   }
 
   /* verify checksum */
-#if CHECKSUM_CHECK_IP
   if (inet_chksum(iphdr, iphdrlen) != 0) {
 
     LWIP_DEBUGF(IP_DEBUG | 2, ("Checksum (0x%x) failed, IP packet dropped.\n", inet_chksum(iphdr, iphdrlen)));
@@ -214,10 +219,9 @@ ip_input(struct pbuf *p, struct netif *inp) {
     snmp_inc_ipindiscards();
     return ERR_OK;
   }
-#endif
 
   /* Trim pbuf. This should have been done at the netif layer,
-   * but we'll do it anyway just to be sure that its done. */
+     but we'll do it anyway just to be sure that its done. */
   pbuf_realloc(p, ntohs(IPH_LEN(iphdr)));
 
   /* is this packet for us? */
@@ -235,7 +239,7 @@ ip_input(struct pbuf *p, struct netif *inp) {
       /* unicast to this interface address? */
       if (ip_addr_cmp(&(iphdr->dest), &(netif->ip_addr)) ||
         /* or broadcast matching this interface network address? */
-        (ip_addr_isbroadcast(&(iphdr->dest), netif) &&
+        (ip_addr_isbroadcast(&(iphdr->dest), &(netif->netmask)) &&
          ip_addr_maskcmp(&(iphdr->dest), &(netif->ip_addr), &(netif->netmask))) ||
          /* or restricted broadcast? */
          ip_addr_cmp(&(iphdr->dest), IP_ADDR_BROADCAST)) {
@@ -248,8 +252,8 @@ ip_input(struct pbuf *p, struct netif *inp) {
   }
 #if LWIP_DHCP
   /* Pass DHCP messages regardless of destination address. DHCP traffic is addressed
-   * using link layer addressing (such as Ethernet MAC) so we must not filter on IP.
-   * According to RFC 1542 section 3.1.1, referred by RFC 2131). */
+     using link layer addressing (such as Ethernet MAC) so we must not filter on IP.
+     According to RFC 1542 section 3.1.1, referred by RFC 2131). */
   if (netif == NULL) {
     /* remote port is DHCP server? */
     if (IPH_PROTO(iphdr) == IP_PROTO_UDP) {
@@ -268,7 +272,7 @@ ip_input(struct pbuf *p, struct netif *inp) {
     LWIP_DEBUGF(IP_DEBUG | DBG_TRACE | 1, ("ip_input: packet not for us.\n"));
 #if IP_FORWARD
     /* non-broadcast packet? */
-    if (!ip_addr_isbroadcast(&(iphdr->dest), inp)) {
+    if (!ip_addr_isbroadcast(&(iphdr->dest), &(inp->netmask))) {
       /* try to forward IP packet on (other) interfaces */
       ip_forward(p, iphdr, inp);
     }
@@ -280,19 +284,19 @@ ip_input(struct pbuf *p, struct netif *inp) {
     pbuf_free(p);
     return ERR_OK;
   }
-  /* packet consists of multiple fragments? */
+
+#if IP_REASSEMBLY
   if ((IPH_OFFSET(iphdr) & htons(IP_OFFMASK | IP_MF)) != 0) {
-#if IP_REASSEMBLY /* packet fragment reassembly code present? */
     LWIP_DEBUGF(IP_DEBUG, ("IP packet is a fragment (id=0x%04x tot_len=%u len=%u MF=%u offset=%u), calling ip_reass()\n",
       ntohs(IPH_ID(iphdr)), p->tot_len, ntohs(IPH_LEN(iphdr)), !!(IPH_OFFSET(iphdr) & htons(IP_MF)), (ntohs(IPH_OFFSET(iphdr)) & IP_OFFMASK)*8));
-    /* reassemble the packet*/
     p = ip_reass(p);
-    /* packet not fully reassembled yet? */
     if (p == NULL) {
       return ERR_OK;
     }
     iphdr = p->payload;
-#else /* IP_REASSEMBLY == 0, no packet fragment reassembly code present */
+  }
+#else /* IP_REASSEMBLY */
+  if ((IPH_OFFSET(iphdr) & htons(IP_OFFMASK | IP_MF)) != 0) {
     pbuf_free(p);
     LWIP_DEBUGF(IP_DEBUG | 2, ("IP packet dropped since it was fragmented (0x%x) (while IP_REASSEMBLY == 0).\n",
                   ntohs(IPH_OFFSET(iphdr))));
@@ -300,10 +304,10 @@ ip_input(struct pbuf *p, struct netif *inp) {
     IP_STATS_INC(ip.drop);
     snmp_inc_ipunknownprotos();
     return ERR_OK;
-#endif /* IP_REASSEMBLY */
   }
+#endif /* IP_REASSEMBLY */
 
-#if IP_OPTIONS == 0 /* no support for IP options in the IP header? */
+#if IP_OPTIONS == 0
   if (iphdrlen > IP_HLEN) {
     LWIP_DEBUGF(IP_DEBUG | 2, ("IP packet dropped since there were IP options (while IP_OPTIONS == 0).\n"));
     pbuf_free(p);
@@ -320,8 +324,7 @@ ip_input(struct pbuf *p, struct netif *inp) {
   LWIP_DEBUGF(IP_DEBUG, ("ip_input: p->len %d p->tot_len %d\n", p->len, p->tot_len));
 
 #if LWIP_RAW
-  /* raw input did not eat the packet? */
-  if (raw_input(p, inp) == 0) {
+  if (!raw_input(p, inp)) {
 #endif /* LWIP_RAW */
 
   switch (IPH_PROTO(iphdr)) {
@@ -344,8 +347,8 @@ ip_input(struct pbuf *p, struct netif *inp) {
     break;
   default:
     /* send ICMP destination protocol unreachable unless is was a broadcast */
-    if (!ip_addr_isbroadcast(&(iphdr->dest), inp) &&
-        !ip_addr_ismulticast(&(iphdr->dest))) {
+    if (!ip_addr_isbroadcast(&(iphdr->dest), &(inp->netmask)) &&
+       !ip_addr_ismulticast(&(iphdr->dest))) {
       p->payload = iphdr;
       icmp_dest_unreach(p, ICMP_DUR_PROTO);
     }
@@ -356,6 +359,7 @@ ip_input(struct pbuf *p, struct netif *inp) {
     IP_STATS_INC(ip.proterr);
     IP_STATS_INC(ip.drop);
     snmp_inc_ipunknownprotos();
+
   }
 #if LWIP_RAW
   } /* LWIP_RAW */
@@ -363,7 +367,9 @@ ip_input(struct pbuf *p, struct netif *inp) {
   return ERR_OK;
 }
 
-/**
+
+/* ip_output_if:
+ *
  * Sends an IP packet on a network interface. This function constructs
  * the IP header and calculates the IP header checksum. If the source
  * IP address is NULL, the IP address of the outgoing network
@@ -409,9 +415,7 @@ ip_output_if(struct pbuf *p, struct ip_addr *src, struct ip_addr *dest,
     }
 
     IPH_CHKSUM_SET(iphdr, 0);
-#if CHECKSUM_GEN_IP
     IPH_CHKSUM_SET(iphdr, inet_chksum(iphdr, IP_HLEN));
-#endif
   } else {
     iphdr = p->payload;
     dest = &(iphdr->dest);
@@ -433,7 +437,8 @@ ip_output_if(struct pbuf *p, struct ip_addr *src, struct ip_addr *dest,
   return netif->output(netif, p, dest);
 }
 
-/**
+/* ip_output:
+ *
  * Simple interface to ip_output_if. It finds the outgoing network
  * interface and calls upon ip_output_if to do the actual work.
  */

src/core/ipv4/ip_addr.c

@@ -32,38 +32,7 @@
 
 #include "lwip/ip_addr.h"
 #include "lwip/inet.h"
-#include "lwip/netif.h"
 
 /* used by IP_ADDR_ANY and IP_ADDR_BROADCAST in ip_addr.h */
 const struct ip_addr ip_addr_any = { 0x00000000UL };
 const struct ip_addr ip_addr_broadcast = { 0xffffffffUL };
-
-/* Determine if an address is a broadcast address on a network interface 
- * 
- * @param addr address to be checked
- * @param netif the network interface against which the address is checked
- * @return returns non-zero if the address is a broadcast address
- *
- */
-
-u8_t ip_addr_isbroadcast(struct ip_addr *addr, struct netif *netif)
-{
-  /* all ones (broadcast) or all zeroes (old skool broadcast) */
-  if ((addr->addr == ip_addr_broadcast.addr) ||
-      (addr->addr == ip_addr_any.addr))
-    return 1;
-  /* no broadcast support on this network interface? */
-  else if ((netif->flags & NETIF_FLAG_BROADCAST) == 0)
-    /* the given address cannot be a broadcast address
-     * nor can we check against any broadcast addresses */
-    return 0;
-  /* address matches network interface address exactly? => no broadcast */
-  else if (addr->addr == netif->ip_addr.addr)
-    return 0;
-  /* host identifier bits are all ones? => network broadcast address */
-  else if ((addr->addr & ~netif->netmask.addr) ==
-           (ip_addr_broadcast.addr & ~netif->netmask.addr))
-    return 1;
-  else
-    return 0;
-}

src/core/ipv4/ip_frag.c

@@ -1,9 +1,3 @@
-/* @file
- * 
- * This is the IP packet segmentation and reassembly implementation.
- *
- */
-
 /*
  * Copyright (c) 2001-2004 Swedish Institute of Computer Science.
  * All rights reserved. 
@@ -37,6 +31,14 @@
  * 
  */
 
+
+/* ip_frag.c
+ *
+ * This is the code for IP segmentation and reassembly
+ *
+ */
+
+
 #include "lwip/opt.h"
 #include "lwip/sys.h"
 #include "lwip/ip.h"
@@ -292,6 +294,7 @@ ip_frag(struct pbuf *p, struct netif *netif, struct ip_addr *dest)
   rambuf->tot_len = rambuf->len = mtu;
   rambuf->payload = MEM_ALIGN((void *)buf);
 
+
   /* Copy the IP header in it */
   iphdr = rambuf->payload;
   memcpy(iphdr, p->payload, IP_HLEN);

src/core/netif.c

@@ -198,14 +198,6 @@ netif_set_ipaddr(struct netif *netif, struct ip_addr *ipaddr)
   }
 #endif
   ip_addr_set(&(netif->ip_addr), ipaddr);
-#if 0 /* only allowed for Ethernet interfaces TODO: how can we check? */
-  /** For Ethernet network interfaces, we would like to send a
-   *  "gratuitous ARP"; this is an ARP packet sent by a node in order
-   *  to spontaneously cause other nodes to update an entry in their
-   *  ARP cache. From RFC 3220 "IP Mobility Support for IPv4" section 4.6.
-   */ 
-  etharp_query(netif, ipaddr, NULL);
-#endif
   LWIP_DEBUGF(NETIF_DEBUG | DBG_TRACE | DBG_STATE | 3, ("netif: IP address of interface %c%c set to %u.%u.%u.%u\n",
     netif->name[0], netif->name[1],
     (unsigned int)(ntohl(netif->ip_addr.addr) >> 24 & 0xff),

src/core/pbuf.c

@@ -11,15 +11,12 @@
  * list. This is called a "pbuf chain".
  *
  * Multiple packets may be queued, also using this singly linked list.
- * This is called a "packet queue".
- * 
- * So, a packet queue consists of one or more pbuf chains, each of
- * which consist of one or more pbufs. Currently, queues are only
- * supported in a limited section of lwIP, this is the etharp queueing
- * code. Outside of this section no packet queues are supported yet.
- * 
+ * This is called a "packet queue". So, a packet queue consists of one
+ * or more pbuf chains, each of which consist of one or more pbufs.
  * The differences between a pbuf chain and a packet queue are very
- * precise but subtle. 
+ * subtle. Currently, queues are only supported in a limited section
+ * of lwIP, this is the etharp queueing code. Outside of this section
+ * no packet queues are supported as of yet.
  *
  * The last pbuf of a packet has a ->tot_len field that equals the
  * ->len field. It can be found by traversing the list. If the last
@@ -453,35 +450,32 @@ pbuf_realloc(struct pbuf *p, u16_t new_len)
  *
  * The ->payload, ->tot_len and ->len fields are adjusted.
  *
- * @param hdr_size_inc Number of bytes to increment header size which
+ * @param hdr_size Number of bytes to increment header size which
  * increases the size of the pbuf. New space is on the front.
  * (Using a negative value decreases the header size.)
- * If hdr_size_inc is 0, this function does nothing and returns succesful.
  *
  * PBUF_ROM and PBUF_REF type buffers cannot have their sizes increased, so
  * the call will fail. A check is made that the increase in header size does
  * not move the payload pointer in front of the start of the buffer.
- * @return non-zero on failure, zero on success.
+ * @return 1 on failure, 0 on success.
  *
+ * @note May not be called on a packet queue.
  */
 u8_t
-pbuf_header(struct pbuf *p, s16_t header_size_increment)
+pbuf_header(struct pbuf *p, s16_t header_size)
 {
   void *payload;
 
-  LWIP_ASSERT("p != NULL", p != NULL);
-  if ((header_size_increment == 0) || (p == NULL)) return 0;
- 
   /* remember current payload pointer */
   payload = p->payload;
 
   /* pbuf types containing payloads? */
   if (p->flags == PBUF_FLAG_RAM || p->flags == PBUF_FLAG_POOL) {
     /* set new payload pointer */
-    p->payload = (u8_t *)p->payload - header_size_increment;
+    p->payload = (u8_t *)p->payload - header_size;
     /* boundary check fails? */
     if ((u8_t *)p->payload < (u8_t *)p + sizeof(struct pbuf)) {
-      LWIP_DEBUGF( PBUF_DEBUG | 2, ("pbuf_header: failed as %p < %p (not enough space for new header size)\n",
+      LWIP_DEBUGF( PBUF_DEBUG | 2, ("pbuf_header: failed as %p < %p\n",
         (u8_t *)p->payload,
         (u8_t *)p + sizeof(struct pbuf)) );\
       /* restore old payload pointer */
@@ -489,37 +483,35 @@ pbuf_header(struct pbuf *p, s16_t header_size_increment)
       /* bail out unsuccesfully */
       return 1;
     }
-  /* pbuf types refering to external payloads? */
+  /* pbuf types refering to payloads? */
   } else if (p->flags == PBUF_FLAG_REF || p->flags == PBUF_FLAG_ROM) {
     /* hide a header in the payload? */
-    if ((header_size_increment < 0) && (header_size_increment - p->len <= 0)) {
+    if ((header_size < 0) && (header_size - p->len <= 0)) {
       /* increase payload pointer */
-      p->payload = (u8_t *)p->payload - header_size_increment;
+      p->payload = (u8_t *)p->payload - header_size;
     } else {
       /* cannot expand payload to front (yet!)
        * bail out unsuccesfully */
       return 1;
     }
   }
+  LWIP_DEBUGF( PBUF_DEBUG, ("pbuf_header: old %p new %p (%d)\n", (void *)payload, (void *)p->payload, header_size) );
   /* modify pbuf length fields */
-  p->len += header_size_increment;
-  p->tot_len += header_size_increment;
-
-  LWIP_DEBUGF( PBUF_DEBUG, ("pbuf_header: old %p new %p (%d)\n",
-    (void *)payload, (void *)p->payload, header_size_increment));
+  p->len += header_size;
+  p->tot_len += header_size;
 
   return 0;
 }
 
 /**
- * Dereference a pbuf chain or queue and deallocate any no-longer-used
- * pbufs at the head of this chain or queue.
+ * Dereference a pbuf (chain) and deallocate any no-longer-used
+ * pbufs at the head of this chain.
  *
- * Decrements the pbuf reference count. If it reaches zero, the pbuf is
- * deallocated.
+ * Decrements the pbuf reference count. If it reaches
+ * zero, the pbuf is deallocated.
  *
  * For a pbuf chain, this is repeated for each pbuf in the chain,
- * up to the first pbuf which has a non-zero reference count after
+ * up to a pbuf which has a non-zero reference count after
  * decrementing. (This might de-allocate the whole chain.)
  *
  * @param pbuf The pbuf (chain) to be dereferenced.
@@ -527,7 +519,7 @@ pbuf_header(struct pbuf *p, s16_t header_size_increment)
  * @return the number of pbufs that were de-allocated
  * from the head of the chain.
  *
- * @note MUST NOT be called on a packet queue (Not verified to work yet).
+ * @note MUST NOT be called on a packet queue.
  * @note the reference counter of a pbuf equals the number of pointers
  * that refer to the pbuf (or into the pbuf).
  *
@@ -550,8 +542,6 @@ pbuf_free(struct pbuf *p)
   u8_t count;
   SYS_ARCH_DECL_PROTECT(old_level);
 
-  LWIP_ASSERT("p != NULL", p != NULL);
-  /* if assertions are disabled, proceed with debug output */
   if (p == NULL) {
     LWIP_DEBUGF(PBUF_DEBUG | DBG_TRACE | 2, ("pbuf_free(p == NULL) was called.\n"));
     return 0;
@@ -718,13 +708,11 @@ pbuf_chain(struct pbuf *h, struct pbuf *t)
 void
 pbuf_queue(struct pbuf *p, struct pbuf *n)
 {
-#if PBUF_DEBUG /* remember head of queue */
-  struct pbuf *q = p;
-#endif
-  /* programmer stupidity checks */
   LWIP_ASSERT("p != NULL", p != NULL);
   LWIP_ASSERT("n != NULL", n != NULL);
-  if ((p == NULL) || (n == NULL)) return;
+
+  if ((p == NULL) || (n == NULL))
+    return;
 
   /* iterate through all packets on queue */
   while (p->next != NULL) {
@@ -732,34 +720,25 @@ pbuf_queue(struct pbuf *p, struct pbuf *n)
 #if PBUF_DEBUG
     /* iterate through all pbufs in packet */
     while (p->tot_len != p->len) {
-      /* make sure invariant condition holds */
-      LWIP_ASSERT("p->len < p->tot_len", p->len < p->tot_len);
       /* make sure each packet is complete */
       LWIP_ASSERT("p->next != NULL", p->next != NULL);
       p = p->next;
-      /* { p->tot_len == p->len => p is last pbuf of a packet } */
     }
 #endif
-    /* { p->tot_len == p->len and p is last pbuf of a packet } */
+    /* now p->tot_len == p->len */
     /* proceed to next packet on queue */
-    if (p->next != NULL) p = p->next;
+    p = p->next;
   }
-  /* { p->tot_len == p->len and p->next == NULL } ==>
-   * { p is last pbuf of last packet on queue } */
   /* chain last pbuf of queue with n */
   p->next = n;
-  /* n is now referenced to by the (packet p in the) queue */
+  /* n is now referenced to one more time */
   pbuf_ref(n);
-  LWIP_DEBUGF(PBUF_DEBUG | DBG_FRESH | 2,
-    ("pbuf_queue: newly queued packet %p sits after packet %p in queue %p\n",
-    (void *)n, (void *)p, (void *)q));
+  LWIP_DEBUGF(PBUF_DEBUG | DBG_FRESH | 2, ("pbuf_queue: referencing queued packet %p\n", (void *)n));
 }
 
 /**
  * Remove a packet from the head of a queue.
  *
- * The caller MUST reference the remainder of the queue (as returned).
- * 
  * @param p pointer to first packet on the queue which will be dequeued.
  * @return first packet on the remaining queue (NULL if no further packets).
  *
@@ -772,25 +751,17 @@ pbuf_dequeue(struct pbuf *p)
 
   /* iterate through all pbufs in packet */
   while (p->tot_len != p->len) {
-    /* make sure invariant condition holds */
-    LWIP_ASSERT("p->len < p->tot_len", p->len < p->tot_len);
     /* make sure each packet is complete */
     LWIP_ASSERT("p->next != NULL", p->next != NULL);
     p = p->next;
   }
-  /* { p->tot_len == p->len } => p is the last pbuf of the first packet */
   /* remember next packet on queue */
   q = p->next;
   /* dequeue p from queue */
   p->next = NULL;
-  /* any next packet on queue? */
-  if (q != NULL) {
-    /* although q is no longer referenced by p, it MUST be referenced by
-     * the caller, who is maintaining this packet queue */
-    LWIP_DEBUGF(PBUF_DEBUG | DBG_FRESH | 2, ("pbuf_dequeue: at least one packet on queue, first %p\n", (void *)q));
-  } else {
-    LWIP_DEBUGF(PBUF_DEBUG | DBG_FRESH | 2, ("pbuf_dequeue: no further packets on queue\n"));
-  }
+  /* q is now referenced to one less time */
+  pbuf_free(q);
+  LWIP_DEBUGF(PBUF_DEBUG | DBG_FRESH | 2, ("pbuf_dequeue: dereferencing remaining queue %p\n", (void *)q));
   return q;
 }
 #endif

src/core/raw.c

@@ -1,9 +1,6 @@
 /**
  * @file
- * 
- * Implementation of raw protocol PCBs for low-level handling of
- * different types of protocols besides (or overriding) those
- * already available in lwIP.
+ * Raw Access module
  *
  */
 /*
@@ -38,6 +35,13 @@
  *
  */
 
+
+/* raw.c
+ *
+ * The code for the Raw Access to the IP
+ *
+ */
+
 #include "lwip/opt.h"
 
 #include "lwip/def.h"
@@ -53,10 +57,11 @@
 #include "lwip/snmp.h"
 
 #if LWIP_RAW
+/* The list of RAW PCBs */
 
-/** The list of RAW PCBs */
 static struct raw_pcb *raw_pcbs = NULL;
 
+
 void
 raw_init(void)
 {
@@ -64,54 +69,42 @@ raw_init(void)
 }
 
 /**
- * Determine if in incoming IP packet is covered by a RAW PCB
- * and if so, pass it to a user-provided receive callback function.
+ * Determine if in incoming IP packet is covered by a RAW pcb and
+ * and process it if possible
  *
  * Given an incoming IP datagram (as a chain of pbufs) this function
- * finds a corresponding RAW PCB and calls the corresponding receive
- * callback function.
+ * finds a corresponding RAW PCB and
  *
  * @param pbuf pbuf to be demultiplexed to a RAW PCB.
  * @param netif network interface on which the datagram was received.
- * @Return - 1 if the packet has been eaten by a RAW PCB receive
- *           callback function. The caller MAY NOT not reference the
- *           packet any longer, and MAY NOT call pbuf_free().
- * @return - 0 if packet is not eaten (pbuf is still referenced by the
- *           caller).
+ * @return 0 if packet is not eated (pbuf needs to be freed then)
+ *         or 1 if the packet has been eaten (pbuf needs not to be freed
+ *         then)
  *
  */
-u8_t
+int
 raw_input(struct pbuf *p, struct netif *inp)
 {
   struct raw_pcb *pcb;
   struct ip_hdr *iphdr;
   int proto;
-  u8_t eaten = 0;
+  int rc = 0;
 
   iphdr = p->payload;
   proto = IPH_PROTO(iphdr);
 
-  pcb = raw_pcbs;
-  /* loop through all raw pcbs until the packet is eaten by one */
-  /* this allows multiple pcbs to match against the packet by design */
-  while ((eaten == 0) && (pcb != NULL)) {
+  for(pcb = raw_pcbs; pcb != NULL; pcb = pcb->next) {
     if (pcb->protocol == proto) {
-      /* receive callback function available? */
-      if (pcb->recv != NULL) {
-        /* the receive callback function did not eat the packet? */
-        if (pcb->recv(pcb->recv_arg, pcb, p, &(iphdr->src)) != 0)
-        {
-          /* receive function ate the packet */
-          p = NULL;
-          eaten = 1;
-        }
+      if (pcb->recv) {
+        if (!pcb->recv(pcb->recv_arg, pcb, p, &(iphdr->src)))
+          return 0;
       }
-      /* no receive callback function was set for this raw PCB */
-      /* drop the packet */
+      pbuf_free(p);
+      rc = 1;
+      break;
     }
-    pcb = pcb->next;
   }
-  return eaten;
+  return rc;
 }
 
 /**
@@ -123,7 +116,7 @@ raw_input(struct pbuf *p, struct netif *inp)
  *
  * @return lwIP error code.
  * - ERR_OK. Successful. No error occured.
- * - ERR_USE. The specified IP address is already bound to by
+ * - ERR_USE. The specified ipaddr is already bound to by
  * another RAW PCB.
  *
  * @see raw_disconnect()
@@ -137,7 +130,7 @@ raw_bind(struct raw_pcb *pcb, struct ip_addr *ipaddr)
 
 /**
  * Connect an RAW PCB. This function is required by upper layers
- * of lwip. Using the raw api you could use raw_sendto() instead
+ * of lwip. Using the raw api you could use raw_send_to() instead
  *
  * This will associate the RAW PCB with the remote address.
  *
@@ -146,7 +139,7 @@ raw_bind(struct raw_pcb *pcb, struct ip_addr *ipaddr)
  *
  * @return lwIP error code
  *
- * @see raw_disconnect() and raw_sendto()
+ * @see raw_disconnect() and raw_send_to()
  */
 err_t
 raw_connect(struct raw_pcb *pcb, struct ip_addr *ipaddr)
@@ -157,21 +150,14 @@ raw_connect(struct raw_pcb *pcb, struct ip_addr *ipaddr)
 
 
 /**
- * Set the callback function for received packets that match the
- * raw PCB's protocol and binding. 
- * 
- * The callback function MUST either
- * - eat the packet by calling pbuf_free() and returning non-zero. The
- *   packet will not be passed to other raw PCBs or other protocol layers.
- * - not free the packet, and return zero. The packet will be matched
- *   against further PCBs and/or forwarded to another protocol layers.
- * 
- * @return non-zero if the packet was free()d, zero if the packet remains
- * available for others.
+ * Set the callback function if a RAW packet with the pcb's protocol
+ * is received. If the callback function returns a value unequal 0
+ * the raw packet is "eaten" and not forwarded to any other raw pcb
+ * including lwip itself
  */
 void
 raw_recv(struct raw_pcb *pcb,
-         u8_t (* recv)(void *arg, struct raw_pcb *upcb, struct pbuf *p,
+         int (* recv)(void *arg, struct raw_pcb *upcb, struct pbuf *p,
                       struct ip_addr *addr),
          void *recv_arg)
 {
@@ -182,25 +168,25 @@ raw_recv(struct raw_pcb *pcb,
 
 /**
  * Send the raw IP packet to the given address. Note that actually you cannot
- * modify the IP headers (this is inconsistent with the receive callback where
- * you actually get the IP headers), you can only specify the IP payload here.
- * It requires some more changes in lwIP. (there will be a raw_send() function
- * then.)
+ * modify the IP headers (this is inconsitent with the receive callback where
+ * you actually get the IP headers), you can only specifiy the ip payload here.
+ * It requires some more changes in LWIP. (there will be a raw_send() function
+ * then)
  *
  * @param pcb the raw pcb which to send
- * @param p the IP payload to send
- * @param ipaddr the destination address of the IP packet
+ * @param p the ip payload to send
+ * @param ipaddr the destination address of the whole IP packet
  *
  */
 err_t
-raw_sendto(struct raw_pcb *pcb, struct pbuf *p, struct ip_addr *ipaddr)
+raw_send_to(struct raw_pcb *pcb, struct pbuf *p, struct ip_addr *ipaddr)
 {
   err_t err;
   struct netif *netif;
   struct ip_addr *src_ip;
   struct pbuf *q; /* q will be sent down the stack */
   
-  LWIP_DEBUGF(RAW_DEBUG | DBG_TRACE | 3, ("raw_sendto\n"));
+  LWIP_DEBUGF(RAW_DEBUG | DBG_TRACE | 3, ("raw_send_to\n"));
   
   /* not enough space to add an IP header to first pbuf in given p chain? */
   if (pbuf_header(p, IP_HLEN)) {
@@ -208,13 +194,13 @@ raw_sendto(struct raw_pcb *pcb, struct pbuf *p, struct ip_addr *ipaddr)
     q = pbuf_alloc(PBUF_IP, 0, PBUF_RAM);
     /* new header pbuf could not be allocated? */
     if (q == NULL) {
-      LWIP_DEBUGF(RAW_DEBUG | DBG_TRACE | 2, ("raw_sendto: could not allocate header\n"));
+      LWIP_DEBUGF(RAW_DEBUG | DBG_TRACE | 2, ("raw_send_to: could not allocate header\n"));
       return ERR_MEM;
     }
     /* chain header q in front of given pbuf p */
     pbuf_chain(q, p);
     /* { first pbuf q points to header pbuf } */
-    LWIP_DEBUGF(RAW_DEBUG, ("raw_sendto: added header pbuf %p before given pbuf %p\n", (void *)q, (void *)p));
+    LWIP_DEBUGF(RAW_DEBUG, ("raw_send_to: added header pbuf %p before given pbuf %p\n", (void *)q, (void *)p));
   }  else {
     /* first pbuf q equals given pbuf */
     q = p;
@@ -222,11 +208,10 @@ raw_sendto(struct raw_pcb *pcb, struct pbuf *p, struct ip_addr *ipaddr)
   }
   
   if ((netif = ip_route(ipaddr)) == NULL) {
-    LWIP_DEBUGF(RAW_DEBUG | 1, ("raw_sendto: No route to 0x%lx\n", ipaddr->addr));
+    LWIP_DEBUGF(RAW_DEBUG | 1, ("raw_send_to: No route to 0x%lx\n", ipaddr->addr));
 #if RAW_STATS
     /*    ++lwip_stats.raw.rterr;*/
 #endif /* RAW_STATS */
-    /* free any temporary header pbuf allocated by pbuf_header() */
     if (q != p) {
       pbuf_free(q);
     }
@@ -255,14 +240,14 @@ raw_sendto(struct raw_pcb *pcb, struct pbuf *p, struct ip_addr *ipaddr)
  * Send the raw IP packet to the address given by raw_connect()
  *
  * @param pcb the raw pcb which to send
- * @param p the IP payload to send
- * @param ipaddr the destination address of the IP packet
+ * @param p the ip payload to send
+ * @param ipaddr the destination address of the whole IP packet
  *
  */
 err_t
 raw_send(struct raw_pcb *pcb, struct pbuf *p)
 {
-  return raw_sendto(pcb, p, &pcb->remote_ip);
+  return raw_send_to(pcb,p,&pcb->remote_ip);
 }
 
 /**
@@ -281,7 +266,7 @@ raw_remove(struct raw_pcb *pcb)
   if (raw_pcbs == pcb) {
     /* make list start at 2nd pcb */
     raw_pcbs = raw_pcbs->next;
-    /* pcb not 1st in list */
+  /* pcb not 1st in list */
   } else for(pcb2 = raw_pcbs; pcb2 != NULL; pcb2 = pcb2->next) {
     /* find pcb in raw_pcbs list */
     if (pcb2->next != NULL && pcb2->next == pcb) {
@@ -318,6 +303,7 @@ raw_new(u16_t proto) {
     pcb->next = raw_pcbs;
     raw_pcbs = pcb;
   }
+
   return pcb;
 }
 

src/core/tcp.c

@@ -2,11 +2,6 @@
  * @file
  *
  * Transmission Control Protocol for IP
- *
- * This file contains common functions for the TCP implementation, such as functinos
- * for manipulating the data structures and the TCP timer functions. TCP functions
- * related to input and output is found in tcp_in.c and tcp_out.c respectively.
- *
  */
 
 /*
@@ -41,6 +36,17 @@
  *
  */
 
+
+/* tcp.c
+ *
+ * This file contains common functions for the TCP implementation, such as functinos
+ * for manipulating the data structures and the TCP timer functions. TCP functions
+ * related to input and output is found in tcp_input.c and tcp_output.c respectively.
+ *
+ */
+
+
+
 #include "lwip/opt.h"
 #include "lwip/def.h"
 #include "lwip/mem.h"
@@ -57,22 +63,26 @@ const u8_t tcp_backoff[13] =
 
 /* The TCP PCB lists. */
 
-/** List of all TCP PCBs in LISTEN state */
+/* List of all TCP PCBs in LISTEN state. */
 union tcp_listen_pcbs_t tcp_listen_pcbs;
-/** List of all TCP PCBs that are in a state in which
- * they accept or send data. */
-struct tcp_pcb *tcp_active_pcbs;  
-/** List of all TCP PCBs in TIME-WAIT state */
-struct tcp_pcb *tcp_tw_pcbs;
+struct tcp_pcb *tcp_active_pcbs;  /* List of all TCP PCBs that are in a
+         state in which they accept or send
+         data. */
+struct tcp_pcb *tcp_tw_pcbs;      /* List of all TCP PCBs in TIME-WAIT. */
 
 struct tcp_pcb *tcp_tmp_pcb;
 
 static u8_t tcp_timer;
+
 static u16_t tcp_new_port(void);
 
-/**
+
+/*
+ * tcp_init():
+ *
  * Initializes the TCP layer.
  */
+
 void
 tcp_init(void)
 {
@@ -88,10 +98,13 @@ tcp_init(void)
   
 }
 
-/**
+/*
+ * tcp_tmr():
+ *
  * Called periodically to dispatch TCP timers.
  *
  */
+
 void
 tcp_tmr(void)
 {
@@ -105,10 +118,13 @@ tcp_tmr(void)
   }
 }
 
-/**
+/*
+ * tcp_close():
+ *
  * Closes the connection held by the PCB.
  *
  */
+
 err_t
 tcp_close(struct tcp_pcb *pcb)
 {
@@ -158,12 +174,15 @@ tcp_close(struct tcp_pcb *pcb)
   return err;
 }
 
-/**
+/*
+ * tcp_abort()
+ *
  * Aborts a connection by sending a RST to the remote host and deletes
  * the local protocol control block. This is done when a connection is
  * killed because of shortage of memory.
  *
  */
+
 void
 tcp_abort(struct tcp_pcb *pcb)
 {
@@ -212,7 +231,9 @@ tcp_abort(struct tcp_pcb *pcb)
   }
 }
 
-/**
+/*
+ * tcp_bind():
+ *
  * Binds the connection to a local portnumber and IP address. If the
  * IP address is not given (i.e., ipaddr == NULL), the IP address of
  * the outgoing network interface is used instead.
@@ -367,13 +388,16 @@ tcp_accept_null(void *arg, struct tcp_pcb *pcb, err_t err)
 }
 #endif /* LWIP_CALLBACK_API */
 
-/**
+/*
+ * tcp_listen():
+ *
  * Set the state of the connection to be LISTEN, which means that it
  * is able to accept incoming connections. The protocol control block
  * is reallocated in order to consume less memory. Setting the
  * connection to LISTEN is an irreversible process.
  *
  */
+
 struct tcp_pcb *
 tcp_listen(struct tcp_pcb *pcb)
 {
@@ -403,12 +427,15 @@ tcp_listen(struct tcp_pcb *pcb)
   return (struct tcp_pcb *)lpcb;
 }
 
-/**
+/*
+ * tcp_recved():
+ *
  * This function should be called by the application when it has
  * processed the data. The purpose is to advertise a larger window
  * when the data has been processed.
  *
  */
+
 void
 tcp_recved(struct tcp_pcb *pcb, u16_t len)
 {
@@ -436,10 +463,13 @@ tcp_recved(struct tcp_pcb *pcb, u16_t len)
          len, pcb->rcv_wnd, TCP_WND - pcb->rcv_wnd));
 }
 
-/**
+/*
+ * tcp_new_port():
+ *
  * A nastly hack featuring 'goto' statements that allocates a
  * new TCP local port.
  */
+
 static u16_t
 tcp_new_port(void)
 {
@@ -473,11 +503,14 @@ tcp_new_port(void)
   return port;
 }
 
-/**
+/*
+ * tcp_connect():
+ *
  * Connects to another host. The function given as the "connected"
  * argument will be called when the connection has been established.
  *
  */
+
 err_t
 tcp_connect(struct tcp_pcb *pcb, struct ip_addr *ipaddr, u16_t port,
       err_t (* connected)(void *arg, struct tcp_pcb *tpcb, err_t err))
@@ -525,11 +558,14 @@ tcp_connect(struct tcp_pcb *pcb, struct ip_addr *ipaddr, u16_t port,
   return ret;
 } 
 
-/**
+/*
+ * tcp_slowtmr():
+ *
  * Called every 500 ms and implements the retransmission timer and the timer that
  * removes PCBs that have been in TIME-WAIT for enough time. It also increments
  * various timers such as the inactivity timer in each PCB.
  */
+
 void
 tcp_slowtmr(void)
 {
@@ -706,9 +742,12 @@ tcp_slowtmr(void)
   }
 }
 
-/**
+/*
+ * tcp_fasttmr():
+ *
  * Is called every TCP_FAST_INTERVAL (250 ms) and sends delayed ACKs.
  */
+
 void
 tcp_fasttmr(void)
 {
@@ -724,10 +763,13 @@ tcp_fasttmr(void)
   }
 }
 
-/**
+/*
+ * tcp_segs_free():
+ *
  * Deallocates a list of TCP segments (tcp_seg structures).
  *
  */
+
 u8_t
 tcp_segs_free(struct tcp_seg *seg)
 {
@@ -741,10 +783,13 @@ tcp_segs_free(struct tcp_seg *seg)
   return count;
 }
 
-/**
+/*
+ * tcp_seg_free():
+ *
  * Frees a TCP segment.
  *
  */
+
 u8_t
 tcp_seg_free(struct tcp_seg *seg)
 {
@@ -762,10 +807,13 @@ tcp_seg_free(struct tcp_seg *seg)
   return count;
 }
 
-/**
+/*
+ * tcp_setprio():
+ *
  * Sets the priority of a connection.
  *
  */
+
 void
 tcp_setprio(struct tcp_pcb *pcb, u8_t prio)
 {
@@ -773,10 +821,13 @@ tcp_setprio(struct tcp_pcb *pcb, u8_t prio)
 }
 #if TCP_QUEUE_OOSEQ
 
-/**
+/*
+ * tcp_seg_copy():
+ *
  * Returns a copy of the given TCP segment.
  *
  */ 
+
 struct tcp_seg *
 tcp_seg_copy(struct tcp_seg *seg)
 {
@@ -912,13 +963,12 @@ tcp_alloc(u8_t prio)
   return pcb;
 }
 
-/**
+/*
+ * tcp_new():
+ *
  * Creates a new TCP protocol control block but doesn't place it on
  * any of the TCP PCB lists.
  *
- * @internal: Maybe there should be a idle TCP PCB list where these
- * PCBs are put on. We can then implement port reservation using
- * tcp_bind(). Currently, we lack this (BSD socket type of) feature.
  */
 
 struct tcp_pcb *
@@ -942,11 +992,14 @@ tcp_arg(struct tcp_pcb *pcb, void *arg)
 }
 #if LWIP_CALLBACK_API
 
-/**
+/*
+ * tcp_recv():
+ *
  * Used to specify the function that should be called when a TCP
  * connection receives data.
  *
  */ 
+
 void
 tcp_recv(struct tcp_pcb *pcb,
    err_t (* recv)(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err))
@@ -954,7 +1007,9 @@ tcp_recv(struct tcp_pcb *pcb,
   pcb->recv = recv;
 }
 
-/**
+/*
+ * tcp_sent():
+ *
  * Used to specify the function that should be called when TCP data
  * has been successfully delivered to the remote host.
  *
@@ -967,11 +1022,14 @@ tcp_sent(struct tcp_pcb *pcb,
   pcb->sent = sent;
 }
 
-/**
+/*
+ * tcp_err():
+ *
  * Used to specify the function that should be called when a fatal error
  * has occured on the connection.
  *
  */ 
+
 void
 tcp_err(struct tcp_pcb *pcb,
    void (* errf)(void *arg, err_t err))
@@ -979,11 +1037,14 @@ tcp_err(struct tcp_pcb *pcb,
   pcb->errf = errf;
 }
 
-/**
+/*
+ * tcp_accept():
+ *
  * Used for specifying the function that should be called when a
  * LISTENing connection has been connected to another host.
  *
  */ 
+
 void
 tcp_accept(struct tcp_pcb *pcb,
      err_t (* accept)(void *arg, struct tcp_pcb *newpcb, err_t err))
@@ -993,12 +1054,15 @@ tcp_accept(struct tcp_pcb *pcb,
 #endif /* LWIP_CALLBACK_API */
 
 
-/**
+/*
+ * tcp_poll():
+ *
  * Used to specify the function that should be called periodically
  * from TCP. The interval is specified in terms of the TCP coarse
  * timer interval, which is called twice a second.
  *
  */ 
+
 void
 tcp_poll(struct tcp_pcb *pcb,
    err_t (* poll)(void *arg, struct tcp_pcb *tpcb), u8_t interval)
@@ -1009,10 +1073,13 @@ tcp_poll(struct tcp_pcb *pcb,
   pcb->pollinterval = interval;
 }
 
-/**
+/*
+ * tcp_pcb_purge():
+ *
  * Purges a TCP PCB. Removes any buffered data and frees the buffer memory.
  *
  */
+
 void
 tcp_pcb_purge(struct tcp_pcb *pcb)
 {
@@ -1042,10 +1109,13 @@ tcp_pcb_purge(struct tcp_pcb *pcb)
   }
 }
 
-/**
+/*
+ * tcp_pcb_remove():
+ *
  * Purges the PCB and removes it from a PCB list. Any delayed ACKs are sent first.
  *
  */
+
 void
 tcp_pcb_remove(struct tcp_pcb **pcblist, struct tcp_pcb *pcb)
 {
@@ -1065,10 +1135,13 @@ tcp_pcb_remove(struct tcp_pcb **pcblist, struct tcp_pcb *pcb)
   LWIP_ASSERT("tcp_pcb_remove: tcp_pcbs_sane()", tcp_pcbs_sane());
 }
 
-/**
+/*
+ * tcp_next_iss():
+ *
  * Calculates a new initial sequence number for new connections.
  *
  */
+
 u32_t
 tcp_next_iss(void)
 {

src/core/tcp_in.c

@@ -2,12 +2,6 @@
  * @file
  *
  * Transmission Control Protocol, incoming traffic
- *
- * The input processing functions of TCP.
- *
- * These functions are generally called in the order (ip_input() ->) tcp_input() ->
- * tcp_process() -> tcp_receive() (-> application).
- * 
  */
 
 /*
@@ -42,10 +36,21 @@
  *
  */
 
+
+/* tcp_input.c
+ *
+ * The input processing functions of TCP.
+ *
+ * These functions are generally called in the order (ip_input() ->) tcp_input() ->
+ * tcp_process() -> tcp_receive() (-> application).
+ *
+ */
+
+
+
 #include "lwip/def.h"
 #include "lwip/opt.h"
 
-#include "lwip/ip_addr.h"
 #include "lwip/netif.h"
 #include "lwip/mem.h"
 #include "lwip/memp.h"
@@ -125,13 +130,12 @@ tcp_input(struct pbuf *p, struct netif *inp)
   }
 
   /* Don't even process incoming broadcasts/multicasts. */
-  if (ip_addr_isbroadcast(&(iphdr->dest), inp) ||
-      ip_addr_ismulticast(&(iphdr->dest))) {
+  if (ip_addr_isbroadcast(&(iphdr->dest), &(inp->netmask)) ||
+     ip_addr_ismulticast(&(iphdr->dest))) {
     pbuf_free(p);
     return;
   }
 
-#if CHECKSUM_CHECK_TCP
   /* Verify TCP checksum. */
   if (inet_chksum_pseudo(p, (struct ip_addr *)&(iphdr->src),
       (struct ip_addr *)&(iphdr->dest),
@@ -148,7 +152,6 @@ tcp_input(struct pbuf *p, struct netif *inp)
     pbuf_free(p);
     return;
   }
-#endif
 
   /* Move the payload pointer in the pbuf so that it points to the
      TCP data instead of the TCP header. */

src/core/tcp_out.c

@@ -2,11 +2,7 @@
  * @file
  *
  * Transmission Control Protocol, outgoing traffic
- *
- * The output functions of TCP.
- *
  */
-
 /*
  * Copyright (c) 2001-2004 Swedish Institute of Computer Science.
  * All rights reserved.
@@ -39,6 +35,15 @@
  *
  */
 
+
+/* tcp_output.c
+ *
+ * The output functions of TCP.
+ *
+ */
+
+
+
 #include "lwip/def.h"
 #include "lwip/opt.h"
 
@@ -46,7 +51,6 @@
 #include "lwip/memp.h"
 #include "lwip/sys.h"
 
-#include "lwip/ip_addr.h"
 #include "lwip/netif.h"
 
 #include "lwip/inet.h"
@@ -402,10 +406,8 @@ tcp_output(struct tcp_pcb *pcb)
     TCPH_HDRLEN_SET(tcphdr, 5);
 
     tcphdr->chksum = 0;
-#if CHECKSUM_GEN_TCP
     tcphdr->chksum = inet_chksum_pseudo(p, &(pcb->local_ip), &(pcb->remote_ip),
           IP_PROTO_TCP, p->tot_len);
-#endif
 
     ip_output(p, &(pcb->local_ip), &(pcb->remote_ip), pcb->ttl, pcb->tos,
         IP_PROTO_TCP);
@@ -521,12 +523,10 @@ tcp_output_segment(struct tcp_seg *seg, struct tcp_pcb *pcb)
   seg->p->payload = seg->tcphdr;
 
   seg->tcphdr->chksum = 0;
-#if CHECKSUM_GEN_TCP
   seg->tcphdr->chksum = inet_chksum_pseudo(seg->p,
              &(pcb->local_ip),
              &(pcb->remote_ip),
              IP_PROTO_TCP, seg->p->tot_len);
-#endif
   TCP_STATS_INC(tcp.xmit);
 
   ip_output(seg->p, &(pcb->local_ip), &(pcb->remote_ip), pcb->ttl, pcb->tos,
@@ -557,10 +557,9 @@ tcp_rst(u32_t seqno, u32_t ackno,
   TCPH_HDRLEN_SET(tcphdr, 5);
 
   tcphdr->chksum = 0;
-#if CHECKSUM_GEN_TCP
   tcphdr->chksum = inet_chksum_pseudo(p, local_ip, remote_ip,
               IP_PROTO_TCP, p->tot_len);
-#endif
+
   TCP_STATS_INC(tcp.xmit);
    /* Send output with hardcoded TTL since we have no access to the pcb */
   ip_output(p, local_ip, remote_ip, TCP_TTL, 0, IP_PROTO_TCP);
@@ -627,9 +626,8 @@ tcp_keepalive(struct tcp_pcb *pcb)
    TCPH_HDRLEN_SET(tcphdr, 5);
    
    tcphdr->chksum = 0;
-#if CHECKSUM_GEN_TCP
    tcphdr->chksum = inet_chksum_pseudo(p, &pcb->local_ip, &pcb->remote_ip, IP_PROTO_TCP, p->tot_len);
-#endif
+
   TCP_STATS_INC(tcp.xmit);
 
    /* Send output to IP */

src/core/udp.c

@@ -47,10 +47,10 @@
 #include "lwip/def.h"
 #include "lwip/memp.h"
 #include "lwip/inet.h"
-#include "lwip/ip_addr.h"
 #include "lwip/netif.h"
 #include "lwip/udp.h"
 #include "lwip/icmp.h"
+#include "lwip/ip_addr.h"
 
 #include "lwip/stats.h"
 
@@ -246,7 +246,6 @@ udp_input(struct pbuf *p, struct netif *inp)
     if (IPH_PROTO(iphdr) == IP_PROTO_UDPLITE) {
 #endif /* IPv4 */
       /* Do the UDP Lite checksum */
-#if CHECKSUM_CHECK_UDP
       if (inet_chksum_pseudo(p, (struct ip_addr *)&(iphdr->src),
          (struct ip_addr *)&(iphdr->dest),
          IP_PROTO_UDPLITE, ntohs(udphdr->len)) != 0) {
@@ -257,9 +256,7 @@ udp_input(struct pbuf *p, struct netif *inp)
   pbuf_free(p);
   goto end;
       }
-#endif
     } else {
-#if CHECKSUM_CHECK_UDP
       if (udphdr->chksum != 0) {
   if (inet_chksum_pseudo(p, (struct ip_addr *)&(iphdr->src),
        (struct ip_addr *)&(iphdr->dest),
@@ -273,7 +270,6 @@ udp_input(struct pbuf *p, struct netif *inp)
     goto end;
   }
       }
-#endif
     }
     pbuf_header(p, -UDP_HLEN);
     if (pcb != NULL) {
@@ -311,8 +307,8 @@ udp_input(struct pbuf *p, struct netif *inp)
       /* No match was found, send ICMP destination port unreachable unless
       destination address was broadcast/multicast. */
 
-      if (!ip_addr_isbroadcast(&iphdr->dest, inp) &&
-          !ip_addr_ismulticast(&iphdr->dest)) {
+      if (!ip_addr_isbroadcast(&iphdr->dest, &inp->netmask) &&
+   !ip_addr_ismulticast(&iphdr->dest)) {
 
   /* adjust pbuf pointer */
   p->payload = iphdr;
@@ -453,14 +449,10 @@ udp_send(struct udp_pcb *pcb, struct pbuf *p)
     /* set UDP message length in UDP header */
     udphdr->len = htons(pcb->chksum_len);
     /* calculate checksum */
-#if CHECKSUM_GEN_UDP
     udphdr->chksum = inet_chksum_pseudo(q, src_ip, &(pcb->remote_ip),
           IP_PROTO_UDP, pcb->chksum_len);
     /* chksum zero must become 0xffff, as zero means 'no checksum' */
     if (udphdr->chksum == 0x0000) udphdr->chksum = 0xffff;
-#else
-    udphdr->chksum = 0x0000;
-#endif
     /* output to IP */
     LWIP_DEBUGF(UDP_DEBUG, ("udp_send: ip_output_if (,,,,IP_PROTO_UDPLITE,)\n"));
     err = ip_output_if (q, src_ip, &pcb->remote_ip, pcb->ttl, pcb->tos, IP_PROTO_UDPLITE, netif);    
@@ -469,15 +461,11 @@ udp_send(struct udp_pcb *pcb, struct pbuf *p)
     LWIP_DEBUGF(UDP_DEBUG, ("udp_send: UDP packet length %u\n", q->tot_len));
     udphdr->len = htons(q->tot_len);
     /* calculate checksum */
-#if CHECKSUM_GEN_UDP
     if ((pcb->flags & UDP_FLAGS_NOCHKSUM) == 0) {
       udphdr->chksum = inet_chksum_pseudo(q, src_ip, &pcb->remote_ip, IP_PROTO_UDP, q->tot_len);
       /* chksum zero must become 0xffff, as zero means 'no checksum' */
       if (udphdr->chksum == 0x0000) udphdr->chksum = 0xffff;
     }
-#else
-    udphdr->chksum = 0x0000;
-#endif
     LWIP_DEBUGF(UDP_DEBUG, ("udp_send: UDP checksum 0x%04x\n", udphdr->chksum));
     LWIP_DEBUGF(UDP_DEBUG, ("udp_send: ip_output_if (,,,,IP_PROTO_UDP,)\n"));
     /* output to IP */

src/include/ipv4/lwip/icmp.h

@@ -37,7 +37,6 @@
 #include "lwip/opt.h"
 #include "lwip/pbuf.h"
 
-#include "lwip/ip_addr.h"
 #include "lwip/netif.h"
 
 #define ICMP_ER 0      /* echo reply */
@@ -71,24 +70,36 @@ void icmp_input(struct pbuf *p, struct netif *inp);
 void icmp_dest_unreach(struct pbuf *p, enum icmp_dur_type t);
 void icmp_time_exceeded(struct pbuf *p, enum icmp_te_type t);
 
+#ifdef PACK_STRUCT_USE_INCLUDES
+#  include "arch/bpstruct.h"
+#endif
+PACK_STRUCT_BEGIN
 struct icmp_echo_hdr {
-  u16_t _type_code;
-  u16_t chksum;
-  u16_t id;
-  u16_t seqno;
-};
+  PACK_STRUCT_FIELD(u16_t _type_code);
+  PACK_STRUCT_FIELD(u16_t chksum);
+  PACK_STRUCT_FIELD(u16_t id);
+  PACK_STRUCT_FIELD(u16_t seqno);
+} PACK_STRUCT_STRUCT;
+PACK_STRUCT_END
 
+PACK_STRUCT_BEGIN
 struct icmp_dur_hdr {
-  u16_t _type_code;
-  u16_t chksum;
-  u32_t unused;
-};
+  PACK_STRUCT_FIELD(u16_t _type_code);
+  PACK_STRUCT_FIELD(u16_t chksum);
+  PACK_STRUCT_FIELD(u32_t unused);
+} PACK_STRUCT_STRUCT;
+PACK_STRUCT_END
 
+PACK_STRUCT_BEGIN
 struct icmp_te_hdr {
-  u16_t _type_code;
-  u16_t chksum;
-  u32_t unused;
-};
+  PACK_STRUCT_FIELD(u16_t _type_code);
+  PACK_STRUCT_FIELD(u16_t chksum);
+  PACK_STRUCT_FIELD(u32_t unused);
+} PACK_STRUCT_STRUCT;
+PACK_STRUCT_END
+#ifdef PACK_STRUCT_USE_INCLUDES
+#  include "arch/epstruct.h"
+#endif
 
 #define ICMPH_TYPE(hdr) (ntohs((hdr)->_type_code) >> 8)
 #define ICMPH_CODE(hdr) (ntohs((hdr)->_type_code) & 0xff)

src/include/ipv4/lwip/ip.h

@@ -94,27 +94,37 @@ err_t ip_output_if(struct pbuf *p, struct ip_addr *src, struct ip_addr *dest,
 #define	SOF_OOBINLINE	(u16_t)0x0100U		/* leave received OOB data in line */
 #define	SOF_REUSEPORT	(u16_t)0x0200U		/* allow local address & port reuse */
 
+
+
+#ifdef PACK_STRUCT_USE_INCLUDES
+#  include "arch/bpstruct.h"
+#endif
+PACK_STRUCT_BEGIN
 struct ip_hdr {
   /* version / header length / type of service */
-  u16_t _v_hl_tos;
+  PACK_STRUCT_FIELD(u16_t _v_hl_tos);
   /* total length */
-  u16_t _len;
+  PACK_STRUCT_FIELD(u16_t _len);
   /* identification */
-  u16_t _id;
+  PACK_STRUCT_FIELD(u16_t _id);
   /* fragment offset field */
-  u16_t _offset;
+  PACK_STRUCT_FIELD(u16_t _offset);
 #define IP_RF 0x8000        /* reserved fragment flag */
 #define IP_DF 0x4000        /* dont fragment flag */
 #define IP_MF 0x2000        /* more fragments flag */
 #define IP_OFFMASK 0x1fff   /* mask for fragmenting bits */
   /* time to live / protocol*/
-  u16_t _ttl_proto;
+  PACK_STRUCT_FIELD(u16_t _ttl_proto);
   /* checksum */
-  u16_t _chksum;
+  PACK_STRUCT_FIELD(u16_t _chksum);
   /* source and destination IP addresses */
-  struct ip_addr src;
-  struct ip_addr dest; 
-};
+  PACK_STRUCT_FIELD(struct ip_addr src);
+  PACK_STRUCT_FIELD(struct ip_addr dest); 
+} PACK_STRUCT_STRUCT;
+PACK_STRUCT_END
+#ifdef PACK_STRUCT_USE_INCLUDES
+#  include "arch/epstruct.h"
+#endif
 
 #define IPH_V(hdr)  (ntohs((hdr)->_v_hl_tos) >> 12)
 #define IPH_HL(hdr) ((ntohs((hdr)->_v_hl_tos) >> 8) & 0x0f)

src/include/ipv4/lwip/ip_addr.h

@@ -34,21 +34,23 @@
 
 #include "lwip/arch.h"
 
+#ifdef PACK_STRUCT_USE_INCLUDES
+#  include "arch/bpstruct.h"
+#endif
+PACK_STRUCT_BEGIN
 struct ip_addr {
-  u32_t addr;
-};
-
-struct ip_addr2 {
-  u16_t addrw[2];
-};
+  PACK_STRUCT_FIELD(u32_t addr);
+} PACK_STRUCT_STRUCT;
+PACK_STRUCT_END
+#ifdef PACK_STRUCT_USE_INCLUDES
+#  include "arch/epstruct.h"
+#endif
 
 /* For compatibility with BSD code */
 struct in_addr {
   u32_t s_addr;
 };
 
-struct netif;
-
 extern const struct ip_addr ip_addr_any;
 extern const struct ip_addr ip_addr_broadcast;
 
@@ -100,7 +102,7 @@ extern const struct ip_addr ip_addr_broadcast;
 
 #define ip_addr_set(dest, src) (dest)->addr = \
                                ((src) == NULL? 0:\
-                               (src)->addr)
+                               ((struct ip_addr *)src)->addr)
 #define ip_addr_maskcmp(addr1, addr2, mask) (((addr1)->addr & \
                                               (mask)->addr) == \
                                              ((addr2)->addr & \
@@ -109,7 +111,10 @@ extern const struct ip_addr ip_addr_broadcast;
 
 #define ip_addr_isany(addr1) ((addr1) == NULL || (addr1)->addr == 0)
 
-u8_t ip_addr_isbroadcast(struct ip_addr *, struct netif *);
+#define ip_addr_isbroadcast(addr1, mask) (((((addr1)->addr) & ~((mask)->addr)) == \
+           (0xffffffff & ~((mask)->addr))) || \
+                                         ((addr1)->addr == 0xffffffff) || \
+                                         ((addr1)->addr == 0x00000000))
 
 #define ip_addr_ismulticast(addr1) (((addr1)->addr & ntohl(0xf0000000)) == ntohl(0xe0000000))
 

src/include/lwip/arch.h

@@ -42,6 +42,20 @@
 
 #include "arch/cc.h"
 
+#ifndef PACK_STRUCT_BEGIN
+#define PACK_STRUCT_BEGIN
+#endif /* PACK_STRUCT_BEGIN */
+
+#ifndef PACK_STRUCT_END
+#define PACK_STRUCT_END
+#endif /* PACK_STRUCT_END */
+
+#ifndef PACK_STRUCT_FIELD
+#define PACK_STRUCT_FIELD(x) x
+#endif /* PACK_STRUCT_FIELD */
+
+
+
 #ifdef LWIP_PROVIDE_ERRNO
 
 #define  EPERM     1  /* Operation not permitted */

src/include/lwip/dhcp.h

@@ -55,35 +55,44 @@ struct dhcp
 #endif
 };
 
+/* MUST be compiled with "pack structs" or equivalent! */
+#ifdef PACK_STRUCT_USE_INCLUDES
+#  include "arch/bpstruct.h"
+#endif
+PACK_STRUCT_BEGIN
 /** minimum set of fields of any DHCP message */
 struct dhcp_msg
 {
-  u8_t op;
-  u8_t htype;
-  u8_t hlen;
-  u8_t hops;
-  u32_t xid;
-  u16_t secs;
-  u16_t flags;
-  struct ip_addr ciaddr;
-  struct ip_addr yiaddr;
-  struct ip_addr siaddr;
-  struct ip_addr giaddr;
+  PACK_STRUCT_FIELD(u8_t op);
+  PACK_STRUCT_FIELD(u8_t htype);
+  PACK_STRUCT_FIELD(u8_t hlen);
+  PACK_STRUCT_FIELD(u8_t hops);
+  PACK_STRUCT_FIELD(u32_t xid);
+  PACK_STRUCT_FIELD(u16_t secs);
+  PACK_STRUCT_FIELD(u16_t flags);
+  PACK_STRUCT_FIELD(u32_t ciaddr);
+  PACK_STRUCT_FIELD(u32_t yiaddr);
+  PACK_STRUCT_FIELD(u32_t siaddr);
+  PACK_STRUCT_FIELD(u32_t giaddr);
 #define DHCP_CHADDR_LEN 16U
-  u8_t chaddr[DHCP_CHADDR_LEN];
+  PACK_STRUCT_FIELD(u8_t chaddr[DHCP_CHADDR_LEN]);
 #define DHCP_SNAME_LEN 64U
-  u8_t sname[DHCP_SNAME_LEN];
+  PACK_STRUCT_FIELD(u8_t sname[DHCP_SNAME_LEN]);
 #define DHCP_FILE_LEN 128U
-  u8_t file[DHCP_FILE_LEN];
-  u32_t cookie;
+  PACK_STRUCT_FIELD(u8_t file[DHCP_FILE_LEN]);
+  PACK_STRUCT_FIELD(u32_t cookie);
 #define DHCP_MIN_OPTIONS_LEN 68U
 /** allow this to be configured in lwipopts.h, but not too small */
 #if ((!defined(DHCP_OPTIONS_LEN)) || (DHCP_OPTIONS_LEN < DHCP_MIN_OPTIONS_LEN))
 /** set this to be sufficient for your options in outgoing DHCP msgs */
 #  define DHCP_OPTIONS_LEN DHCP_MIN_OPTIONS_LEN
 #endif
-  u8_t options[DHCP_OPTIONS_LEN];
-};
+  PACK_STRUCT_FIELD(u8_t options[DHCP_OPTIONS_LEN]);
+} PACK_STRUCT_STRUCT;
+PACK_STRUCT_END
+#ifdef PACK_STRUCT_USE_INCLUDES
+#  include "arch/epstruct.h"
+#endif
 
 /** start DHCP configuration */
 err_t dhcp_start(struct netif *netif);

src/include/lwip/netif.h

@@ -52,8 +52,7 @@
 
 /** whether the network interface is 'up'. this is
  * a software flag used to control whether this network
- * interface is enabled and processes traffic.
- * TODO: who should act on this flag, lwIP stack or driver?? */
+ * interface is enabled and processes traffic */
 #define NETIF_FLAG_UP 0x1U
 /** if set, the netif has broadcast capability */
 #define NETIF_FLAG_BROADCAST 0x2U
@@ -62,36 +61,35 @@
 /** if set, the interface is configured using DHCP */
 #define NETIF_FLAG_DHCP 0x08U
 /** if set, the interface has an active link
- *  (set by the network interface driver) */
+ *  (set by the interface) */
 #define NETIF_FLAG_LINK_UP 0x10U
 
-/** Generic data structure used for all lwIP network interfaces.
- *  The following fields should be filled in by the initialization
- *  function for the device driver: hwaddr_len, hwaddr[], mtu, flags */
-
+/** generic data structure used for all lwIP network interfaces */
 struct netif {
   /** pointer to next in linked list */
   struct netif *next;
-
+  /** The following fields should be filled in by the
+      initialization function for the device driver. */
+  
   /** IP address configuration in network byte order */
   struct ip_addr ip_addr;
   struct ip_addr netmask;
   struct ip_addr gw;
 
   /** This function is called by the network device driver
-   *  to pass a packet up the TCP/IP stack. */
+      to pass a packet up the TCP/IP stack. */
   err_t (* input)(struct pbuf *p, struct netif *inp);
   /** This function is called by the IP module when it wants
-   *  to send a packet on the interface. This function typically
-   *  first resolves the hardware address, then sends the packet. */
+      to send a packet on the interface. This function typically
+      first resolves the hardware address, then sends the packet. */
   err_t (* output)(struct netif *netif, struct pbuf *p,
        struct ip_addr *ipaddr);
   /** This function is called by the ARP module when it wants
-   *  to send a packet on the interface. This function outputs
-   *  the pbuf as-is on the link medium. */
+      to send a packet on the interface. This function outputs
+      the pbuf as-is on the link medium. */
   err_t (* linkoutput)(struct netif *netif, struct pbuf *p);
   /** This field can be set by the device driver and could point
-   *  to state information for the device. */
+      to state information for the device. */
   void *state;
 #if LWIP_DHCP
   /** the DHCP client state information for this netif */
@@ -103,12 +101,12 @@ struct netif {
   unsigned char hwaddr[NETIF_MAX_HWADDR_LEN];
   /** maximum transfer unit (in bytes) */
   u16_t mtu;
-  /** flags (see NETIF_FLAG_ above) */
-  u8_t flags;
   /** descriptive abbreviation */
   char name[2];
   /** number of this interface */
   u8_t num;
+  /** NETIF_FLAG_* */
+  u8_t flags;
 };
 
 /** The list of network interfaces. */

src/include/lwip/opt.h

@@ -175,10 +175,14 @@ a lot of data that needs to be copied, this should be set high. */
 #ifndef ARP_QUEUE_FIRST
 #define ARP_QUEUE_FIRST                 0
 #endif
-
-/* This option is removed to comply with the ARP standard */
-#ifdef ETHARP_ALWAYS_INSERT
-#error ETHARP_ALWAYS_INSERT option is deprecated. Remove it from your lwipopts.h.
+/**
+ * If defined to 1, cache entries are updated or added for every kind of ARP traffic
+ * or broadcast IP traffic. Recommended for routers.
+ * If defined to 0, only existing cache entries are updated. Entries are added when
+ * lwIP is sending to them. Recommended for embedded devices.
+ */
+#ifndef ETHARP_ALWAYS_INSERT
+#define ETHARP_ALWAYS_INSERT            1
 #endif
 
 /* ---------- IP options ---------- */
@@ -504,31 +508,6 @@ a lot of data that needs to be copied, this should be set high. */
 
 #endif /* PPP_SUPPORT */
 
-/* checksum options - set to zero for hardware checksum support */
-
-#ifndef CHECKSUM_GEN_IP
-#define CHECKSUM_GEN_IP                 1
-#endif
- 
-#ifndef CHECKSUM_GEN_UDP
-#define CHECKSUM_GEN_UDP                1
-#endif
- 
-#ifndef CHECKSUM_GEN_TCP
-#define CHECKSUM_GEN_TCP                1
-#endif
- 
-#ifndef CHECKSUM_CHECK_IP
-#define CHECKSUM_CHECK_IP               1
-#endif
- 
-#ifndef CHECKSUM_CHECK_UDP
-#define CHECKSUM_CHECK_UDP              1
-#endif
-
-#ifndef CHECKSUM_CHECK_TCP
-#define CHECKSUM_CHECK_TCP              1
-#endif
 
 /* Debugging options all default to off */
 

src/include/lwip/pbuf.h

@@ -53,8 +53,8 @@ typedef enum {
   PBUF_POOL
 } pbuf_flag;
 
-/* Definitions for the pbuf flag field. These are NOT the flags that
- * are passed to pbuf_alloc(). */
+/* Definitions for the pbuf flag field (these are not the flags that
+   are passed to pbuf_alloc()). */
 #define PBUF_FLAG_RAM   0x00U    /* Flags that pbuf data is stored in RAM */
 #define PBUF_FLAG_ROM   0x01U    /* Flags that pbuf data is stored in ROM */
 #define PBUF_FLAG_POOL  0x02U    /* Flags that the pbuf comes from the pbuf pool */
@@ -79,10 +79,10 @@ struct pbuf {
    */
   u16_t tot_len;
   
-  /** length of this buffer */
+  /* length of this buffer */
   u16_t len;  
 
-  /** flags telling the type of pbuf, see PBUF_FLAG_ */
+  /* flags telling the type of pbuf */
   u16_t flags;
   
   /**
@@ -94,6 +94,11 @@ struct pbuf {
   
 };
 
+/* pbuf_init():
+
+   Initializes the pbuf module. The num parameter determines how many
+   pbufs that should be allocated to the pbuf pool, and the size
+   parameter specifies the size of the data allocated to those.  */
 void pbuf_init(void);
 
 struct pbuf *pbuf_alloc(pbuf_layer l, u16_t size, pbuf_flag flag);
@@ -107,7 +112,5 @@ void pbuf_cat(struct pbuf *h, struct pbuf *t);
 void pbuf_chain(struct pbuf *h, struct pbuf *t);
 struct pbuf *pbuf_take(struct pbuf *f);
 struct pbuf *pbuf_dechain(struct pbuf *p);
-void pbuf_queue(struct pbuf *p, struct pbuf *n);
-struct pbuf * pbuf_dequeue(struct pbuf *p);
 
 #endif /* __LWIP_PBUF_H__ */

src/include/lwip/raw.h

@@ -46,7 +46,7 @@ struct raw_pcb {
 
   u16_t protocol;
 
-  u8_t (* recv)(void *arg, struct raw_pcb *pcb, struct pbuf *p,
+  int (* recv)(void *arg, struct raw_pcb *pcb, struct pbuf *p,
     struct ip_addr *addr);
   void *recv_arg;
 };
@@ -59,15 +59,15 @@ err_t            raw_bind       (struct raw_pcb *pcb, struct ip_addr *ipaddr);
 err_t            raw_connect    (struct raw_pcb *pcb, struct ip_addr *ipaddr);
 
 void             raw_recv       (struct raw_pcb *pcb,
-                                 u8_t (* recv)(void *arg, struct raw_pcb *pcb,
+                                 int (* recv)(void *arg, struct raw_pcb *pcb,
                                               struct pbuf *p,
                                               struct ip_addr *addr),
                                  void *recv_arg);
-err_t            raw_sendto    (struct raw_pcb *pcb, struct pbuf *p, struct ip_addr *ipaddr);
+err_t            raw_send_to    (struct raw_pcb *pcb, struct pbuf *p, struct ip_addr *ipaddr);
 err_t            raw_send       (struct raw_pcb *pcb, struct pbuf *p);
 
 /* The following functions are the lower layer interface to RAW. */
-u8_t              raw_input      (struct pbuf *p, struct netif *inp);
+int              raw_input      (struct pbuf *p, struct netif *inp);
 void             raw_init       (void);
 
 

src/include/lwip/sockets.h

@@ -205,16 +205,10 @@ struct linger {
           unsigned char fd_bits [(FD_SETSIZE+7)/8];
         } fd_set;
 
-/* 
- * only define this in sockets.c so it does not interfere
- * with other projects namespaces where timeval is present
- */ 
-#ifdef LWIP_TIMEVAL_PRIVATE
   struct timeval {
     long    tv_sec;         /* seconds */
     long    tv_usec;        /* and microseconds */
   };
-#endif
 
 #endif
 

src/include/lwip/tcp.h

@@ -161,16 +161,25 @@ void             tcp_rexmit  (struct tcp_pcb *pcb);
 #define  TCP_KEEPCNT       9                             /* Counter for KEEPALIVE probes */
 #define  TCP_MAXIDLE       TCP_KEEPCNT * TCP_KEEPINTVL   /* Maximum KEEPALIVE probe time */
 
+
+#ifdef PACK_STRUCT_USE_INCLUDES
+#  include "arch/bpstruct.h"
+#endif
+PACK_STRUCT_BEGIN
 struct tcp_hdr {
-  u16_t src;
-  u16_t dest;
-  u32_t seqno;
-  u32_t ackno;
-  u16_t _hdrlen_rsvd_flags;
-  u16_t wnd;
-  u16_t chksum;
-  u16_t urgp;
-};
+  PACK_STRUCT_FIELD(u16_t src);
+  PACK_STRUCT_FIELD(u16_t dest);
+  PACK_STRUCT_FIELD(u32_t seqno);
+  PACK_STRUCT_FIELD(u32_t ackno);
+  PACK_STRUCT_FIELD(u16_t _hdrlen_rsvd_flags);
+  PACK_STRUCT_FIELD(u16_t wnd);
+  PACK_STRUCT_FIELD(u16_t chksum);
+  PACK_STRUCT_FIELD(u16_t urgp);
+} PACK_STRUCT_STRUCT;
+PACK_STRUCT_END
+#ifdef PACK_STRUCT_USE_INCLUDES
+#  include "arch/epstruct.h"
+#endif
 
 #define TCPH_OFFSET(phdr) (ntohs((phdr)->_hdrlen_rsvd_flags) >> 8)
 #define TCPH_HDRLEN(phdr) (ntohs((phdr)->_hdrlen_rsvd_flags) >> 12)

src/include/lwip/udp.h

@@ -41,11 +41,11 @@
 #define UDP_HLEN 8
 
 struct udp_hdr {
-  u16_t src;
-  u16_t dest;  /* src/dest UDP ports */
-  u16_t len;
-  u16_t chksum;
-};
+  PACK_STRUCT_FIELD(u16_t src);
+  PACK_STRUCT_FIELD(u16_t dest);  /* src/dest UDP ports */
+  PACK_STRUCT_FIELD(u16_t len);
+  PACK_STRUCT_FIELD(u16_t chksum);
+} PACK_STRUCT_STRUCT;
 
 #define UDP_FLAGS_NOCHKSUM 0x01U
 #define UDP_FLAGS_UDPLITE  0x02U

src/include/netif/etharp.h

@@ -1,7 +1,5 @@
 /*
- * Copyright (c) 2001-2003 Swedish Institute of Computer Science.
- * Copyright (c) 2003-2004 Leon Woestenberg <leon.woestenberg@axon.tv>
- * Copyright (c) 2003-2004 Axon Digital Design B.V., The Netherlands.
+ * Copyright (c) 2001-2004 Swedish Institute of Computer Science.
  * All rights reserved. 
  * 
  * Redistribution and use in source and binary forms, with or without modification, 
@@ -35,45 +33,51 @@
 #ifndef __NETIF_ETHARP_H__
 #define __NETIF_ETHARP_H__
 
-#ifndef ETH_PAD_SIZE
-#define ETH_PAD_SIZE 0
-#endif
-
 #include "lwip/pbuf.h"
 #include "lwip/ip_addr.h"
 #include "lwip/netif.h"
 #include "lwip/ip.h"
 
-struct eth_addr {
-  u8_t addr[6];
-};
-
-struct eth_hdr {
-#if ETH_PAD_SIZE
-  u8_t padding[ETH_PAD_SIZE];
+#ifdef PACK_STRUCT_USE_INCLUDES
+#  include "arch/bpstruct.h"
 #endif
-  struct eth_addr dest;
-  struct eth_addr src;
-  u16_t type;
-};
+PACK_STRUCT_BEGIN
+struct eth_addr {
+  PACK_STRUCT_FIELD(u8_t addr[6]);
+} PACK_STRUCT_STRUCT;
+PACK_STRUCT_END
 
+PACK_STRUCT_BEGIN
+struct eth_hdr {
+  PACK_STRUCT_FIELD(struct eth_addr dest);
+  PACK_STRUCT_FIELD(struct eth_addr src);
+  PACK_STRUCT_FIELD(u16_t type);
+} PACK_STRUCT_STRUCT;
+PACK_STRUCT_END
+
+PACK_STRUCT_BEGIN
 /** the ARP message */
 struct etharp_hdr {
-  struct eth_hdr ethhdr;
-  u16_t hwtype;
-  u16_t proto;
-  u16_t _hwlen_protolen;
-  u16_t opcode;
-  struct eth_addr shwaddr;
-  struct ip_addr2 sipaddr;
-  struct eth_addr dhwaddr;
-  struct ip_addr2 dipaddr;
-};
+  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
 
+PACK_STRUCT_BEGIN
 struct ethip_hdr {
-  struct eth_hdr eth);
-  struct ip_hdr ip;
+  PACK_STRUCT_FIELD(struct eth_hdr eth);
+  PACK_STRUCT_FIELD(struct ip_hdr ip);
 };
+#ifdef PACK_STRUCT_USE_INCLUDES
+#  include "arch/epstruct.h"
+#endif
 
 #define ARP_TMR_INTERVAL 10000
 
@@ -82,11 +86,13 @@ struct ethip_hdr {
 
 void etharp_init(void);
 void etharp_tmr(void);
-void etharp_ip_input(struct netif *netif, struct pbuf *p);
-void etharp_arp_input(struct netif *netif, struct eth_addr *ethaddr,
+struct pbuf *etharp_ip_input(struct netif *netif, struct pbuf *p);
+struct pbuf *etharp_arp_input(struct netif *netif, struct eth_addr *ethaddr,
          struct pbuf *p);
-err_t etharp_output(struct netif *netif, struct ip_addr *ipaddr,
+struct pbuf *etharp_output(struct netif *netif, struct ip_addr *ipaddr,
          struct pbuf *q);
 err_t etharp_query(struct netif *netif, struct ip_addr *ipaddr, struct pbuf *q);
 
+
+
 #endif /* __NETIF_ARP_H__ */

src/netif/etharp.c

@@ -6,16 +6,12 @@
  * to a physical address when sending a packet, and the second part answers
  * requests from other machines for our physical address.
  *
- * This implementation complies with RFC 826 (Ethernet ARP). It supports
- * Gratuitious ARP from RFC3220 (IP Mobility Support for IPv4) section 4.6
- * if an interface calls etharp_query(our_netif, its_ip_addr, NULL) upon
- * address change.
+ * This implementation complies with RFC 826 (Ethernet ARP) and supports
+ * Gratuitious ARP from RFC3220 (IP Mobility Support for IPv4) section 4.6.
  */
 
 /*
- * Copyright (c) 2001-2003 Swedish Institute of Computer Science.
- * Copyright (c) 2003-2004 Leon Woestenberg <leon.woestenberg@axon.tv>
- * Copyright (c) 2003-2004 Axon Digital Design B.V., The Netherlands.
+ * Copyright (c) 2001-2004 Swedish Institute of Computer Science.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modification,
@@ -42,8 +38,49 @@
  *
  * This file is part of the lwIP TCP/IP stack.
  *
+ * Author: Adam Dunkels <adam@sics.se>
+ *
  */
 
+/**
+ * TODO:
+ * - pbufs should be sent from the queue once an ARP entry state
+ *   goes from PENDING to STABLE.
+ * - Non-PENDING entries MUST NOT have queued packets.
+ */
+
+/*
+ * TODO:
+ *
+RFC 3220 4.6          IP Mobility Support for IPv4          January 2002
+
+      -  A Gratuitous ARP [45] is an ARP packet sent by a node in order
+         to spontaneously cause other nodes to update an entry in their
+         ARP cache.  A gratuitous ARP MAY use either an ARP Request or
+         an ARP Reply packet.  In either case, the ARP Sender Protocol
+         Address and ARP Target Protocol Address are both set to the IP
+         address of the cache entry to be updated, and the ARP Sender
+         Hardware Address is set to the link-layer address to which this
+         cache entry should be updated.  When using an ARP Reply packet,
+         the Target Hardware Address is also set to the link-layer
+         address to which this cache entry should be updated (this field
+         is not used in an ARP Request packet).
+
+         In either case, for a gratuitous ARP, the ARP packet MUST be
+         transmitted as a local broadcast packet on the local link.  As
+         specified in [36], any node receiving any ARP packet (Request
+         or Reply) MUST update its local ARP cache with the Sender
+         Protocol and Hardware Addresses in the ARP packet, if the
+         receiving node has an entry for that IP address already in its
+         ARP cache.  This requirement in the ARP protocol applies even
+         for ARP Request packets, and for ARP Reply packets that do not
+         match any ARP Request transmitted by the receiving node [36].
+*
+  My suggestion would be to send a ARP request for our newly obtained
+  address upon configuration of an Ethernet interface.
+
+*/
+
 #include "lwip/opt.h"
 #include "lwip/inet.h"
 #include "netif/etharp.h"
@@ -55,13 +92,10 @@
 #  include "lwip/dhcp.h"
 #endif
 
-/* allows new queueing code to be disabled (0) for regression testing */
-#define ARP_NEW_QUEUE 1
-
 /** the time an ARP entry stays valid after its last update, (120 * 10) seconds = 20 minutes. */
 #define ARP_MAXAGE 120
-/** the time an ARP entry stays pending after first request, (1 * 10) seconds = 10 seconds. */
-#define ARP_MAXPENDING 1
+/** the time an ARP entry stays pending after first request, (2 * 10) seconds = 20 seconds. */
+#define ARP_MAXPENDING 2
 
 #define HWTYPE_ETHERNET 1
 
@@ -78,9 +112,7 @@
 enum etharp_state {
   ETHARP_STATE_EMPTY,
   ETHARP_STATE_PENDING,
-  ETHARP_STATE_STABLE,
-  /** @internal convenience transitional state used in etharp_tmr() */
-  ETHARP_STATE_EXPIRED
+  ETHARP_STATE_STABLE
 };
 
 struct etharp_entry {
@@ -100,9 +132,12 @@ static const struct eth_addr ethbroadcast = {{0xff,0xff,0xff,0xff,0xff,0xff}};
 static struct etharp_entry arp_table[ARP_TABLE_SIZE];
 
 static s8_t find_arp_entry(void);
-/** ask update_arp_entry() to add instead of merely update an ARP entry */
 #define ARP_INSERT_FLAG 1
 static struct pbuf *update_arp_entry(struct netif *netif, struct ip_addr *ipaddr, struct eth_addr *ethaddr, u8_t flags);
+#if ARP_QUEUEING
+static struct pbuf *etharp_enqueue(s8_t i, struct pbuf *q);
+static u8_t etharp_dequeue(s8_t i);
+#endif
 /**
  * Initializes ARP module.
  */
@@ -140,27 +175,24 @@ etharp_tmr(void)
          /* entry has become old? */
         (arp_table[i].ctime >= ARP_MAXAGE)) {
       LWIP_DEBUGF(ETHARP_DEBUG, ("etharp_timer: expired stable entry %u.\n", i));
-      arp_table[i].state = ETHARP_STATE_EXPIRED;
+      goto empty;
     /* an unresolved/pending entry? */
     } else if ((arp_table[i].state == ETHARP_STATE_PENDING) &&
          /* entry unresolved/pending for too long? */
         (arp_table[i].ctime >= ARP_MAXPENDING)) {
       LWIP_DEBUGF(ETHARP_DEBUG, ("etharp_timer: expired pending entry %u.\n", i));
-      arp_table[i].state = ETHARP_STATE_EXPIRED;
-    }
-    /* clean up entries that have just been expired */
-    if (arp_table[i].state == ETHARP_STATE_EXPIRED) {
+  empty:
+      /* empty old entry */      
+      arp_table[i].state = ETHARP_STATE_EMPTY;
 #if ARP_QUEUEING
       /* and empty packet queue */
       if (arp_table[i].p != NULL) {
-        /* remove all queued packets */
+        /* remove any queued packet */
         LWIP_DEBUGF(ETHARP_DEBUG, ("etharp_timer: freeing entry %u, packet queue %p.\n", i, (void *)(arp_table[i].p)));
         pbuf_free(arp_table[i].p);
         arp_table[i].p = NULL;
       }
 #endif
-      /* recycle entry for re-use */      
-      arp_table[i].state = ETHARP_STATE_EMPTY;
     }
   }
 }
@@ -203,24 +235,82 @@ find_arp_entry(void)
     return ERR_MEM;
   }
 
-  /* clean up the oldest stable entry (to be recycled) */
+  /* clean up the recycled stable entry */
   if (arp_table[i].state == ETHARP_STATE_STABLE) {
 #if ARP_QUEUEING
-    /* and empty the packet queue */
-    if (arp_table[i].p != NULL) {
-      LWIP_DEBUGF(ETHARP_DEBUG, ("find_arp_entry: freeing entry %u, packet queue %p.\n", i, (void *)(arp_table[i].p)));
-      /* remove all queued packets */
-      pbuf_free(arp_table[i].p);
-      arp_table[i].p = NULL;
-    }
+    /* free packets on queue */
+    etharp_dequeue(i);
 #endif
     LWIP_DEBUGF(ETHARP_DEBUG | DBG_TRACE, ("find_arp_entry: recycling oldest stable entry %u\n", i));
     arp_table[i].state = ETHARP_STATE_EMPTY;
+    arp_table[i].ctime = 0;
   }
   LWIP_DEBUGF(ETHARP_DEBUG, ("find_arp_entry: returning %u\n", i));
   return i;
 }
 
+#if ARP_QUEUEING
+/*
+ * Enqueues a pbuf (chain) on an ARP entry.
+ * 
+ * Places the pbuf (chain) on the queue (if space allows). The
+ * caller may safely free the pbuf (chain) afterwards, as the
+ * pbufs will be referenced by the queue and copies are made of
+ * pbufs referencing external payloads.
+ * 
+ * @ i the ARP entry index
+ * @arg q the pbuf (chain) to be queued on the ARP entry
+ * 
+ * @return Returns the new head of queue of the ARP entry.
+ * 
+ */
+static struct pbuf *
+etharp_enqueue(s8_t i, struct pbuf *q)
+{
+  /* any pbuf to queue? */
+  if (q != NULL) {
+/* queue later packet over earliers? TODO: Implement multiple pbuf queue */
+#if ARP_QUEUE_FIRST == 0
+    /* remove any pbufs on queue */
+    u8_t deq = etharp_dequeue(i);
+    if (deq > 0) LWIP_DEBUGF(ETHARP_DEBUG | DBG_TRACE | 3, ("etharp_query: dequeued %u pbufs from ARP entry %u. Should not occur.\n", deq, i));
+#endif
+    /* packet can be queued? TODO: Implement multiple pbuf queue */
+    if (arp_table[i].p == NULL) {
+      /* copy any PBUF_REF referenced payloads into PBUF_RAM */
+      q = pbuf_take(q);
+      /* add pbuf to queue */
+      arp_table[i].p = q;
+      /* pbuf (chain) now queued, increase the reference count */
+      pbuf_ref(q);
+      LWIP_DEBUGF(ETHARP_DEBUG | DBG_TRACE | DBG_STATE, ("etharp_query: queued packet %p on ARP entry %u.\n", (void *)q, i));
+    }
+  }
+  return arp_table[i].p;
+}
+
+/**
+ * Dequeues any pbufs queued on an ARP entry
+ * 
+ * @return number of pbufs removed from the queue
+ * 
+ * TODO: decide what is a sensible return value?
+ */
+static u8_t
+etharp_dequeue(s8_t i)
+{
+  /* queued packets on a stable entry (work in progress) */
+  if (arp_table[i].p != NULL) {
+  	/* queue no longer references pbuf */
+  	pbuf_free(arp_table[i].p);
+    arp_table[i].p = NULL;
+    return 1;
+  } else {
+    return 0;
+  }
+}
+#endif
+
 /**
  * Update (or insert) a IP/MAC address pair in the ARP cache.
  *
@@ -244,22 +334,20 @@ update_arp_entry(struct netif *netif, struct ip_addr *ipaddr, struct eth_addr *e
   s8_t i, k;
   LWIP_DEBUGF(ETHARP_DEBUG | DBG_TRACE | 3, ("update_arp_entry()\n"));
   LWIP_ASSERT("netif->hwaddr_len != 0", netif->hwaddr_len != 0);
-  LWIP_DEBUGF(ETHARP_DEBUG | DBG_TRACE, ("update_arp_entry: %u.%u.%u.%u - %02x:%02x:%02x:%02x:%02x:%02x\n",
-                                        ip4_addr1(ipaddr), ip4_addr2(ipaddr), ip4_addr3(ipaddr), ip4_addr4(ipaddr), 
-                                        ethaddr->addr[0], ethaddr->addr[1], ethaddr->addr[2],
-                                        ethaddr->addr[3], ethaddr->addr[4], ethaddr->addr[5]));
+  LWIP_DEBUGF(ETHARP_DEBUG | DBG_TRACE, ("update_arp_entry: %u.%u.%u.%u - %02x:%02x:%02x:%02x:%02x:%02x\n", ip4_addr1(ipaddr), ip4_addr2(ipaddr), ip4_addr3(ipaddr), ip4_addr4(ipaddr),
+  ethaddr->addr[0], ethaddr->addr[1], ethaddr->addr[2], ethaddr->addr[3], ethaddr->addr[4], ethaddr->addr[5]));
   /* do not update for 0.0.0.0 addresses */
   if (ipaddr->addr == 0) {
     LWIP_DEBUGF(ETHARP_DEBUG | DBG_TRACE, ("update_arp_entry: will not add 0.0.0.0 to ARP cache\n"));
     return NULL;
   }
-  /* Walk through the ARP mapping table and try to find an entry to update.
-   * If none is found, a new IP -> MAC address mapping is inserted. */
+  /* 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 (arp_table[i].state != ETHARP_STATE_EMPTY &&
-    	ip_addr_cmp(ipaddr, &arp_table[i].ipaddr)) {
+    the IP address in this ARP table entry. */
+    if (ip_addr_cmp(ipaddr, &arp_table[i].ipaddr)) {
       /* pending entry? */
       if (arp_table[i].state == ETHARP_STATE_PENDING) {
         LWIP_DEBUGF(ETHARP_DEBUG | DBG_TRACE, ("update_arp_entry: pending entry %u goes stable\n", i));
@@ -267,8 +355,12 @@ update_arp_entry(struct netif *netif, struct ip_addr *ipaddr, struct eth_addr *e
         arp_table[i].state = ETHARP_STATE_STABLE;
         /* fall-through to next if */
       }
-      /* stable entry? (possibly just marked stable) */
+      /* stable entry? (possibly just marked to become stable) */
       if (arp_table[i].state == ETHARP_STATE_STABLE) {
+#if ARP_QUEUEING
+        struct pbuf *p;
+        struct eth_hdr *ethhdr;
+#endif
         LWIP_DEBUGF(ETHARP_DEBUG | DBG_TRACE, ("update_arp_entry: updating stable entry %u\n", i));
         /* An old entry found, update this and return. */
         for (k = 0; k < netif->hwaddr_len; ++k) {
@@ -278,15 +370,27 @@ update_arp_entry(struct netif *netif, struct ip_addr *ipaddr, struct eth_addr *e
         arp_table[i].ctime = 0;
 /* this is where we will send out queued packets! */
 #if ARP_QUEUEING
-        while (arp_table[i].p != NULL) {
-          /* get the first packet on the queue (if any) */
-          struct pbuf *p = arp_table[i].p;
-          /* Ethernet header */
-          struct eth_hdr *ethhdr = p->payload;;
-          /* remember (and reference) remainder of queue */
-          /* note: this will also terminate the p pbuf chain */
-          arp_table[i].p = pbuf_dequeue(p);
+        /* get the first packet on the queue (if any) */
+        p = arp_table[i].p;
+        /* (another) queued packet present? */
+        while (p != NULL) {
+          struct pbuf *q, *n;
+          /* search for second packet on queue (n) */
+          q = p;
+          while (q->tot_len > q->len) {
+            LWIP_ASSERT("q->next != NULL (while q->tot_len > q->len)", q->next != NULL);
+            /* proceed to next pbuf of this packet */
+            q = q->next;
+          }
+          /* { q = last pbuf of this packet, q->tot_len == q->len } */
+          LWIP_ASSERT("q->tot_len == q->len", q->tot_len == q->len);
+          /* remember next packet on queue */
+          n = q->next;
+          /* { n = first pbuf of next packet, or NULL if no next packet } */
+          /* terminate this packet pbuf chain */
+          q->next = NULL;
           /* fill-in Ethernet header */
+          ethhdr = p->payload;
           for (k = 0; k < netif->hwaddr_len; ++k) {
             ethhdr->dest.addr[k] = ethaddr->addr[k];
             ethhdr->src.addr[k] = netif->hwaddr[k];
@@ -297,7 +401,11 @@ update_arp_entry(struct netif *netif, struct ip_addr *ipaddr, struct eth_addr *e
           netif->linkoutput(netif, p);
           /* free the queued IP packet */
           pbuf_free(p);
+          /* proceed to next packet on queue */
+          p = n;
         }
+        /* NULL attached buffer*/
+        arp_table[i].p = NULL;
 #endif
         /* IP addresses should only occur once in the ARP entry, we are done */
         return NULL;
@@ -309,8 +417,8 @@ update_arp_entry(struct netif *netif, struct ip_addr *ipaddr, struct eth_addr *e
   LWIP_ASSERT("update_arp_entry: i == ARP_TABLE_SIZE", i == ARP_TABLE_SIZE);
 
   LWIP_DEBUGF(ETHARP_DEBUG | DBG_TRACE, ("update_arp_entry: IP address not yet in table\n"));
-  /* allowed to insert a new entry? */
-  if (flags & ARP_INSERT_FLAG)
+  /* allowed to insert an entry? */
+  if ((ETHARP_ALWAYS_INSERT) || (flags & ARP_INSERT_FLAG))
   {
     LWIP_DEBUGF(ETHARP_DEBUG | DBG_TRACE, ("update_arp_entry: adding entry to table\n"));
     /* find an empty or old entry. */
@@ -356,7 +464,7 @@ update_arp_entry(struct netif *netif, struct ip_addr *ipaddr, struct eth_addr *e
  *
  * @see pbuf_free()
  */
-void
+struct pbuf *
 etharp_ip_input(struct netif *netif, struct pbuf *p)
 {
   struct ethip_hdr *hdr;
@@ -367,12 +475,13 @@ etharp_ip_input(struct netif *netif, struct pbuf *p)
   /* source is on local network? */
   if (!ip_addr_maskcmp(&(hdr->ip.src), &(netif->ip_addr), &(netif->netmask))) {
     /* do nothing */
-    return;
+    return NULL;
   }
 
   LWIP_DEBUGF(ETHARP_DEBUG | DBG_TRACE, ("etharp_ip_input: updating ETHARP table.\n"));
   /* update ARP table, ask to insert entry */
   update_arp_entry(netif, &(hdr->ip.src), &(hdr->eth.src), ARP_INSERT_FLAG);
+  return NULL;
 }
 
 
@@ -391,12 +500,10 @@ etharp_ip_input(struct netif *netif, struct pbuf *p)
  *
  * @see pbuf_free()
  */
-void
+struct pbuf *
 etharp_arp_input(struct netif *netif, struct eth_addr *ethaddr, struct pbuf *p)
 {
   struct etharp_hdr *hdr;
-  /* these are aligned properly, whereas the ARP header fields might not be */
-  struct ip_addr sipaddr, dipaddr;
   u8_t i;
   u8_t for_us;
 
@@ -404,43 +511,44 @@ etharp_arp_input(struct netif *netif, struct eth_addr *ethaddr, struct pbuf *p)
   if (p->tot_len < sizeof(struct etharp_hdr)) {
     LWIP_DEBUGF(ETHARP_DEBUG | DBG_TRACE | 1, ("etharp_arp_input: packet dropped, too short (%d/%d)\n", p->tot_len, sizeof(struct etharp_hdr)));
     pbuf_free(p);
-    return;
+    return NULL;
   }
 
   hdr = p->payload;
  
-  /* get aligned copies of addresses */
-  *(struct ip_addr2 *)&sipaddr = hdr->sipaddr;
-  *(struct ip_addr2 *)&dipaddr = hdr->dipaddr;
-
   /* this interface is not configured? */
   if (netif->ip_addr.addr == 0) {
     for_us = 0;
   } else {
     /* ARP packet directed to us? */
-    for_us = ip_addr_cmp(&dipaddr, &(netif->ip_addr));
+    for_us = ip_addr_cmp(&(hdr->dipaddr), &(netif->ip_addr));
   }
 
-  /* ARP message directed to us? */
+  /* add or update entries in the ARP cache */
   if (for_us) {
-    /* add IP address in ARP cache; assume requester wants to talk to us.
-     * can result in directly sending the queued packets for this host. */
-    update_arp_entry(netif, &sipaddr, &(hdr->shwaddr), ARP_INSERT_FLAG);
-  /* ARP message not directed to us? */
+    /* insert IP address in ARP cache (assume requester wants to talk to us)
+     * we might even send out a queued packet to this host */
+    update_arp_entry(netif, &(hdr->sipaddr), &(hdr->shwaddr), ARP_INSERT_FLAG);
+  /* request was not directed to us, but snoop anyway */
   } else {
-    /* update the source IP address in the cache, if present */
-    update_arp_entry(netif, &sipaddr, &(hdr->shwaddr), 0);
+    /* update the source IP address in the cache */
+    update_arp_entry(netif, &(hdr->sipaddr), &(hdr->shwaddr), 0);
   }
 
-  /* now act on the message itself */
   switch (htons(hdr->opcode)) {
   /* ARP request? */
   case ARP_REQUEST:
     /* ARP request. If it asked for our address, we send out a
-     * reply. In any case, we time-stamp any existing ARP entry,
-     * and possiby send out an IP packet that was queued on it. */
+    reply. In any case, we time-stamp any existing ARP entry,
+    and possiby send out an IP packet that was queued on it. */
 
     LWIP_DEBUGF (ETHARP_DEBUG | DBG_TRACE, ("etharp_arp_input: incoming ARP request\n"));
+    /* we are not configured? */
+    if (netif->ip_addr.addr == 0) {
+      LWIP_DEBUGF(ETHARP_DEBUG | DBG_TRACE, ("etharp_arp_input: we are unconfigured, ARP request ignored.\n"));
+      pbuf_free(p);
+      return NULL;
+    }
     /* ARP request for our address? */
     if (for_us) {
 
@@ -448,8 +556,8 @@ etharp_arp_input(struct netif *netif, struct eth_addr *ethaddr, struct pbuf *p)
       /* re-use pbuf to send ARP reply */
       hdr->opcode = htons(ARP_REPLY);
 
-      hdr->dipaddr = hdr->sipaddr;
-      hdr->sipaddr = *(struct ip_addr2 *)&netif->ip_addr;
+      ip_addr_set(&(hdr->dipaddr), &(hdr->sipaddr));
+      ip_addr_set(&(hdr->sipaddr), &(netif->ip_addr));
 
       for(i = 0; i < netif->hwaddr_len; ++i) {
         hdr->dhwaddr.addr[i] = hdr->shwaddr.addr[i];
@@ -467,22 +575,18 @@ etharp_arp_input(struct netif *netif, struct eth_addr *ethaddr, struct pbuf *p)
       hdr->ethhdr.type = htons(ETHTYPE_ARP);
       /* return ARP reply */
       netif->linkoutput(netif, p);
-    /* we are not configured? */
-    } else if (netif->ip_addr.addr == 0) {
-      /* { for_us == 0 and netif->ip_addr.addr == 0 } */
-      LWIP_DEBUGF(ETHARP_DEBUG | DBG_TRACE, ("etharp_arp_input: we are unconfigured, ARP request ignored.\n"));
+
     /* request was not directed to us */
     } else {
-      /* { for_us == 0 and netif->ip_addr.addr != 0 } */
-      LWIP_DEBUGF(ETHARP_DEBUG | DBG_TRACE, ("etharp_arp_input: ARP request was not for us.\n"));
+      LWIP_DEBUGF(ETHARP_DEBUG | DBG_TRACE, ("etharp_arp_input: incoming ARP request was not for us.\n"));
     }
     break;
   case ARP_REPLY:
-    /* ARP reply. We already updated the ARP cache earlier. */
+    /* ARP reply. We insert or update the ARP table later. */
     LWIP_DEBUGF(ETHARP_DEBUG | DBG_TRACE, ("etharp_arp_input: incoming ARP reply\n"));
 #if (LWIP_DHCP && DHCP_DOES_ARP_CHECK)
     /* DHCP wants to know about ARP replies to our wanna-have-address */
-    if (for_us) dhcp_arp_reply(netif, &sipaddr);
+    if (for_us) dhcp_arp_reply(netif, &hdr->sipaddr);
 #endif
     break;
   default:
@@ -491,6 +595,9 @@ etharp_arp_input(struct netif *netif, struct eth_addr *ethaddr, struct pbuf *p)
   }
   /* free ARP packet */
   pbuf_free(p);
+  p = NULL;
+  /* nothing to send, we did it! */
+  return NULL;
 }
 
 /**
@@ -514,36 +621,33 @@ etharp_arp_input(struct netif *netif, struct eth_addr *ethaddr, struct pbuf *p)
  *
  * @return If non-NULL, a packet ready to be sent by caller.
  *
- * @return
- * - ERR_BUF Could not make room for Ethernet header.
- * - ERR_MEM Hardware address unknown, and no more ARP entries available
- *   to query for address or queue the packet.
- * - ERR_RTE No route to destination (no gateway to external networks).
  */
-err_t
+struct pbuf *
 etharp_output(struct netif *netif, struct ip_addr *ipaddr, struct pbuf *q)
 {
   struct eth_addr *dest, *srcaddr, mcastaddr;
   struct eth_hdr *ethhdr;
   s8_t i;
-  err_t result = ERR_OK;
 
-  /* make room for Ethernet header - should not fail*/
+  /* make room for Ethernet header */
   if (pbuf_header(q, sizeof(struct eth_hdr)) != 0) {
-    /* bail out */
+    /* The pbuf_header() call shouldn't fail, and we'll just bail
+    out if it does.. */
     LWIP_DEBUGF(ETHARP_DEBUG | DBG_TRACE | 2, ("etharp_output: could not allocate room for header.\n"));
     LINK_STATS_INC(link.lenerr);
-    pbuf_free(q);
-    return ERR_BUF;
+    return NULL;
   }
 
   /* assume unresolved Ethernet address */
   dest = NULL;
-  /* Determine on destination hardware address. Broadcasts and multicasts
-   * are special, other IP addresses are looked up in the ARP table. */
+  /* 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. */
 
   /* destination IP address is an IP broadcast address? */
-  if (ip_addr_isany(ipaddr) || ip_addr_isbroadcast(ipaddr, netif)) {
+  if (ip_addr_isany(ipaddr) ||
+    ip_addr_isbroadcast(ipaddr, &(netif->netmask))) {
     /* broadcast on Ethernet also */
     dest = (struct eth_addr *)&ethbroadcast;
   }
@@ -561,67 +665,86 @@ etharp_output(struct netif *netif, struct ip_addr *ipaddr, struct pbuf *q)
   }
   /* destination IP address is an IP unicast address */
   else {
-    /* outside local network? */
+    /* destination IP network address not on local network?
+     * IP layer wants us to forward to the default gateway */
     if (!ip_addr_maskcmp(ipaddr, &(netif->ip_addr), &(netif->netmask))) {
       /* interface has default gateway? */
-      if (netif->gw.addr != 0) {
-        /* send to hardware address of default gateway IP address */
+      if (netif->gw.addr != 0)
+      {
+        /* route to default gateway IP address */
         ipaddr = &(netif->gw);
-      /* no default gateway available? */
-      } else {
-        /* destination unreachable, discard packet */
-        pbuf_free(q);
-        return ERR_RTE;
+      }
+      /* no gateway available? */
+      else
+      {
+        /* IP destination address outside local network, but no gateway available */
+        /* { packet is discarded } */
+        return NULL;
       }
     }
-    result = etharp_query(netif, ipaddr, q);
-  } /* else unicast */
+
+    /* Ethernet address for IP destination address is in ARP cache? */
+    for (i = 0; i < ARP_TABLE_SIZE; ++i) {
+      /* match found? */
+      if (arp_table[i].state == ETHARP_STATE_STABLE &&
+        ip_addr_cmp(ipaddr, &arp_table[i].ipaddr)) {
+        dest = &arp_table[i].ethaddr;
+        break;
+      }
+    }
+    /* could not find the destination Ethernet address in ARP cache? */
+    if (dest == NULL) {
+      /* ARP query for the IP address, submit this IP packet for queueing */
+      /* TODO: How do we handle netif->ipaddr == ipaddr? */
+      etharp_query(netif, ipaddr, q);
+      /* { packet was queued (ERR_OK), or discarded } */
+      /* return nothing */
+      return NULL;
+    }
+    /* destination Ethernet address resolved from ARP cache */
+    else
+    {
+      /* fallthrough */
+    }
+  }
 
   /* destination Ethernet address known */
   if (dest != NULL) {
     /* obtain source Ethernet address of the given interface */
     srcaddr = (struct eth_addr *)netif->hwaddr;
+
     /* A valid IP->MAC address mapping was found, fill in the
      * Ethernet header for the outgoing packet */
     ethhdr = q->payload;
+
     for(i = 0; i < netif->hwaddr_len; i++) {
       ethhdr->dest.addr[i] = dest->addr[i];
       ethhdr->src.addr[i] = srcaddr->addr[i];
     }
+
     ethhdr->type = htons(ETHTYPE_IP);
-    /* send packet */
-    result = netif->linkoutput(netif, q);
+    /* return the outgoing packet */
+    return q;
   }
   /* never reached; here for safety */
-  pbuf_free(q);
-  return result;
+  return NULL;
 }
 
 /**
  * Send an ARP request for the given IP address.
  *
- * If the IP address was not yet in the cache, a pending ARP cache entry
- * is added and an ARP request is sent for the given address. The packet
- * is queued on this entry.
+ * Sends an ARP request for the given IP address, unless
+ * a request for this address is already pending. Optionally
+ * queues an outgoing packet on the resulting ARP entry.
  *
- * If the IP address was already pending in the cache, a new ARP request
- * is sent for the given address. The packet is queued on this entry.
- *
- * If the IP address was already stable in the cache, the packet is
- * directly sent. An ARP request is sent out.
- * 
  * @param netif The lwIP network interface where ipaddr
  * must be queried for.
  * @param ipaddr The IP address to be resolved.
- * @param q If non-NULL, a pbuf that must be delivered to the IP address.
+ * @param q If non-NULL, a pbuf that must be queued on the
+ * ARP entry for the ipaddr IP address.
+ *
+ * @return NULL.
  *
- * @return
- * - ERR_BUF Could not make room for Ethernet header.
- * - ERR_MEM Hardware address unknown, and no more ARP entries available
- *   to query for address or queue the packet.
- * - ERR_MEM Could not queue packet due to memory shortage.
- * - ERR_RTE No route to destination (no gateway to external networks).
-  *
  * @note Might be used in the future by manual IP configuration
  * as well.
  *
@@ -630,73 +753,34 @@ etharp_output(struct netif *netif, struct ip_addr *ipaddr, struct pbuf *q)
  */
 err_t etharp_query(struct netif *netif, struct ip_addr *ipaddr, struct pbuf *q)
 {
-  struct pbuf *p;
-  struct eth_addr * srcaddr = (struct eth_addr *)netif->hwaddr;
+  struct eth_addr *srcaddr;
+  struct etharp_hdr *hdr;
   err_t result = ERR_OK;
-  s8_t i; /* ARP entry index */
-  u8_t k; /* Ethernet address octet index */
-
-  /* Do three things in this order (by design):
-   * 
-   * 1) send out ARP request
-   * 2) find entry in ARP cache
-   * 3) handle the packet
-   */
-
-  /* allocate a pbuf for the outgoing ARP request packet */
-  p = pbuf_alloc(PBUF_LINK, sizeof(struct etharp_hdr), PBUF_RAM);
-  /* could allocate a pbuf for an ARP request? */
-  if (p != NULL) {
-    struct etharp_hdr *hdr = p->payload;
-    LWIP_DEBUGF(ETHARP_DEBUG | DBG_TRACE, ("etharp_query: sending ARP request.\n"));
-    hdr->opcode = htons(ARP_REQUEST);
-    for (k = 0; k < netif->hwaddr_len; k++)
-    {
-      hdr->shwaddr.addr[k] = srcaddr->addr[k];
-      /* the hardware address is what we ask for, in
-       * a request it is a don't-care value, we use zeroes */
-      hdr->dhwaddr.addr[k] = 0x00;
-    }
-    hdr->dipaddr = *(struct ip_addr2 *)ipaddr;
-    hdr->sipaddr = *(struct ip_addr2 *)&netif->ip_addr;
-
-    hdr->hwtype = htons(HWTYPE_ETHERNET);
-    ARPH_HWLEN_SET(hdr, netif->hwaddr_len);
-
-    hdr->proto = htons(ETHTYPE_IP);
-    ARPH_PROTOLEN_SET(hdr, sizeof(struct ip_addr));
-    for (k = 0; k < netif->hwaddr_len; ++k)
-    {
-      /* broadcast to all network interfaces on the local network */
-      hdr->ethhdr.dest.addr[k] = 0xff;
-      hdr->ethhdr.src.addr[k] = srcaddr->addr[k];
-    }
-    hdr->ethhdr.type = htons(ETHTYPE_ARP);
-    /* send ARP query */
-    result = netif->linkoutput(netif, p);
-    /* free ARP query packet */
-    pbuf_free(p);
-    p = NULL;
-  /* could not allocate pbuf for ARP request */
-  } else {
-    result = ERR_MEM;
-    LWIP_DEBUGF(ETHARP_DEBUG | DBG_TRACE | 2, ("etharp_query: could not allocate pbuf for ARP request.\n"));
-  }
-
-  /* search entry of queried IP address in the ARP cache */
+  s8_t i;
+  u8_t perform_arp_request = 1;
+  /* prevent 'unused argument' warning if ARP_QUEUEING == 0 */
+  (void)q;
+  srcaddr = (struct eth_addr *)netif->hwaddr;
+  /* bail out if this IP address is pending */
   for (i = 0; i < ARP_TABLE_SIZE; ++i) {
-    /* valid ARP cache entry with matching IP address? */
-    if (arp_table[i].state != ETHARP_STATE_EMPTY &&
-    	ip_addr_cmp(ipaddr, &arp_table[i].ipaddr)) {
-      /* pending entry? */
+    if (ip_addr_cmp(ipaddr, &arp_table[i].ipaddr)) {
       if (arp_table[i].state == ETHARP_STATE_PENDING) {
-        LWIP_DEBUGF(ETHARP_DEBUG | DBG_TRACE | DBG_STATE, ("etharp_query: requested IP already pending in entry %u\n", i));
-        /* { i != ARP_TABLE_SIZE } */
+        LWIP_DEBUGF(ETHARP_DEBUG | DBG_TRACE | DBG_STATE, ("etharp_query: requested IP already pending as entry %u\n", i));
+        /* break out of for-loop, user may wish to queue a packet on a pending entry */
+        /* TODO: we will issue a new ARP request, which should not occur too often */
+        /* we might want to run a faster timer on ARP to limit this */
         break;
       }
       else if (arp_table[i].state == ETHARP_STATE_STABLE) {
-        LWIP_DEBUGF(ETHARP_DEBUG | DBG_TRACE | DBG_STATE, ("etharp_query: requested IP already stable in entry %u\n", i));
-        /* { i != ARP_TABLE_SIZE } */
+        LWIP_DEBUGF(ETHARP_DEBUG | DBG_TRACE | DBG_STATE, ("etharp_query: requested IP already stable as entry %u\n", i));
+        /* User wishes to queue a packet on a stable entry (or does she want to send
+         * out the packet immediately, we will not know), so we force an ARP request.
+         * Upon response we will send out the queued packet in etharp_update().
+         * 
+         * Alternatively, we could accept the stable entry, and just send out the packet
+         * immediately. I chose to implement the former approach.
+         */
+        perform_arp_request = (q?1:0);
         break;
       }
     }
@@ -714,42 +798,52 @@ err_t etharp_query(struct netif *netif, struct ip_addr *ipaddr, struct pbuf *q)
     /* i is available, create ARP entry */
     arp_table[i].state = ETHARP_STATE_PENDING;
     ip_addr_set(&arp_table[i].ipaddr, ipaddr);
-    arp_table[i].p = NULL;
-    LWIP_DEBUGF(ETHARP_DEBUG | DBG_TRACE, ("etharp_query: added pending entry %u for IP address\n", i));
   }
-
-  /* { i is either a (new or existing) PENDING or STABLE entry } */
-  
-  /* packet given? */
-  if (q != NULL) {
-    /* stable entry? */
-    if (arp_table[i].state == ETHARP_STATE_STABLE) {
-      /* we have a valid IP->Ethernet address mapping,
-       * fill in the Ethernet header for the outgoing packet */
-      struct eth_hdr *ethhdr = q->payload;
-      for(k = 0; k < netif->hwaddr_len; k++) {
-        ethhdr->dest.addr[k] = arp_table[i].ethaddr.addr[k];
-        ethhdr->src.addr[k]  = srcaddr->addr[k];
-      }
-      ethhdr->type = htons(ETHTYPE_IP);
-      LWIP_DEBUGF(ETHARP_DEBUG | DBG_TRACE, ("etharp_query: sending packet %p\n", (void *)q));
-      /* send the packet */
-      result = netif->linkoutput(netif, q);
-#if ARP_QUEUEING /* queue the given q packet */
-    /* pending entry? (either just created or already pending */
-    } else if (arp_table[i].state == ETHARP_STATE_PENDING) {
-      /* copy any PBUF_REF referenced payloads into PBUF_RAM */
-      /* (the caller assumes the referenced payload can be freed) */
-      p = pbuf_take(q);
-      /* queue packet */
-      if (p != NULL) {
-        pbuf_queue(arp_table[i].p, p);
-        LWIP_DEBUGF(ETHARP_DEBUG | DBG_TRACE, ("etharp_query: queued packet %p on ARP entry %d\n", (void *)q, i));
-      } else {
-        LWIP_DEBUGF(ETHARP_DEBUG | DBG_TRACE, ("etharp_query: could not queue a copy of PBUF_REF packet %p (out of memory)\n", (void *)q));
-        result = ERR_MEM; 
-      }
+  /* { i is now valid } */
+#if ARP_QUEUEING /* queue packet (even on a stable entry, see above) */
+  etharp_enqueue(i, q);
 #endif
+  /* ARP request? */
+  if (perform_arp_request)
+  {
+    struct pbuf *p;
+    /* allocate a pbuf for the outgoing ARP request packet */
+    p = pbuf_alloc(PBUF_LINK, sizeof(struct etharp_hdr), PBUF_RAM);
+    /* could allocate pbuf? */
+    if (p != NULL) {
+      u8_t j;
+      LWIP_DEBUGF(ETHARP_DEBUG | DBG_TRACE, ("etharp_query: sending ARP request.\n"));
+      hdr = p->payload;
+      hdr->opcode = htons(ARP_REQUEST);
+      for (j = 0; j < netif->hwaddr_len; ++j)
+      {
+        hdr->shwaddr.addr[j] = srcaddr->addr[j];
+        /* the hardware address is what we ask for, in
+         * a request it is a don't-care, we use 0's */
+        hdr->dhwaddr.addr[j] = 0x00;
+      }
+      ip_addr_set(&(hdr->dipaddr), ipaddr);
+      ip_addr_set(&(hdr->sipaddr), &(netif->ip_addr));
+
+      hdr->hwtype = htons(HWTYPE_ETHERNET);
+      ARPH_HWLEN_SET(hdr, netif->hwaddr_len);
+
+      hdr->proto = htons(ETHTYPE_IP);
+      ARPH_PROTOLEN_SET(hdr, sizeof(struct ip_addr));
+      for (j = 0; j < netif->hwaddr_len; ++j)
+      {
+        hdr->ethhdr.dest.addr[j] = 0xff;
+        hdr->ethhdr.src.addr[j] = srcaddr->addr[j];
+      }
+      hdr->ethhdr.type = htons(ETHTYPE_ARP);
+      /* send ARP query */
+      result = netif->linkoutput(netif, p);
+      /* free ARP query packet */
+      pbuf_free(p);
+      p = NULL;
+    } else {
+      result = ERR_MEM;
+      LWIP_DEBUGF(ETHARP_DEBUG | DBG_TRACE | 2, ("etharp_query: could not allocate pbuf for ARP request.\n"));
     }
   }
   return result;

src/netif/ethernetif.c

@@ -61,6 +61,7 @@ static void  ethernetif_input(struct netif *netif);
 static err_t ethernetif_output(struct netif *netif, struct pbuf *p,
              struct ip_addr *ipaddr);
 
+
 static void
 low_level_init(struct netif *netif)
 {
@@ -94,6 +95,7 @@ low_level_init(struct netif *netif)
  *
  */
 
+
 static err_t
 low_level_output(struct ethernetif *ethernetif, struct pbuf *p)
 {
@@ -101,10 +103,6 @@ low_level_output(struct ethernetif *ethernetif, struct pbuf *p)
 
   initiate transfer();
   
-#if ETH_PAD_SIZE
-  pbuf_header(p, -ETH_PAD_SIZE);			/* drop the padding word */
-#endif
-
   for(q = p; q != NULL; q = q->next) {
     /* Send the data from the pbuf to the interface, one pbuf at a
        time. The size of the data in each pbuf is kept in the ->len
@@ -113,10 +111,6 @@ low_level_output(struct ethernetif *ethernetif, struct pbuf *p)
   }
 
   signal that packet should be sent();
-
-#if ETH_PAD_SIZE
-  pbuf_header(p, ETH_PAD_SIZE);			/* reclaim the padding word */
-#endif
   
 #ifdef LINK_STATS
   lwip_stats.link.xmit++;
@@ -143,33 +137,19 @@ low_level_input(struct ethernetif *ethernetif)
      variable. */
   len = ;
 
-#if ETH_PAD_SIZE
-  len += ETH_PAD_SIZE;						/* allow room for Ethernet padding */
-#endif
-
   /* We allocate a pbuf chain of pbufs from the pool. */
   p = pbuf_alloc(PBUF_RAW, len, PBUF_POOL);
   
   if (p != NULL) {
-
-#if ETH_PAD_SIZE
-    pbuf_header(p, -ETH_PAD_SIZE);			/* drop the padding word */
-#endif
-
     /* We iterate over the pbuf chain until we have read the entire
-     * packet into the pbuf. */
+       packet into the pbuf. */
     for(q = p; q != NULL; q = q->next) {
       /* Read enough bytes to fill this pbuf in the chain. The
-       * available data in the pbuf is given by the q->len
-       * variable. */
+         available data in the pbuf is given by the q->len
+         variable. */
       read data into(q->payload, q->len);
     }
     acknowledge that packet has been read();
-
-#if ETH_PAD_SIZE
-    pbuf_header(p, ETH_PAD_SIZE);			/* reclaim the padding word */
-#endif
-
 #ifdef LINK_STATS
     lwip_stats.link.recv++;
 #endif /* LINK_STATS */      
@@ -197,10 +177,30 @@ static err_t
 ethernetif_output(struct netif *netif, struct pbuf *p,
       struct ip_addr *ipaddr)
 {
+  struct ethernetif *ethernetif;
+  struct pbuf *q;
+  struct eth_hdr *ethhdr;
+  struct eth_addr *dest, mcastaddr;
+  struct ip_addr *queryaddr;
+  err_t err;
+  u8_t i;
   
- /* resolve hardware address, then send (or queue) packet */
-  return etharp_output(netif, ipaddr, p);
- 
+  ethernetif = netif->state;
+
+  /* resolve the link destination hardware address */
+  p = etharp_output(netif, ipaddr, p);
+  
+  /* network hardware address obtained? */
+  if (p == NULL)
+  {
+    /* we cannot tell if the packet was sent: the packet could */
+    /* have been queued on an ARP entry that was already pending. */
+  	return ERR_OK;
+  }
+  	
+  /* send out the packet */
+  return low_level_output(ethernetif, p);
+
 }
 
 /*
@@ -218,43 +218,42 @@ ethernetif_input(struct netif *netif)
 {
   struct ethernetif *ethernetif;
   struct eth_hdr *ethhdr;
-  struct pbuf *p;
+  struct pbuf *p, *q;
 
   ethernetif = netif->state;
   
-  /* move received packet into a new pbuf */
   p = low_level_input(ethernetif);
-  /* no packet could be read, silently ignore this */
-  if (p == NULL) return;
-  /* points to packet payload, which starts with an Ethernet header */
-  ethhdr = p->payload;
+
+  if (p != NULL)
+    return;
 
 #ifdef LINK_STATS
   lwip_stats.link.recv++;
 #endif /* LINK_STATS */
 
   ethhdr = p->payload;
+  q = NULL;
     
   switch (htons(ethhdr->type)) {
-  /* IP packet? */
-  case ETHTYPE_IP:
-    /* update ARP table */
-    etharp_ip_input(netif, p);
-    /* skip Ethernet header */
-    pbuf_header(p, -sizeof(struct eth_hdr));
-    /* pass to network layer */
-    netif->input(p, netif);
-    break;
+    case ETHTYPE_IP:
+      q = etharp_ip_input(netif, p);
+      pbuf_header(p, -14);
+      netif->input(p, netif);
+      break;
       
     case ETHTYPE_ARP:
-      /* pass p to ARP module  */
-      etharp_arp_input(netif, ethernetif->ethaddr, p);
+      q = etharp_arp_input(netif, ethernetif->ethaddr, p);
       break;
     default:
       pbuf_free(p);
       p = NULL;
       break;
   }
+  if (q != NULL) {
+    low_level_output(ethernetif, q);
+    pbuf_free(q);
+    q = NULL;
+  }
 }
 
 static void

src/netif/ppp/chpms.h

@@ -51,7 +51,6 @@
  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  *
- * $Id: chpms.h,v 1.3 2004/02/07 00:30:03 likewise Exp $
  */
 
 #ifndef CHPMS_H

src/netif/ppp/vj.h

@@ -1,8 +1,6 @@
 /*
  * Definitions for tcp compression routines.
  *
- * $Id: vj.h,v 1.4 2004/02/07 00:30:03 likewise Exp $
- *
  * Copyright (c) 1989 Regents of the University of California.
  * All rights reserved.
  *

src/netif/ppp/vjbsdhdr.h

@@ -11,6 +11,7 @@
  * pragmatically since otherwise unsigned comparisons can result
  * against negative integers quite easily, and fail in subtle ways.
  */
+PACK_STRUCT_BEGIN
 struct ip
 {
 #if defined(NO_CHAR_BITFIELDS)
@@ -38,6 +39,7 @@ struct ip
 	u_short	ip_sum;					/* checksum */
 	struct	in_addr ip_src,ip_dst;	/* source and dest address */
 };
+PACK_STRUCT_END
 
 typedef u32_t tcp_seq;
 
@@ -45,6 +47,7 @@ typedef u32_t tcp_seq;
  * TCP header.
  * Per RFC 793, September, 1981.
  */
+PACK_STRUCT_BEGIN
 struct tcphdr  
 {
 	u_short	th_sport;		/* source port */
@@ -68,5 +71,6 @@ struct tcphdr
 	u_short	th_sum;			/* checksum */
 	u_short	th_urp;			/* urgent pointer */
 };
+PACK_STRUCT_END
 
 #endif /* VJBSDHDR_H */