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