LCOV - code coverage report
Current view: top level - src/utils - wpa_debug.c (source / functions) Hit Total Coverage
Test: wpa_supplicant/hostapd combined for hwsim test run 1422976643 Lines: 231 314 73.6 %
Date: 2015-02-03 Functions: 22 23 95.7 %

          Line data    Source code
       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     3621270 : void wpa_debug_print_timestamp(void)
      66             : {
      67             : #ifndef CONFIG_ANDROID_LOG
      68             :         struct os_time tv;
      69             : 
      70     3621270 :         if (!wpa_debug_timestamp)
      71     3621298 :                 return;
      72             : 
      73     3621242 :         os_get_time(&tv);
      74             : #ifdef CONFIG_DEBUG_FILE
      75     3621242 :         if (out_file) {
      76     3394789 :                 fprintf(out_file, "%ld.%06u: ", (long) tv.sec,
      77     3394789 :                         (unsigned int) tv.usec);
      78             :         } else
      79             : #endif /* CONFIG_DEBUG_FILE */
      80      226453 :         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           0 : int wpa_debug_open_linux_tracing(void)
     125             : {
     126             :         int mounts, trace_fd;
     127           0 :         char buf[4096] = {};
     128             :         ssize_t buflen;
     129           0 :         char *line, *tmp1, *path = NULL;
     130             : 
     131           0 :         mounts = open("/proc/mounts", O_RDONLY);
     132           0 :         if (mounts < 0) {
     133           0 :                 printf("no /proc/mounts\n");
     134           0 :                 return -1;
     135             :         }
     136             : 
     137           0 :         buflen = read(mounts, buf, sizeof(buf) - 1);
     138           0 :         close(mounts);
     139           0 :         if (buflen < 0) {
     140           0 :                 printf("failed to read /proc/mounts\n");
     141           0 :                 return -1;
     142             :         }
     143             : 
     144           0 :         line = strtok_r(buf, "\n", &tmp1);
     145           0 :         while (line) {
     146             :                 char *tmp2, *tmp_path, *fstype;
     147             :                 /* "<dev> <mountpoint> <fs type> ..." */
     148           0 :                 strtok_r(line, " ", &tmp2);
     149           0 :                 tmp_path = strtok_r(NULL, " ", &tmp2);
     150           0 :                 fstype = strtok_r(NULL, " ", &tmp2);
     151           0 :                 if (strcmp(fstype, "debugfs") == 0) {
     152           0 :                         path = tmp_path;
     153           0 :                         break;
     154             :                 }
     155             : 
     156           0 :                 line = strtok_r(NULL, "\n", &tmp1);
     157             :         }
     158             : 
     159           0 :         if (path == NULL) {
     160           0 :                 printf("debugfs mountpoint not found\n");
     161           0 :                 return -1;
     162             :         }
     163             : 
     164           0 :         snprintf(buf, sizeof(buf) - 1, "%s/tracing/trace_marker", path);
     165             : 
     166           0 :         trace_fd = open(buf, O_WRONLY);
     167           0 :         if (trace_fd < 0) {
     168           0 :                 printf("failed to open trace_marker file\n");
     169           0 :                 return -1;
     170             :         }
     171           0 :         wpa_debug_tracing_file = fdopen(trace_fd, "w");
     172           0 :         if (wpa_debug_tracing_file == NULL) {
     173           0 :                 close(trace_fd);
     174           0 :                 printf("failed to fdopen()\n");
     175           0 :                 return -1;
     176             :         }
     177             : 
     178           0 :         return 0;
     179             : }
     180             : 
     181             : 
     182          40 : void wpa_debug_close_linux_tracing(void)
     183             : {
     184          40 :         if (wpa_debug_tracing_file == NULL)
     185          80 :                 return;
     186           0 :         fclose(wpa_debug_tracing_file);
     187           0 :         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     3299080 : void wpa_printf(int level, const char *fmt, ...)
     205             : {
     206             :         va_list ap;
     207             : 
     208     3299080 :         va_start(ap, fmt);
     209     3299080 :         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     3138406 :                 wpa_debug_print_timestamp();
     220             : #ifdef CONFIG_DEBUG_FILE
     221     3138406 :                 if (out_file) {
     222     2938534 :                         vfprintf(out_file, fmt, ap);
     223     2938534 :                         fprintf(out_file, "\n");
     224             :                 } else {
     225             : #endif /* CONFIG_DEBUG_FILE */
     226      199872 :                 vprintf(fmt, ap);
     227      199872 :                 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     3299080 :         va_end(ap);
     237             : 
     238             : #ifdef CONFIG_DEBUG_LINUX_TRACING
     239     3299080 :         if (wpa_debug_tracing_file != NULL) {
     240           0 :                 va_start(ap, fmt);
     241           0 :                 fprintf(wpa_debug_tracing_file, WPAS_TRACE_PFX, level);
     242           0 :                 vfprintf(wpa_debug_tracing_file, fmt, ap);
     243           0 :                 fprintf(wpa_debug_tracing_file, "\n");
     244           0 :                 fflush(wpa_debug_tracing_file);
     245           0 :                 va_end(ap);
     246             :         }
     247             : #endif /* CONFIG_DEBUG_LINUX_TRACING */
     248     3299080 : }
     249             : 
     250             : 
     251      342554 : 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      342554 :         if (wpa_debug_tracing_file != NULL) {
     258           0 :                 fprintf(wpa_debug_tracing_file,
     259             :                         WPAS_TRACE_PFX "%s - hexdump(len=%lu):",
     260             :                         level, title, (unsigned long) len);
     261           0 :                 if (buf == NULL) {
     262           0 :                         fprintf(wpa_debug_tracing_file, " [NULL]\n");
     263           0 :                 } else if (!show) {
     264           0 :                         fprintf(wpa_debug_tracing_file, " [REMOVED]\n");
     265             :                 } else {
     266           0 :                         for (i = 0; i < len; i++)
     267           0 :                                 fprintf(wpa_debug_tracing_file,
     268           0 :                                         " %02x", buf[i]);
     269             :                 }
     270           0 :                 fflush(wpa_debug_tracing_file);
     271             :         }
     272             : #endif /* CONFIG_DEBUG_LINUX_TRACING */
     273             : 
     274      342554 :         if (level < wpa_debug_level)
     275      348313 :                 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             :                 os_free(strbuf);
     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             :                 os_free(strbuf);
     343             :                 return;
     344             :         }
     345             : #endif /* CONFIG_DEBUG_SYSLOG */
     346      336795 :         wpa_debug_print_timestamp();
     347             : #ifdef CONFIG_DEBUG_FILE
     348      336795 :         if (out_file) {
     349      312605 :                 fprintf(out_file, "%s - hexdump(len=%lu):",
     350             :                         title, (unsigned long) len);
     351      312605 :                 if (buf == NULL) {
     352       10889 :                         fprintf(out_file, " [NULL]");
     353      301716 :                 } else if (show) {
     354    15994084 :                         for (i = 0; i < len; i++)
     355    15692368 :                                 fprintf(out_file, " %02x", buf[i]);
     356             :                 } else {
     357           0 :                         fprintf(out_file, " [REMOVED]");
     358             :                 }
     359      312605 :                 fprintf(out_file, "\n");
     360             :         } else {
     361             : #endif /* CONFIG_DEBUG_FILE */
     362       24190 :         printf("%s - hexdump(len=%lu):", title, (unsigned long) len);
     363       24190 :         if (buf == NULL) {
     364         173 :                 printf(" [NULL]");
     365       24017 :         } else if (show) {
     366     2512820 :                 for (i = 0; i < len; i++)
     367     2488803 :                         printf(" %02x", buf[i]);
     368             :         } else {
     369           0 :                 printf(" [REMOVED]");
     370             :         }
     371       24190 :         printf("\n");
     372             : #ifdef CONFIG_DEBUG_FILE
     373             :         }
     374             : #endif /* CONFIG_DEBUG_FILE */
     375             : #endif /* CONFIG_ANDROID_LOG */
     376             : }
     377             : 
     378      272053 : void wpa_hexdump(int level, const char *title, const void *buf, size_t len)
     379             : {
     380      272053 :         _wpa_hexdump(level, title, buf, len, 1);
     381      272053 : }
     382             : 
     383             : 
     384       70501 : void wpa_hexdump_key(int level, const char *title, const void *buf, size_t len)
     385             : {
     386       70501 :         _wpa_hexdump(level, title, buf, len, wpa_debug_show_keys);
     387       70501 : }
     388             : 
     389             : 
     390       73816 : 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       73816 :         const u8 *pos = buf;
     395       73816 :         const size_t line_len = 16;
     396             : 
     397             : #ifdef CONFIG_DEBUG_LINUX_TRACING
     398       73816 :         if (wpa_debug_tracing_file != NULL) {
     399           0 :                 fprintf(wpa_debug_tracing_file,
     400             :                         WPAS_TRACE_PFX "%s - hexdump_ascii(len=%lu):",
     401             :                         level, title, (unsigned long) len);
     402           0 :                 if (buf == NULL) {
     403           0 :                         fprintf(wpa_debug_tracing_file, " [NULL]\n");
     404           0 :                 } else if (!show) {
     405           0 :                         fprintf(wpa_debug_tracing_file, " [REMOVED]\n");
     406             :                 } else {
     407             :                         /* can do ascii processing in userspace */
     408           0 :                         for (i = 0; i < len; i++)
     409           0 :                                 fprintf(wpa_debug_tracing_file,
     410           0 :                                         " %02x", pos[i]);
     411             :                 }
     412           0 :                 fflush(wpa_debug_tracing_file);
     413             :         }
     414             : #endif /* CONFIG_DEBUG_LINUX_TRACING */
     415             : 
     416       73816 :         if (level < wpa_debug_level)
     417        3157 :                 return;
     418             : #ifdef CONFIG_ANDROID_LOG
     419             :         _wpa_hexdump(level, title, buf, len, show);
     420             : #else /* CONFIG_ANDROID_LOG */
     421       70659 :         wpa_debug_print_timestamp();
     422             : #ifdef CONFIG_DEBUG_FILE
     423       70659 :         if (out_file) {
     424       68248 :                 if (!show) {
     425           0 :                         fprintf(out_file,
     426             :                                 "%s - hexdump_ascii(len=%lu): [REMOVED]\n",
     427             :                                 title, (unsigned long) len);
     428           0 :                         return;
     429             :                 }
     430       68248 :                 if (buf == NULL) {
     431        1694 :                         fprintf(out_file,
     432             :                                 "%s - hexdump_ascii(len=%lu): [NULL]\n",
     433             :                                 title, (unsigned long) len);
     434        1694 :                         return;
     435             :                 }
     436       66554 :                 fprintf(out_file, "%s - hexdump_ascii(len=%lu):\n",
     437             :                         title, (unsigned long) len);
     438      232944 :                 while (len) {
     439       99836 :                         llen = len > line_len ? line_len : len;
     440       99836 :                         fprintf(out_file, "    ");
     441     1161711 :                         for (i = 0; i < llen; i++)
     442     1061875 :                                 fprintf(out_file, " %02x", pos[i]);
     443      635337 :                         for (i = llen; i < line_len; i++)
     444      535501 :                                 fprintf(out_file, "   ");
     445       99836 :                         fprintf(out_file, "   ");
     446     1161711 :                         for (i = 0; i < llen; i++) {
     447     1061875 :                                 if (isprint(pos[i]))
     448     1048234 :                                         fprintf(out_file, "%c", pos[i]);
     449             :                                 else
     450       13641 :                                         fprintf(out_file, "_");
     451             :                         }
     452      635337 :                         for (i = llen; i < line_len; i++)
     453      535501 :                                 fprintf(out_file, " ");
     454       99836 :                         fprintf(out_file, "\n");
     455       99836 :                         pos += llen;
     456       99836 :                         len -= llen;
     457             :                 }
     458             :         } else {
     459             : #endif /* CONFIG_DEBUG_FILE */
     460        2411 :         if (!show) {
     461           0 :                 printf("%s - hexdump_ascii(len=%lu): [REMOVED]\n",
     462             :                        title, (unsigned long) len);
     463           0 :                 return;
     464             :         }
     465        2411 :         if (buf == NULL) {
     466           0 :                 printf("%s - hexdump_ascii(len=%lu): [NULL]\n",
     467             :                        title, (unsigned long) len);
     468           0 :                 return;
     469             :         }
     470        2411 :         printf("%s - hexdump_ascii(len=%lu):\n", title, (unsigned long) len);
     471        8777 :         while (len) {
     472        3955 :                 llen = len > line_len ? line_len : len;
     473        3955 :                 printf("    ");
     474       47994 :                 for (i = 0; i < llen; i++)
     475       44039 :                         printf(" %02x", pos[i]);
     476       23196 :                 for (i = llen; i < line_len; i++)
     477       19241 :                         printf("   ");
     478        3955 :                 printf("   ");
     479       47994 :                 for (i = 0; i < llen; i++) {
     480       44039 :                         if (isprint(pos[i]))
     481       44026 :                                 printf("%c", pos[i]);
     482             :                         else
     483          13 :                                 printf("_");
     484             :                 }
     485       23196 :                 for (i = llen; i < line_len; i++)
     486       19241 :                         printf(" ");
     487        3955 :                 printf("\n");
     488        3955 :                 pos += llen;
     489        3955 :                 len -= llen;
     490             :         }
     491             : #ifdef CONFIG_DEBUG_FILE
     492             :         }
     493             : #endif /* CONFIG_DEBUG_FILE */
     494             : #endif /* CONFIG_ANDROID_LOG */
     495             : }
     496             : 
     497             : 
     498       62866 : void wpa_hexdump_ascii(int level, const char *title, const void *buf,
     499             :                        size_t len)
     500             : {
     501       62866 :         _wpa_hexdump_ascii(level, title, buf, len, 1);
     502       62866 : }
     503             : 
     504             : 
     505       10950 : void wpa_hexdump_ascii_key(int level, const char *title, const void *buf,
     506             :                            size_t len)
     507             : {
     508       10950 :         _wpa_hexdump_ascii(level, title, buf, len, wpa_debug_show_keys);
     509       10950 : }
     510             : 
     511             : 
     512             : #ifdef CONFIG_DEBUG_FILE
     513             : static char *last_path = NULL;
     514             : #endif /* CONFIG_DEBUG_FILE */
     515             : 
     516        5232 : int wpa_debug_reopen_file(void)
     517             : {
     518             : #ifdef CONFIG_DEBUG_FILE
     519             :         int rv;
     520        5232 :         if (last_path) {
     521        5232 :                 char *tmp = os_strdup(last_path);
     522        5232 :                 wpa_debug_close_file();
     523        5232 :                 rv = wpa_debug_open_file(tmp);
     524        5232 :                 os_free(tmp);
     525             :         } else {
     526           0 :                 wpa_printf(MSG_ERROR, "Last-path was not set, cannot "
     527             :                            "re-open log file.");
     528           0 :                 rv = -1;
     529             :         }
     530        5232 :         return rv;
     531             : #else /* CONFIG_DEBUG_FILE */
     532             :         return 0;
     533             : #endif /* CONFIG_DEBUG_FILE */
     534             : }
     535             : 
     536             : 
     537        5257 : int wpa_debug_open_file(const char *path)
     538             : {
     539             : #ifdef CONFIG_DEBUG_FILE
     540        5257 :         if (!path)
     541           0 :                 return 0;
     542             : 
     543        5257 :         if (last_path == NULL || os_strcmp(last_path, path) != 0) {
     544             :                 /* Save our path to enable re-open */
     545        5257 :                 os_free(last_path);
     546        5257 :                 last_path = os_strdup(path);
     547             :         }
     548             : 
     549        5257 :         out_file = fopen(path, "a");
     550        5257 :         if (out_file == NULL) {
     551           0 :                 wpa_printf(MSG_ERROR, "wpa_debug_open_file: Failed to open "
     552             :                            "output file, using standard output");
     553           0 :                 return -1;
     554             :         }
     555             : #ifndef _WIN32
     556        5257 :         setvbuf(out_file, NULL, _IOLBF, 0);
     557             : #endif /* _WIN32 */
     558             : #else /* CONFIG_DEBUG_FILE */
     559             :         (void)path;
     560             : #endif /* CONFIG_DEBUG_FILE */
     561        5257 :         return 0;
     562             : }
     563             : 
     564             : 
     565        5267 : void wpa_debug_close_file(void)
     566             : {
     567             : #ifdef CONFIG_DEBUG_FILE
     568        5267 :         if (!out_file)
     569        5277 :                 return;
     570        5257 :         fclose(out_file);
     571        5257 :         out_file = NULL;
     572        5257 :         os_free(last_path);
     573        5257 :         last_path = NULL;
     574             : #endif /* CONFIG_DEBUG_FILE */
     575             : }
     576             : 
     577             : 
     578          15 : void wpa_debug_setup_stdout(void)
     579             : {
     580             : #ifndef _WIN32
     581          15 :         setvbuf(stdout, NULL, _IOLBF, 0);
     582             : #endif /* _WIN32 */
     583          15 : }
     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        1254 : void wpa_msg_register_cb(wpa_msg_cb_func func)
     592             : {
     593        1254 :         wpa_msg_cb = func;
     594        1254 : }
     595             : 
     596             : 
     597             : static wpa_msg_get_ifname_func wpa_msg_ifname_cb = NULL;
     598             : 
     599          40 : void wpa_msg_register_ifname_cb(wpa_msg_get_ifname_func func)
     600             : {
     601          40 :         wpa_msg_ifname_cb = func;
     602          40 : }
     603             : 
     604             : 
     605      438205 : 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      438205 :         va_start(ap, fmt);
     614      438205 :         buflen = vsnprintf(NULL, 0, fmt, ap) + 1;
     615      438205 :         va_end(ap);
     616             : 
     617      438205 :         buf = os_malloc(buflen);
     618      438205 :         if (buf == NULL) {
     619          69 :                 wpa_printf(MSG_ERROR, "wpa_msg: Failed to allocate message "
     620             :                            "buffer");
     621      438274 :                 return;
     622             :         }
     623      438136 :         va_start(ap, fmt);
     624      438136 :         prefix[0] = '\0';
     625      438136 :         if (wpa_msg_ifname_cb) {
     626      438136 :                 const char *ifname = wpa_msg_ifname_cb(ctx);
     627      438136 :                 if (ifname) {
     628      437965 :                         int res = os_snprintf(prefix, sizeof(prefix), "%s: ",
     629             :                                               ifname);
     630      437965 :                         if (os_snprintf_error(sizeof(prefix), res))
     631           0 :                                 prefix[0] = '\0';
     632             :                 }
     633             :         }
     634      438136 :         len = vsnprintf(buf, buflen, fmt, ap);
     635      438136 :         va_end(ap);
     636      438136 :         wpa_printf(level, "%s%s", prefix, buf);
     637      438136 :         if (wpa_msg_cb)
     638      438136 :                 wpa_msg_cb(ctx, level, 0, buf, len);
     639      438136 :         os_free(buf);
     640             : }
     641             : 
     642             : 
     643       13986 : 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       13986 :         if (!wpa_msg_cb)
     651           0 :                 return;
     652             : 
     653       13986 :         va_start(ap, fmt);
     654       13986 :         buflen = vsnprintf(NULL, 0, fmt, ap) + 1;
     655       13986 :         va_end(ap);
     656             : 
     657       13986 :         buf = os_malloc(buflen);
     658       13986 :         if (buf == NULL) {
     659           0 :                 wpa_printf(MSG_ERROR, "wpa_msg_ctrl: Failed to allocate "
     660             :                            "message buffer");
     661           0 :                 return;
     662             :         }
     663       13986 :         va_start(ap, fmt);
     664       13986 :         len = vsnprintf(buf, buflen, fmt, ap);
     665       13986 :         va_end(ap);
     666       13986 :         wpa_msg_cb(ctx, level, 0, buf, len);
     667       13986 :         os_free(buf);
     668             : }
     669             : 
     670             : 
     671       90291 : 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       90291 :         va_start(ap, fmt);
     679       90291 :         buflen = vsnprintf(NULL, 0, fmt, ap) + 1;
     680       90291 :         va_end(ap);
     681             : 
     682       90291 :         buf = os_malloc(buflen);
     683       90291 :         if (buf == NULL) {
     684           0 :                 wpa_printf(MSG_ERROR, "wpa_msg_global: Failed to allocate "
     685             :                            "message buffer");
     686       90291 :                 return;
     687             :         }
     688       90291 :         va_start(ap, fmt);
     689       90291 :         len = vsnprintf(buf, buflen, fmt, ap);
     690       90291 :         va_end(ap);
     691       90291 :         wpa_printf(level, "%s", buf);
     692       90291 :         if (wpa_msg_cb)
     693       90291 :                 wpa_msg_cb(ctx, level, 1, buf, len);
     694       90291 :         os_free(buf);
     695             : }
     696             : 
     697             : 
     698         402 : 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         402 :         if (!wpa_msg_cb)
     706           0 :                 return;
     707             : 
     708         402 :         va_start(ap, fmt);
     709         402 :         buflen = vsnprintf(NULL, 0, fmt, ap) + 1;
     710         402 :         va_end(ap);
     711             : 
     712         402 :         buf = os_malloc(buflen);
     713         402 :         if (buf == NULL) {
     714           0 :                 wpa_printf(MSG_ERROR,
     715             :                            "wpa_msg_global_ctrl: Failed to allocate message buffer");
     716           0 :                 return;
     717             :         }
     718         402 :         va_start(ap, fmt);
     719         402 :         len = vsnprintf(buf, buflen, fmt, ap);
     720         402 :         va_end(ap);
     721         402 :         wpa_msg_cb(ctx, level, 1, buf, len);
     722         402 :         os_free(buf);
     723             : }
     724             : 
     725             : 
     726          40 : 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          40 :         va_start(ap, fmt);
     734          40 :         buflen = vsnprintf(NULL, 0, fmt, ap) + 1;
     735          40 :         va_end(ap);
     736             : 
     737          40 :         buf = os_malloc(buflen);
     738          40 :         if (buf == NULL) {
     739           0 :                 wpa_printf(MSG_ERROR, "wpa_msg_no_global: Failed to allocate "
     740             :                            "message buffer");
     741          40 :                 return;
     742             :         }
     743          40 :         va_start(ap, fmt);
     744          40 :         len = vsnprintf(buf, buflen, fmt, ap);
     745          40 :         va_end(ap);
     746          40 :         wpa_printf(level, "%s", buf);
     747          40 :         if (wpa_msg_cb)
     748          40 :                 wpa_msg_cb(ctx, level, 2, buf, len);
     749          40 :         os_free(buf);
     750             : }
     751             : 
     752             : #endif /* CONFIG_NO_WPA_MSG */
     753             : 
     754             : 
     755             : #ifndef CONFIG_NO_HOSTAPD_LOGGER
     756             : static hostapd_logger_cb_func hostapd_logger_cb = NULL;
     757             : 
     758          10 : void hostapd_logger_register_cb(hostapd_logger_cb_func func)
     759             : {
     760          10 :         hostapd_logger_cb = func;
     761          10 : }
     762             : 
     763             : 
     764       85427 : void hostapd_logger(void *ctx, const u8 *addr, unsigned int module, int level,
     765             :                     const char *fmt, ...)
     766             : {
     767             :         va_list ap;
     768             :         char *buf;
     769             :         int buflen;
     770             :         int len;
     771             : 
     772       85427 :         va_start(ap, fmt);
     773       85427 :         buflen = vsnprintf(NULL, 0, fmt, ap) + 1;
     774       85427 :         va_end(ap);
     775             : 
     776       85427 :         buf = os_malloc(buflen);
     777       85427 :         if (buf == NULL) {
     778          39 :                 wpa_printf(MSG_ERROR, "hostapd_logger: Failed to allocate "
     779             :                            "message buffer");
     780       85466 :                 return;
     781             :         }
     782       85388 :         va_start(ap, fmt);
     783       85388 :         len = vsnprintf(buf, buflen, fmt, ap);
     784       85388 :         va_end(ap);
     785       85388 :         if (hostapd_logger_cb)
     786       76144 :                 hostapd_logger_cb(ctx, addr, module, level, buf, len);
     787        9244 :         else if (addr)
     788       55458 :                 wpa_printf(MSG_DEBUG, "hostapd_logger: STA " MACSTR " - %s",
     789       55458 :                            MAC2STR(addr), buf);
     790             :         else
     791           1 :                 wpa_printf(MSG_DEBUG, "hostapd_logger: %s", buf);
     792       85388 :         os_free(buf);
     793             : }
     794             : #endif /* CONFIG_NO_HOSTAPD_LOGGER */

Generated by: LCOV version 1.10