Merged from DEVEL into main tree.

2026-05-18 14:16:55 +08:00 · 2003-11-14 13:17:23 +00:00
parent bdfdc2bb83
commit e4a6d199fe
45 changed files with 2329 additions and 850 deletions
--- a/src/api/api_lib.c
+++ b/src/api/api_lib.c
@@ -38,7 +38,7 @@
 #include "lwip/api_msg.h"
 #include "lwip/memp.h"

-/*-----------------------------------------------------------------------------------*/
+
 struct
 netbuf *netbuf_new(void)
 {
@@ -53,7 +53,7 @@ netbuf *netbuf_new(void)
    return NULL;
  }
 }
-/*-----------------------------------------------------------------------------------*/
+
 void
 netbuf_delete(struct netbuf *buf)
 {
@@ -65,7 +65,7 @@ netbuf_delete(struct netbuf *buf)
    memp_free(MEMP_NETBUF, buf);
  }
 }
-/*-----------------------------------------------------------------------------------*/
+
 void *
 netbuf_alloc(struct netbuf *buf, u16_t size)
 {
@@ -80,7 +80,7 @@ netbuf_alloc(struct netbuf *buf, u16_t size)
  buf->ptr = buf->p;
  return buf->p->payload;
 }
-/*-----------------------------------------------------------------------------------*/
+
 void
 netbuf_free(struct netbuf *buf)
 {
@@ -89,7 +89,7 @@ netbuf_free(struct netbuf *buf)
  }
  buf->p = buf->ptr = NULL;
 }
-/*-----------------------------------------------------------------------------------*/
+
 void
 netbuf_ref(struct netbuf *buf, void *dataptr, u16_t size)
 {
@@ -101,7 +101,7 @@ netbuf_ref(struct netbuf *buf, void *dataptr, u16_t size)
  buf->p->len = buf->p->tot_len = size;
  buf->ptr = buf->p;
 }
-/*-----------------------------------------------------------------------------------*/
+
 void
 netbuf_chain(struct netbuf *head, struct netbuf *tail)
 {
@@ -109,13 +109,13 @@ netbuf_chain(struct netbuf *head, struct netbuf *tail)
  head->ptr = head->p;
  memp_free(MEMP_NETBUF, tail);
 }
-/*-----------------------------------------------------------------------------------*/
+
 u16_t
 netbuf_len(struct netbuf *buf)
 {
  return buf->p->tot_len;
 }
-/*-----------------------------------------------------------------------------------*/
+
 err_t
 netbuf_data(struct netbuf *buf, void **dataptr, u16_t *len)
 {
@@ -126,7 +126,7 @@ netbuf_data(struct netbuf *buf, void **dataptr, u16_t *len)
  *len = buf->ptr->len;
  return ERR_OK;
 }
-/*-----------------------------------------------------------------------------------*/
+
 s8_t
 netbuf_next(struct netbuf *buf)
 {
@@ -139,13 +139,13 @@ netbuf_next(struct netbuf *buf)
  }
  return 0;
 }
-/*-----------------------------------------------------------------------------------*/
+
 void
 netbuf_first(struct netbuf *buf)
 {
  buf->ptr = buf->p;
 }
-/*-----------------------------------------------------------------------------------*/
+
 void
 netbuf_copy_partial(struct netbuf *buf, void *dataptr, u16_t len, u16_t offset)
 {
@@ -154,7 +154,7 @@ netbuf_copy_partial(struct netbuf *buf, void *dataptr, u16_t len, u16_t offset)

  left = 0;

-  if (buf == NULL) {
+  if(buf == NULL || dataptr == NULL) {
    return;
  }
  
@@ -174,34 +174,38 @@ netbuf_copy_partial(struct netbuf *buf, void *dataptr, u16_t len, u16_t offset)
    }
  }
 }
-/*-----------------------------------------------------------------------------------*/
+
 void
 netbuf_copy(struct netbuf *buf, void *dataptr, u16_t len)
 {
  netbuf_copy_partial(buf, dataptr, len, 0);
 }
-/*-----------------------------------------------------------------------------------*/
+
 struct ip_addr *
 netbuf_fromaddr(struct netbuf *buf)
 {
  return buf->fromaddr;
 }
-/*-----------------------------------------------------------------------------------*/
+
 u16_t
 netbuf_fromport(struct netbuf *buf)
 {
  return buf->fromport;
 }
-/*-----------------------------------------------------------------------------------*/
+
 struct
-netconn *netconn_new(enum netconn_type t)
+netconn *netconn_new_with_proto_and_callback(enum netconn_type t, u16_t proto,
+                                   void (*callback)(struct netconn *, enum netconn_evt, u16_t len))
 {
  struct netconn *conn;
+  struct api_msg *msg;

  conn = memp_malloc(MEMP_NETCONN);
  if (conn == NULL) {
    return NULL;
  }
+  
+  conn->err = ERR_OK;
  conn->type = t;
  conn->pcb.tcp = NULL;

@@ -214,25 +218,44 @@ netconn *netconn_new(enum netconn_type t)
  conn->sem = SYS_SEM_NULL;
  conn->state = NETCONN_NONE;
  conn->socket = 0;
-  conn->callback = 0;
+  conn->callback = callback;
  conn->recv_avail = 0;
+
+  if((msg = memp_malloc(MEMP_API_MSG)) == NULL) {
+    memp_free(MEMP_NETCONN, conn);
+    return NULL;
+  }
+  
+  msg->type = API_MSG_NEWCONN;
+  msg->msg.msg.bc.port = proto; /* misusing the port field */
+  msg->msg.conn = conn;
+  api_msg_post(msg);  
+  sys_mbox_fetch(conn->mbox, NULL);
+  memp_free(MEMP_API_MSG, msg);
+
+  if ( conn->err != ERR_OK ) {
+    memp_free(MEMP_NETCONN, conn);
+    return NULL;
+  }
+
  return conn;
 }
-/*-----------------------------------------------------------------------------------*/
+
+
+struct
+netconn *netconn_new(enum netconn_type t)
+{
+  return netconn_new_with_proto_and_callback(t,0,NULL);
+}
+
 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;
+  return netconn_new_with_proto_and_callback(t,0,callback);
 }

-/*-----------------------------------------------------------------------------------*/
+
 err_t
 netconn_delete(struct netconn *conn)
 {
@@ -286,18 +309,21 @@ netconn_delete(struct netconn *conn)
  memp_free(MEMP_NETCONN, conn);
  return ERR_OK;
 }
-/*-----------------------------------------------------------------------------------*/
+
 enum netconn_type
 netconn_type(struct netconn *conn)
 {
  return conn->type;
 }
-/*-----------------------------------------------------------------------------------*/
+
 err_t
 netconn_peer(struct netconn *conn, struct ip_addr *addr,
       u16_t *port)
 {
  switch (conn->type) {
+  case NETCONN_RAW:
+    /* return an error as connecting is only a helper for upper layers */
+    return ERR_CONN;
  case NETCONN_UDPLITE:
  case NETCONN_UDPNOCHKSUM:
  case NETCONN_UDP:
@@ -316,12 +342,16 @@ netconn_peer(struct netconn *conn, struct ip_addr *addr,
  }
  return (conn->err = ERR_OK);
 }
-/*-----------------------------------------------------------------------------------*/
+
 err_t
 netconn_addr(struct netconn *conn, struct ip_addr **addr,
       u16_t *port)
 {
  switch (conn->type) {
+  case NETCONN_RAW:
+    *addr = &(conn->pcb.raw->local_ip);
+    *port = conn->pcb.raw->protocol;
+    break;
  case NETCONN_UDPLITE:
  case NETCONN_UDPNOCHKSUM:
  case NETCONN_UDP:
@@ -335,7 +365,7 @@ netconn_addr(struct netconn *conn, struct ip_addr **addr,
  }
  return (conn->err = ERR_OK);
 }
-/*-----------------------------------------------------------------------------------*/
+
 err_t
 netconn_bind(struct netconn *conn, struct ip_addr *addr,
      u16_t port)
@@ -366,7 +396,7 @@ netconn_bind(struct netconn *conn, struct ip_addr *addr,
  return conn->err;
 }

-/*-----------------------------------------------------------------------------------*/
+
 err_t
 netconn_connect(struct netconn *conn, struct ip_addr *addr,
       u16_t port)
@@ -417,7 +447,7 @@ netconn_disconnect(struct netconn *conn)
  return conn->err;

 }
-/*-----------------------------------------------------------------------------------*/
+
 err_t
 netconn_listen(struct netconn *conn)
 {
@@ -444,7 +474,7 @@ netconn_listen(struct netconn *conn)
  memp_free(MEMP_API_MSG, msg);
  return conn->err;
 }
-/*-----------------------------------------------------------------------------------*/
+
 struct netconn *
 netconn_accept(struct netconn *conn)
 {
@@ -461,7 +491,7 @@ netconn_accept(struct netconn *conn)
  
  return newconn;
 }
-/*-----------------------------------------------------------------------------------*/
+
 struct netbuf *
 netconn_recv(struct netconn *conn)
 {
@@ -557,7 +587,7 @@ netconn_recv(struct netconn *conn)

  return buf;
 }
-/*-----------------------------------------------------------------------------------*/
+
 err_t
 netconn_send(struct netconn *conn, struct netbuf *buf)
 {
@@ -585,7 +615,7 @@ netconn_send(struct netconn *conn, struct netbuf *buf)
  memp_free(MEMP_API_MSG, msg);
  return conn->err;
 }
-/*-----------------------------------------------------------------------------------*/
+
 err_t
 netconn_write(struct netconn *conn, void *dataptr, u16_t size, u8_t copy)
 {
@@ -661,7 +691,7 @@ netconn_write(struct netconn *conn, void *dataptr, u16_t size, u8_t copy)
  
  return conn->err;
 }
-/*-----------------------------------------------------------------------------------*/
+
 err_t
 netconn_close(struct netconn *conn)
 {
@@ -689,10 +719,10 @@ netconn_close(struct netconn *conn)
  memp_free(MEMP_API_MSG, msg);
  return conn->err;
 }
-/*-----------------------------------------------------------------------------------*/
+
 err_t
 netconn_err(struct netconn *conn)
 {
  return conn->err;
 }
-/*-----------------------------------------------------------------------------------*/
+
--- a/src/api/api_msg.c
+++ b/src/api/api_msg.c
@@ -37,6 +37,37 @@
 #include "lwip/sys.h"
 #include "lwip/tcpip.h"

+#if LWIP_RAW
+static int
+recv_raw(void *arg, struct raw_pcb *pcb, struct pbuf *p,
+    struct ip_addr *addr)
+{
+  struct netbuf *buf;
+  struct netconn *conn;
+
+  conn = arg;
+  if (!conn) return 0;
+
+  if (conn->recvmbox != SYS_MBOX_NULL) {
+    if (!(buf = memp_malloc(MEMP_NETBUF))) {
+      return 0;
+    }
+    pbuf_ref(p);
+    buf->p = p;
+    buf->ptr = p;
+    buf->fromaddr = addr;
+    buf->fromport = pcb->protocol;
+
+    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);
+  }
+
+  return 0; /* do not eat the packet */
+}
+#endif
 #if LWIP_UDP
 static void
 recv_udp(void *arg, struct udp_pcb *pcb, struct pbuf *p,
@@ -72,7 +103,7 @@ recv_udp(void *arg, struct udp_pcb *pcb, struct pbuf *p,
 }
 #endif /* LWIP_UDP */
 #if LWIP_TCP
-/*-----------------------------------------------------------------------------------*/
+
 static err_t
 recv_tcp(void *arg, struct tcp_pcb *pcb, struct pbuf *p, err_t err)
 {
@@ -103,7 +134,7 @@ recv_tcp(void *arg, struct tcp_pcb *pcb, struct pbuf *p, err_t err)
  return ERR_OK;
 }

-/*-----------------------------------------------------------------------------------*/
+
 static err_t
 poll_tcp(void *arg, struct tcp_pcb *pcb)
 {
@@ -117,7 +148,7 @@ poll_tcp(void *arg, struct tcp_pcb *pcb)
  }
  return ERR_OK;
 }
-/*-----------------------------------------------------------------------------------*/
+
 static err_t
 sent_tcp(void *arg, struct tcp_pcb *pcb, u16_t len)
 {
@@ -134,7 +165,7 @@ sent_tcp(void *arg, struct tcp_pcb *pcb, u16_t len)
  
  return ERR_OK;
 }
-/*-----------------------------------------------------------------------------------*/
+
 static void
 err_tcp(void *arg, err_t err)
 {
@@ -165,7 +196,7 @@ err_tcp(void *arg, err_t err)
    sys_sem_signal(conn->sem);
  }
 }
-/*-----------------------------------------------------------------------------------*/
+
 static void
 setup_tcp(struct netconn *conn)
 {
@@ -178,7 +209,7 @@ setup_tcp(struct netconn *conn)
  tcp_poll(pcb, poll_tcp, 4);
  tcp_err(pcb, err_tcp);
 }
-/*-----------------------------------------------------------------------------------*/
+
 static err_t
 accept_function(void *arg, struct tcp_pcb *newpcb, err_t err)
 {
@@ -234,17 +265,83 @@ accept_function(void *arg, struct tcp_pcb *newpcb, err_t err)
  return ERR_OK;
 }
 #endif /* LWIP_TCP */
-/*-----------------------------------------------------------------------------------*/
+
 static void
 do_newconn(struct api_msg_msg *msg)
 {
+   if(msg->conn->pcb.tcp != NULL) {
+   /* This "new" connection already has a PCB allocated. */
+   /* Is this an error condition? Should it be deleted? 
+      We currently just are happy and return. */
+     sys_mbox_post(msg->conn->mbox, NULL);
+     return;
+   }
+
+   msg->conn->err = ERR_OK;
+
+   /* Allocate a PCB for this connection */
+   switch(msg->conn->type) {
+#if LWIP_RAW
+   case NETCONN_RAW:
+      msg->conn->pcb.raw = raw_new(msg->msg.bc.port); /* misusing the port field */
+      raw_recv(msg->conn->pcb.raw, recv_raw, msg->conn);
+     break;
+#endif
+#if LWIP_UDP
+   case NETCONN_UDPLITE:
+      msg->conn->pcb.udp = udp_new();
+      if(msg->conn->pcb.udp == NULL) {
+         msg->conn->err = ERR_MEM;
+         break;
+      }
+      udp_setflags(msg->conn->pcb.udp, UDP_FLAGS_UDPLITE);
+      udp_recv(msg->conn->pcb.udp, recv_udp, msg->conn);
+      break;
+   case NETCONN_UDPNOCHKSUM:
+      msg->conn->pcb.udp = udp_new();
+      if(msg->conn->pcb.udp == NULL) {
+         msg->conn->err = ERR_MEM;
+         break;
+      }
+      udp_setflags(msg->conn->pcb.udp, UDP_FLAGS_NOCHKSUM);
+      udp_recv(msg->conn->pcb.udp, recv_udp, msg->conn);
+      break;
+   case NETCONN_UDP:
+      msg->conn->pcb.udp = udp_new();
+      if(msg->conn->pcb.udp == NULL) {
+         msg->conn->err = ERR_MEM;
+         break;
+      }
+      udp_recv(msg->conn->pcb.udp, recv_udp, msg->conn);
+      break;
+#endif /* LWIP_UDP */
+#if LWIP_TCP
+   case NETCONN_TCP:
+      msg->conn->pcb.tcp = tcp_new();
+      if(msg->conn->pcb.tcp == NULL) {
+         msg->conn->err = ERR_MEM;
+         break;
+      }
+      setup_tcp(msg->conn);
+      break;
+#endif
+   }
+   
+  
+  sys_mbox_post(msg->conn->mbox, NULL);
 }
-/*-----------------------------------------------------------------------------------*/
+
+
 static void
 do_delconn(struct api_msg_msg *msg)
 {
  if (msg->conn->pcb.tcp != NULL) {
    switch (msg->conn->type) {
+#if LWIP_RAW
+    case NETCONN_RAW:
+      raw_remove(msg->conn->pcb.raw);
+      break;
+#endif
 #if LWIP_UDP
    case NETCONN_UDPLITE:
      /* FALLTHROUGH */
@@ -287,12 +384,18 @@ do_delconn(struct api_msg_msg *msg)
    sys_mbox_post(msg->conn->mbox, NULL);
  }
 }
-/*-----------------------------------------------------------------------------------*/
+
 static void
 do_bind(struct api_msg_msg *msg)
 {
  if (msg->conn->pcb.tcp == NULL) {
    switch (msg->conn->type) {
+#if LWIP_RAW
+    case NETCONN_RAW:
+      msg->conn->pcb.raw = raw_new(msg->msg.bc.port); /* misusing the port field as protocol */
+      raw_recv(msg->conn->pcb.raw, recv_raw, msg->conn);
+      break;
+#endif
 #if LWIP_UDP
    case NETCONN_UDPLITE:
      msg->conn->pcb.udp = udp_new();
@@ -319,6 +422,11 @@ do_bind(struct api_msg_msg *msg)
    }
  }
  switch (msg->conn->type) {
+#if LWIP_RAW
+  case NETCONN_RAW:
+    msg->conn->err = raw_bind(msg->conn->pcb.raw,msg->msg.bc.ipaddr);
+    break;
+#endif
 #if LWIP_UDP
  case NETCONN_UDPLITE:
    /* FALLTHROUGH */
@@ -339,7 +447,7 @@ do_bind(struct api_msg_msg *msg)
  sys_mbox_post(msg->conn->mbox, NULL);
 }
 #if LWIP_TCP
-/*-----------------------------------------------------------------------------------*/
+
 static err_t
 do_connected(void *arg, struct tcp_pcb *pcb, err_t err)
 {
@@ -359,12 +467,18 @@ do_connected(void *arg, struct tcp_pcb *pcb, err_t err)
  return ERR_OK;
 }
 #endif  
-/*-----------------------------------------------------------------------------------*/
+
 static void
 do_connect(struct api_msg_msg *msg)
 {
  if (msg->conn->pcb.tcp == NULL) {
    switch (msg->conn->type) {
+#if LWIP_RAW
+    case NETCONN_RAW:
+      msg->conn->pcb.raw = raw_new(msg->msg.bc.port); /* misusing the port field as protocol */
+      raw_recv(msg->conn->pcb.raw, recv_raw, msg->conn);
+      break;
+#endif
 #if LWIP_UDP
    case NETCONN_UDPLITE:
      msg->conn->pcb.udp = udp_new();
@@ -410,6 +524,12 @@ do_connect(struct api_msg_msg *msg)
    }
  }
  switch (msg->conn->type) {
+#if LWIP_RAW
+  case NETCONN_RAW:
+    raw_connect(msg->conn->pcb.raw, msg->msg.bc.ipaddr);
+    sys_mbox_post(msg->conn->mbox, NULL);
+    break;
+#endif
 #if LWIP_UDP
  case NETCONN_UDPLITE:
    /* FALLTHROUGH */
@@ -428,6 +548,7 @@ do_connect(struct api_msg_msg *msg)
    do_connected);
    /*tcp_output(msg->conn->pcb.tcp);*/
 #endif
+
  default:
    break;
  }
@@ -438,6 +559,11 @@ do_disconnect(struct api_msg_msg *msg)
 {

  switch (msg->conn->type) {
+#if LWIP_RAW
+  case NETCONN_RAW:
+    /* Do nothing as connecting is only a helper for upper lwip layers */
+    break;
+#endif
 #if LWIP_UDP
  case NETCONN_UDPLITE:
    /* FALLTHROUGH */
@@ -453,12 +579,17 @@ do_disconnect(struct api_msg_msg *msg)
  sys_mbox_post(msg->conn->mbox, NULL);
 }

-/*-----------------------------------------------------------------------------------*/
+
 static void
 do_listen(struct api_msg_msg *msg)
 {
  if (msg->conn->pcb.tcp != NULL) {
    switch (msg->conn->type) {
+#if LWIP_RAW
+    case NETCONN_RAW:
+      LWIP_DEBUGF(API_MSG_DEBUG, ("api_msg: listen RAW: cannot listen for RAW.\n"));
+      break;
+#endif
 #if LWIP_UDP
    case NETCONN_UDPLITE:
      /* FALLTHROUGH */
@@ -491,12 +622,17 @@ do_listen(struct api_msg_msg *msg)
  }
  sys_mbox_post(msg->conn->mbox, NULL);
 }
-/*-----------------------------------------------------------------------------------*/
+
 static void
 do_accept(struct api_msg_msg *msg)
 {
  if (msg->conn->pcb.tcp != NULL) {
    switch (msg->conn->type) {
+#if LWIP_RAW
+    case NETCONN_RAW:
+      LWIP_DEBUGF(API_MSG_DEBUG, ("api_msg: accept RAW: cannot accept for RAW.\n"));
+      break;
+#endif
 #if LWIP_UDP
    case NETCONN_UDPLITE:
      /* FALLTHROUGH */
@@ -511,12 +647,17 @@ do_accept(struct api_msg_msg *msg)
    }
  }
 }
-/*-----------------------------------------------------------------------------------*/
+
 static void
 do_send(struct api_msg_msg *msg)
 {
  if (msg->conn->pcb.tcp != NULL) {
    switch (msg->conn->type) {
+#if LWIP_RAW
+    case NETCONN_RAW:
+      raw_send(msg->conn->pcb.raw, msg->msg.p);
+      break;
+#endif
 #if LWIP_UDP
    case NETCONN_UDPLITE:
      /* FALLTHROUGH */
@@ -532,7 +673,7 @@ do_send(struct api_msg_msg *msg)
  }
  sys_mbox_post(msg->conn->mbox, NULL);
 }
-/*-----------------------------------------------------------------------------------*/
+
 static void
 do_recv(struct api_msg_msg *msg)
 {
@@ -545,7 +686,7 @@ do_recv(struct api_msg_msg *msg)
 #endif  
  sys_mbox_post(msg->conn->mbox, NULL);
 }
-/*-----------------------------------------------------------------------------------*/
+
 static void
 do_write(struct api_msg_msg *msg)
 {
@@ -554,6 +695,11 @@ do_write(struct api_msg_msg *msg)
 #endif  
  if (msg->conn->pcb.tcp != NULL) {
    switch (msg->conn->type) {
+#if LWIP_RAW
+    case NETCONN_RAW:
+      msg->conn->err = ERR_VAL;
+      break;
+#endif
 #if LWIP_UDP 
    case NETCONN_UDPLITE:
      /* FALLTHROUGH */
@@ -571,7 +717,7 @@ do_write(struct api_msg_msg *msg)
   segments when new outgoing data arrives from the user if any
   previously transmitted data on the connection remains
   unacknowledged. */
-      if (err == ERR_OK && msg->conn->pcb.tcp->unacked == NULL) {
+      if(err == ERR_OK && (msg->conn->pcb.tcp->unacked == NULL || (msg->conn->pcb.tcp->flags & TF_NODELAY)) ) {
  tcp_output(msg->conn->pcb.tcp);
      }
      msg->conn->err = err;
@@ -588,7 +734,7 @@ do_write(struct api_msg_msg *msg)
  }
  sys_mbox_post(msg->conn->mbox, NULL);
 }
-/*-----------------------------------------------------------------------------------*/
+
 static void
 do_close(struct api_msg_msg *msg)
 {
@@ -598,6 +744,10 @@ do_close(struct api_msg_msg *msg)

  if (msg->conn->pcb.tcp != NULL) {
    switch (msg->conn->type) {
+#if LWIP_RAW
+    case NETCONN_RAW:
+      break;
+#endif
 #if LWIP_UDP
    case NETCONN_UDPLITE:
      /* FALLTHROUGH */
@@ -619,7 +769,7 @@ do_close(struct api_msg_msg *msg)
  }
  sys_mbox_post(msg->conn->mbox, NULL);
 }
-/*-----------------------------------------------------------------------------------*/
+
 typedef void (* api_msg_decode)(struct api_msg_msg *msg);
 static api_msg_decode decode[API_MSG_MAX] = {
  do_newconn,
@@ -639,12 +789,12 @@ api_msg_input(struct api_msg *msg)
 {  
  decode[msg->type](&(msg->msg));
 }
-/*-----------------------------------------------------------------------------------*/
+
 void
 api_msg_post(struct api_msg *msg)
 {
  tcpip_apimsg(msg);
 }
-/*-----------------------------------------------------------------------------------*/
+


--- a/src/api/err.c
+++ b/src/api/err.c
@@ -47,13 +47,13 @@ static char *err_strerr[] = {"Ok.",
           "Address in use."
 };

-/*-----------------------------------------------------------------------------------*/
+
 char *
 lwip_strerr(err_t err)
 {
  return err_strerr[-err];

 }
-/*-----------------------------------------------------------------------------------*/
+

 #endif /* LWIP_DEBUG */
--- a/src/api/sockets.c
+++ b/src/api/sockets.c
@@ -99,7 +99,7 @@ static int err_to_errno_table[11] = {
      set_errno(sk->err); \
 } while (0)

-/*-----------------------------------------------------------------------------------*/
+
 static struct lwip_socket *
 get_socket(int s)
 {
@@ -121,7 +121,7 @@ get_socket(int s)

  return sock;
 }
-/*-----------------------------------------------------------------------------------*/
+
 static int
 alloc_socket(struct netconn *newconn)
 {
@@ -150,7 +150,7 @@ alloc_socket(struct netconn *newconn)
  sys_sem_signal(socksem);
  return -1;
 }
-/*-----------------------------------------------------------------------------------*/
+
 int
 lwip_accept(int s, struct sockaddr *addr, socklen_t *addrlen)
 {
@@ -164,6 +164,7 @@ lwip_accept(int s, struct sockaddr *addr, socklen_t *addrlen)
  LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_accept(%d)...\n", s));
  sock = get_socket(s);
  if (!sock) {
+    set_errno(EBADF);
    return -1;
  }

@@ -197,16 +198,14 @@ lwip_accept(int s, struct sockaddr *addr, socklen_t *addrlen)
  newconn->socket = newsock;
  sys_sem_signal(socksem);

-#if SOCKETS_DEBUG
  LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_accept(%d) returning new sock=%d addr=", s, newsock));
  ip_addr_debug_print(SOCKETS_DEBUG, &naddr);
  LWIP_DEBUGF(SOCKETS_DEBUG, (" port=%u\n", port));
-#endif

  sock_set_errno(sock, 0);
  return newsock;
 }
-/*-----------------------------------------------------------------------------------*/
+
 int
 lwip_bind(int s, struct sockaddr *name, socklen_t namelen)
 {
@@ -217,17 +216,16 @@ lwip_bind(int s, struct sockaddr *name, socklen_t namelen)

  sock = get_socket(s);
  if (!sock) {
+    set_errno(EBADF);
    return -1;
  }

  local_addr.addr = ((struct sockaddr_in *)name)->sin_addr.s_addr;
  local_port = ((struct sockaddr_in *)name)->sin_port;

-#if SOCKETS_DEBUG
  LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_bind(%d, addr=", s));
  ip_addr_debug_print(SOCKETS_DEBUG, &local_addr);
  LWIP_DEBUGF(SOCKETS_DEBUG, (" port=%u)\n", ntohs(local_port)));
-#endif

  err = netconn_bind(sock->conn, &local_addr, ntohs(local_port));

@@ -241,7 +239,7 @@ lwip_bind(int s, struct sockaddr *name, socklen_t namelen)
  sock_set_errno(sock, 0);
  return 0;
 }
-/*-----------------------------------------------------------------------------------*/
+
 int
 lwip_close(int s)
 {
@@ -257,6 +255,7 @@ lwip_close(int s)
  sock = get_socket(s);
  if (!sock) {
      sys_sem_signal(socksem);
+      set_errno(EBADF);
      return -1;
  }

@@ -271,7 +270,7 @@ lwip_close(int s)
  sock_set_errno(sock, 0);
  return 0;
 }
-/*-----------------------------------------------------------------------------------*/
+
 int
 lwip_connect(int s, struct sockaddr *name, socklen_t namelen)
 {
@@ -280,6 +279,7 @@ lwip_connect(int s, struct sockaddr *name, socklen_t namelen)

  sock = get_socket(s);
  if (!sock) {
+    set_errno(EBADF);
    return -1;
  }

@@ -293,11 +293,9 @@ lwip_connect(int s, struct sockaddr *name, socklen_t namelen)
    remote_addr.addr = ((struct sockaddr_in *)name)->sin_addr.s_addr;
    remote_port = ((struct sockaddr_in *)name)->sin_port;

-#if SOCKETS_DEBUG
    LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_connect(%d, addr=", s));
    ip_addr_debug_print(SOCKETS_DEBUG, &remote_addr);
    LWIP_DEBUGF(SOCKETS_DEBUG, (" port=%u)\n", ntohs(remote_port)));
-#endif

    err = netconn_connect(sock->conn, &remote_addr, ntohs(remote_port));
   }
@@ -312,7 +310,7 @@ lwip_connect(int s, struct sockaddr *name, socklen_t namelen)
  sock_set_errno(sock, 0);
  return 0;
 }
-/*-----------------------------------------------------------------------------------*/
+
 int
 lwip_listen(int s, int backlog)
 {
@@ -322,6 +320,7 @@ lwip_listen(int s, int backlog)
  LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_listen(%d, backlog=%d)\n", s, backlog));
  sock = get_socket(s);
  if (!sock) {
+    set_errno(EBADF);
    return -1;
  }

@@ -336,7 +335,7 @@ lwip_listen(int s, int backlog)
  sock_set_errno(sock, 0);
  return 0;
 }
-/*-----------------------------------------------------------------------------------*/
+
 int
 lwip_recvfrom(int s, void *mem, int len, unsigned int flags,
        struct sockaddr *from, socklen_t *fromlen)
@@ -351,6 +350,7 @@ lwip_recvfrom(int s, void *mem, int len, unsigned int flags,
  LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom(%d, %p, %d, 0x%x, ..)\n", s, mem, len, flags));
  sock = get_socket(s);
  if (!sock) {
+    set_errno(EBADF);
    return -1;
  }

@@ -411,11 +411,9 @@ lwip_recvfrom(int s, void *mem, int len, unsigned int flags,

    memcpy(from, &sin, *fromlen);

-#if SOCKETS_DEBUG
    LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom(%d): addr=", s));
    ip_addr_debug_print(SOCKETS_DEBUG, addr);
    LWIP_DEBUGF(SOCKETS_DEBUG, (" port=%u len=%u\n", port, copylen));
-#endif
  } else {
 #if SOCKETS_DEBUG > 0
    addr = netbuf_fromaddr(buf);
@@ -444,19 +442,19 @@ 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_recvfrom(s, mem, len, 0, NULL, NULL);
 }
-/*-----------------------------------------------------------------------------------*/
+
 int
 lwip_recv(int s, void *mem, int len, unsigned int flags)
 {
  return lwip_recvfrom(s, mem, len, flags, NULL, NULL);
 }
-/*-----------------------------------------------------------------------------------*/
+
 int
 lwip_send(int s, void *data, int size, unsigned int flags)
 {
@@ -468,11 +466,15 @@ lwip_send(int s, void *data, int size, unsigned int flags)

  sock = get_socket(s);
  if (!sock) {
+    set_errno(EBADF);
    return -1;
  }

  switch (netconn_type(sock->conn)) {
+  case NETCONN_RAW:
  case NETCONN_UDP:
+  case NETCONN_UDPLITE:
+  case NETCONN_UDPNOCHKSUM:
    /* create a buffer */
    buf = netbuf_new();

@@ -509,7 +511,7 @@ lwip_send(int s, void *data, int size, unsigned int flags)
  sock_set_errno(sock, 0);
  return size;
 }
-/*-----------------------------------------------------------------------------------*/
+
 int
 lwip_sendto(int s, void *data, int size, unsigned int flags,
       struct sockaddr *to, socklen_t tolen)
@@ -521,6 +523,7 @@ lwip_sendto(int s, void *data, int size, unsigned int flags,

  sock = get_socket(s);
  if (!sock) {
+    set_errno(EBADF);
    return -1;
  }

@@ -530,11 +533,9 @@ 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
  LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_sendto(%d, data=%p, size=%d, flags=0x%x to=", s, data, size, flags));
  ip_addr_debug_print(SOCKETS_DEBUG, &remote_addr);
  LWIP_DEBUGF(SOCKETS_DEBUG, (" port=%u\n", ntohs(remote_port)));
-#endif

  netconn_connect(sock->conn, &remote_addr, ntohs(remote_port));

@@ -548,7 +549,7 @@ lwip_sendto(int s, void *data, int size, unsigned int flags,
  netconn_disconnect(sock->conn);
  return ret;
 }
-/*-----------------------------------------------------------------------------------*/
+
 int
 lwip_socket(int domain, int type, int protocol)
 {
@@ -557,6 +558,10 @@ lwip_socket(int domain, int type, int protocol)

  /* create a netconn */
  switch (type) {
+  case SOCK_RAW:
+    conn = netconn_new_with_proto_and_callback(NETCONN_RAW, protocol, event_callback);
+    LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_socket(%s, SOCK_RAW, %d) = ", domain == PF_INET ? "PF_INET" : "UNKNOWN", protocol));
+    break;
  case SOCK_DGRAM:
    conn = netconn_new_with_callback(NETCONN_UDP, event_callback);
    LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_socket(%s, SOCK_DGRAM, %d) = ", domain == PF_INET ? "PF_INET" : "UNKNOWN", protocol));
@@ -589,14 +594,14 @@ lwip_socket(int domain, int type, int protocol)
  set_errno(0);
  return i;
 }
-/*-----------------------------------------------------------------------------------*/
+
 int
 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)
 {
@@ -643,7 +648,7 @@ lwip_selscan(int maxfdp1, fd_set *readset, fd_set *writeset, fd_set *exceptset)
 }


-/*-----------------------------------------------------------------------------------*/
+
 int
 lwip_select(int maxfdp1, fd_set *readset, fd_set *writeset, fd_set *exceptset,
               struct timeval *timeout)
@@ -723,7 +728,7 @@ lwip_select(int maxfdp1, fd_set *readset, fd_set *writeset, fd_set *exceptset,
            /* Wait forever */
            msectimeout = 0;
        else
-            msectimeout =  ((timeout->tv_sec * 1000) + (timeout->tv_usec /1000));
+            msectimeout =  ((timeout->tv_sec * 1000) + ((timeout->tv_usec + 500)/1000));

        i = sys_sem_wait_timeout(select_cb.sem, msectimeout);

@@ -789,7 +794,7 @@ lwip_select(int maxfdp1, fd_set *readset, fd_set *writeset, fd_set *exceptset,
    return nready;
 }

-/*-----------------------------------------------------------------------------------*/
+
 static void
 event_callback(struct netconn *conn, enum netconn_evt evt, u16_t len)
 {
@@ -878,7 +883,7 @@ event_callback(struct netconn *conn, enum netconn_evt evt, u16_t len)

 }

-/*-----------------------------------------------------------------------------------*/
+


 int lwip_shutdown(int s, int how)
@@ -895,6 +900,7 @@ int lwip_getpeername (int s, struct sockaddr *name, socklen_t *namelen)

  sock = get_socket(s);
  if (!sock) {
+    set_errno(EBADF);
    return -1;
  }

@@ -905,11 +911,9 @@ int lwip_getpeername (int s, struct sockaddr *name, socklen_t *namelen)
  /* get the IP address and port of the remote host */
  netconn_peer(sock->conn, &naddr, &sin.sin_port);

-#if SOCKETS_DEBUG
  LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getpeername(%d, addr=", s));
  ip_addr_debug_print(SOCKETS_DEBUG, &naddr);
  LWIP_DEBUGF(SOCKETS_DEBUG, (" port=%d)\n", sin.sin_port));
-#endif

  sin.sin_port = htons(sin.sin_port);
  sin.sin_addr.s_addr = naddr.addr;
@@ -930,6 +934,7 @@ int lwip_getsockname (int s, struct sockaddr *name, socklen_t *namelen)

  sock = get_socket(s);
  if (!sock) {
+    set_errno(EBADF);
    return -1;
  }

@@ -940,11 +945,9 @@ int lwip_getsockname (int s, struct sockaddr *name, socklen_t *namelen)
  /* get the IP address and port of the remote host */
  netconn_addr(sock->conn, &naddr, &sin.sin_port);

-#if SOCKETS_DEBUG
  LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockname(%d, addr=", s));
  ip_addr_debug_print(SOCKETS_DEBUG, naddr);
  LWIP_DEBUGF(SOCKETS_DEBUG, (" port=%d)\n", sin.sin_port));
-#endif

  sin.sin_port = htons(sin.sin_port);
  sin.sin_addr.s_addr = naddr->addr;
@@ -959,32 +962,190 @@ int lwip_getsockname (int s, struct sockaddr *name, socklen_t *namelen)

 int lwip_getsockopt (int s, int level, int optname, void *optval, socklen_t *optlen)
 {
-  int err = ENOSYS;
+  int err = 0;
  struct lwip_socket *sock = get_socket(s);

-  if (!sock) {
+  if(!sock) {
+   	set_errno(EBADF);
    return -1;
  }

-  if (level == SOL_SOCKET) {
-    switch (optname) {
+  if( NULL == optval || NULL == optlen ) {
+    sock_set_errno( sock, EFAULT );
+    return -1;
+  }
+
+  /* Do length and type checks for the various options first, to keep it readable. */
+  switch( level ) {
+   
+/* Level: SOL_SOCKET */
+  case SOL_SOCKET:
+      switch(optname) {
+         
+      case SO_ACCEPTCONN:
+      case SO_BROADCAST:
+      /* UNIMPL case SO_DEBUG: */
+      /* UNIMPL case SO_DONTROUTE: */
      case SO_ERROR:
-        if (!optval || !optlen || (*optlen != sizeof(int))) {
+      case SO_KEEPALIVE:
+      /* UNIMPL case SO_OOBINLINE: */
+      /* UNIMPL case SO_RCVBUF: */
+      /* UNIMPL case SO_SNDBUF: */
+      /* UNIMPL case SO_RCVLOWAT: */
+      /* UNIMPL case SO_SNDLOWAT: */
+#ifdef SO_REUSE
+      case SO_REUSEADDR:
+      case SO_REUSEPORT:
+#endif /* SO_REUSE */
+      case SO_TYPE:
+      /* UNIMPL case SO_USELOOPBACK: */
+        if( *optlen < sizeof(int) ) {
          err = EINVAL;
-          break;
        }
-        *(int *)optval = sock->err;
-        sock->err = 0;
-        LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, SOL_SOCKET, SO_ERROR) = %d\n", s, *(int *)optval));
-        err = 0;
-        break;
+          break;
+
      default:
        LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, SOL_SOCKET, UNIMPL: optname=0x%x, ..)\n", s, optname));
+        err = ENOPROTOOPT;
+      }  /* switch */
+      break;
+                     
+/* Level: IPPROTO_IP */
+  case IPPROTO_IP:
+      switch(optname) {
+      /* UNIMPL case IP_HDRINCL: */
+      /* UNIMPL case IP_RCVDSTADDR: */
+      /* UNIMPL case IP_RCVIF: */
+      case IP_TTL:
+      case IP_TOS:
+        if( *optlen < sizeof(int) ) {
+          err = EINVAL;
+        }
+        break;
+
+      default:
+        LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_IP, UNIMPL: optname=0x%x, ..)\n", s, optname));
+        err = ENOPROTOOPT;
+      }  /* switch */
+      break;
+         
+/* Level: IPPROTO_TCP */
+  case IPPROTO_TCP:
+      if( *optlen < sizeof(int) ) {
+        err = EINVAL;
        break;
    }
-  } else {
-    LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, level=0x%x, UNIMPL: optname=0x%x, ..)\n", s, level, optname));
+      
+      /* If this is no TCP socket, ignore any options. */
+      if ( sock->conn->type != NETCONN_TCP ) return 0;
+
+      switch( optname ) {
+      case TCP_NODELAY:
+      case TCP_KEEPALIVE:
+        break;
+         
+      default:
+        LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_TCP, UNIMPL: optname=0x%x, ..)\n", s, optname));
+        err = ENOPROTOOPT;
+      }  /* switch */
+      break;
+
+/* UNDEFINED LEVEL */
+  default:
+      LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, level=0x%x, UNIMPL: optname=0x%x, ..)\n", s, level, optname));
+      err = ENOPROTOOPT;
+  }  /* switch */
+
+   
+  if( 0 != err ) {
+    sock_set_errno(sock, err);
+    return -1;
  }
+   
+
+
+  /* Now do the actual option processing */
+
+  switch(level) {
+   
+/* Level: SOL_SOCKET */
+  case SOL_SOCKET:
+    switch( optname ) {
+
+    /* The option flags */
+    case SO_ACCEPTCONN:
+    case SO_BROADCAST:
+    /* UNIMPL case SO_DEBUG: */
+    /* UNIMPL case SO_DONTROUTE: */
+    case SO_KEEPALIVE:
+    /* UNIMPL case SO_OOBINCLUDE: */
+#ifdef SO_REUSE
+    case SO_REUSEADDR:
+    case SO_REUSEPORT:
+#endif /* SO_REUSE */
+    /*case SO_USELOOPBACK: UNIMPL */
+      *(int*)optval = sock->conn->pcb.tcp->so_options & optname;
+      LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, SOL_SOCKET, optname=0x%x, ..) = %s\n", s, optname, (*(int*)optval?"on":"off")));
+      break;
+
+    case SO_TYPE:
+      switch (sock->conn->type) {
+      case NETCONN_RAW:
+        *(int*)optval = SOCK_RAW;
+        break;
+      case NETCONN_TCP:
+        *(int*)optval = SOCK_STREAM;
+        break;
+      case NETCONN_UDP:
+      case NETCONN_UDPLITE:
+      case NETCONN_UDPNOCHKSUM:
+        *(int*)optval = SOCK_DGRAM;
+        break;
+      default: /* unrecognized socket type */
+        *(int*)optval = sock->conn->type;
+        LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, SOL_SOCKET, SO_TYPE): unrecognized socket type %d\n", s, *(int *)optval));
+      }  /* switch */
+      LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, SOL_SOCKET, SO_TYPE) = %d\n", s, *(int *)optval));
+      break;
+
+    case SO_ERROR:
+      *(int *)optval = sock->err;
+      sock->err = 0;
+      LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, SOL_SOCKET, SO_ERROR) = %d\n", s, *(int *)optval));
+      break;
+    }  /* switch */
+    break;
+
+/* Level: IPPROTO_IP */
+  case IPPROTO_IP:
+    switch( optname ) {
+    case IP_TTL:
+      *(int*)optval = sock->conn->pcb.tcp->ttl;
+      LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_IP, IP_TTL) = %d\n", s, *(int *)optval));
+      break;
+    case IP_TOS:
+      *(int*)optval = sock->conn->pcb.tcp->tos;
+      LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_IP, IP_TOS) = %d\n", s, *(int *)optval));
+      break;
+    }  /* switch */
+    break;
+
+/* Level: IPPROTO_TCP */
+  case IPPROTO_TCP:
+    switch( optname ) {
+    case TCP_NODELAY:
+      *(int*)optval = (sock->conn->pcb.tcp->flags & TF_NODELAY);
+      LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_TCP, TCP_NODELAY) = %s\n", s, (*(int*)optval)?"on":"off") );
+      break;
+    case TCP_KEEPALIVE:
+      *(int*)optval = sock->conn->pcb.tcp->keepalive;
+      LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_IP, TCP_KEEPALIVE) = %d\n", s, *(int *)optval));
+      break;
+    }  /* switch */
+    break;
+  }
+
+
  sock_set_errno(sock, err);
  return err ? -1 : 0;
 }
@@ -992,27 +1153,165 @@ int lwip_getsockopt (int s, int level, int optname, void *optval, socklen_t *opt
 int lwip_setsockopt (int s, int level, int optname, const void *optval, socklen_t optlen)
 {
  struct lwip_socket *sock = get_socket(s);
-  int err = ENOSYS;
+  int err = 0;

-  if (!sock) {
+  if(!sock) {
+   	set_errno(EBADF);
    return -1;
  }

-  if (level == SOL_SOCKET) {
-    switch (optname) {
-      case SO_REUSEADDR:
-        LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, SOL_SOCKET, SO_REUSEADDR, ..)\n", s));
-           /* XXX just pretend we support this for now */
-          err = 0;
+  if( NULL == optval ) {
+    sock_set_errno( sock, EFAULT );
+    return -1;
+  }
+
+
+  /* Do length and type checks for the various options first, to keep it readable. */
+  switch( level ) {
+
+/* Level: SOL_SOCKET */
+  case SOL_SOCKET:
+    switch(optname) {
+
+    case SO_BROADCAST:
+    /* UNIMPL case SO_DEBUG: */
+    /* UNIMPL case SO_DONTROUTE: */
+    case SO_KEEPALIVE:
+    /* UNIMPL case SO_OOBINLINE: */
+    /* UNIMPL case SO_RCVBUF: */
+    /* UNIMPL case SO_SNDBUF: */
+    /* UNIMPL case SO_RCVLOWAT: */
+    /* UNIMPL case SO_SNDLOWAT: */
+#ifdef SO_REUSE
+    case SO_REUSEADDR:
+    case SO_REUSEPORT:
+#endif /* SO_REUSE */
+    /* UNIMPL case SO_USELOOPBACK: */
+      if( optlen < sizeof(int) ) {
+        err = EINVAL;
+      }
+      break;
+    default:
+      LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, SOL_SOCKET, UNIMPL: optname=0x%x, ..)\n", s, optname));
+      err = ENOPROTOOPT;
+    }  /* switch */
+    break;
+
+/* Level: IPPROTO_IP */
+  case IPPROTO_IP:
+    switch(optname) {
+    /* UNIMPL case IP_HDRINCL: */
+    /* UNIMPL case IP_RCVDSTADDR: */
+    /* UNIMPL case IP_RCVIF: */
+    case IP_TTL:
+    case IP_TOS:
+      if( optlen < sizeof(int) ) {
+        err = EINVAL;
+      }
        break;
      default:
-        LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, SOL_SOCKET, UNIMPL: optname=0x%x, ..)\n", s, optname));
+      LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_IP, UNIMPL: optname=0x%x, ..)\n", s, optname));
+      err = ENOPROTOOPT;
+    }  /* switch */
+    break;
+
+/* Level: IPPROTO_TCP */
+  case IPPROTO_TCP:
+    if( optlen < sizeof(int) ) {
+      err = EINVAL;
        break;
    }
-  } else {
+
+    /* If this is no TCP socket, ignore any options. */
+    if ( sock->conn->type != NETCONN_TCP ) return 0;
+
+    switch( optname ) {
+    case TCP_NODELAY:
+    case TCP_KEEPALIVE:
+      break;
+
+    default:
+      LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_TCP, UNIMPL: optname=0x%x, ..)\n", s, optname));
+      err = ENOPROTOOPT;
+    }  /* switch */
+    break;
+
+/* UNDEFINED LEVEL */      
+  default:
    LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, level=0x%x, UNIMPL: optname=0x%x, ..)\n", s, level, optname));
+    err = ENOPROTOOPT;
+  }  /* switch */
+
+
+  if( 0 != err ) {
+    sock_set_errno(sock, err);
+    return -1;
  }

+
+
+  /* Now do the actual option processing */
+
+  switch(level) {
+
+/* Level: SOL_SOCKET */
+  case SOL_SOCKET:
+    switch(optname) {
+
+    /* The option flags */
+    case SO_BROADCAST:
+    /* UNIMPL case SO_DEBUG: */
+    /* UNIMPL case SO_DONTROUTE: */
+    case SO_KEEPALIVE:
+    /* UNIMPL case SO_OOBINCLUDE: */
+#ifdef SO_REUSE
+    case SO_REUSEADDR:
+    case SO_REUSEPORT:
+#endif /* SO_REUSE */
+    /* UNIMPL case SO_USELOOPBACK: */
+      if ( *(int*)optval ) {
+        sock->conn->pcb.tcp->so_options |= optname;
+      } else {
+        sock->conn->pcb.tcp->so_options &= ~optname;
+      }
+      LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, SOL_SOCKET, optname=0x%x, ..) -> %s\n", s, optname, (*(int*)optval?"on":"off")));
+      break;
+    }  /* switch */
+    break;
+
+/* Level: IPPROTO_IP */
+  case IPPROTO_IP:
+    switch( optname ) {
+    case IP_TTL:
+      sock->conn->pcb.tcp->ttl = (u8_t)(*(int*)optval);
+      LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_IP, IP_TTL, ..) -> %u\n", s, sock->conn->pcb.tcp->ttl));
+      break;
+    case IP_TOS:
+      sock->conn->pcb.tcp->tos = (u8_t)(*(int*)optval);
+      LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_IP, IP_TOS, ..)-> %u\n", s, sock->conn->pcb.tcp->tos));
+      break;
+    }  /* switch */
+    break;
+
+/* Level: IPPROTO_TCP */
+  case IPPROTO_TCP:
+    switch( optname ) {
+    case TCP_NODELAY:
+      if ( *(int*)optval ) {
+        sock->conn->pcb.tcp->flags |= TF_NODELAY;
+      } else {
+        sock->conn->pcb.tcp->flags &= ~TF_NODELAY;
+      }
+      LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_TCP, TCP_NODELAY) -> %s\n", s, (*(int *)optval)?"on":"off") );
+      break;
+    case TCP_KEEPALIVE:
+      sock->conn->pcb.tcp->keepalive = (u32_t)(*(int*)optval);
+      LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_TCP, TCP_KEEPALIVE) -> %u\n", s, sock->conn->pcb.tcp->keepalive));
+      break;
+    }  /* switch */
+    break;
+  }  /* switch */
+
  sock_set_errno(sock, err);
  return err ? -1 : 0;
 }
@@ -1021,7 +1320,8 @@ int lwip_ioctl(int s, long cmd, void *argp)
 {
  struct lwip_socket *sock = get_socket(s);

-  if (!sock) {
+  if(!sock) {
+   	set_errno(EBADF);
    return -1;
  }

@@ -1035,7 +1335,7 @@ int lwip_ioctl(int s, long cmd, void *argp)
    *((u16_t*)argp) = sock->conn->recv_avail;

    LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_ioctl(%d, FIONREAD, %p) = %u\n", s, argp, *((u16_t*)argp)));
-      sock_set_errno(sock, 0);
+    sock_set_errno(sock, 0);
    return 0;

  case FIONBIO:
@@ -1044,7 +1344,7 @@ int lwip_ioctl(int s, long cmd, void *argp)
    else
      sock->flags &= ~O_NONBLOCK;
    LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_ioctl(%d, FIONBIO, %d)\n", s, !!(sock->flags & O_NONBLOCK)));
-      sock_set_errno(sock, 0);
+    sock_set_errno(sock, 0);
    return 0;

  default:
--- a/src/api/tcpip.c
+++ b/src/api/tcpip.c
@@ -50,7 +50,7 @@ static sys_mbox_t mbox;
 static int tcpip_tcp_timer_active = 0;


-/*-----------------------------------------------------------------------------------*/
+
 static void
 tcpip_tcp_timer(void *arg)
 {
@@ -73,7 +73,7 @@ tcp_timer_needed(void)
  }
 }
 #endif /* LWIP_TCP */
-/*-----------------------------------------------------------------------------------*/
+
 static void
 tcpip_thread(void *arg)
 {
@@ -113,7 +113,7 @@ tcpip_thread(void *arg)
    memp_free(MEMP_TCPIP_MSG, msg);
  }
 }
-/*-----------------------------------------------------------------------------------*/
+
 err_t
 tcpip_input(struct pbuf *p, struct netif *inp)
 {
@@ -131,7 +131,7 @@ tcpip_input(struct pbuf *p, struct netif *inp)
  sys_mbox_post(mbox, msg);
  return ERR_OK;
 }
-/*-----------------------------------------------------------------------------------*/
+
 err_t
 tcpip_callback(void (*f)(void *ctx), void *ctx)
 {
@@ -148,7 +148,7 @@ tcpip_callback(void (*f)(void *ctx), void *ctx)
  sys_mbox_post(mbox, msg);
  return ERR_OK;
 }
-/*-----------------------------------------------------------------------------------*/
+
 void
 tcpip_apimsg(struct api_msg *apimsg)
 {
@@ -162,7 +162,7 @@ tcpip_apimsg(struct api_msg *apimsg)
  msg->msg.apimsg = apimsg;
  sys_mbox_post(mbox, msg);
 }
-/*-----------------------------------------------------------------------------------*/
+
 void
 tcpip_init(void (* initfunc)(void *), void *arg)
 {
@@ -171,7 +171,7 @@ tcpip_init(void (* initfunc)(void *), void *arg)
  mbox = sys_mbox_new();
  sys_thread_new(tcpip_thread, NULL, TCPIP_THREAD_PRIO);
 }
-/*-----------------------------------------------------------------------------------*/
+