aboutsummaryrefslogtreecommitdiff
path: root/src/microhttpd_ws/test_websocket.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/microhttpd_ws/test_websocket.c')
-rw-r--r--src/microhttpd_ws/test_websocket.c8983
1 files changed, 8983 insertions, 0 deletions
diff --git a/src/microhttpd_ws/test_websocket.c b/src/microhttpd_ws/test_websocket.c
new file mode 100644
index 00000000..7e0cf4d6
--- /dev/null
+++ b/src/microhttpd_ws/test_websocket.c
@@ -0,0 +1,8983 @@
1/*
2 This file is part of libmicrohttpd
3 Copyright (C) 2021 David Gausmann
4
5 libmicrohttpd is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published
7 by the Free Software Foundation; either version 3, or (at your
8 option) any later version.
9
10 libmicrohttpd is distributed in the hope that it will be useful, but
11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with libmicrohttpd; see the file COPYING. If not, write to the
17 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18 Boston, MA 02110-1301, USA.
19*/
20/**
21 * @file test_websocket.c
22 * @brief Testcase for WebSocket decoding/encoding
23 * @author David Gausmann
24 */
25#include "microhttpd.h"
26#include "microhttpd_ws.h"
27#include <stdlib.h>
28#include <string.h>
29#include <stdio.h>
30#include <time.h>
31
32int disable_alloc = 0;
33size_t open_allocs = 0;
34
35/**
36 * Custom `malloc()` function used for memory tests
37 */
38static void*
39test_malloc (size_t buf_len)
40{
41 if (0 != disable_alloc)
42 return NULL;
43 void*result = malloc (buf_len);
44 if (NULL != result)
45 ++open_allocs;
46 return result;
47}
48
49
50/**
51 * Custom `realloc()` function used for memory tests
52 */
53static void*
54test_realloc (void*buf, size_t buf_len)
55{
56 if (0 != disable_alloc)
57 return NULL;
58 void*result = realloc (buf, buf_len);
59 if ((NULL != result) && (NULL == buf))
60 ++open_allocs;
61 return result;
62}
63
64
65/**
66 * Custom `free()` function used for memory tests
67 */
68static void
69test_free (void*buf)
70{
71 if (NULL != buf)
72 --open_allocs;
73 free (buf);
74}
75
76
77/**
78 * Helper function which allocates a big amount of data
79 */
80static void
81allocate_length_test_data (char**buf1,
82 char**buf2,
83 size_t buf_len,
84 const char*buf1_prefix,
85 size_t buf1_prefix_len)
86{
87 if (NULL != *buf1)
88 free (*buf1);
89 if (NULL != *buf2)
90 free (*buf2);
91 *buf1 = (char*) malloc (buf_len + buf1_prefix_len);
92 *buf2 = (char*) malloc (buf_len);
93 if ((NULL == buf1) || (NULL == buf2))
94 return;
95 memcpy (*buf1,
96 buf1_prefix,
97 buf1_prefix_len);
98 for (size_t i = 0; i < buf_len; i += 64)
99 {
100 size_t bytes_to_copy = buf_len - i;
101 if (64 < bytes_to_copy)
102 bytes_to_copy = 64;
103 memcpy (*buf1 + i + buf1_prefix_len,
104 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-",
105 bytes_to_copy);
106 memcpy (*buf2 + i,
107 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-",
108 bytes_to_copy);
109 }
110}
111
112
113/**
114 * Helper function which performs a single decoder test
115 */
116static int
117test_decode_single (unsigned int test_line,
118 int flags, size_t max_payload_size, size_t decode_count,
119 size_t buf_step,
120 const char*buf, size_t buf_len,
121 const char*expected_payload, size_t expected_payload_len,
122 int expected_return, int expected_valid, size_t
123 expected_streambuf_read_len)
124{
125 struct MHD_WebSocketStream *ws = NULL;
126 int ret = MHD_WEBSOCKET_STATUS_OK;
127
128 /* initialize stream */
129 ret = MHD_websocket_stream_init (&ws, flags, max_payload_size);
130 if (MHD_WEBSOCKET_STATUS_OK != ret)
131 {
132 fprintf (stderr,
133 "Allocation failed for decode test in line %u.\n",
134 (unsigned int) test_line);
135 return 1;
136 }
137
138 /* perform decoding in a loop */
139 size_t streambuf_read_len = 0;
140 size_t payload_len = 0;
141 char*payload = NULL;
142 for (size_t i = 0; i < decode_count; ++i)
143 {
144 size_t streambuf_read_len_ = 0;
145 size_t bytes_to_take = buf_len - streambuf_read_len;
146 if ((0 != buf_step) && (buf_step < bytes_to_take))
147 bytes_to_take = buf_step;
148 ret = MHD_websocket_decode (ws, buf + streambuf_read_len, bytes_to_take,
149 &streambuf_read_len_, &payload, &payload_len);
150 streambuf_read_len += streambuf_read_len_;
151 if (i + 1 < decode_count)
152 {
153 if (payload)
154 {
155 MHD_websocket_free (ws, payload);
156 payload = NULL;
157 payload_len = 0;
158 }
159 }
160 }
161
162 /* check the (last) result */
163 if (ret != expected_return)
164 {
165 fprintf (stderr,
166 "Decode test failed in line %u: The return value should be %d, but is %d\n",
167 (unsigned int) test_line,
168 (int) expected_return,
169 (int) ret);
170 MHD_websocket_free (ws, payload);
171 MHD_websocket_stream_free (ws);
172 return 1;
173 }
174 if (payload_len != expected_payload_len)
175 {
176 fprintf (stderr,
177 "Decode test failed in line %u: The payload_len should be %u, but is %u\n",
178 (unsigned int) test_line,
179 (unsigned int) expected_payload_len,
180 (unsigned int) payload_len);
181 MHD_websocket_free (ws, payload);
182 MHD_websocket_stream_free (ws);
183 return 1;
184 }
185 if (0 != payload_len)
186 {
187 if (NULL == payload)
188 {
189 fprintf (stderr,
190 "Decode test failed in line %u: The payload is NULL\n",
191 (unsigned int) test_line);
192 MHD_websocket_free (ws, payload);
193 MHD_websocket_stream_free (ws);
194 return 1;
195 }
196 else if (NULL == expected_payload)
197 {
198 fprintf (stderr,
199 "Decode test failed in line %u: The expected_payload is NULL (wrong test declaration)\n",
200 (unsigned int) test_line);
201 MHD_websocket_free (ws, payload);
202 MHD_websocket_stream_free (ws);
203 return 1;
204 }
205 else if (0 != memcmp (payload, expected_payload, payload_len))
206 {
207 fprintf (stderr,
208 "Decode test failed in line %u: The payload differs from the expected_payload\n",
209 (unsigned int) test_line);
210 MHD_websocket_free (ws, payload);
211 MHD_websocket_stream_free (ws);
212 return 1;
213 }
214 }
215 else
216 {
217 if (NULL != payload)
218 {
219 fprintf (stderr,
220 "Decode test failed in line %u: The payload is not NULL, but payload_len is 0\n",
221 (unsigned int) test_line);
222 MHD_websocket_free (ws, payload);
223 MHD_websocket_stream_free (ws);
224 return 1;
225 }
226 else if (NULL != expected_payload)
227 {
228 fprintf (stderr,
229 "Decode test failed in line %u: The expected_payload is not NULL, but expected_payload_len is 0 (wrong test declaration)\n",
230 (unsigned int) test_line);
231 MHD_websocket_free (ws, payload);
232 MHD_websocket_stream_free (ws);
233 return 1;
234 }
235 }
236 if (streambuf_read_len != expected_streambuf_read_len)
237 {
238 fprintf (stderr,
239 "Decode test failed in line %u: The streambuf_read_len should be %u, but is %u\n",
240 (unsigned int) test_line,
241 (unsigned int) expected_streambuf_read_len,
242 (unsigned int) streambuf_read_len);
243 MHD_websocket_free (ws, payload);
244 MHD_websocket_stream_free (ws);
245 return 1;
246 }
247 ret = MHD_websocket_stream_is_valid (ws);
248 if (ret != expected_valid)
249 {
250 fprintf (stderr,
251 "Decode test failed in line %u: The stream validity should be %u, but is %u\n",
252 (unsigned int) test_line,
253 (int) expected_valid,
254 (int) ret);
255 MHD_websocket_free (ws, payload);
256 MHD_websocket_stream_free (ws);
257 return 1;
258 }
259
260 /* cleanup */
261 MHD_websocket_free (ws, payload);
262 MHD_websocket_stream_free (ws);
263
264 return 0;
265}
266
267
268/**
269 * Test procedure for `MHD_websocket_stream_init()` and
270 * `MHD_websocket_stream_init()2`
271 */
272int
273test_inits ()
274{
275 int failed = 0;
276 struct MHD_WebSocketStream*ws;
277 int ret;
278
279 /*
280 ------------------------------------------------------------------------------
281 All valid flags
282 ------------------------------------------------------------------------------
283 */
284 /* Regular test: all valid flags for init */
285 for (int i = 0; i < 7; ++i)
286 {
287 ws = NULL;
288 ret = MHD_websocket_stream_init (&ws,
289 i,
290 0);
291 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
292 (NULL == ws) )
293 {
294 fprintf (stderr,
295 "Init test failed in line %u for flags %d.\n",
296 (unsigned int) __LINE__,
297 (int) i);
298 ++failed;
299 }
300 if (NULL != ws)
301 {
302 MHD_websocket_stream_free (ws);
303 ws = NULL;
304 }
305 }
306 /* Regular test: all valid flags for init2 */
307 for (int i = 0; i < 7; ++i)
308 {
309 ws = NULL;
310 ret = MHD_websocket_stream_init2 (&ws,
311 i,
312 0,
313 test_malloc,
314 test_realloc,
315 test_free);
316 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
317 (NULL == ws) )
318 {
319 fprintf (stderr,
320 "Init test failed in line %u for flags %d.\n",
321 (unsigned int) __LINE__,
322 (int) i);
323 ++failed;
324 }
325 if (NULL != ws)
326 {
327 MHD_websocket_stream_free (ws);
328 ws = NULL;
329 }
330 }
331 /* Fail test: Invalid flags for init */
332 for (int i = 4; i < 32; ++i)
333 {
334 int flags = 1 << i;
335 ws = NULL;
336 ret = MHD_websocket_stream_init (&ws,
337 flags,
338 0);
339 if ((MHD_WEBSOCKET_STATUS_PARAMETER_ERROR != ret) ||
340 (NULL != ws) )
341 {
342 fprintf (stderr,
343 "Init test failed in line %u for invalid flags %d.\n",
344 (unsigned int) __LINE__,
345 (int) flags);
346 ++failed;
347 }
348 if (NULL != ws)
349 {
350 MHD_websocket_stream_free (ws);
351 ws = NULL;
352 }
353 }
354 /* Fail test: Invalid flag for init2 */
355 for (int i = 4; i < 32; ++i)
356 {
357 int flags = 1 << i;
358 ws = NULL;
359 ret = MHD_websocket_stream_init2 (&ws,
360 flags,
361 0,
362 test_malloc,
363 test_realloc,
364 test_free);
365 if ((MHD_WEBSOCKET_STATUS_PARAMETER_ERROR != ret) ||
366 (NULL != ws) )
367 {
368 fprintf (stderr,
369 "Init test failed in line %u for invalid flags %d.\n",
370 (unsigned int) __LINE__,
371 (int) flags);
372 ++failed;
373 }
374 if (NULL != ws)
375 {
376 MHD_websocket_stream_free (ws);
377 ws = NULL;
378 }
379 }
380
381 /*
382 ------------------------------------------------------------------------------
383 max_payload_size
384 ------------------------------------------------------------------------------
385 */
386 /* Regular test: max_payload_size = 0 for init */
387 ws = NULL;
388 ret = MHD_websocket_stream_init (&ws,
389 MHD_WEBSOCKET_FLAG_SERVER
390 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
391 0);
392 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
393 (NULL == ws) )
394 {
395 fprintf (stderr,
396 "Init test failed in line %u for max_payload_size 0.\n",
397 (unsigned int) __LINE__);
398 ++failed;
399 }
400 if (NULL != ws)
401 {
402 MHD_websocket_stream_free (ws);
403 ws = NULL;
404 }
405 /* Regular test: max_payload_size = 0 for init2 */
406 ws = NULL;
407 ret = MHD_websocket_stream_init2 (&ws,
408 MHD_WEBSOCKET_FLAG_SERVER
409 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
410 0,
411 test_malloc,
412 test_realloc,
413 test_free);
414 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
415 (NULL == ws) )
416 {
417 fprintf (stderr,
418 "Init test failed in line %u for max_payload_size 0.\n",
419 (unsigned int) __LINE__);
420 ++failed;
421 }
422 if (NULL != ws)
423 {
424 MHD_websocket_stream_free (ws);
425 ws = NULL;
426 }
427 /* Edge test (success): max_payload_size = 1 for init */
428 ws = NULL;
429 ret = MHD_websocket_stream_init (&ws,
430 MHD_WEBSOCKET_FLAG_SERVER
431 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
432 1);
433 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
434 (NULL == ws) )
435 {
436 fprintf (stderr,
437 "Init test failed in line %u for max_payload_size 1.\n",
438 (unsigned int) __LINE__);
439 ++failed;
440 }
441 if (NULL != ws)
442 {
443 MHD_websocket_stream_free (ws);
444 ws = NULL;
445 }
446 /* Edge test (success): max_payload_size = 1 for init2 */
447 ws = NULL;
448 ret = MHD_websocket_stream_init2 (&ws,
449 MHD_WEBSOCKET_FLAG_SERVER
450 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
451 1,
452 test_malloc,
453 test_realloc,
454 test_free);
455 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
456 (NULL == ws) )
457 {
458 fprintf (stderr,
459 "Init test failed in line %u for max_payload_size 1.\n",
460 (unsigned int) __LINE__);
461 ++failed;
462 }
463 if (NULL != ws)
464 {
465 MHD_websocket_stream_free (ws);
466 ws = NULL;
467 }
468 /* Regular test: max_payload_size = 1000 for init */
469 ws = NULL;
470 ret = MHD_websocket_stream_init (&ws,
471 MHD_WEBSOCKET_FLAG_SERVER
472 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
473 1000);
474 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
475 (NULL == ws) )
476 {
477 fprintf (stderr,
478 "Init test failed in line %u for max_payload_size 1000.\n",
479 (unsigned int) __LINE__);
480 ++failed;
481 }
482 if (NULL != ws)
483 {
484 MHD_websocket_stream_free (ws);
485 ws = NULL;
486 }
487 /* Regular test: max_payload_size = 1000 for init2 */
488 ws = NULL;
489 ret = MHD_websocket_stream_init2 (&ws,
490 MHD_WEBSOCKET_FLAG_SERVER
491 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
492 1000,
493 test_malloc,
494 test_realloc,
495 test_free);
496 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
497 (NULL == ws) )
498 {
499 fprintf (stderr,
500 "Init test failed in line %u for max_payload_size 1000.\n",
501 (unsigned int) __LINE__);
502 ++failed;
503 }
504 if (NULL != ws)
505 {
506 MHD_websocket_stream_free (ws);
507 ws = NULL;
508 }
509 /* Edge test (success): max_payload_size = 0x7FFFFFFFFFFFFFFF for init */
510 ws = NULL;
511 ret = MHD_websocket_stream_init (&ws,
512 MHD_WEBSOCKET_FLAG_SERVER
513 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
514 (uint64_t) 0x7FFFFFFFFFFFFFFF);
515 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
516 (NULL == ws) )
517 {
518 fprintf (stderr,
519 "Init test failed in line %u for max_payload_size 0x7FFFFFFFFFFFFFFF.\n",
520 (unsigned int) __LINE__);
521 ++failed;
522 }
523 if (NULL != ws)
524 {
525 MHD_websocket_stream_free (ws);
526 ws = NULL;
527 }
528 /* Edge test (success): max_payload_size = 0x7FFFFFFFFFFFFFFF for init2 */
529 ws = NULL;
530 ret = MHD_websocket_stream_init2 (&ws,
531 MHD_WEBSOCKET_FLAG_SERVER
532 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
533 (uint64_t) 0x7FFFFFFFFFFFFFFF,
534 test_malloc,
535 test_realloc,
536 test_free);
537 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
538 (NULL == ws) )
539 {
540 fprintf (stderr,
541 "Init test failed in line %u for max_payload_size 0x7FFFFFFFFFFFFFFF.\n",
542 (unsigned int) __LINE__);
543 ++failed;
544 }
545 if (NULL != ws)
546 {
547 MHD_websocket_stream_free (ws);
548 ws = NULL;
549 }
550 /* Edge test (fail): max_payload_size = 0x8000000000000000 for init */
551 ws = NULL;
552 ret = MHD_websocket_stream_init (&ws,
553 MHD_WEBSOCKET_FLAG_SERVER
554 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
555 (uint64_t) 0x8000000000000000);
556 if ((MHD_WEBSOCKET_STATUS_PARAMETER_ERROR != ret) ||
557 (NULL != ws) )
558 {
559 fprintf (stderr,
560 "Init test failed in line %u for max_payload_size 0x8000000000000000.\n",
561 (unsigned int) __LINE__);
562 ++failed;
563 }
564 if (NULL != ws)
565 {
566 MHD_websocket_stream_free (ws);
567 ws = NULL;
568 }
569 /* Edge test (fail): max_payload_size = 0x8000000000000000 for init2 */
570 ws = NULL;
571 ret = MHD_websocket_stream_init2 (&ws,
572 MHD_WEBSOCKET_FLAG_SERVER
573 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
574 (uint64_t) 0x8000000000000000,
575 test_malloc,
576 test_realloc,
577 test_free);
578 if ((MHD_WEBSOCKET_STATUS_PARAMETER_ERROR != ret) ||
579 (NULL != ws) )
580 {
581 fprintf (stderr,
582 "Init test failed in line %u for max_payload_size 0x8000000000000000.\n",
583 (unsigned int) __LINE__);
584 ++failed;
585 }
586 if (NULL != ws)
587 {
588 MHD_websocket_stream_free (ws);
589 ws = NULL;
590 }
591
592 /*
593 ------------------------------------------------------------------------------
594 Missing parameters
595 ------------------------------------------------------------------------------
596 */
597 /* Fail test: websocket stream variable missing for init */
598 ws = NULL;
599 ret = MHD_websocket_stream_init (NULL,
600 MHD_WEBSOCKET_FLAG_SERVER
601 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
602 0);
603 if ((MHD_WEBSOCKET_STATUS_PARAMETER_ERROR != ret) ||
604 (NULL != ws) )
605 {
606 fprintf (stderr,
607 "Init test failed in line %u.\n",
608 (unsigned int) __LINE__);
609 ++failed;
610 }
611 if (NULL != ws)
612 {
613 MHD_websocket_stream_free (ws);
614 ws = NULL;
615 }
616 /* Fail test: websocket stream variable missing for init2 */
617 ws = NULL;
618 ret = MHD_websocket_stream_init2 (NULL,
619 MHD_WEBSOCKET_FLAG_SERVER
620 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
621 0,
622 test_malloc,
623 test_realloc,
624 test_free);
625 if ((MHD_WEBSOCKET_STATUS_PARAMETER_ERROR != ret) ||
626 (NULL != ws) )
627 {
628 fprintf (stderr,
629 "Init test failed in line %u.\n",
630 (unsigned int) __LINE__);
631 ++failed;
632 }
633 if (NULL != ws)
634 {
635 MHD_websocket_stream_free (ws);
636 ws = NULL;
637 }
638 /* Fail test: malloc missing for init2 */
639 ws = NULL;
640 ret = MHD_websocket_stream_init2 (&ws,
641 MHD_WEBSOCKET_FLAG_SERVER
642 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
643 0,
644 NULL,
645 test_realloc,
646 test_free);
647 if ((MHD_WEBSOCKET_STATUS_PARAMETER_ERROR != ret) ||
648 (NULL != ws) )
649 {
650 fprintf (stderr,
651 "Init test failed in line %u.\n",
652 (unsigned int) __LINE__);
653 ++failed;
654 }
655 if (NULL != ws)
656 {
657 MHD_websocket_stream_free (ws);
658 ws = NULL;
659 }
660 /* Fail test: realloc missing for init2 */
661 ws = NULL;
662 ret = MHD_websocket_stream_init2 (&ws,
663 MHD_WEBSOCKET_FLAG_SERVER
664 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
665 0,
666 test_malloc,
667 NULL,
668 test_free);
669 if ((MHD_WEBSOCKET_STATUS_PARAMETER_ERROR != ret) ||
670 (NULL != ws) )
671 {
672 fprintf (stderr,
673 "Init test failed in line %u.\n",
674 (unsigned int) __LINE__);
675 ++failed;
676 }
677 if (NULL != ws)
678 {
679 MHD_websocket_stream_free (ws);
680 ws = NULL;
681 }
682 /* Fail test: free missing for init2 */
683 ws = NULL;
684 ret = MHD_websocket_stream_init2 (&ws,
685 MHD_WEBSOCKET_FLAG_SERVER
686 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
687 0,
688 test_malloc,
689 test_realloc,
690 NULL);
691 if ((MHD_WEBSOCKET_STATUS_PARAMETER_ERROR != ret) ||
692 (NULL != ws) )
693 {
694 fprintf (stderr,
695 "Init test failed in line %u.\n",
696 (unsigned int) __LINE__);
697 ++failed;
698 }
699 if (NULL != ws)
700 {
701 MHD_websocket_stream_free (ws);
702 ws = NULL;
703 }
704
705 return failed != 0 ? 0x01 : 0x00;
706}
707
708
709/**
710 * Test procedure for `MHD_websocket_create_accept()`
711 */
712int
713test_accept ()
714{
715 int failed = 0;
716 char accept_key[29];
717 int ret;
718
719 /*
720 ------------------------------------------------------------------------------
721 accepting
722 ------------------------------------------------------------------------------
723 */
724 /* Regular test: Test case from RFC6455 4.2.2 */
725 memset (accept_key, 0, 29);
726 ret = MHD_websocket_create_accept ("dGhlIHNhbXBsZSBub25jZQ==",
727 accept_key);
728 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
729 (0 != memcmp (accept_key, "s3pPLMBiTxaQ9kYGzzhZRbK+xOo=", 29)))
730 {
731 fprintf (stderr,
732 "Accept test failed in line %u.\n",
733 (unsigned int) __LINE__);
734 ++failed;
735 }
736
737 /*
738 ------------------------------------------------------------------------------
739 Missing parameters
740 ------------------------------------------------------------------------------
741 */
742 /* Fail test: missing sec-key value */
743 memset (accept_key, 0, 29);
744 ret = MHD_websocket_create_accept (NULL,
745 accept_key);
746 if (MHD_WEBSOCKET_STATUS_PARAMETER_ERROR != ret)
747 {
748 fprintf (stderr,
749 "Accept test failed in line %u.\n",
750 (unsigned int) __LINE__);
751 ++failed;
752 }
753 /* Fail test: missing accept variable */
754 memset (accept_key, 0, 29);
755 ret = MHD_websocket_create_accept ("dGhlIHNhbXBsZSBub25jZQ==",
756 NULL);
757 if (MHD_WEBSOCKET_STATUS_PARAMETER_ERROR != ret)
758 {
759 fprintf (stderr,
760 "Accept test failed in line %u.\n",
761 (unsigned int) __LINE__);
762 ++failed;
763 }
764
765 return failed != 0 ? 0x02 : 0x00;
766}
767
768
769/**
770 * Test procedure for `MHD_websocket_decode()`
771 */
772int
773test_decodes ()
774{
775 int failed = 0;
776 char *buf1 = NULL, *buf2 = NULL;
777
778 /*
779 ------------------------------------------------------------------------------
780 text frame
781 ------------------------------------------------------------------------------
782 */
783 /* Regular test: Masked text frame from RFC 6455, must succeed for server */
784 failed += test_decode_single (__LINE__,
785 MHD_WEBSOCKET_FLAG_SERVER
786 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
787 0,
788 1,
789 0,
790 "\x81\x85\x37\xfa\x21\x3d\x7f\x9f\x4d\x51\x58",
791 11,
792 "Hello",
793 5,
794 MHD_WEBSOCKET_STATUS_TEXT_FRAME,
795 MHD_WEBSOCKET_VALIDITY_VALID,
796 11);
797 /* Regular test: Unmasked text frame from RFC 6455, must succeed for client */
798 failed += test_decode_single (__LINE__,
799 MHD_WEBSOCKET_FLAG_CLIENT
800 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
801 0,
802 1,
803 0,
804 "\x81\x05\x48\x65\x6c\x6c\x6f",
805 7,
806 "Hello",
807 5,
808 MHD_WEBSOCKET_STATUS_TEXT_FRAME,
809 MHD_WEBSOCKET_VALIDITY_VALID,
810 7);
811 /* Fail test: Unmasked text frame from RFC 6455, must fail for server */
812 failed += test_decode_single (__LINE__,
813 MHD_WEBSOCKET_FLAG_SERVER
814 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
815 0,
816 1,
817 0,
818 "\x81\x05\x48\x65\x6c\x6c\x6f",
819 7,
820 NULL,
821 0,
822 MHD_WEBSOCKET_STATUS_PROTOCOL_ERROR,
823 MHD_WEBSOCKET_VALIDITY_INVALID,
824 1);
825 /* Fail test: Masked text frame from RFC 6455, must fail for client */
826 failed += test_decode_single (__LINE__,
827 MHD_WEBSOCKET_FLAG_CLIENT
828 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
829 0,
830 1,
831 0,
832 "\x81\x85\x37\xfa\x21\x3d\x7f\x9f\x4d\x51\x58",
833 11,
834 NULL,
835 0,
836 MHD_WEBSOCKET_STATUS_PROTOCOL_ERROR,
837 MHD_WEBSOCKET_VALIDITY_INVALID,
838 1);
839 /* Regular test: Text frame with UTF-8 sequence */
840 failed += test_decode_single (__LINE__,
841 MHD_WEBSOCKET_FLAG_SERVER
842 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
843 0,
844 1,
845 0,
846 "\x81\x90\x00\x00\x00\x00" "This is my n"
847 "\xC3\xB6" "te",
848 22,
849 "This is my n" "\xC3\xB6" "te",
850 16,
851 MHD_WEBSOCKET_STATUS_TEXT_FRAME,
852 MHD_WEBSOCKET_VALIDITY_VALID,
853 22);
854 /* Fail test: Text frame with with invalid UTF-8 */
855 failed += test_decode_single (__LINE__,
856 MHD_WEBSOCKET_FLAG_SERVER
857 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
858 0,
859 1,
860 0,
861 "\x81\x8F\x00\x00\x00\x00" "This is my n" "\xFF"
862 "te",
863 21,
864 NULL,
865 0,
866 MHD_WEBSOCKET_STATUS_UTF8_ENCODING_ERROR,
867 MHD_WEBSOCKET_VALIDITY_INVALID,
868 18);
869 /* Fail test: Text frame with broken UTF-8 sequence */
870 failed += test_decode_single (__LINE__,
871 MHD_WEBSOCKET_FLAG_SERVER
872 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
873 0,
874 1,
875 0,
876 "\x81\x8F\x00\x00\x00\x00" "This is my n" "\xC3"
877 "te",
878 21,
879 NULL,
880 0,
881 MHD_WEBSOCKET_STATUS_UTF8_ENCODING_ERROR,
882 MHD_WEBSOCKET_VALIDITY_INVALID,
883 19);
884 /* Regular test: Text frame without payload and mask (caller = server) */
885 failed += test_decode_single (__LINE__,
886 MHD_WEBSOCKET_FLAG_SERVER
887 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
888 0,
889 1,
890 0,
891 "\x81\x80\x01\x02\x03\x04",
892 6,
893 NULL,
894 0,
895 MHD_WEBSOCKET_STATUS_TEXT_FRAME,
896 MHD_WEBSOCKET_VALIDITY_VALID,
897 6);
898 /* Fail test: Text frame without payload and no mask (caller = server) */
899 failed += test_decode_single (__LINE__,
900 MHD_WEBSOCKET_FLAG_SERVER
901 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
902 0,
903 1,
904 0,
905 "\x81\x00",
906 2,
907 NULL,
908 0,
909 MHD_WEBSOCKET_STATUS_PROTOCOL_ERROR,
910 MHD_WEBSOCKET_VALIDITY_INVALID,
911 1);
912 /* Regular test: Text frame without payload and mask (caller = client) */
913 failed += test_decode_single (__LINE__,
914 MHD_WEBSOCKET_FLAG_CLIENT
915 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
916 0,
917 1,
918 0,
919 "\x81\x00",
920 2,
921 NULL,
922 0,
923 MHD_WEBSOCKET_STATUS_TEXT_FRAME,
924 MHD_WEBSOCKET_VALIDITY_VALID,
925 2);
926 /* Fail test: Text frame without payload and no mask (caller = client) */
927 failed += test_decode_single (__LINE__,
928 MHD_WEBSOCKET_FLAG_CLIENT
929 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
930 0,
931 1,
932 0,
933 "\x81\x80\x01\x02\x03\x04",
934 6,
935 NULL,
936 0,
937 MHD_WEBSOCKET_STATUS_PROTOCOL_ERROR,
938 MHD_WEBSOCKET_VALIDITY_INVALID,
939 1);
940
941 /*
942 ------------------------------------------------------------------------------
943 binary frame
944 ------------------------------------------------------------------------------
945 */
946 /* Regular test: Masked binary frame (decoder = server) */
947 failed += test_decode_single (__LINE__,
948 MHD_WEBSOCKET_FLAG_SERVER
949 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
950 0,
951 1,
952 0,
953 "\x82\x85\x37\xfa\x21\x3d\x7f\x9f\x4d\x51\x58",
954 11,
955 "Hello",
956 5,
957 MHD_WEBSOCKET_STATUS_BINARY_FRAME,
958 MHD_WEBSOCKET_VALIDITY_VALID,
959 11);
960 /* Regular test: Unmasked binary frame (decoder = client) */
961 failed += test_decode_single (__LINE__,
962 MHD_WEBSOCKET_FLAG_CLIENT
963 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
964 0,
965 1,
966 0,
967 "\x82\x05\x48\x65\x6c\x6c\x6f",
968 7,
969 "Hello",
970 5,
971 MHD_WEBSOCKET_STATUS_BINARY_FRAME,
972 MHD_WEBSOCKET_VALIDITY_VALID,
973 7);
974 /* Fail test: Unmasked binary frame (decoder = server) */
975 failed += test_decode_single (__LINE__,
976 MHD_WEBSOCKET_FLAG_SERVER
977 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
978 0,
979 1,
980 0,
981 "\x82\x05\x48\x65\x6c\x6c\x6f",
982 7,
983 NULL,
984 0,
985 MHD_WEBSOCKET_STATUS_PROTOCOL_ERROR,
986 MHD_WEBSOCKET_VALIDITY_INVALID,
987 1);
988 /* Fail test: Masked binary frame (decoder = client) */
989 failed += test_decode_single (__LINE__,
990 MHD_WEBSOCKET_FLAG_CLIENT
991 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
992 0,
993 1,
994 0,
995 "\x82\x85\x37\xfa\x21\x3d\x7f\x9f\x4d\x51\x58",
996 11,
997 NULL,
998 0,
999 MHD_WEBSOCKET_STATUS_PROTOCOL_ERROR,
1000 MHD_WEBSOCKET_VALIDITY_INVALID,
1001 1);
1002 /* Regular test: Binary frame without payload */
1003 failed += test_decode_single (__LINE__,
1004 MHD_WEBSOCKET_FLAG_SERVER
1005 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1006 0,
1007 1,
1008 0,
1009 "\x82\x80\x00\x00\x00\x00",
1010 6,
1011 NULL,
1012 0,
1013 MHD_WEBSOCKET_STATUS_BINARY_FRAME,
1014 MHD_WEBSOCKET_VALIDITY_VALID,
1015 6);
1016 /* Regular test: Fragmented binary frame without payload */
1017 failed += test_decode_single (__LINE__,
1018 MHD_WEBSOCKET_FLAG_SERVER
1019 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1020 0,
1021 1,
1022 0,
1023 "\x02\x80\x00\x00\x00\x00\x80\x80\x00\x00\x00\x00",
1024 12,
1025 NULL,
1026 0,
1027 MHD_WEBSOCKET_STATUS_BINARY_FRAME,
1028 MHD_WEBSOCKET_VALIDITY_VALID,
1029 12);
1030 /* Regular test: Fragmented binary frame without payload, fragments to the caller, 1st call */
1031 failed += test_decode_single (__LINE__,
1032 MHD_WEBSOCKET_FLAG_SERVER
1033 | MHD_WEBSOCKET_FLAG_WANT_FRAGMENTS,
1034 0,
1035 1,
1036 0,
1037 "\x02\x80\x00\x00\x00\x00\x80\x80\x00\x00\x00\x00",
1038 12,
1039 NULL,
1040 0,
1041 MHD_WEBSOCKET_STATUS_BINARY_FRAGMENT,
1042 MHD_WEBSOCKET_VALIDITY_VALID,
1043 6);
1044 /* Regular test: Fragmented binary frame without payload, fragments to the caller, 2nd call */
1045 failed += test_decode_single (__LINE__,
1046 MHD_WEBSOCKET_FLAG_SERVER
1047 | MHD_WEBSOCKET_FLAG_WANT_FRAGMENTS,
1048 0,
1049 2,
1050 0,
1051 "\x02\x80\x00\x00\x00\x00\x80\x80\x00\x00\x00\x00",
1052 12,
1053 NULL,
1054 0,
1055 MHD_WEBSOCKET_STATUS_BINARY_LAST_FRAGMENT,
1056 MHD_WEBSOCKET_VALIDITY_VALID,
1057 12);
1058 /* Regular test: Fragmented binary frame wit payload */
1059 failed += test_decode_single (__LINE__,
1060 MHD_WEBSOCKET_FLAG_SERVER
1061 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1062 0,
1063 1,
1064 0,
1065 "\x02\x83\x00\x00\x00\x00\x01\x02\x03\x80\x83\x00\x00\x00\x00\x04\x05\x06",
1066 18,
1067 "\x01\x02\x03\x04\x05\x06",
1068 6,
1069 MHD_WEBSOCKET_STATUS_BINARY_FRAME,
1070 MHD_WEBSOCKET_VALIDITY_VALID,
1071 18);
1072 /* Regular test: Fragmented binary frame with payload, fragments to the caller, 1st call */
1073 failed += test_decode_single (__LINE__,
1074 MHD_WEBSOCKET_FLAG_SERVER
1075 | MHD_WEBSOCKET_FLAG_WANT_FRAGMENTS,
1076 0,
1077 1,
1078 0,
1079 "\x02\x83\x00\x00\x00\x00\x01\x02\x03\x80\x83\x00\x00\x00\x00\x04\x05\x06",
1080 18,
1081 "\x01\x02\x03",
1082 3,
1083 MHD_WEBSOCKET_STATUS_BINARY_FRAGMENT,
1084 MHD_WEBSOCKET_VALIDITY_VALID,
1085 9);
1086 /* Regular test: Fragmented binary frame without payload, fragments to the caller, 2nd call */
1087 failed += test_decode_single (__LINE__,
1088 MHD_WEBSOCKET_FLAG_SERVER
1089 | MHD_WEBSOCKET_FLAG_WANT_FRAGMENTS,
1090 0,
1091 2,
1092 0,
1093 "\x02\x83\x00\x00\x00\x00\x01\x02\x03\x80\x83\x00\x00\x00\x00\x04\x05\x06",
1094 18,
1095 "\x04\x05\x06",
1096 3,
1097 MHD_WEBSOCKET_STATUS_BINARY_LAST_FRAGMENT,
1098 MHD_WEBSOCKET_VALIDITY_VALID,
1099 18);
1100 /* Regular test: Binary frame with bytes which look like invalid UTF-8 character */
1101 failed += test_decode_single (__LINE__,
1102 MHD_WEBSOCKET_FLAG_SERVER
1103 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1104 0,
1105 1,
1106 0,
1107 "\x82\x85\x00\x00\x00\x00" "Hell\xf6",
1108 11,
1109 "Hell\xf6",
1110 5,
1111 MHD_WEBSOCKET_STATUS_BINARY_FRAME,
1112 MHD_WEBSOCKET_VALIDITY_VALID,
1113 11);
1114 /* Regular test: Binary frame with bytes which look like broken UTF-8 sequence */
1115 failed += test_decode_single (__LINE__,
1116 MHD_WEBSOCKET_FLAG_SERVER
1117 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1118 0,
1119 1,
1120 0,
1121 "\x82\x85\x00\x00\x00\x00" "H\xC3llo",
1122 11,
1123 "H\xC3llo",
1124 5,
1125 MHD_WEBSOCKET_STATUS_BINARY_FRAME,
1126 MHD_WEBSOCKET_VALIDITY_VALID,
1127 11);
1128 /* Regular test: Binary frame with bytes which look like valid UTF-8 sequence */
1129 failed += test_decode_single (__LINE__,
1130 MHD_WEBSOCKET_FLAG_SERVER
1131 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1132 0,
1133 1,
1134 0,
1135 "\x82\x85\x00\x00\x00\x00" "H\xC3\xA4lo",
1136 11,
1137 "H\xC3\xA4lo",
1138 5,
1139 MHD_WEBSOCKET_STATUS_BINARY_FRAME,
1140 MHD_WEBSOCKET_VALIDITY_VALID,
1141 11);
1142 /* Regular test: Fragmented binary frame with bytes which look like valid UTF-8 sequence */
1143 failed += test_decode_single (__LINE__,
1144 MHD_WEBSOCKET_FLAG_SERVER
1145 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1146 0,
1147 1,
1148 0,
1149 "\x02\x82\x00\x00\x00\x00" "H\xC3"
1150 "\x80\x83\x00\x00\x00\x00" "\xA4lo",
1151 17,
1152 "H\xC3\xA4lo",
1153 5,
1154 MHD_WEBSOCKET_STATUS_BINARY_FRAME,
1155 MHD_WEBSOCKET_VALIDITY_VALID,
1156 17);
1157 /* Regular test: Fragmented binary frame with bytes which look like valid UTF-8 sequence,
1158 fragments to the caller, 1st call */
1159 failed += test_decode_single (__LINE__,
1160 MHD_WEBSOCKET_FLAG_SERVER
1161 | MHD_WEBSOCKET_FLAG_WANT_FRAGMENTS,
1162 0,
1163 1,
1164 0,
1165 "\x02\x82\x00\x00\x00\x00" "H\xC3"
1166 "\x80\x83\x00\x00\x00\x00" "\xA4lo",
1167 17,
1168 "H\xC3",
1169 2,
1170 MHD_WEBSOCKET_STATUS_BINARY_FRAGMENT,
1171 MHD_WEBSOCKET_VALIDITY_VALID,
1172 8);
1173 /* Regular test: Fragmented binary frame with bytes which look like valid UTF-8 sequence,
1174 fragments to the caller, 2nd call */
1175 failed += test_decode_single (__LINE__,
1176 MHD_WEBSOCKET_FLAG_SERVER
1177 | MHD_WEBSOCKET_FLAG_WANT_FRAGMENTS,
1178 0,
1179 2,
1180 0,
1181 "\x02\x82\x00\x00\x00\x00" "H\xC3"
1182 "\x80\x83\x00\x00\x00\x00" "\xA4lo",
1183 17,
1184 "\xA4lo",
1185 3,
1186 MHD_WEBSOCKET_STATUS_BINARY_LAST_FRAGMENT,
1187 MHD_WEBSOCKET_VALIDITY_VALID,
1188 17);
1189
1190 /*
1191 ------------------------------------------------------------------------------
1192 close frame
1193 ------------------------------------------------------------------------------
1194 */
1195 /* Regular test: Close frame with no payload but with mask (decoder = server) */
1196 failed += test_decode_single (__LINE__,
1197 MHD_WEBSOCKET_FLAG_SERVER
1198 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1199 0,
1200 1,
1201 0,
1202 "\x88\x80\x00\x00\x00\x00",
1203 6,
1204 NULL,
1205 0,
1206 MHD_WEBSOCKET_STATUS_CLOSE_FRAME,
1207 MHD_WEBSOCKET_VALIDITY_ONLY_VALID_FOR_CONTROL_FRAMES,
1208 6);
1209 /* Regular test: Close frame with no payload (decoder = client) */
1210 failed += test_decode_single (__LINE__,
1211 MHD_WEBSOCKET_FLAG_CLIENT
1212 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1213 0,
1214 1,
1215 0,
1216 "\x88\x00",
1217 2,
1218 NULL,
1219 0,
1220 MHD_WEBSOCKET_STATUS_CLOSE_FRAME,
1221 MHD_WEBSOCKET_VALIDITY_ONLY_VALID_FOR_CONTROL_FRAMES,
1222 2);
1223 /* Fail test: Close frame with no payload and no mask (decoder = server) */
1224 failed += test_decode_single (__LINE__,
1225 MHD_WEBSOCKET_FLAG_SERVER
1226 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1227 0,
1228 1,
1229 0,
1230 "\x88\x00",
1231 2,
1232 NULL,
1233 0,
1234 MHD_WEBSOCKET_STATUS_PROTOCOL_ERROR,
1235 MHD_WEBSOCKET_VALIDITY_INVALID,
1236 1);
1237 /* Fail test: Close frame with no payload but with mask (decoder = client) */
1238 failed += test_decode_single (__LINE__,
1239 MHD_WEBSOCKET_FLAG_CLIENT
1240 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1241 0,
1242 1,
1243 0,
1244 "\x88\x80\x00\x00\x00\x00",
1245 6,
1246 NULL,
1247 0,
1248 MHD_WEBSOCKET_STATUS_PROTOCOL_ERROR,
1249 MHD_WEBSOCKET_VALIDITY_INVALID,
1250 1);
1251 /* Regular test: Close frame with 2 byte payload for close reason */
1252 failed += test_decode_single (__LINE__,
1253 MHD_WEBSOCKET_FLAG_SERVER
1254 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1255 0,
1256 1,
1257 0,
1258 "\x88\x82\x00\x00\x00\x00\x03\xEB",
1259 8,
1260 "\x03\xEB",
1261 2,
1262 MHD_WEBSOCKET_STATUS_CLOSE_FRAME,
1263 MHD_WEBSOCKET_VALIDITY_ONLY_VALID_FOR_CONTROL_FRAMES,
1264 8);
1265 /* Fail test: Close frame with 1 byte payload (no valid close reason) */
1266 failed += test_decode_single (__LINE__,
1267 MHD_WEBSOCKET_FLAG_SERVER
1268 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1269 0,
1270 1,
1271 0,
1272 "\x88\x81\x00\x00\x00\x00\x03",
1273 7,
1274 NULL,
1275 0,
1276 MHD_WEBSOCKET_STATUS_PROTOCOL_ERROR,
1277 MHD_WEBSOCKET_VALIDITY_INVALID,
1278 1);
1279 /* Regular test: Close frame with close reason and UTF-8 description */
1280 failed += test_decode_single (__LINE__,
1281 MHD_WEBSOCKET_FLAG_SERVER
1282 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1283 0,
1284 1,
1285 0,
1286 "\x88\x95\x00\x00\x00\x00\x03\xEB"
1287 "Something was wrong",
1288 27,
1289 "\x03\xEB" "Something was wrong",
1290 21,
1291 MHD_WEBSOCKET_STATUS_CLOSE_FRAME,
1292 MHD_WEBSOCKET_VALIDITY_ONLY_VALID_FOR_CONTROL_FRAMES,
1293 27);
1294 /* Regular test: Close frame with close reason and UTF-8 description (with UTF-8 sequence) */
1295 failed += test_decode_single (__LINE__,
1296 MHD_WEBSOCKET_FLAG_SERVER
1297 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1298 0,
1299 1,
1300 0,
1301 "\x88\x96\x00\x00\x00\x00\x03\xEB"
1302 "Something was wr" "\xC3\xB6" "ng",
1303 28,
1304 "\x03\xEB" "Something was wr" "\xC3\xB6" "ng",
1305 22,
1306 MHD_WEBSOCKET_STATUS_CLOSE_FRAME,
1307 MHD_WEBSOCKET_VALIDITY_ONLY_VALID_FOR_CONTROL_FRAMES,
1308 28);
1309 /* Fail test: Close frame with close reason and invalid UTF-8 in description */
1310 failed += test_decode_single (__LINE__,
1311 MHD_WEBSOCKET_FLAG_SERVER
1312 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1313 0,
1314 1,
1315 0,
1316 "\x88\x95\x00\x00\x00\x00\x03\xEB"
1317 "Something was wr" "\xFF" "ng",
1318 27,
1319 NULL,
1320 0,
1321 MHD_WEBSOCKET_STATUS_UTF8_ENCODING_ERROR,
1322 MHD_WEBSOCKET_VALIDITY_INVALID,
1323 24);
1324 /* Fail test: Close frame with close reason and broken UTF-8 sequence in description */
1325 failed += test_decode_single (__LINE__,
1326 MHD_WEBSOCKET_FLAG_SERVER
1327 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1328 0,
1329 1,
1330 0,
1331 "\x88\x95\x00\x00\x00\x00\x03\xEB"
1332 "Something was wr" "\xC3" "ng",
1333 27,
1334 NULL,
1335 0,
1336 MHD_WEBSOCKET_STATUS_UTF8_ENCODING_ERROR,
1337 MHD_WEBSOCKET_VALIDITY_INVALID,
1338 25);
1339 /* Edge test (success): Close frame with 125 bytes of payload */
1340 failed += test_decode_single (__LINE__,
1341 MHD_WEBSOCKET_FLAG_SERVER
1342 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1343 0,
1344 1,
1345 0,
1346 "\x88\xFD\x00\x00\x00\x00\x03\xEB"
1347 "Something was wrong, so I decided to close this websocket. I hope you are not angry. But this is also the 123 cap test. :-)",
1348 131,
1349 "\x03\xEB"
1350 "Something was wrong, so I decided to close this websocket. I hope you are not angry. But this is also the 123 cap test. :-)",
1351 125,
1352 MHD_WEBSOCKET_STATUS_CLOSE_FRAME,
1353 MHD_WEBSOCKET_VALIDITY_ONLY_VALID_FOR_CONTROL_FRAMES,
1354 131);
1355 /* Edge test (failure): Close frame with 126 bytes of payload */
1356 failed += test_decode_single (__LINE__,
1357 MHD_WEBSOCKET_FLAG_SERVER
1358 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1359 0,
1360 1,
1361 0,
1362 "\x88\xFE\x00\x7e\x00\x00\x00\x00\x03\xEB"
1363 "Something was wrong, so I decided to close this websocket. I hope you are not angry. But this is also the 123 cap test. >:-)",
1364 134,
1365 NULL,
1366 0,
1367 MHD_WEBSOCKET_STATUS_PROTOCOL_ERROR,
1368 MHD_WEBSOCKET_VALIDITY_INVALID,
1369 1);
1370 /* Fail test: Close frame with 500 bytes of payload */
1371 failed += test_decode_single (__LINE__,
1372 MHD_WEBSOCKET_FLAG_SERVER
1373 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1374 0,
1375 1,
1376 0,
1377 "\x88\xFE\x01\xf4\x00\x00\x00\x00\x03\xEB"
1378 "The payload of this test isn't parsed.",
1379 49,
1380 NULL,
1381 0,
1382 MHD_WEBSOCKET_STATUS_PROTOCOL_ERROR,
1383 MHD_WEBSOCKET_VALIDITY_INVALID,
1384 1);
1385 /* Edge test (failure): Close frame with 65535 bytes of payload */
1386 failed += test_decode_single (__LINE__,
1387 MHD_WEBSOCKET_FLAG_SERVER
1388 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1389 0,
1390 1,
1391 0,
1392 "\x88\xFE\xff\xff\x00\x00\x00\x00\x03\xEB"
1393 "The payload of this test isn't parsed.",
1394 49,
1395 NULL,
1396 0,
1397 MHD_WEBSOCKET_STATUS_PROTOCOL_ERROR,
1398 MHD_WEBSOCKET_VALIDITY_INVALID,
1399 1);
1400 /* Edge test (failure): Close frame with 65536 bytes of payload */
1401 failed += test_decode_single (__LINE__,
1402 MHD_WEBSOCKET_FLAG_SERVER
1403 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1404 0,
1405 1,
1406 0,
1407 "\x88\xFF\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x03\xEB"
1408 "The payload of this test isn't parsed.",
1409 54,
1410 NULL,
1411 0,
1412 MHD_WEBSOCKET_STATUS_PROTOCOL_ERROR,
1413 MHD_WEBSOCKET_VALIDITY_INVALID,
1414 1);
1415 /* Fail test: Close frame with 1000000 bytes of payload */
1416 failed += test_decode_single (__LINE__,
1417 MHD_WEBSOCKET_FLAG_SERVER
1418 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1419 0,
1420 1,
1421 0,
1422 "\x88\xFF\x00\x00\x00\x00\x00\x0F\x42\x40\x00\x00\x00\x00\x03\xEB"
1423 "The payload of this test isn't parsed.",
1424 54,
1425 NULL,
1426 0,
1427 MHD_WEBSOCKET_STATUS_PROTOCOL_ERROR,
1428 MHD_WEBSOCKET_VALIDITY_INVALID,
1429 1);
1430
1431 /*
1432 ------------------------------------------------------------------------------
1433 ping frame
1434 ------------------------------------------------------------------------------
1435 */
1436 /* Regular test: Ping frame with no payload but with mask (decoder = server) */
1437 failed += test_decode_single (__LINE__,
1438 MHD_WEBSOCKET_FLAG_SERVER
1439 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1440 0,
1441 1,
1442 0,
1443 "\x89\x80\x00\x00\x00\x00",
1444 6,
1445 NULL,
1446 0,
1447 MHD_WEBSOCKET_STATUS_PING_FRAME,
1448 MHD_WEBSOCKET_VALIDITY_VALID,
1449 6);
1450 /* Regular test: Ping frame with no payload (decoder = client) */
1451 failed += test_decode_single (__LINE__,
1452 MHD_WEBSOCKET_FLAG_CLIENT
1453 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1454 0,
1455 1,
1456 0,
1457 "\x89\x00",
1458 2,
1459 NULL,
1460 0,
1461 MHD_WEBSOCKET_STATUS_PING_FRAME,
1462 MHD_WEBSOCKET_VALIDITY_VALID,
1463 2);
1464 /* Fail test: Ping frame with no payload and no mask (decoder = server) */
1465 failed += test_decode_single (__LINE__,
1466 MHD_WEBSOCKET_FLAG_SERVER
1467 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1468 0,
1469 1,
1470 0,
1471 "\x89\x00",
1472 2,
1473 NULL,
1474 0,
1475 MHD_WEBSOCKET_STATUS_PROTOCOL_ERROR,
1476 MHD_WEBSOCKET_VALIDITY_INVALID,
1477 1);
1478 /* Fail test: Ping frame with no payload but with mask (decoder = client) */
1479 failed += test_decode_single (__LINE__,
1480 MHD_WEBSOCKET_FLAG_CLIENT
1481 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1482 0,
1483 1,
1484 0,
1485 "\x89\x80\x00\x00\x00\x00",
1486 6,
1487 NULL,
1488 0,
1489 MHD_WEBSOCKET_STATUS_PROTOCOL_ERROR,
1490 MHD_WEBSOCKET_VALIDITY_INVALID,
1491 1);
1492 /* Regular test: Ping frame with some (masked) payload */
1493 failed += test_decode_single (__LINE__,
1494 MHD_WEBSOCKET_FLAG_SERVER
1495 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1496 0,
1497 1,
1498 0,
1499 "\x89\x88\x01\x20\x03\x40\xFF\xFF\xFF\xFF\x00\x00\x00\x00",
1500 14,
1501 "\xFE\xDF\xFC\xBF\x01\x20\x03\x40",
1502 8,
1503 MHD_WEBSOCKET_STATUS_PING_FRAME,
1504 MHD_WEBSOCKET_VALIDITY_VALID,
1505 14);
1506 /* Edge test (success): Ping frame with one byte of payload */
1507 failed += test_decode_single (__LINE__,
1508 MHD_WEBSOCKET_FLAG_SERVER
1509 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1510 0,
1511 1,
1512 0,
1513 "\x89\x81\x00\x00\x00\x00" "a",
1514 7,
1515 "a",
1516 1,
1517 MHD_WEBSOCKET_STATUS_PING_FRAME,
1518 MHD_WEBSOCKET_VALIDITY_VALID,
1519 7);
1520 /* Edge test (success): Ping frame with 125 bytes of payload */
1521 failed += test_decode_single (__LINE__,
1522 MHD_WEBSOCKET_FLAG_SERVER
1523 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1524 0,
1525 1,
1526 0,
1527 "\x89\xFD\x00\x00\x00\x00"
1528 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ012345678",
1529 131,
1530 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ012345678",
1531 125,
1532 MHD_WEBSOCKET_STATUS_PING_FRAME,
1533 MHD_WEBSOCKET_VALIDITY_VALID,
1534 131);
1535 /* Edge test (fail): Ping frame with 126 bytes of payload */
1536 failed += test_decode_single (__LINE__,
1537 MHD_WEBSOCKET_FLAG_SERVER
1538 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1539 0,
1540 1,
1541 0,
1542 "\x89\xFE\x00\x7E\x00\x00\x00\x00"
1543 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789",
1544 134,
1545 NULL,
1546 0,
1547 MHD_WEBSOCKET_STATUS_PROTOCOL_ERROR,
1548 MHD_WEBSOCKET_VALIDITY_INVALID,
1549 1);
1550 /* Regular test: Ping frame with UTF-8 data */
1551 failed += test_decode_single (__LINE__,
1552 MHD_WEBSOCKET_FLAG_SERVER
1553 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1554 0,
1555 1,
1556 0,
1557 "\x89\x90\x00\x00\x00\x00" "Ping is bin"
1558 "\xC3\xA4" "ry.",
1559 22,
1560 "Ping is bin" "\xC3\xA4" "ry.",
1561 16,
1562 MHD_WEBSOCKET_STATUS_PING_FRAME,
1563 MHD_WEBSOCKET_VALIDITY_VALID,
1564 22);
1565 /* Regular test: Ping frame with invalid UTF-8 data */
1566 failed += test_decode_single (__LINE__,
1567 MHD_WEBSOCKET_FLAG_SERVER
1568 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1569 0,
1570 1,
1571 0,
1572 "\x89\x8F\x00\x00\x00\x00" "Ping is bin" "\xFF"
1573 "ry.",
1574 21,
1575 "Ping is bin" "\xFF" "ry.",
1576 15,
1577 MHD_WEBSOCKET_STATUS_PING_FRAME,
1578 MHD_WEBSOCKET_VALIDITY_VALID,
1579 21);
1580 /* Regular test: Ping frame with broken UTF-8 sequence */
1581 failed += test_decode_single (__LINE__,
1582 MHD_WEBSOCKET_FLAG_SERVER
1583 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1584 0,
1585 1,
1586 0,
1587 "\x89\x8F\x00\x00\x00\x00" "Ping is bin" "\xC3"
1588 "ry.",
1589 21,
1590 "Ping is bin" "\xC3" "ry.",
1591 15,
1592 MHD_WEBSOCKET_STATUS_PING_FRAME,
1593 MHD_WEBSOCKET_VALIDITY_VALID,
1594 21);
1595
1596 /*
1597 ------------------------------------------------------------------------------
1598 pong frame
1599 ------------------------------------------------------------------------------
1600 */
1601 /* Regular test: Pong frame with no payload but with mask (decoder = server) */
1602 failed += test_decode_single (__LINE__,
1603 MHD_WEBSOCKET_FLAG_SERVER
1604 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1605 0,
1606 1,
1607 0,
1608 "\x8A\x80\x00\x00\x00\x00",
1609 6,
1610 NULL,
1611 0,
1612 MHD_WEBSOCKET_STATUS_PONG_FRAME,
1613 MHD_WEBSOCKET_VALIDITY_VALID,
1614 6);
1615 /* Regular test: Pong frame with no payload (decoder = client) */
1616 failed += test_decode_single (__LINE__,
1617 MHD_WEBSOCKET_FLAG_CLIENT
1618 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1619 0,
1620 1,
1621 0,
1622 "\x8A\x00",
1623 2,
1624 NULL,
1625 0,
1626 MHD_WEBSOCKET_STATUS_PONG_FRAME,
1627 MHD_WEBSOCKET_VALIDITY_VALID,
1628 2);
1629 /* Fail test: Pong frame with no payload and no mask (decoder = server) */
1630 failed += test_decode_single (__LINE__,
1631 MHD_WEBSOCKET_FLAG_SERVER
1632 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1633 0,
1634 1,
1635 0,
1636 "\x8A\x00",
1637 2,
1638 NULL,
1639 0,
1640 MHD_WEBSOCKET_STATUS_PROTOCOL_ERROR,
1641 MHD_WEBSOCKET_VALIDITY_INVALID,
1642 1);
1643 /* Fail test: Pong frame with no payload but with mask (decoder = client) */
1644 failed += test_decode_single (__LINE__,
1645 MHD_WEBSOCKET_FLAG_CLIENT
1646 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1647 0,
1648 1,
1649 0,
1650 "\x8A\x80\x00\x00\x00\x00",
1651 6,
1652 NULL,
1653 0,
1654 MHD_WEBSOCKET_STATUS_PROTOCOL_ERROR,
1655 MHD_WEBSOCKET_VALIDITY_INVALID,
1656 1);
1657 /* Regular test: Pong frame with some (masked) payload */
1658 failed += test_decode_single (__LINE__,
1659 MHD_WEBSOCKET_FLAG_SERVER
1660 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1661 0,
1662 1,
1663 0,
1664 "\x8A\x88\x01\x20\x03\x40\xFF\xFF\xFF\xFF\x00\x00\x00\x00",
1665 14,
1666 "\xFE\xDF\xFC\xBF\x01\x20\x03\x40",
1667 8,
1668 MHD_WEBSOCKET_STATUS_PONG_FRAME,
1669 MHD_WEBSOCKET_VALIDITY_VALID,
1670 14);
1671 /* Edge test (success): Pong frame with one byte of payload */
1672 failed += test_decode_single (__LINE__,
1673 MHD_WEBSOCKET_FLAG_SERVER
1674 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1675 0,
1676 1,
1677 0,
1678 "\x8A\x81\x00\x00\x00\x00" "a",
1679 7,
1680 "a",
1681 1,
1682 MHD_WEBSOCKET_STATUS_PONG_FRAME,
1683 MHD_WEBSOCKET_VALIDITY_VALID,
1684 7);
1685 /* Edge test (success): Pong frame with 125 bytes of payload */
1686 failed += test_decode_single (__LINE__,
1687 MHD_WEBSOCKET_FLAG_SERVER
1688 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1689 0,
1690 1,
1691 0,
1692 "\x8A\xFD\x00\x00\x00\x00"
1693 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ012345678",
1694 131,
1695 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ012345678",
1696 125,
1697 MHD_WEBSOCKET_STATUS_PONG_FRAME,
1698 MHD_WEBSOCKET_VALIDITY_VALID,
1699 131);
1700 /* Edge test (fail): Pong frame with 126 bytes of payload */
1701 failed += test_decode_single (__LINE__,
1702 MHD_WEBSOCKET_FLAG_SERVER
1703 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1704 0,
1705 1,
1706 0,
1707 "\x8A\xFE\x00\x7E\x00\x00\x00\x00"
1708 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789",
1709 134,
1710 NULL,
1711 0,
1712 MHD_WEBSOCKET_STATUS_PROTOCOL_ERROR,
1713 MHD_WEBSOCKET_VALIDITY_INVALID,
1714 1);
1715 /* Regular test: Pong frame with UTF-8 data */
1716 failed += test_decode_single (__LINE__,
1717 MHD_WEBSOCKET_FLAG_SERVER
1718 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1719 0,
1720 1,
1721 0,
1722 "\x8A\x90\x00\x00\x00\x00" "Pong is bin"
1723 "\xC3\xA4" "ry.",
1724 22,
1725 "Pong is bin" "\xC3\xA4" "ry.",
1726 16,
1727 MHD_WEBSOCKET_STATUS_PONG_FRAME,
1728 MHD_WEBSOCKET_VALIDITY_VALID,
1729 22);
1730 /* Regular test: Pong frame with invalid UTF-8 data */
1731 failed += test_decode_single (__LINE__,
1732 MHD_WEBSOCKET_FLAG_SERVER
1733 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1734 0,
1735 1,
1736 0,
1737 "\x8A\x8F\x00\x00\x00\x00" "Pong is bin" "\xFF"
1738 "ry.",
1739 21,
1740 "Pong is bin" "\xFF" "ry.",
1741 15,
1742 MHD_WEBSOCKET_STATUS_PONG_FRAME,
1743 MHD_WEBSOCKET_VALIDITY_VALID,
1744 21);
1745 /* Regular test: Pong frame with broken UTF-8 sequence */
1746 failed += test_decode_single (__LINE__,
1747 MHD_WEBSOCKET_FLAG_SERVER
1748 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1749 0,
1750 1,
1751 0,
1752 "\x8A\x8F\x00\x00\x00\x00" "Pong is bin" "\xC3"
1753 "ry.",
1754 21,
1755 "Pong is bin" "\xC3" "ry.",
1756 15,
1757 MHD_WEBSOCKET_STATUS_PONG_FRAME,
1758 MHD_WEBSOCKET_VALIDITY_VALID,
1759 21);
1760
1761 /*
1762 ------------------------------------------------------------------------------
1763 fragmentation
1764 ------------------------------------------------------------------------------
1765 */
1766 /* Regular test: Fragmented, masked text frame, we are the server and don't want fragments as caller */
1767 failed += test_decode_single (__LINE__,
1768 MHD_WEBSOCKET_FLAG_SERVER
1769 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1770 0,
1771 1,
1772 0,
1773 "\x01\x83\x37\xfa\x21\x3d\x7f\x9f\x4d\x80\x82\x3d\x37\xfa\x21\x51\x58",
1774 17,
1775 "Hello",
1776 5,
1777 MHD_WEBSOCKET_STATUS_TEXT_FRAME,
1778 MHD_WEBSOCKET_VALIDITY_VALID,
1779 17);
1780 /* Regular test: Fragmented, masked text frame, we are the server and don't want fragments as caller, but call decode two times */
1781 failed += test_decode_single (__LINE__,
1782 MHD_WEBSOCKET_FLAG_SERVER
1783 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1784 0,
1785 2,
1786 0,
1787 "\x01\x83\x37\xfa\x21\x3d\x7f\x9f\x4d\x80\x82\x3d\x37\xfa\x21\x51\x58",
1788 17,
1789 NULL,
1790 0,
1791 MHD_WEBSOCKET_STATUS_OK,
1792 MHD_WEBSOCKET_VALIDITY_VALID,
1793 17);
1794 /* Regular test: Fragmented, masked text frame, we are the server and want fragments, one call */
1795 failed += test_decode_single (__LINE__,
1796 MHD_WEBSOCKET_FLAG_SERVER
1797 | MHD_WEBSOCKET_FLAG_WANT_FRAGMENTS,
1798 0,
1799 1,
1800 0,
1801 "\x01\x83\x37\xfa\x21\x3d\x7f\x9f\x4d\x80\x82\x3d\x37\xfa\x21\x51\x58",
1802 17,
1803 "Hel",
1804 3,
1805 MHD_WEBSOCKET_STATUS_TEXT_FRAGMENT,
1806 MHD_WEBSOCKET_VALIDITY_VALID,
1807 9);
1808 /* Regular test: Fragmented, masked text frame, we are the server and want fragments, second call */
1809 failed += test_decode_single (__LINE__,
1810 MHD_WEBSOCKET_FLAG_SERVER
1811 | MHD_WEBSOCKET_FLAG_WANT_FRAGMENTS,
1812 0,
1813 2,
1814 0,
1815 "\x01\x83\x37\xfa\x21\x3d\x7f\x9f\x4d\x80\x82\x3d\x37\xfa\x21\x51\x58",
1816 17,
1817 "lo",
1818 2,
1819 MHD_WEBSOCKET_STATUS_TEXT_LAST_FRAGMENT,
1820 MHD_WEBSOCKET_VALIDITY_VALID,
1821 17);
1822 /* Regular test: Fragmented, masked text frame, we are the server and want fragments, third call */
1823 failed += test_decode_single (__LINE__,
1824 MHD_WEBSOCKET_FLAG_SERVER
1825 | MHD_WEBSOCKET_FLAG_WANT_FRAGMENTS,
1826 0,
1827 3,
1828 0,
1829 "\x01\x83\x37\xfa\x21\x3d\x7f\x9f\x4d\x80\x82\x3d\x37\xfa\x21\x51\x58",
1830 17,
1831 NULL,
1832 0,
1833 MHD_WEBSOCKET_STATUS_OK,
1834 MHD_WEBSOCKET_VALIDITY_VALID,
1835 17);
1836
1837
1838 /*
1839 ------------------------------------------------------------------------------
1840 invalid flags
1841 ------------------------------------------------------------------------------
1842 */
1843 /* Regular test: Template with valid data for the next tests (this one must succeed) */
1844 failed += test_decode_single (__LINE__,
1845 MHD_WEBSOCKET_FLAG_SERVER
1846 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1847 0,
1848 1,
1849 0,
1850 "\x81\x85\x00\x00\x00\x00Hello",
1851 11,
1852 "Hello",
1853 5,
1854 MHD_WEBSOCKET_STATUS_TEXT_FRAME,
1855 MHD_WEBSOCKET_VALIDITY_VALID,
1856 11);
1857 /* Fail test: RSV1 flag set */
1858 failed += test_decode_single (__LINE__,
1859 MHD_WEBSOCKET_FLAG_SERVER
1860 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1861 0,
1862 1,
1863 0,
1864 "\x91\x85\x00\x00\x00\x00Hello",
1865 11,
1866 NULL,
1867 0,
1868 MHD_WEBSOCKET_STATUS_PROTOCOL_ERROR,
1869 MHD_WEBSOCKET_VALIDITY_INVALID,
1870 0);
1871 /* Fail test: RSV2 flag set */
1872 failed += test_decode_single (__LINE__,
1873 MHD_WEBSOCKET_FLAG_SERVER
1874 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1875 0,
1876 1,
1877 0,
1878 "\xA1\x85\x00\x00\x00\x00Hello",
1879 11,
1880 NULL,
1881 0,
1882 MHD_WEBSOCKET_STATUS_PROTOCOL_ERROR,
1883 MHD_WEBSOCKET_VALIDITY_INVALID,
1884 0);
1885 /* Fail test: RSV3 flag set */
1886 failed += test_decode_single (__LINE__,
1887 MHD_WEBSOCKET_FLAG_SERVER
1888 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1889 0,
1890 1,
1891 0,
1892 "\xC1\x85\x00\x00\x00\x00Hello",
1893 11,
1894 NULL,
1895 0,
1896 MHD_WEBSOCKET_STATUS_PROTOCOL_ERROR,
1897 MHD_WEBSOCKET_VALIDITY_INVALID,
1898 0);
1899
1900 /*
1901 ------------------------------------------------------------------------------
1902 invalid opcodes
1903 ------------------------------------------------------------------------------
1904 */
1905 /* Fail test: Invalid opcode 0 (0 is usually valid, but only if there was a data frame before) */
1906 failed += test_decode_single (__LINE__,
1907 MHD_WEBSOCKET_FLAG_SERVER
1908 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1909 0,
1910 1,
1911 0,
1912 "\x80\x85\x00\x00\x00\x00Hello",
1913 11,
1914 NULL,
1915 0,
1916 MHD_WEBSOCKET_STATUS_PROTOCOL_ERROR,
1917 MHD_WEBSOCKET_VALIDITY_INVALID,
1918 0);
1919 /* Fail test: Invalid opcode 3 */
1920 failed += test_decode_single (__LINE__,
1921 MHD_WEBSOCKET_FLAG_SERVER
1922 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1923 0,
1924 1,
1925 0,
1926 "\x83\x85\x00\x00\x00\x00Hello",
1927 11,
1928 NULL,
1929 0,
1930 MHD_WEBSOCKET_STATUS_PROTOCOL_ERROR,
1931 MHD_WEBSOCKET_VALIDITY_INVALID,
1932 0);
1933 /* Fail test: Invalid opcode 4 */
1934 failed += test_decode_single (__LINE__,
1935 MHD_WEBSOCKET_FLAG_SERVER
1936 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1937 0,
1938 1,
1939 0,
1940 "\x84\x85\x00\x00\x00\x00Hello",
1941 11,
1942 NULL,
1943 0,
1944 MHD_WEBSOCKET_STATUS_PROTOCOL_ERROR,
1945 MHD_WEBSOCKET_VALIDITY_INVALID,
1946 0);
1947 /* Fail test: Invalid opcode 5 */
1948 failed += test_decode_single (__LINE__,
1949 MHD_WEBSOCKET_FLAG_SERVER
1950 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1951 0,
1952 1,
1953 0,
1954 "\x85\x85\x00\x00\x00\x00Hello",
1955 11,
1956 NULL,
1957 0,
1958 MHD_WEBSOCKET_STATUS_PROTOCOL_ERROR,
1959 MHD_WEBSOCKET_VALIDITY_INVALID,
1960 0);
1961 /* Fail test: Invalid opcode 6 */
1962 failed += test_decode_single (__LINE__,
1963 MHD_WEBSOCKET_FLAG_SERVER
1964 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1965 0,
1966 1,
1967 0,
1968 "\x86\x85\x00\x00\x00\x00Hello",
1969 11,
1970 NULL,
1971 0,
1972 MHD_WEBSOCKET_STATUS_PROTOCOL_ERROR,
1973 MHD_WEBSOCKET_VALIDITY_INVALID,
1974 0);
1975 /* Fail test: Invalid opcode 7 */
1976 failed += test_decode_single (__LINE__,
1977 MHD_WEBSOCKET_FLAG_SERVER
1978 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1979 0,
1980 1,
1981 0,
1982 "\x87\x85\x00\x00\x00\x00Hello",
1983 11,
1984 NULL,
1985 0,
1986 MHD_WEBSOCKET_STATUS_PROTOCOL_ERROR,
1987 MHD_WEBSOCKET_VALIDITY_INVALID,
1988 0);
1989 /* Fail test: Invalid opcode 0x0B */
1990 failed += test_decode_single (__LINE__,
1991 MHD_WEBSOCKET_FLAG_SERVER
1992 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
1993 0,
1994 1,
1995 0,
1996 "\x8B\x85\x00\x00\x00\x00Hello",
1997 11,
1998 NULL,
1999 0,
2000 MHD_WEBSOCKET_STATUS_PROTOCOL_ERROR,
2001 MHD_WEBSOCKET_VALIDITY_INVALID,
2002 0);
2003 /* Fail test: Invalid opcode 0x0C */
2004 failed += test_decode_single (__LINE__,
2005 MHD_WEBSOCKET_FLAG_SERVER
2006 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2007 0,
2008 1,
2009 0,
2010 "\x8c\x85\x00\x00\x00\x00Hello",
2011 11,
2012 NULL,
2013 0,
2014 MHD_WEBSOCKET_STATUS_PROTOCOL_ERROR,
2015 MHD_WEBSOCKET_VALIDITY_INVALID,
2016 0);
2017 /* Fail test: Invalid opcode 0x0D */
2018 failed += test_decode_single (__LINE__,
2019 MHD_WEBSOCKET_FLAG_SERVER
2020 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2021 0,
2022 1,
2023 0,
2024 "\x8d\x85\x00\x00\x00\x00Hello",
2025 11,
2026 NULL,
2027 0,
2028 MHD_WEBSOCKET_STATUS_PROTOCOL_ERROR,
2029 MHD_WEBSOCKET_VALIDITY_INVALID,
2030 0);
2031 /* Fail test: Invalid opcode 0x0E */
2032 failed += test_decode_single (__LINE__,
2033 MHD_WEBSOCKET_FLAG_SERVER
2034 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2035 0,
2036 1,
2037 0,
2038 "\x8e\x85\x00\x00\x00\x00Hello",
2039 11,
2040 NULL,
2041 0,
2042 MHD_WEBSOCKET_STATUS_PROTOCOL_ERROR,
2043 MHD_WEBSOCKET_VALIDITY_INVALID,
2044 0);
2045 /* Fail test: Invalid opcode 0x0F */
2046 failed += test_decode_single (__LINE__,
2047 MHD_WEBSOCKET_FLAG_SERVER
2048 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2049 0,
2050 1,
2051 0,
2052 "\x8f\x85\x00\x00\x00\x00Hello",
2053 11,
2054 NULL,
2055 0,
2056 MHD_WEBSOCKET_STATUS_PROTOCOL_ERROR,
2057 MHD_WEBSOCKET_VALIDITY_INVALID,
2058 0);
2059
2060
2061 /*
2062 ------------------------------------------------------------------------------
2063 control frames without FIN flag
2064 ------------------------------------------------------------------------------
2065 */
2066 /* Fail test: Close frame without FIN flag */
2067 failed += test_decode_single (__LINE__,
2068 MHD_WEBSOCKET_FLAG_SERVER
2069 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2070 0,
2071 1,
2072 0,
2073 "\x08\x85\x00\x00\x00\x00Hello",
2074 11,
2075 NULL,
2076 0,
2077 MHD_WEBSOCKET_STATUS_PROTOCOL_ERROR,
2078 MHD_WEBSOCKET_VALIDITY_INVALID,
2079 0);
2080 /* Fail test: Ping frame without FIN flag */
2081 failed += test_decode_single (__LINE__,
2082 MHD_WEBSOCKET_FLAG_SERVER
2083 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2084 0,
2085 1,
2086 0,
2087 "\x09\x85\x00\x00\x00\x00Hello",
2088 11,
2089 NULL,
2090 0,
2091 MHD_WEBSOCKET_STATUS_PROTOCOL_ERROR,
2092 MHD_WEBSOCKET_VALIDITY_INVALID,
2093 0);
2094 /* Fail test: Pong frame without FIN flag */
2095 failed += test_decode_single (__LINE__,
2096 MHD_WEBSOCKET_FLAG_SERVER
2097 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2098 0,
2099 1,
2100 0,
2101 "\x0a\x85\x00\x00\x00\x00Hello",
2102 11,
2103 NULL,
2104 0,
2105 MHD_WEBSOCKET_STATUS_PROTOCOL_ERROR,
2106 MHD_WEBSOCKET_VALIDITY_INVALID,
2107 0);
2108
2109 /*
2110 ------------------------------------------------------------------------------
2111 length checks (without max_payload_len)
2112 ------------------------------------------------------------------------------
2113 */
2114 /* Edge test (success): 0 bytes of payload (requires 1 byte length) */
2115 failed += test_decode_single (__LINE__,
2116 MHD_WEBSOCKET_FLAG_SERVER
2117 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2118 0,
2119 1,
2120 0,
2121 "\x81\x80\x00\x00\x00\x00",
2122 6,
2123 NULL,
2124 0,
2125 MHD_WEBSOCKET_STATUS_TEXT_FRAME,
2126 MHD_WEBSOCKET_VALIDITY_VALID,
2127 6);
2128 /* Edge test (success): 1 byte of payload (requires 1 byte length) */
2129 failed += test_decode_single (__LINE__,
2130 MHD_WEBSOCKET_FLAG_SERVER
2131 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2132 0,
2133 1,
2134 0,
2135 "\x81\x81\x00\x00\x00\x00" "a",
2136 7,
2137 "a",
2138 1,
2139 MHD_WEBSOCKET_STATUS_TEXT_FRAME,
2140 MHD_WEBSOCKET_VALIDITY_VALID,
2141 7);
2142 /* Edge test (success): 125 bytes of payload (requires 1 byte length) */
2143 failed += test_decode_single (__LINE__,
2144 MHD_WEBSOCKET_FLAG_SERVER
2145 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2146 0,
2147 1,
2148 0,
2149 "\x81\xfd\x00\x00\x00\x00"
2150 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ012345678",
2151 131,
2152 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ012345678",
2153 125,
2154 MHD_WEBSOCKET_STATUS_TEXT_FRAME,
2155 MHD_WEBSOCKET_VALIDITY_VALID,
2156 131);
2157 /* Edge test (success): 126 bytes of payload (requires 2 byte length) */
2158 failed += test_decode_single (__LINE__,
2159 MHD_WEBSOCKET_FLAG_SERVER
2160 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2161 0,
2162 1,
2163 0,
2164 "\x81\xfe\x00\x7e\x00\x00\x00\x00"
2165 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789",
2166 134,
2167 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789",
2168 126,
2169 MHD_WEBSOCKET_STATUS_TEXT_FRAME,
2170 MHD_WEBSOCKET_VALIDITY_VALID,
2171 134);
2172 /* Edge test (success): 65535 bytes of payload (requires 2 byte length) */
2173 allocate_length_test_data (&buf1,
2174 &buf2,
2175 65535,
2176 "\x81\xfe\xff\xff\x00\x00\x00\x00",
2177 8);
2178 failed += test_decode_single (__LINE__,
2179 MHD_WEBSOCKET_FLAG_SERVER
2180 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2181 0,
2182 1,
2183 0,
2184 buf1,
2185 65535 + 8,
2186 buf2,
2187 65535,
2188 MHD_WEBSOCKET_STATUS_TEXT_FRAME,
2189 MHD_WEBSOCKET_VALIDITY_VALID,
2190 65535 + 8);
2191 /* Edge test (success): 65536 bytes of payload (requires 8 byte length) */
2192 allocate_length_test_data (&buf1,
2193 &buf2,
2194 65536,
2195 "\x81\xff\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00",
2196 14);
2197 failed += test_decode_single (__LINE__,
2198 MHD_WEBSOCKET_FLAG_SERVER
2199 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2200 0,
2201 1,
2202 0,
2203 buf1,
2204 65536 + 14,
2205 buf2,
2206 65536,
2207 MHD_WEBSOCKET_STATUS_TEXT_FRAME,
2208 MHD_WEBSOCKET_VALIDITY_VALID,
2209 65536 + 14);
2210 /* Regular test: 1 MB of payload */
2211 allocate_length_test_data (&buf1,
2212 &buf2,
2213 1048576,
2214 "\x81\xff\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00",
2215 14);
2216 failed += test_decode_single (__LINE__,
2217 MHD_WEBSOCKET_FLAG_SERVER
2218 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2219 0,
2220 1,
2221 0,
2222 buf1,
2223 1048576 + 14,
2224 buf2,
2225 1048576,
2226 MHD_WEBSOCKET_STATUS_TEXT_FRAME,
2227 MHD_WEBSOCKET_VALIDITY_VALID,
2228 1048576 + 14);
2229 /* Regular test: 100 MB of payload */
2230 allocate_length_test_data (&buf1,
2231 &buf2,
2232 104857600,
2233 "\x81\xff\x00\x00\x00\x00\x06\x40\x00\x00\x00\x00\x00\x00",
2234 14);
2235 failed += test_decode_single (__LINE__,
2236 MHD_WEBSOCKET_FLAG_SERVER
2237 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2238 0,
2239 1,
2240 0,
2241 buf1,
2242 104857600 + 14,
2243 buf2,
2244 104857600,
2245 MHD_WEBSOCKET_STATUS_TEXT_FRAME,
2246 MHD_WEBSOCKET_VALIDITY_VALID,
2247 104857600 + 14);
2248 if (NULL != buf1)
2249 {
2250 free (buf1);
2251 buf1 = NULL;
2252 }
2253 if (NULL != buf2)
2254 {
2255 free (buf2);
2256 buf2 = NULL;
2257 }
2258 /* Edge test (success): Maximum allowed length (here is only the header checked) */
2259 failed += test_decode_single (__LINE__,
2260 MHD_WEBSOCKET_FLAG_SERVER
2261 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2262 0,
2263 1,
2264 0,
2265 "\x81\xff\x7f\xff\xff\xff\xff\xff\xff\xff",
2266 10,
2267 NULL,
2268 0,
2269 MHD_WEBSOCKET_STATUS_OK,
2270 MHD_WEBSOCKET_VALIDITY_VALID,
2271 10);
2272 /* Edge test (fail): Too big payload length */
2273 failed += test_decode_single (__LINE__,
2274 MHD_WEBSOCKET_FLAG_SERVER
2275 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2276 0,
2277 1,
2278 0,
2279 "\x81\xff\x80\x00\x00\x00\x00\x00\x00\x00",
2280 10,
2281 NULL,
2282 0,
2283 MHD_WEBSOCKET_STATUS_PROTOCOL_ERROR,
2284 MHD_WEBSOCKET_VALIDITY_INVALID,
2285 10);
2286 /* Edge test (fail): Too big payload length */
2287 failed += test_decode_single (__LINE__,
2288 MHD_WEBSOCKET_FLAG_SERVER
2289 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2290 0,
2291 1,
2292 0,
2293 "\x81\xff\xff\xff\xff\xff\xff\xff\xff\xff",
2294 10,
2295 NULL,
2296 0,
2297 MHD_WEBSOCKET_STATUS_PROTOCOL_ERROR,
2298 MHD_WEBSOCKET_VALIDITY_INVALID,
2299 10);
2300 /* Fail test: Not the smallest payload length syntax used (2 byte instead of 1 byte) */
2301 failed += test_decode_single (__LINE__,
2302 MHD_WEBSOCKET_FLAG_SERVER
2303 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2304 0,
2305 1,
2306 0,
2307 "\x81\xfe\x00\x05\x00\x00\x00\x00" "abcde",
2308 13,
2309 NULL,
2310 0,
2311 MHD_WEBSOCKET_STATUS_PROTOCOL_ERROR,
2312 MHD_WEBSOCKET_VALIDITY_INVALID,
2313 4);
2314 /* Fail test: Not the smallest payload length syntax used (8 byte instead of 1 byte) */
2315 failed += test_decode_single (__LINE__,
2316 MHD_WEBSOCKET_FLAG_SERVER
2317 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2318 0,
2319 1,
2320 0,
2321 "\x81\xff\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x00"
2322 "abcde",
2323 13,
2324 NULL,
2325 0,
2326 MHD_WEBSOCKET_STATUS_PROTOCOL_ERROR,
2327 MHD_WEBSOCKET_VALIDITY_INVALID,
2328 10);
2329 /* Fail test: Not the smallest payload length syntax used (8 byte instead of 2 byte) */
2330 failed += test_decode_single (__LINE__,
2331 MHD_WEBSOCKET_FLAG_SERVER
2332 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2333 0,
2334 1,
2335 0,
2336 "\x81\xff\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00"
2337 "abcde",
2338 13,
2339 NULL,
2340 0,
2341 MHD_WEBSOCKET_STATUS_PROTOCOL_ERROR,
2342 MHD_WEBSOCKET_VALIDITY_INVALID,
2343 10);
2344
2345 /*
2346 ------------------------------------------------------------------------------
2347 length checks (with max_payload_len)
2348 ------------------------------------------------------------------------------
2349 */
2350 /* Regular test: Frame with less payload than specified as limit */
2351 failed += test_decode_single (__LINE__,
2352 MHD_WEBSOCKET_FLAG_SERVER
2353 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2354 100,
2355 1,
2356 0,
2357 "\x81\x85\x00\x00\x00\x00" "Hello",
2358 11,
2359 "Hello",
2360 5,
2361 MHD_WEBSOCKET_STATUS_TEXT_FRAME,
2362 MHD_WEBSOCKET_VALIDITY_VALID,
2363 11);
2364 /* Edge test (success): Frame with the same payload as the specified limit */
2365 failed += test_decode_single (__LINE__,
2366 MHD_WEBSOCKET_FLAG_SERVER
2367 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2368 5,
2369 1,
2370 0,
2371 "\x81\x85\x00\x00\x00\x00" "Hello",
2372 11,
2373 "Hello",
2374 5,
2375 MHD_WEBSOCKET_STATUS_TEXT_FRAME,
2376 MHD_WEBSOCKET_VALIDITY_VALID,
2377 11);
2378 /* Edge test (fail): Frame with more payload than specified as limit */
2379 failed += test_decode_single (__LINE__,
2380 MHD_WEBSOCKET_FLAG_SERVER
2381 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2382 4,
2383 1,
2384 0,
2385 "\x81\x85\x00\x00\x00\x00" "Hello",
2386 11,
2387 NULL,
2388 0,
2389 MHD_WEBSOCKET_STATUS_MAXIMUM_SIZE_EXCEEDED,
2390 MHD_WEBSOCKET_VALIDITY_INVALID,
2391 2);
2392 /* Regular test: Fragmented frames with the sum of payload less than specified as limit */
2393 failed += test_decode_single (__LINE__,
2394 MHD_WEBSOCKET_FLAG_SERVER
2395 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2396 100,
2397 1,
2398 0,
2399 "\x01\x83\x00\x00\x00\x00"
2400 "Hel\x80\x82\x00\x00\x00\x00" "lo",
2401 17,
2402 "Hello",
2403 5,
2404 MHD_WEBSOCKET_STATUS_TEXT_FRAME,
2405 MHD_WEBSOCKET_VALIDITY_VALID,
2406 17);
2407 /* Edge test (success): Fragmented frames with the sum of payload equal to the specified limit */
2408 failed += test_decode_single (__LINE__,
2409 MHD_WEBSOCKET_FLAG_SERVER
2410 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2411 5,
2412 1,
2413 0,
2414 "\x01\x83\x00\x00\x00\x00"
2415 "Hel\x80\x82\x00\x00\x00\x00" "lo",
2416 17,
2417 "Hello",
2418 5,
2419 MHD_WEBSOCKET_STATUS_TEXT_FRAME,
2420 MHD_WEBSOCKET_VALIDITY_VALID,
2421 17);
2422 /* Edge test (fail): Fragmented frames with the sum of payload more than specified as limit */
2423 failed += test_decode_single (__LINE__,
2424 MHD_WEBSOCKET_FLAG_SERVER
2425 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2426 4,
2427 1,
2428 0,
2429 "\x01\x83\x00\x00\x00\x00"
2430 "Hel\x80\x82\x00\x00\x00\x00" "lo",
2431 17,
2432 NULL,
2433 0,
2434 MHD_WEBSOCKET_STATUS_MAXIMUM_SIZE_EXCEEDED,
2435 MHD_WEBSOCKET_VALIDITY_INVALID,
2436 15);
2437 /* Edge test (success): Fragmented frames with the sum of payload greater than
2438 the specified limit, but we take fragments (one call) */
2439 failed += test_decode_single (__LINE__,
2440 MHD_WEBSOCKET_FLAG_SERVER
2441 | MHD_WEBSOCKET_FLAG_WANT_FRAGMENTS,
2442 5,
2443 1,
2444 0,
2445 "\x01\x83\x00\x00\x00\x00"
2446 "Hel\x80\x82\x00\x00\x00\x00" "lo",
2447 17,
2448 "Hel",
2449 3,
2450 MHD_WEBSOCKET_STATUS_TEXT_FRAGMENT,
2451 MHD_WEBSOCKET_VALIDITY_VALID,
2452 9);
2453 /* Edge test (success): Fragmented frames with the sum of payload greater than
2454 the specified limit, but we take fragments (two calls) */
2455 failed += test_decode_single (__LINE__,
2456 MHD_WEBSOCKET_FLAG_SERVER
2457 | MHD_WEBSOCKET_FLAG_WANT_FRAGMENTS,
2458 5,
2459 2,
2460 0,
2461 "\x01\x83\x00\x00\x00\x00"
2462 "Hel\x80\x82\x00\x00\x00\x00" "lo",
2463 17,
2464 "lo",
2465 2,
2466 MHD_WEBSOCKET_STATUS_TEXT_LAST_FRAGMENT,
2467 MHD_WEBSOCKET_VALIDITY_VALID,
2468 17);
2469
2470 /*
2471 ------------------------------------------------------------------------------
2472 UTF-8 sequences
2473 ------------------------------------------------------------------------------
2474 */
2475 /* Regular test: No UTF-8 characters */
2476 failed += test_decode_single (__LINE__,
2477 MHD_WEBSOCKET_FLAG_SERVER
2478 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2479 0,
2480 1,
2481 0,
2482 "\x81\x8A\x00\x00\x00\x00 a ",
2483 16,
2484 " a ",
2485 10,
2486 MHD_WEBSOCKET_STATUS_TEXT_FRAME,
2487 MHD_WEBSOCKET_VALIDITY_VALID,
2488 16);
2489 /* Fail test: A UTF-8 tail character without sequence start character */
2490 failed += test_decode_single (__LINE__,
2491 MHD_WEBSOCKET_FLAG_SERVER
2492 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2493 0,
2494 1,
2495 0,
2496 "\x81\x8A\x00\x00\x00\x00 \xA4 ",
2497 16,
2498 NULL,
2499 0,
2500 MHD_WEBSOCKET_STATUS_UTF8_ENCODING_ERROR,
2501 MHD_WEBSOCKET_VALIDITY_INVALID,
2502 7);
2503 /* Regular test: A two byte UTF-8 sequence */
2504 failed += test_decode_single (__LINE__,
2505 MHD_WEBSOCKET_FLAG_SERVER
2506 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2507 0,
2508 1,
2509 0,
2510 "\x81\x8A\x00\x00\x00\x00 \xC3\xA4 ",
2511 16,
2512 " \xC3\xA4 ",
2513 10,
2514 MHD_WEBSOCKET_STATUS_TEXT_FRAME,
2515 MHD_WEBSOCKET_VALIDITY_VALID,
2516 16);
2517 /* Fail test: A broken two byte UTF-8 sequence */
2518 failed += test_decode_single (__LINE__,
2519 MHD_WEBSOCKET_FLAG_SERVER
2520 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2521 0,
2522 1,
2523 0,
2524 "\x81\x8A\x00\x00\x00\x00 \xC3 ",
2525 16,
2526 NULL,
2527 0,
2528 MHD_WEBSOCKET_STATUS_UTF8_ENCODING_ERROR,
2529 MHD_WEBSOCKET_VALIDITY_INVALID,
2530 8);
2531 /* Fail test: A two byte UTF-8 sequence with one UTF-8 tail too much */
2532 failed += test_decode_single (__LINE__,
2533 MHD_WEBSOCKET_FLAG_SERVER
2534 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2535 0,
2536 1,
2537 0,
2538 "\x81\x8A\x00\x00\x00\x00 \xC3\xA4\xA4 ",
2539 16,
2540 NULL,
2541 0,
2542 MHD_WEBSOCKET_STATUS_UTF8_ENCODING_ERROR,
2543 MHD_WEBSOCKET_VALIDITY_INVALID,
2544 9);
2545 /* Regular test: A three byte UTF-8 sequence */
2546 failed += test_decode_single (__LINE__,
2547 MHD_WEBSOCKET_FLAG_SERVER
2548 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2549 0,
2550 1,
2551 0,
2552 "\x81\x8A\x00\x00\x00\x00 \xEF\x8F\x8F ",
2553 16,
2554 " \xEF\x8F\x8F ",
2555 10,
2556 MHD_WEBSOCKET_STATUS_TEXT_FRAME,
2557 MHD_WEBSOCKET_VALIDITY_VALID,
2558 16);
2559 /* Fail test: A broken byte UTF-8 sequence (two of three bytes) */
2560 failed += test_decode_single (__LINE__,
2561 MHD_WEBSOCKET_FLAG_SERVER
2562 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2563 0,
2564 1,
2565 0,
2566 "\x81\x8A\x00\x00\x00\x00 \xEF\x8F ",
2567 16,
2568 NULL,
2569 0,
2570 MHD_WEBSOCKET_STATUS_UTF8_ENCODING_ERROR,
2571 MHD_WEBSOCKET_VALIDITY_INVALID,
2572 9);
2573 /* Fail test: A broken byte UTF-8 sequence (one of three bytes) */
2574 failed += test_decode_single (__LINE__,
2575 MHD_WEBSOCKET_FLAG_SERVER
2576 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2577 0,
2578 1,
2579 0,
2580 "\x81\x8A\x00\x00\x00\x00 \xEF ",
2581 16,
2582 NULL,
2583 0,
2584 MHD_WEBSOCKET_STATUS_UTF8_ENCODING_ERROR,
2585 MHD_WEBSOCKET_VALIDITY_INVALID,
2586 8);
2587 /* Fail test: A three byte UTF-8 sequence followed by one UTF-8 tail byte */
2588 failed += test_decode_single (__LINE__,
2589 MHD_WEBSOCKET_FLAG_SERVER
2590 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2591 0,
2592 1,
2593 0,
2594 "\x81\x8A\x00\x00\x00\x00 \xEF\x8F\x8F\x8F ",
2595 16,
2596 NULL,
2597 0,
2598 MHD_WEBSOCKET_STATUS_UTF8_ENCODING_ERROR,
2599 MHD_WEBSOCKET_VALIDITY_INVALID,
2600 10);
2601 /* Regular test: A four byte UTF-8 sequence */
2602 failed += test_decode_single (__LINE__,
2603 MHD_WEBSOCKET_FLAG_SERVER
2604 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2605 0,
2606 1,
2607 0,
2608 "\x81\x8A\x00\x00\x00\x00 \xF2\x8F\x8F\x8F ",
2609 16,
2610 " \xF2\x8F\x8F\x8F ",
2611 10,
2612 MHD_WEBSOCKET_STATUS_TEXT_FRAME,
2613 MHD_WEBSOCKET_VALIDITY_VALID,
2614 16);
2615 /* Fail test: A broken four byte UTF-8 sequence (three of four bytes) */
2616 failed += test_decode_single (__LINE__,
2617 MHD_WEBSOCKET_FLAG_SERVER
2618 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2619 0,
2620 1,
2621 0,
2622 "\x81\x8A\x00\x00\x00\x00 \xF2\x8F\x8F ",
2623 16,
2624 NULL,
2625 0,
2626 MHD_WEBSOCKET_STATUS_UTF8_ENCODING_ERROR,
2627 MHD_WEBSOCKET_VALIDITY_INVALID,
2628 10);
2629 /* Fail test: A broken four byte UTF-8 sequence (two of four bytes) */
2630 failed += test_decode_single (__LINE__,
2631 MHD_WEBSOCKET_FLAG_SERVER
2632 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2633 0,
2634 1,
2635 0,
2636 "\x81\x8A\x00\x00\x00\x00 \xF2\x8F ",
2637 16,
2638 NULL,
2639 0,
2640 MHD_WEBSOCKET_STATUS_UTF8_ENCODING_ERROR,
2641 MHD_WEBSOCKET_VALIDITY_INVALID,
2642 9);
2643 /* Fail test: A broken four byte UTF-8 sequence (one of four bytes) */
2644 failed += test_decode_single (__LINE__,
2645 MHD_WEBSOCKET_FLAG_SERVER
2646 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2647 0,
2648 1,
2649 0,
2650 "\x81\x8A\x00\x00\x00\x00 \xF2 ",
2651 16,
2652 NULL,
2653 0,
2654 MHD_WEBSOCKET_STATUS_UTF8_ENCODING_ERROR,
2655 MHD_WEBSOCKET_VALIDITY_INVALID,
2656 8);
2657 /* Fail test: A four byte UTF-8 sequence followed by UTF-8 tail */
2658 failed += test_decode_single (__LINE__,
2659 MHD_WEBSOCKET_FLAG_SERVER
2660 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2661 0,
2662 1,
2663 0,
2664 "\x81\x8A\x00\x00\x00\x00 \xF2\x8F\x8F\x8F\x8F ",
2665 16,
2666 NULL,
2667 0,
2668 MHD_WEBSOCKET_STATUS_UTF8_ENCODING_ERROR,
2669 MHD_WEBSOCKET_VALIDITY_INVALID,
2670 11);
2671 /* Fail test: A five byte UTF-8 sequence (only up to four bytes allowed) */
2672 failed += test_decode_single (__LINE__,
2673 MHD_WEBSOCKET_FLAG_SERVER
2674 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2675 0,
2676 1,
2677 0,
2678 "\x81\x8A\x00\x00\x00\x00 \xFB\x8F\x8F\x8F\x8F ",
2679 16,
2680 NULL,
2681 0,
2682 MHD_WEBSOCKET_STATUS_UTF8_ENCODING_ERROR,
2683 MHD_WEBSOCKET_VALIDITY_INVALID,
2684 7);
2685 /* Fail test: A six byte UTF-8 sequence (only up to four bytes allowed) */
2686 failed += test_decode_single (__LINE__,
2687 MHD_WEBSOCKET_FLAG_SERVER
2688 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2689 0,
2690 1,
2691 0,
2692 "\x81\x8A\x00\x00\x00\x00 \xFD\x8F\x8F\x8F\x8F\x8F ",
2693 16,
2694 NULL,
2695 0,
2696 MHD_WEBSOCKET_STATUS_UTF8_ENCODING_ERROR,
2697 MHD_WEBSOCKET_VALIDITY_INVALID,
2698 7);
2699 /* Fail test: A seven byte UTF-8 sequence (only up to four bytes allowed) */
2700 failed += test_decode_single (__LINE__,
2701 MHD_WEBSOCKET_FLAG_SERVER
2702 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2703 0,
2704 1,
2705 0,
2706 "\x81\x8A\x00\x00\x00\x00 \xFE\x8F\x8F\x8F\x8F\x8F\x8F ",
2707 16,
2708 NULL,
2709 0,
2710 MHD_WEBSOCKET_STATUS_UTF8_ENCODING_ERROR,
2711 MHD_WEBSOCKET_VALIDITY_INVALID,
2712 7);
2713 /* Fail test: A eight byte UTF-8 sequence (only up to four bytes allowed) */
2714 failed += test_decode_single (__LINE__,
2715 MHD_WEBSOCKET_FLAG_SERVER
2716 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2717 0,
2718 1,
2719 0,
2720 "\x81\x8A\x00\x00\x00\x00 \xFF\x8F\x8F\x8F\x8F\x8F\x8F\x8F ",
2721 16,
2722 NULL,
2723 0,
2724 MHD_WEBSOCKET_STATUS_UTF8_ENCODING_ERROR,
2725 MHD_WEBSOCKET_VALIDITY_INVALID,
2726 7);
2727 /* Edge test (success): The maxium allowed UTF-8 character */
2728 failed += test_decode_single (__LINE__,
2729 MHD_WEBSOCKET_FLAG_SERVER
2730 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2731 0,
2732 1,
2733 0,
2734 "\x81\x8A\x00\x00\x00\x00 \xF4\x8F\xBF\xBF ",
2735 16,
2736 " \xF4\x8F\xBF\xBF ",
2737 10,
2738 MHD_WEBSOCKET_STATUS_TEXT_FRAME,
2739 MHD_WEBSOCKET_VALIDITY_VALID,
2740 16);
2741 /* Edge test (fail): The maxium allowed UTF-8 character + 1 */
2742 failed += test_decode_single (__LINE__,
2743 MHD_WEBSOCKET_FLAG_SERVER
2744 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2745 0,
2746 1,
2747 0,
2748 "\x81\x8A\x00\x00\x00\x00 \xF4\x90\x80\x80 ",
2749 16,
2750 NULL,
2751 0,
2752 MHD_WEBSOCKET_STATUS_UTF8_ENCODING_ERROR,
2753 MHD_WEBSOCKET_VALIDITY_INVALID,
2754 8);
2755 /* Edge test (success): The last valid UTF8-1 character */
2756 failed += test_decode_single (__LINE__,
2757 MHD_WEBSOCKET_FLAG_SERVER
2758 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2759 0,
2760 1,
2761 0,
2762 "\x81\x8A\x00\x00\x00\x00 \x7F ",
2763 16,
2764 " \x7F ",
2765 10,
2766 MHD_WEBSOCKET_STATUS_TEXT_FRAME,
2767 MHD_WEBSOCKET_VALIDITY_VALID,
2768 16);
2769 /* Edge test (fail): The value after the last valid UTF8-1 character */
2770 failed += test_decode_single (__LINE__,
2771 MHD_WEBSOCKET_FLAG_SERVER
2772 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2773 0,
2774 1,
2775 0,
2776 "\x81\x8A\x00\x00\x00\x00 \x80 ",
2777 16,
2778 NULL,
2779 0,
2780 MHD_WEBSOCKET_STATUS_UTF8_ENCODING_ERROR,
2781 MHD_WEBSOCKET_VALIDITY_INVALID,
2782 7);
2783 /* Edge test (fail): The value before the first valid UTF8-2 character */
2784 failed += test_decode_single (__LINE__,
2785 MHD_WEBSOCKET_FLAG_SERVER
2786 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2787 0,
2788 1,
2789 0,
2790 "\x81\x8A\x00\x00\x00\x00 \xC1\x80 ",
2791 16,
2792 NULL,
2793 0,
2794 MHD_WEBSOCKET_STATUS_UTF8_ENCODING_ERROR,
2795 MHD_WEBSOCKET_VALIDITY_INVALID,
2796 7);
2797 /* Edge test (success): The first valid UTF8-2 character */
2798 failed += test_decode_single (__LINE__,
2799 MHD_WEBSOCKET_FLAG_SERVER
2800 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2801 0,
2802 1,
2803 0,
2804 "\x81\x8A\x00\x00\x00\x00 \xC2\x80 ",
2805 16,
2806 " \xC2\x80 ",
2807 10,
2808 MHD_WEBSOCKET_STATUS_TEXT_FRAME,
2809 MHD_WEBSOCKET_VALIDITY_VALID,
2810 16);
2811 /* Edge test (success): The last valid UTF8-2 character */
2812 failed += test_decode_single (__LINE__,
2813 MHD_WEBSOCKET_FLAG_SERVER
2814 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2815 0,
2816 1,
2817 0,
2818 "\x81\x8A\x00\x00\x00\x00 \xDF\xBF ",
2819 16,
2820 " \xDF\xBF ",
2821 10,
2822 MHD_WEBSOCKET_STATUS_TEXT_FRAME,
2823 MHD_WEBSOCKET_VALIDITY_VALID,
2824 16);
2825 /* Edge test (fail): The value after the lst valid UTF8-2 character */
2826 failed += test_decode_single (__LINE__,
2827 MHD_WEBSOCKET_FLAG_SERVER
2828 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2829 0,
2830 1,
2831 0,
2832 "\x81\x8A\x00\x00\x00\x00 \xE0\x80 ",
2833 16,
2834 NULL,
2835 0,
2836 MHD_WEBSOCKET_STATUS_UTF8_ENCODING_ERROR,
2837 MHD_WEBSOCKET_VALIDITY_INVALID,
2838 8);
2839 /* Edge test (fail): The value before the first valid UTF8-3 character (tail 1) */
2840 failed += test_decode_single (__LINE__,
2841 MHD_WEBSOCKET_FLAG_SERVER
2842 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2843 0,
2844 1,
2845 0,
2846 "\x81\x8A\x00\x00\x00\x00 \xE0\x9F\x80 ",
2847 16,
2848 NULL,
2849 0,
2850 MHD_WEBSOCKET_STATUS_UTF8_ENCODING_ERROR,
2851 MHD_WEBSOCKET_VALIDITY_INVALID,
2852 8);
2853 /* Edge test (success): The first valid UTF8-3 character (tail 1) */
2854 failed += test_decode_single (__LINE__,
2855 MHD_WEBSOCKET_FLAG_SERVER
2856 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2857 0,
2858 1,
2859 0,
2860 "\x81\x8A\x00\x00\x00\x00 \xE0\xA0\x80 ",
2861 16,
2862 " \xE0\xA0\x80 ",
2863 10,
2864 MHD_WEBSOCKET_STATUS_TEXT_FRAME,
2865 MHD_WEBSOCKET_VALIDITY_VALID,
2866 16);
2867 /* Edge test (success): The last valid UTF8-3 character (tail 1) */
2868 failed += test_decode_single (__LINE__,
2869 MHD_WEBSOCKET_FLAG_SERVER
2870 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2871 0,
2872 1,
2873 0,
2874 "\x81\x8A\x00\x00\x00\x00 \xE0\xBF\xBF ",
2875 16,
2876 " \xE0\xBF\xBF ",
2877 10,
2878 MHD_WEBSOCKET_STATUS_TEXT_FRAME,
2879 MHD_WEBSOCKET_VALIDITY_VALID,
2880 16);
2881 /* Edge test (fail): The value after the first valid UTF8-3 character (tail 1) */
2882 failed += test_decode_single (__LINE__,
2883 MHD_WEBSOCKET_FLAG_SERVER
2884 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2885 0,
2886 1,
2887 0,
2888 "\x81\x8A\x00\x00\x00\x00 \xE0\xC0\x80 ",
2889 16,
2890 NULL,
2891 0,
2892 MHD_WEBSOCKET_STATUS_UTF8_ENCODING_ERROR,
2893 MHD_WEBSOCKET_VALIDITY_INVALID,
2894 8);
2895 /* Edge test (success): The first valid UTF8-3 character (tail 2) */
2896 failed += test_decode_single (__LINE__,
2897 MHD_WEBSOCKET_FLAG_SERVER
2898 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2899 0,
2900 1,
2901 0,
2902 "\x81\x8A\x00\x00\x00\x00 \xE1\x80\x80 ",
2903 16,
2904 " \xE1\x80\x80 ",
2905 10,
2906 MHD_WEBSOCKET_STATUS_TEXT_FRAME,
2907 MHD_WEBSOCKET_VALIDITY_VALID,
2908 16);
2909 /* Edge test (success): The last valid UTF8-3 character (tail 2) */
2910 failed += test_decode_single (__LINE__,
2911 MHD_WEBSOCKET_FLAG_SERVER
2912 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2913 0,
2914 1,
2915 0,
2916 "\x81\x8A\x00\x00\x00\x00 \xEC\xBF\xBF ",
2917 16,
2918 " \xEC\xBF\xBF ",
2919 10,
2920 MHD_WEBSOCKET_STATUS_TEXT_FRAME,
2921 MHD_WEBSOCKET_VALIDITY_VALID,
2922 16);
2923 /* Edge test (fail): The value after the last valid UTF8-3 character (tail 2) */
2924 failed += test_decode_single (__LINE__,
2925 MHD_WEBSOCKET_FLAG_SERVER
2926 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2927 0,
2928 1,
2929 0,
2930 "\x81\x8A\x00\x00\x00\x00 \xEC\xC0\xBF ",
2931 16,
2932 NULL,
2933 0,
2934 MHD_WEBSOCKET_STATUS_UTF8_ENCODING_ERROR,
2935 MHD_WEBSOCKET_VALIDITY_INVALID,
2936 8);
2937 /* Edge test (fail): The value before the first valid UTF8-3 character (tail 3) */
2938 failed += test_decode_single (__LINE__,
2939 MHD_WEBSOCKET_FLAG_SERVER
2940 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2941 0,
2942 1,
2943 0,
2944 "\x81\x8A\x00\x00\x00\x00 \xED\x7F\x80 ",
2945 16,
2946 NULL,
2947 0,
2948 MHD_WEBSOCKET_STATUS_UTF8_ENCODING_ERROR,
2949 MHD_WEBSOCKET_VALIDITY_INVALID,
2950 8);
2951 /* Edge test (success): The first valid UTF8-3 character (tail 3) */
2952 failed += test_decode_single (__LINE__,
2953 MHD_WEBSOCKET_FLAG_SERVER
2954 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2955 0,
2956 1,
2957 0,
2958 "\x81\x8A\x00\x00\x00\x00 \xED\x80\x80 ",
2959 16,
2960 " \xED\x80\x80 ",
2961 10,
2962 MHD_WEBSOCKET_STATUS_TEXT_FRAME,
2963 MHD_WEBSOCKET_VALIDITY_VALID,
2964 16);
2965 /* Edge test (success): The last valid UTF8-3 character (tail 3) */
2966 failed += test_decode_single (__LINE__,
2967 MHD_WEBSOCKET_FLAG_SERVER
2968 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2969 0,
2970 1,
2971 0,
2972 "\x81\x8A\x00\x00\x00\x00 \xED\x9F\xBF ",
2973 16,
2974 " \xED\x9F\xBF ",
2975 10,
2976 MHD_WEBSOCKET_STATUS_TEXT_FRAME,
2977 MHD_WEBSOCKET_VALIDITY_VALID,
2978 16);
2979 /* Edge test (fail): The value after the last valid UTF8-3 character (tail 3) */
2980 failed += test_decode_single (__LINE__,
2981 MHD_WEBSOCKET_FLAG_SERVER
2982 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2983 0,
2984 1,
2985 0,
2986 "\x81\x8A\x00\x00\x00\x00 \xED\xA0\x80 ",
2987 16,
2988 NULL,
2989 0,
2990 MHD_WEBSOCKET_STATUS_UTF8_ENCODING_ERROR,
2991 MHD_WEBSOCKET_VALIDITY_INVALID,
2992 8);
2993 /* Edge test (fail): The value before the first valid UTF8-3 character (tail 4) */
2994 failed += test_decode_single (__LINE__,
2995 MHD_WEBSOCKET_FLAG_SERVER
2996 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
2997 0,
2998 1,
2999 0,
3000 "\x81\x8A\x00\x00\x00\x00 \xEE\x7F\x80 ",
3001 16,
3002 NULL,
3003 0,
3004 MHD_WEBSOCKET_STATUS_UTF8_ENCODING_ERROR,
3005 MHD_WEBSOCKET_VALIDITY_INVALID,
3006 8);
3007 /* Edge test (success): The first valid UTF8-3 character (tail 4) */
3008 failed += test_decode_single (__LINE__,
3009 MHD_WEBSOCKET_FLAG_SERVER
3010 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
3011 0,
3012 1,
3013 0,
3014 "\x81\x8A\x00\x00\x00\x00 \xEE\x80\x80 ",
3015 16,
3016 " \xEE\x80\x80 ",
3017 10,
3018 MHD_WEBSOCKET_STATUS_TEXT_FRAME,
3019 MHD_WEBSOCKET_VALIDITY_VALID,
3020 16);
3021 /* Edge test (success): The last valid UTF8-3 character (tail 4) */
3022 failed += test_decode_single (__LINE__,
3023 MHD_WEBSOCKET_FLAG_SERVER
3024 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
3025 0,
3026 1,
3027 0,
3028 "\x81\x8A\x00\x00\x00\x00 \xEF\xBF\xBF ",
3029 16,
3030 " \xEF\xBF\xBF ",
3031 10,
3032 MHD_WEBSOCKET_STATUS_TEXT_FRAME,
3033 MHD_WEBSOCKET_VALIDITY_VALID,
3034 16);
3035 /* Edge test (fail): The value after the last valid UTF8-3 character (tail 4) */
3036 failed += test_decode_single (__LINE__,
3037 MHD_WEBSOCKET_FLAG_SERVER
3038 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
3039 0,
3040 1,
3041 0,
3042 "\x81\x8A\x00\x00\x00\x00 \xEF\xBF\xC0 ",
3043 16,
3044 NULL,
3045 0,
3046 MHD_WEBSOCKET_STATUS_UTF8_ENCODING_ERROR,
3047 MHD_WEBSOCKET_VALIDITY_INVALID,
3048 9);
3049 /* Edge test (fail): The value after the last valid UTF8-3 character (tail 4) #2 */
3050 failed += test_decode_single (__LINE__,
3051 MHD_WEBSOCKET_FLAG_SERVER
3052 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
3053 0,
3054 1,
3055 0,
3056 "\x81\x8A\x00\x00\x00\x00 \xEF\xC0\xBF ",
3057 16,
3058 NULL,
3059 0,
3060 MHD_WEBSOCKET_STATUS_UTF8_ENCODING_ERROR,
3061 MHD_WEBSOCKET_VALIDITY_INVALID,
3062 8);
3063 /* Edge test (fail): The value before the first valid UTF8-4 character (tail 1) */
3064 failed += test_decode_single (__LINE__,
3065 MHD_WEBSOCKET_FLAG_SERVER
3066 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
3067 0,
3068 1,
3069 0,
3070 "\x81\x8A\x00\x00\x00\x00 \xF0\x8F\x80\x80 ",
3071 16,
3072 NULL,
3073 0,
3074 MHD_WEBSOCKET_STATUS_UTF8_ENCODING_ERROR,
3075 MHD_WEBSOCKET_VALIDITY_INVALID,
3076 8);
3077 /* Edge test (success): The first valid UTF8-4 character (tail 1) */
3078 failed += test_decode_single (__LINE__,
3079 MHD_WEBSOCKET_FLAG_SERVER
3080 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
3081 0,
3082 1,
3083 0,
3084 "\x81\x8A\x00\x00\x00\x00 \xF0\x90\x80\x80 ",
3085 16,
3086 " \xF0\x90\x80\x80 ",
3087 10,
3088 MHD_WEBSOCKET_STATUS_TEXT_FRAME,
3089 MHD_WEBSOCKET_VALIDITY_VALID,
3090 16);
3091 /* Edge test (success): The last valid UTF8-4 character (tail 1) */
3092 failed += test_decode_single (__LINE__,
3093 MHD_WEBSOCKET_FLAG_SERVER
3094 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
3095 0,
3096 1,
3097 0,
3098 "\x81\x8A\x00\x00\x00\x00 \xF0\xBF\xBF\xBF ",
3099 16,
3100 " \xF0\xBF\xBF\xBF ",
3101 10,
3102 MHD_WEBSOCKET_STATUS_TEXT_FRAME,
3103 MHD_WEBSOCKET_VALIDITY_VALID,
3104 16);
3105 /* Edge test (success): The first valid UTF8-4 character (tail 2) */
3106 failed += test_decode_single (__LINE__,
3107 MHD_WEBSOCKET_FLAG_SERVER
3108 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
3109 0,
3110 1,
3111 0,
3112 "\x81\x8A\x00\x00\x00\x00 \xF1\x80\x80\x80 ",
3113 16,
3114 " \xF1\x80\x80\x80 ",
3115 10,
3116 MHD_WEBSOCKET_STATUS_TEXT_FRAME,
3117 MHD_WEBSOCKET_VALIDITY_VALID,
3118 16);
3119 /* Edge test (success): The last valid UTF8-4 character (tail 2) */
3120 failed += test_decode_single (__LINE__,
3121 MHD_WEBSOCKET_FLAG_SERVER
3122 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
3123 0,
3124 1,
3125 0,
3126 "\x81\x8A\x00\x00\x00\x00 \xF3\xBF\xBF\xBF ",
3127 16,
3128 " \xF3\xBF\xBF\xBF ",
3129 10,
3130 MHD_WEBSOCKET_STATUS_TEXT_FRAME,
3131 MHD_WEBSOCKET_VALIDITY_VALID,
3132 16);
3133 /* Edge test (fail): A value before the last valid UTF8-4 character in the second byte (tail 2) */
3134 failed += test_decode_single (__LINE__,
3135 MHD_WEBSOCKET_FLAG_SERVER
3136 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
3137 0,
3138 1,
3139 0,
3140 "\x81\x8A\x00\x00\x00\x00 \xF3\x7F\x80\x80 ",
3141 16,
3142 NULL,
3143 0,
3144 MHD_WEBSOCKET_STATUS_UTF8_ENCODING_ERROR,
3145 MHD_WEBSOCKET_VALIDITY_INVALID,
3146 8);
3147 /* Edge test (fail): A value after the last valid UTF8-4 character in the second byte (tail 2) */
3148 failed += test_decode_single (__LINE__,
3149 MHD_WEBSOCKET_FLAG_SERVER
3150 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
3151 0,
3152 1,
3153 0,
3154 "\x81\x8A\x00\x00\x00\x00 \xF3\xC0\x80\x80 ",
3155 16,
3156 NULL,
3157 0,
3158 MHD_WEBSOCKET_STATUS_UTF8_ENCODING_ERROR,
3159 MHD_WEBSOCKET_VALIDITY_INVALID,
3160 8);
3161 /* Edge test (success): The first valid UTF8-4 character (tail 3) */
3162 failed += test_decode_single (__LINE__,
3163 MHD_WEBSOCKET_FLAG_SERVER
3164 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
3165 0,
3166 1,
3167 0,
3168 "\x81\x8A\x00\x00\x00\x00 \xF4\x80\x80\x80 ",
3169 16,
3170 " \xF4\x80\x80\x80 ",
3171 10,
3172 MHD_WEBSOCKET_STATUS_TEXT_FRAME,
3173 MHD_WEBSOCKET_VALIDITY_VALID,
3174 16);
3175 /* Edge test (success): The last valid UTF8-4 character (tail 3) */
3176 failed += test_decode_single (__LINE__,
3177 MHD_WEBSOCKET_FLAG_SERVER
3178 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
3179 0,
3180 1,
3181 0,
3182 "\x81\x8A\x00\x00\x00\x00 \xF4\x8F\xBF\xBF ",
3183 16,
3184 " \xF4\x8F\xBF\xBF ",
3185 10,
3186 MHD_WEBSOCKET_STATUS_TEXT_FRAME,
3187 MHD_WEBSOCKET_VALIDITY_VALID,
3188 16);
3189 /* Edge test (fail): The value after the last valid UTF8-4 character (tail 3) */
3190 failed += test_decode_single (__LINE__,
3191 MHD_WEBSOCKET_FLAG_SERVER
3192 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
3193 0,
3194 1,
3195 0,
3196 "\x81\x8A\x00\x00\x00\x00 \xF4\x90\x80\x80 ",
3197 16,
3198 NULL,
3199 0,
3200 MHD_WEBSOCKET_STATUS_UTF8_ENCODING_ERROR,
3201 MHD_WEBSOCKET_VALIDITY_INVALID,
3202 8);
3203 /* Edge test (fail): The first byte value the last valid UTF8-4 character */
3204 failed += test_decode_single (__LINE__,
3205 MHD_WEBSOCKET_FLAG_SERVER
3206 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
3207 0,
3208 1,
3209 0,
3210 "\x81\x8A\x00\x00\x00\x00 \xF5\x90\x80\x80 ",
3211 16,
3212 NULL,
3213 0,
3214 MHD_WEBSOCKET_STATUS_UTF8_ENCODING_ERROR,
3215 MHD_WEBSOCKET_VALIDITY_INVALID,
3216 7);
3217
3218 /*
3219 ------------------------------------------------------------------------------
3220 Unfinished UTF-8 sequence between fragmented text frame
3221 ------------------------------------------------------------------------------
3222 */
3223 /* Regular test: UTF-8 sequence between fragments, no fragmentation for the caller */
3224 failed += test_decode_single (__LINE__,
3225 MHD_WEBSOCKET_FLAG_SERVER
3226 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
3227 0,
3228 1,
3229 0,
3230 "\x01\x8D\x00\x00\x00\x00" "This is my n"
3231 "\xC3\x80\x83\x00\x00\x00\x00\xB6" "te",
3232 28,
3233 "This is my n" "\xC3\xB6" "te",
3234 16,
3235 MHD_WEBSOCKET_STATUS_TEXT_FRAME,
3236 MHD_WEBSOCKET_VALIDITY_VALID,
3237 28);
3238 /* Regular test: UTF-8 sequence between fragments, fragmentation for the caller, 1st call */
3239 failed += test_decode_single (__LINE__,
3240 MHD_WEBSOCKET_FLAG_SERVER
3241 | MHD_WEBSOCKET_FLAG_WANT_FRAGMENTS,
3242 0,
3243 1,
3244 0,
3245 "\x01\x8D\x00\x00\x00\x00" "This is my n"
3246 "\xC3\x80\x83\x00\x00\x00\x00\xB6" "te",
3247 28,
3248 "This is my n",
3249 12,
3250 MHD_WEBSOCKET_STATUS_TEXT_FRAGMENT,
3251 MHD_WEBSOCKET_VALIDITY_VALID,
3252 19);
3253 /* Regular test: UTF-8 sequence between fragments, fragmentation for the caller, 2nd call */
3254 failed += test_decode_single (__LINE__,
3255 MHD_WEBSOCKET_FLAG_SERVER
3256 | MHD_WEBSOCKET_FLAG_WANT_FRAGMENTS,
3257 0,
3258 2,
3259 0,
3260 "\x01\x8D\x00\x00\x00\x00" "This is my n"
3261 "\xC3\x80\x83\x00\x00\x00\x00\xB6" "te",
3262 28,
3263 "\xC3\xB6" "te",
3264 4,
3265 MHD_WEBSOCKET_STATUS_TEXT_LAST_FRAGMENT,
3266 MHD_WEBSOCKET_VALIDITY_VALID,
3267 28);
3268 /* Edge test (success): UTF-8 sequence between fragments, but nothing before, fragmentation for the caller, 1st call */
3269 failed += test_decode_single (__LINE__,
3270 MHD_WEBSOCKET_FLAG_SERVER
3271 | MHD_WEBSOCKET_FLAG_WANT_FRAGMENTS,
3272 0,
3273 1,
3274 0,
3275 "\x01\x81\x00\x00\x00\x00\xC3\x80\x81\x00\x00\x00\x00\xB6",
3276 14,
3277 NULL,
3278 0,
3279 MHD_WEBSOCKET_STATUS_TEXT_FRAGMENT,
3280 MHD_WEBSOCKET_VALIDITY_VALID,
3281 7);
3282 /* Edge test (success): UTF-8 sequence between fragments, but nothing before, fragmentation for the caller, 2nd call */
3283 failed += test_decode_single (__LINE__,
3284 MHD_WEBSOCKET_FLAG_SERVER
3285 | MHD_WEBSOCKET_FLAG_WANT_FRAGMENTS,
3286 0,
3287 2,
3288 0,
3289 "\x01\x81\x00\x00\x00\x00\xC3\x80\x81\x00\x00\x00\x00\xB6",
3290 14,
3291 "\xC3\xB6",
3292 2,
3293 MHD_WEBSOCKET_STATUS_TEXT_LAST_FRAGMENT,
3294 MHD_WEBSOCKET_VALIDITY_VALID,
3295 14);
3296
3297 /*
3298 ------------------------------------------------------------------------------
3299 Decoding with broken stream
3300 ------------------------------------------------------------------------------
3301 */
3302 /* Failure test: Invalid sequence */
3303 failed += test_decode_single (__LINE__,
3304 MHD_WEBSOCKET_FLAG_SERVER
3305 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
3306 0,
3307 1,
3308 0,
3309 "\xFF\x81\x85\x00\x00\x00\x00" "Hello",
3310 12,
3311 NULL,
3312 0,
3313 MHD_WEBSOCKET_STATUS_PROTOCOL_ERROR,
3314 MHD_WEBSOCKET_VALIDITY_INVALID,
3315 0);
3316 /* Failure test: Call after invalidated stream */
3317 failed += test_decode_single (__LINE__,
3318 MHD_WEBSOCKET_FLAG_SERVER
3319 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
3320 0,
3321 2,
3322 0,
3323 "\xFF\x81\x85\x00\x00\x00\x00" "Hello",
3324 12,
3325 NULL,
3326 0,
3327 MHD_WEBSOCKET_STATUS_STREAM_BROKEN,
3328 MHD_WEBSOCKET_VALIDITY_INVALID,
3329 0);
3330 /* Failure test: Call after invalidated stream (but with different buffer) */
3331 {
3332 struct MHD_WebSocketStream*ws;
3333 if (MHD_WEBSOCKET_STATUS_OK == MHD_websocket_stream_init (&ws,
3334 MHD_WEBSOCKET_FLAG_SERVER
3335 |
3336 MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
3337 0))
3338 {
3339 size_t streambuf_read_len = 0;
3340 char*payload = NULL;
3341 size_t payload_len = 0;
3342 int ret = 0;
3343 ret = MHD_websocket_decode (ws,
3344 "\xFF",
3345 1,
3346 &streambuf_read_len,
3347 &payload,
3348 &payload_len);
3349 if (MHD_WEBSOCKET_STATUS_PROTOCOL_ERROR != ret)
3350 {
3351 fprintf (stderr,
3352 "Test failed in line %u: The return value should be -1, but is %d\n",
3353 (unsigned int) __LINE__,
3354 (int) ret);
3355 ++failed;
3356 }
3357 else
3358 {
3359 ret = MHD_websocket_decode (ws,
3360 "\x81\x85\x00\x00\x00\x00" "Hello",
3361 11,
3362 &streambuf_read_len,
3363 &payload,
3364 &payload_len);
3365 if (MHD_WEBSOCKET_STATUS_STREAM_BROKEN != ret)
3366 {
3367 fprintf (stderr,
3368 "Test failed in line %u: The return value should be -2, but is %d\n",
3369 (unsigned int) __LINE__,
3370 (int) ret);
3371 ++failed;
3372 }
3373 }
3374 MHD_websocket_stream_free (ws);
3375 }
3376 else
3377 {
3378 fprintf (stderr,
3379 "Individual test failed in line %u\n",
3380 (unsigned int) __LINE__);
3381 ++failed;
3382 }
3383 }
3384
3385 /*
3386 ------------------------------------------------------------------------------
3387 frame after close frame
3388 ------------------------------------------------------------------------------
3389 */
3390 /* Regular test: Close frame */
3391 failed += test_decode_single (__LINE__,
3392 MHD_WEBSOCKET_FLAG_SERVER
3393 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
3394 0,
3395 1,
3396 0,
3397 "\x88\x80\x00\x00\x00\x00\x81\x85\x00\x00\x00\x00"
3398 "Hello",
3399 17,
3400 NULL,
3401 0,
3402 MHD_WEBSOCKET_STATUS_CLOSE_FRAME,
3403 MHD_WEBSOCKET_VALIDITY_ONLY_VALID_FOR_CONTROL_FRAMES,
3404 6);
3405 /* Failure test: Text frame after close frame */
3406 failed += test_decode_single (__LINE__,
3407 MHD_WEBSOCKET_FLAG_SERVER
3408 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
3409 0,
3410 2,
3411 0,
3412 "\x88\x80\x00\x00\x00\x00\x81\x85\x00\x00\x00\x00"
3413 "Hello",
3414 17,
3415 NULL,
3416 0,
3417 MHD_WEBSOCKET_STATUS_PROTOCOL_ERROR,
3418 MHD_WEBSOCKET_VALIDITY_INVALID,
3419 6);
3420 /* Failure test: Binary frame after close frame */
3421 failed += test_decode_single (__LINE__,
3422 MHD_WEBSOCKET_FLAG_SERVER
3423 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
3424 0,
3425 2,
3426 0,
3427 "\x88\x80\x00\x00\x00\x00\x82\x85\x00\x00\x00\x00"
3428 "Hello",
3429 17,
3430 NULL,
3431 0,
3432 MHD_WEBSOCKET_STATUS_PROTOCOL_ERROR,
3433 MHD_WEBSOCKET_VALIDITY_INVALID,
3434 6);
3435 /* Failure test: Continue frame after close frame */
3436 failed += test_decode_single (__LINE__,
3437 MHD_WEBSOCKET_FLAG_SERVER
3438 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
3439 0,
3440 2,
3441 0,
3442 "\x88\x80\x00\x00\x00\x00\x80\x85\x00\x00\x00\x00"
3443 "Hello",
3444 17,
3445 NULL,
3446 0,
3447 MHD_WEBSOCKET_STATUS_PROTOCOL_ERROR,
3448 MHD_WEBSOCKET_VALIDITY_INVALID,
3449 6);
3450 /* Regular test: Ping frame after close frame */
3451 failed += test_decode_single (__LINE__,
3452 MHD_WEBSOCKET_FLAG_SERVER
3453 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
3454 0,
3455 2,
3456 0,
3457 "\x88\x80\x00\x00\x00\x00\x89\x85\x00\x00\x00\x00"
3458 "Hello",
3459 17,
3460 "Hello",
3461 5,
3462 MHD_WEBSOCKET_STATUS_PING_FRAME,
3463 MHD_WEBSOCKET_VALIDITY_ONLY_VALID_FOR_CONTROL_FRAMES,
3464 17);
3465 /* Regular test: Pong frame after close frame */
3466 failed += test_decode_single (__LINE__,
3467 MHD_WEBSOCKET_FLAG_SERVER
3468 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
3469 0,
3470 2,
3471 0,
3472 "\x88\x80\x00\x00\x00\x00\x8A\x85\x00\x00\x00\x00"
3473 "Hello",
3474 17,
3475 "Hello",
3476 5,
3477 MHD_WEBSOCKET_STATUS_PONG_FRAME,
3478 MHD_WEBSOCKET_VALIDITY_ONLY_VALID_FOR_CONTROL_FRAMES,
3479 17);
3480 /* Regular test: Close frame after close frame */
3481 failed += test_decode_single (__LINE__,
3482 MHD_WEBSOCKET_FLAG_SERVER
3483 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
3484 0,
3485 2,
3486 0,
3487 "\x88\x80\x00\x00\x00\x00\x88\x80\x00\x00\x00\x00",
3488 12,
3489 NULL,
3490 0,
3491 MHD_WEBSOCKET_STATUS_CLOSE_FRAME,
3492 MHD_WEBSOCKET_VALIDITY_ONLY_VALID_FOR_CONTROL_FRAMES,
3493 12);
3494
3495 /*
3496 ------------------------------------------------------------------------------
3497 decoding byte-by-byte
3498 ------------------------------------------------------------------------------
3499 */
3500 /* Regular test: Text frame, 2 bytes per loop, 1st call */
3501 failed += test_decode_single (__LINE__,
3502 MHD_WEBSOCKET_FLAG_SERVER
3503 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
3504 0,
3505 1,
3506 2,
3507 "\x81\x91\x01\x02\x04\x08" "Ujm{!kw(uja(ugw|/",
3508 23,
3509 NULL,
3510 0,
3511 MHD_WEBSOCKET_STATUS_OK,
3512 MHD_WEBSOCKET_VALIDITY_VALID,
3513 2);
3514 /* Regular test: Text frame, 2 bytes per loop, 11th call */
3515 failed += test_decode_single (__LINE__,
3516 MHD_WEBSOCKET_FLAG_SERVER
3517 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
3518 0,
3519 11,
3520 2,
3521 "\x81\x91\x01\x02\x04\x08" "Ujm{!kw(uja(ugw|/",
3522 23,
3523 NULL,
3524 0,
3525 MHD_WEBSOCKET_STATUS_OK,
3526 MHD_WEBSOCKET_VALIDITY_VALID,
3527 22);
3528 /* Regular test: Text frame, 2 bytes per loop, 12th call */
3529 failed += test_decode_single (__LINE__,
3530 MHD_WEBSOCKET_FLAG_SERVER
3531 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
3532 0,
3533 12,
3534 2,
3535 "\x81\x91\x01\x02\x04\x08" "Ujm{!kw(uja(ugw|/",
3536 23,
3537 "This is the test.",
3538 17,
3539 MHD_WEBSOCKET_STATUS_TEXT_FRAME,
3540 MHD_WEBSOCKET_VALIDITY_VALID,
3541 23);
3542 /* Regular test: Text frame, 1 byte per loop, 1st call */
3543 failed += test_decode_single (__LINE__,
3544 MHD_WEBSOCKET_FLAG_SERVER
3545 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
3546 0,
3547 1,
3548 1,
3549 "\x81\x91\x01\x02\x04\x08" "Ujm{!kw(uja(ugw|/",
3550 23,
3551 NULL,
3552 0,
3553 MHD_WEBSOCKET_STATUS_OK,
3554 MHD_WEBSOCKET_VALIDITY_VALID,
3555 1);
3556 /* Regular test: Text frame, 1 byte per loop, 22nd call */
3557 failed += test_decode_single (__LINE__,
3558 MHD_WEBSOCKET_FLAG_SERVER
3559 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
3560 0,
3561 22,
3562 1,
3563 "\x81\x91\x01\x02\x04\x08" "Ujm{!kw(uja(ugw|/",
3564 23,
3565 NULL,
3566 0,
3567 MHD_WEBSOCKET_STATUS_OK,
3568 MHD_WEBSOCKET_VALIDITY_VALID,
3569 22);
3570 /* Regular test: Text frame, 1 byte per loop, 23rd call */
3571 failed += test_decode_single (__LINE__,
3572 MHD_WEBSOCKET_FLAG_SERVER
3573 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
3574 0,
3575 23,
3576 1,
3577 "\x81\x91\x01\x02\x04\x08" "Ujm{!kw(uja(ugw|/",
3578 23,
3579 "This is the test.",
3580 17,
3581 MHD_WEBSOCKET_STATUS_TEXT_FRAME,
3582 MHD_WEBSOCKET_VALIDITY_VALID,
3583 23);
3584
3585 /*
3586 ------------------------------------------------------------------------------
3587 mix of fragmented data frames and control frames
3588 ------------------------------------------------------------------------------
3589 */
3590 /* Regular test: Fragmented text frame mixed with one ping frame (1st call) */
3591 failed += test_decode_single (__LINE__,
3592 MHD_WEBSOCKET_FLAG_SERVER
3593 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
3594 0,
3595 1,
3596 0,
3597 "\x01\x85\x00\x00\x00\x00"
3598 "This \x89\x80\x00\x00\x00\x00"
3599 "\x80\x8C\x00\x00\x00\x00" "is the test.",
3600 35,
3601 NULL,
3602 0,
3603 MHD_WEBSOCKET_STATUS_PING_FRAME,
3604 MHD_WEBSOCKET_VALIDITY_VALID,
3605 17);
3606 /* Regular test: Fragmented text frame mixed with one ping frame (2nd call) */
3607 failed += test_decode_single (__LINE__,
3608 MHD_WEBSOCKET_FLAG_SERVER
3609 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
3610 0,
3611 2,
3612 0,
3613 "\x01\x85\x00\x00\x00\x00"
3614 "This \x89\x80\x00\x00\x00\x00"
3615 "\x80\x8C\x00\x00\x00\x00" "is the test.",
3616 35,
3617 "This is the test.",
3618 17,
3619 MHD_WEBSOCKET_STATUS_TEXT_FRAME,
3620 MHD_WEBSOCKET_VALIDITY_VALID,
3621 35);
3622 /* Regular test: Fragmented text frame mixed with one close frame (1st call) */
3623 failed += test_decode_single (__LINE__,
3624 MHD_WEBSOCKET_FLAG_SERVER
3625 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
3626 0,
3627 1,
3628 0,
3629 "\x01\x85\x00\x00\x00\x00"
3630 "This \x88\x80\x00\x00\x00\x00"
3631 "\x80\x8C\x00\x00\x00\x00" "is the test.",
3632 35,
3633 NULL,
3634 0,
3635 MHD_WEBSOCKET_STATUS_CLOSE_FRAME,
3636 MHD_WEBSOCKET_VALIDITY_ONLY_VALID_FOR_CONTROL_FRAMES,
3637 17);
3638 /* Fail test: Fragmented text frame mixed with one ping frame (2nd call) */
3639 failed += test_decode_single (__LINE__,
3640 MHD_WEBSOCKET_FLAG_SERVER
3641 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
3642 0,
3643 2,
3644 0,
3645 "\x01\x85\x00\x00\x00\x00"
3646 "This \x88\x80\x00\x00\x00\x00"
3647 "\x80\x8C\x00\x00\x00\x00" "is the test.",
3648 35,
3649 NULL,
3650 0,
3651 MHD_WEBSOCKET_STATUS_PROTOCOL_ERROR,
3652 MHD_WEBSOCKET_VALIDITY_INVALID,
3653 17);
3654 /* Regular test: Fragmented text frame mixed with one ping frame, the caller wants fragments (1st call) */
3655 failed += test_decode_single (__LINE__,
3656 MHD_WEBSOCKET_FLAG_SERVER
3657 | MHD_WEBSOCKET_FLAG_WANT_FRAGMENTS,
3658 0,
3659 1,
3660 0,
3661 "\x01\x85\x00\x00\x00\x00"
3662 "This \x89\x80\x00\x00\x00\x00"
3663 "\x80\x8C\x00\x00\x00\x00" "is the test.",
3664 35,
3665 "This ",
3666 5,
3667 MHD_WEBSOCKET_STATUS_TEXT_FRAGMENT,
3668 MHD_WEBSOCKET_VALIDITY_VALID,
3669 11);
3670 /* Regular test: Fragmented text frame mixed with one ping frame, the caller wants fragments (2nd call) */
3671 failed += test_decode_single (__LINE__,
3672 MHD_WEBSOCKET_FLAG_SERVER
3673 | MHD_WEBSOCKET_FLAG_WANT_FRAGMENTS,
3674 0,
3675 2,
3676 0,
3677 "\x01\x85\x00\x00\x00\x00"
3678 "This \x89\x80\x00\x00\x00\x00"
3679 "\x80\x8C\x00\x00\x00\x00" "is the test.",
3680 35,
3681 NULL,
3682 0,
3683 MHD_WEBSOCKET_STATUS_PING_FRAME,
3684 MHD_WEBSOCKET_VALIDITY_VALID,
3685 17);
3686 /* Regular test: Fragmented text frame mixed with one ping frame, the caller wants fragments (3rd call) */
3687 failed += test_decode_single (__LINE__,
3688 MHD_WEBSOCKET_FLAG_SERVER
3689 | MHD_WEBSOCKET_FLAG_WANT_FRAGMENTS,
3690 0,
3691 3,
3692 0,
3693 "\x01\x85\x00\x00\x00\x00"
3694 "This \x89\x80\x00\x00\x00\x00"
3695 "\x80\x8C\x00\x00\x00\x00" "is the test.",
3696 35,
3697 "is the test.",
3698 12,
3699 MHD_WEBSOCKET_STATUS_TEXT_LAST_FRAGMENT,
3700 MHD_WEBSOCKET_VALIDITY_VALID,
3701 35);
3702
3703 /*
3704 ------------------------------------------------------------------------------
3705 mix of fragmented data frames and data frames
3706 ------------------------------------------------------------------------------
3707 */
3708 /* Fail test: Fragmented text frame mixed with one non-fragmented binary frame */
3709 failed += test_decode_single (__LINE__,
3710 MHD_WEBSOCKET_FLAG_SERVER
3711 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
3712 0,
3713 1,
3714 0,
3715 "\x01\x85\x00\x00\x00\x00"
3716 "This \x82\x81\x00\x00\x00\x00"
3717 "a\x80\x8C\x00\x00\x00\x00" "is the test.",
3718 36,
3719 NULL,
3720 0,
3721 MHD_WEBSOCKET_STATUS_PROTOCOL_ERROR,
3722 MHD_WEBSOCKET_VALIDITY_INVALID,
3723 11);
3724 /* Regular test: Fragmented text frame mixed with one non-fragmented binary frame; the caller wants fragments; 1st call */
3725 failed += test_decode_single (__LINE__,
3726 MHD_WEBSOCKET_FLAG_SERVER
3727 | MHD_WEBSOCKET_FLAG_WANT_FRAGMENTS,
3728 0,
3729 1,
3730 0,
3731 "\x01\x85\x00\x00\x00\x00"
3732 "This \x82\x81\x00\x00\x00\x00"
3733 "a\x80\x8C\x00\x00\x00\x00" "is the test.",
3734 36,
3735 "This ",
3736 5,
3737 MHD_WEBSOCKET_STATUS_TEXT_FRAGMENT,
3738 MHD_WEBSOCKET_VALIDITY_VALID,
3739 11);
3740 /* Fail test: Fragmented text frame mixed with one non-fragmented binary frame; the caller wants fragments; 2nd call */
3741 failed += test_decode_single (__LINE__,
3742 MHD_WEBSOCKET_FLAG_SERVER
3743 | MHD_WEBSOCKET_FLAG_WANT_FRAGMENTS,
3744 0,
3745 2,
3746 0,
3747 "\x01\x85\x00\x00\x00\x00"
3748 "This \x82\x81\x00\x00\x00\x00"
3749 "a\x80\x8C\x00\x00\x00\x00" "is the test.",
3750 36,
3751 NULL,
3752 0,
3753 MHD_WEBSOCKET_STATUS_PROTOCOL_ERROR,
3754 MHD_WEBSOCKET_VALIDITY_INVALID,
3755 11);
3756 /* Fail test: Fragmented text frame mixed with one fragmented binary frame */
3757 failed += test_decode_single (__LINE__,
3758 MHD_WEBSOCKET_FLAG_SERVER
3759 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
3760 0,
3761 1,
3762 0,
3763 "\x01\x85\x00\x00\x00\x00"
3764 "This \x02\x81\x00\x00\x00\x00"
3765 "a\x80\x8C\x00\x00\x00\x00" "is the test.",
3766 36,
3767 NULL,
3768 0,
3769 MHD_WEBSOCKET_STATUS_PROTOCOL_ERROR,
3770 MHD_WEBSOCKET_VALIDITY_INVALID,
3771 11);
3772 /* Fail test: Fragmented text frame, continue frame, non-fragmented binary frame */
3773 failed += test_decode_single (__LINE__,
3774 MHD_WEBSOCKET_FLAG_SERVER
3775 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
3776 0,
3777 1,
3778 0,
3779 "\x01\x85\x00\x00\x00\x00"
3780 "This \x00\x8C\x00\x00\x00\x00"
3781 "is the test.\x82\x81\x00\x00\x00\x00" "a",
3782 36,
3783 NULL,
3784 0,
3785 MHD_WEBSOCKET_STATUS_PROTOCOL_ERROR,
3786 MHD_WEBSOCKET_VALIDITY_INVALID,
3787 29);
3788 /* Fail test: Fragmented text frame, continue frame, fragmented binary frame */
3789 failed += test_decode_single (__LINE__,
3790 MHD_WEBSOCKET_FLAG_SERVER
3791 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
3792 0,
3793 1,
3794 0,
3795 "\x01\x85\x00\x00\x00\x00"
3796 "This \x00\x8C\x00\x00\x00\x00"
3797 "is the test.\x02\x81\x00\x00\x00\x00" "a",
3798 36,
3799 NULL,
3800 0,
3801 MHD_WEBSOCKET_STATUS_PROTOCOL_ERROR,
3802 MHD_WEBSOCKET_VALIDITY_INVALID,
3803 29);
3804
3805 /*
3806 ------------------------------------------------------------------------------
3807 multiple data frames
3808 ------------------------------------------------------------------------------
3809 */
3810 /* Regular test: Text frame, binary frame, text frame (1st call) */
3811 failed += test_decode_single (__LINE__,
3812 MHD_WEBSOCKET_FLAG_SERVER
3813 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
3814 0,
3815 1,
3816 0,
3817 "\x81\x85\x00\x00\x00\x00"
3818 "This \x82\x87\x00\x00\x00\x00"
3819 "is the \x81\x85\x00\x00\x00\x00" "test.",
3820 35,
3821 "This ",
3822 5,
3823 MHD_WEBSOCKET_STATUS_TEXT_FRAME,
3824 MHD_WEBSOCKET_VALIDITY_VALID,
3825 11);
3826 /* Regular test: Text frame, binary frame, text frame (2nd call) */
3827 failed += test_decode_single (__LINE__,
3828 MHD_WEBSOCKET_FLAG_SERVER
3829 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
3830 0,
3831 2,
3832 0,
3833 "\x81\x85\x00\x00\x00\x00"
3834 "This \x82\x87\x00\x00\x00\x00"
3835 "is the \x81\x85\x00\x00\x00\x00" "test.",
3836 35,
3837 "is the ",
3838 7,
3839 MHD_WEBSOCKET_STATUS_BINARY_FRAME,
3840 MHD_WEBSOCKET_VALIDITY_VALID,
3841 24);
3842 /* Regular test: Text frame, binary frame, text frame (3rd call) */
3843 failed += test_decode_single (__LINE__,
3844 MHD_WEBSOCKET_FLAG_SERVER
3845 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
3846 0,
3847 3,
3848 0,
3849 "\x81\x85\x00\x00\x00\x00"
3850 "This \x82\x87\x00\x00\x00\x00"
3851 "is the \x81\x85\x00\x00\x00\x00" "test.",
3852 35,
3853 "test.",
3854 5,
3855 MHD_WEBSOCKET_STATUS_TEXT_FRAME,
3856 MHD_WEBSOCKET_VALIDITY_VALID,
3857 35);
3858 /*
3859 ------------------------------------------------------------------------------
3860 multiple control frames
3861 ------------------------------------------------------------------------------
3862 */
3863 /* Regular test: Ping frame, pong frame, close frame (1st call) */
3864 failed += test_decode_single (__LINE__,
3865 MHD_WEBSOCKET_FLAG_SERVER
3866 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
3867 0,
3868 1,
3869 0,
3870 "\x89\x85\x00\x00\x00\x00"
3871 "This \x8A\x87\x00\x00\x00\x00"
3872 "is the \x88\x85\x00\x00\x00\x00" "test.",
3873 35,
3874 "This ",
3875 5,
3876 MHD_WEBSOCKET_STATUS_PING_FRAME,
3877 MHD_WEBSOCKET_VALIDITY_VALID,
3878 11);
3879 /* Regular test: Ping frame, pong frame, close frame (2nd call) */
3880 failed += test_decode_single (__LINE__,
3881 MHD_WEBSOCKET_FLAG_SERVER
3882 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
3883 0,
3884 2,
3885 0,
3886 "\x89\x85\x00\x00\x00\x00"
3887 "This \x8A\x87\x00\x00\x00\x00"
3888 "is the \x88\x85\x00\x00\x00\x00" "test.",
3889 35,
3890 "is the ",
3891 7,
3892 MHD_WEBSOCKET_STATUS_PONG_FRAME,
3893 MHD_WEBSOCKET_VALIDITY_VALID,
3894 24);
3895 /* Regular test: Ping frame, pong frame, close frame (3rd call) */
3896 failed += test_decode_single (__LINE__,
3897 MHD_WEBSOCKET_FLAG_SERVER
3898 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
3899 0,
3900 3,
3901 0,
3902 "\x89\x85\x00\x00\x00\x00"
3903 "This \x8A\x87\x00\x00\x00\x00"
3904 "is the \x88\x85\x00\x00\x00\x00" "test.",
3905 35,
3906 "test.",
3907 5,
3908 MHD_WEBSOCKET_STATUS_CLOSE_FRAME,
3909 MHD_WEBSOCKET_VALIDITY_ONLY_VALID_FOR_CONTROL_FRAMES,
3910 35);
3911
3912 /*
3913 ------------------------------------------------------------------------------
3914 generated close frames for errors
3915 ------------------------------------------------------------------------------
3916 */
3917 /* Regular test: Close frame generated for protocol error */
3918 failed += test_decode_single (__LINE__,
3919 MHD_WEBSOCKET_FLAG_SERVER
3920 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS
3921 |
3922 MHD_WEBSOCKET_FLAG_GENERATE_CLOSE_FRAMES_ON_ERROR,
3923 0,
3924 1,
3925 0,
3926 "\xFF",
3927 1,
3928 "\x88\x02\x03\xEA",
3929 4,
3930 MHD_WEBSOCKET_STATUS_PROTOCOL_ERROR,
3931 MHD_WEBSOCKET_VALIDITY_INVALID,
3932 0);
3933 /* Regular test: Close frame generated for UTF-8 sequence error */
3934 failed += test_decode_single (__LINE__,
3935 MHD_WEBSOCKET_FLAG_SERVER
3936 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS
3937 |
3938 MHD_WEBSOCKET_FLAG_GENERATE_CLOSE_FRAMES_ON_ERROR,
3939 0,
3940 1,
3941 0,
3942 "\x81\x85\x00\x00\x00\x00T\xFFst.",
3943 11,
3944 "\x88\x02\x03\xEF",
3945 4,
3946 MHD_WEBSOCKET_STATUS_UTF8_ENCODING_ERROR,
3947 MHD_WEBSOCKET_VALIDITY_INVALID,
3948 7);
3949 /* Regular test: Close frame generated for message size exceeded */
3950 failed += test_decode_single (__LINE__,
3951 MHD_WEBSOCKET_FLAG_SERVER
3952 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS
3953 |
3954 MHD_WEBSOCKET_FLAG_GENERATE_CLOSE_FRAMES_ON_ERROR,
3955 3,
3956 1,
3957 0,
3958 "\x81\x85\x00\x00\x00\x00T\xFFst.",
3959 11,
3960 "\x88\x02\x03\xF1",
3961 4,
3962 MHD_WEBSOCKET_STATUS_MAXIMUM_SIZE_EXCEEDED,
3963 MHD_WEBSOCKET_VALIDITY_INVALID,
3964 2);
3965
3966 /*
3967 ------------------------------------------------------------------------------
3968 terminating NUL character
3969 ------------------------------------------------------------------------------
3970 */
3971 {
3972 struct MHD_WebSocketStream*ws;
3973 if (MHD_WEBSOCKET_STATUS_OK == MHD_websocket_stream_init (&ws,
3974 MHD_WEBSOCKET_FLAG_SERVER
3975 |
3976 MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
3977 0))
3978 {
3979 size_t streambuf_read_len = 0;
3980 char*payload = NULL;
3981 size_t payload_len = 0;
3982 int ret = 0;
3983
3984 /* Regular test: text frame */
3985 ret = MHD_websocket_decode (ws,
3986 "\x81\x85\x00\x00\x00\x00" "Hello",
3987 11,
3988 &streambuf_read_len,
3989 &payload,
3990 &payload_len);
3991 if ((MHD_WEBSOCKET_STATUS_TEXT_FRAME != ret) ||
3992 (5 != payload_len) ||
3993 (NULL == payload) ||
3994 (0 != memcmp ("Hello", payload, 5 + 1)))
3995 {
3996 fprintf (stderr,
3997 "Decode test failed in line %u\n",
3998 (unsigned int) __LINE__);
3999 ++failed;
4000 }
4001 if (NULL != payload)
4002 {
4003 MHD_websocket_free (ws, payload);
4004 payload = NULL;
4005 }
4006
4007 /* Regular test: text frame fragment */
4008 ret = MHD_websocket_decode (ws,
4009 "\x01\x83\x00\x00\x00\x00"
4010 "Hel\x80\x82\x00\x00\x00\x00" "lo",
4011 17,
4012 &streambuf_read_len,
4013 &payload,
4014 &payload_len);
4015 if ((MHD_WEBSOCKET_STATUS_TEXT_FRAME != ret) ||
4016 (5 != payload_len) ||
4017 (NULL == payload) ||
4018 (0 != memcmp ("Hello", payload, 5 + 1)))
4019 {
4020 fprintf (stderr,
4021 "Decode test failed in line %u\n",
4022 (unsigned int) __LINE__);
4023 ++failed;
4024 }
4025 if (NULL != payload)
4026 {
4027 MHD_websocket_free (ws, payload);
4028 payload = NULL;
4029 }
4030
4031 /* Regular test: binary frame */
4032 ret = MHD_websocket_decode (ws,
4033 "\x82\x85\x00\x00\x00\x00" "Hello",
4034 11,
4035 &streambuf_read_len,
4036 &payload,
4037 &payload_len);
4038 if ((MHD_WEBSOCKET_STATUS_BINARY_FRAME != ret) ||
4039 (5 != payload_len) ||
4040 (NULL == payload) ||
4041 (0 != memcmp ("Hello", payload, 5 + 1)))
4042 {
4043 fprintf (stderr,
4044 "Decode test failed in line %u\n",
4045 (unsigned int) __LINE__);
4046 ++failed;
4047 }
4048 if (NULL != payload)
4049 {
4050 MHD_websocket_free (ws, payload);
4051 payload = NULL;
4052 }
4053
4054 /* Regular test: binary frame fragment */
4055 ret = MHD_websocket_decode (ws,
4056 "\x02\x83\x00\x00\x00\x00"
4057 "Hel\x80\x82\x00\x00\x00\x00" "lo",
4058 17,
4059 &streambuf_read_len,
4060 &payload,
4061 &payload_len);
4062 if ((MHD_WEBSOCKET_STATUS_BINARY_FRAME != ret) ||
4063 (5 != payload_len) ||
4064 (NULL == payload) ||
4065 (0 != memcmp ("Hello", payload, 5 + 1)))
4066 {
4067 fprintf (stderr,
4068 "Decode test failed in line %u\n",
4069 (unsigned int) __LINE__);
4070 ++failed;
4071 }
4072 if (NULL != payload)
4073 {
4074 MHD_websocket_free (ws, payload);
4075 payload = NULL;
4076 }
4077
4078 MHD_websocket_stream_free (ws);
4079 }
4080 else
4081 {
4082 fprintf (stderr,
4083 "Individual decode test failed in line %u\n",
4084 (unsigned int) __LINE__);
4085 ++failed;
4086 }
4087 }
4088 {
4089 struct MHD_WebSocketStream*ws;
4090 if (MHD_WEBSOCKET_STATUS_OK == MHD_websocket_stream_init (&ws,
4091 MHD_WEBSOCKET_FLAG_SERVER
4092 |
4093 MHD_WEBSOCKET_FLAG_WANT_FRAGMENTS,
4094 0))
4095 {
4096 size_t streambuf_read_len = 0;
4097 char*payload = NULL;
4098 size_t payload_len = 0;
4099 int ret = 0;
4100
4101 /* Regular test: text frame fragment (caller wants fragment, 1st call) */
4102 ret = MHD_websocket_decode (ws,
4103 "\x01\x83\x00\x00\x00\x00"
4104 "Hel\x80\x82\x00\x00\x00\x00" "lo",
4105 17,
4106 &streambuf_read_len,
4107 &payload,
4108 &payload_len);
4109 if ((MHD_WEBSOCKET_STATUS_TEXT_FRAGMENT != ret) ||
4110 (3 != payload_len) ||
4111 (NULL == payload) ||
4112 (0 != memcmp ("Hel", payload, 3 + 1)))
4113 {
4114 fprintf (stderr,
4115 "Decode test failed in line %u\n",
4116 (unsigned int) __LINE__);
4117 ++failed;
4118 }
4119 if (NULL != payload)
4120 {
4121 MHD_websocket_free (ws, payload);
4122 payload = NULL;
4123 }
4124
4125 /* Regular test: text frame fragment (caller wants fragment, 2nd call) */
4126 ret = MHD_websocket_decode (ws,
4127 "\x01\x83\x00\x00\x00\x00"
4128 "Hel\x80\x82\x00\x00\x00\x00" "lo"
4129 + streambuf_read_len,
4130 17 - streambuf_read_len,
4131 &streambuf_read_len,
4132 &payload,
4133 &payload_len);
4134 if ((MHD_WEBSOCKET_STATUS_TEXT_LAST_FRAGMENT != ret) ||
4135 (2 != payload_len) ||
4136 (NULL == payload) ||
4137 (0 != memcmp ("lo", payload, 2 + 1)))
4138 {
4139 fprintf (stderr,
4140 "Decode test failed in line %u\n",
4141 (unsigned int) __LINE__);
4142 ++failed;
4143 }
4144 if (NULL != payload)
4145 {
4146 MHD_websocket_free (ws, payload);
4147 payload = NULL;
4148 }
4149
4150 /* Regular test: text frame fragment with broken UTF-8 sequence (caller wants fragment, 1st call) */
4151 ret = MHD_websocket_decode (ws,
4152 "\x01\x83\x00\x00\x00\x00"
4153 "He\xC3\x80\x82\x00\x00\x00\x00" "\xB6o",
4154 17,
4155 &streambuf_read_len,
4156 &payload,
4157 &payload_len);
4158 if ((MHD_WEBSOCKET_STATUS_TEXT_FRAGMENT != ret) ||
4159 (2 != payload_len) ||
4160 (NULL == payload) ||
4161 (0 != memcmp ("He", payload, 2 + 1)))
4162 {
4163 fprintf (stderr,
4164 "Decode test failed in line %u\n",
4165 (unsigned int) __LINE__);
4166 ++failed;
4167 }
4168 if (NULL != payload)
4169 {
4170 MHD_websocket_free (ws, payload);
4171 payload = NULL;
4172 }
4173
4174 /* Regular test: text frame fragment with broken UTF-8 sequence (caller wants fragment, 2nd call) */
4175 ret = MHD_websocket_decode (ws,
4176 "\x01\x83\x00\x00\x00\x00"
4177 "He\xC3\x80\x82\x00\x00\x00\x00" "\xB6o"
4178 + streambuf_read_len,
4179 17 - streambuf_read_len,
4180 &streambuf_read_len,
4181 &payload,
4182 &payload_len);
4183 if ((MHD_WEBSOCKET_STATUS_TEXT_LAST_FRAGMENT != ret) ||
4184 (3 != payload_len) ||
4185 (NULL == payload) ||
4186 (0 != memcmp ("\xC3\xB6o", payload, 3 + 1)))
4187 {
4188 fprintf (stderr,
4189 "Decode test failed in line %u\n",
4190 (unsigned int) __LINE__);
4191 ++failed;
4192 }
4193 if (NULL != payload)
4194 {
4195 MHD_websocket_free (ws, payload);
4196 payload = NULL;
4197 }
4198 }
4199 else
4200 {
4201 fprintf (stderr,
4202 "Individual decode test failed in line %u\n",
4203 (unsigned int) __LINE__);
4204 ++failed;
4205 }
4206 }
4207
4208
4209 /*
4210 ------------------------------------------------------------------------------
4211 invalid parameters
4212 ------------------------------------------------------------------------------
4213 */
4214 {
4215 struct MHD_WebSocketStream*ws;
4216 if (MHD_WEBSOCKET_STATUS_OK == MHD_websocket_stream_init (&ws,
4217 MHD_WEBSOCKET_FLAG_SERVER
4218 |
4219 MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
4220 0))
4221 {
4222 size_t streambuf_read_len = 0;
4223 char*payload = NULL;
4224 size_t payload_len = 0;
4225 int ret = 0;
4226
4227 /* Failure test: `ws` is NULL */
4228 payload = (char *) (uintptr_t) 0xBAADF00D;
4229 payload_len = 0x87654321;
4230 streambuf_read_len = 1000;
4231 ret = MHD_websocket_decode (NULL,
4232 "\x81\x85\x00\x00\x00\x00Hello",
4233 11,
4234 &streambuf_read_len,
4235 &payload,
4236 &payload_len);
4237 if ((MHD_WEBSOCKET_STATUS_PARAMETER_ERROR != ret) ||
4238 (NULL != payload) ||
4239 (0 != payload_len) ||
4240 (0 != streambuf_read_len) ||
4241 (MHD_WEBSOCKET_VALIDITY_VALID != MHD_websocket_stream_is_valid (ws)))
4242 {
4243 fprintf (stderr,
4244 "Decode test failed in line %u\n",
4245 (unsigned int) __LINE__);
4246 ++failed;
4247 }
4248 if (((char *) (uintptr_t) 0xBAADF00D) == payload)
4249 {
4250 payload = NULL;
4251 }
4252 if (NULL != payload)
4253 {
4254 MHD_websocket_free (ws, payload);
4255 }
4256 /* Failure test: `buf` is NULL, while `buf_len` != 0 */
4257 payload = (char *) (uintptr_t) 0xBAADF00D;
4258 payload_len = 0x87654321;
4259 streambuf_read_len = 1000;
4260 ret = MHD_websocket_decode (ws,
4261 NULL,
4262 11,
4263 &streambuf_read_len,
4264 &payload,
4265 &payload_len);
4266 if ((MHD_WEBSOCKET_STATUS_PARAMETER_ERROR != ret) ||
4267 (NULL != payload) ||
4268 (0 != payload_len) ||
4269 (0 != streambuf_read_len) ||
4270 (MHD_WEBSOCKET_VALIDITY_VALID != MHD_websocket_stream_is_valid (ws)))
4271 {
4272 fprintf (stderr,
4273 "Decode test failed in line %u\n",
4274 (unsigned int) __LINE__);
4275 ++failed;
4276 }
4277 if (((char *) (uintptr_t) 0xBAADF00D) == payload)
4278 {
4279 payload = NULL;
4280 }
4281 if (NULL != payload)
4282 {
4283 MHD_websocket_free (ws, payload);
4284 }
4285 /* Failure test: `streambuf_read_len` is NULL */
4286 payload = (char *) (uintptr_t) 0xBAADF00D;
4287 payload_len = 0x87654321;
4288 ret = MHD_websocket_decode (ws,
4289 "\x81\x85\x00\x00\x00\x00Hello",
4290 11,
4291 NULL,
4292 &payload,
4293 &payload_len);
4294 if ((MHD_WEBSOCKET_STATUS_PARAMETER_ERROR != ret) ||
4295 (NULL != payload) ||
4296 (0 != payload_len) ||
4297 (MHD_WEBSOCKET_VALIDITY_VALID != MHD_websocket_stream_is_valid (ws)))
4298 {
4299 fprintf (stderr,
4300 "Decode test failed in line %u\n",
4301 (unsigned int) __LINE__);
4302 ++failed;
4303 }
4304 if (((char *) (uintptr_t) 0xBAADF00D) == payload)
4305 {
4306 payload = NULL;
4307 }
4308 if (NULL != payload)
4309 {
4310 MHD_websocket_free (ws, payload);
4311 }
4312 /* Failure test: `payload` is NULL */
4313 payload_len = 0x87654321;
4314 streambuf_read_len = 1000;
4315 ret = MHD_websocket_decode (ws,
4316 "\x81\x85\x00\x00\x00\x00Hello",
4317 11,
4318 &streambuf_read_len,
4319 NULL,
4320 &payload_len);
4321 if ((MHD_WEBSOCKET_STATUS_PARAMETER_ERROR != ret) ||
4322 (0 != payload_len) ||
4323 (0 != streambuf_read_len) ||
4324 (MHD_WEBSOCKET_VALIDITY_VALID != MHD_websocket_stream_is_valid (ws)))
4325 {
4326 fprintf (stderr,
4327 "Decode test failed in line %u\n",
4328 (unsigned int) __LINE__);
4329 ++failed;
4330 }
4331 /* Failure test: `payload_len` is NULL */
4332 payload = (char *) (uintptr_t) 0xBAADF00D;
4333 streambuf_read_len = 1000;
4334 ret = MHD_websocket_decode (ws,
4335 "\x81\x85\x00\x00\x00\x00Hello",
4336 11,
4337 &streambuf_read_len,
4338 &payload,
4339 NULL);
4340 if ((MHD_WEBSOCKET_STATUS_PARAMETER_ERROR != ret) ||
4341 (NULL != payload) ||
4342 (0 != streambuf_read_len) ||
4343 (MHD_WEBSOCKET_VALIDITY_VALID != MHD_websocket_stream_is_valid (ws)))
4344 {
4345 fprintf (stderr,
4346 "Decode test failed in line %u\n",
4347 (unsigned int) __LINE__);
4348 ++failed;
4349 }
4350 if (((char *) (uintptr_t) 0xBAADF00D) == payload)
4351 {
4352 payload = NULL;
4353 }
4354 if (NULL != payload)
4355 {
4356 MHD_websocket_free (ws, payload);
4357 }
4358 /* Regular test: `buf` is NULL and `buf_len` is 0 */
4359 payload = (char *) (uintptr_t) 0xBAADF00D;
4360 payload_len = 0x87654321;
4361 streambuf_read_len = 1000;
4362 ret = MHD_websocket_decode (ws,
4363 NULL,
4364 0,
4365 &streambuf_read_len,
4366 &payload,
4367 &payload_len);
4368 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
4369 (NULL != payload) ||
4370 (0 != payload_len) ||
4371 (0 != streambuf_read_len) ||
4372 (MHD_WEBSOCKET_VALIDITY_VALID != MHD_websocket_stream_is_valid (ws)))
4373 {
4374 fprintf (stderr,
4375 "Decode test failed in line %u\n",
4376 (unsigned int) __LINE__);
4377 ++failed;
4378 }
4379 if (((char *) (uintptr_t) 0xBAADF00D) == payload)
4380 {
4381 payload = NULL;
4382 }
4383 if (NULL != payload)
4384 {
4385 MHD_websocket_free (ws, payload);
4386 }
4387 /* Regular test: `buf` is not NULL and `buf_len` is 0 */
4388 payload = (char *) (uintptr_t) 0xBAADF00D;
4389 payload_len = 0x87654321;
4390 streambuf_read_len = 1000;
4391 ret = MHD_websocket_decode (ws,
4392 "\x81\x85\x00\x00\x00\x00Hello",
4393 0,
4394 &streambuf_read_len,
4395 &payload,
4396 &payload_len);
4397 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
4398 (NULL != payload) ||
4399 (0 != payload_len) ||
4400 (0 != streambuf_read_len) ||
4401 (MHD_WEBSOCKET_VALIDITY_VALID != MHD_websocket_stream_is_valid (ws)))
4402 {
4403 fprintf (stderr,
4404 "Decode test failed in line %u\n",
4405 (unsigned int) __LINE__);
4406 ++failed;
4407 }
4408 if (((char *) (uintptr_t) 0xBAADF00D) == payload)
4409 {
4410 payload = NULL;
4411 }
4412 if (NULL != payload)
4413 {
4414 MHD_websocket_free (ws, payload);
4415 }
4416
4417 MHD_websocket_stream_free (ws);
4418 }
4419 else
4420 {
4421 fprintf (stderr,
4422 "Parameter decode tests failed in line %u\n",
4423 (unsigned int) __LINE__);
4424 ++failed;
4425 }
4426 }
4427
4428 /*
4429 ------------------------------------------------------------------------------
4430 validity after temporary out-of-memory
4431 ------------------------------------------------------------------------------
4432 */
4433 {
4434 struct MHD_WebSocketStream*ws;
4435 if (MHD_WEBSOCKET_STATUS_OK == MHD_websocket_stream_init2 (&ws,
4436 MHD_WEBSOCKET_FLAG_SERVER
4437 |
4438 MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
4439 0,
4440 test_malloc,
4441 test_realloc,
4442 test_free))
4443 {
4444 size_t streambuf_read_len = 0;
4445 char*payload = NULL;
4446 size_t payload_len = 0;
4447 int ret = 0;
4448
4449 /* Failure test: No memory allocation at the start */
4450 disable_alloc = 1;
4451 payload = (char *) (uintptr_t) 0xBAADF00D;
4452 payload_len = 0x87654321;
4453 streambuf_read_len = 1000;
4454 ret = MHD_websocket_decode (ws,
4455 "\x81\x85\x00\x00\x00\x00Hello",
4456 11,
4457 &streambuf_read_len,
4458 &payload,
4459 &payload_len);
4460 if ((MHD_WEBSOCKET_STATUS_MEMORY_ERROR != ret) ||
4461 (NULL != payload) ||
4462 (0 != payload_len) ||
4463 (1000 == streambuf_read_len) ||
4464 (MHD_WEBSOCKET_VALIDITY_VALID != MHD_websocket_stream_is_valid (ws)))
4465 {
4466 fprintf (stderr,
4467 "Decode test failed in line %u\n",
4468 (unsigned int) __LINE__);
4469 ++failed;
4470 }
4471 if (((char *) (uintptr_t) 0xBAADF00D) == payload)
4472 {
4473 payload = NULL;
4474 }
4475 if (NULL != payload)
4476 {
4477 MHD_websocket_free (ws, payload);
4478 }
4479 MHD_websocket_stream_free (ws);
4480 if (MHD_WEBSOCKET_STATUS_OK == MHD_websocket_stream_init2 (&ws,
4481 MHD_WEBSOCKET_FLAG_SERVER
4482 |
4483 MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
4484 0,
4485 test_malloc,
4486 test_realloc,
4487 test_free))
4488 {
4489 /* Failure test: No memory allocation after fragmented frame */
4490 disable_alloc = 0;
4491 payload = (char *) (uintptr_t) 0xBAADF00D;
4492 payload_len = 0x87654321;
4493 streambuf_read_len = 1000;
4494 ret = MHD_websocket_decode (ws,
4495 "\x01\x83\x00\x00\x00\x00" "Hel",
4496 9,
4497 &streambuf_read_len,
4498 &payload,
4499 &payload_len);
4500 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
4501 (NULL != payload) ||
4502 (0 != payload_len) ||
4503 (9 != streambuf_read_len) ||
4504 (MHD_WEBSOCKET_VALIDITY_VALID != MHD_websocket_stream_is_valid (
4505 ws)))
4506 {
4507 fprintf (stderr,
4508 "Decode test failed in line %u\n",
4509 (unsigned int) __LINE__);
4510 ++failed;
4511 }
4512 if (((char *) (uintptr_t) 0xBAADF00D) == payload)
4513 {
4514 payload = NULL;
4515 }
4516 if (NULL != payload)
4517 {
4518 MHD_websocket_free (ws, payload);
4519 }
4520 disable_alloc = 1;
4521 payload = (char *) (uintptr_t) 0xBAADF00D;
4522 payload_len = 0x87654321;
4523 streambuf_read_len = 1000;
4524 ret = MHD_websocket_decode (ws,
4525 "\x80\x82\x00\x00\x00\x00" "lo",
4526 8,
4527 &streambuf_read_len,
4528 &payload,
4529 &payload_len);
4530 if ((MHD_WEBSOCKET_STATUS_MEMORY_ERROR != ret) ||
4531 (NULL != payload) ||
4532 (0 != payload_len) ||
4533 (1000 == streambuf_read_len) ||
4534 (MHD_WEBSOCKET_VALIDITY_VALID != MHD_websocket_stream_is_valid (
4535 ws)))
4536 {
4537 fprintf (stderr,
4538 "Decode test failed in line %u\n",
4539 (unsigned int) __LINE__);
4540 ++failed;
4541 }
4542 if (((char *) (uintptr_t) 0xBAADF00D) == payload)
4543 {
4544 payload = NULL;
4545 }
4546 if (NULL != payload)
4547 {
4548 MHD_websocket_free (ws, payload);
4549 }
4550 /* Regular test: Success after memory allocation ok again */
4551 /* (streambuf_read_len may not be overwritten for this test) */
4552 disable_alloc = 0;
4553 payload = (char *) (uintptr_t) 0xBAADF00D;
4554 payload_len = 0x87654321;
4555 size_t old_streambuf_read_len = streambuf_read_len;
4556 ret = MHD_websocket_decode (ws,
4557 "\x80\x82\x00\x00\x00\x00lo"
4558 + old_streambuf_read_len,
4559 8 - old_streambuf_read_len,
4560 &streambuf_read_len,
4561 &payload,
4562 &payload_len);
4563 if ((MHD_WEBSOCKET_STATUS_TEXT_FRAME != ret) ||
4564 (NULL == payload) ||
4565 (5 != payload_len) ||
4566 (8 != streambuf_read_len + old_streambuf_read_len) ||
4567 (MHD_WEBSOCKET_VALIDITY_VALID != MHD_websocket_stream_is_valid (
4568 ws)) ||
4569 (0 != memcmp ("Hello", payload, 5)))
4570 {
4571 fprintf (stderr,
4572 "Decode test failed in line %u\n",
4573 (unsigned int) __LINE__);
4574 ++failed;
4575 }
4576 if (((char *) (uintptr_t) 0xBAADF00D) == payload)
4577 {
4578 payload = NULL;
4579 }
4580 if (NULL != payload)
4581 {
4582 MHD_websocket_free (ws, payload);
4583 }
4584
4585 MHD_websocket_stream_free (ws);
4586 }
4587 else
4588 {
4589 fprintf (stderr,
4590 "Memory decode test failed in line %u\n",
4591 (unsigned int) __LINE__);
4592 ++failed;
4593 }
4594 }
4595 else
4596 {
4597 fprintf (stderr,
4598 "Memory decode tests failed in line %u\n",
4599 (unsigned int) __LINE__);
4600 ++failed;
4601 }
4602 }
4603
4604 /*
4605 ------------------------------------------------------------------------------
4606 memory leak test, when freeing while decoding
4607 ------------------------------------------------------------------------------
4608 */
4609 {
4610 disable_alloc = 0;
4611 struct MHD_WebSocketStream*ws;
4612 size_t streambuf_read_len = 0;
4613 char*payload = NULL;
4614 size_t payload_len = 0;
4615 int ret = 0;
4616
4617 /* Regular test: Free while decoding of data frame */
4618 open_allocs = 0;
4619 if (MHD_WEBSOCKET_STATUS_OK == MHD_websocket_stream_init2 (&ws,
4620 MHD_WEBSOCKET_FLAG_SERVER
4621 |
4622 MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
4623 0,
4624 test_malloc,
4625 test_realloc,
4626 test_free))
4627 {
4628 ret = MHD_websocket_decode (ws,
4629 "\x81\x85\x00\x00\x00\x00Hel",
4630 9,
4631 &streambuf_read_len,
4632 &payload,
4633 &payload_len);
4634 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
4635 (0 != payload_len) ||
4636 (NULL != payload) ||
4637 (9 != streambuf_read_len) )
4638 {
4639 fprintf (stderr,
4640 "Memory decode test failed in line %u\n",
4641 (unsigned int) __LINE__);
4642 ++failed;
4643 }
4644 ret = MHD_websocket_stream_free (ws);
4645 if (MHD_WEBSOCKET_STATUS_OK != ret)
4646 {
4647 fprintf (stderr,
4648 "Memory decode test failed in line %u\n",
4649 (unsigned int) __LINE__);
4650 ++failed;
4651 }
4652 if (0 != open_allocs)
4653 {
4654 fprintf (stderr,
4655 "Memory decode test failed in line %u (memory leak detected)\n",
4656 (unsigned int) __LINE__);
4657 ++failed;
4658 }
4659 }
4660 else
4661 {
4662 fprintf (stderr,
4663 "Memory test failed in line %u\n",
4664 (unsigned int) __LINE__);
4665 ++failed;
4666 }
4667
4668 /* Regular test: Free while decoding of control frame */
4669 open_allocs = 0;
4670 if (MHD_WEBSOCKET_STATUS_OK == MHD_websocket_stream_init2 (&ws,
4671 MHD_WEBSOCKET_FLAG_SERVER
4672 |
4673 MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
4674 0,
4675 test_malloc,
4676 test_realloc,
4677 test_free))
4678 {
4679 ret = MHD_websocket_decode (ws,
4680 "\x88\x85\x00\x00\x00\x00Hel",
4681 9,
4682 &streambuf_read_len,
4683 &payload,
4684 &payload_len);
4685 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
4686 (0 != payload_len) ||
4687 (NULL != payload) ||
4688 (9 != streambuf_read_len) )
4689 {
4690 fprintf (stderr,
4691 "Memory decode test failed in line %u\n",
4692 (unsigned int) __LINE__);
4693 ++failed;
4694 }
4695 ret = MHD_websocket_stream_free (ws);
4696 if (MHD_WEBSOCKET_STATUS_OK != ret)
4697 {
4698 fprintf (stderr,
4699 "Memory decode test failed in line %u\n",
4700 (unsigned int) __LINE__);
4701 ++failed;
4702 }
4703 if (0 != open_allocs)
4704 {
4705 fprintf (stderr,
4706 "Memory decode test failed in line %u (memory leak detected)\n",
4707 (unsigned int) __LINE__);
4708 ++failed;
4709 }
4710 }
4711 else
4712 {
4713 fprintf (stderr,
4714 "Memory test failed in line %u\n",
4715 (unsigned int) __LINE__);
4716 ++failed;
4717 }
4718
4719 /* Regular test: Free while decoding of fragmented data frame */
4720 open_allocs = 0;
4721 if (MHD_WEBSOCKET_STATUS_OK == MHD_websocket_stream_init2 (&ws,
4722 MHD_WEBSOCKET_FLAG_SERVER
4723 |
4724 MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
4725 0,
4726 test_malloc,
4727 test_realloc,
4728 test_free))
4729 {
4730 ret = MHD_websocket_decode (ws,
4731 "\x01\x85\x00\x00\x00\x00Hello",
4732 11,
4733 &streambuf_read_len,
4734 &payload,
4735 &payload_len);
4736 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
4737 (0 != payload_len) ||
4738 (NULL != payload) ||
4739 (11 != streambuf_read_len) )
4740 {
4741 fprintf (stderr,
4742 "Memory decode test failed in line %u\n",
4743 (unsigned int) __LINE__);
4744 ++failed;
4745 }
4746 ret = MHD_websocket_stream_free (ws);
4747 if (MHD_WEBSOCKET_STATUS_OK != ret)
4748 {
4749 fprintf (stderr,
4750 "Memory decode test failed in line %u\n",
4751 (unsigned int) __LINE__);
4752 ++failed;
4753 }
4754 if (0 != open_allocs)
4755 {
4756 fprintf (stderr,
4757 "Memory decode test failed in line %u (memory leak detected)\n",
4758 (unsigned int) __LINE__);
4759 ++failed;
4760 }
4761 }
4762 else
4763 {
4764 fprintf (stderr,
4765 "Memory test failed in line %u\n",
4766 (unsigned int) __LINE__);
4767 ++failed;
4768 }
4769 /* Regular test: Free while decoding of continued fragmented data frame */
4770 open_allocs = 0;
4771 if (MHD_WEBSOCKET_STATUS_OK == MHD_websocket_stream_init2 (&ws,
4772 MHD_WEBSOCKET_FLAG_SERVER
4773 |
4774 MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
4775 0,
4776 test_malloc,
4777 test_realloc,
4778 test_free))
4779 {
4780 ret = MHD_websocket_decode (ws,
4781 "\x01\x85\x00\x00\x00\x00Hello",
4782 11,
4783 &streambuf_read_len,
4784 &payload,
4785 &payload_len);
4786 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
4787 (0 != payload_len) ||
4788 (NULL != payload) ||
4789 (11 != streambuf_read_len) )
4790 {
4791 fprintf (stderr,
4792 "Memory decode test failed in line %u\n",
4793 (unsigned int) __LINE__);
4794 ++failed;
4795 }
4796 ret = MHD_websocket_decode (ws,
4797 "\x80\x85\x00\x00\x00\x00Hel",
4798 9,
4799 &streambuf_read_len,
4800 &payload,
4801 &payload_len);
4802 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
4803 (0 != payload_len) ||
4804 (NULL != payload) ||
4805 (9 != streambuf_read_len) )
4806 {
4807 fprintf (stderr,
4808 "Memory decode test failed in line %u\n",
4809 (unsigned int) __LINE__);
4810 ++failed;
4811 }
4812 ret = MHD_websocket_stream_free (ws);
4813 if (MHD_WEBSOCKET_STATUS_OK != ret)
4814 {
4815 fprintf (stderr,
4816 "Memory decode test failed in line %u\n",
4817 (unsigned int) __LINE__);
4818 ++failed;
4819 }
4820 if (0 != open_allocs)
4821 {
4822 fprintf (stderr,
4823 "Memory decode test failed in line %u (memory leak detected)\n",
4824 (unsigned int) __LINE__);
4825 ++failed;
4826 }
4827 }
4828 else
4829 {
4830 fprintf (stderr,
4831 "Memory test failed in line %u\n",
4832 (unsigned int) __LINE__);
4833 ++failed;
4834 }
4835 /* Regular test: Free while decoding of control frame during fragmented data frame */
4836 open_allocs = 0;
4837 if (MHD_WEBSOCKET_STATUS_OK == MHD_websocket_stream_init2 (&ws,
4838 MHD_WEBSOCKET_FLAG_SERVER
4839 |
4840 MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
4841 0,
4842 test_malloc,
4843 test_realloc,
4844 test_free))
4845 {
4846 ret = MHD_websocket_decode (ws,
4847 "\x01\x85\x00\x00\x00\x00Hello",
4848 11,
4849 &streambuf_read_len,
4850 &payload,
4851 &payload_len);
4852 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
4853 (0 != payload_len) ||
4854 (NULL != payload) ||
4855 (11 != streambuf_read_len) )
4856 {
4857 fprintf (stderr,
4858 "Memory decode test failed in line %u\n",
4859 (unsigned int) __LINE__);
4860 ++failed;
4861 }
4862 ret = MHD_websocket_decode (ws,
4863 "\x88\x85\x00\x00\x00\x00Hel",
4864 9,
4865 &streambuf_read_len,
4866 &payload,
4867 &payload_len);
4868 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
4869 (0 != payload_len) ||
4870 (NULL != payload) ||
4871 (9 != streambuf_read_len) )
4872 {
4873 fprintf (stderr,
4874 "Memory decode test failed in line %u\n",
4875 (unsigned int) __LINE__);
4876 ++failed;
4877 }
4878 ret = MHD_websocket_stream_free (ws);
4879 if (MHD_WEBSOCKET_STATUS_OK != ret)
4880 {
4881 fprintf (stderr,
4882 "Memory decode test failed in line %u\n",
4883 (unsigned int) __LINE__);
4884 ++failed;
4885 }
4886 if (0 != open_allocs)
4887 {
4888 fprintf (stderr,
4889 "Memory decode test failed in line %u (memory leak detected)\n",
4890 (unsigned int) __LINE__);
4891 ++failed;
4892 }
4893 }
4894 else
4895 {
4896 fprintf (stderr,
4897 "Memory test failed in line %u\n",
4898 (unsigned int) __LINE__);
4899 ++failed;
4900 }
4901 }
4902
4903 if (NULL != buf1)
4904 {
4905 free (buf1);
4906 buf1 = NULL;
4907 }
4908 if (NULL != buf2)
4909 {
4910 free (buf2);
4911 buf2 = NULL;
4912 }
4913 return failed != 0 ? 0x04 : 0x00;
4914}
4915
4916
4917/**
4918 * Test procedure for `MHD_websocket_encode_text()`
4919 */
4920int
4921test_encodes_text ()
4922{
4923 int failed = 0;
4924 struct MHD_WebSocketStream*wss;
4925 struct MHD_WebSocketStream*wsc;
4926 int ret;
4927 char *buf1 = NULL, *buf2 = NULL;
4928 char*frame = NULL;
4929 size_t frame_len = 0;
4930 int utf8_step = 0;
4931
4932 if (MHD_WEBSOCKET_STATUS_OK != MHD_websocket_stream_init (&wsc,
4933 MHD_WEBSOCKET_FLAG_CLIENT,
4934 0))
4935 {
4936 fprintf (stderr,
4937 "No encode text tests possible due to failed stream init in line %u\n",
4938 (unsigned int) __LINE__);
4939 return 0x08;
4940 }
4941 if (MHD_WEBSOCKET_STATUS_OK != MHD_websocket_stream_init (&wss,
4942 MHD_WEBSOCKET_FLAG_SERVER,
4943 0))
4944 {
4945 fprintf (stderr,
4946 "No encode text tests possible due to failed stream init in line %u\n",
4947 (unsigned int) __LINE__);
4948 if (NULL != wsc)
4949 MHD_websocket_stream_free (wsc);
4950 return 0x08;
4951 }
4952
4953 /*
4954 ------------------------------------------------------------------------------
4955 Encoding
4956 ------------------------------------------------------------------------------
4957 */
4958 /* Regular test: Some data without UTF-8, we are server */
4959 ret = MHD_websocket_encode_text (wss,
4960 "blablabla",
4961 9,
4962 MHD_WEBSOCKET_FRAGMENTATION_NONE,
4963 &frame,
4964 &frame_len,
4965 NULL);
4966 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
4967 (11 != frame_len) ||
4968 (NULL == frame) ||
4969 (0 != memcmp (frame, "\x81\x09" "blablabla", 11)))
4970 {
4971 fprintf (stderr,
4972 "Encode text test failed in line %u\n",
4973 (unsigned int) __LINE__);
4974 ++failed;
4975 }
4976 if (NULL != frame)
4977 {
4978 MHD_websocket_free (wss, frame);
4979 frame = NULL;
4980 }
4981 /* Regular test: Some data without UTF-8, we are client */
4982 ret = MHD_websocket_encode_text (wsc,
4983 "blablabla",
4984 9,
4985 MHD_WEBSOCKET_FRAGMENTATION_NONE,
4986 &frame,
4987 &frame_len,
4988 NULL);
4989 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
4990 (15 != frame_len) ||
4991 (NULL == frame) )
4992 {
4993 fprintf (stderr,
4994 "Encode text test failed in line %u\n",
4995 (unsigned int) __LINE__);
4996 ++failed;
4997 }
4998 else
4999 {
5000 failed += test_decode_single (__LINE__,
5001 MHD_WEBSOCKET_FLAG_SERVER
5002 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
5003 0,
5004 1,
5005 0,
5006 frame,
5007 frame_len,
5008 "blablabla",
5009 9,
5010 MHD_WEBSOCKET_STATUS_TEXT_FRAME,
5011 MHD_WEBSOCKET_VALIDITY_VALID,
5012 frame_len);
5013 }
5014 if (NULL != frame)
5015 {
5016 MHD_websocket_free (wsc, frame);
5017 frame = NULL;
5018 }
5019 /* Regular test: Some data with UTF-8, we are server */
5020 ret = MHD_websocket_encode_text (wss,
5021 "bla" "\xC3\xA4" "blabla",
5022 11,
5023 MHD_WEBSOCKET_FRAGMENTATION_NONE,
5024 &frame,
5025 &frame_len,
5026 NULL);
5027 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
5028 (13 != frame_len) ||
5029 (NULL == frame) ||
5030 (0 != memcmp (frame, "\x81\x0B" "bla" "\xC3\xA4" "blabla", 13)))
5031 {
5032 fprintf (stderr,
5033 "Encode text test failed in line %u\n",
5034 (unsigned int) __LINE__);
5035 ++failed;
5036 }
5037 if (NULL != frame)
5038 {
5039 MHD_websocket_free (wss, frame);
5040 frame = NULL;
5041 }
5042 /* Regular test: Some data with UTF-8, we are client */
5043 ret = MHD_websocket_encode_text (wsc,
5044 "bla" "\xC3\xA4" "blabla",
5045 11,
5046 MHD_WEBSOCKET_FRAGMENTATION_NONE,
5047 &frame,
5048 &frame_len,
5049 NULL);
5050 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
5051 (17 != frame_len) ||
5052 (NULL == frame) )
5053 {
5054 fprintf (stderr,
5055 "Encode text test failed in line %u\n",
5056 (unsigned int) __LINE__);
5057 ++failed;
5058 }
5059 else
5060 {
5061 failed += test_decode_single (__LINE__,
5062 MHD_WEBSOCKET_FLAG_SERVER
5063 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
5064 0,
5065 1,
5066 0,
5067 frame,
5068 frame_len,
5069 "bla" "\xC3\xA4" "blabla",
5070 11,
5071 MHD_WEBSOCKET_STATUS_TEXT_FRAME,
5072 MHD_WEBSOCKET_VALIDITY_VALID,
5073 frame_len);
5074 }
5075 if (NULL != frame)
5076 {
5077 MHD_websocket_free (wsc, frame);
5078 frame = NULL;
5079 }
5080 /* Edge test (success): Some data with NUL characters, we are server */
5081 ret = MHD_websocket_encode_text (wss,
5082 "bla" "\0\0\0" "bla",
5083 9,
5084 MHD_WEBSOCKET_FRAGMENTATION_NONE,
5085 &frame,
5086 &frame_len,
5087 NULL);
5088 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
5089 (11 != frame_len) ||
5090 (NULL == frame) ||
5091 (0 != memcmp (frame, "\x81\x09" "bla" "\0\0\0" "bla", 11)))
5092 {
5093 fprintf (stderr,
5094 "Encode text test failed in line %u\n",
5095 (unsigned int) __LINE__);
5096 ++failed;
5097 }
5098 if (NULL != frame)
5099 {
5100 MHD_websocket_free (wss, frame);
5101 frame = NULL;
5102 }
5103 /* Fail test: Some data with broken UTF-8, we are server */
5104 ret = MHD_websocket_encode_text (wss,
5105 "bla" "\xC3" "blabla",
5106 10,
5107 MHD_WEBSOCKET_FRAGMENTATION_NONE,
5108 &frame,
5109 &frame_len,
5110 NULL);
5111 if ((MHD_WEBSOCKET_STATUS_UTF8_ENCODING_ERROR != ret) ||
5112 (0 != frame_len) ||
5113 (NULL != frame) )
5114 {
5115 fprintf (stderr,
5116 "Encode text test failed in line %u\n",
5117 (unsigned int) __LINE__);
5118 ++failed;
5119 }
5120 if (NULL != frame)
5121 {
5122 MHD_websocket_free (wss, frame);
5123 frame = NULL;
5124 }
5125
5126 /*
5127 ------------------------------------------------------------------------------
5128 Fragmentation
5129 ------------------------------------------------------------------------------
5130 */
5131 /* Regular test: Some data without UTF-8 */
5132 ret = MHD_websocket_encode_text (wss,
5133 "blablabla",
5134 9,
5135 MHD_WEBSOCKET_FRAGMENTATION_NONE,
5136 &frame,
5137 &frame_len,
5138 &utf8_step);
5139 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
5140 (11 != frame_len) ||
5141 (NULL == frame) ||
5142 (MHD_WEBSOCKET_UTF8STEP_NORMAL != utf8_step) ||
5143 (0 != memcmp (frame, "\x81\x09" "blablabla", 11)))
5144 {
5145 fprintf (stderr,
5146 "Encode text test failed in line %u\n",
5147 (unsigned int) __LINE__);
5148 ++failed;
5149 }
5150 if (NULL != frame)
5151 {
5152 MHD_websocket_free (wss, frame);
5153 frame = NULL;
5154 }
5155 /* Regular test: First fragment without UTF-8 */
5156 ret = MHD_websocket_encode_text (wss,
5157 "blablabla",
5158 9,
5159 MHD_WEBSOCKET_FRAGMENTATION_FIRST,
5160 &frame,
5161 &frame_len,
5162 &utf8_step);
5163 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
5164 (11 != frame_len) ||
5165 (NULL == frame) ||
5166 (MHD_WEBSOCKET_UTF8STEP_NORMAL != utf8_step) ||
5167 (0 != memcmp (frame, "\x01\x09" "blablabla", 11)))
5168 {
5169 fprintf (stderr,
5170 "Encode text test failed in line %u\n",
5171 (unsigned int) __LINE__);
5172 ++failed;
5173 }
5174 if (NULL != frame)
5175 {
5176 MHD_websocket_free (wss, frame);
5177 frame = NULL;
5178 }
5179 /* Regular test: Middle fragment without UTF-8 */
5180 ret = MHD_websocket_encode_text (wss,
5181 "blablabla",
5182 9,
5183 MHD_WEBSOCKET_FRAGMENTATION_FOLLOWING,
5184 &frame,
5185 &frame_len,
5186 &utf8_step);
5187 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
5188 (11 != frame_len) ||
5189 (NULL == frame) ||
5190 (MHD_WEBSOCKET_UTF8STEP_NORMAL != utf8_step) ||
5191 (0 != memcmp (frame, "\x00\x09" "blablabla", 11)))
5192 {
5193 fprintf (stderr,
5194 "Encode text test failed in line %u\n",
5195 (unsigned int) __LINE__);
5196 ++failed;
5197 }
5198 if (NULL != frame)
5199 {
5200 MHD_websocket_free (wss, frame);
5201 frame = NULL;
5202 }
5203 /* Regular test: Last fragment without UTF-8 */
5204 ret = MHD_websocket_encode_text (wss,
5205 "blablabla",
5206 9,
5207 MHD_WEBSOCKET_FRAGMENTATION_LAST,
5208 &frame,
5209 &frame_len,
5210 &utf8_step);
5211 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
5212 (11 != frame_len) ||
5213 (NULL == frame) ||
5214 (MHD_WEBSOCKET_UTF8STEP_NORMAL != utf8_step) ||
5215 (0 != memcmp (frame, "\x80\x09" "blablabla", 11)))
5216 {
5217 fprintf (stderr,
5218 "Encode text test failed in line %u\n",
5219 (unsigned int) __LINE__);
5220 ++failed;
5221 }
5222 if (NULL != frame)
5223 {
5224 MHD_websocket_free (wss, frame);
5225 frame = NULL;
5226 }
5227 /* Edge test (success): First fragment with UTF-8 on the edge */
5228 ret = MHD_websocket_encode_text (wss,
5229 "blablabl\xC3",
5230 9,
5231 MHD_WEBSOCKET_FRAGMENTATION_FIRST,
5232 &frame,
5233 &frame_len,
5234 &utf8_step);
5235 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
5236 (11 != frame_len) ||
5237 (NULL == frame) ||
5238 (MHD_WEBSOCKET_UTF8STEP_UTF2TAIL_1OF1 != utf8_step) ||
5239 (0 != memcmp (frame, "\x01\x09" "blablabl\xC3", 11)))
5240 {
5241 fprintf (stderr,
5242 "Encode text test failed in line %u\n",
5243 (unsigned int) __LINE__);
5244 ++failed;
5245 }
5246 if (NULL != frame)
5247 {
5248 MHD_websocket_free (wss, frame);
5249 frame = NULL;
5250 }
5251 /* Edge test (success): Last fragment with UTF-8 on the edge */
5252 ret = MHD_websocket_encode_text (wss,
5253 "\xA4" "blablabla",
5254 10,
5255 MHD_WEBSOCKET_FRAGMENTATION_LAST,
5256 &frame,
5257 &frame_len,
5258 &utf8_step);
5259 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
5260 (12 != frame_len) ||
5261 (NULL == frame) ||
5262 (MHD_WEBSOCKET_UTF8STEP_NORMAL != utf8_step) ||
5263 (0 != memcmp (frame, "\x80\x0A" "\xA4" "blablabla", 12)))
5264 {
5265 fprintf (stderr,
5266 "Encode text test failed in line %u\n",
5267 (unsigned int) __LINE__);
5268 ++failed;
5269 }
5270 if (NULL != frame)
5271 {
5272 MHD_websocket_free (wss, frame);
5273 frame = NULL;
5274 }
5275 /* Fail test: Last fragment with UTF-8 on the edge (here with wrong old utf8_step) */
5276 utf8_step = MHD_WEBSOCKET_UTF8STEP_NORMAL;
5277 ret = MHD_websocket_encode_text (wss,
5278 "\xA4" "blablabla",
5279 10,
5280 MHD_WEBSOCKET_FRAGMENTATION_LAST,
5281 &frame,
5282 &frame_len,
5283 &utf8_step);
5284 if ((MHD_WEBSOCKET_STATUS_UTF8_ENCODING_ERROR != ret) ||
5285 (0 != frame_len) ||
5286 (NULL != frame) ||
5287 (MHD_WEBSOCKET_UTF8STEP_NORMAL != utf8_step) )
5288 {
5289 fprintf (stderr,
5290 "Encode text test failed in line %u\n",
5291 (unsigned int) __LINE__);
5292 ++failed;
5293 }
5294 if (NULL != frame)
5295 {
5296 MHD_websocket_free (wss, frame);
5297 frame = NULL;
5298 }
5299 /* Regular test: Last fragment with UTF-8 on the edge for UTF2TAIL_1OF1 */
5300 utf8_step = MHD_WEBSOCKET_UTF8STEP_UTF2TAIL_1OF1;
5301 ret = MHD_websocket_encode_text (wss,
5302 "\xA4" "blablabla",
5303 10,
5304 MHD_WEBSOCKET_FRAGMENTATION_LAST,
5305 &frame,
5306 &frame_len,
5307 &utf8_step);
5308 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
5309 (12 != frame_len) ||
5310 (NULL == frame) ||
5311 (MHD_WEBSOCKET_UTF8STEP_NORMAL != utf8_step) ||
5312 (0 != memcmp (frame, "\x80\x0A" "\xA4" "blablabla", 12)))
5313 {
5314 fprintf (stderr,
5315 "Encode text test failed in line %u\n",
5316 (unsigned int) __LINE__);
5317 ++failed;
5318 }
5319 if (NULL != frame)
5320 {
5321 MHD_websocket_free (wss, frame);
5322 frame = NULL;
5323 }
5324 /* Regular test: Last fragment with UTF-8 on the edge for UTF3TAIL1_1OF2 */
5325 utf8_step = MHD_WEBSOCKET_UTF8STEP_UTF3TAIL1_1OF2;
5326 ret = MHD_websocket_encode_text (wss,
5327 "\xA0\x80" "blablabla",
5328 11,
5329 MHD_WEBSOCKET_FRAGMENTATION_LAST,
5330 &frame,
5331 &frame_len,
5332 &utf8_step);
5333 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
5334 (13 != frame_len) ||
5335 (NULL == frame) ||
5336 (MHD_WEBSOCKET_UTF8STEP_NORMAL != utf8_step) ||
5337 (0 != memcmp (frame, "\x80\x0B" "\xA0\x80" "blablabla", 13)))
5338 {
5339 fprintf (stderr,
5340 "Encode text test failed in line %u\n",
5341 (unsigned int) __LINE__);
5342 ++failed;
5343 }
5344 if (NULL != frame)
5345 {
5346 MHD_websocket_free (wss, frame);
5347 frame = NULL;
5348 }
5349 /* Regular test: Last fragment with UTF-8 on the edge for UTF3TAIL2_1OF2 */
5350 utf8_step = MHD_WEBSOCKET_UTF8STEP_UTF3TAIL2_1OF2;
5351 ret = MHD_websocket_encode_text (wss,
5352 "\x80\x80" "blablabla",
5353 11,
5354 MHD_WEBSOCKET_FRAGMENTATION_LAST,
5355 &frame,
5356 &frame_len,
5357 &utf8_step);
5358 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
5359 (13 != frame_len) ||
5360 (NULL == frame) ||
5361 (MHD_WEBSOCKET_UTF8STEP_NORMAL != utf8_step) ||
5362 (0 != memcmp (frame, "\x80\x0B" "\x80\x80" "blablabla", 13)))
5363 {
5364 fprintf (stderr,
5365 "Encode text test failed in line %u\n",
5366 (unsigned int) __LINE__);
5367 ++failed;
5368 }
5369 if (NULL != frame)
5370 {
5371 MHD_websocket_free (wss, frame);
5372 frame = NULL;
5373 }
5374 /* Regular test: Last fragment with UTF-8 on the edge for UTF3TAIL_1OF2 */
5375 utf8_step = MHD_WEBSOCKET_UTF8STEP_UTF3TAIL_1OF2;
5376 ret = MHD_websocket_encode_text (wss,
5377 "\x80\x80" "blablabla",
5378 11,
5379 MHD_WEBSOCKET_FRAGMENTATION_LAST,
5380 &frame,
5381 &frame_len,
5382 &utf8_step);
5383 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
5384 (13 != frame_len) ||
5385 (NULL == frame) ||
5386 (MHD_WEBSOCKET_UTF8STEP_NORMAL != utf8_step) ||
5387 (0 != memcmp (frame, "\x80\x0B" "\x80\x80" "blablabla", 13)))
5388 {
5389 fprintf (stderr,
5390 "Encode text test failed in line %u\n",
5391 (unsigned int) __LINE__);
5392 ++failed;
5393 }
5394 if (NULL != frame)
5395 {
5396 MHD_websocket_free (wss, frame);
5397 frame = NULL;
5398 }
5399 /* Regular test: Last fragment with UTF-8 on the edge for UTF3TAIL_2OF2 */
5400 utf8_step = MHD_WEBSOCKET_UTF8STEP_UTF3TAIL_2OF2;
5401 ret = MHD_websocket_encode_text (wss,
5402 "\x80" " blablabla",
5403 11,
5404 MHD_WEBSOCKET_FRAGMENTATION_LAST,
5405 &frame,
5406 &frame_len,
5407 &utf8_step);
5408 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
5409 (13 != frame_len) ||
5410 (NULL == frame) ||
5411 (MHD_WEBSOCKET_UTF8STEP_NORMAL != utf8_step) ||
5412 (0 != memcmp (frame, "\x80\x0B" "\x80" " blablabla", 13)))
5413 {
5414 fprintf (stderr,
5415 "Encode text test failed in line %u\n",
5416 (unsigned int) __LINE__);
5417 ++failed;
5418 }
5419 if (NULL != frame)
5420 {
5421 MHD_websocket_free (wss, frame);
5422 frame = NULL;
5423 }
5424 /* Regular test: Last fragment with UTF-8 on the edge for UTF4TAIL1_1OF3 */
5425 utf8_step = MHD_WEBSOCKET_UTF8STEP_UTF4TAIL1_1OF3;
5426 ret = MHD_websocket_encode_text (wss,
5427 "\x90\x80\x80" "blablabla",
5428 12,
5429 MHD_WEBSOCKET_FRAGMENTATION_LAST,
5430 &frame,
5431 &frame_len,
5432 &utf8_step);
5433 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
5434 (14 != frame_len) ||
5435 (NULL == frame) ||
5436 (MHD_WEBSOCKET_UTF8STEP_NORMAL != utf8_step) ||
5437 (0 != memcmp (frame, "\x80\x0C" "\x90\x80\x80" "blablabla", 14)))
5438 {
5439 fprintf (stderr,
5440 "Encode text test failed in line %u\n",
5441 (unsigned int) __LINE__);
5442 ++failed;
5443 }
5444 if (NULL != frame)
5445 {
5446 MHD_websocket_free (wss, frame);
5447 frame = NULL;
5448 }
5449 /* Regular test: Last fragment with UTF-8 on the edge for UTF4TAIL2_1OF3 */
5450 utf8_step = MHD_WEBSOCKET_UTF8STEP_UTF4TAIL2_1OF3;
5451 ret = MHD_websocket_encode_text (wss,
5452 "\x80\x80\x80" "blablabla",
5453 12,
5454 MHD_WEBSOCKET_FRAGMENTATION_LAST,
5455 &frame,
5456 &frame_len,
5457 &utf8_step);
5458 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
5459 (14 != frame_len) ||
5460 (NULL == frame) ||
5461 (MHD_WEBSOCKET_UTF8STEP_NORMAL != utf8_step) ||
5462 (0 != memcmp (frame, "\x80\x0C" "\x80\x80\x80" "blablabla", 14)))
5463 {
5464 fprintf (stderr,
5465 "Encode text test failed in line %u\n",
5466 (unsigned int) __LINE__);
5467 ++failed;
5468 }
5469 if (NULL != frame)
5470 {
5471 MHD_websocket_free (wss, frame);
5472 frame = NULL;
5473 }
5474 /* Regular test: Last fragment with UTF-8 on the edge for UTF4TAIL_1OF3 */
5475 utf8_step = MHD_WEBSOCKET_UTF8STEP_UTF4TAIL_1OF3;
5476 ret = MHD_websocket_encode_text (wss,
5477 "\x80\x80\x80" "blablabla",
5478 12,
5479 MHD_WEBSOCKET_FRAGMENTATION_LAST,
5480 &frame,
5481 &frame_len,
5482 &utf8_step);
5483 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
5484 (14 != frame_len) ||
5485 (NULL == frame) ||
5486 (MHD_WEBSOCKET_UTF8STEP_NORMAL != utf8_step) ||
5487 (0 != memcmp (frame, "\x80\x0C" "\x80\x80\x80" "blablabla", 14)))
5488 {
5489 fprintf (stderr,
5490 "Encode text test failed in line %u\n",
5491 (unsigned int) __LINE__);
5492 ++failed;
5493 }
5494 if (NULL != frame)
5495 {
5496 MHD_websocket_free (wss, frame);
5497 frame = NULL;
5498 }
5499 /* Regular test: Last fragment with UTF-8 on the edge for UTF4TAIL_2OF3 */
5500 utf8_step = MHD_WEBSOCKET_UTF8STEP_UTF4TAIL_2OF3;
5501 ret = MHD_websocket_encode_text (wss,
5502 "\x80\x80" " blablabla",
5503 12,
5504 MHD_WEBSOCKET_FRAGMENTATION_LAST,
5505 &frame,
5506 &frame_len,
5507 &utf8_step);
5508 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
5509 (14 != frame_len) ||
5510 (NULL == frame) ||
5511 (MHD_WEBSOCKET_UTF8STEP_NORMAL != utf8_step) ||
5512 (0 != memcmp (frame, "\x80\x0C" "\x80\x80" " blablabla", 14)))
5513 {
5514 fprintf (stderr,
5515 "Encode text test failed in line %u\n",
5516 (unsigned int) __LINE__);
5517 ++failed;
5518 }
5519 if (NULL != frame)
5520 {
5521 MHD_websocket_free (wss, frame);
5522 frame = NULL;
5523 }
5524 /* Regular test: Last fragment with UTF-8 on the edge for UTF4TAIL_3OF3 */
5525 utf8_step = MHD_WEBSOCKET_UTF8STEP_UTF4TAIL_3OF3;
5526 ret = MHD_websocket_encode_text (wss,
5527 "\x80" " blablabla",
5528 12,
5529 MHD_WEBSOCKET_FRAGMENTATION_LAST,
5530 &frame,
5531 &frame_len,
5532 &utf8_step);
5533 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
5534 (14 != frame_len) ||
5535 (NULL == frame) ||
5536 (MHD_WEBSOCKET_UTF8STEP_NORMAL != utf8_step) ||
5537 (0 != memcmp (frame, "\x80\x0C" "\x80" " blablabla", 14)))
5538 {
5539 fprintf (stderr,
5540 "Encode text test failed in line %u\n",
5541 (unsigned int) __LINE__);
5542 ++failed;
5543 }
5544 if (NULL != frame)
5545 {
5546 MHD_websocket_free (wss, frame);
5547 frame = NULL;
5548 }
5549
5550 /*
5551 ------------------------------------------------------------------------------
5552 Length checks
5553 ------------------------------------------------------------------------------
5554 */
5555 /* Edge test (success): Text frame without data */
5556 ret = MHD_websocket_encode_text (wss,
5557 NULL,
5558 0,
5559 MHD_WEBSOCKET_FRAGMENTATION_NONE,
5560 &frame,
5561 &frame_len,
5562 NULL);
5563 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
5564 (2 != frame_len) ||
5565 (NULL == frame) ||
5566 (0 != memcmp (frame, "\x81\x00", 2)))
5567 {
5568 fprintf (stderr,
5569 "Encode text test failed in line %u\n",
5570 (unsigned int) __LINE__);
5571 ++failed;
5572 }
5573 if (NULL != frame)
5574 {
5575 MHD_websocket_free (wss, frame);
5576 frame = NULL;
5577 }
5578 /* Edge test (success): Text frame with 1 byte of data */
5579 ret = MHD_websocket_encode_text (wss,
5580 "a",
5581 1,
5582 MHD_WEBSOCKET_FRAGMENTATION_NONE,
5583 &frame,
5584 &frame_len,
5585 NULL);
5586 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
5587 (3 != frame_len) ||
5588 (NULL == frame) ||
5589 (0 != memcmp (frame, "\x81\x01" "a", 3)))
5590 {
5591 fprintf (stderr,
5592 "Encode text test failed in line %u\n",
5593 (unsigned int) __LINE__);
5594 ++failed;
5595 }
5596 if (NULL != frame)
5597 {
5598 MHD_websocket_free (wss, frame);
5599 frame = NULL;
5600 }
5601 /* Edge test (success): Text frame with 125 bytes of data */
5602 ret = MHD_websocket_encode_text (wss,
5603 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ012345678",
5604 125,
5605 MHD_WEBSOCKET_FRAGMENTATION_NONE,
5606 &frame,
5607 &frame_len,
5608 NULL);
5609 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
5610 (127 != frame_len) ||
5611 (NULL == frame) ||
5612 (0 != memcmp (frame, "\x81\x7D"
5613 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ012345678",
5614 127)))
5615 {
5616 fprintf (stderr,
5617 "Encode text test failed in line %u\n",
5618 (unsigned int) __LINE__);
5619 ++failed;
5620 }
5621 if (NULL != frame)
5622 {
5623 MHD_websocket_free (wss, frame);
5624 frame = NULL;
5625 }
5626 /* Edge test (success): Text frame with 126 bytes of data */
5627 ret = MHD_websocket_encode_text (wss,
5628 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789",
5629 126,
5630 MHD_WEBSOCKET_FRAGMENTATION_NONE,
5631 &frame,
5632 &frame_len,
5633 NULL);
5634 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
5635 (130 != frame_len) ||
5636 (NULL == frame) ||
5637 (0 != memcmp (frame, "\x81\x7E\x00\x7E"
5638 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789",
5639 130)))
5640 {
5641 fprintf (stderr,
5642 "Encode text test failed in line %u\n",
5643 (unsigned int) __LINE__);
5644 ++failed;
5645 }
5646 if (NULL != frame)
5647 {
5648 MHD_websocket_free (wss, frame);
5649 frame = NULL;
5650 }
5651 /* Edge test (success): Text frame with 65535 bytes of data */
5652 allocate_length_test_data (&buf1,
5653 &buf2,
5654 65535,
5655 "\x81\x7E\xFF\xFF",
5656 4);
5657 ret = MHD_websocket_encode_text (wss,
5658 buf2,
5659 65535,
5660 MHD_WEBSOCKET_FRAGMENTATION_NONE,
5661 &frame,
5662 &frame_len,
5663 NULL);
5664 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
5665 (65535 + 4 != frame_len) ||
5666 (NULL == frame) ||
5667 (0 != memcmp (frame, buf1, 65535 + 4)))
5668 {
5669 fprintf (stderr,
5670 "Encode text test failed in line %u\n",
5671 (unsigned int) __LINE__);
5672 ++failed;
5673 }
5674 if (NULL != frame)
5675 {
5676 MHD_websocket_free (wss, frame);
5677 frame = NULL;
5678 }
5679 /* Edge test (success): Text frame with 65536 bytes of data */
5680 allocate_length_test_data (&buf1,
5681 &buf2,
5682 65536,
5683 "\x81\x7F\x00\x00\x00\x00\x00\x01\x00\x00",
5684 10);
5685 ret = MHD_websocket_encode_text (wss,
5686 buf2,
5687 65536,
5688 MHD_WEBSOCKET_FRAGMENTATION_NONE,
5689 &frame,
5690 &frame_len,
5691 NULL);
5692 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
5693 (65536 + 10 != frame_len) ||
5694 (NULL == frame) ||
5695 (0 != memcmp (frame, buf1, 65536 + 10)))
5696 {
5697 fprintf (stderr,
5698 "Encode text test failed in line %u\n",
5699 (unsigned int) __LINE__);
5700 ++failed;
5701 }
5702 if (NULL != frame)
5703 {
5704 MHD_websocket_free (wss, frame);
5705 frame = NULL;
5706 }
5707 /* Regular test: Text frame with 100 MB of data */
5708 allocate_length_test_data (&buf1,
5709 &buf2,
5710 104857600,
5711 "\x81\x7F\x00\x00\x00\x00\x06\x40\x00\x00",
5712 10);
5713 ret = MHD_websocket_encode_text (wss,
5714 buf2,
5715 104857600,
5716 MHD_WEBSOCKET_FRAGMENTATION_NONE,
5717 &frame,
5718 &frame_len,
5719 NULL);
5720 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
5721 (104857600 + 10 != frame_len) ||
5722 (NULL == frame) ||
5723 (0 != memcmp (frame, buf1, 104857600 + 10)))
5724 {
5725 fprintf (stderr,
5726 "Encode text test failed in line %u\n",
5727 (unsigned int) __LINE__);
5728 ++failed;
5729 }
5730 if (NULL != frame)
5731 {
5732 MHD_websocket_free (wss, frame);
5733 frame = NULL;
5734 }
5735 if (NULL != buf1)
5736 {
5737 free (buf1);
5738 buf1 = NULL;
5739 }
5740 if (NULL != buf2)
5741 {
5742 free (buf2);
5743 buf2 = NULL;
5744 }
5745 /* Fail test: frame_len is greater than 0x7FFFFFFFFFFFFFFF
5746 (this is the maximum allowed payload size) */
5747 frame_len = 0;
5748 ret = MHD_websocket_encode_text (wss,
5749 "abc",
5750 (uint64_t) 0x8000000000000000,
5751 MHD_WEBSOCKET_FRAGMENTATION_NONE,
5752 &frame,
5753 &frame_len,
5754 NULL);
5755 if ((MHD_WEBSOCKET_STATUS_MAXIMUM_SIZE_EXCEEDED != ret) ||
5756 (0 != frame_len) ||
5757 (NULL != frame) )
5758 {
5759 fprintf (stderr,
5760 "Encode text test failed in line %u\n",
5761 (unsigned int) __LINE__);
5762 ++failed;
5763 }
5764 if (NULL != frame)
5765 {
5766 MHD_websocket_free (wss, frame);
5767 frame = NULL;
5768 }
5769
5770 /*
5771 ------------------------------------------------------------------------------
5772 Wrong parameters
5773 ------------------------------------------------------------------------------
5774 */
5775 /* Fail test: `ws` not passed */
5776 frame = (char*) (uintptr_t) 0xBAADF00D;
5777 frame_len = 0x87654321;
5778 ret = MHD_websocket_encode_text (NULL,
5779 "abc",
5780 3,
5781 MHD_WEBSOCKET_FRAGMENTATION_NONE,
5782 &frame,
5783 &frame_len,
5784 NULL);
5785 if ((MHD_WEBSOCKET_STATUS_PARAMETER_ERROR != ret) ||
5786 (0 != frame_len) ||
5787 (NULL != frame) )
5788 {
5789 fprintf (stderr,
5790 "Encode text test failed in line %u\n",
5791 (unsigned int) __LINE__);
5792 ++failed;
5793 }
5794 if (((char*) (uintptr_t) 0xBAADF00D) == frame)
5795 {
5796 frame = NULL;
5797 }
5798 if (NULL != frame)
5799 {
5800 MHD_websocket_free (wss, frame);
5801 frame = NULL;
5802 }
5803 /* Fail test: `payload_utf8` not passed, but `payload_utf8_len` != 0 */
5804 frame = (char*) (uintptr_t) 0xBAADF00D;
5805 frame_len = 0x87654321;
5806 ret = MHD_websocket_encode_text (wss,
5807 NULL,
5808 3,
5809 MHD_WEBSOCKET_FRAGMENTATION_NONE,
5810 &frame,
5811 &frame_len,
5812 NULL);
5813 if ((MHD_WEBSOCKET_STATUS_PARAMETER_ERROR != ret) ||
5814 (0 != frame_len) ||
5815 (NULL != frame) )
5816 {
5817 fprintf (stderr,
5818 "Encode text test failed in line %u\n",
5819 (unsigned int) __LINE__);
5820 ++failed;
5821 }
5822 if (((char*) (uintptr_t) 0xBAADF00D) == frame)
5823 {
5824 frame = NULL;
5825 }
5826 if (NULL != frame)
5827 {
5828 MHD_websocket_free (wss, frame);
5829 frame = NULL;
5830 }
5831 /* Regular test: `payload_utf8` passed, but `payload_utf8_len` == 0 */
5832 frame = (char*) (uintptr_t) 0xBAADF00D;
5833 frame_len = 0x87654321;
5834 ret = MHD_websocket_encode_text (wss,
5835 "abc",
5836 0,
5837 MHD_WEBSOCKET_FRAGMENTATION_NONE,
5838 &frame,
5839 &frame_len,
5840 NULL);
5841 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
5842 (2 != frame_len) ||
5843 (NULL == frame) ||
5844 (((char*) (uintptr_t) 0xBAADF00D) == frame) ||
5845 (0 != memcmp (frame, "\x81\x00", 2)))
5846 {
5847 fprintf (stderr,
5848 "Encode text test failed in line %u\n",
5849 (unsigned int) __LINE__);
5850 ++failed;
5851 }
5852 if (((char*) (uintptr_t) 0xBAADF00D) == frame)
5853 {
5854 frame = NULL;
5855 }
5856 if (NULL != frame)
5857 {
5858 MHD_websocket_free (wss, frame);
5859 frame = NULL;
5860 }
5861 /* Fail test: `frame` not passed */
5862 frame_len = 0x87654321;
5863 ret = MHD_websocket_encode_text (wss,
5864 "abc",
5865 3,
5866 MHD_WEBSOCKET_FRAGMENTATION_NONE,
5867 NULL,
5868 &frame_len,
5869 NULL);
5870 if ((MHD_WEBSOCKET_STATUS_PARAMETER_ERROR != ret) ||
5871 (0 != frame_len) )
5872 {
5873 fprintf (stderr,
5874 "Encode text test failed in line %u\n",
5875 (unsigned int) __LINE__);
5876 ++failed;
5877 }
5878 /* Fail test: `frame_len` not passed */
5879 frame = (char*) (uintptr_t) 0xBAADF00D;
5880 ret = MHD_websocket_encode_text (wss,
5881 "abc",
5882 3,
5883 MHD_WEBSOCKET_FRAGMENTATION_NONE,
5884 &frame,
5885 NULL,
5886 NULL);
5887 if ((MHD_WEBSOCKET_STATUS_PARAMETER_ERROR != ret) ||
5888 (NULL != frame) )
5889 {
5890 fprintf (stderr,
5891 "Encode text test failed in line %u\n",
5892 (unsigned int) __LINE__);
5893 ++failed;
5894 }
5895 if (((char*) (uintptr_t) 0xBAADF00D) == frame)
5896 {
5897 frame = NULL;
5898 }
5899 if (NULL != frame)
5900 {
5901 MHD_websocket_free (wss, frame);
5902 frame = NULL;
5903 }
5904 /* Regular test: `utf8_step` passed for non-fragmentation
5905 (is allowed and `utf8_step` will be filled then) */
5906 frame = (char*) (uintptr_t) 0xBAADF00D;
5907 frame_len = 0x87654321;
5908 utf8_step = -99;
5909 ret = MHD_websocket_encode_text (wss,
5910 "abc",
5911 3,
5912 MHD_WEBSOCKET_FRAGMENTATION_NONE,
5913 &frame,
5914 &frame_len,
5915 &utf8_step);
5916 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
5917 (5 != frame_len) ||
5918 (NULL == frame) ||
5919 (((char*) (uintptr_t) 0xBAADF00D) == frame) ||
5920 (MHD_WEBSOCKET_UTF8STEP_NORMAL != utf8_step) ||
5921 (0 != memcmp (frame, "\x81\x03" "abc", 5)))
5922 {
5923 fprintf (stderr,
5924 "Encode text test failed in line %u\n",
5925 (unsigned int) __LINE__);
5926 ++failed;
5927 }
5928 if (((char*) (uintptr_t) 0xBAADF00D) == frame)
5929 {
5930 frame = NULL;
5931 }
5932 if (NULL != frame)
5933 {
5934 MHD_websocket_free (wss, frame);
5935 frame = NULL;
5936 }
5937 /* Fail test: `utf8_step` passed for non-fragmentation with invalid UTF-8
5938 (is allowed and `utf8_step` will be filled then) */
5939 frame = (char*) (uintptr_t) 0xBAADF00D;
5940 frame_len = 0x87654321;
5941 utf8_step = -99;
5942 ret = MHD_websocket_encode_text (wss,
5943 "ab\xC3",
5944 3,
5945 MHD_WEBSOCKET_FRAGMENTATION_NONE,
5946 &frame,
5947 &frame_len,
5948 &utf8_step);
5949 if ((MHD_WEBSOCKET_STATUS_UTF8_ENCODING_ERROR != ret) ||
5950 (0 != frame_len) ||
5951 (NULL != frame) ||
5952 (MHD_WEBSOCKET_UTF8STEP_UTF2TAIL_1OF1 != utf8_step) )
5953 {
5954 fprintf (stderr,
5955 "Encode text test failed in line %u\n",
5956 (unsigned int) __LINE__);
5957 ++failed;
5958 }
5959 if (((char*) (uintptr_t) 0xBAADF00D) == frame)
5960 {
5961 frame = NULL;
5962 }
5963 if (NULL != frame)
5964 {
5965 MHD_websocket_free (wss, frame);
5966 frame = NULL;
5967 }
5968 /* Fail test: `utf8_step` not passed for fragmentation #1 */
5969 frame = (char*) (uintptr_t) 0xBAADF00D;
5970 frame_len = 0x87654321;
5971 ret = MHD_websocket_encode_text (wss,
5972 "abc",
5973 3,
5974 MHD_WEBSOCKET_FRAGMENTATION_FIRST,
5975 &frame,
5976 &frame_len,
5977 NULL);
5978 if ((MHD_WEBSOCKET_STATUS_PARAMETER_ERROR != ret) ||
5979 (0 != frame_len) ||
5980 (NULL != frame) )
5981 {
5982 fprintf (stderr,
5983 "Encode text test failed in line %u\n",
5984 (unsigned int) __LINE__);
5985 ++failed;
5986 }
5987 if (((char*) (uintptr_t) 0xBAADF00D) == frame)
5988 {
5989 frame = NULL;
5990 }
5991 if (NULL != frame)
5992 {
5993 MHD_websocket_free (wss, frame);
5994 frame = NULL;
5995 }
5996 /* Fail test: `utf8_step` not passed for fragmentation #2 */
5997 frame = (char*) (uintptr_t) 0xBAADF00D;
5998 frame_len = 0x87654321;
5999 ret = MHD_websocket_encode_text (wss,
6000 "abc",
6001 3,
6002 MHD_WEBSOCKET_FRAGMENTATION_FOLLOWING,
6003 &frame,
6004 &frame_len,
6005 NULL);
6006 if ((MHD_WEBSOCKET_STATUS_PARAMETER_ERROR != ret) ||
6007 (0 != frame_len) ||
6008 (NULL != frame) )
6009 {
6010 fprintf (stderr,
6011 "Encode text test failed in line %u\n",
6012 (unsigned int) __LINE__);
6013 ++failed;
6014 }
6015 if (((char*) (uintptr_t) 0xBAADF00D) == frame)
6016 {
6017 frame = NULL;
6018 }
6019 if (NULL != frame)
6020 {
6021 MHD_websocket_free (wss, frame);
6022 frame = NULL;
6023 }
6024 /* Fail test: `utf8_step` not passed for fragmentation #3 */
6025 frame = (char*) (uintptr_t) 0xBAADF00D;
6026 frame_len = 0x87654321;
6027 ret = MHD_websocket_encode_text (wss,
6028 "abc",
6029 3,
6030 MHD_WEBSOCKET_FRAGMENTATION_LAST,
6031 &frame,
6032 &frame_len,
6033 NULL);
6034 if ((MHD_WEBSOCKET_STATUS_PARAMETER_ERROR != ret) ||
6035 (0 != frame_len) ||
6036 (NULL != frame) )
6037 {
6038 fprintf (stderr,
6039 "Encode text test failed in line %u\n",
6040 (unsigned int) __LINE__);
6041 ++failed;
6042 }
6043 if (((char*) (uintptr_t) 0xBAADF00D) == frame)
6044 {
6045 frame = NULL;
6046 }
6047 if (NULL != frame)
6048 {
6049 MHD_websocket_free (wss, frame);
6050 frame = NULL;
6051 }
6052 /* Regular test: `utf8_step` passed for fragmentation #1 */
6053 frame = (char*) (uintptr_t) 0xBAADF00D;
6054 frame_len = 0x87654321;
6055 utf8_step = -99;
6056 ret = MHD_websocket_encode_text (wss,
6057 "abc",
6058 3,
6059 MHD_WEBSOCKET_FRAGMENTATION_FIRST,
6060 &frame,
6061 &frame_len,
6062 &utf8_step);
6063 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
6064 (5 != frame_len) ||
6065 (NULL == frame) ||
6066 (((char*) (uintptr_t) 0xBAADF00D) == frame) ||
6067 (MHD_WEBSOCKET_UTF8STEP_NORMAL != utf8_step) ||
6068 (0 != memcmp (frame, "\x01\x03" "abc", 5)))
6069 {
6070 fprintf (stderr,
6071 "Encode text test failed in line %u\n",
6072 (unsigned int) __LINE__);
6073 ++failed;
6074 }
6075 if (((char*) (uintptr_t) 0xBAADF00D) == frame)
6076 {
6077 frame = NULL;
6078 }
6079 if (NULL != frame)
6080 {
6081 MHD_websocket_free (wss, frame);
6082 frame = NULL;
6083 }
6084 /* Regular test: `utf8_step` passed for fragmentation #2 */
6085 frame = (char*) (uintptr_t) 0xBAADF00D;
6086 frame_len = 0x87654321;
6087 utf8_step = MHD_WEBSOCKET_UTF8STEP_NORMAL;
6088 ret = MHD_websocket_encode_text (wss,
6089 "abc",
6090 3,
6091 MHD_WEBSOCKET_FRAGMENTATION_FOLLOWING,
6092 &frame,
6093 &frame_len,
6094 &utf8_step);
6095 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
6096 (5 != frame_len) ||
6097 (NULL == frame) ||
6098 (((char*) (uintptr_t) 0xBAADF00D) == frame) ||
6099 (MHD_WEBSOCKET_UTF8STEP_NORMAL != utf8_step) ||
6100 (0 != memcmp (frame, "\x00\x03" "abc", 5)))
6101 {
6102 fprintf (stderr,
6103 "Encode text test failed in line %u\n",
6104 (unsigned int) __LINE__);
6105 ++failed;
6106 }
6107 if (((char*) (uintptr_t) 0xBAADF00D) == frame)
6108 {
6109 frame = NULL;
6110 }
6111 if (NULL != frame)
6112 {
6113 MHD_websocket_free (wss, frame);
6114 frame = NULL;
6115 }
6116 /* Regular test: `utf8_step` passed for fragmentation #3 */
6117 frame = (char*) (uintptr_t) 0xBAADF00D;
6118 frame_len = 0x87654321;
6119 utf8_step = MHD_WEBSOCKET_UTF8STEP_NORMAL;
6120 ret = MHD_websocket_encode_text (wss,
6121 "abc",
6122 3,
6123 MHD_WEBSOCKET_FRAGMENTATION_LAST,
6124 &frame,
6125 &frame_len,
6126 &utf8_step);
6127 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
6128 (5 != frame_len) ||
6129 (NULL == frame) ||
6130 (((char*) (uintptr_t) 0xBAADF00D) == frame) ||
6131 (MHD_WEBSOCKET_UTF8STEP_NORMAL != utf8_step) ||
6132 (0 != memcmp (frame, "\x80\x03" "abc", 5)))
6133 {
6134 fprintf (stderr,
6135 "Encode text test failed in line %u\n",
6136 (unsigned int) __LINE__);
6137 ++failed;
6138 }
6139 if (((char*) (uintptr_t) 0xBAADF00D) == frame)
6140 {
6141 frame = NULL;
6142 }
6143 if (NULL != frame)
6144 {
6145 MHD_websocket_free (wss, frame);
6146 frame = NULL;
6147 }
6148 /* Fail test: `fragmentation` has an invalid value */
6149 frame = (char*) (uintptr_t) 0xBAADF00D;
6150 frame_len = 0x87654321;
6151 utf8_step = -99;
6152 ret = MHD_websocket_encode_text (wss,
6153 "abc",
6154 3,
6155 MHD_WEBSOCKET_FRAGMENTATION_LAST + 1,
6156 &frame,
6157 &frame_len,
6158 &utf8_step);
6159 if ((MHD_WEBSOCKET_STATUS_PARAMETER_ERROR != ret) ||
6160 (0 != frame_len) ||
6161 (NULL != frame) ||
6162 (-99 != utf8_step) )
6163 {
6164 fprintf (stderr,
6165 "Encode text test failed in line %u\n",
6166 (unsigned int) __LINE__);
6167 ++failed;
6168 }
6169 if (((char*) (uintptr_t) 0xBAADF00D) == frame)
6170 {
6171 frame = NULL;
6172 }
6173 if (NULL != frame)
6174 {
6175 MHD_websocket_free (wss, frame);
6176 frame = NULL;
6177 }
6178
6179 /*
6180 ------------------------------------------------------------------------------
6181 validity after temporary out-of-memory
6182 ------------------------------------------------------------------------------
6183 */
6184 {
6185 struct MHD_WebSocketStream*wsx;
6186 if (MHD_WEBSOCKET_STATUS_OK == MHD_websocket_stream_init2 (&wsx,
6187 MHD_WEBSOCKET_FLAG_SERVER,
6188 0,
6189 test_malloc,
6190 test_realloc,
6191 test_free))
6192 {
6193 /* Fail test: allocation while no memory available */
6194 disable_alloc = 1;
6195 ret = MHD_websocket_encode_text (wsx,
6196 "abc",
6197 3,
6198 MHD_WEBSOCKET_FRAGMENTATION_NONE,
6199 &frame,
6200 &frame_len,
6201 NULL);
6202 if ((MHD_WEBSOCKET_STATUS_MEMORY_ERROR != ret) ||
6203 (0 != frame_len) ||
6204 (NULL != frame) )
6205 {
6206 fprintf (stderr,
6207 "Encode text test failed in line %u\n",
6208 (unsigned int) __LINE__);
6209 ++failed;
6210 }
6211 if (NULL != frame)
6212 {
6213 MHD_websocket_free (wsx, frame);
6214 frame = NULL;
6215 }
6216 /* Regular test: allocation while memory is available again */
6217 disable_alloc = 0;
6218 ret = MHD_websocket_encode_text (wsx,
6219 "abc",
6220 3,
6221 MHD_WEBSOCKET_FRAGMENTATION_NONE,
6222 &frame,
6223 &frame_len,
6224 NULL);
6225 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
6226 (5 != frame_len) ||
6227 (NULL == frame) ||
6228 (0 != memcmp (frame, "\x81\x03" "abc", 5)))
6229 {
6230 fprintf (stderr,
6231 "Encode text test failed in line %u\n",
6232 (unsigned int) __LINE__);
6233 ++failed;
6234 }
6235 if (NULL != frame)
6236 {
6237 MHD_websocket_free (wsx, frame);
6238 frame = NULL;
6239 }
6240
6241 MHD_websocket_stream_free (wsx);
6242 }
6243 else
6244 {
6245 fprintf (stderr,
6246 "Couldn't perform memory test for text encoding in line %u\n",
6247 (unsigned int) __LINE__);
6248 ++failed;
6249 }
6250 }
6251
6252 if (NULL != buf1)
6253 free (buf1);
6254 if (NULL != buf2)
6255 free (buf2);
6256 if (NULL != wsc)
6257 MHD_websocket_stream_free (wsc);
6258 if (NULL != wss)
6259 MHD_websocket_stream_free (wss);
6260
6261 return failed != 0 ? 0x08 : 0x00;
6262}
6263
6264
6265/**
6266 * Test procedure for `MHD_websocket_encode_binary()`
6267 */
6268int
6269test_encodes_binary ()
6270{
6271 int failed = 0;
6272 struct MHD_WebSocketStream*wss;
6273 struct MHD_WebSocketStream*wsc;
6274 int ret;
6275 char *buf1 = NULL, *buf2 = NULL;
6276 char*frame = NULL;
6277 size_t frame_len = 0;
6278
6279 if (MHD_WEBSOCKET_STATUS_OK != MHD_websocket_stream_init (&wsc,
6280 MHD_WEBSOCKET_FLAG_CLIENT,
6281 0))
6282 {
6283 fprintf (stderr,
6284 "No encode binary tests possible due to failed stream init in line %u\n",
6285 (unsigned int) __LINE__);
6286 return 0x10;
6287 }
6288 if (MHD_WEBSOCKET_STATUS_OK != MHD_websocket_stream_init (&wss,
6289 MHD_WEBSOCKET_FLAG_SERVER,
6290 0))
6291 {
6292 fprintf (stderr,
6293 "No encode binary tests possible due to failed stream init in line %u\n",
6294 (unsigned int) __LINE__);
6295 if (NULL != wsc)
6296 MHD_websocket_stream_free (wsc);
6297 return 0x10;
6298 }
6299
6300 /*
6301 ------------------------------------------------------------------------------
6302 Encoding
6303 ------------------------------------------------------------------------------
6304 */
6305 /* Regular test: Some data, we are server */
6306 ret = MHD_websocket_encode_binary (wss,
6307 "blablabla",
6308 9,
6309 MHD_WEBSOCKET_FRAGMENTATION_NONE,
6310 &frame,
6311 &frame_len);
6312 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
6313 (11 != frame_len) ||
6314 (NULL == frame) ||
6315 (0 != memcmp (frame, "\x82\x09" "blablabla", 11)))
6316 {
6317 fprintf (stderr,
6318 "Encode binary test failed in line %u\n",
6319 (unsigned int) __LINE__);
6320 ++failed;
6321 }
6322 if (NULL != frame)
6323 {
6324 MHD_websocket_free (wss, frame);
6325 frame = NULL;
6326 }
6327 /* Regular test: Some data, we are client */
6328 ret = MHD_websocket_encode_binary (wsc,
6329 "blablabla",
6330 9,
6331 MHD_WEBSOCKET_FRAGMENTATION_NONE,
6332 &frame,
6333 &frame_len);
6334 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
6335 (15 != frame_len) ||
6336 (NULL == frame) )
6337 {
6338 fprintf (stderr,
6339 "Encode binary test failed in line %u\n",
6340 (unsigned int) __LINE__);
6341 ++failed;
6342 }
6343 else
6344 {
6345 failed += test_decode_single (__LINE__,
6346 MHD_WEBSOCKET_FLAG_SERVER
6347 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
6348 0,
6349 1,
6350 0,
6351 frame,
6352 frame_len,
6353 "blablabla",
6354 9,
6355 MHD_WEBSOCKET_STATUS_BINARY_FRAME,
6356 MHD_WEBSOCKET_VALIDITY_VALID,
6357 frame_len);
6358 }
6359 if (NULL != frame)
6360 {
6361 MHD_websocket_free (wsc, frame);
6362 frame = NULL;
6363 }
6364 /* Edge test (success): Some data with NUL characters, we are server */
6365 ret = MHD_websocket_encode_binary (wss,
6366 "bla" "\0\0\0" "bla",
6367 9,
6368 MHD_WEBSOCKET_FRAGMENTATION_NONE,
6369 &frame,
6370 &frame_len);
6371 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
6372 (11 != frame_len) ||
6373 (NULL == frame) ||
6374 (0 != memcmp (frame, "\x82\x09" "bla" "\0\0\0" "bla", 11)))
6375 {
6376 fprintf (stderr,
6377 "Encode binary test failed in line %u\n",
6378 (unsigned int) __LINE__);
6379 ++failed;
6380 }
6381 if (NULL != frame)
6382 {
6383 MHD_websocket_free (wss, frame);
6384 frame = NULL;
6385 }
6386 /* Regular test: Some data which looks like broken UTF-8, we are server */
6387 ret = MHD_websocket_encode_binary (wss,
6388 "bla" "\xC3" "blabla",
6389 10,
6390 MHD_WEBSOCKET_FRAGMENTATION_NONE,
6391 &frame,
6392 &frame_len);
6393 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
6394 (12 != frame_len) ||
6395 (NULL == frame) ||
6396 (0 != memcmp (frame, "\x82\x0A" "bla" "\xC3" "blabla", 12)))
6397 {
6398 fprintf (stderr,
6399 "Encode binary test failed in line %u\n",
6400 (unsigned int) __LINE__);
6401 ++failed;
6402 }
6403 if (NULL != frame)
6404 {
6405 MHD_websocket_free (wss, frame);
6406 frame = NULL;
6407 }
6408
6409 /*
6410 ------------------------------------------------------------------------------
6411 Fragmentation
6412 ------------------------------------------------------------------------------
6413 */
6414 /* Regular test: Some data */
6415 ret = MHD_websocket_encode_binary (wss,
6416 "blablabla",
6417 9,
6418 MHD_WEBSOCKET_FRAGMENTATION_NONE,
6419 &frame,
6420 &frame_len);
6421 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
6422 (11 != frame_len) ||
6423 (NULL == frame) ||
6424 (0 != memcmp (frame, "\x82\x09" "blablabla", 11)))
6425 {
6426 fprintf (stderr,
6427 "Encode binary test failed in line %u\n",
6428 (unsigned int) __LINE__);
6429 ++failed;
6430 }
6431 if (NULL != frame)
6432 {
6433 MHD_websocket_free (wss, frame);
6434 frame = NULL;
6435 }
6436 /* Regular test: First fragment */
6437 ret = MHD_websocket_encode_binary (wss,
6438 "blablabla",
6439 9,
6440 MHD_WEBSOCKET_FRAGMENTATION_FIRST,
6441 &frame,
6442 &frame_len);
6443 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
6444 (11 != frame_len) ||
6445 (NULL == frame) ||
6446 (0 != memcmp (frame, "\x02\x09" "blablabla", 11)))
6447 {
6448 fprintf (stderr,
6449 "Encode binary test failed in line %u\n",
6450 (unsigned int) __LINE__);
6451 ++failed;
6452 }
6453 if (NULL != frame)
6454 {
6455 MHD_websocket_free (wss, frame);
6456 frame = NULL;
6457 }
6458 /* Regular test: Middle fragment */
6459 ret = MHD_websocket_encode_binary (wss,
6460 "blablabla",
6461 9,
6462 MHD_WEBSOCKET_FRAGMENTATION_FOLLOWING,
6463 &frame,
6464 &frame_len);
6465 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
6466 (11 != frame_len) ||
6467 (NULL == frame) ||
6468 (0 != memcmp (frame, "\x00\x09" "blablabla", 11)))
6469 {
6470 fprintf (stderr,
6471 "Encode binary test failed in line %u\n",
6472 (unsigned int) __LINE__);
6473 ++failed;
6474 }
6475 if (NULL != frame)
6476 {
6477 MHD_websocket_free (wss, frame);
6478 frame = NULL;
6479 }
6480 /* Regular test: Last fragment */
6481 ret = MHD_websocket_encode_binary (wss,
6482 "blablabla",
6483 9,
6484 MHD_WEBSOCKET_FRAGMENTATION_LAST,
6485 &frame,
6486 &frame_len);
6487 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
6488 (11 != frame_len) ||
6489 (NULL == frame) ||
6490 (0 != memcmp (frame, "\x80\x09" "blablabla", 11)))
6491 {
6492 fprintf (stderr,
6493 "Encode binary test failed in line %u\n",
6494 (unsigned int) __LINE__);
6495 ++failed;
6496 }
6497 if (NULL != frame)
6498 {
6499 MHD_websocket_free (wss, frame);
6500 frame = NULL;
6501 }
6502
6503 /*
6504 ------------------------------------------------------------------------------
6505 Length checks
6506 ------------------------------------------------------------------------------
6507 */
6508 /* Edge test (success): Binary frame without data */
6509 ret = MHD_websocket_encode_binary (wss,
6510 NULL,
6511 0,
6512 MHD_WEBSOCKET_FRAGMENTATION_NONE,
6513 &frame,
6514 &frame_len);
6515 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
6516 (2 != frame_len) ||
6517 (NULL == frame) ||
6518 (0 != memcmp (frame, "\x82\x00", 2)))
6519 {
6520 fprintf (stderr,
6521 "Encode binary test failed in line %u\n",
6522 (unsigned int) __LINE__);
6523 ++failed;
6524 }
6525 if (NULL != frame)
6526 {
6527 MHD_websocket_free (wss, frame);
6528 frame = NULL;
6529 }
6530 /* Edge test (success): Binary frame with 1 byte of data */
6531 ret = MHD_websocket_encode_binary (wss,
6532 "a",
6533 1,
6534 MHD_WEBSOCKET_FRAGMENTATION_NONE,
6535 &frame,
6536 &frame_len);
6537 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
6538 (3 != frame_len) ||
6539 (NULL == frame) ||
6540 (0 != memcmp (frame, "\x82\x01" "a", 3)))
6541 {
6542 fprintf (stderr,
6543 "Encode binary test failed in line %u\n",
6544 (unsigned int) __LINE__);
6545 ++failed;
6546 }
6547 if (NULL != frame)
6548 {
6549 MHD_websocket_free (wss, frame);
6550 frame = NULL;
6551 }
6552 /* Edge test (success): Binary frame with 125 bytes of data */
6553 ret = MHD_websocket_encode_binary (wss,
6554 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ012345678",
6555 125,
6556 MHD_WEBSOCKET_FRAGMENTATION_NONE,
6557 &frame,
6558 &frame_len);
6559 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
6560 (127 != frame_len) ||
6561 (NULL == frame) ||
6562 (0 != memcmp (frame, "\x82\x7D"
6563 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ012345678",
6564 127)))
6565 {
6566 fprintf (stderr,
6567 "Encode binary test failed in line %u\n",
6568 (unsigned int) __LINE__);
6569 ++failed;
6570 }
6571 if (NULL != frame)
6572 {
6573 MHD_websocket_free (wss, frame);
6574 frame = NULL;
6575 }
6576 /* Edge test (success): Binary frame with 126 bytes of data */
6577 ret = MHD_websocket_encode_binary (wss,
6578 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789",
6579 126,
6580 MHD_WEBSOCKET_FRAGMENTATION_NONE,
6581 &frame,
6582 &frame_len);
6583 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
6584 (130 != frame_len) ||
6585 (NULL == frame) ||
6586 (0 != memcmp (frame, "\x82\x7E\x00\x7E"
6587 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789",
6588 130)))
6589 {
6590 fprintf (stderr,
6591 "Encode binary test failed in line %u\n",
6592 (unsigned int) __LINE__);
6593 ++failed;
6594 }
6595 if (NULL != frame)
6596 {
6597 MHD_websocket_free (wss, frame);
6598 frame = NULL;
6599 }
6600 /* Edge test (success): Binary frame with 65535 bytes of data */
6601 allocate_length_test_data (&buf1,
6602 &buf2,
6603 65535,
6604 "\x82\x7E\xFF\xFF",
6605 4);
6606 ret = MHD_websocket_encode_binary (wss,
6607 buf2,
6608 65535,
6609 MHD_WEBSOCKET_FRAGMENTATION_NONE,
6610 &frame,
6611 &frame_len);
6612 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
6613 (65535 + 4 != frame_len) ||
6614 (NULL == frame) ||
6615 (0 != memcmp (frame, buf1, 65535 + 4)))
6616 {
6617 fprintf (stderr,
6618 "Encode binary test failed in line %u\n",
6619 (unsigned int) __LINE__);
6620 ++failed;
6621 }
6622 if (NULL != frame)
6623 {
6624 MHD_websocket_free (wss, frame);
6625 frame = NULL;
6626 }
6627 /* Edge test (success): Binary frame with 65536 bytes of data */
6628 allocate_length_test_data (&buf1,
6629 &buf2,
6630 65536,
6631 "\x82\x7F\x00\x00\x00\x00\x00\x01\x00\x00",
6632 10);
6633 ret = MHD_websocket_encode_binary (wss,
6634 buf2,
6635 65536,
6636 MHD_WEBSOCKET_FRAGMENTATION_NONE,
6637 &frame,
6638 &frame_len);
6639 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
6640 (65536 + 10 != frame_len) ||
6641 (NULL == frame) ||
6642 (0 != memcmp (frame, buf1, 65536 + 10)))
6643 {
6644 fprintf (stderr,
6645 "Encode binary test failed in line %u\n",
6646 (unsigned int) __LINE__);
6647 ++failed;
6648 }
6649 if (NULL != frame)
6650 {
6651 MHD_websocket_free (wss, frame);
6652 frame = NULL;
6653 }
6654 /* Regular test: Binary frame with 100 MB of data */
6655 allocate_length_test_data (&buf1,
6656 &buf2,
6657 104857600,
6658 "\x82\x7F\x00\x00\x00\x00\x06\x40\x00\x00",
6659 10);
6660 ret = MHD_websocket_encode_binary (wss,
6661 buf2,
6662 104857600,
6663 MHD_WEBSOCKET_FRAGMENTATION_NONE,
6664 &frame,
6665 &frame_len);
6666 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
6667 (104857600 + 10 != frame_len) ||
6668 (NULL == frame) ||
6669 (0 != memcmp (frame, buf1, 104857600 + 10)))
6670 {
6671 fprintf (stderr,
6672 "Encode binary test failed in line %u\n",
6673 (unsigned int) __LINE__);
6674 ++failed;
6675 }
6676 if (NULL != frame)
6677 {
6678 MHD_websocket_free (wss, frame);
6679 frame = NULL;
6680 }
6681 if (NULL != buf1)
6682 {
6683 free (buf1);
6684 buf1 = NULL;
6685 }
6686 if (NULL != buf2)
6687 {
6688 free (buf2);
6689 buf2 = NULL;
6690 }
6691 /* Fail test: `frame_len` is greater than 0x7FFFFFFFFFFFFFFF
6692 (this is the maximum allowed payload size) */
6693 frame_len = 0;
6694 ret = MHD_websocket_encode_binary (wss,
6695 "abc",
6696 (uint64_t) 0x8000000000000000,
6697 MHD_WEBSOCKET_FRAGMENTATION_NONE,
6698 &frame,
6699 &frame_len);
6700 if ((MHD_WEBSOCKET_STATUS_MAXIMUM_SIZE_EXCEEDED != ret) ||
6701 (0 != frame_len) ||
6702 (NULL != frame) )
6703 {
6704 fprintf (stderr,
6705 "Encode binary test failed in line %u\n",
6706 (unsigned int) __LINE__);
6707 ++failed;
6708 }
6709 if (NULL != frame)
6710 {
6711 MHD_websocket_free (wss, frame);
6712 frame = NULL;
6713 }
6714
6715 /*
6716 ------------------------------------------------------------------------------
6717 Wrong parameters
6718 ------------------------------------------------------------------------------
6719 */
6720 /* Fail test: `ws` not passed */
6721 frame = (char*) (uintptr_t) 0xBAADF00D;
6722 frame_len = 0x87654321;
6723 ret = MHD_websocket_encode_binary (NULL,
6724 "abc",
6725 3,
6726 MHD_WEBSOCKET_FRAGMENTATION_NONE,
6727 &frame,
6728 &frame_len);
6729 if ((MHD_WEBSOCKET_STATUS_PARAMETER_ERROR != ret) ||
6730 (0 != frame_len) ||
6731 (NULL != frame) )
6732 {
6733 fprintf (stderr,
6734 "Encode binary test failed in line %u\n",
6735 (unsigned int) __LINE__);
6736 ++failed;
6737 }
6738 if (((char*) (uintptr_t) 0xBAADF00D) == frame)
6739 {
6740 frame = NULL;
6741 }
6742 if (NULL != frame)
6743 {
6744 MHD_websocket_free (wss, frame);
6745 frame = NULL;
6746 }
6747 /* Fail test: `payload` not passed, but `payload_len` != 0 */
6748 frame = (char*) (uintptr_t) 0xBAADF00D;
6749 frame_len = 0x87654321;
6750 ret = MHD_websocket_encode_binary (wss,
6751 NULL,
6752 3,
6753 MHD_WEBSOCKET_FRAGMENTATION_NONE,
6754 &frame,
6755 &frame_len);
6756 if ((MHD_WEBSOCKET_STATUS_PARAMETER_ERROR != ret) ||
6757 (0 != frame_len) ||
6758 (NULL != frame) )
6759 {
6760 fprintf (stderr,
6761 "Encode binary test failed in line %u\n",
6762 (unsigned int) __LINE__);
6763 ++failed;
6764 }
6765 if (((char*) (uintptr_t) 0xBAADF00D) == frame)
6766 {
6767 frame = NULL;
6768 }
6769 if (NULL != frame)
6770 {
6771 MHD_websocket_free (wss, frame);
6772 frame = NULL;
6773 }
6774 /* Regular test: `payload` passed, but `payload_len` == 0 */
6775 frame = (char*) (uintptr_t) 0xBAADF00D;
6776 frame_len = 0x87654321;
6777 ret = MHD_websocket_encode_binary (wss,
6778 "abc",
6779 0,
6780 MHD_WEBSOCKET_FRAGMENTATION_NONE,
6781 &frame,
6782 &frame_len);
6783 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
6784 (2 != frame_len) ||
6785 (NULL == frame) ||
6786 (((char*) (uintptr_t) 0xBAADF00D) == frame) ||
6787 (0 != memcmp (frame, "\x82\x00", 2)))
6788 {
6789 fprintf (stderr,
6790 "Encode binary test failed in line %u\n",
6791 (unsigned int) __LINE__);
6792 ++failed;
6793 }
6794 if (((char*) (uintptr_t) 0xBAADF00D) == frame)
6795 {
6796 frame = NULL;
6797 }
6798 if (NULL != frame)
6799 {
6800 MHD_websocket_free (wss, frame);
6801 frame = NULL;
6802 }
6803 /* Fail test: `frame` not passed */
6804 frame_len = 0x87654321;
6805 ret = MHD_websocket_encode_binary (wss,
6806 "abc",
6807 3,
6808 MHD_WEBSOCKET_FRAGMENTATION_NONE,
6809 NULL,
6810 &frame_len);
6811 if ((MHD_WEBSOCKET_STATUS_PARAMETER_ERROR != ret) ||
6812 (0 != frame_len) ||
6813 (NULL != frame) )
6814 {
6815 fprintf (stderr,
6816 "Encode binary test failed in line %u\n",
6817 (unsigned int) __LINE__);
6818 ++failed;
6819 }
6820 /* Fail test: `frame_len` not passed */
6821 frame = (char*) (uintptr_t) 0xBAADF00D;
6822 ret = MHD_websocket_encode_binary (wss,
6823 "abc",
6824 3,
6825 MHD_WEBSOCKET_FRAGMENTATION_NONE,
6826 &frame,
6827 NULL);
6828 if ((MHD_WEBSOCKET_STATUS_PARAMETER_ERROR != ret) ||
6829 (NULL != frame) )
6830 {
6831 fprintf (stderr,
6832 "Encode binary test failed in line %u\n",
6833 (unsigned int) __LINE__);
6834 ++failed;
6835 }
6836 if (((char*) (uintptr_t) 0xBAADF00D) == frame)
6837 {
6838 frame = NULL;
6839 }
6840 if (NULL != frame)
6841 {
6842 MHD_websocket_free (wss, frame);
6843 frame = NULL;
6844 }
6845 /* Fail test: `fragmentation` has an invalid value */
6846 frame = (char*) (uintptr_t) 0xBAADF00D;
6847 frame_len = 0x87654321;
6848 ret = MHD_websocket_encode_binary (wss,
6849 "abc",
6850 3,
6851 MHD_WEBSOCKET_FRAGMENTATION_LAST + 1,
6852 &frame,
6853 &frame_len);
6854 if ((MHD_WEBSOCKET_STATUS_PARAMETER_ERROR != ret) ||
6855 (0 != frame_len) ||
6856 (NULL != frame) )
6857 {
6858 fprintf (stderr,
6859 "Encode binary test failed in line %u\n",
6860 (unsigned int) __LINE__);
6861 ++failed;
6862 }
6863 if (((char*) (uintptr_t) 0xBAADF00D) == frame)
6864 {
6865 frame = NULL;
6866 }
6867 if (NULL != frame)
6868 {
6869 MHD_websocket_free (wss, frame);
6870 frame = NULL;
6871 }
6872
6873 /*
6874 ------------------------------------------------------------------------------
6875 validity after temporary out-of-memory
6876 ------------------------------------------------------------------------------
6877 */
6878 {
6879 struct MHD_WebSocketStream*wsx;
6880 if (MHD_WEBSOCKET_STATUS_OK == MHD_websocket_stream_init2 (&wsx,
6881 MHD_WEBSOCKET_FLAG_SERVER,
6882 0,
6883 test_malloc,
6884 test_realloc,
6885 test_free))
6886 {
6887 /* Fail test: allocation while no memory available */
6888 disable_alloc = 1;
6889 ret = MHD_websocket_encode_binary (wsx,
6890 "abc",
6891 3,
6892 MHD_WEBSOCKET_FRAGMENTATION_NONE,
6893 &frame,
6894 &frame_len);
6895 if ((MHD_WEBSOCKET_STATUS_MEMORY_ERROR != ret) ||
6896 (0 != frame_len) ||
6897 (NULL != frame) )
6898 {
6899 fprintf (stderr,
6900 "Encode binary test failed in line %u\n",
6901 (unsigned int) __LINE__);
6902 ++failed;
6903 }
6904 if (NULL != frame)
6905 {
6906 MHD_websocket_free (wsx, frame);
6907 frame = NULL;
6908 }
6909 /* Regular test: allocation while memory is available again */
6910 disable_alloc = 0;
6911 ret = MHD_websocket_encode_binary (wsx,
6912 "abc",
6913 3,
6914 MHD_WEBSOCKET_FRAGMENTATION_NONE,
6915 &frame,
6916 &frame_len);
6917 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
6918 (5 != frame_len) ||
6919 (NULL == frame) ||
6920 (0 != memcmp (frame, "\x82\x03" "abc", 5)))
6921 {
6922 fprintf (stderr,
6923 "Encode binary test failed in line %u\n",
6924 (unsigned int) __LINE__);
6925 ++failed;
6926 }
6927 if (NULL != frame)
6928 {
6929 MHD_websocket_free (wsx, frame);
6930 frame = NULL;
6931 }
6932
6933 MHD_websocket_stream_free (wsx);
6934 }
6935 else
6936 {
6937 fprintf (stderr,
6938 "Couldn't perform memory test for binary encoding in line %u\n",
6939 (unsigned int) __LINE__);
6940 ++failed;
6941 }
6942 }
6943
6944 if (NULL != buf1)
6945 free (buf1);
6946 if (NULL != buf2)
6947 free (buf2);
6948 if (NULL != wsc)
6949 MHD_websocket_stream_free (wsc);
6950 if (NULL != wss)
6951 MHD_websocket_stream_free (wss);
6952
6953 return failed != 0 ? 0x10 : 0x00;
6954}
6955
6956
6957/**
6958 * Test procedure for `MHD_websocket_encode_close()`
6959 */
6960int
6961test_encodes_close ()
6962{
6963 int failed = 0;
6964 struct MHD_WebSocketStream*wss;
6965 struct MHD_WebSocketStream*wsc;
6966 int ret;
6967 char *buf1 = NULL, *buf2 = NULL;
6968 char*frame = NULL;
6969 size_t frame_len = 0;
6970
6971 if (MHD_WEBSOCKET_STATUS_OK != MHD_websocket_stream_init (&wsc,
6972 MHD_WEBSOCKET_FLAG_CLIENT,
6973 0))
6974 {
6975 fprintf (stderr,
6976 "No encode close tests possible due to failed stream init in line %u\n",
6977 (unsigned int) __LINE__);
6978 return 0x10;
6979 }
6980 if (MHD_WEBSOCKET_STATUS_OK != MHD_websocket_stream_init (&wss,
6981 MHD_WEBSOCKET_FLAG_SERVER,
6982 0))
6983 {
6984 fprintf (stderr,
6985 "No encode close tests possible due to failed stream init in line %u\n",
6986 (unsigned int) __LINE__);
6987 if (NULL != wsc)
6988 MHD_websocket_stream_free (wsc);
6989 return 0x10;
6990 }
6991
6992 /*
6993 ------------------------------------------------------------------------------
6994 Encoding
6995 ------------------------------------------------------------------------------
6996 */
6997 /* Regular test: Some data, we are server */
6998 ret = MHD_websocket_encode_close (wss,
6999 MHD_WEBSOCKET_CLOSEREASON_REGULAR,
7000 "blablabla",
7001 9,
7002 &frame,
7003 &frame_len);
7004 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
7005 (13 != frame_len) ||
7006 (NULL == frame) ||
7007 (0 != memcmp (frame, "\x88\x0B\x03\xE8" "blablabla", 13)))
7008 {
7009 fprintf (stderr,
7010 "Encode close test failed in line %u\n",
7011 (unsigned int) __LINE__);
7012 ++failed;
7013 }
7014 if (NULL != frame)
7015 {
7016 MHD_websocket_free (wss, frame);
7017 frame = NULL;
7018 }
7019 /* Regular test: Some data, we are client */
7020 ret = MHD_websocket_encode_close (wsc,
7021 MHD_WEBSOCKET_CLOSEREASON_REGULAR,
7022 "blablabla",
7023 9,
7024 &frame,
7025 &frame_len);
7026 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
7027 (17 != frame_len) ||
7028 (NULL == frame) )
7029 {
7030 fprintf (stderr,
7031 "Encode close test failed in line %u\n",
7032 (unsigned int) __LINE__);
7033 ++failed;
7034 }
7035 else
7036 {
7037 failed += test_decode_single (__LINE__,
7038 MHD_WEBSOCKET_FLAG_SERVER
7039 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
7040 0,
7041 1,
7042 0,
7043 frame,
7044 frame_len,
7045 "\x03\xE8" "blablabla",
7046 11,
7047 MHD_WEBSOCKET_STATUS_CLOSE_FRAME,
7048 MHD_WEBSOCKET_VALIDITY_ONLY_VALID_FOR_CONTROL_FRAMES,
7049 frame_len);
7050 }
7051 if (NULL != frame)
7052 {
7053 MHD_websocket_free (wsc, frame);
7054 frame = NULL;
7055 }
7056 /* Regular test: Close reason without text, we are server */
7057 ret = MHD_websocket_encode_close (wss,
7058 MHD_WEBSOCKET_CLOSEREASON_REGULAR,
7059 NULL,
7060 0,
7061 &frame,
7062 &frame_len);
7063 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
7064 (4 != frame_len) ||
7065 (NULL == frame) ||
7066 (0 != memcmp (frame, "\x88\x02\x03\xE8", 4)))
7067 {
7068 fprintf (stderr,
7069 "Encode close test failed in line %u\n",
7070 (unsigned int) __LINE__);
7071 ++failed;
7072 }
7073 if (NULL != frame)
7074 {
7075 MHD_websocket_free (wss, frame);
7076 frame = NULL;
7077 }
7078 /* Regular test: Close reason without text, we are client */
7079 ret = MHD_websocket_encode_close (wsc,
7080 MHD_WEBSOCKET_CLOSEREASON_REGULAR,
7081 NULL,
7082 0,
7083 &frame,
7084 &frame_len);
7085 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
7086 (8 != frame_len) ||
7087 (NULL == frame) )
7088 {
7089 fprintf (stderr,
7090 "Encode close test failed in line %u\n",
7091 (unsigned int) __LINE__);
7092 ++failed;
7093 }
7094 else
7095 {
7096 failed += test_decode_single (__LINE__,
7097 MHD_WEBSOCKET_FLAG_SERVER
7098 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
7099 0,
7100 1,
7101 0,
7102 frame,
7103 frame_len,
7104 "\x03\xE8",
7105 2,
7106 MHD_WEBSOCKET_STATUS_CLOSE_FRAME,
7107 MHD_WEBSOCKET_VALIDITY_ONLY_VALID_FOR_CONTROL_FRAMES,
7108 frame_len);
7109 }
7110 if (NULL != frame)
7111 {
7112 MHD_websocket_free (wsc, frame);
7113 frame = NULL;
7114 }
7115 /* Regular test: Close without reason, we are server */
7116 ret = MHD_websocket_encode_close (wss,
7117 MHD_WEBSOCKET_CLOSEREASON_NO_REASON,
7118 NULL,
7119 0,
7120 &frame,
7121 &frame_len);
7122 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
7123 (2 != frame_len) ||
7124 (NULL == frame) ||
7125 (0 != memcmp (frame, "\x88\x00", 2)))
7126 {
7127 fprintf (stderr,
7128 "Encode close test failed in line %u\n",
7129 (unsigned int) __LINE__);
7130 ++failed;
7131 }
7132 if (NULL != frame)
7133 {
7134 MHD_websocket_free (wss, frame);
7135 frame = NULL;
7136 }
7137 /* Regular test: Close without reason, we are client */
7138 ret = MHD_websocket_encode_close (wsc,
7139 MHD_WEBSOCKET_CLOSEREASON_NO_REASON,
7140 NULL,
7141 0,
7142 &frame,
7143 &frame_len);
7144 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
7145 (6 != frame_len) ||
7146 (NULL == frame) )
7147 {
7148 fprintf (stderr,
7149 "Encode close test failed in line %u\n",
7150 (unsigned int) __LINE__);
7151 ++failed;
7152 }
7153 else
7154 {
7155 failed += test_decode_single (__LINE__,
7156 MHD_WEBSOCKET_FLAG_SERVER
7157 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
7158 0,
7159 1,
7160 0,
7161 frame,
7162 frame_len,
7163 NULL,
7164 0,
7165 MHD_WEBSOCKET_STATUS_CLOSE_FRAME,
7166 MHD_WEBSOCKET_VALIDITY_ONLY_VALID_FOR_CONTROL_FRAMES,
7167 frame_len);
7168 }
7169 if (NULL != frame)
7170 {
7171 MHD_websocket_free (wsc, frame);
7172 frame = NULL;
7173 }
7174 /* Regular test: Close with UTF-8 sequence in reason, we are client */
7175 ret = MHD_websocket_encode_close (wsc,
7176 MHD_WEBSOCKET_CLOSEREASON_REGULAR,
7177 "bla" "\xC3\xA4" "blabla",
7178 11,
7179 &frame,
7180 &frame_len);
7181 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
7182 (19 != frame_len) ||
7183 (NULL == frame) )
7184 {
7185 fprintf (stderr,
7186 "Encode close test failed in line %u\n",
7187 (unsigned int) __LINE__);
7188 ++failed;
7189 }
7190 else
7191 {
7192 failed += test_decode_single (__LINE__,
7193 MHD_WEBSOCKET_FLAG_SERVER
7194 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
7195 0,
7196 1,
7197 0,
7198 frame,
7199 frame_len,
7200 "\x03\xE8" "bla" "\xC3\xA4" "blabla",
7201 13,
7202 MHD_WEBSOCKET_STATUS_CLOSE_FRAME,
7203 MHD_WEBSOCKET_VALIDITY_ONLY_VALID_FOR_CONTROL_FRAMES,
7204 frame_len);
7205 }
7206 if (NULL != frame)
7207 {
7208 MHD_websocket_free (wsc, frame);
7209 frame = NULL;
7210 }
7211 /* Edge test (success): Close reason with NUL characters, we are server */
7212 ret = MHD_websocket_encode_close (wss,
7213 MHD_WEBSOCKET_CLOSEREASON_GOING_AWAY,
7214 "bla" "\0\0\0" "bla",
7215 9,
7216 &frame,
7217 &frame_len);
7218 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
7219 (13 != frame_len) ||
7220 (NULL == frame) ||
7221 (0 != memcmp (frame, "\x88\x0B\x03\xE9" "bla" "\0\0\0" "bla", 13)))
7222 {
7223 fprintf (stderr,
7224 "Encode close test failed in line %u\n",
7225 (unsigned int) __LINE__);
7226 ++failed;
7227 }
7228 if (NULL != frame)
7229 {
7230 MHD_websocket_free (wss, frame);
7231 frame = NULL;
7232 }
7233 /* Fail test: Some data with broken UTF-8, we are server */
7234 ret = MHD_websocket_encode_close (wss,
7235 MHD_WEBSOCKET_CLOSEREASON_REGULAR,
7236 "bla" "\xC3" "blabla",
7237 10,
7238 &frame,
7239 &frame_len);
7240 if ((MHD_WEBSOCKET_STATUS_UTF8_ENCODING_ERROR != ret) ||
7241 (0 != frame_len) ||
7242 (NULL != frame) )
7243 {
7244 fprintf (stderr,
7245 "Encode close test failed in line %u\n",
7246 (unsigned int) __LINE__);
7247 ++failed;
7248 }
7249 if (NULL != frame)
7250 {
7251 MHD_websocket_free (wss, frame);
7252 frame = NULL;
7253 }
7254
7255 /*
7256 ------------------------------------------------------------------------------
7257 Length checks
7258 ------------------------------------------------------------------------------
7259 */
7260 /* Edge test (success): Close frame without payload */
7261 ret = MHD_websocket_encode_close (wss,
7262 MHD_WEBSOCKET_CLOSEREASON_NO_REASON,
7263 NULL,
7264 0,
7265 &frame,
7266 &frame_len);
7267 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
7268 (2 != frame_len) ||
7269 (NULL == frame) ||
7270 (0 != memcmp (frame, "\x88\x00", 2)))
7271 {
7272 fprintf (stderr,
7273 "Encode close test failed in line %u\n",
7274 (unsigned int) __LINE__);
7275 ++failed;
7276 }
7277 if (NULL != frame)
7278 {
7279 MHD_websocket_free (wss, frame);
7280 frame = NULL;
7281 }
7282 /* Edge test (success): Close frame only reason code */
7283 ret = MHD_websocket_encode_close (wss,
7284 MHD_WEBSOCKET_CLOSEREASON_REGULAR,
7285 NULL,
7286 0,
7287 &frame,
7288 &frame_len);
7289 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
7290 (4 != frame_len) ||
7291 (NULL == frame) ||
7292 (0 != memcmp (frame, "\x88\x02\x03\xE8", 4)))
7293 {
7294 fprintf (stderr,
7295 "Encode close test failed in line %u\n",
7296 (unsigned int) __LINE__);
7297 ++failed;
7298 }
7299 if (NULL != frame)
7300 {
7301 MHD_websocket_free (wss, frame);
7302 frame = NULL;
7303 }
7304 /* Edge test (success): Close frame with 1 bytes of reason text */
7305 ret = MHD_websocket_encode_close (wss,
7306 MHD_WEBSOCKET_CLOSEREASON_REGULAR,
7307 "a",
7308 1,
7309 &frame,
7310 &frame_len);
7311 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
7312 (5 != frame_len) ||
7313 (NULL == frame) ||
7314 (0 != memcmp (frame, "\x88\x03\x03\xE8" "a", 5)))
7315 {
7316 fprintf (stderr,
7317 "Encode close test failed in line %u\n",
7318 (unsigned int) __LINE__);
7319 ++failed;
7320 }
7321 if (NULL != frame)
7322 {
7323 MHD_websocket_free (wss, frame);
7324 frame = NULL;
7325 }
7326 /* Edge test (success): Close frame with 123 bytes of reason text */
7327 ret = MHD_websocket_encode_close (wss,
7328 MHD_WEBSOCKET_CLOSEREASON_REGULAR,
7329 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456",
7330 123,
7331 &frame,
7332 &frame_len);
7333 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
7334 (127 != frame_len) ||
7335 (NULL == frame) ||
7336 (0 != memcmp (frame, "\x88\x7D\x03\xE8"
7337 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456",
7338 127)))
7339 {
7340 fprintf (stderr,
7341 "Encode close test failed in line %u\n",
7342 (unsigned int) __LINE__);
7343 ++failed;
7344 }
7345 if (NULL != frame)
7346 {
7347 MHD_websocket_free (wss, frame);
7348 frame = NULL;
7349 }
7350 /* Edge test (fail): Close frame with 124 bytes of reason text*/
7351 ret = MHD_websocket_encode_close (wss,
7352 MHD_WEBSOCKET_CLOSEREASON_REGULAR,
7353 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ01234567",
7354 124,
7355 &frame,
7356 &frame_len);
7357 if ((MHD_WEBSOCKET_STATUS_MAXIMUM_SIZE_EXCEEDED != ret) ||
7358 (0 != frame_len) ||
7359 (NULL != frame) )
7360 {
7361 fprintf (stderr,
7362 "Encode close test failed in line %u\n",
7363 (unsigned int) __LINE__);
7364 ++failed;
7365 }
7366 if (NULL != frame)
7367 {
7368 MHD_websocket_free (wss, frame);
7369 frame = NULL;
7370 }
7371
7372 /*
7373 ------------------------------------------------------------------------------
7374 Wrong parameters
7375 ------------------------------------------------------------------------------
7376 */
7377 /* Fail test: `ws` not passed */
7378 frame = (char*) (uintptr_t) 0xBAADF00D;
7379 frame_len = 0x87654321;
7380 ret = MHD_websocket_encode_close (NULL,
7381 MHD_WEBSOCKET_CLOSEREASON_REGULAR,
7382 "abc",
7383 3,
7384 &frame,
7385 &frame_len);
7386 if ((MHD_WEBSOCKET_STATUS_PARAMETER_ERROR != ret) ||
7387 (0 != frame_len) ||
7388 (NULL != frame) )
7389 {
7390 fprintf (stderr,
7391 "Encode close test failed in line %u\n",
7392 (unsigned int) __LINE__);
7393 ++failed;
7394 }
7395 if (((char*) (uintptr_t) 0xBAADF00D) == frame)
7396 {
7397 frame = NULL;
7398 }
7399 if (NULL != frame)
7400 {
7401 MHD_websocket_free (wss, frame);
7402 frame = NULL;
7403 }
7404 /* Fail test: `payload` not passed, but `payload_len` != 0 */
7405 frame = (char*) (uintptr_t) 0xBAADF00D;
7406 frame_len = 0x87654321;
7407 ret = MHD_websocket_encode_close (wss,
7408 MHD_WEBSOCKET_CLOSEREASON_REGULAR,
7409 NULL,
7410 3,
7411 &frame,
7412 &frame_len);
7413 if ((MHD_WEBSOCKET_STATUS_PARAMETER_ERROR != ret) ||
7414 (0 != frame_len) ||
7415 (NULL != frame) )
7416 {
7417 fprintf (stderr,
7418 "Encode close test failed in line %u\n",
7419 (unsigned int) __LINE__);
7420 ++failed;
7421 }
7422 if (((char*) (uintptr_t) 0xBAADF00D) == frame)
7423 {
7424 frame = NULL;
7425 }
7426 if (NULL != frame)
7427 {
7428 MHD_websocket_free (wss, frame);
7429 frame = NULL;
7430 }
7431 /* Regular test: `payload` passed, but `payload_len` == 0 */
7432 frame = (char*) (uintptr_t) 0xBAADF00D;
7433 frame_len = 0x87654321;
7434 ret = MHD_websocket_encode_close (wss,
7435 MHD_WEBSOCKET_CLOSEREASON_REGULAR,
7436 "abc",
7437 0,
7438 &frame,
7439 &frame_len);
7440 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
7441 (4 != frame_len) ||
7442 (NULL == frame) ||
7443 (((char*) (uintptr_t) 0xBAADF00D) == frame) ||
7444 (0 != memcmp (frame, "\x88\x02\x03\xE8", 4)))
7445 {
7446 fprintf (stderr,
7447 "Encode close test failed in line %u\n",
7448 (unsigned int) __LINE__);
7449 ++failed;
7450 }
7451 if (((char*) (uintptr_t) 0xBAADF00D) == frame)
7452 {
7453 frame = NULL;
7454 }
7455 if (NULL != frame)
7456 {
7457 MHD_websocket_free (wss, frame);
7458 frame = NULL;
7459 }
7460 /* Fail test: `frame` not passed */
7461 frame_len = 0x87654321;
7462 ret = MHD_websocket_encode_close (wss,
7463 MHD_WEBSOCKET_CLOSEREASON_REGULAR,
7464 "abc",
7465 3,
7466 NULL,
7467 &frame_len);
7468 if ((MHD_WEBSOCKET_STATUS_PARAMETER_ERROR != ret) ||
7469 (0 != frame_len) ||
7470 (NULL != frame) )
7471 {
7472 fprintf (stderr,
7473 "Encode close test failed in line %u\n",
7474 (unsigned int) __LINE__);
7475 ++failed;
7476 }
7477 /* Fail test: `frame_len` not passed */
7478 frame = (char*) (uintptr_t) 0xBAADF00D;
7479 ret = MHD_websocket_encode_close (wss,
7480 MHD_WEBSOCKET_CLOSEREASON_REGULAR,
7481 "abc",
7482 3,
7483 &frame,
7484 NULL);
7485 if ((MHD_WEBSOCKET_STATUS_PARAMETER_ERROR != ret) ||
7486 (0 != frame_len) ||
7487 (NULL != frame) )
7488 {
7489 fprintf (stderr,
7490 "Encode close test failed in line %u\n",
7491 (unsigned int) __LINE__);
7492 ++failed;
7493 }
7494 if (((char*) (uintptr_t) 0xBAADF00D) == frame)
7495 {
7496 frame = NULL;
7497 }
7498 if (NULL != frame)
7499 {
7500 MHD_websocket_free (wss, frame);
7501 frame = NULL;
7502 }
7503 /* Fail test: no reason code passed, but reason text */
7504 frame = (char*) (uintptr_t) 0xBAADF00D;
7505 frame_len = 0x87654321;
7506 ret = MHD_websocket_encode_close (wss,
7507 MHD_WEBSOCKET_CLOSEREASON_NO_REASON,
7508 "abc",
7509 3,
7510 &frame,
7511 &frame_len);
7512 if ((MHD_WEBSOCKET_STATUS_PARAMETER_ERROR != ret) ||
7513 (0 != frame_len) ||
7514 (NULL != frame) )
7515 {
7516 fprintf (stderr,
7517 "Encode close test failed in line %u\n",
7518 (unsigned int) __LINE__);
7519 ++failed;
7520 }
7521 if (((char*) (uintptr_t) 0xBAADF00D) == frame)
7522 {
7523 frame = NULL;
7524 }
7525 if (NULL != frame)
7526 {
7527 MHD_websocket_free (wss, frame);
7528 frame = NULL;
7529 }
7530 /* Edge test (fail): Invalid reason code */
7531 frame = (char*) (uintptr_t) 0xBAADF00D;
7532 frame_len = 0x87654321;
7533 ret = MHD_websocket_encode_close (wss,
7534 1,
7535 "abc",
7536 3,
7537 &frame,
7538 &frame_len);
7539 if ((MHD_WEBSOCKET_STATUS_PARAMETER_ERROR != ret) ||
7540 (0 != frame_len) ||
7541 (NULL != frame) )
7542 {
7543 fprintf (stderr,
7544 "Encode close test failed in line %u\n",
7545 (unsigned int) __LINE__);
7546 ++failed;
7547 }
7548 if (((char*) (uintptr_t) 0xBAADF00D) == frame)
7549 {
7550 frame = NULL;
7551 }
7552 if (NULL != frame)
7553 {
7554 MHD_websocket_free (wss, frame);
7555 frame = NULL;
7556 }
7557 /* Edge test (fail): Invalid reason code */
7558 frame = (char*) (uintptr_t) 0xBAADF00D;
7559 frame_len = 0x87654321;
7560 ret = MHD_websocket_encode_close (wss,
7561 999,
7562 "abc",
7563 3,
7564 &frame,
7565 &frame_len);
7566 if ((MHD_WEBSOCKET_STATUS_PARAMETER_ERROR != ret) ||
7567 (0 != frame_len) ||
7568 (NULL != frame) )
7569 {
7570 fprintf (stderr,
7571 "Encode close test failed in line %u\n",
7572 (unsigned int) __LINE__);
7573 ++failed;
7574 }
7575 if (((char*) (uintptr_t) 0xBAADF00D) == frame)
7576 {
7577 frame = NULL;
7578 }
7579 if (NULL != frame)
7580 {
7581 MHD_websocket_free (wss, frame);
7582 frame = NULL;
7583 }
7584 /* Regular test: Custom reason code */
7585 frame = (char*) (uintptr_t) 0xBAADF00D;
7586 frame_len = 0x87654321;
7587 ret = MHD_websocket_encode_close (wss,
7588 2000,
7589 "abc",
7590 3,
7591 &frame,
7592 &frame_len);
7593 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
7594 (7 != frame_len) ||
7595 (NULL == frame) ||
7596 (((char*) (uintptr_t) 0xBAADF00D) == frame) ||
7597 (0 != memcmp (frame, "\x88\x05\x07\xD0" "abc", 7)))
7598 {
7599 fprintf (stderr,
7600 "Encode close test failed in line %u\n",
7601 (unsigned int) __LINE__);
7602 ++failed;
7603 }
7604 if (((char*) (uintptr_t) 0xBAADF00D) == frame)
7605 {
7606 frame = NULL;
7607 }
7608 if (NULL != frame)
7609 {
7610 MHD_websocket_free (wss, frame);
7611 frame = NULL;
7612 }
7613
7614 /*
7615 ------------------------------------------------------------------------------
7616 validity after temporary out-of-memory
7617 ------------------------------------------------------------------------------
7618 */
7619 {
7620 struct MHD_WebSocketStream*wsx;
7621 if (MHD_WEBSOCKET_STATUS_OK == MHD_websocket_stream_init2 (&wsx,
7622 MHD_WEBSOCKET_FLAG_SERVER,
7623 0,
7624 test_malloc,
7625 test_realloc,
7626 test_free))
7627 {
7628 /* Fail test: allocation while no memory available */
7629 disable_alloc = 1;
7630 ret = MHD_websocket_encode_close (wsx,
7631 MHD_WEBSOCKET_CLOSEREASON_REGULAR,
7632 "abc",
7633 3,
7634 &frame,
7635 &frame_len);
7636 if ((MHD_WEBSOCKET_STATUS_MEMORY_ERROR != ret) ||
7637 (0 != frame_len) ||
7638 (NULL != frame) )
7639 {
7640 fprintf (stderr,
7641 "Encode close test failed in line %u\n",
7642 (unsigned int) __LINE__);
7643 ++failed;
7644 }
7645 if (NULL != frame)
7646 {
7647 MHD_websocket_free (wsx, frame);
7648 frame = NULL;
7649 }
7650 /* Regular test: allocation while memory is available again */
7651 disable_alloc = 0;
7652 ret = MHD_websocket_encode_close (wsx,
7653 MHD_WEBSOCKET_CLOSEREASON_REGULAR,
7654 "abc",
7655 3,
7656 &frame,
7657 &frame_len);
7658 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
7659 (7 != frame_len) ||
7660 (NULL == frame) ||
7661 (0 != memcmp (frame, "\x88\x05\x03\xE8" "abc", 7)))
7662 {
7663 fprintf (stderr,
7664 "Encode close test failed in line %u\n",
7665 (unsigned int) __LINE__);
7666 ++failed;
7667 }
7668 if (NULL != frame)
7669 {
7670 MHD_websocket_free (wsx, frame);
7671 frame = NULL;
7672 }
7673
7674 MHD_websocket_stream_free (wsx);
7675 }
7676 else
7677 {
7678 fprintf (stderr,
7679 "Couldn't perform memory test for close encoding in line %u\n",
7680 (unsigned int) __LINE__);
7681 ++failed;
7682 }
7683 }
7684
7685 if (NULL != buf1)
7686 free (buf1);
7687 if (NULL != buf2)
7688 free (buf2);
7689 if (NULL != wsc)
7690 MHD_websocket_stream_free (wsc);
7691 if (NULL != wss)
7692 MHD_websocket_stream_free (wss);
7693
7694 return failed != 0 ? 0x20 : 0x00;
7695}
7696
7697
7698/**
7699 * Test procedure for `MHD_websocket_encode_ping()`
7700 */
7701int
7702test_encodes_ping ()
7703{
7704 int failed = 0;
7705 struct MHD_WebSocketStream*wss;
7706 struct MHD_WebSocketStream*wsc;
7707 int ret;
7708 char *buf1 = NULL, *buf2 = NULL;
7709 char*frame = NULL;
7710 size_t frame_len = 0;
7711
7712 if (MHD_WEBSOCKET_STATUS_OK != MHD_websocket_stream_init (&wsc,
7713 MHD_WEBSOCKET_FLAG_CLIENT,
7714 0))
7715 {
7716 fprintf (stderr,
7717 "No encode ping tests possible due to failed stream init in line %u\n",
7718 (unsigned int) __LINE__);
7719 return 0x10;
7720 }
7721 if (MHD_WEBSOCKET_STATUS_OK != MHD_websocket_stream_init (&wss,
7722 MHD_WEBSOCKET_FLAG_SERVER,
7723 0))
7724 {
7725 fprintf (stderr,
7726 "No encode ping tests possible due to failed stream init in line %u\n",
7727 (unsigned int) __LINE__);
7728 if (NULL != wsc)
7729 MHD_websocket_stream_free (wsc);
7730 return 0x10;
7731 }
7732
7733 /*
7734 ------------------------------------------------------------------------------
7735 Encoding
7736 ------------------------------------------------------------------------------
7737 */
7738 /* Regular test: Some data, we are server */
7739 ret = MHD_websocket_encode_ping (wss,
7740 "blablabla",
7741 9,
7742 &frame,
7743 &frame_len);
7744 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
7745 (11 != frame_len) ||
7746 (NULL == frame) ||
7747 (0 != memcmp (frame, "\x89\x09" "blablabla", 11)))
7748 {
7749 fprintf (stderr,
7750 "Encode ping test failed in line %u\n",
7751 (unsigned int) __LINE__);
7752 ++failed;
7753 }
7754 if (NULL != frame)
7755 {
7756 MHD_websocket_free (wss, frame);
7757 frame = NULL;
7758 }
7759 /* Regular test: Some data, we are client */
7760 ret = MHD_websocket_encode_ping (wsc,
7761 "blablabla",
7762 9,
7763 &frame,
7764 &frame_len);
7765 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
7766 (15 != frame_len) ||
7767 (NULL == frame) )
7768 {
7769 fprintf (stderr,
7770 "Encode ping test failed in line %u\n",
7771 (unsigned int) __LINE__);
7772 ++failed;
7773 }
7774 else
7775 {
7776 failed += test_decode_single (__LINE__,
7777 MHD_WEBSOCKET_FLAG_SERVER
7778 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
7779 0,
7780 1,
7781 0,
7782 frame,
7783 frame_len,
7784 "blablabla",
7785 9,
7786 MHD_WEBSOCKET_STATUS_PING_FRAME,
7787 MHD_WEBSOCKET_VALIDITY_VALID,
7788 frame_len);
7789 }
7790 if (NULL != frame)
7791 {
7792 MHD_websocket_free (wsc, frame);
7793 frame = NULL;
7794 }
7795 /* Regular test: Ping without payload, we are server */
7796 ret = MHD_websocket_encode_ping (wss,
7797 NULL,
7798 0,
7799 &frame,
7800 &frame_len);
7801 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
7802 (2 != frame_len) ||
7803 (NULL == frame) ||
7804 (0 != memcmp (frame, "\x89\x00", 2)))
7805 {
7806 fprintf (stderr,
7807 "Encode ping test failed in line %u\n",
7808 (unsigned int) __LINE__);
7809 ++failed;
7810 }
7811 if (NULL != frame)
7812 {
7813 MHD_websocket_free (wss, frame);
7814 frame = NULL;
7815 }
7816 /* Regular test: Ping without payload, we are client */
7817 ret = MHD_websocket_encode_ping (wsc,
7818 NULL,
7819 0,
7820 &frame,
7821 &frame_len);
7822 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
7823 (6 != frame_len) ||
7824 (NULL == frame) )
7825 {
7826 fprintf (stderr,
7827 "Encode ping test failed in line %u\n",
7828 (unsigned int) __LINE__);
7829 ++failed;
7830 }
7831 else
7832 {
7833 failed += test_decode_single (__LINE__,
7834 MHD_WEBSOCKET_FLAG_SERVER
7835 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
7836 0,
7837 1,
7838 0,
7839 frame,
7840 frame_len,
7841 NULL,
7842 0,
7843 MHD_WEBSOCKET_STATUS_PING_FRAME,
7844 MHD_WEBSOCKET_VALIDITY_VALID,
7845 frame_len);
7846 }
7847 if (NULL != frame)
7848 {
7849 MHD_websocket_free (wsc, frame);
7850 frame = NULL;
7851 }
7852 /* Regular test: Ping with something like UTF-8 sequence in payload, we are client */
7853 ret = MHD_websocket_encode_ping (wsc,
7854 "bla" "\xC3\xA4" "blabla",
7855 11,
7856 &frame,
7857 &frame_len);
7858 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
7859 (17 != frame_len) ||
7860 (NULL == frame) )
7861 {
7862 fprintf (stderr,
7863 "Encode ping test failed in line %u\n",
7864 (unsigned int) __LINE__);
7865 ++failed;
7866 }
7867 else
7868 {
7869 failed += test_decode_single (__LINE__,
7870 MHD_WEBSOCKET_FLAG_SERVER
7871 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
7872 0,
7873 1,
7874 0,
7875 frame,
7876 frame_len,
7877 "bla" "\xC3\xA4" "blabla",
7878 11,
7879 MHD_WEBSOCKET_STATUS_PING_FRAME,
7880 MHD_WEBSOCKET_VALIDITY_VALID,
7881 frame_len);
7882 }
7883 if (NULL != frame)
7884 {
7885 MHD_websocket_free (wsc, frame);
7886 frame = NULL;
7887 }
7888 /* Edge test (success): Ping payload with NUL characters, we are server */
7889 ret = MHD_websocket_encode_ping (wss,
7890 "bla" "\0\0\0" "bla",
7891 9,
7892 &frame,
7893 &frame_len);
7894 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
7895 (11 != frame_len) ||
7896 (NULL == frame) ||
7897 (0 != memcmp (frame, "\x89\x09" "bla" "\0\0\0" "bla", 11)))
7898 {
7899 fprintf (stderr,
7900 "Encode ping test failed in line %u\n",
7901 (unsigned int) __LINE__);
7902 ++failed;
7903 }
7904 if (NULL != frame)
7905 {
7906 MHD_websocket_free (wss, frame);
7907 frame = NULL;
7908 }
7909 /* Regular test: Ping payload with with something which looks like broken UTF-8, we are server */
7910 ret = MHD_websocket_encode_ping (wss,
7911 "bla" "\xC3" "blabla",
7912 10,
7913 &frame,
7914 &frame_len);
7915 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
7916 (12 != frame_len) ||
7917 (NULL == frame) ||
7918 (0 != memcmp (frame, "\x89\x0A" "bla" "\xC3" "blabla", 12)))
7919 {
7920 fprintf (stderr,
7921 "Encode ping test failed in line %u\n",
7922 (unsigned int) __LINE__);
7923 ++failed;
7924 }
7925 if (NULL != frame)
7926 {
7927 MHD_websocket_free (wss, frame);
7928 frame = NULL;
7929 }
7930
7931 /*
7932 ------------------------------------------------------------------------------
7933 Length checks
7934 ------------------------------------------------------------------------------
7935 */
7936 /* Edge test (success): Ping frame without payload */
7937 ret = MHD_websocket_encode_ping (wss,
7938 NULL,
7939 0,
7940 &frame,
7941 &frame_len);
7942 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
7943 (2 != frame_len) ||
7944 (NULL == frame) ||
7945 (0 != memcmp (frame, "\x89\x00", 2)))
7946 {
7947 fprintf (stderr,
7948 "Encode ping test failed in line %u\n",
7949 (unsigned int) __LINE__);
7950 ++failed;
7951 }
7952 if (NULL != frame)
7953 {
7954 MHD_websocket_free (wss, frame);
7955 frame = NULL;
7956 }
7957 /* Edge test (success): Ping frame with one byte of payload */
7958 ret = MHD_websocket_encode_ping (wss,
7959 NULL,
7960 0,
7961 &frame,
7962 &frame_len);
7963 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
7964 (2 != frame_len) ||
7965 (NULL == frame) ||
7966 (0 != memcmp (frame, "\x89\x00", 2)))
7967 {
7968 fprintf (stderr,
7969 "Encode ping test failed in line %u\n",
7970 (unsigned int) __LINE__);
7971 ++failed;
7972 }
7973 if (NULL != frame)
7974 {
7975 MHD_websocket_free (wss, frame);
7976 frame = NULL;
7977 }
7978 /* Edge test (success): Ping frame with 125 bytes of payload */
7979 ret = MHD_websocket_encode_ping (wss,
7980 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ012345678",
7981 125,
7982 &frame,
7983 &frame_len);
7984 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
7985 (127 != frame_len) ||
7986 (NULL == frame) ||
7987 (0 != memcmp (frame, "\x89\x7D"
7988 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ012345678",
7989 127)))
7990 {
7991 fprintf (stderr,
7992 "Encode ping test failed in line %u\n",
7993 (unsigned int) __LINE__);
7994 ++failed;
7995 }
7996 if (NULL != frame)
7997 {
7998 MHD_websocket_free (wss, frame);
7999 frame = NULL;
8000 }
8001 /* Edge test (fail): Ping frame with 126 bytes of payload */
8002 ret = MHD_websocket_encode_ping (wss,
8003 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789",
8004 126,
8005 &frame,
8006 &frame_len);
8007 if ((MHD_WEBSOCKET_STATUS_MAXIMUM_SIZE_EXCEEDED != ret) ||
8008 (0 != frame_len) ||
8009 (NULL != frame) )
8010 {
8011 fprintf (stderr,
8012 "Encode ping test failed in line %u\n",
8013 (unsigned int) __LINE__);
8014 ++failed;
8015 }
8016 if (NULL != frame)
8017 {
8018 MHD_websocket_free (wss, frame);
8019 frame = NULL;
8020 }
8021
8022 /*
8023 ------------------------------------------------------------------------------
8024 Wrong parameters
8025 ------------------------------------------------------------------------------
8026 */
8027 /* Fail test: `ws` not passed */
8028 frame = (char*) (uintptr_t) 0xBAADF00D;
8029 frame_len = 0x87654321;
8030 ret = MHD_websocket_encode_ping (NULL,
8031 "abc",
8032 3,
8033 &frame,
8034 &frame_len);
8035 if ((MHD_WEBSOCKET_STATUS_PARAMETER_ERROR != ret) ||
8036 (0 != frame_len) ||
8037 (NULL != frame) )
8038 {
8039 fprintf (stderr,
8040 "Encode ping test failed in line %u\n",
8041 (unsigned int) __LINE__);
8042 ++failed;
8043 }
8044 if (((char*) (uintptr_t) 0xBAADF00D) == frame)
8045 {
8046 frame = NULL;
8047 }
8048 if (NULL != frame)
8049 {
8050 MHD_websocket_free (wss, frame);
8051 frame = NULL;
8052 }
8053 /* Fail test: `payload` not passed, but `payload_len` != 0 */
8054 frame = (char*) (uintptr_t) 0xBAADF00D;
8055 frame_len = 0x87654321;
8056 ret = MHD_websocket_encode_ping (wss,
8057 NULL,
8058 3,
8059 &frame,
8060 &frame_len);
8061 if ((MHD_WEBSOCKET_STATUS_PARAMETER_ERROR != ret) ||
8062 (0 != frame_len) ||
8063 (NULL != frame) )
8064 {
8065 fprintf (stderr,
8066 "Encode ping test failed in line %u\n",
8067 (unsigned int) __LINE__);
8068 ++failed;
8069 }
8070 if (((char*) (uintptr_t) 0xBAADF00D) == frame)
8071 {
8072 frame = NULL;
8073 }
8074 if (NULL != frame)
8075 {
8076 MHD_websocket_free (wss, frame);
8077 frame = NULL;
8078 }
8079 /* Regular test: `payload` passed, but `payload_len` == 0 */
8080 frame = (char*) (uintptr_t) 0xBAADF00D;
8081 frame_len = 0x87654321;
8082 ret = MHD_websocket_encode_ping (wss,
8083 "abc",
8084 0,
8085 &frame,
8086 &frame_len);
8087 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
8088 (2 != frame_len) ||
8089 (NULL == frame) ||
8090 (((char*) (uintptr_t) 0xBAADF00D) == frame) ||
8091 (0 != memcmp (frame, "\x89\x00", 2)))
8092 {
8093 fprintf (stderr,
8094 "Encode ping test failed in line %u\n",
8095 (unsigned int) __LINE__);
8096 ++failed;
8097 }
8098 if (((char*) (uintptr_t) 0xBAADF00D) == frame)
8099 {
8100 frame = NULL;
8101 }
8102 if (NULL != frame)
8103 {
8104 MHD_websocket_free (wss, frame);
8105 frame = NULL;
8106 }
8107 /* Fail test: `frame` not passed */
8108 frame_len = 0x87654321;
8109 ret = MHD_websocket_encode_ping (wss,
8110 "abc",
8111 3,
8112 NULL,
8113 &frame_len);
8114 if ((MHD_WEBSOCKET_STATUS_PARAMETER_ERROR != ret) ||
8115 (0 != frame_len) )
8116 {
8117 fprintf (stderr,
8118 "Encode ping test failed in line %u\n",
8119 (unsigned int) __LINE__);
8120 ++failed;
8121 }
8122 /* Fail test: `frame_len` not passed */
8123 frame = (char*) (uintptr_t) 0xBAADF00D;
8124 ret = MHD_websocket_encode_ping (wss,
8125 "abc",
8126 3,
8127 &frame,
8128 NULL);
8129 if ((MHD_WEBSOCKET_STATUS_PARAMETER_ERROR != ret) ||
8130 (NULL != frame) )
8131 {
8132 fprintf (stderr,
8133 "Encode ping test failed in line %u\n",
8134 (unsigned int) __LINE__);
8135 ++failed;
8136 }
8137 if (((char*) (uintptr_t) 0xBAADF00D) == frame)
8138 {
8139 frame = NULL;
8140 }
8141 if (NULL != frame)
8142 {
8143 MHD_websocket_free (wss, frame);
8144 frame = NULL;
8145 }
8146
8147 /*
8148 ------------------------------------------------------------------------------
8149 validity after temporary out-of-memory
8150 ------------------------------------------------------------------------------
8151 */
8152 {
8153 struct MHD_WebSocketStream*wsx;
8154 if (MHD_WEBSOCKET_STATUS_OK == MHD_websocket_stream_init2 (&wsx,
8155 MHD_WEBSOCKET_FLAG_SERVER,
8156 0,
8157 test_malloc,
8158 test_realloc,
8159 test_free))
8160 {
8161 /* Fail test: allocation while no memory available */
8162 disable_alloc = 1;
8163 ret = MHD_websocket_encode_ping (wsx,
8164 "abc",
8165 3,
8166 &frame,
8167 &frame_len);
8168 if ((MHD_WEBSOCKET_STATUS_MEMORY_ERROR != ret) ||
8169 (0 != frame_len) ||
8170 (NULL != frame) )
8171 {
8172 fprintf (stderr,
8173 "Encode ping test failed in line %u\n",
8174 (unsigned int) __LINE__);
8175 ++failed;
8176 }
8177 if (NULL != frame)
8178 {
8179 MHD_websocket_free (wsx, frame);
8180 frame = NULL;
8181 }
8182 /* Regular test: allocation while memory is available again */
8183 disable_alloc = 0;
8184 ret = MHD_websocket_encode_ping (wsx,
8185 "abc",
8186 3,
8187 &frame,
8188 &frame_len);
8189 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
8190 (5 != frame_len) ||
8191 (NULL == frame) ||
8192 (0 != memcmp (frame, "\x89\x03" "abc", 5)))
8193 {
8194 fprintf (stderr,
8195 "Encode ping test failed in line %u\n",
8196 (unsigned int) __LINE__);
8197 ++failed;
8198 }
8199 if (NULL != frame)
8200 {
8201 MHD_websocket_free (wsx, frame);
8202 frame = NULL;
8203 }
8204
8205 MHD_websocket_stream_free (wsx);
8206 }
8207 else
8208 {
8209 fprintf (stderr,
8210 "Couldn't perform memory test for ping encoding in line %u\n",
8211 (unsigned int) __LINE__);
8212 ++failed;
8213 }
8214 }
8215
8216 if (NULL != buf1)
8217 free (buf1);
8218 if (NULL != buf2)
8219 free (buf2);
8220 if (NULL != wsc)
8221 MHD_websocket_stream_free (wsc);
8222 if (NULL != wss)
8223 MHD_websocket_stream_free (wss);
8224
8225 return failed != 0 ? 0x40 : 0x00;
8226}
8227
8228
8229/**
8230 * Test procedure for `MHD_websocket_encode_pong()`
8231 */
8232int
8233test_encodes_pong ()
8234{
8235 int failed = 0;
8236 struct MHD_WebSocketStream*wss;
8237 struct MHD_WebSocketStream*wsc;
8238 int ret;
8239 char *buf1 = NULL, *buf2 = NULL;
8240 char*frame = NULL;
8241 size_t frame_len = 0;
8242
8243 if (MHD_WEBSOCKET_STATUS_OK != MHD_websocket_stream_init (&wsc,
8244 MHD_WEBSOCKET_FLAG_CLIENT,
8245 0))
8246 {
8247 fprintf (stderr,
8248 "No encode pong tests possible due to failed stream init in line %u\n",
8249 (unsigned int) __LINE__);
8250 return 0x10;
8251 }
8252 if (MHD_WEBSOCKET_STATUS_OK != MHD_websocket_stream_init (&wss,
8253 MHD_WEBSOCKET_FLAG_SERVER,
8254 0))
8255 {
8256 fprintf (stderr,
8257 "No encode pong tests possible due to failed stream init in line %u\n",
8258 (unsigned int) __LINE__);
8259 if (NULL != wsc)
8260 MHD_websocket_stream_free (wsc);
8261 return 0x10;
8262 }
8263
8264 /*
8265 ------------------------------------------------------------------------------
8266 Encoding
8267 ------------------------------------------------------------------------------
8268 */
8269 /* Regular test: Some data, we are server */
8270 ret = MHD_websocket_encode_pong (wss,
8271 "blablabla",
8272 9,
8273 &frame,
8274 &frame_len);
8275 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
8276 (11 != frame_len) ||
8277 (NULL == frame) ||
8278 (0 != memcmp (frame, "\x8A\x09" "blablabla", 11)))
8279 {
8280 fprintf (stderr,
8281 "Encode pong test failed in line %u\n",
8282 (unsigned int) __LINE__);
8283 ++failed;
8284 }
8285 if (NULL != frame)
8286 {
8287 MHD_websocket_free (wss, frame);
8288 frame = NULL;
8289 }
8290 /* Regular test: Some data, we are client */
8291 ret = MHD_websocket_encode_pong (wsc,
8292 "blablabla",
8293 9,
8294 &frame,
8295 &frame_len);
8296 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
8297 (15 != frame_len) ||
8298 (NULL == frame) )
8299 {
8300 fprintf (stderr,
8301 "Encode pong test failed in line %u\n",
8302 (unsigned int) __LINE__);
8303 ++failed;
8304 }
8305 else
8306 {
8307 failed += test_decode_single (__LINE__,
8308 MHD_WEBSOCKET_FLAG_SERVER
8309 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
8310 0,
8311 1,
8312 0,
8313 frame,
8314 frame_len,
8315 "blablabla",
8316 9,
8317 MHD_WEBSOCKET_STATUS_PONG_FRAME,
8318 MHD_WEBSOCKET_VALIDITY_VALID,
8319 frame_len);
8320 }
8321 if (NULL != frame)
8322 {
8323 MHD_websocket_free (wsc, frame);
8324 frame = NULL;
8325 }
8326 /* Regular test: Pong without payload, we are server */
8327 ret = MHD_websocket_encode_pong (wss,
8328 NULL,
8329 0,
8330 &frame,
8331 &frame_len);
8332 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
8333 (2 != frame_len) ||
8334 (NULL == frame) ||
8335 (0 != memcmp (frame, "\x8A\x00", 2)))
8336 {
8337 fprintf (stderr,
8338 "Encode pong test failed in line %u\n",
8339 (unsigned int) __LINE__);
8340 ++failed;
8341 }
8342 if (NULL != frame)
8343 {
8344 MHD_websocket_free (wss, frame);
8345 frame = NULL;
8346 }
8347 /* Regular test: Pong without payload, we are client */
8348 ret = MHD_websocket_encode_pong (wsc,
8349 NULL,
8350 0,
8351 &frame,
8352 &frame_len);
8353 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
8354 (6 != frame_len) ||
8355 (NULL == frame) )
8356 {
8357 fprintf (stderr,
8358 "Encode pong test failed in line %u\n",
8359 (unsigned int) __LINE__);
8360 ++failed;
8361 }
8362 else
8363 {
8364 failed += test_decode_single (__LINE__,
8365 MHD_WEBSOCKET_FLAG_SERVER
8366 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
8367 0,
8368 1,
8369 0,
8370 frame,
8371 frame_len,
8372 NULL,
8373 0,
8374 MHD_WEBSOCKET_STATUS_PONG_FRAME,
8375 MHD_WEBSOCKET_VALIDITY_VALID,
8376 frame_len);
8377 }
8378 if (NULL != frame)
8379 {
8380 MHD_websocket_free (wsc, frame);
8381 frame = NULL;
8382 }
8383 /* Regular test: Pong with something like UTF-8 sequence in payload, we are client */
8384 ret = MHD_websocket_encode_pong (wsc,
8385 "bla" "\xC3\xA4" "blabla",
8386 11,
8387 &frame,
8388 &frame_len);
8389 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
8390 (17 != frame_len) ||
8391 (NULL == frame) )
8392 {
8393 fprintf (stderr,
8394 "Encode pong test failed in line %u\n",
8395 (unsigned int) __LINE__);
8396 ++failed;
8397 }
8398 else
8399 {
8400 failed += test_decode_single (__LINE__,
8401 MHD_WEBSOCKET_FLAG_SERVER
8402 | MHD_WEBSOCKET_FLAG_NO_FRAGMENTS,
8403 0,
8404 1,
8405 0,
8406 frame,
8407 frame_len,
8408 "bla" "\xC3\xA4" "blabla",
8409 11,
8410 MHD_WEBSOCKET_STATUS_PONG_FRAME,
8411 MHD_WEBSOCKET_VALIDITY_VALID,
8412 frame_len);
8413 }
8414 if (NULL != frame)
8415 {
8416 MHD_websocket_free (wsc, frame);
8417 frame = NULL;
8418 }
8419 /* Edge test (success): Pong payload with NUL characters, we are server */
8420 ret = MHD_websocket_encode_pong (wss,
8421 "bla" "\0\0\0" "bla",
8422 9,
8423 &frame,
8424 &frame_len);
8425 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
8426 (11 != frame_len) ||
8427 (NULL == frame) ||
8428 (0 != memcmp (frame, "\x8A\x09" "bla" "\0\0\0" "bla", 11)))
8429 {
8430 fprintf (stderr,
8431 "Encode pong test failed in line %u\n",
8432 (unsigned int) __LINE__);
8433 ++failed;
8434 }
8435 if (NULL != frame)
8436 {
8437 MHD_websocket_free (wss, frame);
8438 frame = NULL;
8439 }
8440 /* Regular test: Pong payload with with something which looks like broken UTF-8, we are server */
8441 ret = MHD_websocket_encode_pong (wss,
8442 "bla" "\xC3" "blabla",
8443 10,
8444 &frame,
8445 &frame_len);
8446 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
8447 (12 != frame_len) ||
8448 (NULL == frame) ||
8449 (0 != memcmp (frame, "\x8A\x0A" "bla" "\xC3" "blabla", 12)))
8450 {
8451 fprintf (stderr,
8452 "Encode pong test failed in line %u\n",
8453 (unsigned int) __LINE__);
8454 ++failed;
8455 }
8456 if (NULL != frame)
8457 {
8458 MHD_websocket_free (wss, frame);
8459 frame = NULL;
8460 }
8461
8462 /*
8463 ------------------------------------------------------------------------------
8464 Length checks
8465 ------------------------------------------------------------------------------
8466 */
8467 /* Edge test (success): Pong frame without payload */
8468 ret = MHD_websocket_encode_pong (wss,
8469 NULL,
8470 0,
8471 &frame,
8472 &frame_len);
8473 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
8474 (2 != frame_len) ||
8475 (NULL == frame) ||
8476 (0 != memcmp (frame, "\x8A\x00", 2)))
8477 {
8478 fprintf (stderr,
8479 "Encode pong test failed in line %u\n",
8480 (unsigned int) __LINE__);
8481 ++failed;
8482 }
8483 if (NULL != frame)
8484 {
8485 MHD_websocket_free (wss, frame);
8486 frame = NULL;
8487 }
8488 /* Edge test (success): Pong frame with one byte of payload */
8489 ret = MHD_websocket_encode_pong (wss,
8490 NULL,
8491 0,
8492 &frame,
8493 &frame_len);
8494 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
8495 (2 != frame_len) ||
8496 (NULL == frame) ||
8497 (0 != memcmp (frame, "\x8A\x00", 2)))
8498 {
8499 fprintf (stderr,
8500 "Encode pong test failed in line %u\n",
8501 (unsigned int) __LINE__);
8502 ++failed;
8503 }
8504 if (NULL != frame)
8505 {
8506 MHD_websocket_free (wss, frame);
8507 frame = NULL;
8508 }
8509 /* Edge test (success): Pong frame with 125 bytes of payload */
8510 ret = MHD_websocket_encode_pong (wss,
8511 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ012345678",
8512 125,
8513 &frame,
8514 &frame_len);
8515 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
8516 (127 != frame_len) ||
8517 (NULL == frame) ||
8518 (0 != memcmp (frame, "\x8A\x7D"
8519 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ012345678",
8520 127)))
8521 {
8522 fprintf (stderr,
8523 "Encode pong test failed in line %u\n",
8524 (unsigned int) __LINE__);
8525 ++failed;
8526 }
8527 if (NULL != frame)
8528 {
8529 MHD_websocket_free (wss, frame);
8530 frame = NULL;
8531 }
8532 /* Edge test (fail): Pong frame with 126 bytes of payload */
8533 ret = MHD_websocket_encode_pong (wss,
8534 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789",
8535 126,
8536 &frame,
8537 &frame_len);
8538 if ((MHD_WEBSOCKET_STATUS_MAXIMUM_SIZE_EXCEEDED != ret) ||
8539 (0 != frame_len) ||
8540 (NULL != frame) )
8541 {
8542 fprintf (stderr,
8543 "Encode pong test failed in line %u\n",
8544 (unsigned int) __LINE__);
8545 ++failed;
8546 }
8547 if (NULL != frame)
8548 {
8549 MHD_websocket_free (wss, frame);
8550 frame = NULL;
8551 }
8552
8553 /*
8554 ------------------------------------------------------------------------------
8555 Wrong parameters
8556 ------------------------------------------------------------------------------
8557 */
8558 /* Fail test: `ws` not passed */
8559 frame = (char*) (uintptr_t) 0xBAADF00D;
8560 frame_len = 0x87654321;
8561 ret = MHD_websocket_encode_pong (NULL,
8562 "abc",
8563 3,
8564 &frame,
8565 &frame_len);
8566 if ((MHD_WEBSOCKET_STATUS_PARAMETER_ERROR != ret) ||
8567 (0 != frame_len) ||
8568 (NULL != frame) )
8569 {
8570 fprintf (stderr,
8571 "Encode pong test failed in line %u\n",
8572 (unsigned int) __LINE__);
8573 ++failed;
8574 }
8575 if (((char*) (uintptr_t) 0xBAADF00D) == frame)
8576 {
8577 frame = NULL;
8578 }
8579 if (NULL != frame)
8580 {
8581 MHD_websocket_free (wss, frame);
8582 frame = NULL;
8583 }
8584 /* Fail test: `payload` not passed, but `payload_len` != 0 */
8585 frame = (char*) (uintptr_t) 0xBAADF00D;
8586 frame_len = 0x87654321;
8587 ret = MHD_websocket_encode_pong (wss,
8588 NULL,
8589 3,
8590 &frame,
8591 &frame_len);
8592 if ((MHD_WEBSOCKET_STATUS_PARAMETER_ERROR != ret) ||
8593 (0 != frame_len) ||
8594 (NULL != frame) )
8595 {
8596 fprintf (stderr,
8597 "Encode pong test failed in line %u\n",
8598 (unsigned int) __LINE__);
8599 ++failed;
8600 }
8601 if (((char*) (uintptr_t) 0xBAADF00D) == frame)
8602 {
8603 frame = NULL;
8604 }
8605 if (NULL != frame)
8606 {
8607 MHD_websocket_free (wss, frame);
8608 frame = NULL;
8609 }
8610 /* Regular test: `payload` passed, but `payload_len` == 0 */
8611 frame = (char*) (uintptr_t) 0xBAADF00D;
8612 frame_len = 0x87654321;
8613 ret = MHD_websocket_encode_pong (wss,
8614 "abc",
8615 0,
8616 &frame,
8617 &frame_len);
8618 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
8619 (2 != frame_len) ||
8620 (NULL == frame) ||
8621 (((char*) (uintptr_t) 0xBAADF00D) == frame) ||
8622 (0 != memcmp (frame, "\x8A\x00", 2)))
8623 {
8624 fprintf (stderr,
8625 "Encode pong test failed in line %u\n",
8626 (unsigned int) __LINE__);
8627 ++failed;
8628 }
8629 if (((char*) (uintptr_t) 0xBAADF00D) == frame)
8630 {
8631 frame = NULL;
8632 }
8633 if (NULL != frame)
8634 {
8635 MHD_websocket_free (wss, frame);
8636 frame = NULL;
8637 }
8638 /* Fail test: `frame` not passed */
8639 frame_len = 0x87654321;
8640 ret = MHD_websocket_encode_pong (wss,
8641 "abc",
8642 3,
8643 NULL,
8644 &frame_len);
8645 if ((MHD_WEBSOCKET_STATUS_PARAMETER_ERROR != ret) ||
8646 (0 != frame_len) )
8647 {
8648 fprintf (stderr,
8649 "Encode pong test failed in line %u\n",
8650 (unsigned int) __LINE__);
8651 ++failed;
8652 }
8653 /* Fail test: `frame_len` not passed */
8654 frame = (char*) (uintptr_t) 0xBAADF00D;
8655 ret = MHD_websocket_encode_pong (wss,
8656 "abc",
8657 3,
8658 &frame,
8659 NULL);
8660 if ((MHD_WEBSOCKET_STATUS_PARAMETER_ERROR != ret) ||
8661 (NULL != frame) )
8662 {
8663 fprintf (stderr,
8664 "Encode pong test failed in line %u\n",
8665 (unsigned int) __LINE__);
8666 ++failed;
8667 }
8668 if (((char*) (uintptr_t) 0xBAADF00D) == frame)
8669 {
8670 frame = NULL;
8671 }
8672 if (NULL != frame)
8673 {
8674 MHD_websocket_free (wss, frame);
8675 frame = NULL;
8676 }
8677
8678 /*
8679 ------------------------------------------------------------------------------
8680 validity after temporary out-of-memory
8681 ------------------------------------------------------------------------------
8682 */
8683 {
8684 struct MHD_WebSocketStream*wsx;
8685 if (MHD_WEBSOCKET_STATUS_OK == MHD_websocket_stream_init2 (&wsx,
8686 MHD_WEBSOCKET_FLAG_SERVER,
8687 0,
8688 test_malloc,
8689 test_realloc,
8690 test_free))
8691 {
8692 /* Fail test: allocation while no memory available */
8693 disable_alloc = 1;
8694 ret = MHD_websocket_encode_pong (wsx,
8695 "abc",
8696 3,
8697 &frame,
8698 &frame_len);
8699 if ((MHD_WEBSOCKET_STATUS_MEMORY_ERROR != ret) ||
8700 (0 != frame_len) ||
8701 (NULL != frame) )
8702 {
8703 fprintf (stderr,
8704 "Encode pong test failed in line %u\n",
8705 (unsigned int) __LINE__);
8706 ++failed;
8707 }
8708 if (NULL != frame)
8709 {
8710 MHD_websocket_free (wsx, frame);
8711 frame = NULL;
8712 }
8713 /* Regular test: allocation while memory is available again */
8714 disable_alloc = 0;
8715 ret = MHD_websocket_encode_pong (wsx,
8716 "abc",
8717 3,
8718 &frame,
8719 &frame_len);
8720 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
8721 (5 != frame_len) ||
8722 (NULL == frame) ||
8723 (0 != memcmp (frame, "\x8A\x03" "abc", 5)))
8724 {
8725 fprintf (stderr,
8726 "Encode pong test failed in line %u\n",
8727 (unsigned int) __LINE__);
8728 ++failed;
8729 }
8730 if (NULL != frame)
8731 {
8732 MHD_websocket_free (wsx, frame);
8733 frame = NULL;
8734 }
8735
8736 MHD_websocket_stream_free (wsx);
8737 }
8738 else
8739 {
8740 fprintf (stderr,
8741 "Couldn't perform memory test for pong encoding in line %u\n",
8742 (unsigned int) __LINE__);
8743 ++failed;
8744 }
8745 }
8746
8747 if (NULL != buf1)
8748 free (buf1);
8749 if (NULL != buf2)
8750 free (buf2);
8751 if (NULL != wsc)
8752 MHD_websocket_stream_free (wsc);
8753 if (NULL != wss)
8754 MHD_websocket_stream_free (wss);
8755
8756 return failed != 0 ? 0x80 : 0x00;
8757}
8758
8759
8760/**
8761 * Test procedure for `MHD_websocket_split_close_reason()`
8762 */
8763int
8764test_split_close_reason ()
8765{
8766 int failed = 0;
8767 const char*payload;
8768 unsigned short reason_code;
8769 const char*reason_utf8;
8770 size_t reason_utf8_len;
8771 int ret;
8772
8773 /*
8774 ------------------------------------------------------------------------------
8775 Normal splits
8776 ------------------------------------------------------------------------------
8777 */
8778 /* Regular test: Reason code + Reason text */
8779 reason_code = 9999;
8780 reason_utf8 = (const char*) (intptr_t) 0xBAADF00D;
8781 reason_utf8_len = 12345;
8782 payload = "\x03\xE8" "abc";
8783 ret = MHD_websocket_split_close_reason (payload,
8784 5,
8785 &reason_code,
8786 &reason_utf8,
8787 &reason_utf8_len);
8788 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
8789 (MHD_WEBSOCKET_CLOSEREASON_REGULAR != reason_code) ||
8790 (3 != reason_utf8_len) ||
8791 (payload + 2 != reason_utf8) )
8792 {
8793 fprintf (stderr,
8794 "split close reason test failed in line %u\n",
8795 (unsigned int) __LINE__);
8796 ++failed;
8797 }
8798 /* Regular test: Reason code */
8799 reason_code = 9999;
8800 reason_utf8 = (const char*) (intptr_t) 0xBAADF00D;
8801 reason_utf8_len = 12345;
8802 payload = "\x03\xE8";
8803 ret = MHD_websocket_split_close_reason (payload,
8804 2,
8805 &reason_code,
8806 &reason_utf8,
8807 &reason_utf8_len);
8808 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
8809 (MHD_WEBSOCKET_CLOSEREASON_REGULAR != reason_code) ||
8810 (0 != reason_utf8_len) ||
8811 (NULL != reason_utf8) )
8812 {
8813 fprintf (stderr,
8814 "split close reason test failed in line %u\n",
8815 (unsigned int) __LINE__);
8816 ++failed;
8817 }
8818 /* Regular test: No payload */
8819 reason_code = 9999;
8820 reason_utf8 = (const char*) (intptr_t) 0xBAADF00D;
8821 reason_utf8_len = 12345;
8822 payload = NULL;
8823 ret = MHD_websocket_split_close_reason (payload,
8824 0,
8825 &reason_code,
8826 &reason_utf8,
8827 &reason_utf8_len);
8828 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
8829 (MHD_WEBSOCKET_CLOSEREASON_NO_REASON != reason_code) ||
8830 (0 != reason_utf8_len) ||
8831 (NULL != reason_utf8) )
8832 {
8833 fprintf (stderr,
8834 "split close reason test failed in line %u\n",
8835 (unsigned int) __LINE__);
8836 ++failed;
8837 }
8838 /* Regular test: `payload` is not NULL given, but `payload_len` == 0 */
8839 reason_code = 9999;
8840 reason_utf8 = (const char*) (intptr_t) 0xBAADF00D;
8841 reason_utf8_len = 12345;
8842 payload = "abc";
8843 ret = MHD_websocket_split_close_reason (payload,
8844 0,
8845 &reason_code,
8846 &reason_utf8,
8847 &reason_utf8_len);
8848 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
8849 (MHD_WEBSOCKET_CLOSEREASON_NO_REASON != reason_code) ||
8850 (0 != reason_utf8_len) ||
8851 (NULL != reason_utf8) )
8852 {
8853 fprintf (stderr,
8854 "split close reason test failed in line %u\n",
8855 (unsigned int) __LINE__);
8856 ++failed;
8857 }
8858
8859 /*
8860 ------------------------------------------------------------------------------
8861 Wrong parameters
8862 ------------------------------------------------------------------------------
8863 */
8864 /* Fail test: `payload` not passed, but `payload_len` != 0 */
8865 reason_code = 9999;
8866 reason_utf8 = (const char*) (intptr_t) 0xBAADF00D;
8867 reason_utf8_len = 12345;
8868 payload = NULL;
8869 ret = MHD_websocket_split_close_reason (payload,
8870 3,
8871 &reason_code,
8872 &reason_utf8,
8873 &reason_utf8_len);
8874 if ((MHD_WEBSOCKET_STATUS_PARAMETER_ERROR != ret) ||
8875 (MHD_WEBSOCKET_CLOSEREASON_NO_REASON != reason_code) ||
8876 (0 != reason_utf8_len) ||
8877 (NULL != reason_utf8) )
8878 {
8879 fprintf (stderr,
8880 "split close reason test failed in line %u\n",
8881 (unsigned int) __LINE__);
8882 ++failed;
8883 }
8884 /* Regular test: `reason_code` not passed */
8885 reason_utf8 = (const char*) (intptr_t) 0xBAADF00D;
8886 reason_utf8_len = 12345;
8887 payload = "\x03\xE8" "abc";
8888 ret = MHD_websocket_split_close_reason (payload,
8889 5,
8890 NULL,
8891 &reason_utf8,
8892 &reason_utf8_len);
8893 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
8894 (3 != reason_utf8_len) ||
8895 (payload + 2 != reason_utf8) )
8896 {
8897 fprintf (stderr,
8898 "split close reason test failed in line %u\n",
8899 (unsigned int) __LINE__);
8900 ++failed;
8901 }
8902 /* Regular test: `reason_utf8` not passed */
8903 reason_code = 9999;
8904 reason_utf8_len = 12345;
8905 payload = "\x03\xE8" "abc";
8906 ret = MHD_websocket_split_close_reason (payload,
8907 5,
8908 &reason_code,
8909 NULL,
8910 &reason_utf8_len);
8911 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
8912 (MHD_WEBSOCKET_CLOSEREASON_REGULAR != reason_code) ||
8913 (3 != reason_utf8_len) )
8914 {
8915 fprintf (stderr,
8916 "split close reason test failed in line %u\n",
8917 (unsigned int) __LINE__);
8918 ++failed;
8919 }
8920 /* Regular test: `reason_utf8_len` not passed */
8921 reason_code = 9999;
8922 reason_utf8 = (const char*) (intptr_t) 0xBAADF00D;
8923 payload = "\x03\xE8" "abc";
8924 ret = MHD_websocket_split_close_reason (payload,
8925 5,
8926 &reason_code,
8927 &reason_utf8,
8928 NULL);
8929 if ((MHD_WEBSOCKET_STATUS_OK != ret) ||
8930 (MHD_WEBSOCKET_CLOSEREASON_REGULAR != reason_code) ||
8931 (payload + 2 != reason_utf8) )
8932 {
8933 fprintf (stderr,
8934 "split close reason test failed in line %u\n",
8935 (unsigned int) __LINE__);
8936 ++failed;
8937 }
8938 /* Regular test: `reason_code`, `reason_utf8` and `reason_utf8_len` not passed */
8939 /* (this is not prohibited, although it doesn't really make sense) */
8940 payload = "\x03\xE8" "abc";
8941 ret = MHD_websocket_split_close_reason (payload,
8942 5,
8943 NULL,
8944 NULL,
8945 NULL);
8946 if (MHD_WEBSOCKET_STATUS_OK != ret)
8947 {
8948 fprintf (stderr,
8949 "split close reason test failed in line %u\n",
8950 (unsigned int) __LINE__);
8951 ++failed;
8952 }
8953
8954 return failed != 0 ? 0x100 : 0x00;
8955}
8956
8957
8958int
8959main (int argc, char *const *argv)
8960{
8961 unsigned int errorCount = 0;
8962 (void) argc; (void) argv; /* Unused. Silent compiler warning. */
8963
8964 /* seed random number generator */
8965 MHD_websocket_srand ((unsigned long) time (NULL));
8966
8967 /* perform tests */
8968 errorCount += test_inits ();
8969 errorCount += test_accept ();
8970 errorCount += test_decodes ();
8971 errorCount += test_encodes_text ();
8972 errorCount += test_encodes_binary ();
8973 errorCount += test_encodes_close ();
8974 errorCount += test_encodes_ping ();
8975 errorCount += test_encodes_pong ();
8976 errorCount += test_split_close_reason ();
8977
8978 /* output result */
8979 if (errorCount != 0)
8980 fprintf (stderr, "Error (code: %u)\n", errorCount);
8981
8982 return errorCount != 0; /* 0 == pass */
8983}
generated by cgit v1.2.3 (git 2.39.1) at 2024-05-16 00:05:59 +0000