?lang_form? ?lang_select? ?lang_submit? ?lang_endform?
{HEADER END}
{BLAME START}

library

?curdirlinks? -

Blame information for rev 32

Line No. Rev Author Line
1 32 kaklik /*********************************************************************
2 *
3 * HyperText Transfer Protocol (HTTP) Server
4 * Module for Microchip TCP/IP Stack
5 * -Serves dynamic pages to web browsers such as Microsoft Internet
6 * Explorer, Mozilla Firefox, etc.
7 * -Reference: RFC 2068
8 *
9 **********************************************************************
10 * FileName: HTTP.c
11 * Dependencies: TCP, MPFS, HTTPGetVar() callback, HTTPExecCmd() callback
12 * Processor: PIC18, PIC24F, PIC24H, dsPIC30F, dsPIC33F, PIC32
13 * Compiler: Microchip C32 v1.05 or higher
14 * Microchip C30 v3.12 or higher
15 * Microchip C18 v3.30 or higher
16 * HI-TECH PICC-18 PRO 9.63PL2 or higher
17 * Company: Microchip Technology, Inc.
18 *
19 * Software License Agreement
20 *
21 * Copyright (C) 2002-2009 Microchip Technology Inc. All rights
22 * reserved.
23 *
24 * Microchip licenses to you the right to use, modify, copy, and
25 * distribute:
26 * (i) the Software when embedded on a Microchip microcontroller or
27 * digital signal controller product ("Device") which is
28 * integrated into Licensee's product; or
29 * (ii) ONLY the Software driver source files ENC28J60.c, ENC28J60.h,
30 * ENCX24J600.c and ENCX24J600.h ported to a non-Microchip device
31 * used in conjunction with a Microchip ethernet controller for
32 * the sole purpose of interfacing with the ethernet controller.
33 *
34 * You should refer to the license agreement accompanying this
35 * Software for additional information regarding your rights and
36 * obligations.
37 *
38 * THE SOFTWARE AND DOCUMENTATION ARE PROVIDED "AS IS" WITHOUT
39 * WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT
40 * LIMITATION, ANY WARRANTY OF MERCHANTABILITY, FITNESS FOR A
41 * PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT SHALL
42 * MICROCHIP BE LIABLE FOR ANY INCIDENTAL, SPECIAL, INDIRECT OR
43 * CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF
44 * PROCUREMENT OF SUBSTITUTE GOODS, TECHNOLOGY OR SERVICES, ANY CLAIMS
45 * BY THIRD PARTIES (INCLUDING BUT NOT LIMITED TO ANY DEFENSE
46 * THEREOF), ANY CLAIMS FOR INDEMNITY OR CONTRIBUTION, OR OTHER
47 * SIMILAR COSTS, WHETHER ASSERTED ON THE BASIS OF CONTRACT, TORT
48 * (INCLUDING NEGLIGENCE), BREACH OF WARRANTY, OR OTHERWISE.
49 *
50 *
51 * Author Date Comment
52 *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
53 * Nilesh Rajbharti 8/14/01 Original
54 * Nilesh Rajbharti 9/12/01 Released (Rev. 1.0)
55 * Nilesh Rajbharti 2/9/02 Cleanup
56 * Nilesh Rajbharti 5/22/02 Rev 2.0 (See version.log for detail)
57 * Nilesh Rajbharti 7/9/02 Rev 2.1 (Fixed HTTPParse bug)
58 * Howard Schlunder 2/9/05 Fixed variable substitution
59 * parsing (uses hex now)
60 ********************************************************************/
61 #define __HTTP_C
62  
63 #include "TCPIPConfig.h"
64  
65 #if defined(STACK_USE_HTTP_SERVER)
66  
67 #include "TCPIP Stack/TCPIP.h"
68 #include "ctype.h"
69  
70  
71 // Each dynamic variable within a CGI file should be preceeded with this character.
72 #define HTTP_VAR_ESC_CHAR '%'
73 #define HTTP_DYNAMIC_FILE_TYPE (HTTP_CGI)
74  
75 // HTTP File Types
76 #define HTTP_TXT (0u)
77 #define HTTP_HTML (1u)
78 #define HTTP_CGI (2u)
79 #define HTTP_XML (3u)
80 #define HTTP_GIF (4u)
81 #define HTTP_PNG (5u)
82 #define HTTP_JPG (6u)
83 #define HTTP_JAVA (7u)
84 #define HTTP_WAV (8u)
85 #define HTTP_UNKNOWN (9u)
86  
87  
88 #define FILE_EXT_LEN (3u)
89 typedef struct _FILE_TYPES
90 {
91 BYTE fileExt[FILE_EXT_LEN+1];
92 } FILE_TYPES;
93  
94 // Each entry in this structure must be in UPPER case.
95 // Order of these entries must match with those defined by "HTTP File Types" defines.
96 static ROM FILE_TYPES httpFiles[] =
97 {
98 { "TXT" }, // HTTP_TXT
99 { "HTM" }, // HTTP_HTML
100 { "CGI" }, // HTTP_CGI
101 { "XML" }, // HTTP_XML
102 { "GIF" }, // HTTP_GIF
103 { "PNG" }, // HTTP_PNG
104 { "JPG" }, // HTTP_JPG
105 { "CLA" }, // HTTP_JAVA
106 { "WAV" }, // HTTP_WAV
107 { "" } // HTTP_UNKNOWN
108 };
109 #define TOTAL_FILE_TYPES ( sizeof(httpFiles)/sizeof(httpFiles[0]) )
110  
111  
112 typedef struct
113 {
114 ROM BYTE typeString[20];
115 } HTTP_CONTENT;
116  
117 // Content entry order must match with those "HTTP File Types" define's.
118 static ROM HTTP_CONTENT httpContents[] =
119 {
120 { "text/plain" }, // HTTP_TXT
121 { "text/html" }, // HTTP_HTML
122 { "text/html" }, // HTTP_CGI
123 { "text/xml" }, // HTTP_XML
124 { "image/gif" }, // HTTP_GIF
125 { "image/png" }, // HTTP_PNG
126 { "image/jpeg" }, // HTTP_JPG
127 { "application/java-vm" }, // HTTP_JAVA
128 { "audio/x-wave" }, // HTTP_WAV
129 { "" } // HTTP_UNKNOWN
130 };
131 #define TOTAL_HTTP_CONTENTS ( sizeof(httpContents)/sizeof(httpConetents[0]) )
132  
133 // HTTP FSM states for each connection.
134 typedef enum
135 {
136 SM_HTTP_IDLE = 0u,
137 SM_HTTP_GET,
138 SM_HTTP_NOT_FOUND,
139 SM_HTTP_GET_READ,
140 SM_HTTP_GET_PASS,
141 SM_HTTP_GET_DLE,
142 SM_HTTP_GET_HANDLE,
143 SM_HTTP_GET_HANDLE_NEXT,
144 SM_HTTP_GET_VAR,
145 SM_HTTP_HEADER,
146 SM_HTTP_DISCARD
147 } SM_HTTP;
148  
149 // Supported HTTP Commands
150 typedef enum
151 {
152 HTTP_GET = 0u,
153 HTTP_POST,
154 HTTP_NOT_SUPPORTED,
155 HTTP_INVALID_COMMAND
156 } HTTP_COMMAND;
157  
158 // HTTP Connection Info - one for each connection.
159 typedef struct
160 {
161 TCP_SOCKET socket;
162 MPFS file;
163 SM_HTTP smHTTP;
164 BYTE smHTTPGet;
165 WORD VarRef;
166 BYTE bProcess;
167 BYTE Variable;
168 BYTE fileType;
169 } HTTP_INFO;
170 typedef BYTE HTTP_HANDLE;
171  
172  
173 typedef enum
174 {
175 HTTP_NOT_FOUND = 0u,
176 HTTP_NOT_AVAILABLE
177 } HTTP_MESSAGES;
178  
179 // Following message order must match with that of HTTP_MESSAGES enum.
180 static ROM BYTE * ROM HTTPMessages[] =
181 {
182 (ROM BYTE*)"HTTP/1.1 404 Not found\r\n\r\nNot found.\r\n",
183 (ROM BYTE*)"HTTP/1.1 503 \r\n\r\nService Unavailable\r\n"
184 };
185  
186 // Standard HTTP messages.
187 static ROM BYTE HTTP_OK_STRING[] = "HTTP/1.1 200 OK\r\nContent-type: ";
188 static ROM BYTE HTTP_OK_NO_CACHE_STRING[] = "HTTP/1.1 200 OK\r\nDate: Wed, 05 Apr 2006 02:53:05 GMT\r\nExpires: Wed, 05 Apr 2006 02:52:05 GMT\r\nCache-control: private\r\nContent-type: ";
189 #define HTTP_OK_STRING_LEN (sizeof(HTTP_OK_STRING)-1)
190 #define HTTP_OK_NO_CACHE_STRING_LEN (sizeof(HTTP_OK_NO_CACHE_STRING)-1)
191  
192 static ROM BYTE HTTP_HEADER_END_STRING[] = "\r\n\r\n";
193 #define HTTP_HEADER_END_STRING_LEN (sizeof(HTTP_HEADER_END_STRING)-1)
194  
195 // HTTP Command Strings
196 static ROM BYTE HTTP_GET_STRING[] = "GET";
197 #define HTTP_GET_STRING_LEN (sizeof(HTTP_GET_STRING)-1)
198  
199 // Default HTML file.
200 static ROM BYTE HTTP_DEFAULT_FILE_STRING[] = "INDEX.HTM";
201 #define HTTP_DEFAULT_FILE_STRING_LEN (sizeof(HTTP_DEFAULT_FILE_STRING)-1)
202  
203  
204 // Maximum nuber of arguments supported by this HTTP Server.
205 #define MAX_HTTP_ARGS (11u)
206  
207 // Maximum HTML Command String length.
208 #define MAX_HTML_CMD_LEN (100u)
209  
210  
211 static HTTP_INFO HCB[MAX_HTTP_CONNECTIONS];
212  
213  
214 static void HTTPProcess(HTTP_HANDLE h);
215 static HTTP_COMMAND HTTPParse(BYTE *string,
216 BYTE** arg,
217 BYTE* argc,
218 BYTE* type);
219 static BOOL SendFile(HTTP_INFO* ph);
220  
221  
222  
223  
224 /*********************************************************************
225 * Function: void HTTPInit(void)
226 *
227 * PreCondition: TCP must already be initialized.
228 *
229 * Input: None
230 *
231 * Output: HTTP FSM and connections are initialized
232 *
233 * Side Effects: None
234 *
235 * Overview: Set all HTTP connections to Listening state.
236 * Initialize FSM for each connection.
237 *
238 * Note: This function is called only one during lifetime
239 * of the application.
240 ********************************************************************/
241 void HTTPInit(void)
242 {
243 BYTE i;
244  
245 for ( i = 0; i < MAX_HTTP_CONNECTIONS; i++ )
246 {
247 HCB[i].socket = TCPOpen(0, TCP_OPEN_SERVER, HTTP_PORT, TCP_PURPOSE_HTTP_SERVER);
248  
249 HCB[i].smHTTP = SM_HTTP_IDLE;
250 }
251 }
252  
253  
254  
255 /*********************************************************************
256 * Function: void HTTPServer(void)
257 *
258 * PreCondition: HTTPInit() must already be called.
259 *
260 * Input: None
261 *
262 * Output: Opened HTTP connections are served.
263 *
264 * Side Effects: None
265 *
266 * Overview: Browse through each connections and let it
267 * handle its connection.
268 * If a connection is not finished, do not process
269 * next connections. This must be done, all
270 * connections use some static variables that are
271 * common.
272 *
273 * Note: This function acts as a task (similar to one in
274 * RTOS). This function performs its task in
275 * co-operative manner. Main application must call
276 * this function repeatdly to ensure all open
277 * or new connections are served on time.
278 ********************************************************************/
279 void HTTPServer(void)
280 {
281 BYTE conn;
282  
283 for ( conn = 0; conn < MAX_HTTP_CONNECTIONS; conn++ )
284 HTTPProcess(conn);
285 }
286  
287  
288 /*********************************************************************
289 * Function: static BOOL HTTPProcess(HTTP_HANDLE h)
290 *
291 * PreCondition: HTTPInit() called.
292 *
293 * Input: h - Index to the handle which needs to be
294 * processed.
295 *
296 * Output: Connection referred by 'h' is served.
297 *
298 * Side Effects: None
299 *
300 * Overview:
301 *
302 * Note: None.
303 ********************************************************************/
304 static void HTTPProcess(HTTP_HANDLE h)
305 {
306 BYTE httpData[MAX_HTML_CMD_LEN+1];
307 HTTP_COMMAND httpCommand;
308 BOOL lbContinue;
309 BYTE *arg[MAX_HTTP_ARGS];
310 BYTE argc;
311 HTTP_INFO* ph;
312 WORD w;
313  
314 ph = &HCB[h];
315  
316  
317 do
318 {
319 lbContinue = FALSE;
320  
321 // If during handling of HTTP socket, it gets disconnected,
322 // forget about previous processing and return to idle state.
323 if(!TCPIsConnected(ph->socket))
324 {
325 ph->smHTTP = SM_HTTP_IDLE;
326 break;
327 }
328  
329  
330 switch(ph->smHTTP)
331 {
332 case SM_HTTP_IDLE:
333 // Search for the CRLF deliminating the end of the first GET/HEAD/POST request
334 w = TCPFindROMArray(ph->socket, (ROM BYTE*)"\r\n", 2, 0, FALSE);
335 if(w == 0xFFFFu)
336 {
337 if(TCPGetRxFIFOFree(ph->socket) == 0u)
338 {
339 // Request is too big, we can't support it.
340 TCPDisconnect(ph->socket);
341 }
342 break;
343 }
344  
345 lbContinue = TRUE;
346  
347 if(w > sizeof(httpData)-1)
348 w = sizeof(httpData)-1;
349  
350 TCPGetArray(ph->socket, httpData, w);
351 httpData[w] = '\0';
352 TCPDiscard(ph->socket);
353  
354 ph->smHTTP = SM_HTTP_NOT_FOUND;
355 argc = MAX_HTTP_ARGS;
356 httpCommand = HTTPParse(httpData, arg, &argc, &ph->fileType);
357 if ( httpCommand == HTTP_GET )
358 {
359 // If there are any arguments, this must be a remote command.
360 // Execute it and then send the file.
361 // The file name may be modified by command handler.
362 if ( argc > 1u )
363 {
364 // Let main application handle this remote command.
365 HTTPExecCmd(&arg[0], argc);
366  
367 // Command handler must have modified arg[0] which now
368 // points to actual file that will be sent as a result of
369 // this remote command.
370  
371 // Assume that Web author will only use CGI or HTML
372 // file for remote command.
373 ph->fileType = HTTP_CGI;
374 }
375  
376 ph->file = MPFSOpen(arg[0]);
377 if ( ph->file == MPFS_INVALID )
378 {
379 ph->Variable = HTTP_NOT_FOUND;
380 ph->smHTTP = SM_HTTP_NOT_FOUND;
381 }
382 else if ( ph->file == MPFS_NOT_AVAILABLE )
383 {
384 ph->Variable = HTTP_NOT_AVAILABLE;
385 ph->smHTTP = SM_HTTP_NOT_FOUND;
386 }
387 else
388 {
389 ph->smHTTP = SM_HTTP_HEADER;
390 }
391 }
392 break;
393  
394 case SM_HTTP_NOT_FOUND:
395 if(TCPIsPutReady(ph->socket) >= strlenpgm((ROM char*)HTTPMessages[ph->Variable]))
396 {
397 TCPPutROMString(ph->socket, HTTPMessages[ph->Variable]);
398 TCPFlush(ph->socket);
399 TCPDisconnect(ph->socket);
400 ph->smHTTP = SM_HTTP_IDLE;
401 }
402 break;
403  
404 case SM_HTTP_HEADER:
405 if ( TCPIsPutReady(ph->socket) )
406 {
407 lbContinue = TRUE;
408  
409 if ( ph->fileType == HTTP_DYNAMIC_FILE_TYPE )
410 {
411 ph->bProcess = TRUE;
412 TCPPutROMArray(ph->socket, (ROM BYTE*)HTTP_OK_NO_CACHE_STRING, HTTP_OK_NO_CACHE_STRING_LEN);
413 }
414 else
415 {
416 ph->bProcess = FALSE;
417 TCPPutROMArray(ph->socket, (ROM BYTE*)HTTP_OK_STRING, HTTP_OK_STRING_LEN);
418 }
419  
420 TCPPutROMString(ph->socket, httpContents[ph->fileType].typeString);
421 TCPPutROMArray(ph->socket, (ROM BYTE*)HTTP_HEADER_END_STRING, HTTP_HEADER_END_STRING_LEN);
422  
423 ph->smHTTPGet = SM_HTTP_GET_READ;
424 ph->smHTTP = SM_HTTP_GET;
425 }
426 break;
427  
428 case SM_HTTP_GET:
429 // Throw away any more data receieved - we aren't going to use it.
430 TCPDiscard(ph->socket);
431  
432 if(SendFile(ph))
433 {
434 MPFSClose();
435 TCPDisconnect(ph->socket);
436 ph->smHTTP = SM_HTTP_IDLE;
437 }
438 break;
439  
440 default:
441 break;
442 }
443 } while( lbContinue );
444 }
445  
446  
447 /*********************************************************************
448 * Function: static BOOL SendFile(HTTP_INFO* ph)
449 *
450 * PreCondition: None
451 *
452 * Input: ph - A HTTP connection info.
453 *
454 * Output: File reference by this connection is served.
455 *
456 * Side Effects: None
457 *
458 * Overview: None
459 *
460 * Note: None.
461 ********************************************************************/
462 static BOOL SendFile(HTTP_INFO* ph)
463 {
464 BOOL lbTransmit;
465 BYTE c;
466 BYTE buffer[8];
467 WORD w;
468 WORD_VAL HexNumber;
469  
470 MPFSGetBegin(ph->file);
471  
472 // Check if file is dynamic (.cgi) -- need to look for and
473 // process escape sequences
474 if(ph->bProcess)
475 {
476 w = TCPIsPutReady(ph->socket);
477 while(w)
478 {
479 lbTransmit = FALSE;
480  
481 if(ph->smHTTPGet != (BYTE)SM_HTTP_GET_VAR)
482 {
483 c = MPFSGet();
484 if(MPFSIsEOF())
485 {
486 MPFSGetEnd();
487 TCPFlush(ph->socket);
488 return TRUE;
489 }
490 }
491  
492 switch(ph->smHTTPGet)
493 {
494 case SM_HTTP_GET_READ:
495 if ( c == HTTP_VAR_ESC_CHAR )
496 ph->smHTTPGet = SM_HTTP_GET_DLE;
497 else
498 lbTransmit = TRUE;
499 break;
500  
501 case SM_HTTP_GET_DLE:
502 if ( c == HTTP_VAR_ESC_CHAR )
503 {
504 lbTransmit = TRUE;
505 ph->smHTTPGet = SM_HTTP_GET_READ;
506 }
507 else
508 {
509 HexNumber.v[1] = c;
510 ph->smHTTPGet = SM_HTTP_GET_HANDLE;
511 }
512 break;
513  
514 case SM_HTTP_GET_HANDLE:
515 HexNumber.v[0] = c;
516 ph->Variable = hexatob(HexNumber);
517  
518 ph->smHTTPGet = SM_HTTP_GET_VAR;
519 ph->VarRef = HTTP_START_OF_VAR;
520 break;
521  
522 case SM_HTTP_GET_VAR:
523 ph->VarRef = HTTPGetVar(ph->Variable, ph->VarRef, &c);
524 lbTransmit = TRUE;
525 if ( ph->VarRef == HTTP_END_OF_VAR )
526 ph->smHTTPGet = SM_HTTP_GET_READ;
527 break;
528 }
529  
530 if(lbTransmit)
531 {
532 TCPPut(ph->socket, c);
533 w--;
534 }
535 }
536 }
537 else // Static page content -- no processing required
538 {
539 w = TCPIsPutReady(ph->socket);
540 while(w >= sizeof(buffer))
541 {
542 for(c = 0; c < sizeof(buffer); c++)
543 {
544 buffer[c] = MPFSGet();
545 if(MPFSIsEOF())
546 {
547 MPFSGetEnd();
548 TCPPutArray(ph->socket, buffer, c);
549 TCPFlush(ph->socket);
550 return TRUE;
551 }
552 }
553  
554 TCPPutArray(ph->socket, buffer, sizeof(buffer));
555 w -= sizeof(buffer);
556 lbTransmit = TRUE;
557 }
558 if(lbTransmit)
559 TCPFlush(ph->socket);
560 }
561 ph->file = MPFSGetEnd();
562  
563 // We are not done sending a file yet...
564 return FALSE;
565 }
566  
567  
568 /*********************************************************************
569 * Function: static HTTP_COMMAND HTTPParse(BYTE *string,
570 * BYTE** arg,
571 * BYTE* argc,
572 * BYTE* type)
573 *
574 * PreCondition: None
575 *
576 * Input: string - HTTP Command String
577 * arg - List of string pointer to hold
578 * HTTP arguments.
579 * argc - Pointer to hold total number of
580 * arguments in this command string/
581 * type - Pointer to hold type of file
582 * received.
583 * Valid values are:
584 * HTTP_TXT
585 * HTTP_HTML
586 * HTTP_GIF
587 * HTTP_CGI
588 * HTTP_UNKNOWN
589 *
590 * Output: HTTP FSM and connections are initialized
591 *
592 * Side Effects: None
593 *
594 * Overview: None
595 *
596 * Note: This function parses URL that may or may not
597 * contain arguments.
598 * e.g. "GET HTTP/1.0 thank.htm?name=MCHP&age=12"
599 * would be returned as below:
600 * arg[0] => GET
601 * arg[1] => thank.htm
602 * arg[2] => name
603 * arg[3] => MCHP
604 * arg[4] => 12
605 * argc = 5
606 *
607 * This parses does not "de-escape" URL string.
608 ********************************************************************/
609 static HTTP_COMMAND HTTPParse(BYTE *string,
610 BYTE** arg,
611 BYTE* argc,
612 BYTE* type)
613 {
614 BYTE i;
615 BYTE smParse;
616 HTTP_COMMAND cmd;
617 BYTE *ext;
618 BYTE c;
619 ROM BYTE *fileType;
620  
621 enum
622 {
623 SM_PARSE_IDLE,
624 SM_PARSE_ARG,
625 SM_PARSE_ARG_FORMAT
626 };
627  
628 smParse = SM_PARSE_IDLE;
629 ext = NULL;
630 i = 0;
631  
632 // Only "GET" is supported for time being.
633 if ( !memcmppgm2ram(string, (ROM void*) HTTP_GET_STRING, HTTP_GET_STRING_LEN) )
634 {
635 string += (HTTP_GET_STRING_LEN + 1);
636 cmd = HTTP_GET;
637 }
638 else
639 {
640 return HTTP_NOT_SUPPORTED;
641 }
642  
643 // Skip white spaces.
644 while( *string == ' ' )
645 string++;
646  
647 c = *string;
648  
649 while ( c != ' ' && c != '\0' && c != '\r' && c != '\n' )
650  
651 {
652 // Do not accept any more arguments than we haved designed to.
653 if ( i >= *argc )
654 break;
655  
656 switch(smParse)
657 {
658 case SM_PARSE_IDLE:
659 arg[i] = string;
660 c = *string;
661 if ( c == '/' || c == '\\' )
662 smParse = SM_PARSE_ARG;
663 break;
664  
665 case SM_PARSE_ARG:
666 arg[i++] = string;
667 smParse = SM_PARSE_ARG_FORMAT;
668 /*
669 * Do not break.
670 * Parameter may be empty.
671 */
672  
673 case SM_PARSE_ARG_FORMAT:
674 c = *string;
675 if ( c == '?' || c == '&' )
676 {
677 *string = '\0';
678 smParse = SM_PARSE_ARG;
679 }
680 else
681 {
682 // Recover space characters.
683 if ( c == '+' )
684 *string = ' ';
685  
686 // Remember where file extension starts.
687 else if ( c == '.' && i == 1u )
688 {
689 ext = ++string;
690 }
691  
692 else if ( c == '=' )
693 {
694 *string = '\0';
695 smParse = SM_PARSE_ARG;
696 }
697  
698 // Only interested in file name - not a path.
699 else if ( c == '/' || c == '\\' )
700 arg[i-1] = string+1;
701  
702 }
703 break;
704 }
705 string++;
706 c = *string;
707 }
708 *string = '\0';
709  
710 *type = HTTP_UNKNOWN;
711 if ( ext != NULL )
712 {
713 ext = (BYTE*)strupr((char*)ext);
714  
715 fileType = httpFiles[0].fileExt;
716 for ( c = 0; c < TOTAL_FILE_TYPES; c++ )
717 {
718 if ( !memcmppgm2ram((void*)ext, (ROM void*)fileType, FILE_EXT_LEN) )
719 {
720 *type = c;
721 break;
722 }
723 fileType += sizeof(FILE_TYPES);
724  
725 }
726 }
727  
728 if ( i == 0u )
729 {
730 memcpypgm2ram(arg[0], (ROM void*)HTTP_DEFAULT_FILE_STRING,
731 HTTP_DEFAULT_FILE_STRING_LEN);
732 arg[0][HTTP_DEFAULT_FILE_STRING_LEN] = '\0';
733 *type = HTTP_HTML;
734 i++;
735 }
736 *argc = i;
737  
738 return cmd;
739 }
740  
741  
742 #endif //#if defined(STACK_USE_HTTP_SERVER)
{BLAME END}
{FOOTER START}

Powered by WebSVN v2.8.3