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, error_t *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

    error_t err;

    31

    32

    // drop old nickname

    33

    free(conn->nickname);

    34

    35

    // strdup

    36

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

    37

        SET_ERROR(&err, ERR_STRDUP);

    38

    39

        // notify

    40

        return irc_conn_set_error(conn, &err);

    41

    }

    42

    43

    // ok

    44

    return SUCCESS;

    45

}

    46

    47

/**

    48

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

    49

 */

    50

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

    51

{

    52

    struct irc_conn *conn = arg;

    53

    54

    // update state

    55

    conn->registering = false;

    56

    conn->registered = true;

    57

    58

    // set our real nickname from the message target

    59

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

    60

        return;

    61

    62

    // trigger callback

    63

    if (conn->callbacks.on_registered)

    64

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

    65

}

    66

    67

/**

    68

 * PING <server1> [ <server2> ]

    69

 *

    70

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

    71

 */ 

    72

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

    73

{

    74

    struct irc_conn *conn = arg;

    75

    76

    // just reply

    77

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

    78

}

    79

    80

/**

    81

 * NICK <nickname>

    82

 *

    83

 * If the prefix is us, then update our nickname

    84

 */

    85

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

    86

{

    87

    struct irc_conn *conn = arg;

    88

    89

    // ignore if it's not us

    90

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

    91

        return;

    92

    93

    // update our nickname

    94

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

    95

}

    96

    97

/**

    98

 * CTCP ACTION handler

    99

 */

   100

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

   101

{

   102

    struct irc_conn *conn = arg;

   103

   104

    // build the pseudo-line and invoke

   105

    struct irc_line action_line = {

   106

        .source     = line->source,

   107

        .command    = "CTCP ACTION",

   108

        .args       = {

   109

            line->args[0],

   110

            line->args[1],

   111

            NULL

   112

        }

   113

    };

   114

   115

    // invoke the general command handlers

   116

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

   117

}

   118

   119

/**

   120

 * Our command handlers

   121

 */

   122

static struct irc_cmd_handler irc_conn_handlers[] = {

   123

    {   IRC_RPL_WELCOME,    &on_RPL_WELCOME     },

   124

    {   "PING",             &on_PING            },

   125

    {   "NICK",             &on_NICK            },

   126

    {   NULL,               NULL,               },

   127

   128

}, irc_conn_ctcp_handlers[] = {

   129

    {   "ACTION",                   &irc_conn_on_CTCP_ACTION        },

   130

    {   NULL,                       NULL                            }

   131

};

   132

   133

/**

   134

 * Incoming CTCP message handler

   135

 *

   136

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

   137

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

   138

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

   139

 *

   140

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

   141

 */

   142

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

   143

{

   144

    // copy the message data into a mutable buffer

   145

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

   146

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

   147

   148

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

   149

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

   150

   151

    // tokenize the extended message

   152

    // XXX: do something with the trailing data?

   153

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

   154

   155

    // parse the "command" tag

   156

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

   157

   158

    // invalid if missing

   159

    if (tag == NULL)

   160

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

   161

   162

    // parse the CTCP "line"

   163

    struct irc_line ctcp_line = {

   164

        // the sender of the message

   165

        .source     = line->source,

   166

   167

        // the CTCP extended message tag

   168

        .command    = tag,

   169

        .args       = { 

   170

            // the destination of the message

   171

            line->args[0],

   172

   173

            // the rest of the CTCP extended message payload

   174

            msg,

   175

   176

            NULL

   177

        }

   178

    };

   179

   180

    // invoke the CTCP command handlers

   181

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

   182

}

   183

   184

/**

   185

 * Incoming line handler

   186

 */

   187

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

   188

{

   189

    struct irc_conn *conn = arg;

   190

    struct irc_line line;

   191

    struct irc_nm nm;

   192

    int err;

   193

   194

    // log

   195

    log_debug("%s", line_buf);

   196

   197

    // parse

   198

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

   199

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

   200

        return;

   201

    }

   202

   203

    // trap CTCP messages

   204

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

   205

        // parse and invoke the CTCP command handlers

   206

        irc_conn_on_CTCP(conn, &line);

   207

   208

    else

   209

        // invoke command handlers

   210

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

   211

}

   212

   213

/**

   214

 * Transport failed

   215

 */

   216

static void irc_conn_on_error (error_t *err, void *arg)

   217

{

   218

    struct irc_conn *conn = arg;

   219

   220

    // EOF after quit?

   221

    if (ERROR_CODE(err) == ERR_EOF && conn->quitting) {

   222

        // udpate states

   223

        conn->registered = false;

   224

        conn->quitting = false;

   225

        conn->quit = true;

   226

   227

        // callback

   228

        if (conn->callbacks.on_quit)

   229

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

   230

   231

    } else {

   232

        // log

   233

        log_error(err, "transport error");

   234

   235

        // trash ourselves

   236

        irc_conn_set_error(conn, err);

   237

    }

   238

}

   239

   240

static struct line_proto_callbacks irc_conn_lp_callbacks = {

   241

    .on_line        = &irc_conn_on_line,

   242

    .on_error       = &irc_conn_on_error,

   243

};

   244

   245

// XXX: ugly hack to get at an event_base

   246

#include "sock_internal.h"

   247

   248

struct event_base **ev_base_ptr = &_sock_stream_ctx.ev_base;

   249

   250

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

   251

        void *cb_arg, error_t *err)

   252

{

   253

    struct irc_conn *conn;

   254

   255

    // alloc new state struct

   256

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

   257

        return SET_ERROR(err, ERR_CALLOC);

   258

   259

    // init state

   260

    conn->callbacks = *callbacks;

   261

    conn->cb_arg = cb_arg;

   262

   263

    // initialize command handlers

   264

    irc_cmd_init(&conn->handlers);

   265

    irc_cmd_init(&conn->ctcp_handlers);

   266

   267

    // add the core handlers 

   268

    if (

   269

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

   270

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

   271

    )

   272

        goto error;

   273

   274

    // create the line_proto, with our on_line handler

   275

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

   276

        goto error;

   277

   278

    // create the outgoing line queue

   279

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

   280

        goto error;

   281

   282

    // ok

   283

    *conn_ptr = conn;

   284

   285

    return SUCCESS;

   286

   287

error:

   288

    // release

   289

    irc_conn_destroy(conn);

   290

   291

    return ERROR_CODE(err);    

   292

}

   293

   294

void irc_conn_destroy (struct irc_conn *conn)

   295

{

   296

    // the line_proto

   297

    if (conn->lp)

   298

        line_proto_destroy(conn->lp);

   299

   300

    // the queue

   301

    if (conn->out_queue)

   302

        irc_queue_destroy(conn->out_queue);

   303

   304

    // the command handlers

   305

    irc_cmd_clear(&conn->handlers);

   306

    irc_cmd_clear(&conn->ctcp_handlers);

   307

   308

    // additional data

   309

    free(conn->nickname);

   310

   311

    // the irc_conn itself

   312

    free(conn);

   313

}

   314

   315

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

   316

{

   317

    // use the irc_cmd stuff

   318

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

   319

}

   320

   321

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

   322

{

   323

    err_t err;

   324

   325

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

   326

        return ERR_IRC_CONN_REGISTER_STATE;

   327

   328

    // send the initial messages

   329

    if (

   330

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

   331

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

   332

    )

   333

        return err;

   334

   335

    // set state

   336

    conn->registering = true;

   337

   338

    // ok

   339

    return SUCCESS;

   340

}

   341

   342

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

   343

{

   344

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

   345

}

   346

   347

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

   348

{

   349

    // just proxy off to irc_quuee

   350

    return irc_queue_process(conn->out_queue, line);

   351

}

   352

   353

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

   354

{

   355

    // NICK <nickname>

   356

    struct irc_line line = {

   357

        NULL, "NICK", { nickname }

   358

    };

   359

   360

    return irc_conn_send(conn, &line);

   361

}

   362

   363

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

   364

{

   365

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

   366

    struct irc_line line = {

   367

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

   368

    };

   369

   370

    return irc_conn_send(conn, &line);

   371

}

   372

   373

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

   374

{

   375

    // PONG <server> [ <server2> ]

   376

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

   377

    struct irc_line line = {

   378

        NULL, "PONG", { target }

   379

    };

   380

   381

    return irc_conn_send(conn, &line);

   382

}

   383

   384

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

   385

{

   386

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

   387

    struct irc_line line = {

   388

        NULL, "JOIN", { channel }

   389

    };

   390

   391

    return irc_conn_send(conn, &line);

   392

}

   393

   394

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

   395

{

   396

    // PRIVMSG <msgtarget> <message>

   397

    struct irc_line line = {

   398

        NULL, "PRIVMSG", { target, message }

   399

    };

   400

   401

    return irc_conn_send(conn, &line);

   402

}

   403

   404

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

   405

{

   406

    // NOTICE <msgtarget> <message>

   407

    struct irc_line line = {

   408

        NULL, "NOTICE", { target, message }

   409

    };

   410

   411

    return irc_conn_send(conn, &line);

   412

}

   413

   414

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

   415

{

   416

    err_t err;

   417

   418

    struct irc_line line = {

   419

        NULL, "QUIT", { message }

   420

    };

   421

   422

    // state check

   423

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

   424

        return ERR_IRC_CONN_QUIT_STATE;

   425

   426

    // try and send

   427

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

   428

        return err;

   429

   430

    // mark as quitting

   431

    conn->quitting = true;

   432

   433

    // ok

   434

    return SUCCESS;

   435

}

   436