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