1

#include "sock_test.h"

     2

     3

#include <stdlib.h>

     4

#include <string.h>

     5

#include <assert.h>

     6

     7

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

     8

{

     9

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

    10

    struct io_buf *buf = &sock->recv_buf;

    11

    struct io_vec *vec = buf->vec;

    12

    13

    // no current vector -> EOF

    14

    if (!vec)

    15

        return ERR_READ_EOF;

    16

    17

    // vector past the end -> EOF

    18

    if (vec == &buf->vecs[buf->count])

    19

        return ERR_READ_EOF;

    20

    21

    // no data left in current vector -> EOF

    22

    if (buf->off >= vec->len)

    23

        return ERR_READ_EOF;

    24

    25

    // amount of data available in this iovec

    26

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

    27

    28

    // amount to read

    29

    size_t to_read = *len;

    30

    31

    // trim down?

    32

    if (to_read > available)

    33

        to_read = available;

    34

    35

    // copy

    36

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

    37

    38

    // consumed the whole vec?

    39

    if (to_read < available) {

    40

        // move offset

    41

        buf->off += to_read;

    42

    43

    } else {

    44

        // next vector

    45

        buf->vec++;

    46

    }

    47

    48

    // update len

    49

    *len = to_read;

    50

    51

    // ok

    52

    return SUCCESS;

    53

}

    54

    55

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

    56

{

    57

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

    58

    struct io_buf *buf = &sock->send_buf;

    59

    struct io_vec *vec = buf->vec;

    60

    61

    // vectors full?

    62

    if (buf->vecs == NULL || vec == &buf->vecs[buf->count]) {

    63

        size_t vec_offset = vec ? (vec - buf->vecs) : 0;

    64

        struct io_vec *v;

    65

    66

        // new size

    67

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

    68

    69

        // grow

    70

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

    71

    72

        // set vec

    73

        vec = buf->vec = buf->vecs + vec_offset;

    74

    75

        // zero

    76

        for (v = vec; v < &buf->vecs[buf->count]; v++) {

    77

            v->buf = NULL;

    78

            v->len = 0;

    79

        }

    80

    }

    81

    82

    // store

    83

    vec->len = *len;

    84

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

    85

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

    86

    87

    // move vec onwards

    88

    buf->vec++;

    89

    90

    // ok

    91

    return SUCCESS;

    92

}

    93

    94

static err_t sock_test_event_init (struct sock_stream *base_sock)

    95

{

    96

    97

    return SUCCESS;

    98

}

    99

   100

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

   101

{

   102

   103

    return SUCCESS;

   104

}

   105

   106

static void sock_test_release (struct sock_stream *base_sock)

   107

{

   108

   109

}

   110

   111

/*

   112

 * Our sock_stream_type

   113

 */

   114

static struct sock_stream_type sock_test_type = {

   115

    .methods                = {

   116

        .read               = &sock_test_read,

   117

        .write              = &sock_test_write,

   118

        .event_init         = &sock_test_event_init,

   119

        .event_enable       = &sock_test_event_enable,

   120

        .release            = &sock_test_release,

   121

    },

   122

};

   123

   124

struct sock_test* sock_test_create (void)

   125

{

   126

    struct sock_test *sock;

   127

   128

    // allocate

   129

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

   130

   131

    // initialize base with our sock_stream_type

   132

    sock_stream_init(SOCK_TEST_BASE(sock), &sock_test_type);

   133

   134

    // ok

   135

    return sock;

   136

}

   137

   138

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

   139

{

   140

    sock->recv_buf.vecs = vecs;

   141

    sock->recv_buf.count = count;

   142

    sock->recv_buf.vec = vecs;

   143

    sock->recv_buf.off = 0;

   144

}

   145

   146

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

   147

{

   148

    struct io_buf *buf = &sock->send_buf;

   149

    size_t len = 0, i, off = 0;

   150

    char *out;

   151

   152

    // calculate total size

   153

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

   154

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

   155

    }

   156

   157

    // alloc

   158

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

   159

   160

    // copy

   161

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

   162

        memcpy(out + off, buf->vecs[i].buf, buf->vecs[i].len);

   163

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

   164

    }

   165

   166

    // update return

   167

    *buf_ptr = out;

   168

    *len_ptr = len;

   169

}

   170