The first set of changes to incorporate Jason Jiangs TCP write buffering logic

14 files changed, 1488 insertions, 629 deletions

diff --git a/nuttx/ChangeLog b/nuttx/ChangeLog
index 65873be4d..02806f411 100644
--- a/nuttx/ChangeLog
+++ b/nuttx/ChangeLog
@@ -6422,3 +6422,9 @@
 	  the changes does not seem to do any harm (2014-1-13).
 	* net/connect.c and net/uip/uip_callback.c: prevent tcp_connect
 	  callback from being double freed.  From Max Holtzberg (2014-1-13).
+	* net/Kconfig and include/nuttx/net/uip/uipopt.h: Add configuration
+	  support for forthcoming TCP write buffering (2014-1-13).
+	* net/net_send_buffered.c, net_send_unbuffered.c, and
+	  uip/uip_tcpwrbuffer.c:  First set of changes to bring in Jason
+	  Jiang's TCP write buffering logic.  Still not complete but
+	  apparently harmless if not selected. (2014-1-13).
diff --git a/nuttx/include/nuttx/net/net.h b/nuttx/include/nuttx/net/net.h
index d434a89b1..7970ad7fc 100644
--- a/nuttx/include/nuttx/net/net.h
+++ b/nuttx/include/nuttx/net/net.h
@@ -51,7 +51,7 @@
 #include <nuttx/net/uip/uip.h>
 
 /****************************************************************************
- * Definitions
+ * Pre-processor Definitions
  ****************************************************************************/
 
 /* Socket descriptors are the index into the TCB sockets list, offset by the
@@ -101,6 +101,12 @@ struct socket
 #endif
 #endif
   FAR void     *s_conn;      /* Connection: struct uip_conn or uip_udp_conn */
+
+#ifdef CONFIG_NET_TCP_WRBUFFER
+  /* Callback instance for TCP send */
+
+  FAR struct uip_callback_s *s_sndcb;
+#endif
 };
 
 /* This defines a list of sockets indexed by the socket descriptor */
@@ -108,7 +114,7 @@ struct socket
 #if CONFIG_NSOCKET_DESCRIPTORS > 0
 struct socketlist
 {
-  sem_t   sl_sem;            /* Manage access to the socket list */
+  sem_t         sl_sem;      /* Manage access to the socket list */
   struct socket sl_sockets[CONFIG_NSOCKET_DESCRIPTORS];
 };
 #endif
diff --git a/nuttx/include/nuttx/net/uip/uip-tcp.h b/nuttx/include/nuttx/net/uip/uip-tcp.h
index a296ef3e1..c14686822 100644
--- a/nuttx/include/nuttx/net/uip/uip-tcp.h
+++ b/nuttx/include/nuttx/net/uip/uip-tcp.h
@@ -144,15 +144,9 @@ struct uip_conn
 {
   dq_entry_t node;        /* Implements a doubly linked list */
   uip_ipaddr_t ripaddr;   /* The IP address of the remote host */
-  uint16_t lport;         /* The local TCP port, in network byte order */
-  uint16_t rport;         /* The remoteTCP port, in network byte order */
   uint8_t  rcvseq[4];     /* The sequence number that we expect to
                            * receive next */
   uint8_t  sndseq[4];     /* The sequence number that was last sent by us */
-  uint16_t unacked;       /* Number bytes sent but not yet ACKed */
-  uint16_t mss;           /* Current maximum segment size for the
-                           * connection */
-  uint16_t winsize;       /* Current window size of the connection */
   uint8_t  crefs;         /* Reference counts on this instance */
   uint8_t  sa;            /* Retransmission time-out calculation state
                            * variable */
@@ -163,6 +157,16 @@ struct uip_conn
   uint8_t  timer;         /* The retransmission timer (units: half-seconds) */
   uint8_t  nrtx;          /* The number of retransmissions for the last
                            * segment sent */
+  uint16_t lport;         /* The local TCP port, in network byte order */
+  uint16_t rport;         /* The remoteTCP port, in network byte order */
+  uint16_t mss;           /* Current maximum segment size for the
+                           * connection */
+  uint16_t winsize;       /* Current window size of the connection */
+#ifdef CONFIG_NET_TCP_WRBUFFER
+  uint32_t unacked;       /* Number bytes sent but not yet ACKed */
+#else
+  uint16_t unacked;       /* Number bytes sent but not yet ACKed */
+#endif
 
   /* Read-ahead buffering.
    *
@@ -174,6 +178,17 @@ struct uip_conn
   sq_queue_t readahead;   /* Read-ahead buffering */
 #endif
 
+  /* Write buffering */
+
+#ifdef CONFIG_NET_TCP_WRITE_BUFFERS
+  sq_queue_t write_q;     /* Write buffering for segments */
+  sq_queue_t unacked_q;   /* Write buffering for un-ACKed segments */
+  size_t     expired;     /* Number segments retransmitted but not yet ACKed,
+                           * it can only be updated at UIP_ESTABLISHED state */
+  size_t     sent;        /* The number of bytes sent  */
+  uint32_t   isn;         /* Initial sequence number */
+#endif
+
   /* Listen backlog support
    *
    *   blparent - The backlog parent.  If this connection is backlogged,
@@ -238,8 +253,22 @@ struct uip_conn
 struct uip_readahead_s
 {
   sq_entry_t rh_node;      /* Supports a singly linked list */
-  uint16_t rh_nbytes;      /* Number of bytes available in this buffer */
-  uint8_t  rh_buffer[CONFIG_NET_TCP_READAHEAD_BUFSIZE];
+  uint16_t   rh_nbytes;    /* Number of bytes available in this buffer */
+  uint8_t    rh_buffer[CONFIG_NET_TCP_READAHEAD_BUFSIZE];
+};
+#endif
+
+/* This structure supports TCP write buffering */
+
+#ifdef CONFIG_NET_TCP_WRITE_BUFFERS
+struct uip_wrbuffer_s
+{
+  sq_entry_t wb_node;      /* Supports a singly linked list */
+  uint32_t   wb_seqno;     /* Sequence number of the write segment */
+  uint16_t   wb_nbytes;    /* Number of bytes available in this buffer */
+  uint8_t    wb_nrtx;      /* The number of retransmissions for the last
+                            * segment sent */
+  uint8_t    wb_buffer[CONFIG_NET_TCP_WRITE_BUFSIZE];
 };
 #endif
 
@@ -350,7 +379,7 @@ struct uip_tcpip_hdr
  * normally something done by the implementation of the socket() API
  */
 
-extern struct uip_conn *uip_tcpalloc(void);
+struct uip_conn *uip_tcpalloc(void);
 
 /* Allocate a new TCP data callback */
 
@@ -361,14 +390,14 @@ extern struct uip_conn *uip_tcpalloc(void);
  * be done by the implementation of close()
  */
 
-extern void uip_tcpfree(struct uip_conn *conn);
+void uip_tcpfree(struct uip_conn *conn);
 
 /* Bind a TCP connection to a local address */
 
 #ifdef CONFIG_NET_IPv6
-extern int uip_tcpbind(struct uip_conn *conn, const struct sockaddr_in6 *addr);
+int uip_tcpbind(struct uip_conn *conn, const struct sockaddr_in6 *addr);
 #else
-extern int uip_tcpbind(struct uip_conn *conn, const struct sockaddr_in *addr);
+int uip_tcpbind(struct uip_conn *conn, const struct sockaddr_in *addr);
 #endif
 
 /* This function implements the UIP specific parts of the standard
@@ -386,44 +415,51 @@ extern int uip_tcpbind(struct uip_conn *conn, const struct sockaddr_in *addr);
  */
 
 #ifdef CONFIG_NET_IPv6
-extern int uip_tcpconnect(struct uip_conn *conn, const struct sockaddr_in6 *addr);
+int uip_tcpconnect(struct uip_conn *conn, const struct sockaddr_in6 *addr);
 #else
-extern int uip_tcpconnect(struct uip_conn *conn, const struct sockaddr_in *addr);
+int uip_tcpconnect(struct uip_conn *conn, const struct sockaddr_in *addr);
 #endif
 
 /* Start listening to the port bound to the specified TCP connection */
 
-extern int uip_listen(struct uip_conn *conn);
+int uip_listen(struct uip_conn *conn);
 
 /* Stop listening to the port bound to the specified TCP connection */
 
-extern int uip_unlisten(struct uip_conn *conn);
+int uip_unlisten(struct uip_conn *conn);
 
 /* Access to TCP read-ahead buffers */
 
 #ifdef CONFIG_NET_TCP_READAHEAD
-extern struct uip_readahead_s *uip_tcpreadaheadalloc(void);
-extern void uip_tcpreadaheadrelease(struct uip_readahead_s *buf);
+struct uip_readahead_s *uip_tcpreadaheadalloc(void);
+void uip_tcpreadaheadrelease(struct uip_readahead_s *buf);
 #endif /* CONFIG_NET_TCP_READAHEAD */
 
+/* Access to TCP write buffers */
+
+#ifdef CONFIG_NET_TCP_WRITE_BUFFERS
+FAR struct uip_wrbuffer_s *uip_tcpwrbuffer_alloc(FAR const struct timespec *abstime);
+void uip_tcpwrbuffer_release(FAR struct uip_wrbuffer_s *buf);
+#endif /* CONFIG_NET_NTCP_READAHEAD_BUFFERS */
+
 /* Backlog support */
 
 #ifdef CONFIG_NET_TCPBACKLOG
 /* APIs to create and terminate TCP backlog support */
 
-extern int uip_backlogcreate(FAR struct uip_conn *conn, int nblg);
-extern int uip_backlogdestroy(FAR struct uip_conn *conn);
+int uip_backlogcreate(FAR struct uip_conn *conn, int nblg);
+int uip_backlogdestroy(FAR struct uip_conn *conn);
 
 /* APIs to manage individual backlog actions */
 
-extern int uip_backlogadd(FAR struct uip_conn *conn, FAR struct uip_conn *blconn);
+int uip_backlogadd(FAR struct uip_conn *conn, FAR struct uip_conn *blconn);
 #ifndef CONFIG_DISABLE_POLL
-extern bool uip_backlogavailable(FAR struct uip_conn *conn);
+bool uip_backlogavailable(FAR struct uip_conn *conn);
 #else
 #  define uip_backlogavailable(conn)   (false);
 #endif
-extern FAR struct uip_conn *uip_backlogremove(FAR struct uip_conn *conn);
-extern int uip_backlogdelete(FAR struct uip_conn *conn, FAR struct uip_conn *blconn);
+FAR struct uip_conn *uip_backlogremove(FAR struct uip_conn *conn);
+int uip_backlogdelete(FAR struct uip_conn *conn, FAR struct uip_conn *blconn);
 
 #else
 #  define uip_backlogcreate(conn,nblg) (-ENOSYS)
diff --git a/nuttx/include/nuttx/net/uip/uipopt.h b/nuttx/include/nuttx/net/uip/uipopt.h
index 6e047feeb..457a2f855 100644
--- a/nuttx/include/nuttx/net/uip/uipopt.h
+++ b/nuttx/include/nuttx/net/uip/uipopt.h
@@ -16,7 +16,7 @@
  * Note: Most of the configuration options in the uipopt.h should not
  * be changed, but rather the per-project defconfig file.
  *
- *   Copyright (C) 2007, 2011 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2007, 2011, 2014 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * This logic was leveraged from uIP which also has a BSD-style license:
diff --git a/nuttx/net/Kconfig b/nuttx/net/Kconfig
index 0f0c8ed48..743e50495 100644
--- a/nuttx/net/Kconfig
+++ b/nuttx/net/Kconfig
@@ -75,7 +75,7 @@ config NET_SOCKOPTS
 config NET_SOLINGER
 	bool "SO_LINGER socket option"
 	default n
-	depends on NET_SOCKOPTS && !DISABLE_CLOCK
+	depends on NET_SOCKOPTS && NET_TCP_WRITE_BUFFERS && !DISABLE_CLOCK
 	---help---
 		Enable or disable support for the SO_LINGER socket option.
 
@@ -210,6 +210,7 @@ config NET_TCPBACKLOG
 config NET_TCP_SPLIT
 	bool "Enable packet splitting"
 	default n
+	depends on !NET_TCP_WRITE_BUFFERS
 	---help---
 		send() will not return until the transfer has been ACKed by the
 		recipient.  But under RFC 1122, the host need not ACK each packet
diff --git a/nuttx/net/Makefile b/nuttx/net/Makefile
index 32c80b889..8549e5c57 100644
--- a/nuttx/net/Makefile
+++ b/nuttx/net/Makefile
@@ -1,7 +1,7 @@
 ############################################################################
 # net/Makefile
 #
-#   Copyright (C) 2007, 2008, 2011-2013 Gregory Nutt. All rights reserved.
+#   Copyright (C) 2007, 2008, 2011-2014 Gregory Nutt. All rights reserved.
 #   Author: Gregory Nutt <gnutt@nuttx.org>
 #
 # Redistribution and use in source and binary forms, with or without
@@ -41,13 +41,19 @@ ifeq ($(CONFIG_NET),y)
 
 SOCK_ASRCS  =
 SOCK_CSRCS  = bind.c connect.c getsockname.c recv.c recvfrom.c socket.c
-SOCK_CSRCS += sendto.c net_sockets.c net_close.c net_dup.c net_dup2.c 
+SOCK_CSRCS += sendto.c net_sockets.c net_close.c net_dup.c net_dup2.c
 SOCK_CSRCS += net_clone.c net_vfcntl.c
 
 # TCP/IP support
 
 ifeq ($(CONFIG_NET_TCP),y)
 SOCK_CSRCS += send.c listen.c accept.c net_monitor.c
+
+ifeq ($(CONFIG_NET_TCP_WRBUFFER),y)
+SOCK_CSRCS += net_send_buffered.c
+else
+SOCK_CSRCS += net_send_unbuffered.c
+endif
 endif
 
 # Socket options
diff --git a/nuttx/net/net_close.c b/nuttx/net/net_close.c
index 42b87d2f5..d5974e51a 100644
--- a/nuttx/net/net_close.c
+++ b/nuttx/net/net_close.c
@@ -196,8 +196,7 @@ static uint16_t netclose_interrupt(FAR struct uip_driver_s *dev,
         }
     }
 
-#ifdef CONFIG_NET_SOLINGER
-#ifndef CONFIG_DISABLE_CLOCK
+#if defined(CONFIG_NET_SOLINGER) && !defined(CONFIG_DISABLE_CLOCK)
   /* Check for a timeout. */
 
   else if (pstate && close_timeout(pstate))
@@ -208,8 +207,10 @@ static uint16_t netclose_interrupt(FAR struct uip_driver_s *dev,
       pstate->cl_result = -ETIMEDOUT;
       goto end_wait;
     }
-#endif /* CONFIG_DISABLE_CLOCK */
 
+#endif /* CONFIG_NET_SOLINGER && !CONFIG_DISABLE_CLOCK */
+
+#ifdef CONFIG_NET_TCP_WRITE_BUFFERS
   /* Check if all outstanding bytes have been ACKed */
 
   else if (pstate && conn->unacked != 0)
@@ -222,7 +223,7 @@ static uint16_t netclose_interrupt(FAR struct uip_driver_s *dev,
       flags = (flags & ~UIP_NEWDATA);     
     }
 
-#endif /* CONFIG_NET_SOLINGER */
+#endif /* CONFIG_NET_TCP_WRITE_BUFFERS */
 
   else
     {
diff --git a/nuttx/net/net_send_buffered.c b/nuttx/net/net_send_buffered.c
new file mode 100644
index 000000000..b5770cfbe
--- /dev/null
+++ b/nuttx/net/net_send_buffered.c
@@ -0,0 +1,557 @@
+/****************************************************************************
+ * net/net_send_buffered.c
+ *
+ *   Copyright (C) 2007-2014 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <gnutt@nuttx.org>
+ *           Jason Jiang  <jasonj@live.cn>
+ *
+ * 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_TCP) && \
+    defined(CONFIG_NET_TCP_WRITE_BUFFERS)
+
+#include <sys/types.h>
+#include <sys/socket.h>
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <debug.h>
+#include <debug.h>
+
+#include <arch/irq.h>
+#include <nuttx/clock.h>
+#include <nuttx/net/uip/uip-arp.h>
+#include <nuttx/net/uip/uip-arch.h>
+
+#ifdef CONFIG_NET_ARP_IPIN
+#  include <nuttx/net/uip/uip-arp.h>
+#endif
+
+#include "net_internal.h"
+#include "uip/uip_internal.h"
+
+/****************************************************************************
+ * Pre-processor Definitions
+ ****************************************************************************/
+
+#define TCPBUF ((struct uip_tcpip_hdr *)&dev->d_buf[UIP_LLH_LEN])
+
+/****************************************************************************
+ * Private Types
+ ****************************************************************************/
+
+/****************************************************************************
+ * Private Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Function: send_insert_seqment
+ *
+ * Description:
+ *   Inserted a new segment in a write buffer, keep the segment queue in
+ *   ascending order of seqno
+ *
+ * Parameters:
+ *   pstate   send state structure
+ *
+ * Returned Value:
+ *   TRUE:timeout FALSE:no timeout
+ *
+ * Assumptions:
+ *   Running at the interrupt level
+ *
+ ****************************************************************************/
+
+static void send_insert_seqment(FAR struct uip_write_s *segment,
+                                FAR sq_queue_t *q)
+{
+  sq_entry_t *entry = (sq_entry_t*)segment;
+  sq_entry_t *insert = NULL;
+
+  sq_entry_t *itr;
+  for (itr = sq_peek(q); itr; itr = sq_next(itr))
+    {
+      FAR struct uip_write_s *segment0 = (FAR struct uip_write_s*)itr;
+      if (segment0->wb_seqno < segment->wb_seqno)
+        {
+          insert = itr;
+        }
+      else
+        {
+          break;
+        }
+    }
+
+  if (insert)
+    {
+      sq_addafter(insert, entry, q);
+    }
+  else
+    {
+      sq_addfirst(entry, q);
+    }
+}
+
+/****************************************************************************
+ * Function: send_interrupt
+ *
+ * Description:
+ *   This function is called from the interrupt level to perform the actual
+ *   send operation when polled by the uIP layer.
+ *
+ * Parameters:
+ *   dev      The structure of the network driver that caused the interrupt
+ *   conn     The connection structure associated with the socket
+ *   flags    Set of events describing why the callback was invoked
+ *
+ * Returned Value:
+ *   None
+ *
+ * Assumptions:
+ *   Running at the interrupt level
+ *
+ ****************************************************************************/
+
+static uint16_t send_interrupt(FAR struct uip_driver_s *dev, FAR void *pvconn,
+                               FAR void *pvpriv, uint16_t flags)
+{
+  FAR struct uip_conn *conn = (FAR struct uip_conn*)pvconn;
+  FAR struct send_s *pstate = (FAR struct send_s *)pvpriv;
+
+  nllvdbg("flags: %04x\n", flags);
+
+  /* If this packet contains an acknowledgement, then update the count of
+   * acknowledged bytes.
+   */
+
+  if ((flags & UIP_ACKDATA) != 0)
+    {
+      FAR sq_entry_t *entry, *next;
+      FAR struct uip_write_s *segment;
+      uint32_t ackno;
+
+      ackno = uip_tcpgetsequence(TCPBUF->ackno);
+      for (entry = sq_peek(&conn->unacked_q); entry; entry = next)
+        {
+          next    = sq_next(entry);
+          segment = (FAR struct uip_write_s*)entry;
+
+          if (segment->wb_seqno < ackno)
+            {
+              nllvdbg("ACK: acked=%d buflen=%d ackno=%d\n",
+                      segment->wb_seqno, segment->wb_nbytes, ackno);
+
+              /* Segment was ACKed. Remove from ACK waiting queue */
+
+              sq_rem(entry, &conn->unacked_q);
+
+              /* Return the write buffer to the pool of free buffers */
+
+              uip_tcpwritebuffrelease(segment);
+            }
+        }
+    }
+
+  /* Check for a loss of connection */
+
+  else if ((flags & (UIP_CLOSE | UIP_ABORT | UIP_TIMEDOUT)) != 0)
+    {
+      /* Report not connected */
+
+       nllvdbg("Lost connection\n");
+       net_lostconnection(psock, flags);
+       goto end_wait;
+     }
+
+   /* Check if we are being asked to retransmit data */
+
+   else if ((flags & UIP_REXMIT) != 0)
+    {
+      sq_entry_t *entry;
+
+      /* Put all segments that have been sent but not ACKed to write queue
+       * again note, the un-ACKed segment is put at the first of the write_q,
+       * so it can be sent as soon as possible.
+       */
+
+      while ((entry=sq_remlast(&conn->unacked_q)))
+        {
+          struct uip_write_s *segment = (struct uip_write_s*)entry;
+
+          if (segment->wb_nrtx >= UIP_MAXRTX)
+            {
+              //conn->unacked -= segment->wb_nbytes;
+
+              /* Return the write buffer */
+
+              uip_tcpwritebuffrelease(segment);
+
+              /* NOTE expired is different from un-ACKed, it is designed to
+               * represent the number of segments that have been sent,
+               * retransmitted, and un-ACKed, if expired is not zero, the
+               * connection will be closed.
+               *
+               * field expired can only be updated at UIP_ESTABLISHED state
+               */
+
+              conn->expired ++;
+              continue;
+            }
+
+          send_insert_seqment(segment, &conn->write_q);
+        }
+    }
+
+  /* Check if the outgoing packet is available (it may have been claimed
+   * by a sendto interrupt serving a different thread).
+   */
+
+  if (dev->d_sndlen > 0)
+    {
+      /* Another thread has beat us sending data, wait for the next poll */
+
+      return flags;
+    }
+
+  /* We get here if (1) not all of the data has been ACKed, (2) we have been
+   * asked to retransmit data, (3) the connection is still healthy, and (4)
+   * the outgoing packet is available for our use.  In this case, we are
+   * now free to send more data to receiver -- UNLESS the buffer contains
+   * unprocesed incoming data.  In that event, we will have to wait for the
+   * next polling cycle.
+   */
+
+  if ((conn->tcpstateflags & UIP_ESTABLISHED) &&
+      (flags & (UIP_POLL | UIP_REXMIT)) &&
+      !(sq_empty(&conn->write_q)))
+    {
+      /* Check if the destination IP address is in the ARP table.  If not,
+       * then the send won't actually make it out... it will be replaced with
+       * an ARP request.
+       *
+       * 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
+       * packets, then this check should not be necessary; the MAC mapping
+       * should already be in the ARP table.
+       */
+
+#if defined(CONFIG_NET_ETHERNET) && !defined(CONFIG_NET_ARP_IPIN)
+      if (uip_arp_find(conn->ripaddr) != NULL)
+#endif
+        {
+          FAR struct uip_write_s *segment;
+          FAR void *sndbuff;
+          size_tsndlen;
+
+          /* Get the amount of data that we can send in the next packet */
+
+          segment = (FAR struct uip_write_s*)sq_peek(&conn->write_q);
+          if (segment)
+            {
+              sndbuff = segment->wb_buffer;
+              sndlen  = segment->wb_nbytes;
+
+              DEBUGASSERT(sndlen <= uip_mss(conn));
+
+              /* Check if we have "space" in the window */
+
+              if ((pstate->snd_sent - pstate->snd_acked + sndlen) < conn->winsize)
+                {
+                  /* We are committed.. remove the segment from the queue. */
+
+                  (void)sq_remfirst(&conn->write_q);
+
+                  /* Set the sequence number for this segment.  NOTE: uIP
+                   * updates sndseq on receipt of ACK *before* this function
+                   * is called. In that case sndseq will point to the next
+                   * unacknowledged byte (which might have already been
+                   * sent). We will overwrite the value of sndseq here
+                   * before the packet is sent.
+                   */
+
+                  if (segment->wb_nrtx == 0 && segment->wb_seqno == (unsigned)-1)
+                    {
+                      segment->wb_seqno = conn->isn + conn->sent;
+                    }
+
+                  uip_tcpsetsequence(conn->sndseq, segment->wb_seqno);
+
+                  /* Then set-up to send that amount of data. (this won't
+                   * actually happen until the polling cycle completes).
+                   */
+
+                  uip_send(dev, sndbuff, sndlen);
+
+                  /* Remember how much data we send out now so that we know
+                   * when everything has been acknowledged.  Just increment
+                   * the amount of data sent. This will be needed in
+                   * sequence* number calculations and we know that this is
+                   * not a re-transmission. Re-transmissions do not go through
+                   * this path.
+                   */
+
+                  if (segment->wb_nrtx == 0)
+                    {
+                      conn->unacked += sndlen;
+                      conn->sent    += sndlen;
+                   }
+
+                  /* Increment the retransmission counter before expiration.
+                   * NOTE we will not calculate the retransmission timer
+                   * (RTT) to save cpu cycles, each send_insert_seqment
+                   * segment will be retransmitted UIP_MAXRTX times in halt-
+                   * second interval before expiration.
+                   */
+
+                  segment->wb_nrtx ++;
+
+                  /* The segment is waiting for ACK again */
+
+                  send_insert_seqment(segment, &conn->unacked_q);
+
+                  /* Only one data can be sent by low level driver at once,
+                   * tell the caller stop polling the other connection.
+                   */
+
+                  flags &= ~UIP_POLL;
+                }
+            }
+        }
+    }
+
+  /* Continue waiting */
+
+  return flags;
+
+end_wait:
+
+  /* Do not allow any further callbacks */
+
+  psock->s_sndcb->flags = 0;
+  psock->s_sndcb->event = NULL;
+
+  return flags;
+}
+
+/****************************************************************************
+ * 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)
+{
+  uip_lock_t save;
+  size_t     completed = 0;
+  int        err;
+  int        ret = OK;
+
+  if (!psock || psock->s_crefs <= 0)
+    {
+      err = EBADF;
+      goto errout;
+    }
+
+  if (psock->s_type != SOCK_STREAM || !_SS_ISCONNECTED(psock->s_flags))
+    {
+      err = ENOTCONN;
+      goto errout;
+    }
+
+  /* Set the socket state to sending */
+
+  psock->s_flags = _SS_SETSTATE(psock->s_flags, _SF_SEND);
+
+  save = uip_lock();
+
+  if (len > 0)
+    {
+      struct uip_conn *conn = (struct uip_conn*)psock->s_conn;
+
+      if (!psock->s_sndcb)
+        {
+          psock->s_sndcb = uip_tcpcallbackalloc(conn);
+
+          /* Set up the callback in the connection */
+
+          psock->s_sndcb->flags = (UIP_ACKDATA | UIP_REXMIT |UIP_POLL | \
+                                  UIP_CLOSE | UIP_ABORT | UIP_TIMEDOUT);
+          psock->s_sndcb->priv  = (void*)psock;
+          psock->s_sndcb->event = send_interrupt;
+        }
+
+      /* Allocate resources to receive a callback */
+
+      while (completed < len)
+        {
+          struct uip_write_s *segment = uip_tcpwritebuffalloc(NULL);
+          if (segment)
+            {
+              size_t cnt;
+
+              segment->wb_seqno = (unsigned)-1;
+              segment->wb_nrtx  = 0;
+
+              if (len-completed > CONFIG_NET_TCP_WRITE_BUFSIZE)
+                {
+                  cnt = CONFIG_NET_TCP_WRITE_BUFSIZE;
+                }
+              else
+                {
+                  cnt = len - completed;
+                }
+
+              segment->wb_nbytes = cnt;
+              memcpy(segment->wb_buffer, (char*)buf+completed, cnt);
+              completed += cnt;
+
+              /* send_interrupt() will refer to all the write buffer by
+               * conn->writebuff
+               */
+
+              sq_addlast(&segment->wb_node, &conn->write_q);
+
+              /* Notify the device driver of the availaibilty of TX data */
+
+              netdev_txnotify(&conn->ripaddr);
+            }
+        }
+    }
+
+  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 signaled by negative errno values
+   * for the send length
+   */
+
+  if (completed < 0)
+    {
+      err = completed;
+      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 completed;
+
+errout:
+  set_errno(err);
+  return ERROR;
+}
+
+#endif /* CONFIG_NET && CONFIG_NET_TCP && CONFIG_NET_TCP_WRITE_BUFFERS */
diff --git a/nuttx/net/net_send_unbuffered.c b/nuttx/net/net_send_unbuffered.c
new file mode 100644
index 000000000..7d5a3e33a
--- /dev/null
+++ b/nuttx/net/net_send_unbuffered.c
@@ -0,0 +1,638 @@
+/****************************************************************************
+ * net/net_send_unbuffered.c
+ *
+ *   Copyright (C) 2007-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_TCP) && \
+   !defined(CONFIG_NET_TCP_WRITE_BUFFERS)
+
+#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/uip/uip-arp.h>
+#include <nuttx/net/uip/uip-arch.h>
+
+#ifdef CONFIG_NET_ARP_IPIN
+#  include <nuttx/net/uip/uip-arp.h>
+#endif
+
+#include "net_internal.h"
+#include "uip/uip_internal.h"
+
+/****************************************************************************
+ * Definitions
+ ****************************************************************************/
+
+#if defined(CONFIG_NET_TCP_SPLIT) && !defined(CONFIG_NET_TCP_SPLIT_SIZE)
+#  define CONFIG_NET_TCP_SPLIT_SIZE 40
+#endif
+
+#define TCPBUF ((struct uip_tcpip_hdr *)&dev->d_buf[UIP_LLH_LEN])
+
+/****************************************************************************
+ * 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 */
+  uint32_t                   snd_isn;     /* Initial sequence number */
+  uint32_t                   snd_acked;   /* The number of bytes acked */
+#if defined(CONFIG_NET_SOCKOPTS) && !defined(CONFIG_DISABLE_CLOCK)
+  uint32_t                   snd_time;    /* Last send time for determining timeout */
+#endif
+#if defined(CONFIG_NET_TCP_SPLIT)
+  bool                       snd_odd;     /* True: Odd packet in pair transaction */
+#endif
+};
+
+/****************************************************************************
+ * Private Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Function: send_timeout
+ *
+ * Description:
+ *   Check for send timeout.
+ *
+ * Parameters:
+ *   pstate   send state structure
+ *
+ * Returned Value:
+ *   TRUE:timeout FALSE:no timeout
+ *
+ * Assumptions:
+ *   Running at the interrupt level
+ *
+ ****************************************************************************/
+
+#if defined(CONFIG_NET_SOCKOPTS) && !defined(CONFIG_DISABLE_CLOCK)
+static inline int send_timeout(FAR struct send_s *pstate)
+{
+  FAR struct socket *psock = 0;
+
+  /* Check for a timeout configured via setsockopts(SO_SNDTIMEO).
+   * If none... we well let the send wait forever.
+   */
+
+  psock = pstate->snd_sock;
+  if (psock && psock->s_sndtimeo != 0)
+    {
+      /* Check if the configured timeout has elapsed */
+
+      return net_timeo(pstate->snd_time, psock->s_sndtimeo);
+    }
+
+  /* No timeout */
+
+  return FALSE;
+}
+#endif /* CONFIG_NET_SOCKOPTS && !CONFIG_DISABLE_CLOCK */
+
+/****************************************************************************
+ * Function: send_interrupt
+ *
+ * Description:
+ *   This function is called from the interrupt level to perform the actual
+ *   send operation when polled by the uIP layer.
+ *
+ * Parameters:
+ *   dev      The structure of the network driver that caused the interrupt
+ *   conn     The connection structure associated with the socket
+ *   flags    Set of events describing why the callback was invoked
+ *
+ * Returned Value:
+ *   None
+ *
+ * Assumptions:
+ *   Running at the interrupt level
+ *
+ ****************************************************************************/
+
+static uint16_t send_interrupt(FAR struct uip_driver_s *dev, FAR void *pvconn,
+                               FAR void *pvpriv, uint16_t flags)
+{
+  FAR struct uip_conn *conn = (FAR struct uip_conn*)pvconn;
+  FAR struct send_s *pstate = (FAR struct send_s *)pvpriv;
+
+  nllvdbg("flags: %04x acked: %d sent: %d\n",
+          flags, pstate->snd_acked, pstate->snd_sent);
+
+  /* If this packet contains an acknowledgement, then update the count of
+   * acknowledged bytes.
+   */
+
+  if ((flags & UIP_ACKDATA) != 0)
+    {
+      /* Update the timeout */
+
+#if defined(CONFIG_NET_SOCKOPTS) && !defined(CONFIG_DISABLE_CLOCK)
+      pstate->snd_time = clock_systimer();
+#endif
+
+      /* The current acknowledgement number number is the (relative) offset
+       * of the of the next byte needed by the receiver.  The snd_isn is the
+       * offset of the first byte to send to the receiver.  The difference
+       * is the number of bytes to be acknowledged.
+       */
+
+      pstate->snd_acked = uip_tcpgetsequence(TCPBUF->ackno) - pstate->snd_isn;
+      nllvdbg("ACK: acked=%d sent=%d buflen=%d\n",
+              pstate->snd_acked, pstate->snd_sent, pstate->snd_buflen);
+
+      /* Have all of the bytes in the buffer been sent and acknowledged? */
+
+      if (pstate->snd_acked >= pstate->snd_buflen)
+        {
+          /* Yes.  Then pstate->snd_buflen should hold the number of bytes
+           * actually sent.
+           */
+
+          goto end_wait;
+        }
+
+      /* No.. fall through to send more data if necessary */
+    }
+
+  /* Check if we are being asked to retransmit data */
+
+  else if ((flags & UIP_REXMIT) != 0)
+    {
+      /* Yes.. in this case, reset the number of bytes that have been sent
+       * to the number of bytes that have been ACKed.
+       */
+
+      pstate->snd_sent = pstate->snd_acked;
+
+#if defined(CONFIG_NET_TCP_SPLIT)
+      /* Reset the even/odd indicator to even since we need to
+       * retransmit.
+       */
+
+      pstate->snd_odd = false;
+#endif
+
+      /* Fall through to re-send data from the last that was ACKed */
+    }
+
+ /* Check for a loss of connection */
+
+  else if ((flags & (UIP_CLOSE|UIP_ABORT|UIP_TIMEDOUT)) != 0)
+    {
+      /* Report not connected */
+
+      nllvdbg("Lost connection\n");
+
+      net_lostconnection(pstate->snd_sock, flags);
+      pstate->snd_sent = -ENOTCONN;
+      goto end_wait;
+    }
+
+   /* Check if the outgoing packet is available (it may have been claimed
+    * by a sendto interrupt serving a different thread).
+    */
+
+#if 0 /* We can't really support multiple senders on the same TCP socket */
+   else if (dev->d_sndlen > 0)
+     {
+       /* Another thread has beat us sending data, wait for the next poll */
+
+         return flags;
+      }
+#endif
+
+  /* We get here if (1) not all of the data has been ACKed, (2) we have been
+   * asked to retransmit data, (3) the connection is still healthy, and (4)
+   * the outgoing packet is available for our use.  In this case, we are
+   * now free to send more data to receiver -- UNLESS the buffer contains
+   * unprocessed incoming data.  In that event, we will have to wait for the
+   * next polling cycle.
+   */
+
+  if ((flags & UIP_NEWDATA) == 0 && pstate->snd_sent < pstate->snd_buflen)
+    {
+      uint32_t seqno;
+
+      /* Get the amount of data that we can send in the next packet */
+
+      uint32_t sndlen = pstate->snd_buflen - pstate->snd_sent;
+
+
+#if defined(CONFIG_NET_TCP_SPLIT)
+
+      /* RFC 1122 states that a host may delay ACKing for up to 500ms but
+       * must respond to every second  segment).  This logic here will trick
+       * the RFC 1122 recipient into responding sooner.  This logic will be
+       * activated if:
+       *
+       *   1. An even number of packets has been send (where zero is an even
+       *      number),
+       *   2. There is more data be sent (more than or equal to
+       *      CONFIG_NET_TCP_SPLIT_SIZE), but
+       *   3. Not enough data for two packets.
+       *
+       * Then we will split the remaining, single packet into two partial
+       * packets.  This will stimulate the RFC 1122 peer to ACK sooner.
+       *
+       * Don't try to split very small packets (less than CONFIG_NET_TCP_SPLIT_SIZE).
+       * Only the first even packet and the last odd packets could have
+       * sndlen less than CONFIG_NET_TCP_SPLIT_SIZE.  The value of sndlen on
+       * the last even packet is guaranteed to be at least MSS/2 by the
+       * logic below.
+       */
+
+      if (sndlen >= CONFIG_NET_TCP_SPLIT_SIZE)
+        {
+          /* sndlen is the number of bytes remaining to be sent.
+           * uip_mss(conn) will return the number of bytes that can sent
+           * in one packet.  The difference, then, is the number of bytes
+           * that would be sent in the next packet after this one.
+           */
+
+          int32_t next_sndlen = sndlen - uip_mss(conn);
+
+          /*  Is this the even packet in the packet pair transaction? */
+
+          if (!pstate->snd_odd)
+            {
+              /* next_sndlen <= 0 means that the entire remaining data
+               * could fit into this single packet.  This is condition
+               * in which we must do the split.
+               */
+
+              if (next_sndlen <= 0)
+                {
+                  /* Split so that there will be an odd packet.  Here
+                   * we know that 0 < sndlen <= MSS
+                   */
+
+                  sndlen = (sndlen / 2) + 1;
+                }
+            }
+
+          /* No... this is the odd packet in the packet pair transaction */
+
+          else
+            {
+              /* Will there be another (even) packet afer this one?
+               * (next_sndlen > 0)  Will the split condition occur on that
+               * next, even packet? ((next_sndlen - uip_mss(conn)) < 0) If
+               * so, then perform the split now to avoid the case where the
+               * byte count is less than CONFIG_NET_TCP_SPLIT_SIZE on the
+               * next pair.
+               */
+
+              if (next_sndlen > 0 && (next_sndlen - uip_mss(conn)) < 0)
+                {
+                  /* Here, we know that sndlen must be MSS < sndlen <= 2*MSS
+                   * and so (sndlen / 2) is <= MSS.
+                   */
+
+                  sndlen /= 2;
+                }
+            }
+        }
+
+      /* Toggle the even/odd indicator */
+
+      pstate->snd_odd ^= true;
+
+#endif /* CONFIG_NET_TCP_SPLIT */
+
+      if (sndlen > uip_mss(conn))
+        {
+          sndlen = uip_mss(conn);
+        }
+
+      /* Check if we have "space" in the window */
+
+      if ((pstate->snd_sent - pstate->snd_acked + sndlen) < conn->winsize)
+        {
+          /* Set the sequence number for this packet.  NOTE:  uIP updates
+           * sndseq on recept of ACK *before* this function is called.  In that
+           * case sndseq will point to the next unacknowledged byte (which might
+           * have already been sent).  We will overwrite the value of sndseq
+           * here before the packet is sent.
+           */
+
+          seqno = pstate->snd_sent + pstate->snd_isn;
+          nllvdbg("SEND: sndseq %08x->%08x\n", conn->sndseq, seqno);
+          uip_tcpsetsequence(conn->sndseq, seqno);
+
+          /* Then set-up to send that amount of data. (this won't actually
+           * happen until the polling cycle completes).
+           */
+
+          uip_send(dev, &pstate->snd_buffer[pstate->snd_sent], sndlen);
+
+          /* Check if the destination IP address is in the ARP table.  If not,
+           * then the send won't actually make it out... it will be replaced with
+           * an ARP request.
+           *
+           * NOTE 1: This could be an expensive check if there are a lot of entries
+           * 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 incoming IP
+           * packets, then this check should not be necessary; the MAC mapping
+           * should already be in the ARP table.
+           */
+
+#if defined(CONFIG_NET_ETHERNET) && !defined(CONFIG_NET_ARP_IPIN)
+         if (pstate->snd_sent != 0 || uip_arp_find(conn->ripaddr) != NULL)
+#endif
+            {
+              /* Update the amount of data sent (but not necessarily ACKed) */
+
+              pstate->snd_sent += sndlen;
+              nllvdbg("SEND: acked=%d sent=%d buflen=%d\n",
+                      pstate->snd_acked, pstate->snd_sent, pstate->snd_buflen);
+
+            }
+        }
+    }
+
+  /* All data has been sent and we are just waiting for ACK or re-transmit
+   * indications to complete the send.  Check for a timeout.
+   */
+
+#if defined(CONFIG_NET_SOCKOPTS) && !defined(CONFIG_DISABLE_CLOCK)
+  if (send_timeout(pstate))
+    {
+      /* Yes.. report the timeout */
+
+      nlldbg("SEND timeout\n");
+      pstate->snd_sent = -ETIMEDOUT;
+      goto end_wait;
+    }
+#endif /* CONFIG_NET_SOCKOPTS && !CONFIG_DISABLE_CLOCK */
+
+  /* Continue waiting */
+
+  return flags;
+
+end_wait:
+  /* Do not allow any further callbacks */
+
+  pstate->snd_cb->flags   = 0;
+  pstate->snd_cb->priv    = NULL;
+  pstate->snd_cb->event   = NULL;
+
+  /* There are no outstanding, unacknowledged bytes */
+
+  conn->unacked           = 0;
+
+  /* Wake up the waiting thread */
+
+  sem_post(&pstate->snd_sem);
+  return flags;
+}
+
+/****************************************************************************
+ * 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)
+{
+  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;
+    }
+
+  /* If this is an un-connected socket, then return ENOTCONN */
+
+  if (psock->s_type != SOCK_STREAM || !_SS_ISCONNECTED(psock->s_flags))
+    {
+      err = ENOTCONN;
+      goto errout;
+    }
+
+  /* Set the socket state to sending */
+
+  psock->s_flags = _SS_SETSTATE(psock->s_flags, _SF_SEND);
+
+  /* Perform the TCP 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_conn *conn = (struct uip_conn*)psock->s_conn;
+
+      /* Allocate resources to receive a callback */
+
+      state.snd_cb = uip_tcpcallbackalloc(conn);
+      if (state.snd_cb)
+        {
+          /* Get the initial sequence number that will be used */
+
+          state.snd_isn         = uip_tcpgetsequence(conn->sndseq);
+
+          /* There is no outstanding, unacknowledged data after this
+           * initial sequence number.
+           */
+
+          conn->unacked         = 0;
+
+          /* 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_ACKDATA|UIP_REXMIT|UIP_POLL|UIP_CLOSE|UIP_ABORT|UIP_TIMEDOUT;
+          state.snd_cb->priv    = (void*)&state;
+          state.snd_cb->event   = send_interrupt;
+
+          /* Notify the device driver of the availability of TX data */
+
+          netdev_txnotify(conn->ripaddr);
+
+          /* Wait for the send to complete or an error to occur:  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_tcpcallbackfree(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_TCP && !CONFIG_NET_TCP_WRITE_BUFFERS */
diff --git a/nuttx/net/send.c b/nuttx/net/send.c
index 07a36097a..3efa93b5a 100644
--- a/nuttx/net/send.c
+++ b/nuttx/net/send.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * net/send.c
  *
- *   Copyright (C) 2007-2013 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2007-2014 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -43,599 +43,25 @@
 #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/uip/uip-arp.h>
-#include <nuttx/net/uip/uip-arch.h>
-
-#ifdef CONFIG_NET_ARP_IPIN
-#  include <nuttx/net/uip/uip-arp.h>
-#endif
-
 #include "net_internal.h"
-#include "uip/uip_internal.h"
 
 /****************************************************************************
  * Definitions
  ****************************************************************************/
 
-#if defined(CONFIG_NET_TCP_SPLIT) && !defined(CONFIG_NET_TCP_SPLIT_SIZE)
-#  define CONFIG_NET_TCP_SPLIT_SIZE 40
-#endif
-
-#define TCPBUF ((struct uip_tcpip_hdr *)&dev->d_buf[UIP_LLH_LEN])
-
 /****************************************************************************
  * 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 */
-  uint32_t                   snd_isn;     /* Initial sequence number */
-  uint32_t                   snd_acked;   /* The number of bytes acked */
-#if defined(CONFIG_NET_SOCKOPTS) && !defined(CONFIG_DISABLE_CLOCK)
-  uint32_t                   snd_time;    /* Last send time for determining timeout */
-#endif
-#if defined(CONFIG_NET_TCP_SPLIT)
-  bool                       snd_odd;     /* True: Odd packet in pair transaction */
-#endif
-};
-
 /****************************************************************************
  * Private Functions
  ****************************************************************************/
 
 /****************************************************************************
- * Function: send_timeout
- *
- * Description:
- *   Check for send timeout.
- *
- * Parameters:
- *   pstate   send state structure
- *
- * Returned Value:
- *   TRUE:timeout FALSE:no timeout
- *
- * Assumptions:
- *   Running at the interrupt level
- *
- ****************************************************************************/
-
-#if defined(CONFIG_NET_SOCKOPTS) && !defined(CONFIG_DISABLE_CLOCK)
-static inline int send_timeout(FAR struct send_s *pstate)
-{
-  FAR struct socket *psock = 0;
-
-  /* Check for a timeout configured via setsockopts(SO_SNDTIMEO).
-   * If none... we well let the send wait forever.
-   */
-
-  psock = pstate->snd_sock;
-  if (psock && psock->s_sndtimeo != 0)
-    {
-      /* Check if the configured timeout has elapsed */
-
-      return net_timeo(pstate->snd_time, psock->s_sndtimeo);
-    }
-
-  /* No timeout */
-
-  return FALSE;
-}
-#endif /* CONFIG_NET_SOCKOPTS && !CONFIG_DISABLE_CLOCK */
-
-/****************************************************************************
- * Function: send_interrupt
- *
- * Description:
- *   This function is called from the interrupt level to perform the actual
- *   send operation when polled by the uIP layer.
- *
- * Parameters:
- *   dev      The sructure of the network driver that caused the interrupt
- *   conn     The connection structure associated with the socket
- *   flags    Set of events describing why the callback was invoked
- *
- * Returned Value:
- *   None
- *
- * Assumptions:
- *   Running at the interrupt level
- *
- ****************************************************************************/
-
-static uint16_t send_interrupt(FAR struct uip_driver_s *dev, FAR void *pvconn,
-                               FAR void *pvpriv, uint16_t flags)
-{
-  FAR struct uip_conn *conn = (FAR struct uip_conn*)pvconn;
-  FAR struct send_s *pstate = (FAR struct send_s *)pvpriv;
-
-  nllvdbg("flags: %04x acked: %d sent: %d\n",
-          flags, pstate->snd_acked, pstate->snd_sent);
-
-  /* If this packet contains an acknowledgement, then update the count of
-   * acknowldged bytes.
-   */
-
-  if ((flags & UIP_ACKDATA) != 0)
-    {
-      /* Update the timeout */
-
-#if defined(CONFIG_NET_SOCKOPTS) && !defined(CONFIG_DISABLE_CLOCK)
-      pstate->snd_time = clock_systimer();
-#endif
-
-      /* The current acknowledgement number number is the (relative) offset
-       * of the of the next byte needed by the receiver.  The snd_isn is the
-       * offset of the first byte to send to the receiver.  The difference
-       * is the number of bytes to be acknowledged.
-       */
-
-      pstate->snd_acked = uip_tcpgetsequence(TCPBUF->ackno) - pstate->snd_isn;
-      nllvdbg("ACK: acked=%d sent=%d buflen=%d\n",
-              pstate->snd_acked, pstate->snd_sent, pstate->snd_buflen);
-
-      /* Have all of the bytes in the buffer been sent and acknowledged? */
-
-      if (pstate->snd_acked >= pstate->snd_buflen)
-        {
-          /* Yes.  Then pstate->snd_buflen should hold the number of bytes
-           * actually sent.
-           */
-
-          goto end_wait;
-        }
-
-      /* No.. fall through to send more data if necessary */
-    }
-
-  /* Check if we are being asked to retransmit data */
-
-  else if ((flags & UIP_REXMIT) != 0)
-    {
-      /* Yes.. in this case, reset the number of bytes that have been sent
-       * to the number of bytes that have been ACKed.
-       */
-
-      pstate->snd_sent = pstate->snd_acked;
-
-#if defined(CONFIG_NET_TCP_SPLIT)
-      /* Reset the even/odd indicator to even since we need to
-       * retransmit.
-       */
-
-      pstate->snd_odd = false;
-#endif
-
-      /* Fall through to re-send data from the last that was ACKed */
-    }
-
- /* Check for a loss of connection */
-
-  else if ((flags & (UIP_CLOSE|UIP_ABORT|UIP_TIMEDOUT)) != 0)
-    {
-      /* Report not connected */
-
-      nllvdbg("Lost connection\n");
-
-      net_lostconnection(pstate->snd_sock, flags);
-      pstate->snd_sent = -ENOTCONN;
-      goto end_wait;
-    }
-
-   /* Check if the outgoing packet is available (it may have been claimed
-    * by a sendto interrupt serving a different thread).
-    */
-
-#if 0 /* We can't really support multiple senders on the same TCP socket */
-   else if (dev->d_sndlen > 0)
-     {
-       /* Another thread has beat us sending data, wait for the next poll */
-
-         return flags;
-      }
-#endif
-
-  /* We get here if (1) not all of the data has been ACKed, (2) we have been
-   * asked to retransmit data, (3) the connection is still healthy, and (4)
-   * the outgoing packet is available for our use.  In this case, we are
-   * now free to send more data to receiver -- UNLESS the buffer contains
-   * unprocessing incoming data.  In that event, we will have to wait for the
-   * next polling cycle.
-   */
-
-  if ((flags & UIP_NEWDATA) == 0 && pstate->snd_sent < pstate->snd_buflen)
-    {
-      uint32_t seqno;
-
-      /* Get the amount of data that we can send in the next packet */
-
-      uint32_t sndlen = pstate->snd_buflen - pstate->snd_sent;
-
-
-#if defined(CONFIG_NET_TCP_SPLIT)
-
-      /* RFC 1122 states that a host may delay ACKing for up to 500ms but
-       * must respond to every second  segment).  This logic here will trick
-       * the RFC 1122 recipient into responding sooner.  This logic will be
-       * activated if:
-       *
-       *   1. An even number of packets has been send (where zero is an even
-       *      number),
-       *   2. There is more data be sent (more than or equal to
-       *      CONFIG_NET_TCP_SPLIT_SIZE), but
-       *   3. Not enough data for two packets.
-       *
-       * Then we will split the remaining, single packet into two partial
-       * packets.  This will stimulate the RFC 1122 peer to ACK sooner.
-       *
-       * Don't try to split very small packets (less than CONFIG_NET_TCP_SPLIT_SIZE).
-       * Only the first even packet and the last odd packets could have
-       * sndlen less than CONFIG_NET_TCP_SPLIT_SIZE.  The value of sndlen on
-       * the last even packet is guaranteed to be at least MSS/2 by the
-       * logic below.
-       */
-
-      if (sndlen >= CONFIG_NET_TCP_SPLIT_SIZE)
-        {
-          /* sndlen is the number of bytes remaining to be sent.
-           * uip_mss(conn) will return the number of bytes that can sent
-           * in one packet.  The difference, then, is the number of bytes
-           * that would be sent in the next packet after this one.
-           */
-
-          int32_t next_sndlen = sndlen - uip_mss(conn);
-
-          /*  Is this the even packet in the packet pair transaction? */
-
-          if (!pstate->snd_odd)
-            {
-              /* next_sndlen <= 0 means that the entire remaining data
-               * could fit into this single packet.  This is condition
-               * in which we must do the split.
-               */
-
-              if (next_sndlen <= 0)
-                {
-                  /* Split so that there will be an odd packet.  Here
-                   * we know that 0 < sndlen <= MSS
-                   */
-
-                  sndlen = (sndlen / 2) + 1;
-                }
-            }
-
-          /* No... this is the odd packet in the packet pair transaction */
-
-          else
-            {
-              /* Will there be another (even) packet afer this one?
-               * (next_sndlen > 0)  Will the split conidition occur on that
-               * next, even packet? ((next_sndlen - uip_mss(conn)) < 0) If
-               * so, then perform the split now to avoid the case where the
-               * byte count is less than CONFIG_NET_TCP_SPLIT_SIZE on the
-               * next pair.
-               */
-
-              if (next_sndlen > 0 && (next_sndlen - uip_mss(conn)) < 0)
-                {
-                  /* Here, we know that sndlen must be MSS < sndlen <= 2*MSS
-                   * and so (sndlen / 2) is <= MSS.
-                   */
-
-                  sndlen /= 2;
-                }
-            }
-        }
-
-      /* Toggle the even/odd indicator */
-
-      pstate->snd_odd ^= true;
-
-#endif /* CONFIG_NET_TCP_SPLIT */
-
-      if (sndlen > uip_mss(conn))
-        {
-          sndlen = uip_mss(conn);
-        }
-
-      /* Check if we have "space" in the window */
-
-      if ((pstate->snd_sent - pstate->snd_acked + sndlen) < conn->winsize)
-        {
-
-          /* Set the sequence number for this packet.  NOTE:  uIP updates
-           * sndseq on recept of ACK *before* this function is called.  In that
-           * case sndseq will point to the next unacknowledge byte (which might
-           * have already been sent).  We will overwrite the value of sndseq
-           * here before the packet is sent.
-           */
-
-          seqno = pstate->snd_sent + pstate->snd_isn;
-          nllvdbg("SEND: sndseq %08x->%08x\n", conn->sndseq, seqno);
-          uip_tcpsetsequence(conn->sndseq, seqno);
-
-          /* Then set-up to send that amount of data. (this won't actually
-           * happen until the polling cycle completes).
-           */
-
-          uip_send(dev, &pstate->snd_buffer[pstate->snd_sent], sndlen);
-
-          /* Check if the destination IP address is in the ARP table.  If not,
-           * then the send won't actually make it out... it will be replaced with
-           * an ARP request.
-           *
-           * NOTE 1: This could be an expensive check if there are a lot of entries
-           * 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
-           * packets, then this check should not be necessary; the MAC mapping
-           * should already be in the ARP table.
-           */
-
-#if defined(CONFIG_NET_ETHERNET) && !defined(CONFIG_NET_ARP_IPIN)
-         if (pstate->snd_sent != 0 || uip_arp_find(conn->ripaddr) != NULL)
-#endif
-            {
-              /* Update the amount of data sent (but not necessarily ACKed) */
-
-              pstate->snd_sent += sndlen;
-              nllvdbg("SEND: acked=%d sent=%d buflen=%d\n",
-                      pstate->snd_acked, pstate->snd_sent, pstate->snd_buflen);
-
-            }
-        }
-    }
-
-  /* All data has been sent and we are just waiting for ACK or re-transmit
-   * indications to complete the send.  Check for a timeout.
-   */
-
-#if defined(CONFIG_NET_SOCKOPTS) && !defined(CONFIG_DISABLE_CLOCK)
-  if (send_timeout(pstate))
-    {
-      /* Yes.. report the timeout */
-
-      nlldbg("SEND timeout\n");
-      pstate->snd_sent = -ETIMEDOUT;
-      goto end_wait;
-    }
-#endif /* CONFIG_NET_SOCKOPTS && !CONFIG_DISABLE_CLOCK */
-
-  /* Continue waiting */
-
-  return flags;
-
-end_wait:
-  /* Do not allow any further callbacks */
-
-  pstate->snd_cb->flags   = 0;
-  pstate->snd_cb->priv    = NULL;
-  pstate->snd_cb->event   = NULL;
-
-  /* There are no outstanding, unacknowledged bytes */
-
-  conn->unacked           = 0;
-
-  /* Wake up the waiting thread */
-
-  sem_post(&pstate->snd_sem);
-  return flags;
-}
-
-/****************************************************************************
  * 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)
-{
-  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;
-    }
-
-  /* If this is an un-connected socket, then return ENOTCONN */
-
-  if (psock->s_type != SOCK_STREAM || !_SS_ISCONNECTED(psock->s_flags))
-    {
-      err = ENOTCONN;
-      goto errout;
-    }
-
-  /* Set the socket state to sending */
-
-  psock->s_flags = _SS_SETSTATE(psock->s_flags, _SF_SEND);
-
-  /* Perform the TCP 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_conn *conn = (struct uip_conn*)psock->s_conn;
-
-      /* Allocate resources to receive a callback */
-
-      state.snd_cb = uip_tcpcallbackalloc(conn);
-      if (state.snd_cb)
-        {
-          /* Get the initial sequence number that will be used */
-
-          state.snd_isn         = uip_tcpgetsequence(conn->sndseq);
-
-          /* There is no outstanding, unacknowledged data after this
-           * initial sequence number.
-           */
-
-          conn->unacked         = 0;
-
-          /* 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_ACKDATA|UIP_REXMIT|UIP_POLL|UIP_CLOSE|UIP_ABORT|UIP_TIMEDOUT;
-          state.snd_cb->priv    = (void*)&state;
-          state.snd_cb->event   = send_interrupt;
-
-          /* Notify the device driver of the availaibilty of TX data */
-
-          netdev_txnotify(conn->ripaddr);
-
-          /* Wait for the send to complete or an error to occur:  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_tcpcallbackfree(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 signaled 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;
-}
-
-/****************************************************************************
  * Function: send
  *
  * Description:
diff --git a/nuttx/net/socket.c b/nuttx/net/socket.c
index a6befc5d7..460089b3d 100644
--- a/nuttx/net/socket.c
+++ b/nuttx/net/socket.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * net/socket.c
  *
- *   Copyright (C) 2007-2009, 2012 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2007-2009, 2012, 2014 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -128,6 +128,9 @@ int psock_socket(int domain, int type, int protocol, FAR struct socket *psock)
 
   psock->s_type = type;
   psock->s_conn = NULL;
+#ifdef CONFIG_NET_TCP_WRBUFFER
+  psock->s_sndcb = NULL;
+#endif
 
   /* Allocate the appropriate connection structure.  This reserves the
    * the connection structure is is unallocated at this point.  It will
@@ -153,8 +156,11 @@ int psock_socket(int domain, int type, int protocol, FAR struct socket *psock)
                */
 
               DEBUGASSERT(conn->crefs == 0);
-              psock->s_conn = conn;
-              conn->crefs   = 1;
+              psock->s_conn  = conn;
+              conn->crefs    = 1;
+#ifdef CONFIG_NET_TCP_WRBUFFER
+              psock->s_sndcb = NULL;
+#endif
             }
         }
         break;
@@ -282,5 +288,3 @@ errout:
 }
 
 #endif /* CONFIG_NET */
-
-
diff --git a/nuttx/net/uip/Make.defs b/nuttx/net/uip/Make.defs
index c5d915e61..d5564d845 100644
--- a/nuttx/net/uip/Make.defs
+++ b/nuttx/net/uip/Make.defs
@@ -1,7 +1,7 @@
 ############################################################################
-# Make.defs
+# net/uip/Make.defs
 #
-#   Copyright (C) 2007, 2009-20010 Gregory Nutt. All rights reserved.
+#   Copyright (C) 2007, 2009-2010, 2014 Gregory Nutt. All rights reserved.
 #   Author: Gregory Nutt <gnutt@nuttx.org>
 #
 # Redistribution and use in source and binary forms, with or without
@@ -40,8 +40,8 @@ ifeq ($(CONFIG_NET),y)
 
 # Common IP source files
 
-UIP_CSRCS += uip_initialize.c uip_setipid.c uip_input.c uip_send.c \
-	     uip_poll.c uip_chksum.c uip_callback.c
+UIP_CSRCS += uip_initialize.c uip_setipid.c uip_input.c uip_send.c
+UIP_CSRCS += uip_poll.c uip_chksum.c uip_callback.c
 
 # Non-interrupt level support required?
 
@@ -65,18 +65,28 @@ endif
 
 ifeq ($(CONFIG_NET_TCP),y)
 
-UIP_CSRCS += uip_tcpconn.c uip_tcpseqno.c uip_tcppoll.c uip_tcptimer.c uip_tcpsend.c \
-	     uip_tcpinput.c uip_tcpappsend.c uip_listen.c uip_tcpcallback.c \
-	     uip_tcpreadahead.c uip_tcpbacklog.c
+UIP_CSRCS += uip_tcpconn.c uip_tcpseqno.c uip_tcppoll.c uip_tcptimer.c
+UIP_CSRCS += uip_tcpsend.c uip_tcpinput.c uip_tcpappsend.c uip_listen.c
+UIP_CSRCS += uip_tcpcallback.c uip_tcpbacklog.c
 
 endif
 
+# Buffering
+
+ifeq ($(CONFIG_NET_TCP_READAHEAD),y)
+UIP_CSRCS += uip_tcpreadahead.c
+endif
+
+ifeq ($(CONFIG_NET_TCP_WRBUFFER),y)
+UIP_CSRCS += uip_tcpwrbuffer.c
+endif
+
 # UDP source files
 
 ifeq ($(CONFIG_NET_UDP),y)
 
-UIP_CSRCS += uip_udpconn.c uip_udppoll.c uip_udpsend.c uip_udpinput.c \
-	     uip_udpcallback.c
+UIP_CSRCS += uip_udpconn.c uip_udppoll.c uip_udpsend.c uip_udpinput.c
+UIP_CSRCS += uip_udpcallback.c
 
 endif
 
@@ -95,12 +105,10 @@ endif
 # IGMP source files
 
 ifeq ($(CONFIG_NET_IGMP),y)
-UIP_CSRCS += uip_igmpgroup.c uip_igmpinit.c uip_igmpinput.c uip_igmpjoin.c \
-	     uip_igmpleave.c uip_igmpmsg.c uip_igmpsend.c uip_igmptimer.c \
-	     uip_mcastmac.c
+UIP_CSRCS += uip_igmpgroup.c uip_igmpinit.c uip_igmpinput.c uip_igmpjoin.c
+UIP_CSRCS += uip_igmpleave.c uip_igmpmsg.c uip_igmpsend.c uip_igmptimer.c
+UIP_CSRCS += uip_mcastmac.c
 endif
 
 endif
 endif
-
-
diff --git a/nuttx/net/uip/uip_initialize.c b/nuttx/net/uip/uip_initialize.c
index 064f240d1..9b40c87bb 100644
--- a/nuttx/net/uip/uip_initialize.c
+++ b/nuttx/net/uip/uip_initialize.c
@@ -139,6 +139,12 @@ void uip_initialize(void)
 #endif
 #endif /* CONFIG_NET_TCP */
 
+  /* Initialize the TCP/IP write buffering */
+
+#ifdef CONFIG_NET_TCP_WRITE_BUFFERS
+  uip_tcpwrbuffer_init();
+#endif
+
   /* Initialize the UDP connection structures */
 
 #ifdef CONFIG_NET_UDP
@@ -152,4 +158,3 @@ void uip_initialize(void)
 #endif
 }
 #endif /* CONFIG_NET */
-
diff --git a/nuttx/net/uip/uip_tcpwrbuffer.c b/nuttx/net/uip/uip_tcpwrbuffer.c
new file mode 100644
index 000000000..915e451d5
--- /dev/null
+++ b/nuttx/net/uip/uip_tcpwrbuffer.c
@@ -0,0 +1,165 @@
+/****************************************************************************
+ * net/uip/uip_tcpwrbuffer.c
+ *
+ *   Copyright (C) 2007-2009, 2013-2014 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <gnutt@nuttx.org>
+ *           Jason Jiang  <jasonj@live.cn>
+ *
+ * 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/net/uip/uipopt.h>
+#if defined(CONFIG_NET) && defined(CONFIG_NET_TCP) && defined(CONFIG_NET_TCP_WRITE_BUFFERS)
+
+#include <queue.h>
+#include <semaphore.h>
+#include <debug.h>
+
+#include "uip_internal.h"
+
+/****************************************************************************
+ * Private Types
+ ****************************************************************************/
+
+/* Package all globals used by this logic into a structure */
+
+struct wrbuffer_s
+{
+  /* The semaphore to protect the buffers */
+
+  sem_t sem;
+
+  /* This is the list of available write buffers */
+
+  sq_queue_t freebuffers;
+
+  /* These are the pre-allocated write buffers */
+
+  struct uip_wrbuffer_s buffers[CONFIG_NET_NTCP_WRITE_BUFFERS];
+};
+
+/****************************************************************************
+ * Private Data
+ ****************************************************************************/
+
+/* This is the state of the global write buffer resource */
+
+static struct wrbuffer_s g_wrbuffer;
+
+/****************************************************************************
+ * Private Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Function: uip_tcpwrbuffer_init
+ *
+ * Description:
+ *   Initialize the list of free write buffers
+ *
+ * Assumptions:
+ *   Called once early initialization.
+ *
+ ****************************************************************************/
+
+void uip_tcpwrbuffer_init(void)
+{
+  int i;
+
+  sq_init(&g_wrbuffer.freebuffers);
+
+  for (i = 0; i < CONFIG_NET_NTCP_WRITE_BUFFERS; i++)
+    {
+      sq_addfirst(&g_wrbuffer.buffers[i].wb_node, &g_wrbuffer.freebuffers);
+    }
+
+  sem_init(&g_wrbuffer.sem, 0, CONFIG_NET_NTCP_WRITE_BUFFERS);
+}
+
+/****************************************************************************
+ * Function: uip_tcpwrbuffer_alloc
+ *
+ * Description:
+ *   Allocate a TCP write buffer by taking a pre-allocated buffer from
+ *   the free list.  This function is called from TCP logic when a buffer
+ *   of TCP data is about to sent
+ *
+ * Assumptions:
+ *   Called from user logic with interrupts enabled.
+ *
+ ****************************************************************************/
+
+FAR struct uip_wrbuffer_s *uip_tcpwrbuffer_alloc(FAR const struct timespec *abstime)
+{
+  int ret;
+
+  if (abstime)
+    {
+      ret = sem_timedwait(&g_wrbuffer.sem, abstime);
+    }
+  else
+    {
+      ret = sem_wait(&g_wrbuffer.sem);
+    }
+
+  if (ret != 0)
+    {
+      return NULL;
+    }
+
+  return (FAR struct uip_wrbuffer_s*)sq_remfirst(&g_wrbuffer.freebuffers);
+}
+
+/****************************************************************************
+ * Function: uip_tcpwrbuffer_release
+ *
+ * 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.
+ *
+ * Assumptions:
+ *   Called from interrupt level with interrupts disabled.
+ *
+ ****************************************************************************/
+
+void uip_tcpwrbuffer_release(FAR struct uip_wrbuffer_s *wrbuffer)
+{
+  sq_addlast(&wrbuffer->wb_node, &g_wrbuffer.freebuffers);
+  sem_post(&g_wrbuffer.sem);
+}
+
+#endif /* CONFIG_NET && CONFIG_NET_TCP && CONFIG_NET_NTCP_WRITE_BUFFERS*/