From 32005617b9018521233386b60b34642ab483e94d Mon Sep 17 00:00:00 2001 From: fbernon Date: Fri, 4 Jan 2008 22:18:27 +0000 Subject: [PATCH] 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. --- CHANGELOG | 7 +++++++ doc/rawapi.txt | 13 +++++++++++++ src/api/api_lib.c | 14 +++++++------- src/api/api_msg.c | 13 +++++++------ src/api/sockets.c | 12 +++++++++--- src/core/init.c | 6 +++--- src/core/tcp.c | 8 ++++---- src/core/tcp_in.c | 8 ++++---- src/include/lwip/api.h | 2 +- src/include/lwip/api_msg.h | 4 ++-- src/include/lwip/opt.h | 32 ++++++++++++++++---------------- src/include/lwip/tcp.h | 18 +++++++++++------- 12 files changed, 84 insertions(+), 53 deletions(-) diff --git a/CHANGELOG b/CHANGELOG index 8f7b5a2e..8e6da0f3 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -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 diff --git a/doc/rawapi.txt b/doc/rawapi.txt index 016ae64c..93c0e862 100644 --- 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)) diff --git a/src/api/api_lib.c b/src/api/api_lib.c index e109ceca..444f83a9 100644 --- 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; diff --git a/src/api/api_msg.c b/src/api/api_msg.c index e44da527..0a48fd4d 100644 --- 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); } diff --git a/src/api/sockets.c b/src/api/sockets.c index 47f7074f..175fde84 100644 --- 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) { diff --git a/src/core/init.c b/src/core/init.c index d15ef89d..ee073daf 100644 --- 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. diff --git a/src/core/tcp.c b/src/core/tcp.c index 7f819398..dbaa8d4f 100644 --- 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; } diff --git a/src/core/tcp_in.c b/src/core/tcp_in.c index f0ba1a33..4b7b919c 100644 --- 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; diff --git a/src/include/lwip/api.h b/src/include/lwip/api.h index 225339b8..0195df88 100644 --- 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, diff --git a/src/include/lwip/api_msg.h b/src/include/lwip/api_msg.h index 252c219a..e755d735 100644 --- 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; }; diff --git a/src/include/lwip/opt.h b/src/include/lwip/opt.h index 19a9c342..9ec3a426 100644 --- 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 - /* ---------------------------------- diff --git a/src/include/lwip/tcp.h b/src/include/lwip/tcp.h index d51071f7..aa949e43 100644 --- 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 -- 2.39.2