8

#include <assert.h> //<<< XXX: remove

    14

 * The irc_log module state.

    24

/**

    25

 * State required to use irc_cmd_handler with irc_chan.handlers.

    26

 */

    27

struct irc_log_chan {

    28

    /** The irc_log context */

    29

    struct irc_log_ctx *ctx;

    30

    31

    /** The target channel */

    32

    struct irc_chan *chan;

    33

};

    34

    35

/**

    36

 * Our evsql result handler for irc_log_event INSERTs.

    37

 */

    52

/**

    53

 * Log the event into our database.

    54

 *

    55

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

    56

 */

    57

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

    61

    62

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

    63

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

    64

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

    65

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

    85

    86

    // drop lines if not connected

    87

    if (ctx->db == NULL) {

    88

        log_warn("no database connected");

    89

    90

        return ERR_MODULE_CONF;

    91

    }

    96

        nickname, username, hostname,

   102

            nickname, username, hostname,

   106

        return ERR_EVSQL_QUERY_EXEC;

   108

   109

    // ok

   110

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

   111

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

   112

        nickname, username, hostname,

   113

        type, target, message

   114

    );

   115

   116

    return SUCCESS;

   119

/**

   120

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

   121

 */

   122

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

   123

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

   125

    char prefix_buf[IRC_PREFIX_MAX];

   126

    struct irc_nm nm;

   127

    err_t err;

   129

    // parse nickmask

   130

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

   131

        return err;

   132

   133

    // log

   134

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

   137

/**

   138

 * Log a simple channel event of the form:

   139

 *

   140

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

   141

 */

   142

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

   143

{

   144

    struct irc_log_chan *chan_ctx = arg;

   145

   146

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

   147

   148

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

   149

}

   150

   151

/**

   152

 * Log a MODE event on a channel

   153

 *

   154

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

   155

 *

   156

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

   157

 */

   158

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

   159

{

   160

    struct irc_log_chan *chan_ctx = arg;

   161

    char message[512], *ptr = message;

   162

    const char *cmdarg;

   163

   164

    // iterate over each arg

   165

    FOREACH_IRC_LINE_ARGS(line, cmdarg) {

   166

        // separate with spaces

   167

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

   168

            *ptr++ = ' ';

   169

   170

        // append

   171

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

   172

   173

        // buffer full?

   174

        if (ptr > message + 512)

   175

            break;

   176

    }

   177

   178

    // log

   179

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

   180

}

   181

   182

/**

   183

 * Log a KICK event on a channel

   184

 *

   185

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

   186

 */

   187

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

   188

{

   189

    struct irc_log_chan *chan_ctx = arg;

   190

   191

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

   192

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

   193

   194

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

   195

}

   196

   197

/**

   198

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

   199

 *

   200

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

   201

 */

   202

static struct irc_cmd_handler _chan_cmd_handlers[] = {

   203

    {   "JOIN",     &irc_log_on_chan_generic        },

   204

    {   "PART",     &irc_log_on_chan_generic        },

   205

    {   "MODE",     &irc_log_on_chan_MODE           },

   206

    {   "TOPIC",    &irc_log_on_chan_generic        },

   207

    {   "KICK",     &irc_log_on_chan_KICK           },

   208

    {   "PRIVMSG",  &irc_log_on_chan_generic        },

   209

    {   "NOTICE",   &irc_log_on_chan_generic        },

   210

    {   NULL,       NULL                            }

   211

};

   212

   213

/**

   214

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

   215

 *

   216

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

   217

 */

   219

    .on_self_join       = NULL,

   220

    .on_msg             = NULL,

   245

/**

   246

 * Process the irc_log.db_info config option.

   247

 *

   248

 * Creates a new evsql handle.

   249

 *

   250

 * Fails if ctx->db is already set.

   251

 */

   252

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

   253

{

   254

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

   255

   256

    // already connected?

   257

    if (ctx->db)

   258

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

   259

   260

    // create a new evsql handle

   261

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

   262

       return SET_ERROR(err, ERR_EVSQL_NEW_PQ);

   263

   264

    // ok

   265

    return SUCCESS;

   266

}

   267

   268

/**

   269

 * Process the irc_log.channel config option.

   270

 *

   271

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

   272

 *

   273

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

   274

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

   275

 */

   276

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

   277

{

   278

    const char *network, *channel;

   279

   280

    struct irc_log_chan *chan_ctx;

   281

   282

    // parse required args

   283

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

   284

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

   285

   286

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

   287

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

   288

   289

    // extraneous stuff?

   290

    if (value)

   291

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

   292

   293

    // have a db configured?

   294

    if (!ctx->db)

   295

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

   296

   297

    // alloc

   298

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

   299

        return SET_ERROR(err, ERR_CALLOC);

   300

   301

    // store

   302

    chan_ctx->ctx = ctx;

   303

   304

    // get the channel?

   305

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

   306

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

   307

   308

    // add low-level handlers

   309

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

   310

        goto error;

   311

   312

    // add channel callbacks

   313

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

   314

        goto error;

   315

   316

    // log an OPEN message

   317

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

   318

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

   319

        goto error;

   320

   321

    // ok

   322

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

   323

   324

    return SUCCESS;

   325

   326

error:

   327

    // XXX: remove callbacks

   328

    assert(!chan_ctx->chan);

   329

   330

    free(chan_ctx);

   331

   332

    return ERROR_CODE(err);    

   333

}

   334

   335

/**

   336

 * Set a config option

   337

 */

   343

        return irc_log_conf_db_info(ctx, value, err);

   346

        return irc_log_conf_channel(ctx, value, err);

   363