1

     2

#include "irc_conn.h"

     3

#include "irc_cmd.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)

    13

{

    14

    // update state

    15

    conn->registered = true;

    18

}

    19

    20

/*

    21

 * PING <server1> [ <server2> ]

    22

 *

    23

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

    24

 */ 

    25

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

    26

{

    27

    // just reply

    28

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

    29

}

    30

    31

/*

    32

 * Our command handlers

    33

 */

    34

struct irc_cmd_handler {

    35

    /* The command name */

    36

    const char *command;

    37

    38

    /* The handler function */

    39

    void (*func) (struct irc_conn *conn, const struct irc_line *line);

    40

    41

} _cmd_handlers[] = {

    42

    { IRC_RPL_WELCOME,  on_RPL_WELCOME      },

    43

    { "PING",           on_PING             },

    44

    { NULL,             NULL,               },

    45

};

    46

    47

void irc_conn_on_line (char *line_buf, void *arg) 

    48

{

    49

    struct irc_conn *conn = arg;

    50

    struct irc_line line;

    51

    struct irc_cmd_handler *handler;

    52

    int err;

    53

    54

    // log

    56

    57

    // parse

    58

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

    59

        printf("!!! Invalid line: %s: %s\n", line_buf, error_name(err));

    60

    61

        return;

    62

    }

    63

    64

    // look up appropriate handler

    65

    for (handler = _cmd_handlers; handler->command; handler++) {

    66

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

    67

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

    68

            // invoke the func

    69

            handler->func(conn, &line);

    70

            break;

    71

        }

    72

    }

    73

}

    74

    75

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

    76

{

    77

    struct irc_conn *conn;

    78

    79

    // alloc new state struct

    80

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

    81

        return SET_ERROR(err, ERR_CALLOC);

    82

    83

    // create the line_proto, with our on_line handler

    84

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

    85

        return ERROR_CODE(err);

    86

    87

    // send the initial messages

    88

    if (

    89

            irc_conn_NICK(conn, config->nickname)

    90

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

    91

    )

    92

        return ERROR_CODE(err);

    93

    94

    // ok

    95

    *conn_ptr = conn;

    96

    97

    return SUCCESS;

    98

}

    99

   100

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

   101

{

   102

    char line_buf[IRC_LINE_MAX + 2];

   103

    err_t err;

   104

   105

    // format

   106

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

   107

        return err;

   108

   109

    // log

   111

   112

    // add CRLF

   113

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

   114

   115

    // send using line_proto

   116

    // XXX: ignore output-buffering

   117

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

   118

}

   119

   120

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

   121

{

   122

    // NICK <nickname>

   123

    struct irc_line line = {

   124

        NULL, "NICK", { nickname, NULL }

   125

    };

   126

   127

    return irc_conn_send(conn, &line);

   128

}

   129

   130

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

   131

{

   132

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

   133

    struct irc_line line = {

   134

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

   135

    };

   136

   137

    return irc_conn_send(conn, &line);

   138

}

   139

   140

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

   141

{

   142

    // PONG <server> [ <server2> ]

   143

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

   144

    struct irc_line line = {

   145

        NULL, "PONG", { target, NULL }

   146

    };

   147

   148

    return irc_conn_send(conn, &line);

   149

}

   150