1

#include "irc_conn.h"

     2

#include "irc_cmd.h"

     3

#include "log.h"

     4

     5

#include <stdlib.h>

     6

#include <string.h>

     7

     8

/*

     9

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

    10

 */

    11

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

    12

{

    13

    (void) line;

    14

    (void) arg;

    15

    16

    // update state

    17

    conn->registering = false;

    18

    conn->registered = true;

    19

    20

    // trigger callback

    21

    if (conn->callbacks.on_registered)

    22

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

    23

}

    24

    25

/*

    26

 * PING <server1> [ <server2> ]

    27

 *

    28

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

    29

 */ 

    30

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

    31

{

    32

    (void) arg;

    33

    34

    // just reply

    35

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

    36

}

    37

    38

/*

    39

 * Our command handlers

    40

 */

    41

struct irc_cmd_handler _cmd_handlers[] = {

    42

    { IRC_RPL_WELCOME,  on_RPL_WELCOME      },

    43

    { "PING",           on_PING             },

    44

    { NULL,             NULL,               },

    45

};

    46

    47

/*

    48

 * Incoming line handler

    49

 */

    50

void irc_conn_on_line (char *line_buf, void *arg) 

    51

{

    52

    struct irc_conn *conn = arg;

    53

    struct irc_line line;

    54

    struct irc_cmd_chain *chain;

    55

    struct irc_cmd_handler *handler;

    56

    int err;

    57

    58

    // log

    59

    log_debug("%s", line_buf);

    60

    61

    // parse

    62

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

    63

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

    64

        return;

    65

    }

    66

    67

    // run each handler chain

    68

    STAILQ_FOREACH(chain, &conn->handlers, node) {

    69

        // look up appropriate handler

    70

        for (handler = chain->handlers; handler->command; handler++) {

    71

            // the command is alpha-only, so normal case-insensitive cmp is fine

    72

            if (strcasecmp(handler->command, line.command) == 0) {

    73

                // invoke the func

    74

                handler->func(conn, &line, chain->arg);

    75

    76

                // ...only one per chain

    77

                break;

    78

            }

    79

        }

    80

    }

    81

}

    82

    83

err_t irc_conn_create (struct irc_conn **conn_ptr, struct sock_stream *sock, const struct irc_conn_callbacks *callbacks, 

    84

        void *cb_arg, struct error_info *err)

    85

{

    86

    struct irc_conn *conn;

    87

    88

    // alloc new state struct

    89

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

    90

        return SET_ERROR(err, ERR_CALLOC);

    91

    92

    // init state

    93

    conn->callbacks = *callbacks;

    94

    conn->cb_arg = cb_arg;

    95

    96

    // initialize command handlers

    97

    STAILQ_INIT(&conn->handlers);

    98

    99

    // add the core handlers 

   100

    if ((ERROR_CODE(err) = irc_conn_register_handler_chain(conn, _cmd_handlers, NULL)))

   102

   103

    // create the line_proto, with our on_line handler

   104

    if (line_proto_create(&conn->lp, sock, IRC_LINE_MAX * 1.5, &irc_conn_on_line, conn, err))

   106

   107

    // ok

   108

    *conn_ptr = conn;

   109

   110

    return SUCCESS;

   140

}

   141

   142

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

   143

{

   144

    struct irc_cmd_chain *item;

   145

   146

    // allocate the chain item

   147

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

   148

        return ERR_CALLOC;

   149

   150

    // store

   151

    item->handlers = handlers;

   152

    item->arg = arg;

   153

   154

    // append

   155

    STAILQ_INSERT_TAIL(&conn->handlers, item, node);

   156

   157

    // ok

   158

    return SUCCESS;

   159

}

   160

   161

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

   162

{

   163

    err_t err;

   164

   165

    // assert state

   166

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

   167

        // XXX: stupid error code

   168

        return ERR_IRC_CONN_REGISTER_STATE;

   169

   170

    // send the initial messages

   171

    if (

   172

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

   173

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

   174

    )

   175

        return err;

   176

   177

    // set state

   178

    conn->registering = true;

   179

   180

    // ok

   181

    return SUCCESS;

   182

}

   183

   184

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

   185

{

   186

    char line_buf[IRC_LINE_MAX + 2];

   187

    err_t err;

   188

    int ret;

   189

   190

    // format

   191

    if ((err = irc_line_build(line, line_buf)))

   192

        return err;

   193

   194

    // log

   195

    log_debug("%s", line_buf);

   196

   197

    // add CRLF

   198

    strcat(line_buf, "\r\n");

   199

   200

    // send using line_proto

   201

    // XXX: ignore output-buffering

   202

    return (ret = line_proto_send(conn->lp, line_buf)) < 0 ? -ret : SUCCESS;

   203

}

   204

   205

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

   206

{

   207

    // NICK <nickname>

   208

    struct irc_line line = {

   209

        NULL, "NICK", { nickname, NULL }

   210

    };

   211

   212

    return irc_conn_send(conn, &line);

   213

}

   214

   215

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

   216

{

   217

    // USER <user> <mode> <unused> <realname>

   218

    struct irc_line line = {

   219

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

   220

    };

   221

   222

    return irc_conn_send(conn, &line);

   223

}

   224

   225

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

   226

{

   227

    // PONG <server> [ <server2> ]

   228

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

   229

    struct irc_line line = {

   230

        NULL, "PONG", { target, NULL }

   231

    };

   232

   233

    return irc_conn_send(conn, &line);

   234

}

   235

   236

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

   237

{

   238

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

   239

    struct irc_line line = {

   240

        NULL, "JOIN", { channel, NULL }

   241

    };

   242

   243

    return irc_conn_send(conn, &line);

   244

}

   245