1 /* 2 * OS specific functions for UNIX/POSIX systems 3 * Copyright (c) 2005-2019, 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 "includes.h" 10 11 #include <time.h> 12 #include <sys/wait.h> 13 14 #ifdef ANDROID 15 #include <sys/capability.h> 16 #include <sys/prctl.h> 17 #include <private/android_filesystem_config.h> 18 #endif /* ANDROID */ 19 20 #ifdef __MACH__ 21 #include <CoreServices/CoreServices.h> 22 #include <mach/mach.h> 23 #include <mach/mach_time.h> 24 #endif /* __MACH__ */ 25 26 #include "os.h" 27 #include "common.h" 28 29 #ifdef WPA_TRACE 30 31 #include "wpa_debug.h" 32 #include "trace.h" 33 #include "list.h" 34 35 static struct dl_list alloc_list = DL_LIST_HEAD_INIT(alloc_list); 36 37 #define ALLOC_MAGIC 0xa84ef1b2 38 #define FREED_MAGIC 0x67fd487a 39 40 struct os_alloc_trace { 41 unsigned int magic; 42 struct dl_list list; 43 size_t len; 44 WPA_TRACE_INFO 45 } __attribute__((aligned(16))); 46 47 #endif /* WPA_TRACE */ 48 49 50 void os_sleep(os_time_t sec, os_time_t usec) 51 { 52 if (sec) 53 sleep(sec); 54 if (usec) 55 usleep(usec); 56 } 57 58 59 int os_get_time(struct os_time *t) 60 { 61 int res; 62 struct timeval tv; 63 res = gettimeofday(&tv, NULL); 64 t->sec = tv.tv_sec; 65 t->usec = tv.tv_usec; 66 return res; 67 } 68 69 70 int os_get_reltime(struct os_reltime *t) 71 { 72 #ifndef __MACH__ 73 #if defined(CLOCK_BOOTTIME) 74 static clockid_t clock_id = CLOCK_BOOTTIME; 75 #elif defined(CLOCK_MONOTONIC) 76 static clockid_t clock_id = CLOCK_MONOTONIC; 77 #else 78 static clockid_t clock_id = CLOCK_REALTIME; 79 #endif 80 struct timespec ts; 81 int res; 82 83 if (TEST_FAIL()) 84 return -1; 85 86 while (1) { 87 res = clock_gettime(clock_id, &ts); 88 if (res == 0) { 89 t->sec = ts.tv_sec; 90 t->usec = ts.tv_nsec / 1000; 91 return 0; 92 } 93 switch (clock_id) { 94 #ifdef CLOCK_BOOTTIME 95 case CLOCK_BOOTTIME: 96 clock_id = CLOCK_MONOTONIC; 97 break; 98 #endif 99 #ifdef CLOCK_MONOTONIC 100 case CLOCK_MONOTONIC: 101 clock_id = CLOCK_REALTIME; 102 break; 103 #endif 104 case CLOCK_REALTIME: 105 return -1; 106 } 107 } 108 #else /* __MACH__ */ 109 uint64_t abstime, nano; 110 static mach_timebase_info_data_t info = { 0, 0 }; 111 112 if (!info.denom) { 113 if (mach_timebase_info(&info) != KERN_SUCCESS) 114 return -1; 115 } 116 117 abstime = mach_absolute_time(); 118 nano = (abstime * info.numer) / info.denom; 119 120 t->sec = nano / NSEC_PER_SEC; 121 t->usec = (nano - (((uint64_t) t->sec) * NSEC_PER_SEC)) / NSEC_PER_USEC; 122 123 return 0; 124 #endif /* __MACH__ */ 125 } 126 127 128 int os_mktime(int year, int month, int day, int hour, int min, int sec, 129 os_time_t *t) 130 { 131 struct tm tm, *tm1; 132 time_t t_local, t1, t2; 133 os_time_t tz_offset; 134 135 if (year < 1970 || month < 1 || month > 12 || day < 1 || day > 31 || 136 hour < 0 || hour > 23 || min < 0 || min > 59 || sec < 0 || 137 sec > 60) 138 return -1; 139 140 memset(&tm, 0, sizeof(tm)); 141 tm.tm_year = year - 1900; 142 tm.tm_mon = month - 1; 143 tm.tm_mday = day; 144 tm.tm_hour = hour; 145 tm.tm_min = min; 146 tm.tm_sec = sec; 147 148 t_local = mktime(&tm); 149 150 /* figure out offset to UTC */ 151 tm1 = localtime(&t_local); 152 if (tm1) { 153 t1 = mktime(tm1); 154 tm1 = gmtime(&t_local); 155 if (tm1) { 156 t2 = mktime(tm1); 157 tz_offset = t2 - t1; 158 } else 159 tz_offset = 0; 160 } else 161 tz_offset = 0; 162 163 *t = (os_time_t) t_local - tz_offset; 164 return 0; 165 } 166 167 168 int os_gmtime(os_time_t t, struct os_tm *tm) 169 { 170 struct tm *tm2; 171 time_t t2 = t; 172 173 tm2 = gmtime(&t2); 174 if (tm2 == NULL) 175 return -1; 176 tm->sec = tm2->tm_sec; 177 tm->min = tm2->tm_min; 178 tm->hour = tm2->tm_hour; 179 tm->day = tm2->tm_mday; 180 tm->month = tm2->tm_mon + 1; 181 tm->year = tm2->tm_year + 1900; 182 return 0; 183 } 184 185 186 #ifdef __APPLE__ 187 #include <fcntl.h> 188 static int os_daemon(int nochdir, int noclose) 189 { 190 int devnull; 191 192 if (chdir("/") < 0) 193 return -1; 194 195 devnull = open("/dev/null", O_RDWR); 196 if (devnull < 0) 197 return -1; 198 199 if (dup2(devnull, STDIN_FILENO) < 0) { 200 close(devnull); 201 return -1; 202 } 203 204 if (dup2(devnull, STDOUT_FILENO) < 0) { 205 close(devnull); 206 return -1; 207 } 208 209 if (dup2(devnull, STDERR_FILENO) < 0) { 210 close(devnull); 211 return -1; 212 } 213 214 return 0; 215 } 216 #else /* __APPLE__ */ 217 #define os_daemon daemon 218 #endif /* __APPLE__ */ 219 220 221 #ifdef __FreeBSD__ 222 #include <err.h> 223 #include <libutil.h> 224 #include <stdint.h> 225 #endif /* __FreeBSD__ */ 226 227 int os_daemonize(const char *pid_file) 228 { 229 #if defined(__uClinux__) || defined(__sun__) 230 return -1; 231 #else /* defined(__uClinux__) || defined(__sun__) */ 232 #ifdef __FreeBSD__ 233 pid_t otherpid; 234 struct pidfh *pfh; 235 236 pfh = pidfile_open(pid_file, 0600, &otherpid); 237 if (pfh == NULL) { 238 if (errno == EEXIST) { 239 errx(1, "Daemon already running, pid: %jd.", 240 (intmax_t)otherpid); 241 } 242 warn("Cannot open or create pidfile."); 243 } 244 #endif /* __FreeBSD__ */ 245 246 if (os_daemon(0, 0)) { 247 perror("daemon"); 248 #ifdef __FreeBSD__ 249 pidfile_remove(pfh); 250 #endif /* __FreeBSD__ */ 251 return -1; 252 } 253 254 #ifndef __FreeBSD__ 255 if (pid_file) { 256 FILE *f = fopen(pid_file, "w"); 257 if (f) { 258 fprintf(f, "%u\n", getpid()); 259 fclose(f); 260 } 261 } 262 #else /* __FreeBSD__ */ 263 pidfile_write(pfh); 264 #endif /* __FreeBSD__ */ 265 266 return -0; 267 #endif /* defined(__uClinux__) || defined(__sun__) */ 268 } 269 270 271 void os_daemonize_terminate(const char *pid_file) 272 { 273 if (pid_file) 274 unlink(pid_file); 275 } 276 277 278 int os_get_random(unsigned char *buf, size_t len) 279 { 280 #ifdef TEST_FUZZ 281 size_t i; 282 283 for (i = 0; i < len; i++) 284 buf[i] = i & 0xff; 285 return 0; 286 #else /* TEST_FUZZ */ 287 FILE *f; 288 size_t rc; 289 290 if (TEST_FAIL()) 291 return -1; 292 293 f = fopen("/dev/urandom", "rb"); 294 if (f == NULL) { 295 printf("Could not open /dev/urandom.\n"); 296 return -1; 297 } 298 299 rc = fread(buf, 1, len, f); 300 fclose(f); 301 302 return rc != len ? -1 : 0; 303 #endif /* TEST_FUZZ */ 304 } 305 306 307 unsigned long os_random(void) 308 { 309 return random(); 310 } 311 312 313 char * os_rel2abs_path(const char *rel_path) 314 { 315 char *buf = NULL, *cwd, *ret; 316 size_t len = 128, cwd_len, rel_len, ret_len; 317 int last_errno; 318 319 if (!rel_path) 320 return NULL; 321 322 if (rel_path[0] == '/') 323 return os_strdup(rel_path); 324 325 for (;;) { 326 buf = os_malloc(len); 327 if (buf == NULL) 328 return NULL; 329 cwd = getcwd(buf, len); 330 if (cwd == NULL) { 331 last_errno = errno; 332 os_free(buf); 333 if (last_errno != ERANGE) 334 return NULL; 335 len *= 2; 336 if (len > 2000) 337 return NULL; 338 } else { 339 buf[len - 1] = '\0'; 340 break; 341 } 342 } 343 344 cwd_len = os_strlen(cwd); 345 rel_len = os_strlen(rel_path); 346 ret_len = cwd_len + 1 + rel_len + 1; 347 ret = os_malloc(ret_len); 348 if (ret) { 349 os_memcpy(ret, cwd, cwd_len); 350 ret[cwd_len] = '/'; 351 os_memcpy(ret + cwd_len + 1, rel_path, rel_len); 352 ret[ret_len - 1] = '\0'; 353 } 354 os_free(buf); 355 return ret; 356 } 357 358 359 int os_program_init(void) 360 { 361 #ifdef ANDROID 362 /* 363 * We ignore errors here since errors are normal if we 364 * are already running as non-root. 365 */ 366 #ifdef ANDROID_SETGROUPS_OVERRIDE 367 gid_t groups[] = { ANDROID_SETGROUPS_OVERRIDE }; 368 #else /* ANDROID_SETGROUPS_OVERRIDE */ 369 gid_t groups[] = { AID_INET, AID_WIFI, AID_KEYSTORE }; 370 #endif /* ANDROID_SETGROUPS_OVERRIDE */ 371 struct __user_cap_header_struct header; 372 struct __user_cap_data_struct cap; 373 374 setgroups(ARRAY_SIZE(groups), groups); 375 376 prctl(PR_SET_KEEPCAPS, 1, 0, 0, 0); 377 378 setgid(AID_WIFI); 379 setuid(AID_WIFI); 380 381 header.version = _LINUX_CAPABILITY_VERSION; 382 header.pid = 0; 383 cap.effective = cap.permitted = 384 (1 << CAP_NET_ADMIN) | (1 << CAP_NET_RAW); 385 cap.inheritable = 0; 386 capset(&header, &cap); 387 #endif /* ANDROID */ 388 389 return 0; 390 } 391 392 393 void os_program_deinit(void) 394 { 395 #ifdef WPA_TRACE 396 struct os_alloc_trace *a; 397 unsigned long total = 0; 398 dl_list_for_each(a, &alloc_list, struct os_alloc_trace, list) { 399 total += a->len; 400 if (a->magic != ALLOC_MAGIC) { 401 wpa_printf(MSG_INFO, "MEMLEAK[%p]: invalid magic 0x%x " 402 "len %lu", 403 a, a->magic, (unsigned long) a->len); 404 continue; 405 } 406 wpa_printf(MSG_INFO, "MEMLEAK[%p]: len %lu", 407 a, (unsigned long) a->len); 408 wpa_trace_dump("memleak", a); 409 } 410 if (total) 411 wpa_printf(MSG_INFO, "MEMLEAK: total %lu bytes", 412 (unsigned long) total); 413 wpa_trace_deinit(); 414 #endif /* WPA_TRACE */ 415 } 416 417 418 int os_setenv(const char *name, const char *value, int overwrite) 419 { 420 return setenv(name, value, overwrite); 421 } 422 423 424 int os_unsetenv(const char *name) 425 { 426 #if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__APPLE__) || \ 427 defined(__OpenBSD__) 428 unsetenv(name); 429 return 0; 430 #else 431 return unsetenv(name); 432 #endif 433 } 434 435 436 char * os_readfile(const char *name, size_t *len) 437 { 438 FILE *f; 439 char *buf; 440 long pos; 441 442 f = fopen(name, "rb"); 443 if (f == NULL) 444 return NULL; 445 446 if (fseek(f, 0, SEEK_END) < 0 || (pos = ftell(f)) < 0) { 447 fclose(f); 448 return NULL; 449 } 450 *len = pos; 451 if (fseek(f, 0, SEEK_SET) < 0) { 452 fclose(f); 453 return NULL; 454 } 455 456 buf = os_malloc(*len); 457 if (buf == NULL) { 458 fclose(f); 459 return NULL; 460 } 461 462 if (fread(buf, 1, *len, f) != *len) { 463 fclose(f); 464 os_free(buf); 465 return NULL; 466 } 467 468 fclose(f); 469 470 return buf; 471 } 472 473 474 int os_file_exists(const char *fname) 475 { 476 return access(fname, F_OK) == 0; 477 } 478 479 480 int os_fdatasync(FILE *stream) 481 { 482 if (!fflush(stream)) { 483 #ifdef __linux__ 484 return fdatasync(fileno(stream)); 485 #else /* !__linux__ */ 486 #ifdef F_FULLFSYNC 487 /* OS X does not implement fdatasync(). */ 488 return fcntl(fileno(stream), F_FULLFSYNC); 489 #else /* F_FULLFSYNC */ 490 return fsync(fileno(stream)); 491 #endif /* F_FULLFSYNC */ 492 #endif /* __linux__ */ 493 } 494 495 return -1; 496 } 497 498 499 #ifndef WPA_TRACE 500 void * os_zalloc(size_t size) 501 { 502 return calloc(1, size); 503 } 504 #endif /* WPA_TRACE */ 505 506 507 size_t os_strlcpy(char *dest, const char *src, size_t siz) 508 { 509 const char *s = src; 510 size_t left = siz; 511 512 if (left) { 513 /* Copy string up to the maximum size of the dest buffer */ 514 while (--left != 0) { 515 if ((*dest++ = *s++) == '\0') 516 break; 517 } 518 } 519 520 if (left == 0) { 521 /* Not enough room for the string; force NUL-termination */ 522 if (siz != 0) 523 *dest = '\0'; 524 while (*s++) 525 ; /* determine total src string length */ 526 } 527 528 return s - src - 1; 529 } 530 531 532 int os_memcmp_const(const void *a, const void *b, size_t len) 533 { 534 const u8 *aa = a; 535 const u8 *bb = b; 536 size_t i; 537 u8 res; 538 539 for (res = 0, i = 0; i < len; i++) 540 res |= aa[i] ^ bb[i]; 541 542 return res; 543 } 544 545 546 void * os_memdup(const void *src, size_t len) 547 { 548 void *r = os_malloc(len); 549 550 if (r && src) 551 os_memcpy(r, src, len); 552 return r; 553 } 554 555 556 #ifdef WPA_TRACE 557 558 #if defined(WPA_TRACE_BFD) && defined(CONFIG_TESTING_OPTIONS) 559 char wpa_trace_fail_func[256] = { 0 }; 560 unsigned int wpa_trace_fail_after; 561 562 static int testing_fail_alloc(void) 563 { 564 const char *func[WPA_TRACE_LEN]; 565 size_t i, res, len; 566 char *pos, *next; 567 int match; 568 569 if (!wpa_trace_fail_after) 570 return 0; 571 572 res = wpa_trace_calling_func(func, WPA_TRACE_LEN); 573 i = 0; 574 if (i < res && os_strcmp(func[i], __func__) == 0) 575 i++; 576 if (i < res && os_strcmp(func[i], "os_malloc") == 0) 577 i++; 578 if (i < res && os_strcmp(func[i], "os_zalloc") == 0) 579 i++; 580 if (i < res && os_strcmp(func[i], "os_calloc") == 0) 581 i++; 582 if (i < res && os_strcmp(func[i], "os_realloc") == 0) 583 i++; 584 if (i < res && os_strcmp(func[i], "os_realloc_array") == 0) 585 i++; 586 if (i < res && os_strcmp(func[i], "os_strdup") == 0) 587 i++; 588 if (i < res && os_strcmp(func[i], "os_memdup") == 0) 589 i++; 590 591 pos = wpa_trace_fail_func; 592 593 match = 0; 594 while (i < res) { 595 int allow_skip = 1; 596 int maybe = 0; 597 598 if (*pos == '=') { 599 allow_skip = 0; 600 pos++; 601 } else if (*pos == '?') { 602 maybe = 1; 603 pos++; 604 } 605 next = os_strchr(pos, ';'); 606 if (next) 607 len = next - pos; 608 else 609 len = os_strlen(pos); 610 if (os_memcmp(pos, func[i], len) != 0) { 611 if (maybe && next) { 612 pos = next + 1; 613 continue; 614 } 615 if (allow_skip) { 616 i++; 617 continue; 618 } 619 return 0; 620 } 621 if (!next) { 622 match = 1; 623 break; 624 } 625 pos = next + 1; 626 i++; 627 } 628 if (!match) 629 return 0; 630 631 wpa_trace_fail_after--; 632 if (wpa_trace_fail_after == 0) { 633 wpa_printf(MSG_INFO, "TESTING: fail allocation at %s", 634 wpa_trace_fail_func); 635 for (i = 0; i < res; i++) 636 wpa_printf(MSG_INFO, "backtrace[%d] = %s", 637 (int) i, func[i]); 638 return 1; 639 } 640 641 return 0; 642 } 643 644 645 char wpa_trace_test_fail_func[256] = { 0 }; 646 unsigned int wpa_trace_test_fail_after; 647 648 int testing_test_fail(void) 649 { 650 const char *func[WPA_TRACE_LEN]; 651 size_t i, res, len; 652 char *pos, *next; 653 int match; 654 655 if (!wpa_trace_test_fail_after) 656 return 0; 657 658 res = wpa_trace_calling_func(func, WPA_TRACE_LEN); 659 i = 0; 660 if (i < res && os_strcmp(func[i], __func__) == 0) 661 i++; 662 663 pos = wpa_trace_test_fail_func; 664 665 match = 0; 666 while (i < res) { 667 int allow_skip = 1; 668 int maybe = 0; 669 670 if (*pos == '=') { 671 allow_skip = 0; 672 pos++; 673 } else if (*pos == '?') { 674 maybe = 1; 675 pos++; 676 } 677 next = os_strchr(pos, ';'); 678 if (next) 679 len = next - pos; 680 else 681 len = os_strlen(pos); 682 if (os_memcmp(pos, func[i], len) != 0) { 683 if (maybe && next) { 684 pos = next + 1; 685 continue; 686 } 687 if (allow_skip) { 688 i++; 689 continue; 690 } 691 return 0; 692 } 693 if (!next) { 694 match = 1; 695 break; 696 } 697 pos = next + 1; 698 i++; 699 } 700 if (!match) 701 return 0; 702 703 wpa_trace_test_fail_after--; 704 if (wpa_trace_test_fail_after == 0) { 705 wpa_printf(MSG_INFO, "TESTING: fail at %s", 706 wpa_trace_test_fail_func); 707 for (i = 0; i < res; i++) 708 wpa_printf(MSG_INFO, "backtrace[%d] = %s", 709 (int) i, func[i]); 710 return 1; 711 } 712 713 return 0; 714 } 715 716 #else 717 718 static inline int testing_fail_alloc(void) 719 { 720 return 0; 721 } 722 #endif 723 724 void * os_malloc(size_t size) 725 { 726 struct os_alloc_trace *a; 727 728 if (testing_fail_alloc()) 729 return NULL; 730 731 a = malloc(sizeof(*a) + size); 732 if (a == NULL) 733 return NULL; 734 a->magic = ALLOC_MAGIC; 735 dl_list_add(&alloc_list, &a->list); 736 a->len = size; 737 wpa_trace_record(a); 738 return a + 1; 739 } 740 741 742 void * os_realloc(void *ptr, size_t size) 743 { 744 struct os_alloc_trace *a; 745 size_t copy_len; 746 void *n; 747 748 if (ptr == NULL) 749 return os_malloc(size); 750 751 a = (struct os_alloc_trace *) ptr - 1; 752 if (a->magic != ALLOC_MAGIC) { 753 wpa_printf(MSG_INFO, "REALLOC[%p]: invalid magic 0x%x%s", 754 a, a->magic, 755 a->magic == FREED_MAGIC ? " (already freed)" : ""); 756 wpa_trace_show("Invalid os_realloc() call"); 757 abort(); 758 } 759 n = os_malloc(size); 760 if (n == NULL) 761 return NULL; 762 copy_len = a->len; 763 if (copy_len > size) 764 copy_len = size; 765 os_memcpy(n, a + 1, copy_len); 766 os_free(ptr); 767 return n; 768 } 769 770 771 void os_free(void *ptr) 772 { 773 struct os_alloc_trace *a; 774 775 if (ptr == NULL) 776 return; 777 a = (struct os_alloc_trace *) ptr - 1; 778 if (a->magic != ALLOC_MAGIC) { 779 wpa_printf(MSG_INFO, "FREE[%p]: invalid magic 0x%x%s", 780 a, a->magic, 781 a->magic == FREED_MAGIC ? " (already freed)" : ""); 782 wpa_trace_show("Invalid os_free() call"); 783 abort(); 784 } 785 dl_list_del(&a->list); 786 a->magic = FREED_MAGIC; 787 788 wpa_trace_check_ref(ptr); 789 free(a); 790 } 791 792 793 void * os_zalloc(size_t size) 794 { 795 void *ptr = os_malloc(size); 796 if (ptr) 797 os_memset(ptr, 0, size); 798 return ptr; 799 } 800 801 802 char * os_strdup(const char *s) 803 { 804 size_t len; 805 char *d; 806 len = os_strlen(s); 807 d = os_malloc(len + 1); 808 if (d == NULL) 809 return NULL; 810 os_memcpy(d, s, len); 811 d[len] = '\0'; 812 return d; 813 } 814 815 #endif /* WPA_TRACE */ 816 817 818 int os_exec(const char *program, const char *arg, int wait_completion) 819 { 820 pid_t pid; 821 int pid_status; 822 823 pid = fork(); 824 if (pid < 0) { 825 perror("fork"); 826 return -1; 827 } 828 829 if (pid == 0) { 830 /* run the external command in the child process */ 831 const int MAX_ARG = 30; 832 char *_program, *_arg, *pos; 833 char *argv[MAX_ARG + 1]; 834 int i; 835 836 _program = os_strdup(program); 837 _arg = os_strdup(arg); 838 839 argv[0] = _program; 840 841 i = 1; 842 pos = _arg; 843 while (i < MAX_ARG && pos && *pos) { 844 while (*pos == ' ') 845 pos++; 846 if (*pos == '\0') 847 break; 848 argv[i++] = pos; 849 pos = os_strchr(pos, ' '); 850 if (pos) 851 *pos++ = '\0'; 852 } 853 argv[i] = NULL; 854 855 execv(program, argv); 856 perror("execv"); 857 os_free(_program); 858 os_free(_arg); 859 exit(0); 860 return -1; 861 } 862 863 if (wait_completion) { 864 /* wait for the child process to complete in the parent */ 865 waitpid(pid, &pid_status, 0); 866 } 867 868 return 0; 869 } 870