1

     2

#include "sock_gnutls.h"

     3

     4

#include <stdlib.h>

     5

#include <err.h>

     6

     7

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

     8

{

     9

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

    10

    struct error_info *err = SOCK_GNUTLS_ERR(sock);

    11

    int ret;

    12

    13

    // read gnutls record

    14

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

    15

    16

    // errors

    17

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

    18

        RETURN_SET_ERROR_EXTRA(err, ERR_GNUTLS_RECORD_RECV, ret);

    19

    20

    else if (ret == 0)

    21

        return SET_ERROR(err, ERR_READ_EOF);

    22

    23

    24

    // eagain?

    25

    if (ret < 0) {

    26

        *len = 0;

    27

    28

    } else {

    29

        // updated length

    30

        *len = ret;

    31

    32

    }

    33

    34

    return SUCCESS;

    35

}

    36

    37

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

    38

{

    39

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

    40

    struct error_info *err = SOCK_GNUTLS_ERR(sock);

    41

    int ret;

    42

    43

    // read gnutls record

    44

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

    45

    46

    // errors

    47

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

    48

        RETURN_SET_ERROR_EXTRA(err, ERR_GNUTLS_RECORD_RECV, ret);

    49

    50

    else if (ret == 0)

    51

        return SET_ERROR(err, ERR_READ_EOF);

    52

    53

    54

    // eagain?

    55

    if (ret < 0) {

    56

        *len = 0;

    57

    58

    } else {

    59

        // updated length

    60

        *len = ret;

    61

    }

    62

    63

    return SUCCESS;

    64

}

    65

    66

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

    67

{

    68

    struct sock_gnutls *sock = arg;

    69

    70

    (void) fd;

    71

    (void) what;

    72

    73

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

    74

    // event_enable().

    75

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

    76

}

    77

    78

static err_t sock_gnutls_event_init (struct sock_stream *base_sock)

    79

{

    80

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

    81

    82

    err_t err;

    83

    84

    // set nonblocking

    85

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

    86

        return err;

    87

    88

    // add ourselves as the event handler

    89

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

    90

        return err;

    91

    92

    // ok

    93

    return SUCCESS;

    94

}

    95

    96

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

    97

{

    98

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

    99

    int ret;

   100

   101

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

   102

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

   103

    sock->ev_mask = mask;

   104

   105

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

   106

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

   107

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

   108

        case 0: 

   109

            // read more data

   110

            sock_tcp_add_event(SOCK_GNUTLS_TCP(sock), EV_READ); 

   111

            break;

   112

   113

        case 1:

   114

            // write buffer full

   115

            sock_tcp_add_event(SOCK_GNUTLS_TCP(sock), EV_WRITE);

   116

            break;

   117

   118

        default:

   119

            // random error

   120

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

   121

    }

   122

   123

    // ok... wait

   124

    return SUCCESS;

   125

}

   126

   127

static void sock_gnutls_release (struct sock_stream *base_sock)

   128

{

   129

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

   130

   131

    // DIEEEE

   132

    sock_gnutls_destroy(sock);

   133

}

   134

   135

/*

   136

 * Our sock_stream_Type

   137

 */

   138

struct sock_stream_type sock_gnutls_type = {

   139

    .methods                = {

   140

        .read               = &sock_gnutls_read,

   141

        .write              = &sock_gnutls_write,

   142

        .event_init         = &sock_gnutls_event_init,

   143

        .event_enable       = &sock_gnutls_event_enable,

   144

        .release            = &sock_gnutls_release,

   145

    },

   146

};

   147

   148

/*

   149

 * XXX: global shared sock_gnutls_ctx

   150

 */

   151

struct sock_gnutls_client_ctx _sock_gnutls_client_ctx;

   152

   153

/*

   154

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

   155

 */

   156

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

   157

{

   158

    // init to use anonymous x509 cert

   159

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

   160

        return SET_ERROR(err, ERR_GNUTLS_CERT_ALLOC_CRED);

   161

   162

    // done

   163

    return SUCCESS;

   164

}

   165

   166

// XXX: log func

   167

void _log (int level, const char *msg)

   168

{

   169

    printf("gnutls: %d: %s", level, msg);

   170

}

   171

   172

err_t sock_gnutls_global_init (struct error_info *err)

   173

{

   174

    // global init

   175

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

   176

        return SET_ERROR(err, ERR_GNUTLS_GLOBAL_INIT);

   177

   178

    // init _sock_gnutls_ctx

   179

    if (sock_gnutls_client_ctx_anon(&_sock_gnutls_client_ctx, err))

   180

        return ERROR_CODE(err);

   181

   182

    // XXX: debug

   183

//    gnutls_global_set_log_function(&_log);

   184

//    gnutls_global_set_log_level(11);

   185

   186

    // done

   187

    return SUCCESS;

   188

}

   189

   190

err_t sock_ssl_connect (struct sock_stream **sock_ptr, const char *host, const char *service, struct error_info *err)

   191

{

   192

    struct sock_gnutls *sock = NULL;

   193

    struct sock_gnutls_client_ctx *ctx = &_sock_gnutls_client_ctx;

   194

   195

    // alloc

   196

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

   197

        return SET_ERROR(err, ERR_CALLOC);

   198

   199

    // initialize base

   200

    sock_stream_init(SOCK_GNUTLS_BASE(sock), &sock_gnutls_type);

   201

   202

    // initialize client session

   203

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

   204

        JUMP_SET_ERROR(err, ERR_GNUTLS_INIT);

   205

   206

    // ...default priority stuff

   207

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

   208

        JUMP_SET_ERROR(err, ERR_GNUTLS_SET_DEFAULT_PRIORITY);

   209

   210

    // bind anon credentials

   211

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

   212

        JUMP_SET_ERROR(err, ERR_GNUTLS_CRED_SET);

   213

   214

    // TCP connect

   215

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

   216

        JUMP_SET_ERROR_INFO(err, SOCK_GNUTLS_ERR(sock));

   217

   218

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

   219

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

   220

   221

    // perform the handshake

   222

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

   223

        JUMP_SET_ERROR(err, ERR_GNUTLS_HANDSHAKE);

   224

   225

    // done

   226

    *sock_ptr = SOCK_GNUTLS_BASE(sock);

   227

   228

    return SUCCESS;

   229

   230

error:

   231

    // cleanup

   232

    sock_gnutls_destroy(sock);

   233

   234

    return ERROR_CODE(err);    

   235

}

   236

   237

void sock_gnutls_destroy (struct sock_gnutls *sock)

   238

{

   239

    // terminate the TCP transport

   240

    sock_tcp_close(SOCK_GNUTLS_TCP(sock));

   241

   242

    // close the session rudely

   243

    // XXX: does this actually do everything we need it to? Don't want to call gnutls_bye here, since we're void...

   244

    gnutls_deinit(sock->session);

   245

   246

    // free

   247

    free(sock);

   248

}

   249

   250