/* This file is part of the YAZ toolkit.
- * Copyright (C) 1995-2013 Index Data
+ * Copyright (C) Index Data
* See the file LICENSE for details.
*/
/**
#include <errno.h>
#include <fcntl.h>
#include <signal.h>
+#include <yaz/base64.h>
#if HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
#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 */
#if HAVE_GNUTLS_H
#include <gnutls/x509.h>
#include <gnutls/gnutls.h>
-#define ENABLE_SSL 1
-#endif
-
-#if HAVE_OPENSSL_SSL_H
-#include <openssl/ssl.h>
-#include <openssl/err.h>
-#define ENABLE_SSL 1
#endif
#include <yaz/comstack.h>
#include <yaz/tcpip.h>
#include <yaz/errno.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);
-static int tcpip_get_connect(COMSTACK h, char **buf, int *bufsize);
static int tcpip_connect(COMSTACK h, void *address);
static int tcpip_more(COMSTACK h);
static int tcpip_rcvconnect(COMSTACK h);
void *cd);
static int tcpip_set_blocking(COMSTACK p, int blocking);
-#if ENABLE_SSL
+#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
+
+#if HAVE_GETADDRINFO
+struct addrinfo *tcpip_getaddrinfo(const char *str, const char *port,
+ int *ipv6_only);
+#endif
+
static COMSTACK tcpip_accept(COMSTACK h);
static const char *tcpip_addrstr(COMSTACK h);
static void *tcpip_straddr(COMSTACK h, const char *str);
int (*complete)(const char *buf, int len); /* length/complete. */
#if HAVE_GETADDRINFO
struct addrinfo *ai;
+ struct addrinfo *ai_connect;
+ int ipv6_only;
+ char *bind_host;
+#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
struct tcpip_cred_ptr *cred_ptr;
gnutls_session_t session;
char cert_fname[256];
-#elif 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;
- char cert_fname[256];
#endif
char *connect_request_buf;
int connect_request_len;
int connect_response_len;
} tcpip_state;
-#ifdef WIN32
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;
+ sp->bind_host = 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())
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->cerrno = 0;
p->user = 0;
-#if HAVE_GNUTLS_H
- sp->cred_ptr = 0;
- sp->session = 0;
- strcpy(sp->cert_fname, "yaz.pem");
-#elif 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 h=%p\n", p));
return p;
}
-COMSTACK yaz_tcpip_create(int s, int flags, int protocol,
- const char *connect_host)
+static void connect_and_bind(COMSTACK p,
+ const char *connect_host, const char *connect_auth,
+ const char *bind_host)
{
- COMSTACK p = tcpip_type(s, flags, protocol, 0);
- if (!p)
- return 0;
+ if (bind_host)
+ {
+ tcpip_state *sp = (tcpip_state *) p->cprivate;
+ char *cp;
+ sp->bind_host = xmalloc(strlen(bind_host) + 4);
+ strcpy(sp->bind_host, bind_host);
+ cp = strrchr(sp->bind_host, ':');
+
+ if (!cp || cp[1] == '\0')
+ strcat(sp->bind_host, ":0");
+ else
+ strcpy(cp, ":0");
+ }
if (connect_host)
{
tcpip_state *sp = (tcpip_state *) p->cprivate;
- sp->connect_request_buf = (char *) xmalloc(strlen(connect_host) + 30);
- sprintf(sp->connect_request_buf, "CONNECT %s HTTP/1.0\r\n\r\n",
- connect_host);
+ char *cp;
+ sp->connect_request_buf = (char *) xmalloc(strlen(connect_host) + 130);
+ strcpy(sp->connect_request_buf, "CONNECT ");
+ strcat(sp->connect_request_buf, connect_host);
+ cp = strchr(sp->connect_request_buf, '/');
+ if (cp)
+ *cp = '\0';
+ strcat(sp->connect_request_buf, " HTTP/1.0\r\n");
+ if (connect_auth && strlen(connect_auth) < 40)
+ {
+ strcat(sp->connect_request_buf, "Proxy-Authorization: Basic ");
+ yaz_base64encode(connect_auth, sp->connect_request_buf +
+ strlen(sp->connect_request_buf));
+ strcat(sp->connect_request_buf, "\r\n");
+ }
+ strcat(sp->connect_request_buf, "\r\n");
sp->connect_request_len = strlen(sp->connect_request_buf);
- p->f_put = tcpip_put_connect;
- p->f_get = tcpip_get_connect;
- sp->complete = cs_complete_auto_head; /* only want HTTP header */
}
+}
+
+COMSTACK yaz_tcpip_create3(int s, int flags, int protocol,
+ const char *connect_host,
+ const char *connect_auth,
+ const char *bind_host)
+{
+ COMSTACK p = tcpip_type(s, flags, protocol, 0);
+ if (!p)
+ return 0;
+ connect_and_bind(p, connect_host, 0, bind_host);
return p;
}
+COMSTACK yaz_tcpip_create2(int s, int flags, int protocol,
+ const char *connect_host,
+ const char *bind_host)
+{
+ return yaz_tcpip_create3(s, flags, protocol, connect_host, 0, bind_host);
+}
+
+COMSTACK yaz_tcpip_create(int s, int flags, int protocol,
+ const char *connect_host)
+{
+ return yaz_tcpip_create2(s, flags, protocol, connect_host, 0);
+}
+
#if HAVE_GNUTLS_H
static void tcpip_create_cred(COMSTACK cs)
{
COMSTACK ssl_type(int s, int flags, int protocol, void *vp)
{
-#if !ENABLE_SSL
- return 0;
-#else
+#if HAVE_GNUTLS_H
tcpip_state *sp;
COMSTACK p;
p->type = ssl_type;
sp = (tcpip_state *) p->cprivate;
-#if HAVE_GNUTLS_H
sp->session = (gnutls_session_t) vp;
-#elif HAVE_OPENSSL_SSL_H
- sp->ctx = (SSL_CTX *) vp; /* may be NULL */
-#endif
/* note: we don't handle already opened socket in SSL mode - yet */
return p;
+#else
+ return 0;
#endif
}
-#if ENABLE_SSL
+COMSTACK yaz_ssl_create(int s, int flags, int protocol,
+ const char *connect_host,
+ const char *connect_auth,
+ const char *bind_host)
+{
+ COMSTACK p = ssl_type(s, flags, protocol, 0);
+ if (!p)
+ return 0;
+ connect_and_bind(p, connect_host, connect_auth, bind_host);
+ return p;
+}
+
+#if HAVE_GNUTLS_H
static int ssl_check_error(COMSTACK h, tcpip_state *sp, int res)
{
-#if HAVE_OPENSSL_SSL_H
- int err = SSL_get_error(sp->ssl, res);
- TRC(fprintf(stderr, "got err=%d\n", err));
- if (err == SSL_ERROR_WANT_READ)
- {
- TRC(fprintf(stderr, " -> SSL_ERROR_WANT_READ\n"));
- h->io_pending = CS_WANT_READ;
- return 1;
- }
- if (err == SSL_ERROR_WANT_WRITE)
- {
- TRC(fprintf(stderr, " -> SSL_ERROR_WANT_WRITE\n"));
- h->io_pending = CS_WANT_WRITE;
- return 1;
- }
-#elif HAVE_GNUTLS_H
TRC(fprintf(stderr, "ssl_check_error error=%d fatal=%d msg=%s\n",
res,
gnutls_error_is_fatal(res),
h->io_pending = dir ? CS_WANT_WRITE : CS_WANT_READ;
return 1;
}
-#endif
h->cerrno = CSERRORSSL;
return 0;
}
strncpy(host, str, sizeof(host)-1);
host[sizeof(host)-1] = 0;
+ if ((p = strrchr(host, ' ')))
+ *p = 0;
if ((p = strchr(host, '/')))
*p = 0;
if ((p = strrchr(host, ':')))
if (!strcmp("@", host))
{
hints.ai_flags = AI_PASSIVE;
- hints.ai_family = AF_INET6;
+ hints.ai_family = AF_UNSPEC;
error = getaddrinfo(0, port, &hints, &res);
*ipv6_only = 0;
}
}
#if HAVE_GETADDRINFO
+static struct addrinfo *create_net_socket(COMSTACK h)
+{
+ tcpip_state *sp = (tcpip_state *)h->cprivate;
+ 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)
+ {
+ 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)
+ 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 (sp->bind_host)
+ {
+ int r = -1;
+ int ipv6_only = 0;
+ struct addrinfo *ai;
+
+#ifndef WIN32
+ int one = 1;
+ if (setsockopt(h->iofile, SOL_SOCKET, SO_REUSEADDR, (char*)
+ &one, sizeof(one)) < 0)
+ {
+ h->cerrno = CSYSERR;
+ return 0;
+ }
+#endif
+ ai = tcpip_getaddrinfo(sp->bind_host, "0", &ipv6_only);
+ if (!ai)
+ return 0;
+ {
+ struct addrinfo *a;
+ for (a = ai; a; a = a->ai_next)
+ {
+ r = bind(h->iofile, a->ai_addr, a->ai_addrlen);
+ if (!r)
+ break;
+ }
+ }
+ if (r)
+ {
+ h->cerrno = CSYSERR;
+ freeaddrinfo(ai);
+ return 0;
+ }
+ freeaddrinfo(ai);
+ }
+ 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";
- struct addrinfo *ai = 0;
- int ipv6_only = 0;
+
+ if (!tcpip_init())
+ return 0;
+
if (h->protocol == PROTO_HTTP)
{
if (h->type == ssl_type)
else
port = "80";
}
- if (!tcpip_init())
- return 0;
+#if RESOLVER_THREAD
+ if (h->flags & CS_FLAGS_DNS_NO_BLOCK)
+ {
+ if (sp->pipefd[0] != -1)
+ return 0;
+ 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, &ipv6_only);
+ sp->ai = tcpip_getaddrinfo(str, port, &sp->ipv6_only);
if (sp->ai && h->state == CS_ST_UNBND)
{
- int s = -1;
- 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)
- return 0;
- assert(ai);
- h->iofile = s;
- if (ipv6_only >= 0 &&
- setsockopt(h->iofile,
- IPPROTO_IPV6,
- IPV6_V6ONLY, &ipv6_only, sizeof(ipv6_only)))
- return 0;
- if (!tcpip_set_blocking(h, h->flags))
- return 0;
+ return create_net_socket(h);
}
- return ai;
+ return sp->ai;
}
+
#else
void *tcpip_straddr(COMSTACK h, const char *str)
{
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
return -1;
}
#if HAVE_GETADDRINFO
+#if RESOLVER_THREAD
+ if (sp->pipefd[0] != -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;
+ }
+ }
+#endif
r = connect(h->iofile, ai->ai_addr, ai->ai_addrlen);
- freeaddrinfo(sp->ai);
- sp->ai = 0;
+ 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;
*/
int tcpip_rcvconnect(COMSTACK h)
{
-#if ENABLE_SSL
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 (sp->connect_request_buf)
+ {
+ int r;
+
+ sp->complete = cs_complete_auto_head;
+ if (sp->connect_request_len > 0)
+ {
+ r = tcpip_put(h, sp->connect_request_buf,
+ sp->connect_request_len);
+ TRC(fprintf(stderr, "tcpip_put CONNECT r=%d\n", r));
+ if (r) /* < 0 is error, 1 is in-complete */
+ return r;
+ TRC(fprintf(stderr, "tcpip_put CONNECT complete\n"));
+ TRC(fwrite(sp->connect_request_buf, 1, sp->connect_request_len, stderr));
+ }
+ sp->connect_request_len = 0;
+
+ r = tcpip_get(h, &sp->connect_response_buf, &sp->connect_response_len);
+ TRC(fprintf(stderr, "tcpip_get CONNECT r=%d\n", r));
+ if (r == 1)
+ return r;
+ if (r <= 0)
+ return -1;
+ TRC(fwrite(sp->connect_response_buf, 1, r, stderr));
+ xfree(sp->connect_request_buf);
+ sp->connect_request_buf = 0;
+ sp->complete = cs_complete_auto;
+ }
#if HAVE_GNUTLS_H
if (h->type == ssl_type && !sp->session)
{
- gnutls_global_init();
tcpip_create_cred(h);
gnutls_init(&sp->session, GNUTLS_CLIENT);
gnutls_set_default_priority(sp->session);
{
if (ssl_check_error(h, sp, res))
return 1;
- return -1;
- }
- }
-#elif HAVE_OPENSSL_SSL_H
- if (h->type == ssl_type && !sp->ctx)
- {
- SSL_library_init();
- SSL_load_error_strings();
-
- sp->ctx = sp->ctx_alloc = SSL_CTX_new(SSLv23_client_method());
- if (!sp->ctx)
- {
- h->cerrno = CSERRORSSL;
- return -1;
- }
- }
- if (sp->ctx)
- {
- 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)
- {
- if (ssl_check_error(h, sp, res))
- return 1;
- return -1;
+ return cont_connect(h);
}
}
#endif
int one = 1;
#endif
+#if HAVE_GETADDRINFO
+#if RESOLVER_THREAD
+ if (sp->pipefd[0] != -1)
+ {
+ ai = wait_resolver_thread(h);
+ if (!ai)
+ return -1;
+ }
+#endif
+#endif
#if HAVE_GNUTLS_H
if (h->type == ssl_type && !sp->session)
{
int res;
- gnutls_global_init();
-
tcpip_create_cred(h);
-
res = gnutls_certificate_set_x509_key_file(sp->cred_ptr->xcred,
sp->cert_fname,
sp->cert_fname,
return -1;
}
}
-#elif HAVE_OPENSSL_SSL_H
- if (h->type == ssl_type && !sp->ctx)
- {
- SSL_library_init();
- SSL_load_error_strings();
-
- sp->ctx = sp->ctx_alloc = SSL_CTX_new(SSLv23_server_method());
- if (!sp->ctx)
- {
- h->cerrno = CSERRORSSL;
- return -1;
- }
- }
- if (sp->ctx)
- {
- if (sp->ctx_alloc)
- {
- int res;
- res = SSL_CTX_use_certificate_file(sp->ctx, sp->cert_fname,
- SSL_FILETYPE_PEM);
- 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"));
#endif
TRC(fprintf(stderr, "tcpip_accept h=%p pid=%d\n", h, getpid()));
if (h->state == CS_ST_INCON)
{
- tcpip_state *state, *st = (tcpip_state *)h->cprivate;
- 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;
+ cnew->cprivate = state;
- 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;
- }
if (!tcpip_set_blocking(cnew, cnew->flags))
{
h->cerrno = CSYSERR;
#endif
h->newfd = -1;
}
- xfree(cnew);
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_GNUTLS_H
state->cred_ptr = st->cred_ptr;
- state->session = 0;
if (st->cred_ptr)
{
int res;
(gnutls_transport_ptr_t)
(size_t) cnew->iofile);
}
-#elif HAVE_OPENSSL_SSL_H
- state->ctx = st->ctx;
- state->ctx_alloc = 0;
- state->ssl = st->ssl;
- if (state->ctx)
- {
- state->ssl = SSL_new(state->ctx);
- SSL_set_fd(state->ssl, cnew->iofile);
- }
#endif
- state->connect_request_buf = 0;
- state->connect_response_buf = 0;
h = cnew;
}
if (h->state == CS_ST_ACCEPT)
}
TRC(fprintf(stderr, "SSL_accept complete. gnutls\n"));
}
-#elif HAVE_OPENSSL_SSL_H
- tcpip_state *state = (tcpip_state *)h->cprivate;
- if (state->ctx)
- {
- int res;
- errno = 0;
- res = SSL_accept(state->ssl);
- TRC(fprintf(stderr, "SSL_accept res=%d\n", res));
- if (res <= 0)
- {
- if (ssl_check_error(h, state, res))
- {
- return h;
- }
- cs_close(h);
- return 0;
- }
- TRC(fprintf(stderr, "SSL_accept complete\n"));
- }
#endif
}
else
}
-#if ENABLE_SSL
+#if HAVE_GNUTLS_H
/*
* Return: -1 error, >1 good, len of buffer, ==1 incomplete buffer,
* 0=connection closed.
else if (*bufsize - hasread < CS_TCPIP_BUFCHUNK)
if (!(*buf =(char *)xrealloc(*buf, *bufsize *= 2)))
return -1;
-#if HAVE_GNUTLS_H
res = gnutls_record_recv(sp->session, *buf + hasread,
CS_TCPIP_BUFCHUNK);
if (res == 0)
break;
return -1;
}
-#else
- 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)
- {
- if (ssl_check_error(h, sp, res))
- break;
- return -1;
- }
-#endif
hasread += res;
}
TRC (fprintf (stderr, " Out of read loop with hasread=%d, berlen=%d\n",
h->io_pending = CS_WANT_WRITE;
return 1;
}
- h->cerrno = CSYSERR;
- return -1;
+ if (h->flags & CS_FLAGS_BLOCKING)
+ {
+ h->cerrno = CSYSERR;
+ return -1;
+ }
+ else
+ return cont_connect(h);
}
state->written += res;
TRC(fprintf(stderr, " Wrote %d, written=%d, nbytes=%d\n",
}
-#if ENABLE_SSL
+#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)
{
-#if HAVE_GNUTLS_H
res = gnutls_record_send(state->session, buf + state->written,
size - state->written);
if (res <= 0)
return 1;
return -1;
}
-#else
- res = SSL_write(state->ssl, buf + state->written,
- size - state->written);
- if (res <= 0)
- {
- if (ssl_check_error(h, state, res))
- return 1;
- return -1;
- }
-#endif
state->written += res;
TRC(fprintf(stderr, " Wrote %d, written=%d, nbytes=%d\n",
res, state->written, size));
tcpip_state *sp = (struct tcpip_state *)h->cprivate;
TRC(fprintf(stderr, "tcpip_close: h=%p pid=%d\n", h, getpid()));
+#if HAVE_GETADDRINFO
+ xfree(sp->bind_host);
+#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_GNUTLS_H
if (sp->session)
gnutls_bye(sp->session, GNUTLS_SHUT_WR);
-#elif HAVE_OPENSSL_SSL_H
- if (sp->ssl)
- {
- SSL_shutdown(sp->ssl);
- }
#endif
#ifdef WIN32
closesocket(h->iofile);
}
sp->cred_ptr = 0;
}
-#elif HAVE_OPENSSL_SSL_H
- if (sp->ssl)
- {
- TRC(fprintf(stderr, "SSL_free\n"));
- SSL_free(sp->ssl);
- }
- 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);
else
sprintf(buf, "ssl:%s", r);
}
-#elif HAVE_OPENSSL_SSL_H
- if (sp->ctx)
- {
- if (h->protocol == PROTO_HTTP)
- sprintf(buf, "https:%s", r);
- else
- sprintf(buf, "ssl:%s", r);
- }
#endif
return buf;
}
}
}
-#elif HAVE_OPENSSL_SSL_H
- if (cs->type == ssl_type)
- {
- struct tcpip_state *sp = (struct tcpip_state *) cs->cprivate;
- SSL *ssl = (SSL *) sp->ssl;
- if (ssl)
- {
- X509 *server_cert = SSL_get_peer_certificate(ssl);
- if (server_cert)
- {
- char *pem_buf;
- int pem_len;
- BIO *bio = BIO_new(BIO_s_mem());
-
- /* get PEM buffer in memory */
- PEM_write_bio_X509(bio, server_cert);
- pem_len = BIO_get_mem_data(bio, &pem_buf);
- fwrite(pem_buf, pem_len, 1, stdout);
-
- /* print all info on screen .. */
- X509_print_fp(stdout, server_cert);
- BIO_free(bio);
-
- X509_free(server_cert);
- }
- }
- }
#endif
}
void *cs_get_ssl(COMSTACK cs)
{
-#if HAVE_OPENSSL_SSL_H
- if (cs && cs->type == ssl_type)
- {
- struct tcpip_state *sp = (struct tcpip_state *) cs->cprivate;
- return sp->ssl;
- }
-#endif
+ /* doesn't do anything for GNUTLS */
return 0;
}
int cs_set_ssl_ctx(COMSTACK cs, void *ctx)
{
-#if ENABLE_SSL
+#if HAVE_GNUTLS_H
if (cs && cs->type == ssl_type)
{
-#if HAVE_OPENSSL_SSL_H
- struct tcpip_state *sp = (struct tcpip_state *) cs->cprivate;
- if (sp->ctx_alloc)
- return 0;
- sp->ctx = (SSL_CTX *) ctx;
-#endif
+ /* doesn't do anything for GNUTLS */
return 1;
}
#endif
int cs_set_ssl_certificate_file(COMSTACK cs, const char *fname)
{
-#if ENABLE_SSL
+#if HAVE_GNUTLS_H
if (cs && cs->type == ssl_type)
{
struct tcpip_state *sp = (struct tcpip_state *) cs->cprivate;
int cs_get_peer_certificate_x509(COMSTACK cs, char **buf, int *len)
{
-#if HAVE_OPENSSL_SSL_H
- SSL *ssl = (SSL *) cs_get_ssl(cs);
- if (ssl)
+
+#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)
{
- X509 *server_cert = SSL_get_peer_certificate(ssl);
- if (server_cert)
+ 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)
{
- 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;
+ 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 = tcpip_put(h, state->connect_request_buf,
- state->connect_request_len);
- if (r == 0)
- {
- /* it's sent */
- h->f_put = tcpip_put; /* switch to normal tcpip put */
- r = tcpip_put(h, buf, size);
- }
- return r;
-}
-
-static int tcpip_get_connect(COMSTACK h, char **buf, int *bufsize)
-{
- struct tcpip_state *state = (struct tcpip_state *)h->cprivate;
- int r;
-
- r = tcpip_get(h, &state->connect_response_buf,
- &state->connect_response_len);
- if (r < 1)
- return r;
- /* got the connect response completely */
- state->complete = cs_complete_auto; /* switch to normal tcpip get */
- h->f_get = tcpip_get;
- return tcpip_get(h, buf, bufsize);
-}
-
-
/*
* Local variables:
* c-basic-offset: 4
projects / yaz-moved-to-github.git / blobdiff