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
wpa_to_android_level(int level)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
wpa_debug_print_timestamp(void)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
wpa_debug_open_syslog(void)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
wpa_debug_close_syslog(void)97 void wpa_debug_close_syslog(void)
98 {
99 if (wpa_debug_syslog)
100 closelog();
101 }
102
103
syslog_priority(int level)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
wpa_debug_open_linux_tracing(void)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 (fstype && 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
wpa_debug_close_linux_tracing(void)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 */
wpa_printf(int level,const char * fmt,...)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
_wpa_hexdump(int level,const char * title,const u8 * buf,size_t len,int show)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
wpa_hexdump(int level,const char * title,const void * buf,size_t len)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
wpa_hexdump_key(int level,const char * title,const void * buf,size_t len)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
_wpa_hexdump_ascii(int level,const char * title,const void * buf,size_t len,int show)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
wpa_hexdump_ascii(int level,const char * title,const void * buf,size_t len)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
wpa_hexdump_ascii_key(int level,const char * title,const void * buf,size_t len)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
wpa_debug_reopen_file(void)516 int wpa_debug_reopen_file(void)
517 {
518 #ifdef CONFIG_DEBUG_FILE
519 int rv;
520 char *tmp;
521
522 if (!last_path)
523 return 0; /* logfile not used */
524
525 tmp = os_strdup(last_path);
526 if (!tmp)
527 return -1;
528
529 wpa_debug_close_file();
530 rv = wpa_debug_open_file(tmp);
531 os_free(tmp);
532 return rv;
533 #else /* CONFIG_DEBUG_FILE */
534 return 0;
535 #endif /* CONFIG_DEBUG_FILE */
536 }
537
538
wpa_debug_open_file(const char * path)539 int wpa_debug_open_file(const char *path)
540 {
541 #ifdef CONFIG_DEBUG_FILE
542 if (!path)
543 return 0;
544
545 if (last_path == NULL || os_strcmp(last_path, path) != 0) {
546 /* Save our path to enable re-open */
547 os_free(last_path);
548 last_path = os_strdup(path);
549 }
550
551 out_file = fopen(path, "a");
552 if (out_file == NULL) {
553 wpa_printf(MSG_ERROR, "wpa_debug_open_file: Failed to open "
554 "output file, using standard output");
555 return -1;
556 }
557 #ifndef _WIN32
558 setvbuf(out_file, NULL, _IOLBF, 0);
559 #endif /* _WIN32 */
560 #else /* CONFIG_DEBUG_FILE */
561 (void)path;
562 #endif /* CONFIG_DEBUG_FILE */
563 return 0;
564 }
565
566
wpa_debug_close_file(void)567 void wpa_debug_close_file(void)
568 {
569 #ifdef CONFIG_DEBUG_FILE
570 if (!out_file)
571 return;
572 fclose(out_file);
573 out_file = NULL;
574 os_free(last_path);
575 last_path = NULL;
576 #endif /* CONFIG_DEBUG_FILE */
577 }
578
579
wpa_debug_setup_stdout(void)580 void wpa_debug_setup_stdout(void)
581 {
582 #ifndef _WIN32
583 setvbuf(stdout, NULL, _IOLBF, 0);
584 #endif /* _WIN32 */
585 }
586
587 #endif /* CONFIG_NO_STDOUT_DEBUG */
588
589
590 #ifndef CONFIG_NO_WPA_MSG
591 static wpa_msg_cb_func wpa_msg_cb = NULL;
592
wpa_msg_register_cb(wpa_msg_cb_func func)593 void wpa_msg_register_cb(wpa_msg_cb_func func)
594 {
595 wpa_msg_cb = func;
596 }
597
598
599 static wpa_msg_get_ifname_func wpa_msg_ifname_cb = NULL;
600
wpa_msg_register_ifname_cb(wpa_msg_get_ifname_func func)601 void wpa_msg_register_ifname_cb(wpa_msg_get_ifname_func func)
602 {
603 wpa_msg_ifname_cb = func;
604 }
605
606
wpa_msg(void * ctx,int level,const char * fmt,...)607 void wpa_msg(void *ctx, int level, const char *fmt, ...)
608 {
609 va_list ap;
610 char *buf;
611 int buflen;
612 int len;
613 char prefix[130];
614
615 va_start(ap, fmt);
616 buflen = vsnprintf(NULL, 0, fmt, ap) + 1;
617 va_end(ap);
618
619 buf = os_malloc(buflen);
620 if (buf == NULL) {
621 wpa_printf(MSG_ERROR, "wpa_msg: Failed to allocate message "
622 "buffer");
623 return;
624 }
625 va_start(ap, fmt);
626 prefix[0] = '\0';
627 if (wpa_msg_ifname_cb) {
628 const char *ifname = wpa_msg_ifname_cb(ctx);
629 if (ifname) {
630 int res = os_snprintf(prefix, sizeof(prefix), "%s: ",
631 ifname);
632 if (os_snprintf_error(sizeof(prefix), res))
633 prefix[0] = '\0';
634 }
635 }
636 len = vsnprintf(buf, buflen, fmt, ap);
637 va_end(ap);
638 wpa_printf(level, "%s%s", prefix, buf);
639 if (wpa_msg_cb)
640 wpa_msg_cb(ctx, level, WPA_MSG_PER_INTERFACE, buf, len);
641 bin_clear_free(buf, buflen);
642 }
643
644
wpa_msg_ctrl(void * ctx,int level,const char * fmt,...)645 void wpa_msg_ctrl(void *ctx, int level, const char *fmt, ...)
646 {
647 va_list ap;
648 char *buf;
649 int buflen;
650 int len;
651
652 if (!wpa_msg_cb)
653 return;
654
655 va_start(ap, fmt);
656 buflen = vsnprintf(NULL, 0, fmt, ap) + 1;
657 va_end(ap);
658
659 buf = os_malloc(buflen);
660 if (buf == NULL) {
661 wpa_printf(MSG_ERROR, "wpa_msg_ctrl: Failed to allocate "
662 "message buffer");
663 return;
664 }
665 va_start(ap, fmt);
666 len = vsnprintf(buf, buflen, fmt, ap);
667 va_end(ap);
668 wpa_msg_cb(ctx, level, WPA_MSG_PER_INTERFACE, buf, len);
669 bin_clear_free(buf, buflen);
670 }
671
672
wpa_msg_global(void * ctx,int level,const char * fmt,...)673 void wpa_msg_global(void *ctx, int level, const char *fmt, ...)
674 {
675 va_list ap;
676 char *buf;
677 int buflen;
678 int len;
679
680 va_start(ap, fmt);
681 buflen = vsnprintf(NULL, 0, fmt, ap) + 1;
682 va_end(ap);
683
684 buf = os_malloc(buflen);
685 if (buf == NULL) {
686 wpa_printf(MSG_ERROR, "wpa_msg_global: Failed to allocate "
687 "message buffer");
688 return;
689 }
690 va_start(ap, fmt);
691 len = vsnprintf(buf, buflen, fmt, ap);
692 va_end(ap);
693 wpa_printf(level, "%s", buf);
694 if (wpa_msg_cb)
695 wpa_msg_cb(ctx, level, WPA_MSG_GLOBAL, buf, len);
696 bin_clear_free(buf, buflen);
697 }
698
699
wpa_msg_global_ctrl(void * ctx,int level,const char * fmt,...)700 void wpa_msg_global_ctrl(void *ctx, int level, const char *fmt, ...)
701 {
702 va_list ap;
703 char *buf;
704 int buflen;
705 int len;
706
707 if (!wpa_msg_cb)
708 return;
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,
717 "wpa_msg_global_ctrl: Failed to allocate message buffer");
718 return;
719 }
720 va_start(ap, fmt);
721 len = vsnprintf(buf, buflen, fmt, ap);
722 va_end(ap);
723 wpa_msg_cb(ctx, level, WPA_MSG_GLOBAL, buf, len);
724 bin_clear_free(buf, buflen);
725 }
726
727
wpa_msg_no_global(void * ctx,int level,const char * fmt,...)728 void wpa_msg_no_global(void *ctx, int level, const char *fmt, ...)
729 {
730 va_list ap;
731 char *buf;
732 int buflen;
733 int len;
734
735 va_start(ap, fmt);
736 buflen = vsnprintf(NULL, 0, fmt, ap) + 1;
737 va_end(ap);
738
739 buf = os_malloc(buflen);
740 if (buf == NULL) {
741 wpa_printf(MSG_ERROR, "wpa_msg_no_global: Failed to allocate "
742 "message buffer");
743 return;
744 }
745 va_start(ap, fmt);
746 len = vsnprintf(buf, buflen, fmt, ap);
747 va_end(ap);
748 wpa_printf(level, "%s", buf);
749 if (wpa_msg_cb)
750 wpa_msg_cb(ctx, level, WPA_MSG_NO_GLOBAL, buf, len);
751 bin_clear_free(buf, buflen);
752 }
753
754
wpa_msg_global_only(void * ctx,int level,const char * fmt,...)755 void wpa_msg_global_only(void *ctx, int level, const char *fmt, ...)
756 {
757 va_list ap;
758 char *buf;
759 int buflen;
760 int len;
761
762 va_start(ap, fmt);
763 buflen = vsnprintf(NULL, 0, fmt, ap) + 1;
764 va_end(ap);
765
766 buf = os_malloc(buflen);
767 if (buf == NULL) {
768 wpa_printf(MSG_ERROR, "%s: Failed to allocate message buffer",
769 __func__);
770 return;
771 }
772 va_start(ap, fmt);
773 len = vsnprintf(buf, buflen, fmt, ap);
774 va_end(ap);
775 wpa_printf(level, "%s", buf);
776 if (wpa_msg_cb)
777 wpa_msg_cb(ctx, level, WPA_MSG_ONLY_GLOBAL, buf, len);
778 os_free(buf);
779 }
780
781 #endif /* CONFIG_NO_WPA_MSG */
782
783
784 #ifndef CONFIG_NO_HOSTAPD_LOGGER
785 static hostapd_logger_cb_func hostapd_logger_cb = NULL;
786
hostapd_logger_register_cb(hostapd_logger_cb_func func)787 void hostapd_logger_register_cb(hostapd_logger_cb_func func)
788 {
789 hostapd_logger_cb = func;
790 }
791
792
hostapd_logger(void * ctx,const u8 * addr,unsigned int module,int level,const char * fmt,...)793 void hostapd_logger(void *ctx, const u8 *addr, unsigned int module, int level,
794 const char *fmt, ...)
795 {
796 va_list ap;
797 char *buf;
798 int buflen;
799 int len;
800
801 va_start(ap, fmt);
802 buflen = vsnprintf(NULL, 0, fmt, ap) + 1;
803 va_end(ap);
804
805 buf = os_malloc(buflen);
806 if (buf == NULL) {
807 wpa_printf(MSG_ERROR, "hostapd_logger: Failed to allocate "
808 "message buffer");
809 return;
810 }
811 va_start(ap, fmt);
812 len = vsnprintf(buf, buflen, fmt, ap);
813 va_end(ap);
814 if (hostapd_logger_cb)
815 hostapd_logger_cb(ctx, addr, module, level, buf, len);
816 else if (addr)
817 wpa_printf(MSG_DEBUG, "hostapd_logger: STA " MACSTR " - %s",
818 MAC2STR(addr), buf);
819 else
820 wpa_printf(MSG_DEBUG, "hostapd_logger: %s", buf);
821 bin_clear_free(buf, buflen);
822 }
823 #endif /* CONFIG_NO_HOSTAPD_LOGGER */
824
825
debug_level_str(int level)826 const char * debug_level_str(int level)
827 {
828 switch (level) {
829 case MSG_EXCESSIVE:
830 return "EXCESSIVE";
831 case MSG_MSGDUMP:
832 return "MSGDUMP";
833 case MSG_DEBUG:
834 return "DEBUG";
835 case MSG_INFO:
836 return "INFO";
837 case MSG_WARNING:
838 return "WARNING";
839 case MSG_ERROR:
840 return "ERROR";
841 default:
842 return "?";
843 }
844 }
845
846
str_to_debug_level(const char * s)847 int str_to_debug_level(const char *s)
848 {
849 if (os_strcasecmp(s, "EXCESSIVE") == 0)
850 return MSG_EXCESSIVE;
851 if (os_strcasecmp(s, "MSGDUMP") == 0)
852 return MSG_MSGDUMP;
853 if (os_strcasecmp(s, "DEBUG") == 0)
854 return MSG_DEBUG;
855 if (os_strcasecmp(s, "INFO") == 0)
856 return MSG_INFO;
857 if (os_strcasecmp(s, "WARNING") == 0)
858 return MSG_WARNING;
859 if (os_strcasecmp(s, "ERROR") == 0)
860 return MSG_ERROR;
861 return -1;
862 }
863