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 (at) 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 LIBXML_ZLIB_ENABLED 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 LIBXML_ZLIB_ENABLED 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 LIBXML_ZLIB_ENABLED 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 LIBXML_ZLIB_ENABLED 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 LIBXML_ZLIB_ENABLED 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 LIBXML_ZLIB_ENABLED 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 LIBXML_ZLIB_ENABLED 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 LIBXML_ZLIB_ENABLED 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" 1900
