1 #include "transport_test.h"

     2 #include "transport_internal.h"

     3 

     4 #include <stdlib.h>

     5 #include <string.h>

     6 #include <stdio.h>

     7 #include <stdarg.h>

     8 #include <assert.h>

     9 

    10 /**

    11  * Simple IO vector

    12  */

    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)

    67 {

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

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

    70     struct io_vec *v;

    71     struct io_vec *vecs_tmp = buf->vecs;

    72 

    73     // don't grow if not full

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

    75         return SUCCESS;

    76 

    77     // new size

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

    79 

    80     // grow

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

    82         // restore old value

    83         buf->vecs = vecs_tmp;

    84 

    85         return ERR_CALLOC;

    86     }

    87 

    88     // restore vec positions

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

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

    91 

    92     // zero new vecs

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

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

    95 

    96     // ok

    97     return SUCCESS;

    98 }

    99 

   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)

   104 {

   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;

   157     struct io_vec *vec = buf->read_vec;

   158     

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

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

   161         if (!tp->eof) {

   162             // wait for more to be fed in

   163             *len = 0;

   164             return SUCCESS;

   165 

   166         } else {

   167             // EOF!

   168             return SET_ERROR(err, ERR_EOF);

   169         }

   170     }

   171     

   172     // amount of data available in this iovec

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

   174 

   175     // amount to read

   176     size_t to_read = *len;

   177     

   178     // trim down?

   179     if (to_read > available)

   180         to_read = available;

   181 

   182     // copy

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

   184     

   185 

   186     if (to_read < available) {

   187         // bytes still left in the vector

   188         buf->off += to_read;

   189 

   190     } else {

   191         // consumed the whole vector

   192         // XXX: release data?

   193         buf->read_vec++;

   194         buf->off = 0;

   195     }

   196 

   197     // update len

   198     *len = to_read;

   199 

   200     // ok

   201     return SUCCESS;

   202 }

   203 

   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)

   208 {

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

   210 

   211     // write it out

   212     // XXX: partial writes?

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

   214         goto error;

   215     

   216     // ok

   217     return SUCCESS;

   218 

   219 error:

   220     return ERROR_CODE(err);

   221 }

   222 

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

   224 {

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

   226 

   227     (void) tp;

   228     (void) mask;

   229     (void) err;

   230     

   231     // XXX: don't re-trigger anything

   232     

   233     return SUCCESS;

   234 }

   235 

   236 static void transport_test__deinit (transport_t *transport)

   237 {

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

   239 

   240     transport_test_destroy(tp);

   241 }

   242 

   243 /*

   244  * Our sock_stream_type

   245  */

   246 const struct transport_type transport_test_type = {

   247     .base_type = {

   248         .parent     = &transport_type_type,

   249     },

   250     .methods                = {

   251         .read       = transport_test__read,

   252         .write      = transport_test__write,

   253         .events     = transport_test__events,

   254         .deinit     = transport_test__deinit

   255     },

   256 };

   257 

   258 struct transport_test* transport_test_create (struct transport_info *info)

   259 {

   260     struct transport_test *tp;

   261 

   262     // allocate

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

   264     

   265     // initialize base with our transport_type

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

   267 

   268     // ok

   269     return tp;

   270 }

   271 

   272 transport_t* transport_test_cast (struct transport_test *tp)

   273 {

   274     return TRANSPORT_TEST_BASE(tp);

   275 }

   276 

   277 void transport_test_event (struct transport_test *tp, short what)

   278 {

   279     // invoke, masking out as needed

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

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

   282 }

   283 

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

   285 {

   286     // push it

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

   288     

   289     // notify

   290     transport_test_event(tp, TRANSPORT_READ);

   291 }

   292 

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

   294 {

   295     // push it

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

   297 }

   298 

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

   300 {

   301     char buf[TRANSPORT_TEST_FMT_MAX];

   302     size_t ret;

   303 

   304     // format

   305     va_list vargs; va_start(vargs, fmt);

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

   307     va_end(vargs);

   308        

   309     // push it

   310     transport_test_push_buf(tp, buf, ret);

   311 }

   312 

   313 void transport_test_push_eof (struct transport_test *tp)

   314 {

   315     // update state

   316     tp->eof = true;

   317 

   318     transport_test_event(tp, TRANSPORT_READ);

   319 }

   320 

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

   322 {

   323     struct io_buf *buf = &tp->send_buf;

   324     size_t len = 0, i, off = 0;

   325     char *out;

   326     

   327     // calculate total size

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

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

   330     }

   331 

   332     // alloc

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

   334 

   335     // copy

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

   337         struct io_vec *vec = buf->vecs + i;

   338 

   339         memcpy(out + off, vec->buf, vec->len);

   340         off += vec->len;

   341         

   342         // zero

   343         free(vec->buf); vec->buf = NULL;

   344         vec->len = 0;

   345     }

   346     

   347     // update return

   348     *buf_ptr = out;

   349     *len_ptr = len;

   350 

   351     // update write_vec

   352     buf->write_vec = buf->vecs;

   353 }

   354 

   355 void transport_test_async_error (struct transport_test *tp, const error_t *err)

   356 {

   357     transport_error(&tp->base, err);

   358 }

   359 

   360 void transport_test_destroy (struct transport_test *tp)

   361 {

   362     // free the buffers

   363     io_buf_destroy(&tp->send_buf);

   364     io_buf_destroy(&tp->recv_buf);

   365 }

   366