Separate net/net_send_buffered.c and net/net_send_unbuffered.c to net/tcp/tcp_send_buffered.c, net/tcp/tcp_send_unbuffered.c, and pkt/pkt_send.c

9 files changed, 692 insertions, 309 deletions

diff --git a/nuttx/net/Makefile b/nuttx/net/Makefile
index 14d2da874..ab34e09f6 100644
--- a/nuttx/net/Makefile
+++ b/nuttx/net/Makefile
@@ -51,12 +51,6 @@ DEPPATH = --dep-path .
 
 ifeq ($(CONFIG_NET_TCP),y)
 SOCK_CSRCS += send.c listen.c accept.c net_monitor.c
-
-ifeq ($(CONFIG_NET_TCP_WRITE_BUFFERS),y)
-SOCK_CSRCS += net_send_buffered.c
-else
-SOCK_CSRCS += net_send_unbuffered.c
-endif
 endif
 
 # Socket options
diff --git a/nuttx/net/pkt/Make.defs b/nuttx/net/pkt/Make.defs
index f9ea5b270..b1ba37896 100644
--- a/nuttx/net/pkt/Make.defs
+++ b/nuttx/net/pkt/Make.defs
@@ -38,6 +38,13 @@ ifeq ($(CONFIG_NET),y)
 # Packet socket support
 
 ifeq ($(CONFIG_NET_PKT),y)
+
+# Socket layer
+
+SOCK_CSRCS += pkt_send.c
+
+# Transport layer
+
 NET_CSRCS += pkt_conn.c
 NET_CSRCS += pkt_input.c
 NET_CSRCS += pkt_callback.c
diff --git a/nuttx/net/pkt/pkt.h b/nuttx/net/pkt/pkt.h
new file mode 100644
index 000000000..b0d24f230
--- /dev/null
+++ b/nuttx/net/pkt/pkt.h
@@ -0,0 +1,140 @@
+/****************************************************************************
+ * net/pkt/pkt.h
+ *
+ *   Copyright (C) 2014 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:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ * 3. Neither the name NuttX nor the names of its contributors may be
+ *    used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ ****************************************************************************/
+
+#ifndef _NET_PKT_PKT_H
+#define _NET_PKT_PKT_H
+
+/****************************************************************************
+ * Included Files
+ ****************************************************************************/
+
+#include <nuttx/config.h>
+
+#include <sys/types.h>
+
+#ifdef CONFIG_NET_PKT
+
+/****************************************************************************
+ * Pre-processor Definitions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Public Type Definitions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Public Data
+ ****************************************************************************/
+
+#ifdef __cplusplus
+#  define EXTERN extern "C"
+extern "C"
+{
+#else
+#  define EXTERN extern
+#endif
+
+/****************************************************************************
+ * Public Function Prototypes
+ ****************************************************************************/
+
+/****************************************************************************
+ * Function: pkt_send
+ *
+ * Description:
+ *   The pkt_send() call may be used only when the packet socket is in a
+ *   connected state (so that the intended recipient is known).
+ *
+ * Parameters:
+ *   psock    An instance of the internal socket structure.
+ *   buf      Data to send
+ *   len      Length of data to send
+ *
+ * Returned Value:
+ *   On success, returns the number of characters sent.  On  error,
+ *   -1 is returned, and errno is set appropriately:
+ *
+ *   EAGAIN or EWOULDBLOCK
+ *     The socket is marked non-blocking and the requested operation
+ *     would block.
+ *   EBADF
+ *     An invalid descriptor was specified.
+ *   ECONNRESET
+ *     Connection reset by peer.
+ *   EDESTADDRREQ
+ *     The socket is not connection-mode, and no peer address is set.
+ *   EFAULT
+ *      An invalid user space address was specified for a parameter.
+ *   EINTR
+ *      A signal occurred before any data was transmitted.
+ *   EINVAL
+ *      Invalid argument passed.
+ *   EISCONN
+ *     The connection-mode socket was connected already but a recipient
+ *     was specified. (Now either this error is returned, or the recipient
+ *     specification is ignored.)
+ *   EMSGSIZE
+ *     The socket type requires that message be sent atomically, and the
+ *     size of the message to be sent made this impossible.
+ *   ENOBUFS
+ *     The output queue for a network interface was full. This generally
+ *     indicates that the interface has stopped sending, but may be
+ *     caused by transient congestion.
+ *   ENOMEM
+ *     No memory available.
+ *   ENOTCONN
+ *     The socket is not connected, and no target has been given.
+ *   ENOTSOCK
+ *     The argument s is not a socket.
+ *   EPIPE
+ *     The local end has been shut down on a connection oriented socket.
+ *     In this case the process will also receive a SIGPIPE unless
+ *     MSG_NOSIGNAL is set.
+ *
+ * Assumptions:
+ *
+ ****************************************************************************/
+
+struct socket;
+ssize_t pkt_send(FAR struct socket *psock, FAR const void *buf, size_t len);
+
+
+#undef EXTERN
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CONFIG_NET_PKT */
+#endif /* _NET_PKT_PKT_H */
diff --git a/nuttx/net/pkt/pkt_send.c b/nuttx/net/pkt/pkt_send.c
new file mode 100644
index 000000000..5cfd3d7de
--- /dev/null
+++ b/nuttx/net/pkt/pkt_send.c
@@ -0,0 +1,307 @@
+/****************************************************************************
+ * net/pkt/pkt_send.c
+ *
+ *   Copyright (C) 2014 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:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ * 3. Neither the name NuttX nor the names of its contributors may be
+ *    used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ ****************************************************************************/
+
+/****************************************************************************
+ * Included Files
+ ****************************************************************************/
+
+#include <nuttx/config.h>
+#if defined(CONFIG_NET) && defined(CONFIG_NET_PKT)
+
+#include <sys/types.h>
+#include <sys/socket.h>
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <string.h>
+#include <errno.h>
+#include <debug.h>
+
+#include <arch/irq.h>
+#include <nuttx/clock.h>
+#include <nuttx/net/arp.h>
+#include <nuttx/net/uip/uip-arch.h>
+#include <nuttx/net/uip/uip-pkt.h>
+
+#include "net_internal.h"
+#include "uip/uip_internal.h"
+
+/****************************************************************************
+ * Pre-processor Definitions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Private Types
+ ****************************************************************************/
+
+/* This structure holds the state of the send operation until it can be
+ * operated upon from the interrupt level.
+ */
+
+struct send_s
+{
+  FAR struct socket         *snd_sock;    /* Points to the parent socket structure */
+  FAR struct uip_callback_s *snd_cb;      /* Reference to callback instance */
+  sem_t                      snd_sem;     /* Used to wake up the waiting thread */
+  FAR const uint8_t         *snd_buffer;  /* Points to the buffer of data to send */
+  size_t                     snd_buflen;  /* Number of bytes in the buffer to send */
+  ssize_t                    snd_sent;    /* The number of bytes sent */
+};
+
+/****************************************************************************
+ * Private Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Function: pktsend_interrupt
+ ****************************************************************************/
+
+static uint16_t pktsend_interrupt(FAR struct uip_driver_s *dev,
+                                  FAR void *pvconn,
+                                  FAR void *pvpriv, uint16_t flags)
+{
+  FAR struct send_s *pstate = (FAR struct send_s *)pvpriv;
+
+  nllvdbg("flags: %04x sent: %d\n", flags, pstate->snd_sent);
+
+  if (pstate)
+    {
+      /* Check if the outgoing packet is available. If my have been claimed
+       * by a send interrupt serving a different thread -OR- if the output
+       * buffer currently contains unprocessed incoming data. In these cases
+       * we will just have to wait for the next polling cycle.
+       */
+
+      if (dev->d_sndlen > 0 || (flags & UIP_NEWDATA) != 0)
+        {
+          /* Another thread has beat us sending data or the buffer is busy,
+           * Check for a timeout. If not timed out, wait for the next
+           * polling cycle and check again.
+           */
+
+          /* No timeout. Just wait for the next polling cycle */
+
+          return flags;
+        }
+
+      /* It looks like we are good to send the data */
+
+      else
+        {
+          /* Copy the packet data into the device packet buffer and send it */
+
+          uip_pktsend(dev, pstate->snd_buffer, pstate->snd_buflen);
+          pstate->snd_sent = pstate->snd_buflen;
+        }
+
+      /* Don't allow any further call backs. */
+
+      pstate->snd_cb->flags    = 0;
+      pstate->snd_cb->priv     = NULL;
+      pstate->snd_cb->event    = NULL;
+
+      /* Wake up the waiting thread */
+
+      sem_post(&pstate->snd_sem);
+    }
+
+  return flags;
+}
+
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Function: pkt_send
+ *
+ * Description:
+ *   The pkt_send() call may be used only when the packet socket is in a
+ *   connected state (so that the intended recipient is known).
+ *
+ * Parameters:
+ *   psock    An instance of the internal socket structure.
+ *   buf      Data to send
+ *   len      Length of data to send
+ *
+ * Returned Value:
+ *   On success, returns the number of characters sent.  On  error,
+ *   -1 is returned, and errno is set appropriately:
+ *
+ *   EAGAIN or EWOULDBLOCK
+ *     The socket is marked non-blocking and the requested operation
+ *     would block.
+ *   EBADF
+ *     An invalid descriptor was specified.
+ *   ECONNRESET
+ *     Connection reset by peer.
+ *   EDESTADDRREQ
+ *     The socket is not connection-mode, and no peer address is set.
+ *   EFAULT
+ *      An invalid user space address was specified for a parameter.
+ *   EINTR
+ *      A signal occurred before any data was transmitted.
+ *   EINVAL
+ *      Invalid argument passed.
+ *   EISCONN
+ *     The connection-mode socket was connected already but a recipient
+ *     was specified. (Now either this error is returned, or the recipient
+ *     specification is ignored.)
+ *   EMSGSIZE
+ *     The socket type requires that message be sent atomically, and the
+ *     size of the message to be sent made this impossible.
+ *   ENOBUFS
+ *     The output queue for a network interface was full. This generally
+ *     indicates that the interface has stopped sending, but may be
+ *     caused by transient congestion.
+ *   ENOMEM
+ *     No memory available.
+ *   ENOTCONN
+ *     The socket is not connected, and no target has been given.
+ *   ENOTSOCK
+ *     The argument s is not a socket.
+ *   EPIPE
+ *     The local end has been shut down on a connection oriented socket.
+ *     In this case the process will also receive a SIGPIPE unless
+ *     MSG_NOSIGNAL is set.
+ *
+ * Assumptions:
+ *
+ ****************************************************************************/
+
+ssize_t pkt_send(FAR struct socket *psock, FAR const void *buf, size_t len)
+{
+  struct send_s state;
+  uip_lock_t save;
+  int err;
+  int ret = OK;
+
+  /* Verify that the sockfd corresponds to valid, allocated socket */
+
+  if (!psock || psock->s_crefs <= 0)
+    {
+      err = EBADF;
+      goto errout;
+    }
+
+  /* Set the socket state to sending */
+
+  psock->s_flags = _SS_SETSTATE(psock->s_flags, _SF_SEND);
+
+  /* Perform the send operation */
+
+  /* Initialize the state structure. This is done with interrupts
+   * disabled because we don't want anything to happen until we
+   * are ready.
+   */
+
+  save                = uip_lock();
+  memset(&state, 0, sizeof(struct send_s));
+  (void)sem_init(&state.snd_sem, 0, 0); /* Doesn't really fail */
+  state.snd_sock      = psock;          /* Socket descriptor to use */
+  state.snd_buflen    = len;            /* Number of bytes to send */
+  state.snd_buffer    = buf;            /* Buffer to send from */
+
+  if (len > 0)
+    {
+      struct uip_pkt_conn *conn = (struct uip_pkt_conn*)psock->s_conn;
+
+      /* Allocate resource to receive a callback */
+
+      state.snd_cb = uip_pktcallbackalloc(conn);
+      if (state.snd_cb)
+        {
+          /* Set up the callback in the connection */
+
+          state.snd_cb->flags = UIP_POLL;
+          state.snd_cb->priv  = (void*)&state;
+          state.snd_cb->event = pktsend_interrupt;
+
+          /* Notify the device driver of the availability of TX data */
+
+          struct uip_driver_s *dev = netdev_findbyname("eth0");
+          dev->d_txavail(dev);
+
+          /* Wait for the send to complete or an error to occure: NOTES: (1)
+           * uip_lockedwait will also terminate if a signal is received, (2)
+           * interrupts may be disabled! They will be re-enabled while the
+           * task sleeps and automatically re-enabled when the task restarts.
+           */
+
+          ret = uip_lockedwait(&state.snd_sem);
+
+          /* Make sure that no further interrupts are processed */
+
+          uip_pktcallbackfree(conn, state.snd_cb);
+        }
+    }
+
+  sem_destroy(&state.snd_sem);
+  uip_unlock(save);
+
+  /* Set the socket state to idle */
+
+  psock->s_flags = _SS_SETSTATE(psock->s_flags, _SF_IDLE);
+
+  /* Check for a errors, Errors are signalled by negative errno values
+   * for the send length
+   */
+
+  if (state.snd_sent < 0)
+    {
+      err = state.snd_sent;
+      goto errout;
+    }
+
+  /* If uip_lockedwait failed, then we were probably reawakened by a signal. In
+   * this case, uip_lockedwait will have set errno appropriately.
+   */
+
+  if (ret < 0)
+    {
+      err = -ret;
+      goto errout;
+    }
+
+  /* Return the number of bytes actually sent */
+
+  return state.snd_sent;
+
+errout:
+  set_errno(err);
+  return ERROR;
+}
+
+#endif /* CONFIG_NET && CONFIG_NET_PKT */
diff --git a/nuttx/net/send.c b/nuttx/net/send.c
index 3efa93b5a..cbec0f7de 100644
--- a/nuttx/net/send.c
+++ b/nuttx/net/send.c
@@ -43,6 +43,8 @@
 #include <sys/types.h>
 #include <sys/socket.h>
 
+#include "tcp/tcp.h"
+#include "pkt/pkt.h"
 #include "net_internal.h"
 
 /****************************************************************************
@@ -62,6 +64,102 @@
  ****************************************************************************/
 
 /****************************************************************************
+ * Function: psock_send
+ *
+ * Description:
+ *   The send() call may be used only when the socket is in a connected state
+ *   (so that the intended recipient is known). The only difference between
+ *   send() and write() is the presence of flags. With zero flags parameter,
+ *   send() is equivalent to write(). Also, send(sockfd,buf,len,flags) is
+ *   equivalent to sendto(sockfd,buf,len,flags,NULL,0).
+ *
+ * Parameters:
+ *   psock    An instance of the internal socket structure.
+ *   buf      Data to send
+ *   len      Length of data to send
+ *   flags    Send flags
+ *
+ * Returned Value:
+ *   On success, returns the number of characters sent.  On  error,
+ *   -1 is returned, and errno is set appropriately:
+ *
+ *   EAGAIN or EWOULDBLOCK
+ *     The socket is marked non-blocking and the requested operation
+ *     would block.
+ *   EBADF
+ *     An invalid descriptor was specified.
+ *   ECONNRESET
+ *     Connection reset by peer.
+ *   EDESTADDRREQ
+ *     The socket is not connection-mode, and no peer address is set.
+ *   EFAULT
+ *      An invalid user space address was specified for a parameter.
+ *   EINTR
+ *      A signal occurred before any data was transmitted.
+ *   EINVAL
+ *      Invalid argument passed.
+ *   EISCONN
+ *     The connection-mode socket was connected already but a recipient
+ *     was specified. (Now either this error is returned, or the recipient
+ *     specification is ignored.)
+ *   EMSGSIZE
+ *     The socket type requires that message be sent atomically, and the
+ *     size of the message to be sent made this impossible.
+ *   ENOBUFS
+ *     The output queue for a network interface was full. This generally
+ *     indicates that the interface has stopped sending, but may be
+ *     caused by transient congestion.
+ *   ENOMEM
+ *     No memory available.
+ *   ENOTCONN
+ *     The socket is not connected, and no target has been given.
+ *   ENOTSOCK
+ *     The argument s is not a socket.
+ *   EOPNOTSUPP
+ *     Some bit in the flags argument is inappropriate for the socket
+ *     type.
+ *   EPIPE
+ *     The local end has been shut down on a connection oriented socket.
+ *     In this case the process will also receive a SIGPIPE unless
+ *     MSG_NOSIGNAL is set.
+ *
+ * Assumptions:
+ *
+ ****************************************************************************/
+
+ssize_t psock_send(FAR struct socket *psock, FAR const void *buf, size_t len,
+                   int flags)
+{
+  int ret;
+
+  switch (psock->s_type)
+    {
+#if defined(CONFIG_NET_PKT)
+      case SOCK_RAW:
+        {
+          ret = pkt_send(psock, buf, len);
+          break;
+        }
+#endif
+
+#if defined(CONFIG_NET_TCP)
+      case SOCK_STREAM:
+        {
+          ret = tcp_send(psock, buf, len);
+          break;
+        }
+#endif
+
+      default:
+        {
+          ret = ERROR;
+        }
+    }
+
+  return ret;
+}
+
+/****************************************************************************
  * Function: send
  *
  * Description:
diff --git a/nuttx/net/tcp/Make.defs b/nuttx/net/tcp/Make.defs
index b70b90ec9..609fa24bb 100644
--- a/nuttx/net/tcp/Make.defs
+++ b/nuttx/net/tcp/Make.defs
@@ -39,6 +39,16 @@ ifeq ($(CONFIG_NET),y)
 
 ifeq ($(CONFIG_NET_TCP),y)
 
+# Socket layer
+
+ifeq ($(CONFIG_NET_TCP_WRITE_BUFFERS),y)
+SOCK_CSRCS += tcp_send_buffered.c
+else
+SOCK_CSRCS += tcp_send_unbuffered.c
+endif
+
+# Transport layer
+
 NET_CSRCS += tcp_conn.c tcp_seqno.c tcp_poll.c tcp_timer.c tcp_send.c
 NET_CSRCS += tcp_input.c tcp_appsend.c tcp_listen.c tcp_callback.c
 NET_CSRCS += tcp_backlog.c
diff --git a/nuttx/net/tcp/tcp.h b/nuttx/net/tcp/tcp.h
index c776e7e47..73fcdd9f8 100644
--- a/nuttx/net/tcp/tcp.h
+++ b/nuttx/net/tcp/tcp.h
@@ -42,6 +42,8 @@
 
 #include <nuttx/config.h>
 
+#include <sys/types.h>
+
 #ifdef CONFIG_NET_TCP
 
 /****************************************************************************
@@ -69,6 +71,66 @@ extern "C"
  ****************************************************************************/
 
 /****************************************************************************
+ * Function: tcp_send
+ *
+ * Description:
+ *   The tcp_send() call may be used only when the TCP socket is in a
+ *   connected state (so that the intended recipient is known).
+ *
+ * Parameters:
+ *   psock    An instance of the internal socket structure.
+ *   buf      Data to send
+ *   len      Length of data to send
+ *
+ * Returned Value:
+ *   On success, returns the number of characters sent.  On  error,
+ *   -1 is returned, and errno is set appropriately:
+ *
+ *   EAGAIN or EWOULDBLOCK
+ *     The socket is marked non-blocking and the requested operation
+ *     would block.
+ *   EBADF
+ *     An invalid descriptor was specified.
+ *   ECONNRESET
+ *     Connection reset by peer.
+ *   EDESTADDRREQ
+ *     The socket is not connection-mode, and no peer address is set.
+ *   EFAULT
+ *      An invalid user space address was specified for a parameter.
+ *   EINTR
+ *      A signal occurred before any data was transmitted.
+ *   EINVAL
+ *      Invalid argument passed.
+ *   EISCONN
+ *     The connection-mode socket was connected already but a recipient
+ *     was specified. (Now either this error is returned, or the recipient
+ *     specification is ignored.)
+ *   EMSGSIZE
+ *     The socket type requires that message be sent atomically, and the
+ *     size of the message to be sent made this impossible.
+ *   ENOBUFS
+ *     The output queue for a network interface was full. This generally
+ *     indicates that the interface has stopped sending, but may be
+ *     caused by transient congestion.
+ *   ENOMEM
+ *     No memory available.
+ *   ENOTCONN
+ *     The socket is not connected, and no target has been given.
+ *   ENOTSOCK
+ *     The argument s is not a socket.
+ *   EPIPE
+ *     The local end has been shut down on a connection oriented socket.
+ *     In this case the process will also receive a SIGPIPE unless
+ *     MSG_NOSIGNAL is set.
+ *
+ * Assumptions:
+ *
+ ****************************************************************************/
+
+struct socket;
+ssize_t tcp_send(FAR struct socket *psock, FAR const void *buf, size_t len);
+
+/****************************************************************************
  * Function: tcp_wrbuffer_initialize
  *
  * Description:
diff --git a/nuttx/net/net_send_buffered.c b/nuttx/net/tcp/tcp_send_buffered.c
index fc275b74c..8dbf797d5 100644
--- a/nuttx/net/net_send_buffered.c
+++ b/nuttx/net/tcp/tcp_send_buffered.c
@@ -1,5 +1,5 @@
 /****************************************************************************
- * net/net_send_buffered.c
+ * net/tcp/tcp_send_buffered.c
  *
  *   Copyright (C) 2007-2014 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
@@ -658,20 +658,16 @@ static uint16_t send_interrupt(FAR struct uip_driver_s *dev, FAR void *pvconn,
  ****************************************************************************/
 
 /****************************************************************************
- * Function: psock_send
+ * Function: tcp_send
  *
  * Description:
- *   The send() call may be used only when the socket is in a connected state
- *   (so that the intended recipient is known). The only difference between
- *   send() and write() is the presence of flags. With zero flags parameter,
- *   send() is equivalent to write(). Also, send(sockfd,buf,len,flags) is
- *   equivalent to sendto(sockfd,buf,len,flags,NULL,0).
+ *   The tcp_send() call may be used only when the TCP socket is in a
+ *   connected state (so that the intended recipient is known).
  *
  * Parameters:
  *   psock    An instance of the internal socket structure.
  *   buf      Data to send
  *   len      Length of data to send
- *   flags    Send flags
  *
  * Returned Value:
  *   On success, returns the number of characters sent.  On  error,
@@ -709,9 +705,6 @@ static uint16_t send_interrupt(FAR struct uip_driver_s *dev, FAR void *pvconn,
  *     The socket is not connected, and no target has been given.
  *   ENOTSOCK
  *     The argument s is not a socket.
- *   EOPNOTSUPP
- *     Some bit in the flags argument is inappropriate for the socket
- *     type.
  *   EPIPE
  *     The local end has been shut down on a connection oriented socket.
  *     In this case the process will also receive a SIGPIPE unless
@@ -721,8 +714,7 @@ static uint16_t send_interrupt(FAR struct uip_driver_s *dev, FAR void *pvconn,
  *
  ****************************************************************************/
 
-ssize_t psock_send(FAR struct socket *psock, FAR const void *buf, size_t len,
-                   int flags)
+ssize_t tcp_send(FAR struct socket *psock, FAR const void *buf, size_t len)
 {
   uip_lock_t save;
   ssize_t    result = 0;
@@ -743,7 +735,7 @@ ssize_t psock_send(FAR struct socket *psock, FAR const void *buf, size_t len,
 
   /* Dump the incoming buffer */
 
-  BUF_DUMP("psock_send", buf, len);
+  BUF_DUMP("tcp_send", buf, len);
 
   /* Set the socket state to sending */
 
diff --git a/nuttx/net/net_send_unbuffered.c b/nuttx/net/tcp/tcp_send_unbuffered.c
index f6f7a597e..34a71018f 100644
--- a/nuttx/net/net_send_unbuffered.c
+++ b/nuttx/net/tcp/tcp_send_unbuffered.c
@@ -1,5 +1,5 @@
 /****************************************************************************
- * net/net_send_unbuffered.c
+ * net/tcp/tcp_send_unbuffered.c
  *
  *   Copyright (C) 2007-2014 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
@@ -55,15 +55,11 @@
 #include <nuttx/net/arp.h>
 #include <nuttx/net/uip/uip-arch.h>
 
-#ifdef CONFIG_NET_PKT
-#  include <nuttx/net/uip/uip-pkt.h>
-#endif
-
 #include "net_internal.h"
 #include "uip/uip_internal.h"
 
 /****************************************************************************
- * Definitions
+ * Pre-processor Definitions
  ****************************************************************************/
 
 #if defined(CONFIG_NET_TCP_SPLIT) && !defined(CONFIG_NET_TCP_SPLIT_SIZE)
@@ -119,8 +115,7 @@ struct send_s
  *
  ****************************************************************************/
 
-#if defined(CONFIG_NET_TCP) && defined(CONFIG_NET_SOCKOPTS) && \
-   !defined(CONFIG_DISABLE_CLOCK)
+#if defined(CONFIG_NET_SOCKOPTS) && !defined(CONFIG_DISABLE_CLOCK)
 
 static inline int send_timeout(FAR struct send_s *pstate)
 {
@@ -145,180 +140,6 @@ static inline int send_timeout(FAR struct send_s *pstate)
 #endif /* CONFIG_NET_SOCKOPTS && !CONFIG_DISABLE_CLOCK */
 
 /****************************************************************************
- * Function: pktsend_interrupt
- ****************************************************************************/
-
-#if defined(CONFIG_NET_PKT)
-static uint16_t pktsend_interrupt(FAR struct uip_driver_s *dev,
-                                  FAR void *pvconn,
-                                  FAR void *pvpriv, uint16_t flags)
-{
-  FAR struct send_s *pstate = (FAR struct send_s *)pvpriv;
-
-  nllvdbg("flags: %04x sent: %d\n", flags, pstate->snd_sent);
-
-  if (pstate)
-    {
-      /* Check if the outgoing packet is available. If my have been claimed
-       * by a send interrupt serving a different thread -OR- if the output
-       * buffer currently contains unprocessed incoming data. In these cases
-       * we will just have to wait for the next polling cycle.
-       */
-
-      if (dev->d_sndlen > 0 || (flags & UIP_NEWDATA) != 0)
-        {
-          /* Another thread has beat us sending data or the buffer is busy,
-           * Check for a timeout. If not timed out, wait for the next
-           * polling cycle and check again.
-           */
-
-          /* No timeout. Just wait for the next polling cycle */
-
-          return flags;
-        }
-
-      /* It looks like we are good to send the data */
-
-      else
-        {
-          /* Copy the packet data into the device packet buffer and send it */
-
-          uip_pktsend(dev, pstate->snd_buffer, pstate->snd_buflen);
-          pstate->snd_sent = pstate->snd_buflen;
-        }
-
-      /* Don't allow any further call backs. */
-
-      pstate->snd_cb->flags    = 0;
-      pstate->snd_cb->priv     = NULL;
-      pstate->snd_cb->event    = NULL;
-
-      /* Wake up the waiting thread */
-
-      sem_post(&pstate->snd_sem);
-    }
-
-  return flags;
-}
-#endif /* CONFIG_NET_PKT */
-
-/****************************************************************************
- * Function: pktsend
- ****************************************************************************/
-
-#if defined(CONFIG_NET_PKT)
-static ssize_t pktsend(FAR struct socket *psock, FAR const void *buf,
-                       size_t len, int flags)
-{
-  struct send_s state;
-  uip_lock_t save;
-  int err;
-  int ret = OK;
-
-  /* Verify that the sockfd corresponds to valid, allocated socket */
-
-  if (!psock || psock->s_crefs <= 0)
-    {
-      err = EBADF;
-      goto errout;
-    }
-
-  /* Set the socket state to sending */
-
-  psock->s_flags = _SS_SETSTATE(psock->s_flags, _SF_SEND);
-
-  /* Perform the send operation */
-
-  /* Initialize the state structure. This is done with interrupts
-   * disabled because we don't want anything to happen until we
-   * are ready.
-   */
-
-  save                = uip_lock();
-  memset(&state, 0, sizeof(struct send_s));
-  (void)sem_init(&state.snd_sem, 0, 0); /* Doesn't really fail */
-  state.snd_sock      = psock;          /* Socket descriptor to use */
-  state.snd_buflen    = len;            /* Number of bytes to send */
-  state.snd_buffer    = buf;            /* Buffer to send from */
-
-  if (len > 0)
-    {
-      struct uip_pkt_conn *conn = (struct uip_pkt_conn*)psock->s_conn;
-
-      /* Allocate resource to receive a callback */
-
-      state.snd_cb = uip_pktcallbackalloc(conn);
-      if (state.snd_cb)
-        {
-           /* Set the initial time for calculating timeouts */
-
-#if defined(CONFIG_NET_SOCKOPTS) && !defined(CONFIG_DISABLE_CLOCK)
-           state.snd_time       = clock_systimer();
-#endif
-
-          /* Set up the callback in the connection */
-
-          state.snd_cb->flags = UIP_POLL;
-          state.snd_cb->priv  = (void*)&state;
-          state.snd_cb->event = pktsend_interrupt;
-
-          /* Notify the device driver of the availability of TX data */
-
-          struct uip_driver_s *dev = netdev_findbyname("eth0");
-          dev->d_txavail(dev);
-
-          /* Wait for the send to complete or an error to occure: NOTES: (1)
-           * uip_lockedwait will also terminate if a signal is received, (2)
-           * interrupts may be disabled! They will be re-enabled while the
-           * task sleeps and automatically re-enabled when the task restarts.
-           */
-
-          ret = uip_lockedwait(&state.snd_sem);
-
-          /* Make sure that no further interrupts are processed */
-
-          uip_pktcallbackfree(conn, state.snd_cb);
-        }
-    }
-
-  sem_destroy(&state.snd_sem);
-  uip_unlock(save);
-
-  /* Set the socket state to idle */
-
-  psock->s_flags = _SS_SETSTATE(psock->s_flags, _SF_IDLE);
-
-  /* Check for a errors, Errors are signalled by negative errno values
-   * for the send length
-   */
-
-  if (state.snd_sent < 0)
-    {
-      err = state.snd_sent;
-      goto errout;
-    }
-
-  /* If uip_lockedwait failed, then we were probably reawakened by a signal. In
-   * this case, uip_lockedwait will have set errno appropriately.
-   */
-
-  if (ret < 0)
-    {
-      err = -ret;
-      goto errout;
-    }
-
-  /* Return the number of bytes actually sent */
-
-  return state.snd_sent;
-
-errout:
-  set_errno(err);
-  return ERROR;
-}
-#endif /* CONFIG_NET_PKT */
-
-/****************************************************************************
  * Function: tcpsend_interrupt
  *
  * Description:
@@ -338,7 +159,6 @@ errout:
  *
  ****************************************************************************/
 
-#if defined(CONFIG_NET_TCP)
 static uint16_t tcpsend_interrupt(FAR struct uip_driver_s *dev,
                                   FAR void *pvconn,
                                   FAR void *pvpriv, uint16_t flags)
@@ -617,15 +437,69 @@ end_wait:
   sem_post(&pstate->snd_sem);
   return flags;
 }
-#endif
 
 /****************************************************************************
- * Function: tcpsend
+ * Public Functions
  ****************************************************************************/
 
-#if defined(CONFIG_NET_TCP)
-ssize_t tcpsend(FAR struct socket *psock, FAR const void *buf, size_t len,
-                int flags)
+/****************************************************************************
+ * Function: tcp_send
+ *
+ * Description:
+ *   The tcp_send() call may be used only when the TCP socket is in a
+ *   connected state (so that the intended recipient is known).
+ *
+ * Parameters:
+ *   psock    An instance of the internal socket structure.
+ *   buf      Data to send
+ *   len      Length of data to send
+ *
+ * Returned Value:
+ *   On success, returns the number of characters sent.  On  error,
+ *   -1 is returned, and errno is set appropriately:
+ *
+ *   EAGAIN or EWOULDBLOCK
+ *     The socket is marked non-blocking and the requested operation
+ *     would block.
+ *   EBADF
+ *     An invalid descriptor was specified.
+ *   ECONNRESET
+ *     Connection reset by peer.
+ *   EDESTADDRREQ
+ *     The socket is not connection-mode, and no peer address is set.
+ *   EFAULT
+ *      An invalid user space address was specified for a parameter.
+ *   EINTR
+ *      A signal occurred before any data was transmitted.
+ *   EINVAL
+ *      Invalid argument passed.
+ *   EISCONN
+ *     The connection-mode socket was connected already but a recipient
+ *     was specified. (Now either this error is returned, or the recipient
+ *     specification is ignored.)
+ *   EMSGSIZE
+ *     The socket type requires that message be sent atomically, and the
+ *     size of the message to be sent made this impossible.
+ *   ENOBUFS
+ *     The output queue for a network interface was full. This generally
+ *     indicates that the interface has stopped sending, but may be
+ *     caused by transient congestion.
+ *   ENOMEM
+ *     No memory available.
+ *   ENOTCONN
+ *     The socket is not connected, and no target has been given.
+ *   ENOTSOCK
+ *     The argument s is not a socket.
+ *   EPIPE
+ *     The local end has been shut down on a connection oriented socket.
+ *     In this case the process will also receive a SIGPIPE unless
+ *     MSG_NOSIGNAL is set.
+ *
+ * Assumptions:
+ *
+ ****************************************************************************/
+
+ssize_t tcp_send(FAR struct socket *psock, FAR const void *buf, size_t len)
 {
   struct send_s state;
   uip_lock_t save;
@@ -749,106 +623,5 @@ errout:
   set_errno(err);
   return ERROR;
 }
-#endif
-
-/****************************************************************************
- * Public Functions
- ****************************************************************************/
-
-/****************************************************************************
- * Function: psock_send
- *
- * Description:
- *   The send() call may be used only when the socket is in a connected state
- *   (so that the intended recipient is known). The only difference between
- *   send() and write() is the presence of flags. With zero flags parameter,
- *   send() is equivalent to write(). Also, send(sockfd,buf,len,flags) is
- *   equivalent to sendto(sockfd,buf,len,flags,NULL,0).
- *
- * Parameters:
- *   psock    An instance of the internal socket structure.
- *   buf      Data to send
- *   len      Length of data to send
- *   flags    Send flags
- *
- * Returned Value:
- *   On success, returns the number of characters sent.  On  error,
- *   -1 is returned, and errno is set appropriately:
- *
- *   EAGAIN or EWOULDBLOCK
- *     The socket is marked non-blocking and the requested operation
- *     would block.
- *   EBADF
- *     An invalid descriptor was specified.
- *   ECONNRESET
- *     Connection reset by peer.
- *   EDESTADDRREQ
- *     The socket is not connection-mode, and no peer address is set.
- *   EFAULT
- *      An invalid user space address was specified for a parameter.
- *   EINTR
- *      A signal occurred before any data was transmitted.
- *   EINVAL
- *      Invalid argument passed.
- *   EISCONN
- *     The connection-mode socket was connected already but a recipient
- *     was specified. (Now either this error is returned, or the recipient
- *     specification is ignored.)
- *   EMSGSIZE
- *     The socket type requires that message be sent atomically, and the
- *     size of the message to be sent made this impossible.
- *   ENOBUFS
- *     The output queue for a network interface was full. This generally
- *     indicates that the interface has stopped sending, but may be
- *     caused by transient congestion.
- *   ENOMEM
- *     No memory available.
- *   ENOTCONN
- *     The socket is not connected, and no target has been given.
- *   ENOTSOCK
- *     The argument s is not a socket.
- *   EOPNOTSUPP
- *     Some bit in the flags argument is inappropriate for the socket
- *     type.
- *   EPIPE
- *     The local end has been shut down on a connection oriented socket.
- *     In this case the process will also receive a SIGPIPE unless
- *     MSG_NOSIGNAL is set.
- *
- * Assumptions:
- *
- ****************************************************************************/
-
-ssize_t psock_send(FAR struct socket *psock, FAR const void *buf, size_t len,
-                   int flags)
-{
-  int ret;
-
-  switch (psock->s_type)
-    {
-#if defined(CONFIG_NET_PKT)
-      case SOCK_RAW:
-        {
-          ret = pktsend(psock, buf, len, flags);
-          break;
-        }
-#endif
-
-#if defined(CONFIG_NET_TCP)
-      case SOCK_STREAM:
-        {
-          ret = tcpsend(psock, buf, len, flags);
-          break;
-        }
-#endif
-
-      default:
-        {
-          ret = ERROR;
-        }
-    }
-
-  return ret;
-}
 
 #endif /* CONFIG_NET && CONFIG_NET_TCP && !CONFIG_NET_TCP_WRITE_BUFFERS */