HTTPServerApp.c 10.7 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
/*
             LUFA Library
     Copyright (C) Dean Camera, 2010.
              
  dean [at] fourwalledcubicle [dot] com
      www.fourwalledcubicle.com
*/

/*
  Copyright 2010  Dean Camera (dean [at] fourwalledcubicle [dot] com)

  Permission to use, copy, modify, distribute, and sell this 
  software and its documentation for any purpose is hereby granted
  without fee, provided that the above copyright notice appear in 
  all copies and that both that the copyright notice and this
  permission notice and warranty disclaimer appear in supporting 
  documentation, and that the name of the author not be used in 
  advertising or publicity pertaining to distribution of the 
  software without specific, written prior permission.

  The author disclaim all warranties with regard to this
  software, including all implied warranties of merchantability
  and fitness.  In no event shall the author be liable for any
  special, indirect or consequential damages or any damages
  whatsoever resulting from loss of use, data or profits, whether
  in an action of contract, negligence or other tortious action,
  arising out of or in connection with the use or performance of
  this software.
*/

/** \file
 *
 *  Simple HTTP Webserver Application. When connected to the uIP stack,
 *  this will serve out files to HTTP clients.
 */
 
37
#define  INCLUDE_FROM_HTTPSERVERAPP_C
38
39
40
41
42
43
44
#include "HTTPServerApp.h"

/** HTTP server response header, for transmission before the page contents. This indicates to the host that a page exists at the
 *  given location, and gives extra connection information.
 */
char PROGMEM HTTP200Header[] = "HTTP/1.1 200 OK\r\n"
                               "Server: LUFA RNDIS\r\n"
45
                               "Connection: close\r\n"
46
47
                               "MIME-version: 1.0\r\n"
                               "Content-Type: ";
48
49
50
51
52
53

/** 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"
54
                               "Connection: close\r\n"
55
56
57
                               "MIME-version: 1.0\r\n"
                               "Content-Type: text/plain\r\n\r\n"
                               "Error 404: File Not Found";
58
59
60
61

/** Default MIME type sent if no other MIME type can be determined */
char PROGMEM DefaultMIMEType[] = "text/plain";

62
/** List of MIME types for each supported file extension. */
63
64
65
66
67
68
69
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"},
70
		{.Extension = "ico", .MIMEType = "image/x-icon"},
71
72
73
74
75
		{.Extension = "exe", .MIMEType = "application/octet-stream"},
		{.Extension = "gz",  .MIMEType = "application/x-gzip"},
		{.Extension = "zip", .MIMEType = "application/zip"},
		{.Extension = "pdf", .MIMEType = "application/pdf"},
	};
76
77
78
79

/** FAT Fs structure to hold the internal state of the FAT driver for the dataflash contents. */
FATFS DiskFATState;

80

81
/** Initialization function for the simple HTTP webserver. */
82
void HTTPServerApp_Init(void)
83
84
85
86
87
88
89
90
91
92
93
{
	/* Listen on port 80 for HTTP connections from hosts */
	uip_listen(HTONS(HTTP_SERVER_PORT));
	
	/* Mount the dataflash disk via FatFS */
	f_mount(0, &DiskFATState);
}

/** 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.
 */
94
void HTTPServerApp_Callback(void)
95
{
96
	uip_tcp_appstate_t* const AppState = &uip_conn->appstate;
97

98
	if (uip_aborted() || uip_timedout() || uip_closed())
99
	{
100
		/* Connection is being terminated for some reason - close file handle */
101
102
		f_close(&AppState->HTTPServer.FileHandle);
		AppState->HTTPServer.FileOpen = false;
103
104
		
		/* Lock to the closed state so that no further processing will occur on the connection */
105
106
		AppState->HTTPServer.CurrentState  = WEBSERVER_STATE_Closed;
		AppState->HTTPServer.NextState     = WEBSERVER_STATE_Closed;
107
	}
108
109

	if (uip_connected())
110
	{
111
		/* New connection - initialize connection state values */
112
113
114
115
116
		AppState->HTTPServer.CurrentState  = WEBSERVER_STATE_OpenRequestedFile;
		AppState->HTTPServer.NextState     = WEBSERVER_STATE_OpenRequestedFile;
		AppState->HTTPServer.FileOpen      = false;
		AppState->HTTPServer.ACKedFilePos  = 0;
		AppState->HTTPServer.SentChunkSize = 0;
117
	}
118
119

	if (uip_acked())
120
	{
121
		/* Add the amount of ACKed file data to the total sent file bytes counter */
122
		AppState->HTTPServer.ACKedFilePos += AppState->HTTPServer.SentChunkSize;
123
124

		/* Progress to the next state once the current state's data has been ACKed */
125
		AppState->HTTPServer.CurrentState = AppState->HTTPServer.NextState;
126
	}
127

128
	if (uip_rexmit() || uip_acked() || uip_newdata() || uip_connected() || uip_poll())
129
	{
130
		switch (AppState->HTTPServer.CurrentState)
131
132
		{
			case WEBSERVER_STATE_OpenRequestedFile:
133
				HTTPServerApp_OpenRequestedFile();
134
135
				break;
			case WEBSERVER_STATE_SendResponseHeader:
136
				HTTPServerApp_SendResponseHeader();
137
138
				break;
			case WEBSERVER_STATE_SendMIMETypeHeader:
139
				HTTPServerApp_SendMIMETypeHeader();	
140
141
				break;
			case WEBSERVER_STATE_SendData:
142
				HTTPServerApp_SendData();
143
144
145
				break;
			case WEBSERVER_STATE_Closing:
				uip_close();
146
				
147
				AppState->HTTPServer.NextState = WEBSERVER_STATE_Closed;
148
149
150
151
				break;
		}		  
	}		
}
152

153
154
155
/** 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.
 */
156
static void HTTPServerApp_OpenRequestedFile(void)
157
158
{
	uip_tcp_appstate_t* const AppState    = &uip_conn->appstate;
159
	char*               const AppData     = (char*)uip_appdata;
160
161
162
163
164
165
	
	/* No HTTP header received from the client, abort processing */
	if (!(uip_newdata()))
	  return;
	  
	char* RequestToken = strtok(AppData, " ");
166
			
167
168
169
170
171
172
	/* Must be a GET request, abort otherwise */
	if (strcmp(RequestToken, "GET") != 0)
	{
		uip_abort();
		return;
	}
173

174
175
176
177
	char* RequestedFileName = strtok(NULL, " ");
	
	/* If the requested filename has more that just the leading '/' path in it, copy it over */
	if (strlen(RequestedFileName) > 1)
178
	  strncpy(AppState->HTTPServer.FileName, &RequestedFileName[1], (sizeof(AppState->HTTPServer.FileName) - 1));
179
	else
180
	  strcpy(AppState->HTTPServer.FileName, "index.htm");
181

182
	/* Ensure filename is null-terminated */
183
	AppState->HTTPServer.FileName[(sizeof(AppState->HTTPServer.FileName) - 1)] = 0x00;
184
185
	
	/* Try to open the file from the Dataflash disk */
186
	AppState->HTTPServer.FileOpen     = (f_open(&AppState->HTTPServer.FileHandle, AppState->HTTPServer.FileName, FA_OPEN_EXISTING | FA_READ) == FR_OK);
187
188

	/* Lock to the SendResponseHeader state until connection terminated */
189
190
	AppState->HTTPServer.CurrentState = WEBSERVER_STATE_SendResponseHeader;
	AppState->HTTPServer.NextState    = WEBSERVER_STATE_SendResponseHeader;
191
192
193
194
195
}

/** 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.
 */
196
static void HTTPServerApp_SendResponseHeader(void)
197
198
{
	uip_tcp_appstate_t* const AppState    = &uip_conn->appstate;
199
	char*               const AppData     = (char*)uip_appdata;
200

201
	char* HeaderToSend;
202

203
	/* Determine which HTTP header should be sent to the client */
204
	if (AppState->HTTPServer.FileOpen)
205
206
	{
		HeaderToSend = HTTP200Header;
207
		AppState->HTTPServer.NextState = WEBSERVER_STATE_SendMIMETypeHeader;
208
209
210
211
	}
	else
	{
		HeaderToSend = HTTP404Header;
212
		AppState->HTTPServer.NextState = WEBSERVER_STATE_Closing;
213
214
	}

215
	/* Copy over the HTTP response header and send it to the receiving client */
216
217
	strcpy_P(AppData, HeaderToSend);
	uip_send(AppData, strlen(AppData));
218
219
220
221
222
}

/** 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.
 */
223
static void HTTPServerApp_SendMIMETypeHeader(void)
224
225
{
	uip_tcp_appstate_t* const AppState    = &uip_conn->appstate;
226
	char*               const AppData     = (char*)uip_appdata;
227

228
	char*    Extension        = strpbrk(AppState->HTTPServer.FileName, ".");
229
	uint16_t MIMEHeaderLength = 0;
230

231
232
233
234
235
236
237
	/* 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)
238
			{
239
240
241
				MIMEHeaderLength = strlen_P(MIMETypes[i].MIMEType);
				strncpy_P(AppData, MIMETypes[i].MIMEType, MIMEHeaderLength);						
				break;
242
			}
243
244
		} 
	}
245

246
247
248
249
250
251
	/* 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);
252
	}
253
254
255
256
257
258
259
260
261
	
	/* 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 */
262
	AppState->HTTPServer.NextState = WEBSERVER_STATE_SendData;
263
}
264

265
266
267
/** HTTP Server State handler for the Data Send state. This state manages the transmission of file chunks
 *  to the receiving HTTP client.
 */
268
static void HTTPServerApp_SendData(void)
269
270
{
	uip_tcp_appstate_t* const AppState    = &uip_conn->appstate;
271
	char*               const AppData     = (char*)uip_appdata;
272
273
274
275
276

	/* 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 */
277
	f_lseek(&AppState->HTTPServer.FileHandle, AppState->HTTPServer.ACKedFilePos);
278
279
	
	/* Read the next chunk of data from the open file */
280
	f_read(&AppState->HTTPServer.FileHandle, AppData, MaxSegmentSize, &AppState->HTTPServer.SentChunkSize);
281
282
	
	/* Send the next file chunk to the receiving client */
283
	uip_send(AppData, AppState->HTTPServer.SentChunkSize);
284
285
			
	/* Check if we are at the last chunk of the file, if so next ACK should close the connection */
286
	AppState->HTTPServer.NextState = (MaxSegmentSize != AppState->HTTPServer.SentChunkSize) ? WEBSERVER_STATE_Closing : WEBSERVER_STATE_SendData;
287
}