Projects/Webserver/Lib/HTTPServerApp.c

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2010.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6       www.fourwalledcubicle.com
   7 */
   8
   9 /*
  10   Copyright 2010  Dean Camera (dean [at] fourwalledcubicle [dot] com)
  11
  12   Permission to use, copy, modify, distribute, and sell this
  13   software and its documentation for any purpose is hereby granted
  14   without fee, provided that the above copyright notice appear in
  15   all copies and that both that the copyright notice and this
  16   permission notice and warranty disclaimer appear in supporting
  17   documentation, and that the name of the author not be used in
  18   advertising or publicity pertaining to distribution of the
  19   software without specific, written prior permission.
  20
  21   The author disclaim all warranties with regard to this
  22   software, including all implied warranties of merchantability
  23   and fitness.  In no event shall the author be liable for any
  24   special, indirect or consequential damages or any damages
  25   whatsoever resulting from loss of use, data or profits, whether
  26   in an action of contract, negligence or other tortious action,
  27   arising out of or in connection with the use or performance of
  28   this software.
  29 */
  30
  31 /** \file
  32  *
  33  *  Simple HTTP Webserver Application. When connected to the uIP stack,
  34  *  this will serve out files to HTTP clients on port 80.
  35  */
  36
  37 #define  INCLUDE_FROM_HTTPSERVERAPP_C
  38 #include "HTTPServerApp.h"
  39
  40 /** HTTP server response header, for transmission before the page contents. This indicates to the host that a page exists at the
  41  *  given location, and gives extra connection information.
  42  */
  43 const char PROGMEM HTTP200Header[] = "HTTP/1.1 200 OK\r\n"
  44                                      "Server: LUFA " LUFA_VERSION_STRING "\r\n"
  45                                      "Connection: close\r\n"
  46                                      "MIME-version: 1.0\r\n"
  47                                      "Content-Type: ";
  48
  49 /** HTTP server response header, for transmission before a resource not found error. This indicates to the host that the given
  50  *  given URL is invalid, and gives extra error information.
  51  */
  52 const char PROGMEM HTTP404Header[] = "HTTP/1.1 404 Not Found\r\n"
  53                                      "Server: LUFA " LUFA_VERSION_STRING "\r\n"
  54                                      "Connection: close\r\n"
  55                                      "MIME-version: 1.0\r\n"
  56                                      "Content-Type: text/plain\r\n\r\n"
  57                                      "Error 404: File Not Found: /";
  58
  59 /** Default MIME type sent if no other MIME type can be determined. */
  60 const char PROGMEM DefaultMIMEType[] = "text/plain";
  61
  62 /** Default filename to fetch when a directory is requested */
  63 const char PROGMEM DefaultDirFileName[] = "index.htm";
  64
  65 /** List of MIME types for each supported file extension. */
  66 const MIME_Type_t MIMETypes[] =
  67         {
  68                 {.Extension = "htm", .MIMEType = "text/html"},
  69                 {.Extension = "jpg", .MIMEType = "image/jpeg"},
  70                 {.Extension = "gif", .MIMEType = "image/gif"},
  71                 {.Extension = "bmp", .MIMEType = "image/bmp"},
  72                 {.Extension = "png", .MIMEType = "image/png"},
  73                 {.Extension = "ico", .MIMEType = "image/x-icon"},
  74                 {.Extension = "exe", .MIMEType = "application/octet-stream"},
  75                 {.Extension = "gz",  .MIMEType = "application/x-gzip"},
  76                 {.Extension = "zip", .MIMEType = "application/zip"},
  77                 {.Extension = "pdf", .MIMEType = "application/pdf"},
  78         };
  79
  80 /** FAT Fs structure to hold the internal state of the FAT driver for the dataflash contents. */
  81 FATFS DiskFATState;
  82
  83
  84 /** Initialization function for the simple HTTP webserver. */
  85 void HTTPServerApp_Init(void)
  86 {
  87         /* Listen on port 80 for HTTP connections from hosts */
  88         uip_listen(HTONS(HTTP_SERVER_PORT));
  89
  90         /* Mount the dataflash disk via FatFS */
  91         f_mount(0, &DiskFATState);
  92 }
  93
  94 /** uIP stack application callback for the simple HTTP webserver. This function must be called each time the
  95  *  TCP/IP stack needs a TCP packet to be processed.
  96  */
  97 void HTTPServerApp_Callback(void)
  98 {
  99         uip_tcp_appstate_t* const AppState = &uip_conn->appstate;
 100
 101         if (uip_aborted() || uip_timedout() || uip_closed())
 102         {
 103                 /* Connection is being terminated for some reason - close file handle */
 104                 f_close(&AppState->HTTPServer.FileHandle);
 105                 AppState->HTTPServer.FileOpen = false;
 106
 107                 /* Lock to the closed state so that no further processing will occur on the connection */
 108                 AppState->HTTPServer.CurrentState  = WEBSERVER_STATE_Closed;
 109                 AppState->HTTPServer.NextState     = WEBSERVER_STATE_Closed;
 110         }
 111
 112         if (uip_connected())
 113         {
 114                 /* New connection - initialize connection state values */
 115                 AppState->HTTPServer.CurrentState  = WEBSERVER_STATE_OpenRequestedFile;
 116                 AppState->HTTPServer.NextState     = WEBSERVER_STATE_OpenRequestedFile;
 117                 AppState->HTTPServer.FileOpen      = false;
 118                 AppState->HTTPServer.ACKedFilePos  = 0;
 119                 AppState->HTTPServer.SentChunkSize = 0;
 120         }
 121
 122         if (uip_acked())
 123         {
 124                 /* Add the amount of ACKed file data to the total sent file bytes counter */
 125                 AppState->HTTPServer.ACKedFilePos += AppState->HTTPServer.SentChunkSize;
 126
 127                 /* Progress to the next state once the current state's data has been ACKed */
 128                 AppState->HTTPServer.CurrentState = AppState->HTTPServer.NextState;
 129         }
 130
 131         if (uip_rexmit())
 132         {
 133                 /* Return file pointer to the last ACKed position */
 134                 f_lseek(&AppState->HTTPServer.FileHandle, AppState->HTTPServer.ACKedFilePos);
 135         }
 136
 137         if (uip_rexmit() || uip_acked() || uip_newdata() || uip_connected() || uip_poll())
 138         {
 139                 switch (AppState->HTTPServer.CurrentState)
 140                 {
 141                         case WEBSERVER_STATE_OpenRequestedFile:
 142                                 HTTPServerApp_OpenRequestedFile();
 143                                 break;
 144                         case WEBSERVER_STATE_SendResponseHeader:
 145                                 HTTPServerApp_SendResponseHeader();
 146                                 break;
 147                         case WEBSERVER_STATE_SendData:
 148                                 HTTPServerApp_SendData();
 149                                 break;
 150                         case WEBSERVER_STATE_Closing:
 151                                 uip_close();
 152
 153                                 AppState->HTTPServer.NextState = WEBSERVER_STATE_Closed;
 154                                 break;
 155                 }
 156         }
 157 }
 158
 159 /** HTTP Server State handler for the Request Process state. This state manages the processing of incoming HTTP
 160  *  GET requests to the server from the receiving HTTP client.
 161  */
 162 static void HTTPServerApp_OpenRequestedFile(void)
 163 {
 164         uip_tcp_appstate_t* const AppState    = &uip_conn->appstate;
 165         char*               const AppData     = (char*)uip_appdata;
 166
 167         /* No HTTP header received from the client, abort processing */
 168         if (!(uip_newdata()))
 169           return;
 170
 171         char* RequestToken      = strtok(AppData, " ");
 172         char* RequestedFileName = strtok(NULL, " ");
 173
 174         /* Must be a GET request, abort otherwise */
 175         if (strcmp(RequestToken, "GET") != 0)
 176         {
 177                 uip_abort();
 178                 return;
 179         }
 180
 181         /* Copy over the requested filename */
 182         strncpy(AppState->HTTPServer.FileName, &RequestedFileName[1], (sizeof(AppState->HTTPServer.FileName) - 1));
 183
 184         /* Ensure filename is null-terminated */
 185         AppState->HTTPServer.FileName[sizeof(AppState->HTTPServer.FileName) - 1] = 0x00;
 186
 187         /* Determine the length of the URI so that it can be checked to see if it is a directory */
 188         uint8_t FileNameLen = strlen(AppState->HTTPServer.FileName);
 189
 190         /* If the URI is a directory, append the default filename */
 191         if (AppState->HTTPServer.FileName[FileNameLen - 1] == '/')
 192         {
 193                 strncpy_P(&AppState->HTTPServer.FileName[FileNameLen], DefaultDirFileName,
 194                           (sizeof(AppState->HTTPServer.FileName) - FileNameLen));
 195
 196                 /* Ensure altered filename is still null-terminated */
 197                 AppState->HTTPServer.FileName[sizeof(AppState->HTTPServer.FileName) - 1] = 0x00;
 198         }
 199
 200         /* Try to open the file from the Dataflash disk */
 201         AppState->HTTPServer.FileOpen     = (f_open(&AppState->HTTPServer.FileHandle, AppState->HTTPServer.FileName,
 202                                                     (FA_OPEN_EXISTING | FA_READ)) == FR_OK);
 203
 204         /* Lock to the SendResponseHeader state until connection terminated */
 205         AppState->HTTPServer.CurrentState = WEBSERVER_STATE_SendResponseHeader;
 206         AppState->HTTPServer.NextState    = WEBSERVER_STATE_SendResponseHeader;
 207 }
 208
 209 /** HTTP Server State handler for the HTTP Response Header Send state. This state manages the transmission of
 210  *  the HTTP response header to the receiving HTTP client.
 211  */
 212 static void HTTPServerApp_SendResponseHeader(void)
 213 {
 214         uip_tcp_appstate_t* const AppState    = &uip_conn->appstate;
 215         char*               const AppData     = (char*)uip_appdata;
 216
 217         char* Extension     = strpbrk(AppState->HTTPServer.FileName, ".");
 218         bool  FoundMIMEType = false;
 219
 220         /* If the file isn't already open, it wasn't found - send back a 404 error response and abort */
 221         if (!(AppState->HTTPServer.FileOpen))
 222         {
 223                 /* Copy over the HTTP 404 response header and send it to the receiving client */
 224                 strcpy_P(AppData, HTTP404Header);
 225                 strcpy(&AppData[strlen(AppData)], AppState->HTTPServer.FileName);
 226                 uip_send(AppData, strlen(AppData));
 227
 228                 AppState->HTTPServer.NextState = WEBSERVER_STATE_Closing;
 229                 return;
 230         }
 231
 232         /* Copy over the HTTP 200 response header and send it to the receiving client */
 233         strcpy_P(AppData, HTTP200Header);
 234
 235         /* Check to see if a MIME type for the requested file's extension was found */
 236         if (Extension != NULL)
 237         {
 238                 /* Look through the MIME type list, copy over the required MIME type if found */
 239                 for (uint8_t i = 0; i < (sizeof(MIMETypes) / sizeof(MIMETypes[0])); i++)
 240                 {
 241                         if (strcmp(&Extension[1], MIMETypes[i].Extension) == 0)
 242                         {
 243                                 strcpy(&AppData[strlen(AppData)], MIMETypes[i].MIMEType);
 244                                 FoundMIMEType = true;
 245                                 break;
 246                         }
 247                 }
 248         }
 249
 250         /* Check if a MIME type was found and copied to the output buffer */
 251         if (!(FoundMIMEType))
 252         {
 253                 /* MIME type not found - copy over the default MIME type */
 254                 strcpy_P(&AppData[strlen(AppData)], DefaultMIMEType);
 255         }
 256
 257         /* Add the end-of-line terminator and end-of-headers terminator after the MIME type */
 258         strcpy(&AppData[strlen(AppData)], "\r\n\r\n");
 259
 260         /* Send the MIME header to the receiving client */
 261         uip_send(AppData, strlen(AppData));
 262
 263         /* When the MIME header is ACKed, progress to the data send stage */
 264         AppState->HTTPServer.NextState = WEBSERVER_STATE_SendData;
 265 }
 266
 267 /** HTTP Server State handler for the Data Send state. This state manages the transmission of file chunks
 268  *  to the receiving HTTP client.
 269  */
 270 static void HTTPServerApp_SendData(void)
 271 {
 272         uip_tcp_appstate_t* const AppState    = &uip_conn->appstate;
 273         char*               const AppData     = (char*)uip_appdata;
 274
 275         /* Get the maximum segment size for the current packet */
 276         uint16_t MaxChunkSize = uip_mss();
 277
 278         /* Read the next chunk of data from the open file */
 279         f_read(&AppState->HTTPServer.FileHandle, AppData, MaxChunkSize, &AppState->HTTPServer.SentChunkSize);
 280
 281         /* Send the next file chunk to the receiving client */
 282         uip_send(AppData, AppState->HTTPServer.SentChunkSize);
 283
 284         /* Check if we are at the last chunk of the file, if so next ACK should close the connection */
 285         if (MaxChunkSize != AppState->HTTPServer.SentChunkSize)
 286           AppState->HTTPServer.NextState = WEBSERVER_STATE_Closing;
 287 }