1 #include "transport_internal.h"

     2 

     3 #include <assert.h>

     4 

     5 /**

     6  * Our own object_type

     7  */

     8 const struct object_type transport_type_type = {

     9     .parent     = NULL,

    10 };

    11 

    12 /*

    13  * Internal API

    14  */

    15 void transport_init (transport_t *transport, const struct transport_type *type, const struct transport_info *info)

    16 {

    17     // init object

    18     object_init(&transport->base_obj, &type->base_type);

    19     

    20     // store

    21     if (info)

    22         transport->info = *info;

    23 }

    24 

    25 void* transport_check (transport_t *transport, const struct transport_type *type)

    26 {

    27     // trip as a bug

    28     assert(object_check(&transport->base_obj, &type->base_type));

    29 

    30     // ok, cast via void*

    31     return transport;

    32 }

    33 

    34 void transport_connected (transport_t *transport, const error_t *err, bool direct)

    35 {

    36     const struct transport_type *type = object_type(&transport->base_obj, &transport_type_type);

    37 

    38     if (direct || !type->methods._connected) {

    39         // user callback

    40         if (err) {

    41             // connect failed

    42             transport->info.cb_tbl->on_error(transport, err, transport->info.cb_arg);

    43 

    44         } else {

    45             // update state

    46             transport->connected = true;

    47 

    48             // connect succesfull

    49             transport->info.cb_tbl->on_connect(transport, transport->info.cb_arg);

    50         }

    51 

    52     } else {

    53         // wrapper method

    54         type->methods._connected(transport, err);

    55 

    56     }

    57 }

    58 

    59 void transport_invoke (transport_t *transport, short what)

    60 {

    61     // on_ready

    62     if (what & TRANSPORT_READ && transport->info.cb_tbl->on_read)

    63         transport->info.cb_tbl->on_read(transport, transport->info.cb_arg);

    64 

    65     // on_write

    66     if (what & TRANSPORT_WRITE && transport->info.cb_tbl->on_write)

    67         transport->info.cb_tbl->on_write(transport, transport->info.cb_arg);

    68 

    69 }

    70 

    71 void transport_error (transport_t *transport, const error_t *err)

    72 {

    73     // update state

    74     transport->connected = false;

    75 

    76     // invoke callback

    77     transport->info.cb_tbl->on_error(transport, err, transport->info.cb_arg);

    78 }

    79 

    80 /*

    81  * Public API

    82  */

    83 int transport_read (transport_t *transport, void *buf, size_t len, error_t *err)

    84 {

    85     const struct transport_type *type = object_type(&transport->base_obj, &transport_type_type);

    86 

    87     // not readable

    88     if (!type->methods.read)

    89         return SET_ERROR(err, -1);

    90 

    91     // proxy off to method handler

    92     if (type->methods.read(transport, buf, &len, err))

    93         return -ERROR_CODE(err);

    94     

    95     // return updated 'bytes-read' len

    96     return len;

    97 }

    98 

    99 int transport_write (transport_t *transport, const void *buf, size_t len, error_t *err)

   100 {

   101     const struct transport_type *type = object_type(&transport->base_obj, &transport_type_type);

   102 

   103     // XXX: not writeable

   104     if (!type->methods.write)

   105         return SET_ERROR(err, -1);

   106 

   107     // proxy off to method handler

   108     if (type->methods.write(transport, buf, &len, err))

   109         return -ERROR_CODE(err);

   110 

   111     // return updated 'bytes-written' len

   112     return len;

   113 }

   114 

   115 err_t transport_events (transport_t *transport, short mask)

   116 {

   117     const struct transport_type *type = object_type(&transport->base_obj, &transport_type_type);

   118     error_t err;

   119 

   120     // notify transport

   121     if (type->methods.events) {

   122         if (type->methods.events(transport, mask, &err))

   123             goto error;

   124     }

   125 

   126     // update the event mask

   127     transport->info.ev_mask = mask;

   128 

   129     // ok

   130     return SUCCESS;

   131 

   132 error:

   133     return ERROR_CODE(&err);

   134 }

   135 

   136 void transport_set_callbacks (transport_t *transport, const struct transport_callbacks *cb_tbl, void *cb_arg)

   137 {

   138     transport->info.cb_tbl = cb_tbl;

   139     transport->info.cb_arg = cb_arg;

   140 }

   141 

   142 void transport_destroy (transport_t *transport)

   143 {

   144     const struct transport_type *type = object_type(&transport->base_obj, &transport_type_type);

   145 

   146     // destroy the transport-specific stuff

   147     if (type->methods.deinit)

   148         type->methods.deinit(transport);

   149 

   150     // then the transport itself

   151     free(transport);

   152 }

   153