1

#include "irc_chan.h"

     2

#include "irc_proto.h"

     3

#include "log.h"

     4

     5

#include <stdlib.h>

     6

#include <string.h>

     7

#include <assert.h>

     8

     9

const char* irc_chan_name (struct irc_chan *chan)

    10

{

    11

    return chan->info.channel;

    12

}

    13

    14

/**

    15

 * Add or update a nickname to the irc_chan.users list.

    16

 *

    17

 * If the given nickname already exists in our users list, this does nothing. Otherwise, an irc_user is aquired using

    18

 * irc_net_get_user, and a new irc_chan_user struct added to our users list.

    19

 */

    20

static err_t irc_chan_add_user (struct irc_chan *chan, const char *nickname)

    21

{

    22

    struct irc_user *user;

    23

    struct irc_chan_user *chan_user;

    24

    err_t err;

    25

    26

    // skip if already listed

    27

    if (irc_chan_get_user(chan, nickname))

    28

        return SUCCESS;

    29

    30

    // lookup/create the irc_user state

    31

    if ((err = irc_net_get_user(chan->net, &user, nickname)))

    32

        return err;

    33

    34

    // alloc the new irc_chan_user

    35

    if ((chan_user = calloc(1, sizeof(*chan_user))) == NULL) {

    36

        // XXX: release irc_user

    37

        return ERR_CALLOC;

    38

    }

    39

    40

    // store

    41

    chan_user->user = user;

    42

    43

    // add to users list

    44

    LIST_INSERT_HEAD(&chan->users, chan_user, chan_users);

    45

    46

    // ok

    47

    return SUCCESS;

    48

}

    49

    50

/**

    51

 * :nm JOIN <channel>

    52

 */ 

    53

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

    54

{

    55

    struct irc_chan *chan = arg;

    56

    err_t err;

    57

    58

    // us?

    59

    if (irc_prefix_cmp_nick(line->prefix, chan->net->conn->nickname) == 0) {

    60

        // twiddle state

    61

        chan->joining = false;

    62

        chan->joined = true;

    63

    64

        // invoke callback

    65

        IRC_CHAN_INVOKE_CALLBACK(chan, on_self_join);

    66

    67

    } else {

    68

        char prefix_buf[IRC_PREFIX_MAX];

    69

        struct irc_nm nm;

    70

    71

        // parse the nickname

    72

        if ((err = irc_nm_parse(&nm, prefix_buf, line->prefix)))

    73

            return log_warn("invalid prefix: %s", line->prefix);

    74

    75

        // add them

    76

        if ((err = irc_chan_add_user(chan, nm.nickname)))

    77

            return log_warn("irc_chan_add_user(%s, %s): %s", irc_chan_name(chan), nm.nickname, error_name(err));

    78

    79

        // invoke callback (source)

    80

        IRC_CHAN_INVOKE_CALLBACK(chan, on_join, &nm);

    81

    }

    82

}

    83

    84

/**

    85

 * :nm PRIVMSG <channel> <message>

    86

 */

    87

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

    88

{

    89

    struct irc_chan *chan = arg;

    90

    char prefix_buf[IRC_PREFIX_MAX];

    91

    struct irc_nm nm;

    92

    err_t err;

    93

    94

    const char *msg = line->args[1];

    95

    96

    // parse nickmask

    97

    if ((err = irc_nm_parse(&nm, prefix_buf, line->prefix))) {

    98

        log_warn("invalid prefix: %s", line->prefix);

    99

   100

        // invoke callback with NULL source

   101

        IRC_CHAN_INVOKE_CALLBACK(chan, on_msg, NULL, msg);

   102

   103

    } else {

   104

        // invoke callback (source, message)

   105

        IRC_CHAN_INVOKE_CALLBACK(chan, on_msg, &nm, msg);

   106

    }

   107

}

   108

   109

/**

   110

 * Add/update nicknames to users list using irc_chan_add_user

   111

 *

   112

 * @see IRC_RPL_NAMREPLY

   113

 */

   114

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

   115

{

   116

    struct irc_chan *chan = arg;

   117

    char chanflags[IRC_CHANFLAGS_MAX];

   118

    const char *nickname;

   119

    err_t err;

   120

   121

    // the args

   122

    const char *arg_names = line->args[3];

   123

   124

    // copy the nicklist to a mutable buffer

   125

    char names_buf[strlen(arg_names) + 1], *names = names_buf;

   126

    strcpy(names, arg_names);

   127

   128

    // iterate over each name

   129

    // XXX: nickflags

   130

    while ((nickname = strsep(&names, " "))) {

   131

        // parse off the channel flags

   132

        nickname = irc_nick_chanflags(nickname, chanflags);

   133

   134

        // add/update

   135

        // XXX: do something with chanflags

   136

        if ((err = irc_chan_add_user(chan, nickname)))

   137

            log_warn("irc_chan_add_user(%s, %s): %s", irc_chan_name(chan), nickname, error_name(err));

   138

    }

   139

}

   140

   141

/**

   142

 * Channel join sequence complete

   143

 *

   144

 * @see IRC_RPL_ENDOFNAMES

   145

 */

   146

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

   147

{

   148

    struct irc_chan *chan = arg;

   149

   150

    // XXX: update state

   151

    log_info("channel join sync complete");

   152

}

   153

   154

/**

   155

 * Core command handlers

   156

 */

   157

struct irc_cmd_handler _cmd_handlers[] = {

   158

    {   "JOIN",             &irc_chan_on_JOIN           },

   159

    {   "PRIVMSG",          &irc_chan_on_PRIVMSG        },

   160

    {   IRC_RPL_NAMREPLY,   &irc_chan_on_RPL_NAMREPLY   },

   161

    {   IRC_RPL_ENDOFNAMES, &irc_chan_on_RPL_ENDOFNAMES },

   162

    {   NULL,       NULL                                }

   163

};

   164

   165

err_t irc_chan_create (struct irc_chan **chan_ptr, struct irc_net *net, const struct irc_chan_info *info, struct error_info *err)

   166

{

   167

    struct irc_chan *chan;

   168

   169

    // allocate

   170

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

   171

        return SET_ERROR(err, ERR_CALLOC);

   172

   173

    // store

   174

    chan->net = net;

   175

    chan->info = *info;

   176

   177

    // init

   178

    LIST_INIT(&chan->users);

   179

    irc_cmd_init(&chan->handlers);

   180

    CHAIN_INIT(&chan->callbacks);

   181

   182

    // add handlers

   183

    if ((ERROR_CODE(err) = irc_cmd_add(&chan->handlers, _cmd_handlers, chan)))

   184

        goto error;

   185

   186

    // ok

   187

    *chan_ptr = chan;

   188

   189

    return SUCCESS;

   190

   191

error:

   192

    // cleanup

   193

    irc_chan_destroy(chan);

   194

   195

    return ERROR_CODE(err);

   196

}

   197

   198

void irc_chan_destroy (struct irc_chan *chan)

   199

{

   200

    // XXX: free chan_users list

   201

   202

    // free command handlers

   203

    irc_cmd_free(&chan->handlers);

   204

   205

    // free callbacks

   206

    chain_free(&chan->callbacks);

   207

   208

    // free chan itself

   209

    free(chan);

   210

}

   211

   212

err_t irc_chan_add_callbacks (struct irc_chan *chan, const struct irc_chan_callbacks *callbacks, void *arg)

   213

{

   214

    return chain_add(&chan->callbacks, callbacks, arg);

   215

}

   216

   217

void irc_chan_remove_callbacks (struct irc_chan *chan, const struct irc_chan_callbacks *callbacks, void *arg)

   218

{

   219

    chain_remove(&chan->callbacks, callbacks, arg);

   220

}

   221

   222

struct irc_chan_user* irc_chan_get_user (struct irc_chan *chan, const char *nickname)

   223

{

   224

    struct irc_chan_user *chan_user = NULL;

   225

   226

    // look for it...

   227

    LIST_FOREACH(chan_user, &chan->users, chan_users) {

   228

        if (irc_cmp_nick(nickname, chan_user->user->nickname) == 0) {

   229

            // found

   230

            return chan_user;

   231

        }

   232

    }

   233

   234

    // not found

   235

    return NULL;

   236

}

   237

   238

err_t irc_chan_join (struct irc_chan *chan)

   239

{

   240

    err_t err;

   241

   242

    // XXX: error instead?

   243

    assert(!chan->joining && !chan->joined);

   244

    assert(chan->net->conn);

   245

   246

    // send JOIN message on the appropriate connection

   247

    if ((err = irc_conn_JOIN(chan->net->conn, chan->info.channel)))

   248

        // XXX: error state?

   249

        return err;

   250

   251

    // ok

   252

    chan->joining = true;

   253

   254

    return SUCCESS;

   255

}

   256