1

#include "sock_fd.h"

     2

     3

#include <fcntl.h>

     4

#include <unistd.h>

     5

#include <assert.h>

     6

     7

void sock_fd_event_handler (evutil_socket_t fd, short what, void *arg) 

     8

{

     9

    struct sock_fd *sock = arg;

    10

    11

    (void) fd;

    12

    13

    // invoke appropriate callback

    14

    sock_stream_invoke_callbacks(SOCK_FD_BASE(sock), what);

    15

}

    16

    17

err_t sock_fd_read (struct sock_stream *base_sock, void *buf, size_t *len, struct error_info *err)

    18

{

    19

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

    20

    int ret;

    21

    22

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

    23

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

    24

        // unexpected error

    25

        RETURN_SET_ERROR_ERRNO(err, ERR_READ);

    26

    27

    else if (ret == 0)

    28

        // EOF

    29

        return SET_ERROR(err, ERR_READ_EOF);

    30

    31

    32

    if (ret < 0) {

    33

        // EAGAIN -> zero bytes

    34

        *len = 0;

    35

    36

    } else {

    37

        // normal -> bytes read

    38

        *len = ret;

    39

    }

    40

    41

    // ok

    42

    return SUCCESS;

    43

}

    44

    45

err_t sock_fd_write (struct sock_stream *base_sock, const void *buf, size_t *len, struct error_info *err)

    46

{

    47

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

    48

    int ret;

    49

    50

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

    51

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

    52

        // unexpected error

    53

        RETURN_SET_ERROR_ERRNO(err, ERR_WRITE);

    54

    55

    else if (ret == 0)

    56

        // EOF

    57

        return SET_ERROR(err, ERR_WRITE_EOF);

    58

    59

    60

    if (ret < 0) {

    61

        // EAGAIN -> zero bytes

    62

        *len = 0;

    63

    64

    } else {

    65

        // normal -> bytes read

    66

        *len = ret;

    67

    }

    68

    69

    return SUCCESS;

    70

}

    71

    72

err_t sock_fd_event_init (struct sock_stream *base_sock)

    73

{

    74

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

    75

    err_t err;

    76

    77

    // set nonblocking

    78

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

    79

        return err;

    80

    81

    // add ourselves as the event handler

    82

    if ((err = sock_fd_init_ev(sock, &sock_fd_event_handler, sock)))

    83

        return err;

    84

    85

    // done

    86

    return SUCCESS;

    87

}

    88

    89

err_t sock_fd_event_enable (struct sock_stream *base_sock, short mask)

    90

{

    91

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

    92

    93

    // implemented in sock_fd_add_event

    94

    return sock_fd_enable_events(sock, mask);

    95

}

    96

    97

void sock_fd_init (struct sock_fd *sock, int fd)

    98

{

    99

    assert(!sock->ev_read && !sock->ev_write);

   100

   101

    // initialize

   102

    sock->fd = fd;

   103

}

   104

   105

err_t sock_fd_set_nonblock (struct sock_fd *sock, bool nonblock)

   106

{

   107

    // fcntl it

   108

    // XXX: maintain old flags?

   109

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

   110

        RETURN_SET_ERROR_ERRNO(SOCK_FD_ERR(sock), ERR_FCNTL);

   111

   112

    // ok

   113

    return SUCCESS;

   114

}

   115

   116

err_t sock_fd_init_ev (struct sock_fd *sock, void (*ev_cb)(evutil_socket_t, short, void *), void *cb_arg)

   117

{

   118

    // require valid fd

   119

    assert(sock->fd >= 0);

   120

   121

    // this is initialization

   122

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

   123

   124

    // store

   125

    sock->ev_cb = ev_cb;

   126

    sock->ev_arg = cb_arg;

   127

   128

    // create new event

   129

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

   130

        return SET_ERROR(SOCK_FD_ERR(sock), ERR_EVENT_NEW);

   131

   132

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

   133

        return SET_ERROR(SOCK_FD_ERR(sock), ERR_EVENT_NEW);

   134

   135

    // ok

   136

    return SUCCESS;

   137

}

   138

   139

err_t sock_fd_enable_events (struct sock_fd *sock, short mask)

   140

{

   141

    // just add the appropraite events

   142

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

   143

        return SET_ERROR(SOCK_FD_ERR(sock), ERR_EVENT_ADD);

   144

   145

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

   146

        return SET_ERROR(SOCK_FD_ERR(sock), ERR_EVENT_ADD);

   147

   148

    // done

   149

    return SUCCESS;

   150

}

   151

   152

static void sock_fd_free_ev (struct sock_fd *sock)

   153

{

   154

    if (sock->ev_read) {

   155

        event_free(sock->ev_read);

   156

   157

        sock->ev_read = NULL;

   158

    }

   159

   160

    if (sock->ev_write) {

   161

        event_free(sock->ev_write);

   162

   163

        sock->ev_write = NULL;

   164

    }

   165

}

   166

   167

void sock_fd_deinit_ev (struct sock_fd *sock)

   168

{

   169

    sock_fd_free_ev(sock);

   170

    sock->ev_cb = NULL;

   171

    sock->ev_arg = NULL;

   172

}

   173

   174

err_t sock_fd_set (struct sock_fd *sock, int fd)

   175

{

   176

    // close the old one?

   177

    if (sock->fd >= 0)

   178

        // XXX: warn on errors

   179

        close(sock->fd);

   180

   181

    // remove any old events

   182

    sock_fd_free_ev(sock);

   183

   184

    // set the new one

   185

    sock->fd = fd;

   186

   187

    // restore them

   188

    if (sock->ev_cb)

   189

        return sock_fd_init_ev(sock, sock->ev_cb, sock->ev_arg);

   190

   191

    // ok

   192

    return SUCCESS;

   193

}

   194

   195

err_t sock_fd_close (struct sock_fd *sock)

   196

{

   197

    struct error_info *err = SOCK_FD_ERR(sock);

   198

   199

    // no errors yet

   200

    RESET_ERROR(err);

   201

   202

    // must be connected

   203

    assert(sock->fd >= 0);

   204

   205

    // kill any events

   206

    sock_fd_deinit_ev(sock);

   207

   208

    // close the socket itself

   209

    if (close(sock->fd))

   210

        SET_ERROR_ERRNO(err, ERR_CLOSE);

   211

   212

    // invalidate

   213

    sock->fd = -1;

   214

   215

    return ERROR_CODE(err);

   216

}

   217