-/*
- * Copyright (C) 1995-2007, Index Data ApS
+/* This file is part of the YAZ toolkit.
+ * Copyright (C) Index Data
* See the file LICENSE for details.
- *
- * $Id: tcpip.c,v 1.39 2008-01-16 13:01:45 adam Exp $
*/
/**
* \file tcpip.c
* \brief Implements TCP/IP + SSL COMSTACK.
*/
+#if HAVE_CONFIG_H
+#include <config.h>
+#endif
#include <stdio.h>
#include <string.h>
+#include <assert.h>
#include <stdlib.h>
#include <errno.h>
#include <fcntl.h>
#if HAVE_UNISTD_H
#include <unistd.h>
#endif
+#include <yaz/thread_create.h>
#ifdef WIN32
-
/* VS 2003 or later has getaddrinfo; older versions do not */
#include <winsock2.h>
#if _MSC_VER >= 1300
#else
#define HAVE_GETADDRINFO 0
#endif
+#endif
-#else
+#if HAVE_NETINET_IN_H
#include <netinet/in.h>
+#endif
+#if HAVE_NETDB_H
#include <netdb.h>
+#endif
+#if HAVE_ARPA_INET_H
#include <arpa/inet.h>
+#endif
+#if HAVE_NETINET_TCP_H
#include <netinet/tcp.h>
#endif
-
#if HAVE_SYS_SOCKET_H
#include <sys/socket.h>
#endif
#include <sys/wait.h>
#endif
-#if HAVE_OPENSSL_SSL_H
-#include <openssl/ssl.h>
-#include <openssl/err.h>
+#if HAVE_GNUTLS_H
+#include <gnutls/x509.h>
+#include <gnutls/gnutls.h>
#endif
#include <yaz/comstack.h>
#include <yaz/tcpip.h>
-#include <yaz/nmem.h>
+#include <yaz/errno.h>
-static int tcpip_close(COMSTACK h);
+#ifndef WIN32
+#define RESOLVER_THREAD 1
+#endif
+
+static void tcpip_close(COMSTACK h);
static int tcpip_put(COMSTACK h, char *buf, int size);
static int tcpip_get(COMSTACK h, char **buf, int *bufsize);
static int tcpip_put_connect(COMSTACK h, char *buf, int size);
void *cd);
static int tcpip_set_blocking(COMSTACK p, int blocking);
-#if HAVE_OPENSSL_SSL_H
+#if HAVE_GNUTLS_H
static int ssl_get(COMSTACK h, char **buf, int *bufsize);
static int ssl_put(COMSTACK h, char *buf, int size);
#endif
static COMSTACK tcpip_accept(COMSTACK h);
-static char *tcpip_addrstr(COMSTACK h);
+static const char *tcpip_addrstr(COMSTACK h);
static void *tcpip_straddr(COMSTACK h, const char *str);
#if 0
#define YAZ_SOCKLEN_T int
#endif
+#if HAVE_GNUTLS_H
+struct tcpip_cred_ptr {
+ gnutls_certificate_credentials_t xcred;
+ int ref;
+};
+
+#endif
/* this state is used for both SSL and straight TCP/IP */
typedef struct tcpip_state
{
int (*complete)(const char *buf, int len); /* length/complete. */
#if HAVE_GETADDRINFO
struct addrinfo *ai;
+ struct addrinfo *ai_connect;
+ int ipv6_only;
+#if RESOLVER_THREAD
+ int pipefd[2];
+ char *hoststr;
+ const char *port;
+ yaz_thread_t thread_id;
+#endif
#else
struct sockaddr_in addr; /* returned by cs_straddr */
#endif
char buf[128]; /* returned by cs_addrstr */
-#if HAVE_OPENSSL_SSL_H
- SSL_CTX *ctx; /* current CTX. */
- SSL_CTX *ctx_alloc; /* If =ctx it is owned by CS. If 0 it is not owned */
- SSL *ssl;
+#if HAVE_GNUTLS_H
+ struct tcpip_cred_ptr *cred_ptr;
+ gnutls_session_t session;
char cert_fname[256];
#endif
char *connect_request_buf;
int connect_response_len;
} tcpip_state;
-#ifdef WIN32
-static int tcpip_init (void)
+static int tcpip_init(void)
{
+#ifdef WIN32
static int initialized = 0;
+#endif
+ yaz_init_globals();
+#ifdef WIN32
if (!initialized)
{
WORD requested;
return 0;
initialized = 1;
}
+#endif
return 1;
}
-#else
-static int tcpip_init (void)
+
+static struct tcpip_state *tcpip_state_create(void)
{
- return 1;
-}
+ tcpip_state *sp = (struct tcpip_state *) xmalloc(sizeof(*sp));
+
+ sp->altbuf = 0;
+ sp->altsize = sp->altlen = 0;
+ sp->towrite = sp->written = -1;
+ sp->complete = cs_complete_auto;
+
+#if HAVE_GETADDRINFO
+ sp->ai = 0;
+ sp->ai_connect = 0;
+#if RESOLVER_THREAD
+ sp->hoststr = 0;
+ sp->pipefd[0] = sp->pipefd[1] = -1;
+ sp->port = 0;
+#endif
+#endif
+
+#if HAVE_GNUTLS_H
+ sp->cred_ptr = 0;
+ sp->session = 0;
+ strcpy(sp->cert_fname, "yaz.pem");
#endif
+ sp->connect_request_buf = 0;
+ sp->connect_request_len = 0;
+ sp->connect_response_buf = 0;
+ sp->connect_response_len = 0;
+ return sp;
+}
/*
* This function is always called through the cs_create() macro.
COMSTACK tcpip_type(int s, int flags, int protocol, void *vp)
{
COMSTACK p;
- tcpip_state *sp;
- if (!tcpip_init ())
+ if (!tcpip_init())
return 0;
if (!(p = (struct comstack *)xmalloc(sizeof(struct comstack))))
return 0;
- if (!(sp = (struct tcpip_state *)(p->cprivate =
- xmalloc(sizeof(tcpip_state)))))
- return 0;
+ p->cprivate = tcpip_state_create();
p->flags = flags;
p->io_pending = 0;
p->f_addrstr = tcpip_addrstr;
p->f_straddr = tcpip_straddr;
p->f_set_blocking = tcpip_set_blocking;
- p->max_recv_bytes = 5000000;
+ p->max_recv_bytes = 128 * 1024 * 1024;
p->state = s < 0 ? CS_ST_UNBND : CS_ST_IDLE; /* state of line */
p->event = CS_NONE;
p->cerrno = 0;
- p->stackerr = 0;
p->user = 0;
-#if HAVE_OPENSSL_SSL_H
- sp->ctx = sp->ctx_alloc = 0;
- sp->ssl = 0;
- strcpy(sp->cert_fname, "yaz.pem");
-#endif
-
-#if HAVE_GETADDRINFO
- sp->ai = 0;
-#endif
- sp->altbuf = 0;
- sp->altsize = sp->altlen = 0;
- sp->towrite = sp->written = -1;
- if (protocol == PROTO_WAIS)
- sp->complete = completeWAIS;
- else
- sp->complete = cs_complete_auto;
-
- sp->connect_request_buf = 0;
- sp->connect_request_len = 0;
- sp->connect_response_buf = 0;
- sp->connect_response_len = 0;
-
- p->timeout = COMSTACK_DEFAULT_TIMEOUT;
- TRC(fprintf(stderr, "Created new TCPIP comstack\n"));
+ TRC(fprintf(stderr, "Created new TCPIP comstack h=%p\n", p));
return p;
}
return p;
}
+#if HAVE_GNUTLS_H
+static void tcpip_create_cred(COMSTACK cs)
+{
+ tcpip_state *sp = (tcpip_state *) cs->cprivate;
+ sp->cred_ptr = (struct tcpip_cred_ptr *) xmalloc(sizeof(*sp->cred_ptr));
+ sp->cred_ptr->ref = 1;
+ gnutls_certificate_allocate_credentials(&sp->cred_ptr->xcred);
+}
-#if HAVE_OPENSSL_SSL_H
+#endif
COMSTACK ssl_type(int s, int flags, int protocol, void *vp)
{
+#if HAVE_GNUTLS_H
tcpip_state *sp;
COMSTACK p;
- p = tcpip_type (s, flags, protocol, 0);
+ p = tcpip_type(s, flags, protocol, 0);
if (!p)
return 0;
p->f_get = ssl_get;
p->type = ssl_type;
sp = (tcpip_state *) p->cprivate;
- sp->ctx = (SSL_CTX *) vp; /* may be NULL */
-
+ sp->session = (gnutls_session_t) vp;
/* note: we don't handle already opened socket in SSL mode - yet */
return p;
+#else
+ return 0;
+#endif
+}
+
+#if HAVE_GNUTLS_H
+static int ssl_check_error(COMSTACK h, tcpip_state *sp, int res)
+{
+ TRC(fprintf(stderr, "ssl_check_error error=%d fatal=%d msg=%s\n",
+ res,
+ gnutls_error_is_fatal(res),
+ gnutls_strerror(res)));
+ if (res == GNUTLS_E_AGAIN || res == GNUTLS_E_INTERRUPTED)
+ {
+ int dir = gnutls_record_get_direction(sp->session);
+ TRC(fprintf(stderr, " -> incomplete dir=%d\n", dir));
+ h->io_pending = dir ? CS_WANT_WRITE : CS_WANT_READ;
+ return 1;
+ }
+ h->cerrno = CSERRORSSL;
+ return 0;
}
#endif
#if HAVE_GETADDRINFO
/* resolve using getaddrinfo */
-struct addrinfo *tcpip_getaddrinfo(const char *str, const char *port)
+struct addrinfo *tcpip_getaddrinfo(const char *str, const char *port,
+ int *ipv6_only)
{
struct addrinfo hints, *res;
int error;
if (!strcmp("@", host))
{
hints.ai_flags = AI_PASSIVE;
+ hints.ai_family = AF_UNSPEC;
+ error = getaddrinfo(0, port, &hints, &res);
+ *ipv6_only = 0;
+ }
+ else if (!strcmp("@4", host))
+ {
+ hints.ai_flags = AI_PASSIVE;
+ hints.ai_family = AF_INET;
error = getaddrinfo(0, port, &hints, &res);
+ *ipv6_only = -1;
+ }
+ else if (!strcmp("@6", host))
+ {
+ hints.ai_flags = AI_PASSIVE;
+ hints.ai_family = AF_INET6;
+ error = getaddrinfo(0, port, &hints, &res);
+ *ipv6_only = 1;
}
else
{
error = getaddrinfo(host, port, &hints, &res);
+ *ipv6_only = -1;
}
if (error)
return 0;
return 1;
}
-
#if HAVE_GETADDRINFO
-void *tcpip_straddr(COMSTACK h, const char *str)
+static struct addrinfo *create_net_socket(COMSTACK h)
{
tcpip_state *sp = (tcpip_state *)h->cprivate;
- const char *port = "210";
- if (h->protocol == PROTO_HTTP)
- port = "80";
- if (!tcpip_init ())
- return 0;
-
- if (sp->ai)
- freeaddrinfo(sp->ai);
- sp->ai = tcpip_getaddrinfo(str, port);
- if (sp->ai && h->state == CS_ST_UNBND)
+ int s = -1;
+ struct addrinfo *ai = 0;
+ if (sp->ipv6_only >= 0)
+ {
+ for (ai = sp->ai; ai; ai = ai->ai_next)
+ {
+ if (ai->ai_family == AF_INET6)
+ {
+ s = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
+ if (s != -1)
+ break;
+ }
+ }
+ }
+ if (s == -1)
{
- int s = -1;
- struct addrinfo *ai = sp->ai;
- for (; ai; ai = ai->ai_next)
+ for (ai = sp->ai; ai; ai = ai->ai_next)
{
s = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
if (s != -1)
break;
}
- if (s == -1)
+ }
+ if (s == -1)
+ return 0;
+ TRC(fprintf(stderr, "First socket fd=%d\n", s));
+ assert(ai);
+ h->iofile = s;
+ if (ai->ai_family == AF_INET6 && sp->ipv6_only >= 0 &&
+ setsockopt(h->iofile,
+ IPPROTO_IPV6,
+ IPV6_V6ONLY, &sp->ipv6_only, sizeof(sp->ipv6_only)))
+ return 0;
+ if (!tcpip_set_blocking(h, h->flags))
+ return 0;
+ return ai;
+}
+
+#if RESOLVER_THREAD
+
+void *resolver_thread(void *arg)
+{
+ COMSTACK h = (COMSTACK) arg;
+ tcpip_state *sp = (tcpip_state *)h->cprivate;
+
+ sp->ipv6_only = 0;
+ if (sp->ai)
+ freeaddrinfo(sp->ai);
+ sp->ai = tcpip_getaddrinfo(sp->hoststr, sp->port, &sp->ipv6_only);
+ write(sp->pipefd[1], "1", 1);
+ return 0;
+}
+
+static struct addrinfo *wait_resolver_thread(COMSTACK h)
+{
+ tcpip_state *sp = (tcpip_state *)h->cprivate;
+ char buf;
+
+ read(sp->pipefd[0], &buf, 1);
+ yaz_thread_join(&sp->thread_id, 0);
+ close(sp->pipefd[0]);
+ close(sp->pipefd[1]);
+ sp->pipefd[0] = -1;
+ h->iofile = -1;
+ return create_net_socket(h);
+}
+
+#endif
+
+void *tcpip_straddr(COMSTACK h, const char *str)
+{
+ tcpip_state *sp = (tcpip_state *)h->cprivate;
+ const char *port = "210";
+
+ if (!tcpip_init())
+ return 0;
+
+ if (h->protocol == PROTO_HTTP)
+ {
+ if (h->type == ssl_type)
+ port = "443";
+ else
+ port = "80";
+ }
+#if RESOLVER_THREAD
+ if (h->flags & CS_FLAGS_DNS_NO_BLOCK)
+ {
+ if (sp->pipefd[0] != -1)
return 0;
- h->iofile = s;
-
- if (!tcpip_set_blocking(h, h->flags))
+ if (pipe(sp->pipefd) == -1)
return 0;
+
+ sp->port = port;
+ xfree(sp->hoststr);
+ sp->hoststr = xstrdup(str);
+ sp->thread_id = yaz_thread_create(resolver_thread, h);
+ return sp->hoststr;
+ }
+#endif
+ if (sp->ai)
+ freeaddrinfo(sp->ai);
+ sp->ai = tcpip_getaddrinfo(str, port, &sp->ipv6_only);
+ if (sp->ai && h->state == CS_ST_UNBND)
+ {
+ return create_net_socket(h);
}
return sp->ai;
}
+
#else
void *tcpip_straddr(COMSTACK h, const char *str)
{
tcpip_state *sp = (tcpip_state *)h->cprivate;
int port = 210;
if (h->protocol == PROTO_HTTP)
- port = 80;
+ {
+ if (h->type == ssl_type)
+ port = 443;
+ else
+ port = 80;
+ }
- if (!tcpip_init ())
+ if (!tcpip_init())
return 0;
- if (!tcpip_strtoaddr_ex (str, &sp->addr, port))
+ if (!tcpip_strtoaddr_ex(str, &sp->addr, port))
return 0;
if (h->state == CS_ST_UNBND)
{
int tcpip_more(COMSTACK h)
{
tcpip_state *sp = (tcpip_state *)h->cprivate;
-
+
return sp->altlen && (*sp->complete)(sp->altbuf, sp->altlen);
}
+static int cont_connect(COMSTACK h)
+{
+#if HAVE_GETADDRINFO
+ tcpip_state *sp = (tcpip_state *)h->cprivate;
+ struct addrinfo *ai = sp->ai_connect;
+ while (ai && (ai = ai->ai_next))
+ {
+ int s;
+ s = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
+ if (s != -1)
+ {
+#if HAVE_GNUTLS_H
+ if (h->type == ssl_type && sp->session)
+ {
+ gnutls_bye(sp->session, GNUTLS_SHUT_WR);
+ gnutls_deinit(sp->session);
+ sp->session = 0;
+ }
+#endif
+#ifdef WIN32
+ closesocket(h->iofile);
+#else
+ close(h->iofile);
+#endif
+ TRC(fprintf(stderr, "Other socket call fd=%d\n", s));
+ h->state = CS_ST_UNBND;
+ h->iofile = s;
+ tcpip_set_blocking(h, h->flags);
+ return tcpip_connect(h, ai);
+ }
+ }
+#endif
+ h->cerrno = CSYSERR;
+ return -1;
+}
+
+
/*
* connect(2) will block (sometimes) - nothing we can do short of doing
* weird things like spawning subprocesses or threading or some weird junk
int tcpip_connect(COMSTACK h, void *address)
{
#if HAVE_GETADDRINFO
+ struct addrinfo *ai = (struct addrinfo *) address;
tcpip_state *sp = (tcpip_state *)h->cprivate;
#else
struct sockaddr_in *add = (struct sockaddr_in *) address;
#endif
int r;
-#ifdef __sun__
- int recbuflen;
- YAZ_SOCKLEN_T rbufsize = sizeof(recbuflen);
-#endif
- TRC(fprintf(stderr, "tcpip_connect\n"));
+ TRC(fprintf(stderr, "tcpip_connect h=%p\n", h));
h->io_pending = 0;
if (h->state != CS_ST_UNBND)
{
return -1;
}
#if HAVE_GETADDRINFO
- if (sp->ai != (struct addrinfo *) address)
- {
- h->cerrno = CSOUTSTATE;
- return -1;
- }
-#endif
-#ifdef __sun__
- /* On Suns, you must set a bigger Receive Buffer BEFORE a call to connect
- * This gives the connect a chance to negotiate with the other side
- * (see 'man tcp')
- */
- if ( getsockopt(h->iofile, SOL_SOCKET, SO_RCVBUF, (void *)&recbuflen, &rbufsize ) < 0 )
+#if RESOLVER_THREAD
+ if (sp->pipefd[0] != -1)
{
- h->cerrno = CSYSERR;
- return -1;
- }
- TRC(fprintf( stderr, "Current Size of TCP Receive Buffer= %d\n",
- recbuflen ));
- recbuflen *= 10; /* lets be optimistic */
- if ( setsockopt(h->iofile, SOL_SOCKET, SO_RCVBUF, (void *)&recbuflen, rbufsize ) < 0 )
- {
- h->cerrno = CSYSERR;
- return -1;
- }
- if ( getsockopt(h->iofile, SOL_SOCKET, SO_RCVBUF, (void *)&recbuflen, &rbufsize ) )
- {
- h->cerrno = CSYSERR;
- return -1;
+ if (h->flags & CS_FLAGS_BLOCKING)
+ {
+ ai = wait_resolver_thread(h);
+ if (!ai)
+ return -1;
+ }
+ else
+ {
+ h->event = CS_CONNECT;
+ h->state = CS_ST_CONNECTING;
+ h->io_pending = CS_WANT_READ;
+ h->iofile = sp->pipefd[0];
+ return 1;
+ }
}
- TRC(fprintf( stderr, "New Size of TCP Receive Buffer = %d\n",
- recbuflen ));
#endif
-
-#if HAVE_GETADDRINFO
- r = connect(h->iofile, sp->ai->ai_addr, sp->ai->ai_addrlen);
- freeaddrinfo(sp->ai);
- sp->ai = 0;
+ r = connect(h->iofile, ai->ai_addr, ai->ai_addrlen);
+ sp->ai_connect = ai;
#else
r = connect(h->iofile, (struct sockaddr *) add, sizeof(*add));
#endif
#else
if (yaz_errno() == EINPROGRESS)
{
+ TRC(fprintf(stderr, "Pending fd=%d\n", h->iofile));
h->event = CS_CONNECT;
h->state = CS_ST_CONNECTING;
h->io_pending = CS_WANT_WRITE|CS_WANT_READ;
return 1;
}
#endif
- h->cerrno = CSYSERR;
- return -1;
+ return cont_connect(h);
}
h->event = CS_CONNECT;
h->state = CS_ST_CONNECTING;
- return tcpip_rcvconnect (h);
+ return tcpip_rcvconnect(h);
}
/*
*/
int tcpip_rcvconnect(COMSTACK h)
{
-#if HAVE_OPENSSL_SSL_H
tcpip_state *sp = (tcpip_state *)h->cprivate;
-#endif
TRC(fprintf(stderr, "tcpip_rcvconnect\n"));
if (h->state == CS_ST_DATAXFER)
return 0;
+#if HAVE_GETADDRINFO
+#if RESOLVER_THREAD
+ if (sp->pipefd[0] != -1)
+ {
+ struct addrinfo *ai = wait_resolver_thread(h);
+ if (!ai)
+ return -1;
+ h->state = CS_ST_UNBND;
+ return tcpip_connect(h, ai);
+ }
+#endif
+#endif
if (h->state != CS_ST_CONNECTING)
{
h->cerrno = CSOUTSTATE;
return -1;
}
-#if HAVE_OPENSSL_SSL_H
- if (h->type == ssl_type && !sp->ctx)
+#if HAVE_GNUTLS_H
+ if (h->type == ssl_type && !sp->session)
{
- SSL_library_init();
- SSL_load_error_strings();
-
- sp->ctx = sp->ctx_alloc = SSL_CTX_new (SSLv23_method());
- if (!sp->ctx)
- {
- h->cerrno = CSERRORSSL;
- return -1;
- }
+ tcpip_create_cred(h);
+ gnutls_init(&sp->session, GNUTLS_CLIENT);
+ gnutls_set_default_priority(sp->session);
+ gnutls_credentials_set (sp->session, GNUTLS_CRD_CERTIFICATE,
+ sp->cred_ptr->xcred);
+ /* cast to intermediate size_t to avoid GCC warning. */
+ gnutls_transport_set_ptr(sp->session,
+ (gnutls_transport_ptr_t)
+ (size_t) h->iofile);
}
- if (sp->ctx)
+ if (sp->session)
{
- int res;
-
- if (!sp->ssl)
- {
- sp->ssl = SSL_new (sp->ctx);
- SSL_set_fd (sp->ssl, h->iofile);
- }
- res = SSL_connect (sp->ssl);
- if (res <= 0)
+ int res = gnutls_handshake(sp->session);
+ if (res < 0)
{
- int err = SSL_get_error(sp->ssl, res);
- if (err == SSL_ERROR_WANT_READ)
- {
- h->io_pending = CS_WANT_READ;
+ if (ssl_check_error(h, sp, res))
return 1;
- }
- if (err == SSL_ERROR_WANT_WRITE)
- {
- h->io_pending = CS_WANT_WRITE;
- return 1;
- }
- h->cerrno = CSERRORSSL;
- return -1;
+ return cont_connect(h);
}
}
#endif
#define CERTF "ztest.pem"
#define KEYF "ztest.pem"
-static void tcpip_setsockopt (int fd)
-{
-#if 0
- int len = 4096;
- int set = 1;
-
- if (setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char*)&set, sizeof(int)))
- {
- yaz_log(LOG_WARN|LOG_ERRNO, "setsockopt TCP_NODELAY");
- }
- if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, (char*)&len, sizeof(int)))
- {
- yaz_log(LOG_WARN|LOG_ERRNO, "setsockopt SNDBUF");
- }
- if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, (char*)&len, sizeof(int)))
- {
- yaz_log(LOG_WARN|LOG_ERRNO, "setsockopt RCVBUF");
- }
-#endif
-}
-
static int tcpip_bind(COMSTACK h, void *address, int mode)
{
int r;
tcpip_state *sp = (tcpip_state *)h->cprivate;
#if HAVE_GETADDRINFO
+ struct addrinfo *ai = (struct addrinfo *) address;
#else
struct sockaddr *addr = (struct sockaddr *)address;
#endif
#endif
#if HAVE_GETADDRINFO
- if (sp->ai != (struct addrinfo *) address)
+#if RESOLVER_THREAD
+ if (sp->pipefd[0] != -1)
{
- h->cerrno = CSOUTSTATE;
- return -1;
+ ai = wait_resolver_thread(h);
+ if (!ai)
+ return -1;
}
#endif
-
-#if HAVE_OPENSSL_SSL_H
- if (h->type == ssl_type && !sp->ctx)
+#endif
+#if HAVE_GNUTLS_H
+ if (h->type == ssl_type && !sp->session)
{
- SSL_library_init();
- SSL_load_error_strings();
-
- sp->ctx = sp->ctx_alloc = SSL_CTX_new (SSLv23_method());
- if (!sp->ctx)
+ int res;
+ tcpip_create_cred(h);
+ res = gnutls_certificate_set_x509_key_file(sp->cred_ptr->xcred,
+ sp->cert_fname,
+ sp->cert_fname,
+ GNUTLS_X509_FMT_PEM);
+ if (res != GNUTLS_E_SUCCESS)
{
h->cerrno = CSERRORSSL;
return -1;
}
}
- if (sp->ctx)
- {
- if (sp->ctx_alloc)
- {
- int res;
- res = SSL_CTX_use_certificate_chain_file(sp->ctx, sp->cert_fname);
- if (res <= 0)
- {
- ERR_print_errors_fp(stderr);
- exit (2);
- }
- res = SSL_CTX_use_PrivateKey_file (sp->ctx, sp->cert_fname,
- SSL_FILETYPE_PEM);
- if (res <= 0)
- {
- ERR_print_errors_fp(stderr);
- exit (3);
- }
- res = SSL_CTX_check_private_key (sp->ctx);
- if (res <= 0)
- {
- ERR_print_errors_fp(stderr);
- exit(5);
- }
- }
- TRC (fprintf (stderr, "ssl_bind\n"));
- }
- else
- {
- TRC (fprintf (stderr, "tcpip_bind\n"));
- }
#else
- TRC (fprintf (stderr, "tcpip_bind\n"));
+ TRC(fprintf(stderr, "tcpip_bind\n"));
#endif
#ifndef WIN32
- if (setsockopt(h->iofile, SOL_SOCKET, SO_REUSEADDR, (char*)
+ if (setsockopt(h->iofile, SOL_SOCKET, SO_REUSEADDR, (char*)
&one, sizeof(one)) < 0)
{
h->cerrno = CSYSERR;
return -1;
}
#endif
- tcpip_setsockopt(h->iofile);
#if HAVE_GETADDRINFO
- r = bind(h->iofile, sp->ai->ai_addr, sp->ai->ai_addrlen);
+ r = bind(h->iofile, ai->ai_addr, ai->ai_addrlen);
freeaddrinfo(sp->ai);
sp->ai = 0;
#else
int (*check_ip)(void *cd, const char *a, int len, int t),
void *cd)
{
+#ifdef WIN32
+ /* we don't get peer address on Windows (via accept) */
+#else
struct sockaddr_in addr;
YAZ_SOCKLEN_T len = sizeof(addr);
+#endif
TRC(fprintf(stderr, "tcpip_listen pid=%d\n", getpid()));
if (h->state != CS_ST_IDLE)
h->cerrno = CSOUTSTATE;
return -1;
}
+#ifdef WIN32
+ h->newfd = accept(h->iofile, 0, 0);
+#else
h->newfd = accept(h->iofile, (struct sockaddr*)&addr, &len);
+#endif
if (h->newfd < 0)
{
if (
#ifdef WIN32
WSAGetLastError() == WSAEWOULDBLOCK
#else
- yaz_errno() == EWOULDBLOCK
+ yaz_errno() == EWOULDBLOCK
#ifdef EAGAIN
#if EAGAIN != EWOULDBLOCK
|| yaz_errno() == EAGAIN
)
h->cerrno = CSNODATA;
else
+ {
+#ifdef WIN32
+ shutdown(h->iofile, SD_RECEIVE);
+#else
+ shutdown(h->iofile, SHUT_RD);
+#endif
+ listen(h->iofile, SOMAXCONN);
h->cerrno = CSYSERR;
+ }
return -1;
}
+#ifdef WIN32
+ if (addrlen)
+ *addrlen = 0;
+#else
if (addrlen && (size_t) (*addrlen) >= sizeof(struct sockaddr_in))
memcpy(raddr, &addr, *addrlen = sizeof(struct sockaddr_in));
else if (addrlen)
h->newfd = -1;
return -1;
}
+#endif
h->state = CS_ST_INCON;
- tcpip_setsockopt (h->newfd);
return 0;
}
COMSTACK tcpip_accept(COMSTACK h)
{
COMSTACK cnew;
- tcpip_state *state, *st = (tcpip_state *)h->cprivate;
#ifdef WIN32
unsigned long tru = 1;
#endif
- TRC(fprintf(stderr, "tcpip_accept\n"));
+ TRC(fprintf(stderr, "tcpip_accept h=%p pid=%d\n", h, getpid()));
if (h->state == CS_ST_INCON)
{
- if (!(cnew = (COMSTACK)xmalloc(sizeof(*cnew))))
- {
- h->cerrno = CSYSERR;
-#ifdef WIN32
- closesocket(h->newfd);
-#else
- close(h->newfd);
-#endif
- h->newfd = -1;
- return 0;
- }
+ tcpip_state *st = (tcpip_state *)h->cprivate;
+ tcpip_state *state = tcpip_state_create();
+ cnew = (COMSTACK) xmalloc(sizeof(*cnew));
+
memcpy(cnew, h, sizeof(*h));
cnew->iofile = h->newfd;
cnew->io_pending = 0;
- if (!(state = (tcpip_state *)
- (cnew->cprivate = xmalloc(sizeof(tcpip_state)))))
- {
- h->cerrno = CSYSERR;
- if (h->newfd != -1)
- {
-#ifdef WIN32
- closesocket(h->newfd);
-#else
- close(h->newfd);
-#endif
- h->newfd = -1;
- }
- return 0;
- }
+ cnew->cprivate = state;
+
if (!tcpip_set_blocking(cnew, cnew->flags))
{
h->cerrno = CSYSERR;
#endif
h->newfd = -1;
}
- xfree (cnew);
- xfree (state);
+ xfree(state);
+ xfree(cnew);
return 0;
}
h->newfd = -1;
- state->altbuf = 0;
- state->altsize = state->altlen = 0;
- state->towrite = state->written = -1;
- state->complete = st->complete;
-#if HAVE_GETADDRINFO
- state->ai = 0;
-#endif
cnew->state = CS_ST_ACCEPT;
h->state = CS_ST_IDLE;
-
-#if HAVE_OPENSSL_SSL_H
- state->ctx = st->ctx;
- state->ctx_alloc = 0;
- state->ssl = st->ssl;
- if (state->ctx)
+
+#if HAVE_GNUTLS_H
+ state->cred_ptr = st->cred_ptr;
+ if (st->cred_ptr)
{
- state->ssl = SSL_new (state->ctx);
- SSL_set_fd (state->ssl, cnew->iofile);
+ int res;
+
+ (state->cred_ptr->ref)++;
+ gnutls_init(&state->session, GNUTLS_SERVER);
+ if (!state->session)
+ {
+ xfree(cnew);
+ xfree(state);
+ return 0;
+ }
+ res = gnutls_set_default_priority(state->session);
+ if (res != GNUTLS_E_SUCCESS)
+ {
+ xfree(cnew);
+ xfree(state);
+ return 0;
+ }
+ res = gnutls_credentials_set(state->session,
+ GNUTLS_CRD_CERTIFICATE,
+ st->cred_ptr->xcred);
+ if (res != GNUTLS_E_SUCCESS)
+ {
+ xfree(cnew);
+ xfree(state);
+ return 0;
+ }
+ /* cast to intermediate size_t to avoid GCC warning. */
+ gnutls_transport_set_ptr(state->session,
+ (gnutls_transport_ptr_t)
+ (size_t) cnew->iofile);
}
#endif
- state->connect_request_buf = 0;
- state->connect_response_buf = 0;
h = cnew;
}
if (h->state == CS_ST_ACCEPT)
{
-#if HAVE_OPENSSL_SSL_H
+#if HAVE_GNUTLS_H
tcpip_state *state = (tcpip_state *)h->cprivate;
- if (state->ctx)
+ if (state->session)
{
- int res = SSL_accept (state->ssl);
- TRC(fprintf(stderr, "SSL_accept\n"));
- if (res <= 0)
+ int res = gnutls_handshake(state->session);
+ if (res < 0)
{
- int err = SSL_get_error(state->ssl, res);
- if (err == SSL_ERROR_WANT_READ)
- {
- h->io_pending = CS_WANT_READ;
- return h;
- }
- if (err == SSL_ERROR_WANT_WRITE)
+ if (ssl_check_error(h, state, res))
{
- h->io_pending = CS_WANT_WRITE;
+ TRC(fprintf(stderr, "gnutls_handshake int in tcpip_accept\n"));
return h;
}
- cs_close (h);
+ TRC(fprintf(stderr, "gnutls_handshake failed in tcpip_accept\n"));
+ cs_close(h);
return 0;
}
+ TRC(fprintf(stderr, "SSL_accept complete. gnutls\n"));
}
#endif
}
int tmpi, berlen, rest, req, tomove;
int hasread = 0, res;
- TRC(fprintf(stderr, "tcpip_get: bufsize=%d\n", *bufsize));
+ TRC(fprintf(stderr, "tcpip_get: h=%p bufsize=%d\n", h, *bufsize));
if (sp->altlen) /* switch buffers */
{
- TRC(fprintf(stderr, " %d bytes in altbuf (0x%x)\n", sp->altlen,
- (unsigned) sp->altbuf));
+ TRC(fprintf(stderr, " %d bytes in altbuf (%p)\n", sp->altlen,
+ sp->altbuf));
tmpc = *buf;
tmpi = *bufsize;
*buf = sp->altbuf;
TRC(fprintf(stderr, " recv res=%d, hasread=%d\n", res, hasread));
if (res < 0)
{
- TRC(fprintf(stderr, " recv errno=%d, (%s)\n", yaz_errno(),
+ TRC(fprintf(stderr, " recv errno=%d, (%s)\n", yaz_errno(),
strerror(yaz_errno())));
#ifdef WIN32
if (WSAGetLastError() == WSAEWOULDBLOCK)
return -1;
}
#else
- if (yaz_errno() == EWOULDBLOCK
-#ifdef EAGAIN
+ if (yaz_errno() == EWOULDBLOCK
+#ifdef EAGAIN
#if EAGAIN != EWOULDBLOCK
|| yaz_errno() == EAGAIN
#endif
return -1;
}
}
- TRC (fprintf (stderr, " Out of read loop with hasread=%d, berlen=%d\n",
- hasread, berlen));
+ TRC(fprintf(stderr, " Out of read loop with hasread=%d, berlen=%d\n",
+ hasread, berlen));
/* move surplus buffer (or everything if we didn't get a BER rec.) */
if (hasread > berlen)
{
h->cerrno = CSYSERR;
return -1;
}
- TRC(fprintf(stderr, " Moving %d bytes to altbuf(0x%x)\n", tomove,
- (unsigned) sp->altbuf));
+ TRC(fprintf(stderr, " Moving %d bytes to altbuf(%p)\n", tomove,
+ sp->altbuf));
memcpy(sp->altbuf, *buf + berlen, sp->altlen = tomove);
}
if (berlen < CS_TCPIP_BUFCHUNK - 1)
}
-#if HAVE_OPENSSL_SSL_H
+#if HAVE_GNUTLS_H
/*
* Return: -1 error, >1 good, len of buffer, ==1 incomplete buffer,
* 0=connection closed.
TRC(fprintf(stderr, "ssl_get: bufsize=%d\n", *bufsize));
if (sp->altlen) /* switch buffers */
{
- TRC(fprintf(stderr, " %d bytes in altbuf (0x%x)\n", sp->altlen,
- (unsigned) sp->altbuf));
+ TRC(fprintf(stderr, " %d bytes in altbuf (%p)\n", sp->altlen,
+ sp->altbuf));
tmpc = *buf;
tmpi = *bufsize;
*buf = sp->altbuf;
else if (*bufsize - hasread < CS_TCPIP_BUFCHUNK)
if (!(*buf =(char *)xrealloc(*buf, *bufsize *= 2)))
return -1;
- res = SSL_read (sp->ssl, *buf + hasread, CS_TCPIP_BUFCHUNK);
- TRC(fprintf(stderr, " SSL_read res=%d, hasread=%d\n", res, hasread));
- if (res <= 0)
+ res = gnutls_record_recv(sp->session, *buf + hasread,
+ CS_TCPIP_BUFCHUNK);
+ if (res == 0)
{
- int ssl_err = SSL_get_error(sp->ssl, res);
- if (ssl_err == SSL_ERROR_WANT_READ)
- {
- h->io_pending = CS_WANT_READ;
- break;
- }
- if (ssl_err == SSL_ERROR_WANT_WRITE)
- {
- h->io_pending = CS_WANT_WRITE;
+ TRC(fprintf(stderr, "gnutls_record_recv returned 0\n"));
+ return 0;
+ }
+ else if (res < 0)
+ {
+ if (ssl_check_error(h, sp, res))
break;
- }
- if (res == 0)
- return 0;
- h->cerrno = CSERRORSSL;
return -1;
}
hasread += res;
} else if (sp->altsize < req)
if (!(sp->altbuf =(char *)xrealloc(sp->altbuf, sp->altsize = req)))
return -1;
- TRC(fprintf(stderr, " Moving %d bytes to altbuf(0x%x)\n", tomove,
- (unsigned) sp->altbuf));
+ TRC(fprintf(stderr, " Moving %d bytes to altbuf(%p)\n", tomove,
+ sp->altbuf));
memcpy(sp->altbuf, *buf + berlen, sp->altlen = tomove);
}
if (berlen < CS_TCPIP_BUFCHUNK - 1)
int res;
struct tcpip_state *state = (struct tcpip_state *)h->cprivate;
- TRC(fprintf(stderr, "tcpip_put: size=%d\n", size));
+ TRC(fprintf(stderr, "tcpip_put: h=%p size=%d\n", h, size));
h->io_pending = 0;
h->event = CS_DATA;
if (state->towrite < 0)
{
if ((res =
send(h->iofile, buf + state->written, size -
- state->written,
+ state->written,
#ifdef MSG_NOSIGNAL
MSG_NOSIGNAL
#else
#ifdef WIN32
WSAGetLastError() == WSAEWOULDBLOCK
#else
- yaz_errno() == EWOULDBLOCK
+ yaz_errno() == EWOULDBLOCK
#ifdef EAGAIN
#if EAGAIN != EWOULDBLOCK
|| yaz_errno() == EAGAIN
h->io_pending = CS_WANT_WRITE;
return 1;
}
- h->cerrno = CSYSERR;
- return -1;
+ return cont_connect(h);
}
state->written += res;
TRC(fprintf(stderr, " Wrote %d, written=%d, nbytes=%d\n",
}
-#if HAVE_OPENSSL_SSL_H
+#if HAVE_GNUTLS_H
/*
* Returns 1, 0 or -1
* In nonblocking mode, you must call again with same buffer while
}
while (state->towrite > state->written)
{
- res = SSL_write (state->ssl, buf + state->written,
- size - state->written);
+ res = gnutls_record_send(state->session, buf + state->written,
+ size - state->written);
if (res <= 0)
{
- int ssl_err = SSL_get_error(state->ssl, res);
- if (ssl_err == SSL_ERROR_WANT_READ)
- {
- h->io_pending = CS_WANT_READ;
+ if (ssl_check_error(h, state, res))
return 1;
- }
- if (ssl_err == SSL_ERROR_WANT_WRITE)
- {
- h->io_pending = CS_WANT_WRITE;
- return 1;
- }
- h->cerrno = CSERRORSSL;
return -1;
}
state->written += res;
}
#endif
-int tcpip_close(COMSTACK h)
+void tcpip_close(COMSTACK h)
{
tcpip_state *sp = (struct tcpip_state *)h->cprivate;
- TRC(fprintf(stderr, "tcpip_close\n"));
+ TRC(fprintf(stderr, "tcpip_close: h=%p pid=%d\n", h, getpid()));
+#if HAVE_GETADDRINFO
+#if RESOLVER_THREAD
+ if (sp->pipefd[0] != -1)
+ {
+ yaz_thread_join(&sp->thread_id, 0);
+ close(sp->pipefd[0]);
+ close(sp->pipefd[1]);
+ h->iofile = -1;
+ }
+#endif
+#endif
if (h->iofile != -1)
{
-#if HAVE_OPENSSL_SSL_H
- if (sp->ssl)
- {
- SSL_shutdown (sp->ssl);
- }
+#if HAVE_GNUTLS_H
+ if (sp->session)
+ gnutls_bye(sp->session, GNUTLS_SHUT_WR);
#endif
#ifdef WIN32
closesocket(h->iofile);
}
if (sp->altbuf)
xfree(sp->altbuf);
-#if HAVE_OPENSSL_SSL_H
- if (sp->ssl)
+#if HAVE_GNUTLS_H
+ if (sp->session)
{
- TRC (fprintf(stderr, "SSL_free\n"));
- SSL_free (sp->ssl);
+ gnutls_deinit(sp->session);
+ }
+ if (sp->cred_ptr)
+ {
+ assert(sp->cred_ptr->ref > 0);
+
+ if (--(sp->cred_ptr->ref) == 0)
+ {
+ TRC(fprintf(stderr, "Removed credentials %p pid=%d\n",
+ sp->cred_ptr->xcred, getpid()));
+ gnutls_certificate_free_credentials(sp->cred_ptr->xcred);
+ xfree(sp->cred_ptr);
+ }
+ sp->cred_ptr = 0;
}
- sp->ssl = 0;
- if (sp->ctx_alloc)
- SSL_CTX_free (sp->ctx_alloc);
#endif
#if HAVE_GETADDRINFO
if (sp->ai)
freeaddrinfo(sp->ai);
+#if RESOLVER_THREAD
+ xfree(sp->hoststr);
+#endif
#endif
xfree(sp->connect_request_buf);
xfree(sp->connect_response_buf);
xfree(sp);
xfree(h);
- return 0;
}
-char *tcpip_addrstr(COMSTACK h)
+const char *tcpip_addrstr(COMSTACK h)
{
tcpip_state *sp = (struct tcpip_state *)h->cprivate;
char *r = 0, *buf = sp->buf;
char host[120];
struct sockaddr_storage addr;
YAZ_SOCKLEN_T len = sizeof(addr);
-
+
if (getpeername(h->iofile, (struct sockaddr *)&addr, &len) < 0)
{
h->cerrno = CSYSERR;
return 0;
}
- if (getnameinfo((struct sockaddr *) &addr, len, host, sizeof(host)-1,
- 0, 0,
+ if (getnameinfo((struct sockaddr *) &addr, len, host, sizeof(host)-1,
+ 0, 0,
(h->flags & CS_FLAGS_NUMERICHOST) ? NI_NUMERICHOST : 0))
{
r = "unknown";
}
else
r = host;
-
+
#else
struct sockaddr_in addr;
YAZ_SOCKLEN_T len = sizeof(addr);
struct hostent *host;
-
+
if (getpeername(h->iofile, (struct sockaddr*) &addr, &len) < 0)
{
h->cerrno = CSYSERR;
r = (char*) host->h_name;
}
if (!r)
- r = inet_ntoa(addr.sin_addr);
+ r = inet_ntoa(addr.sin_addr);
#endif
if (h->protocol == PROTO_HTTP)
sprintf(buf, "http:%s", r);
else
sprintf(buf, "tcp:%s", r);
-#if HAVE_OPENSSL_SSL_H
- if (sp->ctx)
+#if HAVE_GNUTLS_H
+ if (sp->session)
{
if (h->protocol == PROTO_HTTP)
sprintf(buf, "https:%s", r);
return buf;
}
-int static tcpip_set_blocking(COMSTACK p, int flags)
+static int tcpip_set_blocking(COMSTACK p, int flags)
{
unsigned long flag;
-
+
#ifdef WIN32
flag = (flags & CS_FLAGS_BLOCKING) ? 0 : 1;
if (ioctlsocket(p->iofile, FIONBIO, &flag) < 0)
return 1;
}
-#if HAVE_OPENSSL_SSL_H
-int cs_set_ssl_ctx(COMSTACK cs, void *ctx)
-{
- struct tcpip_state *sp;
- if (!cs || cs->type != ssl_type)
- return 0;
- sp = (struct tcpip_state *) cs->cprivate;
- if (sp->ctx_alloc)
- return 0;
- sp->ctx = (SSL_CTX *) ctx;
- return 1;
-}
-void *cs_get_ssl(COMSTACK cs)
+#if HAVE_GNUTLS_H
+/* gnutls_x509_crt_print appeared in 1.7.6. Memory leaks were fixed in 1.7.9.
+ GNUTLS_CRT_PRINT_FULL appeared in 2.4.0. */
+#if GNUTLS_VERSION_NUMBER >= 0x020400
+#define USE_GNUTLS_X509_CRT_PRINT 1
+#else
+#define USE_GNUTLS_X509_CRT_PRINT 0
+#endif
+
+
+#if USE_GNUTLS_X509_CRT_PRINT
+#else
+static const char *bin2hex(const void *bin, size_t bin_size)
{
- struct tcpip_state *sp;
- if (!cs || cs->type != ssl_type)
- return 0;
- sp = (struct tcpip_state *) cs->cprivate;
- return sp->ssl;
+ static char printable[110];
+ const unsigned char *_bin = bin;
+ char *print;
+ size_t i;
+ if (bin_size > 50)
+ bin_size = 50;
+ print = printable;
+ for (i = 0; i < bin_size; i++)
+ {
+ sprintf(print, "%.2x ", _bin[i]);
+ print += 2;
+ }
+ return printable;
}
-int cs_set_ssl_certificate_file(COMSTACK cs, const char *fname)
+static void x509_crt_print(gnutls_x509_crt_t cert)
{
- struct tcpip_state *sp;
- if (!cs || cs->type != ssl_type)
- return 0;
- sp = (struct tcpip_state *) cs->cprivate;
- strncpy(sp->cert_fname, fname, sizeof(sp->cert_fname)-1);
- sp->cert_fname[sizeof(sp->cert_fname)-1] = '\0';
- return 1;
+ time_t expiration_time, activation_time;
+ size_t size;
+ char serial[40];
+ char dn[256];
+ unsigned int algo, bits;
+
+ expiration_time = gnutls_x509_crt_get_expiration_time(cert);
+ activation_time = gnutls_x509_crt_get_activation_time(cert);
+
+ printf("\tCertificate is valid since: %s", ctime(&activation_time));
+ printf("\tCertificate expires: %s", ctime(&expiration_time));
+
+ /* Print the serial number of the certificate. */
+ size = sizeof(serial);
+ gnutls_x509_crt_get_serial(cert, serial, &size);
+
+ printf("\tCertificate serial number: %s\n", bin2hex(serial, size));
+
+ /* Extract some of the public key algorithm's parameters
+ */
+ algo = gnutls_x509_crt_get_pk_algorithm(cert, &bits);
+
+ printf("Certificate public key: %s", gnutls_pk_algorithm_get_name(algo));
+
+ /* Print the version of the X.509 certificate. */
+ printf("\tCertificate version: #%d\n", gnutls_x509_crt_get_version(cert));
+
+ size = sizeof(dn);
+ gnutls_x509_crt_get_dn(cert, dn, &size);
+ printf("\tDN: %s\n", dn);
+
+ size = sizeof(dn);
+ gnutls_x509_crt_get_issuer_dn(cert, dn, &size);
+ printf("\tIssuer's DN: %s\n", dn);
}
+#endif
+#endif
-int cs_get_peer_certificate_x509(COMSTACK cs, char **buf, int *len)
+void cs_print_session_info(COMSTACK cs)
{
- SSL *ssl = (SSL *) cs_get_ssl(cs);
- if (ssl)
+#if HAVE_GNUTLS_H
+ struct tcpip_state *sp = (struct tcpip_state *) cs->cprivate;
+ if (cs->type == ssl_type && sp->session)
{
- X509 *server_cert = SSL_get_peer_certificate (ssl);
- if (server_cert)
+ const gnutls_datum_t *cert_list;
+ unsigned i, cert_list_size;
+ if (gnutls_certificate_type_get(sp->session) != GNUTLS_CRT_X509)
+ return;
+ printf("X509 certificate\n");
+ cert_list = gnutls_certificate_get_peers(sp->session,
+ &cert_list_size);
+ printf("Peer provided %u certificates\n", cert_list_size);
+ for (i = 0; i < cert_list_size; i++)
{
- BIO *bio = BIO_new(BIO_s_mem());
- char *pem_buf;
- /* get PEM buffer in memory */
- PEM_write_bio_X509(bio, server_cert);
- *len = BIO_get_mem_data(bio, &pem_buf);
- *buf = (char *) xmalloc(*len);
- memcpy(*buf, pem_buf, *len);
- BIO_free(bio);
- return 1;
+ gnutls_x509_crt_t cert;
+#if USE_GNUTLS_X509_CRT_PRINT
+ int ret;
+ gnutls_datum_t cinfo;
+#endif
+ gnutls_x509_crt_init(&cert);
+ gnutls_x509_crt_import(cert, &cert_list[i], GNUTLS_X509_FMT_DER);
+ printf("Certificate info %d:\n", i + 1);
+#if USE_GNUTLS_X509_CRT_PRINT
+ ret = gnutls_x509_crt_print(cert, GNUTLS_CRT_PRINT_FULL,
+ &cinfo);
+ if (ret == 0)
+ {
+ printf("\t%s\n", cinfo.data);
+ gnutls_free(cinfo.data);
+ }
+#else
+ x509_crt_print(cert);
+#endif
+ gnutls_x509_crt_deinit(cert);
+
}
}
- return 0;
-}
-#else
-int cs_set_ssl_ctx(COMSTACK cs, void *ctx)
-{
- return 0;
+#endif
}
void *cs_get_ssl(COMSTACK cs)
{
+ /* doesn't do anything for GNUTLS */
return 0;
}
-int cs_get_peer_certificate_x509(COMSTACK cs, char **buf, int *len)
+int cs_set_ssl_ctx(COMSTACK cs, void *ctx)
{
+#if HAVE_GNUTLS_H
+ if (cs && cs->type == ssl_type)
+ {
+ /* doesn't do anything for GNUTLS */
+ return 1;
+ }
+#endif
return 0;
}
int cs_set_ssl_certificate_file(COMSTACK cs, const char *fname)
{
+#if HAVE_GNUTLS_H
+ if (cs && cs->type == ssl_type)
+ {
+ struct tcpip_state *sp = (struct tcpip_state *) cs->cprivate;
+ strncpy(sp->cert_fname, fname, sizeof(sp->cert_fname)-1);
+ sp->cert_fname[sizeof(sp->cert_fname)-1] = '\0';
+ return 1;
+ }
+#endif
return 0;
}
-#endif
+int cs_get_peer_certificate_x509(COMSTACK cs, char **buf, int *len)
+{
+
+#if HAVE_GNUTLS_H
+#if USE_GNUTLS_X509_CRT_PRINT
+ struct tcpip_state *sp = (struct tcpip_state *) cs->cprivate;
+ if (cs->type == ssl_type && sp->session)
+ {
+ const gnutls_datum_t *cert_list;
+ unsigned cert_list_size;
+ if (gnutls_certificate_type_get(sp->session) != GNUTLS_CRT_X509)
+ return 0;
+ cert_list = gnutls_certificate_get_peers(sp->session, &cert_list_size);
+ if (cert_list_size > 0)
+ {
+ gnutls_x509_crt_t cert;
+ int ret;
+ gnutls_datum_t cinfo;
+
+ gnutls_x509_crt_init(&cert);
+ gnutls_x509_crt_import(cert, &cert_list[0], GNUTLS_X509_FMT_DER);
+
+ ret = gnutls_x509_crt_print(cert, GNUTLS_CRT_PRINT_FULL, &cinfo);
+ if (ret == 0)
+ {
+ *buf = xstrdup((char *) cinfo.data);
+ *len = strlen(*buf);
+ gnutls_free(cinfo.data);
+ gnutls_x509_crt_deinit(cert);
+ return 1;
+ }
+ gnutls_x509_crt_deinit(cert);
+ }
+ }
+#endif
+#endif
+ return 0;
+}
static int tcpip_put_connect(COMSTACK h, char *buf, int size)
{
struct tcpip_state *state = (struct tcpip_state *)h->cprivate;
int r;
- r = tcpip_get(h, &state->connect_response_buf,
+ r = tcpip_get(h, &state->connect_response_buf,
&state->connect_response_len);
if (r < 1)
return r;
/*
* Local variables:
* c-basic-offset: 4
+ * c-file-style: "Stroustrup"
* indent-tabs-mode: nil
* End:
* vim: shiftwidth=4 tabstop=8 expandtab