contrib/wpa/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 "utils/const_time.h"
  13 #include "common/ieee802_11_defs.h"
  14 #include "utils/bitfield.h"
  15 #include "utils/ext_password.h"
  16 #include "utils/trace.h"
  17 #include "utils/base64.h"
  18 #include "utils/ip_addr.h"
  19 #include "utils/eloop.h"
  20 #include "utils/json.h"
  21 #include "utils/module_tests.h"
  22
  23
  24 struct printf_test_data {
  25         u8 *data;
  26         size_t len;
  27         char *encoded;
  28 };
  29
  30 static const struct printf_test_data printf_tests[] = {
  31         { (u8 *) "abcde", 5, "abcde" },
  32         { (u8 *) "a\0b\nc\ed\re\tf\"\\", 13, "a\\0b\\nc\\ed\\re\\tf\\\"\\\\" },
  33         { (u8 *) "\x00\x31\x00\x32\x00\x39", 6, "\\x001\\0002\\09" },
  34         { (u8 *) "\n\n\n", 3, "\n\12\x0a" },
  35         { (u8 *) "\303\245\303\244\303\266\303\205\303\204\303\226", 12,
  36           "\\xc3\\xa5\xc3\\xa4\\xc3\\xb6\\xc3\\x85\\xc3\\x84\\xc3\\x96" },
  37         { (u8 *) "\303\245\303\244\303\266\303\205\303\204\303\226", 12,
  38           "\\303\\245\\303\\244\\303\\266\\303\\205\\303\\204\\303\\226" },
  39         { (u8 *) "\xe5\xe4\xf6\xc5\xc4\xd6", 6,
  40           "\\xe5\\xe4\\xf6\\xc5\\xc4\\xd6" },
  41         { NULL, 0, NULL }
  42 };
  43
  44
  45 static int printf_encode_decode_tests(void)
  46 {
  47         int i;
  48         size_t binlen;
  49         char buf[100];
  50         u8 bin[100];
  51         int errors = 0;
  52         int array[10];
  53
  54         wpa_printf(MSG_INFO, "printf encode/decode tests");
  55
  56         for (i = 0; printf_tests[i].data; i++) {
  57                 const struct printf_test_data *test = &printf_tests[i];
  58                 printf_encode(buf, sizeof(buf), test->data, test->len);
  59                 wpa_printf(MSG_INFO, "%d: -> \"%s\"", i, buf);
  60
  61                 binlen = printf_decode(bin, sizeof(bin), buf);
  62                 if (binlen != test->len ||
  63                     os_memcmp(bin, test->data, binlen) != 0) {
  64                         wpa_hexdump(MSG_ERROR, "Error in decoding#1",
  65                                     bin, binlen);
  66                         errors++;
  67                 }
  68
  69                 binlen = printf_decode(bin, sizeof(bin), test->encoded);
  70                 if (binlen != test->len ||
  71                     os_memcmp(bin, test->data, binlen) != 0) {
  72                         wpa_hexdump(MSG_ERROR, "Error in decoding#2",
  73                                     bin, binlen);
  74                         errors++;
  75                 }
  76         }
  77
  78         buf[5] = 'A';
  79         printf_encode(buf, 5, (const u8 *) "abcde", 5);
  80         if (buf[5] != 'A') {
  81                 wpa_printf(MSG_ERROR, "Error in bounds checking#1");
  82                 errors++;
  83         }
  84
  85         for (i = 5; i < 10; i++) {
  86                 buf[i] = 'A';
  87                 printf_encode(buf, i, (const u8 *) "\xdd\xdd\xdd\xdd\xdd", 5);
  88                 if (buf[i] != 'A') {
  89                         wpa_printf(MSG_ERROR, "Error in bounds checking#2(%d)",
  90                                    i);
  91                         errors++;
  92                 }
  93         }
  94
  95         if (printf_decode(bin, 3, "abcde") != 2)
  96                 errors++;
  97
  98         if (printf_decode(bin, 3, "\\xa") != 1 || bin[0] != 10)
  99                 errors++;
 100
 101         if (printf_decode(bin, 3, "\\xq") != 1 || bin[0] != 'q')
 102                 errors++;
 103
 104         if (printf_decode(bin, 3, "\\a") != 1 || bin[0] != 'a')
 105                 errors++;
 106
 107         array[0] = 10;
 108         array[1] = 10;
 109         array[2] = 5;
 110         array[3] = 10;
 111         array[4] = 5;
 112         array[5] = 0;
 113         if (int_array_len(array) != 5)
 114                 errors++;
 115         int_array_sort_unique(array);
 116         if (int_array_len(array) != 2)
 117                 errors++;
 118
 119         if (errors) {
 120                 wpa_printf(MSG_ERROR, "%d printf test(s) failed", errors);
 121                 return -1;
 122         }
 123
 124         return 0;
 125 }
 126
 127
 128 static int bitfield_tests(void)
 129 {
 130         struct bitfield *bf;
 131         int i;
 132         int errors = 0;
 133
 134         wpa_printf(MSG_INFO, "bitfield tests");
 135
 136         bf = bitfield_alloc(123);
 137         if (bf == NULL)
 138                 return -1;
 139
 140         for (i = 0; i < 123; i++) {
 141                 if (bitfield_is_set(bf, i) || bitfield_is_set(bf, i + 1))
 142                         errors++;
 143                 if (i > 0 && bitfield_is_set(bf, i - 1))
 144                         errors++;
 145                 bitfield_set(bf, i);
 146                 if (!bitfield_is_set(bf, i))
 147                         errors++;
 148                 bitfield_clear(bf, i);
 149                 if (bitfield_is_set(bf, i))
 150                         errors++;
 151         }
 152
 153         for (i = 123; i < 200; i++) {
 154                 if (bitfield_is_set(bf, i) || bitfield_is_set(bf, i + 1))
 155                         errors++;
 156                 if (i > 0 && bitfield_is_set(bf, i - 1))
 157                         errors++;
 158                 bitfield_set(bf, i);
 159                 if (bitfield_is_set(bf, i))
 160                         errors++;
 161                 bitfield_clear(bf, i);
 162                 if (bitfield_is_set(bf, i))
 163                         errors++;
 164         }
 165
 166         for (i = 0; i < 123; i++) {
 167                 if (bitfield_is_set(bf, i) || bitfield_is_set(bf, i + 1))
 168                         errors++;
 169                 bitfield_set(bf, i);
 170                 if (!bitfield_is_set(bf, i))
 171                         errors++;
 172         }
 173
 174         for (i = 0; i < 123; i++) {
 175                 if (!bitfield_is_set(bf, i))
 176                         errors++;
 177                 bitfield_clear(bf, i);
 178                 if (bitfield_is_set(bf, i))
 179                         errors++;
 180         }
 181
 182         for (i = 0; i < 123; i++) {
 183                 if (bitfield_get_first_zero(bf) != i)
 184                         errors++;
 185                 bitfield_set(bf, i);
 186         }
 187         if (bitfield_get_first_zero(bf) != -1)
 188                 errors++;
 189         for (i = 0; i < 123; i++) {
 190                 if (!bitfield_is_set(bf, i))
 191                         errors++;
 192                 bitfield_clear(bf, i);
 193                 if (bitfield_get_first_zero(bf) != i)
 194                         errors++;
 195                 bitfield_set(bf, i);
 196         }
 197         if (bitfield_get_first_zero(bf) != -1)
 198                 errors++;
 199
 200         bitfield_free(bf);
 201
 202         bf = bitfield_alloc(8);
 203         if (bf == NULL)
 204                 return -1;
 205         if (bitfield_get_first_zero(bf) != 0)
 206                 errors++;
 207         for (i = 0; i < 8; i++)
 208                 bitfield_set(bf, i);
 209         if (bitfield_get_first_zero(bf) != -1)
 210                 errors++;
 211         bitfield_free(bf);
 212
 213         if (errors) {
 214                 wpa_printf(MSG_ERROR, "%d bitfield test(s) failed", errors);
 215                 return -1;
 216         }
 217
 218         return 0;
 219 }
 220
 221
 222 static int int_array_tests(void)
 223 {
 224         int test1[] = { 1, 2, 3, 4, 5, 6, 0 };
 225         int test2[] = { 1, -1, 0 };
 226         int test3[] = { 1, 1, 1, -1, 2, 3, 4, 1, 2, 0 };
 227         int test3_res[] = { -1, 1, 2, 3, 4, 0 };
 228         int errors = 0;
 229         int len;
 230
 231         wpa_printf(MSG_INFO, "int_array tests");
 232
 233         if (int_array_len(test1) != 6 ||
 234             int_array_len(test2) != 2)
 235                 errors++;
 236
 237         int_array_sort_unique(test3);
 238         len = int_array_len(test3_res);
 239         if (int_array_len(test3) != len)
 240                 errors++;
 241         else if (os_memcmp(test3, test3_res, len * sizeof(int)) != 0)
 242                 errors++;
 243
 244         if (errors) {
 245                 wpa_printf(MSG_ERROR, "%d int_array test(s) failed", errors);
 246                 return -1;
 247         }
 248
 249         return 0;
 250 }
 251
 252
 253 static int ext_password_tests(void)
 254 {
 255         struct ext_password_data *data;
 256         int ret = 0;
 257         struct wpabuf *pw;
 258
 259         wpa_printf(MSG_INFO, "ext_password tests");
 260
 261         data = ext_password_init("unknown", "foo");
 262         if (data != NULL)
 263                 return -1;
 264
 265         data = ext_password_init("test", NULL);
 266         if (data == NULL)
 267                 return -1;
 268         pw = ext_password_get(data, "foo");
 269         if (pw != NULL)
 270                 ret = -1;
 271         ext_password_free(pw);
 272
 273         ext_password_deinit(data);
 274
 275         pw = ext_password_get(NULL, "foo");
 276         if (pw != NULL)
 277                 ret = -1;
 278         ext_password_free(pw);
 279
 280         return ret;
 281 }
 282
 283
 284 static int trace_tests(void)
 285 {
 286         wpa_printf(MSG_INFO, "trace tests");
 287
 288         wpa_trace_show("test backtrace");
 289         wpa_trace_dump_funcname("test funcname", trace_tests);
 290
 291         return 0;
 292 }
 293
 294
 295 static int base64_tests(void)
 296 {
 297         int errors = 0;
 298         unsigned char *res;
 299         size_t res_len;
 300
 301         wpa_printf(MSG_INFO, "base64 tests");
 302
 303         res = base64_encode((const unsigned char *) "", ~0, &res_len);
 304         if (res) {
 305                 errors++;
 306                 os_free(res);
 307         }
 308
 309         res = base64_encode((const unsigned char *) "=", 1, &res_len);
 310         if (!res || res_len != 5 || res[0] != 'P' || res[1] != 'Q' ||
 311             res[2] != '=' || res[3] != '=' || res[4] != '\n')
 312                 errors++;
 313         os_free(res);
 314
 315         res = base64_encode((const unsigned char *) "=", 1, NULL);
 316         if (!res || res[0] != 'P' || res[1] != 'Q' ||
 317             res[2] != '=' || res[3] != '=' || res[4] != '\n')
 318                 errors++;
 319         os_free(res);
 320
 321         res = base64_decode((const unsigned char *) "", 0, &res_len);
 322         if (res) {
 323                 errors++;
 324                 os_free(res);
 325         }
 326
 327         res = base64_decode((const unsigned char *) "a", 1, &res_len);
 328         if (res) {
 329                 errors++;
 330                 os_free(res);
 331         }
 332
 333         res = base64_decode((const unsigned char *) "====", 4, &res_len);
 334         if (res) {
 335                 errors++;
 336                 os_free(res);
 337         }
 338
 339         res = base64_decode((const unsigned char *) "PQ==", 4, &res_len);
 340         if (!res || res_len != 1 || res[0] != '=')
 341                 errors++;
 342         os_free(res);
 343
 344         res = base64_decode((const unsigned char *) "P.Q-=!=*", 8, &res_len);
 345         if (!res || res_len != 1 || res[0] != '=')
 346                 errors++;
 347         os_free(res);
 348
 349         if (errors) {
 350                 wpa_printf(MSG_ERROR, "%d base64 test(s) failed", errors);
 351                 return -1;
 352         }
 353
 354         return 0;
 355 }
 356
 357
 358 static int common_tests(void)
 359 {
 360         char buf[3], longbuf[100];
 361         u8 addr[ETH_ALEN] = { 1, 2, 3, 4, 5, 6 };
 362         u8 bin[3];
 363         int errors = 0;
 364         struct wpa_freq_range_list ranges;
 365         size_t len;
 366         const char *txt;
 367         u8 ssid[255];
 368
 369         wpa_printf(MSG_INFO, "common tests");
 370
 371         if (hwaddr_mask_txt(buf, 3, addr, addr) != -1)
 372                 errors++;
 373
 374         if (wpa_scnprintf(buf, 0, "hello") != 0 ||
 375             wpa_scnprintf(buf, 3, "hello") != 2)
 376                 errors++;
 377
 378         if (wpa_snprintf_hex(buf, 0, addr, ETH_ALEN) != 0 ||
 379             wpa_snprintf_hex(buf, 3, addr, ETH_ALEN) != 2)
 380                 errors++;
 381
 382         if (merge_byte_arrays(bin, 3, addr, ETH_ALEN, NULL, 0) != 3 ||
 383             merge_byte_arrays(bin, 3, NULL, 0, addr, ETH_ALEN) != 3)
 384                 errors++;
 385
 386         if (dup_binstr(NULL, 0) != NULL)
 387                 errors++;
 388
 389         if (freq_range_list_includes(NULL, 0) != 0)
 390                 errors++;
 391
 392         os_memset(&ranges, 0, sizeof(ranges));
 393         if (freq_range_list_parse(&ranges, "") != 0 ||
 394             freq_range_list_includes(&ranges, 0) != 0 ||
 395             freq_range_list_str(&ranges) != NULL)
 396                 errors++;
 397
 398         if (utf8_unescape(NULL, 0, buf, sizeof(buf)) != 0 ||
 399             utf8_unescape("a", 1, NULL, 0) != 0 ||
 400             utf8_unescape("a\\", 2, buf, sizeof(buf)) != 0 ||
 401             utf8_unescape("abcde", 5, buf, sizeof(buf)) != 0 ||
 402             utf8_unescape("abc", 3, buf, 3) != 3)
 403                 errors++;
 404
 405         if (utf8_unescape("a", 0, buf, sizeof(buf)) != 1 || buf[0] != 'a')
 406                 errors++;
 407
 408         if (utf8_unescape("\\b", 2, buf, sizeof(buf)) != 1 || buf[0] != 'b')
 409                 errors++;
 410
 411         if (utf8_escape(NULL, 0, buf, sizeof(buf)) != 0 ||
 412             utf8_escape("a", 1, NULL, 0) != 0 ||
 413             utf8_escape("abcde", 5, buf, sizeof(buf)) != 0 ||
 414             utf8_escape("a\\bcde", 6, buf, sizeof(buf)) != 0 ||
 415             utf8_escape("ab\\cde", 6, buf, sizeof(buf)) != 0 ||
 416             utf8_escape("abc\\de", 6, buf, sizeof(buf)) != 0 ||
 417             utf8_escape("abc", 3, buf, 3) != 3)
 418                 errors++;
 419
 420         if (utf8_escape("a", 0, buf, sizeof(buf)) != 1 || buf[0] != 'a')
 421                 errors++;
 422
 423         os_memset(ssid, 0, sizeof(ssid));
 424         txt = wpa_ssid_txt(ssid, sizeof(ssid));
 425         len = os_strlen(txt);
 426         /* Verify that SSID_MAX_LEN * 4 buffer limit is enforced. */
 427         if (len != SSID_MAX_LEN * 4) {
 428                 wpa_printf(MSG_ERROR,
 429                            "Unexpected wpa_ssid_txt() result with too long SSID");
 430                 errors++;
 431         }
 432
 433         if (wpa_snprintf_hex_sep(longbuf, 0, addr, ETH_ALEN, '-') != 0 ||
 434             wpa_snprintf_hex_sep(longbuf, 5, addr, ETH_ALEN, '-') != 3 ||
 435             os_strcmp(longbuf, "01-0") != 0)
 436                 errors++;
 437
 438         if (errors) {
 439                 wpa_printf(MSG_ERROR, "%d common test(s) failed", errors);
 440                 return -1;
 441         }
 442
 443         return 0;
 444 }
 445
 446
 447 static int os_tests(void)
 448 {
 449         int errors = 0;
 450         void *ptr;
 451         os_time_t t;
 452
 453         wpa_printf(MSG_INFO, "os tests");
 454
 455         ptr = os_calloc((size_t) -1, (size_t) -1);
 456         if (ptr) {
 457                 errors++;
 458                 os_free(ptr);
 459         }
 460         ptr = os_calloc((size_t) 2, (size_t) -1);
 461         if (ptr) {
 462                 errors++;
 463                 os_free(ptr);
 464         }
 465         ptr = os_calloc((size_t) -1, (size_t) 2);
 466         if (ptr) {
 467                 errors++;
 468                 os_free(ptr);
 469         }
 470
 471         ptr = os_realloc_array(NULL, (size_t) -1, (size_t) -1);
 472         if (ptr) {
 473                 errors++;
 474                 os_free(ptr);
 475         }
 476
 477         os_sleep(1, 1);
 478
 479         if (os_mktime(1969, 1, 1, 1, 1, 1, &t) == 0 ||
 480             os_mktime(1971, 0, 1, 1, 1, 1, &t) == 0 ||
 481             os_mktime(1971, 13, 1, 1, 1, 1, &t) == 0 ||
 482             os_mktime(1971, 1, 0, 1, 1, 1, &t) == 0 ||
 483             os_mktime(1971, 1, 32, 1, 1, 1, &t) == 0 ||
 484             os_mktime(1971, 1, 1, -1, 1, 1, &t) == 0 ||
 485             os_mktime(1971, 1, 1, 24, 1, 1, &t) == 0 ||
 486             os_mktime(1971, 1, 1, 1, -1, 1, &t) == 0 ||
 487             os_mktime(1971, 1, 1, 1, 60, 1, &t) == 0 ||
 488             os_mktime(1971, 1, 1, 1, 1, -1, &t) == 0 ||
 489             os_mktime(1971, 1, 1, 1, 1, 61, &t) == 0 ||
 490             os_mktime(1971, 1, 1, 1, 1, 1, &t) != 0 ||
 491             os_mktime(2020, 1, 2, 3, 4, 5, &t) != 0 ||
 492             os_mktime(2015, 12, 31, 23, 59, 59, &t) != 0)
 493                 errors++;
 494
 495         if (os_setenv("hwsim_test_env", "test value", 0) != 0 ||
 496             os_setenv("hwsim_test_env", "test value 2", 1) != 0 ||
 497             os_unsetenv("hwsim_test_env") != 0)
 498                 errors++;
 499
 500         if (os_file_exists("/this-file-does-not-exists-hwsim") != 0)
 501                 errors++;
 502
 503         if (errors) {
 504                 wpa_printf(MSG_ERROR, "%d os test(s) failed", errors);
 505                 return -1;
 506         }
 507
 508         return 0;
 509 }
 510
 511
 512 static int wpabuf_tests(void)
 513 {
 514         int errors = 0;
 515         void *ptr;
 516         struct wpabuf *buf;
 517
 518         wpa_printf(MSG_INFO, "wpabuf tests");
 519
 520         ptr = os_malloc(100);
 521         if (ptr) {
 522                 buf = wpabuf_alloc_ext_data(ptr, 100);
 523                 if (buf) {
 524                         if (wpabuf_resize(&buf, 100) < 0)
 525                                 errors++;
 526                         else
 527                                 wpabuf_put(buf, 100);
 528                         wpabuf_free(buf);
 529                 } else {
 530                         errors++;
 531                         os_free(ptr);
 532                 }
 533         } else {
 534                 errors++;
 535         }
 536
 537         buf = wpabuf_alloc(100);
 538         if (buf) {
 539                 struct wpabuf *buf2;
 540
 541                 wpabuf_put(buf, 100);
 542                 if (wpabuf_resize(&buf, 100) < 0)
 543                         errors++;
 544                 else
 545                         wpabuf_put(buf, 100);
 546                 buf2 = wpabuf_concat(buf, NULL);
 547                 if (buf2 != buf)
 548                         errors++;
 549                 wpabuf_free(buf2);
 550         } else {
 551                 errors++;
 552         }
 553
 554         buf = NULL;
 555         buf = wpabuf_zeropad(buf, 10);
 556         if (buf != NULL)
 557                 errors++;
 558
 559         if (errors) {
 560                 wpa_printf(MSG_ERROR, "%d wpabuf test(s) failed", errors);
 561                 return -1;
 562         }
 563
 564         return 0;
 565 }
 566
 567
 568 static int ip_addr_tests(void)
 569 {
 570         int errors = 0;
 571         struct hostapd_ip_addr addr;
 572         char buf[100];
 573
 574         wpa_printf(MSG_INFO, "ip_addr tests");
 575
 576         if (hostapd_parse_ip_addr("1.2.3.4", &addr) != 0 ||
 577             addr.af != AF_INET ||
 578             hostapd_ip_txt(NULL, buf, sizeof(buf)) != NULL ||
 579             hostapd_ip_txt(&addr, buf, 1) != buf || buf[0] != '\0' ||
 580             hostapd_ip_txt(&addr, buf, 0) != NULL ||
 581             hostapd_ip_txt(&addr, buf, sizeof(buf)) != buf)
 582                 errors++;
 583
 584         if (hostapd_parse_ip_addr("::", &addr) != 0 ||
 585             addr.af != AF_INET6 ||
 586             hostapd_ip_txt(&addr, buf, 1) != buf || buf[0] != '\0' ||
 587             hostapd_ip_txt(&addr, buf, sizeof(buf)) != buf)
 588                 errors++;
 589
 590         if (errors) {
 591                 wpa_printf(MSG_ERROR, "%d ip_addr test(s) failed", errors);
 592                 return -1;
 593         }
 594
 595         return 0;
 596 }
 597
 598
 599 struct test_eloop {
 600         unsigned int magic;
 601         int close_in_timeout;
 602         int pipefd1[2];
 603         int pipefd2[2];
 604 };
 605
 606
 607 static void eloop_tests_start(int close_in_timeout);
 608
 609
 610 static void eloop_test_read_2(int sock, void *eloop_ctx, void *sock_ctx)
 611 {
 612         struct test_eloop *t = eloop_ctx;
 613         ssize_t res;
 614         char buf[10];
 615
 616         wpa_printf(MSG_INFO, "%s: sock=%d", __func__, sock);
 617
 618         if (t->magic != 0x12345678) {
 619                 wpa_printf(MSG_INFO, "%s: unexpected magic 0x%x",
 620                            __func__, t->magic);
 621         }
 622
 623         if (t->pipefd2[0] != sock) {
 624                 wpa_printf(MSG_INFO, "%s: unexpected sock %d != %d",
 625                            __func__, sock, t->pipefd2[0]);
 626         }
 627
 628         res = read(sock, buf, sizeof(buf));
 629         wpa_printf(MSG_INFO, "%s: sock=%d --> res=%d",
 630                    __func__, sock, (int) res);
 631 }
 632
 633
 634 static void eloop_test_read_2_wrong(int sock, void *eloop_ctx, void *sock_ctx)
 635 {
 636         struct test_eloop *t = eloop_ctx;
 637
 638         wpa_printf(MSG_INFO, "%s: sock=%d", __func__, sock);
 639
 640         if (t->magic != 0x12345678) {
 641                 wpa_printf(MSG_INFO, "%s: unexpected magic 0x%x",
 642                            __func__, t->magic);
 643         }
 644
 645         if (t->pipefd2[0] != sock) {
 646                 wpa_printf(MSG_INFO, "%s: unexpected sock %d != %d",
 647                            __func__, sock, t->pipefd2[0]);
 648         }
 649
 650         /*
 651          * This is expected to block due to the original socket with data having
 652          * been closed and no new data having been written to the new socket
 653          * with the same fd. To avoid blocking the process during test, skip the
 654          * read here.
 655          */
 656         wpa_printf(MSG_ERROR, "%s: FAIL - should not have called this function",
 657                    __func__);
 658 }
 659
 660
 661 static void reopen_pipefd2(struct test_eloop *t)
 662 {
 663         if (t->pipefd2[0] < 0) {
 664                 wpa_printf(MSG_INFO, "pipefd2 had been closed");
 665         } else {
 666                 int res;
 667
 668                 wpa_printf(MSG_INFO, "close pipefd2");
 669                 eloop_unregister_read_sock(t->pipefd2[0]);
 670                 close(t->pipefd2[0]);
 671                 t->pipefd2[0] = -1;
 672                 close(t->pipefd2[1]);
 673                 t->pipefd2[1] = -1;
 674
 675                 res = pipe(t->pipefd2);
 676                 if (res < 0) {
 677                         wpa_printf(MSG_INFO, "pipe: %s", strerror(errno));
 678                         t->pipefd2[0] = -1;
 679                         t->pipefd2[1] = -1;
 680                         return;
 681                 }
 682
 683                 wpa_printf(MSG_INFO,
 684                            "re-register pipefd2 with new sockets %d,%d",
 685                            t->pipefd2[0], t->pipefd2[1]);
 686                 eloop_register_read_sock(t->pipefd2[0], eloop_test_read_2_wrong,
 687                                          t, NULL);
 688         }
 689 }
 690
 691
 692 static void eloop_test_read_1(int sock, void *eloop_ctx, void *sock_ctx)
 693 {
 694         struct test_eloop *t = eloop_ctx;
 695         ssize_t res;
 696         char buf[10];
 697
 698         wpa_printf(MSG_INFO, "%s: sock=%d", __func__, sock);
 699
 700         if (t->magic != 0x12345678) {
 701                 wpa_printf(MSG_INFO, "%s: unexpected magic 0x%x",
 702                            __func__, t->magic);
 703         }
 704
 705         if (t->pipefd1[0] != sock) {
 706                 wpa_printf(MSG_INFO, "%s: unexpected sock %d != %d",
 707                            __func__, sock, t->pipefd1[0]);
 708         }
 709
 710         res = read(sock, buf, sizeof(buf));
 711         wpa_printf(MSG_INFO, "%s: sock=%d --> res=%d",
 712                    __func__, sock, (int) res);
 713
 714         if (!t->close_in_timeout)
 715                 reopen_pipefd2(t);
 716 }
 717
 718
 719 static void eloop_test_cb(void *eloop_data, void *user_ctx)
 720 {
 721         struct test_eloop *t = eloop_data;
 722
 723         wpa_printf(MSG_INFO, "%s", __func__);
 724
 725         if (t->magic != 0x12345678) {
 726                 wpa_printf(MSG_INFO, "%s: unexpected magic 0x%x",
 727                            __func__, t->magic);
 728         }
 729
 730         if (t->close_in_timeout)
 731                 reopen_pipefd2(t);
 732 }
 733
 734
 735 static void eloop_test_timeout(void *eloop_data, void *user_ctx)
 736 {
 737         struct test_eloop *t = eloop_data;
 738         int next_run = 0;
 739
 740         wpa_printf(MSG_INFO, "%s", __func__);
 741
 742         if (t->magic != 0x12345678) {
 743                 wpa_printf(MSG_INFO, "%s: unexpected magic 0x%x",
 744                            __func__, t->magic);
 745         }
 746
 747         if (t->pipefd1[0] >= 0) {
 748                 wpa_printf(MSG_INFO, "pipefd1 had not been closed");
 749                 eloop_unregister_read_sock(t->pipefd1[0]);
 750                 close(t->pipefd1[0]);
 751                 t->pipefd1[0] = -1;
 752                 close(t->pipefd1[1]);
 753                 t->pipefd1[1] = -1;
 754         }
 755
 756         if (t->pipefd2[0] >= 0) {
 757                 wpa_printf(MSG_INFO, "pipefd2 had not been closed");
 758                 eloop_unregister_read_sock(t->pipefd2[0]);
 759                 close(t->pipefd2[0]);
 760                 t->pipefd2[0] = -1;
 761                 close(t->pipefd2[1]);
 762                 t->pipefd2[1] = -1;
 763         }
 764
 765         next_run = t->close_in_timeout;
 766         t->magic = 0;
 767         wpa_printf(MSG_INFO, "%s - free(%p)", __func__, t);
 768         os_free(t);
 769
 770         if (next_run)
 771                 eloop_tests_start(0);
 772 }
 773
 774
 775 static void eloop_tests_start(int close_in_timeout)
 776 {
 777         struct test_eloop *t;
 778         int res;
 779
 780         t = os_zalloc(sizeof(*t));
 781         if (!t)
 782                 return;
 783         t->magic = 0x12345678;
 784         t->close_in_timeout = close_in_timeout;
 785
 786         wpa_printf(MSG_INFO, "starting eloop tests (%p) (close_in_timeout=%d)",
 787                    t, close_in_timeout);
 788
 789         res = pipe(t->pipefd1);
 790         if (res < 0) {
 791                 wpa_printf(MSG_INFO, "pipe: %s", strerror(errno));
 792                 os_free(t);
 793                 return;
 794         }
 795
 796         res = pipe(t->pipefd2);
 797         if (res < 0) {
 798                 wpa_printf(MSG_INFO, "pipe: %s", strerror(errno));
 799                 close(t->pipefd1[0]);
 800                 close(t->pipefd1[1]);
 801                 os_free(t);
 802                 return;
 803         }
 804
 805         wpa_printf(MSG_INFO, "pipe fds: %d,%d %d,%d",
 806                    t->pipefd1[0], t->pipefd1[1],
 807                    t->pipefd2[0], t->pipefd2[1]);
 808
 809         eloop_register_read_sock(t->pipefd1[0], eloop_test_read_1, t, NULL);
 810         eloop_register_read_sock(t->pipefd2[0], eloop_test_read_2, t, NULL);
 811         eloop_register_timeout(0, 0, eloop_test_cb, t, NULL);
 812         eloop_register_timeout(0, 200000, eloop_test_timeout, t, NULL);
 813
 814         if (write(t->pipefd1[1], "HELLO", 5) < 0)
 815                 wpa_printf(MSG_INFO, "write: %s", strerror(errno));
 816         if (write(t->pipefd2[1], "TEST", 4) < 0)
 817                 wpa_printf(MSG_INFO, "write: %s", strerror(errno));
 818         os_sleep(0, 50000);
 819         wpa_printf(MSG_INFO, "waiting for eloop callbacks");
 820 }
 821
 822
 823 static void eloop_tests_run(void *eloop_data, void *user_ctx)
 824 {
 825         eloop_tests_start(1);
 826 }
 827
 828
 829 static int eloop_tests(void)
 830 {
 831         wpa_printf(MSG_INFO, "schedule eloop tests to be run");
 832
 833         /*
 834          * Cannot return error from these without a significant design change,
 835          * so for now, run the tests from a scheduled timeout and require
 836          * separate verification of the results from the debug log.
 837          */
 838         eloop_register_timeout(0, 0, eloop_tests_run, NULL, NULL);
 839
 840         return 0;
 841 }
 842
 843
 844 #ifdef CONFIG_JSON
 845 struct json_test_data {
 846         const char *json;
 847         const char *tree;
 848 };
 849
 850 static const struct json_test_data json_test_cases[] = {
 851         { "{}", "[1:OBJECT:]" },
 852         { "[]", "[1:ARRAY:]" },
 853         { "{", NULL },
 854         { "[", NULL },
 855         { "}", NULL },
 856         { "]", NULL },
 857         { "[[]]", "[1:ARRAY:][2:ARRAY:]" },
 858         { "{\"t\":\"test\"}", "[1:OBJECT:][2:STRING:t]" },
 859         { "{\"t\":123}", "[1:OBJECT:][2:NUMBER:t]" },
 860         { "{\"t\":true}", "[1:OBJECT:][2:BOOLEAN:t]" },
 861         { "{\"t\":false}", "[1:OBJECT:][2:BOOLEAN:t]" },
 862         { "{\"t\":null}", "[1:OBJECT:][2:NULL:t]" },
 863         { "{\"t\":truetrue}", NULL },
 864         { "\"test\"", "[1:STRING:]" },
 865         { "123", "[1:NUMBER:]" },
 866         { "true", "[1:BOOLEAN:]" },
 867         { "false", "[1:BOOLEAN:]" },
 868         { "null", "[1:NULL:]" },
 869         { "truetrue", NULL },
 870         { " {\t\n\r\"a\"\n:\r1\n,\n\"b\":3\n}\n",
 871           "[1:OBJECT:][2:NUMBER:a][2:NUMBER:b]" },
 872         { ",", NULL },
 873         { "{,}", NULL },
 874         { "[,]", NULL },
 875         { ":", NULL },
 876         { "{:}", NULL },
 877         { "[:]", NULL },
 878         { "{ \"\\u005c\" : \"\\u005c\" }", "[1:OBJECT:][2:STRING:\\]" },
 879         { "[{},{}]", "[1:ARRAY:][2:OBJECT:][2:OBJECT:]" },
 880         { "[1,2]", "[1:ARRAY:][2:NUMBER:][2:NUMBER:]" },
 881         { "[\"1\",\"2\"]", "[1:ARRAY:][2:STRING:][2:STRING:]" },
 882         { "[true,false]", "[1:ARRAY:][2:BOOLEAN:][2:BOOLEAN:]" },
 883 };
 884 #endif /* CONFIG_JSON */
 885
 886
 887 static int json_tests(void)
 888 {
 889 #ifdef CONFIG_JSON
 890         unsigned int i;
 891         struct json_token *root;
 892         char buf[1000];
 893
 894         wpa_printf(MSG_INFO, "JSON tests");
 895
 896         for (i = 0; i < ARRAY_SIZE(json_test_cases); i++) {
 897                 const struct json_test_data *test = &json_test_cases[i];
 898                 int res = 0;
 899
 900                 root = json_parse(test->json, os_strlen(test->json));
 901                 if ((root && !test->tree) || (!root && test->tree)) {
 902                         wpa_printf(MSG_INFO, "JSON test %u failed", i);
 903                         res = -1;
 904                 } else if (root) {
 905                         json_print_tree(root, buf, sizeof(buf));
 906                         if (os_strcmp(buf, test->tree) != 0) {
 907                                 wpa_printf(MSG_INFO,
 908                                            "JSON test %u tree mismatch: %s %s",
 909                                            i, buf, test->tree);
 910                                 res = -1;
 911                         }
 912                 }
 913                 json_free(root);
 914                 if (res < 0)
 915                         return -1;
 916
 917         }
 918 #endif /* CONFIG_JSON */
 919         return 0;
 920 }
 921
 922
 923 static int const_time_tests(void)
 924 {
 925         struct const_time_fill_msb_test {
 926                 unsigned int val;
 927                 unsigned int expected;
 928         } const_time_fill_msb_tests[] = {
 929                 { 0, 0 },
 930                 { 1, 0 },
 931                 { 2, 0 },
 932                 { 1 << (sizeof(unsigned int) * 8 - 1), ~0 },
 933                 { ~0 - 1, ~0 },
 934                 { ~0, ~0 }
 935         };
 936         struct const_time_is_zero_test {
 937                 unsigned int val;
 938                 unsigned int expected;
 939         } const_time_is_zero_tests[] = {
 940                 { 0, ~0 },
 941                 { 1, 0 },
 942                 { 2, 0 },
 943                 { 1 << (sizeof(unsigned int) * 8 - 1), 0 },
 944                 { ~0 - 1, 0 },
 945                 { ~0, 0 }
 946         };
 947         struct const_time_eq_test {
 948                 unsigned int a;
 949                 unsigned int b;
 950                 unsigned int expected;
 951                 unsigned int expected_u8;
 952         } const_time_eq_tests[] = {
 953                 { 0, 1, 0, 0 },
 954                 { 1, 2, 0, 0 },
 955                 { 1, 1, ~0, 0xff },
 956                 { ~0, ~0, ~0, 0xff },
 957                 { ~0, ~0 - 1, 0, 0 },
 958                 { 0, 0, ~0, 0xff }
 959         };
 960         struct const_time_eq_bin_test {
 961                 u8 *a;
 962                 u8 *b;
 963                 size_t len;
 964                 unsigned int expected;
 965         } const_time_eq_bin_tests[] = {
 966                 { (u8 *) "", (u8 *) "", 0, ~0 },
 967                 { (u8 *) "abcde", (u8 *) "abcde", 5, ~0 },
 968                 { (u8 *) "abcde", (u8 *) "Abcde", 5, 0 },
 969                 { (u8 *) "abcde", (u8 *) "aBcde", 5, 0 },
 970                 { (u8 *) "abcde", (u8 *) "abCde", 5, 0 },
 971                 { (u8 *) "abcde", (u8 *) "abcDe", 5, 0 },
 972                 { (u8 *) "abcde", (u8 *) "abcdE", 5, 0 },
 973                 { (u8 *) "\x00", (u8 *) "\x01", 1, 0 },
 974                 { (u8 *) "\x00", (u8 *) "\x80", 1, 0 },
 975                 { (u8 *) "\x00", (u8 *) "\x00", 1, ~0 }
 976         };
 977         struct const_time_select_test {
 978                 unsigned int mask;
 979                 unsigned int true_val;
 980                 unsigned int false_val;
 981                 unsigned int expected;
 982         } const_time_select_tests[] = {
 983                 { ~0, ~0, ~0, ~0 },
 984                 { 0, ~0, ~0, ~0 },
 985                 { ~0, ~0, 0, ~0 },
 986                 { 0, ~0, 0, 0 },
 987                 { ~0, 0xaaaaaaaa, 0x55555555, 0xaaaaaaaa },
 988                 { 0, 0xaaaaaaaa, 0x55555555, 0x55555555 },
 989                 { ~0, 3, 3, 3 },
 990                 { 0, 3, 3, 3 },
 991                 { ~0, 1, 2, 1 },
 992                 { 0, 1, 2, 2 }
 993         };
 994         struct const_time_select_int_test {
 995                 unsigned int mask;
 996                 int true_val;
 997                 int false_val;
 998                 int expected;
 999         } const_time_select_int_tests[] = {
1000                 { ~0, -128, 127, -128 },
1001                 { 0, -128, 127, 127 },
1002                 { ~0, -2147483648, 2147483647, -2147483648 },
1003                 { 0, -2147483648, 2147483647, 2147483647 },
1004                 { ~0, 0, 0, 0 },
1005                 { 0, 0, 0, 0 },
1006                 { ~0, -1, 1, -1 },
1007                 { 0, -1, 1, 1 }
1008         };
1009         struct const_time_select_u8_test {
1010                 u8 mask;
1011                 u8 true_val;
1012                 u8 false_val;
1013                 u8 expected;
1014         } const_time_select_u8_tests[] = {
1015                 { ~0, ~0, ~0, ~0 },
1016                 { 0, ~0, ~0, ~0 },
1017                 { ~0, ~0, 0, ~0 },
1018                 { 0, ~0, 0, 0 },
1019                 { ~0, 0xaa, 0x55, 0xaa },
1020                 { 0, 0xaa, 0x55, 0x55 },
1021                 { ~0, 1, 2, 1 },
1022                 { 0, 1, 2, 2 }
1023         };
1024         struct const_time_select_s8_test {
1025                 u8 mask;
1026                 s8 true_val;
1027                 s8 false_val;
1028                 s8 expected;
1029         } const_time_select_s8_tests[] = {
1030                 { ~0, -128, 127, -128 },
1031                 { 0, -128, 127, 127 },
1032                 { ~0, 0, 0, 0 },
1033                 { 0, 0, 0, 0 },
1034                 { ~0, -1, 1, -1 },
1035                 { 0, -1, 1, 1 }
1036         };
1037         struct const_time_select_bin_test {
1038                 u8 mask;
1039                 u8 *true_val;
1040                 u8 *false_val;
1041                 size_t len;
1042                 u8 *expected;
1043         } const_time_select_bin_tests[] = {
1044                 { ~0, (u8 *) "abcde", (u8 *) "ABCDE", 5, (u8 *) "abcde" },
1045                 { 0, (u8 *) "abcde", (u8 *) "ABCDE", 5, (u8 *) "ABCDE" },
1046                 { ~0, (u8 *) "", (u8 *) "", 0, (u8 *) "" },
1047                 { 0, (u8 *) "", (u8 *) "", 0, (u8 *) "" }
1048         };
1049         struct const_time_memcmp_test {
1050                 char *a;
1051                 char *b;
1052                 size_t len;
1053                 int expected;
1054         } const_time_memcmp_tests[] = {
1055                 { "abcde", "abcde", 5, 0 },
1056                 { "abcde", "bbcde", 5, -1 },
1057                 { "bbcde", "abcde", 5, 1 },
1058                 { "accde", "abcde", 5, 1 },
1059                 { "abcee", "abcde", 5, 1 },
1060                 { "abcdf", "abcde", 5, 1 },
1061                 { "cbcde", "aXXXX", 5, 2 },
1062                 { "a", "d", 1, -3 },
1063                 { "", "", 0, 0 }
1064         };
1065         unsigned int i;
1066         int ret = 0;
1067
1068         wpa_printf(MSG_INFO, "constant time tests");
1069
1070         for (i = 0; i < ARRAY_SIZE(const_time_fill_msb_tests); i++) {
1071                 struct const_time_fill_msb_test *test;
1072
1073                 test = &const_time_fill_msb_tests[i];
1074                 if (const_time_fill_msb(test->val) != test->expected) {
1075                         wpa_printf(MSG_ERROR,
1076                                    "const_time_fill_msb(0x%x) test failed",
1077                                    test->val);
1078                         ret = -1;
1079                 }
1080         }
1081
1082         for (i = 0; i < ARRAY_SIZE(const_time_is_zero_tests); i++) {
1083                 struct const_time_is_zero_test *test;
1084
1085                 test = &const_time_is_zero_tests[i];
1086                 if (const_time_is_zero(test->val) != test->expected) {
1087                         wpa_printf(MSG_ERROR,
1088                                    "const_time_is_zero(0x%x) test failed",
1089                                    test->val);
1090                         ret = -1;
1091                 }
1092         }
1093
1094         for (i = 0; i < ARRAY_SIZE(const_time_eq_tests); i++) {
1095                 struct const_time_eq_test *test;
1096
1097                 test = &const_time_eq_tests[i];
1098                 if (const_time_eq(test->a, test->b) != test->expected) {
1099                         wpa_printf(MSG_ERROR,
1100                                    "const_time_eq(0x%x,0x%x) test failed",
1101                                    test->a, test->b);
1102                         ret = -1;
1103                 }
1104                 if (const_time_eq_u8(test->a, test->b) != test->expected_u8) {
1105                         wpa_printf(MSG_ERROR,
1106                                    "const_time_eq_u8(0x%x,0x%x) test failed",
1107                                    test->a, test->b);
1108                         ret = -1;
1109                 }
1110         }
1111
1112         for (i = 0; i < ARRAY_SIZE(const_time_eq_bin_tests); i++) {
1113                 struct const_time_eq_bin_test *test;
1114
1115                 test = &const_time_eq_bin_tests[i];
1116                 if (const_time_eq_bin(test->a, test->b, test->len) !=
1117                     test->expected) {
1118                         wpa_printf(MSG_ERROR,
1119                                    "const_time_eq_bin(len=%u) test failed",
1120                                    (unsigned int) test->len);
1121                         ret = -1;
1122                 }
1123         }
1124
1125         for (i = 0; i < ARRAY_SIZE(const_time_select_tests); i++) {
1126                 struct const_time_select_test *test;
1127
1128                 test = &const_time_select_tests[i];
1129                 if (const_time_select(test->mask, test->true_val,
1130                                       test->false_val) != test->expected) {
1131                         wpa_printf(MSG_ERROR,
1132                                    "const_time_select(0x%x,0x%x,0x%x) test failed",
1133                                    test->mask, test->true_val, test->false_val);
1134                         ret = -1;
1135                 }
1136         }
1137
1138         for (i = 0; i < ARRAY_SIZE(const_time_select_int_tests); i++) {
1139                 struct const_time_select_int_test *test;
1140
1141                 test = &const_time_select_int_tests[i];
1142                 if (const_time_select_int(test->mask, test->true_val,
1143                                           test->false_val) != test->expected) {
1144                         wpa_printf(MSG_ERROR,
1145                                    "const_time_select_int(0x%x,%d,%d) test failed",
1146                                    test->mask, test->true_val, test->false_val);
1147                         ret = -1;
1148                 }
1149         }
1150
1151         for (i = 0; i < ARRAY_SIZE(const_time_select_u8_tests); i++) {
1152                 struct const_time_select_u8_test *test;
1153
1154                 test = &const_time_select_u8_tests[i];
1155                 if (const_time_select_u8(test->mask, test->true_val,
1156                                          test->false_val) != test->expected) {
1157                         wpa_printf(MSG_ERROR,
1158                                    "const_time_select_u8(0x%x,0x%x,0x%x) test failed",
1159                                    test->mask, test->true_val, test->false_val);
1160                         ret = -1;
1161                 }
1162         }
1163
1164         for (i = 0; i < ARRAY_SIZE(const_time_select_s8_tests); i++) {
1165                 struct const_time_select_s8_test *test;
1166
1167                 test = &const_time_select_s8_tests[i];
1168                 if (const_time_select_s8(test->mask, test->true_val,
1169                                          test->false_val) != test->expected) {
1170                         wpa_printf(MSG_ERROR,
1171                                    "const_time_select_s8(0x%x,0x%x,0x%x) test failed",
1172                                    test->mask, test->true_val, test->false_val);
1173                         ret = -1;
1174                 }
1175         }
1176
1177         for (i = 0; i < ARRAY_SIZE(const_time_select_bin_tests); i++) {
1178                 struct const_time_select_bin_test *test;
1179                 u8 dst[100];
1180
1181                 test = &const_time_select_bin_tests[i];
1182                 const_time_select_bin(test->mask, test->true_val,
1183                                       test->false_val, test->len, dst);
1184                 if (os_memcmp(dst, test->expected, test->len) != 0) {
1185                         wpa_printf(MSG_ERROR,
1186                                    "const_time_select_bin(0x%x,%u) test failed",
1187                                    test->mask, (unsigned int) test->len);
1188                         ret = -1;
1189                 }
1190         }
1191
1192         for (i = 0; i < ARRAY_SIZE(const_time_memcmp_tests); i++) {
1193                 struct const_time_memcmp_test *test;
1194                 int res;
1195
1196                 test = &const_time_memcmp_tests[i];
1197                 res = const_time_memcmp(test->a, test->b, test->len);
1198                 if (res != test->expected) {
1199                         wpa_printf(MSG_ERROR,
1200                                    "const_time_memcmp(%s,%s,%d) test failed (%d != %d)",
1201                                    test->a, test->b, (int) test->len,
1202                                    res, test->expected);
1203                         ret = -1;
1204                 }
1205         }
1206
1207         return ret;
1208 }
1209
1210
1211 int utils_module_tests(void)
1212 {
1213         int ret = 0;
1214
1215         wpa_printf(MSG_INFO, "utils module tests");
1216
1217         if (printf_encode_decode_tests() < 0 ||
1218             ext_password_tests() < 0 ||
1219             trace_tests() < 0 ||
1220             bitfield_tests() < 0 ||
1221             base64_tests() < 0 ||
1222             common_tests() < 0 ||
1223             os_tests() < 0 ||
1224             wpabuf_tests() < 0 ||
1225             ip_addr_tests() < 0 ||
1226             eloop_tests() < 0 ||
1227             json_tests() < 0 ||
1228             const_time_tests() < 0 ||
1229             int_array_tests() < 0)
1230                 ret = -1;
1231
1232         return ret;
1233 }