src/utils/utils_module_tests.c

   1 /*
   2  * utils module tests
   3  * Copyright (c) 2014-2015, Jouni Malinen <j@w1.fi>
   4  *
   5  * This software may be distributed under the terms of the BSD license.
   6  * See README for more details.
   7  */
   8
   9 #include "utils/includes.h"
  10
  11 #include "utils/common.h"
  12 #include "common/ieee802_11_defs.h"
  13 #include "utils/bitfield.h"
  14 #include "utils/ext_password.h"
  15 #include "utils/trace.h"
  16 #include "utils/base64.h"
  17 #include "utils/ip_addr.h"
  18 #include "utils/eloop.h"
  19 #include "utils/json.h"
  20 #include "utils/module_tests.h"
  21
  22
  23 struct printf_test_data {
  24         u8 *data;
  25         size_t len;
  26         char *encoded;
  27 };
  28
  29 static const struct printf_test_data printf_tests[] = {
  30         { (u8 *) "abcde", 5, "abcde" },
  31         { (u8 *) "a\0b\nc\ed\re\tf\"\\", 13, "a\\0b\\nc\\ed\\re\\tf\\\"\\\\" },
  32         { (u8 *) "\x00\x31\x00\x32\x00\x39", 6, "\\x001\\0002\\09" },
  33         { (u8 *) "\n\n\n", 3, "\n\12\x0a" },
  34         { (u8 *) "\303\245\303\244\303\266\303\205\303\204\303\226", 12,
  35           "\\xc3\\xa5\xc3\\xa4\\xc3\\xb6\\xc3\\x85\\xc3\\x84\\xc3\\x96" },
  36         { (u8 *) "\303\245\303\244\303\266\303\205\303\204\303\226", 12,
  37           "\\303\\245\\303\\244\\303\\266\\303\\205\\303\\204\\303\\226" },
  38         { (u8 *) "\xe5\xe4\xf6\xc5\xc4\xd6", 6,
  39           "\\xe5\\xe4\\xf6\\xc5\\xc4\\xd6" },
  40         { NULL, 0, NULL }
  41 };
  42
  43
  44 static int printf_encode_decode_tests(void)
  45 {
  46         int i;
  47         size_t binlen;
  48         char buf[100];
  49         u8 bin[100];
  50         int errors = 0;
  51         int array[10];
  52
  53         wpa_printf(MSG_INFO, "printf encode/decode tests");
  54
  55         for (i = 0; printf_tests[i].data; i++) {
  56                 const struct printf_test_data *test = &printf_tests[i];
  57                 printf_encode(buf, sizeof(buf), test->data, test->len);
  58                 wpa_printf(MSG_INFO, "%d: -> \"%s\"", i, buf);
  59
  60                 binlen = printf_decode(bin, sizeof(bin), buf);
  61                 if (binlen != test->len ||
  62                     os_memcmp(bin, test->data, binlen) != 0) {
  63                         wpa_hexdump(MSG_ERROR, "Error in decoding#1",
  64                                     bin, binlen);
  65                         errors++;
  66                 }
  67
  68                 binlen = printf_decode(bin, sizeof(bin), test->encoded);
  69                 if (binlen != test->len ||
  70                     os_memcmp(bin, test->data, binlen) != 0) {
  71                         wpa_hexdump(MSG_ERROR, "Error in decoding#2",
  72                                     bin, binlen);
  73                         errors++;
  74                 }
  75         }
  76
  77         buf[5] = 'A';
  78         printf_encode(buf, 5, (const u8 *) "abcde", 5);
  79         if (buf[5] != 'A') {
  80                 wpa_printf(MSG_ERROR, "Error in bounds checking#1");
  81                 errors++;
  82         }
  83
  84         for (i = 5; i < 10; i++) {
  85                 buf[i] = 'A';
  86                 printf_encode(buf, i, (const u8 *) "\xdd\xdd\xdd\xdd\xdd", 5);
  87                 if (buf[i] != 'A') {
  88                         wpa_printf(MSG_ERROR, "Error in bounds checking#2(%d)",
  89                                    i);
  90                         errors++;
  91                 }
  92         }
  93
  94         if (printf_decode(bin, 3, "abcde") != 2)
  95                 errors++;
  96
  97         if (printf_decode(bin, 3, "\\xa") != 1 || bin[0] != 10)
  98                 errors++;
  99
 100         if (printf_decode(bin, 3, "\\xq") != 1 || bin[0] != 'q')
 101                 errors++;
 102
 103         if (printf_decode(bin, 3, "\\a") != 1 || bin[0] != 'a')
 104                 errors++;
 105
 106         array[0] = 10;
 107         array[1] = 10;
 108         array[2] = 5;
 109         array[3] = 10;
 110         array[4] = 5;
 111         array[5] = 0;
 112         if (int_array_len(array) != 5)
 113                 errors++;
 114         int_array_sort_unique(array);
 115         if (int_array_len(array) != 2)
 116                 errors++;
 117
 118         if (errors) {
 119                 wpa_printf(MSG_ERROR, "%d printf test(s) failed", errors);
 120                 return -1;
 121         }
 122
 123         return 0;
 124 }
 125
 126
 127 static int bitfield_tests(void)
 128 {
 129         struct bitfield *bf;
 130         int i;
 131         int errors = 0;
 132
 133         wpa_printf(MSG_INFO, "bitfield tests");
 134
 135         bf = bitfield_alloc(123);
 136         if (bf == NULL)
 137                 return -1;
 138
 139         for (i = 0; i < 123; i++) {
 140                 if (bitfield_is_set(bf, i) || bitfield_is_set(bf, i + 1))
 141                         errors++;
 142                 if (i > 0 && bitfield_is_set(bf, i - 1))
 143                         errors++;
 144                 bitfield_set(bf, i);
 145                 if (!bitfield_is_set(bf, i))
 146                         errors++;
 147                 bitfield_clear(bf, i);
 148                 if (bitfield_is_set(bf, i))
 149                         errors++;
 150         }
 151
 152         for (i = 123; i < 200; i++) {
 153                 if (bitfield_is_set(bf, i) || bitfield_is_set(bf, i + 1))
 154                         errors++;
 155                 if (i > 0 && bitfield_is_set(bf, i - 1))
 156                         errors++;
 157                 bitfield_set(bf, i);
 158                 if (bitfield_is_set(bf, i))
 159                         errors++;
 160                 bitfield_clear(bf, i);
 161                 if (bitfield_is_set(bf, i))
 162                         errors++;
 163         }
 164
 165         for (i = 0; i < 123; i++) {
 166                 if (bitfield_is_set(bf, i) || bitfield_is_set(bf, i + 1))
 167                         errors++;
 168                 bitfield_set(bf, i);
 169                 if (!bitfield_is_set(bf, i))
 170                         errors++;
 171         }
 172
 173         for (i = 0; i < 123; i++) {
 174                 if (!bitfield_is_set(bf, i))
 175                         errors++;
 176                 bitfield_clear(bf, i);
 177                 if (bitfield_is_set(bf, i))
 178                         errors++;
 179         }
 180
 181         for (i = 0; i < 123; i++) {
 182                 if (bitfield_get_first_zero(bf) != i)
 183                         errors++;
 184                 bitfield_set(bf, i);
 185         }
 186         if (bitfield_get_first_zero(bf) != -1)
 187                 errors++;
 188         for (i = 0; i < 123; i++) {
 189                 if (!bitfield_is_set(bf, i))
 190                         errors++;
 191                 bitfield_clear(bf, i);
 192                 if (bitfield_get_first_zero(bf) != i)
 193                         errors++;
 194                 bitfield_set(bf, i);
 195         }
 196         if (bitfield_get_first_zero(bf) != -1)
 197                 errors++;
 198
 199         bitfield_free(bf);
 200
 201         bf = bitfield_alloc(8);
 202         if (bf == NULL)
 203                 return -1;
 204         if (bitfield_get_first_zero(bf) != 0)
 205                 errors++;
 206         for (i = 0; i < 8; i++)
 207                 bitfield_set(bf, i);
 208         if (bitfield_get_first_zero(bf) != -1)
 209                 errors++;
 210         bitfield_free(bf);
 211
 212         if (errors) {
 213                 wpa_printf(MSG_ERROR, "%d bitfield test(s) failed", errors);
 214                 return -1;
 215         }
 216
 217         return 0;
 218 }
 219
 220
 221 static int int_array_tests(void)
 222 {
 223         int test1[] = { 1, 2, 3, 4, 5, 6, 0 };
 224         int test2[] = { 1, -1, 0 };
 225         int test3[] = { 1, 1, 1, -1, 2, 3, 4, 1, 2, 0 };
 226         int test3_res[] = { -1, 1, 2, 3, 4, 0 };
 227         int errors = 0;
 228         int len;
 229
 230         wpa_printf(MSG_INFO, "int_array tests");
 231
 232         if (int_array_len(test1) != 6 ||
 233             int_array_len(test2) != 2)
 234                 errors++;
 235
 236         int_array_sort_unique(test3);
 237         len = int_array_len(test3_res);
 238         if (int_array_len(test3) != len)
 239                 errors++;
 240         else if (os_memcmp(test3, test3_res, len * sizeof(int)) != 0)
 241                 errors++;
 242
 243         if (errors) {
 244                 wpa_printf(MSG_ERROR, "%d int_array test(s) failed", errors);
 245                 return -1;
 246         }
 247
 248         return 0;
 249 }
 250
 251
 252 static int ext_password_tests(void)
 253 {
 254         struct ext_password_data *data;
 255         int ret = 0;
 256         struct wpabuf *pw;
 257
 258         wpa_printf(MSG_INFO, "ext_password tests");
 259
 260         data = ext_password_init("unknown", "foo");
 261         if (data != NULL)
 262                 return -1;
 263
 264         data = ext_password_init("test", NULL);
 265         if (data == NULL)
 266                 return -1;
 267         pw = ext_password_get(data, "foo");
 268         if (pw != NULL)
 269                 ret = -1;
 270         ext_password_free(pw);
 271
 272         ext_password_deinit(data);
 273
 274         pw = ext_password_get(NULL, "foo");
 275         if (pw != NULL)
 276                 ret = -1;
 277         ext_password_free(pw);
 278
 279         return ret;
 280 }
 281
 282
 283 static int trace_tests(void)
 284 {
 285         wpa_printf(MSG_INFO, "trace tests");
 286
 287         wpa_trace_show("test backtrace");
 288         wpa_trace_dump_funcname("test funcname", trace_tests);
 289
 290         return 0;
 291 }
 292
 293
 294 static int base64_tests(void)
 295 {
 296         int errors = 0;
 297         unsigned char *res;
 298         size_t res_len;
 299
 300         wpa_printf(MSG_INFO, "base64 tests");
 301
 302         res = base64_encode((const unsigned char *) "", ~0, &res_len);
 303         if (res) {
 304                 errors++;
 305                 os_free(res);
 306         }
 307
 308         res = base64_encode((const unsigned char *) "=", 1, &res_len);
 309         if (!res || res_len != 5 || res[0] != 'P' || res[1] != 'Q' ||
 310             res[2] != '=' || res[3] != '=' || res[4] != '\n')
 311                 errors++;
 312         os_free(res);
 313
 314         res = base64_encode((const unsigned char *) "=", 1, NULL);
 315         if (!res || res[0] != 'P' || res[1] != 'Q' ||
 316             res[2] != '=' || res[3] != '=' || res[4] != '\n')
 317                 errors++;
 318         os_free(res);
 319
 320         res = base64_decode((const unsigned char *) "", 0, &res_len);
 321         if (res) {
 322                 errors++;
 323                 os_free(res);
 324         }
 325
 326         res = base64_decode((const unsigned char *) "a", 1, &res_len);
 327         if (res) {
 328                 errors++;
 329                 os_free(res);
 330         }
 331
 332         res = base64_decode((const unsigned char *) "====", 4, &res_len);
 333         if (res) {
 334                 errors++;
 335                 os_free(res);
 336         }
 337
 338         res = base64_decode((const unsigned char *) "PQ==", 4, &res_len);
 339         if (!res || res_len != 1 || res[0] != '=')
 340                 errors++;
 341         os_free(res);
 342
 343         res = base64_decode((const unsigned char *) "P.Q-=!=*", 8, &res_len);
 344         if (!res || res_len != 1 || res[0] != '=')
 345                 errors++;
 346         os_free(res);
 347
 348         if (errors) {
 349                 wpa_printf(MSG_ERROR, "%d base64 test(s) failed", errors);
 350                 return -1;
 351         }
 352
 353         return 0;
 354 }
 355
 356
 357 static int common_tests(void)
 358 {
 359         char buf[3], longbuf[100];
 360         u8 addr[ETH_ALEN] = { 1, 2, 3, 4, 5, 6 };
 361         u8 bin[3];
 362         int errors = 0;
 363         struct wpa_freq_range_list ranges;
 364         size_t len;
 365         const char *txt;
 366         u8 ssid[255];
 367
 368         wpa_printf(MSG_INFO, "common tests");
 369
 370         if (hwaddr_mask_txt(buf, 3, addr, addr) != -1)
 371                 errors++;
 372
 373         if (wpa_scnprintf(buf, 0, "hello") != 0 ||
 374             wpa_scnprintf(buf, 3, "hello") != 2)
 375                 errors++;
 376
 377         if (wpa_snprintf_hex(buf, 0, addr, ETH_ALEN) != 0 ||
 378             wpa_snprintf_hex(buf, 3, addr, ETH_ALEN) != 2)
 379                 errors++;
 380
 381         if (merge_byte_arrays(bin, 3, addr, ETH_ALEN, NULL, 0) != 3 ||
 382             merge_byte_arrays(bin, 3, NULL, 0, addr, ETH_ALEN) != 3)
 383                 errors++;
 384
 385         if (dup_binstr(NULL, 0) != NULL)
 386                 errors++;
 387
 388         if (freq_range_list_includes(NULL, 0) != 0)
 389                 errors++;
 390
 391         os_memset(&ranges, 0, sizeof(ranges));
 392         if (freq_range_list_parse(&ranges, "") != 0 ||
 393             freq_range_list_includes(&ranges, 0) != 0 ||
 394             freq_range_list_str(&ranges) != NULL)
 395                 errors++;
 396
 397         if (utf8_unescape(NULL, 0, buf, sizeof(buf)) != 0 ||
 398             utf8_unescape("a", 1, NULL, 0) != 0 ||
 399             utf8_unescape("a\\", 2, buf, sizeof(buf)) != 0 ||
 400             utf8_unescape("abcde", 5, buf, sizeof(buf)) != 0 ||
 401             utf8_unescape("abc", 3, buf, 3) != 3)
 402                 errors++;
 403
 404         if (utf8_unescape("a", 0, buf, sizeof(buf)) != 1 || buf[0] != 'a')
 405                 errors++;
 406
 407         if (utf8_unescape("\\b", 2, buf, sizeof(buf)) != 1 || buf[0] != 'b')
 408                 errors++;
 409
 410         if (utf8_escape(NULL, 0, buf, sizeof(buf)) != 0 ||
 411             utf8_escape("a", 1, NULL, 0) != 0 ||
 412             utf8_escape("abcde", 5, buf, sizeof(buf)) != 0 ||
 413             utf8_escape("a\\bcde", 6, buf, sizeof(buf)) != 0 ||
 414             utf8_escape("ab\\cde", 6, buf, sizeof(buf)) != 0 ||
 415             utf8_escape("abc\\de", 6, buf, sizeof(buf)) != 0 ||
 416             utf8_escape("abc", 3, buf, 3) != 3)
 417                 errors++;
 418
 419         if (utf8_escape("a", 0, buf, sizeof(buf)) != 1 || buf[0] != 'a')
 420                 errors++;
 421
 422         os_memset(ssid, 0, sizeof(ssid));
 423         txt = wpa_ssid_txt(ssid, sizeof(ssid));
 424         len = os_strlen(txt);
 425         /* Verify that SSID_MAX_LEN * 4 buffer limit is enforced. */
 426         if (len != SSID_MAX_LEN * 4) {
 427                 wpa_printf(MSG_ERROR,
 428                            "Unexpected wpa_ssid_txt() result with too long SSID");
 429                 errors++;
 430         }
 431
 432         if (wpa_snprintf_hex_sep(longbuf, 0, addr, ETH_ALEN, '-') != 0 ||
 433             wpa_snprintf_hex_sep(longbuf, 5, addr, ETH_ALEN, '-') != 3 ||
 434             os_strcmp(longbuf, "01-0") != 0)
 435                 errors++;
 436
 437         if (errors) {
 438                 wpa_printf(MSG_ERROR, "%d common test(s) failed", errors);
 439                 return -1;
 440         }
 441
 442         return 0;
 443 }
 444
 445
 446 static int os_tests(void)
 447 {
 448         int errors = 0;
 449         void *ptr;
 450         os_time_t t;
 451
 452         wpa_printf(MSG_INFO, "os tests");
 453
 454         ptr = os_calloc((size_t) -1, (size_t) -1);
 455         if (ptr) {
 456                 errors++;
 457                 os_free(ptr);
 458         }
 459         ptr = os_calloc((size_t) 2, (size_t) -1);
 460         if (ptr) {
 461                 errors++;
 462                 os_free(ptr);
 463         }
 464         ptr = os_calloc((size_t) -1, (size_t) 2);
 465         if (ptr) {
 466                 errors++;
 467                 os_free(ptr);
 468         }
 469
 470         ptr = os_realloc_array(NULL, (size_t) -1, (size_t) -1);
 471         if (ptr) {
 472                 errors++;
 473                 os_free(ptr);
 474         }
 475
 476         os_sleep(1, 1);
 477
 478         if (os_mktime(1969, 1, 1, 1, 1, 1, &t) == 0 ||
 479             os_mktime(1971, 0, 1, 1, 1, 1, &t) == 0 ||
 480             os_mktime(1971, 13, 1, 1, 1, 1, &t) == 0 ||
 481             os_mktime(1971, 1, 0, 1, 1, 1, &t) == 0 ||
 482             os_mktime(1971, 1, 32, 1, 1, 1, &t) == 0 ||
 483             os_mktime(1971, 1, 1, -1, 1, 1, &t) == 0 ||
 484             os_mktime(1971, 1, 1, 24, 1, 1, &t) == 0 ||
 485             os_mktime(1971, 1, 1, 1, -1, 1, &t) == 0 ||
 486             os_mktime(1971, 1, 1, 1, 60, 1, &t) == 0 ||
 487             os_mktime(1971, 1, 1, 1, 1, -1, &t) == 0 ||
 488             os_mktime(1971, 1, 1, 1, 1, 61, &t) == 0 ||
 489             os_mktime(1971, 1, 1, 1, 1, 1, &t) != 0 ||
 490             os_mktime(2020, 1, 2, 3, 4, 5, &t) != 0 ||
 491             os_mktime(2015, 12, 31, 23, 59, 59, &t) != 0)
 492                 errors++;
 493
 494         if (os_setenv("hwsim_test_env", "test value", 0) != 0 ||
 495             os_setenv("hwsim_test_env", "test value 2", 1) != 0 ||
 496             os_unsetenv("hwsim_test_env") != 0)
 497                 errors++;
 498
 499         if (os_file_exists("/this-file-does-not-exists-hwsim") != 0)
 500                 errors++;
 501
 502         if (errors) {
 503                 wpa_printf(MSG_ERROR, "%d os test(s) failed", errors);
 504                 return -1;
 505         }
 506
 507         return 0;
 508 }
 509
 510
 511 static int wpabuf_tests(void)
 512 {
 513         int errors = 0;
 514         void *ptr;
 515         struct wpabuf *buf;
 516
 517         wpa_printf(MSG_INFO, "wpabuf tests");
 518
 519         ptr = os_malloc(100);
 520         if (ptr) {
 521                 buf = wpabuf_alloc_ext_data(ptr, 100);
 522                 if (buf) {
 523                         if (wpabuf_resize(&buf, 100) < 0)
 524                                 errors++;
 525                         else
 526                                 wpabuf_put(buf, 100);
 527                         wpabuf_free(buf);
 528                 } else {
 529                         errors++;
 530                         os_free(ptr);
 531                 }
 532         } else {
 533                 errors++;
 534         }
 535
 536         buf = wpabuf_alloc(100);
 537         if (buf) {
 538                 struct wpabuf *buf2;
 539
 540                 wpabuf_put(buf, 100);
 541                 if (wpabuf_resize(&buf, 100) < 0)
 542                         errors++;
 543                 else
 544                         wpabuf_put(buf, 100);
 545                 buf2 = wpabuf_concat(buf, NULL);
 546                 if (buf2 != buf)
 547                         errors++;
 548                 wpabuf_free(buf2);
 549         } else {
 550                 errors++;
 551         }
 552
 553         buf = NULL;
 554         buf = wpabuf_zeropad(buf, 10);
 555         if (buf != NULL)
 556                 errors++;
 557
 558         if (errors) {
 559                 wpa_printf(MSG_ERROR, "%d wpabuf test(s) failed", errors);
 560                 return -1;
 561         }
 562
 563         return 0;
 564 }
 565
 566
 567 static int ip_addr_tests(void)
 568 {
 569         int errors = 0;
 570         struct hostapd_ip_addr addr;
 571         char buf[100];
 572
 573         wpa_printf(MSG_INFO, "ip_addr tests");
 574
 575         if (hostapd_parse_ip_addr("1.2.3.4", &addr) != 0 ||
 576             addr.af != AF_INET ||
 577             hostapd_ip_txt(NULL, buf, sizeof(buf)) != NULL ||
 578             hostapd_ip_txt(&addr, buf, 1) != buf || buf[0] != '\0' ||
 579             hostapd_ip_txt(&addr, buf, 0) != NULL ||
 580             hostapd_ip_txt(&addr, buf, sizeof(buf)) != buf)
 581                 errors++;
 582
 583         if (hostapd_parse_ip_addr("::", &addr) != 0 ||
 584             addr.af != AF_INET6 ||
 585             hostapd_ip_txt(&addr, buf, 1) != buf || buf[0] != '\0' ||
 586             hostapd_ip_txt(&addr, buf, sizeof(buf)) != buf)
 587                 errors++;
 588
 589         if (errors) {
 590                 wpa_printf(MSG_ERROR, "%d ip_addr test(s) failed", errors);
 591                 return -1;
 592         }
 593
 594         return 0;
 595 }
 596
 597
 598 struct test_eloop {
 599         unsigned int magic;
 600         int close_in_timeout;
 601         int pipefd1[2];
 602         int pipefd2[2];
 603 };
 604
 605
 606 static void eloop_tests_start(int close_in_timeout);
 607
 608
 609 static void eloop_test_read_2(int sock, void *eloop_ctx, void *sock_ctx)
 610 {
 611         struct test_eloop *t = eloop_ctx;
 612         ssize_t res;
 613         char buf[10];
 614
 615         wpa_printf(MSG_INFO, "%s: sock=%d", __func__, sock);
 616
 617         if (t->magic != 0x12345678) {
 618                 wpa_printf(MSG_INFO, "%s: unexpected magic 0x%x",
 619                            __func__, t->magic);
 620         }
 621
 622         if (t->pipefd2[0] != sock) {
 623                 wpa_printf(MSG_INFO, "%s: unexpected sock %d != %d",
 624                            __func__, sock, t->pipefd2[0]);
 625         }
 626
 627         res = read(sock, buf, sizeof(buf));
 628         wpa_printf(MSG_INFO, "%s: sock=%d --> res=%d",
 629                    __func__, sock, (int) res);
 630 }
 631
 632
 633 static void eloop_test_read_2_wrong(int sock, void *eloop_ctx, void *sock_ctx)
 634 {
 635         struct test_eloop *t = eloop_ctx;
 636
 637         wpa_printf(MSG_INFO, "%s: sock=%d", __func__, sock);
 638
 639         if (t->magic != 0x12345678) {
 640                 wpa_printf(MSG_INFO, "%s: unexpected magic 0x%x",
 641                            __func__, t->magic);
 642         }
 643
 644         if (t->pipefd2[0] != sock) {
 645                 wpa_printf(MSG_INFO, "%s: unexpected sock %d != %d",
 646                            __func__, sock, t->pipefd2[0]);
 647         }
 648
 649         /*
 650          * This is expected to block due to the original socket with data having
 651          * been closed and no new data having been written to the new socket
 652          * with the same fd. To avoid blocking the process during test, skip the
 653          * read here.
 654          */
 655         wpa_printf(MSG_ERROR, "%s: FAIL - should not have called this function",
 656                    __func__);
 657 }
 658
 659
 660 static void reopen_pipefd2(struct test_eloop *t)
 661 {
 662         if (t->pipefd2[0] < 0) {
 663                 wpa_printf(MSG_INFO, "pipefd2 had been closed");
 664         } else {
 665                 int res;
 666
 667                 wpa_printf(MSG_INFO, "close pipefd2");
 668                 eloop_unregister_read_sock(t->pipefd2[0]);
 669                 close(t->pipefd2[0]);
 670                 t->pipefd2[0] = -1;
 671                 close(t->pipefd2[1]);
 672                 t->pipefd2[1] = -1;
 673
 674                 res = pipe(t->pipefd2);
 675                 if (res < 0) {
 676                         wpa_printf(MSG_INFO, "pipe: %s", strerror(errno));
 677                         t->pipefd2[0] = -1;
 678                         t->pipefd2[1] = -1;
 679                         return;
 680                 }
 681
 682                 wpa_printf(MSG_INFO,
 683                            "re-register pipefd2 with new sockets %d,%d",
 684                            t->pipefd2[0], t->pipefd2[1]);
 685                 eloop_register_read_sock(t->pipefd2[0], eloop_test_read_2_wrong,
 686                                          t, NULL);
 687         }
 688 }
 689
 690
 691 static void eloop_test_read_1(int sock, void *eloop_ctx, void *sock_ctx)
 692 {
 693         struct test_eloop *t = eloop_ctx;
 694         ssize_t res;
 695         char buf[10];
 696
 697         wpa_printf(MSG_INFO, "%s: sock=%d", __func__, sock);
 698
 699         if (t->magic != 0x12345678) {
 700                 wpa_printf(MSG_INFO, "%s: unexpected magic 0x%x",
 701                            __func__, t->magic);
 702         }
 703
 704         if (t->pipefd1[0] != sock) {
 705                 wpa_printf(MSG_INFO, "%s: unexpected sock %d != %d",
 706                            __func__, sock, t->pipefd1[0]);
 707         }
 708
 709         res = read(sock, buf, sizeof(buf));
 710         wpa_printf(MSG_INFO, "%s: sock=%d --> res=%d",
 711                    __func__, sock, (int) res);
 712
 713         if (!t->close_in_timeout)
 714                 reopen_pipefd2(t);
 715 }
 716
 717
 718 static void eloop_test_cb(void *eloop_data, void *user_ctx)
 719 {
 720         struct test_eloop *t = eloop_data;
 721
 722         wpa_printf(MSG_INFO, "%s", __func__);
 723
 724         if (t->magic != 0x12345678) {
 725                 wpa_printf(MSG_INFO, "%s: unexpected magic 0x%x",
 726                            __func__, t->magic);
 727         }
 728
 729         if (t->close_in_timeout)
 730                 reopen_pipefd2(t);
 731 }
 732
 733
 734 static void eloop_test_timeout(void *eloop_data, void *user_ctx)
 735 {
 736         struct test_eloop *t = eloop_data;
 737         int next_run = 0;
 738
 739         wpa_printf(MSG_INFO, "%s", __func__);
 740
 741         if (t->magic != 0x12345678) {
 742                 wpa_printf(MSG_INFO, "%s: unexpected magic 0x%x",
 743                            __func__, t->magic);
 744         }
 745
 746         if (t->pipefd1[0] >= 0) {
 747                 wpa_printf(MSG_INFO, "pipefd1 had not been closed");
 748                 eloop_unregister_read_sock(t->pipefd1[0]);
 749                 close(t->pipefd1[0]);
 750                 t->pipefd1[0] = -1;
 751                 close(t->pipefd1[1]);
 752                 t->pipefd1[1] = -1;
 753         }
 754
 755         if (t->pipefd2[0] >= 0) {
 756                 wpa_printf(MSG_INFO, "pipefd2 had not been closed");
 757                 eloop_unregister_read_sock(t->pipefd2[0]);
 758                 close(t->pipefd2[0]);
 759                 t->pipefd2[0] = -1;
 760                 close(t->pipefd2[1]);
 761                 t->pipefd2[1] = -1;
 762         }
 763
 764         next_run = t->close_in_timeout;
 765         t->magic = 0;
 766         wpa_printf(MSG_INFO, "%s - free(%p)", __func__, t);
 767         os_free(t);
 768
 769         if (next_run)
 770                 eloop_tests_start(0);
 771 }
 772
 773
 774 static void eloop_tests_start(int close_in_timeout)
 775 {
 776         struct test_eloop *t;
 777         int res;
 778
 779         t = os_zalloc(sizeof(*t));
 780         if (!t)
 781                 return;
 782         t->magic = 0x12345678;
 783         t->close_in_timeout = close_in_timeout;
 784
 785         wpa_printf(MSG_INFO, "starting eloop tests (%p) (close_in_timeout=%d)",
 786                    t, close_in_timeout);
 787
 788         res = pipe(t->pipefd1);
 789         if (res < 0) {
 790                 wpa_printf(MSG_INFO, "pipe: %s", strerror(errno));
 791                 os_free(t);
 792                 return;
 793         }
 794
 795         res = pipe(t->pipefd2);
 796         if (res < 0) {
 797                 wpa_printf(MSG_INFO, "pipe: %s", strerror(errno));
 798                 close(t->pipefd1[0]);
 799                 close(t->pipefd1[1]);
 800                 os_free(t);
 801                 return;
 802         }
 803
 804         wpa_printf(MSG_INFO, "pipe fds: %d,%d %d,%d",
 805                    t->pipefd1[0], t->pipefd1[1],
 806                    t->pipefd2[0], t->pipefd2[1]);
 807
 808         eloop_register_read_sock(t->pipefd1[0], eloop_test_read_1, t, NULL);
 809         eloop_register_read_sock(t->pipefd2[0], eloop_test_read_2, t, NULL);
 810         eloop_register_timeout(0, 0, eloop_test_cb, t, NULL);
 811         eloop_register_timeout(0, 200000, eloop_test_timeout, t, NULL);
 812
 813         if (write(t->pipefd1[1], "HELLO", 5) < 0)
 814                 wpa_printf(MSG_INFO, "write: %s", strerror(errno));
 815         if (write(t->pipefd2[1], "TEST", 4) < 0)
 816                 wpa_printf(MSG_INFO, "write: %s", strerror(errno));
 817         os_sleep(0, 50000);
 818         wpa_printf(MSG_INFO, "waiting for eloop callbacks");
 819 }
 820
 821
 822 static void eloop_tests_run(void *eloop_data, void *user_ctx)
 823 {
 824         eloop_tests_start(1);
 825 }
 826
 827
 828 static int eloop_tests(void)
 829 {
 830         wpa_printf(MSG_INFO, "schedule eloop tests to be run");
 831
 832         /*
 833          * Cannot return error from these without a significant design change,
 834          * so for now, run the tests from a scheduled timeout and require
 835          * separate verification of the results from the debug log.
 836          */
 837         eloop_register_timeout(0, 0, eloop_tests_run, NULL, NULL);
 838
 839         return 0;
 840 }
 841
 842
 843 #ifdef CONFIG_JSON
 844 struct json_test_data {
 845         const char *json;
 846         const char *tree;
 847 };
 848
 849 static const struct json_test_data json_test_cases[] = {
 850         { "{}", "[1:OBJECT:]" },
 851         { "[]", "[1:ARRAY:]" },
 852         { "{", NULL },
 853         { "[", NULL },
 854         { "}", NULL },
 855         { "]", NULL },
 856         { "[[]]", "[1:ARRAY:][2:ARRAY:]" },
 857         { "{\"t\":\"test\"}", "[1:OBJECT:][2:STRING:t]" },
 858         { "{\"t\":123}", "[1:OBJECT:][2:NUMBER:t]" },
 859         { "{\"t\":true}", "[1:OBJECT:][2:BOOLEAN:t]" },
 860         { "{\"t\":false}", "[1:OBJECT:][2:BOOLEAN:t]" },
 861         { "{\"t\":null}", "[1:OBJECT:][2:NULL:t]" },
 862         { "{\"t\":truetrue}", NULL },
 863         { "\"test\"", "[1:STRING:]" },
 864         { "123", "[1:NUMBER:]" },
 865         { "true", "[1:BOOLEAN:]" },
 866         { "false", "[1:BOOLEAN:]" },
 867         { "null", "[1:NULL:]" },
 868         { "truetrue", NULL },
 869         { " {\t\n\r\"a\"\n:\r1\n,\n\"b\":3\n}\n",
 870           "[1:OBJECT:][2:NUMBER:a][2:NUMBER:b]" },
 871         { ",", NULL },
 872         { "{,}", NULL },
 873         { "[,]", NULL },
 874         { ":", NULL },
 875         { "{:}", NULL },
 876         { "[:]", NULL },
 877         { "{ \"\\u005c\" : \"\\u005c\" }", "[1:OBJECT:][2:STRING:\\]" },
 878         { "[{},{}]", "[1:ARRAY:][2:OBJECT:][2:OBJECT:]" },
 879         { "[1,2]", "[1:ARRAY:][2:NUMBER:][2:NUMBER:]" },
 880         { "[\"1\",\"2\"]", "[1:ARRAY:][2:STRING:][2:STRING:]" },
 881         { "[true,false]", "[1:ARRAY:][2:BOOLEAN:][2:BOOLEAN:]" },
 882 };
 883 #endif /* CONFIG_JSON */
 884
 885
 886 static int json_tests(void)
 887 {
 888 #ifdef CONFIG_JSON
 889         unsigned int i;
 890         struct json_token *root;
 891         char buf[1000];
 892
 893         wpa_printf(MSG_INFO, "JSON tests");
 894
 895         for (i = 0; i < ARRAY_SIZE(json_test_cases); i++) {
 896                 const struct json_test_data *test = &json_test_cases[i];
 897                 int res = 0;
 898
 899                 root = json_parse(test->json, os_strlen(test->json));
 900                 if ((root && !test->tree) || (!root && test->tree)) {
 901                         wpa_printf(MSG_INFO, "JSON test %u failed", i);
 902                         res = -1;
 903                 } else if (root) {
 904                         json_print_tree(root, buf, sizeof(buf));
 905                         if (os_strcmp(buf, test->tree) != 0) {
 906                                 wpa_printf(MSG_INFO,
 907                                            "JSON test %u tree mismatch: %s %s",
 908                                            i, buf, test->tree);
 909                                 res = -1;
 910                         }
 911                 }
 912                 json_free(root);
 913                 if (res < 0)
 914                         return -1;
 915
 916         }
 917 #endif /* CONFIG_JSON */
 918         return 0;
 919 }
 920
 921
 922 int utils_module_tests(void)
 923 {
 924         int ret = 0;
 925
 926         wpa_printf(MSG_INFO, "utils module tests");
 927
 928         if (printf_encode_decode_tests() < 0 ||
 929             ext_password_tests() < 0 ||
 930             trace_tests() < 0 ||
 931             bitfield_tests() < 0 ||
 932             base64_tests() < 0 ||
 933             common_tests() < 0 ||
 934             os_tests() < 0 ||
 935             wpabuf_tests() < 0 ||
 936             ip_addr_tests() < 0 ||
 937             eloop_tests() < 0 ||
 938             json_tests() < 0 ||
 939             int_array_tests() < 0)
 940                 ret = -1;
 941
 942         return ret;
 943 }