1

#include "logwatch.h"

     2

     3

#include "../config.h"

     4

#include "../log.h"

     5

     6

#include <assert.h>

     7

     8

static err_t logwatch_init (struct nexus *nexus, void **ctx_ptr, struct error_info *err)

     9

{

    10

    struct logwatch *ctx;

    11

    12

    // allocate

    13

    if ((ctx = calloc(1, sizeof(*ctx))) == NULL)

    14

        RETURN_SET_ERROR(err, ERR_CALLOC);

    15

    16

    // init

    17

    TAILQ_INIT(&ctx->sources);

    18

    TAILQ_INIT(&ctx->filters);

    19

    TAILQ_INIT(&ctx->channels);

    20

    21

    // store

    22

    ctx->nexus = nexus;

    23

    24

    // ok

    25

    *ctx_ptr = ctx;

    26

    27

    return SUCCESS;

    28

}

    29

    30

struct logwatch_chan* logwatch_get_chan (struct logwatch *ctx, struct irc_chan *irc_chan)

    31

{

    32

    struct logwatch_chan *chan;

    33

    34

    // existing?

    35

    if ((chan = logwatch_chan_lookup(ctx, irc_chan))) {

    36

        // get ref

    37

        chan->refcount++;

    38

    39

    } else {

    40

        // create a new one with a ref

    41

        // XXX: errors...

    42

        chan = logwatch_chan_create(ctx, irc_chan);

    43

    }

    44

    45

    // ok

    46

    return chan;

    47

}

    48

    49

void logwatch_on_line (struct logwatch *ctx, const struct logwatch_source *source, const char *line)

    50

{

    51

    const struct logwatch_filter *filter;

    52

    struct error_info err;

    53

    int ret;

    54

    55

    // apply each filter

    56

    TAILQ_FOREACH(filter, &ctx->filters, logwatch_filters) {

    57

        // apply it

    58

        if ((ret = logwatch_filter_apply(filter, source, line, &err)) < 0)

    59

            log_warn("logwatch_filter_apply(%s, %s, %s): %s", filter->name, source->name, line, error_msg(&err));

    60

    61

        // blackhole?

    62

        if (ret > 0)

    63

            break;

    64

    }

    65

}

    66

    67

    68

void logwatch_on_error (struct logwatch *ctx, const struct logwatch_source *source, const struct error_info *err)

    69

{

    70

    struct logwatch_chan *chan;

    71

    72

    // notify each relevant channel

    73

    TAILQ_FOREACH(chan, &ctx->channels, logwatch_channels) {

    74

        // skip irrelevant channels

    75

        if (!logwatch_chan_has_source(chan, source))

    76

            continue;

    77

    78

        // send an error message

    79

        logwatch_chan_msg(chan, "!!! Source '%s' failed: %s", source->name, error_msg(err));

    80

    }

    81

}

    82

    83

/**

    84

 * Add a logwatch_source with a FIFO at the given path

    85

 */

    86

static err_t logwatch_conf_source_fifo (void *_ctx, const struct config_option *option, const struct config_value values[], struct error_info *err)

    87

{

    88

    struct logwatch *ctx = _ctx;

    89

    90

    // parse arguments

    91

    const char *path = config_get_string(option, values, "path");

    92

    93

    // open it

    94

    if (logwatch_open_fifo(ctx, path, err) == NULL)

    95

       return ERROR_CODE(err);

    96

    97

    // ok

    98

    return SUCCESS;

    99

}

   100

   101

/**

   102

 * Add a logwatch_filter for the given bits

   103

 */

   104

static err_t logwatch_conf_filter (void *_ctx, const struct config_option *option, const struct config_value values[], struct error_info *err)

   105

{

   106

    struct logwatch *ctx = _ctx;

   107

    struct logwatch_filter *filter;

   108

   109

    const struct logwatch_source *source = NULL;

   110

    struct logwatch_chan *chan = NULL;

   111

    const char *name, *source_name, *pattern, *format;

   112

    struct irc_chan *irc_chan;

   113

   114

    // parse arguments

   115

    name        = config_get_string     (option, values, "name"     );

   116

    source_name = config_get_string     (option, values, "source"   );

   117

    pattern     = config_get_string     (option, values, "pattern"  );

   118

    format      = config_get_string     (option, values, "format"   );

   119

    irc_chan    = config_get_irc_chan   (option, values, "chan"     );

   120

   121

    // replace old filter?

   122

    if ((filter = logwatch_filter_lookup(ctx, name))) {

   123

        log_info("removing old filter: %s: %p", name, filter);

   124

        logwatch_filter_destroy(filter);

   125

    }

   126

   127

    // lookup source

   128

    if (source_name && (source = logwatch_source_lookup(ctx, source_name)) == NULL)

   129

       RETURN_SET_ERROR_STR(err, ERR_MODULE_CONF, "unknown logwatch_source name");

   130

   131

    // lookup channel

   132

    if (irc_chan && (chan = logwatch_get_chan(ctx, irc_chan)) == NULL)

   133

        RETURN_SET_ERROR_STR(err, ERR_MODULE_CONF, "logwatch_get_chan failed");

   134

   135

    log_info("add filter: name=%s, source=%s, pattern=%s, format=%s, chan=%s",

   136

        name, source_name, pattern, format, irc_chan_name(irc_chan));

   137

   138

    // create a new one

   139

    if ((filter = logwatch_filter(ctx, name, source, pattern, format, chan, err)) == NULL)

   140

        goto error;

   141

   142

    // ok

   143

    return SUCCESS;

   144

   145

error:

   146

    return ERROR_CODE(err);    

   147

}

   148

   149

/**

   150

 * Configuration options

   151

 */

   152

struct config_option logwatch_config_options[] = CONFIG_OPTIONS(

   153

    CONFIG_OPT(         "source_fifo",  logwatch_conf_source_fifo,

   154

        "read input lines from the FIFO at the given path",

   155

   156

        CONFIG_PARAM(       "path",     CONFIG_STRING,      "filesystem path to FIFO",                  false   )

   157

    ),

   158

   159

    CONFIG_OPT(         "filter",       logwatch_conf_filter, 

   160

        "filter lines from source (or all), using the given regular expression (or all lines), and format output "

   161

        "using the given format expression (or pass through directly), and finally send the output to the given channel. "

   162

        "If a filter with the same name already exists, it will be replaced.",

   163

   164

        CONFIG_PARAM(       "name",    CONFIG_STRING,       "filter name",                              false   ),

   165

        CONFIG_PARAM(       "source",  CONFIG_STRING,       "optional logwatch_source to use",          true    ),

   166

        CONFIG_PARAM(       "pattern", CONFIG_STRING,       "optional regular expression pattern",      true    ),

   167

        CONFIG_PARAM(       "format",  CONFIG_STRING,       "optional output format",                   true    ),

   168

        CONFIG_PARAM(       "chan",    CONFIG_IRC_CHAN,     "channel to send output to, or NULL to blackhole",  true)

   169

    )

   170

);

   171

   172

static void logwatch_destroy (void *_ctx)

   173

{

   174

    struct logwatch *ctx = _ctx;

   175

    struct logwatch_filter *filter;

   176

    struct logwatch_source *source;

   177

   178

    // flush the filters list

   179

    while ((filter = TAILQ_FIRST(&ctx->filters)))

   180

        logwatch_filter_destroy(filter);

   181

   182

    // flush the sources list

   183

    while ((source = TAILQ_FIRST(&ctx->sources)))

   184

        logwatch_source_destroy(source);

   185

   186

    // release the context

   187

    free(ctx);

   188

}

   189

   190

/**

   191

 * The module function table

   192

 */

   193

struct module_desc logwatch_module = {

   194

    .init               = logwatch_init,

   195

    .config_options     = logwatch_config_options,

   196

    .unload             = NULL,

   197

    .destroy            = logwatch_destroy

   198

};

   199