1

     2

#include "irc_net_internal.h"

     3

#include "sock_tcp.h"

     4

#include "log.h"

     5

     6

#include <time.h>

     7

#include <assert.h>

     8

     9

void irc_net_disconnect (struct irc_net *net)

    10

{

    11

    struct irc_chan *chan = NULL;

    12

    13

    // mark

    14

    net->connected = false;

    15

    16

    // destroy connection and set NULL

    17

    irc_conn_destroy(net->conn);

    18

    net->conn = NULL;

    19

    20

    // update channel state

    21

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

    22

        // XXX: notify channel somehow

    23

    24

    }

    25

    26

}

    27

    28

/**

    29

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

    30

 * it to us.

    31

 *

    32

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

    33

 */

    34

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

    35

{

    36

    // mark state

    37

    net->connecting = false;

    38

    39

    // create the irc connection state

    40

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

    41

        goto error;

    42

    43

    // add our command handlers

    44

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

    45

        goto error;

    46

    47

    // register

    48

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

    49

        goto error;

    50

    51

    // great, we're alive now

    52

    net->connected = true;

    53

    net->connected_ts = time(NULL);

    54

    55

    return SUCCESS;

    56

    57

error:

    58

    if (!net->conn) {

    59

        // cleanup transport ourselves

    60

        transport_destroy(transport);

    61

    62

    } else {

    63

        // cleanup the partial stuff

    64

        irc_conn_destroy(net->conn);

    65

    66

        net->conn = NULL;

    67

    }

    68

    69

    return ERROR_CODE(err);

    70

}

    71

    72

/**

    73

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

    74

 * irc_net_connected().

    75

 */

    76

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

    77

{

    78

    struct irc_net *net = arg;

    79

    error_t err;

    80

    81

    // yay

    82

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

    83

        log_err_info(&err, "irc_net_connected");

    84

}

    85

    86

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

    87

{

    88

    struct irc_net *net = arg;

    89

    error_t err;

    90

    91

    // clean up

    92

    transport_destroy(transport);

    93

    94

    // attempt reconnect later

    95

    log_err_info(conn_err, "connect failed");

    96

    97

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

    98

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

    99

}

   100

   101

static const struct transport_callbacks irc_net_transport_callbacks = {

   102

    .on_connect = irc_net_on_connect,

   103

    .on_error   = irc_net_on_connect_error,

   104

};

   105

   106

/**

   107

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

   108

 * later if this succeeds.

   109

 */

   110

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

   111

{

   112

    struct irc_net_info *info = &net->info;

   113

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

   114

    transport_t *transport = NULL;

   115

   116

    // sanity check

   117

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

   118

   119

    // connect based on what's known

   120

    if (info->transport) {

   121

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

   122

   123

        // direct transport connection

   124

        transport = info->transport;

   125

   126

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

   127

        info->transport = NULL;

   128

   129

        // then create the transport right away

   130

        if (irc_net_connected(net, transport, err))

   131

            goto error;

   132

   133

    } else if (info->ssl_cred) {

   134

        // aquire a ref

   135

        // NOTE: before any error handling

   136

        sock_ssl_client_cred_get(info->ssl_cred);

   137

   138

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

   139

   140

        // connect

   141

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

   142

            goto error;

   143

   144

        net->connecting = true;

   145

   146

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

   147

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

   148

   149

        // begin async connect

   150

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

   151

            goto error;

   152

   153

        net->connecting = true;

   154

   155

    } else {

   156

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

   157

   158

    }

   159

   160

    return SUCCESS;

   161

   162

error:

   163

    return ERROR_CODE(err);    

   164

}

   165

   166

/**

   167

 * Reconnect timer callback

   168

 */

   169

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

   170

{

   171

    struct irc_net *net = arg;

   172

    struct error_info err;

   173

   174

    (void) fd;

   175

    (void) what;

   176

   177

    // execute it?

   178

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

   179

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

   180

}

   181

   182

/**

   183

 * Schedule a reconnection attempt in IRC_NET_RECONNECT_INTERVAL.

   184

 */

   185

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

   186

{   

   187

    // ...for x seconds

   188

    struct timeval tv = { IRC_NET_RECONNECT_INTERVAL, 0 };

   189

   190

    // schedule

   191

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

   192

        return SET_ERROR(err, ERR_EVENT_ADD);

   193

   194

    // oke

   195

    return SUCCESS;

   196

}

   197

   198

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

   199

{

   200

    // attempt to reconnect now?

   201

    if (now) {

   202

        if (irc_net_do_connect(net, err))

   203

            // log error and continue below with schedule_reconnect

   204

            log_err_info(err, "reconnect failed");

   205

   206

        else

   207

            // connecting, done

   208

            return SUCCESS;

   209

    }

   210

   211

    // schedule for later

   212

    if (irc_net_schedule_reconnect(net, err))

   213

        goto error;

   214

   215

    // ok

   216

    return SUCCESS;

   217

   218

error:

   219

    return ERROR_CODE(err);

   220

}

   221

   222

// XXX: to get the ev_base

   223

#include "sock_internal.h"

   224

   225

   226

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

   227

{

   228

    // look up the ev_base 

   229

    struct event_base *ev_base = _sock_stream_ctx.ev_base;

   230

   231

    // reconnect timer

   232

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

   233

        return SET_ERROR(err, ERR_EVENT_NEW);

   234

   235

    // ok

   236

    return SUCCESS;

   237

}

   238

   239

void irc_net_connect_destroy (struct irc_net *net)

   240

{

   241

    event_free(net->reconnect_timer);

   242

}

   243