You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
373 lines
10 KiB
C
373 lines
10 KiB
C
/**
|
|
* \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;
|
|
}
|
|
}
|
|
/*-----------------------------------------------------------------------------------*/
|
|
/** @} */
|
|
/** @} */
|