log.h

Go to the documentation of this file.

/* Copyright (c) 2001, Matej Pfajfar.
 * Copyright (c) 2001-2004, Roger Dingledine.
 * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
 * Copyright (c) 2007-2010, The Tor Project, Inc. */
/* See LICENSE for licensing information */

#ifndef _TOR_LOG_H

#include "compat.h"

#ifdef HAVE_SYSLOG_H
#include <syslog.h>
#define LOG_WARN LOG_WARNING
#if LOG_DEBUG < LOG_ERR
#error "Your syslog.h thinks high numbers are more important.  " \
       "We aren't prepared to deal with that."
#endif
#else
/* Note: Syslog's logging code refers to priorities, with 0 being the most
 * important.  Thus, all our comparisons needed to be reversed when we added
 * syslog support.
 *
 * The upshot of this is that comments about log levels may be messed up: for
 * "maximum severity" read "most severe" and "numerically *lowest* severity".
 */

#define LOG_DEBUG   7

#define LOG_INFO    6

#define LOG_NOTICE  5

#define LOG_WARN    4

#define LOG_ERR     3
#endif

/* Logging domains */

#define LD_GENERAL  (1u<<0)

#define LD_CRYPTO   (1u<<1)

#define LD_NET      (1u<<2)

#define LD_CONFIG   (1u<<3)

#define LD_FS       (1u<<4)

#define LD_PROTOCOL (1u<<5)

#define LD_MM       (1u<<6)

#define LD_HTTP     (1u<<7)

#define LD_APP      (1u<<8)

#define LD_CONTROL  (1u<<9)

#define LD_CIRC     (1u<<10)

#define LD_REND     (1u<<11)

#define LD_BUG      (1u<<12)

#define LD_DIR      (1u<<13)

#define LD_DIRSERV  (1u<<14)

#define LD_OR       (1u<<15)

#define LD_EDGE     (1u<<16)
#define LD_EXIT     LD_EDGE

#define LD_ACCT     (1u<<17)

#define LD_HIST     (1u<<18)

#define LD_HANDSHAKE (1u<<19)

#define N_LOGGING_DOMAINS 20

typedef uint32_t log_domain_mask_t;

typedef struct log_severity_list_t {
  log_domain_mask_t masks[LOG_DEBUG-LOG_ERR+1];
} log_severity_list_t;

#ifdef LOG_PRIVATE

#define SEVERITY_MASK_IDX(sev) ((sev) - LOG_ERR)
#endif

typedef void (*log_callback)(int severity, uint32_t domain, const char *msg);

void init_logging(void);
int parse_log_level(const char *level);
const char *log_level_to_string(int level);
int parse_log_severity_config(const char **cfg,
                              log_severity_list_t *severity_out);
void set_log_severity_config(int minSeverity, int maxSeverity,
                             log_severity_list_t *severity_out);
void add_stream_log(const log_severity_list_t *severity, const char *name,
                    int fd);
int add_file_log(const log_severity_list_t *severity, const char *filename);
#ifdef HAVE_SYSLOG_H
int add_syslog_log(const log_severity_list_t *severity);
#endif
int add_callback_log(const log_severity_list_t *severity, log_callback cb);
int get_min_log_level(void);
void switch_logs_debug(void);
void logs_free_all(void);
void add_temp_log(int min_severity);
void close_temp_logs(void);
void rollback_log_changes(void);
void mark_logs_temp(void);
void change_callback_log_severity(int loglevelMin, int loglevelMax,
                                  log_callback cb);
void log_set_application_name(const char *name);

/* Outputs a message to stdout */
void tor_log(int severity, log_domain_mask_t domain, const char *format, ...)
  CHECK_PRINTF(3,4);
#define log tor_log /* hack it so we don't conflict with log() as much */

#ifdef __GNUC__
extern int _log_global_min_severity;

void _log_fn(int severity, log_domain_mask_t domain,
             const char *funcname, const char *format, ...)
  CHECK_PRINTF(4,5);
#define log_fn(severity, domain, args...)               \
  _log_fn(severity, domain, __PRETTY_FUNCTION__, args)
#define log_debug(domain, args...)                                      \
  STMT_BEGIN                                                            \
    if (PREDICT_UNLIKELY(_log_global_min_severity == LOG_DEBUG))        \
      _log_fn(LOG_DEBUG, domain, __PRETTY_FUNCTION__, args);            \
  STMT_END
#define log_info(domain, args...)                           \
  _log_fn(LOG_INFO, domain, __PRETTY_FUNCTION__, args)
#define log_notice(domain, args...)                         \
  _log_fn(LOG_NOTICE, domain, __PRETTY_FUNCTION__, args)
#define log_warn(domain, args...)                           \
  _log_fn(LOG_WARN, domain, __PRETTY_FUNCTION__, args)
#define log_err(domain, args...)                            \
  _log_fn(LOG_ERR, domain, __PRETTY_FUNCTION__, args)

#else /* ! defined(__GNUC__) */

void _log_fn(int severity, log_domain_mask_t domain, const char *format, ...);
void _log_debug(log_domain_mask_t domain, const char *format, ...);
void _log_info(log_domain_mask_t domain, const char *format, ...);
void _log_notice(log_domain_mask_t domain, const char *format, ...);
void _log_warn(log_domain_mask_t domain, const char *format, ...);
void _log_err(log_domain_mask_t domain, const char *format, ...);

#if defined(_MSC_VER) && _MSC_VER < 1300
/* MSVC 6 and earlier don't have __func__, or even __LINE__. */
#define log_fn _log_fn
#define log_debug _log_debug
#define log_info _log_info
#define log_notice _log_notice
#define log_warn _log_warn
#define log_err _log_err
#else
/* We don't have GCC's varargs macros, so use a global variable to pass the
 * function name to log_fn */
extern const char *_log_fn_function_name;
/* We abuse the comma operator here, since we can't use the standard
 * do {...} while (0) trick to wrap this macro, since the macro can't take
 * arguments. */
#define log_fn (_log_fn_function_name=__func__),_log_fn
#define log_debug (_log_fn_function_name=__func__),_log_debug
#define log_info (_log_fn_function_name=__func__),_log_info
#define log_notice (_log_fn_function_name=__func__),_log_notice
#define log_warn (_log_fn_function_name=__func__),_log_warn
#define log_err (_log_fn_function_name=__func__),_log_err
#endif

#endif /* !GNUC */

# define _TOR_LOG_H
#endif

---