comstack.c

Go to the documentation of this file.

/* This file is part of the YAZ toolkit.
 * Copyright (C) Index Data
 * See the file LICENSE for details.
 */
#if HAVE_CONFIG_H
#include <config.h>
#endif
 
#include <string.h>
#include <errno.h>
#include <limits.h>
 
#include <yaz/yaz-iconv.h>
#include <yaz/log.h>
#include "comstack-p.h"
#include <yaz/tcpip.h>
#include <yaz/unix.h>
#include <yaz/odr.h>
#include <yaz/matchstr.h>
#include <yaz/atoi.h>
 
static const char *cs_errlist[] =
{
    "No error or unspecified error",
    "System (lower-layer) error",
    "Operation out of state",
    "No data (operation would block)",
    "New data while half of old buffer is on the line (flow control)",
    "Permission denied",
    "SSL error",
    "Too large incoming buffer",
    "Protocol error in incoming data"
};
 
const char *cs_errmsg(int n)
{
    if (n < CSNONE || n > CSLASTERROR)
        n = CSNONE;
    return cs_errlist[n];
}
 
const char *cs_strerror(COMSTACK h)
{
    return cs_errmsg(h->cerrno);
}
 
int cs_get_error(COMSTACK cs, const char **details)
{
    if (details)
        *details = yaz_tcpip_get_error_details(cs);
    return cs->cerrno;
}
 
void cs_get_host_args(const char *type_and_host, const char **args)
{
    *args = "";
    if (!strncmp(type_and_host, "unix:", 5))
    {
        const char *cp = strchr(type_and_host + 5, ':');
        if (!cp)
            return;
        type_and_host = cp + 1;
        if (!strchr(type_and_host, ':'))
        {
            *args = type_and_host;  /* unix:path:args */
            return;
        }
    }
    if (*type_and_host)
    {
        const char *cp = strchr(type_and_host, '/');
        if (cp)
        {
            if (cp > type_and_host && !memcmp(cp - 1, "://", 3))
                cp = strchr(cp + 2, '/');
        }
        if (cp)
            *args = cp + 1;
    }
}
 
int cs_parse_host(const char *uri, const char **host,
                  CS_TYPE *t, enum oid_proto *proto,
                  char **connect_host)
{
    *connect_host = 0;
 
    *t = tcpip_type;
    if (strncmp(uri, "connect:", 8) == 0)
    {
        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(uri, "unix:", 5) == 0)
    {
        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;
        }
#ifdef WIN32
        xfree(*connect_host);
        *connect_host = 0;
        return 0;
#else
        *t = unix_type;
#endif
    }
 
    if (strncmp (uri, "tcp:", 4) == 0)
    {
        *host = uri + 4;
        *proto = PROTO_Z3950;
    }
    else if (strncmp (uri, "ssl:", 4) == 0)
    {
#if HAVE_GNUTLS_H
        *t = ssl_type;
        *host = uri + 4;
        *proto = PROTO_Z3950;
#else
        xfree(*connect_host);
        *connect_host = 0;
        return 0;
#endif
    }
    else if (strncmp(uri, "http:", 5) == 0)
    {
        *host = uri + 5;
        while (**host == '/')
            (*host)++;
        *proto = PROTO_HTTP;
    }
    else if (strncmp(uri, "https:", 6) == 0)
    {
#if HAVE_GNUTLS_H
        *t = ssl_type;
        *host = uri + 6;
        while (**host == '/')
            (*host)++;
        *proto = PROTO_HTTP;
#else
        xfree(*connect_host);
        *connect_host = 0;
        return 0;
#endif
    }
    else
    {
        *host = uri;
        *proto = PROTO_Z3950;
    }
    return 1;
}
 
COMSTACK cs_create_host(const char *vhost, int flags, void **vp)
{
    return cs_create_host_proxy(vhost, flags, vp, 0);
}
 
COMSTACK cs_create_host_proxy(const char *vhost, int flags, void **vp,
                              const char *proxy_host)
{
    int proxy_mode;
    return cs_create_host2(vhost, flags, vp, proxy_host, &proxy_mode);
}
 
COMSTACK cs_create_host2(const char *vhost, int flags, void **vp,
                         const char *proxy_host, int *proxy_mode)
{
    enum oid_proto proto = PROTO_Z3950;
    const char *host = 0;
    COMSTACK cs;
    CS_TYPE t;
    char *connect_buf = 0;
    char *connect_host = 0;
    char *connect_auth = 0;
 
    const char *bind_host = strchr(vhost, ' ');
    if (bind_host && bind_host[1])
        bind_host++;
    else
        bind_host = 0;
 
    *proxy_mode = 0;
    if (!cs_parse_host(vhost, &host, &t, &proto, &connect_buf))
        return 0;
 
    /*  vhost      proxy       proxy method  proxy-flag */
    /*  TCP+Z3950  TCP+Z3950   TCP+Z3950      1 */
    /*  TCP+Z3950  TCP+HTTP    CONNECT        0 */
    /*  TCP+HTTP   TCP+Z3950   TCP+HTTP       1 */
    /*  TCP+HTTP   TCP+HTTP    TCP+HTTP       1 */
    /*  SSL+*      TCP+*       CONNECT        0 */
    /*  ?          SSL         error */
 
    if (proxy_host && !connect_buf)
    {
        enum oid_proto proto1;
        CS_TYPE t1;
        const char *host1 = 0;
 
        if (!cs_parse_host(proxy_host, &host1, &t1, &proto1, &connect_buf))
            return 0;
        if (connect_buf)
        {
            xfree(connect_buf);
            return 0;
        }
        if (t1 != tcpip_type)
            return 0;
 
        if (t == ssl_type || (proto == PROTO_Z3950 && proto1 == PROTO_HTTP))
            connect_buf = xstrdup(host1);
        else
        {
            *proxy_mode = 1;
            host = host1;
        }
    }
    if (connect_buf)
    {
        char *cp = strchr(connect_buf, '@');
        if (cp)
        {
            *cp = '\0';
            connect_host = cp + 1;
            connect_auth = connect_buf;
        } else {
            connect_host = connect_buf;
        }
    }
    if (t == tcpip_type)
    {
        cs = yaz_tcpip_create3(-1, flags, proto, connect_host ? host : 0,
                               connect_auth, bind_host);
    }
    else if (t == ssl_type)
    {
        cs = yaz_ssl_create(-1, flags, proto, connect_host ? host : 0,
                            connect_auth, bind_host);
    }
    else
    {
        cs = cs_create(t, flags, proto);
    }
    if (cs)
    {
        if (!(*vp = cs_straddr(cs, connect_host ? connect_host : host)))
        {
            cs_close (cs);
            cs = 0;
        }
    }
    xfree(connect_buf);
    return cs;
}
 
int cs_look (COMSTACK cs)
{
    return cs->event;
}
 
static int skip_crlf(const char *buf, int len, int *i)
{
    if (*i < len)
    {
        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;
}
 
static int http_token_char(char c)
{
    /* RFC 9110, Section 5.6.2: tchar */
    return yaz_isdigit(c) || yaz_isupper(c) || yaz_islower(c)
        || (c && strchr("!#$%&'*+-.^_`|~", c));
}
 
int yaz_http_parse_chunks(const char *buf, int len, char *content_buf,
                          int *content_len)
{
    int i = 0;
    int off = 0;
 
    /* inside chunked body .. */
    while (1)
    {
        int chunk_len = 0;
        int ret;
 
        if (i >= len)
            return 0;
        /* read chunk length */
        ret = yaz_atoi(16, buf + i, len - i, &chunk_len);
        if (ret <= 0)
            return -1;
        i += ret;
        /* skip chunk extension and consume the line ending */
        while (1)
        {
            if (i >= len)
                return 0;
            if (skip_crlf(buf, len, &i))
                break;
            i++;
        }
 
        if (chunk_len == 0)
            break;
        if (chunk_len > len - i)
            return 0;
        if (content_buf)
            memcpy(content_buf + off, buf + i, chunk_len);
        i += chunk_len;
        off += chunk_len;
        if (i >= len)
            return 0;
        if (!skip_crlf(buf, len, &i))
        {
            if (buf[i] == '\r' && i == len - 1)
                return 0;
            return -1;
        }
    }
    /* consider trailing headers .. */
    while (1)
    {
        if (i >= len)
            return 0;
        if (buf[i] == '\r' && i == len - 1)
            return 0;
        if (skip_crlf(buf, len, &i))
        {
            if (content_len)
                *content_len = off;
            return i;
        }
 
        /* validate the trailer field name */
        {
            int field_start = i;
 
            while (1)
            {
                if (i >= len)
                    return 0;
                if (buf[i] == ':')
                {
                    if (i == field_start)
                        return -1;
                    i++;
                    break;
                }
                if (!http_token_char(buf[i]))
                    return -1;
                i++;
            }
        }
 
        /* skip the trailer field value */
        while (1)
        {
            if (i >= len)
                return 0;
            if (skip_crlf(buf, len, &i))
                break;
            i++;
        }
    }
}
 
static int cs_complete_http(const char *buf, int len, int head_only)
{
    /* deal with HTTP request/response */
    int i, content_len = 0, chunked = 0;
 
    /* need at least one line followed by \n or \r .. */
    for (i = 0; ; i++)
        if (i == len)
            return 0; /* incomplete */
        else if (buf[i] == '\n' || buf[i] == '\r')
            break;
 
    /* check to see if it's a response with content */
    if (!head_only && !memcmp(buf, "HTTP/", 5))
    {
        int j;
        for (j = 5; j < i; j++)
            if (buf[j] == ' ')
            {
                ++j;
                if (buf[j] == '1') /* 1XX */
                    head_only = 1;
                else if (!memcmp(buf + j, "204", 3))
                    head_only = 1;
                else if (!memcmp(buf + j, "304", 3))
                    head_only = 1;
                else
                    content_len = -1;
                break;
            }
    }
    for (i = 2; i <= len - 2; )
    {
        if (i > 8192)
            return -1;  /* header exceeds 8K: protocol error */
        if (!skip_crlf(buf, len, &i))
        {
            i++;
            continue;
        }
        if (skip_crlf(buf, len, &i))
        {
            /* inside content */
            if (head_only)
                return i;
            if (chunked)
            {
                int r = yaz_http_parse_chunks(buf + i, len - i, 0, 0);
                return r > 0 ? i + r : r;
            }
            if (content_len == -1)
                return 0;   /* no content length */
            if (content_len > (unsigned)(INT_MAX - i))
                return -1;
            if (len >= i + content_len)
                return i + content_len;
            break;
        }
        if (i < len - 19 && !yaz_strncasecmp(buf+i, "Transfer-Encoding:", 18))
        {
            int token_start;
            i += 18;
            while (i < len && buf[i] == ' ')
                i++;
            token_start = i;
            for (;;)
            {
                int j;
                if (i >= len - 2)
                    return 0;
                if (i == token_start + 7 && !yaz_strncasecmp(buf + token_start, "chunked", 7))
                    chunked = 1;
                j = i;
                if (skip_crlf(buf, len, &j))
                    break;
                i++;
            }
        }
        else if (i < len - 16 && !yaz_strncasecmp(buf+i, "Content-Length:", 15))
        {
            int no_read;
 
            i += 15;
            while (i < len && buf[i] == ' ')
                i++;
            if (i == len)
                return 0;
            no_read = yaz_atoi(10, buf + i, len - i, &content_len);
            if (no_read <= 0)
                return -1;  /* overflow or no digits */
            i += no_read;
        }
        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
                && buf[3] >= 0x20 && buf[3] < 0x7f)
    {
        int r = cs_complete_http(buf, len, head_only);
        return r;
    }
    return completeBER_n(buf, len, 0);
}
 
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);
}
 
int cs_set_head_only(COMSTACK cs, int head_only)
{
    if (cs->type == tcpip_type || cs->type == ssl_type)
        return yaz_tcpip_set_head_only(cs, head_only);
#ifndef WIN32
    if (cs->type == unix_type)
        return yaz_unix_set_head_only(cs, head_only);
#endif
    cs->cerrno = CSOUTSTATE;
    return -1;
}
 
void cs_set_max_recv_bytes(COMSTACK cs, int max_recv_bytes)
{
    cs->max_recv_bytes = max_recv_bytes;
}
 
/*
 * Local variables:
 * c-basic-offset: 4
 * c-file-style: "Stroustrup"
 * indent-tabs-mode: nil
 * End:
 * vim: shiftwidth=4 tabstop=8 expandtab
 */