1

     2

#include "sock_tcp.h"

     3

#include "log.h"

     4

     5

#include <stdlib.h>

     6

#include <sys/types.h>

     7

#include <sys/socket.h>

     8

#include <unistd.h>

     9

#include <fcntl.h>

    10

#include <string.h>

    11

#include <assert.h>

    12

    13

/*

    14

 * Our basic socket event handler for driving our callbacks

    15

 */

    16

static void sock_tcp_event_handler (evutil_socket_t fd, short what, void *arg) 

    17

{

    18

    struct sock_tcp *sock = arg;

    19

    20

    (void) fd;

    21

    22

    // invoke appropriate callback

    23

    sock_stream_invoke_callbacks(SOCK_TCP_BASE(sock), what);

    24

}

    25

    26

/*

    27

 * Our sock_stream_methods.read method

    28

 */

    29

static err_t sock_tcp_read (struct sock_stream *base_sock, void *buf, size_t *len)

    30

{

    31

    struct sock_tcp *sock = SOCK_FROM_BASE(base_sock, struct sock_tcp);

    32

    int ret;

    33

    34

    // read(), and detect non-EAGAIN or EOF

    35

    if ((ret = read(sock->fd, buf, *len)) < 0 && errno != EAGAIN)

    36

        // unexpected error

    37

        RETURN_SET_ERROR_ERRNO(SOCK_TCP_ERR(sock), ERR_READ);

    38

    39

    else if (ret == 0)

    40

        // EOF

    41

        return SET_ERROR(SOCK_TCP_ERR(sock), ERR_READ_EOF);

    42

    43

    44

    if (ret < 0) {

    45

        // EAGAIN -> zero bytes

    46

        *len = 0;

    47

    48

    } else {

    49

        // normal -> bytes read

    50

        *len = ret;

    51

    }

    52

    53

    // ok

    54

    return SUCCESS;

    55

}

    56

    57

/*

    58

 * Our sock_stream_methods.write method

    59

 */

    60

static err_t sock_tcp_write (struct sock_stream *base_sock, const void *buf, size_t *len)

    61

{

    62

    struct sock_tcp *sock = SOCK_FROM_BASE(base_sock, struct sock_tcp);

    63

    int ret;

    64

    65

    // write(), and detect non-EAGAIN or EOF

    66

    if ((ret = write(sock->fd, buf, *len)) < 0 && errno != EAGAIN)

    67

        // unexpected error

    68

        RETURN_SET_ERROR_ERRNO(SOCK_TCP_ERR(sock), ERR_WRITE);

    69

    70

    else if (ret == 0)

    71

        // EOF

    72

        return SET_ERROR(SOCK_TCP_ERR(sock), ERR_WRITE_EOF);

    73

    74

    75

    if (ret < 0) {

    76

        // EAGAIN -> zero bytes

    77

        *len = 0;

    78

    79

    } else {

    80

        // normal -> bytes read

    81

        *len = ret;

    82

    }

    83

    84

    return SUCCESS;

    85

}

    86

    87

static err_t sock_tcp_event_init (struct sock_stream *base_sock)

    88

{

    89

    struct sock_tcp *sock = SOCK_FROM_BASE(base_sock, struct sock_tcp);

    90

    err_t err;

    91

    92

    // set nonblocking

    93

    if ((err = sock_tcp_set_nonblock(sock, 1)))

    94

        return err;

    95

    96

    // add ourselves as the event handler

    97

    if ((err = sock_tcp_init_ev(sock, &sock_tcp_event_handler, sock)))

    98

        return err;

    99

   100

    // done

   101

    return SUCCESS;

   102

}

   103

   104

static err_t sock_tcp_event_enable (struct sock_stream *base_sock, short mask)

   105

{

   106

    struct sock_tcp *sock = SOCK_FROM_BASE(base_sock, struct sock_tcp);

   107

   108

    // implemented in sock_tcp_add_event

   109

    return sock_tcp_add_event(sock, mask);

   110

}

   111

   112

static void sock_tcp_release (struct sock_stream *base_sock)

   113

{

   114

    struct sock_tcp *sock = SOCK_FROM_BASE(base_sock, struct sock_tcp);

   115

   116

    // close and free

   117

    sock_tcp_close(sock);

   118

    sock_tcp_free(sock);

   119

}

   120

   121

/*

   122

 * Our sock_stream_type

   123

 */

   124

static struct sock_stream_type sock_tcp_type = {

   125

    .methods                = {

   126

        .read               = &sock_tcp_read,

   127

        .write              = &sock_tcp_write,

   128

        .event_init         = &sock_tcp_event_init,

   129

        .event_enable       = &sock_tcp_event_enable,

   130

        .release            = &sock_tcp_release,

   131

    },

   132

};

   133

   134

err_t sock_tcp_alloc (struct sock_tcp **sock_ptr)

   135

{

   136

    // alloc

   137

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

   138

        return ERR_CALLOC;

   139

   140

    // initialize base with sock_tcp_type

   141

    sock_stream_init(SOCK_TCP_BASE(*sock_ptr), &sock_tcp_type);

   142

   143

    // invalid fds are <0

   144

    (*sock_ptr)->fd = -1;

   145

   146

    // done

   147

    return SUCCESS;

   148

}

   149

   150

err_t sock_tcp_init_fd (struct sock_tcp *sock, int fd)

   151

{

   152

    // valid fd

   153

    assert(fd >= 0);

   154

   155

    // initialize

   156

    sock->fd = fd;

   157

   158

    // done

   159

    return SUCCESS;

   160

}

   161

   162

err_t sock_tcp_init_ev (struct sock_tcp *sock, void (*ev_cb)(evutil_socket_t, short, void *), void *cb_arg)

   163

{

   164

    // require valid fd

   165

    assert(sock->fd >= 0);

   166

   167

    // this is initialization

   168

    assert(sock->ev_read == NULL && sock->ev_write == NULL);

   169

   170

    // create new event

   171

    if ((sock->ev_read = event_new(_sock_stream_ctx.ev_base, sock->fd, EV_READ, ev_cb, cb_arg)) == NULL)

   172

        return SET_ERROR(SOCK_TCP_ERR(sock), ERR_EVENT_NEW);

   173

   174

    if ((sock->ev_write = event_new(_sock_stream_ctx.ev_base, sock->fd, EV_WRITE, ev_cb, cb_arg)) == NULL)

   175

        return SET_ERROR(SOCK_TCP_ERR(sock), ERR_EVENT_NEW);

   176

   177

    // ok

   178

    return SUCCESS;

   179

}

   180

   181

void sock_tcp_deinit_ev (struct sock_tcp *sock)

   182

{

   183

    if (sock->ev_read) {

   184

        event_del(sock->ev_read);

   185

   186

        sock->ev_read = NULL;

   187

    }

   188

   189

    if (sock->ev_write) {

   190

        event_del(sock->ev_write);

   191

   192

        sock->ev_write = NULL;

   193

    }

   194

}

   195

   196

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

   197

{

   198

    // must not be set already

   199

    assert(sock->fd < 0);

   200

   201

    // call socket

   202

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

   203

        RETURN_SET_ERROR_ERRNO(err, ERR_SOCKET);

   204

   205

    // ok

   206

    return SUCCESS;

   207

}

   208

   209

err_t sock_tcp_add_event (struct sock_tcp *sock, short mask)

   210

{

   211

    // just add the appropraite events

   212

    if (mask & EV_READ && event_add(sock->ev_read, NULL))

   213

        return SET_ERROR(SOCK_TCP_ERR(sock), ERR_EVENT_ADD);

   214

   215

    if (mask & EV_WRITE && event_add(sock->ev_write, NULL))

   216

        return SET_ERROR(SOCK_TCP_ERR(sock), ERR_EVENT_ADD);

   217

   218

    // done

   219

    return SUCCESS;

   220

}

   221

   222

/**

   223

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

   224

 */

   225

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

   226

{

   227

    // no more addresses left?

   228

    if (!addr)

   229

        // XXX: rename error

   230

        return SET_ERROR(err, ERR_GETADDRINFO_EMPTY);

   231

   232

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

   233

    do {

   234

        // attempt to start connect

   235

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

   236

            break;

   237

   238

        // try the next one

   239

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

   240

   241

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

   242

   243

   244

    if (addr) {

   245

        // we succesfully did a sock_tcp_connect_async_addr on valid address

   246

        return SUCCESS;

   247

   248

    } else {

   249

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

   250

        return ERROR_CODE(err);

   251

    }

   252

}

   253

   254

/**

   255

 * Our async connect operation has completed, clean up addrinfos and events, and call the user callback. The given

   256

 * \a err should be NULL for successful completion, or the error for unsuccesfully completion.

   257

 */

   258

static void sock_tcp_connect_async_done (struct sock_tcp *sock, struct error_info *err)

   259

{

   260

    // free the addrinfo

   261

    freeaddrinfo(sock->async_res); 

   262

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

   263

   264

    // remove our event handler so the user can install their own

   265

    sock_tcp_deinit_ev(sock);

   266

   267

    // ok, run callback

   268

    SOCK_TCP_BASE(sock)->conn_cb_func(SOCK_TCP_BASE(sock), err, SOCK_TCP_BASE(sock)->conn_cb_arg);

   269

}

   270

   271

/**

   272

 * Our start_connect callback

   273

 */

   274

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

   275

{

   276

    struct sock_tcp *sock = arg;

   277

    int optval;

   278

    socklen_t optlen;

   279

    struct error_info err;

   280

    err_t tmp;

   281

   282

    // XXX: timeouts

   283

    (void) what;

   284

   285

    // read error code

   286

    if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &optval, &optlen))

   287

        JUMP_SET_ERROR_ERRNO(&err, ERR_GETSOCKOPT);

   288

   289

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

   290

    if (optlen != sizeof(optval))

   291

        JUMP_SET_ERROR_EXTRA(&err, ERR_GETSOCKOPT, EINVAL);

   292

   293

    // did the connect complete succesfully or not?

   294

    if (optval)

   295

        JUMP_SET_ERROR_EXTRA(&err, ERR_CONNECT, optval);

   296

   297

    // done

   298

    return sock_tcp_connect_async_done(sock, NULL);

   299

   300

error:

   301

    // close the socket

   302

    if ((tmp = sock_tcp_close(sock)))

   303

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

   304

   305

    // log a warning

   306

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

   307

   308

    // try the next one or fail completely

   309

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

   310

        sock_tcp_connect_async_done(sock, &err);

   311

}

   312

   313

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

   314

{

   315

    int ret;

   316

    err_t tmp;

   317

   318

    // first, create the socket

   319

    if (sock_tcp_init_socket(sock, addr, err))

   320

        return ERROR_CODE(err);

   321

   322

    // then, set it up as nonblocking

   323

    if ((ERROR_CODE(err) = sock_tcp_set_nonblock(sock, true)))

   324

        goto error;

   325

   326

    // then, initiate the connect

   327

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

   328

        JUMP_SET_ERROR_ERRNO(err, ERR_CONNECT);

   329

   330

    if (ret < 0) {

   331

        // ok, connect started, setup our completion callback

   332

        if ((ERROR_CODE(err) = sock_tcp_init_ev(sock, &sock_tcp_connect_cb, sock)))

   333

            goto error;

   334

   335

        // enable for write

   336

        if ((ERROR_CODE(err) = sock_tcp_add_event(sock, EV_WRITE)))

   337

            goto error;

   338

   339

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

   340

        sock->async_cur = addr;

   341

   342

    } else {

   343

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

   344

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

   345

        JUMP_SET_ERROR_EXTRA(err, ERR_CONNECT, EINPROGRESS);

   346

    }

   347

   348

    // ok

   349

    return SUCCESS;

   350

   351

error:

   352

    // close the stuff we did open

   353

    if ((tmp = sock_tcp_close(sock)))

   354

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

   355

   356

    return ERROR_CODE(err);

   357

}

   358

   359

err_t sock_tcp_connect_async_begin (struct sock_tcp *sock, const char *hostname, const char *service, struct error_info *err)

   360

{

   361

    struct addrinfo hints;

   362

    int ret;

   363

   364

    // hints

   365

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

   366

    hints.ai_family = AF_UNSPEC;

   367

    hints.ai_socktype = SOCK_STREAM;

   368

   369

    // resolve

   370

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

   371

        RETURN_SET_ERROR_EXTRA(err, ERR_GETADDRINFO, ret);

   372

   373

    // start connecting

   374

    return sock_tcp_connect_async_continue(sock, sock->async_res, err);

   375

}

   376

   377

err_t sock_tcp_connect_blocking (struct sock_tcp *sock, const char *hostname, const char *service, struct error_info *err)

   378

{

   379

    struct addrinfo hints, *res, *r;

   380

    int ret;

   381

   382

    // zero error code

   383

    RESET_ERROR(err);

   384

   385

    // hints

   386

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

   387

    hints.ai_family = AF_UNSPEC;

   388

    hints.ai_socktype = SOCK_STREAM;

   389

   390

    // resolve

   391

    if ((ret = getaddrinfo(hostname, service, &hints, &res)))

   392

        RETURN_SET_ERROR_EXTRA(err, ERR_GETADDRINFO, ret);

   393

   394

    // try each result in turn

   395

    for (r = res; r; r = r->ai_next) {

   396

        // create the socket

   397

        if ((sock->fd = socket(r->ai_family, r->ai_socktype, r->ai_protocol)) < 0) {

   398

            // remember error

   399

            SET_ERROR_ERRNO(err, ERR_SOCKET);

   400

   401

            // skip to next one

   402

            continue;

   403

        }

   404

   405

        // connect to remote address

   406

        if (connect(sock->fd, r->ai_addr, r->ai_addrlen)) {

   407

            // remember error

   408

            SET_ERROR_ERRNO(err, ERR_CONNECT);

   409

   410

            // close/invalidate socket

   411

            close(sock->fd);

   412

            sock->fd = -1;

   413

   414

            // skip to next one

   415

            continue;

   416

        }

   417

   418

        // valid socket, use this

   419

        break;

   420

    }

   421

   422

    // ensure we got some valid socket, else return last error code

   423

    if (sock->fd < 0) {

   424

        // did we hit some error?

   425

        if (IS_ERROR(err))

   426

            // return last error

   427

            return ERROR_CODE(err);

   428

   429

        else

   430

            // no results

   431

            return SET_ERROR(err, ERR_GETADDRINFO_EMPTY);

   432

    }

   433

   434

    // ok, done

   435

    return 0;    

   436

}

   437

   438

err_t sock_tcp_set_nonblock (struct sock_tcp *sock, bool nonblock)

   439

{

   440

    // fcntl it

   441

    // XXX: maintain old flags?

   442

    if (fcntl(sock->fd, F_SETFL, nonblock ? O_NONBLOCK : 0) < 0)

   443

        RETURN_SET_ERROR_ERRNO(SOCK_TCP_ERR(sock), ERR_FCNTL);

   444

   445

    // ok

   446

    return SUCCESS;

   447

}

   448

   449

err_t sock_tcp_close (struct sock_tcp *sock)

   450

{

   451

    struct error_info *err = SOCK_TCP_ERR(sock);

   452

   453

    // no errors yet

   454

    RESET_ERROR(err);

   455

   456

    // must be connected

   457

    assert(sock->fd >= 0);

   458

   459

    // kill any events

   460

    sock_tcp_deinit_ev(sock);

   461

   462

    // close the socket itself

   463

    if (close(sock->fd))

   464

        SET_ERROR_ERRNO(err, ERR_CLOSE);

   465

   466

    // invalidate

   467

    sock->fd = -1;

   468

   469

    return ERROR_CODE(err);

   470

}

   471

   472

void sock_tcp_free (struct sock_tcp *sock)

   473

{

   474

    // must not be connected

   475

    assert(sock->fd < 0);

   476

   477

    // free

   478

    free(sock);

   479

}

   480

   481

err_t sock_tcp_connect (struct sock_stream **sock_ptr, const char *host, const char *service, struct error_info *err)

   482

{

   483

    struct sock_tcp *sock;

   484

   485

    // allocate

   486

    if ((ERROR_CODE(err) = sock_tcp_alloc(&sock)))

   487

        return ERROR_CODE(err);

   488

   489

    // connect    

   490

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

   491

        goto error;

   492