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
13 #ifdef ANDROID
14 #include <sys/capability.h>
15 #include <linux/prctl.h>
16 #include <private/android_filesystem_config.h>
17 #endif /* ANDROID */
18
19 #include "os.h"
20
21 #ifdef WPA_TRACE
22
23 #include "common.h"
24 #include "wpa_debug.h"
25 #include "trace.h"
26 #include "list.h"
27
28 static struct dl_list alloc_list;
29
30 #define ALLOC_MAGIC 0xa84ef1b2
31 #define FREED_MAGIC 0x67fd487a
32
33 struct os_alloc_trace {
34 unsigned int magic;
35 struct dl_list list;
36 size_t len;
37 WPA_TRACE_INFO
38 };
39
40 #endif /* WPA_TRACE */
41
42
os_sleep(os_time_t sec,os_time_t usec)43 void os_sleep(os_time_t sec, os_time_t usec)
44 {
45 if (sec)
46 sleep(sec);
47 if (usec)
48 usleep(usec);
49 }
50
51
os_get_time(struct os_time * t)52 int os_get_time(struct os_time *t)
53 {
54 int res;
55 struct timeval tv;
56 res = gettimeofday(&tv, NULL);
57 t->sec = tv.tv_sec;
58 t->usec = tv.tv_usec;
59 return res;
60 }
61
62
os_mktime(int year,int month,int day,int hour,int min,int sec,os_time_t * t)63 int os_mktime(int year, int month, int day, int hour, int min, int sec,
64 os_time_t *t)
65 {
66 struct tm tm, *tm1;
67 time_t t_local, t1, t2;
68 os_time_t tz_offset;
69
70 if (year < 1970 || month < 1 || month > 12 || day < 1 || day > 31 ||
71 hour < 0 || hour > 23 || min < 0 || min > 59 || sec < 0 ||
72 sec > 60)
73 return -1;
74
75 memset(&tm, 0, sizeof(tm));
76 tm.tm_year = year - 1900;
77 tm.tm_mon = month - 1;
78 tm.tm_mday = day;
79 tm.tm_hour = hour;
80 tm.tm_min = min;
81 tm.tm_sec = sec;
82
83 t_local = mktime(&tm);
84
85 /* figure out offset to UTC */
86 tm1 = localtime(&t_local);
87 if (tm1) {
88 t1 = mktime(tm1);
89 tm1 = gmtime(&t_local);
90 if (tm1) {
91 t2 = mktime(tm1);
92 tz_offset = t2 - t1;
93 } else
94 tz_offset = 0;
95 } else
96 tz_offset = 0;
97
98 *t = (os_time_t) t_local - tz_offset;
99 return 0;
100 }
101
102
os_gmtime(os_time_t t,struct os_tm * tm)103 int os_gmtime(os_time_t t, struct os_tm *tm)
104 {
105 struct tm *tm2;
106 time_t t2 = t;
107
108 tm2 = gmtime(&t2);
109 if (tm2 == NULL)
110 return -1;
111 tm->sec = tm2->tm_sec;
112 tm->min = tm2->tm_min;
113 tm->hour = tm2->tm_hour;
114 tm->day = tm2->tm_mday;
115 tm->month = tm2->tm_mon + 1;
116 tm->year = tm2->tm_year + 1900;
117 return 0;
118 }
119
120
121 #ifdef __APPLE__
122 #include <fcntl.h>
os_daemon(int nochdir,int noclose)123 static int os_daemon(int nochdir, int noclose)
124 {
125 int devnull;
126
127 if (chdir("/") < 0)
128 return -1;
129
130 devnull = open("/dev/null", O_RDWR);
131 if (devnull < 0)
132 return -1;
133
134 if (dup2(devnull, STDIN_FILENO) < 0) {
135 close(devnull);
136 return -1;
137 }
138
139 if (dup2(devnull, STDOUT_FILENO) < 0) {
140 close(devnull);
141 return -1;
142 }
143
144 if (dup2(devnull, STDERR_FILENO) < 0) {
145 close(devnull);
146 return -1;
147 }
148
149 return 0;
150 }
151 #else /* __APPLE__ */
152 #define os_daemon daemon
153 #endif /* __APPLE__ */
154
155
os_daemonize(const char * pid_file)156 int os_daemonize(const char *pid_file)
157 {
158 #if defined(__uClinux__) || defined(__sun__)
159 return -1;
160 #else /* defined(__uClinux__) || defined(__sun__) */
161 if (os_daemon(0, 0)) {
162 perror("daemon");
163 return -1;
164 }
165
166 if (pid_file) {
167 FILE *f = fopen(pid_file, "w");
168 if (f) {
169 fprintf(f, "%u\n", getpid());
170 fclose(f);
171 }
172 }
173
174 return -0;
175 #endif /* defined(__uClinux__) || defined(__sun__) */
176 }
177
178
os_daemonize_terminate(const char * pid_file)179 void os_daemonize_terminate(const char *pid_file)
180 {
181 if (pid_file)
182 unlink(pid_file);
183 }
184
185
os_get_random(unsigned char * buf,size_t len)186 int os_get_random(unsigned char *buf, size_t len)
187 {
188 FILE *f;
189 size_t rc;
190
191 f = fopen("/dev/urandom", "rb");
192 if (f == NULL) {
193 printf("Could not open /dev/urandom.\n");
194 return -1;
195 }
196
197 rc = fread(buf, 1, len, f);
198 fclose(f);
199
200 return rc != len ? -1 : 0;
201 }
202
203
os_random(void)204 unsigned long os_random(void)
205 {
206 return random();
207 }
208
209
os_rel2abs_path(const char * rel_path)210 char * os_rel2abs_path(const char *rel_path)
211 {
212 char *buf = NULL, *cwd, *ret;
213 size_t len = 128, cwd_len, rel_len, ret_len;
214 int last_errno;
215
216 if (!rel_path)
217 return NULL;
218
219 if (rel_path[0] == '/')
220 return os_strdup(rel_path);
221
222 for (;;) {
223 buf = os_malloc(len);
224 if (buf == NULL)
225 return NULL;
226 cwd = getcwd(buf, len);
227 if (cwd == NULL) {
228 last_errno = errno;
229 os_free(buf);
230 if (last_errno != ERANGE)
231 return NULL;
232 len *= 2;
233 if (len > 2000)
234 return NULL;
235 } else {
236 buf[len - 1] = '\0';
237 break;
238 }
239 }
240
241 cwd_len = os_strlen(cwd);
242 rel_len = os_strlen(rel_path);
243 ret_len = cwd_len + 1 + rel_len + 1;
244 ret = os_malloc(ret_len);
245 if (ret) {
246 os_memcpy(ret, cwd, cwd_len);
247 ret[cwd_len] = '/';
248 os_memcpy(ret + cwd_len + 1, rel_path, rel_len);
249 ret[ret_len - 1] = '\0';
250 }
251 os_free(buf);
252 return ret;
253 }
254
255
os_program_init(void)256 int os_program_init(void)
257 {
258 #ifdef ANDROID
259 /*
260 * We ignore errors here since errors are normal if we
261 * are already running as non-root.
262 */
263 #ifdef ANDROID_SETGROUPS_OVERRIDE
264 gid_t groups[] = { ANDROID_SETGROUPS_OVERRIDE };
265 #else /* ANDROID_SETGROUPS_OVERRIDE */
266 gid_t groups[] = { AID_INET, AID_WIFI, AID_KEYSTORE };
267 #endif /* ANDROID_SETGROUPS_OVERRIDE */
268 struct __user_cap_header_struct header;
269 struct __user_cap_data_struct cap;
270
271 setgroups(sizeof(groups)/sizeof(groups[0]), groups);
272
273 prctl(PR_SET_KEEPCAPS, 1, 0, 0, 0);
274
275 setgid(AID_WIFI);
276 setuid(AID_WIFI);
277
278 header.version = _LINUX_CAPABILITY_VERSION;
279 header.pid = 0;
280 cap.effective = cap.permitted =
281 (1 << CAP_NET_ADMIN) | (1 << CAP_NET_RAW);
282 cap.inheritable = 0;
283 capset(&header, &cap);
284 #endif /* ANDROID */
285
286 #ifdef WPA_TRACE
287 dl_list_init(&alloc_list);
288 #endif /* WPA_TRACE */
289 return 0;
290 }
291
292
os_program_deinit(void)293 void os_program_deinit(void)
294 {
295 #ifdef WPA_TRACE
296 struct os_alloc_trace *a;
297 unsigned long total = 0;
298 dl_list_for_each(a, &alloc_list, struct os_alloc_trace, list) {
299 total += a->len;
300 if (a->magic != ALLOC_MAGIC) {
301 wpa_printf(MSG_INFO, "MEMLEAK[%p]: invalid magic 0x%x "
302 "len %lu",
303 a, a->magic, (unsigned long) a->len);
304 continue;
305 }
306 wpa_printf(MSG_INFO, "MEMLEAK[%p]: len %lu",
307 a, (unsigned long) a->len);
308 wpa_trace_dump("memleak", a);
309 }
310 if (total)
311 wpa_printf(MSG_INFO, "MEMLEAK: total %lu bytes",
312 (unsigned long) total);
313 #endif /* WPA_TRACE */
314 }
315
316
os_setenv(const char * name,const char * value,int overwrite)317 int os_setenv(const char *name, const char *value, int overwrite)
318 {
319 return setenv(name, value, overwrite);
320 }
321
322
os_unsetenv(const char * name)323 int os_unsetenv(const char *name)
324 {
325 #if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__APPLE__) || \
326 defined(__OpenBSD__)
327 unsetenv(name);
328 return 0;
329 #else
330 return unsetenv(name);
331 #endif
332 }
333
334
os_readfile(const char * name,size_t * len)335 char * os_readfile(const char *name, size_t *len)
336 {
337 FILE *f;
338 char *buf;
339 long pos;
340
341 f = fopen(name, "rb");
342 if (f == NULL)
343 return NULL;
344
345 if (fseek(f, 0, SEEK_END) < 0 || (pos = ftell(f)) < 0) {
346 fclose(f);
347 return NULL;
348 }
349 *len = pos;
350 if (fseek(f, 0, SEEK_SET) < 0) {
351 fclose(f);
352 return NULL;
353 }
354
355 buf = os_malloc(*len);
356 if (buf == NULL) {
357 fclose(f);
358 return NULL;
359 }
360
361 if (fread(buf, 1, *len, f) != *len) {
362 fclose(f);
363 os_free(buf);
364 return NULL;
365 }
366
367 fclose(f);
368
369 return buf;
370 }
371
372
373 #ifndef WPA_TRACE
os_zalloc(size_t size)374 void * os_zalloc(size_t size)
375 {
376 return calloc(1, size);
377 }
378 #endif /* WPA_TRACE */
379
380
os_strlcpy(char * dest,const char * src,size_t siz)381 size_t os_strlcpy(char *dest, const char *src, size_t siz)
382 {
383 const char *s = src;
384 size_t left = siz;
385
386 if (left) {
387 /* Copy string up to the maximum size of the dest buffer */
388 while (--left != 0) {
389 if ((*dest++ = *s++) == '\0')
390 break;
391 }
392 }
393
394 if (left == 0) {
395 /* Not enough room for the string; force NUL-termination */
396 if (siz != 0)
397 *dest = '\0';
398 while (*s++)
399 ; /* determine total src string length */
400 }
401
402 return s - src - 1;
403 }
404
405
406 #ifdef WPA_TRACE
407
os_malloc(size_t size)408 void * os_malloc(size_t size)
409 {
410 struct os_alloc_trace *a;
411 a = malloc(sizeof(*a) + size);
412 if (a == NULL)
413 return NULL;
414 a->magic = ALLOC_MAGIC;
415 dl_list_add(&alloc_list, &a->list);
416 a->len = size;
417 wpa_trace_record(a);
418 return a + 1;
419 }
420
421
os_realloc(void * ptr,size_t size)422 void * os_realloc(void *ptr, size_t size)
423 {
424 struct os_alloc_trace *a;
425 size_t copy_len;
426 void *n;
427
428 if (ptr == NULL)
429 return os_malloc(size);
430
431 a = (struct os_alloc_trace *) ptr - 1;
432 if (a->magic != ALLOC_MAGIC) {
433 wpa_printf(MSG_INFO, "REALLOC[%p]: invalid magic 0x%x%s",
434 a, a->magic,
435 a->magic == FREED_MAGIC ? " (already freed)" : "");
436 wpa_trace_show("Invalid os_realloc() call");
437 abort();
438 }
439 n = os_malloc(size);
440 if (n == NULL)
441 return NULL;
442 copy_len = a->len;
443 if (copy_len > size)
444 copy_len = size;
445 os_memcpy(n, a + 1, copy_len);
446 os_free(ptr);
447 return n;
448 }
449
450
os_free(void * ptr)451 void os_free(void *ptr)
452 {
453 struct os_alloc_trace *a;
454
455 if (ptr == NULL)
456 return;
457 a = (struct os_alloc_trace *) ptr - 1;
458 if (a->magic != ALLOC_MAGIC) {
459 wpa_printf(MSG_INFO, "FREE[%p]: invalid magic 0x%x%s",
460 a, a->magic,
461 a->magic == FREED_MAGIC ? " (already freed)" : "");
462 wpa_trace_show("Invalid os_free() call");
463 abort();
464 }
465 dl_list_del(&a->list);
466 a->magic = FREED_MAGIC;
467
468 wpa_trace_check_ref(ptr);
469 free(a);
470 }
471
472
os_zalloc(size_t size)473 void * os_zalloc(size_t size)
474 {
475 void *ptr = os_malloc(size);
476 if (ptr)
477 os_memset(ptr, 0, size);
478 return ptr;
479 }
480
481
os_strdup(const char * s)482 char * os_strdup(const char *s)
483 {
484 size_t len;
485 char *d;
486 len = os_strlen(s);
487 d = os_malloc(len + 1);
488 if (d == NULL)
489 return NULL;
490 os_memcpy(d, s, len);
491 d[len] = '\0';
492 return d;
493 }
494
495 #endif /* WPA_TRACE */
496