1

     2

#include "log.h"

     3

#include "str.h"

     4

     5

#include <stdio.h>

     6

#include <stdarg.h>

     7

#include <string.h>

     8

     9

/**

    10

 * The default log output func

    11

 */

    12

void log_default_func (const char *line, void *arg)

    13

{

    14

    (void) arg;

    15

    16

    // display

    17

    printf("%s\n", line);

    18

}

    19

    20

/**

    21

 * The global log level

    22

 */

    23

static enum log_level _log_level = LOG_LEVEL_DEFAULT;

    24

    25

/**

    26

 * The global log output func

    27

 */

    28

static struct log_output_ctx {

    29

    /** The function itself */

    30

    log_output_func func;

    31

    32

    /** The arg */

    33

    void *arg;

    34

} _log_output_ctx = { log_default_func, NULL };

    35

    36

/**

    37

 * List of log level names

    38

 */

    39

const char *log_level_names[] = {

    40

    "DEBUG",

    41

    "INFO",

    42

    "WARN",

    43

    "ERROR",

    44

    "FATAL",

    45

    NULL

    46

};

    47

    48

#define _LOG_LEVEL_NAME(ll) case LOG_ ## ll: return #ll;

    49

const char *log_level_name (enum log_level level)

    50

{

    51

    switch (level) {

    52

        _LOG_LEVEL_NAME(DEBUG)

    53

        _LOG_LEVEL_NAME(INFO)

    54

        _LOG_LEVEL_NAME(WARN)

    55

        _LOG_LEVEL_NAME(ERROR)

    56

        _LOG_LEVEL_NAME(FATAL)

    57

        default: return "???";

    58

    }

    59

}

    60

#undef _LOG_LEVEL_NAME

    61

    62

void set_log_level (enum log_level level)

    63

{

    64

    // meep meep

    65

    _log_level = level;

    66

}

    67

    68

void log_set_func (log_output_func func, void *arg)

    69

{

    70

    // replace the current one

    71

    _log_output_ctx.func = func ? func : log_default_func;

    72

    _log_output_ctx.arg = arg;

    73

}

    74

    75

/**

    76

 * Format the full output line, and pass it to the log_output_func. The line will be of the form:

    77

 *  "[<level>] <func> : <log_fmt> [ <user_fmt> ]"

    78

 */

    79

static void log_output (enum log_level level, const char *func, const char *user_fmt, va_list user_fmtargs, const char *log_fmt, ...)

    80

{

    81

    char buf[LOG_MSG_MAX], *buf_ptr = buf;

    82

    size_t buf_size = sizeof(buf);

    83

    84

    // filter out?

    85

    if (level < _log_level)

    86

        return;

    87

    88

    // output the header

    89

    buf_ptr += str_advance(NULL, &buf_size, str_append_fmt(buf_ptr, buf_size, "[%5s] %20s : ", log_level_name(level), func));

    90

    91

    // output the user data

    92

    buf_ptr += str_advance(NULL, &buf_size, str_append_fmt_va(buf_ptr, buf_size, user_fmt, user_fmtargs));

    93

    94

    // output the suffix

    95

    if (log_fmt) {

    96

        va_list vargs;

    97

    98

        va_start(vargs, log_fmt);

    99

        buf_ptr += str_advance(NULL, &buf_size, str_append_fmt_va(buf_ptr, buf_size, log_fmt, vargs));

   100

        va_end(vargs);

   101

    }

   102

   103

    // send it to the output func

   104

    _log_output_ctx.func(buf, _log_output_ctx.arg);

   105

}

   106

   107

void log_msg (enum log_level level, const char *func, const char *format, ...)

   108

{

   109

    va_list vargs;

   110

   111

    // formatted output: no suffix

   112

    va_start(vargs, format);

   113

    log_output(level, func, format, vargs, NULL);

   114

    va_end(vargs);

   115

}

   116

   117

void _log_err_code (enum log_level level, err_t err, const char *func, const char *format, ...)

   118

{

   119

    va_list vargs;

   120

   121

    // formatted output: suffix error_name()

   122

    va_start(vargs, format);

   123

    log_output(level, func, format, vargs, ": %s", error_name(err));

   124

    va_end(vargs);

   125

}

   126

   127

void _log_err (enum log_level level, const error_t *err, const char *func, const char *format, ...)

   128

{

   129

    va_list vargs;

   130

   131

    // formatted output: suffix error_msg()

   132

    va_start(vargs, format);

   133

    log_output(level, func, format, vargs, ": %s", error_msg(err));

   134

    va_end(vargs);

   135

}

   136

   137

void _log_perr (enum log_level level, const char *func, const char *format, ...)

   138

{

   139

    va_list vargs;

   140

   141

    // formatted output: suffix strerror()

   142

    va_start(vargs, format);

   143

    log_output(level, func, format, vargs, ": %s", strerror(errno));

   144

    va_end(vargs);

   145

}

   146