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

{

    17

    // update state

    18

    conn->registered = true;

    19

    20

    log_info("registered");

    21

}

    22

    23

/*

    24

 * PING <server1> [ <server2> ]

    25

 *

    26

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

    27

 */ 

    28

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

    29

{

    32

    // just reply

    33

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

    34

}

    35

    36

/*

    37

 * Our command handlers

    38

 */

    39

struct irc_cmd_handler _cmd_handlers[] = {

    40

    { IRC_RPL_WELCOME,  on_RPL_WELCOME      },

    41

    { "PING",           on_PING             },

    42

    { NULL,             NULL,               },

    43

};

    44

    45

/*

    46

 * Incoming line handler

    47

 */

    48

void irc_conn_on_line (char *line_buf, void *arg) 

    49

{

    50

    struct irc_conn *conn = arg;

    51

    struct irc_line line;

    52

    struct irc_cmd_chain *chain;

    53

    struct irc_cmd_handler *handler;

    54

    int err;

    55

    56

    // log

    57

    log_debug("%s", line_buf);

    58

    59

    // parse

    60

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

    61

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

    62

        return;

    63

    }

    64

    65

    // run each handler chain

    66

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

    67

        // look up appropriate handler

    68

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

    69

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

    70

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

    71

                // invoke the func

    72

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

    73

    74

                // ...only one per chain

    75

                break;

    76

            }

    77

        }

    78

    }

    79

}

    80

    81

err_t irc_conn_create (struct irc_conn **conn_ptr, struct sock_stream *sock, const struct irc_conn_config *config, struct error_info *err)

    82

{

    83

    struct irc_conn *conn;

    84

    85

    // alloc new state struct

    86

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

    87

        return SET_ERROR(err, ERR_CALLOC);

    88

    89

    // initialize command handlers

    90

    STAILQ_INIT(&conn->handlers);

    91

    92

    // add the core handlers 

    93

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

    94

        return ERROR_CODE(err);

    95

    96

    // create the line_proto, with our on_line handler

    97

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

    98

        return ERROR_CODE(err);

    99

   100

    // send the initial messages

   101

    if (

   102

            irc_conn_NICK(conn, config->nickname)

   103

        ||  irc_conn_USER(conn, config->username, config->realname)

   104

    )

   105

        return ERROR_CODE(err);

   106

   107

    // ok

   108

    *conn_ptr = conn;

   109

   110

    return SUCCESS;

   111

}

   112

   113

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

   114

{

   115

    struct irc_cmd_chain *item;

   116

   117

    // allocate the chain item

   118

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

   119

        return ERR_CALLOC;

   120

   121

    // store

   122

    item->handlers = handlers;

   123

    item->arg = arg;

   124

   125

    // append

   126

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

   127

   128

    // ok

   129

    return SUCCESS;

   130

}

   131

   132

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

   133

{

   134

    char line_buf[IRC_LINE_MAX + 2];

   135

    err_t err;

   137

   138

    // format

   139

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

   140

        return err;

   141

   142

    // log

   143

    log_debug("%s", line_buf);

   144

   145

    // add CRLF

   146

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

   147

   148

    // send using line_proto

   149

    // XXX: ignore output-buffering

   151

}

   152

   153

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

   154

{

   155

    // NICK <nickname>

   156

    struct irc_line line = {

   157

        NULL, "NICK", { nickname, NULL }

   158

    };

   159

   160

    return irc_conn_send(conn, &line);

   161

}

   162

   163

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

   164

{

   165

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

   166

    struct irc_line line = {

   167

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

   168

    };

   169

   170

    return irc_conn_send(conn, &line);

   171

}

   172

   173

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

   174

{

   175

    // PONG <server> [ <server2> ]

   176

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

   177

    struct irc_line line = {

   178

        NULL, "PONG", { target, NULL }

   179

    };

   180

   181

    return irc_conn_send(conn, &line);

   182

}

   183

   184

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

   185

{

   186

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

   187

    struct irc_line line = {

   188

        NULL, "JOIN", { channel, NULL }

   189

    };

   190

   191

    return irc_conn_send(conn, &line);

   192

}

   193