Aksal/nuttx
3
1
Fork 1
mirror of https://github.com/apache/nuttx.git synced 2026-08-01 20:28:58 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

Finished partitioning uip.c (now system is broken)

Browse source 
git-svn-id: svn://svn.code.sf.net/p/nuttx/code/trunk@375 42af7a65-404d-4744-a932-0658087f49c3
This commit is contained in:
patacongo 2007-11-07 18:54:35 +00:00
parent 81d093e29e
commit 22cd175fd7
20 changed files with 2944 additions and 1930 deletions
Download patch file Download diff file Expand all files Collapse all files

2
fs/fs_open.c
View file

@ -74,7 +74,9 @@ int open(const char *path, int oflags, ...)
struct filelist *list;
FAR struct inode *inode;
const char *relpath = NULL;
#ifdef CONFIG_FILE_MODE
mode_t mode = 0666;
#endif
int ret;
int fd;

58
include/net/uip/uip-arch.h
View file

@ -57,28 +57,20 @@
* Definitions
****************************************************************************/
/* The following flags are passed as an argument to the uip_interrupt()
/* The following flags are passed as an argument to the uip_poll()
* function. They are used to distinguish between the two cases where
* uip_interrupt() is called. It can be called either because we have
* uip_poll() is called. It can be called either because we have
* incoming data that should be processed, or because the periodic
* timer has fired. These values are never used directly, but only in
* the macrose defined in this file.
* timer has fired.
*
* UIP_DRV_RECEIVE - There is new incoming data from the driver in the d_buf
* field of the uip_driver_s structure. The length of the
* new data is provided in the d_len field of the
* uip_driver_s structure.
* UIP_DRV_TIMER - Called periodically from driver to service timeout-
* related activities to and to get timeout-related
* responses (e.g., reset)
* UIP_DRV_POLL - Poll TCP for data to be transmitted
* UIP_DRV_UDPPOLL - Poll for UDP data to be transmitted. This value is used
* internally by the uip_poll logic.
*/
#define UIP_DRV_RECEIVE 1
#define UIP_DRV_TIMER 2
#define UIP_DRV_POLL 3
#define UIP_DRV_TIMER 1
#define UIP_DRV_POLL 2
/****************************************************************************
* Public Types
@ -214,7 +206,7 @@ struct uip_driver_s
*
* dev->d_len = devicedriver_poll();
* if(dev->d_len > 0) {
* uip_input();
* uip_input(dev);
* if(dev->d_len > 0) {
* devicedriver_send();
* }
@ -230,7 +222,7 @@ struct uip_driver_s
* if(dev->d_len > 0) {
* if(BUF->type == HTONS(UIP_ETHTYPE_IP)) {
* uip_arp_ipin();
* uip_input();
* uip_input(dev);
* if(dev->d_len > 0) {
* uip_arp_out();
* devicedriver_send();
@ -243,12 +235,12 @@ struct uip_driver_s
* }
*/
#define uip_input(dev) uip_interrupt(dev, UIP_DRV_RECEIVE)
extern void uip_input(struct uip_driver_s *dev);
/* Polling of connections.
*
* This function will traverse each active uIP connection structure and
* perform uip_interrupt with the specified event. After each polling each
* perform uip_input with the specified event. After each polling each
* active uIP connection structure, this function will call the provided
* callback function if the poll resulted in new data to be send. The poll
* will continue until all connections have been polled or until the user-
@ -305,37 +297,29 @@ extern int uip_poll(struct uip_driver_s *dev, uip_poll_callback_t callback, int
#define uip_periodic(dev,cb) uip_poll(dev, db, UIP_DRV_TIMER);
/* Architecure support
*
* The actual uIP function which does all the work. Called from the
* interrupt level by a device driver.
*/
extern void uip_interrupt(struct uip_driver_s *dev, uint8 event);
/* By defining UIP_ARCH_CHKSUM, the architecture can replace the following
* functions with hardware assisted solutions.
*/
/* Carry out a 32-bit addition.
*
* Because not all architectures for which uIP is intended has native
* 32-bit arithmetic, uIP uses an external C function for doing the
* required 32-bit additions in the TCP protocol processing. This
* function should add the two arguments and place the result in the
* global variable uip_acc32.
* op32 - A pointer to a 4-byte array representing a 32-bit
* integer in network byte order (big endian). This value may not
* be word aligned.
*
* Note: The 32-bit integer pointed to by the op32 parameter and the
* result in the uip_acc32 variable are in network byte order (big
* endian).
* For uip_incr32, the value pointed to by op32 is modified in place
* For uip_add32, the value pointed to by op32 is unmodified
*
* op16 - A 16-bit integer in host byte order.
*
* op32 A pointer to a 4-byte array representing a 32-bit
* integer in network byte order (big endian).
* sum - The location to return the result (32-bit, network byte order,
* possibly unaligned).
*
* op16 A 16-bit integer in host byte order.
* uip_add32 only.
*/
extern void uip_add32(uint8 *op32, uint16 op16);
extern void uip_add32(const uint8 *op32, uint16 op16, uint8 *sum);
extern void uip_incr32(uint8 *op32, uint16 op16);
/* Calculate the Internet checksum over a buffer.
*

190
include/net/uip/uip.h
View file

@ -222,55 +222,54 @@ struct uip_stats
{
struct
{
uip_stats_t drop; /* Number of dropped packets at the IP layer. */
uip_stats_t recv; /* Number of received packets at the IP layer. */
uip_stats_t sent; /* Number of sent packets at the IP layer. */
uip_stats_t vhlerr; /* Number of packets dropped due to wrong
IP version or header length. */
uip_stats_t hblenerr; /* Number of packets dropped due to wrong
IP length, high byte. */
uip_stats_t lblenerr; /* Number of packets dropped due to wrong
IP length, low byte. */
uip_stats_t fragerr; /* Number of packets dropped since they
were IP fragments. */
uip_stats_t chkerr; /* Number of packets dropped due to IP
checksum errors. */
uip_stats_t protoerr; /* Number of packets dropped since they
were neither ICMP, UDP nor TCP. */
} ip; /* IP statistics. */
uip_stats_t drop; /* Number of dropped packets at the IP layer. */
uip_stats_t recv; /* Number of received packets at the IP layer. */
uip_stats_t sent; /* Number of sent packets at the IP layer. */
uip_stats_t vhlerr; /* Number of packets dropped due to wrong
IP version or header length. */
uip_stats_t hblenerr; /* Number of packets dropped due to wrong
IP length, high byte. */
uip_stats_t lblenerr; /* Number of packets dropped due to wrong
IP length, low byte. */
uip_stats_t fragerr; /* Number of packets dropped since they
were IP fragments. */
uip_stats_t chkerr; /* Number of packets dropped due to IP
checksum errors. */
uip_stats_t protoerr; /* Number of packets dropped since they
were neither ICMP, UDP nor TCP. */
} ip; /* IP statistics. */
struct
{
uip_stats_t drop; /* Number of dropped ICMP packets. */
uip_stats_t recv; /* Number of received ICMP packets. */
uip_stats_t sent; /* Number of sent ICMP packets. */
uip_stats_t typeerr; /* Number of ICMP packets with a wrong type. */
} icmp; /* ICMP statistics. */
uip_stats_t drop; /* Number of dropped ICMP packets. */
uip_stats_t recv; /* Number of received ICMP packets. */
uip_stats_t sent; /* Number of sent ICMP packets. */
uip_stats_t typeerr; /* Number of ICMP packets with a wrong type. */
} icmp; /* ICMP statistics. */
struct
{
uip_stats_t drop; /* Number of dropped TCP segments. */
uip_stats_t recv; /* Number of recived TCP segments. */
uip_stats_t sent; /* Number of sent TCP segments. */
uip_stats_t chkerr; /* Number of TCP segments with a bad checksum. */
uip_stats_t ackerr; /* Number of TCP segments with a bad ACK number. */
uip_stats_t rst; /* Number of recevied TCP RST (reset) segments. */
uip_stats_t rexmit; /* Number of retransmitted TCP segments. */
uip_stats_t syndrop; /* Number of dropped SYNs due to too few
connections was avaliable. */
uip_stats_t synrst; /* Number of SYNs for closed ports,
triggering a RST. */
} tcp; /* TCP statistics. */
uip_stats_t drop; /* Number of dropped TCP segments. */
uip_stats_t recv; /* Number of recived TCP segments. */
uip_stats_t sent; /* Number of sent TCP segments. */
uip_stats_t chkerr; /* Number of TCP segments with a bad checksum. */
uip_stats_t ackerr; /* Number of TCP segments with a bad ACK number. */
uip_stats_t rst; /* Number of recevied TCP RST (reset) segments. */
uip_stats_t rexmit; /* Number of retransmitted TCP segments. */
uip_stats_t syndrop; /* Number of dropped SYNs due to too few
connections was avaliable. */
uip_stats_t synrst; /* Number of SYNs for closed ports, triggering a RST. */
} tcp; /* TCP statistics. */
#ifdef CONFIG_NET_UDP
struct
{
uip_stats_t drop; /* Number of dropped UDP segments. */
uip_stats_t recv; /* Number of recived UDP segments. */
uip_stats_t sent; /* Number of sent UDP segments. */
uip_stats_t chkerr; /* Number of UDP segments with a bad checksum. */
} udp; /* UDP statistics. */
uip_stats_t drop; /* Number of dropped UDP segments. */
uip_stats_t recv; /* Number of recived UDP segments. */
uip_stats_t sent; /* Number of sent UDP segments. */
uip_stats_t chkerr; /* Number of UDP segments with a bad checksum. */
} udp; /* UDP statistics. */
#endif /* CONFIG_NET_UDP */
};
@ -282,28 +281,29 @@ struct uip_tcpip_hdr
/* IPv6 Ip header. */
uint8 vtc;
uint8 tcflow;
uint16 flow;
uint8 len[2];
uint8 proto, ttl;
uip_ip6addr_t srcipaddr;
uip_ip6addr_t destipaddr;
uint8 vtc; /* Bits 0-3: version, bits 4-7: traffic class (MS) */
uint8 tcf; /* Bits 0-3: traffic class (LS), 4-bits: flow label (MS) */
uint16 flow; /* 16-bit flow label (LS) */
uint8 len[2]; /* 16-bit Payload length */
uint8 proto; /* 8-bit Next header (same as IPv4 protocol field) */
uint8 ttl; /* 8-bit Hop limit (like IPv4 TTL field) */
uip_ip6addr_t srcipaddr; /* 128-bit Source address */
uip_ip6addr_t destipaddr; /* 128-bit Destination address */
#else /* CONFIG_NET_IPv6 */
/* IPv4 IP header. */
uint8 vhl; /* 8-bit Version (4) and header length (5 or 6) */
uint8 tos; /* 8-bit Type of service (e.g., 6=TCP) */
uint8 len[2]; /* 16-bit Total length */
uint8 ipid[2]; /* 16-bit Identification */
uint8 ipoffset[2]; /* 16-bit IP flags + fragment offset */
uint8 ttl; /* 8-bit Time to Live */
uint8 proto; /* 8-bit Protocol */
uint16 ipchksum; /* 16-bit Header checksum */
uint16 srcipaddr[2]; /* 32-bit Source IP address */
uint16 destipaddr[2]; /* 32-bit Destination IP address */
uint8 vhl; /* 8-bit Version (4) and header length (5 or 6) */
uint8 tos; /* 8-bit Type of service (e.g., 6=TCP) */
uint8 len[2]; /* 16-bit Total length */
uint8 ipid[2]; /* 16-bit Identification */
uint8 ipoffset[2]; /* 16-bit IP flags + fragment offset */
uint8 ttl; /* 8-bit Time to Live */
uint8 proto; /* 8-bit Protocol */
uint16 ipchksum; /* 16-bit Header checksum */
uint16 srcipaddr[2]; /* 32-bit Source IP address */
uint16 destipaddr[2]; /* 32-bit Destination IP address */
#endif /* CONFIG_NET_IPv6 */
@ -327,31 +327,31 @@ struct uip_icmpip_hdr
{
#ifdef CONFIG_NET_IPv6
/* IPv6 IP header. */
/* IPv6 Ip header. */
uint8 vtc;
uint8 tcf;
uint16 flow;
uint8 len[2];
uint8 proto;
uint8 ttl;
uip_ip6addr_t srcipaddr;
uip_ip6addr_t destipaddr;
uint8 vtc; /* Bits 0-3: version, bits 4-7: traffic class (MS) */
uint8 tcf; /* Bits 0-3: traffic class (LS), bits 4-7: flow label (MS) */
uint16 flow; /* 16-bit flow label (LS) */
uint8 len[2]; /* 16-bit Payload length */
uint8 proto; /* 8-bit Next header (same as IPv4 protocol field) */
uint8 ttl; /* 8-bit Hop limit (like IPv4 TTL field) */
uip_ip6addr_t srcipaddr; /* 128-bit Source address */
uip_ip6addr_t destipaddr; /* 128-bit Destination address */
#else /* CONFIG_NET_IPv6 */
/* IPv4 IP header. */
uint8 vhl; /* 8-bit Version (4) and header length (5 or 6) */
uint8 tos; /* 8-bit Type of service (e.g., 6=TCP) */
uint8 len[2]; /* 16-bit Total length */
uint8 ipid[2]; /* 16-bit Identification */
uint8 ipoffset[2]; /* 16-bit IP flags + fragment offset */
uint8 ttl; /* 8-bit Time to Live */
uint8 proto; /* 8-bit Protocol */
uint16 ipchksum; /* 16-bit Header checksum */
uint16 srcipaddr[2]; /* 32-bit Source IP address */
uint16 destipaddr[2]; /* 32-bit Destination IP address */
uint8 vhl; /* 8-bit Version (4) and header length (5 or 6) */
uint8 tos; /* 8-bit Type of service (e.g., 6=TCP) */
uint8 len[2]; /* 16-bit Total length */
uint8 ipid[2]; /* 16-bit Identification */
uint8 ipoffset[2]; /* 16-bit IP flags + fragment offset */
uint8 ttl; /* 8-bit Time to Live */
uint8 proto; /* 8-bit Protocol */
uint16 ipchksum; /* 16-bit Header checksum */
uint16 srcipaddr[2]; /* 32-bit Source IP address */
uint16 destipaddr[2]; /* 32-bit Destination IP address */
#endif /* CONFIG_NET_IPv6 */
@ -384,31 +384,31 @@ struct uip_udpip_hdr
{
#ifdef CONFIG_NET_IPv6
/* IPv6 IP header. */
/* IPv6 Ip header. */
uint8 vtc;
uint8 tcf;
uint16 flow;
uint8 len[2];
uint8 proto;
uint8 ttl;
uip_ip6addr_t srcipaddr;
uip_ip6addr_t destipaddr;
uint8 vtc; /* Bits 0-3: version, bits 4-7: traffic class (MS) */
uint8 tcf; /* Bits 0-3: traffic class (LS), 4-bits: flow label (MS) */
uint16 flow; /* 16-bit flow label (LS) */
uint8 len[2]; /* 16-bit Payload length */
uint8 proto; /* 8-bit Next header (same as IPv4 protocol field) */
uint8 ttl; /* 8-bit Hop limit (like IPv4 TTL field) */
uip_ip6addr_t srcipaddr; /* 128-bit Source address */
uip_ip6addr_t destipaddr; /* 128-bit Destination address */
#else /* CONFIG_NET_IPv6 */
/* IPv4 header. */
uint8 vhl; /* 8-bit Version (4) and header length (5 or 6) */
uint8 tos; /* 8-bit Type of service (e.g., 6=TCP) */
uint8 len[2]; /* 16-bit Total length */
uint8 ipid[2]; /* 16-bit Identification */
uint8 ipoffset[2]; /* 16-bit IP flags + fragment offset */
uint8 ttl; /* 8-bit Time to Live */
uint8 proto; /* 8-bit Protocol */
uint16 ipchksum; /* 16-bit Header checksum */
uint16 srcipaddr[2]; /* 32-bit Source IP address */
uint16 destipaddr[2]; /* 32-bit Destination IP address */
uint8 vhl; /* 8-bit Version (4) and header length (5 or 6) */
uint8 tos; /* 8-bit Type of service (e.g., 6=TCP) */
uint8 len[2]; /* 16-bit Total length */
uint8 ipid[2]; /* 16-bit Identification */
uint8 ipoffset[2]; /* 16-bit IP flags + fragment offset */
uint8 ttl; /* 8-bit Time to Live */
uint8 proto; /* 8-bit Protocol */
uint16 ipchksum; /* 16-bit Header checksum */
uint16 srcipaddr[2]; /* 32-bit Source IP address */
uint16 destipaddr[2]; /* 32-bit Destination IP address */
#endif /* CONFIG_NET_IPv6 */
@ -459,10 +459,6 @@ extern uint16 uip_urglen; /* Length of (received) urgent data */
extern struct uip_conn *uip_conn;
/* 4-byte array used for the 32-bit sequence number calculations.*/
extern uint8 uip_acc32[4];
/* The current UDP connection. */
#ifdef CONFIG_NET_UDP

23
net/uip/Make.defs
View file

@ -38,9 +38,21 @@ UIP_CSRCS =
ifeq ($(CONFIG_NET),y)
UIP_CSRCS += uip-initialize.c uip-arp.c uip.c uip-send.c uip-fw.c \
uip-neighbor.c uip-split.c uip-tcpconn.c uip-listen.c \
uip-poll.c uip-chksum.c
# Common network source files
UIP_CSRCS += uip-initialize.c uip-setipid.c uip-arp.c uip-input.c uip-send.c \
uip-fw.c uip-split.c uip-poll.c uip-chksum.c
ifeq ($(CONFIG_NET_IPv6),y)
UIP_CSRCS += uip-neighbor.c
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
# UDP source files
ifeq ($(CONFIG_NET_UDP),y)
@ -48,6 +60,11 @@ UIP_CSRCS += uip-udpconn.c uip-udppoll.c uip-udpsend.c uip-udpinput.c \
uip-udpcallback.c
endif
#ICMP source files
UIP_CSRCS += uip-icmpinput.c
endif

49
net/uip/uip-chksum.c
View file

@ -116,12 +116,15 @@ static uint16 upper_layer_chksum(struct uip_driver_s *dev, uint8 proto)
/* First sum pseudoheader. */
/* IP protocol and length fields. This addition cannot carry. */
sum = upper_layer_len + proto;
/* Sum IP source and destination addresses. */
sum = chksum(sum, (uint8 *)&BUF->srcipaddr, 2 * sizeof(uip_ipaddr_t));
/* Sum TCP header and data. */
sum = chksum(sum, &dev->d_buf[UIP_IPH_LEN + UIP_LLH_LEN], upper_layer_len);
return (sum == 0) ? 0xffff : htons(sum);
@ -143,35 +146,49 @@ static uint16 uip_icmp6chksum(struct uip_driver_s *dev)
/* Calculate the Internet checksum over a buffer. */
#if !UIP_ARCH_ADD32
void uip_add32(uint8 *op32, uint16 op16)
static void uip_carry32(uint8 *sum, uint16 op16)
{
uip_acc32[3] = op32[3] + (op16 & 0xff);
uip_acc32[2] = op32[2] + (op16 >> 8);
uip_acc32[1] = op32[1];
uip_acc32[0] = op32[0];
if (uip_acc32[2] < (op16 >> 8))
if (sum[2] < (op16 >> 8))
{
++uip_acc32[1];
if (uip_acc32[1] == 0)
++sum[1];
if (sum[1] == 0)
{
++uip_acc32[0];
++sum[0];
}
}
if (uip_acc32[3] < (op16 & 0xff))
if (sum[3] < (op16 & 0xff))
{
++uip_acc32[2];
if (uip_acc32[2] == 0)
++sum[2];
if (sum[2] == 0)
{
++uip_acc32[1];
if (uip_acc32[1] == 0)
++sum[1];
if (sum[1] == 0)
{
++uip_acc32[0];
++sum[0];
}
}
}
}
void uip_add32(const uint8 *op32, uint16 op16, uint8 *sum)
{
/* op32 and the sum are in network order (big-endian); op16 is host order. */
sum[3] = op32[3] + (op16 & 0xff);
sum[2] = op32[2] + (op16 >> 8);
sum[1] = op32[1];
sum[0] = op32[0];
uip_carry32(sum, op16);
}
void uip_incr32(uint8 *op32, uint16 op16)
{
op32[3] += (op16 & 0xff);
op32[2] += (op16 >> 8);
uip_carry32(op32, op16);
}
#endif /* UIP_ARCH_ADD32 */
#if !UIP_ARCH_CHKSUM

243
net/uip/uip-icmpinput.c Normal file
View file

@ -0,0 +1,243 @@
/****************************************************************************
* net/uip/uip-icmpinput.c
* Handling incoming ICMP/ICMP6 input
*
* Copyright (C) 2007 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <spudmonkey@racsa.co.cr>
*
* Adapted for NuttX from logic in uIP which also has a BSD-like license:
*
* Original author Adam Dunkels <adam@dunkels.com>
* Copyright () 2001-2003, Adam Dunkels.
* All rights reserved.
*
* 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. The name of the author may not be used to endorse or promote
* products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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 <nuttx/config.h>
#ifdef CONFIG_NET
#include <sys/types.h>
#include <debug.h>
#include <net/uip/uipopt.h>
#include <net/uip/uip.h>
#include <net/uip/uip-arch.h>
#include "uip-internal.h"
/****************************************************************************
* Definitions
****************************************************************************/
#define ICMPBUF ((struct uip_icmpip_hdr *)&dev->d_buf[UIP_LLH_LEN])
/****************************************************************************
* Public Variables
****************************************************************************/
/****************************************************************************
* Private Variables
****************************************************************************/
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: uip_icmpinput
*
* Description:
* Handle incoming ICMP/ICMP6 input
*
* Parameters:
* dev - The device driver structure containing the received ICMP/ICMP6
* packet
*
* Return:
* None
*
* Assumptions:
* Called from the interrupt level or with interrupts disabled.
*
****************************************************************************/
void uip_icmpinput(struct uip_driver_s *dev)
{
#ifdef CONFIG_NET_STATISTICS
uip_stat.icmp.recv++;
#endif
#ifndef CONFIG_NET_IPv6
/* ICMPv4 processing code follows. */
/* ICMP echo (i.e., ping) processing. This is simple, we only change the
* ICMP type from ECHO to ECHO_REPLY and adjust the ICMP checksum before
* we return the packet.
*/
if (ICMPBUF->type != ICMP_ECHO)
{
uip_log("icmp: not ICMP echo.");
goto typeerr;
}
/* If we are configured to use ping IP address assignment, we use
* the destination IP address of this ping packet and assign it to
* ourself.
*/
#if UIP_PINGADDRCONF
if (dev->d_ipaddr == 0)
{
dev->d_ipaddr = ICMPBUF->destipaddr;
}
#endif /* UIP_PINGADDRCONF */
ICMPBUF->type = ICMP_ECHO_REPLY;
if (ICMPBUF->icmpchksum >= HTONS(0xffff - (ICMP_ECHO << 8)))
{
ICMPBUF->icmpchksum += HTONS(ICMP_ECHO << 8) + 1;
}
else
{
ICMPBUF->icmpchksum += HTONS(ICMP_ECHO << 8);
}
/* Swap IP addresses. */
uiphdr_ipaddr_copy(ICMPBUF->destipaddr, ICMPBUF->srcipaddr);
uiphdr_ipaddr_copy(ICMPBUF->srcipaddr, &dev->d_ipaddr);
vdbg("Outgoing ICMP packet length: %d (%d)\n",
dev->d_len, (ICMPBUF->len[0] << 8) | ICMPBUF->len[1]);
#ifdef CONFIG_NET_STATISTICS
uip_stat.icmp.sent++;
uip_stat.ip.sent++;
#endif
return;
typeerr:
#ifdef CONFIG_NET_STATISTICS
uip_stat.icmp.typeerr++;
uip_stat.icmp.drop++;
#endif
dev->d_len = 0;
#else /* !CONFIG_NET_IPv6 */
/* If we get a neighbor solicitation for our address we should send
* a neighbor advertisement message back.
*/
if (ICMPBUF->type == ICMP6_NEIGHBOR_SOLICITATION)
{
if (uip_ipaddr_cmp(ICMPBUF->icmp6data, dev->d_ipaddr))
{
if (ICMPBUF->options[0] == ICMP6_OPTION_SOURCE_LINK_ADDRESS)
{
/* Save the sender's address in our neighbor list. */
uiphdr_neighbor_add(ICMPBUF->srcipaddr, &(ICMPBUF->options[2]));
}
/* We should now send a neighbor advertisement back to where the
* neighbor solicication came from.
*/
ICMPBUF->type = ICMP6_NEIGHBOR_ADVERTISEMENT;
ICMPBUF->flags = ICMP6_FLAG_S; /* Solicited flag. */
ICMPBUF->reserved1 = ICMPBUF->reserved2 = ICMPBUF->reserved3 = 0;
uiphdr_ipaddr_copy(ICMPBUF->destipaddr, ICMPBUF->srcipaddr);
uiphdr_ipaddr_copy(ICMPBUF->srcipaddr, dev->d_ipaddr);
ICMPBUF->options[0] = ICMP6_OPTION_TARGET_LINK_ADDRESS;
ICMPBUF->options[1] = 1; /* Options length, 1 = 8 bytes. */
memcpy(&(ICMPBUF->options[2]), &dev->d_mac, IFHWADDRLEN);
ICMPBUF->icmpchksum = 0;
ICMPBUF->icmpchksum = ~uip_icmp6chksum(dev);
}
else
{
goto drop;
}
}
else if (ICMPBUF->type == ICMP6_ECHO)
{
/* ICMP echo (i.e., ping) processing. This is simple, we only
* change the ICMP type from ECHO to ECHO_REPLY and update the
* ICMP checksum before we return the packet.
*/
ICMPBUF->type = ICMP6_ECHO_REPLY;
uiphdr_ipaddr_copy(ICMPBUF->destipaddr, ICMPBUF->srcipaddr);
uiphdr_ipaddr_copy(ICMPBUF->srcipaddr, dev->d_ipaddr);
ICMPBUF->icmpchksum = 0;
ICMPBUF->icmpchksum = ~uip_icmp6chksum(dev);
}
else
{
uip_log("icmp: unknown ICMP6 message.");
goto typeerr;
}
vdbg("Outgoing ICMP6 packet length: %d (%d)\n",
dev->d_len, (ICMPBUF->len[0] << 8) | ICMPBUF->len[1]);
#ifdef CONFIG_NET_STATISTICS
uip_stat.icmp.sent++;
uip_stat.ip.sent++;
#endif
return;
typeerr:
#ifdef CONFIG_NET_STATISTICS
uip_stat.icmp.typeerr++;
#endif
drop:
#ifdef CONFIG_NET_STATISTICS
uip_stat.icmp.drop++;
#endif
dev->d_len = 0;
#endif /* !CONFIG_NET_IPv6 */
}
#endif /* CONFIG_NET */

45
net/uip/uip-initialize.c
View file

@ -57,6 +57,51 @@
* Public Variables
****************************************************************************/
#if UIP_URGDATA > 0
void *uip_urgdata; /* urgent data (out-of-band data), if present. */
uint16 uip_urglen; /* Length of (received) urgent data */
#endif
/* The uip_flags variable is used for communication between the TCP/IP
* stack and the application program.
*/
uint8 uip_flags;
/* uip_conn always points to the current connection. */
struct uip_conn *uip_conn;
#ifdef CONFIG_NET_UDP
struct uip_udp_conn *uip_udp_conn;
#endif /* CONFIG_NET_UDP */
#ifdef CONFIG_NET_STATISTICS
struct uip_stats uip_stat;
#endif
/* Increasing number used for the IP ID field. */
uint16 g_ipid;
const uip_ipaddr_t all_ones_addr =
#ifdef CONFIG_NET_IPv6
{0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff};
#else /* CONFIG_NET_IPv6 */
{0xffffffff};
#endif /* CONFIG_NET_IPv6 */
const uip_ipaddr_t all_zeroes_addr =
#ifdef CONFIG_NET_IPv6
{0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000};
#else
{0x00000000};
#endif
#if UIP_REASSEMBLY && !defined(CONFIG_NET_IPv6)
uint8 uip_reasstmr;
#endif
/****************************************************************************
* Private Variables
****************************************************************************/

509
net/uip/uip-input.c Normal file
View file

@ -0,0 +1,509 @@
/****************************************************************************
* net/uip/uip-input.c
* The uIP TCP/IP stack code.
*
* Copyright (C) 2007 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <spudmonkey@racsa.co.cr>
*
* Adapted for NuttX from logic in uIP which also has a BSD-like license:
*
* uIP is an implementation of the TCP/IP protocol stack intended for
* small 8-bit and 16-bit microcontrollers.
*
* uIP provides the necessary protocols for Internet communication,
* with a very small code footprint and RAM requirements - the uIP
* code size is on the order of a few kilobytes and RAM usage is on
* the order of a few hundred bytes.
*
* Original author Adam Dunkels <adam@dunkels.com>
* Copyright () 2001-2003, Adam Dunkels.
* All rights reserved.
*
* 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. The name of the author may not be used to endorse or promote
* products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
*
****************************************************************************/
/****************************************************************************
* uIP is a small implementation of the IP, UDP and TCP protocols (as
* well as some basic ICMP stuff). The implementation couples the IP,
* UDP, TCP and the application layers very tightly. To keep the size
* of the compiled code down, this code frequently uses the goto
* statement. While it would be possible to break the uip_input()
* function into many smaller functions, this would increase the code
* size because of the overhead of parameter passing and the fact that
* the optimier would not be as efficient.
*
* The principle is that we have a small buffer, called the d_buf,
* in which the device driver puts an incoming packet. The TCP/IP
* stack parses the headers in the packet, and calls the
* application. If the remote host has sent data to the application,
* this data is present in the d_buf and the application read the
* data from there. It is up to the application to put this data into
* a byte stream if needed. The application will not be fed with data
* that is out of sequence.
*
* If the application whishes to send data to the peer, it should put
* its data into the d_buf. The d_appdata pointer points to the
* first available byte. The TCP/IP stack will calculate the
* checksums, and fill in the necessary header fields and finally send
* the packet back to the peer.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#ifdef CONFIG_NET
#include <sys/types.h>
#include <sys/ioctl.h>
#include <debug.h>
#include <string.h>
#include <net/uip/uipopt.h>
#include <net/uip/uip.h>
#include <net/uip/uip-arch.h>
#ifdef CONFIG_NET_IPv6
# include "uip-neighbor.h"
#endif /* CONFIG_NET_IPv6 */
#include "uip-internal.h"
/****************************************************************************
* Definitions
****************************************************************************/
/* Macros. */
#define BUF ((struct uip_tcpip_hdr *)&dev->d_buf[UIP_LLH_LEN])
#define FBUF ((struct uip_tcpip_hdr *)&uip_reassbuf[0])
/* IP fragment re-assembly */
#define IP_MF 0x20
#define UIP_REASS_BUFSIZE (UIP_BUFSIZE - UIP_LLH_LEN)
#define UIP_REASS_FLAG_LASTFRAG 0x01
/****************************************************************************
* Public Variables
****************************************************************************/
/****************************************************************************
* Private Variables
****************************************************************************/
#if UIP_REASSEMBLY && !defined(CONFIG_NET_IPv6)
static uint8 uip_reassbuf[UIP_REASS_BUFSIZE];
static uint8 uip_reassbitmap[UIP_REASS_BUFSIZE / (8 * 8)];
static const uint8 bitmap_bits[8] = {0xff, 0x7f, 0x3f, 0x1f, 0x0f, 0x07, 0x03, 0x01};
static uint16 uip_reasslen;
static uint8 uip_reassflags;
#endif /* UIP_REASSEMBLY */
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Function: uip_reass
*
* Description:
* IP fragment reassembly: not well-tested.
*
* Assumptions:
*
****************************************************************************/
#if UIP_REASSEMBLY && !defined(CONFIG_NET_IPv6)
static uint8 uip_reass(void)
{
uint16 offset, len;
uint16 i;
/* If ip_reasstmr is zero, no packet is present in the buffer, so we
* write the IP header of the fragment into the reassembly
* buffer. The timer is updated with the maximum age.
*/
if (uip_reasstmr == 0)
{
memcpy(uip_reassbuf, &BUF->vhl, UIP_IPH_LEN);
uip_reasstmr = UIP_REASS_MAXAGE;
uip_reassflags = 0;
/* Clear the bitmap. */
memset(uip_reassbitmap, 0, sizeof(uip_reassbitmap));
}
/* Check if the incoming fragment matches the one currently present
* in the reasembly buffer. If so, we proceed with copying the
* fragment into the buffer.
*/
if (uiphdr_addr_cmp(BUF->srcipaddr, FBUF->srcipaddr) &&
uiphdr_addr_cmp(BUF->destipaddr == FBUF->destipaddr) &&
BUF->g_ipid[0] == FBUF->g_ipid[0] && BUF->g_ipid[1] == FBUF->g_ipid[1])
{
len = (BUF->len[0] << 8) + BUF->len[1] - (BUF->vhl & 0x0f) * 4;
offset = (((BUF->ipoffset[0] & 0x3f) << 8) + BUF->ipoffset[1]) * 8;
/* If the offset or the offset + fragment length overflows the
* reassembly buffer, we discard the entire packet.
*/
if (offset > UIP_REASS_BUFSIZE || offset + len > UIP_REASS_BUFSIZE)
{
uip_reasstmr = 0;
goto nullreturn;
}
/* Copy the fragment into the reassembly buffer, at the right offset. */
memcpy(&uip_reassbuf[UIP_IPH_LEN + offset], (char *)BUF + (int)((BUF->vhl & 0x0f) * 4), len);
/* Update the bitmap. */
if (offset / (8 * 8) == (offset + len) / (8 * 8))
{
/* If the two endpoints are in the same byte, we only update that byte. */
uip_reassbitmap[offset / (8 * 8)] |=
bitmap_bits[(offset / 8 ) & 7] & ~bitmap_bits[((offset + len) / 8 ) & 7];
}
else
{
/* If the two endpoints are in different bytes, we update the bytes
* in the endpoints and fill the stuff inbetween with 0xff.
*/
uip_reassbitmap[offset / (8 * 8)] |= bitmap_bits[(offset / 8 ) & 7];
for (i = 1 + offset / (8 * 8); i < (offset + len) / (8 * 8); ++i)
{
uip_reassbitmap[i] = 0xff;
}
uip_reassbitmap[(offset + len) / (8 * 8)] |= ~bitmap_bits[((offset + len) / 8 ) & 7];
}
/* If this fragment has the More Fragments flag set to zero, we know that
* this is the last fragment, so we can calculate the size of the entire
* packet. We also set the IP_REASS_FLAG_LASTFRAG flag to indicate that
* we have received the final fragment.
*/
if ((BUF->ipoffset[0] & IP_MF) == 0)
{
uip_reassflags |= UIP_REASS_FLAG_LASTFRAG;
uip_reasslen = offset + len;
}
/* Finally, we check if we have a full packet in the buffer. We do this
* by checking if we have the last fragment and if all bits in the bitmap
* are set.
*/
if (uip_reassflags & UIP_REASS_FLAG_LASTFRAG)
{
/* Check all bytes up to and including all but the last byte in
* the bitmap.
*/
for (i = 0; i < uip_reasslen / (8 * 8) - 1; ++i)
{
if (uip_reassbitmap[i] != 0xff)
{
goto nullreturn;
}
}
/* Check the last byte in the bitmap. It should contain just the
* right amount of bits.
*/
if (uip_reassbitmap[uip_reasslen / (8 * 8)] != (uint8)~bitmap_bits[uip_reasslen / 8 & 7])
{
goto nullreturn;
}
/* If we have come this far, we have a full packet in the buffer,
* so we allocate a pbuf and copy the packet into it. We also reset
* the timer.
*/
uip_reasstmr = 0;
memcpy(BUF, FBUF, uip_reasslen);
/* Pretend to be a "normal" (i.e., not fragmented) IP packet from
* now on.
*/
BUF->ipoffset[0] = BUF->ipoffset[1] = 0;
BUF->len[0] = uip_reasslen >> 8;
BUF->len[1] = uip_reasslen & 0xff;
BUF->ipchksum = 0;
BUF->ipchksum = ~(uip_ipchksum(dev));
return uip_reasslen;
}
}
nullreturn:
return 0;
}
#endif /* UIP_REASSEMBLY */
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Function: uip_input
*
* Description:
*
* Assumptions:
*
****************************************************************************/
void uip_input(struct uip_driver_s *dev)
{
dev->d_snddata = &dev->d_buf[UIP_IPTCPH_LEN + UIP_LLH_LEN];
dev->d_appdata = &dev->d_buf[UIP_IPTCPH_LEN + UIP_LLH_LEN];
/* This is where the input processing starts. */
#ifdef CONFIG_NET_STATISTICS
uip_stat.ip.recv++;
#endif
/* Start of IP input header processing code. */
#ifdef CONFIG_NET_IPv6
/* Check validity of the IP header. */
if ((BUF->vtc & 0xf0) != 0x60)
{
/* IP version and header length. */
#ifdef CONFIG_NET_STATISTICS
uip_stat.ip.drop++;
uip_stat.ip.vhlerr++;
#endif
uip_log("ipv6: invalid version.");
goto drop;
}
#else /* CONFIG_NET_IPv6 */
/* Check validity of the IP header. */
if (BUF->vhl != 0x45)
{
/* IP version and header length. */
#ifdef CONFIG_NET_STATISTICS
uip_stat.ip.drop++;
uip_stat.ip.vhlerr++;
#endif
uip_log("ip: invalid version or header length.");
goto drop;
}
#endif /* CONFIG_NET_IPv6 */
/* Check the size of the packet. If the size reported to us in d_len is
* smaller the size reported in the IP header, we assume that the packet
* has been corrupted in transit. If the size of d_len is larger than the
* size reported in the IP packet header, the packet has been padded and
* we set d_len to the correct value.
*/
if ((BUF->len[0] << 8) + BUF->len[1] <= dev->d_len)
{
dev->d_len = (BUF->len[0] << 8) + BUF->len[1];
#ifdef CONFIG_NET_IPv6
/* The length reported in the IPv6 header is the length of the
* payload that follows the header. However, uIP uses the d_len
* variable for holding the size of the entire packet, including the
* IP header. For IPv4 this is not a problem as the length field in
* the IPv4 header contains the length of the entire packet. But
* for IPv6 we need to add the size of the IPv6 header (40 bytes).
*/
dev->d_len += 40;
#endif /* CONFIG_NET_IPv6 */
}
else
{
uip_log("ip: packet shorter than reported in IP header.");
goto drop;
}
#ifndef CONFIG_NET_IPv6
/* Check the fragment flag. */
if ((BUF->ipoffset[0] & 0x3f) != 0 || BUF->ipoffset[1] != 0)
{
#if UIP_REASSEMBLY
dev->d_len = uip_reass();
if (dev->d_len == 0)
{
goto drop;
}
#else /* UIP_REASSEMBLY */
#ifdef CONFIG_NET_STATISTICS
uip_stat.ip.drop++;
uip_stat.ip.fragerr++;
#endif
uip_log("ip: fragment dropped.");
goto drop;
#endif /* UIP_REASSEMBLY */
}
#endif /* CONFIG_NET_IPv6 */
if (uip_ipaddr_cmp(dev->d_ipaddr, all_zeroes_addr))
{
/* If we are configured to use ping IP address configuration and
* hasn't been assigned an IP address yet, we accept all ICMP
* packets.
*/
#if UIP_PINGADDRCONF && !CONFIG_NET_IPv6
if (BUF->proto == UIP_PROTO_ICMP)
{
uip_log("ip: possible ping config packet received.");
uip_icmpinput(dev);
goto done;
}
else
#endif /* UIP_PINGADDRCONF */
{
uip_log("ip: packet dropped since no address assigned.");
goto drop;
}
}
else
{
/* If IP broadcast support is configured, we check for a broadcast
* UDP packet, which may be destined to us.
*/
#if UIP_BROADCAST
if (BUF->proto == UIP_PROTO_UDP && uip_ipaddr_cmp(BUF->destipaddr, all_ones_addr)
{
uip_udpinput(dev);
return;
}
#endif /* UIP_BROADCAST */
/* Check if the packet is destined for our IP address. */
#ifndef CONFIG_NET_IPv6
if (!uip_ipaddr_cmp(uip_ip4addr_conv(BUF->destipaddr), dev->d_ipaddr))
{
#ifdef CONFIG_NET_STATISTICS
uip_stat.ip.drop++;
#endif
goto drop;
}
#else /* CONFIG_NET_IPv6 */
/* For IPv6, packet reception is a little trickier as we need to
* make sure that we listen to certain multicast addresses (all
* hosts multicast address, and the solicited-node multicast
* address) as well. However, we will cheat here and accept all
* multicast packets that are sent to the ff02::/16 addresses.
*/
if (!uip_ipaddr_cmp(BUF->destipaddr, dev->d_ipaddr) &&
BUF->destipaddr & HTONL(0xffff0000) != HTONL(0xff020000))
{
#ifdef CONFIG_NET_STATISTICS
uip_stat.ip.drop++;
#endif
goto drop;
}
#endif /* CONFIG_NET_IPv6 */
}
#ifndef CONFIG_NET_IPv6
if (uip_ipchksum(dev) != 0xffff)
{
/* Compute and check the IP header checksum. */
#ifdef CONFIG_NET_STATISTICS
uip_stat.ip.drop++;
uip_stat.ip.chkerr++;
#endif
uip_log("ip: bad checksum.");
goto drop;
}
#endif /* CONFIG_NET_IPv6 */
/* Everything looks good so far. Now process the incoming packet
* according to the protocol.
*/
switch (BUF->proto)
{
case UIP_PROTO_TCP: /* TCP input */
uip_tcpinput(dev);
break;
#ifdef CONFIG_NET_UDP
case UIP_PROTO_UDP: /* UDP input */
uip_udpinput(dev);
break;
#endif
/* Check for ICMP input */
#ifndef CONFIG_NET_IPv6
case UIP_PROTO_ICMP: /* ICMP input */
#else
case UIP_PROTO_ICMP6: /* ICMP6 input */
#endif
uip_icmpinput(dev);
break;
default: /* Unrecognized/unsupported protocol */
#ifdef CONFIG_NET_STATISTICS
uip_stat.ip.drop++;
uip_stat.ip.protoerr++;
#endif
uip_log("ip: Unrecognized IP protocol.");
goto drop;
}
/* Return and let the caller do any actual transmission. */
return;
drop:
dev->d_len = 0;
}
#endif /* CONFIG_NET */

72
net/uip/uip-internal.h
View file

@ -55,6 +55,37 @@
* Public Macro Definitions
****************************************************************************/
/* TCP definitions */
#define TCP_FIN 0x01
#define TCP_SYN 0x02
#define TCP_RST 0x04
#define TCP_PSH 0x08
#define TCP_ACK 0x10
#define TCP_URG 0x20
#define TCP_CTL 0x3f
#define TCP_OPT_END 0 /* End of TCP options list */
#define TCP_OPT_NOOP 1 /* "No-operation" TCP option */
#define TCP_OPT_MSS 2 /* Maximum segment size TCP option */
#define TCP_OPT_MSS_LEN 4 /* Length of TCP MSS option. */
/* ICMP/ICMP6 definitions */
#define ICMP_ECHO_REPLY 0
#define ICMP_ECHO 8
#define ICMP6_ECHO_REPLY 129
#define ICMP6_ECHO 128
#define ICMP6_NEIGHBOR_SOLICITATION 135
#define ICMP6_NEIGHBOR_ADVERTISEMENT 136
#define ICMP6_FLAG_S (1 << 6)
#define ICMP6_OPTION_SOURCE_LINK_ADDRESS 1
#define ICMP6_OPTION_TARGET_LINK_ADDRESS 2
/****************************************************************************
* Public Type Definitions
****************************************************************************/
@ -70,6 +101,10 @@ extern const uip_ipaddr_t all_zeroes_addr;
extern uint16 g_ipid;
#if UIP_REASSEMBLY && !defined(CONFIG_NET_IPv6)
extern uint8 uip_reasstmr;
#endif
/****************************************************************************
* Public Function Prototypes
****************************************************************************/
@ -90,12 +125,43 @@ EXTERN struct uip_conn *uip_tcplistener(uint16 portno);
EXTERN struct uip_conn *uip_tcpaccept(struct uip_tcpip_hdr *buf);
EXTERN void uip_tcpnextsequence(void);
/* Defined in uip-tcppoll.c *************************************************/
EXTERN void uip_tcppoll(struct uip_driver_s *dev, struct uip_conn *conn);
/* Defined in uip-udptimer.c ************************************************/
EXTERN void uip_udptimer(struct uip_driver_s *dev, struct uip_conn *conn);
/* Defined in uip_listen.c **************************************************/
EXTERN void uip_listeninit(void);
EXTERN boolean uip_islistener(uint16 port);
EXTERN int uip_accept(struct uip_conn *conn, uint16 portno);
/* Defined in uip-tcpsend.c *************************************************/
EXTERN void uip_tcpsend(struct uip_driver_s *dev, struct uip_conn *conn,
uint8 flags, uint16 len);
EXTERN void uip_tcpreset(struct uip_driver_s *dev);
EXTERN void uip_tcpack(struct uip_driver_s *dev, struct uip_conn *conn,
uint8 ack);
/* Defined in uip-tcpappsend.c **********************************************/
EXTERN void uip_tcpappsend(struct uip_driver_s *dev, struct uip_conn *conn,
uint8 result);
EXTERN void uip_tcprexmit(struct uip_driver_s *dev, struct uip_conn *conn,
uint8 result);
/* Defined in uip-tcpinput.c ************************************************/
EXTERN void uip_tcpinput(struct uip_driver_s *dev);
/* Defined in uip_uipcallback.c *********************************************/
EXTERN void uip_tcpcallback(struct uip_driver_s *dev);
#ifdef CONFIG_NET_UDP
/* Defined in uip_udpconn.c *************************************************/
@ -103,7 +169,7 @@ EXTERN void uip_udpinit(void);
EXTERN struct uip_udp_conn *uip_udpactive(struct uip_udpip_hdr *buf);
EXTERN struct uip_udp_conn *uip_nextudpconn(struct uip_udp_conn *conn);
/* Defined in uip-udppool.c *************************************************/
/* Defined in uip-udppoll.c *************************************************/
EXTERN void uip_udppoll(struct uip_driver_s *dev, struct uip_udp_conn *conn);
@ -120,6 +186,10 @@ EXTERN void uip_udpinput(struct uip_driver_s *dev);
EXTERN void uip_udpcallback(struct uip_driver_s *dev);
#endif /* CONFIG_NET_UDP */
/* Defined in uip-icmpinput.c ***********************************************/
EXTERN void uip_icmpinput(struct uip_driver_s *dev);
/* UIP logging **************************************************************/
/* This function must be provided by the application if CONFIG_NET_LOGGING

10
net/uip/uip-poll.c
View file

@ -107,7 +107,15 @@ int uip_poll(struct uip_driver_s *dev, uip_poll_callback_t callback, int event)
while ((conn = uip_nexttcpconn(conn)))
{
uip_conn = conn;
uip_interrupt(dev, event);
if (event == UIP_DRV_POLL)
{
uip_tcppoll(dev, conn);
}
else
{
uip_tcptimer(dev, conn);
}
if (callback(dev))
{
irqrestore(flags);

78
net/uip/uip-setipid.c Normal file
View file

@ -0,0 +1,78 @@
/****************************************************************************
* net/uip/uip-udpcallback.c
*
* Copyright (C) 2007 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <spudmonkey@racsa.co.cr>
*
*
* 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 <nuttx/config.h>
#ifdef CONFIG_NET
#include <sys/types.h>
#include <debug.h>
#include <net/uip/uip.h>
#include "uip-internal.h"
/****************************************************************************
* Private Data
****************************************************************************/
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Function: uip_setipid
*
* Description:
* This function may be used at boot time to set the initial ip_id.
*
* Assumptions:
*
****************************************************************************/
void uip_setipid(uint16 id)
{
g_ipid = id;
}
#endif /* CONFIG_NET */

8
net/uip/uip-split.c
View file

@ -102,18 +102,16 @@ void uip_split_output(struct uip_driver_s *dev)
/* dev->d_appdata += len1;*/
memcpy(dev->d_appdata, dev->d_appdata + len1, len2);
uip_add32(BUF->seqno, len1);
BUF->seqno[0] = uip_acc32[0];
BUF->seqno[1] = uip_acc32[1];
BUF->seqno[2] = uip_acc32[2];
BUF->seqno[3] = uip_acc32[3];
uip_incr32(BUF->seqno, len1);
/* 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));
#endif /* CONFIG_NET_IPv6 */

225
net/uip/uip-tcpappsend.c Normal file
View file

@ -0,0 +1,225 @@
/****************************************************************************
* net/uip/uip-tcpappsend.c
*
* Copyright (C) 2007 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <spudmonkey@racsa.co.cr>
*
* Adapted for NuttX from logic in uIP which also has a BSD-like license:
*
* Original author Adam Dunkels <adam@dunkels.com>
* Copyright () 2001-2003, Adam Dunkels.
* All rights reserved.
*
* 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. The name of the author may not be used to endorse or promote
* products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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 <nuttx/config.h>
#ifdef CONFIG_NET
#include <sys/types.h>
#include <debug.h>
#include <net/uip/uipopt.h>
#include <net/uip/uip.h>
#include <net/uip/uip-arch.h>
#include "uip-internal.h"
/****************************************************************************
* Definitions
****************************************************************************/
#define BUF ((struct uip_tcpip_hdr *)&dev->d_buf[UIP_LLH_LEN])
/****************************************************************************
* Public Variables
****************************************************************************/
/****************************************************************************
* Private Variables
****************************************************************************/
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: uip_tcpappsend
*
* Description:
* Handle application response
*
* Parameters:
* dev - The device driver structure to use in the send operation
* conn - The TCP connection structure holding connection information
* result - App result event sent
*
* Return:
* None
*
* Assumptions:
* Called from the interrupt level or with interrupts disabled.
*
****************************************************************************/
void uip_tcpappsend(struct uip_driver_s *dev, struct uip_conn *conn, uint8 result)
{
/* Handle the result based on the application response */
if (result & UIP_ABORT)
{
dev->d_sndlen = 0;
conn->tcpstateflags = UIP_CLOSED;
vdbg("TCP state: UIP_CLOSED\n");
uip_tcpsend(dev, conn, TCP_RST | TCP_ACK, UIP_IPTCPH_LEN);
}
else if (result & UIP_CLOSE)
{
conn->tcpstateflags = UIP_FIN_WAIT_1;
conn->len = 1;
conn->nrtx = 0;
vdbg("TCP state: UIP_FIN_WAIT_1\n");
dev->d_sndlen = 0;
uip_tcpsend(dev, conn, TCP_FIN | TCP_ACK, UIP_IPTCPH_LEN);
}
/* If d_sndlen > 0, the application has data to be sent. */
else if (dev->d_sndlen > 0)
{
/* If the connection has acknowledged data, the contents of
* the ->len variable should be discarded.
*/
if (result & UIP_ACKDATA)
{
conn->len = 0;
}
/* If the ->len variable is non-zero the connection has
* already data in transit and cannot send anymore right
* now.
*/
if (conn->len == 0)
{
/* The application cannot send more than what is
* allowed by the mss (the minumum of the MSS and the
* available window).
*/
if (dev->d_sndlen > conn->mss)
{
dev->d_sndlen = conn->mss;
}
/* Remember how much data we send out now so that we
* know when everything has been acknowledged.
*/
conn->len = dev->d_sndlen;
}
else
{
/* If the application already had unacknowledged data,
* we make sure that the application does not send
* (i.e., retransmit) out more than it previously sent
* out.
*/
dev->d_sndlen = conn->len;
}
/* Then handle the rest of the operation just as for the rexmit case */
conn->nrtx = 0;
uip_tcprexmit(dev, conn, result);
}
}
/****************************************************************************
* Name: uip_tcprexmit
*
* Description:
* Handle application retransmission
*
* Parameters:
* dev - The device driver structure to use in the send operation
* conn - The TCP connection structure holding connection information
* result - App result event sent
*
* Return:
* None
*
* Assumptions:
* Called from the interrupt level or with interrupts disabled.
*
****************************************************************************/
void uip_tcprexmit(struct uip_driver_s *dev, struct uip_conn *conn, uint8 result)
{
dev->d_appdata = dev->d_snddata;
/* If the application has data to be sent, or if the incoming packet had
* new data in it, we must send out a packet.
*/
if (dev->d_sndlen > 0 && conn->len > 0)
{
/* We always set the ACK flag in response packets adding the length of
* the IP and TCP headers.
*/
uip_tcpsend(dev, conn, TCP_ACK | TCP_PSH, conn->len + UIP_TCPIP_HLEN);
}
/* If there is no data to send, just send out a pure ACK if there is newdata. */
else if (result & UIP_NEWDATA)
{
uip_tcpsend(dev, conn, TCP_ACK, UIP_TCPIP_HLEN);
}
/* There is nothing to do -- drop the packet */
else
{
dev->d_len = 0;
}
}
#endif /* CONFIG_NET */

105
net/uip/uip-tcpcallback.c Normal file
View file

@ -0,0 +1,105 @@
/****************************************************************************
* net/uip/uip-tcpcallback.c
*
* Copyright (C) 2007 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <spudmonkey@racsa.co.cr>
*
*
* 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 <nuttx/config.h>
#ifdef CONFIG_NET
#include <sys/types.h>
#include <debug.h>
#include <net/uip/uipopt.h>
#include <net/uip/uip.h>
#include <net/uip/uip-arch.h>
#include "uip-internal.h"
/****************************************************************************
* Private Data
****************************************************************************/
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Function: uip_tcpcallback
*
* Description:
* Inform the application holding the TCP socket of a change in state.
*
* Assumptions:
* This function is called at the interrupt level with interrupts disabled.
*
****************************************************************************/
void uip_tcpcallback(struct uip_driver_s *dev)
{
vdbg("uip_flags: %02x\n", uip_flags);
/* Some sanity checking */
if (uip_conn)
{
/* Check if there is a data callback */
if (uip_conn->data_event)
{
/* Perform the callback */
uip_conn->data_event(dev, uip_conn->data_private);
}
/* Check if there is a connection-related event and a connection
* callback.
*/
if (((uip_flags & UIP_CONN_EVENTS) != 0) && uip_conn->connection_event)
{
/* Perform the callback */
uip_conn->connection_event(uip_conn->connection_private);
}
}
}
#endif /* CONFIG_NET */

753
net/uip/uip-tcpinput.c Normal file
View file

@ -0,0 +1,753 @@
/****************************************************************************
* net/uip/uip-tcpinput.c
* Handling incoming TCP input
*
* Copyright (C) 2007 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <spudmonkey@racsa.co.cr>
*
* Adapted for NuttX from logic in uIP which also has a BSD-like license:
*
* Original author Adam Dunkels <adam@dunkels.com>
* Copyright () 2001-2003, Adam Dunkels.
* All rights reserved.
*
* 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. The name of the author may not be used to endorse or promote
* products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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 <nuttx/config.h>
#ifdef CONFIG_NET
#include <sys/types.h>
#include <debug.h>
#include <net/uip/uipopt.h>
#include <net/uip/uip.h>
#include <net/uip/uip-arch.h>
#include "uip-internal.h"
/****************************************************************************
* Definitions
****************************************************************************/
#define BUF ((struct uip_tcpip_hdr *)&dev->d_buf[UIP_LLH_LEN])
/****************************************************************************
* Public Variables
****************************************************************************/
/****************************************************************************
* Private Variables
****************************************************************************/
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: uip_tcpinput
*
* Description:
* Handle incoming TCP input
*
* Parameters:
* dev - The device driver structure containing the received TCP packet.
*
* Return:
* None
*
* Assumptions:
* Called from the interrupt level or with interrupts disabled.
*
****************************************************************************/
void uip_tcpinput(struct uip_driver_s *dev)
{
register struct uip_conn *uip_connr = uip_conn;
uint16 tmp16;
uint8 opt;
int len;
int i;
#ifdef CONFIG_NET_STATISTICS
uip_stat.tcp.recv++;
#endif
/* Start of TCP input header processing code. */
if (uip_tcpchksum(dev) != 0xffff)
{
/* Compute and check the TCP checksum. */
#ifdef CONFIG_NET_STATISTICS
uip_stat.tcp.drop++;
uip_stat.tcp.chkerr++;
#endif
uip_log("tcp: bad checksum.");
goto drop;
}
/* Demultiplex this segment. First check any active connections. */
uip_connr = uip_tcpactive(BUF);
if (uip_connr)
{
goto found;
}
/* If we didn't find and active connection that expected the packet,
* either (1) this packet is an old duplicate, or (2) this is a SYN packet
* destined for a connection in LISTEN. If the SYN flag isn't set,
* it is an old packet and we send a RST.
*/
if ((BUF->flags & TCP_CTL) == TCP_SYN)
{
/* This is a SYN packet for a connection. Find the connection
* listening on this port.
*/
tmp16 = BUF->destport;
if (uip_islistener(tmp16))
{
/* We matched the incoming packet with a connection in LISTEN.
* We now need to create a new connection and send a SYNACK in
* response.
*/
/* First allocate a new connection structure and see if there is any
* user application to accept it.
*/
uip_connr = uip_tcpaccept(BUF);
if (uip_connr)
{
/* The connection structure was successfully allocated. Now see
* there is an application waiting to accept the connection (or at
* least queue it it for acceptance).
*/
if (uip_accept(uip_connr, tmp16) != OK)
{
/* No, then we have to give the connection back */
uip_tcpfree(uip_connr);
uip_connr = NULL;
}
}
if (!uip_connr)
{
/* Either (1) all available connections are in use, or (2) there is no
* application in place to accept the connection. We drop packet and hope that
* the remote end will retransmit the packet at a time when we
* have more spare connections or someone waiting to accept the connection.
*/
#ifdef CONFIG_NET_STATISTICS
uip_stat.tcp.syndrop++;
#endif
uip_log("tcp: found no unused connections.");
goto drop;
}
uip_incr32(uip_conn->rcv_nxt, 1);
uip_conn = uip_connr;
/* Parse the TCP MSS option, if present. */
if ((BUF->tcpoffset & 0xf0) > 0x50)
{
for (i = 0; i < ((BUF->tcpoffset >> 4) - 5) << 2 ;)
{
opt = dev->d_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + i];
if (opt == TCP_OPT_END)
{
/* End of options. */
break;
}
else if (opt == TCP_OPT_NOOP)
{
/* NOP option. */
++i;
}
else if (opt == TCP_OPT_MSS &&
dev->d_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + i] == TCP_OPT_MSS_LEN)
{
/* An MSS option with the right option length. */
tmp16 = ((uint16)dev->d_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 2 + i] << 8) |
(uint16)dev->d_buf[UIP_IPTCPH_LEN + UIP_LLH_LEN + 3 + i];
uip_connr->initialmss = uip_connr->mss =
tmp16 > UIP_TCP_MSS? UIP_TCP_MSS: tmp16;
/* And we are done processing options. */
break;
}
else
{
/* All other options have a length field, so that we easily
* can skip past them.
*/
if (dev->d_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + i] == 0)
{
/* If the length field is zero, the options are malformed
* and we don't process them further.
*/
break;
}
i += dev->d_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + i];
}
}
}
/* Our response will be a SYNACK. */
uip_tcpack(dev, uip_connr, TCP_ACK | TCP_SYN);
goto done;
}
}
/* This is (1) an old duplicate packet or (2) a SYN packet but with
* no matching listener found. Send RST packet in either case.
*/
/* We do not send resets in response to resets. */
if (BUF->flags & TCP_RST)
{
goto drop;
}
#ifdef CONFIG_NET_STATISTICS
uip_stat.tcp.synrst++;
#endif
uip_tcpreset(dev);
goto done;
found:
uip_conn = uip_connr;
uip_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
* sequence number of this reset is wihtin our advertised window
* before we accept the reset.
*/
if (BUF->flags & TCP_RST)
{
uip_connr->tcpstateflags = UIP_CLOSED;
vdbg("TCP state: UIP_CLOSED\n");
uip_log("tcp: got reset, aborting connection.");
uip_flags = UIP_ABORT;
uip_tcpcallback(dev);
goto drop;
}
/* Calculated the length of the data, if the application has sent
* any data to us.
*/
len = (BUF->tcpoffset >> 4) << 2;
/* d_len will contain the length of the actual TCP data. This is
* calculated by subtracing the length of the TCP header (in
* len) and the length of the IP header (20 bytes).
*/
dev->d_len -= (len + UIP_IPH_LEN);
/* First, check if the sequence number of the incoming packet is
* what we're expecting next. If not, we send out an ACK with the
* correct numbers in.
*/
if (!(((uip_connr->tcpstateflags & UIP_TS_MASK) == UIP_SYN_SENT) &&
((BUF->flags & TCP_CTL) == (TCP_SYN | TCP_ACK))))
{
if ((dev->d_len > 0 || ((BUF->flags & (TCP_SYN | TCP_FIN)) != 0)) &&
(BUF->seqno[0] != uip_connr->rcv_nxt[0] ||
BUF->seqno[1] != uip_connr->rcv_nxt[1] ||
BUF->seqno[2] != uip_connr->rcv_nxt[2] ||
BUF->seqno[3] != uip_connr->rcv_nxt[3]))
{
uip_tcpsend(dev, uip_connr, TCP_ACK, UIP_IPTCPH_LEN);
goto done;
}
}
/* Next, check if the incoming segment acknowledges any outstanding
* data. If so, we update the sequence number, reset the length of
* the outstanding data, calculate RTT estimations, and reset the
* retransmission timer.
*/
if ((BUF->flags & TCP_ACK) && uip_outstanding(uip_connr))
{
/* Temporary variables. */
uint8 acc32[4];
uip_add32(uip_connr->snd_nxt, uip_connr->len, acc32);
if (BUF->ackno[0] == acc32[0] && BUF->ackno[1] == acc32[1] &&
BUF->ackno[2] == acc32[2] && BUF->ackno[3] == acc32[3])
{
/* Update sequence number. */
uip_connr->snd_nxt[0] = acc32[0];
uip_connr->snd_nxt[1] = acc32[1];
uip_connr->snd_nxt[2] = acc32[2];
uip_connr->snd_nxt[3] = acc32[3];
/* Do RTT estimation, unless we have done retransmissions. */
if (uip_connr->nrtx == 0)
{
signed char m;
m = uip_connr->rto - uip_connr->timer;
/* This is taken directly from VJs original code in his paper */
m = m - (uip_connr->sa >> 3);
uip_connr->sa += m;
if (m < 0)
{
m = -m;
}
m = m - (uip_connr->sv >> 2);
uip_connr->sv += m;
uip_connr->rto = (uip_connr->sa >> 3) + uip_connr->sv;
}
/* Set the acknowledged flag. */
uip_flags = UIP_ACKDATA;
/* Reset the retransmission timer. */
uip_connr->timer = uip_connr->rto;
/* Reset length of outstanding data. */
uip_connr->len = 0;
}
}
/* Do different things depending on in what state the connection is. */
switch(uip_connr->tcpstateflags & UIP_TS_MASK)
{
/* CLOSED and LISTEN are not handled here. CLOSE_WAIT is not
* implemented, since we force the application to close when the
* peer sends a FIN (hence the application goes directly from
* ESTABLISHED to LAST_ACK).
*/
case UIP_SYN_RCVD:
/* In SYN_RCVD we have sent out a SYNACK in response to a SYN, and
* we are waiting for an ACK that acknowledges the data we sent
* out the last time. Therefore, we want to have the UIP_ACKDATA
* flag set. If so, we enter the ESTABLISHED state.
*/
if (uip_flags & UIP_ACKDATA)
{
uip_connr->tcpstateflags = UIP_ESTABLISHED;
uip_connr->len = 0;
vdbg("TCP state: UIP_ESTABLISHED\n");
uip_flags = UIP_CONNECTED;
if (dev->d_len > 0)
{
uip_flags |= UIP_NEWDATA;
uip_incr32(uip_conn->rcv_nxt, dev->d_len);
}
dev->d_sndlen = 0;
uip_tcpcallback(dev);
uip_tcpappsend(dev, uip_connr, uip_flags);
goto done;
}
goto drop;
case UIP_SYN_SENT:
/* In SYN_SENT, we wait for a SYNACK that is sent in response to
* our SYN. The rcv_nxt is set to sequence number in the SYNACK
* plus one, and we send an ACK. We move into the ESTABLISHED
* state.
*/
if ((uip_flags & UIP_ACKDATA) &&
(BUF->flags & TCP_CTL) == (TCP_SYN | TCP_ACK))
{
/* Parse the TCP MSS option, if present. */
if ((BUF->tcpoffset & 0xf0) > 0x50)
{
for (i = 0; i < ((BUF->tcpoffset >> 4) - 5) << 2 ;)
{
opt = dev->d_buf[UIP_IPTCPH_LEN + UIP_LLH_LEN + i];
if (opt == TCP_OPT_END)
{
/* End of options. */
break;
}
else if (opt == TCP_OPT_NOOP)
{
/* NOP option. */
++i;
}
else if (opt == TCP_OPT_MSS &&
dev->d_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + i] == TCP_OPT_MSS_LEN)
{
/* An MSS option with the right option length. */
tmp16 =
(dev->d_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 2 + i] << 8) |
dev->d_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 3 + i];
uip_connr->initialmss =
uip_connr->mss =
tmp16 > UIP_TCP_MSS? UIP_TCP_MSS: tmp16;
/* And we are done processing options. */
break;
}
else
{
/* All other options have a length field, so that we
* easily can skip past them.
*/
if (dev->d_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + i] == 0)
{
/* If the length field is zero, the options are
* malformed and we don't process them further.
*/
break;
}
i += dev->d_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + i];
}
}
}
uip_connr->tcpstateflags = UIP_ESTABLISHED;
uip_connr->rcv_nxt[0] = BUF->seqno[0];
uip_connr->rcv_nxt[1] = BUF->seqno[1];
uip_connr->rcv_nxt[2] = BUF->seqno[2];
uip_connr->rcv_nxt[3] = BUF->seqno[3];
vdbg("TCP state: UIP_ESTABLISHED\n");
uip_incr32(uip_conn->rcv_nxt, 1);
uip_flags = UIP_CONNECTED | UIP_NEWDATA;
uip_connr->len = 0;
dev->d_len = 0;
dev->d_sndlen = 0;
uip_tcpcallback(dev);
uip_tcpappsend(dev, uip_connr, uip_flags);
goto done;
}
/* Inform the application that the connection failed */
uip_flags = UIP_ABORT;
uip_tcpcallback(dev);
/* The connection is closed after we send the RST */
uip_conn->tcpstateflags = UIP_CLOSED;
vdbg("TCP state: UIP_CLOSED\n");
/* We do not send resets in response to resets. */
if (BUF->flags & TCP_RST)
{
goto drop;
}
uip_tcpreset(dev);
goto done;
case UIP_ESTABLISHED:
/* In the ESTABLISHED state, we call upon the application to feed
* data into the d_buf. If the UIP_ACKDATA flag is set, the
* application should put new data into the buffer, otherwise we are
* retransmitting an old segment, and the application should put that
* data into the buffer.
*
* If the incoming packet is a FIN, we should close the connection on
* this side as well, and we send out a FIN and enter the LAST_ACK
* state. We require that there is no outstanding data; otherwise the
* sequence numbers will be screwed up.
*/
if (BUF->flags & TCP_FIN && !(uip_connr->tcpstateflags & UIP_STOPPED))
{
if (uip_outstanding(uip_connr))
{
goto drop;
}
uip_incr32(uip_conn->rcv_nxt, dev->d_len + 1);
uip_flags |= UIP_CLOSE;
if (dev->d_len > 0)
{
uip_flags |= UIP_NEWDATA;
}
uip_tcpcallback(dev);
uip_connr->tcpstateflags = UIP_LAST_ACK;
uip_connr->len = 1;
uip_connr->nrtx = 0;
vdbg("TCP state: UIP_LAST_ACK\n");
uip_tcpsend(dev, uip_connr, TCP_FIN | TCP_ACK, UIP_IPTCPH_LEN);
goto done;
}
/* Check the URG flag. If this is set, the segment carries urgent
data that we must pass to the application. */
if ((BUF->flags & TCP_URG) != 0)
{
#if UIP_URGDATA > 0
uip_urglen = (BUF->urgp[0] << 8) | BUF->urgp[1];
if (uip_urglen > dev->d_len)
{
/* There is more urgent data in the next segment to come. */
uip_urglen = dev->d_len;
}
uip_incr32(uip_conn->rcv_nxt, uip_urglen);
dev->d_len -= uip_urglen;
uip_urgdata = dev->d_appdata;
dev->d_appdata += uip_urglen;
}
else
{
uip_urglen = 0;
#else /* UIP_URGDATA > 0 */
dev->d_appdata =
((uint8*)dev->d_appdata) + ((BUF->urgp[0] << 8) | BUF->urgp[1]);
dev->d_len -=
(BUF->urgp[0] << 8) | BUF->urgp[1];
#endif /* UIP_URGDATA > 0 */
}
/* If d_len > 0 we have TCP data in the packet, and we flag this
* by setting the UIP_NEWDATA flag and update the sequence number
* we acknowledge. If the application has stopped the dataflow
* using uip_stop(), we must not accept any data packets from the
* remote host.
*/
if (dev->d_len > 0 && !(uip_connr->tcpstateflags & UIP_STOPPED))
{
uip_flags |= UIP_NEWDATA;
uip_incr32(uip_conn->rcv_nxt, dev->d_len);
}
/* Check if the available buffer space advertised by the other end
* is smaller than the initial MSS for this connection. If so, we
* set the current MSS to the window size to ensure that the
* application does not send more data than the other end can
* handle.
*
* If the remote host advertises a zero window, we set the MSS to
* the initial MSS so that the application will send an entire MSS
* of data. This data will not be acknowledged by the receiver,
* and the application will retransmit it. This is called the
* "persistent timer" and uses the retransmission mechanim.
*/
tmp16 = ((uint16)BUF->wnd[0] << 8) + (uint16)BUF->wnd[1];
if (tmp16 > uip_connr->initialmss || tmp16 == 0)
{
tmp16 = uip_connr->initialmss;
}
uip_connr->mss = tmp16;
/* If this packet constitutes an ACK for outstanding data (flagged
* by the UIP_ACKDATA flag, we should call the application since it
* might want to send more data. If the incoming packet had data
* from the peer (as flagged by the UIP_NEWDATA flag), the
* application must also be notified.
*
* When the application is called, the d_len field
* contains the length of the incoming data. The application can
* access the incoming data through the global pointer
* d_appdata, which usually points UIP_IPTCPH_LEN + UIP_LLH_LEN
* bytes into the d_buf array.
*
* If the application wishes to send any data, this data should be
* put into the d_appdata and the length of the data should be
* put into d_len. If the application don't have any data to
* send, d_len must be set to 0.
*/
if (uip_flags & (UIP_NEWDATA | UIP_ACKDATA))
{
dev->d_sndlen = 0;
uip_tcpcallback(dev);
uip_tcpappsend(dev, uip_connr, uip_flags);
goto done;
}
goto drop;
case UIP_LAST_ACK:
/* We can close this connection if the peer has acknowledged our
* FIN. This is indicated by the UIP_ACKDATA flag.
*/
if (uip_flags & UIP_ACKDATA)
{
uip_connr->tcpstateflags = UIP_CLOSED;
vdbg("TCP state: UIP_CLOSED\n");
uip_flags = UIP_CLOSE;
uip_tcpcallback(dev);
}
break;
case UIP_FIN_WAIT_1:
/* The application has closed the connection, but the remote host
* hasn't closed its end yet. Thus we do nothing but wait for a
* FIN from the other side.
*/
if (dev->d_len > 0)
{
uip_incr32(uip_conn->rcv_nxt, dev->d_len);
}
if (BUF->flags & TCP_FIN)
{
if (uip_flags & UIP_ACKDATA)
{
uip_connr->tcpstateflags = UIP_TIME_WAIT;
uip_connr->timer = 0;
uip_connr->len = 0;
vdbg("TCP state: UIP_TIME_WAIT\n");
}
else
{
uip_connr->tcpstateflags = UIP_CLOSING;
vdbg("TCP state: UIP_CLOSING\n");
}
uip_incr32(uip_conn->rcv_nxt, 1);
uip_flags = UIP_CLOSE;
uip_tcpcallback(dev);
uip_tcpsend(dev, uip_connr, TCP_ACK, UIP_IPTCPH_LEN);
goto done;
}
else if (uip_flags & UIP_ACKDATA)
{
uip_connr->tcpstateflags = UIP_FIN_WAIT_2;
uip_connr->len = 0;
vdbg("TCP state: UIP_FIN_WAIT_2\n");
goto drop;
}
if (dev->d_len > 0)
{
uip_tcpsend(dev, uip_connr, TCP_ACK, UIP_IPTCPH_LEN);
goto done;
}
goto drop;
case UIP_FIN_WAIT_2:
if (dev->d_len > 0)
{
uip_incr32(uip_conn->rcv_nxt, dev->d_len);
}
if (BUF->flags & TCP_FIN)
{
uip_connr->tcpstateflags = UIP_TIME_WAIT;
uip_connr->timer = 0;
vdbg("TCP state: UIP_TIME_WAIT\n");
uip_incr32(uip_conn->rcv_nxt, 1);
uip_flags = UIP_CLOSE;
uip_tcpcallback(dev);
uip_tcpsend(dev, uip_connr, TCP_ACK, UIP_IPTCPH_LEN);
goto done;
}
if (dev->d_len > 0)
{
uip_tcpsend(dev, uip_connr, TCP_ACK, UIP_IPTCPH_LEN);
goto done;
}
goto drop;
case UIP_TIME_WAIT:
uip_tcpsend(dev, uip_connr, TCP_ACK, UIP_IPTCPH_LEN);
goto done;
case UIP_CLOSING:
if (uip_flags & UIP_ACKDATA)
{
uip_connr->tcpstateflags = UIP_TIME_WAIT;
uip_connr->timer = 0;
vdbg("TCP state: UIP_TIME_WAIT\n");
}
}
goto drop;
done:
uip_flags = 0;
return;
drop:
uip_flags = 0;
dev->d_len = 0;
}
#endif /* CONFIG_NET */

126
net/uip/uip-tcppoll.c Normal file
View file

@ -0,0 +1,126 @@
/****************************************************************************
* net/uip/uip-tcppoll.c
* Poll for the availability of TCP TX data
*
* Copyright (C) 2007 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <spudmonkey@racsa.co.cr>
*
* Adapted for NuttX from logic in uIP which also has a BSD-like license:
*
* Original author Adam Dunkels <adam@dunkels.com>
* Copyright () 2001-2003, Adam Dunkels.
* All rights reserved.
*
* 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. The name of the author may not be used to endorse or promote
* products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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 <nuttx/config.h>
#ifdef CONFIG_NET
#include <sys/types.h>
#include <debug.h>
#include <net/uip/uipopt.h>
#include <net/uip/uip.h>
#include <net/uip/uip-arch.h>
#include "uip-internal.h"
/****************************************************************************
* Definitions
****************************************************************************/
/****************************************************************************
* Public Variables
****************************************************************************/
/****************************************************************************
* Private Variables
****************************************************************************/
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: uip_tcppoll
*
* Description:
* Poll a TCP connection structure for availability of TX data
*
* Parameters:
* dev - The device driver structure to use in the send operation
* conn - The TCP "connection" to poll for TX data
*
* Return:
* None
*
* Assumptions:
* Called from the interrupt level or with interrupts disabled.
*
****************************************************************************/
void uip_tcppoll(struct uip_driver_s *dev, struct uip_conn *conn)
{
/* Verify that the connection is established and if the connection has
* oustanding (unacknowledged) sent data.
*/
if ((conn->tcpstateflags & UIP_TS_MASK) == UIP_ESTABLISHED &&
!uip_outstanding(conn))
{
/* Set up for the callback */
dev->d_snddata = &dev->d_buf[UIP_IPTCPH_LEN + UIP_LLH_LEN];
dev->d_appdata = &dev->d_buf[UIP_IPTCPH_LEN + UIP_LLH_LEN];
/* Perfom the callback */
uip_flags = UIP_POLL;
uip_tcpcallback(dev);
/* Handle the callback response */
uip_tcpappsend(dev, conn, uip_flags);
}
else
{
/* Nothing to do for this connection */
dev->d_len = 0;
}
}
#endif /* CONFIG_NET */

365
net/uip/uip-tcpsend.c Normal file
View file

@ -0,0 +1,365 @@
/****************************************************************************
* net/uip/uip-tcpsend.c
*
* Copyright (C) 2007 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <spudmonkey@racsa.co.cr>
*
* Adapted for NuttX from logic in uIP which also has a BSD-like license:
*
* Original author Adam Dunkels <adam@dunkels.com>
* Copyright () 2001-2003, Adam Dunkels.
* All rights reserved.
*
* 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. The name of the author may not be used to endorse or promote
* products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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 <nuttx/config.h>
#ifdef CONFIG_NET
#include <sys/types.h>
#include <debug.h>
#include <net/uip/uipopt.h>
#include <net/uip/uip.h>
#include <net/uip/uip-arch.h>
#include "uip-internal.h"
/****************************************************************************
* Definitions
****************************************************************************/
#define BUF ((struct uip_tcpip_hdr *)&dev->d_buf[UIP_LLH_LEN])
/****************************************************************************
* Public Variables
****************************************************************************/
/****************************************************************************
* Private Variables
****************************************************************************/
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Name: uip_tcpsendcomplete
*
* Description:
* Complete the final portions of the send operation. This function sets
* up IP header and computes the TCP checksum
*
* Parameters:
* dev - The device driver structure to use in the send operation
*
* Return:
* None
*
* Assumptions:
* Called from the interrupt level or with interrupts disabled.
*
****************************************************************************/
static void uip_tcpsendcomplete(struct uip_driver_s *dev)
{
BUF->ttl = UIP_TTL;
#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);
#else /* CONFIG_NET_IPv6 */
BUF->len[0] = (dev->d_len >> 8);
BUF->len[1] = (dev->d_len & 0xff);
#endif /* CONFIG_NET_IPv6 */
BUF->urgp[0] = BUF->urgp[1] = 0;
/* Calculate TCP checksum. */
BUF->tcpchksum = 0;
BUF->tcpchksum = ~(uip_tcpchksum(dev));
#ifdef CONFIG_NET_IPv6
BUF->vtc = 0x60;
BUF->tcf = 0x00;
BUF->flow = 0x00;
#else /* CONFIG_NET_IPv6 */
BUF->vhl = 0x45;
BUF->tos = 0;
BUF->ipoffset[0] = 0;
BUF->ipoffset[1] = 0;
++g_ipid;
BUF->ipid[0] = g_ipid >> 8;
BUF->ipid[1] = g_ipid & 0xff;
/* Calculate IP checksum. */
BUF->ipchksum = 0;
BUF->ipchksum = ~(uip_ipchksum(dev));
#endif /* CONFIG_NET_IPv6 */
vdbg("Outgoing TCP packet length: %d (%d)\n",
dev->d_len, (BUF->len[0] << 8) | BUF->len[1]);
#ifdef CONFIG_NET_STATISTICS
uip_stat.tcp.sent++;
uip_stat.ip.sent++;
#endif
}
/****************************************************************************
* Name: uip_tcpsendcommon
*
* Description:
* We're done with the input processing. We are now ready to send a reply
* Our job is to fill in all the fields of the TCP and IP headers before
* calculating the checksum and finally send the packet.
*
* Parameters:
* dev - The device driver structure to use in the send operation
* conn - The TCP connection structure holding connection information
*
* Return:
* None
*
* Assumptions:
* Called from the interrupt level or with interrupts disabled.
*
****************************************************************************/
static void uip_tcpsendcommon(struct uip_driver_s *dev, struct uip_conn *conn)
{
BUF->ackno[0] = conn->rcv_nxt[0];
BUF->ackno[1] = conn->rcv_nxt[1];
BUF->ackno[2] = conn->rcv_nxt[2];
BUF->ackno[3] = conn->rcv_nxt[3];
BUF->seqno[0] = conn->snd_nxt[0];
BUF->seqno[1] = conn->snd_nxt[1];
BUF->seqno[2] = conn->snd_nxt[2];
BUF->seqno[3] = conn->snd_nxt[3];
BUF->proto = UIP_PROTO_TCP;
BUF->srcport = conn->lport;
BUF->destport = conn->rport;
uiphdr_ipaddr_copy(BUF->srcipaddr, &dev->d_ipaddr);
uiphdr_ipaddr_copy(BUF->destipaddr, &conn->ripaddr);
if (conn->tcpstateflags & UIP_STOPPED)
{
/* If the connection has issued uip_stop(), we advertise a zero
* window so that the remote host will stop sending data.
*/
BUF->wnd[0] = 0;
BUF->wnd[1] = 0;
}
else
{
BUF->wnd[0] = ((UIP_RECEIVE_WINDOW) >> 8);
BUF->wnd[1] = ((UIP_RECEIVE_WINDOW) & 0xff);
}
/* Finish the IP portion of the message, calculate checksums and send
* the message.
*/
uip_tcpsendcomplete(dev);
}
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: uip_tcpsend
*
* Description:
* Setup to send a TCP packet
*
* Parameters:
* dev - The device driver structure to use in the send operation
* conn - The TCP connection structure holding connection information
* flags - flags to apply to the TCP header
* len - length of the message
*
* Return:
* None
*
* Assumptions:
* Called from the interrupt level or with interrupts disabled.
*
****************************************************************************/
void uip_tcpsend(struct uip_driver_s *dev, struct uip_conn *conn, uint8 flags, uint16 len)
{
BUF->flags = flags;
dev->d_len = len;
BUF->tcpoffset = (UIP_TCPH_LEN / 4) << 4;
uip_tcpsendcommon(dev, conn);
}
/****************************************************************************
* Name: uip_tcpreset
*
* Description:
* Send a TCP reset (no-data) message
*
* Parameters:
* dev - The device driver structure to use in the send operation
*
* Return:
* None
*
* Assumptions:
* Called from the interrupt level or with interrupts disabled.
*
****************************************************************************/
void uip_tcpreset(struct uip_driver_s *dev)
{
uint16 tmp16;
uint8 seqbyte;
#ifdef CONFIG_NET_STATISTICS
uip_stat.tcp.rst++;
#endif
BUF->flags = TCP_RST | TCP_ACK;
dev->d_len = UIP_IPTCPH_LEN;
BUF->tcpoffset = 5 << 4;
/* Flip the seqno and ackno fields in the TCP header. */
seqbyte = BUF->seqno[3];
BUF->seqno[3] = BUF->ackno[3];
BUF->ackno[3] = seqbyte;
seqbyte = BUF->seqno[2];
BUF->seqno[2] = BUF->ackno[2];
BUF->ackno[2] = seqbyte;
seqbyte = BUF->seqno[1];
BUF->seqno[1] = BUF->ackno[1];
BUF->ackno[1] = seqbyte;
seqbyte = BUF->seqno[0];
BUF->seqno[0] = BUF->ackno[0];
BUF->ackno[0] = seqbyte;
/* We also have to increase the sequence number we are
* acknowledging. If the least significant byte overflowed, we need
* to propagate the carry to the other bytes as well.
*/
if (++(BUF->ackno[3]) == 0)
{
if (++(BUF->ackno[2]) == 0)
{
if (++(BUF->ackno[1]) == 0)
{
++(BUF->ackno[0]);
}
}
}
/* Swap port numbers. */
tmp16 = BUF->srcport;
BUF->srcport = BUF->destport;
BUF->destport = tmp16;
/* Swap IP addresses. */
uiphdr_ipaddr_copy(BUF->destipaddr, BUF->srcipaddr);
uiphdr_ipaddr_copy(BUF->srcipaddr, dev->d_ipaddr);
/* And send out the RST packet */
uip_tcpsendcomplete(dev);
}
/****************************************************************************
* Name: uip_tcpack
*
* Description:
* Send the SYN or SYNACK response.
*
* Parameters:
* dev - The device driver structure to use in the send operation
* conn - The TCP connection structure holding connection information
* ack - The ACK response to send
*
* Return:
* None
*
* Assumptions:
* Called from the interrupt level or with interrupts disabled.
*
****************************************************************************/
void uip_tcpack(struct uip_driver_s *dev, struct uip_conn *conn, uint8 ack)
{
/* Save the ACK bits */
BUF->flags = ack;
/* We send out the TCP Maximum Segment Size option with our ack. */
BUF->optdata[0] = TCP_OPT_MSS;
BUF->optdata[1] = TCP_OPT_MSS_LEN;
BUF->optdata[2] = (UIP_TCP_MSS) / 256;
BUF->optdata[3] = (UIP_TCP_MSS) & 255;
dev->d_len = UIP_IPTCPH_LEN + TCP_OPT_MSS_LEN;
BUF->tcpoffset = ((UIP_TCPH_LEN + TCP_OPT_MSS_LEN) / 4) << 4;
/* Complete the common portions of the TCP message */
uip_tcpsendcommon(dev, conn);
}
#endif /* CONFIG_NET */

241
net/uip/uip-tcptimer.c Normal file
View file

@ -0,0 +1,241 @@
/****************************************************************************
* net/uip/uip-tcptimer.c
* Poll for the availability of TCP TX data
*
* Copyright (C) 2007 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <spudmonkey@racsa.co.cr>
*
* Adapted for NuttX from logic in uIP which also has a BSD-like license:
*
* Original author Adam Dunkels <adam@dunkels.com>
* Copyright () 2001-2003, Adam Dunkels.
* All rights reserved.
*
* 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. The name of the author may not be used to endorse or promote
* products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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 <nuttx/config.h>
#ifdef CONFIG_NET
#include <sys/types.h>
#include <debug.h>
#include <net/uip/uipopt.h>
#include <net/uip/uip.h>
#include <net/uip/uip-arch.h>
#include "uip-internal.h"
/****************************************************************************
* Definitions
****************************************************************************/
/****************************************************************************
* Public Variables
****************************************************************************/
/****************************************************************************
* Private Variables
****************************************************************************/
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: uip_tcptimer
*
* Description:
* Handle a TCP timer expiration for the provided TCP connection
*
* Parameters:
* dev - The device driver structure to use in the send operation
* conn - The TCP "connection" to poll for TX data
*
* Return:
* None
*
* Assumptions:
* Called from the interrupt level or with interrupts disabled.
*
****************************************************************************/
void uip_tcptimer(struct uip_driver_s *dev, struct uip_conn *conn)
{
dev->d_snddata = &dev->d_buf[UIP_IPTCPH_LEN + UIP_LLH_LEN];
dev->d_appdata = &dev->d_buf[UIP_IPTCPH_LEN + UIP_LLH_LEN];
/* Increment the timer used by the reassembly logic */
#if UIP_REASSEMBLY
if (uip_reasstmr != 0)
{
uip_reasstmr++;
}
#endif /* UIP_REASSEMBLY */
/* Increase the TCP sequence number */
uip_tcpnextsequence();
/* Reset the length variables. */
dev->d_len = 0;
dev->d_sndlen = 0;
/* Check if the connection is in a state in which we simply wait
* for the connection to time out. If so, we increase the
* connection's timer and remove the connection if it times
* out.
*/
if (conn->tcpstateflags == UIP_TIME_WAIT || conn->tcpstateflags == UIP_FIN_WAIT_2)
{
(conn->timer)++;
if (conn->timer == UIP_TIME_WAIT_TIMEOUT)
{
conn->tcpstateflags = UIP_CLOSED;
vdbg("TCP state: UIP_CLOSED\n");
}
}
else if (conn->tcpstateflags != UIP_CLOSED)
{
/* If the connection has outstanding data, we increase the
* connection's timer and see if it has reached the RTO value
* in which case we retransmit.
*/
if (uip_outstanding(conn))
{
if (conn->timer-- == 0)
{
if (conn->nrtx == UIP_MAXRTX ||
((conn->tcpstateflags == UIP_SYN_SENT ||
conn->tcpstateflags == UIP_SYN_RCVD) &&
conn->nrtx == UIP_MAXSYNRTX))
{
conn->tcpstateflags = UIP_CLOSED;
vdbg("TCP state: UIP_CLOSED\n");
/* We call uip_tcpcallback() with uip_flags set to
* UIP_TIMEDOUT to inform the application that the
* connection has timed out.
*/
uip_flags = UIP_TIMEDOUT;
uip_tcpcallback(dev);
/* We also send a reset packet to the remote host. */
uip_tcpsend(dev, conn, TCP_RST | TCP_ACK, UIP_IPTCPH_LEN);
goto done;
}
/* Exponential backoff. */
conn->timer = UIP_RTO << (conn->nrtx > 4 ? 4: conn->nrtx);
++(conn->nrtx);
/* Ok, so we need to retransmit. We do this differently
* depending on which state we are in. In ESTABLISHED, we
* call upon the application so that it may prepare the
* data for the retransmit. In SYN_RCVD, we resend the
* SYNACK that we sent earlier and in LAST_ACK we have to
* retransmit our FINACK.
*/
#ifdef CONFIG_NET_STATISTICS
uip_stat.tcp.rexmit++;
#endif
switch(conn->tcpstateflags & UIP_TS_MASK)
{
case UIP_SYN_RCVD:
/* In the SYN_RCVD state, we should retransmit our
* SYNACK.
*/
uip_tcpack(dev, conn, TCP_ACK | TCP_SYN);
goto done;
case UIP_SYN_SENT:
/* In the SYN_SENT state, we retransmit out SYN. */
uip_tcpack(dev, conn, TCP_SYN);
goto done;
case UIP_ESTABLISHED:
/* In the ESTABLISHED state, we call upon the application
* to do the actual retransmit after which we jump into
* the code for sending out the packet.
*/
uip_flags = UIP_REXMIT;
uip_tcpcallback(dev);
uip_tcprexmit(dev, conn, uip_flags);
goto done;
case UIP_FIN_WAIT_1:
case UIP_CLOSING:
case UIP_LAST_ACK:
/* In all these states we should retransmit a FINACK. */
uip_tcpsend(dev, conn, TCP_FIN | TCP_ACK, UIP_IPTCPH_LEN);
goto done;
}
}
}
else if ((conn->tcpstateflags & UIP_TS_MASK) == UIP_ESTABLISHED)
{
/* If there was no need for a retransmission, we poll the
* application for new data.
*/
uip_flags = UIP_POLL;
uip_tcpcallback(dev);
uip_tcpappsend(dev, conn, uip_flags);
goto done;
}
}
/* Nothing to be done */
dev->d_len = 0;
done:
uip_flags = 0;
return;
}
#endif /* CONFIG_NET */

5
net/uip/uip-udpsend.c
View file

@ -1,6 +1,5 @@
/****************************************************************************
* net/uip/uip-udpsend.c
* Poll for the availability of UDP TX data
*
* Copyright (C) 2007 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <spudmonkey@racsa.co.cr>
@ -115,8 +114,8 @@ void uip_udpsend(struct uip_driver_s *dev, struct uip_udp_conn *conn)
UDPBUF->flow = 0x00;
UDPBUF->len[0] = (dev->d_sndlen >> 8);
UDPBUF->len[1] = (dev->d_sndlen & 0xff);
UDPBUF->proto = UIP_PROTO_UDP;
UDPBUF->ttl = conn->ttl;
UDPBUF->nexthdr = UIP_PROTO_UDP;
UDPBUF->hoplimit = conn->ttl;
uip_ipaddr_copy(UDPBUF->srcipaddr, &dev->d_ipaddr);
uip_ipaddr_copy(UDPBUF->destipaddr, &conn->ripaddr);

1767
net/uip/uip.c
View file

File diff suppressed because it is too large Load diff