1 /* 2 * xmlIO.c : implementation of the I/O interfaces used by the parser 3 * 4 * See Copyright for the status of this software. 5 * 6 * daniel (at) veillard.com 7 * 8 * 14 Nov 2000 ht - for VMS, truncated name of long functions to under 32 char 9 */ 10 11 #define IN_LIBXML 12 #include "libxml.h" 13 14 #include <string.h> 15 #ifdef HAVE_ERRNO_H 16 #include <errno.h> 17 #endif 18 19 20 #ifdef HAVE_SYS_TYPES_H 21 #include <sys/types.h> 22 #endif 23 #ifdef HAVE_SYS_STAT_H 24 #include <sys/stat.h> 25 #endif 26 #ifdef HAVE_FCNTL_H 27 #include <fcntl.h> 28 #endif 29 #ifdef HAVE_UNISTD_H 30 #include <unistd.h> 31 #endif 32 #ifdef HAVE_STDLIB_H 33 #include <stdlib.h> 34 #endif 35 #ifdef HAVE_ZLIB_H 36 #include <zlib.h> 37 #endif 38 #ifdef HAVE_LZMA_H 39 #include <lzma.h> 40 #endif 41 42 #if defined(WIN32) || defined(_WIN32) 43 #include <windows.h> 44 #endif 45 46 #if defined(_WIN32_WCE) 47 #include <winnls.h> /* for CP_UTF8 */ 48 #endif 49 50 /* Figure a portable way to know if a file is a directory. */ 51 #ifndef HAVE_STAT 52 # ifdef HAVE__STAT 53 /* MS C library seems to define stat and _stat. The definition 54 is identical. Still, mapping them to each other causes a warning. */ 55 # ifndef _MSC_VER 56 # define stat(x,y) _stat(x,y) 57 # endif 58 # define HAVE_STAT 59 # endif 60 #else 61 # ifdef HAVE__STAT 62 # if defined(_WIN32) || defined (__DJGPP__) && !defined (__CYGWIN__) 63 # define stat _stat 64 # endif 65 # endif 66 #endif 67 #ifdef HAVE_STAT 68 # ifndef S_ISDIR 69 # ifdef _S_ISDIR 70 # define S_ISDIR(x) _S_ISDIR(x) 71 # else 72 # ifdef S_IFDIR 73 # ifndef S_IFMT 74 # ifdef _S_IFMT 75 # define S_IFMT _S_IFMT 76 # endif 77 # endif 78 # ifdef S_IFMT 79 # define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR) 80 # endif 81 # endif 82 # endif 83 # endif 84 #endif 85 86 #include <libxml/xmlmemory.h> 87 #include <libxml/parser.h> 88 #include <libxml/parserInternals.h> 89 #include <libxml/xmlIO.h> 90 #include <libxml/uri.h> 91 #include <libxml/nanohttp.h> 92 #include <libxml/nanoftp.h> 93 #include <libxml/xmlerror.h> 94 #ifdef LIBXML_CATALOG_ENABLED 95 #include <libxml/catalog.h> 96 #endif 97 #include <libxml/globals.h> 98 99 #include "buf.h" 100 #include "enc.h" 101 102 /* #define VERBOSE_FAILURE */ 103 /* #define DEBUG_EXTERNAL_ENTITIES */ 104 /* #define DEBUG_INPUT */ 105 106 #ifdef DEBUG_INPUT 107 #define MINLEN 40 108 #else 109 #define MINLEN 4000 110 #endif 111 112 /* 113 * Input I/O callback sets 114 */ 115 typedef struct _xmlInputCallback { 116 xmlInputMatchCallback matchcallback; 117 xmlInputOpenCallback opencallback; 118 xmlInputReadCallback readcallback; 119 xmlInputCloseCallback closecallback; 120 } xmlInputCallback; 121 122 #define MAX_INPUT_CALLBACK 15 123 124 static xmlInputCallback xmlInputCallbackTable[MAX_INPUT_CALLBACK]; 125 static int xmlInputCallbackNr = 0; 126 static int xmlInputCallbackInitialized = 0; 127 128 #ifdef LIBXML_OUTPUT_ENABLED 129 /* 130 * Output I/O callback sets 131 */ 132 typedef struct _xmlOutputCallback { 133 xmlOutputMatchCallback matchcallback; 134 xmlOutputOpenCallback opencallback; 135 xmlOutputWriteCallback writecallback; 136 xmlOutputCloseCallback closecallback; 137 } xmlOutputCallback; 138 139 #define MAX_OUTPUT_CALLBACK 15 140 141 static xmlOutputCallback xmlOutputCallbackTable[MAX_OUTPUT_CALLBACK]; 142 static int xmlOutputCallbackNr = 0; 143 static int xmlOutputCallbackInitialized = 0; 144 145 xmlOutputBufferPtr 146 xmlAllocOutputBufferInternal(xmlCharEncodingHandlerPtr encoder); 147 #endif /* LIBXML_OUTPUT_ENABLED */ 148 149 /************************************************************************ 150 * * 151 * Tree memory error handler * 152 * * 153 ************************************************************************/ 154 155 static const char *IOerr[] = { 156 "Unknown IO error", /* UNKNOWN */ 157 "Permission denied", /* EACCES */ 158 "Resource temporarily unavailable",/* EAGAIN */ 159 "Bad file descriptor", /* EBADF */ 160 "Bad message", /* EBADMSG */ 161 "Resource busy", /* EBUSY */ 162 "Operation canceled", /* ECANCELED */ 163 "No child processes", /* ECHILD */ 164 "Resource deadlock avoided",/* EDEADLK */ 165 "Domain error", /* EDOM */ 166 "File exists", /* EEXIST */ 167 "Bad address", /* EFAULT */ 168 "File too large", /* EFBIG */ 169 "Operation in progress", /* EINPROGRESS */ 170 "Interrupted function call",/* EINTR */ 171 "Invalid argument", /* EINVAL */ 172 "Input/output error", /* EIO */ 173 "Is a directory", /* EISDIR */ 174 "Too many open files", /* EMFILE */ 175 "Too many links", /* EMLINK */ 176 "Inappropriate message buffer length",/* EMSGSIZE */ 177 "Filename too long", /* ENAMETOOLONG */ 178 "Too many open files in system",/* ENFILE */ 179 "No such device", /* ENODEV */ 180 "No such file or directory",/* ENOENT */ 181 "Exec format error", /* ENOEXEC */ 182 "No locks available", /* ENOLCK */ 183 "Not enough space", /* ENOMEM */ 184 "No space left on device", /* ENOSPC */ 185 "Function not implemented", /* ENOSYS */ 186 "Not a directory", /* ENOTDIR */ 187 "Directory not empty", /* ENOTEMPTY */ 188 "Not supported", /* ENOTSUP */ 189 "Inappropriate I/O control operation",/* ENOTTY */ 190 "No such device or address",/* ENXIO */ 191 "Operation not permitted", /* EPERM */ 192 "Broken pipe", /* EPIPE */ 193 "Result too large", /* ERANGE */ 194 "Read-only file system", /* EROFS */ 195 "Invalid seek", /* ESPIPE */ 196 "No such process", /* ESRCH */ 197 "Operation timed out", /* ETIMEDOUT */ 198 "Improper link", /* EXDEV */ 199 "Attempt to load network entity %s", /* XML_IO_NETWORK_ATTEMPT */ 200 "encoder error", /* XML_IO_ENCODER */ 201 "flush error", 202 "write error", 203 "no input", 204 "buffer full", 205 "loading error", 206 "not a socket", /* ENOTSOCK */ 207 "already connected", /* EISCONN */ 208 "connection refused", /* ECONNREFUSED */ 209 "unreachable network", /* ENETUNREACH */ 210 "adddress in use", /* EADDRINUSE */ 211 "already in use", /* EALREADY */ 212 "unknown address familly", /* EAFNOSUPPORT */ 213 }; 214 215 #if defined(_WIN32) || defined (__DJGPP__) && !defined (__CYGWIN__) 216 /** 217 * __xmlIOWin32UTF8ToWChar: 218 * @u8String: uft-8 string 219 * 220 * Convert a string from utf-8 to wchar (WINDOWS ONLY!) 221 */ 222 static wchar_t * 223 __xmlIOWin32UTF8ToWChar(const char *u8String) 224 { 225 wchar_t *wString = NULL; 226 227 if (u8String) { 228 int wLen = 229 MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, u8String, 230 -1, NULL, 0); 231 if (wLen) { 232 wString = xmlMalloc(wLen * sizeof(wchar_t)); 233 if (wString) { 234 if (MultiByteToWideChar 235 (CP_UTF8, 0, u8String, -1, wString, wLen) == 0) { 236 xmlFree(wString); 237 wString = NULL; 238 } 239 } 240 } 241 } 242 243 return wString; 244 } 245 #endif 246 247 /** 248 * xmlIOErrMemory: 249 * @extra: extra informations 250 * 251 * Handle an out of memory condition 252 */ 253 static void 254 xmlIOErrMemory(const char *extra) 255 { 256 __xmlSimpleError(XML_FROM_IO, XML_ERR_NO_MEMORY, NULL, NULL, extra); 257 } 258 259 /** 260 * __xmlIOErr: 261 * @code: the error number 262 * @ 263 * @extra: extra informations 264 * 265 * Handle an I/O error 266 */ 267 void 268 __xmlIOErr(int domain, int code, const char *extra) 269 { 270 unsigned int idx; 271 272 if (code == 0) { 273 #ifdef HAVE_ERRNO_H 274 if (errno == 0) code = 0; 275 #ifdef EACCES 276 else if (errno == EACCES) code = XML_IO_EACCES; 277 #endif 278 #ifdef EAGAIN 279 else if (errno == EAGAIN) code = XML_IO_EAGAIN; 280 #endif 281 #ifdef EBADF 282 else if (errno == EBADF) code = XML_IO_EBADF; 283 #endif 284 #ifdef EBADMSG 285 else if (errno == EBADMSG) code = XML_IO_EBADMSG; 286 #endif 287 #ifdef EBUSY 288 else if (errno == EBUSY) code = XML_IO_EBUSY; 289 #endif 290 #ifdef ECANCELED 291 else if (errno == ECANCELED) code = XML_IO_ECANCELED; 292 #endif 293 #ifdef ECHILD 294 else if (errno == ECHILD) code = XML_IO_ECHILD; 295 #endif 296 #ifdef EDEADLK 297 else if (errno == EDEADLK) code = XML_IO_EDEADLK; 298 #endif 299 #ifdef EDOM 300 else if (errno == EDOM) code = XML_IO_EDOM; 301 #endif 302 #ifdef EEXIST 303 else if (errno == EEXIST) code = XML_IO_EEXIST; 304 #endif 305 #ifdef EFAULT 306 else if (errno == EFAULT) code = XML_IO_EFAULT; 307 #endif 308 #ifdef EFBIG 309 else if (errno == EFBIG) code = XML_IO_EFBIG; 310 #endif 311 #ifdef EINPROGRESS 312 else if (errno == EINPROGRESS) code = XML_IO_EINPROGRESS; 313 #endif 314 #ifdef EINTR 315 else if (errno == EINTR) code = XML_IO_EINTR; 316 #endif 317 #ifdef EINVAL 318 else if (errno == EINVAL) code = XML_IO_EINVAL; 319 #endif 320 #ifdef EIO 321 else if (errno == EIO) code = XML_IO_EIO; 322 #endif 323 #ifdef EISDIR 324 else if (errno == EISDIR) code = XML_IO_EISDIR; 325 #endif 326 #ifdef EMFILE 327 else if (errno == EMFILE) code = XML_IO_EMFILE; 328 #endif 329 #ifdef EMLINK 330 else if (errno == EMLINK) code = XML_IO_EMLINK; 331 #endif 332 #ifdef EMSGSIZE 333 else if (errno == EMSGSIZE) code = XML_IO_EMSGSIZE; 334 #endif 335 #ifdef ENAMETOOLONG 336 else if (errno == ENAMETOOLONG) code = XML_IO_ENAMETOOLONG; 337 #endif 338 #ifdef ENFILE 339 else if (errno == ENFILE) code = XML_IO_ENFILE; 340 #endif 341 #ifdef ENODEV 342 else if (errno == ENODEV) code = XML_IO_ENODEV; 343 #endif 344 #ifdef ENOENT 345 else if (errno == ENOENT) code = XML_IO_ENOENT; 346 #endif 347 #ifdef ENOEXEC 348 else if (errno == ENOEXEC) code = XML_IO_ENOEXEC; 349 #endif 350 #ifdef ENOLCK 351 else if (errno == ENOLCK) code = XML_IO_ENOLCK; 352 #endif 353 #ifdef ENOMEM 354 else if (errno == ENOMEM) code = XML_IO_ENOMEM; 355 #endif 356 #ifdef ENOSPC 357 else if (errno == ENOSPC) code = XML_IO_ENOSPC; 358 #endif 359 #ifdef ENOSYS 360 else if (errno == ENOSYS) code = XML_IO_ENOSYS; 361 #endif 362 #ifdef ENOTDIR 363 else if (errno == ENOTDIR) code = XML_IO_ENOTDIR; 364 #endif 365 #ifdef ENOTEMPTY 366 else if (errno == ENOTEMPTY) code = XML_IO_ENOTEMPTY; 367 #endif 368 #ifdef ENOTSUP 369 else if (errno == ENOTSUP) code = XML_IO_ENOTSUP; 370 #endif 371 #ifdef ENOTTY 372 else if (errno == ENOTTY) code = XML_IO_ENOTTY; 373 #endif 374 #ifdef ENXIO 375 else if (errno == ENXIO) code = XML_IO_ENXIO; 376 #endif 377 #ifdef EPERM 378 else if (errno == EPERM) code = XML_IO_EPERM; 379 #endif 380 #ifdef EPIPE 381 else if (errno == EPIPE) code = XML_IO_EPIPE; 382 #endif 383 #ifdef ERANGE 384 else if (errno == ERANGE) code = XML_IO_ERANGE; 385 #endif 386 #ifdef EROFS 387 else if (errno == EROFS) code = XML_IO_EROFS; 388 #endif 389 #ifdef ESPIPE 390 else if (errno == ESPIPE) code = XML_IO_ESPIPE; 391 #endif 392 #ifdef ESRCH 393 else if (errno == ESRCH) code = XML_IO_ESRCH; 394 #endif 395 #ifdef ETIMEDOUT 396 else if (errno == ETIMEDOUT) code = XML_IO_ETIMEDOUT; 397 #endif 398 #ifdef EXDEV 399 else if (errno == EXDEV) code = XML_IO_EXDEV; 400 #endif 401 #ifdef ENOTSOCK 402 else if (errno == ENOTSOCK) code = XML_IO_ENOTSOCK; 403 #endif 404 #ifdef EISCONN 405 else if (errno == EISCONN) code = XML_IO_EISCONN; 406 #endif 407 #ifdef ECONNREFUSED 408 else if (errno == ECONNREFUSED) code = XML_IO_ECONNREFUSED; 409 #endif 410 #ifdef ETIMEDOUT 411 else if (errno == ETIMEDOUT) code = XML_IO_ETIMEDOUT; 412 #endif 413 #ifdef ENETUNREACH 414 else if (errno == ENETUNREACH) code = XML_IO_ENETUNREACH; 415 #endif 416 #ifdef EADDRINUSE 417 else if (errno == EADDRINUSE) code = XML_IO_EADDRINUSE; 418 #endif 419 #ifdef EINPROGRESS 420 else if (errno == EINPROGRESS) code = XML_IO_EINPROGRESS; 421 #endif 422 #ifdef EALREADY 423 else if (errno == EALREADY) code = XML_IO_EALREADY; 424 #endif 425 #ifdef EAFNOSUPPORT 426 else if (errno == EAFNOSUPPORT) code = XML_IO_EAFNOSUPPORT; 427 #endif 428 else code = XML_IO_UNKNOWN; 429 #endif /* HAVE_ERRNO_H */ 430 } 431 idx = 0; 432 if (code >= XML_IO_UNKNOWN) idx = code - XML_IO_UNKNOWN; 433 if (idx >= (sizeof(IOerr) / sizeof(IOerr[0]))) idx = 0; 434 435 __xmlSimpleError(domain, code, NULL, IOerr[idx], extra); 436 } 437 438 /** 439 * xmlIOErr: 440 * @code: the error number 441 * @extra: extra informations 442 * 443 * Handle an I/O error 444 */ 445 static void 446 xmlIOErr(int code, const char *extra) 447 { 448 __xmlIOErr(XML_FROM_IO, code, extra); 449 } 450 451 /** 452 * __xmlLoaderErr: 453 * @ctx: the parser context 454 * @extra: extra informations 455 * 456 * Handle a resource access error 457 */ 458 void 459 __xmlLoaderErr(void *ctx, const char *msg, const char *filename) 460 { 461 xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx; 462 xmlStructuredErrorFunc schannel = NULL; 463 xmlGenericErrorFunc channel = NULL; 464 void *data = NULL; 465 xmlErrorLevel level = XML_ERR_ERROR; 466 467 if ((ctxt != NULL) && (ctxt->disableSAX != 0) && 468 (ctxt->instate == XML_PARSER_EOF)) 469 return; 470 if ((ctxt != NULL) && (ctxt->sax != NULL)) { 471 if (ctxt->validate) { 472 channel = ctxt->sax->error; 473 level = XML_ERR_ERROR; 474 } else { 475 channel = ctxt->sax->warning; 476 level = XML_ERR_WARNING; 477 } 478 if (ctxt->sax->initialized == XML_SAX2_MAGIC) 479 schannel = ctxt->sax->serror; 480 data = ctxt->userData; 481 } 482 __xmlRaiseError(schannel, channel, data, ctxt, NULL, XML_FROM_IO, 483 XML_IO_LOAD_ERROR, level, NULL, 0, 484 filename, NULL, NULL, 0, 0, 485 msg, filename); 486 487 } 488 489 /************************************************************************ 490 * * 491 * Tree memory error handler * 492 * * 493 ************************************************************************/ 494 /** 495 * xmlNormalizeWindowsPath: 496 * @path: the input file path 497 * 498 * This function is obsolete. Please see xmlURIFromPath in uri.c for 499 * a better solution. 500 * 501 * Returns a canonicalized version of the path 502 */ 503 xmlChar * 504 xmlNormalizeWindowsPath(const xmlChar *path) 505 { 506 return xmlCanonicPath(path); 507 } 508 509 /** 510 * xmlCleanupInputCallbacks: 511 * 512 * clears the entire input callback table. this includes the 513 * compiled-in I/O. 514 */ 515 void 516 xmlCleanupInputCallbacks(void) 517 { 518 int i; 519 520 if (!xmlInputCallbackInitialized) 521 return; 522 523 for (i = xmlInputCallbackNr - 1; i >= 0; i--) { 524 xmlInputCallbackTable[i].matchcallback = NULL; 525 xmlInputCallbackTable[i].opencallback = NULL; 526 xmlInputCallbackTable[i].readcallback = NULL; 527 xmlInputCallbackTable[i].closecallback = NULL; 528 } 529 530 xmlInputCallbackNr = 0; 531 xmlInputCallbackInitialized = 0; 532 } 533 534 /** 535 * xmlPopInputCallbacks: 536 * 537 * Clear the top input callback from the input stack. this includes the 538 * compiled-in I/O. 539 * 540 * Returns the number of input callback registered or -1 in case of error. 541 */ 542 int 543 xmlPopInputCallbacks(void) 544 { 545 if (!xmlInputCallbackInitialized) 546 return(-1); 547 548 if (xmlInputCallbackNr <= 0) 549 return(-1); 550 551 xmlInputCallbackNr--; 552 xmlInputCallbackTable[xmlInputCallbackNr].matchcallback = NULL; 553 xmlInputCallbackTable[xmlInputCallbackNr].opencallback = NULL; 554 xmlInputCallbackTable[xmlInputCallbackNr].readcallback = NULL; 555 xmlInputCallbackTable[xmlInputCallbackNr].closecallback = NULL; 556 557 return(xmlInputCallbackNr); 558 } 559 560 #ifdef LIBXML_OUTPUT_ENABLED 561 /** 562 * xmlCleanupOutputCallbacks: 563 * 564 * clears the entire output callback table. this includes the 565 * compiled-in I/O callbacks. 566 */ 567 void 568 xmlCleanupOutputCallbacks(void) 569 { 570 int i; 571 572 if (!xmlOutputCallbackInitialized) 573 return; 574 575 for (i = xmlOutputCallbackNr - 1; i >= 0; i--) { 576 xmlOutputCallbackTable[i].matchcallback = NULL; 577 xmlOutputCallbackTable[i].opencallback = NULL; 578 xmlOutputCallbackTable[i].writecallback = NULL; 579 xmlOutputCallbackTable[i].closecallback = NULL; 580 } 581 582 xmlOutputCallbackNr = 0; 583 xmlOutputCallbackInitialized = 0; 584 } 585 #endif /* LIBXML_OUTPUT_ENABLED */ 586 587 /************************************************************************ 588 * * 589 * Standard I/O for file accesses * 590 * * 591 ************************************************************************/ 592 593 #if defined(_WIN32) || defined (__DJGPP__) && !defined (__CYGWIN__) 594 595 /** 596 * xmlWrapOpenUtf8: 597 * @path: the path in utf-8 encoding 598 * @mode: type of access (0 - read, 1 - write) 599 * 600 * function opens the file specified by @path 601 * 602 */ 603 static FILE* 604 xmlWrapOpenUtf8(const char *path,int mode) 605 { 606 FILE *fd = NULL; 607 wchar_t *wPath; 608 609 wPath = __xmlIOWin32UTF8ToWChar(path); 610 if(wPath) 611 { 612 fd = _wfopen(wPath, mode ? L"wb" : L"rb"); 613 xmlFree(wPath); 614 } 615 /* maybe path in native encoding */ 616 if(fd == NULL) 617 fd = fopen(path, mode ? "wb" : "rb"); 618 619 return fd; 620 } 621 622 #ifdef HAVE_ZLIB_H 623 static gzFile 624 xmlWrapGzOpenUtf8(const char *path, const char *mode) 625 { 626 gzFile fd; 627 wchar_t *wPath; 628 629 fd = gzopen (path, mode); 630 if (fd) 631 return fd; 632 633 wPath = __xmlIOWin32UTF8ToWChar(path); 634 if(wPath) 635 { 636 int d, m = (strstr(mode, "r") ? O_RDONLY : O_RDWR); 637 #ifdef _O_BINARY 638 m |= (strstr(mode, "b") ? _O_BINARY : 0); 639 #endif 640 d = _wopen(wPath, m); 641 if (d >= 0) 642 fd = gzdopen(d, mode); 643 xmlFree(wPath); 644 } 645 646 return fd; 647 } 648 #endif 649 650 /** 651 * xmlWrapStatUtf8: 652 * @path: the path in utf-8 encoding 653 * @info: structure that stores results 654 * 655 * function obtains information about the file or directory 656 * 657 */ 658 static int 659 xmlWrapStatUtf8(const char *path,struct stat *info) 660 { 661 #ifdef HAVE_STAT 662 int retval = -1; 663 wchar_t *wPath; 664 665 wPath = __xmlIOWin32UTF8ToWChar(path); 666 if (wPath) 667 { 668 retval = _wstat(wPath,info); 669 xmlFree(wPath); 670 } 671 /* maybe path in native encoding */ 672 if(retval < 0) 673 retval = stat(path,info); 674 return retval; 675 #else 676 return -1; 677 #endif 678 } 679 680 /** 681 * xmlWrapOpenNative: 682 * @path: the path 683 * @mode: type of access (0 - read, 1 - write) 684 * 685 * function opens the file specified by @path 686 * 687 */ 688 static FILE* 689 xmlWrapOpenNative(const char *path,int mode) 690 { 691 return fopen(path,mode ? "wb" : "rb"); 692 } 693 694 /** 695 * xmlWrapStatNative: 696 * @path: the path 697 * @info: structure that stores results 698 * 699 * function obtains information about the file or directory 700 * 701 */ 702 static int 703 xmlWrapStatNative(const char *path,struct stat *info) 704 { 705 #ifdef HAVE_STAT 706 return stat(path,info); 707 #else 708 return -1; 709 #endif 710 } 711 712 typedef int (* xmlWrapStatFunc) (const char *f, struct stat *s); 713 static xmlWrapStatFunc xmlWrapStat = xmlWrapStatNative; 714 typedef FILE* (* xmlWrapOpenFunc)(const char *f,int mode); 715 static xmlWrapOpenFunc xmlWrapOpen = xmlWrapOpenNative; 716 #ifdef HAVE_ZLIB_H 717 typedef gzFile (* xmlWrapGzOpenFunc) (const char *f, const char *mode); 718 static xmlWrapGzOpenFunc xmlWrapGzOpen = gzopen; 719 #endif 720 /** 721 * xmlInitPlatformSpecificIo: 722 * 723 * Initialize platform specific features. 724 */ 725 static void 726 xmlInitPlatformSpecificIo(void) 727 { 728 static int xmlPlatformIoInitialized = 0; 729 OSVERSIONINFO osvi; 730 731 if(xmlPlatformIoInitialized) 732 return; 733 734 osvi.dwOSVersionInfoSize = sizeof(osvi); 735 736 if(GetVersionEx(&osvi) && (osvi.dwPlatformId == VER_PLATFORM_WIN32_NT)) { 737 xmlWrapStat = xmlWrapStatUtf8; 738 xmlWrapOpen = xmlWrapOpenUtf8; 739 #ifdef HAVE_ZLIB_H 740 xmlWrapGzOpen = xmlWrapGzOpenUtf8; 741 #endif 742 } else { 743 xmlWrapStat = xmlWrapStatNative; 744 xmlWrapOpen = xmlWrapOpenNative; 745 #ifdef HAVE_ZLIB_H 746 xmlWrapGzOpen = gzopen; 747 #endif 748 } 749 750 xmlPlatformIoInitialized = 1; 751 return; 752 } 753 754 #endif 755 756 /** 757 * xmlCheckFilename: 758 * @path: the path to check 759 * 760 * function checks to see if @path is a valid source 761 * (file, socket...) for XML. 762 * 763 * if stat is not available on the target machine, 764 * returns 1. if stat fails, returns 0 (if calling 765 * stat on the filename fails, it can't be right). 766 * if stat succeeds and the file is a directory, 767 * returns 2. otherwise returns 1. 768 */ 769 770 int 771 xmlCheckFilename (const char *path) 772 { 773 #ifdef HAVE_STAT 774 struct stat stat_buffer; 775 #endif 776 if (path == NULL) 777 return(0); 778 779 #ifdef HAVE_STAT 780 #if defined(_WIN32) || defined (__DJGPP__) && !defined (__CYGWIN__) 781 /* 782 * On Windows stat and wstat do not work with long pathname, 783 * which start with '\\?\' 784 */ 785 if ((path[0] == '\\') && (path[1] == '\\') && (path[2] == '?') && 786 (path[3] == '\\') ) 787 return 1; 788 789 if (xmlWrapStat(path, &stat_buffer) == -1) 790 return 0; 791 #else 792 if (stat(path, &stat_buffer) == -1) 793 return 0; 794 #endif 795 #ifdef S_ISDIR 796 if (S_ISDIR(stat_buffer.st_mode)) 797 return 2; 798 #endif 799 #endif /* HAVE_STAT */ 800 return 1; 801 } 802 803 /** 804 * xmlNop: 805 * 806 * No Operation function, does nothing, no input 807 * 808 * Returns zero 809 */ 810 int 811 xmlNop(void) { 812 return(0); 813 } 814 815 /** 816 * xmlFdRead: 817 * @context: the I/O context 818 * @buffer: where to drop data 819 * @len: number of bytes to read 820 * 821 * Read @len bytes to @buffer from the I/O channel. 822 * 823 * Returns the number of bytes written 824 */ 825 static int 826 xmlFdRead (void * context, char * buffer, int len) { 827 int ret; 828 829 ret = read((int) (long) context, &buffer[0], len); 830 if (ret < 0) xmlIOErr(0, "read()"); 831 return(ret); 832 } 833 834 #ifdef LIBXML_OUTPUT_ENABLED 835 /** 836 * xmlFdWrite: 837 * @context: the I/O context 838 * @buffer: where to get data 839 * @len: number of bytes to write 840 * 841 * Write @len bytes from @buffer to the I/O channel. 842 * 843 * Returns the number of bytes written 844 */ 845 static int 846 xmlFdWrite (void * context, const char * buffer, int len) { 847 int ret = 0; 848 849 if (len > 0) { 850 ret = write((int) (long) context, &buffer[0], len); 851 if (ret < 0) xmlIOErr(0, "write()"); 852 } 853 return(ret); 854 } 855 #endif /* LIBXML_OUTPUT_ENABLED */ 856 857 /** 858 * xmlFdClose: 859 * @context: the I/O context 860 * 861 * Close an I/O channel 862 * 863 * Returns 0 in case of success and error code otherwise 864 */ 865 static int 866 xmlFdClose (void * context) { 867 int ret; 868 ret = close((int) (long) context); 869 if (ret < 0) xmlIOErr(0, "close()"); 870 return(ret); 871 } 872 873 /** 874 * xmlFileMatch: 875 * @filename: the URI for matching 876 * 877 * input from FILE * 878 * 879 * Returns 1 if matches, 0 otherwise 880 */ 881 int 882 xmlFileMatch (const char *filename ATTRIBUTE_UNUSED) { 883 return(1); 884 } 885 886 /** 887 * xmlFileOpen_real: 888 * @filename: the URI for matching 889 * 890 * input from FILE *, supports compressed input 891 * if @filename is " " then the standard input is used 892 * 893 * Returns an I/O context or NULL in case of error 894 */ 895 static void * 896 xmlFileOpen_real (const char *filename) { 897 const char *path = filename; 898 FILE *fd; 899 900 if (filename == NULL) 901 return(NULL); 902 903 if (!strcmp(filename, "-")) { 904 fd = stdin; 905 return((void *) fd); 906 } 907 908 if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file://localhost/", 17)) { 909 #if defined (_WIN32) || defined (__DJGPP__) && !defined(__CYGWIN__) 910 path = &filename[17]; 911 #else 912 path = &filename[16]; 913 #endif 914 } else if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file:///", 8)) { 915 #if defined (_WIN32) || defined (__DJGPP__) && !defined(__CYGWIN__) 916 path = &filename[8]; 917 #else 918 path = &filename[7]; 919 #endif 920 } else if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file:/", 6)) { 921 /* lots of generators seems to lazy to read RFC 1738 */ 922 #if defined (_WIN32) || defined (__DJGPP__) && !defined(__CYGWIN__) 923 path = &filename[6]; 924 #else 925 path = &filename[5]; 926 #endif 927 } 928 929 if (!xmlCheckFilename(path)) 930 return(NULL); 931 932 #if defined(_WIN32) || defined (__DJGPP__) && !defined (__CYGWIN__) 933 fd = xmlWrapOpen(path, 0); 934 #else 935 fd = fopen(path, "r"); 936 #endif /* WIN32 */ 937 if (fd == NULL) xmlIOErr(0, path); 938 return((void *) fd); 939 } 940 941 /** 942 * xmlFileOpen: 943 * @filename: the URI for matching 944 * 945 * Wrapper around xmlFileOpen_real that try it with an unescaped 946 * version of @filename, if this fails fallback to @filename 947 * 948 * Returns a handler or NULL in case or failure 949 */ 950 void * 951 xmlFileOpen (const char *filename) { 952 char *unescaped; 953 void *retval; 954 955 retval = xmlFileOpen_real(filename); 956 if (retval == NULL) { 957 unescaped = xmlURIUnescapeString(filename, 0, NULL); 958 if (unescaped != NULL) { 959 retval = xmlFileOpen_real(unescaped); 960 xmlFree(unescaped); 961 } 962 } 963 964 return retval; 965 } 966 967 #ifdef LIBXML_OUTPUT_ENABLED 968 /** 969 * xmlFileOpenW: 970 * @filename: the URI for matching 971 * 972 * output to from FILE *, 973 * if @filename is "-" then the standard output is used 974 * 975 * Returns an I/O context or NULL in case of error 976 */ 977 static void * 978 xmlFileOpenW (const char *filename) { 979 const char *path = NULL; 980 FILE *fd; 981 982 if (!strcmp(filename, "-")) { 983 fd = stdout; 984 return((void *) fd); 985 } 986 987 if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file://localhost/", 17)) 988 #if defined (_WIN32) || defined (__DJGPP__) && !defined(__CYGWIN__) 989 path = &filename[17]; 990 #else 991 path = &filename[16]; 992 #endif 993 else if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file:///", 8)) { 994 #if defined (_WIN32) || defined (__DJGPP__) && !defined(__CYGWIN__) 995 path = &filename[8]; 996 #else 997 path = &filename[7]; 998 #endif 999 } else 1000 path = filename; 1001 1002 if (path == NULL) 1003 return(NULL); 1004 1005 #if defined(_WIN32) || defined (__DJGPP__) && !defined (__CYGWIN__) 1006 fd = xmlWrapOpen(path, 1); 1007 #else 1008 fd = fopen(path, "wb"); 1009 #endif /* WIN32 */ 1010 1011 if (fd == NULL) xmlIOErr(0, path); 1012 return((void *) fd); 1013 } 1014 #endif /* LIBXML_OUTPUT_ENABLED */ 1015 1016 /** 1017 * xmlFileRead: 1018 * @context: the I/O context 1019 * @buffer: where to drop data 1020 * @len: number of bytes to write 1021 * 1022 * Read @len bytes to @buffer from the I/O channel. 1023 * 1024 * Returns the number of bytes written or < 0 in case of failure 1025 */ 1026 int 1027 xmlFileRead (void * context, char * buffer, int len) { 1028 int ret; 1029 if ((context == NULL) || (buffer == NULL)) 1030 return(-1); 1031 ret = fread(&buffer[0], 1, len, (FILE *) context); 1032 if (ret < 0) xmlIOErr(0, "fread()"); 1033 return(ret); 1034 } 1035 1036 #ifdef LIBXML_OUTPUT_ENABLED 1037 /** 1038 * xmlFileWrite: 1039 * @context: the I/O context 1040 * @buffer: where to drop data 1041 * @len: number of bytes to write 1042 * 1043 * Write @len bytes from @buffer to the I/O channel. 1044 * 1045 * Returns the number of bytes written 1046 */ 1047 static int 1048 xmlFileWrite (void * context, const char * buffer, int len) { 1049 int items; 1050 1051 if ((context == NULL) || (buffer == NULL)) 1052 return(-1); 1053 items = fwrite(&buffer[0], len, 1, (FILE *) context); 1054 if ((items == 0) && (ferror((FILE *) context))) { 1055 xmlIOErr(0, "fwrite()"); 1056 return(-1); 1057 } 1058 return(items * len); 1059 } 1060 #endif /* LIBXML_OUTPUT_ENABLED */ 1061 1062 /** 1063 * xmlFileClose: 1064 * @context: the I/O context 1065 * 1066 * Close an I/O channel 1067 * 1068 * Returns 0 or -1 in case of error 1069 */ 1070 int 1071 xmlFileClose (void * context) { 1072 FILE *fil; 1073 int ret; 1074 1075 if (context == NULL) 1076 return(-1); 1077 fil = (FILE *) context; 1078 if ((fil == stdout) || (fil == stderr)) { 1079 ret = fflush(fil); 1080 if (ret < 0) 1081 xmlIOErr(0, "fflush()"); 1082 return(0); 1083 } 1084 if (fil == stdin) 1085 return(0); 1086 ret = ( fclose((FILE *) context) == EOF ) ? -1 : 0; 1087 if (ret < 0) 1088 xmlIOErr(0, "fclose()"); 1089 return(ret); 1090 } 1091 1092 /** 1093 * xmlFileFlush: 1094 * @context: the I/O context 1095 * 1096 * Flush an I/O channel 1097 */ 1098 static int 1099 xmlFileFlush (void * context) { 1100 int ret; 1101 1102 if (context == NULL) 1103 return(-1); 1104 ret = ( fflush((FILE *) context) == EOF ) ? -1 : 0; 1105 if (ret < 0) 1106 xmlIOErr(0, "fflush()"); 1107 return(ret); 1108 } 1109 1110 #ifdef LIBXML_OUTPUT_ENABLED 1111 /** 1112 * xmlBufferWrite: 1113 * @context: the xmlBuffer 1114 * @buffer: the data to write 1115 * @len: number of bytes to write 1116 * 1117 * Write @len bytes from @buffer to the xml buffer 1118 * 1119 * Returns the number of bytes written 1120 */ 1121 static int 1122 xmlBufferWrite (void * context, const char * buffer, int len) { 1123 int ret; 1124 1125 ret = xmlBufferAdd((xmlBufferPtr) context, (const xmlChar *) buffer, len); 1126 if (ret != 0) 1127 return(-1); 1128 return(len); 1129 } 1130 #endif 1131 1132 #ifdef HAVE_ZLIB_H 1133 /************************************************************************ 1134 * * 1135 * I/O for compressed file accesses * 1136 * * 1137 ************************************************************************/ 1138 /** 1139 * xmlGzfileMatch: 1140 * @filename: the URI for matching 1141 * 1142 * input from compressed file test 1143 * 1144 * Returns 1 if matches, 0 otherwise 1145 */ 1146 static int 1147 xmlGzfileMatch (const char *filename ATTRIBUTE_UNUSED) { 1148 return(1); 1149 } 1150 1151 /** 1152 * xmlGzfileOpen_real: 1153 * @filename: the URI for matching 1154 * 1155 * input from compressed file open 1156 * if @filename is " " then the standard input is used 1157 * 1158 * Returns an I/O context or NULL in case of error 1159 */ 1160 static void * 1161 xmlGzfileOpen_real (const char *filename) { 1162 const char *path = NULL; 1163 gzFile fd; 1164 1165 if (!strcmp(filename, "-")) { 1166 int duped_fd = dup(fileno(stdin)); 1167 fd = gzdopen(duped_fd, "rb"); 1168 if (fd == Z_NULL && duped_fd >= 0) { 1169 close(duped_fd); /* gzdOpen() does not close on failure */ 1170 } 1171 1172 return((void *) fd); 1173 } 1174 1175 if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file://localhost/", 17)) 1176 #if defined (_WIN32) || defined (__DJGPP__) && !defined(__CYGWIN__) 1177 path = &filename[17]; 1178 #else 1179 path = &filename[16]; 1180 #endif 1181 else if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file:///", 8)) { 1182 #if defined (_WIN32) || defined (__DJGPP__) && !defined(__CYGWIN__) 1183 path = &filename[8]; 1184 #else 1185 path = &filename[7]; 1186 #endif 1187 } else 1188 path = filename; 1189 1190 if (path == NULL) 1191 return(NULL); 1192 if (!xmlCheckFilename(path)) 1193 return(NULL); 1194 1195 #if defined(_WIN32) || defined (__DJGPP__) && !defined (__CYGWIN__) 1196 fd = xmlWrapGzOpen(path, "rb"); 1197 #else 1198 fd = gzopen(path, "rb"); 1199 #endif 1200 return((void *) fd); 1201 } 1202 1203 /** 1204 * xmlGzfileOpen: 1205 * @filename: the URI for matching 1206 * 1207 * Wrapper around xmlGzfileOpen if the open fais, it will 1208 * try to unescape @filename 1209 */ 1210 static void * 1211 xmlGzfileOpen (const char *filename) { 1212 char *unescaped; 1213 void *retval; 1214 1215 retval = xmlGzfileOpen_real(filename); 1216 if (retval == NULL) { 1217 unescaped = xmlURIUnescapeString(filename, 0, NULL); 1218 if (unescaped != NULL) { 1219 retval = xmlGzfileOpen_real(unescaped); 1220 } 1221 xmlFree(unescaped); 1222 } 1223 return retval; 1224 } 1225 1226 #ifdef LIBXML_OUTPUT_ENABLED 1227 /** 1228 * xmlGzfileOpenW: 1229 * @filename: the URI for matching 1230 * @compression: the compression factor (0 - 9 included) 1231 * 1232 * input from compressed file open 1233 * if @filename is " " then the standard input is used 1234 * 1235 * Returns an I/O context or NULL in case of error 1236 */ 1237 static void * 1238 xmlGzfileOpenW (const char *filename, int compression) { 1239 const char *path = NULL; 1240 char mode[15]; 1241 gzFile fd; 1242 1243 snprintf(mode, sizeof(mode), "wb%d", compression); 1244 if (!strcmp(filename, "-")) { 1245 int duped_fd = dup(fileno(stdout)); 1246 fd = gzdopen(duped_fd, "rb"); 1247 if (fd == Z_NULL && duped_fd >= 0) { 1248 close(duped_fd); /* gzdOpen() does not close on failure */ 1249 } 1250 1251 return((void *) fd); 1252 } 1253 1254 if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file://localhost/", 17)) 1255 #if defined (_WIN32) || defined (__DJGPP__) && !defined(__CYGWIN__) 1256 path = &filename[17]; 1257 #else 1258 path = &filename[16]; 1259 #endif 1260 else if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file:///", 8)) { 1261 #if defined (_WIN32) || defined (__DJGPP__) && !defined(__CYGWIN__) 1262 path = &filename[8]; 1263 #else 1264 path = &filename[7]; 1265 #endif 1266 } else 1267 path = filename; 1268 1269 if (path == NULL) 1270 return(NULL); 1271 1272 #if defined(_WIN32) || defined (__DJGPP__) && !defined (__CYGWIN__) 1273 fd = xmlWrapGzOpen(path, mode); 1274 #else 1275 fd = gzopen(path, mode); 1276 #endif 1277 return((void *) fd); 1278 } 1279 #endif /* LIBXML_OUTPUT_ENABLED */ 1280 1281 /** 1282 * xmlGzfileRead: 1283 * @context: the I/O context 1284 * @buffer: where to drop data 1285 * @len: number of bytes to write 1286 * 1287 * Read @len bytes to @buffer from the compressed I/O channel. 1288 * 1289 * Returns the number of bytes written 1290 */ 1291 static int 1292 xmlGzfileRead (void * context, char * buffer, int len) { 1293 int ret; 1294 1295 ret = gzread((gzFile) context, &buffer[0], len); 1296 if (ret < 0) xmlIOErr(0, "gzread()"); 1297 return(ret); 1298 } 1299 1300 #ifdef LIBXML_OUTPUT_ENABLED 1301 /** 1302 * xmlGzfileWrite: 1303 * @context: the I/O context 1304 * @buffer: where to drop data 1305 * @len: number of bytes to write 1306 * 1307 * Write @len bytes from @buffer to the compressed I/O channel. 1308 * 1309 * Returns the number of bytes written 1310 */ 1311 static int 1312 xmlGzfileWrite (void * context, const char * buffer, int len) { 1313 int ret; 1314 1315 ret = gzwrite((gzFile) context, (char *) &buffer[0], len); 1316 if (ret < 0) xmlIOErr(0, "gzwrite()"); 1317 return(ret); 1318 } 1319 #endif /* LIBXML_OUTPUT_ENABLED */ 1320 1321 /** 1322 * xmlGzfileClose: 1323 * @context: the I/O context 1324 * 1325 * Close a compressed I/O channel 1326 */ 1327 static int 1328 xmlGzfileClose (void * context) { 1329 int ret; 1330 1331 ret = (gzclose((gzFile) context) == Z_OK ) ? 0 : -1; 1332 if (ret < 0) xmlIOErr(0, "gzclose()"); 1333 return(ret); 1334 } 1335 #endif /* HAVE_ZLIB_H */ 1336 1337 #ifdef LIBXML_LZMA_ENABLED 1338 /************************************************************************ 1339 * * 1340 * I/O for compressed file accesses * 1341 * * 1342 ************************************************************************/ 1343 #include "xzlib.h" 1344 /** 1345 * xmlXzfileMatch: 1346 * @filename: the URI for matching 1347 * 1348 * input from compressed file test 1349 * 1350 * Returns 1 if matches, 0 otherwise 1351 */ 1352 static int 1353 xmlXzfileMatch (const char *filename ATTRIBUTE_UNUSED) { 1354 return(1); 1355 } 1356 1357 /** 1358 * xmlXzFileOpen_real: 1359 * @filename: the URI for matching 1360 * 1361 * input from compressed file open 1362 * if @filename is " " then the standard input is used 1363 * 1364 * Returns an I/O context or NULL in case of error 1365 */ 1366 static void * 1367 xmlXzfileOpen_real (const char *filename) { 1368 const char *path = NULL; 1369 xzFile fd; 1370 1371 if (!strcmp(filename, "-")) { 1372 fd = __libxml2_xzdopen(dup(fileno(stdin)), "rb"); 1373 return((void *) fd); 1374 } 1375 1376 if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file://localhost/", 17)) { 1377 path = &filename[16]; 1378 } else if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file:///", 8)) { 1379 path = &filename[7]; 1380 } else if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file:/", 6)) { 1381 /* lots of generators seems to lazy to read RFC 1738 */ 1382 path = &filename[5]; 1383 } else 1384 path = filename; 1385 1386 if (path == NULL) 1387 return(NULL); 1388 if (!xmlCheckFilename(path)) 1389 return(NULL); 1390 1391 fd = __libxml2_xzopen(path, "rb"); 1392 return((void *) fd); 1393 } 1394 1395 /** 1396 * xmlXzfileOpen: 1397 * @filename: the URI for matching 1398 * 1399 * Wrapper around xmlXzfileOpen_real that try it with an unescaped 1400 * version of @filename, if this fails fallback to @filename 1401 * 1402 * Returns a handler or NULL in case or failure 1403 */ 1404 static void * 1405 xmlXzfileOpen (const char *filename) { 1406 char *unescaped; 1407 void *retval; 1408 1409 retval = xmlXzfileOpen_real(filename); 1410 if (retval == NULL) { 1411 unescaped = xmlURIUnescapeString(filename, 0, NULL); 1412 if (unescaped != NULL) { 1413 retval = xmlXzfileOpen_real(unescaped); 1414 } 1415 xmlFree(unescaped); 1416 } 1417 1418 return retval; 1419 } 1420 1421 /** 1422 * xmlXzfileRead: 1423 * @context: the I/O context 1424 * @buffer: where to drop data 1425 * @len: number of bytes to write 1426 * 1427 * Read @len bytes to @buffer from the compressed I/O channel. 1428 * 1429 * Returns the number of bytes written 1430 */ 1431 static int 1432 xmlXzfileRead (void * context, char * buffer, int len) { 1433 int ret; 1434 1435 ret = __libxml2_xzread((xzFile) context, &buffer[0], len); 1436 if (ret < 0) xmlIOErr(0, "xzread()"); 1437 return(ret); 1438 } 1439 1440 /** 1441 * xmlXzfileClose: 1442 * @context: the I/O context 1443 * 1444 * Close a compressed I/O channel 1445 */ 1446 static int 1447 xmlXzfileClose (void * context) { 1448 int ret; 1449 1450 ret = (__libxml2_xzclose((xzFile) context) == LZMA_OK ) ? 0 : -1; 1451 if (ret < 0) xmlIOErr(0, "xzclose()"); 1452 return(ret); 1453 } 1454 #endif /* LIBXML_LZMA_ENABLED */ 1455 1456 #ifdef LIBXML_HTTP_ENABLED 1457 /************************************************************************ 1458 * * 1459 * I/O for HTTP file accesses * 1460 * * 1461 ************************************************************************/ 1462 1463 #ifdef LIBXML_OUTPUT_ENABLED 1464 typedef struct xmlIOHTTPWriteCtxt_ 1465 { 1466 int compression; 1467 1468 char * uri; 1469 1470 void * doc_buff; 1471 1472 } xmlIOHTTPWriteCtxt, *xmlIOHTTPWriteCtxtPtr; 1473 1474 #ifdef HAVE_ZLIB_H 1475 1476 #define DFLT_WBITS ( -15 ) 1477 #define DFLT_MEM_LVL ( 8 ) 1478 #define GZ_MAGIC1 ( 0x1f ) 1479 #define GZ_MAGIC2 ( 0x8b ) 1480 #define LXML_ZLIB_OS_CODE ( 0x03 ) 1481 #define INIT_HTTP_BUFF_SIZE ( 32768 ) 1482 #define DFLT_ZLIB_RATIO ( 5 ) 1483 1484 /* 1485 ** Data structure and functions to work with sending compressed data 1486 ** via HTTP. 1487 */ 1488 1489 typedef struct xmlZMemBuff_ 1490 { 1491 unsigned long size; 1492 unsigned long crc; 1493 1494 unsigned char * zbuff; 1495 z_stream zctrl; 1496 1497 } xmlZMemBuff, *xmlZMemBuffPtr; 1498 1499 /** 1500 * append_reverse_ulong 1501 * @buff: Compressed memory buffer 1502 * @data: Unsigned long to append 1503 * 1504 * Append a unsigned long in reverse byte order to the end of the 1505 * memory buffer. 1506 */ 1507 static void 1508 append_reverse_ulong( xmlZMemBuff * buff, unsigned long data ) { 1509 1510 int idx; 1511 1512 if ( buff == NULL ) 1513 return; 1514 1515 /* 1516 ** This is plagiarized from putLong in gzio.c (zlib source) where 1517 ** the number "4" is hardcoded. If zlib is ever patched to 1518 ** support 64 bit file sizes, this code would need to be patched 1519 ** as well. 1520 */ 1521 1522 for ( idx = 0; idx < 4; idx++ ) { 1523 *buff->zctrl.next_out = ( data & 0xff ); 1524 data >>= 8; 1525 buff->zctrl.next_out++; 1526 } 1527 1528 return; 1529 } 1530 1531 /** 1532 * 1533 * xmlFreeZMemBuff 1534 * @buff: The memory buffer context to clear 1535 * 1536 * Release all the resources associated with the compressed memory buffer. 1537 */ 1538 static void 1539 xmlFreeZMemBuff( xmlZMemBuffPtr buff ) { 1540 1541 #ifdef DEBUG_HTTP 1542 int z_err; 1543 #endif 1544 1545 if ( buff == NULL ) 1546 return; 1547 1548 xmlFree( buff->zbuff ); 1549 #ifdef DEBUG_HTTP 1550 z_err = deflateEnd( &buff->zctrl ); 1551 if ( z_err != Z_OK ) 1552 xmlGenericError( xmlGenericErrorContext, 1553 "xmlFreeZMemBuff: Error releasing zlib context: %d\n", 1554 z_err ); 1555 #else 1556 deflateEnd( &buff->zctrl ); 1557 #endif 1558 1559 xmlFree( buff ); 1560 return; 1561 } 1562 1563 /** 1564 * xmlCreateZMemBuff 1565 *@compression: Compression value to use 1566 * 1567 * Create a memory buffer to hold the compressed XML document. The 1568 * compressed document in memory will end up being identical to what 1569 * would be created if gzopen/gzwrite/gzclose were being used to 1570 * write the document to disk. The code for the header/trailer data to 1571 * the compression is plagiarized from the zlib source files. 1572 */ 1573 static void * 1574 xmlCreateZMemBuff( int compression ) { 1575 1576 int z_err; 1577 int hdr_lgth; 1578 xmlZMemBuffPtr buff = NULL; 1579 1580 if ( ( compression < 1 ) || ( compression > 9 ) ) 1581 return ( NULL ); 1582 1583 /* Create the control and data areas */ 1584 1585 buff = xmlMalloc( sizeof( xmlZMemBuff ) ); 1586 if ( buff == NULL ) { 1587 xmlIOErrMemory("creating buffer context"); 1588 return ( NULL ); 1589 } 1590 1591 (void)memset( buff, 0, sizeof( xmlZMemBuff ) ); 1592 buff->size = INIT_HTTP_BUFF_SIZE; 1593 buff->zbuff = xmlMalloc( buff->size ); 1594 if ( buff->zbuff == NULL ) { 1595 xmlFreeZMemBuff( buff ); 1596 xmlIOErrMemory("creating buffer"); 1597 return ( NULL ); 1598 } 1599 1600 z_err = deflateInit2( &buff->zctrl, compression, Z_DEFLATED, 1601 DFLT_WBITS, DFLT_MEM_LVL, Z_DEFAULT_STRATEGY ); 1602 if ( z_err != Z_OK ) { 1603 xmlChar msg[500]; 1604 xmlFreeZMemBuff( buff ); 1605 buff = NULL; 1606 xmlStrPrintf(msg, 500, 1607 "xmlCreateZMemBuff: %s %d\n", 1608 "Error initializing compression context. ZLIB error:", 1609 z_err ); 1610 xmlIOErr(XML_IO_WRITE, (const char *) msg); 1611 return ( NULL ); 1612 } 1613 1614 /* Set the header data. The CRC will be needed for the trailer */ 1615 buff->crc = crc32( 0L, NULL, 0 ); 1616 hdr_lgth = snprintf( (char *)buff->zbuff, buff->size, 1617 "%c%c%c%c%c%c%c%c%c%c", 1618 GZ_MAGIC1, GZ_MAGIC2, Z_DEFLATED, 1619 0, 0, 0, 0, 0, 0, LXML_ZLIB_OS_CODE ); 1620 buff->zctrl.next_out = buff->zbuff + hdr_lgth; 1621 buff->zctrl.avail_out = buff->size - hdr_lgth; 1622 1623 return ( buff ); 1624 } 1625 1626 /** 1627 * xmlZMemBuffExtend 1628 * @buff: Buffer used to compress and consolidate data. 1629 * @ext_amt: Number of bytes to extend the buffer. 1630 * 1631 * Extend the internal buffer used to store the compressed data by the 1632 * specified amount. 1633 * 1634 * Returns 0 on success or -1 on failure to extend the buffer. On failure 1635 * the original buffer still exists at the original size. 1636 */ 1637 static int 1638 xmlZMemBuffExtend( xmlZMemBuffPtr buff, size_t ext_amt ) { 1639 1640 int rc = -1; 1641 size_t new_size; 1642 size_t cur_used; 1643 1644 unsigned char * tmp_ptr = NULL; 1645 1646 if ( buff == NULL ) 1647 return ( -1 ); 1648 1649 else if ( ext_amt == 0 ) 1650 return ( 0 ); 1651 1652 cur_used = buff->zctrl.next_out - buff->zbuff; 1653 new_size = buff->size + ext_amt; 1654 1655 #ifdef DEBUG_HTTP 1656 if ( cur_used > new_size ) 1657 xmlGenericError( xmlGenericErrorContext, 1658 "xmlZMemBuffExtend: %s\n%s %d bytes.\n", 1659 "Buffer overwrite detected during compressed memory", 1660 "buffer extension. Overflowed by", 1661 (cur_used - new_size ) ); 1662 #endif 1663 1664 tmp_ptr = xmlRealloc( buff->zbuff, new_size ); 1665 if ( tmp_ptr != NULL ) { 1666 rc = 0; 1667 buff->size = new_size; 1668 buff->zbuff = tmp_ptr; 1669 buff->zctrl.next_out = tmp_ptr + cur_used; 1670 buff->zctrl.avail_out = new_size - cur_used; 1671 } 1672 else { 1673 xmlChar msg[500]; 1674 xmlStrPrintf(msg, 500, 1675 "xmlZMemBuffExtend: %s %lu bytes.\n", 1676 "Allocation failure extending output buffer to", 1677 new_size ); 1678 xmlIOErr(XML_IO_WRITE, (const char *) msg); 1679 } 1680 1681 return ( rc ); 1682 } 1683 1684 /** 1685 * xmlZMemBuffAppend 1686 * @buff: Buffer used to compress and consolidate data 1687 * @src: Uncompressed source content to append to buffer 1688 * @len: Length of source data to append to buffer 1689 * 1690 * Compress and append data to the internal buffer. The data buffer 1691 * will be expanded if needed to store the additional data. 1692 * 1693 * Returns the number of bytes appended to the buffer or -1 on error. 1694 */ 1695 static int 1696 xmlZMemBuffAppend( xmlZMemBuffPtr buff, const char * src, int len ) { 1697 1698 int z_err; 1699 size_t min_accept; 1700 1701 if ( ( buff == NULL ) || ( src == NULL ) ) 1702 return ( -1 ); 1703 1704 buff->zctrl.avail_in = len; 1705 buff->zctrl.next_in = (unsigned char *)src; 1706 while ( buff->zctrl.avail_in > 0 ) { 1707 /* 1708 ** Extend the buffer prior to deflate call if a reasonable amount 1709 ** of output buffer space is not available. 1710 */ 1711 min_accept = buff->zctrl.avail_in / DFLT_ZLIB_RATIO; 1712 if ( buff->zctrl.avail_out <= min_accept ) { 1713 if ( xmlZMemBuffExtend( buff, buff->size ) == -1 ) 1714 return ( -1 ); 1715 } 1716 1717 z_err = deflate( &buff->zctrl, Z_NO_FLUSH ); 1718 if ( z_err != Z_OK ) { 1719 xmlChar msg[500]; 1720 xmlStrPrintf(msg, 500, 1721 "xmlZMemBuffAppend: %s %d %s - %d", 1722 "Compression error while appending", 1723 len, "bytes to buffer. ZLIB error", z_err ); 1724 xmlIOErr(XML_IO_WRITE, (const char *) msg); 1725 return ( -1 ); 1726 } 1727 } 1728 1729 buff->crc = crc32( buff->crc, (unsigned char *)src, len ); 1730 1731 return ( len ); 1732 } 1733 1734 /** 1735 * xmlZMemBuffGetContent 1736 * @buff: Compressed memory content buffer 1737 * @data_ref: Pointer reference to point to compressed content 1738 * 1739 * Flushes the compression buffers, appends gzip file trailers and 1740 * returns the compressed content and length of the compressed data. 1741 * NOTE: The gzip trailer code here is plagiarized from zlib source. 1742 * 1743 * Returns the length of the compressed data or -1 on error. 1744 */ 1745 static int 1746 xmlZMemBuffGetContent( xmlZMemBuffPtr buff, char ** data_ref ) { 1747 1748 int zlgth = -1; 1749 int z_err; 1750 1751 if ( ( buff == NULL ) || ( data_ref == NULL ) ) 1752 return ( -1 ); 1753 1754 /* Need to loop until compression output buffers are flushed */ 1755 1756 do 1757 { 1758 z_err = deflate( &buff->zctrl, Z_FINISH ); 1759 if ( z_err == Z_OK ) { 1760 /* In this case Z_OK means more buffer space needed */ 1761 1762 if ( xmlZMemBuffExtend( buff, buff->size ) == -1 ) 1763 return ( -1 ); 1764 } 1765 } 1766 while ( z_err == Z_OK ); 1767 1768 /* If the compression state is not Z_STREAM_END, some error occurred */ 1769 1770 if ( z_err == Z_STREAM_END ) { 1771 1772 /* Need to append the gzip data trailer */ 1773 1774 if ( buff->zctrl.avail_out < ( 2 * sizeof( unsigned long ) ) ) { 1775 if ( xmlZMemBuffExtend(buff, (2 * sizeof(unsigned long))) == -1 ) 1776 return ( -1 ); 1777 } 1778 1779 /* 1780 ** For whatever reason, the CRC and length data are pushed out 1781 ** in reverse byte order. So a memcpy can't be used here. 1782 */ 1783 1784 append_reverse_ulong( buff, buff->crc ); 1785 append_reverse_ulong( buff, buff->zctrl.total_in ); 1786 1787 zlgth = buff->zctrl.next_out - buff->zbuff; 1788 *data_ref = (char *)buff->zbuff; 1789 } 1790 1791 else { 1792 xmlChar msg[500]; 1793 xmlStrPrintf(msg, 500, 1794 "xmlZMemBuffGetContent: %s - %d\n", 1795 "Error flushing zlib buffers. Error code", z_err ); 1796 xmlIOErr(XML_IO_WRITE, (const char *) msg); 1797 } 1798 1799 return ( zlgth ); 1800 } 1801 #endif /* LIBXML_OUTPUT_ENABLED */ 1802 #endif /* HAVE_ZLIB_H */ 1803 1804 #ifdef LIBXML_OUTPUT_ENABLED 1805 /** 1806 * xmlFreeHTTPWriteCtxt 1807 * @ctxt: Context to cleanup 1808 * 1809 * Free allocated memory and reclaim system resources. 1810 * 1811 * No return value. 1812 */ 1813 static void 1814 xmlFreeHTTPWriteCtxt( xmlIOHTTPWriteCtxtPtr ctxt ) 1815 { 1816 if ( ctxt->uri != NULL ) 1817 xmlFree( ctxt->uri ); 1818 1819 if ( ctxt->doc_buff != NULL ) { 1820 1821 #ifdef HAVE_ZLIB_H 1822 if ( ctxt->compression > 0 ) { 1823 xmlFreeZMemBuff( ctxt->doc_buff ); 1824 } 1825 else 1826 #endif 1827 { 1828 xmlOutputBufferClose( ctxt->doc_buff ); 1829 } 1830 } 1831 1832 xmlFree( ctxt ); 1833 return; 1834 } 1835 #endif /* LIBXML_OUTPUT_ENABLED */ 1836 1837 1838 /** 1839 * xmlIOHTTPMatch: 1840 * @filename: the URI for matching 1841 * 1842 * check if the URI matches an HTTP one 1843 * 1844 * Returns 1 if matches, 0 otherwise 1845 */ 1846 int 1847 xmlIOHTTPMatch (const char *filename) { 1848 if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "http://", 7)) 1849 return(1); 1850 return(0); 1851 } 1852 1853 /** 1854 * xmlIOHTTPOpen: 1855 * @filename: the URI for matching 1856 * 1857 * open an HTTP I/O channel 1858 * 1859 * Returns an I/O context or NULL in case of error 1860 */ 1861 void * 1862 xmlIOHTTPOpen (const char *filename) { 1863 return(xmlNanoHTTPOpen(filename, NULL)); 1864 } 1865 1866 #ifdef LIBXML_OUTPUT_ENABLED 1867 /** 1868 * xmlIOHTTPOpenW: 1869 * @post_uri: The destination URI for the document 1870 * @compression: The compression desired for the document. 1871 * 1872 * Open a temporary buffer to collect the document for a subsequent HTTP POST 1873 * request. Non-static as is called from the output buffer creation routine. 1874 * 1875 * Returns an I/O context or NULL in case of error. 1876 */ 1877 1878 void * 1879 xmlIOHTTPOpenW(const char *post_uri, int compression) 1880 { 1881 1882 xmlIOHTTPWriteCtxtPtr ctxt = NULL; 1883 1884 if (post_uri == NULL) 1885 return (NULL); 1886 1887 ctxt = xmlMalloc(sizeof(xmlIOHTTPWriteCtxt)); 1888 if (ctxt == NULL) { 1889 xmlIOErrMemory("creating HTTP output context"); 1890 return (NULL); 1891 } 1892 1893 (void) memset(ctxt, 0, sizeof(xmlIOHTTPWriteCtxt)); 1894 1895 ctxt->uri = (char *) xmlStrdup((const xmlChar *)post_uri); 1896 if (ctxt->uri == NULL) { 1897 xmlIOErrMemory("copying URI"); 1898 xmlFreeHTTPWriteCtxt(ctxt); 1899 return (NULL); 1900 } 1901 1902 /* 1903 * ** Since the document length is required for an HTTP post, 1904 * ** need to put the document into a buffer. A memory buffer 1905 * ** is being used to avoid pushing the data to disk and back. 1906 */ 1907 1908 #ifdef HAVE_ZLIB_H 1909 if ((compression > 0) && (compression <= 9)) { 1910 1911 ctxt->compression = compression; 1912 ctxt->doc_buff = xmlCreateZMemBuff(compression); 1913 } else 1914 #endif 1915 { 1916 /* Any character conversions should have been done before this */ 1917 1918 ctxt->doc_buff = xmlAllocOutputBufferInternal(NULL); 1919 } 1920 1921 if (ctxt->doc_buff == NULL) { 1922 xmlFreeHTTPWriteCtxt(ctxt); 1923 ctxt = NULL; 1924 } 1925 1926 return (ctxt); 1927 } 1928 #endif /* LIBXML_OUTPUT_ENABLED */ 1929 1930 #ifdef LIBXML_OUTPUT_ENABLED 1931 /** 1932 * xmlIOHTTPDfltOpenW 1933 * @post_uri: The destination URI for this document. 1934 * 1935 * Calls xmlIOHTTPOpenW with no compression to set up for a subsequent 1936 * HTTP post command. This function should generally not be used as 1937 * the open callback is short circuited in xmlOutputBufferCreateFile. 1938 * 1939 * Returns a pointer to the new IO context. 1940 */ 1941 static void * 1942 xmlIOHTTPDfltOpenW( const char * post_uri ) { 1943 return ( xmlIOHTTPOpenW( post_uri, 0 ) ); 1944 } 1945 #endif /* LIBXML_OUTPUT_ENABLED */ 1946 1947 /** 1948 * xmlIOHTTPRead: 1949 * @context: the I/O context 1950 * @buffer: where to drop data 1951 * @len: number of bytes to write 1952 * 1953 * Read @len bytes to @buffer from the I/O channel. 1954 * 1955 * Returns the number of bytes written 1956 */ 1957 int 1958 xmlIOHTTPRead(void * context, char * buffer, int len) { 1959 if ((buffer == NULL) || (len < 0)) return(-1); 1960 return(xmlNanoHTTPRead(context, &buffer[0], len)); 1961 } 1962 1963 #ifdef LIBXML_OUTPUT_ENABLED 1964 /** 1965 * xmlIOHTTPWrite 1966 * @context: previously opened writing context 1967 * @buffer: data to output to temporary buffer 1968 * @len: bytes to output 1969 * 1970 * Collect data from memory buffer into a temporary file for later 1971 * processing. 1972 * 1973 * Returns number of bytes written. 1974 */ 1975 1976 static int 1977 xmlIOHTTPWrite( void * context, const char * buffer, int len ) { 1978 1979 xmlIOHTTPWriteCtxtPtr ctxt = context; 1980 1981 if ( ( ctxt == NULL ) || ( ctxt->doc_buff == NULL ) || ( buffer == NULL ) ) 1982 return ( -1 ); 1983 1984 if ( len > 0 ) { 1985 1986 /* Use gzwrite or fwrite as previously setup in the open call */ 1987 1988 #ifdef HAVE_ZLIB_H 1989 if ( ctxt->compression > 0 ) 1990 len = xmlZMemBuffAppend( ctxt->doc_buff, buffer, len ); 1991 1992 else 1993 #endif 1994 len = xmlOutputBufferWrite( ctxt->doc_buff, len, buffer ); 1995 1996 if ( len < 0 ) { 1997 xmlChar msg[500]; 1998 xmlStrPrintf(msg, 500, 1999 "xmlIOHTTPWrite: %s\n%s '%s'.\n", 2000 "Error appending to internal buffer.", 2001 "Error sending document to URI", 2002 ctxt->uri ); 2003 xmlIOErr(XML_IO_WRITE, (const char *) msg); 2004 } 2005 } 2006 2007 return ( len ); 2008 } 2009 #endif /* LIBXML_OUTPUT_ENABLED */ 2010 2011 2012 /** 2013 * xmlIOHTTPClose: 2014 * @context: the I/O context 2015 * 2016 * Close an HTTP I/O channel 2017 * 2018 * Returns 0 2019 */ 2020 int 2021 xmlIOHTTPClose (void * context) { 2022 xmlNanoHTTPClose(context); 2023 return 0; 2024 } 2025 2026 #ifdef LIBXML_OUTPUT_ENABLED 2027 /** 2028 * xmlIOHTTCloseWrite 2029 * @context: The I/O context 2030 * @http_mthd: The HTTP method to be used when sending the data 2031 * 2032 * Close the transmit HTTP I/O channel and actually send the data. 2033 */ 2034 static int 2035 xmlIOHTTPCloseWrite( void * context, const char * http_mthd ) { 2036 2037 int close_rc = -1; 2038 int http_rtn = 0; 2039 int content_lgth = 0; 2040 xmlIOHTTPWriteCtxtPtr ctxt = context; 2041 2042 char * http_content = NULL; 2043 char * content_encoding = NULL; 2044 char * content_type = (char *) "text/xml"; 2045 void * http_ctxt = NULL; 2046 2047 if ( ( ctxt == NULL ) || ( http_mthd == NULL ) ) 2048 return ( -1 ); 2049 2050 /* Retrieve the content from the appropriate buffer */ 2051 2052 #ifdef HAVE_ZLIB_H 2053 2054 if ( ctxt->compression > 0 ) { 2055 content_lgth = xmlZMemBuffGetContent( ctxt->doc_buff, &http_content ); 2056 content_encoding = (char *) "Content-Encoding: gzip"; 2057 } 2058 else 2059 #endif 2060 { 2061 /* Pull the data out of the memory output buffer */ 2062 2063 xmlOutputBufferPtr dctxt = ctxt->doc_buff; 2064 http_content = (char *) xmlBufContent(dctxt->buffer); 2065 content_lgth = xmlBufUse(dctxt->buffer); 2066 } 2067 2068 if ( http_content == NULL ) { 2069 xmlChar msg[500]; 2070 xmlStrPrintf(msg, 500, 2071 "xmlIOHTTPCloseWrite: %s '%s' %s '%s'.\n", 2072 "Error retrieving content.\nUnable to", 2073 http_mthd, "data to URI", ctxt->uri ); 2074 xmlIOErr(XML_IO_WRITE, (const char *) msg); 2075 } 2076 2077 else { 2078 2079 http_ctxt = xmlNanoHTTPMethod( ctxt->uri, http_mthd, http_content, 2080 &content_type, content_encoding, 2081 content_lgth ); 2082 2083 if ( http_ctxt != NULL ) { 2084 #ifdef DEBUG_HTTP 2085 /* If testing/debugging - dump reply with request content */ 2086 2087 FILE * tst_file = NULL; 2088 char buffer[ 4096 ]; 2089 char * dump_name = NULL; 2090 int avail; 2091 2092 xmlGenericError( xmlGenericErrorContext, 2093 "xmlNanoHTTPCloseWrite: HTTP %s to\n%s returned %d.\n", 2094 http_mthd, ctxt->uri, 2095 xmlNanoHTTPReturnCode( http_ctxt ) ); 2096 2097 /* 2098 ** Since either content or reply may be gzipped, 2099 ** dump them to separate files instead of the 2100 ** standard error context. 2101 */ 2102 2103 dump_name = tempnam( NULL, "lxml" ); 2104 if ( dump_name != NULL ) { 2105 (void)snprintf( buffer, sizeof(buffer), "%s.content", dump_name ); 2106 2107 tst_file = fopen( buffer, "wb" ); 2108 if ( tst_file != NULL ) { 2109 xmlGenericError( xmlGenericErrorContext, 2110 "Transmitted content saved in file: %s\n", buffer ); 2111 2112 fwrite( http_content, sizeof( char ), 2113 content_lgth, tst_file ); 2114 fclose( tst_file ); 2115 } 2116 2117 (void)snprintf( buffer, sizeof(buffer), "%s.reply", dump_name ); 2118 tst_file = fopen( buffer, "wb" ); 2119 if ( tst_file != NULL ) { 2120 xmlGenericError( xmlGenericErrorContext, 2121 "Reply content saved in file: %s\n", buffer ); 2122 2123 2124 while ( (avail = xmlNanoHTTPRead( http_ctxt, 2125 buffer, sizeof( buffer ) )) > 0 ) { 2126 2127 fwrite( buffer, sizeof( char ), avail, tst_file ); 2128 } 2129 2130 fclose( tst_file ); 2131 } 2132 2133 free( dump_name ); 2134 } 2135 #endif /* DEBUG_HTTP */ 2136 2137 http_rtn = xmlNanoHTTPReturnCode( http_ctxt ); 2138 if ( ( http_rtn >= 200 ) && ( http_rtn < 300 ) ) 2139 close_rc = 0; 2140 else { 2141 xmlChar msg[500]; 2142 xmlStrPrintf(msg, 500, 2143 "xmlIOHTTPCloseWrite: HTTP '%s' of %d %s\n'%s' %s %d\n", 2144 http_mthd, content_lgth, 2145 "bytes to URI", ctxt->uri, 2146 "failed. HTTP return code:", http_rtn ); 2147 xmlIOErr(XML_IO_WRITE, (const char *) msg); 2148 } 2149 2150 xmlNanoHTTPClose( http_ctxt ); 2151 xmlFree( content_type ); 2152 } 2153 } 2154 2155 /* Final cleanups */ 2156 2157 xmlFreeHTTPWriteCtxt( ctxt ); 2158 2159 return ( close_rc ); 2160 } 2161 2162 /** 2163 * xmlIOHTTPClosePut 2164 * 2165 * @context: The I/O context 2166 * 2167 * Close the transmit HTTP I/O channel and actually send data using a PUT 2168 * HTTP method. 2169 */ 2170 static int 2171 xmlIOHTTPClosePut( void * ctxt ) { 2172 return ( xmlIOHTTPCloseWrite( ctxt, "PUT" ) ); 2173 } 2174 2175 2176 /** 2177 * xmlIOHTTPClosePost 2178 * 2179 * @context: The I/O context 2180 * 2181 * Close the transmit HTTP I/O channel and actually send data using a POST 2182 * HTTP method. 2183 */ 2184 static int 2185 xmlIOHTTPClosePost( void * ctxt ) { 2186 return ( xmlIOHTTPCloseWrite( ctxt, "POST" ) ); 2187 } 2188 #endif /* LIBXML_OUTPUT_ENABLED */ 2189 2190 #endif /* LIBXML_HTTP_ENABLED */ 2191 2192 #ifdef LIBXML_FTP_ENABLED 2193 /************************************************************************ 2194 * * 2195 * I/O for FTP file accesses * 2196 * * 2197 ************************************************************************/ 2198 /** 2199 * xmlIOFTPMatch: 2200 * @filename: the URI for matching 2201 * 2202 * check if the URI matches an FTP one 2203 * 2204 * Returns 1 if matches, 0 otherwise 2205 */ 2206 int 2207 xmlIOFTPMatch (const char *filename) { 2208 if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "ftp://", 6)) 2209 return(1); 2210 return(0); 2211 } 2212 2213 /** 2214 * xmlIOFTPOpen: 2215 * @filename: the URI for matching 2216 * 2217 * open an FTP I/O channel 2218 * 2219 * Returns an I/O context or NULL in case of error 2220 */ 2221 void * 2222 xmlIOFTPOpen (const char *filename) { 2223 return(xmlNanoFTPOpen(filename)); 2224 } 2225 2226 /** 2227 * xmlIOFTPRead: 2228 * @context: the I/O context 2229 * @buffer: where to drop data 2230 * @len: number of bytes to write 2231 * 2232 * Read @len bytes to @buffer from the I/O channel. 2233 * 2234 * Returns the number of bytes written 2235 */ 2236 int 2237 xmlIOFTPRead(void * context, char * buffer, int len) { 2238 if ((buffer == NULL) || (len < 0)) return(-1); 2239 return(xmlNanoFTPRead(context, &buffer[0], len)); 2240 } 2241 2242 /** 2243 * xmlIOFTPClose: 2244 * @context: the I/O context 2245 * 2246 * Close an FTP I/O channel 2247 * 2248 * Returns 0 2249 */ 2250 int 2251 xmlIOFTPClose (void * context) { 2252 return ( xmlNanoFTPClose(context) ); 2253 } 2254 #endif /* LIBXML_FTP_ENABLED */ 2255 2256 2257 /** 2258 * xmlRegisterInputCallbacks: 2259 * @matchFunc: the xmlInputMatchCallback 2260 * @openFunc: the xmlInputOpenCallback 2261 * @readFunc: the xmlInputReadCallback 2262 * @closeFunc: the xmlInputCloseCallback 2263 * 2264 * Register a new set of I/O callback for handling parser input. 2265 * 2266 * Returns the registered handler number or -1 in case of error 2267 */ 2268 int 2269 xmlRegisterInputCallbacks(xmlInputMatchCallback matchFunc, 2270 xmlInputOpenCallback openFunc, xmlInputReadCallback readFunc, 2271 xmlInputCloseCallback closeFunc) { 2272 if (xmlInputCallbackNr >= MAX_INPUT_CALLBACK) { 2273 return(-1); 2274 } 2275 xmlInputCallbackTable[xmlInputCallbackNr].matchcallback = matchFunc; 2276 xmlInputCallbackTable[xmlInputCallbackNr].opencallback = openFunc; 2277 xmlInputCallbackTable[xmlInputCallbackNr].readcallback = readFunc; 2278 xmlInputCallbackTable[xmlInputCallbackNr].closecallback = closeFunc; 2279 xmlInputCallbackInitialized = 1; 2280 return(xmlInputCallbackNr++); 2281 } 2282 2283 #ifdef LIBXML_OUTPUT_ENABLED 2284 /** 2285 * xmlRegisterOutputCallbacks: 2286 * @matchFunc: the xmlOutputMatchCallback 2287 * @openFunc: the xmlOutputOpenCallback 2288 * @writeFunc: the xmlOutputWriteCallback 2289 * @closeFunc: the xmlOutputCloseCallback 2290 * 2291 * Register a new set of I/O callback for handling output. 2292 * 2293 * Returns the registered handler number or -1 in case of error 2294 */ 2295 int 2296 xmlRegisterOutputCallbacks(xmlOutputMatchCallback matchFunc, 2297 xmlOutputOpenCallback openFunc, xmlOutputWriteCallback writeFunc, 2298 xmlOutputCloseCallback closeFunc) { 2299 if (xmlOutputCallbackNr >= MAX_OUTPUT_CALLBACK) { 2300 return(-1); 2301 } 2302 xmlOutputCallbackTable[xmlOutputCallbackNr].matchcallback = matchFunc; 2303 xmlOutputCallbackTable[xmlOutputCallbackNr].opencallback = openFunc; 2304 xmlOutputCallbackTable[xmlOutputCallbackNr].writecallback = writeFunc; 2305 xmlOutputCallbackTable[xmlOutputCallbackNr].closecallback = closeFunc; 2306 xmlOutputCallbackInitialized = 1; 2307 return(xmlOutputCallbackNr++); 2308 } 2309 #endif /* LIBXML_OUTPUT_ENABLED */ 2310 2311 /** 2312 * xmlRegisterDefaultInputCallbacks: 2313 * 2314 * Registers the default compiled-in I/O handlers. 2315 */ 2316 void 2317 xmlRegisterDefaultInputCallbacks(void) { 2318 if (xmlInputCallbackInitialized) 2319 return; 2320 2321 #if defined(_WIN32) || defined (__DJGPP__) && !defined (__CYGWIN__) 2322 xmlInitPlatformSpecificIo(); 2323 #endif 2324 2325 xmlRegisterInputCallbacks(xmlFileMatch, xmlFileOpen, 2326 xmlFileRead, xmlFileClose); 2327 #ifdef HAVE_ZLIB_H 2328 xmlRegisterInputCallbacks(xmlGzfileMatch, xmlGzfileOpen, 2329 xmlGzfileRead, xmlGzfileClose); 2330 #endif /* HAVE_ZLIB_H */ 2331 #ifdef LIBXML_LZMA_ENABLED 2332 xmlRegisterInputCallbacks(xmlXzfileMatch, xmlXzfileOpen, 2333 xmlXzfileRead, xmlXzfileClose); 2334 #endif /* LIBXML_LZMA_ENABLED */ 2335 2336 #ifdef LIBXML_HTTP_ENABLED 2337 xmlRegisterInputCallbacks(xmlIOHTTPMatch, xmlIOHTTPOpen, 2338 xmlIOHTTPRead, xmlIOHTTPClose); 2339 #endif /* LIBXML_HTTP_ENABLED */ 2340 2341 #ifdef LIBXML_FTP_ENABLED 2342 xmlRegisterInputCallbacks(xmlIOFTPMatch, xmlIOFTPOpen, 2343 xmlIOFTPRead, xmlIOFTPClose); 2344 #endif /* LIBXML_FTP_ENABLED */ 2345 xmlInputCallbackInitialized = 1; 2346 } 2347 2348 #ifdef LIBXML_OUTPUT_ENABLED 2349 /** 2350 * xmlRegisterDefaultOutputCallbacks: 2351 * 2352 * Registers the default compiled-in I/O handlers. 2353 */ 2354 void 2355 xmlRegisterDefaultOutputCallbacks (void) { 2356 if (xmlOutputCallbackInitialized) 2357 return; 2358 2359 #if defined(_WIN32) || defined (__DJGPP__) && !defined (__CYGWIN__) 2360 xmlInitPlatformSpecificIo(); 2361 #endif 2362 2363 xmlRegisterOutputCallbacks(xmlFileMatch, xmlFileOpenW, 2364 xmlFileWrite, xmlFileClose); 2365 2366 #ifdef LIBXML_HTTP_ENABLED 2367 xmlRegisterOutputCallbacks(xmlIOHTTPMatch, xmlIOHTTPDfltOpenW, 2368 xmlIOHTTPWrite, xmlIOHTTPClosePut); 2369 #endif 2370 2371 /********************************* 2372 No way a-priori to distinguish between gzipped files from 2373 uncompressed ones except opening if existing then closing 2374 and saving with same compression ratio ... a pain. 2375 2376 #ifdef HAVE_ZLIB_H 2377 xmlRegisterOutputCallbacks(xmlGzfileMatch, xmlGzfileOpen, 2378 xmlGzfileWrite, xmlGzfileClose); 2379 #endif 2380 2381 Nor FTP PUT .... 2382 #ifdef LIBXML_FTP_ENABLED 2383 xmlRegisterOutputCallbacks(xmlIOFTPMatch, xmlIOFTPOpen, 2384 xmlIOFTPWrite, xmlIOFTPClose); 2385 #endif 2386 **********************************/ 2387 xmlOutputCallbackInitialized = 1; 2388 } 2389 2390 #ifdef LIBXML_HTTP_ENABLED 2391 /** 2392 * xmlRegisterHTTPPostCallbacks: 2393 * 2394 * By default, libxml submits HTTP output requests using the "PUT" method. 2395 * Calling this method changes the HTTP output method to use the "POST" 2396 * method instead. 2397 * 2398 */ 2399 void 2400 xmlRegisterHTTPPostCallbacks( void ) { 2401 2402 /* Register defaults if not done previously */ 2403 2404 if ( xmlOutputCallbackInitialized == 0 ) 2405 xmlRegisterDefaultOutputCallbacks( ); 2406 2407 xmlRegisterOutputCallbacks(xmlIOHTTPMatch, xmlIOHTTPDfltOpenW, 2408 xmlIOHTTPWrite, xmlIOHTTPClosePost); 2409 return; 2410 } 2411 #endif 2412 #endif /* LIBXML_OUTPUT_ENABLED */ 2413 2414 /** 2415 * xmlAllocParserInputBuffer: 2416 * @enc: the charset encoding if known 2417 * 2418 * Create a buffered parser input for progressive parsing 2419 * 2420 * Returns the new parser input or NULL 2421 */ 2422 xmlParserInputBufferPtr 2423 xmlAllocParserInputBuffer(xmlCharEncoding enc) { 2424 xmlParserInputBufferPtr ret; 2425 2426 ret = (xmlParserInputBufferPtr) xmlMalloc(sizeof(xmlParserInputBuffer)); 2427 if (ret == NULL) { 2428 xmlIOErrMemory("creating input buffer"); 2429 return(NULL); 2430 } 2431 memset(ret, 0, (size_t) sizeof(xmlParserInputBuffer)); 2432 ret->buffer = xmlBufCreateSize(2 * xmlDefaultBufferSize); 2433 if (ret->buffer == NULL) { 2434 xmlFree(ret); 2435 return(NULL); 2436 } 2437 xmlBufSetAllocationScheme(ret->buffer, XML_BUFFER_ALLOC_DOUBLEIT); 2438 ret->encoder = xmlGetCharEncodingHandler(enc); 2439 if (ret->encoder != NULL) 2440 ret->raw = xmlBufCreateSize(2 * xmlDefaultBufferSize); 2441 else 2442 ret->raw = NULL; 2443 ret->readcallback = NULL; 2444 ret->closecallback = NULL; 2445 ret->context = NULL; 2446 ret->compressed = -1; 2447 ret->rawconsumed = 0; 2448 2449 return(ret); 2450 } 2451 2452 #ifdef LIBXML_OUTPUT_ENABLED 2453 /** 2454 * xmlAllocOutputBuffer: 2455 * @encoder: the encoding converter or NULL 2456 * 2457 * Create a buffered parser output 2458 * 2459 * Returns the new parser output or NULL 2460 */ 2461 xmlOutputBufferPtr 2462 xmlAllocOutputBuffer(xmlCharEncodingHandlerPtr encoder) { 2463 xmlOutputBufferPtr ret; 2464 2465 ret = (xmlOutputBufferPtr) xmlMalloc(sizeof(xmlOutputBuffer)); 2466 if (ret == NULL) { 2467 xmlIOErrMemory("creating output buffer"); 2468 return(NULL); 2469 } 2470 memset(ret, 0, (size_t) sizeof(xmlOutputBuffer)); 2471 ret->buffer = xmlBufCreate(); 2472 if (ret->buffer == NULL) { 2473 xmlFree(ret); 2474 return(NULL); 2475 } 2476 2477 /* try to avoid a performance problem with Windows realloc() */ 2478 if (xmlBufGetAllocationScheme(ret->buffer) == XML_BUFFER_ALLOC_EXACT) 2479 xmlBufSetAllocationScheme(ret->buffer, XML_BUFFER_ALLOC_DOUBLEIT); 2480 2481 ret->encoder = encoder; 2482 if (encoder != NULL) { 2483 ret->conv = xmlBufCreateSize(4000); 2484 if (ret->conv == NULL) { 2485 xmlFree(ret); 2486 return(NULL); 2487 } 2488 2489 /* 2490 * This call is designed to initiate the encoder state 2491 */ 2492 xmlCharEncOutput(ret, 1); 2493 } else 2494 ret->conv = NULL; 2495 ret->writecallback = NULL; 2496 ret->closecallback = NULL; 2497 ret->context = NULL; 2498 ret->written = 0; 2499 2500 return(ret); 2501 } 2502 2503 /** 2504 * xmlAllocOutputBufferInternal: 2505 * @encoder: the encoding converter or NULL 2506 * 2507 * Create a buffered parser output 2508 * 2509 * Returns the new parser output or NULL 2510 */ 2511 xmlOutputBufferPtr 2512 xmlAllocOutputBufferInternal(xmlCharEncodingHandlerPtr encoder) { 2513 xmlOutputBufferPtr ret; 2514 2515 ret = (xmlOutputBufferPtr) xmlMalloc(sizeof(xmlOutputBuffer)); 2516 if (ret == NULL) { 2517 xmlIOErrMemory("creating output buffer"); 2518 return(NULL); 2519 } 2520 memset(ret, 0, (size_t) sizeof(xmlOutputBuffer)); 2521 ret->buffer = xmlBufCreate(); 2522 if (ret->buffer == NULL) { 2523 xmlFree(ret); 2524 return(NULL); 2525 } 2526 2527 2528 /* 2529 * For conversion buffers we use the special IO handling 2530 */ 2531 xmlBufSetAllocationScheme(ret->buffer, XML_BUFFER_ALLOC_IO); 2532 2533 ret->encoder = encoder; 2534 if (encoder != NULL) { 2535 ret->conv = xmlBufCreateSize(4000); 2536 if (ret->conv == NULL) { 2537 xmlFree(ret); 2538 return(NULL); 2539 } 2540 2541 /* 2542 * This call is designed to initiate the encoder state 2543 */ 2544 xmlCharEncOutput(ret, 1); 2545 } else 2546 ret->conv = NULL; 2547 ret->writecallback = NULL; 2548 ret->closecallback = NULL; 2549 ret->context = NULL; 2550 ret->written = 0; 2551 2552 return(ret); 2553 } 2554 2555 #endif /* LIBXML_OUTPUT_ENABLED */ 2556 2557 /** 2558 * xmlFreeParserInputBuffer: 2559 * @in: a buffered parser input 2560 * 2561 * Free up the memory used by a buffered parser input 2562 */ 2563 void 2564 xmlFreeParserInputBuffer(xmlParserInputBufferPtr in) { 2565 if (in == NULL) return; 2566 2567 if (in->raw) { 2568 xmlBufFree(in->raw); 2569 in->raw = NULL; 2570 } 2571 if (in->encoder != NULL) { 2572 xmlCharEncCloseFunc(in->encoder); 2573 } 2574 if (in->closecallback != NULL) { 2575 in->closecallback(in->context); 2576 } 2577 if (in->buffer != NULL) { 2578 xmlBufFree(in->buffer); 2579 in->buffer = NULL; 2580 } 2581 2582 xmlFree(in); 2583 } 2584 2585 #ifdef LIBXML_OUTPUT_ENABLED 2586 /** 2587 * xmlOutputBufferClose: 2588 * @out: a buffered output 2589 * 2590 * flushes and close the output I/O channel 2591 * and free up all the associated resources 2592 * 2593 * Returns the number of byte written or -1 in case of error. 2594 */ 2595 int 2596 xmlOutputBufferClose(xmlOutputBufferPtr out) 2597 { 2598 int written; 2599 int err_rc = 0; 2600 2601 if (out == NULL) 2602 return (-1); 2603 if (out->writecallback != NULL) 2604 xmlOutputBufferFlush(out); 2605 if (out->closecallback != NULL) { 2606 err_rc = out->closecallback(out->context); 2607 } 2608 written = out->written; 2609 if (out->conv) { 2610 xmlBufFree(out->conv); 2611 out->conv = NULL; 2612 } 2613 if (out->encoder != NULL) { 2614 xmlCharEncCloseFunc(out->encoder); 2615 } 2616 if (out->buffer != NULL) { 2617 xmlBufFree(out->buffer); 2618 out->buffer = NULL; 2619 } 2620 2621 if (out->error) 2622 err_rc = -1; 2623 xmlFree(out); 2624 return ((err_rc == 0) ? written : err_rc); 2625 } 2626 #endif /* LIBXML_OUTPUT_ENABLED */ 2627 2628 xmlParserInputBufferPtr 2629 __xmlParserInputBufferCreateFilename(const char *URI, xmlCharEncoding enc) { 2630 xmlParserInputBufferPtr ret; 2631 int i = 0; 2632 void *context = NULL; 2633 2634 if (xmlInputCallbackInitialized == 0) 2635 xmlRegisterDefaultInputCallbacks(); 2636 2637 if (URI == NULL) return(NULL); 2638 2639 /* 2640 * Try to find one of the input accept method accepting that scheme 2641 * Go in reverse to give precedence to user defined handlers. 2642 */ 2643 if (context == NULL) { 2644 for (i = xmlInputCallbackNr - 1;i >= 0;i--) { 2645 if ((xmlInputCallbackTable[i].matchcallback != NULL) && 2646 (xmlInputCallbackTable[i].matchcallback(URI) != 0)) { 2647 context = xmlInputCallbackTable[i].opencallback(URI); 2648 if (context != NULL) { 2649 break; 2650 } 2651 } 2652 } 2653 } 2654 if (context == NULL) { 2655 return(NULL); 2656 } 2657 2658 /* 2659 * Allocate the Input buffer front-end. 2660 */ 2661 ret = xmlAllocParserInputBuffer(enc); 2662 if (ret != NULL) { 2663 ret->context = context; 2664 ret->readcallback = xmlInputCallbackTable[i].readcallback; 2665 ret->closecallback = xmlInputCallbackTable[i].closecallback; 2666 #ifdef HAVE_ZLIB_H 2667 if ((xmlInputCallbackTable[i].opencallback == xmlGzfileOpen) && 2668 (strcmp(URI, "-") != 0)) { 2669 #if defined(ZLIB_VERNUM) && ZLIB_VERNUM >= 0x1230 2670 ret->compressed = !gzdirect(context); 2671 #else 2672 if (((z_stream *)context)->avail_in > 4) { 2673 char *cptr, buff4[4]; 2674 cptr = (char *) ((z_stream *)context)->next_in; 2675 if (gzread(context, buff4, 4) == 4) { 2676 if (strncmp(buff4, cptr, 4) == 0) 2677 ret->compressed = 0; 2678 else 2679 ret->compressed = 1; 2680 gzrewind(context); 2681 } 2682 } 2683 #endif 2684 } 2685 #endif 2686 #ifdef LIBXML_LZMA_ENABLED 2687 if ((xmlInputCallbackTable[i].opencallback == xmlXzfileOpen) && 2688 (strcmp(URI, "-") != 0)) { 2689 ret->compressed = __libxml2_xzcompressed(context); 2690 } 2691 #endif 2692 } 2693 else 2694 xmlInputCallbackTable[i].closecallback (context); 2695 2696 return(ret); 2697 } 2698 2699 /** 2700 * xmlParserInputBufferCreateFilename: 2701 * @URI: a C string containing the URI or filename 2702 * @enc: the charset encoding if known 2703 * 2704 * Create a buffered parser input for the progressive parsing of a file 2705 * If filename is "-' then we use stdin as the input. 2706 * Automatic support for ZLIB/Compress compressed document is provided 2707 * by default if found at compile-time. 2708 * Do an encoding check if enc == XML_CHAR_ENCODING_NONE 2709 * 2710 * Returns the new parser input or NULL 2711 */ 2712 xmlParserInputBufferPtr 2713 xmlParserInputBufferCreateFilename(const char *URI, xmlCharEncoding enc) { 2714 if ((xmlParserInputBufferCreateFilenameValue)) { 2715 return xmlParserInputBufferCreateFilenameValue(URI, enc); 2716 } 2717 return __xmlParserInputBufferCreateFilename(URI, enc); 2718 } 2719 2720 #ifdef LIBXML_OUTPUT_ENABLED 2721 xmlOutputBufferPtr 2722 __xmlOutputBufferCreateFilename(const char *URI, 2723 xmlCharEncodingHandlerPtr encoder, 2724 int compression ATTRIBUTE_UNUSED) { 2725 xmlOutputBufferPtr ret; 2726 xmlURIPtr puri; 2727 int i = 0; 2728 void *context = NULL; 2729 char *unescaped = NULL; 2730 #ifdef HAVE_ZLIB_H 2731 int is_file_uri = 1; 2732 #endif 2733 2734 if (xmlOutputCallbackInitialized == 0) 2735 xmlRegisterDefaultOutputCallbacks(); 2736 2737 if (URI == NULL) return(NULL); 2738 2739 puri = xmlParseURI(URI); 2740 if (puri != NULL) { 2741 #ifdef HAVE_ZLIB_H 2742 if ((puri->scheme != NULL) && 2743 (!xmlStrEqual(BAD_CAST puri->scheme, BAD_CAST "file"))) 2744 is_file_uri = 0; 2745 #endif 2746 /* 2747 * try to limit the damages of the URI unescaping code. 2748 */ 2749 if ((puri->scheme == NULL) || 2750 (xmlStrEqual(BAD_CAST puri->scheme, BAD_CAST "file"))) 2751 unescaped = xmlURIUnescapeString(URI, 0, NULL); 2752 xmlFreeURI(puri); 2753 } 2754 2755 /* 2756 * Try to find one of the output accept method accepting that scheme 2757 * Go in reverse to give precedence to user defined handlers. 2758 * try with an unescaped version of the URI 2759 */ 2760 if (unescaped != NULL) { 2761 #ifdef HAVE_ZLIB_H 2762 if ((compression > 0) && (compression <= 9) && (is_file_uri == 1)) { 2763 context = xmlGzfileOpenW(unescaped, compression); 2764 if (context != NULL) { 2765 ret = xmlAllocOutputBufferInternal(encoder); 2766 if (ret != NULL) { 2767 ret->context = context; 2768 ret->writecallback = xmlGzfileWrite; 2769 ret->closecallback = xmlGzfileClose; 2770 } 2771 xmlFree(unescaped); 2772 return(ret); 2773 } 2774 } 2775 #endif 2776 for (i = xmlOutputCallbackNr - 1;i >= 0;i--) { 2777 if ((xmlOutputCallbackTable[i].matchcallback != NULL) && 2778 (xmlOutputCallbackTable[i].matchcallback(unescaped) != 0)) { 2779 #if defined(LIBXML_HTTP_ENABLED) && defined(HAVE_ZLIB_H) 2780 /* Need to pass compression parameter into HTTP open calls */ 2781 if (xmlOutputCallbackTable[i].matchcallback == xmlIOHTTPMatch) 2782 context = xmlIOHTTPOpenW(unescaped, compression); 2783 else 2784 #endif 2785 context = xmlOutputCallbackTable[i].opencallback(unescaped); 2786 if (context != NULL) 2787 break; 2788 } 2789 } 2790 xmlFree(unescaped); 2791 } 2792 2793 /* 2794 * If this failed try with a non-escaped URI this may be a strange 2795 * filename 2796 */ 2797 if (context == NULL) { 2798 #ifdef HAVE_ZLIB_H 2799 if ((compression > 0) && (compression <= 9) && (is_file_uri == 1)) { 2800 context = xmlGzfileOpenW(URI, compression); 2801 if (context != NULL) { 2802 ret = xmlAllocOutputBufferInternal(encoder); 2803 if (ret != NULL) { 2804 ret->context = context; 2805 ret->writecallback = xmlGzfileWrite; 2806 ret->closecallback = xmlGzfileClose; 2807 } 2808 return(ret); 2809 } 2810 } 2811 #endif 2812 for (i = xmlOutputCallbackNr - 1;i >= 0;i--) { 2813 if ((xmlOutputCallbackTable[i].matchcallback != NULL) && 2814 (xmlOutputCallbackTable[i].matchcallback(URI) != 0)) { 2815 #if defined(LIBXML_HTTP_ENABLED) && defined(HAVE_ZLIB_H) 2816 /* Need to pass compression parameter into HTTP open calls */ 2817 if (xmlOutputCallbackTable[i].matchcallback == xmlIOHTTPMatch) 2818 context = xmlIOHTTPOpenW(URI, compression); 2819 else 2820 #endif 2821 context = xmlOutputCallbackTable[i].opencallback(URI); 2822 if (context != NULL) 2823 break; 2824 } 2825 } 2826 } 2827 2828 if (context == NULL) { 2829 return(NULL); 2830 } 2831 2832 /* 2833 * Allocate the Output buffer front-end. 2834 */ 2835 ret = xmlAllocOutputBufferInternal(encoder); 2836 if (ret != NULL) { 2837 ret->context = context; 2838 ret->writecallback = xmlOutputCallbackTable[i].writecallback; 2839 ret->closecallback = xmlOutputCallbackTable[i].closecallback; 2840 } 2841 return(ret); 2842 } 2843 2844 /** 2845 * xmlOutputBufferCreateFilename: 2846 * @URI: a C string containing the URI or filename 2847 * @encoder: the encoding converter or NULL 2848 * @compression: the compression ration (0 none, 9 max). 2849 * 2850 * Create a buffered output for the progressive saving of a file 2851 * If filename is "-' then we use stdout as the output. 2852 * Automatic support for ZLIB/Compress compressed document is provided 2853 * by default if found at compile-time. 2854 * TODO: currently if compression is set, the library only support 2855 * writing to a local file. 2856 * 2857 * Returns the new output or NULL 2858 */ 2859 xmlOutputBufferPtr 2860 xmlOutputBufferCreateFilename(const char *URI, 2861 xmlCharEncodingHandlerPtr encoder, 2862 int compression ATTRIBUTE_UNUSED) { 2863 if ((xmlOutputBufferCreateFilenameValue)) { 2864 return xmlOutputBufferCreateFilenameValue(URI, encoder, compression); 2865 } 2866 return __xmlOutputBufferCreateFilename(URI, encoder, compression); 2867 } 2868 #endif /* LIBXML_OUTPUT_ENABLED */ 2869 2870 /** 2871 * xmlParserInputBufferCreateFile: 2872 * @file: a FILE* 2873 * @enc: the charset encoding if known 2874 * 2875 * Create a buffered parser input for the progressive parsing of a FILE * 2876 * buffered C I/O 2877 * 2878 * Returns the new parser input or NULL 2879 */ 2880 xmlParserInputBufferPtr 2881 xmlParserInputBufferCreateFile(FILE *file, xmlCharEncoding enc) { 2882 xmlParserInputBufferPtr ret; 2883 2884 if (xmlInputCallbackInitialized == 0) 2885 xmlRegisterDefaultInputCallbacks(); 2886 2887 if (file == NULL) return(NULL); 2888 2889 ret = xmlAllocParserInputBuffer(enc); 2890 if (ret != NULL) { 2891 ret->context = file; 2892 ret->readcallback = xmlFileRead; 2893 ret->closecallback = xmlFileFlush; 2894 } 2895 2896 return(ret); 2897 } 2898 2899 #ifdef LIBXML_OUTPUT_ENABLED 2900 /** 2901 * xmlOutputBufferCreateFile: 2902 * @file: a FILE* 2903 * @encoder: the encoding converter or NULL 2904 * 2905 * Create a buffered output for the progressive saving to a FILE * 2906 * buffered C I/O 2907 * 2908 * Returns the new parser output or NULL 2909 */ 2910 xmlOutputBufferPtr 2911 xmlOutputBufferCreateFile(FILE *file, xmlCharEncodingHandlerPtr encoder) { 2912 xmlOutputBufferPtr ret; 2913 2914 if (xmlOutputCallbackInitialized == 0) 2915 xmlRegisterDefaultOutputCallbacks(); 2916 2917 if (file == NULL) return(NULL); 2918 2919 ret = xmlAllocOutputBufferInternal(encoder); 2920 if (ret != NULL) { 2921 ret->context = file; 2922 ret->writecallback = xmlFileWrite; 2923 ret->closecallback = xmlFileFlush; 2924 } 2925 2926 return(ret); 2927 } 2928 2929 /** 2930 * xmlOutputBufferCreateBuffer: 2931 * @buffer: a xmlBufferPtr 2932 * @encoder: the encoding converter or NULL 2933 * 2934 * Create a buffered output for the progressive saving to a xmlBuffer 2935 * 2936 * Returns the new parser output or NULL 2937 */ 2938 xmlOutputBufferPtr 2939 xmlOutputBufferCreateBuffer(xmlBufferPtr buffer, 2940 xmlCharEncodingHandlerPtr encoder) { 2941 xmlOutputBufferPtr ret; 2942 2943 if (buffer == NULL) return(NULL); 2944 2945 ret = xmlOutputBufferCreateIO((xmlOutputWriteCallback) 2946 xmlBufferWrite, 2947 (xmlOutputCloseCallback) 2948 NULL, (void *) buffer, encoder); 2949 2950 return(ret); 2951 } 2952 2953 /** 2954 * xmlOutputBufferGetContent: 2955 * @out: an xmlOutputBufferPtr 2956 * 2957 * Gives a pointer to the data currently held in the output buffer 2958 * 2959 * Returns a pointer to the data or NULL in case of error 2960 */ 2961 const xmlChar * 2962 xmlOutputBufferGetContent(xmlOutputBufferPtr out) { 2963 if ((out == NULL) || (out->buffer == NULL)) 2964 return(NULL); 2965 2966 return(xmlBufContent(out->buffer)); 2967 } 2968 2969 /** 2970 * xmlOutputBufferGetSize: 2971 * @out: an xmlOutputBufferPtr 2972 * 2973 * Gives the length of the data currently held in the output buffer 2974 * 2975 * Returns 0 in case or error or no data is held, the size otherwise 2976 */ 2977 size_t 2978 xmlOutputBufferGetSize(xmlOutputBufferPtr out) { 2979 if ((out == NULL) || (out->buffer == NULL)) 2980 return(0); 2981 2982 return(xmlBufUse(out->buffer)); 2983 } 2984 2985 2986 #endif /* LIBXML_OUTPUT_ENABLED */ 2987 2988 /** 2989 * xmlParserInputBufferCreateFd: 2990 * @fd: a file descriptor number 2991 * @enc: the charset encoding if known 2992 * 2993 * Create a buffered parser input for the progressive parsing for the input 2994 * from a file descriptor 2995 * 2996 * Returns the new parser input or NULL 2997 */ 2998 xmlParserInputBufferPtr 2999 xmlParserInputBufferCreateFd(int fd, xmlCharEncoding enc) { 3000 xmlParserInputBufferPtr ret; 3001 3002 if (fd < 0) return(NULL); 3003 3004 ret = xmlAllocParserInputBuffer(enc); 3005 if (ret != NULL) { 3006 ret->context = (void *) (long) fd; 3007 ret->readcallback = xmlFdRead; 3008 ret->closecallback = xmlFdClose; 3009 } 3010 3011 return(ret); 3012 } 3013 3014 /** 3015 * xmlParserInputBufferCreateMem: 3016 * @mem: the memory input 3017 * @size: the length of the memory block 3018 * @enc: the charset encoding if known 3019 * 3020 * Create a buffered parser input for the progressive parsing for the input 3021 * from a memory area. 3022 * 3023 * Returns the new parser input or NULL 3024 */ 3025 xmlParserInputBufferPtr 3026 xmlParserInputBufferCreateMem(const char *mem, int size, xmlCharEncoding enc) { 3027 xmlParserInputBufferPtr ret; 3028 int errcode; 3029 3030 if (size <= 0) return(NULL); 3031 if (mem == NULL) return(NULL); 3032 3033 ret = xmlAllocParserInputBuffer(enc); 3034 if (ret != NULL) { 3035 ret->context = (void *) mem; 3036 ret->readcallback = (xmlInputReadCallback) xmlNop; 3037 ret->closecallback = NULL; 3038 errcode = xmlBufAdd(ret->buffer, (const xmlChar *) mem, size); 3039 if (errcode != 0) { 3040 xmlFree(ret); 3041 return(NULL); 3042 } 3043 } 3044 3045 return(ret); 3046 } 3047 3048 /** 3049 * xmlParserInputBufferCreateStatic: 3050 * @mem: the memory input 3051 * @size: the length of the memory block 3052 * @enc: the charset encoding if known 3053 * 3054 * Create a buffered parser input for the progressive parsing for the input 3055 * from an immutable memory area. This will not copy the memory area to 3056 * the buffer, but the memory is expected to be available until the end of 3057 * the parsing, this is useful for example when using mmap'ed file. 3058 * 3059 * Returns the new parser input or NULL 3060 */ 3061 xmlParserInputBufferPtr 3062 xmlParserInputBufferCreateStatic(const char *mem, int size, 3063 xmlCharEncoding enc) { 3064 xmlParserInputBufferPtr ret; 3065 3066 if (size <= 0) return(NULL); 3067 if (mem == NULL) return(NULL); 3068 3069 ret = (xmlParserInputBufferPtr) xmlMalloc(sizeof(xmlParserInputBuffer)); 3070 if (ret == NULL) { 3071 xmlIOErrMemory("creating input buffer"); 3072 return(NULL); 3073 } 3074 memset(ret, 0, (size_t) sizeof(xmlParserInputBuffer)); 3075 ret->buffer = xmlBufCreateStatic((void *)mem, (size_t) size); 3076 if (ret->buffer == NULL) { 3077 xmlFree(ret); 3078 return(NULL); 3079 } 3080 ret->encoder = xmlGetCharEncodingHandler(enc); 3081 if (ret->encoder != NULL) 3082 ret->raw = xmlBufCreateSize(2 * xmlDefaultBufferSize); 3083 else 3084 ret->raw = NULL; 3085 ret->compressed = -1; 3086 ret->context = (void *) mem; 3087 ret->readcallback = NULL; 3088 ret->closecallback = NULL; 3089 3090 return(ret); 3091 } 3092 3093 #ifdef LIBXML_OUTPUT_ENABLED 3094 /** 3095 * xmlOutputBufferCreateFd: 3096 * @fd: a file descriptor number 3097 * @encoder: the encoding converter or NULL 3098 * 3099 * Create a buffered output for the progressive saving 3100 * to a file descriptor 3101 * 3102 * Returns the new parser output or NULL 3103 */ 3104 xmlOutputBufferPtr 3105 xmlOutputBufferCreateFd(int fd, xmlCharEncodingHandlerPtr encoder) { 3106 xmlOutputBufferPtr ret; 3107 3108 if (fd < 0) return(NULL); 3109 3110 ret = xmlAllocOutputBufferInternal(encoder); 3111 if (ret != NULL) { 3112 ret->context = (void *) (long) fd; 3113 ret->writecallback = xmlFdWrite; 3114 ret->closecallback = NULL; 3115 } 3116 3117 return(ret); 3118 } 3119 #endif /* LIBXML_OUTPUT_ENABLED */ 3120 3121 /** 3122 * xmlParserInputBufferCreateIO: 3123 * @ioread: an I/O read function 3124 * @ioclose: an I/O close function 3125 * @ioctx: an I/O handler 3126 * @enc: the charset encoding if known 3127 * 3128 * Create a buffered parser input for the progressive parsing for the input 3129 * from an I/O handler 3130 * 3131 * Returns the new parser input or NULL 3132 */ 3133 xmlParserInputBufferPtr 3134 xmlParserInputBufferCreateIO(xmlInputReadCallback ioread, 3135 xmlInputCloseCallback ioclose, void *ioctx, xmlCharEncoding enc) { 3136 xmlParserInputBufferPtr ret; 3137 3138 if (ioread == NULL) return(NULL); 3139 3140 ret = xmlAllocParserInputBuffer(enc); 3141 if (ret != NULL) { 3142 ret->context = (void *) ioctx; 3143 ret->readcallback = ioread; 3144 ret->closecallback = ioclose; 3145 } 3146 3147 return(ret); 3148 } 3149 3150 #ifdef LIBXML_OUTPUT_ENABLED 3151 /** 3152 * xmlOutputBufferCreateIO: 3153 * @iowrite: an I/O write function 3154 * @ioclose: an I/O close function 3155 * @ioctx: an I/O handler 3156 * @encoder: the charset encoding if known 3157 * 3158 * Create a buffered output for the progressive saving 3159 * to an I/O handler 3160 * 3161 * Returns the new parser output or NULL 3162 */ 3163 xmlOutputBufferPtr 3164 xmlOutputBufferCreateIO(xmlOutputWriteCallback iowrite, 3165 xmlOutputCloseCallback ioclose, void *ioctx, 3166 xmlCharEncodingHandlerPtr encoder) { 3167 xmlOutputBufferPtr ret; 3168 3169 if (iowrite == NULL) return(NULL); 3170 3171 ret = xmlAllocOutputBufferInternal(encoder); 3172 if (ret != NULL) { 3173 ret->context = (void *) ioctx; 3174 ret->writecallback = iowrite; 3175 ret->closecallback = ioclose; 3176 } 3177 3178 return(ret); 3179 } 3180 #endif /* LIBXML_OUTPUT_ENABLED */ 3181 3182 /** 3183 * xmlParserInputBufferCreateFilenameDefault: 3184 * @func: function pointer to the new ParserInputBufferCreateFilenameFunc 3185 * 3186 * Registers a callback for URI input file handling 3187 * 3188 * Returns the old value of the registration function 3189 */ 3190 xmlParserInputBufferCreateFilenameFunc 3191 xmlParserInputBufferCreateFilenameDefault(xmlParserInputBufferCreateFilenameFunc func) 3192 { 3193 xmlParserInputBufferCreateFilenameFunc old = xmlParserInputBufferCreateFilenameValue; 3194 if (old == NULL) { 3195 old = __xmlParserInputBufferCreateFilename; 3196 } 3197 3198 xmlParserInputBufferCreateFilenameValue = func; 3199 return(old); 3200 } 3201 3202 /** 3203 * xmlOutputBufferCreateFilenameDefault: 3204 * @func: function pointer to the new OutputBufferCreateFilenameFunc 3205 * 3206 * Registers a callback for URI output file handling 3207 * 3208 * Returns the old value of the registration function 3209 */ 3210 xmlOutputBufferCreateFilenameFunc 3211 xmlOutputBufferCreateFilenameDefault(xmlOutputBufferCreateFilenameFunc func) 3212 { 3213 xmlOutputBufferCreateFilenameFunc old = xmlOutputBufferCreateFilenameValue; 3214 #ifdef LIBXML_OUTPUT_ENABLED 3215 if (old == NULL) { 3216 old = __xmlOutputBufferCreateFilename; 3217 } 3218 #endif 3219 xmlOutputBufferCreateFilenameValue = func; 3220 return(old); 3221 } 3222 3223 /** 3224 * xmlParserInputBufferPush: 3225 * @in: a buffered parser input 3226 * @len: the size in bytes of the array. 3227 * @buf: an char array 3228 * 3229 * Push the content of the arry in the input buffer 3230 * This routine handle the I18N transcoding to internal UTF-8 3231 * This is used when operating the parser in progressive (push) mode. 3232 * 3233 * Returns the number of chars read and stored in the buffer, or -1 3234 * in case of error. 3235 */ 3236 int 3237 xmlParserInputBufferPush(xmlParserInputBufferPtr in, 3238 int len, const char *buf) { 3239 int nbchars = 0; 3240 int ret; 3241 3242 if (len < 0) return(0); 3243 if ((in == NULL) || (in->error)) return(-1); 3244 if (in->encoder != NULL) { 3245 unsigned int use; 3246 3247 /* 3248 * Store the data in the incoming raw buffer 3249 */ 3250 if (in->raw == NULL) { 3251 in->raw = xmlBufCreate(); 3252 } 3253 ret = xmlBufAdd(in->raw, (const xmlChar *) buf, len); 3254 if (ret != 0) 3255 return(-1); 3256 3257 /* 3258 * convert as much as possible to the parser reading buffer. 3259 */ 3260 use = xmlBufUse(in->raw); 3261 nbchars = xmlCharEncInput(in, 1); 3262 if (nbchars < 0) { 3263 xmlIOErr(XML_IO_ENCODER, NULL); 3264 in->error = XML_IO_ENCODER; 3265 return(-1); 3266 } 3267 in->rawconsumed += (use - xmlBufUse(in->raw)); 3268 } else { 3269 nbchars = len; 3270 ret = xmlBufAdd(in->buffer, (xmlChar *) buf, nbchars); 3271 if (ret != 0) 3272 return(-1); 3273 } 3274 #ifdef DEBUG_INPUT 3275 xmlGenericError(xmlGenericErrorContext, 3276 "I/O: pushed %d chars, buffer %d/%d\n", 3277 nbchars, xmlBufUse(in->buffer), xmlBufLength(in->buffer)); 3278 #endif 3279 return(nbchars); 3280 } 3281 3282 /** 3283 * endOfInput: 3284 * 3285 * When reading from an Input channel indicated end of file or error 3286 * don't reread from it again. 3287 */ 3288 static int 3289 endOfInput (void * context ATTRIBUTE_UNUSED, 3290 char * buffer ATTRIBUTE_UNUSED, 3291 int len ATTRIBUTE_UNUSED) { 3292 return(0); 3293 } 3294 3295 /** 3296 * xmlParserInputBufferGrow: 3297 * @in: a buffered parser input 3298 * @len: indicative value of the amount of chars to read 3299 * 3300 * Grow up the content of the input buffer, the old data are preserved 3301 * This routine handle the I18N transcoding to internal UTF-8 3302 * This routine is used when operating the parser in normal (pull) mode 3303 * 3304 * TODO: one should be able to remove one extra copy by copying directly 3305 * onto in->buffer or in->raw 3306 * 3307 * Returns the number of chars read and stored in the buffer, or -1 3308 * in case of error. 3309 */ 3310 int 3311 xmlParserInputBufferGrow(xmlParserInputBufferPtr in, int len) { 3312 char *buffer = NULL; 3313 int res = 0; 3314 int nbchars = 0; 3315 3316 if ((in == NULL) || (in->error)) return(-1); 3317 if ((len <= MINLEN) && (len != 4)) 3318 len = MINLEN; 3319 3320 if (xmlBufAvail(in->buffer) <= 0) { 3321 xmlIOErr(XML_IO_BUFFER_FULL, NULL); 3322 in->error = XML_IO_BUFFER_FULL; 3323 return(-1); 3324 } 3325 3326 if (xmlBufGrow(in->buffer, len + 1) < 0) { 3327 xmlIOErrMemory("growing input buffer"); 3328 in->error = XML_ERR_NO_MEMORY; 3329 return(-1); 3330 } 3331 buffer = (char *)xmlBufEnd(in->buffer); 3332 3333 /* 3334 * Call the read method for this I/O type. 3335 */ 3336 if (in->readcallback != NULL) { 3337 res = in->readcallback(in->context, &buffer[0], len); 3338 if (res <= 0) 3339 in->readcallback = endOfInput; 3340 } else { 3341 xmlIOErr(XML_IO_NO_INPUT, NULL); 3342 in->error = XML_IO_NO_INPUT; 3343 return(-1); 3344 } 3345 if (res < 0) { 3346 return(-1); 3347 } 3348 3349 /* 3350 * try to establish compressed status of input if not done already 3351 */ 3352 if (in->compressed == -1) { 3353 #ifdef LIBXML_LZMA_ENABLED 3354 if (in->readcallback == xmlXzfileRead) 3355 in->compressed = __libxml2_xzcompressed(in->context); 3356 #endif 3357 } 3358 3359 len = res; 3360 if (in->encoder != NULL) { 3361 unsigned int use; 3362 3363 /* 3364 * Store the data in the incoming raw buffer 3365 */ 3366 if (in->raw == NULL) { 3367 in->raw = xmlBufCreate(); 3368 } 3369 res = xmlBufAdd(in->raw, (const xmlChar *) buffer, len); 3370 if (res != 0) 3371 return(-1); 3372 3373 /* 3374 * convert as much as possible to the parser reading buffer. 3375 */ 3376 use = xmlBufUse(in->raw); 3377 nbchars = xmlCharEncInput(in, 1); 3378 if (nbchars < 0) { 3379 xmlIOErr(XML_IO_ENCODER, NULL); 3380 in->error = XML_IO_ENCODER; 3381 return(-1); 3382 } 3383 in->rawconsumed += (use - xmlBufUse(in->raw)); 3384 } else { 3385 nbchars = len; 3386 xmlBufAddLen(in->buffer, nbchars); 3387 } 3388 #ifdef DEBUG_INPUT 3389 xmlGenericError(xmlGenericErrorContext, 3390 "I/O: read %d chars, buffer %d\n", 3391 nbchars, xmlBufUse(in->buffer)); 3392 #endif 3393 return(nbchars); 3394 } 3395 3396 /** 3397 * xmlParserInputBufferRead: 3398 * @in: a buffered parser input 3399 * @len: indicative value of the amount of chars to read 3400 * 3401 * Refresh the content of the input buffer, the old data are considered 3402 * consumed 3403 * This routine handle the I18N transcoding to internal UTF-8 3404 * 3405 * Returns the number of chars read and stored in the buffer, or -1 3406 * in case of error. 3407 */ 3408 int 3409 xmlParserInputBufferRead(xmlParserInputBufferPtr in, int len) { 3410 if ((in == NULL) || (in->error)) return(-1); 3411 if (in->readcallback != NULL) 3412 return(xmlParserInputBufferGrow(in, len)); 3413 else if (xmlBufGetAllocationScheme(in->buffer) == XML_BUFFER_ALLOC_IMMUTABLE) 3414 return(0); 3415 else 3416 return(-1); 3417 } 3418 3419 #ifdef LIBXML_OUTPUT_ENABLED 3420 /** 3421 * xmlOutputBufferWrite: 3422 * @out: a buffered parser output 3423 * @len: the size in bytes of the array. 3424 * @buf: an char array 3425 * 3426 * Write the content of the array in the output I/O buffer 3427 * This routine handle the I18N transcoding from internal UTF-8 3428 * The buffer is lossless, i.e. will store in case of partial 3429 * or delayed writes. 3430 * 3431 * Returns the number of chars immediately written, or -1 3432 * in case of error. 3433 */ 3434 int 3435 xmlOutputBufferWrite(xmlOutputBufferPtr out, int len, const char *buf) { 3436 int nbchars = 0; /* number of chars to output to I/O */ 3437 int ret; /* return from function call */ 3438 int written = 0; /* number of char written to I/O so far */ 3439 int chunk; /* number of byte curreent processed from buf */ 3440 3441 if ((out == NULL) || (out->error)) return(-1); 3442 if (len < 0) return(0); 3443 if (out->error) return(-1); 3444 3445 do { 3446 chunk = len; 3447 if (chunk > 4 * MINLEN) 3448 chunk = 4 * MINLEN; 3449 3450 /* 3451 * first handle encoding stuff. 3452 */ 3453 if (out->encoder != NULL) { 3454 /* 3455 * Store the data in the incoming raw buffer 3456 */ 3457 if (out->conv == NULL) { 3458 out->conv = xmlBufCreate(); 3459 } 3460 ret = xmlBufAdd(out->buffer, (const xmlChar *) buf, chunk); 3461 if (ret != 0) 3462 return(-1); 3463 3464 if ((xmlBufUse(out->buffer) < MINLEN) && (chunk == len)) 3465 goto done; 3466 3467 /* 3468 * convert as much as possible to the parser reading buffer. 3469 */ 3470 ret = xmlCharEncOutput(out, 0); 3471 if ((ret < 0) && (ret != -3)) { 3472 xmlIOErr(XML_IO_ENCODER, NULL); 3473 out->error = XML_IO_ENCODER; 3474 return(-1); 3475 } 3476 nbchars = xmlBufUse(out->conv); 3477 } else { 3478 ret = xmlBufAdd(out->buffer, (const xmlChar *) buf, chunk); 3479 if (ret != 0) 3480 return(-1); 3481 nbchars = xmlBufUse(out->buffer); 3482 } 3483 buf += chunk; 3484 len -= chunk; 3485 3486 if ((nbchars < MINLEN) && (len <= 0)) 3487 goto done; 3488 3489 if (out->writecallback) { 3490 /* 3491 * second write the stuff to the I/O channel 3492 */ 3493 if (out->encoder != NULL) { 3494 ret = out->writecallback(out->context, 3495 (const char *)xmlBufContent(out->conv), nbchars); 3496 if (ret >= 0) 3497 xmlBufShrink(out->conv, ret); 3498 } else { 3499 ret = out->writecallback(out->context, 3500 (const char *)xmlBufContent(out->buffer), nbchars); 3501 if (ret >= 0) 3502 xmlBufShrink(out->buffer, ret); 3503 } 3504 if (ret < 0) { 3505 xmlIOErr(XML_IO_WRITE, NULL); 3506 out->error = XML_IO_WRITE; 3507 return(ret); 3508 } 3509 out->written += ret; 3510 } 3511 written += nbchars; 3512 } while (len > 0); 3513 3514 done: 3515 #ifdef DEBUG_INPUT 3516 xmlGenericError(xmlGenericErrorContext, 3517 "I/O: wrote %d chars\n", written); 3518 #endif 3519 return(written); 3520 } 3521 3522 /** 3523 * xmlEscapeContent: 3524 * @out: a pointer to an array of bytes to store the result 3525 * @outlen: the length of @out 3526 * @in: a pointer to an array of unescaped UTF-8 bytes 3527 * @inlen: the length of @in 3528 * 3529 * Take a block of UTF-8 chars in and escape them. 3530 * Returns 0 if success, or -1 otherwise 3531 * The value of @inlen after return is the number of octets consumed 3532 * if the return value is positive, else unpredictable. 3533 * The value of @outlen after return is the number of octets consumed. 3534 */ 3535 static int 3536 xmlEscapeContent(unsigned char* out, int *outlen, 3537 const xmlChar* in, int *inlen) { 3538 unsigned char* outstart = out; 3539 const unsigned char* base = in; 3540 unsigned char* outend = out + *outlen; 3541 const unsigned char* inend; 3542 3543 inend = in + (*inlen); 3544 3545 while ((in < inend) && (out < outend)) { 3546 if (*in == '<') { 3547 if (outend - out < 4) break; 3548 *out++ = '&'; 3549 *out++ = 'l'; 3550 *out++ = 't'; 3551 *out++ = ';'; 3552 } else if (*in == '>') { 3553 if (outend - out < 4) break; 3554 *out++ = '&'; 3555 *out++ = 'g'; 3556 *out++ = 't'; 3557 *out++ = ';'; 3558 } else if (*in == '&') { 3559 if (outend - out < 5) break; 3560 *out++ = '&'; 3561 *out++ = 'a'; 3562 *out++ = 'm'; 3563 *out++ = 'p'; 3564 *out++ = ';'; 3565 } else if (*in == '\r') { 3566 if (outend - out < 5) break; 3567 *out++ = '&'; 3568 *out++ = '#'; 3569 *out++ = '1'; 3570 *out++ = '3'; 3571 *out++ = ';'; 3572 } else { 3573 *out++ = (unsigned char) *in; 3574 } 3575 ++in; 3576 } 3577 *outlen = out - outstart; 3578 *inlen = in - base; 3579 return(0); 3580 } 3581 3582 /** 3583 * xmlOutputBufferWriteEscape: 3584 * @out: a buffered parser output 3585 * @str: a zero terminated UTF-8 string 3586 * @escaping: an optional escaping function (or NULL) 3587 * 3588 * Write the content of the string in the output I/O buffer 3589 * This routine escapes the caracters and then handle the I18N 3590 * transcoding from internal UTF-8 3591 * The buffer is lossless, i.e. will store in case of partial 3592 * or delayed writes. 3593 * 3594 * Returns the number of chars immediately written, or -1 3595 * in case of error. 3596 */ 3597 int 3598 xmlOutputBufferWriteEscape(xmlOutputBufferPtr out, const xmlChar *str, 3599 xmlCharEncodingOutputFunc escaping) { 3600 int nbchars = 0; /* number of chars to output to I/O */ 3601 int ret; /* return from function call */ 3602 int written = 0; /* number of char written to I/O so far */ 3603 int oldwritten=0;/* loop guard */ 3604 int chunk; /* number of byte currently processed from str */ 3605 int len; /* number of bytes in str */ 3606 int cons; /* byte from str consumed */ 3607 3608 if ((out == NULL) || (out->error) || (str == NULL) || 3609 (out->buffer == NULL) || 3610 (xmlBufGetAllocationScheme(out->buffer) == XML_BUFFER_ALLOC_IMMUTABLE)) 3611 return(-1); 3612 len = strlen((const char *)str); 3613 if (len < 0) return(0); 3614 if (out->error) return(-1); 3615 if (escaping == NULL) escaping = xmlEscapeContent; 3616 3617 do { 3618 oldwritten = written; 3619 3620 /* 3621 * how many bytes to consume and how many bytes to store. 3622 */ 3623 cons = len; 3624 chunk = xmlBufAvail(out->buffer) - 1; 3625 3626 /* 3627 * make sure we have enough room to save first, if this is 3628 * not the case force a flush, but make sure we stay in the loop 3629 */ 3630 if (chunk < 40) { 3631 if (xmlBufGrow(out->buffer, 100) < 0) 3632 return(-1); 3633 oldwritten = -1; 3634 continue; 3635 } 3636 3637 /* 3638 * first handle encoding stuff. 3639 */ 3640 if (out->encoder != NULL) { 3641 /* 3642 * Store the data in the incoming raw buffer 3643 */ 3644 if (out->conv == NULL) { 3645 out->conv = xmlBufCreate(); 3646 } 3647 ret = escaping(xmlBufEnd(out->buffer) , 3648 &chunk, str, &cons); 3649 if ((ret < 0) || (chunk == 0)) /* chunk==0 => nothing done */ 3650 return(-1); 3651 xmlBufAddLen(out->buffer, chunk); 3652 3653 if ((xmlBufUse(out->buffer) < MINLEN) && (cons == len)) 3654 goto done; 3655 3656 /* 3657 * convert as much as possible to the output buffer. 3658 */ 3659 ret = xmlCharEncOutput(out, 0); 3660 if ((ret < 0) && (ret != -3)) { 3661 xmlIOErr(XML_IO_ENCODER, NULL); 3662 out->error = XML_IO_ENCODER; 3663 return(-1); 3664 } 3665 nbchars = xmlBufUse(out->conv); 3666 } else { 3667 ret = escaping(xmlBufEnd(out->buffer), &chunk, str, &cons); 3668 if ((ret < 0) || (chunk == 0)) /* chunk==0 => nothing done */ 3669 return(-1); 3670 xmlBufAddLen(out->buffer, chunk); 3671 nbchars = xmlBufUse(out->buffer); 3672 } 3673 str += cons; 3674 len -= cons; 3675 3676 if ((nbchars < MINLEN) && (len <= 0)) 3677 goto done; 3678 3679 if (out->writecallback) { 3680 /* 3681 * second write the stuff to the I/O channel 3682 */ 3683 if (out->encoder != NULL) { 3684 ret = out->writecallback(out->context, 3685 (const char *)xmlBufContent(out->conv), nbchars); 3686 if (ret >= 0) 3687 xmlBufShrink(out->conv, ret); 3688 } else { 3689 ret = out->writecallback(out->context, 3690 (const char *)xmlBufContent(out->buffer), nbchars); 3691 if (ret >= 0) 3692 xmlBufShrink(out->buffer, ret); 3693 } 3694 if (ret < 0) { 3695 xmlIOErr(XML_IO_WRITE, NULL); 3696 out->error = XML_IO_WRITE; 3697 return(ret); 3698 } 3699 out->written += ret; 3700 } else if (xmlBufAvail(out->buffer) < MINLEN) { 3701 xmlBufGrow(out->buffer, MINLEN); 3702 } 3703 written += nbchars; 3704 } while ((len > 0) && (oldwritten != written)); 3705 3706 done: 3707 #ifdef DEBUG_INPUT 3708 xmlGenericError(xmlGenericErrorContext, 3709 "I/O: wrote %d chars\n", written); 3710 #endif 3711 return(written); 3712 } 3713 3714 /** 3715 * xmlOutputBufferWriteString: 3716 * @out: a buffered parser output 3717 * @str: a zero terminated C string 3718 * 3719 * Write the content of the string in the output I/O buffer 3720 * This routine handle the I18N transcoding from internal UTF-8 3721 * The buffer is lossless, i.e. will store in case of partial 3722 * or delayed writes. 3723 * 3724 * Returns the number of chars immediately written, or -1 3725 * in case of error. 3726 */ 3727 int 3728 xmlOutputBufferWriteString(xmlOutputBufferPtr out, const char *str) { 3729 int len; 3730 3731 if ((out == NULL) || (out->error)) return(-1); 3732 if (str == NULL) 3733 return(-1); 3734 len = strlen(str); 3735 3736 if (len > 0) 3737 return(xmlOutputBufferWrite(out, len, str)); 3738 return(len); 3739 } 3740 3741 /** 3742 * xmlOutputBufferFlush: 3743 * @out: a buffered output 3744 * 3745 * flushes the output I/O channel 3746 * 3747 * Returns the number of byte written or -1 in case of error. 3748 */ 3749 int 3750 xmlOutputBufferFlush(xmlOutputBufferPtr out) { 3751 int nbchars = 0, ret = 0; 3752 3753 if ((out == NULL) || (out->error)) return(-1); 3754 /* 3755 * first handle encoding stuff. 3756 */ 3757 if ((out->conv != NULL) && (out->encoder != NULL)) { 3758 /* 3759 * convert as much as possible to the parser output buffer. 3760 */ 3761 do { 3762 nbchars = xmlCharEncOutput(out, 0); 3763 if (nbchars < 0) { 3764 xmlIOErr(XML_IO_ENCODER, NULL); 3765 out->error = XML_IO_ENCODER; 3766 return(-1); 3767 } 3768 } while (nbchars); 3769 } 3770 3771 /* 3772 * second flush the stuff to the I/O channel 3773 */ 3774 if ((out->conv != NULL) && (out->encoder != NULL) && 3775 (out->writecallback != NULL)) { 3776 ret = out->writecallback(out->context, 3777 (const char *)xmlBufContent(out->conv), 3778 xmlBufUse(out->conv)); 3779 if (ret >= 0) 3780 xmlBufShrink(out->conv, ret); 3781 } else if (out->writecallback != NULL) { 3782 ret = out->writecallback(out->context, 3783 (const char *)xmlBufContent(out->buffer), 3784 xmlBufUse(out->buffer)); 3785 if (ret >= 0) 3786 xmlBufShrink(out->buffer, ret); 3787 } 3788 if (ret < 0) { 3789 xmlIOErr(XML_IO_FLUSH, NULL); 3790 out->error = XML_IO_FLUSH; 3791 return(ret); 3792 } 3793 out->written += ret; 3794 3795 #ifdef DEBUG_INPUT 3796 xmlGenericError(xmlGenericErrorContext, 3797 "I/O: flushed %d chars\n", ret); 3798 #endif 3799 return(ret); 3800 } 3801 #endif /* LIBXML_OUTPUT_ENABLED */ 3802 3803 /** 3804 * xmlParserGetDirectory: 3805 * @filename: the path to a file 3806 * 3807 * lookup the directory for that file 3808 * 3809 * Returns a new allocated string containing the directory, or NULL. 3810 */ 3811 char * 3812 xmlParserGetDirectory(const char *filename) { 3813 char *ret = NULL; 3814 char dir[1024]; 3815 char *cur; 3816 3817 #ifdef _WIN32_WCE /* easy way by now ... wince does not have dirs! */ 3818 return NULL; 3819 #endif 3820 3821 if (xmlInputCallbackInitialized == 0) 3822 xmlRegisterDefaultInputCallbacks(); 3823 3824 if (filename == NULL) return(NULL); 3825 3826 #if defined(WIN32) && !defined(__CYGWIN__) 3827 # define IS_XMLPGD_SEP(ch) ((ch=='/')||(ch=='\\')) 3828 #else 3829 # define IS_XMLPGD_SEP(ch) (ch=='/') 3830 #endif 3831 3832 strncpy(dir, filename, 1023); 3833 dir[1023] = 0; 3834 cur = &dir[strlen(dir)]; 3835 while (cur > dir) { 3836 if (IS_XMLPGD_SEP(*cur)) break; 3837 cur --; 3838 } 3839 if (IS_XMLPGD_SEP(*cur)) { 3840 if (cur == dir) dir[1] = 0; 3841 else *cur = 0; 3842 ret = xmlMemStrdup(dir); 3843 } else { 3844 if (getcwd(dir, 1024) != NULL) { 3845 dir[1023] = 0; 3846 ret = xmlMemStrdup(dir); 3847 } 3848 } 3849 return(ret); 3850 #undef IS_XMLPGD_SEP 3851 } 3852 3853 /**************************************************************** 3854 * * 3855 * External entities loading * 3856 * * 3857 ****************************************************************/ 3858 3859 /** 3860 * xmlCheckHTTPInput: 3861 * @ctxt: an XML parser context 3862 * @ret: an XML parser input 3863 * 3864 * Check an input in case it was created from an HTTP stream, in that 3865 * case it will handle encoding and update of the base URL in case of 3866 * redirection. It also checks for HTTP errors in which case the input 3867 * is cleanly freed up and an appropriate error is raised in context 3868 * 3869 * Returns the input or NULL in case of HTTP error. 3870 */ 3871 xmlParserInputPtr 3872 xmlCheckHTTPInput(xmlParserCtxtPtr ctxt, xmlParserInputPtr ret) { 3873 #ifdef LIBXML_HTTP_ENABLED 3874 if ((ret != NULL) && (ret->buf != NULL) && 3875 (ret->buf->readcallback == xmlIOHTTPRead) && 3876 (ret->buf->context != NULL)) { 3877 const char *encoding; 3878 const char *redir; 3879 const char *mime; 3880 int code; 3881 3882 code = xmlNanoHTTPReturnCode(ret->buf->context); 3883 if (code >= 400) { 3884 /* fatal error */ 3885 if (ret->filename != NULL) 3886 __xmlLoaderErr(ctxt, "failed to load HTTP resource \"%s\"\n", 3887 (const char *) ret->filename); 3888 else 3889 __xmlLoaderErr(ctxt, "failed to load HTTP resource\n", NULL); 3890 xmlFreeInputStream(ret); 3891 ret = NULL; 3892 } else { 3893 3894 mime = xmlNanoHTTPMimeType(ret->buf->context); 3895 if ((xmlStrstr(BAD_CAST mime, BAD_CAST "/xml")) || 3896 (xmlStrstr(BAD_CAST mime, BAD_CAST "+xml"))) { 3897 encoding = xmlNanoHTTPEncoding(ret->buf->context); 3898 if (encoding != NULL) { 3899 xmlCharEncodingHandlerPtr handler; 3900 3901 handler = xmlFindCharEncodingHandler(encoding); 3902 if (handler != NULL) { 3903 xmlSwitchInputEncoding(ctxt, ret, handler); 3904 } else { 3905 __xmlErrEncoding(ctxt, XML_ERR_UNKNOWN_ENCODING, 3906 "Unknown encoding %s", 3907 BAD_CAST encoding, NULL); 3908 } 3909 if (ret->encoding == NULL) 3910 ret->encoding = xmlStrdup(BAD_CAST encoding); 3911 } 3912 #if 0 3913 } else if (xmlStrstr(BAD_CAST mime, BAD_CAST "html")) { 3914 #endif 3915 } 3916 redir = xmlNanoHTTPRedir(ret->buf->context); 3917 if (redir != NULL) { 3918 if (ret->filename != NULL) 3919 xmlFree((xmlChar *) ret->filename); 3920 if (ret->directory != NULL) { 3921 xmlFree((xmlChar *) ret->directory); 3922 ret->directory = NULL; 3923 } 3924 ret->filename = 3925 (char *) xmlStrdup((const xmlChar *) redir); 3926 } 3927 } 3928 } 3929 #endif 3930 return(ret); 3931 } 3932 3933 static int xmlNoNetExists(const char *URL) { 3934 const char *path; 3935 3936 if (URL == NULL) 3937 return(0); 3938 3939 if (!xmlStrncasecmp(BAD_CAST URL, BAD_CAST "file://localhost/", 17)) 3940 #if defined (_WIN32) || defined (__DJGPP__) && !defined(__CYGWIN__) 3941 path = &URL[17]; 3942 #else 3943 path = &URL[16]; 3944 #endif 3945 else if (!xmlStrncasecmp(BAD_CAST URL, BAD_CAST "file:///", 8)) { 3946 #if defined (_WIN32) || defined (__DJGPP__) && !defined(__CYGWIN__) 3947 path = &URL[8]; 3948 #else 3949 path = &URL[7]; 3950 #endif 3951 } else 3952 path = URL; 3953 3954 return xmlCheckFilename(path); 3955 } 3956 3957 #ifdef LIBXML_CATALOG_ENABLED 3958 3959 /** 3960 * xmlResolveResourceFromCatalog: 3961 * @URL: the URL for the entity to load 3962 * @ID: the System ID for the entity to load 3963 * @ctxt: the context in which the entity is called or NULL 3964 * 3965 * Resolves the URL and ID against the appropriate catalog. 3966 * This function is used by xmlDefaultExternalEntityLoader and 3967 * xmlNoNetExternalEntityLoader. 3968 * 3969 * Returns a new allocated URL, or NULL. 3970 */ 3971 static xmlChar * 3972 xmlResolveResourceFromCatalog(const char *URL, const char *ID, 3973 xmlParserCtxtPtr ctxt) { 3974 xmlChar *resource = NULL; 3975 xmlCatalogAllow pref; 3976 3977 /* 3978 * If the resource doesn't exists as a file, 3979 * try to load it from the resource pointed in the catalogs 3980 */ 3981 pref = xmlCatalogGetDefaults(); 3982 3983 if ((pref != XML_CATA_ALLOW_NONE) && (!xmlNoNetExists(URL))) { 3984 /* 3985 * Do a local lookup 3986 */ 3987 if ((ctxt != NULL) && (ctxt->catalogs != NULL) && 3988 ((pref == XML_CATA_ALLOW_ALL) || 3989 (pref == XML_CATA_ALLOW_DOCUMENT))) { 3990 resource = xmlCatalogLocalResolve(ctxt->catalogs, 3991 (const xmlChar *)ID, 3992 (const xmlChar *)URL); 3993 } 3994 /* 3995 * Try a global lookup 3996 */ 3997 if ((resource == NULL) && 3998 ((pref == XML_CATA_ALLOW_ALL) || 3999 (pref == XML_CATA_ALLOW_GLOBAL))) { 4000 resource = xmlCatalogResolve((const xmlChar *)ID, 4001 (const xmlChar *)URL); 4002 } 4003 if ((resource == NULL) && (URL != NULL)) 4004 resource = xmlStrdup((const xmlChar *) URL); 4005 4006 /* 4007 * TODO: do an URI lookup on the reference 4008 */ 4009 if ((resource != NULL) && (!xmlNoNetExists((const char *)resource))) { 4010 xmlChar *tmp = NULL; 4011 4012 if ((ctxt != NULL) && (ctxt->catalogs != NULL) && 4013 ((pref == XML_CATA_ALLOW_ALL) || 4014 (pref == XML_CATA_ALLOW_DOCUMENT))) { 4015 tmp = xmlCatalogLocalResolveURI(ctxt->catalogs, resource); 4016 } 4017 if ((tmp == NULL) && 4018 ((pref == XML_CATA_ALLOW_ALL) || 4019 (pref == XML_CATA_ALLOW_GLOBAL))) { 4020 tmp = xmlCatalogResolveURI(resource); 4021 } 4022 4023 if (tmp != NULL) { 4024 xmlFree(resource); 4025 resource = tmp; 4026 } 4027 } 4028 } 4029 4030 return resource; 4031 } 4032 4033 #endif 4034 4035 /** 4036 * xmlDefaultExternalEntityLoader: 4037 * @URL: the URL for the entity to load 4038 * @ID: the System ID for the entity to load 4039 * @ctxt: the context in which the entity is called or NULL 4040 * 4041 * By default we don't load external entitites, yet. 4042 * 4043 * Returns a new allocated xmlParserInputPtr, or NULL. 4044 */ 4045 static xmlParserInputPtr 4046 xmlDefaultExternalEntityLoader(const char *URL, const char *ID, 4047 xmlParserCtxtPtr ctxt) 4048 { 4049 xmlParserInputPtr ret = NULL; 4050 xmlChar *resource = NULL; 4051 4052 #ifdef DEBUG_EXTERNAL_ENTITIES 4053 xmlGenericError(xmlGenericErrorContext, 4054 "xmlDefaultExternalEntityLoader(%s, xxx)\n", URL); 4055 #endif 4056 if ((ctxt != NULL) && (ctxt->options & XML_PARSE_NONET)) { 4057 int options = ctxt->options; 4058 4059 ctxt->options -= XML_PARSE_NONET; 4060 ret = xmlNoNetExternalEntityLoader(URL, ID, ctxt); 4061 ctxt->options = options; 4062 return(ret); 4063 } 4064 #ifdef LIBXML_CATALOG_ENABLED 4065 resource = xmlResolveResourceFromCatalog(URL, ID, ctxt); 4066 #endif 4067 4068 if (resource == NULL) 4069 resource = (xmlChar *) URL; 4070 4071 if (resource == NULL) { 4072 if (ID == NULL) 4073 ID = "NULL"; 4074 __xmlLoaderErr(ctxt, "failed to load external entity \"%s\"\n", ID); 4075 return (NULL); 4076 } 4077 ret = xmlNewInputFromFile(ctxt, (const char *) resource); 4078 if ((resource != NULL) && (resource != (xmlChar *) URL)) 4079 xmlFree(resource); 4080 return (ret); 4081 } 4082 4083 static xmlExternalEntityLoader xmlCurrentExternalEntityLoader = 4084 xmlDefaultExternalEntityLoader; 4085 4086 /** 4087 * xmlSetExternalEntityLoader: 4088 * @f: the new entity resolver function 4089 * 4090 * Changes the defaultexternal entity resolver function for the application 4091 */ 4092 void 4093 xmlSetExternalEntityLoader(xmlExternalEntityLoader f) { 4094 xmlCurrentExternalEntityLoader = f; 4095 } 4096 4097 /** 4098 * xmlGetExternalEntityLoader: 4099 * 4100 * Get the default external entity resolver function for the application 4101 * 4102 * Returns the xmlExternalEntityLoader function pointer 4103 */ 4104 xmlExternalEntityLoader 4105 xmlGetExternalEntityLoader(void) { 4106 return(xmlCurrentExternalEntityLoader); 4107 } 4108 4109 /** 4110 * xmlLoadExternalEntity: 4111 * @URL: the URL for the entity to load 4112 * @ID: the Public ID for the entity to load 4113 * @ctxt: the context in which the entity is called or NULL 4114 * 4115 * Load an external entity, note that the use of this function for 4116 * unparsed entities may generate problems 4117 * 4118 * Returns the xmlParserInputPtr or NULL 4119 */ 4120 xmlParserInputPtr 4121 xmlLoadExternalEntity(const char *URL, const char *ID, 4122 xmlParserCtxtPtr ctxt) { 4123 if ((URL != NULL) && (xmlNoNetExists(URL) == 0)) { 4124 char *canonicFilename; 4125 xmlParserInputPtr ret; 4126 4127 canonicFilename = (char *) xmlCanonicPath((const xmlChar *) URL); 4128 if (canonicFilename == NULL) { 4129 xmlIOErrMemory("building canonical path\n"); 4130 return(NULL); 4131 } 4132 4133 ret = xmlCurrentExternalEntityLoader(canonicFilename, ID, ctxt); 4134 xmlFree(canonicFilename); 4135 return(ret); 4136 } 4137 return(xmlCurrentExternalEntityLoader(URL, ID, ctxt)); 4138 } 4139 4140 /************************************************************************ 4141 * * 4142 * Disabling Network access * 4143 * * 4144 ************************************************************************/ 4145 4146 /** 4147 * xmlNoNetExternalEntityLoader: 4148 * @URL: the URL for the entity to load 4149 * @ID: the System ID for the entity to load 4150 * @ctxt: the context in which the entity is called or NULL 4151 * 4152 * A specific entity loader disabling network accesses, though still 4153 * allowing local catalog accesses for resolution. 4154 * 4155 * Returns a new allocated xmlParserInputPtr, or NULL. 4156 */ 4157 xmlParserInputPtr 4158 xmlNoNetExternalEntityLoader(const char *URL, const char *ID, 4159 xmlParserCtxtPtr ctxt) { 4160 xmlParserInputPtr input = NULL; 4161 xmlChar *resource = NULL; 4162 4163 #ifdef LIBXML_CATALOG_ENABLED 4164 resource = xmlResolveResourceFromCatalog(URL, ID, ctxt); 4165 #endif 4166 4167 if (resource == NULL) 4168 resource = (xmlChar *) URL; 4169 4170 if (resource != NULL) { 4171 if ((!xmlStrncasecmp(BAD_CAST resource, BAD_CAST "ftp://", 6)) || 4172 (!xmlStrncasecmp(BAD_CAST resource, BAD_CAST "http://", 7))) { 4173 xmlIOErr(XML_IO_NETWORK_ATTEMPT, (const char *) resource); 4174 if (resource != (xmlChar *) URL) 4175 xmlFree(resource); 4176 return(NULL); 4177 } 4178 } 4179 input = xmlDefaultExternalEntityLoader((const char *) resource, ID, ctxt); 4180 if (resource != (xmlChar *) URL) 4181 xmlFree(resource); 4182 return(input); 4183 } 4184 4185 #define bottom_xmlIO 4186 #include "elfgcchack.h" 4187
