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