sergiotarxz/nuttx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Networking: Seperate tcp_input() and udp_input() into seprate functions tcp_ipv4_input(), tcp_ipv6_input(), udp_ipv4_input(), and upd_ipv6_input() than can deal will the data offsets caused by the differing sizes of the IP header.

Browse Source
This commit is contained in:
Gregory Nutt 2015-01-15 15:06:46 -06:00
parent 60e50ff3b5
commit 630366272a
18 changed files with 438 additions and 200 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
include/nuttx/net/netconfig.h
View File

@ -211,21 +211,21 @@
#endif #endif
/* The UDP maximum packet size. This is should not be to set to more /* The UDP maximum packet size. This is should not be to set to more
* than NET_DEV_MTU(d) - NET_LL_HDRLEN(dev) - IPUDP_HDRLEN. * than NET_DEV_MTU(d) - NET_LL_HDRLEN(dev) - IPv4UDP_HDRLEN.
*/ */
#define UDP_MSS(d) (NET_DEV_MTU(d) - NET_LL_HDRLEN(d) - IPUDP_HDRLEN) #define UDP_MSS(d) (NET_DEV_MTU(d) - NET_LL_HDRLEN(d) - IPv4UDP_HDRLEN)
#ifdef CONFIG_NET_ETHERNET #ifdef CONFIG_NET_ETHERNET
# define MIN_UDP_MSS (CONFIG_NET_ETH_MTU - ETH_HDRLEN - IPUDP_HDRLEN) # define MIN_UDP_MSS (CONFIG_NET_ETH_MTU - ETH_HDRLEN - IPv4UDP_HDRLEN)
#else /* if defined(CONFIG_NET_SLIP) */ #else /* if defined(CONFIG_NET_SLIP) */
# define MIN_UDP_MSS (CONFIG_NET_SLIP_MTU - IPUDP_HDRLEN) # define MIN_UDP_MSS (CONFIG_NET_SLIP_MTU - IPv4UDP_HDRLEN)
#endif #endif
#ifdef CONFIG_NET_SLIP #ifdef CONFIG_NET_SLIP
# define MAX_UDP_MSS (CONFIG_NET_SLIP_MTU - IPUDP_HDRLEN) # define MAX_UDP_MSS (CONFIG_NET_SLIP_MTU - IPv4UDP_HDRLEN)
#else /* if defined(CONFIG_NET_ETHERNET) */ #else /* if defined(CONFIG_NET_ETHERNET) */
# define MAX_UDP_MSS (CONFIG_NET_ETH_MTU - ETH_HDRLEN - IPUDP_HDRLEN) # define MAX_UDP_MSS (CONFIG_NET_ETH_MTU - ETH_HDRLEN - IPv4UDP_HDRLEN)
#endif #endif
/* TCP configuration options */ /* TCP configuration options */
@ -288,7 +288,7 @@
#define TCP_MAXSYNRTX 5 #define TCP_MAXSYNRTX 5
/* The TCP maximum segment size. This is should not be set to more /* The TCP maximum segment size. This is should not be set to more
* than NET_DEV_MTU(dev) - NET_LL_HDRLEN(dev) - IPTCP_HDRLEN. * than NET_DEV_MTU(dev) - NET_LL_HDRLEN(dev) - IPv4TCP_HDRLEN.
* *
* In the case where there are multiple network devices with different * In the case where there are multiple network devices with different
* link layer protocols (CONFIG_NET_MULTILINK), each network device * link layer protocols (CONFIG_NET_MULTILINK), each network device
@ -296,13 +296,13 @@
* the minimum MSS for that case. * the minimum MSS for that case.
*/ */
#define TCP_MSS(d) (NET_DEV_MTU(d) - NET_LL_HDRLEN(d) - IPTCP_HDRLEN) #define TCP_MSS(d) (NET_DEV_MTU(d) - NET_LL_HDRLEN(d) - IPv4TCP_HDRLEN)
#ifdef CONFIG_NET_ETHERNET #ifdef CONFIG_NET_ETHERNET
# define ETH_TCP_MSS (CONFIG_NET_ETH_MTU - ETH_HDRLEN - IPTCP_HDRLEN) # define ETH_TCP_MSS (CONFIG_NET_ETH_MTU - ETH_HDRLEN - IPv4TCP_HDRLEN)
# define MIN_TCP_MSS ETH_TCP_MSS # define MIN_TCP_MSS ETH_TCP_MSS
#elif defined(CONFIG_NET_SLIP) #elif defined(CONFIG_NET_SLIP)
# define SLIP_TCP_MSS (CONFIG_NET_SLIP_MTU - IPTCP_HDRLEN) # define SLIP_TCP_MSS (CONFIG_NET_SLIP_MTU - IPv4TCP_HDRLEN)
# define MIN_TCP_MSS SLIP_TCP_MSS # define MIN_TCP_MSS SLIP_TCP_MSS
#endif #endif

25
include/nuttx/net/tcp.h
View File

@ -98,7 +98,14 @@
/* TCP header sizes */ /* TCP header sizes */
#define TCP_HDRLEN 20 /* Size of TCP header */ #define TCP_HDRLEN 20 /* Size of TCP header */
#define IPTCP_HDRLEN (TCP_HDRLEN + IPv4_HDRLEN) /* Size of IPv4 + TCP header */
#ifdef CONFIG_NET_IPv4
# define IPv4TCP_HDRLEN (TCP_HDRLEN + IPv4_HDRLEN) /* Size of IPv4 + TCP header */
#endif
#ifdef CONFIG_NET_IPv4
# define IPv6TCP_HDRLEN (TCP_HDRLEN + IPv6_HDRLEN) /* Size of IPv4 + TCP header */
#endif
/* Initial minimum MSS according to RFC 879 /* Initial minimum MSS according to RFC 879
* *
@ -121,6 +128,22 @@
* Public Type Definitions * Public Type Definitions
****************************************************************************/ ****************************************************************************/
/* TCP header */
struct tcp_hdr_s
{
uint16_t srcport;
uint16_t destport;
uint8_t seqno[4];
uint8_t ackno[4];
uint8_t tcpoffset;
uint8_t flags;
uint8_t wnd[2];
uint16_t tcpchksum;
uint8_t urgp[2];
uint8_t optdata[4];
};
/* The TCP and IP headers */ /* The TCP and IP headers */
#ifdef CONFIG_NET_IPv4 #ifdef CONFIG_NET_IPv4

19
include/nuttx/net/udp.h
View File

@ -63,12 +63,29 @@
/* Header sizes */ /* Header sizes */
#define UDP_HDRLEN 8 /* Size of UDP header */ #define UDP_HDRLEN 8 /* Size of UDP header */
#define IPUDP_HDRLEN (UDP_HDRLEN + IPv4_HDRLEN) /* Size of IPv4 + UDP header */
#ifdef CONFIG_NET_IPv4
# define IPv4UDP_HDRLEN (UDP_HDRLEN + IPv4_HDRLEN) /* Size of IPv4 + UDP headers */
#endif
#ifdef CONFIG_NET_IPv6
# define IPv6UDP_HDRLEN (UDP_HDRLEN + IPv4_HDRLEN) /* Size of IPv6 + UDP headers */
#endif
/**************************************************************************** /****************************************************************************
* Public Type Definitions * Public Type Definitions
****************************************************************************/ ****************************************************************************/
/* The UDP header */
struct udp_hdr_s
{
uint16_t srcport;
uint16_t destport;
uint16_t udplen;
uint16_t udpchksum;
};
/* The UDP and IP headers */ /* The UDP and IP headers */
#ifdef CONFIG_NET_IPv4 #ifdef CONFIG_NET_IPv4

6
net/devif/ipv4_input.c
View File

@ -383,7 +383,7 @@ int ipv4_input(FAR struct net_driver_s *dev)
if (pbuf->proto == IP_PROTO_UDP && if (pbuf->proto == IP_PROTO_UDP &&
net_ipv4addr_cmp(net_ip4addr_conv32(pbuf->destipaddr), g_alloneaddr)) net_ipv4addr_cmp(net_ip4addr_conv32(pbuf->destipaddr), g_alloneaddr))
{ {
return udp_input(dev); return udp_ipv4_input(dev);
} }
/* In most other cases, the device must be assigned a non-zero IP /* In most other cases, the device must be assigned a non-zero IP
@ -457,13 +457,13 @@ int ipv4_input(FAR struct net_driver_s *dev)
{ {
#ifdef CONFIG_NET_TCP #ifdef CONFIG_NET_TCP
case IP_PROTO_TCP: /* TCP input */ case IP_PROTO_TCP: /* TCP input */
tcp_input(dev); tcp_ipv4_input(dev);
break; break;
#endif #endif
#ifdef CONFIG_NET_UDP #ifdef CONFIG_NET_UDP
case IP_PROTO_UDP: /* UDP input */ case IP_PROTO_UDP: /* UDP input */
udp_input(dev); udp_ipv4_input(dev);
break; break;
#endif #endif

4
net/devif/ipv6_input.c
View File

@ -251,13 +251,13 @@ int ipv6_input(FAR struct net_driver_s *dev)
{ {
#ifdef CONFIG_NET_TCP #ifdef CONFIG_NET_TCP
case IP_PROTO_TCP: /* TCP input */ case IP_PROTO_TCP: /* TCP input */
tcp_input(dev); tcp_ipv6_input(dev);
break; break;
#endif #endif
#ifdef CONFIG_NET_UDP #ifdef CONFIG_NET_UDP
case IP_PROTO_UDP: /* UDP input */ case IP_PROTO_UDP: /* UDP input */
udp_input(dev); udp_ipv6_input(dev);
break; break;
#endif #endif

4
net/pkt/pkt_poll.c
View File

@ -102,8 +102,8 @@ void pkt_poll(FAR struct net_driver_s *dev, FAR struct pkt_conn_s *conn)
{ {
/* Setup for the application callback */ /* Setup for the application callback */
dev->d_appdata = &dev->d_buf[NET_LL_HDRLEN(dev) + IPUDP_HDRLEN]; dev->d_appdata = &dev->d_buf[NET_LL_HDRLEN(dev) + IPv4UDP_HDRLEN];
dev->d_snddata = &dev->d_buf[NET_LL_HDRLEN(dev) + IPUDP_HDRLEN]; dev->d_snddata = &dev->d_buf[NET_LL_HDRLEN(dev) + IPv4UDP_HDRLEN];
dev->d_len = 0; dev->d_len = 0;
dev->d_sndlen = 0; dev->d_sndlen = 0;

107
net/tcp/tcp.h
View File

@ -103,6 +103,7 @@
struct net_driver_s; /* Forward reference */ struct net_driver_s; /* Forward reference */
struct devif_callback_s; /* Forward reference */ struct devif_callback_s; /* Forward reference */
struct tcp_backlog_s; /* Forward reference */ struct tcp_backlog_s; /* Forward reference */
struct tcp_hdr_s; /* Forward reference */
struct tcp_conn_s struct tcp_conn_s
{ {
@ -272,7 +273,7 @@ extern "C"
struct tcp_iphdr_s; /* Forward reference */ struct tcp_iphdr_s; /* Forward reference */
/**************************************************************************** /****************************************************************************
* Name: tcp_initialize() * Name: tcp_initialize
* *
* Description: * Description:
* Initialize the TCP/IP connection structures. Called only once and only * Initialize the TCP/IP connection structures. Called only once and only
@ -283,12 +284,12 @@ struct tcp_iphdr_s; /* Forward reference */
void tcp_initialize(void); void tcp_initialize(void);
/**************************************************************************** /****************************************************************************
* Name: tcp_alloc() * Name: tcp_alloc
* *
* Description: * Description:
* Find a free TCP/IP connection structure and allocate it * Find a free TCP/IP connection structure and allocate it
* for use. This is normally something done by the implementation of the * for use. This is normally something done by the implementation of the
* socket() API but is also called from the interrupt level when a TCP * socket() API but is also called from the driver level when a TCP
* packet is received while "listening" * packet is received while "listening"
* *
****************************************************************************/ ****************************************************************************/
@ -296,7 +297,7 @@ void tcp_initialize(void);
FAR struct tcp_conn_s *tcp_alloc(void); FAR struct tcp_conn_s *tcp_alloc(void);
/**************************************************************************** /****************************************************************************
* Name: tcp_free() * Name: tcp_free
* *
* Description: * Description:
* Free a connection structure that is no longer in use. This should be * Free a connection structure that is no longer in use. This should be
@ -307,51 +308,51 @@ FAR struct tcp_conn_s *tcp_alloc(void);
void tcp_free(FAR struct tcp_conn_s *conn); void tcp_free(FAR struct tcp_conn_s *conn);
/**************************************************************************** /****************************************************************************
* Name: tcp_active() * Name: tcp_active
* *
* Description: * Description:
* Find a connection structure that is the appropriate * Find a connection structure that is the appropriate
* connection to be used with the provided TCP/IP header * connection to be used with the provided TCP/IP header
* *
* Assumptions: * Assumptions:
* This function is called from UIP logic at interrupt level * Called from network stack logic with the network stack locked
* *
****************************************************************************/ ****************************************************************************/
FAR struct tcp_conn_s *tcp_active(struct tcp_iphdr_s *buf); FAR struct tcp_conn_s *tcp_active(FAR struct net_driver_s *dev,
FAR struct tcp_hdr_s *tcp);
/**************************************************************************** /****************************************************************************
* Name: tcp_nextconn() * Name: tcp_nextconn
* *
* Description: * Description:
* Traverse the list of active TCP connections * Traverse the list of active TCP connections
* *
* Assumptions: * Assumptions:
* This function is called from UIP logic at interrupt level (or with * Called from network stack logic with the network stack locked
* interrupts disabled).
* *
****************************************************************************/ ****************************************************************************/
FAR struct tcp_conn_s *tcp_nextconn(FAR struct tcp_conn_s *conn); FAR struct tcp_conn_s *tcp_nextconn(FAR struct tcp_conn_s *conn);
/**************************************************************************** /****************************************************************************
* Name: tcp_alloc_accept() * Name: tcp_alloc_accept
* *
* Description: * Description:
* Called when driver interrupt processing matches the incoming packet * Called when driver processing matches the incoming packet with a
* with a connection in LISTEN. In that case, this function will create * connection in LISTEN. In that case, this function will create a new
* a new connection and initialize it to send a SYNACK in return. * connection and initialize it to send a SYNACK in return.
* *
* Assumptions: * Assumptions:
* This function is called from UIP logic at interrupt level * Called from network stack logic with the network stack locked
* *
****************************************************************************/ ****************************************************************************/
FAR struct tcp_conn_s *tcp_alloc_accept(FAR struct net_driver_s *dev, FAR struct tcp_conn_s *tcp_alloc_accept(FAR struct net_driver_s *dev,
FAR struct tcp_iphdr_s *buf); FAR struct tcp_hdr_s *tcp);
/**************************************************************************** /****************************************************************************
* Name: tcp_bind() * Name: tcp_bind
* *
* Description: * Description:
* This function implements the lower level parts of the standard TCP * This function implements the lower level parts of the standard TCP
@ -409,7 +410,7 @@ int tcp_connect(FAR struct tcp_conn_s *conn,
* Set the TCP/IP sequence number * Set the TCP/IP sequence number
* *
* Assumptions: * Assumptions:
* This function may called from the interrupt level * Called from network stack logic with the network stack locked
* *
****************************************************************************/ ****************************************************************************/
@ -422,7 +423,7 @@ void tcp_setsequence(FAR uint8_t *seqno, uint32_t value);
* Get the TCP/IP sequence number * Get the TCP/IP sequence number
* *
* Assumptions: * Assumptions:
* This function may called from the interrupt level * Called from network stack logic with the network stack locked
* *
****************************************************************************/ ****************************************************************************/
@ -435,7 +436,7 @@ uint32_t tcp_getsequence(FAR uint8_t *seqno);
* Add the length to get the next TCP sequence number. * Add the length to get the next TCP sequence number.
* *
* Assumptions: * Assumptions:
* This function may called from the interrupt level * Called from network stack logic with the network stack locked
* *
****************************************************************************/ ****************************************************************************/
@ -449,7 +450,7 @@ uint32_t tcp_addsequence(FAR uint8_t *seqno, uint16_t len);
* established. * established.
* *
* Assumptions: * Assumptions:
* This function may called from the interrupt level * Called from network stack logic with the network stack locked
* *
****************************************************************************/ ****************************************************************************/
@ -462,7 +463,7 @@ void tcp_initsequence(FAR uint8_t *seqno);
* Increment the TCP/IP sequence number * Increment the TCP/IP sequence number
* *
* Assumptions: * Assumptions:
* This function is called from the interrupt level * Called from network stack logic with the network stack locked
* *
****************************************************************************/ ****************************************************************************/
@ -483,7 +484,7 @@ void tcp_nextsequence(void);
* None * None
* *
* Assumptions: * Assumptions:
* Called from the interrupt level or with interrupts disabled. * Called from network stack logic with the network stack locked
* *
****************************************************************************/ ****************************************************************************/
@ -505,7 +506,7 @@ void tcp_poll(FAR struct net_driver_s *dev, FAR struct tcp_conn_s *conn);
* None * None
* *
* Assumptions: * Assumptions:
* Called from the interrupt level or with interrupts disabled. * Called from network stack logic with the network stack locked
* *
****************************************************************************/ ****************************************************************************/
@ -560,7 +561,7 @@ int tcp_listen(FAR struct tcp_conn_s *conn);
* Return true is there is a listener for the specified port * Return true is there is a listener for the specified port
* *
* Assumptions: * Assumptions:
* Called at interrupt level * Called from network stack logic with the network stack locked
* *
****************************************************************************/ ****************************************************************************/
@ -573,7 +574,7 @@ bool tcp_islistener(uint16_t portno);
* Accept the new connection for the specified listening port. * Accept the new connection for the specified listening port.
* *
* Assumptions: * Assumptions:
* Called at interrupt level * Called from network stack logic with the network stack locked
* *
****************************************************************************/ ****************************************************************************/
@ -597,7 +598,7 @@ int tcp_accept_connection(FAR struct net_driver_s *dev,
* None * None
* *
* Assumptions: * Assumptions:
* Called from the interrupt level or with interrupts disabled. * Called from network stack logic with the network stack locked
* *
****************************************************************************/ ****************************************************************************/
@ -617,7 +618,7 @@ void tcp_send(FAR struct net_driver_s *dev, FAR struct tcp_conn_s *conn,
* None * None
* *
* Assumptions: * Assumptions:
* Called from the interrupt level or with interrupts disabled. * Called from network stack logic with the network stack locked
* *
****************************************************************************/ ****************************************************************************/
@ -638,7 +639,7 @@ void tcp_reset(FAR struct net_driver_s *dev);
* None * None
* *
* Assumptions: * Assumptions:
* Called from the interrupt level or with interrupts disabled. * Called from network stack logic with the network stack locked
* *
****************************************************************************/ ****************************************************************************/
@ -663,7 +664,7 @@ void tcp_ack(FAR struct net_driver_s *dev, FAR struct tcp_conn_s *conn,
* None * None
* *
* Assumptions: * Assumptions:
* Called from the interrupt level or with interrupts disabled. * Called from network stack logic with the network stack locked
* *
****************************************************************************/ ****************************************************************************/
@ -685,7 +686,7 @@ void tcp_appsend(FAR struct net_driver_s *dev, FAR struct tcp_conn_s *conn,
* None * None
* *
* Assumptions: * Assumptions:
* Called from the interrupt level or with interrupts disabled. * Called from network stack logic with the network stack locked
* *
****************************************************************************/ ****************************************************************************/
@ -694,10 +695,10 @@ void tcp_rexmit(FAR struct net_driver_s *dev, FAR struct tcp_conn_s *conn,
/* Defined in tcp_input.c ***************************************************/ /* Defined in tcp_input.c ***************************************************/
/**************************************************************************** /****************************************************************************
* Name: tcp_input * Name: tcp_ipv4_input
* *
* Description: * Description:
* Handle incoming TCP input * Handle incoming TCP input with IPv4 header
* *
* Parameters: * Parameters:
* dev - The device driver structure containing the received TCP packet. * dev - The device driver structure containing the received TCP packet.
@ -706,11 +707,34 @@ void tcp_rexmit(FAR struct net_driver_s *dev, FAR struct tcp_conn_s *conn,
* None * None
* *
* Assumptions: * Assumptions:
* Called from the interrupt level or with interrupts disabled. * Called from the Ethernet driver with the network stack locked
* *
****************************************************************************/ ****************************************************************************/
void tcp_input(FAR struct net_driver_s *dev); #ifdef CONFIG_NET_IPv4
void tcp_ipv4_input(FAR struct net_driver_s *dev);
#endif
/****************************************************************************
* Name: tcp_ipv6_input
*
* Description:
* Handle incoming TCP input with IPv4 header
*
* Parameters:
* dev - The device driver structure containing the received TCP packet.
*
* Return:
* None
*
* Assumptions:
* Called from the Ethernet driver with the network stack locked
*
****************************************************************************/
#ifdef CONFIG_NET_IPv6
void tcp_ipv6_input(FAR struct net_driver_s *dev);
#endif
/* Defined in tcp_callback.c ************************************************/ /* Defined in tcp_callback.c ************************************************/
/**************************************************************************** /****************************************************************************
@ -720,7 +744,7 @@ void tcp_input(FAR struct net_driver_s *dev);
* Inform the application holding the TCP socket of a change in state. * Inform the application holding the TCP socket of a change in state.
* *
* Assumptions: * Assumptions:
* This function is called at the interrupt level with interrupts disabled. * Called from network stack logic with the network stack locked
* *
****************************************************************************/ ****************************************************************************/
@ -749,7 +773,7 @@ uint16_t tcp_callback(FAR struct net_driver_s *dev,
* Assumptions: * Assumptions:
* - The caller has checked that TCP_NEWDATA is set in flags and that is no * - The caller has checked that TCP_NEWDATA is set in flags and that is no
* other handler available to process the incoming data. * other handler available to process the incoming data.
* - This function is called at the interrupt level with interrupts disabled. * - Called from network stack logic with the network stack locked
* *
****************************************************************************/ ****************************************************************************/
@ -788,8 +812,7 @@ int tcp_backlogcreate(FAR struct tcp_conn_s *conn, int nblg);
* is freed that has pending connections. * is freed that has pending connections.
* *
* Assumptions: * Assumptions:
* The caller has disabled interrupts so that there can be no conflict * Called from network stack logic with the network stack locked
* with ongoing, interrupt driven activity
* *
****************************************************************************/ ****************************************************************************/
@ -808,7 +831,7 @@ int tcp_backlogdestroy(FAR struct tcp_conn_s *conn);
* function adds the new connection to the backlog. * function adds the new connection to the backlog.
* *
* Assumptions: * Assumptions:
* Called from the interrupt level with interrupts disabled * Called from network stack logic with the network stack locked
* *
****************************************************************************/ ****************************************************************************/
@ -864,7 +887,7 @@ FAR struct tcp_conn_s *tcp_backlogremove(FAR struct tcp_conn_s *conn);
* to remove the defunct connection from the list. * to remove the defunct connection from the list.
* *
* Assumptions: * Assumptions:
* Called from the interrupt level with interrupts disabled * Called from network stack logic with the network stack locked
* *
****************************************************************************/ ****************************************************************************/
@ -984,7 +1007,7 @@ FAR struct tcp_wrbuffer_s *tcp_wrbuffer_alloc(void);
* buffered data. * buffered data.
* *
* Assumptions: * Assumptions:
* Called from interrupt level with interrupts disabled. * Called from network stack logic with the network stack locked
* *
****************************************************************************/ ****************************************************************************/

8
net/tcp/tcp_appsend.c
View File

@ -112,7 +112,7 @@ void tcp_appsend(FAR struct net_driver_s *dev, FAR struct tcp_conn_s *conn,
conn->tcpstateflags = TCP_CLOSED; conn->tcpstateflags = TCP_CLOSED;
nllvdbg("TCP state: TCP_CLOSED\n"); nllvdbg("TCP state: TCP_CLOSED\n");
tcp_send(dev, conn, TCP_RST | TCP_ACK, IPTCP_HDRLEN); tcp_send(dev, conn, TCP_RST | TCP_ACK, IPv4TCP_HDRLEN);
} }
/* Check for connection closed */ /* Check for connection closed */
@ -125,7 +125,7 @@ void tcp_appsend(FAR struct net_driver_s *dev, FAR struct tcp_conn_s *conn,
nllvdbg("TCP state: TCP_FIN_WAIT_1\n"); nllvdbg("TCP state: TCP_FIN_WAIT_1\n");
dev->d_sndlen = 0; dev->d_sndlen = 0;
tcp_send(dev, conn, TCP_FIN | TCP_ACK, IPTCP_HDRLEN); tcp_send(dev, conn, TCP_FIN | TCP_ACK, IPv4TCP_HDRLEN);
} }
/* None of the above */ /* None of the above */
@ -204,14 +204,14 @@ void tcp_rexmit(FAR struct net_driver_s *dev, FAR struct tcp_conn_s *conn,
* the IP and TCP headers. * the IP and TCP headers.
*/ */
tcp_send(dev, conn, TCP_ACK | TCP_PSH, dev->d_sndlen + IPTCP_HDRLEN); tcp_send(dev, conn, TCP_ACK | TCP_PSH, dev->d_sndlen + IPv4TCP_HDRLEN);
} }
/* If there is no data to send, just send out a pure ACK if one is requested`. */ /* If there is no data to send, just send out a pure ACK if one is requested`. */
else if ((result & TCP_SNDACK) != 0) else if ((result & TCP_SNDACK) != 0)
{ {
tcp_send(dev, conn, TCP_ACK, IPTCP_HDRLEN); tcp_send(dev, conn, TCP_ACK, IPv4TCP_HDRLEN);
} }
/* There is nothing to do -- drop the packet */ /* There is nothing to do -- drop the packet */

62
net/tcp/tcp_conn.c
View File

@ -60,6 +60,13 @@
#include "devif/devif.h" #include "devif/devif.h"
#include "tcp/tcp.h" #include "tcp/tcp.h"
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
#define IPv4 ((struct net_iphdr_s *)&dev->d_buf[NET_LL_HDRLEN(dev)])
#define IPv6 ((struct net_ipv6hdr_s *)&dev->d_buf[NET_LL_HDRLEN(dev)])
/**************************************************************************** /****************************************************************************
* Private Data * Private Data
****************************************************************************/ ****************************************************************************/
@ -85,7 +92,7 @@ static uint16_t g_last_tcp_port;
****************************************************************************/ ****************************************************************************/
/**************************************************************************** /****************************************************************************
* Name: tcp_listener() * Name: tcp_listener
* *
* Description: * Description:
* Given a local port number (in network byte order), find the TCP * Given a local port number (in network byte order), find the TCP
@ -144,7 +151,7 @@ static FAR struct tcp_conn_s *tcp_listener(uint16_t portno)
} }
/**************************************************************************** /****************************************************************************
* Name: tcp_selectport() * Name: tcp_selectport
* *
* Description: * Description:
* If the port number is zero; select an unused port for the connection. * If the port number is zero; select an unused port for the connection.
@ -230,7 +237,7 @@ static int tcp_selectport(uint16_t portno)
****************************************************************************/ ****************************************************************************/
/**************************************************************************** /****************************************************************************
* Name: tcp_initialize() * Name: tcp_initialize
* *
* Description: * Description:
* Initialize the TCP/IP connection structures. Called only once and only * Initialize the TCP/IP connection structures. Called only once and only
@ -261,7 +268,7 @@ void tcp_initialize(void)
} }
/**************************************************************************** /****************************************************************************
* Name: tcp_alloc() * Name: tcp_alloc
* *
* Description: * Description:
* Find a free TCP/IP connection structure and allocate it * Find a free TCP/IP connection structure and allocate it
@ -374,7 +381,7 @@ FAR struct tcp_conn_s *tcp_alloc(void)
} }
/**************************************************************************** /****************************************************************************
* Name: tcp_free() * Name: tcp_free
* *
* Description: * Description:
* Free a connection structure that is no longer in use. This should be * Free a connection structure that is no longer in use. This should be
@ -466,7 +473,7 @@ void tcp_free(FAR struct tcp_conn_s *conn)
} }
/**************************************************************************** /****************************************************************************
* Name: tcp_active() * Name: tcp_active
* *
* Description: * Description:
* Find a connection structure that is the appropriate * Find a connection structure that is the appropriate
@ -477,12 +484,20 @@ void tcp_free(FAR struct tcp_conn_s *conn)
* *
****************************************************************************/ ****************************************************************************/
FAR struct tcp_conn_s *tcp_active(struct tcp_iphdr_s *buf) FAR struct tcp_conn_s *tcp_active(FAR struct net_driver_s *dev,
FAR struct tcp_hdr_s *tcp)
{ {
FAR struct tcp_conn_s *conn = (struct tcp_conn_s *)g_active_tcp_connections.head; FAR struct net_iphdr_s *ip = IPv4;
in_addr_t srcipaddr = net_ip4addr_conv32(buf->srcipaddr); FAR struct tcp_conn_s *conn;
in_addr_t srcipaddr;
#ifdef CONFIG_NETDEV_MULTINIC #ifdef CONFIG_NETDEV_MULTINIC
in_addr_t destipaddr = net_ip4addr_conv32(buf->destipaddr); in_addr_t destipaddr;
#endif
conn = (FAR struct tcp_conn_s *)g_active_tcp_connections.head;
srcipaddr = net_ip4addr_conv32(ip->srcipaddr);
#ifdef CONFIG_NETDEV_MULTINIC
destipaddr = net_ip4addr_conv32(ip->destipaddr);
#endif #endif
while (conn) while (conn)
@ -507,8 +522,8 @@ FAR struct tcp_conn_s *tcp_active(struct tcp_iphdr_s *buf)
*/ */
if (conn->tcpstateflags != TCP_CLOSED && if (conn->tcpstateflags != TCP_CLOSED &&
buf->destport == conn->lport && tcp->destport == conn->lport &&
buf->srcport == conn->rport && tcp->srcport == conn->rport &&
#ifdef CONFIG_NETDEV_MULTINIC #ifdef CONFIG_NETDEV_MULTINIC
(net_ipaddr_cmp(conn->lipaddr, g_allzeroaddr) || (net_ipaddr_cmp(conn->lipaddr, g_allzeroaddr) ||
net_ipaddr_cmp(destipaddr, conn->lipaddr)) && net_ipaddr_cmp(destipaddr, conn->lipaddr)) &&
@ -531,7 +546,7 @@ FAR struct tcp_conn_s *tcp_active(struct tcp_iphdr_s *buf)
} }
/**************************************************************************** /****************************************************************************
* Name: tcp_nextconn() * Name: tcp_nextconn
* *
* Description: * Description:
* Traverse the list of active TCP connections * Traverse the list of active TCP connections
@ -555,7 +570,7 @@ FAR struct tcp_conn_s *tcp_nextconn(FAR struct tcp_conn_s *conn)
} }
/**************************************************************************** /****************************************************************************
* Name: tcp_alloc_accept() * Name: tcp_alloc_accept
* *
* Description: * Description:
* Called when driver interrupt processing matches the incoming packet * Called when driver interrupt processing matches the incoming packet
@ -568,9 +583,12 @@ FAR struct tcp_conn_s *tcp_nextconn(FAR struct tcp_conn_s *conn)
****************************************************************************/ ****************************************************************************/
FAR struct tcp_conn_s *tcp_alloc_accept(FAR struct net_driver_s *dev, FAR struct tcp_conn_s *tcp_alloc_accept(FAR struct net_driver_s *dev,
FAR struct tcp_iphdr_s *buf) FAR struct tcp_hdr_s *tcp)
{ {
FAR struct tcp_conn_s *conn = tcp_alloc(); FAR struct net_iphdr_s *ip = IPv4;
FAR struct tcp_conn_s *conn;
conn = tcp_alloc();
if (conn) if (conn)
{ {
/* Fill in the necessary fields for the new connection. */ /* Fill in the necessary fields for the new connection. */
@ -580,12 +598,12 @@ FAR struct tcp_conn_s *tcp_alloc_accept(FAR struct net_driver_s *dev,
conn->sa = 0; conn->sa = 0;
conn->sv = 4; conn->sv = 4;
conn->nrtx = 0; conn->nrtx = 0;
conn->lport = buf->destport; conn->lport = tcp->destport;
conn->rport = buf->srcport; conn->rport = tcp->srcport;
conn->mss = TCP_INITIAL_MSS(dev); conn->mss = TCP_INITIAL_MSS(dev);
net_ipaddr_copy(conn->ripaddr, net_ip4addr_conv32(buf->srcipaddr)); net_ipaddr_copy(conn->ripaddr, net_ip4addr_conv32(ip->srcipaddr));
#ifdef CONFIG_NETDEV_MULTINIC #ifdef CONFIG_NETDEV_MULTINIC
net_ipaddr_copy(conn->lipaddr, net_ip4addr_conv32(buf->destipaddr)); net_ipaddr_copy(conn->lipaddr, net_ip4addr_conv32(ip->destipaddr));
#endif #endif
conn->tcpstateflags = TCP_SYN_RCVD; conn->tcpstateflags = TCP_SYN_RCVD;
@ -599,7 +617,7 @@ FAR struct tcp_conn_s *tcp_alloc_accept(FAR struct net_driver_s *dev,
/* rcvseq should be the seqno from the incoming packet + 1. */ /* rcvseq should be the seqno from the incoming packet + 1. */
memcpy(conn->rcvseq, buf->seqno, 4); memcpy(conn->rcvseq, tcp->seqno, 4);
#ifdef CONFIG_NET_TCP_READAHEAD #ifdef CONFIG_NET_TCP_READAHEAD
/* Initialize the list of TCP read-ahead buffers */ /* Initialize the list of TCP read-ahead buffers */
@ -625,7 +643,7 @@ FAR struct tcp_conn_s *tcp_alloc_accept(FAR struct net_driver_s *dev,
} }
/**************************************************************************** /****************************************************************************
* Name: tcp_bind() * Name: tcp_bind
* *
* Description: * Description:
* This function implements the lower level parts of the standard TCP * This function implements the lower level parts of the standard TCP

186
net/tcp/tcp_input.c
View File

@ -64,8 +64,6 @@
* Pre-processor Definitions * Pre-processor Definitions
****************************************************************************/ ****************************************************************************/
#define BUF ((struct tcp_iphdr_s *)&dev->d_buf[NET_LL_HDRLEN(dev)])
/**************************************************************************** /****************************************************************************
* Public Variables * Public Variables
****************************************************************************/ ****************************************************************************/
@ -78,10 +76,6 @@
* Private Functions * Private Functions
****************************************************************************/ ****************************************************************************/
/****************************************************************************
* Public Functions
****************************************************************************/
/**************************************************************************** /****************************************************************************
* Name: tcp_input * Name: tcp_input
* *
@ -90,6 +84,8 @@
* *
* Parameters: * Parameters:
* dev - The device driver structure containing the received TCP packet. * dev - The device driver structure containing the received TCP packet.
* tcp - A pointer to the TCP header in the packet
* tcpiplen - Combined length of the IP and TCP headers
* *
* Return: * Return:
* None * None
@ -99,10 +95,11 @@
* *
****************************************************************************/ ****************************************************************************/
void tcp_input(FAR struct net_driver_s *dev) static void tcp_input(FAR struct net_driver_s *dev,
FAR struct tcp_hdr_s *tcp, unsigned int tcpiplen)
{ {
FAR struct tcp_conn_s *conn = NULL; FAR struct tcp_conn_s *conn = NULL;
FAR struct tcp_iphdr_s *pbuf = BUF; unsigned int hdrlen;
uint16_t tmp16; uint16_t tmp16;
uint16_t flags; uint16_t flags;
uint8_t opt; uint8_t opt;
@ -110,13 +107,21 @@ void tcp_input(FAR struct net_driver_s *dev)
int len; int len;
int i; int i;
dev->d_snddata = &dev->d_buf[IPTCP_HDRLEN + NET_LL_HDRLEN(dev)];
dev->d_appdata = &dev->d_buf[IPTCP_HDRLEN + NET_LL_HDRLEN(dev)];
#ifdef CONFIG_NET_STATISTICS #ifdef CONFIG_NET_STATISTICS
/* Bump up the count of TCP packets received */
g_netstats.tcp.recv++; g_netstats.tcp.recv++;
#endif #endif
/* Get the size of the link layer header, the IP header, and the TCP header */
hdrlen = tcpiplen + NET_LL_HDRLEN(dev);
/* Initialize for tcp_send() */
dev->d_snddata = &dev->d_buf[hdrlen];
dev->d_appdata = &dev->d_buf[hdrlen];
/* Start of TCP input header processing code. */ /* Start of TCP input header processing code. */
if (tcp_chksum(dev) != 0xffff) if (tcp_chksum(dev) != 0xffff)
@ -133,7 +138,7 @@ void tcp_input(FAR struct net_driver_s *dev)
/* Demultiplex this segment. First check any active connections. */ /* Demultiplex this segment. First check any active connections. */
conn = tcp_active(pbuf); conn = tcp_active(dev, tcp);
if (conn) if (conn)
{ {
/* We found an active connection.. Check for the subsequent SYN /* We found an active connection.. Check for the subsequent SYN
@ -143,7 +148,7 @@ void tcp_input(FAR struct net_driver_s *dev)
*/ */
if ((conn->tcpstateflags & TCP_STATE_MASK) != TCP_SYN_RCVD && if ((conn->tcpstateflags & TCP_STATE_MASK) != TCP_SYN_RCVD &&
(BUF->flags & TCP_CTL) == TCP_SYN) (tcp->flags & TCP_CTL) == TCP_SYN)
{ {
goto reset; goto reset;
} }
@ -159,13 +164,13 @@ void tcp_input(FAR struct net_driver_s *dev)
* it is an old packet and we send a RST. * it is an old packet and we send a RST.
*/ */
if ((pbuf->flags & TCP_CTL) == TCP_SYN) if ((tcp->flags & TCP_CTL) == TCP_SYN)
{ {
/* This is a SYN packet for a connection. Find the connection /* This is a SYN packet for a connection. Find the connection
* listening on this port. * listening on this port.
*/ */
tmp16 = pbuf->destport; tmp16 = tcp->destport;
if (tcp_islistener(tmp16)) if (tcp_islistener(tmp16))
{ {
/* We matched the incoming packet with a connection in LISTEN. /* We matched the incoming packet with a connection in LISTEN.
@ -177,7 +182,7 @@ void tcp_input(FAR struct net_driver_s *dev)
* user application to accept it. * user application to accept it.
*/ */
conn = tcp_alloc_accept(dev, pbuf); conn = tcp_alloc_accept(dev, tcp);
if (conn) if (conn)
{ {
/* The connection structure was successfully allocated. Now see if /* The connection structure was successfully allocated. Now see if
@ -215,11 +220,11 @@ void tcp_input(FAR struct net_driver_s *dev)
/* Parse the TCP MSS option, if present. */ /* Parse the TCP MSS option, if present. */
if ((pbuf->tcpoffset & 0xf0) > 0x50) if ((tcp->tcpoffset & 0xf0) > 0x50)
{ {
for (i = 0; i < ((pbuf->tcpoffset >> 4) - 5) << 2 ;) for (i = 0; i < ((tcp->tcpoffset >> 4) - 5) << 2 ;)
{ {
opt = dev->d_buf[IPTCP_HDRLEN + NET_LL_HDRLEN(dev) + i]; opt = dev->d_buf[hdrlen + i];
if (opt == TCP_OPT_END) if (opt == TCP_OPT_END)
{ {
/* End of options. */ /* End of options. */
@ -233,12 +238,12 @@ void tcp_input(FAR struct net_driver_s *dev)
++i; ++i;
} }
else if (opt == TCP_OPT_MSS && else if (opt == TCP_OPT_MSS &&
dev->d_buf[IPTCP_HDRLEN + NET_LL_HDRLEN(dev) + 1 + i] == TCP_OPT_MSS_LEN) dev->d_buf[hdrlen + 1 + i] == TCP_OPT_MSS_LEN)
{ {
/* An MSS option with the right option length. */ /* An MSS option with the right option length. */
tmp16 = ((uint16_t)dev->d_buf[IPTCP_HDRLEN + NET_LL_HDRLEN(dev) + 2 + i] << 8) | tmp16 = ((uint16_t)dev->d_buf[hdrlen + 2 + i] << 8) |
(uint16_t)dev->d_buf[IPTCP_HDRLEN + NET_LL_HDRLEN(dev) + 3 + i]; (uint16_t)dev->d_buf[hdrlen + 3 + i];
conn->mss = tmp16 > TCP_MSS(dev) ? TCP_MSS(dev) : tmp16; conn->mss = tmp16 > TCP_MSS(dev) ? TCP_MSS(dev) : tmp16;
/* And we are done processing options. */ /* And we are done processing options. */
@ -251,7 +256,7 @@ void tcp_input(FAR struct net_driver_s *dev)
* can skip past them. * can skip past them.
*/ */
if (dev->d_buf[IPTCP_HDRLEN + NET_LL_HDRLEN(dev) + 1 + i] == 0) if (dev->d_buf[hdrlen + 1 + i] == 0)
{ {
/* If the length field is zero, the options are malformed /* If the length field is zero, the options are malformed
* and we don't process them further. * and we don't process them further.
@ -259,7 +264,7 @@ void tcp_input(FAR struct net_driver_s *dev)
break; break;
} }
i += dev->d_buf[IPTCP_HDRLEN + NET_LL_HDRLEN(dev) + 1 + i]; i += dev->d_buf[hdrlen + 1 + i];
} }
} }
} }
@ -279,7 +284,7 @@ reset:
/* We do not send resets in response to resets. */ /* We do not send resets in response to resets. */
if ((pbuf->flags & TCP_RST) != 0) if ((tcp->flags & TCP_RST) != 0)
{ {
goto drop; goto drop;
} }
@ -294,7 +299,7 @@ found:
/* Update the connection's window size */ /* Update the connection's window size */
conn->winsize = ((uint16_t)pbuf->wnd[0] << 8) + (uint16_t)pbuf->wnd[1]; conn->winsize = ((uint16_t)tcp->wnd[0] << 8) + (uint16_t)tcp->wnd[1];
flags = 0; flags = 0;
@ -304,7 +309,7 @@ found:
* before we accept the reset. * before we accept the reset.
*/ */
if ((pbuf->flags & TCP_RST) != 0) if ((tcp->flags & TCP_RST) != 0)
{ {
conn->tcpstateflags = TCP_CLOSED; conn->tcpstateflags = TCP_CLOSED;
nlldbg("RESET - TCP state: TCP_CLOSED\n"); nlldbg("RESET - TCP state: TCP_CLOSED\n");
@ -317,7 +322,7 @@ found:
* any data to us. * any data to us.
*/ */
len = (pbuf->tcpoffset >> 4) << 2; len = (tcp->tcpoffset >> 4) << 2;
/* d_len will contain the length of the actual TCP data. This is /* d_len will contain the length of the actual TCP data. This is
* calculated by subtracting the length of the TCP header (in * calculated by subtracting the length of the TCP header (in
@ -334,14 +339,14 @@ found:
*/ */
if (!((((conn->tcpstateflags & TCP_STATE_MASK) == TCP_SYN_SENT) && if (!((((conn->tcpstateflags & TCP_STATE_MASK) == TCP_SYN_SENT) &&
((pbuf->flags & TCP_CTL) == (TCP_SYN | TCP_ACK))) || ((tcp->flags & TCP_CTL) == (TCP_SYN | TCP_ACK))) ||
(((conn->tcpstateflags & TCP_STATE_MASK) == TCP_SYN_RCVD) && (((conn->tcpstateflags & TCP_STATE_MASK) == TCP_SYN_RCVD) &&
((pbuf->flags & TCP_CTL) == TCP_SYN)))) ((tcp->flags & TCP_CTL) == TCP_SYN))))
{ {
if ((dev->d_len > 0 || ((pbuf->flags & (TCP_SYN | TCP_FIN)) != 0)) && if ((dev->d_len > 0 || ((tcp->flags & (TCP_SYN | TCP_FIN)) != 0)) &&
memcmp(pbuf->seqno, conn->rcvseq, 4) != 0) memcmp(tcp->seqno, conn->rcvseq, 4) != 0)
{ {
tcp_send(dev, conn, TCP_ACK, IPTCP_HDRLEN); tcp_send(dev, conn, TCP_ACK, tcpiplen);
return; return;
} }
} }
@ -352,7 +357,7 @@ found:
* retransmission timer. * retransmission timer.
*/ */
if ((pbuf->flags & TCP_ACK) != 0 && conn->unacked > 0) if ((tcp->flags & TCP_ACK) != 0 && conn->unacked > 0)
{ {
uint32_t unackseq; uint32_t unackseq;
uint32_t ackseq; uint32_t ackseq;
@ -372,7 +377,7 @@ found:
* incoming packet. * incoming packet.
*/ */
ackseq = tcp_getsequence(pbuf->ackno); ackseq = tcp_getsequence(tcp->ackno);
/* Check how many of the outstanding bytes have been acknowledged. For /* Check how many of the outstanding bytes have been acknowledged. For
* a most uIP send operation, this should always be true. However, * a most uIP send operation, this should always be true. However,
@ -464,7 +469,7 @@ found:
conn->tcpstateflags = TCP_ESTABLISHED; conn->tcpstateflags = TCP_ESTABLISHED;
#ifdef CONFIG_NET_TCP_WRITE_BUFFERS #ifdef CONFIG_NET_TCP_WRITE_BUFFERS
conn->isn = tcp_getsequence(pbuf->ackno); conn->isn = tcp_getsequence(tcp->ackno);
tcp_setsequence(conn->sndseq, conn->isn); tcp_setsequence(conn->sndseq, conn->isn);
conn->sent = 0; conn->sent = 0;
#endif #endif
@ -486,7 +491,7 @@ found:
/* We need to retransmit the SYNACK */ /* We need to retransmit the SYNACK */
if ((pbuf->flags & TCP_CTL) == TCP_SYN) if ((tcp->flags & TCP_CTL) == TCP_SYN)
{ {
tcp_ack(dev, conn, TCP_ACK | TCP_SYN); tcp_ack(dev, conn, TCP_ACK | TCP_SYN);
return; return;
@ -501,15 +506,15 @@ found:
* state. * state.
*/ */
if ((flags & TCP_ACKDATA) != 0 && (pbuf->flags & TCP_CTL) == (TCP_SYN | TCP_ACK)) if ((flags & TCP_ACKDATA) != 0 && (tcp->flags & TCP_CTL) == (TCP_SYN | TCP_ACK))
{ {
/* Parse the TCP MSS option, if present. */ /* Parse the TCP MSS option, if present. */
if ((pbuf->tcpoffset & 0xf0) > 0x50) if ((tcp->tcpoffset & 0xf0) > 0x50)
{ {
for (i = 0; i < ((pbuf->tcpoffset >> 4) - 5) << 2 ;) for (i = 0; i < ((tcp->tcpoffset >> 4) - 5) << 2 ;)
{ {
opt = dev->d_buf[IPTCP_HDRLEN + NET_LL_HDRLEN(dev) + i]; opt = dev->d_buf[hdrlen + i];
if (opt == TCP_OPT_END) if (opt == TCP_OPT_END)
{ {
/* End of options. */ /* End of options. */
@ -523,13 +528,13 @@ found:
++i; ++i;
} }
else if (opt == TCP_OPT_MSS && else if (opt == TCP_OPT_MSS &&
dev->d_buf[IPTCP_HDRLEN + NET_LL_HDRLEN(dev) + 1 + i] == TCP_OPT_MSS_LEN) dev->d_buf[hdrlen + 1 + i] == TCP_OPT_MSS_LEN)
{ {
/* An MSS option with the right option length. */ /* An MSS option with the right option length. */
tmp16 = tmp16 =
(dev->d_buf[IPTCP_HDRLEN + NET_LL_HDRLEN(dev) + 2 + i] << 8) | (dev->d_buf[hdrlen + 2 + i] << 8) |
dev->d_buf[IPTCP_HDRLEN + NET_LL_HDRLEN(dev) + 3 + i]; dev->d_buf[hdrlen + 3 + i];
conn->mss = tmp16 > TCP_MSS(dev) ? TCP_MSS(dev) : tmp16; conn->mss = tmp16 > TCP_MSS(dev) ? TCP_MSS(dev) : tmp16;
/* And we are done processing options. */ /* And we are done processing options. */
@ -542,7 +547,7 @@ found:
* easily can skip past them. * easily can skip past them.
*/ */
if (dev->d_buf[IPTCP_HDRLEN + NET_LL_HDRLEN(dev) + 1 + i] == 0) if (dev->d_buf[hdrlen + 1 + i] == 0)
{ {
/* If the length field is zero, the options are /* If the length field is zero, the options are
* malformed and we don't process them further. * malformed and we don't process them further.
@ -550,19 +555,19 @@ found:
break; break;
} }
i += dev->d_buf[IPTCP_HDRLEN + NET_LL_HDRLEN(dev) + 1 + i]; i += dev->d_buf[hdrlen + 1 + i];
} }
} }
} }
conn->tcpstateflags = TCP_ESTABLISHED; conn->tcpstateflags = TCP_ESTABLISHED;
memcpy(conn->rcvseq, pbuf->seqno, 4); memcpy(conn->rcvseq, tcp->seqno, 4);
net_incr32(conn->rcvseq, 1); net_incr32(conn->rcvseq, 1);
conn->unacked = 0; conn->unacked = 0;
#ifdef CONFIG_NET_TCP_WRITE_BUFFERS #ifdef CONFIG_NET_TCP_WRITE_BUFFERS
conn->isn = tcp_getsequence(pbuf->ackno); conn->isn = tcp_getsequence(tcp->ackno);
tcp_setsequence(conn->sndseq, conn->isn); tcp_setsequence(conn->sndseq, conn->isn);
#endif #endif
dev->d_len = 0; dev->d_len = 0;
@ -585,7 +590,7 @@ found:
/* We do not send resets in response to resets. */ /* We do not send resets in response to resets. */
if ((pbuf->flags & TCP_RST) != 0) if ((tcp->flags & TCP_RST) != 0)
{ {
goto drop; goto drop;
} }
@ -606,7 +611,7 @@ found:
* sequence numbers will be screwed up. * sequence numbers will be screwed up.
*/ */
if ((pbuf->flags & TCP_FIN) != 0 && (conn->tcpstateflags & TCP_STOPPED) == 0) if ((tcp->flags & TCP_FIN) != 0 && (conn->tcpstateflags & TCP_STOPPED) == 0)
{ {
/* Needs to be investigated further. /* Needs to be investigated further.
* Windows often sends FIN packets together with the last ACK for * Windows often sends FIN packets together with the last ACK for
@ -639,7 +644,7 @@ found:
conn->nrtx = 0; conn->nrtx = 0;
nllvdbg("TCP state: TCP_LAST_ACK\n"); nllvdbg("TCP state: TCP_LAST_ACK\n");
tcp_send(dev, conn, TCP_FIN | TCP_ACK, IPTCP_HDRLEN); tcp_send(dev, conn, TCP_FIN | TCP_ACK, tcpiplen);
return; return;
} }
@ -647,10 +652,10 @@ found:
* data that we must pass to the application. * data that we must pass to the application.
*/ */
if ((pbuf->flags & TCP_URG) != 0) if ((tcp->flags & TCP_URG) != 0)
{ {
#ifdef CONFIG_NET_TCPURGDATA #ifdef CONFIG_NET_TCPURGDATA
dev->d_urglen = (pbuf->urgp[0] << 8) | pbuf->urgp[1]; dev->d_urglen = (tcp->urgp[0] << 8) | tcp->urgp[1];
if (dev->d_urglen > dev->d_len) if (dev->d_urglen > dev->d_len)
{ {
/* There is more urgent data in the next segment to come. */ /* There is more urgent data in the next segment to come. */
@ -667,8 +672,8 @@ found:
{ {
dev->d_urglen = 0; dev->d_urglen = 0;
#else /* CONFIG_NET_TCPURGDATA */ #else /* CONFIG_NET_TCPURGDATA */
dev->d_appdata = ((uint8_t*)dev->d_appdata) + ((pbuf->urgp[0] << 8) | pbuf->urgp[1]); dev->d_appdata = ((uint8_t*)dev->d_appdata) + ((tcp->urgp[0] << 8) | tcp->urgp[1]);
dev->d_len -= (pbuf->urgp[0] << 8) | pbuf->urgp[1]; dev->d_len -= (tcp->urgp[0] << 8) | tcp->urgp[1];
#endif /* CONFIG_NET_TCPURGDATA */ #endif /* CONFIG_NET_TCPURGDATA */
} }
@ -692,8 +697,7 @@ found:
* When the application is called, the d_len field * When the application is called, the d_len field
* contains the length of the incoming data. The application can * contains the length of the incoming data. The application can
* access the incoming data through the global pointer * access the incoming data through the global pointer
* d_appdata, which usually points IPTCP_HDRLEN + NET_LL_HDRLEN(dev) * d_appdata, which usually points hdrlen bytes into the d_buf array.
* bytes into the d_buf array.
* *
* If the application wishes to send any data, this data should be * 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 the d_appdata and the length of the data should be
@ -761,7 +765,7 @@ found:
net_incr32(conn->rcvseq, dev->d_len); net_incr32(conn->rcvseq, dev->d_len);
} }
if ((pbuf->flags & TCP_FIN) != 0) if ((tcp->flags & TCP_FIN) != 0)
{ {
if ((flags & TCP_ACKDATA) != 0) if ((flags & TCP_ACKDATA) != 0)
{ {
@ -778,7 +782,7 @@ found:
net_incr32(conn->rcvseq, 1); net_incr32(conn->rcvseq, 1);
(void)tcp_callback(dev, conn, TCP_CLOSE); (void)tcp_callback(dev, conn, TCP_CLOSE);
tcp_send(dev, conn, TCP_ACK, IPTCP_HDRLEN); tcp_send(dev, conn, TCP_ACK, tcpiplen);
return; return;
} }
else if ((flags & TCP_ACKDATA) != 0) else if ((flags & TCP_ACKDATA) != 0)
@ -791,7 +795,7 @@ found:
if (dev->d_len > 0) if (dev->d_len > 0)
{ {
tcp_send(dev, conn, TCP_ACK, IPTCP_HDRLEN); tcp_send(dev, conn, TCP_ACK, tcpiplen);
return; return;
} }
@ -803,7 +807,7 @@ found:
net_incr32(conn->rcvseq, dev->d_len); net_incr32(conn->rcvseq, dev->d_len);
} }
if ((pbuf->flags & TCP_FIN) != 0) if ((tcp->flags & TCP_FIN) != 0)
{ {
conn->tcpstateflags = TCP_TIME_WAIT; conn->tcpstateflags = TCP_TIME_WAIT;
conn->timer = 0; conn->timer = 0;
@ -811,20 +815,20 @@ found:
net_incr32(conn->rcvseq, 1); net_incr32(conn->rcvseq, 1);
(void)tcp_callback(dev, conn, TCP_CLOSE); (void)tcp_callback(dev, conn, TCP_CLOSE);
tcp_send(dev, conn, TCP_ACK, IPTCP_HDRLEN); tcp_send(dev, conn, TCP_ACK, tcpiplen);
return; return;
} }
if (dev->d_len > 0) if (dev->d_len > 0)
{ {
tcp_send(dev, conn, TCP_ACK, IPTCP_HDRLEN); tcp_send(dev, conn, TCP_ACK, tcpiplen);
return; return;
} }
goto drop; goto drop;
case TCP_TIME_WAIT: case TCP_TIME_WAIT:
tcp_send(dev, conn, TCP_ACK, IPTCP_HDRLEN); tcp_send(dev, conn, TCP_ACK, tcpiplen);
return; return;
case TCP_CLOSING: case TCP_CLOSING:
@ -843,4 +847,58 @@ drop:
dev->d_len = 0; dev->d_len = 0;
} }
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: tcp_ipv4_input
*
* Description:
* Handle incoming TCP input with IPv4 header
*
* Parameters:
* dev - The device driver structure containing the received TCP packet.
*
* Return:
* None
*
* Assumptions:
* Called from the Ethernet driver with the network stack locked
*
****************************************************************************/
#ifdef CONFIG_NET_IPv4
void tcp_ipv4_input(FAR struct net_driver_s *dev)
{
unsigned int offset = IPv4_HDRLEN + NET_LL_HDRLEN(dev);
tcp_input(dev, (FAR struct tcp_hdr_s *)&dev->d_buf[offset], IPv4TCP_HDRLEN);
}
#endif
/****************************************************************************
* Name: tcp_ipv6_input
*
* Description:
* Handle incoming TCP input with IPv4 header
*
* Parameters:
* dev - The device driver structure containing the received TCP packet.
*
* Return:
* None
*
* Assumptions:
* Called from the Ethernet driver with the network stack locked
*
****************************************************************************/
#ifdef CONFIG_NET_IPv6
void tcp_ipv6_input(FAR struct net_driver_s *dev)
{
unsigned int offset = IPv6_HDRLEN + NET_LL_HDRLEN(dev);
tcp_input(dev, (FAR struct tcp_hdr_s *)&dev->d_buf[offset], IPv6TCP_HDRLEN);
}
#endif
#endif /* CONFIG_NET && CONFIG_NET_TCP */ #endif /* CONFIG_NET && CONFIG_NET_TCP */

4
net/tcp/tcp_poll.c
View File

@ -103,8 +103,8 @@ void tcp_poll(FAR struct net_driver_s *dev, FAR struct tcp_conn_s *conn)
{ {
/* Set up for the callback */ /* Set up for the callback */
dev->d_snddata = &dev->d_buf[IPTCP_HDRLEN + NET_LL_HDRLEN(dev)]; dev->d_snddata = &dev->d_buf[IPv4TCP_HDRLEN + NET_LL_HDRLEN(dev)];
dev->d_appdata = &dev->d_buf[IPTCP_HDRLEN + NET_LL_HDRLEN(dev)]; dev->d_appdata = &dev->d_buf[IPv4TCP_HDRLEN + NET_LL_HDRLEN(dev)];
dev->d_len = 0; dev->d_len = 0;
dev->d_sndlen = 0; dev->d_sndlen = 0;

4
net/tcp/tcp_send.c
View File

@ -275,7 +275,7 @@ void tcp_reset(FAR struct net_driver_s *dev)
#endif #endif
pbuf->flags = TCP_RST | TCP_ACK; pbuf->flags = TCP_RST | TCP_ACK;
dev->d_len = IPTCP_HDRLEN; dev->d_len = IPv4TCP_HDRLEN;
pbuf->tcpoffset = 5 << 4; pbuf->tcpoffset = 5 << 4;
/* Flip the seqno and ackno fields in the TCP header. */ /* Flip the seqno and ackno fields in the TCP header. */
@ -362,7 +362,7 @@ void tcp_ack(FAR struct net_driver_s *dev, FAR struct tcp_conn_s *conn,
pbuf->optdata[1] = TCP_OPT_MSS_LEN; pbuf->optdata[1] = TCP_OPT_MSS_LEN;
pbuf->optdata[2] = TCP_MSS(dev) / 256; pbuf->optdata[2] = TCP_MSS(dev) / 256;
pbuf->optdata[3] = TCP_MSS(dev) & 255; pbuf->optdata[3] = TCP_MSS(dev) & 255;
dev->d_len = IPTCP_HDRLEN + TCP_OPT_MSS_LEN; dev->d_len = IPv4TCP_HDRLEN + TCP_OPT_MSS_LEN;
pbuf->tcpoffset = ((TCP_HDRLEN + TCP_OPT_MSS_LEN) / 4) << 4; pbuf->tcpoffset = ((TCP_HDRLEN + TCP_OPT_MSS_LEN) / 4) << 4;
/* Complete the common portions of the TCP message */ /* Complete the common portions of the TCP message */

8
net/tcp/tcp_timer.c
View File

@ -100,8 +100,8 @@ void tcp_timer(FAR struct net_driver_s *dev, FAR struct tcp_conn_s *conn,
{ {
uint8_t result; uint8_t result;
dev->d_snddata = &dev->d_buf[IPTCP_HDRLEN + NET_LL_HDRLEN(dev)]; dev->d_snddata = &dev->d_buf[IPv4TCP_HDRLEN + NET_LL_HDRLEN(dev)];
dev->d_appdata = &dev->d_buf[IPTCP_HDRLEN + NET_LL_HDRLEN(dev)]; dev->d_appdata = &dev->d_buf[IPv4TCP_HDRLEN + NET_LL_HDRLEN(dev)];
/* Increase the TCP sequence number */ /* Increase the TCP sequence number */
@ -183,7 +183,7 @@ void tcp_timer(FAR struct net_driver_s *dev, FAR struct tcp_conn_s *conn,
/* We also send a reset packet to the remote host. */ /* We also send a reset packet to the remote host. */
tcp_send(dev, conn, TCP_RST | TCP_ACK, IPTCP_HDRLEN); tcp_send(dev, conn, TCP_RST | TCP_ACK, IPv4TCP_HDRLEN);
goto done; goto done;
} }
@ -234,7 +234,7 @@ void tcp_timer(FAR struct net_driver_s *dev, FAR struct tcp_conn_s *conn,
case TCP_LAST_ACK: case TCP_LAST_ACK:
/* In all these states we should retransmit a FINACK. */ /* In all these states we should retransmit a FINACK. */
tcp_send(dev, conn, TCP_FIN | TCP_ACK, IPTCP_HDRLEN); tcp_send(dev, conn, TCP_FIN | TCP_ACK, IPv4TCP_HDRLEN);
goto done; goto done;
} }
} }

50
net/udp/udp.h
View File

@ -62,6 +62,7 @@
/* Representation of a uIP UDP connection */ /* Representation of a uIP UDP connection */
struct devif_callback_s; /* Forward reference */ struct devif_callback_s; /* Forward reference */
struct udp_hdr_s; /* Forward reference */
struct udp_conn_s struct udp_conn_s
{ {
@ -96,8 +97,8 @@ extern "C"
* Public Function Prototypes * Public Function Prototypes
****************************************************************************/ ****************************************************************************/
struct udp_iphdr_s; /* Forward reference */
struct net_driver_s; /* Forward reference */ struct net_driver_s; /* Forward reference */
struct udp_iphdr_s; /* Forward reference */
/* Defined in udp_conn.c ****************************************************/ /* Defined in udp_conn.c ****************************************************/
/**************************************************************************** /****************************************************************************
@ -141,11 +142,12 @@ void udp_free(FAR struct udp_conn_s *conn);
* connection to be used within the provided TCP/IP header * connection to be used within the provided TCP/IP header
* *
* Assumptions: * Assumptions:
* This function is called from UIP logic at interrupt level * Called from network stack logic with the network stack locked
* *
****************************************************************************/ ****************************************************************************/
FAR struct udp_conn_s *udp_active(FAR struct udp_iphdr_s *buf); FAR struct udp_conn_s *udp_active(FAR struct net_driver_s *dev,
FAR struct udp_hdr_s *udp);
/**************************************************************************** /****************************************************************************
* Name: udp_nextconn() * Name: udp_nextconn()
@ -154,8 +156,7 @@ FAR struct udp_conn_s *udp_active(FAR struct udp_iphdr_s *buf);
* Traverse the list of allocated UDP connections * Traverse the list of allocated UDP connections
* *
* Assumptions: * Assumptions:
* This function is called from UIP logic at interrupt level (or with * Called from network stack logic with the network stack locked
* interrupts disabled).
* *
****************************************************************************/ ****************************************************************************/
@ -224,7 +225,7 @@ int udp_connect(FAR struct udp_conn_s *conn,
* None * None
* *
* Assumptions: * Assumptions:
* Called from the interrupt level or with interrupts disabled. * Called from network stack logic with the network stack locked
* *
****************************************************************************/ ****************************************************************************/
@ -245,7 +246,7 @@ void udp_poll(FAR struct net_driver_s *dev, FAR struct udp_conn_s *conn);
* None * None
* *
* Assumptions: * Assumptions:
* Called from the interrupt level or with interrupts disabled. * Called from network stack logic with the network stack locked
* *
****************************************************************************/ ****************************************************************************/
@ -253,10 +254,10 @@ void udp_send(FAR struct net_driver_s *dev, FAR struct udp_conn_s *conn);
/* Defined in udp_input.c ***************************************************/ /* Defined in udp_input.c ***************************************************/
/**************************************************************************** /****************************************************************************
* Name: udp_input * Name: udp_ipv4_input
* *
* Description: * Description:
* Handle incoming UDP input * Handle incoming UDP input in an IPv4 packet
* *
* Parameters: * Parameters:
* dev - The device driver structure containing the received UDP packet * dev - The device driver structure containing the received UDP packet
@ -267,11 +268,36 @@ void udp_send(FAR struct net_driver_s *dev, FAR struct udp_conn_s *conn);
* but no receive in place to catch the packet yet. * but no receive in place to catch the packet yet.
* *
* Assumptions: * Assumptions:
* Called from the interrupt level or with interrupts disabled. * Called from network stack logic with the network stack locked
* *
****************************************************************************/ ****************************************************************************/
int udp_input(FAR struct net_driver_s *dev); #ifdef CONFIG_NET_IPv4
int udp_ipv4_input(FAR struct net_driver_s *dev);
#endif
/****************************************************************************
* Name: udp_ipv6_input
*
* Description:
* Handle incoming UDP input in an IPv6 packet
*
* Parameters:
* dev - The device driver structure containing the received UDP packet
*
* Return:
* OK The packet has been processed and can be deleted
* ERROR Hold the packet and try again later. There is a listening socket
* but no receive in place to catch the packet yet.
*
* Assumptions:
* Called from network stack logic with the network stack locked
*
****************************************************************************/
#ifdef CONFIG_NET_IPv6
int udp_ipv6_input(FAR struct net_driver_s *dev);
#endif
/* Defined in udp_callback.c ************************************************/ /* Defined in udp_callback.c ************************************************/
/**************************************************************************** /****************************************************************************
@ -284,7 +310,7 @@ int udp_input(FAR struct net_driver_s *dev);
* OK if packet has been processed, otherwise ERROR. * OK if packet has been processed, otherwise ERROR.
* *
* Assumptions: * Assumptions:
* This function is called at the interrupt level with interrupts disabled. * Called from network stack logic with the network stack locked
* *
****************************************************************************/ ****************************************************************************/

22
net/udp/udp_conn.c
View File

@ -62,6 +62,12 @@
#include "netdev/netdev.h" #include "netdev/netdev.h"
#include "udp/udp.h" #include "udp/udp.h"
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
#define IPv4 ((struct net_iphdr_s *)&dev->d_buf[NET_LL_HDRLEN(dev)])
/**************************************************************************** /****************************************************************************
* Private Data * Private Data
****************************************************************************/ ****************************************************************************/
@ -342,11 +348,13 @@ void udp_free(FAR struct udp_conn_s *conn)
* *
****************************************************************************/ ****************************************************************************/
FAR struct udp_conn_s *udp_active(FAR struct udp_iphdr_s *buf) FAR struct udp_conn_s *udp_active(FAR struct net_driver_s *dev,
FAR struct udp_hdr_s *udp)
{ {
FAR struct udp_conn_s *conn = FAR struct net_iphdr_s *ip = IPv4;
(FAR struct udp_conn_s *)g_active_udp_connections.head; FAR struct udp_conn_s *conn;
conn = (FAR struct udp_conn_s *)g_active_udp_connections.head;
while (conn) while (conn)
{ {
/* If the local UDP port is non-zero, the connection is considered /* If the local UDP port is non-zero, the connection is considered
@ -370,16 +378,16 @@ FAR struct udp_conn_s *udp_active(FAR struct udp_iphdr_s *buf)
* is destined for this UDP connection. * is destined for this UDP connection.
*/ */
if (conn->lport != 0 && buf->destport == conn->lport && if (conn->lport != 0 && udp->destport == conn->lport &&
(conn->rport == 0 || buf->srcport == conn->rport) && (conn->rport == 0 || udp->srcport == conn->rport) &&
#ifdef CONFIG_NETDEV_MULTINIC #ifdef CONFIG_NETDEV_MULTINIC
(net_ipaddr_cmp(conn->lipaddr, g_allzeroaddr) || (net_ipaddr_cmp(conn->lipaddr, g_allzeroaddr) ||
net_ipaddr_cmp(conn->lipaddr, g_alloneaddr) || net_ipaddr_cmp(conn->lipaddr, g_alloneaddr) ||
net_ipaddr_hdrcmp(buf->destipaddr, &conn->lipaddr)) && net_ipaddr_hdrcmp(ip->destipaddr, &conn->lipaddr)) &&
#endif #endif
(net_ipaddr_cmp(conn->ripaddr, g_allzeroaddr) || (net_ipaddr_cmp(conn->ripaddr, g_allzeroaddr) ||
net_ipaddr_cmp(conn->ripaddr, g_alloneaddr) || net_ipaddr_cmp(conn->ripaddr, g_alloneaddr) ||
net_ipaddr_hdrcmp(buf->srcipaddr, &conn->ripaddr))) net_ipaddr_hdrcmp(ip->srcipaddr, &conn->ripaddr)))
{ {
/* Matching connection found.. return a reference to it */ /* Matching connection found.. return a reference to it */

95
net/udp/udp_input.c
View File

@ -60,8 +60,6 @@
* Pre-processor Definitions * Pre-processor Definitions
****************************************************************************/ ****************************************************************************/
#define UDPBUF ((struct udp_iphdr_s *)&dev->d_buf[NET_LL_HDRLEN(dev)])
/**************************************************************************** /****************************************************************************
* Public Variables * Public Variables
****************************************************************************/ ****************************************************************************/
@ -74,10 +72,6 @@
* Private Functions * Private Functions
****************************************************************************/ ****************************************************************************/
/****************************************************************************
* Public Functions
****************************************************************************/
/**************************************************************************** /****************************************************************************
* Name: udp_input * Name: udp_input
* *
@ -86,6 +80,8 @@
* *
* Parameters: * Parameters:
* dev - The device driver structure containing the received UDP packet * dev - The device driver structure containing the received UDP packet
* udp - A pointer to the UDP header in the packet
* udpiplen - Length of the IP and UDP headers
* *
* Return: * Return:
* OK The packet has been processed and can be deleted * OK The packet has been processed and can be deleted
@ -97,12 +93,15 @@
* *
****************************************************************************/ ****************************************************************************/
int udp_input(FAR struct net_driver_s *dev) static int udp_input(FAR struct net_driver_s *dev, FAR struct udp_hdr_s *udp,
unsigned int udpiplen)
{ {
FAR struct udp_conn_s *conn; FAR struct udp_conn_s *conn;
FAR struct udp_iphdr_s *pbuf = UDPBUF; unsigned int hdrlen;
int ret = OK; int ret = OK;
/* Update the count of UDP packets received */
#ifdef CONFIG_NET_STATISTICS #ifdef CONFIG_NET_STATISTICS
g_netstats.udp.recv++; g_netstats.udp.recv++;
#endif #endif
@ -112,10 +111,16 @@ int udp_input(FAR struct net_driver_s *dev)
* application sets d_sndlen, it has a packet to send. * application sets d_sndlen, it has a packet to send.
*/ */
dev->d_len -= IPUDP_HDRLEN; dev->d_len -= udpiplen;
/* Get the size of the link layer header, the IP header, and the UDP header */
hdrlen = udpiplen + NET_LL_HDRLEN(dev);
#ifdef CONFIG_NET_UDP_CHECKSUMS #ifdef CONFIG_NET_UDP_CHECKSUMS
dev->d_appdata = &dev->d_buf[NET_LL_HDRLEN(dev) + IPUDP_HDRLEN]; dev->d_appdata = &dev->d_buf[hdrlen];
if (pbuf->udpchksum != 0 && udp_chksum(dev) != 0xffff)
if (udp->udpchksum != 0 && udp_chksum(dev) != 0xffff)
{ {
#ifdef CONFIG_NET_STATISTICS #ifdef CONFIG_NET_STATISTICS
g_netstats.udp.drop++; g_netstats.udp.drop++;
@ -134,7 +139,7 @@ int udp_input(FAR struct net_driver_s *dev)
* receiving a UDP datagram (multicast reception). This could be * receiving a UDP datagram (multicast reception). This could be
* handled easily by something like: * handled easily by something like:
* *
* for (conn = NULL; conn = udp_active (pbuf, conn); ) * for (conn = NULL; conn = udp_active(dev, udp); )
* *
* If the callback logic that receives a packet responds with an * If the callback logic that receives a packet responds with an
* outgoing packet, then it will over-write the received buffer, * outgoing packet, then it will over-write the received buffer,
@ -143,15 +148,15 @@ int udp_input(FAR struct net_driver_s *dev)
* packet as read-only. * packet as read-only.
*/ */
conn = udp_active(pbuf); conn = udp_active(dev, udp);
if (conn) if (conn)
{ {
uint16_t flags; uint16_t flags;
/* Set-up for the application callback */ /* Set-up for the application callback */
dev->d_appdata = &dev->d_buf[NET_LL_HDRLEN(dev) + IPUDP_HDRLEN]; dev->d_appdata = &dev->d_buf[hdrlen];
dev->d_snddata = &dev->d_buf[NET_LL_HDRLEN(dev) + IPUDP_HDRLEN]; dev->d_snddata = &dev->d_buf[hdrlen];
dev->d_sndlen = 0; dev->d_sndlen = 0;
/* Perform the application callback */ /* Perform the application callback */
@ -188,4 +193,64 @@ int udp_input(FAR struct net_driver_s *dev)
return ret; return ret;
} }
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: udp_ipv4_input
*
* Description:
* Handle incoming UDP input in an IPv4 packet
*
* Parameters:
* dev - The device driver structure containing the received UDP packet
*
* Return:
* OK The packet has been processed and can be deleted
* ERROR Hold the packet and try again later. There is a listening socket
* but no receive in place to catch the packet yet.
*
* Assumptions:
* Called from network stack logic with the network stack locked
*
****************************************************************************/
#ifdef CONFIG_NET_IPv4
int udp_ipv4_input(FAR struct net_driver_s *dev)
{
unsigned int offset = IPv4_HDRLEN + NET_LL_HDRLEN(dev);
return udp_input(dev, (FAR struct udp_hdr_s *)&dev->d_buf[offset],
IPv4UDP_HDRLEN);
}
#endif
/****************************************************************************
* Name: udp_ipv6_input
*
* Description:
* Handle incoming UDP input in an IPv6 packet
*
* Parameters:
* dev - The device driver structure containing the received UDP packet
*
* Return:
* OK The packet has been processed and can be deleted
* ERROR Hold the packet and try again later. There is a listening socket
* but no receive in place to catch the packet yet.
*
* Assumptions:
* Called from network stack logic with the network stack locked
*
****************************************************************************/
#ifdef CONFIG_NET_IPv6
int udp_ipv6_input(FAR struct net_driver_s *dev)
{
unsigned int offset = IPv6_HDRLEN + NET_LL_HDRLEN(dev);
return udp_input(dev, (FAR struct udp_hdr_s *)&dev->d_buf[offset],
IPv6UDP_HDRLEN);
}
#endif
#endif /* CONFIG_NET && CONFIG_NET_UDP */ #endif /* CONFIG_NET && CONFIG_NET_UDP */

4
net/udp/udp_poll.c
View File

@ -100,8 +100,8 @@ void udp_poll(FAR struct net_driver_s *dev, FAR struct udp_conn_s *conn)
{ {
/* Set-up for the application callback */ /* Set-up for the application callback */
dev->d_appdata = &dev->d_buf[NET_LL_HDRLEN(dev) + IPUDP_HDRLEN]; dev->d_appdata = &dev->d_buf[NET_LL_HDRLEN(dev) + IPv4UDP_HDRLEN];
dev->d_snddata = &dev->d_buf[NET_LL_HDRLEN(dev) + IPUDP_HDRLEN]; dev->d_snddata = &dev->d_buf[NET_LL_HDRLEN(dev) + IPv4UDP_HDRLEN];
dev->d_len = 0; dev->d_len = 0;
dev->d_sndlen = 0; dev->d_sndlen = 0;

2
net/udp/udp_send.c
View File

@ -109,7 +109,7 @@ void udp_send(struct net_driver_s *dev, struct udp_conn_s *conn)
* the IP and UDP headers (and, eventually, the Ethernet header) * the IP and UDP headers (and, eventually, the Ethernet header)
*/ */
dev->d_len = dev->d_sndlen + IPUDP_HDRLEN; dev->d_len = dev->d_sndlen + IPv4UDP_HDRLEN;
/* Initialize the IP header. Note that for IPv6, the IP length field /* Initialize the IP header. Note that for IPv6, the IP length field
* does not include the IPv6 IP header length. * does not include the IPv6 IP header length.