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