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

    // update state

    39

    transport->connected = true;

    40

    41

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

    42

        // user callback

    43

        if (err)

    44

            // connect failed

    45

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

    46

        else

    47

            // connect succesfull

    48

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

    49

    50

    } else {

    51

        // wrapper method

    52

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

    53

    }

    54

}

    55

    56

void transport_invoke (transport_t *transport, short what)

    57

{

    58

    // on_ready

    59

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

    60

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

    61

    62

    // on_write

    63

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

    64

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

    65

    66

}

    67

    68

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

    69

{

    70

    // update state

    71

    transport->connected = false;

    72

    73

    // invoke callback

    74

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

    75

}

    76

    77

/*

    78

 * Public API

    79

 */

    80

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

    81

{

    82

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

    83

    84

    // not readable

    85

    if (!type->methods.read)

    86

        return SET_ERROR(err, -1);

    87

    88

    // proxy off to method handler

    89

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

    90

        return -ERROR_CODE(err);

    91

    92

    // return updated 'bytes-read' len

    93

    return len;

    94

}

    95

    96

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

    97

{

    98

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

    99

   100

    // XXX: not writeable

   101

    if (!type->methods.write)

   102

        return SET_ERROR(err, -1);

   103

   104

    // proxy off to method handler

   105

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

   106

        return -ERROR_CODE(err);

   107

   108

    // return updated 'bytes-written' len

   109

    return len;

   110

}

   111

   112

err_t transport_events (transport_t *transport, short mask)

   113

{

   114

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

   115

    error_t err;

   116

   117

    // notify transport

   118

    if (type->methods.events) {

   119

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

   120

            goto error;

   121

    }

   122

   123

    // update the event mask

   124

    transport->info.ev_mask = mask;

   125

   126

    // ok

   127

    return SUCCESS;

   128

   129

error:

   130

    return ERROR_CODE(&err);

   131

}

   132

   133

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

   134

{

   135

    transport->info.cb_tbl = cb_tbl;

   136

    transport->info.cb_arg = cb_arg;

   137

}

   138

   139

void transport_destroy (transport_t *transport)

   140

{

   141

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

   142

   143

    // destroy the transport-specific stuff

   144

    if (type->methods.deinit)

   145

        type->methods.deinit(transport);

   146

   147

    // then the transport itself

   148

    free(transport);

   149

}

   150