1

#include "sock_test.h"

     2

     3

#include <stdlib.h>

     4

#include <string.h>

     5

#include <assert.h>

     6

     7

/**

     8

 * Grow buf->vecs as needed, to ensure that buf->write_vec is valid

     9

 */

    10

static err_t sock_test_grow_buf (struct io_buf *buf)

    11

{

    12

    size_t read_vec_offset = buf->read_vec ? (buf->read_vec - buf->vecs) : 0;

    13

    size_t write_vec_offset = buf->write_vec ? (buf->write_vec - buf->vecs) : 0;

    14

    struct io_vec *v;

    15

    struct io_vec *vecs_tmp = buf->vecs;

    16

    17

    // don't grow if not full

    18

    if (buf->vecs && buf->write_vec < buf->vecs + buf->count)

    19

        return SUCCESS;

    20

    21

    // new size

    22

    buf->count = buf->count * 2 + 1;

    23

    24

    // grow

    25

    if ((buf->vecs = realloc(buf->vecs, buf->count * sizeof(struct io_vec))) == NULL) {

    26

        // restore old value

    27

        buf->vecs = vecs_tmp;

    28

    29

        return ERR_CALLOC;

    30

    }

    31

    32

    // set vec

    33

    buf->write_vec = buf->vecs + write_vec_offset;

    34

    buf->read_vec = buf->vecs + read_vec_offset;

    35

    36

    // zero new vecs

    37

    for (v = buf->write_vec; v < buf->vecs + buf->count; v++) {

    38

        v->buf = NULL;

    39

        v->len = 0;

    40

    }

    41

    42

    // ok

    43

    return SUCCESS;

    44

}

    45

    46

static err_t sock_test_read (struct sock_stream *base_sock, void *buf_ptr, size_t *len)

    47

{

    48

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

    49

    struct io_buf *buf = &sock->recv_buf;

    50

    struct io_vec *vec = buf->read_vec;

    51

    52

    // EOF/nonblock if we're past the end of the last vector

    53

    if (!vec || vec == buf->vecs + buf->count || buf->off >= vec->len) {

    54

        if (sock->nonblocking && !sock->eof) {

    55

            // wait for more to be fed in

    56

            *len = 0;

    57

            return SUCCESS;

    58

    59

        } else {

    60

            // EOF!

    61

            return SET_ERROR(SOCK_TEST_ERR(sock), ERR_READ_EOF);

    62

        }

    63

    }

    64

    65

    // amount of data available in this iovec

    66

    size_t available = vec->len - buf->off;

    67

    68

    // amount to read

    69

    size_t to_read = *len;

    70

    71

    // trim down?

    72

    if (to_read > available)

    73

        to_read = available;

    74

    75

    // copy

    76

    memcpy(buf_ptr, vec->buf + buf->off, to_read);

    77

    78

    // consumed the whole vec?

    79

    if (to_read < available) {

    80

        // move offset

    81

        buf->off += to_read;

    82

    83

    } else {

    84

        // next vector

    85

        buf->read_vec++;

    86

    }

    87

    88

    // update len

    89

    *len = to_read;

    90

    91

    // ok

    92

    return SUCCESS;

    93

}

    94

    95

static err_t sock_test_write (struct sock_stream *base_sock, const void *buf_ptr, size_t *len)

    96

{

    97

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

    98

    struct io_buf *buf = &sock->send_buf;

    99

   100

    // ensure there's room

   101

    assert(sock_test_grow_buf(buf) == SUCCESS);

   102

   103

    // the next buffer

   104

    struct io_vec *vec = buf->write_vec;

   105

   106

    // store

   107

    vec->len = *len;

   108

    assert((vec->buf = malloc(vec->len)));

   109

    memcpy(vec->buf, buf_ptr, vec->len);

   110

   111

    // move vec onwards

   112

    buf->write_vec++;

   113

   114

    // ok

   115

    return SUCCESS;

   116

}

   117

   118

static err_t sock_test_event_init (struct sock_stream *base_sock)

   119

{

   120

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

   121

   122

    // set the nonblocking flag

   123

    sock->nonblocking = true;

   124

   125

    return SUCCESS;

   126

}

   127

   128

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

   129

{

   130

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

   131

   132

    // store mask

   133

    sock->ev_mask = mask;

   134

   135

    return SUCCESS;

   136

}

   137

   138

static void sock_test_release (struct sock_stream *base_sock)

   139

{

   140

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

   141

   142

    sock_test_destroy(sock);

   143

}

   144

   145

/*

   146

 * Our sock_stream_type

   147

 */

   148

static struct sock_stream_type sock_test_type = {

   149

    .methods                = {

   150

        .read               = &sock_test_read,

   151

        .write              = &sock_test_write,

   152

        .event_init         = &sock_test_event_init,

   153

        .event_enable       = &sock_test_event_enable,

   154

        .release            = &sock_test_release,

   155

    },

   156

};

   157

   158

struct sock_test* sock_test_create (void)

   159

{

   160

    struct sock_test *sock;

   161

   162

    // allocate

   163

    assert((sock = calloc(1, sizeof(*sock))));

   164

   165

    // initialize base with our sock_stream_type

   166

    sock_stream_init(SOCK_TEST_BASE(sock), &sock_test_type);

   167

   168

    // ok

   169

    return sock;

   170

}

   171

   172

void sock_test_destroy (struct sock_test *sock)

   173

{

   174

    size_t i;

   175

    struct io_buf *sbuf = &sock->send_buf, *rbuf = &sock->recv_buf;

   176

   177

    // free the send buffer

   178

    for (i = 0; i < sbuf->count; i++) {

   179

        free(sbuf->vecs[i].buf);

   180

    }

   181

   182

    // free the buffer vector lists

   183

    free(sbuf->vecs);

   184

    free(rbuf->vecs);

   185

   186

    // free the sock itself

   187

    free(sock);

   188

}

   189

   190

void sock_test_set_recv_buffer (struct sock_test *sock, struct io_vec *vecs, size_t count, bool eof)

   191

{

   192

    struct io_buf *buf = &sock->recv_buf;

   193

   194

    // allocate + copy

   195

    assert((buf->vecs = calloc(count, sizeof(struct io_vec))));

   196

    memcpy(buf->vecs, vecs, count * sizeof(struct io_vec));

   197

   198

    // set

   199

    buf->count = count;

   200

    buf->read_vec = buf->vecs;

   201

    buf->write_vec = buf->vecs + count;

   202

    buf->off = 0;

   203

   204

    // set EOF flag?

   205

    if (eof)

   206

        sock->eof = true;

   207

}

   208

   209

void sock_test_add_recv_vec (struct sock_test *sock, struct io_vec new_vec)

   210

{

   211

    struct io_buf *buf = &sock->recv_buf;

   212

   213

    // ensure there's room

   214

    assert(sock_test_grow_buf(buf) == SUCCESS);

   215

   216

    // copy    

   217

    *(buf->write_vec++) = new_vec;

   218

   219

    // notify events?

   220

    if (sock->ev_mask) {

   221

        int mask = sock->ev_mask;

   222

        sock->ev_mask = 0;

   223

   224

        sock_stream_invoke_callbacks(SOCK_TEST_BASE(sock), mask);

   225

    }

   226

}

   227

   237

void sock_test_get_send_data (struct sock_test *sock, char **buf_ptr, size_t *len_ptr)

   238

{

   239

    struct io_buf *buf = &sock->send_buf;

   240

    size_t len = 0, i, off = 0;

   241

    char *out;

   242

   243

    // calculate total size

   244

    for (i = 0; i < buf->count; i++) {

   245

        len += buf->vecs[i].len;

   246

    }

   247

   248

    // alloc

   249

    assert((out = malloc(len)));

   250

   251

    // copy

   252

    for (i = 0; i < buf->count; i++) {

   261

    }

   262

   263

    // update return

   264

    *buf_ptr = out;

   265

    *len_ptr = len;

   269

}

   270