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 6008844 : void wpa_debug_print_timestamp(void)
66 : {
67 : #ifndef CONFIG_ANDROID_LOG
68 : struct os_time tv;
69 :
70 6008844 : if (!wpa_debug_timestamp)
71 6013126 : return;
72 :
73 6004562 : os_get_time(&tv);
74 : #ifdef CONFIG_DEBUG_FILE
75 6004562 : if (out_file) {
76 5747150 : fprintf(out_file, "%ld.%06u: ", (long) tv.sec,
77 5747150 : (unsigned int) tv.usec);
78 : } else
79 : #endif /* CONFIG_DEBUG_FILE */
80 257412 : 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 1 : int wpa_debug_open_linux_tracing(void)
125 : {
126 : int mounts, trace_fd;
127 1 : char buf[4096] = {};
128 : ssize_t buflen;
129 1 : char *line, *tmp1, *path = NULL;
130 :
131 1 : mounts = open("/proc/mounts", O_RDONLY);
132 1 : if (mounts < 0) {
133 0 : printf("no /proc/mounts\n");
134 0 : return -1;
135 : }
136 :
137 1 : buflen = read(mounts, buf, sizeof(buf) - 1);
138 1 : close(mounts);
139 1 : if (buflen < 0) {
140 0 : printf("failed to read /proc/mounts\n");
141 0 : return -1;
142 : }
143 :
144 1 : line = strtok_r(buf, "\n", &tmp1);
145 9 : while (line) {
146 : char *tmp2, *tmp_path, *fstype;
147 : /* "<dev> <mountpoint> <fs type> ..." */
148 8 : strtok_r(line, " ", &tmp2);
149 8 : tmp_path = strtok_r(NULL, " ", &tmp2);
150 8 : fstype = strtok_r(NULL, " ", &tmp2);
151 8 : if (strcmp(fstype, "debugfs") == 0) {
152 1 : path = tmp_path;
153 1 : break;
154 : }
155 :
156 7 : line = strtok_r(NULL, "\n", &tmp1);
157 : }
158 :
159 1 : if (path == NULL) {
160 0 : printf("debugfs mountpoint not found\n");
161 0 : return -1;
162 : }
163 :
164 1 : snprintf(buf, sizeof(buf) - 1, "%s/tracing/trace_marker", path);
165 :
166 1 : trace_fd = open(buf, O_WRONLY);
167 1 : if (trace_fd < 0) {
168 0 : printf("failed to open trace_marker file\n");
169 0 : return -1;
170 : }
171 1 : wpa_debug_tracing_file = fdopen(trace_fd, "w");
172 1 : 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 1 : return 0;
179 : }
180 :
181 :
182 74 : void wpa_debug_close_linux_tracing(void)
183 : {
184 74 : if (wpa_debug_tracing_file == NULL)
185 147 : return;
186 1 : fclose(wpa_debug_tracing_file);
187 1 : 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 5716867 : void wpa_printf(int level, const char *fmt, ...)
205 : {
206 : va_list ap;
207 :
208 5716867 : va_start(ap, fmt);
209 5716867 : 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 5276490 : wpa_debug_print_timestamp();
220 : #ifdef CONFIG_DEBUG_FILE
221 5276490 : if (out_file) {
222 5049230 : vfprintf(out_file, fmt, ap);
223 5049230 : fprintf(out_file, "\n");
224 : } else {
225 : #endif /* CONFIG_DEBUG_FILE */
226 227260 : vprintf(fmt, ap);
227 227260 : 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 5716867 : va_end(ap);
237 :
238 : #ifdef CONFIG_DEBUG_LINUX_TRACING
239 5716867 : if (wpa_debug_tracing_file != NULL) {
240 150 : va_start(ap, fmt);
241 150 : fprintf(wpa_debug_tracing_file, WPAS_TRACE_PFX, level);
242 150 : vfprintf(wpa_debug_tracing_file, fmt, ap);
243 150 : fprintf(wpa_debug_tracing_file, "\n");
244 150 : fflush(wpa_debug_tracing_file);
245 150 : va_end(ap);
246 : }
247 : #endif /* CONFIG_DEBUG_LINUX_TRACING */
248 5716867 : }
249 :
250 :
251 517137 : 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 517137 : if (wpa_debug_tracing_file != NULL) {
258 5 : fprintf(wpa_debug_tracing_file,
259 : WPAS_TRACE_PFX "%s - hexdump(len=%lu):",
260 : level, title, (unsigned long) len);
261 5 : if (buf == NULL) {
262 0 : fprintf(wpa_debug_tracing_file, " [NULL]\n");
263 5 : } else if (!show) {
264 0 : fprintf(wpa_debug_tracing_file, " [REMOVED]\n");
265 : } else {
266 51 : for (i = 0; i < len; i++)
267 46 : fprintf(wpa_debug_tracing_file,
268 46 : " %02x", buf[i]);
269 : }
270 5 : fflush(wpa_debug_tracing_file);
271 : }
272 : #endif /* CONFIG_DEBUG_LINUX_TRACING */
273 :
274 517137 : if (level < wpa_debug_level)
275 526653 : 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 507621 : wpa_debug_print_timestamp();
347 : #ifdef CONFIG_DEBUG_FILE
348 507621 : if (out_file) {
349 480239 : fprintf(out_file, "%s - hexdump(len=%lu):",
350 : title, (unsigned long) len);
351 480239 : if (buf == NULL) {
352 15839 : fprintf(out_file, " [NULL]");
353 464400 : } else if (show) {
354 22654237 : for (i = 0; i < len; i++)
355 22189837 : fprintf(out_file, " %02x", buf[i]);
356 : } else {
357 0 : fprintf(out_file, " [REMOVED]");
358 : }
359 480239 : fprintf(out_file, "\n");
360 : } else {
361 : #endif /* CONFIG_DEBUG_FILE */
362 27382 : printf("%s - hexdump(len=%lu):", title, (unsigned long) len);
363 27382 : if (buf == NULL) {
364 185 : printf(" [NULL]");
365 27197 : } else if (show) {
366 2831310 : for (i = 0; i < len; i++)
367 2804113 : printf(" %02x", buf[i]);
368 : } else {
369 0 : printf(" [REMOVED]");
370 : }
371 27382 : printf("\n");
372 : #ifdef CONFIG_DEBUG_FILE
373 : }
374 : #endif /* CONFIG_DEBUG_FILE */
375 : #endif /* CONFIG_ANDROID_LOG */
376 : }
377 :
378 418549 : void wpa_hexdump(int level, const char *title, const void *buf, size_t len)
379 : {
380 418549 : _wpa_hexdump(level, title, buf, len, 1);
381 418549 : }
382 :
383 :
384 98588 : void wpa_hexdump_key(int level, const char *title, const void *buf, size_t len)
385 : {
386 98588 : _wpa_hexdump(level, title, buf, len, wpa_debug_show_keys);
387 98588 : }
388 :
389 :
390 137260 : 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 137260 : const u8 *pos = buf;
395 137260 : const size_t line_len = 16;
396 :
397 : #ifdef CONFIG_DEBUG_LINUX_TRACING
398 137260 : 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 137260 : if (level < wpa_debug_level)
417 7068 : return;
418 : #ifdef CONFIG_ANDROID_LOG
419 : _wpa_hexdump(level, title, buf, len, show);
420 : #else /* CONFIG_ANDROID_LOG */
421 130192 : wpa_debug_print_timestamp();
422 : #ifdef CONFIG_DEBUG_FILE
423 130192 : if (out_file) {
424 127397 : 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 127397 : if (buf == NULL) {
431 4253 : fprintf(out_file,
432 : "%s - hexdump_ascii(len=%lu): [NULL]\n",
433 : title, (unsigned long) len);
434 4253 : return;
435 : }
436 123144 : fprintf(out_file, "%s - hexdump_ascii(len=%lu):\n",
437 : title, (unsigned long) len);
438 506956 : while (len) {
439 260668 : llen = len > line_len ? line_len : len;
440 260668 : fprintf(out_file, " ");
441 3376201 : for (i = 0; i < llen; i++)
442 3115533 : fprintf(out_file, " %02x", pos[i]);
443 1315823 : for (i = llen; i < line_len; i++)
444 1055155 : fprintf(out_file, " ");
445 260668 : fprintf(out_file, " ");
446 3376201 : for (i = 0; i < llen; i++) {
447 3115533 : if (isprint(pos[i]))
448 3027243 : fprintf(out_file, "%c", pos[i]);
449 : else
450 88290 : fprintf(out_file, "_");
451 : }
452 1315823 : for (i = llen; i < line_len; i++)
453 1055155 : fprintf(out_file, " ");
454 260668 : fprintf(out_file, "\n");
455 260668 : pos += llen;
456 260668 : len -= llen;
457 : }
458 : } else {
459 : #endif /* CONFIG_DEBUG_FILE */
460 2795 : if (!show) {
461 0 : printf("%s - hexdump_ascii(len=%lu): [REMOVED]\n",
462 : title, (unsigned long) len);
463 0 : return;
464 : }
465 2795 : if (buf == NULL) {
466 0 : printf("%s - hexdump_ascii(len=%lu): [NULL]\n",
467 : title, (unsigned long) len);
468 0 : return;
469 : }
470 2795 : printf("%s - hexdump_ascii(len=%lu):\n", title, (unsigned long) len);
471 10221 : while (len) {
472 4631 : llen = len > line_len ? line_len : len;
473 4631 : printf(" ");
474 56326 : for (i = 0; i < llen; i++)
475 51695 : printf(" %02x", pos[i]);
476 27032 : for (i = llen; i < line_len; i++)
477 22401 : printf(" ");
478 4631 : printf(" ");
479 56326 : for (i = 0; i < llen; i++) {
480 51695 : if (isprint(pos[i]))
481 51686 : printf("%c", pos[i]);
482 : else
483 9 : printf("_");
484 : }
485 27032 : for (i = llen; i < line_len; i++)
486 22401 : printf(" ");
487 4631 : printf("\n");
488 4631 : pos += llen;
489 4631 : len -= llen;
490 : }
491 : #ifdef CONFIG_DEBUG_FILE
492 : }
493 : #endif /* CONFIG_DEBUG_FILE */
494 : #endif /* CONFIG_ANDROID_LOG */
495 : }
496 :
497 :
498 122638 : void wpa_hexdump_ascii(int level, const char *title, const void *buf,
499 : size_t len)
500 : {
501 122638 : _wpa_hexdump_ascii(level, title, buf, len, 1);
502 122638 : }
503 :
504 :
505 14622 : void wpa_hexdump_ascii_key(int level, const char *title, const void *buf,
506 : size_t len)
507 : {
508 14622 : _wpa_hexdump_ascii(level, title, buf, len, wpa_debug_show_keys);
509 14622 : }
510 :
511 :
512 : #ifdef CONFIG_DEBUG_FILE
513 : static char *last_path = NULL;
514 : #endif /* CONFIG_DEBUG_FILE */
515 :
516 8068 : int wpa_debug_reopen_file(void)
517 : {
518 : #ifdef CONFIG_DEBUG_FILE
519 : int rv;
520 8068 : if (last_path) {
521 8068 : char *tmp = os_strdup(last_path);
522 8068 : wpa_debug_close_file();
523 8068 : rv = wpa_debug_open_file(tmp);
524 8068 : 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 8068 : return rv;
531 : #else /* CONFIG_DEBUG_FILE */
532 : return 0;
533 : #endif /* CONFIG_DEBUG_FILE */
534 : }
535 :
536 :
537 8123 : int wpa_debug_open_file(const char *path)
538 : {
539 : #ifdef CONFIG_DEBUG_FILE
540 8123 : if (!path)
541 0 : return 0;
542 :
543 8123 : if (last_path == NULL || os_strcmp(last_path, path) != 0) {
544 : /* Save our path to enable re-open */
545 8123 : os_free(last_path);
546 8123 : last_path = os_strdup(path);
547 : }
548 :
549 8123 : out_file = fopen(path, "a");
550 8123 : 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 8123 : setvbuf(out_file, NULL, _IOLBF, 0);
557 : #endif /* _WIN32 */
558 : #else /* CONFIG_DEBUG_FILE */
559 : (void)path;
560 : #endif /* CONFIG_DEBUG_FILE */
561 8123 : return 0;
562 : }
563 :
564 :
565 8136 : void wpa_debug_close_file(void)
566 : {
567 : #ifdef CONFIG_DEBUG_FILE
568 8136 : if (!out_file)
569 8149 : return;
570 8123 : fclose(out_file);
571 8123 : out_file = NULL;
572 8123 : os_free(last_path);
573 8123 : last_path = NULL;
574 : #endif /* CONFIG_DEBUG_FILE */
575 : }
576 :
577 :
578 19 : void wpa_debug_setup_stdout(void)
579 : {
580 : #ifndef _WIN32
581 19 : setvbuf(stdout, NULL, _IOLBF, 0);
582 : #endif /* _WIN32 */
583 19 : }
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 2310 : void wpa_msg_register_cb(wpa_msg_cb_func func)
592 : {
593 2310 : wpa_msg_cb = func;
594 2310 : }
595 :
596 :
597 : static wpa_msg_get_ifname_func wpa_msg_ifname_cb = NULL;
598 :
599 74 : void wpa_msg_register_ifname_cb(wpa_msg_get_ifname_func func)
600 : {
601 74 : wpa_msg_ifname_cb = func;
602 74 : }
603 :
604 :
605 923579 : 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 923579 : va_start(ap, fmt);
614 923579 : buflen = vsnprintf(NULL, 0, fmt, ap) + 1;
615 923579 : va_end(ap);
616 :
617 923579 : buf = os_malloc(buflen);
618 923579 : if (buf == NULL) {
619 76 : wpa_printf(MSG_ERROR, "wpa_msg: Failed to allocate message "
620 : "buffer");
621 923655 : return;
622 : }
623 923503 : va_start(ap, fmt);
624 923503 : prefix[0] = '\0';
625 923503 : if (wpa_msg_ifname_cb) {
626 923503 : const char *ifname = wpa_msg_ifname_cb(ctx);
627 923503 : if (ifname) {
628 923260 : int res = os_snprintf(prefix, sizeof(prefix), "%s: ",
629 : ifname);
630 923260 : if (os_snprintf_error(sizeof(prefix), res))
631 0 : prefix[0] = '\0';
632 : }
633 : }
634 923503 : len = vsnprintf(buf, buflen, fmt, ap);
635 923503 : va_end(ap);
636 923503 : wpa_printf(level, "%s%s", prefix, buf);
637 923503 : if (wpa_msg_cb)
638 923490 : wpa_msg_cb(ctx, level, WPA_MSG_PER_INTERFACE, buf, len);
639 923503 : bin_clear_free(buf, buflen);
640 : }
641 :
642 :
643 24622 : 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 24622 : if (!wpa_msg_cb)
651 0 : return;
652 :
653 24622 : va_start(ap, fmt);
654 24622 : buflen = vsnprintf(NULL, 0, fmt, ap) + 1;
655 24622 : va_end(ap);
656 :
657 24622 : buf = os_malloc(buflen);
658 24622 : if (buf == NULL) {
659 0 : wpa_printf(MSG_ERROR, "wpa_msg_ctrl: Failed to allocate "
660 : "message buffer");
661 0 : return;
662 : }
663 24622 : va_start(ap, fmt);
664 24622 : len = vsnprintf(buf, buflen, fmt, ap);
665 24622 : va_end(ap);
666 24622 : wpa_msg_cb(ctx, level, WPA_MSG_PER_INTERFACE, buf, len);
667 24622 : bin_clear_free(buf, buflen);
668 : }
669 :
670 :
671 246533 : 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 246533 : va_start(ap, fmt);
679 246533 : buflen = vsnprintf(NULL, 0, fmt, ap) + 1;
680 246533 : va_end(ap);
681 :
682 246533 : buf = os_malloc(buflen);
683 246533 : if (buf == NULL) {
684 7 : wpa_printf(MSG_ERROR, "wpa_msg_global: Failed to allocate "
685 : "message buffer");
686 246540 : return;
687 : }
688 246526 : va_start(ap, fmt);
689 246526 : len = vsnprintf(buf, buflen, fmt, ap);
690 246526 : va_end(ap);
691 246526 : wpa_printf(level, "%s", buf);
692 246526 : if (wpa_msg_cb)
693 246526 : wpa_msg_cb(ctx, level, WPA_MSG_GLOBAL, buf, len);
694 246526 : bin_clear_free(buf, buflen);
695 : }
696 :
697 :
698 516 : 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 516 : if (!wpa_msg_cb)
706 0 : return;
707 :
708 516 : va_start(ap, fmt);
709 516 : buflen = vsnprintf(NULL, 0, fmt, ap) + 1;
710 516 : va_end(ap);
711 :
712 516 : buf = os_malloc(buflen);
713 516 : if (buf == NULL) {
714 0 : wpa_printf(MSG_ERROR,
715 : "wpa_msg_global_ctrl: Failed to allocate message buffer");
716 0 : return;
717 : }
718 516 : va_start(ap, fmt);
719 516 : len = vsnprintf(buf, buflen, fmt, ap);
720 516 : va_end(ap);
721 516 : wpa_msg_cb(ctx, level, WPA_MSG_GLOBAL, buf, len);
722 516 : bin_clear_free(buf, buflen);
723 : }
724 :
725 :
726 46 : 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 46 : va_start(ap, fmt);
734 46 : buflen = vsnprintf(NULL, 0, fmt, ap) + 1;
735 46 : va_end(ap);
736 :
737 46 : buf = os_malloc(buflen);
738 46 : if (buf == NULL) {
739 0 : wpa_printf(MSG_ERROR, "wpa_msg_no_global: Failed to allocate "
740 : "message buffer");
741 46 : return;
742 : }
743 46 : va_start(ap, fmt);
744 46 : len = vsnprintf(buf, buflen, fmt, ap);
745 46 : va_end(ap);
746 46 : wpa_printf(level, "%s", buf);
747 46 : if (wpa_msg_cb)
748 46 : wpa_msg_cb(ctx, level, WPA_MSG_NO_GLOBAL, buf, len);
749 46 : bin_clear_free(buf, buflen);
750 : }
751 :
752 :
753 3963 : void wpa_msg_global_only(void *ctx, int level, const char *fmt, ...)
754 : {
755 : va_list ap;
756 : char *buf;
757 : int buflen;
758 : int len;
759 :
760 3963 : va_start(ap, fmt);
761 3963 : buflen = vsnprintf(NULL, 0, fmt, ap) + 1;
762 3963 : va_end(ap);
763 :
764 3963 : buf = os_malloc(buflen);
765 3963 : if (buf == NULL) {
766 0 : wpa_printf(MSG_ERROR, "%s: Failed to allocate message buffer",
767 : __func__);
768 3963 : return;
769 : }
770 3963 : va_start(ap, fmt);
771 3963 : len = vsnprintf(buf, buflen, fmt, ap);
772 3963 : va_end(ap);
773 3963 : wpa_printf(level, "%s", buf);
774 3963 : if (wpa_msg_cb)
775 3963 : wpa_msg_cb(ctx, level, WPA_MSG_ONLY_GLOBAL, buf, len);
776 3963 : os_free(buf);
777 : }
778 :
779 : #endif /* CONFIG_NO_WPA_MSG */
780 :
781 :
782 : #ifndef CONFIG_NO_HOSTAPD_LOGGER
783 : static hostapd_logger_cb_func hostapd_logger_cb = NULL;
784 :
785 25 : void hostapd_logger_register_cb(hostapd_logger_cb_func func)
786 : {
787 25 : hostapd_logger_cb = func;
788 25 : }
789 :
790 :
791 106023 : void hostapd_logger(void *ctx, const u8 *addr, unsigned int module, int level,
792 : const char *fmt, ...)
793 : {
794 : va_list ap;
795 : char *buf;
796 : int buflen;
797 : int len;
798 :
799 106023 : va_start(ap, fmt);
800 106023 : buflen = vsnprintf(NULL, 0, fmt, ap) + 1;
801 106023 : va_end(ap);
802 :
803 106023 : buf = os_malloc(buflen);
804 106023 : if (buf == NULL) {
805 38 : wpa_printf(MSG_ERROR, "hostapd_logger: Failed to allocate "
806 : "message buffer");
807 106061 : return;
808 : }
809 105985 : va_start(ap, fmt);
810 105985 : len = vsnprintf(buf, buflen, fmt, ap);
811 105985 : va_end(ap);
812 105985 : if (hostapd_logger_cb)
813 95536 : hostapd_logger_cb(ctx, addr, module, level, buf, len);
814 10449 : else if (addr)
815 62688 : wpa_printf(MSG_DEBUG, "hostapd_logger: STA " MACSTR " - %s",
816 62688 : MAC2STR(addr), buf);
817 : else
818 1 : wpa_printf(MSG_DEBUG, "hostapd_logger: %s", buf);
819 105985 : bin_clear_free(buf, buflen);
820 : }
821 : #endif /* CONFIG_NO_HOSTAPD_LOGGER */
822 :
823 :
824 20 : const char * debug_level_str(int level)
825 : {
826 20 : switch (level) {
827 : case MSG_EXCESSIVE:
828 2 : return "EXCESSIVE";
829 : case MSG_MSGDUMP:
830 10 : return "MSGDUMP";
831 : case MSG_DEBUG:
832 2 : return "DEBUG";
833 : case MSG_INFO:
834 2 : return "INFO";
835 : case MSG_WARNING:
836 2 : return "WARNING";
837 : case MSG_ERROR:
838 2 : return "ERROR";
839 : default:
840 0 : return "?";
841 : }
842 : }
843 :
844 :
845 21 : int str_to_debug_level(const char *s)
846 : {
847 21 : if (os_strcasecmp(s, "EXCESSIVE") == 0)
848 2 : return MSG_EXCESSIVE;
849 19 : if (os_strcasecmp(s, "MSGDUMP") == 0)
850 9 : return MSG_MSGDUMP;
851 10 : if (os_strcasecmp(s, "DEBUG") == 0)
852 2 : return MSG_DEBUG;
853 8 : if (os_strcasecmp(s, "INFO") == 0)
854 2 : return MSG_INFO;
855 6 : if (os_strcasecmp(s, "WARNING") == 0)
856 2 : return MSG_WARNING;
857 4 : if (os_strcasecmp(s, "ERROR") == 0)
858 2 : return MSG_ERROR;
859 2 : return -1;
860 : }
|
