1 /* This case tests basic post method. */
2 #include "tx_api.h"
3 #include "nx_api.h"
4 #include "fx_api.h"
5 #include "nxd_http_client.h"
6 #include "nxd_http_server.h"
7
8 extern void test_control_return(UINT);
9
10 #if !defined(NX_DISABLE_IPV4)
11
12 #define DEMO_STACK_SIZE 4096
13
14 /* This is a HTTP get packet captured by wireshark. POST AAAAAAAAAA*/
15 static char pkt[] = {
16 0x50, 0x4f, 0x53, 0x54, 0x20, 0x2f, 0x69, 0x6e, /* POST /in */
17 0x64, 0x65, 0x78, 0x2e, 0x68, 0x74, 0x6d, 0x20, /* dex.htm */
18 0x48, 0x54, 0x54, 0x50, 0x2f, 0x31, 0x2e, 0x31, /* HTTP/1.1 */
19 0x0d, 0x0a, 0x55, 0x73, 0x65, 0x72, 0x2d, 0x41, /* ..User-A */
20 0x67, 0x65, 0x6e, 0x74, 0x3a, 0x20, 0x63, 0x75, /* gent: cu */
21 0x72, 0x6c, 0x2f, 0x37, 0x2e, 0x33, 0x32, 0x2e, /* rl/7.32. */
22 0x30, 0x0d, 0x0a, 0x48, 0x6f, 0x73, 0x74, 0x3a, /* 0..Host: */
23 0x20, 0x31, 0x39, 0x32, 0x2e, 0x31, 0x36, 0x38, /* 192.168 */
24 0x2e, 0x30, 0x2e, 0x31, 0x32, 0x33, 0x0d, 0x0a, /* .0.123.. */
25 0x41, 0x63, 0x63, 0x65, 0x70, 0x74, 0x3a, 0x20, /* Accept: */
26 0x2a, 0x2f, 0x2a, 0x0d, 0x0a, 0x43, 0x6f, 0x6e, /* */
27 0x74, 0x65, 0x6e, 0x74, 0x2d, 0x4c, 0x65, 0x6e, /* tent-Len */
28 0x67, 0x74, 0x68, 0x3a, 0x20, 0x31, 0x30, 0x0d, /* gth: 10. */
29 0x0a, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, /* .Content */
30 0x2d, 0x54, 0x79, 0x70, 0x65, 0x3a, 0x20, 0x61, /* -Type: a */
31 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, /* pplicati */
32 0x6f, 0x6e, 0x2f, 0x78, 0x2d, 0x77, 0x77, 0x77, /* on/x-www */
33 0x2d, 0x66, 0x6f, 0x72, 0x6d, 0x2d, 0x75, 0x72, /* -form-ur */
34 0x6c, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, /* lencoded */
35 0x0d, 0x0a, 0x0d, 0x0a, 0x41, 0x41, 0x41, 0x41, /* ....AAAA */
36 0x41, 0x41, 0x41, 0x41, 0x41, 0x41 /* AAAAAA */
37 };
38
39
40 /* Set up FileX and file memory resources. */
41 static CHAR *ram_disk_memory;
42 static FX_MEDIA ram_disk;
43 static unsigned char media_memory[512];
44
45 /* Define device drivers. */
46 extern void _fx_ram_driver(FX_MEDIA *media_ptr);
47 extern void _nx_ram_network_driver_1024(NX_IP_DRIVER *driver_req_ptr);
48
49
50 /* Set up the HTTP client global variables. */
51
52 #define CLIENT_PACKET_SIZE (NX_HTTP_SERVER_MIN_PACKET_SIZE * 2)
53
54 static TX_THREAD client_thread;
55 static NX_PACKET_POOL client_pool;
56 static NX_HTTP_CLIENT my_client;
57 static NX_IP client_ip;
58 static UINT error_counter;
59
60 static NX_TCP_SOCKET client_socket;
61
62 /* Set up the HTTP server global variables */
63
64 #define SERVER_PACKET_SIZE (NX_HTTP_SERVER_MIN_PACKET_SIZE * 2)
65
66 static NX_HTTP_SERVER my_server;
67 static NX_PACKET_POOL server_pool;
68 static TX_THREAD server_thread;
69 static NX_IP server_ip;
70 #ifdef __PRODUCT_NETXDUO__
71 static NXD_ADDRESS server_ip_address;
72 #else
73 static ULONG server_ip_address;
74 #endif
75
76
77 static void thread_client_entry(ULONG thread_input);
78 static void thread_server_entry(ULONG thread_input);
79
80 #define HTTP_SERVER_ADDRESS IP_ADDRESS(192,168,0,105)
81 #define HTTP_CLIENT_ADDRESS IP_ADDRESS(192,168,0,123)
82
83 static UINT my_get_notify(NX_HTTP_SERVER *server_ptr, UINT request_type, CHAR *resource, NX_PACKET *packet_ptr);
84
85 #ifdef CTEST
test_application_define(void * first_unused_memory)86 VOID test_application_define(void *first_unused_memory)
87 #else
88 void netx_http_post_basic_test_application_define(void *first_unused_memory)
89 #endif
90 {
91
92 CHAR *pointer;
93 UINT status;
94
95 error_counter = 0;
96
97 /* Setup the working pointer. */
98 pointer = (CHAR *) first_unused_memory;
99
100 /* Create a helper thread for the server. */
101 tx_thread_create(&server_thread, "HTTP Server thread", thread_server_entry, 0,
102 pointer, DEMO_STACK_SIZE,
103 4, 4, TX_NO_TIME_SLICE, TX_AUTO_START);
104
105 pointer = pointer + DEMO_STACK_SIZE;
106
107 /* Initialize the NetX system. */
108 nx_system_initialize();
109
110 /* Create the server packet pool. */
111 status = nx_packet_pool_create(&server_pool, "HTTP Server Packet Pool", SERVER_PACKET_SIZE,
112 pointer, SERVER_PACKET_SIZE*8);
113 pointer = pointer + SERVER_PACKET_SIZE * 8;
114 if (status)
115 error_counter++;
116
117 /* Create an IP instance. */
118 status = nx_ip_create(&server_ip, "HTTP Server IP", HTTP_SERVER_ADDRESS,
119 0xFFFFFF00UL, &server_pool, _nx_ram_network_driver_1024,
120 pointer, 4096, 1);
121 pointer = pointer + 4096;
122 if (status)
123 error_counter++;
124
125 /* Enable ARP and supply ARP cache memory for the server IP instance. */
126 status = nx_arp_enable(&server_ip, (void *) pointer, 1024);
127 pointer = pointer + 1024;
128 if (status)
129 error_counter++;
130
131
132 /* Enable TCP traffic. */
133 status = nx_tcp_enable(&server_ip);
134 if (status)
135 error_counter++;
136
137 /* Set up the server's IPv4 address here. */
138 #ifdef __PRODUCT_NETXDUO__
139 server_ip_address.nxd_ip_address.v4 = HTTP_SERVER_ADDRESS;
140 server_ip_address.nxd_ip_version = NX_IP_VERSION_V4;
141 #else
142 server_ip_address = HTTP_SERVER_ADDRESS;
143 #endif
144
145 /* Create the HTTP Server. */
146 status = nx_http_server_create(&my_server, "My HTTP Server", &server_ip, &ram_disk,
147 pointer, 2048, &server_pool, NX_NULL, my_get_notify);
148 pointer = pointer + 2048;
149 if (status)
150 error_counter++;
151
152 /* Save the memory pointer for the RAM disk. */
153 ram_disk_memory = pointer;
154
155 /* Create the HTTP Client thread. */
156 status = tx_thread_create(&client_thread, "HTTP Client", thread_client_entry, 0,
157 pointer, DEMO_STACK_SIZE,
158 6, 6, TX_NO_TIME_SLICE, TX_AUTO_START);
159 pointer = pointer + DEMO_STACK_SIZE;
160 if (status)
161 error_counter++;
162
163 /* Create the Client packet pool. */
164 status = nx_packet_pool_create(&client_pool, "HTTP Client Packet Pool", CLIENT_PACKET_SIZE,
165 pointer, CLIENT_PACKET_SIZE*8);
166 pointer = pointer + CLIENT_PACKET_SIZE * 8;
167 if (status)
168 error_counter++;
169
170 /* Create an IP instance. */
171 status = nx_ip_create(&client_ip, "HTTP Client IP", HTTP_CLIENT_ADDRESS,
172 0xFFFFFF00UL, &client_pool, _nx_ram_network_driver_1024,
173 pointer, 2048, 1);
174 pointer = pointer + 2048;
175 if (status)
176 error_counter++;
177
178 status = nx_arp_enable(&client_ip, (void *) pointer, 1024);
179 pointer = pointer + 2048;
180 if (status)
181 error_counter++;
182
183 /* Enable TCP traffic. */
184 status = nx_tcp_enable(&client_ip);
185 if (status)
186 error_counter++;
187
188 }
189
190
thread_client_entry(ULONG thread_input)191 void thread_client_entry(ULONG thread_input)
192 {
193
194 UINT status;
195 NX_PACKET *send_packet;
196 NX_PACKET *recv_packet;
197 NX_PACKET *my_packet;
198 CHAR *buffer_ptr;
199
200 /* Format the RAM disk - the memory for the RAM disk was setup in
201 tx_application_define above. This must be set up before the client(s) start
202 sending requests. */
203 status = fx_media_format(&ram_disk,
204 _fx_ram_driver, /* Driver entry */
205 ram_disk_memory, /* RAM disk memory pointer */
206 media_memory, /* Media buffer pointer */
207 sizeof(media_memory), /* Media buffer size */
208 "MY_RAM_DISK", /* Volume Name */
209 1, /* Number of FATs */
210 32, /* Directory Entries */
211 0, /* Hidden sectors */
212 256, /* Total sectors */
213 128, /* Sector size */
214 1, /* Sectors per cluster */
215 1, /* Heads */
216 1); /* Sectors per track */
217
218 /* Check the media format status. */
219 if (status != FX_SUCCESS)
220 error_counter++;
221
222 /* Open the RAM disk. */
223 status = fx_media_open(&ram_disk, "RAM DISK", _fx_ram_driver, ram_disk_memory, media_memory, sizeof(media_memory));
224
225 /* Check the media open status. */
226 if (status != FX_SUCCESS)
227 error_counter++;
228
229 /* Create an HTTP client instance. */
230 status = nx_http_client_create(&my_client, "HTTP Client", &client_ip, &client_pool, 600);
231
232 /* Check status. */
233 if (status)
234 error_counter++;
235
236 #ifdef __PRODUCT_NETXDUO__
237
238 /* Now upload an HTML file to the HTTP IP server using the 'duo' service (supports IPv4 and IPv6). */
239 status = nxd_http_client_put_start(&my_client, &server_ip_address, "/index.htm",
240 "name", "password", 103, 5 * NX_IP_PERIODIC_RATE);
241 #else
242
243 /* Now upload an HTML file to the HTTP IP server using the 'NetX' service (supports only IPv4). */
244 status = nx_http_client_put_start(&my_client, HTTP_SERVER_ADDRESS, "/index.htm",
245 "name", "password", 103, 5 * NX_IP_PERIODIC_RATE);
246 #endif
247
248 /* Check status. */
249 if (status)
250 error_counter++;
251
252 /* Allocate a packet. */
253 status = nx_packet_allocate(&client_pool, &send_packet, NX_TCP_PACKET, NX_WAIT_FOREVER);
254
255 /* Check status. */
256 if(status)
257 error_counter++;
258
259 /* Build a simple 103-byte HTML page. */
260 nx_packet_data_append(send_packet, "<HTML>\r\n", 8,
261 &client_pool, NX_WAIT_FOREVER);
262 nx_packet_data_append(send_packet,
263 "<HEAD><TITLE>NetX HTTP Test</TITLE></HEAD>\r\n", 44,
264 &client_pool, NX_WAIT_FOREVER);
265 nx_packet_data_append(send_packet, "<BODY>\r\n", 8,
266 &client_pool, NX_WAIT_FOREVER);
267 nx_packet_data_append(send_packet, "<H1>Another NetX Test Page!</H1>\r\n", 25,
268 &client_pool, NX_WAIT_FOREVER);
269 nx_packet_data_append(send_packet, "</BODY>\r\n", 9,
270 &client_pool, NX_WAIT_FOREVER);
271 nx_packet_data_append(send_packet, "</HTML>\r\n", 9,
272 &client_pool, NX_WAIT_FOREVER);
273
274 /* Complete the PUT by writing the total length. */
275 status = nx_http_client_put_packet(&my_client, send_packet, 1 * NX_IP_PERIODIC_RATE);
276 if(status)
277 error_counter++;
278
279 /* Now GET the test file */
280
281 #ifdef __PRODUCT_NETXDUO__
282
283 /* Use the 'duo' service to send a GET request to the server (can use IPv4 or IPv6 addresses). */
284 status = nxd_http_client_get_start(&my_client, &server_ip_address,
285 "/index.htm", NX_NULL, 0, "name", "password", NX_IP_PERIODIC_RATE);
286 #else
287
288 /* Use the 'NetX' service to send a GET request to the server (can only use IPv4 addresses). */
289 status = nx_http_client_get_start(&my_client, HTTP_SERVER_ADDRESS, "/index.htm",
290 NX_NULL, 0, "name", "password", NX_IP_PERIODIC_RATE);
291 #endif /* USE_DUO */
292
293 if(status)
294 error_counter++;
295
296 while (1)
297 {
298 status = nx_http_client_get_packet(&my_client, &recv_packet, 1 * NX_IP_PERIODIC_RATE);
299
300 if (status == NX_HTTP_GET_DONE)
301 break;
302
303 if (status)
304 error_counter++;
305 else
306 nx_packet_release(recv_packet);
307 }
308
309 status = nx_http_client_delete(&my_client);
310 if(status)
311 error_counter++;
312
313 /* Create a socket. */
314 status = nx_tcp_socket_create(&client_ip, &client_socket, "Client Socket",
315 NX_IP_NORMAL, NX_FRAGMENT_OKAY, NX_IP_TIME_TO_LIVE, 1024,
316 NX_NULL, NX_NULL);
317 if(status)
318 error_counter++;
319
320 /* Bind the socket. */
321 status = nx_tcp_client_socket_bind(&client_socket, 50295, 1 * NX_IP_PERIODIC_RATE);
322 if(status)
323 error_counter++;
324
325 /* Call connect to send an SYN. */
326 status = nx_tcp_client_socket_connect(&client_socket, HTTP_SERVER_ADDRESS, 80, 2 * NX_IP_PERIODIC_RATE);
327 if(status)
328 error_counter++;
329
330 /* Allocate a packet. */
331 status = nx_packet_allocate(&client_pool, &my_packet, NX_TCP_PACKET, 1 * NX_IP_PERIODIC_RATE);
332 if(status)
333 error_counter++;
334
335 /* Write POST packet into the packet payload. */
336 status = nx_packet_data_append(my_packet, pkt, sizeof(pkt), &client_pool, 1 * NX_IP_PERIODIC_RATE);
337 if(status)
338 error_counter++;
339
340 /* Send the packet out. */
341 status = nx_tcp_socket_send(&client_socket, my_packet, 1 * NX_IP_PERIODIC_RATE);
342 if(status)
343 error_counter++;
344
345
346 /* Receive the response from http server. */
347 status = nx_tcp_socket_receive(&client_socket, &recv_packet, 1 * NX_IP_PERIODIC_RATE);
348 if(status)
349 error_counter++;
350 else
351 {
352 buffer_ptr = (CHAR *)recv_packet ->nx_packet_prepend_ptr;
353
354 /* Check the status, If success , it should be 200. */
355 if((buffer_ptr[9] != '2') || (buffer_ptr[10] != '0') || (buffer_ptr[11] != '0'))
356 error_counter++;
357
358 nx_packet_release(recv_packet);
359 }
360
361 tx_thread_sleep(1 * NX_IP_PERIODIC_RATE);
362
363 if(error_counter)
364 {
365 printf("ERROR!\n");
366 test_control_return(1);
367 }
368 else
369 {
370 printf("SUCCESS!\n");
371 test_control_return(0);
372 }
373
374 }
375
376
377 /* Define the helper HTTP server thread. */
thread_server_entry(ULONG thread_input)378 void thread_server_entry(ULONG thread_input)
379 {
380
381 UINT status;
382
383 /* Print out test information banner. */
384 printf("NetX Test: HTTP Post Basic Test......................................");
385
386 /* Check for earlier error. */
387 if(error_counter)
388 {
389 printf("ERROR!\n");
390 test_control_return(1);
391 }
392
393 /* OK to start the HTTP Server. */
394 status = nx_http_server_start(&my_server);
395 if(status)
396 error_counter++;
397
398 tx_thread_sleep(2 * NX_IP_PERIODIC_RATE);
399
400 status = nx_http_server_delete(&my_server);
401 if(status)
402 error_counter++;
403
404 }
405
406
407 /* Test extended functions. */
my_get_notify(NX_HTTP_SERVER * server_ptr,UINT request_type,CHAR * resource,NX_PACKET * packet_ptr)408 UINT my_get_notify(NX_HTTP_SERVER *server_ptr, UINT request_type, CHAR *resource, NX_PACKET *packet_ptr)
409 {
410
411 UINT status;
412 NX_PACKET *response_pkt;
413 UCHAR data[] = "hello";
414
415 /* Process multipart data. */
416 if (request_type == NX_HTTP_SERVER_GET_REQUEST)
417 {
418
419 /* Generate HTTP header. */
420 status = nx_http_server_callback_generate_response_header_extended(server_ptr, &response_pkt, NX_HTTP_STATUS_OK, sizeof(NX_HTTP_STATUS_OK) - 1, sizeof(data) - 1, "text/html", 9, "Server: NetXDuo HTTP 5.3\r\n", 26);
421 if (status == NX_SUCCESS)
422 {
423 if (nx_http_server_callback_packet_send(server_ptr, response_pkt))
424 nx_packet_release(response_pkt);
425 }
426 else
427 error_counter++;
428
429 status = nx_http_server_callback_data_send(server_ptr, data, sizeof(data) - 1);
430 if (status)
431 error_counter++;
432 }
433 else if (request_type == NX_HTTP_SERVER_POST_REQUEST)
434 {
435 status = nx_http_server_callback_response_send_extended(server_ptr, NX_HTTP_STATUS_OK, sizeof(NX_HTTP_STATUS_OK) - 1, "Server: NetXDuo HTTP 5.3\r\n", 26, NX_NULL, 0);
436 if (status)
437 error_counter++;
438 }
439 else
440 return NX_SUCCESS;
441
442 return(NX_HTTP_CALLBACK_COMPLETED);
443 }
444
445 #else
446
447 #ifdef CTEST
test_application_define(void * first_unused_memory)448 VOID test_application_define(void *first_unused_memory)
449 #else
450 void netx_http_post_basic_test_application_define(void *first_unused_memory)
451 #endif
452 {
453
454 /* Print out test information banner. */
455 printf("NetX Test: HTTP Post Basic Test......................................N/A\n");
456
457 test_control_return(3);
458 }
459 #endif
460
