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 */
|
