18dbcf02cSchristos /*
28dbcf02cSchristos * wpa_supplicant/hostapd / Internal implementation of OS specific functions
38dbcf02cSchristos * Copyright (c) 2005-2006, Jouni Malinen <j@w1.fi>
48dbcf02cSchristos *
562a52023Schristos * This software may be distributed under the terms of the BSD license.
662a52023Schristos * See README for more details.
78dbcf02cSchristos *
88dbcf02cSchristos * This file is an example of operating system specific wrapper functions.
98dbcf02cSchristos * This version implements many of the functions internally, so it can be used
108dbcf02cSchristos * to fill in missing functions from the target system C libraries.
118dbcf02cSchristos *
128dbcf02cSchristos * Some of the functions are using standard C library calls in order to keep
138dbcf02cSchristos * this file in working condition to allow the functions to be tested on a
148dbcf02cSchristos * Linux target. Please note that OS_NO_C_LIB_DEFINES needs to be defined for
158dbcf02cSchristos * this file to work correctly. Note that these implementations are only
168dbcf02cSchristos * examples and are not optimized for speed.
178dbcf02cSchristos */
188dbcf02cSchristos
198dbcf02cSchristos #include "includes.h"
209a53cbbeSchristos #include <time.h>
219a53cbbeSchristos #include <sys/wait.h>
228dbcf02cSchristos
238dbcf02cSchristos #undef OS_REJECT_C_LIB_FUNCTIONS
249a53cbbeSchristos #include "common.h"
258dbcf02cSchristos
os_sleep(os_time_t sec,os_time_t usec)268dbcf02cSchristos void os_sleep(os_time_t sec, os_time_t usec)
278dbcf02cSchristos {
288dbcf02cSchristos if (sec)
298dbcf02cSchristos sleep(sec);
308dbcf02cSchristos if (usec)
318dbcf02cSchristos usleep(usec);
328dbcf02cSchristos }
338dbcf02cSchristos
348dbcf02cSchristos
os_get_time(struct os_time * t)358dbcf02cSchristos int os_get_time(struct os_time *t)
368dbcf02cSchristos {
378dbcf02cSchristos int res;
388dbcf02cSchristos struct timeval tv;
398dbcf02cSchristos res = gettimeofday(&tv, NULL);
408dbcf02cSchristos t->sec = tv.tv_sec;
418dbcf02cSchristos t->usec = tv.tv_usec;
428dbcf02cSchristos return res;
438dbcf02cSchristos }
448dbcf02cSchristos
458dbcf02cSchristos
os_get_reltime(struct os_reltime * t)4636d97821Schristos int os_get_reltime(struct os_reltime *t)
4736d97821Schristos {
4836d97821Schristos int res;
4936d97821Schristos struct timeval tv;
5036d97821Schristos res = gettimeofday(&tv, NULL);
5136d97821Schristos t->sec = tv.tv_sec;
5236d97821Schristos t->usec = tv.tv_usec;
5336d97821Schristos return res;
5436d97821Schristos }
5536d97821Schristos
5636d97821Schristos
os_mktime(int year,int month,int day,int hour,int min,int sec,os_time_t * t)578dbcf02cSchristos int os_mktime(int year, int month, int day, int hour, int min, int sec,
588dbcf02cSchristos os_time_t *t)
598dbcf02cSchristos {
608dbcf02cSchristos struct tm tm;
618dbcf02cSchristos
628dbcf02cSchristos if (year < 1970 || month < 1 || month > 12 || day < 1 || day > 31 ||
638dbcf02cSchristos hour < 0 || hour > 23 || min < 0 || min > 59 || sec < 0 ||
648dbcf02cSchristos sec > 60)
658dbcf02cSchristos return -1;
668dbcf02cSchristos
678dbcf02cSchristos os_memset(&tm, 0, sizeof(tm));
688dbcf02cSchristos tm.tm_year = year - 1900;
698dbcf02cSchristos tm.tm_mon = month - 1;
708dbcf02cSchristos tm.tm_mday = day;
718dbcf02cSchristos tm.tm_hour = hour;
728dbcf02cSchristos tm.tm_min = min;
738dbcf02cSchristos tm.tm_sec = sec;
748dbcf02cSchristos
758dbcf02cSchristos *t = (os_time_t) mktime(&tm);
768dbcf02cSchristos return 0;
778dbcf02cSchristos }
788dbcf02cSchristos
798dbcf02cSchristos
os_gmtime(os_time_t t,struct os_tm * tm)8042669be3Schristos int os_gmtime(os_time_t t, struct os_tm *tm)
8142669be3Schristos {
8242669be3Schristos struct tm *tm2;
8342669be3Schristos time_t t2 = t;
8442669be3Schristos
8542669be3Schristos tm2 = gmtime(&t2);
8642669be3Schristos if (tm2 == NULL)
8742669be3Schristos return -1;
8842669be3Schristos tm->sec = tm2->tm_sec;
8942669be3Schristos tm->min = tm2->tm_min;
9042669be3Schristos tm->hour = tm2->tm_hour;
9142669be3Schristos tm->day = tm2->tm_mday;
9242669be3Schristos tm->month = tm2->tm_mon + 1;
9342669be3Schristos tm->year = tm2->tm_year + 1900;
9442669be3Schristos return 0;
9542669be3Schristos }
9642669be3Schristos
9742669be3Schristos
os_daemonize(const char * pid_file)988dbcf02cSchristos int os_daemonize(const char *pid_file)
998dbcf02cSchristos {
1008dbcf02cSchristos if (daemon(0, 0)) {
1019a53cbbeSchristos wpa_printf(MSG_ERROR, "daemon: %s", strerror(errno));
1028dbcf02cSchristos return -1;
1038dbcf02cSchristos }
1048dbcf02cSchristos
1058dbcf02cSchristos if (pid_file) {
1068dbcf02cSchristos FILE *f = fopen(pid_file, "w");
1078dbcf02cSchristos if (f) {
1088dbcf02cSchristos fprintf(f, "%u\n", getpid());
1098dbcf02cSchristos fclose(f);
1108dbcf02cSchristos }
1118dbcf02cSchristos }
1128dbcf02cSchristos
1138dbcf02cSchristos return -0;
1148dbcf02cSchristos }
1158dbcf02cSchristos
1168dbcf02cSchristos
os_daemonize_terminate(const char * pid_file)1178dbcf02cSchristos void os_daemonize_terminate(const char *pid_file)
1188dbcf02cSchristos {
1198dbcf02cSchristos if (pid_file)
1208dbcf02cSchristos unlink(pid_file);
1218dbcf02cSchristos }
1228dbcf02cSchristos
1238dbcf02cSchristos
os_get_random(unsigned char * buf,size_t len)1248dbcf02cSchristos int os_get_random(unsigned char *buf, size_t len)
1258dbcf02cSchristos {
1268dbcf02cSchristos FILE *f;
1278dbcf02cSchristos size_t rc;
1288dbcf02cSchristos
1298dbcf02cSchristos f = fopen("/dev/urandom", "rb");
1308dbcf02cSchristos if (f == NULL) {
1318dbcf02cSchristos printf("Could not open /dev/urandom.\n");
1328dbcf02cSchristos return -1;
1338dbcf02cSchristos }
1348dbcf02cSchristos
1358dbcf02cSchristos rc = fread(buf, 1, len, f);
1368dbcf02cSchristos fclose(f);
1378dbcf02cSchristos
1388dbcf02cSchristos return rc != len ? -1 : 0;
1398dbcf02cSchristos }
1408dbcf02cSchristos
1418dbcf02cSchristos
os_random(void)1428dbcf02cSchristos unsigned long os_random(void)
1438dbcf02cSchristos {
1448dbcf02cSchristos return random();
1458dbcf02cSchristos }
1468dbcf02cSchristos
1478dbcf02cSchristos
os_rel2abs_path(const char * rel_path)1488dbcf02cSchristos char * os_rel2abs_path(const char *rel_path)
1498dbcf02cSchristos {
1508dbcf02cSchristos char *buf = NULL, *cwd, *ret;
1518dbcf02cSchristos size_t len = 128, cwd_len, rel_len, ret_len;
1528dbcf02cSchristos
1538dbcf02cSchristos if (rel_path[0] == '/')
1548dbcf02cSchristos return os_strdup(rel_path);
1558dbcf02cSchristos
1568dbcf02cSchristos for (;;) {
1578dbcf02cSchristos buf = os_malloc(len);
1588dbcf02cSchristos if (buf == NULL)
1598dbcf02cSchristos return NULL;
1608dbcf02cSchristos cwd = getcwd(buf, len);
1618dbcf02cSchristos if (cwd == NULL) {
1628dbcf02cSchristos os_free(buf);
1638dbcf02cSchristos if (errno != ERANGE) {
1648dbcf02cSchristos return NULL;
1658dbcf02cSchristos }
1668dbcf02cSchristos len *= 2;
1678dbcf02cSchristos } else {
1688dbcf02cSchristos break;
1698dbcf02cSchristos }
1708dbcf02cSchristos }
1718dbcf02cSchristos
1729a53cbbeSchristos cwd_len = os_strlen(cwd);
1739a53cbbeSchristos rel_len = os_strlen(rel_path);
1748dbcf02cSchristos ret_len = cwd_len + 1 + rel_len + 1;
1758dbcf02cSchristos ret = os_malloc(ret_len);
1768dbcf02cSchristos if (ret) {
1778dbcf02cSchristos os_memcpy(ret, cwd, cwd_len);
1788dbcf02cSchristos ret[cwd_len] = '/';
1798dbcf02cSchristos os_memcpy(ret + cwd_len + 1, rel_path, rel_len);
1808dbcf02cSchristos ret[ret_len - 1] = '\0';
1818dbcf02cSchristos }
1828dbcf02cSchristos os_free(buf);
1838dbcf02cSchristos return ret;
1848dbcf02cSchristos }
1858dbcf02cSchristos
1868dbcf02cSchristos
os_program_init(void)1878dbcf02cSchristos int os_program_init(void)
1888dbcf02cSchristos {
1898dbcf02cSchristos return 0;
1908dbcf02cSchristos }
1918dbcf02cSchristos
1928dbcf02cSchristos
os_program_deinit(void)1938dbcf02cSchristos void os_program_deinit(void)
1948dbcf02cSchristos {
1958dbcf02cSchristos }
1968dbcf02cSchristos
1978dbcf02cSchristos
os_setenv(const char * name,const char * value,int overwrite)1988dbcf02cSchristos int os_setenv(const char *name, const char *value, int overwrite)
1998dbcf02cSchristos {
2008dbcf02cSchristos return setenv(name, value, overwrite);
2018dbcf02cSchristos }
2028dbcf02cSchristos
2038dbcf02cSchristos
os_unsetenv(const char * name)2048dbcf02cSchristos int os_unsetenv(const char *name)
2058dbcf02cSchristos {
2068dbcf02cSchristos #if defined(__FreeBSD__) || defined(__NetBSD__)
2078dbcf02cSchristos unsetenv(name);
2088dbcf02cSchristos return 0;
2098dbcf02cSchristos #else
2108dbcf02cSchristos return unsetenv(name);
2118dbcf02cSchristos #endif
2128dbcf02cSchristos }
2138dbcf02cSchristos
2148dbcf02cSchristos
os_readfile(const char * name,size_t * len)2158dbcf02cSchristos char * os_readfile(const char *name, size_t *len)
2168dbcf02cSchristos {
2178dbcf02cSchristos FILE *f;
2188dbcf02cSchristos char *buf;
2198dbcf02cSchristos
2208dbcf02cSchristos f = fopen(name, "rb");
2218dbcf02cSchristos if (f == NULL)
2228dbcf02cSchristos return NULL;
2238dbcf02cSchristos
2248dbcf02cSchristos fseek(f, 0, SEEK_END);
2258dbcf02cSchristos *len = ftell(f);
2268dbcf02cSchristos fseek(f, 0, SEEK_SET);
2278dbcf02cSchristos
2288dbcf02cSchristos buf = os_malloc(*len);
2298dbcf02cSchristos if (buf == NULL) {
2308dbcf02cSchristos fclose(f);
2318dbcf02cSchristos return NULL;
2328dbcf02cSchristos }
2338dbcf02cSchristos
2348dbcf02cSchristos if (fread(buf, 1, *len, f) != *len) {
2358dbcf02cSchristos fclose(f);
2368dbcf02cSchristos os_free(buf);
2378dbcf02cSchristos return NULL;
2388dbcf02cSchristos }
2398dbcf02cSchristos
2408dbcf02cSchristos fclose(f);
2418dbcf02cSchristos
2428dbcf02cSchristos return buf;
2438dbcf02cSchristos }
2448dbcf02cSchristos
2458dbcf02cSchristos
os_fdatasync(FILE * stream)246*928750b6Schristos int os_fdatasync(FILE *stream)
247*928750b6Schristos {
248*928750b6Schristos return 0;
249*928750b6Schristos }
250*928750b6Schristos
251*928750b6Schristos
os_zalloc(size_t size)2528dbcf02cSchristos void * os_zalloc(size_t size)
2538dbcf02cSchristos {
2548dbcf02cSchristos void *n = os_malloc(size);
2558dbcf02cSchristos if (n)
2568dbcf02cSchristos os_memset(n, 0, size);
2578dbcf02cSchristos return n;
2588dbcf02cSchristos }
2598dbcf02cSchristos
2608dbcf02cSchristos
os_malloc(size_t size)2618dbcf02cSchristos void * os_malloc(size_t size)
2628dbcf02cSchristos {
2638dbcf02cSchristos return malloc(size);
2648dbcf02cSchristos }
2658dbcf02cSchristos
2668dbcf02cSchristos
os_realloc(void * ptr,size_t size)2678dbcf02cSchristos void * os_realloc(void *ptr, size_t size)
2688dbcf02cSchristos {
2698dbcf02cSchristos return realloc(ptr, size);
2708dbcf02cSchristos }
2718dbcf02cSchristos
2728dbcf02cSchristos
os_free(void * ptr)2738dbcf02cSchristos void os_free(void *ptr)
2748dbcf02cSchristos {
2758dbcf02cSchristos free(ptr);
2768dbcf02cSchristos }
2778dbcf02cSchristos
2788dbcf02cSchristos
os_memcpy(void * dest,const void * src,size_t n)2798dbcf02cSchristos void * os_memcpy(void *dest, const void *src, size_t n)
2808dbcf02cSchristos {
2818dbcf02cSchristos char *d = dest;
2828dbcf02cSchristos const char *s = src;
2838dbcf02cSchristos while (n--)
2848dbcf02cSchristos *d++ = *s++;
2858dbcf02cSchristos return dest;
2868dbcf02cSchristos }
2878dbcf02cSchristos
2888dbcf02cSchristos
os_memmove(void * dest,const void * src,size_t n)2898dbcf02cSchristos void * os_memmove(void *dest, const void *src, size_t n)
2908dbcf02cSchristos {
2918dbcf02cSchristos if (dest < src)
2928dbcf02cSchristos os_memcpy(dest, src, n);
2938dbcf02cSchristos else {
2948dbcf02cSchristos /* overlapping areas */
2958dbcf02cSchristos char *d = (char *) dest + n;
2968dbcf02cSchristos const char *s = (const char *) src + n;
2978dbcf02cSchristos while (n--)
2988dbcf02cSchristos *--d = *--s;
2998dbcf02cSchristos }
3008dbcf02cSchristos return dest;
3018dbcf02cSchristos }
3028dbcf02cSchristos
3038dbcf02cSchristos
os_memset(void * s,int c,size_t n)3048dbcf02cSchristos void * os_memset(void *s, int c, size_t n)
3058dbcf02cSchristos {
3068dbcf02cSchristos char *p = s;
3078dbcf02cSchristos while (n--)
3088dbcf02cSchristos *p++ = c;
3098dbcf02cSchristos return s;
3108dbcf02cSchristos }
3118dbcf02cSchristos
3128dbcf02cSchristos
os_memcmp(const void * s1,const void * s2,size_t n)3138dbcf02cSchristos int os_memcmp(const void *s1, const void *s2, size_t n)
3148dbcf02cSchristos {
3158dbcf02cSchristos const unsigned char *p1 = s1, *p2 = s2;
3168dbcf02cSchristos
3178dbcf02cSchristos if (n == 0)
3188dbcf02cSchristos return 0;
3198dbcf02cSchristos
3208dbcf02cSchristos while (*p1 == *p2) {
3218dbcf02cSchristos p1++;
3228dbcf02cSchristos p2++;
3238dbcf02cSchristos n--;
3248dbcf02cSchristos if (n == 0)
3258dbcf02cSchristos return 0;
3268dbcf02cSchristos }
3278dbcf02cSchristos
3288dbcf02cSchristos return *p1 - *p2;
3298dbcf02cSchristos }
3308dbcf02cSchristos
3318dbcf02cSchristos
os_strdup(const char * s)3328dbcf02cSchristos char * os_strdup(const char *s)
3338dbcf02cSchristos {
3348dbcf02cSchristos char *res;
3358dbcf02cSchristos size_t len;
3368dbcf02cSchristos if (s == NULL)
3378dbcf02cSchristos return NULL;
3388dbcf02cSchristos len = os_strlen(s);
3398dbcf02cSchristos res = os_malloc(len + 1);
3408dbcf02cSchristos if (res)
3418dbcf02cSchristos os_memcpy(res, s, len + 1);
3428dbcf02cSchristos return res;
3438dbcf02cSchristos }
3448dbcf02cSchristos
3458dbcf02cSchristos
os_strlen(const char * s)3468dbcf02cSchristos size_t os_strlen(const char *s)
3478dbcf02cSchristos {
3488dbcf02cSchristos const char *p = s;
3498dbcf02cSchristos while (*p)
3508dbcf02cSchristos p++;
3518dbcf02cSchristos return p - s;
3528dbcf02cSchristos }
3538dbcf02cSchristos
3548dbcf02cSchristos
os_strcasecmp(const char * s1,const char * s2)3558dbcf02cSchristos int os_strcasecmp(const char *s1, const char *s2)
3568dbcf02cSchristos {
3578dbcf02cSchristos /*
3588dbcf02cSchristos * Ignoring case is not required for main functionality, so just use
3598dbcf02cSchristos * the case sensitive version of the function.
3608dbcf02cSchristos */
3618dbcf02cSchristos return os_strcmp(s1, s2);
3628dbcf02cSchristos }
3638dbcf02cSchristos
3648dbcf02cSchristos
os_strncasecmp(const char * s1,const char * s2,size_t n)3658dbcf02cSchristos int os_strncasecmp(const char *s1, const char *s2, size_t n)
3668dbcf02cSchristos {
3678dbcf02cSchristos /*
3688dbcf02cSchristos * Ignoring case is not required for main functionality, so just use
3698dbcf02cSchristos * the case sensitive version of the function.
3708dbcf02cSchristos */
3718dbcf02cSchristos return os_strncmp(s1, s2, n);
3728dbcf02cSchristos }
3738dbcf02cSchristos
3748dbcf02cSchristos
os_strchr(const char * s,int c)3758dbcf02cSchristos char * os_strchr(const char *s, int c)
3768dbcf02cSchristos {
3778dbcf02cSchristos while (*s) {
3788dbcf02cSchristos if (*s == c)
3798dbcf02cSchristos return (char *) s;
3808dbcf02cSchristos s++;
3818dbcf02cSchristos }
3828dbcf02cSchristos return NULL;
3838dbcf02cSchristos }
3848dbcf02cSchristos
3858dbcf02cSchristos
os_strrchr(const char * s,int c)3868dbcf02cSchristos char * os_strrchr(const char *s, int c)
3878dbcf02cSchristos {
3888dbcf02cSchristos const char *p = s;
3898dbcf02cSchristos while (*p)
3908dbcf02cSchristos p++;
3918dbcf02cSchristos p--;
3928dbcf02cSchristos while (p >= s) {
3938dbcf02cSchristos if (*p == c)
3948dbcf02cSchristos return (char *) p;
3958dbcf02cSchristos p--;
3968dbcf02cSchristos }
3978dbcf02cSchristos return NULL;
3988dbcf02cSchristos }
3998dbcf02cSchristos
4008dbcf02cSchristos
os_strcmp(const char * s1,const char * s2)4018dbcf02cSchristos int os_strcmp(const char *s1, const char *s2)
4028dbcf02cSchristos {
4038dbcf02cSchristos while (*s1 == *s2) {
4048dbcf02cSchristos if (*s1 == '\0')
4058dbcf02cSchristos break;
4068dbcf02cSchristos s1++;
4078dbcf02cSchristos s2++;
4088dbcf02cSchristos }
4098dbcf02cSchristos
4108dbcf02cSchristos return *s1 - *s2;
4118dbcf02cSchristos }
4128dbcf02cSchristos
4138dbcf02cSchristos
os_strncmp(const char * s1,const char * s2,size_t n)4148dbcf02cSchristos int os_strncmp(const char *s1, const char *s2, size_t n)
4158dbcf02cSchristos {
4168dbcf02cSchristos if (n == 0)
4178dbcf02cSchristos return 0;
4188dbcf02cSchristos
4198dbcf02cSchristos while (*s1 == *s2) {
4208dbcf02cSchristos if (*s1 == '\0')
4218dbcf02cSchristos break;
4228dbcf02cSchristos s1++;
4238dbcf02cSchristos s2++;
4248dbcf02cSchristos n--;
4258dbcf02cSchristos if (n == 0)
4268dbcf02cSchristos return 0;
4278dbcf02cSchristos }
4288dbcf02cSchristos
4298dbcf02cSchristos return *s1 - *s2;
4308dbcf02cSchristos }
4318dbcf02cSchristos
4328dbcf02cSchristos
os_strlcpy(char * dest,const char * src,size_t siz)4338dbcf02cSchristos size_t os_strlcpy(char *dest, const char *src, size_t siz)
4348dbcf02cSchristos {
4358dbcf02cSchristos const char *s = src;
4368dbcf02cSchristos size_t left = siz;
4378dbcf02cSchristos
4388dbcf02cSchristos if (left) {
4398dbcf02cSchristos /* Copy string up to the maximum size of the dest buffer */
4408dbcf02cSchristos while (--left != 0) {
4418dbcf02cSchristos if ((*dest++ = *s++) == '\0')
4428dbcf02cSchristos break;
4438dbcf02cSchristos }
4448dbcf02cSchristos }
4458dbcf02cSchristos
4468dbcf02cSchristos if (left == 0) {
4478dbcf02cSchristos /* Not enough room for the string; force NUL-termination */
4488dbcf02cSchristos if (siz != 0)
4498dbcf02cSchristos *dest = '\0';
4508dbcf02cSchristos while (*s++)
4518dbcf02cSchristos ; /* determine total src string length */
4528dbcf02cSchristos }
4538dbcf02cSchristos
4548dbcf02cSchristos return s - src - 1;
4558dbcf02cSchristos }
4568dbcf02cSchristos
4578dbcf02cSchristos
os_memcmp_const(const void * a,const void * b,size_t len)45836d97821Schristos int os_memcmp_const(const void *a, const void *b, size_t len)
45936d97821Schristos {
46036d97821Schristos const u8 *aa = a;
46136d97821Schristos const u8 *bb = b;
46236d97821Schristos size_t i;
46336d97821Schristos u8 res;
46436d97821Schristos
46536d97821Schristos for (res = 0, i = 0; i < len; i++)
46636d97821Schristos res |= aa[i] ^ bb[i];
46736d97821Schristos
46836d97821Schristos return res;
46936d97821Schristos }
47036d97821Schristos
47136d97821Schristos
os_strstr(const char * haystack,const char * needle)4728dbcf02cSchristos char * os_strstr(const char *haystack, const char *needle)
4738dbcf02cSchristos {
4748dbcf02cSchristos size_t len = os_strlen(needle);
4758dbcf02cSchristos while (*haystack) {
4768dbcf02cSchristos if (os_strncmp(haystack, needle, len) == 0)
4778dbcf02cSchristos return (char *) haystack;
4788dbcf02cSchristos haystack++;
4798dbcf02cSchristos }
4808dbcf02cSchristos
4818dbcf02cSchristos return NULL;
4828dbcf02cSchristos }
4838dbcf02cSchristos
4848dbcf02cSchristos
os_snprintf(char * str,size_t size,const char * format,...)4858dbcf02cSchristos int os_snprintf(char *str, size_t size, const char *format, ...)
4868dbcf02cSchristos {
4878dbcf02cSchristos va_list ap;
4888dbcf02cSchristos int ret;
4898dbcf02cSchristos
4908dbcf02cSchristos /* See http://www.ijs.si/software/snprintf/ for portable
4918dbcf02cSchristos * implementation of snprintf.
4928dbcf02cSchristos */
4938dbcf02cSchristos
4948dbcf02cSchristos va_start(ap, format);
4958dbcf02cSchristos ret = vsnprintf(str, size, format, ap);
4968dbcf02cSchristos va_end(ap);
4978dbcf02cSchristos if (size > 0)
4988dbcf02cSchristos str[size - 1] = '\0';
4998dbcf02cSchristos return ret;
5008dbcf02cSchristos }
5019a53cbbeSchristos
5029a53cbbeSchristos
os_exec(const char * program,const char * arg,int wait_completion)5039a53cbbeSchristos int os_exec(const char *program, const char *arg, int wait_completion)
5049a53cbbeSchristos {
5059a53cbbeSchristos pid_t pid;
5069a53cbbeSchristos int pid_status;
5079a53cbbeSchristos
5089a53cbbeSchristos pid = fork();
5099a53cbbeSchristos if (pid < 0) {
5109a53cbbeSchristos wpa_printf(MSG_ERROR, "fork: %s", strerror(errno));
5119a53cbbeSchristos return -1;
5129a53cbbeSchristos }
5139a53cbbeSchristos
5149a53cbbeSchristos if (pid == 0) {
5159a53cbbeSchristos /* run the external command in the child process */
5169a53cbbeSchristos const int MAX_ARG = 30;
5179a53cbbeSchristos char *_program, *_arg, *pos;
5189a53cbbeSchristos char *argv[MAX_ARG + 1];
5199a53cbbeSchristos int i;
5209a53cbbeSchristos
5219a53cbbeSchristos _program = os_strdup(program);
5229a53cbbeSchristos _arg = os_strdup(arg);
5239a53cbbeSchristos
5249a53cbbeSchristos argv[0] = _program;
5259a53cbbeSchristos
5269a53cbbeSchristos i = 1;
5279a53cbbeSchristos pos = _arg;
5289a53cbbeSchristos while (i < MAX_ARG && pos && *pos) {
5299a53cbbeSchristos while (*pos == ' ')
5309a53cbbeSchristos pos++;
5319a53cbbeSchristos if (*pos == '\0')
5329a53cbbeSchristos break;
5339a53cbbeSchristos argv[i++] = pos;
5349a53cbbeSchristos pos = os_strchr(pos, ' ');
5359a53cbbeSchristos if (pos)
5369a53cbbeSchristos *pos++ = '\0';
5379a53cbbeSchristos }
5389a53cbbeSchristos argv[i] = NULL;
5399a53cbbeSchristos
5409a53cbbeSchristos execv(program, argv);
5419a53cbbeSchristos wpa_printf(MSG_ERROR, "execv: %s", strerror(errno));
5429a53cbbeSchristos os_free(_program);
5439a53cbbeSchristos os_free(_arg);
5449a53cbbeSchristos exit(0);
5459a53cbbeSchristos return -1;
5469a53cbbeSchristos }
5479a53cbbeSchristos
5489a53cbbeSchristos if (wait_completion) {
5499a53cbbeSchristos /* wait for the child process to complete in the parent */
5509a53cbbeSchristos waitpid(pid, &pid_status, 0);
5519a53cbbeSchristos }
5529a53cbbeSchristos
5539a53cbbeSchristos return 0;
5549a53cbbeSchristos }
555