1

#include "module.h"

     2

#include "irc_chan.h"

     3

#include "error.h"

     4

#include "log.h"

     5

     6

#include <stdlib.h>

     7

#include <string.h>

     8

     9

#include <event2/event.h>

    10

#include <evsql.h>

    11

    12

/**

    13

 * The irc_log module state.

    14

 */

    15

struct irc_log_ctx {

    16

    /** The nexus this module is loaded for */

    17

    struct nexus *nexus;

    18

    19

    /** The database connection */

    20

    struct evsql *db;

    21

};

    22

    23

/**

    24

 * State required to use irc_cmd_handler with irc_chan.handlers.

    25

 */

    26

struct irc_log_chan {

    27

    /** The irc_log context */

    28

    struct irc_log_ctx *ctx;

    29

    30

    /** The target channel */

    31

    struct irc_chan *chan;

    32

};

    33

    34

/**

    35

 * Our evsql result handler for irc_log_event INSERTs.

    36

 */

    37

static void irc_log_on_sql_result (struct evsql_result *res, void *arg)

    38

{

    39

    struct irc_log_ctx *ctx = arg;

    40

    err_t err;

    41

    42

    (void) ctx;

    43

    44

    if ((err = evsql_result_check(res)))

    45

        log_error("irc_log_event: %s", evsql_result_error(res));

    46

    47

    // ok

    48

    evsql_result_free(res);

    49

}

    50

    51

/**

    52

 * Log the event into our database.

    53

 *

    54

 * Any of source, target, message can be NULL to insert NULLs

    55

 */

    56

static err_t irc_log_event (struct irc_log_ctx *ctx, struct irc_chan *chan, const struct irc_nm *source,

    57

        const char *type, const char *target, const char *message)

    58

{

    59

    struct evsql_query *query;

    60

    61

    // unpack the nick/user/hostname args, as source can be NULL

    62

    const char *nickname = source ? source->nickname : NULL;

    63

    const char *username = source ? source->username : NULL;

    64

    const char *hostname = source ? source->hostname : NULL;

    65

    66

    // our SQL query

    67

    static struct evsql_query_info sql = {

    68

        "INSERT INTO logs ("

    69

        "  network, channel, nickname, username, hostname, type, target, message"

    70

        " ) VALUES ("

    71

        "  $1::varchar, $2::varchar, $3::varchar, $4::varchar, $5::varchar, $6::varchar, $7::varchar, $8::varchar"

    72

        " )", { 

    73

            EVSQL_TYPE(STRING),     // network

    74

            EVSQL_TYPE(STRING),     // channel

    75

            EVSQL_TYPE(STRING),     // nickname

    76

            EVSQL_TYPE(STRING),     // username

    77

            EVSQL_TYPE(STRING),     // hostname

    78

            EVSQL_TYPE(STRING),     // type

    79

            EVSQL_TYPE(STRING),     // target

    80

            EVSQL_TYPE(STRING),     // message

    81

            EVSQL_TYPE_END

    82

        }

    83

    };

    84

    85

    // drop lines if not connected

    86

    if (ctx->db == NULL) {

    87

        log_warn("no database connected");

    88

    89

        return ERR_MODULE_CONF;

    90

    }

    91

    92

    // run the INSERT

    93

    if ((query = evsql_query_exec(ctx->db, NULL, &sql, &irc_log_on_sql_result, ctx,

    94

        chan->net->info.network, irc_chan_name(chan),

    95

        nickname, username, hostname,

    96

        type, target, message

    97

    )) == NULL) {

    98

        // XXX: get evsql_query error info somehow...

    99

        log_error("evsql_query_exec failed for %s:%s - %s!%s@%s - %s -> %s - %s", 

   100

            chan->net->info.network, irc_chan_name(chan),

   101

            nickname, username, hostname,

   102

            type, target, message

   103

        );

   104

   105

        return ERR_EVSQL_QUERY_EXEC;

   106

    }

   107

   108

    // ok

   109

    log_debug("%s:%s - %s!%s@%s - %s -> %s - %s", 

   110

        chan->net->info.network, irc_chan_name(chan),

   111

        nickname, username, hostname,

   112

        type, target, message

   113

    );

   114

   115

    return SUCCESS;

   116

}

   117

   118

/**

   119

 * Parse the prefix into a nickmask and pass on to irc_log_event

   120

 */

   121

static err_t irc_log_event_prefix (struct irc_log_ctx *ctx, struct irc_chan *chan, const char *prefix,

   122

        const char *type, const char *target, const char *message)

   123

{

   124

    char prefix_buf[IRC_PREFIX_MAX];

   125

    struct irc_nm nm;

   126

    err_t err;

   127

   128

    // parse nickmask

   129

    if ((err = irc_nm_parse(&nm, prefix_buf, prefix)))

   130

        return err;

   131

   132

    // log

   133

    return irc_log_event(ctx, chan, &nm, type, target, message);

   134

}

   135

   136

/**

   137

 * Log a simple channel event of the form:

   138

 *

   139

 * :nm <type> <channel> [<msg>]

   140

 */

   141

static void irc_log_on_chan_generic (const struct irc_line *line, void *arg)

   142

{

   143

    struct irc_log_chan *chan_ctx = arg;

   144

   145

    const char *msg = line->args[1];

   146

   147

    irc_log_event_prefix(chan_ctx->ctx, chan_ctx->chan, line->prefix, line->command, NULL, msg);

   148

}

   149

   150

/**

   151

 * Log a MODE event on a channel

   152

 *

   153

 * :nm MODE <channel> [<modearg> [...]]

   154

 *

   155

 * This conacts all the modeargs together, and logs that as the message

   156

 */

   157

static void irc_log_on_chan_MODE (const struct irc_line *line, void *arg)

   158

{

   159

    struct irc_log_chan *chan_ctx = arg;

   160

    char message[512], *ptr = message;

   161

    const char *cmdarg;

   162

   163

    // iterate over each arg

   164

    FOREACH_IRC_LINE_ARGS(line, cmdarg) {

   165

        // separate with spaces

   166

        if (cmdarg > line->args[0])

   167

            *ptr++ = ' ';

   168

   169

        // append

   170

        ptr += snprintf(ptr, (message + 512 - ptr), "%s", cmdarg);

   171

   172

        // buffer full?

   173

        if (ptr > message + 512)

   174

            break;

   175

    }

   176

   177

    // log

   178

    irc_log_event_prefix(chan_ctx->ctx, chan_ctx->chan, line->prefix, line->command, NULL, message);

   179

}

   180

   181

/**

   182

 * Log a KICK event on a channel

   183

 *

   184

 * :nm KICK <channel> <target> [<comment>]

   185

 */

   186

static void irc_log_on_chan_KICK (const struct irc_line *line, void *arg)

   187

{

   188

    struct irc_log_chan *chan_ctx = arg;

   189

   190

    const char *target = line->args[1];    

   191

    const char *msg = line->args[2];

   192

   193

    irc_log_event_prefix(chan_ctx->ctx, chan_ctx->chan, line->prefix, line->command, target, msg);

   194

}

   195

   196

/**

   197

 * Our low-level channel-specific message handlers for logged channels.

   198

 *

   199

 * Note that these get a `struct irc_log_chan*` as an argument.

   200

 */

   201

static struct irc_cmd_handler _chan_cmd_handlers[] = {

   202

    {   "JOIN",     &irc_log_on_chan_generic        },

   203

    {   "PART",     &irc_log_on_chan_generic        },

   204

    {   "MODE",     &irc_log_on_chan_MODE           },

   205

    {   "TOPIC",    &irc_log_on_chan_generic        },

   206

    {   "KICK",     &irc_log_on_chan_KICK           },

   207

    {   "PRIVMSG",  &irc_log_on_chan_generic        },

   208

    {   "NOTICE",   &irc_log_on_chan_generic        },

   209

    {   NULL,       NULL                            }

   210

};

   211

   212

/**

   213

 * Our high-level channel-specific callbacks for logged channels.

   214

 *

   215

 * Note that these get a `struct irc_log_chan*` as an argument.

   216

 */

   217

static struct irc_chan_callbacks _chan_callbacks = {

   218

    .on_self_join       = NULL,

   219

    .on_msg             = NULL,

   220

};

   221

   278

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

   279

{

   280

    struct irc_log_ctx *ctx;

   281

   282

    // allocate

   283

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

   284

        return SET_ERROR(err, ERR_CALLOC);

   285

   286

    // store

   287

    ctx->nexus = nexus;

   288

   289

    log_info("module initialized");

   290

   291

    // ok

   292

    *ctx_ptr = ctx;

   293

   295

}

   296

   297

/**

   298

 * Process the irc_log.db_info config option.

   299

 *

   300

 * Creates a new evsql handle.

   301

 *

   302

 * Fails if ctx->db is already set.

   303

 */

   304

static err_t irc_log_conf_db_info (struct irc_log_ctx *ctx, char *value, struct error_info *err)

   305

{

   306

    log_info("connect to database: %s", value);

   307

   308

    // already connected?

   309

    if (ctx->db)

   310

        RETURN_SET_ERROR_STR(err, ERR_MODULE_CONF, "irc_log.db_info already set");

   311

   312

    // create a new evsql handle

   313

    if ((ctx->db = evsql_new_pq(ctx->nexus->ev_base, value, NULL, NULL)) == NULL)

   314

       return SET_ERROR(err, ERR_EVSQL_NEW_PQ);

   315

   316

    // ok

   317

    return SUCCESS;

   318

}

   319

   320

/**

   321

 * Process the irc_log.channel config option.

   322

 *

   323

 * Creates a new irc_log_chan context, looks up the channel, adds our command handlers, and logs an OPEN event.

   324

 *

   325

 * Fails if the value is invalid, we don't have a database connected, the channel doesn't exist, adding our command

   326

 * handlers/callbacks fails, or sending the initial INSERT-OPEN query fails.

   327

 */

   328

static err_t irc_log_conf_channel (struct irc_log_ctx *ctx, char *value, struct error_info *err)

   329

{

   330

    const char *network, *channel;

   332

   333

    // parse required args

   334

    if ((network = strsep(&value, ":")) == NULL)

   335

        RETURN_SET_ERROR_STR(err, ERR_MODULE_CONF, "invalid <network> for irc_log.channel");

   336

   337

    if ((channel = strsep(&value, ":")) == NULL)

   338

        RETURN_SET_ERROR_STR(err, ERR_MODULE_CONF, "invalid <channel> for irc_log.channel");

   339

   340

    // extraneous stuff?

   341

    if (value)

   342

        RETURN_SET_ERROR_STR(err, ERR_MODULE_CONF, "trailing data for irc_log.channel");

   343

   344

    // have a db configured?

   345

    if (!ctx->db)

   346

        RETURN_SET_ERROR_STR(err, ERR_MODULE_CONF, "irc_log.channel used without any irc_log.db_info");

   347

   348

    // get the channel?

   351

   355

   356

    // ok

   357

    return SUCCESS;

   358

}

   359

   360

/**

   361

 * Set a config option

   362

 */

   363

static err_t irc_log_conf (void *mod_ctx, const char *name, char *value, struct error_info *err)

   364

{

   365

    struct irc_log_ctx *ctx = mod_ctx;

   366

   367

    if (strcmp(name, "db_info") == 0) {

   368

        return irc_log_conf_db_info(ctx, value, err);

   369

   370

    } else if (strcmp(name, "channel") == 0) {

   371

        return irc_log_conf_channel(ctx, value, err);

   372

   373

    } else {

   374

        RETURN_SET_ERROR_STR(err, ERR_MODULE_CONF, "unknown configuration option");

   375

    }

   376

   377

    // ok

   378

    return SUCCESS;

   379

}

   380

   381

/**

   382

 * The module function table

   383

 */

   384

struct module_funcs irc_log_funcs = {

   385

    .init       = &irc_log_init,

   386

    .conf       = &irc_log_conf,

   387

};

   388