1

     2

#include "sock_tcp_internal.h"

     3

#include "sock_internal.h"

     4

#include "log.h"

     5

     6

#include <stdlib.h>

     7

#include <sys/types.h>

     8

#include <sys/socket.h>

     9

#include <string.h>

    10

    11

/**

    12

 * Start connecting to the given address in a non-blocking fashion. Returns any errors that immediately crop up,

    13

 * otherwise eventually calls sock_tcp_connect_done().

    14

 */

    15

static err_t sock_tcp_connect_addr (struct sock_tcp *sock, struct addrinfo *addr, error_t *err);

    16

    17

    18

    19

/**

    20

 * Our transport_methods

    21

 */

    22

static void _sock_tcp_destroy (transport_t *transport)

    23

{

    24

    struct sock_tcp *sock = transport_check(transport, &sock_tcp_type);

    25

    26

    // proxy

    27

    sock_tcp_destroy(sock);

    28

}

    29

    30

/*

    31

 * Our transport_type

    32

 */

    33

struct transport_type sock_tcp_type = {

    35

    .methods                = {

    36

        .read               = transport_fd_methods_read,

    37

        .write              = transport_fd_methods_write,

    38

        .events             = transport_fd_methods_events,

    39

        .destroy            = _sock_tcp_destroy,

    40

    },

    41

};

    42

    43

/**

    44

 * Create a new socket() using the given addr's family/socktype/protocol, and update our transport_fd state.

    45

 */

    46

static err_t sock_tcp_create_socket (struct sock_tcp *sock, struct addrinfo *addr, error_t *err)

    47

{

    48

    int fd;

    49

    50

    // call socket()

    51

    if ((fd = socket(addr->ai_family, addr->ai_socktype, addr->ai_protocol)) < 0)

    52

        RETURN_SET_ERROR_ERRNO(err, ERR_SOCKET);

    53

    54

    // ok, update transport_fd

    55

    transport_fd_set(SOCK_TCP_FD(sock), fd);

    56

    57

    58

    return SUCCESS;

    59

}

    60

    61

/**

    62

 * Read the socket's error code, if any.

    63

 *

    64

 * The read error number is stored in err->extra on SUCCESS, unless reading the error fails, in which case

    65

 * err contains the normal error info.

    66

 *

    67

 * @return error code on failure

    68

 */

    69

static err_t sock_tcp_read_error (struct sock_tcp *sock, error_t *err)

    70

{

    71

    int optval;

    72

    socklen_t optlen;

    73

    74

    RESET_ERROR(err);

    75

    76

    // init params

    77

    optval = 0;

    78

    optlen = sizeof(optval);

    79

    80

    // read error code

    81

    if (getsockopt(SOCK_TCP_FD(sock)->fd, SOL_SOCKET, SO_ERROR, &optval, &optlen))

    82

        RETURN_SET_ERROR_ERRNO(err, ERR_GETSOCKOPT);

    83

    84

    // sanity-check optlen... not sure if this is sensible

    85

    if (optlen != sizeof(optval))

    86

        RETURN_SET_ERROR_EXTRA(err, ERR_GETSOCKOPT, EINVAL);

    87

    88

    // then store the system error code

    89

    ERROR_EXTRA(err) = optval;

    90

    91

    // ok

    92

    return SUCCESS;

    93

}

    94

    95

/**

    96

 * Attempt to connect to the given addrinfo, or the next one, if that fails, etc.

    97

 *

    98

 * This does not call transport_connected().

    99

 */

   100

static err_t sock_tcp_connect_continue (struct sock_tcp *sock, struct addrinfo *addr, struct error_info *err)

   101

{

   102

    if (!addr)

   103

        // no more addresses left to try

   104

        return SET_ERROR(err, ERR_GETADDRINFO_EMPTY);

   105

   106

    // try and connect to each one until we find one that works

   107

    do {

   108

        // attempt to start connect

   109

        if (sock_tcp_connect_addr(sock, addr, err) == SUCCESS)

   110

            break;

   111

   112

        // log a warning on the failed connect

   113

        log_warn("sock_tcp_connect_addr(%s): %s", addr->ai_canonname, error_msg(err));

   114

   115

    } while ((addr = addr->ai_next));

   116

   117

   118

    if (addr)

   119

        // we succesfully did a sock_tcp_connect_addr on valid address

   120

        return SUCCESS;

   121

   122

    else

   123

        // all of the connect_async_addr's failed, return the last error

   124

        return ERROR_CODE(err);

   125

   126

}

   127

   128

/**

   129

 * Cleanup our resolver state and any connect callbacks after a connect

   130

 */

   131

static void sock_tcp_connect_cleanup (struct sock_tcp *sock)

   132

{

   133

    // free the addrinfo

   134

    freeaddrinfo(sock->async_res); 

   135

    sock->async_res = sock->async_cur = NULL;

   136

   137

    // remove our event handler

   138

    transport_fd_clear(SOCK_TCP_FD(sock));

   139

}

   140

   141

/**

   142

 * Our async connect operation has completed, clean up, set up state for event-based operation with user callbacks, and

   143

 * invoke transport_connected().

   144

 *

   145

 * The given \a err should be NULL for successful completion, or the error for failures.

   146

 */

   147

static void sock_tcp_connect_done (struct sock_tcp *sock, struct error_info *conn_err)

   148

{

   149

    error_t err;

   150

   151

    // cleanup

   152

    sock_tcp_connect_cleanup(sock);

   153

   154

    if (conn_err)

   155

        // passthrough errors

   156

        JUMP_SET_ERROR_INFO(&err, conn_err);

   157

   158

    // set up for default transport event-based operation

   159

    if ((ERROR_CODE(&err) = transport_fd_defaults(SOCK_TCP_FD(sock))))

   160

        goto error;

   161

   162

    // ok, no error

   163

   164

error:                

   165

    // pass on to transport

   166

    transport_connected(SOCK_TCP_TRANSPORT(sock), IS_ERROR(&err) ? &err : NULL, false);

   167

}

   168

   169

/**

   170

 * Our async connect callback

   171

 */

   172

static void sock_tcp_on_connect (struct transport_fd *fd, short what, void *arg)

   173

{

   174

    struct sock_tcp *sock = arg;

   175

    struct error_info err;

   176

    err_t tmp;

   177

   178

    // XXX: timeouts

   179

    (void) what;

   180

   181

    // read socket error code

   182

    if (sock_tcp_read_error(sock, &err))

   183

        goto error;

   184

   185

    // did the connect fail?

   186

    if (ERROR_EXTRA(&err))

   187

        JUMP_SET_ERROR(&err, ERR_CONNECT);

   188

   189

    // done, success

   190

    return sock_tcp_connect_done(sock, NULL);

   191

   192

error:

   193

    // close the socket

   194

    if ((tmp = transport_fd_close(fd)))

   195

        log_warn("error closing socket after connect error: %s", error_name(tmp));

   196

   197

    // log a warning

   198

    log_warn("connect to '%s' failed: %s", sock->async_cur->ai_canonname, error_msg(&err));

   199

   200

    // try the next one or fail completely

   201

    if (sock_tcp_connect_continue(sock, sock->async_cur->ai_next, &err))

   202

        sock_tcp_connect_done(sock, &err);

   203

}

   204

   205

static err_t sock_tcp_connect_addr (struct sock_tcp *sock, struct addrinfo *addr, error_t *err)

   206

{

   207

    int ret;

   208

    err_t tmp;

   209

   210

    // first, create the socket

   211

    if (sock_tcp_create_socket(sock, addr, err))

   212

        return ERROR_CODE(err);

   213

   214

    // then, set it up as nonblocking

   215

    if ((ERROR_CODE(err) = transport_fd_nonblock(SOCK_TCP_FD(sock), true)))

   216

        goto error;

   217

   218

    // then, initiate the connect

   219

    if ((ret = connect(SOCK_TCP_FD(sock)->fd, addr->ai_addr, addr->ai_addrlen)) < 0 && errno != EINPROGRESS) 

   220

        JUMP_SET_ERROR_ERRNO(err, ERR_CONNECT);

   221

   222

    if (ret < 0) {

   223

        // set the "current" address in case it fails and we need to try the next one

   224

        sock->async_cur = addr;

   225

   226

        // ok, connect started, setup our completion callback

   227

        if ((ERROR_CODE(err) = transport_fd_setup(SOCK_TCP_FD(sock), sock_tcp_on_connect, sock)))

   228

            goto error;

   229

   230

        // enable for write

   231

        if ((ERROR_CODE(err) = transport_fd_enable(SOCK_TCP_FD(sock), TRANSPORT_WRITE)))

   232

            goto error;

   233

   234

    } else {

   235

        // oops... blocking connect - fail to avoid confusion

   236

        // XXX: come up with a better error name to use

   237

        // XXX: support non-async connects as well

   238

        JUMP_SET_ERROR_EXTRA(err, ERR_CONNECT, EINPROGRESS);

   239

    }

   240

   241

    // ok

   242

    return SUCCESS;

   243

   244

error:

   245

    // close the stuff we did open

   246

    if ((tmp = transport_fd_close(SOCK_TCP_FD(sock))))

   247

        log_warn("error closing socket after connect error: %s", error_name(tmp));

   248

   249

    return ERROR_CODE(err);

   250

}

   251

   252

/**

   253

 * External interface

   254

 */

   255

void sock_tcp_init (struct sock_tcp *sock)

   256

{

   257

    struct event_base *ev_base = _sock_stream_ctx.ev_base;

   258

   259

    // init without any fd

   260

    transport_fd_init(SOCK_TCP_FD(sock), ev_base, TRANSPORT_FD_INVALID);

   261

   262

}

   263

   264

err_t sock_tcp_connect_async (struct sock_tcp *sock, const char *hostname, const char *service, error_t *err)

   265

{

   266

    struct addrinfo hints;

   267

    int ret;

   268

   269

    // build hints

   270

    memset(&hints, 0, sizeof(hints));

   271

    hints.ai_family = AF_UNSPEC;

   272

    hints.ai_socktype = SOCK_STREAM;

   273

   274

    // resolve (blocking)

   275

    if ((ret = getaddrinfo(hostname, service, &hints, &sock->async_res)))

   276

        RETURN_SET_ERROR_EXTRA(err, ERR_GETADDRINFO, ret);

   277

   278

    // start connecting on the first result

   279

    if (sock_tcp_connect_continue(sock, sock->async_res, err))

   280

        goto error;

   281

   282

    // ok

   283

    return SUCCESS;

   284

   285

error:

   286

    // cleanup

   287

    if (sock->async_res)

   288

        sock_tcp_connect_cleanup(sock);

   289

   290

    return ERROR_CODE(err);

   291

}

   292

   293

void sock_tcp_destroy (struct sock_tcp *sock)

   294

{

   295

    // cleanup our stuff

   296

    if (sock->async_res)

   297

        sock_tcp_connect_cleanup(sock);

   298

   299

    // destroy lower level

   300

    transport_fd_destroy(SOCK_TCP_FD(sock)); 

   301

}

   302

   303

/**

   304

 * Public interface

   305

 */

   306

err_t sock_tcp_connect (const struct transport_info *info, transport_t **transport_ptr, 

   307

        const char *host, const char *service, error_t *err)

   308

{

   309

    struct sock_tcp *sock;

   310

   311

    // alloc

   312

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

   313

        return ERR_CALLOC;

   314

   315

    // initialize transport

   316

    transport_init(SOCK_TCP_TRANSPORT(sock), &sock_tcp_type, info);

   317

   318

    // init our state

   319

    sock_tcp_init(sock);

   320

   321

    // connect    

   322

    if (sock_tcp_connect_async(sock, host, service, err))

   323

        goto error;

   324

   325

    // good

   326

    *transport_ptr = SOCK_TCP_TRANSPORT(sock);

   327

   328

    return 0;

   329

   330

error:

   331

    // cleanup

   332

    sock_tcp_destroy(sock);

   333

   334

    // return error code

   335

    return ERROR_CODE(err);

   336

}

   337