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