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;
  43
  44         if (year < 1970 || month < 1 || month > 12 || day < 1 || day > 31 ||
  45             hour < 0 || hour > 23 || min < 0 || min > 59 || sec < 0 ||
  46             sec > 60)
  47                 return -1;
  48
  49         memset(&tm, 0, sizeof(tm));
  50         tm.tm_year = year - 1900;
  51         tm.tm_mon = month - 1;
  52         tm.tm_mday = day;
  53         tm.tm_hour = hour;
  54         tm.tm_min = min;
  55         tm.tm_sec = sec;
  56
  57         *t = (os_time_t) mktime(&tm);
  58         return 0;
  59 }
  60
  61
  62 int os_daemonize(const char *pid_file)
  63 {
  64         if (daemon(0, 0)) {
  65                 perror("daemon");
  66                 return -1;
  67         }
  68
  69         if (pid_file) {
  70                 FILE *f = fopen(pid_file, "w");
  71                 if (f) {
  72                         fprintf(f, "%u\n", getpid());
  73                         fclose(f);
  74                 }
  75         }
  76
  77         return -0;
  78 }
  79
  80
  81 void os_daemonize_terminate(const char *pid_file)
  82 {
  83         if (pid_file)
  84                 unlink(pid_file);
  85 }
  86
  87
  88 int os_get_random(unsigned char *buf, size_t len)
  89 {
  90         FILE *f;
  91         size_t rc;
  92
  93         f = fopen("/dev/urandom", "rb");
  94         if (f == NULL) {
  95                 printf("Could not open /dev/urandom.\n");
  96                 return -1;
  97         }
  98
  99         rc = fread(buf, 1, len, f);
 100         fclose(f);
 101
 102         return rc != len ? -1 : 0;
 103 }
 104
 105
 106 unsigned long os_random(void)
 107 {
 108         return random();
 109 }
 110
 111
 112 char * os_rel2abs_path(const char *rel_path)
 113 {
 114         char *buf = NULL, *cwd, *ret;
 115         size_t len = 128, cwd_len, rel_len, ret_len;
 116         int last_errno;
 117
 118         if (rel_path[0] == '/')
 119                 return strdup(rel_path);
 120
 121         for (;;) {
 122                 buf = malloc(len);
 123                 if (buf == NULL)
 124                         return NULL;
 125                 cwd = getcwd(buf, len);
 126                 if (cwd == NULL) {
 127                         last_errno = errno;
 128                         free(buf);
 129                         if (last_errno != ERANGE)
 130                                 return NULL;
 131                         len *= 2;
 132                         if (len > 2000)
 133                                 return NULL;
 134                 } else {
 135                         buf[len - 1] = '\0';
 136                         break;
 137                 }
 138         }
 139
 140         cwd_len = strlen(cwd);
 141         rel_len = strlen(rel_path);
 142         ret_len = cwd_len + 1 + rel_len + 1;
 143         ret = malloc(ret_len);
 144         if (ret) {
 145                 memcpy(ret, cwd, cwd_len);
 146                 ret[cwd_len] = '/';
 147                 memcpy(ret + cwd_len + 1, rel_path, rel_len);
 148                 ret[ret_len - 1] = '\0';
 149         }
 150         free(buf);
 151         return ret;
 152 }
 153
 154
 155 int os_program_init(void)
 156 {
 157         return 0;
 158 }
 159
 160
 161 void os_program_deinit(void)
 162 {
 163 }
 164
 165
 166 int os_setenv(const char *name, const char *value, int overwrite)
 167 {
 168         return setenv(name, value, overwrite);
 169 }
 170
 171
 172 int os_unsetenv(const char *name)
 173 {
 174 #if defined(__FreeBSD__) || defined(__NetBSD__)
 175         unsetenv(name);
 176         return 0;
 177 #else
 178         return unsetenv(name);
 179 #endif
 180 }
 181
 182
 183 char * os_readfile(const char *name, size_t *len)
 184 {
 185         FILE *f;
 186         char *buf;
 187
 188         f = fopen(name, "rb");
 189         if (f == NULL)
 190                 return NULL;
 191
 192         fseek(f, 0, SEEK_END);
 193         *len = ftell(f);
 194         fseek(f, 0, SEEK_SET);
 195
 196         buf = malloc(*len);
 197         if (buf == NULL) {
 198                 fclose(f);
 199                 return NULL;
 200         }
 201
 202         fread(buf, 1, *len, f);
 203         fclose(f);
 204
 205         return buf;
 206 }
 207
 208
 209 void * os_zalloc(size_t size)
 210 {
 211         return calloc(1, size);
 212 }