Add the following features and bugfixes:

Added select() functionality to sockets library.
Support for errno in sockets library.
Byte ordering fixes.
basic lwip_ioctl(), FIONREAD, get/setsockopt() etc. support

- added additional argument to netif_add to pass state pointer so that the
if_init function has access to context information before
the interface is added, without accessing globals.

- added netif_remove()

- to conserve cpu load the tcpip_tcp_timer should only be active
when tcbs that need it exist.

- pass length of available data to callbacks for NETCONN_EVT_RCV events

- added tcpip_link_input(), a hack to allow processing of PPP
packets in tcpip_thread() context. This saves threads and context
switches.

- renamed incompatible ASSERT() macro to LWIP_ASSERT() to avoid name
collision.

- changed a bunch of %d's to %u's in format strings for unsigned values.

- added ip_frag to lwip_stats.

- changed IP_REASS_MAXAGE and IP_REASS_TMO defaults to more realistic
values.

- added sys_timeout_remove() function to cancel timeouts (needed by PPP
amongst other things).

- tolerate NULL returns from sys_arch_timeouts() since some threads might
not need to use or have timeouts.

- added sys_sem_wait_timeout()

- moved mem_malloc() function to end of mem.c to work around tasking
compiler bug.

- automatically bind to local tcp port if 0.

- allow customization of port ranges for automatic local bindings.

- corrected various typos, spelling errors, etc..

Thanks to Marc Boucher for many of these changes.

src/api/api_lib.c

@@ -215,8 +215,25 @@ netconn *netconn_new(enum netconn_type t)
   conn->acceptmbox = SYS_MBOX_NULL;
   conn->sem = SYS_SEM_NULL;
   conn->state = NETCONN_NONE;
+  conn->socket = 0;
+  conn->callback = 0;
+  conn->recv_avail = 0;
   return conn;
 }
+/*-----------------------------------------------------------------------------------*/
+struct
+netconn *netconn_new_with_callback(enum netconn_type t,
+                                   void (*callback)(struct netconn *, enum netconn_evt, u16_t len))
+{
+    struct netconn *conn;
+    
+    /* get a netconn and then initialize callback pointer and socket */
+    conn = netconn_new(t);
+    if (conn)
+        conn->callback = callback;
+    return conn;
+}
+
 /*-----------------------------------------------------------------------------------*/
 err_t
 netconn_delete(struct netconn *conn)
@@ -437,7 +454,10 @@ netconn_accept(struct netconn *conn)
   }
   
   sys_mbox_fetch(conn->acceptmbox, (void **)&newconn);
-
+  /* Register event with callback */
+  if (conn->callback)
+      (*conn->callback)(conn, NETCONN_EVT_RCVMINUS, 0);
+  
   return newconn;
 }
 /*-----------------------------------------------------------------------------------*/
@@ -476,7 +496,11 @@ netconn_recv(struct netconn *conn)
     }
     
     sys_mbox_fetch(conn->recvmbox, (void **)&p);
-    
+	conn->recv_avail -= p->tot_len;
+    /* Register event with callback */
+    if (conn->callback)
+        (*conn->callback)(conn, NETCONN_EVT_RCVMINUS, p->tot_len);
+
     /* If we are closed, we indicate that we no longer wish to recieve
        data by setting conn->recvmbox to SYS_MBOX_NULL. */
     if(p == NULL) {
@@ -509,6 +533,10 @@ netconn_recv(struct netconn *conn)
     memp_freep(MEMP_API_MSG, msg);
   } else {
     sys_mbox_fetch(conn->recvmbox, (void **)&buf);
+	conn->recv_avail -= buf->p->tot_len;
+    /* Register event with callback */
+    if (conn->callback)
+        (*conn->callback)(conn, NETCONN_EVT_RCVMINUS, buf->p->tot_len);
   }
 
   
@@ -620,6 +648,7 @@ netconn_write(struct netconn *conn, void *dataptr, u16_t size, u8_t copy)
     sys_sem_free(conn->sem);
     conn->sem = SYS_SEM_NULL;
   }
+  
   return conn->err;
 }
 /*-----------------------------------------------------------------------------------*/
@@ -657,7 +686,3 @@ netconn_err(struct netconn *conn)
   return conn->err;
 }
 /*-----------------------------------------------------------------------------------*/
-
-
-
-

src/api/api_msg.c

@@ -52,6 +52,10 @@ recv_tcp(void *arg, struct tcp_pcb *pcb, struct pbuf *p, err_t err)
 
   if(conn->recvmbox != SYS_MBOX_NULL) {
     conn->err = err;
+	conn->recv_avail += p->tot_len;
+    /* Register event with callback */
+    if (conn->callback)
+        (*conn->callback)(conn, NETCONN_EVT_RCVPLUS, p->tot_len);
     sys_mbox_post(conn->recvmbox, p);
   }  
   return ERR_OK;
@@ -82,7 +86,11 @@ recv_udp(void *arg, struct udp_pcb *pcb, struct pbuf *p,
       buf->fromaddr = addr;
       buf->fromport = port;
     }
-    
+
+	conn->recv_avail += p->tot_len;
+    /* Register event with callback */
+    if (conn->callback)
+        (*conn->callback)(conn, NETCONN_EVT_RCVPLUS, p->tot_len);
     sys_mbox_post(conn->recvmbox, buf);
   }
 }
@@ -111,6 +119,11 @@ sent_tcp(void *arg, struct tcp_pcb *pcb, u16_t len)
   if(conn != NULL && conn->sem != SYS_SEM_NULL) {
     sys_sem_signal(conn->sem);
   }
+
+  if (conn && conn->callback)
+      if (tcp_sndbuf(conn->pcb.tcp) > TCP_SNDLOWAT)
+          (*conn->callback)(conn, NETCONN_EVT_SENDPLUS, len);
+  
   return ERR_OK;
 }
 /*-----------------------------------------------------------------------------------*/
@@ -126,12 +139,18 @@ err_tcp(void *arg, err_t err)
   
   conn->err = err;
   if(conn->recvmbox != SYS_MBOX_NULL) {
+    /* Register event with callback */
+    if (conn->callback)
+      (*conn->callback)(conn, NETCONN_EVT_RCVPLUS, 0);
     sys_mbox_post(conn->recvmbox, NULL);
   }
   if(conn->mbox != SYS_MBOX_NULL) {
     sys_mbox_post(conn->mbox, NULL);
   }
   if(conn->acceptmbox != SYS_MBOX_NULL) {
+     /* Register event with callback */
+    if (conn->callback)
+      (*conn->callback)(conn, NETCONN_EVT_RCVPLUS, 0);
     sys_mbox_post(conn->acceptmbox, NULL);
   }
   if(conn->sem != SYS_SEM_NULL) {
@@ -155,15 +174,17 @@ setup_tcp(struct netconn *conn)
 static err_t
 accept_function(void *arg, struct tcp_pcb *newpcb, err_t err)
 {
-  sys_mbox_t *mbox;
+  sys_mbox_t mbox;
   struct netconn *newconn;
+  struct netconn *conn;
   
 #if API_MSG_DEBUG
 #if TCP_DEBUG
   tcp_debug_print_state(newpcb->state);
 #endif /* TCP_DEBUG */
 #endif /* API_MSG_DEBUG */
-  mbox = (sys_mbox_t *)arg;
+  conn = (struct netconn *)arg;
+  mbox = conn->acceptmbox;
   newconn = memp_mallocp(MEMP_NETCONN);
   if(newconn == NULL) {
     return ERR_MEM;
@@ -191,7 +212,17 @@ accept_function(void *arg, struct tcp_pcb *newpcb, err_t err)
   }
   newconn->acceptmbox = SYS_MBOX_NULL;
   newconn->err = err;
-  sys_mbox_post(*mbox, newconn);
+  /* Register event with callback */
+  if (conn->callback)
+  {
+    (*conn->callback)(conn, NETCONN_EVT_RCVPLUS, 0);
+    /* We have to set the callback here even though
+     * the new socket is unknown. Mark the socket as -1. */
+    newconn->callback = conn->callback;
+    newconn->socket = -1;
+  }
+  
+  sys_mbox_post(mbox, newconn);
   return ERR_OK;
 }
 /*-----------------------------------------------------------------------------------*/
@@ -232,6 +263,13 @@ do_delconn(struct api_msg_msg *msg)
     break;
     }
   }
+  /* Trigger select() in socket layer */
+  if (msg->conn->callback)
+  {
+      (*msg->conn->callback)(msg->conn, NETCONN_EVT_RCVPLUS, 0);
+      (*msg->conn->callback)(msg->conn, NETCONN_EVT_SENDPLUS, 0);
+  }
+  
   if(msg->conn->mbox != SYS_MBOX_NULL) {
     sys_mbox_post(msg->conn->mbox, NULL);
   }
@@ -417,7 +455,7 @@ do_listen(struct api_msg_msg *msg)
 	    break;
 	  }
 	}
-	tcp_arg(msg->conn->pcb.tcp, (void *)&(msg->conn->acceptmbox));
+	tcp_arg(msg->conn->pcb.tcp, msg->conn);
 	tcp_accept(msg->conn->pcb.tcp, accept_function);
       }
       break;
@@ -504,6 +542,12 @@ do_write(struct api_msg_msg *msg)
 	tcp_output(msg->conn->pcb.tcp);
       }
       msg->conn->err = err;
+      if (msg->conn->callback)
+          if (err == ERR_OK)
+          {
+              if (tcp_sndbuf(msg->conn->pcb.tcp) <= TCP_SNDLOWAT)
+                  (*msg->conn->callback)(msg->conn, NETCONN_EVT_SENDMINUS, msg->msg.w.len);
+          }
       break;
     }
   }

src/api/sockets.c

@@ -28,22 +28,76 @@
  * 
  * Author: Adam Dunkels <adam@sics.se>
  *
+ * Improved by Marc Boucher <marc@mbsi.ca> and David Haas <dhaas@alum.rpi.edu>
+ *
  */
 
 #include "lwip/debug.h"
 #include "lwip/api.h"
+#include "lwip/arch.h"
+#include "lwip/sys.h"
 
 #include "lwip/sockets.h"
 
-#define NUM_SOCKETS 10
+#define NUM_SOCKETS MEMP_NUM_NETCONN
 
 struct lwip_socket {
   struct netconn *conn;
   struct netbuf *lastdata;
   u16_t lastoffset;
+  u16_t rcvevent;
+  u16_t sendevent;
+  u16_t	flags;
+  int err;
+};
+
+struct lwip_select_cb 
+{
+    struct lwip_select_cb *next;
+    fd_set *readset;
+    fd_set *writeset;
+    fd_set *exceptset;
+    int sem_signalled;
+    sys_sem_t sem;
 };
 
 static struct lwip_socket sockets[NUM_SOCKETS];
+static struct lwip_select_cb *select_cb_list = 0;
+
+static sys_sem_t socksem = 0;
+static sys_sem_t selectsem = 0;
+
+static void
+event_callback(struct netconn *conn, enum netconn_evt evt, u16_t len);
+
+static int err_to_errno_table[11] = {
+    0,			/* ERR_OK    0      No error, everything OK. */
+    ENOMEM,		/* ERR_MEM  -1      Out of memory error.     */
+    ENOBUFS,		/* ERR_BUF  -2      Buffer error.            */
+    ECONNABORTED,	/* ERR_ABRT -3      Connection aborted.      */
+    ECONNRESET,		/* ERR_RST  -4      Connection reset.        */
+    ESHUTDOWN,		/* ERR_CLSD -5      Connection closed.       */
+    ENOTCONN,		/* ERR_CONN -6      Not connected.           */
+    EINVAL,		/* ERR_VAL  -7      Illegal value.           */
+    EIO,		/* ERR_ARG  -8      Illegal argument.        */
+    EHOSTUNREACH,	/* ERR_RTE  -9      Routing problem.         */
+    EADDRINUSE		/* ERR_USE  -10     Address in use.          */
+};
+
+#define err_to_errno(err) \
+	((err) < (sizeof(err_to_errno_table)/sizeof(int))) ? \
+		err_to_errno_table[-(err)] : EIO
+
+#ifdef ERRNO
+#define set_errno(err) errno = (err)
+#else
+#define set_errno(err)
+#endif
+
+#define sock_set_errno(sk, e) do { \
+			sk->err = (e); \
+			set_errno(sk->err); \
+} while(0)
 
 /*-----------------------------------------------------------------------------------*/
 static struct lwip_socket *
@@ -51,17 +105,20 @@ get_socket(int s)
 {
   struct lwip_socket *sock;
   
-  if(s > NUM_SOCKETS) {
-    /* errno = EBADF; */
+  if((s < 0) || (s > NUM_SOCKETS)) {
+	DEBUGF(SOCKETS_DEBUG, ("get_socket(%d): invalid\n", s));
+	set_errno(EBADF);
     return NULL;
   }
   
   sock = &sockets[s];
 
-  if(sock->conn == NULL) {
-    /* errno = EBADF; */
+  if(!sock->conn) {
+	DEBUGF(SOCKETS_DEBUG, ("get_socket(%d): not active\n", s));
+	set_errno(EBADF);
     return NULL;
   }
+
   return sock;
 }
 /*-----------------------------------------------------------------------------------*/
@@ -69,16 +126,28 @@ static int
 alloc_socket(struct netconn *newconn)
 {
   int i;
+
+  if (!socksem)
+      socksem = sys_sem_new(1);
+
+  /* Protect socket array */
+  sys_sem_wait(socksem);
   
   /* allocate a new socket identifier */
   for(i = 0; i < NUM_SOCKETS; ++i) {
-    if(sockets[i].conn == NULL) {
+    if(!sockets[i].conn) {
       sockets[i].conn = newconn;
       sockets[i].lastdata = NULL;
       sockets[i].lastoffset = 0;
+      sockets[i].rcvevent = 0;
+      sockets[i].sendevent = 1; /* TCP send buf is empty */
+      sockets[i].flags = 0;
+      sockets[i].err = 0;
+      sys_sem_signal(socksem);
       return i;
     }
   }
+  sys_sem_signal(socksem);
   return -1;
 }
 /*-----------------------------------------------------------------------------------*/
@@ -90,9 +159,11 @@ lwip_accept(int s, struct sockaddr *addr, int *addrlen)
   struct ip_addr naddr;
   u16_t port;
   int newsock;
+  struct sockaddr_in sin;
 
+  DEBUGF(SOCKETS_DEBUG, ("lwip_accept(%d)...\n", s));
   sock = get_socket(s);
-  if(sock == NULL) {
+  if(!sock) {
     return -1;
   }
   
@@ -101,14 +172,38 @@ lwip_accept(int s, struct sockaddr *addr, int *addrlen)
   /* get the IP address and port of the remote host */
   netconn_peer(newconn, &naddr, &port);
   
-  ((struct sockaddr_in *)addr)->sin_addr.s_addr = naddr.addr;
-  ((struct sockaddr_in *)addr)->sin_port = port;
+  memset(&sin, 0, sizeof(sin));
+  sin.sin_len = sizeof(sin);
+  sin.sin_family = AF_INET;
+  sin.sin_port = htons(port);
+  sin.sin_addr.s_addr = naddr.addr;
+
+  if(*addrlen > sizeof(sin))
+      *addrlen = sizeof(sin);
+
+  memcpy(addr, &sin, *addrlen);
 
   newsock = alloc_socket(newconn);
   if(newsock == -1) {  
     netconn_delete(newconn);
-    /* errno = ENOBUFS; */
+	sock_set_errno(sock, ENOBUFS);
+	return -1;
   }
+  newconn->callback = event_callback;
+  sock = get_socket(newsock);
+  
+  sys_sem_wait(socksem);
+  sock->rcvevent += -1 - newconn->socket;
+  newconn->socket = newsock;
+  sys_sem_signal(socksem);
+
+#if SOCKETS_DEBUG
+  DEBUGF(SOCKETS_DEBUG, ("lwip_accept(%d) returning new sock=%d addr=", s, newsock));
+  ip_addr_debug_print(&naddr);
+  DEBUGF(SOCKETS_DEBUG, (" port=%u\n", port));
+#endif
+  
+  sock_set_errno(sock, 0);
   return newsock;
 }
 /*-----------------------------------------------------------------------------------*/
@@ -116,25 +211,34 @@ int
 lwip_bind(int s, struct sockaddr *name, int namelen)
 {
   struct lwip_socket *sock;
-  struct ip_addr remote_addr;
-  u16_t remote_port;
+  struct ip_addr local_addr;
+  u16_t local_port;
   err_t err;
   
   sock = get_socket(s);
-  if(sock == NULL) {
+  if(!sock) {
     return -1;
   }
   
-  remote_addr.addr = ((struct sockaddr_in *)name)->sin_addr.s_addr;
-  remote_port = ((struct sockaddr_in *)name)->sin_port;
+  local_addr.addr = ((struct sockaddr_in *)name)->sin_addr.s_addr;
+  local_port = ((struct sockaddr_in *)name)->sin_port;
+
+#if SOCKETS_DEBUG
+  DEBUGF(SOCKETS_DEBUG, ("lwip_bind(%d, addr=", s));
+  ip_addr_debug_print(&local_addr);
+  DEBUGF(SOCKETS_DEBUG, (" port=%u)\n", ntohs(local_port)));
+#endif
   
-  err = netconn_bind(sock->conn, &remote_addr, ntohs(remote_port));
+  err = netconn_bind(sock->conn, &local_addr, ntohs(local_port));
 
   if(err != ERR_OK) {
-    /* errno = ... */
+  	DEBUGF(SOCKETS_DEBUG, ("lwip_bind(%d) failed, err=%d\n", s, err));
+	sock_set_errno(sock, err_to_errno(err));
     return -1;
   }
 
+  DEBUGF(SOCKETS_DEBUG, ("lwip_bind(%d) succeeded\n", s));
+  sock_set_errno(sock, 0);
   return 0;
 }
 /*-----------------------------------------------------------------------------------*/
@@ -143,20 +247,28 @@ lwip_close(int s)
 {
   struct lwip_socket *sock;
   
-  DEBUGF(SOCKETS_DEBUG, ("close: socket %d\n", s));
+  DEBUGF(SOCKETS_DEBUG, ("lwip_close(%d)\n", s));
+  if (!socksem)
+      socksem = sys_sem_new(1);
+
+  /* We cannot allow multiple closes of the same socket. */
+  sys_sem_wait(socksem);
+  
   sock = get_socket(s);
-  if(sock == NULL) {
-    return -1;
+  if(!sock) {
+      sys_sem_signal(socksem);
+      return -1;
   }
   
-  
   netconn_delete(sock->conn);
-  if(sock->lastdata != NULL) {
+  if(sock->lastdata) {
     netbuf_delete(sock->lastdata);
   }
   sock->lastdata = NULL;
   sock->lastoffset = 0;
   sock->conn = NULL;
+  sys_sem_signal(socksem);
+  sock_set_errno(sock, 0);
   return 0;
 }
 /*-----------------------------------------------------------------------------------*/
@@ -164,28 +276,40 @@ int
 lwip_connect(int s, struct sockaddr *name, int namelen)
 {
   struct lwip_socket *sock;
-  struct ip_addr remote_addr;
-  u16_t remote_port;
   err_t err;
 
   sock = get_socket(s);
-  if(sock == NULL) {
+  if(!sock) {
     return -1;
   }
- 
+  
   if (((struct sockaddr_in *)name)->sin_family == AF_UNSPEC) {
-    err = netconn_disconnect(sock->conn);
-  } else {  
-    remote_addr.addr = ((struct sockaddr_in *)name)->sin_addr.s_addr;
-    remote_port = ((struct sockaddr_in *)name)->sin_port;
-    err = netconn_connect(sock->conn, &remote_addr, ntohs(remote_port));
-  }  
+  	DEBUGF(SOCKETS_DEBUG, ("lwip_connect(%d, AF_UNSPEC)\n", s));
+	err = netconn_disconnect(sock->conn);
+  } else {
+  	struct ip_addr remote_addr;
+  	u16_t remote_port;
+
+  	remote_addr.addr = ((struct sockaddr_in *)name)->sin_addr.s_addr;
+  	remote_port = ((struct sockaddr_in *)name)->sin_port;
+
+#if SOCKETS_DEBUG
+  	DEBUGF(SOCKETS_DEBUG, ("lwip_connect(%d, addr=", s));
+  	ip_addr_debug_print(&remote_addr);
+  	DEBUGF(SOCKETS_DEBUG, (" port=%u)\n", ntohs(remote_port)));
+#endif
+        
+  	err = netconn_connect(sock->conn, &remote_addr, ntohs(remote_port));
+   }
 
   if(err != ERR_OK) {
-    /* errno = ... */
+  	DEBUGF(SOCKETS_DEBUG, ("lwip_connect(%d) failed, err=%d\n", s, err));
+	sock_set_errno(sock, err_to_errno(err));
     return -1;
   }
 
+  DEBUGF(SOCKETS_DEBUG, ("lwip_connect(%d) succeeded\n", s));
+  sock_set_errno(sock, 0);
   return 0;
 }
 /*-----------------------------------------------------------------------------------*/
@@ -195,18 +319,21 @@ lwip_listen(int s, int backlog)
   struct lwip_socket *sock;    
   err_t err;
   
+  DEBUGF(SOCKETS_DEBUG, ("lwip_listen(%d, backlog=%d)\n", s, backlog));
   sock = get_socket(s);
-  if(sock == NULL) {
+  if(!sock) {
     return -1;
   }
  
   err = netconn_listen(sock->conn);
 
   if(err != ERR_OK) {
-    /* errno = ... */
+  	DEBUGF(SOCKETS_DEBUG, ("lwip_listen(%d) failed, err=%d\n", s, err));
+	sock_set_errno(sock, err_to_errno(err));
     return -1;
   }
 
+  sock_set_errno(sock, 0);
   return 0;
 }
 /*-----------------------------------------------------------------------------------*/
@@ -221,21 +348,33 @@ lwip_recvfrom(int s, void *mem, int len, unsigned int flags,
   u16_t port;
 
   
+  DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom(%d, %p, %d, 0x%x, ..)\n", s, mem, len, flags));
   sock = get_socket(s);
-  if(sock == NULL) {
+  if(!sock) {
     return -1;
   }
 
   /* Check if there is data left from the last recv operation. */
-  if(sock->lastdata != NULL) {    
+  if(sock->lastdata) {    
     buf = sock->lastdata;
   } else {
+    /* If this is non-blocking call, then check first */
+    if (((flags & MSG_DONTWAIT) || (sock->flags & O_NONBLOCK))
+	&& !sock->rcvevent)
+    {
+      DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom(%d): returning EWOULDBLOCK\n", s));
+      sock_set_errno(sock, EWOULDBLOCK);
+      return -1;
+    }
+      
     /* No data was left from the previous operation, so we try to get
        some from the network. */
     buf = netconn_recv(sock->conn);
     
-    if(buf == NULL) {
+    if(!buf) {
       /* We should really do some error checking here. */
+      DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom(%d): buf == NULL!\n", s));
+      sock_set_errno(sock, 0);
       return 0;
     }
   }
@@ -255,13 +394,38 @@ lwip_recvfrom(int s, void *mem, int len, unsigned int flags,
   netbuf_copy_partial(buf, mem, copylen, sock->lastoffset);
 
   /* Check to see from where the data was. */
-  if(from != NULL && fromlen != NULL) {
+  if(from && fromlen) {
+    struct sockaddr_in sin;
+
+    addr = netbuf_fromaddr(buf);
+    port = netbuf_fromport(buf);
+
+    memset(&sin, 0, sizeof(sin));
+    sin.sin_len = sizeof(sin);
+    sin.sin_family = AF_INET;
+    sin.sin_port = htons(port);
+    sin.sin_addr.s_addr = addr->addr;
+
+    if(*fromlen > sizeof(sin))
+      *fromlen = sizeof(sin);
+
+    memcpy(from, &sin, *fromlen);
+
+#if SOCKETS_DEBUG
+    DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom(%d): addr=", s));
+    ip_addr_debug_print(addr);
+    DEBUGF(SOCKETS_DEBUG, (" port=%u len=%u\n", port, copylen));
+#endif
+  } else {
+#if SOCKETS_DEBUG > 0
     addr = netbuf_fromaddr(buf);
     port = netbuf_fromport(buf);  
-    ((struct sockaddr_in *)from)->sin_addr.s_addr = addr->addr;
-    ((struct sockaddr_in *)from)->sin_port = port;
-    ((struct sockaddr_in *)from)->sin_family = AF_INET;
-    *fromlen = sizeof(struct sockaddr_in);
+
+    DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom(%d): addr=", s));
+    ip_addr_debug_print(addr);
+    DEBUGF(SOCKETS_DEBUG, (" port=%u len=%u\n", port, copylen));
+#endif
+
   }
  
   /* If this is a TCP socket, check if there is data left in the
@@ -277,13 +441,14 @@ lwip_recvfrom(int s, void *mem, int len, unsigned int flags,
   }
 
  
+  sock_set_errno(sock, 0);
   return copylen;
 }
 /*-----------------------------------------------------------------------------------*/
 int
 lwip_read(int s, void *mem, int len)
 {
-  return lwip_recv(s, mem, len, 0);
+  return lwip_recvfrom(s, mem, len, 0, NULL, NULL);
 }
 /*-----------------------------------------------------------------------------------*/
 int
@@ -299,10 +464,10 @@ lwip_send(int s, void *data, int size, unsigned int flags)
   struct netbuf *buf;
   err_t err;
 
-  DEBUGF(SOCKETS_DEBUG, ("send: socket %d, size %d\n", s, size));
+  DEBUGF(SOCKETS_DEBUG, ("lwip_send(%d, data=%p, size=%d, flags=0x%x)\n", s, data, size, flags));
 
   sock = get_socket(s);
-  if(sock == NULL) {
+  if(!sock) {
     return -1;
   }  
   
@@ -311,8 +476,9 @@ lwip_send(int s, void *data, int size, unsigned int flags)
     /* create a buffer */
     buf = netbuf_new();
 
-    if(buf == NULL) {
-      /* errno = ENOBUFS; */
+    if(!buf) {
+	  DEBUGF(SOCKETS_DEBUG, ("lwip_send(%d) ENOBUFS\n", s));
+	  sock_set_errno(sock, ENOBUFS);
       return -1;
     }
     
@@ -334,10 +500,13 @@ lwip_send(int s, void *data, int size, unsigned int flags)
     break;
   }
   if(err != ERR_OK) {
-    /* errno = ... */
+	DEBUGF(SOCKETS_DEBUG, ("lwip_send(%d) err=%d\n", s, err));
+	sock_set_errno(sock, err_to_errno(err));
     return -1;    
   }
-    
+
+  DEBUGF(SOCKETS_DEBUG, ("lwip_send(%d) ok size=%d\n", s, size));
+  sock_set_errno(sock, 0);
   return size;
 }
 /*-----------------------------------------------------------------------------------*/
@@ -351,7 +520,7 @@ lwip_sendto(int s, void *data, int size, unsigned int flags,
   int ret,connected;
 
   sock = get_socket(s);
-  if(sock == NULL) {
+  if(!sock) {
     return -1;
   }
   
@@ -360,16 +529,23 @@ lwip_sendto(int s, void *data, int size, unsigned int flags,
   
   remote_addr.addr = ((struct sockaddr_in *)to)->sin_addr.s_addr;
   remote_port = ((struct sockaddr_in *)to)->sin_port;
+
+#if SOCKETS_DEBUG
+  DEBUGF(SOCKETS_DEBUG, ("lwip_sendto(%d, data=%p, size=%d, flags=0x%x to=", s, data, size, flags));
+  ip_addr_debug_print(&remote_addr);
+  DEBUGF(SOCKETS_DEBUG, (" port=%u\n", ntohs(remote_port)));
+#endif
+  
   netconn_connect(sock->conn, &remote_addr, ntohs(remote_port));
   
   ret = lwip_send(s, data, size, flags);
 
   /* reset the remote address and port number
      of the connection */
-  if (connected)
-    netconn_connect(sock->conn, &addr, port);
+  if(connected)
+  	netconn_connect(sock->conn, &addr, port);
   else
-    netconn_disconnect(sock->conn);	  
+	netconn_disconnect(sock->conn);
   return ret;
 }
 /*-----------------------------------------------------------------------------------*/
@@ -382,28 +558,35 @@ lwip_socket(int domain, int type, int protocol)
   /* create a netconn */
   switch(type) {
   case SOCK_DGRAM:
-    conn = netconn_new(NETCONN_UDP);
+    conn = netconn_new_with_callback(NETCONN_UDP, event_callback);
+	DEBUGF(SOCKETS_DEBUG, ("lwip_socket(%s, SOCK_DGRAM, %d) = ", domain == PF_INET ? "PF_INET" : "UNKNOWN", protocol));
     break;
   case SOCK_STREAM:
-    conn = netconn_new(NETCONN_TCP);
+    conn = netconn_new_with_callback(NETCONN_TCP, event_callback);
+	DEBUGF(SOCKETS_DEBUG, ("lwip_socket(%s, SOCK_STREAM, %d) = ", domain == PF_INET ? "PF_INET" : "UNKNOWN", protocol));
     break;
   default:
-    /* errno = ... */
+	DEBUGF(SOCKETS_DEBUG, ("lwip_socket(%d, %d/UNKNOWN, %d) = -1\n", domain, type, protocol));
+	set_errno(EINVAL);
     return -1;
   }
 
-  if(conn == NULL) {
-    DEBUGF(SOCKETS_DEBUG, ("socket: could not create netconn.\n"));
-    /* errno = ENOBUFS; */
+  if(!conn) {
+    DEBUGF(SOCKETS_DEBUG, ("-1 / ENOBUFS (could not create netconn)\n"));
+	set_errno(ENOBUFS);
     return -1;
   }
 
   i = alloc_socket(conn);
 
   if(i == -1) {
-    /* errno = ENOBUFS; */
     netconn_delete(conn);
+	set_errno(ENOBUFS);
+	return -1;
   }
+  conn->socket = i;
+  DEBUGF(SOCKETS_DEBUG, ("%d\n", i));
+  set_errno(0);
   return i;
 }
 /*-----------------------------------------------------------------------------------*/
@@ -412,4 +595,456 @@ lwip_write(int s, void *data, int size)
 {
    return lwip_send(s, data, size, 0);
 }
+
 /*-----------------------------------------------------------------------------------*/
+static int
+lwip_selscan(int maxfdp1, fd_set *readset, fd_set *writeset, fd_set *exceptset)
+{
+    int i, nready = 0;
+    fd_set lreadset, lwriteset, lexceptset;
+    struct lwip_socket *p_sock;
+
+    FD_ZERO(&lreadset);
+    FD_ZERO(&lwriteset);
+    FD_ZERO(&lexceptset);
+    
+    /* Go through each socket in each list to count number of sockets which
+       currently match */
+    for(i = 0; i < maxfdp1; i++)
+    {
+        if(FD_ISSET(i, readset))
+        {
+            /* See if netconn of this socket is ready for read */
+            p_sock = get_socket(i);
+            if (p_sock && (p_sock->lastdata || p_sock->rcvevent))
+            {
+                FD_SET(i, &lreadset);
+    			DEBUGF(SOCKETS_DEBUG, ("lwip_selscan: fd=%d ready for reading\n", i));
+                nready++;
+            }
+        }
+        if(FD_ISSET(i, writeset))
+        {
+            /* See if netconn of this socket is ready for write */
+            p_sock = get_socket(i);
+            if (p_sock && p_sock->sendevent)
+            {
+                FD_SET(i, &lwriteset);
+    			DEBUGF(SOCKETS_DEBUG, ("lwip_selscan: fd=%d ready for writing\n", i));
+                nready++;
+            }
+        }
+    }
+    *readset = lreadset;
+    *writeset = lwriteset;
+    FD_ZERO(exceptset);
+
+    return nready;
+}
+
+
+/*-----------------------------------------------------------------------------------*/
+int
+lwip_select(int maxfdp1, fd_set *readset, fd_set *writeset, fd_set *exceptset,
+               const struct timeval *timeout)
+{
+    int i;
+    int nready;
+    fd_set lreadset, lwriteset, lexceptset;
+    u32_t msectimeout;
+    struct lwip_select_cb select_cb;
+    struct lwip_select_cb *p_selcb;
+
+	DEBUGF(SOCKETS_DEBUG, ("lwip_select(%d, %p, %p, %p, tvsec=%ld tvusec=%ld)\n", maxfdp1, (void *)readset, (void *) writeset, (void *) exceptset, timeout ? timeout->tv_sec : -1L, timeout ? timeout->tv_usec : -1L));
+    select_cb.next = 0;
+    select_cb.readset = readset;
+    select_cb.writeset = writeset;
+    select_cb.exceptset = exceptset;
+    select_cb.sem_signalled = 0;
+    
+    /* Protect ourselves searching through the list */
+    if (!selectsem)
+        selectsem = sys_sem_new(1);
+    sys_sem_wait(selectsem);
+    
+    if (readset)
+        lreadset = *readset;
+    else
+        FD_ZERO(&lreadset);
+    if (writeset)
+        lwriteset = *writeset;
+    else
+        FD_ZERO(&lwriteset);
+    if (exceptset)
+        lexceptset = *exceptset;
+    else
+        FD_ZERO(&lexceptset);
+    
+    /* Go through each socket in each list to count number of sockets which
+       currently match */
+    nready = lwip_selscan(maxfdp1, &lreadset, &lwriteset, &lexceptset);
+    
+    /* If we don't have any current events, then suspend if we are supposed to */
+    if (!nready)
+    {
+        if (timeout && timeout->tv_sec == 0 && timeout->tv_usec == 0)
+        {
+            sys_sem_signal(socksem);
+            if (readset)
+                FD_ZERO(readset);
+            if (writeset)
+                FD_ZERO(writeset);
+            if (exceptset)
+                FD_ZERO(exceptset);
+
+			DEBUGF(SOCKETS_DEBUG, ("lwip_select: no timeout, returning 0\n"));
+  			set_errno(0);
+            return 0;
+        }
+        
+        /* add our semaphore to list */
+        /* We don't actually need any dynamic memory. Our entry on the
+         * list is only valid while we are in this function, so it's ok
+         * to use local variables */
+
+        select_cb.sem = sys_sem_new(0);
+        /* Note that we are still protected */
+        /* Put this select_cb on top of list */
+        select_cb.next = select_cb_list;
+        select_cb_list = &select_cb;
+
+        /* Now we can safely unprotect */
+        sys_sem_signal(selectsem);
+
+        /* Now just wait to be woken */
+        if (timeout == 0)
+            /* Wait forever */
+            msectimeout = 0;
+        else
+            msectimeout =  ((timeout->tv_sec * 1000) + (timeout->tv_usec /1000));
+
+        i = sys_sem_wait_timeout(select_cb.sem, msectimeout);
+
+        /* Take us off the list */
+        sys_sem_wait(selectsem);
+        if (select_cb_list == &select_cb)
+            select_cb_list = select_cb.next;
+        else
+            for (p_selcb = select_cb_list; p_selcb; p_selcb = p_selcb->next)
+                if (p_selcb->next == &select_cb)
+                {
+                    p_selcb->next = select_cb.next;
+                    break;
+                }
+        
+        sys_sem_signal(selectsem);
+        
+        sys_sem_free(select_cb.sem);
+        if (i == 0)             /* Timeout */
+        {
+            if (readset)
+                FD_ZERO(readset);
+            if (writeset)
+                FD_ZERO(writeset);
+            if (exceptset)
+                FD_ZERO(exceptset);
+			DEBUGF(SOCKETS_DEBUG, ("lwip_select: timeout expired\n"));
+  			set_errno(0);
+            return 0;
+        }
+
+        if (readset)
+            lreadset = *readset;
+        else
+            FD_ZERO(&lreadset);
+        if (writeset)
+            lwriteset = *writeset;
+        else
+            FD_ZERO(&lwriteset);
+        if (exceptset)
+            lexceptset = *exceptset;
+        else
+            FD_ZERO(&lexceptset);
+
+        /* See what's set */
+        nready = lwip_selscan(maxfdp1, &lreadset, &lwriteset, &lexceptset);
+    }
+    else
+        sys_sem_signal(selectsem);
+    
+    if (readset)
+        *readset = lreadset;
+    if (writeset)
+        *writeset = lwriteset;
+    if (exceptset)
+        *exceptset = lexceptset;
+	DEBUGF(SOCKETS_DEBUG, ("lwip_select: nready=%d\n", nready));
+  	set_errno(0);
+    return nready;
+}
+
+/*-----------------------------------------------------------------------------------*/
+static void
+event_callback(struct netconn *conn, enum netconn_evt evt, u16_t len)
+{
+    int s;
+    struct lwip_socket *sock;
+    struct lwip_select_cb *scb;
+    
+    /* Get socket */
+    if (conn)
+    {
+        s = conn->socket;
+        if (s < 0)
+        {
+            /* Data comes in right away after an accept, even though
+             * the server task might not have created a new socket yet.
+             * Just count down (or up) if that's the case and we
+             * will use the data later. Note that only receive events
+             * can happen before the new socket is set up. */
+            if (evt == NETCONN_EVT_RCVPLUS)
+                conn->socket--;
+            return;
+        }
+        
+        sock = get_socket(s);
+        if (!sock)
+            return;
+    }
+    else
+        return;
+
+    if (!selectsem)
+        selectsem = sys_sem_new(1);
+    
+    sys_sem_wait(selectsem);
+    /* Set event as required */
+    switch (evt)
+    {
+      case NETCONN_EVT_RCVPLUS:
+        sock->rcvevent++;
+        break;
+      case NETCONN_EVT_RCVMINUS:
+        sock->rcvevent--;
+        break;
+      case NETCONN_EVT_SENDPLUS:
+        sock->sendevent = 1;
+        break;
+      case NETCONN_EVT_SENDMINUS:
+        sock->sendevent = 0;
+        break;
+    }
+    sys_sem_signal(selectsem);
+    
+    /* Now decide if anyone is waiting for this socket */
+    /* NOTE: This code is written this way to protect the select link list
+       but to avoid a deadlock situation by releasing socksem before
+       signalling for the select. This means we need to go through the list
+       multiple times ONLY IF a select was actually waiting. We go through
+       the list the number of waiting select calls + 1. This list is
+       expected to be small. */
+    while (1)
+    {
+        sys_sem_wait(selectsem);
+        for (scb = select_cb_list; scb; scb = scb->next)
+        {
+            if (scb->sem_signalled == 0)
+            {
+                /* Test this select call for our socket */
+                if (scb->readset && FD_ISSET(s, scb->readset))
+                    if (sock->rcvevent)
+                        break;
+                if (scb->writeset && FD_ISSET(s, scb->writeset))
+                    if (sock->sendevent)
+                        break;
+            }
+        }
+        if (scb)
+        {
+            scb->sem_signalled = 1;
+            sys_sem_signal(selectsem);
+            sys_sem_signal(scb->sem);
+        } else {
+            sys_sem_signal(selectsem);
+            break;
+        }
+    }
+    
+}
+
+/*-----------------------------------------------------------------------------------*/
+
+
+int lwip_shutdown(int s, int how)
+{
+	DEBUGF(SOCKETS_DEBUG, ("lwip_shutdown(%d, how=%d)\n", s, how));
+    return lwip_close(s); /* XXX temporary hack until proper implementation */
+}
+
+int lwip_getpeername (int s, struct sockaddr *name, int *namelen)
+{
+  struct lwip_socket *sock;
+  struct sockaddr_in sin;
+  struct ip_addr naddr;
+
+  sock = get_socket(s);
+  if(!sock) {
+    return -1;
+  }
+  
+  memset(&sin, 0, sizeof(sin));
+  sin.sin_len = sizeof(sin);
+  sin.sin_family = AF_INET;
+
+  /* get the IP address and port of the remote host */
+  netconn_peer(sock->conn, &naddr, &sin.sin_port);
+  
+#if SOCKETS_DEBUG
+  DEBUGF(SOCKETS_DEBUG, ("lwip_getpeername(%d, addr=", s));
+  ip_addr_debug_print(&naddr);
+  DEBUGF(SOCKETS_DEBUG, (" port=%d)\n", sin.sin_port));
+#endif
+  
+  sin.sin_port = htons(sin.sin_port);
+  sin.sin_addr.s_addr = naddr.addr;
+
+  if(*namelen > sizeof(sin))
+      *namelen = sizeof(sin);
+
+  memcpy(name, &sin, *namelen);
+  sock_set_errno(sock, 0);
+  return 0;
+}
+
+int lwip_getsockname (int s, struct sockaddr *name, int *namelen)
+{
+  struct lwip_socket *sock;
+  struct sockaddr_in sin;
+  struct ip_addr *naddr;
+
+  sock = get_socket(s);
+  if(!sock) {
+    return -1;
+  }
+  
+  memset(&sin, 0, sizeof(sin));
+  sin.sin_len = sizeof(sin);
+  sin.sin_family = AF_INET;
+
+  /* get the IP address and port of the remote host */
+  netconn_addr(sock->conn, &naddr, &sin.sin_port);
+
+#if SOCKETS_DEBUG
+  DEBUGF(SOCKETS_DEBUG, ("lwip_getsockname(%d, addr=", s));
+  ip_addr_debug_print(naddr);
+  DEBUGF(SOCKETS_DEBUG, (" port=%d)\n", sin.sin_port));
+#endif
+  
+  sin.sin_port = htons(sin.sin_port);
+  sin.sin_addr.s_addr = naddr->addr;
+
+  if(*namelen > sizeof(sin))
+      *namelen = sizeof(sin);
+
+  memcpy(name, &sin, *namelen);
+  sock_set_errno(sock, 0);
+  return 0;
+}
+
+int lwip_getsockopt (int s, int level, int optname, char *optval, int *optlen)
+{
+	int err = ENOSYS;
+	struct lwip_socket *sock = get_socket(s);
+
+	if(!sock) {
+		return -1;
+	}
+
+	if(level == SOL_SOCKET) {
+		switch(optname) {
+			case SO_ERROR:
+				if(!optval || !optlen || (*optlen != sizeof(int))) {
+					err = EINVAL;
+					break;
+				}
+				*(int *)optval = sock->err;
+				sock->err = 0;
+				DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, SOL_SOCKET, SO_ERROR) = %d\n", s, *(int *)optval));
+				err = 0;
+				break;
+			default:
+				DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, SOL_SOCKET, UNIMPL: optname=0x%x, ..)\n", s, optname));
+				break;
+		}
+	} else {
+		DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, level=0x%x, UNIMPL: optname=0x%x, ..)\n", s, level, optname));
+	}
+	sock_set_errno(sock, err);
+	return err ? -1 : 0;
+}
+
+int lwip_setsockopt (int s, int level, int optname, const char *optval, int optlen)
+{
+	struct lwip_socket *sock = get_socket(s);
+	int err = ENOSYS;
+
+	if(!sock) {
+		return -1;
+	}
+
+	if(level == SOL_SOCKET) {
+		switch(optname) {
+			case SO_REUSEADDR:
+				DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, SOL_SOCKET, SO_REUSEADDR, ..)\n", s));
+			   	/* XXX just pretend we support this for now */
+  				err = 0;
+				break;
+			default:
+				DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, SOL_SOCKET, UNIMPL: optname=0x%x, ..)\n", s, optname));
+				break;
+		}
+	} else {
+		DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, level=0x%x, UNIMPL: optname=0x%x, ..)\n", s, level, optname));
+	}
+
+	sock_set_errno(sock, err);
+	return err ? -1 : 0;
+}
+
+int lwip_ioctl(int s, long cmd, void *argp)
+{
+	struct lwip_socket *sock = get_socket(s);
+
+	if(!sock) {
+		return -1;
+	}
+
+	switch(cmd) {
+	case FIONREAD:
+		if(!argp) {
+			sock_set_errno(sock, EINVAL);
+			return -1;
+		}
+
+		*((u16_t*)argp) = sock->conn->recv_avail;
+
+		DEBUGF(SOCKETS_DEBUG, ("lwip_ioctl(%d, FIONREAD, %p) = %u\n", s, argp, *((u16_t*)argp)));
+  		sock_set_errno(sock, 0);
+		return 0;
+
+	case FIONBIO:
+		if(argp && *(u32_t*)argp)
+			sock->flags |= O_NONBLOCK;
+		else
+			sock->flags &= ~O_NONBLOCK;
+		DEBUGF(SOCKETS_DEBUG, ("lwip_ioctl(%d, FIONBIO, %d)\n", s, !!(sock->flags & O_NONBLOCK)));
+  		sock_set_errno(sock, 0);
+		return 0;
+
+	default:
+		DEBUGF(SOCKETS_DEBUG, ("lwip_ioctl(%d, UNIMPL: 0x%lx, %p)\n", s, cmd, argp));
+		sock_set_errno(sock, ENOSYS); /* not yet implemented */
+		return -1;
+	}
+}
+

src/api/tcpip.c

@@ -49,15 +49,32 @@ static void (* tcpip_init_done)(void *arg) = NULL;
 static void *tcpip_init_done_arg;
 static sys_mbox_t mbox;
 
+static int tcpip_tcp_timer_active = 0;
+
+
 /*-----------------------------------------------------------------------------------*/
 static void
 tcpip_tcp_timer(void *arg)
 {
+  (void)arg;
+
   tcp_tmr();
-  sys_timeout(TCP_TMR_INTERVAL, (sys_timeout_handler)tcpip_tcp_timer, NULL);
+  if(tcp_active_pcbs || tcp_tw_pcbs) {
+  	sys_timeout(TCP_TMR_INTERVAL, (sys_timeout_handler)tcpip_tcp_timer, NULL);
+  } else {
+	tcpip_tcp_timer_active = 0;
+  }
+}
+
+void
+tcp_timer_needed(void)
+{
+  if(!tcpip_tcp_timer_active && (tcp_active_pcbs || tcp_tw_pcbs)) {
+	tcpip_tcp_timer_active = 1;
+  	sys_timeout(TCP_TMR_INTERVAL, (sys_timeout_handler)tcpip_tcp_timer, NULL);
+  }
 }
 /*-----------------------------------------------------------------------------------*/
-
 static void
 tcpip_thread(void *arg)
 {
@@ -67,8 +84,6 @@ tcpip_thread(void *arg)
   udp_init();
   tcp_init();
 
-  sys_timeout(TCP_TMR_INTERVAL, (sys_timeout_handler)tcpip_tcp_timer, NULL);
-  
   if(tcpip_init_done != NULL) {
     tcpip_init_done(tcpip_init_done_arg);
   }
@@ -84,6 +99,10 @@ tcpip_thread(void *arg)
       DEBUGF(TCPIP_DEBUG, ("tcpip_thread: IP packet %p\n", (void *)msg));
       ip_input(msg->msg.inp.p, msg->msg.inp.netif);
       break;
+    case TCPIP_MSG_LINK:
+      DEBUGF(TCPIP_DEBUG, ("tcpip_thread: LINK packet %p\n", (void *)msg));
+      msg->msg.inp.netif->input(msg->msg.inp.p, msg->msg.inp.netif);
+      break;
     default:
       break;
     }
@@ -109,6 +128,24 @@ tcpip_input(struct pbuf *p, struct netif *inp)
   return ERR_OK;
 }
 /*-----------------------------------------------------------------------------------*/
+err_t
+tcpip_link_input(struct pbuf *p, struct netif *inp)
+{
+  struct tcpip_msg *msg;
+  
+  msg = memp_mallocp(MEMP_TCPIP_MSG);
+  if(msg == NULL) {
+    pbuf_free(p);    
+    return ERR_MEM;  
+  }
+  
+  msg->type = TCPIP_MSG_LINK;
+  msg->msg.inp.p = p;
+  msg->msg.inp.netif = inp;
+  sys_mbox_post(mbox, msg);
+  return ERR_OK;
+}
+/*-----------------------------------------------------------------------------------*/
 void
 tcpip_apimsg(struct api_msg *apimsg)
 {
@@ -129,7 +166,7 @@ tcpip_init(void (* initfunc)(void *), void *arg)
   tcpip_init_done = initfunc;
   tcpip_init_done_arg = arg;
   mbox = sys_mbox_new();
-  sys_thread_new((void *)tcpip_thread, NULL);
+  sys_thread_new(tcpip_thread, NULL);
 }
 /*-----------------------------------------------------------------------------------*/