contrib/hostapd/os_internal.c

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