]>
Commit | Line | Data |
---|---|---|
6fc6879b JM |
1 | /* |
2 | * wpa_supplicant/hostapd / Internal implementation of OS specific functions | |
3 | * Copyright (c) 2005-2006, Jouni Malinen <j@w1.fi> | |
4 | * | |
0f3d578e JM |
5 | * This software may be distributed under the terms of the BSD license. |
6 | * See README for more details. | |
6fc6879b JM |
7 | * |
8 | * This file is an example of operating system specific wrapper functions. | |
9 | * This version implements many of the functions internally, so it can be used | |
10 | * to fill in missing functions from the target system C libraries. | |
11 | * | |
12 | * Some of the functions are using standard C library calls in order to keep | |
13 | * this file in working condition to allow the functions to be tested on a | |
14 | * Linux target. Please note that OS_NO_C_LIB_DEFINES needs to be defined for | |
15 | * this file to work correctly. Note that these implementations are only | |
16 | * examples and are not optimized for speed. | |
17 | */ | |
18 | ||
19 | #include "includes.h" | |
20 | ||
21 | #undef OS_REJECT_C_LIB_FUNCTIONS | |
22 | #include "os.h" | |
23 | ||
24 | void os_sleep(os_time_t sec, os_time_t usec) | |
25 | { | |
26 | if (sec) | |
27 | sleep(sec); | |
28 | if (usec) | |
29 | usleep(usec); | |
30 | } | |
31 | ||
32 | ||
33 | int os_get_time(struct os_time *t) | |
34 | { | |
35 | int res; | |
36 | struct timeval tv; | |
37 | res = gettimeofday(&tv, NULL); | |
38 | t->sec = tv.tv_sec; | |
39 | t->usec = tv.tv_usec; | |
40 | return res; | |
41 | } | |
42 | ||
43 | ||
594516b4 JB |
44 | int os_get_reltime(struct os_reltime *t) |
45 | { | |
46 | int res; | |
47 | struct timeval tv; | |
48 | res = gettimeofday(&tv, NULL); | |
49 | t->sec = tv.tv_sec; | |
50 | t->usec = tv.tv_usec; | |
51 | return res; | |
52 | } | |
53 | ||
54 | ||
6fc6879b JM |
55 | int os_mktime(int year, int month, int day, int hour, int min, int sec, |
56 | os_time_t *t) | |
57 | { | |
58 | struct tm tm; | |
59 | ||
60 | if (year < 1970 || month < 1 || month > 12 || day < 1 || day > 31 || | |
61 | hour < 0 || hour > 23 || min < 0 || min > 59 || sec < 0 || | |
62 | sec > 60) | |
63 | return -1; | |
64 | ||
65 | os_memset(&tm, 0, sizeof(tm)); | |
66 | tm.tm_year = year - 1900; | |
67 | tm.tm_mon = month - 1; | |
68 | tm.tm_mday = day; | |
69 | tm.tm_hour = hour; | |
70 | tm.tm_min = min; | |
71 | tm.tm_sec = sec; | |
72 | ||
73 | *t = (os_time_t) mktime(&tm); | |
74 | return 0; | |
75 | } | |
76 | ||
77 | ||
96b2cb22 JM |
78 | int os_gmtime(os_time_t t, struct os_tm *tm) |
79 | { | |
96b2cb22 | 80 | struct tm *tm2; |
d5cbee41 | 81 | time_t t2 = t; |
96b2cb22 | 82 | |
d5cbee41 | 83 | tm2 = gmtime(&t2); |
96b2cb22 JM |
84 | if (tm2 == NULL) |
85 | return -1; | |
86 | tm->sec = tm2->tm_sec; | |
87 | tm->min = tm2->tm_min; | |
88 | tm->hour = tm2->tm_hour; | |
89 | tm->day = tm2->tm_mday; | |
90 | tm->month = tm2->tm_mon + 1; | |
91 | tm->year = tm2->tm_year + 1900; | |
92 | return 0; | |
93 | } | |
94 | ||
95 | ||
6fc6879b JM |
96 | int os_daemonize(const char *pid_file) |
97 | { | |
98 | if (daemon(0, 0)) { | |
99 | perror("daemon"); | |
100 | return -1; | |
101 | } | |
102 | ||
103 | if (pid_file) { | |
104 | FILE *f = fopen(pid_file, "w"); | |
105 | if (f) { | |
106 | fprintf(f, "%u\n", getpid()); | |
107 | fclose(f); | |
108 | } | |
109 | } | |
110 | ||
111 | return -0; | |
112 | } | |
113 | ||
114 | ||
115 | void os_daemonize_terminate(const char *pid_file) | |
116 | { | |
117 | if (pid_file) | |
118 | unlink(pid_file); | |
119 | } | |
120 | ||
121 | ||
122 | int os_get_random(unsigned char *buf, size_t len) | |
123 | { | |
124 | FILE *f; | |
125 | size_t rc; | |
126 | ||
127 | f = fopen("/dev/urandom", "rb"); | |
128 | if (f == NULL) { | |
129 | printf("Could not open /dev/urandom.\n"); | |
130 | return -1; | |
131 | } | |
132 | ||
133 | rc = fread(buf, 1, len, f); | |
134 | fclose(f); | |
135 | ||
136 | return rc != len ? -1 : 0; | |
137 | } | |
138 | ||
139 | ||
140 | unsigned long os_random(void) | |
141 | { | |
142 | return random(); | |
143 | } | |
144 | ||
145 | ||
146 | char * os_rel2abs_path(const char *rel_path) | |
147 | { | |
148 | char *buf = NULL, *cwd, *ret; | |
149 | size_t len = 128, cwd_len, rel_len, ret_len; | |
150 | ||
151 | if (rel_path[0] == '/') | |
152 | return os_strdup(rel_path); | |
153 | ||
154 | for (;;) { | |
155 | buf = os_malloc(len); | |
156 | if (buf == NULL) | |
157 | return NULL; | |
158 | cwd = getcwd(buf, len); | |
159 | if (cwd == NULL) { | |
160 | os_free(buf); | |
161 | if (errno != ERANGE) { | |
162 | return NULL; | |
163 | } | |
164 | len *= 2; | |
165 | } else { | |
166 | break; | |
167 | } | |
168 | } | |
169 | ||
170 | cwd_len = strlen(cwd); | |
171 | rel_len = strlen(rel_path); | |
172 | ret_len = cwd_len + 1 + rel_len + 1; | |
173 | ret = os_malloc(ret_len); | |
174 | if (ret) { | |
175 | os_memcpy(ret, cwd, cwd_len); | |
176 | ret[cwd_len] = '/'; | |
177 | os_memcpy(ret + cwd_len + 1, rel_path, rel_len); | |
178 | ret[ret_len - 1] = '\0'; | |
179 | } | |
180 | os_free(buf); | |
181 | return ret; | |
182 | } | |
183 | ||
184 | ||
185 | int os_program_init(void) | |
186 | { | |
187 | return 0; | |
188 | } | |
189 | ||
190 | ||
191 | void os_program_deinit(void) | |
192 | { | |
193 | } | |
194 | ||
195 | ||
196 | int os_setenv(const char *name, const char *value, int overwrite) | |
197 | { | |
198 | return setenv(name, value, overwrite); | |
199 | } | |
200 | ||
201 | ||
202 | int os_unsetenv(const char *name) | |
203 | { | |
204 | #if defined(__FreeBSD__) || defined(__NetBSD__) | |
205 | unsetenv(name); | |
206 | return 0; | |
207 | #else | |
208 | return unsetenv(name); | |
209 | #endif | |
210 | } | |
211 | ||
212 | ||
213 | char * os_readfile(const char *name, size_t *len) | |
214 | { | |
215 | FILE *f; | |
216 | char *buf; | |
217 | ||
218 | f = fopen(name, "rb"); | |
219 | if (f == NULL) | |
220 | return NULL; | |
221 | ||
222 | fseek(f, 0, SEEK_END); | |
223 | *len = ftell(f); | |
224 | fseek(f, 0, SEEK_SET); | |
225 | ||
226 | buf = os_malloc(*len); | |
227 | if (buf == NULL) { | |
228 | fclose(f); | |
229 | return NULL; | |
230 | } | |
231 | ||
a698d284 JM |
232 | if (fread(buf, 1, *len, f) != *len) { |
233 | fclose(f); | |
234 | os_free(buf); | |
235 | return NULL; | |
236 | } | |
237 | ||
6fc6879b JM |
238 | fclose(f); |
239 | ||
240 | return buf; | |
241 | } | |
242 | ||
243 | ||
244 | void * os_zalloc(size_t size) | |
245 | { | |
246 | void *n = os_malloc(size); | |
247 | if (n) | |
248 | os_memset(n, 0, size); | |
249 | return n; | |
250 | } | |
251 | ||
252 | ||
253 | void * os_malloc(size_t size) | |
254 | { | |
255 | return malloc(size); | |
256 | } | |
257 | ||
258 | ||
259 | void * os_realloc(void *ptr, size_t size) | |
260 | { | |
261 | return realloc(ptr, size); | |
262 | } | |
263 | ||
264 | ||
265 | void os_free(void *ptr) | |
266 | { | |
267 | free(ptr); | |
268 | } | |
269 | ||
270 | ||
271 | void * os_memcpy(void *dest, const void *src, size_t n) | |
272 | { | |
273 | char *d = dest; | |
274 | const char *s = src; | |
275 | while (n--) | |
276 | *d++ = *s++; | |
277 | return dest; | |
278 | } | |
279 | ||
280 | ||
281 | void * os_memmove(void *dest, const void *src, size_t n) | |
282 | { | |
283 | if (dest < src) | |
284 | os_memcpy(dest, src, n); | |
285 | else { | |
286 | /* overlapping areas */ | |
287 | char *d = (char *) dest + n; | |
288 | const char *s = (const char *) src + n; | |
289 | while (n--) | |
290 | *--d = *--s; | |
291 | } | |
292 | return dest; | |
293 | } | |
294 | ||
295 | ||
296 | void * os_memset(void *s, int c, size_t n) | |
297 | { | |
298 | char *p = s; | |
299 | while (n--) | |
300 | *p++ = c; | |
301 | return s; | |
302 | } | |
303 | ||
304 | ||
305 | int os_memcmp(const void *s1, const void *s2, size_t n) | |
306 | { | |
307 | const unsigned char *p1 = s1, *p2 = s2; | |
308 | ||
309 | if (n == 0) | |
310 | return 0; | |
311 | ||
312 | while (*p1 == *p2) { | |
313 | p1++; | |
314 | p2++; | |
315 | n--; | |
316 | if (n == 0) | |
317 | return 0; | |
318 | } | |
319 | ||
320 | return *p1 - *p2; | |
321 | } | |
322 | ||
323 | ||
324 | char * os_strdup(const char *s) | |
325 | { | |
326 | char *res; | |
327 | size_t len; | |
328 | if (s == NULL) | |
329 | return NULL; | |
330 | len = os_strlen(s); | |
331 | res = os_malloc(len + 1); | |
332 | if (res) | |
333 | os_memcpy(res, s, len + 1); | |
334 | return res; | |
335 | } | |
336 | ||
337 | ||
338 | size_t os_strlen(const char *s) | |
339 | { | |
340 | const char *p = s; | |
341 | while (*p) | |
342 | p++; | |
343 | return p - s; | |
344 | } | |
345 | ||
346 | ||
347 | int os_strcasecmp(const char *s1, const char *s2) | |
348 | { | |
349 | /* | |
350 | * Ignoring case is not required for main functionality, so just use | |
351 | * the case sensitive version of the function. | |
352 | */ | |
353 | return os_strcmp(s1, s2); | |
354 | } | |
355 | ||
356 | ||
357 | int os_strncasecmp(const char *s1, const char *s2, size_t n) | |
358 | { | |
359 | /* | |
360 | * Ignoring case is not required for main functionality, so just use | |
361 | * the case sensitive version of the function. | |
362 | */ | |
363 | return os_strncmp(s1, s2, n); | |
364 | } | |
365 | ||
366 | ||
367 | char * os_strchr(const char *s, int c) | |
368 | { | |
369 | while (*s) { | |
370 | if (*s == c) | |
371 | return (char *) s; | |
372 | s++; | |
373 | } | |
374 | return NULL; | |
375 | } | |
376 | ||
377 | ||
378 | char * os_strrchr(const char *s, int c) | |
379 | { | |
380 | const char *p = s; | |
381 | while (*p) | |
382 | p++; | |
383 | p--; | |
384 | while (p >= s) { | |
385 | if (*p == c) | |
386 | return (char *) p; | |
387 | p--; | |
388 | } | |
389 | return NULL; | |
390 | } | |
391 | ||
392 | ||
393 | int os_strcmp(const char *s1, const char *s2) | |
394 | { | |
395 | while (*s1 == *s2) { | |
396 | if (*s1 == '\0') | |
397 | break; | |
398 | s1++; | |
399 | s2++; | |
400 | } | |
401 | ||
402 | return *s1 - *s2; | |
403 | } | |
404 | ||
405 | ||
406 | int os_strncmp(const char *s1, const char *s2, size_t n) | |
407 | { | |
408 | if (n == 0) | |
409 | return 0; | |
410 | ||
411 | while (*s1 == *s2) { | |
412 | if (*s1 == '\0') | |
413 | break; | |
414 | s1++; | |
415 | s2++; | |
416 | n--; | |
417 | if (n == 0) | |
418 | return 0; | |
419 | } | |
420 | ||
421 | return *s1 - *s2; | |
422 | } | |
423 | ||
424 | ||
425 | char * os_strncpy(char *dest, const char *src, size_t n) | |
426 | { | |
427 | char *d = dest; | |
428 | ||
429 | while (n--) { | |
430 | *d = *src; | |
431 | if (*src == '\0') | |
432 | break; | |
433 | d++; | |
434 | src++; | |
435 | } | |
436 | ||
437 | return dest; | |
438 | } | |
439 | ||
440 | ||
441 | size_t os_strlcpy(char *dest, const char *src, size_t siz) | |
442 | { | |
443 | const char *s = src; | |
444 | size_t left = siz; | |
445 | ||
446 | if (left) { | |
447 | /* Copy string up to the maximum size of the dest buffer */ | |
448 | while (--left != 0) { | |
449 | if ((*dest++ = *s++) == '\0') | |
450 | break; | |
451 | } | |
452 | } | |
453 | ||
454 | if (left == 0) { | |
455 | /* Not enough room for the string; force NUL-termination */ | |
456 | if (siz != 0) | |
457 | *dest = '\0'; | |
458 | while (*s++) | |
459 | ; /* determine total src string length */ | |
460 | } | |
461 | ||
462 | return s - src - 1; | |
463 | } | |
464 | ||
465 | ||
466 | char * os_strstr(const char *haystack, const char *needle) | |
467 | { | |
468 | size_t len = os_strlen(needle); | |
469 | while (*haystack) { | |
470 | if (os_strncmp(haystack, needle, len) == 0) | |
471 | return (char *) haystack; | |
472 | haystack++; | |
473 | } | |
474 | ||
475 | return NULL; | |
476 | } | |
477 | ||
478 | ||
479 | int os_snprintf(char *str, size_t size, const char *format, ...) | |
480 | { | |
481 | va_list ap; | |
482 | int ret; | |
483 | ||
484 | /* See http://www.ijs.si/software/snprintf/ for portable | |
485 | * implementation of snprintf. | |
486 | */ | |
487 | ||
488 | va_start(ap, format); | |
489 | ret = vsnprintf(str, size, format, ap); | |
490 | va_end(ap); | |
491 | if (size > 0) | |
492 | str[size - 1] = '\0'; | |
493 | return ret; | |
494 | } |