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