1

#include "transport_test.h"

     2

#include "transport_internal.h"

     6

#include <stdio.h>

     7

#include <stdarg.h>

    11

 * Simple IO vector

    13

struct io_vec {

    14

    /** The buffer */

    15

    char *buf;

    16

    17

    /** Buffer size */

    18

    size_t len;

    19

};

    20

    21

/**

    22

 * Simple vectored IO-buffer

    23

 */

    24

struct io_buf {

    25

    /** The array of buffer-vectors, {NULL}-terminated */

    26

    struct io_vec *vecs;

    27

    28

    /** The number of io_vecs */

    29

    size_t count;

    30

    31

    /** Current read/write vector */

    32

    struct io_vec *read_vec, *write_vec;

    33

    34

    /** Offset into current vector */

    35

    size_t off;

    36

};

    37

    38

/**

    39

 * Forward-declare our transport_type

    40

 */

    41

extern const struct transport_type transport_test_type;

    42

    43

    44

/**

    45

 * A dummy sock_stream implementation intended for testing purposes.

    46

 */

    47

struct transport_test {

    48

    /** The base transport stuff */

    49

    struct transport base;

    50

    51

    /** The send/recieve buffers */

    52

    struct io_buf send_buf, recv_buf;

    53

    54

    /** No more data is going to be added, return EOF once all the rest is consumed */

    55

    bool eof;

    56

};

    57

    58

/**

    59

 * Get a transport pointer from a transport_test pointer

    60

 */

    61

#define TRANSPORT_TEST_BASE(tp_ptr) (&(tp_ptr)->base)

    62

    63

/**

    64

 * Grow buf->vecs if needed to ensure that buf->write_vec points to a valid io_vec

    65

 */

    66

static err_t io_buf_grow (struct io_buf *buf)

    88

    // restore vec positions

    93

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

    94

        memset(v, 0, sizeof(*v));

   100

/**

   101

 * Write some data to an io_buf, copying it.

   102

 */

   103

static err_t io_buf_write (struct io_buf *buf, const char *data, size_t len)

   105

    error_t err;

   106

   107

    // ensure there's room

   108

    if ((ERROR_CODE(&err) = io_buf_grow(buf)))

   109

        goto error;

   110

   111

    // the vector to use

   112

    struct io_vec *vec = buf->write_vec;

   113

   114

    // allocate

   115

    if ((vec->buf = malloc(len)) == NULL)

   116

        JUMP_SET_ERROR(&err, ERR_MEM);

   117

   118

    // store

   119

    vec->len = len;

   120

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

   121

   122

    // vec consumed

   123

    buf->write_vec++;

   124

   125

    // ok

   126

    return SUCCESS;

   127

   128

error:

   129

    return ERROR_CODE(&err);

   130

}

   131

   132

/**

   133

 * Destroy the io_buf, freeing all resources.

   134

 *

   135

 * The io_buf must not be used anymore.

   136

 */

   137

static void io_buf_destroy (struct io_buf *buf)

   138

{

   139

    size_t i;

   140

   141

    // free the io_vec buffers

   142

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

   143

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

   144

    }

   145

   146

    // free the vector list

   147

    free(buf->vecs);

   148

}

   149

   150

/**

   151

 * transport_methods::read implementation.

   152

 */

   153

static err_t transport_test_read (transport_t *transport, void *buf_ptr, size_t *len, error_t *err)

   154

{

   155

    struct transport_test *tp = transport_check(transport, &transport_test_type);

   156

    struct io_buf *buf = &tp->recv_buf;

   161

        if (!tp->eof) {

   168

            return SET_ERROR(err, ERR_EOF);

   185

   187

        // bytes still left in the vector

   191

        // consumed the whole vector

   192

        // XXX: release data?

   194

        buf->off = 0;

   204

/**

   205

 * transport_methods::write implementation.

   206

 */

   207

static err_t transport_test_write (transport_t *transport, const void *data, size_t *len, error_t *err)

   209

    struct transport_test *tp = transport_check(transport, &transport_test_type);

   211

    // write it out

   212

    // XXX: partial writes?

   213

    if ((ERROR_CODE(err) = io_buf_write(&tp->send_buf, data, *len)))

   223

static err_t transport_test_events (transport_t *transport, short mask, error_t *err)

   225

    struct transport_test *tp = transport_check(transport, &transport_test_type);

   227

    (void) tp;

   228

    (void) mask;

   229

    (void) err;

   230

   231

    // XXX: don't re-trigger anything

   232

   236

static void _transport_test_destroy (transport_t *transport)

   238

    struct transport_test *tp = transport_check(transport, &transport_test_type);

   240

    transport_test_destroy(tp);

   246

const struct transport_type transport_test_type = {

   248

        .read               = transport_test_read,

   249

        .write              = transport_test_write,

   250

        .events             = transport_test_events,

   251

        .destroy            = _transport_test_destroy

   255

struct transport_test* transport_test_create (struct transport_info *info)

   257

    struct transport_test *tp;

   260

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

   262

    // initialize base with our transport_type

   263

    transport_init(TRANSPORT_TEST_BASE(tp), &transport_test_type, info);

   266

    return tp;

   269

transport_t* transport_test_cast (struct transport_test *tp)

   271

    return TRANSPORT_TEST_BASE(tp);

   274

void transport_test_event (struct transport_test *tp, short what)

   276

    // invoke, masking out as needed

   277

    // this won't do anything if all the bits are masked out

   278

    transport_invoke(TRANSPORT_TEST_BASE(tp), what & TRANSPORT_TEST_BASE(tp)->info.ev_mask);

   281

void transport_test_push_buf (struct transport_test *tp, const char *data, size_t len)

   283

    // push it

   284

    assert(io_buf_write(&tp->recv_buf, data, len) == SUCCESS);

   285

   286

    // notify

   287

    transport_test_event(tp, TRANSPORT_READ);

   290

void transport_test_push_str (struct transport_test *tp, const char *str)

   292

    // push it

   293

    transport_test_push_buf(tp, str, strlen(str));

   296

void transport_test_push_fmt (struct transport_test *tp, const char *fmt, ...)

   298

    char buf[TRANSPORT_TEST_FMT_MAX];

   299

    size_t ret;

   300

   301

    // format

   302

    va_list vargs; va_start(vargs, fmt);

   303

    assert((ret = vsnprintf(buf, sizeof(buf), fmt, vargs)) <= sizeof(buf));

   304

    va_end(vargs);

   305

   306

    // push it

   307

    transport_test_push_buf(tp, buf, ret);

   308

}

   309

   310

void transport_test_push_eof (struct transport_test *tp)

   311

{

   312

    // update state

   313

    tp->eof = true;

   314

   315

    transport_test_event(tp, TRANSPORT_READ);

   316

}

   317

   318

void transport_test_pull_buf (struct transport_test *tp, char **buf_ptr, size_t *len_ptr)

   319

{

   320

    struct io_buf *buf = &tp->send_buf;

   352

void transport_test_destroy (struct transport_test *tp)

   353

{

   354

    // free the buffers

   355

    io_buf_destroy(&tp->send_buf);

   356

    io_buf_destroy(&tp->recv_buf);

   357

}

   358