/**************************************************************************** * netutils/webserver/httpd.c * httpd Web server * * Copyright (C) 2007, 2008 Gregory Nutt. All rights reserved. * Author: Gregory Nutt * * This is a leverage of similar logic from uIP: * * Author: Adam Dunkels * 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 #include #include #include #include #include #include #include #include #include #include #include #include "httpd.h" #include "httpd_cgi.h" /**************************************************************************** * 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 #undef CONFIG_NETUTILS_HTTPD_DUMPBUFFER #undef CONFIG_NETUTILS_HTTPD_DUMPPSTATE /**************************************************************************** * 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(const char *buffer, ssize_t nbytes) { #ifdef CONFIG_DEBUG char line[128]; int ch; int i; int j; for (i = 0; i < nbytes; i += 16) { sprintf(line, "%04x: ", i); for ( j = 0; j < 16; j++) { if (i + j < nbytes) { sprintf(&line[strlen(line)], "%02x ", buffer[i+j] ); } else { strcpy(&line[strlen(line)], " "); } } for ( j = 0; j < 16; j++) { if (i + j < nbytes) { ch = buffer[i+j]; sprintf(&line[strlen(line)], "%c", ch >= 0x20 && ch <= 0x7e ? ch : '.'); } } dbg("%s\n", line); } #endif } #else # define httpd_dumpbuffer(buffer,nbytes) #endif #ifdef CONFIG_NETUTILS_HTTPD_DUMPPSTATE static void httpd_dumppstate(struct httpd_state *pstate, const char *msg) { #ifdef CONFIG_DEBUG dbg("[%d] pstate(%p): [%s]\n", pstate->ht_sockfd, pstate, msg); dbg(" filename: [%s]\n", pstate->ht_filename); dbg(" htfile len: %d\n", pstate->ht_file.len); dbg(" sockfd: %d\n", pstate->ht_sockfd); dbg(" scriptptr: %p\n", pstate->ht_scriptptr); dbg(" scriptlen: %d\n", pstate->ht_scriptlen); dbg(" 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; } vdbg("[%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(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; if (!httpd_fs_open(pstate->ht_filename, &pstate->ht_file)) { 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(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) { dbg("[%d] recv failed: %d\n", pstate->ht_sockfd, errno); return ERROR; } httpd_dumpbuffer(pstate->ht_buffer, recvlen); /* We will handle only GET */ if (strncmp(pstate->ht_buffer, g_httpcmdget, strlen(g_httpcmdget)) != 0) { dbg("[%d] Unsupported command\n", pstate->ht_sockfd); return ERROR; } /* Get the name of the file to provide */ if (pstate->ht_buffer[4] != ISO_slash) { dbg("[%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'; } dbg("[%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; dbg("[%d] Started\n", sockfd); /* Verify that the state structure was successfully allocated */ if (pstate) { /* Loop processing each HTTP command */ // do { /* 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); } // while (ret == OK); /* 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: 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) { }