1

     2

#include "sock_internal.h"

     3

#include "sock_gnutls.h"

     4

     5

#include <assert.h>

     6

     7

// global sock_stream_ctx instance

     8

struct sock_stream_ctx _sock_stream_ctx;

     9

    10

err_t sock_init (struct event_base *ev_base, struct error_info *err)

    11

{

    12

    // store ev_base

    13

    _sock_stream_ctx.ev_base = ev_base;

    14

    15

    // XXX: just call these all directly for now

    16

    if (sock_gnutls_global_init(err))

    17

        return ERROR_CODE(err);

    18

    19

    // done

    20

    return SUCCESS;

    21

}

    22

    23

void sock_stream_init (struct sock_stream *sock, struct sock_stream_type *type, sock_stream_connect_cb cb_func, void *cb_arg)

    24

{

    25

    // be strict

    26

    assert(sock->type == NULL);

    27

    28

    // store 

    29

    sock->type = type;

    30

    sock->conn_cb_func = cb_func;

    31

    sock->conn_cb_arg = cb_arg;

    32

}

    33

    34

int sock_stream_read (struct sock_stream *sock, void *buf, size_t len)

    35

{

    36

    struct error_info *err = SOCK_ERR(sock);

    37

    38

    // XXX: not readable

    39

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

    40

        return -1;

    41

    42

    // proxy off to method handler

    43

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

    44

        return -ERROR_CODE(err);

    45

    46

    // return updated bytes-read len

    47

    return len;

    48

}

    49

    50

int sock_stream_write (struct sock_stream *sock, const void *buf, size_t len)

    51

{

    52

    struct error_info *err = SOCK_ERR(sock);

    53

    54

    // XXX: not writeable

    55

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

    56

        return -1;

    57

    58

    // proxy off to method handler

    59

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

    60

        return -ERROR_CODE(err);

    61

    62

    // return updated bytes-written len

    63

    return len;

    64

}

    65

    66

err_t sock_stream_event_init (struct sock_stream *sock, const struct sock_stream_callbacks *callbacks, void *arg)

    67

{

    68

    // store

    69

    sock->cb_info = callbacks;

    70

    sock->cb_arg = arg;

    71

    72

    // run method

    73

    return sock->type->methods.event_init(sock);

    74

}

    75

    76

err_t sock_stream_event_enable (struct sock_stream *sock, short mask)

    77

{

    78

    // run method

    79

    return sock->type->methods.event_enable(sock, mask);

    80

}

    81

    82

const struct error_info* sock_stream_error (struct sock_stream *sock)

    83

{

    84

    // return pointer

    85

    return SOCK_ERR(sock);

    86

}

    87

    88

void sock_stream_invoke_callbacks (struct sock_stream *sock, short what)

    89

{

    90

    if (what & EV_READ && sock->cb_info->on_read)

    91

        sock->cb_info->on_read(sock, sock->cb_arg);

    92

    93

    if (what & EV_WRITE && sock->cb_info->on_write)

    94

        sock->cb_info->on_read(sock, sock->cb_arg);

    95

}

    96

    97

void sock_stream_invoke_conn_cb (struct sock_stream *sock, struct error_info *err, bool direct)

    98

{

    99

    if (!direct && sock->type->methods._conn_cb) {

   100

        // invoke indirectly

   101

        sock->type->methods._conn_cb(sock, err);

   102

   103

    } else {

   104

        sock_stream_connect_cb cb_func = sock->conn_cb_func;

   105

   106

        // invoke directly

   107

        sock->conn_cb_func = NULL;

   108

        cb_func(sock, err, sock->conn_cb_arg);

   109

        sock->conn_cb_arg = NULL;

   110

    }

   111

}

   112

   113

void sock_stream_release (struct sock_stream *sock)

   114

{

   115

    sock->type->methods.release(sock);

   116

}

   117