rawapi.txt, api.h, api_lib.c, api_msg.h, api_msg.c, sockets.c, tcp.h, tcp.c, tcp_in.c, init.c, opt.h: rename backlog options with TCP_ prefix, limit the "backlog" parameter in an u8_t, 0 is interpreted as "smallest queue", add documentation in the rawapi.txt file.

src/api/api_lib.c

@@ -261,7 +261,7 @@ netconn_disconnect(struct netconn *conn)
  * Set a TCP netconn into listen mode
  *
  * @param conn the tcp netconn to set to listen mode
- * @param backlog the listen backlog (0 = max), only used if LWIP_LISTEN_BACKLOG==1
+ * @param backlog the listen backlog, only used if TCP_LISTEN_BACKLOG==1
  * @return ERR_OK if the netconn was set to listen (UDP and RAW netconns
  *         don't return any error (yet?))
  */
@@ -270,16 +270,16 @@ netconn_listen_with_backlog(struct netconn *conn, u8_t backlog)
 {
   struct api_msg msg;
 
-  /* This does no harm. If LWIP_LISTEN_BACKLOG is off, backlog is unused. */
+  /* This does no harm. If TCP_LISTEN_BACKLOG is off, backlog is unused. */
   LWIP_UNUSED_ARG(backlog);
 
   LWIP_ERROR("netconn_listen: invalid conn", (conn != NULL), return ERR_ARG;);
 
-#if LWIP_LISTEN_BACKLOG
-  msg.msg.msg.lb.backlog = backlog;
-#endif /* LWIP_LISTEN_BACKLOG */
   msg.function = do_listen;
   msg.msg.conn = conn;
+#if TCP_LISTEN_BACKLOG
+  msg.msg.msg.lb.backlog = backlog;
+#endif /* TCP_LISTEN_BACKLOG */
   TCPIP_APIMSG(&msg);
   return conn->err;
 }
@@ -309,7 +309,7 @@ netconn_accept(struct netconn *conn)
     /* Register event with callback */
     API_EVENT(conn, NETCONN_EVT_RCVMINUS, 0);
 
-#if LWIP_LISTEN_BACKLOG
+#if TCP_LISTEN_BACKLOG
     if (newconn != NULL) {
       /* Let the stack know that we have accepted the connection. */
       struct api_msg msg;
@@ -317,7 +317,7 @@ netconn_accept(struct netconn *conn)
       msg.msg.conn = conn;
       TCPIP_APIMSG(&msg);
     }
-#endif /* LWIP_LISTEN_BACKLOG */
+#endif /* TCP_LISTEN_BACKLOG */
   }
 
   return newconn;

src/api/api_msg.c

@@ -717,13 +717,17 @@ do_listen(struct api_msg_msg *msg)
     if (msg->conn->pcb.tcp != NULL) {
       if (msg->conn->type == NETCONN_TCP) {
         if (msg->conn->pcb.tcp->state == CLOSED) {
+#if TCP_LISTEN_BACKLOG
+          struct tcp_pcb* lpcb = tcp_listen_with_backlog(msg->conn->pcb.tcp, msg->msg.lb.backlog);
+#else  /* TCP_LISTEN_BACKLOG */
           struct tcp_pcb* lpcb = tcp_listen(msg->conn->pcb.tcp);
+#endif /* TCP_LISTEN_BACKLOG */
           if (lpcb == NULL) {
             msg->conn->err = ERR_MEM;
           } else {
             /* delete the recvmbox and allocate the acceptmbox */
             if (msg->conn->recvmbox != SYS_MBOX_NULL) {
-              /* @todo: should we drain the recvmbox here? */
+              /** @todo: should we drain the recvmbox here? */
               sys_mbox_free(msg->conn->recvmbox);
               msg->conn->recvmbox = NULL;
             }
@@ -735,9 +739,6 @@ do_listen(struct api_msg_msg *msg)
             if (msg->conn->err == ERR_OK) {
               msg->conn->state = NETCONN_LISTEN;
               msg->conn->pcb.tcp = lpcb;
-#if LWIP_LISTEN_BACKLOG
-              tcp_backlog(lpcb, msg->msg.lb.backlog);
-#endif /* LWIP_LISTEN_BACKLOG */
               tcp_arg(msg->conn->pcb.tcp, msg->conn);
               tcp_accept(msg->conn->pcb.tcp, accept_function);
             }
@@ -803,11 +804,11 @@ do_recv(struct api_msg_msg *msg)
   if (!ERR_IS_FATAL(msg->conn->err)) {
     if (msg->conn->pcb.tcp != NULL) {
       if (msg->conn->type == NETCONN_TCP) {
-#if LWIP_LISTEN_BACKLOG
+#if TCP_LISTEN_BACKLOG
         if (msg->conn->pcb.tcp->state == LISTEN) {
           tcp_accepted(msg->conn->pcb.tcp);
         } else
-#endif /* LWIP_LISTEN_BACKLOG */
+#endif /* TCP_LISTEN_BACKLOG */
         {
           tcp_recved(msg->conn->pcb.tcp, msg->msg.r.len);
         }

src/api/sockets.c

@@ -421,7 +421,7 @@ lwip_connect(int s, const struct sockaddr *name, socklen_t namelen)
  * The socket may not have been used for another connection previously.
  *
  * @param s the socket to set to listening mode
- * @param backlog (ATTENTION: this is not implemented, yet!)
+ * @param backlog (ATTENTION: need TCP_LISTEN_BACKLOG=1)
  * @return 0 on success, non-zero on failure
  */
 int
@@ -431,13 +431,19 @@ lwip_listen(int s, int backlog)
   err_t err;
 
   LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_listen(%d, backlog=%d)\n", s, backlog));
-  LWIP_ASSERT("backlog must be between 0 and 255", backlog > 0);
-  LWIP_ASSERT("backlog must be between 0 and 255", backlog <= 0xff);
 
   sock = get_socket(s);
   if (!sock)
     return -1;
 
+  /* limit the "backlog" parameter to fit in an u8_t */
+  if (backlog < 0) {
+    backlog = 0;
+  }
+  if (backlog > 0xff) {
+    backlog = 0xff;
+  }
+
   err = netconn_listen_with_backlog(sock->conn, backlog);
 
   if (err != ERR_OK) {

src/core/init.c

@@ -103,6 +103,9 @@
 #if (LWIP_TCP && ((TCP_MAXRTX > 12) || (TCP_SYNMAXRTX > 12)))
   #error "If you want to use TCP, TCP_MAXRTX and TCP_SYNMAXRTX must less or equal to 12 (due to tcp_backoff table), so, you have to reduce them in your lwipopts.h"
 #endif
+#if (LWIP_TCP && TCP_LISTEN_BACKLOG && (TCP_DEFAULT_LISTEN_BACKLOG < 0) || (TCP_DEFAULT_LISTEN_BACKLOG > 255))
+  #error "If you want to use TCP backlog, TCP_DEFAULT_LISTEN_BACKLOG must fit into an u8_t"
+#endif
 #if (LWIP_IGMP && (MEMP_NUM_IGMP_GROUP<=1))
   #error "If you want to use IGMP, you have to define MEMP_NUM_IGMP_GROUP>1 in your lwipopts.h"
 #endif
@@ -152,9 +155,6 @@
 #if (MEM_USE_POOLS && !MEMP_USE_CUSTOM_POOLS)
   #error "MEM_USE_POOLS requires custom pools (MEMP_USE_CUSTOM_POOLS) to be enabled in your lwipopts.h"
 #endif
-#if (LWIP_DEFAULT_LISTEN_BACKLOG < 0) || (LWIP_DEFAULT_LISTEN_BACKLOG > 255)
-  #error "LWIP_DEFAULT_LISTEN_BACKLOG must fit into an u8_t"
-#endif
 
 
 /* Compile-time checks for deprecated options.

src/core/tcp.c

@@ -343,7 +343,7 @@ tcp_accept_null(void *arg, struct tcp_pcb *pcb, err_t err)
  *             tpcb = tcp_listen(tpcb);
  */
 struct tcp_pcb *
-tcp_listen(struct tcp_pcb *pcb)
+tcp_listen_with_backlog(struct tcp_pcb *pcb, u8_t backlog)
 {
   struct tcp_pcb_listen *lpcb;
 
@@ -370,10 +370,10 @@ tcp_listen(struct tcp_pcb *pcb)
 #if LWIP_CALLBACK_API
   lpcb->accept = tcp_accept_null;
 #endif /* LWIP_CALLBACK_API */
-#if LWIP_LISTEN_BACKLOG
+#if TCP_LISTEN_BACKLOG
   lpcb->accepts_pending = 0;
-  lpcb->backlog = LWIP_DEFAULT_LISTEN_BACKLOG;
-#endif /* LWIP_LISTEN_BACKLOG */
+  lpcb->backlog = (backlog ? backlog : 1);
+#endif /* TCP_LISTEN_BACKLOG */
   TCP_REG(&tcp_listen_pcbs.listen_pcbs, lpcb);
   return (struct tcp_pcb *)lpcb;
 }

src/core/tcp_in.c

@@ -381,11 +381,11 @@ tcp_listen_input(struct tcp_pcb_listen *pcb)
       tcphdr->dest, tcphdr->src);
   } else if (flags & TCP_SYN) {
     LWIP_DEBUGF(TCP_DEBUG, ("TCP connection request %"U16_F" -> %"U16_F".\n", tcphdr->src, tcphdr->dest));
-#if LWIP_LISTEN_BACKLOG
+#if TCP_LISTEN_BACKLOG
     if (pcb->accepts_pending >= pcb->backlog) {
       return ERR_ABRT;
     }
-#endif /* LWIP_LISTEN_BACKLOG */
+#endif /* TCP_LISTEN_BACKLOG */
     npcb = tcp_alloc(pcb->prio);
     /* If a new PCB could not be created (probably due to lack of memory),
        we don't do anything, but rely on the sender will retransmit the
@@ -395,9 +395,9 @@ tcp_listen_input(struct tcp_pcb_listen *pcb)
       TCP_STATS_INC(tcp.memerr);
       return ERR_MEM;
     }
-#if LWIP_LISTEN_BACKLOG
+#if TCP_LISTEN_BACKLOG
     pcb->accepts_pending++;
-#endif /* LWIP_LISTEN_BACKLOG */
+#endif /* TCP_LISTEN_BACKLOG */
     /* Set up the new PCB. */
     ip_addr_set(&(npcb->local_ip), &(iphdr->dest));
     npcb->local_port = pcb->local_port;

src/include/lwip/api.h

@@ -180,7 +180,7 @@ err_t             netconn_connect (struct netconn *conn,
                                    u16_t port);
 err_t             netconn_disconnect (struct netconn *conn);
 err_t             netconn_listen_with_backlog(struct netconn *conn, u8_t backlog);
-#define netconn_listen(conn) netconn_listen_with_backlog(conn, LWIP_DEFAULT_LISTEN_BACKLOG);
+#define netconn_listen(conn) netconn_listen_with_backlog(conn, TCP_DEFAULT_LISTEN_BACKLOG)
 struct netconn *  netconn_accept  (struct netconn *conn);
 struct netbuf *   netconn_recv    (struct netconn *conn);
 err_t             netconn_sendto  (struct netconn *conn,

src/include/lwip/api_msg.h

@@ -93,11 +93,11 @@ struct api_msg_msg {
       enum netconn_igmp join_or_leave;
     } jl;
 #endif /* LWIP_IGMP */
-#if LWIP_LISTEN_BACKLOG
+#if TCP_LISTEN_BACKLOG
     struct {
       u8_t backlog;
     } lb;
-#endif /* LWIP_LISTEN_BACKLOG */
+#endif /* TCP_LISTEN_BACKLOG */
   } msg;
 };
 

src/include/lwip/opt.h

@@ -713,6 +713,22 @@
 #define TCP_SNDLOWAT                    (TCP_SND_BUF/2)
 #endif
 
+/**
+ * TCP_LISTEN_BACKLOG: Enable the backlog option for tcp listen pcb.
+ */
+#ifndef TCP_LISTEN_BACKLOG
+#define TCP_LISTEN_BACKLOG              0
+#endif
+
+/**
+ * The maximum allowed backlog for TCP listen netconns.
+ * This backlog is used unless another is explicitly specified.
+ * 0xff is the maximum (u8_t).
+ */
+#ifndef TCP_DEFAULT_LISTEN_BACKLOG
+#define TCP_DEFAULT_LISTEN_BACKLOG      0xff
+#endif
+
 /**
  * LWIP_EVENT_API and LWIP_CALLBACK_API: Only one of these should be set to 1.
  *     LWIP_EVENT_API==1: The user defines lwip_tcp_event() to receive all
@@ -728,22 +744,6 @@
 #define LWIP_CALLBACK_API               0
 #endif
 
-/**
- * LWIP_LISTEN_BACKLOG: Enable the backlog option for tcp listen pcb.
- */
-#ifndef LWIP_LISTEN_BACKLOG
-#define LWIP_LISTEN_BACKLOG             1
-#endif
-
-/**
- * The maximum allowed backlog for TCP listen netconns.
- * This backlog is used unless another is explicitly specified.
- * 0xff is the maximum (u8_t).
- */
-#ifndef LWIP_DEFAULT_LISTEN_BACKLOG
-#define LWIP_DEFAULT_LISTEN_BACKLOG     0xff
-#endif
-
 
 /*
    ----------------------------------

src/include/lwip/tcp.h

@@ -79,10 +79,11 @@ void             tcp_err     (struct tcp_pcb *pcb,
 #define          tcp_mss(pcb)      ((pcb)->mss)
 #define          tcp_sndbuf(pcb)   ((pcb)->snd_buf)
 
-#if LWIP_LISTEN_BACKLOG
-#define          tcp_accepted(pcb)       (((struct tcp_pcb_listen *)(pcb))->accepts_pending--)
-#define          tcp_backlog(pcb, bklog) (((struct tcp_pcb_listen *)(pcb))->backlog = bklog)
-#endif /* LWIP_LISTEN_BACKLOG */
+#if TCP_LISTEN_BACKLOG
+#define          tcp_accepted(pcb) (((struct tcp_pcb_listen *)(pcb))->accepts_pending--)
+#else  /* TCP_LISTEN_BACKLOG */
+#define          tcp_accepted(pcb)
+#endif /* TCP_LISTEN_BACKLOG */
 
 void             tcp_recved  (struct tcp_pcb *pcb, u16_t len);
 err_t            tcp_bind    (struct tcp_pcb *pcb, struct ip_addr *ipaddr,
@@ -91,7 +92,10 @@ 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));
-struct tcp_pcb * tcp_listen  (struct tcp_pcb *pcb);
+
+struct tcp_pcb * tcp_listen_with_backlog(struct tcp_pcb *pcb, u8_t backlog);
+#define          tcp_listen(pcb) tcp_listen_with_backlog(pcb, TCP_DEFAULT_LISTEN_BACKLOG)
+
 void             tcp_abort   (struct tcp_pcb *pcb);
 err_t            tcp_close   (struct tcp_pcb *pcb);
 
@@ -422,10 +426,10 @@ struct tcp_pcb_listen {
    */
   err_t (* accept)(void *arg, struct tcp_pcb *newpcb, err_t err);
 #endif /* LWIP_CALLBACK_API */
-#if LWIP_LISTEN_BACKLOG
+#if TCP_LISTEN_BACKLOG
   u8_t backlog;
   u8_t accepts_pending;
-#endif /* LWIP_LISTEN_BACKLOG */
+#endif /* TCP_LISTEN_BACKLOG */
 };
 
 #if LWIP_EVENT_API