← Back to branch summary

~ubuntu-branches/ubuntu/hardy/wpasupplicant/hardy

« back to all changes in this revision

Viewing changes to os_internal.c

  • Committer: Bazaar Package Importer
  • Author(s): Reinhard Tartler, Alexander Sack
  • Date: 2007-08-26 16:06:57 UTC
  • mfrom: (1.1.9 upstream)
  • Revision ID: james.westby@ubuntu.com-20070826160657-2m8pxoweuxe8f93t
Tags: 0.6.0+0.5.8-0ubuntu1
https://launchpad.net/bugs/140763
https://launchpad.net/bugs/141233
* New upstream release
* remove patch 11_erroneous_manpage_ref, applied upstream
* remove patch 25_wpas_dbus_unregister_iface_fix, applied upstream

[ Alexander Sack ]
* bumping upstream version to replace development version 0.6.0 with
  this package from stable release branch.
* attempt to fix wierd timeout and high latency issues by going
  back to stable upstream version (0.5.9) (LP: #140763,
  LP: #141233).

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
}