From 0cc9b5ef69aa200c2610f3e87281fe9aa9d7d389 Mon Sep 17 00:00:00 2001 From: patacongo Date: Mon, 19 Nov 2007 23:09:39 +0000 Subject: Add TCP readahead logic git-svn-id: svn://svn.code.sf.net/p/nuttx/code/trunk@387 42af7a65-404d-4744-a932-0658087f49c3 --- nuttx/net/netdev-ioctl.c | 2 +- nuttx/net/recvfrom.c | 143 ++++++++++++++++++++---- nuttx/net/socket.c | 5 +- nuttx/net/uip/Make.defs | 3 +- nuttx/net/uip/uip-arp.c | 18 +-- nuttx/net/uip/uip-chksum.c | 2 +- nuttx/net/uip/uip-fw.c | 230 +++++++++++++++++++++++---------------- nuttx/net/uip/uip-icmpinput.c | 4 +- nuttx/net/uip/uip-initialize.c | 6 + nuttx/net/uip/uip-input.c | 10 +- nuttx/net/uip/uip-internal.h | 8 ++ nuttx/net/uip/uip-listen.c | 10 +- nuttx/net/uip/uip-send.c | 2 +- nuttx/net/uip/uip-setipid.c | 2 +- nuttx/net/uip/uip-split.c | 132 ++++++++++++---------- nuttx/net/uip/uip-tcpcallback.c | 103 +++++++++++++++--- nuttx/net/uip/uip-tcpconn.c | 20 +++- nuttx/net/uip/uip-tcpinput.c | 2 +- nuttx/net/uip/uip-tcpreadahead.c | 132 ++++++++++++++++++++++ nuttx/net/uip/uip-tcpsend.c | 4 +- nuttx/net/uip/uip-udpconn.c | 6 +- nuttx/net/uip/uip-udpsend.c | 2 +- 22 files changed, 622 insertions(+), 224 deletions(-) create mode 100644 nuttx/net/uip/uip-tcpreadahead.c (limited to 'nuttx/net') diff --git a/nuttx/net/netdev-ioctl.c b/nuttx/net/netdev-ioctl.c index 3825a5f7b..e13a22170 100644 --- a/nuttx/net/netdev-ioctl.c +++ b/nuttx/net/netdev-ioctl.c @@ -215,7 +215,7 @@ int netdev_ioctl(int sockfd, int cmd, struct ifreq *req) break; case SIOCGIFMTU: /* Get MTU size */ - req->ifr_mtu = UIP_BUFSIZE; + req->ifr_mtu = CONFIG_NET_BUFSIZE; break; case SIOCGIFHWADDR: /* Get hardware address */ diff --git a/nuttx/net/recvfrom.c b/nuttx/net/recvfrom.c index b0c9a223f..906b5aa6e 100644 --- a/nuttx/net/recvfrom.c +++ b/nuttx/net/recvfrom.c @@ -129,6 +129,93 @@ static void recvfrom_newdata(struct uip_driver_s *dev, struct recvfrom_s *pstate dev->d_len = 0; } +/**************************************************************************** + * Function: recvfrom_readahead + * + * Description: + * Copy the read data from the packet + * + * Parameters: + * dev The sructure of the network driver that caused the interrupt + * pstate recvfrom state structure + * + * Returned Value: + * None + * + * Assumptions: + * Running at the interrupt level + * + ****************************************************************************/ + +#if CONFIG_NET_NTCP_READAHEAD_BUFFERS > 0 +static inline void recvfrom_readahead(struct recvfrom_s *pstate) +{ + struct uip_conn *conn = (struct uip_conn *)pstate->rf_sock->s_conn; + struct uip_readahead_s *readahead; + size_t recvlen; + + /* Check there is any TCP data already buffered in a read-ahead + * buffer. + */ + + do + { + /* Get the read-ahead buffer at the head of the list (if any) */ + + readahead = (struct uip_readahead_s *)sq_remfirst(&conn->readahead); + if (readahead) + { + /* We have a new buffer... transfer that buffered data into + * the user buffer. + * + * First, get the length of the data to transfer. + */ + + if (readahead->rh_nbytes > pstate->rf_buflen) + { + recvlen = pstate->rf_buflen; + } + else + { + recvlen = readahead->rh_nbytes; + } + + if (recvlen > 0) + { + /* Copy the read-ahead data into the user buffer */ + + memcpy(pstate->rf_buffer, readahead->rh_buffer, recvlen); + vdbg("Received %d bytes (of %d)\n", recvlen, readahead->rh_nbytes); + + /* Update the accumulated size of the data read */ + + pstate->rf_recvlen += recvlen; + pstate->rf_buffer += recvlen; + pstate->rf_buflen -= recvlen; + } + + /* If the read-ahead buffer is empty, then release it. If not, then + * we will have to move the data down and return the buffer to the + * front of the list. + */ + + if (recvlen < readahead->rh_nbytes) + { + readahead->rh_nbytes -= recvlen; + memcpy(readahead->rh_buffer, &readahead->rh_buffer[recvlen], + readahead->rh_nbytes); + sq_addfirst(&readahead->rh_node, &conn->readahead); + } + else + { + uip_tcpreadaheadrelease(readahead); + } + } + } + while (readahead && pstate->rf_buflen > 0); +} +#endif + /**************************************************************************** * Function: recvfrom_timeout * @@ -449,8 +536,8 @@ static void recvfrom_init(FAR struct socket *psock, FAR void *buf, size_t len, memset(pstate, 0, sizeof(struct recvfrom_s)); (void)sem_init(&pstate->rf_sem, 0, 0); /* Doesn't really fail */ - pstate->rf_buflen = len; - pstate->rf_buffer = buf; + pstate->rf_buflen = len; + pstate->rf_buffer = buf; #if defined(CONFIG_NET_SOCKOPTS) && !defined(CONFIG_DISABLE_CLOCK) /* Set up the start time for the timeout */ @@ -538,9 +625,9 @@ static ssize_t udp_recvfrom(FAR struct socket *psock, FAR void *buf, size_t len, #endif { struct uip_udp_conn *udp_conn; - struct recvfrom_s state; - irqstate_t save; - int ret; + struct recvfrom_s state; + irqstate_t save; + int ret; /* Perform the UDP recvfrom() operation */ @@ -619,10 +706,10 @@ static ssize_t tcp_recvfrom(FAR struct socket *psock, FAR void *buf, size_t len, FAR const struct sockaddr_in *infrom ) #endif { - struct uip_conn *conn; - struct recvfrom_s state; - irqstate_t save; - int ret; + struct uip_conn *conn; + struct recvfrom_s state; + irqstate_t save; + int ret; /* Verify that the SOCK_STREAM has been connected */ @@ -642,24 +729,38 @@ static ssize_t tcp_recvfrom(FAR struct socket *psock, FAR void *buf, size_t len, save = irqsave(); recvfrom_init(psock, buf, len, &state); - /* Set up the callback in the connection */ +#if CONFIG_NET_NTCP_READAHEAD_BUFFERS > 0 - conn = (struct uip_conn *)psock->s_conn; - conn->data_private = (void*)&state; - conn->data_event = recvfrom_tcpinterrupt; + /* Handle any any TCP data already buffered in a read-ahead buffer. */ - /* Wait for either the receive to complete or for an error/timeout to occur. - * NOTES: (1) sem_wait will also terminate if a signal is received, (2) - * interrupts are disabled! They will be re-enabled while the task sleeps - * and automatically re-enabled when the task restarts. + recvfrom_readahead(&state); + + /* If there is space to receive anything more, then we will + * wait to receive the data. */ - ret = sem_wait(&state.rf_sem); + if (state.rf_buflen > 0) +#endif + { + /* Set up the callback in the connection */ - /* Make sure that no further interrupts are processed */ + conn = (struct uip_conn *)psock->s_conn; + conn->data_private = (void*)&state; + conn->data_event = recvfrom_tcpinterrupt; + + /* Wait for either the receive to complete or for an error/timeout to occur. + * NOTES: (1) sem_wait will also terminate if a signal is received, (2) + * interrupts are disabled! They will be re-enabled while the task sleeps + * and automatically re-enabled when the task restarts. + */ - conn->data_private = NULL; - conn->data_event = NULL; + ret = sem_wait(&state.rf_sem); + + /* Make sure that no further interrupts are processed */ + + conn->data_private = NULL; + conn->data_event = NULL; + } irqrestore(save); #warning "Needs to return server address" diff --git a/nuttx/net/socket.c b/nuttx/net/socket.c index 5efc86df9..d7c21d01b 100644 --- a/nuttx/net/socket.c +++ b/nuttx/net/socket.c @@ -135,7 +135,10 @@ int socket(int domain, int type, int protocol) psock->s_type = type; psock->s_conn = NULL; - /* Allocate the appropriate connection structure */ + /* Allocate the appropriate connection structure. This reserves the + * the connection structure is is unallocated at this point. It will + * not actually be initialized until the socket is connected. + */ switch (type) { diff --git a/nuttx/net/uip/Make.defs b/nuttx/net/uip/Make.defs index 8a232ffbf..4256e72e9 100644 --- a/nuttx/net/uip/Make.defs +++ b/nuttx/net/uip/Make.defs @@ -50,7 +50,8 @@ endif # TCP source files UIP_CSRCS += uip-tcpconn.c uip-tcppoll.c uip-tcptimer.c uip-tcpsend.c \ - uip-tcpinput.c uip-tcpappsend.c uip-listen.c uip-tcpcallback.c + uip-tcpinput.c uip-tcpappsend.c uip-listen.c uip-tcpcallback.c \ + uip-tcpreadahead.c # UDP source files diff --git a/nuttx/net/uip/uip-arp.c b/nuttx/net/uip/uip-arp.c index 13dd1ba03..4d95d16d3 100644 --- a/nuttx/net/uip/uip-arp.c +++ b/nuttx/net/uip/uip-arp.c @@ -129,7 +129,7 @@ static const struct uip_eth_addr broadcast_ethaddr = {{0xff, 0xff, 0xff, 0xff, 0xff, 0xff}}; static const uint16 broadcast_ipaddr[2] = {0xffff, 0xffff}; -static struct arp_entry arp_table[UIP_ARPTAB_SIZE]; +static struct arp_entry arp_table[CONFIG_NET_ARPTAB_SIZE]; static uint8 g_arptime; @@ -170,7 +170,7 @@ static void uip_arp_update(uint16 *pipaddr, uint8 *ethaddr) * inserted in the ARP table. */ - for (i = 0; i < UIP_ARPTAB_SIZE; ++i) + for (i = 0; i < CONFIG_NET_ARPTAB_SIZE; ++i) { tabptr = &arp_table[i]; @@ -198,7 +198,7 @@ static void uip_arp_update(uint16 *pipaddr, uint8 *ethaddr) /* First, we try to find an unused entry in the ARP table. */ - for (i = 0; i < UIP_ARPTAB_SIZE; ++i) + for (i = 0; i < CONFIG_NET_ARPTAB_SIZE; ++i) { tabptr = &arp_table[i]; if (tabptr->at_ipaddr == 0) @@ -211,11 +211,11 @@ static void uip_arp_update(uint16 *pipaddr, uint8 *ethaddr) * throw it away. */ - if (i == UIP_ARPTAB_SIZE) + if (i == CONFIG_NET_ARPTAB_SIZE) { uint8 tmpage = 0; int j = 0; - for (i = 0; i < UIP_ARPTAB_SIZE; ++i) + for (i = 0; i < CONFIG_NET_ARPTAB_SIZE; ++i) { tabptr = &arp_table[i]; if (g_arptime - tabptr->at_time > tmpage) @@ -246,7 +246,7 @@ static void uip_arp_update(uint16 *pipaddr, uint8 *ethaddr) void uip_arp_init(void) { int i; - for (i = 0; i < UIP_ARPTAB_SIZE; ++i) + for (i = 0; i < CONFIG_NET_ARPTAB_SIZE; ++i) { memset(&arp_table[i].at_ipaddr, 0, sizeof(in_addr_t)); } @@ -265,7 +265,7 @@ void uip_arp_timer(void) int i; ++g_arptime; - for (i = 0; i < UIP_ARPTAB_SIZE; ++i) + for (i = 0; i < CONFIG_NET_ARPTAB_SIZE; ++i) { tabptr = &arp_table[i]; if (tabptr->at_ipaddr != 0 && g_arptime - tabptr->at_time >= UIP_ARP_MAXAGE) @@ -451,7 +451,7 @@ void uip_arp_out(struct uip_driver_s *dev) /* Check if we already have this destination address in the ARP table */ - for (i = 0; i < UIP_ARPTAB_SIZE; ++i) + for (i = 0; i < CONFIG_NET_ARPTAB_SIZE; ++i) { tabptr = &arp_table[i]; if (uip_ipaddr_cmp(ipaddr, tabptr->at_ipaddr)) @@ -460,7 +460,7 @@ void uip_arp_out(struct uip_driver_s *dev) } } - if (i == UIP_ARPTAB_SIZE) + if (i == CONFIG_NET_ARPTAB_SIZE) { /* The destination address was not in our ARP table, so we * overwrite the IP packet with an ARP request. diff --git a/nuttx/net/uip/uip-chksum.c b/nuttx/net/uip/uip-chksum.c index c8c173b95..6faaf9817 100644 --- a/nuttx/net/uip/uip-chksum.c +++ b/nuttx/net/uip/uip-chksum.c @@ -223,7 +223,7 @@ uint16 uip_udpchksum(struct uip_driver_s *dev) { return upper_layer_chksum(dev, UIP_PROTO_UDP); } -#endif /* UIP_UDP_CHECKSUMS */ +#endif #endif /* UIP_ARCH_CHKSUM */ #endif /* CONFIG_NET */ diff --git a/nuttx/net/uip/uip-fw.c b/nuttx/net/uip/uip-fw.c index 187fb6c39..fa9b5fc4e 100644 --- a/nuttx/net/uip/uip-fw.c +++ b/nuttx/net/uip/uip-fw.c @@ -103,15 +103,19 @@ struct icmpip_hdr }; /* ICMP ECHO. */ + #define ICMP_ECHO 8 /* ICMP TIME-EXCEEDED. */ + #define ICMP_TE 11 /* Pointer to the TCP/IP headers of the packet in the d_buf buffer. */ + #define BUF ((struct tcpip_hdr *)&dev->d_buf[UIP_LLH_LEN]) /* Pointer to the ICMP/IP headers of the packet in the d_buf buffer. */ + #define ICMPBUF ((struct icmpip_hdr *)&dev->d_buf[UIP_LLH_LEN]) /* Certain fields of an IP packet that are used for identifying @@ -158,11 +162,12 @@ void uip_fw_init(void) { struct uip_fw_netif *t; defaultnetif = NULL; - while(netifs != NULL) { - t = netifs; - netifs = netifs->next; - t->next = NULL; - } + while(netifs != NULL) + { + t = netifs; + netifs = netifs->next; + t->next = NULL; + } } /* Send out an ICMP TIME-EXCEEDED message. @@ -176,18 +181,24 @@ static void time_exceeded(struct uip_driver_s *dev) in_addr_t tmp_addr; /* We don't send out ICMP errors for ICMP messages. */ - if (ICMPBUF->proto == UIP_PROTO_ICMP) { - dev->d_len = 0; - return; - } + + if (ICMPBUF->proto == UIP_PROTO_ICMP) + { + dev->d_len = 0; + return; + } + /* Copy fields from packet header into payload of this ICMP packet. */ + memcpy(&(ICMPBUF->payload[0]), ICMPBUF, 28); /* Set the ICMP type and code. */ - ICMPBUF->type = ICMP_TE; + + ICMPBUF->type = ICMP_TE; ICMPBUF->icode = 0; /* Calculate the ICMP checksum. */ + ICMPBUF->icmpchksum = 0; ICMPBUF->icmpchksum = ~uip_chksum((uint16 *)&(ICMPBUF->type), 36); @@ -195,30 +206,34 @@ static void time_exceeded(struct uip_driver_s *dev) * original packet. */ - tmp_addr = BUF->destipaddr; + tmp_addr = BUF->destipaddr; BUF->destipaddr = BUF->srcipaddr; - BUF->srcipaddr = tmp_addr; + BUF->srcipaddr = tmp_addr; /* Set our IP address as the source address. */ BUF->srcipaddr = dev->d_ipaddr; /* The size of the ICMP time exceeded packet is 36 + the size of the - IP header (20) = 56. */ - dev->d_len = 56; + * IP header (20) = 56. + */ + + dev->d_len = 56; ICMPBUF->len[0] = 0; ICMPBUF->len[1] = dev->d_len; /* Fill in the other fields in the IP header. */ - ICMPBUF->vhl = 0x45; - ICMPBUF->tos = 0; + + ICMPBUF->vhl = 0x45; + ICMPBUF->tos = 0; ICMPBUF->ipoffset[0] = ICMPBUF->ipoffset[1] = 0; - ICMPBUF->ttl = UIP_TTL; - ICMPBUF->proto = UIP_PROTO_ICMP; + ICMPBUF->ttl = UIP_TTL; + ICMPBUF->proto = UIP_PROTO_ICMP; /* Calculate IP checksum. */ - ICMPBUF->ipchksum = 0; - ICMPBUF->ipchksum = ~(uip_ipchksum(dev)); + + ICMPBUF->ipchksum = 0; + ICMPBUF->ipchksum = ~(uip_ipchksum(dev)); } /* Register a packet in the forwarding cache so that it won't be @@ -231,31 +246,36 @@ static void fwcache_register(struct uip_driver_s *dev) int i, oldest; oldest = FW_TIME; - fw = NULL; + fw = NULL; /* Find the oldest entry in the cache. */ - for (i = 0; i < FWCACHE_SIZE; ++i) { - if (fwcache[i].timer == 0) { - fw = &fwcache[i]; - break; - } else if (fwcache[i].timer <= oldest) { - fw = &fwcache[i]; - oldest = fwcache[i].timer; + + for (i = 0; i < FWCACHE_SIZE; ++i) + { + if (fwcache[i].timer == 0) + { + fw = &fwcache[i]; + break; + } + else if (fwcache[i].timer <= oldest) + { + fw = &fwcache[i]; + oldest = fwcache[i].timer; + } } - } - fw->timer = FW_TIME; - fw->ipid = BUF->ipid; - fw->srcipaddr = BUF->srcipaddr; + fw->timer = FW_TIME; + fw->ipid = BUF->ipid; + fw->srcipaddr = BUF->srcipaddr; fw->destipaddr = BUF->destipaddr; - fw->proto = BUF->proto; + fw->proto = BUF->proto; #if notdef fw->payload[0] = BUF->srcport; fw->payload[1] = BUF->destport; #endif #if UIP_REASSEMBLY > 0 - fw->len = BUF->len; - fw->offset = BUF->ipoffset; + fw->len = BUF->len; + fw->offset = BUF->ipoffset; #endif } @@ -301,35 +321,44 @@ uint8 uip_fw_output(struct uip_driver_s *dev) { struct uip_fw_netif *netif; - if (dev->d_len == 0) { - return UIP_FW_ZEROLEN; - } + if (dev->d_len == 0) + { + return UIP_FW_ZEROLEN; + } fwcache_register(dev); -#if UIP_BROADCAST +#ifdef CONFIG_NET_BROADCAST /* Link local broadcasts go out on all interfaces. */ + if (/*BUF->proto == UIP_PROTO_UDP &&*/ - BUF->destipaddr[0] == 0xffff && - BUF->destipaddr[1] == 0xffff) { - if (defaultnetif != NULL) { - defaultnetif->output(); - } - for (netif = netifs; netif != NULL; netif = netif->next) { - netif->output(); + BUF->destipaddr[0] == 0xffff && + BUF->destipaddr[1] == 0xffff) + { + if (defaultnetif != NULL) + { + defaultnetif->output(); + } + for (netif = netifs; netif != NULL; netif = netif->next) + { + netif->output(); + } + return UIP_FW_OK; } - return UIP_FW_OK; - } -#endif /* UIP_BROADCAST */ +#endif netif = find_netif (dev); dbg("netif: %p output: %p len: %d\n", netif, netif->output, dev->d_len); - if (netif == NULL) { - return UIP_FW_NOROUTE; - } + if (netif == NULL) + { + return UIP_FW_NOROUTE; + } + /* If we now have found a suitable network interface, we call its - output function to send out the packet. */ + * output function to send out the packet. + */ + return netif->output(); } @@ -353,39 +382,43 @@ uint8 uip_fw_forward(struct uip_driver_s *dev) } /* If we use ping IP address configuration, and our IP address is - not yet configured, we should intercept all ICMP echo packets. */ -#if UIP_PINGADDRCONF + * not yet configured, we should intercept all ICMP echo packets. + */ + +#ifdef CONFIG_NET_PINGADDRCONF if (dev->d_ipaddr == 0 && BUF->proto == UIP_PROTO_ICMP && ICMPBUF->type == ICMP_ECHO) { return UIP_FW_LOCAL; } -#endif /* UIP_PINGADDRCONF */ +#endif /* Check if the packet is in the forwarding cache already, and if so we drop it. */ - for (fw = fwcache; fw < &fwcache[FWCACHE_SIZE]; ++fw) { - if (fw->timer != 0 && + for (fw = fwcache; fw < &fwcache[FWCACHE_SIZE]; ++fw) + { + if (fw->timer != 0 && #if UIP_REASSEMBLY > 0 - fw->len == BUF->len && - fw->offset == BUF->ipoffset && + fw->len == BUF->len && + fw->offset == BUF->ipoffset && #endif - fw->ipid == BUF->ipid && - fw->srcipaddr == BUF->srcipaddr && - fw->destipaddr == BUF->destipaddr && + fw->ipid == BUF->ipid && + fw->srcipaddr == BUF->srcipaddr && + fw->destipaddr == BUF->destipaddr && #if notdef - fw->payload[0] == BUF->srcport && - fw->payload[1] == BUF->destport && + fw->payload[0] == BUF->srcport && + fw->payload[1] == BUF->destport && #endif - fw->proto == BUF->proto) { - /* Drop packet. */ - return UIP_FW_FORWARDED; + fw->proto == BUF->proto) + { + /* Drop packet. */ + return UIP_FW_FORWARDED; + } } - } /* If the TTL reaches zero we produce an ICMP time exceeded message - in the d_buf buffer and forward that packet back to the sender - of the packet. + * in the d_buf buffer and forward that packet back to the sender + * of the packet. */ if (BUF->ttl <= 1) @@ -400,28 +433,37 @@ uint8 uip_fw_forward(struct uip_driver_s *dev) } /* Decrement the TTL (time-to-live) value in the IP header */ + BUF->ttl = BUF->ttl - 1; /* Update the IP checksum. */ - if (BUF->ipchksum >= HTONS(0xffff - 0x0100)) { - BUF->ipchksum = BUF->ipchksum + HTONS(0x0100) + 1; - } else { - BUF->ipchksum = BUF->ipchksum + HTONS(0x0100); - } - - if (dev->d_len > 0) { - dev->d_appdata = &dev->d_buf[UIP_LLH_LEN + UIP_TCPIP_HLEN]; - uip_fw_output(dev); - } - -#if UIP_BROADCAST - if (BUF->destipaddr[0] == 0xffff && BUF->destipaddr[1] == 0xffff) { - return UIP_FW_LOCAL; - } -#endif /* UIP_BROADCAST */ + + if (BUF->ipchksum >= HTONS(0xffff - 0x0100)) + { + BUF->ipchksum = BUF->ipchksum + HTONS(0x0100) + 1; + } + else + { + BUF->ipchksum = BUF->ipchksum + HTONS(0x0100); + } + + if (dev->d_len > 0) + { + dev->d_appdata = &dev->d_buf[UIP_LLH_LEN + UIP_TCPIP_HLEN]; + uip_fw_output(dev); + } + +#ifdef CONFIG_NET_BROADCAST + if (BUF->destipaddr[0] == 0xffff && BUF->destipaddr[1] == 0xffff) + { + return UIP_FW_LOCAL; + } +#endif /* Return non-zero to indicate that the packet was forwarded and that no - other processing should be made. */ + * other processing should be made. + */ + return UIP_FW_FORWARDED; } @@ -434,7 +476,7 @@ uint8 uip_fw_forward(struct uip_driver_s *dev) void uip_fw_register(struct uip_fw_netif *netif) { netif->next = netifs; - netifs = netif; + netifs = netif; } /* Register a default network interface. @@ -456,9 +498,11 @@ void uip_fw_default(struct uip_fw_netif *netif) void uip_fw_periodic(void) { struct fwcache_entry *fw; - for (fw = fwcache; fw < &fwcache[FWCACHE_SIZE]; ++fw) { - if (fw->timer > 0) { - --fw->timer; + for (fw = fwcache; fw < &fwcache[FWCACHE_SIZE]; ++fw) + { + if (fw->timer > 0) + { + --fw->timer; + } } - } } diff --git a/nuttx/net/uip/uip-icmpinput.c b/nuttx/net/uip/uip-icmpinput.c index 8dd276330..5dae94bd7 100644 --- a/nuttx/net/uip/uip-icmpinput.c +++ b/nuttx/net/uip/uip-icmpinput.c @@ -119,12 +119,12 @@ void uip_icmpinput(struct uip_driver_s *dev) * ourself. */ -#if UIP_PINGADDRCONF +#ifdef CONFIG_NET_PINGADDRCONF if (dev->d_ipaddr == 0) { dev->d_ipaddr = ICMPBUF->destipaddr; } -#endif /* UIP_PINGADDRCONF */ +#endif ICMPBUF->type = ICMP_ECHO_REPLY; diff --git a/nuttx/net/uip/uip-initialize.c b/nuttx/net/uip/uip-initialize.c index 3a7701cbe..2e00c5d9c 100644 --- a/nuttx/net/uip/uip-initialize.c +++ b/nuttx/net/uip/uip-initialize.c @@ -125,6 +125,12 @@ void uip_initialize(void) uip_tcpinit(); + /* Initialize the TCP/IP read-ahead buffering */ + +#if CONFIG_NET_NTCP_READAHEAD_BUFFERS > 0 + uip_tcpreadaheadinit(); +#endif + /* Initialize the UDP connection structures */ #ifdef CONFIG_NET_UDP diff --git a/nuttx/net/uip/uip-input.c b/nuttx/net/uip/uip-input.c index 1c3de79e6..71f9b8b9a 100644 --- a/nuttx/net/uip/uip-input.c +++ b/nuttx/net/uip/uip-input.c @@ -108,7 +108,7 @@ /* IP fragment re-assembly */ #define IP_MF 0x20 -#define UIP_REASS_BUFSIZE (UIP_BUFSIZE - UIP_LLH_LEN) +#define UIP_REASS_BUFSIZE (CONFIG_NET_BUFSIZE - UIP_LLH_LEN) #define UIP_REASS_FLAG_LASTFRAG 0x01 /**************************************************************************** @@ -392,7 +392,7 @@ void uip_input(struct uip_driver_s *dev) * packets. */ -#if UIP_PINGADDRCONF && !CONFIG_NET_IPv6 +#if defined(CONFIG_NET_PINGADDRCONF) && !defined(CONFIG_NET_IPv6) if (BUF->proto == UIP_PROTO_ICMP) { dbg("Possible ping config packet received\n"); @@ -400,7 +400,7 @@ void uip_input(struct uip_driver_s *dev) goto done; } else -#endif /* UIP_PINGADDRCONF */ +#endif { dbg("No IP address assigned\n"); goto drop; @@ -412,13 +412,13 @@ void uip_input(struct uip_driver_s *dev) * UDP packet, which may be destined to us. */ -#if UIP_BROADCAST +#ifdef CONFIG_NET_BROADCAST if (BUF->proto == UIP_PROTO_UDP && uip_ipaddr_cmp(BUF->destipaddr, all_ones_addr) { uip_udpinput(dev); return; } -#endif /* UIP_BROADCAST */ +#endif /* Check if the packet is destined for our IP address. */ #ifndef CONFIG_NET_IPv6 diff --git a/nuttx/net/uip/uip-internal.h b/nuttx/net/uip/uip-internal.h index 118ccd53f..c358d431f 100644 --- a/nuttx/net/uip/uip-internal.h +++ b/nuttx/net/uip/uip-internal.h @@ -194,6 +194,14 @@ EXTERN void uip_udpcallback(struct uip_driver_s *dev, EXTERN void uip_icmpinput(struct uip_driver_s *dev); +/* Defined in uip-tcpreadahead.c ********************************************/ + +#if CONFIG_NET_NTCP_READAHEAD_BUFFERS > 0 +EXTERN void uip_tcpreadaheadinit(void); +EXTERN struct uip_readahead_s *uip_tcpreadaheadalloc(void); +EXTERN void uip_tcpreadaheadrelease(struct uip_readahead_s *buf); +#endif /* CONFIG_NET_NTCP_READAHEAD_BUFFERS */ + #undef EXTERN #ifdef __cplusplus } diff --git a/nuttx/net/uip/uip-listen.c b/nuttx/net/uip/uip-listen.c index e7ee8ffc3..643d054cb 100644 --- a/nuttx/net/uip/uip-listen.c +++ b/nuttx/net/uip/uip-listen.c @@ -57,7 +57,7 @@ /* The uip_listenports list all currently listening ports. */ -static uint16 uip_listenports[UIP_LISTENPORTS]; +static uint16 uip_listenports[CONFIG_NET_MAX_LISTENPORTS]; /**************************************************************************** * Private Functions @@ -82,7 +82,7 @@ static uint16 uip_listenports[UIP_LISTENPORTS]; void uip_listeninit(void) { int ndx; - for (ndx = 0; ndx < UIP_LISTENPORTS; ndx++) + for (ndx = 0; ndx < CONFIG_NET_MAX_LISTENPORTS; ndx++) { uip_listenports[ndx] = 0; } @@ -106,7 +106,7 @@ int uip_unlisten(uint16 port) int ret = -EINVAL; flags = irqsave(); - for (ndx = 0; ndx < UIP_LISTENPORTS; ndx++) + for (ndx = 0; ndx < CONFIG_NET_MAX_LISTENPORTS; ndx++) { if (uip_listenports[ndx] == port) { @@ -137,7 +137,7 @@ int uip_listen(uint16 port) int ret = -ENOBUFS; flags = irqsave(); - for (ndx = 0; ndx < UIP_LISTENPORTS; ndx++) + for (ndx = 0; ndx < CONFIG_NET_MAX_LISTENPORTS; ndx++) { if (uip_listenports[ndx] == 0) { @@ -164,7 +164,7 @@ int uip_listen(uint16 port) boolean uip_islistener(uint16 portno) { int ndx; - for (ndx = 0; ndx < UIP_LISTENPORTS; ndx++) + for (ndx = 0; ndx < CONFIG_NET_MAX_LISTENPORTS; ndx++) { if (uip_listenports[ndx] == portno) { diff --git a/nuttx/net/uip/uip-send.c b/nuttx/net/uip/uip-send.c index 6cdfd7252..93096168a 100644 --- a/nuttx/net/uip/uip-send.c +++ b/nuttx/net/uip/uip-send.c @@ -93,7 +93,7 @@ void uip_send(struct uip_driver_s *dev, const void *buf, int len) { - if (dev && len > 0 && len < UIP_BUFSIZE) + if (dev && len > 0 && len < CONFIG_NET_BUFSIZE) { dev->d_sndlen = len; memcpy(dev->d_snddata, buf, len ); diff --git a/nuttx/net/uip/uip-setipid.c b/nuttx/net/uip/uip-setipid.c index 71467b0f8..5726c7c7a 100644 --- a/nuttx/net/uip/uip-setipid.c +++ b/nuttx/net/uip/uip-setipid.c @@ -1,5 +1,5 @@ /**************************************************************************** - * net/uip/uip-udpcallback.c + * net/uip/uip-setipid.c * * Copyright (C) 2007 Gregory Nutt. All rights reserved. * Author: Gregory Nutt diff --git a/nuttx/net/uip/uip-split.c b/nuttx/net/uip/uip-split.c index 8d75487d2..68b19d275 100644 --- a/nuttx/net/uip/uip-split.c +++ b/nuttx/net/uip/uip-split.c @@ -42,85 +42,103 @@ void uip_split_output(struct uip_driver_s *dev) { - uint16 tcplen, len1, len2; + uint16 tcplen; + uint16 len1; + uint16 len2; /* We only try to split maximum sized TCP segments. */ - if(BUF->proto == UIP_PROTO_TCP && - dev->d_len == UIP_BUFSIZE - UIP_LLH_LEN) { - - tcplen = dev->d_len - UIP_TCPIP_HLEN; - /* Split the segment in two. If the original packet length was - odd, we make the second packet one byte larger. */ - len1 = len2 = tcplen / 2; - if(len1 + len2 < tcplen) { - ++len2; - } - /* Create the first packet. This is done by altering the length - field of the IP header and updating the checksums. */ - dev->d_len = len1 + UIP_TCPIP_HLEN; + if (BUF->proto == UIP_PROTO_TCP && + dev->d_len == CONFIG_NET_BUFSIZE - UIP_LLH_LEN) + { + tcplen = dev->d_len - UIP_TCPIP_HLEN; + + /* Split the segment in two. If the original packet length was + * odd, we make the second packet one byte larger. + */ + + len1 = len2 = tcplen / 2; + if (len1 + len2 < tcplen) + { + ++len2; + } + + /* Create the first packet. This is done by altering the length + * field of the IP header and updating the checksums. + */ + + dev->d_len = len1 + UIP_TCPIP_HLEN; #ifdef CONFIG_NET_IPv6 - /* For IPv6, the IP length field does not include the IPv6 IP header - length. */ - BUF->len[0] = ((dev->d_len - UIP_IPH_LEN) >> 8); - BUF->len[1] = ((dev->d_len - UIP_IPH_LEN) & 0xff); + /* For IPv6, the IP length field does not include the IPv6 IP header + * length. + */ + BUF->len[0] = ((dev->d_len - UIP_IPH_LEN) >> 8); + BUF->len[1] = ((dev->d_len - UIP_IPH_LEN) & 0xff); #else /* CONFIG_NET_IPv6 */ - BUF->len[0] = dev->d_len >> 8; - BUF->len[1] = dev->d_len & 0xff; + BUF->len[0] = dev->d_len >> 8; + BUF->len[1] = dev->d_len & 0xff; #endif /* CONFIG_NET_IPv6 */ - /* Recalculate the TCP checksum. */ - BUF->tcpchksum = 0; - BUF->tcpchksum = ~(uip_tcpchksum(dev)); + /* Recalculate the TCP checksum. */ + + BUF->tcpchksum = 0; + BUF->tcpchksum = ~(uip_tcpchksum(dev)); #ifndef CONFIG_NET_IPv6 - /* Recalculate the IP checksum. */ - BUF->ipchksum = 0; - BUF->ipchksum = ~(uip_ipchksum(dev)); + /* Recalculate the IP checksum. */ + + BUF->ipchksum = 0; + BUF->ipchksum = ~(uip_ipchksum(dev)); #endif /* CONFIG_NET_IPv6 */ - /* Transmit the first packet. */ - /* uip_fw_output();*/ - tcpip_output(); + /* Transmit the first packet. */ + /* uip_fw_output();*/ + tcpip_output(); + + /* Now, create the second packet. To do this, it is not enough to + * just alter the length field, but we must also update the TCP + * sequence number and point the d_appdata to a new place in + * memory. This place is detemined by the length of the first + * packet (len1). + */ - /* Now, create the second packet. To do this, it is not enough to - just alter the length field, but we must also update the TCP - sequence number and point the d_appdata to a new place in - memory. This place is detemined by the length of the first - packet (len1). */ - dev->d_len = len2 + UIP_TCPIP_HLEN; + dev->d_len = len2 + UIP_TCPIP_HLEN; #ifdef CONFIG_NET_IPv6 - /* For IPv6, the IP length field does not include the IPv6 IP header - length. */ - BUF->len[0] = ((dev->d_len - UIP_IPH_LEN) >> 8); - BUF->len[1] = ((dev->d_len - UIP_IPH_LEN) & 0xff); + /* For IPv6, the IP length field does not include the IPv6 IP header + * length. + */ + + BUF->len[0] = ((dev->d_len - UIP_IPH_LEN) >> 8); + BUF->len[1] = ((dev->d_len - UIP_IPH_LEN) & 0xff); #else /* CONFIG_NET_IPv6 */ - BUF->len[0] = dev->d_len >> 8; - BUF->len[1] = dev->d_len & 0xff; + BUF->len[0] = dev->d_len >> 8; + BUF->len[1] = dev->d_len & 0xff; #endif /* CONFIG_NET_IPv6 */ - /* dev->d_appdata += len1;*/ - memcpy(dev->d_appdata, dev->d_appdata + len1, len2); + /* dev->d_appdata += len1;*/ + memcpy(dev->d_appdata, dev->d_appdata + len1, len2); - uip_incr32(BUF->seqno, len1); + uip_incr32(BUF->seqno, len1); - /* Recalculate the TCP checksum. */ + /* Recalculate the TCP checksum. */ - BUF->tcpchksum = 0; - BUF->tcpchksum = ~(uip_tcpchksum(dev)); + BUF->tcpchksum = 0; + BUF->tcpchksum = ~(uip_tcpchksum(dev)); #ifndef CONFIG_NET_IPv6 - /* Recalculate the IP checksum. */ + /* Recalculate the IP checksum. */ - BUF->ipchksum = 0; - BUF->ipchksum = ~(uip_ipchksum(dev)); + BUF->ipchksum = 0; + BUF->ipchksum = ~(uip_ipchksum(dev)); #endif /* CONFIG_NET_IPv6 */ - /* Transmit the second packet. */ - /* uip_fw_output();*/ - tcpip_output(); - } else { - /* uip_fw_output();*/ - tcpip_output(); - } + /* Transmit the second packet. */ + /* uip_fw_output();*/ + tcpip_output(); + } + else + { + /* uip_fw_output();*/ + tcpip_output(); + } } diff --git a/nuttx/net/uip/uip-tcpcallback.c b/nuttx/net/uip/uip-tcpcallback.c index 973a2f2a2..311323059 100644 --- a/nuttx/net/uip/uip-tcpcallback.c +++ b/nuttx/net/uip/uip-tcpcallback.c @@ -42,6 +42,7 @@ #ifdef CONFIG_NET #include +#include #include #include @@ -58,6 +59,89 @@ * Private Functions ****************************************************************************/ +/**************************************************************************** + * Function: uip_dataevent + * + * Description: + * This is the default data_event handler that is called when there is no + * use data handler in place + * + * Assumptions: + * This function is called at the interrupt level with interrupts disabled. + * + ****************************************************************************/ + +static inline uint8 +uip_dataevent(struct uip_driver_s *dev, struct uip_conn *conn, uint8 flags) +{ +#if CONFIG_NET_NTCP_READAHEAD_BUFFERS > 0 + struct uip_readahead_s *readahead; + uint16 recvlen; +#endif + uint8 ret = flags; + + /* Is there new data? With non-zero length? (Certain connection events + * can have zero-length with UIP_NEWDATA set just to cause an ACK). + */ + + if (uip_newdata_event(flags) && dev->d_len > 0) + { +#if CONFIG_NET_NTCP_READAHEAD_BUFFERS > 0 + /* Allocate a read-ahead buffer to hold the newly received data */ + + readahead = uip_tcpreadaheadalloc(); + if (readahead) + { + /* Get the length of the data to buffer. If the sizes of the + * read-ahead buffers are picked correct, they should always + * hold the full received packet.\ + */ + + if (dev->d_len > CONFIG_NET_TCP_READAHEAD_BUFSIZE) + { + recvlen = CONFIG_NET_TCP_READAHEAD_BUFSIZE; + } + else + { + recvlen = dev->d_len; + } + + /* Copy the new appdata into the read-ahead buffer */ + + memcpy(readahead->rh_buffer, dev->d_appdata, recvlen); + readahead->rh_nbytes = recvlen; + vdbg("Buffered %d bytes (of %d)\n", recvlen, dev->d_len); + + /* Save the readahead buffer in the connection structure where + * it can be found with recv() is called. + */ + + sq_addlast(&readahead->rh_node, &conn->readahead); + + /* Indicate that all of the data in the buffer has been consumed */ + + dev->d_len = 0; + } + else +#endif + { + /* There is no handler to receive new data and there are no free + * read-ahead buffers to retain the data. In this case, clear the + * UIP_NEWDATA bit so that no ACK will be sent and drop the packet. + */ + +#ifdef CONFIG_NET_STATISTICS + uip_stat.tcp.syndrop++; + uip_stat.tcp.drop++; +#endif + ret &= ~UIP_NEWDATA; + dev->d_len = 0; + } + } + + return ret; +} + /**************************************************************************** * Public Functions ****************************************************************************/ @@ -104,23 +188,12 @@ uint8 uip_tcpcallback(struct uip_driver_s *dev, struct uip_conn *conn, uint8 fla ret = conn->data_event(dev, conn, flags); } - else if ((flags & UIP_CONN_EVENTS) == 0) + else { - /* There is no handler to receive new data in place and this is not a - * connection event (which may also include new data that must be ACKed). - * In this case, clear the UIP_NEWDATA bit so that no ACK will be sent - * and drop the packet. - */ - - dbg("No listener on connection\n"); - -#ifdef CONFIG_NET_STATISTICS - uip_stat.tcp.syndrop++; - uip_stat.tcp.drop++; -#endif + /* There is no handler to receive new data in place */ - ret &= ~UIP_NEWDATA; - dev->d_len = 0; + vdbg("No listener on connection\n"); + ret = uip_dataevent(dev, conn, flags); } /* Check if there is a connection-related event and a connection diff --git a/nuttx/net/uip/uip-tcpconn.c b/nuttx/net/uip/uip-tcpconn.c index c0c151570..edeb464ec 100644 --- a/nuttx/net/uip/uip-tcpconn.c +++ b/nuttx/net/uip/uip-tcpconn.c @@ -70,7 +70,7 @@ /* The array containing all uIP TCP connections. */ -static struct uip_conn g_tcp_connections[UIP_CONNS]; +static struct uip_conn g_tcp_connections[CONFIG_NET_TCP_CONNS]; /* A list of all free TCP connections */ @@ -186,7 +186,7 @@ void uip_tcpinit(void) /* Now initialize each connection structure */ - for (i = 0; i < UIP_CONNS; i++) + for (i = 0; i < CONFIG_NET_TCP_CONNS; i++) { /* Mark the connection closed and move it to the free list */ @@ -394,7 +394,7 @@ struct uip_conn *uip_tcplistener(uint16 portno) /* Check if this port number is in use by any active UIP TCP connection */ - for (i = 0; i < UIP_CONNS; i++) + for (i = 0; i < CONFIG_NET_TCP_CONNS; i++) { conn = &g_tcp_connections[i]; if (conn->tcpstateflags != UIP_CLOSED && conn->lport == portno) @@ -450,12 +450,18 @@ struct uip_conn *uip_tcpaccept(struct uip_tcpip_hdr *buf) conn->rcv_nxt[1] = buf->seqno[1]; conn->rcv_nxt[0] = buf->seqno[0]; + /* Initialize the list of TCP read-ahead buffers */ + +#if CONFIG_NET_NTCP_READAHEAD_BUFFERS > 0 + sq_init(&conn->readahead); +#endif + /* And, finally, put the connection structure into the active list. * Interrupts should already be disabled in this context. */ dq_addlast(&conn->node, &g_active_tcp_connections); - } + } return conn; } @@ -615,6 +621,12 @@ int uip_tcpconnect(struct uip_conn *conn, const struct sockaddr_in *addr) uip_ipaddr_copy(conn->ripaddr, addr->sin_addr.s_addr); + /* Initialize the list of TCP read-ahead buffers */ + +#if CONFIG_NET_NTCP_READAHEAD_BUFFERS > 0 + sq_init(&conn->readahead); +#endif + /* And, finally, put the connection structure into the active * list. Because g_active_tcp_connections is accessed from user level and * interrupt level, code, it is necessary to keep interrupts disabled during diff --git a/nuttx/net/uip/uip-tcpinput.c b/nuttx/net/uip/uip-tcpinput.c index 5ce3e2df6..1a74d5f81 100644 --- a/nuttx/net/uip/uip-tcpinput.c +++ b/nuttx/net/uip/uip-tcpinput.c @@ -265,7 +265,7 @@ void uip_tcpinput(struct uip_driver_s *dev) found: - flags = 0; + flags = 0; /* We do a very naive form of TCP reset processing; we just accept * any RST and kill our connection. We should in fact check if the diff --git a/nuttx/net/uip/uip-tcpreadahead.c b/nuttx/net/uip/uip-tcpreadahead.c new file mode 100644 index 000000000..6c4c78f1e --- /dev/null +++ b/nuttx/net/uip/uip-tcpreadahead.c @@ -0,0 +1,132 @@ +/**************************************************************************** + * net/uip/uip-tcpreadahead.c + * + * Copyright (C) 2007 Gregory Nutt. All rights reserved. + * Author: Gregory Nutt + * + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * 3. Neither the name NuttX nor the names of its contributors may be + * used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN + * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + ****************************************************************************/ + +/**************************************************************************** + * Included Files + ****************************************************************************/ + +#include +#if defined(CONFIG_NET) && (CONFIG_NET_NTCP_READAHEAD_BUFFERS > 0) + +#include +#include +#include + +#include + +#include "uip-internal.h" + +/**************************************************************************** + * Private Data + ****************************************************************************/ + +/* These are the pre-allocated read-ahead buffers */ + +static struct uip_readahead_s g_buffers[CONFIG_NET_NTCP_READAHEAD_BUFFERS]; + +/* This is the list of available read-ahead buffers */ + +static sq_queue_t g_freebuffers; + +/**************************************************************************** + * Private Functions + ****************************************************************************/ + +/**************************************************************************** + * Public Functions + ****************************************************************************/ + +/**************************************************************************** + * Function: uip_tcpreadaheadinit + * + * Description: + * Initialize the list of free read-ahead buffers + * + * Assumptions: + * Called once early initialization. + * + ****************************************************************************/ + +void uip_tcpreadaheadinit(void) +{ + int i; + + sq_init(&g_freebuffers); + for (i = 0; i < CONFIG_NET_NTCP_READAHEAD_BUFFERS; i++) + { + sq_addfirst(&g_buffers[i].rh_node, &g_freebuffers); + } +} + +/**************************************************************************** + * Function: uip_tcpreadaheadalloc + * + * Description: + * Allocate a TCP read-ahead buffer by taking a pre-allocated buffer from + * the free list. This function is called from TCP logic when new, + * incoming TCP data is received but there is no user logic recving the + * the data. Note: malloc() cannot be used because this function is + * called from interrupt level. + * + * Assumptions: + * Called from interrupt level with interrupts disabled. + * + ****************************************************************************/ + +struct uip_readahead_s *uip_tcpreadaheadalloc(void) +{ + return (struct uip_readahead_s*)sq_remfirst(&g_freebuffers); +} + +/**************************************************************************** + * Function: uip_tcpreadaheadrelease + * + * Description: + * Release a TCP read-ahead buffer by returning the buffer to the free list. + * This function is called from user logic after it is consumed the buffered + * data. + * + * Assumptions: + * Called from user logic BUT with interrupts disabled. + * + ****************************************************************************/ + +void uip_tcpreadaheadrelease(struct uip_readahead_s *buf) +{ + sq_addfirst(&buf->rh_node, &g_freebuffers); +} + +#endif /* CONFIG_NET && CONFIG_NET_NTCP_READAHEAD_BUFFERS*/ diff --git a/nuttx/net/uip/uip-tcpsend.c b/nuttx/net/uip/uip-tcpsend.c index 31766d202..02123bc82 100644 --- a/nuttx/net/uip/uip-tcpsend.c +++ b/nuttx/net/uip/uip-tcpsend.c @@ -199,8 +199,8 @@ static void uip_tcpsendcommon(struct uip_driver_s *dev, struct uip_conn *conn) } else { - BUF->wnd[0] = ((UIP_RECEIVE_WINDOW) >> 8); - BUF->wnd[1] = ((UIP_RECEIVE_WINDOW) & 0xff); + BUF->wnd[0] = ((CONFIG_NET_TCP_CONNS) >> 8); + BUF->wnd[1] = ((CONFIG_NET_TCP_CONNS) & 0xff); } /* Finish the IP portion of the message, calculate checksums and send diff --git a/nuttx/net/uip/uip-udpconn.c b/nuttx/net/uip/uip-udpconn.c index 87ca3f8a6..b904aaac5 100644 --- a/nuttx/net/uip/uip-udpconn.c +++ b/nuttx/net/uip/uip-udpconn.c @@ -66,7 +66,7 @@ /* The array containing all uIP UDP connections. */ -struct uip_udp_conn g_udp_connections[UIP_UDP_CONNS]; +struct uip_udp_conn g_udp_connections[CONFIG_NET_UDP_CONNS]; /* A list of all free UDP connections */ @@ -124,7 +124,7 @@ static struct uip_udp_conn *uip_find_conn( uint16 portno ) /* Now search each connection structure.*/ - for (i = 0; i < UIP_UDP_CONNS; i++) + for (i = 0; i < CONFIG_NET_UDP_CONNS; i++) { if (g_udp_connections[ i ].lport == portno) { @@ -158,7 +158,7 @@ void uip_udpinit(void) dq_init(&g_active_udp_connections); sem_init(&g_free_sem, 0, 1); - for (i = 0; i < UIP_UDP_CONNS; i++) + for (i = 0; i < CONFIG_NET_UDP_CONNS; i++) { /* Mark the connection closed and move it to the free list */ diff --git a/nuttx/net/uip/uip-udpsend.c b/nuttx/net/uip/uip-udpsend.c index 7a2a0547c..8f77f78a2 100644 --- a/nuttx/net/uip/uip-udpsend.c +++ b/nuttx/net/uip/uip-udpsend.c @@ -160,7 +160,7 @@ void uip_udpsend(struct uip_driver_s *dev, struct uip_udp_conn *conn) } #else UDPBUF->udpchksum = 0; -#endif /* UIP_UDP_CHECKSUMS */ +#endif vdbg("Outgoing UDP packet length: %d (%d)\n", dev->d_len, (UDPBUF->len[0] << 8) | UDPBUF->len[1]); -- cgit v1.2.3