1

#include "irc_net.h"

     2

#include "irc_net_internal.h"

     3

#include "log.h"

     4

     5

#include <stdlib.h>

     6

#include <string.h>

     7

#include <assert.h>

     8

#include <time.h>

     9

    10

const char* irc_net_name (struct irc_net *net)

    11

{

    12

    return net ? net->info.network : NULL;

    13

}

    14

    15

/**

    16

 * Do a lookup for an irc_user with the given nickname, and return it it found, else NULL.

    17

 *

    18

 * This does not refcount anything.

    19

 */

    20

static struct irc_user* irc_net_lookup_user (struct irc_net *net, const char *nickname)

    21

{

    22

    struct irc_user *user = NULL;

    23

    24

    // look for it...

    25

    LIST_FOREACH(user, &net->users, net_users) {

    26

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

    27

            // found existing

    28

            return user;

    29

    }

    30

    31

    // not found

    32

    return NULL;

    33

}

    34

    35

/**

    36

 * Our irc_conn has registered. Join our channels

    37

 */

    38

static void irc_net_conn_registered (struct irc_conn *conn, void *arg)

    39

{

    40

    struct irc_net *net = arg;

    41

    struct irc_chan *chan = NULL;

    42

    error_t err;

    43

    44

    (void) conn;

    45

    46

    // join our channels

    47

    TAILQ_FOREACH(chan, &net->channels, net_channels) {

    48

        if ((ERROR_CODE(&err) = irc_chan_join(chan))) {

    49

            // XXX: this should be some kind of irc_chan_error instead

    50

    51

        }

    52

    }

    53

}

    54

    55

/**

    56

 * Our irc_conn has spontaneously failed, destroy it

    57

 */

    58

static void irc_net_conn_error (struct irc_conn *conn, error_t *err, void *arg)

    59

{

    60

    struct irc_net *net = arg;

    61

    62

    (void) conn;

    63

    64

    // log an error

    65

    log_error(err, "irc_conn error");

    66

    67

    // tear down state

    68

    irc_net_disconnect(net);

    69

    70

    // reconnect, either right away, or at the five-minute interval

    71

    if (irc_net_connect(net, (time(NULL) - net->connected_ts > IRC_NET_RECONNECT_INTERVAL), err))

    72

        log_error(err, "unable to reconnect");

    73

}

    74

    75

/**

    76

 * Our irc_conn has quit succesfully

    77

 */

    78

static void irc_net_conn_quit (struct irc_conn *conn, void *arg)

    79

{

    80

    struct irc_net *net = arg;

    81

    82

    (void) conn;

    83

    84

    // clean up the conn

    85

    irc_net_disconnect(net);

    86

    87

    // XXX: notify user

    88

}

    89

    90

/**

    91

 * Our irc_conn_callbacks list

    92

 */

    93

struct irc_conn_callbacks irc_net_conn_callbacks = {

    94

    .on_registered  = &irc_net_conn_registered,

    95

    .on_error       = &irc_net_conn_error,

    96

    .on_quit        = &irc_net_conn_quit,

    97

};

    98

    99

/**

   100

 * Propagate the command to the appropriate irc_chan based on the given name

   101

 */

   102

static void irc_net_propagate_chan (struct irc_net *net, const struct irc_line *line, const char *channel)

   103

{

   104

    struct irc_chan *chan;

   105

   106

    // look up channel

   107

    if ((chan = irc_net_get_chan(net, channel)) == NULL) {

   108

        log_warn("unknown channel: %s", channel);

   109

        return;

   110

    }

   111

   112

    // propagate

   113

    irc_cmd_invoke(&chan->handlers, line);

   114

}

   115

   116

/**

   117

 * Propagate line to irc_chan based on args[0]

   118

 */ 

   119

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

   120

{

   121

    struct irc_net *net = arg;

   122

   123

    irc_net_propagate_chan(net, line, line->args[0]);

   124

}

   125

   126

/**

   127

 * Propagate line to irc_chan based on args[1]

   128

 */ 

   129

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

   130

{

   131

    struct irc_net *net = arg;

   132

   133

    irc_net_propagate_chan(net, line, line->args[1]);

   134

}

   135

   136

/**

   137

 * Propagate line to irc_chan based on args[2]

   138

 */ 

   139

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

   140

{

   141

    struct irc_net *net = arg;

   142

   143

    irc_net_propagate_chan(net, line, line->args[2]);

   144

}

   145

   146

/**

   147

 * Propagate line to irc_chans based on the source nickname and chan_users.

   148

 */

   149

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

   150

{

   151

    struct irc_net *net = arg;

   152

    struct irc_chan *chan;

   153

   154

    // scan each channel

   155

    TAILQ_FOREACH(chan, &net->channels, net_channels) {

   156

        if (irc_chan_get_user(chan, line->source->nickname)) {

   157

            // propagate

   158

            irc_cmd_invoke(&chan->handlers, line);

   159

        }

   160

    }

   161

}

   162

   163

/**

   164

 * :nm NICK <nickname>

   165

 *

   166

 * Look for a relevant irc_user, and rename them.

   167

 *

   168

 * Ignores if the irc_user could not be found, then propagates to the irc_chan's that the user is on, and then renames

   169

 * the irc_user.

   170

 */

   171

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

   172

{

   173

    struct irc_net *net = arg;

   174

    struct irc_user *user;

   175

    err_t err;

   176

   177

    // ignore for unknown

   178

    if ((user = irc_net_lookup_user(net, line->source->nickname)) == NULL)

   179

        return;

   180

   181

    // propagate to channels

   182

    irc_net_on_chanuser(line, arg);

   183

   184

    // rename them

   185

    if ((err = irc_user_rename(user, line->args[0])))

   186

        // XXX: what to do?

   187

        log_err(err, "irc_user_rename failed");

   188

}

   189

   190

/**

   191

 * :nm (PRIVMSG|NOTICE) <target> <message>

   192

 *

   193

 * Either propagate to channel if found, otherwise handle as a privmsg

   194

 */

   195

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

   196

{

   197

    struct irc_net *net = arg;

   198

   199

    // XXX: does two lookups

   200

    if (irc_net_get_chan(net, line->args[0])) {

   201

        // short-circuit to on_chan0

   202

        irc_net_on_chan0(line, arg);

   203

   204

    } else {

   205

        // XXX: callbacks for privmsgs

   206

   207

    }

   208

}

   209

   210

/**

   211

 * :nm MODE <target> [<stuff> [ ... ]]

   212

 *

   213

 * If target is ourselves, handle as a private umode, otherwise, propagate to channel

   214

 */

   215

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

   216

{

   217

    struct irc_net *net = arg;

   218

   219

    if (irc_conn_self(net->conn, line->args[0]))

   220

        // don't really care about our umode...

   221

        log_info("mode set: %s -> %s %s %s...", line->source->nickname, line->args[1], line->args[2], line->args[3]);

   222

   223

    else

   224

        // it's a channel mode

   225

        irc_net_propagate_chan(net, line, line->args[0]);

   226

   227

}

   228

   229

/**

   230

 * Our irc_cmd handler list

   231

 */

   232

struct irc_cmd_handler irc_net_cmd_handlers[] = {

   233

    // propagate certain messages to the appropriate channel

   234

    {   "QUIT",             &irc_net_on_chanuser    },

   235

    {   "JOIN",             &irc_net_on_chan0       },

   236

    {   "PART",             &irc_net_on_chan0       },

   237

    {   "MODE",             &irc_net_on_MODE        },

   238

    {   "TOPIC",            &irc_net_on_chan0       },

   239

    {   "KICK",             &irc_net_on_chan0       },

   240

    {   IRC_RPL_NAMREPLY,   &irc_net_on_chan2       },

   241

    {   IRC_RPL_ENDOFNAMES, &irc_net_on_chan1       },

   242

    {   "CTCP ACTION",      &irc_net_on_chan0       },

   243

   244

    // special-case handling for others

   245

    {   "NICK",             &irc_net_on_NICK        },

   246

    // Note: no need to handle QUIT, as the channels should take care of irc_net_put_user'ing it away.

   247

    {   "PRIVMSG",          &irc_net_on_msg         },

   248

    {   "NOTICE",           &irc_net_on_msg         },

   249

   250

    {   NULL,               NULL                    }

   251

};

   252

   253

err_t irc_net_create (struct irc_net **net_ptr, const struct irc_net_info *info, error_t *err)

   254

{

   255

    struct irc_net *net;

   256

   257

    // allocate

   258

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

   259

        return SET_ERROR(err, ERR_CALLOC);

   260

   261

    // initialize

   262

    // XXX: we need to copy *info's fields

   263

    net->info = *info;

   264

    TAILQ_INIT(&net->channels);

   265

    LIST_INIT(&net->users);

   266

   267

    // init subsystems

   268

    if (irc_net_connect_init(net, err))

   269

        goto error;

   270

   271

    // initial connect

   272

    if (irc_net_connect(net, true, err))

   273

        goto error;

   274

   275

    // ok

   276

    *net_ptr = net;

   277

   278

    return SUCCESS;

   279

   280

error:

   281

    // cleanup main

   282

    irc_net_destroy(net);

   283

   284

    return ERROR_CODE(err);

   285

}

   286

   287

void irc_net_destroy (struct irc_net *net)

   288

{

   289

    struct irc_chan *chan_next = TAILQ_FIRST(&net->channels), *chan;

   290

    struct irc_user *user_next, *user;

   291

   292

    // our conn

   293

    if (net->conn)

   294

        irc_conn_destroy(net->conn);

   295

   296

    // our channels

   297

    while ((chan = chan_next)) {

   298

        chan_next = TAILQ_NEXT(chan, net_channels);

   299

   300

        irc_chan_destroy(chan);

   301

    }

   302

   303

    // our users

   304

    // XXX: this disregards external refs

   305

    for (user_next = LIST_FIRST(&net->users); (user = user_next); ) {

   306

        user_next = LIST_NEXT(user, net_users);

   307

   308

        irc_user_destroy(user);

   309

    }

   310

   311

    // our info

   312

    if (net->info.ssl_cred)

   313

        ssl_client_cred_put(net->info.ssl_cred);

   314

   315

    // misc

   316

    irc_net_connect_destroy(net);

   317

   318

    // ourselves

   319

    free(net);

   320

}

   321

   322

err_t irc_net_add_chan (struct irc_net *net, struct irc_chan **chan_ptr, const struct irc_chan_info *info, error_t *err)

   323

{

   324

    struct irc_chan *chan;

   325

   326

    // create the new irc_chan struct

   327

    if (irc_chan_create(&chan, net, info, err))

   328

        return ERROR_CODE(err);

   329

   330

    // add to network list

   331

    TAILQ_INSERT_TAIL(&net->channels, chan, net_channels);

   332

   333

    // currently connected?

   334

    if (net->conn && net->conn->registered) {

   335

        // then join

   336

        if ((ERROR_CODE(err) = irc_chan_join(chan)))

   337

            return ERROR_CODE(err);

   338

    }

   339

   340

    // ok

   341

    if (chan_ptr)

   342

        *chan_ptr = chan;

   343

   344

    return SUCCESS;

   345

}

   346

   347

struct irc_chan* irc_net_get_chan (struct irc_net *net, const char *channel)

   348

{

   349

    struct irc_chan *chan = NULL;

   350

   351

    // look for it...

   352

    TAILQ_FOREACH(chan, &net->channels, net_channels) {

   353

        if (strcasecmp(chan->info.channel, channel) == 0)

   354

            // found it

   355

            return chan;

   356

    }

   357

   358

    // no such channel

   359

    return NULL;

   360

}

   361

   362

err_t irc_net_get_user (struct irc_net *net, struct irc_user **user_ptr, const char *nickname)

   363

{

   364

    struct irc_user *user;

   365

    err_t err;

   366

   367

    // lookup

   368

    if ((user = irc_net_lookup_user(net, nickname)) == NULL) {

   369

        // create a new user struct

   370

        if ((err = irc_user_create(&user, net, nickname)))

   371

            return err;

   372

   373

        // add to our list

   374

        LIST_INSERT_HEAD(&net->users, user, net_users);

   375

   376

    } else {

   377

        // check for refcount overflow

   378

        assert(user->refcount < SIZE_MAX);

   379

    }

   380

   381

    // 'get' it

   382

    user->refcount++;

   383

   384

    // ok

   385

    *user_ptr = user;

   386

   387

    return SUCCESS;

   388

}

   389

   390

void irc_net_put_user (struct irc_net *net, struct irc_user *user)

   391

{

   392

    (void) net;

   393

   394

    assert(user->refcount > 0);

   395

   396

    // nothing if it's still in use elsewhere

   397

    if (--user->refcount)

   398

        return;

   399

   400

    // remove from list

   401

    LIST_REMOVE(user, net_users);

   402

   403

    // destroy

   404

    irc_user_destroy(user);

   405

}

   406

   407

err_t irc_net_quit (struct irc_net *net, const char *message)

   408

{

   409

   if (!net->conn)

   410

       return ERR_IRC_NET_STATE;

   411

   412

    // send the QUIT message, and then we can wait for the reply

   413

    return irc_conn_QUIT(net->conn, message);

   414

}