xmlIO

xmlIO —

Synopsis




int         (*xmlInputMatchCallback)        (char const *filename);
void*       (*xmlInputOpenCallback)         (char const *filename);
int         (*xmlInputReadCallback)         (void *context,
                                             char *buffer,
                                             int len);
int         (*xmlInputCloseCallback)        (void *context);
int         (*xmlOutputMatchCallback)       (char const *filename);
void*       (*xmlOutputOpenCallback)        (char const *filename);
int         (*xmlOutputWriteCallback)       (void *context,
                                             const char *buffer,
                                             int len);
int         (*xmlOutputCloseCallback)       (void *context);
struct      xmlParserInputBuffer;
struct      xmlOutputBuffer;
void        xmlCleanupInputCallbacks        (void);
void        xmlRegisterDefaultInputCallbacks
                                            (void);
xmlParserInputBufferPtr xmlAllocParserInputBuffer
                                            (xmlCharEncoding enc);
xmlParserInputBufferPtr xmlParserInputBufferCreateFilename
                                            (const char *URI,
                                             xmlCharEncoding enc);
xmlParserInputBufferPtr xmlParserInputBufferCreateFile
                                            (FILE *file,
                                             xmlCharEncoding enc);
xmlParserInputBufferPtr xmlParserInputBufferCreateFd
                                            (int fd,
                                             xmlCharEncoding enc);
xmlParserInputBufferPtr xmlParserInputBufferCreateMem
                                            (const char *mem,
                                             int size,
                                             xmlCharEncoding enc);
xmlParserInputBufferPtr xmlParserInputBufferCreateStatic
                                            (const char *mem,
                                             int size,
                                             xmlCharEncoding enc);
xmlParserInputBufferPtr xmlParserInputBufferCreateIO
                                            (xmlInputReadCallback ioread,
                                             xmlInputCloseCallback ioclose,
                                             void *ioctx,
                                             xmlCharEncoding enc);
int         xmlParserInputBufferRead        (xmlParserInputBufferPtr in,
                                             int len);
int         xmlParserInputBufferGrow        (xmlParserInputBufferPtr in,
                                             int len);
int         xmlParserInputBufferPush        (xmlParserInputBufferPtr in,
                                             int len,
                                             const char *buf);
void        xmlFreeParserInputBuffer        (xmlParserInputBufferPtr in);
char*       xmlParserGetDirectory           (const char *filename);
int         xmlRegisterInputCallbacks       (xmlInputMatchCallback matchFunc,
                                             xmlInputOpenCallback openFunc,
                                             xmlInputReadCallback readFunc,
                                             xmlInputCloseCallback closeFunc);
void        xmlCleanupOutputCallbacks       (void);
void        xmlRegisterDefaultOutputCallbacks
                                            (void);
xmlOutputBufferPtr xmlAllocOutputBuffer     (xmlCharEncodingHandlerPtr encoder);
xmlOutputBufferPtr xmlOutputBufferCreateFilename
                                            (const char *URI,
                                             xmlCharEncodingHandlerPtr encoder,
                                             int compression);
xmlOutputBufferPtr xmlOutputBufferCreateFile
                                            (FILE *file,
                                             xmlCharEncodingHandlerPtr encoder);
xmlOutputBufferPtr xmlOutputBufferCreateFd  (int fd,
                                             xmlCharEncodingHandlerPtr encoder);
xmlOutputBufferPtr xmlOutputBufferCreateIO  (xmlOutputWriteCallback iowrite,
                                             xmlOutputCloseCallback ioclose,
                                             void *ioctx,
                                             xmlCharEncodingHandlerPtr encoder);
int         xmlOutputBufferWrite            (xmlOutputBufferPtr out,
                                             int len,
                                             const char *buf);
int         xmlOutputBufferWriteString      (xmlOutputBufferPtr out,
                                             const char *str);
int         xmlOutputBufferFlush            (xmlOutputBufferPtr out);
int         xmlOutputBufferClose            (xmlOutputBufferPtr out);
int         xmlRegisterOutputCallbacks      (xmlOutputMatchCallback matchFunc,
                                             xmlOutputOpenCallback openFunc,
                                             xmlOutputWriteCallback writeFunc,
                                             xmlOutputCloseCallback closeFunc);
void*       xmlIOHTTPOpenW                  (const char *post_uri,
                                             int compression);
void        xmlRegisterHTTPPostCallbacks    (void);
xmlParserInputPtr xmlCheckHTTPInput         (xmlParserCtxtPtr ctxt,
                                             xmlParserInputPtr ret);
xmlParserInputPtr xmlNoNetExternalEntityLoader
                                            (const char *URL,
                                             const char *ID,
                                             xmlParserCtxtPtr ctxt);
xmlChar*    xmlNormalizeWindowsPath         (const xmlChar *path);
int         xmlCheckFilename                (const char *path);
int         xmlFileMatch                    (const char *filename);
void*       xmlFileOpen                     (const char *filename);
int         xmlFileRead                     (void *context,
                                             char *buffer,
                                             int len);
int         xmlFileClose                    (void *context);
int         xmlIOHTTPMatch                  (const char *filename);
void*       xmlIOHTTPOpen                   (const char *filename);
int         xmlIOHTTPRead                   (void *context,
                                             char *buffer,
                                             int len);
int         xmlIOHTTPClose                  (void *context);
int         xmlIOFTPMatch                   (const char *filename);
void*       xmlIOFTPOpen                    (const char *filename);
int         xmlIOFTPRead                    (void *context,
                                             char *buffer,
                                             int len);
int         xmlIOFTPClose                   (void *context);

Description

Details

xmlInputMatchCallback ()

int         (*xmlInputMatchCallback)        (char const *filename);

Callback used in the I/O Input API to detect if the current handler can provide input fonctionnalities for this resource.

filename: the filename or URI
Returns :1 if yes and 0 if another Input module should be used

xmlInputOpenCallback ()

void*       (*xmlInputOpenCallback)         (char const *filename);

Callback used in the I/O Input API to open the resource

filename: the filename or URI

xmlInputReadCallback ()

int         (*xmlInputReadCallback)         (void *context,
                                             char *buffer,
                                             int len);

Callback used in the I/O Input API to read the resource

context: an Input context
buffer: the buffer to store data read
len: the length of the buffer in bytes
Returns :the number of bytes read or -1 in case of error

xmlInputCloseCallback ()

int         (*xmlInputCloseCallback)        (void *context);

Callback used in the I/O Input API to close the resource

context: an Input context
Returns :0 or -1 in case of error

xmlOutputMatchCallback ()

int         (*xmlOutputMatchCallback)       (char const *filename);

Callback used in the I/O Output API to detect if the current handler can provide output fonctionnalities for this resource.

filename: the filename or URI
Returns :1 if yes and 0 if another Output module should be used

xmlOutputOpenCallback ()

void*       (*xmlOutputOpenCallback)        (char const *filename);

Callback used in the I/O Output API to open the resource

filename: the filename or URI

xmlOutputWriteCallback ()

int         (*xmlOutputWriteCallback)       (void *context,
                                             const char *buffer,
                                             int len);

Callback used in the I/O Output API to write to the resource

context: an Output context
buffer: the buffer of data to write
len: the length of the buffer in bytes
Returns :the number of bytes written or -1 in case of error

xmlOutputCloseCallback ()

int         (*xmlOutputCloseCallback)       (void *context);

Callback used in the I/O Output API to close the resource

context: an Output context
Returns :0 or -1 in case of error

struct xmlParserInputBuffer

struct xmlParserInputBuffer {

    void*                  context;
    xmlInputReadCallback   readcallback;
    xmlInputCloseCallback  closecallback;
    
    xmlCharEncodingHandlerPtr encoder; /* I18N conversions to UTF-8 */
    
    xmlBufferPtr buffer;    /* Local buffer encoded in UTF-8 */
    xmlBufferPtr raw;       /* if encoder != NULL buffer for raw input */
    int	compressed;	    /* -1=unknown, 0=not compressed, 1=compressed */
    int error;
};


struct xmlOutputBuffer

struct xmlOutputBuffer {

    void*                   context;
    xmlOutputWriteCallback  writecallback;
    xmlOutputCloseCallback  closecallback;
    
    xmlCharEncodingHandlerPtr encoder; /* I18N conversions to UTF-8 */
    
    xmlBufferPtr buffer;    /* Local buffer encoded in UTF-8 or ISOLatin */
    xmlBufferPtr conv;      /* if encoder != NULL buffer for output */
    int written;            /* total number of byte written */
    int error;
};


xmlCleanupInputCallbacks ()

void        xmlCleanupInputCallbacks        (void);

clears the entire input callback table. this includes the compiled-in I/O.


xmlRegisterDefaultInputCallbacks ()

void        xmlRegisterDefaultInputCallbacks
                                            (void);

Registers the default compiled-in I/O handlers.


xmlAllocParserInputBuffer ()

xmlParserInputBufferPtr xmlAllocParserInputBuffer
                                            (xmlCharEncoding enc);

Create a buffered parser input for progressive parsing

enc: the charset encoding if known
Returns :the new parser input or NULL

xmlParserInputBufferCreateFilename ()

xmlParserInputBufferPtr xmlParserInputBufferCreateFilename
                                            (const char *URI,
                                             xmlCharEncoding enc);

Create a buffered parser input for the progressive parsing of a file If filename is "-' then we use stdin as the input. Automatic support for ZLIB/Compress compressed document is provided by default if found at compile-time. Do an encoding check if enc == XML_CHAR_ENCODING_NONE

URI: a C string containing the URI or filename
enc: the charset encoding if known
Returns :the new parser input or NULL

xmlParserInputBufferCreateFile ()

xmlParserInputBufferPtr xmlParserInputBufferCreateFile
                                            (FILE *file,
                                             xmlCharEncoding enc);

Create a buffered parser input for the progressive parsing of a FILE * buffered C I/O

file: a FILE*
enc: the charset encoding if known
Returns :the new parser input or NULL

xmlParserInputBufferCreateFd ()

xmlParserInputBufferPtr xmlParserInputBufferCreateFd
                                            (int fd,
                                             xmlCharEncoding enc);

Create a buffered parser input for the progressive parsing for the input from a file descriptor

fd: a file descriptor number
enc: the charset encoding if known
Returns :the new parser input or NULL

xmlParserInputBufferCreateMem ()

xmlParserInputBufferPtr xmlParserInputBufferCreateMem
                                            (const char *mem,
                                             int size,
                                             xmlCharEncoding enc);

Create a buffered parser input for the progressive parsing for the input from a memory area.

mem: the memory input
size: the length of the memory block
enc: the charset encoding if known
Returns :the new parser input or NULL

xmlParserInputBufferCreateStatic ()

xmlParserInputBufferPtr xmlParserInputBufferCreateStatic
                                            (const char *mem,
                                             int size,
                                             xmlCharEncoding enc);

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.

mem: the memory input
size: the length of the memory block
enc: the charset encoding if known
Returns :the new parser input or NULL

xmlParserInputBufferCreateIO ()

xmlParserInputBufferPtr xmlParserInputBufferCreateIO
                                            (xmlInputReadCallback ioread,
                                             xmlInputCloseCallback ioclose,
                                             void *ioctx,
                                             xmlCharEncoding enc);

Create a buffered parser input for the progressive parsing for the input from an I/O handler

ioread: an I/O read function
ioclose: an I/O close function
ioctx: an I/O handler
enc: the charset encoding if known
Returns :the new parser input or NULL

xmlParserInputBufferRead ()

int         xmlParserInputBufferRead        (xmlParserInputBufferPtr in,
                                             int len);

Refresh the content of the input buffer, the old data are considered consumed This routine handle the I18N transcoding to internal UTF-8

in: a buffered parser input
len: indicative value of the amount of chars to read
Returns :the number of chars read and stored in the buffer, or -1 in case of error.

xmlParserInputBufferGrow ()

int         xmlParserInputBufferGrow        (xmlParserInputBufferPtr in,
                                             int len);

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

in: a buffered parser input
len: indicative value of the amount of chars to read
Returns :the number of chars read and stored in the buffer, or -1 in case of error.

xmlParserInputBufferPush ()

int         xmlParserInputBufferPush        (xmlParserInputBufferPtr in,
                                             int len,
                                             const char *buf);

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.

in: a buffered parser input
len: the size in bytes of the array.
buf: an char array
Returns :the number of chars read and stored in the buffer, or -1 in case of error.

xmlFreeParserInputBuffer ()

void        xmlFreeParserInputBuffer        (xmlParserInputBufferPtr in);

Free up the memory used by a buffered parser input

in: a buffered parser input

xmlParserGetDirectory ()

char*       xmlParserGetDirectory           (const char *filename);

lookup the directory for that file

filename: the path to a file
Returns :a new allocated string containing the directory, or NULL.

xmlRegisterInputCallbacks ()

int         xmlRegisterInputCallbacks       (xmlInputMatchCallback matchFunc,
                                             xmlInputOpenCallback openFunc,
                                             xmlInputReadCallback readFunc,
                                             xmlInputCloseCallback closeFunc);

Register a new set of I/O callback for handling parser input.

matchFunc: the xmlInputMatchCallback
openFunc: the xmlInputOpenCallback
readFunc: the xmlInputReadCallback
closeFunc: the xmlInputCloseCallback
Returns :the registered handler number or -1 in case of error

xmlCleanupOutputCallbacks ()

void        xmlCleanupOutputCallbacks       (void);

clears the entire output callback table. this includes the compiled-in I/O callbacks.


xmlRegisterDefaultOutputCallbacks ()

void        xmlRegisterDefaultOutputCallbacks
                                            (void);

Registers the default compiled-in I/O handlers.


xmlAllocOutputBuffer ()

xmlOutputBufferPtr xmlAllocOutputBuffer     (xmlCharEncodingHandlerPtr encoder);

Create a buffered parser output

encoder: the encoding converter or NULL
Returns :the new parser output or NULL

xmlOutputBufferCreateFilename ()

xmlOutputBufferPtr xmlOutputBufferCreateFilename
                                            (const char *URI,
                                             xmlCharEncodingHandlerPtr encoder,
                                             int compression);

Create a buffered output for the progressive saving of a file If filename is "-' then we use stdout as the output. Automatic support for ZLIB/Compress compressed document is provided by default if found at compile-time. TODO: currently if compression is set, the library only support writing to a local file.

URI: a C string containing the URI or filename
encoder: the encoding converter or NULL
compression: the compression ration (0 none, 9 max).
Returns :the new output or NULL

xmlOutputBufferCreateFile ()

xmlOutputBufferPtr xmlOutputBufferCreateFile
                                            (FILE *file,
                                             xmlCharEncodingHandlerPtr encoder);

Create a buffered output for the progressive saving to a FILE * buffered C I/O

file: a FILE*
encoder: the encoding converter or NULL
Returns :the new parser output or NULL

xmlOutputBufferCreateFd ()

xmlOutputBufferPtr xmlOutputBufferCreateFd  (int fd,
                                             xmlCharEncodingHandlerPtr encoder);

Create a buffered output for the progressive saving to a file descriptor

fd: a file descriptor number
encoder: the encoding converter or NULL
Returns :the new parser output or NULL

xmlOutputBufferCreateIO ()

xmlOutputBufferPtr xmlOutputBufferCreateIO  (xmlOutputWriteCallback iowrite,
                                             xmlOutputCloseCallback ioclose,
                                             void *ioctx,
                                             xmlCharEncodingHandlerPtr encoder);

Create a buffered output for the progressive saving to an I/O handler

iowrite: an I/O write function
ioclose: an I/O close function
ioctx: an I/O handler
encoder: the charset encoding if known
Returns :the new parser output or NULL

xmlOutputBufferWrite ()

int         xmlOutputBufferWrite            (xmlOutputBufferPtr out,
                                             int len,
                                             const char *buf);

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.

out: a buffered parser output
len: the size in bytes of the array.
buf: an char array
Returns :the number of chars immediately written, or -1 in case of error.

xmlOutputBufferWriteString ()

int         xmlOutputBufferWriteString      (xmlOutputBufferPtr out,
                                             const char *str);

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.

out: a buffered parser output
str: a zero terminated C string
Returns :the number of chars immediately written, or -1 in case of error.

xmlOutputBufferFlush ()

int         xmlOutputBufferFlush            (xmlOutputBufferPtr out);

flushes the output I/O channel

out: a buffered output
Returns :the number of byte written or -1 in case of error.

xmlOutputBufferClose ()

int         xmlOutputBufferClose            (xmlOutputBufferPtr out);

flushes and close the output I/O channel and free up all the associated resources

out: a buffered output
Returns :the number of byte written or -1 in case of error.

xmlRegisterOutputCallbacks ()

int         xmlRegisterOutputCallbacks      (xmlOutputMatchCallback matchFunc,
                                             xmlOutputOpenCallback openFunc,
                                             xmlOutputWriteCallback writeFunc,
                                             xmlOutputCloseCallback closeFunc);

Register a new set of I/O callback for handling output.

matchFunc: the xmlOutputMatchCallback
openFunc: the xmlOutputOpenCallback
writeFunc: the xmlOutputWriteCallback
closeFunc: the xmlOutputCloseCallback
Returns :the registered handler number or -1 in case of error

xmlIOHTTPOpenW ()

void*       xmlIOHTTPOpenW                  (const char *post_uri,
                                             int compression);

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.

post_uri: The destination URI for the document
compression: The compression desired for the document.

xmlRegisterHTTPPostCallbacks ()

void        xmlRegisterHTTPPostCallbacks    (void);

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.


xmlCheckHTTPInput ()

xmlParserInputPtr xmlCheckHTTPInput         (xmlParserCtxtPtr ctxt,
                                             xmlParserInputPtr ret);

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

ctxt: an XML parser context
ret: an XML parser input
Returns :the input or NULL in case of HTTP error.

xmlNoNetExternalEntityLoader ()

xmlParserInputPtr xmlNoNetExternalEntityLoader
                                            (const char *URL,
                                             const char *ID,
                                             xmlParserCtxtPtr ctxt);

A specific entity loader disabling network accesses, though still allowing local catalog accesses for resolution.

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
Returns :a new allocated xmlParserInputPtr, or NULL.

xmlNormalizeWindowsPath ()

xmlChar*    xmlNormalizeWindowsPath         (const xmlChar *path);

This function is obsolete. Please see xmlURIFromPath in uri.c for a better solution.

path: the input file path
Returns :a canonicalized version of the path

xmlCheckFilename ()

int         xmlCheckFilename                (const char *path);

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,

path: the path to check
Returns :2. otherwise returns 1.

xmlFileMatch ()

int         xmlFileMatch                    (const char *filename);

input from FILE *

filename: the URI for matching
Returns :1 if matches, 0 otherwise

xmlFileOpen ()

void*       xmlFileOpen                     (const char *filename);

Wrapper around xmlFileOpen_real that try it with an unescaped version of filename, if this fails fallback to filename

filename: the URI for matching

xmlFileRead ()

int         xmlFileRead                     (void *context,
                                             char *buffer,
                                             int len);

Read len bytes to buffer from the I/O channel.

context: the I/O context
buffer: where to drop data
len: number of bytes to write
Returns :the number of bytes written

xmlFileClose ()

int         xmlFileClose                    (void *context);

Close an I/O channel

context: the I/O context
Returns :0 or -1 in case of error

xmlIOHTTPMatch ()

int         xmlIOHTTPMatch                  (const char *filename);

check if the URI matches an HTTP one

filename: the URI for matching
Returns :1 if matches, 0 otherwise

xmlIOHTTPOpen ()

void*       xmlIOHTTPOpen                   (const char *filename);

open an HTTP I/O channel

filename: the URI for matching

xmlIOHTTPRead ()

int         xmlIOHTTPRead                   (void *context,
                                             char *buffer,
                                             int len);

Read len bytes to buffer from the I/O channel.

context: the I/O context
buffer: where to drop data
len: number of bytes to write
Returns :the number of bytes written

xmlIOHTTPClose ()

int         xmlIOHTTPClose                  (void *context);

Close an HTTP I/O channel

context: the I/O context
Returns :0

xmlIOFTPMatch ()

int         xmlIOFTPMatch                   (const char *filename);

check if the URI matches an FTP one

filename: the URI for matching
Returns :1 if matches, 0 otherwise

xmlIOFTPOpen ()

void*       xmlIOFTPOpen                    (const char *filename);

open an FTP I/O channel

filename: the URI for matching

xmlIOFTPRead ()

int         xmlIOFTPRead                    (void *context,
                                             char *buffer,
                                             int len);

Read len bytes to buffer from the I/O channel.

context: the I/O context
buffer: where to drop data
len: number of bytes to write
Returns :the number of bytes written

xmlIOFTPClose ()

int         xmlIOFTPClose                   (void *context);

Close an FTP I/O channel

context: the I/O context
Returns :0