Home | History | Annotate | Download | only in utils
      1 /*
      2  * wpa_supplicant/hostapd / Debug prints
      3  * Copyright (c) 2002-2013, Jouni Malinen <j (at) 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 void wpa_debug_print_timestamp(void)
     66 {
     67 #ifndef CONFIG_ANDROID_LOG
     68 	struct os_time tv;
     69 
     70 	if (!wpa_debug_timestamp)
     71 		return;
     72 
     73 	os_get_time(&tv);
     74 #ifdef CONFIG_DEBUG_FILE
     75 	if (out_file) {
     76 		fprintf(out_file, "%ld.%06u: ", (long) tv.sec,
     77 			(unsigned int) tv.usec);
     78 	} else
     79 #endif /* CONFIG_DEBUG_FILE */
     80 	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 int wpa_debug_open_linux_tracing(void)
    125 {
    126 	int mounts, trace_fd;
    127 	char buf[4096] = {};
    128 	ssize_t buflen;
    129 	char *line, *tmp1, *path = NULL;
    130 
    131 	mounts = open("/proc/mounts", O_RDONLY);
    132 	if (mounts < 0) {
    133 		printf("no /proc/mounts\n");
    134 		return -1;
    135 	}
    136 
    137 	buflen = read(mounts, buf, sizeof(buf) - 1);
    138 	close(mounts);
    139 	if (buflen < 0) {
    140 		printf("failed to read /proc/mounts\n");
    141 		return -1;
    142 	}
    143 
    144 	line = strtok_r(buf, "\n", &tmp1);
    145 	while (line) {
    146 		char *tmp2, *tmp_path, *fstype;
    147 		/* "<dev> <mountpoint> <fs type> ..." */
    148 		strtok_r(line, " ", &tmp2);
    149 		tmp_path = strtok_r(NULL, " ", &tmp2);
    150 		fstype = strtok_r(NULL, " ", &tmp2);
    151 		if (fstype && strcmp(fstype, "debugfs") == 0) {
    152 			path = tmp_path;
    153 			break;
    154 		}
    155 
    156 		line = strtok_r(NULL, "\n", &tmp1);
    157 	}
    158 
    159 	if (path == NULL) {
    160 		printf("debugfs mountpoint not found\n");
    161 		return -1;
    162 	}
    163 
    164 	snprintf(buf, sizeof(buf) - 1, "%s/tracing/trace_marker", path);
    165 
    166 	trace_fd = open(buf, O_WRONLY);
    167 	if (trace_fd < 0) {
    168 		printf("failed to open trace_marker file\n");
    169 		return -1;
    170 	}
    171 	wpa_debug_tracing_file = fdopen(trace_fd, "w");
    172 	if (wpa_debug_tracing_file == NULL) {
    173 		close(trace_fd);
    174 		printf("failed to fdopen()\n");
    175 		return -1;
    176 	}
    177 
    178 	return 0;
    179 }
    180 
    181 
    182 void wpa_debug_close_linux_tracing(void)
    183 {
    184 	if (wpa_debug_tracing_file == NULL)
    185 		return;
    186 	fclose(wpa_debug_tracing_file);
    187 	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 void wpa_printf(int level, const char *fmt, ...)
    205 {
    206 	va_list ap;
    207 
    208 	va_start(ap, fmt);
    209 	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 		wpa_debug_print_timestamp();
    220 #ifdef CONFIG_DEBUG_FILE
    221 		if (out_file) {
    222 			vfprintf(out_file, fmt, ap);
    223 			fprintf(out_file, "\n");
    224 		} else {
    225 #endif /* CONFIG_DEBUG_FILE */
    226 		vprintf(fmt, ap);
    227 		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 	va_end(ap);
    237 
    238 #ifdef CONFIG_DEBUG_LINUX_TRACING
    239 	if (wpa_debug_tracing_file != NULL) {
    240 		va_start(ap, fmt);
    241 		fprintf(wpa_debug_tracing_file, WPAS_TRACE_PFX, level);
    242 		vfprintf(wpa_debug_tracing_file, fmt, ap);
    243 		fprintf(wpa_debug_tracing_file, "\n");
    244 		fflush(wpa_debug_tracing_file);
    245 		va_end(ap);
    246 	}
    247 #endif /* CONFIG_DEBUG_LINUX_TRACING */
    248 }
    249 
    250 
    251 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 	if (wpa_debug_tracing_file != NULL) {
    258 		fprintf(wpa_debug_tracing_file,
    259 			WPAS_TRACE_PFX "%s - hexdump(len=%lu):",
    260 			level, title, (unsigned long) len);
    261 		if (buf == NULL) {
    262 			fprintf(wpa_debug_tracing_file, " [NULL]\n");
    263 		} else if (!show) {
    264 			fprintf(wpa_debug_tracing_file, " [REMOVED]\n");
    265 		} else {
    266 			for (i = 0; i < len; i++)
    267 				fprintf(wpa_debug_tracing_file,
    268 					" %02x", buf[i]);
    269 		}
    270 		fflush(wpa_debug_tracing_file);
    271 	}
    272 #endif /* CONFIG_DEBUG_LINUX_TRACING */
    273 
    274 	if (level < wpa_debug_level)
    275 		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 	wpa_debug_print_timestamp();
    347 #ifdef CONFIG_DEBUG_FILE
    348 	if (out_file) {
    349 		fprintf(out_file, "%s - hexdump(len=%lu):",
    350 			title, (unsigned long) len);
    351 		if (buf == NULL) {
    352 			fprintf(out_file, " [NULL]");
    353 		} else if (show) {
    354 			for (i = 0; i < len; i++)
    355 				fprintf(out_file, " %02x", buf[i]);
    356 		} else {
    357 			fprintf(out_file, " [REMOVED]");
    358 		}
    359 		fprintf(out_file, "\n");
    360 	} else {
    361 #endif /* CONFIG_DEBUG_FILE */
    362 	printf("%s - hexdump(len=%lu):", title, (unsigned long) len);
    363 	if (buf == NULL) {
    364 		printf(" [NULL]");
    365 	} else if (show) {
    366 		for (i = 0; i < len; i++)
    367 			printf(" %02x", buf[i]);
    368 	} else {
    369 		printf(" [REMOVED]");
    370 	}
    371 	printf("\n");
    372 #ifdef CONFIG_DEBUG_FILE
    373 	}
    374 #endif /* CONFIG_DEBUG_FILE */
    375 #endif /* CONFIG_ANDROID_LOG */
    376 }
    377 
    378 void wpa_hexdump(int level, const char *title, const void *buf, size_t len)
    379 {
    380 	_wpa_hexdump(level, title, buf, len, 1);
    381 }
    382 
    383 
    384 void wpa_hexdump_key(int level, const char *title, const void *buf, size_t len)
    385 {
    386 	_wpa_hexdump(level, title, buf, len, wpa_debug_show_keys);
    387 }
    388 
    389 
    390 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 	const u8 *pos = buf;
    395 	const size_t line_len = 16;
    396 
    397 #ifdef CONFIG_DEBUG_LINUX_TRACING
    398 	if (wpa_debug_tracing_file != NULL) {
    399 		fprintf(wpa_debug_tracing_file,
    400 			WPAS_TRACE_PFX "%s - hexdump_ascii(len=%lu):",
    401 			level, title, (unsigned long) len);
    402 		if (buf == NULL) {
    403 			fprintf(wpa_debug_tracing_file, " [NULL]\n");
    404 		} else if (!show) {
    405 			fprintf(wpa_debug_tracing_file, " [REMOVED]\n");
    406 		} else {
    407 			/* can do ascii processing in userspace */
    408 			for (i = 0; i < len; i++)
    409 				fprintf(wpa_debug_tracing_file,
    410 					" %02x", pos[i]);
    411 		}
    412 		fflush(wpa_debug_tracing_file);
    413 	}
    414 #endif /* CONFIG_DEBUG_LINUX_TRACING */
    415 
    416 	if (level < wpa_debug_level)
    417 		return;
    418 #ifdef CONFIG_ANDROID_LOG
    419 	_wpa_hexdump(level, title, buf, len, show);
    420 #else /* CONFIG_ANDROID_LOG */
    421 	wpa_debug_print_timestamp();
    422 #ifdef CONFIG_DEBUG_FILE
    423 	if (out_file) {
    424 		if (!show) {
    425 			fprintf(out_file,
    426 				"%s - hexdump_ascii(len=%lu): [REMOVED]\n",
    427 				title, (unsigned long) len);
    428 			return;
    429 		}
    430 		if (buf == NULL) {
    431 			fprintf(out_file,
    432 				"%s - hexdump_ascii(len=%lu): [NULL]\n",
    433 				title, (unsigned long) len);
    434 			return;
    435 		}
    436 		fprintf(out_file, "%s - hexdump_ascii(len=%lu):\n",
    437 			title, (unsigned long) len);
    438 		while (len) {
    439 			llen = len > line_len ? line_len : len;
    440 			fprintf(out_file, "    ");
    441 			for (i = 0; i < llen; i++)
    442 				fprintf(out_file, " %02x", pos[i]);
    443 			for (i = llen; i < line_len; i++)
    444 				fprintf(out_file, "   ");
    445 			fprintf(out_file, "   ");
    446 			for (i = 0; i < llen; i++) {
    447 				if (isprint(pos[i]))
    448 					fprintf(out_file, "%c", pos[i]);
    449 				else
    450 					fprintf(out_file, "_");
    451 			}
    452 			for (i = llen; i < line_len; i++)
    453 				fprintf(out_file, " ");
    454 			fprintf(out_file, "\n");
    455 			pos += llen;
    456 			len -= llen;
    457 		}
    458 	} else {
    459 #endif /* CONFIG_DEBUG_FILE */
    460 	if (!show) {
    461 		printf("%s - hexdump_ascii(len=%lu): [REMOVED]\n",
    462 		       title, (unsigned long) len);
    463 		return;
    464 	}
    465 	if (buf == NULL) {
    466 		printf("%s - hexdump_ascii(len=%lu): [NULL]\n",
    467 		       title, (unsigned long) len);
    468 		return;
    469 	}
    470 	printf("%s - hexdump_ascii(len=%lu):\n", title, (unsigned long) len);
    471 	while (len) {
    472 		llen = len > line_len ? line_len : len;
    473 		printf("    ");
    474 		for (i = 0; i < llen; i++)
    475 			printf(" %02x", pos[i]);
    476 		for (i = llen; i < line_len; i++)
    477 			printf("   ");
    478 		printf("   ");
    479 		for (i = 0; i < llen; i++) {
    480 			if (isprint(pos[i]))
    481 				printf("%c", pos[i]);
    482 			else
    483 				printf("_");
    484 		}
    485 		for (i = llen; i < line_len; i++)
    486 			printf(" ");
    487 		printf("\n");
    488 		pos += llen;
    489 		len -= llen;
    490 	}
    491 #ifdef CONFIG_DEBUG_FILE
    492 	}
    493 #endif /* CONFIG_DEBUG_FILE */
    494 #endif /* CONFIG_ANDROID_LOG */
    495 }
    496 
    497 
    498 void wpa_hexdump_ascii(int level, const char *title, const void *buf,
    499 		       size_t len)
    500 {
    501 	_wpa_hexdump_ascii(level, title, buf, len, 1);
    502 }
    503 
    504 
    505 void wpa_hexdump_ascii_key(int level, const char *title, const void *buf,
    506 			   size_t len)
    507 {
    508 	_wpa_hexdump_ascii(level, title, buf, len, wpa_debug_show_keys);
    509 }
    510 
    511 
    512 #ifdef CONFIG_DEBUG_FILE
    513 static char *last_path = NULL;
    514 #endif /* CONFIG_DEBUG_FILE */
    515 
    516 int wpa_debug_reopen_file(void)
    517 {
    518 #ifdef CONFIG_DEBUG_FILE
    519 	int rv;
    520 	char *tmp;
    521 
    522 	if (!last_path)
    523 		return 0; /* logfile not used */
    524 
    525 	tmp = os_strdup(last_path);
    526 	if (!tmp)
    527 		return -1;
    528 
    529 	wpa_debug_close_file();
    530 	rv = wpa_debug_open_file(tmp);
    531 	os_free(tmp);
    532 	return rv;
    533 #else /* CONFIG_DEBUG_FILE */
    534 	return 0;
    535 #endif /* CONFIG_DEBUG_FILE */
    536 }
    537 
    538 
    539 int wpa_debug_open_file(const char *path)
    540 {
    541 #ifdef CONFIG_DEBUG_FILE
    542 	if (!path)
    543 		return 0;
    544 
    545 	if (last_path == NULL || os_strcmp(last_path, path) != 0) {
    546 		/* Save our path to enable re-open */
    547 		os_free(last_path);
    548 		last_path = os_strdup(path);
    549 	}
    550 
    551 	out_file = fopen(path, "a");
    552 	if (out_file == NULL) {
    553 		wpa_printf(MSG_ERROR, "wpa_debug_open_file: Failed to open "
    554 			   "output file, using standard output");
    555 		return -1;
    556 	}
    557 #ifndef _WIN32
    558 	setvbuf(out_file, NULL, _IOLBF, 0);
    559 #endif /* _WIN32 */
    560 #else /* CONFIG_DEBUG_FILE */
    561 	(void)path;
    562 #endif /* CONFIG_DEBUG_FILE */
    563 	return 0;
    564 }
    565 
    566 
    567 void wpa_debug_close_file(void)
    568 {
    569 #ifdef CONFIG_DEBUG_FILE
    570 	if (!out_file)
    571 		return;
    572 	fclose(out_file);
    573 	out_file = NULL;
    574 	os_free(last_path);
    575 	last_path = NULL;
    576 #endif /* CONFIG_DEBUG_FILE */
    577 }
    578 
    579 
    580 void wpa_debug_setup_stdout(void)
    581 {
    582 #ifndef _WIN32
    583 	setvbuf(stdout, NULL, _IOLBF, 0);
    584 #endif /* _WIN32 */
    585 }
    586 
    587 #endif /* CONFIG_NO_STDOUT_DEBUG */
    588 
    589 
    590 #ifndef CONFIG_NO_WPA_MSG
    591 static wpa_msg_cb_func wpa_msg_cb = NULL;
    592 
    593 void wpa_msg_register_cb(wpa_msg_cb_func func)
    594 {
    595 	wpa_msg_cb = func;
    596 }
    597 
    598 
    599 static wpa_msg_get_ifname_func wpa_msg_ifname_cb = NULL;
    600 
    601 void wpa_msg_register_ifname_cb(wpa_msg_get_ifname_func func)
    602 {
    603 	wpa_msg_ifname_cb = func;
    604 }
    605 
    606 
    607 void wpa_msg(void *ctx, int level, const char *fmt, ...)
    608 {
    609 	va_list ap;
    610 	char *buf;
    611 	int buflen;
    612 	int len;
    613 	char prefix[130];
    614 
    615 	va_start(ap, fmt);
    616 	buflen = vsnprintf(NULL, 0, fmt, ap) + 1;
    617 	va_end(ap);
    618 
    619 	buf = os_malloc(buflen);
    620 	if (buf == NULL) {
    621 		wpa_printf(MSG_ERROR, "wpa_msg: Failed to allocate message "
    622 			   "buffer");
    623 		return;
    624 	}
    625 	va_start(ap, fmt);
    626 	prefix[0] = '\0';
    627 	if (wpa_msg_ifname_cb) {
    628 		const char *ifname = wpa_msg_ifname_cb(ctx);
    629 		if (ifname) {
    630 			int res = os_snprintf(prefix, sizeof(prefix), "%s: ",
    631 					      ifname);
    632 			if (os_snprintf_error(sizeof(prefix), res))
    633 				prefix[0] = '\0';
    634 		}
    635 	}
    636 	len = vsnprintf(buf, buflen, fmt, ap);
    637 	va_end(ap);
    638 	wpa_printf(level, "%s%s", prefix, buf);
    639 	if (wpa_msg_cb)
    640 		wpa_msg_cb(ctx, level, WPA_MSG_PER_INTERFACE, buf, len);
    641 	bin_clear_free(buf, buflen);
    642 }
    643 
    644 
    645 void wpa_msg_ctrl(void *ctx, int level, const char *fmt, ...)
    646 {
    647 	va_list ap;
    648 	char *buf;
    649 	int buflen;
    650 	int len;
    651 
    652 	if (!wpa_msg_cb)
    653 		return;
    654 
    655 	va_start(ap, fmt);
    656 	buflen = vsnprintf(NULL, 0, fmt, ap) + 1;
    657 	va_end(ap);
    658 
    659 	buf = os_malloc(buflen);
    660 	if (buf == NULL) {
    661 		wpa_printf(MSG_ERROR, "wpa_msg_ctrl: Failed to allocate "
    662 			   "message buffer");
    663 		return;
    664 	}
    665 	va_start(ap, fmt);
    666 	len = vsnprintf(buf, buflen, fmt, ap);
    667 	va_end(ap);
    668 	wpa_msg_cb(ctx, level, WPA_MSG_PER_INTERFACE, buf, len);
    669 	bin_clear_free(buf, buflen);
    670 }
    671 
    672 
    673 void wpa_msg_global(void *ctx, int level, const char *fmt, ...)
    674 {
    675 	va_list ap;
    676 	char *buf;
    677 	int buflen;
    678 	int len;
    679 
    680 	va_start(ap, fmt);
    681 	buflen = vsnprintf(NULL, 0, fmt, ap) + 1;
    682 	va_end(ap);
    683 
    684 	buf = os_malloc(buflen);
    685 	if (buf == NULL) {
    686 		wpa_printf(MSG_ERROR, "wpa_msg_global: Failed to allocate "
    687 			   "message buffer");
    688 		return;
    689 	}
    690 	va_start(ap, fmt);
    691 	len = vsnprintf(buf, buflen, fmt, ap);
    692 	va_end(ap);
    693 	wpa_printf(level, "%s", buf);
    694 	if (wpa_msg_cb)
    695 		wpa_msg_cb(ctx, level, WPA_MSG_GLOBAL, buf, len);
    696 	bin_clear_free(buf, buflen);
    697 }
    698 
    699 
    700 void wpa_msg_global_ctrl(void *ctx, int level, const char *fmt, ...)
    701 {
    702 	va_list ap;
    703 	char *buf;
    704 	int buflen;
    705 	int len;
    706 
    707 	if (!wpa_msg_cb)
    708 		return;
    709 
    710 	va_start(ap, fmt);
    711 	buflen = vsnprintf(NULL, 0, fmt, ap) + 1;
    712 	va_end(ap);
    713 
    714 	buf = os_malloc(buflen);
    715 	if (buf == NULL) {
    716 		wpa_printf(MSG_ERROR,
    717 			   "wpa_msg_global_ctrl: Failed to allocate message buffer");
    718 		return;
    719 	}
    720 	va_start(ap, fmt);
    721 	len = vsnprintf(buf, buflen, fmt, ap);
    722 	va_end(ap);
    723 	wpa_msg_cb(ctx, level, WPA_MSG_GLOBAL, buf, len);
    724 	bin_clear_free(buf, buflen);
    725 }
    726 
    727 
    728 void wpa_msg_no_global(void *ctx, int level, const char *fmt, ...)
    729 {
    730 	va_list ap;
    731 	char *buf;
    732 	int buflen;
    733 	int len;
    734 
    735 	va_start(ap, fmt);
    736 	buflen = vsnprintf(NULL, 0, fmt, ap) + 1;
    737 	va_end(ap);
    738 
    739 	buf = os_malloc(buflen);
    740 	if (buf == NULL) {
    741 		wpa_printf(MSG_ERROR, "wpa_msg_no_global: Failed to allocate "
    742 			   "message buffer");
    743 		return;
    744 	}
    745 	va_start(ap, fmt);
    746 	len = vsnprintf(buf, buflen, fmt, ap);
    747 	va_end(ap);
    748 	wpa_printf(level, "%s", buf);
    749 	if (wpa_msg_cb)
    750 		wpa_msg_cb(ctx, level, WPA_MSG_NO_GLOBAL, buf, len);
    751 	bin_clear_free(buf, buflen);
    752 }
    753 
    754 
    755 void wpa_msg_global_only(void *ctx, int level, const char *fmt, ...)
    756 {
    757 	va_list ap;
    758 	char *buf;
    759 	int buflen;
    760 	int len;
    761 
    762 	va_start(ap, fmt);
    763 	buflen = vsnprintf(NULL, 0, fmt, ap) + 1;
    764 	va_end(ap);
    765 
    766 	buf = os_malloc(buflen);
    767 	if (buf == NULL) {
    768 		wpa_printf(MSG_ERROR, "%s: Failed to allocate message buffer",
    769 			   __func__);
    770 		return;
    771 	}
    772 	va_start(ap, fmt);
    773 	len = vsnprintf(buf, buflen, fmt, ap);
    774 	va_end(ap);
    775 	wpa_printf(level, "%s", buf);
    776 	if (wpa_msg_cb)
    777 		wpa_msg_cb(ctx, level, WPA_MSG_ONLY_GLOBAL, buf, len);
    778 	os_free(buf);
    779 }
    780 
    781 #endif /* CONFIG_NO_WPA_MSG */
    782 
    783 
    784 #ifndef CONFIG_NO_HOSTAPD_LOGGER
    785 static hostapd_logger_cb_func hostapd_logger_cb = NULL;
    786 
    787 void hostapd_logger_register_cb(hostapd_logger_cb_func func)
    788 {
    789 	hostapd_logger_cb = func;
    790 }
    791 
    792 
    793 void hostapd_logger(void *ctx, const u8 *addr, unsigned int module, int level,
    794 		    const char *fmt, ...)
    795 {
    796 	va_list ap;
    797 	char *buf;
    798 	int buflen;
    799 	int len;
    800 
    801 	va_start(ap, fmt);
    802 	buflen = vsnprintf(NULL, 0, fmt, ap) + 1;
    803 	va_end(ap);
    804 
    805 	buf = os_malloc(buflen);
    806 	if (buf == NULL) {
    807 		wpa_printf(MSG_ERROR, "hostapd_logger: Failed to allocate "
    808 			   "message buffer");
    809 		return;
    810 	}
    811 	va_start(ap, fmt);
    812 	len = vsnprintf(buf, buflen, fmt, ap);
    813 	va_end(ap);
    814 	if (hostapd_logger_cb)
    815 		hostapd_logger_cb(ctx, addr, module, level, buf, len);
    816 	else if (addr)
    817 		wpa_printf(MSG_DEBUG, "hostapd_logger: STA " MACSTR " - %s",
    818 			   MAC2STR(addr), buf);
    819 	else
    820 		wpa_printf(MSG_DEBUG, "hostapd_logger: %s", buf);
    821 	bin_clear_free(buf, buflen);
    822 }
    823 #endif /* CONFIG_NO_HOSTAPD_LOGGER */
    824 
    825 
    826 const char * debug_level_str(int level)
    827 {
    828 	switch (level) {
    829 	case MSG_EXCESSIVE:
    830 		return "EXCESSIVE";
    831 	case MSG_MSGDUMP:
    832 		return "MSGDUMP";
    833 	case MSG_DEBUG:
    834 		return "DEBUG";
    835 	case MSG_INFO:
    836 		return "INFO";
    837 	case MSG_WARNING:
    838 		return "WARNING";
    839 	case MSG_ERROR:
    840 		return "ERROR";
    841 	default:
    842 		return "?";
    843 	}
    844 }
    845 
    846 
    847 int str_to_debug_level(const char *s)
    848 {
    849 	if (os_strcasecmp(s, "EXCESSIVE") == 0)
    850 		return MSG_EXCESSIVE;
    851 	if (os_strcasecmp(s, "MSGDUMP") == 0)
    852 		return MSG_MSGDUMP;
    853 	if (os_strcasecmp(s, "DEBUG") == 0)
    854 		return MSG_DEBUG;
    855 	if (os_strcasecmp(s, "INFO") == 0)
    856 		return MSG_INFO;
    857 	if (os_strcasecmp(s, "WARNING") == 0)
    858 		return MSG_WARNING;
    859 	if (os_strcasecmp(s, "ERROR") == 0)
    860 		return MSG_ERROR;
    861 	return -1;
    862 }
    863