Move nuttx/netutils to apps/netutils

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

Makefile

@@ -47,7 +47,7 @@ APPDIR = ${shell pwd}
 # SUBDIRS is the list of all directories containing Makefiles.  It is used
 # only for cleaning.
 
-SUBDIRS = nshlib vsn
+SUBDIRS = nshlib netutils vsn
 
 # we use a non-existing .built_always to guarantee that Makefile
 # always walks into the sub-directories and asks for build

README.txt

@@ -52,6 +52,7 @@ will call:
 Application skeleton can be found under the hello sub-directory,
 which shows how an application can be added to the project. One must
 define:
+
  1. create sub-directory as: appname
  2. provide entry point: appname_main()
  3. set the requirements in the file: Makefile, specially the lines:
@@ -62,3 +63,6 @@ define:
 	CSRCS		= C source file list as foo1.c foo2.c ..
 
  4. add application in the apps/Makefile
+
+
+

netutils/Makefile

@@ -0,0 +1,62 @@
+############################################################################
+# apps/netutils/Makefile
+#
+#   Copyright (C) 2011 Gregory Nutt. All rights reserved.
+#   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+#
+# 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.
+#
+############################################################################
+
+-include $(TOPDIR)/.config	# Current configuration
+
+# Sub-directories
+
+ifeq ($(CONFIG_NET),y)
+SUBDIRS = uiplib dhcpc dhcpd resolv smtp telnetd webclient webserver tftpc thttpd
+endif
+
+all: nothing
+.PHONY: nothing depend clean distclean
+
+nothing:
+
+define DOMAKE
+	@(MAKE) -C $1 $2 TOPDIR="$(TOPDIR) APPDIR=$(APPDIR)"
+endef
+
+depend:
+	$(foreach DIR, $(SUBDIRS), $(eval $(call DOMAKE,$(DIR),depend)))
+
+clean:
+	$(foreach DIR, $(SUBDIRS), $(eval $(call DOMAKE,$(DIR),clean)))
+
+distclean: clean
+	$(foreach DIR, $(SUBDIRS), $(eval $(call DOMAKE,$(DIR),distclean)))
+
+-include Make.dep

netutils/README.txt

@@ -0,0 +1,39 @@
+netutils
+^^^^^^^^
+
+This directory contains most of the network applications contained
+under the uIP-1.0 apps directory.  As the uIP apps/README says,
+these applications "are not all heavily tested."  These uIP apps
+include:
+
+  dhcpc     - Dynamic Host Configuration Protocol (DHCP) client
+  resolv    - uIP DNS resolver
+  smtp      - Simple Mail Transfer Protocol (SMTP) client
+  telnetd   - TELNET server
+  webclient - HTTP web client
+  webserver - HTTP web server
+
+You may find additional information on these apps in the uIP forum
+accessible through: http://www.sics.se/~adam/uip/index.php/Main_Page 
+
+Additional applications that were not part of uIP (but which are
+highly influenced by uIP) include:
+
+  dhcpd     - Dynamic Host Configuration Protocol (DHCP) server
+  tftpc     - TFTP client
+  thttpd    - This is a port of Jef Poskanzer's THTTPD HTPPD server.
+              See http://acme.com/software/thttpd/.
+
+If you use DHCPC/D, then some special configuration network options are
+required.  These include:
+
+  CONFIG_NET=y               Of course
+  CONFIG_NSOCKET_DESCRIPTORS And, of course, you must allocate some
+                             socket descriptors.
+  CONFIG_NET_UDP=y           UDP support is required for DHCP
+                             (as well as various other UDP-related
+                             configuration settings).
+  CONFIG_NET_BROADCAST=y     UDP broadcast support is needed.
+  CONFIG_NET_BUFSIZE=650     The client must be prepared to receive
+  (or larger)                DHCP messages of up to 576 bytes (excluding
+                             Ethernet, IP, or UDP headers and FCS).

netutils/dhcpc/Makefile

@@ -0,0 +1,94 @@
+############################################################################
+# apps/netutils/dhcpc/Makefile
+#
+#   Copyright (C) 2011 Gregory Nutt. All rights reserved.
+#   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+#
+# 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.
+#
+############################################################################
+
+-include $(TOPDIR)/.config
+-include $(TOPDIR)/Make.defs
+include $(APPDIR)/Make.defs
+
+# DHCP Client Library
+
+ASRCS		=
+CSRCS		= 
+
+ifeq ($(CONFIG_NET_UDP),y)
+CSRCS		+= dhcpc.c
+endif
+
+AOBJS		= $(ASRCS:.S=$(OBJEXT))
+COBJS		= $(CSRCS:.c=$(OBJEXT))
+
+SRCS		= $(ASRCS) $(CSRCS)
+OBJS		= $(AOBJS) $(COBJS)
+
+BIN	    	= ../../libapps$(LIBEXT)
+
+ROOTDEPPATH	= --dep-path .
+
+# Common build
+
+VPATH		= 
+
+all: .built
+
+$(AOBJS): %$(OBJEXT): %.S
+	$(call ASSEMBLE, $<, $@)
+
+$(COBJS): %$(OBJEXT): %.c
+	$(call COMPILE, $<, $@)
+
+$(BIN):	$(OBJS)
+	@( for obj in $(OBJS) ; do \
+		$(call ARCHIVE, $@, $${obj}); \
+	done ; )
+	@touch .built
+	
+.built: $(BIN)
+
+.depend: Makefile $(SRCS)
+	@$(MKDEP) $(ROOTDEPPATH) \
+	  $(CC) -- $(CFLAGS) -- $(SRCS) >Make.dep
+	@touch $@
+
+# Register application
+depend: .depend
+
+clean:
+	@rm -f $(BIN) *.o *~ .*.swp .built
+	$(call CLEAN)
+
+distclean: clean
+	@rm -f Make.dep .depend
+
+-include Make.dep

netutils/dhcpc/dhcpc.c

@@ -0,0 +1,607 @@
+/****************************************************************************
+ * netutils/dhcpc/dhcpc.c
+ *
+ *   Copyright (C) 2007, 2009, 2011 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * Based heavily on portions of uIP:
+ *
+ *   Author: Adam Dunkels <adam@dunkels.com>
+ *   Copyright (c) 2005, Swedish Institute of Computer Science
+ *   All rights reserved.
+ *
+ * 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 of the Institute 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 INSTITUTE 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 INSTITUTE 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 <sys/types.h>
+#include <sys/socket.h>
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <unistd.h>
+#include <time.h>
+#include <errno.h>
+#include <debug.h>
+
+#include <net/uip/uip.h>
+#include <apps/netutils/dhcpc.h>
+#include <apps/netutils/uiplib.h>
+
+/****************************************************************************
+ * Definitions
+ ****************************************************************************/
+
+#define STATE_INITIAL           0
+#define STATE_HAVE_OFFER        1
+#define STATE_HAVE_LEASE        2
+
+#define BOOTP_BROADCAST         0x8000
+
+#define DHCP_REQUEST            1
+#define DHCP_REPLY              2
+#define DHCP_HTYPE_ETHERNET     1
+#define DHCP_HLEN_ETHERNET      6
+#define DHCP_MSG_LEN            236
+
+#define DHCPC_SERVER_PORT       67
+#define DHCPC_CLIENT_PORT       68
+
+#define DHCPDISCOVER            1
+#define DHCPOFFER               2
+#define DHCPREQUEST             3
+#define DHCPDECLINE             4
+#define DHCPACK                 5
+#define DHCPNAK                 6
+#define DHCPRELEASE             7
+
+#define DHCP_OPTION_SUBNET_MASK 1
+#define DHCP_OPTION_ROUTER      3
+#define DHCP_OPTION_DNS_SERVER  6
+#define DHCP_OPTION_REQ_IPADDR  50
+#define DHCP_OPTION_LEASE_TIME  51
+#define DHCP_OPTION_MSG_TYPE    53
+#define DHCP_OPTION_SERVER_ID   54
+#define DHCP_OPTION_REQ_LIST    55
+#define DHCP_OPTION_END         255
+
+#define BUFFER_SIZE             256
+
+/****************************************************************************
+ * Private Types
+ ****************************************************************************/
+
+struct dhcp_msg
+{
+  uint8_t  op;
+  uint8_t  htype;
+  uint8_t  hlen;
+  uint8_t  hops;
+  uint8_t  xid[4];
+  uint16_t secs;
+  uint16_t flags;
+  uint8_t  ciaddr[4];
+  uint8_t  yiaddr[4];
+  uint8_t  siaddr[4];
+  uint8_t  giaddr[4];
+  uint8_t  chaddr[16];
+#ifndef CONFIG_NET_DHCP_LIGHT
+  uint8_t  sname[64];
+  uint8_t  file[128];
+#endif
+  uint8_t  options[312];
+};
+
+struct dhcpc_state_s
+{
+  struct uip_udp_conn *ds_conn;
+  const void          *ds_macaddr;
+  int                  ds_maclen;
+  int                  sockfd;
+  struct in_addr       ipaddr;
+  struct in_addr       serverid;
+  struct dhcp_msg      packet;
+};
+
+/****************************************************************************
+ * Private Data
+ ****************************************************************************/
+
+static const uint8_t xid[4]          = {0xad, 0xde, 0x12, 0x23};
+static const uint8_t magic_cookie[4] = {99, 130, 83, 99};
+
+/****************************************************************************
+ * Private Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: dhcpc_add<option>
+ ****************************************************************************/
+
+static uint8_t *dhcpc_addmsgtype(uint8_t *optptr, uint8_t type)
+{
+  *optptr++ = DHCP_OPTION_MSG_TYPE;
+  *optptr++ = 1;
+  *optptr++ = type;
+  return optptr;
+}
+
+static uint8_t *dhcpc_addserverid(struct in_addr *serverid, uint8_t *optptr)
+{
+  *optptr++ = DHCP_OPTION_SERVER_ID;
+  *optptr++ = 4;
+  memcpy(optptr, &serverid->s_addr, 4);
+  return optptr + 4;
+}
+
+static uint8_t *dhcpc_addreqipaddr(struct in_addr *ipaddr, uint8_t *optptr)
+{
+  *optptr++ = DHCP_OPTION_REQ_IPADDR;
+  *optptr++ = 4;
+  memcpy(optptr, &ipaddr->s_addr, 4);
+  return optptr + 4;
+}
+
+static uint8_t *dhcpc_addreqoptions(uint8_t *optptr)
+{
+  *optptr++ = DHCP_OPTION_REQ_LIST;
+  *optptr++ = 3;
+  *optptr++ = DHCP_OPTION_SUBNET_MASK;
+  *optptr++ = DHCP_OPTION_ROUTER;
+  *optptr++ = DHCP_OPTION_DNS_SERVER;
+  return optptr;
+}
+
+static uint8_t *dhcpc_addend(uint8_t *optptr)
+{
+  *optptr++ = DHCP_OPTION_END;
+  return optptr;
+}
+
+/****************************************************************************
+ * Name: dhcpc_sendmsg
+ ****************************************************************************/
+
+static int dhcpc_sendmsg(struct dhcpc_state_s *pdhcpc,
+                         struct dhcpc_state *presult, int msgtype)
+{
+  struct sockaddr_in addr;
+  uint8_t *pend;
+  in_addr_t serverid = INADDR_BROADCAST;
+  int len;
+
+  /* Create the common message header settings */
+
+  memset(&pdhcpc->packet, 0, sizeof(struct dhcp_msg));
+  pdhcpc->packet.op    = DHCP_REQUEST;
+  pdhcpc->packet.htype = DHCP_HTYPE_ETHERNET;
+  pdhcpc->packet.hlen  = pdhcpc->ds_maclen;
+  memcpy(pdhcpc->packet.xid, xid, 4);
+  memcpy(pdhcpc->packet.chaddr, pdhcpc->ds_macaddr, pdhcpc->ds_maclen);
+  memset(&pdhcpc->packet.chaddr[pdhcpc->ds_maclen], 0, 16 - pdhcpc->ds_maclen);
+  memcpy(pdhcpc->packet.options, magic_cookie, sizeof(magic_cookie));
+
+  /* Add the common header options */
+
+  pend = &pdhcpc->packet.options[4];
+  pend = dhcpc_addmsgtype(pend, msgtype);
+
+  /* Handle the message specific settings */
+
+  switch (msgtype)
+    {
+      /* Broadcast DISCOVER message to all servers */
+
+      case DHCPDISCOVER:
+        pdhcpc->packet.flags = HTONS(BOOTP_BROADCAST); /*  Broadcast bit. */
+        pend     = dhcpc_addreqoptions(pend);
+        break;
+
+      /* Send REQUEST message to the server that sent the *first* OFFER */
+
+      case DHCPREQUEST:
+        pdhcpc->packet.flags = HTONS(BOOTP_BROADCAST); /*  Broadcast bit. */
+        memcpy(pdhcpc->packet.ciaddr, &pdhcpc->ipaddr.s_addr, 4);
+        pend     = dhcpc_addserverid(&pdhcpc->serverid, pend);
+        pend     = dhcpc_addreqipaddr(&pdhcpc->ipaddr, pend);
+        break;
+
+      /* Send DECLINE message to the server that sent the *last* OFFER */
+
+      case DHCPDECLINE:
+        memcpy(pdhcpc->packet.ciaddr, &presult->ipaddr.s_addr, 4);
+        pend     = dhcpc_addserverid(&presult->serverid, pend);
+        serverid = presult->serverid.s_addr;
+        break;
+
+      default:
+        return ERROR;
+    }
+
+  pend = dhcpc_addend(pend);
+  len  = pend - (uint8_t*)&pdhcpc->packet;
+
+  /* Send the request */
+
+  addr.sin_family      = AF_INET;
+  addr.sin_port        = HTONS(DHCPC_SERVER_PORT);
+  addr.sin_addr.s_addr = serverid;
+
+  return sendto(pdhcpc->sockfd, &pdhcpc->packet, len, 0,
+                (struct sockaddr*)&addr, sizeof(struct sockaddr_in));
+}
+
+/****************************************************************************
+ * Name: dhcpc_parseoptions
+ ****************************************************************************/
+
+static uint8_t dhcpc_parseoptions(struct dhcpc_state *presult, uint8_t *optptr, int len)
+{
+  uint8_t *end = optptr + len;
+  uint8_t type = 0;
+
+  while (optptr < end)
+    {
+      switch(*optptr)
+        {
+          case DHCP_OPTION_SUBNET_MASK:
+            /* Get subnet mask in network order */
+
+            memcpy(&presult->netmask.s_addr, optptr + 2, 4);
+            break;
+
+          case DHCP_OPTION_ROUTER:
+            /* Get the default router address in network order */
+
+            memcpy(&presult->default_router.s_addr, optptr + 2, 4);
+            break;
+
+          case DHCP_OPTION_DNS_SERVER:
+            /* Get the DNS server address in network order */
+
+            memcpy(&presult->dnsaddr.s_addr, optptr + 2, 4);
+            break;
+
+          case DHCP_OPTION_MSG_TYPE:
+            /* Get message type */
+
+            type = *(optptr + 2);
+            break;
+
+          case DHCP_OPTION_SERVER_ID:
+            /* Get server address in network order */
+
+            memcpy(&presult->serverid.s_addr, optptr + 2, 4);
+            break;
+
+          case DHCP_OPTION_LEASE_TIME:
+            {
+              /* Get lease time (in seconds) in host order */
+
+              uint16_t tmp[2];
+              memcpy(tmp, optptr + 2, 4);
+              presult->lease_time = ((uint32_t)ntohs(tmp[0])) << 16 | (uint32_t)ntohs(tmp[1]);
+            }
+            break;
+
+          case DHCP_OPTION_END:
+            return type;
+        }
+
+      optptr += optptr[1] + 2;
+    }
+  return type;
+}
+
+/****************************************************************************
+ * Name: dhcpc_parsemsg
+ ****************************************************************************/
+
+static uint8_t dhcpc_parsemsg(struct dhcpc_state_s *pdhcpc, int buflen,
+                            struct dhcpc_state *presult)
+{
+  if (pdhcpc->packet.op == DHCP_REPLY &&
+      memcmp(pdhcpc->packet.xid, xid, sizeof(xid)) == 0 &&
+      memcmp(pdhcpc->packet.chaddr, pdhcpc->ds_macaddr, pdhcpc->ds_maclen) == 0)
+    {
+      memcpy(&presult->ipaddr.s_addr, pdhcpc->packet.yiaddr, 4);
+      return dhcpc_parseoptions(presult, &pdhcpc->packet.options[4], buflen);
+    }
+  return 0;
+}
+
+/****************************************************************************
+ * Global Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: dhcpc_open
+ ****************************************************************************/
+
+void *dhcpc_open(const void *macaddr, int maclen)
+{
+  struct dhcpc_state_s *pdhcpc;
+  struct sockaddr_in addr;
+  struct timeval tv;
+
+  dbg("MAC: %02x:%02x:%02x:%02x:%02x:%02x\n",
+      ((uint8_t*)macaddr)[0], ((uint8_t*)macaddr)[1], ((uint8_t*)macaddr)[2],
+      ((uint8_t*)macaddr)[3], ((uint8_t*)macaddr)[4], ((uint8_t*)macaddr)[5]);
+
+  /* Allocate an internal DHCP structure */
+
+  pdhcpc = (struct dhcpc_state_s *)malloc(sizeof(struct dhcpc_state_s));
+  if (pdhcpc)
+    {
+      /* Initialize the allocated structure */
+
+      memset(pdhcpc, 0, sizeof(struct dhcpc_state_s));
+      pdhcpc->ds_macaddr = macaddr;
+      pdhcpc->ds_maclen  = maclen;
+
+      /* Create a UDP socket */
+
+      pdhcpc->sockfd    = socket(PF_INET, SOCK_DGRAM, 0);
+      if (pdhcpc->sockfd < 0)
+        {
+          free(pdhcpc);
+          return NULL;
+        }
+
+      /* bind the socket */
+
+      addr.sin_family      = AF_INET;
+      addr.sin_port        = HTONS(DHCPC_CLIENT_PORT);
+      addr.sin_addr.s_addr = INADDR_ANY;
+
+      if (bind(pdhcpc->sockfd, (struct sockaddr*)&addr, sizeof(struct sockaddr_in)) < 0)
+        {
+          close(pdhcpc->sockfd);
+          free(pdhcpc);
+          return NULL;
+        }
+
+      /* Configure for read timeouts */
+
+      tv.tv_sec  = 10;
+      tv.tv_usec = 0;
+      if (setsockopt(pdhcpc->sockfd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(struct timeval)) < 0)
+        {
+          close(pdhcpc->sockfd);
+          free(pdhcpc);
+          return NULL;
+        }
+    }
+
+  return (void*)pdhcpc;
+}
+
+/****************************************************************************
+ * Name: dhcpc_close
+ ****************************************************************************/
+
+void dhcpc_close(void *handle)
+{
+  struct dchcpc_state_internal *pdhcpc = (struct dchcpc_state_internal *)handle;
+  if (pdhcpc)
+    {
+      free(pdhcpc);
+    }
+}
+
+/****************************************************************************
+ * Name: dhcpc_request
+ ****************************************************************************/
+
+int dhcpc_request(void *handle, struct dhcpc_state *presult)
+{
+  struct dhcpc_state_s *pdhcpc = (struct dhcpc_state_s *)handle;
+  struct in_addr oldaddr;
+  struct in_addr newaddr;
+  ssize_t result;
+  uint8_t msgtype;
+  int     retries;
+  int     state;
+
+  /* Save the currently assigned IP address (should be INADDR_ANY) */
+
+  oldaddr.s_addr = 0;
+  uip_gethostaddr("eth0", &oldaddr);
+
+  /* Loop until we receive the lease (or an error occurs) */
+
+  do
+    {
+      /* Set the IP address to INADDR_ANY. */
+
+      newaddr.s_addr = INADDR_ANY;
+      (void)uip_sethostaddr("eth0", &newaddr);
+
+      /* Loop sending DISCOVER until we receive an OFFER from a DHCP
+       * server.  We will lock on to the first OFFER and decline any
+       * subsequent offers (which will happen if there are more than one
+       * DHCP servers on the network.
+       */
+
+      state = STATE_INITIAL;
+      do
+        {
+          /* Send the DISCOVER command */
+
+          dbg("Broadcast DISCOVER\n");
+          if (dhcpc_sendmsg(pdhcpc, presult, DHCPDISCOVER) < 0)
+            {
+              return ERROR;
+            }
+
+          /* Get the DHCPOFFER response */
+
+          result = recv(pdhcpc->sockfd, &pdhcpc->packet, sizeof(struct dhcp_msg), 0);
+          if (result >= 0)
+            {
+              msgtype = dhcpc_parsemsg(pdhcpc, result, presult);
+              if (msgtype == DHCPOFFER)
+                {
+                  /* Save the servid from the presult so that it is not clobbered
+                   * by a new OFFER.
+                   */
+
+                  dbg("Received OFFER from %08x\n", ntohl(presult->serverid.s_addr));
+                  pdhcpc->ipaddr.s_addr   = presult->ipaddr.s_addr;
+                  pdhcpc->serverid.s_addr = presult->serverid.s_addr;
+
+                  /* Temporarily use the address offered by the server and break
+                   * out of the loop.
+                   */
+
+                  (void)uip_sethostaddr("eth0", &presult->ipaddr);
+                  state = STATE_HAVE_OFFER;
+                }
+            }
+
+          /* An error has occurred.  If this was a timeout error (meaning that
+           * nothing was received on this socket for a long period of time).
+           * Then loop and send the DISCOVER command again.
+           */
+
+          else if (*get_errno_ptr() != EAGAIN)
+            {
+              /* An error other than a timeout was received -- error out */
+
+              return ERROR;
+            }
+        }
+      while (state == STATE_INITIAL);
+
+
+      /* Loop sending the REQUEST up to three times (if there is no response) */
+
+      retries = 0;
+      do
+        {
+          /* Send the REQUEST message to obtain the lease that was offered to us. */
+
+          dbg("Send REQUEST\n");
+          if (dhcpc_sendmsg(pdhcpc, presult, DHCPREQUEST) < 0)
+            {
+              return ERROR;
+            }
+          retries++;
+
+          /* Get the ACK/NAK response to the REQUEST (or timeout) */
+
+          result = recv(pdhcpc->sockfd, &pdhcpc->packet, sizeof(struct dhcp_msg), 0);
+          if (result >= 0)
+            {
+              /* Parse the response */
+
+              msgtype = dhcpc_parsemsg(pdhcpc, result, presult);
+
+              /* The ACK response means that the server has accepted our request
+               * and we have the lease.
+               */
+
+              if (msgtype == DHCPACK)
+                {
+                  dbg("Received ACK\n");
+                  state = STATE_HAVE_LEASE;
+                }
+
+              /* NAK means the server has refused our request.  Break out of
+               * this loop with state == STATE_HAVE_OFFER and send DISCOVER again
+               */
+
+              else if (msgtype == DHCPNAK)
+                {
+                  dbg("Received NAK\n");
+                  break;
+                }
+
+              /* If we get any OFFERs from other servers, then decline them now
+               * and continue waiting for the ACK from the server that we
+               * requested from.
+               */
+
+              else if (msgtype == DHCPOFFER)
+                {
+                  dbg("Received another OFFER, send DECLINE\n");
+                  (void)dhcpc_sendmsg(pdhcpc, presult, DHCPDECLINE);
+                }
+
+              /* Otherwise, it is something that we do not recognize */
+
+              else
+                {
+                  dbg("Ignoring msgtype=%d\n", msgtype);
+                }
+            }
+
+          /* An error has occurred.  If this was a timeout error (meaning
+           * that nothing was received on this socket for a long period of time).
+           * Then break out and send the DISCOVER command again (at most
+           * 3 times).
+           */
+
+          else if (*get_errno_ptr() != EAGAIN)
+            {
+              /* An error other than a timeout was received */
+
+              (void)uip_sethostaddr("eth0", &oldaddr);
+              return ERROR;
+            }
+        }
+      while (state == STATE_HAVE_OFFER && retries < 3);
+    }
+  while (state != STATE_HAVE_LEASE);
+
+  dbg("Got IP address %d.%d.%d.%d\n",
+      (presult->ipaddr.s_addr >> 24 ) & 0xff,
+      (presult->ipaddr.s_addr >> 16 ) & 0xff,
+      (presult->ipaddr.s_addr >> 8  ) & 0xff,
+      (presult->ipaddr.s_addr       ) & 0xff);
+  dbg("Got netmask %d.%d.%d.%d\n",
+      (presult->netmask.s_addr >> 24 ) & 0xff,
+      (presult->netmask.s_addr >> 16 ) & 0xff,
+      (presult->netmask.s_addr >> 8  ) & 0xff,
+      (presult->netmask.s_addr       ) & 0xff);
+  dbg("Got DNS server %d.%d.%d.%d\n",
+      (presult->dnsaddr.s_addr >> 24 ) & 0xff,
+      (presult->dnsaddr.s_addr >> 16 ) & 0xff,
+      (presult->dnsaddr.s_addr >> 8  ) & 0xff,
+      (presult->dnsaddr.s_addr       ) & 0xff);
+  dbg("Got default router %d.%d.%d.%d\n",
+      (presult->default_router.s_addr >> 24 ) & 0xff,
+      (presult->default_router.s_addr >> 16 ) & 0xff,
+      (presult->default_router.s_addr >> 8  ) & 0xff,
+      (presult->default_router.s_addr       ) & 0xff);
+  dbg("Lease expires in %d seconds\n", presult->lease_time);
+  return OK;
+}

netutils/dhcpd/Makefile

@@ -0,0 +1,94 @@
+############################################################################
+# apps/netutils/dhcpd/Makefile
+#
+#   Copyright (C) 2011 Gregory Nutt. All rights reserved.
+#   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+#
+# 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.
+#
+############################################################################
+
+-include $(TOPDIR)/.config
+-include $(TOPDIR)/Make.defs
+include $(APPDIR)/Make.defs
+
+# DHCP Daemn Library
+
+ASRCS		=
+CSRCS		= 
+
+ifeq ($(CONFIG_NET_UDP),y)
+CSRCS		+= dhcpd.c
+endif
+
+AOBJS		= $(ASRCS:.S=$(OBJEXT))
+COBJS		= $(CSRCS:.c=$(OBJEXT))
+
+SRCS		= $(ASRCS) $(CSRCS)
+OBJS		= $(AOBJS) $(COBJS)
+
+BIN	    	= ../../libapps$(LIBEXT)
+
+ROOTDEPPATH	= --dep-path .
+
+# Common build
+
+VPATH		= 
+
+all: .built
+
+$(AOBJS): %$(OBJEXT): %.S
+	$(call ASSEMBLE, $<, $@)
+
+$(COBJS): %$(OBJEXT): %.c
+	$(call COMPILE, $<, $@)
+
+$(BIN):	$(OBJS)
+	@( for obj in $(OBJS) ; do \
+		$(call ARCHIVE, $@, $${obj}); \
+	done ; )
+	@touch .built
+	
+.built: $(BIN)
+
+.depend: Makefile $(SRCS)
+	@$(MKDEP) $(ROOTDEPPATH) \
+	  $(CC) -- $(CFLAGS) -- $(SRCS) >Make.dep
+	@touch $@
+
+# Register application
+depend: .depend
+
+clean:
+	@rm -f $(BIN) *.o *~ .*.swp .built
+	$(call CLEAN)
+
+distclean: clean
+	@rm -f Make.dep .depend
+
+-include Make.dep

netutils/resolv/Makefile

@@ -0,0 +1,94 @@
+############################################################################
+# apps/netutils/resolv/Makefile
+#
+#   Copyright (C) 2011 Gregory Nutt. All rights reserved.
+#   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+#
+# 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.
+#
+############################################################################
+
+-include $(TOPDIR)/.config
+-include $(TOPDIR)/Make.defs
+include $(APPDIR)/Make.defs
+
+# Resolver library
+
+ASRCS		=
+CSRCS		= 
+
+ifeq ($(CONFIG_NET_UDP),y)
+CSRCS		= resolv.c
+endif
+
+AOBJS		= $(ASRCS:.S=$(OBJEXT))
+COBJS		= $(CSRCS:.c=$(OBJEXT))
+
+SRCS		= $(ASRCS) $(CSRCS)
+OBJS		= $(AOBJS) $(COBJS)
+
+BIN	    	= ../../libapps$(LIBEXT)
+
+ROOTDEPPATH	= --dep-path .
+
+# Common build
+
+VPATH		= 
+
+all: .built
+
+$(AOBJS): %$(OBJEXT): %.S
+	$(call ASSEMBLE, $<, $@)
+
+$(COBJS): %$(OBJEXT): %.c
+	$(call COMPILE, $<, $@)
+
+$(BIN):	$(OBJS)
+	@( for obj in $(OBJS) ; do \
+		$(call ARCHIVE, $@, $${obj}); \
+	done ; )
+	@touch .built
+	
+.built: $(BIN)
+
+.depend: Makefile $(SRCS)
+	@$(MKDEP) $(ROOTDEPPATH) \
+	  $(CC) -- $(CFLAGS) -- $(SRCS) >Make.dep
+	@touch $@
+
+# Register application
+depend: .depend
+
+clean:
+	@rm -f $(BIN) *.o *~ .*.swp .built
+	$(call CLEAN)
+
+distclean: clean
+	@rm -f Make.dep .depend
+
+-include Make.dep

netutils/resolv/resolv.c

@@ -0,0 +1,440 @@
+/****************************************************************************
+ * uip-resolv.c
+ * DNS host name to IP address resolver.
+ *
+ * The uIP DNS resolver functions are used to lookup a hostname and
+ * map it to a numerical IP address. It maintains a list of resolved
+ * hostnames that can be queried with the resolv_lookup()
+ * function. New hostnames can be resolved using the resolv_query()
+ * function.
+ *
+ * When a hostname has been resolved (or found to be non-existant),
+ * the resolver code calls a callback function called resolv_found()
+ * that must be implemented by the module that uses the resolver.
+ *
+ *   Copyright (C) 2007, 2009 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * Based heavily on portions of uIP:
+ *
+ *   Author: Adam Dunkels <adam@dunkels.com>
+ *   Copyright (c) 2002-2003, Adam Dunkels.
+ *   All rights reserved.
+ *
+ * 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. The name of the author may not be used to endorse or promote
+ *    products derived from this software without specific prior
+ *    written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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>
+
+#include <stdint.h>
+#include <string.h>
+#include <unistd.h>
+#include <time.h>
+#include <errno.h>
+#include <debug.h>
+
+#include <sys/socket.h>
+#include <arpa/inet.h>
+
+#include <apps/netutils/resolv.h>
+
+/****************************************************************************
+ * Definitions
+ ****************************************************************************/
+
+#ifndef CONFIG_NET_RESOLV_ENTRIES
+#define RESOLV_ENTRIES 4
+#else /* CONFIG_NET_RESOLV_ENTRIES */
+#define RESOLV_ENTRIES CONFIG_NET_RESOLV_ENTRIES
+#endif /* CONFIG_NET_RESOLV_ENTRIES */
+
+#ifndef NULL
+#define NULL (void *)0
+#endif /* NULL */
+
+/* The maximum number of retries when asking for a name */
+
+#define MAX_RETRIES 8
+
+#define DNS_FLAG1_RESPONSE        0x80
+#define DNS_FLAG1_OPCODE_STATUS   0x10
+#define DNS_FLAG1_OPCODE_INVERSE  0x08
+#define DNS_FLAG1_OPCODE_STANDARD 0x00
+#define DNS_FLAG1_AUTHORATIVE     0x04
+#define DNS_FLAG1_TRUNC           0x02
+#define DNS_FLAG1_RD              0x01
+#define DNS_FLAG2_RA              0x80
+#define DNS_FLAG2_ERR_MASK        0x0f
+#define DNS_FLAG2_ERR_NONE        0x00
+#define DNS_FLAG2_ERR_NAME        0x03
+
+#define SEND_BUFFER_SIZE 64
+#define RECV_BUFFER_SIZE 64
+
+#ifdef CONFIG_NET_IPv6
+#define ADDRLEN sizeof(struct sockaddr_in6)
+#else
+#define ADDRLEN sizeof(struct sockaddr_in)
+#endif
+
+/****************************************************************************
+ * Private Types
+ ****************************************************************************/
+
+/* The DNS message header */
+
+struct dns_hdr
+{
+  uint16_t id;
+  uint8_t  flags1, flags2;
+  uint16_t numquestions;
+  uint16_t numanswers;
+  uint16_t numauthrr;
+  uint16_t numextrarr;
+};
+
+/* The DNS answer message structure */
+
+struct dns_answer
+{
+  /* DNS answer record starts with either a domain name or a pointer
+   * to a name already present somewhere in the packet.
+   */
+
+  uint16_t type;
+  uint16_t class;
+  uint16_t ttl[2];
+  uint16_t len;
+#ifdef CONFIG_NET_IPv6
+  struct in6_addr ipaddr;
+#else
+  struct in_addr ipaddr;
+#endif
+};
+
+struct namemap
+{
+  uint8_t state;
+  uint8_t tmr;
+  uint8_t retries;
+  uint8_t seqno;
+  uint8_t err;
+  char name[32];
+#ifdef CONFIG_NET_IPv6
+  struct in6_addr ipaddr;
+#else
+  struct in_addr ipaddr;
+#endif
+};
+
+/****************************************************************************
+ * Private Data
+ ****************************************************************************/
+
+static uint8_t g_seqno;
+static int g_sockfd = -1;
+#ifdef CONFIG_NET_IPv6
+static struct sockaddr_in6 g_dnsserver;
+#else
+static struct sockaddr_in g_dnsserver;
+#endif
+
+/****************************************************************************
+ * Private Functions
+ ****************************************************************************/
+
+/* Walk through a compact encoded DNS name and return the end of it. */
+
+static unsigned char *parse_name(unsigned char *query)
+{
+  unsigned char n;
+
+  do
+    {
+      n = *query++;
+
+      while(n > 0)
+        {
+          ++query;
+          --n;
+        }
+    }
+  while(*query != 0);
+  return query + 1;
+}
+
+/* Runs through the list of names to see if there are any that have
+ * not yet been queried and, if so, sends out a query.
+ */
+
+#ifdef CONFIG_NET_IPv6
+static int send_query(const char *name, struct sockaddr_in6 *addr)
+#else
+static int send_query(const char *name, struct sockaddr_in *addr)
+#endif
+{
+  register struct dns_hdr *hdr;
+  char *query;
+  char *nptr;
+  const char *nameptr;
+  uint8_t seqno = g_seqno++;
+  static unsigned char endquery[] = {0, 0, 1, 0, 1};
+  char buffer[SEND_BUFFER_SIZE];
+  int n;
+
+  hdr               = (struct dns_hdr*)buffer;
+  memset(hdr, 0, sizeof(struct dns_hdr));
+  hdr->id           = htons(seqno);
+  hdr->flags1       = DNS_FLAG1_RD;
+  hdr->numquestions = HTONS(1);
+  query             = buffer + 12;
+
+  /* Convert hostname into suitable query format. */
+
+  nameptr = name - 1;
+  do
+   {
+     nameptr++;
+     nptr = query++;
+     for (n = 0; *nameptr != '.' && *nameptr != 0; nameptr++)
+       {
+         *query++ = *nameptr;
+         n++;
+       }
+     *nptr = n;
+   }
+  while(*nameptr != 0);
+
+  memcpy(query, endquery, 5);
+  return sendto(g_sockfd, buffer, query + 5 - buffer, 0, (struct sockaddr*)addr, ADDRLEN);
+}
+
+/* Called when new UDP data arrives */
+
+#ifdef CONFIG_NET_IPv6
+#error "Not implemented"
+#else
+int recv_response(struct sockaddr_in *addr)
+#endif
+{
+  unsigned char *nameptr;
+  char buffer[RECV_BUFFER_SIZE];
+  struct dns_answer *ans;
+  struct dns_hdr *hdr;
+  uint8_t nquestions;
+  uint8_t nanswers;
+  int ret;
+
+  /* Receive the response */
+
+  ret = recv(g_sockfd, buffer, RECV_BUFFER_SIZE, 0);
+  if (ret < 0)
+    {
+      return ret;
+    }
+
+  hdr = (struct dns_hdr *)buffer;
+
+  dbg( "ID %d\n", htons(hdr->id));
+  dbg( "Query %d\n", hdr->flags1 & DNS_FLAG1_RESPONSE);
+  dbg( "Error %d\n", hdr->flags2 & DNS_FLAG2_ERR_MASK);
+  dbg( "Num questions %d, answers %d, authrr %d, extrarr %d\n",
+       htons(hdr->numquestions), htons(hdr->numanswers),
+       htons(hdr->numauthrr), htons(hdr->numextrarr));
+
+  /* Check for error. If so, call callback to inform */
+
+  if ((hdr->flags2 & DNS_FLAG2_ERR_MASK) != 0)
+    {
+      return ERROR;
+    }
+
+  /* We only care about the question(s) and the answers. The authrr
+   * and the extrarr are simply discarded.
+   */
+
+  nquestions = htons(hdr->numquestions);
+  nanswers   = htons(hdr->numanswers);
+
+  /* Skip the name in the question. XXX: This should really be
+   * checked agains the name in the question, to be sure that they
+   * match.
+    */
+
+  nameptr = parse_name((unsigned char *)buffer + 12) + 4;
+
+  for (; nanswers > 0; nanswers--)
+    {
+      /* The first byte in the answer resource record determines if it
+       * is a compressed record or a normal one.
+       */
+
+      if (*nameptr & 0xc0)
+        {
+          /* Compressed name. */
+
+          nameptr +=2;
+          dbg("Compressed anwser\n");
+        }
+      else
+        {
+          /* Not compressed name. */
+          nameptr = parse_name(nameptr);
+        }
+
+      ans = (struct dns_answer *)nameptr;
+      dbg("Answer: type %x, class %x, ttl %x, length %x\n",
+          htons(ans->type), htons(ans->class), (htons(ans->ttl[0]) << 16) | htons(ans->ttl[1]),
+          htons(ans->len));
+
+      /* Check for IP address type and Internet class. Others are discarded. */
+
+      if (ans->type == HTONS(1) && ans->class == HTONS(1) && ans->len == HTONS(4))
+        {
+          dbg("IP address %d.%d.%d.%d\n",
+              (ans->ipaddr.s_addr >> 24 ) & 0xff,
+              (ans->ipaddr.s_addr >> 16 ) & 0xff,
+              (ans->ipaddr.s_addr >> 8  ) & 0xff,
+              (ans->ipaddr.s_addr       ) & 0xff);
+
+           /* XXX: we should really check that this IP address is the one
+           * we want.
+           */
+
+          addr->sin_addr.s_addr = ans->ipaddr.s_addr;
+          return OK;
+        }
+      else
+        {
+          nameptr = nameptr + 10 + htons(ans->len);
+        }
+    }
+  return ERROR;
+}
+
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
+
+/* Get the binding for name. */
+
+#ifdef CONFIG_NET_IPv6
+int resolv_query(FAR const char *name, FAR struct sockaddr_in6 *addr)
+#else
+int resolv_query(FAR const char *name, FAR struct sockaddr_in *addr)
+#endif
+{
+  int retries;
+  int ret;
+
+  /* Loop while receive timeout errors occur and there are remaining retries */
+
+  for (retries = 0; retries < 3; retries++)
+    {
+      if (send_query(name, addr) < 0)
+        {
+          return ERROR;
+        }
+
+      ret = recv_response(addr);
+      if (ret >= 0)
+        {
+          /* Response received successfully */
+
+          return OK;
+        }
+
+      else if (errno != EAGAIN)
+        {
+          /* Some failure other than receive timeout occurred */
+
+          return ERROR;
+        }
+    }
+
+  return ERROR;
+}
+
+/* Obtain the currently configured DNS server. */
+
+#ifdef CONFIG_NET_IPv6
+void resolv_getserver(struct in6_addr *dnsserver)
+#else
+void resolv_getserver(struct in_addr *dnsserver)
+#endif
+{
+#ifdef CONFIG_NET_IPv6
+  memcpy(dnsserver, &g_dnsserver.sin6_addr, ADDRLEN);
+#else
+  dnsserver->s_addr = g_dnsserver.sin_addr.s_addr;
+#endif
+}
+
+/* Configure which DNS server to use for queries */
+
+#ifdef CONFIG_NET_IPv6
+void resolv_conf(const struct in6_addr *dnsserver)
+#else
+void resolv_conf(const struct in_addr *dnsserver)
+#endif
+{
+  g_dnsserver.sin_family = AF_INET;
+  g_dnsserver.sin_port   = HTONS(53);
+#ifdef CONFIG_NET_IPv6
+  memcpy(&g_dnsserver.sin6_addr, dnsserver, ADDRLEN);
+#else
+  g_dnsserver.sin_addr.s_addr = dnsserver->s_addr;
+#endif
+}
+
+/* Initalize the resolver. */
+
+int resolv_init(void)
+{
+  struct timeval tv;
+  g_sockfd = socket(PF_INET, SOCK_DGRAM, 0);
+  if (g_sockfd < 0)
+    {
+      return ERROR;
+    }
+
+  /* Set up a receive timeout */
+
+  tv.tv_sec  = 30;
+  tv.tv_usec = 0;
+  if (setsockopt(g_sockfd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(struct timeval)) < 0)
+    {
+      close(g_sockfd);
+      g_sockfd = -1;
+      return ERROR;
+    }
+
+  return OK;
+}

netutils/smtp/Makefile

@@ -0,0 +1,94 @@
+############################################################################
+# apps/netutils/smtp/Makefile
+#
+#   Copyright (C) 2011 Gregory Nutt. All rights reserved.
+#   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+#
+# 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.
+#
+############################################################################
+
+-include $(TOPDIR)/.config
+-include $(TOPDIR)/Make.defs
+include $(APPDIR)/Make.defs
+
+# SMTP Library
+
+ASRCS		=
+CSRCS		= 
+
+ifeq ($(CONFIG_NET_TCP),y)
+CSRCS		+= smtp.c
+endif
+
+AOBJS		= $(ASRCS:.S=$(OBJEXT))
+COBJS		= $(CSRCS:.c=$(OBJEXT))
+
+SRCS		= $(ASRCS) $(CSRCS)
+OBJS		= $(AOBJS) $(COBJS)
+
+BIN	    	= ../../libapps$(LIBEXT)
+
+ROOTDEPPATH	= --dep-path .
+
+# Common build
+
+VPATH		= 
+
+all: .built
+
+$(AOBJS): %$(OBJEXT): %.S
+	$(call ASSEMBLE, $<, $@)
+
+$(COBJS): %$(OBJEXT): %.c
+	$(call COMPILE, $<, $@)
+
+$(BIN):	$(OBJS)
+	@( for obj in $(OBJS) ; do \
+		$(call ARCHIVE, $@, $${obj}); \
+	done ; )
+	@touch .built
+	
+.built: $(BIN)
+
+.depend: Makefile $(SRCS)
+	@$(MKDEP) $(ROOTDEPPATH) \
+	  $(CC) -- $(CFLAGS) -- $(SRCS) >Make.dep
+	@touch $@
+
+# Register application
+depend: .depend
+
+clean:
+	@rm -f $(BIN) *.o *~ .*.swp .built
+	$(call CLEAN)
+
+distclean: clean
+	@rm -f Make.dep .depend
+
+-include Make.dep

netutils/smtp/smtp.c

@@ -0,0 +1,376 @@
+/****************************************************************************
+ * apps/netutitls/smtp/smtp.c
+ * smtp SMTP E-mail sender
+ *
+ *   Copyright (C) 2007, 2009, 2011 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * Heavily leveraged from uIP 1.0 which also has a BSD-like license:
+ *
+ * The Simple Mail Transfer Protocol (SMTP) as defined by RFC821 is
+ * the standard way of sending and transfering e-mail on the
+ * Internet. This simple example implementation is intended as an
+ * example of how to implement protocols in uIP, and is able to send
+ * out e-mail but has not been extensively tested.
+ *
+ *   Author: Adam Dunkels <adam@dunkels.com>
+ *   Copyright (c) 2004, Adam Dunkels.
+ *   All rights reserved.
+ *
+ * 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 of the Institute 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 INSTITUTE 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 INSTITUTE 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>
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <semaphore.h>
+#include <sys/socket.h>
+
+#include <net/uip/uip.h>
+#include <apps/netutils/smtp.h>
+
+/****************************************************************************
+ * Definitions
+ ****************************************************************************/
+
+#define SMTP_INPUT_BUFFER_SIZE 512
+
+#define ISO_nl 0x0a
+#define ISO_cr 0x0d
+
+#define ISO_period 0x2e
+
+#define ISO_2  0x32
+#define ISO_3  0x33
+#define ISO_4  0x34
+#define ISO_5  0x35
+
+/****************************************************************************
+ * Private Types
+ ****************************************************************************/
+
+/* This structure represents the state of a single SMTP transaction */
+
+struct smtp_state
+{
+  uint8_t      state;
+  bool         connected;
+  sem_t        sem;
+  uip_ipaddr_t smtpserver;
+  const char  *localhostname;
+  const char  *to;
+  const char  *cc;
+  const char  *from;
+  const char  *subject;
+  const char  *msg;
+  int          msglen;
+  int          sentlen;
+  int          textlen;
+  int          sendptr;
+  char         buffer[SMTP_INPUT_BUFFER_SIZE];
+};
+
+/****************************************************************************
+ * Private Data
+ ****************************************************************************/
+
+static const char g_smtp220[]            = "220";
+static const char g_smtpcrnlperiodcrnl[] = "\r\n.\r\n";
+static const char g_smtpdata[]           = "DATA\r\n";
+static const char g_smtpfrom[]           = "From: ";
+static const char g_smtphelo[]           = "HELO ";
+static const char g_smtpmailfrom[]       = "MAIL FROM: ";
+static const char g_smtpquit[]           = "QUIT\r\n";
+static const char g_smtprcptto[]         = "RCPT TO: ";
+static const char g_smtpsubject[]        = "Subject: ";
+static const char g_smtpto[]             = "To: ";
+
+/****************************************************************************
+ * Private Functions
+ ****************************************************************************/
+
+static inline int smtp_send_message(int sockfd, struct smtp_state *psmtp)
+{
+  if (recv(sockfd, psmtp->buffer, SMTP_INPUT_BUFFER_SIZE, 0) < 0)
+    {
+      return ERROR;
+    }
+
+  if (strncmp(psmtp->buffer, g_smtp220, strlen(g_smtp220)) != 0)
+    {
+      return ERROR;
+    }
+
+  snprintf(psmtp->buffer, SMTP_INPUT_BUFFER_SIZE, "%s%s\r\n", g_smtphelo, psmtp->localhostname);
+  if (send(sockfd, psmtp->buffer, strlen(psmtp->buffer), 0) < 0)
+    {
+      return ERROR;
+    }
+
+  if (recv(sockfd, psmtp->buffer, SMTP_INPUT_BUFFER_SIZE, 0) < 0)
+    {
+      return ERROR;
+    }
+
+  if (psmtp->buffer[0] != ISO_2)
+    {
+      return ERROR;
+    }
+
+  snprintf(psmtp->buffer, SMTP_INPUT_BUFFER_SIZE, "%s%s\r\n", g_smtpmailfrom, psmtp->from);
+  if (send(sockfd, psmtp->buffer, strlen(psmtp->buffer), 0) < 0)
+    {
+      return ERROR;
+    }
+
+  if (recv(sockfd, psmtp->buffer, SMTP_INPUT_BUFFER_SIZE, 0) < 0)
+    {
+      return ERROR;
+    }
+
+  if (psmtp->buffer[0] != ISO_2)
+    {
+      return ERROR;
+    }
+
+  snprintf(psmtp->buffer, SMTP_INPUT_BUFFER_SIZE, "%s%s\r\n", g_smtprcptto, psmtp->to);
+  if (send(sockfd, psmtp->buffer, strlen(psmtp->buffer), 0) < 0)
+    {
+      return ERROR;
+    }
+
+  if (recv(sockfd, psmtp->buffer, SMTP_INPUT_BUFFER_SIZE, 0) < 0)
+    {
+      return ERROR;
+    }
+
+  if (psmtp->buffer[0] != ISO_2)
+    {
+      return ERROR;
+    }
+
+  if (psmtp->cc != 0)
+    {
+      snprintf(psmtp->buffer, SMTP_INPUT_BUFFER_SIZE, "%s%s\r\n", g_smtprcptto, psmtp->cc);
+      if (send(sockfd, psmtp->buffer, strlen(psmtp->buffer), 0) < 0)
+        {
+          return ERROR;
+        }
+
+      if (recv(sockfd, psmtp->buffer, SMTP_INPUT_BUFFER_SIZE, 0) < 0)
+        {
+          return ERROR;
+        }
+
+      if (psmtp->buffer[0] != ISO_2)
+        {
+          return ERROR;
+        }
+    }
+
+  if (send(sockfd, g_smtpdata, strlen(g_smtpdata), 0) < 0)
+    {
+      return ERROR;
+    }
+
+  if (recv(sockfd, psmtp->buffer, SMTP_INPUT_BUFFER_SIZE, 0) < 0)
+    {
+      return ERROR;
+    }
+
+  if (psmtp->buffer[0] != ISO_3)
+    {
+      return ERROR;
+    }
+
+  snprintf(psmtp->buffer, SMTP_INPUT_BUFFER_SIZE, "%s%s\r\n", g_smtpto, psmtp->to);
+  if (send(sockfd, psmtp->buffer, strlen(psmtp->buffer), 0) < 0)
+    {
+      return ERROR;
+    }
+
+  if (psmtp->cc != 0)
+    {
+      snprintf(psmtp->buffer, SMTP_INPUT_BUFFER_SIZE, "%s%s\r\n", g_smtpto, psmtp->cc);
+      if (send(sockfd, psmtp->buffer, strlen(psmtp->buffer), 0) < 0)
+        {
+          return ERROR;
+        }
+    }
+
+  snprintf(psmtp->buffer, SMTP_INPUT_BUFFER_SIZE, "%s%s\r\n", g_smtpfrom, psmtp->from);
+  if (send(sockfd, psmtp->buffer, strlen(psmtp->buffer), 0) < 0)
+    {
+      return ERROR;
+    }
+
+  snprintf(psmtp->buffer, SMTP_INPUT_BUFFER_SIZE, "%s%s\r\n", g_smtpsubject, psmtp->subject);
+  if (send(sockfd, psmtp->buffer, strlen(psmtp->buffer), 0) < 0)
+    {
+      return ERROR;
+    }
+
+  if (send(sockfd, psmtp->msg, psmtp->msglen, 0) < 0)
+    {
+      return ERROR;
+    }
+
+  if (send(sockfd, g_smtpcrnlperiodcrnl, strlen(g_smtpcrnlperiodcrnl), 0) < 0)
+    {
+      return ERROR;
+    }
+
+  if (recv(sockfd, psmtp->buffer, SMTP_INPUT_BUFFER_SIZE, 0) < 0)
+    {
+      return ERROR;
+    }
+
+  if (psmtp->buffer[0] != ISO_2)
+    {
+      return ERROR;
+    }
+
+  if (send(sockfd, g_smtpquit, strlen(g_smtpquit), 0) < 0)
+    {
+      return ERROR;
+    }
+  return OK;
+}
+
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
+
+/* Specificy an SMTP server and hostname.
+ *
+ * This function is used to configure the SMTP module with an SMTP server and
+ * the hostname of the host.
+ *
+ *   lhostname - The hostname of the local, uIP host.
+ *
+ *   paddr     - A pointer to the IP address of the SMTP server to be
+ *               configured.
+ */
+
+void smtp_configure(void *handle, const char *lhostname,
+                    const uip_ipaddr_t *paddr)
+{
+  struct smtp_state *psmtp = (struct smtp_state *)handle;
+  psmtp->localhostname = lhostname;
+  uip_ipaddr_copy(psmtp->smtpserver, paddr);
+}
+
+/* Send an e-mail.
+ *
+ *   to      - The e-mail address of the receiver of the e-mail.
+ *   cc      - The e-mail address of the CC: receivers of the e-mail.
+ *   from    - The e-mail address of the sender of the e-mail.
+ *   subject - The subject of the e-mail.
+ *   msg     - The actual e-mail message.
+ *   msglen  - The length of the e-mail message.
+ */
+
+int smtp_send(void *handle, const char *to, const char *cc, const char *from,
+              const char *subject, const char *msg, int msglen)
+{
+  struct smtp_state *psmtp = (struct smtp_state *)handle;
+  struct sockaddr_in server;
+  int sockfd;
+  int ret;
+
+  /* Setup */
+
+  psmtp->connected = true;
+  psmtp->to        = to;
+  psmtp->cc        = cc;
+  psmtp->from      = from;
+  psmtp->subject   = subject;
+  psmtp->msg       = msg;
+  psmtp->msglen    = msglen;
+
+  /* Create a socket */
+
+  sockfd = socket(AF_INET, SOCK_STREAM, 0);
+  if (sockfd < 0)
+    {
+      return ERROR;
+    }
+
+  /* Connect to server.  First we have to set some fields in the
+   * 'server' structure.  The system will assign me an arbitrary
+   * local port that is not in use.
+   */
+
+  server.sin_family = AF_INET;
+  memcpy(&server.sin_addr.s_addr, &psmtp->smtpserver, sizeof(in_addr_t));
+  server.sin_port = HTONS(25);
+
+  if (connect(sockfd, (struct sockaddr *)&server, sizeof(struct sockaddr_in)) < 0)
+    {
+      close(sockfd);
+      return ERROR;
+    }
+
+  /* Send the message */
+
+  ret = smtp_send_message(sockfd, psmtp);
+
+  close(sockfd);
+  return ret;
+}
+
+void *smtp_open(void)
+{
+  /* Allocate the handle */
+
+  struct smtp_state *psmtp = (struct smtp_state *)malloc(sizeof(struct smtp_state));
+  if (psmtp)
+    {
+      /* Initialize the handle */
+
+      memset(psmtp, 0, sizeof(struct smtp_state));
+     (void)sem_init(&psmtp->sem, 0, 0);
+    }
+  return (void*)psmtp;
+}
+
+void smtp_close(void *handle)
+{
+  struct smtp_state *psmtp = (struct smtp_state *)handle;
+  if (psmtp)
+    {
+      sem_destroy(&psmtp->sem);
+      free(psmtp);
+    }
+}

netutils/telnetd/Makefile

@@ -0,0 +1,94 @@
+############################################################################
+# apps/netutils/telnetd/Makefile
+#
+#   Copyright (C) 2011 Gregory Nutt. All rights reserved.
+#   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+#
+# 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.
+#
+############################################################################
+
+-include $(TOPDIR)/.config
+-include $(TOPDIR)/Make.defs
+include $(APPDIR)/Make.defs
+
+# Telnet daemon
+
+ASRCS		=
+CSRCS		= 
+
+ifeq ($(CONFIG_NET_TCP),y)
+CSRCS		+= telnetd.c shell.c
+endif
+
+AOBJS		= $(ASRCS:.S=$(OBJEXT))
+COBJS		= $(CSRCS:.c=$(OBJEXT))
+
+SRCS		= $(ASRCS) $(CSRCS)
+OBJS		= $(AOBJS) $(COBJS)
+
+BIN	    	= ../../libapps$(LIBEXT)
+
+ROOTDEPPATH	= --dep-path .
+
+# Common build
+
+VPATH		= 
+
+all: .built
+
+$(AOBJS): %$(OBJEXT): %.S
+	$(call ASSEMBLE, $<, $@)
+
+$(COBJS): %$(OBJEXT): %.c
+	$(call COMPILE, $<, $@)
+
+$(BIN):	$(OBJS)
+	@( for obj in $(OBJS) ; do \
+		$(call ARCHIVE, $@, $${obj}); \
+	done ; )
+	@touch .built
+	
+.built: $(BIN)
+
+.depend: Makefile $(SRCS)
+	@$(MKDEP) $(ROOTDEPPATH) \
+	  $(CC) -- $(CFLAGS) -- $(SRCS) >Make.dep
+	@touch $@
+
+# Register application
+depend: .depend
+
+clean:
+	@rm -f $(BIN) *.o *~ .*.swp .built
+	$(call CLEAN)
+
+distclean: clean
+	@rm -f Make.dep .depend
+
+-include Make.dep

netutils/telnetd/README.txt

@@ -0,0 +1,7 @@
+This directory is here for historical reasons. Nothing contained in this
+directory is currently used by NuttX.  This directly contains a functional
+port of the tiny uIP shell.  In the NuttX environment, the NuttShell (at
+apps/nshlib) supercedes this tiny shell and also supports telnetd.
+
+This example is retained here for reference purposes only.
+

netutils/telnetd/shell.c

@@ -0,0 +1,139 @@
+/****************************************************************************
+ * netutils/telnetd/telnetd.c
+ *
+ *   Copyright (C) 2007 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * This is a leverage of similar logic from uIP:
+ *
+ *   Author: Adam Dunkels <adam@sics.se>
+ *   Copyright (c) 2003, Adam Dunkels.
+ *   All rights reserved.
+ *
+ * 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 of the Institute 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 INSTITUTE 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 INSTITUTE 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 <string.h>
+#include "shell.h"
+
+/****************************************************************************
+ * Definitions
+ ****************************************************************************/
+
+#define SHELL_PROMPT "uIP 1.0> "
+
+/****************************************************************************
+ * Private Types
+ ****************************************************************************/
+
+struct ptentry_s
+{
+  char *commandstr;
+  void (* pfunc)(void *handle, char *str);
+};
+
+/****************************************************************************
+ * Private Function Prototypes
+ ****************************************************************************/
+
+static void parse(void *handle, register char *str, struct ptentry_s *t);
+static void help(void *handle, char *str);
+static void unknown(void *handle, char *str);
+
+/****************************************************************************
+ * Private Data
+ ****************************************************************************/
+
+static struct ptentry_s g_parsetab[] =
+{
+  {"stats", help},
+  {"conn",  help},
+  {"help",  help},
+  {"exit",  shell_quit},
+  {"?",     help},
+  {NULL,    unknown}
+};
+
+/****************************************************************************
+ * Private Functions
+ ****************************************************************************/
+
+static void parse(void *handle, char *str, struct ptentry_s *t)
+{
+  struct ptentry_s *p;
+
+  for (p = t; p->commandstr != NULL; ++p)
+    {
+      if (strncmp(p->commandstr, str, strlen(p->commandstr)) == 0)
+        {
+          break;
+        }
+    }
+
+  p->pfunc(handle, str);
+}
+
+static void help(void *handle, char *str)
+{
+  shell_output(handle, "Available commands:");
+  shell_output(handle, "stats   - show network statistics");
+  shell_output(handle, "conn    - show TCP connections");
+  shell_output(handle, "help, ? - show help");
+  shell_output(handle, "exit    - exit shell");
+}
+
+static void unknown(void *handle, char *str)
+{
+  if (strlen(str) > 0)
+    {
+      shell_output(handle, "Unknown command: ", str);
+    }
+}
+
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
+
+void shell_init(void *handle)
+{
+}
+
+void shell_start(void *handle)
+{
+  shell_output(handle, "uIP command shell");
+  shell_output(handle, "Type '?' and return for help");
+  shell_prompt(handle, SHELL_PROMPT);
+}
+
+void shell_input(void *handle, char *cmd)
+{
+  parse(handle, cmd, g_parsetab);
+  shell_prompt(handle, SHELL_PROMPT);
+}

netutils/telnetd/shell.h

@@ -0,0 +1,97 @@
+/****************************************************************************
+ * netutils/telnetd/shell.h
+ * Interface for the Contiki shell.
+ *
+ *   Copyright (C) 2007 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * Based on uIP which also has a BSD style license:
+ *
+ *   Author: Adam Dunkels <adam@dunkels.com>
+ *   Copyright (c) 2003, Adam Dunkels.
+ *   All rights reserved.
+ *
+ * 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. The name of the author may not be used to endorse or promote
+ *    products derived from this software without specific prior
+ *    written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+ *
+ ****************************************************************************/
+
+/* Some of the functions declared in this file must be implemented as
+ * a shell back-end in the architecture specific files of a Contiki
+ * port.
+ */
+
+#ifndef __SHELL_H__
+#define __SHELL_H__
+
+/* Initialize the shell.
+ *
+ * Called when the shell front-end process starts. This function may
+ * be used to start listening for signals.
+ */
+
+void shell_init(void *handle);
+
+/* Start the shell back-end.
+ *
+ * Called by the front-end when a new shell is started.
+ */
+
+void shell_start(void *handle);
+
+/* Process a shell command.
+ *
+ * This function will be called by the shell GUI / telnet server whan
+ * a command has been entered that should be processed by the shell
+ * back-end.
+ *
+ * command The command to be processed.
+ */
+
+void shell_input(void *handle, char *command);
+
+/* Quit the shell. */
+
+void shell_quit(void *handle, char *);
+
+/* Print a string to the shell window.
+ *
+ * This function is implemented by the shell GUI / telnet server and
+ * can be called by the shell back-end to output a string in the
+ * shell window. The string is automatically appended with a linebreak.
+ */
+
+void shell_output(void *handle, const char *fmt, ...);
+
+/* Print a prompt to the shell window.
+ *
+ * This function can be used by the shell back-end to print out a
+ * prompt to the shell window.
+ *
+ */
+
+void shell_prompt(void *handle, char *prompt);
+
+#endif /* __SHELL_H__ */

netutils/telnetd/telnetd.c

@@ -0,0 +1,459 @@
+/****************************************************************************
+ * netutils/telnetd/telnetd.c
+ *
+ *   Copyright (C) 2007, 2009, 2011 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * This is a leverage of similar logic from uIP:
+ *
+ *   Author: Adam Dunkels <adam@sics.se>
+ *   Copyright (c) 2003, Adam Dunkels.
+ *   All rights reserved.
+ *
+ * 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 of the Institute 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 INSTITUTE 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 INSTITUTE 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>
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include <pthread.h>
+#include <debug.h>
+
+#include <apps/netutils/telnetd.h>
+#include <apps/netutils/uiplib.h>
+
+#include "shell.h"
+
+/****************************************************************************
+ * Definitions
+ ****************************************************************************/
+
+#define ISO_nl       0x0a
+#define ISO_cr       0x0d
+
+#define STATE_NORMAL 0
+#define STATE_IAC    1
+#define STATE_WILL   2
+#define STATE_WONT   3
+#define STATE_DO     4
+#define STATE_DONT   5
+#define STATE_CLOSE  6
+
+#define TELNET_IAC   255
+#define TELNET_WILL  251
+#define TELNET_WONT  252
+#define TELNET_DO    253
+#define TELNET_DONT  254
+
+/* Configurable settings */
+
+#ifndef CONFIG_NETUTILS_IOBUFFER_SIZE
+# define CONFIG_NETUTILS_IOBUFFER_SIZE 512
+#endif
+
+#ifndef CONFIG_NETUTILS_CMD_SIZE
+# define CONFIG_NETUTILS_CMD_SIZE 40
+#endif
+
+/* As threads are created to handle each request, a stack must be allocated
+ * for the thread.  Use a default if the user provided no stacksize.
+ */
+
+#ifndef CONFIG_NETUTILS_TELNETDSTACKSIZE
+# define CONFIG_NETUTILS_TELNETDSTACKSIZE 4096
+#endif
+
+/* Enabled dumping of all input/output buffers */
+
+#undef CONFIG_NETUTILS_TELNETD_DUMPBUFFER
+
+/****************************************************************************
+ * Private Types
+ ****************************************************************************/
+
+struct telnetd_s
+{
+  int     tn_sockfd;
+  char    tn_iobuffer[CONFIG_NETUTILS_IOBUFFER_SIZE];
+  char    tn_cmd[CONFIG_NETUTILS_CMD_SIZE];
+  uint8_t tn_bufndx;
+  uint8_t tn_state;
+};
+
+/****************************************************************************
+ * Private Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: telnetd_dumpbuffer
+ *
+ * Description:
+ *   Dump a buffer of data (debug only)
+ *
+ ****************************************************************************/
+
+#ifdef CONFIG_NETUTILS_TELNETD_DUMPBUFFER
+static inline void telnetd_dumpbuffer(FAR const char *msg, FAR const char *buffer, unsigned int nbytes)
+{
+  /* CONFIG_DEBUG, CONFIG_DEBUG_VERBOSE, and CONFIG_DEBUG_NET have to be
+  * defined or the following does nothing.
+  */
+    
+  nvdbgdumpbuffer(msg, (FAR const uint8_t*)buffer, nbytes);
+}
+#else
+# define telnetd_dumpbuffer(msg,buffer,nbytes)
+#endif
+
+/****************************************************************************
+ * Name: telnetd_putchar
+ *
+ * Description:
+ *   Add another parsed character to the TELNET command string
+ *
+ ****************************************************************************/
+
+static void telnetd_putchar(struct telnetd_s *pstate, uint8_t ch)
+{
+  /* Ignore carriage returns */
+
+  if (ch == ISO_cr)
+  {
+    return;
+  }
+
+  /* Add all other characters to the cmd buffer */
+
+  pstate->tn_cmd[pstate->tn_bufndx] = ch;
+
+  /* If a newline was added or if the buffer is full, then process it now */
+
+  if (ch == ISO_nl || pstate->tn_bufndx == (CONFIG_NETUTILS_CMD_SIZE - 1))
+    {
+      if (pstate->tn_bufndx > 0)
+        {
+          pstate->tn_cmd[pstate->tn_bufndx] = '\0';
+        }
+
+      telnetd_dumpbuffer("TELNET CMD", pstate->tn_cmd, strlen(pstate->tn_cmd));
+      shell_input(pstate, pstate->tn_cmd);
+      pstate->tn_bufndx = 0;
+    }
+  else
+    {
+      pstate->tn_bufndx++;
+      vdbg("Add '%c', bufndx=%d\n", ch, pstate->tn_bufndx);
+    }
+}
+
+/****************************************************************************
+ * Name: telnetd_sendopt
+ *
+ * Description:
+ *
+ ****************************************************************************/
+
+static void telnetd_sendopt(struct telnetd_s *pstate, uint8_t option, uint8_t value)
+{
+  uint8_t optbuf[4];
+  optbuf[0] = TELNET_IAC;
+  optbuf[1] = option;
+  optbuf[2] = value;
+  optbuf[3] = 0;
+
+  telnetd_dumpbuffer("Send optbuf", optbuf, 4);
+  if (send(pstate->tn_sockfd, optbuf, 4, 0) < 0)
+    {
+      dbg("[%d] Failed to send TELNET_IAC\n", pstate->tn_sockfd);
+    }
+}
+
+/****************************************************************************
+ * Name: telnetd_receive
+ *
+ * Description:
+ *   Process a received TELENET buffer
+ *
+ ****************************************************************************/
+
+static int telnetd_receive(struct telnetd_s *pstate, size_t len)
+{
+  char *ptr = pstate->tn_iobuffer;
+  uint8_t ch;
+
+  while (len > 0)
+    {
+      ch = *ptr++;
+      len--;
+
+      vdbg("ch=%02x state=%d\n", ch, pstate->tn_state);
+      switch (pstate->tn_state)
+        {
+          case STATE_IAC:
+            if (ch == TELNET_IAC)
+              {
+                telnetd_putchar(pstate, ch);
+                pstate->tn_state = STATE_NORMAL;
+             }
+            else
+              {
+                switch (ch)
+                  {
+                    case TELNET_WILL:
+                      pstate->tn_state = STATE_WILL;
+                      break;
+
+                    case TELNET_WONT:
+                      pstate->tn_state = STATE_WONT;
+                      break;
+
+                    case TELNET_DO:
+                      pstate->tn_state = STATE_DO;
+                      break;
+
+                    case TELNET_DONT:
+                      pstate->tn_state = STATE_DONT;
+                      break;
+
+                    default:
+                      pstate->tn_state = STATE_NORMAL;
+                      break;
+                  }
+              }
+            break;
+
+          case STATE_WILL:
+            /* Reply with a DONT */
+
+            telnetd_sendopt(pstate, TELNET_DONT, ch);
+            pstate->tn_state = STATE_NORMAL;
+            break;
+
+          case STATE_WONT:
+            /* Reply with a DONT */
+
+            telnetd_sendopt(pstate, TELNET_DONT, ch);
+            pstate->tn_state = STATE_NORMAL;
+            break;
+
+          case STATE_DO:
+            /* Reply with a WONT */
+
+            telnetd_sendopt(pstate, TELNET_WONT, ch);
+            pstate->tn_state = STATE_NORMAL;
+            break;
+
+          case STATE_DONT:
+            /* Reply with a WONT */
+
+            telnetd_sendopt(pstate, TELNET_WONT, ch);
+            pstate->tn_state = STATE_NORMAL;
+            break;
+
+          case STATE_NORMAL:
+            if (ch == TELNET_IAC)
+              {
+                pstate->tn_state = STATE_IAC;
+              }
+            else
+              {
+                telnetd_putchar(pstate, ch);
+              }
+            break;
+        }
+    }
+  return OK;
+}
+
+/****************************************************************************
+ * Name: telnetd_handler
+ *
+ * Description:
+ *   Each time a new connection to port 23 is made, a new thread is created
+ *   that begins at this entry point.  There should be exactly one argument
+ *   and it should be the socket descriptor (+1).
+ *
+ ****************************************************************************/
+
+static void *telnetd_handler(void *arg)
+{
+  struct telnetd_s *pstate = (struct telnetd_s *)malloc(sizeof(struct telnetd_s));
+  int               sockfd = (int)arg;
+  int               ret    = ERROR;
+
+  dbg("[%d] Started\n", sockfd);
+
+  /* Verify that the state structure was successfully allocated */
+
+  if (pstate)
+    {
+      /* Initialize the thread state structure */
+
+      memset(pstate, 0, sizeof(struct telnetd_s));
+      pstate->tn_sockfd = sockfd;
+      pstate->tn_state  = STATE_NORMAL;
+
+      /* Start up the shell */
+
+      shell_init(pstate);
+      shell_start(pstate);
+
+      /* Loop processing each TELNET command */
+      do
+        {
+          /* Read a buffer of data from the TELNET client */
+
+          ret = recv(pstate->tn_sockfd, pstate->tn_iobuffer, CONFIG_NETUTILS_IOBUFFER_SIZE, 0);
+          if (ret > 0)
+            {
+
+              /* Process the received TELNET data */
+
+              telnetd_dumpbuffer("Received buffer", pstate->tn_iobuffer, ret);
+              ret = telnetd_receive(pstate, ret);
+            }
+        }
+      while (ret >= 0 && pstate->tn_state != STATE_CLOSE);
+      dbg("[%d] ret=%d tn_state=%d\n", sockfd, ret, pstate->tn_state);
+
+      /* End of command processing -- Clean up and exit */
+
+      free(pstate);
+    }
+
+  /* Exit the task */
+
+  dbg("[%d] Exitting\n", sockfd);
+  close(sockfd);
+  return NULL;
+}
+
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: telnetd_init
+ *
+ * Description:
+ *   This is the main processing thread for telnetd.  It never returns
+ *   unless an error occurs
+ *
+ ****************************************************************************/
+
+void telnetd_init(void)
+{
+  /* Execute telnetd_handler on each connection to port 23 */
+
+  uip_server(HTONS(23), telnetd_handler, CONFIG_NETUTILS_TELNETDSTACKSIZE);
+}
+
+/****************************************************************************
+ * Name: shell_prompt
+ *
+ * Description:
+ *   Print a prompt to the shell window.
+ *
+ *   This function can be used by the shell back-end to print out a prompt
+ *   to the shell window.
+ *
+ ****************************************************************************/
+
+void shell_prompt(void *handle, char *str)
+{
+  struct telnetd_s *pstate = (struct telnetd_s *)handle;
+  int len = strlen(str);
+
+  strncpy(pstate->tn_iobuffer, str, len);
+  telnetd_dumpbuffer("Shell prompt", pstate->tn_iobuffer, len);
+  if (send(pstate->tn_sockfd, pstate->tn_iobuffer, len, 0) < 0)
+    {
+      dbg("[%d] Failed to send prompt\n", pstate->tn_sockfd);
+    }
+}
+
+/****************************************************************************
+ * Name: shell_output
+ *
+ * Description:
+ *   Print a string to the shell window.
+ *
+ *   This function is implemented by the shell GUI / telnet server and
+ *   can be called by the shell back-end to output a string in the
+ *   shell window. The string is automatically appended with a linebreak.
+ *
+ ****************************************************************************/
+
+void shell_output(void *handle, const char *fmt, ...)
+{
+  struct telnetd_s *pstate = (struct telnetd_s *)handle;
+  unsigned len;
+  va_list ap;
+
+  va_start(ap, fmt);
+  vsnprintf(pstate->tn_iobuffer, CONFIG_NETUTILS_IOBUFFER_SIZE, fmt, ap);
+  va_end(ap);
+
+  len = strlen(pstate->tn_iobuffer);
+  if (len < CONFIG_NETUTILS_IOBUFFER_SIZE - 2)
+    {
+      pstate->tn_iobuffer[len]   = ISO_cr;
+      pstate->tn_iobuffer[len+1] = ISO_nl;
+      pstate->tn_iobuffer[len+2] = '\0';
+    }
+
+  telnetd_dumpbuffer("Shell output", pstate->tn_iobuffer, len+2);
+  if (send(pstate->tn_sockfd, pstate->tn_iobuffer, len+2, 0) < 0)
+    {
+      dbg("[%d] Failed to send response\n", pstate->tn_sockfd);
+    }
+}
+
+/****************************************************************************
+ * Name: shell_quit
+ *
+ * Description:
+ *   Quit the shell
+ *
+ ****************************************************************************/
+
+void shell_quit(void *handle, char *str)
+{
+  struct telnetd_s *pstate = (struct telnetd_s *)handle;
+  pstate->tn_state = STATE_CLOSE;
+}
+

netutils/tftpc/Makefile

@@ -0,0 +1,96 @@
+############################################################################
+# apps/netutils/tftpc/Makefile
+#
+#   Copyright (C) 2011 Gregory Nutt. All rights reserved.
+#   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+#
+# 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.
+#
+############################################################################
+
+-include $(TOPDIR)/.config
+-include $(TOPDIR)/Make.defs
+include $(APPDIR)/Make.defs
+
+# TFTP Client Library
+
+ASRCS		=
+CSRCS		= 
+
+ifeq ($(CONFIG_NET_UDP),y)
+ifneq ($(CONFIG_NFILE_DESCRIPTORS),0)
+CSRCS		+= tftpc_get.c tftpc_put.c tftpc_packets.c
+endif
+endif
+
+AOBJS		= $(ASRCS:.S=$(OBJEXT))
+COBJS		= $(CSRCS:.c=$(OBJEXT))
+
+SRCS		= $(ASRCS) $(CSRCS)
+OBJS		= $(AOBJS) $(COBJS)
+
+BIN	    	= ../../libapps$(LIBEXT)
+
+ROOTDEPPATH	= --dep-path .
+
+# Common build
+
+VPATH		= 
+
+all: .built
+
+$(AOBJS): %$(OBJEXT): %.S
+	$(call ASSEMBLE, $<, $@)
+
+$(COBJS): %$(OBJEXT): %.c
+	$(call COMPILE, $<, $@)
+
+$(BIN):	$(OBJS)
+	@( for obj in $(OBJS) ; do \
+		$(call ARCHIVE, $@, $${obj}); \
+	done ; )
+	@touch .built
+	
+.built: $(BIN)
+
+.depend: Makefile $(SRCS)
+	@$(MKDEP) $(ROOTDEPPATH) \
+	  $(CC) -- $(CFLAGS) -- $(SRCS) >Make.dep
+	@touch $@
+
+# Register application
+depend: .depend
+
+clean:
+	@rm -f $(BIN) *.o *~ .*.swp .built
+	$(call CLEAN)
+
+distclean: clean
+	@rm -f Make.dep .depend
+
+-include Make.dep

netutils/tftpc/tftpc_get.c

@@ -0,0 +1,328 @@
+/****************************************************************************
+ * netuils/tftp/tftpc_get.c
+ *
+ *   Copyright (C) 2008-2009, 2011 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * 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, TFTP_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>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <debug.h>
+
+#include <net/uip/uipopt.h>
+#include <net/uip/uip.h>
+#include <apps/netutils/tftp.h>
+
+#include "tftpc_internal.h"
+
+#if defined(CONFIG_NET) && defined(CONFIG_NET_UDP) && CONFIG_NFILE_DESCRIPTORS > 0
+
+/****************************************************************************
+ * Pre-processor Definitions
+ ****************************************************************************/
+
+#define TFTP_RETRIES 3
+
+/****************************************************************************
+ * Private Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: tftp_write
+ ****************************************************************************/
+
+static inline ssize_t tftp_write(int fd, const uint8_t *buf, size_t len)
+{
+  size_t left = len;
+  ssize_t nbyteswritten;
+
+  while (left > 0)
+    {
+      /* Write the data... repeating the write in the event that it was
+       * interrupted by a signal.
+       */
+
+      do
+        {
+          nbyteswritten = write(fd, buf, left);
+        }
+      while (nbyteswritten < 0 && errno == EINTR);
+
+      /* Check for non-EINTR errors */
+
+      if (nbyteswritten < 0)
+        {
+          ndbg("write failed: %d\n", errno);
+          return ERROR;
+        }
+
+      /* Handle partial writes */
+
+      nvdbg("Wrote %d bytes to file\n", nbyteswritten);
+      left -= nbyteswritten;
+      buf  += nbyteswritten;
+    }
+  return len;
+}
+
+/****************************************************************************
+ * Name: tftp_parsedatapacket
+ ****************************************************************************/
+
+static inline int tftp_parsedatapacket(const uint8_t *packet,
+                                       uint16_t *opcode, uint16_t *blockno)
+{
+  *opcode = (uint16_t)packet[0] << 8 | (uint16_t)packet[1];
+  if (*opcode == TFTP_DATA)
+    {
+       *blockno = (uint16_t)packet[2] << 8 | (uint16_t)packet[3];
+       return OK;
+    }
+#if defined(CONFIG_DEBUG) && defined(CONFIG_DEBUG_NET)
+  else if (*opcode == TFTP_ERR)
+    {
+      (void)tftp_parseerrpacket(packet);
+    }
+#endif
+  return ERROR;
+}
+
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: tftpget
+ *
+ * Input Parameters:
+ *   remote - The name of the file on the TFTP server.
+ *   local  - Path to the location on a mounted filesystem where the file
+ *            will be stored.
+ *   addr   - The IP address of the server in network order
+ *   binary - TRUE:  Perform binary ('octect') transfer
+ *            FALSE: Perform text ('netascii') transfer
+ *
+ ****************************************************************************/
+
+int tftpget(const char *remote, const char *local, in_addr_t addr, bool binary)
+{
+  struct sockaddr_in server;  /* The address of the TFTP server */
+  struct sockaddr_in from;    /* The address the last UDP message recv'd from */
+  uint8_t *packet;            /* Allocated memory to hold one packet */
+  uint16_t blockno = 0;       /* The current transfer block number */
+  uint16_t opcode;            /* Received opcode */
+  uint16_t rblockno;          /* Received block number */
+  int len;                    /* Generic length */
+  int sd;                     /* Socket descriptor for socket I/O */
+  int fd;                     /* File descriptor for file I/O */
+  int retry;                  /* Retry counter */
+  int nbytesrecvd = 0;        /* The number of bytes received in the packet */
+  int ndatabytes;             /* The number of data bytes received */
+  int result = ERROR;         /* Assume failure */
+  int ret;                    /* Generic return status */
+
+  /* Allocate the buffer to used for socket/disk I/O */
+
+  packet = (uint8_t*)zalloc(TFTP_IOBUFSIZE);
+  if (!packet)
+    {
+      ndbg("packet memory allocation failure\n");
+      errno = ENOMEM;
+      goto errout;
+    }
+
+  /* Open the file for writing */
+
+  fd = open(local, O_WRONLY|O_CREAT|O_TRUNC, 0666);
+  if (fd < 0)
+    {
+      ndbg("open failed: %d\n", errno);
+      goto errout_with_packet;
+   }
+
+  /* Initialize a UDP socket and setup the server addresss */
+
+  sd = tftp_sockinit(&server, addr);
+  if (sd < 0)
+    {
+      goto errout_with_fd;
+    }
+
+  /* Then enter the transfer loop.  Loop until the entire file has
+   * been received or until an error occurs.
+   */
+
+  do
+    {
+      /* Increment the TFTP block number for the next transfer */
+
+      blockno++;
+
+      /* Send the next block if the file within a loop.  We will
+       * retry up to TFTP_RETRIES times before giving up on the
+       * transfer.
+       */
+
+      for (retry = 0; retry < TFTP_RETRIES; retry++)
+        {
+          /* Send the read request using the well-known port number before
+           * receiving the first block.  Each retry of the first block will
+           * re-send the request.
+           */
+
+          if (blockno == 1)
+            {
+              len             = tftp_mkreqpacket(packet, TFTP_RRQ, remote, binary);
+              server.sin_port = HTONS(CONFIG_NETUTILS_TFTP_PORT);
+              ret             = tftp_sendto(sd, packet, len, &server);
+              if (ret != len)
+                {
+                  goto errout_with_sd;
+                }
+
+              /* Subsequent sendto will use the port number selected by the TFTP
+               * server in the DATA packet.  Setting the server port to zero
+               * here indicates that we have not yet received the server port number.
+               */
+
+              server.sin_port = 0;
+            }
+
+          /* Get the next packet from the server */
+
+          nbytesrecvd = tftp_recvfrom(sd, packet, TFTP_IOBUFSIZE, &from);
+
+          /* Check if anything valid was received */
+
+          if (nbytesrecvd >= 0)
+            {
+              /* Verify the sender address and port number */
+
+              if (server.sin_addr.s_addr != from.sin_addr.s_addr)
+                {
+                  nvdbg("Invalid address in DATA\n");
+                  retry--;
+                  continue;
+                }
+
+              if (server.sin_port && server.sin_port != from.sin_port)
+                {
+                  nvdbg("Invalid port in DATA\n");
+                  len = tftp_mkerrpacket(packet, TFTP_ERR_UNKID, TFTP_ERRST_UNKID);
+                  ret = tftp_sendto(sd, packet, len, &from);
+                  retry--;
+                  continue;
+                }
+
+              /* Parse the incoming DATA packet */
+
+              if (nbytesrecvd < TFTP_DATAHEADERSIZE ||
+                  tftp_parsedatapacket(packet, &opcode, &rblockno) != OK ||
+                  blockno != rblockno)
+                {
+                  nvdbg("Parse failure\n");
+                  if (opcode > TFTP_MAXRFC1350)
+                    {
+                      len = tftp_mkerrpacket(packet, TFTP_ERR_ILLEGALOP, TFTP_ERRST_ILLEGALOP);
+                      ret = tftp_sendto(sd, packet, len, &from);
+                    }
+                  continue;
+                }
+
+              /* Replace the server port to the one in the good data response */
+
+              if (!server.sin_port)
+                {
+                  server.sin_port = from.sin_port;
+                }
+
+              /* Then break out of the loop */
+
+              break;
+            }
+        }
+
+      /* Did we exhaust all of the retries? */
+
+      if (retry == TFTP_RETRIES)
+        {
+          nvdbg("Retry limit exceeded\n");
+          goto errout_with_sd;
+        }
+
+      /* Write the received data chunk to the file */
+
+      ndatabytes = nbytesrecvd - TFTP_DATAHEADERSIZE;
+      tftp_dumpbuffer("Recvd DATA", packet + TFTP_DATAHEADERSIZE, ndatabytes);
+      if (tftp_write(fd, packet + TFTP_DATAHEADERSIZE, ndatabytes) < 0)
+        {
+          goto errout_with_sd;
+        }
+
+      /* Send the acknowledgment */
+
+      len = tftp_mkackpacket(packet, blockno);
+      ret = tftp_sendto(sd, packet, len, &server);
+      if (ret != len)
+        {
+          goto errout_with_sd;
+        }
+      nvdbg("ACK blockno %d\n", blockno);
+    }
+  while (ndatabytes >= TFTP_DATASIZE);
+
+  /* Return success */
+
+  result = OK;
+
+errout_with_sd:
+  close(sd);
+errout_with_fd:
+  close(fd);
+errout_with_packet:
+  free(packet);
+errout:
+  return result;
+}
+
+#endif /* CONFIG_NET && CONFIG_NET_UDP && CONFIG_NFILE_DESCRIPTORS > 0 */

netutils/tftpc/tftpc_internal.h

@@ -0,0 +1,173 @@
+/****************************************************************************
+ * netutils/tftoc/tftpc_internal.h
+ *
+ *   Copyright (C) 2008-2009 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ * 3. Neither the name NuttX nor the names of its contributors may be
+ *    used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ ****************************************************************************/
+
+#ifndef __NETUTILS_TFTP_TFTPC_INTERNAL_H
+#define __NETUTILS_TFTP_TFTPC_INTERNAL_H
+
+/****************************************************************************
+ * Included Files
+ ****************************************************************************/
+
+#include <nuttx/config.h>
+#include <nuttx/compiler.h>
+
+#include <sys/types.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+#include <net/uip/uipopt.h>
+
+/****************************************************************************
+ * Pre-processor Definitions
+ ****************************************************************************/
+
+/* Verify TFTP configuration settings ***************************************/
+/* The settings beginning with CONFIG_NETUTILS_TFTP_* can all be set in the
+ * NuttX configuration file.  If they are are defined in the configuration
+ * then default values are assigned here.
+ */
+
+/* The "well-known" server TFTP port number (usually 69).  This port number
+ * is only used for the initial server contact.  The server will negotiate
+ * a new transfer port number after the initial client request.
+ */
+
+#ifndef CONFIG_NETUTILS_TFTP_PORT
+#  define CONFIG_NETUTILS_TFTP_PORT 69
+#endif
+
+/* recvfrom timeout in deci-seconds */
+
+#ifndef CONFIG_NETUTILS_TFTP_TIMEOUT
+#  define CONFIG_NETUTILS_TFTP_TIMEOUT 10 /* One second */
+#endif
+
+/* Dump received buffers */
+
+#undef CONFIG_NETUTILS_TFTP_DUMPBUFFERS
+
+/* Sizes of TFTP messsage headers */
+
+#define TFTP_ACKHEADERSIZE  4
+#define TFTP_ERRHEADERSIZE  4
+#define TFTP_DATAHEADERSIZE 4
+
+/* The maximum size for TFTP data is determined by the configured uIP packet
+ * size (but cannot exceed 512 + sizeof(TFTP_DATA header).
+ */
+
+#define TFTP_DATAHEADERSIZE 4
+#define TFTP_MAXPACKETSIZE  (TFTP_DATAHEADERSIZE+512)
+
+#if UIP_UDP_MSS < TFTP_MAXPACKETSIZE
+#  define TFTP_PACKETSIZE   UIP_UDP_MSS
+#  ifdef CONFIG_CPP_HAVE_WARNING
+#    warning "uIP MSS is too small for TFTP"
+#  endif
+#else
+#  define TFTP_PACKETSIZE   TFTP_MAXPACKETSIZE
+#endif
+
+#define TFTP_DATASIZE      (TFTP_PACKETSIZE-TFTP_DATAHEADERSIZE)
+#define TFTP_IOBUFSIZE     (TFTP_PACKETSIZE+8)
+
+/* TFTP Opcodes *************************************************************/
+
+#define TFTP_RRQ  1  /* Read Request          RFC 1350, RFC 2090 */
+#define TFTP_WRQ  2  /* Write Request         RFC 1350 */
+#define TFTP_DATA 3  /* Data chunk            RFC 1350 */
+#define TFTP_ACK  4  /* Acknowledgement       RFC 1350 */
+#define TFTP_ERR  5  /* Error Message         RFC 1350 */
+#define TFTP_OACK 6  /* Option acknowledgment RFC 2347 */
+
+#define TFTP_MAXRFC1350 5
+
+/* TFTP Error Codes *********************************************************/
+
+/* Error codes */
+
+#define TFTP_ERR_NONE         0  /* No error */
+#define TFTP_ERR_NOSUCHFILE   1  /* File not found */
+#define TFTP_ERR_ACCESS       2  /* Access violation */
+#define TFTP_ERR_FULL         3  /* Disk full or allocation exceeded */
+#define TFTP_ERR_ILLEGALOP    4  /* Illegal TFTP operation */
+#define TFTP_ERR_UNKID        5  /* Unknown transfer ID */
+#define TFTP_ERR_EXISTS       6  /* File already exists */
+#define TFTP_ERR_UNKUSER      7  /* No such user */
+#define TFTP_ERR_NEGOTIATE    8  /* Terminate transfer due to option negotiation */
+
+/* Error strings */
+
+#define TFTP_ERR_STNOSUCHFILE "File not found"
+#define TFTP_ERRST_ACCESS     "Access violation"
+#define TFTP_ERRST_FULL       "Disk full or allocation exceeded"
+#define TFTP_ERRST_ILLEGALOP  "Illegal TFTP operation"
+#define TFTP_ERRST_UNKID      "Unknown transfer ID"
+#define TFTP_ERRST_EXISTS     "File already exists"
+#define TFTP_ERRST_UNKUSER    "No such user"
+#define TFTP_ERRST_NEGOTIATE  "Terminate transfer due to option negotiation"
+
+/****************************************************************************
+ * Public Type Definitions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Public Data
+ ****************************************************************************/
+
+/****************************************************************************
+ * Public Function Prototypes
+ ****************************************************************************/
+
+/* Defined in tftp_packet.c *************************************************/
+
+extern int tftp_sockinit(struct sockaddr_in *server, in_addr_t addr);
+extern int tftp_mkreqpacket(uint8_t *buffer, int opcode, const char *path, bool binary);
+extern int tftp_mkackpacket(uint8_t *buffer, uint16_t blockno);
+extern int tftp_mkerrpacket(uint8_t *buffer, uint16_t errorcode, const char *errormsg);
+#if defined(CONFIG_DEBUG) && defined(CONFIG_DEBUG_NET)
+extern int tftp_parseerrpacket(const uint8_t *packet);
+#endif
+
+extern ssize_t tftp_recvfrom(int sd, void *buf, size_t len, struct sockaddr_in *from);
+extern ssize_t tftp_sendto(int sd, const void *buf, size_t len, struct sockaddr_in *to);
+
+#ifdef CONFIG_NETUTILS_TFTP_DUMPBUFFERS
+# define tftp_dumpbuffer(msg, buffer, nbytes) nvdbgdumpbuffer(msg, buffer, nbytes)
+#else
+# define tftp_dumpbuffer(msg, buffer, nbytes)
+#endif
+
+#endif /* __NETUTILS_TFTP_TFTPC_INTERNAL_H */

netutils/tftpc/tftpc_packets.c

@@ -0,0 +1,330 @@
+/****************************************************************************
+ * netuils/tftp/tftpc_packets.c
+ *
+ *   Copyright (C) 2008-2009, 2011 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * 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, TFTP_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>
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+#include <errno.h>
+#include <debug.h>
+
+#include <netinet/in.h>
+
+#include <net/uip/uipopt.h>
+#include <net/uip/uip.h>
+#include <apps/netutils/tftp.h>
+
+#include "tftpc_internal.h"
+
+#if defined(CONFIG_NET) && defined(CONFIG_NET_UDP) && CONFIG_NFILE_DESCRIPTORS > 0
+
+/****************************************************************************
+ * Pre-processor Definitions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Public Data
+ ****************************************************************************/
+
+/****************************************************************************
+ * Private Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: tftp_mode
+ ****************************************************************************/
+
+static inline const char *tftp_mode(bool binary)
+{
+  return binary ? "octet" : "netascii";
+}
+
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: tftp_sockinit
+ *
+ * Description:
+ *   Common initialization logic:  Create the socket and initialize the
+ *   server address structure.
+ *
+ ****************************************************************************/
+
+int tftp_sockinit(struct sockaddr_in *server, in_addr_t addr)
+{
+  struct timeval timeo;
+  int sd;
+  int ret;
+
+  /* Create the UDP socket */
+
+  sd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+  if (sd < 0)
+    {
+      ndbg("socket failed: %d\n", errno);
+      return ERROR;
+    }
+
+  /* Set the recvfrom timeout */
+
+  timeo.tv_sec  = CONFIG_NETUTILS_TFTP_TIMEOUT / 10;
+  timeo.tv_usec = (CONFIG_NETUTILS_TFTP_TIMEOUT % 10) * 100000;
+  ret = setsockopt(sd, SOL_SOCKET, SO_RCVTIMEO, &timeo, sizeof(struct timeval));
+  if (ret < 0)
+    {
+      ndbg("setsockopt failed: %d\n", errno);
+    }
+
+  /* Initialize the server address structure */
+
+  memset(server, 0, sizeof(struct sockaddr_in));
+  server->sin_family      = AF_INET;
+  server->sin_addr.s_addr = addr;
+  server->sin_port        = HTONS(CONFIG_NETUTILS_TFTP_PORT);
+  return sd;
+}
+
+/****************************************************************************
+ * Name: tftp_mkreqpacket
+ *
+ * Description:
+ *   RRQ or WRQ message format:
+ *
+ *     2 bytes: Opcode (network order == big-endian)
+ *     N bytes: Filename
+ *     1 byte:  0
+ *     N bytes: mode
+ *     1 byte:  0
+ *
+ * Return
+ *  Then number of bytes in the request packet (never fails)
+ *
+ ****************************************************************************/
+
+int tftp_mkreqpacket(uint8_t *buffer, int opcode, const char *path, bool binary)
+{
+  buffer[0] = opcode >> 8;
+  buffer[1] = opcode & 0xff;
+  return sprintf((char*)&buffer[2], "%s%c%s", path, 0, tftp_mode(binary)) + 3;
+}
+
+/****************************************************************************
+ * Name: tftp_mkackpacket
+ *
+ * Description:
+ *   ACK message format:
+ *
+ *     2 bytes: Opcode (network order == big-endian)
+ *     2 bytes: Block number (network order == big-endian)
+ *
+ ****************************************************************************/
+
+int tftp_mkackpacket(uint8_t *buffer, uint16_t blockno)
+{
+  buffer[0] = TFTP_ACK >> 8;
+  buffer[1] = TFTP_ACK & 0xff;
+  buffer[2] = blockno >> 8;
+  buffer[3] = blockno & 0xff;
+  return 4;
+}
+
+/****************************************************************************
+ * Name: tftp_mkerrpacket
+ *
+ * Description:
+ *   ERROR message format:
+ *
+ *     2 bytes: Opcode (network order == big-endian)
+ *     2 bytes: Error number (network order == big-endian)
+ *     N bytes: Error string
+ *     1 byte:  0
+ *
+ ****************************************************************************/
+
+int tftp_mkerrpacket(uint8_t *buffer, uint16_t errorcode, const char *errormsg)
+{
+  buffer[0] = TFTP_ERR >> 8;
+  buffer[1] = TFTP_ERR & 0xff;
+  buffer[2] = errorcode >> 8;
+  buffer[3] = errorcode & 0xff;
+  strcpy((char*)&buffer[4], errormsg);
+  return strlen(errormsg) + 5;
+}
+
+/****************************************************************************
+ * Name: tftp_parseerrpacket
+ *
+ * Description:
+ *   ERROR message format:
+ *
+ *     2 bytes: Opcode (network order == big-endian)
+ *     2 bytes: Error number (network order == big-endian)
+ *     N bytes: Error string
+ *     1 byte:  0
+ *
+ ****************************************************************************/
+
+#if defined(CONFIG_DEBUG) && defined(CONFIG_DEBUG_NET)
+int tftp_parseerrpacket(const uint8_t *buffer)
+{
+  uint16_t opcode       = (uint16_t)buffer[0] << 8 | (uint16_t)buffer[1];
+  uint16_t errcode      = (uint16_t)buffer[2] << 8 | (uint16_t)buffer[3];
+  const char *errmsg  = (const char *)&buffer[4];
+
+  if (opcode == TFTP_ERR)
+    {
+      ndbg("ERR message: %s (%d)\n", errmsg, errcode);
+      return OK;
+    }
+  return ERROR;
+}
+#endif
+
+/****************************************************************************
+ * Name: tftp_recvfrom
+ *
+ * Description:
+ *   recvfrom helper
+ *
+ ****************************************************************************/
+
+ssize_t tftp_recvfrom(int sd, void *buf, size_t len, struct sockaddr_in *from)
+{
+  int     addrlen;
+  ssize_t nbytes;
+
+  /* Loop handles the case where the recvfrom is interrupted by a signal and
+   * we should unconditionally try again.
+   */
+
+  for (;;)
+    {
+      /* For debugging, it is helpful to start with a clean buffer */
+
+#if defined(CONFIG_DEBUG_VERBOSE) && defined(CONFIG_DEBUG_NET)
+      memset(buf, 0, len);
+#endif
+
+      /* Receive the packet */
+
+      addrlen = sizeof(struct sockaddr_in);
+      nbytes = recvfrom(sd, buf, len, 0, (struct sockaddr*)from, (socklen_t*)&addrlen);
+
+      /* Check for errors */
+
+      if (nbytes < 0)
+        {
+          /* Check for a timeout */
+
+          if (errno == EAGAIN)
+            {
+              ndbg("recvfrom timed out\n");
+              return ERROR;
+            }
+
+          /* If EINTR, then loop and try again.  Other errors are fatal */
+
+          else if (errno != EINTR)
+            {
+              ndbg("recvfrom failed: %d\n", errno);
+              return ERROR;
+            }
+        }
+
+      /* No errors?  Return the number of bytes received */
+
+      else
+        {
+          return nbytes;
+        }
+    }
+}
+
+/****************************************************************************
+ * Name: tftp_sendto
+ *
+ * Description:
+ *   sendto helper
+ *
+ ****************************************************************************/
+
+ssize_t tftp_sendto(int sd, const void *buf, size_t len, struct sockaddr_in *to)
+{
+  ssize_t nbytes;
+
+  /* Loop handles the case where the sendto is interrupted by a signal and
+   * we should unconditionally try again.
+   */
+
+  for (;;)
+    {
+      /* Send the packet */
+
+      nbytes = sendto(sd, buf, len, 0, (struct sockaddr*)to, sizeof(struct sockaddr_in));
+
+      /* Check for errors */
+
+      if (nbytes < 0)
+        {
+          /* If EINTR, then loop and try again.  Other errors are fatal */
+
+          if (errno != EINTR)
+            {
+              ndbg("sendto failed: %d\n", errno);
+              return ERROR;
+            }
+        }
+
+      /* No errors?  Return the number of bytes received */
+
+      else
+        {
+          return nbytes;
+        }
+    }
+}
+
+#endif /* CONFIG_NET && CONFIG_NET_UDP && CONFIG_NFILE_DESCRIPTORS */

netutils/tftpc/tftpc_put.c

@@ -0,0 +1,477 @@
+/****************************************************************************
+ * netuils/tftp/tftpc_put.c
+ *
+ *   Copyright (C) 2008-2009, 2011 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * 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, TFTP_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>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <debug.h>
+
+#include <net/uip/uipopt.h>
+#include <net/uip/uip.h>
+#include <apps/netutils/tftp.h>
+
+#include "tftpc_internal.h"
+
+#if defined(CONFIG_NET) && defined(CONFIG_NET_UDP) && CONFIG_NFILE_DESCRIPTORS > 0
+
+/****************************************************************************
+ * Pre-processor Definitions
+ ****************************************************************************/
+
+#define TFTP_RETRIES 3
+
+/****************************************************************************
+ * Private Function Prototypes
+ ****************************************************************************/
+
+/****************************************************************************
+ * Private Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: tftp_read
+ ****************************************************************************/
+
+static inline ssize_t tftp_read(int fd, uint8_t *buf, size_t buflen)
+{
+  ssize_t nbytesread;
+  ssize_t totalread = 0;
+
+  while (totalread < buflen)
+    {
+      /* Read the data... repeating the read in the event that it was
+       * interrupted by a signal.
+       */
+
+      do
+        {
+          nbytesread = read(fd, buf, buflen - totalread);
+        }
+      while (nbytesread < 0 && errno == EINTR);
+
+      /* Check for non-EINTR errors */
+
+      if (nbytesread < 0)
+        {
+          ndbg("read failed: %d\n", errno);
+          return ERROR;
+        }
+
+      /* Check for end of file */
+
+      else if (nbytesread == 0)
+        {
+          break;
+        }
+
+      /* Handle partial reads.  Partial reads can happen normally
+       * when the source is some device driver that returns data
+       * in bits and pieces as received (such as a pipe)
+       */
+
+      totalread += nbytesread;
+      buf       += nbytesread;
+    }
+  return totalread;
+}
+
+/****************************************************************************
+ * Name: tftp_mkdatapacket
+ *
+ * Description:
+ *   DATA message format:
+ *
+ *     2 bytes: Opcode (network order == big-endian)
+ *     2 bytes: Block number (network order == big-endian)
+ *     N bytes: Data (where N <= 512)
+ *
+ * Input Parameters:
+ *   fd      - File descriptor used to read from the file
+ *   offset  - File offset to read from
+ *   packet  - Buffer to write the data packet into
+ *   blockno - The block number of the packet
+ *
+ * Return Value:
+ *   Number of bytes read into the packet. <TFTP_PACKETSIZE means end of file;
+ *   <1 if an error occurs.
+ *
+ ****************************************************************************/
+
+int tftp_mkdatapacket(int fd, off_t offset, uint8_t *packet, uint16_t blockno)
+{
+  off_t tmp;
+  int nbytesread;
+
+  /* Format the DATA message header */
+
+  packet[0] = TFTP_DATA >> 8;
+  packet[1] = TFTP_DATA & 0xff;
+  packet[2] = blockno >> 8;
+  packet[3] = blockno & 0xff;
+
+  /* Seek to the correct offset in the file */
+
+  tmp = lseek(fd, offset, SEEK_SET);
+  if (tmp == (off_t)-1)
+    {
+      ndbg("lseek failed: %d\n", errno);
+      return ERROR;
+    }
+
+  /* Read the file data into the packet buffer */
+
+  nbytesread = tftp_read(fd, &packet[TFTP_DATAHEADERSIZE], TFTP_DATASIZE);
+  if (nbytesread < 0)
+    {
+      return ERROR;
+    }
+  return nbytesread + TFTP_DATAHEADERSIZE;
+}
+
+/****************************************************************************
+ * Name: tftp_rcvack
+ *
+ * Description:
+ *   ACK message format:
+ *
+ *     2 bytes: Opcode (network order == big-endian)
+ *     2 bytes: Block number (network order == big-endian)
+ *
+ * Input Parameters:
+ *   sd      - Socket descriptor to use in in the transfer
+ *   packet   - buffer to use for the tranfers
+ *   server  - The address of the server
+ *   port    - The port number of the server (0 if not yet known)
+ *   blockno - Location to return block number in the received ACK
+ *
+ * Returned Value:
+ *   OK:success and blockno valid, ERROR:failure.
+ *
+ ****************************************************************************/
+
+static int tftp_rcvack(int sd, uint8_t *packet, struct sockaddr_in *server,
+                       uint16_t *port, uint16_t *blockno)
+{
+  struct sockaddr_in from;     /* The address the last UDP message recv'd from */
+  ssize_t nbytes;              /* The number of bytes received. */
+  uint16_t opcode;             /* The received opcode */
+  uint16_t rblockno;           /* The received block number */
+  int packetlen;               /* Packet length */
+  int retry;                   /* Retry counter */
+
+  /* Try up to TFTP_RETRIES times */
+
+  for (retry = 0; retry < TFTP_RETRIES; retry++)
+    {
+      /* Try for until a valid ACK is received or some error occurs */
+
+      for (;;)
+        {
+          /* Receive the next UDP packet from the server */
+
+          nbytes = tftp_recvfrom(sd, packet, TFTP_IOBUFSIZE, &from);
+          if (nbytes < TFTP_ACKHEADERSIZE)
+            {
+              /* Failed to receive a good packet */
+
+              if (nbytes >= 0)
+                {
+                  ndbg("tftp_recvfrom short packet: %d bytes\n", nbytes);
+                }
+
+              /* Break out to bump up the retry count */
+
+              break;
+            }
+          else
+            {
+               /* Get the port being used by the server if that has not yet been established */
+
+               if (!*port)
+                 {
+                   *port            = from.sin_port;
+                   server->sin_port = from.sin_port;
+                 }
+
+               /* Verify that the packet was received from the correct host and port */
+
+               if (server->sin_addr.s_addr != from.sin_addr.s_addr)
+                 {
+                   nvdbg("Invalid address in DATA\n");
+                   continue;
+                 }
+
+              if (*port != server->sin_port)
+                {
+                  nvdbg("Invalid port in DATA\n");
+                  packetlen = tftp_mkerrpacket(packet, TFTP_ERR_UNKID, TFTP_ERRST_UNKID);
+                  (void)tftp_sendto(sd, packet, packetlen, server);
+                  continue;
+                }
+
+              /* Parse the error message */
+
+               opcode   = (uint16_t)packet[0] << 8 | (uint16_t)packet[1];
+               rblockno = (uint16_t)packet[2] << 8 | (uint16_t)packet[3];
+
+              /* Verify that the message that we received is an ACK for the
+               * expected block number.
+               */
+
+               if (opcode != TFTP_ACK)
+                 {
+                   nvdbg("Bad opcode\n");
+#if defined(CONFIG_DEBUG) && defined(CONFIG_DEBUG_NET)
+                  if (opcode == TFTP_ERR)
+                    {
+                      (void)tftp_parseerrpacket(packet);
+                    }
+                  else
+#endif
+                  if (opcode > TFTP_MAXRFC1350)
+                    {
+                      packetlen = tftp_mkerrpacket(packet, TFTP_ERR_ILLEGALOP, TFTP_ERRST_ILLEGALOP);
+                      (void)tftp_sendto(sd, packet, packetlen, server);
+                    }
+
+                  /* Break out an bump up the retry count */
+
+                  break;
+                }
+
+              /* Success! */
+
+              nvdbg("Received ACK for block %d\n", rblockno);
+              *blockno = rblockno;
+              return OK;
+            }
+        }
+    }
+
+  /* We have tried TFTP_RETRIES times */
+
+  ndbg("Timeout, Waiting for ACK\n");
+  return ERROR; /* Will never get here */
+}
+
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: tftpput
+ *
+ * Input Parameters:
+ *   local  - Path to the file system object to be sent.
+ *   remote - The name of the file on the TFTP server.
+ *   addr   - The IP address of the server in network order
+ *   binary - TRUE:  Perform binary ('octect') transfer
+ *            FALSE: Perform text ('netascii') transfer
+ *
+ ****************************************************************************/
+
+int tftpput(const char *local, const char *remote, in_addr_t addr, bool binary)
+{
+  struct sockaddr_in server;         /* The address of the TFTP server */
+  uint8_t *packet;                   /* Allocated memory to hold one packet */
+  off_t offset;                      /* Offset into source file */
+  uint16_t blockno;                  /* The current transfer block number */
+  uint16_t rblockno;                 /* The ACK'ed block number */
+  uint16_t port = 0;                 /* This is the port number for the transfer */
+  int packetlen;                     /* The length of the data packet */
+  int sd;                            /* Socket descriptor for socket I/O */
+  int fd;                            /* File descriptor for file I/O */
+  int retry;                         /* Retry counter */
+  int result = ERROR;                /* Assume failure */
+  int ret;                           /* Generic return status */
+
+  /* Allocate the buffer to used for socket/disk I/O */
+
+  packet = (uint8_t*)zalloc(TFTP_IOBUFSIZE);
+  if (!packet)
+    {
+      ndbg("packet memory allocation failure\n");
+      errno = ENOMEM;
+      goto errout;
+    }
+
+  /* Open the file for reading */
+
+  fd = open(local, O_RDONLY);
+  if (fd < 0)
+    {
+      ndbg("open failed: %d\n", errno);
+      goto errout_with_packet;
+    }
+
+  /* Initialize a UDP socket and setup the server addresss */
+
+  sd = tftp_sockinit(&server, addr);
+  if (sd < 0)
+    {
+      goto errout_with_fd;
+    }
+
+  /* Send the write request using the well known port.  This may need
+   * to be done several times because (1) UDP is inherenly unreliable
+   * and packets may be lost normally, and (2) uIP has a nasty habit
+   * of droppying packets if there is nothing hit in the ARP table.
+   */
+
+  blockno = 1;
+  retry   = 0;
+  for (;;)
+    {
+      packetlen = tftp_mkreqpacket(packet, TFTP_WRQ, remote, binary);
+      ret = tftp_sendto(sd, packet, packetlen, &server);
+      if (ret != packetlen)
+        {
+          goto errout_with_sd;
+        }
+
+      /* Receive the ACK for the write request */
+
+      if (tftp_rcvack(sd, packet, &server, &port, NULL) == 0)
+        {
+          break;
+        }
+
+      ndbg("Re-sending request\n");
+
+      /* We are going to loop and re-send the request packet. Check the
+       * retry count so that we do not loop forever.
+        */
+
+      if (++retry > TFTP_RETRIES)
+        {
+          ndbg("Retry count exceeded\n");
+          errno = ETIMEDOUT;
+          goto errout_with_sd;
+        }
+    }
+
+  /* Then loop sending the entire file to the server in chunks */
+
+  offset     = 0;
+  retry      = 0;
+
+  for (;;)
+    {
+      /* Construct the next data packet */
+
+      packetlen = tftp_mkdatapacket(fd, offset, packet, blockno);
+      if (packetlen < 0)
+        {
+          goto errout_with_sd;
+        }
+
+      /* Send the next data chunk */
+
+      ret = tftp_sendto(sd, packet, packetlen, &server);
+      if (ret != packetlen)
+        {
+          goto errout_with_sd;
+        }
+
+      /* Check for an ACK for the data chunk */
+
+      if (tftp_rcvack(sd, packet, &server, &port, &rblockno) == OK)
+        {
+          /* Check if the packet that we just sent was ACK'ed.  If not,
+           * we just loop to resend the same packet (same blockno, same
+           * file offset).
+           */
+
+          if (rblockno == blockno)
+            {
+               /* Yes.. If we are at the end of the file and if all of the packets
+                * have been ACKed, then we are done.
+                */
+
+              if (packetlen < TFTP_PACKETSIZE)
+                {
+                  break;
+                }
+
+               /* Not the last block.. set up for the next block */
+
+               blockno++;
+               offset += TFTP_DATASIZE;
+               retry  = 0;
+
+               /* Skip the retry test */
+
+               continue;
+            }
+        }
+
+      /* We are going to loop and re-send the data packet. Check the retry
+       * count so that we do not loop forever.
+       */
+
+      if (++retry > TFTP_RETRIES)
+        {
+          ndbg("Retry count exceeded\n");
+          errno = ETIMEDOUT;
+          goto errout_with_sd;
+        }
+    }
+
+  /* Return success */
+
+  result = OK;
+
+errout_with_sd:
+  close(sd);
+errout_with_fd:
+  close(fd);
+errout_with_packet:
+  free(packet);
+errout:
+  return result;
+}
+
+#endif /* CONFIG_NET && CONFIG_NET_UDP && CONFIG_NFILE_DESCRIPTORS > 0 */

netutils/thttpd/Makefile

@@ -0,0 +1,121 @@
+#############################################################################
+# apps/netutils/thttpd/Makefile
+#
+#   Copyright (C) 2009, 2011 Gregory Nutt. All rights reserved.
+#   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+#
+# 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.
+#
+#############################################################################
+
+-include $(TOPDIR)/.config
+-include $(TOPDIR)/Make.defs
+include $(APPDIR)/Make.defs
+
+# THTTPD Library
+
+ASRCS		=
+CSRCS		= 
+
+ifeq ($(CONFIG_NET_TCP),y)
+CSRCS		+= thttpd.c libhttpd.c thttpd_cgi.c thttpd_alloc.c thttpd_strings.c timers.c fdwatch.c tdate_parse.c
+endif
+
+AOBJS		= $(ASRCS:.S=$(OBJEXT))
+COBJS		= $(CSRCS:.c=$(OBJEXT))
+
+SRCS		= $(ASRCS) $(CSRCS)
+OBJS		= $(AOBJS) $(COBJS)
+
+BIN	    	= ../../libapps$(LIBEXT)
+
+ROOTDEPPATH	= --dep-path .
+
+# CGI binaries (examples only, not used in the build)
+
+CGIBINDIR	= $(APPDIR)/netutils/thttpd/cgi-bin
+
+SUBDIRS		=
+ifeq ($(CONFIG_NXFLAT),y)
+SUBDIRS		= cgi-src
+SUBDIR_BIN1	= phf
+SUBDIR_BIN2	= redirect
+SUBDIR_BIN3	= ssi
+SUBDIR_BIN	+= cgi-bin/$(SUBDIR_BIN1) cgi-bin/$(SUBDIR_BIN2)  cgi-bin/$(SUBDIR_BIN3)
+endif
+
+all: $(SUBDIR_BIN) $(BIN)
+.PHONY: depend clean distclean
+
+ifeq ($(CONFIG_NXFLAT),y)
+cgi-bin:
+	@mkdir cgi-bin
+
+cgi-src/$(SUBDIR_BIN1):
+	@$(MAKE) -C cgi-src $(SUBDIR_BIN1)
+
+cgi-bin/$(SUBDIR_BIN1): cgi-bin cgi-src/$(SUBDIR_BIN1)
+	@cp -a cgi-src/$(SUBDIR_BIN1) $@
+
+cgi-src/$(SUBDIR_BIN2):
+	@$(MAKE) -C cgi-src $(SUBDIR_BIN2)
+
+cgi-bin/$(SUBDIR_BIN2): cgi-bin cgi-src/$(SUBDIR_BIN2)
+	@cp -a cgi-src/$(SUBDIR_BIN2) $@
+
+cgi-src/$(SUBDIR_BIN3):
+	@$(MAKE) -C cgi-src $(SUBDIR_BIN3)
+
+cgi-bin/$(SUBDIR_BIN3): cgi-bin cgi-src/$(SUBDIR_BIN3)
+	@cp -a cgi-src/$(SUBDIR_BIN3) $@
+endif
+
+$(BIN):	$(OBJS)
+	@( for obj in $(OBJS) ; do \
+		$(call ARCHIVE, $@, $${obj}); \
+	done ; )
+	@touch .built
+	
+.built: $(BIN)
+
+.depend: Makefile $(SRCS)
+	@$(MKDEP) $(ROOTDEPPATH) \
+	  $(CC) -- $(CFLAGS) -- $(SRCS) >Make.dep
+	@touch $@
+
+# Register application
+depend: .depend
+
+clean:
+	@rm -f $(BIN) *.o *~ .*.swp .built
+	$(call CLEAN)
+
+distclean: clean
+	@rm -f Make.dep .depend
+
+-include Make.dep

netutils/thttpd/cgi-src/Makefile

@@ -0,0 +1,136 @@
+############################################################################
+# apps/netutils/cgi-src/Makefile
+#
+#   Copyright (C) 2009, 2011 Gregory Nutt. All rights reserved.
+#   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+#
+# 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.
+#
+############################################################################
+
+-include $(TOPDIR)/.config
+-include $(TOPDIR)/Make.defs
+
+CFLAGS		+= -I$(APPDIR)/netutils/thttpd -I$(APPDIR)/netutils/thttpd/cgi-src
+CGIBINDIR	= $(APPDIR)/netutils/thttpd/cgi-bin
+CLEANFILES	= *.o redirect ssi phf
+
+BIN1			= phf
+BIN2			= redirect
+BIN3			= ssi
+BIN				= $(BIN1) $(BIN2) $(BIN3)
+
+R1SRCS1			= $(BIN1).c
+R1OBJS1			= $(R1SRCS1:.c=.o)
+R2SRC1			= $(BIN1)-thunk.S
+R2OBJ1			= $(R2SRC1:.S=.o)
+
+R1SRCS2			= $(BIN2).c
+R1OBJS2			= $(R1SRCS2:.c=.o)
+R2SRC2			= $(BIN2)-thunk.S
+R2OBJ2			= $(R2SRC2:.S=.o)
+
+R1SRCS3			= $(BIN3).c
+R1OBJS3			= $(R1SRCS3:.c=.o)
+R2SRC3			= $(BIN3)-thunk.S
+R2OBJ3			= $(R2SRC3:.S=.o)
+
+DERIVED			= $(R2SRC1) $(R2SRC2) $(R2SRC3)
+
+R1COBJS			= $(R1OBJS1) $(R1OBJS2) $(R1OBJS3)
+R2AOBJS			= $(R2OBJ1) $(R2OBJ2) $(R2OBJ3)
+
+all: $(BIN1) $(BIN2) $(BIN3)
+
+$(R1COBJS): %.o: %.c
+	@echo "CC: $<"
+	@$(CC) -c $(CPICFLAGS) $< -o $@
+
+$(R2AOBJS): %.o: %.S
+	@echo "AS: $<"
+	@$(CC) -c $(CPICFLAGS) $< -o $@
+
+# BIN1
+
+$(BIN1).r1: $(R1OBJS1)
+	@echo "LD: $<"
+	@$(LD) $(NXFLATLDFLAGS1) -o $@ $^
+
+$(R2SRC1): $(BIN1).r1
+	@echo "MK: $<"
+	@$(MKNXFLAT) -o $@ $^
+
+$(BIN1).r2: $(R2OBJ1)
+	@echo "LD: $<"
+	@$(LD) $(NXFLATLDFLAGS2) -o $@ $(R1OBJS1) $(R2OBJ1)
+
+$(BIN1): $(BIN1).r2
+	@echo "LD: $<"
+	@$(LDNXFLAT) $(LDNXFLATFLAGS) -o $@ $^
+
+#BIN2
+
+$(BIN2).r1: $(R1OBJS2)
+	@echo "LD: $<"
+	@$(LD) $(NXFLATLDFLAGS1) -o $@ $^
+
+$(R2SRC2): $(BIN2).r1
+	@echo "MK: $<"
+	@$(MKNXFLAT) -o $@ $^
+
+$(BIN2).r2: $(R2OBJ2)
+	@echo "LD: $<"
+	@$(LD) $(NXFLATLDFLAGS2) -o $@ $(R1OBJS2) $(R2OBJ2)
+
+$(BIN2): $(BIN2).r2
+	@echo "LD: $<"
+	@$(LDNXFLAT) $(LDNXFLATFLAGS) -o $@ $^
+# BIN3
+
+$(BIN3).r1: $(R1OBJS3)
+	@echo "LD: $<"
+	@$(LD) $(NXFLATLDFLAGS1) -o $@ $^
+
+$(R2SRC3): $(BIN3).r1
+	@echo "MK: $<"
+	@$(MKNXFLAT) -o $@ $^
+
+$(BIN3).r2: $(R2OBJ3)
+	@echo "LD: $<"
+	@$(LD) $(NXFLATLDFLAGS2) -o $@ $(R1OBJS3) $(R2OBJ3)
+
+$(BIN3): $(BIN3).r2
+	@echo "LD: $<"
+	@$(LDNXFLAT) $(LDNXFLATFLAGS) -o $@ $^
+
+clean:
+	@rm -f $(BIN1) $(BIN2) $(BIN3) *.r1 *.r2 *-thunk.S *~ .*.swp
+	$(call CLEAN)
+
+distclean: clean
+

netutils/thttpd/cgi-src/phf.c

@@ -0,0 +1,77 @@
+/****************************************************************************
+ * netutils/thttpd/cgi-src/phf.c
+ * Cracker trap
+ *
+ *   Copyright (C) 2009 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * Derived from the file of the same name in the original THTTPD package:
+ *
+ *   Copyright © 1996 by Jef Poskanzer <jef@mail.acme.com>.
+ *   All rights reserved.
+ *
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
+ *
+ ****************************************************************************/
+
+/* Old distributions of the NCSA and Apache web servers included a
+ * version of the phf program that had a bug.  The program could
+ * easily be made to run arbitrary shell commands.  There is no real
+ * legitimate use for phf, so any attempts to run it must be considered
+ * to be attacks.  Accordingly, this version of phf logs the attack
+ * on stderr and then returns a page on CONFIG_THTTPD_CGI_OUTFD indicating
+ * that phf doesn't exist.
+ */
+
+/****************************************************************************
+ * Included Files
+ ****************************************************************************/
+
+#include <nuttx/config.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "config.h"
+
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
+
+int main(int argc, char *argv[])
+{
+  fprintf(stderr, "phf CGI probe from %s\n", getenv("REMOTE_ADDR"));
+
+  (void)printf("\
+Content-type: text/html\n\
+Status: 404/html\n\
+\n\
+<HTML><HEAD><TITLE>404 Not Found</TITLE></HEAD>\n\
+<BODY><H2>404 Not Found</H2>\n\
+The requested object does not exist on this server.\n\
+The link you followed is either outdated, inaccurate,\n\
+or the server has been instructed not to let you have it.\n\
+</BODY></HTML>\n");
+  return 0;
+}

netutils/thttpd/cgi-src/redirect.c

@@ -0,0 +1,269 @@
+/****************************************************************************
+ * netutils/thttpd/cgi-src/redirect.c
+ * Simple redirection CGI program
+ *
+ *   Copyright (C) 2009 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * Derived from the file of the same name in the original THTTPD package:
+ *
+ *   Copyright © 1995 by Jef Poskanzer <jef@mail.acme.com>.
+ *   All rights reserved.
+ *
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
+ *
+ ****************************************************************************/
+
+/* Three steps to set up a redirection:
+ *
+ *  1. Make sure your web server is set up to allow CGI programs.
+ *  2. Make a symbolic link from the file you want to redirect,
+ *     pointing at this program in the CGI bin directory.
+ *  3. Add an entry to the file ".redirects" in the directory where your
+ *     http server runs CGI programs.  For most servers, this is the
+ *     directory where the given CGI program lives.  The format of the
+ *     file is a bunch of lines with a filename, whitespace, and the new
+ *     URL.  For example:
+ *
+ *     /test/oldfile.html    http://www.acme.com/test/newfile.html
+ *
+ *     The easiest way to figure out precisely what filename to put into
+ *     .redirects is to set up the symlink and then click on it.  You'll get
+ *     back a "404 Not Found" page which includes the filename as received by
+ *     the redirect program, and that's what you want to use.
+ *
+ * Note: this is designed for thttpd (http://www.acme.com/software/thttpd/)
+ * and using it with other web servers may require some hacking.  A possible
+ * gotcha is with the symbolic link from the old file pointing at this
+ * script - servers other than thttpd may not allow that link to be run
+ * as a CGI program, because they don't check the link to see that it
+ * points into the allowed CGI directory.
+ *
+ * Note two: It would be really cool to have this program look for
+ * the .redirects file in the same directory as the file being redirected,
+ * instead of in the binaries directory.  Unfortunately, this appears
+ * to be impossible with the information CGI gives, plus the non-standardized
+ * but widespread practice of running CGI programs in the directory where
+ * the binary lives.  Perhaps CGI 1.2 will address this.
+ */
+
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+
+#include "config.h"
+
+/****************************************************************************
+ * Pre-Processor Definitions
+ ****************************************************************************/
+
+#define LINE_SIZE 80
+
+/****************************************************************************
+ * Private Data
+ ****************************************************************************/
+
+static char g_iobuffer[LINE_SIZE];
+static char g_file[LINE_SIZE];
+static char g_url[LINE_SIZE];
+
+/****************************************************************************
+ * Private Functions
+ ****************************************************************************/
+
+static void internal_error(char *reason)
+{
+  char *title = "500 Internal Error";
+
+  (void)printf("\
+Status: %s\n\
+Content-type: text/html\n\
+\n\
+<HTML><HEAD><TITLE>%s</TITLE></HEAD>\n\
+<BODY><H2>%s</H2>\n\
+Something unusual went wrong during a redirection request:\n\
+<BLOCKQUOTE>\n\
+%s\n\
+</BLOCKQUOTE>\n\
+</BODY></HTML>\n", title, title, title, reason);
+}
+
+static void not_found(char *script_name)
+{
+  char *title = "404 Not Found";
+
+  (void)printf("\
+Status: %s\n\
+Content-type: text/html\n\
+\n\
+<HTML><HEAD><TITLE>%s</TITLE></HEAD>\n\
+<BODY><H2>%s</H2>\n\
+The requested filename, %s, is set up to be redirected to another URL;\n\
+however, the new URL has not yet been specified.\n\
+</BODY></HTML>\n", title, title, title, script_name);
+}
+
+static void moved(char *script_name, char *url)
+{
+  char *title = "Moved";
+
+  (void)printf("\
+Location: %s\n\
+Content-type: text/html\n\
+\n\
+<HTML><HEAD><TITLE>%s</TITLE></HEAD>\n\
+<BODY><H2>%s</H2>\n\
+The requested filename, %s, has moved to a new URL:\n\
+<A HREF=\"%s\">%s</A>.\n\
+</BODY></HTML>\n", url, title, title, script_name, url, url);
+}
+
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
+
+int main(int argc, char **argv)
+{
+  char *script_name;
+  char *path_info;
+  char *cp = 0;
+  FILE *fp;
+  char *star;
+  int  err = 0;
+
+  /* Get the name that we were run as, which is the filename being **
+   * redirected.
+   */
+
+  script_name = getenv("SCRIPT_NAME");
+  if (!script_name)
+    {
+      internal_error("Couldn't get SCRIPT_NAME environment variable.");
+      return 1;
+    }
+
+  /* Append the PATH_INFO, if any.  This allows redirection of whole **
+   * directories.
+   */
+
+  path_info = getenv("PATH_INFO");
+  if (path_info)
+    {
+      cp = (char *)malloc(strlen(script_name) + strlen(path_info) + 1);
+      if (!cp)
+        {
+          internal_error("Out of memory.");
+          return 2;
+        }
+
+      (void)sprintf(cp, "%s%s", script_name, path_info);
+      script_name = cp;
+    }
+
+  /* Open the redirects file. */
+
+  fp = fopen(".redirects", "r");
+  if (fp == (FILE *) 0)
+    {
+      internal_error("Couldn't open .redirects file.");
+      err = 3;
+      goto errout_with_cp;
+    }
+
+  /* Search the file for a matching entry. */
+
+  while (fgets(g_iobuffer, LINE_SIZE, fp) != NULL)
+    {
+      /* Remove comments. */
+
+      cp = strchr(g_iobuffer, '#');
+      if (cp)
+        {
+          *cp = '\0';
+        }
+
+      /* Skip leading whitespace. */
+
+      cp = g_iobuffer;
+      cp += strspn(cp, " \t");
+
+      /* Check for blank line. */
+
+      if (*cp != '\0')
+        {
+          /* Parse line. */
+
+          if (sscanf(cp, "%[^ \t\n] %[^ \t\n]", g_file, g_url) == 2)
+            {
+              /* Check for wildcard match. */
+
+              star = strchr(g_file, '*');
+              if (star != (char *)0)
+                {
+                  /* Check for leading match. */
+
+                  if (strncmp(g_file, script_name, star - g_file) == 0)
+                    {
+                      /* Got it; put together the full name. */
+
+                      strcat(g_url, script_name + (star - g_file));
+
+                      /* XXX Whack the script_name, too? */
+
+                      moved(script_name, g_url);
+                      goto success_out;
+                    }
+                }
+
+              /* Check for exact match. */
+
+              if (strcmp(g_file, script_name) == 0)
+                {
+                  /* Got it. */
+
+                  moved(script_name, g_url);
+                  goto success_out;
+                }
+            }
+        }
+    }
+
+  /* No match found. */
+
+  not_found(script_name);
+  err = 4;
+
+success_out:
+  fclose(fp);
+errout_with_cp:
+  if (cp)
+    {
+      free(cp);
+    }
+  return err;
+}

netutils/thttpd/cgi-src/ssi.c

@@ -0,0 +1,957 @@
+/****************************************************************************
+ * netutils/thttpd/cgi-src/ssi.c
+ * Server-side-includes CGI program
+ *
+ *   Copyright (C) 2009 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * Derived from the file of the same name in the original THTTPD package:
+ *
+ *   Copyright © 1995 by Jef Poskanzer <jef@mail.acme.com>.
+ *   All rights reserved.
+ *
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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 <sys/types.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+
+#include <nuttx/regex.h>
+
+#include "config.h"
+
+/****************************************************************************
+ * Pre-Processor Definitions
+ ****************************************************************************/
+
+#define ST_GROUND    0
+#define ST_LESSTHAN  1
+#define ST_BANG      2
+#define ST_MINUS1    3
+#define ST_MINUS2    4
+
+#define SF_BYTES     0
+#define SF_ABBREV    1
+
+#define DI_CONFIG    0
+#define DI_INCLUDE   1
+#define DI_ECHO      2
+#define DI_FSIZE     3
+#define DI_FLASTMOD  4
+
+#define BUFFER_SIZE  512
+#define TIMEFMT_SIZE 80
+#define MAX_TAGS     32
+
+/****************************************************************************
+ * Private Function Prototypes
+ ****************************************************************************/
+
+static void read_file(FILE *instream, char *vfilename, char *filename);
+
+/****************************************************************************
+ * Private Data
+ ****************************************************************************/
+
+static char *g_url;
+static char  g_timeformat[TIMEFMT_SIZE];
+static char  g_iobuffer1[BUFFER_SIZE];
+static char  g_iobuffer2[BUFFER_SIZE];
+static char *g_tags[MAX_TAGS];
+static int   g_sizefmt;
+static struct stat g_sb;
+
+/****************************************************************************
+ * Private Functions
+ ****************************************************************************/
+
+static void internal_error(char *reason)
+{
+  char *title = "500 Internal Error";
+
+  (void)printf("\
+<HTML><HEAD><TITLE>%s</TITLE></HEAD>\n\
+<BODY><H2>%s</H2>\n\
+Something unusual went wrong during a server-side-includes request:\n\
+<BLOCKQUOTE>\n\
+%s\n\
+</BLOCKQUOTE>\n\
+</BODY></HTML>\n", title, title, reason);
+}
+
+static void not_found(char *filename)
+{
+  char *title = "404 Not Found";
+
+  (void)printf("\
+<HTML><HEAD><TITLE>%s</TITLE></HEAD>\n\
+<BODY><H2>%s</H2>\n\
+The requested server-side-includes filename, %s,\n\
+does not seem to exist.\n\
+</BODY></HTML>\n", title, title, filename);
+}
+
+static void not_found2(char *directive, char *tag, char *filename)
+{
+  char *title = "Not Found";
+
+  (void)printf("\
+<HR><H2>%s</H2>\n\
+The filename requested in a %s %s directive, %s,\n\
+does not seem to exist.\n\
+<HR>\n", title, directive, tag, filename);
+}
+
+static void not_permitted(char *directive, char *tag, char *val)
+{
+  char *title = "Not Permitted";
+
+  (void)printf("\
+<HR><H2>%s</H2>\n\
+The filename requested in the %s %s=%s directive\n\
+may not be fetched.\n\
+<HR>\n", title, directive, tag, val);
+}
+
+static void unknown_directive(char *filename, char *directive)
+{
+  char *title = "Unknown Directive";
+
+  (void)printf("\
+<HR><H2>%s</H2>\n\
+The requested server-side-includes filename, %s,\n\
+tried to use an unknown directive, %s.\n\
+<HR>\n", title, filename, directive);
+}
+
+static void unknown_tag(char *filename, char *directive, char *tag)
+{
+  char *title = "Unknown Tag";
+
+  (void)printf("\
+<HR><H2>%s</H2>\n\
+The requested server-side-includes filename, %s,\n\
+tried to use the directive %s with an unknown tag, %s.\n\
+<HR>\n", title, filename, directive, tag);
+}
+
+static void unknown_value(char *filename, char *directive, char *tag, char *val)
+{
+  char *title = "Unknown Value";
+
+  (void)printf("\
+<HR><H2>%s</H2>\n\
+The requested server-side-includes filename, %s,\n\
+tried to use the directive %s %s with an unknown value, %s.\n\
+<HR>\n", title, filename, directive, tag, val);
+}
+
+static int get_filename(char *vfilename, char *filename,
+                         char *directive, char *tag, char *val, char *fn,
+                         int fnsize)
+{
+  char *cp;
+  int vl;
+  int fl;
+
+  /* Used for the various commands that accept a file name. These commands
+   * accept two tags: virtual Gives a virtual path to a document on the
+   * server. file Gives a pathname relative to the current directory. ../ 
+   * cannot be used in this pathname, nor can absolute paths be used.
+   */
+
+  vl = strlen(vfilename);
+  fl = strlen(filename);
+
+  if (strcmp(tag, "virtual") == 0)
+    {
+      if (strstr(val, "../") != (char *)0)
+        {
+          not_permitted(directive, tag, val);
+          return -1;
+        }
+
+      /* Figure out root using difference between vfilename and filename. */
+
+      if (vl > fl || strcmp(vfilename, &filename[fl - vl]) != 0)
+        {
+          return -1;
+        }
+ 
+      if (fl - vl + strlen(val) >= fnsize)
+        {
+          return -1;
+        }
+
+      (void)strncpy(fn, filename, fl - vl);
+      (void)strcpy(&fn[fl - vl], val);
+    }
+  else if (strcmp(tag, "file") == 0)
+    {
+      if (val[0] == '/' || strstr(val, "../") != (char *)0)
+        {
+          not_permitted(directive, tag, val);
+          return -1;
+        }
+      if (fl + 1 + strlen(val) >= fnsize)
+        {
+          return -1;
+        }
+
+      (void)strcpy(fn, filename);
+      cp = strrchr(fn, '/');
+      if (cp == (char *)0)
+        {
+          cp = &fn[strlen(fn)];
+          *cp = '/';
+        }
+      (void)strcpy(++cp, val);
+    }
+  else
+    {
+      unknown_tag(filename, directive, tag);
+      return -1;
+    }
+  return 0;
+}
+
+static int check_filename(char *filename)
+{
+  static int inited = 0;
+  static char *cgi_pattern;
+#ifdef CONFIG_AUTH_FILE
+  struct stat sb;
+  char *dirname;
+  char *authname;
+  char *cp;
+  int fnl;
+  int r;
+#endif
+
+  if (!inited)
+    {
+      /* Get the cgi pattern. */
+
+      cgi_pattern = getenv("CGI_PATTERN");
+#ifdef CGI_PATTERN
+      if (cgi_pattern == (char *)0)
+        {
+          cgi_pattern = CGI_PATTERN;
+        }
+#endif /* CGI_PATTERN */
+      inited = 1;
+    }
+
+  /* ../ is not permitted. */
+
+  if (strstr(filename, "../") !=NULL)
+    {
+      return 0;
+    }
+
+  /* Ensure that we are not reading a basic auth password file. */
+
+#ifdef CONFIG_AUTH_FILE
+  fnl = strlen(filename);
+  if (strcmp(filename, CONFIG_AUTH_FILE) == 0 ||
+      (fnl >= sizeof(CONFIG_AUTH_FILE) &&
+       strcmp(&filename[fnl - sizeof(CONFIG_AUTH_FILE) + 1], CONFIG_AUTH_FILE) == 0 &&
+       filename[fnl - sizeof(CONFIG_AUTH_FILE)] == '/'))
+    {
+      return 0;
+    }
+
+  /* Check for an auth file in the same directory.  We can't do an actual **
+   * auth password check here because CGI programs are not given the **
+   * authorization header, for security reasons.  So instead we just **
+   * prohibit access to all auth-protected files.
+   */
+
+  dirname = strdup(filename);
+  if (dirname == (char *)0)
+    {
+      /* out of memory */
+
+      return 0;
+    }
+
+  cp = strrchr(dirname, '/');
+  if (cp == (char *)0)
+    {
+      (void)strcpy(dirname, ".");
+    }
+  else
+    {
+      *cp = '\0';
+    }
+
+  authname = malloc(strlen(dirname) + 1 + sizeof(CONFIG_AUTH_FILE));
+  if (!authname)
+    {
+      /* out of memory */
+
+      free(dirname);
+      return 0;
+    }
+
+  (void)sprintf(authname, "%s/%s", dirname, CONFIG_AUTH_FILE);
+  r = stat(authname, &sb);
+
+  free(dirname);
+  free(authname);
+
+  if (r == 0)
+    {
+      return 0;
+    }
+#endif /* CONFIG_AUTH_FILE */
+
+  /* Ensure that we are not reading a CGI file. */
+
+  if (cgi_pattern != (char *)0 && match(cgi_pattern, filename))
+    {
+      return 0;
+    }
+  return 1;
+}
+
+static void show_time(time_t t, int gmt)
+{
+  struct tm *tmP;
+
+  if (gmt)
+    {
+      tmP = gmtime(&t);
+    }
+  else
+    {
+      tmP = localtime(&t);
+    }
+
+  if (strftime(g_iobuffer2, BUFFER_SIZE, g_timeformat, tmP) > 0)
+    {
+      (void)puts(g_iobuffer2);
+    }
+}
+
+static void show_size(off_t size)
+{
+  switch (g_sizefmt)
+    {
+    case SF_BYTES:
+      (void)printf("%ld", (long)size);  /* spec says should have commas */
+      break;
+
+    case SF_ABBREV:
+      if (size < 1024)
+        {
+          (void)printf("%ld", (long)size);
+        }
+      else if (size < 1024)
+        {
+          (void)printf("%ldK", (long)size / 1024L);
+        }
+      else if (size < 1024 * 1024)
+        {
+          (void)printf("%ldM", (long)size / (1024L * 1024L));
+        }
+      else
+        {
+          (void)printf("%ldG", (long)size / (1024L * 1024L * 1024L));
+        }
+      break;
+    }
+}
+
+static void do_config(FILE *instream, char *vfilename, char *filename,
+                       char *directive, char *tag, char *val)
+{
+  /* The config directive controls various aspects of the file parsing. **
+   * There are two valid tags: g_timeformat Gives the server a new format to
+   * use when providing dates.  This is a string compatible with the
+   * strftime library call. g_sizefmt Determines the formatting to be used
+   * when displaying the size of a file.  Valid choices are bytes, for a
+   * formatted byte count (formatted as 1,234,567), or abbrev for an
+   * abbreviated version displaying the number of kilobytes or megabytes the 
+   * file occupies.
+   */
+
+  if (strcmp(tag, "g_timeformat") == 0)
+    {
+      (void)strncpy(g_timeformat, val, TIMEFMT_SIZE - 1);
+      g_timeformat[TIMEFMT_SIZE - 1] = '\0';
+    }
+  else if (strcmp(tag, "g_sizefmt") == 0)
+    {
+      if (strcmp(val, "bytes") == 0)
+        {
+          g_sizefmt = SF_BYTES;
+        }
+      else if (strcmp(val, "abbrev") == 0)
+        {
+          g_sizefmt = SF_ABBREV;
+        }
+      else
+        {
+          unknown_value(filename, directive, tag, val);
+        }
+    }
+  else
+    {
+      unknown_tag(filename, directive, tag);
+    }
+}
+
+static void do_include(FILE *instream, char *vfilename, char *filename,
+                        char *directive, char *tag, char *val)
+{
+  FILE *instream2;
+  int ret;
+
+  /* Inserts the text of another document into the parsed document. */
+
+  ret = get_filename(vfilename, filename, directive, tag, val, g_iobuffer1, BUFFER_SIZE);
+  if (ret < 0)
+    {
+      return;
+    }
+
+  if (!check_filename(g_iobuffer1))
+    {
+      not_permitted(directive, tag, g_iobuffer1);
+      return;
+    }
+
+  instream2 = fopen(g_iobuffer1, "r");
+  if (instream2 == (FILE *) 0)
+    {
+      not_found2(directive, tag, g_iobuffer1);
+      return;
+    }
+
+  if (strcmp(tag, "virtual") == 0)
+    {
+      if (strlen(val) <BUFFER_SIZE)
+        {
+          (void)strcpy(g_iobuffer2, val);
+        }
+      else
+        {
+          (void)strcpy(g_iobuffer2, g_iobuffer1);    /* same size, has to fit */
+        }
+    }
+  else
+    {
+      if (strlen(vfilename) + 1 + strlen(val) < BUFFER_SIZE)
+        {
+          char *cp;
+          (void)strcpy(g_iobuffer2, vfilename);
+          cp = strrchr(g_iobuffer2, '/');
+          if (cp == (char *)0)
+            {
+              cp = &g_iobuffer2[strlen(g_iobuffer2)];
+              *cp = '/';
+            }
+          (void)strcpy(++cp, val);
+        }
+      else
+        {
+          (void)strcpy(g_iobuffer2, g_iobuffer1);    /* same size, has to fit */
+        }
+    }
+
+  read_file(instream2, g_iobuffer2, g_iobuffer1);
+  (void)fclose(instream2);
+}
+
+static void do_echo(FILE *instream, char *vfilename, char *filename, 
+                     char *directive, char *tag, char *val)
+{
+  char *cp;
+
+  /* Prints the value of one of the include variables.  Any dates are
+   * printed subject to the currently configured g_timeformat.  The only valid
+   * tag is var, whose value is the name of the variable you wish to echo.
+   */
+
+  if (strcmp(tag, "var") != 0)
+    {
+      unknown_tag(filename, directive, tag);
+    }
+  else
+    {
+      if (strcmp(val, "DOCUMENT_NAME") == 0)
+        {
+          /* The current filename. */
+
+          (void)puts(filename);
+        }
+      else if (strcmp(val, "DOCUMENT_URI") == 0)
+        {
+          /* The virtual path to this file (such as /~robm/foo.shtml). */
+
+          (void)puts(vfilename);
+        }
+      else if (strcmp(val, "QUERY_STRING_UNESCAPED") == 0)
+        {
+          /* The unescaped version of any search query the client sent. */
+
+          cp = getenv("QUERY_STRING");
+          if (cp != (char *)0)
+            {
+              (void)puts(cp);
+            }
+        }
+      else if (strcmp(val, "DATE_LOCAL") == 0)
+        {
+          struct timeval tm;
+
+          /* The current date, local time zone. */
+
+          gettimeofday(&tm, NULL);
+          show_time(tm.tv_sec, 0);
+        }
+      else if (strcmp(val, "DATE_GMT") == 0)
+        {
+          struct timeval tm;
+
+          /* Same as DATE_LOCAL but in Greenwich mean time. */
+
+          gettimeofday(&tm, NULL);
+          show_time(tm.tv_sec, 1);
+        }
+      else if (strcmp(val, "LAST_MODIFIED") == 0)
+        {
+          /* The last modification date of the current document. */
+
+          if (fstat(fileno(instream), &g_sb) >= 0)
+            {
+              show_time(g_sb.st_mtime, 0);
+            }
+        }
+      else
+        {
+          /* Try an environment variable. */
+
+          cp = getenv(val);
+          if (cp == (char *)0)
+            {
+              unknown_value(filename, directive, tag, val);
+            }
+          else
+            {
+              (void)puts(cp);
+            }
+        }
+    }
+}
+
+static void do_fsize(FILE *instream, char *vfilename, char *filename,
+                      char *directive, char *tag, char *val)
+{
+  int ret;
+
+  /* Prints the size of the specified file. */
+
+  ret = get_filename(vfilename, filename, directive, tag, val, g_iobuffer1, BUFFER_SIZE);
+  if (ret < 0)
+    {
+      return;
+    }
+
+  if (stat(g_iobuffer1, &g_sb) < 0)
+    {
+      not_found2(directive, tag, g_iobuffer1);
+      return;
+    }
+
+  show_size(g_sb.st_size);
+}
+
+static void do_flastmod(FILE *instream, char *vfilename, char *filename,
+                         char *directive, char *tag, char *val)
+{
+  int ret;
+
+  /* Prints the last modification date of the specified file. */
+
+  ret = get_filename(vfilename, filename, directive, tag, val, g_iobuffer1, BUFFER_SIZE);
+  if (ret < 0)
+    {
+      return;
+    }
+
+  if (stat(g_iobuffer1, &g_sb) < 0)
+    {
+      not_found2(directive, tag, g_iobuffer1);
+      return;
+    }
+  show_time(g_sb.st_mtime, 0);
+}
+
+static void parse(FILE *instream, char *vfilename, char *filename, char *str)
+{
+  char *directive;
+  char *cp;
+  int ntags;
+  int dirn;
+  int i;
+  char *val;
+
+  directive = str;
+  directive += strspn(directive, " \t\n\r");
+
+  ntags = 0;
+  cp = directive;
+  for (;;)
+    {
+      cp = strpbrk(cp, " \t\n\r\"");
+      if (cp == (char *)0)
+        {
+          break;
+        }
+
+      if (*cp == '"')
+        {
+          cp = strpbrk(cp + 1, "\"");
+          cp++;
+          if (*cp == '\0')
+            {
+              break;
+            }
+        }
+
+      *cp++ = '\0';
+      cp += strspn(cp, " \t\n\r");
+      if (*cp == '\0')
+        {
+          break;
+        }
+
+      if (ntags < MAX_TAGS)
+        {
+          g_tags[ntags++] = cp;
+        }
+    }
+
+  if (strcmp(directive, "config") == 0)
+    {
+      dirn = DI_CONFIG;
+    }
+  else if (strcmp(directive, "include") == 0)
+    {
+      dirn = DI_INCLUDE;
+    }
+  else if (strcmp(directive, "echo") == 0)
+    {
+      dirn = DI_ECHO;
+    }
+  else if (strcmp(directive, "fsize") == 0)
+    {
+      dirn = DI_FSIZE;
+    }
+  else if (strcmp(directive, "flastmod") == 0)
+    {
+      dirn = DI_FLASTMOD;
+    }
+  else
+    {
+      unknown_directive(filename, directive);
+      return;
+    }
+
+  for (i = 0; i < ntags; ++i)
+    {
+      if (i > 0)
+        {
+          putchar(' ');
+        }
+
+      val = strchr(g_tags[i], '=');
+      if (val == (char *)0)
+        {
+          val = "";
+        }
+      else
+        {
+          *val++ = '\0';
+        }
+
+      if (*val == '"' && val[strlen(val) - 1] == '"')
+        {
+          val[strlen(val) - 1] = '\0';
+          ++val;
+        }
+
+      switch (dirn)
+        {
+        case DI_CONFIG:
+          do_config(instream, vfilename, filename, directive, g_tags[i], val);
+          break;
+
+        case DI_INCLUDE:
+          do_include(instream, vfilename, filename, directive, g_tags[i], val);
+          break;
+
+        case DI_ECHO:
+          do_echo(instream, vfilename, filename, directive, g_tags[i], val);
+          break;
+
+        case DI_FSIZE:
+          do_fsize(instream, vfilename, filename, directive, g_tags[i], val);
+          break;
+
+        case DI_FLASTMOD:
+          do_flastmod(instream, vfilename, filename, directive, g_tags[i], val);
+          break;
+        }
+    }
+}
+
+static void slurp(FILE *instream, char *vfilename, char *filename)
+{
+  int state;
+  int ich;
+  int i;
+
+  /* Now slurp in the rest of the comment from the input file. */
+
+  i     = 0;
+  state = ST_GROUND;
+  while ((ich = getc(instream)) != EOF)
+    {
+      switch (state)
+        {
+        case ST_GROUND:
+          if (ich == '-')
+            {
+              state = ST_MINUS1;
+            }
+          break;
+
+        case ST_MINUS1:
+          if (ich == '-')
+            {
+              state = ST_MINUS2;
+            }
+          else
+            {
+              state = ST_GROUND;
+            }
+          break;
+
+        case ST_MINUS2:
+          if (ich == '>')
+            {
+              g_iobuffer1[i - 2] = '\0';
+              parse(instream, vfilename, filename, g_iobuffer1);
+              return;
+            }
+          else if (ich != '-')
+            {
+              state = ST_GROUND;
+            }
+          break;
+        }
+
+      if (i < BUFFER_SIZE - 1)
+        {
+          g_iobuffer1[i++] = (char)ich;
+        }
+    }
+}
+
+static void read_file(FILE *instream, char *vfilename, char *filename)
+{
+  int ich;
+  int state;
+
+  /* Copy it to output, while running a state-machine to look for SSI
+   * directives.
+   */
+
+  state = ST_GROUND;
+  while ((ich = getc(instream)) != EOF)
+    {
+      switch (state)
+        {
+        case ST_GROUND:
+          if (ich == '<')
+            {
+              state = ST_LESSTHAN;
+              continue;
+            }
+          break;
+
+        case ST_LESSTHAN:
+          if (ich == '!')
+            {
+              state = ST_BANG;
+              continue;
+            }
+          else
+            {
+              state = ST_GROUND;
+              putchar('<');
+            }
+          break;
+
+        case ST_BANG:
+          if (ich == '-')
+            {
+              state = ST_MINUS1;
+              continue;
+            }
+          else
+            {
+              state = ST_GROUND;
+              (void)puts("<!");
+            }
+          break;
+
+        case ST_MINUS1:
+          if (ich == '-')
+            {
+              state = ST_MINUS2;
+              continue;
+            }
+          else
+            {
+              state = ST_GROUND;
+              (void)puts("<!-");
+            }
+          break;
+
+        case ST_MINUS2:
+          if (ich == '#')
+            {
+              slurp(instream, vfilename, filename);
+              state = ST_GROUND;
+              continue;
+            }
+          else
+            {
+              state = ST_GROUND;
+              (void)puts("<!--");
+            }
+          break;
+        }
+
+      putchar((char)ich);
+    }
+}
+
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
+
+int main(int argc, char **argv)
+{
+  FILE *instream;
+  char *script_name;
+  char *path_info;
+  char *path_translated;
+  int err = 0;
+
+  /* Default formats. */
+
+  (void)strcpy(g_timeformat, "%a %b %e %T %Z %Y");
+  g_sizefmt = SF_BYTES;
+
+  /* The MIME type has to be text/html. */
+
+  (void)puts("Content-type: text/html\n\n");
+
+  /* Get the name that we were run as. */
+
+  script_name = getenv("SCRIPT_NAME");
+  if (!script_name)
+    {
+      internal_error("Couldn't get SCRIPT_NAME environment variable.");
+      return 1;
+    }
+
+  /* Append the PATH_INFO, if any, to get the full URL. */
+
+  path_info = getenv("PATH_INFO");
+  if (!path_info)
+    {
+      path_info = "";
+    }
+
+  g_url = (char*)malloc(strlen(script_name) + strlen(path_info) + 1);
+  if (!g_url)
+    {
+      internal_error("Out of memory.");
+      return 2;
+    }
+  (void)sprintf(g_url, "%s%s", script_name, path_info);
+
+  /* Get the name of the file to parse. */
+
+  path_translated = getenv("PATH_TRANSLATED");
+  if (!path_translated)
+    {
+      internal_error("Couldn't get PATH_TRANSLATED environment variable.");
+      err = 3;
+      goto errout_with_g_url;
+    }
+
+  if (!check_filename(path_translated))
+    {
+      not_permitted("initial", "PATH_TRANSLATED", path_translated);
+      err = 4;
+      goto errout_with_g_url;
+    }
+
+  /* Open it. */
+
+  instream = fopen(path_translated, "r");
+  if (!instream)
+    {
+      not_found(path_translated);
+      err = 5;
+      goto errout_with_g_url;
+    }
+
+  /* Read and handle the file. */
+
+  read_file(instream, path_info, path_translated);
+
+  (void)fclose(instream);
+
+errout_with_g_url:
+  free(g_url);
+  return err;
+}

netutils/thttpd/config.h

@@ -0,0 +1,253 @@
+/****************************************************************************
+ * netutils/thttpd/config.h
+ *
+ *   Copyright (C) 2009 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ * 3. Neither the name NuttX nor the names of its contributors may be
+ *    used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ ****************************************************************************/
+
+#ifndef __NETUTILS_THTTPD_CONFIG_H
+#define __NETUTILS_THTTPD_CONFIG_H
+
+/****************************************************************************
+ * Included files
+ ****************************************************************************/
+
+#include <nuttx/config.h>
+#include <nuttx/compiler.h>
+#include <stdint.h>
+
+/****************************************************************************
+ * Pre-processor Definitions
+ ****************************************************************************/
+
+/* Make sure that the system is configured to handle THTTPD */
+
+#undef CONFIG_THTTPD
+#if defined(CONFIG_NET) && defined(CONFIG_NET_TCP) && \
+    defined(CONFIG_NET_TCPBACKLOG) && !defined(CONFIG_DISABLE_ENVIRONMENT) && \
+    !defined(CONFIG_SDCLONE_DISABLE) && CONFIG_NET_NTCP_READAHEAD_BUFFERS > 0
+
+#  define CONFIG_THTTPD 1
+
+/* Check all THTTPD configuration settings.  Complain on any that should have
+ * been defined but were not.  Supply some kind of reasonable value for all
+ * undefined settings.
+ */
+
+/* Server port number */
+
+#  ifndef CONFIG_THTTPD_PORT
+#    define CONFIG_THTTPD_PORT 80
+#  endif
+
+/* Server IP address (no host name) */
+
+#  ifndef CONFIG_THTTPD_IPADDR
+#    ifdef CONFIG_CPP_HAVE_WARNING
+#      warning "CONFIG_THTTPD_IPADDR not defined"
+#    endif
+#    define CONFIG_THTTPD_IPADDR (10<<24|0<<16|0<<8|2)
+#  endif
+
+/* SERVER_ADDRESS: response */
+
+#  ifndef CONFIG_THTTPD_SERVER_ADDRESS
+#    define CONFIG_THTTPD_SERVER_ADDRESS "http://www.nuttx.org"
+#  endif
+
+/* SERVER_SOFTWARE: response */
+
+#  ifndef CONFIG_THTTPD_SERVER_SOFTWARE
+#    define CONFIG_THTTPD_SERVER_SOFTWARE "thttpd/2.25b 29dec2003-NuttX"
+#  endif
+
+#  ifndef CONFIG_THTTPD_PATH
+#    ifdef CONFIG_CPP_HAVE_WARNING
+#      warning "CONFIG_THTTPD_PATH not defined"
+#    endif
+#    define CONFIG_THTTPD_PATH "/mnt/www"
+#  endif
+
+#  ifndef CONFIG_THTTPD_CGI_PATH
+#    ifdef CONFIG_CPP_HAVE_WARNING
+#      warning "CONFIG_THTTPD_CGI_PATH not defined"
+#    endif
+#    define CONFIG_THTTPD_CGI_PATH "/mnt/www/cgi-bin"
+#  endif
+
+/* Only CGI programs whose fully expanded pathes match this pattern will be executed.  In fact,
+ * if this value is not defined then no CGI logic will be built.
+ */
+
+#  ifndef CONFIG_THTTPD_CGI_PATTERN
+#    define CONFIG_THTTPD_CGI_PATTERN "/mnt/www/cgi-bin/*"
+#  endif
+
+/* These provide the priority and stack size of the CGI child tasks */
+
+#  ifndef CONFIG_THTTPD_CGI_PRIORITY
+#    define CONFIG_THTTPD_CGI_PRIORITY 50
+#  endif
+
+#  ifndef CONFIG_THTTPD_CGI_STACKSIZE
+#    define CONFIG_THTTPD_CGI_STACKSIZE 2048
+#  endif
+
+/* Byte output limit for CGI tasks */
+
+#  ifndef CONFIG_THTTPD_CGI_BYTECOUNT
+#    define CONFIG_THTTPD_CGI_BYTECOUNT 200000
+#  endif
+
+/* How many seconds to allow CGI programs to run before killing them. */
+
+#  ifndef CONFIG_THTTPD_CGI_TIMELIMIT
+#    define CONFIG_THTTPD_CGI_TIMELIMIT 0 /* No time limit */
+#  endif
+
+/* The default character set name to use with text MIME types. */
+
+#  ifndef CONFIG_THTTPD_CHARSET
+#    define CONFIG_THTTPD_CHARSET "iso-8859-1"
+#  endif
+
+/* Initial buffer size, buffer reallocation increment, maximum buffer size */
+
+#  ifndef CONFIG_THTTPD_IOBUFFERSIZE
+#    define CONFIG_THTTPD_IOBUFFERSIZE 256
+#  endif
+
+#  ifndef CONFIG_THTTPD_MINSTRSIZE
+#   define CONFIG_THTTPD_MINSTRSIZE 64
+#  endif
+
+#  ifndef CONFIG_THTTPD_REALLOCINCR
+#    define CONFIG_THTTPD_REALLOCINCR 64
+#  endif
+
+#  ifndef CONFIG_THTTPD_MAXREALLOC
+#    define CONFIG_THTTPD_MAXREALLOC 4096
+#  endif
+
+#  ifndef CONFIG_THTTPD_CGIINBUFFERSIZE
+#    define CONFIG_THTTPD_CGIINBUFFERSIZE 512	/* Size of buffer to interpose input */
+#  endif
+
+#  ifndef CONFIG_THTTPD_CGIOUTBUFFERSIZE
+#    define CONFIG_THTTPD_CGIOUTBUFFERSIZE 512	/* Size of buffer to interpose output */
+#  endif
+
+#  if CONFIG_THTTPD_IOBUFFERSIZE > 65535
+#    error "Can't use uint16_t for buffer size"
+#  endif
+
+/* A list of index filenames to check. The files are searched for in this order. */
+
+#  ifndef CONFIG_THTTPD_INDEX_NAMES
+#    define CONFIG_THTTPD_INDEX_NAMES "index.html", "index.htm", "index.cgi"
+#  endif
+
+/* CONFIG_AUTH_FILE - The file to use for authentication. If this is defined then
+ *   thttpd checks for this file in the local directory before every fetch. If the
+ *   file exists then authentication is done, otherwise the fetch proceeds as usual.
+ *   If you leave this undefined then thttpd will not implement authentication at
+ *   all and will not check for auth files, which saves a bit of CPU time.
+ *   A typical value is ".htpasswd"
+ */
+
+/* The listen() backlog queue length. */
+
+#  ifndef CONFIG_THTTPD_LISTEN_BACKLOG
+#    define CONFIG_THTTPD_LISTEN_BACKLOG 8
+#  endif
+
+/* How many milliseconds to leave a connection open while doing a lingering close */
+
+#  ifndef CONFIG_THTTPD_LINGER_MSEC
+#    define CONFIG_THTTPD_LINGER_MSEC 500
+#  endif
+
+/* How often to run the occasional cleanup job.*/
+
+#  ifndef CONFIG_THTTPD_OCCASIONAL_MSEC
+#    define CONFIG_THTTPD_OCCASIONAL_MSEC 120 /* Two minutes */
+#  endif
+
+/* How many seconds to allow for reading the initial request on a new connection. */
+
+#  ifndef CONFIG_THTTPD_IDLE_READ_LIMIT_SEC
+#    define CONFIG_THTTPD_IDLE_READ_LIMIT_SEC 300
+#  endif
+
+/* How many seconds before an idle connection gets closed. */
+
+#  ifndef CONFIG_THTTPD_IDLE_SEND_LIMIT_SEC
+#    define CONFIG_THTTPD_IDLE_SEND_LIMIT_SEC 300
+#  endif
+
+/* Memory debug instrumentation depends on other debug options */
+
+#if (!defined(CONFIG_DEBUG) || !defined(CONFIG_DEBUG_NET)) && defined(CONFIG_THTTPD_MEMDEBUG)
+#  undef CONFIG_THTTPD_MEMDEBUG
+#endif
+
+/* Tilde mapping. Many URLs use ~username to indicate a user's home directory. thttpd
+ * provides two options for mapping this construct to an  actual filename.
+ *
+ * 1) Map ~username to <prefix>/username. This is the recommended choice. Each user
+ *    gets a subdirectory in the main web tree, and the tilde construct points there.
+ *    The prefix could be something like "users", or it could be empty.
+ * 2) Map ~username to <user's homedir>/<postfix>. The postfix would be the name of
+ *    a subdirectory off of the user's actual home dir, something like "public_html".
+ *
+ * You can also leave both options undefined, and thttpd will not do anything special
+ * about tildes. Enabling both options is an error.
+ *
+ * Typical values, if they're defined, are "users" for CONFIG_THTTPD_TILDE_MAP1 and "public_html"
+ * for CONFIG_THTTPD_TILDE_MAP2. 
+ */
+
+#  if defined(CONFIG_THTTPD_TILDE_MAP1) && defined(CONFIG_THTTPD_TILDE_MAP2)
+#    error "Both CONFIG_THTTPD_TILDE_MAP1 andCONFIG_THTTPD_TILDE_MAP2 are defined"
+#  endif
+
+/* If CONFIG_THTTPD_URLPATTERN is defined, then it will be used to match and verify
+ * referrers.
+ */
+
+#else  /* Dependencies not provided */
+#  ifdef CONFIG_CPP_HAVE_WARNING
+#    warning "THTTPD not built because dependencies not selected in configuration"
+#  endif
+#endif  /* Dependencies not provided */
+
+#endif /* __NETUTILS_THTTPD_CONFIG_H */
+

netutils/thttpd/fdwatch.c

@@ -0,0 +1,371 @@
+/****************************************************************************
+ * netutils/thttpd/timers.c
+ * FD watcher routines for poll()
+ *
+ *   Copyright (C) 2009 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * Derived from the file of the same name in the original THTTPD package:
+ *
+ *   Copyright © 1999,2000 by Jef Poskanzer <jef@mail.acme.com>.
+ *   All rights reserved.
+ *
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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>
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <debug.h>
+#include <poll.h>
+#include <debug.h>
+
+#include "config.h"
+#include "thttpd_alloc.h"
+#include "fdwatch.h"
+
+#ifdef CONFIG_THTTPD
+
+/****************************************************************************
+ * Pre-Processor Definitions
+ ****************************************************************************/
+
+/* Debug output from this file is normally suppressed.  If enabled, be aware
+ * that output to stdout will interfere with CGI programs (you could use the
+ * the low-level debug (lldbg) functions which probably do not use stdout
+ */
+
+#ifdef CONFIG_THTTPD_FDWATCH_DEBUG
+#  ifdef CONFIG_CPP_HAVE_VARARGS
+#    define fwdbg(format, arg...)    ndbg(format, ##arg)
+#    define fwlldbg(format, arg...)  nlldbg(format, ##arg)
+#    define fwvdbg(format, arg...)   nvdbg(format, ##arg)
+#    define fwllvdbg(format, arg...) nllvdbg(format, ##arg)
+#  else
+#    define fwdbg    ndbg
+#    define fwlldbg  nlldbg
+#    define fwvdbg   nvdbg
+#    define fwllvdbg nllvdbg
+#  endif
+#else
+#  ifdef CONFIG_CPP_HAVE_VARARGS
+#    define fwdbg(x...)
+#    define fwlldbg(x...)
+#    define fwvdbg(x...)
+#    define fwllvdbg(x...)
+#  else
+#    define fwdbg    (void)
+#    define fwlldbg  (void)
+#    define fwvdbg   (void)
+#    define fwllvdbg (void)
+#  endif
+#endif
+
+#ifndef MIN
+#  define MIN(a,b) ((a) < (b) ? (a) : (b))
+#endif
+
+/****************************************************************************
+ * Private Data
+ ****************************************************************************/
+
+/****************************************************************************
+ * Private Function Prototypes
+ ****************************************************************************/
+
+/****************************************************************************
+ * Private Functions
+ ****************************************************************************/
+
+#ifdef CONFIG_THTTPD_FDWATCH_DEBUG
+static void fdwatch_dump(const char *msg, FAR struct fdwatch_s *fw)
+{
+  int i;
+ 
+  fwvdbg("%s\n", msg);
+  fwvdbg("nwatched: %d nfds: %d\n", fw->nwatched, fw->nfds);
+  for (i = 0; i < fw->nwatched; i++)
+  {
+    fwvdbg("%2d. pollfds: {fd: %d events: %02x revents: %02x} client: %p\n",
+           i+1, fw->pollfds[i].fd, fw->pollfds[i].events,
+           fw->pollfds[i].revents, fw->client[i]);
+  }
+  fwvdbg("nactive: %d next: %d\n", fw->nactive, fw->next);
+  for (i = 0; i < fw->nactive; i++)
+  {
+    fwvdbg("%2d. %d active\n", i, fw->ready[i]);
+  }
+}
+#else
+#  define fdwatch_dump(m,f)
+#endif
+
+static int fdwatch_pollndx(FAR struct fdwatch_s *fw, int fd)
+{
+  int pollndx;
+
+  /* Get the index associated with the fd */
+
+  for (pollndx = 0; pollndx < fw->nwatched; pollndx++)
+    {
+      if (fw->pollfds[pollndx].fd == fd)
+        {
+          fwvdbg("pollndx: %d\n", pollndx);
+          return pollndx;
+        }
+    }
+
+  fwdbg("No poll index for fd %d: %d\n", fd);
+  return -1;
+}
+
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
+
+/* Initialize the fdwatch data structures.  Returns -1 on failure. */
+
+struct fdwatch_s *fdwatch_initialize(int nfds)
+{
+  FAR struct fdwatch_s *fw;
+
+  /* Allocate the fdwatch data structure */
+
+  fw = (struct fdwatch_s*)zalloc(sizeof(struct fdwatch_s));
+  if (!fw)
+    {
+      fwdbg("Failed to allocate fdwatch\n");
+      return NULL;
+    }
+
+  /* Initialize the fdwatch data structures. */
+
+  fw->nfds = nfds;
+
+  fw->client = (void**)httpd_malloc(sizeof(void*) * nfds);
+  if (!fw->client)
+    {
+      goto errout_with_allocations;
+    }
+
+  fw->pollfds = (struct pollfd*)httpd_malloc(sizeof(struct pollfd) * nfds);
+  if (!fw->pollfds)
+    {
+      goto errout_with_allocations;
+    }
+
+  fw->ready = (uint8_t*)httpd_malloc(sizeof(uint8_t) * nfds);
+  if (!fw->ready)
+    {
+      goto errout_with_allocations;
+    }
+
+  fdwatch_dump("Initial state:", fw);
+  return fw;
+
+errout_with_allocations:
+  fdwatch_uninitialize(fw);
+  return NULL;
+}
+
+/* Uninitialize the fwdatch data structure */
+
+void fdwatch_uninitialize(struct fdwatch_s *fw)
+{
+  if (fw)
+    {
+      fdwatch_dump("Uninitializing:", fw);
+      if (fw->client)
+        {
+          httpd_free(fw->client);
+        }
+
+      if (fw->pollfds)
+        {
+          httpd_free(fw->pollfds);
+        }
+
+      if (fw->ready)
+        {
+          httpd_free(fw->ready);
+        }
+
+      httpd_free(fw);
+    }
+}
+
+/* Add a descriptor to the watch list.  rw is either FDW_READ or FDW_WRITE.  */
+
+void fdwatch_add_fd(struct fdwatch_s *fw, int fd, void *client_data)
+{
+  fwvdbg("fd: %d client_data: %p\n", fd, client_data);
+  fdwatch_dump("Before adding:", fw);
+
+  if (fw->nwatched >= fw->nfds)
+    {
+      fwdbg("too many fds\n");
+      return;
+    }
+
+  /* Save the new fd at the end of the list */
+
+  fw->pollfds[fw->nwatched].fd     = fd;
+  fw->pollfds[fw->nwatched].events = POLLIN;
+  fw->client[fw->nwatched]         = client_data;
+
+  /* Increment the count of watched descriptors */
+
+  fw->nwatched++;
+  fdwatch_dump("After adding:", fw);
+}
+
+/* Remove a descriptor from the watch list. */
+
+void fdwatch_del_fd(struct fdwatch_s *fw, int fd)
+{
+  int pollndx;
+
+  fwvdbg("fd: %d\n", fd);
+  fdwatch_dump("Before deleting:", fw);
+
+  /* Get the index associated with the fd */
+
+  pollndx = fdwatch_pollndx(fw, fd);
+  if (pollndx >= 0)
+    {
+      /* Decrement the number of fds in the poll table */
+
+      fw->nwatched--;
+
+      /* Replace the deleted one with the one at the the end
+       * of the list.
+       */
+
+      if (pollndx != fw->nwatched)
+        {
+          fw->pollfds[pollndx] = fw->pollfds[fw->nwatched];
+          fw->client[pollndx]  = fw->client[fw->nwatched];
+        }
+    }
+   fdwatch_dump("After deleting:", fw);
+}
+
+/* Do the watch.  Return value is the number of descriptors that are ready,
+ * or 0 if the timeout expired, or -1 on errors.  A timeout of INFTIM means
+ * wait indefinitely.
+ */
+
+int fdwatch(struct fdwatch_s *fw, long timeout_msecs)
+{
+  int ret;
+  int i;
+
+  /* Wait for activity on any of the desciptors.  When poll() returns, ret
+   * will hold the number of descriptors with activity (or zero on a timeout
+   * or <0 on an error.
+   */
+
+  fdwatch_dump("Before waiting:", fw);
+  fwvdbg("Waiting... (timeout %d)\n", timeout_msecs);
+  fw->nactive = 0;
+  fw->next    = 0;
+  ret         = poll(fw->pollfds, fw->nwatched, (int)timeout_msecs);
+  fwvdbg("Awakened: %d\n", ret);
+
+  /* Look through all of the descriptors and make a list of all of them than
+   * have activity.
+   */
+
+  if (ret > 0)
+    {
+      for (i = 0; i < fw->nwatched; i++)
+        {
+          /* Is there activity on this descriptor? */
+
+          if (fw->pollfds[i].revents & (POLLIN | POLLERR | POLLHUP | POLLNVAL))
+            {
+              /* Yes... save it in a shorter list */
+
+              fwvdbg("pollndx: %d fd: %d revents: %04x\n",
+                    i, fw->pollfds[i].fd, fw->pollfds[i].revents);
+
+              fw->ready[fw->nactive++] = fw->pollfds[i].fd;
+              if (fw->nactive == ret)
+                {
+                  /* We have all of them, break out early */
+
+                  break;
+                }
+            }
+        }
+    }
+
+  /* Return the number of descriptors with activity */
+
+  fwvdbg("nactive: %d\n", fw->nactive);
+  fdwatch_dump("After wakeup:", fw);
+  return ret;
+}
+
+/* Check if a descriptor was ready. */
+
+int fdwatch_check_fd(struct fdwatch_s *fw, int fd)
+{
+  int pollndx;
+
+  fwvdbg("fd: %d\n", fd);
+  fdwatch_dump("Checking:", fw);
+
+  /* Get the index associated with the fd */
+
+  pollndx = fdwatch_pollndx(fw, fd);
+  if (pollndx >= 0 && (fw->pollfds[pollndx].revents & POLLERR) == 0)
+    {
+      return fw->pollfds[pollndx].revents & (POLLIN | POLLHUP | POLLNVAL);
+    }
+
+  fwvdbg("POLLERR fd: %d\n", fd);
+  return 0;
+}
+
+void *fdwatch_get_next_client_data(struct fdwatch_s *fw)
+{
+  fdwatch_dump("Before getting client data:", fw);
+  if (fw->next >= fw->nwatched)
+    {
+      fwvdbg("All client data returned: %d\n", fw->next);
+      return (void*)-1;
+    }
+
+  fwvdbg("client_data[%d]: %p\n", fw->next, fw->client[fw->next]);
+  return fw->client[fw->next++];
+}
+
+#endif /* CONFIG_THTTPD */
+

netutils/thttpd/fdwatch.h

@@ -0,0 +1,111 @@
+/****************************************************************************
+ * netutils/thttpd/fdwatch.h
+ *
+ *   Copyright (C) 2009 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * Derived from the file of the same name in THTTPD:
+ *
+ *   Copyright © 1999 by Jef Poskanzer <jef@mail.acme.com>.
+ *   All rights reserved.
+ *
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ ****************************************************************************/
+
+#ifndef __NETUTILS_THTTPD_FDWATCH_H
+#define __NETUTILS_THTTPD_FDWATCH_H
+
+/****************************************************************************
+ * Included Files
+ ****************************************************************************/
+
+#include <nuttx/config.h>
+#include <stdint.h>
+
+/****************************************************************************
+ * Pre-Processor Definitions
+ ****************************************************************************/
+
+/* Define to enable detailed FDWATCH debug output */
+
+#undef CONFIG_THTTPD_FDWATCH_DEBUG
+
+#ifndef INFTIM
+#  define INFTIM -1
+#endif
+
+/****************************************************************************
+ * Private Types
+ ****************************************************************************/
+
+struct fdwatch_s
+{
+  struct pollfd *pollfds;          /* Poll data (allocated) */
+  void         **client;           /* Client data (allocated) */
+  uint8_t       *ready;            /* The list of fds with activity (allocated) */
+  uint8_t        nfds;             /* The configured maximum number of fds */
+  uint8_t        nwatched;         /* The number of fds currently watched */
+  uint8_t        nactive;          /* The number of fds with activity */
+  uint8_t        next;             /* The index to the next client data */
+};
+
+/****************************************************************************
+ * Public Function Prototypes
+ ****************************************************************************/
+
+/* Initialize the fdwatch data structures.  Returns NULL on failure. */
+
+extern struct fdwatch_s *fdwatch_initialize(int nfds);
+
+/* Uninitialize the fwdatch data structure */
+
+extern void fdwatch_uninitialize(struct fdwatch_s *fw);
+
+/* Add a descriptor to the watch list */
+
+extern void fdwatch_add_fd(struct fdwatch_s *fw, int fd, void *client_data);
+
+/* Delete a descriptor from the watch list. */
+
+extern void fdwatch_del_fd(struct fdwatch_s *fw, int fd);
+
+/* Do the watch.  Return value is the number of descriptors that are ready,
+ * or 0 if the timeout expired, or -1 on errors.  A timeout of INFTIM means
+ * wait indefinitely.
+ */
+
+extern int fdwatch(struct fdwatch_s *fw, long timeout_msecs);
+
+/* Check if a descriptor was ready. */
+
+extern int fdwatch_check_fd(struct fdwatch_s *fw, int fd);
+
+/* Get the client data for the next returned event.  Returns -1 when there
+ * are no more events.
+ */
+
+extern void *fdwatch_get_next_client_data(struct fdwatch_s *fw);
+
+#endif /* __NETUTILS_THTTPD_FDWATCH_H */
+

netutils/thttpd/libhttpd.h

@@ -0,0 +1,342 @@
+/****************************************************************************
+ * netutils/thttpd/libhttpd.h
+ * HTTP Protocol Library Definitions
+ *
+ *   Copyright (C) 2009 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * Derived from the file of the same name in the original THTTPD package:
+ *
+ *   Copyright © 1995,1998,1999,2000,2001 by Jef Poskanzer <jef@mail.acme.com>.
+ *   All rights reserved.
+ *
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ ****************************************************************************/
+
+#ifndef __NETUTILS_THTTPD_LIBHTTPD_H
+#define __NETUTILS_THTTPD_LIBHTTPD_H
+
+/****************************************************************************
+ * Included Files
+ ****************************************************************************/
+
+#include <nuttx/config.h>
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+#include <time.h>
+
+#include "config.h"
+#ifdef CONFIG_THTTPD
+
+/****************************************************************************
+ * Pre-processor Definitions
+ ****************************************************************************/
+
+/* A few convenient defines. */
+
+#ifndef MAX
+#  define MAX(a,b) ((a) > (b) ? (a) : (b))
+#endif
+#ifndef MIN
+#  define MIN(a,b) ((a) < (b) ? (a) : (b))
+#endif
+
+/* Enable special instrumentation to track down "400 Bad Request" problems */
+
+#undef CONFIG_THTTPD_BADREQUEST /* Define to enable "Bad Request" instrumentation */
+
+#ifdef CONFIG_THTTPD_BADREQUEST
+#  if !defined(CONFIG_DEBUG_VERBOSE) || !defined(CONFIG_DEBUG_NET)
+#    undef CONFIG_THTTPD_BADREQUEST
+#  else
+#    define BADREQUEST(s) nvdbg("Bad Request: \"%s\"\n", s)
+#  endif
+#endif
+
+#ifndef CONFIG_THTTPD_BADREQUEST
+#  undef  BADREQUEST
+#  define BADREQUEST(s)
+#endif
+
+/* Enable special instrumentation to track down "501 Not Implemented" problems */
+
+#undef CONFIG_THTTPD_NOTIMPLEMENTED /* Define to enable "Not Implemented" instrumentation */
+
+#ifdef CONFIG_THTTPD_NOTIMPLEMENTED
+#  if !defined(CONFIG_DEBUG_VERBOSE) || !defined(CONFIG_DEBUG_NET)
+#    undef CONFIG_THTTPD_NOTIMPLEMENTED
+#  else
+#    define NOTIMPLEMENTED(s) nvdbg("Not Implemented: \"%s\"\n", s)
+#  endif
+#endif
+
+#ifndef CONFIG_THTTPD_NOTIMPLEMENTED
+#  undef  NOTIMPLEMENTED
+#  define NOTIMPLEMENTED(s)
+#endif
+
+/* Enable special instrumentation to track down "500 Internal Error" problems */
+
+#undef CONFIG_THTTPD_INTERNALERROR /* Define to enable "Internal Error" instrumentation */
+
+#ifdef CONFIG_THTTPD_INTERNALERROR
+#  if !defined(CONFIG_DEBUG_VERBOSE) || !defined(CONFIG_DEBUG_NET)
+#    undef CONFIG_THTTPD_INTERNALERROR
+#  else
+#    define INTERNALERROR(s) nvdbg("Internal Error: \"%s\"\n", s)
+#  endif
+#endif
+
+#ifndef CONFIG_THTTPD_INTERNALERROR
+#  undef  INTERNALERROR
+#  define INTERNALERROR(s)
+#endif
+
+/* Methods */
+
+#define METHOD_UNKNOWN 0
+#define METHOD_GET 1
+#define METHOD_HEAD 2
+#define METHOD_POST 3
+
+/* States for checked_state. */
+
+#define CHST_FIRSTWORD  0
+#define CHST_FIRSTWS    1
+#define CHST_SECONDWORD 2
+#define CHST_SECONDWS   3
+#define CHST_THIRDWORD  4
+#define CHST_THIRDWS    5
+#define CHST_LINE       6
+#define CHST_LF         7
+#define CHST_CR         8
+#define CHST_CRLF       9
+#define CHST_CRLFCR     10
+#define CHST_BOGUS      11
+
+#define GC_FAIL 0
+#define GC_OK 1
+#define GC_NO_MORE 2
+
+#define GR_NO_REQUEST 0
+#define GR_GOT_REQUEST 1
+#define GR_BAD_REQUEST 2
+
+/****************************************************************************
+ * Public Type Definitions
+ ****************************************************************************/
+
+/* A multi-family sockaddr. */
+
+#ifdef  CONFIG_NET_IPv6
+typedef struct sockaddr_in6 httpd_sockaddr;
+#else
+typedef struct sockaddr_in httpd_sockaddr;
+#endif
+
+/* A server. */
+
+typedef struct
+{
+  char *hostname;
+  int   cgi_count;
+  int   listen_fd;
+} httpd_server;
+
+/* A connection. */
+
+typedef struct
+{
+  int initialized;
+  httpd_server *hs;
+  httpd_sockaddr client_addr;
+  char *read_buf;
+  size_t read_size, read_idx, checked_idx;
+  int checked_state;
+  int method;
+  off_t bytes_to_send;
+  off_t bytes_sent;
+  char *encodedurl;
+  char *decodedurl;
+  char *protocol;
+  char *origfilename;
+  char *expnfilename;
+  char *encodings;
+  char *pathinfo;
+  char *query;
+  char *referer;
+  char *useragent;
+  char *accept;
+  char *accepte;
+  char *acceptl;
+  char *cookie;
+  char *contenttype;
+  char *reqhost;
+  char *hdrhost;
+  char *hostdir;
+  char *authorization;
+  char *remoteuser;
+  size_t maxdecodedurl, maxorigfilename, maxexpnfilename, maxencodings,
+    maxpathinfo, maxquery, maxaccept, maxaccepte, maxreqhost, maxhostdir,
+    maxremoteuser, maxresponse;
+#ifdef CONFIG_THTTPD_TILDE_MAP2
+  char *altdir;
+  size_t maxaltdir;
+#endif
+  time_t if_modified_since, range_if;
+  size_t contentlength;
+  char *type;                  /* not malloc()ed */
+#ifdef CONFIG_THTTPD_VHOST
+  char *vhostname;             /* not malloc()ed */
+#endif
+  bool mime_flag;
+  bool one_one;                /* HTTP/1.1 or better */
+  bool got_range;
+  bool tildemapped;            /* this connection got tilde-mapped */
+  bool keep_alive;
+  bool should_linger;
+  int conn_fd;                 /* Connection to the client */
+  int file_fd;                 /* Descriptor for open, outgoing file */
+  off_t range_start;           /* File range start from Range= */
+  off_t range_end;             /* File range end from Range= */
+  struct stat sb;
+
+  /* This is the I/O buffer that is used to buffer portions of outgoing files */
+
+  uint16_t buflen;             /* Index to first valid data in buffer */
+  uint8_t buffer[CONFIG_THTTPD_IOBUFFERSIZE];
+} httpd_conn;
+
+/****************************************************************************
+ * Public Function Prototypes
+ ****************************************************************************/
+
+/* Initializes.  Does the socket(), bind(), and listen().   Returns an
+ * httpd_server* which includes a socket fd that you can select() on.
+ * Return (httpd_server*) 0 on error.
+ */
+
+extern FAR httpd_server *httpd_initialize(FAR httpd_sockaddr *sa);
+
+/* Call to unlisten/close socket(s) listening for new connections. */
+
+extern void httpd_unlisten(httpd_server *hs);
+
+/* Call to shut down. */
+
+extern void httpd_terminate(httpd_server *hs);
+
+/* When a listen fd is ready to read, call this.  It does the accept() and
+ * returns an httpd_conn* which includes the fd to read the request from and
+ * write the response to.  Returns an indication of whether the accept()
+ * failed, succeeded, or if there were no more connections to accept.
+ *
+ * In order to minimize malloc()s, the caller passes in the httpd_conn.
+ * The caller is also responsible for setting initialized to zero before the
+ * first call using each different httpd_conn.
+ */
+
+extern int httpd_get_conn(httpd_server *hs, int listen_fd, httpd_conn *hc);
+
+/* Checks whether the data in hc->read_buf constitutes a complete request
+ * yet.  The caller reads data into hc->read_buf[hc->read_idx] and advances
+ * hc->read_idx.  This routine checks what has been read so far, using
+ * hc->checked_idx and hc->checked_state to keep track, and returns an
+ * indication of whether there is no complete request yet, there is a
+ * complete request, or there won't be a valid request due to a syntax error.
+ */
+
+extern int httpd_got_request(httpd_conn *hc);
+
+/* Parses the request in hc->read_buf.  Fills in lots of fields in hc,
+ * like the URL and the various headers.
+ *
+ * Returns -1 on error.
+ */
+
+extern int httpd_parse_request(httpd_conn *hc);
+
+/* Starts sending data back to the client.  In some cases (directories,
+ * CGI programs), finishes sending by itself - in those cases, hc->file_fd
+ * is negative.  If there is more data to be sent, then hc->file_fd is a file
+ * stream for the file to send.  If you don't have a current timeval
+ * handy just pass in 0.
+ *
+ * Returns -1 on error.
+ */
+
+extern int httpd_start_request(httpd_conn *hc, struct timeval *nowP);
+
+/* Actually sends any buffered response text. */
+
+extern void httpd_write_response(httpd_conn *hc);
+
+/* Call this to close down a connection and free the data. */
+
+extern void httpd_close_conn(httpd_conn *hc);
+
+/* Call this to de-initialize a connection struct and *really* free the
+ * mallocced strings.
+ */
+
+extern void httpd_destroy_conn(httpd_conn *hc);
+
+/* Send an error message back to the client. */
+
+extern void httpd_send_err(httpd_conn *hc, int status, const char *title,
+                           const char *extraheads, const char *form, const char *arg);
+
+/* Generate a string representation of a method number. */
+
+extern const char *httpd_method_str(int method);
+
+/* Format a network socket to a string representation. */
+
+extern char *httpd_ntoa(httpd_sockaddr * saP);
+
+/* Set NDELAY mode on a socket. */
+
+extern void httpd_set_ndelay(int fd);
+
+/* Clear NDELAY mode on a socket. */
+
+extern void httpd_clear_ndelay(int fd);
+
+/* Read to requested buffer, accounting for interruptions and EOF */
+
+extern int httpd_read(int fd, const void *buf, size_t nbytes);
+
+/* Write the buffer completely, accounting for interruptions */
+
+extern int httpd_write(int fd, const void *buf, size_t nbytes);
+
+#endif /* CONFIG_THTTPD */
+#endif /* __NETUTILS_THTTPD_LIBHTTPD_H */
+

netutils/thttpd/mime_types.h

@@ -0,0 +1,279 @@
+/****************************************************************************
+ * netutils/thttpd/mime_types.h
+ * Provides mappings between filename extensions and MIME types and encodings.
+ *
+ * Based on mime_encodings.txt and mime_types.txt by Jef Poskanser which
+ * contained no copyright information.
+ *
+ *   Copyright (C) 2007-2009 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ * 3. Neither the name NuttX nor the names of its contributors may be
+ *    used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ ****************************************************************************/
+
+#ifndef __NETUTILS_THTTPD_MIME_TYPES_H
+#define __NETUTILS_THTTPD_MIME_TYPES_H
+
+/****************************************************************************
+ * Included Files
+ ****************************************************************************/
+
+#include <sys/types.h>
+
+/****************************************************************************
+ * Private Types
+ ****************************************************************************/
+
+struct mime_entry
+{
+  char   *ext;
+  size_t  ext_len;
+  char   *val;
+  size_t  val_len;
+};
+
+/****************************************************************************
+ * Private Data
+ ****************************************************************************/
+
+/* A list of file extensions followed by the corresponding MIME encoding.
+ * Extensions not found in the table proceed to the mime_types table.
+ * Must be ordered by extension so to support binary searches.
+ */
+
+static struct mime_entry enc_tab[] =
+{
+  { "Z",       0, "compress",   0 },
+  { "gz",      0, "gzip",       0 },
+  { "uu",      0, "x-uuencode", 0 },
+};
+static const int n_enc_tab = sizeof(enc_tab) / sizeof(*enc_tab);
+
+/* A list of file extensions followed by the corresponding MIME type.
+ * Extensions not found in the table are returned as text/plain.
+ * Must be ordered by extension so to support binary searches.
+ */
+
+static struct mime_entry typ_tab[] =
+{
+  { "a",       0, "application/octet-stream", 0 },
+  { "aab",     0, "application/x-authorware-bin", 0 },
+  { "aam",     0, "application/x-authorware-map", 0 },
+  { "aas",     0, "application/x-authorware-seg", 0 },
+  { "ai",      0, "application/postscript", 0 },
+  { "aif",     0, "audio/x-aiff", 0 },
+  { "aifc",    0, "audio/x-aiff", 0 },
+  { "aiff",    0, "audio/x-aiff", 0 },
+  { "asc",     0, "text/plain", 0 },
+  { "asf",     0, "video/x-ms-asf", 0 },
+  { "asx",     0, "video/x-ms-asf", 0 },
+  { "au",      0, "audio/basic", 0 },
+  { "avi",     0, "video/x-msvideo", 0 },
+  { "bcpio",   0, "application/x-bcpio", 0 },
+  { "bin",     0, "application/octet-stream", 0 },
+  { "bmp",     0, "image/bmp", 0 },
+  { "cdf",     0, "application/x-netcdf", 0 },
+  { "class",   0, "application/x-java-vm", 0 },
+  { "cpio",    0, "application/x-cpio", 0 },
+  { "cpt",     0, "application/mac-compactpro", 0 },
+  { "crl",     0, "application/x-pkcs7-crl", 0 },
+  { "crt",     0, "application/x-x509-ca-cert", 0 },
+  { "csh",     0, "application/x-csh", 0 },
+  { "css",     0, "text/css", 0 },
+  { "dcr",     0, "application/x-director", 0 },
+  { "dir",     0, "application/x-director", 0 },
+  { "djv",     0, "image/vnd.djvu", 0 },
+  { "djvu",    0, "image/vnd.djvu", 0 },
+  { "dll",     0, "application/octet-stream", 0 },
+  { "dms",     0, "application/octet-stream", 0 },
+  { "doc",     0, "application/msword", 0 },
+  { "dtd",     0, "text/xml", 0 },
+  { "dump",    0, "application/octet-stream", 0 },
+  { "dvi",     0, "application/x-dvi", 0 },
+  { "dxr",     0, "application/x-director", 0 },
+  { "eps",     0, "application/postscript", 0 },
+  { "etx",     0, "text/x-setext", 0 },
+  { "exe",     0, "application/octet-stream", 0 },
+  { "ez",      0, "application/andrew-inset", 0 },
+  { "fgd",     0, "application/x-director", 0 },
+  { "fh",      0, "image/x-freehand", 0 },
+  { "fh4",     0, "image/x-freehand", 0 },
+  { "fh5",     0, "image/x-freehand", 0 },
+  { "fh7",     0, "image/x-freehand", 0 },
+  { "fhc",     0, "image/x-freehand", 0 },
+  { "gif",     0, "image/gif", 0 },
+  { "gtar",    0, "application/x-gtar", 0 },
+  { "hdf",     0, "application/x-hdf", 0 },
+  { "hqx",     0, "application/mac-binhex40", 0 },
+  { "htm",     0, "text/html; charset=%s", 0 },
+  { "html",    0, "text/html; charset=%s", 0 },
+  { "ice",     0, "x-conference/x-cooltalk", 0 },
+  { "ief",     0, "image/ief", 0 },
+  { "iges",    0, "model/iges", 0 },
+  { "igs",     0, "model/iges", 0 },
+  { "iv",      0, "application/x-inventor", 0 },
+  { "jar",     0, "application/x-java-archive", 0 },
+  { "jfif",    0, "image/jpeg", 0 },
+  { "jpe",     0, "image/jpeg", 0 },
+  { "jpeg",    0, "image/jpeg", 0 },
+  { "jpg",     0, "image/jpeg", 0 },
+  { "js",      0, "application/x-javascript", 0 },
+  { "kar",     0, "audio/midi", 0 },
+  { "latex",   0, "application/x-latex", 0 },
+  { "lha",     0, "application/octet-stream", 0 },
+  { "lzh",     0, "application/octet-stream", 0 },
+  { "m3u",     0, "audio/x-mpegurl", 0 },
+  { "man",     0, "application/x-troff-man", 0 },
+  { "mathml",  0, "application/mathml+xml", 0 },
+  { "me",      0, "application/x-troff-me", 0 },
+  { "mesh",    0, "model/mesh", 0 },
+  { "mid",     0, "audio/midi", 0 },
+  { "midi",    0, "audio/midi", 0 },
+  { "mif",     0, "application/vnd.mif", 0 },
+  { "mime",    0, "message/rfc822", 0 },
+  { "mml",     0, "application/mathml+xml", 0 },
+  { "mov",     0, "video/quicktime", 0 },
+  { "movie",   0, "video/x-sgi-movie", 0 },
+  { "mp2",     0, "audio/mpeg", 0 },
+  { "mp3",     0, "audio/mpeg", 0 },
+  { "mp4",     0, "video/mp4", 0 },
+  { "mpe",     0, "video/mpeg", 0 },
+  { "mpeg",    0, "video/mpeg", 0 },
+  { "mpg",     0, "video/mpeg", 0 },
+  { "mpga",    0, "audio/mpeg", 0 },
+  { "ms",      0, "application/x-troff-ms", 0 },
+  { "msh",     0, "model/mesh", 0 },
+  { "mv",      0, "video/x-sgi-movie", 0 },
+  { "mxu",     0, "video/vnd.mpegurl", 0 },
+  { "nc",      0, "application/x-netcdf", 0 },
+  { "o",       0, "application/octet-stream", 0 },
+  { "oda",     0, "application/oda", 0 },
+  { "ogg",     0, "application/x-ogg", 0 },
+  { "pac",     0, "application/x-ns-proxy-autoconfig", 0 },
+  { "pbm",     0, "image/x-portable-bitmap", 0 },
+  { "pdb",     0, "chemical/x-pdb", 0 },
+  { "pdf",     0, "application/pdf", 0 },
+  { "pgm",     0, "image/x-portable-graymap", 0 },
+  { "pgn",     0, "application/x-chess-pgn", 0 },
+  { "png",     0, "image/png", 0 },
+  { "pnm",     0, "image/x-portable-anymap", 0 },
+  { "ppm",     0, "image/x-portable-pixmap", 0 },
+  { "ppt",     0, "application/vnd.ms-powerpoint", 0 },
+  { "ps",      0, "application/postscript", 0 },
+  { "qt",      0, "video/quicktime", 0 },
+  { "ra",      0, "audio/x-realaudio", 0 },
+  { "ram",     0, "audio/x-pn-realaudio", 0 },
+  { "ras",     0, "image/x-cmu-raster", 0 },
+  { "rdf",     0, "application/rdf+xml", 0 },
+  { "rgb",     0, "image/x-rgb", 0 },
+  { "rm",      0, "audio/x-pn-realaudio", 0 },
+  { "roff",    0, "application/x-troff", 0 },
+  { "rpm",     0, "audio/x-pn-realaudio-plugin", 0 },
+  { "rss",     0, "application/rss+xml", 0 },
+  { "rtf",     0, "text/rtf", 0 },
+  { "rtx",     0, "text/richtext", 0 },
+  { "sgm",     0, "text/sgml", 0 },
+  { "sgml",    0, "text/sgml", 0 },
+  { "sh",      0, "application/x-sh", 0 },
+  { "shar",    0, "application/x-shar", 0 },
+  { "silo",    0, "model/mesh", 0 },
+  { "sit",     0, "application/x-stuffit", 0 },
+  { "skd",     0, "application/x-koan", 0 },
+  { "skm",     0, "application/x-koan", 0 },
+  { "skp",     0, "application/x-koan", 0 },
+  { "skt",     0, "application/x-koan", 0 },
+  { "smi",     0, "application/smil", 0 },
+  { "smil",    0, "application/smil", 0 },
+  { "snd",     0, "audio/basic", 0 },
+  { "so",      0, "application/octet-stream", 0 },
+  { "spl",     0, "application/x-futuresplash", 0 },
+  { "src",     0, "application/x-wais-source", 0 },
+  { "stc",     0, "application/vnd.sun.xml.calc.template", 0 },
+  { "std",     0, "application/vnd.sun.xml.draw.template", 0 },
+  { "sti",     0, "application/vnd.sun.xml.impress.template", 0 },
+  { "stw",     0, "application/vnd.sun.xml.writer.template", 0 },
+  { "sv4cpio", 0, "application/x-sv4cpio", 0 },
+  { "sv4crc",  0, "application/x-sv4crc", 0 },
+  { "svg",     0, "image/svg+xml", 0 },
+  { "svgz",    0, "image/svg+xml", 0 },
+  { "swf",     0, "application/x-shockwave-flash", 0 },
+  { "sxc",     0, "application/vnd.sun.xml.calc", 0 },
+  { "sxd",     0, "application/vnd.sun.xml.draw", 0 },
+  { "sxg",     0, "application/vnd.sun.xml.writer.global", 0 },
+  { "sxi",     0, "application/vnd.sun.xml.impress", 0 },
+  { "sxm",     0, "application/vnd.sun.xml.math", 0 },
+  { "sxw",     0, "application/vnd.sun.xml.writer", 0 },
+  { "t",       0, "application/x-troff", 0 },
+  { "tar",     0, "application/x-tar", 0 },
+  { "tcl",     0, "application/x-tcl", 0 },
+  { "tex",     0, "application/x-tex", 0 },
+  { "texi",    0, "application/x-texinfo", 0 },
+  { "texinfo", 0, "application/x-texinfo", 0 },
+  { "tif",     0, "image/tiff", 0 },
+  { "tiff",    0, "image/tiff", 0 },
+  { "tr",      0, "application/x-troff", 0 },
+  { "tsp",     0, "application/dsptype", 0 },
+  { "tsv",     0, "text/tab-separated-values", 0 },
+  { "txt",     0, "text/plain; charset=%s", 0 },
+  { "ustar",   0, "application/x-ustar", 0 },
+  { "vcd",     0, "application/x-cdlink", 0 },
+  { "vrml",    0, "model/vrml", 0 },
+  { "vx",      0, "video/x-rad-screenplay", 0 },
+  { "wav",     0, "audio/x-wav", 0 },
+  { "wax",     0, "audio/x-ms-wax", 0 },
+  { "wbmp",    0, "image/vnd.wap.wbmp", 0 },
+  { "wbxml",   0, "application/vnd.wap.wbxml", 0 },
+  { "wm",      0, "video/x-ms-wm", 0 },
+  { "wma",     0, "audio/x-ms-wma", 0 },
+  { "wmd",     0, "application/x-ms-wmd", 0 },
+  { "wml",     0, "text/vnd.wap.wml", 0 },
+  { "wmlc",    0, "application/vnd.wap.wmlc", 0 },
+  { "wmls",    0, "text/vnd.wap.wmlscript", 0 },
+  { "wmlsc",   0, "application/vnd.wap.wmlscriptc", 0 },
+  { "wmv",     0, "video/x-ms-wmv", 0 },
+  { "wmx",     0, "video/x-ms-wmx", 0 },
+  { "wmz",     0, "application/x-ms-wmz", 0 },
+  { "wrl",     0, "model/vrml", 0 },
+  { "wsrc",    0, "application/x-wais-source", 0 },
+  { "wvx",     0, "video/x-ms-wvx", 0 },
+  { "xbm",     0, "image/x-xbitmap", 0 },
+  { "xht",     0, "application/xhtml+xml", 0 },
+  { "xhtml",   0, "application/xhtml+xml", 0 },
+  { "xls",     0, "application/vnd.ms-excel", 0 },
+  { "xml",     0, "text/xml", 0 },
+  { "xpm",     0, "image/x-xpixmap", 0 },
+  { "xsl",     0, "text/xml", 0 },
+  { "xwd",     0, "image/x-xwindowdump", 0 },
+  { "xyz",     0, "chemical/x-xyz", 0 },
+  { "zip",     0, "application/zip", 0 },
+};
+static const int n_typ_tab = sizeof(typ_tab) / sizeof(*typ_tab);
+
+#endif /* __NETUTILS_THTTPD_MIME_TYPES_H */
+

netutils/thttpd/tdate_parse.c

@@ -0,0 +1,341 @@
+/****************************************************************************
+ * netutils/thttpd/timers.c
+ * Parse string dates into internal form, stripped-down version
+ *
+ *   Copyright (C) 2009 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * Derived from the file of the same name in the original THTTPD package:
+ *
+ *   Copyright © 1995 by Jef Poskanzer <jef@mail.acme.com>.
+ *   All rights reserved.
+ *
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <time.h>
+#include <debug.h>
+
+#include "tdate_parse.h"
+
+/****************************************************************************
+ * Private Types
+ ****************************************************************************/
+
+#undef TDATE_PARSE_WORKS /* tdate_parse() doesn't work */
+#undef HAVE_DAY_OF_WEEK  /* Day of week not yet supported by NuttX */
+
+/****************************************************************************
+ * Private Types
+ ****************************************************************************/
+
+struct strlong
+{
+  char *s;
+  long l;
+};
+
+/****************************************************************************
+ * Private Functions
+ ****************************************************************************/
+
+#ifdef HAVE_DAY_OF_WEEK /* Day of week not yet supported by NuttX */
+static void pound_case(char *str)
+{
+  for (; *str != '\0'; ++str)
+    {
+      if (isupper((int)*str))
+        {
+          *str = tolower((int)*str);
+        }
+    }
+}
+#endif
+
+#ifdef HAVE_DAY_OF_WEEK /* Day of week not yet supported by NuttX */
+static int strlong_compare(const void *v1, const void *v2)
+{
+  return strcmp(((struct strlong *)v1)->s, ((struct strlong *)v2)->s);
+}
+#endif
+
+#ifdef HAVE_DAY_OF_WEEK /* Day of week not yet supported by NuttX */
+static int strlong_search(char *str, struct strlong *tab, int n, long *lP)
+{
+  int i, h, l, r;
+
+  l = 0;
+  h = n - 1;
+  for (;;)
+    {
+      i = (h + l) / 2;
+      r = strcmp(str, tab[i].s);
+      if (r < 0)
+        {
+          h = i - 1;
+        }
+      else if (r > 0)
+        {
+          l = i + 1;
+        }
+      else
+        {
+          *lP = tab[i].l;
+          return 1;
+        }
+
+      if (h < l)
+        {
+          return 0;
+        }
+    }
+}
+#endif
+
+#ifdef HAVE_DAY_OF_WEEK /* Day of week not yet supported by NuttX */
+static int scan_wday(char *str_wday, long *tm_wdayP)
+{
+  static struct strlong wday_tab[] = {
+    {"sun", 0}, {"sunday", 0},
+    {"mon", 1}, {"monday", 1},
+    {"tue", 2}, {"tuesday", 2},
+    {"wed", 3}, {"wednesday", 3},
+    {"thu", 4}, {"thursday", 4},
+    {"fri", 5}, {"friday", 5},
+    {"sat", 6}, {"saturday", 6},
+  };
+  static int sorted = 0;
+
+  if (!sorted)
+    {
+      (void)qsort(wday_tab, sizeof(wday_tab) / sizeof(struct strlong),
+                  sizeof(struct strlong), strlong_compare);
+      sorted = 1;
+    }
+  pound_case(str_wday);
+  return strlong_search(str_wday, wday_tab,
+                        sizeof(wday_tab) / sizeof(struct strlong), tm_wdayP);
+}
+#endif /* Day of week not yet supported by NuttX */
+
+#ifdef TDATE_PARSE_WORKS
+static int scan_mon(char *str_mon, long *tm_monP)
+{
+  static struct strlong mon_tab[] = {
+    {"jan", 0}, {"january", 0},
+    {"feb", 1}, {"february", 1},
+    {"mar", 2}, {"march", 2},
+    {"apr", 3}, {"april", 3},
+    {"may", 4},
+    {"jun", 5}, {"june", 5},
+    {"jul", 6}, {"july", 6},
+    {"aug", 7}, {"august", 7},
+    {"sep", 8}, {"september", 8},
+    {"oct", 9}, {"october", 9},
+    {"nov", 10}, {"november", 10},
+    {"dec", 11}, {"december", 11},
+  };
+  static int sorted = 0;
+
+  if (!sorted)
+    {
+      (void)qsort(mon_tab, sizeof(mon_tab) / sizeof(struct strlong),
+                  sizeof(struct strlong), strlong_compare);
+      sorted = 1;
+    }
+  pound_case(str_mon);
+  return strlong_search(str_mon, mon_tab,
+                        sizeof(mon_tab) / sizeof(struct strlong), tm_monP);
+}
+#endif
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
+
+time_t tdate_parse(char *str)
+{
+#ifdef TDATE_PARSE_WORKS /* REVISIT -- doesn't work */
+  struct tm tm;
+  char *cp;
+  char str_mon[32];
+  int tm_year;
+  int tm_mday;
+  int tm_hour;
+  int tm_min;
+  int tm_sec;
+  long tm_mon;
+#ifdef HAVE_DAY_OF_WEEK /* Day of week not yet supported by NuttX */
+  char str_wday[32];
+  long tm_wday;
+#endif
+
+  nvdbg("str: \"%s\"\n", str);
+
+  /* Initialize. */
+
+  (void)memset((char *)&tm, 0, sizeof(struct tm));
+
+  /* Skip initial whitespace ourselves - sscanf is clumsy at this. */
+
+  for (cp = str; *cp == ' ' || *cp == '\t'; ++cp)
+    {
+      continue;
+    }
+
+  /* And do the sscanfs.  WARNING: you can add more formats here, but be
+   * careful! You can easily screw up the parsing of existing formats when
+   * you add new ones.  The order is important. */
+
+  /* DD-mth-YY HH:MM:SS GMT */
+  if (sscanf(cp, "%d-%400[a-zA-Z]-%d %d:%d:%d GMT",
+             &tm_mday, str_mon, &tm_year, &tm_hour, &tm_min,
+             &tm_sec) == 6 && scan_mon(str_mon, &tm_mon))
+    {
+      tm.tm_mday = tm_mday;
+      tm.tm_mon  = tm_mon;
+      tm.tm_year = tm_year;
+      tm.tm_hour = tm_hour;
+      tm.tm_min  = tm_min;
+      tm.tm_sec  = tm_sec;
+    }
+
+  /* DD mth YY HH:MM:SS GMT */
+  else if (sscanf(cp, "%d %400[a-zA-Z] %d %d:%d:%d GMT",
+                  &tm_mday, str_mon, &tm_year, &tm_hour, &tm_min,
+                  &tm_sec) == 6 && scan_mon(str_mon, &tm_mon))
+    {
+      tm.tm_mday = tm_mday;
+      tm.tm_mon  = tm_mon;
+      tm.tm_year = tm_year;
+      tm.tm_hour = tm_hour;
+      tm.tm_min  = tm_min;
+      tm.tm_sec  = tm_sec;
+    }
+
+  /* HH:MM:SS GMT DD-mth-YY */
+  else if (sscanf(cp, "%d:%d:%d GMT %d-%400[a-zA-Z]-%d",
+                  &tm_hour, &tm_min, &tm_sec, &tm_mday, str_mon,
+                  &tm_year) == 6 && scan_mon(str_mon, &tm_mon))
+    {
+      tm.tm_hour = tm_hour;
+      tm.tm_min  = tm_min;
+      tm.tm_sec  = tm_sec;
+      tm.tm_mday = tm_mday;
+      tm.tm_mon  = tm_mon;
+      tm.tm_year = tm_year;
+    }
+
+  /* HH:MM:SS GMT DD mth YY */
+  else if (sscanf(cp, "%d:%d:%d GMT %d %400[a-zA-Z] %d",
+                  &tm_hour, &tm_min, &tm_sec, &tm_mday, str_mon,
+                  &tm_year) == 6 && scan_mon(str_mon, &tm_mon))
+    {
+      tm.tm_hour = tm_hour;
+      tm.tm_min  = tm_min;
+      tm.tm_sec  = tm_sec;
+      tm.tm_mday = tm_mday;
+      tm.tm_mon  = tm_mon;
+      tm.tm_year = tm_year;
+    }
+
+#ifdef HAVE_DAY_OF_WEEK /* Day of week not yet supported by NuttX */
+  /* wdy, DD-mth-YY HH:MM:SS GMT */
+  else if (sscanf(cp, "%400[a-zA-Z], %d-%400[a-zA-Z]-%d %d:%d:%d GMT",
+                  str_wday, &tm_mday, str_mon, &tm_year, &tm_hour, &tm_min,
+                  &tm_sec) == 7 &&
+           scan_wday(str_wday, &tm_wday) && scan_mon(str_mon, &tm_mon))
+    {
+      tm.tm_wday = tm_wday;
+      tm.tm_mday = tm_mday;
+      tm.tm_mon  = tm_mon;
+      tm.tm_year = tm_year;
+      tm.tm_hour = tm_hour;
+      tm.tm_min  = tm_min;
+      tm.tm_sec  = tm_sec;
+    }
+#endif /* Day of week not yet supported by NuttX */
+
+#ifdef HAVE_DAY_OF_WEEK /* Day of week not yet supported by NuttX */
+  /* wdy, DD mth YY HH:MM:SS GMT */
+  else if (sscanf(cp, "%400[a-zA-Z], %d %400[a-zA-Z] %d %d:%d:%d GMT",
+                  str_wday, &tm_mday, str_mon, &tm_year, &tm_hour, &tm_min,
+                  &tm_sec) == 7 &&
+           scan_wday(str_wday, &tm_wday) && scan_mon(str_mon, &tm_mon))
+    {
+      tm.tm_wday = tm_wday;
+      tm.tm_mday = tm_mday;
+      tm.tm_mon  = tm_mon;
+      tm.tm_year = tm_year;
+      tm.tm_hour = tm_hour;
+      tm.tm_min  = tm_min;
+      tm.tm_sec  = tm_sec;
+    }
+#endif /* Day of week not yet supported by NuttX */
+
+#ifdef HAVE_DAY_OF_WEEK /* Day of week not yet supported by NuttX */
+  /* wdy mth DD HH:MM:SS GMT YY */
+  else if (sscanf(cp, "%400[a-zA-Z] %400[a-zA-Z] %d %d:%d:%d GMT %d",
+                  str_wday, str_mon, &tm_mday, &tm_hour, &tm_min, &tm_sec,
+                  &tm_year) == 7 &&
+           scan_wday(str_wday, &tm_wday) && scan_mon(str_mon, &tm_mon))
+    {
+      tm.tm_wday = tm_wday;
+      tm.tm_mon  = tm_mon;
+      tm.tm_mday = tm_mday;
+      tm.tm_hour = tm_hour;
+      tm.tm_min  = tm_min;
+      tm.tm_sec  = tm_sec;
+      tm.tm_year = tm_year;
+    }
+#endif /* Day of week not yet supported by NuttX */
+  else
+    {
+      return (time_t) - 1;
+    }
+
+  if (tm.tm_year > 1900)
+    {
+      tm.tm_year -= 1900;
+    }
+  else if (tm.tm_year < 70)
+    {
+      tm.tm_year += 100;
+    }
+
+  return mktime(&tm);
+#else
+  return 0; // for now
+#endif
+}
+

netutils/thttpd/tdate_parse.h

@@ -0,0 +1,41 @@
+/****************************************************************************
+ * netutils/thttpd/fdwatch.h
+ *
+ *   Copyright (C) 2009 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * Derived from the file of the same name in THTTPD:
+ *
+ *   Copyright © 1995 by Jef Poskanzer <jef@mail.acme.com>.
+ *   All rights reserved.
+ *
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ ****************************************************************************/
+
+#ifndef __NETUTILS_TDATE_PARSE_H
+#define __NETUTILS_TDATE_PARSE_H
+
+extern time_t tdate_parse(char *str);
+
+#endif  /* __NETUTILS_TDATE_PARSE_H */

netutils/thttpd/thttpd.c

@@ -0,0 +1,861 @@
+/****************************************************************************
+ * netutils/thttpd/thttpd.c
+ * Tiny HTTP Server
+ *
+ *   Copyright (C) 2009, 2011 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * Derived from the file of the same name in the original THTTPD package:
+ *
+ *   Copyright © 1995,1998,1999,2000,2001 by Jef Poskanzer <jef@mail.acme.com>.
+ *   All rights reserved.
+ *
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <errno.h>
+#include <debug.h>
+
+#include <nuttx/compiler.h>
+#include <nuttx/symtab.h>
+#include <apps/netutils/thttpd.h>
+
+#include "config.h"
+#include "fdwatch.h"
+#include "libhttpd.h"
+#include "thttpd_alloc.h"
+#include "thttpd_strings.h"
+#include "timers.h"
+
+#ifdef CONFIG_THTTPD
+
+/****************************************************************************
+ * Pre-processor Definitions
+ ****************************************************************************/
+
+#ifndef MAXPATHLEN
+#  define MAXPATHLEN 64
+#endif
+
+/* The connection states */
+
+#define CNST_FREE      0
+#define CNST_READING   1
+#define CNST_SENDING   2
+#define CNST_LINGERING 3
+
+#define SPARE_FDS      2
+#define AVAILABLE_FDS  (CONFIG_NSOCKET_DESCRIPTORS - SPARE_FDS)
+
+/****************************************************************************
+ * Private Types
+ ****************************************************************************/
+
+struct connect_s
+{
+  struct connect_s *next;
+  int conn_state;
+  httpd_conn *hc;
+  time_t active_at;
+  Timer *wakeup_timer;
+  Timer *linger_timer;
+  off_t end_offset;            /* The final offset+1 of the file to send */
+  off_t offset;                /* The current offset into the file to send */
+  bool eof;                    /* Set true when length==0 read from file */
+};
+
+/****************************************************************************
+ * Private Data
+ ****************************************************************************/
+
+static httpd_server *hs;
+static struct connect_s *free_connections;
+static struct connect_s *connects;
+static struct fdwatch_s *fw;
+
+/****************************************************************************
+ * Public Data
+ ****************************************************************************/
+
+/****************************************************************************
+ * Private Function Prototypes
+ ****************************************************************************/
+
+static void shut_down(void);
+static int  handle_newconnect(struct timeval *tv, int listen_fd);
+static void handle_read(struct connect_s *conn, struct timeval *tv);
+static void handle_send(struct connect_s *conn, struct timeval *tv);
+static void handle_linger(struct connect_s *conn, struct timeval *tv);
+static void finish_connection(struct connect_s *conn, struct timeval *tv);
+static void clear_connection(struct connect_s *conn, struct timeval *tv);
+static void really_clear_connection(struct connect_s *conn);
+static void idle(ClientData client_data, struct timeval *nowP);
+static void linger_clear_connection(ClientData client_data, struct timeval *nowP);
+static void occasional(ClientData client_data, struct timeval *nowP);
+
+/****************************************************************************
+ * Private Functions
+ ****************************************************************************/
+
+static void shut_down(void)
+{
+  int cnum;
+
+  for (cnum = 0; cnum < AVAILABLE_FDS; ++cnum)
+    {
+      if (connects[cnum].conn_state != CNST_FREE)
+        {
+          httpd_close_conn(connects[cnum].hc);
+        }
+
+      if (connects[cnum].hc != NULL)
+        {
+          httpd_destroy_conn(connects[cnum].hc);
+          httpd_free((void *)connects[cnum].hc);
+          connects[cnum].hc = NULL;
+        }
+    }
+
+  if (hs)
+    {
+      httpd_server *ths = hs;
+      hs = NULL;
+      if (ths->listen_fd != -1)
+        {
+          fdwatch_del_fd(fw, ths->listen_fd);
+        }
+      httpd_terminate(ths);
+    }
+
+  tmr_destroy();
+  httpd_free((void *)connects);
+}
+
+static int handle_newconnect(struct timeval *tv, int listen_fd)
+{
+  struct connect_s *conn;
+  ClientData client_data;
+
+  /* This loops until the accept() fails, trying to start new connections as 
+   * fast as possible so we don't overrun the listen queue.
+   */
+
+  nvdbg("New connection(s) on listen_fd %d\n", listen_fd);
+  for (;;)
+    {
+      /* Get the next free connection from the free list */
+
+      conn = free_connections;
+      
+      /* Are there any free connections? */
+
+      if (!conn)
+        {
+          /* Out of connection slots.  Run the timers, then the  existing
+           * connections, and maybe we'll free up a slot  by the time we get
+           * back here.
+           */
+
+          ndbg("No free connections\n");
+          tmr_run(tv);
+          return -1;
+        }
+
+      /* Make the httpd_conn if necessary */
+
+      if (!conn->hc)
+        {
+          conn->hc = NEW(httpd_conn, 1);
+          if (conn->hc == NULL)
+            {
+              ndbg("out of memory allocating an httpd_conn\n");
+              exit(1);
+            }
+
+          conn->hc->initialized = 0;
+        }
+
+      /* Get the connection */
+
+      switch (httpd_get_conn(hs, listen_fd, conn->hc))
+        {
+          /* Some error happened.  Run the timers, then the  existing
+           * connections.  Maybe the error will clear.
+           */
+
+        case GC_FAIL:
+          tmr_run(tv);
+          return -1;
+
+          /* No more connections to accept for now */
+
+        case GC_NO_MORE:
+          return 0;
+
+        default:
+          break;
+        }
+
+      nvdbg("New connection fd %d\n", conn->hc->conn_fd);
+ 
+      /* Remove the connection entry from the free list */
+
+      conn->conn_state        = CNST_READING;
+      free_connections        = conn->next;
+      conn->next              = NULL;
+
+      client_data.p           = conn;
+      conn->active_at         = tv->tv_sec;
+      conn->wakeup_timer      = NULL;
+      conn->linger_timer      = NULL;
+      conn->offset            = 0;
+ 
+      /* Set the connection file descriptor to no-delay mode */
+
+      httpd_set_ndelay(conn->hc->conn_fd);
+      fdwatch_add_fd(fw, conn->hc->conn_fd, conn);
+    }
+}
+
+static void handle_read(struct connect_s *conn, struct timeval *tv)
+{
+  ClientData client_data;
+  httpd_conn *hc = conn->hc;
+  off_t actual;
+  int sz;
+
+  /* Is there room in our buffer to read more bytes? */
+
+  if (hc->read_idx >= hc->read_size)
+    {
+      if (hc->read_size > CONFIG_THTTPD_MAXREALLOC)
+        {
+          BADREQUEST("MAXREALLOC");
+          goto errout_with_400;
+        }
+      httpd_realloc_str(&hc->read_buf, &hc->read_size, hc->read_size + CONFIG_THTTPD_REALLOCINCR);
+    }
+
+  /* Read some more bytes */
+
+  sz = read(hc->conn_fd, &(hc->read_buf[hc->read_idx]), hc->read_size - hc->read_idx);
+  if (sz == 0)
+    {
+      BADREQUEST("EOF");
+      goto errout_with_400;
+    }
+
+  if (sz < 0)
+    {
+      /* Ignore EINTR and EAGAIN.  Also ignore EWOULDBLOCK.  At first glance
+       * you would think that connections returned by fdwatch as readable
+       * should never give an EWOULDBLOCK; however, this apparently can
+       * happen if a packet gets garbled.
+       */
+
+      if (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK)
+        {
+          return;
+        }
+ 
+      ndbg("read(fd=%d) failed: %d\n", hc->conn_fd, errno);
+      BADREQUEST("read");
+      goto errout_with_400;
+    }
+
+  hc->read_idx += sz;
+  conn->active_at = tv->tv_sec;
+
+  /* Do we have a complete request yet? */
+
+  switch (httpd_got_request(hc))
+    {
+    case GR_NO_REQUEST:
+      return;
+    case GR_BAD_REQUEST:
+     BADREQUEST("httpd_got_request");
+     goto errout_with_400;
+    }
+
+  /* Yes.  Try parsing and resolving it */
+
+  if (httpd_parse_request(hc) < 0)
+    {
+      goto errout_with_connection;
+    }
+
+  /* Start the connection going */
+
+  if (httpd_start_request(hc, tv) < 0)
+    {
+      /* Something went wrong.  Close down the connection */
+
+      goto errout_with_connection;
+    }
+
+  /* Set up the file offsets to read */
+
+  conn->eof            = false;
+  if (hc->got_range)
+    {
+      conn->offset     = hc->range_start;
+      conn->end_offset = hc->range_end + 1;
+    }
+  else
+    {
+      conn->offset     = 0;
+      if (hc->bytes_to_send < 0)
+        {
+          conn->end_offset = 0;
+        }
+      else
+        {
+          conn->end_offset = hc->bytes_to_send;
+        }
+    }
+
+  /* Check if it's already handled */
+
+  if (hc->file_fd < 0)
+    {
+      /* No file descriptor means someone else is handling it */
+
+      conn->offset = hc->bytes_sent;
+      goto errout_with_connection;
+    }
+
+  if (conn->offset >= conn->end_offset)
+    {
+      /* There's nothing to send */
+
+      goto errout_with_connection;
+    }
+
+  /* Seek to the offset of the next byte to send */
+
+  actual = lseek(hc->file_fd, conn->offset, SEEK_SET);
+  if (actual != conn->offset)
+    {
+       ndbg("fseek to %d failed: offset=%d errno=%d\n", conn->offset, actual, errno);
+       BADREQUEST("lseek");
+       goto errout_with_400;
+    }
+
+  /* We have a valid connection and a file to send to it */
+
+  conn->conn_state = CNST_SENDING;
+  client_data.p    = conn;
+  fdwatch_del_fd(fw, hc->conn_fd);
+  return;
+
+errout_with_400:
+  BADREQUEST("errout");
+  httpd_send_err(hc, 400, httpd_err400title, "", httpd_err400form, "");
+
+errout_with_connection:
+  finish_connection(conn, tv);
+  return;
+}
+
+static inline int read_buffer(struct connect_s *conn)
+{
+  httpd_conn *hc = conn->hc;
+  ssize_t nread = 0;
+
+  if (hc->buflen < CONFIG_THTTPD_IOBUFFERSIZE && !conn->eof)
+    {
+      nread = read(hc->file_fd, &hc->buffer[hc->buflen],
+                   CONFIG_THTTPD_IOBUFFERSIZE - hc->buflen);
+      if (nread == 0)
+        {
+          /* Reading zero bytes means we are at the end of file */
+
+          conn->end_offset = conn->offset;
+          conn->eof        = true;
+        }
+      else if (nread > 0)
+        {
+          hc->buflen      += nread;
+        }
+    }
+  return nread;
+}
+
+static void handle_send(struct connect_s *conn, struct timeval *tv)
+{
+  httpd_conn *hc = conn->hc;
+  int nwritten;
+  int nread;
+
+  /* Read until the entire file is sent -- this could take awhile!! */
+
+  while (conn->offset < conn->end_offset)
+    {
+      nvdbg("offset: %d end_offset: %d bytes_sent: %d\n",
+            conn->offset, conn->end_offset, conn->hc->bytes_sent);
+
+      /* Fill the rest of the response buffer with file data */
+
+      nread = read_buffer(conn);
+      if (nread < 0)
+        {
+          ndbg("File read error: %d\n", errno);
+          goto errout_clear_connection;
+        }
+      nvdbg("Read %d bytes, buflen %d\n", nread, hc->buflen);
+
+      /* Send the buffer */
+
+      if (hc->buflen > 0)
+        {
+          /* httpd_write does not return until all bytes have been sent
+           * (or an error occurs).
+           */
+ 
+          nwritten = httpd_write(hc->conn_fd, hc->buffer, hc->buflen);
+          if (nwritten < 0)
+            {
+              ndbg("Error sending %s: %d\n", hc->encodedurl, errno);
+              goto errout_clear_connection;
+            }
+
+          /* We wrote one full buffer of data (httpd_write does not
+           * return until the full buffer is written (or an error occurs).
+           */
+
+          conn->active_at       = tv->tv_sec;
+          hc->buflen            = 0;
+
+          /* And update how much of the file we wrote */
+
+          conn->offset         += nwritten;
+          conn->hc->bytes_sent += nwritten;
+          nvdbg("Wrote %d bytes\n", nwritten);
+        }
+    }
+
+  /* The file transfer is complete -- finish the connection */
+
+  nvdbg("Finish connection\n");
+  finish_connection(conn, tv);
+  return;
+
+errout_clear_connection:
+  ndbg("Clear connection\n");
+  clear_connection(conn, tv);
+  return;
+}
+
+static void handle_linger(struct connect_s *conn, struct timeval *tv)
+{
+  httpd_conn *hc = conn->hc;
+  int ret;
+
+    /* In lingering-close mode we just read and ignore bytes.  An error or EOF 
+   * ends things, otherwise we go until a timeout 
+   */
+
+  ret = read(conn->hc->conn_fd, hc->buffer, CONFIG_THTTPD_IOBUFFERSIZE);
+  if (ret < 0 && (errno == EINTR || errno == EAGAIN))
+    {
+      return;
+    }
+
+  if (ret <= 0)
+    {
+      really_clear_connection(conn);
+    }
+}
+
+static void finish_connection(struct connect_s *conn, struct timeval *tv)
+{
+  /* If we haven't actually sent the buffered response yet, do so now */
+
+  httpd_write_response(conn->hc);
+
+  /* And clear */
+
+  clear_connection(conn, tv);
+}
+
+static void clear_connection(struct connect_s *conn, struct timeval *tv)
+{
+  ClientData client_data;
+
+  if (conn->wakeup_timer != NULL)
+    {
+      tmr_cancel(conn->wakeup_timer);
+      conn->wakeup_timer = 0;
+    }
+
+  /* This is our version of Apache's lingering_close() routine, which is
+   * their version of the often-broken SO_LINGER socket option.  For why
+   * this is necessary, see http://www.apache.org/docs/misc/fin_wait_2.html
+   * What we do is delay the actual closing for a few seconds, while reading
+   * any bytes that come over the connection.  However, we don't want to do
+   * this unless it's necessary, because it ties up a connection slot and
+   * file descriptor which means our maximum connection-handling rateis
+   * lower.  So, elsewhere we set a flag when we detect the few
+   * circumstances that make a lingering close necessary.  If the flag isn't 
+   * set we do the real close now.
+   */
+
+  if (conn->conn_state == CNST_LINGERING)
+    {
+      /* If we were already lingering, shut down for real */
+
+      tmr_cancel(conn->linger_timer);
+      conn->linger_timer      = NULL;
+      conn->hc->should_linger = false;
+    }
+  else if (conn->hc->should_linger)
+    {
+      fdwatch_del_fd(fw, conn->hc->conn_fd);
+      conn->conn_state = CNST_LINGERING;
+      fdwatch_add_fd(fw, conn->hc->conn_fd, conn);
+      client_data.p = conn;
+
+      conn->linger_timer = tmr_create(tv, linger_clear_connection, client_data,
+                                      CONFIG_THTTPD_LINGER_MSEC, 0);
+      if (conn->linger_timer != NULL)
+        {
+          return;
+        }
+      ndbg("tmr_create(linger_clear_connection) failed\n");
+    }
+
+  /* Either we are done lingering, we shouldn't linger, or we failed to setup the linger */
+
+  really_clear_connection(conn);
+}
+
+static void really_clear_connection(struct connect_s *conn)
+{
+  fdwatch_del_fd(fw, conn->hc->conn_fd);
+  httpd_close_conn(conn->hc);
+  if (conn->linger_timer != NULL)
+    {
+      tmr_cancel(conn->linger_timer);
+      conn->linger_timer = 0;
+    }
+
+  /* Put the connection structure back on the free list */
+
+  conn->conn_state  = CNST_FREE;
+  conn->next        = free_connections;
+  free_connections  = conn;
+}
+
+static void idle(ClientData client_data, struct timeval *nowP)
+{
+  int cnum;
+  struct connect_s *conn;
+
+  for (cnum = 0; cnum < AVAILABLE_FDS; ++cnum)
+    {
+      conn = &connects[cnum];
+      switch (conn->conn_state)
+        {
+        case CNST_READING:
+          if (nowP->tv_sec - conn->active_at >= CONFIG_THTTPD_IDLE_READ_LIMIT_SEC)
+            {
+              ndbg("%s connection timed out reading\n", httpd_ntoa(&conn->hc->client_addr));
+              httpd_send_err(conn->hc, 408, httpd_err408title, "",
+                             httpd_err408form, "");
+              finish_connection(conn, nowP);
+            }
+          break;
+
+        case CNST_SENDING:
+          if (nowP->tv_sec - conn->active_at >= CONFIG_THTTPD_IDLE_SEND_LIMIT_SEC)
+            {
+              ndbg("%s connection timed out sending\n", httpd_ntoa(&conn->hc->client_addr));
+              clear_connection(conn, nowP);
+            }
+          break;
+        }
+    }
+}
+
+static void linger_clear_connection(ClientData client_data, struct timeval *nowP)
+{
+  struct connect_s *conn;
+
+  nvdbg("Clear connection\n");
+  conn = (struct connect_s *) client_data.p;
+  conn->linger_timer = NULL;
+  really_clear_connection(conn);
+}
+
+static void occasional(ClientData client_data, struct timeval *nowP)
+{
+  tmr_cleanup();
+}
+
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Function: thttpd_main
+ *
+ * Description:
+ *   This function is the entrypoint into the THTTPD server.  It does not
+ *   return.  It may be called, the normal mechanism for starting the server
+ *   is:
+ *
+ *   1) Set is g_thttpdsymtab and g_thttpdnsymbols.  The user is required
+ *      to provide a symbol table to use for binding CGI programs (if CGI
+ *      is enabled.  See examples/nxflat and examples/thttpd for examples of
+ *      how such a symbol table may be created.
+ *   2) Call task_create() to start thttpd_main()
+ *
+ ****************************************************************************/
+
+int thttpd_main(int argc, char **argv)
+{
+  int num_ready;
+  int cnum;
+  FAR struct connect_s *conn;
+  FAR httpd_conn *hc;
+  httpd_sockaddr sa;
+  struct timeval tv;
+#ifdef CONFIG_THTTPD_DIR
+  int ret;
+#endif
+
+  nvdbg("THTTPD started\n");
+
+  /* Setup host address */
+
+#ifdef  CONFIG_NET_IPv6
+#  error "IPv6 support not yet implemented"
+#else
+  sa.sin_family      = AF_INET;
+  sa.sin_port        = HTONS(CONFIG_THTTPD_PORT);
+  sa.sin_addr.s_addr = HTONL(CONFIG_THTTPD_IPADDR);
+#endif
+
+  /* Initialize the fdwatch package to handle all of the configured
+   * socket descriptors
+   */
+
+  fw = fdwatch_initialize(CONFIG_NSOCKET_DESCRIPTORS);
+  if (!fw)
+    {
+      ndbg("fdwatch initialization failure\n");
+      exit(1);
+    }
+
+  /* Switch directories again if requested */
+
+#ifdef CONFIG_THTTPD_DATADIR
+  if (chdir(CONFIG_THTTPD_DATADIR) < 0)
+    {
+      ndbg("chdir to %s: %d\n", CONFIG_THTTPD_DATADIR, errno);
+      exit(1);
+    }
+#endif
+
+  /* Initialize the timer package */
+
+  tmr_init();
+
+  /* Initialize the HTTP layer */
+
+  nvdbg("Calling httpd_initialize()\n");
+  hs = httpd_initialize(&sa);
+  if (!hs)
+    {
+      ndbg("httpd_initialize() failed\n");
+      exit(1);
+    }
+
+  /* Set up the occasional timer */
+
+  if (tmr_create(NULL, occasional, JunkClientData, CONFIG_THTTPD_OCCASIONAL_MSEC * 1000L, 1) == NULL)
+    {
+      ndbg("tmr_create(occasional) failed\n");
+      exit(1);
+    }
+
+  /* Set up the idle timer */
+
+  if (tmr_create(NULL, idle, JunkClientData, 5 * 1000L, 1) == NULL)
+    {
+      ndbg("tmr_create(idle) failed\n");
+      exit(1);
+
+    }
+
+  /* Initialize our connections table */
+
+  connects = NEW(struct connect_s, AVAILABLE_FDS);
+  if (connects == NULL)
+    {
+      ndbg("Out of memory allocating a struct connect_s\n");
+      exit(1);
+    }
+
+  for (cnum = 0; cnum < AVAILABLE_FDS; ++cnum)
+    {
+      connects[cnum].conn_state  = CNST_FREE;
+      connects[cnum].next        = &connects[cnum + 1];
+      connects[cnum].hc          = NULL;
+    }
+
+  connects[AVAILABLE_FDS-1].next = NULL;      /* End of link list */
+  free_connections               = connects;  /* Beginning of the link list */
+
+  if (hs != NULL)
+    {
+      if (hs->listen_fd != -1)
+        {
+          fdwatch_add_fd(fw, hs->listen_fd, NULL);
+        }
+    }
+
+  /* Main loop */
+
+  nvdbg("Entering the main loop\n");
+  (void)gettimeofday(&tv, NULL);
+  for(;;)
+    {
+      /* Do the fd watch */
+
+      num_ready = fdwatch(fw, tmr_mstimeout(&tv));
+      if (num_ready < 0)
+        {
+          if (errno == EINTR || errno == EAGAIN)
+            {
+              /* Not errors... try again */
+
+              continue;
+            }
+
+          ndbg("fdwatch failed: %d\n", errno);
+          exit(1);
+        }
+
+      (void)gettimeofday(&tv, NULL);
+
+      if (num_ready == 0)
+        {
+          /* No fd's are ready - run the timers */
+
+          tmr_run(&tv);
+          continue;
+        }
+
+      /* Is it a new connection? */
+
+      if (fdwatch_check_fd(fw, hs->listen_fd))
+        {
+          if (!handle_newconnect(&tv, hs->listen_fd))
+            {
+              /* Go around the loop and do another fdwatch, rather than 
+               * dropping through and processing existing connections.  New
+               * connections always get priority.
+               */
+
+              continue;
+            }
+        }
+
+      /* Find the connections that need servicing */
+
+      while ((conn = (struct connect_s*)fdwatch_get_next_client_data(fw)) != (struct connect_s*)-1)
+        {
+          if (conn)
+            {
+              hc = conn->hc;
+              if (fdwatch_check_fd(fw, hc->conn_fd))
+                {
+                  nvdbg("Handle conn_state %d\n", conn->conn_state);
+                  switch (conn->conn_state)
+                    {
+                      case CNST_READING:
+                        {
+                          handle_read(conn, &tv);
+
+                          /* If a GET request was received and a file is ready to
+                           * be sent, then fall through to send the file.
+                           */
+
+                          if (conn->conn_state != CNST_SENDING)
+                            { 
+                              break;
+                            }
+                        }
+
+                      case CNST_SENDING:
+                        {
+                          /* Send a file -- this really should be performed on a
+                           * separate thread to keep the serve from locking up during
+                           * the write.
+                           */
+
+                          handle_send(conn, &tv);
+                        }
+                        break;
+
+                      case CNST_LINGERING:
+                        {
+                          /* Linger close the connection */
+
+                          handle_linger(conn, &tv);
+                        }
+                        break;
+                    }
+                }
+            }
+        }
+      tmr_run(&tv);
+    }
+
+  /* The main loop terminated */
+
+  shut_down();
+  ndbg("Exiting\n");
+  exit(0);
+}
+
+#endif /* CONFIG_THTTPD */
+

netutils/thttpd/thttpd_alloc.c

@@ -0,0 +1,199 @@
+/****************************************************************************
+ * netutils/thttpd/thttpd_alloc.c
+ *
+ *   Copyright (C) 2009 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * 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>
+
+#include <sys/types.h>
+#include <stdlib.h>
+#include <debug.h>
+#include <errno.h>
+
+#include "config.h"
+#include "thttpd_alloc.h"
+
+#ifdef CONFIG_THTTPD
+
+/****************************************************************************
+ * Pre-processor Definitions
+ ****************************************************************************/
+
+#ifndef MAX
+#  define MAX(a,b) ((a) > (b) ? (a) : (b))
+#endif
+
+#ifndef MIN
+#  define MIN(a,b) ((a) < (b) ? (a) : (b))
+#endif
+
+/****************************************************************************
+ * Private Data
+ ****************************************************************************/
+
+#ifdef CONFIG_THTTPD_MEMDEBUG
+static int    g_nallocations = 0;
+static int    g_nfreed       = 0;
+static size_t g_allocated    = 0;
+#endif
+
+/****************************************************************************
+ * Private Functions
+ ****************************************************************************/
+
+/* Generate debugging statistics */
+
+#ifdef CONFIG_THTTPD_MEMDEBUG
+void httpd_memstats(void)
+{
+  static struct mallinfo mm;
+
+  ndbg("%d allocations (%lu bytes), %d freed\n", g_nallocations, (unsigned long)g_allocated, g_nfreed);
+
+  /* Get the current memory usage */
+
+#ifdef CONFIG_CAN_PASS_STRUCTS
+  mm = mallinfo();
+#else
+  (void)mallinfo(&mm);
+#endif
+  ndbg("arena: %08x ordblks: %08x mxordblk: %08x uordblks: %08x fordblks: %08x\n",
+       mm.arena, mm.ordblks, mm.mxordblk, mm.uordblks, mm.fordblks);
+}
+#endif
+
+/****************************************************************************
+ * Global Functions
+ ****************************************************************************/
+
+#ifdef CONFIG_THTTPD_MEMDEBUG
+FAR void *httpd_malloc(size_t nbytes)
+{
+  void *ptr = malloc(nbytes);
+  if (!ptr)
+    {
+      ndbg("Allocation of %d bytes failed\n", nbytes);
+    }
+  else
+    {
+      nvdbg("Allocated %d bytes at %p\n", nbytes, ptr);
+      g_nallocations++;
+      g_allocated += nbytes;
+    }
+  httpd_memstats();
+  return ptr;
+}
+#endif
+
+#ifdef CONFIG_THTTPD_MEMDEBUG
+FAR void *httpd_realloc(FAR void *oldptr, size_t oldsize, size_t newsize)
+{
+  void *ptr = realloc(oldptr, newsize);
+  if (!ptr)
+    {
+      ndbg("Re-allocation from %d to %d bytes failed\n",
+           oldsize, newsize);
+    }
+  else
+    {
+      nvdbg("Re-allocated form %d to %d bytes (from %p to %p)\n",
+            oldsize, newsize, oldptr, ptr);
+      g_allocated += (newsize - oldsize);
+    }
+  httpd_memstats();
+  return ptr;
+}
+#endif
+
+#ifdef CONFIG_THTTPD_MEMDEBUG
+void httpd_free(FAR void *ptr)
+{
+  free(ptr);
+  g_nfreed++;
+  nvdbg("Freed memory at %p\n", ptr);
+  httpd_memstats();
+}
+#endif
+
+#ifdef CONFIG_THTTPD_MEMDEBUG
+FAR char *httpd_strdup(const char *str)
+{
+  FAR char *newstr = strdup(str);
+  if (!newstr)
+    {
+      ndbg("strdup of %s failed\n", str);
+    }
+  else
+    {
+      nvdbg("strdup'ed %s\n", str);
+      g_nallocations++;
+      g_allocated += (strlen(str)+1);
+    }
+  httpd_memstats();
+  return newstr;
+}
+#endif
+
+/* Helpers to implement dynamically allocated strings */
+
+void httpd_realloc_str(char **pstr, size_t *maxsize, size_t size)
+{
+  size_t oldsize;
+  if (*maxsize == 0)
+    {
+      *maxsize = MAX(CONFIG_THTTPD_MINSTRSIZE, size + CONFIG_THTTPD_REALLOCINCR);
+      *pstr    = NEW(char, *maxsize + 1);
+    }
+  else if (size > *maxsize)
+    {
+      oldsize  = *maxsize;
+      *maxsize = MAX(oldsize * 2, size * 5 / 4);
+      *pstr    = httpd_realloc(*pstr, oldsize + 1, *maxsize + 1);
+    }
+  else
+    {
+      return;
+    }
+
+  if (!*pstr)
+    {
+      ndbg("out of memory reallocating a string to %d bytes\n", *maxsize);
+      exit(1);
+    }
+}
+
+#endif /* CONFIG_THTTPD */

netutils/thttpd/thttpd_alloc.h

@@ -0,0 +1,78 @@
+/****************************************************************************
+ * netutils/thttpd/thttpd_alloc.h
+ *
+ *   Copyright (C) 2009 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ * 3. Neither the name NuttX nor the names of its contributors may be
+ *    used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ ****************************************************************************/
+
+#ifndef __NETUTILS_THTTPD_HTTDP_ALLOC_H
+#define __NETUTILS_THTTPD_HTTDP_ALLOC_H
+
+/****************************************************************************
+ * Included Files
+ ****************************************************************************/
+
+#include <nuttx/config.h>
+#include <stdlib.h>
+#include <string.h>
+#include "config.h"
+
+#ifdef CONFIG_THTTPD
+
+/****************************************************************************
+ * Global Functions
+ ****************************************************************************/
+
+/* Allows all memory management calls to be intercepted */
+
+#ifdef CONFIG_THTTPD_MEMDEBUG
+extern FAR void *httpd_malloc(size_t nbytes);
+extern FAR void *httpd_realloc(FAR void *oldptr, size_t oldsize, size_t newsize);
+extern void      httpd_free(FAR void *ptr);
+extern FAR char *httpd_strdup(const char *str);
+#else
+#  define httpd_malloc(n)      malloc(n)
+#  define httpd_realloc(p,o,n) realloc(p,n)
+#  define httpd_free(p)        free(p)
+#  define httpd_strdup(s)      strdup(s)
+#endif
+
+/* Helpers to support allocations in multiples of a type size */
+
+#define NEW(t,n)               ((t*)httpd_malloc(sizeof(t)*(n)))
+#define RENEW(p,t,o,n)         ((t*)httpd_realloc((void*)p, sizeof(t)*(o), sizeof(t)*(n)))
+
+/* Helpers to implement dynamically allocated strings */
+
+extern void httpd_realloc_str(char **pstr, size_t *maxsizeP, size_t size);
+
+#endif /* CONFIG_THTTPD */
+#endif /* __NETUTILS_THTTPD_HTTDP_ALLOC_H */

netutils/thttpd/thttpd_cgi.h

@@ -0,0 +1,61 @@
+/****************************************************************************
+ * netutils/thttpd/thttpd_cgi.h
+ * CGI support
+ *
+ *   Copyright (C) 2009 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * Derived from the file libhttpd.c in the original THTTPD package:
+ *
+ *   Copyright © 1995,1998,1999,2000,2001 by Jef Poskanzer <jef@mail.acme.com>.
+ *   All rights reserved.
+ *
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ ****************************************************************************/
+
+#ifndef __HTTPD_CGI_H
+#define __HTTPD_CGI_H
+
+/****************************************************************************
+ * Included Files
+ ****************************************************************************/
+
+#include <nuttx/config.h>
+
+#include "config.h"
+#include "libhttpd.h"
+
+#if defined(CONFIG_THTTPD) && defined(CONFIG_THTTPD_CGI_PATTERN)
+
+/****************************************************************************
+ * Public Function Prototypes
+ ****************************************************************************/
+
+extern int cgi(httpd_conn *hc);
+#if CONFIG_THTTPD_CGI_TIMELIMIT > 0
+static void cgi_kill(ClientData client_data, struct timeval *now);
+#endif
+
+#endif /* CONFIG_THTTPD && CONFIG_THTTPD_CGI_PATTERN */
+#endif /* __HTTPD_CGI_H */

netutils/thttpd/thttpd_strings.c

@@ -0,0 +1,179 @@
+/****************************************************************************
+ * netutils/thttpd/thttpd_strings.c
+ * HTTP strings
+ *
+ *   Copyright (C) 2009 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * Derived from the file of the same name in the original THTTPD package:
+ *
+ *   Copyright © 1995,1998,1999,2000,2001 by Jef Poskanzer <jef@mail.acme.com>.
+ *   All rights reserved.
+ *
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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>
+
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+
+#include "config.h"
+#include "thttpd_strings.h"
+
+#ifdef CONFIG_THTTPD
+
+/****************************************************************************
+ * Public Data
+ ****************************************************************************/
+
+/* This is the 'root' of the Filesystem as seen by the HTTP client */
+
+const char httpd_root[] = CONFIG_THTTPD_PATH;
+
+/* HTPP status */
+
+const char ok200title[]  = "OK";
+const char ok206title[]  = "Partial Content";
+
+const char err302title[] = "Found";
+const char err302form[]  = "The actual URL is '%s'.\n";
+
+const char err304title[] = "Not Modified";
+
+const char httpd_err400title[]  = "Bad Request";
+const char httpd_err400form[]   = "Your request has bad syntax or is inherently impossible to satisfy.\n";
+
+#ifdef CONFIG_THTTPD_AUTH_FILE
+const char err401title[] = "Unauthorized";
+const char err401form[]  = "Authorization required for the URL '%s'.\n";
+#endif
+
+const char err403title[] = "Forbidden";
+#ifndef EXPLICIT_ERROR_PAGES
+const char err403form[]  = "You do not have permission to get URL '%s' from this server.\n";
+#endif
+
+const char err404title[] = "Not Found";
+const char err404form[]  = "The requested URL '%s' was not found on this server.\n";
+
+const char httpd_err408title[]  = "Request Timeout";
+const char httpd_err408form[]   = "No request appeared within a reasonable time period.\n";
+
+const char err500title[] = "Internal Error";
+const char err500form[]  = "There was an unusual problem serving the requested URL '%s'.\n";
+
+const char err501title[] = "Not Implemented";
+const char err501form[]  = "The requested method '%s' is not implemented by this server.\n";
+
+const char httpd_err503title[] = "Service Temporarily Overloaded";
+const char httpd_err503form[]  = "The requested URL '%s' is temporarily overloaded.  Please try again later.\n";
+
+/* HTML strings */
+
+const char html_crlf[]      = "\r\n";
+const char html_html[]      = "<HTML>\r\n";
+const char html_endhtml[]   = "</HTML>\r\n";
+const char html_hdtitle[]   = "<HEAD><TITLE>";
+const char html_titlehd[]   = "</TITLE></HEAD>\r\n";
+const char html_body[]      = "<BODY BGCOLOR=\"#99cc99\" TEXT=\"#000000\" LINK=\"#2020ff\" VLINK=\"#4040cc\">\r\n";
+const char html_endbody[]   = "</BODY>\r\n";
+const char html_hdr2[]      = "<H2>";
+const char html_endhdr2[]   = "</H2>";
+
+/****************************************************************************
+ * Private Functions
+ ****************************************************************************/
+
+static int hexit(char nibble)
+{
+  if (nibble >= '0' && nibble <= '9')
+    {
+      return nibble - '0';
+    }
+  else if (nibble >= 'a' && nibble <= 'f')
+    {
+      return nibble - 'a' + 10;
+    }
+  else if (nibble >= 'A' && nibble <= 'F')
+    {
+      return nibble - 'A' + 10;
+    }
+  return 0;
+}
+
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
+
+/* Copies and decodes a string.  It's ok for from and to to be the same string. */
+
+void httpd_strdecode(char *to, char *from)
+{
+  for (; *from != '\0'; ++to, ++from)
+    {
+      if (from[0] == '%' && isxdigit(from[1]) && isxdigit(from[2]))
+        {
+          *to = hexit(from[1]) * 16 + hexit(from[2]);
+          from += 2;
+        }
+      else
+        {
+          *to = *from;
+        }
+    }
+  *to = '\0';
+}
+
+/* Copies and encodes a string. */
+
+#ifdef CONFIG_THTTPD_GENERATE_INDICES
+static void httpd_strencode(char *to, int tosize, char *from)
+{
+  int tolen;
+
+  for (tolen = 0; *from != '\0' && tolen + 4 < tosize; ++from)
+    {
+      if (isalnum(*from) || strchr("/_.-~", *from) != NULL)
+        {
+          *to = *from;
+          ++to;
+          ++tolen;
+        }
+      else
+        {
+          (void)sprintf(to, "%%%02x", (int)*from & 0xff);
+          to += 3;
+          tolen += 3;
+        }
+    }
+  *to = '\0';
+}
+#endif /* CONFIG_THTTPD_GENERATE_INDICES */
+#endif /* CONFIG_THTTPD */

netutils/thttpd/thttpd_strings.h

@@ -0,0 +1,123 @@
+/****************************************************************************
+ * netutils/thttpd/thttpd_strings.h
+ * HTTP strings
+ *
+ *   Copyright (C) 2009 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * Derived from the file of the same name in the original THTTPD package:
+ *
+ *   Copyright © 1995,1998,1999,2000,2001 by Jef Poskanzer <jef@mail.acme.com>.
+ *   All rights reserved.
+ *
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ ****************************************************************************/
+
+#ifndef __NETUTILS_THTTPD_THTTPD_STRINGS_H
+#define __NETUTILS_THTTPD_THTTPD_STRINGS_H
+
+/****************************************************************************
+ * Included Files
+ ****************************************************************************/
+
+#include <nuttx/config.h>
+
+#include "config.h"
+
+#ifdef CONFIG_THTTPD
+
+/****************************************************************************
+ * Public Data
+ ****************************************************************************/
+
+/* This is the 'root' of the Filesystem as seen by the HTTP client */
+
+extern const char httpd_root[];
+
+/* HTPP status */
+
+extern const char ok200title[];
+extern const char ok206title[];
+
+extern const char err302title[];
+extern const char err302form[];
+
+extern const char err304title[];
+
+extern const char httpd_err400title[];
+extern const char httpd_err400form[];
+
+#ifdef CONFIG_THTTPD_AUTH_FILE
+extern const char err401title[];
+extern const char err401form[];
+#endif
+
+extern const char err403title[];
+#ifndef EXPLICIT_ERROR_PAGES
+extern const char err403form[];
+#endif
+
+extern const char err404title[];
+extern const char err404form[];
+
+extern const char httpd_err408title[];
+extern const char httpd_err408form[];
+
+extern const char err500title[];
+extern const char err500form[];
+
+extern const char err501title[];
+extern const char err501form[];
+
+extern const char httpd_err503title[];
+extern const char httpd_err503form[];
+
+/* HTML strings */
+
+extern const char html_crlf[];
+extern const char html_html[];
+extern const char html_endhtml[];
+extern const char html_hdtitle[];
+extern const char html_titlehd[];
+extern const char html_body[];
+extern const char html_endbody[];
+extern const char html_hdr2[];
+extern const char html_endhdr2[];
+
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
+
+/* Copies and decodes a string.  It's ok for from and to to be the same string. */
+
+extern void httpd_strdecode(char *to, char *from);
+
+/* Copies and encodes a string. */
+
+#ifdef CONFIG_THTTPD_GENERATE_INDICES
+extern void httpd_strencode(char *to, int tosize, char *from);
+#endif
+
+#endif /* CONFIG_THTTPD */
+#endif /* __NETUTILS_THTTPD_THTTPD_STRINGS_H */

netutils/thttpd/timers.c

@@ -0,0 +1,365 @@
+/****************************************************************************
+ * netutils/thttpd/timers.c
+ * Simple Timer Routines
+ *
+ *   Copyright (C) 2009 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * Derived from the file of the same name in the original THTTPD package:
+ *
+ *   Copyright © 1995,1998,2000 by Jef Poskanzer <jef@mail.acme.com>.
+ *   All rights reserved.
+ *
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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 <sys/time.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <debug.h>
+
+#include "thttpd_alloc.h"
+#include "timers.h"
+
+/****************************************************************************
+ * Pre-Processor Definitons
+ ****************************************************************************/
+
+#define HASH_SIZE 67
+
+/****************************************************************************
+ * Private Data
+ ****************************************************************************/
+
+static Timer *timers[HASH_SIZE];
+static Timer *free_timers;
+
+/****************************************************************************
+ * Public Data
+ ****************************************************************************/
+
+ClientData JunkClientData;
+
+/****************************************************************************
+ * Private Functions
+ ****************************************************************************/
+
+static unsigned int hash(Timer *tmr)
+{
+  /* We can hash on the trigger time, even though it can change over the
+   * life of a timer via the periodic bit.
+   * This is because both of those guys call l_resort(), which  * recomputes
+   * the hash and moves the timer to the appropriate list.
+   */
+
+  return ((unsigned int)tmr->time.tv_sec ^
+          (unsigned int)tmr->time.tv_usec) % HASH_SIZE;
+}
+
+static void l_add(Timer *tmr)
+{
+  int h = tmr->hash;
+  register Timer *tmr2;
+  register Timer *tmr2prev;
+
+  tmr2 = timers[h];
+  if (tmr2 == NULL)
+    {
+      /* The list is empty. */
+      timers[h] = tmr;
+      tmr->prev = tmr->next = NULL;
+    }
+  else
+    {
+      if (tmr->time.tv_sec < tmr2->time.tv_sec ||
+          (tmr->time.tv_sec == tmr2->time.tv_sec &&
+           tmr->time.tv_usec <= tmr2->time.tv_usec))
+        {
+          /* The new timer goes at the head of the list. */
+
+          timers[h] = tmr;
+          tmr->prev = NULL;
+          tmr->next = tmr2;
+          tmr2->prev = tmr;
+        }
+      else
+        {
+          /* Walk the list to find the insertion point. */
+
+          for (tmr2prev = tmr2, tmr2 = tmr2->next; tmr2 != NULL;
+               tmr2prev = tmr2, tmr2 = tmr2->next)
+            {
+              if (tmr->time.tv_sec < tmr2->time.tv_sec ||
+                  (tmr->time.tv_sec == tmr2->time.tv_sec &&
+                   tmr->time.tv_usec <= tmr2->time.tv_usec))
+                {
+                  /* Found it. */
+                  tmr2prev->next = tmr;
+                  tmr->prev = tmr2prev;
+                  tmr->next = tmr2;
+                  tmr2->prev = tmr;
+                  return;
+                }
+            }
+
+          /* Oops, got to the end of the list.  Add to tail. */
+
+          tmr2prev->next = tmr;
+          tmr->prev = tmr2prev;
+          tmr->next = NULL;
+        }
+    }
+}
+
+static void l_remove(Timer *tmr)
+{
+  int h = tmr->hash;
+
+  if (tmr->prev == NULL)
+    {
+      timers[h] = tmr->next;
+    }
+  else
+    {
+      tmr->prev->next = tmr->next;
+    }
+
+  if (tmr->next != NULL)
+    {
+      tmr->next->prev = tmr->prev;
+    }
+}
+
+static void l_resort(Timer *tmr)
+{
+  /* Remove the timer from its old list. */
+
+  l_remove(tmr);
+
+  /* Recompute the hash. */
+
+  tmr->hash = hash(tmr);
+
+  /* And add it back in to its new list, sorted correctly. */
+
+  l_add(tmr);
+}
+
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
+
+void tmr_init(void)
+{
+  int h;
+
+  for (h = 0; h < HASH_SIZE; ++h)
+    {
+      timers[h] = NULL;
+    }
+
+  free_timers = NULL;
+}
+
+Timer *tmr_create(struct timeval *now, TimerProc *timer_proc,
+                  ClientData client_data, long msecs, int periodic)
+{
+  Timer *tmr;
+
+  if (free_timers != NULL)
+    {
+      tmr = free_timers;
+      free_timers = tmr->next;
+    }
+  else
+    {
+      tmr = (Timer*)httpd_malloc(sizeof(Timer));
+      if (!tmr)
+        {
+          return NULL;
+        }
+    }
+
+  tmr->timer_proc  = timer_proc;
+  tmr->client_data = client_data;
+  tmr->msecs       = msecs;
+  tmr->periodic    = periodic;
+
+  if (now != NULL)
+    {
+      tmr->time = *now;
+    }
+  else
+    {
+      (void)gettimeofday(&tmr->time, NULL);
+    }
+
+  tmr->time.tv_sec  += msecs / 1000L;
+  tmr->time.tv_usec += (msecs % 1000L) * 1000L;
+  if (tmr->time.tv_usec >= 1000000L)
+    {
+      tmr->time.tv_sec  += tmr->time.tv_usec / 1000000L;
+      tmr->time.tv_usec %= 1000000L;
+    }
+  tmr->hash = hash(tmr);
+
+  /* Add the new timer to the proper active list. */
+
+  l_add(tmr);
+  return tmr;
+}
+
+long tmr_mstimeout(struct timeval *now)
+{
+  int h;
+  int gotone;
+  long msecs, m;
+  register Timer *tmr;
+
+  gotone = 0;
+  msecs  = 0;
+
+  /* Since the lists are sorted, we only need to look at the  * first timer on
+   * each one.
+   */
+
+  for (h = 0; h < HASH_SIZE; ++h)
+    {
+      tmr = timers[h];
+      if (tmr != NULL)
+        {
+          m = (tmr->time.tv_sec - now->tv_sec) * 1000L +
+            (tmr->time.tv_usec - now->tv_usec) / 1000L;
+          if (!gotone)
+            {
+              msecs = m;
+              gotone = 1;
+            }
+          else if (m < msecs)
+            {
+              msecs = m;
+            }
+        }
+    }
+
+  if (!gotone)
+    {
+      return INFTIM;
+    }
+
+  if (msecs <= 0)
+    {
+      msecs = 0;
+    }
+
+  return msecs;
+}
+
+void tmr_run(struct timeval *now)
+{
+  int h;
+  Timer *tmr;
+  Timer *next;
+
+  for (h = 0; h < HASH_SIZE; ++h)
+    {
+      for (tmr = timers[h]; tmr != NULL; tmr = next)
+        {
+          next = tmr->next;
+
+          /* Since the lists are sorted, as soon as we find a timer  * that isn'tmr 
+           * ready yet, we can go on to the next list
+           */
+
+          if (tmr->time.tv_sec > now->tv_sec ||
+              (tmr->time.tv_sec == now->tv_sec && tmr->time.tv_usec > now->tv_usec))
+            {
+              break;
+            }
+
+          (tmr->timer_proc)(tmr->client_data, now);
+          if (tmr->periodic)
+            {
+              /* Reschedule. */
+
+              tmr->time.tv_sec += tmr->msecs / 1000L;
+              tmr->time.tv_usec += (tmr->msecs % 1000L) * 1000L;
+              if (tmr->time.tv_usec >= 1000000L)
+                {
+                  tmr->time.tv_sec += tmr->time.tv_usec / 1000000L;
+                  tmr->time.tv_usec %= 1000000L;
+                }
+              l_resort(tmr);
+            }
+          else
+            {
+              tmr_cancel(tmr);
+            }
+        }
+    }
+}
+
+void tmr_cancel(Timer *tmr)
+{
+  /* Remove it from its active list. */
+
+  l_remove(tmr);
+
+  /* And put it on the free list. */
+
+  tmr->next   = free_timers;
+  free_timers = tmr;
+  tmr->prev   = NULL;
+}
+
+void tmr_cleanup(void)
+{
+  Timer *tmr;
+
+  while (free_timers != NULL)
+    {
+      tmr = free_timers;
+      free_timers = tmr->next;
+      httpd_free((void*)tmr);
+    }
+}
+
+void tmr_destroy(void)
+{
+  int h;
+
+  for (h = 0; h < HASH_SIZE; ++h)
+    {
+      while (timers[h] != NULL)
+        {
+          tmr_cancel(timers[h]);
+        }
+    }
+  tmr_cleanup();
+}

netutils/thttpd/timers.h

@@ -0,0 +1,136 @@
+/****************************************************************************
+ * netutils/thttpd/timers.h
+ * Header file for THTTPD timers package
+ *
+ *   Copyright (C) 2009 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * Derived from the file of the same name in THTTPD:
+ *
+ *   Copyright © 1995,1998,1999,2000 by Jef Poskanzer <jef@mail.acme.com>.
+ *   All rights reserved.
+ *
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ ****************************************************************************/
+
+#ifndef __NETUTILS_THTTPD_TIMERS_H
+#define __NETUTILS_THTTPD_TIMERS_H
+
+/****************************************************************************
+ * Included Files
+ ****************************************************************************/
+
+#include <time.h>
+
+/****************************************************************************
+ * Pre-processor Definitions
+ ****************************************************************************/
+
+#ifndef INFTIM
+#  define INFTIM -1
+#endif
+
+/****************************************************************************
+ * Public Types
+ ****************************************************************************/
+
+/* ClientData is a random value that tags along with a timer.  The client
+ * can use it for whatever, and it gets passed to the callback when the
+ * timer triggers.
+ */
+
+typedef union
+{
+  void *p;
+  int   i;
+  long  l;
+} ClientData;
+
+/* The TimerProc gets called when the timer expires.  It gets passed
+ * the ClientData associated with the timer, and a timeval in case
+ * it wants to schedule another timer.
+ */
+
+typedef void TimerProc(ClientData client_data, struct timeval *nowP);
+
+/* The Timer struct. */
+
+typedef struct TimerStruct
+{
+  TimerProc          *timer_proc;
+  ClientData          client_data;
+  long                msecs;
+  int                 periodic;
+  struct timeval      time;
+  struct TimerStruct *prev;
+  struct TimerStruct *next;
+  int hash;
+} Timer;
+
+/****************************************************************************
+ * Public Data
+ ****************************************************************************/
+
+extern ClientData JunkClientData;       /* For use when you don't care */
+
+/****************************************************************************
+ * Public Function Prototypes
+ ****************************************************************************/
+
+/* Initialize the timer package. */
+
+extern void tmr_init(void);
+
+/* Set up a timer, either periodic or one-shot. Returns (Timer*) 0 on errors. */
+
+extern Timer *tmr_create(struct timeval *nowP, TimerProc * timer_proc,
+                         ClientData client_data, long msecs, int periodic);
+
+/* Returns a timeout in milliseconds indicating how long until the next timer
+ * triggers.  You can just put the call to this routine right in your poll().
+ * Returns INFTIM (-1) if no timers are pending.
+ */
+
+extern long tmr_mstimeout(struct timeval *nowP);
+
+/* Run the list of timers. Your main program needs to call this every so often. */
+
+extern void tmr_run(struct timeval *nowP);
+
+/* Deschedule a timer.  Note that non-periodic timers are automatically
+ * descheduled when they run, so you don't have to call this on them.
+ */
+
+extern void tmr_cancel(Timer *timer);
+
+/* Clean up the timers package, freeing any unused storage. */
+
+extern void tmr_cleanup(void);
+
+/* Cancel all timers and free storage, usually in preparation for exitting. */
+
+extern void tmr_destroy(void);
+
+#endif /* __NETUTILS_THTTPD_TIMERS_H */
+

netutils/uiplib/Makefile

@@ -0,0 +1,103 @@
+############################################################################
+# apps/netutils/uiplib/Makefile
+#
+#   Copyright (C) 2011 Gregory Nutt. All rights reserved.
+#   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+#
+# 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.
+#
+############################################################################
+
+-include $(TOPDIR)/.config
+-include $(TOPDIR)/Make.defs
+include $(APPDIR)/Make.defs
+
+# UIP Library
+
+ASRCS		=
+CSRCS		= uiplib.c uip_sethostaddr.c uip_gethostaddr.c uip_setdraddr.c \
+			  uip_setnetmask.c uip_parsehttpurl.c uip_server.c
+
+# No MAC address support for SLIP (Ethernet only)
+
+ifneq ($(CONFIG_NET_SLIP),y)
+CSRCS		+= uip_setmacaddr.c uip_getmacaddr.c
+endif
+
+# IGMP support
+
+ifeq ($(CONFIG_NET_IGMP),y)
+CSRCS		+= uip_ipmsfilter.c
+endif
+
+AOBJS		= $(ASRCS:.S=$(OBJEXT))
+COBJS		= $(CSRCS:.c=$(OBJEXT))
+
+SRCS		= $(ASRCS) $(CSRCS)
+OBJS		= $(AOBJS) $(COBJS)
+
+BIN	    	= ../../libapps$(LIBEXT)
+
+ROOTDEPPATH	= --dep-path .
+
+# Common build
+
+VPATH		= 
+
+all: .built
+
+$(AOBJS): %$(OBJEXT): %.S
+	$(call ASSEMBLE, $<, $@)
+
+$(COBJS): %$(OBJEXT): %.c
+	$(call COMPILE, $<, $@)
+
+$(BIN):	$(OBJS)
+	@( for obj in $(OBJS) ; do \
+		$(call ARCHIVE, $@, $${obj}); \
+	done ; )
+	@touch .built
+	
+.built: $(BIN)
+
+.depend: Makefile $(SRCS)
+	@$(MKDEP) $(ROOTDEPPATH) \
+	  $(CC) -- $(CFLAGS) -- $(SRCS) >Make.dep
+	@touch $@
+
+# Register application
+depend: .depend
+
+clean:
+	@rm -f $(BIN) *.o *~ .*.swp .built
+	$(call CLEAN)
+
+distclean: clean
+	@rm -f Make.dep .depend
+
+-include Make.dep

netutils/uiplib/uip_gethostaddr.c

@@ -0,0 +1,106 @@
+/****************************************************************************
+ * netutils/uiplib/uip_gethostaddr.c
+ *
+ *   Copyright (C) 2007-2009, 2011 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * 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) && CONFIG_NSOCKET_DESCRIPTORS > 0
+
+#include <sys/socket.h>
+#include <sys/ioctl.h>
+
+#include <string.h>
+#include <errno.h>
+
+#include <netinet/in.h>
+#include <net/if.h>
+
+#include <apps/netutils/uiplib.h>
+
+/****************************************************************************
+ * Pre-processor Definitions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Global Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: uip_gethostaddr
+ *
+ * Description:
+ *   Get the network driver IP address
+ *
+ * Parameters:
+ *   ifname   The name of the interface to use
+ *   ipaddr   The location to return the IP address
+ *
+ * Return:
+ *   0 on sucess; -1 on failure
+ *
+ ****************************************************************************/
+
+#ifdef CONFIG_NET_IPv6
+int uip_gethostaddr(const char *ifname, struct in6_addr *addr)
+#else
+int uip_gethostaddr(const char *ifname, struct in_addr *addr)
+#endif
+{
+  int ret = ERROR;
+  if (ifname && addr)
+    {
+      int sockfd = socket(PF_INET, UIPLIB_SOCK_IOCTL, 0);
+      if (sockfd >= 0)
+        {
+          struct ifreq req;
+          strncpy(req.ifr_name, ifname, IFNAMSIZ);
+          ret = ioctl(sockfd, SIOCGIFADDR, (unsigned long)&req);
+          if (!ret)
+            {
+#ifdef CONFIG_NET_IPv6
+#error "req.ifr_addr.s_addr not big enough for IPv6 address"
+              memcpy(addr, &req.ifr_addr, sizeof(struct in6_addr));
+#else
+              memcpy(addr, &req.ifr_addr, sizeof(struct in_addr));
+#endif
+            }
+        }
+    }
+  return ret;
+}
+
+#endif /* CONFIG_NET && CONFIG_NSOCKET_DESCRIPTORS */

netutils/uiplib/uip_getmacaddr.c

@@ -0,0 +1,104 @@
+/****************************************************************************
+ * netutils/uiplib/uip_getmacaddr.c
+ *
+ *   Copyright (C) 2007-2009, 2011 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * 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) && CONFIG_NSOCKET_DESCRIPTORS > 0
+
+#include <sys/socket.h>
+#include <sys/ioctl.h>
+#include <stdint.h>
+#include <string.h>
+#include <errno.h>
+
+#include <netinet/in.h>
+#include <net/if.h>
+
+#include <apps/netutils/uiplib.h>
+
+/****************************************************************************
+ * Global Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: uip_getmacaddr
+ *
+ * Description:
+ *   Get the network driver IP address
+ *
+ * Parameters:
+ *   ifname   The name of the interface to use
+ *   macaddr  The location to return the MAC address
+ *
+ * Return:
+ *   0 on sucess; -1 on failure
+ *
+ ****************************************************************************/
+
+int uip_getmacaddr(const char *ifname, uint8_t *macaddr)
+{
+  int ret = ERROR;
+  if (ifname && macaddr)
+    {
+      /* Get a socket (only so that we get access to the INET subsystem) */
+
+      int sockfd = socket(PF_INET, UIPLIB_SOCK_IOCTL, 0);
+      if (sockfd >= 0)
+        {
+          struct ifreq req;
+          memset (&req, 0, sizeof(struct ifreq));
+
+          /* Put the driver name into the request */
+
+          strncpy(req.ifr_name, ifname, IFNAMSIZ);
+
+          /* Perform the ioctl to get the MAC address */
+
+          ret = ioctl(sockfd, SIOCGIFHWADDR, (unsigned long)&req);
+          if (!ret)
+            {
+              /* Return the MAC address */
+
+              memcpy(macaddr, &req.ifr_hwaddr.sa_data, IFHWADDRLEN);
+            }
+        }
+    }
+  return ret;
+}
+
+#endif /* CONFIG_NET && CONFIG_NSOCKET_DESCRIPTORS */

netutils/uiplib/uip_ipmsfilter.c

@@ -0,0 +1,116 @@
+/****************************************************************************
+ * netutils/uiplib/uip_setmultiaddr.c
+ *
+ *   Copyright (C) 2010-2011 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * 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>
+
+#include <sys/socket.h>
+#include <sys/ioctl.h>
+#include <stdint.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+#include <debug.h>
+
+#include <netinet/in.h>
+#include <sys/sockio.h>
+
+#include <apps/netutils/uiplib.h>
+#include <apps/netutils/ipmsfilter.h>
+
+#ifdef CONFIG_NET_IGMP
+
+/****************************************************************************
+ * Pre-processor Definitions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Global Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: ipmsfilter
+ *
+ * Description:
+ *   Add or remove an IP address from a multicast filter set.
+ *
+ * Parameters:
+ *   ifname     The name of the interface to use, size must less than IMSFNAMSIZ
+ *   multiaddr  Multicast group address to add/remove (network byte order)
+ *   fmode      MCAST_INCLUDE: Add multicast address
+ *              MCAST_EXCLUDE: Remove multicast address
+ *
+ * Return:
+ *   0 on sucess; Negated errno on failure
+ *
+ ****************************************************************************/
+
+int ipmsfilter(FAR const char *ifname, FAR const struct in_addr *multiaddr,
+               uint32_t fmode)
+{
+  int ret = ERROR;
+
+  nvdbg("ifname: %s muliaddr: %08x fmode: %ld\n", ifname, *multiaddr, fmode);
+  if (ifname && multiaddr)
+    {
+      /* Get a socket (only so that we get access to the INET subsystem) */
+
+      int sockfd = socket(PF_INET, UIPLIB_SOCK_IOCTL, 0);
+      if (sockfd >= 0)
+        {
+          struct ip_msfilter imsf;
+
+          /* Put the driver name into the request */
+
+          strncpy(imsf.imsf_name, ifname, IMSFNAMSIZ);
+
+          /* Put the new address into the request */
+
+          imsf.imsf_multiaddr.s_addr = multiaddr->s_addr;
+
+          /* Perforom the ioctl to set the MAC address */
+
+          imsf.imsf_fmode = fmode;
+          ret = ioctl(sockfd, SIOCSIPMSFILTER, (unsigned long)&imsf);
+          close(sockfd);
+        }
+    }
+  return ret;
+}
+
+#endif /* CONFIG_NET_IGM */

netutils/uiplib/uip_parsehttpurl.c

@@ -0,0 +1,149 @@
+/****************************************************************************
+ * netutils/uiplib/uip_parsehttpurl.c
+ *
+ *   Copyright (C) 2009, 2011 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * 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>
+
+#include <stdint.h>
+#include <string.h>
+#include <errno.h>
+
+#include <apps/netutils/uiplib.h>
+
+/****************************************************************************
+ * Private Data
+ *****************************************************************************/
+
+const char g_http[] = "http://";
+#define HTTPLEN 7
+
+/****************************************************************************
+ * Public Functions
+ *****************************************************************************/
+
+/****************************************************************************
+ * Name: uip_parsehttpurl
+ ****************************************************************************/
+
+int uip_parsehttpurl(const char *url, uint16_t *port,
+                     char *hostname, int hostlen,
+                     char *filename, int namelen)
+{
+  const char *src = url;
+  char *dest;
+  int bytesleft;
+  int ret = OK;
+
+  /* A valid HTTP URL must begin with http:// if it does not, we will assume
+   * that it is a file name only, but still return an error.  wget() depends
+   * on this strange behavior.
+   */
+
+  if (strncmp(src, g_http, HTTPLEN) != 0)
+    {
+      ret = -EINVAL;
+    }
+  else
+    {
+      /* Skip over the http:// */
+
+      src += HTTPLEN;
+
+      /* Concatenate the hostname following http:// and up to the termnator */
+
+      dest      = hostname;
+      bytesleft = hostlen;
+      while (*src != '\0' && *src != '/' && *src != ' ' && *src != ':')
+        {
+          /* Make sure that there is space for another character in the hostname.
+           * (reserving space for the null terminator)
+           */
+
+          if (bytesleft > 1)
+            {
+              *dest++ = *src++;
+              bytesleft--;
+            }
+          else
+            {
+              ret = -E2BIG;
+            }
+        }
+      *dest = '\0';
+
+      /* Check if the hostname is following by a port number */
+
+      if (*src == ':')
+        {
+          uint16_t accum = 0;
+          src++; /* Skip over the colon */
+ 
+          while (*src >= '0' && *src <= '9')
+            {
+              accum = 10*accum + *src - '0';
+              src++;
+            }
+          *port = accum;
+        }
+    }
+
+  /* The rest of the line is the file name */
+
+  if (*src == '\0' || *src == ' ')
+    {
+      ret = -ENOENT;
+    }
+
+  /* Make sure the file name starts with exactly one '/' */
+
+  dest      = filename;
+  bytesleft = namelen;
+  while (*src == '/')
+    {
+      src++;
+    }
+  *dest++ = '/';
+  bytesleft--;
+
+  /* The copy the rest of the file name to the user buffer */
+ 
+  strncpy(dest, src, namelen);
+  filename[namelen-1] = '\0';
+  return ret;
+}
+

netutils/uiplib/uip_server.c

@@ -0,0 +1,184 @@
+/****************************************************************************
+ * netutils/uiplib/uip_server.c
+ *
+ *   Copyright (C) 2007-2009, 2011 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * 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 Gregory Nutt 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>
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <pthread.h>
+#include <errno.h>
+#include <debug.h>
+#include <netinet/in.h>
+
+#include <apps/netutils/uiplib.h>
+
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: uip_server
+ *
+ * Description:
+ *   Implement basic server logic
+ *
+ * Parameters:
+ *   portno    The port to listen on (in network byte order)
+ *   handler   The entrypoint of the task to spawn when a new connection is
+ *             accepted.
+ *   stacksize The stack size needed by the spawned task
+ *
+ * Return:
+ *   Does not return unless an error occurs.
+ *
+ ****************************************************************************/
+
+void uip_server(uint16_t portno, pthread_startroutine_t handler, int stacksize)
+{
+  struct sockaddr_in myaddr;
+#ifdef CONFIG_NET_HAVE_SOLINGER
+  struct linger ling;
+#endif
+  pthread_t child;
+  pthread_attr_t attr;
+  socklen_t addrlen;
+  int listensd;
+  int acceptsd;
+#ifdef CONFIG_NET_HAVE_REUSEADDR
+  int optval;
+#endif
+
+  /* Create a new TCP socket to use to listen for connections */
+
+  listensd = socket(PF_INET, SOCK_STREAM, 0);
+  if (listensd < 0)
+    {
+      ndbg("socket failure: %d\n", errno);
+      return;
+    }
+
+  /* Set socket to reuse address */
+
+#ifdef CONFIG_NET_HAVE_REUSEADDR
+  optval = 1;
+  if (setsockopt(listensd, SOL_SOCKET, SO_REUSEADDR, (void*)&optval, sizeof(int)) < 0)
+    {
+      ndbg("setsockopt SO_REUSEADDR failure: %d\n", errno);
+      goto errout_with_socket;
+    }
+#endif
+
+  /* Bind the socket to a local address */
+
+  myaddr.sin_family      = AF_INET;
+  myaddr.sin_port        = portno;
+  myaddr.sin_addr.s_addr = INADDR_ANY;
+
+  if (bind(listensd, (struct sockaddr*)&myaddr, sizeof(struct sockaddr_in)) < 0)
+    {
+      ndbg("bind failure: %d\n", errno);
+      goto errout_with_socket;
+    }
+
+  /* Listen for connections on the bound TCP socket */
+
+  if (listen(listensd, 5) < 0)
+    {
+      ndbg("listen failure %d\n", errno);
+      goto errout_with_socket;
+    }
+
+  /* Begin accepting connections */
+
+  nvdbg("Accepting connections on port %d\n", ntohs(portno));
+  for (;;)
+    {
+      addrlen = sizeof(struct sockaddr_in);
+      acceptsd = accept(listensd, (struct sockaddr*)&myaddr, &addrlen);
+      if (acceptsd < 0)
+        {
+          ndbg("accept failure: %d\n", errno);
+          break;;
+        }
+      nvdbg("Connection accepted -- spawning sd=%d\n", acceptsd);
+
+      /* Configure to "linger" until all data is sent when the socket is closed */
+
+#ifdef CONFIG_NET_HAVE_SOLINGER
+      ling.l_onoff  = 1;
+      ling.l_linger = 30;     /* timeout is seconds */
+      if (setsockopt(acceptsd, SOL_SOCKET, SO_LINGER, &ling, sizeof(struct linger)) < 0)
+        {
+          close(acceptsd);
+          ndbg("setsockopt SO_LINGER failure: %d\n", errno);
+          break;;
+        }
+#endif
+
+      /* Create a thread to handle the connection.  The socket descriptor is
+       * provided in as the single argument to the new thread.
+       */
+
+      (void)pthread_attr_init(&attr);
+      (void)pthread_attr_setstacksize(&attr, stacksize);
+
+      if (pthread_create(&child, &attr, handler, (void*)acceptsd) != 0)
+        {
+          close(acceptsd);
+          ndbg("create_create failed\n");
+          break;
+        }
+
+      /* We don't care when/how the child thread exits so detach from it now
+       * in order to avoid memory leaks.
+       */
+
+      (void)pthread_detach(child);
+    }
+
+errout_with_socket:
+  close(listensd);
+}

netutils/uiplib/uip_setdraddr.c

@@ -0,0 +1,117 @@
+/****************************************************************************
+ * netutils/uiplib/uip_setdraddr.c
+ *
+ *   Copyright (C) 2007-2009, 2011 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * 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) && CONFIG_NSOCKET_DESCRIPTORS > 0
+
+#include <sys/socket.h>
+#include <sys/ioctl.h>
+
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+
+#include <netinet/in.h>
+#include <net/if.h>
+
+#include <apps/netutils/uiplib.h>
+
+/****************************************************************************
+ * Global Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: uip_setdraddr
+ *
+ * Description:
+ *   Set the default router IP address
+ *
+ * Parameters:
+ *   ifname   The name of the interface to use
+ *   ipaddr   The address to set
+ *
+ * Return:
+ *   0 on sucess; -1 on failure
+ *
+ ****************************************************************************/
+
+#ifdef CONFIG_NET_IPv6
+int uip_setdraddr(const char *ifname, const struct in6_addr *addr)
+#else
+int uip_setdraddr(const char *ifname, const struct in_addr *addr)
+#endif
+{
+  int ret = ERROR;
+  if (ifname && addr)
+    {
+      int sockfd = socket(PF_INET, UIPLIB_SOCK_IOCTL, 0);
+      if (sockfd >= 0)
+        {
+          struct ifreq req;
+#ifdef CONFIG_NET_IPv6
+          struct sockaddr_in6 *inaddr;
+#else
+          struct sockaddr_in  *inaddr;
+#endif
+          /* Add the device name to the request */
+
+          strncpy(req.ifr_name, ifname, IFNAMSIZ);
+
+          /* Add the INET address to the request */
+
+#ifdef CONFIG_NET_IPv6
+#error "req.ifr_addr.s_addr not big enough for IPv6 address"
+          inaddr             = (struct sockaddr_in6 *)&req.ifr_addr;
+          inaddr->sin_family = AF_INET6;
+          inaddr->sin_port   = 0;
+          memcpy(&inaddr->sin6_addr, addr, sizeof(struct in6_addr));
+#else
+          inaddr             = (struct sockaddr_in *)&req.ifr_addr;
+          inaddr->sin_family = AF_INET;
+          inaddr->sin_port   = 0;
+          memcpy(&inaddr->sin_addr, addr, sizeof(struct in_addr));
+#endif
+          ret = ioctl(sockfd, SIOCSIFDSTADDR, (unsigned long)&req);
+          close(sockfd);
+        }
+    }
+  return ret;
+}
+
+#endif /* CONFIG_NET && CONFIG_NSOCKET_DESCRIPTORS */

netutils/uiplib/uip_sethostaddr.c

@@ -0,0 +1,117 @@
+/****************************************************************************
+ * netutils/uiplib/uip_sethostaddr.c
+ *
+ *   Copyright (C) 2007-2009, 2011 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * 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) && CONFIG_NSOCKET_DESCRIPTORS > 0
+
+#include <sys/socket.h>
+#include <sys/ioctl.h>
+
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+
+#include <netinet/in.h>
+#include <net/if.h>
+
+#include <apps/netutils/uiplib.h>
+
+/****************************************************************************
+ * Global Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: uip_sethostaddr
+ *
+ * Description:
+ *   Set the network driver IP address
+ *
+ * Parameters:
+ *   ifname   The name of the interface to use
+ *   ipaddr   The address to set
+ *
+ * Return:
+ *   0 on sucess; -1 on failure
+ *
+ ****************************************************************************/
+
+#ifdef CONFIG_NET_IPv6
+int uip_sethostaddr(const char *ifname, const struct in6_addr *addr)
+#else
+int uip_sethostaddr(const char *ifname, const struct in_addr *addr)
+#endif
+{
+  int ret = ERROR;
+  if (ifname && addr)
+    {
+      int sockfd = socket(PF_INET, UIPLIB_SOCK_IOCTL, 0);
+      if (sockfd >= 0)
+        {
+          struct ifreq req;
+#ifdef CONFIG_NET_IPv6
+          struct sockaddr_in6 *inaddr;
+#else
+          struct sockaddr_in  *inaddr;
+#endif
+          /* Add the device name to the request */
+
+          strncpy(req.ifr_name, ifname, IFNAMSIZ);
+
+          /* Add the INET address to the request */
+
+#ifdef CONFIG_NET_IPv6
+#error "req.ifr_addr.s_addr not big enough for IPv6 address"
+          inaddr             = (struct sockaddr_in6 *)&req.ifr_addr;
+          inaddr->sin_family = AF_INET6;
+          inaddr->sin_port   = 0;
+          memcpy(&inaddr->sin6_addr, addr, sizeof(struct in6_addr));
+#else
+          inaddr             = (struct sockaddr_in *)&req.ifr_addr;
+          inaddr->sin_family = AF_INET;
+          inaddr->sin_port   = 0;
+          memcpy(&inaddr->sin_addr, addr, sizeof(struct in_addr));
+#endif
+          ret = ioctl(sockfd, SIOCSIFADDR, (unsigned long)&req);
+          close(sockfd);
+        }
+    }
+  return ret;
+}
+
+#endif /* CONFIG_NET && CONFIG_NSOCKET_DESCRIPTORS */

netutils/uiplib/uip_setmacaddr.c

@@ -0,0 +1,114 @@
+/****************************************************************************
+ * netutils/uiplib/uip_setmacaddr.c
+ *
+ *   Copyright (C) 2007-2009, 2011 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * 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) && CONFIG_NSOCKET_DESCRIPTORS > 0
+
+#include <sys/socket.h>
+#include <sys/ioctl.h>
+#include <stdint.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+
+#include <netinet/in.h>
+#include <net/if.h>
+
+#include <apps/netutils/uiplib.h>
+
+/****************************************************************************
+ * Pre-processor Definitions
+ ****************************************************************************/
+
+#ifdef CONFIG_NET_IPv6
+# define AF_INETX AF_INET6
+#else
+# define AF_INETX AF_INET
+#endif
+
+/****************************************************************************
+ * Global Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: uip_setmacaddr
+ *
+ * Description:
+ *   Set the network driver MAC address
+ *
+ * Parameters:
+ *   ifname   The name of the interface to use
+ *   macaddr  MAC address to set, size must be IFHWADDRLEN
+ *
+ * Return:
+ *   0 on sucess; -1 on failure
+ *
+ ****************************************************************************/
+
+int uip_setmacaddr(const char *ifname, const uint8_t *macaddr)
+{
+  int ret = ERROR;
+  if (ifname && macaddr)
+    {
+      /* Get a socket (only so that we get access to the INET subsystem) */
+
+      int sockfd = socket(PF_INET, UIPLIB_SOCK_IOCTL, 0);
+      if (sockfd >= 0)
+        {
+          struct ifreq req;
+
+          /* Put the driver name into the request */
+
+          strncpy(req.ifr_name, ifname, IFNAMSIZ);
+
+          /* Put the new MAC address into the request */
+
+          req.ifr_hwaddr.sa_family = AF_INETX;
+          memcpy(&req.ifr_hwaddr.sa_data, macaddr, IFHWADDRLEN);
+
+          /* Perforom the ioctl to set the MAC address */
+
+          ret = ioctl(sockfd, SIOCSIFHWADDR, (unsigned long)&req);
+          close(sockfd);
+        }
+    }
+  return ret;
+}
+
+#endif /* CONFIG_NET && CONFIG_NSOCKET_DESCRIPTORS */

netutils/uiplib/uip_setnetmask.c

@@ -0,0 +1,116 @@
+/****************************************************************************
+ * netutils/uiplib/uip_setnetmask.c
+ *
+ *   Copyright (C) 2007-2009, 2011 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * 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) && CONFIG_NSOCKET_DESCRIPTORS > 0
+
+#include <sys/socket.h>
+#include <sys/ioctl.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+
+#include <netinet/in.h>
+#include <net/if.h>
+
+#include <apps/netutils/uiplib.h>
+
+/****************************************************************************
+ * Global Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: uip_setnetmask
+ *
+ * Description:
+ *   Set the netmask
+ *
+ * Parameters:
+ *   ifname   The name of the interface to use
+ *   ipaddr   The address to set
+ *
+ * Return:
+ *   0 on sucess; -1 on failure
+ *
+ ****************************************************************************/
+
+#ifdef CONFIG_NET_IPv6
+int uip_setnetmask(const char *ifname, const struct in6_addr *addr)
+#else
+int uip_setnetmask(const char *ifname, const struct in_addr *addr)
+#endif
+{
+  int ret = ERROR;
+  if (ifname && addr)
+    {
+      int sockfd = socket(PF_INET, UIPLIB_SOCK_IOCTL, 0);
+      if (sockfd >= 0)
+        {
+          struct ifreq req;
+#ifdef CONFIG_NET_IPv6
+          struct sockaddr_in6 *inaddr;
+#else
+          struct sockaddr_in  *inaddr;
+#endif
+          /* Add the device name to the request */
+
+          strncpy(req.ifr_name, ifname, IFNAMSIZ);
+
+          /* Add the INET address to the request */
+
+#ifdef CONFIG_NET_IPv6
+#error "req.ifr_addr.s_addr not big enough for IPv6 address"
+          inaddr             = (struct sockaddr_in6 *)&req.ifr_addr;
+          inaddr->sin_family = AF_INET6;
+          inaddr->sin_port   = 0;
+          memcpy(&inaddr->sin6_addr, addr, sizeof(struct in6_addr));
+#else
+          inaddr             = (struct sockaddr_in *)&req.ifr_addr;
+          inaddr->sin_family = AF_INET;
+          inaddr->sin_port   = 0;
+          memcpy(&inaddr->sin_addr, addr, sizeof(struct in_addr));
+#endif
+          ret = ioctl(sockfd, SIOCSIFNETMASK, (unsigned long)&req);
+          close(sockfd);
+        }
+    }
+  return ret;
+}
+
+#endif /* CONFIG_NET && CONFIG_NSOCKET_DESCRIPTORS */

netutils/uiplib/uiplib.c

@@ -0,0 +1,95 @@
+/****************************************************************************
+ * netutils/uiplib/uiplib.c
+ * Various uIP library functions.
+ *
+ *   Copyright (C) 2007, 2009, 2011 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * Based on uIP which also has a BSD style license:
+ *
+ *   Author: Adam Dunkels <adam@sics.se>
+ *   Copyright (c) 2004, Adam Dunkels and the Swedish Institute of
+ *   Computer Science.
+ *   All rights reserved.
+ *
+ * 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. The name of the author may not be used to endorse or promote
+ *    products derived from this software without specific prior
+ *    written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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 <stdint.h>
+#include <stdbool.h>
+
+#include <net/uip/uip.h>
+#include <apps/netutils/uiplib.h>
+
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
+
+bool uiplib_ipaddrconv(const char *addrstr, uint8_t *ipaddr)
+{
+  unsigned char tmp;
+  char c;
+  unsigned char i;
+  unsigned char j;
+
+  tmp = 0;
+
+  for (i = 0; i < 4; ++i)
+    {
+      j = 0;
+      do
+        {
+          c = *addrstr;
+          ++j;
+          if (j > 4)
+           {
+             return false;
+           }
+          if (c == '.' || c == 0)
+            {
+              *ipaddr = tmp;
+              ++ipaddr;
+              tmp = 0;
+            }
+          else if(c >= '0' && c <= '9')
+            {
+              tmp = (tmp * 10) + (c - '0');
+            }
+          else
+            {
+              return false;
+            }
+          ++addrstr;
+        }
+      while(c != '.' && c != 0);
+    }
+  return true;
+}

netutils/webclient/Makefile

@@ -0,0 +1,94 @@
+############################################################################
+# apps/netutils/webclient/Makefile
+#
+#   Copyright (C) 2011 Gregory Nutt. All rights reserved.
+#   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+#
+# 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.
+#
+############################################################################
+
+-include $(TOPDIR)/.config
+-include $(TOPDIR)/Make.defs
+include $(APPDIR)/Make.defs
+
+# Web client library
+
+ASRCS		=
+CSRCS		= 
+
+ifeq ($(CONFIG_NET_TCP),y)
+CSRCS		= webclient.c
+endif
+
+AOBJS		= $(ASRCS:.S=$(OBJEXT))
+COBJS		= $(CSRCS:.c=$(OBJEXT))
+
+SRCS		= $(ASRCS) $(CSRCS)
+OBJS		= $(AOBJS) $(COBJS)
+
+BIN	    	= ../../libapps$(LIBEXT)
+
+ROOTDEPPATH	= --dep-path .
+
+# Common build
+
+VPATH		= 
+
+all: .built
+
+$(AOBJS): %$(OBJEXT): %.S
+	$(call ASSEMBLE, $<, $@)
+
+$(COBJS): %$(OBJEXT): %.c
+	$(call COMPILE, $<, $@)
+
+$(BIN):	$(OBJS)
+	@( for obj in $(OBJS) ; do \
+		$(call ARCHIVE, $@, $${obj}); \
+	done ; )
+	@touch .built
+	
+.built: $(BIN)
+
+.depend: Makefile $(SRCS)
+	@$(MKDEP) $(ROOTDEPPATH) \
+	  $(CC) -- $(CFLAGS) -- $(SRCS) >Make.dep
+	@touch $@
+
+# Register application
+depend: .depend
+
+clean:
+	@rm -f $(BIN) *.o *~ .*.swp .built
+	$(call CLEAN)
+
+distclean: clean
+	@rm -f Make.dep .depend
+
+-include Make.dep

netutils/webclient/webclient.c

@@ -0,0 +1,583 @@
+/****************************************************************************
+ * netutils/webclient/webclient.c
+ * Implementation of the HTTP client.
+ *
+ *   Copyright (C) 2007, 2009, 2011 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * Based on uIP which also has a BSD style license:
+ *
+ *   Author: Adam Dunkels <adam@dunkels.com>
+ *   Copyright (c) 2002, Adam Dunkels.
+ *   All rights reserved.
+ *
+ * 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. The name of the author may not be used to endorse or promote
+ *    products derived from this software without specific prior
+ *    written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+ *
+ ****************************************************************************/
+
+/* This example shows a HTTP client that is able to download web pages
+ * and files from web servers. It requires a number of callback
+ * functions to be implemented by the module that utilizes the code:
+ * webclient_datahandler().
+ */
+
+/****************************************************************************
+ * Included Files
+ ****************************************************************************/
+
+#ifndef CONFIG_WEBCLIENT_HOST
+#  include <nuttx/config.h>
+#  include <nuttx/compiler.h>
+#  include <debug.h>
+#endif
+
+#include <sys/socket.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+
+#ifdef CONFIG_HAVE_GETHOSTBYNAME
+#  include <netdb.h>
+#else
+#  include <apps/netutils/resolv.h>
+#endif
+
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <apps/netutils/uiplib.h>
+#include <apps/netutils/webclient.h>
+
+/****************************************************************************
+ * Definitions
+ ****************************************************************************/
+
+#define WEBCLIENT_TIMEOUT          100
+
+#define WEBCLIENT_STATE_STATUSLINE 0
+#define WEBCLIENT_STATE_HEADERS    1
+#define WEBCLIENT_STATE_DATA       2
+#define WEBCLIENT_STATE_CLOSE      3
+
+#define HTTPSTATUS_NONE            0
+#define HTTPSTATUS_OK              1
+#define HTTPSTATUS_MOVED           2
+#define HTTPSTATUS_ERROR           3
+
+#define ISO_nl                     0x0a
+#define ISO_cr                     0x0d
+#define ISO_space                  0x20
+
+/****************************************************************************
+ * Private Types
+ ****************************************************************************/
+
+struct wget_s
+{
+  /* Internal status */
+
+  uint8_t state;
+  uint8_t httpstatus;
+
+  uint16_t port;     /* The port number to use in the connection */
+
+  /* These describe the just-received buffer of data */
+
+  FAR char *buffer;  /* user-provided buffer */
+  int buflen;        /* Length of the user provided buffer */
+  int offset;        /* Offset to the beginning of interesting data */
+  int datend;        /* Offset+1 to the last valid byte of data in the buffer */  
+
+  /* Buffer HTTP header data and parse line at a time */
+
+  char line[CONFIG_WEBCLIENT_MAXHTTPLINE];
+  int  ndx;
+
+#ifdef CONFIG_WEBCLIENT_GETMIMETYPE
+  char mimetype[CONFIG_WEBCLIENT_MAXMIMESIZE];
+#endif
+  char hostname[CONFIG_WEBCLIENT_MAXHOSTNAME];
+  char filename[CONFIG_WEBCLIENT_MAXFILENAME];
+};
+
+/****************************************************************************
+ * Private Data
+ ****************************************************************************/
+
+static const char g_http10[]          = "HTTP/1.0";
+static const char g_http11[]          = "HTTP/1.1";
+#ifdef CONFIG_WEBCLIENT_GETMIMETYPE
+static const char g_httpcontenttype[] = "content-type: ";
+#endif
+static const char g_httphost[]        = "host: ";
+static const char g_httplocation[]    = "location: ";
+static const char g_httpget[]         = "GET ";
+
+static const char g_httpuseragentfields[] =
+  "Connection: close\r\n"
+  "User-Agent: NuttX/0.4.x (; http://www.nuttx.org/)\r\n\r\n";
+
+static const char g_http200[]         = "200 ";
+static const char g_http301[]         = "301 ";
+static const char g_http302[]         = "302 ";
+
+static const char g_httpcrnl[]        = "\r\n";
+
+/****************************************************************************
+ * Private Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Private Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: wget_strcpy
+ ****************************************************************************/
+
+static char *wget_strcpy(char *dest, const char *src)
+{
+  int len = strlen(src);
+  memcpy(dest, src, len);
+  dest[len] = '\0';
+  return dest + len;
+}
+
+/****************************************************************************
+ * Name: wget_resolvehost
+ ****************************************************************************/
+
+static inline int wget_resolvehost(const char *hostname, in_addr_t *ipaddr)
+{
+#ifdef CONFIG_HAVE_GETHOSTBYNAME
+
+  struct hostent *he;
+
+  nvdbg("Getting address of %s\n", hostname);
+  he = gethostbyname(hostname);
+  if (!he)
+    {
+      ndbg("gethostbyname failed: %d\n", h_errno);
+      return ERROR;
+    }
+
+  nvdbg("Using IP address %04x%04x\n", (uint16_t)he->h_addr[1], (uint16_t)he->h_addr[0]);
+  memcpy(ipaddr, he->h_addr, sizeof(in_addr_t));
+  return OK;
+
+#else
+
+# ifdef CONFIG_NET_IPv6
+  struct sockaddr_in6 addr;
+# else
+  struct sockaddr_in addr;
+# endif
+
+  /* First check if the host is an IP address. */
+
+  if (!uiplib_ipaddrconv(hostname, (uint8_t*)ipaddr))
+    {
+      /* 'host' does not point to a valid address string.  Try to resolve
+       *  the host name to an IP address.
+       */
+ 
+      if (resolv_query(hostname, &addr) < 0)
+        {
+          /* Needs to set the errno here */
+
+          return ERROR;
+        }
+
+      /* Save the host address -- Needs fixed for IPv6 */
+
+      *ipaddr = addr.sin_addr.s_addr;
+  }
+  return OK;
+
+#endif
+}
+
+/****************************************************************************
+ * Name: wget_parsestatus
+ ****************************************************************************/
+
+static inline int wget_parsestatus(struct wget_s *ws)
+{
+  int offset;
+  int ndx;
+  char *dest;
+
+  offset = ws->offset;
+  ndx    = ws->ndx;
+
+  while (offset < ws->datend)
+    {
+      ws->line[ndx] = ws->buffer[offset];
+      if (ws->line[ndx] == ISO_nl)
+        {
+          ws->line[ndx] = '\0';
+          if ((strncmp(ws->line, g_http10, strlen(g_http10)) == 0) ||
+              (strncmp(ws->line, g_http11, strlen(g_http11)) == 0))
+            {
+              dest = &(ws->line[9]);
+              ws->httpstatus = HTTPSTATUS_NONE;
+
+              /* Check for 200 OK */
+
+              if (strncmp(dest, g_http200, strlen(g_http200)) == 0)
+                {
+                  ws->httpstatus = HTTPSTATUS_OK;
+                }
+
+              /* Check for 301 Moved permanently or 302 Found. Location: header line
+               * will contain the new location.
+               */
+
+              else if (strncmp(dest, g_http301, strlen(g_http301)) == 0 ||
+                       strncmp(dest, g_http302, strlen(g_http302)) == 0)
+                {
+
+                  ws->httpstatus = HTTPSTATUS_MOVED;
+                }
+            }
+          else
+            {
+              return - ECONNABORTED;
+            }
+
+          /* We're done parsing the status line, so start parsing the HTTP headers. */
+
+          ws->state = WEBCLIENT_STATE_HEADERS;
+          break;
+        }
+      else
+        {
+          offset++;
+          ndx++;
+        }
+    }
+
+  ws->offset = offset;
+  ws->ndx    = ndx;
+  return OK;
+}
+
+/****************************************************************************
+ * Name: wget_parsestatus
+ ****************************************************************************/
+
+static inline int wget_parseheaders(struct wget_s *ws)
+{
+  int offset;
+  int ndx;
+
+  offset = ws->offset;
+  ndx    = ws->ndx;
+
+  while (offset < ws->datend)
+    {
+      ws->line[ndx] = ws->buffer[offset];
+      if (ws->line[ndx] == ISO_nl)
+        {
+          /* We have an entire HTTP header line in s.line, so
+           * we parse it.
+           */
+
+          if (ndx > 0) /* Should always be true */
+            {
+              if (ws->line[0] == ISO_cr)
+                {
+                  /* This was the last header line (i.e., and empty "\r\n"), so
+                   * we are done with the headers and proceed with the actual
+                   * data.
+                   */
+
+                  ws->state = WEBCLIENT_STATE_DATA;
+                  goto exit;
+               }
+
+              /* Truncate the trailing \r\n */
+
+              ws->line[ndx-1] = '\0';
+
+              /* Check for specific HTTP header fields. */
+
+#ifdef CONFIG_WEBCLIENT_GETMIMETYPE
+              if (strncasecmp(ws->line, g_httpcontenttype, strlen(g_httpcontenttype)) == 0)
+                {
+                  /* Found Content-type field. */
+
+                  char *dest = strchr(ws->line, ';');
+                  if (dest != NULL)
+                    {
+                      *dest = 0;
+                   }
+                  strncpy(ws->mimetype, ws->line + strlen(g_httpcontenttype), sizeof(ws->mimetype));
+                }
+              else
+#endif
+              if (strncasecmp(ws->line, g_httplocation, strlen(g_httplocation)) == 0)
+                {
+                  /* Parse the new HTTP host and filename from the URL.  Note that
+                   * the return value is ignored.  In the event of failure, we
+                   * retain the current location.
+                   */
+
+                  (void)uip_parsehttpurl(ws->line + strlen(g_httplocation), &ws->port,
+                                         ws->hostname, CONFIG_WEBCLIENT_MAXHOSTNAME,
+                                         ws->filename, CONFIG_WEBCLIENT_MAXFILENAME);
+                  nvdbg("New hostname='%s' filename='%s'\n", ws->hostname, ws->filename);
+                }
+            }
+
+          /* We're done parsing this line, so we reset the index to the start
+           * of the next line.
+           */
+
+          ndx = 0;
+        }
+      else
+        {
+          ndx++;
+        }
+      offset++;
+    }
+
+exit:
+  ws->offset = offset;
+  ws->ndx    = ndx;
+  return OK;
+}
+
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: wget
+ *
+ * Description:
+ *   Obtain the requested file from an HTTP server using the GET method.
+ *
+ *   Note: If the function is passed a host name, it must already be in
+ *   the resolver cache in order for the function to connect to the web
+ *   server. It is therefore up to the calling module to implement the
+ *   resolver calls and the signal handler used for reporting a resolv
+ *   query answer.
+ *
+ * Input Parameters
+ *   url      - A pointer to a string containing either the full URL to
+ *              the file to get (e.g., http://www.nutt.org/index.html, or
+ *              http://192.168.23.1:80/index.html).
+ *   buffer   - A user provided buffer to receive the file data (also
+ *              used for the outgoing GET request
+ *   buflen   - The size of the user provided buffer
+ *   callback - As data is obtained from the host, this function is
+ *              to dispose of each block of file data as it is received.
+ *
+ * Returned Value:
+ *   0: if the GET operation completed successfully;
+ *  -1: On a failure with errno set appropriately 
+ *
+ ****************************************************************************/
+ 
+int wget(FAR const char *url, FAR char *buffer, int buflen,
+         wget_callback_t callback, FAR void *arg)
+{
+  struct sockaddr_in server;
+  struct wget_s ws;
+  bool redirected;
+  char *dest;
+  int sockfd;
+  int len;
+  int ret = OK;
+
+  /* Initialize the state structure */
+
+  memset(&ws, 0, sizeof(struct wget_s));
+  ws.buffer = buffer;
+  ws.buflen = buflen;
+  ws.port   = 80;
+
+  /* Parse the hostname (with optional port number) and filename from the URL */
+
+  ret = uip_parsehttpurl(url, &ws.port,
+                         ws.hostname, CONFIG_WEBCLIENT_MAXHOSTNAME,
+                         ws.filename, CONFIG_WEBCLIENT_MAXFILENAME);
+  if (ret != 0)
+    {
+      ndbg("Malformed HTTP URL: %s\n", url);
+      errno = -ret;
+      return ERROR;
+    }
+  nvdbg("hostname='%s' filename='%s'\n", ws.hostname, ws.filename);
+
+  /* The following sequence may repeat indefinitely if we are redirected */
+
+  do
+    {
+      /* Re-initialize portions of the state structure that could have
+       * been left from the previous time through the loop and should not
+       * persist with the new connection.
+       */
+
+      ws.httpstatus = HTTPSTATUS_NONE;
+      ws.offset     = 0;
+      ws.datend     = 0;
+      ws.ndx        = 0;
+
+      /* Create a socket */
+
+      sockfd = socket(AF_INET, SOCK_STREAM, 0);
+      if (sockfd < 0)
+        {
+          /* socket failed.  It will set the errno appropriately */
+
+          ndbg("socket failed: %d\n", errno);
+          return ERROR;
+        }
+
+      /* Get the server adddress from the host name */
+
+      server.sin_family = AF_INET;
+      server.sin_port   = htons(ws.port);
+      ret = wget_resolvehost(ws.hostname, &server.sin_addr.s_addr);
+      if (ret < 0)
+        {
+          /* Could not resolve host (or malformed IP address) */
+
+          ndbg("Failed to resolve hostname\n");
+          ret = -EHOSTUNREACH;
+          goto errout_with_errno;
+        }
+
+      /* Connect to server.  First we have to set some fields in the
+       * 'server' address structure.  The system will assign me an arbitrary
+       * local port that is not in use.
+       */
+
+      ret = connect(sockfd, (struct sockaddr *)&server, sizeof(struct sockaddr_in));
+      if (ret < 0)
+        {
+          ndbg("connect failed: %d\n", errno);
+          goto errout;
+        }
+
+      /* Send the GET request */
+
+      dest   = ws.buffer;
+      dest   = wget_strcpy(dest, g_httpget);
+      dest   = wget_strcpy(dest, ws.filename);
+     *dest++ = ISO_space;
+      dest   = wget_strcpy(dest, g_http10);
+      dest   = wget_strcpy(dest, g_httpcrnl);
+      dest   = wget_strcpy(dest, g_httphost);
+      dest   = wget_strcpy(dest, ws.hostname);
+      dest   = wget_strcpy(dest, g_httpcrnl);
+      dest   = wget_strcpy(dest, g_httpuseragentfields);
+      len    = dest - buffer;
+
+      ret    = send(sockfd, buffer, len, 0);
+      if (ret < 0)
+        {
+          ndbg("send failed: %d\n", errno);
+          goto errout;
+        }
+
+      /* Now loop to get the file sent in response to the GET.  This
+       * loop continues until either we read the end of file (nbytes == 0)
+       * or until we detect that we have been redirected.
+       */
+
+      ws.state   = WEBCLIENT_STATE_STATUSLINE;
+      redirected = false;
+      for(;;)
+        {
+          ws.datend = recv(sockfd, ws.buffer, ws.buflen, 0);
+          if (ws.datend < 0)
+            {
+              ndbg("recv failed: %d\n", errno);
+              ret = ws.datend;
+              goto errout_with_errno;
+            }
+          else if (ret == 0)
+            {
+              close(sockfd);            
+              break;
+            }
+
+          /* Handle initial parsing of the status line */
+
+          ws.offset = 0;
+          if (ws.state == WEBCLIENT_STATE_STATUSLINE)
+            {
+              ret = wget_parsestatus(&ws);
+              if (ret < 0)
+                {
+                  goto errout_with_errno;
+                }
+            }
+
+          /* Parse the HTTP data */
+
+          if (ws.state == WEBCLIENT_STATE_HEADERS)
+            {
+              ret = wget_parseheaders(&ws);
+              if (ret < 0)
+                {
+                  goto errout_with_errno;
+                }
+            }
+
+          /* Dispose of the data payload */
+
+          if (ws.state == WEBCLIENT_STATE_DATA)
+            {
+              if (ws.httpstatus != HTTPSTATUS_MOVED)
+                {
+                  /* Let the client decide what to do with the received file */
+
+                  callback(&ws.buffer, ws.offset, ws.datend, &buflen, arg);
+                }
+              else
+                {
+                  redirected = true;
+                  close(sockfd);            
+                  break;
+                }
+            }
+        }
+    }
+  while (redirected);
+  return OK;
+
+errout_with_errno:
+  errno = -ret;
+errout:
+  close(sockfd);
+  return ERROR;
+}

netutils/webserver/Makefile

@@ -0,0 +1,94 @@
+############################################################################
+# apps/netutils/webserver/Makefile
+#
+#   Copyright (C) 2011 Gregory Nutt. All rights reserved.
+#   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+#
+# 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.
+#
+############################################################################
+
+-include $(TOPDIR)/.config
+-include $(TOPDIR)/Make.defs
+include $(APPDIR)/Make.defs
+
+# Web server library
+
+ASRCS		=
+CSRCS		= 
+
+ifeq ($(CONFIG_NET_TCP),y)
+CSRCS		= httpd.c httpd_fs.c httpd_cgi.c
+endif
+
+AOBJS		= $(ASRCS:.S=$(OBJEXT))
+COBJS		= $(CSRCS:.c=$(OBJEXT))
+
+SRCS		= $(ASRCS) $(CSRCS)
+OBJS		= $(AOBJS) $(COBJS)
+
+BIN	    	= ../../libapps$(LIBEXT)
+
+ROOTDEPPATH	= --dep-path .
+
+# Common build
+
+VPATH		= 
+
+all: .built
+
+$(AOBJS): %$(OBJEXT): %.S
+	$(call ASSEMBLE, $<, $@)
+
+$(COBJS): %$(OBJEXT): %.c
+	$(call COMPILE, $<, $@)
+
+$(BIN):	$(OBJS)
+	@( for obj in $(OBJS) ; do \
+		$(call ARCHIVE, $@, $${obj}); \
+	done ; )
+	@touch .built
+	
+.built: $(BIN)
+
+.depend: Makefile $(SRCS)
+	@$(MKDEP) $(ROOTDEPPATH) \
+	  $(CC) -- $(CFLAGS) -- $(SRCS) >Make.dep
+	@touch $@
+
+# Register application
+depend: .depend
+
+clean:
+	@rm -f $(BIN) *.o *~ .*.swp .built
+	$(call CLEAN)
+
+distclean: clean
+	@rm -f Make.dep .depend
+
+-include Make.dep

netutils/webserver/httpd.c

@@ -0,0 +1,498 @@
+/****************************************************************************
+ * netutils/webserver/httpd.c
+ * httpd Web server
+ *
+ *   Copyright (C) 2007-2009, 2011 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * This is a leverage of similar logic from uIP:
+ *
+ *   Author: Adam Dunkels <adam@sics.se>
+ *   Copyright (c) 2004, Adam Dunkels.
+ *   All rights reserved.
+ *
+ *   The uIP web server is a very simplistic implementation of an HTTP
+ *   server. It can serve web pages and files from a read-only ROM
+ *   filesystem, and provides a very small scripting language.
+ *
+ * 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 of the Institute 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 INSTITUTE 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 INSTITUTE 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>
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <pthread.h>
+#include <errno.h>
+#include <debug.h>
+
+#include <net/uip/uip.h>
+#include <apps/netutils/uiplib.h>
+#include <apps/netutils/httpd.h>
+
+#include "httpd.h"
+#include "httpd_cgi.h"
+
+/****************************************************************************
+ * Pre-processor Definitions
+ ****************************************************************************/
+
+#define ISO_nl      0x0a
+#define ISO_space   0x20
+#define ISO_bang    0x21
+#define ISO_percent 0x25
+#define ISO_period  0x2e
+#define ISO_slash   0x2f
+#define ISO_colon   0x3a
+
+/****************************************************************************
+ * Private Data
+ ****************************************************************************/
+
+static const char g_httpcontenttypebinary[] = "Content-type: application/octet-stream\r\n\r\n";
+static const char g_httpcontenttypecss[]    = "Content-type: text/css\r\n\r\n";
+static const char g_httpcontenttypegif[]    = "Content-type: image/gif\r\n\r\n";
+static const char g_httpcontenttypehtml[]   = "Content-type: text/html\r\n\r\n";
+static const char g_httpcontenttypejpg[]    = "Content-type: image/jpeg\r\n\r\n";
+static const char g_httpcontenttypeplain[]  = "Content-type: text/plain\r\n\r\n";
+static const char g_httpcontenttypepng[]    = "Content-type: image/png\r\n\r\n";
+
+static const char g_httpextensionhtml[]     = ".html";
+static const char g_httpextensionshtml[]    = ".shtml";
+static const char g_httpextensioncss[]      = ".css";
+static const char g_httpextensionpng[]      = ".png";
+static const char g_httpextensiongif[]      = ".gif";
+static const char g_httpextensionjpg[]      = ".jpg";
+
+static const char g_http404path[]           = "/404.html";
+static const char g_httpindexpath[]         = "/index.html";
+
+static const char g_httpcmdget[]            = "GET ";
+
+static const char g_httpheader200[]         =
+  "HTTP/1.0 200 OK\r\n"
+  "Server: uIP/1.0 http://www.sics.se/~adam/uip/\r\n"
+  "Connection: close\r\n";
+
+static const char g_httpheader404[]         =
+   "HTTP/1.0 404 Not found\r\n"
+   "Server: uIP/1.0 http://www.sics.se/~adam/uip/\r\n"
+   "Connection: close\r\n";
+
+/****************************************************************************
+ * Private Functions
+ ****************************************************************************/
+
+#ifdef CONFIG_NETUTILS_HTTPD_DUMPBUFFER
+static void httpd_dumpbuffer(FAR const char *msg, FAR const char *buffer, unsigned int nbytes)
+{
+  /* CONFIG_DEBUG, CONFIG_DEBUG_VERBOSE, and CONFIG_DEBUG_NET have to be
+   * defined or the following does nothing.
+   */
+    
+  nvdbgdumpbuffer(msg, (FAR const uint8_t*)buffer, nbytes);
+}
+#else
+# define httpd_dumpbuffer(msg,buffer,nbytes)
+#endif
+
+#ifdef CONFIG_NETUTILS_HTTPD_DUMPPSTATE
+static void httpd_dumppstate(struct httpd_state *pstate, const char *msg)
+{
+#if defined(CONFIG_DEBUG) && defined(CONFIG_DEBUG_VERBOSE) && defined(CONFIG_DEBUG_NET)
+  nvdbg("[%d] pstate(%p): [%s]\n", pstate->ht_sockfd, pstate, msg);
+  nvdbg("  filename:      [%s]\n", pstate->ht_filename);
+  nvdbg("  htfile len:    %d\n", pstate->ht_file.len);
+  nvdbg("  sockfd:        %d\n", pstate->ht_sockfd);
+  nvdbg("  scriptptr:     %p\n", pstate->ht_scriptptr);
+  nvdbg("  scriptlen:     %d\n", pstate->ht_scriptlen);
+  nvdbg("  sndlen:        %d\n", pstate->ht_sndlen);
+#endif
+}
+#else
+# define httpd_dumppstate(pstate, msg)
+#endif
+
+static void next_scriptstate(struct httpd_state *pstate)
+{
+  char *p;
+  p = strchr(pstate->ht_scriptptr, ISO_nl) + 1;
+  pstate->ht_scriptlen -= (unsigned short)(p - pstate->ht_scriptptr);
+  pstate->ht_scriptptr  = p;
+}
+
+static int handle_script(struct httpd_state *pstate)
+{
+  int len;
+  char *ptr;
+
+  while (pstate->ht_file.len > 0)
+    {
+      /* Check if we should start executing a script */
+
+      if (*pstate->ht_file.data == ISO_percent && *(pstate->ht_file.data + 1) == ISO_bang)
+        {
+          pstate->ht_scriptptr = pstate->ht_file.data + 3;
+          pstate->ht_scriptlen = pstate->ht_file.len - 3;
+          if (*(pstate->ht_scriptptr - 1) == ISO_colon)
+            {
+              httpd_fs_open(pstate->ht_scriptptr + 1, &pstate->ht_file);
+              send(pstate->ht_sockfd, pstate->ht_file.data, pstate->ht_file.len, 0);
+            }
+          else
+            {
+              httpd_cgi(pstate->ht_scriptptr)(pstate, pstate->ht_scriptptr);
+            }
+          next_scriptstate(pstate);
+
+          /* The script is over, so we reset the pointers and continue
+           * sending the rest of the file
+           */
+
+          pstate->ht_file.data = pstate->ht_scriptptr;
+          pstate->ht_file.len  = pstate->ht_scriptlen;
+        }
+      else
+        {
+          /* See if we find the start of script marker in the block of HTML
+           * to be sent
+           */
+
+          if (pstate->ht_file.len > HTTPD_IOBUFFER_SIZE)
+            {
+              len = HTTPD_IOBUFFER_SIZE;
+            }
+          else
+            {
+              len = pstate->ht_file.len;
+            }
+
+          if (*pstate->ht_file.data == ISO_percent)
+            {
+              ptr = strchr(pstate->ht_file.data + 1, ISO_percent);
+            }
+          else
+            {
+              ptr = strchr(pstate->ht_file.data, ISO_percent);
+            }
+
+          if (ptr != NULL && ptr != pstate->ht_file.data)
+            {
+              len = (int)(ptr - pstate->ht_file.data);
+              if (len >= HTTPD_IOBUFFER_SIZE)
+                {
+                  len = HTTPD_IOBUFFER_SIZE;
+                }
+            }
+          send(pstate->ht_sockfd, pstate->ht_file.data, len, 0);
+          pstate->ht_file.data += len;
+          pstate->ht_file.len  -= len;
+        }
+    }
+  return OK;
+}
+
+static int httpd_addchunk(struct httpd_state *pstate, const char *buffer, int len)
+{
+  int newlen;
+  int chunklen;
+  int ret;
+
+  do
+    {
+      /* Determine the size of the next chunk so that it fits into the buffer */
+
+      newlen = pstate->ht_sndlen + len;
+      if (newlen > HTTPD_IOBUFFER_SIZE)
+        {
+          newlen   = HTTPD_IOBUFFER_SIZE;
+          chunklen = HTTPD_IOBUFFER_SIZE - pstate->ht_sndlen;
+        }
+      else
+        {
+          chunklen = len;
+        }
+      nvdbg("[%d] sndlen=%d len=%d newlen=%d chunklen=%d\n",
+            pstate->ht_sockfd, pstate->ht_sndlen, len, newlen, chunklen);
+
+      /* Copy that chunk into the send buffer */
+
+      memcpy(&pstate->ht_buffer[pstate->ht_sndlen], buffer, chunklen);
+
+      if (newlen >= HTTPD_IOBUFFER_SIZE)
+        {
+          /* The buffer is full.. Send what we have and reset to send again */
+
+          httpd_dumpbuffer("Outgoing buffer", pstate->ht_buffer, newlen);
+          ret = send(pstate->ht_sockfd, pstate->ht_buffer, newlen, 0);
+          if (ret < 0)
+            {
+              return ret;
+            }
+
+          newlen = 0;
+        }
+
+      pstate->ht_sndlen = newlen;
+      len              -= chunklen;
+      buffer           += chunklen;
+    }
+  while (len > 0);
+  return OK;
+}
+
+static int send_headers(struct httpd_state *pstate, const char *statushdr, int len)
+{
+  char *ptr;
+  int ret;
+
+  ret = httpd_addchunk(pstate, statushdr, len);
+  if (ret < 0)
+    {
+      return ret;
+    }
+
+  ptr = strrchr(pstate->ht_filename, ISO_period);
+  if (ptr == NULL)
+    {
+      ret = httpd_addchunk(pstate, g_httpcontenttypebinary, strlen(g_httpcontenttypebinary));
+    }
+  else if (strncmp(g_httpextensionhtml, ptr, strlen(g_httpextensionhtml)) == 0 ||
+           strncmp(g_httpextensionshtml, ptr, strlen(g_httpextensionshtml)) == 0)
+    {
+      ret = httpd_addchunk(pstate, g_httpcontenttypehtml, strlen(g_httpcontenttypehtml));
+    }
+  else if (strncmp(g_httpextensioncss, ptr, strlen(g_httpextensioncss)) == 0)
+    {
+      ret = httpd_addchunk(pstate, g_httpcontenttypecss, strlen(g_httpcontenttypecss));
+    }
+  else if (strncmp(g_httpextensionpng, ptr, strlen(g_httpextensionpng)) == 0)
+    {
+      ret = httpd_addchunk(pstate, g_httpcontenttypepng, strlen(g_httpcontenttypepng));
+    }
+  else if (strncmp(g_httpextensiongif, ptr, strlen(g_httpextensiongif)) == 0)
+    {
+      ret = httpd_addchunk(pstate, g_httpcontenttypegif, strlen(g_httpcontenttypegif));
+    }
+  else if (strncmp(g_httpextensionjpg, ptr, strlen(g_httpextensionjpg)) == 0)
+    {
+      ret = httpd_addchunk(pstate, g_httpcontenttypejpg, strlen(g_httpcontenttypejpg));
+    }
+  else
+    {
+      ret = httpd_addchunk(pstate, g_httpcontenttypeplain, strlen(g_httpcontenttypeplain));
+    }
+
+  return ret;
+}
+
+static int httpd_sendfile(struct httpd_state *pstate)
+{
+  char *ptr;
+  int ret = ERROR;
+
+  pstate->ht_sndlen = 0;
+
+  nvdbg("[%d] sending file '%s'\n", pstate->ht_sockfd, pstate->ht_filename);
+  if (!httpd_fs_open(pstate->ht_filename, &pstate->ht_file))
+    {
+      ndbg("[%d] '%s' not found\n", pstate->ht_sockfd, pstate->ht_filename);
+      memcpy(pstate->ht_filename, g_http404path, strlen(g_http404path));
+      httpd_fs_open(g_http404path, &pstate->ht_file);
+      if (send_headers(pstate, g_httpheader404, strlen(g_httpheader404)) == OK)
+        {
+          ret = httpd_addchunk(pstate, pstate->ht_file.data, pstate->ht_file.len);
+        }
+    }
+  else
+    {
+      if (send_headers(pstate, g_httpheader200, strlen(g_httpheader200)) == OK)
+        {
+          ptr = strchr(pstate->ht_filename, ISO_period);
+          if (ptr != NULL &&
+              strncmp(ptr, g_httpextensionshtml, strlen(g_httpextensionshtml)) == 0)
+            {
+              ret = handle_script(pstate);
+            }
+          else
+            {
+              ret = httpd_addchunk(pstate, pstate->ht_file.data, pstate->ht_file.len);
+            }
+        }
+    }
+
+  /* Send anything remaining in the buffer */
+
+  if (ret == OK && pstate->ht_sndlen > 0)
+    {
+      httpd_dumpbuffer("Outgoing buffer", pstate->ht_buffer, pstate->ht_sndlen);
+      if (send(pstate->ht_sockfd, pstate->ht_buffer, pstate->ht_sndlen, 0) < 0)
+        {
+          ret = ERROR;
+        }
+    }
+
+  return ret;
+}
+
+static inline int httpd_cmd(struct httpd_state *pstate)
+{
+  ssize_t recvlen;
+  int i;
+
+  /* Get the next HTTP command.  We will handle only GET */
+
+  recvlen = recv(pstate->ht_sockfd, pstate->ht_buffer, HTTPD_IOBUFFER_SIZE, 0);
+  if (recvlen < 0)
+    {
+      ndbg("[%d] recv failed: %d\n", pstate->ht_sockfd, errno);
+      return ERROR;
+    }
+  httpd_dumpbuffer("Incoming buffer", pstate->ht_buffer, recvlen);
+
+  /*  We will handle only GET */
+
+  if (strncmp(pstate->ht_buffer, g_httpcmdget, strlen(g_httpcmdget)) != 0)
+    {
+      ndbg("[%d] Unsupported command\n", pstate->ht_sockfd);
+      return ERROR;
+    }
+
+  /* Get the name of the file to provide */
+
+  if (pstate->ht_buffer[4] != ISO_slash)
+    {
+      ndbg("[%d] Missing path\n", pstate->ht_sockfd);
+      return ERROR;
+    }
+  else if (pstate->ht_buffer[5] == ISO_space)
+    {
+      strncpy(pstate->ht_filename, g_httpindexpath, strlen(g_httpindexpath));
+    }
+  else
+    {
+      for (i = 0;
+           i < (HTTPD_MAX_FILENAME-1) && pstate->ht_buffer[i+4] != ISO_space;
+           i++)
+        {
+          pstate->ht_filename[i] = pstate->ht_buffer[i+4];
+        }
+        pstate->ht_filename[i]='\0';
+    }
+  nvdbg("[%d] Filename: %s\n", pstate->ht_sockfd, pstate->ht_filename);
+
+  /* Then send the file */
+
+  return httpd_sendfile(pstate);
+}
+
+/****************************************************************************
+ * Name: httpd_handler
+ *
+ * Description:
+ *   Each time a new connection to port 80 is made, a new thread is created
+ *   that begins at this entry point.  There should be exactly one argument
+ *   and it should be the socket descriptor (+1).
+ *
+ ****************************************************************************/
+
+static void *httpd_handler(void *arg)
+{
+  struct httpd_state *pstate = (struct httpd_state *)malloc(sizeof(struct httpd_state));
+  int                 sockfd = (int)arg;
+  int                 ret    = ERROR;
+
+  nvdbg("[%d] Started\n", sockfd);
+
+  /* Verify that the state structure was successfully allocated */
+
+  if (pstate)
+    {
+      /* Re-initialize the thread state structure */
+
+      memset(pstate, 0, sizeof(struct httpd_state));
+      pstate->ht_sockfd = sockfd;
+
+      /* Then handle the next httpd command */
+
+      ret = httpd_cmd(pstate);
+
+      /* End of command processing -- Clean up and exit */
+
+      free(pstate);
+    }
+
+  /* Exit the task */
+
+  nvdbg("[%d] Exitting\n", sockfd);
+  close(sockfd);
+  return NULL;
+}
+
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
+/****************************************************************************
+ * Name: httpd_listen
+ *
+ * Description:
+ *   This is the main processing thread for the webserver.  It never returns
+ *   unless an error occurs
+ *
+ ****************************************************************************/
+
+int httpd_listen(void)
+{
+  /* Execute httpd_handler on each connection to port 80 */
+
+  uip_server(HTONS(80), httpd_handler, CONFIG_NETUTILS_HTTPDSTACKSIZE);
+
+  /* uip_server only returns on errors */
+
+  return ERROR;
+}
+
+/****************************************************************************
+ * Name: httpd_init
+ *
+ * Description:
+ *   This function initializes the web server and should be called at system
+ *   boot-up.
+ *
+ ****************************************************************************/
+
+void httpd_init(void)
+{
+}

netutils/webserver/httpd.h

@@ -0,0 +1,118 @@
+/****************************************************************************
+ * netutils/webserver/httpd.h
+ *
+ *   Copyright (C) 2007, 2009 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * Based on uIP which also has a BSD style license:
+ *
+ *   Author: Adam Dunkels <adam@sics.se>
+ *   Copyright (c) 2001-2005, Adam Dunkels.
+ *   All rights reserved.
+ *
+ * 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. The name of the author may not be used to endorse or promote
+ *    products derived from this software without specific prior
+ *    written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ ****************************************************************************/
+
+#ifndef _NETUTILS_WEBSERVER_HTTPD_H
+#define _NETUTILS_WEBSERVER_HTTPD_H
+
+/****************************************************************************
+ * Included Files
+ ****************************************************************************/
+
+#include <nuttx/config.h>
+#include <stdint.h>
+#include <net/uip/uip.h>
+#include <net/uip/uipopt.h>
+
+/****************************************************************************
+ * Pre-processor Definitions
+ ****************************************************************************/
+
+/* As threads are created to handle each request, a stack must be allocated
+ * for the thread.  Use a default if the user provided no stacksize.
+ */
+
+#ifndef  CONFIG_NETUTILS_HTTPDSTACKSIZE
+# define CONFIG_NETUTILS_HTTPDSTACKSIZE 4096
+#endif
+
+#undef  CONFIG_NETUTILS_HTTPDFSSTATS
+#define CONFIG_NETUTILS_HTTPDFSSTATS 1
+
+#ifndef  CONFIG_NET_STATISTICS
+#  undef CONFIG_NETUTILS_HTTPDNETSTATS
+#endif
+
+/* For efficiency reasons, the size of the IO buffer should be a multiple
+ * of the TCP MSS value.  Also, the current design requires that the IO
+ * buffer be sufficiently large to contain the entire GET request.
+ */
+
+#define HTTPD_IOBUFFER_SIZE (3*UIP_TCP_MSS)
+
+/* this is the maximum size of a file path */
+
+#define HTTPD_MAX_FILENAME  20
+
+/****************************************************************************
+ * Public Types
+ ****************************************************************************/
+
+struct httpd_fs_file
+{
+  char *data;
+  int len;
+};
+
+struct httpd_state
+{
+  char     ht_buffer[HTTPD_IOBUFFER_SIZE];  /* recv()/send() buffer */
+  char     ht_filename[HTTPD_MAX_FILENAME]; /* filename from GET command */
+  struct httpd_fs_file ht_file;             /* Fake file data to send */
+  int      ht_sockfd;                       /* The socket descriptor from accept() */
+  char    *ht_scriptptr;
+  uint16_t ht_scriptlen;
+  uint16_t ht_sndlen;
+};
+
+/****************************************************************************
+ * Public Function Prototypes
+ ****************************************************************************/
+
+#ifdef CONFIG_NETUTILS_HTTPDFSSTATS
+#if CONFIG_NETUTILS_HTTPDFSSTATS == 1
+extern uint16_t httpd_fs_count(char *name);
+#endif /* CONFIG_NETUTILS_HTTPDFSSTATS */
+#endif /* CONFIG_NETUTILS_HTTPDFSSTATS */
+
+/* file must be allocated by caller and will be filled in by the function. */
+
+int  httpd_fs_open(const char *name, struct httpd_fs_file *file);
+void httpd_fs_init(void);
+
+#endif /* _NETUTILS_WEBSERVER_HTTPD_H */

netutils/webserver/httpd_cgi.c

@@ -0,0 +1,170 @@
+/****************************************************************************
+ * httpd_cgi.c
+ * Web server script interface
+ * Author: Adam Dunkels <adam@sics.se>
+ *
+ * Copyright (c) 2001-2006, Adam Dunkels.
+ * All rights reserved.
+ *
+ * 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. The name of the author may not be used to endorse or promote
+ *    products derived from this software without specific prior
+ *    written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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 <stdio.h>
+#include <string.h>
+#include <sys/socket.h>
+
+#include <nuttx/compiler.h>
+
+#include <net/uip/uip.h>
+#include <apps/netutils/httpd.h>
+
+#include "httpd_cgi.h"
+
+/****************************************************************************
+ * Pre-processor Definitions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Private Function Prototypes
+ ****************************************************************************/
+
+static void nullfunction(struct httpd_state *pstate, char *ptr);
+#ifdef CONFIG_NETUTILS_HTTPDNETSTATS
+static void net_stats(struct httpd_state *pstate, char *ptr);
+#endif
+
+#ifdef CONFIG_NETUTILS_HTTPDFILESTATS
+static void file_stats(struct httpd_state *pstate, char *ptr);
+#endif
+
+/****************************************************************************
+ * Private Data
+ ****************************************************************************/
+
+#ifdef CONFIG_NETUTILS_HTTPDFILESTATS
+HTTPD_CGI_CALL(file, "file-stats", file_stats);
+#endif
+#ifdef CONFIG_NETUTILS_HTTPDNETSTATS
+HTTPD_CGI_CALL(net, "net-stats", net_stats);
+#endif
+
+static const struct httpd_cgi_call *calls[] =
+{
+#ifdef CONFIG_NETUTILS_HTTPDFILESTATS
+  &file,
+#endif
+#ifdef CONFIG_NETUTILS_HTTPDNETSTATS
+  &net,
+#endif
+  NULL
+};
+
+static const char closed[] =   /*  "CLOSED",*/
+  {0x43, 0x4c, 0x4f, 0x53, 0x45, 0x44, 0};
+static const char syn_rcvd[] = /*  "SYN-RCVD",*/
+  {0x53, 0x59, 0x4e, 0x2d, 0x52, 0x43, 0x56, 0x44,  0};
+static const char syn_sent[] = /*  "SYN-SENT",*/
+  {0x53, 0x59, 0x4e, 0x2d, 0x53, 0x45, 0x4e, 0x54,  0};
+static const char established[] = /*  "ESTABLISHED",*/
+  {0x45, 0x53, 0x54, 0x41, 0x42, 0x4c, 0x49, 0x53, 0x48, 0x45, 0x44, 0};
+static const char fin_wait_1[] = /*  "FIN-WAIT-1",*/
+  {0x46, 0x49, 0x4e, 0x2d, 0x57, 0x41, 0x49, 0x54, 0x2d, 0x31, 0};
+static const char fin_wait_2[] = /*  "FIN-WAIT-2",*/
+  {0x46, 0x49, 0x4e, 0x2d, 0x57, 0x41, 0x49, 0x54, 0x2d, 0x32, 0};
+static const char closing[] = /*  "CLOSING",*/
+  {0x43, 0x4c, 0x4f, 0x53, 0x49, 0x4e, 0x47, 0};
+static const char time_wait[] = /*  "TIME-WAIT,"*/
+  {0x54, 0x49, 0x4d, 0x45, 0x2d, 0x57, 0x41, 0x49, 0x54, 0};
+static const char last_ack[] = /*  "LAST-ACK"*/
+  {0x4c, 0x41, 0x53, 0x54, 0x2d, 0x41, 0x43, 0x4b, 0};
+
+/****************************************************************************
+ * Private Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: nullfunction
+ ****************************************************************************/
+
+static void nullfunction(struct httpd_state *pstate, char *ptr)
+{
+}
+
+/****************************************************************************
+ * Name: net_stats
+ ****************************************************************************/
+
+#ifdef CONFIG_NETUTILS_HTTPDNETSTATS
+static void net_stats(struct httpd_state *pstate, char *ptr)
+{
+  char buffer[16];
+  int i;
+
+  for (i = 0; i < sizeof(uip_stat) / sizeof(uip_stats_t); i++)
+    {
+      snprintf(buffer, 16, "%5u\n", ((uip_stats_t *)&uip_stat)[i]);
+      send(pstate->ht_sockfd, buffer, strlen(buffer), 0);
+    }
+}
+#endif
+
+/****************************************************************************
+ * Name: file_stats
+ ****************************************************************************/
+
+#ifdef CONFIG_NETUTILS_HTTPDFILESTATS
+static void file_stats(struct httpd_state *pstate, char *ptr)
+{
+  char buffer[16];
+  char *pcount = strchr(ptr, ' ') + 1;
+  snprintf(buffer, 16, "%5u", httpd_fs_count(pcount));
+  (void)send(pstate->ht_sockfd, buffer, strlen(buffer), 0);
+}
+#endif
+
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
+
+httpd_cgifunction httpd_cgi(char *name)
+{
+  const struct httpd_cgi_call **f;
+
+  /* Find the matching name in the table, return the function. */
+
+  for(f = calls; *f != NULL; ++f)
+    {
+      if(strncmp((*f)->name, name, strlen((*f)->name)) == 0)
+        {
+          return (*f)->function;
+        }
+    }
+  return nullfunction;
+}

netutils/webserver/httpd_cgi.h

@@ -0,0 +1,69 @@
+/* httpd_cgi.h
+ * Web server script interface header file
+ * Author: Adam Dunkels <adam@sics.se>
+ *
+ * Copyright (c) 2001, Adam Dunkels.
+ * All rights reserved.
+ *
+ * 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. The name of the author may not be used to endorse or promote
+ *    products derived from this software without specific prior
+ *    written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __HTTPD_CGI_H__
+#define __HTTPD_CGI_H__
+
+#include <apps/netutils/httpd.h>
+
+#include "httpd.h"
+
+typedef void (*httpd_cgifunction)(struct httpd_state *, char *);
+
+httpd_cgifunction httpd_cgi(char *name);
+
+struct httpd_cgi_call
+{
+  const char *name;
+  httpd_cgifunction function;
+};
+
+/**
+ * \brief      HTTPD CGI function declaration
+ * \param name The C variable name of the function
+ * \param str  The string name of the function, used in the script file
+ * \param function A pointer to the function that implements it
+ *
+ *             This macro is used for declaring a HTTPD CGI
+ *             function. This function is then added to the list of
+ *             HTTPD CGI functions with the httpd_cgi_add() function.
+ *
+ * \hideinitializer
+ */
+#define HTTPD_CGI_CALL(name, str, function) \
+static void function(struct httpd_state *, char *); \
+static const struct httpd_cgi_call name = {str, function}
+
+void httpd_cgi_init(void);
+#endif /* __HTTPD_CGI_H__ */
+
+/** @} */

netutils/webserver/httpd_fs.c

@@ -0,0 +1,155 @@
+/****************************************************************************
+ * netutils/webserver/httpd_fs.c
+ *
+ *   Copyright (C) 2007-2009, 2011 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * Based on uIP which also has a BSD style license:
+ *
+ *   Author: Adam Dunkels <adam@sics.se>
+ *   Copyright (c) 2001, Swedish Institute of Computer Science.
+ *   All rights reserved.
+ *
+ * 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 of the Institute 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 INSTITUTE 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 INSTITUTE 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 Header Files
+ ****************************************************************************/
+
+#include <stdint.h>
+
+#include <apps/netutils/httpd.h>
+
+#include "httpd.h"
+#include "httpd_fsdata.h"
+
+/****************************************************************************
+ * Pre-processor Definitions
+ ****************************************************************************/
+
+#ifndef NULL
+#define NULL 0
+#endif /* NULL */
+
+/****************************************************************************
+ * Private Data
+ ****************************************************************************/
+
+#include "httpd_fsdata.c"
+
+#if CONFIG_NETUTILS_HTTPDFSSTATS
+static uint16_t count[HTTPD_FS_NUMFILES];
+#endif /* CONFIG_NETUTILS_HTTPDFSSTATS */
+
+/****************************************************************************
+ * Private Functions
+ ****************************************************************************/
+
+static uint8_t httpd_fs_strcmp(const char *str1, const char *str2)
+{
+  int i;
+
+  i = 0;
+  for (;;)
+    {
+      if (str2[i] == 0 || str1[i] == '\r' || str1[i] == '\n')
+        {
+          return 0;
+        }
+
+      if (str1[i] != str2[i])
+        {
+          return 1;
+        }
+
+      i++;
+    }
+}
+
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
+
+int httpd_fs_open(const char *name, struct httpd_fs_file *file)
+{
+#if CONFIG_NETUTILS_HTTPDFSSTATS
+  uint16_t i = 0;
+#endif /* CONFIG_NETUTILS_HTTPDFSSTATS */
+  struct httpd_fsdata_file_noconst *f;
+
+  for(f = (struct httpd_fsdata_file_noconst *)HTTPD_FS_ROOT;
+      f != NULL;
+      f = (struct httpd_fsdata_file_noconst *)f->next)
+    {
+      if (httpd_fs_strcmp(name, f->name) == 0)
+        {
+          file->data = f->data;
+          file->len  = f->len;
+#if CONFIG_NETUTILS_HTTPDFSSTATS
+          ++count[i];
+#endif /* CONFIG_NETUTILS_HTTPDFSSTATS */
+          return 1;
+        }
+#if CONFIG_NETUTILS_HTTPDFSSTATS
+      ++i;
+#endif /* CONFIG_NETUTILS_HTTPDFSSTATS */
+    }
+  return 0;
+}
+
+void httpd_fs_init(void)
+{
+#if CONFIG_NETUTILS_HTTPDFSSTATS
+  uint16_t i;
+  for(i = 0; i < HTTPD_FS_NUMFILES; i++)
+    {
+      count[i] = 0;
+    }
+#endif /* CONFIG_NETUTILS_HTTPDFSSTATS */
+}
+
+#if CONFIG_NETUTILS_HTTPDFSSTATS
+uint16_t httpd_fs_count(char *name)
+{
+  struct httpd_fsdata_file_noconst *f;
+  uint16_t i;
+
+  i = 0;
+  for(f = (struct httpd_fsdata_file_noconst *)HTTPD_FS_ROOT;
+      f != NULL;
+      f = (struct httpd_fsdata_file_noconst *)f->next)
+    {
+      if (httpd_fs_strcmp(name, f->name) == 0)
+        {
+          return count[i];
+        }
+      ++i;
+    }
+  return 0;
+}
+#endif /* CONFIG_NETUTILS_HTTPDFSSTATS */

netutils/webserver/httpd_fsdata.c

@@ -0,0 +1,614 @@
+static const unsigned char data_processes_shtml[] =
+{
+  /* /processes.shtml */
+
+  0x2f, 0x70, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x65, 0x73, 0x2e, 0x73, 0x68, 0x74, 0x6d, 0x6c, 0,
+  0x25, 0x21, 0x3a, 0x20, 0x2f, 0x68, 0x65, 0x61, 0x64, 0x65, 
+  0x72, 0x2e, 0x68, 0x74, 0x6d, 0x6c, 0x0a, 0x3c, 0x68, 0x31, 
+  0x3e, 0x53, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x20, 0x70, 0x72, 
+  0x6f, 0x63, 0x65, 0x73, 0x73, 0x65, 0x73, 0x3c, 0x2f, 0x68, 
+  0x31, 0x3e, 0x3c, 0x62, 0x72, 0x3e, 0x3c, 0x74, 0x61, 0x62, 
+  0x6c, 0x65, 0x20, 0x77, 0x69, 0x64, 0x74, 0x68, 0x3d, 0x22, 
+  0x31, 0x30, 0x30, 0x25, 0x22, 0x3e, 0x0a, 0x3c, 0x74, 0x72, 
+  0x3e, 0x3c, 0x74, 0x68, 0x3e, 0x49, 0x44, 0x3c, 0x2f, 0x74, 
+  0x68, 0x3e, 0x3c, 0x74, 0x68, 0x3e, 0x4e, 0x61, 0x6d, 0x65, 
+  0x3c, 0x2f, 0x74, 0x68, 0x3e, 0x3c, 0x74, 0x68, 0x3e, 0x50, 
+  0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x3c, 0x2f, 0x74, 
+  0x68, 0x3e, 0x3c, 0x74, 0x68, 0x3e, 0x50, 0x6f, 0x6c, 0x6c, 
+  0x20, 0x68, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x72, 0x3c, 0x2f, 
+  0x74, 0x68, 0x3e, 0x3c, 0x74, 0x68, 0x3e, 0x45, 0x76, 0x65, 
+  0x6e, 0x74, 0x20, 0x68, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x72, 
+  0x3c, 0x2f, 0x74, 0x68, 0x3e, 0x3c, 0x74, 0x68, 0x3e, 0x50, 
+  0x72, 0x6f, 0x63, 0x73, 0x74, 0x61, 0x74, 0x65, 0x3c, 0x2f, 
+  0x74, 0x68, 0x3e, 0x3c, 0x2f, 0x74, 0x72, 0x3e, 0x0a, 0x25, 
+  0x21, 0x20, 0x70, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x65, 
+  0x73, 0x0a, 0x25, 0x21, 0x3a, 0x20, 0x2f, 0x66, 0x6f, 0x6f, 
+  0x74, 0x65, 0x72, 0x2e, 0x68, 0x74, 0x6d, 0x6c, 0
+};
+
+static const unsigned char data_404_html[] =
+{
+  /* /404.html */
+
+  0x2f, 0x34, 0x30, 0x34, 0x2e, 0x68, 0x74, 0x6d, 0x6c, 0,
+  0x3c, 0x68, 0x74, 0x6d, 0x6c, 0x3e, 0x0a, 0x20, 0x20, 0x3c, 
+  0x62, 0x6f, 0x64, 0x79, 0x20, 0x62, 0x67, 0x63, 0x6f, 0x6c, 
+  0x6f, 0x72, 0x3d, 0x22, 0x77, 0x68, 0x69, 0x74, 0x65, 0x22, 
+  0x3e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x3c, 0x63, 0x65, 0x6e, 
+  0x74, 0x65, 0x72, 0x3e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 
+  0x20, 0x3c, 0x68, 0x31, 0x3e, 0x34, 0x30, 0x34, 0x20, 0x2d, 
+  0x20, 0x66, 0x69, 0x6c, 0x65, 0x20, 0x6e, 0x6f, 0x74, 0x20, 
+  0x66, 0x6f, 0x75, 0x6e, 0x64, 0x3c, 0x2f, 0x68, 0x31, 0x3e, 
+  0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3c, 0x68, 0x33, 
+  0x3e, 0x47, 0x6f, 0x20, 0x3c, 0x61, 0x20, 0x68, 0x72, 0x65, 
+  0x66, 0x3d, 0x22, 0x2f, 0x22, 0x3e, 0x68, 0x65, 0x72, 0x65, 
+  0x3c, 0x2f, 0x61, 0x3e, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x65, 
+  0x61, 0x64, 0x2e, 0x3c, 0x2f, 0x68, 0x33, 0x3e, 0x0a, 0x20, 
+  0x20, 0x20, 0x20, 0x3c, 0x2f, 0x63, 0x65, 0x6e, 0x74, 0x65, 
+  0x72, 0x3e, 0x0a, 0x20, 0x20, 0x3c, 0x2f, 0x62, 0x6f, 0x64, 
+  0x79, 0x3e, 0x0a, 0x3c, 0x2f, 0x68, 0x74, 0x6d, 0x6c, 0x3e, 
+  0
+};
+
+static const unsigned char data_files_shtml[] =
+{
+  /* /files.shtml */
+
+  0x2f, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x2e, 0x73, 0x68, 0x74, 0x6d, 0x6c, 0,
+  0x25, 0x21, 0x3a, 0x20, 0x2f, 0x68, 0x65, 0x61, 0x64, 0x65, 
+  0x72, 0x2e, 0x68, 0x74, 0x6d, 0x6c, 0x0a, 0x3c, 0x68, 0x31, 
+  0x3e, 0x46, 0x69, 0x6c, 0x65, 0x20, 0x73, 0x74, 0x61, 0x74, 
+  0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x3c, 0x2f, 0x68, 0x31, 
+  0x3e, 0x0a, 0x3c, 0x63, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x3e, 
+  0x0a, 0x3c, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x77, 0x69, 
+  0x64, 0x74, 0x68, 0x3d, 0x22, 0x33, 0x30, 0x30, 0x22, 0x3e, 
+  0x0a, 0x3c, 0x74, 0x72, 0x3e, 0x3c, 0x74, 0x64, 0x3e, 0x3c, 
+  0x61, 0x20, 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x2f, 0x69, 
+  0x6e, 0x64, 0x65, 0x78, 0x2e, 0x68, 0x74, 0x6d, 0x6c, 0x22, 
+  0x3e, 0x2f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x68, 0x74, 
+  0x6d, 0x6c, 0x3c, 0x2f, 0x61, 0x3e, 0x3c, 0x2f, 0x74, 0x64, 
+  0x3e, 0x0a, 0x3c, 0x74, 0x64, 0x3e, 0x25, 0x21, 0x20, 0x66, 
+  0x69, 0x6c, 0x65, 0x2d, 0x73, 0x74, 0x61, 0x74, 0x73, 0x20, 
+  0x2f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x68, 0x74, 0x6d, 
+  0x6c, 0x0a, 0x3c, 0x2f, 0x74, 0x64, 0x3e, 0x3c, 0x74, 0x64, 
+  0x3e, 0x3c, 0x69, 0x6d, 0x67, 0x20, 0x73, 0x72, 0x63, 0x3d, 
+  0x22, 0x2f, 0x66, 0x61, 0x64, 0x65, 0x2e, 0x70, 0x6e, 0x67, 
+  0x22, 0x20, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x3d, 0x31, 
+  0x30, 0x20, 0x77, 0x69, 0x64, 0x74, 0x68, 0x3d, 0x25, 0x21, 
+  0x20, 0x66, 0x69, 0x6c, 0x65, 0x2d, 0x73, 0x74, 0x61, 0x74, 
+  0x73, 0x20, 0x2f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x68, 
+  0x74, 0x6d, 0x6c, 0x0a, 0x3e, 0x20, 0x3c, 0x2f, 0x74, 0x64, 
+  0x3e, 0x3c, 0x2f, 0x74, 0x72, 0x3e, 0x0a, 0x3c, 0x74, 0x72, 
+  0x3e, 0x3c, 0x74, 0x64, 0x3e, 0x3c, 0x61, 0x20, 0x68, 0x72, 
+  0x65, 0x66, 0x3d, 0x22, 0x2f, 0x66, 0x69, 0x6c, 0x65, 0x73, 
+  0x2e, 0x73, 0x68, 0x74, 0x6d, 0x6c, 0x22, 0x3e, 0x2f, 0x66, 
+  0x69, 0x6c, 0x65, 0x73, 0x2e, 0x73, 0x68, 0x74, 0x6d, 0x6c, 
+  0x3c, 0x2f, 0x61, 0x3e, 0x3c, 0x2f, 0x74, 0x64, 0x3e, 0x0a, 
+  0x3c, 0x74, 0x64, 0x3e, 0x25, 0x21, 0x20, 0x66, 0x69, 0x6c, 
+  0x65, 0x2d, 0x73, 0x74, 0x61, 0x74, 0x73, 0x20, 0x2f, 0x66, 
+  0x69, 0x6c, 0x65, 0x73, 0x2e, 0x73, 0x68, 0x74, 0x6d, 0x6c, 
+  0x0a, 0x3c, 0x2f, 0x74, 0x64, 0x3e, 0x3c, 0x74, 0x64, 0x3e, 
+  0x3c, 0x69, 0x6d, 0x67, 0x20, 0x73, 0x72, 0x63, 0x3d, 0x22, 
+  0x2f, 0x66, 0x61, 0x64, 0x65, 0x2e, 0x70, 0x6e, 0x67, 0x22, 
+  0x20, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x3d, 0x31, 0x30, 
+  0x20, 0x77, 0x69, 0x64, 0x74, 0x68, 0x3d, 0x25, 0x21, 0x20, 
+  0x66, 0x69, 0x6c, 0x65, 0x2d, 0x73, 0x74, 0x61, 0x74, 0x73, 
+  0x20, 0x2f, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x2e, 0x73, 0x68, 
+  0x74, 0x6d, 0x6c, 0x0a, 0x3e, 0x20, 0x3c, 0x2f, 0x74, 0x64, 
+  0x3e, 0x3c, 0x2f, 0x74, 0x72, 0x3e, 0x0a, 0x3c, 0x74, 0x72, 
+  0x3e, 0x3c, 0x74, 0x64, 0x3e, 0x3c, 0x61, 0x20, 0x68, 0x72, 
+  0x65, 0x66, 0x3d, 0x22, 0x2f, 0x74, 0x63, 0x70, 0x2e, 0x73, 
+  0x68, 0x74, 0x6d, 0x6c, 0x22, 0x3e, 0x2f, 0x74, 0x63, 0x70, 
+  0x2e, 0x73, 0x68, 0x74, 0x6d, 0x6c, 0x3c, 0x2f, 0x61, 0x3e, 
+  0x3c, 0x2f, 0x74, 0x64, 0x3e, 0x0a, 0x3c, 0x74, 0x64, 0x3e, 
+  0x25, 0x21, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x2d, 0x73, 0x74, 
+  0x61, 0x74, 0x73, 0x20, 0x2f, 0x74, 0x63, 0x70, 0x2e, 0x73, 
+  0x68, 0x74, 0x6d, 0x6c, 0x0a, 0x3c, 0x2f, 0x74, 0x64, 0x3e, 
+  0x3c, 0x74, 0x64, 0x3e, 0x3c, 0x69, 0x6d, 0x67, 0x20, 0x73, 
+  0x72, 0x63, 0x3d, 0x22, 0x2f, 0x66, 0x61, 0x64, 0x65, 0x2e, 
+  0x70, 0x6e, 0x67, 0x22, 0x20, 0x68, 0x65, 0x69, 0x67, 0x68, 
+  0x74, 0x3d, 0x31, 0x30, 0x20, 0x77, 0x69, 0x64, 0x74, 0x68, 
+  0x3d, 0x25, 0x21, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x2d, 0x73, 
+  0x74, 0x61, 0x74, 0x73, 0x20, 0x2f, 0x74, 0x63, 0x70, 0x2e, 
+  0x73, 0x68, 0x74, 0x6d, 0x6c, 0x0a, 0x3e, 0x20, 0x3c, 0x2f, 
+  0x74, 0x64, 0x3e, 0x3c, 0x2f, 0x74, 0x72, 0x3e, 0x0a, 0x3c, 
+  0x74, 0x72, 0x3e, 0x3c, 0x74, 0x64, 0x3e, 0x3c, 0x61, 0x20, 
+  0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x2f, 0x73, 0x74, 0x61, 
+  0x74, 0x73, 0x2e, 0x73, 0x68, 0x74, 0x6d, 0x6c, 0x22, 0x3e, 
+  0x2f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x2e, 0x73, 0x68, 0x74, 
+  0x6d, 0x6c, 0x3c, 0x2f, 0x61, 0x3e, 0x3c, 0x2f, 0x74, 0x64, 
+  0x3e, 0x0a, 0x3c, 0x74, 0x64, 0x3e, 0x25, 0x21, 0x20, 0x66, 
+  0x69, 0x6c, 0x65, 0x2d, 0x73, 0x74, 0x61, 0x74, 0x73, 0x20, 
+  0x2f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x2e, 0x73, 0x68, 0x74, 
+  0x6d, 0x6c, 0x0a, 0x3c, 0x2f, 0x74, 0x64, 0x3e, 0x3c, 0x74, 
+  0x64, 0x3e, 0x3c, 0x69, 0x6d, 0x67, 0x20, 0x73, 0x72, 0x63, 
+  0x3d, 0x22, 0x2f, 0x66, 0x61, 0x64, 0x65, 0x2e, 0x70, 0x6e, 
+  0x67, 0x22, 0x20, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x3d, 
+  0x31, 0x30, 0x20, 0x77, 0x69, 0x64, 0x74, 0x68, 0x3d, 0x25, 
+  0x21, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x2d, 0x73, 0x74, 0x61, 
+  0x74, 0x73, 0x20, 0x2f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x2e, 
+  0x73, 0x68, 0x74, 0x6d, 0x6c, 0x0a, 0x3e, 0x20, 0x3c, 0x2f, 
+  0x74, 0x64, 0x3e, 0x3c, 0x2f, 0x74, 0x72, 0x3e, 0x0a, 0x3c, 
+  0x74, 0x72, 0x3e, 0x3c, 0x74, 0x64, 0x3e, 0x3c, 0x61, 0x20, 
+  0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x2f, 0x73, 0x74, 0x79, 
+  0x6c, 0x65, 0x2e, 0x63, 0x73, 0x73, 0x22, 0x3e, 0x2f, 0x73, 
+  0x74, 0x79, 0x6c, 0x65, 0x2e, 0x63, 0x73, 0x73, 0x3c, 0x2f, 
+  0x61, 0x3e, 0x3c, 0x2f, 0x74, 0x64, 0x3e, 0x0a, 0x3c, 0x74, 
+  0x64, 0x3e, 0x25, 0x21, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x2d, 
+  0x73, 0x74, 0x61, 0x74, 0x73, 0x20, 0x2f, 0x73, 0x74, 0x79, 
+  0x6c, 0x65, 0x2e, 0x63, 0x73, 0x73, 0x0a, 0x3c, 0x2f, 0x74, 
+  0x64, 0x3e, 0x3c, 0x74, 0x64, 0x3e, 0x3c, 0x69, 0x6d, 0x67, 
+  0x20, 0x73, 0x72, 0x63, 0x3d, 0x22, 0x2f, 0x66, 0x61, 0x64, 
+  0x65, 0x2e, 0x70, 0x6e, 0x67, 0x22, 0x20, 0x68, 0x65, 0x69, 
+  0x67, 0x68, 0x74, 0x3d, 0x31, 0x30, 0x20, 0x77, 0x69, 0x64, 
+  0x74, 0x68, 0x3d, 0x25, 0x21, 0x20, 0x66, 0x69, 0x6c, 0x65, 
+  0x2d, 0x73, 0x74, 0x61, 0x74, 0x73, 0x20, 0x2f, 0x73, 0x74, 
+  0x79, 0x6c, 0x65, 0x2e, 0x63, 0x73, 0x73, 0x0a, 0x3e, 0x20, 
+  0x3c, 0x2f, 0x74, 0x64, 0x3e, 0x3c, 0x2f, 0x74, 0x72, 0x3e, 
+  0x0a, 0x3c, 0x74, 0x72, 0x3e, 0x3c, 0x74, 0x64, 0x3e, 0x3c, 
+  0x61, 0x20, 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x2f, 0x34, 
+  0x30, 0x34, 0x2e, 0x68, 0x74, 0x6d, 0x6c, 0x22, 0x3e, 0x2f, 
+  0x34, 0x30, 0x34, 0x2e, 0x68, 0x74, 0x6d, 0x6c, 0x3c, 0x2f, 
+  0x61, 0x3e, 0x3c, 0x2f, 0x74, 0x64, 0x3e, 0x0a, 0x3c, 0x74, 
+  0x64, 0x3e, 0x25, 0x21, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x2d, 
+  0x73, 0x74, 0x61, 0x74, 0x73, 0x20, 0x2f, 0x34, 0x30, 0x34, 
+  0x2e, 0x68, 0x74, 0x6d, 0x6c, 0x0a, 0x3c, 0x2f, 0x74, 0x64, 
+  0x3e, 0x3c, 0x74, 0x64, 0x3e, 0x3c, 0x69, 0x6d, 0x67, 0x20, 
+  0x73, 0x72, 0x63, 0x3d, 0x22, 0x2f, 0x66, 0x61, 0x64, 0x65, 
+  0x2e, 0x70, 0x6e, 0x67, 0x22, 0x20, 0x68, 0x65, 0x69, 0x67, 
+  0x68, 0x74, 0x3d, 0x31, 0x30, 0x20, 0x77, 0x69, 0x64, 0x74, 
+  0x68, 0x3d, 0x25, 0x21, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x2d, 
+  0x73, 0x74, 0x61, 0x74, 0x73, 0x20, 0x2f, 0x34, 0x30, 0x34, 
+  0x2e, 0x68, 0x74, 0x6d, 0x6c, 0x0a, 0x3e, 0x20, 0x3c, 0x2f, 
+  0x74, 0x64, 0x3e, 0x3c, 0x2f, 0x74, 0x72, 0x3e, 0x0a, 0x3c, 
+  0x74, 0x72, 0x3e, 0x3c, 0x74, 0x64, 0x3e, 0x3c, 0x61, 0x20, 
+  0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x2f, 0x66, 0x61, 0x64, 
+  0x65, 0x2e, 0x70, 0x6e, 0x67, 0x22, 0x3e, 0x2f, 0x66, 0x61, 
+  0x64, 0x65, 0x2e, 0x70, 0x6e, 0x67, 0x3c, 0x2f, 0x61, 0x3e, 
+  0x3c, 0x2f, 0x74, 0x64, 0x3e, 0x0a, 0x3c, 0x74, 0x64, 0x3e, 
+  0x25, 0x21, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x2d, 0x73, 0x74, 
+  0x61, 0x74, 0x73, 0x20, 0x2f, 0x66, 0x61, 0x64, 0x65, 0x2e, 
+  0x70, 0x6e, 0x67, 0x0a, 0x3c, 0x2f, 0x74, 0x64, 0x3e, 0x3c, 
+  0x74, 0x64, 0x3e, 0x3c, 0x69, 0x6d, 0x67, 0x20, 0x73, 0x72, 
+  0x63, 0x3d, 0x22, 0x2f, 0x66, 0x61, 0x64, 0x65, 0x2e, 0x70, 
+  0x6e, 0x67, 0x22, 0x20, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 
+  0x3d, 0x31, 0x30, 0x20, 0x77, 0x69, 0x64, 0x74, 0x68, 0x3d, 
+  0x25, 0x21, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x2d, 0x73, 0x74, 
+  0x61, 0x74, 0x73, 0x20, 0x2f, 0x66, 0x61, 0x64, 0x65, 0x2e, 
+  0x70, 0x6e, 0x67, 0x0a, 0x3e, 0x20, 0x3c, 0x2f, 0x74, 0x64, 
+  0x3e, 0x3c, 0x2f, 0x74, 0x72, 0x3e, 0x0a, 0x3c, 0x2f, 0x74, 
+  0x61, 0x62, 0x6c, 0x65, 0x3e, 0x0a, 0x3c, 0x2f, 0x63, 0x65, 
+  0x6e, 0x74, 0x65, 0x72, 0x3e, 0x0a, 0x25, 0x21, 0x3a, 0x20, 
+  0x2f, 0x66, 0x6f, 0x6f, 0x74, 0x65, 0x72, 0x2e, 0x68, 0x74, 
+  0x6d, 0x6c, 0x0a, 0
+};
+
+static const unsigned char data_footer_html[] =
+{
+  /* /footer.html */
+
+  0x2f, 0x66, 0x6f, 0x6f, 0x74, 0x65, 0x72, 0x2e, 0x68, 0x74, 0x6d, 0x6c, 0,
+  0x20, 0x20, 0x3c, 0x2f, 0x62, 0x6f, 0x64, 0x79, 0x3e, 0x0a, 
+  0x3c, 0x2f, 0x68, 0x74, 0x6d, 0x6c, 0x3e, 0
+};
+
+static const unsigned char data_header_html[] =
+{
+  /* /header.html */
+
+  0x2f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x2e, 0x68, 0x74, 0x6d, 0x6c, 0,
+  0x3c, 0x21, 0x44, 0x4f, 0x43, 0x54, 0x59, 0x50, 0x45, 0x20, 
+  0x48, 0x54, 0x4d, 0x4c, 0x20, 0x50, 0x55, 0x42, 0x4c, 0x49, 
+  0x43, 0x20, 0x22, 0x2d, 0x2f, 0x2f, 0x57, 0x33, 0x43, 0x2f, 
+  0x2f, 0x44, 0x54, 0x44, 0x20, 0x48, 0x54, 0x4d, 0x4c, 0x20, 
+  0x34, 0x2e, 0x30, 0x31, 0x20, 0x54, 0x72, 0x61, 0x6e, 0x73, 
+  0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x2f, 0x2f, 0x45, 
+  0x4e, 0x22, 0x20, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 
+  0x2f, 0x77, 0x77, 0x77, 0x2e, 0x77, 0x33, 0x2e, 0x6f, 0x72, 
+  0x67, 0x2f, 0x54, 0x52, 0x2f, 0x68, 0x74, 0x6d, 0x6c, 0x34, 
+  0x2f, 0x6c, 0x6f, 0x6f, 0x73, 0x65, 0x2e, 0x64, 0x74, 0x64, 
+  0x22, 0x3e, 0x0a, 0x3c, 0x68, 0x74, 0x6d, 0x6c, 0x3e, 0x0a, 
+  0x20, 0x20, 0x3c, 0x68, 0x65, 0x61, 0x64, 0x3e, 0x0a, 0x20, 
+  0x20, 0x20, 0x20, 0x3c, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x3e, 
+  0x57, 0x65, 0x6c, 0x63, 0x6f, 0x6d, 0x65, 0x20, 0x74, 0x6f, 
+  0x20, 0x74, 0x68, 0x65, 0x20, 0x75, 0x49, 0x50, 0x20, 0x77, 
+  0x65, 0x62, 0x20, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x21, 
+  0x3c, 0x2f, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x3e, 0x0a, 0x20, 
+  0x20, 0x20, 0x20, 0x3c, 0x6c, 0x69, 0x6e, 0x6b, 0x20, 0x72, 
+  0x65, 0x6c, 0x3d, 0x22, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x73, 
+  0x68, 0x65, 0x65, 0x74, 0x22, 0x20, 0x74, 0x79, 0x70, 0x65, 
+  0x3d, 0x22, 0x74, 0x65, 0x78, 0x74, 0x2f, 0x63, 0x73, 0x73, 
+  0x22, 0x20, 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x73, 0x74, 
+  0x79, 0x6c, 0x65, 0x2e, 0x63, 0x73, 0x73, 0x22, 0x3e, 0x20, 
+  0x20, 0x0a, 0x20, 0x20, 0x3c, 0x2f, 0x68, 0x65, 0x61, 0x64, 
+  0x3e, 0x0a, 0x20, 0x20, 0x3c, 0x62, 0x6f, 0x64, 0x79, 0x20, 
+  0x62, 0x67, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x3d, 0x22, 0x23, 
+  0x66, 0x66, 0x66, 0x65, 0x65, 0x63, 0x22, 0x20, 0x74, 0x65, 
+  0x78, 0x74, 0x3d, 0x22, 0x62, 0x6c, 0x61, 0x63, 0x6b, 0x22, 
+  0x3e, 0x0a, 0x0a, 0x20, 0x20, 0x3c, 0x64, 0x69, 0x76, 0x20, 
+  0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x6d, 0x65, 0x6e, 
+  0x75, 0x22, 0x3e, 0x0a, 0x20, 0x20, 0x3c, 0x64, 0x69, 0x76, 
+  0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x6d, 0x65, 
+  0x6e, 0x75, 0x62, 0x6f, 0x78, 0x22, 0x3e, 0x3c, 0x61, 0x20, 
+  0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x2f, 0x22, 0x3e, 0x46, 
+  0x72, 0x6f, 0x6e, 0x74, 0x20, 0x70, 0x61, 0x67, 0x65, 0x3c, 
+  0x2f, 0x61, 0x3e, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x0a, 
+  0x20, 0x20, 0x3c, 0x64, 0x69, 0x76, 0x20, 0x63, 0x6c, 0x61, 
+  0x73, 0x73, 0x3d, 0x22, 0x6d, 0x65, 0x6e, 0x75, 0x62, 0x6f, 
+  0x78, 0x22, 0x3e, 0x3c, 0x61, 0x20, 0x68, 0x72, 0x65, 0x66, 
+  0x3d, 0x22, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x2e, 0x73, 0x68, 
+  0x74, 0x6d, 0x6c, 0x22, 0x3e, 0x46, 0x69, 0x6c, 0x65, 0x20, 
+  0x73, 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 
+  0x3c, 0x2f, 0x61, 0x3e, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, 
+  0x0a, 0x20, 0x20, 0x3c, 0x64, 0x69, 0x76, 0x20, 0x63, 0x6c, 
+  0x61, 0x73, 0x73, 0x3d, 0x22, 0x6d, 0x65, 0x6e, 0x75, 0x62, 
+  0x6f, 0x78, 0x22, 0x3e, 0x3c, 0x61, 0x20, 0x68, 0x72, 0x65, 
+  0x66, 0x3d, 0x22, 0x73, 0x74, 0x61, 0x74, 0x73, 0x2e, 0x73, 
+  0x68, 0x74, 0x6d, 0x6c, 0x22, 0x3e, 0x4e, 0x65, 0x74, 0x77, 
+  0x6f, 0x72, 0x6b, 0x20, 0x73, 0x74, 0x61, 0x74, 0x69, 0x73, 
+  0x74, 0x69, 0x63, 0x73, 0x3c, 0x2f, 0x61, 0x3e, 0x3c, 0x2f, 
+  0x64, 0x69, 0x76, 0x3e, 0x0a, 0x20, 0x20, 0x3c, 0x64, 0x69, 
+  0x76, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x6d, 
+  0x65, 0x6e, 0x75, 0x62, 0x6f, 0x78, 0x22, 0x3e, 0x3c, 0x61, 
+  0x20, 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x74, 0x63, 0x70, 
+  0x2e, 0x73, 0x68, 0x74, 0x6d, 0x6c, 0x22, 0x3e, 0x4e, 0x65, 
+  0x74, 0x77, 0x6f, 0x72, 0x6b, 0x0a, 0x20, 0x20, 0x63, 0x6f, 
+  0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x3c, 
+  0x2f, 0x61, 0x3e, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x0a, 
+  0x20, 0x20, 0x3c, 0x62, 0x72, 0x3e, 0x0a, 0x20, 0x20, 0x3c, 
+  0x2f, 0x64, 0x69, 0x76, 0x3e, 0x0a, 0x20, 0x20, 0x0a, 0x20, 
+  0x20, 0x3c, 0x64, 0x69, 0x76, 0x20, 0x63, 0x6c, 0x61, 0x73, 
+  0x73, 0x3d, 0x22, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 
+  0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3e, 0x0a, 0
+};
+
+static const unsigned char data_index_html[] =
+{
+  /* /index.html */
+
+  0x2f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x68, 0x74, 0x6d, 0x6c, 0,
+  0x3c, 0x21, 0x44, 0x4f, 0x43, 0x54, 0x59, 0x50, 0x45, 0x20, 
+  0x48, 0x54, 0x4d, 0x4c, 0x20, 0x50, 0x55, 0x42, 0x4c, 0x49, 
+  0x43, 0x20, 0x22, 0x2d, 0x2f, 0x2f, 0x57, 0x33, 0x43, 0x2f, 
+  0x2f, 0x44, 0x54, 0x44, 0x20, 0x48, 0x54, 0x4d, 0x4c, 0x20, 
+  0x34, 0x2e, 0x30, 0x31, 0x20, 0x54, 0x72, 0x61, 0x6e, 0x73, 
+  0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x2f, 0x2f, 0x45, 
+  0x4e, 0x22, 0x20, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 
+  0x2f, 0x77, 0x77, 0x77, 0x2e, 0x77, 0x33, 0x2e, 0x6f, 0x72, 
+  0x67, 0x2f, 0x54, 0x52, 0x2f, 0x68, 0x74, 0x6d, 0x6c, 0x34, 
+  0x2f, 0x6c, 0x6f, 0x6f, 0x73, 0x65, 0x2e, 0x64, 0x74, 0x64, 
+  0x22, 0x3e, 0x0a, 0x3c, 0x68, 0x74, 0x6d, 0x6c, 0x3e, 0x0a, 
+  0x20, 0x20, 0x3c, 0x68, 0x65, 0x61, 0x64, 0x3e, 0x0a, 0x20, 
+  0x20, 0x20, 0x20, 0x3c, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x3e, 
+  0x57, 0x65, 0x6c, 0x63, 0x6f, 0x6d, 0x65, 0x20, 0x74, 0x6f, 
+  0x20, 0x74, 0x68, 0x65, 0x20, 0x75, 0x49, 0x50, 0x20, 0x77, 
+  0x65, 0x62, 0x20, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x21, 
+  0x3c, 0x2f, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x3e, 0x0a, 0x20, 
+  0x20, 0x20, 0x20, 0x3c, 0x6c, 0x69, 0x6e, 0x6b, 0x20, 0x72, 
+  0x65, 0x6c, 0x3d, 0x22, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x73, 
+  0x68, 0x65, 0x65, 0x74, 0x22, 0x20, 0x74, 0x79, 0x70, 0x65, 
+  0x3d, 0x22, 0x74, 0x65, 0x78, 0x74, 0x2f, 0x63, 0x73, 0x73, 
+  0x22, 0x20, 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x73, 0x74, 
+  0x79, 0x6c, 0x65, 0x2e, 0x63, 0x73, 0x73, 0x22, 0x3e, 0x20, 
+  0x20, 0x0a, 0x20, 0x20, 0x3c, 0x2f, 0x68, 0x65, 0x61, 0x64, 
+  0x3e, 0x0a, 0x20, 0x20, 0x3c, 0x62, 0x6f, 0x64, 0x79, 0x20, 
+  0x62, 0x67, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x3d, 0x22, 0x23, 
+  0x66, 0x66, 0x66, 0x65, 0x65, 0x63, 0x22, 0x20, 0x74, 0x65, 
+  0x78, 0x74, 0x3d, 0x22, 0x62, 0x6c, 0x61, 0x63, 0x6b, 0x22, 
+  0x3e, 0x0a, 0x0a, 0x20, 0x20, 0x3c, 0x64, 0x69, 0x76, 0x20, 
+  0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x6d, 0x65, 0x6e, 
+  0x75, 0x22, 0x3e, 0x0a, 0x20, 0x20, 0x3c, 0x64, 0x69, 0x76, 
+  0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x6d, 0x65, 
+  0x6e, 0x75, 0x62, 0x6f, 0x78, 0x22, 0x3e, 0x3c, 0x61, 0x20, 
+  0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x2f, 0x22, 0x3e, 0x46, 
+  0x72, 0x6f, 0x6e, 0x74, 0x20, 0x70, 0x61, 0x67, 0x65, 0x3c, 
+  0x2f, 0x61, 0x3e, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x0a, 
+  0x20, 0x20, 0x3c, 0x64, 0x69, 0x76, 0x20, 0x63, 0x6c, 0x61, 
+  0x73, 0x73, 0x3d, 0x22, 0x6d, 0x65, 0x6e, 0x75, 0x62, 0x6f, 
+  0x78, 0x22, 0x3e, 0x3c, 0x61, 0x20, 0x68, 0x72, 0x65, 0x66, 
+  0x3d, 0x22, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x2e, 0x73, 0x68, 
+  0x74, 0x6d, 0x6c, 0x22, 0x3e, 0x46, 0x69, 0x6c, 0x65, 0x20, 
+  0x73, 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 
+  0x3c, 0x2f, 0x61, 0x3e, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, 
+  0x0a, 0x20, 0x20, 0x3c, 0x64, 0x69, 0x76, 0x20, 0x63, 0x6c, 
+  0x61, 0x73, 0x73, 0x3d, 0x22, 0x6d, 0x65, 0x6e, 0x75, 0x62, 
+  0x6f, 0x78, 0x22, 0x3e, 0x3c, 0x61, 0x20, 0x68, 0x72, 0x65, 
+  0x66, 0x3d, 0x22, 0x73, 0x74, 0x61, 0x74, 0x73, 0x2e, 0x73, 
+  0x68, 0x74, 0x6d, 0x6c, 0x22, 0x3e, 0x4e, 0x65, 0x74, 0x77, 
+  0x6f, 0x72, 0x6b, 0x20, 0x73, 0x74, 0x61, 0x74, 0x69, 0x73, 
+  0x74, 0x69, 0x63, 0x73, 0x3c, 0x2f, 0x61, 0x3e, 0x3c, 0x2f, 
+  0x64, 0x69, 0x76, 0x3e, 0x0a, 0x20, 0x20, 0x3c, 0x64, 0x69, 
+  0x76, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 0x22, 0x6d, 
+  0x65, 0x6e, 0x75, 0x62, 0x6f, 0x78, 0x22, 0x3e, 0x3c, 0x61, 
+  0x20, 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x74, 0x63, 0x70, 
+  0x2e, 0x73, 0x68, 0x74, 0x6d, 0x6c, 0x22, 0x3e, 0x4e, 0x65, 
+  0x74, 0x77, 0x6f, 0x72, 0x6b, 0x0a, 0x20, 0x20, 0x63, 0x6f, 
+  0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x3c, 
+  0x2f, 0x61, 0x3e, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x0a, 
+  0x20, 0x20, 0x3c, 0x62, 0x72, 0x3e, 0x0a, 0x20, 0x20, 0x3c, 
+  0x2f, 0x64, 0x69, 0x76, 0x3e, 0x0a, 0x0a, 0x20, 0x20, 0x3c, 
+  0x64, 0x69, 0x76, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x3d, 
+  0x22, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x62, 0x6c, 
+  0x6f, 0x63, 0x6b, 0x22, 0x3e, 0x0a, 0x20, 0x20, 0x3c, 0x70, 
+  0x3e, 0x0a, 0x20, 0x20, 0x54, 0x68, 0x65, 0x73, 0x65, 0x20, 
+  0x77, 0x65, 0x62, 0x20, 0x70, 0x61, 0x67, 0x65, 0x73, 0x20, 
+  0x61, 0x72, 0x65, 0x20, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 
+  0x20, 0x62, 0x79, 0x20, 0x61, 0x20, 0x73, 0x6d, 0x61, 0x6c, 
+  0x6c, 0x20, 0x77, 0x65, 0x62, 0x20, 0x73, 0x65, 0x72, 0x76, 
+  0x65, 0x72, 0x20, 0x72, 0x75, 0x6e, 0x6e, 0x69, 0x6e, 0x67, 
+  0x20, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x70, 0x20, 0x6f, 0x66, 
+  0x0a, 0x20, 0x20, 0x74, 0x68, 0x65, 0x20, 0x3c, 0x61, 0x20, 
+  0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x68, 0x74, 0x74, 0x70, 
+  0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x73, 0x69, 0x63, 
+  0x73, 0x2e, 0x73, 0x65, 0x2f, 0x7e, 0x61, 0x64, 0x61, 0x6d, 
+  0x2f, 0x75, 0x69, 0x70, 0x2f, 0x22, 0x3e, 0x75, 0x49, 0x50, 
+  0x20, 0x65, 0x6d, 0x62, 0x65, 0x64, 0x64, 0x65, 0x64, 0x20, 
+  0x54, 0x43, 0x50, 0x2f, 0x49, 0x50, 0x0a, 0x20, 0x20, 0x73, 
+  0x74, 0x61, 0x63, 0x6b, 0x3c, 0x2f, 0x61, 0x3e, 0x2e, 0x0a, 
+  0x20, 0x20, 0x3c, 0x2f, 0x70, 0x3e, 0x0a, 0x20, 0x20, 0x3c, 
+  0x70, 0x3e, 0x0a, 0x20, 0x20, 0x43, 0x6c, 0x69, 0x63, 0x6b, 
+  0x20, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6c, 0x69, 
+  0x6e, 0x6b, 0x73, 0x20, 0x61, 0x62, 0x6f, 0x76, 0x65, 0x20, 
+  0x66, 0x6f, 0x72, 0x20, 0x77, 0x65, 0x62, 0x20, 0x73, 0x65, 
+  0x72, 0x76, 0x65, 0x72, 0x20, 0x73, 0x74, 0x61, 0x74, 0x69, 
+  0x73, 0x74, 0x69, 0x63, 0x73, 0x2e, 0x0a, 0x20, 0x20, 0x3c, 
+  0x2f, 0x70, 0x3e, 0x0a, 0x0a, 0x20, 0x20, 0x3c, 0x2f, 0x62, 
+  0x6f, 0x64, 0x79, 0x3e, 0x0a, 0x3c, 0x2f, 0x68, 0x74, 0x6d, 
+  0x6c, 0x3e, 0x0a, 0
+};
+
+static const unsigned char data_style_css[] =
+{
+  /* /style.css */
+
+  0x2f, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x2e, 0x63, 0x73, 0x73, 0,
+  0x68, 0x31, 0x20, 0x0a, 0x7b, 0x0a, 0x20, 0x20, 0x74, 0x65, 
+  0x78, 0x74, 0x2d, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x3a, 0x20, 
+  0x63, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x3b, 0x0a, 0x20, 0x20, 
+  0x66, 0x6f, 0x6e, 0x74, 0x2d, 0x73, 0x69, 0x7a, 0x65, 0x3a, 
+  0x31, 0x34, 0x70, 0x74, 0x3b, 0x0a, 0x20, 0x20, 0x66, 0x6f, 
+  0x6e, 0x74, 0x2d, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x3a, 
+  0x61, 0x72, 0x69, 0x61, 0x6c, 0x2c, 0x68, 0x65, 0x6c, 0x76, 
+  0x65, 0x74, 0x69, 0x63, 0x61, 0x3b, 0x0a, 0x20, 0x20, 0x66, 
+  0x6f, 0x6e, 0x74, 0x2d, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 
+  0x3a, 0x62, 0x6f, 0x6c, 0x64, 0x3b, 0x0a, 0x20, 0x20, 0x70, 
+  0x61, 0x64, 0x64, 0x69, 0x6e, 0x67, 0x3a, 0x31, 0x30, 0x70, 
+  0x78, 0x3b, 0x20, 0x0a, 0x7d, 0x0a, 0x0a, 0x62, 0x6f, 0x64, 
+  0x79, 0x0a, 0x7b, 0x0a, 0x0a, 0x20, 0x20, 0x62, 0x61, 0x63, 
+  0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x2d, 0x63, 0x6f, 
+  0x6c, 0x6f, 0x72, 0x3a, 0x20, 0x23, 0x66, 0x66, 0x66, 0x65, 
+  0x65, 0x63, 0x3b, 0x0a, 0x20, 0x20, 0x63, 0x6f, 0x6c, 0x6f, 
+  0x72, 0x3a, 0x62, 0x6c, 0x61, 0x63, 0x6b, 0x3b, 0x0a, 0x0a, 
+  0x20, 0x20, 0x66, 0x6f, 0x6e, 0x74, 0x2d, 0x73, 0x69, 0x7a, 
+  0x65, 0x3a, 0x38, 0x70, 0x74, 0x3b, 0x0a, 0x20, 0x20, 0x66, 
+  0x6f, 0x6e, 0x74, 0x2d, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79, 
+  0x3a, 0x61, 0x72, 0x69, 0x61, 0x6c, 0x2c, 0x68, 0x65, 0x6c, 
+  0x76, 0x65, 0x74, 0x69, 0x63, 0x61, 0x3b, 0x0a, 0x7d, 0x0a, 
+  0x0a, 0x2e, 0x6d, 0x65, 0x6e, 0x75, 0x0a, 0x7b, 0x0a, 0x20, 
+  0x20, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x3a, 0x20, 0x34, 
+  0x70, 0x78, 0x3b, 0x0a, 0x20, 0x20, 0x77, 0x69, 0x64, 0x74, 
+  0x68, 0x3a, 0x36, 0x30, 0x25, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 
+  0x70, 0x61, 0x64, 0x64, 0x69, 0x6e, 0x67, 0x3a, 0x32, 0x70, 
+  0x78, 0x3b, 0x0a, 0x09, 0x0a, 0x20, 0x20, 0x62, 0x6f, 0x72, 
+  0x64, 0x65, 0x72, 0x3a, 0x20, 0x73, 0x6f, 0x6c, 0x69, 0x64, 
+  0x20, 0x31, 0x70, 0x78, 0x3b, 0x0a, 0x20, 0x20, 0x62, 0x61, 
+  0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x2d, 0x63, 
+  0x6f, 0x6c, 0x6f, 0x72, 0x3a, 0x20, 0x23, 0x66, 0x66, 0x66, 
+  0x63, 0x64, 0x32, 0x3b, 0x0a, 0x20, 0x20, 0x74, 0x65, 0x78, 
+  0x74, 0x2d, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x3a, 0x6c, 0x65, 
+  0x66, 0x74, 0x3b, 0x0a, 0x20, 0x20, 0x0a, 0x20, 0x20, 0x66, 
+  0x6f, 0x6e, 0x74, 0x2d, 0x73, 0x69, 0x7a, 0x65, 0x3a, 0x39, 
+  0x70, 0x74, 0x3b, 0x0a, 0x20, 0x20, 0x66, 0x6f, 0x6e, 0x74, 
+  0x2d, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x3a, 0x61, 0x72, 
+  0x69, 0x61, 0x6c, 0x2c, 0x68, 0x65, 0x6c, 0x76, 0x65, 0x74, 
+  0x69, 0x63, 0x61, 0x3b, 0x20, 0x20, 0x0a, 0x7d, 0x0a, 0x0a, 
+  0x64, 0x69, 0x76, 0x2e, 0x6d, 0x65, 0x6e, 0x75, 0x62, 0x6f, 
+  0x78, 0x0a, 0x7b, 0x0a, 0x20, 0x20, 0x77, 0x69, 0x64, 0x74, 
+  0x68, 0x3a, 0x20, 0x32, 0x35, 0x25, 0x3b, 0x0a, 0x20, 0x20, 
+  0x62, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x3a, 0x20, 0x30, 0x3b, 
+  0x0a, 0x20, 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x3a, 0x20, 
+  0x6c, 0x65, 0x66, 0x74, 0x3b, 0x0a, 0x74, 0x65, 0x78, 0x74, 
+  0x2d, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x3a, 0x20, 0x63, 0x65, 
+  0x6e, 0x74, 0x65, 0x72, 0x3b, 0x0a, 0x7d, 0x0a, 0x0a, 0x2e, 
+  0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x62, 0x6c, 0x6f, 
+  0x63, 0x6b, 0x0a, 0x7b, 0x20, 0x20, 0x0a, 0x20, 0x20, 0x6d, 
+  0x61, 0x72, 0x67, 0x69, 0x6e, 0x3a, 0x20, 0x34, 0x70, 0x78, 
+  0x3b, 0x0a, 0x20, 0x20, 0x77, 0x69, 0x64, 0x74, 0x68, 0x3a, 
+  0x36, 0x30, 0x25, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x70, 0x61, 
+  0x64, 0x64, 0x69, 0x6e, 0x67, 0x3a, 0x32, 0x70, 0x78, 0x3b, 
+  0x0a, 0x0a, 0x20, 0x20, 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72, 
+  0x3a, 0x20, 0x31, 0x70, 0x78, 0x20, 0x64, 0x6f, 0x74, 0x74, 
+  0x65, 0x64, 0x3b, 0x0a, 0x20, 0x20, 0x62, 0x61, 0x63, 0x6b, 
+  0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x2d, 0x63, 0x6f, 0x6c, 
+  0x6f, 0x72, 0x3a, 0x20, 0x77, 0x68, 0x69, 0x74, 0x65, 0x3b, 
+  0x0a, 0x0a, 0x20, 0x20, 0x66, 0x6f, 0x6e, 0x74, 0x2d, 0x73, 
+  0x69, 0x7a, 0x65, 0x3a, 0x38, 0x70, 0x74, 0x3b, 0x0a, 0x20, 
+  0x20, 0x66, 0x6f, 0x6e, 0x74, 0x2d, 0x66, 0x61, 0x6d, 0x69, 
+  0x6c, 0x79, 0x3a, 0x61, 0x72, 0x69, 0x61, 0x6c, 0x2c, 0x68, 
+  0x65, 0x6c, 0x76, 0x65, 0x74, 0x69, 0x63, 0x61, 0x3b, 0x20, 
+  0x20, 0x0a, 0x0a, 0x7d, 0x0a, 0x0a, 0x70, 0x2e, 0x69, 0x6e, 
+  0x74, 0x72, 0x6f, 0x0a, 0x7b, 0x0a, 0x20, 0x20, 0x6d, 0x61, 
+  0x72, 0x67, 0x69, 0x6e, 0x2d, 0x6c, 0x65, 0x66, 0x74, 0x3a, 
+  0x32, 0x30, 0x70, 0x78, 0x3b, 0x0a, 0x20, 0x20, 0x6d, 0x61, 
+  0x72, 0x67, 0x69, 0x6e, 0x2d, 0x72, 0x69, 0x67, 0x68, 0x74, 
+  0x3a, 0x32, 0x30, 0x70, 0x78, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 
+  0x66, 0x6f, 0x6e, 0x74, 0x2d, 0x73, 0x69, 0x7a, 0x65, 0x3a, 
+  0x31, 0x30, 0x70, 0x74, 0x3b, 0x0a, 0x2f, 0x2a, 0x20, 0x20, 
+  0x66, 0x6f, 0x6e, 0x74, 0x2d, 0x77, 0x65, 0x69, 0x67, 0x68, 
+  0x74, 0x3a, 0x62, 0x6f, 0x6c, 0x64, 0x3b, 0x20, 0x2a, 0x2f, 
+  0x0a, 0x20, 0x20, 0x66, 0x6f, 0x6e, 0x74, 0x2d, 0x66, 0x61, 
+  0x6d, 0x69, 0x6c, 0x79, 0x3a, 0x61, 0x72, 0x69, 0x61, 0x6c, 
+  0x2c, 0x68, 0x65, 0x6c, 0x76, 0x65, 0x74, 0x69, 0x63, 0x61, 
+  0x3b, 0x20, 0x20, 0x0a, 0x7d, 0x0a, 0x0a, 0x70, 0x2e, 0x63, 
+  0x6c, 0x69, 0x6e, 0x6b, 0x0a, 0x7b, 0x0a, 0x20, 0x20, 0x66, 
+  0x6f, 0x6e, 0x74, 0x2d, 0x73, 0x69, 0x7a, 0x65, 0x3a, 0x31, 
+  0x32, 0x70, 0x74, 0x3b, 0x0a, 0x20, 0x20, 0x66, 0x6f, 0x6e, 
+  0x74, 0x2d, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x3a, 0x63, 
+  0x6f, 0x75, 0x72, 0x69, 0x65, 0x72, 0x2c, 0x6d, 0x6f, 0x6e, 
+  0x6f, 0x73, 0x70, 0x61, 0x63, 0x65, 0x3b, 0x20, 0x20, 0x0a, 
+  0x20, 0x20, 0x74, 0x65, 0x78, 0x74, 0x2d, 0x61, 0x6c, 0x69, 
+  0x67, 0x6e, 0x3a, 0x63, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x3b, 
+  0x0a, 0x7d, 0x0a, 0x0a, 0x70, 0x2e, 0x63, 0x6c, 0x69, 0x6e, 
+  0x6b, 0x39, 0x0a, 0x7b, 0x0a, 0x20, 0x20, 0x66, 0x6f, 0x6e, 
+  0x74, 0x2d, 0x73, 0x69, 0x7a, 0x65, 0x3a, 0x39, 0x70, 0x74, 
+  0x3b, 0x0a, 0x20, 0x20, 0x66, 0x6f, 0x6e, 0x74, 0x2d, 0x66, 
+  0x61, 0x6d, 0x69, 0x6c, 0x79, 0x3a, 0x63, 0x6f, 0x75, 0x72, 
+  0x69, 0x65, 0x72, 0x2c, 0x6d, 0x6f, 0x6e, 0x6f, 0x73, 0x70, 
+  0x61, 0x63, 0x65, 0x3b, 0x20, 0x20, 0x0a, 0x20, 0x20, 0x74, 
+  0x65, 0x78, 0x74, 0x2d, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x3a, 
+  0x63, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x3b, 0x0a, 0x7d, 0x0a, 
+  0x0a, 0x0a, 0x70, 0x0a, 0x7b, 0x0a, 0x20, 0x20, 0x70, 0x61, 
+  0x64, 0x64, 0x69, 0x6e, 0x67, 0x2d, 0x6c, 0x65, 0x66, 0x74, 
+  0x3a, 0x31, 0x30, 0x70, 0x78, 0x3b, 0x0a, 0x7d, 0x0a, 0x0a, 
+  0x70, 0x2e, 0x72, 0x69, 0x67, 0x68, 0x74, 0x0a, 0x7b, 0x0a, 
+  0x20, 0x20, 0x74, 0x65, 0x78, 0x74, 0x2d, 0x61, 0x6c, 0x69, 
+  0x67, 0x6e, 0x3a, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3b, 0x20, 
+  0x0a, 0x7d, 0x0a, 0x0a, 0
+};
+
+static const unsigned char data_fade_png[] =
+{
+  /* /fade.png */
+
+  0x2f, 0x66, 0x61, 0x64, 0x65, 0x2e, 0x70, 0x6e, 0x67, 0x00,
+  0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 
+  0x00, 0x0d, 0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x00, 0x04, 
+  0x00, 0x00, 0x00, 0x0a, 0x08, 0x02, 0x00, 0x00, 0x00, 0x1c, 
+  0x99, 0x68, 0x59, 0x00, 0x00, 0x00, 0x09, 0x70, 0x48, 0x59, 
+  0x73, 0x00, 0x00, 0x0b, 0x13, 0x00, 0x00, 0x0b, 0x13, 0x01, 
+  0x00, 0x9a, 0x9c, 0x18, 0x00, 0x00, 0x00, 0x07, 0x74, 0x49, 
+  0x4d, 0x45, 0x07, 0xd6, 0x06, 0x08, 0x14, 0x1b, 0x39, 0xaf, 
+  0x5b, 0xc0, 0xe3, 0x00, 0x00, 0x00, 0x1d, 0x74, 0x45, 0x58, 
+  0x74, 0x43, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x00, 0x43, 
+  0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 
+  0x68, 0x20, 0x54, 0x68, 0x65, 0x20, 0x47, 0x49, 0x4d, 0x50, 
+  0xef, 0x64, 0x25, 0x6e, 0x00, 0x00, 0x00, 0x3a, 0x49, 0x44, 
+  0x41, 0x54, 0x08, 0xd7, 0x75, 0x8c, 0x31, 0x12, 0x00, 0x10, 
+  0x10, 0xc4, 0x2e, 0x37, 0x9e, 0x40, 0x65, 0xfd, 0xff, 0x83, 
+  0xf4, 0x0a, 0x1c, 0x8d, 0x54, 0x9b, 0xc9, 0xcc, 0x9a, 0x3d, 
+  0x90, 0x73, 0x71, 0x67, 0x91, 0xd4, 0x74, 0x36, 0xa9, 0x55, 
+  0x01, 0xf8, 0x29, 0x58, 0xc8, 0xbf, 0x48, 0xc4, 0x81, 0x74, 
+  0x0b, 0xa3, 0x0f, 0x7c, 0xdb, 0x04, 0xe8, 0x40, 0x05, 0xdf, 
+  0xa1, 0xf3, 0xfc, 0x73, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 
+  0x4e, 0x44, 0xae, 0x42, 0x60, 0x82, 0
+};
+
+static const unsigned char data_stats_shtml[] =
+{
+  /* /stats.shtml */
+
+  0x2f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x2e, 0x73, 0x68, 0x74, 0x6d, 0x6c, 0,
+  0x25, 0x21, 0x3a, 0x20, 0x2f, 0x68, 0x65, 0x61, 0x64, 0x65, 
+  0x72, 0x2e, 0x68, 0x74, 0x6d, 0x6c, 0x0a, 0x3c, 0x68, 0x31, 
+  0x3e, 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x20, 0x73, 
+  0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x3c, 
+  0x2f, 0x68, 0x31, 0x3e, 0x0a, 0x3c, 0x63, 0x65, 0x6e, 0x74, 
+  0x65, 0x72, 0x3e, 0x0a, 0x3c, 0x74, 0x61, 0x62, 0x6c, 0x65, 
+  0x20, 0x77, 0x69, 0x64, 0x74, 0x68, 0x3d, 0x22, 0x33, 0x30, 
+  0x30, 0x22, 0x20, 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x3d, 
+  0x22, 0x30, 0x22, 0x3e, 0x0a, 0x3c, 0x74, 0x72, 0x3e, 0x3c, 
+  0x74, 0x64, 0x3e, 0x3c, 0x70, 0x72, 0x65, 0x3e, 0x0a, 0x49, 
+  0x50, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 
+  0x20, 0x20, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x73, 0x20, 
+  0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x64, 0x0a, 0x20, 
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 
+  0x20, 0x20, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x73, 0x20, 
+  0x73, 0x65, 0x6e, 0x74, 0x0a, 0x09, 0x20, 0x20, 0x20, 0x20, 
+  0x20, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x73, 0x20, 0x64, 
+  0x72, 0x6f, 0x70, 0x70, 0x65, 0x64, 0x0a, 0x49, 0x50, 0x20, 
+  0x65, 0x72, 0x72, 0x6f, 0x72, 0x73, 0x20, 0x20, 0x20, 0x20, 
+  0x49, 0x50, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 
+  0x2f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x20, 0x6c, 0x65, 
+  0x6e, 0x67, 0x74, 0x68, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x49, 0x50, 
+  0x20, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x2c, 0x20, 0x68, 
+  0x69, 0x67, 0x68, 0x20, 0x62, 0x79, 0x74, 0x65, 0x0a, 0x20, 
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 
+  0x20, 0x20, 0x49, 0x50, 0x20, 0x6c, 0x65, 0x6e, 0x67, 0x74, 
+  0x68, 0x2c, 0x20, 0x6c, 0x6f, 0x77, 0x20, 0x62, 0x79, 0x74, 
+  0x65, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x49, 0x50, 0x20, 0x66, 0x72, 
+  0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x0a, 0x20, 0x20, 
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 
+  0x20, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x20, 0x63, 0x68, 
+  0x65, 0x63, 0x6b, 0x73, 0x75, 0x6d, 0x0a, 0x20, 0x20, 0x20, 
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 
+  0x57, 0x72, 0x6f, 0x6e, 0x67, 0x20, 0x70, 0x72, 0x6f, 0x74, 
+  0x6f, 0x63, 0x6f, 0x6c, 0x0a, 0x49, 0x43, 0x4d, 0x50, 0x09, 
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x50, 0x61, 0x63, 0x6b, 0x65, 
+  0x74, 0x73, 0x20, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 
+  0x64, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x50, 0x61, 0x63, 0x6b, 0x65, 
+  0x74, 0x73, 0x20, 0x73, 0x65, 0x6e, 0x74, 0x0a, 0x20, 0x20, 
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 
+  0x20, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x73, 0x20, 0x64, 
+  0x72, 0x6f, 0x70, 0x70, 0x65, 0x64, 0x0a, 0x20, 0x20, 0x20, 
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 
+  0x54, 0x79, 0x70, 0x65, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 
+  0x73, 0x0a, 0x54, 0x43, 0x50, 0x20, 0x20, 0x20, 0x20, 0x20, 
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x50, 0x61, 0x63, 0x6b, 0x65, 
+  0x74, 0x73, 0x20, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 
+  0x64, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x50, 0x61, 0x63, 0x6b, 0x65, 
+  0x74, 0x73, 0x20, 0x73, 0x65, 0x6e, 0x74, 0x0a, 0x20, 0x20, 
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 
+  0x20, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x73, 0x20, 0x64, 
+  0x72, 0x6f, 0x70, 0x70, 0x65, 0x64, 0x0a, 0x20, 0x20, 0x20, 
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 
+  0x43, 0x68, 0x65, 0x63, 0x6b, 0x73, 0x75, 0x6d, 0x20, 0x65, 
+  0x72, 0x72, 0x6f, 0x72, 0x73, 0x0a, 0x20, 0x20, 0x20, 0x20, 
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x44, 
+  0x61, 0x74, 0x61, 0x20, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 
+  0x73, 0x20, 0x77, 0x69, 0x74, 0x68, 0x6f, 0x75, 0x74, 0x20, 
+  0x41, 0x43, 0x4b, 0x73, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x52, 0x65, 
+  0x73, 0x65, 0x74, 0x73, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x52, 0x65, 
+  0x74, 0x72, 0x61, 0x6e, 0x73, 0x6d, 0x69, 0x73, 0x73, 0x69, 
+  0x6f, 0x6e, 0x73, 0x0a, 0x09, 0x20, 0x20, 0x20, 0x20, 0x20, 
+  0x4e, 0x6f, 0x20, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 
+  0x69, 0x6f, 0x6e, 0x20, 0x61, 0x76, 0x61, 0x6c, 0x69, 0x61, 
+  0x62, 0x6c, 0x65, 0x0a, 0x09, 0x20, 0x20, 0x20, 0x20, 0x20, 
+  0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 
+  0x20, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x73, 0x20, 
+  0x74, 0x6f, 0x20, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x64, 0x20, 
+  0x70, 0x6f, 0x72, 0x74, 0x73, 0x0a, 0x3c, 0x2f, 0x70, 0x72, 
+  0x65, 0x3e, 0x3c, 0x2f, 0x74, 0x64, 0x3e, 0x3c, 0x74, 0x64, 
+  0x3e, 0x3c, 0x70, 0x72, 0x65, 0x3e, 0x25, 0x21, 0x20, 0x6e, 
+  0x65, 0x74, 0x2d, 0x73, 0x74, 0x61, 0x74, 0x73, 0x0a, 0x3c, 
+  0x2f, 0x70, 0x72, 0x65, 0x3e, 0x3c, 0x2f, 0x74, 0x61, 0x62, 
+  0x6c, 0x65, 0x3e, 0x0a, 0x3c, 0x2f, 0x63, 0x65, 0x6e, 0x74, 
+  0x65, 0x72, 0x3e, 0x0a, 0x25, 0x21, 0x3a, 0x20, 0x2f, 0x66, 
+  0x6f, 0x6f, 0x74, 0x65, 0x72, 0x2e, 0x68, 0x74, 0x6d, 0x6c, 
+  0x0a, 0
+};
+
+const struct httpd_fsdata_file file_processes_shtml[] =
+  {{NULL, data_processes_shtml, data_processes_shtml + 17, sizeof(data_processes_shtml) - 18}};
+
+const struct httpd_fsdata_file file_404_html[] =
+  {{file_processes_shtml, data_404_html, data_404_html + 10, sizeof(data_404_html) - 11}};
+
+const struct httpd_fsdata_file file_files_shtml[] =
+  {{file_404_html, data_files_shtml, data_files_shtml + 13, sizeof(data_files_shtml) - 14}};
+
+const struct httpd_fsdata_file file_footer_html[] =
+  {{file_files_shtml, data_footer_html, data_footer_html + 13, sizeof(data_footer_html) - 14}};
+
+const struct httpd_fsdata_file file_header_html[] =
+  {{file_footer_html, data_header_html, data_header_html + 13, sizeof(data_header_html) - 14}};
+
+const struct httpd_fsdata_file file_index_html[] =
+  {{file_header_html, data_index_html, data_index_html + 12, sizeof(data_index_html) - 13}};
+
+const struct httpd_fsdata_file file_style_css[] =
+  {{file_index_html, data_style_css, data_style_css + 11, sizeof(data_style_css) - 12}};
+
+const struct httpd_fsdata_file file_fade_png[] =
+  {{file_style_css, data_fade_png, data_fade_png + 10, sizeof(data_fade_png) - 11}};
+
+const struct httpd_fsdata_file file_stats_shtml[] =
+  {{file_fade_png, data_stats_shtml, data_stats_shtml + 13, sizeof(data_stats_shtml) - 14}};
+
+#define HTTPD_FS_ROOT     file_stats_shtml
+#define HTTPD_FS_NUMFILES 10

netutils/webserver/httpd_fsdata.h

@@ -0,0 +1,79 @@
+/****************************************************************************
+ * netutils/webserver/httpd_fsdata.h
+ *
+ *   Copyright (C) 2007-2009 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * Based on uIP which also has a BSD style license:
+ *
+ *   Author: Adam Dunkels <adam@sics.se>
+ *   Copyright (c) 2001, Swedish Institute of Computer Science.
+ *   All rights reserved.
+ *
+ * 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 of the Institute 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 INSTITUTE 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 INSTITUTE OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ ****************************************************************************/
+
+#ifndef __HTTPD_FSDATA_H__
+#define __HTTPD_FSDATA_H__
+
+/****************************************************************************
+ * Included Files
+ ****************************************************************************/
+
+#include <stdint.h>
+#include <net/uip/uip.h>
+
+/****************************************************************************
+ * Public Types
+ ****************************************************************************/
+
+struct httpd_fsdata_file
+{
+  const struct httpd_fsdata_file *next;
+  FAR const uint8_t *name;
+  FAR const uint8_t *data;
+  int len;
+#ifdef CONFIG_NETUTILS_HTTPDFSSTATS
+#if CONFIG_NETUTILS_HTTPDFSSTATS == 1
+  uint16_t count;
+#endif /* CONFIG_NETUTILS_HTTPDFSSTATS */
+#endif /* CONFIG_NETUTILS_HTTPDFSSTATS */
+};
+
+struct httpd_fsdata_file_noconst
+{
+  FAR struct httpd_fsdata_file *next;
+  FAR char *name;
+  FAR char *data;
+  int len;
+#ifdef CONFIG_NETUTILS_HTTPDFSSTATS
+#if CONFIG_NETUTILS_HTTPDFSSTATS == 1
+  uint16_t count;
+#endif /* CONFIG_NETUTILS_HTTPDFSSTATS */
+#endif /* CONFIG_NETUTILS_HTTPDFSSTATS */
+};
+
+#endif /* __HTTPD_FSDATA_H__ */

netutils/webserver/makefsdata

@@ -0,0 +1,75 @@
+#!/usr/bin/perl
+
+open(OUTPUT, "> httpd-fsdata.c");
+
+chdir("httpd-fs");
+
+opendir(DIR, ".");
+@files =  grep { !/^\./ && !/(CVS|~)/ } readdir(DIR);
+closedir(DIR);
+
+foreach $file (@files) {  
+   
+    if(-d $file && $file !~ /^\./) {
+	print "Processing directory $file\n";
+	opendir(DIR, $file);
+	@newfiles =  grep { !/^\./ && !/(CVS|~)/ } readdir(DIR);
+	closedir(DIR);
+	printf "Adding files @newfiles\n";
+	@files = (@files, map { $_ = "$file/$_" } @newfiles);
+	next;
+    }
+}
+
+foreach $file (@files) {
+    if(-f $file) {
+	
+	print "Adding file $file\n";
+
+	open(FILE, $file) || die "Could not open file $file\n";
+
+	$file =~ s-^-/-;
+	$fvar = $file;
+	$fvar =~ s-/-_-g;
+	$fvar =~ s-\.-_-g;
+	# for AVR, add PROGMEM here
+	print(OUTPUT "static const unsigned char data".$fvar."[] =\n");
+	print(OUTPUT "{\n  /* $file */\n\n  ");
+	for($j = 0; $j < length($file); $j++) {
+	    printf(OUTPUT "%#02x, ", unpack("C", substr($file, $j, 1)));
+	}
+	printf(OUTPUT "0x00,\n  ");
+	
+	$i = 0;        
+	while(read(FILE, $data, 1)) {
+	    printf(OUTPUT "%#02x, ", unpack("C", $data));
+	    $i++;
+	    if($i == 10) {
+		print(OUTPUT "\n");
+		$i = 0;
+		print(OUTPUT "  ");
+	    }
+	}
+	print(OUTPUT "0x00\n};\n\n");
+	close(FILE);
+	push(@fvars, $fvar);
+	push(@pfiles, $file);
+    }
+}
+
+for($i = 0; $i < @fvars; $i++) {
+    $file = $pfiles[$i];
+    $fvar = $fvars[$i];
+
+    if($i == 0) {
+        $prevfile = "NULL";
+    } else {
+        $prevfile = "file" . $fvars[$i - 1];
+    }
+    print(OUTPUT "const struct httpd_fsdata_file file".$fvar."[] = {{$prevfile, data$fvar, ");
+    print(OUTPUT "data$fvar + ". (length($file) + 1) .", ");
+    print(OUTPUT "sizeof(data$fvar) - ". (length($file) + 1) ."}};\n\n");
+}
+
+print(OUTPUT "#define HTTPD_FS_ROOT     file$fvars[$i - 1]\n\n");
+print(OUTPUT "#define HTTPD_FS_NUMFILES $i\n");

nshlib/Makefile

@@ -33,15 +33,9 @@
 #
 ############################################################################
 
-# TODO, this makefile should run make under the app dirs, instead of
-# sourcing the Make.defs!
-
+-include $(TOPDIR)/.config
 -include $(TOPDIR)/Make.defs
-include ../Make.defs
-
-ifeq ($(WINTOOL),y)
-INCDIROPT	= -w
-endif
+include $(APPDIR)/Make.defs
 
 # NSH Library
 

vsn/Makefile

@@ -1,5 +1,5 @@
 ############################################################################
-# vsn/Makefile
+# apps/vsn/Makefile
 #
 #   Copyright (C) 2011 Gregory Nutt. All rights reserved.
 #   Author: Gregory Nutt <spudmonkey@racsa.co.cr>

vsn/free/Makefile

@@ -37,8 +37,9 @@
 # TODO, this makefile should run make under the app dirs, instead of
 # sourcing the Make.defs!
 
+-include $(TOPDIR)/.config
 -include $(TOPDIR)/Make.defs
-include ../../Make.defs
+include $(APPDIR)/Make.defs
 
 ifeq ($(WINTOOL),y)
 INCDIROPT	= -w

vsn/hello/Makefile

@@ -37,8 +37,9 @@
 # TODO, this makefile should run make under the app dirs, instead of
 # sourcing the Make.defs!
 
+-include $(TOPDIR)/.config
 -include $(TOPDIR)/Make.defs
-include ../../Make.defs
+include $(APPDIR)/Make.defs
 
 ifeq ($(WINTOOL),y)
 INCDIROPT	= -w

vsn/poweroff/Makefile

@@ -37,8 +37,9 @@
 # TODO, this makefile should run make under the app dirs, instead of
 # sourcing the Make.defs!
 
+-include $(TOPDIR)/.config
 -include $(TOPDIR)/Make.defs
-include ../../Make.defs
+include $(APPDIR)/Make.defs
 
 ifeq ($(WINTOOL),y)
 INCDIROPT	= -w

vsn/ramtron/Makefile

@@ -37,8 +37,9 @@
 # TODO, this makefile should run make under the app dirs, instead of
 # sourcing the Make.defs!
 
+-include $(TOPDIR)/.config
 -include $(TOPDIR)/Make.defs
-include ../../Make.defs
+include $(APPDIR)/Make.defs
 
 ifeq ($(WINTOOL),y)
 INCDIROPT	= -w

vsn/sdcard/Makefile

@@ -37,8 +37,9 @@
 # TODO, this makefile should run make under the app dirs, instead of
 # sourcing the Make.defs!
 
+-include $(TOPDIR)/.config
 -include $(TOPDIR)/Make.defs
-include ../../Make.defs
+include $(APPDIR)/Make.defs
 
 ifeq ($(WINTOOL),y)
 INCDIROPT	= -w