contrib/hostapd/src/utils/os_unix.c

   1 /*
   2  * wpa_supplicant/hostapd / OS specific functions for UNIX/POSIX systems
   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
  15 #include "includes.h"
  16
  17 #include "os.h"
  18
  19 void os_sleep(os_time_t sec, os_time_t usec)
  20 {
  21         if (sec)
  22                 sleep(sec);
  23         if (usec)
  24                 usleep(usec);
  25 }
  26
  27
  28 int os_get_time(struct os_time *t)
  29 {
  30         int res;
  31         struct timeval tv;
  32         res = gettimeofday(&tv, NULL);
  33         t->sec = tv.tv_sec;
  34         t->usec = tv.tv_usec;
  35         return res;
  36 }
  37
  38
  39 int os_mktime(int year, int month, int day, int hour, int min, int sec,
  40               os_time_t *t)
  41 {
  42         struct tm tm, *tm1;
  43         time_t t_local, t1, t2;
  44         os_time_t tz_offset;
  45
  46         if (year < 1970 || month < 1 || month > 12 || day < 1 || day > 31 ||
  47             hour < 0 || hour > 23 || min < 0 || min > 59 || sec < 0 ||
  48             sec > 60)
  49                 return -1;
  50
  51         memset(&tm, 0, sizeof(tm));
  52         tm.tm_year = year - 1900;
  53         tm.tm_mon = month - 1;
  54         tm.tm_mday = day;
  55         tm.tm_hour = hour;
  56         tm.tm_min = min;
  57         tm.tm_sec = sec;
  58
  59         t_local = mktime(&tm);
  60
  61         /* figure out offset to UTC */
  62         tm1 = localtime(&t_local);
  63         if (tm1) {
  64                 t1 = mktime(tm1);
  65                 tm1 = gmtime(&t_local);
  66                 if (tm1) {
  67                         t2 = mktime(tm1);
  68                         tz_offset = t2 - t1;
  69                 } else
  70                         tz_offset = 0;
  71         } else
  72                 tz_offset = 0;
  73
  74         *t = (os_time_t) t_local - tz_offset;
  75         return 0;
  76 }
  77
  78
  79 #ifdef __APPLE__
  80 #include <fcntl.h>
  81 static int os_daemon(int nochdir, int noclose)
  82 {
  83         int devnull;
  84
  85         if (chdir("/") < 0)
  86                 return -1;
  87
  88         devnull = open("/dev/null", O_RDWR);
  89         if (devnull < 0)
  90                 return -1;
  91
  92         if (dup2(devnull, STDIN_FILENO) < 0) {
  93                 close(devnull);
  94                 return -1;
  95         }
  96
  97         if (dup2(devnull, STDOUT_FILENO) < 0) {
  98                 close(devnull);
  99                 return -1;
 100         }
 101
 102         if (dup2(devnull, STDERR_FILENO) < 0) {
 103                 close(devnull);
 104                 return -1;
 105         }
 106
 107         return 0;
 108 }
 109 #else /* __APPLE__ */
 110 #define os_daemon daemon
 111 #endif /* __APPLE__ */
 112
 113
 114 int os_daemonize(const char *pid_file)
 115 {
 116 #ifdef __uClinux__
 117         return -1;
 118 #else /* __uClinux__ */
 119         if (os_daemon(0, 0)) {
 120                 perror("daemon");
 121                 return -1;
 122         }
 123
 124         if (pid_file) {
 125                 FILE *f = fopen(pid_file, "w");
 126                 if (f) {
 127                         fprintf(f, "%u\n", getpid());
 128                         fclose(f);
 129                 }
 130         }
 131
 132         return -0;
 133 #endif /* __uClinux__ */
 134 }
 135
 136
 137 void os_daemonize_terminate(const char *pid_file)
 138 {
 139         if (pid_file)
 140                 unlink(pid_file);
 141 }
 142
 143
 144 int os_get_random(unsigned char *buf, size_t len)
 145 {
 146         FILE *f;
 147         size_t rc;
 148
 149         f = fopen("/dev/urandom", "rb");
 150         if (f == NULL) {
 151                 printf("Could not open /dev/urandom.\n");
 152                 return -1;
 153         }
 154
 155         rc = fread(buf, 1, len, f);
 156         fclose(f);
 157
 158         return rc != len ? -1 : 0;
 159 }
 160
 161
 162 unsigned long os_random(void)
 163 {
 164         return random();
 165 }
 166
 167
 168 char * os_rel2abs_path(const char *rel_path)
 169 {
 170         char *buf = NULL, *cwd, *ret;
 171         size_t len = 128, cwd_len, rel_len, ret_len;
 172         int last_errno;
 173
 174         if (rel_path[0] == '/')
 175                 return strdup(rel_path);
 176
 177         for (;;) {
 178                 buf = malloc(len);
 179                 if (buf == NULL)
 180                         return NULL;
 181                 cwd = getcwd(buf, len);
 182                 if (cwd == NULL) {
 183                         last_errno = errno;
 184                         free(buf);
 185                         if (last_errno != ERANGE)
 186                                 return NULL;
 187                         len *= 2;
 188                         if (len > 2000)
 189                                 return NULL;
 190                 } else {
 191                         buf[len - 1] = '\0';
 192                         break;
 193                 }
 194         }
 195
 196         cwd_len = strlen(cwd);
 197         rel_len = strlen(rel_path);
 198         ret_len = cwd_len + 1 + rel_len + 1;
 199         ret = malloc(ret_len);
 200         if (ret) {
 201                 memcpy(ret, cwd, cwd_len);
 202                 ret[cwd_len] = '/';
 203                 memcpy(ret + cwd_len + 1, rel_path, rel_len);
 204                 ret[ret_len - 1] = '\0';
 205         }
 206         free(buf);
 207         return ret;
 208 }
 209
 210
 211 int os_program_init(void)
 212 {
 213         return 0;
 214 }
 215
 216
 217 void os_program_deinit(void)
 218 {
 219 }
 220
 221
 222 int os_setenv(const char *name, const char *value, int overwrite)
 223 {
 224         return setenv(name, value, overwrite);
 225 }
 226
 227
 228 int os_unsetenv(const char *name)
 229 {
 230 #if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__APPLE__) || \
 231     defined(__OpenBSD__)
 232         unsetenv(name);
 233         return 0;
 234 #else
 235         return unsetenv(name);
 236 #endif
 237 }
 238
 239
 240 char * os_readfile(const char *name, size_t *len)
 241 {
 242         FILE *f;
 243         char *buf;
 244
 245         f = fopen(name, "rb");
 246         if (f == NULL)
 247                 return NULL;
 248
 249         fseek(f, 0, SEEK_END);
 250         *len = ftell(f);
 251         fseek(f, 0, SEEK_SET);
 252
 253         buf = malloc(*len);
 254         if (buf == NULL) {
 255                 fclose(f);
 256                 return NULL;
 257         }
 258
 259         if (fread(buf, 1, *len, f) != *len) {
 260                 fclose(f);
 261                 free(buf);
 262                 return NULL;
 263         }
 264
 265         fclose(f);
 266
 267         return buf;
 268 }
 269
 270
 271 void * os_zalloc(size_t size)
 272 {
 273         return calloc(1, size);
 274 }
 275
 276
 277 size_t os_strlcpy(char *dest, const char *src, size_t siz)
 278 {
 279         const char *s = src;
 280         size_t left = siz;
 281
 282         if (left) {
 283                 /* Copy string up to the maximum size of the dest buffer */
 284                 while (--left != 0) {
 285                         if ((*dest++ = *s++) == '\0')
 286                                 break;
 287                 }
 288         }
 289
 290         if (left == 0) {
 291                 /* Not enough room for the string; force NUL-termination */
 292                 if (siz != 0)
 293                         *dest = '\0';
 294                 while (*s++)
 295                         ; /* determine total src string length */
 296         }
 297
 298         return s - src - 1;
 299 }