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