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 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(const 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 }
 328
 329
 330 void * __hide_aliasing_typecast(void *foo)
 331 {
 332         return foo;
 333 }