1 /* 2 * OS specific functions for UNIX/POSIX systems 3 * Copyright (c) 2005-2009, Jouni Malinen <j (at) 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 #include "os.h" 21 #include "common.h" 22 23 #ifdef WPA_TRACE 24 25 #include "wpa_debug.h" 26 #include "trace.h" 27 #include "list.h" 28 29 static struct dl_list alloc_list; 30 31 #define ALLOC_MAGIC 0xa84ef1b2 32 #define FREED_MAGIC 0x67fd487a 33 34 struct os_alloc_trace { 35 unsigned int magic; 36 struct dl_list list; 37 size_t len; 38 WPA_TRACE_INFO 39 }; 40 41 #endif /* WPA_TRACE */ 42 43 44 void os_sleep(os_time_t sec, os_time_t usec) 45 { 46 if (sec) 47 sleep(sec); 48 if (usec) 49 usleep(usec); 50 } 51 52 53 int os_get_time(struct os_time *t) 54 { 55 int res; 56 struct timeval tv; 57 res = gettimeofday(&tv, NULL); 58 t->sec = tv.tv_sec; 59 t->usec = tv.tv_usec; 60 return res; 61 } 62 63 64 int os_get_reltime(struct os_reltime *t) 65 { 66 #if defined(CLOCK_BOOTTIME) 67 static clockid_t clock_id = CLOCK_BOOTTIME; 68 #elif defined(CLOCK_MONOTONIC) 69 static clockid_t clock_id = CLOCK_MONOTONIC; 70 #else 71 static clockid_t clock_id = CLOCK_REALTIME; 72 #endif 73 struct timespec ts; 74 int res; 75 76 while (1) { 77 res = clock_gettime(clock_id, &ts); 78 if (res == 0) { 79 t->sec = ts.tv_sec; 80 t->usec = ts.tv_nsec / 1000; 81 return 0; 82 } 83 switch (clock_id) { 84 #ifdef CLOCK_BOOTTIME 85 case CLOCK_BOOTTIME: 86 clock_id = CLOCK_MONOTONIC; 87 break; 88 #endif 89 #ifdef CLOCK_MONOTONIC 90 case CLOCK_MONOTONIC: 91 clock_id = CLOCK_REALTIME; 92 break; 93 #endif 94 case CLOCK_REALTIME: 95 return -1; 96 } 97 } 98 } 99 100 101 int os_mktime(int year, int month, int day, int hour, int min, int sec, 102 os_time_t *t) 103 { 104 struct tm tm, *tm1; 105 time_t t_local, t1, t2; 106 os_time_t tz_offset; 107 108 if (year < 1970 || month < 1 || month > 12 || day < 1 || day > 31 || 109 hour < 0 || hour > 23 || min < 0 || min > 59 || sec < 0 || 110 sec > 60) 111 return -1; 112 113 memset(&tm, 0, sizeof(tm)); 114 tm.tm_year = year - 1900; 115 tm.tm_mon = month - 1; 116 tm.tm_mday = day; 117 tm.tm_hour = hour; 118 tm.tm_min = min; 119 tm.tm_sec = sec; 120 121 t_local = mktime(&tm); 122 123 /* figure out offset to UTC */ 124 tm1 = localtime(&t_local); 125 if (tm1) { 126 t1 = mktime(tm1); 127 tm1 = gmtime(&t_local); 128 if (tm1) { 129 t2 = mktime(tm1); 130 tz_offset = t2 - t1; 131 } else 132 tz_offset = 0; 133 } else 134 tz_offset = 0; 135 136 *t = (os_time_t) t_local - tz_offset; 137 return 0; 138 } 139 140 141 int os_gmtime(os_time_t t, struct os_tm *tm) 142 { 143 struct tm *tm2; 144 time_t t2 = t; 145 146 tm2 = gmtime(&t2); 147 if (tm2 == NULL) 148 return -1; 149 tm->sec = tm2->tm_sec; 150 tm->min = tm2->tm_min; 151 tm->hour = tm2->tm_hour; 152 tm->day = tm2->tm_mday; 153 tm->month = tm2->tm_mon + 1; 154 tm->year = tm2->tm_year + 1900; 155 return 0; 156 } 157 158 159 #ifdef __APPLE__ 160 #include <fcntl.h> 161 static int os_daemon(int nochdir, int noclose) 162 { 163 int devnull; 164 165 if (chdir("/") < 0) 166 return -1; 167 168 devnull = open("/dev/null", O_RDWR); 169 if (devnull < 0) 170 return -1; 171 172 if (dup2(devnull, STDIN_FILENO) < 0) { 173 close(devnull); 174 return -1; 175 } 176 177 if (dup2(devnull, STDOUT_FILENO) < 0) { 178 close(devnull); 179 return -1; 180 } 181 182 if (dup2(devnull, STDERR_FILENO) < 0) { 183 close(devnull); 184 return -1; 185 } 186 187 return 0; 188 } 189 #else /* __APPLE__ */ 190 #define os_daemon daemon 191 #endif /* __APPLE__ */ 192 193 194 int os_daemonize(const char *pid_file) 195 { 196 #if defined(__uClinux__) || defined(__sun__) 197 return -1; 198 #else /* defined(__uClinux__) || defined(__sun__) */ 199 if (os_daemon(0, 0)) { 200 perror("daemon"); 201 return -1; 202 } 203 204 if (pid_file) { 205 FILE *f = fopen(pid_file, "w"); 206 if (f) { 207 fprintf(f, "%u\n", getpid()); 208 fclose(f); 209 } 210 } 211 212 return -0; 213 #endif /* defined(__uClinux__) || defined(__sun__) */ 214 } 215 216 217 void os_daemonize_terminate(const char *pid_file) 218 { 219 if (pid_file) 220 unlink(pid_file); 221 } 222 223 224 int os_get_random(unsigned char *buf, size_t len) 225 { 226 FILE *f; 227 size_t rc; 228 229 f = fopen("/dev/urandom", "rb"); 230 if (f == NULL) { 231 printf("Could not open /dev/urandom.\n"); 232 return -1; 233 } 234 235 rc = fread(buf, 1, len, f); 236 fclose(f); 237 238 return rc != len ? -1 : 0; 239 } 240 241 242 unsigned long os_random(void) 243 { 244 return random(); 245 } 246 247 248 char * os_rel2abs_path(const char *rel_path) 249 { 250 char *buf = NULL, *cwd, *ret; 251 size_t len = 128, cwd_len, rel_len, ret_len; 252 int last_errno; 253 254 if (!rel_path) 255 return NULL; 256 257 if (rel_path[0] == '/') 258 return os_strdup(rel_path); 259 260 for (;;) { 261 buf = os_malloc(len); 262 if (buf == NULL) 263 return NULL; 264 cwd = getcwd(buf, len); 265 if (cwd == NULL) { 266 last_errno = errno; 267 os_free(buf); 268 if (last_errno != ERANGE) 269 return NULL; 270 len *= 2; 271 if (len > 2000) 272 return NULL; 273 } else { 274 buf[len - 1] = '\0'; 275 break; 276 } 277 } 278 279 cwd_len = os_strlen(cwd); 280 rel_len = os_strlen(rel_path); 281 ret_len = cwd_len + 1 + rel_len + 1; 282 ret = os_malloc(ret_len); 283 if (ret) { 284 os_memcpy(ret, cwd, cwd_len); 285 ret[cwd_len] = '/'; 286 os_memcpy(ret + cwd_len + 1, rel_path, rel_len); 287 ret[ret_len - 1] = '\0'; 288 } 289 os_free(buf); 290 return ret; 291 } 292 293 294 int os_program_init(void) 295 { 296 #ifdef ANDROID 297 /* 298 * We ignore errors here since errors are normal if we 299 * are already running as non-root. 300 */ 301 #ifdef ANDROID_SETGROUPS_OVERRIDE 302 gid_t groups[] = { ANDROID_SETGROUPS_OVERRIDE }; 303 #else /* ANDROID_SETGROUPS_OVERRIDE */ 304 gid_t groups[] = { AID_INET, AID_WIFI, AID_KEYSTORE }; 305 #endif /* ANDROID_SETGROUPS_OVERRIDE */ 306 struct __user_cap_header_struct header; 307 struct __user_cap_data_struct cap; 308 309 setgroups(ARRAY_SIZE(groups), groups); 310 311 prctl(PR_SET_KEEPCAPS, 1, 0, 0, 0); 312 313 setgid(AID_WIFI); 314 setuid(AID_WIFI); 315 316 header.version = _LINUX_CAPABILITY_VERSION; 317 header.pid = 0; 318 cap.effective = cap.permitted = 319 (1 << CAP_NET_ADMIN) | (1 << CAP_NET_RAW); 320 cap.inheritable = 0; 321 capset(&header, &cap); 322 #endif /* ANDROID */ 323 324 #ifdef WPA_TRACE 325 dl_list_init(&alloc_list); 326 #endif /* WPA_TRACE */ 327 return 0; 328 } 329 330 331 void os_program_deinit(void) 332 { 333 #ifdef WPA_TRACE 334 struct os_alloc_trace *a; 335 unsigned long total = 0; 336 dl_list_for_each(a, &alloc_list, struct os_alloc_trace, list) { 337 total += a->len; 338 if (a->magic != ALLOC_MAGIC) { 339 wpa_printf(MSG_INFO, "MEMLEAK[%p]: invalid magic 0x%x " 340 "len %lu", 341 a, a->magic, (unsigned long) a->len); 342 continue; 343 } 344 wpa_printf(MSG_INFO, "MEMLEAK[%p]: len %lu", 345 a, (unsigned long) a->len); 346 wpa_trace_dump("memleak", a); 347 } 348 if (total) 349 wpa_printf(MSG_INFO, "MEMLEAK: total %lu bytes", 350 (unsigned long) total); 351 #endif /* WPA_TRACE */ 352 } 353 354 355 int os_setenv(const char *name, const char *value, int overwrite) 356 { 357 return setenv(name, value, overwrite); 358 } 359 360 361 int os_unsetenv(const char *name) 362 { 363 #if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__APPLE__) || \ 364 defined(__OpenBSD__) 365 unsetenv(name); 366 return 0; 367 #else 368 return unsetenv(name); 369 #endif 370 } 371 372 373 char * os_readfile(const char *name, size_t *len) 374 { 375 FILE *f; 376 char *buf; 377 long pos; 378 379 f = fopen(name, "rb"); 380 if (f == NULL) 381 return NULL; 382 383 if (fseek(f, 0, SEEK_END) < 0 || (pos = ftell(f)) < 0) { 384 fclose(f); 385 return NULL; 386 } 387 *len = pos; 388 if (fseek(f, 0, SEEK_SET) < 0) { 389 fclose(f); 390 return NULL; 391 } 392 393 buf = os_malloc(*len); 394 if (buf == NULL) { 395 fclose(f); 396 return NULL; 397 } 398 399 if (fread(buf, 1, *len, f) != *len) { 400 fclose(f); 401 os_free(buf); 402 return NULL; 403 } 404 405 fclose(f); 406 407 return buf; 408 } 409 410 411 int os_file_exists(const char *fname) 412 { 413 FILE *f = fopen(fname, "rb"); 414 if (f == NULL) 415 return 0; 416 fclose(f); 417 return 1; 418 } 419 420 421 #ifndef WPA_TRACE 422 void * os_zalloc(size_t size) 423 { 424 return calloc(1, size); 425 } 426 #endif /* WPA_TRACE */ 427 428 429 size_t os_strlcpy(char *dest, const char *src, size_t siz) 430 { 431 const char *s = src; 432 size_t left = siz; 433 434 if (left) { 435 /* Copy string up to the maximum size of the dest buffer */ 436 while (--left != 0) { 437 if ((*dest++ = *s++) == '\0') 438 break; 439 } 440 } 441 442 if (left == 0) { 443 /* Not enough room for the string; force NUL-termination */ 444 if (siz != 0) 445 *dest = '\0'; 446 while (*s++) 447 ; /* determine total src string length */ 448 } 449 450 return s - src - 1; 451 } 452 453 454 int os_memcmp_const(const void *a, const void *b, size_t len) 455 { 456 const u8 *aa = a; 457 const u8 *bb = b; 458 size_t i; 459 u8 res; 460 461 for (res = 0, i = 0; i < len; i++) 462 res |= aa[i] ^ bb[i]; 463 464 return res; 465 } 466 467 468 #ifdef WPA_TRACE 469 470 void * os_malloc(size_t size) 471 { 472 struct os_alloc_trace *a; 473 a = malloc(sizeof(*a) + size); 474 if (a == NULL) 475 return NULL; 476 a->magic = ALLOC_MAGIC; 477 dl_list_add(&alloc_list, &a->list); 478 a->len = size; 479 wpa_trace_record(a); 480 return a + 1; 481 } 482 483 484 void * os_realloc(void *ptr, size_t size) 485 { 486 struct os_alloc_trace *a; 487 size_t copy_len; 488 void *n; 489 490 if (ptr == NULL) 491 return os_malloc(size); 492 493 a = (struct os_alloc_trace *) ptr - 1; 494 if (a->magic != ALLOC_MAGIC) { 495 wpa_printf(MSG_INFO, "REALLOC[%p]: invalid magic 0x%x%s", 496 a, a->magic, 497 a->magic == FREED_MAGIC ? " (already freed)" : ""); 498 wpa_trace_show("Invalid os_realloc() call"); 499 abort(); 500 } 501 n = os_malloc(size); 502 if (n == NULL) 503 return NULL; 504 copy_len = a->len; 505 if (copy_len > size) 506 copy_len = size; 507 os_memcpy(n, a + 1, copy_len); 508 os_free(ptr); 509 return n; 510 } 511 512 513 void os_free(void *ptr) 514 { 515 struct os_alloc_trace *a; 516 517 if (ptr == NULL) 518 return; 519 a = (struct os_alloc_trace *) ptr - 1; 520 if (a->magic != ALLOC_MAGIC) { 521 wpa_printf(MSG_INFO, "FREE[%p]: invalid magic 0x%x%s", 522 a, a->magic, 523 a->magic == FREED_MAGIC ? " (already freed)" : ""); 524 wpa_trace_show("Invalid os_free() call"); 525 abort(); 526 } 527 dl_list_del(&a->list); 528 a->magic = FREED_MAGIC; 529 530 wpa_trace_check_ref(ptr); 531 free(a); 532 } 533 534 535 void * os_zalloc(size_t size) 536 { 537 void *ptr = os_malloc(size); 538 if (ptr) 539 os_memset(ptr, 0, size); 540 return ptr; 541 } 542 543 544 char * os_strdup(const char *s) 545 { 546 size_t len; 547 char *d; 548 len = os_strlen(s); 549 d = os_malloc(len + 1); 550 if (d == NULL) 551 return NULL; 552 os_memcpy(d, s, len); 553 d[len] = '\0'; 554 return d; 555 } 556 557 #endif /* WPA_TRACE */ 558 559 560 int os_exec(const char *program, const char *arg, int wait_completion) 561 { 562 pid_t pid; 563 int pid_status; 564 565 pid = fork(); 566 if (pid < 0) { 567 perror("fork"); 568 return -1; 569 } 570 571 if (pid == 0) { 572 /* run the external command in the child process */ 573 const int MAX_ARG = 30; 574 char *_program, *_arg, *pos; 575 char *argv[MAX_ARG + 1]; 576 int i; 577 578 _program = os_strdup(program); 579 _arg = os_strdup(arg); 580 581 argv[0] = _program; 582 583 i = 1; 584 pos = _arg; 585 while (i < MAX_ARG && pos && *pos) { 586 while (*pos == ' ') 587 pos++; 588 if (*pos == '\0') 589 break; 590 argv[i++] = pos; 591 pos = os_strchr(pos, ' '); 592 if (pos) 593 *pos++ = '\0'; 594 } 595 argv[i] = NULL; 596 597 execv(program, argv); 598 perror("execv"); 599 os_free(_program); 600 os_free(_arg); 601 exit(0); 602 return -1; 603 } 604 605 if (wait_completion) { 606 /* wait for the child process to complete in the parent */ 607 waitpid(pid, &pid_status, 0); 608 } 609 610 return 0; 611 } 612
