/** | |
* \addtogroup exampleapps | |
* @{ | |
*/ | |
/** | |
* \defgroup httpd Web server | |
* @{ | |
* | |
* 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. | |
* | |
* The script language is very simple and works as follows. Each | |
* script line starts with a command character, either "i", "t", "c", | |
* "#" or ".". The "i" command tells the script interpreter to | |
* "include" a file from the virtual file system and output it to the | |
* web browser. The "t" command should be followed by a line of text | |
* that is to be output to the browser. The "c" command is used to | |
* call one of the C functions from the httpd-cgi.c file. A line that | |
* starts with a "#" is ignored (i.e., the "#" denotes a comment), and | |
* the "." denotes the last script line. | |
* | |
* The script that produces the file statistics page looks somewhat | |
* like this: | |
* | |
\code | |
i /header.html | |
t <h1>File statistics</h1><br><table width="100%"> | |
t <tr><td><a href="/index.html">/index.html</a></td><td> | |
c a /index.html | |
t </td></tr> <tr><td><a href="/cgi/files">/cgi/files</a></td><td> | |
c a /cgi/files | |
t </td></tr> <tr><td><a href="/cgi/tcp">/cgi/tcp</a></td><td> | |
c a /cgi/tcp | |
t </td></tr> <tr><td><a href="/404.html">/404.html</a></td><td> | |
c a /404.html | |
t </td></tr></table> | |
i /footer.plain | |
. | |
\endcode | |
* | |
*/ | |
/** | |
* \file | |
* HTTP server. | |
* \author Adam Dunkels <adam@dunkels.com> | |
*/ | |
/* | |
* 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. | |
* | |
* This file is part of the uIP TCP/IP stack. | |
* | |
* $Id: httpd.c,v 1.28.2.6 2003/10/07 13:22:27 adam Exp $ | |
* | |
*/ | |
#include "uip.h" | |
#include "httpd.h" | |
#include "fs.h" | |
#include "fsdata.h" | |
#include "cgi.h" | |
#define NULL (void *)0 | |
/* The HTTP server states: */ | |
#define HTTP_NOGET 0 | |
#define HTTP_FILE 1 | |
#define HTTP_TEXT 2 | |
#define HTTP_FUNC 3 | |
#define HTTP_END 4 | |
#ifdef DEBUG | |
#include <stdio.h> | |
#define PRINT(x) | |
#define PRINTLN(x) | |
#else /* DEBUG */ | |
#define PRINT(x) | |
#define PRINTLN(x) | |
#endif /* DEBUG */ | |
struct httpd_state *hs; | |
extern const struct fsdata_file file_index_html; | |
extern const struct fsdata_file file_404_html; | |
static void next_scriptline(void); | |
static void next_scriptstate(void); | |
#define ISO_G 0x47 | |
#define ISO_E 0x45 | |
#define ISO_T 0x54 | |
#define ISO_slash 0x2f | |
#define ISO_c 0x63 | |
#define ISO_g 0x67 | |
#define ISO_i 0x69 | |
#define ISO_space 0x20 | |
#define ISO_nl 0x0a | |
#define ISO_cr 0x0d | |
#define ISO_a 0x61 | |
#define ISO_t 0x74 | |
#define ISO_hash 0x23 | |
#define ISO_period 0x2e | |
#define httpPORT 80 | |
/*-----------------------------------------------------------------------------------*/ | |
/** | |
* Initialize the web server. | |
* | |
* Starts to listen for incoming connection requests on TCP port 80. | |
*/ | |
/*-----------------------------------------------------------------------------------*/ | |
void | |
httpd_init(void) | |
{ | |
fs_init(); | |
/* Listen to port 80. */ | |
uip_listen(HTONS(httpPORT)); | |
} | |
/*-----------------------------------------------------------------------------------*/ | |
void | |
httpd_appcall(void) | |
{ | |
struct fs_file fsfile; | |
u8_t i; | |
switch(uip_conn->lport) { | |
/* This is the web server: */ | |
case HTONS(httpPORT): | |
/* Pick out the application state from the uip_conn structure. */ | |
hs = (struct httpd_state *)(uip_conn->appstate); | |
/* We use the uip_ test functions to deduce why we were | |
called. If uip_connected() is non-zero, we were called | |
because a remote host has connected to us. If | |
uip_newdata() is non-zero, we were called because the | |
remote host has sent us new data, and if uip_acked() is | |
non-zero, the remote host has acknowledged the data we | |
previously sent to it. */ | |
if(uip_connected()) { | |
/* 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 = HTTP_NOGET; | |
hs->count = 0; | |
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->count++ >= 10) { | |
uip_abort(); | |
} | |
return; | |
} else if(uip_newdata() && hs->state == HTTP_NOGET) { | |
/* This is the first data we receive, and it should contain a | |
GET. */ | |
/* Check for GET. */ | |
if(uip_appdata[0] != ISO_G || | |
uip_appdata[1] != ISO_E || | |
uip_appdata[2] != ISO_T || | |
uip_appdata[3] != ISO_space) { | |
/* If it isn't a GET, we abort the connection. */ | |
uip_abort(); | |
return; | |
} | |
/* Find the file we are looking for. */ | |
for(i = 4; i < 40; ++i) { | |
if(uip_appdata[i] == ISO_space || | |
uip_appdata[i] == ISO_cr || | |
uip_appdata[i] == ISO_nl) { | |
uip_appdata[i] = 0; | |
break; | |
} | |
} | |
PRINT("request for file "); | |
PRINTLN(&uip_appdata[4]); | |
/* Check for a request for "/". */ | |
if(uip_appdata[4] == ISO_slash && | |
uip_appdata[5] == 0) { | |
fs_open(file_index_html.name, &fsfile); | |
} else { | |
if(!fs_open((const char *)&uip_appdata[4], &fsfile)) { | |
PRINTLN("couldn't open file"); | |
fs_open(file_404_html.name, &fsfile); | |
} | |
} | |
if(uip_appdata[4] == ISO_slash && | |
uip_appdata[5] == ISO_c && | |
uip_appdata[6] == ISO_g && | |
uip_appdata[7] == ISO_i && | |
uip_appdata[8] == ISO_slash) { | |
/* If the request is for a file that starts with "/cgi/", we | |
prepare for invoking a script. */ | |
hs->script = fsfile.data; | |
next_scriptstate(); | |
} else { | |
hs->script = NULL; | |
/* The web server is now no longer in the HTTP_NOGET state, but | |
in the HTTP_FILE state since is has now got the GET from | |
the client and will start transmitting the file. */ | |
hs->state = HTTP_FILE; | |
/* Point the file pointers in the connection state to point to | |
the first byte of the file. */ | |
hs->dataptr = fsfile.data; | |
hs->count = fsfile.len; | |
} | |
} | |
if(hs->state != HTTP_FUNC) { | |
/* Check if the client (remote end) has acknowledged any data that | |
we've previously sent. If so, we move the file pointer further | |
into the file and send back more data. If we are out of data to | |
send, we close the connection. */ | |
if(uip_acked()) { | |
if(hs->count >= uip_conn->len) { | |
hs->count -= uip_conn->len; | |
hs->dataptr += uip_conn->len; | |
} else { | |
hs->count = 0; | |
} | |
if(hs->count == 0) { | |
if(hs->script != NULL) { | |
next_scriptline(); | |
next_scriptstate(); | |
} else { | |
uip_close(); | |
} | |
} | |
} | |
} else { | |
/* Call the CGI function. */ | |
if(cgitab[hs->script[2] - ISO_a](uip_acked())) { | |
/* If the function returns non-zero, we jump to the next line | |
in the script. */ | |
next_scriptline(); | |
next_scriptstate(); | |
} | |
} | |
if(hs->state != HTTP_FUNC && !uip_poll()) { | |
/* Send a piece of data, but not more than the MSS of the | |
connection. */ | |
uip_send(( void * ) hs->dataptr, hs->count); | |
} | |
/* Finally, return to uIP. Our outgoing packet will soon be on its | |
way... */ | |
return; | |
default: | |
/* Should never happen. */ | |
uip_abort(); | |
break; | |
} | |
} | |
/*-----------------------------------------------------------------------------------*/ | |
/* next_scriptline(): | |
* | |
* Reads the script until it finds a newline. */ | |
static void | |
next_scriptline(void) | |
{ | |
/* Loop until we find a newline character. */ | |
do { | |
++(hs->script); | |
} while(hs->script[0] != ISO_nl); | |
/* Eat up the newline as well. */ | |
++(hs->script); | |
} | |
/*-----------------------------------------------------------------------------------*/ | |
/* next_sciptstate: | |
* | |
* Reads one line of script and decides what to do next. | |
*/ | |
static void | |
next_scriptstate(void) | |
{ | |
struct fs_file fsfile; | |
long i; | |
again: | |
switch(hs->script[0]) { | |
case ISO_t: | |
/* Send a text string. */ | |
hs->state = HTTP_TEXT; | |
hs->dataptr = &hs->script[2]; | |
/* Calculate length of string. */ | |
for(i = 0; hs->dataptr[i] != ISO_nl; ++i); | |
hs->count = i; | |
break; | |
case ISO_c: | |
/* Call a function. */ | |
hs->state = HTTP_FUNC; | |
hs->dataptr = NULL; | |
hs->count = 0; | |
cgitab[hs->script[2] - ISO_a](0); | |
break; | |
case ISO_i: | |
/* Include a file. */ | |
hs->state = HTTP_FILE; | |
if(!fs_open(&hs->script[2], &fsfile)) { | |
uip_abort(); | |
} | |
hs->dataptr = fsfile.data; | |
hs->count = fsfile.len; | |
break; | |
case ISO_hash: | |
/* Comment line. */ | |
next_scriptline(); | |
goto again; | |
case ISO_period: | |
/* End of script. */ | |
hs->state = HTTP_END; | |
uip_close(); | |
break; | |
default: | |
uip_abort(); | |
break; | |
} | |
} | |
/*-----------------------------------------------------------------------------------*/ | |
/** @} */ | |
/** @} */ |