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