1

/**

     2

 * @file

     3

 *

     4

 * A module to filter out certain lines from normal syslog() files, and forward them to an IRC channel.

     5

 */

     6

#include <sys/queue.h>

     7

#include "../irc_chan.h"

     8

#include "../line_proto.h"

     9

#include "../nexus.h"

    10

    11

#include <event2/event.h>

    12

#include <pcre.h>

    13

    14

/**

    15

 * A source of log lines.

    16

 *

    17

 * XXX: currently this is just hardcoded to be a FIFO

    18

 */

    19

struct logwatch_source {

    20

    /** The logwatch context we are registered to */

    21

    struct logwatch *ctx;

    22

    23

    /** Our name */

    24

    char *name;

    25

    26

    /** The input FIFO */

    27

    struct line_proto *lp;

    28

    29

    /** Our entry in logwatch::sources */

    30

    TAILQ_ENTRY(logwatch_source) logwatch_sources;

    31

};

    32

    33

/**

    34

 * Maximum length of input lines

    35

 */

    36

#define LOGWATCH_SOURCE_LINE_MAX 1024

    37

    38

/**

    39

 * Logwatch's per-channel state

    40

 */

    41

struct logwatch_chan {

    42

    /** The logwatch context we are registered to */

    43

    struct logwatch *ctx;

    44

    45

    /** The actual irc_chan */

    46

    struct irc_chan *irc_chan;

    47

    48

    /** Number of references */

    49

    size_t refcount;

    50

    51

    /** Our entry in logwatch::channels */

    52

    TAILQ_ENTRY(logwatch_chan) logwatch_channels;

    53

};

    54

    55

/**

    56

 * Maximum length of a logwatch_chan message, not including NUL byte

    57

 *

    58

 * XXX: this is a bad way to handle truncation

    59

 */

    60

#define LOGWATCH_CHAN_MSG_MAX 470

    61

    62

/**

    63

 * A filter specifies what lines to match, and how to then format the output.

    64

 */

    65

struct logwatch_filter {

    66

    /** The logwatch context we are registered to */

    67

    struct logwatch *ctx;

    68

    69

    /** The name of the filter */

    70

    char *name;

    71

    72

    /** The source to restrict this to, if any */

    73

    const struct logwatch_source *source;

    74

    75

    /** 

    76

     * The compiled regular expression to match, or NULL to match all lines.

    77

     */

    78

    pcre *regexp;

    79

    80

    /** 

    81

     * The output format string, or NULL to send the line itself as-is

    82

     */

    83

    char *format;

    84

    85

    /**

    86

     * The channel to send output to 

    87

     */

    88

    struct logwatch_chan *chan;

    89

    90

    /** Our entry in logwatch::filters */

    91

    TAILQ_ENTRY(logwatch_filter) logwatch_filters;

    92

};

    93

    94

/**

    95

 * Maximum number of capture groups in the filter's regexp

    96

 */

    97

#define LOGWATCH_FILTER_GROUPS_MAX 16

    98

    99

/**

   100

 * Maximum length of logwatch_filter output

   101

 */

   102

#define LOGWATCH_FILTER_OUT_MAX 450

   103

   104

/**

   105

 * The logwatch module state

   106

 */

   107

struct logwatch {

   108

    /** The nexus we are loaded on */

   109

    struct nexus *nexus;

   110

   111

    /** List of sources */

   112

    TAILQ_HEAD(logwatch_source_list, logwatch_source) sources;

   113

   114

    /** List of filters */

   115

    TAILQ_HEAD(logwatch_filter_list, logwatch_filter) filters;

   116

   117

    /** List of chanenls */

   118

    TAILQ_HEAD(logwatch_chan_list, logwatch_chan) channels;

   119

};

   120

   121

/**

   122

 * Add a new FIFO logwatch_source

   123

 *

   124

 * @param ctx the logwatch state

   125

 * @param path the path to the fifo, also used as the name

   126

 * @param err returned error info

   127

 * @return the new logwatch_source, or NULL on error

   128

 */

   129

struct logwatch_source* logwatch_open_fifo (struct logwatch *ctx, const char *path, struct error_info *err);

   130

   131

/**

   132

 * Destroy a source, removing it from the list of sources.

   133

 *

   134

 * XXX: remove all affected filters as well

   135

 */

   136

void logwatch_source_destroy (struct logwatch_source *source);

   137

   138

/**

   139

 * Lookup a logwatch_source by name

   140

 */

   141

const struct logwatch_source* logwatch_source_lookup (struct logwatch *ctx, const char *name);

   142

   143

/**

   144

 * Returns true if the given chan is linked to the given source via at least one filter

   145

 */

   146

bool logwatch_chan_has_source (struct logwatch_chan *chan, const struct logwatch_source *source);

   147

   148

/**

   149

 * Look for an existing logwatch_chan entry, returning it if it exists

   150

 */

   151

struct logwatch_chan* logwatch_chan_lookup (struct logwatch *ctx, struct irc_chan *irc_chan);

   152

   153

/**

   154

 * Create a new irc_chan with an initial refcount of one.

   155

 *

   156

 * @returns NULL on ERR_CALLOC

   157

 */

   158

struct logwatch_chan* logwatch_chan_create (struct logwatch *ctx, struct irc_chan *irc_chan);

   159

   160

/**

   161

 * Returns a logwatch_chan reference, destroying as needed.

   162

 */

   163

void logwatch_chan_put (struct logwatch_chan *chan);

   164

   165

/**

   166

 * Send a notice of at most LOGWATCH_CHAN_MSG_MAX bytes to the channel using the given format string.

   167

 */

   168

err_t logwatch_chan_msg (struct logwatch_chan *chan, const char *fmt, ...);

   169

   170

/**

   171

 * Find an existing logwatch_chan for the given channel, or create a new one. Returns a real reference that should be

   172

 * returned using logwatch_put_chan().

   173

 *

   174

 * @returns NULL on ERR_CALLOC

   175

 */

   176

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

   177

   178

/**

   179

 * Lookup an existing filter by name.

   180

 */

   181

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

   182

   183

/**

   184

 * Add a new filter.

   185

 *

   186

 * The given logwatch_chan should be a new reference.

   187

 */

   188

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

   189

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

   190

   191

/**

   192

 * Destroy a logwatch_filter, unregistering it

   193

 */

   194

void logwatch_filter_destroy (struct logwatch_filter *filter);

   195

   196

/**

   197

 * Pass the given line (from the given source) through the given filter.

   198

 *

   199

 * Returns 0 if the next filter should be tried, >0 if no more filters should be processed, and -err_t on error.

   200

 */

   201

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

   202

   203

/**

   204

 * Remove any filters registered with the given source

   205

 */

   206

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

   207

   208

/**

   209

 * Handle a line from the given source by applying it to all filters.

   210

 */

   211

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

   212

   213

/**

   214

 * Handle a disasterous error on a logwatch_source by notifying any irc_chan's that it is linked to via our filters.

   215

 *

   216

 * The logwatch_source will dispose of itself after this.

   217

 */

   218

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