Use GNU TLS for Debian package

[yaz-moved-to-github.git] / src / tcpip.c

diff --git a/src/tcpip.c b/src/tcpip.c
index b1f9fa9..bd87856 100644 (file)
--- a/src/tcpip.c
+++ b/src/tcpip.c
@@ -1,8 +1,6 @@
-/*
- * Copyright (C) 1995-2007, Index Data ApS
+/* This file is part of the YAZ toolkit.
+ * Copyright (C) 1995-2008 Index Data
  * See the file LICENSE for details.
- *
- * $Id: tcpip.c,v 1.35 2007-10-07 08:53:26 adam Exp $
  */
 /**
  * \file tcpip.c
@@ -46,16 +44,19 @@
 #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/openssl.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>
@@ -76,7 +77,7 @@ static int tcpip_listen(COMSTACK h, char *raddr, int *addrlen,
                  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
@@ -104,14 +105,14 @@ 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 ENABLE_SSL
     SSL_CTX *ctx;       /* current CTX. */
     SSL_CTX *ctx_alloc; /* If =ctx it is owned by CS. If 0 it is not owned */
     SSL *ssl;
@@ -190,7 +191,7 @@ COMSTACK tcpip_type(int s, int flags, int protocol, void *vp)
     p->stackerr = 0;
     p->user = 0;
 
-#if HAVE_OPENSSL_SSL_H
+#if ENABLE_SSL
     sp->ctx = sp->ctx_alloc = 0;
     sp->ssl = 0;
     strcpy(sp->cert_fname, "yaz.pem");
@@ -227,7 +228,7 @@ COMSTACK yaz_tcpip_create(int s, int flags, int protocol,
     if (connect_host)
     {
         tcpip_state *sp = (tcpip_state *) p->cprivate;
-        sp->connect_request_buf = xmalloc(strlen(connect_host) + 30);
+        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);
@@ -239,7 +240,7 @@ COMSTACK yaz_tcpip_create(int s, int flags, int protocol,
 }
 
 
-#if HAVE_OPENSSL_SSL_H
+#if ENABLE_SSL
 
 COMSTACK ssl_type(int s, int flags, int protocol, void *vp)
 {
@@ -259,6 +260,41 @@ COMSTACK ssl_type(int s, int flags, int protocol, void *vp)
     /* note: we don't handle already opened socket in SSL mode - yet */
     return p;
 }
+
+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;
+    }
+#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
+    h->cerrno = CSERRORSSL;
+    return 0;
+}
 #endif
 
 #if HAVE_GETADDRINFO
@@ -409,8 +445,7 @@ 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);
 }
 
 /*
@@ -511,7 +546,7 @@ int tcpip_connect(COMSTACK h, void *address)
  */
 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"));
@@ -523,13 +558,13 @@ int tcpip_rcvconnect(COMSTACK h)
         h->cerrno = CSOUTSTATE;
         return -1;
     }
-#if HAVE_OPENSSL_SSL_H
+#if ENABLE_SSL
     if (h->type == ssl_type && !sp->ctx)
     {
         SSL_library_init();
         SSL_load_error_strings();
 
-        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;
@@ -545,21 +580,11 @@ int tcpip_rcvconnect(COMSTACK h)
             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;
         }
     }
@@ -615,13 +640,13 @@ static int tcpip_bind(COMSTACK h, void *address, int mode)
     }
 #endif
 
-#if HAVE_OPENSSL_SSL_H
+#if ENABLE_SSL
     if (h->type == ssl_type && !sp->ctx)
     {
         SSL_library_init();
         SSL_load_error_strings();
 
-        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;
@@ -633,25 +658,38 @@ static int tcpip_bind(COMSTACK h, void *address, int mode)
         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)
             {
+#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"));
     }
@@ -724,7 +762,15 @@ int tcpip_listen(COMSTACK h, char *raddr, int *addrlen,
             )
             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;
     }
     if (addrlen && (size_t) (*addrlen) >= sizeof(struct sockaddr_in))
@@ -815,7 +861,7 @@ COMSTACK tcpip_accept(COMSTACK h)
         cnew->state = CS_ST_ACCEPT;
         h->state = CS_ST_IDLE;
         
-#if HAVE_OPENSSL_SSL_H
+#if ENABLE_SSL
         state->ctx = st->ctx;
         state->ctx_alloc = 0;
         state->ssl = st->ssl;
@@ -824,35 +870,32 @@ COMSTACK tcpip_accept(COMSTACK h)
             state->ssl = SSL_new (state->ctx);
             SSL_set_fd (state->ssl, cnew->iofile);
         }
+#endif
         state->connect_request_buf = 0;
         state->connect_response_buf = 0;
-#endif
         h = cnew;
     }
     if (h->state == CS_ST_ACCEPT)
     {
-#if HAVE_OPENSSL_SSL_H
+
+#if ENABLE_SSL
         tcpip_state *state = (tcpip_state *)h->cprivate;
         if (state->ctx)
         {
-            int res = SSL_accept (state->ssl);
-            TRC(fprintf(stderr, "SSL_accept\n"));
+            int res;
+            errno = 0;
+            res = SSL_accept(state->ssl);
+            TRC(fprintf(stderr, "SSL_accept res=%d\n", res));
             if (res <= 0)
             {
-                int err = SSL_get_error(state->ssl, res);
-                if (err == SSL_ERROR_WANT_READ)
-                {
-                    h->io_pending = CS_WANT_READ;
-                    return h;
-                }
-                if (err == SSL_ERROR_WANT_WRITE)
+                if (ssl_check_error(h, state, res))
                 {
-                    h->io_pending = CS_WANT_WRITE;
                     return h;
                 }
-                cs_close (h);
+                cs_close(h);
                 return 0;
             }
+            TRC(fprintf(stderr, "SSL_accept complete\n"));
         }
 #endif
     }
@@ -895,7 +938,7 @@ int tcpip_get(COMSTACK h, char **buf, int *bufsize)
         sp->altsize = tmpi;
     }
     h->io_pending = 0;
-    while (!(berlen = (*sp->complete)((unsigned char *)*buf, hasread)))
+    while (!(berlen = (*sp->complete)(*buf, hasread)))
     {
         if (!*bufsize)
         {
@@ -999,7 +1042,7 @@ int tcpip_get(COMSTACK h, char **buf, int *bufsize)
 }
 
 
-#if HAVE_OPENSSL_SSL_H
+#if ENABLE_SSL
 /*
  * Return: -1 error, >1 good, len of buffer, ==1 incomplete buffer,
  * 0=connection closed.
@@ -1026,7 +1069,7 @@ int ssl_get(COMSTACK h, char **buf, int *bufsize)
         sp->altsize = tmpi;
     }
     h->io_pending = 0;
-    while (!(berlen = (*sp->complete)((unsigned char *)*buf, hasread)))
+    while (!(berlen = (*sp->complete)(*buf, hasread)))
     {
         if (!*bufsize)
         {
@@ -1040,20 +1083,8 @@ int ssl_get(COMSTACK h, char **buf, int *bufsize)
         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;
-                break;
-            }
-            if (ssl_err == SSL_ERROR_WANT_WRITE)
-            {
-                h->io_pending = CS_WANT_WRITE;
+            if (ssl_check_error(h, sp, res))
                 break;
-            }
-            if (res == 0)
-                return 0;
-            h->cerrno = CSERRORSSL;
             return -1;
         }
         hasread += res;
@@ -1153,7 +1184,7 @@ int tcpip_put(COMSTACK h, char *buf, int size)
 }
 
 
-#if HAVE_OPENSSL_SSL_H
+#if ENABLE_SSL
 /*
  * Returns 1, 0 or -1
  * In nonblocking mode, you must call again with same buffer while
@@ -1179,22 +1210,12 @@ int ssl_put(COMSTACK h, char *buf, int size)
     }
     while (state->towrite > state->written)
     {
-        res = SSL_write (state->ssl, buf + state->written,
-                         size - state->written);
+        res = SSL_write(state->ssl, 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;
-                return 1;
-            }
-            if (ssl_err == SSL_ERROR_WANT_WRITE)
-            {
-                h->io_pending = CS_WANT_WRITE;
+            if (ssl_check_error(h, state, res))
                 return 1;
-            }
-            h->cerrno = CSERRORSSL;
             return -1;
         }
         state->written += res;
@@ -1214,7 +1235,7 @@ int tcpip_close(COMSTACK h)
     TRC(fprintf(stderr, "tcpip_close\n"));
     if (h->iofile != -1)
     {
-#if HAVE_OPENSSL_SSL_H
+#if ENABLE_SSL
         if (sp->ssl)
         {
             SSL_shutdown (sp->ssl);
@@ -1228,7 +1249,7 @@ int tcpip_close(COMSTACK h)
     }
     if (sp->altbuf)
         xfree(sp->altbuf);
-#if HAVE_OPENSSL_SSL_H
+#if ENABLE_SSL
     if (sp->ssl)
     {
         TRC (fprintf(stderr, "SSL_free\n"));
@@ -1299,7 +1320,7 @@ char *tcpip_addrstr(COMSTACK h)
         sprintf(buf, "http:%s", r);
     else
         sprintf(buf, "tcp:%s", r);
-#if HAVE_OPENSSL_SSL_H
+#if ENABLE_SSL
     if (sp->ctx)
     {
         if (h->protocol == PROTO_HTTP)
@@ -1335,7 +1356,7 @@ int static tcpip_set_blocking(COMSTACK p, int flags)
     return 1;
 }
 
-#if HAVE_OPENSSL_SSL_H
+#if ENABLE_SSL
 int cs_set_ssl_ctx(COMSTACK cs, void *ctx)
 {
     struct tcpip_state *sp;
@@ -1373,6 +1394,7 @@ int cs_get_peer_certificate_x509(COMSTACK cs, char **buf, int *len)
     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)
         {
@@ -1386,6 +1408,7 @@ int cs_get_peer_certificate_x509(COMSTACK cs, char **buf, int *len)
             BIO_free(bio);
             return 1;
         }
+#endif
     }
     return 0;
 }