nanohttp.c

   1 /*
   2  * nanohttp.c: minimalist HTTP GET implementation to fetch external subsets.
   3  *             focuses on size, streamability, reentrancy and portability
   4  *
   5  * This is clearly not a general purpose HTTP implementation
   6  * If you look for one, check:
   7  *         http://www.w3.org/Library/
   8  *
   9  * See Copyright for the status of this software.
  10  *
  11  * daniel@veillard.com
  12  */
  13
  14 #define IN_LIBXML
  15 #include "libxml.h"
  16
  17 #ifdef LIBXML_HTTP_ENABLED
  18 #include <string.h>
  19
  20 #ifdef HAVE_STDLIB_H
  21 #include <stdlib.h>
  22 #endif
  23 #ifdef HAVE_UNISTD_H
  24 #include <unistd.h>
  25 #endif
  26 #ifdef HAVE_SYS_TYPES_H
  27 #include <sys/types.h>
  28 #endif
  29 #ifdef HAVE_SYS_SOCKET_H
  30 #include <sys/socket.h>
  31 #endif
  32 #ifdef HAVE_NETINET_IN_H
  33 #include <netinet/in.h>
  34 #endif
  35 #ifdef HAVE_ARPA_INET_H
  36 #include <arpa/inet.h>
  37 #endif
  38 #ifdef HAVE_NETDB_H
  39 #include <netdb.h>
  40 #endif
  41 #ifdef HAVE_RESOLV_H
  42 #ifdef HAVE_ARPA_NAMESER_H
  43 #include <arpa/nameser.h>
  44 #endif
  45 #include <resolv.h>
  46 #endif
  47 #ifdef HAVE_FCNTL_H
  48 #include <fcntl.h>
  49 #endif
  50 #ifdef HAVE_ERRNO_H
  51 #include <errno.h>
  52 #endif
  53 #ifdef HAVE_SYS_TIME_H
  54 #include <sys/time.h>
  55 #endif
  56 #ifndef HAVE_POLL_H
  57 #ifdef HAVE_SYS_SELECT_H
  58 #include <sys/select.h>
  59 #endif
  60 #else
  61 #include <poll.h>
  62 #endif
  63 #ifdef HAVE_STRINGS_H
  64 #include <strings.h>
  65 #endif
  66 #ifdef HAVE_ZLIB_H
  67 #include <zlib.h>
  68 #endif
  69
  70
  71 #ifdef VMS
  72 #include <stropts>
  73 #define XML_SOCKLEN_T unsigned int
  74 #endif
  75
  76 #if defined(_WIN32) && !defined(__CYGWIN__)
  77 #include <wsockcompat.h>
  78 #endif
  79
  80 #include <libxml/globals.h>
  81 #include <libxml/xmlerror.h>
  82 #include <libxml/xmlmemory.h>
  83 #include <libxml/parser.h> /* for xmlStr(n)casecmp() */
  84 #include <libxml/nanohttp.h>
  85 #include <libxml/globals.h>
  86 #include <libxml/uri.h>
  87
  88 /**
  89  * A couple portability macros
  90  */
  91 #ifndef _WINSOCKAPI_
  92 #if !defined(__BEOS__) || defined(__HAIKU__)
  93 #define closesocket(s) close(s)
  94 #endif
  95 #define SOCKET int
  96 #define INVALID_SOCKET (-1)
  97 #endif
  98
  99 #ifdef __BEOS__
 100 #ifndef PF_INET
 101 #define PF_INET AF_INET
 102 #endif
 103 #endif
 104
 105 #ifndef XML_SOCKLEN_T
 106 #define XML_SOCKLEN_T unsigned int
 107 #endif
 108
 109 #ifdef STANDALONE
 110 #define DEBUG_HTTP
 111 #define xmlStrncasecmp(a, b, n) strncasecmp((char *)a, (char *)b, n)
 112 #define xmlStrcasecmpi(a, b) strcasecmp((char *)a, (char *)b)
 113 #endif
 114
 115 #define XML_NANO_HTTP_MAX_REDIR 10
 116
 117 #define XML_NANO_HTTP_CHUNK     4096
 118
 119 #define XML_NANO_HTTP_CLOSED    0
 120 #define XML_NANO_HTTP_WRITE     1
 121 #define XML_NANO_HTTP_READ      2
 122 #define XML_NANO_HTTP_NONE      4
 123
 124 typedef struct xmlNanoHTTPCtxt {
 125     char *protocol;     /* the protocol name */
 126     char *hostname;     /* the host name */
 127     int port;           /* the port */
 128     char *path;         /* the path within the URL */
 129     char *query;        /* the query string */
 130     SOCKET fd;          /* the file descriptor for the socket */
 131     int state;          /* WRITE / READ / CLOSED */
 132     char *out;          /* buffer sent (zero terminated) */
 133     char *outptr;       /* index within the buffer sent */
 134     char *in;           /* the receiving buffer */
 135     char *content;      /* the start of the content */
 136     char *inptr;        /* the next byte to read from network */
 137     char *inrptr;       /* the next byte to give back to the client */
 138     int inlen;          /* len of the input buffer */
 139     int last;           /* return code for last operation */
 140     int returnValue;    /* the protocol return value */
 141     int version;        /* the protocol version */
 142     int ContentLength;  /* specified content length from HTTP header */
 143     char *contentType;  /* the MIME type for the input */
 144     char *location;     /* the new URL in case of redirect */
 145     char *authHeader;   /* contents of {WWW,Proxy}-Authenticate header */
 146     char *encoding;     /* encoding extracted from the contentType */
 147     char *mimeType;     /* Mime-Type extracted from the contentType */
 148 #ifdef HAVE_ZLIB_H
 149     z_stream *strm;     /* Zlib stream object */
 150     int usesGzip;       /* "Content-Encoding: gzip" was detected */
 151 #endif
 152 } xmlNanoHTTPCtxt, *xmlNanoHTTPCtxtPtr;
 153
 154 static int initialized = 0;
 155 static char *proxy = NULL;       /* the proxy name if any */
 156 static int proxyPort;   /* the proxy port if any */
 157 static unsigned int timeout = 60;/* the select() timeout in seconds */
 158
 159 static int xmlNanoHTTPFetchContent( void * ctx, char ** ptr, int * len );
 160
 161 /**
 162  * xmlHTTPErrMemory:
 163  * @extra:  extra informations
 164  *
 165  * Handle an out of memory condition
 166  */
 167 static void
 168 xmlHTTPErrMemory(const char *extra)
 169 {
 170     __xmlSimpleError(XML_FROM_HTTP, XML_ERR_NO_MEMORY, NULL, NULL, extra);
 171 }
 172
 173 /**
 174  * A portability function
 175  */
 176 static int socket_errno(void) {
 177 #ifdef _WINSOCKAPI_
 178     int err = WSAGetLastError();
 179     switch(err) {
 180         case WSAECONNRESET:
 181             return(ECONNRESET);
 182         case WSAEINPROGRESS:
 183             return(EINPROGRESS);
 184         case WSAEINTR:
 185             return(EINTR);
 186         case WSAESHUTDOWN:
 187             return(ESHUTDOWN);
 188         case WSAEWOULDBLOCK:
 189             return(EWOULDBLOCK);
 190         default:
 191             return(err);
 192     }
 193 #else
 194     return(errno);
 195 #endif
 196 }
 197
 198 #ifdef SUPPORT_IP6
 199 static
 200 int have_ipv6(void) {
 201     SOCKET s;
 202
 203     s = socket (AF_INET6, SOCK_STREAM, 0);
 204     if (s != INVALID_SOCKET) {
 205         close (s);
 206         return (1);
 207     }
 208     return (0);
 209 }
 210 #endif
 211
 212 /**
 213  * xmlNanoHTTPInit:
 214  *
 215  * Initialize the HTTP protocol layer.
 216  * Currently it just checks for proxy informations
 217  */
 218
 219 void
 220 xmlNanoHTTPInit(void) {
 221     const char *env;
 222 #ifdef _WINSOCKAPI_
 223     WSADATA wsaData;
 224 #endif
 225
 226     if (initialized)
 227         return;
 228
 229 #ifdef _WINSOCKAPI_
 230     if (WSAStartup(MAKEWORD(1, 1), &wsaData) != 0)
 231         return;
 232 #endif
 233
 234     if (proxy == NULL) {
 235         proxyPort = 80;
 236         env = getenv("no_proxy");
 237         if (env && ((env[0] == '*') && (env[1] == 0)))
 238             goto done;
 239         env = getenv("http_proxy");
 240         if (env != NULL) {
 241             xmlNanoHTTPScanProxy(env);
 242             goto done;
 243         }
 244         env = getenv("HTTP_PROXY");
 245         if (env != NULL) {
 246             xmlNanoHTTPScanProxy(env);
 247             goto done;
 248         }
 249     }
 250 done:
 251     initialized = 1;
 252 }
 253
 254 /**
 255  * xmlNanoHTTPCleanup:
 256  *
 257  * Cleanup the HTTP protocol layer.
 258  */
 259
 260 void
 261 xmlNanoHTTPCleanup(void) {
 262     if (proxy != NULL) {
 263         xmlFree(proxy);
 264         proxy = NULL;
 265     }
 266 #ifdef _WINSOCKAPI_
 267     if (initialized)
 268         WSACleanup();
 269 #endif
 270     initialized = 0;
 271     return;
 272 }
 273
 274 /**
 275  * xmlNanoHTTPScanURL:
 276  * @ctxt:  an HTTP context
 277  * @URL:  The URL used to initialize the context
 278  *
 279  * (Re)Initialize an HTTP context by parsing the URL and finding
 280  * the protocol host port and path it indicates.
 281  */
 282
 283 static void
 284 xmlNanoHTTPScanURL(xmlNanoHTTPCtxtPtr ctxt, const char *URL) {
 285     xmlURIPtr uri;
 286     int len;
 287
 288     /*
 289      * Clear any existing data from the context
 290      */
 291     if (ctxt->protocol != NULL) {
 292         xmlFree(ctxt->protocol);
 293         ctxt->protocol = NULL;
 294     }
 295     if (ctxt->hostname != NULL) {
 296         xmlFree(ctxt->hostname);
 297         ctxt->hostname = NULL;
 298     }
 299     if (ctxt->path != NULL) {
 300         xmlFree(ctxt->path);
 301         ctxt->path = NULL;
 302     }
 303     if (ctxt->query != NULL) {
 304         xmlFree(ctxt->query);
 305         ctxt->query = NULL;
 306     }
 307     if (URL == NULL) return;
 308
 309     uri = xmlParseURIRaw(URL, 1);
 310     if (uri == NULL)
 311         return;
 312
 313     if ((uri->scheme == NULL) || (uri->server == NULL)) {
 314         xmlFreeURI(uri);
 315         return;
 316     }
 317
 318     ctxt->protocol = xmlMemStrdup(uri->scheme);
 319     /* special case of IPv6 addresses, the [] need to be removed */
 320     if ((uri->server != NULL) && (*uri->server == '[')) {
 321         len = strlen(uri->server);
 322         if ((len > 2) && (uri->server[len - 1] == ']')) {
 323             ctxt->hostname = (char *) xmlCharStrndup(uri->server + 1, len -2);
 324         } else
 325             ctxt->hostname = xmlMemStrdup(uri->server);
 326     } else
 327         ctxt->hostname = xmlMemStrdup(uri->server);
 328     if (uri->path != NULL)
 329         ctxt->path = xmlMemStrdup(uri->path);
 330     else
 331         ctxt->path = xmlMemStrdup("/");
 332     if (uri->query != NULL)
 333         ctxt->query = xmlMemStrdup(uri->query);
 334     if (uri->port != 0)
 335         ctxt->port = uri->port;
 336
 337     xmlFreeURI(uri);
 338 }
 339
 340 /**
 341  * xmlNanoHTTPScanProxy:
 342  * @URL:  The proxy URL used to initialize the proxy context
 343  *
 344  * (Re)Initialize the HTTP Proxy context by parsing the URL and finding
 345  * the protocol host port it indicates.
 346  * Should be like http://myproxy/ or http://myproxy:3128/
 347  * A NULL URL cleans up proxy informations.
 348  */
 349
 350 void
 351 xmlNanoHTTPScanProxy(const char *URL) {
 352     xmlURIPtr uri;
 353
 354     if (proxy != NULL) {
 355         xmlFree(proxy);
 356         proxy = NULL;
 357     }
 358     proxyPort = 0;
 359
 360 #ifdef DEBUG_HTTP
 361     if (URL == NULL)
 362         xmlGenericError(xmlGenericErrorContext,
 363                 "Removing HTTP proxy info\n");
 364     else
 365         xmlGenericError(xmlGenericErrorContext,
 366                 "Using HTTP proxy %s\n", URL);
 367 #endif
 368     if (URL == NULL) return;
 369
 370     uri = xmlParseURIRaw(URL, 1);
 371     if ((uri == NULL) || (uri->scheme == NULL) ||
 372         (strcmp(uri->scheme, "http")) || (uri->server == NULL)) {
 373         __xmlIOErr(XML_FROM_HTTP, XML_HTTP_URL_SYNTAX, "Syntax Error\n");
 374         if (uri != NULL)
 375             xmlFreeURI(uri);
 376         return;
 377     }
 378
 379     proxy = xmlMemStrdup(uri->server);
 380     if (uri->port != 0)
 381         proxyPort = uri->port;
 382
 383     xmlFreeURI(uri);
 384 }
 385
 386 /**
 387  * xmlNanoHTTPNewCtxt:
 388  * @URL:  The URL used to initialize the context
 389  *
 390  * Allocate and initialize a new HTTP context.
 391  *
 392  * Returns an HTTP context or NULL in case of error.
 393  */
 394
 395 static xmlNanoHTTPCtxtPtr
 396 xmlNanoHTTPNewCtxt(const char *URL) {
 397     xmlNanoHTTPCtxtPtr ret;
 398
 399     ret = (xmlNanoHTTPCtxtPtr) xmlMalloc(sizeof(xmlNanoHTTPCtxt));
 400     if (ret == NULL) {
 401         xmlHTTPErrMemory("allocating context");
 402         return(NULL);
 403     }
 404
 405     memset(ret, 0, sizeof(xmlNanoHTTPCtxt));
 406     ret->port = 80;
 407     ret->returnValue = 0;
 408     ret->fd = INVALID_SOCKET;
 409     ret->ContentLength = -1;
 410
 411     xmlNanoHTTPScanURL(ret, URL);
 412
 413     return(ret);
 414 }
 415
 416 /**
 417  * xmlNanoHTTPFreeCtxt:
 418  * @ctxt:  an HTTP context
 419  *
 420  * Frees the context after closing the connection.
 421  */
 422
 423 static void
 424 xmlNanoHTTPFreeCtxt(xmlNanoHTTPCtxtPtr ctxt) {
 425     if (ctxt == NULL) return;
 426     if (ctxt->hostname != NULL) xmlFree(ctxt->hostname);
 427     if (ctxt->protocol != NULL) xmlFree(ctxt->protocol);
 428     if (ctxt->path != NULL) xmlFree(ctxt->path);
 429     if (ctxt->query != NULL) xmlFree(ctxt->query);
 430     if (ctxt->out != NULL) xmlFree(ctxt->out);
 431     if (ctxt->in != NULL) xmlFree(ctxt->in);
 432     if (ctxt->contentType != NULL) xmlFree(ctxt->contentType);
 433     if (ctxt->encoding != NULL) xmlFree(ctxt->encoding);
 434     if (ctxt->mimeType != NULL) xmlFree(ctxt->mimeType);
 435     if (ctxt->location != NULL) xmlFree(ctxt->location);
 436     if (ctxt->authHeader != NULL) xmlFree(ctxt->authHeader);
 437 #ifdef HAVE_ZLIB_H
 438     if (ctxt->strm != NULL) {
 439         inflateEnd(ctxt->strm);
 440         xmlFree(ctxt->strm);
 441     }
 442 #endif
 443
 444     ctxt->state = XML_NANO_HTTP_NONE;
 445     if (ctxt->fd != INVALID_SOCKET) closesocket(ctxt->fd);
 446     ctxt->fd = INVALID_SOCKET;
 447     xmlFree(ctxt);
 448 }
 449
 450 /**
 451  * xmlNanoHTTPSend:
 452  * @ctxt:  an HTTP context
 453  *
 454  * Send the input needed to initiate the processing on the server side
 455  * Returns number of bytes sent or -1 on error.
 456  */
 457
 458 static int
 459 xmlNanoHTTPSend(xmlNanoHTTPCtxtPtr ctxt, const char *xmt_ptr, int outlen)
 460 {
 461     int total_sent = 0;
 462 #ifdef HAVE_POLL_H
 463     struct pollfd p;
 464 #else
 465     struct timeval tv;
 466     fd_set wfd;
 467 #endif
 468
 469     if ((ctxt->state & XML_NANO_HTTP_WRITE) && (xmt_ptr != NULL)) {
 470         while (total_sent < outlen) {
 471             int nsent = send(ctxt->fd, SEND_ARG2_CAST (xmt_ptr + total_sent),
 472                              outlen - total_sent, 0);
 473
 474             if (nsent > 0)
 475                 total_sent += nsent;
 476             else if ((nsent == -1) &&
 477 #if defined(EAGAIN) && EAGAIN != EWOULDBLOCK
 478                      (socket_errno() != EAGAIN) &&
 479 #endif
 480                      (socket_errno() != EWOULDBLOCK)) {
 481                 __xmlIOErr(XML_FROM_HTTP, 0, "send failed\n");
 482                 if (total_sent == 0)
 483                     total_sent = -1;
 484                 break;
 485             } else {
 486                 /*
 487                  * No data sent
 488                  * Since non-blocking sockets are used, wait for
 489                  * socket to be writable or default timeout prior
 490                  * to retrying.
 491                  */
 492 #ifndef HAVE_POLL_H
 493 #ifndef _WINSOCKAPI_
 494                 if (ctxt->fd > FD_SETSIZE)
 495                     return -1;
 496 #endif
 497
 498                 tv.tv_sec = timeout;
 499                 tv.tv_usec = 0;
 500                 FD_ZERO(&wfd);
 501 #ifdef _MSC_VER
 502 #pragma warning(push)
 503 #pragma warning(disable: 4018)
 504 #endif
 505                 FD_SET(ctxt->fd, &wfd);
 506 #ifdef _MSC_VER
 507 #pragma warning(pop)
 508 #endif
 509                 (void) select(ctxt->fd + 1, NULL, &wfd, NULL, &tv);
 510 #else
 511                 p.fd = ctxt->fd;
 512                 p.events = POLLOUT;
 513                 (void) poll(&p, 1, timeout * 1000);
 514 #endif /* !HAVE_POLL_H */
 515             }
 516         }
 517     }
 518
 519     return total_sent;
 520 }
 521
 522 /**
 523  * xmlNanoHTTPRecv:
 524  * @ctxt:  an HTTP context
 525  *
 526  * Read information coming from the HTTP connection.
 527  * This is a blocking call (but it blocks in select(), not read()).
 528  *
 529  * Returns the number of byte read or -1 in case of error.
 530  */
 531
 532 static int
 533 xmlNanoHTTPRecv(xmlNanoHTTPCtxtPtr ctxt)
 534 {
 535 #ifdef HAVE_POLL_H
 536     struct pollfd p;
 537 #else
 538     fd_set rfd;
 539     struct timeval tv;
 540 #endif
 541
 542
 543     while (ctxt->state & XML_NANO_HTTP_READ) {
 544         if (ctxt->in == NULL) {
 545             ctxt->in = (char *) xmlMallocAtomic(65000 * sizeof(char));
 546             if (ctxt->in == NULL) {
 547                 xmlHTTPErrMemory("allocating input");
 548                 ctxt->last = -1;
 549                 return (-1);
 550             }
 551             ctxt->inlen = 65000;
 552             ctxt->inptr = ctxt->content = ctxt->inrptr = ctxt->in;
 553         }
 554         if (ctxt->inrptr > ctxt->in + XML_NANO_HTTP_CHUNK) {
 555             int delta = ctxt->inrptr - ctxt->in;
 556             int len = ctxt->inptr - ctxt->inrptr;
 557
 558             memmove(ctxt->in, ctxt->inrptr, len);
 559             ctxt->inrptr -= delta;
 560             ctxt->content -= delta;
 561             ctxt->inptr -= delta;
 562         }
 563         if ((ctxt->in + ctxt->inlen) < (ctxt->inptr + XML_NANO_HTTP_CHUNK)) {
 564             int d_inptr = ctxt->inptr - ctxt->in;
 565             int d_content = ctxt->content - ctxt->in;
 566             int d_inrptr = ctxt->inrptr - ctxt->in;
 567             char *tmp_ptr = ctxt->in;
 568
 569             ctxt->inlen *= 2;
 570             ctxt->in = (char *) xmlRealloc(tmp_ptr, ctxt->inlen);
 571             if (ctxt->in == NULL) {
 572                 xmlHTTPErrMemory("allocating input buffer");
 573                 xmlFree(tmp_ptr);
 574                 ctxt->last = -1;
 575                 return (-1);
 576             }
 577             ctxt->inptr = ctxt->in + d_inptr;
 578             ctxt->content = ctxt->in + d_content;
 579             ctxt->inrptr = ctxt->in + d_inrptr;
 580         }
 581         ctxt->last = recv(ctxt->fd, ctxt->inptr, XML_NANO_HTTP_CHUNK, 0);
 582         if (ctxt->last > 0) {
 583             ctxt->inptr += ctxt->last;
 584             return (ctxt->last);
 585         }
 586         if (ctxt->last == 0) {
 587             return (0);
 588         }
 589         if (ctxt->last == -1) {
 590             switch (socket_errno()) {
 591                 case EINPROGRESS:
 592                 case EWOULDBLOCK:
 593 #if defined(EAGAIN) && EAGAIN != EWOULDBLOCK
 594                 case EAGAIN:
 595 #endif
 596                     break;
 597
 598                 case ECONNRESET:
 599                 case ESHUTDOWN:
 600                     return (0);
 601
 602                 default:
 603                     __xmlIOErr(XML_FROM_HTTP, 0, "recv failed\n");
 604                     return (-1);
 605             }
 606         }
 607 #ifdef HAVE_POLL_H
 608         p.fd = ctxt->fd;
 609         p.events = POLLIN;
 610         if ((poll(&p, 1, timeout * 1000) < 1)
 611 #if defined(EINTR)
 612             && (errno != EINTR)
 613 #endif
 614             )
 615             return (0);
 616 #else /* !HAVE_POLL_H */
 617 #ifndef _WINSOCKAPI_
 618         if (ctxt->fd > FD_SETSIZE)
 619             return 0;
 620 #endif
 621
 622         tv.tv_sec = timeout;
 623         tv.tv_usec = 0;
 624         FD_ZERO(&rfd);
 625
 626 #ifdef _MSC_VER
 627 #pragma warning(push)
 628 #pragma warning(disable: 4018)
 629 #endif
 630
 631         FD_SET(ctxt->fd, &rfd);
 632
 633 #ifdef _MSC_VER
 634 #pragma warning(pop)
 635 #endif
 636
 637         if ((select(ctxt->fd + 1, &rfd, NULL, NULL, &tv) < 1)
 638 #if defined(EINTR)
 639             && (socket_errno() != EINTR)
 640 #endif
 641             )
 642             return (0);
 643 #endif /* !HAVE_POLL_H */
 644     }
 645     return (0);
 646 }
 647
 648 /**
 649  * xmlNanoHTTPReadLine:
 650  * @ctxt:  an HTTP context
 651  *
 652  * Read one line in the HTTP server output, usually for extracting
 653  * the HTTP protocol informations from the answer header.
 654  *
 655  * Returns a newly allocated string with a copy of the line, or NULL
 656  *         which indicate the end of the input.
 657  */
 658
 659 static char *
 660 xmlNanoHTTPReadLine(xmlNanoHTTPCtxtPtr ctxt) {
 661     char buf[4096];
 662     char *bp = buf;
 663     int rc;
 664
 665     while (bp - buf < 4095) {
 666         if (ctxt->inrptr == ctxt->inptr) {
 667             if ( (rc = xmlNanoHTTPRecv(ctxt)) == 0) {
 668                 if (bp == buf)
 669                     return(NULL);
 670                 else
 671                     *bp = 0;
 672                 return(xmlMemStrdup(buf));
 673             }
 674             else if ( rc == -1 ) {
 675                 return ( NULL );
 676             }
 677         }
 678         *bp = *ctxt->inrptr++;
 679         if (*bp == '\n') {
 680             *bp = 0;
 681             return(xmlMemStrdup(buf));
 682         }
 683         if (*bp != '\r')
 684             bp++;
 685     }
 686     buf[4095] = 0;
 687     return(xmlMemStrdup(buf));
 688 }
 689
 690
 691 /**
 692  * xmlNanoHTTPScanAnswer:
 693  * @ctxt:  an HTTP context
 694  * @line:  an HTTP header line
 695  *
 696  * Try to extract useful informations from the server answer.
 697  * We currently parse and process:
 698  *  - The HTTP revision/ return code
 699  *  - The Content-Type, Mime-Type and charset used
 700  *  - The Location for redirect processing.
 701  *
 702  * Returns -1 in case of failure, the file descriptor number otherwise
 703  */
 704
 705 static void
 706 xmlNanoHTTPScanAnswer(xmlNanoHTTPCtxtPtr ctxt, const char *line) {
 707     const char *cur = line;
 708
 709     if (line == NULL) return;
 710
 711     if (!strncmp(line, "HTTP/", 5)) {
 712         int version = 0;
 713         int ret = 0;
 714
 715         cur += 5;
 716         while ((*cur >= '0') && (*cur <= '9')) {
 717             version *= 10;
 718             version += *cur - '0';
 719             cur++;
 720         }
 721         if (*cur == '.') {
 722             cur++;
 723             if ((*cur >= '0') && (*cur <= '9')) {
 724                 version *= 10;
 725                 version += *cur - '0';
 726                 cur++;
 727             }
 728             while ((*cur >= '0') && (*cur <= '9'))
 729                 cur++;
 730         } else
 731             version *= 10;
 732         if ((*cur != ' ') && (*cur != '\t')) return;
 733         while ((*cur == ' ') || (*cur == '\t')) cur++;
 734         if ((*cur < '0') || (*cur > '9')) return;
 735         while ((*cur >= '0') && (*cur <= '9')) {
 736             ret *= 10;
 737             ret += *cur - '0';
 738             cur++;
 739         }
 740         if ((*cur != 0) && (*cur != ' ') && (*cur != '\t')) return;
 741         ctxt->returnValue = ret;
 742         ctxt->version = version;
 743     } else if (!xmlStrncasecmp(BAD_CAST line, BAD_CAST"Content-Type:", 13)) {
 744         const xmlChar *charset, *last, *mime;
 745         cur += 13;
 746         while ((*cur == ' ') || (*cur == '\t')) cur++;
 747         if (ctxt->contentType != NULL)
 748             xmlFree(ctxt->contentType);
 749         ctxt->contentType = xmlMemStrdup(cur);
 750         mime = (const xmlChar *) cur;
 751         last = mime;
 752         while ((*last != 0) && (*last != ' ') && (*last != '\t') &&
 753                (*last != ';') && (*last != ','))
 754             last++;
 755         if (ctxt->mimeType != NULL)
 756             xmlFree(ctxt->mimeType);
 757         ctxt->mimeType = (char *) xmlStrndup(mime, last - mime);
 758         charset = xmlStrstr(BAD_CAST ctxt->contentType, BAD_CAST "charset=");
 759         if (charset != NULL) {
 760             charset += 8;
 761             last = charset;
 762             while ((*last != 0) && (*last != ' ') && (*last != '\t') &&
 763                    (*last != ';') && (*last != ','))
 764                 last++;
 765             if (ctxt->encoding != NULL)
 766                 xmlFree(ctxt->encoding);
 767             ctxt->encoding = (char *) xmlStrndup(charset, last - charset);
 768         }
 769     } else if (!xmlStrncasecmp(BAD_CAST line, BAD_CAST"ContentType:", 12)) {
 770         const xmlChar *charset, *last, *mime;
 771         cur += 12;
 772         if (ctxt->contentType != NULL) return;
 773         while ((*cur == ' ') || (*cur == '\t')) cur++;
 774         ctxt->contentType = xmlMemStrdup(cur);
 775         mime = (const xmlChar *) cur;
 776         last = mime;
 777         while ((*last != 0) && (*last != ' ') && (*last != '\t') &&
 778                (*last != ';') && (*last != ','))
 779             last++;
 780         if (ctxt->mimeType != NULL)
 781             xmlFree(ctxt->mimeType);
 782         ctxt->mimeType = (char *) xmlStrndup(mime, last - mime);
 783         charset = xmlStrstr(BAD_CAST ctxt->contentType, BAD_CAST "charset=");
 784         if (charset != NULL) {
 785             charset += 8;
 786             last = charset;
 787             while ((*last != 0) && (*last != ' ') && (*last != '\t') &&
 788                    (*last != ';') && (*last != ','))
 789                 last++;
 790             if (ctxt->encoding != NULL)
 791                 xmlFree(ctxt->encoding);
 792             ctxt->encoding = (char *) xmlStrndup(charset, last - charset);
 793         }
 794     } else if (!xmlStrncasecmp(BAD_CAST line, BAD_CAST"Location:", 9)) {
 795         cur += 9;
 796         while ((*cur == ' ') || (*cur == '\t')) cur++;
 797         if (ctxt->location != NULL)
 798             xmlFree(ctxt->location);
 799         if (*cur == '/') {
 800             xmlChar *tmp_http = xmlStrdup(BAD_CAST "http://");
 801             xmlChar *tmp_loc =
 802                 xmlStrcat(tmp_http, (const xmlChar *) ctxt->hostname);
 803             ctxt->location =
 804                 (char *) xmlStrcat (tmp_loc, (const xmlChar *) cur);
 805         } else {
 806             ctxt->location = xmlMemStrdup(cur);
 807         }
 808     } else if (!xmlStrncasecmp(BAD_CAST line, BAD_CAST"WWW-Authenticate:", 17)) {
 809         cur += 17;
 810         while ((*cur == ' ') || (*cur == '\t')) cur++;
 811         if (ctxt->authHeader != NULL)
 812             xmlFree(ctxt->authHeader);
 813         ctxt->authHeader = xmlMemStrdup(cur);
 814     } else if (!xmlStrncasecmp(BAD_CAST line, BAD_CAST"Proxy-Authenticate:", 19)) {
 815         cur += 19;
 816         while ((*cur == ' ') || (*cur == '\t')) cur++;
 817         if (ctxt->authHeader != NULL)
 818             xmlFree(ctxt->authHeader);
 819         ctxt->authHeader = xmlMemStrdup(cur);
 820 #ifdef HAVE_ZLIB_H
 821     } else if ( !xmlStrncasecmp( BAD_CAST line, BAD_CAST"Content-Encoding:", 17) ) {
 822         cur += 17;
 823         while ((*cur == ' ') || (*cur == '\t')) cur++;
 824         if ( !xmlStrncasecmp( BAD_CAST cur, BAD_CAST"gzip", 4) ) {
 825             ctxt->usesGzip = 1;
 826
 827             ctxt->strm = xmlMalloc(sizeof(z_stream));
 828
 829             if (ctxt->strm != NULL) {
 830                 ctxt->strm->zalloc = Z_NULL;
 831                 ctxt->strm->zfree = Z_NULL;
 832                 ctxt->strm->opaque = Z_NULL;
 833                 ctxt->strm->avail_in = 0;
 834                 ctxt->strm->next_in = Z_NULL;
 835
 836                 inflateInit2( ctxt->strm, 31 );
 837             }
 838         }
 839 #endif
 840     } else if ( !xmlStrncasecmp( BAD_CAST line, BAD_CAST"Content-Length:", 15) ) {
 841         cur += 15;
 842         ctxt->ContentLength = strtol( cur, NULL, 10 );
 843     }
 844 }
 845
 846 /**
 847  * xmlNanoHTTPConnectAttempt:
 848  * @addr:  a socket address structure
 849  *
 850  * Attempt a connection to the given IP:port endpoint. It forces
 851  * non-blocking semantic on the socket, and allow 60 seconds for
 852  * the host to answer.
 853  *
 854  * Returns -1 in case of failure, the file descriptor number otherwise
 855  */
 856
 857 static SOCKET
 858 xmlNanoHTTPConnectAttempt(struct sockaddr *addr)
 859 {
 860 #ifndef HAVE_POLL_H
 861     fd_set wfd;
 862 #ifdef _WINSOCKAPI_
 863     fd_set xfd;
 864 #endif
 865     struct timeval tv;
 866 #else /* !HAVE_POLL_H */
 867     struct pollfd p;
 868 #endif /* !HAVE_POLL_H */
 869     int status;
 870
 871     int addrlen;
 872
 873     SOCKET s;
 874
 875 #ifdef SUPPORT_IP6
 876     if (addr->sa_family == AF_INET6) {
 877         s = socket(PF_INET6, SOCK_STREAM, IPPROTO_TCP);
 878         addrlen = sizeof(struct sockaddr_in6);
 879     } else
 880 #endif
 881     {
 882         s = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
 883         addrlen = sizeof(struct sockaddr_in);
 884     }
 885     if (s == INVALID_SOCKET) {
 886 #ifdef DEBUG_HTTP
 887         perror("socket");
 888 #endif
 889         __xmlIOErr(XML_FROM_HTTP, 0, "socket failed\n");
 890         return INVALID_SOCKET;
 891     }
 892 #ifdef _WINSOCKAPI_
 893     {
 894         u_long one = 1;
 895
 896         status = ioctlsocket(s, FIONBIO, &one) == SOCKET_ERROR ? -1 : 0;
 897     }
 898 #else /* _WINSOCKAPI_ */
 899 #if defined(VMS)
 900     {
 901         int enable = 1;
 902
 903         status = ioctl(s, FIONBIO, &enable);
 904     }
 905 #else /* VMS */
 906 #if defined(__BEOS__) && !defined(__HAIKU__)
 907     {
 908         bool noblock = true;
 909
 910         status =
 911             setsockopt(s, SOL_SOCKET, SO_NONBLOCK, &noblock,
 912                        sizeof(noblock));
 913     }
 914 #else /* __BEOS__ */
 915     if ((status = fcntl(s, F_GETFL, 0)) != -1) {
 916 #ifdef O_NONBLOCK
 917         status |= O_NONBLOCK;
 918 #else /* O_NONBLOCK */
 919 #ifdef F_NDELAY
 920         status |= F_NDELAY;
 921 #endif /* F_NDELAY */
 922 #endif /* !O_NONBLOCK */
 923         status = fcntl(s, F_SETFL, status);
 924     }
 925     if (status < 0) {
 926 #ifdef DEBUG_HTTP
 927         perror("nonblocking");
 928 #endif
 929         __xmlIOErr(XML_FROM_HTTP, 0, "error setting non-blocking IO\n");
 930         closesocket(s);
 931         return INVALID_SOCKET;
 932     }
 933 #endif /* !__BEOS__ */
 934 #endif /* !VMS */
 935 #endif /* !_WINSOCKAPI_ */
 936
 937     if (connect(s, addr, addrlen) == -1) {
 938         switch (socket_errno()) {
 939             case EINPROGRESS:
 940             case EWOULDBLOCK:
 941                 break;
 942             default:
 943                 __xmlIOErr(XML_FROM_HTTP, 0,
 944                            "error connecting to HTTP server");
 945                 closesocket(s);
 946                 return INVALID_SOCKET;
 947         }
 948     }
 949 #ifndef HAVE_POLL_H
 950     tv.tv_sec = timeout;
 951     tv.tv_usec = 0;
 952
 953 #ifdef _MSC_VER
 954 #pragma warning(push)
 955 #pragma warning(disable: 4018)
 956 #endif
 957 #ifndef _WINSOCKAPI_
 958     if (s > FD_SETSIZE)
 959         return INVALID_SOCKET;
 960 #endif
 961     FD_ZERO(&wfd);
 962     FD_SET(s, &wfd);
 963
 964 #ifdef _WINSOCKAPI_
 965     FD_ZERO(&xfd);
 966     FD_SET(s, &xfd);
 967
 968     switch (select(s + 1, NULL, &wfd, &xfd, &tv))
 969 #else
 970     switch (select(s + 1, NULL, &wfd, NULL, &tv))
 971 #endif
 972 #ifdef _MSC_VER
 973 #pragma warning(pop)
 974 #endif
 975
 976 #else /* !HAVE_POLL_H */
 977     p.fd = s;
 978     p.events = POLLOUT;
 979     switch (poll(&p, 1, timeout * 1000))
 980 #endif /* !HAVE_POLL_H */
 981
 982     {
 983         case 0:
 984             /* Time out */
 985             __xmlIOErr(XML_FROM_HTTP, 0, "Connect attempt timed out");
 986             closesocket(s);
 987             return INVALID_SOCKET;
 988         case -1:
 989             /* Ermm.. ?? */
 990             __xmlIOErr(XML_FROM_HTTP, 0, "Connect failed");
 991             closesocket(s);
 992             return INVALID_SOCKET;
 993     }
 994
 995 #ifndef HAVE_POLL_H
 996     if (FD_ISSET(s, &wfd)
 997 #ifdef _WINSOCKAPI_
 998         || FD_ISSET(s, &xfd)
 999 #endif
1000         )
1001 #else /* !HAVE_POLL_H */
1002     if (p.revents == POLLOUT)
1003 #endif /* !HAVE_POLL_H */
1004     {
1005         XML_SOCKLEN_T len;
1006
1007         len = sizeof(status);
1008 #ifdef SO_ERROR
1009         if (getsockopt(s, SOL_SOCKET, SO_ERROR, (char *) &status, &len) <
1010             0) {
1011             /* Solaris error code */
1012             __xmlIOErr(XML_FROM_HTTP, 0, "getsockopt failed\n");
1013             closesocket(s);
1014             return INVALID_SOCKET;
1015         }
1016 #endif
1017         if (status) {
1018             __xmlIOErr(XML_FROM_HTTP, 0,
1019                        "Error connecting to remote host");
1020             closesocket(s);
1021             errno = status;
1022             return INVALID_SOCKET;
1023         }
1024     } else {
1025         /* pbm */
1026         __xmlIOErr(XML_FROM_HTTP, 0, "select failed\n");
1027         closesocket(s);
1028         return INVALID_SOCKET;
1029     }
1030
1031     return (s);
1032 }
1033
1034 /**
1035  * xmlNanoHTTPConnectHost:
1036  * @host:  the host name
1037  * @port:  the port number
1038  *
1039  * Attempt a connection to the given host:port endpoint. It tries
1040  * the multiple IP provided by the DNS if available.
1041  *
1042  * Returns -1 in case of failure, the file descriptor number otherwise
1043  */
1044
1045 static SOCKET
1046 xmlNanoHTTPConnectHost(const char *host, int port)
1047 {
1048     struct sockaddr *addr = NULL;
1049     struct sockaddr_in sockin;
1050
1051 #ifdef SUPPORT_IP6
1052     struct in6_addr ia6;
1053     struct sockaddr_in6 sockin6;
1054 #endif
1055     SOCKET s;
1056
1057     memset (&sockin, 0, sizeof(sockin));
1058 #ifdef SUPPORT_IP6
1059     memset (&sockin6, 0, sizeof(sockin6));
1060 #endif
1061
1062 #if !defined(HAVE_GETADDRINFO) && defined(SUPPORT_IP6) && defined(RES_USE_INET6)
1063     if (have_ipv6 ())
1064     {
1065         if (!(_res.options & RES_INIT))
1066             res_init();
1067         _res.options |= RES_USE_INET6;
1068     }
1069 #endif
1070
1071 #if defined(HAVE_GETADDRINFO) && defined(SUPPORT_IP6) && !defined(_WIN32)
1072     if (have_ipv6 ())
1073 #endif
1074 #if defined(HAVE_GETADDRINFO) && (defined(SUPPORT_IP6) || defined(_WIN32))
1075     {
1076         int status;
1077         struct addrinfo hints, *res, *result;
1078
1079         result = NULL;
1080         memset (&hints, 0,sizeof(hints));
1081         hints.ai_socktype = SOCK_STREAM;
1082
1083         status = getaddrinfo (host, NULL, &hints, &result);
1084         if (status) {
1085             __xmlIOErr(XML_FROM_HTTP, 0, "getaddrinfo failed\n");
1086             return INVALID_SOCKET;
1087         }
1088
1089         for (res = result; res; res = res->ai_next) {
1090             if (res->ai_family == AF_INET) {
1091                 if ((size_t)res->ai_addrlen > sizeof(sockin)) {
1092                     __xmlIOErr(XML_FROM_HTTP, 0, "address size mismatch\n");
1093                     freeaddrinfo (result);
1094                     return INVALID_SOCKET;
1095                 }
1096                 memcpy (&sockin, res->ai_addr, res->ai_addrlen);
1097                 sockin.sin_port = htons (port);
1098                 addr = (struct sockaddr *)&sockin;
1099 #ifdef SUPPORT_IP6
1100             } else if (have_ipv6 () && (res->ai_family == AF_INET6)) {
1101                 if ((size_t)res->ai_addrlen > sizeof(sockin6)) {
1102                     __xmlIOErr(XML_FROM_HTTP, 0, "address size mismatch\n");
1103                     freeaddrinfo (result);
1104                     return INVALID_SOCKET;
1105                 }
1106                 memcpy (&sockin6, res->ai_addr, res->ai_addrlen);
1107                 sockin6.sin6_port = htons (port);
1108                 addr = (struct sockaddr *)&sockin6;
1109 #endif
1110             } else
1111                 continue;              /* for */
1112
1113             s = xmlNanoHTTPConnectAttempt (addr);
1114             if (s != INVALID_SOCKET) {
1115                 freeaddrinfo (result);
1116                 return (s);
1117             }
1118         }
1119
1120         if (result)
1121             freeaddrinfo (result);
1122     }
1123 #endif
1124 #if defined(HAVE_GETADDRINFO) && defined(SUPPORT_IP6) && !defined(_WIN32)
1125     else
1126 #endif
1127 #if !defined(HAVE_GETADDRINFO) || !defined(_WIN32)
1128     {
1129         struct hostent *h;
1130         struct in_addr ia;
1131         int i;
1132
1133         h = gethostbyname (GETHOSTBYNAME_ARG_CAST host);
1134         if (h == NULL) {
1135
1136 /*
1137  * Okay, I got fed up by the non-portability of this error message
1138  * extraction code. it work on Linux, if it work on your platform
1139  * and one want to enable it, send me the defined(foobar) needed
1140  */
1141 #if defined(HAVE_NETDB_H) && defined(HOST_NOT_FOUND) && defined(__linux__)
1142             const char *h_err_txt = "";
1143
1144             switch (h_errno) {
1145                 case HOST_NOT_FOUND:
1146                     h_err_txt = "Authoritive host not found";
1147                     break;
1148
1149                 case TRY_AGAIN:
1150                     h_err_txt =
1151                         "Non-authoritive host not found or server failure.";
1152                     break;
1153
1154                 case NO_RECOVERY:
1155                     h_err_txt =
1156                         "Non-recoverable errors:  FORMERR, REFUSED, or NOTIMP.";
1157                     break;
1158
1159 #ifdef NO_ADDRESS
1160                 case NO_ADDRESS:
1161                     h_err_txt =
1162                         "Valid name, no data record of requested type.";
1163                     break;
1164 #endif
1165
1166                 default:
1167                     h_err_txt = "No error text defined.";
1168                     break;
1169             }
1170             __xmlIOErr(XML_FROM_HTTP, 0, h_err_txt);
1171 #else
1172             __xmlIOErr(XML_FROM_HTTP, 0, "Failed to resolve host");
1173 #endif
1174             return INVALID_SOCKET;
1175         }
1176
1177         for (i = 0; h->h_addr_list[i]; i++) {
1178             if (h->h_addrtype == AF_INET) {
1179                 /* A records (IPv4) */
1180                 if ((unsigned int) h->h_length > sizeof(ia)) {
1181                     __xmlIOErr(XML_FROM_HTTP, 0, "address size mismatch\n");
1182                     return INVALID_SOCKET;
1183                 }
1184                 memcpy (&ia, h->h_addr_list[i], h->h_length);
1185                 sockin.sin_family = h->h_addrtype;
1186                 sockin.sin_addr = ia;
1187                 sockin.sin_port = (unsigned short)htons ((unsigned short)port);
1188                 addr = (struct sockaddr *) &sockin;
1189 #ifdef SUPPORT_IP6
1190             } else if (have_ipv6 () && (h->h_addrtype == AF_INET6)) {
1191                 /* AAAA records (IPv6) */
1192                 if ((unsigned int) h->h_length > sizeof(ia6)) {
1193                     __xmlIOErr(XML_FROM_HTTP, 0, "address size mismatch\n");
1194                     return INVALID_SOCKET;
1195                 }
1196                 memcpy (&ia6, h->h_addr_list[i], h->h_length);
1197                 sockin6.sin6_family = h->h_addrtype;
1198                 sockin6.sin6_addr = ia6;
1199                 sockin6.sin6_port = htons (port);
1200                 addr = (struct sockaddr *) &sockin6;
1201 #endif
1202             } else
1203                 break;              /* for */
1204
1205             s = xmlNanoHTTPConnectAttempt (addr);
1206             if (s != INVALID_SOCKET)
1207                 return (s);
1208         }
1209     }
1210 #endif
1211
1212 #ifdef DEBUG_HTTP
1213     xmlGenericError(xmlGenericErrorContext,
1214                     "xmlNanoHTTPConnectHost:  unable to connect to '%s'.\n",
1215                     host);
1216 #endif
1217     return INVALID_SOCKET;
1218 }
1219
1220
1221 /**
1222  * xmlNanoHTTPOpen:
1223  * @URL:  The URL to load
1224  * @contentType:  if available the Content-Type information will be
1225  *                returned at that location
1226  *
1227  * This function try to open a connection to the indicated resource
1228  * via HTTP GET.
1229  *
1230  * Returns NULL in case of failure, otherwise a request handler.
1231  *     The contentType, if provided must be freed by the caller
1232  */
1233
1234 void*
1235 xmlNanoHTTPOpen(const char *URL, char **contentType) {
1236     if (contentType != NULL) *contentType = NULL;
1237     return(xmlNanoHTTPMethod(URL, NULL, NULL, contentType, NULL, 0));
1238 }
1239
1240 /**
1241  * xmlNanoHTTPOpenRedir:
1242  * @URL:  The URL to load
1243  * @contentType:  if available the Content-Type information will be
1244  *                returned at that location
1245  * @redir: if available the redirected URL will be returned
1246  *
1247  * This function try to open a connection to the indicated resource
1248  * via HTTP GET.
1249  *
1250  * Returns NULL in case of failure, otherwise a request handler.
1251  *     The contentType, if provided must be freed by the caller
1252  */
1253
1254 void*
1255 xmlNanoHTTPOpenRedir(const char *URL, char **contentType, char **redir) {
1256     if (contentType != NULL) *contentType = NULL;
1257     if (redir != NULL) *redir = NULL;
1258     return(xmlNanoHTTPMethodRedir(URL, NULL, NULL, contentType, redir, NULL,0));
1259 }
1260
1261 /**
1262  * xmlNanoHTTPRead:
1263  * @ctx:  the HTTP context
1264  * @dest:  a buffer
1265  * @len:  the buffer length
1266  *
1267  * This function tries to read @len bytes from the existing HTTP connection
1268  * and saves them in @dest. This is a blocking call.
1269  *
1270  * Returns the number of byte read. 0 is an indication of an end of connection.
1271  *         -1 indicates a parameter error.
1272  */
1273 int
1274 xmlNanoHTTPRead(void *ctx, void *dest, int len) {
1275     xmlNanoHTTPCtxtPtr ctxt = (xmlNanoHTTPCtxtPtr) ctx;
1276 #ifdef HAVE_ZLIB_H
1277     int bytes_read = 0;
1278     int orig_avail_in;
1279     int z_ret;
1280 #endif
1281
1282     if (ctx == NULL) return(-1);
1283     if (dest == NULL) return(-1);
1284     if (len <= 0) return(0);
1285
1286 #ifdef HAVE_ZLIB_H
1287     if (ctxt->usesGzip == 1) {
1288         if (ctxt->strm == NULL) return(0);
1289
1290         ctxt->strm->next_out = dest;
1291         ctxt->strm->avail_out = len;
1292         ctxt->strm->avail_in = ctxt->inptr - ctxt->inrptr;
1293
1294         while (ctxt->strm->avail_out > 0 &&
1295                (ctxt->strm->avail_in > 0 || xmlNanoHTTPRecv(ctxt) > 0)) {
1296             orig_avail_in = ctxt->strm->avail_in =
1297                             ctxt->inptr - ctxt->inrptr - bytes_read;
1298             ctxt->strm->next_in = BAD_CAST (ctxt->inrptr + bytes_read);
1299
1300             z_ret = inflate(ctxt->strm, Z_NO_FLUSH);
1301             bytes_read += orig_avail_in - ctxt->strm->avail_in;
1302
1303             if (z_ret != Z_OK) break;
1304         }
1305
1306         ctxt->inrptr += bytes_read;
1307         return(len - ctxt->strm->avail_out);
1308     }
1309 #endif
1310
1311     while (ctxt->inptr - ctxt->inrptr < len) {
1312         if (xmlNanoHTTPRecv(ctxt) <= 0) break;
1313     }
1314     if (ctxt->inptr - ctxt->inrptr < len)
1315         len = ctxt->inptr - ctxt->inrptr;
1316     memcpy(dest, ctxt->inrptr, len);
1317     ctxt->inrptr += len;
1318     return(len);
1319 }
1320
1321 /**
1322  * xmlNanoHTTPClose:
1323  * @ctx:  the HTTP context
1324  *
1325  * This function closes an HTTP context, it ends up the connection and
1326  * free all data related to it.
1327  */
1328 void
1329 xmlNanoHTTPClose(void *ctx) {
1330     xmlNanoHTTPCtxtPtr ctxt = (xmlNanoHTTPCtxtPtr) ctx;
1331
1332     if (ctx == NULL) return;
1333
1334     xmlNanoHTTPFreeCtxt(ctxt);
1335 }
1336
1337 /**
1338  * xmlNanoHTTPMethodRedir:
1339  * @URL:  The URL to load
1340  * @method:  the HTTP method to use
1341  * @input:  the input string if any
1342  * @contentType:  the Content-Type information IN and OUT
1343  * @redir:  the redirected URL OUT
1344  * @headers:  the extra headers
1345  * @ilen:  input length
1346  *
1347  * This function try to open a connection to the indicated resource
1348  * via HTTP using the given @method, adding the given extra headers
1349  * and the input buffer for the request content.
1350  *
1351  * Returns NULL in case of failure, otherwise a request handler.
1352  *     The contentType, or redir, if provided must be freed by the caller
1353  */
1354
1355 void*
1356 xmlNanoHTTPMethodRedir(const char *URL, const char *method, const char *input,
1357                   char **contentType, char **redir,
1358                   const char *headers, int ilen ) {
1359     xmlNanoHTTPCtxtPtr ctxt;
1360     char *bp, *p;
1361     int blen;
1362     SOCKET ret;
1363     int nbRedirects = 0;
1364     char *redirURL = NULL;
1365 #ifdef DEBUG_HTTP
1366     int xmt_bytes;
1367 #endif
1368
1369     if (URL == NULL) return(NULL);
1370     if (method == NULL) method = "GET";
1371     xmlNanoHTTPInit();
1372
1373 retry:
1374     if (redirURL == NULL) {
1375         ctxt = xmlNanoHTTPNewCtxt(URL);
1376         if (ctxt == NULL)
1377             return(NULL);
1378     } else {
1379         ctxt = xmlNanoHTTPNewCtxt(redirURL);
1380         if (ctxt == NULL)
1381             return(NULL);
1382         ctxt->location = xmlMemStrdup(redirURL);
1383     }
1384
1385     if ((ctxt->protocol == NULL) || (strcmp(ctxt->protocol, "http"))) {
1386         __xmlIOErr(XML_FROM_HTTP, XML_HTTP_URL_SYNTAX, "Not a valid HTTP URI");
1387         xmlNanoHTTPFreeCtxt(ctxt);
1388         if (redirURL != NULL) xmlFree(redirURL);
1389         return(NULL);
1390     }
1391     if (ctxt->hostname == NULL) {
1392         __xmlIOErr(XML_FROM_HTTP, XML_HTTP_UNKNOWN_HOST,
1393                    "Failed to identify host in URI");
1394         xmlNanoHTTPFreeCtxt(ctxt);
1395         if (redirURL != NULL) xmlFree(redirURL);
1396         return(NULL);
1397     }
1398     if (proxy) {
1399         blen = strlen(ctxt->hostname) * 2 + 16;
1400         ret = xmlNanoHTTPConnectHost(proxy, proxyPort);
1401     }
1402     else {
1403         blen = strlen(ctxt->hostname);
1404         ret = xmlNanoHTTPConnectHost(ctxt->hostname, ctxt->port);
1405     }
1406     if (ret == INVALID_SOCKET) {
1407         xmlNanoHTTPFreeCtxt(ctxt);
1408         if (redirURL != NULL) xmlFree(redirURL);
1409         return(NULL);
1410     }
1411     ctxt->fd = ret;
1412
1413     if (input == NULL)
1414         ilen = 0;
1415     else
1416         blen += 36;
1417
1418     if (headers != NULL)
1419         blen += strlen(headers) + 2;
1420     if (contentType && *contentType)
1421         /* reserve for string plus 'Content-Type: \r\n" */
1422         blen += strlen(*contentType) + 16;
1423     if (ctxt->query != NULL)
1424         /* 1 for '?' */
1425         blen += strlen(ctxt->query) + 1;
1426     blen += strlen(method) + strlen(ctxt->path) + 24;
1427 #ifdef HAVE_ZLIB_H
1428     /* reserve for possible 'Accept-Encoding: gzip' string */
1429     blen += 23;
1430 #endif
1431     if (ctxt->port != 80) {
1432         /* reserve space for ':xxxxx', incl. potential proxy */
1433         if (proxy)
1434             blen += 17;
1435         else
1436             blen += 11;
1437     }
1438     bp = (char*)xmlMallocAtomic(blen);
1439     if ( bp == NULL ) {
1440         xmlNanoHTTPFreeCtxt( ctxt );
1441         xmlHTTPErrMemory("allocating header buffer");
1442         return ( NULL );
1443     }
1444
1445     p = bp;
1446
1447     if (proxy) {
1448         if (ctxt->port != 80) {
1449             p += snprintf( p, blen - (p - bp), "%s http://%s:%d%s",
1450                         method, ctxt->hostname,
1451                         ctxt->port, ctxt->path );
1452         }
1453         else
1454             p += snprintf( p, blen - (p - bp), "%s http://%s%s", method,
1455                         ctxt->hostname, ctxt->path);
1456     }
1457     else
1458         p += snprintf( p, blen - (p - bp), "%s %s", method, ctxt->path);
1459
1460     if (ctxt->query != NULL)
1461         p += snprintf( p, blen - (p - bp), "?%s", ctxt->query);
1462
1463     if (ctxt->port == 80) {
1464         p += snprintf( p, blen - (p - bp), " HTTP/1.0\r\nHost: %s\r\n",
1465                     ctxt->hostname);
1466     } else {
1467         p += snprintf( p, blen - (p - bp), " HTTP/1.0\r\nHost: %s:%d\r\n",
1468                     ctxt->hostname, ctxt->port);
1469     }
1470
1471 #ifdef HAVE_ZLIB_H
1472     p += snprintf(p, blen - (p - bp), "Accept-Encoding: gzip\r\n");
1473 #endif
1474
1475     if (contentType != NULL && *contentType)
1476         p += snprintf(p, blen - (p - bp), "Content-Type: %s\r\n", *contentType);
1477
1478     if (headers != NULL)
1479         p += snprintf( p, blen - (p - bp), "%s", headers );
1480
1481     if (input != NULL)
1482         snprintf(p, blen - (p - bp), "Content-Length: %d\r\n\r\n", ilen );
1483     else
1484         snprintf(p, blen - (p - bp), "\r\n");
1485
1486 #ifdef DEBUG_HTTP
1487     xmlGenericError(xmlGenericErrorContext,
1488             "-> %s%s", proxy? "(Proxy) " : "", bp);
1489     if ((blen -= strlen(bp)+1) < 0)
1490         xmlGenericError(xmlGenericErrorContext,
1491                 "ERROR: overflowed buffer by %d bytes\n", -blen);
1492 #endif
1493     ctxt->outptr = ctxt->out = bp;
1494     ctxt->state = XML_NANO_HTTP_WRITE;
1495     blen = strlen( ctxt->out );
1496 #ifdef DEBUG_HTTP
1497     xmt_bytes = xmlNanoHTTPSend(ctxt, ctxt->out, blen );
1498     if ( xmt_bytes != blen )
1499         xmlGenericError( xmlGenericErrorContext,
1500                         "xmlNanoHTTPMethodRedir:  Only %d of %d %s %s\n",
1501                         xmt_bytes, blen,
1502                         "bytes of HTTP headers sent to host",
1503                         ctxt->hostname );
1504 #else
1505     xmlNanoHTTPSend(ctxt, ctxt->out, blen );
1506 #endif
1507
1508     if ( input != NULL ) {
1509 #ifdef DEBUG_HTTP
1510         xmt_bytes = xmlNanoHTTPSend( ctxt, input, ilen );
1511
1512         if ( xmt_bytes != ilen )
1513             xmlGenericError( xmlGenericErrorContext,
1514                         "xmlNanoHTTPMethodRedir:  Only %d of %d %s %s\n",
1515                         xmt_bytes, ilen,
1516                         "bytes of HTTP content sent to host",
1517                         ctxt->hostname );
1518 #else
1519         xmlNanoHTTPSend( ctxt, input, ilen );
1520 #endif
1521     }
1522
1523     ctxt->state = XML_NANO_HTTP_READ;
1524
1525     while ((p = xmlNanoHTTPReadLine(ctxt)) != NULL) {
1526         if (*p == 0) {
1527             ctxt->content = ctxt->inrptr;
1528             xmlFree(p);
1529             break;
1530         }
1531         xmlNanoHTTPScanAnswer(ctxt, p);
1532
1533 #ifdef DEBUG_HTTP
1534         xmlGenericError(xmlGenericErrorContext, "<- %s\n", p);
1535 #endif
1536         xmlFree(p);
1537     }
1538
1539     if ((ctxt->location != NULL) && (ctxt->returnValue >= 300) &&
1540         (ctxt->returnValue < 400)) {
1541 #ifdef DEBUG_HTTP
1542         xmlGenericError(xmlGenericErrorContext,
1543                 "\nRedirect to: %s\n", ctxt->location);
1544 #endif
1545         while ( xmlNanoHTTPRecv(ctxt) > 0 )
1546             ;
1547         if (nbRedirects < XML_NANO_HTTP_MAX_REDIR) {
1548             nbRedirects++;
1549             if (redirURL != NULL)
1550                 xmlFree(redirURL);
1551             redirURL = xmlMemStrdup(ctxt->location);
1552             xmlNanoHTTPFreeCtxt(ctxt);
1553             goto retry;
1554         }
1555         xmlNanoHTTPFreeCtxt(ctxt);
1556         if (redirURL != NULL) xmlFree(redirURL);
1557 #ifdef DEBUG_HTTP
1558         xmlGenericError(xmlGenericErrorContext,
1559                 "xmlNanoHTTPMethodRedir: Too many redirects, aborting ...\n");
1560 #endif
1561         return(NULL);
1562     }
1563
1564     if (contentType != NULL) {
1565         if (ctxt->contentType != NULL)
1566             *contentType = xmlMemStrdup(ctxt->contentType);
1567         else
1568             *contentType = NULL;
1569     }
1570
1571     if ((redir != NULL) && (redirURL != NULL)) {
1572         *redir = redirURL;
1573     } else {
1574         if (redirURL != NULL)
1575             xmlFree(redirURL);
1576         if (redir != NULL)
1577             *redir = NULL;
1578     }
1579
1580 #ifdef DEBUG_HTTP
1581     if (ctxt->contentType != NULL)
1582         xmlGenericError(xmlGenericErrorContext,
1583                 "\nCode %d, content-type '%s'\n\n",
1584                ctxt->returnValue, ctxt->contentType);
1585     else
1586         xmlGenericError(xmlGenericErrorContext,
1587                 "\nCode %d, no content-type\n\n",
1588                ctxt->returnValue);
1589 #endif
1590
1591     return((void *) ctxt);
1592 }
1593
1594 /**
1595  * xmlNanoHTTPMethod:
1596  * @URL:  The URL to load
1597  * @method:  the HTTP method to use
1598  * @input:  the input string if any
1599  * @contentType:  the Content-Type information IN and OUT
1600  * @headers:  the extra headers
1601  * @ilen:  input length
1602  *
1603  * This function try to open a connection to the indicated resource
1604  * via HTTP using the given @method, adding the given extra headers
1605  * and the input buffer for the request content.
1606  *
1607  * Returns NULL in case of failure, otherwise a request handler.
1608  *     The contentType, if provided must be freed by the caller
1609  */
1610
1611 void*
1612 xmlNanoHTTPMethod(const char *URL, const char *method, const char *input,
1613                   char **contentType, const char *headers, int ilen) {
1614     return(xmlNanoHTTPMethodRedir(URL, method, input, contentType,
1615                                   NULL, headers, ilen));
1616 }
1617
1618 /**
1619  * xmlNanoHTTPFetch:
1620  * @URL:  The URL to load
1621  * @filename:  the filename where the content should be saved
1622  * @contentType:  if available the Content-Type information will be
1623  *                returned at that location
1624  *
1625  * This function try to fetch the indicated resource via HTTP GET
1626  * and save it's content in the file.
1627  *
1628  * Returns -1 in case of failure, 0 incase of success. The contentType,
1629  *     if provided must be freed by the caller
1630  */
1631 int
1632 xmlNanoHTTPFetch(const char *URL, const char *filename, char **contentType) {
1633     void *ctxt = NULL;
1634     char *buf = NULL;
1635     int fd;
1636     int len;
1637     int ret = 0;
1638
1639     if (filename == NULL) return(-1);
1640     ctxt = xmlNanoHTTPOpen(URL, contentType);
1641     if (ctxt == NULL) return(-1);
1642
1643     if (!strcmp(filename, "-"))
1644         fd = 0;
1645     else {
1646         fd = open(filename, O_CREAT | O_WRONLY, 00644);
1647         if (fd < 0) {
1648             xmlNanoHTTPClose(ctxt);
1649             if ((contentType != NULL) && (*contentType != NULL)) {
1650                 xmlFree(*contentType);
1651                 *contentType = NULL;
1652             }
1653             return(-1);
1654         }
1655     }
1656
1657     xmlNanoHTTPFetchContent( ctxt, &buf, &len );
1658     if ( len > 0 ) {
1659         if (write(fd, buf, len) == -1) {
1660             ret = -1;
1661         }
1662     }
1663
1664     xmlNanoHTTPClose(ctxt);
1665     close(fd);
1666     return(ret);
1667 }
1668
1669 #ifdef LIBXML_OUTPUT_ENABLED
1670 /**
1671  * xmlNanoHTTPSave:
1672  * @ctxt:  the HTTP context
1673  * @filename:  the filename where the content should be saved
1674  *
1675  * This function saves the output of the HTTP transaction to a file
1676  * It closes and free the context at the end
1677  *
1678  * Returns -1 in case of failure, 0 incase of success.
1679  */
1680 int
1681 xmlNanoHTTPSave(void *ctxt, const char *filename) {
1682     char *buf = NULL;
1683     int fd;
1684     int len;
1685     int ret = 0;
1686
1687     if ((ctxt == NULL) || (filename == NULL)) return(-1);
1688
1689     if (!strcmp(filename, "-"))
1690         fd = 0;
1691     else {
1692         fd = open(filename, O_CREAT | O_WRONLY, 0666);
1693         if (fd < 0) {
1694             xmlNanoHTTPClose(ctxt);
1695             return(-1);
1696         }
1697     }
1698
1699     xmlNanoHTTPFetchContent( ctxt, &buf, &len );
1700     if ( len > 0 ) {
1701         if (write(fd, buf, len) == -1) {
1702             ret = -1;
1703         }
1704     }
1705
1706     xmlNanoHTTPClose(ctxt);
1707     close(fd);
1708     return(ret);
1709 }
1710 #endif /* LIBXML_OUTPUT_ENABLED */
1711
1712 /**
1713  * xmlNanoHTTPReturnCode:
1714  * @ctx:  the HTTP context
1715  *
1716  * Get the latest HTTP return code received
1717  *
1718  * Returns the HTTP return code for the request.
1719  */
1720 int
1721 xmlNanoHTTPReturnCode(void *ctx) {
1722     xmlNanoHTTPCtxtPtr ctxt = (xmlNanoHTTPCtxtPtr) ctx;
1723
1724     if (ctxt == NULL) return(-1);
1725
1726     return(ctxt->returnValue);
1727 }
1728
1729 /**
1730  * xmlNanoHTTPAuthHeader:
1731  * @ctx:  the HTTP context
1732  *
1733  * Get the authentication header of an HTTP context
1734  *
1735  * Returns the stashed value of the WWW-Authenticate or Proxy-Authenticate
1736  * header.
1737  */
1738 const char *
1739 xmlNanoHTTPAuthHeader(void *ctx) {
1740     xmlNanoHTTPCtxtPtr ctxt = (xmlNanoHTTPCtxtPtr) ctx;
1741
1742     if (ctxt == NULL) return(NULL);
1743
1744     return(ctxt->authHeader);
1745 }
1746
1747 /**
1748  * xmlNanoHTTPContentLength:
1749  * @ctx:  the HTTP context
1750  *
1751  * Provides the specified content length from the HTTP header.
1752  *
1753  * Return the specified content length from the HTTP header.  Note that
1754  * a value of -1 indicates that the content length element was not included in
1755  * the response header.
1756  */
1757 int
1758 xmlNanoHTTPContentLength( void * ctx ) {
1759     xmlNanoHTTPCtxtPtr  ctxt = (xmlNanoHTTPCtxtPtr)ctx;
1760
1761     return ( ( ctxt == NULL ) ? -1 : ctxt->ContentLength );
1762 }
1763
1764 /**
1765  * xmlNanoHTTPRedir:
1766  * @ctx:  the HTTP context
1767  *
1768  * Provides the specified redirection URL if available from the HTTP header.
1769  *
1770  * Return the specified redirection URL or NULL if not redirected.
1771  */
1772 const char *
1773 xmlNanoHTTPRedir( void * ctx ) {
1774     xmlNanoHTTPCtxtPtr  ctxt = (xmlNanoHTTPCtxtPtr)ctx;
1775
1776     return ( ( ctxt == NULL ) ? NULL : ctxt->location );
1777 }
1778
1779 /**
1780  * xmlNanoHTTPEncoding:
1781  * @ctx:  the HTTP context
1782  *
1783  * Provides the specified encoding if specified in the HTTP headers.
1784  *
1785  * Return the specified encoding or NULL if not available
1786  */
1787 const char *
1788 xmlNanoHTTPEncoding( void * ctx ) {
1789     xmlNanoHTTPCtxtPtr  ctxt = (xmlNanoHTTPCtxtPtr)ctx;
1790
1791     return ( ( ctxt == NULL ) ? NULL : ctxt->encoding );
1792 }
1793
1794 /**
1795  * xmlNanoHTTPMimeType:
1796  * @ctx:  the HTTP context
1797  *
1798  * Provides the specified Mime-Type if specified in the HTTP headers.
1799  *
1800  * Return the specified Mime-Type or NULL if not available
1801  */
1802 const char *
1803 xmlNanoHTTPMimeType( void * ctx ) {
1804     xmlNanoHTTPCtxtPtr  ctxt = (xmlNanoHTTPCtxtPtr)ctx;
1805
1806     return ( ( ctxt == NULL ) ? NULL : ctxt->mimeType );
1807 }
1808
1809 /**
1810  * xmlNanoHTTPFetchContent:
1811  * @ctx:  the HTTP context
1812  * @ptr:  pointer to set to the content buffer.
1813  * @len:  integer pointer to hold the length of the content
1814  *
1815  * Check if all the content was read
1816  *
1817  * Returns 0 if all the content was read and available, returns
1818  * -1 if received content length was less than specified or an error
1819  * occurred.
1820  */
1821 static int
1822 xmlNanoHTTPFetchContent( void * ctx, char ** ptr, int * len ) {
1823     xmlNanoHTTPCtxtPtr  ctxt = (xmlNanoHTTPCtxtPtr)ctx;
1824
1825     int                 rc = 0;
1826     int                 cur_lgth;
1827     int                 rcvd_lgth;
1828     int                 dummy_int;
1829     char *              dummy_ptr = NULL;
1830
1831     /*  Dummy up return input parameters if not provided  */
1832
1833     if ( len == NULL )
1834         len = &dummy_int;
1835
1836     if ( ptr == NULL )
1837         ptr = &dummy_ptr;
1838
1839     /*  But can't work without the context pointer  */
1840
1841     if ( ( ctxt == NULL ) || ( ctxt->content == NULL ) ) {
1842         *len = 0;
1843         *ptr = NULL;
1844         return ( -1 );
1845     }
1846
1847     rcvd_lgth = ctxt->inptr - ctxt->content;
1848
1849     while ( (cur_lgth = xmlNanoHTTPRecv( ctxt )) > 0 ) {
1850
1851         rcvd_lgth += cur_lgth;
1852         if ( (ctxt->ContentLength > 0) && (rcvd_lgth >= ctxt->ContentLength) )
1853             break;
1854     }
1855
1856     *ptr = ctxt->content;
1857     *len = rcvd_lgth;
1858
1859     if ( ( ctxt->ContentLength > 0 ) && ( rcvd_lgth < ctxt->ContentLength ) )
1860         rc = -1;
1861     else if ( rcvd_lgth == 0 )
1862         rc = -1;
1863
1864     return ( rc );
1865 }
1866
1867 #ifdef STANDALONE
1868 int main(int argc, char **argv) {
1869     char *contentType = NULL;
1870
1871     if (argv[1] != NULL) {
1872         if (argv[2] != NULL)
1873             xmlNanoHTTPFetch(argv[1], argv[2], &contentType);
1874         else
1875             xmlNanoHTTPFetch(argv[1], "-", &contentType);
1876         if (contentType != NULL) xmlFree(contentType);
1877     } else {
1878         xmlGenericError(xmlGenericErrorContext,
1879                 "%s: minimal HTTP GET implementation\n", argv[0]);
1880         xmlGenericError(xmlGenericErrorContext,
1881                 "\tusage %s [ URL [ filename ] ]\n", argv[0]);
1882     }
1883     xmlNanoHTTPCleanup();
1884     xmlMemoryDump();
1885     return(0);
1886 }
1887 #endif /* STANDALONE */
1888 #else /* !LIBXML_HTTP_ENABLED */
1889 #ifdef STANDALONE
1890 #include <stdio.h>
1891 int main(int argc, char **argv) {
1892     xmlGenericError(xmlGenericErrorContext,
1893             "%s : HTTP support not compiled in\n", argv[0]);
1894     return(0);
1895 }
1896 #endif /* STANDALONE */
1897 #endif /* LIBXML_HTTP_ENABLED */
1898 #define bottom_nanohttp
1899 #include "elfgcchack.h"