contrib/hostapd/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 int os_daemonize(const char *pid_file)
  80 {
  81         if (daemon(0, 0)) {
  82                 perror("daemon");
  83                 return -1;
  84         }
  85
  86         if (pid_file) {
  87                 FILE *f = fopen(pid_file, "w");
  88                 if (f) {
  89                         fprintf(f, "%u\n", getpid());
  90                         fclose(f);
  91                 }
  92         }
  93
  94         return -0;
  95 }
  96
  97
  98 void os_daemonize_terminate(const char *pid_file)
  99 {
 100         if (pid_file)
 101                 unlink(pid_file);
 102 }
 103
 104
 105 int os_get_random(unsigned char *buf, size_t len)
 106 {
 107         FILE *f;
 108         size_t rc;
 109
 110         f = fopen("/dev/urandom", "rb");
 111         if (f == NULL) {
 112                 printf("Could not open /dev/urandom.\n");
 113                 return -1;
 114         }
 115
 116         rc = fread(buf, 1, len, f);
 117         fclose(f);
 118
 119         return rc != len ? -1 : 0;
 120 }
 121
 122
 123 unsigned long os_random(void)
 124 {
 125         return random();
 126 }
 127
 128
 129 char * os_rel2abs_path(const char *rel_path)
 130 {
 131         char *buf = NULL, *cwd, *ret;
 132         size_t len = 128, cwd_len, rel_len, ret_len;
 133         int last_errno;
 134
 135         if (rel_path[0] == '/')
 136                 return strdup(rel_path);
 137
 138         for (;;) {
 139                 buf = malloc(len);
 140                 if (buf == NULL)
 141                         return NULL;
 142                 cwd = getcwd(buf, len);
 143                 if (cwd == NULL) {
 144                         last_errno = errno;
 145                         free(buf);
 146                         if (last_errno != ERANGE)
 147                                 return NULL;
 148                         len *= 2;
 149                         if (len > 2000)
 150                                 return NULL;
 151                 } else {
 152                         buf[len - 1] = '\0';
 153                         break;
 154                 }
 155         }
 156
 157         cwd_len = strlen(cwd);
 158         rel_len = strlen(rel_path);
 159         ret_len = cwd_len + 1 + rel_len + 1;
 160         ret = malloc(ret_len);
 161         if (ret) {
 162                 memcpy(ret, cwd, cwd_len);
 163                 ret[cwd_len] = '/';
 164                 memcpy(ret + cwd_len + 1, rel_path, rel_len);
 165                 ret[ret_len - 1] = '\0';
 166         }
 167         free(buf);
 168         return ret;
 169 }
 170
 171
 172 int os_program_init(void)
 173 {
 174         return 0;
 175 }
 176
 177
 178 void os_program_deinit(void)
 179 {
 180 }
 181
 182
 183 int os_setenv(const char *name, const char *value, int overwrite)
 184 {
 185         return setenv(name, value, overwrite);
 186 }
 187
 188
 189 int os_unsetenv(const char *name)
 190 {
 191 #if defined(__FreeBSD__) || defined(__NetBSD__)
 192         unsetenv(name);
 193         return 0;
 194 #else
 195         return unsetenv(name);
 196 #endif
 197 }
 198
 199
 200 char * os_readfile(const char *name, size_t *len)
 201 {
 202         FILE *f;
 203         char *buf;
 204
 205         f = fopen(name, "rb");
 206         if (f == NULL)
 207                 return NULL;
 208
 209         fseek(f, 0, SEEK_END);
 210         *len = ftell(f);
 211         fseek(f, 0, SEEK_SET);
 212
 213         buf = malloc(*len);
 214         if (buf == NULL) {
 215                 fclose(f);
 216                 return NULL;
 217         }
 218
 219         fread(buf, 1, *len, f);
 220         fclose(f);
 221
 222         return buf;
 223 }
 224
 225
 226 void * os_zalloc(size_t size)
 227 {
 228         return calloc(1, size);
 229 }