1

     2

#include "sock_gnutls.h"

     3

     4

#include <stdlib.h>

     5

#include <err.h>

     6

     7

// XXX: errors

     8

static err_t sock_gnutls_read (struct sock_stream *base_sock, void *buf, size_t *len)

     9

{

    10

    struct sock_gnutls *sock = SOCK_FROM_BASE(base_sock, struct sock_gnutls);

    11

    struct error_info *err = SOCK_GNUTLS_ERR(sock);

    12

    int ret;

    13

    14

    // read gnutls record

    15

    ret = gnutls_record_recv(sock->session, buf, *len);

    16

    17

    // errors

    18

    if (ret < 0 && ret != GNUTLS_E_AGAIN)

    19

        RETURN_SET_ERROR_EXTRA(err, ERR_GNUTLS_RECORD_RECV, ret);

    20

    21

    else if (ret == 0)

    22

        return SET_ERROR(err, ERR_READ_EOF);

    23

    24

    25

    // eagain?

    27

        *len = 0;

    28

    29

    } else {

    30

        // updated length

    31

        *len = ret;

    32

    33

    }

    34

    35

    return SUCCESS;

    36

}

    37

    38

static err_t sock_gnutls_write (struct sock_stream *base_sock, const void *buf, size_t *len)

    39

{

    40

    struct sock_gnutls *sock = SOCK_FROM_BASE(base_sock, struct sock_gnutls);

    41

    struct error_info *err = SOCK_GNUTLS_ERR(sock);

    42

    int ret;

    43

    44

    // read gnutls record

    45

    ret = gnutls_record_send(sock->session, buf, *len);

    46

    47

    // errors

    48

    if (ret < 0 && ret != GNUTLS_E_AGAIN)

    49

        RETURN_SET_ERROR_EXTRA(err, ERR_GNUTLS_RECORD_RECV, ret);

    50

    51

    else if (ret == 0)

    52

        return SET_ERROR(err, ERR_READ_EOF);

    53

    54

    55

    // eagain?

    57

        *len = 0;

    58

    59

    } else {

    60

        // updated length

    61

        *len = ret;

    62

    }

    63

    64

    return SUCCESS;

    65

}

    66

    67

static void sock_gnutls_event_handler (int fd, short what, void *arg)

    68

{

    69

    struct sock_gnutls *sock = arg;

    70

    71

    // gnutls might be able to proceed now, so ask user to try what didn't work before now, using the mask given to

    72

    // event_enable().

    73

    sock_stream_invoke_callbacks(SOCK_GNUTLS_BASE(sock), sock->ev_mask);

    74

}

    75

    76

static err_t sock_gnutls_event_init (struct sock_stream *base_sock)

    77

{

    78

    struct sock_gnutls *sock = SOCK_FROM_BASE(base_sock, struct sock_gnutls);

    79

    80

    err_t err;

    81

    82

    // set nonblocking

    83

    if ((err = sock_tcp_set_nonblock(SOCK_GNUTLS_TCP(sock), 1)))

    84

        return err;

    85

    86

    // add ourselves as the event handler

    87

    if ((err = sock_tcp_init_ev(SOCK_GNUTLS_TCP(sock), &sock_gnutls_event_handler, sock)))

    88

        return err;

    89

    90

    // ok

    91

    return SUCCESS;

    92

}

    93

    94

static err_t sock_gnutls_event_enable (struct sock_stream *base_sock, short mask)

    95

{

    96

    struct sock_gnutls *sock = SOCK_FROM_BASE(base_sock, struct sock_gnutls);

    97

    int ret;

    98

    99

    // store the ev_mask. We don't care about it here, because we assume that event_enable is only called once read or

   100

    // write, respectively, return zero. This is really the only case we can handle with gnutls.

   101

    sock->ev_mask = mask;

   102

   103

    // gnutls_record_get_direction tells us what I/O operation gnutls would have required for the last

   104

    // operation, so we can use that to determine what events to register

   105

    switch ((ret = gnutls_record_get_direction(sock->session))) {

   106

        case 0: 

   107

            // read more data

   108

            sock_tcp_add_event(SOCK_GNUTLS_TCP(sock), EV_READ); 

   109

            break;

   110

   111

        case 1:

   112

            // write buffer full

   113

            sock_tcp_add_event(SOCK_GNUTLS_TCP(sock), EV_WRITE);

   114

            break;

   115

   116

        default:

   117

            // random error

   118

            RETURN_SET_ERROR_EXTRA(SOCK_GNUTLS_ERR(sock), ERR_GNUTLS_RECORD_GET_DIRECTION, ret);

   119

    }

   120

   121

    // ok... wait

   122

    return SUCCESS;

   123

}

   124

   125

/*

   126

 * Our sock_stream_Type

   127

 */

   128

struct sock_stream_type sock_gnutls_type = {

   129

    .methods.read           = &sock_gnutls_read,

   130

    .methods.write          = &sock_gnutls_write,

   131

    .methods.event_init     = &sock_gnutls_event_init,

   132

    .methods.event_enable   = &sock_gnutls_event_enable,

   133

};

   134

   135

/*

   136

 * XXX: global shared sock_gnutls_ctx

   137

 */

   138

struct sock_gnutls_client_ctx _sock_gnutls_client_ctx;

   139

   140

/*

   141

 * Configure the given gnutls socket context to use simple anonymous client credentials

   142

 */

   143

static err_t sock_gnutls_client_ctx_anon (struct sock_gnutls_client_ctx *ctx, struct error_info *err)

   144

{

   145

    // init to use anonymous x509 cert

   146

    if ((ERROR_EXTRA(err) = gnutls_certificate_allocate_credentials(&ctx->xcred)) < 0)

   147

        return SET_ERROR(err, ERR_GNUTLS_CERT_ALLOC_CRED);

   148

   149

    // done

   150

    return SUCCESS;

   151

}

   152

   159

err_t sock_gnutls_global_init (struct error_info *err)

   160

{

   161

    // global init

   162

    if ((ERROR_EXTRA(err) = gnutls_global_init()) < 0)

   163

        return SET_ERROR(err, ERR_GNUTLS_GLOBAL_INIT);

   164

   165

    // init _sock_gnutls_ctx

   166

    if (sock_gnutls_client_ctx_anon(&_sock_gnutls_client_ctx, err))

   167

        return ERROR_CODE(err);

   168

   173

    // done

   174

    return SUCCESS;

   175

}

   176

   177

   179

{

   180

    struct sock_gnutls *sock = NULL;

   181

    struct sock_gnutls_client_ctx *ctx = &_sock_gnutls_client_ctx;

   182

   183

    // alloc

   184

    if ((sock = calloc(1, sizeof(*sock))) == NULL)

   185

        return SET_ERROR(err, ERR_CALLOC);

   186

   187

    // initialize base

   188

    sock_stream_init(SOCK_GNUTLS_BASE(sock), &sock_gnutls_type);

   189

   190

    // initialize client session

   191

    if ((ERROR_EXTRA(err) = gnutls_init(&sock->session, GNUTLS_CLIENT)) < 0)

   192

        JUMP_SET_ERROR(err, ERR_GNUTLS_INIT);

   193

   194

    // ...default priority stuff

   195

    if ((ERROR_EXTRA(err) = gnutls_set_default_priority(sock->session)))

   196

        JUMP_SET_ERROR(err, ERR_GNUTLS_SET_DEFAULT_PRIORITY);

   197

   198

    // bind anon credentials

   199

    if ((ERROR_EXTRA(err) = gnutls_credentials_set(sock->session, GNUTLS_CRD_CERTIFICATE, ctx->xcred)))

   200

        JUMP_SET_ERROR(err, ERR_GNUTLS_CRED_SET);

   201

   202

    // TCP connect

   203

    if (sock_tcp_init_connect(SOCK_GNUTLS_TCP(sock), host, service))

   204

        JUMP_SET_ERROR_INFO(err, SOCK_GNUTLS_ERR(sock));

   205

   206

    // bind default transport functions (recv/send) to use the TCP fd

   207

    gnutls_transport_set_ptr(sock->session, (gnutls_transport_ptr_t) sock->base_tcp.fd);

   208

   209

    // perform the handshake

   210

    if ((ERROR_EXTRA(err) = gnutls_handshake(sock->session)) < 0)

   211

        JUMP_SET_ERROR(err, ERR_GNUTLS_HANDSHAKE);

   212

   213

    // done

   214

    *sock_ptr = SOCK_GNUTLS_BASE(sock);

   215

   216

    return SUCCESS;

   217

   218

error:

   219

    // XXX: cleanup

   220

   221

    return ERROR_CODE(err);    

   222

}

   223