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 #ifndef WPA_DEBUG_H 10 #define WPA_DEBUG_H 11 12 #include "wpabuf.h" 13 14 extern int wpa_debug_level; 15 extern int wpa_debug_show_keys; 16 extern int wpa_debug_timestamp; 17 extern int wpa_debug_syslog; 18 19 /* Debugging function - conditional printf and hex dump. Driver wrappers can 20 * use these for debugging purposes. */ 21 22 enum { 23 MSG_EXCESSIVE, MSG_MSGDUMP, MSG_DEBUG, MSG_INFO, MSG_WARNING, MSG_ERROR 24 }; 25 26 #ifdef CONFIG_NO_STDOUT_DEBUG 27 28 #define wpa_debug_print_timestamp() do { } while (0) 29 #define wpa_printf(args...) do { } while (0) 30 #define wpa_hexdump(l,t,b,le) do { } while (0) 31 #define wpa_hexdump_buf(l,t,b) do { } while (0) 32 #define wpa_hexdump_key(l,t,b,le) do { } while (0) 33 #define wpa_hexdump_buf_key(l,t,b) do { } while (0) 34 #define wpa_hexdump_ascii(l,t,b,le) do { } while (0) 35 #define wpa_hexdump_ascii_key(l,t,b,le) do { } while (0) 36 #define wpa_debug_open_file(p) do { } while (0) 37 #define wpa_debug_close_file() do { } while (0) 38 #define wpa_debug_setup_stdout() do { } while (0) 39 #define wpa_dbg(args...) do { } while (0) 40 41 static inline int wpa_debug_reopen_file(void) 42 { 43 return 0; 44 } 45 46 #else /* CONFIG_NO_STDOUT_DEBUG */ 47 48 int wpa_debug_open_file(const char *path); 49 int wpa_debug_reopen_file(void); 50 void wpa_debug_close_file(void); 51 void wpa_debug_setup_stdout(void); 52 void wpa_debug_stop_log(void); 53 54 /** 55 * wpa_debug_printf_timestamp - Print timestamp for debug output 56 * 57 * This function prints a timestamp in seconds_from_1970.microsoconds 58 * format if debug output has been configured to include timestamps in debug 59 * messages. 60 */ 61 void wpa_debug_print_timestamp(void); 62 63 /** 64 * wpa_printf - conditional printf 65 * @level: priority level (MSG_*) of the message 66 * @fmt: printf format string, followed by optional arguments 67 * 68 * This function is used to print conditional debugging and error messages. The 69 * output may be directed to stdout, stderr, and/or syslog based on 70 * configuration. 71 * 72 * Note: New line '\n' is added to the end of the text when printing to stdout. 73 */ 74 void wpa_printf(int level, const char *fmt, ...) 75 PRINTF_FORMAT(2, 3); 76 77 /** 78 * wpa_hexdump - conditional hex dump 79 * @level: priority level (MSG_*) of the message 80 * @title: title of for the message 81 * @buf: data buffer to be dumped 82 * @len: length of the buf 83 * 84 * This function is used to print conditional debugging and error messages. The 85 * output may be directed to stdout, stderr, and/or syslog based on 86 * configuration. The contents of buf is printed out has hex dump. 87 */ 88 void wpa_hexdump(int level, const char *title, const void *buf, size_t len); 89 90 static inline void wpa_hexdump_buf(int level, const char *title, 91 const struct wpabuf *buf) 92 { 93 wpa_hexdump(level, title, buf ? wpabuf_head(buf) : NULL, 94 buf ? wpabuf_len(buf) : 0); 95 } 96 97 /** 98 * wpa_hexdump_key - conditional hex dump, hide keys 99 * @level: priority level (MSG_*) of the message 100 * @title: title of for the message 101 * @buf: data buffer to be dumped 102 * @len: length of the buf 103 * 104 * This function is used to print conditional debugging and error messages. The 105 * output may be directed to stdout, stderr, and/or syslog based on 106 * configuration. The contents of buf is printed out has hex dump. This works 107 * like wpa_hexdump(), but by default, does not include secret keys (passwords, 108 * etc.) in debug output. 109 */ 110 void wpa_hexdump_key(int level, const char *title, const void *buf, size_t len); 111 112 static inline void wpa_hexdump_buf_key(int level, const char *title, 113 const struct wpabuf *buf) 114 { 115 wpa_hexdump_key(level, title, buf ? wpabuf_head(buf) : NULL, 116 buf ? wpabuf_len(buf) : 0); 117 } 118 119 /** 120 * wpa_hexdump_ascii - conditional hex dump 121 * @level: priority level (MSG_*) of the message 122 * @title: title of for the message 123 * @buf: data buffer to be dumped 124 * @len: length of the buf 125 * 126 * This function is used to print conditional debugging and error messages. The 127 * output may be directed to stdout, stderr, and/or syslog based on 128 * configuration. The contents of buf is printed out has hex dump with both 129 * the hex numbers and ASCII characters (for printable range) are shown. 16 130 * bytes per line will be shown. 131 */ 132 void wpa_hexdump_ascii(int level, const char *title, const void *buf, 133 size_t len); 134 135 /** 136 * wpa_hexdump_ascii_key - conditional hex dump, hide keys 137 * @level: priority level (MSG_*) of the message 138 * @title: title of for the message 139 * @buf: data buffer to be dumped 140 * @len: length of the buf 141 * 142 * This function is used to print conditional debugging and error messages. The 143 * output may be directed to stdout, stderr, and/or syslog based on 144 * configuration. The contents of buf is printed out has hex dump with both 145 * the hex numbers and ASCII characters (for printable range) are shown. 16 146 * bytes per line will be shown. This works like wpa_hexdump_ascii(), but by 147 * default, does not include secret keys (passwords, etc.) in debug output. 148 */ 149 void wpa_hexdump_ascii_key(int level, const char *title, const void *buf, 150 size_t len); 151 152 /* 153 * wpa_dbg() behaves like wpa_msg(), but it can be removed from build to reduce 154 * binary size. As such, it should be used with debugging messages that are not 155 * needed in the control interface while wpa_msg() has to be used for anything 156 * that needs to shown to control interface monitors. 157 */ 158 #define wpa_dbg(args...) wpa_msg(args) 159 160 #endif /* CONFIG_NO_STDOUT_DEBUG */ 161 162 163 #ifdef CONFIG_NO_WPA_MSG 164 #define wpa_msg(args...) do { } while (0) 165 #define wpa_msg_ctrl(args...) do { } while (0) 166 #define wpa_msg_global(args...) do { } while (0) 167 #define wpa_msg_global_ctrl(args...) do { } while (0) 168 #define wpa_msg_no_global(args...) do { } while (0) 169 #define wpa_msg_global_only(args...) do { } while (0) 170 #define wpa_msg_register_cb(f) do { } while (0) 171 #define wpa_msg_register_ifname_cb(f) do { } while (0) 172 #else /* CONFIG_NO_WPA_MSG */ 173 /** 174 * wpa_msg - Conditional printf for default target and ctrl_iface monitors 175 * @ctx: Pointer to context data; this is the ctx variable registered 176 * with struct wpa_driver_ops::init() 177 * @level: priority level (MSG_*) of the message 178 * @fmt: printf format string, followed by optional arguments 179 * 180 * This function is used to print conditional debugging and error messages. The 181 * output may be directed to stdout, stderr, and/or syslog based on 182 * configuration. This function is like wpa_printf(), but it also sends the 183 * same message to all attached ctrl_iface monitors. 184 * 185 * Note: New line '\n' is added to the end of the text when printing to stdout. 186 */ 187 void wpa_msg(void *ctx, int level, const char *fmt, ...) PRINTF_FORMAT(3, 4); 188 189 /** 190 * wpa_msg_ctrl - Conditional printf for ctrl_iface monitors 191 * @ctx: Pointer to context data; this is the ctx variable registered 192 * with struct wpa_driver_ops::init() 193 * @level: priority level (MSG_*) of the message 194 * @fmt: printf format string, followed by optional arguments 195 * 196 * This function is used to print conditional debugging and error messages. 197 * This function is like wpa_msg(), but it sends the output only to the 198 * attached ctrl_iface monitors. In other words, it can be used for frequent 199 * events that do not need to be sent to syslog. 200 */ 201 void wpa_msg_ctrl(void *ctx, int level, const char *fmt, ...) 202 PRINTF_FORMAT(3, 4); 203 204 /** 205 * wpa_msg_global - Global printf for ctrl_iface monitors 206 * @ctx: Pointer to context data; this is the ctx variable registered 207 * with struct wpa_driver_ops::init() 208 * @level: priority level (MSG_*) of the message 209 * @fmt: printf format string, followed by optional arguments 210 * 211 * This function is used to print conditional debugging and error messages. 212 * This function is like wpa_msg(), but it sends the output as a global event, 213 * i.e., without being specific to an interface. For backwards compatibility, 214 * an old style event is also delivered on one of the interfaces (the one 215 * specified by the context data). 216 */ 217 void wpa_msg_global(void *ctx, int level, const char *fmt, ...) 218 PRINTF_FORMAT(3, 4); 219 220 /** 221 * wpa_msg_global_ctrl - Conditional global printf for ctrl_iface monitors 222 * @ctx: Pointer to context data; this is the ctx variable registered 223 * with struct wpa_driver_ops::init() 224 * @level: priority level (MSG_*) of the message 225 * @fmt: printf format string, followed by optional arguments 226 * 227 * This function is used to print conditional debugging and error messages. 228 * This function is like wpa_msg_global(), but it sends the output only to the 229 * attached global ctrl_iface monitors. In other words, it can be used for 230 * frequent events that do not need to be sent to syslog. 231 */ 232 void wpa_msg_global_ctrl(void *ctx, int level, const char *fmt, ...) 233 PRINTF_FORMAT(3, 4); 234 235 /** 236 * wpa_msg_no_global - Conditional printf for ctrl_iface monitors 237 * @ctx: Pointer to context data; this is the ctx variable registered 238 * with struct wpa_driver_ops::init() 239 * @level: priority level (MSG_*) of the message 240 * @fmt: printf format string, followed by optional arguments 241 * 242 * This function is used to print conditional debugging and error messages. 243 * This function is like wpa_msg(), but it does not send the output as a global 244 * event. 245 */ 246 void wpa_msg_no_global(void *ctx, int level, const char *fmt, ...) 247 PRINTF_FORMAT(3, 4); 248 249 /** 250 * wpa_msg_global_only - Conditional printf for ctrl_iface monitors 251 * @ctx: Pointer to context data; this is the ctx variable registered 252 * with struct wpa_driver_ops::init() 253 * @level: priority level (MSG_*) of the message 254 * @fmt: printf format string, followed by optional arguments 255 * 256 * This function is used to print conditional debugging and error messages. 257 * This function is like wpa_msg_global(), but it sends the output only as a 258 * global event. 259 */ 260 void wpa_msg_global_only(void *ctx, int level, const char *fmt, ...) 261 PRINTF_FORMAT(3, 4); 262 263 enum wpa_msg_type { 264 WPA_MSG_PER_INTERFACE, 265 WPA_MSG_GLOBAL, 266 WPA_MSG_NO_GLOBAL, 267 WPA_MSG_ONLY_GLOBAL, 268 }; 269 270 typedef void (*wpa_msg_cb_func)(void *ctx, int level, enum wpa_msg_type type, 271 const char *txt, size_t len); 272 273 /** 274 * wpa_msg_register_cb - Register callback function for wpa_msg() messages 275 * @func: Callback function (%NULL to unregister) 276 */ 277 void wpa_msg_register_cb(wpa_msg_cb_func func); 278 279 typedef const char * (*wpa_msg_get_ifname_func)(void *ctx); 280 void wpa_msg_register_ifname_cb(wpa_msg_get_ifname_func func); 281 282 #endif /* CONFIG_NO_WPA_MSG */ 283 284 #ifdef CONFIG_NO_HOSTAPD_LOGGER 285 #define hostapd_logger(args...) do { } while (0) 286 #define hostapd_logger_register_cb(f) do { } while (0) 287 #else /* CONFIG_NO_HOSTAPD_LOGGER */ 288 void hostapd_logger(void *ctx, const u8 *addr, unsigned int module, int level, 289 const char *fmt, ...) PRINTF_FORMAT(5, 6); 290 291 typedef void (*hostapd_logger_cb_func)(void *ctx, const u8 *addr, 292 unsigned int module, int level, 293 const char *txt, size_t len); 294 295 /** 296 * hostapd_logger_register_cb - Register callback function for hostapd_logger() 297 * @func: Callback function (%NULL to unregister) 298 */ 299 void hostapd_logger_register_cb(hostapd_logger_cb_func func); 300 #endif /* CONFIG_NO_HOSTAPD_LOGGER */ 301 302 #define HOSTAPD_MODULE_IEEE80211 0x00000001 303 #define HOSTAPD_MODULE_IEEE8021X 0x00000002 304 #define HOSTAPD_MODULE_RADIUS 0x00000004 305 #define HOSTAPD_MODULE_WPA 0x00000008 306 #define HOSTAPD_MODULE_DRIVER 0x00000010 307 #define HOSTAPD_MODULE_MLME 0x00000040 308 309 enum hostapd_logger_level { 310 HOSTAPD_LEVEL_DEBUG_VERBOSE = 0, 311 HOSTAPD_LEVEL_DEBUG = 1, 312 HOSTAPD_LEVEL_INFO = 2, 313 HOSTAPD_LEVEL_NOTICE = 3, 314 HOSTAPD_LEVEL_WARNING = 4 315 }; 316 317 318 #ifdef CONFIG_DEBUG_SYSLOG 319 320 void wpa_debug_open_syslog(void); 321 void wpa_debug_close_syslog(void); 322 323 #else /* CONFIG_DEBUG_SYSLOG */ 324 325 static inline void wpa_debug_open_syslog(void) 326 { 327 } 328 329 static inline void wpa_debug_close_syslog(void) 330 { 331 } 332 333 #endif /* CONFIG_DEBUG_SYSLOG */ 334 335 #ifdef CONFIG_DEBUG_LINUX_TRACING 336 337 int wpa_debug_open_linux_tracing(void); 338 void wpa_debug_close_linux_tracing(void); 339 340 #else /* CONFIG_DEBUG_LINUX_TRACING */ 341 342 static inline int wpa_debug_open_linux_tracing(void) 343 { 344 return 0; 345 } 346 347 static inline void wpa_debug_close_linux_tracing(void) 348 { 349 } 350 351 #endif /* CONFIG_DEBUG_LINUX_TRACING */ 352 353 354 #ifdef EAPOL_TEST 355 #define WPA_ASSERT(a) \ 356 do { \ 357 if (!(a)) { \ 358 printf("WPA_ASSERT FAILED '" #a "' " \ 359 "%s %s:%d\n", \ 360 __FUNCTION__, __FILE__, __LINE__); \ 361 exit(1); \ 362 } \ 363 } while (0) 364 #else 365 #define WPA_ASSERT(a) do { } while (0) 366 #endif 367 368 const char * debug_level_str(int level); 369 int str_to_debug_level(const char *s); 370 371 #endif /* WPA_DEBUG_H */ 372