← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/wpasupplicant/gutsy

« back to all changes in this revision

Viewing changes to src/utils/common.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:
src/utils/common.c
1
 
/*
2
 
 * wpa_supplicant/hostapd / common helper functions, etc.
3
 
 * Copyright (c) 2002-2007, 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 "common.h"
18
 
 
19
 
 
20
 
static int hex2num(char c)
21
 
{
22
 
        if (c >= '0' && c <= '9')
23
 
                return c - '0';
24
 
        if (c >= 'a' && c <= 'f')
25
 
                return c - 'a' + 10;
26
 
        if (c >= 'A' && c <= 'F')
27
 
                return c - 'A' + 10;
28
 
        return -1;
29
 
}
30
 
 
31
 
 
32
 
static int hex2byte(const char *hex)
33
 
{
34
 
        int a, b;
35
 
        a = hex2num(*hex++);
36
 
        if (a < 0)
37
 
                return -1;
38
 
        b = hex2num(*hex++);
39
 
        if (b < 0)
40
 
                return -1;
41
 
        return (a << 4) | b;
42
 
}
43
 
 
44
 
 
45
 
/**
46
 
 * hwaddr_aton - Convert ASCII string to MAC address
47
 
 * @txt: MAC address as a string (e.g., "00:11:22:33:44:55")
48
 
 * @addr: Buffer for the MAC address (ETH_ALEN = 6 bytes)
49
 
 * Returns: 0 on success, -1 on failure (e.g., string not a MAC address)
50
 
 */
51
 
int hwaddr_aton(const char *txt, u8 *addr)
52
 
{
53
 
        int i;
54
 
 
55
 
        for (i = 0; i < 6; i++) {
56
 
                int a, b;
57
 
 
58
 
                a = hex2num(*txt++);
59
 
                if (a < 0)
60
 
                        return -1;
61
 
                b = hex2num(*txt++);
62
 
                if (b < 0)
63
 
                        return -1;
64
 
                *addr++ = (a << 4) | b;
65
 
                if (i < 5 && *txt++ != ':')
66
 
                        return -1;
67
 
        }
68
 
 
69
 
        return 0;
70
 
}
71
 
 
72
 
 
73
 
/**
74
 
 * hexstr2bin - Convert ASCII hex string into binary data
75
 
 * @hex: ASCII hex string (e.g., "01ab")
76
 
 * @buf: Buffer for the binary data
77
 
 * @len: Length of the text to convert in bytes (of buf); hex will be double
78
 
 * this size
79
 
 * Returns: 0 on success, -1 on failure (invalid hex string)
80
 
 */
81
 
int hexstr2bin(const char *hex, u8 *buf, size_t len)
82
 
{
83
 
        size_t i;
84
 
        int a;
85
 
        const char *ipos = hex;
86
 
        u8 *opos = buf;
87
 
 
88
 
        for (i = 0; i < len; i++) {
89
 
                a = hex2byte(ipos);
90
 
                if (a < 0)
91
 
                        return -1;
92
 
                *opos++ = a;
93
 
                ipos += 2;
94
 
        }
95
 
        return 0;
96
 
}
97
 
 
98
 
 
99
 
/**
100
 
 * inc_byte_array - Increment arbitrary length byte array by one
101
 
 * @counter: Pointer to byte array
102
 
 * @len: Length of the counter in bytes
103
 
 *
104
 
 * This function increments the last byte of the counter by one and continues
105
 
 * rolling over to more significant bytes if the byte was incremented from
106
 
 * 0xff to 0x00.
107
 
 */
108
 
void inc_byte_array(u8 *counter, size_t len)
109
 
{
110
 
        int pos = len - 1;
111
 
        while (pos >= 0) {
112
 
                counter[pos]++;
113
 
                if (counter[pos] != 0)
114
 
                        break;
115
 
                pos--;
116
 
        }
117
 
}
118
 
 
119
 
 
120
 
void wpa_get_ntp_timestamp(u8 *buf)
121
 
{
122
 
        struct os_time now;
123
 
        u32 sec, usec;
124
 
        be32 tmp;
125
 
 
126
 
        /* 64-bit NTP timestamp (time from 1900-01-01 00:00:00) */
127
 
        os_get_time(&now);
128
 
        sec = now.sec + 2208988800U; /* Epoch to 1900 */
129
 
        /* Estimate 2^32/10^6 = 4295 - 1/32 - 1/512 */
130
 
        usec = now.usec;
131
 
        usec = 4295 * usec - (usec >> 5) - (usec >> 9);
132
 
        tmp = host_to_be32(sec);
133
 
        os_memcpy(buf, (u8 *) &tmp, 4);
134
 
        tmp = host_to_be32(usec);
135
 
        os_memcpy(buf + 4, (u8 *) &tmp, 4);
136
 
}
137
 
 
138
 
 
139
 
static inline int _wpa_snprintf_hex(char *buf, size_t buf_size, const u8 *data,
140
 
                                    size_t len, int uppercase)
141
 
{
142
 
        size_t i;
143
 
        char *pos = buf, *end = buf + buf_size;
144
 
        int ret;
145
 
        if (buf_size == 0)
146
 
                return 0;
147
 
        for (i = 0; i < len; i++) {
148
 
                ret = os_snprintf(pos, end - pos, uppercase ? "%02X" : "%02x",
149
 
                                  data[i]);
150
 
                if (ret < 0 || ret >= end - pos) {
151
 
                        end[-1] = '\0';
152
 
                        return pos - buf;
153
 
                }
154
 
                pos += ret;
155
 
        }
156
 
        end[-1] = '\0';
157
 
        return pos - buf;
158
 
}
159
 
 
160
 
/**
161
 
 * wpa_snprintf_hex - Print data as a hex string into a buffer
162
 
 * @buf: Memory area to use as the output buffer
163
 
 * @buf_size: Maximum buffer size in bytes (should be at least 2 * len + 1)
164
 
 * @data: Data to be printed
165
 
 * @len: Length of data in bytes
166
 
 * Returns: Number of bytes written
167
 
 */
168
 
int wpa_snprintf_hex(char *buf, size_t buf_size, const u8 *data, size_t len)
169
 
{
170
 
        return _wpa_snprintf_hex(buf, buf_size, data, len, 0);
171
 
}
172
 
 
173
 
 
174
 
/**
175
 
 * wpa_snprintf_hex_uppercase - Print data as a upper case hex string into buf
176
 
 * @buf: Memory area to use as the output buffer
177
 
 * @buf_size: Maximum buffer size in bytes (should be at least 2 * len + 1)
178
 
 * @data: Data to be printed
179
 
 * @len: Length of data in bytes
180
 
 * Returns: Number of bytes written
181
 
 */
182
 
int wpa_snprintf_hex_uppercase(char *buf, size_t buf_size, const u8 *data,
183
 
                               size_t len)
184
 
{
185
 
        return _wpa_snprintf_hex(buf, buf_size, data, len, 1);
186
 
}
187
 
 
188
 
 
189
 
#ifdef CONFIG_ANSI_C_EXTRA
190
 
 
191
 
#ifdef _WIN32_WCE
192
 
void perror(const char *s)
193
 
{
194
 
        wpa_printf(MSG_ERROR, "%s: GetLastError: %d",
195
 
                   s, (int) GetLastError());
196
 
}
197
 
#endif /* _WIN32_WCE */
198
 
 
199
 
 
200
 
int optind = 1;
201
 
int optopt;
202
 
char *optarg;
203
 
 
204
 
int getopt(int argc, char *const argv[], const char *optstring)
205
 
{
206
 
        static int optchr = 1;
207
 
        char *cp;
208
 
 
209
 
        if (optchr == 1) {
210
 
                if (optind >= argc) {
211
 
                        /* all arguments processed */
212
 
                        return EOF;
213
 
                }
214
 
 
215
 
                if (argv[optind][0] != '-' || argv[optind][1] == '\0') {
216
 
                        /* no option characters */
217
 
                        return EOF;
218
 
                }
219
 
        }
220
 
 
221
 
        if (os_strcmp(argv[optind], "--") == 0) {
222
 
                /* no more options */
223
 
                optind++;
224
 
                return EOF;
225
 
        }
226
 
 
227
 
        optopt = argv[optind][optchr];
228
 
        cp = os_strchr(optstring, optopt);
229
 
        if (cp == NULL || optopt == ':') {
230
 
                if (argv[optind][++optchr] == '\0') {
231
 
                        optchr = 1;
232
 
                        optind++;
233
 
                }
234
 
                return '?';
235
 
        }
236
 
 
237
 
        if (cp[1] == ':') {
238
 
                /* Argument required */
239
 
                optchr = 1;
240
 
                if (argv[optind][optchr + 1]) {
241
 
                        /* No space between option and argument */
242
 
                        optarg = &argv[optind++][optchr + 1];
243
 
                } else if (++optind >= argc) {
244
 
                        /* option requires an argument */
245
 
                        return '?';
246
 
                } else {
247
 
                        /* Argument in the next argv */
248
 
                        optarg = argv[optind++];
249
 
                }
250
 
        } else {
251
 
                /* No argument */
252
 
                if (argv[optind][++optchr] == '\0') {
253
 
                        optchr = 1;
254
 
                        optind++;
255
 
                }
256
 
                optarg = NULL;
257
 
        }
258
 
        return *cp;
259
 
}
260
 
#endif /* CONFIG_ANSI_C_EXTRA */
261
 
 
262
 
 
263
 
#ifdef CONFIG_NATIVE_WINDOWS
264
 
/**
265
 
 * wpa_unicode2ascii_inplace - Convert unicode string into ASCII
266
 
 * @str: Pointer to string to convert
267
 
 *
268
 
 * This function converts a unicode string to ASCII using the same
269
 
 * buffer for output. If UNICODE is not set, the buffer is not
270
 
 * modified.
271
 
 */
272
 
void wpa_unicode2ascii_inplace(TCHAR *str)
273
 
{
274
 
#ifdef UNICODE
275
 
        char *dst = (char *) str;
276
 
        while (*str)
277
 
                *dst++ = (char) *str++;
278
 
        *dst = '\0';
279
 
#endif /* UNICODE */
280
 
}
281
 
 
282
 
 
283
 
TCHAR * wpa_strdup_tchar(const char *str)
284
 
{
285
 
#ifdef UNICODE
286
 
        TCHAR *buf;
287
 
        buf = os_malloc((strlen(str) + 1) * sizeof(TCHAR));
288
 
        if (buf == NULL)
289
 
                return NULL;
290
 
        wsprintf(buf, L"%S", str);
291
 
        return buf;
292
 
#else /* UNICODE */
293
 
        return os_strdup(str);
294
 
#endif /* UNICODE */
295
 
}
296
 
#endif /* CONFIG_NATIVE_WINDOWS */
297
 
 
298
 
 
299
 
/**
300
 
 * wpa_ssid_txt - Convert SSID to a printable string
301
 
 * @ssid: SSID (32-octet string)
302
 
 * @ssid_len: Length of ssid in octets
303
 
 * Returns: Pointer to a printable string
304
 
 *
305
 
 * This function can be used to convert SSIDs into printable form. In most
306
 
 * cases, SSIDs do not use unprintable characters, but IEEE 802.11 standard
307
 
 * does not limit the used character set, so anything could be used in an SSID.
308
 
 *
309
 
 * This function uses a static buffer, so only one call can be used at the
310
 
 * time, i.e., this is not re-entrant and the returned buffer must be used
311
 
 * before calling this again.
312
 
 */
313
 
const char * wpa_ssid_txt(u8 *ssid, size_t ssid_len)
314
 
{
315
 
        static char ssid_txt[33];
316
 
        char *pos;
317
 
 
318
 
        if (ssid_len > 32)
319
 
                ssid_len = 32;
320
 
        os_memcpy(ssid_txt, ssid, ssid_len);
321
 
        ssid_txt[ssid_len] = '\0';
322
 
        for (pos = ssid_txt; *pos != '\0'; pos++) {
323
 
                if ((u8) *pos < 32 || (u8) *pos >= 127)
324
 
                        *pos = '_';
325
 
        }
326
 
        return ssid_txt;
327
 
}