1 /* 2 * wpa_supplicant/hostapd / common helper functions, etc. 3 * Copyright (c) 2002-2007, Jouni Malinen <j (at) w1.fi> 4 * 5 * This software may be distributed under the terms of the BSD license. 6 * See README for more details. 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 26 int hex2byte(const char *hex) 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 /** 40 * hwaddr_aton - Convert ASCII string to MAC address (colon-delimited format) 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 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 } 90 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 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 void printf_encode(char *txt, size_t maxlen, const u8 *data, size_t len) 348 { 349 char *end = txt + maxlen; 350 size_t i; 351 352 for (i = 0; i < len; i++) { 353 if (txt + 4 > end) 354 break; 355 356 switch (data[i]) { 357 case '\"': 358 *txt++ = '\\'; 359 *txt++ = '\"'; 360 break; 361 case '\\': 362 *txt++ = '\\'; 363 *txt++ = '\\'; 364 break; 365 case '\e': 366 *txt++ = '\\'; 367 *txt++ = 'e'; 368 break; 369 case '\n': 370 *txt++ = '\\'; 371 *txt++ = 'n'; 372 break; 373 case '\r': 374 *txt++ = '\\'; 375 *txt++ = 'r'; 376 break; 377 case '\t': 378 *txt++ = '\\'; 379 *txt++ = 't'; 380 break; 381 default: 382 if (data[i] >= 32 && data[i] <= 127) { 383 *txt++ = data[i]; 384 } else { 385 txt += os_snprintf(txt, end - txt, "\\x%02x", 386 data[i]); 387 } 388 break; 389 } 390 } 391 392 *txt = '\0'; 393 } 394 395 396 size_t printf_decode(u8 *buf, size_t maxlen, const char *str) 397 { 398 const char *pos = str; 399 size_t len = 0; 400 int val; 401 402 while (*pos) { 403 if (len == maxlen) 404 break; 405 switch (*pos) { 406 case '\\': 407 pos++; 408 switch (*pos) { 409 case '\\': 410 buf[len++] = '\\'; 411 pos++; 412 break; 413 case '"': 414 buf[len++] = '"'; 415 pos++; 416 break; 417 case 'n': 418 buf[len++] = '\n'; 419 pos++; 420 break; 421 case 'r': 422 buf[len++] = '\r'; 423 pos++; 424 break; 425 case 't': 426 buf[len++] = '\t'; 427 pos++; 428 break; 429 case 'e': 430 buf[len++] = '\e'; 431 pos++; 432 break; 433 case 'x': 434 pos++; 435 val = hex2byte(pos); 436 if (val < 0) { 437 val = hex2num(*pos); 438 if (val < 0) 439 break; 440 buf[len++] = val; 441 pos++; 442 } else { 443 buf[len++] = val; 444 pos += 2; 445 } 446 break; 447 case '0': 448 case '1': 449 case '2': 450 case '3': 451 case '4': 452 case '5': 453 case '6': 454 case '7': 455 val = *pos++ - '0'; 456 if (*pos >= '0' && *pos <= '7') 457 val = val * 8 + (*pos++ - '0'); 458 if (*pos >= '0' && *pos <= '7') 459 val = val * 8 + (*pos++ - '0'); 460 buf[len++] = val; 461 break; 462 default: 463 break; 464 } 465 break; 466 default: 467 buf[len++] = *pos++; 468 break; 469 } 470 } 471 472 return len; 473 } 474 475 476 /** 477 * wpa_ssid_txt - Convert SSID to a printable string 478 * @ssid: SSID (32-octet string) 479 * @ssid_len: Length of ssid in octets 480 * Returns: Pointer to a printable string 481 * 482 * This function can be used to convert SSIDs into printable form. In most 483 * cases, SSIDs do not use unprintable characters, but IEEE 802.11 standard 484 * does not limit the used character set, so anything could be used in an SSID. 485 * 486 * This function uses a static buffer, so only one call can be used at the 487 * time, i.e., this is not re-entrant and the returned buffer must be used 488 * before calling this again. 489 */ 490 const char * wpa_ssid_txt(const u8 *ssid, size_t ssid_len) 491 { 492 static char ssid_txt[32 * 4 + 1]; 493 494 if (ssid == NULL) { 495 ssid_txt[0] = '\0'; 496 return ssid_txt; 497 } 498 499 printf_encode(ssid_txt, sizeof(ssid_txt), ssid, ssid_len); 500 return ssid_txt; 501 } 502 503 504 void * __hide_aliasing_typecast(void *foo) 505 { 506 return foo; 507 } 508 509 510 char * wpa_config_parse_string(const char *value, size_t *len) 511 { 512 if (*value == '"') { 513 const char *pos; 514 char *str; 515 value++; 516 pos = os_strrchr(value, '"'); 517 if (pos == NULL || pos[1] != '\0') 518 return NULL; 519 *len = pos - value; 520 str = dup_binstr(value, *len); 521 if (str == NULL) 522 return NULL; 523 return str; 524 } else if (*value == 'P' && value[1] == '"') { 525 const char *pos; 526 char *tstr, *str; 527 size_t tlen; 528 value += 2; 529 pos = os_strrchr(value, '"'); 530 if (pos == NULL || pos[1] != '\0') 531 return NULL; 532 tlen = pos - value; 533 tstr = dup_binstr(value, tlen); 534 if (tstr == NULL) 535 return NULL; 536 537 str = os_malloc(tlen + 1); 538 if (str == NULL) { 539 os_free(tstr); 540 return NULL; 541 } 542 543 *len = printf_decode((u8 *) str, tlen + 1, tstr); 544 os_free(tstr); 545 546 return str; 547 } else { 548 u8 *str; 549 size_t tlen, hlen = os_strlen(value); 550 if (hlen & 1) 551 return NULL; 552 tlen = hlen / 2; 553 str = os_malloc(tlen + 1); 554 if (str == NULL) 555 return NULL; 556 if (hexstr2bin(value, str, tlen)) { 557 os_free(str); 558 return NULL; 559 } 560 str[tlen] = '\0'; 561 *len = tlen; 562 return (char *) str; 563 } 564 } 565 566 567 int is_hex(const u8 *data, size_t len) 568 { 569 size_t i; 570 571 for (i = 0; i < len; i++) { 572 if (data[i] < 32 || data[i] >= 127) 573 return 1; 574 } 575 return 0; 576 } 577 578 579 size_t merge_byte_arrays(u8 *res, size_t res_len, 580 const u8 *src1, size_t src1_len, 581 const u8 *src2, size_t src2_len) 582 { 583 size_t len = 0; 584 585 os_memset(res, 0, res_len); 586 587 if (src1) { 588 if (src1_len >= res_len) { 589 os_memcpy(res, src1, res_len); 590 return res_len; 591 } 592 593 os_memcpy(res, src1, src1_len); 594 len += src1_len; 595 } 596 597 if (src2) { 598 if (len + src2_len >= res_len) { 599 os_memcpy(res + len, src2, res_len - len); 600 return res_len; 601 } 602 603 os_memcpy(res + len, src2, src2_len); 604 len += src2_len; 605 } 606 607 return len; 608 } 609 610 611 char * dup_binstr(const void *src, size_t len) 612 { 613 char *res; 614 615 if (src == NULL) 616 return NULL; 617 res = os_malloc(len + 1); 618 if (res == NULL) 619 return NULL; 620 os_memcpy(res, src, len); 621 res[len] = '\0'; 622 623 return res; 624 } 625
