src/http.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 http.c
   7  * \brief Implements HTTP decoding
   8  */
   9 #if HAVE_CONFIG_H
  10 #include <config.h>
  11 #endif
  12
  13 #include <yaz/odr.h>
  14 #include <yaz/yaz-version.h>
  15 #include <yaz/yaz-iconv.h>
  16 #include <yaz/matchstr.h>
  17 #include <yaz/zgdu.h>
  18 #include <yaz/base64.h>
  19
  20 static int decode_headers_content(ODR o, int off, Z_HTTP_Header **headers,
  21                                   char **content_buf, int *content_len)
  22 {
  23     int i = off;
  24     int chunked = 0;
  25
  26     *headers = 0;
  27     while (i < o->size-1 && o->buf[i] == '\n')
  28     {
  29         int po;
  30         i++;
  31         if (o->buf[i] == '\r' && i < o->size-1 && o->buf[i+1] == '\n')
  32         {
  33             i++;
  34             break;
  35         }
  36         if (o->buf[i] == '\n')
  37             break;
  38         for (po = i; ; i++)
  39         {
  40             if (i == o->size)
  41             {
  42                 o->error = OHTTP;
  43                 return 0;
  44             }
  45             else if (o->buf[i] == ':')
  46                 break;
  47         }
  48         *headers = (Z_HTTP_Header *) odr_malloc(o, sizeof(**headers));
  49         (*headers)->name = (char*) odr_malloc(o, i - po + 1);
  50         memcpy ((*headers)->name, o->buf + po, i - po);
  51         (*headers)->name[i - po] = '\0';
  52         i++;
  53         while (i < o->size-1 && o->buf[i] == ' ')
  54             i++;
  55         for (po = i; i < o->size-1 && !strchr("\r\n", o->buf[i]); i++)
  56             ;
  57
  58         (*headers)->value = (char*) odr_malloc(o, i - po + 1);
  59         memcpy ((*headers)->value, o->buf + po, i - po);
  60         (*headers)->value[i - po] = '\0';
  61
  62         if (!yaz_strcasecmp((*headers)->name, "Transfer-Encoding")
  63             &&
  64             !yaz_strcasecmp((*headers)->value, "chunked"))
  65             chunked = 1;
  66         headers = &(*headers)->next;
  67         if (i < o->size-1 && o->buf[i] == '\r')
  68             i++;
  69     }
  70     *headers = 0;
  71     if (o->buf[i] != '\n')
  72     {
  73         o->error = OHTTP;
  74         return 0;
  75     }
  76     i++;
  77
  78     if (chunked)
  79     {
  80         int off = 0;
  81
  82         /* we know buffer will be smaller than o->size - i*/
  83         *content_buf = (char*) odr_malloc(o, o->size - i);
  84
  85         while (1)
  86         {
  87             /* chunk length .. */
  88             int chunk_len = 0;
  89             for (; i  < o->size-2; i++)
  90                 if (yaz_isdigit(o->buf[i]))
  91                     chunk_len = chunk_len * 16 +
  92                         (o->buf[i] - '0');
  93                 else if (yaz_isupper(o->buf[i]))
  94                     chunk_len = chunk_len * 16 +
  95                         (o->buf[i] - ('A'-10));
  96                 else if (yaz_islower(o->buf[i]))
  97                     chunk_len = chunk_len * 16 +
  98                         (o->buf[i] - ('a'-10));
  99                 else
 100                     break;
 101             /* chunk extension ... */
 102             while (o->buf[i] != '\r' && o->buf[i+1] != '\n')
 103             {
 104                 if (i >= o->size-2)
 105                 {
 106                     o->error = OHTTP;
 107                     return 0;
 108                 }
 109                 i++;
 110             }
 111             i += 2;  /* skip CRLF */
 112             if (chunk_len == 0)
 113                 break;
 114             if (chunk_len < 0 || off + chunk_len > o->size)
 115             {
 116                 o->error = OHTTP;
 117                 return 0;
 118             }
 119             /* copy chunk .. */
 120             memcpy (*content_buf + off, o->buf + i, chunk_len);
 121             i += chunk_len + 2; /* skip chunk+CRLF */
 122             off += chunk_len;
 123         }
 124         if (!off)
 125             *content_buf = 0;
 126         *content_len = off;
 127     }
 128     else
 129     {
 130         if (i > o->size)
 131         {
 132             o->error = OHTTP;
 133             return 0;
 134         }
 135         else if (i == o->size)
 136         {
 137             *content_buf = 0;
 138             *content_len = 0;
 139         }
 140         else
 141         {
 142             *content_len = o->size - i;
 143             *content_buf = (char*) odr_malloc(o, *content_len + 1);
 144             memcpy(*content_buf, o->buf + i, *content_len);
 145             (*content_buf)[*content_len] = '\0';
 146         }
 147     }
 148     return 1;
 149 }
 150
 151 void z_HTTP_header_add_content_type(ODR o, Z_HTTP_Header **hp,
 152                                     const char *content_type,
 153                                     const char *charset)
 154 {
 155     const char *l = "Content-Type";
 156     if (charset)
 157     {
 158         char *ctype = (char *)
 159             odr_malloc(o, strlen(content_type)+strlen(charset) + 15);
 160         sprintf(ctype, "%s; charset=%s", content_type, charset);
 161         z_HTTP_header_add(o, hp, l, ctype);
 162     }
 163     else
 164         z_HTTP_header_add(o, hp, l, content_type);
 165
 166 }
 167
 168 /*
 169  * HTTP Basic authentication is described at:
 170  * http://tools.ietf.org/html/rfc1945#section-11.1
 171  */
 172 void z_HTTP_header_add_basic_auth(ODR o, Z_HTTP_Header **hp,
 173                                   const char *username, const char *password)
 174 {
 175     char *tmp, *buf;
 176     int len;
 177
 178     if (username == 0)
 179         return;
 180     if (password == 0)
 181         password = "";
 182
 183     len = strlen(username) + strlen(password);
 184     tmp = (char *) odr_malloc(o, len+2);
 185     sprintf(tmp, "%s:%s", username, password);
 186     buf = (char *) odr_malloc(o, (len+1) * 8/6 + 12);
 187     strcpy(buf, "Basic ");
 188     yaz_base64encode(tmp, &buf[strlen(buf)]);
 189     z_HTTP_header_set(o, hp, "Authorization", buf);
 190 }
 191
 192
 193 void z_HTTP_header_add(ODR o, Z_HTTP_Header **hp, const char *n,
 194                        const char *v)
 195 {
 196     while (*hp)
 197         hp = &(*hp)->next;
 198     *hp = (Z_HTTP_Header *) odr_malloc(o, sizeof(**hp));
 199     (*hp)->name = odr_strdup(o, n);
 200     (*hp)->value = odr_strdup(o, v);
 201     (*hp)->next = 0;
 202 }
 203
 204 void z_HTTP_header_set(ODR o, Z_HTTP_Header **hp, const char *n,
 205                        const char *v)
 206 {
 207     while (*hp)
 208     {
 209         if (!yaz_strcasecmp((*hp)->name, n))
 210         {
 211             (*hp)->value = odr_strdup(o, v);
 212             return;
 213         }
 214         hp = &(*hp)->next;
 215     }
 216     *hp = (Z_HTTP_Header *) odr_malloc(o, sizeof(**hp));
 217     (*hp)->name = odr_strdup(o, n);
 218     (*hp)->value = odr_strdup(o, v);
 219     (*hp)->next = 0;
 220 }
 221
 222 const char *z_HTTP_header_remove(Z_HTTP_Header **hp, const char *n)
 223 {
 224     while (*hp)
 225     {
 226         if (!yaz_strcasecmp((*hp)->name, n))
 227         {
 228             const char *v = (*hp)->value;
 229             *hp = (*hp)->next;
 230             return v;
 231         }
 232         hp = &(*hp)->next;
 233     }
 234     return 0;
 235 }
 236
 237 const char *z_HTTP_header_lookup(const Z_HTTP_Header *hp, const char *n)
 238 {
 239     for (; hp; hp = hp->next)
 240         if (!yaz_strcasecmp(hp->name, n))
 241             return hp->value;
 242     return 0;
 243 }
 244
 245
 246 Z_GDU *z_get_HTTP_Request(ODR o)
 247 {
 248     Z_GDU *p = (Z_GDU *) odr_malloc(o, sizeof(*p));
 249     Z_HTTP_Request *hreq;
 250
 251     p->which = Z_GDU_HTTP_Request;
 252     p->u.HTTP_Request = (Z_HTTP_Request *) odr_malloc(o, sizeof(*hreq));
 253     hreq = p->u.HTTP_Request;
 254     hreq->headers = 0;
 255     hreq->content_len = 0;
 256     hreq->content_buf = 0;
 257     hreq->version = "1.1";
 258     hreq->method = "POST";
 259     hreq->path = "/";
 260     z_HTTP_header_add(o, &hreq->headers, "User-Agent", "YAZ/" YAZ_VERSION);
 261     return p;
 262 }
 263
 264
 265 Z_GDU *z_get_HTTP_Request_host_path(ODR odr,
 266                                     const char *host,
 267                                     const char *path)
 268 {
 269     Z_GDU *p = z_get_HTTP_Request(odr);
 270
 271     p->u.HTTP_Request->path = odr_strdup(odr, path);
 272
 273     if (host)
 274     {
 275         const char *cp0 = strstr(host, "://");
 276         const char *cp1 = 0;
 277         if (cp0)
 278             cp0 = cp0+3;
 279         else
 280             cp0 = host;
 281
 282         cp1 = strchr(cp0, '/');
 283         if (!cp1)
 284             cp1 = cp0+strlen(cp0);
 285
 286         if (cp0 && cp1)
 287         {
 288             char *h = (char*) odr_malloc(odr, cp1 - cp0 + 1);
 289             memcpy (h, cp0, cp1 - cp0);
 290             h[cp1-cp0] = '\0';
 291             z_HTTP_header_add(odr, &p->u.HTTP_Request->headers,
 292                               "Host", h);
 293         }
 294     }
 295     return p;
 296 }
 297
 298 Z_GDU *z_get_HTTP_Request_uri(ODR odr, const char *uri, const char *args,
 299                               int use_full_uri)
 300 {
 301     Z_GDU *p = z_get_HTTP_Request(odr);
 302     const char *cp0 = strstr(uri, "://");
 303     const char *cp1 = 0;
 304     if (cp0)
 305         cp0 = cp0+3;
 306     else
 307         cp0 = uri;
 308
 309     cp1 = strchr(cp0, '/');
 310     if (!cp1)
 311         cp1 = cp0+strlen(cp0);
 312
 313     if (cp0 && cp1)
 314     {
 315         char *h = (char*) odr_malloc(odr, cp1 - cp0 + 1);
 316         memcpy (h, cp0, cp1 - cp0);
 317         h[cp1-cp0] = '\0';
 318         z_HTTP_header_add(odr, &p->u.HTTP_Request->headers,
 319                           "Host", h);
 320     }
 321
 322     if (!args)
 323     {
 324         if (*cp1)
 325             args = cp1 + 1;
 326         else
 327             args = "";
 328     }
 329     p->u.HTTP_Request->path = odr_malloc(odr, cp1 - uri + strlen(args) + 2);
 330     if (use_full_uri)
 331     {
 332         memcpy(p->u.HTTP_Request->path, uri, cp1 - uri);
 333         strcpy(p->u.HTTP_Request->path + (cp1 - uri), "/");
 334     }
 335     else
 336         strcpy(p->u.HTTP_Request->path, "/");
 337     strcat(p->u.HTTP_Request->path, args);
 338     return p;
 339 }
 340
 341 Z_GDU *z_get_HTTP_Response_details(ODR o, int code, const char *details)
 342 {
 343     Z_GDU *p = (Z_GDU *) odr_malloc(o, sizeof(*p));
 344     Z_HTTP_Response *hres;
 345
 346     p->which = Z_GDU_HTTP_Response;
 347     p->u.HTTP_Response = (Z_HTTP_Response *) odr_malloc(o, sizeof(*hres));
 348     hres = p->u.HTTP_Response;
 349     hres->headers = 0;
 350     hres->content_len = 0;
 351     hres->content_buf = 0;
 352     hres->code = code;
 353     hres->version = "1.1";
 354     z_HTTP_header_add(o, &hres->headers, "Server",
 355                       "YAZ/" YAZ_VERSION);
 356     if (code != 200)
 357     {
 358         const char *http_err = z_HTTP_errmsg(code);
 359         size_t sz = 400 + strlen(http_err) + (details ?
 360                                               strlen(details) : 0);
 361         hres->content_buf = (char*) odr_malloc(o, sz);
 362         sprintf(hres->content_buf,
 363                 "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01//EN\""
 364                 " \"http://www.w3.org/TR/html4/strict.dtd\">\n"
 365                 "<HTML>\n"
 366                 " <HEAD>\n"
 367                 "  <TITLE>YAZ " YAZ_VERSION "</TITLE>\n"
 368                 " </HEAD>\n"
 369                 " <BODY>\n"
 370                 "  <P><A HREF=\"http://www.indexdata.com/yaz/\">YAZ</A> "
 371                 YAZ_VERSION "</P>\n"
 372                 "  <P>Error: %d</P>\n"
 373                 "  <P>Description: %s</P>\n", code, http_err);
 374         if (details)
 375         {
 376             sprintf(hres->content_buf + strlen(hres->content_buf),
 377                     "<P>Details: %s</P>\n", details);
 378         }
 379         sprintf(hres->content_buf + strlen(hres->content_buf),
 380                 " </BODY>\n"
 381                 "</HTML>\n");
 382         hres->content_len = strlen(hres->content_buf);
 383         z_HTTP_header_add(o, &hres->headers, "Content-Type", "text/html");
 384     }
 385     return p;
 386 }
 387
 388 Z_GDU *z_get_HTTP_Response(ODR o, int code)
 389 {
 390     return z_get_HTTP_Response_details(o, code, 0);
 391 }
 392
 393 const char *z_HTTP_errmsg(int code)
 394 {
 395     switch (code)
 396     {
 397     case 100:
 398         return "Continue";
 399     case 101:
 400         return "Switching Protocols";
 401     case 200:
 402         return "OK";
 403     case 201:
 404         return "Created";
 405     case 202:
 406         return "Accepted";
 407     case 203:
 408         return "Non-Authoritative Information";
 409     case 204:
 410         return "No Content";
 411     case 205:
 412         return "Reset Content";
 413     case 206:
 414         return "Partial Content";
 415     case 300:
 416         return "Multiple Choices";
 417     case 301:
 418         return "Moved Permenently";
 419     case 302:
 420         return "Found";
 421     case 303:
 422         return "See Other";
 423     case 304:
 424         return "Not Modified";
 425     case 305:
 426         return "Use Proxy";
 427     case 307:
 428         return "Temporary Redirect";
 429     case 400:
 430         return "Bad Request";
 431     case 404:
 432         return "Not Found";
 433     case 405:
 434         return "Method Not Allowed";
 435     case 406:
 436         return "Not Acceptable";
 437     case 407:
 438         return "Proxy Authentication Required";
 439     case 408:
 440         return "Request Timeout";
 441     case 409:
 442         return "Conflict";
 443     case 410:
 444         return "Gone";
 445     case 411:
 446         return "Length Required";
 447     case 412:
 448         return "Precondition Failed";
 449     case 413:
 450         return "Request Entity Too Large";
 451     case 414:
 452         return "Request-URI Too Long";
 453     case 415:
 454         return "Unsupported Media Type";
 455     case 416:
 456         return "Requested Range Not Satisfiable";
 457     case 417:
 458         return "Expectation Failed";
 459     case 500:
 460         return "Internal Error";
 461     case 501:
 462         return "Not Implemented";
 463     case 502:
 464         return "Bad Gateway";
 465     case 503:
 466         return "Service Unavailable";
 467     case 504:
 468         return "Gateway Timeout";
 469     case 505:
 470         return "HTTP Version Not Supported";
 471     default:
 472         return "Unknown Error";
 473     }
 474 }
 475
 476 int yaz_decode_http_response(ODR o, Z_HTTP_Response **hr_p)
 477 {
 478     int i, po;
 479     Z_HTTP_Response *hr = (Z_HTTP_Response *) odr_malloc(o, sizeof(*hr));
 480
 481     *hr_p = hr;
 482     hr->content_buf = 0;
 483     hr->content_len = 0;
 484
 485     po = i = 5;
 486     while (i < o->size-2 && !strchr(" \r\n", o->buf[i]))
 487         i++;
 488     hr->version = (char *) odr_malloc(o, i - po + 1);
 489     if (i - po)
 490         memcpy(hr->version, o->buf + po, i - po);
 491     hr->version[i-po] = 0;
 492     if (o->buf[i] != ' ')
 493     {
 494         o->error = OHTTP;
 495         return 0;
 496     }
 497     i++;
 498     hr->code = 0;
 499     while (i < o->size-2 && o->buf[i] >= '0' && o->buf[i] <= '9')
 500     {
 501         hr->code = hr->code*10 + (o->buf[i] - '0');
 502         i++;
 503     }
 504     while (i < o->size-1 && o->buf[i] != '\n')
 505         i++;
 506     return decode_headers_content(o, i, &hr->headers,
 507                                   &hr->content_buf, &hr->content_len);
 508 }
 509
 510 int yaz_decode_http_request(ODR o, Z_HTTP_Request **hr_p)
 511 {
 512     int i, po;
 513     Z_HTTP_Request *hr = (Z_HTTP_Request *) odr_malloc(o, sizeof(*hr));
 514
 515     *hr_p = hr;
 516
 517     /* method .. */
 518     for (i = 0; o->buf[i] != ' '; i++)
 519         if (i >= o->size-5 || i > 30)
 520         {
 521             o->error = OHTTP;
 522             return 0;
 523         }
 524     hr->method = (char *) odr_malloc(o, i+1);
 525     memcpy (hr->method, o->buf, i);
 526     hr->method[i] = '\0';
 527     /* path */
 528     po = i+1;
 529     for (i = po; o->buf[i] != ' '; i++)
 530         if (i >= o->size-5)
 531         {
 532             o->error = OHTTP;
 533             return 0;
 534         }
 535     hr->path = (char *) odr_malloc(o, i - po + 1);
 536     memcpy (hr->path, o->buf+po, i - po);
 537     hr->path[i - po] = '\0';
 538     /* HTTP version */
 539     i++;
 540     if (i > o->size-5 || memcmp(o->buf+i, "HTTP/", 5))
 541     {
 542         o->error = OHTTP;
 543         return 0;
 544     }
 545     i+= 5;
 546     po = i;
 547     while (i < o->size && !strchr("\r\n", o->buf[i]))
 548         i++;
 549     hr->version = (char *) odr_malloc(o, i - po + 1);
 550     memcpy(hr->version, o->buf + po, i - po);
 551     hr->version[i - po] = '\0';
 552     /* headers */
 553     if (i < o->size-1 && o->buf[i] == '\r')
 554         i++;
 555     if (o->buf[i] != '\n')
 556     {
 557         o->error = OHTTP;
 558         return 0;
 559     }
 560     return decode_headers_content(o, i, &hr->headers,
 561                                   &hr->content_buf, &hr->content_len);
 562 }
 563
 564 static void dump_http_package(ODR o, const char *buf, size_t len)
 565 {
 566     int i;
 567     for (i = 0; ; i++)
 568     {
 569         if (i == len)
 570         {
 571             odr_printf(o, "%.*s\n", i, buf);
 572             break;
 573         }
 574         else if (i > 8192)
 575         {
 576             odr_printf(o, "%.*s\n", i, buf);
 577             odr_printf(o, "(truncated\n", (long) len);
 578             break;
 579         }
 580         else if (buf[i] == 0)
 581         {
 582             odr_printf(o, "%.*s\n", i, buf);
 583             odr_printf(o, "(binary data)\n", (long) len);
 584             break;
 585         }
 586     }
 587 }
 588
 589 int yaz_encode_http_response(ODR o, Z_HTTP_Response *hr)
 590 {
 591     char sbuf[80];
 592     Z_HTTP_Header *h;
 593     int top0 = o->top;
 594
 595     sprintf(sbuf, "HTTP/%s %d %s\r\n", hr->version,
 596             hr->code,
 597             z_HTTP_errmsg(hr->code));
 598     odr_write(o, sbuf, strlen(sbuf));
 599     /* use content_len for Content-Length */
 600     sprintf(sbuf, "Content-Length: %d\r\n", hr->content_len);
 601     odr_write(o, sbuf, strlen(sbuf));
 602     for (h = hr->headers; h; h = h->next)
 603     {
 604         if (yaz_strcasecmp(h->name, "Content-Length")
 605             && yaz_strcasecmp(h->name, "Transfer-Encoding"))
 606         {   /* skip Content-Length if given. content_len rules */
 607             odr_write(o, h->name, strlen(h->name));
 608             odr_write(o, ": ", 2);
 609             odr_write(o, h->value, strlen(h->value));
 610             odr_write(o, "\r\n", 2);
 611         }
 612     }
 613     odr_write(o, "\r\n", 2);
 614     if (hr->content_buf)
 615         odr_write(o, hr->content_buf, hr->content_len);
 616     if (o->direction == ODR_PRINT)
 617     {
 618         odr_printf(o, "-- HTTP response:\n");
 619         dump_http_package(o, (const char *) o->buf + top0, o->top - top0);
 620         odr_printf(o, "--\n");
 621     }
 622     return 1;
 623 }
 624
 625 int yaz_encode_http_request(ODR o, Z_HTTP_Request *hr)
 626 {
 627     Z_HTTP_Header *h;
 628     int top0 = o->top;
 629
 630     odr_write(o, hr->method, strlen(hr->method));
 631     odr_write(o, " ", 1);
 632     odr_write(o, hr->path, strlen(hr->path));
 633     odr_write(o, " HTTP/", 6);
 634     odr_write(o, hr->version, strlen(hr->version));
 635     odr_write(o, "\r\n", 2);
 636     if (hr->content_len &&
 637         !z_HTTP_header_lookup(hr->headers,
 638                               "Content-Length"))
 639     {
 640         char lstr[60];
 641         sprintf(lstr, "Content-Length: %d\r\n",
 642                 hr->content_len);
 643         odr_write(o, lstr, strlen(lstr));
 644     }
 645     for (h = hr->headers; h; h = h->next)
 646     {
 647         odr_write(o, h->name, strlen(h->name));
 648         odr_write(o, ": ", 2);
 649         odr_write(o, h->value, strlen(h->value));
 650         odr_write(o, "\r\n", 2);
 651     }
 652     odr_write(o, "\r\n", 2);
 653     if (hr->content_buf)
 654         odr_write(o, hr->content_buf, hr->content_len);
 655     if (o->direction == ODR_PRINT)
 656     {
 657         odr_printf(o, "-- HTTP request:\n");
 658         dump_http_package(o, (const char *) o->buf + top0, o->top - top0);
 659         odr_printf(o, "--\n");
 660     }
 661     return 1;
 662 }
 663
 664 /*
 665  * Local variables:
 666  * c-basic-offset: 4
 667  * c-file-style: "Stroustrup"
 668  * indent-tabs-mode: nil
 669  * End:
 670  * vim: shiftwidth=4 tabstop=8 expandtab
 671  */
 672