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 #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
os_sleep(os_time_t sec,os_time_t usec)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
os_get_time(struct os_time * t)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
os_get_reltime(struct os_reltime * t)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
os_mktime(int year,int month,int day,int hour,int min,int sec,os_time_t * t)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
os_gmtime(os_time_t t,struct os_tm * tm)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>
os_daemon(int nochdir,int noclose)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
os_daemonize(const char * pid_file)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
os_daemonize_terminate(const char * pid_file)217 void os_daemonize_terminate(const char *pid_file)
218 {
219 if (pid_file)
220 unlink(pid_file);
221 }
222
223
os_get_random(unsigned char * buf,size_t len)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
os_random(void)242 unsigned long os_random(void)
243 {
244 return random();
245 }
246
247
os_rel2abs_path(const char * rel_path)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
os_program_init(void)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
os_program_deinit(void)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
os_setenv(const char * name,const char * value,int overwrite)355 int os_setenv(const char *name, const char *value, int overwrite)
356 {
357 return setenv(name, value, overwrite);
358 }
359
360
os_unsetenv(const char * name)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
os_readfile(const char * name,size_t * len)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
os_file_exists(const char * fname)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
os_zalloc(size_t size)422 void * os_zalloc(size_t size)
423 {
424 return calloc(1, size);
425 }
426 #endif /* WPA_TRACE */
427
428
os_strlcpy(char * dest,const char * src,size_t siz)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
os_memcmp_const(const void * a,const void * b,size_t len)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
os_malloc(size_t size)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
os_realloc(void * ptr,size_t size)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
os_free(void * ptr)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
os_zalloc(size_t size)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
os_strdup(const char * s)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
os_exec(const char * program,const char * arg,int wait_completion)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