1

     2

#include "sock_gnutls.h"

     3

     4

#include <stdlib.h>

     5

#include <err.h>

     6

     7

static void _sock_gnutls_error (struct sock_gnutls *sock, const char *func, int _err) {

     8

    if (_err == GNUTLS_E_FATAL_ALERT_RECEIVED)

     9

        errx(1, "%s: %s: %s", func, gnutls_strerror(_err), gnutls_alert_get_name(gnutls_alert_get(sock->session)));

    10

    11

    else

    12

        errx(1, "%s: %s", func, gnutls_strerror(_err));

    13

}

    14

    16

{

    17

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

    18

    19

    // just map to gnutls_record_recv

    20

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

    21

}

    22

    24

{

    25

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

    26

    27

    // just map to gnutls_record_send

    28

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

    29

}

    30

    31

/*

    32

 * Our sock_stream_Type

    33

 */

    34

struct sock_stream_type sock_gnutls_type = {

    35

    .methods.read   = &sock_gnutls_read,

    36

    .methods.write  = &sock_gnutls_write,

    37

};

    38

    39

/*

    40

 * XXX: global shared sock_gnutls_ctx

    41

 */

    42

struct sock_gnutls_client_ctx _sock_gnutls_client_ctx;

    43

    44

/*

    45

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

    46

 *

    47

 * XXX: errors

    48

 */

    49

void sock_gnutls_client_ctx_anon (struct sock_gnutls_client_ctx *ctx)

    50

{

    51

      gnutls_certificate_allocate_credentials(&ctx->xcred);

    52

}

    53

    55

{

    56

    int _err;

    57

    58

    // global init

    59

    if ((_err = gnutls_global_init()) < 0)

    60

        errx(1, "gnutls_global_init: %s", gnutls_strerror(_err));

    61

    62

    // init _sock_gnutls_ctx

    63

    sock_gnutls_client_ctx_anon(&_sock_gnutls_client_ctx);

    67

}

    68

    69

    70

// XXX: errors

    71

struct sock_stream *sock_ssl_connect (const char *host, const char *service)

    72

{

    73

    int _err;

    74

    struct sock_gnutls *sock;

    75

    struct sock_gnutls_client_ctx *ctx = &_sock_gnutls_client_ctx;

    76

    77

    // alloc

    78

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

    79

        errx(1, "calloc");

    80

    81

    // initialize

    82

    sock->base_tcp.base.type = &sock_gnutls_type;

    83

    84

    // initialize client session

    85

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

    86

        errx(1, "gnutls_init: %s", gnutls_strerror(_err));

    87

    88

    // ...default priority stuff

    89

    gnutls_set_default_priority(sock->session);

    90

    91

    // bind anon credentials

    92

    gnutls_credentials_set(sock->session, GNUTLS_CRD_CERTIFICATE, ctx->xcred);

    93

    94

    // TCP connect

    95

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

    96

    97

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

    98

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

    99

   100

    // perform the handshake

   101

    if ((_err = gnutls_handshake(sock->session)) < 0)

   102

        _sock_gnutls_error(sock, "gnutls_handshake", _err);

   103

   104

    // done

   105

    return SOCK_GNUTLS_BASE(sock);

   106

}

   107