X-Git-Url: http://git.indexdata.com/?p=yaz-moved-to-github.git;a=blobdiff_plain;f=src%2Fcomstack.c;h=cec2fd3dd6f40f75f74ef128146698ae8768e029;hp=12b52182e10310d53fc39b70b969f8297cb833c6;hb=fe42f72dc30321041420cf2d1a83867b1c450f38;hpb=32687c1504015e0675d49983707576f8db9b7bfc

diff --git a/src/comstack.c b/src/comstack.c
index 12b5218..cec2fd3 100644
--- a/src/comstack.c
+++ b/src/comstack.c
@@ -1,19 +1,19 @@
-/*
- * Copyright (C) 1995-2006, Index Data ApS
+/* This file is part of the YAZ toolkit.
+ * Copyright (C) 1995-2012 Index Data
  * See the file LICENSE for details.
- *
- * $Id: comstack.c,v 1.16 2006-08-24 13:25:45 adam Exp $
  */
-
-/** 
+/**
  * \file comstack.c
  * \brief Implements Generic COMSTACK functions
  */
+#if HAVE_CONFIG_H
+#include <config.h>
+#endif
 
 #include <string.h>
-#include <ctype.h>
 #include <errno.h>
 
+#include <yaz/yaz-iconv.h>
 #include <yaz/log.h>
 #include <yaz/comstack.h>
 #include <yaz/tcpip.h>
@@ -24,6 +24,14 @@
 #define strncasecmp _strnicmp
 #endif
 
+#if HAVE_GNUTLS_H
+#define ENABLE_SSL 1
+#endif
+
+#if HAVE_OPENSSL_SSL_H
+#define ENABLE_SSL 1
+#endif
+
 static const char *cs_errlist[] =
 {
     "No error or unspecified error",
@@ -58,9 +66,17 @@ const char *cs_strerror(COMSTACK h)
 
 void cs_get_host_args(const char *type_and_host, const char **args)
 {
-    
+
     *args = "";
-    if (*type_and_host && strncmp(type_and_host, "unix:", 5))
+    if (!strncmp(type_and_host, "unix:", 5))
+    {
+        const char *cp = strchr(type_and_host + 5, ':');
+        if (cp)
+            type_and_host = cp + 1;
+        else
+            type_and_host += strlen(type_and_host); /* empty string */
+    }
+    if (*type_and_host)
     {
         const char *cp;
         cp = strstr(type_and_host, "://");
@@ -74,70 +90,132 @@ void cs_get_host_args(const char *type_and_host, const char **args)
     }
 }
 
-COMSTACK cs_create_host(const char *type_and_host, int blocking, void **vp)
+static int cs_parse_host(const char *uri, const char **host,
+                         CS_TYPE *t, enum oid_proto *proto,
+                         char **connect_host)
 {
-    enum oid_proto proto = PROTO_Z3950;
-    const char *host = 0;
-    COMSTACK cs;
-    CS_TYPE t;
+    *connect_host = 0;
 
-    if (strncmp (type_and_host, "tcp:", 4) == 0)
+    *t = tcpip_type;
+    if (strncmp(uri, "connect:", 8) == 0)
     {
-        t = tcpip_type;
-        host = type_and_host + 4;
+        const char *cp = strchr(uri, ',');
+        if (cp)
+        {
+            size_t len;
+
+            uri += 8;
+            len = cp - uri;
+            *connect_host = (char *) xmalloc(len + 1);
+            memcpy(*connect_host, uri, len);
+            (*connect_host)[len] = '\0';
+            uri = cp + 1;
+        }
     }
-    else if (strncmp (type_and_host, "ssl:", 4) == 0)
+    else if (strncmp(uri, "unix:", 5) == 0)
     {
-#if HAVE_OPENSSL_SSL_H
-        t = ssl_type;
-        host = type_and_host + 4;
-#else
+        const char *cp;
+
+        uri += 5;
+        cp = strchr(uri, ':');
+        if (cp)
+        {
+            size_t len = cp - uri;
+            *connect_host = (char *) xmalloc(len + 1);
+            memcpy(*connect_host, uri, len);
+            (*connect_host)[len] = '\0';
+            uri = cp + 1;
+        }
+        else
+        {
+            *connect_host = xstrdup(uri);
+            uri += strlen(uri); /* set to "" */
+        }
+#ifdef WIN32
         return 0;
+#else
+        *t = unix_type;
 #endif
     }
-    else if (strncmp (type_and_host, "unix:", 5) == 0)
+
+    if (strncmp (uri, "tcp:", 4) == 0)
+    {
+        *host = uri + 4;
+        *proto = PROTO_Z3950;
+    }
+    else if (strncmp (uri, "ssl:", 4) == 0)
     {
-#ifndef WIN32
-        t = unix_type;
-        host = type_and_host + 5;
+#if ENABLE_SSL
+        *t = ssl_type;
+        *host = uri + 4;
+        *proto = PROTO_Z3950;
 #else
         return 0;
 #endif
     }
-    else if (strncmp(type_and_host, "http:", 5) == 0)
+    else if (strncmp(uri, "http:", 5) == 0)
     {
-        t = tcpip_type;
-        host = type_and_host + 5;
-        while (host[0] == '/')
-            host++;
-        proto = PROTO_HTTP;
+        *host = uri + 5;
+        while (**host == '/')
+            (*host)++;
+        *proto = PROTO_HTTP;
     }
-    else if (strncmp(type_and_host, "https:", 6) == 0)
+    else if (strncmp(uri, "https:", 6) == 0)
     {
-#if HAVE_OPENSSL_SSL_H
-        t = ssl_type;
-        host = type_and_host + 6;
-        while (host[0] == '/')
-            host++;
-        proto = PROTO_HTTP;
+#if ENABLE_SSL
+        *t = ssl_type;
+        *host = uri + 6;
+        while (**host == '/')
+            (*host)++;
+        *proto = PROTO_HTTP;
 #else
         return 0;
 #endif
     }
     else
     {
-        t = tcpip_type;
-        host = type_and_host;
+        *host = uri;
+        *proto = PROTO_Z3950;
     }
-    cs = cs_create (t, blocking, proto);
-    if (!cs)
+    return 1;
+}
+
+COMSTACK cs_create_host(const char *vhost, int blocking, void **vp)
+{
+    return cs_create_host_proxy(vhost, blocking, vp, 0);
+}
+
+COMSTACK cs_create_host_proxy(const char *vhost, int blocking, void **vp,
+                              const char *proxy_host)
+{
+    enum oid_proto proto = PROTO_Z3950;
+    const char *host = 0;
+    COMSTACK cs;
+    CS_TYPE t;
+    char *connect_host = 0;
+
+    if (!cs_parse_host(vhost, &host, &t, &proto, &connect_host))
         return 0;
 
-    if (!(*vp = cs_straddr(cs, host)))
+    if (t == tcpip_type)
     {
-        cs_close (cs);
-        return 0;
-    }    
+        cs = yaz_tcpip_create(-1, blocking, proto, connect_host ? host : 0);
+    }
+    else
+    {
+        cs = cs_create(t, blocking, proto);
+    }
+    if (cs)
+    {
+        if (proxy_host)
+            host = proxy_host;
+        if (!(*vp = cs_straddr(cs, connect_host ? connect_host : host)))
+        {
+            cs_close (cs);
+            cs = 0;
+        }
+    }
+    xfree(connect_host);
     return cs;
 }
 
@@ -146,150 +224,196 @@ int cs_look (COMSTACK cs)
     return cs->event;
 }
 
-#define CHUNK_DEBUG 0
-int cs_complete_auto(const unsigned char *buf, int len)
+static int skip_crlf(const char *buf, int len, int *i)
 {
-    if (len > 5 && buf[0] >= 0x20 && buf[0] < 0x7f
-                && buf[1] >= 0x20 && buf[1] < 0x7f
-                && buf[2] >= 0x20 && buf[2] < 0x7f)
+    if (*i < len)
     {
-        /* deal with HTTP request/response */
-        int i = 2, content_len = 0, chunked = 0;
+        if (buf[*i] == '\r' && *i < len-1 && buf[*i + 1] == '\n')
+        {
+            (*i) += 2;
+            return 1;
+        }
+        else if (buf[*i] == '\n')
+        {
+            (*i)++;
+            return 1;
+        }
+    }
+    return 0;
+}
 
-        /* if dealing with HTTP responses - then default
-           content length is unlimited (socket close) */
-        if (!memcmp(buf, "HTTP/", 5))
-            content_len = -1; 
+#define CHUNK_DEBUG 0
 
-        while (i <= len-4)
-        {
-            if (i > 8192)
-            {
-                return i;  /* do not allow more than 8K HTTP header */
-            }
-            if (buf[i] == '\r' && buf[i+1] == '\n')
-            {
-                i += 2;
-                if (buf[i] == '\r' && buf[i+1] == '\n')
-                {
-                    if (chunked)
-                    { 
-                        /* inside chunked body .. */
-                        while(1)
-                        {
-                            int j, chunk_len = 0;
-                            i += 2;
+static int cs_read_chunk(const char *buf, int i, int len)
+{
+    /* inside chunked body .. */
+    while (1)
+    {
+        int chunk_len = 0;
 #if CHUNK_DEBUG
-/* debugging */
-                            if (i <len-2)
-                            {
-                                printf ("\n<<<");
-                                int j;
-                                for (j = i; j <= i+4; j++)
-                                    printf ("%c", buf[j]);
-                                printf (">>>\n");
-                            }
+        if (i < len-2)
+        {
+            printf ("\n<<<");
+            int j;
+            for (j = i; j <= i+3; j++)
+                printf ("%c", buf[j]);
+            printf (">>>\n");
+        }
 #endif
-                            /* read chunk length */
-                            while (1)
-                                if (i >= len-2) {
+        /* read chunk length */
+        while (1)
+            if (i >= len-2) {
 #if CHUNK_DEBUG
-/* debugging */                                    
-                                    printf ("XXXXXXXX not there yet 1\n");
-                                    printf ("i=%d len=%d\n", i, len);
+                printf ("returning incomplete read at 1\n");
+                printf ("i=%d len=%d\n", i, len);
 #endif
-                                    return 0;
-                                } else if (isdigit(buf[i]))
-                                    chunk_len = chunk_len * 16 + 
-                                        (buf[i++] - '0');
-                                else if (isupper(buf[i]))
-                                    chunk_len = chunk_len * 16 + 
-                                        (buf[i++] - ('A'-10));
-                                else if (islower(buf[i]))
-                                    chunk_len = chunk_len * 16 + 
-                                        (buf[i++] - ('a'-10));
-                                else
-                                    break;
-                            /* move forward until CRLF - skip chunk ext */
-                            j = 0;
-                            while (buf[i] != '\r' && buf[i+1] != '\n')
-                            {
-                                if (i >= len-2)
-                                    return 0;   /* need more buffer .. */
-                                if (++j > 1000)
-                                    return i; /* enough.. stop */
-                                i++;
-                            }
-                            /* got CRLF */
+                return 0;
+            } else if (yaz_isdigit(buf[i]))
+                chunk_len = chunk_len * 16 +
+                    (buf[i++] - '0');
+            else if (yaz_isupper(buf[i]))
+                chunk_len = chunk_len * 16 +
+                    (buf[i++] - ('A'-10));
+            else if (yaz_islower(buf[i]))
+                chunk_len = chunk_len * 16 +
+                    (buf[i++] - ('a'-10));
+            else
+                break;
+        if (chunk_len == 0)
+            break;
+        if (chunk_len < 0)
+            return i;
+
+        while (1)
+        {
+            if (i >= len -1)
+                return 0;
+            if (skip_crlf(buf, len, &i))
+                break;
+            i++;
+        }
+        /* got CRLF */
 #if CHUNK_DEBUG
-                            printf ("XXXXXX chunk_len=%d\n", chunk_len);
-#endif                      
-                            if (chunk_len < 0)
-                                return i+2;    /* bad chunk_len */
-                            if (chunk_len == 0)
-                                break;
-                            i += chunk_len+2;
-                        }
-                        /* consider trailing headers .. */
-                        while(i <= len-4)
-                        {
-                            if (buf[i] == '\r' &&  buf[i+1] == '\n' &&
-                                buf[i+2] == '\r' && buf[i+3] == '\n')
-                                if (len >= i+4)
-                                    return i+4;
-                            i++;
-                        }
+        printf ("chunk_len=%d\n", chunk_len);
+#endif
+        i += chunk_len;
+        if (i >= len-2)
+            return 0;
+        if (!skip_crlf(buf, len, &i))
+            return 0;
+    }
+    /* consider trailing headers .. */
+    while (i < len)
+    {
+        if (skip_crlf(buf, len, &i))
+        {
+            if (skip_crlf(buf, len, &i))
+                return i;
+        }
+        else
+            i++;
+    }
 #if CHUNK_DEBUG
-/* debugging */
-                        printf ("XXXXXXXXX not there yet 2\n");
-                        printf ("i=%d len=%d\n", i, len);
+    printf ("returning incomplete read at 2\n");
+    printf ("i=%d len=%d\n", i, len);
 #endif
-                        return 0;
-                    }
-                    else
-                    {   /* not chunked ; inside body */
-                        /* i += 2 seems not to work with GCC -O2 .. 
-                           so i+2 is used instead .. */
-                        if (content_len == -1)
-                            return 0;   /* no content length */
-                        else if (len >= (i+2)+ content_len)
-                        {
-                            return (i+2)+ content_len;
-                        }
+    return 0;
+}
+
+static int cs_complete_http(const char *buf, int len, int head_only)
+{
+    /* deal with HTTP request/response */
+    int i = 2, content_len = 0, chunked = 0;
+
+    if (len < 6)
+        return 0;
+
+    /* if dealing with HTTP responses - then default
+       content length is unlimited (socket close) */
+    if (!head_only && !memcmp(buf, "HTTP/", 5))
+        content_len = -1;
+
+#if 0
+    printf("len = %d\n", len);
+    fwrite (buf, 1, len, stdout);
+    printf("----------\n");
+#endif
+    while (i <= len-2)
+    {
+        if (i > 8192)
+        {
+            return i;  /* do not allow more than 8K HTTP header */
+        }
+        if (skip_crlf(buf, len, &i))
+        {
+            if (skip_crlf(buf, len, &i))
+            {
+                /* inside content */
+                if (chunked)
+                    return cs_read_chunk(buf, i, len);
+                else
+                {   /* not chunked ; inside body */
+                    if (content_len == -1)
+                        return 0;   /* no content length */
+                    else if (len >= i + content_len)
+                    {
+                        return i + content_len;
                     }
-                    break;
-                }
-                else if (i < len - 20 && 
-                         !strncasecmp((const char *) buf+i, "Transfer-Encoding:", 18))
-                {
-                    i+=18;
-                    while (buf[i] == ' ')
-                        i++;
-                    if (i < len - 8)
-                        if (!strncasecmp((const char *) buf+i, "chunked", 7))
-                            chunked = 1;
-                }
-                else if (i < len - 17 &&
-                         !strncasecmp((const char *)buf+i, "Content-Length:", 15))
-                {
-                    i+= 15;
-                    while (buf[i] == ' ')
-                        i++;
-                    content_len = 0;
-                    while (i <= len-4 && isdigit(buf[i]))
-                        content_len = content_len*10 + (buf[i++] - '0');
-                    if (content_len < 0) /* prevent negative offsets */
-                        content_len = 0;
                 }
-                else
+                break;
+            }
+            else if (i < len - 20 &&
+                     !strncasecmp((const char *) buf+i, "Transfer-Encoding:", 18))
+            {
+                i+=18;
+                while (buf[i] == ' ')
+                    i++;
+                if (i < len - 8)
+                    if (!strncasecmp((const char *) buf+i, "chunked", 7))
+                        chunked = 1;
+            }
+            else if (i < len - 17 &&
+                     !strncasecmp((const char *)buf+i, "Content-Length:", 15))
+            {
+                i+= 15;
+                while (buf[i] == ' ')
                     i++;
+                content_len = 0;
+                while (i <= len-4 && yaz_isdigit(buf[i]))
+                    content_len = content_len*10 + (buf[i++] - '0');
+                if (content_len < 0) /* prevent negative offsets */
+                    content_len = 0;
             }
             else
                 i++;
         }
-        return 0;
+        else
+            i++;
+    }
+    return 0;
+}
+
+static int cs_complete_auto_x(const char *buf, int len, int head_only)
+{
+    if (len > 5 && buf[0] >= 0x20 && buf[0] < 0x7f
+                && buf[1] >= 0x20 && buf[1] < 0x7f
+                && buf[2] >= 0x20 && buf[2] < 0x7f)
+    {
+        int r = cs_complete_http(buf, len, head_only);
+        return r;
     }
-    return completeBER(buf, len);
+    return completeBER((const unsigned char *) buf, len);
+}
+
+
+int cs_complete_auto(const char *buf, int len)
+{
+    return cs_complete_auto_x(buf, len, 0);
+}
+
+int cs_complete_auto_head(const char *buf, int len)
+{
+    return cs_complete_auto_x(buf, len, 1);
 }
 
 void cs_set_max_recv_bytes(COMSTACK cs, int max_recv_bytes)
@@ -300,6 +424,7 @@ void cs_set_max_recv_bytes(COMSTACK cs, int max_recv_bytes)
 /*
  * Local variables:
  * c-basic-offset: 4
+ * c-file-style: "Stroustrup"
  * indent-tabs-mode: nil
  * End:
  * vim: shiftwidth=4 tabstop=8 expandtab