1

     2

#include "irc_conn.h"

     3

#include "irc_cmd.h"

     4

#include "log.h"

     5

     6

#include <stdlib.h>

     7

#include <string.h>

     8

     9

/*

    10

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

    11

 */

    12

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

    13

{

    14

    (void) line;

    15

    (void) arg;

    16

    17

    // update state

    19

    conn->registered = true;

    20

    24

}

    25

    26

/*

    27

 * PING <server1> [ <server2> ]

    28

 *

    29

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

    30

 */ 

    31

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

    32

{

    33

    (void) arg;

    34

    35

    // just reply

    36

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

    37

}

    38

    39

/*

    40

 * Our command handlers

    41

 */

    42

struct irc_cmd_handler _cmd_handlers[] = {

    43

    { IRC_RPL_WELCOME,  on_RPL_WELCOME      },

    44

    { "PING",           on_PING             },

    45

    { NULL,             NULL,               },

    46

};

    47

    48

/*

    49

 * Incoming line handler

    50

 */

    51

void irc_conn_on_line (char *line_buf, void *arg) 

    52

{

    53

    struct irc_conn *conn = arg;

    54

    struct irc_line line;

    55

    struct irc_cmd_chain *chain;

    56

    struct irc_cmd_handler *handler;

    57

    int err;

    58

    59

    // log

    60

    log_debug("%s", line_buf);

    61

    62

    // parse

    63

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

    64

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

    65

        return;

    66

    }

    67

    68

    // run each handler chain

    69

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

    70

        // look up appropriate handler

    71

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

    72

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

    73

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

    74

                // invoke the func

    75

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

    76

    77

                // ...only one per chain

    78

                break;

    79

            }

    80

        }

    81

    }

    82

}

    83

    86

{

    87

    struct irc_conn *conn;

    88

    89

    // alloc new state struct

    90

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

    91

        return SET_ERROR(err, ERR_CALLOC);

    92

    97

    // initialize command handlers

    98

    STAILQ_INIT(&conn->handlers);

    99

   100

    // add the core handlers 

   101

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

   102

        return ERROR_CODE(err);

   103

   104

    // create the line_proto, with our on_line handler

   105

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

   106

        return ERROR_CODE(err);

   107

   108

    // ok

   109

    *conn_ptr = conn;

   110

   111

    return SUCCESS;

   112

}

   113

   114

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

   115

{

   116

    struct irc_cmd_chain *item;

   117

   118

    // allocate the chain item

   119

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

   120

        return ERR_CALLOC;

   121

   122

    // store

   123

    item->handlers = handlers;

   124

    item->arg = arg;

   125

   126

    // append

   127

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

   128

   129

    // ok

   130

    return SUCCESS;

   131

}

   132

   156

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

   157

{

   158

    char line_buf[IRC_LINE_MAX + 2];

   159

    err_t err;

   160

    int ret;

   161

   162

    // format

   163

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

   164

        return err;

   165

   166

    // log

   167

    log_debug("%s", line_buf);

   168

   169

    // add CRLF

   170

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

   171

   172

    // send using line_proto

   173

    // XXX: ignore output-buffering

   174

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

   175

}

   176

   177

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

   178

{

   179

    // NICK <nickname>

   180

    struct irc_line line = {

   181

        NULL, "NICK", { nickname, NULL }

   182

    };

   183

   184

    return irc_conn_send(conn, &line);

   185

}

   186

   187

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

   188

{

   189

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

   190

    struct irc_line line = {

   191

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

   192

    };

   193

   194

    return irc_conn_send(conn, &line);

   195

}

   196

   197

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

   198

{

   199

    // PONG <server> [ <server2> ]

   200

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

   201

    struct irc_line line = {

   202

        NULL, "PONG", { target, NULL }

   203

    };

   204

   205

    return irc_conn_send(conn, &line);

   206

}

   207

   208

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

   209

{

   210

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

   211

    struct irc_line line = {

   212

        NULL, "JOIN", { channel, NULL }

   213

    };

   214

   215

    return irc_conn_send(conn, &line);

   216

}

   217