contiki-cpc/apps/httpd.c - contiki-1.x - Gitiles

 /*
  * 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.
  *
  * This file is part of the uIP TCP/IP stack.
  *
  * $Id: httpd.c,v 1.1 2006/04/17 15:18:18 kthacker Exp $
  *
  */


 #include "uip.h"

 #include "http-strings.h"

 #include "httpd.h"
 #include "httpd-fs.h"
 #include "httpd-fsdata.h"
 #include "httpd-cgi.h"

 #include "tcpip.h"

 #include <stdio.h>

 /* The HTTP server states: */
 #define STATE_DEALLOCATED       0
 #define STATE_INITIAL           1
 #define STATE_GET               2
 #define STATE_HEADERS           3
 #define STATE_SEND_HEADERS      4
 #define STATE_SEND_CONTENT_TYPE 5
 #define STATE_SEND_DATA         6

 #define ISO_nl                  0x0a
 #define ISO_space               0x20
 #define ISO_slash               0x2f

 #ifdef DEBUG
 #include <stdio.h>
 #define PRINT(x) printf("%s", x)
 #define PRINTLN(x) printf("%s\n", x)
 #else /* DEBUG */
 #define PRINT(x)
 #define PRINTLN(x)
 #endif /* DEBUG */


 #define HTTPD_CONF_NUMCONNS 4
 static struct httpd_state conns[HTTPD_CONF_NUMCONNS];
 u8_t i;

 struct http_filetype {
   const char *ext;
   unsigned char extlen;
   const char *type;
   unsigned char typelen;
 };

 static struct http_filetype filetypes[] = {
   {http_html, sizeof(http_html) - 1,
    http_content_type_html, sizeof(http_content_type_html) - 1},
   {http_htm, sizeof(http_htm) - 1,
    http_content_type_html, sizeof(http_content_type_html) - 1},
   {http_css, sizeof(http_css) - 1,
    http_content_type_css, sizeof(http_content_type_css) - 1},
   {http_png, sizeof(http_png) - 1,
    http_content_type_png, sizeof(http_content_type_png) - 1},
   {http_gif, sizeof(http_gif) - 1,
    http_content_type_gif, sizeof(http_content_type_gif) - 1},
   {http_jpg, sizeof(http_jpg) - 1,
    http_content_type_jpg, sizeof(http_content_type_jpg) - 1},
   {http_txt, sizeof(http_txt) - 1,
    http_content_type_text, sizeof(http_content_type_text) - 1},
   {http_text, sizeof(http_text) - 1,
    http_content_type_text, sizeof(http_content_type_text) - 1},
   {NULL, 0, NULL, 0}
 };
 #define NUMFILETYPES (sizeof(filetypes) / sizeof(struct http_filetype))
 /*-----------------------------------------------------------------------------*/
 static struct httpd_state *
 alloc_state(void)
 {

   for(i = 0; i < HTTPD_CONF_NUMCONNS; ++i) {
     if(conns[i].state == STATE_DEALLOCATED) {
       return &conns[i];
     }
   }

   /* We are overloaded! XXX: we'll just kick all other connections! */
   for(i = 0; i < HTTPD_CONF_NUMCONNS; ++i) {
     conns[i].state = STATE_DEALLOCATED;
   }

   return NULL;
 }
 /*-----------------------------------------------------------------------------*/
 static void
 dealloc_state(struct httpd_state *s)
 {
   s->state = STATE_DEALLOCATED;
 }
 /*-----------------------------------------------------------------------------*/
 void
 httpd_init(void)
 {
   httpd_fs_init();

   /* Listen to port 80. */
   tcp_listen(HTONS(80));

   for(i = 0; i < HTTPD_CONF_NUMCONNS; ++i) {
     conns[i].state = STATE_DEALLOCATED;
   }
 }
 /*-----------------------------------------------------------------------------*/
 /**
  * \internal
  * Buffer an amount of data from the incoming uIP data.
  *
  * \param buf A pointer to the buffer.
  * \param len The length of data to buffer.
  *
  * \return Zero if the function wasn't able to buffer to buffer all
  * data, non-zero otherwise.
  */
 /*-----------------------------------------------------------------------------*/
 static unsigned char
 buffer(CC_REGISTER_ARG struct httpd_buffer *buf, int len, u8_t c)
 {
   while(buf->ptr < len &&
 	uip_len > 0) {
     buf->buf[buf->ptr] = *uip_appdata;
     ++uip_appdata;
     --uip_len;

     if(buf->buf[buf->ptr] == c) {
       return 1;
     }
     ++buf->ptr;
   }
   return (buf->ptr == len);
 }
 /*-----------------------------------------------------------------------------*/
 static void
 buffer_reset(struct httpd_buffer *buf)
 {
   buf->ptr = 0;
 }
 /*-----------------------------------------------------------------------------*/
 static void
 newdata(CC_REGISTER_ARG struct httpd_state *hs)
 {
   int i;
   struct http_filetype *filetype;

   while(uip_len > 0) {
     switch(hs->state) {

     case STATE_INITIAL:
       /* This is the first data that we receive, so we check if we can
 	 identify the "GET" request. We call the buffer() function to
 	 try to buffer 4 bytes of data from the incoming data stream. If
 	 the function isn't able to buffer enough data, we return and
 	 will try again next time around. */
       hs->buf.buf = hs->getbuffer;
       if(buffer(&(hs->buf), 4, ISO_space)) {
 	if(strncmp(http_get, hs->buf.buf, 4) == 0) {
 	  hs->state = STATE_GET;
 	  buffer_reset(&(hs->buf));
 	} else {
 	  uip_abort();
 	  return;
 	}
       }
       break;

     case STATE_GET:
       /* We will read one byte at a time from the GET request until we
 	 find a en end of the line (\n\r). The GET request is remembered
 	 in the httpd state since we might need to look at it later. */
       hs->buf.buf = hs->getbuffer;
       if(buffer(&(hs->buf), sizeof(hs->getbuffer), ISO_nl)) {
 	hs->state = STATE_HEADERS;
 	hs->getlen = hs->buf.ptr - 1;
 	/* Null-terminate GET request string. */
 	hs->getbuffer[hs->getlen] = 0;

 	/* If there is a space character in the get request, we find
 	   it and null terminate the string there. */
 	for(i = 0; i < hs->getlen; ++i) {
 	  if(hs->getbuffer[i] == ISO_space) {
 	    hs->getbuffer[i] = 0;
 	    hs->getlen = i;
 	    break;
 	  }
 	}
 	buffer_reset(&(hs->buf));
       }
       break;

     case STATE_HEADERS:
       hs->buf.buf = hs->hdrbuffer;
       if(buffer(&(hs->buf), sizeof(hs->hdrbuffer), '\n')) {
 	if(hs->buf.ptr == 1) {
 	  hs->state = STATE_SEND_HEADERS;
 	  if(httpd_fs_open(hs->getbuffer, &hs->file)) {
 	    hs->count = sizeof(http_header_200) - 1;
 	    hs->dataptr = (char *)http_header_200;
 	    hs->contenttype = http_content_type_binary;
 	    hs->contentlen = sizeof(http_content_type_binary) - 1;
 	    for(filetype = filetypes;
 		filetype->ext != NULL;
 		++filetype) {
 	      if(strncmp(filetype->ext,
 			 hs->getbuffer + (hs->getlen - filetype->extlen),
 			 filetype->extlen) == 0) {
 		hs->contenttype = filetype->type;
 		hs->contentlen = filetype->typelen;
 		break;
 	      }
 	    }

 	  } else if(hs->getbuffer[0] == ISO_slash &&
 	      hs->getbuffer[1] == 0) {
 	    hs->count = sizeof(http_header_200) - 1;
 	    hs->dataptr = (char *)http_header_200;
 	    hs->contenttype = http_content_type_html;
 	    hs->contentlen = sizeof(http_content_type_html) - 1;
 	    httpd_fs_open(http_index_html, &hs->file);
 	  } else {
 	    hs->count = sizeof(http_header_404) - 1;
 	    hs->dataptr = (char *)http_header_404;
 	    hs->contenttype = http_content_type_html;
 	    hs->contentlen = sizeof(http_content_type_html) - 1;
 	    httpd_fs_open(http_404_html, &hs->file);
 	  }
 	} else {
 	  buffer_reset(&(hs->buf));
 	}
       }
       break;

     default:
       uip_len = 0;
       break;
     }
   }
 }
 /*-----------------------------------------------------------------------------*/
 static void
 acked(CC_REGISTER_ARG struct httpd_state *hs)
 {
   hs->poll = 0;


   switch(hs->state) {

   case STATE_SEND_HEADERS:
     if(hs->count >= uip_mss()) {
       hs->count -= uip_mss();
       hs->dataptr += uip_mss();
     } else {
       hs->count = 0;
     }
     if(hs->count == 0) {
       hs->state = STATE_SEND_CONTENT_TYPE;
       hs->count = hs->contentlen;
       hs->dataptr = (char *)hs->contenttype;
     }
     break;

   case STATE_SEND_CONTENT_TYPE:
     if(hs->count >= uip_mss()) {
       hs->count -= uip_mss();
       hs->dataptr += uip_mss();
     } else {
       hs->count = 0;
     }
     if(hs->count == 0) {
       hs->state = STATE_SEND_DATA;
       hs->count = hs->file.len;
       hs->dataptr = hs->file.data;
     }
     break;

   case STATE_SEND_DATA:
     if(hs->count >= uip_mss()) {
       hs->count -= uip_mss();
       hs->dataptr += uip_mss();
     } else {
       hs->count = 0;
     }
     if(hs->count == 0) {
       uip_close();
       dealloc_state(hs);
     }
     break;
   }
 }
 /*-----------------------------------------------------------------------------*/
 static void
 senddata(CC_REGISTER_ARG struct httpd_state *hs)
 {
   if(hs->state == STATE_SEND_HEADERS ||
      hs->state == STATE_SEND_CONTENT_TYPE ||
      hs->state == STATE_SEND_DATA) {
     uip_send(hs->dataptr,
 	     hs->count > uip_mss()? uip_mss(): hs->count);
   }
 }
 /*-----------------------------------------------------------------------------*/
 void
 httpd_appcall(void *state)
 {
   register struct httpd_state *hs;

   hs = (struct httpd_state *)(state);


   if(uip_connected()) {
     /* Since we've just been connected, the state pointer should be
        NULL and we need to allocate a new state object. If we have run
        out of memory for state objects, we'll have to abort the
        connection and return. */
     if(hs == NULL) {
       hs = alloc_state();
       if(hs == NULL) {
 	uip_close();
 	return;
       }
       tcp_markconn(uip_conn, (void *)hs);
     }
     /* Since we have just been connected with the remote host, we
        reset the state for this connection. The ->count variable
        contains the amount of data that is yet to be sent to the
        remote host, and the ->state is set to HTTP_NOGET to signal
        that we haven't received any HTTP GET request for this
        connection yet. */
     hs->state = STATE_INITIAL;
     hs->count = 0;
     hs->poll = 0;
     buffer_reset(&(hs->buf));
     return;
   }

   if(uip_closed() ||
      uip_aborted() ||
      uip_timedout()) {
     if(hs != NULL) {
       dealloc_state(hs);
     }
     return;
   } else if(uip_poll()) {
     /* If we are polled ten times, we abort the connection. This is
        because we don't want connections lingering indefinately in
        the system. */
     if(hs != NULL) {
       if(hs->state == STATE_DEALLOCATED) {
 	uip_abort();
       } else if(hs->poll++ >= 100) {
 	uip_abort();
 	dealloc_state(hs);
       }
     }
     return;
   }

   if(uip_acked()) {
     acked(hs);
   }

   if(uip_newdata()) {
     newdata(hs);
   }

   if(uip_rexmit() ||
      uip_newdata() ||
      uip_acked()) {
     senddata(hs);
   } else if(uip_poll()) {
     senddata(hs);
   }


 }
 /*-----------------------------------------------------------------------------*/
	/*
	* 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.
	*
	* This file is part of the uIP TCP/IP stack.
	*
	* $Id: httpd.c,v 1.1 2006/04/17 15:18:18 kthacker Exp $
	*
	*/


	#include "uip.h"

	#include "http-strings.h"

	#include "httpd.h"
	#include "httpd-fs.h"
	#include "httpd-fsdata.h"
	#include "httpd-cgi.h"

	#include "tcpip.h"

	#include <stdio.h>

	/* The HTTP server states: */
	#define STATE_DEALLOCATED 0
	#define STATE_INITIAL 1
	#define STATE_GET 2
	#define STATE_HEADERS 3
	#define STATE_SEND_HEADERS 4
	#define STATE_SEND_CONTENT_TYPE 5
	#define STATE_SEND_DATA 6

	#define ISO_nl 0x0a
	#define ISO_space 0x20
	#define ISO_slash 0x2f

	#ifdef DEBUG
	#include <stdio.h>
	#define PRINT(x) printf("%s", x)
	#define PRINTLN(x) printf("%s\n", x)
	#else /* DEBUG */
	#define PRINT(x)
	#define PRINTLN(x)
	#endif /* DEBUG */


	#define HTTPD_CONF_NUMCONNS 4
	static struct httpd_state conns[HTTPD_CONF_NUMCONNS];
	u8_t i;

	struct http_filetype {
	const char *ext;
	unsigned char extlen;
	const char *type;
	unsigned char typelen;
	};

	static struct http_filetype filetypes[] = {
	{http_html, sizeof(http_html) - 1,
	http_content_type_html, sizeof(http_content_type_html) - 1},
	{http_htm, sizeof(http_htm) - 1,
	http_content_type_html, sizeof(http_content_type_html) - 1},
	{http_css, sizeof(http_css) - 1,
	http_content_type_css, sizeof(http_content_type_css) - 1},
	{http_png, sizeof(http_png) - 1,
	http_content_type_png, sizeof(http_content_type_png) - 1},
	{http_gif, sizeof(http_gif) - 1,
	http_content_type_gif, sizeof(http_content_type_gif) - 1},
	{http_jpg, sizeof(http_jpg) - 1,
	http_content_type_jpg, sizeof(http_content_type_jpg) - 1},
	{http_txt, sizeof(http_txt) - 1,
	http_content_type_text, sizeof(http_content_type_text) - 1},
	{http_text, sizeof(http_text) - 1,
	http_content_type_text, sizeof(http_content_type_text) - 1},
	{NULL, 0, NULL, 0}
	};
	#define NUMFILETYPES (sizeof(filetypes) / sizeof(struct http_filetype))
	/-----------------------------------------------------------------------------/
	static struct httpd_state *
	alloc_state(void)
	{

	for(i = 0; i < HTTPD_CONF_NUMCONNS; ++i) {
	if(conns[i].state == STATE_DEALLOCATED) {
	return &conns[i];
	}
	}

	/* We are overloaded! XXX: we'll just kick all other connections! */
	for(i = 0; i < HTTPD_CONF_NUMCONNS; ++i) {
	conns[i].state = STATE_DEALLOCATED;
	}

	return NULL;
	}
	/-----------------------------------------------------------------------------/
	static void
	dealloc_state(struct httpd_state *s)
	{
	s->state = STATE_DEALLOCATED;
	}
	/-----------------------------------------------------------------------------/
	void
	httpd_init(void)
	{
	httpd_fs_init();

	/* Listen to port 80. */
	tcp_listen(HTONS(80));

	for(i = 0; i < HTTPD_CONF_NUMCONNS; ++i) {
	conns[i].state = STATE_DEALLOCATED;
	}
	}
	/-----------------------------------------------------------------------------/
	/**
	* \internal
	* Buffer an amount of data from the incoming uIP data.
	*
	* \param buf A pointer to the buffer.
	* \param len The length of data to buffer.
	*
	* \return Zero if the function wasn't able to buffer to buffer all
	* data, non-zero otherwise.
	*/
	/-----------------------------------------------------------------------------/
	static unsigned char
	buffer(CC_REGISTER_ARG struct httpd_buffer *buf, int len, u8_t c)
	{
	while(buf->ptr < len &&
	uip_len > 0) {
	buf->buf[buf->ptr] = *uip_appdata;
	++uip_appdata;
	--uip_len;

	if(buf->buf[buf->ptr] == c) {
	return 1;
	}
	++buf->ptr;
	}
	return (buf->ptr == len);
	}
	/-----------------------------------------------------------------------------/
	static void
	buffer_reset(struct httpd_buffer *buf)
	{
	buf->ptr = 0;
	}
	/-----------------------------------------------------------------------------/
	static void
	newdata(CC_REGISTER_ARG struct httpd_state *hs)
	{
	int i;
	struct http_filetype *filetype;

	while(uip_len > 0) {
	switch(hs->state) {

	case STATE_INITIAL:
	/* This is the first data that we receive, so we check if we can
	identify the "GET" request. We call the buffer() function to
	try to buffer 4 bytes of data from the incoming data stream. If
	the function isn't able to buffer enough data, we return and
	will try again next time around. */
	hs->buf.buf = hs->getbuffer;
	if(buffer(&(hs->buf), 4, ISO_space)) {
	if(strncmp(http_get, hs->buf.buf, 4) == 0) {
	hs->state = STATE_GET;
	buffer_reset(&(hs->buf));
	} else {
	uip_abort();
	return;
	}
	}
	break;

	case STATE_GET:
	/* We will read one byte at a time from the GET request until we
	find a en end of the line (\n\r). The GET request is remembered
	in the httpd state since we might need to look at it later. */
	hs->buf.buf = hs->getbuffer;
	if(buffer(&(hs->buf), sizeof(hs->getbuffer), ISO_nl)) {
	hs->state = STATE_HEADERS;
	hs->getlen = hs->buf.ptr - 1;
	/* Null-terminate GET request string. */
	hs->getbuffer[hs->getlen] = 0;

	/* If there is a space character in the get request, we find
	it and null terminate the string there. */
	for(i = 0; i < hs->getlen; ++i) {
	if(hs->getbuffer[i] == ISO_space) {
	hs->getbuffer[i] = 0;
	hs->getlen = i;
	break;
	}
	}
	buffer_reset(&(hs->buf));
	}
	break;

	case STATE_HEADERS:
	hs->buf.buf = hs->hdrbuffer;
	if(buffer(&(hs->buf), sizeof(hs->hdrbuffer), '\n')) {
	if(hs->buf.ptr == 1) {
	hs->state = STATE_SEND_HEADERS;
	if(httpd_fs_open(hs->getbuffer, &hs->file)) {
	hs->count = sizeof(http_header_200) - 1;
	hs->dataptr = (char *)http_header_200;
	hs->contenttype = http_content_type_binary;
	hs->contentlen = sizeof(http_content_type_binary) - 1;
	for(filetype = filetypes;
	filetype->ext != NULL;
	++filetype) {
	if(strncmp(filetype->ext,
	hs->getbuffer + (hs->getlen - filetype->extlen),
	filetype->extlen) == 0) {
	hs->contenttype = filetype->type;
	hs->contentlen = filetype->typelen;
	break;
	}
	}

	} else if(hs->getbuffer[0] == ISO_slash &&
	hs->getbuffer[1] == 0) {
	hs->count = sizeof(http_header_200) - 1;
	hs->dataptr = (char *)http_header_200;
	hs->contenttype = http_content_type_html;
	hs->contentlen = sizeof(http_content_type_html) - 1;
	httpd_fs_open(http_index_html, &hs->file);
	} else {
	hs->count = sizeof(http_header_404) - 1;
	hs->dataptr = (char *)http_header_404;
	hs->contenttype = http_content_type_html;
	hs->contentlen = sizeof(http_content_type_html) - 1;
	httpd_fs_open(http_404_html, &hs->file);
	}
	} else {
	buffer_reset(&(hs->buf));
	}
	}
	break;

	default:
	uip_len = 0;
	break;
	}
	}
	}
	/-----------------------------------------------------------------------------/
	static void
	acked(CC_REGISTER_ARG struct httpd_state *hs)
	{
	hs->poll = 0;


	switch(hs->state) {

	case STATE_SEND_HEADERS:
	if(hs->count >= uip_mss()) {
	hs->count -= uip_mss();
	hs->dataptr += uip_mss();
	} else {
	hs->count = 0;
	}
	if(hs->count == 0) {
	hs->state = STATE_SEND_CONTENT_TYPE;
	hs->count = hs->contentlen;
	hs->dataptr = (char *)hs->contenttype;
	}
	break;

	case STATE_SEND_CONTENT_TYPE:
	if(hs->count >= uip_mss()) {
	hs->count -= uip_mss();
	hs->dataptr += uip_mss();
	} else {
	hs->count = 0;
	}
	if(hs->count == 0) {
	hs->state = STATE_SEND_DATA;
	hs->count = hs->file.len;
	hs->dataptr = hs->file.data;
	}
	break;

	case STATE_SEND_DATA:
	if(hs->count >= uip_mss()) {
	hs->count -= uip_mss();
	hs->dataptr += uip_mss();
	} else {
	hs->count = 0;
	}
	if(hs->count == 0) {
	uip_close();
	dealloc_state(hs);
	}
	break;
	}
	}
	/-----------------------------------------------------------------------------/
	static void
	senddata(CC_REGISTER_ARG struct httpd_state *hs)
	{
	if(hs->state == STATE_SEND_HEADERS \|\|
	hs->state == STATE_SEND_CONTENT_TYPE \|\|
	hs->state == STATE_SEND_DATA) {
	uip_send(hs->dataptr,
	hs->count > uip_mss()? uip_mss(): hs->count);
	}
	}
	/-----------------------------------------------------------------------------/
	void
	httpd_appcall(void *state)
	{
	register struct httpd_state *hs;

	hs = (struct httpd_state *)(state);


	if(uip_connected()) {
	/* Since we've just been connected, the state pointer should be
	NULL and we need to allocate a new state object. If we have run
	out of memory for state objects, we'll have to abort the
	connection and return. */
	if(hs == NULL) {
	hs = alloc_state();
	if(hs == NULL) {
	uip_close();
	return;
	}
	tcp_markconn(uip_conn, (void *)hs);
	}
	/* Since we have just been connected with the remote host, we
	reset the state for this connection. The ->count variable
	contains the amount of data that is yet to be sent to the
	remote host, and the ->state is set to HTTP_NOGET to signal
	that we haven't received any HTTP GET request for this
	connection yet. */
	hs->state = STATE_INITIAL;
	hs->count = 0;
	hs->poll = 0;
	buffer_reset(&(hs->buf));
	return;
	}

	if(uip_closed() \|\|
	uip_aborted() \|\|
	uip_timedout()) {
	if(hs != NULL) {
	dealloc_state(hs);
	}
	return;
	} else if(uip_poll()) {
	/* If we are polled ten times, we abort the connection. This is
	because we don't want connections lingering indefinately in
	the system. */
	if(hs != NULL) {
	if(hs->state == STATE_DEALLOCATED) {
	uip_abort();
	} else if(hs->poll++ >= 100) {
	uip_abort();
	dealloc_state(hs);
	}
	}
	return;
	}

	if(uip_acked()) {
	acked(hs);
	}

	if(uip_newdata()) {
	newdata(hs);
	}

	if(uip_rexmit() \|\|
	uip_newdata() \|\|
	uip_acked()) {
	senddata(hs);
	} else if(uip_poll()) {
	senddata(hs);
	}


	}
	/-----------------------------------------------------------------------------/