1

     2

#include "irc_net_internal.h"

     3

#include "tcp.h"

     4

#include "ssl.h"

     5

#include "log.h"

     6

     7

#include <time.h>

     8

#include <assert.h>

     9

    10

void irc_net_disconnect (struct irc_net *net)

    11

{

    12

    struct irc_chan *chan = NULL;

    13

    14

    // mark

    15

    net->connected = false;

    16

    17

    // destroy connection and set NULL

    18

    irc_conn_destroy(net->conn);

    19

    net->conn = NULL;

    20

    21

    // update channel state

    22

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

    23

        // XXX: notify channel somehow

    24

    25

    }

    26

    27

}

    28

    29

/**

    30

 * We have succesfully established a connection to our server with the given transport, so create the irc_conn and bind

    31

 * it to us.

    32

 *

    33

 * If this fails, this will clean up any partial state, including \a transport.

    34

 */

    35

static err_t irc_net_connected (struct irc_net *net, transport_t *transport, struct error_info *err)

    36

{

    37

    // mark state

    38

    net->connecting = false;

    39

    40

    // create the irc connection state

    41

    if (irc_conn_create(&net->conn, transport, &irc_net_conn_callbacks, net, err))

    42

        goto error;

    43

    44

    // add our command handlers

    45

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

    46

        goto error;

    47

    48

    // register

    49

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

    50

        goto error;

    51

    52

    // great, we're alive now

    53

    net->connected = true;

    54

    net->connected_ts = time(NULL);

    55

    56

    return SUCCESS;

    57

    58

error:

    59

    if (!net->conn) {

    60

        // cleanup transport ourselves

    61

        transport_destroy(transport);

    62

    63

    } else {

    64

        // cleanup the partial stuff

    65

        irc_conn_destroy(net->conn);

    66

    67

        net->conn = NULL;

    68

    }

    69

    70

    return ERROR_CODE(err);

    71

}

    72

    73

/**

    74

 * Our sock_*_connect_async callback. If the connect ended up failing, then try and reconnect later. Otherwise, do

    75

 * irc_net_connected().

    76

 */

    77

static void irc_net_on_connect (transport_t *transport, void *arg)

    78

{

    79

    struct irc_net *net = arg;

    80

    error_t err;

    81

    82

    // yay

    83

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

    84

        log_error(&err, "irc_net_connected");

    85

}

    86

    87

static void irc_net_on_connect_error (transport_t *transport, const error_t *conn_err, void *arg)

    88

{

    89

    struct irc_net *net = arg;

    90

    error_t err;

    91

    92

    // clean up

    93

    transport_destroy(transport);

    94

    95

    // attempt reconnect later

    96

    log_error(conn_err, "connect failed");

    97

    98

    if (irc_net_connect(net, false, &err))

    99

        log_error(&err, "unable to reconnect");

   100

}

   101

   102

static const struct transport_callbacks irc_net_transport_callbacks = {

   103

    .on_connect = irc_net_on_connect,

   104

    .on_error   = irc_net_on_connect_error,

   105

};

   106

   107

/**

   108

 * The low-level connect() implementation, connects based on irc_net::info, calling irc_net_connected/irc_net_reconnect

   109

 * later if this succeeds.

   110

 */

   111

static err_t irc_net_do_connect (struct irc_net *net, struct error_info *err)

   112

{

   113

    struct irc_net_info *info = &net->info;

   114

    struct transport_info transport_info = { &irc_net_transport_callbacks, net, TRANSPORT_READ | TRANSPORT_WRITE };

   115

    transport_t *transport = NULL;

   116

   117

    // sanity check

   118

    assert(!net->connecting && !net->connected);

   119

   120

    // connect based on what's known

   121

    if (info->transport) {

   122

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

   123

   124

        // direct transport connection

   125

        transport = info->transport;

   126

   127

        // invalidate it from info since it will get destroyed later

   128

        info->transport = NULL;

   129

   130

        // then create the transport right away

   131

        if (irc_net_connected(net, transport, err))

   132

            goto error;

   133

   134

    } else if (info->ssl_cred) {

   135

        // aquire a ref

   136

        // NOTE: before any error handling

   137

        ssl_client_cred_get(info->ssl_cred);

   138

   139

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

   140

   141

        // connect

   142

        if (ssl_connect(&transport_info, &transport, info->hostname, info->service, info->ssl_cred, err))

   143

            goto error;

   144

   145

        net->connecting = true;

   146

   147

    } else if (info->hostname || info->service) {

   148

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

   149

   150

        // begin async connect

   151

        if (tcp_connect(&transport_info, &transport, info->hostname, info->service, err))

   152

            goto error;

   153

   154

        net->connecting = true;

   155

   156

    } else {

   157

        RETURN_SET_ERROR_STR(err, ERR_MISC, "no connection info specified");

   158

   159

    }

   160

   161

    return SUCCESS;

   162

   163

error:

   164

    return ERROR_CODE(err);    

   165

}

   166

   167

/**

   168

 * Reconnect timer callback

   169

 */

   170

static void irc_net_reconnect_timer_cb (int fd, short what, void *arg)

   171

{

   172

    struct irc_net *net = arg;

   173

    struct error_info err;

   174

   175

    (void) fd;

   176

    (void) what;

   177

   178

    // execute it?

   179

    if (irc_net_connect(net, true, &err))

   180

        log_error(&err, "unable to reconnect");

   181

}

   182

   183

/**

   184

 * Schedule a reconnection attempt in IRC_NET_RECONNECT_INTERVAL.

   185

 */

   186

static err_t irc_net_schedule_reconnect (struct irc_net *net, struct error_info *err)

   187

{   

   188

    // ...for x seconds

   189

    struct timeval tv = { IRC_NET_RECONNECT_INTERVAL, 0 };

   190

   191

    // schedule

   192

    if (event_add(net->reconnect_timer, &tv))

   193

        return SET_ERROR(err, ERR_EVENT_ADD);

   194

   195

    // oke

   196

    return SUCCESS;

   197

}

   198

   199

err_t irc_net_connect (struct irc_net *net, bool now, struct error_info *err)

   200

{

   201

    // attempt to reconnect now?

   202

    if (now) {

   203

        if (irc_net_do_connect(net, err))

   204

            // log error and continue below with schedule_reconnect

   205

            log_error(err, "reconnect failed");

   206

   207

        else

   208

            // connecting, done

   209

            return SUCCESS;

   210

    }

   211

   212

    // schedule for later

   213

    if (irc_net_schedule_reconnect(net, err))

   214

        goto error;

   215

   216

    // ok

   217

    return SUCCESS;

   218

   219

error:

   220

    return ERROR_CODE(err);

   221

}

   222

   223

// XXX: to get the ev_base

   224

#include "sock_internal.h"

   225

   226

   227

err_t irc_net_connect_init (struct irc_net *net, struct error_info *err)

   228

{

   229

    // look up the ev_base 

   230

    struct event_base *ev_base = _sock_stream_ctx.ev_base;

   231

   232

    // reconnect timer

   233

    if ((net->reconnect_timer = evtimer_new(ev_base, irc_net_reconnect_timer_cb, net)) == NULL)

   234

        return SET_ERROR(err, ERR_EVENT_NEW);

   235

   236

    // ok

   237

    return SUCCESS;

   238

}

   239

   240

void irc_net_connect_destroy (struct irc_net *net)

   241

{

   242

    event_free(net->reconnect_timer);

   243

}

   244