1

#include "irc_net.h"

     2

#include "log.h"

     3

     4

#include <stdlib.h>

     5

#include <string.h>

     6

     7

static void irc_net_conn_registered (struct irc_conn *conn, void *arg)

     8

{

     9

    struct irc_net *net = arg;

    10

    struct irc_chan *chan = NULL;

    11

    err_t err;

    12

    13

    (void) conn;

    14

    15

    // join our channels

    16

    TAILQ_FOREACH(chan, &net->channels, node) {

    17

        if ((err = irc_chan_join(chan)))

    18

            // XXX: fuck...

    19

            FATAL_ERR(err, "irc_chan_join failed");

    20

    }

    21

}

    22

    37

/**

    38

 * Our irc_conn_callbacks list

    39

 */

    40

struct irc_conn_callbacks _conn_callbacks = {

    41

    .on_registered  = &irc_net_conn_registered,

    43

};

    44

    45

/**

    46

 * Propagate the command to the appropriate irc_chan based on the given name

    47

 */

    48

static void irc_net_propagate_chan (struct irc_net *net, const struct irc_line *line, const char *channel)

    49

{

    50

    struct irc_chan *chan;

    51

    52

    // look up channel

    53

    if ((chan = irc_net_get_chan(net, channel)) == NULL) {

    54

        log_warn("unknown channel: %s", channel);

    55

        return;

    56

    }

    57

    58

    // propagate

    59

    irc_cmd_invoke(&chan->handlers, line);

    60

}

    61

    62

/**

    63

 * Propagate line to irc_chan based on args[0]

    64

 */ 

    65

static void irc_net_on_chan0 (const struct irc_line *line, void *arg)

    66

{

    67

    struct irc_net *net = arg;

    68

    69

    irc_net_propagate_chan(net, line, line->args[0]);

    70

}

    71

    72

/**

    73

 * :nm PRIVMSG <target> <message>

    74

 *

    75

 * Either propagate to channel if found, otherwise handle as a privmsg

    76

 */

    77

static void irc_net_on_PRIVMSG (const struct irc_line *line, void *arg)

    78

{

    79

    struct irc_net *net = arg;

    80

    81

    // XXX: does two lookups

    82

    if (irc_net_get_chan(net, line->args[0])) {

    83

        // short-circuit to on_chan0

    84

        irc_net_on_chan0(line, arg);

    85

    86

    } else {

    87

        // XXX: callbacks for privmsgs

    88

    89

    }

    90

}

    91

    92

/**

    93

 * Our irc_cmd handler list

    94

 */

    95

static struct irc_cmd_handler _cmd_handlers[] = {

    96

    {   "JOIN",     &irc_net_on_chan0       },

    97

    {   "PRIVMSG",  &irc_net_on_PRIVMSG     },

    98

    {   NULL,       NULL                    }

    99

};

   100

   101

err_t irc_net_create (struct irc_net **net_ptr, const struct irc_net_info *info, struct error_info *err)

   102

{

   103

    struct irc_net *net;

   104

    struct sock_stream *sock = NULL;

   105

   106

    // allocate

   107

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

   108

        return SET_ERROR(err, ERR_CALLOC);

   109

   110

    // initialize

   111

    TAILQ_INIT(&net->channels);

   112

   113

    if (info->raw_sock) {

   114

        log_info("connected using raw socket: %p", info->raw_sock);

   115

   116

        sock = info->raw_sock;

   117

   118

    } else if (info->use_ssl) {

   119

        log_info("connecting to [%s]:%s using SSL", info->hostname, info->service);

   120

   121

        // XXX: over-simplified blocking connect

   122

        if (sock_ssl_connect(&sock, info->hostname, info->service, err))

   123

            goto error;

   124

   125

    } else {

   126

        log_info("connecting to [%s]:%s", info->hostname, info->service);

   127

   128

        // XXX: over-simplified blocking connect

   129

        if (sock_tcp_connect(&sock, info->hostname, info->service, err))

   130

            goto error;

   131

   132

    }

   133

   134

    // create the irc connection state

   135

    if (irc_conn_create(&net->conn, sock, &_conn_callbacks, net, err))

   136

        goto error;

   137

   138

    // add our command handlers

   139

    if ((ERROR_CODE(err) = irc_conn_add_cmd_handlers (net->conn, _cmd_handlers, net)))

   140

        goto error;

   141

   142

    // register

   143

    log_info("connected, registering");

   144

   145

    if ((ERROR_CODE(err) = irc_conn_register(net->conn, &info->register_info)))

   146

        goto error;

   147

   148

    // ok

   149

    *net_ptr = net;

   150

   151

    return SUCCESS;

   152

   153

error:

   154

    // cleanup

   155

    if (net->conn)

   156

        // irc_conn takes care of the socket as well

   157

        irc_conn_destroy(net->conn);

   158

   159

    else if (sock)

   160

        // we need to clean up the socket ourself

   161

        sock_stream_release(sock);

   162

   163

    // release our state

   164

    free(net);

   165

   166

    return ERROR_CODE(err);

   167

}

   168

   169

struct irc_chan* irc_net_add_chan (struct irc_net *net, const struct irc_chan_info *info)

   170

{

   171

    struct irc_chan *chan;

   172

    struct error_info err;

   173

   174

    // create the new irc_chan struct

   175

    if (irc_chan_create(&chan, net, info, &err))

   176

        // XXX: we lose error info

   177

        return NULL;

   178

   179

    // add to network list

   180

    TAILQ_INSERT_TAIL(&net->channels, chan, node);

   181

   182

    // currently connected?

   183

    if (net->conn && net->conn->registered) {

   184

        // then join

   185

        if ((ERROR_CODE(&err) = irc_chan_join(chan)))

   186

            // XXX

   187

            return NULL;

   188

    }

   189

   190

    // ok, return

   191

    return chan;

   192

}

   193

   194

struct irc_chan* irc_net_get_chan (struct irc_net *net, const char *channel)

   195

{

   196

    struct irc_chan *chan = NULL;

   197

   198

    // look for it...

   199

    TAILQ_FOREACH(chan, &net->channels, node) {

   200

        if (strcasecmp(chan->info.channel, channel) == 0)

   201

            // found it

   202

            return chan;

   203

    }

   204

   205

    // no such channel

   206

    return NULL;

   207

   208

}

   209