contrib/hostapd/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 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 + 1 >= 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         if (maxlen > len)
 472                 buf[len] = '\0';
 473
 474         return len;
 475 }
 476
 477
 478 /**
 479  * wpa_ssid_txt - Convert SSID to a printable string
 480  * @ssid: SSID (32-octet string)
 481  * @ssid_len: Length of ssid in octets
 482  * Returns: Pointer to a printable string
 483  *
 484  * This function can be used to convert SSIDs into printable form. In most
 485  * cases, SSIDs do not use unprintable characters, but IEEE 802.11 standard
 486  * does not limit the used character set, so anything could be used in an SSID.
 487  *
 488  * This function uses a static buffer, so only one call can be used at the
 489  * time, i.e., this is not re-entrant and the returned buffer must be used
 490  * before calling this again.
 491  */
 492 const char * wpa_ssid_txt(const u8 *ssid, size_t ssid_len)
 493 {
 494         static char ssid_txt[32 * 4 + 1];
 495
 496         if (ssid == NULL) {
 497                 ssid_txt[0] = '\0';
 498                 return ssid_txt;
 499         }
 500
 501         printf_encode(ssid_txt, sizeof(ssid_txt), ssid, ssid_len);
 502         return ssid_txt;
 503 }
 504
 505
 506 void * __hide_aliasing_typecast(void *foo)
 507 {
 508         return foo;
 509 }
 510
 511
 512 char * wpa_config_parse_string(const char *value, size_t *len)
 513 {
 514         if (*value == '"') {
 515                 const char *pos;
 516                 char *str;
 517                 value++;
 518                 pos = os_strrchr(value, '"');
 519                 if (pos == NULL || pos[1] != '\0')
 520                         return NULL;
 521                 *len = pos - value;
 522                 str = dup_binstr(value, *len);
 523                 if (str == NULL)
 524                         return NULL;
 525                 return str;
 526         } else if (*value == 'P' && value[1] == '"') {
 527                 const char *pos;
 528                 char *tstr, *str;
 529                 size_t tlen;
 530                 value += 2;
 531                 pos = os_strrchr(value, '"');
 532                 if (pos == NULL || pos[1] != '\0')
 533                         return NULL;
 534                 tlen = pos - value;
 535                 tstr = dup_binstr(value, tlen);
 536                 if (tstr == NULL)
 537                         return NULL;
 538
 539                 str = os_malloc(tlen + 1);
 540                 if (str == NULL) {
 541                         os_free(tstr);
 542                         return NULL;
 543                 }
 544
 545                 *len = printf_decode((u8 *) str, tlen + 1, tstr);
 546                 os_free(tstr);
 547
 548                 return str;
 549         } else {
 550                 u8 *str;
 551                 size_t tlen, hlen = os_strlen(value);
 552                 if (hlen & 1)
 553                         return NULL;
 554                 tlen = hlen / 2;
 555                 str = os_malloc(tlen + 1);
 556                 if (str == NULL)
 557                         return NULL;
 558                 if (hexstr2bin(value, str, tlen)) {
 559                         os_free(str);
 560                         return NULL;
 561                 }
 562                 str[tlen] = '\0';
 563                 *len = tlen;
 564                 return (char *) str;
 565         }
 566 }
 567
 568
 569 int is_hex(const u8 *data, size_t len)
 570 {
 571         size_t i;
 572
 573         for (i = 0; i < len; i++) {
 574                 if (data[i] < 32 || data[i] >= 127)
 575                         return 1;
 576         }
 577         return 0;
 578 }
 579
 580
 581 int find_first_bit(u32 value)
 582 {
 583         int pos = 0;
 584
 585         while (value) {
 586                 if (value & 0x1)
 587                         return pos;
 588                 value >>= 1;
 589                 pos++;
 590         }
 591
 592         return -1;
 593 }
 594
 595
 596 size_t merge_byte_arrays(u8 *res, size_t res_len,
 597                          const u8 *src1, size_t src1_len,
 598                          const u8 *src2, size_t src2_len)
 599 {
 600         size_t len = 0;
 601
 602         os_memset(res, 0, res_len);
 603
 604         if (src1) {
 605                 if (src1_len >= res_len) {
 606                         os_memcpy(res, src1, res_len);
 607                         return res_len;
 608                 }
 609
 610                 os_memcpy(res, src1, src1_len);
 611                 len += src1_len;
 612         }
 613
 614         if (src2) {
 615                 if (len + src2_len >= res_len) {
 616                         os_memcpy(res + len, src2, res_len - len);
 617                         return res_len;
 618                 }
 619
 620                 os_memcpy(res + len, src2, src2_len);
 621                 len += src2_len;
 622         }
 623
 624         return len;
 625 }
 626
 627
 628 char * dup_binstr(const void *src, size_t len)
 629 {
 630         char *res;
 631
 632         if (src == NULL)
 633                 return NULL;
 634         res = os_malloc(len + 1);
 635         if (res == NULL)
 636                 return NULL;
 637         os_memcpy(res, src, len);
 638         res[len] = '\0';
 639
 640         return res;
 641 }
 642
 643
 644 int freq_range_list_parse(struct wpa_freq_range_list *res, const char *value)
 645 {
 646         struct wpa_freq_range *freq = NULL, *n;
 647         unsigned int count = 0;
 648         const char *pos, *pos2, *pos3;
 649
 650         /*
 651          * Comma separated list of frequency ranges.
 652          * For example: 2412-2432,2462,5000-6000
 653          */
 654         pos = value;
 655         while (pos && pos[0]) {
 656                 n = os_realloc_array(freq, count + 1,
 657                                      sizeof(struct wpa_freq_range));
 658                 if (n == NULL) {
 659                         os_free(freq);
 660                         return -1;
 661                 }
 662                 freq = n;
 663                 freq[count].min = atoi(pos);
 664                 pos2 = os_strchr(pos, '-');
 665                 pos3 = os_strchr(pos, ',');
 666                 if (pos2 && (!pos3 || pos2 < pos3)) {
 667                         pos2++;
 668                         freq[count].max = atoi(pos2);
 669                 } else
 670                         freq[count].max = freq[count].min;
 671                 pos = pos3;
 672                 if (pos)
 673                         pos++;
 674                 count++;
 675         }
 676
 677         os_free(res->range);
 678         res->range = freq;
 679         res->num = count;
 680
 681         return 0;
 682 }
 683
 684
 685 int freq_range_list_includes(const struct wpa_freq_range_list *list,
 686                              unsigned int freq)
 687 {
 688         unsigned int i;
 689
 690         if (list == NULL)
 691                 return 0;
 692
 693         for (i = 0; i < list->num; i++) {
 694                 if (freq >= list->range[i].min && freq <= list->range[i].max)
 695                         return 1;
 696         }
 697
 698         return 0;
 699 }
 700
 701
 702 char * freq_range_list_str(const struct wpa_freq_range_list *list)
 703 {
 704         char *buf, *pos, *end;
 705         size_t maxlen;
 706         unsigned int i;
 707         int res;
 708
 709         if (list->num == 0)
 710                 return NULL;
 711
 712         maxlen = list->num * 30;
 713         buf = os_malloc(maxlen);
 714         if (buf == NULL)
 715                 return NULL;
 716         pos = buf;
 717         end = buf + maxlen;
 718
 719         for (i = 0; i < list->num; i++) {
 720                 struct wpa_freq_range *range = &list->range[i];
 721
 722                 if (range->min == range->max)
 723                         res = os_snprintf(pos, end - pos, "%s%u",
 724                                           i == 0 ? "" : ",", range->min);
 725                 else
 726                         res = os_snprintf(pos, end - pos, "%s%u-%u",
 727                                           i == 0 ? "" : ",",
 728                                           range->min, range->max);
 729                 if (res < 0 || res > end - pos) {
 730                         os_free(buf);
 731                         return NULL;
 732                 }
 733                 pos += res;
 734         }
 735
 736         return buf;
 737 }
 738
 739
 740 int int_array_len(const int *a)
 741 {
 742         int i;
 743         for (i = 0; a && a[i]; i++)
 744                 ;
 745         return i;
 746 }
 747
 748
 749 void int_array_concat(int **res, const int *a)
 750 {
 751         int reslen, alen, i;
 752         int *n;
 753
 754         reslen = int_array_len(*res);
 755         alen = int_array_len(a);
 756
 757         n = os_realloc_array(*res, reslen + alen + 1, sizeof(int));
 758         if (n == NULL) {
 759                 os_free(*res);
 760                 *res = NULL;
 761                 return;
 762         }
 763         for (i = 0; i <= alen; i++)
 764                 n[reslen + i] = a[i];
 765         *res = n;
 766 }
 767
 768
 769 static int freq_cmp(const void *a, const void *b)
 770 {
 771         int _a = *(int *) a;
 772         int _b = *(int *) b;
 773
 774         if (_a == 0)
 775                 return 1;
 776         if (_b == 0)
 777                 return -1;
 778         return _a - _b;
 779 }
 780
 781
 782 void int_array_sort_unique(int *a)
 783 {
 784         int alen;
 785         int i, j;
 786
 787         if (a == NULL)
 788                 return;
 789
 790         alen = int_array_len(a);
 791         qsort(a, alen, sizeof(int), freq_cmp);
 792
 793         i = 0;
 794         j = 1;
 795         while (a[i] && a[j]) {
 796                 if (a[i] == a[j]) {
 797                         j++;
 798                         continue;
 799                 }
 800                 a[++i] = a[j++];
 801         }
 802         if (a[i])
 803                 i++;
 804         a[i] = 0;
 805 }
 806
 807
 808 void int_array_add_unique(int **res, int a)
 809 {
 810         int reslen;
 811         int *n;
 812
 813         for (reslen = 0; *res && (*res)[reslen]; reslen++) {
 814                 if ((*res)[reslen] == a)
 815                         return; /* already in the list */
 816         }
 817
 818         n = os_realloc_array(*res, reslen + 2, sizeof(int));
 819         if (n == NULL) {
 820                 os_free(*res);
 821                 *res = NULL;
 822                 return;
 823         }
 824
 825         n[reslen] = a;
 826         n[reslen + 1] = 0;
 827
 828         *res = n;
 829 }