1

     2

#include "sock_tcp.h"

     3

     4

#include <stdlib.h>

     5

#include <sys/types.h>

     6

#include <sys/socket.h>

     7

#include <netdb.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

    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

/*

   113

 * Our sock_stream_type

   114

 */

   115

struct sock_stream_type sock_tcp_type = {

   122

};

   123

   124

err_t sock_tcp_alloc (struct sock_tcp **sock_ptr)

   125

{

   126

    // alloc

   127

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

   128

        return ERR_CALLOC;

   129

   130

    // initialize base with sock_tcp_type

   131

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

   132

   133

    // invalid fds are <0

   134

    (*sock_ptr)->fd = -1;

   135

   136

    // done

   137

    return SUCCESS;

   138

}

   139

   140

err_t sock_tcp_init_fd (struct sock_tcp *sock, int fd)

   141

{

   142

    // valid fd -XXX: err instead?

   143

    assert(fd >= 0);

   144

   145

    // initialize

   146

    sock->fd = fd;

   147

   148

    // done

   149

    return SUCCESS;

   150

}

   151

   152

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

   153

{

   154

    // require valid fd

   155

    assert(sock->fd >= 0);

   156

   157

    // this is initialization

   158

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

   159

   160

    // create new event

   161

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

   162

        return SET_ERROR(SOCK_TCP_ERR(sock), ERR_EVENT_NEW);

   163

   164

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

   165

        return SET_ERROR(SOCK_TCP_ERR(sock), ERR_EVENT_NEW);

   166

   167

    // ok

   168

    return SUCCESS;

   169

}

   170

   171

err_t sock_tcp_add_event (struct sock_tcp *sock, short mask)

   172

{

   173

    // just add the appropraite events

   174

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

   175

        return SET_ERROR(SOCK_TCP_ERR(sock), ERR_EVENT_ADD);

   176

   177

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

   178

        return SET_ERROR(SOCK_TCP_ERR(sock), ERR_EVENT_ADD);

   179

   180

    // done

   181

    return SUCCESS;

   182

}

   183

   184

err_t sock_tcp_init_connect (struct sock_tcp *sock, const char *hostname, const char *service)

   185

{

   186

    struct addrinfo hints, *res, *r;

   187

    int err;

   188

    RESET_ERROR(SOCK_TCP_ERR(sock));

   189

   190

    // hints

   191

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

   192

    hints.ai_family = AF_UNSPEC;

   193

    hints.ai_socktype = SOCK_STREAM;

   194

   195

    // resolve

   196

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

   197

        RETURN_SET_ERROR_EXTRA(SOCK_TCP_ERR(sock), ERR_GETADDRINFO, err);

   198

   199

    // try each result in turn

   200

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

   201

        // create the socket

   202

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

   203

            // remember error

   204

            SET_ERROR_ERRNO(SOCK_TCP_ERR(sock), ERR_SOCKET);

   205

   206

            // skip to next one

   207

            continue;

   208

        }

   209

   210

        // connect to remote address

   211

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

   212

            // remember error

   213

            SET_ERROR_ERRNO(SOCK_TCP_ERR(sock), ERR_CONNECT);

   214

   215

            // close/invalidate socket

   216

            close(sock->fd);

   217

            sock->fd = -1;

   218

   219

            // skip to next one

   220

            continue;

   221

        }

   222

   223

        // valid socket, use this

   224

        break;

   225

    }

   226

   227

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

   228

    if (sock->fd < 0) {

   229

        // did we hit some error?

   230

        if (IS_ERROR(SOCK_TCP_ERR(sock)))

   231

            // return last error

   232

            return ERROR_CODE(SOCK_TCP_ERR(sock));

   233

   234

        else

   235

            // no results

   236

            return SET_ERROR(SOCK_TCP_ERR(sock), ERR_GETADDRINFO_EMPTY);

   237

    }

   238

   239

    // ok, done

   240

    return 0;    

   241

}

   242

   243

err_t sock_tcp_set_nonblock (struct sock_tcp *sock, int nonblock)

   244

{

   245

    // fcntl it

   246

    // XXX: maintain old flags?

   247

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

   248

        RETURN_SET_ERROR_ERRNO(SOCK_TCP_ERR(sock), ERR_FCNTL);

   249

   250

    // ok

   251

    return SUCCESS;

   252

}

   253

   254

void sock_tcp_release (struct sock_tcp *sock)

   255

{

   256

    // must not be connected

   257

    assert(sock->fd < 0);

   258

   259

    // free

   260

    free(sock);

   261

}

   262

   263

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

   264

{

   265

    struct sock_tcp *sock;

   266

    err_t err;

   267

   268

    // allocate

   269

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

   270

        return err;

   271

   272

    // connect

   273

    if ((err = sock_tcp_init_connect(sock, host, service))) {

   274

        // copy error_info

   275

        SET_ERROR_INFO(err_info, sock_stream_error(SOCK_TCP_BASE(sock)));

   276

   277

        // cleanup

   278

        sock_tcp_release(sock);

   279

   280

        // return error code

   281

        return err;

   282

    }

   283

   284

    // good

   285

    *sock_ptr = SOCK_TCP_BASE(sock);

   286

   287

    return 0;

   288

}

   289

   290