/*
* xmlIO.c : implementation of the I/O interfaces used by the parser
*
* See Copyright for the status of this software.
*
* daniel@veillard.com
*
* 14 Nov 2000 ht - for VMS, truncated name of long functions to under 32 char
*/
#define IN_LIBXML
#include "libxml.h"
#include <string.h>
#ifdef HAVE_ERRNO_H
#include <errno.h>
#endif
#ifdef HAVE_SYS_TYPES_H
#endif
#ifdef HAVE_SYS_STAT_H
#endif
#ifdef HAVE_FCNTL_H
#include <fcntl.h>
#endif
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif
#ifdef HAVE_ZLIB_H
#include <zlib.h>
#endif
#include <windows.h>
#endif
#if defined(_WIN32_WCE)
#include <winnls.h> /* for CP_UTF8 */
#endif
/* Figure a portable way to know if a file is a directory. */
#ifndef HAVE_STAT
# ifdef HAVE__STAT
/* MS C library seems to define stat and _stat. The definition
is identical. Still, mapping them to each other causes a warning. */
# ifndef _MSC_VER
# endif
# define HAVE_STAT
# endif
#else
# ifdef HAVE__STAT
# endif
# endif
#endif
#ifdef HAVE_STAT
# ifndef S_ISDIR
# ifdef _S_ISDIR
# else
# ifdef S_IFDIR
# ifndef S_IFMT
# ifdef _S_IFMT
# endif
# endif
# ifdef S_IFMT
# endif
# endif
# endif
# endif
#endif
#include <libxml/xmlmemory.h>
#include <libxml/parserInternals.h>
#include <libxml/nanohttp.h>
#include <libxml/xmlerror.h>
#ifdef LIBXML_CATALOG_ENABLED
#endif
/* #define VERBOSE_FAILURE */
/* #define DEBUG_EXTERNAL_ENTITIES */
/* #define DEBUG_INPUT */
#ifdef DEBUG_INPUT
#else
#endif
/*
* Input I/O callback sets
*/
typedef struct _xmlInputCallback {
static int xmlInputCallbackNr = 0;
static int xmlInputCallbackInitialized = 0;
#ifdef LIBXML_OUTPUT_ENABLED
/*
* Output I/O callback sets
*/
typedef struct _xmlOutputCallback {
static int xmlOutputCallbackNr = 0;
static int xmlOutputCallbackInitialized = 0;
#endif /* LIBXML_OUTPUT_ENABLED */
/************************************************************************
* *
* Tree memory error handler *
* *
************************************************************************/
static const char *IOerr[] = {
"Unknown IO error", /* UNKNOWN */
"Permission denied", /* EACCES */
"Resource temporarily unavailable",/* EAGAIN */
"Bad file descriptor", /* EBADF */
"Bad message", /* EBADMSG */
"Resource busy", /* EBUSY */
"Operation canceled", /* ECANCELED */
"No child processes", /* ECHILD */
"Resource deadlock avoided",/* EDEADLK */
"Domain error", /* EDOM */
"File exists", /* EEXIST */
"Bad address", /* EFAULT */
"File too large", /* EFBIG */
"Operation in progress", /* EINPROGRESS */
"Interrupted function call",/* EINTR */
"Invalid argument", /* EINVAL */
"Is a directory", /* EISDIR */
"Too many open files", /* EMFILE */
"Too many links", /* EMLINK */
"Inappropriate message buffer length",/* EMSGSIZE */
"Filename too long", /* ENAMETOOLONG */
"Too many open files in system",/* ENFILE */
"No such device", /* ENODEV */
"No such file or directory",/* ENOENT */
"Exec format error", /* ENOEXEC */
"No locks available", /* ENOLCK */
"Not enough space", /* ENOMEM */
"No space left on device", /* ENOSPC */
"Function not implemented", /* ENOSYS */
"Not a directory", /* ENOTDIR */
"Directory not empty", /* ENOTEMPTY */
"Not supported", /* ENOTSUP */
"Inappropriate I/O control operation",/* ENOTTY */
"No such device or address",/* ENXIO */
"Operation not permitted", /* EPERM */
"Broken pipe", /* EPIPE */
"Result too large", /* ERANGE */
"Read-only file system", /* EROFS */
"Invalid seek", /* ESPIPE */
"No such process", /* ESRCH */
"Operation timed out", /* ETIMEDOUT */
"Improper link", /* EXDEV */
"Attempt to load network entity %s", /* XML_IO_NETWORK_ATTEMPT */
"encoder error", /* XML_IO_ENCODER */
"flush error",
"write error",
"no input",
"buffer full",
"loading error",
"not a socket", /* ENOTSOCK */
"already connected", /* EISCONN */
"connection refused", /* ECONNREFUSED */
"unreachable network", /* ENETUNREACH */
"adddress in use", /* EADDRINUSE */
"already in use", /* EALREADY */
"unknown address familly", /* EAFNOSUPPORT */
};
/**
* __xmlIOWin32UTF8ToWChar:
* @u8String: uft-8 string
*
* Convert a string from utf-8 to wchar (WINDOWS ONLY!)
*/
static wchar_t *
{
if (u8String) {
int wLen =
-1, NULL, 0);
if (wLen) {
if (wString) {
}
}
}
}
return wString;
}
#endif
/**
* xmlIOErrMemory:
* @extra: extra informations
*
* Handle an out of memory condition
*/
static void
{
}
/**
* __xmlIOErr:
* @code: the error number
* @
* @extra: extra informations
*
* Handle an I/O error
*/
void
{
unsigned int idx;
if (code == 0) {
#ifdef HAVE_ERRNO_H
#ifdef EACCES
#endif
#ifdef EAGAIN
#endif
#ifdef EBADF
#endif
#ifdef EBADMSG
#endif
#ifdef EBUSY
#endif
#ifdef ECANCELED
#endif
#ifdef ECHILD
#endif
#ifdef EDEADLK
#endif
#ifdef EDOM
#endif
#ifdef EEXIST
#endif
#ifdef EFAULT
#endif
#ifdef EFBIG
#endif
#ifdef EINPROGRESS
#endif
#ifdef EINTR
#endif
#ifdef EINVAL
#endif
#ifdef EIO
#endif
#ifdef EISDIR
#endif
#ifdef EMFILE
#endif
#ifdef EMLINK
#endif
#ifdef EMSGSIZE
#endif
#ifdef ENAMETOOLONG
#endif
#ifdef ENFILE
#endif
#ifdef ENODEV
#endif
#ifdef ENOENT
#endif
#ifdef ENOEXEC
#endif
#ifdef ENOLCK
#endif
#ifdef ENOMEM
#endif
#ifdef ENOSPC
#endif
#ifdef ENOSYS
#endif
#ifdef ENOTDIR
#endif
#ifdef ENOTEMPTY
#endif
#ifdef ENOTSUP
#endif
#ifdef ENOTTY
#endif
#ifdef ENXIO
#endif
#ifdef EPERM
#endif
#ifdef EPIPE
#endif
#ifdef ERANGE
#endif
#ifdef EROFS
#endif
#ifdef ESPIPE
#endif
#ifdef ESRCH
#endif
#ifdef ETIMEDOUT
#endif
#ifdef EXDEV
#endif
#ifdef ENOTSOCK
#endif
#ifdef EISCONN
#endif
#ifdef ECONNREFUSED
#endif
#ifdef ETIMEDOUT
#endif
#ifdef ENETUNREACH
#endif
#ifdef EADDRINUSE
#endif
#ifdef EINPROGRESS
#endif
#ifdef EALREADY
#endif
#ifdef EAFNOSUPPORT
#endif
else code = XML_IO_UNKNOWN;
#endif /* HAVE_ERRNO_H */
}
idx = 0;
}
/**
* xmlIOErr:
* @code: the error number
* @extra: extra informations
*
* Handle an I/O error
*/
static void
{
}
/**
* __xmlLoaderErr:
* @ctx: the parser context
* @extra: extra informations
*
* Handle a resource access error
*/
void
{
return;
} else {
}
}
}
/************************************************************************
* *
* Tree memory error handler *
* *
************************************************************************/
/**
* xmlNormalizeWindowsPath:
* @path: the input file path
*
* This function is obsolete. Please see xmlURIFromPath in uri.c for
* a better solution.
*
* Returns a canonicalized version of the path
*/
xmlChar *
{
return xmlCanonicPath(path);
}
/**
* xmlCleanupInputCallbacks:
*
* clears the entire input callback table. this includes the
* compiled-in I/O.
*/
void
xmlCleanupInputCallbacks(void)
{
int i;
return;
for (i = xmlInputCallbackNr - 1; i >= 0; i--) {
}
xmlInputCallbackNr = 0;
}
/**
* xmlPopInputCallbacks:
*
* Clear the top input callback from the input stack. this includes the
* compiled-in I/O.
*
* Returns the number of input callback registered or -1 in case of error.
*/
int
xmlPopInputCallbacks(void)
{
return(-1);
if (xmlInputCallbackNr <= 0)
return(-1);
return(xmlInputCallbackNr);
}
#ifdef LIBXML_OUTPUT_ENABLED
/**
* xmlCleanupOutputCallbacks:
*
* clears the entire output callback table. this includes the
* compiled-in I/O callbacks.
*/
void
{
int i;
return;
for (i = xmlOutputCallbackNr - 1; i >= 0; i--) {
}
xmlOutputCallbackNr = 0;
}
#endif /* LIBXML_OUTPUT_ENABLED */
/************************************************************************
* *
* Standard I/O for file accesses *
* *
************************************************************************/
/**
* xmlWrapOpenUtf8:
* @path: the path in utf-8 encoding
* @mode: type of access (0 - read, 1 - write)
*
* function opens the file specified by @path
*
*/
static FILE*
{
if(wPath)
{
}
/* maybe path in native encoding */
return fd;
}
/**
* xmlWrapStatUtf8:
* @path: the path in utf-8 encoding
* @info: structure that stores results
*
* function obtains information about the file or directory
*
*/
static int
{
#ifdef HAVE_STAT
if (wPath)
{
}
/* maybe path in native encoding */
if(retval < 0)
return retval;
#else
return -1;
#endif
}
/**
* xmlWrapOpenNative:
* @path: the path
* @mode: type of access (0 - read, 1 - write)
*
* function opens the file specified by @path
*
*/
static FILE*
{
}
/**
* xmlWrapStatNative:
* @path: the path
* @info: structure that stores results
*
* function obtains information about the file or directory
*
*/
static int
{
#ifdef HAVE_STAT
#else
return -1;
#endif
}
/**
* xmlInitPlatformSpecificIo:
*
* Initialize platform specific features.
*/
static void
{
static int xmlPlatformIoInitialized = 0;
return;
} else {
}
return;
}
#endif
/**
* xmlCheckFilename:
* @path: the path to check
*
* function checks to see if @path is a valid source
* (file, socket...) for XML.
*
* if stat is not available on the target machine,
* returns 1. if stat fails, returns 0 (if calling
* stat on the filename fails, it can't be right).
* if stat succeeds and the file is a directory,
* returns 2. otherwise returns 1.
*/
int
{
#ifdef HAVE_STAT
#endif
return(0);
#ifdef HAVE_STAT
return 0;
#else
return 0;
#endif
#ifdef S_ISDIR
return 2;
#endif
#endif /* HAVE_STAT */
return 1;
}
static int
xmlNop(void) {
return(0);
}
/**
* xmlFdRead:
* @context: the I/O context
* @buffer: where to drop data
* @len: number of bytes to read
*
* Read @len bytes to @buffer from the I/O channel.
*
* Returns the number of bytes written
*/
static int
int ret;
return(ret);
}
#ifdef LIBXML_OUTPUT_ENABLED
/**
* xmlFdWrite:
* @context: the I/O context
* @buffer: where to get data
* @len: number of bytes to write
*
* Write @len bytes from @buffer to the I/O channel.
*
* Returns the number of bytes written
*/
static int
int ret = 0;
if (len > 0) {
}
return(ret);
}
#endif /* LIBXML_OUTPUT_ENABLED */
/**
* xmlFdClose:
* @context: the I/O context
*
* Close an I/O channel
*
* Returns 0 in case of success and error code otherwise
*/
static int
int ret;
return(ret);
}
/**
* xmlFileMatch:
* @filename: the URI for matching
*
* input from FILE *
*
* Returns 1 if matches, 0 otherwise
*/
int
return(1);
}
/**
* xmlFileOpen_real:
* @filename: the URI for matching
*
* input from FILE *, supports compressed input
* if @filename is " " then the standard input is used
*
* Returns an I/O context or NULL in case of error
*/
static void *
return(NULL);
return((void *) fd);
}
#else
#endif
#else
#endif
/* lots of generators seems to lazy to read RFC 1738 */
#else
#endif
} else
return(NULL);
if (!xmlCheckFilename(path))
return(NULL);
#else
#endif /* WIN32 */
return((void *) fd);
}
/**
* xmlFileOpen:
* @filename: the URI for matching
*
* Wrapper around xmlFileOpen_real that try it with an unescaped
* version of @filename, if this fails fallback to @filename
*
* Returns a handler or NULL in case or failure
*/
void *
char *unescaped;
void *retval;
}
}
return retval;
}
#ifdef LIBXML_OUTPUT_ENABLED
/**
* xmlFileOpenW:
* @filename: the URI for matching
*
* output to from FILE *,
* if @filename is "-" then the standard output is used
*
* Returns an I/O context or NULL in case of error
*/
static void *
return((void *) fd);
}
#else
#endif
#else
#endif
} else
return(NULL);
#else
#endif /* WIN32 */
return((void *) fd);
}
#endif /* LIBXML_OUTPUT_ENABLED */
/**
* xmlFileRead:
* @context: the I/O context
* @buffer: where to drop data
* @len: number of bytes to write
*
* Read @len bytes to @buffer from the I/O channel.
*
* Returns the number of bytes written or < 0 in case of failure
*/
int
int ret;
return(-1);
return(ret);
}
#ifdef LIBXML_OUTPUT_ENABLED
/**
* xmlFileWrite:
* @context: the I/O context
* @buffer: where to drop data
* @len: number of bytes to write
*
* Write @len bytes from @buffer to the I/O channel.
*
* Returns the number of bytes written
*/
static int
int items;
return(-1);
xmlIOErr(0, "fwrite()");
return(-1);
}
}
#endif /* LIBXML_OUTPUT_ENABLED */
/**
* xmlFileClose:
* @context: the I/O context
*
* Close an I/O channel
*
* Returns 0 or -1 in case of error
*/
int
int ret;
return(-1);
if (ret < 0)
xmlIOErr(0, "fflush()");
return(0);
}
return(0);
if (ret < 0)
xmlIOErr(0, "fclose()");
return(ret);
}
/**
* xmlFileFlush:
* @context: the I/O context
*
* Flush an I/O channel
*/
static int
int ret;
return(-1);
if (ret < 0)
xmlIOErr(0, "fflush()");
return(ret);
}
#ifdef LIBXML_OUTPUT_ENABLED
/**
* xmlBufferWrite:
* @context: the xmlBuffer
* @buffer: the data to write
* @len: number of bytes to write
*
* Write @len bytes from @buffer to the xml buffer
*
* Returns the number of bytes written
*/
static int
int ret;
if (ret != 0)
return(-1);
return(len);
}
#endif
#ifdef HAVE_ZLIB_H
/************************************************************************
* *
* I/O for compressed file accesses *
* *
************************************************************************/
/**
* xmlGzfileMatch:
* @filename: the URI for matching
*
* input from compressed file test
*
* Returns 1 if matches, 0 otherwise
*/
static int
return(1);
}
/**
* xmlGzfileOpen_real:
* @filename: the URI for matching
*
* input from compressed file open
* if @filename is " " then the standard input is used
*
* Returns an I/O context or NULL in case of error
*/
static void *
return((void *) fd);
}
#else
#endif
#else
#endif
} else
return(NULL);
if (!xmlCheckFilename(path))
return(NULL);
return((void *) fd);
}
/**
* xmlGzfileOpen:
* @filename: the URI for matching
*
* Wrapper around xmlGzfileOpen if the open fais, it will
* try to unescape @filename
*/
static void *
char *unescaped;
void *retval;
}
}
return retval;
}
#ifdef LIBXML_OUTPUT_ENABLED
/**
* xmlGzfileOpenW:
* @filename: the URI for matching
* @compression: the compression factor (0 - 9 included)
*
* input from compressed file open
* if @filename is " " then the standard input is used
*
* Returns an I/O context or NULL in case of error
*/
static void *
return((void *) fd);
}
#else
#endif
#else
#endif
} else
return(NULL);
return((void *) fd);
}
#endif /* LIBXML_OUTPUT_ENABLED */
/**
* xmlGzfileRead:
* @context: the I/O context
* @buffer: where to drop data
* @len: number of bytes to write
*
* Read @len bytes to @buffer from the compressed I/O channel.
*
* Returns the number of bytes written
*/
static int
int ret;
return(ret);
}
#ifdef LIBXML_OUTPUT_ENABLED
/**
* xmlGzfileWrite:
* @context: the I/O context
* @buffer: where to drop data
* @len: number of bytes to write
*
* Write @len bytes from @buffer to the compressed I/O channel.
*
* Returns the number of bytes written
*/
static int
int ret;
return(ret);
}
#endif /* LIBXML_OUTPUT_ENABLED */
/**
* xmlGzfileClose:
* @context: the I/O context
*
* Close a compressed I/O channel
*/
static int
int ret;
return(ret);
}
#endif /* HAVE_ZLIB_H */
#ifdef LIBXML_HTTP_ENABLED
/************************************************************************
* *
* I/O for HTTP file accesses *
* *
************************************************************************/
#ifdef LIBXML_OUTPUT_ENABLED
typedef struct xmlIOHTTPWriteCtxt_
{
int compression;
char * uri;
void * doc_buff;
#ifdef HAVE_ZLIB_H
/*
** Data structure and functions to work with sending compressed data
** via HTTP.
*/
typedef struct xmlZMemBuff_
{
unsigned long size;
unsigned long crc;
unsigned char * zbuff;
/**
* append_reverse_ulong
* @buff: Compressed memory buffer
* @data: Unsigned long to append
*
* Append a unsigned long in reverse byte order to the end of the
* memory buffer.
*/
static void
int idx;
return;
/*
** This is plagiarized from putLong in gzio.c (zlib source) where
** the number "4" is hardcoded. If zlib is ever patched to
** support 64 bit file sizes, this code would need to be patched
** as well.
*/
data >>= 8;
}
return;
}
/**
*
* xmlFreeZMemBuff
* @buff: The memory buffer context to clear
*
* Release all the resources associated with the compressed memory buffer.
*/
static void
#ifdef DEBUG_HTTP
int z_err;
#endif
return;
#ifdef DEBUG_HTTP
"xmlFreeZMemBuff: Error releasing zlib context: %d\n",
z_err );
#else
#endif
return;
}
/**
* xmlCreateZMemBuff
*@compression: Compression value to use
*
* Create a memory buffer to hold the compressed XML document. The
* compressed document in memory will end up being identical to what
* the compression is plagiarized from the zlib source files.
*/
static void *
int z_err;
int hdr_lgth;
return ( NULL );
/* Create the control and data areas */
xmlIOErrMemory("creating buffer context");
return ( NULL );
}
xmlFreeZMemBuff( buff );
xmlIOErrMemory("creating buffer");
return ( NULL );
}
xmlFreeZMemBuff( buff );
(const xmlChar *) "xmlCreateZMemBuff: %s %d\n",
"Error initializing compression context. ZLIB error:",
z_err );
return ( NULL );
}
/* Set the header data. The CRC will be needed for the trailer */
"%c%c%c%c%c%c%c%c%c%c",
0, 0, 0, 0, 0, 0, LXML_ZLIB_OS_CODE );
return ( buff );
}
/**
* xmlZMemBuffExtend
* @buff: Buffer used to compress and consolidate data.
* @ext_amt: Number of bytes to extend the buffer.
*
* Extend the internal buffer used to store the compressed data by the
* specified amount.
*
* Returns 0 on success or -1 on failure to extend the buffer. On failure
* the original buffer still exists at the original size.
*/
static int
return ( -1 );
else if ( ext_amt == 0 )
return ( 0 );
#ifdef DEBUG_HTTP
"xmlZMemBuffExtend: %s\n%s %d bytes.\n",
"Buffer overwrite detected during compressed memory",
"buffer extension. Overflowed by",
#endif
rc = 0;
}
else {
(const xmlChar *) "xmlZMemBuffExtend: %s %lu bytes.\n",
"Allocation failure extending output buffer to",
new_size );
}
return ( rc );
}
/**
* xmlZMemBuffAppend
* @buff: Buffer used to compress and consolidate data
* @src: Uncompressed source content to append to buffer
* @len: Length of source data to append to buffer
*
* Compress and append data to the internal buffer. The data buffer
* will be expanded if needed to store the additional data.
*
* Returns the number of bytes appended to the buffer or -1 on error.
*/
static int
int z_err;
return ( -1 );
/*
** Extend the buffer prior to deflate call if a reasonable amount
** of output buffer space is not available.
*/
return ( -1 );
}
(const xmlChar *) "xmlZMemBuffAppend: %s %d %s - %d",
"Compression error while appending",
return ( -1 );
}
}
return ( len );
}
/**
* xmlZMemBuffGetContent
* @buff: Compressed memory content buffer
* @data_ref: Pointer reference to point to compressed content
*
* Flushes the compression buffers, appends gzip file trailers and
* returns the compressed content and length of the compressed data.
* NOTE: The gzip trailer code here is plagiarized from zlib source.
*
* Returns the length of the compressed data or -1 on error.
*/
static int
int z_err;
return ( -1 );
/* Need to loop until compression output buffers are flushed */
do
{
/* In this case Z_OK means more buffer space needed */
return ( -1 );
}
}
/* If the compression state is not Z_STREAM_END, some error occurred */
if ( z_err == Z_STREAM_END ) {
/* Need to append the gzip data trailer */
return ( -1 );
}
/*
** For whatever reason, the CRC and length data are pushed out
** in reverse byte order. So a memcpy can't be used here.
*/
}
else {
(const xmlChar *) "xmlZMemBuffGetContent: %s - %d\n",
"Error flushing zlib buffers. Error code", z_err );
}
return ( zlgth );
}
#endif /* LIBXML_OUTPUT_ENABLED */
#endif /* HAVE_ZLIB_H */
#ifdef LIBXML_OUTPUT_ENABLED
/**
* xmlFreeHTTPWriteCtxt
* @ctxt: Context to cleanup
*
* Free allocated memory and reclaim system resources.
*
* No return value.
*/
static void
{
#ifdef HAVE_ZLIB_H
if ( ctxt->compression > 0 ) {
}
else
#endif
{
}
}
return;
}
#endif /* LIBXML_OUTPUT_ENABLED */
/**
* xmlIOHTTPMatch:
* @filename: the URI for matching
*
* check if the URI matches an HTTP one
*
* Returns 1 if matches, 0 otherwise
*/
int
return(1);
return(0);
}
/**
* xmlIOHTTPOpen:
* @filename: the URI for matching
*
* open an HTTP I/O channel
*
* Returns an I/O context or NULL in case of error
*/
void *
}
#ifdef LIBXML_OUTPUT_ENABLED
/**
* xmlIOHTTPOpenW:
* @post_uri: The destination URI for the document
* @compression: The compression desired for the document.
*
* Open a temporary buffer to collect the document for a subsequent HTTP POST
* request. Non-static as is called from the output buffer creation routine.
*
* Returns an I/O context or NULL in case of error.
*/
void *
{
return (NULL);
xmlIOErrMemory("creating HTTP output context");
return (NULL);
}
xmlIOErrMemory("copying URI");
return (NULL);
}
/*
* ** Since the document length is required for an HTTP post,
* ** need to put the document into a buffer. A memory buffer
* ** is being used to avoid pushing the data to disk and back.
*/
#ifdef HAVE_ZLIB_H
} else
#endif
{
/* Any character conversions should have been done before this */
}
}
return (ctxt);
}
#endif /* LIBXML_OUTPUT_ENABLED */
#ifdef LIBXML_OUTPUT_ENABLED
/**
* xmlIOHTTPDfltOpenW
* @post_uri: The destination URI for this document.
*
* Calls xmlIOHTTPOpenW with no compression to set up for a subsequent
* HTTP post command. This function should generally not be used as
* the open callback is short circuited in xmlOutputBufferCreateFile.
*
* Returns a pointer to the new IO context.
*/
static void *
return ( xmlIOHTTPOpenW( post_uri, 0 ) );
}
#endif /* LIBXML_OUTPUT_ENABLED */
/**
* xmlIOHTTPRead:
* @context: the I/O context
* @buffer: where to drop data
* @len: number of bytes to write
*
* Read @len bytes to @buffer from the I/O channel.
*
* Returns the number of bytes written
*/
int
}
#ifdef LIBXML_OUTPUT_ENABLED
/**
* xmlIOHTTPWrite
* @context: previously opened writing context
* @buffer: data to output to temporary buffer
* @len: bytes to output
*
* Collect data from memory buffer into a temporary file for later
* processing.
*
* Returns number of bytes written.
*/
static int
return ( -1 );
if ( len > 0 ) {
/* Use gzwrite or fwrite as previously setup in the open call */
#ifdef HAVE_ZLIB_H
if ( ctxt->compression > 0 )
else
#endif
if ( len < 0 ) {
(const xmlChar *) "xmlIOHTTPWrite: %s\n%s '%s'.\n",
"Error appending to internal buffer.",
"Error sending document to URI",
}
}
return ( len );
}
#endif /* LIBXML_OUTPUT_ENABLED */
/**
* xmlIOHTTPClose:
* @context: the I/O context
*
* Close an HTTP I/O channel
*
* Returns 0
*/
int
return 0;
}
#ifdef LIBXML_OUTPUT_ENABLED
/**
* xmlIOHTTCloseWrite
* @context: The I/O context
* @http_mthd: The HTTP method to be used when sending the data
*
* Close the transmit HTTP I/O channel and actually send the data.
*/
static int
int http_rtn = 0;
int content_lgth = 0;
return ( -1 );
/* Retrieve the content from the appropriate buffer */
#ifdef HAVE_ZLIB_H
if ( ctxt->compression > 0 ) {
content_encoding = (char *) "Content-Encoding: gzip";
}
else
#endif
{
/* Pull the data out of the memory output buffer */
}
if ( http_content == NULL ) {
(const xmlChar *) "xmlIOHTTPCloseWrite: %s '%s' %s '%s'.\n",
"Error retrieving content.\nUnable to",
}
else {
content_lgth );
#ifdef DEBUG_HTTP
int avail;
"xmlNanoHTTPCloseWrite: HTTP %s to\n%s returned %d.\n",
/*
** Since either content or reply may be gzipped,
** dump them to separate files instead of the
** standard error context.
*/
"Transmitted content saved in file: %s\n", buffer );
fwrite( http_content, sizeof( char ),
content_lgth, tst_file );
}
"Reply content saved in file: %s\n", buffer );
}
}
}
#endif /* DEBUG_HTTP */
close_rc = 0;
else {
(const xmlChar *) "xmlIOHTTPCloseWrite: HTTP '%s' of %d %s\n'%s' %s %d\n",
"failed. HTTP return code:", http_rtn );
}
xmlFree( content_type );
}
}
/* Final cleanups */
return ( close_rc );
}
/**
* xmlIOHTTPClosePut
*
* @context: The I/O context
*
* Close the transmit HTTP I/O channel and actually send data using a PUT
* HTTP method.
*/
static int
}
/**
* xmlIOHTTPClosePost
*
* @context: The I/O context
*
* Close the transmit HTTP I/O channel and actually send data using a POST
* HTTP method.
*/
static int
}
#endif /* LIBXML_OUTPUT_ENABLED */
#endif /* LIBXML_HTTP_ENABLED */
#ifdef LIBXML_FTP_ENABLED
/************************************************************************
* *
* I/O for FTP file accesses *
* *
************************************************************************/
/**
* xmlIOFTPMatch:
* @filename: the URI for matching
*
* check if the URI matches an FTP one
*
* Returns 1 if matches, 0 otherwise
*/
int
return(1);
return(0);
}
/**
* xmlIOFTPOpen:
* @filename: the URI for matching
*
* open an FTP I/O channel
*
* Returns an I/O context or NULL in case of error
*/
void *
return(xmlNanoFTPOpen(filename));
}
/**
* xmlIOFTPRead:
* @context: the I/O context
* @buffer: where to drop data
* @len: number of bytes to write
*
* Read @len bytes to @buffer from the I/O channel.
*
* Returns the number of bytes written
*/
int
}
/**
* xmlIOFTPClose:
* @context: the I/O context
*
* Close an FTP I/O channel
*
* Returns 0
*/
int
return ( xmlNanoFTPClose(context) );
}
#endif /* LIBXML_FTP_ENABLED */
/**
* xmlRegisterInputCallbacks:
* @matchFunc: the xmlInputMatchCallback
* @openFunc: the xmlInputOpenCallback
* @readFunc: the xmlInputReadCallback
* @closeFunc: the xmlInputCloseCallback
*
* Register a new set of I/O callback for handling parser input.
*
* Returns the registered handler number or -1 in case of error
*/
int
if (xmlInputCallbackNr >= MAX_INPUT_CALLBACK) {
return(-1);
}
return(xmlInputCallbackNr++);
}
#ifdef LIBXML_OUTPUT_ENABLED
/**
* xmlRegisterOutputCallbacks:
* @matchFunc: the xmlOutputMatchCallback
* @openFunc: the xmlOutputOpenCallback
* @writeFunc: the xmlOutputWriteCallback
* @closeFunc: the xmlOutputCloseCallback
*
* Register a new set of I/O callback for handling output.
*
* Returns the registered handler number or -1 in case of error
*/
int
if (xmlOutputCallbackNr >= MAX_INPUT_CALLBACK) {
return(-1);
}
return(xmlOutputCallbackNr++);
}
#endif /* LIBXML_OUTPUT_ENABLED */
/**
* xmlRegisterDefaultInputCallbacks:
*
* Registers the default compiled-in I/O handlers.
*/
void
xmlRegisterDefaultInputCallbacks(void) {
return;
#endif
#ifdef HAVE_ZLIB_H
#endif /* HAVE_ZLIB_H */
#ifdef LIBXML_HTTP_ENABLED
#endif /* LIBXML_HTTP_ENABLED */
#ifdef LIBXML_FTP_ENABLED
#endif /* LIBXML_FTP_ENABLED */
}
#ifdef LIBXML_OUTPUT_ENABLED
/**
* xmlRegisterDefaultOutputCallbacks:
*
* Registers the default compiled-in I/O handlers.
*/
void
xmlRegisterDefaultOutputCallbacks (void) {
return;
#endif
#ifdef LIBXML_HTTP_ENABLED
#endif
/*********************************
No way a-priori to distinguish between gzipped files from
uncompressed ones except opening if existing then closing
and saving with same compression ratio ... a pain.
#ifdef HAVE_ZLIB_H
xmlRegisterOutputCallbacks(xmlGzfileMatch, xmlGzfileOpen,
xmlGzfileWrite, xmlGzfileClose);
#endif
Nor FTP PUT ....
#ifdef LIBXML_FTP_ENABLED
xmlRegisterOutputCallbacks(xmlIOFTPMatch, xmlIOFTPOpen,
xmlIOFTPWrite, xmlIOFTPClose);
#endif
**********************************/
}
#ifdef LIBXML_HTTP_ENABLED
/**
* xmlRegisterHTTPPostCallbacks:
*
* By default, libxml submits HTTP output requests using the "PUT" method.
* Calling this method changes the HTTP output method to use the "POST"
* method instead.
*
*/
void
xmlRegisterHTTPPostCallbacks( void ) {
/* Register defaults if not done previously */
if ( xmlOutputCallbackInitialized == 0 )
return;
}
#endif
#endif /* LIBXML_OUTPUT_ENABLED */
/**
* xmlAllocParserInputBuffer:
* @enc: the charset encoding if known
*
* Create a buffered parser input for progressive parsing
*
* Returns the new parser input or NULL
*/
xmlIOErrMemory("creating input buffer");
return(NULL);
}
return(NULL);
}
else
ret->rawconsumed = 0;
return(ret);
}
#ifdef LIBXML_OUTPUT_ENABLED
/**
* xmlAllocOutputBuffer:
* @encoder: the encoding converter or NULL
*
* Create a buffered parser output
*
* Returns the new parser output or NULL
*/
xmlIOErrMemory("creating output buffer");
return(NULL);
}
return(NULL);
}
/*
* This call is designed to initiate the encoder state
*/
} else
return(ret);
}
#endif /* LIBXML_OUTPUT_ENABLED */
/**
* xmlFreeParserInputBuffer:
* @in: a buffered parser input
*
* Free up the memory used by a buffered parser input
*/
void
}
}
}
}
}
#ifdef LIBXML_OUTPUT_ENABLED
/**
* xmlOutputBufferClose:
* @out: a buffered output
*
* flushes and close the output I/O channel
* and free up all the associated resources
*
* Returns the number of byte written or -1 in case of error.
*/
int
{
int written;
int err_rc = 0;
return (-1);
}
}
}
}
err_rc = -1;
}
#endif /* LIBXML_OUTPUT_ENABLED */
int i = 0;
if (xmlInputCallbackInitialized == 0)
/*
* Try to find one of the input accept method accepting that scheme
* Go in reverse to give precedence to user defined handlers.
*/
for (i = xmlInputCallbackNr - 1;i >= 0;i--) {
break;
}
}
}
}
return(NULL);
}
/*
* Allocate the Input buffer front-end.
*/
#ifdef HAVE_ZLIB_H
ret->compressed = 0;
else
}
}
}
#endif
}
else
return(ret);
}
/**
* xmlParserInputBufferCreateFilename:
* @URI: a C string containing the URI or filename
* @enc: the charset encoding if known
*
* Create a buffered parser input for the progressive parsing of a file
* If filename is "-' then we use stdin as the input.
* by default if found at compile-time.
* Do an encoding check if enc == XML_CHAR_ENCODING_NONE
*
* Returns the new parser input or NULL
*/
}
}
#ifdef LIBXML_OUTPUT_ENABLED
int compression ATTRIBUTE_UNUSED) {
int i = 0;
#ifdef HAVE_ZLIB_H
#endif
if (xmlOutputCallbackInitialized == 0)
#ifdef HAVE_ZLIB_H
is_file_uri = 0;
#endif
/*
* try to limit the damages of the URI unescaping code.
*/
}
/*
* Try to find one of the output accept method accepting that scheme
* Go in reverse to give precedence to user defined handlers.
* try with an unescaped version of the URI
*/
#ifdef HAVE_ZLIB_H
}
return(ret);
}
}
#endif
for (i = xmlOutputCallbackNr - 1;i >= 0;i--) {
#if defined(LIBXML_HTTP_ENABLED) && defined(HAVE_ZLIB_H)
/* Need to pass compression parameter into HTTP open calls */
else
#endif
break;
}
}
}
/*
* If this failed try with a non-escaped URI this may be a strange
* filename
*/
#ifdef HAVE_ZLIB_H
}
return(ret);
}
}
#endif
for (i = xmlOutputCallbackNr - 1;i >= 0;i--) {
#if defined(LIBXML_HTTP_ENABLED) && defined(HAVE_ZLIB_H)
/* Need to pass compression parameter into HTTP open calls */
else
#endif
break;
}
}
}
return(NULL);
}
/*
* Allocate the Output buffer front-end.
*/
}
return(ret);
}
/**
* xmlOutputBufferCreateFilename:
* @URI: a C string containing the URI or filename
* @encoder: the encoding converter or NULL
* @compression: the compression ration (0 none, 9 max).
*
* Create a buffered output for the progressive saving of a file
* If filename is "-' then we use stdout as the output.
* by default if found at compile-time.
* TODO: currently if compression is set, the library only support
* writing to a local file.
*
* Returns the new output or NULL
*/
int compression ATTRIBUTE_UNUSED) {
if ((xmlOutputBufferCreateFilenameValue)) {
}
}
#endif /* LIBXML_OUTPUT_ENABLED */
/**
* xmlParserInputBufferCreateFile:
* @file: a FILE*
* @enc: the charset encoding if known
*
* Create a buffered parser input for the progressive parsing of a FILE *
* buffered C I/O
*
* Returns the new parser input or NULL
*/
if (xmlInputCallbackInitialized == 0)
}
return(ret);
}
#ifdef LIBXML_OUTPUT_ENABLED
/**
* xmlOutputBufferCreateFile:
* @file: a FILE*
* @encoder: the encoding converter or NULL
*
* Create a buffered output for the progressive saving to a FILE *
* buffered C I/O
*
* Returns the new parser output or NULL
*/
if (xmlOutputCallbackInitialized == 0)
}
return(ret);
}
/**
* xmlOutputBufferCreateBuffer:
* @buffer: a xmlBufferPtr
* @encoder: the encoding converter or NULL
*
* Create a buffered output for the progressive saving to a xmlBuffer
*
* Returns the new parser output or NULL
*/
return(ret);
}
#endif /* LIBXML_OUTPUT_ENABLED */
/**
* xmlParserInputBufferCreateFd:
* @fd: a file descriptor number
* @enc: the charset encoding if known
*
* Create a buffered parser input for the progressive parsing for the input
* from a file descriptor
*
* Returns the new parser input or NULL
*/
}
return(ret);
}
/**
* xmlParserInputBufferCreateMem:
* @mem: the memory input
* @size: the length of the memory block
* @enc: the charset encoding if known
*
* Create a buffered parser input for the progressive parsing for the input
* from a memory area.
*
* Returns the new parser input or NULL
*/
int errcode;
if (errcode != 0) {
return(NULL);
}
}
return(ret);
}
/**
* xmlParserInputBufferCreateStatic:
* @mem: the memory input
* @size: the length of the memory block
* @enc: the charset encoding if known
*
* Create a buffered parser input for the progressive parsing for the input
* from an immutable memory area. This will not copy the memory area to
* the buffer, but the memory is expected to be available until the end of
* the parsing, this is useful for example when using mmap'ed file.
*
* Returns the new parser input or NULL
*/
xmlIOErrMemory("creating input buffer");
return(NULL);
}
return(NULL);
}
else
return(ret);
}
#ifdef LIBXML_OUTPUT_ENABLED
/**
* xmlOutputBufferCreateFd:
* @fd: a file descriptor number
* @encoder: the encoding converter or NULL
*
* Create a buffered output for the progressive saving
* to a file descriptor
*
* Returns the new parser output or NULL
*/
}
return(ret);
}
#endif /* LIBXML_OUTPUT_ENABLED */
/**
* xmlParserInputBufferCreateIO:
* @ioread: an I/O read function
* @ioclose: an I/O close function
* @ioctx: an I/O handler
* @enc: the charset encoding if known
*
* Create a buffered parser input for the progressive parsing for the input
* from an I/O handler
*
* Returns the new parser input or NULL
*/
}
return(ret);
}
#ifdef LIBXML_OUTPUT_ENABLED
/**
* xmlOutputBufferCreateIO:
* @iowrite: an I/O write function
* @ioclose: an I/O close function
* @ioctx: an I/O handler
* @encoder: the charset encoding if known
*
* Create a buffered output for the progressive saving
* to an I/O handler
*
* Returns the new parser output or NULL
*/
}
return(ret);
}
#endif /* LIBXML_OUTPUT_ENABLED */
/**
* xmlParserInputBufferCreateFilenameDefault:
* @func: function pointer to the new ParserInputBufferCreateFilenameFunc
*
* Registers a callback for URI input file handling
*
* Returns the old value of the registration function
*/
{
}
return(old);
}
/**
* xmlOutputBufferCreateFilenameDefault:
* @func: function pointer to the new OutputBufferCreateFilenameFunc
*
* Registers a callback for URI output file handling
*
* Returns the old value of the registration function
*/
{
#ifdef LIBXML_OUTPUT_ENABLED
}
#endif
return(old);
}
/**
* xmlParserInputBufferPush:
* @in: a buffered parser input
* @len: the size in bytes of the array.
* @buf: an char array
*
* Push the content of the arry in the input buffer
* This routine handle the I18N transcoding to internal UTF-8
* This is used when operating the parser in progressive (push) mode.
*
* Returns the number of chars read and stored in the buffer, or -1
* in case of error.
*/
int
int nbchars = 0;
int ret;
if (len < 0) return(0);
unsigned int use;
/*
* Store the data in the incoming raw buffer
*/
}
if (ret != 0)
return(-1);
/*
* convert as much as possible to the parser reading buffer.
*/
if (nbchars < 0) {
return(-1);
}
} else {
if (ret != 0)
return(-1);
}
#ifdef DEBUG_INPUT
"I/O: pushed %d chars, buffer %d/%d\n",
#endif
return(nbchars);
}
/**
* endOfInput:
*
* When reading from an Input channel indicated end of file or error
* don't reread from it again.
*/
static int
char * buffer ATTRIBUTE_UNUSED,
int len ATTRIBUTE_UNUSED) {
return(0);
}
/**
* xmlParserInputBufferGrow:
* @in: a buffered parser input
* @len: indicative value of the amount of chars to read
*
* Grow up the content of the input buffer, the old data are preserved
* This routine handle the I18N transcoding to internal UTF-8
* This routine is used when operating the parser in normal (pull) mode
*
* TODO: one should be able to remove one extra copy by copying directly
* onto in->buffer or in->raw
*
* Returns the number of chars read and stored in the buffer, or -1
* in case of error.
*/
int
int res = 0;
int nbchars = 0;
int buffree;
unsigned int needSize;
if (buffree <= 0) {
return(-1);
}
xmlIOErrMemory("growing input buffer");
return(-1);
}
}
/*
* Call the read method for this I/O type.
*/
if (res <= 0)
} else {
return(-1);
}
if (res < 0) {
return(-1);
}
unsigned int use;
/*
* Store the data in the incoming raw buffer
*/
}
if (res != 0)
return(-1);
/*
* convert as much as possible to the parser reading buffer.
*/
if (nbchars < 0) {
return(-1);
}
} else {
}
#ifdef DEBUG_INPUT
"I/O: read %d chars, buffer %d/%d\n",
#endif
return(nbchars);
}
/**
* xmlParserInputBufferRead:
* @in: a buffered parser input
* @len: indicative value of the amount of chars to read
*
* Refresh the content of the input buffer, the old data are considered
* consumed
* This routine handle the I18N transcoding to internal UTF-8
*
* Returns the number of chars read and stored in the buffer, or -1
* in case of error.
*/
int
return(0);
else
return(-1);
}
#ifdef LIBXML_OUTPUT_ENABLED
/**
* xmlOutputBufferWrite:
* @out: a buffered parser output
* @len: the size in bytes of the array.
* @buf: an char array
*
* Write the content of the array in the output I/O buffer
* This routine handle the I18N transcoding from internal UTF-8
* The buffer is lossless, i.e. will store in case of partial
* or delayed writes.
*
* Returns the number of chars immediately written, or -1
* in case of error.
*/
int
if (len < 0) return(0);
do {
/*
* first handle encoding stuff.
*/
/*
* Store the data in the incoming raw buffer
*/
}
if (ret != 0)
return(-1);
goto done;
/*
* convert as much as possible to the parser reading buffer.
*/
return(-1);
}
} else {
if (ret != 0)
return(-1);
}
goto done;
if (out->writecallback) {
/*
* second write the stuff to the I/O channel
*/
if (ret >= 0)
} else {
if (ret >= 0)
}
if (ret < 0) {
return(ret);
}
}
} while (len > 0);
done:
#ifdef DEBUG_INPUT
"I/O: wrote %d chars\n", written);
#endif
return(written);
}
/**
* xmlEscapeContent:
* @out: a pointer to an array of bytes to store the result
* @outlen: the length of @out
* @in: a pointer to an array of unescaped UTF-8 bytes
* @inlen: the length of @in
*
* Take a block of UTF-8 chars in and escape them.
* Returns 0 if success, or -1 otherwise
* The value of @inlen after return is the number of octets consumed
* if the return value is positive, else unpredictable.
* The value of @outlen after return is the number of octets consumed.
*/
static int
const unsigned char* inend;
if (*in == '<') {
*out++ = '&';
*out++ = 'l';
*out++ = 't';
*out++ = ';';
} else if (*in == '>') {
*out++ = '&';
*out++ = 'g';
*out++ = 't';
*out++ = ';';
} else if (*in == '&') {
*out++ = '&';
*out++ = 'a';
*out++ = 'm';
*out++ = 'p';
*out++ = ';';
} else if (*in == '\r') {
*out++ = '&';
*out++ = '#';
*out++ = '1';
*out++ = '3';
*out++ = ';';
} else {
}
++in;
}
return(0);
}
/**
* xmlOutputBufferWriteEscape:
* @out: a buffered parser output
* @str: a zero terminated UTF-8 string
* @escaping: an optional escaping function (or NULL)
*
* Write the content of the string in the output I/O buffer
* This routine escapes the caracters and then handle the I18N
* transcoding from internal UTF-8
* The buffer is lossless, i.e. will store in case of partial
* or delayed writes.
*
* Returns the number of chars immediately written, or -1
* in case of error.
*/
int
if (len < 0) return(0);
do {
/*
* how many bytes to consume and how many bytes to store.
*/
/*
* first handle encoding stuff.
*/
/*
* Store the data in the incoming raw buffer
*/
}
return(-1);
goto done;
/*
* convert as much as possible to the output buffer.
*/
return(-1);
}
} else {
return(-1);
}
goto done;
if (out->writecallback) {
/*
* second write the stuff to the I/O channel
*/
if (ret >= 0)
} else {
if (ret >= 0)
}
if (ret < 0) {
return(ret);
}
}
done:
#ifdef DEBUG_INPUT
"I/O: wrote %d chars\n", written);
#endif
return(written);
}
/**
* xmlOutputBufferWriteString:
* @out: a buffered parser output
* @str: a zero terminated C string
*
* Write the content of the string in the output I/O buffer
* This routine handle the I18N transcoding from internal UTF-8
* The buffer is lossless, i.e. will store in case of partial
* or delayed writes.
*
* Returns the number of chars immediately written, or -1
* in case of error.
*/
int
int len;
return(-1);
if (len > 0)
return(len);
}
/**
* xmlOutputBufferFlush:
* @out: a buffered output
*
* flushes the output I/O channel
*
* Returns the number of byte written or -1 in case of error.
*/
int
/*
* first handle encoding stuff.
*/
/*
* convert as much as possible to the parser reading buffer.
*/
if (nbchars < 0) {
return(-1);
}
}
/*
* second flush the stuff to the I/O channel
*/
if (ret >= 0)
if (ret >= 0)
}
if (ret < 0) {
return(ret);
}
#ifdef DEBUG_INPUT
"I/O: flushed %d chars\n", ret);
#endif
return(ret);
}
#endif /* LIBXML_OUTPUT_ENABLED */
/**
* xmlParserGetDirectory:
* @filename: the path to a file
*
* lookup the directory for that file
*
* Returns a new allocated string containing the directory, or NULL.
*/
char *
char *cur;
#ifdef _WIN32_WCE /* easy way by now ... wince does not have dirs! */
return NULL;
#endif
if (xmlInputCallbackInitialized == 0)
#if defined(WIN32) && !defined(__CYGWIN__)
#else
#endif
dir[1023] = 0;
if (IS_XMLPGD_SEP(*cur)) break;
cur --;
}
if (IS_XMLPGD_SEP(*cur)) {
else *cur = 0;
} else {
dir[1023] = 0;
}
}
return(ret);
}
/****************************************************************
* *
* External entities loading *
* *
****************************************************************/
/**
* xmlCheckHTTPInput:
* @ctxt: an XML parser context
* @ret: an XML parser input
*
* Check an input in case it was created from an HTTP stream, in that
* case it will handle encoding and update of the base URL in case of
* redirection. It also checks for HTTP errors in which case the input
* is cleanly freed up and an appropriate error is raised in context
*
* Returns the input or NULL in case of HTTP error.
*/
#ifdef LIBXML_HTTP_ENABLED
const char *encoding;
const char *redir;
const char *mime;
int code;
if (code >= 400) {
/* fatal error */
else
} else {
} else {
"Unknown encoding %s",
}
}
#if 0
#endif
}
}
}
}
}
#endif
return(ret);
}
const char *path;
return(0);
#else
#endif
#else
#endif
} else
return xmlCheckFilename(path);
}
#ifdef LIBXML_CATALOG_ENABLED
/**
* xmlResolveResourceFromCatalog:
* @URL: the URL for the entity to load
* @ID: the System ID for the entity to load
* @ctxt: the context in which the entity is called or NULL
*
* Resolves the URL and ID against the appropriate catalog.
* This function is used by xmlDefaultExternalEntityLoader and
* xmlNoNetExternalEntityLoader.
*
* Returns a new allocated URL, or NULL.
*/
static xmlChar *
/*
* If the resource doesn't exists as a file,
* try to load it from the resource pointed in the catalogs
*/
/*
* Do a local lookup
*/
((pref == XML_CATA_ALLOW_ALL) ||
(pref == XML_CATA_ALLOW_DOCUMENT))) {
}
/*
* Try a global lookup
*/
((pref == XML_CATA_ALLOW_ALL) ||
(pref == XML_CATA_ALLOW_GLOBAL))) {
}
/*
* TODO: do an URI lookup on the reference
*/
((pref == XML_CATA_ALLOW_ALL) ||
(pref == XML_CATA_ALLOW_DOCUMENT))) {
}
((pref == XML_CATA_ALLOW_ALL) ||
(pref == XML_CATA_ALLOW_GLOBAL))) {
}
}
}
}
return resource;
}
#endif
/**
* xmlDefaultExternalEntityLoader:
* @URL: the URL for the entity to load
* @ID: the System ID for the entity to load
* @ctxt: the context in which the entity is called or NULL
*
* By default we don't load external entitites, yet.
*
* Returns a new allocated xmlParserInputPtr, or NULL.
*/
static xmlParserInputPtr
{
#ifdef DEBUG_EXTERNAL_ENTITIES
"xmlDefaultExternalEntityLoader(%s, xxx)\n", URL);
#endif
return(ret);
}
#ifdef LIBXML_CATALOG_ENABLED
#endif
ID = "NULL";
return (NULL);
}
return (ret);
}
/**
* xmlSetExternalEntityLoader:
* @f: the new entity resolver function
*
* Changes the defaultexternal entity resolver function for the application
*/
void
}
/**
* xmlGetExternalEntityLoader:
*
* Get the default external entity resolver function for the application
*
* Returns the xmlExternalEntityLoader function pointer
*/
xmlGetExternalEntityLoader(void) {
return(xmlCurrentExternalEntityLoader);
}
/**
* xmlLoadExternalEntity:
* @URL: the URL for the entity to load
* @ID: the Public ID for the entity to load
* @ctxt: the context in which the entity is called or NULL
*
* Load an external entity, note that the use of this function for
* unparsed entities may generate problems
*
* Returns the xmlParserInputPtr or NULL
*/
char *canonicFilename;
if (canonicFilename == NULL) {
xmlIOErrMemory("building canonical path\n");
return(NULL);
}
return(ret);
}
}
/************************************************************************
* *
* Disabling Network access *
* *
************************************************************************/
/**
* xmlNoNetExternalEntityLoader:
* @URL: the URL for the entity to load
* @ID: the System ID for the entity to load
* @ctxt: the context in which the entity is called or NULL
*
* A specific entity loader disabling network accesses, though still
* allowing local catalog accesses for resolution.
*
* Returns a new allocated xmlParserInputPtr, or NULL.
*/
#ifdef LIBXML_CATALOG_ENABLED
#endif
return(NULL);
}
}
return(input);
}
#define bottom_xmlIO
#include "elfgcchack.h"