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