Branch data 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 : 1063548 : void wpa_debug_print_timestamp(void)
66 : : {
67 : : #ifndef CONFIG_ANDROID_LOG
68 : : struct os_time tv;
69 : :
70 [ - + ]: 1063548 : if (!wpa_debug_timestamp)
71 : 1063548 : return;
72 : :
73 : 1063548 : os_get_time(&tv);
74 : : #ifdef CONFIG_DEBUG_FILE
75 [ + + ]: 1063548 : if (out_file) {
76 : 995483 : fprintf(out_file, "%ld.%06u: ", (long) tv.sec,
77 : 995483 : (unsigned int) tv.usec);
78 : : } else
79 : : #endif /* CONFIG_DEBUG_FILE */
80 : 68065 : 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 : 6 : 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 : 999358 : void wpa_printf(int level, const char *fmt, ...)
205 : : {
206 : : va_list ap;
207 : :
208 : 999358 : va_start(ap, fmt);
209 [ + + ]: 999358 : 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 : 926092 : wpa_debug_print_timestamp();
220 : : #ifdef CONFIG_DEBUG_FILE
221 [ + + ]: 926092 : if (out_file) {
222 : 864584 : vfprintf(out_file, fmt, ap);
223 : 864584 : fprintf(out_file, "\n");
224 : : } else {
225 : : #endif /* CONFIG_DEBUG_FILE */
226 : 61508 : vprintf(fmt, ap);
227 : 61508 : 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 : 999358 : va_end(ap);
237 : :
238 : : #ifdef CONFIG_DEBUG_LINUX_TRACING
239 [ - + ]: 999358 : 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 : 999358 : }
249 : :
250 : :
251 : 98260 : 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 [ - + ]: 98260 : 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 [ + + ]: 98260 : if (level < wpa_debug_level)
275 : 98260 : 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 : 94534 : wpa_debug_print_timestamp();
347 : : #ifdef CONFIG_DEBUG_FILE
348 [ + + ]: 94534 : if (out_file) {
349 : 88753 : fprintf(out_file, "%s - hexdump(len=%lu):",
350 : : title, (unsigned long) len);
351 [ + + ]: 88753 : if (buf == NULL) {
352 : 3981 : fprintf(out_file, " [NULL]");
353 [ + - ]: 84772 : } else if (show) {
354 [ + + ]: 5602814 : for (i = 0; i < len; i++)
355 : 5518042 : fprintf(out_file, " %02x", buf[i]);
356 : : } else {
357 : 0 : fprintf(out_file, " [REMOVED]");
358 : : }
359 : 88753 : fprintf(out_file, "\n");
360 : : } else {
361 : : #endif /* CONFIG_DEBUG_FILE */
362 : 5781 : printf("%s - hexdump(len=%lu):", title, (unsigned long) len);
363 [ + + ]: 5781 : if (buf == NULL) {
364 : 18 : printf(" [NULL]");
365 [ + - ]: 5763 : } else if (show) {
366 [ + + ]: 803308 : for (i = 0; i < len; i++)
367 : 797545 : printf(" %02x", buf[i]);
368 : : } else {
369 : 0 : printf(" [REMOVED]");
370 : : }
371 : 5781 : printf("\n");
372 : : #ifdef CONFIG_DEBUG_FILE
373 : : }
374 : : #endif /* CONFIG_DEBUG_FILE */
375 : : #endif /* CONFIG_ANDROID_LOG */
376 : : }
377 : :
378 : 83272 : void wpa_hexdump(int level, const char *title, const void *buf, size_t len)
379 : : {
380 : 83272 : _wpa_hexdump(level, title, buf, len, 1);
381 : 83272 : }
382 : :
383 : :
384 : 14988 : void wpa_hexdump_key(int level, const char *title, const void *buf, size_t len)
385 : : {
386 : 14988 : _wpa_hexdump(level, title, buf, len, wpa_debug_show_keys);
387 : 14988 : }
388 : :
389 : :
390 : 23775 : 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 : 23775 : const u8 *pos = buf;
395 : 23775 : const size_t line_len = 16;
396 : :
397 : : #ifdef CONFIG_DEBUG_LINUX_TRACING
398 [ - + ]: 23775 : 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 [ + + ]: 23775 : if (level < wpa_debug_level)
417 : 3 : return;
418 : : #ifdef CONFIG_ANDROID_LOG
419 : : _wpa_hexdump(level, title, buf, len, show);
420 : : #else /* CONFIG_ANDROID_LOG */
421 : 23772 : wpa_debug_print_timestamp();
422 : : #ifdef CONFIG_DEBUG_FILE
423 [ + + ]: 23772 : if (out_file) {
424 [ - + ]: 22996 : 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 [ + + ]: 22996 : if (buf == NULL) {
431 : 585 : fprintf(out_file,
432 : : "%s - hexdump_ascii(len=%lu): [NULL]\n",
433 : : title, (unsigned long) len);
434 : 585 : return;
435 : : }
436 : 22411 : fprintf(out_file, "%s - hexdump_ascii(len=%lu):\n",
437 : : title, (unsigned long) len);
438 [ + + ]: 59459 : while (len) {
439 : 37048 : llen = len > line_len ? line_len : len;
440 : 37048 : fprintf(out_file, " ");
441 [ + + ]: 452833 : for (i = 0; i < llen; i++)
442 : 415785 : fprintf(out_file, " %02x", pos[i]);
443 [ + + ]: 214031 : for (i = llen; i < line_len; i++)
444 : 176983 : fprintf(out_file, " ");
445 : 37048 : fprintf(out_file, " ");
446 [ + + ]: 452833 : for (i = 0; i < llen; i++) {
447 [ + + ]: 415785 : if (isprint(pos[i]))
448 : 405062 : fprintf(out_file, "%c", pos[i]);
449 : : else
450 : 10723 : fprintf(out_file, "_");
451 : : }
452 [ + + ]: 214031 : for (i = llen; i < line_len; i++)
453 : 176983 : fprintf(out_file, " ");
454 : 37048 : fprintf(out_file, "\n");
455 : 37048 : pos += llen;
456 : 37048 : len -= llen;
457 : : }
458 : : } else {
459 : : #endif /* CONFIG_DEBUG_FILE */
460 [ - + ]: 776 : if (!show) {
461 : 0 : printf("%s - hexdump_ascii(len=%lu): [REMOVED]\n",
462 : : title, (unsigned long) len);
463 : 0 : return;
464 : : }
465 [ - + ]: 776 : if (buf == NULL) {
466 : 0 : printf("%s - hexdump_ascii(len=%lu): [NULL]\n",
467 : : title, (unsigned long) len);
468 : 0 : return;
469 : : }
470 : 776 : printf("%s - hexdump_ascii(len=%lu):\n", title, (unsigned long) len);
471 [ + + ]: 25117 : while (len) {
472 : 1342 : llen = len > line_len ? line_len : len;
473 : 1342 : printf(" ");
474 [ + + ]: 15616 : for (i = 0; i < llen; i++)
475 : 14274 : printf(" %02x", pos[i]);
476 [ + + ]: 8540 : for (i = llen; i < line_len; i++)
477 : 7198 : printf(" ");
478 : 1342 : printf(" ");
479 [ + + ]: 15616 : for (i = 0; i < llen; i++) {
480 [ + + ]: 14274 : if (isprint(pos[i]))
481 : 14271 : printf("%c", pos[i]);
482 : : else
483 : 3 : printf("_");
484 : : }
485 [ + + ]: 8540 : for (i = llen; i < line_len; i++)
486 : 7198 : printf(" ");
487 : 1342 : printf("\n");
488 : 1342 : pos += llen;
489 : 1342 : len -= llen;
490 : : }
491 : : #ifdef CONFIG_DEBUG_FILE
492 : : }
493 : : #endif /* CONFIG_DEBUG_FILE */
494 : : #endif /* CONFIG_ANDROID_LOG */
495 : : }
496 : :
497 : :
498 : 20746 : void wpa_hexdump_ascii(int level, const char *title, const void *buf,
499 : : size_t len)
500 : : {
501 : 20746 : _wpa_hexdump_ascii(level, title, buf, len, 1);
502 : 20746 : }
503 : :
504 : :
505 : 3029 : void wpa_hexdump_ascii_key(int level, const char *title, const void *buf,
506 : : size_t len)
507 : : {
508 : 3029 : _wpa_hexdump_ascii(level, title, buf, len, wpa_debug_show_keys);
509 : 3029 : }
510 : :
511 : :
512 : : #ifdef CONFIG_DEBUG_FILE
513 : : static char *last_path = NULL;
514 : : #endif /* CONFIG_DEBUG_FILE */
515 : :
516 : 1568 : int wpa_debug_reopen_file(void)
517 : : {
518 : : #ifdef CONFIG_DEBUG_FILE
519 : : int rv;
520 [ + - ]: 1568 : if (last_path) {
521 : 1568 : char *tmp = os_strdup(last_path);
522 : 1568 : wpa_debug_close_file();
523 : 1568 : rv = wpa_debug_open_file(tmp);
524 : 1568 : 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 : 1568 : return rv;
531 : : #else /* CONFIG_DEBUG_FILE */
532 : : return 0;
533 : : #endif /* CONFIG_DEBUG_FILE */
534 : : }
535 : :
536 : :
537 : 1573 : int wpa_debug_open_file(const char *path)
538 : : {
539 : : #ifdef CONFIG_DEBUG_FILE
540 [ - + ]: 1573 : if (!path)
541 : 0 : return 0;
542 : :
543 [ - + ][ # # ]: 1573 : if (last_path == NULL || os_strcmp(last_path, path) != 0) {
544 : : /* Save our path to enable re-open */
545 : 1573 : os_free(last_path);
546 : 1573 : last_path = os_strdup(path);
547 : : }
548 : :
549 : 1573 : out_file = fopen(path, "a");
550 [ - + ]: 1573 : 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 : 1573 : setvbuf(out_file, NULL, _IOLBF, 0);
557 : : #endif /* _WIN32 */
558 : : #endif /* CONFIG_DEBUG_FILE */
559 : 1573 : return 0;
560 : : }
561 : :
562 : :
563 : 1573 : void wpa_debug_close_file(void)
564 : : {
565 : : #ifdef CONFIG_DEBUG_FILE
566 [ - + ]: 1573 : if (!out_file)
567 : 1573 : return;
568 : 1573 : fclose(out_file);
569 : 1573 : out_file = NULL;
570 : 1573 : os_free(last_path);
571 : 1573 : 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 : 394 : void wpa_msg_register_cb(wpa_msg_cb_func func)
582 : : {
583 : 394 : wpa_msg_cb = func;
584 : 394 : }
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 : 141162 : 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 : 141162 : va_start(ap, fmt);
604 : 141162 : buflen = vsnprintf(NULL, 0, fmt, ap) + 1;
605 : 141162 : va_end(ap);
606 : :
607 : 141162 : buf = os_malloc(buflen);
608 [ - + ]: 141162 : if (buf == NULL) {
609 : 0 : wpa_printf(MSG_ERROR, "wpa_msg: Failed to allocate message "
610 : : "buffer");
611 : 141162 : return;
612 : : }
613 : 141162 : va_start(ap, fmt);
614 : 141162 : prefix[0] = '\0';
615 [ + - ]: 141162 : if (wpa_msg_ifname_cb) {
616 : 141162 : const char *ifname = wpa_msg_ifname_cb(ctx);
617 [ + - ]: 141162 : if (ifname) {
618 : 141162 : int res = os_snprintf(prefix, sizeof(prefix), "%s: ",
619 : : ifname);
620 [ + - ][ - + ]: 141162 : if (res < 0 || res >= (int) sizeof(prefix))
621 : 0 : prefix[0] = '\0';
622 : : }
623 : : }
624 : 141162 : len = vsnprintf(buf, buflen, fmt, ap);
625 : 141162 : va_end(ap);
626 : 141162 : wpa_printf(level, "%s%s", prefix, buf);
627 [ + - ]: 141162 : if (wpa_msg_cb)
628 : 141162 : wpa_msg_cb(ctx, level, 0, buf, len);
629 : 141162 : os_free(buf);
630 : : }
631 : :
632 : :
633 : 3981 : 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 [ - + ]: 3981 : if (!wpa_msg_cb)
641 : 0 : return;
642 : :
643 : 3981 : va_start(ap, fmt);
644 : 3981 : buflen = vsnprintf(NULL, 0, fmt, ap) + 1;
645 : 3981 : va_end(ap);
646 : :
647 : 3981 : buf = os_malloc(buflen);
648 [ - + ]: 3981 : if (buf == NULL) {
649 : 0 : wpa_printf(MSG_ERROR, "wpa_msg_ctrl: Failed to allocate "
650 : : "message buffer");
651 : 0 : return;
652 : : }
653 : 3981 : va_start(ap, fmt);
654 : 3981 : len = vsnprintf(buf, buflen, fmt, ap);
655 : 3981 : va_end(ap);
656 : 3981 : wpa_msg_cb(ctx, level, 0, buf, len);
657 : 3981 : os_free(buf);
658 : : }
659 : :
660 : :
661 : 31172 : 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 : 31172 : va_start(ap, fmt);
669 : 31172 : buflen = vsnprintf(NULL, 0, fmt, ap) + 1;
670 : 31172 : va_end(ap);
671 : :
672 : 31172 : buf = os_malloc(buflen);
673 [ - + ]: 31172 : if (buf == NULL) {
674 : 0 : wpa_printf(MSG_ERROR, "wpa_msg_global: Failed to allocate "
675 : : "message buffer");
676 : 31172 : return;
677 : : }
678 : 31172 : va_start(ap, fmt);
679 : 31172 : len = vsnprintf(buf, buflen, fmt, ap);
680 : 31172 : va_end(ap);
681 : 31172 : wpa_printf(level, "%s", buf);
682 [ + - ]: 31172 : if (wpa_msg_cb)
683 : 31172 : wpa_msg_cb(ctx, level, 1, buf, len);
684 : 31172 : 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 : 24216 : 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 : 24216 : va_start(ap, fmt);
735 : 24216 : buflen = vsnprintf(NULL, 0, fmt, ap) + 1;
736 : 24216 : va_end(ap);
737 : :
738 : 24216 : buf = os_malloc(buflen);
739 [ - + ]: 24216 : if (buf == NULL) {
740 : 0 : wpa_printf(MSG_ERROR, "hostapd_logger: Failed to allocate "
741 : : "message buffer");
742 : 24216 : return;
743 : : }
744 : 24216 : va_start(ap, fmt);
745 : 24216 : len = vsnprintf(buf, buflen, fmt, ap);
746 : 24216 : va_end(ap);
747 [ + + ]: 24216 : if (hostapd_logger_cb)
748 : 19631 : hostapd_logger_cb(ctx, addr, module, level, buf, len);
749 [ + - ]: 4585 : else if (addr)
750 : 4585 : wpa_printf(MSG_DEBUG, "hostapd_logger: STA " MACSTR " - %s",
751 : 27510 : MAC2STR(addr), buf);
752 : : else
753 : 0 : wpa_printf(MSG_DEBUG, "hostapd_logger: %s", buf);
754 : 24216 : os_free(buf);
755 : : }
756 : : #endif /* CONFIG_NO_HOSTAPD_LOGGER */
|
