-
Notifications
You must be signed in to change notification settings - Fork 1
/
Copy pathCustomHTTPApp.c
1949 lines (1640 loc) · 56.4 KB
/
CustomHTTPApp.c
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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/*********************************************************************
*
* Application to Demo HTTP2 Server
* Support for HTTP2 module in Microchip TCP/IP Stack
* -Implements the application
* -Reference: RFC 1002
*
*********************************************************************
* FileName: CustomHTTPApp.c
* Dependencies: TCP/IP stack
* Processor: PIC18, PIC24F, PIC24H, dsPIC30F, dsPIC33F, PIC32
* Compiler: Microchip C32 v1.05 or higher
* Microchip C30 v3.12 or higher
* Microchip C18 v3.30 or higher
* HI-TECH PICC-18 PRO 9.63PL2 or higher
* Company: Microchip Technology, Inc.
*
* Software License Agreement
*
* Copyright (C) 2002-2010 Microchip Technology Inc. All rights
* reserved.
*
* Microchip licenses to you the right to use, modify, copy, and
* distribute:
* (i) the Software when embedded on a Microchip microcontroller or
* digital signal controller product ("Device") which is
* integrated into Licensee's product; or
* (ii) ONLY the Software driver source files ENC28J60.c, ENC28J60.h,
* ENCX24J600.c and ENCX24J600.h ported to a non-Microchip device
* used in conjunction with a Microchip ethernet controller for
* the sole purpose of interfacing with the ethernet controller.
*
* You should refer to the license agreement accompanying this
* Software for additional information regarding your rights and
* obligations.
*
* THE SOFTWARE AND DOCUMENTATION ARE PROVIDED "AS IS" WITHOUT
* WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT
* LIMITATION, ANY WARRANTY OF MERCHANTABILITY, FITNESS FOR A
* PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT SHALL
* MICROCHIP BE LIABLE FOR ANY INCIDENTAL, SPECIAL, INDIRECT OR
* CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF
* PROCUREMENT OF SUBSTITUTE GOODS, TECHNOLOGY OR SERVICES, ANY CLAIMS
* BY THIRD PARTIES (INCLUDING BUT NOT LIMITED TO ANY DEFENSE
* THEREOF), ANY CLAIMS FOR INDEMNITY OR CONTRIBUTION, OR OTHER
* SIMILAR COSTS, WHETHER ASSERTED ON THE BASIS OF CONTRACT, TORT
* (INCLUDING NEGLIGENCE), BREACH OF WARRANTY, OR OTHERWISE.
*
*
* Author Date Comment
*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* Elliott Wood 6/18/07 Original
********************************************************************/
#define __CUSTOMHTTPAPP_C
#include "TCPIPConfig.h"
#if defined(STACK_USE_HTTP2_SERVER)
#include "TCPIP Stack/TCPIP.h"
#include "MainDemo.h" // Needed for SaveAppConfig() prototype
/****************************************************************************
Section:
Function Prototypes and Memory Globalizers
***************************************************************************/
#if defined(HTTP_USE_POST)
#if defined(USE_LCD)
static HTTP_IO_RESULT HTTPPostLCD(void);
#endif
#if defined(STACK_USE_HTTP_MD5_DEMO)
#if !defined(STACK_USE_MD5)
#error The HTTP_MD5_DEMO requires STACK_USE_MD5
#endif
static HTTP_IO_RESULT HTTPPostMD5(void);
#endif
#if defined(STACK_USE_HTTP_APP_RECONFIG)
extern APP_CONFIG AppConfig;
static HTTP_IO_RESULT HTTPPostConfig(void);
#if defined(STACK_USE_SNMP_SERVER)
static HTTP_IO_RESULT HTTPPostSNMPCommunity(void);
#endif
#endif
#if defined(STACK_USE_HTTP_EMAIL_DEMO) || defined(STACK_USE_SMTP_CLIENT)
#if !defined(STACK_USE_SMTP_CLIENT)
#error The HTTP_EMAIL_DEMO requires STACK_USE_SMTP_CLIENT
#endif
static HTTP_IO_RESULT HTTPPostEmail(void);
#endif
#if defined(STACK_USE_DYNAMICDNS_CLIENT)
static HTTP_IO_RESULT HTTPPostDDNSConfig(void);
#endif
#endif
// RAM allocated for DDNS parameters
#if defined(STACK_USE_DYNAMICDNS_CLIENT)
static BYTE DDNSData[100];
#endif
// Sticky status message variable.
// This is used to indicated whether or not the previous POST operation was
// successful. The application uses these to store status messages when a
// POST operation redirects. This lets the application provide status messages
// after a redirect, when connection instance data has already been lost.
static BOOL lastSuccess = FALSE;
// Stick status message variable. See lastSuccess for details.
static BOOL lastFailure = FALSE;
/****************************************************************************
Section:
Authorization Handlers
***************************************************************************/
/*****************************************************************************
Function:
BYTE HTTPNeedsAuth(BYTE* cFile)
Internal:
See documentation in the TCP/IP Stack API or HTTP2.h for details.
***************************************************************************/
#if defined(HTTP_USE_AUTHENTICATION)
BYTE HTTPNeedsAuth(BYTE* cFile)
{
// If the filename begins with the folder "protect", then require auth
if(memcmppgm2ram(cFile, (ROM void*)"protect", 7) == 0)
return 0x00; // Authentication will be needed later
// If the filename begins with the folder "snmp", then require auth
if(memcmppgm2ram(cFile, (ROM void*)"snmp", 4) == 0)
return 0x00; // Authentication will be needed later
#if defined(HTTP_MPFS_UPLOAD_REQUIRES_AUTH)
if(memcmppgm2ram(cFile, (ROM void*)"mpfsupload", 10) == 0)
return 0x00;
#endif
// You can match additional strings here to password protect other files.
// You could switch this and exclude files from authentication.
// You could also always return 0x00 to require auth for all files.
// You can return different values (0x00 to 0x79) to track "realms" for below.
return 0x80; // No authentication required
}
#endif
/*****************************************************************************
Function:
BYTE HTTPCheckAuth(BYTE* cUser, BYTE* cPass)
Internal:
See documentation in the TCP/IP Stack API or HTTP2.h for details.
***************************************************************************/
#if defined(HTTP_USE_AUTHENTICATION)
BYTE HTTPCheckAuth(BYTE* cUser, BYTE* cPass)
{
if(strcmppgm2ram((char *)cUser,(ROM char *)"admin") == 0
&& strcmppgm2ram((char *)cPass, (ROM char *)"microchip") == 0)
return 0x80; // We accept this combination
// You can add additional user/pass combos here.
// If you return specific "realm" values above, you can base this
// decision on what specific file or folder is being accessed.
// You could return different values (0x80 to 0xff) to indicate
// various users or groups, and base future processing decisions
// in HTTPExecuteGet/Post or HTTPPrint callbacks on this value.
return 0x00; // Provided user/pass is invalid
}
#endif
/****************************************************************************
Section:
GET Form Handlers
***************************************************************************/
/*****************************************************************************
Function:
HTTP_IO_RESULT HTTPExecuteGet(void)
Internal:
See documentation in the TCP/IP Stack API or HTTP2.h for details.
***************************************************************************/
HTTP_IO_RESULT HTTPExecuteGet(void)
{
BYTE *ptr;
BYTE filename[20];
// Load the file name
// Make sure BYTE filename[] above is large enough for your longest name
MPFSGetFilename(curHTTP.file, filename, 20);
// If its the forms.htm page
if(!memcmppgm2ram(filename, "forms.htm", 9))
{
// Seek out each of the four LED strings, and if it exists set the LED states
ptr = HTTPGetROMArg(curHTTP.data, (ROM BYTE *)"led4");
if(ptr)
LED4_IO = (*ptr == '1');
ptr = HTTPGetROMArg(curHTTP.data, (ROM BYTE *)"led3");
if(ptr)
LED3_IO = (*ptr == '1');
ptr = HTTPGetROMArg(curHTTP.data, (ROM BYTE *)"led2");
if(ptr)
LED2_IO = (*ptr == '1');
ptr = HTTPGetROMArg(curHTTP.data, (ROM BYTE *)"led1");
if(ptr)
LED1_IO = (*ptr == '1');
}
// If it's the LED updater file
else if(!memcmppgm2ram(filename, "cookies.htm", 11))
{
// This is very simple. The names and values we want are already in
// the data array. We just set the hasArgs value to indicate how many
// name/value pairs we want stored as cookies.
// To add the second cookie, just increment this value.
// remember to also add a dynamic variable callback to control the printout.
curHTTP.hasArgs = 0x01;
}
// If it's the LED updater file
else if(!memcmppgm2ram(filename, "leds.cgi", 8))
{
// Determine which LED to toggle
ptr = HTTPGetROMArg(curHTTP.data, (ROM BYTE *)"led");
// Toggle the specified LED
switch(*ptr) {
case '1':
LED1_IO ^= 1;
break;
case '2':
LED2_IO ^= 1;
break;
case '3':
LED3_IO ^= 1;
break;
case '4':
LED4_IO ^= 1;
break;
case '5':
LED5_IO ^= 1;
break;
case '6':
LED6_IO ^= 1;
break;
case '7':
LED7_IO ^= 1;
break;
}
}
return HTTP_IO_DONE;
}
/****************************************************************************
Section:
POST Form Handlers
***************************************************************************/
#if defined(HTTP_USE_POST)
/*****************************************************************************
Function:
HTTP_IO_RESULT HTTPExecutePost(void)
Internal:
See documentation in the TCP/IP Stack API or HTTP2.h for details.
***************************************************************************/
HTTP_IO_RESULT HTTPExecutePost(void)
{
// Resolve which function to use and pass along
BYTE filename[20];
// Load the file name
// Make sure BYTE filename[] above is large enough for your longest name
MPFSGetFilename(curHTTP.file, filename, sizeof(filename));
#if defined(USE_LCD)
if(!memcmppgm2ram(filename, "forms.htm", 9))
return HTTPPostLCD();
#endif
#if defined(STACK_USE_HTTP_MD5_DEMO)
if(!memcmppgm2ram(filename, "upload.htm", 10))
return HTTPPostMD5();
#endif
#if defined(STACK_USE_HTTP_APP_RECONFIG)
if(!memcmppgm2ram(filename, "protect/config.htm", 18))
return HTTPPostConfig();
#if defined(STACK_USE_SNMP_SERVER)
else if(!memcmppgm2ram(filename, "snmp/snmpconfig.htm", 19))
return HTTPPostSNMPCommunity();
#endif
#endif
#if defined(STACK_USE_SMTP_CLIENT)
if(!strcmppgm2ram((char*)filename, "email/index.htm"))
return HTTPPostEmail();
#endif
#if defined(STACK_USE_DYNAMICDNS_CLIENT)
if(!strcmppgm2ram((char*)filename, "dyndns/index.htm"))
return HTTPPostDDNSConfig();
#endif
return HTTP_IO_DONE;
}
/*****************************************************************************
Function:
static HTTP_IO_RESULT HTTPPostLCD(void)
Summary:
Processes the LCD form on forms.htm
Description:
Locates the 'lcd' parameter and uses it to update the text displayed
on the board's LCD display.
This function has four states. The first reads a name from the data
string returned as part of the POST request. If a name cannot
be found, it returns, asking for more data. Otherwise, if the name
is expected, it reads the associated value and writes it to the LCD.
If the name is not expected, the value is discarded and the next name
parameter is read.
In the case where the expected string is never found, this function
will eventually return HTTP_IO_NEED_DATA when no data is left. In that
case, the HTTP2 server will automatically trap the error and issue an
Internal Server Error to the browser.
Precondition:
None
Parameters:
None
Return Values:
HTTP_IO_DONE - the parameter has been found and saved
HTTP_IO_WAITING - the function is pausing to continue later
HTTP_IO_NEED_DATA - data needed by this function has not yet arrived
***************************************************************************/
#if defined(USE_LCD)
static HTTP_IO_RESULT HTTPPostLCD(void)
{
BYTE* cDest;
#define SM_POST_LCD_READ_NAME (0u)
#define SM_POST_LCD_READ_VALUE (1u)
switch(curHTTP.smPost)
{
// Find the name
case SM_POST_LCD_READ_NAME:
// Read a name
if(HTTPReadPostName(curHTTP.data, HTTP_MAX_DATA_LEN) == HTTP_READ_INCOMPLETE)
return HTTP_IO_NEED_DATA;
curHTTP.smPost = SM_POST_LCD_READ_VALUE;
// No break...continue reading value
// Found the value, so store the LCD and return
case SM_POST_LCD_READ_VALUE:
// If value is expected, read it to data buffer,
// otherwise ignore it (by reading to NULL)
if(!strcmppgm2ram((char*)curHTTP.data, (ROM char*)"lcd"))
cDest = curHTTP.data;
else
cDest = NULL;
// Read a value string
if(HTTPReadPostValue(cDest, HTTP_MAX_DATA_LEN) == HTTP_READ_INCOMPLETE)
return HTTP_IO_NEED_DATA;
// If this was an unexpected value, look for a new name
if(!cDest)
{
curHTTP.smPost = SM_POST_LCD_READ_NAME;
break;
}
// Copy up to 32 characters to the LCD
if(strlen((char*)cDest) < 32u)
{
memset(LCDText, ' ', 32);
strcpy((char*)LCDText, (char*)cDest);
}
else
{
memcpy(LCDText, (void *)cDest, 32);
}
LCDUpdate();
// This is the only expected value, so callback is done
strcpypgm2ram((char*)curHTTP.data, "/forms.htm");
curHTTP.httpStatus = HTTP_REDIRECT;
return HTTP_IO_DONE;
}
// Default assumes that we're returning for state machine convenience.
// Function will be called again later.
return HTTP_IO_WAITING;
}
#endif
/*****************************************************************************
Function:
static HTTP_IO_RESULT HTTPPostConfig(void)
Summary:
Processes the configuration form on config/index.htm
Description:
Accepts configuration parameters from the form, saves them to a
temporary location in RAM, then eventually saves the data to EEPROM or
external Flash.
When complete, this function redirects to config/reboot.htm, which will
display information on reconnecting to the board.
This function creates a shadow copy of the AppConfig structure in
RAM and then overwrites incoming data there as it arrives. For each
name/value pair, the name is first read to curHTTP.data[0:5]. Next, the
value is read to newAppConfig. Once all data has been read, the new
AppConfig is saved back to EEPROM and the browser is redirected to
reboot.htm. That file includes an AJAX call to reboot.cgi, which
performs the actual reboot of the machine.
If an IP address cannot be parsed, too much data is POSTed, or any other
parsing error occurs, the browser reloads config.htm and displays an error
message at the top.
Precondition:
None
Parameters:
None
Return Values:
HTTP_IO_DONE - all parameters have been processed
HTTP_IO_NEED_DATA - data needed by this function has not yet arrived
***************************************************************************/
#if defined(STACK_USE_HTTP_APP_RECONFIG)
static HTTP_IO_RESULT HTTPPostConfig(void)
{
APP_CONFIG newAppConfig;
BYTE *ptr;
BYTE i;
// Check to see if the browser is attempting to submit more data than we
// can parse at once. This function needs to receive all updated
// parameters and validate them all before committing them to memory so that
// orphaned configuration parameters do not get written (for example, if a
// static IP address is given, but the subnet mask fails parsing, we
// should not use the static IP address). Everything needs to be processed
// in a single transaction. If this is impossible, fail and notify the user.
// As a web devloper, if you add parameters to AppConfig and run into this
// problem, you could fix this by to splitting your update web page into two
// seperate web pages (causing two transactional writes). Alternatively,
// you could fix it by storing a static shadow copy of AppConfig someplace
// in memory and using it instead of newAppConfig. Lastly, you could
// increase the TCP RX FIFO size for the HTTP server. This will allow more
// data to be POSTed by the web browser before hitting this limit.
if(curHTTP.byteCount > TCPIsGetReady(sktHTTP) + TCPGetRxFIFOFree(sktHTTP))
goto ConfigFailure;
// Ensure that all data is waiting to be parsed. If not, keep waiting for
// all of it to arrive.
if(TCPIsGetReady(sktHTTP) < curHTTP.byteCount)
return HTTP_IO_NEED_DATA;
// Use current config in non-volatile memory as defaults
#if defined(EEPROM_CS_TRIS)
XEEReadArray(sizeof(NVM_VALIDATION_STRUCT), (BYTE*)&newAppConfig, sizeof(newAppConfig));
#elif defined(SPIFLASH_CS_TRIS)
SPIFlashReadArray(sizeof(NVM_VALIDATION_STRUCT), (BYTE*)&newAppConfig, sizeof(newAppConfig));
#endif
// Start out assuming that DHCP is disabled. This is necessary since the
// browser doesn't submit this field if it is unchecked (meaning zero).
// However, if it is checked, this will be overridden since it will be
// submitted.
newAppConfig.Flags.bIsDHCPEnabled = 0;
// Read all browser POST data
while(curHTTP.byteCount)
{
// Read a form field name
if(HTTPReadPostName(curHTTP.data, 6) != HTTP_READ_OK)
goto ConfigFailure;
// Read a form field value
if(HTTPReadPostValue(curHTTP.data + 6, sizeof(curHTTP.data)-6-2) != HTTP_READ_OK)
goto ConfigFailure;
// Parse the value that was read
if(!strcmppgm2ram((char*)curHTTP.data, (ROM char*)"ip"))
{// Read new static IP Address
if(!StringToIPAddress(curHTTP.data+6, &newAppConfig.MyIPAddr))
goto ConfigFailure;
newAppConfig.DefaultIPAddr.Val = newAppConfig.MyIPAddr.Val;
}
else if(!strcmppgm2ram((char*)curHTTP.data, (ROM char*)"gw"))
{// Read new gateway address
if(!StringToIPAddress(curHTTP.data+6, &newAppConfig.MyGateway))
goto ConfigFailure;
}
else if(!strcmppgm2ram((char*)curHTTP.data, (ROM char*)"sub"))
{// Read new static subnet
if(!StringToIPAddress(curHTTP.data+6, &newAppConfig.MyMask))
goto ConfigFailure;
newAppConfig.DefaultMask.Val = newAppConfig.MyMask.Val;
}
else if(!strcmppgm2ram((char*)curHTTP.data, (ROM char*)"dns1"))
{// Read new primary DNS server
if(!StringToIPAddress(curHTTP.data+6, &newAppConfig.PrimaryDNSServer))
goto ConfigFailure;
}
else if(!strcmppgm2ram((char*)curHTTP.data, (ROM char*)"dns2"))
{// Read new secondary DNS server
if(!StringToIPAddress(curHTTP.data+6, &newAppConfig.SecondaryDNSServer))
goto ConfigFailure;
}
else if(!strcmppgm2ram((char*)curHTTP.data, (ROM char*)"mac"))
{
// Read new MAC address
WORD w;
BYTE i;
ptr = curHTTP.data+6;
for(i = 0; i < 12u; i++)
{// Read the MAC address
// Skip non-hex bytes
while( *ptr != 0x00u && !(*ptr >= '0' && *ptr <= '9') && !(*ptr >= 'A' && *ptr <= 'F') && !(*ptr >= 'a' && *ptr <= 'f') )
ptr++;
// MAC string is over, so zeroize the rest
if(*ptr == 0x00u)
{
for(; i < 12u; i++)
curHTTP.data[i] = '0';
break;
}
// Save the MAC byte
curHTTP.data[i] = *ptr++;
}
// Read MAC Address, one byte at a time
for(i = 0; i < 6u; i++)
{
((BYTE*)&w)[1] = curHTTP.data[i*2];
((BYTE*)&w)[0] = curHTTP.data[i*2+1];
newAppConfig.MyMACAddr.v[i] = hexatob(*((WORD_VAL*)&w));
}
}
else if(!strcmppgm2ram((char*)curHTTP.data, (ROM char*)"host"))
{// Read new hostname
FormatNetBIOSName(&curHTTP.data[6]);
memcpy((void*)newAppConfig.NetBIOSName, (void*)curHTTP.data+6, 16);
}
else if(!strcmppgm2ram((char*)curHTTP.data, (ROM char*)"dhcp"))
{// Read new DHCP Enabled flag
if(curHTTP.data[6] == '1')
newAppConfig.Flags.bIsDHCPEnabled = 1;
}
}
// All parsing complete! Save new settings and force a reboot
SaveAppConfig(&newAppConfig);
// Set the board to reboot and display reconnecting information
strcpypgm2ram((char*)curHTTP.data, "/protect/reboot.htm?");
memcpy((void*)(curHTTP.data+20), (void*)newAppConfig.NetBIOSName, 16);
curHTTP.data[20+16] = 0x00; // Force null termination
for(i = 20; i < 20u+16u; i++)
{
if(curHTTP.data[i] == ' ')
curHTTP.data[i] = 0x00;
}
curHTTP.httpStatus = HTTP_REDIRECT;
return HTTP_IO_DONE;
ConfigFailure:
lastFailure = TRUE;
strcpypgm2ram((char*)curHTTP.data, "/protect/config.htm");
curHTTP.httpStatus = HTTP_REDIRECT;
return HTTP_IO_DONE;
}
#if defined(STACK_USE_SNMP_SERVER)
static HTTP_IO_RESULT HTTPPostSNMPCommunity(void)
{
BYTE vCommunityIndex;
BYTE *dest;
#define SM_CFG_SNMP_READ_NAME (0u)
#define SM_CFG_SNMP_READ_VALUE (1u)
switch(curHTTP.smPost)
{
case SM_CFG_SNMP_READ_NAME:
// If all parameters have been read, end
if(curHTTP.byteCount == 0)
{
SaveAppConfig(&AppConfig);
return HTTP_IO_DONE;
}
// Read a name
if(HTTPReadPostName(curHTTP.data, sizeof(curHTTP.data)-2) == HTTP_READ_INCOMPLETE)
return HTTP_IO_NEED_DATA;
// Move to reading a value, but no break
curHTTP.smPost = SM_CFG_SNMP_READ_VALUE;
case SM_CFG_SNMP_READ_VALUE:
// Read a value
if(HTTPReadPostValue(curHTTP.data + 6, sizeof(curHTTP.data)-6-2) == HTTP_READ_INCOMPLETE)
return HTTP_IO_NEED_DATA;
// Default action after this is to read the next name, unless there's an error
curHTTP.smPost = SM_CFG_SNMP_READ_NAME;
// See if this is a known parameter and legal (must be null
// terminator in 4th field name byte, string must no greater than
// SNMP_COMMUNITY_MAX_LEN bytes long, and SNMP_MAX_COMMUNITY_SUPPORT
// must not be violated.
vCommunityIndex = curHTTP.data[3] - '0';
if(vCommunityIndex >= SNMP_MAX_COMMUNITY_SUPPORT)
break;
if(curHTTP.data[4] != 0x00u)
break;
if(memcmppgm2ram((void*)curHTTP.data, (ROM void*)"rcm", 3) == 0)
dest = AppConfig.readCommunity[vCommunityIndex];
else if(memcmppgm2ram((void*)curHTTP.data, (ROM void*)"wcm", 3) == 0)
dest = AppConfig.writeCommunity[vCommunityIndex];
else
break;
if(strlen((char*)curHTTP.data + 6) > SNMP_COMMUNITY_MAX_LEN)
break;
// String seems valid, lets copy it to AppConfig
strcpy((char*)dest, (char*)curHTTP.data+6);
break;
}
return HTTP_IO_WAITING; // Assume we're waiting to process more data
}
#endif //#if defined(STACK_USE_SNMP_SERVER)
#endif // #if defined(STACK_USE_HTTP_APP_RECONFIG)
/*****************************************************************************
Function:
static HTTP_IO_RESULT HTTPPostMD5(void)
Summary:
Processes the file upload form on upload.htm
Description:
This function demonstrates the processing of file uploads. First, the
function locates the file data, skipping over any headers that arrive.
Second, it reads the file 64 bytes at a time and hashes that data. Once
all data has been received, the function calculates the MD5 sum and
stores it in curHTTP.data.
After the headers, the first line from the form will be the MIME
separator. Following that is more headers about the file, which we
discard. After another CRLFCRLF, the file data begins, and we read
it 16 bytes at a time and add that to the MD5 calculation. The reading
terminates when the separator string is encountered again on its own
line. Notice that the actual file data is trashed in this process,
allowing us to accept files of arbitrary size, not limited by RAM.
Also notice that the data buffer is used as an arbitrary storage array
for the result. The ~uploadedmd5~ callback reads this data later to
send back to the client.
Precondition:
None
Parameters:
None
Return Values:
HTTP_IO_DONE - all parameters have been processed
HTTP_IO_WAITING - the function is pausing to continue later
HTTP_IO_NEED_DATA - data needed by this function has not yet arrived
***************************************************************************/
#if defined(STACK_USE_HTTP_MD5_DEMO)
static HTTP_IO_RESULT HTTPPostMD5(void)
{
WORD lenA, lenB;
static HASH_SUM md5; // Assume only one simultaneous MD5
#define SM_MD5_READ_SEPARATOR (0u)
#define SM_MD5_SKIP_TO_DATA (1u)
#define SM_MD5_READ_DATA (2u)
#define SM_MD5_POST_COMPLETE (3u)
// Don't care about curHTTP.data at this point, so use that for buffer
switch(curHTTP.smPost)
{
// Just started, so try to find the separator string
case SM_MD5_READ_SEPARATOR:
// Reset the MD5 calculation
MD5Initialize(&md5);
// See if a CRLF is in the buffer
lenA = TCPFindROMArray(sktHTTP, (ROM BYTE*)"\r\n", 2, 0, FALSE);
if(lenA == 0xffff)
{//if not, ask for more data
return HTTP_IO_NEED_DATA;
}
// If so, figure out where the last byte of data is
// Data ends at CRLFseparator--CRLF, so 6+len bytes
curHTTP.byteCount -= lenA + 6;
// Read past the CRLF
curHTTP.byteCount -= TCPGetArray(sktHTTP, NULL, lenA+2);
// Save the next state (skip to CRLFCRLF)
curHTTP.smPost = SM_MD5_SKIP_TO_DATA;
// No break...continue reading the headers if possible
// Skip the headers
case SM_MD5_SKIP_TO_DATA:
// Look for the CRLFCRLF
lenA = TCPFindROMArray(sktHTTP, (ROM BYTE*)"\r\n\r\n", 4, 0, FALSE);
if(lenA != 0xffff)
{// Found it, so remove all data up to and including
lenA = TCPGetArray(sktHTTP, NULL, lenA+4);
curHTTP.byteCount -= lenA;
curHTTP.smPost = SM_MD5_READ_DATA;
}
else
{// Otherwise, remove as much as possible
lenA = TCPGetArray(sktHTTP, NULL, TCPIsGetReady(sktHTTP) - 4);
curHTTP.byteCount -= lenA;
// Return the need more data flag
return HTTP_IO_NEED_DATA;
}
// No break if we found the header terminator
// Read and hash file data
case SM_MD5_READ_DATA:
// Find out how many bytes are available to be read
lenA = TCPIsGetReady(sktHTTP);
if(lenA > curHTTP.byteCount)
lenA = curHTTP.byteCount;
while(lenA > 0u)
{// Add up to 64 bytes at a time to the sum
lenB = TCPGetArray(sktHTTP, curHTTP.data, (lenA < 64u)?lenA:64);
curHTTP.byteCount -= lenB;
lenA -= lenB;
MD5AddData(&md5, curHTTP.data, lenB);
}
// If we've read all the data
if(curHTTP.byteCount == 0u)
{// Calculate and copy result to curHTTP.data for printout
curHTTP.smPost = SM_MD5_POST_COMPLETE;
MD5Calculate(&md5, curHTTP.data);
return HTTP_IO_DONE;
}
// Ask for more data
return HTTP_IO_NEED_DATA;
}
return HTTP_IO_DONE;
}
#endif // #if defined(STACK_USE_HTTP_MD5_DEMO)
/*****************************************************************************
Function:
static HTTP_IO_RESULT HTTPPostEmail(void)
Summary:
Processes the e-mail form on email/index.htm
Description:
This function sends an e-mail message using the SMTP client and
optionally encrypts the connection to the SMTP server using SSL. It
demonstrates the use of the SMTP client, waiting for asynchronous
processes in an HTTP callback, and how to send e-mail attachments using
the stack.
Messages with attachments are sent using multipart/mixed MIME encoding,
which has three sections. The first has no headers, and is only to be
displayed by old clients that cannot interpret the MIME format. (The
overwhelming majority of these clients have been obseleted, but the
so-called "ignored" section is still used.) The second has a few
headers to indicate that it is the main body of the message in plain-
text encoding. The third section has headers indicating an attached
file, along with its name and type. All sections are separated by a
boundary string, which cannot appear anywhere else in the message.
Precondition:
None
Parameters:
None
Return Values:
HTTP_IO_DONE - the message has been sent
HTTP_IO_WAITING - the function is waiting for the SMTP process to complete
HTTP_IO_NEED_DATA - data needed by this function has not yet arrived
***************************************************************************/
#if defined(STACK_USE_SMTP_CLIENT)
static HTTP_IO_RESULT HTTPPostEmail(void)
{
static BYTE *ptrData;
static BYTE *szPort;
#if defined(STACK_USE_SSL_CLIENT)
static BYTE *szUseSSL;
#endif
WORD len, rem;
BYTE cName[8];
#define SM_EMAIL_CLAIM_MODULE (0u)
#define SM_EMAIL_READ_PARAM_NAME (1u)
#define SM_EMAIL_READ_PARAM_VALUE (2u)
#define SM_EMAIL_PUT_IGNORED (3u)
#define SM_EMAIL_PUT_BODY (4u)
#define SM_EMAIL_PUT_ATTACHMENT_HEADER (5u)
#define SM_EMAIL_PUT_ATTACHMENT_DATA_BTNS (6u)
#define SM_EMAIL_PUT_ATTACHMENT_DATA_LEDS (7u)
#define SM_EMAIL_PUT_ATTACHMENT_DATA_POT (8u)
#define SM_EMAIL_PUT_TERMINATOR (9u)
#define SM_EMAIL_FINISHING (10u)
#define EMAIL_SPACE_REMAINING (HTTP_MAX_DATA_LEN - (ptrData - curHTTP.data))
switch(curHTTP.smPost)
{
case SM_EMAIL_CLAIM_MODULE:
// Try to claim module
if(SMTPBeginUsage())
{// Module was claimed, so set up static parameters
SMTPClient.Subject.szROM = (ROM BYTE*)"Microchip TCP/IP Stack Status Update";
SMTPClient.ROMPointers.Subject = 1;
SMTPClient.From.szROM = (ROM BYTE*)"\"SMTP Service\" <[email protected]>";
SMTPClient.ROMPointers.From = 1;
// The following two lines indicate to the receiving client that
// this message has an attachment. The boundary field *must not*
// be included anywhere in the content of the message. In real
// applications it is typically a long random string.
SMTPClient.OtherHeaders.szROM = (ROM BYTE*)"MIME-version: 1.0\r\nContent-type: multipart/mixed; boundary=\"frontier\"\r\n";
SMTPClient.ROMPointers.OtherHeaders = 1;
// Move our state machine forward
ptrData = curHTTP.data;
szPort = NULL;
curHTTP.smPost = SM_EMAIL_READ_PARAM_NAME;
}
return HTTP_IO_WAITING;
case SM_EMAIL_READ_PARAM_NAME:
// Search for a parameter name in POST data
if(HTTPReadPostName(cName, sizeof(cName)) == HTTP_READ_INCOMPLETE)
return HTTP_IO_NEED_DATA;
// Try to match the name value
if(!strcmppgm2ram((char*)cName, (ROM char*)"server"))
{// Read the server name
SMTPClient.Server.szRAM = ptrData;
curHTTP.smPost = SM_EMAIL_READ_PARAM_VALUE;
}
else if(!strcmppgm2ram((char*)cName, (ROM char*)"port"))
{// Read the server port
szPort = ptrData;
curHTTP.smPost = SM_EMAIL_READ_PARAM_VALUE;
}
#if defined(STACK_USE_SSL_CLIENT)
else if(!strcmppgm2ram((char*)cName, (ROM char*)"ssl"))
{// Read the server port
szUseSSL = ptrData;
curHTTP.smPost = SM_EMAIL_READ_PARAM_VALUE;
}
#endif
else if(!strcmppgm2ram((char*)cName, (ROM char*)"user"))
{// Read the user name
SMTPClient.Username.szRAM = ptrData;
curHTTP.smPost = SM_EMAIL_READ_PARAM_VALUE;
}
else if(!strcmppgm2ram((char*)cName, (ROM char*)"pass"))
{// Read the password
SMTPClient.Password.szRAM = ptrData;
curHTTP.smPost = SM_EMAIL_READ_PARAM_VALUE;
}
else if(!strcmppgm2ram((char*)cName, (ROM char*)"to"))
{// Read the To string
SMTPClient.To.szRAM = ptrData;
curHTTP.smPost = SM_EMAIL_READ_PARAM_VALUE;
}
else if(!strcmppgm2ram((char*)cName, (ROM char*)"msg"))
{// Done with headers, move on to the message
// Delete paramters that are just null strings (no data from user) or illegal (ex: password without username)
if(SMTPClient.Server.szRAM)
if(*SMTPClient.Server.szRAM == 0x00u)
SMTPClient.Server.szRAM = NULL;
if(SMTPClient.Username.szRAM)
if(*SMTPClient.Username.szRAM == 0x00u)
SMTPClient.Username.szRAM = NULL;
if(SMTPClient.Password.szRAM)
if((*SMTPClient.Password.szRAM == 0x00u) || (SMTPClient.Username.szRAM == NULL))
SMTPClient.Password.szRAM = NULL;
// Decode server port string if it exists
if(szPort)
if(*szPort)
SMTPClient.ServerPort = (WORD)atol((char*)szPort);
// Determine if SSL should be used
#if defined(STACK_USE_SSL_CLIENT)
if(szUseSSL)
if(*szUseSSL == '1')
SMTPClient.UseSSL = TRUE;
#endif
// Start sending the message
SMTPSendMail();
curHTTP.smPost = SM_EMAIL_PUT_IGNORED;
return HTTP_IO_WAITING;
}
else
{// Don't know what we're receiving
curHTTP.smPost = SM_EMAIL_READ_PARAM_VALUE;
}
// No break...continue to try reading the value
case SM_EMAIL_READ_PARAM_VALUE:
// Search for a parameter value in POST data
if(HTTPReadPostValue(ptrData, EMAIL_SPACE_REMAINING) == HTTP_READ_INCOMPLETE)
return HTTP_IO_NEED_DATA;
// Move past the data that was just read
ptrData += strlen((char*)ptrData);
if(ptrData < curHTTP.data + HTTP_MAX_DATA_LEN - 1)
ptrData += 1;
// Try reading the next parameter
curHTTP.smPost = SM_EMAIL_READ_PARAM_NAME;
return HTTP_IO_WAITING;
case SM_EMAIL_PUT_IGNORED:
// This section puts a message that is ignored by compatible clients.
// This text will not display unless the receiving client is obselete
// and does not understand the MIME structure.
// The "--frontier" indicates the start of a section, then any
// needed MIME headers follow, then two CRLF pairs, and then
// the actual content (which will be the body text in the next state).
// Check to see if a failure occured
if(!SMTPIsBusy())
{
curHTTP.smPost = SM_EMAIL_FINISHING;
return HTTP_IO_WAITING;
}
// See if we're ready to write data
if(SMTPIsPutReady() < 90u)
return HTTP_IO_WAITING;