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

     * Our logged channels

    24

     */

    25

    TAILQ_HEAD(irc_log_ctx_channels, irc_log_chan) channels;

    26

    27

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

    28

    bool unloading;

    29

};

    30

    31

/**

    32

 * State required to use irc_cmd_handler with irc_chan.handlers.

    33

 */

    34

struct irc_log_chan {

    35

    /** The irc_log context */

    36

    struct irc_log_ctx *ctx;

    37

    38

    /** The target channel */

    39

    struct irc_chan *chan;

    40

    41

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

    42

    bool stopping;

    43

    44

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

    45

    TAILQ_ENTRY(irc_log_chan) ctx_channels;

    46

};

    47

    48

/*

    49

 * Forward-declare

    50

 */

    51

static void irc_log_chan_destroy (struct irc_log_chan *chan_ctx);

    52

    53

/**

    54

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

    55

 */

    56

static void irc_log_stopped (struct irc_log_ctx *ctx)

    57

{

    58

    // schedule an evsql_destroy

    59

    if (evsql_destroy_next(ctx->db))

    60

        log_fatal("evsql_destroy_next failed");

    61

    62

    // free ourself

    63

    free(ctx);

    64

}

    65

    66

/**

    67

 * The irc_log_chan has completed shutdown

    68

 */

    69

static void irc_log_chan_stopped (struct irc_log_chan *chan_ctx)

    70

{

    71

    struct irc_log_ctx *ctx = chan_ctx->ctx;

    72

    73

    // destroy the channel

    74

    irc_log_chan_destroy(chan_ctx);

    75

    76

    // was it the final channel for unloading?

    77

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

    78

        irc_log_stopped(ctx);

    79

}

    80

    81

/**

    82

 * Our evsql result handler for irc_log_event INSERTs.

    83

 */

    84

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

    85

{

    86

    struct irc_log_chan *chan_ctx = arg;

    87

    err_t err;

    88

    89

    // check errors

    90

    if ((err = evsql_result_check(res)))

    91

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

    92

    93

    // ok, don't need the result anymore

    94

    evsql_result_free(res);

    95

    96

    // if stopping, then handle that

    97

    if (chan_ctx->stopping)

    98

        irc_log_chan_stopped(chan_ctx);

    99

}

   100

   101

/**

   102

 * Log the event into our database.

   103

 *

   104

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

   105

 */

   106

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

   107

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

   108

{

   109

    struct evsql_query *query;

   110

   111

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

   112

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

   113

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

   114

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

   115

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

   116

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

   117

   118

    // our SQL query

   119

    static struct evsql_query_info sql = {

   120

        "INSERT INTO logs ("

   121

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

   122

        " ) VALUES ("

   123

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

   124

        " )", { 

   125

            EVSQL_TYPE(STRING),     // network

   126

            EVSQL_TYPE(STRING),     // channel

   127

            EVSQL_TYPE(STRING),     // nickname

   128

            EVSQL_TYPE(STRING),     // username

   129

            EVSQL_TYPE(STRING),     // hostname

   130

            EVSQL_TYPE(STRING),     // type

   131

            EVSQL_TYPE(STRING),     // target

   132

            EVSQL_TYPE(STRING),     // message

   133

            EVSQL_TYPE_END

   134

        }

   135

    };

   136

   137

    // drop lines if not connected

   138

    if (ctx->db == NULL) {

   139

        log_warn("no database connected");

   140

   141

        return ERR_MODULE_CONF;

   142

    }

   143

   144

    // run the INSERT

   145

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

   146

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

   147

    )) == NULL) {

   148

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

   149

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

   150

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

   151

        );

   152

   153

        return ERR_EVSQL_QUERY_EXEC;

   154

    }

   155

   156

    // ok

   157

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

   158

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

   159

    );

   160

   161

    return SUCCESS;

   162

}

   163

   164

/**

   165

 * Log a simple channel event of the form:

   166

 *

   167

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

   168

 */

   169

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

   170

{

   171

    struct irc_log_chan *chan_ctx = arg;

   172

   173

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

   174

   175

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

   176

}

   177

   178

/**

   211

 * Log a MODE event on a channel

   212

 *

   213

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

   214

 *

   215

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

   216

 */

   217

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

   218

{

   219

    struct irc_log_chan *chan_ctx = arg;

   220

    char message[512], *ptr = message;

   221

    const char *cmdarg;

   222

   223

    // iterate over each arg

   224

    FOREACH_IRC_LINE_ARGS(line, cmdarg) {

   225

        // separate with spaces

   226

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

   227

            *ptr++ = ' ';

   228

   229

        // append

   230

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

   231

   232

        // buffer full?

   233

        if (ptr > message + 512)

   234

            break;

   235

    }

   236

   237

    // log

   238

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

   239

}

   240

   241

/**

   242

 * Log a KICK event on a channel

   243

 *

   244

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

   245

 */

   246

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

   247

{

   248

    struct irc_log_chan *chan_ctx = arg;

   249

   250

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

   251

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

   252

   253

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

   254

}

   255

   256

/**

   257

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

   258

 *

   259

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

   260

 */

   261

static struct irc_cmd_handler _chan_cmd_handlers[] = {

   264

    {   "JOIN",     &irc_log_on_chan_generic        },

   265

    {   "PART",     &irc_log_on_chan_generic        },

   266

    {   "MODE",     &irc_log_on_chan_MODE           },

   267

    {   "TOPIC",    &irc_log_on_chan_generic        },

   268

    {   "KICK",     &irc_log_on_chan_KICK           },

   269

    {   "PRIVMSG",  &irc_log_on_chan_generic        },

   270

    {   "NOTICE",   &irc_log_on_chan_generic        },

   271

    {   NULL,       NULL                            }

   272

};

   273

   274

/**

   275

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

   276

 *

   277

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

   278

 */

   279

static struct irc_chan_callbacks _chan_callbacks = {

   280

    .on_self_join       = NULL,

   281

    .on_msg             = NULL,

   282

};

   283

   284

/**

   285

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

   286

 */

   287

static void irc_log_chan_destroy (struct irc_log_chan *chan_ctx)

   288

{

   289

    // remove any handlers/callbacks

   290

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

   291

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

   292

   293

    // remove from channels list

   294

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

   295

   296

    // free ourselves

   297

    free(chan_ctx);

   298

}

   299

   300

/**

   301

 * Begin logging the given channel

   302

 */

   303

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

   304

{

   305

    struct irc_log_chan *chan_ctx;

   306

   307

    // alloc

   308

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

   309

        return SET_ERROR(err, ERR_CALLOC);

   310

   311

    // store

   312

    chan_ctx->ctx = ctx;

   313

    chan_ctx->chan = chan;

   314

   315

    // add to channels list

   316

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

   317

   318

    // add low-level handlers

   319

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

   320

        goto error;

   321

   322

    // add channel callbacks

   323

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

   324

        goto error;

   325

   326

    // log an OPEN message

   327

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

   328

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

   329

        goto error;

   330

   331

    // ok

   332

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

   333

   334

    return SUCCESS;

   335

   336

error:

   337

    // cleanup

   338

    irc_log_chan_destroy(chan_ctx);

   339

   340

    return ERROR_CODE(err);

   341

}

   342

   343

/**

   344

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

   345

 *

   346

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

   347

 */

   348

static err_t irc_log_chan_stop (struct irc_log_chan *chan_ctx)

   349

{

   350

    err_t err;

   351

   352

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

   353

    chan_ctx->stopping = true;

   354

   355

    // log the CLOSE event

   356

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

   357

        goto error;

   358

   359

    // ok

   360

    return SUCCESS;

   361

   362

error:

   363

    // destroy it uncleanly

   364

    irc_log_chan_destroy(chan_ctx);

   365

   366

    return err;

   367

}

   368

   369

/**

   370

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

   371

 */

   372

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

   373

{

   374

    struct irc_log_ctx *ctx;

   375

   376

    // allocate

   377

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

   378

        return SET_ERROR(err, ERR_CALLOC);

   379

   380

    // store

   381

    ctx->nexus = nexus;

   382

   383

    // initialize

   384

    TAILQ_INIT(&ctx->channels);

   385

   386

    log_info("module initialized");

   387

   388

    // ok

   389

    *ctx_ptr = ctx;

   390

   391

    return SUCCESS;

   392

}

   393

   394

/**

   395

 * Process the irc_log.db_info config option.

   396

 *

   397

 * Creates a new evsql handle.

   398

 *

   399

 * Fails if ctx->db is already set.

   400

 */

   401

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

   402

{

   403

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

   404

   405

    // already connected?

   406

    if (ctx->db)

   407

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

   408

   409

    // create a new evsql handle

   410

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

   411

       return SET_ERROR(err, ERR_EVSQL_NEW_PQ);

   412

   413

    // ok

   414

    return SUCCESS;

   415

}

   416

   417

/**

   418

 * Process the irc_log.channel config option.

   419

 *

   420

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

   421

 *

   422

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

   423

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

   424

 */

   425

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

   426

{

   427

    const char *network, *channel;

   428

    struct irc_chan *chan;

   429

   430

    // parse required args

   431

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

   432

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

   433

   434

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

   435

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

   436

   437

    // extraneous stuff?

   438

    if (value)

   439

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

   440

   441

    // have a db configured?

   442

    if (!ctx->db)

   443

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

   444

   445

    // get the channel?

   446

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

   447

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

   448

   449

    // begin logging it

   450

    if (irc_log_chan(ctx, chan, err))

   451

        return ERROR_CODE(err);

   452

   453

    // ok

   454

    return SUCCESS;

   455

}

   456

   457

/**

   458

 * Set a config option

   459

 */

   460

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

   461

{

   462

    struct irc_log_ctx *ctx = _ctx;

   463

   464

    // wrong state

   465

    if (ctx->unloading)

   466

        RETURN_SET_ERROR_STR(err, ERR_MODULE_CONF, "module is being unloaded");

   467

   468

    // apply the config setting

   469

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

   470

        return irc_log_conf_db_info(ctx, value, err);

   471

   472

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

   473

        return irc_log_conf_channel(ctx, value, err);

   474

   475

    } else {

   476

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

   477

    }

   478

   479

    // ok

   480

    return SUCCESS;

   481

}

   482

   483

/**

   484

 * Deinitialize, logging CLOSE events for all channels, and removing any hooks we've added

   485

 */

   486

static err_t irc_log_unload (void *_ctx)

   487

{

   488

    struct irc_log_ctx *ctx = _ctx;

   489

    struct irc_log_chan *chan_ctx;

   490

   491

    // update our state to mark ourselves as unloading