/* This file is part of the YAZ toolkit.
- * Copyright (C) 1995-2008 Index Data
+ * Copyright (C) 1995-2013 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>
#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
#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
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_GNUTLS_H
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->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;
}
#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)
{
tcpip_state *sp = (tcpip_state *)h->cprivate;
const char *port = "210";
+ struct addrinfo *ai = 0;
+ int ipv6_only = 0;
if (h->protocol == PROTO_HTTP)
- port = "80";
+ {
+ if (h->type == ssl_type)
+ port = "443";
+ else
+ port = "80";
+ }
if (!tcpip_init())
return 0;
if (sp->ai)
freeaddrinfo(sp->ai);
- sp->ai = tcpip_getaddrinfo(str, port);
+ sp->ai = tcpip_getaddrinfo(str, port, &ipv6_only);
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)
- break;
+ 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;
+ assert(ai);
h->iofile = s;
-
+ if (ai->ai_family == AF_INET6 && 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 sp->ai;
+ return 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())
return 0;
int tcpip_more(COMSTACK h)
{
tcpip_state *sp = (tcpip_state *)h->cprivate;
-
+
return sp->altlen && (*sp->complete)(sp->altbuf, sp->altlen);
}
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 )
- {
- 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 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);
-
- gnutls_transport_set_ptr(sp->session, (gnutls_transport_ptr_t) h->iofile);
-
- res = gnutls_handshake(sp->session);
+ /* 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->session)
+ {
+ int res = gnutls_handshake(sp->session);
if (res < 0)
{
if (ssl_check_error(h, sp, res))
#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
int one = 1;
#endif
-#if HAVE_GETADDRINFO
- if (sp->ai != (struct addrinfo *) address)
- {
- h->cerrno = CSOUTSTATE;
- return -1;
- }
-#endif
-
#if HAVE_GNUTLS_H
if (h->type == ssl_type && !sp->session)
{
tcpip_create_cred(h);
- res = gnutls_certificate_set_x509_key_file(sp->cred_ptr->xcred,
+ res = gnutls_certificate_set_x509_key_file(sp->cred_ptr->xcred,
sp->cert_fname,
sp->cert_fname,
GNUTLS_X509_FMT_PEM);
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
}
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;
}
#endif
cnew->state = CS_ST_ACCEPT;
h->state = CS_ST_IDLE;
-
+
#if HAVE_GNUTLS_H
state->cred_ptr = st->cred_ptr;
state->session = 0;
return 0;
}
res = gnutls_credentials_set(state->session,
- GNUTLS_CRD_CERTIFICATE,
+ GNUTLS_CRD_CERTIFICATE,
st->cred_ptr->xcred);
if (res != GNUTLS_E_SUCCESS)
{
xfree(state);
return 0;
}
- gnutls_transport_set_ptr(state->session,
- (gnutls_transport_ptr_t) cnew->iofile);
+ /* 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;
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
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;
#if HAVE_GNUTLS_H
res = gnutls_record_recv(sp->session, *buf + hasread,
CS_TCPIP_BUFCHUNK);
- if (res < 0)
+ 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;
} 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
while (state->towrite > state->written)
{
#if HAVE_GNUTLS_H
- res = gnutls_record_send(state->session, buf + state->written,
+ res = gnutls_record_send(state->session, buf + state->written,
size - state->written);
if (res <= 0)
{
return -1;
}
#else
- res = SSL_write(state->ssl, buf + state->written,
+ 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 h=%p pid=%d\n", h, getpid()));
+ TRC(fprintf(stderr, "tcpip_close: h=%p pid=%d\n", h, getpid()));
if (h->iofile != -1)
{
#if HAVE_GNUTLS_H
if (sp->session)
- gnutls_bye(sp->session, GNUTLS_SHUT_RDWR);
+ gnutls_bye(sp->session, GNUTLS_SHUT_WR);
#elif HAVE_OPENSSL_SSL_H
if (sp->ssl)
{
if (--(sp->cred_ptr->ref) == 0)
{
- TRC(fprintf(stderr, "Removed credentials %p pid=%d\n",
+ 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);
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)
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_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)
+{
+ 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;
+}
+
+static void x509_crt_print(gnutls_x509_crt_t cert)
+{
+ 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
+
void cs_print_session_info(COMSTACK cs)
{
#if HAVE_GNUTLS_H
struct tcpip_state *sp = (struct tcpip_state *) cs->cprivate;
- if (sp->session)
+ if (cs->type == ssl_type && 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;
+#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);
+
+ }
}
#elif HAVE_OPENSSL_SSL_H
- struct tcpip_state *sp = (struct tcpip_state *) cs->cprivate;
- SSL *ssl = (SSL *) sp->ssl;
- if (ssl)
+ if (cs->type == ssl_type)
{
- X509 *server_cert = SSL_get_peer_certificate(ssl);
-
- if (server_cert)
+ struct tcpip_state *sp = (struct tcpip_state *) cs->cprivate;
+ SSL *ssl = (SSL *) sp->ssl;
+ if (ssl)
{
- char *pem_buf;
- int pem_len;
- BIO *bio = BIO_new(BIO_s_mem());
+ 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);
+ /* 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);
+ /* print all info on screen .. */
+ X509_print_fp(stdout, server_cert);
+ BIO_free(bio);
- X509_free(server_cert);
+ X509_free(server_cert);
+ }
}
}
#endif
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;
}
int cs_set_ssl_ctx(COMSTACK cs, void *ctx)
{
#if ENABLE_SSL
- struct tcpip_state *sp;
- if (!cs || cs->type != ssl_type)
- return 0;
- sp = (struct tcpip_state *) cs->cprivate;
+ if (cs && cs->type == ssl_type)
+ {
#if HAVE_OPENSSL_SSL_H
- if (sp->ctx_alloc)
- return 0;
- sp->ctx = (SSL_CTX *) ctx;
+ struct tcpip_state *sp = (struct tcpip_state *) cs->cprivate;
+ if (sp->ctx_alloc)
+ return 0;
+ sp->ctx = (SSL_CTX *) ctx;
#endif
- return 1;
-#else
- return 0;
+ return 1;
+ }
#endif
+ return 0;
}
int cs_set_ssl_certificate_file(COMSTACK cs, const char *fname)
{
#if ENABLE_SSL
- 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;
-#else
- return 0;
+ 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)
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
projects / yaz-moved-to-github.git / blobdiff