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

    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

/**

    66

 * :nm JOIN <channel>

    67

 */ 

    68

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

    69

{

    70

    struct irc_chan *chan = arg;

    71

    err_t err;

    72

    73

    // us?

    74

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

    75

        // twiddle state

    76

        chan->joining = false;

    77

        chan->joined = true;

    78

    79

        // invoke callback

    80

        IRC_CHAN_INVOKE_CALLBACK(chan, on_self_join);

    81

    82

    } else {

    83

        char prefix_buf[IRC_PREFIX_MAX];

    84

        struct irc_nm nm;

    85

    86

        // parse the nickname

    87

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

    88

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

    89

    90

        // add them

    91

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

    92

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

    93

    94

        // invoke callback (source)

    95

        IRC_CHAN_INVOKE_CALLBACK(chan, on_join, &nm);

    96

    }

    97

}

    98

    99

/**

   143

 * :nm PRIVMSG <channel> <message>

   144

 */

   145

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

   146

{

   147

    struct irc_chan *chan = arg;

   148

    char prefix_buf[IRC_PREFIX_MAX];

   149

    struct irc_nm nm;

   150

    err_t err;

   151

   152

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

   153

   154

    // parse nickmask

   155

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

   156

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

   157

   158

        // invoke callback with NULL source

   159

        IRC_CHAN_INVOKE_CALLBACK(chan, on_msg, NULL, msg);

   160

   161

    } else {

   162

        // invoke callback (source, message)

   163

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

   164

    }

   165

}

   166

   167

/**

   168

 * Add/update nicknames to users list using irc_chan_add_user

   169

 *

   170

 * @see IRC_RPL_NAMREPLY

   171

 */

   172

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

   173

{

   174

    struct irc_chan *chan = arg;

   175

    char chanflags[IRC_CHANFLAGS_MAX];

   176

    const char *nickname;

   177

    err_t err;

   178

   179

    // the args

   180

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

   181

   182

    // copy the nicklist to a mutable buffer

   183

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

   184

    strcpy(names, arg_names);

   185

   186

    // iterate over each name

   187

    // XXX: nickflags

   188

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

   189

        // parse off the channel flags

   190

        nickname = irc_nick_chanflags(nickname, chanflags);

   191

   192

        // add/update

   193

        // XXX: do something with chanflags

   194

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

   195

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

   196

    }

   197

}

   198

   199

/**

   200

 * Channel join sequence complete

   201

 *

   202

 * @see IRC_RPL_ENDOFNAMES

   203

 */

   204

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

   205

{

   206

    struct irc_chan *chan = arg;

   207

   208

    // XXX: update state

   209

    log_info("channel join sync complete");

   210

}

   211

   212

/**

   213

 * Core command handlers

   214

 */

   215

struct irc_cmd_handler _cmd_handlers[] = {

   216

    {   "JOIN",             &irc_chan_on_JOIN           },

   218

    {   "PRIVMSG",          &irc_chan_on_PRIVMSG        },

   219

    {   IRC_RPL_NAMREPLY,   &irc_chan_on_RPL_NAMREPLY   },

   220

    {   IRC_RPL_ENDOFNAMES, &irc_chan_on_RPL_ENDOFNAMES },

   221

    {   NULL,       NULL                                }

   222

};

   223

   224

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

   225

{

   226

    struct irc_chan *chan;

   227

   228

    // allocate

   229

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

   230

        return SET_ERROR(err, ERR_CALLOC);

   231

   232

    // store

   233

    chan->net = net;

   234

    chan->info = *info;

   235

   236

    // init

   237

    LIST_INIT(&chan->users);

   238

    irc_cmd_init(&chan->handlers);

   239

    CHAIN_INIT(&chan->callbacks);

   240

   241

    // add handlers

   242

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

   243

        goto error;

   244

   245

    // ok

   246

    *chan_ptr = chan;

   247

   248

    return SUCCESS;

   249

   250

error:

   251

    // cleanup

   252

    irc_chan_destroy(chan);

   253

   254

    return ERROR_CODE(err);

   255

}

   256

   257

void irc_chan_destroy (struct irc_chan *chan)

   258

{

   265

   266

    // free command handlers

   267

    irc_cmd_free(&chan->handlers);

   268

   269

    // free callbacks

   270

    chain_free(&chan->callbacks);

   271

   272

    // free chan itself

   273

    free(chan);

   274

}

   275

   276

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

   277

{

   278

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

   279

}

   280

   281

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

   282

{

   283

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

   284

}

   285

   286

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

   287

{

   288

    struct irc_chan_user *chan_user = NULL;

   289

   290

    // look for it...

   291

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

   292

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

   293

            // found

   294

            return chan_user;

   295

        }

   296

    }

   297

   298

    // not found

   299

    return NULL;

   300

}

   301

   302

err_t irc_chan_join (struct irc_chan *chan)

   303

{

   304

    err_t err;

   305

   306

    // XXX: error instead?

   307

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

   308

    assert(chan->net->conn);

   309

   310

    // send JOIN message on the appropriate connection

   311

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

   312

        // XXX: error state?

   313

        return err;

   314

   315

    // ok

   316

    chan->joining = true;

   317

   318

    return SUCCESS;

   319

}

   320