1

     2

#include "log.h"

     3

#include "str.h"

     4

     5

#include <stdio.h>

     6

#include <stdarg.h>

     7

#include <string.h>

     9

    10

/**

    11

 * The default log output func

    12

 */

    13

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

    14

{

    15

    (void) arg;

    16

    17

    // display

    18

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

    19

}

    20

    21

/**

    22

 * The global log level

    23

 */

    24

static enum log_level _log_level = LOG_LEVEL_DEFAULT;

    25

    26

/**

    27

 * The global log output func

    28

 */

    29

static struct log_output_ctx {

    30

    /** The function itself */

    31

    log_output_func func;

    32

    33

    /** The arg */

    34

    void *arg;

    35

} _log_output_ctx = { log_default_func, NULL };

    36

    37

/**

    38

 * List of log level names

    39

 */

    40

const char *log_level_names[] = {

    41

    "DEBUG",

    42

    "INFO",

    43

    "WARN",

    44

    "ERROR",

    45

    "FATAL",

    46

    NULL

    47

};

    48

    49

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

    50

const char *log_level_name (enum log_level level)

    51

{

    52

    switch (level) {

    53

        _LOG_LEVEL_NAME(DEBUG)

    54

        _LOG_LEVEL_NAME(INFO)

    55

        _LOG_LEVEL_NAME(WARN)

    56

        _LOG_LEVEL_NAME(ERROR)

    57

        _LOG_LEVEL_NAME(FATAL)

    58

        default: return "???";

    59

    }

    60

}

    61

#undef _LOG_LEVEL_NAME

    62

    63

void set_log_level (enum log_level level)

    64

{

    65

    // meep meep

    66

    _log_level = level;

    67

}

    68

    69

void log_set_func (log_output_func func, void *arg)

    70

{

    71

    // replace the current one

    72

    _log_output_ctx.func = func ? func : log_default_func;

    73

    _log_output_ctx.arg = arg;

    74

}

    75

    76

void log_output_tag_va (enum log_level level, const char *tag, const char *func, const char *user_fmt, va_list user_fmtargs, const char *log_fmt, va_list log_fmtargs)

    77

{

    78

    char buf[LOG_MSG_MAX], *buf_ptr = buf;

    79

    size_t buf_size = sizeof(buf);

    80

    81

    // filter out?

    82

    if (level < _log_level)

    83

        return;

    84

    85

    // output the header

    86

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

    87

    88

    // output the user data

    89

    if (user_fmt)

    90

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

    91

    92

    // output the suffix

    93

    if (log_fmt)

    94

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

    95

    96

    // send it to the output func

    97

    _log_output_ctx.func(buf, _log_output_ctx.arg);

    98

    99

}

   100

   101

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

   102

{

   103

    va_list vargs;

   104

   105

    va_start(vargs, log_fmt);

   106

    log_output_tag_va(level, tag, func, user_fmt, user_fmtargs, log_fmt, vargs);

   107

    va_end(vargs);

   108

}

   109

   110

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

   111

{

   112

    va_list vargs;

   113

   114

    // formatted output: no suffix

   115

    va_start(vargs, format);

   116

    log_output_tag(level, log_level_name(level), func, format, vargs, NULL);

   117

    va_end(vargs);

   118

}

   119

   120

void _log_msg_va2 (enum log_level level, const char *func, const char *fmt1, va_list fmtargs1, const char *fmt2, va_list fmtargs2)

   121

{

   122

    log_output_tag_va(level, log_level_name(level), func, fmt1, fmtargs1, fmt2, fmtargs2);

   123

}

   124

   125

void _log_err (enum log_level level, const struct error_list *list, err_t code, const char *func, const char *format, ...)

   126

{

   127

    va_list vargs;

   128

   129

    // formatted output: suffix error_name()

   130

    va_start(vargs, format);

   131

    log_output_tag(level, log_level_name(level), func, format, vargs, ": %s", error_name(list, code));

   132

    va_end(vargs);

   133

}

   134

   135

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

   136

{

   137

    va_list vargs;

   138

   139

    // formatted output: suffix error_msg()

   140

    va_start(vargs, format);

   141

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

   142

    va_end(vargs);

   143

}

   144

   145

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

   146

{

   147

    va_list vargs;

   148

   149

    // formatted output: suffix strerror()

   150

    va_start(vargs, format);

   151

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

   152

    va_end(vargs);

   153

}

   154

   155

void _log_exit (enum log_level level, int exit_code, const char *func, const char *format, ...)

   156

{

   157

    va_list vargs;

   158

   159

    // formatted output without any suffix

   160

    va_start(vargs, format);

   161

    log_output_tag(level, "EXIT", func, format, vargs, NULL);

   162

    va_end(vargs);

   163

   164

    // exit

   165

    exit(exit_code);

   166

}