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/ieee802_11_defs.h"
  12 #include "common.h"
  13
  14
  15 static int hex2num(char c)
  16 {
  17         if (c >= '0' && c <= '9')
  18                 return c - '0';
  19         if (c >= 'a' && c <= 'f')
  20                 return c - 'a' + 10;
  21         if (c >= 'A' && c <= 'F')
  22                 return c - 'A' + 10;
  23         return -1;
  24 }
  25
  26
  27 int hex2byte(const char *hex)
  28 {
  29         int a, b;
  30         a = hex2num(*hex++);
  31         if (a < 0)
  32                 return -1;
  33         b = hex2num(*hex++);
  34         if (b < 0)
  35                 return -1;
  36         return (a << 4) | b;
  37 }
  38
  39
  40 static const char * hwaddr_parse(const char *txt, u8 *addr)
  41 {
  42         size_t i;
  43
  44         for (i = 0; i < ETH_ALEN; i++) {
  45                 int a;
  46
  47                 a = hex2byte(txt);
  48                 if (a < 0)
  49                         return NULL;
  50                 txt += 2;
  51                 addr[i] = a;
  52                 if (i < ETH_ALEN - 1 && *txt++ != ':')
  53                         return NULL;
  54         }
  55         return txt;
  56 }
  57
  58
  59 /**
  60  * hwaddr_aton - Convert ASCII string to MAC address (colon-delimited format)
  61  * @txt: MAC address as a string (e.g., "00:11:22:33:44:55")
  62  * @addr: Buffer for the MAC address (ETH_ALEN = 6 bytes)
  63  * Returns: 0 on success, -1 on failure (e.g., string not a MAC address)
  64  */
  65 int hwaddr_aton(const char *txt, u8 *addr)
  66 {
  67         return hwaddr_parse(txt, addr) ? 0 : -1;
  68 }
  69
  70
  71 /**
  72  * hwaddr_masked_aton - Convert ASCII string with optional mask to MAC address (colon-delimited format)
  73  * @txt: MAC address with optional mask as a string (e.g., "00:11:22:33:44:55/ff:ff:ff:ff:00:00")
  74  * @addr: Buffer for the MAC address (ETH_ALEN = 6 bytes)
  75  * @mask: Buffer for the MAC address mask (ETH_ALEN = 6 bytes)
  76  * @maskable: Flag to indicate whether a mask is allowed
  77  * Returns: 0 on success, -1 on failure (e.g., string not a MAC address)
  78  */
  79 int hwaddr_masked_aton(const char *txt, u8 *addr, u8 *mask, u8 maskable)
  80 {
  81         const char *r;
  82
  83         /* parse address part */
  84         r = hwaddr_parse(txt, addr);
  85         if (!r)
  86                 return -1;
  87
  88         /* check for optional mask */
  89         if (*r == '\0' || isspace((unsigned char) *r)) {
  90                 /* no mask specified, assume default */
  91                 os_memset(mask, 0xff, ETH_ALEN);
  92         } else if (maskable && *r == '/') {
  93                 /* mask specified and allowed */
  94                 r = hwaddr_parse(r + 1, mask);
  95                 /* parser error? */
  96                 if (!r)
  97                         return -1;
  98         } else {
  99                 /* mask specified but not allowed or trailing garbage */
 100                 return -1;
 101         }
 102
 103         return 0;
 104 }
 105
 106
 107 /**
 108  * hwaddr_compact_aton - Convert ASCII string to MAC address (no colon delimitors format)
 109  * @txt: MAC address as a string (e.g., "001122334455")
 110  * @addr: Buffer for the MAC address (ETH_ALEN = 6 bytes)
 111  * Returns: 0 on success, -1 on failure (e.g., string not a MAC address)
 112  */
 113 int hwaddr_compact_aton(const char *txt, u8 *addr)
 114 {
 115         int i;
 116
 117         for (i = 0; i < 6; i++) {
 118                 int a, b;
 119
 120                 a = hex2num(*txt++);
 121                 if (a < 0)
 122                         return -1;
 123                 b = hex2num(*txt++);
 124                 if (b < 0)
 125                         return -1;
 126                 *addr++ = (a << 4) | b;
 127         }
 128
 129         return 0;
 130 }
 131
 132 /**
 133  * hwaddr_aton2 - Convert ASCII string to MAC address (in any known format)
 134  * @txt: MAC address as a string (e.g., 00:11:22:33:44:55 or 0011.2233.4455)
 135  * @addr: Buffer for the MAC address (ETH_ALEN = 6 bytes)
 136  * Returns: Characters used (> 0) on success, -1 on failure
 137  */
 138 int hwaddr_aton2(const char *txt, u8 *addr)
 139 {
 140         int i;
 141         const char *pos = txt;
 142
 143         for (i = 0; i < 6; i++) {
 144                 int a, b;
 145
 146                 while (*pos == ':' || *pos == '.' || *pos == '-')
 147                         pos++;
 148
 149                 a = hex2num(*pos++);
 150                 if (a < 0)
 151                         return -1;
 152                 b = hex2num(*pos++);
 153                 if (b < 0)
 154                         return -1;
 155                 *addr++ = (a << 4) | b;
 156         }
 157
 158         return pos - txt;
 159 }
 160
 161
 162 /**
 163  * hexstr2bin - Convert ASCII hex string into binary data
 164  * @hex: ASCII hex string (e.g., "01ab")
 165  * @buf: Buffer for the binary data
 166  * @len: Length of the text to convert in bytes (of buf); hex will be double
 167  * this size
 168  * Returns: 0 on success, -1 on failure (invalid hex string)
 169  */
 170 int hexstr2bin(const char *hex, u8 *buf, size_t len)
 171 {
 172         size_t i;
 173         int a;
 174         const char *ipos = hex;
 175         u8 *opos = buf;
 176
 177         for (i = 0; i < len; i++) {
 178                 a = hex2byte(ipos);
 179                 if (a < 0)
 180                         return -1;
 181                 *opos++ = a;
 182                 ipos += 2;
 183         }
 184         return 0;
 185 }
 186
 187
 188 int hwaddr_mask_txt(char *buf, size_t len, const u8 *addr, const u8 *mask)
 189 {
 190         size_t i;
 191         int print_mask = 0;
 192         int res;
 193
 194         for (i = 0; i < ETH_ALEN; i++) {
 195                 if (mask[i] != 0xff) {
 196                         print_mask = 1;
 197                         break;
 198                 }
 199         }
 200
 201         if (print_mask)
 202                 res = os_snprintf(buf, len, MACSTR "/" MACSTR,
 203                                   MAC2STR(addr), MAC2STR(mask));
 204         else
 205                 res = os_snprintf(buf, len, MACSTR, MAC2STR(addr));
 206         if (os_snprintf_error(len, res))
 207                 return -1;
 208         return res;
 209 }
 210
 211
 212 /**
 213  * inc_byte_array - Increment arbitrary length byte array by one
 214  * @counter: Pointer to byte array
 215  * @len: Length of the counter in bytes
 216  *
 217  * This function increments the last byte of the counter by one and continues
 218  * rolling over to more significant bytes if the byte was incremented from
 219  * 0xff to 0x00.
 220  */
 221 void inc_byte_array(u8 *counter, size_t len)
 222 {
 223         int pos = len - 1;
 224         while (pos >= 0) {
 225                 counter[pos]++;
 226                 if (counter[pos] != 0)
 227                         break;
 228                 pos--;
 229         }
 230 }
 231
 232
 233 void wpa_get_ntp_timestamp(u8 *buf)
 234 {
 235         struct os_time now;
 236         u32 sec, usec;
 237         be32 tmp;
 238
 239         /* 64-bit NTP timestamp (time from 1900-01-01 00:00:00) */
 240         os_get_time(&now);
 241         sec = now.sec + 2208988800U; /* Epoch to 1900 */
 242         /* Estimate 2^32/10^6 = 4295 - 1/32 - 1/512 */
 243         usec = now.usec;
 244         usec = 4295 * usec - (usec >> 5) - (usec >> 9);
 245         tmp = host_to_be32(sec);
 246         os_memcpy(buf, (u8 *) &tmp, 4);
 247         tmp = host_to_be32(usec);
 248         os_memcpy(buf + 4, (u8 *) &tmp, 4);
 249 }
 250
 251 /**
 252  * wpa_scnprintf - Simpler-to-use snprintf function
 253  * @buf: Output buffer
 254  * @size: Buffer size
 255  * @fmt: format
 256  *
 257  * Simpler snprintf version that doesn't require further error checks - the
 258  * return value only indicates how many bytes were actually written, excluding
 259  * the NULL byte (i.e., 0 on error, size-1 if buffer is not big enough).
 260  */
 261 int wpa_scnprintf(char *buf, size_t size, const char *fmt, ...)
 262 {
 263         va_list ap;
 264         int ret;
 265
 266         if (!size)
 267                 return 0;
 268
 269         va_start(ap, fmt);
 270         ret = vsnprintf(buf, size, fmt, ap);
 271         va_end(ap);
 272
 273         if (ret < 0)
 274                 return 0;
 275         if ((size_t) ret >= size)
 276                 return size - 1;
 277
 278         return ret;
 279 }
 280
 281
 282 int wpa_snprintf_hex_sep(char *buf, size_t buf_size, const u8 *data, size_t len,
 283                          char sep)
 284 {
 285         size_t i;
 286         char *pos = buf, *end = buf + buf_size;
 287         int ret;
 288
 289         if (buf_size == 0)
 290                 return 0;
 291
 292         for (i = 0; i < len; i++) {
 293                 ret = os_snprintf(pos, end - pos, "%02x%c",
 294                                   data[i], sep);
 295                 if (os_snprintf_error(end - pos, ret)) {
 296                         end[-1] = '\0';
 297                         return pos - buf;
 298                 }
 299                 pos += ret;
 300         }
 301         pos[-1] = '\0';
 302         return pos - buf;
 303 }
 304
 305
 306 static inline int _wpa_snprintf_hex(char *buf, size_t buf_size, const u8 *data,
 307                                     size_t len, int uppercase)
 308 {
 309         size_t i;
 310         char *pos = buf, *end = buf + buf_size;
 311         int ret;
 312         if (buf_size == 0)
 313                 return 0;
 314         for (i = 0; i < len; i++) {
 315                 ret = os_snprintf(pos, end - pos, uppercase ? "%02X" : "%02x",
 316                                   data[i]);
 317                 if (os_snprintf_error(end - pos, ret)) {
 318                         end[-1] = '\0';
 319                         return pos - buf;
 320                 }
 321                 pos += ret;
 322         }
 323         end[-1] = '\0';
 324         return pos - buf;
 325 }
 326
 327 /**
 328  * wpa_snprintf_hex - Print data as a hex string into a buffer
 329  * @buf: Memory area to use as the output buffer
 330  * @buf_size: Maximum buffer size in bytes (should be at least 2 * len + 1)
 331  * @data: Data to be printed
 332  * @len: Length of data in bytes
 333  * Returns: Number of bytes written
 334  */
 335 int wpa_snprintf_hex(char *buf, size_t buf_size, const u8 *data, size_t len)
 336 {
 337         return _wpa_snprintf_hex(buf, buf_size, data, len, 0);
 338 }
 339
 340
 341 /**
 342  * wpa_snprintf_hex_uppercase - Print data as a upper case hex string into buf
 343  * @buf: Memory area to use as the output buffer
 344  * @buf_size: Maximum buffer size in bytes (should be at least 2 * len + 1)
 345  * @data: Data to be printed
 346  * @len: Length of data in bytes
 347  * Returns: Number of bytes written
 348  */
 349 int wpa_snprintf_hex_uppercase(char *buf, size_t buf_size, const u8 *data,
 350                                size_t len)
 351 {
 352         return _wpa_snprintf_hex(buf, buf_size, data, len, 1);
 353 }
 354
 355
 356 #ifdef CONFIG_ANSI_C_EXTRA
 357
 358 #ifdef _WIN32_WCE
 359 void perror(const char *s)
 360 {
 361         wpa_printf(MSG_ERROR, "%s: GetLastError: %d",
 362                    s, (int) GetLastError());
 363 }
 364 #endif /* _WIN32_WCE */
 365
 366
 367 int optind = 1;
 368 int optopt;
 369 char *optarg;
 370
 371 int getopt(int argc, char *const argv[], const char *optstring)
 372 {
 373         static int optchr = 1;
 374         char *cp;
 375
 376         if (optchr == 1) {
 377                 if (optind >= argc) {
 378                         /* all arguments processed */
 379                         return EOF;
 380                 }
 381
 382                 if (argv[optind][0] != '-' || argv[optind][1] == '\0') {
 383                         /* no option characters */
 384                         return EOF;
 385                 }
 386         }
 387
 388         if (os_strcmp(argv[optind], "--") == 0) {
 389                 /* no more options */
 390                 optind++;
 391                 return EOF;
 392         }
 393
 394         optopt = argv[optind][optchr];
 395         cp = os_strchr(optstring, optopt);
 396         if (cp == NULL || optopt == ':') {
 397                 if (argv[optind][++optchr] == '\0') {
 398                         optchr = 1;
 399                         optind++;
 400                 }
 401                 return '?';
 402         }
 403
 404         if (cp[1] == ':') {
 405                 /* Argument required */
 406                 optchr = 1;
 407                 if (argv[optind][optchr + 1]) {
 408                         /* No space between option and argument */
 409                         optarg = &argv[optind++][optchr + 1];
 410                 } else if (++optind >= argc) {
 411                         /* option requires an argument */
 412                         return '?';
 413                 } else {
 414                         /* Argument in the next argv */
 415                         optarg = argv[optind++];
 416                 }
 417         } else {
 418                 /* No argument */
 419                 if (argv[optind][++optchr] == '\0') {
 420                         optchr = 1;
 421                         optind++;
 422                 }
 423                 optarg = NULL;
 424         }
 425         return *cp;
 426 }
 427 #endif /* CONFIG_ANSI_C_EXTRA */
 428
 429
 430 #ifdef CONFIG_NATIVE_WINDOWS
 431 /**
 432  * wpa_unicode2ascii_inplace - Convert unicode string into ASCII
 433  * @str: Pointer to string to convert
 434  *
 435  * This function converts a unicode string to ASCII using the same
 436  * buffer for output. If UNICODE is not set, the buffer is not
 437  * modified.
 438  */
 439 void wpa_unicode2ascii_inplace(TCHAR *str)
 440 {
 441 #ifdef UNICODE
 442         char *dst = (char *) str;
 443         while (*str)
 444                 *dst++ = (char) *str++;
 445         *dst = '\0';
 446 #endif /* UNICODE */
 447 }
 448
 449
 450 TCHAR * wpa_strdup_tchar(const char *str)
 451 {
 452 #ifdef UNICODE
 453         TCHAR *buf;
 454         buf = os_malloc((strlen(str) + 1) * sizeof(TCHAR));
 455         if (buf == NULL)
 456                 return NULL;
 457         wsprintf(buf, L"%S", str);
 458         return buf;
 459 #else /* UNICODE */
 460         return os_strdup(str);
 461 #endif /* UNICODE */
 462 }
 463 #endif /* CONFIG_NATIVE_WINDOWS */
 464
 465
 466 void printf_encode(char *txt, size_t maxlen, const u8 *data, size_t len)
 467 {
 468         char *end = txt + maxlen;
 469         size_t i;
 470
 471         for (i = 0; i < len; i++) {
 472                 if (txt + 4 >= end)
 473                         break;
 474
 475                 switch (data[i]) {
 476                 case '\"':
 477                         *txt++ = '\\';
 478                         *txt++ = '\"';
 479                         break;
 480                 case '\\':
 481                         *txt++ = '\\';
 482                         *txt++ = '\\';
 483                         break;
 484                 case '\033':
 485                         *txt++ = '\\';
 486                         *txt++ = 'e';
 487                         break;
 488                 case '\n':
 489                         *txt++ = '\\';
 490                         *txt++ = 'n';
 491                         break;
 492                 case '\r':
 493                         *txt++ = '\\';
 494                         *txt++ = 'r';
 495                         break;
 496                 case '\t':
 497                         *txt++ = '\\';
 498                         *txt++ = 't';
 499                         break;
 500                 default:
 501                         if (data[i] >= 32 && data[i] <= 126) {
 502                                 *txt++ = data[i];
 503                         } else {
 504                                 txt += os_snprintf(txt, end - txt, "\\x%02x",
 505                                                    data[i]);
 506                         }
 507                         break;
 508                 }
 509         }
 510
 511         *txt = '\0';
 512 }
 513
 514
 515 size_t printf_decode(u8 *buf, size_t maxlen, const char *str)
 516 {
 517         const char *pos = str;
 518         size_t len = 0;
 519         int val;
 520
 521         while (*pos) {
 522                 if (len + 1 >= maxlen)
 523                         break;
 524                 switch (*pos) {
 525                 case '\\':
 526                         pos++;
 527                         switch (*pos) {
 528                         case '\\':
 529                                 buf[len++] = '\\';
 530                                 pos++;
 531                                 break;
 532                         case '"':
 533                                 buf[len++] = '"';
 534                                 pos++;
 535                                 break;
 536                         case 'n':
 537                                 buf[len++] = '\n';
 538                                 pos++;
 539                                 break;
 540                         case 'r':
 541                                 buf[len++] = '\r';
 542                                 pos++;
 543                                 break;
 544                         case 't':
 545                                 buf[len++] = '\t';
 546                                 pos++;
 547                                 break;
 548                         case 'e':
 549                                 buf[len++] = '\033';
 550                                 pos++;
 551                                 break;
 552                         case 'x':
 553                                 pos++;
 554                                 val = hex2byte(pos);
 555                                 if (val < 0) {
 556                                         val = hex2num(*pos);
 557                                         if (val < 0)
 558                                                 break;
 559                                         buf[len++] = val;
 560                                         pos++;
 561                                 } else {
 562                                         buf[len++] = val;
 563                                         pos += 2;
 564                                 }
 565                                 break;
 566                         case '0':
 567                         case '1':
 568                         case '2':
 569                         case '3':
 570                         case '4':
 571                         case '5':
 572                         case '6':
 573                         case '7':
 574                                 val = *pos++ - '0';
 575                                 if (*pos >= '0' && *pos <= '7')
 576                                         val = val * 8 + (*pos++ - '0');
 577                                 if (*pos >= '0' && *pos <= '7')
 578                                         val = val * 8 + (*pos++ - '0');
 579                                 buf[len++] = val;
 580                                 break;
 581                         default:
 582                                 break;
 583                         }
 584                         break;
 585                 default:
 586                         buf[len++] = *pos++;
 587                         break;
 588                 }
 589         }
 590         if (maxlen > len)
 591                 buf[len] = '\0';
 592
 593         return len;
 594 }
 595
 596
 597 /**
 598  * wpa_ssid_txt - Convert SSID to a printable string
 599  * @ssid: SSID (32-octet string)
 600  * @ssid_len: Length of ssid in octets
 601  * Returns: Pointer to a printable string
 602  *
 603  * This function can be used to convert SSIDs into printable form. In most
 604  * cases, SSIDs do not use unprintable characters, but IEEE 802.11 standard
 605  * does not limit the used character set, so anything could be used in an SSID.
 606  *
 607  * This function uses a static buffer, so only one call can be used at the
 608  * time, i.e., this is not re-entrant and the returned buffer must be used
 609  * before calling this again.
 610  */
 611 const char * wpa_ssid_txt(const u8 *ssid, size_t ssid_len)
 612 {
 613         static char ssid_txt[SSID_MAX_LEN * 4 + 1];
 614
 615         if (ssid == NULL) {
 616                 ssid_txt[0] = '\0';
 617                 return ssid_txt;
 618         }
 619
 620         printf_encode(ssid_txt, sizeof(ssid_txt), ssid, ssid_len);
 621         return ssid_txt;
 622 }
 623
 624
 625 void * __hide_aliasing_typecast(void *foo)
 626 {
 627         return foo;
 628 }
 629
 630
 631 char * wpa_config_parse_string(const char *value, size_t *len)
 632 {
 633         if (*value == '"') {
 634                 const char *pos;
 635                 char *str;
 636                 value++;
 637                 pos = os_strrchr(value, '"');
 638                 if (pos == NULL || pos[1] != '\0')
 639                         return NULL;
 640                 *len = pos - value;
 641                 str = dup_binstr(value, *len);
 642                 if (str == NULL)
 643                         return NULL;
 644                 return str;
 645         } else if (*value == 'P' && value[1] == '"') {
 646                 const char *pos;
 647                 char *tstr, *str;
 648                 size_t tlen;
 649                 value += 2;
 650                 pos = os_strrchr(value, '"');
 651                 if (pos == NULL || pos[1] != '\0')
 652                         return NULL;
 653                 tlen = pos - value;
 654                 tstr = dup_binstr(value, tlen);
 655                 if (tstr == NULL)
 656                         return NULL;
 657
 658                 str = os_malloc(tlen + 1);
 659                 if (str == NULL) {
 660                         os_free(tstr);
 661                         return NULL;
 662                 }
 663
 664                 *len = printf_decode((u8 *) str, tlen + 1, tstr);
 665                 os_free(tstr);
 666
 667                 return str;
 668         } else {
 669                 u8 *str;
 670                 size_t tlen, hlen = os_strlen(value);
 671                 if (hlen & 1)
 672                         return NULL;
 673                 tlen = hlen / 2;
 674                 str = os_malloc(tlen + 1);
 675                 if (str == NULL)
 676                         return NULL;
 677                 if (hexstr2bin(value, str, tlen)) {
 678                         os_free(str);
 679                         return NULL;
 680                 }
 681                 str[tlen] = '\0';
 682                 *len = tlen;
 683                 return (char *) str;
 684         }
 685 }
 686
 687
 688 int is_hex(const u8 *data, size_t len)
 689 {
 690         size_t i;
 691
 692         for (i = 0; i < len; i++) {
 693                 if (data[i] < 32 || data[i] >= 127)
 694                         return 1;
 695         }
 696         return 0;
 697 }
 698
 699
 700 int has_ctrl_char(const u8 *data, size_t len)
 701 {
 702         size_t i;
 703
 704         for (i = 0; i < len; i++) {
 705                 if (data[i] < 32 || data[i] == 127)
 706                         return 1;
 707         }
 708         return 0;
 709 }
 710
 711
 712 int has_newline(const char *str)
 713 {
 714         while (*str) {
 715                 if (*str == '\n' || *str == '\r')
 716                         return 1;
 717                 str++;
 718         }
 719         return 0;
 720 }
 721
 722
 723 size_t merge_byte_arrays(u8 *res, size_t res_len,
 724                          const u8 *src1, size_t src1_len,
 725                          const u8 *src2, size_t src2_len)
 726 {
 727         size_t len = 0;
 728
 729         os_memset(res, 0, res_len);
 730
 731         if (src1) {
 732                 if (src1_len >= res_len) {
 733                         os_memcpy(res, src1, res_len);
 734                         return res_len;
 735                 }
 736
 737                 os_memcpy(res, src1, src1_len);
 738                 len += src1_len;
 739         }
 740
 741         if (src2) {
 742                 if (len + src2_len >= res_len) {
 743                         os_memcpy(res + len, src2, res_len - len);
 744                         return res_len;
 745                 }
 746
 747                 os_memcpy(res + len, src2, src2_len);
 748                 len += src2_len;
 749         }
 750
 751         return len;
 752 }
 753
 754
 755 char * dup_binstr(const void *src, size_t len)
 756 {
 757         char *res;
 758
 759         if (src == NULL)
 760                 return NULL;
 761         res = os_malloc(len + 1);
 762         if (res == NULL)
 763                 return NULL;
 764         os_memcpy(res, src, len);
 765         res[len] = '\0';
 766
 767         return res;
 768 }
 769
 770
 771 int freq_range_list_parse(struct wpa_freq_range_list *res, const char *value)
 772 {
 773         struct wpa_freq_range *freq = NULL, *n;
 774         unsigned int count = 0;
 775         const char *pos, *pos2, *pos3;
 776
 777         /*
 778          * Comma separated list of frequency ranges.
 779          * For example: 2412-2432,2462,5000-6000
 780          */
 781         pos = value;
 782         while (pos && pos[0]) {
 783                 n = os_realloc_array(freq, count + 1,
 784                                      sizeof(struct wpa_freq_range));
 785                 if (n == NULL) {
 786                         os_free(freq);
 787                         return -1;
 788                 }
 789                 freq = n;
 790                 freq[count].min = atoi(pos);
 791                 pos2 = os_strchr(pos, '-');
 792                 pos3 = os_strchr(pos, ',');
 793                 if (pos2 && (!pos3 || pos2 < pos3)) {
 794                         pos2++;
 795                         freq[count].max = atoi(pos2);
 796                 } else
 797                         freq[count].max = freq[count].min;
 798                 pos = pos3;
 799                 if (pos)
 800                         pos++;
 801                 count++;
 802         }
 803
 804         os_free(res->range);
 805         res->range = freq;
 806         res->num = count;
 807
 808         return 0;
 809 }
 810
 811
 812 int freq_range_list_includes(const struct wpa_freq_range_list *list,
 813                              unsigned int freq)
 814 {
 815         unsigned int i;
 816
 817         if (list == NULL)
 818                 return 0;
 819
 820         for (i = 0; i < list->num; i++) {
 821                 if (freq >= list->range[i].min && freq <= list->range[i].max)
 822                         return 1;
 823         }
 824
 825         return 0;
 826 }
 827
 828
 829 char * freq_range_list_str(const struct wpa_freq_range_list *list)
 830 {
 831         char *buf, *pos, *end;
 832         size_t maxlen;
 833         unsigned int i;
 834         int res;
 835
 836         if (list->num == 0)
 837                 return NULL;
 838
 839         maxlen = list->num * 30;
 840         buf = os_malloc(maxlen);
 841         if (buf == NULL)
 842                 return NULL;
 843         pos = buf;
 844         end = buf + maxlen;
 845
 846         for (i = 0; i < list->num; i++) {
 847                 struct wpa_freq_range *range = &list->range[i];
 848
 849                 if (range->min == range->max)
 850                         res = os_snprintf(pos, end - pos, "%s%u",
 851                                           i == 0 ? "" : ",", range->min);
 852                 else
 853                         res = os_snprintf(pos, end - pos, "%s%u-%u",
 854                                           i == 0 ? "" : ",",
 855                                           range->min, range->max);
 856                 if (os_snprintf_error(end - pos, res)) {
 857                         os_free(buf);
 858                         return NULL;
 859                 }
 860                 pos += res;
 861         }
 862
 863         return buf;
 864 }
 865
 866
 867 int int_array_len(const int *a)
 868 {
 869         int i;
 870         for (i = 0; a && a[i]; i++)
 871                 ;
 872         return i;
 873 }
 874
 875
 876 void int_array_concat(int **res, const int *a)
 877 {
 878         int reslen, alen, i;
 879         int *n;
 880
 881         reslen = int_array_len(*res);
 882         alen = int_array_len(a);
 883
 884         n = os_realloc_array(*res, reslen + alen + 1, sizeof(int));
 885         if (n == NULL) {
 886                 os_free(*res);
 887                 *res = NULL;
 888                 return;
 889         }
 890         for (i = 0; i <= alen; i++)
 891                 n[reslen + i] = a[i];
 892         *res = n;
 893 }
 894
 895
 896 static int freq_cmp(const void *a, const void *b)
 897 {
 898         int _a = *(int *) a;
 899         int _b = *(int *) b;
 900
 901         if (_a == 0)
 902                 return 1;
 903         if (_b == 0)
 904                 return -1;
 905         return _a - _b;
 906 }
 907
 908
 909 void int_array_sort_unique(int *a)
 910 {
 911         int alen;
 912         int i, j;
 913
 914         if (a == NULL)
 915                 return;
 916
 917         alen = int_array_len(a);
 918         qsort(a, alen, sizeof(int), freq_cmp);
 919
 920         i = 0;
 921         j = 1;
 922         while (a[i] && a[j]) {
 923                 if (a[i] == a[j]) {
 924                         j++;
 925                         continue;
 926                 }
 927                 a[++i] = a[j++];
 928         }
 929         if (a[i])
 930                 i++;
 931         a[i] = 0;
 932 }
 933
 934
 935 void int_array_add_unique(int **res, int a)
 936 {
 937         int reslen;
 938         int *n;
 939
 940         for (reslen = 0; *res && (*res)[reslen]; reslen++) {
 941                 if ((*res)[reslen] == a)
 942                         return; /* already in the list */
 943         }
 944
 945         n = os_realloc_array(*res, reslen + 2, sizeof(int));
 946         if (n == NULL) {
 947                 os_free(*res);
 948                 *res = NULL;
 949                 return;
 950         }
 951
 952         n[reslen] = a;
 953         n[reslen + 1] = 0;
 954
 955         *res = n;
 956 }
 957
 958
 959 void str_clear_free(char *str)
 960 {
 961         if (str) {
 962                 size_t len = os_strlen(str);
 963                 os_memset(str, 0, len);
 964                 os_free(str);
 965         }
 966 }
 967
 968
 969 void bin_clear_free(void *bin, size_t len)
 970 {
 971         if (bin) {
 972                 os_memset(bin, 0, len);
 973                 os_free(bin);
 974         }
 975 }
 976
 977
 978 int random_mac_addr(u8 *addr)
 979 {
 980         if (os_get_random(addr, ETH_ALEN) < 0)
 981                 return -1;
 982         addr[0] &= 0xfe; /* unicast */
 983         addr[0] |= 0x02; /* locally administered */
 984         return 0;
 985 }
 986
 987
 988 int random_mac_addr_keep_oui(u8 *addr)
 989 {
 990         if (os_get_random(addr + 3, 3) < 0)
 991                 return -1;
 992         addr[0] &= 0xfe; /* unicast */
 993         addr[0] |= 0x02; /* locally administered */
 994         return 0;
 995 }
 996
 997
 998 /**
 999  * cstr_token - Get next token from const char string
1000  * @str: a constant string to tokenize
1001  * @delim: a string of delimiters
1002  * @last: a pointer to a character following the returned token
1003  *      It has to be set to NULL for the first call and passed for any
1004  *      further call.
1005  * Returns: a pointer to token position in str or NULL
1006  *
1007  * This function is similar to str_token, but it can be used with both
1008  * char and const char strings. Differences:
1009  * - The str buffer remains unmodified
1010  * - The returned token is not a NULL terminated string, but a token
1011  *   position in str buffer. If a return value is not NULL a size
1012  *   of the returned token could be calculated as (last - token).
1013  */
1014 const char * cstr_token(const char *str, const char *delim, const char **last)
1015 {
1016         const char *end, *token = str;
1017
1018         if (!str || !delim || !last)
1019                 return NULL;
1020
1021         if (*last)
1022                 token = *last;
1023
1024         while (*token && os_strchr(delim, *token))
1025                 token++;
1026
1027         if (!*token)
1028                 return NULL;
1029
1030         end = token + 1;
1031
1032         while (*end && !os_strchr(delim, *end))
1033                 end++;
1034
1035         *last = end;
1036         return token;
1037 }
1038
1039
1040 /**
1041  * str_token - Get next token from a string
1042  * @buf: String to tokenize. Note that the string might be modified.
1043  * @delim: String of delimiters
1044  * @context: Pointer to save our context. Should be initialized with
1045  *      NULL on the first call, and passed for any further call.
1046  * Returns: The next token, NULL if there are no more valid tokens.
1047  */
1048 char * str_token(char *str, const char *delim, char **context)
1049 {
1050         char *token = (char *) cstr_token(str, delim, (const char **) context);
1051
1052         if (token && **context)
1053                 *(*context)++ = '\0';
1054
1055         return token;
1056 }
1057
1058
1059 size_t utf8_unescape(const char *inp, size_t in_size,
1060                      char *outp, size_t out_size)
1061 {
1062         size_t res_size = 0;
1063
1064         if (!inp || !outp)
1065                 return 0;
1066
1067         if (!in_size)
1068                 in_size = os_strlen(inp);
1069
1070         /* Advance past leading single quote */
1071         if (*inp == '\'' && in_size) {
1072                 inp++;
1073                 in_size--;
1074         }
1075
1076         while (in_size--) {
1077                 if (res_size >= out_size)
1078                         return 0;
1079
1080                 switch (*inp) {
1081                 case '\'':
1082                         /* Terminate on bare single quote */
1083                         *outp = '\0';
1084                         return res_size;
1085
1086                 case '\\':
1087                         if (!in_size--)
1088                                 return 0;
1089                         inp++;
1090                         /* fall through */
1091
1092                 default:
1093                         *outp++ = *inp++;
1094                         res_size++;
1095                 }
1096         }
1097
1098         /* NUL terminate if space allows */
1099         if (res_size < out_size)
1100                 *outp = '\0';
1101
1102         return res_size;
1103 }
1104
1105
1106 size_t utf8_escape(const char *inp, size_t in_size,
1107                    char *outp, size_t out_size)
1108 {
1109         size_t res_size = 0;
1110
1111         if (!inp || !outp)
1112                 return 0;
1113
1114         /* inp may or may not be NUL terminated, but must be if 0 size
1115          * is specified */
1116         if (!in_size)
1117                 in_size = os_strlen(inp);
1118
1119         while (in_size--) {
1120                 if (res_size++ >= out_size)
1121                         return 0;
1122
1123                 switch (*inp) {
1124                 case '\\':
1125                 case '\'':
1126                         if (res_size++ >= out_size)
1127                                 return 0;
1128                         *outp++ = '\\';
1129                         /* fall through */
1130
1131                 default:
1132                         *outp++ = *inp++;
1133                         break;
1134                 }
1135         }
1136
1137         /* NUL terminate if space allows */
1138         if (res_size < out_size)
1139                 *outp = '\0';
1140
1141         return res_size;
1142 }
1143
1144
1145 int is_ctrl_char(char c)
1146 {
1147         return c > 0 && c < 32;
1148 }
1149
1150
1151 /**
1152  * ssid_parse - Parse a string that contains SSID in hex or text format
1153  * @buf: Input NULL terminated string that contains the SSID
1154  * @ssid: Output SSID
1155  * Returns: 0 on success, -1 otherwise
1156  *
1157  * The SSID has to be enclosed in double quotes for the text format or space
1158  * or NULL terminated string of hex digits for the hex format. buf can include
1159  * additional arguments after the SSID.
1160  */
1161 int ssid_parse(const char *buf, struct wpa_ssid_value *ssid)
1162 {
1163         char *tmp, *res, *end;
1164         size_t len;
1165
1166         ssid->ssid_len = 0;
1167
1168         tmp = os_strdup(buf);
1169         if (!tmp)
1170                 return -1;
1171
1172         if (*tmp != '"') {
1173                 end = os_strchr(tmp, ' ');
1174                 if (end)
1175                         *end = '\0';
1176         } else {
1177                 end = os_strchr(tmp + 1, '"');
1178                 if (!end) {
1179                         os_free(tmp);
1180                         return -1;
1181                 }
1182
1183                 end[1] = '\0';
1184         }
1185
1186         res = wpa_config_parse_string(tmp, &len);
1187         if (res && len <= SSID_MAX_LEN) {
1188                 ssid->ssid_len = len;
1189                 os_memcpy(ssid->ssid, res, len);
1190         }
1191
1192         os_free(tmp);
1193         os_free(res);
1194
1195         return ssid->ssid_len ? 0 : -1;
1196 }
1197
1198
1199 int str_starts(const char *str, const char *start)
1200 {
1201         return os_strncmp(str, start, os_strlen(start)) == 0;
1202 }