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

 * Invoke the named irc_chan_callbacks field with the given args

    16

 */

    17

#define IRC_CHAN_INVOKE_CALLBACK(chan, _cb_name_, ...)          \

    18

    do {                                                        \

    19

        struct chain_head *head;                                \

    20

                                                                \

    21

        CHAIN_FOREACH(&(chan)->callbacks, head) {               \

    22

            const struct irc_chan_callbacks *callbacks = head->chain;       \

    23

                                                                \

    24

            if (callbacks->_cb_name_)                           \

    25

                callbacks->_cb_name_((chan), ## __VA_ARGS__, head->arg);    \

    26

        }                                                       \

    27

    } while (0);

    28

    29

/**

    30

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

    31

 *

    32

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

    33

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

    34

 */

    35

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

    36

{

    37

    struct irc_user *user;

    38

    struct irc_chan_user *chan_user;

    39

    err_t err;

    40

    41

    // skip if already listed

    42

    if (irc_chan_get_user(chan, nickname))

    43

        return SUCCESS;

    44

    45

    // lookup/create the irc_user state, incrementing the refcount

    46

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

    47

        return err;

    48

    49

    // alloc the new irc_chan_user

    50

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

    51

        // XXX: release irc_user

    52

        return ERR_CALLOC;

    53

    }

    54

    55

    // store

    56

    chan_user->user = user;

    57

    58

    // add to users list

    59

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

    60

    61

    // ok

    62

    return SUCCESS;

    63

}

    64

    65

/**

    66

 * Remove an irc_chan_user previously added by irc_chan_add_user().

    67

 */

    68

static void irc_chan_remove_user (struct irc_chan *chan, struct irc_chan_user *chan_user)

    69

{

    70

    // put the irc_user reference back, decrementing refcount

    71

    irc_net_put_user(chan->net, chan_user->user);

    72

    73

    // remove from list

    74

    LIST_REMOVE(chan_user, chan_users);

    75

    76

    // free

    77

    free(chan_user);

    78

}

    79

    80

/**

    81

 * :nm JOIN <channel>

    82

 */ 

    83

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

    84

{

    85

    struct irc_chan *chan = arg;

    86

    err_t err;

    87

    88

    // us?

    89

    if (irc_cmp_nick(line->source->nickname, chan->net->conn->nickname) == 0) {

    90

        // twiddle state

    91

        chan->joining = false;

    92

        chan->joined = true;

    93

    94

        // invoke callback

    95

        IRC_CHAN_INVOKE_CALLBACK(chan, on_self_join);

    96

    97

    } else {

    98

        // add them

    99

        if ((err = irc_chan_add_user(chan, line->source->nickname)))

   100

            return log_warn("irc_chan_add_user(%s, %s): %s", irc_chan_name(chan), line->source->nickname, error_name(err));

   101

   102

        // invoke callback (source)

   103

        IRC_CHAN_INVOKE_CALLBACK(chan, on_join, line->source);

   104

    }

   105

}

   106

   107

/**

   108

 * :nm PRIVMSG <channel> <message>

   109

 */

   110

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

   111

{

   112

    struct irc_chan *chan = arg;

   113

   114

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

   115

   116

    // invoke callback (source, message)

   117

    IRC_CHAN_INVOKE_CALLBACK(chan, on_msg, line->source, msg);

   118

}

   119

   120

/**

   121

 * Add/update nicknames to users list using irc_chan_add_user

   122

 *

   123

 * @see IRC_RPL_NAMREPLY

   124

 */

   125

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

   126

{

   127

    struct irc_chan *chan = arg;

   128

    char chanflags[IRC_CHANFLAGS_MAX];

   129

    const char *nickname;

   130

    err_t err;

   131

   132

    // the args

   133

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

   134

   135

    // copy the nicklist to a mutable buffer

   136

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

   137

    strcpy(names, arg_names);

   138

   139

    // iterate over each name

   140

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

   141

        // skip empty token at end

   142

        if (strlen(nickname) == 0)

   143

            continue;

   144

   145

        // parse off the channel flags

   146

        nickname = irc_nick_chanflags(nickname, chanflags);

   147

   148

        // add/update

   149

        // XXX: do something with chanflags

   150

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

   151

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

   152

    }

   153

}

   154

   155

/**

   156

 * Channel join sequence complete

   157

 *

   158

 * @see IRC_RPL_ENDOFNAMES

   159

 */

   160

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

   161

{

   162

    struct irc_chan *chan = arg;

   163

   166

    // XXX: update state

   167

    log_info("channel join sync complete");

   168

}

   169

   170

/**

   171

 * Someone, or us ourselves, left a channel

   172

 *

   173

 * :nm PART <channel> [<message>]

   174

 */

   175

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

   176

{

   177

    struct irc_chan *chan = arg;

   178

   179

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

   180

   181

    // us?

   182

    if (irc_cmp_nick(line->source->nickname, chan->net->conn->nickname) == 0) {

   183

        // twiddle state

   184

        chan->joined = false;

   185

        chan->parted = true;

   186

   187

        // invoke callback

   188

        IRC_CHAN_INVOKE_CALLBACK(chan, on_self_part);

   189

   190

        // XXX: cleanup

   191

   192

    } else {

   193

        // someone else

   194

        struct irc_chan_user *chan_user;

   195

   196

        // invoke callback (source, msg)

   197

        IRC_CHAN_INVOKE_CALLBACK(chan, on_part, line->source, msg);

   198

   199

        // look up the irc_chan_user

   200

        if ((chan_user = irc_chan_get_user(chan, line->source->nickname)) == NULL)

   201

            return log_warn("PART'd user not on channel: %s, %s", irc_chan_name(chan), line->source->nickname);

   202

   203

        // remove them

   204

        irc_chan_remove_user(chan, chan_user);

   205

    }

   206

}

   207

   208

/**

   209

 * :nm KICK <channel> <target> [<reason>]

   210

 *

   211

 * User kicked some other user, might be us

   212

 */

   213

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

   214

{

   215

    struct irc_chan *chan = arg;

   216

    struct irc_chan_user *target_user;

   217

   218

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

   219

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

   220

   221

    // us?

   222

    if (irc_cmp_nick(target, chan->net->conn->nickname) == 0) {

   223

        // twiddle state

   224

        chan->joined = false;

   225

        chan->kicked = true;

   226

   227

        // invoke callback (source, msg)

   228

        IRC_CHAN_INVOKE_CALLBACK(chan, on_self_kicked, line->source, msg);

   229

   230

        // XXX: cleanup

   231

   232

    } else {

   233

        // look up the target irc_chan_user

   234

        if ((target_user = irc_chan_get_user(chan, target)) == NULL)

   235

            return log_warn("KICK'd user not on channel: %s, %s", irc_chan_name(chan), target);

   236

   237

        // invoke callback (source, target_user, msg)

   238

        IRC_CHAN_INVOKE_CALLBACK(chan, on_kick, line->source, target_user, msg);

   239

   240

        // remove them

   241

        irc_chan_remove_user(chan, target_user);

   242

    }

   243

}

   244

   245

/**

   246

 * :nm QUIT [<message>]

   247

 *

   248

 * User quit, so remove them from our users list

   249

 */

   250

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

   251

{

   252

    struct irc_chan *chan = arg;

   253

    struct irc_chan_user *chan_user;

   254

   255

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

   256

   257

    // invoke callback (source, msg)

   258

    IRC_CHAN_INVOKE_CALLBACK(chan, on_quit, line->source, msg);

   259

   260

    // look up the irc_chan_user

   261

    if ((chan_user = irc_chan_get_user(chan, line->source->nickname)) == NULL)

   262

        return log_warn("QUIT'd user not on channel: %s, %s", irc_chan_name(chan), line->source->nickname);

   263

   264

    // remove them

   265

    irc_chan_remove_user(chan, chan_user);

   266

}

   267

   268

/**

   269

 * Core command handlers

   270

 */

   271

struct irc_cmd_handler _cmd_handlers[] = {

   272

    {   "JOIN",             &irc_chan_on_JOIN           },

   273

    {   IRC_RPL_NAMREPLY,   &irc_chan_on_RPL_NAMREPLY   },

   274

    {   IRC_RPL_ENDOFNAMES, &irc_chan_on_RPL_ENDOFNAMES },

   275

    {   "PRIVMSG",          &irc_chan_on_PRIVMSG        },

   276

    {   "PART",             &irc_chan_on_PART           },

   277

    {   "KICK",             &irc_chan_on_KICK           },

   278

    {   "QUIT",             &irc_chan_on_QUIT           },

   279

    {   NULL,       NULL                                }

   280

};

   281

   282

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

   283

{

   284

    struct irc_chan *chan;

   285

   286

    // allocate

   287

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

   288

        return SET_ERROR(err, ERR_CALLOC);

   289

   290

    // store

   291

    chan->net = net;

   292

    chan->info = *info;

   293

   294

    // init

   295

    LIST_INIT(&chan->users);

   296

    irc_cmd_init(&chan->handlers);

   297

    CHAIN_INIT(&chan->callbacks);

   298

   299

    // add handlers

   300

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

   301

        goto error;

   302

   303

    // ok

   304

    *chan_ptr = chan;

   305

   306

    return SUCCESS;

   307

   308

error:

   309

    // cleanup

   310

    irc_chan_destroy(chan);

   311

   312

    return ERROR_CODE(err);

   313

}

   314

   315

void irc_chan_destroy (struct irc_chan *chan)

   316

{

   317

    struct irc_chan_user *chan_user;

   318

   319

    // free users

   320

    while ((chan_user = LIST_FIRST(&chan->users))) {

   321

        irc_chan_remove_user(chan, chan_user);

   322

    }

   323

   324

    // free command handlers

   325

    irc_cmd_free(&chan->handlers);

   326

   327

    // free callbacks

   328

    chain_free(&chan->callbacks);

   329

   330

    // free chan itself

   331

    free(chan);

   332

}

   333

   334

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

   335

{

   336

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

   337

}

   338

   339

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

   340

{

   341

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

   342

}

   343

   344

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

   345

{

   346

    struct irc_chan_user *chan_user = NULL;

   347

   348

    // look for it...

   349

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

   350

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

   351

            // found

   352

            return chan_user;

   353

        }

   354

    }

   355

   356

    // not found

   357

    return NULL;

   358

}

   359

   360

err_t irc_chan_join (struct irc_chan *chan)

   361

{

   362

    err_t err;

   367

   370

   371

    // send JOIN message on the appropriate connection

   372

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

   373

        // XXX: error state?

   374

        return err;

   375

   376

    // ok

   377

    chan->joining = true;

   378

   379

    return SUCCESS;

   380

}

   381