Implement poll/select for sockets

git-svn-id: svn://svn.code.sf.net/p/nuttx/code/trunk@1277 42af7a65-404d-4744-a932-0658087f49c3

2 files changed, 287 insertions, 11 deletions

diff --git a/nuttx/net/net-internal.h b/nuttx/net/net-internal.h
index 43d8d81df..37d22c280 100644
--- a/nuttx/net/net-internal.h
+++ b/nuttx/net/net-internal.h
@@ -1,7 +1,7 @@
 /****************************************************************************
- * net-internal.h
+ * net/net-internal.h
  *
- *   Copyright (C) 2007 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2007, 2008 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -14,7 +14,7 @@
  *    notice, this list of conditions and the following disclaimer in
  *    the documentation and/or other materials provided with the
  *    distribution.
- * 3. Neither the name Gregory Nutt nor the names of its contributors may be
+ * 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.
  *
diff --git a/nuttx/net/net-poll.c b/nuttx/net/net-poll.c
index b11cfe964..08c2bb1b4 100644
--- a/nuttx/net/net-poll.c
+++ b/nuttx/net/net-poll.c
@@ -49,7 +49,231 @@
 #include "net-internal.h"
 
 /****************************************************************************
- * Global Functions
+ * Pre-processor Definitions
+ ****************************************************************************/
+
+/* Network polling can only be supported on TCP and only if read-ahead buffering
+ * is enabled (it could be supported on UDP as will if it also had read-ahead
+ * buffering.
+ */
+
+#if defined(CONFIG_DISABLE_POLL) && CONFIG_NSOCKET_DESCRIPTORS > 0 && \
+    defined(CONFIG_NET_TCP) && CONFIG_NET_NTCP_READAHEAD_BUFFERS > 0
+#  define HAVE_NETPOLL 1
+#else
+#  undef HAVE_NETPOLL
+#endif
+
+/****************************************************************************
+ * Private Types
+ ****************************************************************************/
+
+struct net_poll_s
+{
+  FAR struct pollfd         *fds;  /* The descriptor poll info */
+};
+
+/****************************************************************************
+ * Private Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Function: poll_interrupt
+ *
+ * Description:
+ *   This function is called from the interrupt level to perform the actual
+ *   TCP receive operation via 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
+ *
+ ****************************************************************************/
+
+#ifdef HAVE_NETPOLL
+static uint16 poll_interrupt(struct uip_driver_s *dev, FAR void *conn,
+                             FAR void *pvprivate, uint16 flags)
+{
+  struct pollfd *fds = (struct recvfrom_s *)pvprivate;
+
+  nvdbg("flags: %04x\n", flags);
+
+  /* 'private' might be null in some race conditions (?) */
+
+  if (fds)
+    {
+      pollevent_t eventset = 0;
+
+      /* Check for data availability events. */
+
+      if ((flags & UIP_NEWDATA) != 0)
+        {
+          eventset |= POLLIN & fds->events;
+        }
+
+      /* A poll is a sign that we are free to send data. */
+
+      if ((flags & UIP_POLL) != 0)
+        {
+          eventset |= POLLOUT & fds->events;
+        }
+
+      /* Check for a loss of connection events */
+
+      if ((flags & (UIP_CLOSE|UIP_ABORT|UIP_TIMEDOUT)) != 0)
+        {
+          eventset |= (POLLERR|POLLHUP);
+        }
+
+      if (eventset)
+        {
+          fds->revevents |= eventset;
+          sem_post(fds->sem);
+        }
+    }
+  return flags;
+}
+#endif /* HAVE_NETPOLL */
+
+/****************************************************************************
+ * Function: net_pollsetup
+ *
+ * Description:
+ *   Setup to monitor events on one TCP/IP socket
+ *
+ * Input Parameters:
+ *   conn  - The TCP/IP connection of interest
+ *   fds   - The structure describing the events to be monitored, OR NULL if
+ *           this is a request to stop monitoring events.
+ *
+ * Returned Value:
+ *  0: Success; Negated errno on failure
+ *
+ ****************************************************************************/
+
+#ifdef HAVE_NETPOLL
+static inline int net_pollsetup((FAR struct uip_conn *)conn, struct pollfd *fds)
+{
+  FAR struct uip_callback_s *cb;
+  irqstate_t flags;
+  int ret;
+
+  /* Sanity check */
+
+#ifdef CONFIG_DEBUG
+  if (!conn || !fds || fds->private)
+    {
+      ret = -EINVAL;
+      goto errout;
+    }
+#endif
+
+  /* Some of the  following must be atomic */
+
+  flags = irqsave();
+
+  /* Allocate a TCP/IP callback structure */
+
+  cb = uip_tcpcallbackalloc(conn);
+  if (!cb)
+    {
+      ret = -EBUSY;
+      goto errout_with_irq;
+    }
+
+  /* Initialize the callbcack structure */
+
+  cb->flags    = UIP_NEWDATA|UIP_POLL|UIP_CLOSE|UIP_ABORT|UIP_TIMEDOUT;
+  cb->private  = (FAR void *)fds;
+  cb->event    = poll_interrupt;
+
+  /* Save the nps reference in the poll structure for use at teardown as well */
+
+  fds->private = (FAR void *)cb;
+
+  /* Check for read data availability now */
+
+  if (!sq_empty(&conn->readahead))
+    {
+      fds->revents = fds->events & POLLIN;
+      if (fds->revents != 0)
+        {
+          /* If data is available now, the signal the poll logic */
+
+          sem_post(fds->sem);
+        }
+    }
+  irqrestore(flags);
+  return OK;
+
+errout_with_irq:
+  irqrestore(flags);
+  free(nps);
+errout:
+  return ret;
+}
+#endif /* HAVE_NETPOLL */
+
+/****************************************************************************
+ * Function: net_pollteardown
+ *
+ * Description:
+ *   Teardown monitoring of events on an TCP/IP socket
+ *
+ * Input Parameters:
+ *   conn  - The TCP/IP connection of interest
+ *
+ * Returned Value:
+ *  0: Success; Negated errno on failure
+ *
+ ****************************************************************************/
+
+#ifdef HAVE_NETPOLL
+static inline int net_pollteardown((FAR struct uip_conn *)conn, struct pollfd *fds)
+{
+  FAR struct uip_callback_s *cb;
+  irqstate_t flags;
+  int ret;
+
+  /* Sanity check */
+
+#ifdef CONFIG_DEBUG
+  if (!conn || !fds || !fds->private)
+    {
+      ret = -EINVAL;
+      goto errout;
+    }
+#endif
+
+  /* Recover the socket descriptor poll state info from the poll structure */
+
+  cb = (FAR struct uip_callback_s *)fds->private;
+  if (cb)
+    {
+      /* Release the callback */
+
+      flags = irqsave();
+      uip_tcpcallbackfree(conn, cb);
+      irqrestore(flags);
+
+      /* Release the poll/select data slot */
+
+      fds->private = NULL;
+    }
+
+  return OK;
+}
+#endif /* HAVE_NETPOLL */
+
+/****************************************************************************
+ * Public Functions
  ****************************************************************************/
 
 /****************************************************************************
@@ -59,22 +283,74 @@
  *   The standard poll() operation redirects operations on socket descriptors
  *   to this function.
  *
- * Parameters:
+ * Input Parameters:
  *   fd   - The socket descriptor of interest
- *   fds  - The structures describing events to be monitored, OR NULL if
+ *   fds  - The structure describing the events to be monitored, OR NULL if
  *          this is a request to stop monitoring events.
  *
  * Returned Value:
- *  TBD
+ *  0: Success; Negated errno on failure
  *
  ****************************************************************************/
 
+#ifndef CONFIG_DISABLE_POLL
 int net_poll(int sockfd, struct pollfd *fds)
 {
-#ifdef CONFIG_CPP_HAVE_WARNING
-#  warning To be provided
-#endif
+#ifndef HAVE_NETPOLL
   return -ENOSYS;
+#else
+  FAR struct socket *psock;
+  int ret;
+
+  /* Verify that non-NULL pointers were passed */
+
+#ifdef CONFIG_DEBUG
+  if (!fds)
+    {
+      ret = -EINVAL;
+      goto errout;
+    }
+#endif
+
+  /* Get the underlying socket structure and verify that the sockfd
+   * corresponds to valid, allocated socket
+   */
+
+  psock = sockfd_socket(sockfd);
+  if (!psock || psock->s_crefs <= 0)
+    {
+      ret = -EBADF;
+      goto errout;
+    }
+
+#ifdef CONFIG_NET_UDP
+  /* poll() not supported for UDP */
+
+  if (psock->s_type != SOCK_STREAM)
+    {
+      ret = -ENOSYS;
+      goto errout;
+    }
+#endif
+
+  /* Check if we are setting up or tearing down the poll */
+  if (fds)
+    {
+      /* Perform the TCP/IP poll() setup */
+
+      ret = net_pollsetup((FAR struct uip_conn *)psock->conn, fds);
+    }
+  else
+    {
+      /* Perform the TCP/IP poll() teardown */
+
+      ret = net_pollteardown((FAR struct uip_conn *)psock->conn);
+    }
+
+errout:
+  return ret;
+#endif /* HAVE_NETPOLL */
 }
+#endif /* !CONFIG_DISABLE_POLL */
 
-#endif /* CONFIG_NET&& !CONFIG_DISABLE_POLL */
+#endif /* CONFIG_NET && !CONFIG_DISABLE_POLL */