1 /* This case tests basic POST method. */
2 #include "tx_api.h"
3 #include "nx_api.h"
4 #include "fx_api.h"
5 #include "nx_web_http_client.h"
6 #include "nx_web_http_server.h"
7
8 extern void test_control_return(UINT);
9
10 #if !defined(NX_DISABLE_IPV4) && !defined(NX_DISABLE_PACKET_CHAIN)
11
12 #include "test_device_cert.c"
13 #include "test_ca_cert.c"
14 #define ca_cert_der test_ca_cert_der
15 #define ca_cert_der_len test_ca_cert_der_len
16
17 #define DEMO_STACK_SIZE 4096
18
19 /* Set up FileX and file memory resources. */
20 static CHAR ram_disk_memory[4096];
21 static FX_MEDIA ram_disk;
22 static UCHAR media_memory[4096];
23
24 static UCHAR server_stack[16000];
25
26 /* Define device drivers. */
27 extern void _fx_ram_driver(FX_MEDIA *media_ptr);
28 extern void _nx_ram_network_driver_1024(NX_IP_DRIVER *driver_req_ptr);
29
30 /* Set up the HTTP client global variables. */
31
32 #define CLIENT_PACKET_SIZE (NX_WEB_HTTP_SERVER_MIN_PACKET_SIZE * 2)
33
34 static TX_THREAD client_thread;
35 static NX_PACKET_POOL client_pool;
36 static NX_WEB_HTTP_CLIENT my_client;
37 static NX_IP client_ip;
38 static UINT error_counter;
39
40 /* Set up the HTTP server global variables */
41
42 #define SERVER_PACKET_SIZE (NX_WEB_HTTP_CLIENT_MIN_PACKET_SIZE * 2)
43
44 static NX_WEB_HTTP_SERVER my_server;
45 static NX_PACKET_POOL server_pool;
46 static TX_THREAD server_thread;
47 static NX_IP server_ip;
48 static NXD_ADDRESS server_ip_address;
49 static UINT http_server_start = 0;
50 static UINT http_client_stop = 0;
51
52 static void thread_client_entry(ULONG thread_input);
53 static void thread_server_entry(ULONG thread_input);
54
55 #define HTTP_SERVER_ADDRESS IP_ADDRESS(1,2,3,4)
56 #define HTTP_CLIENT_ADDRESS IP_ADDRESS(1,2,3,5)
57
58 #define MESSAGE_LENGTH (4 * 1024)
59 /* POST AAAAAAAAAA*/
60 static char pkt[] = {
61 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
62 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
63 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
64 'Y', 'Z', '0', '1', '2', '3', '4', '5',
65 };
66
67 static UCHAR server_pool_area[SERVER_PACKET_SIZE * 16];
68 static UCHAR client_pool_area[SERVER_PACKET_SIZE * 16];
69
70 static UINT server_request_callback(NX_WEB_HTTP_SERVER *server_ptr, UINT request_type, CHAR *resource, NX_PACKET *packet_ptr);
71
72 #ifdef CTEST
test_application_define(void * first_unused_memory)73 VOID test_application_define(void *first_unused_memory)
74 #else
75 void netx_web_post_large_packet_test_application_define(void *first_unused_memory)
76 #endif
77 {
78 CHAR *pointer;
79 UINT status;
80
81
82 error_counter = 0;
83
84 /* Setup the working pointer. */
85 pointer = (CHAR *) first_unused_memory;
86
87 /* Create a helper thread for the server. */
88 tx_thread_create(&server_thread, "HTTP Server thread", thread_server_entry, 0,
89 pointer, DEMO_STACK_SIZE,
90 NX_WEB_HTTP_SERVER_PRIORITY, NX_WEB_HTTP_SERVER_PRIORITY, TX_NO_TIME_SLICE, TX_AUTO_START);
91
92 pointer = pointer + DEMO_STACK_SIZE;
93
94 /* Initialize the NetX system. */
95 nx_system_initialize();
96
97 /* Create the server packet pool. */
98 status = nx_packet_pool_create(&server_pool, "HTTP Server Packet Pool", SERVER_PACKET_SIZE,
99 server_pool_area, sizeof(server_pool_area));
100 if (status)
101 error_counter++;
102
103 /* Create an IP instance. */
104 status = nx_ip_create(&server_ip, "HTTP Server IP", HTTP_SERVER_ADDRESS,
105 0xFFFFFF00UL, &server_pool, _nx_ram_network_driver_1024,
106 pointer, 4096, 1);
107 pointer = pointer + 4096;
108 if (status)
109 error_counter++;
110
111 /* Enable ARP and supply ARP cache memory for the server IP instance. */
112 status = nx_arp_enable(&server_ip, (void *) pointer, 1024);
113 pointer = pointer + 1024;
114 if (status)
115 error_counter++;
116
117 /* Enable TCP traffic. */
118 status = nx_tcp_enable(&server_ip);
119 if (status)
120 error_counter++;
121
122 /* Create the HTTP Client thread. */
123 status = tx_thread_create(&client_thread, "HTTP Client", thread_client_entry, 0,
124 pointer, DEMO_STACK_SIZE,
125 NX_WEB_HTTP_SERVER_PRIORITY + 2, NX_WEB_HTTP_SERVER_PRIORITY + 2, TX_NO_TIME_SLICE, TX_AUTO_START);
126 pointer = pointer + DEMO_STACK_SIZE;
127 if (status)
128 error_counter++;
129
130 /* Create the server packet pool. */
131 status = nx_packet_pool_create(&client_pool, "HTTP Server Packet Pool", SERVER_PACKET_SIZE,
132 client_pool_area, sizeof(client_pool_area));
133 if (status)
134 error_counter++;
135
136 /* Create an IP instance. */
137 status = nx_ip_create(&client_ip, "HTTP Client IP", HTTP_CLIENT_ADDRESS,
138 0xFFFFFF00UL, &client_pool, _nx_ram_network_driver_1024,
139 pointer, 2048, 1);
140 pointer = pointer + 2048;
141 if (status)
142 error_counter++;
143
144 status = nx_arp_enable(&client_ip, (void *) pointer, 1024);
145 pointer = pointer + 2048;
146 if (status)
147 error_counter++;
148
149 /* Enable TCP traffic. */
150 status = nx_tcp_enable(&client_ip);
151 if (status)
152 error_counter++;
153 }
154
thread_client_entry(ULONG thread_input)155 void thread_client_entry(ULONG thread_input)
156 {
157 UINT i;
158 UINT status;
159 NX_PACKET *send_packet;
160 NX_PACKET *recv_packet;
161
162
163 /* Give IP task and driver a chance to initialize the system. */
164 tx_thread_sleep(NX_IP_PERIODIC_RATE);
165
166 /* Set server IP address. */
167 server_ip_address.nxd_ip_address.v4 = HTTP_SERVER_ADDRESS;
168 server_ip_address.nxd_ip_version = NX_IP_VERSION_V4;
169
170 /* Wait HTTP server started. */
171 while(!http_server_start)
172 {
173 tx_thread_sleep(NX_IP_PERIODIC_RATE);
174 }
175
176 /* Create an HTTP client instance. */
177 status = nx_web_http_client_create(&my_client, "HTTP Client", &client_ip, &client_pool, 1536);
178
179 /* Check status. */
180 if (status)
181 error_counter++;
182
183 /* Post long message */
184 status = nx_web_http_client_post_start(&my_client, &server_ip_address,
185 NX_WEB_HTTP_SERVER_PORT,"/test.txt",
186 "www.abc.com", "name", "password", MESSAGE_LENGTH, NX_WAIT_FOREVER);
187
188 /* Check status. */
189 if (status)
190 {
191 error_counter++;
192 }
193
194 /* Allocate a packet. */
195 status = nx_web_http_client_request_packet_allocate(&my_client, &send_packet, 1 * NX_IP_PERIODIC_RATE);
196
197 /* Check status. */
198 if (status)
199 error_counter++;
200
201 for (i = 0; i < MESSAGE_LENGTH / sizeof(pkt); i++)
202 {
203 /* Write test data into the packet payload. */
204 status = nx_packet_data_append(send_packet, pkt, sizeof(pkt), &client_pool, NX_WAIT_FOREVER);
205 }
206
207 /* Send the POST request. */
208 status = nx_web_http_client_put_packet(&my_client, send_packet, 1 * NX_IP_PERIODIC_RATE);
209 if (status)
210 {
211 error_counter++;
212 nx_packet_release(send_packet);
213 }
214
215 /* Get response from server. */
216 while (1)
217 {
218 status = nx_web_http_client_response_body_get(&my_client, &recv_packet, 1 * NX_IP_PERIODIC_RATE);
219
220 if (status)
221 break;
222 else
223 nx_packet_release(recv_packet);
224 }
225
226 /* Check status. */
227 if (status != NX_WEB_HTTP_GET_DONE)
228 error_counter++;
229 else
230 nx_packet_release(recv_packet);
231
232 status = nx_web_http_client_delete(&my_client);
233 if (status)
234 error_counter++;
235
236 http_client_stop = 1;
237 }
238
239 /* Define the helper HTTP server thread. */
thread_server_entry(ULONG thread_input)240 void thread_server_entry(ULONG thread_input)
241 {
242 UINT status;
243 FX_FILE my_file;
244 UINT server_port = NX_WEB_HTTP_SERVER_PORT;
245
246
247 /* Print out test information banner. */
248 printf("NetX Test: Web Post Long Message Test................................");
249
250 /* Check for earlier error. */
251 if(error_counter)
252 {
253 printf("ERROR!\n");
254 test_control_return(1);
255 }
256
257 fx_media_format(&ram_disk,
258 _fx_ram_driver, // Driver entry
259 ram_disk_memory, // RAM disk memory pointer
260 media_memory, // Media buffer pointer
261 sizeof(media_memory), // Media buffer size
262 "MY_RAM_DISK", // Volume Name
263 1, // Number of FATs
264 32, // Directory Entries
265 0, // Hidden sectors
266 256, // Total sectors
267 512, // Sector size
268 8, // Sectors per cluster
269 1, // Heads
270 1); // Sectors per track
271
272 /* Open the RAM disk. */
273 status = fx_media_open(&ram_disk, "RAM DISK", _fx_ram_driver, ram_disk_memory, media_memory, sizeof(media_memory)) ;
274 status += fx_file_create(&ram_disk, "TEST.TXT");
275 status += fx_file_open(&ram_disk, &my_file, "TEST.TXT", FX_OPEN_FOR_WRITE);
276 status += fx_file_write(&my_file, "https server", 12);
277 status += fx_file_close(&my_file);
278 if(status)
279 error_counter++;
280
281 /* Give NetX a chance to initialize the system. */
282 tx_thread_sleep(NX_IP_PERIODIC_RATE);
283
284 /* Create the HTTP Server. */
285 status = nx_web_http_server_create(&my_server, "My HTTP Server", &server_ip, server_port, &ram_disk,
286 &server_stack, sizeof(server_stack), &server_pool,
287 NX_NULL, server_request_callback);
288 if (status)
289 error_counter++;
290
291 /* OK to start the HTTP Server. */
292 status = nx_web_http_server_start(&my_server);
293 if (status)
294 error_counter++;
295
296 http_server_start = 1;
297
298 /* Wait HTTP test finished. */
299 while(!http_client_stop)
300 {
301 tx_thread_sleep(NX_IP_PERIODIC_RATE);
302 }
303
304 status = nx_web_http_server_delete(&my_server);
305 if (status)
306 error_counter++;
307
308 /* Check packet pool. */
309 if (server_pool.nx_packet_pool_available != server_pool.nx_packet_pool_total)
310 {
311 error_counter++;
312 }
313
314 if (client_pool.nx_packet_pool_available != client_pool.nx_packet_pool_total)
315 {
316 error_counter++;
317 }
318
319 if(error_counter)
320 {
321 printf("ERROR!\n");
322 test_control_return(1);
323 }
324 else
325 {
326 printf("SUCCESS!\n");
327 test_control_return(0);
328 }
329 }
330
331 /* Define the server request callback function. */
server_request_callback(NX_WEB_HTTP_SERVER * server_ptr,UINT request_type,CHAR * resource,NX_PACKET * packet_ptr)332 static UINT server_request_callback(NX_WEB_HTTP_SERVER *server_ptr, UINT request_type, CHAR *resource, NX_PACKET *packet_ptr)
333 {
334 ULONG offset, total_length;
335 ULONG length = 0;
336 UCHAR buffer[sizeof(pkt)];
337 UINT i = 0, actual_size;
338 UINT status;
339
340 /* Process multipart data. */
341 if(request_type == NX_WEB_HTTP_SERVER_POST_REQUEST)
342 {
343
344 nx_web_http_server_content_length_get(packet_ptr, &length);
345 if (length != MESSAGE_LENGTH)
346 {
347 error_counter++;
348 }
349
350 total_length = 0;
351
352 while (total_length < MESSAGE_LENGTH)
353 {
354 offset = 0;
355 while (offset != sizeof(pkt))
356 {
357 status = nx_web_http_server_content_get_extended(server_ptr, packet_ptr, total_length + offset, &buffer[offset], sizeof(pkt) - offset, &actual_size);
358 offset += actual_size;
359 }
360
361 total_length += offset;
362
363 if (actual_size == 0)
364 {
365 break;
366 }
367 }
368
369 if (total_length != MESSAGE_LENGTH)
370 error_counter++;
371
372 /* Generate HTTP header. */
373 status = nx_web_http_server_callback_response_send_extended(server_ptr, NX_WEB_HTTP_STATUS_OK, sizeof(NX_WEB_HTTP_STATUS_OK) - 1,
374 "hello", 5, NX_NULL, 0);
375 if(status)
376 {
377 error_counter++;
378 }
379 }
380 else
381 {
382 return(NX_SUCCESS);
383 }
384
385 return(NX_WEB_HTTP_CALLBACK_COMPLETED);
386 }
387 #else
388
389 #ifdef CTEST
test_application_define(void * first_unused_memory)390 VOID test_application_define(void *first_unused_memory)
391 #else
392 void netx_web_post_large_packet_test_application_define(void *first_unused_memory)
393 #endif
394 {
395
396 /* Print out test information banner. */
397 printf("NetX Test: Web Post Long Message Test................................N/A\n");
398
399 test_control_return(3);
400 }
401 #endif
402
