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