nuttx/nuttx-mirror
1
2
Fork 0
mirror of https://github.com/apache/nuttx.git synced 2025-01-13 09:49:21 +08:00
Code Issues Projects Releases Packages Wiki Activity Actions

net/uip: Review all files in this directory for coding style and spelling

Browse source
This commit is contained in:
Gregory Nutt 2014-04-12 12:13:01 -06:00
parent a7789ce91f
commit dc0211b218
36 changed files with 183 additions and 144 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
net/net_send_buffered.c
View file

@ -269,7 +269,7 @@ static uint16_t send_interrupt(FAR struct uip_driver_s *dev, FAR void *pvconn,
* NOTE 1: This could be an expensive check if there are a lot of
* entries in the ARP table.
*
* NOTE 2: If we are actually harvesting IP addresses on incomming IP
* NOTE 2: If we are actually harvesting IP addresses on incoming IP
* packets, then this check should not be necessary; the MAC mapping
* should already be in the ARP table.
*/

2
net/net_sendfile.c
View file

@ -315,7 +315,7 @@ static uint16_t sendfile_interrupt(FAR struct uip_driver_s *dev, FAR void *pvcon
* in the ARP table. Hence, we only check on the first packet -- when
* snd_sent is zero.
*
* NOTE 2: If we are actually harvesting IP addresses on incomming IP
* NOTE 2: If we are actually harvesting IP addresses on incoming IP
* packets, then this check should not be necessary; the MAC mapping
* should already be in the ARP table.
*/

12
net/uip/uip_arp.c
View file

@ -240,6 +240,7 @@ void uip_arp_arpin(struct uip_driver_s *dev)
dev->d_len = 0;
return;
}
dev->d_len = 0;
ipaddr = uip_ip4addr_conv(parp->ah_dipaddr);
@ -327,7 +328,7 @@ void uip_arp_out(struct uip_driver_s *dev)
in_addr_t destipaddr;
/* Find the destination IP address in the ARP table and construct
* the Ethernet header. If the destination IP addres isn't on the
* the Ethernet header. If the destination IP address isn't on the
* local network, we use the default router's IP address instead.
*
* If not ARP table entry is found, we overwrite the original IP
@ -340,6 +341,7 @@ void uip_arp_out(struct uip_driver_s *dev)
{
memcpy(peth->dest, g_broadcast_ethaddr.ether_addr_octet, ETHER_ADDR_LEN);
}
#if defined(CONFIG_NET_IGMP) && !defined(CONFIG_NET_IPv6)
/* Check if the destination address is a multicast address
*
@ -353,7 +355,7 @@ void uip_arp_out(struct uip_driver_s *dev)
else if (NTOHS(pip->eh_destipaddr[0]) >= 0xe000 &&
NTOHS(pip->eh_destipaddr[0]) <= 0xefff)
{
/* Build the well-known IPv4 IGMP ethernet address. The first
/* Build the well-known IPv4 IGMP Ethernet address. The first
* three bytes are fixed; the final three variable come from the
* last three bytes of the IP address.
*/
@ -374,7 +376,7 @@ void uip_arp_out(struct uip_driver_s *dev)
#ifdef CONFIG_NET_ROUTE
/* We have a routing table.. find the correct router to use in
* this case (or, as a fallback, use the device's default router
* this case (or, as a fall-back, use the device's default router
* address). We will use the router IP address instead of the
* destination address when determining the MAC address.
*/
@ -426,12 +428,12 @@ void uip_arp_out(struct uip_driver_s *dev)
return;
}
/* Build an ethernet header. */
/* Build an Ethernet header. */
memcpy(peth->dest, tabptr->at_ethaddr.ether_addr_octet, ETHER_ADDR_LEN);
}
/* Finish populating the ethernet header */
/* Finish populating the Ethernet header */
memcpy(peth->src, dev->d_mac.ether_addr_octet, ETHER_ADDR_LEN);
peth->type = HTONS(UIP_ETHTYPE_IP);

7
net/uip/uip_arptab.c
View file

@ -199,7 +199,8 @@ void uip_arp_update(uint16_t *pipaddr, uint8_t *ethaddr)
if (i == CONFIG_NET_ARPTAB_SIZE)
{
uint8_t tmpage = 0;
int j = 0;
int j = 0;
for (i = 0; i < CONFIG_NET_ARPTAB_SIZE; ++i)
{
tabptr = &g_arptable[i];
@ -209,6 +210,7 @@ void uip_arp_update(uint16_t *pipaddr, uint8_t *ethaddr)
j = i;
}
}
i = j;
tabptr = &g_arptable[i];
}
@ -229,7 +231,7 @@ void uip_arp_update(uint16_t *pipaddr, uint8_t *ethaddr)
* Find the ARP entry corresponding to this IP address.
*
* Input parameters:
* ipaddr - Refers to an IP addressin network order
* ipaddr - Refers to an IP address in network order
*
* Assumptions
* Interrupts are disabled; Returned value will become unstable when
@ -250,6 +252,7 @@ struct arp_entry *uip_arp_find(in_addr_t ipaddr)
return tabptr;
}
}
return NULL;
}

5
net/uip/uip_callback.c
View file

@ -69,7 +69,7 @@ static FAR struct uip_callback_s *g_cbfreelist = NULL;
* Function: uip_callbackinit
*
* Description:
* Configure the pre-allocated callaback structures into a free list.
* Configure the pre-allocated callback structures into a free list.
* This is called internally as part of uIP initialization and should not
* be accessed from the application or socket layer.
*
@ -153,7 +153,8 @@ FAR struct uip_callback_s *uip_callbackalloc(FAR struct uip_callback_s **list)
*
****************************************************************************/
void uip_callbackfree(FAR struct uip_callback_s *cb, FAR struct uip_callback_s **list)
void uip_callbackfree(FAR struct uip_callback_s *cb,
FAR struct uip_callback_s **list)
{
FAR struct uip_callback_s *prev;
FAR struct uip_callback_s *curr;

4
net/uip/uip_chksum.c
View file

@ -84,6 +84,7 @@ static uint16_t chksum(uint16_t sum, const uint8_t *data, uint16_t len)
{
sum++; /* carry */
}
dataptr += 2;
}
@ -114,7 +115,7 @@ static uint16_t upper_layer_chksum(struct uip_driver_s *dev, uint8_t proto)
upper_layer_len = (((uint16_t)(pbuf->len[0]) << 8) + pbuf->len[1]) - UIP_IPH_LEN;
#endif /* CONFIG_NET_IPv6 */
/* First sum pseudoheader. */
/* First sum pseudo-header. */
/* IP protocol and length fields. This addition cannot carry. */
@ -226,5 +227,4 @@ uint16_t uip_icmpchksum(struct uip_driver_s *dev, int len)
#endif
#endif /* UIP_ARCH_CHKSUM */
#endif /* CONFIG_NET */

2
net/uip/uip_icmpinput.c
View file

@ -221,7 +221,7 @@ typeerr:
}
/* We should now send a neighbor advertisement back to where the
* neighbor solicication came from.
* neighbor solicitation came from.
*/
picmp->type = ICMP6_NEIGHBOR_ADVERTISEMENT;

4
net/uip/uip_icmpping.c
View file

@ -192,7 +192,7 @@ static uint16_t ping_interrupt(struct uip_driver_s *dev, void *conn,
* If the output buffer currently contains unprocessed incoming
* data.
* -OR-
* If we have alread sent the ECHO request
* If we have already sent the ECHO request
*
* In the first two cases, we will just have to wait for the next
* polling cycle.
@ -350,7 +350,7 @@ int uip_ping(uip_ipaddr_t addr, uint16_t id, uint16_t seqno,
state.png_cb->event = ping_interrupt;
state.png_result = -EINTR; /* Assume sem-wait interrupted by signal */
/* Notify the device driver of the availaibilty of TX data */
/* Notify the device driver of the availability of TX data */
netdev_txnotify(state.png_addr);

2
net/uip/uip_icmppoll.c
View file

@ -49,7 +49,7 @@
#include "uip_internal.h"
/****************************************************************************
* Definitions
* Pre-processor Definitions
****************************************************************************/
/****************************************************************************

4
net/uip/uip_icmpsend.c
View file

@ -49,7 +49,7 @@
#include "uip_internal.h"
/****************************************************************************
* Definitions
* Pre-processor Definitions
****************************************************************************/
#define ICMPBUF ((struct uip_icmpip_hdr *)&dev->d_buf[UIP_LLH_LEN])
@ -94,7 +94,7 @@ void uip_icmpsend(struct uip_driver_s *dev, uip_ipaddr_t *destaddr)
if (dev->d_sndlen > 0)
{
/* The total length to send is the size of the application data plus
* the IP and ICMP headers (and, eventually, the ethernet header)
* the IP and ICMP headers (and, eventually, the Ethernet header)
*/
dev->d_len = dev->d_sndlen + UIP_IPICMPH_LEN;

6
net/uip/uip_igmpgroup.c
View file

@ -163,7 +163,9 @@ static inline FAR struct igmp_group_s *uip_grpheapalloc(void)
#if CONFIG_PREALLOC_IGMPGROUPS > 0
static inline FAR struct igmp_group_s *uip_grpprealloc(void)
{
FAR struct igmp_group_s *group = (FAR struct igmp_group_s *)sq_remfirst(&g_freelist);
FAR struct igmp_group_s *group =
(FAR struct igmp_group_s *)sq_remfirst(&g_freelist);
if (group)
{
memset(group, 0, sizeof(struct igmp_group_s));
@ -361,7 +363,7 @@ void uip_grpfree(FAR struct uip_driver_s *dev, FAR struct igmp_group_s *group)
sq_rem((FAR sq_entry_t*)group, &dev->grplist);
/* Destroy the wait semapore */
/* Destroy the wait semaphore */
(void)sem_destroy(&group->sem);

8
net/uip/uip_igmpinput.c
View file

@ -59,7 +59,7 @@
* Pre-processor Definitions
****************************************************************************/
#define IGMPBUF ((struct uip_igmphdr_s *)&dev->d_buf[UIP_LLH_LEN])
#define IGMPBUF ((struct uip_igmphdr_s *)&dev->d_buf[UIP_LLH_LEN])
/****************************************************************************
* Private Functions
@ -156,8 +156,8 @@ void uip_igmpinput(struct uip_driver_s *dev)
/* RFC 2236, 2.2. ax Response Time
* "The Max Response Time field is meaningful only in Membership Query
* messages, and specifies the maximum allowed time before sending a
* responding report in units of 1/10 second. In all other messages, it
* is set to zero by the sender and ignored by receivers.
* responding report in units of 1/10 second. In all other messages,
* it is set to zero by the sender and ignored by receivers.
*/
/* Check if the query was sent to all systems */
@ -239,7 +239,7 @@ void uip_igmpinput(struct uip_driver_s *dev)
else if (group->grpaddr != 0)
{
nllvdbg("Unitcast queury\n");
nllvdbg("Unicast query\n");
IGMP_STATINCR(uip_stat.igmp.ucast_query);
nlldbg("Query to a specific group with the group address as destination\n");

6
net/uip/uip_igmppoll.c
View file

@ -81,7 +81,7 @@ static inline void uip_schedsend(FAR struct uip_driver_s *dev, FAR struct igmp_g
{
uip_ipaddr_t *dest;
/* Check what kind of messsage we need to send. There are only two
/* Check what kind of message we need to send. There are only two
* possibilities:
*/
@ -156,7 +156,9 @@ void uip_igmppoll(FAR struct uip_driver_s *dev)
/* Check each member of the group */
for (group = (FAR struct igmp_group_s *)dev->grplist.head; group; group = group->next)
for (group = (FAR struct igmp_group_s *)dev->grplist.head;
group;
group = group->next)
{
/* Does this member have a pending outgoing message? */

8
net/uip/uip_igmpsend.c
View file

@ -105,9 +105,9 @@ static uint16_t uip_igmpchksum(FAR uint8_t *buffer, int buflen)
* the IP header and calculates the IP header checksum.
*
* Parameters:
* dev - The device driver structure to use in the send operation.
* group - Describes the multicast group member and identifies the message
* to be sent.
* dev - The device driver structure to use in the send operation.
* group - Describes the multicast group member and identifies the
* message to be sent.
* destipaddr - The IP address of the recipient of the message
*
* Return:
@ -124,7 +124,7 @@ void uip_igmpsend(FAR struct uip_driver_s *dev, FAR struct igmp_group_s *group,
nllvdbg("msgid: %02x destipaddr: %08x\n", group->msgid, (int)*destipaddr);
/* The total length to send is the size of the IP and IGMP headers and 4
* bytes for the ROUTER ALERT (and, eventually, the ethernet header)
* bytes for the ROUTER ALERT (and, eventually, the Ethernet header)
*/
dev->d_len = UIP_IPIGMPH_LEN;

9
net/uip/uip_igmptimer.c
View file

@ -123,7 +123,7 @@ static void uip_igmptimeout(int argc, uint32_t arg, ...)
/* If the group exists and is no an IDLE MEMBER, then it must be a DELAYING
* member. Race conditions are avoided because (1) the timer is not started
* until after the first IGMPv2_MEMBERSHIP_REPORT during the join, and (2)
* the timer is canceled before sending the IGMP_LEAVE_GROUP during a leave.
* the timer is cancelled before sending the IGMP_LEAVE_GROUP during a leave.
*/
if (!IS_IDLEMEMBER(group->flags))
@ -141,7 +141,7 @@ static void uip_igmptimeout(int argc, uint32_t arg, ...)
* is stranded if both reports were lost? This is consistent with the
* RFC that states: "To cover the possibility of the initial Membership
* Report being lost or damaged, it is recommended that it be repeated
* once or twice after shortdelays [Unsolicited Report Interval]..."
* once or twice after short delays [Unsolicited Report Interval]..."
*/
}
}
@ -190,8 +190,11 @@ void uip_igmpstartticks(FAR struct igmp_group_s *group, int ticks)
/* Start the timer */
gtmrlldbg("ticks: %d\n", ticks);
ret = wd_start(group->wdog, ticks, uip_igmptimeout, 1, (uint32_t)group);
DEBUGASSERT(ret == OK);
UNUSED(ret);
}
void uip_igmpstarttimer(FAR struct igmp_group_s *group, uint8_t decisecs)
@ -213,7 +216,7 @@ void uip_igmpstarttimer(FAR struct igmp_group_s *group, uint8_t decisecs)
* avoid race conditions) and return true.
*
* Assumptions:
* This function may be called from most any context. If true is retuend
* This function may be called from most any context. If true is returned
* then the caller must call uip_igmpstartticks() to restart the timer
*
****************************************************************************/

6
net/uip/uip_input.c
View file

@ -65,7 +65,7 @@
* 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
* If the application wishes 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
@ -166,7 +166,7 @@ static uint8_t uip_reass(void)
}
/* Check if the incoming fragment matches the one currently present
* in the reasembly buffer. If so, we proceed with copying the
* in the reassembly buffer. If so, we proceed with copying the
* fragment into the buffer.
*/
@ -297,7 +297,6 @@ nullreturn:
* yet. Currently useful for UDP when a packet arrives before a recv
* call is in place.
*
*
* Assumptions:
*
****************************************************************************/
@ -329,6 +328,7 @@ int uip_input(struct uip_driver_s *dev)
nlldbg("Invalid IPv6 version: %d\n", pbuf->vtc >> 4);
goto drop;
}
#else /* CONFIG_NET_IPv6 */
/* Check validity of the IP header. */

2
net/uip/uip_internal.h
View file

@ -53,7 +53,7 @@
#include <nuttx/net/uip/uip.h>
/****************************************************************************
* Public Macro Definitions
* Pre-processor Definitions
****************************************************************************/
/****************************************************************************

5
net/uip/uip_listen.c
View file

@ -112,7 +112,7 @@ struct uip_conn *uip_findlistener(uint16_t portno)
* Setup the listening data structures
*
* Assumptions:
* Called early in the inialization phase while the system is still
* Called early in the initialization phase while the system is still
* single-threaded.
*
****************************************************************************/
@ -282,7 +282,8 @@ int uip_accept(struct uip_driver_s *dev, struct uip_conn *conn,
}
#endif
}
return ret;
return ret;
}
#endif /* CONFIG_NET */

8
net/uip/uip_neighbor.c
View file

@ -10,6 +10,7 @@
* 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
@ -91,6 +92,7 @@ void uip_neighbor_add(uip_ipaddr_t ipaddr, struct uip_neighbor_addr *addr)
oldest_time = 0;
oldest = 0;
for (i = 0; i < ENTRIES; ++i)
{
if (entries[i].time == MAX_TIME)
@ -130,6 +132,7 @@ static struct neighbor_entry *find_entry(uip_ipaddr_t ipaddr)
return &entries[i];
}
}
return NULL;
}
@ -156,7 +159,8 @@ struct uip_neighbor_addr *uip_neighbor_lookup(uip_ipaddr_t ipaddr)
e->addr.addr.ether_addr_octet[2], e->addr.addr.ether_addr_octet[3],
e->addr.addr.ether_addr_octet[4], e->addr.addr.ether_addr_octet[5]);
return &e->addr;
}
return &e->addr;
}
return NULL;
}

58
net/uip/uip_poll.c
View file

@ -69,7 +69,8 @@
****************************************************************************/
#if defined(CONFIG_NET_ICMP) && defined(CONFIG_NET_ICMP_PING)
static inline int uip_pollicmp(struct uip_driver_s *dev, uip_poll_callback_t callback)
static inline int uip_pollicmp(FAR struct uip_driver_s *dev,
uip_poll_callback_t callback)
{
/* Perform the UDP TX poll */
@ -94,7 +95,8 @@ static inline int uip_pollicmp(struct uip_driver_s *dev, uip_poll_callback_t cal
****************************************************************************/
#ifdef CONFIG_NET_IGMP
static inline int uip_polligmp(struct uip_driver_s *dev, uip_poll_callback_t callback)
static inline int uip_polligmp(FAR struct uip_driver_s *dev,
uip_poll_callback_t callback)
{
/* Perform the UDP TX poll */
@ -113,17 +115,17 @@ static inline int uip_polligmp(struct uip_driver_s *dev, uip_poll_callback_t cal
* Poll all UDP connections for available packets to send.
*
* Assumptions:
* This function is called from the MAC device driver and may be called from
* the timer interrupt/watchdog handle level.
* This function is called from the MAC device driver and may be called
* from the timer interrupt/watchdog handle level.
*
****************************************************************************/
#ifdef CONFIG_NET_UDP
static int uip_polludpconnections(struct uip_driver_s *dev,
static int uip_polludpconnections(FAR struct uip_driver_s *dev,
uip_poll_callback_t callback)
{
struct uip_udp_conn *udp_conn = NULL;
int bstop = 0;
FAR struct uip_udp_conn *udp_conn = NULL;
int bstop = 0;
/* Traverse all of the allocated UDP connections and perform the poll action */
@ -149,17 +151,17 @@ static int uip_polludpconnections(struct uip_driver_s *dev,
* Poll all UDP connections for available packets to send.
*
* Assumptions:
* This function is called from the MAC device driver and may be called from
* the timer interrupt/watchdog handle level.
* This function is called from the MAC device driver and may be called
* from the timer interrupt/watchdog handle level.
*
****************************************************************************/
#ifdef CONFIG_NET_TCP
static inline int uip_polltcpconnections(struct uip_driver_s *dev,
static inline int uip_polltcpconnections(FAR struct uip_driver_s *dev,
uip_poll_callback_t callback)
{
struct uip_conn *conn = NULL;
int bstop = 0;
FAR struct uip_conn *conn = NULL;
int bstop = 0;
/* Traverse all of the active TCP connections and perform the poll action */
@ -194,11 +196,11 @@ static inline int uip_polltcpconnections(struct uip_driver_s *dev,
****************************************************************************/
#ifdef CONFIG_NET_TCP
static inline int uip_polltcptimer(struct uip_driver_s *dev,
static inline int uip_polltcptimer(FAR struct uip_driver_s *dev,
uip_poll_callback_t callback, int hsec)
{
struct uip_conn *conn = NULL;
int bstop = 0;
FAR struct uip_conn *conn = NULL;
int bstop = 0;
/* Traverse all of the active TCP connections and perform the poll action */
@ -229,11 +231,12 @@ static inline int uip_polltcptimer(struct uip_driver_s *dev,
* Description:
* This function will traverse each active uIP connection structure and
* will perform TCP and UDP polling operations. uip_poll() may be called
* asychronously with the network drvier can accept another outgoing packet.
* asynchronously with the network driver can accept another outgoing
* packet.
*
* This function will call the provided callback function for every active
* connection. Polling will continue until all connections have been polled
* or until the user-suplied function returns a non-zero value (which it
* or until the user-supplied function returns a non-zero value (which it
* should do only if it cannot accept further write data).
*
* When the callback function is called, there may be an outbound packet
@ -242,16 +245,16 @@ static inline int uip_polltcptimer(struct uip_driver_s *dev,
* out the packet.
*
* Assumptions:
* This function is called from the MAC device driver and may be called from
* the timer interrupt/watchdog handle level.
* This function is called from the MAC device driver and may be called
* from the timer interrupt/watchdog handle level.
*
****************************************************************************/
int uip_poll(struct uip_driver_s *dev, uip_poll_callback_t callback)
int uip_poll(FAR struct uip_driver_s *dev, uip_poll_callback_t callback)
{
int bstop;
/* Check for pendig IGMP messages */
/* Check for pending IGMP messages */
#ifdef CONFIG_NET_IGMP
bstop = uip_polligmp(dev, callback);
@ -264,14 +267,18 @@ int uip_poll(struct uip_driver_s *dev, uip_poll_callback_t callback)
if (!bstop)
{
#ifdef CONFIG_NET_UDP
/* Traverse all of the allocated UDP connections and perform the poll action */
/* Traverse all of the allocated UDP connections and perform the
* poll action.
*/
bstop = uip_polludpconnections(dev, callback);
if (!bstop)
#endif
{
#if defined(CONFIG_NET_ICMP) && defined(CONFIG_NET_ICMP_PING)
/* Traverse all of the tasks waiting to send an ICMP ECHO request */
/* Traverse all of the tasks waiting to send an ICMP ECHO
* request
*/
bstop = uip_pollicmp(dev, callback);
#endif
@ -292,7 +299,7 @@ int uip_poll(struct uip_driver_s *dev, uip_poll_callback_t callback)
*
* This function will call the provided callback function for every active
* connection. Polling will continue until all connections have been polled
* or until the user-suplied function returns a non-zero value (which it
* or until the user-supplied function returns a non-zero value (which it
* should do only if it cannot accept further write data).
*
* When the callback function is called, there may be an outbound packet
@ -306,7 +313,8 @@ int uip_poll(struct uip_driver_s *dev, uip_poll_callback_t callback)
*
****************************************************************************/
int uip_timer(struct uip_driver_s *dev, uip_poll_callback_t callback, int hsec)
int uip_timer(FAR struct uip_driver_s *dev, uip_poll_callback_t callback,
int hsec)
{
int bstop;

4
net/uip/uip_send.c
View file

@ -48,7 +48,7 @@
#include <nuttx/net/uip/uip-arch.h>
/****************************************************************************
* Definitions
* Pre-processor Definitions
****************************************************************************/
/****************************************************************************
@ -87,7 +87,7 @@
* the network interface driver.
*
* Assumptions:
* Called from the interrupt level or, at a mimimum, with interrupts
* Called from the interrupt level or, at a minimum, with interrupts
* disabled.
*
****************************************************************************/

1
net/uip/uip_setipid.c
View file

@ -4,7 +4,6 @@
* Copyright (C) 2007, 2009 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <gnutt@nuttx.org>
*
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:

2
net/uip/uip_tcpappsend.c
View file

@ -55,7 +55,7 @@
#include "uip_internal.h"
/****************************************************************************
* Definitions
* Pre-processor Definitions
****************************************************************************/
/****************************************************************************

3
net/uip/uip_tcpbacklog.c
View file

@ -107,7 +107,7 @@ int uip_backlogcreate(FAR struct uip_conn *conn, int nblg)
/* Then determine the full size of the allocation include the
* uip_backlog_s, a pre-allocated array of struct uip_blcontainer_s
* and alignement padding
* and alignment padding
*/
size = offset + nblg * sizeof(struct uip_blcontainer_s);
@ -399,6 +399,7 @@ int uip_backlogdelete(FAR struct uip_conn *conn, FAR struct uip_conn *blconn)
nlldbg("Failed to find pending connection\n");
return -EINVAL;
}
return OK;
}

23
net/uip/uip_tcpcallback.c
View file

@ -63,7 +63,7 @@
* Function: uip_readahead
*
* Description:
* Copy as much received data as possible into the readahead buffer
* Copy as much received data as possible into the read-ahead buffer
*
* Assumptions:
* This function is called at the interrupt level with interrupts disabled.
@ -71,8 +71,8 @@
****************************************************************************/
#ifdef CONFIG_NET_TCP_READAHEAD
static int uip_readahead(struct uip_readahead_s *readahead, uint8_t *buf,
int len)
static int uip_readahead(FAR struct uip_readahead_s *readahead,
FAR uint8_t *buf, int len)
{
int available = CONFIG_NET_TCP_READAHEAD_BUFSIZE - readahead->rh_nbytes;
int recvlen = 0;
@ -95,6 +95,7 @@ static int uip_readahead(struct uip_readahead_s *readahead, uint8_t *buf,
memcpy(&readahead->rh_buffer[readahead->rh_nbytes], buf, recvlen);
readahead->rh_nbytes += recvlen;
}
return recvlen;
}
#endif
@ -216,7 +217,7 @@ uint16_t uip_tcpcallback(struct uip_driver_s *dev, struct uip_conn *conn,
* attempted.
* UIP_SNDACK - If UIP_NEWDATA is cleared, then UIP_SNDACK may be set
* to indicate that an ACK should be included in the response.
* (In UIP_NEWDATA is cleared bu UIP_SNDACK is not set, then
* (In UIP_NEWDATA is cleared but UIP_SNDACK is not set, then
* dev->d_len should also be cleared).
*/
@ -259,7 +260,7 @@ uint16_t uip_tcpcallback(struct uip_driver_s *dev, struct uip_conn *conn,
* (2) from the TCP event logic is there is no listener in place ready to
* receive the data.
*
* Input Parmeters:
* Input Parameters:
* conn - A pointer to the TCP connection structure
* buffer - A pointer to the buffer to be copied to the read-ahead
* buffers
@ -287,11 +288,11 @@ uint16_t uip_datahandler(FAR struct uip_conn *conn, FAR uint8_t *buffer,
/* First, we need to determine if we have space to buffer the data. This
* needs to be verified before we actually begin buffering the data. We
* will use any remaining space in the last allocated readahead buffer
* will use any remaining space in the last allocated read-ahead buffer
* plus as much one additional buffer. It is expected that the size of
* readahead buffers are tuned so that one full packet will always fit
* into one readahead buffer (for example if the buffer size is 420, then
* a readahead buffer of 366 will hold a full packet of TCP data).
* read-ahead buffers are tuned so that one full packet will always fit
* into one read-ahead buffer (for example if the buffer size is 420, then
* a read-ahead buffer of 366 will hold a full packet of TCP data).
*/
readahead1 = (FAR struct uip_readahead_s*)conn->readahead.tail;
@ -300,7 +301,7 @@ uint16_t uip_datahandler(FAR struct uip_conn *conn, FAR uint8_t *buffer,
(readahead2 = uip_tcpreadahead_alloc()) != NULL)
{
/* We have buffer space. Now try to append add as much data as possible
* to the last readahead buffer attached to this connection.
* to the last read-ahead buffer attached to this connection.
*/
remaining = buflen;
@ -321,7 +322,7 @@ uint16_t uip_datahandler(FAR struct uip_conn *conn, FAR uint8_t *buffer,
readahead2->rh_nbytes = 0;
recvlen += uip_readahead(readahead2, buffer, remaining);
/* Save the readahead buffer in the connection structure where
/* Save the read-ahead buffer in the connection structure where
* it can be found with recv() is called.
*/

16
net/uip/uip_tcpconn.c
View file

@ -89,8 +89,8 @@ static uint16_t g_last_tcp_port;
* Name: uip_selectport()
*
* Description:
* If the portnumber is zero; select an unused port for the connection.
* If the portnumber is non-zero, verify that no other connection has
* If the port number is zero; select an unused port for the connection.
* If the port number is non-zero, verify that no other connection has
* been created with this port number.
*
* Input Parameters:
@ -164,7 +164,7 @@ static int uip_selectport(uint16_t portno)
*
* Description:
* Initialize the TCP/IP connection structures. Called only once and only
* from the UIP layer at startup in normal user mode.
* from the UIP layer at start-up in normal user mode.
*
****************************************************************************/
@ -221,7 +221,7 @@ struct uip_conn *uip_tcpalloc(void)
if (!conn)
{
/* As a fallback, check for connection structures which can be stalled.
/* As a fall-back, check for connection structures which can be stalled.
*
* Search the active connection list for the oldest connection
* that is in the UIP_TIME_WAIT or UIP_FIN_WAIT_1 state.
@ -462,7 +462,7 @@ struct uip_conn *uip_nexttcpconn(struct uip_conn *conn)
* connection that listens on this this port.
*
* Primary uses: (1) to determine if a port number is available, (2) to
* To idenfity the socket that will accept new connections on a local port.
* To identify the socket that will accept new connections on a local port.
*
****************************************************************************/
@ -478,7 +478,7 @@ struct uip_conn *uip_tcplistener(uint16_t portno)
conn = &g_tcp_connections[i];
if (conn->tcpstateflags != UIP_CLOSED && conn->lport == portno)
{
/* The portnumber is in use, return the connection */
/* The port number is in use, return the connection */
return conn;
}
@ -614,7 +614,7 @@ int uip_tcpbind(struct uip_conn *conn, const struct sockaddr_in *addr)
* TCP connect() operation: It connects to a remote host using TCP.
*
* This function is used to start a new connection to the specified
* port on the specied host. It uses the connection structure that was
* port on the specified host. It uses the connection structure that was
* allocated by a preceding socket() call. It sets the connection to
* the SYN_SENT state and sets the retransmission timer to 0. This will
* cause a TCP SYN segment to be sent out the next time this connection
@ -645,7 +645,7 @@ int uip_tcpconnect(struct uip_conn *conn, const struct sockaddr_in *addr)
return -EISCONN;
}
/* If the TCP port has not alread been bound to a local port, then select
/* If the TCP port has not already been bound to a local port, then select
* one now.
*/

9
net/uip/uip_tcpinput.c
View file

@ -354,7 +354,7 @@ found:
uint32_t ackseq;
/* The next sequence number is equal to the current sequence
* number (sndseq) plus the size of the oustanding, unacknowledged
* number (sndseq) plus the size of the outstanding, unacknowledged
* data (unacked).
*/
@ -379,7 +379,7 @@ found:
if (ackseq <= unackseq)
{
/* Calculate the new number of oustanding, unacknowledged bytes */
/* Calculate the new number of outstanding, unacknowledged bytes */
conn->unacked = unackseq - ackseq;
}
@ -487,6 +487,7 @@ found:
uip_tcpack(dev, conn, TCP_ACK | TCP_SYN);
return;
}
goto drop;
case UIP_SYN_SENT:
@ -584,6 +585,7 @@ found:
{
goto drop;
}
uip_tcpreset(dev);
return;
@ -668,7 +670,7 @@ found:
/* If d_len > 0 we have TCP data in the packet, and we flag this
* by setting the UIP_NEWDATA flag. If the application has stopped
* the dataflow using uip_stop(), we must not accept any data
* the data flow using uip_stop(), we must not accept any data
* packets from the remote host.
*/
@ -727,6 +729,7 @@ found:
uip_tcpappsend(dev, conn, result);
return;
}
goto drop;
case UIP_LAST_ACK:

2
net/uip/uip_tcppoll.c
View file

@ -108,7 +108,7 @@ void uip_tcppoll(struct uip_driver_s *dev, struct uip_conn *conn)
dev->d_len = 0;
dev->d_sndlen = 0;
/* Perfom the callback */
/* Perform the callback */
result = uip_tcpcallback(dev, conn, UIP_POLL);

2
net/uip/uip_tcpreadahead.c
View file

@ -108,7 +108,7 @@ void uip_tcpreadahead_init(void)
* Description:
* Allocate a TCP read-ahead buffer by taking a pre-allocated buffer from
* the free list. This function is called from TCP logic when new,
* incoming TCP data is received but there is no user logic recving the
* incoming TCP data is received but there is no user logic receiving the
* the data. Note: kmalloc() cannot be used because this function is
* called from interrupt level.
*

36
net/uip/uip_tcpsend.c
View file

@ -80,7 +80,7 @@
* up IP header and computes the TCP checksum
*
* Parameters:
* dev - The device driver structure to use in the send operation
* dev - The device driver structure to use in the send operation
*
* Return:
* None
@ -90,9 +90,9 @@
*
****************************************************************************/
static void uip_tcpsendcomplete(struct uip_driver_s *dev)
static void uip_tcpsendcomplete(FAR struct uip_driver_s *dev)
{
struct uip_tcpip_hdr *pbuf = BUF;
FAR struct uip_tcpip_hdr *pbuf = BUF;
pbuf->ttl = UIP_TTL;
@ -160,8 +160,8 @@ static void uip_tcpsendcomplete(struct uip_driver_s *dev)
* 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
* dev - The device driver structure to use in the send operation
* conn - The TCP connection structure holding connection information
*
* Return:
* None
@ -171,9 +171,10 @@ static void uip_tcpsendcomplete(struct uip_driver_s *dev)
*
****************************************************************************/
static void uip_tcpsendcommon(struct uip_driver_s *dev, struct uip_conn *conn)
static void uip_tcpsendcommon(FAR struct uip_driver_s *dev,
FAR struct uip_conn *conn)
{
struct uip_tcpip_hdr *pbuf = BUF;
FAR struct uip_tcpip_hdr *pbuf = BUF;
memcpy(pbuf->ackno, conn->rcvseq, 4);
memcpy(pbuf->seqno, conn->sndseq, 4);
@ -205,7 +206,6 @@ static void uip_tcpsendcommon(struct uip_driver_s *dev, struct uip_conn *conn)
*/
uip_tcpsendcomplete(dev);
}
/****************************************************************************
@ -232,10 +232,10 @@ static void uip_tcpsendcommon(struct uip_driver_s *dev, struct uip_conn *conn)
*
****************************************************************************/
void uip_tcpsend(struct uip_driver_s *dev, struct uip_conn *conn,
void uip_tcpsend(FAR struct uip_driver_s *dev, FAR struct uip_conn *conn,
uint16_t flags, uint16_t len)
{
struct uip_tcpip_hdr *pbuf = BUF;
FAR struct uip_tcpip_hdr *pbuf = BUF;
pbuf->flags = flags;
dev->d_len = len;
@ -260,12 +260,11 @@ void uip_tcpsend(struct uip_driver_s *dev, struct uip_conn *conn,
*
****************************************************************************/
void uip_tcpreset(struct uip_driver_s *dev)
void uip_tcpreset(FAR struct uip_driver_s *dev)
{
struct uip_tcpip_hdr *pbuf = BUF;
FAR struct uip_tcpip_hdr *pbuf = BUF;
uint16_t tmp16;
uint8_t seqbyte;
uint8_t seqbyte;
#ifdef CONFIG_NET_STATISTICS
uip_stat.tcp.rst++;
@ -332,9 +331,9 @@ void uip_tcpreset(struct uip_driver_s *dev)
* 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
* 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
@ -344,7 +343,8 @@ void uip_tcpreset(struct uip_driver_s *dev)
*
****************************************************************************/
void uip_tcpack(struct uip_driver_s *dev, struct uip_conn *conn, uint8_t ack)
void uip_tcpack(FAR struct uip_driver_s *dev, FAR struct uip_conn *conn,
uint8_t ack)
{
struct uip_tcpip_hdr *pbuf = BUF;

9
net/uip/uip_tcptimer.c
View file

@ -81,9 +81,9 @@
* 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
* hsed - The polling interval in halves of a second
* dev - The device driver structure to use in the send operation
* conn - The TCP "connection" to poll for TX data
* hsed - The polling interval in halves of a second
*
* Return:
* None
@ -93,7 +93,8 @@
*
****************************************************************************/
void uip_tcptimer(struct uip_driver_s *dev, struct uip_conn *conn, int hsec)
void uip_tcptimer(FAR struct uip_driver_s *dev, FAR struct uip_conn *conn,
int hsec)
{
uint8_t result;

7
net/uip/uip_tcpwrbuffer.c
View file

@ -122,7 +122,8 @@ void uip_tcpwrbuffer_init(void)
*
****************************************************************************/
FAR struct uip_wrbuffer_s *uip_tcpwrbuffer_alloc(FAR const struct timespec *abstime)
FAR struct uip_wrbuffer_s *
uip_tcpwrbuffer_alloc(FAR const struct timespec *abstime)
{
int ret;
@ -148,8 +149,8 @@ FAR struct uip_wrbuffer_s *uip_tcpwrbuffer_alloc(FAR const struct timespec *abst
*
* Description:
* Release a TCP write buffer by returning the buffer to the free list.
* This function is called from user logic after it is consumed the buffered
* data.
* This function is called from user logic after it is consumed the
* buffered data.
*
* Assumptions:
* Called from interrupt level with interrupts disabled.

33
net/uip/uip_udpconn.c
View file

@ -95,7 +95,7 @@ static uint16_t g_last_udp_port;
*
****************************************************************************/
static inline void _uip_semtake(sem_t *sem)
static inline void _uip_semtake(FAR sem_t *sem)
{
/* Take the semaphore (perhaps waiting) */
@ -120,7 +120,7 @@ static inline void _uip_semtake(sem_t *sem)
*
****************************************************************************/
static struct uip_udp_conn *uip_find_conn(uint16_t portno)
static FAR struct uip_udp_conn *uip_find_conn(uint16_t portno)
{
int i;
@ -143,7 +143,7 @@ static struct uip_udp_conn *uip_find_conn(uint16_t portno)
* Description:
* Select an unused port number.
*
* NOTE that in prinicple this function could fail if there is no available
* NOTE that in principle this function could fail if there is no available
* port number. There is no check for that case and it would actually
* in an infinite loop if that were the case. In this simple, small UDP
* implementation, it is reasonable to assume that that error cannot happen
@ -231,7 +231,7 @@ void uip_udpinit(void)
* Name: uip_udpalloc()
*
* Description:
* Alloc a new, uninitialized UDP connection structure.
* Allocate a new, uninitialized UDP connection structure.
*
****************************************************************************/
@ -255,6 +255,7 @@ struct uip_udp_conn *uip_udpalloc(void)
dq_addlast(&conn->node, &g_active_udp_connections);
}
_uip_semgive(&g_free_sem);
return conn;
}
@ -295,16 +296,17 @@ void uip_udpfree(struct uip_udp_conn *conn)
*
* Description:
* Find a connection structure that is the appropriate
* connection to be used withi the provided TCP/IP header
* connection to be used within the provided TCP/IP header
*
* Assumptions:
* This function is called from UIP logic at interrupt level
*
****************************************************************************/
struct uip_udp_conn *uip_udpactive(struct uip_udpip_hdr *buf)
struct uip_udp_conn *uip_udpactive(FAR struct uip_udpip_hdr *buf)
{
struct uip_udp_conn *conn = (struct uip_udp_conn *)g_active_udp_connections.head;
FAR struct uip_udp_conn *conn =
(FAR struct uip_udp_conn *)g_active_udp_connections.head;
while (conn)
{
@ -348,7 +350,7 @@ struct uip_udp_conn *uip_udpactive(struct uip_udpip_hdr *buf)
*
****************************************************************************/
struct uip_udp_conn *uip_nextudpconn(struct uip_udp_conn *conn)
FAR struct uip_udp_conn *uip_nextudpconn(FAR struct uip_udp_conn *conn)
{
if (!conn)
{
@ -373,9 +375,11 @@ struct uip_udp_conn *uip_nextudpconn(struct uip_udp_conn *conn)
****************************************************************************/
#ifdef CONFIG_NET_IPv6
int uip_udpbind(struct uip_udp_conn *conn, const struct sockaddr_in6 *addr)
int uip_udpbind(FAR struct uip_udp_conn *conn,
FAR const struct sockaddr_in6 *addr)
#else
int uip_udpbind(struct uip_udp_conn *conn, const struct sockaddr_in *addr)
int uip_udpbind(FAR struct uip_udp_conn *conn,
FAR const struct sockaddr_in *addr)
#endif
{
int ret = -EADDRINUSE;
@ -408,6 +412,7 @@ int uip_udpbind(struct uip_udp_conn *conn, const struct sockaddr_in *addr)
uip_unlock(flags);
}
return ret;
}
@ -432,9 +437,11 @@ int uip_udpbind(struct uip_udp_conn *conn, const struct sockaddr_in *addr)
****************************************************************************/
#ifdef CONFIG_NET_IPv6
int uip_udpconnect(struct uip_udp_conn *conn, const struct sockaddr_in6 *addr)
int uip_udpconnect(FAR struct uip_udp_conn *conn,
FAR const struct sockaddr_in6 *addr)
#else
int uip_udpconnect(struct uip_udp_conn *conn, const struct sockaddr_in *addr)
int uip_udpconnect(FAR struct uip_udp_conn *conn,
FAR const struct sockaddr_in *addr)
#endif
{
/* Has this address already been bound to a local port (lport)? */
@ -461,7 +468,7 @@ int uip_udpconnect(struct uip_udp_conn *conn, const struct sockaddr_in *addr)
uip_ipaddr_copy(conn->ripaddr, g_allzeroaddr);
}
conn->ttl = UIP_TTL;
conn->ttl = UIP_TTL;
return OK;
}

6
net/uip/uip_udpinput.c
View file

@ -87,14 +87,14 @@
* 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 recv in place to catch the packet yet.
* but no receive in place to catch the packet yet.
*
* Assumptions:
* Called from the interrupt level or with interrupts disabled.
*
****************************************************************************/
int uip_udpinput(struct uip_driver_s *dev)
int uip_udpinput(FAR struct uip_driver_s *dev)
{
struct uip_udp_conn *conn;
struct uip_udpip_hdr *pbuf = UDPBUF;
@ -131,7 +131,7 @@ int uip_udpinput(struct uip_driver_s *dev)
{
uint16_t flags;
/* Setup for the application callback */
/* Set-up for the application callback */
dev->d_appdata = &dev->d_buf[UIP_LLH_LEN + UIP_IPUDPH_LEN];
dev->d_snddata = &dev->d_buf[UIP_LLH_LEN + UIP_IPUDPH_LEN];

6
net/uip/uip_udppoll.c
View file

@ -80,7 +80,7 @@
* Poll a UDP "connection" structure for availability of TX data
*
* Parameters:
* dev - The device driver structure to use in the send operation
* dev - The device driver structure to use in the send operation
* conn - The UDP "connection" to poll for TX data
*
* Return:
@ -91,13 +91,13 @@
*
****************************************************************************/
void uip_udppoll(struct uip_driver_s *dev, struct uip_udp_conn *conn)
void uip_udppoll(FAR struct uip_driver_s *dev, FAR struct uip_udp_conn *conn)
{
/* Verify that the UDP connection is valid */
if (conn->lport != 0)
{
/* Setup for the application callback */
/* Set-up for the application callback */
dev->d_appdata = &dev->d_buf[UIP_LLH_LEN + UIP_IPUDPH_LEN];
dev->d_snddata = &dev->d_buf[UIP_LLH_LEN + UIP_IPUDPH_LEN];

8
net/uip/uip_udpsend.c
View file

@ -78,10 +78,10 @@
* Name: uip_udpsend
*
* Description:
* Setup to send a UDP packet
* Set-up to send a UDP packet
*
* Parameters:
* dev - The device driver structure to use in the send operation
* dev - The device driver structure to use in the send operation
* conn - The UDP "connection" structure holding port information
*
* Return:
@ -98,8 +98,8 @@ void uip_udpsend(struct uip_driver_s *dev, struct uip_udp_conn *conn)
if (dev->d_sndlen > 0)
{
/* The total lenth to send is the size of the application data plus
* the IP and UDP headers (and, eventually, the ethernet header)
/* The total length to send is the size of the application data plus
* the IP and UDP headers (and, eventually, the Ethernet header)
*/
dev->d_len = dev->d_sndlen + UIP_IPUDPH_LEN;