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 1688610 : void wpa_debug_print_timestamp(void)
66 : {
67 : #ifndef CONFIG_ANDROID_LOG
68 : struct os_time tv;
69 :
70 1688610 : if (!wpa_debug_timestamp)
71 1688612 : return;
72 :
73 1688608 : os_get_time(&tv);
74 : #ifdef CONFIG_DEBUG_FILE
75 1688608 : if (out_file) {
76 1579264 : fprintf(out_file, "%ld.%06u: ", (long) tv.sec,
77 1579264 : (unsigned int) tv.usec);
78 : } else
79 : #endif /* CONFIG_DEBUG_FILE */
80 109344 : 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 6 : void wpa_debug_close_linux_tracing(void)
183 : {
184 6 : if (wpa_debug_tracing_file == NULL)
185 12 : 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 1567219 : void wpa_printf(int level, const char *fmt, ...)
205 : {
206 : va_list ap;
207 :
208 1567219 : va_start(ap, fmt);
209 1567219 : 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 1465936 : wpa_debug_print_timestamp();
220 : #ifdef CONFIG_DEBUG_FILE
221 1465936 : if (out_file) {
222 1368906 : vfprintf(out_file, fmt, ap);
223 1368906 : fprintf(out_file, "\n");
224 : } else {
225 : #endif /* CONFIG_DEBUG_FILE */
226 97030 : vprintf(fmt, ap);
227 97030 : 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 1567219 : va_end(ap);
237 :
238 : #ifdef CONFIG_DEBUG_LINUX_TRACING
239 1567219 : 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 1567219 : }
249 :
250 :
251 161270 : 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 161270 : 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 161270 : if (level < wpa_debug_level)
275 165784 : 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 156756 : wpa_debug_print_timestamp();
347 : #ifdef CONFIG_DEBUG_FILE
348 156756 : if (out_file) {
349 145697 : fprintf(out_file, "%s - hexdump(len=%lu):",
350 : title, (unsigned long) len);
351 145697 : if (buf == NULL) {
352 5382 : fprintf(out_file, " [NULL]");
353 140315 : } else if (show) {
354 8392317 : for (i = 0; i < len; i++)
355 8252002 : fprintf(out_file, " %02x", buf[i]);
356 : } else {
357 0 : fprintf(out_file, " [REMOVED]");
358 : }
359 145697 : fprintf(out_file, "\n");
360 : } else {
361 : #endif /* CONFIG_DEBUG_FILE */
362 11059 : printf("%s - hexdump(len=%lu):", title, (unsigned long) len);
363 11059 : if (buf == NULL) {
364 73 : printf(" [NULL]");
365 10986 : } else if (show) {
366 1482768 : for (i = 0; i < len; i++)
367 1471782 : printf(" %02x", buf[i]);
368 : } else {
369 0 : printf(" [REMOVED]");
370 : }
371 11059 : printf("\n");
372 : #ifdef CONFIG_DEBUG_FILE
373 : }
374 : #endif /* CONFIG_DEBUG_FILE */
375 : #endif /* CONFIG_ANDROID_LOG */
376 : }
377 :
378 131871 : void wpa_hexdump(int level, const char *title, const void *buf, size_t len)
379 : {
380 131871 : _wpa_hexdump(level, title, buf, len, 1);
381 131871 : }
382 :
383 :
384 29399 : void wpa_hexdump_key(int level, const char *title, const void *buf, size_t len)
385 : {
386 29399 : _wpa_hexdump(level, title, buf, len, wpa_debug_show_keys);
387 29399 : }
388 :
389 :
390 37342 : 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 37342 : const u8 *pos = buf;
395 37342 : const size_t line_len = 16;
396 :
397 : #ifdef CONFIG_DEBUG_LINUX_TRACING
398 37342 : 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 37342 : if (level < wpa_debug_level)
417 1894 : return;
418 : #ifdef CONFIG_ANDROID_LOG
419 : _wpa_hexdump(level, title, buf, len, show);
420 : #else /* CONFIG_ANDROID_LOG */
421 35448 : wpa_debug_print_timestamp();
422 : #ifdef CONFIG_DEBUG_FILE
423 35448 : if (out_file) {
424 34193 : 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 34193 : if (buf == NULL) {
431 1025 : fprintf(out_file,
432 : "%s - hexdump_ascii(len=%lu): [NULL]\n",
433 : title, (unsigned long) len);
434 1025 : return;
435 : }
436 33168 : fprintf(out_file, "%s - hexdump_ascii(len=%lu):\n",
437 : title, (unsigned long) len);
438 119351 : while (len) {
439 53015 : llen = len > line_len ? line_len : len;
440 53015 : fprintf(out_file, " ");
441 637916 : for (i = 0; i < llen; i++)
442 584901 : fprintf(out_file, " %02x", pos[i]);
443 316354 : for (i = llen; i < line_len; i++)
444 263339 : fprintf(out_file, " ");
445 53015 : fprintf(out_file, " ");
446 637916 : for (i = 0; i < llen; i++) {
447 584901 : if (isprint(pos[i]))
448 573389 : fprintf(out_file, "%c", pos[i]);
449 : else
450 11512 : fprintf(out_file, "_");
451 : }
452 316354 : for (i = llen; i < line_len; i++)
453 263339 : fprintf(out_file, " ");
454 53015 : fprintf(out_file, "\n");
455 53015 : pos += llen;
456 53015 : len -= llen;
457 : }
458 : } else {
459 : #endif /* CONFIG_DEBUG_FILE */
460 1255 : if (!show) {
461 0 : printf("%s - hexdump_ascii(len=%lu): [REMOVED]\n",
462 : title, (unsigned long) len);
463 0 : return;
464 : }
465 1255 : if (buf == NULL) {
466 0 : printf("%s - hexdump_ascii(len=%lu): [NULL]\n",
467 : title, (unsigned long) len);
468 0 : return;
469 : }
470 1255 : printf("%s - hexdump_ascii(len=%lu):\n", title, (unsigned long) len);
471 4866 : while (len) {
472 2356 : llen = len > line_len ? line_len : len;
473 2356 : printf(" ");
474 28879 : for (i = 0; i < llen; i++)
475 26523 : printf(" %02x", pos[i]);
476 13529 : for (i = llen; i < line_len; i++)
477 11173 : printf(" ");
478 2356 : printf(" ");
479 28879 : for (i = 0; i < llen; i++) {
480 26523 : if (isprint(pos[i]))
481 26520 : printf("%c", pos[i]);
482 : else
483 3 : printf("_");
484 : }
485 13529 : for (i = llen; i < line_len; i++)
486 11173 : printf(" ");
487 2356 : printf("\n");
488 2356 : pos += llen;
489 2356 : len -= llen;
490 : }
491 : #ifdef CONFIG_DEBUG_FILE
492 : }
493 : #endif /* CONFIG_DEBUG_FILE */
494 : #endif /* CONFIG_ANDROID_LOG */
495 : }
496 :
497 :
498 32359 : void wpa_hexdump_ascii(int level, const char *title, const void *buf,
499 : size_t len)
500 : {
501 32359 : _wpa_hexdump_ascii(level, title, buf, len, 1);
502 32359 : }
503 :
504 :
505 4983 : void wpa_hexdump_ascii_key(int level, const char *title, const void *buf,
506 : size_t len)
507 : {
508 4983 : _wpa_hexdump_ascii(level, title, buf, len, wpa_debug_show_keys);
509 4983 : }
510 :
511 :
512 : #ifdef CONFIG_DEBUG_FILE
513 : static char *last_path = NULL;
514 : #endif /* CONFIG_DEBUG_FILE */
515 :
516 2548 : int wpa_debug_reopen_file(void)
517 : {
518 : #ifdef CONFIG_DEBUG_FILE
519 : int rv;
520 2548 : if (last_path) {
521 2548 : char *tmp = os_strdup(last_path);
522 2548 : wpa_debug_close_file();
523 2548 : rv = wpa_debug_open_file(tmp);
524 2548 : 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 2548 : return rv;
531 : #else /* CONFIG_DEBUG_FILE */
532 : return 0;
533 : #endif /* CONFIG_DEBUG_FILE */
534 : }
535 :
536 :
537 2553 : int wpa_debug_open_file(const char *path)
538 : {
539 : #ifdef CONFIG_DEBUG_FILE
540 2553 : if (!path)
541 0 : return 0;
542 :
543 2553 : if (last_path == NULL || os_strcmp(last_path, path) != 0) {
544 : /* Save our path to enable re-open */
545 2553 : os_free(last_path);
546 2553 : last_path = os_strdup(path);
547 : }
548 :
549 2553 : out_file = fopen(path, "a");
550 2553 : 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 2553 : setvbuf(out_file, NULL, _IOLBF, 0);
557 : #endif /* _WIN32 */
558 : #endif /* CONFIG_DEBUG_FILE */
559 2553 : return 0;
560 : }
561 :
562 :
563 2553 : void wpa_debug_close_file(void)
564 : {
565 : #ifdef CONFIG_DEBUG_FILE
566 2553 : if (!out_file)
567 2553 : return;
568 2553 : fclose(out_file);
569 2553 : out_file = NULL;
570 2553 : os_free(last_path);
571 2553 : last_path = NULL;
572 : #endif /* CONFIG_DEBUG_FILE */
573 : }
574 :
575 : #endif /* CONFIG_NO_STDOUT_DEBUG */
576 :
577 :
578 : #ifndef CONFIG_NO_WPA_MSG
579 : static wpa_msg_cb_func wpa_msg_cb = NULL;
580 :
581 646 : void wpa_msg_register_cb(wpa_msg_cb_func func)
582 : {
583 646 : wpa_msg_cb = func;
584 646 : }
585 :
586 :
587 : static wpa_msg_get_ifname_func wpa_msg_ifname_cb = NULL;
588 :
589 6 : void wpa_msg_register_ifname_cb(wpa_msg_get_ifname_func func)
590 : {
591 6 : wpa_msg_ifname_cb = func;
592 6 : }
593 :
594 :
595 219730 : void wpa_msg(void *ctx, int level, const char *fmt, ...)
596 : {
597 : va_list ap;
598 : char *buf;
599 : int buflen;
600 : int len;
601 : char prefix[130];
602 :
603 219730 : va_start(ap, fmt);
604 219730 : buflen = vsnprintf(NULL, 0, fmt, ap) + 1;
605 219730 : va_end(ap);
606 :
607 219730 : buf = os_malloc(buflen);
608 219730 : if (buf == NULL) {
609 0 : wpa_printf(MSG_ERROR, "wpa_msg: Failed to allocate message "
610 : "buffer");
611 219730 : return;
612 : }
613 219730 : va_start(ap, fmt);
614 219730 : prefix[0] = '\0';
615 219730 : if (wpa_msg_ifname_cb) {
616 219730 : const char *ifname = wpa_msg_ifname_cb(ctx);
617 219730 : if (ifname) {
618 219729 : int res = os_snprintf(prefix, sizeof(prefix), "%s: ",
619 : ifname);
620 219729 : if (res < 0 || res >= (int) sizeof(prefix))
621 0 : prefix[0] = '\0';
622 : }
623 : }
624 219730 : len = vsnprintf(buf, buflen, fmt, ap);
625 219730 : va_end(ap);
626 219730 : wpa_printf(level, "%s%s", prefix, buf);
627 219730 : if (wpa_msg_cb)
628 219730 : wpa_msg_cb(ctx, level, 0, buf, len);
629 219730 : os_free(buf);
630 : }
631 :
632 :
633 5866 : void wpa_msg_ctrl(void *ctx, int level, const char *fmt, ...)
634 : {
635 : va_list ap;
636 : char *buf;
637 : int buflen;
638 : int len;
639 :
640 5866 : if (!wpa_msg_cb)
641 0 : return;
642 :
643 5866 : va_start(ap, fmt);
644 5866 : buflen = vsnprintf(NULL, 0, fmt, ap) + 1;
645 5866 : va_end(ap);
646 :
647 5866 : buf = os_malloc(buflen);
648 5866 : if (buf == NULL) {
649 0 : wpa_printf(MSG_ERROR, "wpa_msg_ctrl: Failed to allocate "
650 : "message buffer");
651 0 : return;
652 : }
653 5866 : va_start(ap, fmt);
654 5866 : len = vsnprintf(buf, buflen, fmt, ap);
655 5866 : va_end(ap);
656 5866 : wpa_msg_cb(ctx, level, 0, buf, len);
657 5866 : os_free(buf);
658 : }
659 :
660 :
661 51442 : void wpa_msg_global(void *ctx, int level, const char *fmt, ...)
662 : {
663 : va_list ap;
664 : char *buf;
665 : int buflen;
666 : int len;
667 :
668 51442 : va_start(ap, fmt);
669 51442 : buflen = vsnprintf(NULL, 0, fmt, ap) + 1;
670 51442 : va_end(ap);
671 :
672 51442 : buf = os_malloc(buflen);
673 51442 : if (buf == NULL) {
674 0 : wpa_printf(MSG_ERROR, "wpa_msg_global: Failed to allocate "
675 : "message buffer");
676 51442 : return;
677 : }
678 51442 : va_start(ap, fmt);
679 51442 : len = vsnprintf(buf, buflen, fmt, ap);
680 51442 : va_end(ap);
681 51442 : wpa_printf(level, "%s", buf);
682 51442 : if (wpa_msg_cb)
683 51442 : wpa_msg_cb(ctx, level, 1, buf, len);
684 51442 : os_free(buf);
685 : }
686 :
687 :
688 26 : void wpa_msg_no_global(void *ctx, int level, const char *fmt, ...)
689 : {
690 : va_list ap;
691 : char *buf;
692 : int buflen;
693 : int len;
694 :
695 26 : va_start(ap, fmt);
696 26 : buflen = vsnprintf(NULL, 0, fmt, ap) + 1;
697 26 : va_end(ap);
698 :
699 26 : buf = os_malloc(buflen);
700 26 : if (buf == NULL) {
701 0 : wpa_printf(MSG_ERROR, "wpa_msg_no_global: Failed to allocate "
702 : "message buffer");
703 26 : return;
704 : }
705 26 : va_start(ap, fmt);
706 26 : len = vsnprintf(buf, buflen, fmt, ap);
707 26 : va_end(ap);
708 26 : wpa_printf(level, "%s", buf);
709 26 : if (wpa_msg_cb)
710 26 : wpa_msg_cb(ctx, level, 2, buf, len);
711 26 : os_free(buf);
712 : }
713 :
714 : #endif /* CONFIG_NO_WPA_MSG */
715 :
716 :
717 : #ifndef CONFIG_NO_HOSTAPD_LOGGER
718 : static hostapd_logger_cb_func hostapd_logger_cb = NULL;
719 :
720 2 : void hostapd_logger_register_cb(hostapd_logger_cb_func func)
721 : {
722 2 : hostapd_logger_cb = func;
723 2 : }
724 :
725 :
726 36965 : void hostapd_logger(void *ctx, const u8 *addr, unsigned int module, int level,
727 : const char *fmt, ...)
728 : {
729 : va_list ap;
730 : char *buf;
731 : int buflen;
732 : int len;
733 :
734 36965 : va_start(ap, fmt);
735 36965 : buflen = vsnprintf(NULL, 0, fmt, ap) + 1;
736 36965 : va_end(ap);
737 :
738 36965 : buf = os_malloc(buflen);
739 36965 : if (buf == NULL) {
740 0 : wpa_printf(MSG_ERROR, "hostapd_logger: Failed to allocate "
741 : "message buffer");
742 36965 : return;
743 : }
744 36965 : va_start(ap, fmt);
745 36965 : len = vsnprintf(buf, buflen, fmt, ap);
746 36965 : va_end(ap);
747 36965 : if (hostapd_logger_cb)
748 30995 : hostapd_logger_cb(ctx, addr, module, level, buf, len);
749 5970 : else if (addr)
750 35820 : wpa_printf(MSG_DEBUG, "hostapd_logger: STA " MACSTR " - %s",
751 35820 : MAC2STR(addr), buf);
752 : else
753 0 : wpa_printf(MSG_DEBUG, "hostapd_logger: %s", buf);
754 36965 : os_free(buf);
755 : }
756 : #endif /* CONFIG_NO_HOSTAPD_LOGGER */
|
