1

#include "irc_net.h"

     2

#include "log.h"

     3

     4

#include <stdlib.h>

     5

#include <string.h>

     6

#include <assert.h>

     7

     8

const char* irc_net_name (struct irc_net *net)

     9

{

    10

    return net->info.network;

    11

}

    12

    13

/**

    14

 * Something happaned which caused our irc_conn to fail. Destroy it, and recover. XXX: somehow

    15

 */

    16

static void irc_net_error (struct irc_net *net, struct error_info *err)

    17

{

    18

    struct irc_chan *chan = NULL;

    19

    20

    // log an error

    21

    log_err_info(err, "irc_conn failed");

    22

    23

    // destroy connection and set NULL

    24

    irc_conn_destroy(net->conn);

    25

    net->conn = NULL;

    26

    27

    // update channel state

    28

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

    29

        // XXX: notify channel somehow

    30

    }

    31

    32

    // XXX: reconnect?

    33

}

    34

    35

/**

    36

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

    37

 *

    38

 * This does not refcount anything.

    39

 */

    40

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

    41

{

    42

    struct irc_user *user = NULL;

    43

    44

    // look for it...

    45

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

    46

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

    47

            // found existing

    48

            return user;

    49

    }

    50

    51

    // not found

    52

    return NULL;

    53

}

    54

    55

/**

    56

 * Our irc_conn has registered. Join our channels

    57

 */

    58

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

    59

{

    60

    struct irc_net *net = arg;

    61

    struct irc_chan *chan = NULL;

    62

    struct error_info err;

    63

    64

    (void) conn;

    65

    66

    // join our channels

    67

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

    68

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

    69

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

    70

            irc_net_error(net, &err);

    71

    }

    72

}

    73

    74

/**

    75

 * Our irc_conn has spontaneously failed, destroy it

    76

 */

    77

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

    78

{

    79

    struct irc_net *net = arg;

    80

    81

    (void) conn;

    82

    83

    irc_net_error(net, err);

    84

}

    85

    86

/**

    87

 * Our irc_conn has quit succesfully

    88

 */

    89

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

    90

{

    91

    struct irc_net *net = arg;

    92

    93

    // clean up the conn

    94

    irc_conn_destroy(conn);

    95

    net->conn = NULL;

    96

    97

    // XXX: notify user

    98

}

    99

   100

/**

   101

 * Our irc_conn_callbacks list

   102

 */

   103

struct irc_conn_callbacks _conn_callbacks = {

   104

    .on_registered  = &irc_net_conn_registered,

   105

    .on_error       = &irc_net_conn_error,

   106

    .on_quit        = &irc_net_conn_quit,

   107

};

   108

   109

/**

   110

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

   111

 */

   112

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

   113

{

   114

    struct irc_chan *chan;

   115

   116

    // look up channel

   117

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

   118

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

   119

        return;

   120

    }

   121

   122

    // propagate

   123

    irc_cmd_invoke(&chan->handlers, line);

   124

}

   125

   126

/**

   127

 * Propagate line to irc_chan based on args[0]

   128

 */ 

   129

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

   130

{

   131

    struct irc_net *net = arg;

   132

   133

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

   134

}

   135

   136

/**

   137

 * Propagate line to irc_chan based on args[1]

   138

 */ 

   139

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

   140

{

   141

    struct irc_net *net = arg;

   142

   143

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

   144

}

   145

   146

/**

   147

 * Propagate line to irc_chan based on args[2]

   148

 */ 

   149

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

   150

{

   151

    struct irc_net *net = arg;

   152

   153

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

   154

}

   155

   156

/**

   157

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

   158

 */

   159

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

   160

{

   161

    struct irc_net *net = arg;

   162

    struct irc_chan *chan;

   163

   164

    // scan each channel

   165

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

   166

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

   167

            // propagate

   168

            irc_cmd_invoke(&chan->handlers, line);

   169

        }

   170

    }

   171

}

   172

   173

/**

   174

 * :nm NICK <nickname>

   175

 *

   176

 * Look for a relevant irc_user, and rename them.

   177

 *

   178

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

   179

 * the irc_user.

   180

 */

   181

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

   182

{

   183

    struct irc_net *net = arg;

   184

    struct irc_user *user;

   185

    err_t err;

   186

   187

    // ignore for unknown

   188

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

   189

        return;

   190

   191

    // propagate to channels

   192

    irc_net_on_chanuser(line, arg);

   193

   194

    // rename them

   195

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

   196

        // XXX: what to do?

   197

        log_err(err, "irc_user_rename failed");

   198

}

   199

   200

/**

   201

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

   202

 *

   203

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

   204

 */

   205

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

   206

{

   207

    struct irc_net *net = arg;

   208

   209

    // XXX: does two lookups

   210

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

   211

        // short-circuit to on_chan0

   212

        irc_net_on_chan0(line, arg);

   213

   214

    } else {

   215

        // XXX: callbacks for privmsgs

   216

   217

    }

   218

}

   219

   220

/**

   221

 * Our irc_cmd handler list

   222

 */

   223

static struct irc_cmd_handler _cmd_handlers[] = {

   224

    // propagate certain messages to the appropriate channel

   225

    {   "QUIT",             &irc_net_on_chanuser    },

   226

    {   "JOIN",             &irc_net_on_chan0       },

   227

    {   "PART",             &irc_net_on_chan0       },

   228

    {   "MODE",             &irc_net_on_chan0       },

   229

    {   "TOPIC",            &irc_net_on_chan0       },

   230

    {   "KICK",             &irc_net_on_chan0       },

   231

    {   IRC_RPL_NAMREPLY,   &irc_net_on_chan2       },

   232

    {   IRC_RPL_ENDOFNAMES, &irc_net_on_chan1       },

   233

    {   "CTCP ACTION",      &irc_net_on_chan0       },

   234

   235

    // special-case handling for others

   236

    {   "NICK",             &irc_net_on_NICK        },

   237

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

   238

    {   "PRIVMSG",          &irc_net_on_msg         },

   239

    {   "NOTICE",           &irc_net_on_msg         },

   240

   241

    {   NULL,               NULL                    }

   242

};

   243

   244

/**

   245

 * The given socket is now connected, so create the irc_conn and bind it in to us

   246

 */

   247

static err_t irc_net_connected (struct irc_net *net, struct sock_stream *sock, struct error_info *err)

   248

{

   249

    // create the irc connection state

   250

    if (irc_conn_create(&net->conn, sock, &_conn_callbacks, net, err))

   251

        return ERROR_CODE(err);

   252

   253

    // add our command handlers

   254

    if ((ERROR_CODE(err) = irc_conn_add_cmd_handlers (net->conn, _cmd_handlers, net)))

   255

        return ERROR_CODE(err);

   256

   257

    // register

   258

    if ((ERROR_CODE(err) = irc_conn_register(net->conn, &net->info.register_info)))

   259

        return ERROR_CODE(err);

   260

   261

    // ok

   262

    return SUCCESS;

   263

}

   264

   265

static void irc_net_on_connect (struct sock_stream *sock, struct error_info *conn_err, void *arg)

   266

{

   267

    struct irc_net *net = arg;

   268

    struct error_info err;

   269

   270

    // XXX: better error handling

   271

   272

    // trap errors

   273

    if (conn_err)

   274

        FATAL_ERROR(conn_err, "async TCP connect failed");

   275

   276

    // ok, yay

   277

    if (irc_net_connected(net, sock, &err))

   278

        FATAL_ERROR(&err, "irc_net_connected failed");

   279

   280

    // XXX: cleanup

   281

}

   282

   283

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

   284

{

   285

    struct irc_net *net;

   286

    struct sock_stream *sock = NULL;

   287

   288

    // allocate

   289

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

   290

        return SET_ERROR(err, ERR_CALLOC);

   291

   292

    // initialize

   293

    net->info = *info;

   294

    TAILQ_INIT(&net->channels);

   295

    LIST_INIT(&net->users);

   296

   297

    // non-async socket connect?

   298

    if (info->raw_sock || info->use_ssl) {

   299

        // create the socket

   300

        if (info->raw_sock) {

   301

            log_debug("connected using raw socket: %p", info->raw_sock);

   302

   303

            sock = info->raw_sock;

   304

   305

        } else if (info->use_ssl) {

   306

            log_debug("connecting to [%s]:%s using SSL", info->hostname, info->service);

   307

   308

            // XXX: over-simplified blocking connect

   309

            if (sock_ssl_connect(&sock, info->hostname, info->service, err))

   310

                goto error;

   311

        }

   312

   313

        // then create the conn right away

   314

        if (irc_net_connected(net, sock, err))

   315

            goto error;

   316

   317

    } else {

   318

        log_debug("connecting to [%s]:%s", info->hostname, info->service);

   319

   320

        // begin async connect

   321

        if (sock_tcp_connect_async(&sock, info->hostname, info->service, &irc_net_on_connect, net, err))

   322

            goto error;

   323

   324

    }

   325

   326

    // ok

   327

    *net_ptr = net;

   328

   329

    return SUCCESS;

   330

   331

error:

   332

    if (sock && !net->conn)

   333

        // we need to clean up the socket ourself

   334

        sock_stream_release(sock);

   335

   336

    // cleanup main

   337

    irc_net_destroy(net);

   338

   339

    return ERROR_CODE(err);

   340

}

   341

   342

void irc_net_destroy (struct irc_net *net)

   343

{

   344

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

   345

   346

    // our conn

   347

    if (net->conn)

   348

        irc_conn_destroy(net->conn);

   349

   350

    // our channels

   351

    while (next) {

   352

        chan = next;

   353

        next = TAILQ_NEXT(chan, net_channels);

   354

   355

        irc_chan_destroy(chan);

   356

    }

   357

   358

    // XXX: our users

   359

   360

    // ourselves

   361

    free(net);

   362

}

   363

   364

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

   365

{

   366

    struct irc_chan *chan;

   367

   368

    // create the new irc_chan struct

   369

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

   370

        return ERROR_CODE(err);

   371

   372

    // add to network list

   373

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

   374

   375

    // currently connected?

   376

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

   377

        // then join

   378

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

   379

            return ERROR_CODE(err);

   380

    }

   381

   382

    // ok

   383

    if (chan_ptr)

   384

        *chan_ptr = chan;

   385

   386

    return SUCCESS;

   387

}

   388

   389

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

   390

{

   391

    struct irc_chan *chan = NULL;

   392

   393

    // look for it...

   394

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

   395

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

   396

            // found it

   397

            return chan;

   398

    }

   399

   400

    // no such channel

   401

    return NULL;

   402

}

   403

   404

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

   405

{

   406

    struct irc_user *user;

   407

    err_t err;

   408

   409

    // lookup

   410

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

   411

        // create a new user struct

   412

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

   413

            return err;

   414

   415

        // add to our list

   416

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

   417

   418

    } else {

   419

        // check for refcount overflow

   420

        assert(user->refcount < SIZE_MAX);

   421

    }

   422

   423

    // 'get' it

   424

    user->refcount++;

   425

   426

    // ok

   427

    *user_ptr = user;

   428

   429

    return SUCCESS;

   430

}

   431

   432

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

   433

{

   434

    (void) net;

   435

   436

    assert(user->refcount > 0);

   437

   438

    // nothing if it's still in use elsewhere

   439

    if (--user->refcount)

   440

        return;

   441

   442

    // remove from list

   443

    LIST_REMOVE(user, net_users);

   444

   445

    // destroy

   446

    irc_user_destroy(user);

   447

}

   448

   449

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

   450

{

   451

   if (!net->conn)

   452

       return ERR_IRC_NET_STATE;

   453

   454

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

   455

    return irc_conn_QUIT(net->conn, message);

   456

}