Annotation of embedaddon/libxml2/xmlIO.c, revision 1.1
1.1 ! misho 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"
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to xmlIO.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libxml2