-/*
- * Copyright (C) 1995-2005, Index Data ApS
+/* This file is part of the YAZ toolkit.
+ * Copyright (C) 1995-2012 Index Data
* See the file LICENSE for details.
- *
- * $Id: tcpip.c,v 1.19 2006-08-24 13:25: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>
#endif
#ifdef WIN32
-#include <winsock.h>
+/* VS 2003 or later has getaddrinfo; older versions do not */
+#include <winsock2.h>
+#if _MSC_VER >= 1300
+#include <ws2tcpip.h>
+#define HAVE_GETADDRINFO 1
#else
+#define HAVE_GETADDRINFO 0
+#endif
+#endif
+
+#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_SYS_SELECT_H
-#include <sys/select.h>
-#endif
#if HAVE_SYS_WAIT_H
#include <sys/wait.h>
#endif
+#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/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);
+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 HAVE_OPENSSL_SSL_H
+#if ENABLE_SSL
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 written; /* -1 if we aren't writing */
int towrite; /* to verify against user input */
- int (*complete)(const unsigned char *buf, int len); /* length/comple. */
+ int (*complete)(const char *buf, int len); /* length/complete. */
+#if HAVE_GETADDRINFO
+ struct addrinfo *ai;
+#else
struct sockaddr_in addr; /* returned by cs_straddr */
+#endif
char buf[128]; /* returned by cs_addrstr */
-#if HAVE_OPENSSL_SSL_H
+#if HAVE_GNUTLS_H
+ 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;
+ char *connect_response_buf;
+ int connect_response_len;
} tcpip_state;
#ifdef WIN32
-static int tcpip_init (void)
+static int tcpip_init(void)
{
static int initialized = 0;
if (!initialized)
return 1;
}
#else
-static int tcpip_init (void)
+static int tcpip_init(void)
{
return 1;
}
* This function is always called through the cs_create() macro.
* s >= 0: socket has already been established for us.
*/
-COMSTACK tcpip_type(int s, int blocking, int protocol, void *vp)
+COMSTACK tcpip_type(int s, int flags, int protocol, void *vp)
{
COMSTACK p;
tcpip_state *sp;
- int new_socket;
-#ifdef WIN32
- unsigned long tru = 1;
-#endif
- if (!tcpip_init ())
+ if (!tcpip_init())
return 0;
- if (s < 0)
- {
- if ((s = socket(AF_INET, SOCK_STREAM, 0)) < 0)
- return 0;
- new_socket = 1;
- }
- else
- new_socket = 0;
if (!(p = (struct comstack *)xmalloc(sizeof(struct comstack))))
return 0;
if (!(sp = (struct tcpip_state *)(p->cprivate =
xmalloc(sizeof(tcpip_state)))))
return 0;
- if (!((p->blocking = blocking)&1))
- {
-#ifdef WIN32
- if (ioctlsocket(s, FIONBIO, &tru) < 0)
- return 0;
-#else
- if (fcntl(s, F_SETFL, O_NONBLOCK) < 0)
- return 0;
-#ifndef MSG_NOSIGNAL
- signal (SIGPIPE, SIG_IGN);
-#endif
-#endif
- }
+ p->flags = flags;
p->io_pending = 0;
p->iofile = s;
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 = new_socket ? CS_ST_UNBND : CS_ST_IDLE; /* state of line */
+ 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
+#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;
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"));
return p;
}
-#if HAVE_OPENSSL_SSL_H
+COMSTACK yaz_tcpip_create(int s, int flags, int protocol,
+ const char *connect_host)
+{
+ COMSTACK p = tcpip_type(s, flags, protocol, 0);
+ if (!p)
+ return 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);
+ 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 */
+ }
+ return p;
+}
-COMSTACK ssl_type(int s, int blocking, int protocol, void *vp)
+#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)
+{
+#if !ENABLE_SSL
+ return 0;
+#else
tcpip_state *sp;
COMSTACK p;
- p = tcpip_type (s, blocking, 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;
+#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;
+#endif
}
+
+#if ENABLE_SSL
+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),
+ 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;
+ }
#endif
+ h->cerrno = CSERRORSSL;
+ return 0;
+}
+#endif
+
+#if HAVE_GETADDRINFO
+/* resolve using getaddrinfo */
+struct addrinfo *tcpip_getaddrinfo(const char *str, const char *port)
+{
+ struct addrinfo hints, *res;
+ int error;
+ char host[512], *p;
+
+ hints.ai_flags = 0;
+ hints.ai_family = AF_UNSPEC;
+ hints.ai_socktype = SOCK_STREAM;
+ hints.ai_protocol = 0;
+ hints.ai_addrlen = 0;
+ hints.ai_addr = NULL;
+ hints.ai_canonname = NULL;
+ hints.ai_next = NULL;
+
+ strncpy(host, str, sizeof(host)-1);
+ host[sizeof(host)-1] = 0;
+ if ((p = strchr(host, '/')))
+ *p = 0;
+ if ((p = strrchr(host, ':')))
+ {
+ *p = '\0';
+ port = p+1;
+ }
+
+ 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
+ {
+ error = getaddrinfo(host, port, &hints, &res);
+ }
+ if (error)
+ return 0;
+ return res;
+}
+#endif
+/* gethostbyname .. old systems */
int tcpip_strtoaddr_ex(const char *str, struct sockaddr_in *add,
int default_port)
{
struct hostent *hp;
char *p, buf[512];
short int port = default_port;
- unsigned tmpadd;
-
- if (!tcpip_init ())
- return 0;
+#ifdef WIN32
+ unsigned long tmpadd;
+#else
+ in_addr_t tmpadd;
+#endif
TRC(fprintf(stderr, "tcpip_strtoaddress: %s\n", str ? str : "NULL"));
add->sin_family = AF_INET;
- strncpy(buf, str, 511);
- buf[511] = 0;
+ strncpy(buf, str, sizeof(buf)-1);
+ buf[sizeof(buf)-1] = 0;
if ((p = strchr(buf, '/')))
*p = 0;
- if ((p = strchr(buf, ':')))
+ if ((p = strrchr(buf, ':')))
{
*p = 0;
port = atoi(p + 1);
}
add->sin_port = htons(port);
if (!strcmp("@", buf))
+ {
add->sin_addr.s_addr = INADDR_ANY;
+ }
+ else if ((tmpadd = inet_addr(buf)) != -1)
+ {
+ memcpy(&add->sin_addr.s_addr, &tmpadd, sizeof(struct in_addr));
+ }
else if ((hp = gethostbyname(buf)))
+ {
memcpy(&add->sin_addr.s_addr, *hp->h_addr_list,
sizeof(struct in_addr));
- else if ((tmpadd = (unsigned) inet_addr(buf)) != 0)
- memcpy(&add->sin_addr.s_addr, &tmpadd, sizeof(struct in_addr));
+ }
else
return 0;
return 1;
}
+#if HAVE_GETADDRINFO
void *tcpip_straddr(COMSTACK h, const char *str)
{
tcpip_state *sp = (tcpip_state *)h->cprivate;
- int port = 210;
-
+ const char *port = "210";
+ struct addrinfo *ai = 0;
if (h->protocol == PROTO_HTTP)
- port = 80;
-
- if (!tcpip_strtoaddr_ex (str, &sp->addr, port))
+ {
+ if (h->type == ssl_type)
+ port = "443";
+ else
+ port = "80";
+ }
+ if (!tcpip_init())
return 0;
- return &sp->addr;
-}
-struct sockaddr_in *tcpip_strtoaddr(const char *str)
+ if (sp->ai)
+ freeaddrinfo(sp->ai);
+ sp->ai = tcpip_getaddrinfo(str, port);
+ 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 (!tcpip_set_blocking(h, h->flags))
+ return 0;
+ }
+ return ai;
+}
+#else
+void *tcpip_straddr(COMSTACK h, const char *str)
{
- static struct sockaddr_in add;
-
- if (!tcpip_strtoaddr_ex (str, &add, 210))
+ tcpip_state *sp = (tcpip_state *)h->cprivate;
+ int port = 210;
+ if (h->protocol == PROTO_HTTP)
+ {
+ if (h->type == ssl_type)
+ port = 443;
+ else
+ port = 80;
+ }
+
+ if (!tcpip_init())
+ return 0;
+ if (!tcpip_strtoaddr_ex(str, &sp->addr, port))
return 0;
- return &add;
+ if (h->state == CS_ST_UNBND)
+ {
+ int s;
+ s = socket(AF_INET, SOCK_STREAM, 0);
+ if (s < 0)
+ return 0;
+ h->iofile = s;
+
+ if (!tcpip_set_blocking(h, h->flags))
+ return 0;
+ }
+ return &sp->addr;
}
+#endif
int tcpip_more(COMSTACK h)
{
tcpip_state *sp = (tcpip_state *)h->cprivate;
-
- return sp->altlen && (*sp->complete)((unsigned char *) sp->altbuf,
- sp->altlen);
+
+ return sp->altlen && (*sp->complete)(sp->altbuf, sp->altlen);
}
/*
*/
int tcpip_connect(COMSTACK h, void *address)
{
- struct sockaddr_in *add = (struct sockaddr_in *)address;
- int r;
-#ifdef __sun__
- int recbuflen;
- YAZ_SOCKLEN_T rbufsize = sizeof(recbuflen);
+#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;
TRC(fprintf(stderr, "tcpip_connect\n"));
h->io_pending = 0;
if (h->state != CS_ST_UNBND)
h->cerrno = CSOUTSTATE;
return -1;
}
-#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, ai->ai_addr, ai->ai_addrlen);
+ freeaddrinfo(sp->ai);
+ sp->ai = 0;
+#else
r = connect(h->iofile, (struct sockaddr *) add, sizeof(*add));
+#endif
if (r < 0)
{
#ifdef WIN32
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
+#if ENABLE_SSL
tcpip_state *sp = (tcpip_state *)h->cprivate;
#endif
TRC(fprintf(stderr, "tcpip_rcvconnect\n"));
h->cerrno = CSOUTSTATE;
return -1;
}
-#if HAVE_OPENSSL_SSL_H
+#if HAVE_GNUTLS_H
+ if (h->type == ssl_type && !sp->session)
+ {
+ 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 HAVE_OPENSSL_SSL_H
if (h->type == ssl_type && !sp->ctx)
{
+ SSL_library_init();
SSL_load_error_strings();
- SSLeay_add_all_algorithms();
- sp->ctx = sp->ctx_alloc = SSL_CTX_new (SSLv23_method());
+ sp->ctx = sp->ctx_alloc = SSL_CTX_new(SSLv23_client_method());
if (!sp->ctx)
{
h->cerrno = CSERRORSSL;
if (!sp->ssl)
{
- sp->ssl = SSL_new (sp->ctx);
- SSL_set_fd (sp->ssl, h->iofile);
+ sp->ssl = SSL_new(sp->ctx);
+ SSL_set_fd(sp->ssl, h->iofile);
}
- res = SSL_connect (sp->ssl);
+ res = SSL_connect(sp->ssl);
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;
}
}
#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
#ifdef WIN32
BOOL one = 1;
#else
- unsigned long one = 1;
+ int one = 1;
#endif
-#if HAVE_OPENSSL_SSL_H
- tcpip_state *sp = (tcpip_state *)h->cprivate;
+#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,
+ 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_load_error_strings();
- SSLeay_add_all_algorithms();
- sp->ctx = sp->ctx_alloc = SSL_CTX_new (SSLv23_method());
+ sp->ctx = sp->ctx_alloc = SSL_CTX_new(SSLv23_server_method());
if (!sp->ctx)
{
h->cerrno = CSERRORSSL;
if (sp->ctx_alloc)
{
int res;
- res = SSL_CTX_use_certificate_chain_file(sp->ctx, sp->cert_fname);
+ res = SSL_CTX_use_certificate_file(sp->ctx, sp->cert_fname,
+ SSL_FILETYPE_PEM);
if (res <= 0)
{
ERR_print_errors_fp(stderr);
- exit (2);
+ exit(2);
}
- res = SSL_CTX_use_PrivateKey_file (sp->ctx, sp->cert_fname,
+ res = SSL_CTX_use_PrivateKey_file(sp->ctx, sp->cert_fname,
SSL_FILETYPE_PEM);
if (res <= 0)
{
ERR_print_errors_fp(stderr);
- exit (3);
+ exit(3);
}
- res = SSL_CTX_check_private_key (sp->ctx);
+ res = SSL_CTX_check_private_key(sp->ctx);
if (res <= 0)
{
ERR_print_errors_fp(stderr);
exit(5);
}
}
- TRC (fprintf (stderr, "ssl_bind\n"));
+ TRC(fprintf(stderr, "ssl_bind\n"));
}
else
{
- TRC (fprintf (stderr, "tcpip_bind\n"));
+ 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 (bind(h->iofile, addr, sizeof(struct sockaddr_in)))
+#if HAVE_GETADDRINFO
+ r = bind(h->iofile, ai->ai_addr, ai->ai_addrlen);
+ freeaddrinfo(sp->ai);
+ sp->ai = 0;
+#else
+ r = bind(h->iofile, addr, sizeof(struct sockaddr_in));
+#endif
+ if (r)
{
h->cerrno = CSYSERR;
return -1;
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)
{
+ 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)))))
{
}
return 0;
}
- if (!(cnew->blocking&1) &&
-#ifdef WIN32
- (ioctlsocket(cnew->iofile, FIONBIO, &tru) < 0)
-#else
- (fcntl(cnew->iofile, F_SETFL, O_NONBLOCK) < 0)
-#endif
- )
+ if (!tcpip_set_blocking(cnew, cnew->flags))
{
h->cerrno = CSYSERR;
if (h->newfd != -1)
#endif
h->newfd = -1;
}
- xfree (cnew);
- xfree (state);
+ xfree(cnew);
+ xfree(state);
return 0;
}
h->newfd = -1;
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
+
+#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 (state->ctx)
{
- state->ssl = SSL_new (state->ctx);
- SSL_set_fd (state->ssl, cnew->iofile);
+ 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)
{
-#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)
+ if (ssl_check_error(h, state, res))
{
- h->io_pending = CS_WANT_READ;
+ TRC(fprintf(stderr, "gnutls_handshake int in tcpip_accept\n"));
return h;
}
- if (err == SSL_ERROR_WANT_WRITE)
+ 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)
+ {
+ 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))
{
- h->io_pending = CS_WANT_WRITE;
return h;
}
- cs_close (h);
+ cs_close(h);
return 0;
}
+ TRC(fprintf(stderr, "SSL_accept complete\n"));
}
#endif
}
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;
sp->altsize = tmpi;
}
h->io_pending = 0;
- while (!(berlen = (*sp->complete)((unsigned char *)*buf, hasread)))
+ while (!(berlen = (*sp->complete)(*buf, hasread)))
{
if (!*bufsize)
{
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)
break;
}
else
+ {
+ h->cerrno = CSYSERR;
return -1;
+ }
#else
- if (yaz_errno() == EWOULDBLOCK
-#ifdef EAGAIN
+ if (yaz_errno() == EWOULDBLOCK
+#ifdef EAGAIN
#if EAGAIN != EWOULDBLOCK
|| yaz_errno() == EAGAIN
#endif
else if (yaz_errno() == 0)
continue;
else
+ {
+ h->cerrno = CSYSERR;
return -1;
+ }
#endif
}
else if (!res)
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)
{
if (!sp->altbuf)
{
if (!(sp->altbuf = (char *)xmalloc(sp->altsize = req)))
+ {
+ h->cerrno = CSYSERR;
return -1;
+ }
} else if (sp->altsize < req)
if (!(sp->altbuf =(char *)xrealloc(sp->altbuf, sp->altsize = req)))
+ {
+ 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 ENABLE_SSL
/*
* 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;
sp->altsize = tmpi;
}
h->io_pending = 0;
- while (!(berlen = (*sp->complete)((unsigned char *)*buf, hasread)))
+ while (!(berlen = (*sp->complete)(*buf, hasread)))
{
if (!*bufsize)
{
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);
+#if HAVE_GNUTLS_H
+ res = gnutls_record_recv(sp->session, *buf + hasread,
+ CS_TCPIP_BUFCHUNK);
+ if (res == 0)
+ {
+ TRC(fprintf(stderr, "gnutls_record_recv returned 0\n"));
+ return 0;
+ }
+ else if (res < 0)
+ {
+ if (ssl_check_error(h, sp, res))
+ 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)
{
- int ssl_err = SSL_get_error(sp->ssl, res);
- if (ssl_err == SSL_ERROR_WANT_READ)
- {
- h->io_pending = CS_WANT_READ;
+ if (ssl_check_error(h, sp, res))
break;
- }
- if (ssl_err == SSL_ERROR_WANT_WRITE)
- {
- h->io_pending = CS_WANT_WRITE;
- break;
- }
- if (res == 0)
- return 0;
- h->cerrno = CSERRORSSL;
return -1;
}
+#endif
hasread += res;
}
TRC (fprintf (stderr, " Out of read loop with hasread=%d, berlen=%d\n",
} 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)
{
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
}
-#if HAVE_OPENSSL_SSL_H
+#if ENABLE_SSL
/*
* 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);
+#if HAVE_GNUTLS_H
+ 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;
+ }
+#else
+ res = SSL_write(state->ssl, buf + state->written,
+ size - state->written);
+ if (res <= 0)
+ {
+ if (ssl_check_error(h, state, res))
return 1;
- }
- h->cerrno = CSERRORSSL;
return -1;
}
+#endif
state->written += res;
TRC(fprintf(stderr, " Wrote %d, written=%d, nbytes=%d\n",
res, state->written, size));
}
#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 HAVE_OPENSSL_SSL_H
+#if HAVE_GNUTLS_H
+ if (sp->session)
+ gnutls_bye(sp->session, GNUTLS_SHUT_RDWR);
+#elif HAVE_OPENSSL_SSL_H
if (sp->ssl)
{
- SSL_shutdown (sp->ssl);
+ SSL_shutdown(sp->ssl);
}
#endif
#ifdef WIN32
}
if (sp->altbuf)
xfree(sp->altbuf);
-#if HAVE_OPENSSL_SSL_H
+#if HAVE_GNUTLS_H
+ if (sp->session)
+ {
+ 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;
+ }
+#elif HAVE_OPENSSL_SSL_H
if (sp->ssl)
{
- TRC (fprintf(stderr, "SSL_free\n"));
- SSL_free (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);
+ SSL_CTX_free(sp->ctx_alloc);
#endif
+#if HAVE_GETADDRINFO
+ if (sp->ai)
+ freeaddrinfo(sp->ai);
+#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)
{
- struct sockaddr_in addr;
tcpip_state *sp = (struct tcpip_state *)h->cprivate;
char *r = 0, *buf = sp->buf;
- YAZ_SOCKLEN_T len;
+
+#if HAVE_GETADDRINFO
+ 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,
+ (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;
-
- len = sizeof(addr);
+
if (getpeername(h->iofile, (struct sockaddr*) &addr, &len) < 0)
{
h->cerrno = CSYSERR;
return 0;
}
- if (!(h->blocking&2)) {
- if ((host = gethostbyaddr((char*)&addr.sin_addr, sizeof(addr.sin_addr),
- AF_INET)))
+ if (!(h->flags & CS_FLAGS_NUMERICHOST))
+ {
+ if ((host = gethostbyaddr((char*)&addr.sin_addr,
+ sizeof(addr.sin_addr),
+ AF_INET)))
r = (char*) host->h_name;
}
if (!r)
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 HAVE_GNUTLS_H
+ if (sp->session)
+ {
+ if (h->protocol == PROTO_HTTP)
+ sprintf(buf, "https:%s", r);
+ else
+ sprintf(buf, "ssl:%s", r);
+ }
+#elif HAVE_OPENSSL_SSL_H
if (sp->ctx)
{
if (h->protocol == PROTO_HTTP)
return buf;
}
-int static tcpip_set_blocking(COMSTACK p, int blocking)
+static int tcpip_set_blocking(COMSTACK p, int flags)
{
unsigned long flag;
-
- if (p->blocking == blocking)
- return 1;
+
#ifdef WIN32
- flag = 1;
+ flag = (flags & CS_FLAGS_BLOCKING) ? 0 : 1;
if (ioctlsocket(p->iofile, FIONBIO, &flag) < 0)
return 0;
#else
flag = fcntl(p->iofile, F_GETFL, 0);
- if(!(blocking&1))
- flag = flag & ~O_NONBLOCK;
+ if (flags & CS_FLAGS_BLOCKING)
+ flag = flag & ~O_NONBLOCK; /* blocking */
else
- flag = flag | O_NONBLOCK;
+ {
+ flag = flag | O_NONBLOCK; /* non-blocking */
+ signal(SIGPIPE, SIG_IGN);
+ }
if (fcntl(p->iofile, F_SETFL, flag) < 0)
return 0;
#endif
- p->blocking = blocking;
+ p->flags = flags;
return 1;
}
-#if HAVE_OPENSSL_SSL_H
-int cs_set_ssl_ctx(COMSTACK cs, void *ctx)
+#if HAVE_GNUTLS_H
+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;
- if (sp->ctx_alloc)
- return 0;
- sp->ctx = (SSL_CTX *) ctx;
- return 1;
+ 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;
+}
+#endif
+
+void cs_print_session_info(COMSTACK cs)
+{
+#if HAVE_GNUTLS_H
+ if (cs->type == ssl_type)
+ {
+ struct tcpip_state *sp = (struct tcpip_state *) cs->cprivate;
+ if (sp->session)
+ {
+ 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++)
+ {
+ gnutls_x509_crt_t cert;
+ gnutls_datum_t cinfo;
+ int ret;
+ time_t expiration_time, activation_time;
+ size_t size;
+ char serial[40];
+ char dn[256];
+ unsigned int algo, bits;
+
+ /* we only print information about the first certificate. */
+ gnutls_x509_crt_init(&cert);
+ gnutls_x509_crt_import(cert, &cert_list[i], GNUTLS_X509_FMT_DER);
+ printf("Certificate info %d:\n", i + 1);
+ /* This is the preferred way of printing short information about
+ a certificate. */
+ ret = gnutls_x509_crt_print(cert, GNUTLS_CRT_PRINT_ONELINE, &cinfo);
+ if (ret == 0)
+ {
+ printf("\t%s\n", cinfo.data);
+ gnutls_free(cinfo.data);
+ }
+
+ /* If you want to extract fields manually for some other reason,
+ below are popular example calls. */
+
+ 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);
+
+ gnutls_x509_crt_deinit(cert);
+
+ }
+ }
+ }
+#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)
{
- struct tcpip_state *sp;
- if (!cs || cs->type != ssl_type)
- return 0;
- sp = (struct tcpip_state *) cs->cprivate;
- return sp->ssl;
+#if HAVE_OPENSSL_SSL_H
+ if (cs && cs->type == ssl_type)
+ {
+ struct tcpip_state *sp = (struct tcpip_state *) cs->cprivate;
+ return sp->ssl;
+ }
+#endif
+ return 0;
+}
+
+int cs_set_ssl_ctx(COMSTACK cs, void *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;
+ }
+#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 HAVE_OPENSSL_SSL_H
SSL *ssl = (SSL *) cs_get_ssl(cs);
if (ssl)
{
- X509 *server_cert = SSL_get_peer_certificate (ssl);
+ X509 *server_cert = SSL_get_peer_certificate(ssl);
if (server_cert)
{
BIO *bio = BIO_new(BIO_s_mem());
return 1;
}
}
- return 0;
-}
-#else
-int cs_set_ssl_ctx(COMSTACK cs, void *ctx)
-{
+#endif
return 0;
}
-void *cs_get_ssl(COMSTACK cs)
+static int tcpip_put_connect(COMSTACK h, char *buf, int size)
{
- return 0;
-}
+ struct tcpip_state *state = (struct tcpip_state *)h->cprivate;
-int cs_get_peer_certificate_x509(COMSTACK cs, char **buf, int *len)
-{
- return 0;
+ 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;
}
-int cs_set_ssl_certificate_file(COMSTACK cs, const char *fname)
+static int tcpip_get_connect(COMSTACK h, char **buf, int *bufsize)
{
- return 0;
+ 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);
}
-#endif
+
/*
* 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