xmlIO.c

   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@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 int
 804 xmlNop(void) {
 805     return(0);
 806 }
 807
 808 /**
 809  * xmlFdRead:
 810  * @context:  the I/O context
 811  * @buffer:  where to drop data
 812  * @len:  number of bytes to read
 813  *
 814  * Read @len bytes to @buffer from the I/O channel.
 815  *
 816  * Returns the number of bytes written
 817  */
 818 static int
 819 xmlFdRead (void * context, char * buffer, int len) {
 820     int ret;
 821
 822     ret = read((int) (long) context, &buffer[0], len);
 823     if (ret < 0) xmlIOErr(0, "read()");
 824     return(ret);
 825 }
 826
 827 #ifdef LIBXML_OUTPUT_ENABLED
 828 /**
 829  * xmlFdWrite:
 830  * @context:  the I/O context
 831  * @buffer:  where to get data
 832  * @len:  number of bytes to write
 833  *
 834  * Write @len bytes from @buffer to the I/O channel.
 835  *
 836  * Returns the number of bytes written
 837  */
 838 static int
 839 xmlFdWrite (void * context, const char * buffer, int len) {
 840     int ret = 0;
 841
 842     if (len > 0) {
 843         ret = write((int) (long) context, &buffer[0], len);
 844         if (ret < 0) xmlIOErr(0, "write()");
 845     }
 846     return(ret);
 847 }
 848 #endif /* LIBXML_OUTPUT_ENABLED */
 849
 850 /**
 851  * xmlFdClose:
 852  * @context:  the I/O context
 853  *
 854  * Close an I/O channel
 855  *
 856  * Returns 0 in case of success and error code otherwise
 857  */
 858 static int
 859 xmlFdClose (void * context) {
 860     int ret;
 861     ret = close((int) (long) context);
 862     if (ret < 0) xmlIOErr(0, "close()");
 863     return(ret);
 864 }
 865
 866 /**
 867  * xmlFileMatch:
 868  * @filename:  the URI for matching
 869  *
 870  * input from FILE *
 871  *
 872  * Returns 1 if matches, 0 otherwise
 873  */
 874 int
 875 xmlFileMatch (const char *filename ATTRIBUTE_UNUSED) {
 876     return(1);
 877 }
 878
 879 /**
 880  * xmlFileOpen_real:
 881  * @filename:  the URI for matching
 882  *
 883  * input from FILE *, supports compressed input
 884  * if @filename is " " then the standard input is used
 885  *
 886  * Returns an I/O context or NULL in case of error
 887  */
 888 static void *
 889 xmlFileOpen_real (const char *filename) {
 890     const char *path = NULL;
 891     FILE *fd;
 892
 893     if (filename == NULL)
 894         return(NULL);
 895
 896     if (!strcmp(filename, "-")) {
 897         fd = stdin;
 898         return((void *) fd);
 899     }
 900
 901     if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file://localhost/", 17)) {
 902 #if defined (_WIN32) || defined (__DJGPP__) && !defined(__CYGWIN__)
 903         path = &filename[17];
 904 #else
 905         path = &filename[16];
 906 #endif
 907     } else if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file:///", 8)) {
 908 #if defined (_WIN32) || defined (__DJGPP__) && !defined(__CYGWIN__)
 909         path = &filename[8];
 910 #else
 911         path = &filename[7];
 912 #endif
 913     } else if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file:/", 6)) {
 914         /* lots of generators seems to lazy to read RFC 1738 */
 915 #if defined (_WIN32) || defined (__DJGPP__) && !defined(__CYGWIN__)
 916         path = &filename[6];
 917 #else
 918         path = &filename[5];
 919 #endif
 920     } else
 921         path = filename;
 922
 923     if (path == NULL)
 924         return(NULL);
 925     if (!xmlCheckFilename(path))
 926         return(NULL);
 927
 928 #if defined(_WIN32) || defined (__DJGPP__) && !defined (__CYGWIN__)
 929     fd = xmlWrapOpen(path, 0);
 930 #else
 931     fd = fopen(path, "r");
 932 #endif /* WIN32 */
 933     if (fd == NULL) xmlIOErr(0, path);
 934     return((void *) fd);
 935 }
 936
 937 /**
 938  * xmlFileOpen:
 939  * @filename:  the URI for matching
 940  *
 941  * Wrapper around xmlFileOpen_real that try it with an unescaped
 942  * version of @filename, if this fails fallback to @filename
 943  *
 944  * Returns a handler or NULL in case or failure
 945  */
 946 void *
 947 xmlFileOpen (const char *filename) {
 948     char *unescaped;
 949     void *retval;
 950
 951     retval = xmlFileOpen_real(filename);
 952     if (retval == NULL) {
 953         unescaped = xmlURIUnescapeString(filename, 0, NULL);
 954         if (unescaped != NULL) {
 955             retval = xmlFileOpen_real(unescaped);
 956             xmlFree(unescaped);
 957         }
 958     }
 959
 960     return retval;
 961 }
 962
 963 #ifdef LIBXML_OUTPUT_ENABLED
 964 /**
 965  * xmlFileOpenW:
 966  * @filename:  the URI for matching
 967  *
 968  * output to from FILE *,
 969  * if @filename is "-" then the standard output is used
 970  *
 971  * Returns an I/O context or NULL in case of error
 972  */
 973 static void *
 974 xmlFileOpenW (const char *filename) {
 975     const char *path = NULL;
 976     FILE *fd;
 977
 978     if (!strcmp(filename, "-")) {
 979         fd = stdout;
 980         return((void *) fd);
 981     }
 982
 983     if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file://localhost/", 17))
 984 #if defined (_WIN32) || defined (__DJGPP__) && !defined(__CYGWIN__)
 985         path = &filename[17];
 986 #else
 987         path = &filename[16];
 988 #endif
 989     else if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file:///", 8)) {
 990 #if defined (_WIN32) || defined (__DJGPP__) && !defined(__CYGWIN__)
 991         path = &filename[8];
 992 #else
 993         path = &filename[7];
 994 #endif
 995     } else
 996         path = filename;
 997
 998     if (path == NULL)
 999         return(NULL);
1000
1001 #if defined(_WIN32) || defined (__DJGPP__) && !defined (__CYGWIN__)
1002     fd = xmlWrapOpen(path, 1);
1003 #else
1004            fd = fopen(path, "wb");
1005 #endif /* WIN32 */
1006
1007          if (fd == NULL) xmlIOErr(0, path);
1008     return((void *) fd);
1009 }
1010 #endif /* LIBXML_OUTPUT_ENABLED */
1011
1012 /**
1013  * xmlFileRead:
1014  * @context:  the I/O context
1015  * @buffer:  where to drop data
1016  * @len:  number of bytes to write
1017  *
1018  * Read @len bytes to @buffer from the I/O channel.
1019  *
1020  * Returns the number of bytes written or < 0 in case of failure
1021  */
1022 int
1023 xmlFileRead (void * context, char * buffer, int len) {
1024     int ret;
1025     if ((context == NULL) || (buffer == NULL))
1026         return(-1);
1027     ret = fread(&buffer[0], 1,  len, (FILE *) context);
1028     if (ret < 0) xmlIOErr(0, "fread()");
1029     return(ret);
1030 }
1031
1032 #ifdef LIBXML_OUTPUT_ENABLED
1033 /**
1034  * xmlFileWrite:
1035  * @context:  the I/O context
1036  * @buffer:  where to drop data
1037  * @len:  number of bytes to write
1038  *
1039  * Write @len bytes from @buffer to the I/O channel.
1040  *
1041  * Returns the number of bytes written
1042  */
1043 static int
1044 xmlFileWrite (void * context, const char * buffer, int len) {
1045     int items;
1046
1047     if ((context == NULL) || (buffer == NULL))
1048         return(-1);
1049     items = fwrite(&buffer[0], len, 1, (FILE *) context);
1050     if ((items == 0) && (ferror((FILE *) context))) {
1051         xmlIOErr(0, "fwrite()");
1052         return(-1);
1053     }
1054     return(items * len);
1055 }
1056 #endif /* LIBXML_OUTPUT_ENABLED */
1057
1058 /**
1059  * xmlFileClose:
1060  * @context:  the I/O context
1061  *
1062  * Close an I/O channel
1063  *
1064  * Returns 0 or -1 in case of error
1065  */
1066 int
1067 xmlFileClose (void * context) {
1068     FILE *fil;
1069     int ret;
1070
1071     if (context == NULL)
1072         return(-1);
1073     fil = (FILE *) context;
1074     if ((fil == stdout) || (fil == stderr)) {
1075         ret = fflush(fil);
1076         if (ret < 0)
1077             xmlIOErr(0, "fflush()");
1078         return(0);
1079     }
1080     if (fil == stdin)
1081         return(0);
1082     ret = ( fclose((FILE *) context) == EOF ) ? -1 : 0;
1083     if (ret < 0)
1084         xmlIOErr(0, "fclose()");
1085     return(ret);
1086 }
1087
1088 /**
1089  * xmlFileFlush:
1090  * @context:  the I/O context
1091  *
1092  * Flush an I/O channel
1093  */
1094 static int
1095 xmlFileFlush (void * context) {
1096     int ret;
1097
1098     if (context == NULL)
1099         return(-1);
1100     ret = ( fflush((FILE *) context) == EOF ) ? -1 : 0;
1101     if (ret < 0)
1102         xmlIOErr(0, "fflush()");
1103     return(ret);
1104 }
1105
1106 #ifdef LIBXML_OUTPUT_ENABLED
1107 /**
1108  * xmlBufferWrite:
1109  * @context:  the xmlBuffer
1110  * @buffer:  the data to write
1111  * @len:  number of bytes to write
1112  *
1113  * Write @len bytes from @buffer to the xml buffer
1114  *
1115  * Returns the number of bytes written
1116  */
1117 static int
1118 xmlBufferWrite (void * context, const char * buffer, int len) {
1119     int ret;
1120
1121     ret = xmlBufferAdd((xmlBufferPtr) context, (const xmlChar *) buffer, len);
1122     if (ret != 0)
1123         return(-1);
1124     return(len);
1125 }
1126 #endif
1127
1128 #ifdef HAVE_ZLIB_H
1129 /************************************************************************
1130  *                                                                      *
1131  *              I/O for compressed file accesses                        *
1132  *                                                                      *
1133  ************************************************************************/
1134 /**
1135  * xmlGzfileMatch:
1136  * @filename:  the URI for matching
1137  *
1138  * input from compressed file test
1139  *
1140  * Returns 1 if matches, 0 otherwise
1141  */
1142 static int
1143 xmlGzfileMatch (const char *filename ATTRIBUTE_UNUSED) {
1144     return(1);
1145 }
1146
1147 /**
1148  * xmlGzfileOpen_real:
1149  * @filename:  the URI for matching
1150  *
1151  * input from compressed file open
1152  * if @filename is " " then the standard input is used
1153  *
1154  * Returns an I/O context or NULL in case of error
1155  */
1156 static void *
1157 xmlGzfileOpen_real (const char *filename) {
1158     const char *path = NULL;
1159     gzFile fd;
1160
1161     if (!strcmp(filename, "-")) {
1162         fd = gzdopen(dup(0), "rb");
1163         return((void *) fd);
1164     }
1165
1166     if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file://localhost/", 17))
1167 #if defined (_WIN32) || defined (__DJGPP__) && !defined(__CYGWIN__)
1168         path = &filename[17];
1169 #else
1170         path = &filename[16];
1171 #endif
1172     else if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file:///", 8)) {
1173 #if defined (_WIN32) || defined (__DJGPP__) && !defined(__CYGWIN__)
1174         path = &filename[8];
1175 #else
1176         path = &filename[7];
1177 #endif
1178     } else
1179         path = filename;
1180
1181     if (path == NULL)
1182         return(NULL);
1183     if (!xmlCheckFilename(path))
1184         return(NULL);
1185
1186 #if defined(_WIN32) || defined (__DJGPP__) && !defined (__CYGWIN__)
1187     fd = xmlWrapGzOpen(path, "rb");
1188 #else
1189     fd = gzopen(path, "rb");
1190 #endif
1191     return((void *) fd);
1192 }
1193
1194 /**
1195  * xmlGzfileOpen:
1196  * @filename:  the URI for matching
1197  *
1198  * Wrapper around xmlGzfileOpen if the open fais, it will
1199  * try to unescape @filename
1200  */
1201 static void *
1202 xmlGzfileOpen (const char *filename) {
1203     char *unescaped;
1204     void *retval;
1205
1206     retval = xmlGzfileOpen_real(filename);
1207     if (retval == NULL) {
1208         unescaped = xmlURIUnescapeString(filename, 0, NULL);
1209         if (unescaped != NULL) {
1210             retval = xmlGzfileOpen_real(unescaped);
1211         }
1212         xmlFree(unescaped);
1213     }
1214     return retval;
1215 }
1216
1217 #ifdef LIBXML_OUTPUT_ENABLED
1218 /**
1219  * xmlGzfileOpenW:
1220  * @filename:  the URI for matching
1221  * @compression:  the compression factor (0 - 9 included)
1222  *
1223  * input from compressed file open
1224  * if @filename is " " then the standard input is used
1225  *
1226  * Returns an I/O context or NULL in case of error
1227  */
1228 static void *
1229 xmlGzfileOpenW (const char *filename, int compression) {
1230     const char *path = NULL;
1231     char mode[15];
1232     gzFile fd;
1233
1234     snprintf(mode, sizeof(mode), "wb%d", compression);
1235     if (!strcmp(filename, "-")) {
1236         fd = gzdopen(dup(1), mode);
1237         return((void *) fd);
1238     }
1239
1240     if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file://localhost/", 17))
1241 #if defined (_WIN32) || defined (__DJGPP__) && !defined(__CYGWIN__)
1242         path = &filename[17];
1243 #else
1244         path = &filename[16];
1245 #endif
1246     else if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file:///", 8)) {
1247 #if defined (_WIN32) || defined (__DJGPP__) && !defined(__CYGWIN__)
1248         path = &filename[8];
1249 #else
1250         path = &filename[7];
1251 #endif
1252     } else
1253         path = filename;
1254
1255     if (path == NULL)
1256         return(NULL);
1257
1258 #if defined(_WIN32) || defined (__DJGPP__) && !defined (__CYGWIN__)
1259     fd = xmlWrapGzOpen(path, mode);
1260 #else
1261     fd = gzopen(path, mode);
1262 #endif
1263     return((void *) fd);
1264 }
1265 #endif /* LIBXML_OUTPUT_ENABLED */
1266
1267 /**
1268  * xmlGzfileRead:
1269  * @context:  the I/O context
1270  * @buffer:  where to drop data
1271  * @len:  number of bytes to write
1272  *
1273  * Read @len bytes to @buffer from the compressed I/O channel.
1274  *
1275  * Returns the number of bytes written
1276  */
1277 static int
1278 xmlGzfileRead (void * context, char * buffer, int len) {
1279     int ret;
1280
1281     ret = gzread((gzFile) context, &buffer[0], len);
1282     if (ret < 0) xmlIOErr(0, "gzread()");
1283     return(ret);
1284 }
1285
1286 #ifdef LIBXML_OUTPUT_ENABLED
1287 /**
1288  * xmlGzfileWrite:
1289  * @context:  the I/O context
1290  * @buffer:  where to drop data
1291  * @len:  number of bytes to write
1292  *
1293  * Write @len bytes from @buffer to the compressed I/O channel.
1294  *
1295  * Returns the number of bytes written
1296  */
1297 static int
1298 xmlGzfileWrite (void * context, const char * buffer, int len) {
1299     int ret;
1300
1301     ret = gzwrite((gzFile) context, (char *) &buffer[0], len);
1302     if (ret < 0) xmlIOErr(0, "gzwrite()");
1303     return(ret);
1304 }
1305 #endif /* LIBXML_OUTPUT_ENABLED */
1306
1307 /**
1308  * xmlGzfileClose:
1309  * @context:  the I/O context
1310  *
1311  * Close a compressed I/O channel
1312  */
1313 static int
1314 xmlGzfileClose (void * context) {
1315     int ret;
1316
1317     ret =  (gzclose((gzFile) context) == Z_OK ) ? 0 : -1;
1318     if (ret < 0) xmlIOErr(0, "gzclose()");
1319     return(ret);
1320 }
1321 #endif /* HAVE_ZLIB_H */
1322
1323 #ifdef HAVE_LZMA_H
1324 /************************************************************************
1325  *                                                                      *
1326  *              I/O for compressed file accesses                        *
1327  *                                                                      *
1328  ************************************************************************/
1329 #include "xzlib.h"
1330 /**
1331  * xmlXzfileMatch:
1332  * @filename:  the URI for matching
1333  *
1334  * input from compressed file test
1335  *
1336  * Returns 1 if matches, 0 otherwise
1337  */
1338 static int
1339 xmlXzfileMatch (const char *filename ATTRIBUTE_UNUSED) {
1340     return(1);
1341 }
1342
1343 /**
1344  * xmlXzFileOpen_real:
1345  * @filename:  the URI for matching
1346  *
1347  * input from compressed file open
1348  * if @filename is " " then the standard input is used
1349  *
1350  * Returns an I/O context or NULL in case of error
1351  */
1352 static void *
1353 xmlXzfileOpen_real (const char *filename) {
1354     const char *path = NULL;
1355     xzFile fd;
1356
1357     if (!strcmp(filename, "-")) {
1358         fd = __libxml2_xzdopen(dup(0), "rb");
1359         return((void *) fd);
1360     }
1361
1362     if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file://localhost/", 17)) {
1363         path = &filename[16];
1364     } else if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file:///", 8)) {
1365         path = &filename[7];
1366     } else if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file:/", 6)) {
1367         /* lots of generators seems to lazy to read RFC 1738 */
1368         path = &filename[5];
1369     } else
1370         path = filename;
1371
1372     if (path == NULL)
1373         return(NULL);
1374     if (!xmlCheckFilename(path))
1375         return(NULL);
1376
1377     fd = __libxml2_xzopen(path, "rb");
1378     return((void *) fd);
1379 }
1380
1381 /**
1382  * xmlXzfileOpen:
1383  * @filename:  the URI for matching
1384  *
1385  * Wrapper around xmlXzfileOpen_real that try it with an unescaped
1386  * version of @filename, if this fails fallback to @filename
1387  *
1388  * Returns a handler or NULL in case or failure
1389  */
1390 static void *
1391 xmlXzfileOpen (const char *filename) {
1392     char *unescaped;
1393     void *retval;
1394
1395     retval = xmlXzfileOpen_real(filename);
1396     if (retval == NULL) {
1397         unescaped = xmlURIUnescapeString(filename, 0, NULL);
1398         if (unescaped != NULL) {
1399             retval = xmlXzfileOpen_real(unescaped);
1400         }
1401         xmlFree(unescaped);
1402     }
1403
1404     return retval;
1405 }
1406
1407 /**
1408  * xmlXzfileRead:
1409  * @context:  the I/O context
1410  * @buffer:  where to drop data
1411  * @len:  number of bytes to write
1412  *
1413  * Read @len bytes to @buffer from the compressed I/O channel.
1414  *
1415  * Returns the number of bytes written
1416  */
1417 static int
1418 xmlXzfileRead (void * context, char * buffer, int len) {
1419     int ret;
1420
1421     ret = __libxml2_xzread((xzFile) context, &buffer[0], len);
1422     if (ret < 0) xmlIOErr(0, "xzread()");
1423     return(ret);
1424 }
1425
1426 /**
1427  * xmlXzfileClose:
1428  * @context:  the I/O context
1429  *
1430  * Close a compressed I/O channel
1431  */
1432 static int
1433 xmlXzfileClose (void * context) {
1434     int ret;
1435
1436     ret =  (__libxml2_xzclose((xzFile) context) == LZMA_OK ) ? 0 : -1;
1437     if (ret < 0) xmlIOErr(0, "xzclose()");
1438     return(ret);
1439 }
1440 #endif /* HAVE_LZMA_H */
1441
1442 #ifdef LIBXML_HTTP_ENABLED
1443 /************************************************************************
1444  *                                                                      *
1445  *                      I/O for HTTP file accesses                      *
1446  *                                                                      *
1447  ************************************************************************/
1448
1449 #ifdef LIBXML_OUTPUT_ENABLED
1450 typedef struct xmlIOHTTPWriteCtxt_
1451 {
1452     int                 compression;
1453
1454     char *              uri;
1455
1456     void *              doc_buff;
1457
1458 } xmlIOHTTPWriteCtxt, *xmlIOHTTPWriteCtxtPtr;
1459
1460 #ifdef HAVE_ZLIB_H
1461
1462 #define DFLT_WBITS              ( -15 )
1463 #define DFLT_MEM_LVL            ( 8 )
1464 #define GZ_MAGIC1               ( 0x1f )
1465 #define GZ_MAGIC2               ( 0x8b )
1466 #define LXML_ZLIB_OS_CODE       ( 0x03 )
1467 #define INIT_HTTP_BUFF_SIZE     ( 32768 )
1468 #define DFLT_ZLIB_RATIO         ( 5 )
1469
1470 /*
1471 **  Data structure and functions to work with sending compressed data
1472 **  via HTTP.
1473 */
1474
1475 typedef struct xmlZMemBuff_
1476 {
1477    unsigned long        size;
1478    unsigned long        crc;
1479
1480    unsigned char *      zbuff;
1481    z_stream             zctrl;
1482
1483 } xmlZMemBuff, *xmlZMemBuffPtr;
1484
1485 /**
1486  * append_reverse_ulong
1487  * @buff:  Compressed memory buffer
1488  * @data:  Unsigned long to append
1489  *
1490  * Append a unsigned long in reverse byte order to the end of the
1491  * memory buffer.
1492  */
1493 static void
1494 append_reverse_ulong( xmlZMemBuff * buff, unsigned long data ) {
1495
1496     int         idx;
1497
1498     if ( buff == NULL )
1499         return;
1500
1501     /*
1502     **  This is plagiarized from putLong in gzio.c (zlib source) where
1503     **  the number "4" is hardcoded.  If zlib is ever patched to
1504     **  support 64 bit file sizes, this code would need to be patched
1505     **  as well.
1506     */
1507
1508     for ( idx = 0; idx < 4; idx++ ) {
1509         *buff->zctrl.next_out = ( data & 0xff );
1510         data >>= 8;
1511         buff->zctrl.next_out++;
1512     }
1513
1514     return;
1515 }
1516
1517 /**
1518  *
1519  * xmlFreeZMemBuff
1520  * @buff:  The memory buffer context to clear
1521  *
1522  * Release all the resources associated with the compressed memory buffer.
1523  */
1524 static void
1525 xmlFreeZMemBuff( xmlZMemBuffPtr buff ) {
1526
1527 #ifdef DEBUG_HTTP
1528     int z_err;
1529 #endif
1530
1531     if ( buff == NULL )
1532         return;
1533
1534     xmlFree( buff->zbuff );
1535 #ifdef DEBUG_HTTP
1536     z_err = deflateEnd( &buff->zctrl );
1537     if ( z_err != Z_OK )
1538         xmlGenericError( xmlGenericErrorContext,
1539                         "xmlFreeZMemBuff:  Error releasing zlib context:  %d\n",
1540                         z_err );
1541 #else
1542     deflateEnd( &buff->zctrl );
1543 #endif
1544
1545     xmlFree( buff );
1546     return;
1547 }
1548
1549 /**
1550  * xmlCreateZMemBuff
1551  *@compression: Compression value to use
1552  *
1553  * Create a memory buffer to hold the compressed XML document.  The
1554  * compressed document in memory will end up being identical to what
1555  * would be created if gzopen/gzwrite/gzclose were being used to
1556  * write the document to disk.  The code for the header/trailer data to
1557  * the compression is plagiarized from the zlib source files.
1558  */
1559 static void *
1560 xmlCreateZMemBuff( int compression ) {
1561
1562     int                 z_err;
1563     int                 hdr_lgth;
1564     xmlZMemBuffPtr      buff = NULL;
1565
1566     if ( ( compression < 1 ) || ( compression > 9 ) )
1567         return ( NULL );
1568
1569     /*  Create the control and data areas  */
1570
1571     buff = xmlMalloc( sizeof( xmlZMemBuff ) );
1572     if ( buff == NULL ) {
1573         xmlIOErrMemory("creating buffer context");
1574         return ( NULL );
1575     }
1576
1577     (void)memset( buff, 0, sizeof( xmlZMemBuff ) );
1578     buff->size = INIT_HTTP_BUFF_SIZE;
1579     buff->zbuff = xmlMalloc( buff->size );
1580     if ( buff->zbuff == NULL ) {
1581         xmlFreeZMemBuff( buff );
1582         xmlIOErrMemory("creating buffer");
1583         return ( NULL );
1584     }
1585
1586     z_err = deflateInit2( &buff->zctrl, compression, Z_DEFLATED,
1587                             DFLT_WBITS, DFLT_MEM_LVL, Z_DEFAULT_STRATEGY );
1588     if ( z_err != Z_OK ) {
1589         xmlChar msg[500];
1590         xmlFreeZMemBuff( buff );
1591         buff = NULL;
1592         xmlStrPrintf(msg, 500,
1593                     (const xmlChar *) "xmlCreateZMemBuff:  %s %d\n",
1594                     "Error initializing compression context.  ZLIB error:",
1595                     z_err );
1596         xmlIOErr(XML_IO_WRITE, (const char *) msg);
1597         return ( NULL );
1598     }
1599
1600     /*  Set the header data.  The CRC will be needed for the trailer  */
1601     buff->crc = crc32( 0L, NULL, 0 );
1602     hdr_lgth = snprintf( (char *)buff->zbuff, buff->size,
1603                         "%c%c%c%c%c%c%c%c%c%c",
1604                         GZ_MAGIC1, GZ_MAGIC2, Z_DEFLATED,
1605                         0, 0, 0, 0, 0, 0, LXML_ZLIB_OS_CODE );
1606     buff->zctrl.next_out  = buff->zbuff + hdr_lgth;
1607     buff->zctrl.avail_out = buff->size - hdr_lgth;
1608
1609     return ( buff );
1610 }
1611
1612 /**
1613  * xmlZMemBuffExtend
1614  * @buff:  Buffer used to compress and consolidate data.
1615  * @ext_amt:   Number of bytes to extend the buffer.
1616  *
1617  * Extend the internal buffer used to store the compressed data by the
1618  * specified amount.
1619  *
1620  * Returns 0 on success or -1 on failure to extend the buffer.  On failure
1621  * the original buffer still exists at the original size.
1622  */
1623 static int
1624 xmlZMemBuffExtend( xmlZMemBuffPtr buff, size_t ext_amt ) {
1625
1626     int                 rc = -1;
1627     size_t              new_size;
1628     size_t              cur_used;
1629
1630     unsigned char *     tmp_ptr = NULL;
1631
1632     if ( buff == NULL )
1633         return ( -1 );
1634
1635     else if ( ext_amt == 0 )
1636         return ( 0 );
1637
1638     cur_used = buff->zctrl.next_out - buff->zbuff;
1639     new_size = buff->size + ext_amt;
1640
1641 #ifdef DEBUG_HTTP
1642     if ( cur_used > new_size )
1643         xmlGenericError( xmlGenericErrorContext,
1644                         "xmlZMemBuffExtend:  %s\n%s %d bytes.\n",
1645                         "Buffer overwrite detected during compressed memory",
1646                         "buffer extension.  Overflowed by",
1647                         (cur_used - new_size ) );
1648 #endif
1649
1650     tmp_ptr = xmlRealloc( buff->zbuff, new_size );
1651     if ( tmp_ptr != NULL ) {
1652         rc = 0;
1653         buff->size  = new_size;
1654         buff->zbuff = tmp_ptr;
1655         buff->zctrl.next_out  = tmp_ptr + cur_used;
1656         buff->zctrl.avail_out = new_size - cur_used;
1657     }
1658     else {
1659         xmlChar msg[500];
1660         xmlStrPrintf(msg, 500,
1661                     (const xmlChar *) "xmlZMemBuffExtend:  %s %lu bytes.\n",
1662                     "Allocation failure extending output buffer to",
1663                     new_size );
1664         xmlIOErr(XML_IO_WRITE, (const char *) msg);
1665     }
1666
1667     return ( rc );
1668 }
1669
1670 /**
1671  * xmlZMemBuffAppend
1672  * @buff:  Buffer used to compress and consolidate data
1673  * @src:   Uncompressed source content to append to buffer
1674  * @len:   Length of source data to append to buffer
1675  *
1676  * Compress and append data to the internal buffer.  The data buffer
1677  * will be expanded if needed to store the additional data.
1678  *
1679  * Returns the number of bytes appended to the buffer or -1 on error.
1680  */
1681 static int
1682 xmlZMemBuffAppend( xmlZMemBuffPtr buff, const char * src, int len ) {
1683
1684     int         z_err;
1685     size_t      min_accept;
1686
1687     if ( ( buff == NULL ) || ( src == NULL ) )
1688         return ( -1 );
1689
1690     buff->zctrl.avail_in = len;
1691     buff->zctrl.next_in  = (unsigned char *)src;
1692     while ( buff->zctrl.avail_in > 0 ) {
1693         /*
1694         **  Extend the buffer prior to deflate call if a reasonable amount
1695         **  of output buffer space is not available.
1696         */
1697         min_accept = buff->zctrl.avail_in / DFLT_ZLIB_RATIO;
1698         if ( buff->zctrl.avail_out <= min_accept ) {
1699             if ( xmlZMemBuffExtend( buff, buff->size ) == -1 )
1700                 return ( -1 );
1701         }
1702
1703         z_err = deflate( &buff->zctrl, Z_NO_FLUSH );
1704         if ( z_err != Z_OK ) {
1705             xmlChar msg[500];
1706             xmlStrPrintf(msg, 500,
1707                         (const xmlChar *) "xmlZMemBuffAppend:  %s %d %s - %d",
1708                         "Compression error while appending",
1709                         len, "bytes to buffer.  ZLIB error", z_err );
1710             xmlIOErr(XML_IO_WRITE, (const char *) msg);
1711             return ( -1 );
1712         }
1713     }
1714
1715     buff->crc = crc32( buff->crc, (unsigned char *)src, len );
1716
1717     return ( len );
1718 }
1719
1720 /**
1721  * xmlZMemBuffGetContent
1722  * @buff:  Compressed memory content buffer
1723  * @data_ref:  Pointer reference to point to compressed content
1724  *
1725  * Flushes the compression buffers, appends gzip file trailers and
1726  * returns the compressed content and length of the compressed data.
1727  * NOTE:  The gzip trailer code here is plagiarized from zlib source.
1728  *
1729  * Returns the length of the compressed data or -1 on error.
1730  */
1731 static int
1732 xmlZMemBuffGetContent( xmlZMemBuffPtr buff, char ** data_ref ) {
1733
1734     int         zlgth = -1;
1735     int         z_err;
1736
1737     if ( ( buff == NULL ) || ( data_ref == NULL ) )
1738         return ( -1 );
1739
1740     /*  Need to loop until compression output buffers are flushed  */
1741
1742     do
1743     {
1744         z_err = deflate( &buff->zctrl, Z_FINISH );
1745         if ( z_err == Z_OK ) {
1746             /*  In this case Z_OK means more buffer space needed  */
1747
1748             if ( xmlZMemBuffExtend( buff, buff->size ) == -1 )
1749                 return ( -1 );
1750         }
1751     }
1752     while ( z_err == Z_OK );
1753
1754     /*  If the compression state is not Z_STREAM_END, some error occurred  */
1755
1756     if ( z_err == Z_STREAM_END ) {
1757
1758         /*  Need to append the gzip data trailer  */
1759
1760         if ( buff->zctrl.avail_out < ( 2 * sizeof( unsigned long ) ) ) {
1761             if ( xmlZMemBuffExtend(buff, (2 * sizeof(unsigned long))) == -1 )
1762                 return ( -1 );
1763         }
1764
1765         /*
1766         **  For whatever reason, the CRC and length data are pushed out
1767         **  in reverse byte order.  So a memcpy can't be used here.
1768         */
1769
1770         append_reverse_ulong( buff, buff->crc );
1771         append_reverse_ulong( buff, buff->zctrl.total_in );
1772
1773         zlgth = buff->zctrl.next_out - buff->zbuff;
1774         *data_ref = (char *)buff->zbuff;
1775     }
1776
1777     else {
1778         xmlChar msg[500];
1779         xmlStrPrintf(msg, 500,
1780                     (const xmlChar *) "xmlZMemBuffGetContent:  %s - %d\n",
1781                     "Error flushing zlib buffers.  Error code", z_err );
1782         xmlIOErr(XML_IO_WRITE, (const char *) msg);
1783     }
1784
1785     return ( zlgth );
1786 }
1787 #endif /* LIBXML_OUTPUT_ENABLED */
1788 #endif  /*  HAVE_ZLIB_H  */
1789
1790 #ifdef LIBXML_OUTPUT_ENABLED
1791 /**
1792  * xmlFreeHTTPWriteCtxt
1793  * @ctxt:  Context to cleanup
1794  *
1795  * Free allocated memory and reclaim system resources.
1796  *
1797  * No return value.
1798  */
1799 static void
1800 xmlFreeHTTPWriteCtxt( xmlIOHTTPWriteCtxtPtr ctxt )
1801 {
1802     if ( ctxt->uri != NULL )
1803         xmlFree( ctxt->uri );
1804
1805     if ( ctxt->doc_buff != NULL ) {
1806
1807 #ifdef HAVE_ZLIB_H
1808         if ( ctxt->compression > 0 ) {
1809             xmlFreeZMemBuff( ctxt->doc_buff );
1810         }
1811         else
1812 #endif
1813         {
1814             xmlOutputBufferClose( ctxt->doc_buff );
1815         }
1816     }
1817
1818     xmlFree( ctxt );
1819     return;
1820 }
1821 #endif /* LIBXML_OUTPUT_ENABLED */
1822
1823
1824 /**
1825  * xmlIOHTTPMatch:
1826  * @filename:  the URI for matching
1827  *
1828  * check if the URI matches an HTTP one
1829  *
1830  * Returns 1 if matches, 0 otherwise
1831  */
1832 int
1833 xmlIOHTTPMatch (const char *filename) {
1834     if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "http://", 7))
1835         return(1);
1836     return(0);
1837 }
1838
1839 /**
1840  * xmlIOHTTPOpen:
1841  * @filename:  the URI for matching
1842  *
1843  * open an HTTP I/O channel
1844  *
1845  * Returns an I/O context or NULL in case of error
1846  */
1847 void *
1848 xmlIOHTTPOpen (const char *filename) {
1849     return(xmlNanoHTTPOpen(filename, NULL));
1850 }
1851
1852 #ifdef LIBXML_OUTPUT_ENABLED
1853 /**
1854  * xmlIOHTTPOpenW:
1855  * @post_uri:  The destination URI for the document
1856  * @compression:  The compression desired for the document.
1857  *
1858  * Open a temporary buffer to collect the document for a subsequent HTTP POST
1859  * request.  Non-static as is called from the output buffer creation routine.
1860  *
1861  * Returns an I/O context or NULL in case of error.
1862  */
1863
1864 void *
1865 xmlIOHTTPOpenW(const char *post_uri, int compression)
1866 {
1867
1868     xmlIOHTTPWriteCtxtPtr ctxt = NULL;
1869
1870     if (post_uri == NULL)
1871         return (NULL);
1872
1873     ctxt = xmlMalloc(sizeof(xmlIOHTTPWriteCtxt));
1874     if (ctxt == NULL) {
1875         xmlIOErrMemory("creating HTTP output context");
1876         return (NULL);
1877     }
1878
1879     (void) memset(ctxt, 0, sizeof(xmlIOHTTPWriteCtxt));
1880
1881     ctxt->uri = (char *) xmlStrdup((const xmlChar *)post_uri);
1882     if (ctxt->uri == NULL) {
1883         xmlIOErrMemory("copying URI");
1884         xmlFreeHTTPWriteCtxt(ctxt);
1885         return (NULL);
1886     }
1887
1888     /*
1889      * **  Since the document length is required for an HTTP post,
1890      * **  need to put the document into a buffer.  A memory buffer
1891      * **  is being used to avoid pushing the data to disk and back.
1892      */
1893
1894 #ifdef HAVE_ZLIB_H
1895     if ((compression > 0) && (compression <= 9)) {
1896
1897         ctxt->compression = compression;
1898         ctxt->doc_buff = xmlCreateZMemBuff(compression);
1899     } else
1900 #endif
1901     {
1902         /*  Any character conversions should have been done before this  */
1903
1904         ctxt->doc_buff = xmlAllocOutputBufferInternal(NULL);
1905     }
1906
1907     if (ctxt->doc_buff == NULL) {
1908         xmlFreeHTTPWriteCtxt(ctxt);
1909         ctxt = NULL;
1910     }
1911
1912     return (ctxt);
1913 }
1914 #endif /* LIBXML_OUTPUT_ENABLED */
1915
1916 #ifdef LIBXML_OUTPUT_ENABLED
1917 /**
1918  * xmlIOHTTPDfltOpenW
1919  * @post_uri:  The destination URI for this document.
1920  *
1921  * Calls xmlIOHTTPOpenW with no compression to set up for a subsequent
1922  * HTTP post command.  This function should generally not be used as
1923  * the open callback is short circuited in xmlOutputBufferCreateFile.
1924  *
1925  * Returns a pointer to the new IO context.
1926  */
1927 static void *
1928 xmlIOHTTPDfltOpenW( const char * post_uri ) {
1929     return ( xmlIOHTTPOpenW( post_uri, 0 ) );
1930 }
1931 #endif /* LIBXML_OUTPUT_ENABLED */
1932
1933 /**
1934  * xmlIOHTTPRead:
1935  * @context:  the I/O context
1936  * @buffer:  where to drop data
1937  * @len:  number of bytes to write
1938  *
1939  * Read @len bytes to @buffer from the I/O channel.
1940  *
1941  * Returns the number of bytes written
1942  */
1943 int
1944 xmlIOHTTPRead(void * context, char * buffer, int len) {
1945     if ((buffer == NULL) || (len < 0)) return(-1);
1946     return(xmlNanoHTTPRead(context, &buffer[0], len));
1947 }
1948
1949 #ifdef LIBXML_OUTPUT_ENABLED
1950 /**
1951  * xmlIOHTTPWrite
1952  * @context:  previously opened writing context
1953  * @buffer:   data to output to temporary buffer
1954  * @len:      bytes to output
1955  *
1956  * Collect data from memory buffer into a temporary file for later
1957  * processing.
1958  *
1959  * Returns number of bytes written.
1960  */
1961
1962 static int
1963 xmlIOHTTPWrite( void * context, const char * buffer, int len ) {
1964
1965     xmlIOHTTPWriteCtxtPtr       ctxt = context;
1966
1967     if ( ( ctxt == NULL ) || ( ctxt->doc_buff == NULL ) || ( buffer == NULL ) )
1968         return ( -1 );
1969
1970     if ( len > 0 ) {
1971
1972         /*  Use gzwrite or fwrite as previously setup in the open call  */
1973
1974 #ifdef HAVE_ZLIB_H
1975         if ( ctxt->compression > 0 )
1976             len = xmlZMemBuffAppend( ctxt->doc_buff, buffer, len );
1977
1978         else
1979 #endif
1980             len = xmlOutputBufferWrite( ctxt->doc_buff, len, buffer );
1981
1982         if ( len < 0 ) {
1983             xmlChar msg[500];
1984             xmlStrPrintf(msg, 500,
1985                         (const xmlChar *) "xmlIOHTTPWrite:  %s\n%s '%s'.\n",
1986                         "Error appending to internal buffer.",
1987                         "Error sending document to URI",
1988                         ctxt->uri );
1989             xmlIOErr(XML_IO_WRITE, (const char *) msg);
1990         }
1991     }
1992
1993     return ( len );
1994 }
1995 #endif /* LIBXML_OUTPUT_ENABLED */
1996
1997
1998 /**
1999  * xmlIOHTTPClose:
2000  * @context:  the I/O context
2001  *
2002  * Close an HTTP I/O channel
2003  *
2004  * Returns 0
2005  */
2006 int
2007 xmlIOHTTPClose (void * context) {
2008     xmlNanoHTTPClose(context);
2009     return 0;
2010 }
2011
2012 #ifdef LIBXML_OUTPUT_ENABLED
2013 /**
2014  * xmlIOHTTCloseWrite
2015  * @context:  The I/O context
2016  * @http_mthd: The HTTP method to be used when sending the data
2017  *
2018  * Close the transmit HTTP I/O channel and actually send the data.
2019  */
2020 static int
2021 xmlIOHTTPCloseWrite( void * context, const char * http_mthd ) {
2022
2023     int                         close_rc = -1;
2024     int                         http_rtn = 0;
2025     int                         content_lgth = 0;
2026     xmlIOHTTPWriteCtxtPtr       ctxt = context;
2027
2028     char *                      http_content = NULL;
2029     char *                      content_encoding = NULL;
2030     char *                      content_type = (char *) "text/xml";
2031     void *                      http_ctxt = NULL;
2032
2033     if ( ( ctxt == NULL ) || ( http_mthd == NULL ) )
2034         return ( -1 );
2035
2036     /*  Retrieve the content from the appropriate buffer  */
2037
2038 #ifdef HAVE_ZLIB_H
2039
2040     if ( ctxt->compression > 0 ) {
2041         content_lgth = xmlZMemBuffGetContent( ctxt->doc_buff, &http_content );
2042         content_encoding = (char *) "Content-Encoding: gzip";
2043     }
2044     else
2045 #endif
2046     {
2047         /*  Pull the data out of the memory output buffer  */
2048
2049         xmlOutputBufferPtr      dctxt = ctxt->doc_buff;
2050         http_content = (char *) xmlBufContent(dctxt->buffer);
2051         content_lgth = xmlBufUse(dctxt->buffer);
2052     }
2053
2054     if ( http_content == NULL ) {
2055         xmlChar msg[500];
2056         xmlStrPrintf(msg, 500,
2057                      (const xmlChar *) "xmlIOHTTPCloseWrite:  %s '%s' %s '%s'.\n",
2058                      "Error retrieving content.\nUnable to",
2059                      http_mthd, "data to URI", ctxt->uri );
2060         xmlIOErr(XML_IO_WRITE, (const char *) msg);
2061     }
2062
2063     else {
2064
2065         http_ctxt = xmlNanoHTTPMethod( ctxt->uri, http_mthd, http_content,
2066                                         &content_type, content_encoding,
2067                                         content_lgth );
2068
2069         if ( http_ctxt != NULL ) {
2070 #ifdef DEBUG_HTTP
2071             /*  If testing/debugging - dump reply with request content  */
2072
2073             FILE *      tst_file = NULL;
2074             char        buffer[ 4096 ];
2075             char *      dump_name = NULL;
2076             int         avail;
2077
2078             xmlGenericError( xmlGenericErrorContext,
2079                         "xmlNanoHTTPCloseWrite:  HTTP %s to\n%s returned %d.\n",
2080                         http_mthd, ctxt->uri,
2081                         xmlNanoHTTPReturnCode( http_ctxt ) );
2082
2083             /*
2084             **  Since either content or reply may be gzipped,
2085             **  dump them to separate files instead of the
2086             **  standard error context.
2087             */
2088
2089             dump_name = tempnam( NULL, "lxml" );
2090             if ( dump_name != NULL ) {
2091                 (void)snprintf( buffer, sizeof(buffer), "%s.content", dump_name );
2092
2093                 tst_file = fopen( buffer, "wb" );
2094                 if ( tst_file != NULL ) {
2095                     xmlGenericError( xmlGenericErrorContext,
2096                         "Transmitted content saved in file:  %s\n", buffer );
2097
2098                     fwrite( http_content, sizeof( char ),
2099                                         content_lgth, tst_file );
2100                     fclose( tst_file );
2101                 }
2102
2103                 (void)snprintf( buffer, sizeof(buffer), "%s.reply", dump_name );
2104                 tst_file = fopen( buffer, "wb" );
2105                 if ( tst_file != NULL ) {
2106                     xmlGenericError( xmlGenericErrorContext,
2107                         "Reply content saved in file:  %s\n", buffer );
2108
2109
2110                     while ( (avail = xmlNanoHTTPRead( http_ctxt,
2111                                         buffer, sizeof( buffer ) )) > 0 ) {
2112
2113                         fwrite( buffer, sizeof( char ), avail, tst_file );
2114                     }
2115
2116                     fclose( tst_file );
2117                 }
2118
2119                 free( dump_name );
2120             }
2121 #endif  /*  DEBUG_HTTP  */
2122
2123             http_rtn = xmlNanoHTTPReturnCode( http_ctxt );
2124             if ( ( http_rtn >= 200 ) && ( http_rtn < 300 ) )
2125                 close_rc = 0;
2126             else {
2127                 xmlChar msg[500];
2128                 xmlStrPrintf(msg, 500,
2129     (const xmlChar *) "xmlIOHTTPCloseWrite: HTTP '%s' of %d %s\n'%s' %s %d\n",
2130                             http_mthd, content_lgth,
2131                             "bytes to URI", ctxt->uri,
2132                             "failed.  HTTP return code:", http_rtn );
2133                 xmlIOErr(XML_IO_WRITE, (const char *) msg);
2134             }
2135
2136             xmlNanoHTTPClose( http_ctxt );
2137             xmlFree( content_type );
2138         }
2139     }
2140
2141     /*  Final cleanups  */
2142
2143     xmlFreeHTTPWriteCtxt( ctxt );
2144
2145     return ( close_rc );
2146 }
2147
2148 /**
2149  * xmlIOHTTPClosePut
2150  *
2151  * @context:  The I/O context
2152  *
2153  * Close the transmit HTTP I/O channel and actually send data using a PUT
2154  * HTTP method.
2155  */
2156 static int
2157 xmlIOHTTPClosePut( void * ctxt ) {
2158     return ( xmlIOHTTPCloseWrite( ctxt, "PUT" ) );
2159 }
2160
2161
2162 /**
2163  * xmlIOHTTPClosePost
2164  *
2165  * @context:  The I/O context
2166  *
2167  * Close the transmit HTTP I/O channel and actually send data using a POST
2168  * HTTP method.
2169  */
2170 static int
2171 xmlIOHTTPClosePost( void * ctxt ) {
2172     return ( xmlIOHTTPCloseWrite( ctxt, "POST" ) );
2173 }
2174 #endif /* LIBXML_OUTPUT_ENABLED */
2175
2176 #endif /* LIBXML_HTTP_ENABLED */
2177
2178 #ifdef LIBXML_FTP_ENABLED
2179 /************************************************************************
2180  *                                                                      *
2181  *                      I/O for FTP file accesses                       *
2182  *                                                                      *
2183  ************************************************************************/
2184 /**
2185  * xmlIOFTPMatch:
2186  * @filename:  the URI for matching
2187  *
2188  * check if the URI matches an FTP one
2189  *
2190  * Returns 1 if matches, 0 otherwise
2191  */
2192 int
2193 xmlIOFTPMatch (const char *filename) {
2194     if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "ftp://", 6))
2195         return(1);
2196     return(0);
2197 }
2198
2199 /**
2200  * xmlIOFTPOpen:
2201  * @filename:  the URI for matching
2202  *
2203  * open an FTP I/O channel
2204  *
2205  * Returns an I/O context or NULL in case of error
2206  */
2207 void *
2208 xmlIOFTPOpen (const char *filename) {
2209     return(xmlNanoFTPOpen(filename));
2210 }
2211
2212 /**
2213  * xmlIOFTPRead:
2214  * @context:  the I/O context
2215  * @buffer:  where to drop data
2216  * @len:  number of bytes to write
2217  *
2218  * Read @len bytes to @buffer from the I/O channel.
2219  *
2220  * Returns the number of bytes written
2221  */
2222 int
2223 xmlIOFTPRead(void * context, char * buffer, int len) {
2224     if ((buffer == NULL) || (len < 0)) return(-1);
2225     return(xmlNanoFTPRead(context, &buffer[0], len));
2226 }
2227
2228 /**
2229  * xmlIOFTPClose:
2230  * @context:  the I/O context
2231  *
2232  * Close an FTP I/O channel
2233  *
2234  * Returns 0
2235  */
2236 int
2237 xmlIOFTPClose (void * context) {
2238     return ( xmlNanoFTPClose(context) );
2239 }
2240 #endif /* LIBXML_FTP_ENABLED */
2241
2242
2243 /**
2244  * xmlRegisterInputCallbacks:
2245  * @matchFunc:  the xmlInputMatchCallback
2246  * @openFunc:  the xmlInputOpenCallback
2247  * @readFunc:  the xmlInputReadCallback
2248  * @closeFunc:  the xmlInputCloseCallback
2249  *
2250  * Register a new set of I/O callback for handling parser input.
2251  *
2252  * Returns the registered handler number or -1 in case of error
2253  */
2254 int
2255 xmlRegisterInputCallbacks(xmlInputMatchCallback matchFunc,
2256         xmlInputOpenCallback openFunc, xmlInputReadCallback readFunc,
2257         xmlInputCloseCallback closeFunc) {
2258     if (xmlInputCallbackNr >= MAX_INPUT_CALLBACK) {
2259         return(-1);
2260     }
2261     xmlInputCallbackTable[xmlInputCallbackNr].matchcallback = matchFunc;
2262     xmlInputCallbackTable[xmlInputCallbackNr].opencallback = openFunc;
2263     xmlInputCallbackTable[xmlInputCallbackNr].readcallback = readFunc;
2264     xmlInputCallbackTable[xmlInputCallbackNr].closecallback = closeFunc;
2265     xmlInputCallbackInitialized = 1;
2266     return(xmlInputCallbackNr++);
2267 }
2268
2269 #ifdef LIBXML_OUTPUT_ENABLED
2270 /**
2271  * xmlRegisterOutputCallbacks:
2272  * @matchFunc:  the xmlOutputMatchCallback
2273  * @openFunc:  the xmlOutputOpenCallback
2274  * @writeFunc:  the xmlOutputWriteCallback
2275  * @closeFunc:  the xmlOutputCloseCallback
2276  *
2277  * Register a new set of I/O callback for handling output.
2278  *
2279  * Returns the registered handler number or -1 in case of error
2280  */
2281 int
2282 xmlRegisterOutputCallbacks(xmlOutputMatchCallback matchFunc,
2283         xmlOutputOpenCallback openFunc, xmlOutputWriteCallback writeFunc,
2284         xmlOutputCloseCallback closeFunc) {
2285     if (xmlOutputCallbackNr >= MAX_OUTPUT_CALLBACK) {
2286         return(-1);
2287     }
2288     xmlOutputCallbackTable[xmlOutputCallbackNr].matchcallback = matchFunc;
2289     xmlOutputCallbackTable[xmlOutputCallbackNr].opencallback = openFunc;
2290     xmlOutputCallbackTable[xmlOutputCallbackNr].writecallback = writeFunc;
2291     xmlOutputCallbackTable[xmlOutputCallbackNr].closecallback = closeFunc;
2292     xmlOutputCallbackInitialized = 1;
2293     return(xmlOutputCallbackNr++);
2294 }
2295 #endif /* LIBXML_OUTPUT_ENABLED */
2296
2297 /**
2298  * xmlRegisterDefaultInputCallbacks:
2299  *
2300  * Registers the default compiled-in I/O handlers.
2301  */
2302 void
2303 xmlRegisterDefaultInputCallbacks(void) {
2304     if (xmlInputCallbackInitialized)
2305         return;
2306
2307 #if defined(_WIN32) || defined (__DJGPP__) && !defined (__CYGWIN__)
2308     xmlInitPlatformSpecificIo();
2309 #endif
2310
2311     xmlRegisterInputCallbacks(xmlFileMatch, xmlFileOpen,
2312                               xmlFileRead, xmlFileClose);
2313 #ifdef HAVE_ZLIB_H
2314     xmlRegisterInputCallbacks(xmlGzfileMatch, xmlGzfileOpen,
2315                               xmlGzfileRead, xmlGzfileClose);
2316 #endif /* HAVE_ZLIB_H */
2317 #ifdef HAVE_LZMA_H
2318     xmlRegisterInputCallbacks(xmlXzfileMatch, xmlXzfileOpen,
2319                               xmlXzfileRead, xmlXzfileClose);
2320 #endif /* HAVE_ZLIB_H */
2321
2322 #ifdef LIBXML_HTTP_ENABLED
2323     xmlRegisterInputCallbacks(xmlIOHTTPMatch, xmlIOHTTPOpen,
2324                               xmlIOHTTPRead, xmlIOHTTPClose);
2325 #endif /* LIBXML_HTTP_ENABLED */
2326
2327 #ifdef LIBXML_FTP_ENABLED
2328     xmlRegisterInputCallbacks(xmlIOFTPMatch, xmlIOFTPOpen,
2329                               xmlIOFTPRead, xmlIOFTPClose);
2330 #endif /* LIBXML_FTP_ENABLED */
2331     xmlInputCallbackInitialized = 1;
2332 }
2333
2334 #ifdef LIBXML_OUTPUT_ENABLED
2335 /**
2336  * xmlRegisterDefaultOutputCallbacks:
2337  *
2338  * Registers the default compiled-in I/O handlers.
2339  */
2340 void
2341 xmlRegisterDefaultOutputCallbacks (void) {
2342     if (xmlOutputCallbackInitialized)
2343         return;
2344
2345 #if defined(_WIN32) || defined (__DJGPP__) && !defined (__CYGWIN__)
2346     xmlInitPlatformSpecificIo();
2347 #endif
2348
2349     xmlRegisterOutputCallbacks(xmlFileMatch, xmlFileOpenW,
2350                               xmlFileWrite, xmlFileClose);
2351
2352 #ifdef LIBXML_HTTP_ENABLED
2353     xmlRegisterOutputCallbacks(xmlIOHTTPMatch, xmlIOHTTPDfltOpenW,
2354                                xmlIOHTTPWrite, xmlIOHTTPClosePut);
2355 #endif
2356
2357 /*********************************
2358  No way a-priori to distinguish between gzipped files from
2359  uncompressed ones except opening if existing then closing
2360  and saving with same compression ratio ... a pain.
2361
2362 #ifdef HAVE_ZLIB_H
2363     xmlRegisterOutputCallbacks(xmlGzfileMatch, xmlGzfileOpen,
2364                                xmlGzfileWrite, xmlGzfileClose);
2365 #endif
2366
2367  Nor FTP PUT ....
2368 #ifdef LIBXML_FTP_ENABLED
2369     xmlRegisterOutputCallbacks(xmlIOFTPMatch, xmlIOFTPOpen,
2370                                xmlIOFTPWrite, xmlIOFTPClose);
2371 #endif
2372  **********************************/
2373     xmlOutputCallbackInitialized = 1;
2374 }
2375
2376 #ifdef LIBXML_HTTP_ENABLED
2377 /**
2378  * xmlRegisterHTTPPostCallbacks:
2379  *
2380  * By default, libxml submits HTTP output requests using the "PUT" method.
2381  * Calling this method changes the HTTP output method to use the "POST"
2382  * method instead.
2383  *
2384  */
2385 void
2386 xmlRegisterHTTPPostCallbacks( void ) {
2387
2388     /*  Register defaults if not done previously  */
2389
2390     if ( xmlOutputCallbackInitialized == 0 )
2391         xmlRegisterDefaultOutputCallbacks( );
2392
2393     xmlRegisterOutputCallbacks(xmlIOHTTPMatch, xmlIOHTTPDfltOpenW,
2394                                xmlIOHTTPWrite, xmlIOHTTPClosePost);
2395     return;
2396 }
2397 #endif
2398 #endif /* LIBXML_OUTPUT_ENABLED */
2399
2400 /**
2401  * xmlAllocParserInputBuffer:
2402  * @enc:  the charset encoding if known
2403  *
2404  * Create a buffered parser input for progressive parsing
2405  *
2406  * Returns the new parser input or NULL
2407  */
2408 xmlParserInputBufferPtr
2409 xmlAllocParserInputBuffer(xmlCharEncoding enc) {
2410     xmlParserInputBufferPtr ret;
2411
2412     ret = (xmlParserInputBufferPtr) xmlMalloc(sizeof(xmlParserInputBuffer));
2413     if (ret == NULL) {
2414         xmlIOErrMemory("creating input buffer");
2415         return(NULL);
2416     }
2417     memset(ret, 0, (size_t) sizeof(xmlParserInputBuffer));
2418     ret->buffer = xmlBufCreateSize(2 * xmlDefaultBufferSize);
2419     if (ret->buffer == NULL) {
2420         xmlFree(ret);
2421         return(NULL);
2422     }
2423     xmlBufSetAllocationScheme(ret->buffer, XML_BUFFER_ALLOC_DOUBLEIT);
2424     ret->encoder = xmlGetCharEncodingHandler(enc);
2425     if (ret->encoder != NULL)
2426         ret->raw = xmlBufCreateSize(2 * xmlDefaultBufferSize);
2427     else
2428         ret->raw = NULL;
2429     ret->readcallback = NULL;
2430     ret->closecallback = NULL;
2431     ret->context = NULL;
2432     ret->compressed = -1;
2433     ret->rawconsumed = 0;
2434
2435     return(ret);
2436 }
2437
2438 #ifdef LIBXML_OUTPUT_ENABLED
2439 /**
2440  * xmlAllocOutputBuffer:
2441  * @encoder:  the encoding converter or NULL
2442  *
2443  * Create a buffered parser output
2444  *
2445  * Returns the new parser output or NULL
2446  */
2447 xmlOutputBufferPtr
2448 xmlAllocOutputBuffer(xmlCharEncodingHandlerPtr encoder) {
2449     xmlOutputBufferPtr ret;
2450
2451     ret = (xmlOutputBufferPtr) xmlMalloc(sizeof(xmlOutputBuffer));
2452     if (ret == NULL) {
2453         xmlIOErrMemory("creating output buffer");
2454         return(NULL);
2455     }
2456     memset(ret, 0, (size_t) sizeof(xmlOutputBuffer));
2457     ret->buffer = xmlBufCreate();
2458     if (ret->buffer == NULL) {
2459         xmlFree(ret);
2460         return(NULL);
2461     }
2462
2463     /* try to avoid a performance problem with Windows realloc() */
2464     if (xmlBufGetAllocationScheme(ret->buffer) == XML_BUFFER_ALLOC_EXACT)
2465         xmlBufSetAllocationScheme(ret->buffer, XML_BUFFER_ALLOC_DOUBLEIT);
2466
2467     ret->encoder = encoder;
2468     if (encoder != NULL) {
2469         ret->conv = xmlBufCreateSize(4000);
2470         if (ret->conv == NULL) {
2471             xmlFree(ret);
2472             return(NULL);
2473         }
2474
2475         /*
2476          * This call is designed to initiate the encoder state
2477          */
2478         xmlCharEncOutput(ret, 1);
2479     } else
2480         ret->conv = NULL;
2481     ret->writecallback = NULL;
2482     ret->closecallback = NULL;
2483     ret->context = NULL;
2484     ret->written = 0;
2485
2486     return(ret);
2487 }
2488
2489 /**
2490  * xmlAllocOutputBufferInternal:
2491  * @encoder:  the encoding converter or NULL
2492  *
2493  * Create a buffered parser output
2494  *
2495  * Returns the new parser output or NULL
2496  */
2497 xmlOutputBufferPtr
2498 xmlAllocOutputBufferInternal(xmlCharEncodingHandlerPtr encoder) {
2499     xmlOutputBufferPtr ret;
2500
2501     ret = (xmlOutputBufferPtr) xmlMalloc(sizeof(xmlOutputBuffer));
2502     if (ret == NULL) {
2503         xmlIOErrMemory("creating output buffer");
2504         return(NULL);
2505     }
2506     memset(ret, 0, (size_t) sizeof(xmlOutputBuffer));
2507     ret->buffer = xmlBufCreate();
2508     if (ret->buffer == NULL) {
2509         xmlFree(ret);
2510         return(NULL);
2511     }
2512
2513
2514     /*
2515      * For conversion buffers we use the special IO handling
2516      */
2517     xmlBufSetAllocationScheme(ret->buffer, XML_BUFFER_ALLOC_IO);
2518
2519     ret->encoder = encoder;
2520     if (encoder != NULL) {
2521         ret->conv = xmlBufCreateSize(4000);
2522         if (ret->conv == NULL) {
2523             xmlFree(ret);
2524             return(NULL);
2525         }
2526
2527         /*
2528          * This call is designed to initiate the encoder state
2529          */
2530         xmlCharEncOutput(ret, 1);
2531     } else
2532         ret->conv = NULL;
2533     ret->writecallback = NULL;
2534     ret->closecallback = NULL;
2535     ret->context = NULL;
2536     ret->written = 0;
2537
2538     return(ret);
2539 }
2540
2541 #endif /* LIBXML_OUTPUT_ENABLED */
2542
2543 /**
2544  * xmlFreeParserInputBuffer:
2545  * @in:  a buffered parser input
2546  *
2547  * Free up the memory used by a buffered parser input
2548  */
2549 void
2550 xmlFreeParserInputBuffer(xmlParserInputBufferPtr in) {
2551     if (in == NULL) return;
2552
2553     if (in->raw) {
2554         xmlBufFree(in->raw);
2555         in->raw = NULL;
2556     }
2557     if (in->encoder != NULL) {
2558         xmlCharEncCloseFunc(in->encoder);
2559     }
2560     if (in->closecallback != NULL) {
2561         in->closecallback(in->context);
2562     }
2563     if (in->buffer != NULL) {
2564         xmlBufFree(in->buffer);
2565         in->buffer = NULL;
2566     }
2567
2568     xmlFree(in);
2569 }
2570
2571 #ifdef LIBXML_OUTPUT_ENABLED
2572 /**
2573  * xmlOutputBufferClose:
2574  * @out:  a buffered output
2575  *
2576  * flushes and close the output I/O channel
2577  * and free up all the associated resources
2578  *
2579  * Returns the number of byte written or -1 in case of error.
2580  */
2581 int
2582 xmlOutputBufferClose(xmlOutputBufferPtr out)
2583 {
2584     int written;
2585     int err_rc = 0;
2586
2587     if (out == NULL)
2588         return (-1);
2589     if (out->writecallback != NULL)
2590         xmlOutputBufferFlush(out);
2591     if (out->closecallback != NULL) {
2592         err_rc = out->closecallback(out->context);
2593     }
2594     written = out->written;
2595     if (out->conv) {
2596         xmlBufFree(out->conv);
2597         out->conv = NULL;
2598     }
2599     if (out->encoder != NULL) {
2600         xmlCharEncCloseFunc(out->encoder);
2601     }
2602     if (out->buffer != NULL) {
2603         xmlBufFree(out->buffer);
2604         out->buffer = NULL;
2605     }
2606
2607     if (out->error)
2608         err_rc = -1;
2609     xmlFree(out);
2610     return ((err_rc == 0) ? written : err_rc);
2611 }
2612 #endif /* LIBXML_OUTPUT_ENABLED */
2613
2614 xmlParserInputBufferPtr
2615 __xmlParserInputBufferCreateFilename(const char *URI, xmlCharEncoding enc) {
2616     xmlParserInputBufferPtr ret;
2617     int i = 0;
2618     void *context = NULL;
2619
2620     if (xmlInputCallbackInitialized == 0)
2621         xmlRegisterDefaultInputCallbacks();
2622
2623     if (URI == NULL) return(NULL);
2624
2625     /*
2626      * Try to find one of the input accept method accepting that scheme
2627      * Go in reverse to give precedence to user defined handlers.
2628      */
2629     if (context == NULL) {
2630         for (i = xmlInputCallbackNr - 1;i >= 0;i--) {
2631             if ((xmlInputCallbackTable[i].matchcallback != NULL) &&
2632                 (xmlInputCallbackTable[i].matchcallback(URI) != 0)) {
2633                 context = xmlInputCallbackTable[i].opencallback(URI);
2634                 if (context != NULL) {
2635                     break;
2636                 }
2637             }
2638         }
2639     }
2640     if (context == NULL) {
2641         return(NULL);
2642     }
2643
2644     /*
2645      * Allocate the Input buffer front-end.
2646      */
2647     ret = xmlAllocParserInputBuffer(enc);
2648     if (ret != NULL) {
2649         ret->context = context;
2650         ret->readcallback = xmlInputCallbackTable[i].readcallback;
2651         ret->closecallback = xmlInputCallbackTable[i].closecallback;
2652 #ifdef HAVE_ZLIB_H
2653         if ((xmlInputCallbackTable[i].opencallback == xmlGzfileOpen) &&
2654                 (strcmp(URI, "-") != 0)) {
2655 #if defined(ZLIB_VERNUM) && ZLIB_VERNUM >= 0x1230
2656             ret->compressed = !gzdirect(context);
2657 #else
2658             if (((z_stream *)context)->avail_in > 4) {
2659                 char *cptr, buff4[4];
2660                 cptr = (char *) ((z_stream *)context)->next_in;
2661                 if (gzread(context, buff4, 4) == 4) {
2662                     if (strncmp(buff4, cptr, 4) == 0)
2663                         ret->compressed = 0;
2664                     else
2665                         ret->compressed = 1;
2666                     gzrewind(context);
2667                 }
2668             }
2669 #endif
2670         }
2671 #endif
2672     }
2673     else
2674       xmlInputCallbackTable[i].closecallback (context);
2675
2676     return(ret);
2677 }
2678
2679 /**
2680  * xmlParserInputBufferCreateFilename:
2681  * @URI:  a C string containing the URI or filename
2682  * @enc:  the charset encoding if known
2683  *
2684  * Create a buffered parser input for the progressive parsing of a file
2685  * If filename is "-' then we use stdin as the input.
2686  * Automatic support for ZLIB/Compress compressed document is provided
2687  * by default if found at compile-time.
2688  * Do an encoding check if enc == XML_CHAR_ENCODING_NONE
2689  *
2690  * Returns the new parser input or NULL
2691  */
2692 xmlParserInputBufferPtr
2693 xmlParserInputBufferCreateFilename(const char *URI, xmlCharEncoding enc) {
2694     if ((xmlParserInputBufferCreateFilenameValue)) {
2695                 return xmlParserInputBufferCreateFilenameValue(URI, enc);
2696         }
2697         return __xmlParserInputBufferCreateFilename(URI, enc);
2698 }
2699
2700 #ifdef LIBXML_OUTPUT_ENABLED
2701 xmlOutputBufferPtr
2702 __xmlOutputBufferCreateFilename(const char *URI,
2703                               xmlCharEncodingHandlerPtr encoder,
2704                               int compression ATTRIBUTE_UNUSED) {
2705     xmlOutputBufferPtr ret;
2706     xmlURIPtr puri;
2707     int i = 0;
2708     void *context = NULL;
2709     char *unescaped = NULL;
2710 #ifdef HAVE_ZLIB_H
2711     int is_file_uri = 1;
2712 #endif
2713
2714     if (xmlOutputCallbackInitialized == 0)
2715         xmlRegisterDefaultOutputCallbacks();
2716
2717     if (URI == NULL) return(NULL);
2718
2719     puri = xmlParseURI(URI);
2720     if (puri != NULL) {
2721 #ifdef HAVE_ZLIB_H
2722         if ((puri->scheme != NULL) &&
2723             (!xmlStrEqual(BAD_CAST puri->scheme, BAD_CAST "file")))
2724             is_file_uri = 0;
2725 #endif
2726         /*
2727          * try to limit the damages of the URI unescaping code.
2728          */
2729         if ((puri->scheme == NULL) ||
2730             (xmlStrEqual(BAD_CAST puri->scheme, BAD_CAST "file")))
2731             unescaped = xmlURIUnescapeString(URI, 0, NULL);
2732         xmlFreeURI(puri);
2733     }
2734
2735     /*
2736      * Try to find one of the output accept method accepting that scheme
2737      * Go in reverse to give precedence to user defined handlers.
2738      * try with an unescaped version of the URI
2739      */
2740     if (unescaped != NULL) {
2741 #ifdef HAVE_ZLIB_H
2742         if ((compression > 0) && (compression <= 9) && (is_file_uri == 1)) {
2743             context = xmlGzfileOpenW(unescaped, compression);
2744             if (context != NULL) {
2745                 ret = xmlAllocOutputBufferInternal(encoder);
2746                 if (ret != NULL) {
2747                     ret->context = context;
2748                     ret->writecallback = xmlGzfileWrite;
2749                     ret->closecallback = xmlGzfileClose;
2750                 }
2751                 xmlFree(unescaped);
2752                 return(ret);
2753             }
2754         }
2755 #endif
2756         for (i = xmlOutputCallbackNr - 1;i >= 0;i--) {
2757             if ((xmlOutputCallbackTable[i].matchcallback != NULL) &&
2758                 (xmlOutputCallbackTable[i].matchcallback(unescaped) != 0)) {
2759 #if defined(LIBXML_HTTP_ENABLED) && defined(HAVE_ZLIB_H)
2760                 /*  Need to pass compression parameter into HTTP open calls  */
2761                 if (xmlOutputCallbackTable[i].matchcallback == xmlIOHTTPMatch)
2762                     context = xmlIOHTTPOpenW(unescaped, compression);
2763                 else
2764 #endif
2765                     context = xmlOutputCallbackTable[i].opencallback(unescaped);
2766                 if (context != NULL)
2767                     break;
2768             }
2769         }
2770         xmlFree(unescaped);
2771     }
2772
2773     /*
2774      * If this failed try with a non-escaped URI this may be a strange
2775      * filename
2776      */
2777     if (context == NULL) {
2778 #ifdef HAVE_ZLIB_H
2779         if ((compression > 0) && (compression <= 9) && (is_file_uri == 1)) {
2780             context = xmlGzfileOpenW(URI, compression);
2781             if (context != NULL) {
2782                 ret = xmlAllocOutputBufferInternal(encoder);
2783                 if (ret != NULL) {
2784                     ret->context = context;
2785                     ret->writecallback = xmlGzfileWrite;
2786                     ret->closecallback = xmlGzfileClose;
2787                 }
2788                 return(ret);
2789             }
2790         }
2791 #endif
2792         for (i = xmlOutputCallbackNr - 1;i >= 0;i--) {
2793             if ((xmlOutputCallbackTable[i].matchcallback != NULL) &&
2794                 (xmlOutputCallbackTable[i].matchcallback(URI) != 0)) {
2795 #if defined(LIBXML_HTTP_ENABLED) && defined(HAVE_ZLIB_H)
2796                 /*  Need to pass compression parameter into HTTP open calls  */
2797                 if (xmlOutputCallbackTable[i].matchcallback == xmlIOHTTPMatch)
2798                     context = xmlIOHTTPOpenW(URI, compression);
2799                 else
2800 #endif
2801                     context = xmlOutputCallbackTable[i].opencallback(URI);
2802                 if (context != NULL)
2803                     break;
2804             }
2805         }
2806     }
2807
2808     if (context == NULL) {
2809         return(NULL);
2810     }
2811
2812     /*
2813      * Allocate the Output buffer front-end.
2814      */
2815     ret = xmlAllocOutputBufferInternal(encoder);
2816     if (ret != NULL) {
2817         ret->context = context;
2818         ret->writecallback = xmlOutputCallbackTable[i].writecallback;
2819         ret->closecallback = xmlOutputCallbackTable[i].closecallback;
2820     }
2821     return(ret);
2822 }
2823
2824 /**
2825  * xmlOutputBufferCreateFilename:
2826  * @URI:  a C string containing the URI or filename
2827  * @encoder:  the encoding converter or NULL
2828  * @compression:  the compression ration (0 none, 9 max).
2829  *
2830  * Create a buffered  output for the progressive saving of a file
2831  * If filename is "-' then we use stdout as the output.
2832  * Automatic support for ZLIB/Compress compressed document is provided
2833  * by default if found at compile-time.
2834  * TODO: currently if compression is set, the library only support
2835  *       writing to a local file.
2836  *
2837  * Returns the new output or NULL
2838  */
2839 xmlOutputBufferPtr
2840 xmlOutputBufferCreateFilename(const char *URI,
2841                               xmlCharEncodingHandlerPtr encoder,
2842                               int compression ATTRIBUTE_UNUSED) {
2843     if ((xmlOutputBufferCreateFilenameValue)) {
2844                 return xmlOutputBufferCreateFilenameValue(URI, encoder, compression);
2845         }
2846         return __xmlOutputBufferCreateFilename(URI, encoder, compression);
2847 }
2848 #endif /* LIBXML_OUTPUT_ENABLED */
2849
2850 /**
2851  * xmlParserInputBufferCreateFile:
2852  * @file:  a FILE*
2853  * @enc:  the charset encoding if known
2854  *
2855  * Create a buffered parser input for the progressive parsing of a FILE *
2856  * buffered C I/O
2857  *
2858  * Returns the new parser input or NULL
2859  */
2860 xmlParserInputBufferPtr
2861 xmlParserInputBufferCreateFile(FILE *file, xmlCharEncoding enc) {
2862     xmlParserInputBufferPtr ret;
2863
2864     if (xmlInputCallbackInitialized == 0)
2865         xmlRegisterDefaultInputCallbacks();
2866
2867     if (file == NULL) return(NULL);
2868
2869     ret = xmlAllocParserInputBuffer(enc);
2870     if (ret != NULL) {
2871         ret->context = file;
2872         ret->readcallback = xmlFileRead;
2873         ret->closecallback = xmlFileFlush;
2874     }
2875
2876     return(ret);
2877 }
2878
2879 #ifdef LIBXML_OUTPUT_ENABLED
2880 /**
2881  * xmlOutputBufferCreateFile:
2882  * @file:  a FILE*
2883  * @encoder:  the encoding converter or NULL
2884  *
2885  * Create a buffered output for the progressive saving to a FILE *
2886  * buffered C I/O
2887  *
2888  * Returns the new parser output or NULL
2889  */
2890 xmlOutputBufferPtr
2891 xmlOutputBufferCreateFile(FILE *file, xmlCharEncodingHandlerPtr encoder) {
2892     xmlOutputBufferPtr ret;
2893
2894     if (xmlOutputCallbackInitialized == 0)
2895         xmlRegisterDefaultOutputCallbacks();
2896
2897     if (file == NULL) return(NULL);
2898
2899     ret = xmlAllocOutputBufferInternal(encoder);
2900     if (ret != NULL) {
2901         ret->context = file;
2902         ret->writecallback = xmlFileWrite;
2903         ret->closecallback = xmlFileFlush;
2904     }
2905
2906     return(ret);
2907 }
2908
2909 /**
2910  * xmlOutputBufferCreateBuffer:
2911  * @buffer:  a xmlBufferPtr
2912  * @encoder:  the encoding converter or NULL
2913  *
2914  * Create a buffered output for the progressive saving to a xmlBuffer
2915  *
2916  * Returns the new parser output or NULL
2917  */
2918 xmlOutputBufferPtr
2919 xmlOutputBufferCreateBuffer(xmlBufferPtr buffer,
2920                             xmlCharEncodingHandlerPtr encoder) {
2921     xmlOutputBufferPtr ret;
2922
2923     if (buffer == NULL) return(NULL);
2924
2925     ret = xmlOutputBufferCreateIO((xmlOutputWriteCallback)
2926                                   xmlBufferWrite,
2927                                   (xmlOutputCloseCallback)
2928                                   NULL, (void *) buffer, encoder);
2929
2930     return(ret);
2931 }
2932
2933 /**
2934  * xmlOutputBufferGetContent:
2935  * @out:  an xmlOutputBufferPtr
2936  *
2937  * Gives a pointer to the data currently held in the output buffer
2938  *
2939  * Returns a pointer to the data or NULL in case of error
2940  */
2941 const xmlChar *
2942 xmlOutputBufferGetContent(xmlOutputBufferPtr out) {
2943     if ((out == NULL) || (out->buffer == NULL))
2944         return(NULL);
2945
2946     return(xmlBufContent(out->buffer));
2947 }
2948
2949 /**
2950  * xmlOutputBufferGetSize:
2951  * @out:  an xmlOutputBufferPtr
2952  *
2953  * Gives the length of the data currently held in the output buffer
2954  *
2955  * Returns 0 in case or error or no data is held, the size otherwise
2956  */
2957 size_t
2958 xmlOutputBufferGetSize(xmlOutputBufferPtr out) {
2959     if ((out == NULL) || (out->buffer == NULL))
2960         return(0);
2961
2962     return(xmlBufUse(out->buffer));
2963 }
2964
2965
2966 #endif /* LIBXML_OUTPUT_ENABLED */
2967
2968 /**
2969  * xmlParserInputBufferCreateFd:
2970  * @fd:  a file descriptor number
2971  * @enc:  the charset encoding if known
2972  *
2973  * Create a buffered parser input for the progressive parsing for the input
2974  * from a file descriptor
2975  *
2976  * Returns the new parser input or NULL
2977  */
2978 xmlParserInputBufferPtr
2979 xmlParserInputBufferCreateFd(int fd, xmlCharEncoding enc) {
2980     xmlParserInputBufferPtr ret;
2981
2982     if (fd < 0) return(NULL);
2983
2984     ret = xmlAllocParserInputBuffer(enc);
2985     if (ret != NULL) {
2986         ret->context = (void *) (long) fd;
2987         ret->readcallback = xmlFdRead;
2988         ret->closecallback = xmlFdClose;
2989     }
2990
2991     return(ret);
2992 }
2993
2994 /**
2995  * xmlParserInputBufferCreateMem:
2996  * @mem:  the memory input
2997  * @size:  the length of the memory block
2998  * @enc:  the charset encoding if known
2999  *
3000  * Create a buffered parser input for the progressive parsing for the input
3001  * from a memory area.
3002  *
3003  * Returns the new parser input or NULL
3004  */
3005 xmlParserInputBufferPtr
3006 xmlParserInputBufferCreateMem(const char *mem, int size, xmlCharEncoding enc) {
3007     xmlParserInputBufferPtr ret;
3008     int errcode;
3009
3010     if (size <= 0) return(NULL);
3011     if (mem == NULL) return(NULL);
3012
3013     ret = xmlAllocParserInputBuffer(enc);
3014     if (ret != NULL) {
3015         ret->context = (void *) mem;
3016         ret->readcallback = (xmlInputReadCallback) xmlNop;
3017         ret->closecallback = NULL;
3018         errcode = xmlBufAdd(ret->buffer, (const xmlChar *) mem, size);
3019         if (errcode != 0) {
3020             xmlFree(ret);
3021             return(NULL);
3022         }
3023     }
3024
3025     return(ret);
3026 }
3027
3028 /**
3029  * xmlParserInputBufferCreateStatic:
3030  * @mem:  the memory input
3031  * @size:  the length of the memory block
3032  * @enc:  the charset encoding if known
3033  *
3034  * Create a buffered parser input for the progressive parsing for the input
3035  * from an immutable memory area. This will not copy the memory area to
3036  * the buffer, but the memory is expected to be available until the end of
3037  * the parsing, this is useful for example when using mmap'ed file.
3038  *
3039  * Returns the new parser input or NULL
3040  */
3041 xmlParserInputBufferPtr
3042 xmlParserInputBufferCreateStatic(const char *mem, int size,
3043                                  xmlCharEncoding enc) {
3044     xmlParserInputBufferPtr ret;
3045
3046     if (size <= 0) return(NULL);
3047     if (mem == NULL) return(NULL);
3048
3049     ret = (xmlParserInputBufferPtr) xmlMalloc(sizeof(xmlParserInputBuffer));
3050     if (ret == NULL) {
3051         xmlIOErrMemory("creating input buffer");
3052         return(NULL);
3053     }
3054     memset(ret, 0, (size_t) sizeof(xmlParserInputBuffer));
3055     ret->buffer = xmlBufCreateStatic((void *)mem, (size_t) size);
3056     if (ret->buffer == NULL) {
3057         xmlFree(ret);
3058         return(NULL);
3059     }
3060     ret->encoder = xmlGetCharEncodingHandler(enc);
3061     if (ret->encoder != NULL)
3062         ret->raw = xmlBufCreateSize(2 * xmlDefaultBufferSize);
3063     else
3064         ret->raw = NULL;
3065     ret->compressed = -1;
3066     ret->context = (void *) mem;
3067     ret->readcallback = NULL;
3068     ret->closecallback = NULL;
3069
3070     return(ret);
3071 }
3072
3073 #ifdef LIBXML_OUTPUT_ENABLED
3074 /**
3075  * xmlOutputBufferCreateFd:
3076  * @fd:  a file descriptor number
3077  * @encoder:  the encoding converter or NULL
3078  *
3079  * Create a buffered output for the progressive saving
3080  * to a file descriptor
3081  *
3082  * Returns the new parser output or NULL
3083  */
3084 xmlOutputBufferPtr
3085 xmlOutputBufferCreateFd(int fd, xmlCharEncodingHandlerPtr encoder) {
3086     xmlOutputBufferPtr ret;
3087
3088     if (fd < 0) return(NULL);
3089
3090     ret = xmlAllocOutputBufferInternal(encoder);
3091     if (ret != NULL) {
3092         ret->context = (void *) (long) fd;
3093         ret->writecallback = xmlFdWrite;
3094         ret->closecallback = NULL;
3095     }
3096
3097     return(ret);
3098 }
3099 #endif /* LIBXML_OUTPUT_ENABLED */
3100
3101 /**
3102  * xmlParserInputBufferCreateIO:
3103  * @ioread:  an I/O read function
3104  * @ioclose:  an I/O close function
3105  * @ioctx:  an I/O handler
3106  * @enc:  the charset encoding if known
3107  *
3108  * Create a buffered parser input for the progressive parsing for the input
3109  * from an I/O handler
3110  *
3111  * Returns the new parser input or NULL
3112  */
3113 xmlParserInputBufferPtr
3114 xmlParserInputBufferCreateIO(xmlInputReadCallback   ioread,
3115          xmlInputCloseCallback  ioclose, void *ioctx, xmlCharEncoding enc) {
3116     xmlParserInputBufferPtr ret;
3117
3118     if (ioread == NULL) return(NULL);
3119
3120     ret = xmlAllocParserInputBuffer(enc);
3121     if (ret != NULL) {
3122         ret->context = (void *) ioctx;
3123         ret->readcallback = ioread;
3124         ret->closecallback = ioclose;
3125     }
3126
3127     return(ret);
3128 }
3129
3130 #ifdef LIBXML_OUTPUT_ENABLED
3131 /**
3132  * xmlOutputBufferCreateIO:
3133  * @iowrite:  an I/O write function
3134  * @ioclose:  an I/O close function
3135  * @ioctx:  an I/O handler
3136  * @encoder:  the charset encoding if known
3137  *
3138  * Create a buffered output for the progressive saving
3139  * to an I/O handler
3140  *
3141  * Returns the new parser output or NULL
3142  */
3143 xmlOutputBufferPtr
3144 xmlOutputBufferCreateIO(xmlOutputWriteCallback   iowrite,
3145          xmlOutputCloseCallback  ioclose, void *ioctx,
3146          xmlCharEncodingHandlerPtr encoder) {
3147     xmlOutputBufferPtr ret;
3148
3149     if (iowrite == NULL) return(NULL);
3150
3151     ret = xmlAllocOutputBufferInternal(encoder);
3152     if (ret != NULL) {
3153         ret->context = (void *) ioctx;
3154         ret->writecallback = iowrite;
3155         ret->closecallback = ioclose;
3156     }
3157
3158     return(ret);
3159 }
3160 #endif /* LIBXML_OUTPUT_ENABLED */
3161
3162 /**
3163  * xmlParserInputBufferCreateFilenameDefault:
3164  * @func: function pointer to the new ParserInputBufferCreateFilenameFunc
3165  *
3166  * Registers a callback for URI input file handling
3167  *
3168  * Returns the old value of the registration function
3169  */
3170 xmlParserInputBufferCreateFilenameFunc
3171 xmlParserInputBufferCreateFilenameDefault(xmlParserInputBufferCreateFilenameFunc func)
3172 {
3173     xmlParserInputBufferCreateFilenameFunc old = xmlParserInputBufferCreateFilenameValue;
3174     if (old == NULL) {
3175                 old = __xmlParserInputBufferCreateFilename;
3176         }
3177
3178     xmlParserInputBufferCreateFilenameValue = func;
3179     return(old);
3180 }
3181
3182 /**
3183  * xmlOutputBufferCreateFilenameDefault:
3184  * @func: function pointer to the new OutputBufferCreateFilenameFunc
3185  *
3186  * Registers a callback for URI output file handling
3187  *
3188  * Returns the old value of the registration function
3189  */
3190 xmlOutputBufferCreateFilenameFunc
3191 xmlOutputBufferCreateFilenameDefault(xmlOutputBufferCreateFilenameFunc func)
3192 {
3193     xmlOutputBufferCreateFilenameFunc old = xmlOutputBufferCreateFilenameValue;
3194 #ifdef LIBXML_OUTPUT_ENABLED
3195     if (old == NULL) {
3196                 old = __xmlOutputBufferCreateFilename;
3197         }
3198 #endif
3199     xmlOutputBufferCreateFilenameValue = func;
3200     return(old);
3201 }
3202
3203 /**
3204  * xmlParserInputBufferPush:
3205  * @in:  a buffered parser input
3206  * @len:  the size in bytes of the array.
3207  * @buf:  an char array
3208  *
3209  * Push the content of the arry in the input buffer
3210  * This routine handle the I18N transcoding to internal UTF-8
3211  * This is used when operating the parser in progressive (push) mode.
3212  *
3213  * Returns the number of chars read and stored in the buffer, or -1
3214  *         in case of error.
3215  */
3216 int
3217 xmlParserInputBufferPush(xmlParserInputBufferPtr in,
3218                          int len, const char *buf) {
3219     int nbchars = 0;
3220     int ret;
3221
3222     if (len < 0) return(0);
3223     if ((in == NULL) || (in->error)) return(-1);
3224     if (in->encoder != NULL) {
3225         unsigned int use;
3226
3227         /*
3228          * Store the data in the incoming raw buffer
3229          */
3230         if (in->raw == NULL) {
3231             in->raw = xmlBufCreate();
3232         }
3233         ret = xmlBufAdd(in->raw, (const xmlChar *) buf, len);
3234         if (ret != 0)
3235             return(-1);
3236
3237         /*
3238          * convert as much as possible to the parser reading buffer.
3239          */
3240         use = xmlBufUse(in->raw);
3241         nbchars = xmlCharEncInput(in, 1);
3242         if (nbchars < 0) {
3243             xmlIOErr(XML_IO_ENCODER, NULL);
3244             in->error = XML_IO_ENCODER;
3245             return(-1);
3246         }
3247         in->rawconsumed += (use - xmlBufUse(in->raw));
3248     } else {
3249         nbchars = len;
3250         ret = xmlBufAdd(in->buffer, (xmlChar *) buf, nbchars);
3251         if (ret != 0)
3252             return(-1);
3253     }
3254 #ifdef DEBUG_INPUT
3255     xmlGenericError(xmlGenericErrorContext,
3256             "I/O: pushed %d chars, buffer %d/%d\n",
3257             nbchars, xmlBufUse(in->buffer), xmlBufLength(in->buffer));
3258 #endif
3259     return(nbchars);
3260 }
3261
3262 /**
3263  * endOfInput:
3264  *
3265  * When reading from an Input channel indicated end of file or error
3266  * don't reread from it again.
3267  */
3268 static int
3269 endOfInput (void * context ATTRIBUTE_UNUSED,
3270             char * buffer ATTRIBUTE_UNUSED,
3271             int len ATTRIBUTE_UNUSED) {
3272     return(0);
3273 }
3274
3275 /**
3276  * xmlParserInputBufferGrow:
3277  * @in:  a buffered parser input
3278  * @len:  indicative value of the amount of chars to read
3279  *
3280  * Grow up the content of the input buffer, the old data are preserved
3281  * This routine handle the I18N transcoding to internal UTF-8
3282  * This routine is used when operating the parser in normal (pull) mode
3283  *
3284  * TODO: one should be able to remove one extra copy by copying directly
3285  *       onto in->buffer or in->raw
3286  *
3287  * Returns the number of chars read and stored in the buffer, or -1
3288  *         in case of error.
3289  */
3290 int
3291 xmlParserInputBufferGrow(xmlParserInputBufferPtr in, int len) {
3292     char *buffer = NULL;
3293     int res = 0;
3294     int nbchars = 0;
3295
3296     if ((in == NULL) || (in->error)) return(-1);
3297     if ((len <= MINLEN) && (len != 4))
3298         len = MINLEN;
3299
3300     if (xmlBufAvail(in->buffer) <= 0) {
3301         xmlIOErr(XML_IO_BUFFER_FULL, NULL);
3302         in->error = XML_IO_BUFFER_FULL;
3303         return(-1);
3304     }
3305
3306     if (xmlBufGrow(in->buffer, len + 1) < 0) {
3307         xmlIOErrMemory("growing input buffer");
3308         in->error = XML_ERR_NO_MEMORY;
3309         return(-1);
3310     }
3311     buffer = (char *)xmlBufEnd(in->buffer);
3312
3313     /*
3314      * Call the read method for this I/O type.
3315      */
3316     if (in->readcallback != NULL) {
3317         res = in->readcallback(in->context, &buffer[0], len);
3318         if (res <= 0)
3319             in->readcallback = endOfInput;
3320     } else {
3321         xmlIOErr(XML_IO_NO_INPUT, NULL);
3322         in->error = XML_IO_NO_INPUT;
3323         return(-1);
3324     }
3325     if (res < 0) {
3326         return(-1);
3327     }
3328     len = res;
3329     if (in->encoder != NULL) {
3330         unsigned int use;
3331
3332         /*
3333          * Store the data in the incoming raw buffer
3334          */
3335         if (in->raw == NULL) {
3336             in->raw = xmlBufCreate();
3337         }
3338         res = xmlBufAdd(in->raw, (const xmlChar *) buffer, len);
3339         if (res != 0)
3340             return(-1);
3341
3342         /*
3343          * convert as much as possible to the parser reading buffer.
3344          */
3345         use = xmlBufUse(in->raw);
3346         nbchars = xmlCharEncInput(in, 1);
3347         if (nbchars < 0) {
3348             xmlIOErr(XML_IO_ENCODER, NULL);
3349             in->error = XML_IO_ENCODER;
3350             return(-1);
3351         }
3352         in->rawconsumed += (use - xmlBufUse(in->raw));
3353     } else {
3354         nbchars = len;
3355         xmlBufAddLen(in->buffer, nbchars);
3356     }
3357 #ifdef DEBUG_INPUT
3358     xmlGenericError(xmlGenericErrorContext,
3359             "I/O: read %d chars, buffer %d\n",
3360             nbchars, xmlBufUse(in->buffer));
3361 #endif
3362     return(nbchars);
3363 }
3364
3365 /**
3366  * xmlParserInputBufferRead:
3367  * @in:  a buffered parser input
3368  * @len:  indicative value of the amount of chars to read
3369  *
3370  * Refresh the content of the input buffer, the old data are considered
3371  * consumed
3372  * This routine handle the I18N transcoding to internal UTF-8
3373  *
3374  * Returns the number of chars read and stored in the buffer, or -1
3375  *         in case of error.
3376  */
3377 int
3378 xmlParserInputBufferRead(xmlParserInputBufferPtr in, int len) {
3379     if ((in == NULL) || (in->error)) return(-1);
3380     if (in->readcallback != NULL)
3381         return(xmlParserInputBufferGrow(in, len));
3382     else if (xmlBufGetAllocationScheme(in->buffer) == XML_BUFFER_ALLOC_IMMUTABLE)
3383         return(0);
3384     else
3385         return(-1);
3386 }
3387
3388 #ifdef LIBXML_OUTPUT_ENABLED
3389 /**
3390  * xmlOutputBufferWrite:
3391  * @out:  a buffered parser output
3392  * @len:  the size in bytes of the array.
3393  * @buf:  an char array
3394  *
3395  * Write the content of the array in the output I/O buffer
3396  * This routine handle the I18N transcoding from internal UTF-8
3397  * The buffer is lossless, i.e. will store in case of partial
3398  * or delayed writes.
3399  *
3400  * Returns the number of chars immediately written, or -1
3401  *         in case of error.
3402  */
3403 int
3404 xmlOutputBufferWrite(xmlOutputBufferPtr out, int len, const char *buf) {
3405     int nbchars = 0; /* number of chars to output to I/O */
3406     int ret;         /* return from function call */
3407     int written = 0; /* number of char written to I/O so far */
3408     int chunk;       /* number of byte curreent processed from buf */
3409
3410     if ((out == NULL) || (out->error)) return(-1);
3411     if (len < 0) return(0);
3412     if (out->error) return(-1);
3413
3414     do {
3415         chunk = len;
3416         if (chunk > 4 * MINLEN)
3417             chunk = 4 * MINLEN;
3418
3419         /*
3420          * first handle encoding stuff.
3421          */
3422         if (out->encoder != NULL) {
3423             /*
3424              * Store the data in the incoming raw buffer
3425              */
3426             if (out->conv == NULL) {
3427                 out->conv = xmlBufCreate();
3428             }
3429             ret = xmlBufAdd(out->buffer, (const xmlChar *) buf, chunk);
3430             if (ret != 0)
3431                 return(-1);
3432
3433             if ((xmlBufUse(out->buffer) < MINLEN) && (chunk == len))
3434                 goto done;
3435
3436             /*
3437              * convert as much as possible to the parser reading buffer.
3438              */
3439             ret = xmlCharEncOutput(out, 0);
3440             if ((ret < 0) && (ret != -3)) {
3441                 xmlIOErr(XML_IO_ENCODER, NULL);
3442                 out->error = XML_IO_ENCODER;
3443                 return(-1);
3444             }
3445             nbchars = xmlBufUse(out->conv);
3446         } else {
3447             ret = xmlBufAdd(out->buffer, (const xmlChar *) buf, chunk);
3448             if (ret != 0)
3449                 return(-1);
3450             nbchars = xmlBufUse(out->buffer);
3451         }
3452         buf += chunk;
3453         len -= chunk;
3454
3455         if ((nbchars < MINLEN) && (len <= 0))
3456             goto done;
3457
3458         if (out->writecallback) {
3459             /*
3460              * second write the stuff to the I/O channel
3461              */
3462             if (out->encoder != NULL) {
3463                 ret = out->writecallback(out->context,
3464                            (const char *)xmlBufContent(out->conv), nbchars);
3465                 if (ret >= 0)
3466                     xmlBufShrink(out->conv, ret);
3467             } else {
3468                 ret = out->writecallback(out->context,
3469                            (const char *)xmlBufContent(out->buffer), nbchars);
3470                 if (ret >= 0)
3471                     xmlBufShrink(out->buffer, ret);
3472             }
3473             if (ret < 0) {
3474                 xmlIOErr(XML_IO_WRITE, NULL);
3475                 out->error = XML_IO_WRITE;
3476                 return(ret);
3477             }
3478             out->written += ret;
3479         }
3480         written += nbchars;
3481     } while (len > 0);
3482
3483 done:
3484 #ifdef DEBUG_INPUT
3485     xmlGenericError(xmlGenericErrorContext,
3486             "I/O: wrote %d chars\n", written);
3487 #endif
3488     return(written);
3489 }
3490
3491 /**
3492  * xmlEscapeContent:
3493  * @out:  a pointer to an array of bytes to store the result
3494  * @outlen:  the length of @out
3495  * @in:  a pointer to an array of unescaped UTF-8 bytes
3496  * @inlen:  the length of @in
3497  *
3498  * Take a block of UTF-8 chars in and escape them.
3499  * Returns 0 if success, or -1 otherwise
3500  * The value of @inlen after return is the number of octets consumed
3501  *     if the return value is positive, else unpredictable.
3502  * The value of @outlen after return is the number of octets consumed.
3503  */
3504 static int
3505 xmlEscapeContent(unsigned char* out, int *outlen,
3506                  const xmlChar* in, int *inlen) {
3507     unsigned char* outstart = out;
3508     const unsigned char* base = in;
3509     unsigned char* outend = out + *outlen;
3510     const unsigned char* inend;
3511
3512     inend = in + (*inlen);
3513
3514     while ((in < inend) && (out < outend)) {
3515         if (*in == '<') {
3516             if (outend - out < 4) break;
3517             *out++ = '&';
3518             *out++ = 'l';
3519             *out++ = 't';
3520             *out++ = ';';
3521         } else if (*in == '>') {
3522             if (outend - out < 4) break;
3523             *out++ = '&';
3524             *out++ = 'g';
3525             *out++ = 't';
3526             *out++ = ';';
3527         } else if (*in == '&') {
3528             if (outend - out < 5) break;
3529             *out++ = '&';
3530             *out++ = 'a';
3531             *out++ = 'm';
3532             *out++ = 'p';
3533             *out++ = ';';
3534         } else if (*in == '\r') {
3535             if (outend - out < 5) break;
3536             *out++ = '&';
3537             *out++ = '#';
3538             *out++ = '1';
3539             *out++ = '3';
3540             *out++ = ';';
3541         } else {
3542             *out++ = (unsigned char) *in;
3543         }
3544         ++in;
3545     }
3546     *outlen = out - outstart;
3547     *inlen = in - base;
3548     return(0);
3549 }
3550
3551 /**
3552  * xmlOutputBufferWriteEscape:
3553  * @out:  a buffered parser output
3554  * @str:  a zero terminated UTF-8 string
3555  * @escaping:  an optional escaping function (or NULL)
3556  *
3557  * Write the content of the string in the output I/O buffer
3558  * This routine escapes the caracters and then handle the I18N
3559  * transcoding from internal UTF-8
3560  * The buffer is lossless, i.e. will store in case of partial
3561  * or delayed writes.
3562  *
3563  * Returns the number of chars immediately written, or -1
3564  *         in case of error.
3565  */
3566 int
3567 xmlOutputBufferWriteEscape(xmlOutputBufferPtr out, const xmlChar *str,
3568                            xmlCharEncodingOutputFunc escaping) {
3569     int nbchars = 0; /* number of chars to output to I/O */
3570     int ret;         /* return from function call */
3571     int written = 0; /* number of char written to I/O so far */
3572     int oldwritten=0;/* loop guard */
3573     int chunk;       /* number of byte currently processed from str */
3574     int len;         /* number of bytes in str */
3575     int cons;        /* byte from str consumed */
3576
3577     if ((out == NULL) || (out->error) || (str == NULL) ||
3578         (out->buffer == NULL) ||
3579         (xmlBufGetAllocationScheme(out->buffer) == XML_BUFFER_ALLOC_IMMUTABLE))
3580         return(-1);
3581     len = strlen((const char *)str);
3582     if (len < 0) return(0);
3583     if (out->error) return(-1);
3584     if (escaping == NULL) escaping = xmlEscapeContent;
3585
3586     do {
3587         oldwritten = written;
3588
3589         /*
3590          * how many bytes to consume and how many bytes to store.
3591          */
3592         cons = len;
3593         chunk = xmlBufAvail(out->buffer) - 1;
3594
3595         /*
3596          * make sure we have enough room to save first, if this is
3597          * not the case force a flush, but make sure we stay in the loop
3598          */
3599         if (chunk < 40) {
3600             if (xmlBufGrow(out->buffer, 100) < 0)
3601                 return(-1);
3602             oldwritten = -1;
3603             continue;
3604         }
3605
3606         /*
3607          * first handle encoding stuff.
3608          */
3609         if (out->encoder != NULL) {
3610             /*
3611              * Store the data in the incoming raw buffer
3612              */
3613             if (out->conv == NULL) {
3614                 out->conv = xmlBufCreate();
3615             }
3616             ret = escaping(xmlBufEnd(out->buffer) ,
3617                            &chunk, str, &cons);
3618             if ((ret < 0) || (chunk == 0)) /* chunk==0 => nothing done */
3619                 return(-1);
3620             xmlBufAddLen(out->buffer, chunk);
3621
3622             if ((xmlBufUse(out->buffer) < MINLEN) && (cons == len))
3623                 goto done;
3624
3625             /*
3626              * convert as much as possible to the output buffer.
3627              */
3628             ret = xmlCharEncOutput(out, 0);
3629             if ((ret < 0) && (ret != -3)) {
3630                 xmlIOErr(XML_IO_ENCODER, NULL);
3631                 out->error = XML_IO_ENCODER;
3632                 return(-1);
3633             }
3634             nbchars = xmlBufUse(out->conv);
3635         } else {
3636             ret = escaping(xmlBufEnd(out->buffer), &chunk, str, &cons);
3637             if ((ret < 0) || (chunk == 0)) /* chunk==0 => nothing done */
3638                 return(-1);
3639             xmlBufAddLen(out->buffer, chunk);
3640             nbchars = xmlBufUse(out->buffer);
3641         }
3642         str += cons;
3643         len -= cons;
3644
3645         if ((nbchars < MINLEN) && (len <= 0))
3646             goto done;
3647
3648         if (out->writecallback) {
3649             /*
3650              * second write the stuff to the I/O channel
3651              */
3652             if (out->encoder != NULL) {
3653                 ret = out->writecallback(out->context,
3654                            (const char *)xmlBufContent(out->conv), nbchars);
3655                 if (ret >= 0)
3656                     xmlBufShrink(out->conv, ret);
3657             } else {
3658                 ret = out->writecallback(out->context,
3659                            (const char *)xmlBufContent(out->buffer), nbchars);
3660                 if (ret >= 0)
3661                     xmlBufShrink(out->buffer, ret);
3662             }
3663             if (ret < 0) {
3664                 xmlIOErr(XML_IO_WRITE, NULL);
3665                 out->error = XML_IO_WRITE;
3666                 return(ret);
3667             }
3668             out->written += ret;
3669         } else if (xmlBufAvail(out->buffer) < MINLEN) {
3670             xmlBufGrow(out->buffer, MINLEN);
3671         }
3672         written += nbchars;
3673     } while ((len > 0) && (oldwritten != written));
3674
3675 done:
3676 #ifdef DEBUG_INPUT
3677     xmlGenericError(xmlGenericErrorContext,
3678             "I/O: wrote %d chars\n", written);
3679 #endif
3680     return(written);
3681 }
3682
3683 /**
3684  * xmlOutputBufferWriteString:
3685  * @out:  a buffered parser output
3686  * @str:  a zero terminated C string
3687  *
3688  * Write the content of the string in the output I/O buffer
3689  * This routine handle the I18N transcoding from internal UTF-8
3690  * The buffer is lossless, i.e. will store in case of partial
3691  * or delayed writes.
3692  *
3693  * Returns the number of chars immediately written, or -1
3694  *         in case of error.
3695  */
3696 int
3697 xmlOutputBufferWriteString(xmlOutputBufferPtr out, const char *str) {
3698     int len;
3699
3700     if ((out == NULL) || (out->error)) return(-1);
3701     if (str == NULL)
3702         return(-1);
3703     len = strlen(str);
3704
3705     if (len > 0)
3706         return(xmlOutputBufferWrite(out, len, str));
3707     return(len);
3708 }
3709
3710 /**
3711  * xmlOutputBufferFlush:
3712  * @out:  a buffered output
3713  *
3714  * flushes the output I/O channel
3715  *
3716  * Returns the number of byte written or -1 in case of error.
3717  */
3718 int
3719 xmlOutputBufferFlush(xmlOutputBufferPtr out) {
3720     int nbchars = 0, ret = 0;
3721
3722     if ((out == NULL) || (out->error)) return(-1);
3723     /*
3724      * first handle encoding stuff.
3725      */
3726     if ((out->conv != NULL) && (out->encoder != NULL)) {
3727         /*
3728          * convert as much as possible to the parser output buffer.
3729          */
3730         do {
3731             nbchars = xmlCharEncOutput(out, 0);
3732             if (nbchars < 0) {
3733                 xmlIOErr(XML_IO_ENCODER, NULL);
3734                 out->error = XML_IO_ENCODER;
3735                 return(-1);
3736             }
3737         } while (nbchars);
3738     }
3739
3740     /*
3741      * second flush the stuff to the I/O channel
3742      */
3743     if ((out->conv != NULL) && (out->encoder != NULL) &&
3744         (out->writecallback != NULL)) {
3745         ret = out->writecallback(out->context,
3746                                  (const char *)xmlBufContent(out->conv),
3747                                  xmlBufUse(out->conv));
3748         if (ret >= 0)
3749             xmlBufShrink(out->conv, ret);
3750     } else if (out->writecallback != NULL) {
3751         ret = out->writecallback(out->context,
3752                                  (const char *)xmlBufContent(out->buffer),
3753                                  xmlBufUse(out->buffer));
3754         if (ret >= 0)
3755             xmlBufShrink(out->buffer, ret);
3756     }
3757     if (ret < 0) {
3758         xmlIOErr(XML_IO_FLUSH, NULL);
3759         out->error = XML_IO_FLUSH;
3760         return(ret);
3761     }
3762     out->written += ret;
3763
3764 #ifdef DEBUG_INPUT
3765     xmlGenericError(xmlGenericErrorContext,
3766             "I/O: flushed %d chars\n", ret);
3767 #endif
3768     return(ret);
3769 }
3770 #endif /* LIBXML_OUTPUT_ENABLED */
3771
3772 /**
3773  * xmlParserGetDirectory:
3774  * @filename:  the path to a file
3775  *
3776  * lookup the directory for that file
3777  *
3778  * Returns a new allocated string containing the directory, or NULL.
3779  */
3780 char *
3781 xmlParserGetDirectory(const char *filename) {
3782     char *ret = NULL;
3783     char dir[1024];
3784     char *cur;
3785
3786 #ifdef _WIN32_WCE  /* easy way by now ... wince does not have dirs! */
3787     return NULL;
3788 #endif
3789
3790     if (xmlInputCallbackInitialized == 0)
3791         xmlRegisterDefaultInputCallbacks();
3792
3793     if (filename == NULL) return(NULL);
3794
3795 #if defined(WIN32) && !defined(__CYGWIN__)
3796 #   define IS_XMLPGD_SEP(ch) ((ch=='/')||(ch=='\\'))
3797 #else
3798 #   define IS_XMLPGD_SEP(ch) (ch=='/')
3799 #endif
3800
3801     strncpy(dir, filename, 1023);
3802     dir[1023] = 0;
3803     cur = &dir[strlen(dir)];
3804     while (cur > dir) {
3805          if (IS_XMLPGD_SEP(*cur)) break;
3806          cur --;
3807     }
3808     if (IS_XMLPGD_SEP(*cur)) {
3809         if (cur == dir) dir[1] = 0;
3810         else *cur = 0;
3811         ret = xmlMemStrdup(dir);
3812     } else {
3813         if (getcwd(dir, 1024) != NULL) {
3814             dir[1023] = 0;
3815             ret = xmlMemStrdup(dir);
3816         }
3817     }
3818     return(ret);
3819 #undef IS_XMLPGD_SEP
3820 }
3821
3822 /****************************************************************
3823  *                                                              *
3824  *              External entities loading                       *
3825  *                                                              *
3826  ****************************************************************/
3827
3828 /**
3829  * xmlCheckHTTPInput:
3830  * @ctxt: an XML parser context
3831  * @ret: an XML parser input
3832  *
3833  * Check an input in case it was created from an HTTP stream, in that
3834  * case it will handle encoding and update of the base URL in case of
3835  * redirection. It also checks for HTTP errors in which case the input
3836  * is cleanly freed up and an appropriate error is raised in context
3837  *
3838  * Returns the input or NULL in case of HTTP error.
3839  */
3840 xmlParserInputPtr
3841 xmlCheckHTTPInput(xmlParserCtxtPtr ctxt, xmlParserInputPtr ret) {
3842 #ifdef LIBXML_HTTP_ENABLED
3843     if ((ret != NULL) && (ret->buf != NULL) &&
3844         (ret->buf->readcallback == xmlIOHTTPRead) &&
3845         (ret->buf->context != NULL)) {
3846         const char *encoding;
3847         const char *redir;
3848         const char *mime;
3849         int code;
3850
3851         code = xmlNanoHTTPReturnCode(ret->buf->context);
3852         if (code >= 400) {
3853             /* fatal error */
3854             if (ret->filename != NULL)
3855                 __xmlLoaderErr(ctxt, "failed to load HTTP resource \"%s\"\n",
3856                          (const char *) ret->filename);
3857             else
3858                 __xmlLoaderErr(ctxt, "failed to load HTTP resource\n", NULL);
3859             xmlFreeInputStream(ret);
3860             ret = NULL;
3861         } else {
3862
3863             mime = xmlNanoHTTPMimeType(ret->buf->context);
3864             if ((xmlStrstr(BAD_CAST mime, BAD_CAST "/xml")) ||
3865                 (xmlStrstr(BAD_CAST mime, BAD_CAST "+xml"))) {
3866                 encoding = xmlNanoHTTPEncoding(ret->buf->context);
3867                 if (encoding != NULL) {
3868                     xmlCharEncodingHandlerPtr handler;
3869
3870                     handler = xmlFindCharEncodingHandler(encoding);
3871                     if (handler != NULL) {
3872                         xmlSwitchInputEncoding(ctxt, ret, handler);
3873                     } else {
3874                         __xmlErrEncoding(ctxt, XML_ERR_UNKNOWN_ENCODING,
3875                                          "Unknown encoding %s",
3876                                          BAD_CAST encoding, NULL);
3877                     }
3878                     if (ret->encoding == NULL)
3879                         ret->encoding = xmlStrdup(BAD_CAST encoding);
3880                 }
3881 #if 0
3882             } else if (xmlStrstr(BAD_CAST mime, BAD_CAST "html")) {
3883 #endif
3884             }
3885             redir = xmlNanoHTTPRedir(ret->buf->context);
3886             if (redir != NULL) {
3887                 if (ret->filename != NULL)
3888                     xmlFree((xmlChar *) ret->filename);
3889                 if (ret->directory != NULL) {
3890                     xmlFree((xmlChar *) ret->directory);
3891                     ret->directory = NULL;
3892                 }
3893                 ret->filename =
3894                     (char *) xmlStrdup((const xmlChar *) redir);
3895             }
3896         }
3897     }
3898 #endif
3899     return(ret);
3900 }
3901
3902 static int xmlNoNetExists(const char *URL) {
3903     const char *path;
3904
3905     if (URL == NULL)
3906         return(0);
3907
3908     if (!xmlStrncasecmp(BAD_CAST URL, BAD_CAST "file://localhost/", 17))
3909 #if defined (_WIN32) || defined (__DJGPP__) && !defined(__CYGWIN__)
3910         path = &URL[17];
3911 #else
3912         path = &URL[16];
3913 #endif
3914     else if (!xmlStrncasecmp(BAD_CAST URL, BAD_CAST "file:///", 8)) {
3915 #if defined (_WIN32) || defined (__DJGPP__) && !defined(__CYGWIN__)
3916         path = &URL[8];
3917 #else
3918         path = &URL[7];
3919 #endif
3920     } else
3921         path = URL;
3922
3923     return xmlCheckFilename(path);
3924 }
3925
3926 #ifdef LIBXML_CATALOG_ENABLED
3927
3928 /**
3929  * xmlResolveResourceFromCatalog:
3930  * @URL:  the URL for the entity to load
3931  * @ID:  the System ID for the entity to load
3932  * @ctxt:  the context in which the entity is called or NULL
3933  *
3934  * Resolves the URL and ID against the appropriate catalog.
3935  * This function is used by xmlDefaultExternalEntityLoader and
3936  * xmlNoNetExternalEntityLoader.
3937  *
3938  * Returns a new allocated URL, or NULL.
3939  */
3940 static xmlChar *
3941 xmlResolveResourceFromCatalog(const char *URL, const char *ID,
3942                               xmlParserCtxtPtr ctxt) {
3943     xmlChar *resource = NULL;
3944     xmlCatalogAllow pref;
3945
3946     /*
3947      * If the resource doesn't exists as a file,
3948      * try to load it from the resource pointed in the catalogs
3949      */
3950     pref = xmlCatalogGetDefaults();
3951
3952     if ((pref != XML_CATA_ALLOW_NONE) && (!xmlNoNetExists(URL))) {
3953         /*
3954          * Do a local lookup
3955          */
3956         if ((ctxt != NULL) && (ctxt->catalogs != NULL) &&
3957             ((pref == XML_CATA_ALLOW_ALL) ||
3958              (pref == XML_CATA_ALLOW_DOCUMENT))) {
3959             resource = xmlCatalogLocalResolve(ctxt->catalogs,
3960                                               (const xmlChar *)ID,
3961                                               (const xmlChar *)URL);
3962         }
3963         /*
3964          * Try a global lookup
3965          */
3966         if ((resource == NULL) &&
3967             ((pref == XML_CATA_ALLOW_ALL) ||
3968              (pref == XML_CATA_ALLOW_GLOBAL))) {
3969             resource = xmlCatalogResolve((const xmlChar *)ID,
3970                                          (const xmlChar *)URL);
3971         }
3972         if ((resource == NULL) && (URL != NULL))
3973             resource = xmlStrdup((const xmlChar *) URL);
3974
3975         /*
3976          * TODO: do an URI lookup on the reference
3977          */
3978         if ((resource != NULL) && (!xmlNoNetExists((const char *)resource))) {
3979             xmlChar *tmp = NULL;
3980
3981             if ((ctxt != NULL) && (ctxt->catalogs != NULL) &&
3982                 ((pref == XML_CATA_ALLOW_ALL) ||
3983                  (pref == XML_CATA_ALLOW_DOCUMENT))) {
3984                 tmp = xmlCatalogLocalResolveURI(ctxt->catalogs, resource);
3985             }
3986             if ((tmp == NULL) &&
3987                 ((pref == XML_CATA_ALLOW_ALL) ||
3988                  (pref == XML_CATA_ALLOW_GLOBAL))) {
3989                 tmp = xmlCatalogResolveURI(resource);
3990             }
3991
3992             if (tmp != NULL) {
3993                 xmlFree(resource);
3994                 resource = tmp;
3995             }
3996         }
3997     }
3998
3999     return resource;
4000 }
4001
4002 #endif
4003
4004 /**
4005  * xmlDefaultExternalEntityLoader:
4006  * @URL:  the URL for the entity to load
4007  * @ID:  the System ID for the entity to load
4008  * @ctxt:  the context in which the entity is called or NULL
4009  *
4010  * By default we don't load external entitites, yet.
4011  *
4012  * Returns a new allocated xmlParserInputPtr, or NULL.
4013  */
4014 static xmlParserInputPtr
4015 xmlDefaultExternalEntityLoader(const char *URL, const char *ID,
4016                                xmlParserCtxtPtr ctxt)
4017 {
4018     xmlParserInputPtr ret = NULL;
4019     xmlChar *resource = NULL;
4020
4021 #ifdef DEBUG_EXTERNAL_ENTITIES
4022     xmlGenericError(xmlGenericErrorContext,
4023                     "xmlDefaultExternalEntityLoader(%s, xxx)\n", URL);
4024 #endif
4025     if ((ctxt != NULL) && (ctxt->options & XML_PARSE_NONET)) {
4026         int options = ctxt->options;
4027
4028         ctxt->options -= XML_PARSE_NONET;
4029         ret = xmlNoNetExternalEntityLoader(URL, ID, ctxt);
4030         ctxt->options = options;
4031         return(ret);
4032     }
4033 #ifdef LIBXML_CATALOG_ENABLED
4034     resource = xmlResolveResourceFromCatalog(URL, ID, ctxt);
4035 #endif
4036
4037     if (resource == NULL)
4038         resource = (xmlChar *) URL;
4039
4040     if (resource == NULL) {
4041         if (ID == NULL)
4042             ID = "NULL";
4043         __xmlLoaderErr(ctxt, "failed to load external entity \"%s\"\n", ID);
4044         return (NULL);
4045     }
4046     ret = xmlNewInputFromFile(ctxt, (const char *) resource);
4047     if ((resource != NULL) && (resource != (xmlChar *) URL))
4048         xmlFree(resource);
4049     return (ret);
4050 }
4051
4052 static xmlExternalEntityLoader xmlCurrentExternalEntityLoader =
4053        xmlDefaultExternalEntityLoader;
4054
4055 /**
4056  * xmlSetExternalEntityLoader:
4057  * @f:  the new entity resolver function
4058  *
4059  * Changes the defaultexternal entity resolver function for the application
4060  */
4061 void
4062 xmlSetExternalEntityLoader(xmlExternalEntityLoader f) {
4063     xmlCurrentExternalEntityLoader = f;
4064 }
4065
4066 /**
4067  * xmlGetExternalEntityLoader:
4068  *
4069  * Get the default external entity resolver function for the application
4070  *
4071  * Returns the xmlExternalEntityLoader function pointer
4072  */
4073 xmlExternalEntityLoader
4074 xmlGetExternalEntityLoader(void) {
4075     return(xmlCurrentExternalEntityLoader);
4076 }
4077
4078 /**
4079  * xmlLoadExternalEntity:
4080  * @URL:  the URL for the entity to load
4081  * @ID:  the Public ID for the entity to load
4082  * @ctxt:  the context in which the entity is called or NULL
4083  *
4084  * Load an external entity, note that the use of this function for
4085  * unparsed entities may generate problems
4086  *
4087  * Returns the xmlParserInputPtr or NULL
4088  */
4089 xmlParserInputPtr
4090 xmlLoadExternalEntity(const char *URL, const char *ID,
4091                       xmlParserCtxtPtr ctxt) {
4092     if ((URL != NULL) && (xmlNoNetExists(URL) == 0)) {
4093         char *canonicFilename;
4094         xmlParserInputPtr ret;
4095
4096         canonicFilename = (char *) xmlCanonicPath((const xmlChar *) URL);
4097         if (canonicFilename == NULL) {
4098             xmlIOErrMemory("building canonical path\n");
4099             return(NULL);
4100         }
4101
4102         ret = xmlCurrentExternalEntityLoader(canonicFilename, ID, ctxt);
4103         xmlFree(canonicFilename);
4104         return(ret);
4105     }
4106     return(xmlCurrentExternalEntityLoader(URL, ID, ctxt));
4107 }
4108
4109 /************************************************************************
4110  *                                                                      *
4111  *              Disabling Network access                                *
4112  *                                                                      *
4113  ************************************************************************/
4114
4115 /**
4116  * xmlNoNetExternalEntityLoader:
4117  * @URL:  the URL for the entity to load
4118  * @ID:  the System ID for the entity to load
4119  * @ctxt:  the context in which the entity is called or NULL
4120  *
4121  * A specific entity loader disabling network accesses, though still
4122  * allowing local catalog accesses for resolution.
4123  *
4124  * Returns a new allocated xmlParserInputPtr, or NULL.
4125  */
4126 xmlParserInputPtr
4127 xmlNoNetExternalEntityLoader(const char *URL, const char *ID,
4128                              xmlParserCtxtPtr ctxt) {
4129     xmlParserInputPtr input = NULL;
4130     xmlChar *resource = NULL;
4131
4132 #ifdef LIBXML_CATALOG_ENABLED
4133     resource = xmlResolveResourceFromCatalog(URL, ID, ctxt);
4134 #endif
4135
4136     if (resource == NULL)
4137         resource = (xmlChar *) URL;
4138
4139     if (resource != NULL) {
4140         if ((!xmlStrncasecmp(BAD_CAST resource, BAD_CAST "ftp://", 6)) ||
4141             (!xmlStrncasecmp(BAD_CAST resource, BAD_CAST "http://", 7))) {
4142             xmlIOErr(XML_IO_NETWORK_ATTEMPT, (const char *) resource);
4143             if (resource != (xmlChar *) URL)
4144                 xmlFree(resource);
4145             return(NULL);
4146         }
4147     }
4148     input = xmlDefaultExternalEntityLoader((const char *) resource, ID, ctxt);
4149     if (resource != (xmlChar *) URL)
4150         xmlFree(resource);
4151     return(input);
4152 }
4153
4154 #define bottom_xmlIO
4155 #include "elfgcchack.h"