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