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 694800 : void wpa_debug_print_timestamp(void)
66 : {
67 : #ifndef CONFIG_ANDROID_LOG
68 : struct os_time tv;
69 :
70 694800 : if (!wpa_debug_timestamp)
71 694800 : return;
72 :
73 694800 : os_get_time(&tv);
74 : #ifdef CONFIG_DEBUG_FILE
75 694800 : if (out_file) {
76 694800 : fprintf(out_file, "%ld.%06u: ", (long) tv.sec,
77 694800 : (unsigned int) tv.usec);
78 : } else
79 : #endif /* CONFIG_DEBUG_FILE */
80 0 : 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 1 : void wpa_debug_close_linux_tracing(void)
183 : {
184 1 : if (wpa_debug_tracing_file == NULL)
185 2 : 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 582902 : void wpa_printf(int level, const char *fmt, ...)
205 : {
206 : va_list ap;
207 :
208 582902 : va_start(ap, fmt);
209 582902 : 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 582902 : wpa_debug_print_timestamp();
220 : #ifdef CONFIG_DEBUG_FILE
221 582902 : if (out_file) {
222 582902 : vfprintf(out_file, fmt, ap);
223 582902 : fprintf(out_file, "\n");
224 : } else {
225 : #endif /* CONFIG_DEBUG_FILE */
226 0 : vprintf(fmt, ap);
227 0 : 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 582902 : va_end(ap);
237 :
238 : #ifdef CONFIG_DEBUG_LINUX_TRACING
239 582902 : 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 582902 : }
249 :
250 :
251 47859 : 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 47859 : 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 47859 : if (level < wpa_debug_level)
275 47859 : 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 47859 : wpa_debug_print_timestamp();
347 : #ifdef CONFIG_DEBUG_FILE
348 47859 : if (out_file) {
349 47859 : fprintf(out_file, "%s - hexdump(len=%lu):",
350 : title, (unsigned long) len);
351 47859 : if (buf == NULL) {
352 44 : fprintf(out_file, " [NULL]");
353 47815 : } else if (show) {
354 3118109 : for (i = 0; i < len; i++)
355 3070294 : fprintf(out_file, " %02x", buf[i]);
356 : } else {
357 0 : fprintf(out_file, " [REMOVED]");
358 : }
359 47859 : fprintf(out_file, "\n");
360 : } else {
361 : #endif /* CONFIG_DEBUG_FILE */
362 0 : printf("%s - hexdump(len=%lu):", title, (unsigned long) len);
363 0 : if (buf == NULL) {
364 0 : printf(" [NULL]");
365 0 : } else if (show) {
366 0 : for (i = 0; i < len; i++)
367 0 : printf(" %02x", buf[i]);
368 : } else {
369 0 : printf(" [REMOVED]");
370 : }
371 0 : printf("\n");
372 : #ifdef CONFIG_DEBUG_FILE
373 : }
374 : #endif /* CONFIG_DEBUG_FILE */
375 : #endif /* CONFIG_ANDROID_LOG */
376 : }
377 :
378 38523 : void wpa_hexdump(int level, const char *title, const void *buf, size_t len)
379 : {
380 38523 : _wpa_hexdump(level, title, buf, len, 1);
381 38523 : }
382 :
383 :
384 9336 : void wpa_hexdump_key(int level, const char *title, const void *buf, size_t len)
385 : {
386 9336 : _wpa_hexdump(level, title, buf, len, wpa_debug_show_keys);
387 9336 : }
388 :
389 :
390 17419 : 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 17419 : const u8 *pos = buf;
395 17419 : const size_t line_len = 16;
396 :
397 : #ifdef CONFIG_DEBUG_LINUX_TRACING
398 17419 : 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 17419 : if (level < wpa_debug_level)
417 0 : return;
418 : #ifdef CONFIG_ANDROID_LOG
419 : _wpa_hexdump(level, title, buf, len, show);
420 : #else /* CONFIG_ANDROID_LOG */
421 17419 : wpa_debug_print_timestamp();
422 : #ifdef CONFIG_DEBUG_FILE
423 17419 : if (out_file) {
424 17419 : 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 17419 : if (buf == NULL) {
431 0 : fprintf(out_file,
432 : "%s - hexdump_ascii(len=%lu): [NULL]\n",
433 : title, (unsigned long) len);
434 0 : return;
435 : }
436 17419 : fprintf(out_file, "%s - hexdump_ascii(len=%lu):\n",
437 : title, (unsigned long) len);
438 64586 : while (len) {
439 29748 : llen = len > line_len ? line_len : len;
440 29748 : fprintf(out_file, " ");
441 372108 : for (i = 0; i < llen; i++)
442 342360 : fprintf(out_file, " %02x", pos[i]);
443 163356 : for (i = llen; i < line_len; i++)
444 133608 : fprintf(out_file, " ");
445 29748 : fprintf(out_file, " ");
446 372108 : for (i = 0; i < llen; i++) {
447 342360 : if (isprint(pos[i]))
448 341995 : fprintf(out_file, "%c", pos[i]);
449 : else
450 365 : fprintf(out_file, "_");
451 : }
452 163356 : for (i = llen; i < line_len; i++)
453 133608 : fprintf(out_file, " ");
454 29748 : fprintf(out_file, "\n");
455 29748 : pos += llen;
456 29748 : len -= llen;
457 : }
458 : } else {
459 : #endif /* CONFIG_DEBUG_FILE */
460 0 : if (!show) {
461 0 : printf("%s - hexdump_ascii(len=%lu): [REMOVED]\n",
462 : title, (unsigned long) len);
463 0 : return;
464 : }
465 0 : if (buf == NULL) {
466 0 : printf("%s - hexdump_ascii(len=%lu): [NULL]\n",
467 : title, (unsigned long) len);
468 0 : return;
469 : }
470 0 : printf("%s - hexdump_ascii(len=%lu):\n", title, (unsigned long) len);
471 0 : while (len) {
472 0 : llen = len > line_len ? line_len : len;
473 0 : printf(" ");
474 0 : for (i = 0; i < llen; i++)
475 0 : printf(" %02x", pos[i]);
476 0 : for (i = llen; i < line_len; i++)
477 0 : printf(" ");
478 0 : printf(" ");
479 0 : for (i = 0; i < llen; i++) {
480 0 : if (isprint(pos[i]))
481 0 : printf("%c", pos[i]);
482 : else
483 0 : printf("_");
484 : }
485 0 : for (i = llen; i < line_len; i++)
486 0 : printf(" ");
487 0 : printf("\n");
488 0 : pos += llen;
489 0 : len -= llen;
490 : }
491 : #ifdef CONFIG_DEBUG_FILE
492 : }
493 : #endif /* CONFIG_DEBUG_FILE */
494 : #endif /* CONFIG_ANDROID_LOG */
495 : }
496 :
497 :
498 17101 : void wpa_hexdump_ascii(int level, const char *title, const void *buf,
499 : size_t len)
500 : {
501 17101 : _wpa_hexdump_ascii(level, title, buf, len, 1);
502 17101 : }
503 :
504 :
505 318 : void wpa_hexdump_ascii_key(int level, const char *title, const void *buf,
506 : size_t len)
507 : {
508 318 : _wpa_hexdump_ascii(level, title, buf, len, wpa_debug_show_keys);
509 318 : }
510 :
511 :
512 : #ifdef CONFIG_DEBUG_FILE
513 : static char *last_path = NULL;
514 : #endif /* CONFIG_DEBUG_FILE */
515 :
516 726 : int wpa_debug_reopen_file(void)
517 : {
518 : #ifdef CONFIG_DEBUG_FILE
519 : int rv;
520 726 : if (last_path) {
521 726 : char *tmp = os_strdup(last_path);
522 726 : wpa_debug_close_file();
523 726 : rv = wpa_debug_open_file(tmp);
524 726 : 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 726 : return rv;
531 : #else /* CONFIG_DEBUG_FILE */
532 : return 0;
533 : #endif /* CONFIG_DEBUG_FILE */
534 : }
535 :
536 :
537 727 : int wpa_debug_open_file(const char *path)
538 : {
539 : #ifdef CONFIG_DEBUG_FILE
540 727 : if (!path)
541 0 : return 0;
542 :
543 727 : if (last_path == NULL || os_strcmp(last_path, path) != 0) {
544 : /* Save our path to enable re-open */
545 727 : os_free(last_path);
546 727 : last_path = os_strdup(path);
547 : }
548 :
549 727 : out_file = fopen(path, "a");
550 727 : 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 727 : setvbuf(out_file, NULL, _IOLBF, 0);
557 : #endif /* _WIN32 */
558 : #endif /* CONFIG_DEBUG_FILE */
559 727 : return 0;
560 : }
561 :
562 :
563 727 : void wpa_debug_close_file(void)
564 : {
565 : #ifdef CONFIG_DEBUG_FILE
566 727 : if (!out_file)
567 727 : return;
568 727 : fclose(out_file);
569 727 : out_file = NULL;
570 727 : os_free(last_path);
571 727 : 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 652 : void wpa_msg_register_cb(wpa_msg_cb_func func)
582 : {
583 652 : wpa_msg_cb = func;
584 652 : }
585 :
586 :
587 : static wpa_msg_get_ifname_func wpa_msg_ifname_cb = NULL;
588 :
589 1 : void wpa_msg_register_ifname_cb(wpa_msg_get_ifname_func func)
590 : {
591 1 : wpa_msg_ifname_cb = func;
592 1 : }
593 :
594 :
595 31215 : 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 31215 : va_start(ap, fmt);
604 31215 : buflen = vsnprintf(NULL, 0, fmt, ap) + 1;
605 31215 : va_end(ap);
606 :
607 31215 : buf = os_malloc(buflen);
608 31215 : if (buf == NULL) {
609 0 : wpa_printf(MSG_ERROR, "wpa_msg: Failed to allocate message "
610 : "buffer");
611 31215 : return;
612 : }
613 31215 : va_start(ap, fmt);
614 31215 : prefix[0] = '\0';
615 31215 : if (wpa_msg_ifname_cb) {
616 31215 : const char *ifname = wpa_msg_ifname_cb(ctx);
617 31215 : if (ifname) {
618 31215 : int res = os_snprintf(prefix, sizeof(prefix), "%s: ",
619 : ifname);
620 31215 : if (res < 0 || res >= (int) sizeof(prefix))
621 0 : prefix[0] = '\0';
622 : }
623 : }
624 31215 : len = vsnprintf(buf, buflen, fmt, ap);
625 31215 : va_end(ap);
626 31215 : wpa_printf(level, "%s%s", prefix, buf);
627 31215 : if (wpa_msg_cb)
628 31215 : wpa_msg_cb(ctx, level, 0, buf, len);
629 31215 : os_free(buf);
630 : }
631 :
632 :
633 163 : 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 163 : if (!wpa_msg_cb)
641 0 : return;
642 :
643 163 : va_start(ap, fmt);
644 163 : buflen = vsnprintf(NULL, 0, fmt, ap) + 1;
645 163 : va_end(ap);
646 :
647 163 : buf = os_malloc(buflen);
648 163 : if (buf == NULL) {
649 0 : wpa_printf(MSG_ERROR, "wpa_msg_ctrl: Failed to allocate "
650 : "message buffer");
651 0 : return;
652 : }
653 163 : va_start(ap, fmt);
654 163 : len = vsnprintf(buf, buflen, fmt, ap);
655 163 : va_end(ap);
656 163 : wpa_msg_cb(ctx, level, 0, buf, len);
657 163 : os_free(buf);
658 : }
659 :
660 :
661 0 : 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 0 : va_start(ap, fmt);
669 0 : buflen = vsnprintf(NULL, 0, fmt, ap) + 1;
670 0 : va_end(ap);
671 :
672 0 : buf = os_malloc(buflen);
673 0 : if (buf == NULL) {
674 0 : wpa_printf(MSG_ERROR, "wpa_msg_global: Failed to allocate "
675 : "message buffer");
676 0 : return;
677 : }
678 0 : va_start(ap, fmt);
679 0 : len = vsnprintf(buf, buflen, fmt, ap);
680 0 : va_end(ap);
681 0 : wpa_printf(level, "%s", buf);
682 0 : if (wpa_msg_cb)
683 0 : wpa_msg_cb(ctx, level, 1, buf, len);
684 0 : os_free(buf);
685 : }
686 :
687 :
688 0 : void wpa_msg_global_ctrl(void *ctx, int level, const char *fmt, ...)
689 : {
690 : va_list ap;
691 : char *buf;
692 : int buflen;
693 : int len;
694 :
695 0 : if (!wpa_msg_cb)
696 0 : return;
697 :
698 0 : va_start(ap, fmt);
699 0 : buflen = vsnprintf(NULL, 0, fmt, ap) + 1;
700 0 : va_end(ap);
701 :
702 0 : buf = os_malloc(buflen);
703 0 : if (buf == NULL) {
704 0 : wpa_printf(MSG_ERROR,
705 : "wpa_msg_global_ctrl: Failed to allocate message buffer");
706 0 : return;
707 : }
708 0 : va_start(ap, fmt);
709 0 : len = vsnprintf(buf, buflen, fmt, ap);
710 0 : va_end(ap);
711 0 : wpa_msg_cb(ctx, level, 1, buf, len);
712 0 : os_free(buf);
713 : }
714 :
715 :
716 0 : void wpa_msg_no_global(void *ctx, int level, const char *fmt, ...)
717 : {
718 : va_list ap;
719 : char *buf;
720 : int buflen;
721 : int len;
722 :
723 0 : va_start(ap, fmt);
724 0 : buflen = vsnprintf(NULL, 0, fmt, ap) + 1;
725 0 : va_end(ap);
726 :
727 0 : buf = os_malloc(buflen);
728 0 : if (buf == NULL) {
729 0 : wpa_printf(MSG_ERROR, "wpa_msg_no_global: Failed to allocate "
730 : "message buffer");
731 0 : return;
732 : }
733 0 : va_start(ap, fmt);
734 0 : len = vsnprintf(buf, buflen, fmt, ap);
735 0 : va_end(ap);
736 0 : wpa_printf(level, "%s", buf);
737 0 : if (wpa_msg_cb)
738 0 : wpa_msg_cb(ctx, level, 2, buf, len);
739 0 : os_free(buf);
740 : }
741 :
742 : #endif /* CONFIG_NO_WPA_MSG */
743 :
744 :
745 : #ifndef CONFIG_NO_HOSTAPD_LOGGER
746 : static hostapd_logger_cb_func hostapd_logger_cb = NULL;
747 :
748 1 : void hostapd_logger_register_cb(hostapd_logger_cb_func func)
749 : {
750 1 : hostapd_logger_cb = func;
751 1 : }
752 :
753 :
754 47145 : void hostapd_logger(void *ctx, const u8 *addr, unsigned int module, int level,
755 : const char *fmt, ...)
756 : {
757 : va_list ap;
758 : char *buf;
759 : int buflen;
760 : int len;
761 :
762 47145 : va_start(ap, fmt);
763 47145 : buflen = vsnprintf(NULL, 0, fmt, ap) + 1;
764 47145 : va_end(ap);
765 :
766 47145 : buf = os_malloc(buflen);
767 47145 : if (buf == NULL) {
768 0 : wpa_printf(MSG_ERROR, "hostapd_logger: Failed to allocate "
769 : "message buffer");
770 47145 : return;
771 : }
772 47145 : va_start(ap, fmt);
773 47145 : len = vsnprintf(buf, buflen, fmt, ap);
774 47145 : va_end(ap);
775 47145 : if (hostapd_logger_cb)
776 47145 : hostapd_logger_cb(ctx, addr, module, level, buf, len);
777 0 : else if (addr)
778 0 : wpa_printf(MSG_DEBUG, "hostapd_logger: STA " MACSTR " - %s",
779 0 : MAC2STR(addr), buf);
780 : else
781 0 : wpa_printf(MSG_DEBUG, "hostapd_logger: %s", buf);
782 47145 : os_free(buf);
783 : }
784 : #endif /* CONFIG_NO_HOSTAPD_LOGGER */
|
