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, incrementing the refcount

    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

 * Remove an irc_chan_user previously added by irc_chan_add_user().

    52

 */

    53

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

    54

{

    55

    // put the irc_user reference back, decrementing refcount

    56

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

    57

    58

    // remove from list

    59

    LIST_REMOVE(chan_user, chan_users);

    60

    61

    // free

    62

    free(chan_user);

    63

}

    64

    65

/**

    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_cmp_nick(line->source->nickname, 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

        // add them

    84

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

    85

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

    86

    87

        // invoke callback (source)

    88

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

    89

    }

    90

}

    91

    92

/**

    93

 * Someone, or us ourselves, left a channel

    94

 *

    95

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

    96

 */

    97

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

    98

{

    99

    struct irc_chan *chan = arg;

   100

   101

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

   102

   103

    // us?

   104

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

   105

        // twiddle state

   106

        chan->joined = false;

   107

        chan->parted = true;

   108

   109

        // invoke callback

   110

        IRC_CHAN_INVOKE_CALLBACK(chan, on_self_part);

   111

   112

    } else {

   113

        // someone else

   114

        struct irc_chan_user *chan_user;

   115

   116

        // invoke callback (source, msg)

   117

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

   118

   119

        // look up the irc_chan_user

   120

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

   121

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

   122

   123

        // remove them

   124

        irc_chan_remove_user(chan, chan_user);

   125

    }

   126

}

   127

   128

/**

   129

 * :nm PRIVMSG <channel> <message>

   130

 */

   131

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

   132

{

   133

    struct irc_chan *chan = arg;

   134

   135

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

   136

   137

    // invoke callback (source, message)

   138

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

   139

}

   140

   141

/**

   142

 * Add/update nicknames to users list using irc_chan_add_user

   143

 *

   144

 * @see IRC_RPL_NAMREPLY

   145

 */

   146

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

   147

{

   148

    struct irc_chan *chan = arg;

   149

    char chanflags[IRC_CHANFLAGS_MAX];

   150

    const char *nickname;

   151

    err_t err;

   152

   153

    // the args

   154

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

   155

   156

    // copy the nicklist to a mutable buffer

   157

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

   158

    strcpy(names, arg_names);

   159

   160

    // iterate over each name

   161

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

   162

        // skip empty token at end

   163

        if (strlen(nickname) == 0)

   164

            continue;

   165

   166

        // parse off the channel flags

   167

        nickname = irc_nick_chanflags(nickname, chanflags);

   168

   169

        // add/update

   170

        // XXX: do something with chanflags

   171

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

   172

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

   173

    }

   174

}

   175

   176

/**

   177

 * Channel join sequence complete

   178

 *

   179

 * @see IRC_RPL_ENDOFNAMES

   180

 */

   181

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

   182

{

   183

    struct irc_chan *chan = arg;

   184

   185

    // XXX: update state

   186

    log_info("channel join sync complete");

   187

}

   188

   189

/**

   190

 * :nm QUIT [<message>]

   191

 *

   192

 * User quit, so remove them from our users list

   193

 */

   194

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

   195

{

   196

    struct irc_chan *chan = arg;

   197

    struct irc_chan_user *chan_user;

   198

   199

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

   200

   201

    // invoke callback (source, msg)

   202

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

   203

   204

    // look up the irc_chan_user

   205

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

   206

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

   207

   208

    // remove them

   209

    irc_chan_remove_user(chan, chan_user);

   210

}

   211

   212

/**

   213

 * Core command handlers

   214

 */

   215

struct irc_cmd_handler _cmd_handlers[] = {

   216

    {   "JOIN",             &irc_chan_on_JOIN           },

   217

    {   IRC_RPL_NAMREPLY,   &irc_chan_on_RPL_NAMREPLY   },

   218

    {   IRC_RPL_ENDOFNAMES, &irc_chan_on_RPL_ENDOFNAMES },

   219

    {   "PRIVMSG",          &irc_chan_on_PRIVMSG        },

   220

    {   "PART",             &irc_chan_on_PART           },

   221

    {   "QUIT",             &irc_chan_on_QUIT           },

   222

    {   NULL,       NULL                                }

   223

};

   224

   225

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

   226

{

   227

    struct irc_chan *chan;

   228

   229

    // allocate

   230

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

   231

        return SET_ERROR(err, ERR_CALLOC);

   232

   233

    // store

   234

    chan->net = net;

   235

    chan->info = *info;

   236

   237

    // init

   238

    LIST_INIT(&chan->users);

   239

    irc_cmd_init(&chan->handlers);

   240

    CHAIN_INIT(&chan->callbacks);

   241

   242

    // add handlers

   243

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

   244

        goto error;

   245

   246

    // ok

   247

    *chan_ptr = chan;

   248

   249

    return SUCCESS;

   250

   251

error:

   252

    // cleanup

   253

    irc_chan_destroy(chan);

   254

   255

    return ERROR_CODE(err);

   256

}

   257

   258

void irc_chan_destroy (struct irc_chan *chan)

   259

{

   260

    struct irc_chan_user *chan_user;

   261

   262

    // free users

   263

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

   264

        irc_chan_remove_user(chan, chan_user);

   265

    }

   266

   267

    // free command handlers

   268

    irc_cmd_free(&chan->handlers);

   269

   270

    // free callbacks

   271

    chain_free(&chan->callbacks);

   272

   273

    // free chan itself

   274

    free(chan);

   275

}

   276

   277

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

   278

{

   279

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

   280

}

   281

   282

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

   283

{

   284

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

   285

}

   286

   287

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

   288

{

   289

    struct irc_chan_user *chan_user = NULL;

   290

   291

    // look for it...

   292

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

   293

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

   294

            // found

   295

            return chan_user;

   296

        }

   297

    }

   298

   299

    // not found

   300

    return NULL;

   301

}

   302

   303

err_t irc_chan_join (struct irc_chan *chan)

   304

{

   305

    err_t err;

   306

   307

    // XXX: error instead?

   308

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

   309

    assert(chan->net->conn);

   310

   311

    // send JOIN message on the appropriate connection

   312

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

   313

        // XXX: error state?

   314

        return err;

   315

   316

    // ok

   317

    chan->joining = true;

   318

   319

    return SUCCESS;

   320

}

   321