1

     2

#include "irc_conn.h"

     4

     5

#include <stdlib.h>

     6

#include <string.h>

     7

     8

/*

    18

 * PING <server1> [ <server2> ]

    19

 *

    20

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

    21

 */ 

    22

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

    23

{

    24

    // just reply

    25

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

    26

}

    27

    28

/*

    29

 * Our command handlers

    30

 */

    31

struct irc_cmd_handler {

    32

    /* The command name */

    33

    const char *command;

    34

    35

    /* The handler function */

    36

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

    37

    38

} _cmd_handlers[] = {

    40

    { "PING",           on_PING             },

    41

    { NULL,             NULL,               },

    42

};

    43

    44

void irc_conn_on_line (char *line_buf, void *arg) 

    45

{

    46

    struct irc_conn *conn = arg;

    47

    struct irc_line line;

    48

    struct irc_cmd_handler *handler;

    49

    int err;

    50

    51

    // log

    52

    printf("<<< %s\n", line_buf);

    53

    54

    // parse

    55

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

    56

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

    57

    58

        return;

    59

    }

    60

    61

    // look up appropriate handler

    62

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

    63

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

    64

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

    65

            // invoke the func

    66

            handler->func(conn, &line);

    67

            break;

    68

        }

    69

    }

    70

}

    71

    72

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

    73

{

    74

    struct irc_conn *conn;

    75

    76

    // alloc new state struct

    77

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

    78

        return SET_ERROR(err, ERR_CALLOC);

    79

    80

    // create the line_proto, with our on_line handler

    81

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

    82

        return ERROR_CODE(err);

    83

    84

    // send the initial messages

    85

    if (

    86

            irc_conn_NICK(conn, config->nickname)

    87

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

    88

    )

    89

        return ERROR_CODE(err);

    90

    91

    // ok

    92

    *conn_ptr = conn;

    93

    94

    return SUCCESS;

    95

}

    96

    97

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

    98

{

    99

    char line_buf[IRC_LINE_MAX + 2];

   100

    err_t err;

   101

   102

    // format

   103

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

   104

        return err;

   105

   106

    // log

   107

    printf(">>> %s\n", line_buf);

   108

   109

    // add CRLF

   110

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

   111

   112

    // send using line_proto

   113

    // XXX: ignore output-buffering

   114

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

   115

}

   116

   117

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

   118

{

   119

    // NICK <nickname>

   120

    struct irc_line line = {

   121

        NULL, "NICK", { nickname, NULL }

   122

    };

   123

   124

    return irc_conn_send(conn, &line);

   125

}

   126

   127

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

   128

{

   129

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

   130

    struct irc_line line = {

   131

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

   132

    };

   133

   134

    return irc_conn_send(conn, &line);

   135

}

   136

   137

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

   138

{

   139

    // PONG <server> [ <server2> ]

   140

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

   141

    struct irc_line line = {

   142

        NULL, "PONG", { target, NULL }

   143

    };

   144

   145

    return irc_conn_send(conn, &line);

   146

}

   147