libeap/src/utils/wpa_debug.c

   1 /*
   2  * wpa_supplicant/hostapd / Debug prints
   3  * Copyright (c) 2002-2013, 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 #ifdef CONFIG_DEBUG_SYSLOG
  14 #include <syslog.h>
  15
  16 static int wpa_debug_syslog = 0;
  17 #endif /* CONFIG_DEBUG_SYSLOG */
  18
  19 #ifdef CONFIG_DEBUG_LINUX_TRACING
  20 #include <sys/types.h>
  21 #include <sys/stat.h>
  22 #include <fcntl.h>
  23 #include <string.h>
  24 #include <stdio.h>
  25
  26 static FILE *wpa_debug_tracing_file = NULL;
  27
  28 #define WPAS_TRACE_PFX "wpas <%d>: "
  29 #endif /* CONFIG_DEBUG_LINUX_TRACING */
  30
  31
  32 int wpa_debug_level = MSG_INFO;
  33 int wpa_debug_show_keys = 0;
  34 int wpa_debug_timestamp = 0;
  35
  36
  37 #ifdef CONFIG_ANDROID_LOG
  38
  39 #include <android/log.h>
  40
  41 #ifndef ANDROID_LOG_NAME
  42 #define ANDROID_LOG_NAME        "wpa_supplicant"
  43 #endif /* ANDROID_LOG_NAME */
  44
  45 static int wpa_to_android_level(int level)
  46 {
  47         if (level == MSG_ERROR)
  48                 return ANDROID_LOG_ERROR;
  49         if (level == MSG_WARNING)
  50                 return ANDROID_LOG_WARN;
  51         if (level == MSG_INFO)
  52                 return ANDROID_LOG_INFO;
  53         return ANDROID_LOG_DEBUG;
  54 }
  55
  56 #endif /* CONFIG_ANDROID_LOG */
  57
  58 #ifndef CONFIG_NO_STDOUT_DEBUG
  59
  60 #ifdef CONFIG_DEBUG_FILE
  61 static FILE *out_file = NULL;
  62 #endif /* CONFIG_DEBUG_FILE */
  63
  64
  65 void wpa_debug_print_timestamp(void)
  66 {
  67 #ifndef CONFIG_ANDROID_LOG
  68         struct os_time tv;
  69
  70         if (!wpa_debug_timestamp)
  71                 return;
  72
  73         os_get_time(&tv);
  74 #ifdef CONFIG_DEBUG_FILE
  75         if (out_file) {
  76                 fprintf(out_file, "%ld.%06u: ", (long) tv.sec,
  77                         (unsigned int) tv.usec);
  78         } else
  79 #endif /* CONFIG_DEBUG_FILE */
  80         printf("%ld.%06u: ", (long) tv.sec, (unsigned int) tv.usec);
  81 #endif /* CONFIG_ANDROID_LOG */
  82 }
  83
  84
  85 #ifdef CONFIG_DEBUG_SYSLOG
  86 #ifndef LOG_HOSTAPD
  87 #define LOG_HOSTAPD LOG_DAEMON
  88 #endif /* LOG_HOSTAPD */
  89
  90 void wpa_debug_open_syslog(void)
  91 {
  92         openlog("wpa_supplicant", LOG_PID | LOG_NDELAY, LOG_HOSTAPD);
  93         wpa_debug_syslog++;
  94 }
  95
  96
  97 void wpa_debug_close_syslog(void)
  98 {
  99         if (wpa_debug_syslog)
 100                 closelog();
 101 }
 102
 103
 104 static int syslog_priority(int level)
 105 {
 106         switch (level) {
 107         case MSG_MSGDUMP:
 108         case MSG_DEBUG:
 109                 return LOG_DEBUG;
 110         case MSG_INFO:
 111                 return LOG_NOTICE;
 112         case MSG_WARNING:
 113                 return LOG_WARNING;
 114         case MSG_ERROR:
 115                 return LOG_ERR;
 116         }
 117         return LOG_INFO;
 118 }
 119 #endif /* CONFIG_DEBUG_SYSLOG */
 120
 121
 122 #ifdef CONFIG_DEBUG_LINUX_TRACING
 123
 124 int wpa_debug_open_linux_tracing(void)
 125 {
 126         int mounts, trace_fd;
 127         char buf[4096] = {};
 128         ssize_t buflen;
 129         char *line, *tmp1, *path = NULL;
 130
 131         mounts = open("/proc/mounts", O_RDONLY);
 132         if (mounts < 0) {
 133                 printf("no /proc/mounts\n");
 134                 return -1;
 135         }
 136
 137         buflen = read(mounts, buf, sizeof(buf) - 1);
 138         close(mounts);
 139         if (buflen < 0) {
 140                 printf("failed to read /proc/mounts\n");
 141                 return -1;
 142         }
 143
 144         line = strtok_r(buf, "\n", &tmp1);
 145         while (line) {
 146                 char *tmp2, *tmp_path, *fstype;
 147                 /* "<dev> <mountpoint> <fs type> ..." */
 148                 strtok_r(line, " ", &tmp2);
 149                 tmp_path = strtok_r(NULL, " ", &tmp2);
 150                 fstype = strtok_r(NULL, " ", &tmp2);
 151                 if (strcmp(fstype, "debugfs") == 0) {
 152                         path = tmp_path;
 153                         break;
 154                 }
 155
 156                 line = strtok_r(NULL, "\n", &tmp1);
 157         }
 158
 159         if (path == NULL) {
 160                 printf("debugfs mountpoint not found\n");
 161                 return -1;
 162         }
 163
 164         snprintf(buf, sizeof(buf) - 1, "%s/tracing/trace_marker", path);
 165
 166         trace_fd = open(buf, O_WRONLY);
 167         if (trace_fd < 0) {
 168                 printf("failed to open trace_marker file\n");
 169                 return -1;
 170         }
 171         wpa_debug_tracing_file = fdopen(trace_fd, "w");
 172         if (wpa_debug_tracing_file == NULL) {
 173                 close(trace_fd);
 174                 printf("failed to fdopen()\n");
 175                 return -1;
 176         }
 177
 178         return 0;
 179 }
 180
 181
 182 void wpa_debug_close_linux_tracing(void)
 183 {
 184         if (wpa_debug_tracing_file == NULL)
 185                 return;
 186         fclose(wpa_debug_tracing_file);
 187         wpa_debug_tracing_file = NULL;
 188 }
 189
 190 #endif /* CONFIG_DEBUG_LINUX_TRACING */
 191
 192
 193 /**
 194  * wpa_printf - conditional printf
 195  * @level: priority level (MSG_*) of the message
 196  * @fmt: printf format string, followed by optional arguments
 197  *
 198  * This function is used to print conditional debugging and error messages. The
 199  * output may be directed to stdout, stderr, and/or syslog based on
 200  * configuration.
 201  *
 202  * Note: New line '\n' is added to the end of the text when printing to stdout.
 203  */
 204 void wpa_printf(int level, const char *fmt, ...)
 205 {
 206         va_list ap;
 207
 208         va_start(ap, fmt);
 209         if (level >= wpa_debug_level) {
 210 #ifdef CONFIG_ANDROID_LOG
 211                 __android_log_vprint(wpa_to_android_level(level),
 212                                      ANDROID_LOG_NAME, fmt, ap);
 213 #else /* CONFIG_ANDROID_LOG */
 214 #ifdef CONFIG_DEBUG_SYSLOG
 215                 if (wpa_debug_syslog) {
 216                         vsyslog(syslog_priority(level), fmt, ap);
 217                 } else {
 218 #endif /* CONFIG_DEBUG_SYSLOG */
 219                 wpa_debug_print_timestamp();
 220 #ifdef CONFIG_DEBUG_FILE
 221                 if (out_file) {
 222                         vfprintf(out_file, fmt, ap);
 223                         fprintf(out_file, "\n");
 224                 } else {
 225 #endif /* CONFIG_DEBUG_FILE */
 226                 vprintf(fmt, ap);
 227                 printf("\n");
 228 #ifdef CONFIG_DEBUG_FILE
 229                 }
 230 #endif /* CONFIG_DEBUG_FILE */
 231 #ifdef CONFIG_DEBUG_SYSLOG
 232                 }
 233 #endif /* CONFIG_DEBUG_SYSLOG */
 234 #endif /* CONFIG_ANDROID_LOG */
 235         }
 236         va_end(ap);
 237
 238 #ifdef CONFIG_DEBUG_LINUX_TRACING
 239         if (wpa_debug_tracing_file != NULL) {
 240                 va_start(ap, fmt);
 241                 fprintf(wpa_debug_tracing_file, WPAS_TRACE_PFX, level);
 242                 vfprintf(wpa_debug_tracing_file, fmt, ap);
 243                 fprintf(wpa_debug_tracing_file, "\n");
 244                 fflush(wpa_debug_tracing_file);
 245                 va_end(ap);
 246         }
 247 #endif /* CONFIG_DEBUG_LINUX_TRACING */
 248 }
 249
 250
 251 static void _wpa_hexdump(int level, const char *title, const u8 *buf,
 252                          size_t len, int show)
 253 {
 254         size_t i;
 255
 256 #ifdef CONFIG_DEBUG_LINUX_TRACING
 257         if (wpa_debug_tracing_file != NULL) {
 258                 fprintf(wpa_debug_tracing_file,
 259                         WPAS_TRACE_PFX "%s - hexdump(len=%lu):",
 260                         level, title, (unsigned long) len);
 261                 if (buf == NULL) {
 262                         fprintf(wpa_debug_tracing_file, " [NULL]\n");
 263                 } else if (!show) {
 264                         fprintf(wpa_debug_tracing_file, " [REMOVED]\n");
 265                 } else {
 266                         for (i = 0; i < len; i++)
 267                                 fprintf(wpa_debug_tracing_file,
 268                                         " %02x", buf[i]);
 269                 }
 270                 fflush(wpa_debug_tracing_file);
 271         }
 272 #endif /* CONFIG_DEBUG_LINUX_TRACING */
 273
 274         if (level < wpa_debug_level)
 275                 return;
 276 #ifdef CONFIG_ANDROID_LOG
 277         {
 278                 const char *display;
 279                 char *strbuf = NULL;
 280                 size_t slen = len;
 281                 if (buf == NULL) {
 282                         display = " [NULL]";
 283                 } else if (len == 0) {
 284                         display = "";
 285                 } else if (show && len) {
 286                         /* Limit debug message length for Android log */
 287                         if (slen > 32)
 288                                 slen = 32;
 289                         strbuf = os_malloc(1 + 3 * slen);
 290                         if (strbuf == NULL) {
 291                                 wpa_printf(MSG_ERROR, "wpa_hexdump: Failed to "
 292                                            "allocate message buffer");
 293                                 return;
 294                         }
 295
 296                         for (i = 0; i < slen; i++)
 297                                 os_snprintf(&strbuf[i * 3], 4, " %02x",
 298                                             buf[i]);
 299
 300                         display = strbuf;
 301                 } else {
 302                         display = " [REMOVED]";
 303                 }
 304
 305                 __android_log_print(wpa_to_android_level(level),
 306                                     ANDROID_LOG_NAME,
 307                                     "%s - hexdump(len=%lu):%s%s",
 308                                     title, (long unsigned int) len, display,
 309                                     len > slen ? " ..." : "");
 310                 bin_clear_free(strbuf, 1 + 3 * slen);
 311                 return;
 312         }
 313 #else /* CONFIG_ANDROID_LOG */
 314 #ifdef CONFIG_DEBUG_SYSLOG
 315         if (wpa_debug_syslog) {
 316                 const char *display;
 317                 char *strbuf = NULL;
 318
 319                 if (buf == NULL) {
 320                         display = " [NULL]";
 321                 } else if (len == 0) {
 322                         display = "";
 323                 } else if (show && len) {
 324                         strbuf = os_malloc(1 + 3 * len);
 325                         if (strbuf == NULL) {
 326                                 wpa_printf(MSG_ERROR, "wpa_hexdump: Failed to "
 327                                            "allocate message buffer");
 328                                 return;
 329                         }
 330
 331                         for (i = 0; i < len; i++)
 332                                 os_snprintf(&strbuf[i * 3], 4, " %02x",
 333                                             buf[i]);
 334
 335                         display = strbuf;
 336                 } else {
 337                         display = " [REMOVED]";
 338                 }
 339
 340                 syslog(syslog_priority(level), "%s - hexdump(len=%lu):%s",
 341                        title, (unsigned long) len, display);
 342                 bin_clear_free(strbuf, 1 + 3 * len);
 343                 return;
 344         }
 345 #endif /* CONFIG_DEBUG_SYSLOG */
 346         wpa_debug_print_timestamp();
 347 #ifdef CONFIG_DEBUG_FILE
 348         if (out_file) {
 349                 fprintf(out_file, "%s - hexdump(len=%lu):",
 350                         title, (unsigned long) len);
 351                 if (buf == NULL) {
 352                         fprintf(out_file, " [NULL]");
 353                 } else if (show) {
 354                         for (i = 0; i < len; i++)
 355                                 fprintf(out_file, " %02x", buf[i]);
 356                 } else {
 357                         fprintf(out_file, " [REMOVED]");
 358                 }
 359                 fprintf(out_file, "\n");
 360         } else {
 361 #endif /* CONFIG_DEBUG_FILE */
 362         printf("%s - hexdump(len=%lu):", title, (unsigned long) len);
 363         if (buf == NULL) {
 364                 printf(" [NULL]");
 365         } else if (show) {
 366                 for (i = 0; i < len; i++)
 367                         printf(" %02x", buf[i]);
 368         } else {
 369                 printf(" [REMOVED]");
 370         }
 371         printf("\n");
 372 #ifdef CONFIG_DEBUG_FILE
 373         }
 374 #endif /* CONFIG_DEBUG_FILE */
 375 #endif /* CONFIG_ANDROID_LOG */
 376 }
 377
 378 void wpa_hexdump(int level, const char *title, const void *buf, size_t len)
 379 {
 380         _wpa_hexdump(level, title, buf, len, 1);
 381 }
 382
 383
 384 void wpa_hexdump_key(int level, const char *title, const void *buf, size_t len)
 385 {
 386         _wpa_hexdump(level, title, buf, len, wpa_debug_show_keys);
 387 }
 388
 389
 390 static void _wpa_hexdump_ascii(int level, const char *title, const void *buf,
 391                                size_t len, int show)
 392 {
 393         size_t i, llen;
 394         const u8 *pos = buf;
 395         const size_t line_len = 16;
 396
 397 #ifdef CONFIG_DEBUG_LINUX_TRACING
 398         if (wpa_debug_tracing_file != NULL) {
 399                 fprintf(wpa_debug_tracing_file,
 400                         WPAS_TRACE_PFX "%s - hexdump_ascii(len=%lu):",
 401                         level, title, (unsigned long) len);
 402                 if (buf == NULL) {
 403                         fprintf(wpa_debug_tracing_file, " [NULL]\n");
 404                 } else if (!show) {
 405                         fprintf(wpa_debug_tracing_file, " [REMOVED]\n");
 406                 } else {
 407                         /* can do ascii processing in userspace */
 408                         for (i = 0; i < len; i++)
 409                                 fprintf(wpa_debug_tracing_file,
 410                                         " %02x", pos[i]);
 411                 }
 412                 fflush(wpa_debug_tracing_file);
 413         }
 414 #endif /* CONFIG_DEBUG_LINUX_TRACING */
 415
 416         if (level < wpa_debug_level)
 417                 return;
 418 #ifdef CONFIG_ANDROID_LOG
 419         _wpa_hexdump(level, title, buf, len, show);
 420 #else /* CONFIG_ANDROID_LOG */
 421         wpa_debug_print_timestamp();
 422 #ifdef CONFIG_DEBUG_FILE
 423         if (out_file) {
 424                 if (!show) {
 425                         fprintf(out_file,
 426                                 "%s - hexdump_ascii(len=%lu): [REMOVED]\n",
 427                                 title, (unsigned long) len);
 428                         return;
 429                 }
 430                 if (buf == NULL) {
 431                         fprintf(out_file,
 432                                 "%s - hexdump_ascii(len=%lu): [NULL]\n",
 433                                 title, (unsigned long) len);
 434                         return;
 435                 }
 436                 fprintf(out_file, "%s - hexdump_ascii(len=%lu):\n",
 437                         title, (unsigned long) len);
 438                 while (len) {
 439                         llen = len > line_len ? line_len : len;
 440                         fprintf(out_file, "    ");
 441                         for (i = 0; i < llen; i++)
 442                                 fprintf(out_file, " %02x", pos[i]);
 443                         for (i = llen; i < line_len; i++)
 444                                 fprintf(out_file, "   ");
 445                         fprintf(out_file, "   ");
 446                         for (i = 0; i < llen; i++) {
 447                                 if (isprint(pos[i]))
 448                                         fprintf(out_file, "%c", pos[i]);
 449                                 else
 450                                         fprintf(out_file, "_");
 451                         }
 452                         for (i = llen; i < line_len; i++)
 453                                 fprintf(out_file, " ");
 454                         fprintf(out_file, "\n");
 455                         pos += llen;
 456                         len -= llen;
 457                 }
 458         } else {
 459 #endif /* CONFIG_DEBUG_FILE */
 460         if (!show) {
 461                 printf("%s - hexdump_ascii(len=%lu): [REMOVED]\n",
 462                        title, (unsigned long) len);
 463                 return;
 464         }
 465         if (buf == NULL) {
 466                 printf("%s - hexdump_ascii(len=%lu): [NULL]\n",
 467                        title, (unsigned long) len);
 468                 return;
 469         }
 470         printf("%s - hexdump_ascii(len=%lu):\n", title, (unsigned long) len);
 471         while (len) {
 472                 llen = len > line_len ? line_len : len;
 473                 printf("    ");
 474                 for (i = 0; i < llen; i++)
 475                         printf(" %02x", pos[i]);
 476                 for (i = llen; i < line_len; i++)
 477                         printf("   ");
 478                 printf("   ");
 479                 for (i = 0; i < llen; i++) {
 480                         if (isprint(pos[i]))
 481                                 printf("%c", pos[i]);
 482                         else
 483                                 printf("_");
 484                 }
 485                 for (i = llen; i < line_len; i++)
 486                         printf(" ");
 487                 printf("\n");
 488                 pos += llen;
 489                 len -= llen;
 490         }
 491 #ifdef CONFIG_DEBUG_FILE
 492         }
 493 #endif /* CONFIG_DEBUG_FILE */
 494 #endif /* CONFIG_ANDROID_LOG */
 495 }
 496
 497
 498 void wpa_hexdump_ascii(int level, const char *title, const void *buf,
 499                        size_t len)
 500 {
 501         _wpa_hexdump_ascii(level, title, buf, len, 1);
 502 }
 503
 504
 505 void wpa_hexdump_ascii_key(int level, const char *title, const void *buf,
 506                            size_t len)
 507 {
 508         _wpa_hexdump_ascii(level, title, buf, len, wpa_debug_show_keys);
 509 }
 510
 511
 512 #ifdef CONFIG_DEBUG_FILE
 513 static char *last_path = NULL;
 514 #endif /* CONFIG_DEBUG_FILE */
 515
 516 int wpa_debug_reopen_file(void)
 517 {
 518 #ifdef CONFIG_DEBUG_FILE
 519         int rv;
 520         if (last_path) {
 521                 char *tmp = os_strdup(last_path);
 522                 wpa_debug_close_file();
 523                 rv = wpa_debug_open_file(tmp);
 524                 os_free(tmp);
 525         } else {
 526                 wpa_printf(MSG_ERROR, "Last-path was not set, cannot "
 527                            "re-open log file.");
 528                 rv = -1;
 529         }
 530         return rv;
 531 #else /* CONFIG_DEBUG_FILE */
 532         return 0;
 533 #endif /* CONFIG_DEBUG_FILE */
 534 }
 535
 536
 537 int wpa_debug_open_file(const char *path)
 538 {
 539 #ifdef CONFIG_DEBUG_FILE
 540         if (!path)
 541                 return 0;
 542
 543         if (last_path == NULL || os_strcmp(last_path, path) != 0) {
 544                 /* Save our path to enable re-open */
 545                 os_free(last_path);
 546                 last_path = os_strdup(path);
 547         }
 548
 549         out_file = fopen(path, "a");
 550         if (out_file == NULL) {
 551                 wpa_printf(MSG_ERROR, "wpa_debug_open_file: Failed to open "
 552                            "output file, using standard output");
 553                 return -1;
 554         }
 555 #ifndef _WIN32
 556         setvbuf(out_file, NULL, _IOLBF, 0);
 557 #endif /* _WIN32 */
 558 #else /* CONFIG_DEBUG_FILE */
 559         (void)path;
 560 #endif /* CONFIG_DEBUG_FILE */
 561         return 0;
 562 }
 563
 564
 565 void wpa_debug_close_file(void)
 566 {
 567 #ifdef CONFIG_DEBUG_FILE
 568         if (!out_file)
 569                 return;
 570         fclose(out_file);
 571         out_file = NULL;
 572         os_free(last_path);
 573         last_path = NULL;
 574 #endif /* CONFIG_DEBUG_FILE */
 575 }
 576
 577
 578 void wpa_debug_setup_stdout(void)
 579 {
 580 #ifndef _WIN32
 581         setvbuf(stdout, NULL, _IOLBF, 0);
 582 #endif /* _WIN32 */
 583 }
 584
 585 #endif /* CONFIG_NO_STDOUT_DEBUG */
 586
 587
 588 #ifndef CONFIG_NO_WPA_MSG
 589 static wpa_msg_cb_func wpa_msg_cb = NULL;
 590
 591 void wpa_msg_register_cb(wpa_msg_cb_func func)
 592 {
 593         wpa_msg_cb = func;
 594 }
 595
 596
 597 static wpa_msg_get_ifname_func wpa_msg_ifname_cb = NULL;
 598
 599 void wpa_msg_register_ifname_cb(wpa_msg_get_ifname_func func)
 600 {
 601         wpa_msg_ifname_cb = func;
 602 }
 603
 604
 605 void wpa_msg(void *ctx, int level, const char *fmt, ...)
 606 {
 607         va_list ap;
 608         char *buf;
 609         int buflen;
 610         int len;
 611         char prefix[130];
 612
 613         va_start(ap, fmt);
 614         buflen = vsnprintf(NULL, 0, fmt, ap) + 1;
 615         va_end(ap);
 616
 617         buf = os_malloc(buflen);
 618         if (buf == NULL) {
 619                 wpa_printf(MSG_ERROR, "wpa_msg: Failed to allocate message "
 620                            "buffer");
 621                 return;
 622         }
 623         va_start(ap, fmt);
 624         prefix[0] = '\0';
 625         if (wpa_msg_ifname_cb) {
 626                 const char *ifname = wpa_msg_ifname_cb(ctx);
 627                 if (ifname) {
 628                         int res = os_snprintf(prefix, sizeof(prefix), "%s: ",
 629                                               ifname);
 630                         if (os_snprintf_error(sizeof(prefix), res))
 631                                 prefix[0] = '\0';
 632                 }
 633         }
 634         len = vsnprintf(buf, buflen, fmt, ap);
 635         va_end(ap);
 636         wpa_printf(level, "%s%s", prefix, buf);
 637         if (wpa_msg_cb)
 638                 wpa_msg_cb(ctx, level, WPA_MSG_PER_INTERFACE, buf, len);
 639         bin_clear_free(buf, buflen);
 640 }
 641
 642
 643 void wpa_msg_ctrl(void *ctx, int level, const char *fmt, ...)
 644 {
 645         va_list ap;
 646         char *buf;
 647         int buflen;
 648         int len;
 649
 650         if (!wpa_msg_cb)
 651                 return;
 652
 653         va_start(ap, fmt);
 654         buflen = vsnprintf(NULL, 0, fmt, ap) + 1;
 655         va_end(ap);
 656
 657         buf = os_malloc(buflen);
 658         if (buf == NULL) {
 659                 wpa_printf(MSG_ERROR, "wpa_msg_ctrl: Failed to allocate "
 660                            "message buffer");
 661                 return;
 662         }
 663         va_start(ap, fmt);
 664         len = vsnprintf(buf, buflen, fmt, ap);
 665         va_end(ap);
 666         wpa_msg_cb(ctx, level, WPA_MSG_PER_INTERFACE, buf, len);
 667         bin_clear_free(buf, buflen);
 668 }
 669
 670
 671 void wpa_msg_global(void *ctx, int level, const char *fmt, ...)
 672 {
 673         va_list ap;
 674         char *buf;
 675         int buflen;
 676         int len;
 677
 678         va_start(ap, fmt);
 679         buflen = vsnprintf(NULL, 0, fmt, ap) + 1;
 680         va_end(ap);
 681
 682         buf = os_malloc(buflen);
 683         if (buf == NULL) {
 684                 wpa_printf(MSG_ERROR, "wpa_msg_global: Failed to allocate "
 685                            "message buffer");
 686                 return;
 687         }
 688         va_start(ap, fmt);
 689         len = vsnprintf(buf, buflen, fmt, ap);
 690         va_end(ap);
 691         wpa_printf(level, "%s", buf);
 692         if (wpa_msg_cb)
 693                 wpa_msg_cb(ctx, level, WPA_MSG_GLOBAL, buf, len);
 694         bin_clear_free(buf, buflen);
 695 }
 696
 697
 698 void wpa_msg_global_ctrl(void *ctx, int level, const char *fmt, ...)
 699 {
 700         va_list ap;
 701         char *buf;
 702         int buflen;
 703         int len;
 704
 705         if (!wpa_msg_cb)
 706                 return;
 707
 708         va_start(ap, fmt);
 709         buflen = vsnprintf(NULL, 0, fmt, ap) + 1;
 710         va_end(ap);
 711
 712         buf = os_malloc(buflen);
 713         if (buf == NULL) {
 714                 wpa_printf(MSG_ERROR,
 715                            "wpa_msg_global_ctrl: Failed to allocate message buffer");
 716                 return;
 717         }
 718         va_start(ap, fmt);
 719         len = vsnprintf(buf, buflen, fmt, ap);
 720         va_end(ap);
 721         wpa_msg_cb(ctx, level, WPA_MSG_GLOBAL, buf, len);
 722         bin_clear_free(buf, buflen);
 723 }
 724
 725
 726 void wpa_msg_no_global(void *ctx, int level, const char *fmt, ...)
 727 {
 728         va_list ap;
 729         char *buf;
 730         int buflen;
 731         int len;
 732
 733         va_start(ap, fmt);
 734         buflen = vsnprintf(NULL, 0, fmt, ap) + 1;
 735         va_end(ap);
 736
 737         buf = os_malloc(buflen);
 738         if (buf == NULL) {
 739                 wpa_printf(MSG_ERROR, "wpa_msg_no_global: Failed to allocate "
 740                            "message buffer");
 741                 return;
 742         }
 743         va_start(ap, fmt);
 744         len = vsnprintf(buf, buflen, fmt, ap);
 745         va_end(ap);
 746         wpa_printf(level, "%s", buf);
 747         if (wpa_msg_cb)
 748                 wpa_msg_cb(ctx, level, WPA_MSG_NO_GLOBAL, buf, len);
 749         bin_clear_free(buf, buflen);
 750 }
 751
 752
 753 void wpa_msg_global_only(void *ctx, int level, const char *fmt, ...)
 754 {
 755         va_list ap;
 756         char *buf;
 757         int buflen;
 758         int len;
 759
 760         va_start(ap, fmt);
 761         buflen = vsnprintf(NULL, 0, fmt, ap) + 1;
 762         va_end(ap);
 763
 764         buf = os_malloc(buflen);
 765         if (buf == NULL) {
 766                 wpa_printf(MSG_ERROR, "%s: Failed to allocate message buffer",
 767                            __func__);
 768                 return;
 769         }
 770         va_start(ap, fmt);
 771         len = vsnprintf(buf, buflen, fmt, ap);
 772         va_end(ap);
 773         wpa_printf(level, "%s", buf);
 774         if (wpa_msg_cb)
 775                 wpa_msg_cb(ctx, level, WPA_MSG_ONLY_GLOBAL, buf, len);
 776         os_free(buf);
 777 }
 778
 779 #endif /* CONFIG_NO_WPA_MSG */
 780
 781
 782 #ifndef CONFIG_NO_HOSTAPD_LOGGER
 783 static hostapd_logger_cb_func hostapd_logger_cb = NULL;
 784
 785 void hostapd_logger_register_cb(hostapd_logger_cb_func func)
 786 {
 787         hostapd_logger_cb = func;
 788 }
 789
 790
 791 void hostapd_logger(void *ctx, const u8 *addr, unsigned int module, int level,
 792                     const char *fmt, ...)
 793 {
 794         va_list ap;
 795         char *buf;
 796         int buflen;
 797         int len;
 798
 799         va_start(ap, fmt);
 800         buflen = vsnprintf(NULL, 0, fmt, ap) + 1;
 801         va_end(ap);
 802
 803         buf = os_malloc(buflen);
 804         if (buf == NULL) {
 805                 wpa_printf(MSG_ERROR, "hostapd_logger: Failed to allocate "
 806                            "message buffer");
 807                 return;
 808         }
 809         va_start(ap, fmt);
 810         len = vsnprintf(buf, buflen, fmt, ap);
 811         va_end(ap);
 812         if (hostapd_logger_cb)
 813                 hostapd_logger_cb(ctx, addr, module, level, buf, len);
 814         else if (addr)
 815                 wpa_printf(MSG_DEBUG, "hostapd_logger: STA " MACSTR " - %s",
 816                            MAC2STR(addr), buf);
 817         else
 818                 wpa_printf(MSG_DEBUG, "hostapd_logger: %s", buf);
 819         bin_clear_free(buf, buflen);
 820 }
 821 #endif /* CONFIG_NO_HOSTAPD_LOGGER */
 822
 823
 824 const char * debug_level_str(int level)
 825 {
 826         switch (level) {
 827         case MSG_EXCESSIVE:
 828                 return "EXCESSIVE";
 829         case MSG_MSGDUMP:
 830                 return "MSGDUMP";
 831         case MSG_DEBUG:
 832                 return "DEBUG";
 833         case MSG_INFO:
 834                 return "INFO";
 835         case MSG_WARNING:
 836                 return "WARNING";
 837         case MSG_ERROR:
 838                 return "ERROR";
 839         default:
 840                 return "?";
 841         }
 842 }
 843
 844
 845 int str_to_debug_level(const char *s)
 846 {
 847         if (os_strcasecmp(s, "EXCESSIVE") == 0)
 848                 return MSG_EXCESSIVE;
 849         if (os_strcasecmp(s, "MSGDUMP") == 0)
 850                 return MSG_MSGDUMP;
 851         if (os_strcasecmp(s, "DEBUG") == 0)
 852                 return MSG_DEBUG;
 853         if (os_strcasecmp(s, "INFO") == 0)
 854                 return MSG_INFO;
 855         if (os_strcasecmp(s, "WARNING") == 0)
 856                 return MSG_WARNING;
 857         if (os_strcasecmp(s, "ERROR") == 0)
 858                 return MSG_ERROR;
 859         return -1;
 860 }