X-Git-Url: http://git.linex4red.de/pub/USBasp.git/blobdiff_plain/d11ed10c5314c44dc01c06954d1d73d4894cbff8..f4f44f9fc11d0ee9e0dbaf3323d095af32e8b0ef:/Projects/Webserver/Lib/HTTPServerApp.c?ds=sidebyside

diff --git a/Projects/Webserver/Lib/HTTPServerApp.c b/Projects/Webserver/Lib/HTTPServerApp.c
index 01aab76ea..081207c6b 100644
--- a/Projects/Webserver/Lib/HTTPServerApp.c
+++ b/Projects/Webserver/Lib/HTTPServerApp.c
@@ -34,6 +34,7 @@
  *  this will serve out files to HTTP clients.
  */
  
+#define  INCLUDE_FROM_HTTPSERVERAPP_C
 #include "HTTPServerApp.h"
 
 /** HTTP server response header, for transmission before the page contents. This indicates to the host that a page exists at the
@@ -41,22 +42,44 @@
  */
 char PROGMEM HTTP200Header[] = "HTTP/1.1 200 OK\r\n"
                                "Server: LUFA RNDIS\r\n"
-                               "Content-type: text/html\r\n"
-                               "Connection: close\r\n\r\n";
+                               "Connection: close\r\n"
+                               "MIME-version: 1.0\r\n"
+                               "Content-Type: ";
 
 /** HTTP server response header, for transmission before a resource not found error. This indicates to the host that the given
  *  given URL is invalid, and gives extra error information.
  */
 char PROGMEM HTTP404Header[] = "HTTP/1.1 404 Not Found\r\n"
                                "Server: LUFA RNDIS\r\n"
-                               "Connection: close\r\n\r\n"
-							   "The requested file was not found.";
+                               "Connection: close\r\n"
+                               "MIME-version: 1.0\r\n"
+                               "Content-Type: text/plain\r\n\r\n"
+                               "Error 404: File Not Found";
+
+/** Default MIME type sent if no other MIME type can be determined */
+char PROGMEM DefaultMIMEType[] = "text/plain";
+
+/** List of MIME types for each supported file extension. */
+MIME_Type_t PROGMEM MIMETypes[] =
+	{
+		{.Extension = "htm", .MIMEType = "text/html"},
+		{.Extension = "jpg", .MIMEType = "image/jpeg"},
+		{.Extension = "gif", .MIMEType = "image/gif"},
+		{.Extension = "bmp", .MIMEType = "image/bmp"},
+		{.Extension = "png", .MIMEType = "image/png"},
+		{.Extension = "ico", .MIMEType = "image/x-icon"},
+		{.Extension = "exe", .MIMEType = "application/octet-stream"},
+		{.Extension = "gz",  .MIMEType = "application/x-gzip"},
+		{.Extension = "zip", .MIMEType = "application/zip"},
+		{.Extension = "pdf", .MIMEType = "application/pdf"},
+	};
 
 /** FAT Fs structure to hold the internal state of the FAT driver for the dataflash contents. */
 FATFS DiskFATState;
 
+
 /** Initialization function for the simple HTTP webserver. */
-void WebserverApp_Init(void)
+void HTTPServerApp_Init(void)
 {
 	/* Listen on port 80 for HTTP connections from hosts */
 	uip_listen(HTONS(HTTP_SERVER_PORT));
@@ -68,110 +91,197 @@ void WebserverApp_Init(void)
 /** uIP stack application callback for the simple HTTP webserver. This function must be called each time the
  *  TCP/IP stack needs a TCP packet to be processed.
  */
-void WebserverApp_Callback(void)
+void HTTPServerApp_Callback(void)
 {
-	uip_tcp_appstate_t* const AppState    = &uip_conn->appstate;
-	char*                     AppData     = (char*)uip_appdata;
-	uint16_t                  AppDataSize = 0;
+	uip_tcp_appstate_t* const AppState = &uip_conn->appstate;
 
-	if (uip_aborted() || uip_timedout())
+	if (uip_aborted() || uip_timedout() || uip_closed())
 	{
-		/* Close the file before terminating, if it is open */
-		f_close(&AppState->FileToSend);
+		/* Connection is being terminated for some reason - close file handle */
+		f_close(&AppState->HTTPServer.FileHandle);
+		AppState->HTTPServer.FileOpen = false;
+		
+		/* Lock to the closed state so that no further processing will occur on the connection */
+		AppState->HTTPServer.CurrentState  = WEBSERVER_STATE_Closed;
+		AppState->HTTPServer.NextState     = WEBSERVER_STATE_Closed;
+	}
 
-		AppState->CurrentState = WEBSERVER_STATE_Closed;
+	if (uip_connected())
+	{
+		/* New connection - initialize connection state values */
+		AppState->HTTPServer.CurrentState  = WEBSERVER_STATE_OpenRequestedFile;
+		AppState->HTTPServer.NextState     = WEBSERVER_STATE_OpenRequestedFile;
+		AppState->HTTPServer.FileOpen      = false;
+		AppState->HTTPServer.ACKedFilePos  = 0;
+		AppState->HTTPServer.SentChunkSize = 0;
+	}
 
-		return;
+	if (uip_acked())
+	{
+		/* Add the amount of ACKed file data to the total sent file bytes counter */
+		AppState->HTTPServer.ACKedFilePos += AppState->HTTPServer.SentChunkSize;
+
+		/* Progress to the next state once the current state's data has been ACKed */
+		AppState->HTTPServer.CurrentState = AppState->HTTPServer.NextState;
 	}
-	else if (uip_closed())
+
+	if (uip_rexmit() || uip_acked() || uip_newdata() || uip_connected() || uip_poll())
 	{
-		/* Completed connection, just return */
+		switch (AppState->HTTPServer.CurrentState)
+		{
+			case WEBSERVER_STATE_OpenRequestedFile:
+				HTTPServerApp_OpenRequestedFile();
+				break;
+			case WEBSERVER_STATE_SendResponseHeader:
+				HTTPServerApp_SendResponseHeader();
+				break;
+			case WEBSERVER_STATE_SendMIMETypeHeader:
+				HTTPServerApp_SendMIMETypeHeader();	
+				break;
+			case WEBSERVER_STATE_SendData:
+				HTTPServerApp_SendData();
+				break;
+			case WEBSERVER_STATE_Closing:
+				uip_close();
+				
+				AppState->HTTPServer.NextState = WEBSERVER_STATE_Closed;
+				break;
+		}		  
+	}		
+}
+
+/** HTTP Server State handler for the Request Process state. This state manages the processing of incomming HTTP
+ *  GET requests to the server from the receiving HTTP client.
+ */
+static void HTTPServerApp_OpenRequestedFile(void)
+{
+	uip_tcp_appstate_t* const AppState    = &uip_conn->appstate;
+	char*               const AppData     = (char*)uip_appdata;
+	
+	/* No HTTP header received from the client, abort processing */
+	if (!(uip_newdata()))
+	  return;
+	  
+	char* RequestToken = strtok(AppData, " ");
+			
+	/* Must be a GET request, abort otherwise */
+	if (strcmp(RequestToken, "GET") != 0)
+	{
+		uip_abort();
 		return;
 	}
-	else if (uip_connected())
+
+	char* RequestedFileName = strtok(NULL, " ");
+	
+	/* If the requested filename has more that just the leading '/' path in it, copy it over */
+	if (strlen(RequestedFileName) > 1)
+	  strncpy(AppState->HTTPServer.FileName, &RequestedFileName[1], (sizeof(AppState->HTTPServer.FileName) - 1));
+	else
+	  strcpy(AppState->HTTPServer.FileName, "index.htm");
+
+	/* Ensure filename is null-terminated */
+	AppState->HTTPServer.FileName[(sizeof(AppState->HTTPServer.FileName) - 1)] = 0x00;
+	
+	/* Try to open the file from the Dataflash disk */
+	AppState->HTTPServer.FileOpen     = (f_open(&AppState->HTTPServer.FileHandle, AppState->HTTPServer.FileName, FA_OPEN_EXISTING | FA_READ) == FR_OK);
+
+	/* Lock to the SendResponseHeader state until connection terminated */
+	AppState->HTTPServer.CurrentState = WEBSERVER_STATE_SendResponseHeader;
+	AppState->HTTPServer.NextState    = WEBSERVER_STATE_SendResponseHeader;
+}
+
+/** HTTP Server State handler for the HTTP Response Header Send state. This state manages the transmission of
+ *  the HTTP response header to the receiving HTTP client.
+ */
+static void HTTPServerApp_SendResponseHeader(void)
+{
+	uip_tcp_appstate_t* const AppState    = &uip_conn->appstate;
+	char*               const AppData     = (char*)uip_appdata;
+
+	char* HeaderToSend;
+
+	/* Determine which HTTP header should be sent to the client */
+	if (AppState->HTTPServer.FileOpen)
 	{
-		/* New connection - initialize connection state and data pointer to the appropriate HTTP header */
-		AppState->CurrentState = WEBSERVER_STATE_OpenRequestedFile;
+		HeaderToSend = HTTP200Header;
+		AppState->HTTPServer.NextState = WEBSERVER_STATE_SendMIMETypeHeader;
 	}
-	
-	switch (AppState->CurrentState)
+	else
 	{
-		case WEBSERVER_STATE_OpenRequestedFile:
-			/* Wait for the packet containing the request header */
-			if (uip_datalen())
-			{
-				/* Must be a GET request, abort otherwise */
-				if (strncmp(AppData, "GET ", (sizeof("GET ") - 1)) != 0)
-				{
-					uip_abort();
-					break;
-				}
-		
-				char FileName[13];
-
-				/* Copy over the requested filename from the GET request */
-				for (uint8_t i = 0; i < (sizeof(FileName) - 1); i++)
-				{
-					FileName[i] = AppData[sizeof("GET ") + i];
-					
-					if (FileName[i] == ' ')
-					{
-						FileName[i] = 0x00;
-						break;
-					}
-				}
-				
-				/* Ensure requested filename is null-terminated */
-				FileName[(sizeof(FileName) - 1)] = 0x00;
-				
-				/* If no filename specified, assume the default of INDEX.HTM */
-				if (FileName[0] == 0x00)
-				  strcpy(FileName, "INDEX.HTM");
-				
-				/* Try to open the file from the Dataflash disk */
-				AppState->FileOpen = (f_open(&AppState->FileToSend, FileName, FA_OPEN_EXISTING | FA_READ) == FR_OK);
+		HeaderToSend = HTTP404Header;
+		AppState->HTTPServer.NextState = WEBSERVER_STATE_Closing;
+	}
 
-				AppState->CurrentState = WEBSERVER_STATE_SendHeaders;
-			}
+	/* Copy over the HTTP response header and send it to the receiving client */
+	strcpy_P(AppData, HeaderToSend);
+	uip_send(AppData, strlen(AppData));
+}
 
-			break;
-		case WEBSERVER_STATE_SendHeaders:
-			/* Determine what HTTP header should be sent to the client */
-			if (AppState->FileOpen)
-			{
-				AppDataSize = strlen_P(HTTP200Header);
-				strncpy_P(AppData, HTTP200Header, AppDataSize);				
-			}
-			else
-			{
-				AppDataSize = strlen_P(HTTP404Header);
-				strncpy_P(AppData, HTTP404Header, AppDataSize);				
-			}
-			
-			uip_send(AppData, AppDataSize);
-			
-			AppState->CurrentState = WEBSERVER_STATE_SendData;
-			break;
-		case WEBSERVER_STATE_SendData:
-			/* If end of file/file not open, progress to the close state */
-			if (!(AppState->FileOpen))
+/** HTTP Server State handler for the MIME Header Send state. This state manages the transmission of the file
+ *  MIME type header for the requested file to the receiving HTTP client.
+ */
+static void HTTPServerApp_SendMIMETypeHeader(void)
+{
+	uip_tcp_appstate_t* const AppState    = &uip_conn->appstate;
+	char*               const AppData     = (char*)uip_appdata;
+
+	char*    Extension        = strpbrk(AppState->HTTPServer.FileName, ".");
+	uint16_t MIMEHeaderLength = 0;
+
+	/* Check to see if a file extension was found for the requested filename */
+	if (Extension != NULL)
+	{
+		/* Look through the MIME type list, copy over the required MIME type if found */
+		for (int i = 0; i < (sizeof(MIMETypes) / sizeof(MIMETypes[0])); i++)
+		{
+			if (strcmp_P(&Extension[1], MIMETypes[i].Extension) == 0)
 			{
-				f_close(&AppState->FileToSend);
-				uip_close();
-				AppState->CurrentState = WEBSERVER_STATE_Closed;
+				MIMEHeaderLength = strlen_P(MIMETypes[i].MIMEType);
+				strncpy_P(AppData, MIMETypes[i].MIMEType, MIMEHeaderLength);						
 				break;
 			}
+		} 
+	}
 
-			uint16_t MaxSegSize = uip_mss();
-			
-			/* Read the next chunk of data from the open file */
-			f_read(&AppState->FileToSend, AppData, MaxSegSize, &AppDataSize);
-			AppState->FileOpen = (MaxSegSize == AppDataSize);
-
-			/* If data was read, send it to the client */
-			if (AppDataSize)
-			  uip_send(AppData, AppDataSize);
-					
-			break;
+	/* Check if a MIME type was found and copied to the output buffer */
+	if (!(MIMEHeaderLength))
+	{
+		/* MIME type not found - copy over the default MIME type */
+		MIMEHeaderLength = strlen_P(DefaultMIMEType);
+		strncpy_P(AppData, DefaultMIMEType, MIMEHeaderLength);
 	}
+	
+	/* Add the end-of line terminator and end-of-headers terminator after the MIME type */
+	strncpy(&AppData[MIMEHeaderLength], "\r\n\r\n", sizeof("\r\n\r\n"));
+	MIMEHeaderLength += (sizeof("\r\n\r\n") - 1);
+	
+	/* Send the MIME header to the receiving client */
+	uip_send(AppData, MIMEHeaderLength);
+	
+	/* When the MIME header is ACKed, progress to the data send stage */
+	AppState->HTTPServer.NextState = WEBSERVER_STATE_SendData;
+}
+
+/** HTTP Server State handler for the Data Send state. This state manages the transmission of file chunks
+ *  to the receiving HTTP client.
+ */
+static void HTTPServerApp_SendData(void)
+{
+	uip_tcp_appstate_t* const AppState    = &uip_conn->appstate;
+	char*               const AppData     = (char*)uip_appdata;
+
+	/* Must determine the maximum segment size to determine maximum file chunk size */
+	uint16_t MaxSegmentSize = uip_mss();
+
+	/* Return file pointer to the last ACKed position */
+	f_lseek(&AppState->HTTPServer.FileHandle, AppState->HTTPServer.ACKedFilePos);
+	
+	/* Read the next chunk of data from the open file */
+	f_read(&AppState->HTTPServer.FileHandle, AppData, MaxSegmentSize, &AppState->HTTPServer.SentChunkSize);
+	
+	/* Send the next file chunk to the receiving client */
+	uip_send(AppData, AppState->HTTPServer.SentChunkSize);
+			
+	/* Check if we are at the last chunk of the file, if so next ACK should close the connection */
+	AppState->HTTPServer.NextState = (MaxSegmentSize != AppState->HTTPServer.SentChunkSize) ? WEBSERVER_STATE_Closing : WEBSERVER_STATE_SendData;
 }