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

    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;

    59

        } else {

    60

            // EOF!

    61

            return SET_ERROR(SOCK_TEST_ERR(sock), ERR_READ_EOF);

    62

        }

    63

    }

    85

        buf->read_vec++;

   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;

   112

    buf->write_vec++;

   120

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

   121

   122

    // set the nonblocking flag

   123

    sock->nonblocking = true;

   124

   130

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

   131

   137

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

   139

    sock_test_destroy(sock);

   169

void sock_test_destroy (struct sock_test *sock)

   171

    size_t i;

   172

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

   173

   174

    // free the send buffer

   175

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

   176

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

   177

    }

   178

   179

    // free the buffer vector lists

   180

    free(sbuf->vecs);

   181

    free(rbuf->vecs);

   182

   183

    // free the sock itself

   184

    free(sock);

   185

}

   186

   187

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

   188

{

   189

    struct io_buf *buf = &sock->recv_buf;

   190

   191

    // allocate + copy

   192

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

   193

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

   194

   195

    // set

   196

    buf->count = count;

   197

    buf->read_vec = buf->vecs;

   198

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

   199

    buf->off = 0;

   200

   201

    // set EOF flag?

   202

    if (eof)

   203

        sock->eof = true;

   204

}

   205

   206

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

   207

{

   208

    struct io_buf *buf = &sock->recv_buf;

   209

   210

    // ensure there's room

   211

    assert(sock_test_grow_buf(buf) == SUCCESS);

   212

   213

    // copy    

   214

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