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 ? chan->info.channel : "NULL";

    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 irc_chan_callback_item *item;                    \

    20

                                                                \

    21

        CHAIN_FOREACH_SAFE(&(chan)->callbacks, item) {          \

    22

            if (item->callbacks->_cb_name_)                     \

    23

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

    24

        }                                                       \

    25

    } while (0)

    26

    27

/**

    28

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

    29

 *

    30

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

    31

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

    32

 */

    33

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

    34

{

    35

    struct irc_user *user;

    36

    struct irc_chan_user *chan_user;

    37

    err_t err;

    38

    39

    // skip if already listed

    40

    if (irc_chan_get_user(chan, nickname))

    41

        return SUCCESS;

    42

    43

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

    44

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

    45

        return err;

    46

    47

    // alloc the new irc_chan_user

    48

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

    49

        // XXX: release irc_user

    50

        return ERR_CALLOC;

    51

    }

    52

    53

    // store

    54

    chan_user->user = user;

    55

    56

    // add to users list

    57

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

    58

    59

    // ok

    60

    return SUCCESS;

    61

}

    62

    63

/**

    64

 * Remove an irc_chan_user previously added by irc_chan_add_user().

    65

 */

    66

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

    67

{

    68

    // put the irc_user reference back, decrementing refcount

    69

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

    70

    71

    // remove from list

    72

    LIST_REMOVE(chan_user, chan_users);

    73

    74

    // free

    75

    free(chan_user);

    76

}

    77

    78

/**

    79

 * :nm JOIN <channel>

    80

 */ 

    81

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

    82

{

    83

    struct irc_chan *chan = arg;

    84

    err_t err;

    85

    86

    if (irc_conn_self(chan->net->conn, line->source->nickname)) {

    87

        // twiddle state

    88

        chan->joining = false;

    89

        chan->joined = true;

    90

    91

        // invoke callback

    92

        IRC_CHAN_INVOKE_CALLBACK(chan, on_self_join);

    93

    94

    } else {

    95

        // add them

    96

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

    97

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

    98

    99

        // invoke callback (source)

   100

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

   101

    }

   102

}

   103

   104

/**

   105

 * :nm PRIVMSG <channel> <message>

   106

 */

   107

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

   108

{

   109

    struct irc_chan *chan = arg;

   110

   111

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

   112

   113

    // invoke callback (source, message)

   114

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

   115

}

   116

   117

/**

   118

 * Add/update nicknames to users list using irc_chan_add_user

   119

 *

   120

 * @see IRC_RPL_NAMREPLY

   121

 */

   122

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

   123

{

   124

    struct irc_chan *chan = arg;

   125

    char chanflags[IRC_CHANFLAGS_MAX];

   126

    const char *nickname;

   127

    err_t err;

   128

   129

    // the args

   130

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

   131

   132

    // copy the nicklist to a mutable buffer

   133

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

   134

    strcpy(names, arg_names);

   135

   136

    // iterate over each name

   137

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

   138

        // skip empty token at end

   139

        if (strlen(nickname) == 0)

   140

            continue;

   141

   142

        // parse off the channel flags

   143

        nickname = irc_nick_chanflags(nickname, chanflags);

   144

   145

        // add/update

   146

        // XXX: do something with chanflags

   147

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

   148

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

   149

    }

   150

}

   151

   152

/**

   153

 * Channel join sequence complete

   154

 *

   155

 * @see IRC_RPL_ENDOFNAMES

   156

 */

   157

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

   158

{

   159

    struct irc_chan *chan = arg;

   160

   161

    (void) line;

   162

    (void) chan;

   163

   164

    // XXX: update state

   165

    log_info("channel join sync complete");

   166

}

   167

   168

/**

   169

 * Someone, or us ourselves, left a channel

   170

 *

   171

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

   172

 */

   173

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

   174

{

   175

    struct irc_chan *chan = arg;

   176

   177

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

   178

   179

    if (irc_conn_self(chan->net->conn, line->source->nickname)) {

   180

        // twiddle state

   181

        chan->joined = false;

   182

        chan->parted = true;

   183

   184

        // invoke callback

   185

        IRC_CHAN_INVOKE_CALLBACK(chan, on_self_part);

   186

   187

        // XXX: cleanup

   188

   189

    } else {

   190

        // someone else

   191

        struct irc_chan_user *chan_user;

   192

   193

        // invoke callback (source, msg)

   194

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

   195

   196

        // look up the irc_chan_user

   197

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

   198

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

   199

   200

        // remove them

   201

        irc_chan_remove_user(chan, chan_user);

   202

    }

   203

}

   204

   205

/**

   206

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

   207

 *

   208

 * User kicked some other user, might be us

   209

 */

   210

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

   211

{

   212

    struct irc_chan *chan = arg;

   213

    struct irc_chan_user *target_user;

   214

   215

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

   216

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

   217

   218

    if (irc_conn_self(chan->net->conn, target)) {

   219

        // twiddle state

   220

        chan->joined = false;

   221

        chan->kicked = true;

   222

   223

        // invoke callback (source, msg)

   224

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

   225

   226

        // XXX: cleanup

   227

   228

    } else {

   229

        // look up the target irc_chan_user

   230

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

   231

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

   232

   233

        // invoke callback (source, target_user, msg)

   234

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

   235

   236

        // remove them

   237

        irc_chan_remove_user(chan, target_user);

   238

    }

   239

}

   240

   241

/**

   242

 * :nm QUIT [<message>]

   243

 *

   244

 * User quit, so remove them from our users list

   245

 */

   246

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

   247

{

   248

    struct irc_chan *chan = arg;

   249

    struct irc_chan_user *chan_user;

   250

   251

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

   252

   253

    // invoke callback (source, msg)

   254

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

   255

   256

    // look up the irc_chan_user

   257

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

   258

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

   259

   260

    // remove them

   261

    irc_chan_remove_user(chan, chan_user);

   262

}

   263

   264

/**

   265

 * Core command handlers

   266

 */

   267

struct irc_cmd_handler _cmd_handlers[] = {

   268

    {   "JOIN",             &irc_chan_on_JOIN           },

   269

    {   IRC_RPL_NAMREPLY,   &irc_chan_on_RPL_NAMREPLY   },

   270

    {   IRC_RPL_ENDOFNAMES, &irc_chan_on_RPL_ENDOFNAMES },

   271

    {   "PRIVMSG",          &irc_chan_on_PRIVMSG        },

   272

    {   "PART",             &irc_chan_on_PART           },

   273

    {   "KICK",             &irc_chan_on_KICK           },

   274

    {   "QUIT",             &irc_chan_on_QUIT           },

   275

    {   NULL,       NULL                                }

   276

};

   277

   279

{

   280

    struct irc_chan *chan;

   281

   282

    // allocate

   283

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

   284

        return SET_ERROR(err, ERR_CALLOC);

   285

   286

    // store

   287

    chan->net = net;

   288

   289

    // copy info

   290

    if ((chan->info.channel = strdup(info->channel)) == NULL)

   291

        JUMP_SET_ERROR(err, ERR_STRDUP);

   292

   293

    // init

   294

    LIST_INIT(&chan->users);

   295

    irc_cmd_init(&chan->handlers);

   296

    CHAIN_INIT(&chan->callbacks);

   297

   298

    // add handlers

   299

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

   300

        goto error;

   301

   302

    // ok

   303

    *chan_ptr = chan;

   304

   305

    return SUCCESS;

   306

   307

error:

   308

    // cleanup

   309

    irc_chan_destroy(chan);

   310

   311

    return ERROR_CODE(err);

   312

}

   313

   314

void irc_chan_destroy (struct irc_chan *chan)

   315

{

   316

    struct irc_chan_user *chan_user;

   317

   318

    // free users

   319

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

   320

        irc_chan_remove_user(chan, chan_user);

   321

    }

   322

   323

    // free chan itself

   324

    irc_cmd_clear(&chan->handlers);

   325

    CHAIN_CLEAR(&chan->callbacks);

   326

    free((char *) chan->info.channel);

   327

    free(chan);

   328

}

   329

   330

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

   331

{

   332

    struct irc_chan_callback_item *item;

   333

   334

    // create a new item

   335

    if ((item = CHAIN_ADD_TAIL(&chan->callbacks)) == NULL)

   336

        return ERR_MEM;

   337

   338

    // store

   339

    item->callbacks = callbacks;

   340

    item->arg = arg;

   341

   342

    // ok

   343

    return SUCCESS;

   344

}

   345

   346

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

   347

{

   348

    struct irc_chan_callback_item *item;

   349

   350

    // remove all matching callback_items

   351

    CHAIN_DELETE_WHICH(&chan->callbacks, item, item->callbacks == callbacks && item->arg == arg);

   352

}

   353

   354

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

   355

{

   356

    struct irc_chan_user *chan_user = NULL;

   357

   358

    // look for it...

   359

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

   360

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

   361

            // found

   362

            return chan_user;

   363

        }

   364

    }

   365

   366

    // not found

   367

    return NULL;

   368

}

   369

   370

err_t irc_chan_join (struct irc_chan *chan)

   371

{

   372

    err_t err;

   373

   374

    // correct state 

   375

    if (chan->joining || chan->joined)

   376

        return ERR_IRC_CHAN_STATE;

   377

   378

    if (!chan->net->conn)

   379

        return ERR_IRC_NET_STATE;

   380

   381

    // send JOIN message on the appropriate connection

   382

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

   383

        // XXX: error state?

   384

        return err;

   385

   386

    // ok

   387

    chan->joining = true;

   388

   389

    return SUCCESS;

   390

}

   391

   392

err_t irc_chan_PRIVMSG (struct irc_chan *chan, const char *message)

   393

{

   394

    err_t err;

   395

   396

    // correct state 

   397

    if (!chan->joined)

   398

        return ERR_IRC_CHAN_STATE;

   399

   400

    if (!chan->net->conn)

   401

        return ERR_IRC_NET_STATE;

   402

   403

    // send the PRIVMSG message

   404

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

   405

        return err;

   406

   407

    // invoke callback (msg)

   408

    IRC_CHAN_INVOKE_CALLBACK(chan, on_self_msg, message);

   409

   410

    // ok

   411

    return SUCCESS;

   412

}

   413

   414

err_t irc_chan_NOTICE (struct irc_chan *chan, const char *message)

   415

{

   416

    err_t err;

   417

   418

    // correct state 

   419

    if (!chan->joined)

   420

        return ERR_IRC_CHAN_STATE;

   421

   422

    if (!chan->net->conn)

   423

        return ERR_IRC_NET_STATE;

   424

   425

    // send the PRIVMSG message

   426

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

   427

        return err;

   428

   429

    // invoke callback (msg)

   430

    IRC_CHAN_INVOKE_CALLBACK(chan, on_self_notice, message);

   431

   432

    // ok

   433

    return SUCCESS;

   434

}

   435