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.

19 years ago · 32005617b9
12 changed files with 84 additions and 53 deletions
--- a/7
+++ b/7
@ -18,6 +18,13 @@ HISTORY
  * [Enter new changes just after this line - do not remove this line]

  ++ New features:
+
+  2008-01-04 Frédéric Bernon, Simon Goldschmidt, Jonathan Larmour
+  * 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.
+
  2007-12-31 Kieran Mansley (based on patch from Per-Henrik Lundbolm)
  * tcp.c, tcp_in.c, tcp_out.c, tcp.h: Add TCP persist timer

--- a/doc/rawapi.txt
+++ b/doc/rawapi.txt
@ -95,6 +95,19 @@ incoming connections or be explicitly connected to another host.
  listening connection. If so, the memory associated with the pcb
  passed as an argument to tcp_listen() will not be deallocated.

+- struct tcp_pcb *tcp_listen_with_backlog(struct tcp_pcb *pcb, u8_t backlog)
+
+  Same as tcp_listen, but limits the number of outstanding connections
+  in the listen queue to the value specified by the backlog argument.
+  To use it, your need to set TCP_LISTEN_BACKLOG=1 in your lwipopts.h.
+
+- void tcp_accepted(struct tcp_pcb *pcb)
+
+  Inform lwIP that an incoming connection has been accepted. This would
+  usually be called from the accept callback. This allows lwIP to perform
+  housekeeping tasks, such as allowing further incoming connections to be
+  queued in the listen backlog.
+
 - void tcp_accept(struct tcp_pcb *pcb,
                  err_t (* accept)(void *arg, struct tcp_pcb *newpcb,
                                   err_t err))
--- a/src/api/api_lib.c
+++ b/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;
--- a/src/api/api_msg.c
+++ b/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);
        }
--- a/src/api/sockets.c
+++ b/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) {
--- a/src/core/init.c
+++ b/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.
--- a/src/core/tcp.c
+++ b/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;
 }
--- a/src/core/tcp_in.c
+++ b/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;
--- a/src/include/lwip/api.h
+++ b/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,
--- a/src/include/lwip/api_msg.h
+++ b/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;
 };

--- a/src/include/lwip/opt.h
+++ b/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
-

 /*
   ----------------------------------
--- a/src/include/lwip/tcp.h
+++ b/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