LCOV - code coverage report
Current view: top level - src/utils - wpa_debug.h (source / functions) Hit Total Coverage
Test: wpa_supplicant/hostapd combined for hwsim test run 1401264779 Lines: 8 10 80.0 %
Date: 2014-05-28 Functions: 3 4 75.0 %

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

Generated by: LCOV version 1.10