## 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        xmlCleanupOutputCallbacks       (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 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        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 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 */
    };

### 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 */
    };

### xmlCleanupInputCallbacks ()

    void        xmlCleanupInputCallbacks        (void);

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

### xmlCleanupOutputCallbacks ()

    void        xmlCleanupOutputCallbacks       (void);

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

### 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

### 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

### 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.

### 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