1

#include "irc_conn.h"

     2

#include "irc_cmd.h"

     3

#include "irc_proto.h"

     4

#include "log.h"

     5

     6

#include <stdlib.h>

     7

#include <string.h>

     8

#include <assert.h>

     9

    10

/**

    11

 * Handle an async error on this IRC connection that we could not recover from any other way, the protocol is now dead,

    12

 * and should be considered as destroyed after this returns.

    13

 *

    14

 * For conveniance, this returns the ERROR_CODE

    15

 */

    16

static err_t irc_conn_set_error (struct irc_conn *conn, struct error_info *err)

    17

{

    18

    // notify user callback

    19

    conn->callbacks.on_error(conn, err, conn->cb_arg);

    20

    21

    return ERROR_CODE(err);

    22

}

    23

    24

    25

/**

    26

 * Update irc_conn.nickname

    27

 */

    28

static err_t irc_conn_set_nickname (struct irc_conn *conn, const char *nickname)

    29

{

    30

    struct error_info err;

    31

    32

    // strdup

    33

    if ((conn->nickname = strdup(nickname)) == NULL) {

    34

        SET_ERROR(&err, ERR_STRDUP);

    35

    36

        // notify

    37

        return irc_conn_set_error(conn, &err);

    38

    }

    39

    40

    // ok

    41

    return SUCCESS;

    42

}

    43

    44

/**

    45

 * 001 <nick> :Welcome to the Internet Relay Network <nick>!<user>@<host>

    46

 */

    47

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

    48

{

    49

    struct irc_conn *conn = arg;

    50

    51

    // update state

    52

    conn->registering = false;

    53

    conn->registered = true;

    54

    55

    // set our real nickname from the message target

    56

    if (irc_conn_set_nickname(conn, line->args[0]))

    57

        return;

    58

    59

    // trigger callback

    60

    if (conn->callbacks.on_registered)

    61

        conn->callbacks.on_registered(conn, conn->cb_arg);

    62

}

    63

    64

/**

    65

 * PING <server1> [ <server2> ]

    66

 *

    67

 * Send a 'PONG <server1>` reply right away.

    68

 */ 

    69

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

    70

{

    71

    struct irc_conn *conn = arg;

    72

    73

    // just reply

    74

    irc_conn_PONG(conn, line->args[0]);

    75

}

    76

    77

/**

    78

 * NICK <nickname>

    79

 *

    80

 * If the prefix is us, then update our nickname

    81

 */

    82

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

    83

{

    84

    struct irc_conn *conn = arg;

    85

    86

    // ignore if it's not us

    87

    if (!line->source || irc_cmp_nick(line->source->nickname, conn->nickname))

    88

        return;

    89

    90

    // update our nickname

    91

    irc_conn_set_nickname(conn, line->args[0]);

    92

}

    93

    94

/**

    95

 * CTCP ACTION handler

    96

 */

    97

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

    98

{

    99

    struct irc_conn *conn = arg;

   100

   101

    // build the pseudo-line and invoke

   102

    struct irc_line action_line = {

   103

        .source     = line->source,

   104

        .command    = "CTCP ACTION",

   105

        .args       = {

   106

            line->args[0],

   107

            line->args[1],

   108

            NULL

   109

        }

   110

    };

   111

   112

    // invoke the general command handlers

   113

    irc_cmd_invoke(&conn->handlers, &action_line);

   114

}

   115

   116

/**

   117

 * Our command handlers

   118

 */

   119

static struct irc_cmd_handler irc_conn_handlers[] = {

   120

    {   IRC_RPL_WELCOME,    &on_RPL_WELCOME     },

   121

    {   "PING",             &on_PING            },

   122

    {   "NICK",             &on_NICK            },

   123

    {   NULL,               NULL,               },

   124

   125

}, irc_conn_ctcp_handlers[] = {

   126

    {   "ACTION",                   &irc_conn_on_CTCP_ACTION        },

   127

    {   NULL,                       NULL                            }

   128

};

   129

   130

/**

   131

 * Incoming CTCP message handler

   132

 *

   133

 * We only handle "simple" CTCP messages, i.e. those that begin and end with X-DELIM and contain a single tagged

   134

 * extended message. The full range of CTCP quoting etc specified in the "offical" spec referenced below is not

   135

 * implemented, as it is rarely used, or even implemented.

   136

 *

   137

 * http://www.irchelp.org/irchelp/rfc/ctcpspec.html

   138

 */

   139

static void irc_conn_on_CTCP (struct irc_conn *conn, const struct irc_line *line)

   140

{

   141

    // copy the message data into a mutable buffer

   142

    char data_buf[strlen(line->args[1]) + 1], *data = data_buf;

   143

    strcpy(data_buf, line->args[1]);

   144

   145

    // should only be called when this is true...

   146

    assert(*data++ == '\001');

   147

   148

    // tokenize the extended message

   149

    // XXX: do something with the trailing data?

   150

    char *msg = strsep(&data, "\001");

   151

   152

    // parse the "command" tag

   153

    char *tag = strsep(&msg, " ");

   154

   155

    // invalid if missing

   156

    if (tag == NULL)

   157

        return log_warn("CTCP message with no tag: '%s'", data);

   158

   159

    // parse the CTCP "line"

   160

    struct irc_line ctcp_line = {

   161

        // the sender of the message

   162

        .source     = line->source,

   163

   164

        // the CTCP extended message tag

   165

        .command    = tag,

   166

        .args       = { 

   167

            // the destination of the message

   168

            line->args[0],

   169

   170

            // the rest of the CTCP extended message payload

   171

            msg,

   172

   173

            NULL

   174

        }

   175

    };

   176

   177

    // invoke the CTCP command handlers

   178

    irc_cmd_invoke(&conn->ctcp_handlers, &ctcp_line);

   179

}

   180

   181

/**

   182

 * Incoming line handler

   183

 */

   184

static void irc_conn_on_line (char *line_buf, void *arg) 

   185

{

   186

    struct irc_conn *conn = arg;

   187

    struct irc_line line;

   188

    struct irc_nm nm;

   189

    int err;

   190

   191

    // log

   192

    log_debug("%s", line_buf);

   193

   194

    // parse

   195

    if ((err = irc_line_parse(&line, &nm, line_buf))) {

   196

        log_warn("invalid line: %s: %s\n", line_buf, error_name(err));

   197

        return;

   198

    }

   199

   200

    // trap CTCP messages

   201

    if (strcasecmp(line.command, "PRIVMSG") == 0 && line.args[1][0] == '\001')

   202

        // parse and invoke the CTCP command handlers

   203

        irc_conn_on_CTCP(conn, &line);

   204

   205

    else

   206

        // invoke command handlers

   207

        irc_cmd_invoke(&conn->handlers, &line);

   208

}

   209

   210

/**

   211

 * Transport failed

   212

 */

   213

static void irc_conn_on_error (struct error_info *err, void *arg)

   214

{

   215

    struct irc_conn *conn = arg;

   216

   217

    // EOF after quit?

   219

        // udpate states

   220

        conn->registered = false;

   221

        conn->quitting = false;

   222

        conn->quit = true;

   223

   224

        // callback

   225

        if (conn->callbacks.on_quit)

   226

            conn->callbacks.on_quit(conn, conn->cb_arg);

   227

   228

    } else {

   229

        // log

   230

        log_err_info(err, "line_proto error");

   231

   232

        // trash ourselves

   233

        irc_conn_set_error(conn, err);

   234

    }

   235

}

   236

   237

static struct line_proto_callbacks irc_conn_lp_callbacks = {

   238

    .on_line        = &irc_conn_on_line,

   239

    .on_error       = &irc_conn_on_error,

   240

};

   241

   242

// XXX: ugly hack to get at an event_base

   243

#include "sock_internal.h"

   244

   245

struct event_base **ev_base_ptr = &_sock_stream_ctx.ev_base;

   246

   247

err_t irc_conn_create (struct irc_conn **conn_ptr, transport_t *transport, const struct irc_conn_callbacks *callbacks, 

   248

        void *cb_arg, error_t *err)

   249

{

   250

    struct irc_conn *conn;

   251

   252

    // alloc new state struct

   253

    if ((conn = calloc(1, sizeof(struct irc_conn))) == NULL)

   254

        return SET_ERROR(err, ERR_CALLOC);

   255

   256

    // init state

   257

    conn->callbacks = *callbacks;

   258

    conn->cb_arg = cb_arg;

   259

   260

    // initialize command handlers

   261

    irc_cmd_init(&conn->handlers);

   262

    irc_cmd_init(&conn->ctcp_handlers);

   263

   264

    // add the core handlers 

   265

    if (

   266

            (ERROR_CODE(err) = irc_cmd_add(&conn->handlers, irc_conn_handlers, conn))

   267

        ||  (ERROR_CODE(err) = irc_cmd_add(&conn->ctcp_handlers, irc_conn_ctcp_handlers, conn))

   268

    )

   269

        goto error;

   270

   271

    // create the line_proto, with our on_line handler

   272

    if (line_proto_create(&conn->lp, transport, IRC_LINE_MAX * 1.5, &irc_conn_lp_callbacks, conn, err))

   273

        goto error;

   274

   275

    // create the outgoing line queue

   276

    if (irc_queue_create(&conn->out_queue, *ev_base_ptr, conn->lp, err))

   277

        goto error;

   278

   279

    // ok

   280

    *conn_ptr = conn;

   281

   282

    return SUCCESS;

   283

   284

error:

   285

    // release

   286

    irc_conn_destroy(conn);

   287

   288

    return ERROR_CODE(err);    

   289

}

   290

   291

void irc_conn_destroy (struct irc_conn *conn)

   292

{

   293

    // the line_proto

   294

    if (conn->lp)

   295

        line_proto_destroy(conn->lp);

   296

   297

    // the queue

   298

    if (conn->out_queue)

   299

        irc_queue_destroy(conn->out_queue);

   300

   301

    // the command handlers

   302

    irc_cmd_free(&conn->handlers);

   303

    irc_cmd_free(&conn->ctcp_handlers);

   304

   305

    // additional data

   306

    free(conn->nickname);

   307

   308

    // the irc_conn itself

   309

    free(conn);

   310

}

   311

   312

err_t irc_conn_add_cmd_handlers (struct irc_conn *conn, struct irc_cmd_handler *handlers, void *arg)

   313

{

   314

    // use the irc_cmd stuff

   315

    return irc_cmd_add(&conn->handlers, handlers, arg);

   316

}

   317

   318

err_t irc_conn_register (struct irc_conn *conn, const struct irc_conn_register_info *info)

   319

{

   320

    err_t err;

   321

   322

    if (conn->registering || conn->registered)

   323

        return ERR_IRC_CONN_REGISTER_STATE;

   324

   325

    // send the initial messages

   326

    if (

   327

            (err = irc_conn_NICK(conn, info->nickname))

   328

        ||  (err = irc_conn_USER(conn, info->username, info->realname))

   329

    )

   330

        return err;

   331

   332

    // set state

   333

    conn->registering = true;

   334

   335

    // ok

   336

    return SUCCESS;

   337

}

   338

   339

bool irc_conn_self (struct irc_conn *conn, const char *nickname)

   340

{

   341

    return conn && nickname && conn->nickname && (irc_cmp_nick(conn->nickname, nickname) == 0);

   342

}

   343

   344

err_t irc_conn_send (struct irc_conn *conn, const struct irc_line *line)

   345

{

   346

    // just proxy off to irc_quuee

   347

    return irc_queue_process(conn->out_queue, line);

   348

}

   349

   350

err_t irc_conn_NICK (struct irc_conn *conn, const char *nickname)

   351

{

   352

    // NICK <nickname>

   353

    struct irc_line line = {

   354

        NULL, "NICK", { nickname }

   355

    };

   356

   357

    return irc_conn_send(conn, &line);

   358

}

   359

   360

err_t irc_conn_USER (struct irc_conn *conn, const char *username, const char *realname)

   361

{

   362

    // USER <user> <mode> * <realname>

   363

    struct irc_line line = {

   364

        NULL, "USER", { username, "0", "*", realname }

   365

    };

   366

   367

    return irc_conn_send(conn, &line);

   368

}

   369

   370

err_t irc_conn_PONG (struct irc_conn *conn, const char *target)

   371

{

   372

    // PONG <server> [ <server2> ]

   373

    // params are actually the wrong way around now, but nobody cares

   374

    struct irc_line line = {

   375

        NULL, "PONG", { target }

   376

    };

   377

   378

    return irc_conn_send(conn, &line);

   379

}

   380

   381

err_t irc_conn_JOIN (struct irc_conn *conn, const char *channel)

   382

{

   383

    // JOIN (<channel> [ "," <channel> [ ... ] ]) [<key> [ "," <key> [ ... ] ] ]

   384

    struct irc_line line = {

   385

        NULL, "JOIN", { channel }

   386

    };

   387

   388

    return irc_conn_send(conn, &line);

   389

}

   390

   391

err_t irc_conn_PRIVMSG (struct irc_conn *conn, const char *target, const char *message)

   392

{

   393

    // PRIVMSG <msgtarget> <message>

   394

    struct irc_line line = {

   395

        NULL, "PRIVMSG", { target, message }

   396

    };

   397

   398

    return irc_conn_send(conn, &line);

   399

}

   400

   401

err_t irc_conn_NOTICE (struct irc_conn *conn, const char *target, const char *message)

   402

{

   403

    // NOTICE <msgtarget> <message>

   404

    struct irc_line line = {

   405

        NULL, "NOTICE", { target, message }

   406

    };

   407

   408

    return irc_conn_send(conn, &line);

   409

}

   410

   411

err_t irc_conn_QUIT (struct irc_conn *conn, const char *message)

   412

{

   413

    err_t err;

   414

   415

    struct irc_line line = {

   416

        NULL, "QUIT", { message }

   417

    };

   418

   419

    // state check

   420

    if (conn->quitting || conn->quit)

   421

        return ERR_IRC_CONN_QUIT_STATE;

   422

   423

    // try and send

   424

    if ((err = irc_conn_send(conn, &line)))

   425

        return err;

   426

   427

    // mark as quitting

   428

    conn->quitting = true;

   429

   430

    // ok

   431

    return SUCCESS;

   432

}

   433