1

#include "module.h"

     2

#include "irc_chan.h"

     3

#include "config.h"

     4

#include "error.h"

     5

#include "log.h"

     6

     7

#include <stdlib.h>

     8

#include <string.h>

     9

    10

#include <event2/event.h>

    11

#include <evsql.h>

    12

    13

/**

    14

 * The irc_log module state.

    15

 */

    16

struct irc_log_ctx {

    17

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

    18

    struct nexus *nexus;

    19

    20

    /** The database connection */

    21

    struct evsql *db;

    22

    23

    /**

    24

     * Our logged channels

    25

     */

    26

    TAILQ_HEAD(irc_log_ctx_channels, irc_log_chan) channels;

    27

    28

    /** Are we currently unloading ourself (via irc_log_unload) ? */

    29

    bool unloading;

    30

};

    31

    32

/**

    33

 * State required to use irc_cmd_handler with irc_chan.handlers.

    34

 */

    35

struct irc_log_chan {

    36

    /** The irc_log context */

    37

    struct irc_log_ctx *ctx;

    38

    39

    /** The target channel */

    40

    struct irc_chan *chan;

    41

    42

    /** Are we stopping (irc_log_chan_stop called)? */

    43

    bool stopping;

    44

    45

    /** We are part of the irc_log_ctx.channels list */

    46

    TAILQ_ENTRY(irc_log_chan) ctx_channels;

    47

};

    48

    49

/*

    50

 * Forward-declare

    51

 */

    52

static void irc_log_chan_destroy (struct irc_log_chan *chan_ctx);

    53

    54

/**

    55

 * The irc_log_ctx has completed stopping all the channels, and should now destroy itself

    56

 */

    57

static void irc_log_stopped (struct irc_log_ctx *ctx)

    58

{

    59

    // schedule an evsql_destroy

    60

    if (evsql_destroy_next(ctx->db))

    61

        log_fatal("evsql_destroy_next failed");

    62

    63

    // free ourself

    64

    free(ctx);

    65

}

    66

    67

/**

    68

 * The irc_log_chan has completed shutdown

    69

 */

    70

static void irc_log_chan_stopped (struct irc_log_chan *chan_ctx)

    71

{

    72

    struct irc_log_ctx *ctx = chan_ctx->ctx;

    73

    74

    // destroy the channel

    75

    irc_log_chan_destroy(chan_ctx);

    76

    77

    // was it the final channel for unloading?

    78

    if (ctx->unloading && TAILQ_EMPTY(&ctx->channels))

    79

        irc_log_stopped(ctx);

    80

}

    81

    82

/**

    83

 * Our evsql result handler for irc_log_event INSERTs.

    84

 */

    85

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

    86

{

    87

    struct irc_log_chan *chan_ctx = arg;

    88

    err_t err;

    89

    90

    // check errors

    91

    if ((err = evsql_result_check(res)))

    92

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

    93

    94

    // ok, don't need the result anymore

    95

    evsql_result_free(res);

    96

    97

    // if stopping, then handle that

    98

    if (chan_ctx->stopping)

    99

        irc_log_chan_stopped(chan_ctx);

   100

}

   101

   102

/**

   103

 * Log the event into our database.

   104

 *

   105

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

   106

 */

   107

static err_t irc_log_event (struct irc_log_ctx *ctx, struct irc_log_chan *chan_ctx, const struct irc_nm *source,

   108

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

   109

{

   110

    struct evsql_query *query;

   111

   112

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

   113

    const char *network = chan_ctx ? chan_ctx->chan->net->info.network : NULL;

   114

    const char *channel = chan_ctx ? irc_chan_name(chan_ctx->chan) : NULL;

   115

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

   116

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

   117

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

   118

   119

    // our SQL query

   120

    static struct evsql_query_info sql = {

   121

        "INSERT INTO logs ("

   122

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

   123

        " ) VALUES ("

   124

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

   125

        " )", { 

   126

            EVSQL_TYPE(STRING),     // network

   127

            EVSQL_TYPE(STRING),     // channel

   128

            EVSQL_TYPE(STRING),     // nickname

   129

            EVSQL_TYPE(STRING),     // username

   130

            EVSQL_TYPE(STRING),     // hostname

   131

            EVSQL_TYPE(STRING),     // type

   132

            EVSQL_TYPE(STRING),     // target

   133

            EVSQL_TYPE(STRING),     // message

   134

            EVSQL_TYPE_END

   135

        }

   136

    };

   137

   138

    // drop lines if not connected

   139

    if (ctx->db == NULL) {

   140

        log_warn("no database connected");

   141

   142

        return ERR_MODULE_CONF;

   143

    }

   144

   145

    // run the INSERT

   146

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

   147

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

   148

    )) == NULL) {

   149

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

   150

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

   151

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

   152

        );

   153

   154

        return ERR_EVSQL_QUERY_EXEC;

   155

    }

   156

   157

    // ok

   158

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

   159

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

   160

    );

   161

   162

    return SUCCESS;

   163

}

   164

   165

/**

   166

 * Log a simple channel event of the form:

   167

 *

   168

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

   169

 */

   170

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

   171

{

   172

    struct irc_log_chan *chan_ctx = arg;

   173

   174

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

   175

   176

    irc_log_event(chan_ctx->ctx, chan_ctx, line->source, line->command, NULL, msg);

   177

}

   178

   179

/**

   180

 * Log a NICK event on a channel

   181

 *

   182

 * :nm NICK <nickname>

   183

 *

   184

 * This logs the new nickname as the target

   185

 */

   186

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

   187

{

   188

    struct irc_log_chan *chan_ctx = arg;

   189

   190

    const char *nickname = line->args[0];

   191

   192

    // log it

   193

    irc_log_event(chan_ctx->ctx, chan_ctx, line->source, line->command, nickname, NULL);

   194

}

   195

   196

/**

   197

 * Log a QUIT event on a channel

   198

 *

   199

 * :nm QUIT [<message>]

   200

 */

   201

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

   202

{

   203

    struct irc_log_chan *chan_ctx = arg;

   204

   205

    const char *message = line->args[0];

   206

   207

    // log it

   208

    irc_log_event(chan_ctx->ctx, chan_ctx, line->source, line->command, NULL, message);

   209

}

   210

   211

/**

   212

 * Log a MODE event on a channel

   213

 *

   214

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

   215

 *

   216

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

   217

 */

   218

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

   219

{

   220

    struct irc_log_chan *chan_ctx = arg;

   221

    char message[512], *ptr = message;

   222

    const char *cmdarg;

   223

   224

    // iterate over each arg

   225

    FOREACH_IRC_LINE_ARGS(line, cmdarg) {

   226

        // separate with spaces

   227

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

   228

            *ptr++ = ' ';

   229

   230

        // append

   231

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

   232

   233

        // buffer full?

   234

        if (ptr > message + 512)

   235

            break;

   236

    }

   237

   238

    // log

   239

    irc_log_event(chan_ctx->ctx, chan_ctx, line->source, line->command, NULL, message);

   240

}

   241

   242

/**

   243

 * Log a KICK event on a channel

   244

 *

   245

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

   246

 */

   247

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

   248

{

   249

    struct irc_log_chan *chan_ctx = arg;

   250

   251

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

   252

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

   253

   254

    irc_log_event(chan_ctx->ctx, chan_ctx, line->source, line->command, target, msg);

   255

}

   256

   257

/**

   272

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

   273

 *

   274

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

   275

 */

   276

static struct irc_cmd_handler _chan_cmd_handlers[] = {

   288

};

   289

   290

/**

   291

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

   292

 *

   293

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

   294

 */

   295

static struct irc_chan_callbacks _chan_callbacks = {

   296

    .on_self_join       = NULL,

   297

    .on_msg             = NULL,

   298

};

   299

   300

/**

   301

 * Release resources associated with the given irc_log_chan without doing any clean shutdown stuff

   302

 */

   303

static void irc_log_chan_destroy (struct irc_log_chan *chan_ctx)

   304

{

   305

    // remove any handlers/callbacks

   306

    irc_cmd_remove(&chan_ctx->chan->handlers, _chan_cmd_handlers, chan_ctx);

   307

    irc_chan_remove_callbacks(chan_ctx->chan, &_chan_callbacks, chan_ctx);

   308

   309

    // remove from channels list

   310

    TAILQ_REMOVE(&chan_ctx->ctx->channels, chan_ctx, ctx_channels);

   311

   312

    // free ourselves

   313

    free(chan_ctx);

   314

}

   315

   316

/**

   317

 * Begin logging the given channel

   318

 */

   319

static err_t irc_log_chan (struct irc_log_ctx *ctx, struct irc_chan *chan, struct error_info *err)

   320

{

   321

    struct irc_log_chan *chan_ctx;

   322

   323

    // alloc

   324

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

   325

        return SET_ERROR(err, ERR_CALLOC);

   326

   327

    // store

   328

    chan_ctx->ctx = ctx;

   329

    chan_ctx->chan = chan;

   330

   331

    // add to channels list

   332

    TAILQ_INSERT_TAIL(&ctx->channels, chan_ctx, ctx_channels);

   333

   334

    // add low-level handlers

   335

    if ((ERROR_CODE(err) = irc_cmd_add(&chan_ctx->chan->handlers, _chan_cmd_handlers, chan_ctx)))

   336

        goto error;

   337

   338

    // add channel callbacks

   339

    if ((ERROR_CODE(err) = irc_chan_add_callbacks(chan_ctx->chan, &_chan_callbacks, chan_ctx)))

   340

        goto error;

   341

   342

    // log an OPEN message

   343

    // XXX: move this to when we first JOIN the channel

   344

    if ((ERROR_CODE(err) = irc_log_event(ctx, chan_ctx, NULL, "OPEN", NULL, NULL)))

   345

        goto error;

   346

   347

    // ok

   348

    log_info("logging channel %s:%s", chan_ctx->chan->net->info.network, irc_chan_name(chan_ctx->chan));

   349

   350

    return SUCCESS;

   351

   352

error:

   353

    // cleanup

   354

    irc_log_chan_destroy(chan_ctx);

   355

   356

    return ERROR_CODE(err);

   357

}

   358

   359

/**

   360

 * Stop logging the given channel, shutting it down nicely and then releasing its resources.

   361

 *

   362

 * If shutting it down nicely fails, this just destroys it.

   363

 */

   364

static err_t irc_log_chan_stop (struct irc_log_chan *chan_ctx)

   365

{

   366

    err_t err;

   367

   368

    // mark it as stopping, so the result callback knows to destroy it

   369

    chan_ctx->stopping = true;

   370

   371

    // log the CLOSE event

   372

    if ((err = irc_log_event(chan_ctx->ctx, chan_ctx, NULL, "CLOSE", NULL, NULL)))

   373

        goto error;

   374

   375

    // ok

   376

    return SUCCESS;

   377

   378

error:

   379

    // destroy it uncleanly

   380

    irc_log_chan_destroy(chan_ctx);

   381

   382

    return err;

   383

}

   384

   385

/**

   386

 * Allocate and initialize an irc_log_ctx. This doesn't do very much, the real magic happens in irc_log_conf.

   387

 */

   388

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

   389

{

   390

    struct irc_log_ctx *ctx;

   391

   392

    // allocate

   393

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

   394

        return SET_ERROR(err, ERR_CALLOC);

   395

   396

    // store

   397

    ctx->nexus = nexus;

   398

   399

    // initialize

   400

    TAILQ_INIT(&ctx->channels);

   401

   402

    log_info("module initialized");

   403

   404

    // ok

   405

    *ctx_ptr = ctx;

   406

   407

    return SUCCESS;

   408

}

   409

   410

/**

   411

 * Process the irc_log.db_info config option.

   412

 *

   413

 * Creates a new evsql handle.

   414

 *

   415

 * Fails if ctx->db is already set.

   416

 */

   417

static err_t irc_log_conf_db_info (void *_ctx, char *value, struct error_info *err)

   418

{

   419

    struct irc_log_ctx *ctx = _ctx;

   420

   421

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

   422

   423

    // already connected?

   424

    if (ctx->db)

   425

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

   426

   427

    // create a new evsql handle

   428

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

   429

       return SET_ERROR(err, ERR_EVSQL_NEW_PQ);

   430

   431

    // ok

   432

    return SUCCESS;

   433

}

   434

   435

/**

   436

 * Process the irc_log.channel config option.

   437

 *

   438

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

   439

 *

   440

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

   441

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

   442

 */

   443

static err_t irc_log_conf_channel (void *_ctx, char *value, struct error_info *err)

   444

{

   445

    struct irc_log_ctx *ctx = _ctx;

   446

    const char *network, *channel;

   447

    struct irc_chan *chan;

   448

   449

    // parse required args

   450

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

   451

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

   452

   453

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

   454

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

   455

   456

    // extraneous stuff?

   457

    if (value)

   458

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

   459

   460

    // have a db configured?

   461

    if (!ctx->db)

   462

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

   463

   464

    // get the channel?

   465

    if ((chan = irc_client_get_chan(ctx->nexus->client, network, channel)) == NULL)

   466

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

   467

   468

    // begin logging it

   469

    if (irc_log_chan(ctx, chan, err))

   470

        return ERROR_CODE(err);

   471

   472

    // ok

   473

    return SUCCESS;

   474

}

   475

   476

/**

   477

 * Our configuration options

   478

 */

   479

struct config_option irc_log_config_options[] = {

   480

    {   "db_info",  CONFIG_STRING,  &irc_log_conf_db_info,  "[<key>=<value> [...]]",    "set database connection info, see libpq docs"  },

   481

    {   "channel",  CONFIG_STRING,  &irc_log_conf_channel,  "<network>:<channel>",      "log the given channel"                         },

   482

    {   NULL,       0,              NULL,                   NULL,                       NULL                                            }

   483

};

   484

   485

/**

   486

 * Set a config option

   487

 */

   488

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

   489

{

   490

    struct irc_log_ctx *ctx = _ctx;