/* This file is part of the YAZ toolkit.
- * Copyright (C) 1995-2008 Index Data
+ * Copyright (C) 1995-2011 Index Data
* See the file LICENSE for details.
*/
/**
* \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>
#endif
#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
#if HAVE_GNUTLS_H
#include <gnutls/x509.h>
#include <gnutls/gnutls.h>
-#define ENABLE_SSL 2
-
-#if ENABLE_SSL == 1
-#include <gnutls/openssl.h>
-#endif
-
+#define ENABLE_SSL 1
#endif
#if HAVE_OPENSSL_SSL_H
#include <yaz/comstack.h>
#include <yaz/tcpip.h>
-#include <yaz/nmem.h>
+#include <yaz/errno.h>
-static int tcpip_close(COMSTACK h);
+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);
#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
{
struct sockaddr_in addr; /* returned by cs_straddr */
#endif
char buf[128]; /* returned by cs_addrstr */
-#if ENABLE_SSL == 2
- gnutls_certificate_credentials_t xcred;
+#if HAVE_GNUTLS_H
+ struct tcpip_cred_ptr *cred_ptr;
gnutls_session_t session;
char cert_fname[256];
-#elif ENABLE_SSL == 1
+#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;
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 ENABLE_SSL == 2
- sp->xcred = 0;
+#if HAVE_GNUTLS_H
+ sp->cred_ptr = 0;
sp->session = 0;
-#elif ENABLE_SSL == 1
+ 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");
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);
+}
+
+#endif
COMSTACK ssl_type(int s, int flags, int protocol, void *vp)
{
p->type = ssl_type;
sp = (tcpip_state *) p->cprivate;
-#if ENABLE_SSL == 2
+#if HAVE_GNUTLS_H
sp->session = (gnutls_session_t) vp;
-#else
+#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 */
h->io_pending = CS_WANT_WRITE;
return 1;
}
-#else
-#if ENABLE_SSL == 2
- fprintf(stderr, "ssl_check_error error=%d fatal=%d msg=%s\n",
- res,
- gnutls_error_is_fatal(res),
- gnutls_strerror(res));
+#elif HAVE_GNUTLS_H
+ 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);
h->io_pending = dir ? CS_WANT_WRITE : CS_WANT_READ;
return 1;
}
-#else
- int tls_error = sp->ssl->last_error;
- TRC(fprintf(stderr, "ssl_check_error error=%d fatal=%d msg=%s\n",
- sp->ssl->last_error,
- gnutls_error_is_fatal(tls_error),
- gnutls_strerror(tls_error)));
- if (tls_error == GNUTLS_E_AGAIN || tls_error == GNUTLS_E_INTERRUPTED)
- {
- int dir = gnutls_record_get_direction(sp->ssl->gnutls_state);
- TRC(fprintf(stderr, " -> incomplete dir=%d\n", dir));
- h->io_pending = dir ? CS_WANT_WRITE : CS_WANT_READ;
- return 1;
- }
-#endif
#endif
h->cerrno = CSERRORSSL;
return 0;
if (!strcmp("@", host))
{
hints.ai_flags = AI_PASSIVE;
+ hints.ai_family = AF_INET;
+ error = getaddrinfo(0, port, &hints, &res);
+ }
+ else if (!strcmp("@6", host))
+ {
+ hints.ai_flags = AI_PASSIVE;
+ hints.ai_family = AF_INET6;
error = getaddrinfo(0, port, &hints, &res);
}
else
return 1;
}
-
#if HAVE_GETADDRINFO
void *tcpip_straddr(COMSTACK h, const char *str)
{
tcpip_state *sp = (tcpip_state *)h->cprivate;
const char *port = "210";
+ struct addrinfo *ai = 0;
if (h->protocol == PROTO_HTTP)
port = "80";
if (!tcpip_init())
if (sp->ai && h->state == CS_ST_UNBND)
{
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)
}
if (s == -1)
return 0;
+ assert(ai);
h->iofile = s;
if (!tcpip_set_blocking(h, h->flags))
return 0;
}
- return sp->ai;
+ return ai;
}
#else
void *tcpip_straddr(COMSTACK h, const char *str)
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"));
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 )
- {
- 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;
- }
- 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);
+ r = connect(h->iofile, ai->ai_addr, ai->ai_addrlen);
freeaddrinfo(sp->ai);
sp->ai = 0;
#else
{
#if ENABLE_SSL
tcpip_state *sp = (tcpip_state *)h->cprivate;
- int res;
#endif
TRC(fprintf(stderr, "tcpip_rcvconnect\n"));
h->cerrno = CSOUTSTATE;
return -1;
}
-#if ENABLE_SSL == 2
- gnutls_global_init();
-
- gnutls_certificate_allocate_credentials(&sp->xcred);
- gnutls_init(&sp->session, GNUTLS_CLIENT);
- gnutls_priority_set_direct(sp->session,
- "PERFORMANCE", NULL);
-
- gnutls_credentials_set (sp->session, GNUTLS_CRD_CERTIFICATE, sp->xcred);
-
- gnutls_transport_set_ptr(sp->session, (gnutls_transport_ptr_t) h->iofile);
-
- res = gnutls_handshake(sp->session);
- if (res < 0)
+#if HAVE_GNUTLS_H
+ if (h->type == ssl_type && !sp->session)
{
- if (ssl_check_error(h, sp, res))
- return 1;
- return -1;
+ int res;
+ gnutls_global_init();
+
+ 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);
+ res = gnutls_handshake(sp->session);
+ if (res < 0)
+ {
+ if (ssl_check_error(h, sp, res))
+ return 1;
+ return -1;
+ }
}
-#elif ENABLE_SSL == 1
+#elif HAVE_OPENSSL_SSL_H
if (h->type == ssl_type && !sp->ctx)
{
SSL_library_init();
#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
+#if HAVE_GETADDRINFO
+ struct addrinfo *ai = (struct addrinfo *) address;
#else
struct sockaddr *addr = (struct sockaddr *)address;
#endif
int one = 1;
#endif
-#if HAVE_GETADDRINFO
- if (sp->ai != (struct addrinfo *) address)
+#if HAVE_GNUTLS_H
+ if (h->type == ssl_type && !sp->session)
{
- h->cerrno = CSOUTSTATE;
- return -1;
- }
-#endif
+ int res;
+ gnutls_global_init();
-#if ENABLE_SSL == 2
- exit(9);
-#elif ENABLE_SSL == 1
+ 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;
+ }
+ }
+#elif HAVE_OPENSSL_SSL_H
if (h->type == ssl_type && !sp->ctx)
{
SSL_library_init();
SSL_FILETYPE_PEM);
if (res <= 0)
{
-#if HAVE_OPENSSL_SSL_H
ERR_print_errors_fp(stderr);
-#else
- fprintf(stderr, " SSL_CTX_use_certificate_file %s failed\n",
- sp->cert_fname);
-#endif
exit(2);
}
res = SSL_CTX_use_PrivateKey_file(sp->ctx, sp->cert_fname,
SSL_FILETYPE_PEM);
if (res <= 0)
{
-#if HAVE_OPENSSL_SSL_H
ERR_print_errors_fp(stderr);
-#else
- fprintf(stderr, " SSL_CTX_use_certificate_file %s failed\n",
- sp->cert_fname);
-#endif
exit(3);
}
-#if HAVE_OPENSSL_SSL_H
res = SSL_CTX_check_private_key(sp->ctx);
if (res <= 0)
{
ERR_print_errors_fp(stderr);
exit(5);
}
-#endif
}
TRC(fprintf(stderr, "ssl_bind\n"));
}
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 (
}
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)
{
+ tcpip_state *state, *st = (tcpip_state *)h->cprivate;
if (!(cnew = (COMSTACK)xmalloc(sizeof(*cnew))))
{
h->cerrno = CSYSERR;
memcpy(cnew, h, sizeof(*h));
cnew->iofile = h->newfd;
cnew->io_pending = 0;
+
if (!(state = (tcpip_state *)
(cnew->cprivate = xmalloc(sizeof(tcpip_state)))))
{
cnew->state = CS_ST_ACCEPT;
h->state = CS_ST_IDLE;
-#if ENABLE_SSL == 2
- exit(9);
-#elif ENABLE_SSL == 1
+#if HAVE_GNUTLS_H
+ state->cred_ptr = st->cred_ptr;
+ state->session = 0;
+ if (st->cred_ptr)
+ {
+ 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);
+ }
+#elif HAVE_OPENSSL_SSL_H
state->ctx = st->ctx;
state->ctx_alloc = 0;
state->ssl = st->ssl;
}
if (h->state == CS_ST_ACCEPT)
{
-
-#if ENABLE_SSL == 2
- exit(9);
-#elif ENABLE_SSL == 1
+#if HAVE_GNUTLS_H
+ tcpip_state *state = (tcpip_state *)h->cprivate;
+ if (state->session)
+ {
+ int res = gnutls_handshake(state->session);
+ if (res < 0)
+ {
+ if (ssl_check_error(h, state, res))
+ {
+ TRC(fprintf(stderr, "gnutls_handshake int in tcpip_accept\n"));
+ return h;
+ }
+ TRC(fprintf(stderr, "gnutls_handshake failed in tcpip_accept\n"));
+ cs_close(h);
+ return 0;
+ }
+ TRC(fprintf(stderr, "SSL_accept complete. gnutls\n"));
+ }
+#elif HAVE_OPENSSL_SSL_H
tcpip_state *state = (tcpip_state *)h->cprivate;
if (state->ctx)
{
TRC(fprintf(stderr, "tcpip_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;
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)
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;
-#if ENABLE_SSL == 2
+#if HAVE_GNUTLS_H
res = gnutls_record_recv(sp->session, *buf + hasread,
CS_TCPIP_BUFCHUNK);
if (res < 0)
} 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)
}
while (state->towrite > state->written)
{
-#if ENABLE_SSL == 2
+#if HAVE_GNUTLS_H
res = gnutls_record_send(state->session, buf + state->written,
size - state->written);
if (res <= 0)
return 1;
return -1;
}
-#elif ENABLE_SSL == 1
+#else
res = SSL_write(state->ssl, buf + state->written,
size - state->written);
if (res <= 0)
}
#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 (h->iofile != -1)
{
-#if ENABLE_SSL == 2
+#if HAVE_GNUTLS_H
if (sp->session)
gnutls_bye(sp->session, GNUTLS_SHUT_RDWR);
-#elif ENABLE_SSL == 2
+#elif HAVE_OPENSSL_SSL_H
if (sp->ssl)
{
SSL_shutdown(sp->ssl);
}
if (sp->altbuf)
xfree(sp->altbuf);
-#if ENABLE_SSL == 2
+#if HAVE_GNUTLS_H
if (sp->session)
{
gnutls_deinit(sp->session);
- gnutls_certificate_free_credentials(sp->xcred);
}
-#elif ENABLE_SSL == 1
+ 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;
+ }
+#elif HAVE_OPENSSL_SSL_H
if (sp->ssl)
{
TRC(fprintf(stderr, "SSL_free\n"));
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;
sprintf(buf, "http:%s", r);
else
sprintf(buf, "tcp:%s", r);
-#if ENABLE_SSL == 2
+#if HAVE_GNUTLS_H
if (sp->session)
{
if (h->protocol == PROTO_HTTP)
else
sprintf(buf, "ssl:%s", r);
}
-#elif ENABLE_SSL == 1
+#elif HAVE_OPENSSL_SSL_H
if (sp->ctx)
{
if (h->protocol == PROTO_HTTP)
return buf;
}
-int static tcpip_set_blocking(COMSTACK p, int flags)
+static int tcpip_set_blocking(COMSTACK p, int flags)
{
unsigned long flag;
void cs_print_session_info(COMSTACK cs)
{
#if HAVE_GNUTLS_H
-#if ENABLE_SSL == 2
struct tcpip_state *sp = (struct tcpip_state *) cs->cprivate;
if (sp->session)
{
return;
printf("X509 certificate\n");
}
-#else
- struct tcpip_state *sp = (struct tcpip_state *) cs->cprivate;
- SSL *ssl = (SSL *) sp->ssl;
- if (ssl)
- {
- gnutls_session_t session = ssl->gnutls_state;
- if (gnutls_certificate_type_get(session) != GNUTLS_CRT_X509)
- return;
- printf("X509 certificate\n");
- }
-#endif
-#endif
-#if HAVE_OPENSSL_SSL_H
+#elif HAVE_OPENSSL_SSL_H
struct tcpip_state *sp = (struct tcpip_state *) cs->cprivate;
SSL *ssl = (SSL *) sp->ssl;
if (ssl)
void *cs_get_ssl(COMSTACK cs)
{
#if HAVE_OPENSSL_SSL_H
- struct tcpip_state *sp;
- if (!cs || cs->type != ssl_type)
- return 0;
- sp = (struct tcpip_state *) cs->cprivate;
- return sp->ssl;
-#else
- return 0;
+ if (cs && cs->type == ssl_type)
+ {
+ struct tcpip_state *sp = (struct tcpip_state *) cs->cprivate;
+ return sp->ssl;
+ }
#endif
+ return 0;
}
-#if ENABLE_SSL
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 ENABLE_SSL == 1
- if (sp->ctx_alloc)
- return 0;
- sp->ctx = (SSL_CTX *) ctx;
+#if ENABLE_SSL
+ 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
- return 1;
+ return 1;
+ }
+#endif
+ return 0;
}
int cs_set_ssl_certificate_file(COMSTACK cs, const char *fname)
{
- 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;
+#if ENABLE_SSL
+ 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;
}
int cs_get_peer_certificate_x509(COMSTACK cs, char **buf, int *len)
{
-#if ENABLE_SSL == 1
+#if HAVE_OPENSSL_SSL_H
SSL *ssl = (SSL *) cs_get_ssl(cs);
if (ssl)
{
-#if HAVE_OPENSSL_SSL_H
X509 *server_cert = SSL_get_peer_certificate(ssl);
if (server_cert)
{
}
}
#endif
-#endif
- return 0;
-}
-#else
-int cs_set_ssl_ctx(COMSTACK cs, void *ctx)
-{
- return 0;
-}
-
-int cs_get_peer_certificate_x509(COMSTACK cs, char **buf, int *len)
-{
return 0;
}
-int cs_set_ssl_certificate_file(COMSTACK cs, const char *fname)
-{
- return 0;
-}
-#endif
-
-
static int tcpip_put_connect(COMSTACK h, char *buf, int size)
{
struct tcpip_state *state = (struct tcpip_state *)h->cprivate;
/*
* Local variables:
* c-basic-offset: 4
+ * c-file-style: "Stroustrup"
* indent-tabs-mode: nil
* End:
* vim: shiftwidth=4 tabstop=8 expandtab
projects / yaz-moved-to-github.git / blobdiff