src/comstack.c

   1 /* This file is part of the YAZ toolkit.
   2  * Copyright (C) 1995-2013 Index Data
   3  * See the file LICENSE for details.
   4  */
   5 /**
   6  * \file comstack.c
   7  * \brief Implements Generic COMSTACK functions
   8  */
   9 #if HAVE_CONFIG_H
  10 #include <config.h>
  11 #endif
  12
  13 #include <string.h>
  14 #include <errno.h>
  15
  16 #include <yaz/yaz-iconv.h>
  17 #include <yaz/log.h>
  18 #include <yaz/comstack.h>
  19 #include <yaz/tcpip.h>
  20 #include <yaz/unix.h>
  21 #include <yaz/odr.h>
  22 #include <yaz/matchstr.h>
  23
  24 #if HAVE_GNUTLS_H
  25 #define ENABLE_SSL 1
  26 #endif
  27
  28 #if HAVE_OPENSSL_SSL_H
  29 #define ENABLE_SSL 1
  30 #endif
  31
  32 static const char *cs_errlist[] =
  33 {
  34     "No error or unspecified error",
  35     "System (lower-layer) error",
  36     "Operation out of state",
  37     "No data (operation would block)",
  38     "New data while half of old buffer is on the line (flow control)",
  39     "Permission denied",
  40     "SSL error",
  41     "Too large incoming buffer"
  42 };
  43
  44 const char *cs_errmsg(int n)
  45 {
  46     static char buf[250];
  47
  48     if (n < CSNONE || n > CSLASTERROR) {
  49         sprintf(buf, "unknown comstack error %d", n);
  50         return buf;
  51     }
  52     if (n == CSYSERR) {
  53         sprintf(buf, "%s: %s", cs_errlist[n], strerror(errno));
  54         return buf;
  55     }
  56     return cs_errlist[n];
  57 }
  58
  59 const char *cs_strerror(COMSTACK h)
  60 {
  61     return cs_errmsg(h->cerrno);
  62 }
  63
  64 void cs_get_host_args(const char *type_and_host, const char **args)
  65 {
  66
  67     *args = "";
  68     if (!strncmp(type_and_host, "unix:", 5))
  69     {
  70         const char *cp = strchr(type_and_host + 5, ':');
  71         if (cp)
  72             type_and_host = cp + 1;
  73         else
  74             type_and_host += strlen(type_and_host); /* empty string */
  75     }
  76     if (*type_and_host)
  77     {
  78         const char *cp;
  79         cp = strstr(type_and_host, "://");
  80         if (cp)
  81             cp = cp+3;
  82         else
  83             cp = type_and_host;
  84         cp = strchr(cp, '/');
  85         if (cp)
  86             *args = cp+1;
  87     }
  88 }
  89
  90 static int cs_parse_host(const char *uri, const char **host,
  91                          CS_TYPE *t, enum oid_proto *proto,
  92                          char **connect_host)
  93 {
  94     *connect_host = 0;
  95
  96     *t = tcpip_type;
  97     if (strncmp(uri, "connect:", 8) == 0)
  98     {
  99         const char *cp = strchr(uri, ',');
 100         if (cp)
 101         {
 102             size_t len;
 103
 104             uri += 8;
 105             len = cp - uri;
 106             *connect_host = (char *) xmalloc(len + 1);
 107             memcpy(*connect_host, uri, len);
 108             (*connect_host)[len] = '\0';
 109             uri = cp + 1;
 110         }
 111     }
 112     else if (strncmp(uri, "unix:", 5) == 0)
 113     {
 114         const char *cp;
 115
 116         uri += 5;
 117         cp = strchr(uri, ':');
 118         if (cp)
 119         {
 120             size_t len = cp - uri;
 121             *connect_host = (char *) xmalloc(len + 1);
 122             memcpy(*connect_host, uri, len);
 123             (*connect_host)[len] = '\0';
 124             uri = cp + 1;
 125         }
 126 #ifdef WIN32
 127         return 0;
 128 #else
 129         *t = unix_type;
 130 #endif
 131     }
 132
 133     if (strncmp (uri, "tcp:", 4) == 0)
 134     {
 135         *host = uri + 4;
 136         *proto = PROTO_Z3950;
 137     }
 138     else if (strncmp (uri, "ssl:", 4) == 0)
 139     {
 140 #if ENABLE_SSL
 141         *t = ssl_type;
 142         *host = uri + 4;
 143         *proto = PROTO_Z3950;
 144 #else
 145         return 0;
 146 #endif
 147     }
 148     else if (strncmp(uri, "http:", 5) == 0)
 149     {
 150         *host = uri + 5;
 151         while (**host == '/')
 152             (*host)++;
 153         *proto = PROTO_HTTP;
 154     }
 155     else if (strncmp(uri, "https:", 6) == 0)
 156     {
 157 #if ENABLE_SSL
 158         *t = ssl_type;
 159         *host = uri + 6;
 160         while (**host == '/')
 161             (*host)++;
 162         *proto = PROTO_HTTP;
 163 #else
 164         return 0;
 165 #endif
 166     }
 167     else
 168     {
 169         *host = uri;
 170         *proto = PROTO_Z3950;
 171     }
 172     return 1;
 173 }
 174
 175 COMSTACK cs_create_host(const char *vhost, int blocking, void **vp)
 176 {
 177     return cs_create_host_proxy(vhost, blocking, vp, 0);
 178 }
 179
 180 COMSTACK cs_create_host_proxy(const char *vhost, int blocking, void **vp,
 181                               const char *proxy_host)
 182 {
 183     enum oid_proto proto = PROTO_Z3950;
 184     const char *host = 0;
 185     COMSTACK cs;
 186     CS_TYPE t;
 187     char *connect_host = 0;
 188
 189     if (!cs_parse_host(vhost, &host, &t, &proto, &connect_host))
 190     {
 191         xfree(connect_host);
 192         return 0;
 193     }
 194
 195     if (proxy_host)
 196     {
 197         enum oid_proto proto1;
 198
 199         xfree(connect_host);
 200         if (!cs_parse_host(proxy_host, &host, &t, &proto1, &connect_host))
 201         {
 202             xfree(connect_host);
 203             return 0;
 204         }
 205     }
 206
 207     if (t == tcpip_type)
 208     {
 209         cs = yaz_tcpip_create(-1, blocking, proto, connect_host ? host : 0);
 210     }
 211     else
 212     {
 213         cs = cs_create(t, blocking, proto);
 214     }
 215     if (cs)
 216     {
 217         if (!(*vp = cs_straddr(cs, connect_host ? connect_host : host)))
 218         {
 219             cs_close (cs);
 220             cs = 0;
 221         }
 222     }
 223     xfree(connect_host);
 224     return cs;
 225 }
 226
 227 int cs_look (COMSTACK cs)
 228 {
 229     return cs->event;
 230 }
 231
 232 static int skip_crlf(const char *buf, int len, int *i)
 233 {
 234     if (*i < len)
 235     {
 236         if (buf[*i] == '\r' && *i < len-1 && buf[*i + 1] == '\n')
 237         {
 238             (*i) += 2;
 239             return 1;
 240         }
 241         else if (buf[*i] == '\n')
 242         {
 243             (*i)++;
 244             return 1;
 245         }
 246     }
 247     return 0;
 248 }
 249
 250 #define CHUNK_DEBUG 0
 251
 252 static int cs_read_chunk(const char *buf, int i, int len)
 253 {
 254     /* inside chunked body .. */
 255     while (1)
 256     {
 257         int chunk_len = 0;
 258 #if CHUNK_DEBUG
 259         if (i < len-2)
 260         {
 261             int j;
 262             printf ("\n<<<");
 263             for (j = i; j <= i+3; j++)
 264                 printf ("%c", buf[j]);
 265             printf (">>>\n");
 266         }
 267 #endif
 268         /* read chunk length */
 269         while (1)
 270             if (i >= len-2) {
 271 #if CHUNK_DEBUG
 272                 printf ("returning incomplete read at 1\n");
 273                 printf ("i=%d len=%d\n", i, len);
 274 #endif
 275                 return 0;
 276             } else if (yaz_isdigit(buf[i]))
 277                 chunk_len = chunk_len * 16 +
 278                     (buf[i++] - '0');
 279             else if (yaz_isupper(buf[i]))
 280                 chunk_len = chunk_len * 16 +
 281                     (buf[i++] - ('A'-10));
 282             else if (yaz_islower(buf[i]))
 283                 chunk_len = chunk_len * 16 +
 284                     (buf[i++] - ('a'-10));
 285             else
 286                 break;
 287         if (chunk_len == 0)
 288             break;
 289         if (chunk_len < 0)
 290             return i;
 291
 292         while (1)
 293         {
 294             if (i >= len -1)
 295                 return 0;
 296             if (skip_crlf(buf, len, &i))
 297                 break;
 298             i++;
 299         }
 300         /* got CRLF */
 301 #if CHUNK_DEBUG
 302         printf ("chunk_len=%d\n", chunk_len);
 303 #endif
 304         i += chunk_len;
 305         if (i >= len-2)
 306             return 0;
 307         if (!skip_crlf(buf, len, &i))
 308             return 0;
 309     }
 310     /* consider trailing headers .. */
 311     while (i < len)
 312     {
 313         if (skip_crlf(buf, len, &i))
 314         {
 315             if (skip_crlf(buf, len, &i))
 316                 return i;
 317         }
 318         else
 319             i++;
 320     }
 321 #if CHUNK_DEBUG
 322     printf ("returning incomplete read at 2\n");
 323     printf ("i=%d len=%d\n", i, len);
 324 #endif
 325     return 0;
 326 }
 327
 328 static int cs_complete_http(const char *buf, int len, int head_only)
 329 {
 330     /* deal with HTTP request/response */
 331     int i, content_len = 0, chunked = 0;
 332
 333     /* need at least one line followed by \n or \r .. */
 334     for (i = 0; ; i++)
 335         if (i == len)
 336             return 0; /* incomplete */
 337         else if (buf[i] == '\n' || buf[i] == '\r')
 338             break;
 339
 340     /* check to see if it's a response with content */
 341     if (!head_only && !memcmp(buf, "HTTP/", 5))
 342     {
 343         int j;
 344         for (j = 5; j < i; j++)
 345             if (buf[j] == ' ')
 346             {
 347                 ++j;
 348                 if (buf[j] == '1') /* 1XX */
 349                     ;
 350                 else if (!memcmp(buf + j, "204", 3))
 351                     ;
 352                 else if (!memcmp(buf + j, "304", 3))
 353                     ;
 354                 else
 355                     content_len = -1;
 356                 break;
 357             }
 358     }
 359 #if 0
 360     printf("len = %d\n", len);
 361     fwrite (buf, 1, len, stdout);
 362     printf("----------\n");
 363 #endif
 364     for (i = 2; i <= len-2; )
 365     {
 366         if (i > 8192)
 367         {
 368             return i;  /* do not allow more than 8K HTTP header */
 369         }
 370         if (skip_crlf(buf, len, &i))
 371         {
 372             if (skip_crlf(buf, len, &i))
 373             {
 374                 /* inside content */
 375                 if (chunked)
 376                     return cs_read_chunk(buf, i, len);
 377                 else
 378                 {   /* not chunked ; inside body */
 379                     if (content_len == -1)
 380                         return 0;   /* no content length */
 381                     else if (len >= i + content_len)
 382                     {
 383                         return i + content_len;
 384                     }
 385                 }
 386                 break;
 387             }
 388             else if (i < len - 20 &&
 389                      !yaz_strncasecmp((const char *) buf+i,
 390                                       "Transfer-Encoding:", 18))
 391             {
 392                 i+=18;
 393                 while (buf[i] == ' ')
 394                     i++;
 395                 if (i < len - 8)
 396                     if (!yaz_strncasecmp((const char *) buf+i, "chunked", 7))
 397                         chunked = 1;
 398             }
 399             else if (i < len - 17 &&
 400                      !yaz_strncasecmp((const char *)buf+i,
 401                                       "Content-Length:", 15))
 402             {
 403                 i+= 15;
 404                 while (buf[i] == ' ')
 405                     i++;
 406                 content_len = 0;
 407                 while (i <= len-4 && yaz_isdigit(buf[i]))
 408                     content_len = content_len*10 + (buf[i++] - '0');
 409                 if (content_len < 0) /* prevent negative offsets */
 410                     content_len = 0;
 411             }
 412             else
 413                 i++;
 414         }
 415         else
 416             i++;
 417     }
 418     return 0;
 419 }
 420
 421 static int cs_complete_auto_x(const char *buf, int len, int head_only)
 422 {
 423     if (len > 5 && buf[0] >= 0x20 && buf[0] < 0x7f
 424                 && buf[1] >= 0x20 && buf[1] < 0x7f
 425                 && buf[2] >= 0x20 && buf[2] < 0x7f)
 426     {
 427         int r = cs_complete_http(buf, len, head_only);
 428         return r;
 429     }
 430     return completeBER((const unsigned char *) buf, len);
 431 }
 432
 433
 434 int cs_complete_auto(const char *buf, int len)
 435 {
 436     return cs_complete_auto_x(buf, len, 0);
 437 }
 438
 439 int cs_complete_auto_head(const char *buf, int len)
 440 {
 441     return cs_complete_auto_x(buf, len, 1);
 442 }
 443
 444 void cs_set_max_recv_bytes(COMSTACK cs, int max_recv_bytes)
 445 {
 446     cs->max_recv_bytes = max_recv_bytes;
 447 }
 448
 449 /*
 450  * Local variables:
 451  * c-basic-offset: 4
 452  * c-file-style: "Stroustrup"
 453  * indent-tabs-mode: nil
 454  * End:
 455  * vim: shiftwidth=4 tabstop=8 expandtab
 456  */
 457