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

    11

    // just map to gnutls_record_recv

    12

    return gnutls_record_recv(sock->session, buf, len);

    13

}

    14

    15

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

    16

{

    17

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

    18

    19

    // just map to gnutls_record_send

    20

    return gnutls_record_send(sock->session, buf, len);

    21

}

    22

    23

/*

    24

 * Our sock_stream_Type

    25

 */

    26

struct sock_stream_type sock_gnutls_type = {

    27

    .methods.read   = &sock_gnutls_read,

    28

    .methods.write  = &sock_gnutls_write,

    29

};

    30

    31

/*

    32

 * XXX: global shared sock_gnutls_ctx

    33

 */

    34

struct sock_gnutls_client_ctx _sock_gnutls_client_ctx;

    35

    36

/*

    37

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

    38

 */

    39

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

    40

{

    41

    // init to use anonymous x509 cert

    42

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

    43

        return SET_ERROR(err, ERR_GNUTLS_CERT_ALLOC_CRED);

    44

    45

    // done

    46

    return SUCCESS;

    47

}

    48

    49

err_t sock_gnutls_global_init (struct error_info *err)

    50

{

    51

    // global init

    52

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

    53

        return SET_ERROR(err, ERR_GNUTLS_GLOBAL_INIT);

    54

    55

    // init _sock_gnutls_ctx

    56

    if (sock_gnutls_client_ctx_anon(&_sock_gnutls_client_ctx, err))

    57

        return ERROR_CODE(err);

    58

    59

    // done

    60

    return SUCCESS;

    61

}

    62

    63

    64

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

    65

{

    66

    struct sock_gnutls *sock = NULL;

    67

    struct sock_gnutls_client_ctx *ctx = &_sock_gnutls_client_ctx;

    68

    69

    // alloc

    70

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

    71

        return SET_ERROR(err, ERR_CALLOC);

    72

    73

    // initialize base

    74

    sock_stream_init(SOCK_GNUTLS_BASE(sock), &sock_gnutls_type);

    75

    76

    // initialize client session

    77

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

    78

        JUMP_SET_ERROR(err, ERR_GNUTLS_INIT);

    79

    80

    // ...default priority stuff

    81

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

    82

        JUMP_SET_ERROR(err, ERR_GNUTLS_SET_DEFAULT_PRIORITY);

    83

    84

    // bind anon credentials

    85

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

    86

        JUMP_SET_ERROR(err, ERR_GNUTLS_CRED_SET);

    87

    88

    // TCP connect

    89

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

    90

        JUMP_SET_ERROR_INFO(err, SOCK_GNUTLS_ERR(sock));

    91

    92

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

    93

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

    94

    95

    // perform the handshake

    96

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

    97

        JUMP_SET_ERROR(err, ERR_GNUTLS_HANDSHAKE);

    98

    99

    // done

   100

    *sock_ptr = SOCK_GNUTLS_BASE(sock);

   101

   102

    return SUCCESS;

   103

   104

error:

   105

    // XXX: cleanup

   106

   107

    return ERROR_CODE(err);    

   108

}

   109