X-Git-Url: http://git.indexdata.com/?a=blobdiff_plain;ds=sidebyside;f=src%2Ftcpip.c;h=54025270793cf242b28aa03c160e0d296b7d2c28;hb=a4459ba5eb7552f2c11ad9efe7f5b7bd63c64fb3;hp=72faa782a9ae238a5b3118a5a343d6207adfe617;hpb=0b3ab2336aeda693cbecbf78ff956103f4e6d0cc;p=yaz-moved-to-github.git

diff --git a/src/tcpip.c b/src/tcpip.c
index 72faa78..5402527 100644
--- a/src/tcpip.c
+++ b/src/tcpip.c
@@ -1,8 +1,6 @@
-/*
- * Copyright (C) 1995-2006, 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.24 2006-08-30 19:26:43 adam Exp $
  */
 /**
  * \file tcpip.c
@@ -26,10 +24,17 @@
 #endif
 
 #ifdef WIN32
+
+/* 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
+
+#else
 #include <netinet/in.h>
 #include <netdb.h>
 #include <arpa/inet.h>
@@ -39,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>
@@ -58,6 +66,8 @@
 static int 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);
@@ -67,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
@@ -95,19 +105,23 @@ 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 *res;
+    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;
     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
@@ -137,44 +151,20 @@ static int tcpip_init (void)
  * 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 ())
         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;
@@ -195,20 +185,20 @@ COMSTACK tcpip_type(int s, int blocking, int protocol, void *vp)
     p->f_set_blocking = tcpip_set_blocking;
     p->max_recv_bytes = 5000000;
 
-    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 ENABLE_SSL
     sp->ctx = sp->ctx_alloc = 0;
     sp->ssl = 0;
     strcpy(sp->cert_fname, "yaz.pem");
 #endif
 
 #if HAVE_GETADDRINFO
-    sp->res = 0;
+    sp->ai = 0;
 #endif
     sp->altbuf = 0;
     sp->altsize = sp->altlen = 0;
@@ -218,20 +208,46 @@ COMSTACK tcpip_type(int s, int blocking, int protocol, void *vp)
     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;
+}
+
+
+#if ENABLE_SSL
 
-COMSTACK ssl_type(int s, int blocking, int protocol, void *vp)
+COMSTACK ssl_type(int s, int flags, int protocol, void *vp)
 {
     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;
@@ -267,7 +283,7 @@ struct addrinfo *tcpip_getaddrinfo(const char *str, const char *port)
     host[sizeof(host)-1] = 0;
     if ((p = strchr(host, '/')))
         *p = 0;
-    if ((p = strchr(host, ':')))
+    if ((p = strrchr(host, ':')))
     {
         *p = '\0';
         port = p+1;
@@ -306,7 +322,7 @@ int tcpip_strtoaddr_ex(const char *str, struct sockaddr_in *add,
     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);
@@ -341,10 +357,27 @@ void *tcpip_straddr(COMSTACK h, const char *str)
     if (!tcpip_init ())
         return 0;
 
-    if (sp->res)
-        freeaddrinfo(sp->res);
-    sp->res = tcpip_getaddrinfo(str, port);
-    return sp->res;
+    if (sp->ai)
+        freeaddrinfo(sp->ai);
+    sp->ai = tcpip_getaddrinfo(str, port);
+    if (sp->ai && h->state == CS_ST_UNBND)
+    {
+        int s = -1;
+        struct addrinfo *ai = sp->ai;
+        for (; 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;
+        h->iofile = s;
+        
+        if (!tcpip_set_blocking(h, h->flags))
+            return 0;
+    }
+    return sp->ai;
 }
 #else
 void *tcpip_straddr(COMSTACK h, const char *str)
@@ -358,6 +391,17 @@ void *tcpip_straddr(COMSTACK h, const char *str)
         return 0;
     if (!tcpip_strtoaddr_ex (str, &sp->addr, port))
         return 0;
+    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
@@ -366,8 +410,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);
 }
 
 /*
@@ -378,7 +421,7 @@ int tcpip_more(COMSTACK h)
 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
@@ -394,6 +437,13 @@ int tcpip_connect(COMSTACK h, void *address)
         h->cerrno = CSOUTSTATE;
         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
@@ -422,7 +472,9 @@ int tcpip_connect(COMSTACK h, void *address)
 #endif
 
 #if HAVE_GETADDRINFO
-    r = connect(h->iofile, ai->ai_addr, ai->ai_addrlen);
+    r = connect(h->iofile, sp->ai->ai_addr, sp->ai->ai_addrlen);
+    freeaddrinfo(sp->ai);
+    sp->ai = 0;
 #else
     r = connect(h->iofile, (struct sockaddr *) add, sizeof(*add));
 #endif
@@ -459,7 +511,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"));
@@ -471,13 +523,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();
-        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;
@@ -493,7 +545,8 @@ 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 HAVE_OPENSSL_SSL_H
         if (res <= 0)
         {
             int err = SSL_get_error(sp->ssl, res);
@@ -510,6 +563,20 @@ int tcpip_rcvconnect(COMSTACK h)
             h->cerrno = CSERRORSSL;
             return -1;
         }
+#else
+        TRC(fprintf(stderr, "SSL_connect res=%d last_error=%d\n",
+                    res, sp->ssl->last_error));
+        if (res == 0 && sp->ssl->last_error == GNUTLS_E_AGAIN)
+        {
+            h->io_pending = CS_WANT_READ;
+            return 1;
+        }
+        else if (res <= 0)
+        {
+            h->cerrno = CSERRORSSL;
+            return -1;
+        }
+#endif
     }
 #endif
     h->event = CS_DATA;
@@ -544,25 +611,32 @@ static void tcpip_setsockopt (int fd)
 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_GETADDRINFO
+    if (sp->ai != (struct addrinfo *) address)
+    {
+        h->cerrno = CSOUTSTATE;
+        return -1;
+    }
+#endif
+
+#if ENABLE_SSL
     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;
@@ -574,25 +648,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"));
     }
@@ -613,7 +700,9 @@ static int tcpip_bind(COMSTACK h, void *address, int mode)
 #endif
     tcpip_setsockopt(h->iofile);
 #if HAVE_GETADDRINFO
-    r = bind(h->iofile, ai->ai_addr, ai->ai_addrlen);
+    r = bind(h->iofile, sp->ai->ai_addr, sp->ai->ai_addrlen);
+    freeaddrinfo(sp->ai);
+    sp->ai = 0;
 #else
     r = bind(h->iofile, addr, sizeof(struct sockaddr_in));
 #endif
@@ -663,7 +752,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))
@@ -727,13 +824,7 @@ COMSTACK tcpip_accept(COMSTACK h)
             }
             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)
@@ -754,10 +845,13 @@ COMSTACK tcpip_accept(COMSTACK h)
         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 ENABLE_SSL
         state->ctx = st->ctx;
         state->ctx_alloc = 0;
         state->ssl = st->ssl;
@@ -767,16 +861,20 @@ COMSTACK tcpip_accept(COMSTACK h)
             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 ENABLE_SSL
         tcpip_state *state = (tcpip_state *)h->cprivate;
         if (state->ctx)
         {
-            int res = SSL_accept (state->ssl);
+            int res;
             TRC(fprintf(stderr, "SSL_accept\n"));
+            res = SSL_accept (state->ssl);
+#if HAVE_OPENSSL_SSL_H
             if (res <= 0)
             {
                 int err = SSL_get_error(state->ssl, res);
@@ -793,6 +891,20 @@ COMSTACK tcpip_accept(COMSTACK h)
                 cs_close (h);
                 return 0;
             }
+#else
+            TRC(fprintf(stderr, "SSL_accept res=%d last_error=%d\n",
+                        res, state->ssl->last_error));
+            if (res == 0 && state->ssl->last_error == GNUTLS_E_AGAIN)
+            {
+                h->io_pending = CS_WANT_READ;
+                return h;
+            }
+            else if (res <= 0) /* assume real error */
+            {
+                cs_close(h);
+                return 0;
+            }
+#endif
         }
 #endif
     }
@@ -835,7 +947,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)
         {
@@ -860,7 +972,7 @@ int tcpip_get(COMSTACK h, char **buf, int *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)
@@ -869,7 +981,10 @@ int tcpip_get(COMSTACK h, char **buf, int *bufsize)
                 break;
             }
             else
+            {
+                h->cerrno = CSYSERR;
                 return -1;
+            }
 #else
             if (yaz_errno() == EWOULDBLOCK 
 #ifdef EAGAIN   
@@ -889,7 +1004,10 @@ int tcpip_get(COMSTACK h, char **buf, int *bufsize)
             else if (yaz_errno() == 0)
                 continue;
             else
+            {
+                h->cerrno = CSYSERR;
                 return -1;
+            }
 #endif
         }
         else if (!res)
@@ -913,10 +1031,16 @@ int tcpip_get(COMSTACK h, char **buf, int *bufsize)
         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));
         memcpy(sp->altbuf, *buf + berlen, sp->altlen = tomove);
@@ -927,7 +1051,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.
@@ -954,7 +1078,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)
         {
@@ -1081,7 +1205,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
@@ -1142,7 +1266,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);
@@ -1156,7 +1280,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"));
@@ -1167,9 +1291,11 @@ int tcpip_close(COMSTACK h)
         SSL_CTX_free (sp->ctx_alloc);
 #endif
 #if HAVE_GETADDRINFO
-    if (sp->res)
-        freeaddrinfo(sp->res);
+    if (sp->ai)
+        freeaddrinfo(sp->ai);
 #endif
+    xfree(sp->connect_request_buf);
+    xfree(sp->connect_response_buf);
     xfree(sp);
     xfree(h);
     return 0;
@@ -1177,30 +1303,55 @@ int tcpip_close(COMSTACK h)
 
 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);
+        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 ENABLE_SSL
     if (sp->ctx)
     {
         if (h->protocol == PROTO_HTTP)
@@ -1212,30 +1363,31 @@ char *tcpip_addrstr(COMSTACK h)
     return buf;
 }
 
-int static tcpip_set_blocking(COMSTACK p, int blocking)
+int static 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
+#if ENABLE_SSL
 int cs_set_ssl_ctx(COMSTACK cs, void *ctx)
 {
     struct tcpip_state *sp;
@@ -1273,6 +1425,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)
         {
@@ -1286,6 +1439,7 @@ int cs_get_peer_certificate_x509(COMSTACK cs, char **buf, int *len)
             BIO_free(bio);
             return 1;
         }
+#endif
     }
     return 0;
 }
@@ -1311,6 +1465,38 @@ int cs_set_ssl_certificate_file(COMSTACK cs, const char *fname)
 }
 #endif
 
+
+static int tcpip_put_connect(COMSTACK h, char *buf, int size)
+{
+    struct tcpip_state *state = (struct tcpip_state *)h->cprivate;
+
+    int r = tcpip_put(h, state->connect_request_buf,
+                      state->connect_request_len);
+    if (r == 0)
+    {
+        /* it's sent */
+        h->f_put = tcpip_put; /* switch to normal tcpip put */
+        r = tcpip_put(h, buf, size);
+    }
+    return r;
+}
+
+static int tcpip_get_connect(COMSTACK h, char **buf, int *bufsize)
+{
+    struct tcpip_state *state = (struct tcpip_state *)h->cprivate;
+    int r;
+
+    r = tcpip_get(h, &state->connect_response_buf, 
+                  &state->connect_response_len);
+    if (r < 1)
+        return r;
+    /* got the connect response completely */
+    state->complete = cs_complete_auto; /* switch to normal tcpip get */
+    h->f_get = tcpip_get;
+    return tcpip_get(h, buf, bufsize);
+}
+
+
 /*
  * Local variables:
  * c-basic-offset: 4