1

#ifndef TRANSPORT_INTERNAL_H

     2

#define TRANSPORT_INTERNAL_H

     3

     4

/**

     5

 * @file

     6

 *

     7

 * The internal interface for transport implementations.

     8

 */ 

     9

#include "transport.h"

    10

    11

#include <stdbool.h>

    12

    13

/**

    14

 * Method table for implementation stuff.

    15

 *

    16

 * Note that it is the transport's resposibility to implement the behaviour described in transport.h

    17

 */

    18

struct transport_methods {

    19

    /** For transport_read() */

    20

    err_t (*read) (transport_t *transport, void *buf, size_t *len, error_t *err);

    21

    22

    /** For transport_write() */

    23

    err_t (*write) (transport_t *transport, const void *buf, size_t *len, error_t *err);

    24

    25

    /**

    27

     *

    28

     * The old mask is still available in transport::info::ev_mask.

    29

     */

    30

    err_t (*events) (transport_t *transport, short mask, error_t *err);

    31

    32

    /** 

    33

     * Release the transport's internal state, but not the transport itself.

    34

     *

    35

     * In other words, this should release everything inside the transport_t, but not free() the transport_t itself.

    36

     */

    37

    void (*destroy) (transport_t *transport);

    38

    39

    /**

    40

     * Used by layered transports to handle transport_connected.

    41

     *

    42

     * If this is NULL, transport_connected will call the user callback directly, otherwise, it will proxy through this.

    43

     *

    44

     * The \a err param follows the same rules as for transport_connected() - NULL for success, error info otherwise.

    45

     *

    46

     * @param transport the transport state

    47

     * @param err error info if the connect failed

    48

     */

    49

    void (*_connected) (transport_t *transport, const error_t *err);

    50

};

    51

    52

/**

    53

 * The definition of a transport type

    54

 */

    55

struct transport_type {

    56

    /** Parent type */

    57

    const struct transport_type *parent;

    58

    59

    /** Method table */

    60

    struct transport_methods methods;

    61

};

    62

    63

/**

    64

 * The base transport type

    65

 */

    66

struct transport {

    67

    /** The type info, or NULL if not yet bound */

    68

    const struct transport_type *type;

    69

    70

    /** User info */

    71

    struct transport_info info;

    72

    73

    /** Are we connected? */

    74

    bool connected;

    75

};

    76

    77

/**

    78

 * Bind the given transport to the given type with the given user info.

    79

 *

    80

 * \a info may be given as NULL to not have any callbacks, but this will crash if any transport_* is called before

    81

 * transport_set_callbacks().

    82

 *

    83

 * It is a bug to call this with a transport that is already bound.

    84

 */

    85

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

    86

    87

/**

    88

 * Check the type of the transport, and return the transport as a void* suitable for casting to the appropriate struct

    89

 * for the type, or any of its children.

    90

 *

    91

 * It is a bug to call this with a transport of a different type.

    92

 */

    93

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

    94

    95

/**

    96

 * Mark the transport as connected, calling transport_methods::_connected if it exists and \a direct is not given,

    97

 * transport_callbacks::on_connected/transport_callbacks::on_error otherwise.

    98

 *

    99

 * If the connect succeeded, \a err should be given as NULL. If the connect failed, \a err should contain the error

   100

 * info.

   101

 *

   102

 * If called from the transport_methods::_connected method, pass in direct to avoid recursion.

   103

 *

   105

 *

   107

 *

   108

 * @param transport the transport state

   109

 * @param err NULL for success, otherwise connect error code

   110

 * @param direct call the user callback directly, ignoring any method

   111

 */

   112

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

   113

   114

/**

   115

 * Invoke the user callbacks based on the given TRANSPORT_* flags

   116

 */

   117

void transport_invoke (transport_t *transport, short what);

   118

   119

/**

   120

 * Mark the transport as failed, calling transport_methods::on_error with the given error code.

   121

 */

   122

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

   123

   124

#endif /* TRANSPORT_INTERNAL_H */