1

#include "transport_internal.h"

     2

     3

#include <assert.h>

     4

     5

/*

     6

 * Internal API

     7

 */

     8

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

     9

{

    10

    // not already bound

    11

    assert(!transport->type);

    12

    13

    // store

    14

    transport->type = type;

    15

    16

    if (info)

    17

        transport->info = *info;

    18

}

    19

    20

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

    21

{

    22

    const struct transport_type *tp_type;

    23

    24

    // sanity check

    25

    assert(type);

    26

    27

    // look for a matching type in the transport's type list

    28

    for (tp_type = transport->type; tp_type; tp_type = tp_type->parent)

    29

        if (tp_type == type)

    30

            break;

    31

    32

    // make sure we found one

    33

    assert(tp_type);

    34

    35

    // ok

    36

    return transport;

    37

}

    38

    39

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

    40

{

    41

    // update state

    42

    transport->connected = true;

    43

    44

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

    45

        // user callback

    46

        if (err)

    47

            // connect failed

    48

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

    49

        else

    50

            // connect succesfull

    51

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

    52

    53

    } else {

    54

        // wrapper method

    55

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

    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

    // not readable

    86

    if (!transport->type->methods.read)

    87

        return SET_ERROR(err, -1);

    88

    89

    // proxy off to method handler

    90

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

    91

        return -ERROR_CODE(err);

    92

    94

    return len;

    95

}

    96

    97

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

    98

{

    99

    // XXX: not writeable

   100

    if (!transport->type->methods.write)

   101

        return SET_ERROR(err, -1);

   102

   103

    // proxy off to method handler

   104

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

   105

        return -ERROR_CODE(err);

   106

   108

    return len;

   109

}

   110

   111

err_t transport_events (transport_t *transport, short mask)

   112

{

   113

    error_t err;

   114

   115

    // notify transport

   116

    if (transport->type->methods.events) {

   117

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

   118

            goto error;

   119

    }

   120

   121

    // update the event mask

   122

    transport->info.ev_mask = mask;

   123

   124

    // ok

   125

    return SUCCESS;

   126

   127

error:

   128

    return ERROR_CODE(&err);

   129

}

   130

   131

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

   132

{

   133

    transport->info.cb_tbl = cb_tbl;

   134

    transport->info.cb_arg = cb_arg;

   135

}

   136

   137

void transport_destroy (transport_t *transport)

   138

{

   139

    // destroy the transport-specific stuff

   140

    if (transport->type->methods.destroy)

   141

        transport->type->methods.destroy(transport);

   142

   143

    // then the transport itself

   144

    free(transport);

   145

}

   146