contrib/wpa/src/utils/os_unix.c

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