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

    54

    // apply each filter

    55

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

    56

        if (logwatch_filter_apply(filter, source, line, &err))

    57

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

    58

    }

    59

}

    60

    61

    62

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

    63

{

    64

    struct logwatch_chan *chan;

    65

    66

    // notify each relevant channel

    67

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

    68

        // skip irrelevant channels

    69

        if (!logwatch_chan_has_source(chan, source))

    70

            continue;

    71

    72

        // send an error message

    73

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

    74

    }

    75

}

    76

    77

/**

    78

 * Add a logwatch_source with a FIFO at the given path

    79

 */

    80

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

    81

{

    82

    struct logwatch *ctx = _ctx;

    83

    84

    // parse arguments

    85

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

    86

    87

    // open it

    88

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

    89

       return ERROR_CODE(err);

    90

    91

    // ok

    92

    return SUCCESS;

    93

}

    94

    95

/**

    96

 * Add a logwatch_filter for the given bits

    97

 */

    98

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

    99

{

   100

    struct logwatch *ctx = _ctx;

   101

    struct logwatch_filter *filter;

   102

   103

    const struct logwatch_source *source = NULL;

   104

    struct logwatch_chan *chan;

   105

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

   106

    struct irc_chan *irc_chan;

   107

   108

    // parse arguments

   109

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

   110

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

   111

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

   112

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

   113

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

   114

   122

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

   123

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

   124

   126

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

   127

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

   128

   129

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

   130

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

   131

   133

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

   134

        goto error;

   135

   136

    // ok

   137

    return SUCCESS;

   138

   139

error:

   140

    return ERROR_CODE(err);    

   141

}

   142

   143

/**

   144

 * Configuration options

   145

 */

   146

struct config_option logwatch_config_options[] = CONFIG_OPTIONS(

   147

    CONFIG_OPT(         "source_fifo",  logwatch_conf_source_fifo,

   148

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

   149

   150

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

   151

    ),

   152

   153

    CONFIG_OPT(         "filter",       logwatch_conf_filter, 

   154

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

   157

   158

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

   159

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

   160

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

   161

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

   162

        CONFIG_PARAM(       "chan",    CONFIG_IRC_CHAN,    "channel to send output to",                false   )

   163

    )

   164

);

   165

   166

static void logwatch_destroy (void *_ctx)

   167

{

   168

    struct logwatch *ctx = _ctx;

   169

    struct logwatch_filter *filter;

   170

    struct logwatch_source *source;

   171

   172

    // flush the filters list

   173

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

   174

        logwatch_filter_destroy(filter);

   175

   176

    // flush the sources list

   177

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

   178

        logwatch_source_destroy(source);

   179

   180

    // release the context

   181

    free(ctx);

   182

}

   183

   184

/**

   185

 * The module function table

   186

 */

   187

struct module_desc logwatch_module = {

   188

    .init               = logwatch_init,

   189

    .config_options     = logwatch_config_options,

   190

    .unload             = NULL,

   191

    .destroy            = logwatch_destroy

   192

};

   193