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?

    26

    if (ret < 0) {

    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?

    56

    if (ret < 0) {

    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

    (void) fd;

    72

    (void) what;

    73

    74

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

    75

    // event_enable().

    76

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

    77

}

    78

    79

static err_t sock_gnutls_event_init (struct sock_stream *base_sock)

    80

{

    81

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

    82

    83

    err_t err;

    84

    85

    // set nonblocking

    86

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

    87

        return err;

    88

    89

    // add ourselves as the event handler

    90

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

    91

        return err;

    92

    93

    // ok

    94

    return SUCCESS;

    95

}

    96

    97

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

    98

{

    99

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

   100

    int ret;

   101

   102

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

   103

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

   104

    sock->ev_mask = mask;

   105

   106

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

   107

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

   108

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

   109

        case 0: 

   110

            // read more data

   111

            sock_tcp_add_event(SOCK_GNUTLS_TCP(sock), EV_READ); 

   112

            break;

   113

   114

        case 1:

   115

            // write buffer full

   116

            sock_tcp_add_event(SOCK_GNUTLS_TCP(sock), EV_WRITE);

   117

            break;

   118

   119

        default:

   120

            // random error

   121

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

   122

    }

   123

   124

    // ok... wait

   125

    return SUCCESS;

   126

}

   127

   143

/*

   144

 * Our sock_stream_Type

   145

 */

   146

struct sock_stream_type sock_gnutls_type = {

   147

    .methods                = {

   148

        .read               = &sock_gnutls_read,

   149

        .write              = &sock_gnutls_write,

   150

        .event_init         = &sock_gnutls_event_init,

   151

        .event_enable       = &sock_gnutls_event_enable,

   153

    },

   154

};

   155

   156

/*

   157

 * XXX: global shared sock_gnutls_ctx

   158

 */

   159

struct sock_gnutls_client_ctx _sock_gnutls_client_ctx;

   160

   161

/*

   162

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

   163

 */

   164

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

   165

{

   166

    // init to use anonymous x509 cert

   167

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

   168

        return SET_ERROR(err, ERR_GNUTLS_CERT_ALLOC_CRED);

   169

   170

    // done

   171

    return SUCCESS;

   172

}

   173

   174

// XXX: log func

   175

void _log (int level, const char *msg)

   176

{

   177

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

   178

}

   179

   180

err_t sock_gnutls_global_init (struct error_info *err)

   181

{

   182

    // global init

   183

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

   184

        return SET_ERROR(err, ERR_GNUTLS_GLOBAL_INIT);

   185

   186

    // init _sock_gnutls_ctx

   187

    if (sock_gnutls_client_ctx_anon(&_sock_gnutls_client_ctx, err))

   188

        return ERROR_CODE(err);

   189

   190

    // XXX: debug

   191

//    gnutls_global_set_log_function(&_log);

   192

//    gnutls_global_set_log_level(11);

   193

   194

    // done

   195

    return SUCCESS;

   196

}

   197

   198

   199

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

   200

{

   201

    struct sock_gnutls *sock = NULL;

   202

    struct sock_gnutls_client_ctx *ctx = &_sock_gnutls_client_ctx;

   203

   204

    // alloc

   205

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

   206

        return SET_ERROR(err, ERR_CALLOC);

   207

   208

    // initialize base

   209

    sock_stream_init(SOCK_GNUTLS_BASE(sock), &sock_gnutls_type);

   210

   211

    // initialize client session

   212

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

   213

        JUMP_SET_ERROR(err, ERR_GNUTLS_INIT);

   214

   215

    // ...default priority stuff

   216

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

   217

        JUMP_SET_ERROR(err, ERR_GNUTLS_SET_DEFAULT_PRIORITY);

   218

   219

    // bind anon credentials

   220

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

   221

        JUMP_SET_ERROR(err, ERR_GNUTLS_CRED_SET);

   222

   223

    // TCP connect

   224

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

   225

        JUMP_SET_ERROR_INFO(err, SOCK_GNUTLS_ERR(sock));

   226

   227

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

   228

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

   229

   230

    // perform the handshake

   231

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

   232

        JUMP_SET_ERROR(err, ERR_GNUTLS_HANDSHAKE);

   233

   234

    // done

   235

    *sock_ptr = SOCK_GNUTLS_BASE(sock);

   236

   237

    return SUCCESS;

   238

   239

error:

   240

    // XXX: cleanup

   241

   242

    return ERROR_CODE(err);    

   243

}

   244