wslog.h

Go to the documentation of this file.

 
#ifndef __WSLOG_H__
#define __WSLOG_H__
 
#include <inttypes.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdarg.h>
#include <time.h>
#include <glib.h>
 
#include <ws_symbol_export.h>
#include <ws_attributes.h>
#include <ws_log_defs.h>
#include <ws_posix_compat.h>
#include "ws_getopt.h"
 
#ifdef WS_LOG_DOMAIN
#define _LOG_DOMAIN WS_LOG_DOMAIN
#else
#define _LOG_DOMAIN ""
#endif
 
#ifdef WS_DEBUG
#define _LOG_DEBUG_ENABLED true
#else
#define _LOG_DEBUG_ENABLED false
#endif
 
/*
 * Define the macro WS_LOG_DOMAIN *before* including this header,
 * for example:
 *   #define WS_LOG_DOMAIN LOG_DOMAIN_MAIN
 */
 
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
 
/*
 * Console open preference is stored in the Windows registry.
 *   HKEY_CURRENT_USER\Software\Wireshark\ConsoleOpen
 */
#define LOG_HKCU_CONSOLE_OPEN   "ConsoleOpen"

typedef enum {
    LOG_CONSOLE_OPEN_NEVER,   
    LOG_CONSOLE_OPEN_AUTO,    
    LOG_CONSOLE_OPEN_ALWAYS,  
} ws_log_console_open_pref;
 
 
WSUTIL_EXPORT
ws_log_console_open_pref ws_log_console_open;

typedef struct {
    struct tm   tstamp_secs;  
    long        nanosecs;     
    intmax_t    pid;          
} ws_log_manifest_t;

typedef void (ws_log_writer_cb)(const char *domain, enum ws_log_level level,
                            const char *file, long line, const char *func,
                            const char *fatal_msg, ws_log_manifest_t *mft,
                            const char *user_format, va_list user_ap,
                            void *user_data);
 

typedef void (ws_log_writer_free_data_cb)(void *user_data);

WS_DLL_PUBLIC
void ws_log_file_writer(FILE *fp, const char *domain, enum ws_log_level level,
                            const char *file, long line, const char *func,
                            ws_log_manifest_t *mft,
                            const char *user_format, va_list user_ap);

WS_DLL_PUBLIC
void ws_log_console_writer(const char *domain, enum ws_log_level level,
                            const char *file, long line, const char *func,
                            ws_log_manifest_t *mft,
                            const char *user_format, va_list user_ap);
 

WS_DLL_PUBLIC
void ws_log_console_writer_set_use_stdout(bool use_stdout);
 

WS_DLL_PUBLIC
WS_RETNONNULL
const char *ws_log_level_to_string(enum ws_log_level level);
 

WS_DLL_PUBLIC
bool ws_log_msg_is_active(const char *domain, enum ws_log_level level);
 

WS_DLL_PUBLIC
enum ws_log_level ws_log_get_level(void);
 

WS_DLL_PUBLIC
enum ws_log_level ws_log_set_level(enum ws_log_level level);
 

WS_DLL_PUBLIC
enum ws_log_level ws_log_set_level_str(const char *str_level);
 

WS_DLL_PUBLIC
void ws_log_set_domain_filter(const char *domain_filter);

WS_DLL_PUBLIC
void ws_log_set_fatal_domain_filter(const char *domain_filter);
 

WS_DLL_PUBLIC
void ws_log_set_debug_filter(const char *str_filter);
 

WS_DLL_PUBLIC
void ws_log_set_noisy_filter(const char *str_filter);
 

WS_DLL_PUBLIC
enum ws_log_level ws_log_set_fatal_level(enum ws_log_level level);
 

WS_DLL_PUBLIC
enum ws_log_level ws_log_set_fatal_level_str(const char *str_level);
 

WS_DLL_PUBLIC
void ws_log_set_fatal_count(uint32_t count);
 

WS_DLL_PUBLIC
bool ws_log_set_fatal_count_str(const char *str_count);
 

WS_DLL_PUBLIC
void ws_log_set_writer(ws_log_writer_cb *writer);
 

WS_DLL_PUBLIC
void ws_log_set_writer_with_data(ws_log_writer_cb *writer,
                        void *user_data,
                        ws_log_writer_free_data_cb *free_user_data);
 
 
#define LOG_ARGS_NOEXIT -1
 
#define LONGOPT_WSLOG_LOG_LEVEL            LONGOPT_BASE_WSLOG+1
#define LONGOPT_WSLOG_LOG_DOMAIN           LONGOPT_BASE_WSLOG+2
#define LONGOPT_WSLOG_LOG_FILE             LONGOPT_BASE_WSLOG+3
#define LONGOPT_WSLOG_LOG_FATAL            LONGOPT_BASE_WSLOG+4
#define LONGOPT_WSLOG_LOG_FATAL_COUNT      LONGOPT_BASE_WSLOG+5
#define LONGOPT_WSLOG_LOG_FATAL_DOMAIN     LONGOPT_BASE_WSLOG+6
#define LONGOPT_WSLOG_LOG_DEBUG            LONGOPT_BASE_WSLOG+7
#define LONGOPT_WSLOG_LOG_NOISY            LONGOPT_BASE_WSLOG+8

#define LONGOPT_WSLOG \
    {"log-level",             ws_required_argument, NULL, LONGOPT_WSLOG_LOG_LEVEL},  \
    {"log-domain",            ws_required_argument, NULL, LONGOPT_WSLOG_LOG_DOMAIN}, \
    /* Alias "domain" and "domains". */                                              \
    {"log-domains",           ws_required_argument, NULL, LONGOPT_WSLOG_LOG_DOMAIN}, \
    {"log-file",              ws_required_argument, NULL, LONGOPT_WSLOG_LOG_FILE},   \
    {"log-fatal",             ws_required_argument, NULL, LONGOPT_WSLOG_LOG_FATAL},  \
    {"log-fatal-count",       ws_required_argument, NULL, LONGOPT_WSLOG_LOG_FATAL_COUNT},  \
    /* Alias "domain" and "domains". */                                                    \
    {"log-fatal-domain",      ws_required_argument, NULL, LONGOPT_WSLOG_LOG_FATAL_DOMAIN}, \
    {"log-fatal-domains",     ws_required_argument, NULL, LONGOPT_WSLOG_LOG_FATAL_DOMAIN}, \
    {"log-debug",             ws_required_argument, NULL, LONGOPT_WSLOG_LOG_DEBUG}, \
    {"log-noisy",             ws_required_argument, NULL, LONGOPT_WSLOG_LOG_NOISY},

WS_DLL_PUBLIC
int ws_log_parse_args(int *argc_ptr, char *argv[],
                        const char* optstring, const struct ws_option* long_options,
                        void (*vcmdarg_err)(const char *, va_list ap),
                        int exit_failure);
 

WS_DLL_PUBLIC
bool ws_log_is_wslog_arg(int arg);
 

WS_DLL_PUBLIC
void ws_log_init(void (*vcmdarg_err)(const char *, va_list ap), const char* console_title);
 

WS_DLL_PUBLIC
void ws_log_init_with_writer(ws_log_writer_cb *writer,
                        void (*vcmdarg_err)(const char *, va_list ap), const char* console_title);
 

WS_DLL_PUBLIC
void ws_log_init_with_writer_and_data(ws_log_writer_cb *writer,
                        void *user_data,
                        ws_log_writer_free_data_cb *free_user_data,
                        void (*vcmdarg_err)(const char *, va_list ap), const char* console_title);
 

WS_DLL_PUBLIC
void ws_log(const char *domain, enum ws_log_level level,
                    const char *format, ...) G_GNUC_PRINTF(3,4);
 

WS_DLL_PUBLIC
void ws_logv(const char *domain, enum ws_log_level level,
                    const char *format, va_list ap);
 

WS_DLL_PUBLIC
void ws_log_full(const char *domain, enum ws_log_level level,
                    const char *file, long line, const char *func,
                    const char *format, ...) G_GNUC_PRINTF(6,7);
 

WS_DLL_PUBLIC
void ws_logv_full(const char *domain, enum ws_log_level level,
                    const char *file, long line, const char *func,
                    const char *format, va_list ap);
 

WS_DLL_PUBLIC
WS_NORETURN
void ws_log_fatal_full(const char *domain, enum ws_log_level level,
                    const char *file, long line, const char *func,
                    const char *format, ...) G_GNUC_PRINTF(6,7);
 
 
/*
 * The if condition avoids -Wunused warnings for variables used only with
 * WS_DEBUG, typically inside a ws_debug() call. The compiler will
 * optimize away the dead execution branch.
 */
#define _LOG_IF_ACTIVE(active, level, file, line, func, ...) \
        do {                                        \
            if (active) {                           \
                ws_log_full(_LOG_DOMAIN, level,     \
                            file, line, func,       \
                            __VA_ARGS__);           \
            }                                       \
        } while (0)
 
#define _LOG_FULL(active, level, ...) \
        _LOG_IF_ACTIVE(active, level, __FILE__, __LINE__, __func__, __VA_ARGS__)
 
#define _LOG_SIMPLE(active, level, ...) \
        _LOG_IF_ACTIVE(active, level, NULL, -1, NULL, __VA_ARGS__)

#define ws_error(...) \
        ws_log_fatal_full(_LOG_DOMAIN, LOG_LEVEL_ERROR, \
                            __FILE__, __LINE__, __func__, __VA_ARGS__)

#define ws_critical(...) \
        _LOG_FULL(true, LOG_LEVEL_CRITICAL, __VA_ARGS__)

#define ws_warning(...) \
        _LOG_FULL(true, LOG_LEVEL_WARNING, __VA_ARGS__)

#define ws_message(...) \
        _LOG_SIMPLE(true, LOG_LEVEL_MESSAGE, __VA_ARGS__)

#define ws_info(...) \
        _LOG_SIMPLE(true, LOG_LEVEL_INFO, __VA_ARGS__)
 

#define ws_debug(...) \
        _LOG_FULL(_LOG_DEBUG_ENABLED, LOG_LEVEL_DEBUG, __VA_ARGS__)

#define ws_noisy(...) \
        _LOG_FULL(_LOG_DEBUG_ENABLED, LOG_LEVEL_NOISY, __VA_ARGS__)
 

#define WS_DEBUG_HERE(...) \
        _LOG_FULL(true, LOG_LEVEL_ECHO, __VA_ARGS__)

#define WS_NOT_IMPLEMENTED() \
        ws_error("Not implemented yet")
 

WS_DLL_PUBLIC
void ws_log_utf8_full(const char *domain, enum ws_log_level level,
                    const char *file, long line, const char *func,
                    const char *string, ssize_t length, const char *endptr);
 

#define ws_log_utf8(str, len, endptr) \
    do {                                                        \
        if (_LOG_DEBUG_ENABLED) {                               \
            ws_log_utf8_full(LOG_DOMAIN_UTF_8, LOG_LEVEL_DEBUG, \
                                __FILE__, __LINE__, __func__,   \
                                str, len, endptr);              \
        }                                                       \
    } while (0)
 

WS_DLL_PUBLIC
void ws_log_buffer_full(const char *domain, enum ws_log_level level,
                    const char *file, long line, const char *func,
                    const uint8_t *buffer, size_t size,
                    size_t max_bytes_len, const char *msg);

#define ws_log_buffer(buf, size, msg) \
        do {                                                        \
            if (_LOG_DEBUG_ENABLED) {                               \
                ws_log_buffer_full(_LOG_DOMAIN, LOG_LEVEL_DEBUG,    \
                        __FILE__, __LINE__, __func__,               \
                        buf, size, 36, msg ? msg : #buf);           \
            }                                                       \
        } while (0)
 

WS_DLL_PUBLIC
void ws_log_write_always_full(const char *domain, enum ws_log_level level,
                    const char *file, long line, const char *func,
                    const char *format, ...) G_GNUC_PRINTF(6,7);
 

WS_DLL_PUBLIC
void ws_log_add_custom_file(FILE *fp);
 

WS_DLL_PUBLIC
void ws_log_print_usage(FILE *fp);
 
#ifdef __cplusplus
}
#endif /* __cplusplus */
 
#endif /* __WSLOG_H__ */