#define IN_LIBXML
#include "libxml.h"
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/stat.h>
#if defined(_WIN32)
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <io.h>
#include <direct.h>
#else
#include <unistd.h>
#endif
#ifdef LIBXML_ZLIB_ENABLED
#include <zlib.h>
#endif
#include <libxml/xmlIO.h>
#include <libxml/xmlmemory.h>
#include <libxml/uri.h>
#include <libxml/parserInternals.h>
#include <libxml/xmlerror.h>
#ifdef LIBXML_CATALOG_ENABLED
#include <libxml/catalog.h>
#endif
#include "private/buf.h"
#include "private/enc.h"
#include "private/error.h"
#include "private/io.h"
#ifndef SIZE_MAX
#define SIZE_MAX ((size_t) -1)
#endif
#define MINLEN 4000
#ifndef STDOUT_FILENO
#define STDOUT_FILENO 1
#endif
#ifndef S_ISDIR
# ifdef _S_ISDIR
# define S_ISDIR(x) _S_ISDIR(x)
# elif defined(S_IFDIR)
# ifdef S_IFMT
# define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
# elif defined(_S_IFMT)
# define S_ISDIR(m) (((m) & _S_IFMT) == S_IFDIR)
# endif
# endif
#endif
typedef struct _xmlInputCallback {
xmlInputMatchCallback matchcallback;
xmlInputOpenCallback opencallback;
xmlInputReadCallback readcallback;
xmlInputCloseCallback closecallback;
} xmlInputCallback;
static int
xmlIODefaultMatch(const char *filename);
#define MAX_INPUT_CALLBACK 10
static xmlInputCallback xmlInputCallbackTable[MAX_INPUT_CALLBACK];
static int xmlInputCallbackNr;
#ifdef LIBXML_OUTPUT_ENABLED
typedef struct _xmlOutputCallback {
xmlOutputMatchCallback matchcallback;
xmlOutputOpenCallback opencallback;
xmlOutputWriteCallback writecallback;
xmlOutputCloseCallback closecallback;
} xmlOutputCallback;
#define MAX_OUTPUT_CALLBACK 10
static xmlOutputCallback xmlOutputCallbackTable[MAX_OUTPUT_CALLBACK];
static int xmlOutputCallbackNr;
#endif
static int
xmlSerializeHexCharRef(char *buf, int val) {
char *out = buf;
int shift = 0, bits;
*out++ = '&';
*out++ = '#';
*out++ = 'x';
bits = val;
if (bits & 0xFF0000) {
shift = 16;
bits &= 0xFF0000;
} else if (bits & 0x00FF00) {
shift = 8;
bits &= 0x00FF00;
}
if (bits & 0xF0F0F0) {
shift += 4;
}
do {
int d = (val >> shift) & 0x0F;
if (d < 10)
*out++ = '0' + d;
else
*out++ = 'A' + (d - 10);
shift -= 4;
} while (shift >= 0);
*out++ = ';';
return(out - buf);
}
#include "codegen/escape.inc"
xmlChar *
xmlEscapeText(const xmlChar *string, int flags) {
const xmlChar *cur;
xmlChar *buffer;
xmlChar *out;
const signed char *tab;
size_t size = 50;
#ifdef LIBXML_HTML_ENABLED
if (flags & XML_ESCAPE_HTML) {
if (flags & XML_ESCAPE_ATTR)
tab = htmlEscapeTabAttr;
else
tab = htmlEscapeTab;
}
else
#endif
{
if (flags & XML_ESCAPE_QUOT)
tab = xmlEscapeTabQuot;
else if (flags & XML_ESCAPE_ATTR)
tab = xmlEscapeTabAttr;
else
tab = xmlEscapeTab;
}
buffer = xmlMalloc(size + 1);
if (buffer == NULL)
return(NULL);
out = buffer;
cur = string;
while (*cur != 0) {
char tempBuf[12];
const xmlChar *base;
const char *repl;
size_t used;
size_t replSize;
size_t unescapedSize;
size_t totalSize;
int c;
int offset;
base = cur;
offset = -1;
while (1) {
c = *cur;
if (c < 0x80) {
offset = tab[c];
if (offset >= 0)
break;
} else if (flags & XML_ESCAPE_NON_ASCII) {
break;
}
cur += 1;
}
unescapedSize = cur - base;
if (offset >= 0) {
if (c == 0) {
replSize = 0;
repl = "";
} else {
replSize = xmlEscapeContent[offset],
repl = &xmlEscapeContent[offset+1];
cur += 1;
}
} else {
int val = 0, len = 4;
val = xmlGetUTF8Char(cur, &len);
if (val < 0) {
val = 0xFFFD;
cur += 1;
} else {
if ((val == 0xFFFE) || (val == 0xFFFF))
val = 0xFFFD;
cur += len;
}
replSize = xmlSerializeHexCharRef(tempBuf, val);
repl = tempBuf;
}
used = out - buffer;
totalSize = unescapedSize + replSize;
if (totalSize > size - used) {
xmlChar *tmp;
size_t newSize;
if ((size > (SIZE_MAX - 1) / 2) ||
(totalSize > (SIZE_MAX - 1) / 2 - size)) {
xmlFree(buffer);
return(NULL);
}
newSize = size + totalSize;
if (*cur != 0)
newSize *= 2;
tmp = xmlRealloc(buffer, newSize + 1);
if (tmp == NULL) {
xmlFree(buffer);
return(NULL);
}
buffer = tmp;
size = newSize;
out = buffer + used;
}
memcpy(out, base, unescapedSize);
out += unescapedSize;
memcpy(out, repl, replSize);
out += replSize;
if (c == 0)
break;
base = cur;
}
*out = 0;
return(buffer);
}
#ifdef LIBXML_OUTPUT_ENABLED
void
xmlSerializeText(xmlOutputBuffer *buf, const xmlChar *string, size_t maxSize,
unsigned flags) {
const xmlChar *cur;
const signed char *tab;
if (string == NULL)
return;
#ifdef LIBXML_HTML_ENABLED
if (flags & XML_ESCAPE_HTML) {
if (flags & XML_ESCAPE_ATTR)
tab = htmlEscapeTabAttr;
else
tab = htmlEscapeTab;
}
else
#endif
{
if (flags & XML_ESCAPE_QUOT)
tab = xmlEscapeTabQuot;
else if (flags & XML_ESCAPE_ATTR)
tab = xmlEscapeTabAttr;
else
tab = xmlEscapeTab;
}
cur = string;
while (1) {
const xmlChar *base;
int c;
int offset;
base = cur;
offset = -1;
while (1) {
if ((size_t) (cur - string) >= maxSize)
break;
c = (unsigned char) *cur;
if (c < 0x80) {
offset = tab[c];
if (offset >= 0)
break;
} else if (flags & XML_ESCAPE_NON_ASCII) {
break;
}
cur += 1;
}
if (cur > base)
xmlOutputBufferWrite(buf, cur - base, (char *) base);
if ((size_t) (cur - string) >= maxSize)
break;
if (offset >= 0) {
if (c == 0)
break;
xmlOutputBufferWrite(buf, xmlEscapeContent[offset],
&xmlEscapeContent[offset+1]);
cur += 1;
} else {
char tempBuf[12];
int tempSize;
int val = 0, len = 4;
val = xmlGetUTF8Char(cur, &len);
if (val < 0) {
val = 0xFFFD;
cur += 1;
} else {
if ((val == 0xFFFE) || (val == 0xFFFF))
val = 0xFFFD;
cur += len;
}
tempSize = xmlSerializeHexCharRef(tempBuf, val);
xmlOutputBufferWrite(buf, tempSize, tempBuf);
}
}
}
#endif
static int
xmlIOErr(int err)
{
xmlParserErrors code;
switch (err) {
#ifdef EACCES
case EACCES: code = XML_IO_EACCES; break;
#endif
#ifdef EAGAIN
case EAGAIN: code = XML_IO_EAGAIN; break;
#endif
#ifdef EBADF
case EBADF: code = XML_IO_EBADF; break;
#endif
#ifdef EBADMSG
case EBADMSG: code = XML_IO_EBADMSG; break;
#endif
#ifdef EBUSY
case EBUSY: code = XML_IO_EBUSY; break;
#endif
#ifdef ECANCELED
case ECANCELED: code = XML_IO_ECANCELED; break;
#endif
#ifdef ECHILD
case ECHILD: code = XML_IO_ECHILD; break;
#endif
#ifdef EDEADLK
case EDEADLK: code = XML_IO_EDEADLK; break;
#endif
#ifdef EDOM
case EDOM: code = XML_IO_EDOM; break;
#endif
#ifdef EEXIST
case EEXIST: code = XML_IO_EEXIST; break;
#endif
#ifdef EFAULT
case EFAULT: code = XML_IO_EFAULT; break;
#endif
#ifdef EFBIG
case EFBIG: code = XML_IO_EFBIG; break;
#endif
#ifdef EINPROGRESS
case EINPROGRESS: code = XML_IO_EINPROGRESS; break;
#endif
#ifdef EINTR
case EINTR: code = XML_IO_EINTR; break;
#endif
#ifdef EINVAL
case EINVAL: code = XML_IO_EINVAL; break;
#endif
#ifdef EIO
case EIO: code = XML_IO_EIO; break;
#endif
#ifdef EISDIR
case EISDIR: code = XML_IO_EISDIR; break;
#endif
#ifdef EMFILE
case EMFILE: code = XML_IO_EMFILE; break;
#endif
#ifdef EMLINK
case EMLINK: code = XML_IO_EMLINK; break;
#endif
#ifdef EMSGSIZE
case EMSGSIZE: code = XML_IO_EMSGSIZE; break;
#endif
#ifdef ENAMETOOLONG
case ENAMETOOLONG: code = XML_IO_ENAMETOOLONG; break;
#endif
#ifdef ENFILE
case ENFILE: code = XML_IO_ENFILE; break;
#endif
#ifdef ENODEV
case ENODEV: code = XML_IO_ENODEV; break;
#endif
#ifdef ENOENT
case ENOENT: code = XML_IO_ENOENT; break;
#endif
#ifdef ENOEXEC
case ENOEXEC: code = XML_IO_ENOEXEC; break;
#endif
#ifdef ENOLCK
case ENOLCK: code = XML_IO_ENOLCK; break;
#endif
#ifdef ENOMEM
case ENOMEM: code = XML_IO_ENOMEM; break;
#endif
#ifdef ENOSPC
case ENOSPC: code = XML_IO_ENOSPC; break;
#endif
#ifdef ENOSYS
case ENOSYS: code = XML_IO_ENOSYS; break;
#endif
#ifdef ENOTDIR
case ENOTDIR: code = XML_IO_ENOTDIR; break;
#endif
#if defined(ENOTEMPTY) && ENOTEMPTY != EEXIST
case ENOTEMPTY: code = XML_IO_ENOTEMPTY; break;
#endif
#ifdef ENOTSUP
case ENOTSUP: code = XML_IO_ENOTSUP; break;
#endif
#ifdef ENOTTY
case ENOTTY: code = XML_IO_ENOTTY; break;
#endif
#ifdef ENXIO
case ENXIO: code = XML_IO_ENXIO; break;
#endif
#ifdef EPERM
case EPERM: code = XML_IO_EPERM; break;
#endif
#ifdef EPIPE
case EPIPE: code = XML_IO_EPIPE; break;
#endif
#ifdef ERANGE
case ERANGE: code = XML_IO_ERANGE; break;
#endif
#ifdef EROFS
case EROFS: code = XML_IO_EROFS; break;
#endif
#ifdef ESPIPE
case ESPIPE: code = XML_IO_ESPIPE; break;
#endif
#ifdef ESRCH
case ESRCH: code = XML_IO_ESRCH; break;
#endif
#ifdef ETIMEDOUT
case ETIMEDOUT: code = XML_IO_ETIMEDOUT; break;
#endif
#ifdef EXDEV
case EXDEV: code = XML_IO_EXDEV; break;
#endif
#ifdef ENOTSOCK
case ENOTSOCK: code = XML_IO_ENOTSOCK; break;
#endif
#ifdef EISCONN
case EISCONN: code = XML_IO_EISCONN; break;
#endif
#ifdef ECONNREFUSED
case ECONNREFUSED: code = XML_IO_ECONNREFUSED; break;
#endif
#ifdef ENETUNREACH
case ENETUNREACH: code = XML_IO_ENETUNREACH; break;
#endif
#ifdef EADDRINUSE
case EADDRINUSE: code = XML_IO_EADDRINUSE; break;
#endif
#ifdef EALREADY
case EALREADY: code = XML_IO_EALREADY; break;
#endif
#ifdef EAFNOSUPPORT
case EAFNOSUPPORT: code = XML_IO_EAFNOSUPPORT; break;
#endif
default: code = XML_IO_UNKNOWN; break;
}
return(code);
}
#if defined(_WIN32)
static wchar_t *
__xmlIOWin32UTF8ToWChar(const char *u8String)
{
wchar_t *wString = NULL;
int i;
if (u8String) {
int wLen =
MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, u8String,
-1, NULL, 0);
if (wLen) {
wString = xmlMalloc(wLen * sizeof(wchar_t));
if (wString) {
if (MultiByteToWideChar
(CP_UTF8, 0, u8String, -1, wString, wLen) == 0) {
xmlFree(wString);
wString = NULL;
}
}
for (i = 0; wString[i] != 0; i++) {
if (wString[i] == '/')
wString[i] = '\\';
}
}
}
return wString;
}
#endif
xmlChar *
xmlNormalizeWindowsPath(const xmlChar *path)
{
return xmlStrdup(path);
}
int
xmlCheckFilename(const char *path)
{
#if defined(_WIN32)
struct _stat stat_buffer;
#else
struct stat stat_buffer;
#endif
int res;
if (path == NULL)
return(0);
#if defined(_WIN32)
{
wchar_t *wpath;
if ((path[0] == '\\') && (path[1] == '\\') && (path[2] == '?') &&
(path[3] == '\\') )
return 1;
wpath = __xmlIOWin32UTF8ToWChar(path);
if (wpath == NULL)
return(0);
res = _wstat(wpath, &stat_buffer);
xmlFree(wpath);
}
#else
res = stat(path, &stat_buffer);
#endif
if (res < 0)
return 0;
#ifdef S_ISDIR
if (S_ISDIR(stat_buffer.st_mode))
return 2;
#endif
return 1;
}
static int
xmlConvertUriToPath(const char *uri, char **out) {
const char *escaped;
char *unescaped;
*out = NULL;
if (!xmlStrncasecmp(BAD_CAST uri, BAD_CAST "file://localhost/", 17)) {
escaped = &uri[16];
} else if (!xmlStrncasecmp(BAD_CAST uri, BAD_CAST "file:///", 8)) {
escaped = &uri[7];
} else if (!xmlStrncasecmp(BAD_CAST uri, BAD_CAST "file:/", 6)) {
escaped = &uri[5];
} else {
return(1);
}
#ifdef _WIN32
escaped += 1;
#endif
unescaped = xmlURIUnescapeString(escaped, 0, NULL);
if (unescaped == NULL)
return(-1);
*out = unescaped;
return(0);
}
typedef struct {
int fd;
} xmlFdIOCtxt;
static xmlParserErrors
xmlFdOpen(const char *filename, int write, int *out) {
char *fromUri = NULL;
int flags;
int fd;
xmlParserErrors ret;
*out = -1;
if (filename == NULL)
return(XML_ERR_ARGUMENT);
if (xmlConvertUriToPath(filename, &fromUri) < 0)
return(XML_ERR_NO_MEMORY);
if (fromUri != NULL)
filename = fromUri;
#if defined(_WIN32)
{
wchar_t *wpath;
wpath = __xmlIOWin32UTF8ToWChar(filename);
if (wpath == NULL) {
xmlFree(fromUri);
return(XML_ERR_NO_MEMORY);
}
if (write)
flags = _O_WRONLY | _O_CREAT | _O_TRUNC;
else
flags = _O_RDONLY;
fd = _wopen(wpath, flags | _O_BINARY, 0666);
xmlFree(wpath);
}
#else
if (write)
flags = O_WRONLY | O_CREAT | O_TRUNC;
else
flags = O_RDONLY;
fd = open(filename, flags, 0666);
#endif
if (fd < 0) {
if ((errno == ENOENT) || (errno == EINVAL)) {
ret = XML_IO_ENOENT;
} else {
ret = xmlIOErr(errno);
}
} else {
*out = fd;
ret = XML_ERR_OK;
}
xmlFree(fromUri);
return(ret);
}
static int
xmlFdRead(void *context, char *buffer, int len) {
xmlFdIOCtxt *fdctxt = context;
int fd = fdctxt->fd;
int ret = 0;
int bytes;
while (len > 0) {
bytes = read(fd, buffer, len);
if (bytes < 0) {
if (ret > 0)
break;
return(-xmlIOErr(errno));
}
if (bytes == 0)
break;
ret += bytes;
buffer += bytes;
len -= bytes;
}
return(ret);
}
#ifdef LIBXML_OUTPUT_ENABLED
static int
xmlFdWrite(void *context, const char *buffer, int len) {
xmlFdIOCtxt *fdctxt = context;
int fd = fdctxt->fd;
int ret = 0;
int bytes;
while (len > 0) {
bytes = write(fd, buffer, len);
if (bytes < 0)
return(-xmlIOErr(errno));
ret += bytes;
buffer += bytes;
len -= bytes;
}
return(ret);
}
#endif
static int
xmlFdFree(void *context) {
xmlFree(context);
return(XML_ERR_OK);
}
static int
xmlFdClose (void * context) {
xmlFdIOCtxt *fdctxt = context;
int fd = fdctxt->fd;
int ret;
ret = close(fd);
xmlFree(fdctxt);
if (ret < 0)
return(xmlIOErr(errno));
return(XML_ERR_OK);
}
int
xmlFileMatch (const char *filename ATTRIBUTE_UNUSED) {
return(1);
}
static xmlParserErrors
xmlFileOpenSafe(const char *filename, int write, void **out) {
char *fromUri = NULL;
FILE *fd;
xmlParserErrors ret = XML_ERR_OK;
*out = NULL;
if (filename == NULL)
return(XML_ERR_ARGUMENT);
if (xmlConvertUriToPath(filename, &fromUri) < 0)
return(XML_ERR_NO_MEMORY);
if (fromUri != NULL)
filename = fromUri;
#if defined(_WIN32)
{
wchar_t *wpath;
wpath = __xmlIOWin32UTF8ToWChar(filename);
if (wpath == NULL) {
xmlFree(fromUri);
return(XML_ERR_NO_MEMORY);
}
fd = _wfopen(wpath, write ? L"wb" : L"rb");
xmlFree(wpath);
}
#else
fd = fopen(filename, write ? "wb" : "rb");
#endif
if (fd == NULL) {
if ((errno == ENOENT) || (errno == EINVAL)) {
ret = XML_IO_ENOENT;
} else {
ret = xmlIOErr(errno);
}
}
*out = fd;
xmlFree(fromUri);
return(ret);
}
void *
xmlFileOpen(const char *filename) {
void *context;
xmlFileOpenSafe(filename, 0, &context);
return(context);
}
int
xmlFileRead(void * context, char * buffer, int len) {
FILE *file = context;
size_t bytes;
if ((context == NULL) || (buffer == NULL))
return(-1);
errno = 0;
bytes = fread(buffer, 1, len, file);
if ((bytes < (size_t) len) && (ferror(file)))
return(-xmlIOErr(errno));
return(bytes);
}
#ifdef LIBXML_OUTPUT_ENABLED
static int
xmlFileWrite(void *context, const char *buffer, int len) {
FILE *file = context;
size_t bytes;
if ((context == NULL) || (buffer == NULL))
return(-1);
errno = 0;
bytes = fwrite(buffer, 1, len, file);
if (bytes < (size_t) len)
return(-xmlIOErr(errno));
return(len);
}
#endif
static int
xmlFileFlush (void * context) {
FILE *file = context;
if (file == NULL)
return(-1);
if (fflush(file) != 0)
return(xmlIOErr(errno));
return(XML_ERR_OK);
}
int
xmlFileClose (void * context) {
FILE *file = context;
if (context == NULL)
return(-1);
if (file == stdin)
return(0);
if ((file == stdout) || (file == stderr))
return(xmlFileFlush(file));
if (fclose(file) != 0)
return(xmlIOErr(errno));
return(0);
}
#ifdef LIBXML_OUTPUT_ENABLED
static int
xmlBufferWrite (void * context, const char * buffer, int len) {
int ret;
ret = xmlBufferAdd((xmlBufferPtr) context, (const xmlChar *) buffer, len);
if (ret != 0)
return(-XML_ERR_NO_MEMORY);
return(len);
}
#endif
#ifdef LIBXML_ZLIB_ENABLED
static int
xmlGzfileRead (void * context, char * buffer, int len) {
int ret;
ret = gzread((gzFile) context, &buffer[0], len);
if (ret < 0)
return(-XML_IO_UNKNOWN);
return(ret);
}
#ifdef LIBXML_OUTPUT_ENABLED
static int
xmlGzfileWrite (void * context, const char * buffer, int len) {
int ret;
ret = gzwrite((gzFile) context, (char *) &buffer[0], len);
if (ret < 0)
return(-XML_IO_UNKNOWN);
return(ret);
}
#endif
static int
xmlGzfileClose (void * context) {
if (gzclose((gzFile) context) != Z_OK)
return(XML_IO_UNKNOWN);
return(0);
}
#endif
static int
xmlIODefaultMatch(const char *filename ATTRIBUTE_UNUSED) {
return(1);
}
#if defined(LIBXML_ZLIB_ENABLED)
#ifdef _WIN32
typedef __int64 xmlFileOffset;
#else
typedef off_t xmlFileOffset;
#endif
static xmlFileOffset
xmlSeek(int fd, xmlFileOffset offset, int whence) {
#ifdef _WIN32
HANDLE h = (HANDLE) _get_osfhandle(fd);
if (h != INVALID_HANDLE_VALUE && GetFileType(h) != FILE_TYPE_DISK)
return -1;
return _lseeki64(fd, offset, whence);
#else
return lseek(fd, offset, whence);
#endif
}
#endif
xmlParserErrors
xmlInputFromFd(xmlParserInputBuffer *buf, int fd,
xmlParserInputFlags flags) {
xmlFdIOCtxt *fdctxt;
int copy;
(void) flags;
#ifdef LIBXML_ZLIB_ENABLED
if (flags & XML_INPUT_UNZIP) {
gzFile gzStream;
xmlFileOffset pos;
pos = xmlSeek(fd, 0, SEEK_CUR);
copy = dup(fd);
if (copy == -1)
return(xmlIOErr(errno));
gzStream = gzdopen(copy, "rb");
if (gzStream == NULL) {
close(copy);
} else {
int compressed = (gzdirect(gzStream) == 0);
if ((compressed) ||
(pos < 0) ||
(xmlSeek(fd, pos, SEEK_SET) < 0)) {
buf->context = gzStream;
buf->readcallback = xmlGzfileRead;
buf->closecallback = xmlGzfileClose;
buf->compressed = compressed;
return(XML_ERR_OK);
}
xmlGzfileClose(gzStream);
}
}
#endif
copy = dup(fd);
if (copy == -1)
return(xmlIOErr(errno));
fdctxt = xmlMalloc(sizeof(*fdctxt));
if (fdctxt == NULL) {
close(copy);
return(XML_ERR_NO_MEMORY);
}
fdctxt->fd = copy;
buf->context = fdctxt;
buf->readcallback = xmlFdRead;
buf->closecallback = xmlFdClose;
return(XML_ERR_OK);
}
#ifdef LIBXML_OUTPUT_ENABLED
static xmlParserErrors
xmlOutputDefaultOpen(xmlOutputBufferPtr buf, const char *filename,
int compression) {
xmlFdIOCtxt *fdctxt;
int fd;
(void) compression;
if (!strcmp(filename, "-")) {
fd = dup(STDOUT_FILENO);
if (fd < 0)
return(xmlIOErr(errno));
} else {
int ret;
ret = xmlFdOpen(filename, 1, &fd);
if (ret != XML_ERR_OK)
return(ret);
}
#ifdef LIBXML_ZLIB_ENABLED
if ((compression > 0) && (compression <= 9)) {
gzFile gzStream;
char mode[15];
snprintf(mode, sizeof(mode), "wb%d", compression);
gzStream = gzdopen(fd, mode);
if (gzStream == NULL) {
close(fd);
return(XML_IO_UNKNOWN);
}
buf->context = gzStream;
buf->writecallback = xmlGzfileWrite;
buf->closecallback = xmlGzfileClose;
return(XML_ERR_OK);
}
#endif
fdctxt = xmlMalloc(sizeof(*fdctxt));
if (fdctxt == NULL) {
close(fd);
return(XML_ERR_NO_MEMORY);
}
fdctxt->fd = fd;
buf->context = fdctxt;
buf->writecallback = xmlFdWrite;
buf->closecallback = xmlFdClose;
return(XML_ERR_OK);
}
#endif
xmlParserInputBuffer *
xmlAllocParserInputBuffer(xmlCharEncoding enc) {
xmlParserInputBufferPtr ret;
ret = (xmlParserInputBufferPtr) xmlMalloc(sizeof(xmlParserInputBuffer));
if (ret == NULL) {
return(NULL);
}
memset(ret, 0, sizeof(xmlParserInputBuffer));
ret->buffer = xmlBufCreate(XML_IO_BUFFER_SIZE);
if (ret->buffer == NULL) {
xmlFree(ret);
return(NULL);
}
if (enc != XML_CHAR_ENCODING_NONE) {
if (xmlLookupCharEncodingHandler(enc, &ret->encoder) != XML_ERR_OK) {
xmlFreeParserInputBuffer(ret);
return(NULL);
}
}
if (ret->encoder != NULL)
ret->raw = xmlBufCreate(XML_IO_BUFFER_SIZE);
else
ret->raw = NULL;
ret->readcallback = NULL;
ret->closecallback = NULL;
ret->context = NULL;
ret->compressed = -1;
ret->rawconsumed = 0;
return(ret);
}
#ifdef LIBXML_OUTPUT_ENABLED
xmlOutputBuffer *
xmlAllocOutputBuffer(xmlCharEncodingHandler *encoder) {
xmlOutputBufferPtr ret;
ret = (xmlOutputBufferPtr) xmlMalloc(sizeof(xmlOutputBuffer));
if (ret == NULL) {
return(NULL);
}
memset(ret, 0, sizeof(xmlOutputBuffer));
ret->buffer = xmlBufCreate(MINLEN);
if (ret->buffer == NULL) {
xmlFree(ret);
return(NULL);
}
ret->encoder = encoder;
if (encoder != NULL) {
ret->conv = xmlBufCreate(MINLEN);
if (ret->conv == NULL) {
xmlBufFree(ret->buffer);
xmlFree(ret);
return(NULL);
}
xmlCharEncOutput(ret, 1);
} else
ret->conv = NULL;
ret->writecallback = NULL;
ret->closecallback = NULL;
ret->context = NULL;
ret->written = 0;
return(ret);
}
#endif
void
xmlFreeParserInputBuffer(xmlParserInputBuffer *in) {
if (in == NULL) return;
if (in->raw) {
xmlBufFree(in->raw);
in->raw = NULL;
}
if (in->encoder != NULL) {
xmlCharEncCloseFunc(in->encoder);
}
if (in->closecallback != NULL) {
in->closecallback(in->context);
}
if (in->buffer != NULL) {
xmlBufFree(in->buffer);
in->buffer = NULL;
}
xmlFree(in);
}
#ifdef LIBXML_OUTPUT_ENABLED
int
xmlOutputBufferClose(xmlOutputBuffer *out)
{
int ret;
if (out == NULL)
return (-1);
if (out->writecallback != NULL)
xmlOutputBufferFlush(out);
if (out->closecallback != NULL) {
int code = out->closecallback(out->context);
if ((code != XML_ERR_OK) &&
(!xmlIsCatastrophicError(XML_ERR_FATAL, out->error))) {
if (code < 0)
out->error = XML_IO_UNKNOWN;
else
out->error = code;
}
}
if (out->error != XML_ERR_OK)
ret = -out->error;
else
ret = out->written;
if (out->conv) {
xmlBufFree(out->conv);
out->conv = NULL;
}
if (out->encoder != NULL) {
xmlCharEncCloseFunc(out->encoder);
}
if (out->buffer != NULL) {
xmlBufFree(out->buffer);
out->buffer = NULL;
}
xmlFree(out);
return(ret);
}
#endif
xmlParserErrors
xmlParserInputBufferCreateUrl(const char *URI, xmlCharEncoding enc,
xmlParserInputFlags flags,
xmlParserInputBuffer **out) {
xmlParserInputBufferPtr buf;
xmlParserErrors ret;
int i;
xmlInitParser();
*out = NULL;
if (URI == NULL)
return(XML_ERR_ARGUMENT);
buf = xmlAllocParserInputBuffer(enc);
if (buf == NULL)
return(XML_ERR_NO_MEMORY);
ret = XML_IO_ENOENT;
for (i = xmlInputCallbackNr - 1; i >= 0; i--) {
xmlInputCallback *cb = &xmlInputCallbackTable[i];
if (cb->matchcallback == xmlIODefaultMatch) {
int fd;
ret = xmlFdOpen(URI, 0, &fd);
if (ret == XML_ERR_OK) {
ret = xmlInputFromFd(buf, fd, flags);
close(fd);
break;
} else if (ret != XML_IO_ENOENT) {
break;
}
} else if ((cb->matchcallback != NULL) &&
(cb->matchcallback(URI) != 0)) {
buf->context = cb->opencallback(URI);
if (buf->context != NULL) {
buf->readcallback = cb->readcallback;
buf->closecallback = cb->closecallback;
ret = XML_ERR_OK;
break;
}
}
}
if (ret != XML_ERR_OK) {
xmlFreeParserInputBuffer(buf);
*out = NULL;
return(ret);
}
*out = buf;
return(ret);
}
xmlParserInputBuffer *
__xmlParserInputBufferCreateFilename(const char *URI, xmlCharEncoding enc) {
xmlParserInputBufferPtr ret;
xmlParserInputBufferCreateUrl(URI, enc, 0, &ret);
return(ret);
}
xmlParserInputBuffer *
xmlParserInputBufferCreateFilename(const char *URI, xmlCharEncoding enc) {
xmlParserInputBufferPtr ret;
xmlParserErrors code;
if (xmlParserInputBufferCreateFilenameValue != NULL)
return(xmlParserInputBufferCreateFilenameValue(URI, enc));
code = xmlParserInputBufferCreateUrl(URI, enc, 0, &ret);
if ((code != XML_ERR_OK) && (code != XML_IO_ENOENT)) {
if (xmlRaiseError(NULL, NULL, NULL, NULL, NULL, XML_FROM_IO, code,
XML_ERR_ERROR, URI, 0, NULL, NULL, NULL, 0, 0,
"Failed to open file\n") < 0)
xmlRaiseMemoryError(NULL, NULL, NULL, XML_FROM_IO, NULL);
}
return(ret);
}
#ifdef LIBXML_OUTPUT_ENABLED
xmlOutputBuffer *
__xmlOutputBufferCreateFilename(const char *URI,
xmlCharEncodingHandler *encoder,
int compression) {
xmlOutputBufferPtr ret = NULL;
xmlURIPtr puri;
int i = 0;
char *unescaped = NULL;
xmlInitParser();
if (URI == NULL)
goto error;
puri = xmlParseURI(URI);
if (puri != NULL) {
if (puri->scheme == NULL) {
unescaped = xmlURIUnescapeString(URI, 0, NULL);
if (unescaped == NULL) {
xmlFreeURI(puri);
goto error;
}
URI = unescaped;
}
xmlFreeURI(puri);
}
ret = xmlAllocOutputBuffer(encoder);
if (ret == NULL)
goto error;
for (i = xmlOutputCallbackNr - 1; i >= 0; i--) {
xmlOutputCallback *cb = &xmlOutputCallbackTable[i];
xmlParserErrors code;
if (cb->matchcallback == xmlIODefaultMatch) {
code = xmlOutputDefaultOpen(ret, URI, compression);
if (code == XML_ERR_OK)
break;
} else if ((cb->matchcallback != NULL) &&
(cb->matchcallback(URI) != 0)) {
ret->context = cb->opencallback(URI);
if (ret->context != NULL) {
ret->writecallback = cb->writecallback;
ret->closecallback = cb->closecallback;
break;
}
}
}
if (ret->context == NULL) {
ret->encoder = NULL;
xmlOutputBufferClose(ret);
ret = NULL;
}
error:
xmlFree(unescaped);
return(ret);
}
xmlOutputBuffer *
xmlOutputBufferCreateFilename(const char *URI,
xmlCharEncodingHandler *encoder,
int compression ATTRIBUTE_UNUSED) {
if ((xmlOutputBufferCreateFilenameValue)) {
return xmlOutputBufferCreateFilenameValue(URI, encoder, compression);
}
return __xmlOutputBufferCreateFilename(URI, encoder, compression);
}
#endif
xmlParserInputBuffer *
xmlParserInputBufferCreateFile(FILE *file, xmlCharEncoding enc) {
xmlParserInputBufferPtr ret;
if (file == NULL) return(NULL);
ret = xmlAllocParserInputBuffer(enc);
if (ret != NULL) {
ret->context = file;
ret->readcallback = xmlFileRead;
ret->closecallback = NULL;
}
return(ret);
}
#ifdef LIBXML_OUTPUT_ENABLED
xmlOutputBuffer *
xmlOutputBufferCreateFile(FILE *file, xmlCharEncodingHandler *encoder) {
xmlOutputBufferPtr ret;
if (file == NULL) {
return(NULL);
}
ret = xmlAllocOutputBuffer(encoder);
if (ret != NULL) {
ret->context = file;
ret->writecallback = xmlFileWrite;
ret->closecallback = xmlFileFlush;
}
return(ret);
}
xmlOutputBuffer *
xmlOutputBufferCreateBuffer(xmlBuffer *buffer,
xmlCharEncodingHandler *encoder) {
xmlOutputBufferPtr ret;
if (buffer == NULL) {
return(NULL);
}
ret = xmlOutputBufferCreateIO(xmlBufferWrite, NULL, (void *) buffer,
encoder);
return(ret);
}
const xmlChar *
xmlOutputBufferGetContent(xmlOutputBuffer *out) {
if ((out == NULL) || (out->buffer == NULL) || ((out->encoder != NULL) && (out->conv == NULL)) || (out->error != 0))
return(NULL);
if (out->encoder != NULL)
return(xmlBufContent(out->conv));
return(xmlBufContent(out->buffer));
}
size_t
xmlOutputBufferGetSize(xmlOutputBuffer *out) {
if ((out == NULL) || (out->buffer == NULL) || ((out->encoder != NULL) && (out->conv == NULL)) || (out->error != 0))
return(0);
if (out->encoder != NULL)
return(xmlBufUse(out->conv));
return(xmlBufUse(out->buffer));
}
#endif
xmlParserInputBuffer *
xmlParserInputBufferCreateFd(int fd, xmlCharEncoding enc) {
xmlParserInputBufferPtr ret;
if (fd < 0) return(NULL);
ret = xmlAllocParserInputBuffer(enc);
if (ret != NULL) {
xmlFdIOCtxt *fdctxt;
fdctxt = xmlMalloc(sizeof(*fdctxt));
if (fdctxt == NULL) {
return(NULL);
}
fdctxt->fd = fd;
ret->context = fdctxt;
ret->readcallback = xmlFdRead;
ret->closecallback = xmlFdFree;
}
return(ret);
}
typedef struct {
const char *cur;
size_t size;
} xmlMemIOCtxt;
static int
xmlMemRead(void *vctxt, char *buf, int size) {
xmlMemIOCtxt *ctxt = vctxt;
if ((size_t) size > ctxt->size)
size = ctxt->size;
memcpy(buf, ctxt->cur, size);
ctxt->cur += size;
ctxt->size -= size;
return size;
}
static int
xmlMemClose(void *vctxt) {
xmlMemIOCtxt *ctxt = vctxt;
xmlFree(ctxt);
return(0);
}
xmlParserInputBuffer *
xmlNewInputBufferMemory(const void *mem, size_t size,
xmlParserInputFlags flags, xmlCharEncoding enc) {
xmlParserInputBufferPtr ret;
if ((flags & XML_INPUT_BUF_STATIC) &&
((flags & XML_INPUT_BUF_ZERO_TERMINATED) == 0)) {
xmlMemIOCtxt *ctxt;
ret = xmlAllocParserInputBuffer(enc);
if (ret == NULL)
return(NULL);
ctxt = xmlMalloc(sizeof(*ctxt));
if (ctxt == NULL) {
xmlFreeParserInputBuffer(ret);
return(NULL);
}
ctxt->cur = mem;
ctxt->size = size;
ret->context = ctxt;
ret->readcallback = xmlMemRead;
ret->closecallback = xmlMemClose;
} else {
ret = xmlMalloc(sizeof(*ret));
if (ret == NULL)
return(NULL);
memset(ret, 0, sizeof(xmlParserInputBuffer));
ret->compressed = -1;
ret->buffer = xmlBufCreateMem((const xmlChar *) mem, size,
(flags & XML_INPUT_BUF_STATIC ? 1 : 0));
if (ret->buffer == NULL) {
xmlFree(ret);
return(NULL);
}
}
return(ret);
}
xmlParserInputBuffer *
xmlParserInputBufferCreateMem(const char *mem, int size, xmlCharEncoding enc) {
if ((mem == NULL) || (size < 0))
return(NULL);
return(xmlNewInputBufferMemory(mem, size, 0, enc));
}
xmlParserInputBuffer *
xmlParserInputBufferCreateStatic(const char *mem, int size,
xmlCharEncoding enc) {
if ((mem == NULL) || (size < 0))
return(NULL);
return(xmlNewInputBufferMemory(mem, size, XML_INPUT_BUF_STATIC, enc));
}
xmlParserInputBuffer *
xmlNewInputBufferString(const char *str, xmlParserInputFlags flags) {
xmlParserInputBufferPtr ret;
ret = xmlMalloc(sizeof(*ret));
if (ret == NULL)
return(NULL);
memset(ret, 0, sizeof(xmlParserInputBuffer));
ret->compressed = -1;
ret->buffer = xmlBufCreateMem((const xmlChar *) str, strlen(str),
(flags & XML_INPUT_BUF_STATIC ? 1 : 0));
if (ret->buffer == NULL) {
xmlFree(ret);
return(NULL);
}
return(ret);
}
#ifdef LIBXML_OUTPUT_ENABLED
xmlOutputBuffer *
xmlOutputBufferCreateFd(int fd, xmlCharEncodingHandler *encoder) {
xmlOutputBufferPtr ret;
if (fd < 0) {
return(NULL);
}
ret = xmlAllocOutputBuffer(encoder);
if (ret != NULL) {
xmlFdIOCtxt *fdctxt;
fdctxt = xmlMalloc(sizeof(*fdctxt));
if (fdctxt == NULL) {
return(NULL);
}
fdctxt->fd = fd;
ret->context = fdctxt;
ret->writecallback = xmlFdWrite;
ret->closecallback = xmlFdFree;
}
return(ret);
}
#endif
xmlParserInputBuffer *
xmlParserInputBufferCreateIO(xmlInputReadCallback ioread,
xmlInputCloseCallback ioclose, void *ioctx, xmlCharEncoding enc) {
xmlParserInputBufferPtr ret;
if (ioread == NULL) return(NULL);
ret = xmlAllocParserInputBuffer(enc);
if (ret != NULL) {
ret->context = (void *) ioctx;
ret->readcallback = ioread;
ret->closecallback = ioclose;
}
return(ret);
}
#ifdef LIBXML_OUTPUT_ENABLED
xmlOutputBuffer *
xmlOutputBufferCreateIO(xmlOutputWriteCallback iowrite,
xmlOutputCloseCallback ioclose, void *ioctx,
xmlCharEncodingHandler *encoder) {
xmlOutputBufferPtr ret;
if (iowrite == NULL) {
return(NULL);
}
ret = xmlAllocOutputBuffer(encoder);
if (ret != NULL) {
ret->context = (void *) ioctx;
ret->writecallback = iowrite;
ret->closecallback = ioclose;
}
return(ret);
}
#endif
xmlParserInputBufferCreateFilenameFunc
xmlParserInputBufferCreateFilenameDefault(
xmlParserInputBufferCreateFilenameFunc func)
{
xmlParserInputBufferCreateFilenameFunc old;
old = xmlParserInputBufferCreateFilenameValue;
if (old == NULL)
old = __xmlParserInputBufferCreateFilename;
if (func == __xmlParserInputBufferCreateFilename)
func = NULL;
xmlParserInputBufferCreateFilenameValue = func;
return(old);
}
xmlOutputBufferCreateFilenameFunc
xmlOutputBufferCreateFilenameDefault(xmlOutputBufferCreateFilenameFunc func)
{
xmlOutputBufferCreateFilenameFunc old = xmlOutputBufferCreateFilenameValue;
#ifdef LIBXML_OUTPUT_ENABLED
if (old == NULL) {
old = __xmlOutputBufferCreateFilename;
}
#endif
xmlOutputBufferCreateFilenameValue = func;
return(old);
}
int
xmlParserInputBufferPush(xmlParserInputBuffer *in,
int len, const char *buf) {
size_t nbchars = 0;
int ret;
if (len < 0) return(0);
if ((in == NULL) || (in->error)) return(-1);
if (in->encoder != NULL) {
if (in->raw == NULL) {
in->raw = xmlBufCreate(50);
if (in->raw == NULL) {
in->error = XML_ERR_NO_MEMORY;
return(-1);
}
}
ret = xmlBufAdd(in->raw, (const xmlChar *) buf, len);
if (ret != 0) {
in->error = XML_ERR_NO_MEMORY;
return(-1);
}
nbchars = SIZE_MAX;
if (xmlCharEncInput(in, &nbchars, 0) !=
XML_ENC_ERR_SUCCESS)
return(-1);
if (nbchars > INT_MAX)
nbchars = INT_MAX;
} else {
nbchars = len;
ret = xmlBufAdd(in->buffer, (xmlChar *) buf, nbchars);
if (ret != 0) {
in->error = XML_ERR_NO_MEMORY;
return(-1);
}
}
return(nbchars);
}
static int
endOfInput (void * context ATTRIBUTE_UNUSED,
char * buffer ATTRIBUTE_UNUSED,
int len ATTRIBUTE_UNUSED) {
return(0);
}
int
xmlParserInputBufferGrow(xmlParserInputBuffer *in, int len) {
int res = 0;
if ((in == NULL) || (in->error))
return(-1);
if (len < MINLEN)
len = MINLEN;
if (in->readcallback != NULL) {
xmlBufPtr buf;
if (in->encoder == NULL) {
buf = in->buffer;
} else {
if (in->raw == NULL) {
in->raw = xmlBufCreate(XML_IO_BUFFER_SIZE);
if (in->raw == NULL) {
in->error = XML_ERR_NO_MEMORY;
return(-1);
}
}
buf = in->raw;
}
if (xmlBufGrow(buf, len) < 0) {
in->error = XML_ERR_NO_MEMORY;
return(-1);
}
res = in->readcallback(in->context, (char *)xmlBufEnd(buf), len);
if (res <= 0)
in->readcallback = endOfInput;
if (res < 0) {
if (res == -1)
in->error = XML_IO_UNKNOWN;
else
in->error = -res;
return(-1);
}
if (xmlBufAddLen(buf, res) < 0) {
in->error = XML_ERR_NO_MEMORY;
return(-1);
}
}
if (in->encoder != NULL) {
size_t sizeOut;
if (in->readcallback == NULL)
sizeOut = len;
else
sizeOut = SIZE_MAX;
if (xmlCharEncInput(in, &sizeOut, 0) !=
XML_ENC_ERR_SUCCESS)
return(-1);
res = sizeOut;
}
return(res);
}
int
xmlParserInputBufferRead(xmlParserInputBuffer *in, int len) {
return(xmlParserInputBufferGrow(in, len));
}
#ifdef LIBXML_OUTPUT_ENABLED
int
xmlOutputBufferWrite(xmlOutputBuffer *out, int len, const char *data) {
xmlBufPtr buf = NULL;
size_t written = 0;
int ret;
if ((out == NULL) || (out->error))
return(-1);
if (len < 0)
return(0);
ret = xmlBufAdd(out->buffer, (const xmlChar *) data, len);
if (ret != 0) {
out->error = XML_ERR_NO_MEMORY;
return(-1);
}
if (out->encoder != NULL) {
if (out->conv == NULL) {
out->conv = xmlBufCreate(MINLEN);
if (out->conv == NULL) {
out->error = XML_ERR_NO_MEMORY;
return(-1);
}
}
if (xmlBufUse(out->buffer) < 256) {
ret = 0;
} else {
ret = xmlCharEncOutput(out, 0);
if (ret < 0)
return(-1);
}
if (out->writecallback)
buf = out->conv;
else
written = ret;
} else {
if (out->writecallback)
buf = out->buffer;
else
written = len;
}
if ((buf != NULL) && (out->writecallback)) {
while (1) {
size_t nbchars = xmlBufUse(buf);
if (nbchars < MINLEN)
break;
if (nbchars >= INT_MAX) {
out->error = XML_ERR_INTERNAL_ERROR;
return(-1);
}
ret = out->writecallback(out->context,
(const char *)xmlBufContent(buf), nbchars);
if (ret < 0) {
out->error = (ret == -1) ? XML_IO_WRITE : -ret;
return(-1);
}
if ((ret == 0) || ((size_t) ret > nbchars)) {
out->error = XML_ERR_INTERNAL_ERROR;
return(-1);
}
xmlBufShrink(buf, ret);
written += ret;
if (out->written > INT_MAX - ret)
out->written = INT_MAX;
else
out->written += ret;
}
}
return(written <= INT_MAX ? written : INT_MAX);
}
int
xmlOutputBufferWriteEscape(xmlOutputBuffer *out, const xmlChar *str,
xmlCharEncodingOutputFunc escaping) {
int ret;
int written = 0;
size_t len;
if ((out == NULL) || (out->error) || (str == NULL))
return(-1);
len = strlen((const char *) str);
if (len >= INT_MAX) {
out->error = XML_ERR_RESOURCE_LIMIT;
return(-1);
}
if (escaping == NULL) {
char *escaped = (char *) xmlEscapeText(str, 0);
if (escaped == NULL) {
out->error = XML_ERR_NO_MEMORY;
return(-1);
}
len = strlen(escaped);
if (len >= INT_MAX) {
out->error = XML_ERR_RESOURCE_LIMIT;
return(-1);
}
ret = xmlOutputBufferWrite(out, len, escaped);
xmlFree(escaped);
return(ret);
}
while (len > 0) {
xmlChar buf[1024];
int c_out;
int c_in;
c_out = 1024;
c_in = len;
ret = escaping(buf, &c_out, str, &c_in);
if (ret < 0) {
out->error = XML_ERR_NO_MEMORY;
return(-1);
}
str += c_in;
len -= c_in;
ret = xmlOutputBufferWrite(out, c_out, (char *) buf);
if (ret < 0)
return(ret);
written += ret;
}
return(written);
}
int
xmlOutputBufferWriteString(xmlOutputBuffer *out, const char *str) {
int len;
if ((out == NULL) || (out->error)) return(-1);
if (str == NULL)
return(-1);
len = strlen(str);
if (len > 0)
return(xmlOutputBufferWrite(out, len, str));
return(len);
}
void
xmlOutputBufferWriteQuotedString(xmlOutputBuffer *buf,
const xmlChar *string) {
const xmlChar *cur, *base;
if ((buf == NULL) || (buf->error))
return;
if (xmlStrchr(string, '\"')) {
if (xmlStrchr(string, '\'')) {
xmlOutputBufferWrite(buf, 1, "\"");
base = cur = string;
while(*cur != 0){
if(*cur == '"'){
if (base != cur)
xmlOutputBufferWrite(buf, cur - base,
(const char *) base);
xmlOutputBufferWrite(buf, 6, """);
cur++;
base = cur;
}
else {
cur++;
}
}
if (base != cur)
xmlOutputBufferWrite(buf, cur - base, (const char *) base);
xmlOutputBufferWrite(buf, 1, "\"");
}
else{
xmlOutputBufferWrite(buf, 1, "'");
xmlOutputBufferWriteString(buf, (const char *) string);
xmlOutputBufferWrite(buf, 1, "'");
}
} else {
xmlOutputBufferWrite(buf, 1, "\"");
xmlOutputBufferWriteString(buf, (const char *) string);
xmlOutputBufferWrite(buf, 1, "\"");
}
}
int
xmlOutputBufferFlush(xmlOutputBuffer *out) {
int nbchars = 0, ret = 0;
if ((out == NULL) || (out->error)) return(-1);
if ((out->conv != NULL) && (out->encoder != NULL)) {
do {
nbchars = xmlCharEncOutput(out, 0);
if (nbchars < 0)
return(-1);
} while (nbchars);
}
if ((out->conv != NULL) && (out->encoder != NULL) &&
(out->writecallback != NULL)) {
size_t bufsize = xmlBufUse(out->conv);
if (bufsize >= INT_MAX) {
out->error = XML_ERR_INTERNAL_ERROR;
return(-1);
}
ret = out->writecallback(out->context,
(const char *)xmlBufContent(out->conv),
bufsize);
if (ret >= 0)
xmlBufShrink(out->conv, ret);
} else if (out->writecallback != NULL) {
size_t bufsize = xmlBufUse(out->buffer);
if (bufsize >= INT_MAX) {
out->error = XML_ERR_INTERNAL_ERROR;
return(-1);
}
ret = out->writecallback(out->context,
(const char *)xmlBufContent(out->buffer),
bufsize);
if (ret >= 0)
xmlBufShrink(out->buffer, ret);
}
if (ret < 0) {
out->error = (ret == -1) ? XML_IO_WRITE : -ret;
return(ret);
}
if (out->written > INT_MAX - ret)
out->written = INT_MAX;
else
out->written += ret;
return(ret);
}
#endif
char *
xmlParserGetDirectory(const char *filename) {
char *ret = NULL;
char dir[1024];
char *cur;
if (filename == NULL) return(NULL);
#if defined(_WIN32)
# define IS_XMLPGD_SEP(ch) ((ch=='/')||(ch=='\\'))
#else
# define IS_XMLPGD_SEP(ch) (ch=='/')
#endif
strncpy(dir, filename, 1023);
dir[1023] = 0;
cur = &dir[strlen(dir)];
while (cur > dir) {
if (IS_XMLPGD_SEP(*cur)) break;
cur --;
}
if (IS_XMLPGD_SEP(*cur)) {
if (cur == dir) dir[1] = 0;
else *cur = 0;
ret = xmlMemStrdup(dir);
} else {
ret = xmlMemStrdup(".");
}
return(ret);
#undef IS_XMLPGD_SEP
}
int
xmlNoNetExists(const char *filename) {
char *fromUri;
int ret;
if (filename == NULL)
return(0);
if (xmlConvertUriToPath(filename, &fromUri) < 0)
return(0);
if (fromUri != NULL)
filename = fromUri;
ret = xmlCheckFilename(filename);
xmlFree(fromUri);
return(ret);
}
void
xmlInitIOCallbacks(void)
{
xmlInputCallbackNr = 1;
xmlInputCallbackTable[0].matchcallback = xmlIODefaultMatch;
#ifdef LIBXML_OUTPUT_ENABLED
xmlOutputCallbackNr = 1;
xmlOutputCallbackTable[0].matchcallback = xmlIODefaultMatch;
#endif
}
int
xmlRegisterInputCallbacks(xmlInputMatchCallback matchFunc,
xmlInputOpenCallback openFunc, xmlInputReadCallback readFunc,
xmlInputCloseCallback closeFunc) {
xmlInitParser();
if (xmlInputCallbackNr >= MAX_INPUT_CALLBACK) {
return(-1);
}
xmlInputCallbackTable[xmlInputCallbackNr].matchcallback = matchFunc;
xmlInputCallbackTable[xmlInputCallbackNr].opencallback = openFunc;
xmlInputCallbackTable[xmlInputCallbackNr].readcallback = readFunc;
xmlInputCallbackTable[xmlInputCallbackNr].closecallback = closeFunc;
return(xmlInputCallbackNr++);
}
void
xmlRegisterDefaultInputCallbacks(void) {
xmlRegisterInputCallbacks(xmlIODefaultMatch, NULL, NULL, NULL);
}
int
xmlPopInputCallbacks(void)
{
xmlInitParser();
if (xmlInputCallbackNr <= 0)
return(-1);
xmlInputCallbackNr--;
return(xmlInputCallbackNr);
}
void
xmlCleanupInputCallbacks(void)
{
xmlInitParser();
xmlInputCallbackNr = 0;
}
#ifdef LIBXML_OUTPUT_ENABLED
int
xmlRegisterOutputCallbacks(xmlOutputMatchCallback matchFunc,
xmlOutputOpenCallback openFunc, xmlOutputWriteCallback writeFunc,
xmlOutputCloseCallback closeFunc) {
xmlInitParser();
if (xmlOutputCallbackNr >= MAX_OUTPUT_CALLBACK) {
return(-1);
}
xmlOutputCallbackTable[xmlOutputCallbackNr].matchcallback = matchFunc;
xmlOutputCallbackTable[xmlOutputCallbackNr].opencallback = openFunc;
xmlOutputCallbackTable[xmlOutputCallbackNr].writecallback = writeFunc;
xmlOutputCallbackTable[xmlOutputCallbackNr].closecallback = closeFunc;
return(xmlOutputCallbackNr++);
}
void
xmlRegisterDefaultOutputCallbacks (void) {
xmlRegisterOutputCallbacks(xmlIODefaultMatch, NULL, NULL, NULL);
}
int
xmlPopOutputCallbacks(void)
{
xmlInitParser();
if (xmlOutputCallbackNr <= 0)
return(-1);
xmlOutputCallbackNr--;
return(xmlOutputCallbackNr);
}
void
xmlCleanupOutputCallbacks(void)
{
xmlInitParser();
xmlOutputCallbackNr = 0;
}
#endif