1

#include "logwatch.h"

     2

#include "../str.h"

     3

#include "../log.h"

     4

     5

#include <stdlib.h>

     6

#include <string.h>

     7

     8

#include <assert.h>

     9

    10

struct logwatch_filter* logwatch_filter_lookup (struct logwatch *ctx, const char *name)

    11

{

    12

    struct logwatch_filter *filter;

    13

    14

    // inspect each filter

    15

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

    16

        if (strcmp(filter->name, name) == 0)

    17

            return filter;

    18

    19

    // not found

    20

    return NULL;

    21

}

    22

    23

struct logwatch_filter* logwatch_filter (struct logwatch *ctx, const char *name, const struct logwatch_source *source,

    24

        const char *pattern, const char *format, struct logwatch_chan *chan, struct error_info *err)

    25

{

    26

    struct logwatch_filter *filter;

    27

    const char *err_msg;

    28

    int err_offset;

    29

    30

    // alloc

    31

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

    32

        JUMP_SET_ERROR(err, ERR_CALLOC);

    33

    34

    // optional source

    35

    filter->source = source;

    36

    37

    // name?

    38

    if (name && (filter->name = strdup(name)) == NULL)

    39

        JUMP_SET_ERROR(err, ERR_STRDUP);

    40

    41

    // compile the regexp

    42

    // XXX: any flags?

    43

    if (pattern && (filter->regexp = pcre_compile(pattern, 0, &err_msg, &err_offset, NULL)) == NULL)

    44

        JUMP_SET_ERROR_STR(err, ERR_PCRE_COMPILE, err_msg);

    45

    46

    // format?

    47

    if (format && (filter->format = strdup(format)) == NULL)

    48

        JUMP_SET_ERROR(err, ERR_STRDUP);

    49

    50

    // output channel

    51

    filter->chan = chan;

    52

    53

    // add it

    54

    TAILQ_INSERT_TAIL(&ctx->filters, filter, logwatch_filters);

    55

    56

    // mark it as registered

    57

    filter->ctx = ctx;

    58

    59

    // ok

    60

    return filter;

    61

    62

error:

    63

    // cleanup

    64

    if (filter)

    65

        logwatch_filter_destroy(filter);

    66

    67

    return NULL;

    68

}

    69

    70

void logwatch_filter_destroy (struct logwatch_filter *filter)

    71

{

    72

    if (filter->ctx)

    73

        // unreigster

    74

        TAILQ_REMOVE(&filter->ctx->filters, filter, logwatch_filters);

    75

    76

    // this if is probably not needed

    77

    if (filter->regexp) 

    78

        pcre_free(filter->regexp);

    79

    80

    if (filter->chan)    

    81

        // release the logwatch_chan ref

    82

        logwatch_chan_put(filter->chan);

    83

    84

    // free misc

    85

    free(filter->format);

    86

    free(filter->name);

    87

    free(filter);

    88

}

    89

    90

void logwatch_filter_remove (struct logwatch *ctx, const struct logwatch_source *source)

    91

{

    92

    struct logwatch_filter *filter, *next;

    93

    94

    // inspect each filter

    95

    for (filter = TAILQ_FIRST(&ctx->filters); filter; filter = next) {

    96

        next = TAILQ_NEXT(filter, logwatch_filters);

    97

    98

        // destroy matching

    99

        if (filter->source == source)

   100

            logwatch_filter_destroy(filter);

   101

    }

   102

}

   103

   104

/**

   105

 * str_format context for logwatch_filter_apply operation

   106

 */

   107

struct logwatch_filter_str_format_ctx {

   108

    /** The regexp we are processing */

   109

    pcre *regexp;

   110

   111

    /** The subject string */

   112

    const char *subject;

   113

   114

    /** The match group vector */

   115

    int *groups;

   116

   117

    /** Number of match items in groups */

   118

    size_t group_count;

   119

};

   120

   121

/**

   122

 * Our callback for str_format params used by logwatch_filter_apply()

   123

 */

   124

static err_t logwatch_filter_str_format_cb (const char *name, const char **value, ssize_t *value_len, void *arg)

   125

{

   126

    struct logwatch_filter_str_format_ctx *ctx = arg;

   127

    int num;

   128

   129

    // look it up

   130

    if (!ctx->regexp || (num = pcre_get_stringnumber(ctx->regexp, name)) < 0)

   131

        // no such capture group

   132

        return ERR_STR_FMT_NAME;

   133

   134

    // sanity check

   135

    assert((size_t) num < ctx->group_count);

   136

   137

    // look up the start/end offsets

   138

    int start = ctx->groups[num * 2 + 0];

   139

    int end = ctx->groups[num * 2 + 1];

   140

   141

    // return a pointer to the subject

   142

    *value = ctx->subject + start;

   143

    *value_len = end - start;

   144

   145

    // ok

   146

    return SUCCESS;

   147

}

   148

   149

// number of pcre ovec elemnents required

   150

#define LOGWATCH_FILTER_OVEC_ITEMS ((LOGWATCH_FILTER_GROUPS_MAX + 1) * 3)

   151

   152

// length of output line prefix

   153

#define LOGWATCH_FILTER_OUT_PREFIX_LEN 16

   154

   155

int logwatch_filter_apply (const struct logwatch_filter *filter, const struct logwatch_source *source, const char *line, struct error_info *err)

   156

{

   157

    int ovec[LOGWATCH_FILTER_OVEC_ITEMS], ret;

   158

    char buf[LOGWATCH_FILTER_OUT_MAX + 1], *buf_ptr = buf;

   159

    size_t buf_size = sizeof(buf);

   160

   161

    // XXX: what to do for truncated data?

   162

   163

    // discard based on source?

   164

    if (filter->source && source != filter->source)

   165

        return 0;

   166

   167

    // match against the regexp?

   168

    if (filter->regexp && (ret = pcre_exec(filter->regexp, NULL, line, strlen(line), 0, 0, ovec, LOGWATCH_FILTER_OVEC_ITEMS)) <= 0) {

   169

        if (ret == PCRE_ERROR_NOMATCH)

   170

            // no match, ignore

   171

            return 0;

   172

   173

        else

   174

            // misc. error

   175

            // XXX: might be 0 for too many groups

   176

            JUMP_SET_ERROR_EXTRA(err, ERR_PCRE_EXEC, ret);

   177

    }

   178

   179

    // blackhole?

   180

    if (!filter->chan)

   181

        return 1;

   182

   183

    // format?

   184

    if (filter->format) {

   185

        // setup the ctx

   186

        struct logwatch_filter_str_format_ctx ctx = {

   187

            .regexp         = filter->regexp, 

   188

            .subject        = line,

   189

            .groups         = ovec,

   190

            .group_count    = ret 

   191

        };

   192

   193

        // operate

   194

        if ((ERROR_CODE(err) = str_format(buf_ptr, buf_size, filter->format, logwatch_filter_str_format_cb, &ctx)))

   195

            goto error;

   196

   197

    } else {

   198

        // quote the entire line

   199

        // XXX: overflow

   200

        buf_ptr += str_advance(NULL, &buf_size, str_quote(buf_ptr, buf_size, line, -1));

   201

   202

    }

   203

   204

    // log

   205

    log_info("<%s>:%s -> %s:%s", source->name, line, irc_chan_name(filter->chan->irc_chan), buf);

   206

   207

    // send it

   208

    if ((ERROR_CODE(err) = logwatch_chan_msg(filter->chan, "[%s] %s", filter->name, buf)))

   209

        goto error;

   210

   211

    // ok, stop here

   212

    return 1;

   213

   214

error:

   215

    return -ERROR_CODE(err);    

   216

}

   217