VirtualBox

source: vbox/trunk/src/libs/libxml2-2.9.14/xmlIO.c@ 102654

Last change on this file since 102654 was 96464, checked in by vboxsync, 2 years ago

libs/libxml2-2.9.14: Made it build in no-CRT mode. bugref:10261
  • Property svn:eol-style set to native
File size: 104.0 KB
Line 
1/*
2 * xmlIO.c : implementation of the I/O interfaces used by the parser
3 *
4 * See Copyright for the status of this software.
5 *
6 * daniel@veillard.com
7 *
8 * 14 Nov 2000 ht - for VMS, truncated name of long functions to under 32 char
9 */
10
11#define IN_LIBXML
12#include "libxml.h"
13
14#include <string.h>
15#include <stddef.h>
16#ifdef HAVE_ERRNO_H
17#include <errno.h>
18#endif
19
20
21#ifdef HAVE_SYS_TYPES_H
22#include <sys/types.h>
23#endif
24#ifdef HAVE_SYS_STAT_H
25#include <sys/stat.h>
26#endif
27#ifdef HAVE_FCNTL_H
28#include <fcntl.h>
29#endif
30#ifdef HAVE_UNISTD_H
31#include <unistd.h>
32#endif
33#ifdef HAVE_STDLIB_H
34#include <stdlib.h>
35#endif
36#ifdef LIBXML_ZLIB_ENABLED
37#include <zlib.h>
38#endif
39#ifdef LIBXML_LZMA_ENABLED
40#include <lzma.h>
41#endif
42
43#if defined(_WIN32) && !defined(__CYGWIN__)
44#define WIN32_LEAN_AND_MEAN
45#include <windows.h>
46#endif
47
48#if defined(_WIN32_WCE)
49#include <winnls.h> /* for CP_UTF8 */
50#endif
51
52#ifndef S_ISDIR
53# ifdef _S_ISDIR
54# define S_ISDIR(x) _S_ISDIR(x)
55# elif defined(S_IFDIR)
56# ifdef S_IFMT
57# define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
58# elif defined(_S_IFMT)
59# define S_ISDIR(m) (((m) & _S_IFMT) == S_IFDIR)
60# endif
61# endif
62#endif
63
64#include <libxml/xmlmemory.h>
65#include <libxml/parser.h>
66#include <libxml/parserInternals.h>
67#include <libxml/xmlIO.h>
68#include <libxml/uri.h>
69#include <libxml/nanohttp.h>
70#include <libxml/nanoftp.h>
71#include <libxml/xmlerror.h>
72#ifdef LIBXML_CATALOG_ENABLED
73#include <libxml/catalog.h>
74#endif
75#include <libxml/globals.h>
76
77#include "buf.h"
78#include "enc.h"
79
80/* #define VERBOSE_FAILURE */
81/* #define DEBUG_EXTERNAL_ENTITIES */
82/* #define DEBUG_INPUT */
83
84#ifdef DEBUG_INPUT
85#define MINLEN 40
86#else
87#define MINLEN 4000
88#endif
89
90/*
91 * Input I/O callback sets
92 */
93typedef struct _xmlInputCallback {
94 xmlInputMatchCallback matchcallback;
95 xmlInputOpenCallback opencallback;
96 xmlInputReadCallback readcallback;
97 xmlInputCloseCallback closecallback;
98} xmlInputCallback;
99
100#define MAX_INPUT_CALLBACK 15
101
102static xmlInputCallback xmlInputCallbackTable[MAX_INPUT_CALLBACK];
103static int xmlInputCallbackNr = 0;
104static int xmlInputCallbackInitialized = 0;
105
106#ifdef LIBXML_OUTPUT_ENABLED
107/*
108 * Output I/O callback sets
109 */
110typedef struct _xmlOutputCallback {
111 xmlOutputMatchCallback matchcallback;
112 xmlOutputOpenCallback opencallback;
113 xmlOutputWriteCallback writecallback;
114 xmlOutputCloseCallback closecallback;
115} xmlOutputCallback;
116
117#define MAX_OUTPUT_CALLBACK 15
118
119static xmlOutputCallback xmlOutputCallbackTable[MAX_OUTPUT_CALLBACK];
120static int xmlOutputCallbackNr = 0;
121static int xmlOutputCallbackInitialized = 0;
122
123xmlOutputBufferPtr
124xmlAllocOutputBufferInternal(xmlCharEncodingHandlerPtr encoder);
125#endif /* LIBXML_OUTPUT_ENABLED */
126
127/************************************************************************
128 * *
129 * Tree memory error handler *
130 * *
131 ************************************************************************/
132
133static const char *IOerr[] = {
134 "Unknown IO error", /* UNKNOWN */
135 "Permission denied", /* EACCES */
136 "Resource temporarily unavailable",/* EAGAIN */
137 "Bad file descriptor", /* EBADF */
138 "Bad message", /* EBADMSG */
139 "Resource busy", /* EBUSY */
140 "Operation canceled", /* ECANCELED */
141 "No child processes", /* ECHILD */
142 "Resource deadlock avoided",/* EDEADLK */
143 "Domain error", /* EDOM */
144 "File exists", /* EEXIST */
145 "Bad address", /* EFAULT */
146 "File too large", /* EFBIG */
147 "Operation in progress", /* EINPROGRESS */
148 "Interrupted function call",/* EINTR */
149 "Invalid argument", /* EINVAL */
150 "Input/output error", /* EIO */
151 "Is a directory", /* EISDIR */
152 "Too many open files", /* EMFILE */
153 "Too many links", /* EMLINK */
154 "Inappropriate message buffer length",/* EMSGSIZE */
155 "Filename too long", /* ENAMETOOLONG */
156 "Too many open files in system",/* ENFILE */
157 "No such device", /* ENODEV */
158 "No such file or directory",/* ENOENT */
159 "Exec format error", /* ENOEXEC */
160 "No locks available", /* ENOLCK */
161 "Not enough space", /* ENOMEM */
162 "No space left on device", /* ENOSPC */
163 "Function not implemented", /* ENOSYS */
164 "Not a directory", /* ENOTDIR */
165 "Directory not empty", /* ENOTEMPTY */
166 "Not supported", /* ENOTSUP */
167 "Inappropriate I/O control operation",/* ENOTTY */
168 "No such device or address",/* ENXIO */
169 "Operation not permitted", /* EPERM */
170 "Broken pipe", /* EPIPE */
171 "Result too large", /* ERANGE */
172 "Read-only file system", /* EROFS */
173 "Invalid seek", /* ESPIPE */
174 "No such process", /* ESRCH */
175 "Operation timed out", /* ETIMEDOUT */
176 "Improper link", /* EXDEV */
177 "Attempt to load network entity %s", /* XML_IO_NETWORK_ATTEMPT */
178 "encoder error", /* XML_IO_ENCODER */
179 "flush error",
180 "write error",
181 "no input",
182 "buffer full",
183 "loading error",
184 "not a socket", /* ENOTSOCK */
185 "already connected", /* EISCONN */
186 "connection refused", /* ECONNREFUSED */
187 "unreachable network", /* ENETUNREACH */
188 "address in use", /* EADDRINUSE */
189 "already in use", /* EALREADY */
190 "unknown address family", /* EAFNOSUPPORT */
191};
192
193#if (defined(_WIN32) || defined (__DJGPP__)) && !defined (__CYGWIN__) && !defined(IPRT_NO_CRT)
194/**
195 * __xmlIOWin32UTF8ToWChar:
196 * @u8String: uft-8 string
197 *
198 * Convert a string from utf-8 to wchar (WINDOWS ONLY!)
199 */
200static wchar_t *
201__xmlIOWin32UTF8ToWChar(const char *u8String)
202{
203 wchar_t *wString = NULL;
204
205 if (u8String) {
206 int wLen =
207 MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, u8String,
208 -1, NULL, 0);
209 if (wLen) {
210 wString = xmlMalloc(wLen * sizeof(wchar_t));
211 if (wString) {
212 if (MultiByteToWideChar
213 (CP_UTF8, 0, u8String, -1, wString, wLen) == 0) {
214 xmlFree(wString);
215 wString = NULL;
216 }
217 }
218 }
219 }
220
221 return wString;
222}
223#endif
224
225/**
226 * xmlIOErrMemory:
227 * @extra: extra information
228 *
229 * Handle an out of memory condition
230 */
231static void
232xmlIOErrMemory(const char *extra)
233{
234 __xmlSimpleError(XML_FROM_IO, XML_ERR_NO_MEMORY, NULL, NULL, extra);
235}
236
237/**
238 * __xmlIOErr:
239 * @code: the error number
240 * @
241 * @extra: extra information
242 *
243 * Handle an I/O error
244 */
245void
246__xmlIOErr(int domain, int code, const char *extra)
247{
248 unsigned int idx;
249
250 if (code == 0) {
251#ifdef HAVE_ERRNO_H
252 if (errno == 0) code = 0;
253#ifdef EACCES
254 else if (errno == EACCES) code = XML_IO_EACCES;
255#endif
256#ifdef EAGAIN
257 else if (errno == EAGAIN) code = XML_IO_EAGAIN;
258#endif
259#ifdef EBADF
260 else if (errno == EBADF) code = XML_IO_EBADF;
261#endif
262#ifdef EBADMSG
263 else if (errno == EBADMSG) code = XML_IO_EBADMSG;
264#endif
265#ifdef EBUSY
266 else if (errno == EBUSY) code = XML_IO_EBUSY;
267#endif
268#ifdef ECANCELED
269 else if (errno == ECANCELED) code = XML_IO_ECANCELED;
270#endif
271#ifdef ECHILD
272 else if (errno == ECHILD) code = XML_IO_ECHILD;
273#endif
274#ifdef EDEADLK
275 else if (errno == EDEADLK) code = XML_IO_EDEADLK;
276#endif
277#ifdef EDOM
278 else if (errno == EDOM) code = XML_IO_EDOM;
279#endif
280#ifdef EEXIST
281 else if (errno == EEXIST) code = XML_IO_EEXIST;
282#endif
283#ifdef EFAULT
284 else if (errno == EFAULT) code = XML_IO_EFAULT;
285#endif
286#ifdef EFBIG
287 else if (errno == EFBIG) code = XML_IO_EFBIG;
288#endif
289#ifdef EINPROGRESS
290 else if (errno == EINPROGRESS) code = XML_IO_EINPROGRESS;
291#endif
292#ifdef EINTR
293 else if (errno == EINTR) code = XML_IO_EINTR;
294#endif
295#ifdef EINVAL
296 else if (errno == EINVAL) code = XML_IO_EINVAL;
297#endif
298#ifdef EIO
299 else if (errno == EIO) code = XML_IO_EIO;
300#endif
301#ifdef EISDIR
302 else if (errno == EISDIR) code = XML_IO_EISDIR;
303#endif
304#ifdef EMFILE
305 else if (errno == EMFILE) code = XML_IO_EMFILE;
306#endif
307#ifdef EMLINK
308 else if (errno == EMLINK) code = XML_IO_EMLINK;
309#endif
310#ifdef EMSGSIZE
311 else if (errno == EMSGSIZE) code = XML_IO_EMSGSIZE;
312#endif
313#ifdef ENAMETOOLONG
314 else if (errno == ENAMETOOLONG) code = XML_IO_ENAMETOOLONG;
315#endif
316#ifdef ENFILE
317 else if (errno == ENFILE) code = XML_IO_ENFILE;
318#endif
319#ifdef ENODEV
320 else if (errno == ENODEV) code = XML_IO_ENODEV;
321#endif
322#ifdef ENOENT
323 else if (errno == ENOENT) code = XML_IO_ENOENT;
324#endif
325#ifdef ENOEXEC
326 else if (errno == ENOEXEC) code = XML_IO_ENOEXEC;
327#endif
328#ifdef ENOLCK
329 else if (errno == ENOLCK) code = XML_IO_ENOLCK;
330#endif
331#ifdef ENOMEM
332 else if (errno == ENOMEM) code = XML_IO_ENOMEM;
333#endif
334#ifdef ENOSPC
335 else if (errno == ENOSPC) code = XML_IO_ENOSPC;
336#endif
337#ifdef ENOSYS
338 else if (errno == ENOSYS) code = XML_IO_ENOSYS;
339#endif
340#ifdef ENOTDIR
341 else if (errno == ENOTDIR) code = XML_IO_ENOTDIR;
342#endif
343#ifdef ENOTEMPTY
344 else if (errno == ENOTEMPTY) code = XML_IO_ENOTEMPTY;
345#endif
346#ifdef ENOTSUP
347 else if (errno == ENOTSUP) code = XML_IO_ENOTSUP;
348#endif
349#ifdef ENOTTY
350 else if (errno == ENOTTY) code = XML_IO_ENOTTY;
351#endif
352#ifdef ENXIO
353 else if (errno == ENXIO) code = XML_IO_ENXIO;
354#endif
355#ifdef EPERM
356 else if (errno == EPERM) code = XML_IO_EPERM;
357#endif
358#ifdef EPIPE
359 else if (errno == EPIPE) code = XML_IO_EPIPE;
360#endif
361#ifdef ERANGE
362 else if (errno == ERANGE) code = XML_IO_ERANGE;
363#endif
364#ifdef EROFS
365 else if (errno == EROFS) code = XML_IO_EROFS;
366#endif
367#ifdef ESPIPE
368 else if (errno == ESPIPE) code = XML_IO_ESPIPE;
369#endif
370#ifdef ESRCH
371 else if (errno == ESRCH) code = XML_IO_ESRCH;
372#endif
373#ifdef ETIMEDOUT
374 else if (errno == ETIMEDOUT) code = XML_IO_ETIMEDOUT;
375#endif
376#ifdef EXDEV
377 else if (errno == EXDEV) code = XML_IO_EXDEV;
378#endif
379#ifdef ENOTSOCK
380 else if (errno == ENOTSOCK) code = XML_IO_ENOTSOCK;
381#endif
382#ifdef EISCONN
383 else if (errno == EISCONN) code = XML_IO_EISCONN;
384#endif
385#ifdef ECONNREFUSED
386 else if (errno == ECONNREFUSED) code = XML_IO_ECONNREFUSED;
387#endif
388#ifdef ETIMEDOUT
389 else if (errno == ETIMEDOUT) code = XML_IO_ETIMEDOUT;
390#endif
391#ifdef ENETUNREACH
392 else if (errno == ENETUNREACH) code = XML_IO_ENETUNREACH;
393#endif
394#ifdef EADDRINUSE
395 else if (errno == EADDRINUSE) code = XML_IO_EADDRINUSE;
396#endif
397#ifdef EINPROGRESS
398 else if (errno == EINPROGRESS) code = XML_IO_EINPROGRESS;
399#endif
400#ifdef EALREADY
401 else if (errno == EALREADY) code = XML_IO_EALREADY;
402#endif
403#ifdef EAFNOSUPPORT
404 else if (errno == EAFNOSUPPORT) code = XML_IO_EAFNOSUPPORT;
405#endif
406 else code = XML_IO_UNKNOWN;
407#endif /* HAVE_ERRNO_H */
408 }
409 idx = 0;
410 if (code >= XML_IO_UNKNOWN) idx = code - XML_IO_UNKNOWN;
411 if (idx >= (sizeof(IOerr) / sizeof(IOerr[0]))) idx = 0;
412
413 __xmlSimpleError(domain, code, NULL, IOerr[idx], extra);
414}
415
416/**
417 * xmlIOErr:
418 * @code: the error number
419 * @extra: extra information
420 *
421 * Handle an I/O error
422 */
423static void
424xmlIOErr(int code, const char *extra)
425{
426 __xmlIOErr(XML_FROM_IO, code, extra);
427}
428
429/**
430 * __xmlLoaderErr:
431 * @ctx: the parser context
432 * @extra: extra information
433 *
434 * Handle a resource access error
435 */
436void
437__xmlLoaderErr(void *ctx, const char *msg, const char *filename)
438{
439 xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
440 xmlStructuredErrorFunc schannel = NULL;
441 xmlGenericErrorFunc channel = NULL;
442 void *data = NULL;
443 xmlErrorLevel level = XML_ERR_ERROR;
444
445 if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
446 (ctxt->instate == XML_PARSER_EOF))
447 return;
448 if ((ctxt != NULL) && (ctxt->sax != NULL)) {
449 if (ctxt->validate) {
450 channel = ctxt->sax->error;
451 level = XML_ERR_ERROR;
452 } else {
453 channel = ctxt->sax->warning;
454 level = XML_ERR_WARNING;
455 }
456 if (ctxt->sax->initialized == XML_SAX2_MAGIC)
457 schannel = ctxt->sax->serror;
458 data = ctxt->userData;
459 }
460 __xmlRaiseError(schannel, channel, data, ctxt, NULL, XML_FROM_IO,
461 XML_IO_LOAD_ERROR, level, NULL, 0,
462 filename, NULL, NULL, 0, 0,
463 msg, filename);
464
465}
466
467/************************************************************************
468 * *
469 * Tree memory error handler *
470 * *
471 ************************************************************************/
472/**
473 * xmlNormalizeWindowsPath:
474 * @path: the input file path
475 *
476 * This function is obsolete. Please see xmlURIFromPath in uri.c for
477 * a better solution.
478 *
479 * Returns a canonicalized version of the path
480 */
481xmlChar *
482xmlNormalizeWindowsPath(const xmlChar *path)
483{
484 return xmlCanonicPath(path);
485}
486
487/**
488 * xmlCleanupInputCallbacks:
489 *
490 * clears the entire input callback table. this includes the
491 * compiled-in I/O.
492 */
493void
494xmlCleanupInputCallbacks(void)
495{
496 int i;
497
498 if (!xmlInputCallbackInitialized)
499 return;
500
501 for (i = xmlInputCallbackNr - 1; i >= 0; i--) {
502 xmlInputCallbackTable[i].matchcallback = NULL;
503 xmlInputCallbackTable[i].opencallback = NULL;
504 xmlInputCallbackTable[i].readcallback = NULL;
505 xmlInputCallbackTable[i].closecallback = NULL;
506 }
507
508 xmlInputCallbackNr = 0;
509 xmlInputCallbackInitialized = 0;
510}
511
512/**
513 * xmlPopInputCallbacks:
514 *
515 * Clear the top input callback from the input stack. this includes the
516 * compiled-in I/O.
517 *
518 * Returns the number of input callback registered or -1 in case of error.
519 */
520int
521xmlPopInputCallbacks(void)
522{
523 if (!xmlInputCallbackInitialized)
524 return(-1);
525
526 if (xmlInputCallbackNr <= 0)
527 return(-1);
528
529 xmlInputCallbackNr--;
530 xmlInputCallbackTable[xmlInputCallbackNr].matchcallback = NULL;
531 xmlInputCallbackTable[xmlInputCallbackNr].opencallback = NULL;
532 xmlInputCallbackTable[xmlInputCallbackNr].readcallback = NULL;
533 xmlInputCallbackTable[xmlInputCallbackNr].closecallback = NULL;
534
535 return(xmlInputCallbackNr);
536}
537
538#ifdef LIBXML_OUTPUT_ENABLED
539/**
540 * xmlCleanupOutputCallbacks:
541 *
542 * clears the entire output callback table. this includes the
543 * compiled-in I/O callbacks.
544 */
545void
546xmlCleanupOutputCallbacks(void)
547{
548 int i;
549
550 if (!xmlOutputCallbackInitialized)
551 return;
552
553 for (i = xmlOutputCallbackNr - 1; i >= 0; i--) {
554 xmlOutputCallbackTable[i].matchcallback = NULL;
555 xmlOutputCallbackTable[i].opencallback = NULL;
556 xmlOutputCallbackTable[i].writecallback = NULL;
557 xmlOutputCallbackTable[i].closecallback = NULL;
558 }
559
560 xmlOutputCallbackNr = 0;
561 xmlOutputCallbackInitialized = 0;
562}
563
564/**
565 * xmlPopOutputCallbacks:
566 *
567 * Remove the top output callbacks from the output stack. This includes the
568 * compiled-in I/O.
569 *
570 * Returns the number of output callback registered or -1 in case of error.
571 */
572int
573xmlPopOutputCallbacks(void)
574{
575 if (!xmlOutputCallbackInitialized)
576 return(-1);
577
578 if (xmlOutputCallbackNr <= 0)
579 return(-1);
580
581 xmlOutputCallbackNr--;
582 xmlOutputCallbackTable[xmlOutputCallbackNr].matchcallback = NULL;
583 xmlOutputCallbackTable[xmlOutputCallbackNr].opencallback = NULL;
584 xmlOutputCallbackTable[xmlOutputCallbackNr].writecallback = NULL;
585 xmlOutputCallbackTable[xmlOutputCallbackNr].closecallback = NULL;
586
587 return(xmlOutputCallbackNr);
588}
589
590#endif /* LIBXML_OUTPUT_ENABLED */
591
592/************************************************************************
593 * *
594 * Standard I/O for file accesses *
595 * *
596 ************************************************************************/
597
598#if (defined(_WIN32) || defined (__DJGPP__)) && !defined (__CYGWIN__) && !defined(IPRT_NO_CRT)
599
600/**
601 * xmlWrapOpenUtf8:
602 * @path: the path in utf-8 encoding
603 * @mode: type of access (0 - read, 1 - write)
604 *
605 * function opens the file specified by @path
606 *
607 */
608static FILE*
609xmlWrapOpenUtf8(const char *path,int mode)
610{
611 FILE *fd = NULL;
612 wchar_t *wPath;
613
614 wPath = __xmlIOWin32UTF8ToWChar(path);
615 if(wPath)
616 {
617 fd = _wfopen(wPath, mode ? L"wb" : L"rb");
618 xmlFree(wPath);
619 }
620 /* maybe path in native encoding */
621 if(fd == NULL)
622 fd = fopen(path, mode ? "wb" : "rb");
623
624 return fd;
625}
626
627#ifdef LIBXML_ZLIB_ENABLED
628static gzFile
629xmlWrapGzOpenUtf8(const char *path, const char *mode)
630{
631 gzFile fd;
632 wchar_t *wPath;
633
634 fd = gzopen (path, mode);
635 if (fd)
636 return fd;
637
638 wPath = __xmlIOWin32UTF8ToWChar(path);
639 if(wPath)
640 {
641 int d, m = (strstr(mode, "r") ? O_RDONLY : O_RDWR);
642#ifdef _O_BINARY
643 m |= (strstr(mode, "b") ? _O_BINARY : 0);
644#endif
645 d = _wopen(wPath, m);
646 if (d >= 0)
647 fd = gzdopen(d, mode);
648 xmlFree(wPath);
649 }
650
651 return fd;
652}
653#endif
654
655/**
656 * xmlWrapStatUtf8:
657 * @path: the path in utf-8 encoding
658 * @info: structure that stores results
659 *
660 * function obtains information about the file or directory
661 *
662 */
663static int
664xmlWrapStatUtf8(const char *path, struct _stat *info) {
665 int retval = -1;
666 wchar_t *wPath;
667
668 wPath = __xmlIOWin32UTF8ToWChar(path);
669 if (wPath) {
670 retval = _wstat(wPath, info);
671 xmlFree(wPath);
672 }
673 /* maybe path in native encoding */
674 if(retval < 0)
675 retval = _stat(path, info);
676 return retval;
677}
678
679#endif
680
681/**
682 * xmlCheckFilename:
683 * @path: the path to check
684 *
685 * function checks to see if @path is a valid source
686 * (file, socket...) for XML.
687 *
688 * if stat is not available on the target machine,
689 * returns 1. if stat fails, returns 0 (if calling
690 * stat on the filename fails, it can't be right).
691 * if stat succeeds and the file is a directory,
692 * returns 2. otherwise returns 1.
693 */
694
695int
696xmlCheckFilename (const char *path)
697{
698#ifdef HAVE_STAT
699#if (defined(_WIN32) || defined (__DJGPP__)) && !defined (__CYGWIN__) && !defined(IPRT_NO_CRT)
700 struct _stat stat_buffer;
701#else
702 struct stat stat_buffer;
703#endif
704#endif
705 if (path == NULL)
706 return(0);
707
708#ifdef HAVE_STAT
709#if (defined(_WIN32) || defined (__DJGPP__)) && !defined (__CYGWIN__) && !defined(IPRT_NO_CRT)
710 /*
711 * On Windows stat and wstat do not work with long pathname,
712 * which start with '\\?\'
713 */
714 if ((path[0] == '\\') && (path[1] == '\\') && (path[2] == '?') &&
715 (path[3] == '\\') )
716 return 1;
717
718 if (xmlWrapStatUtf8(path, &stat_buffer) == -1)
719 return 0;
720#else
721 if (stat(path, &stat_buffer) == -1)
722 return 0;
723#endif
724#ifdef S_ISDIR
725 if (S_ISDIR(stat_buffer.st_mode))
726 return 2;
727#endif
728#endif /* HAVE_STAT */
729 return 1;
730}
731
732/**
733 * xmlInputReadCallbackNop:
734 *
735 * No Operation xmlInputReadCallback function, does nothing.
736 *
737 * Returns zero
738 */
739int
740xmlInputReadCallbackNop(void *context ATTRIBUTE_UNUSED,
741 char *buffer ATTRIBUTE_UNUSED,
742 int len ATTRIBUTE_UNUSED) {
743 return(0);
744}
745
746/**
747 * xmlFdRead:
748 * @context: the I/O context
749 * @buffer: where to drop data
750 * @len: number of bytes to read
751 *
752 * Read @len bytes to @buffer from the I/O channel.
753 *
754 * Returns the number of bytes written
755 */
756static int
757xmlFdRead (void * context, char * buffer, int len) {
758 int ret;
759
760 ret = read((int) (ptrdiff_t) context, &buffer[0], len);
761 if (ret < 0) xmlIOErr(0, "read()");
762 return(ret);
763}
764
765#ifdef LIBXML_OUTPUT_ENABLED
766/**
767 * xmlFdWrite:
768 * @context: the I/O context
769 * @buffer: where to get data
770 * @len: number of bytes to write
771 *
772 * Write @len bytes from @buffer to the I/O channel.
773 *
774 * Returns the number of bytes written
775 */
776static int
777xmlFdWrite (void * context, const char * buffer, int len) {
778 int ret = 0;
779
780 if (len > 0) {
781 ret = write((int) (ptrdiff_t) context, &buffer[0], len);
782 if (ret < 0) xmlIOErr(0, "write()");
783 }
784 return(ret);
785}
786#endif /* LIBXML_OUTPUT_ENABLED */
787
788/**
789 * xmlFdClose:
790 * @context: the I/O context
791 *
792 * Close an I/O channel
793 *
794 * Returns 0 in case of success and error code otherwise
795 */
796static int
797xmlFdClose (void * context) {
798 int ret;
799 ret = close((int) (ptrdiff_t) context);
800 if (ret < 0) xmlIOErr(0, "close()");
801 return(ret);
802}
803
804/**
805 * xmlFileMatch:
806 * @filename: the URI for matching
807 *
808 * input from FILE *
809 *
810 * Returns 1 if matches, 0 otherwise
811 */
812int
813xmlFileMatch (const char *filename ATTRIBUTE_UNUSED) {
814 return(1);
815}
816
817/**
818 * xmlFileOpen_real:
819 * @filename: the URI for matching
820 *
821 * input from FILE *, supports compressed input
822 * if @filename is " " then the standard input is used
823 *
824 * Returns an I/O context or NULL in case of error
825 */
826static void *
827xmlFileOpen_real (const char *filename) {
828 const char *path = filename;
829 FILE *fd;
830
831 if (filename == NULL)
832 return(NULL);
833
834 if (!strcmp(filename, "-")) {
835 fd = stdin;
836 return((void *) fd);
837 }
838
839 if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file://localhost/", 17)) {
840#if defined (_WIN32) || defined (__DJGPP__) && !defined(__CYGWIN__)
841 path = &filename[17];
842#else
843 path = &filename[16];
844#endif
845 } else if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file:///", 8)) {
846#if defined (_WIN32) || defined (__DJGPP__) && !defined(__CYGWIN__)
847 path = &filename[8];
848#else
849 path = &filename[7];
850#endif
851 } else if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file:/", 6)) {
852 /* lots of generators seems to lazy to read RFC 1738 */
853#if defined (_WIN32) || defined (__DJGPP__) && !defined(__CYGWIN__)
854 path = &filename[6];
855#else
856 path = &filename[5];
857#endif
858 }
859
860 /* Do not check DDNAME on zOS ! */
861#if !defined(__MVS__)
862 if (!xmlCheckFilename(path))
863 return(NULL);
864#endif
865
866#if (defined(_WIN32) || defined (__DJGPP__)) && !defined (__CYGWIN__) && !defined(IPRT_NO_CRT)
867 fd = xmlWrapOpenUtf8(path, 0);
868#else
869 fd = fopen(path, "r");
870#endif /* WIN32 */
871 if (fd == NULL) xmlIOErr(0, path);
872 return((void *) fd);
873}
874
875/**
876 * xmlFileOpen:
877 * @filename: the URI for matching
878 *
879 * Wrapper around xmlFileOpen_real that try it with an unescaped
880 * version of @filename, if this fails fallback to @filename
881 *
882 * Returns a handler or NULL in case or failure
883 */
884void *
885xmlFileOpen (const char *filename) {
886 char *unescaped;
887 void *retval;
888
889 retval = xmlFileOpen_real(filename);
890 if (retval == NULL) {
891 unescaped = xmlURIUnescapeString(filename, 0, NULL);
892 if (unescaped != NULL) {
893 retval = xmlFileOpen_real(unescaped);
894 xmlFree(unescaped);
895 }
896 }
897
898 return retval;
899}
900
901#ifdef LIBXML_OUTPUT_ENABLED
902/**
903 * xmlFileOpenW:
904 * @filename: the URI for matching
905 *
906 * output to from FILE *,
907 * if @filename is "-" then the standard output is used
908 *
909 * Returns an I/O context or NULL in case of error
910 */
911static void *
912xmlFileOpenW (const char *filename) {
913 const char *path = NULL;
914 FILE *fd;
915
916 if (!strcmp(filename, "-")) {
917 fd = stdout;
918 return((void *) fd);
919 }
920
921 if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file://localhost/", 17))
922#if defined (_WIN32) || defined (__DJGPP__) && !defined(__CYGWIN__)
923 path = &filename[17];
924#else
925 path = &filename[16];
926#endif
927 else if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file:///", 8)) {
928#if defined (_WIN32) || defined (__DJGPP__) && !defined(__CYGWIN__)
929 path = &filename[8];
930#else
931 path = &filename[7];
932#endif
933 } else
934 path = filename;
935
936 if (path == NULL)
937 return(NULL);
938
939#if (defined(_WIN32) || defined (__DJGPP__)) && !defined (__CYGWIN__) && !defined(IPRT_NO_CRT)
940 fd = xmlWrapOpenUtf8(path, 1);
941#elif(__MVS__)
942 fd = fopen(path, "w");
943#else
944 fd = fopen(path, "wb");
945#endif /* WIN32 */
946
947 if (fd == NULL) xmlIOErr(0, path);
948 return((void *) fd);
949}
950#endif /* LIBXML_OUTPUT_ENABLED */
951
952/**
953 * xmlFileRead:
954 * @context: the I/O context
955 * @buffer: where to drop data
956 * @len: number of bytes to write
957 *
958 * Read @len bytes to @buffer from the I/O channel.
959 *
960 * Returns the number of bytes written or < 0 in case of failure
961 */
962int
963xmlFileRead (void * context, char * buffer, int len) {
964 int ret;
965 if ((context == NULL) || (buffer == NULL))
966 return(-1);
967 ret = fread(&buffer[0], 1, len, (FILE *) context);
968 if (ret < 0) xmlIOErr(0, "fread()");
969 return(ret);
970}
971
972#ifdef LIBXML_OUTPUT_ENABLED
973/**
974 * xmlFileWrite:
975 * @context: the I/O context
976 * @buffer: where to drop data
977 * @len: number of bytes to write
978 *
979 * Write @len bytes from @buffer to the I/O channel.
980 *
981 * Returns the number of bytes written
982 */
983static int
984xmlFileWrite (void * context, const char * buffer, int len) {
985 int items;
986
987 if ((context == NULL) || (buffer == NULL))
988 return(-1);
989 items = fwrite(&buffer[0], len, 1, (FILE *) context);
990 if ((items == 0) && (ferror((FILE *) context))) {
991 xmlIOErr(0, "fwrite()");
992 return(-1);
993 }
994 return(items * len);
995}
996#endif /* LIBXML_OUTPUT_ENABLED */
997
998/**
999 * xmlFileClose:
1000 * @context: the I/O context
1001 *
1002 * Close an I/O channel
1003 *
1004 * Returns 0 or -1 in case of error
1005 */
1006int
1007xmlFileClose (void * context) {
1008 FILE *fil;
1009 int ret;
1010
1011 if (context == NULL)
1012 return(-1);
1013 fil = (FILE *) context;
1014 if ((fil == stdout) || (fil == stderr)) {
1015 ret = fflush(fil);
1016 if (ret < 0)
1017 xmlIOErr(0, "fflush()");
1018 return(0);
1019 }
1020 if (fil == stdin)
1021 return(0);
1022 ret = ( fclose((FILE *) context) == EOF ) ? -1 : 0;
1023 if (ret < 0)
1024 xmlIOErr(0, "fclose()");
1025 return(ret);
1026}
1027
1028/**
1029 * xmlFileFlush:
1030 * @context: the I/O context
1031 *
1032 * Flush an I/O channel
1033 */
1034static int
1035xmlFileFlush (void * context) {
1036 int ret;
1037
1038 if (context == NULL)
1039 return(-1);
1040 ret = ( fflush((FILE *) context) == EOF ) ? -1 : 0;
1041 if (ret < 0)
1042 xmlIOErr(0, "fflush()");
1043 return(ret);
1044}
1045
1046#ifdef LIBXML_OUTPUT_ENABLED
1047/**
1048 * xmlBufferWrite:
1049 * @context: the xmlBuffer
1050 * @buffer: the data to write
1051 * @len: number of bytes to write
1052 *
1053 * Write @len bytes from @buffer to the xml buffer
1054 *
1055 * Returns the number of bytes written
1056 */
1057static int
1058xmlBufferWrite (void * context, const char * buffer, int len) {
1059 int ret;
1060
1061 ret = xmlBufferAdd((xmlBufferPtr) context, (const xmlChar *) buffer, len);
1062 if (ret != 0)
1063 return(-1);
1064 return(len);
1065}
1066#endif
1067
1068#ifdef LIBXML_ZLIB_ENABLED
1069/************************************************************************
1070 * *
1071 * I/O for compressed file accesses *
1072 * *
1073 ************************************************************************/
1074/**
1075 * xmlGzfileMatch:
1076 * @filename: the URI for matching
1077 *
1078 * input from compressed file test
1079 *
1080 * Returns 1 if matches, 0 otherwise
1081 */
1082static int
1083xmlGzfileMatch (const char *filename ATTRIBUTE_UNUSED) {
1084 return(1);
1085}
1086
1087/**
1088 * xmlGzfileOpen_real:
1089 * @filename: the URI for matching
1090 *
1091 * input from compressed file open
1092 * if @filename is " " then the standard input is used
1093 *
1094 * Returns an I/O context or NULL in case of error
1095 */
1096static void *
1097xmlGzfileOpen_real (const char *filename) {
1098 const char *path = NULL;
1099 gzFile fd;
1100
1101 if (!strcmp(filename, "-")) {
1102 int duped_fd = dup(fileno(stdin));
1103 fd = gzdopen(duped_fd, "rb");
1104 if (fd == Z_NULL && duped_fd >= 0) {
1105 close(duped_fd); /* gzdOpen() does not close on failure */
1106 }
1107
1108 return((void *) fd);
1109 }
1110
1111 if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file://localhost/", 17))
1112#if defined (_WIN32) || defined (__DJGPP__) && !defined(__CYGWIN__)
1113 path = &filename[17];
1114#else
1115 path = &filename[16];
1116#endif
1117 else if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file:///", 8)) {
1118#if defined (_WIN32) || defined (__DJGPP__) && !defined(__CYGWIN__)
1119 path = &filename[8];
1120#else
1121 path = &filename[7];
1122#endif
1123 } else
1124 path = filename;
1125
1126 if (path == NULL)
1127 return(NULL);
1128 if (!xmlCheckFilename(path))
1129 return(NULL);
1130
1131#if (defined(_WIN32) || defined (__DJGPP__)) && !defined (__CYGWIN__) && !defined(IPRT_NO_CRT)
1132 fd = xmlWrapGzOpenUtf8(path, "rb");
1133#else
1134 fd = gzopen(path, "rb");
1135#endif
1136 return((void *) fd);
1137}
1138
1139/**
1140 * xmlGzfileOpen:
1141 * @filename: the URI for matching
1142 *
1143 * Wrapper around xmlGzfileOpen if the open fais, it will
1144 * try to unescape @filename
1145 */
1146static void *
1147xmlGzfileOpen (const char *filename) {
1148 char *unescaped;
1149 void *retval;
1150
1151 retval = xmlGzfileOpen_real(filename);
1152 if (retval == NULL) {
1153 unescaped = xmlURIUnescapeString(filename, 0, NULL);
1154 if (unescaped != NULL) {
1155 retval = xmlGzfileOpen_real(unescaped);
1156 }
1157 xmlFree(unescaped);
1158 }
1159 return retval;
1160}
1161
1162#ifdef LIBXML_OUTPUT_ENABLED
1163/**
1164 * xmlGzfileOpenW:
1165 * @filename: the URI for matching
1166 * @compression: the compression factor (0 - 9 included)
1167 *
1168 * input from compressed file open
1169 * if @filename is " " then the standard input is used
1170 *
1171 * Returns an I/O context or NULL in case of error
1172 */
1173static void *
1174xmlGzfileOpenW (const char *filename, int compression) {
1175 const char *path = NULL;
1176 char mode[15];
1177 gzFile fd;
1178
1179 snprintf(mode, sizeof(mode), "wb%d", compression);
1180 if (!strcmp(filename, "-")) {
1181 int duped_fd = dup(fileno(stdout));
1182 fd = gzdopen(duped_fd, "rb");
1183 if (fd == Z_NULL && duped_fd >= 0) {
1184 close(duped_fd); /* gzdOpen() does not close on failure */
1185 }
1186
1187 return((void *) fd);
1188 }
1189
1190 if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file://localhost/", 17))
1191#if defined (_WIN32) || defined (__DJGPP__) && !defined(__CYGWIN__)
1192 path = &filename[17];
1193#else
1194 path = &filename[16];
1195#endif
1196 else if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file:///", 8)) {
1197#if defined (_WIN32) || defined (__DJGPP__) && !defined(__CYGWIN__)
1198 path = &filename[8];
1199#else
1200 path = &filename[7];
1201#endif
1202 } else
1203 path = filename;
1204
1205 if (path == NULL)
1206 return(NULL);
1207
1208#if (defined(_WIN32) || defined (__DJGPP__)) && !defined (__CYGWIN__) && !defined(IPRT_NO_CRT)
1209 fd = xmlWrapGzOpenUtf8(path, mode);
1210#else
1211 fd = gzopen(path, mode);
1212#endif
1213 return((void *) fd);
1214}
1215#endif /* LIBXML_OUTPUT_ENABLED */
1216
1217/**
1218 * xmlGzfileRead:
1219 * @context: the I/O context
1220 * @buffer: where to drop data
1221 * @len: number of bytes to write
1222 *
1223 * Read @len bytes to @buffer from the compressed I/O channel.
1224 *
1225 * Returns the number of bytes read.
1226 */
1227static int
1228xmlGzfileRead (void * context, char * buffer, int len) {
1229 int ret;
1230
1231 ret = gzread((gzFile) context, &buffer[0], len);
1232 if (ret < 0) xmlIOErr(0, "gzread()");
1233 return(ret);
1234}
1235
1236#ifdef LIBXML_OUTPUT_ENABLED
1237/**
1238 * xmlGzfileWrite:
1239 * @context: the I/O context
1240 * @buffer: where to drop data
1241 * @len: number of bytes to write
1242 *
1243 * Write @len bytes from @buffer to the compressed I/O channel.
1244 *
1245 * Returns the number of bytes written
1246 */
1247static int
1248xmlGzfileWrite (void * context, const char * buffer, int len) {
1249 int ret;
1250
1251 ret = gzwrite((gzFile) context, (char *) &buffer[0], len);
1252 if (ret < 0) xmlIOErr(0, "gzwrite()");
1253 return(ret);
1254}
1255#endif /* LIBXML_OUTPUT_ENABLED */
1256
1257/**
1258 * xmlGzfileClose:
1259 * @context: the I/O context
1260 *
1261 * Close a compressed I/O channel
1262 */
1263static int
1264xmlGzfileClose (void * context) {
1265 int ret;
1266
1267 ret = (gzclose((gzFile) context) == Z_OK ) ? 0 : -1;
1268 if (ret < 0) xmlIOErr(0, "gzclose()");
1269 return(ret);
1270}
1271#endif /* LIBXML_ZLIB_ENABLED */
1272
1273#ifdef LIBXML_LZMA_ENABLED
1274/************************************************************************
1275 * *
1276 * I/O for compressed file accesses *
1277 * *
1278 ************************************************************************/
1279#include "xzlib.h"
1280/**
1281 * xmlXzfileMatch:
1282 * @filename: the URI for matching
1283 *
1284 * input from compressed file test
1285 *
1286 * Returns 1 if matches, 0 otherwise
1287 */
1288static int
1289xmlXzfileMatch (const char *filename ATTRIBUTE_UNUSED) {
1290 return(1);
1291}
1292
1293/**
1294 * xmlXzFileOpen_real:
1295 * @filename: the URI for matching
1296 *
1297 * input from compressed file open
1298 * if @filename is " " then the standard input is used
1299 *
1300 * Returns an I/O context or NULL in case of error
1301 */
1302static void *
1303xmlXzfileOpen_real (const char *filename) {
1304 const char *path = NULL;
1305 xzFile fd;
1306
1307 if (!strcmp(filename, "-")) {
1308 fd = __libxml2_xzdopen(dup(fileno(stdin)), "rb");
1309 return((void *) fd);
1310 }
1311
1312 if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file://localhost/", 17)) {
1313 path = &filename[16];
1314 } else if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file:///", 8)) {
1315 path = &filename[7];
1316 } else if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file:/", 6)) {
1317 /* lots of generators seems to lazy to read RFC 1738 */
1318 path = &filename[5];
1319 } else
1320 path = filename;
1321
1322 if (path == NULL)
1323 return(NULL);
1324 if (!xmlCheckFilename(path))
1325 return(NULL);
1326
1327 fd = __libxml2_xzopen(path, "rb");
1328 return((void *) fd);
1329}
1330
1331/**
1332 * xmlXzfileOpen:
1333 * @filename: the URI for matching
1334 *
1335 * Wrapper around xmlXzfileOpen_real that try it with an unescaped
1336 * version of @filename, if this fails fallback to @filename
1337 *
1338 * Returns a handler or NULL in case or failure
1339 */
1340static void *
1341xmlXzfileOpen (const char *filename) {
1342 char *unescaped;
1343 void *retval;
1344
1345 retval = xmlXzfileOpen_real(filename);
1346 if (retval == NULL) {
1347 unescaped = xmlURIUnescapeString(filename, 0, NULL);
1348 if (unescaped != NULL) {
1349 retval = xmlXzfileOpen_real(unescaped);
1350 }
1351 xmlFree(unescaped);
1352 }
1353
1354 return retval;
1355}
1356
1357/**
1358 * xmlXzfileRead:
1359 * @context: the I/O context
1360 * @buffer: where to drop data
1361 * @len: number of bytes to write
1362 *
1363 * Read @len bytes to @buffer from the compressed I/O channel.
1364 *
1365 * Returns the number of bytes written
1366 */
1367static int
1368xmlXzfileRead (void * context, char * buffer, int len) {
1369 int ret;
1370
1371 ret = __libxml2_xzread((xzFile) context, &buffer[0], len);
1372 if (ret < 0) xmlIOErr(0, "xzread()");
1373 return(ret);
1374}
1375
1376/**
1377 * xmlXzfileClose:
1378 * @context: the I/O context
1379 *
1380 * Close a compressed I/O channel
1381 */
1382static int
1383xmlXzfileClose (void * context) {
1384 int ret;
1385
1386 ret = (__libxml2_xzclose((xzFile) context) == LZMA_OK ) ? 0 : -1;
1387 if (ret < 0) xmlIOErr(0, "xzclose()");
1388 return(ret);
1389}
1390#endif /* LIBXML_LZMA_ENABLED */
1391
1392#ifdef LIBXML_HTTP_ENABLED
1393/************************************************************************
1394 * *
1395 * I/O for HTTP file accesses *
1396 * *
1397 ************************************************************************/
1398
1399#ifdef LIBXML_OUTPUT_ENABLED
1400typedef struct xmlIOHTTPWriteCtxt_
1401{
1402 int compression;
1403
1404 char * uri;
1405
1406 void * doc_buff;
1407
1408} xmlIOHTTPWriteCtxt, *xmlIOHTTPWriteCtxtPtr;
1409
1410#ifdef LIBXML_ZLIB_ENABLED
1411
1412#define DFLT_WBITS ( -15 )
1413#define DFLT_MEM_LVL ( 8 )
1414#define GZ_MAGIC1 ( 0x1f )
1415#define GZ_MAGIC2 ( 0x8b )
1416#define LXML_ZLIB_OS_CODE ( 0x03 )
1417#define INIT_HTTP_BUFF_SIZE ( 32768 )
1418#define DFLT_ZLIB_RATIO ( 5 )
1419
1420/*
1421** Data structure and functions to work with sending compressed data
1422** via HTTP.
1423*/
1424
1425typedef struct xmlZMemBuff_
1426{
1427 unsigned long size;
1428 unsigned long crc;
1429
1430 unsigned char * zbuff;
1431 z_stream zctrl;
1432
1433} xmlZMemBuff, *xmlZMemBuffPtr;
1434
1435/**
1436 * append_reverse_ulong
1437 * @buff: Compressed memory buffer
1438 * @data: Unsigned long to append
1439 *
1440 * Append a unsigned long in reverse byte order to the end of the
1441 * memory buffer.
1442 */
1443static void
1444append_reverse_ulong( xmlZMemBuff * buff, unsigned long data ) {
1445
1446 int idx;
1447
1448 if ( buff == NULL )
1449 return;
1450
1451 /*
1452 ** This is plagiarized from putLong in gzio.c (zlib source) where
1453 ** the number "4" is hardcoded. If zlib is ever patched to
1454 ** support 64 bit file sizes, this code would need to be patched
1455 ** as well.
1456 */
1457
1458 for ( idx = 0; idx < 4; idx++ ) {
1459 *buff->zctrl.next_out = ( data & 0xff );
1460 data >>= 8;
1461 buff->zctrl.next_out++;
1462 }
1463
1464 return;
1465}
1466
1467/**
1468 *
1469 * xmlFreeZMemBuff
1470 * @buff: The memory buffer context to clear
1471 *
1472 * Release all the resources associated with the compressed memory buffer.
1473 */
1474static void
1475xmlFreeZMemBuff( xmlZMemBuffPtr buff ) {
1476
1477#ifdef DEBUG_HTTP
1478 int z_err;
1479#endif
1480
1481 if ( buff == NULL )
1482 return;
1483
1484 xmlFree( buff->zbuff );
1485#ifdef DEBUG_HTTP
1486 z_err = deflateEnd( &buff->zctrl );
1487 if ( z_err != Z_OK )
1488 xmlGenericError( xmlGenericErrorContext,
1489 "xmlFreeZMemBuff: Error releasing zlib context: %d\n",
1490 z_err );
1491#else
1492 deflateEnd( &buff->zctrl );
1493#endif
1494
1495 xmlFree( buff );
1496 return;
1497}
1498
1499/**
1500 * xmlCreateZMemBuff
1501 *@compression: Compression value to use
1502 *
1503 * Create a memory buffer to hold the compressed XML document. The
1504 * compressed document in memory will end up being identical to what
1505 * would be created if gzopen/gzwrite/gzclose were being used to
1506 * write the document to disk. The code for the header/trailer data to
1507 * the compression is plagiarized from the zlib source files.
1508 */
1509static void *
1510xmlCreateZMemBuff( int compression ) {
1511
1512 int z_err;
1513 int hdr_lgth;
1514 xmlZMemBuffPtr buff = NULL;
1515
1516 if ( ( compression < 1 ) || ( compression > 9 ) )
1517 return ( NULL );
1518
1519 /* Create the control and data areas */
1520
1521 buff = xmlMalloc( sizeof( xmlZMemBuff ) );
1522 if ( buff == NULL ) {
1523 xmlIOErrMemory("creating buffer context");
1524 return ( NULL );
1525 }
1526
1527 (void)memset( buff, 0, sizeof( xmlZMemBuff ) );
1528 buff->size = INIT_HTTP_BUFF_SIZE;
1529 buff->zbuff = xmlMalloc( buff->size );
1530 if ( buff->zbuff == NULL ) {
1531 xmlFreeZMemBuff( buff );
1532 xmlIOErrMemory("creating buffer");
1533 return ( NULL );
1534 }
1535
1536 z_err = deflateInit2( &buff->zctrl, compression, Z_DEFLATED,
1537 DFLT_WBITS, DFLT_MEM_LVL, Z_DEFAULT_STRATEGY );
1538 if ( z_err != Z_OK ) {
1539 xmlChar msg[500];
1540 xmlFreeZMemBuff( buff );
1541 buff = NULL;
1542 xmlStrPrintf(msg, 500,
1543 "xmlCreateZMemBuff: %s %d\n",
1544 "Error initializing compression context. ZLIB error:",
1545 z_err );
1546 xmlIOErr(XML_IO_WRITE, (const char *) msg);
1547 return ( NULL );
1548 }
1549
1550 /* Set the header data. The CRC will be needed for the trailer */
1551 buff->crc = crc32( 0L, NULL, 0 );
1552 hdr_lgth = snprintf( (char *)buff->zbuff, buff->size,
1553 "%c%c%c%c%c%c%c%c%c%c",
1554 GZ_MAGIC1, GZ_MAGIC2, Z_DEFLATED,
1555 0, 0, 0, 0, 0, 0, LXML_ZLIB_OS_CODE );
1556 buff->zctrl.next_out = buff->zbuff + hdr_lgth;
1557 buff->zctrl.avail_out = buff->size - hdr_lgth;
1558
1559 return ( buff );
1560}
1561
1562/**
1563 * xmlZMemBuffExtend
1564 * @buff: Buffer used to compress and consolidate data.
1565 * @ext_amt: Number of bytes to extend the buffer.
1566 *
1567 * Extend the internal buffer used to store the compressed data by the
1568 * specified amount.
1569 *
1570 * Returns 0 on success or -1 on failure to extend the buffer. On failure
1571 * the original buffer still exists at the original size.
1572 */
1573static int
1574xmlZMemBuffExtend( xmlZMemBuffPtr buff, size_t ext_amt ) {
1575
1576 int rc = -1;
1577 size_t new_size;
1578 size_t cur_used;
1579
1580 unsigned char * tmp_ptr = NULL;
1581
1582 if ( buff == NULL )
1583 return ( -1 );
1584
1585 else if ( ext_amt == 0 )
1586 return ( 0 );
1587
1588 cur_used = buff->zctrl.next_out - buff->zbuff;
1589 new_size = buff->size + ext_amt;
1590
1591#ifdef DEBUG_HTTP
1592 if ( cur_used > new_size )
1593 xmlGenericError( xmlGenericErrorContext,
1594 "xmlZMemBuffExtend: %s\n%s %d bytes.\n",
1595 "Buffer overwrite detected during compressed memory",
1596 "buffer extension. Overflowed by",
1597 (cur_used - new_size ) );
1598#endif
1599
1600 tmp_ptr = xmlRealloc( buff->zbuff, new_size );
1601 if ( tmp_ptr != NULL ) {
1602 rc = 0;
1603 buff->size = new_size;
1604 buff->zbuff = tmp_ptr;
1605 buff->zctrl.next_out = tmp_ptr + cur_used;
1606 buff->zctrl.avail_out = new_size - cur_used;
1607 }
1608 else {
1609 xmlChar msg[500];
1610 xmlStrPrintf(msg, 500,
1611 "xmlZMemBuffExtend: %s %lu bytes.\n",
1612 "Allocation failure extending output buffer to",
1613 (unsigned long) new_size );
1614 xmlIOErr(XML_IO_WRITE, (const char *) msg);
1615 }
1616
1617 return ( rc );
1618}
1619
1620/**
1621 * xmlZMemBuffAppend
1622 * @buff: Buffer used to compress and consolidate data
1623 * @src: Uncompressed source content to append to buffer
1624 * @len: Length of source data to append to buffer
1625 *
1626 * Compress and append data to the internal buffer. The data buffer
1627 * will be expanded if needed to store the additional data.
1628 *
1629 * Returns the number of bytes appended to the buffer or -1 on error.
1630 */
1631static int
1632xmlZMemBuffAppend( xmlZMemBuffPtr buff, const char * src, int len ) {
1633
1634 int z_err;
1635 size_t min_accept;
1636
1637 if ( ( buff == NULL ) || ( src == NULL ) )
1638 return ( -1 );
1639
1640 buff->zctrl.avail_in = len;
1641 buff->zctrl.next_in = (unsigned char *)src;
1642 while ( buff->zctrl.avail_in > 0 ) {
1643 /*
1644 ** Extend the buffer prior to deflate call if a reasonable amount
1645 ** of output buffer space is not available.
1646 */
1647 min_accept = buff->zctrl.avail_in / DFLT_ZLIB_RATIO;
1648 if ( buff->zctrl.avail_out <= min_accept ) {
1649 if ( xmlZMemBuffExtend( buff, buff->size ) == -1 )
1650 return ( -1 );
1651 }
1652
1653 z_err = deflate( &buff->zctrl, Z_NO_FLUSH );
1654 if ( z_err != Z_OK ) {
1655 xmlChar msg[500];
1656 xmlStrPrintf(msg, 500,
1657 "xmlZMemBuffAppend: %s %d %s - %d",
1658 "Compression error while appending",
1659 len, "bytes to buffer. ZLIB error", z_err );
1660 xmlIOErr(XML_IO_WRITE, (const char *) msg);
1661 return ( -1 );
1662 }
1663 }
1664
1665 buff->crc = crc32( buff->crc, (unsigned char *)src, len );
1666
1667 return ( len );
1668}
1669
1670/**
1671 * xmlZMemBuffGetContent
1672 * @buff: Compressed memory content buffer
1673 * @data_ref: Pointer reference to point to compressed content
1674 *
1675 * Flushes the compression buffers, appends gzip file trailers and
1676 * returns the compressed content and length of the compressed data.
1677 * NOTE: The gzip trailer code here is plagiarized from zlib source.
1678 *
1679 * Returns the length of the compressed data or -1 on error.
1680 */
1681static int
1682xmlZMemBuffGetContent( xmlZMemBuffPtr buff, char ** data_ref ) {
1683
1684 int zlgth = -1;
1685 int z_err;
1686
1687 if ( ( buff == NULL ) || ( data_ref == NULL ) )
1688 return ( -1 );
1689
1690 /* Need to loop until compression output buffers are flushed */
1691
1692 do
1693 {
1694 z_err = deflate( &buff->zctrl, Z_FINISH );
1695 if ( z_err == Z_OK ) {
1696 /* In this case Z_OK means more buffer space needed */
1697
1698 if ( xmlZMemBuffExtend( buff, buff->size ) == -1 )
1699 return ( -1 );
1700 }
1701 }
1702 while ( z_err == Z_OK );
1703
1704 /* If the compression state is not Z_STREAM_END, some error occurred */
1705
1706 if ( z_err == Z_STREAM_END ) {
1707
1708 /* Need to append the gzip data trailer */
1709
1710 if ( buff->zctrl.avail_out < ( 2 * sizeof( unsigned long ) ) ) {
1711 if ( xmlZMemBuffExtend(buff, (2 * sizeof(unsigned long))) == -1 )
1712 return ( -1 );
1713 }
1714
1715 /*
1716 ** For whatever reason, the CRC and length data are pushed out
1717 ** in reverse byte order. So a memcpy can't be used here.
1718 */
1719
1720 append_reverse_ulong( buff, buff->crc );
1721 append_reverse_ulong( buff, buff->zctrl.total_in );
1722
1723 zlgth = buff->zctrl.next_out - buff->zbuff;
1724 *data_ref = (char *)buff->zbuff;
1725 }
1726
1727 else {
1728 xmlChar msg[500];
1729 xmlStrPrintf(msg, 500,
1730 "xmlZMemBuffGetContent: %s - %d\n",
1731 "Error flushing zlib buffers. Error code", z_err );
1732 xmlIOErr(XML_IO_WRITE, (const char *) msg);
1733 }
1734
1735 return ( zlgth );
1736}
1737#endif /* LIBXML_OUTPUT_ENABLED */
1738#endif /* LIBXML_ZLIB_ENABLED */
1739
1740#ifdef LIBXML_OUTPUT_ENABLED
1741/**
1742 * xmlFreeHTTPWriteCtxt
1743 * @ctxt: Context to cleanup
1744 *
1745 * Free allocated memory and reclaim system resources.
1746 *
1747 * No return value.
1748 */
1749static void
1750xmlFreeHTTPWriteCtxt( xmlIOHTTPWriteCtxtPtr ctxt )
1751{
1752 if ( ctxt->uri != NULL )
1753 xmlFree( ctxt->uri );
1754
1755 if ( ctxt->doc_buff != NULL ) {
1756
1757#ifdef LIBXML_ZLIB_ENABLED
1758 if ( ctxt->compression > 0 ) {
1759 xmlFreeZMemBuff( ctxt->doc_buff );
1760 }
1761 else
1762#endif
1763 {
1764 xmlOutputBufferClose( ctxt->doc_buff );
1765 }
1766 }
1767
1768 xmlFree( ctxt );
1769 return;
1770}
1771#endif /* LIBXML_OUTPUT_ENABLED */
1772
1773
1774/**
1775 * xmlIOHTTPMatch:
1776 * @filename: the URI for matching
1777 *
1778 * check if the URI matches an HTTP one
1779 *
1780 * Returns 1 if matches, 0 otherwise
1781 */
1782int
1783xmlIOHTTPMatch (const char *filename) {
1784 if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "http://", 7))
1785 return(1);
1786 return(0);
1787}
1788
1789/**
1790 * xmlIOHTTPOpen:
1791 * @filename: the URI for matching
1792 *
1793 * open an HTTP I/O channel
1794 *
1795 * Returns an I/O context or NULL in case of error
1796 */
1797void *
1798xmlIOHTTPOpen (const char *filename) {
1799 return(xmlNanoHTTPOpen(filename, NULL));
1800}
1801
1802#ifdef LIBXML_OUTPUT_ENABLED
1803/**
1804 * xmlIOHTTPOpenW:
1805 * @post_uri: The destination URI for the document
1806 * @compression: The compression desired for the document.
1807 *
1808 * Open a temporary buffer to collect the document for a subsequent HTTP POST
1809 * request. Non-static as is called from the output buffer creation routine.
1810 *
1811 * Returns an I/O context or NULL in case of error.
1812 */
1813
1814void *
1815xmlIOHTTPOpenW(const char *post_uri, int compression ATTRIBUTE_UNUSED)
1816{
1817
1818 xmlIOHTTPWriteCtxtPtr ctxt = NULL;
1819
1820 if (post_uri == NULL)
1821 return (NULL);
1822
1823 ctxt = xmlMalloc(sizeof(xmlIOHTTPWriteCtxt));
1824 if (ctxt == NULL) {
1825 xmlIOErrMemory("creating HTTP output context");
1826 return (NULL);
1827 }
1828
1829 (void) memset(ctxt, 0, sizeof(xmlIOHTTPWriteCtxt));
1830
1831 ctxt->uri = (char *) xmlStrdup((const xmlChar *)post_uri);
1832 if (ctxt->uri == NULL) {
1833 xmlIOErrMemory("copying URI");
1834 xmlFreeHTTPWriteCtxt(ctxt);
1835 return (NULL);
1836 }
1837
1838 /*
1839 * ** Since the document length is required for an HTTP post,
1840 * ** need to put the document into a buffer. A memory buffer
1841 * ** is being used to avoid pushing the data to disk and back.
1842 */
1843
1844#ifdef LIBXML_ZLIB_ENABLED
1845 if ((compression > 0) && (compression <= 9)) {
1846
1847 ctxt->compression = compression;
1848 ctxt->doc_buff = xmlCreateZMemBuff(compression);
1849 } else
1850#endif
1851 {
1852 /* Any character conversions should have been done before this */
1853
1854 ctxt->doc_buff = xmlAllocOutputBufferInternal(NULL);
1855 }
1856
1857 if (ctxt->doc_buff == NULL) {
1858 xmlFreeHTTPWriteCtxt(ctxt);
1859 ctxt = NULL;
1860 }
1861
1862 return (ctxt);
1863}
1864#endif /* LIBXML_OUTPUT_ENABLED */
1865
1866#ifdef LIBXML_OUTPUT_ENABLED
1867/**
1868 * xmlIOHTTPDfltOpenW
1869 * @post_uri: The destination URI for this document.
1870 *
1871 * Calls xmlIOHTTPOpenW with no compression to set up for a subsequent
1872 * HTTP post command. This function should generally not be used as
1873 * the open callback is short circuited in xmlOutputBufferCreateFile.
1874 *
1875 * Returns a pointer to the new IO context.
1876 */
1877static void *
1878xmlIOHTTPDfltOpenW( const char * post_uri ) {
1879 return ( xmlIOHTTPOpenW( post_uri, 0 ) );
1880}
1881#endif /* LIBXML_OUTPUT_ENABLED */
1882
1883/**
1884 * xmlIOHTTPRead:
1885 * @context: the I/O context
1886 * @buffer: where to drop data
1887 * @len: number of bytes to write
1888 *
1889 * Read @len bytes to @buffer from the I/O channel.
1890 *
1891 * Returns the number of bytes written
1892 */
1893int
1894xmlIOHTTPRead(void * context, char * buffer, int len) {
1895 if ((buffer == NULL) || (len < 0)) return(-1);
1896 return(xmlNanoHTTPRead(context, &buffer[0], len));
1897}
1898
1899#ifdef LIBXML_OUTPUT_ENABLED
1900/**
1901 * xmlIOHTTPWrite
1902 * @context: previously opened writing context
1903 * @buffer: data to output to temporary buffer
1904 * @len: bytes to output
1905 *
1906 * Collect data from memory buffer into a temporary file for later
1907 * processing.
1908 *
1909 * Returns number of bytes written.
1910 */
1911
1912static int
1913xmlIOHTTPWrite( void * context, const char * buffer, int len ) {
1914
1915 xmlIOHTTPWriteCtxtPtr ctxt = context;
1916
1917 if ( ( ctxt == NULL ) || ( ctxt->doc_buff == NULL ) || ( buffer == NULL ) )
1918 return ( -1 );
1919
1920 if ( len > 0 ) {
1921
1922 /* Use gzwrite or fwrite as previously setup in the open call */
1923
1924#ifdef LIBXML_ZLIB_ENABLED
1925 if ( ctxt->compression > 0 )
1926 len = xmlZMemBuffAppend( ctxt->doc_buff, buffer, len );
1927
1928 else
1929#endif
1930 len = xmlOutputBufferWrite( ctxt->doc_buff, len, buffer );
1931
1932 if ( len < 0 ) {
1933 xmlChar msg[500];
1934 xmlStrPrintf(msg, 500,
1935 "xmlIOHTTPWrite: %s\n%s '%s'.\n",
1936 "Error appending to internal buffer.",
1937 "Error sending document to URI",
1938 ctxt->uri );
1939 xmlIOErr(XML_IO_WRITE, (const char *) msg);
1940 }
1941 }
1942
1943 return ( len );
1944}
1945#endif /* LIBXML_OUTPUT_ENABLED */
1946
1947
1948/**
1949 * xmlIOHTTPClose:
1950 * @context: the I/O context
1951 *
1952 * Close an HTTP I/O channel
1953 *
1954 * Returns 0
1955 */
1956int
1957xmlIOHTTPClose (void * context) {
1958 xmlNanoHTTPClose(context);
1959 return 0;
1960}
1961
1962#ifdef LIBXML_OUTPUT_ENABLED
1963/**
1964 * xmlIOHTTCloseWrite
1965 * @context: The I/O context
1966 * @http_mthd: The HTTP method to be used when sending the data
1967 *
1968 * Close the transmit HTTP I/O channel and actually send the data.
1969 */
1970static int
1971xmlIOHTTPCloseWrite( void * context, const char * http_mthd ) {
1972
1973 int close_rc = -1;
1974 int http_rtn = 0;
1975 int content_lgth = 0;
1976 xmlIOHTTPWriteCtxtPtr ctxt = context;
1977
1978 char * http_content = NULL;
1979 char * content_encoding = NULL;
1980 char * content_type = (char *) "text/xml";
1981 void * http_ctxt = NULL;
1982
1983 if ( ( ctxt == NULL ) || ( http_mthd == NULL ) )
1984 return ( -1 );
1985
1986 /* Retrieve the content from the appropriate buffer */
1987
1988#ifdef LIBXML_ZLIB_ENABLED
1989
1990 if ( ctxt->compression > 0 ) {
1991 content_lgth = xmlZMemBuffGetContent( ctxt->doc_buff, &http_content );
1992 content_encoding = (char *) "Content-Encoding: gzip";
1993 }
1994 else
1995#endif
1996 {
1997 /* Pull the data out of the memory output buffer */
1998
1999 xmlOutputBufferPtr dctxt = ctxt->doc_buff;
2000 http_content = (char *) xmlBufContent(dctxt->buffer);
2001 content_lgth = xmlBufUse(dctxt->buffer);
2002 }
2003
2004 if ( http_content == NULL ) {
2005 xmlChar msg[500];
2006 xmlStrPrintf(msg, 500,
2007 "xmlIOHTTPCloseWrite: %s '%s' %s '%s'.\n",
2008 "Error retrieving content.\nUnable to",
2009 http_mthd, "data to URI", ctxt->uri );
2010 xmlIOErr(XML_IO_WRITE, (const char *) msg);
2011 }
2012
2013 else {
2014
2015 http_ctxt = xmlNanoHTTPMethod( ctxt->uri, http_mthd, http_content,
2016 &content_type, content_encoding,
2017 content_lgth );
2018
2019 if ( http_ctxt != NULL ) {
2020#ifdef DEBUG_HTTP
2021 /* If testing/debugging - dump reply with request content */
2022
2023 FILE * tst_file = NULL;
2024 char buffer[ 4096 ];
2025 char * dump_name = NULL;
2026 int avail;
2027
2028 xmlGenericError( xmlGenericErrorContext,
2029 "xmlNanoHTTPCloseWrite: HTTP %s to\n%s returned %d.\n",
2030 http_mthd, ctxt->uri,
2031 xmlNanoHTTPReturnCode( http_ctxt ) );
2032
2033 /*
2034 ** Since either content or reply may be gzipped,
2035 ** dump them to separate files instead of the
2036 ** standard error context.
2037 */
2038
2039 dump_name = tempnam( NULL, "lxml" );
2040 if ( dump_name != NULL ) {
2041 (void)snprintf( buffer, sizeof(buffer), "%s.content", dump_name );
2042
2043 tst_file = fopen( buffer, "wb" );
2044 if ( tst_file != NULL ) {
2045 xmlGenericError( xmlGenericErrorContext,
2046 "Transmitted content saved in file: %s\n", buffer );
2047
2048 fwrite( http_content, sizeof( char ),
2049 content_lgth, tst_file );
2050 fclose( tst_file );
2051 }
2052
2053 (void)snprintf( buffer, sizeof(buffer), "%s.reply", dump_name );
2054 tst_file = fopen( buffer, "wb" );
2055 if ( tst_file != NULL ) {
2056 xmlGenericError( xmlGenericErrorContext,
2057 "Reply content saved in file: %s\n", buffer );
2058
2059
2060 while ( (avail = xmlNanoHTTPRead( http_ctxt,
2061 buffer, sizeof( buffer ) )) > 0 ) {
2062
2063 fwrite( buffer, sizeof( char ), avail, tst_file );
2064 }
2065
2066 fclose( tst_file );
2067 }
2068
2069 free( dump_name );
2070 }
2071#endif /* DEBUG_HTTP */
2072
2073 http_rtn = xmlNanoHTTPReturnCode( http_ctxt );
2074 if ( ( http_rtn >= 200 ) && ( http_rtn < 300 ) )
2075 close_rc = 0;
2076 else {
2077 xmlChar msg[500];
2078 xmlStrPrintf(msg, 500,
2079 "xmlIOHTTPCloseWrite: HTTP '%s' of %d %s\n'%s' %s %d\n",
2080 http_mthd, content_lgth,
2081 "bytes to URI", ctxt->uri,
2082 "failed. HTTP return code:", http_rtn );
2083 xmlIOErr(XML_IO_WRITE, (const char *) msg);
2084 }
2085
2086 xmlNanoHTTPClose( http_ctxt );
2087 xmlFree( content_type );
2088 }
2089 }
2090
2091 /* Final cleanups */
2092
2093 xmlFreeHTTPWriteCtxt( ctxt );
2094
2095 return ( close_rc );
2096}
2097
2098/**
2099 * xmlIOHTTPClosePut
2100 *
2101 * @context: The I/O context
2102 *
2103 * Close the transmit HTTP I/O channel and actually send data using a PUT
2104 * HTTP method.
2105 */
2106static int
2107xmlIOHTTPClosePut( void * ctxt ) {
2108 return ( xmlIOHTTPCloseWrite( ctxt, "PUT" ) );
2109}
2110
2111
2112/**
2113 * xmlIOHTTPClosePost
2114 *
2115 * @context: The I/O context
2116 *
2117 * Close the transmit HTTP I/O channel and actually send data using a POST
2118 * HTTP method.
2119 */
2120static int
2121xmlIOHTTPClosePost( void * ctxt ) {
2122 return ( xmlIOHTTPCloseWrite( ctxt, "POST" ) );
2123}
2124#endif /* LIBXML_OUTPUT_ENABLED */
2125
2126#endif /* LIBXML_HTTP_ENABLED */
2127
2128#ifdef LIBXML_FTP_ENABLED
2129/************************************************************************
2130 * *
2131 * I/O for FTP file accesses *
2132 * *
2133 ************************************************************************/
2134/**
2135 * xmlIOFTPMatch:
2136 * @filename: the URI for matching
2137 *
2138 * check if the URI matches an FTP one
2139 *
2140 * Returns 1 if matches, 0 otherwise
2141 */
2142int
2143xmlIOFTPMatch (const char *filename) {
2144 if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "ftp://", 6))
2145 return(1);
2146 return(0);
2147}
2148
2149/**
2150 * xmlIOFTPOpen:
2151 * @filename: the URI for matching
2152 *
2153 * open an FTP I/O channel
2154 *
2155 * Returns an I/O context or NULL in case of error
2156 */
2157void *
2158xmlIOFTPOpen (const char *filename) {
2159 return(xmlNanoFTPOpen(filename));
2160}
2161
2162/**
2163 * xmlIOFTPRead:
2164 * @context: the I/O context
2165 * @buffer: where to drop data
2166 * @len: number of bytes to write
2167 *
2168 * Read @len bytes to @buffer from the I/O channel.
2169 *
2170 * Returns the number of bytes written
2171 */
2172int
2173xmlIOFTPRead(void * context, char * buffer, int len) {
2174 if ((buffer == NULL) || (len < 0)) return(-1);
2175 return(xmlNanoFTPRead(context, &buffer[0], len));
2176}
2177
2178/**
2179 * xmlIOFTPClose:
2180 * @context: the I/O context
2181 *
2182 * Close an FTP I/O channel
2183 *
2184 * Returns 0
2185 */
2186int
2187xmlIOFTPClose (void * context) {
2188 return ( xmlNanoFTPClose(context) );
2189}
2190#endif /* LIBXML_FTP_ENABLED */
2191
2192
2193/**
2194 * xmlRegisterInputCallbacks:
2195 * @matchFunc: the xmlInputMatchCallback
2196 * @openFunc: the xmlInputOpenCallback
2197 * @readFunc: the xmlInputReadCallback
2198 * @closeFunc: the xmlInputCloseCallback
2199 *
2200 * Register a new set of I/O callback for handling parser input.
2201 *
2202 * Returns the registered handler number or -1 in case of error
2203 */
2204int
2205xmlRegisterInputCallbacks(xmlInputMatchCallback matchFunc,
2206 xmlInputOpenCallback openFunc, xmlInputReadCallback readFunc,
2207 xmlInputCloseCallback closeFunc) {
2208 if (xmlInputCallbackNr >= MAX_INPUT_CALLBACK) {
2209 return(-1);
2210 }
2211 xmlInputCallbackTable[xmlInputCallbackNr].matchcallback = matchFunc;
2212 xmlInputCallbackTable[xmlInputCallbackNr].opencallback = openFunc;
2213 xmlInputCallbackTable[xmlInputCallbackNr].readcallback = readFunc;
2214 xmlInputCallbackTable[xmlInputCallbackNr].closecallback = closeFunc;
2215 xmlInputCallbackInitialized = 1;
2216 return(xmlInputCallbackNr++);
2217}
2218
2219#ifdef LIBXML_OUTPUT_ENABLED
2220/**
2221 * xmlRegisterOutputCallbacks:
2222 * @matchFunc: the xmlOutputMatchCallback
2223 * @openFunc: the xmlOutputOpenCallback
2224 * @writeFunc: the xmlOutputWriteCallback
2225 * @closeFunc: the xmlOutputCloseCallback
2226 *
2227 * Register a new set of I/O callback for handling output.
2228 *
2229 * Returns the registered handler number or -1 in case of error
2230 */
2231int
2232xmlRegisterOutputCallbacks(xmlOutputMatchCallback matchFunc,
2233 xmlOutputOpenCallback openFunc, xmlOutputWriteCallback writeFunc,
2234 xmlOutputCloseCallback closeFunc) {
2235 if (xmlOutputCallbackNr >= MAX_OUTPUT_CALLBACK) {
2236 return(-1);
2237 }
2238 xmlOutputCallbackTable[xmlOutputCallbackNr].matchcallback = matchFunc;
2239 xmlOutputCallbackTable[xmlOutputCallbackNr].opencallback = openFunc;
2240 xmlOutputCallbackTable[xmlOutputCallbackNr].writecallback = writeFunc;
2241 xmlOutputCallbackTable[xmlOutputCallbackNr].closecallback = closeFunc;
2242 xmlOutputCallbackInitialized = 1;
2243 return(xmlOutputCallbackNr++);
2244}
2245#endif /* LIBXML_OUTPUT_ENABLED */
2246
2247/**
2248 * xmlRegisterDefaultInputCallbacks:
2249 *
2250 * Registers the default compiled-in I/O handlers.
2251 */
2252void
2253xmlRegisterDefaultInputCallbacks(void) {
2254 if (xmlInputCallbackInitialized)
2255 return;
2256
2257 xmlRegisterInputCallbacks(xmlFileMatch, xmlFileOpen,
2258 xmlFileRead, xmlFileClose);
2259#ifdef LIBXML_ZLIB_ENABLED
2260 xmlRegisterInputCallbacks(xmlGzfileMatch, xmlGzfileOpen,
2261 xmlGzfileRead, xmlGzfileClose);
2262#endif /* LIBXML_ZLIB_ENABLED */
2263#ifdef LIBXML_LZMA_ENABLED
2264 xmlRegisterInputCallbacks(xmlXzfileMatch, xmlXzfileOpen,
2265 xmlXzfileRead, xmlXzfileClose);
2266#endif /* LIBXML_LZMA_ENABLED */
2267
2268#ifdef LIBXML_HTTP_ENABLED
2269 xmlRegisterInputCallbacks(xmlIOHTTPMatch, xmlIOHTTPOpen,
2270 xmlIOHTTPRead, xmlIOHTTPClose);
2271#endif /* LIBXML_HTTP_ENABLED */
2272
2273#ifdef LIBXML_FTP_ENABLED
2274 xmlRegisterInputCallbacks(xmlIOFTPMatch, xmlIOFTPOpen,
2275 xmlIOFTPRead, xmlIOFTPClose);
2276#endif /* LIBXML_FTP_ENABLED */
2277 xmlInputCallbackInitialized = 1;
2278}
2279
2280#ifdef LIBXML_OUTPUT_ENABLED
2281/**
2282 * xmlRegisterDefaultOutputCallbacks:
2283 *
2284 * Registers the default compiled-in I/O handlers.
2285 */
2286void
2287xmlRegisterDefaultOutputCallbacks (void) {
2288 if (xmlOutputCallbackInitialized)
2289 return;
2290
2291 xmlRegisterOutputCallbacks(xmlFileMatch, xmlFileOpenW,
2292 xmlFileWrite, xmlFileClose);
2293
2294#ifdef LIBXML_HTTP_ENABLED
2295 xmlRegisterOutputCallbacks(xmlIOHTTPMatch, xmlIOHTTPDfltOpenW,
2296 xmlIOHTTPWrite, xmlIOHTTPClosePut);
2297#endif
2298
2299/*********************************
2300 No way a-priori to distinguish between gzipped files from
2301 uncompressed ones except opening if existing then closing
2302 and saving with same compression ratio ... a pain.
2303
2304#ifdef LIBXML_ZLIB_ENABLED
2305 xmlRegisterOutputCallbacks(xmlGzfileMatch, xmlGzfileOpen,
2306 xmlGzfileWrite, xmlGzfileClose);
2307#endif
2308
2309 Nor FTP PUT ....
2310#ifdef LIBXML_FTP_ENABLED
2311 xmlRegisterOutputCallbacks(xmlIOFTPMatch, xmlIOFTPOpen,
2312 xmlIOFTPWrite, xmlIOFTPClose);
2313#endif
2314 **********************************/
2315 xmlOutputCallbackInitialized = 1;
2316}
2317
2318#ifdef LIBXML_HTTP_ENABLED
2319/**
2320 * xmlRegisterHTTPPostCallbacks:
2321 *
2322 * By default, libxml submits HTTP output requests using the "PUT" method.
2323 * Calling this method changes the HTTP output method to use the "POST"
2324 * method instead.
2325 *
2326 */
2327void
2328xmlRegisterHTTPPostCallbacks( void ) {
2329
2330 /* Register defaults if not done previously */
2331
2332 if ( xmlOutputCallbackInitialized == 0 )
2333 xmlRegisterDefaultOutputCallbacks( );
2334
2335 xmlRegisterOutputCallbacks(xmlIOHTTPMatch, xmlIOHTTPDfltOpenW,
2336 xmlIOHTTPWrite, xmlIOHTTPClosePost);
2337 return;
2338}
2339#endif
2340#endif /* LIBXML_OUTPUT_ENABLED */
2341
2342/**
2343 * xmlAllocParserInputBuffer:
2344 * @enc: the charset encoding if known
2345 *
2346 * Create a buffered parser input for progressive parsing
2347 *
2348 * Returns the new parser input or NULL
2349 */
2350xmlParserInputBufferPtr
2351xmlAllocParserInputBuffer(xmlCharEncoding enc) {
2352 xmlParserInputBufferPtr ret;
2353
2354 ret = (xmlParserInputBufferPtr) xmlMalloc(sizeof(xmlParserInputBuffer));
2355 if (ret == NULL) {
2356 xmlIOErrMemory("creating input buffer");
2357 return(NULL);
2358 }
2359 memset(ret, 0, (size_t) sizeof(xmlParserInputBuffer));
2360 ret->buffer = xmlBufCreateSize(2 * xmlDefaultBufferSize);
2361 if (ret->buffer == NULL) {
2362 xmlFree(ret);
2363 return(NULL);
2364 }
2365 xmlBufSetAllocationScheme(ret->buffer, XML_BUFFER_ALLOC_DOUBLEIT);
2366 ret->encoder = xmlGetCharEncodingHandler(enc);
2367 if (ret->encoder != NULL)
2368 ret->raw = xmlBufCreateSize(2 * xmlDefaultBufferSize);
2369 else
2370 ret->raw = NULL;
2371 ret->readcallback = NULL;
2372 ret->closecallback = NULL;
2373 ret->context = NULL;
2374 ret->compressed = -1;
2375 ret->rawconsumed = 0;
2376
2377 return(ret);
2378}
2379
2380#ifdef LIBXML_OUTPUT_ENABLED
2381/**
2382 * xmlAllocOutputBuffer:
2383 * @encoder: the encoding converter or NULL
2384 *
2385 * Create a buffered parser output
2386 *
2387 * Returns the new parser output or NULL
2388 */
2389xmlOutputBufferPtr
2390xmlAllocOutputBuffer(xmlCharEncodingHandlerPtr encoder) {
2391 xmlOutputBufferPtr ret;
2392
2393 ret = (xmlOutputBufferPtr) xmlMalloc(sizeof(xmlOutputBuffer));
2394 if (ret == NULL) {
2395 xmlIOErrMemory("creating output buffer");
2396 return(NULL);
2397 }
2398 memset(ret, 0, (size_t) sizeof(xmlOutputBuffer));
2399 ret->buffer = xmlBufCreate();
2400 if (ret->buffer == NULL) {
2401 xmlFree(ret);
2402 return(NULL);
2403 }
2404
2405 /* try to avoid a performance problem with Windows realloc() */
2406 if (xmlBufGetAllocationScheme(ret->buffer) == XML_BUFFER_ALLOC_EXACT)
2407 xmlBufSetAllocationScheme(ret->buffer, XML_BUFFER_ALLOC_DOUBLEIT);
2408
2409 ret->encoder = encoder;
2410 if (encoder != NULL) {
2411 ret->conv = xmlBufCreateSize(4000);
2412 if (ret->conv == NULL) {
2413 xmlBufFree(ret->buffer);
2414 xmlFree(ret);
2415 return(NULL);
2416 }
2417
2418 /*
2419 * This call is designed to initiate the encoder state
2420 */
2421 xmlCharEncOutput(ret, 1);
2422 } else
2423 ret->conv = NULL;
2424 ret->writecallback = NULL;
2425 ret->closecallback = NULL;
2426 ret->context = NULL;
2427 ret->written = 0;
2428
2429 return(ret);
2430}
2431
2432/**
2433 * xmlAllocOutputBufferInternal:
2434 * @encoder: the encoding converter or NULL
2435 *
2436 * Create a buffered parser output
2437 *
2438 * Returns the new parser output or NULL
2439 */
2440xmlOutputBufferPtr
2441xmlAllocOutputBufferInternal(xmlCharEncodingHandlerPtr encoder) {
2442 xmlOutputBufferPtr ret;
2443
2444 ret = (xmlOutputBufferPtr) xmlMalloc(sizeof(xmlOutputBuffer));
2445 if (ret == NULL) {
2446 xmlIOErrMemory("creating output buffer");
2447 return(NULL);
2448 }
2449 memset(ret, 0, (size_t) sizeof(xmlOutputBuffer));
2450 ret->buffer = xmlBufCreate();
2451 if (ret->buffer == NULL) {
2452 xmlFree(ret);
2453 return(NULL);
2454 }
2455
2456
2457 /*
2458 * For conversion buffers we use the special IO handling
2459 */
2460 xmlBufSetAllocationScheme(ret->buffer, XML_BUFFER_ALLOC_IO);
2461
2462 ret->encoder = encoder;
2463 if (encoder != NULL) {
2464 ret->conv = xmlBufCreateSize(4000);
2465 if (ret->conv == NULL) {
2466 xmlBufFree(ret->buffer);
2467 xmlFree(ret);
2468 return(NULL);
2469 }
2470
2471 /*
2472 * This call is designed to initiate the encoder state
2473 */
2474 xmlCharEncOutput(ret, 1);
2475 } else
2476 ret->conv = NULL;
2477 ret->writecallback = NULL;
2478 ret->closecallback = NULL;
2479 ret->context = NULL;
2480 ret->written = 0;
2481
2482 return(ret);
2483}
2484
2485#endif /* LIBXML_OUTPUT_ENABLED */
2486
2487/**
2488 * xmlFreeParserInputBuffer:
2489 * @in: a buffered parser input
2490 *
2491 * Free up the memory used by a buffered parser input
2492 */
2493void
2494xmlFreeParserInputBuffer(xmlParserInputBufferPtr in) {
2495 if (in == NULL) return;
2496
2497 if (in->raw) {
2498 xmlBufFree(in->raw);
2499 in->raw = NULL;
2500 }
2501 if (in->encoder != NULL) {
2502 xmlCharEncCloseFunc(in->encoder);
2503 }
2504 if (in->closecallback != NULL) {
2505 in->closecallback(in->context);
2506 }
2507 if (in->buffer != NULL) {
2508 xmlBufFree(in->buffer);
2509 in->buffer = NULL;
2510 }
2511
2512 xmlFree(in);
2513}
2514
2515#ifdef LIBXML_OUTPUT_ENABLED
2516/**
2517 * xmlOutputBufferClose:
2518 * @out: a buffered output
2519 *
2520 * flushes and close the output I/O channel
2521 * and free up all the associated resources
2522 *
2523 * Returns the number of byte written or -1 in case of error.
2524 */
2525int
2526xmlOutputBufferClose(xmlOutputBufferPtr out)
2527{
2528 int written;
2529 int err_rc = 0;
2530
2531 if (out == NULL)
2532 return (-1);
2533 if (out->writecallback != NULL)
2534 xmlOutputBufferFlush(out);
2535 if (out->closecallback != NULL) {
2536 err_rc = out->closecallback(out->context);
2537 }
2538 written = out->written;
2539 if (out->conv) {
2540 xmlBufFree(out->conv);
2541 out->conv = NULL;
2542 }
2543 if (out->encoder != NULL) {
2544 xmlCharEncCloseFunc(out->encoder);
2545 }
2546 if (out->buffer != NULL) {
2547 xmlBufFree(out->buffer);
2548 out->buffer = NULL;
2549 }
2550
2551 if (out->error)
2552 err_rc = -1;
2553 xmlFree(out);
2554 return ((err_rc == 0) ? written : err_rc);
2555}
2556#endif /* LIBXML_OUTPUT_ENABLED */
2557
2558xmlParserInputBufferPtr
2559__xmlParserInputBufferCreateFilename(const char *URI, xmlCharEncoding enc) {
2560 xmlParserInputBufferPtr ret;
2561 int i = 0;
2562 void *context = NULL;
2563
2564 if (xmlInputCallbackInitialized == 0)
2565 xmlRegisterDefaultInputCallbacks();
2566
2567 if (URI == NULL) return(NULL);
2568
2569 /*
2570 * Try to find one of the input accept method accepting that scheme
2571 * Go in reverse to give precedence to user defined handlers.
2572 */
2573 if (context == NULL) {
2574 for (i = xmlInputCallbackNr - 1;i >= 0;i--) {
2575 if ((xmlInputCallbackTable[i].matchcallback != NULL) &&
2576 (xmlInputCallbackTable[i].matchcallback(URI) != 0)) {
2577 context = xmlInputCallbackTable[i].opencallback(URI);
2578 if (context != NULL) {
2579 break;
2580 }
2581 }
2582 }
2583 }
2584 if (context == NULL) {
2585 return(NULL);
2586 }
2587
2588 /*
2589 * Allocate the Input buffer front-end.
2590 */
2591 ret = xmlAllocParserInputBuffer(enc);
2592 if (ret != NULL) {
2593 ret->context = context;
2594 ret->readcallback = xmlInputCallbackTable[i].readcallback;
2595 ret->closecallback = xmlInputCallbackTable[i].closecallback;
2596#ifdef LIBXML_ZLIB_ENABLED
2597 if ((xmlInputCallbackTable[i].opencallback == xmlGzfileOpen) &&
2598 (strcmp(URI, "-") != 0)) {
2599#if defined(ZLIB_VERNUM) && ZLIB_VERNUM >= 0x1230
2600 ret->compressed = !gzdirect(context);
2601#else
2602 if (((z_stream *)context)->avail_in > 4) {
2603 char *cptr, buff4[4];
2604 cptr = (char *) ((z_stream *)context)->next_in;
2605 if (gzread(context, buff4, 4) == 4) {
2606 if (strncmp(buff4, cptr, 4) == 0)
2607 ret->compressed = 0;
2608 else
2609 ret->compressed = 1;
2610 gzrewind(context);
2611 }
2612 }
2613#endif
2614 }
2615#endif
2616#ifdef LIBXML_LZMA_ENABLED
2617 if ((xmlInputCallbackTable[i].opencallback == xmlXzfileOpen) &&
2618 (strcmp(URI, "-") != 0)) {
2619 ret->compressed = __libxml2_xzcompressed(context);
2620 }
2621#endif
2622 }
2623 else
2624 xmlInputCallbackTable[i].closecallback (context);
2625
2626 return(ret);
2627}
2628
2629/**
2630 * xmlParserInputBufferCreateFilename:
2631 * @URI: a C string containing the URI or filename
2632 * @enc: the charset encoding if known
2633 *
2634 * Create a buffered parser input for the progressive parsing of a file
2635 * If filename is "-' then we use stdin as the input.
2636 * Automatic support for ZLIB/Compress compressed document is provided
2637 * by default if found at compile-time.
2638 * Do an encoding check if enc == XML_CHAR_ENCODING_NONE
2639 *
2640 * Returns the new parser input or NULL
2641 */
2642xmlParserInputBufferPtr
2643xmlParserInputBufferCreateFilename(const char *URI, xmlCharEncoding enc) {
2644 if ((xmlParserInputBufferCreateFilenameValue)) {
2645 return xmlParserInputBufferCreateFilenameValue(URI, enc);
2646 }
2647 return __xmlParserInputBufferCreateFilename(URI, enc);
2648}
2649
2650#ifdef LIBXML_OUTPUT_ENABLED
2651xmlOutputBufferPtr
2652__xmlOutputBufferCreateFilename(const char *URI,
2653 xmlCharEncodingHandlerPtr encoder,
2654 int compression ATTRIBUTE_UNUSED) {
2655 xmlOutputBufferPtr ret;
2656 xmlURIPtr puri;
2657 int i = 0;
2658 void *context = NULL;
2659 char *unescaped = NULL;
2660#ifdef LIBXML_ZLIB_ENABLED
2661 int is_file_uri = 1;
2662#endif
2663
2664 if (xmlOutputCallbackInitialized == 0)
2665 xmlRegisterDefaultOutputCallbacks();
2666
2667 if (URI == NULL) return(NULL);
2668
2669 puri = xmlParseURI(URI);
2670 if (puri != NULL) {
2671#ifdef LIBXML_ZLIB_ENABLED
2672 if ((puri->scheme != NULL) &&
2673 (!xmlStrEqual(BAD_CAST puri->scheme, BAD_CAST "file")))
2674 is_file_uri = 0;
2675#endif
2676 /*
2677 * try to limit the damages of the URI unescaping code.
2678 */
2679 if ((puri->scheme == NULL) ||
2680 (xmlStrEqual(BAD_CAST puri->scheme, BAD_CAST "file")))
2681 unescaped = xmlURIUnescapeString(URI, 0, NULL);
2682 xmlFreeURI(puri);
2683 }
2684
2685 /*
2686 * Try to find one of the output accept method accepting that scheme
2687 * Go in reverse to give precedence to user defined handlers.
2688 * try with an unescaped version of the URI
2689 */
2690 if (unescaped != NULL) {
2691#ifdef LIBXML_ZLIB_ENABLED
2692 if ((compression > 0) && (compression <= 9) && (is_file_uri == 1)) {
2693 context = xmlGzfileOpenW(unescaped, compression);
2694 if (context != NULL) {
2695 ret = xmlAllocOutputBufferInternal(encoder);
2696 if (ret != NULL) {
2697 ret->context = context;
2698 ret->writecallback = xmlGzfileWrite;
2699 ret->closecallback = xmlGzfileClose;
2700 }
2701 xmlFree(unescaped);
2702 return(ret);
2703 }
2704 }
2705#endif
2706 for (i = xmlOutputCallbackNr - 1;i >= 0;i--) {
2707 if ((xmlOutputCallbackTable[i].matchcallback != NULL) &&
2708 (xmlOutputCallbackTable[i].matchcallback(unescaped) != 0)) {
2709#if defined(LIBXML_HTTP_ENABLED) && defined(LIBXML_ZLIB_ENABLED)
2710 /* Need to pass compression parameter into HTTP open calls */
2711 if (xmlOutputCallbackTable[i].matchcallback == xmlIOHTTPMatch)
2712 context = xmlIOHTTPOpenW(unescaped, compression);
2713 else
2714#endif
2715 context = xmlOutputCallbackTable[i].opencallback(unescaped);
2716 if (context != NULL)
2717 break;
2718 }
2719 }
2720 xmlFree(unescaped);
2721 }
2722
2723 /*
2724 * If this failed try with a non-escaped URI this may be a strange
2725 * filename
2726 */
2727 if (context == NULL) {
2728#ifdef LIBXML_ZLIB_ENABLED
2729 if ((compression > 0) && (compression <= 9) && (is_file_uri == 1)) {
2730 context = xmlGzfileOpenW(URI, compression);
2731 if (context != NULL) {
2732 ret = xmlAllocOutputBufferInternal(encoder);
2733 if (ret != NULL) {
2734 ret->context = context;
2735 ret->writecallback = xmlGzfileWrite;
2736 ret->closecallback = xmlGzfileClose;
2737 }
2738 else
2739 xmlGzfileClose(context);
2740 return(ret);
2741 }
2742 }
2743#endif
2744 for (i = xmlOutputCallbackNr - 1;i >= 0;i--) {
2745 if ((xmlOutputCallbackTable[i].matchcallback != NULL) &&
2746 (xmlOutputCallbackTable[i].matchcallback(URI) != 0)) {
2747#if defined(LIBXML_HTTP_ENABLED) && defined(LIBXML_ZLIB_ENABLED)
2748 /* Need to pass compression parameter into HTTP open calls */
2749 if (xmlOutputCallbackTable[i].matchcallback == xmlIOHTTPMatch)
2750 context = xmlIOHTTPOpenW(URI, compression);
2751 else
2752#endif
2753 context = xmlOutputCallbackTable[i].opencallback(URI);
2754 if (context != NULL)
2755 break;
2756 }
2757 }
2758 }
2759
2760 if (context == NULL) {
2761 return(NULL);
2762 }
2763
2764 /*
2765 * Allocate the Output buffer front-end.
2766 */
2767 ret = xmlAllocOutputBufferInternal(encoder);
2768 if (ret != NULL) {
2769 ret->context = context;
2770 ret->writecallback = xmlOutputCallbackTable[i].writecallback;
2771 ret->closecallback = xmlOutputCallbackTable[i].closecallback;
2772 }
2773 return(ret);
2774}
2775
2776/**
2777 * xmlOutputBufferCreateFilename:
2778 * @URI: a C string containing the URI or filename
2779 * @encoder: the encoding converter or NULL
2780 * @compression: the compression ration (0 none, 9 max).
2781 *
2782 * Create a buffered output for the progressive saving of a file
2783 * If filename is "-' then we use stdout as the output.
2784 * Automatic support for ZLIB/Compress compressed document is provided
2785 * by default if found at compile-time.
2786 * TODO: currently if compression is set, the library only support
2787 * writing to a local file.
2788 *
2789 * Returns the new output or NULL
2790 */
2791xmlOutputBufferPtr
2792xmlOutputBufferCreateFilename(const char *URI,
2793 xmlCharEncodingHandlerPtr encoder,
2794 int compression ATTRIBUTE_UNUSED) {
2795 if ((xmlOutputBufferCreateFilenameValue)) {
2796 return xmlOutputBufferCreateFilenameValue(URI, encoder, compression);
2797 }
2798 return __xmlOutputBufferCreateFilename(URI, encoder, compression);
2799}
2800#endif /* LIBXML_OUTPUT_ENABLED */
2801
2802/**
2803 * xmlParserInputBufferCreateFile:
2804 * @file: a FILE*
2805 * @enc: the charset encoding if known
2806 *
2807 * Create a buffered parser input for the progressive parsing of a FILE *
2808 * buffered C I/O
2809 *
2810 * Returns the new parser input or NULL
2811 */
2812xmlParserInputBufferPtr
2813xmlParserInputBufferCreateFile(FILE *file, xmlCharEncoding enc) {
2814 xmlParserInputBufferPtr ret;
2815
2816 if (xmlInputCallbackInitialized == 0)
2817 xmlRegisterDefaultInputCallbacks();
2818
2819 if (file == NULL) return(NULL);
2820
2821 ret = xmlAllocParserInputBuffer(enc);
2822 if (ret != NULL) {
2823 ret->context = file;
2824 ret->readcallback = xmlFileRead;
2825 ret->closecallback = xmlFileFlush;
2826 }
2827
2828 return(ret);
2829}
2830
2831#ifdef LIBXML_OUTPUT_ENABLED
2832/**
2833 * xmlOutputBufferCreateFile:
2834 * @file: a FILE*
2835 * @encoder: the encoding converter or NULL
2836 *
2837 * Create a buffered output for the progressive saving to a FILE *
2838 * buffered C I/O
2839 *
2840 * Returns the new parser output or NULL
2841 */
2842xmlOutputBufferPtr
2843xmlOutputBufferCreateFile(FILE *file, xmlCharEncodingHandlerPtr encoder) {
2844 xmlOutputBufferPtr ret;
2845
2846 if (xmlOutputCallbackInitialized == 0)
2847 xmlRegisterDefaultOutputCallbacks();
2848
2849 if (file == NULL) return(NULL);
2850
2851 ret = xmlAllocOutputBufferInternal(encoder);
2852 if (ret != NULL) {
2853 ret->context = file;
2854 ret->writecallback = xmlFileWrite;
2855 ret->closecallback = xmlFileFlush;
2856 }
2857
2858 return(ret);
2859}
2860
2861/**
2862 * xmlOutputBufferCreateBuffer:
2863 * @buffer: a xmlBufferPtr
2864 * @encoder: the encoding converter or NULL
2865 *
2866 * Create a buffered output for the progressive saving to a xmlBuffer
2867 *
2868 * Returns the new parser output or NULL
2869 */
2870xmlOutputBufferPtr
2871xmlOutputBufferCreateBuffer(xmlBufferPtr buffer,
2872 xmlCharEncodingHandlerPtr encoder) {
2873 xmlOutputBufferPtr ret;
2874
2875 if (buffer == NULL) return(NULL);
2876
2877 ret = xmlOutputBufferCreateIO(xmlBufferWrite, NULL, (void *) buffer,
2878 encoder);
2879
2880 return(ret);
2881}
2882
2883/**
2884 * xmlOutputBufferGetContent:
2885 * @out: an xmlOutputBufferPtr
2886 *
2887 * Gives a pointer to the data currently held in the output buffer
2888 *
2889 * Returns a pointer to the data or NULL in case of error
2890 */
2891const xmlChar *
2892xmlOutputBufferGetContent(xmlOutputBufferPtr out) {
2893 if ((out == NULL) || (out->buffer == NULL))
2894 return(NULL);
2895
2896 return(xmlBufContent(out->buffer));
2897}
2898
2899/**
2900 * xmlOutputBufferGetSize:
2901 * @out: an xmlOutputBufferPtr
2902 *
2903 * Gives the length of the data currently held in the output buffer
2904 *
2905 * Returns 0 in case or error or no data is held, the size otherwise
2906 */
2907size_t
2908xmlOutputBufferGetSize(xmlOutputBufferPtr out) {
2909 if ((out == NULL) || (out->buffer == NULL))
2910 return(0);
2911
2912 return(xmlBufUse(out->buffer));
2913}
2914
2915
2916#endif /* LIBXML_OUTPUT_ENABLED */
2917
2918/**
2919 * xmlParserInputBufferCreateFd:
2920 * @fd: a file descriptor number
2921 * @enc: the charset encoding if known
2922 *
2923 * Create a buffered parser input for the progressive parsing for the input
2924 * from a file descriptor
2925 *
2926 * Returns the new parser input or NULL
2927 */
2928xmlParserInputBufferPtr
2929xmlParserInputBufferCreateFd(int fd, xmlCharEncoding enc) {
2930 xmlParserInputBufferPtr ret;
2931
2932 if (fd < 0) return(NULL);
2933
2934 ret = xmlAllocParserInputBuffer(enc);
2935 if (ret != NULL) {
2936 ret->context = (void *) (ptrdiff_t) fd;
2937 ret->readcallback = xmlFdRead;
2938 ret->closecallback = xmlFdClose;
2939 }
2940
2941 return(ret);
2942}
2943
2944/**
2945 * xmlParserInputBufferCreateMem:
2946 * @mem: the memory input
2947 * @size: the length of the memory block
2948 * @enc: the charset encoding if known
2949 *
2950 * Create a buffered parser input for the progressive parsing for the input
2951 * from a memory area.
2952 *
2953 * Returns the new parser input or NULL
2954 */
2955xmlParserInputBufferPtr
2956xmlParserInputBufferCreateMem(const char *mem, int size, xmlCharEncoding enc) {
2957 xmlParserInputBufferPtr ret;
2958 int errcode;
2959
2960 if (size < 0) return(NULL);
2961 if (mem == NULL) return(NULL);
2962
2963 ret = xmlAllocParserInputBuffer(enc);
2964 if (ret != NULL) {
2965 ret->context = (void *) mem;
2966 ret->readcallback = xmlInputReadCallbackNop;
2967 ret->closecallback = NULL;
2968 errcode = xmlBufAdd(ret->buffer, (const xmlChar *) mem, size);
2969 if (errcode != 0) {
2970 xmlFree(ret);
2971 return(NULL);
2972 }
2973 }
2974
2975 return(ret);
2976}
2977
2978/**
2979 * xmlParserInputBufferCreateStatic:
2980 * @mem: the memory input
2981 * @size: the length of the memory block
2982 * @enc: the charset encoding if known
2983 *
2984 * Create a buffered parser input for the progressive parsing for the input
2985 * from an immutable memory area. This will not copy the memory area to
2986 * the buffer, but the memory is expected to be available until the end of
2987 * the parsing, this is useful for example when using mmap'ed file.
2988 *
2989 * Returns the new parser input or NULL
2990 */
2991xmlParserInputBufferPtr
2992xmlParserInputBufferCreateStatic(const char *mem, int size,
2993 xmlCharEncoding enc) {
2994 xmlParserInputBufferPtr ret;
2995
2996 if (size < 0) return(NULL);
2997 if (mem == NULL) return(NULL);
2998
2999 ret = (xmlParserInputBufferPtr) xmlMalloc(sizeof(xmlParserInputBuffer));
3000 if (ret == NULL) {
3001 xmlIOErrMemory("creating input buffer");
3002 return(NULL);
3003 }
3004 memset(ret, 0, (size_t) sizeof(xmlParserInputBuffer));
3005 ret->buffer = xmlBufCreateStatic((void *)mem, (size_t) size);
3006 if (ret->buffer == NULL) {
3007 xmlFree(ret);
3008 return(NULL);
3009 }
3010 ret->encoder = xmlGetCharEncodingHandler(enc);
3011 if (ret->encoder != NULL)
3012 ret->raw = xmlBufCreateSize(2 * xmlDefaultBufferSize);
3013 else
3014 ret->raw = NULL;
3015 ret->compressed = -1;
3016 ret->context = (void *) mem;
3017 ret->readcallback = NULL;
3018 ret->closecallback = NULL;
3019
3020 return(ret);
3021}
3022
3023#ifdef LIBXML_OUTPUT_ENABLED
3024/**
3025 * xmlOutputBufferCreateFd:
3026 * @fd: a file descriptor number
3027 * @encoder: the encoding converter or NULL
3028 *
3029 * Create a buffered output for the progressive saving
3030 * to a file descriptor
3031 *
3032 * Returns the new parser output or NULL
3033 */
3034xmlOutputBufferPtr
3035xmlOutputBufferCreateFd(int fd, xmlCharEncodingHandlerPtr encoder) {
3036 xmlOutputBufferPtr ret;
3037
3038 if (fd < 0) return(NULL);
3039
3040 ret = xmlAllocOutputBufferInternal(encoder);
3041 if (ret != NULL) {
3042 ret->context = (void *) (ptrdiff_t) fd;
3043 ret->writecallback = xmlFdWrite;
3044 ret->closecallback = NULL;
3045 }
3046
3047 return(ret);
3048}
3049#endif /* LIBXML_OUTPUT_ENABLED */
3050
3051/**
3052 * xmlParserInputBufferCreateIO:
3053 * @ioread: an I/O read function
3054 * @ioclose: an I/O close function
3055 * @ioctx: an I/O handler
3056 * @enc: the charset encoding if known
3057 *
3058 * Create a buffered parser input for the progressive parsing for the input
3059 * from an I/O handler
3060 *
3061 * Returns the new parser input or NULL
3062 */
3063xmlParserInputBufferPtr
3064xmlParserInputBufferCreateIO(xmlInputReadCallback ioread,
3065 xmlInputCloseCallback ioclose, void *ioctx, xmlCharEncoding enc) {
3066 xmlParserInputBufferPtr ret;
3067
3068 if (ioread == NULL) return(NULL);
3069
3070 ret = xmlAllocParserInputBuffer(enc);
3071 if (ret != NULL) {
3072 ret->context = (void *) ioctx;
3073 ret->readcallback = ioread;
3074 ret->closecallback = ioclose;
3075 }
3076
3077 return(ret);
3078}
3079
3080#ifdef LIBXML_OUTPUT_ENABLED
3081/**
3082 * xmlOutputBufferCreateIO:
3083 * @iowrite: an I/O write function
3084 * @ioclose: an I/O close function
3085 * @ioctx: an I/O handler
3086 * @encoder: the charset encoding if known
3087 *
3088 * Create a buffered output for the progressive saving
3089 * to an I/O handler
3090 *
3091 * Returns the new parser output or NULL
3092 */
3093xmlOutputBufferPtr
3094xmlOutputBufferCreateIO(xmlOutputWriteCallback iowrite,
3095 xmlOutputCloseCallback ioclose, void *ioctx,
3096 xmlCharEncodingHandlerPtr encoder) {
3097 xmlOutputBufferPtr ret;
3098
3099 if (iowrite == NULL) return(NULL);
3100
3101 ret = xmlAllocOutputBufferInternal(encoder);
3102 if (ret != NULL) {
3103 ret->context = (void *) ioctx;
3104 ret->writecallback = iowrite;
3105 ret->closecallback = ioclose;
3106 }
3107
3108 return(ret);
3109}
3110#endif /* LIBXML_OUTPUT_ENABLED */
3111
3112/**
3113 * xmlParserInputBufferCreateFilenameDefault:
3114 * @func: function pointer to the new ParserInputBufferCreateFilenameFunc
3115 *
3116 * Registers a callback for URI input file handling
3117 *
3118 * Returns the old value of the registration function
3119 */
3120xmlParserInputBufferCreateFilenameFunc
3121xmlParserInputBufferCreateFilenameDefault(xmlParserInputBufferCreateFilenameFunc func)
3122{
3123 xmlParserInputBufferCreateFilenameFunc old = xmlParserInputBufferCreateFilenameValue;
3124 if (old == NULL) {
3125 old = __xmlParserInputBufferCreateFilename;
3126 }
3127
3128 xmlParserInputBufferCreateFilenameValue = func;
3129 return(old);
3130}
3131
3132/**
3133 * xmlOutputBufferCreateFilenameDefault:
3134 * @func: function pointer to the new OutputBufferCreateFilenameFunc
3135 *
3136 * Registers a callback for URI output file handling
3137 *
3138 * Returns the old value of the registration function
3139 */
3140xmlOutputBufferCreateFilenameFunc
3141xmlOutputBufferCreateFilenameDefault(xmlOutputBufferCreateFilenameFunc func)
3142{
3143 xmlOutputBufferCreateFilenameFunc old = xmlOutputBufferCreateFilenameValue;
3144#ifdef LIBXML_OUTPUT_ENABLED
3145 if (old == NULL) {
3146 old = __xmlOutputBufferCreateFilename;
3147 }
3148#endif
3149 xmlOutputBufferCreateFilenameValue = func;
3150 return(old);
3151}
3152
3153/**
3154 * xmlParserInputBufferPush:
3155 * @in: a buffered parser input
3156 * @len: the size in bytes of the array.
3157 * @buf: an char array
3158 *
3159 * Push the content of the arry in the input buffer
3160 * This routine handle the I18N transcoding to internal UTF-8
3161 * This is used when operating the parser in progressive (push) mode.
3162 *
3163 * Returns the number of chars read and stored in the buffer, or -1
3164 * in case of error.
3165 */
3166int
3167xmlParserInputBufferPush(xmlParserInputBufferPtr in,
3168 int len, const char *buf) {
3169 int nbchars = 0;
3170 int ret;
3171
3172 if (len < 0) return(0);
3173 if ((in == NULL) || (in->error)) return(-1);
3174 if (in->encoder != NULL) {
3175 unsigned int use;
3176
3177 /*
3178 * Store the data in the incoming raw buffer
3179 */
3180 if (in->raw == NULL) {
3181 in->raw = xmlBufCreate();
3182 }
3183 ret = xmlBufAdd(in->raw, (const xmlChar *) buf, len);
3184 if (ret != 0)
3185 return(-1);
3186
3187 /*
3188 * convert as much as possible to the parser reading buffer.
3189 */
3190 use = xmlBufUse(in->raw);
3191 nbchars = xmlCharEncInput(in, 1);
3192 if (nbchars < 0) {
3193 xmlIOErr(XML_IO_ENCODER, NULL);
3194 in->error = XML_IO_ENCODER;
3195 return(-1);
3196 }
3197 in->rawconsumed += (use - xmlBufUse(in->raw));
3198 } else {
3199 nbchars = len;
3200 ret = xmlBufAdd(in->buffer, (xmlChar *) buf, nbchars);
3201 if (ret != 0)
3202 return(-1);
3203 }
3204#ifdef DEBUG_INPUT
3205 xmlGenericError(xmlGenericErrorContext,
3206 "I/O: pushed %d chars, buffer %d/%d\n",
3207 nbchars, xmlBufUse(in->buffer), xmlBufLength(in->buffer));
3208#endif
3209 return(nbchars);
3210}
3211
3212/**
3213 * endOfInput:
3214 *
3215 * When reading from an Input channel indicated end of file or error
3216 * don't reread from it again.
3217 */
3218static int
3219endOfInput (void * context ATTRIBUTE_UNUSED,
3220 char * buffer ATTRIBUTE_UNUSED,
3221 int len ATTRIBUTE_UNUSED) {
3222 return(0);
3223}
3224
3225/**
3226 * xmlParserInputBufferGrow:
3227 * @in: a buffered parser input
3228 * @len: indicative value of the amount of chars to read
3229 *
3230 * Grow up the content of the input buffer, the old data are preserved
3231 * This routine handle the I18N transcoding to internal UTF-8
3232 * This routine is used when operating the parser in normal (pull) mode
3233 *
3234 * TODO: one should be able to remove one extra copy by copying directly
3235 * onto in->buffer or in->raw
3236 *
3237 * Returns the number of chars read and stored in the buffer, or -1
3238 * in case of error.
3239 */
3240int
3241xmlParserInputBufferGrow(xmlParserInputBufferPtr in, int len) {
3242 char *buffer = NULL;
3243 int res = 0;
3244 int nbchars = 0;
3245
3246 if ((in == NULL) || (in->error)) return(-1);
3247 if ((len <= MINLEN) && (len != 4))
3248 len = MINLEN;
3249
3250 if (xmlBufAvail(in->buffer) <= 0) {
3251 xmlIOErr(XML_IO_BUFFER_FULL, NULL);
3252 in->error = XML_IO_BUFFER_FULL;
3253 return(-1);
3254 }
3255
3256 if (xmlBufGrow(in->buffer, len + 1) < 0) {
3257 xmlIOErrMemory("growing input buffer");
3258 in->error = XML_ERR_NO_MEMORY;
3259 return(-1);
3260 }
3261 buffer = (char *)xmlBufEnd(in->buffer);
3262
3263 /*
3264 * Call the read method for this I/O type.
3265 */
3266 if (in->readcallback != NULL) {
3267 res = in->readcallback(in->context, &buffer[0], len);
3268 if (res <= 0)
3269 in->readcallback = endOfInput;
3270 } else {
3271 xmlIOErr(XML_IO_NO_INPUT, NULL);
3272 in->error = XML_IO_NO_INPUT;
3273 return(-1);
3274 }
3275 if (res < 0) {
3276 return(-1);
3277 }
3278
3279 /*
3280 * try to establish compressed status of input if not done already
3281 */
3282 if (in->compressed == -1) {
3283#ifdef LIBXML_LZMA_ENABLED
3284 if (in->readcallback == xmlXzfileRead)
3285 in->compressed = __libxml2_xzcompressed(in->context);
3286#endif
3287 }
3288
3289 len = res;
3290 if (in->encoder != NULL) {
3291 unsigned int use;
3292
3293 /*
3294 * Store the data in the incoming raw buffer
3295 */
3296 if (in->raw == NULL) {
3297 in->raw = xmlBufCreate();
3298 }
3299 res = xmlBufAdd(in->raw, (const xmlChar *) buffer, len);
3300 if (res != 0)
3301 return(-1);
3302
3303 /*
3304 * convert as much as possible to the parser reading buffer.
3305 */
3306 use = xmlBufUse(in->raw);
3307 nbchars = xmlCharEncInput(in, 1);
3308 if (nbchars < 0) {
3309 xmlIOErr(XML_IO_ENCODER, NULL);
3310 in->error = XML_IO_ENCODER;
3311 return(-1);
3312 }
3313 in->rawconsumed += (use - xmlBufUse(in->raw));
3314 } else {
3315 nbchars = len;
3316 xmlBufAddLen(in->buffer, nbchars);
3317 }
3318#ifdef DEBUG_INPUT
3319 xmlGenericError(xmlGenericErrorContext,
3320 "I/O: read %d chars, buffer %d\n",
3321 nbchars, xmlBufUse(in->buffer));
3322#endif
3323 return(nbchars);
3324}
3325
3326/**
3327 * xmlParserInputBufferRead:
3328 * @in: a buffered parser input
3329 * @len: indicative value of the amount of chars to read
3330 *
3331 * Refresh the content of the input buffer, the old data are considered
3332 * consumed
3333 * This routine handle the I18N transcoding to internal UTF-8
3334 *
3335 * Returns the number of chars read and stored in the buffer, or -1
3336 * in case of error.
3337 */
3338int
3339xmlParserInputBufferRead(xmlParserInputBufferPtr in, int len) {
3340 if ((in == NULL) || (in->error)) return(-1);
3341 if (in->readcallback != NULL)
3342 return(xmlParserInputBufferGrow(in, len));
3343 else if (xmlBufGetAllocationScheme(in->buffer) == XML_BUFFER_ALLOC_IMMUTABLE)
3344 return(0);
3345 else
3346 return(-1);
3347}
3348
3349#ifdef LIBXML_OUTPUT_ENABLED
3350/**
3351 * xmlOutputBufferWrite:
3352 * @out: a buffered parser output
3353 * @len: the size in bytes of the array.
3354 * @buf: an char array
3355 *
3356 * Write the content of the array in the output I/O buffer
3357 * This routine handle the I18N transcoding from internal UTF-8
3358 * The buffer is lossless, i.e. will store in case of partial
3359 * or delayed writes.
3360 *
3361 * Returns the number of chars immediately written, or -1
3362 * in case of error.
3363 */
3364int
3365xmlOutputBufferWrite(xmlOutputBufferPtr out, int len, const char *buf) {
3366 int nbchars = 0; /* number of chars to output to I/O */
3367 int ret; /* return from function call */
3368 int written = 0; /* number of char written to I/O so far */
3369 int chunk; /* number of byte current processed from buf */
3370
3371 if ((out == NULL) || (out->error)) return(-1);
3372 if (len < 0) return(0);
3373 if (out->error) return(-1);
3374
3375 do {
3376 chunk = len;
3377 if (chunk > 4 * MINLEN)
3378 chunk = 4 * MINLEN;
3379
3380 /*
3381 * first handle encoding stuff.
3382 */
3383 if (out->encoder != NULL) {
3384 /*
3385 * Store the data in the incoming raw buffer
3386 */
3387 if (out->conv == NULL) {
3388 out->conv = xmlBufCreate();
3389 }
3390 ret = xmlBufAdd(out->buffer, (const xmlChar *) buf, chunk);
3391 if (ret != 0)
3392 return(-1);
3393
3394 if ((xmlBufUse(out->buffer) < MINLEN) && (chunk == len))
3395 goto done;
3396
3397 /*
3398 * convert as much as possible to the parser reading buffer.
3399 */
3400 ret = xmlCharEncOutput(out, 0);
3401 if ((ret < 0) && (ret != -3)) {
3402 xmlIOErr(XML_IO_ENCODER, NULL);
3403 out->error = XML_IO_ENCODER;
3404 return(-1);
3405 }
3406 if (out->writecallback)
3407 nbchars = xmlBufUse(out->conv);
3408 else
3409 nbchars = ret >= 0 ? ret : 0;
3410 } else {
3411 ret = xmlBufAdd(out->buffer, (const xmlChar *) buf, chunk);
3412 if (ret != 0)
3413 return(-1);
3414 if (out->writecallback)
3415 nbchars = xmlBufUse(out->buffer);
3416 else
3417 nbchars = chunk;
3418 }
3419 buf += chunk;
3420 len -= chunk;
3421
3422 if (out->writecallback) {
3423 if ((nbchars < MINLEN) && (len <= 0))
3424 goto done;
3425
3426 /*
3427 * second write the stuff to the I/O channel
3428 */
3429 if (out->encoder != NULL) {
3430 ret = out->writecallback(out->context,
3431 (const char *)xmlBufContent(out->conv), nbchars);
3432 if (ret >= 0)
3433 xmlBufShrink(out->conv, ret);
3434 } else {
3435 ret = out->writecallback(out->context,
3436 (const char *)xmlBufContent(out->buffer), nbchars);
3437 if (ret >= 0)
3438 xmlBufShrink(out->buffer, ret);
3439 }
3440 if (ret < 0) {
3441 xmlIOErr(XML_IO_WRITE, NULL);
3442 out->error = XML_IO_WRITE;
3443 return(ret);
3444 }
3445 if (out->written > INT_MAX - ret)
3446 out->written = INT_MAX;
3447 else
3448 out->written += ret;
3449 }
3450 written += nbchars;
3451 } while (len > 0);
3452
3453done:
3454#ifdef DEBUG_INPUT
3455 xmlGenericError(xmlGenericErrorContext,
3456 "I/O: wrote %d chars\n", written);
3457#endif
3458 return(written);
3459}
3460
3461/**
3462 * xmlEscapeContent:
3463 * @out: a pointer to an array of bytes to store the result
3464 * @outlen: the length of @out
3465 * @in: a pointer to an array of unescaped UTF-8 bytes
3466 * @inlen: the length of @in
3467 *
3468 * Take a block of UTF-8 chars in and escape them.
3469 * Returns 0 if success, or -1 otherwise
3470 * The value of @inlen after return is the number of octets consumed
3471 * if the return value is positive, else unpredictable.
3472 * The value of @outlen after return is the number of octets consumed.
3473 */
3474static int
3475xmlEscapeContent(unsigned char* out, int *outlen,
3476 const xmlChar* in, int *inlen) {
3477 unsigned char* outstart = out;
3478 const unsigned char* base = in;
3479 unsigned char* outend = out + *outlen;
3480 const unsigned char* inend;
3481
3482 inend = in + (*inlen);
3483
3484 while ((in < inend) && (out < outend)) {
3485 if (*in == '<') {
3486 if (outend - out < 4) break;
3487 *out++ = '&';
3488 *out++ = 'l';
3489 *out++ = 't';
3490 *out++ = ';';
3491 } else if (*in == '>') {
3492 if (outend - out < 4) break;
3493 *out++ = '&';
3494 *out++ = 'g';
3495 *out++ = 't';
3496 *out++ = ';';
3497 } else if (*in == '&') {
3498 if (outend - out < 5) break;
3499 *out++ = '&';
3500 *out++ = 'a';
3501 *out++ = 'm';
3502 *out++ = 'p';
3503 *out++ = ';';
3504 } else if (*in == '\r') {
3505 if (outend - out < 5) break;
3506 *out++ = '&';
3507 *out++ = '#';
3508 *out++ = '1';
3509 *out++ = '3';
3510 *out++ = ';';
3511 } else {
3512 *out++ = (unsigned char) *in;
3513 }
3514 ++in;
3515 }
3516 *outlen = out - outstart;
3517 *inlen = in - base;
3518 return(0);
3519}
3520
3521/**
3522 * xmlOutputBufferWriteEscape:
3523 * @out: a buffered parser output
3524 * @str: a zero terminated UTF-8 string
3525 * @escaping: an optional escaping function (or NULL)
3526 *
3527 * Write the content of the string in the output I/O buffer
3528 * This routine escapes the characters and then handle the I18N
3529 * transcoding from internal UTF-8
3530 * The buffer is lossless, i.e. will store in case of partial
3531 * or delayed writes.
3532 *
3533 * Returns the number of chars immediately written, or -1
3534 * in case of error.
3535 */
3536int
3537xmlOutputBufferWriteEscape(xmlOutputBufferPtr out, const xmlChar *str,
3538 xmlCharEncodingOutputFunc escaping) {
3539 int nbchars = 0; /* number of chars to output to I/O */
3540 int ret; /* return from function call */
3541 int written = 0; /* number of char written to I/O so far */
3542 int oldwritten=0;/* loop guard */
3543 int chunk; /* number of byte currently processed from str */
3544 int len; /* number of bytes in str */
3545 int cons; /* byte from str consumed */
3546
3547 if ((out == NULL) || (out->error) || (str == NULL) ||
3548 (out->buffer == NULL) ||
3549 (xmlBufGetAllocationScheme(out->buffer) == XML_BUFFER_ALLOC_IMMUTABLE))
3550 return(-1);
3551 len = strlen((const char *)str);
3552 if (len < 0) return(0);
3553 if (out->error) return(-1);
3554 if (escaping == NULL) escaping = xmlEscapeContent;
3555
3556 do {
3557 oldwritten = written;
3558
3559 /*
3560 * how many bytes to consume and how many bytes to store.
3561 */
3562 cons = len;
3563 chunk = xmlBufAvail(out->buffer) - 1;
3564
3565 /*
3566 * make sure we have enough room to save first, if this is
3567 * not the case force a flush, but make sure we stay in the loop
3568 */
3569 if (chunk < 40) {
3570 if (xmlBufGrow(out->buffer, 100) < 0)
3571 return(-1);
3572 oldwritten = -1;
3573 continue;
3574 }
3575
3576 /*
3577 * first handle encoding stuff.
3578 */
3579 if (out->encoder != NULL) {
3580 /*
3581 * Store the data in the incoming raw buffer
3582 */
3583 if (out->conv == NULL) {
3584 out->conv = xmlBufCreate();
3585 }
3586 ret = escaping(xmlBufEnd(out->buffer) ,
3587 &chunk, str, &cons);
3588 if ((ret < 0) || (chunk == 0)) /* chunk==0 => nothing done */
3589 return(-1);
3590 xmlBufAddLen(out->buffer, chunk);
3591
3592 if ((xmlBufUse(out->buffer) < MINLEN) && (cons == len))
3593 goto done;
3594
3595 /*
3596 * convert as much as possible to the output buffer.
3597 */
3598 ret = xmlCharEncOutput(out, 0);
3599 if ((ret < 0) && (ret != -3)) {
3600 xmlIOErr(XML_IO_ENCODER, NULL);
3601 out->error = XML_IO_ENCODER;
3602 return(-1);
3603 }
3604 if (out->writecallback)
3605 nbchars = xmlBufUse(out->conv);
3606 else
3607 nbchars = ret >= 0 ? ret : 0;
3608 } else {
3609 ret = escaping(xmlBufEnd(out->buffer), &chunk, str, &cons);
3610 if ((ret < 0) || (chunk == 0)) /* chunk==0 => nothing done */
3611 return(-1);
3612 xmlBufAddLen(out->buffer, chunk);
3613 if (out->writecallback)
3614 nbchars = xmlBufUse(out->buffer);
3615 else
3616 nbchars = chunk;
3617 }
3618 str += cons;
3619 len -= cons;
3620
3621 if (out->writecallback) {
3622 if ((nbchars < MINLEN) && (len <= 0))
3623 goto done;
3624
3625 /*
3626 * second write the stuff to the I/O channel
3627 */
3628 if (out->encoder != NULL) {
3629 ret = out->writecallback(out->context,
3630 (const char *)xmlBufContent(out->conv), nbchars);
3631 if (ret >= 0)
3632 xmlBufShrink(out->conv, ret);
3633 } else {
3634 ret = out->writecallback(out->context,
3635 (const char *)xmlBufContent(out->buffer), nbchars);
3636 if (ret >= 0)
3637 xmlBufShrink(out->buffer, ret);
3638 }
3639 if (ret < 0) {
3640 xmlIOErr(XML_IO_WRITE, NULL);
3641 out->error = XML_IO_WRITE;
3642 return(ret);
3643 }
3644 if (out->written > INT_MAX - ret)
3645 out->written = INT_MAX;
3646 else
3647 out->written += ret;
3648 } else if (xmlBufAvail(out->buffer) < MINLEN) {
3649 xmlBufGrow(out->buffer, MINLEN);
3650 }
3651 written += nbchars;
3652 } while ((len > 0) && (oldwritten != written));
3653
3654done:
3655#ifdef DEBUG_INPUT
3656 xmlGenericError(xmlGenericErrorContext,
3657 "I/O: wrote %d chars\n", written);
3658#endif
3659 return(written);
3660}
3661
3662/**
3663 * xmlOutputBufferWriteString:
3664 * @out: a buffered parser output
3665 * @str: a zero terminated C string
3666 *
3667 * Write the content of the string in the output I/O buffer
3668 * This routine handle the I18N transcoding from internal UTF-8
3669 * The buffer is lossless, i.e. will store in case of partial
3670 * or delayed writes.
3671 *
3672 * Returns the number of chars immediately written, or -1
3673 * in case of error.
3674 */
3675int
3676xmlOutputBufferWriteString(xmlOutputBufferPtr out, const char *str) {
3677 int len;
3678
3679 if ((out == NULL) || (out->error)) return(-1);
3680 if (str == NULL)
3681 return(-1);
3682 len = strlen(str);
3683
3684 if (len > 0)
3685 return(xmlOutputBufferWrite(out, len, str));
3686 return(len);
3687}
3688
3689/**
3690 * xmlOutputBufferFlush:
3691 * @out: a buffered output
3692 *
3693 * flushes the output I/O channel
3694 *
3695 * Returns the number of byte written or -1 in case of error.
3696 */
3697int
3698xmlOutputBufferFlush(xmlOutputBufferPtr out) {
3699 int nbchars = 0, ret = 0;
3700
3701 if ((out == NULL) || (out->error)) return(-1);
3702 /*
3703 * first handle encoding stuff.
3704 */
3705 if ((out->conv != NULL) && (out->encoder != NULL)) {
3706 /*
3707 * convert as much as possible to the parser output buffer.
3708 */
3709 do {
3710 nbchars = xmlCharEncOutput(out, 0);
3711 if (nbchars < 0) {
3712 xmlIOErr(XML_IO_ENCODER, NULL);
3713 out->error = XML_IO_ENCODER;
3714 return(-1);
3715 }
3716 } while (nbchars);
3717 }
3718
3719 /*
3720 * second flush the stuff to the I/O channel
3721 */
3722 if ((out->conv != NULL) && (out->encoder != NULL) &&
3723 (out->writecallback != NULL)) {
3724 ret = out->writecallback(out->context,
3725 (const char *)xmlBufContent(out->conv),
3726 xmlBufUse(out->conv));
3727 if (ret >= 0)
3728 xmlBufShrink(out->conv, ret);
3729 } else if (out->writecallback != NULL) {
3730 ret = out->writecallback(out->context,
3731 (const char *)xmlBufContent(out->buffer),
3732 xmlBufUse(out->buffer));
3733 if (ret >= 0)
3734 xmlBufShrink(out->buffer, ret);
3735 }
3736 if (ret < 0) {
3737 xmlIOErr(XML_IO_FLUSH, NULL);
3738 out->error = XML_IO_FLUSH;
3739 return(ret);
3740 }
3741 if (out->written > INT_MAX - ret)
3742 out->written = INT_MAX;
3743 else
3744 out->written += ret;
3745
3746#ifdef DEBUG_INPUT
3747 xmlGenericError(xmlGenericErrorContext,
3748 "I/O: flushed %d chars\n", ret);
3749#endif
3750 return(ret);
3751}
3752#endif /* LIBXML_OUTPUT_ENABLED */
3753
3754/**
3755 * xmlParserGetDirectory:
3756 * @filename: the path to a file
3757 *
3758 * lookup the directory for that file
3759 *
3760 * Returns a new allocated string containing the directory, or NULL.
3761 */
3762char *
3763xmlParserGetDirectory(const char *filename) {
3764 char *ret = NULL;
3765 char dir[1024];
3766 char *cur;
3767
3768#ifdef _WIN32_WCE /* easy way by now ... wince does not have dirs! */
3769 return NULL;
3770#endif
3771
3772 if (xmlInputCallbackInitialized == 0)
3773 xmlRegisterDefaultInputCallbacks();
3774
3775 if (filename == NULL) return(NULL);
3776
3777#if defined(_WIN32) && !defined(__CYGWIN__)
3778# define IS_XMLPGD_SEP(ch) ((ch=='/')||(ch=='\\'))
3779#else
3780# define IS_XMLPGD_SEP(ch) (ch=='/')
3781#endif
3782
3783 strncpy(dir, filename, 1023);
3784 dir[1023] = 0;
3785 cur = &dir[strlen(dir)];
3786 while (cur > dir) {
3787 if (IS_XMLPGD_SEP(*cur)) break;
3788 cur --;
3789 }
3790 if (IS_XMLPGD_SEP(*cur)) {
3791 if (cur == dir) dir[1] = 0;
3792 else *cur = 0;
3793 ret = xmlMemStrdup(dir);
3794 } else {
3795 if (getcwd(dir, 1024) != NULL) {
3796 dir[1023] = 0;
3797 ret = xmlMemStrdup(dir);
3798 }
3799 }
3800 return(ret);
3801#undef IS_XMLPGD_SEP
3802}
3803
3804/****************************************************************
3805 * *
3806 * External entities loading *
3807 * *
3808 ****************************************************************/
3809
3810/**
3811 * xmlCheckHTTPInput:
3812 * @ctxt: an XML parser context
3813 * @ret: an XML parser input
3814 *
3815 * Check an input in case it was created from an HTTP stream, in that
3816 * case it will handle encoding and update of the base URL in case of
3817 * redirection. It also checks for HTTP errors in which case the input
3818 * is cleanly freed up and an appropriate error is raised in context
3819 *
3820 * Returns the input or NULL in case of HTTP error.
3821 */
3822xmlParserInputPtr
3823xmlCheckHTTPInput(xmlParserCtxtPtr ctxt, xmlParserInputPtr ret) {
3824#ifdef LIBXML_HTTP_ENABLED
3825 if ((ret != NULL) && (ret->buf != NULL) &&
3826 (ret->buf->readcallback == xmlIOHTTPRead) &&
3827 (ret->buf->context != NULL)) {
3828 const char *encoding;
3829 const char *redir;
3830 const char *mime;
3831 int code;
3832
3833 code = xmlNanoHTTPReturnCode(ret->buf->context);
3834 if (code >= 400) {
3835 /* fatal error */
3836 if (ret->filename != NULL)
3837 __xmlLoaderErr(ctxt, "failed to load HTTP resource \"%s\"\n",
3838 (const char *) ret->filename);
3839 else
3840 __xmlLoaderErr(ctxt, "failed to load HTTP resource\n", NULL);
3841 xmlFreeInputStream(ret);
3842 ret = NULL;
3843 } else {
3844
3845 mime = xmlNanoHTTPMimeType(ret->buf->context);
3846 if ((xmlStrstr(BAD_CAST mime, BAD_CAST "/xml")) ||
3847 (xmlStrstr(BAD_CAST mime, BAD_CAST "+xml"))) {
3848 encoding = xmlNanoHTTPEncoding(ret->buf->context);
3849 if (encoding != NULL) {
3850 xmlCharEncodingHandlerPtr handler;
3851
3852 handler = xmlFindCharEncodingHandler(encoding);
3853 if (handler != NULL) {
3854 xmlSwitchInputEncoding(ctxt, ret, handler);
3855 } else {
3856 __xmlErrEncoding(ctxt, XML_ERR_UNKNOWN_ENCODING,
3857 "Unknown encoding %s",
3858 BAD_CAST encoding, NULL);
3859 }
3860 if (ret->encoding == NULL)
3861 ret->encoding = xmlStrdup(BAD_CAST encoding);
3862 }
3863#if 0
3864 } else if (xmlStrstr(BAD_CAST mime, BAD_CAST "html")) {
3865#endif
3866 }
3867 redir = xmlNanoHTTPRedir(ret->buf->context);
3868 if (redir != NULL) {
3869 if (ret->filename != NULL)
3870 xmlFree((xmlChar *) ret->filename);
3871 if (ret->directory != NULL) {
3872 xmlFree((xmlChar *) ret->directory);
3873 ret->directory = NULL;
3874 }
3875 ret->filename =
3876 (char *) xmlStrdup((const xmlChar *) redir);
3877 }
3878 }
3879 }
3880#endif
3881 return(ret);
3882}
3883
3884static int xmlNoNetExists(const char *URL) {
3885 const char *path;
3886
3887 if (URL == NULL)
3888 return(0);
3889
3890 if (!xmlStrncasecmp(BAD_CAST URL, BAD_CAST "file://localhost/", 17))
3891#if defined (_WIN32) || defined (__DJGPP__) && !defined(__CYGWIN__)
3892 path = &URL[17];
3893#else
3894 path = &URL[16];
3895#endif
3896 else if (!xmlStrncasecmp(BAD_CAST URL, BAD_CAST "file:///", 8)) {
3897#if defined (_WIN32) || defined (__DJGPP__) && !defined(__CYGWIN__)
3898 path = &URL[8];
3899#else
3900 path = &URL[7];
3901#endif
3902 } else
3903 path = URL;
3904
3905 return xmlCheckFilename(path);
3906}
3907
3908#ifdef LIBXML_CATALOG_ENABLED
3909
3910/**
3911 * xmlResolveResourceFromCatalog:
3912 * @URL: the URL for the entity to load
3913 * @ID: the System ID for the entity to load
3914 * @ctxt: the context in which the entity is called or NULL
3915 *
3916 * Resolves the URL and ID against the appropriate catalog.
3917 * This function is used by xmlDefaultExternalEntityLoader and
3918 * xmlNoNetExternalEntityLoader.
3919 *
3920 * Returns a new allocated URL, or NULL.
3921 */
3922static xmlChar *
3923xmlResolveResourceFromCatalog(const char *URL, const char *ID,
3924 xmlParserCtxtPtr ctxt) {
3925 xmlChar *resource = NULL;
3926 xmlCatalogAllow pref;
3927
3928 /*
3929 * If the resource doesn't exists as a file,
3930 * try to load it from the resource pointed in the catalogs
3931 */
3932 pref = xmlCatalogGetDefaults();
3933
3934 if ((pref != XML_CATA_ALLOW_NONE) && (!xmlNoNetExists(URL))) {
3935 /*
3936 * Do a local lookup
3937 */
3938 if ((ctxt != NULL) && (ctxt->catalogs != NULL) &&
3939 ((pref == XML_CATA_ALLOW_ALL) ||
3940 (pref == XML_CATA_ALLOW_DOCUMENT))) {
3941 resource = xmlCatalogLocalResolve(ctxt->catalogs,
3942 (const xmlChar *)ID,
3943 (const xmlChar *)URL);
3944 }
3945 /*
3946 * Try a global lookup
3947 */
3948 if ((resource == NULL) &&
3949 ((pref == XML_CATA_ALLOW_ALL) ||
3950 (pref == XML_CATA_ALLOW_GLOBAL))) {
3951 resource = xmlCatalogResolve((const xmlChar *)ID,
3952 (const xmlChar *)URL);
3953 }
3954 if ((resource == NULL) && (URL != NULL))
3955 resource = xmlStrdup((const xmlChar *) URL);
3956
3957 /*
3958 * TODO: do an URI lookup on the reference
3959 */
3960 if ((resource != NULL) && (!xmlNoNetExists((const char *)resource))) {
3961 xmlChar *tmp = NULL;
3962
3963 if ((ctxt != NULL) && (ctxt->catalogs != NULL) &&
3964 ((pref == XML_CATA_ALLOW_ALL) ||
3965 (pref == XML_CATA_ALLOW_DOCUMENT))) {
3966 tmp = xmlCatalogLocalResolveURI(ctxt->catalogs, resource);
3967 }
3968 if ((tmp == NULL) &&
3969 ((pref == XML_CATA_ALLOW_ALL) ||
3970 (pref == XML_CATA_ALLOW_GLOBAL))) {
3971 tmp = xmlCatalogResolveURI(resource);
3972 }
3973
3974 if (tmp != NULL) {
3975 xmlFree(resource);
3976 resource = tmp;
3977 }
3978 }
3979 }
3980
3981 return resource;
3982}
3983
3984#endif
3985
3986/**
3987 * xmlDefaultExternalEntityLoader:
3988 * @URL: the URL for the entity to load
3989 * @ID: the System ID for the entity to load
3990 * @ctxt: the context in which the entity is called or NULL
3991 *
3992 * By default we don't load external entities, yet.
3993 *
3994 * Returns a new allocated xmlParserInputPtr, or NULL.
3995 */
3996static xmlParserInputPtr
3997xmlDefaultExternalEntityLoader(const char *URL, const char *ID,
3998 xmlParserCtxtPtr ctxt)
3999{
4000 xmlParserInputPtr ret = NULL;
4001 xmlChar *resource = NULL;
4002
4003#ifdef DEBUG_EXTERNAL_ENTITIES
4004 xmlGenericError(xmlGenericErrorContext,
4005 "xmlDefaultExternalEntityLoader(%s, xxx)\n", URL);
4006#endif
4007 if ((ctxt != NULL) && (ctxt->options & XML_PARSE_NONET)) {
4008 int options = ctxt->options;
4009
4010 ctxt->options -= XML_PARSE_NONET;
4011 ret = xmlNoNetExternalEntityLoader(URL, ID, ctxt);
4012 ctxt->options = options;
4013 return(ret);
4014 }
4015#ifdef LIBXML_CATALOG_ENABLED
4016 resource = xmlResolveResourceFromCatalog(URL, ID, ctxt);
4017#endif
4018
4019 if (resource == NULL)
4020 resource = (xmlChar *) URL;
4021
4022 if (resource == NULL) {
4023 if (ID == NULL)
4024 ID = "NULL";
4025 __xmlLoaderErr(ctxt, "failed to load external entity \"%s\"\n", ID);
4026 return (NULL);
4027 }
4028 ret = xmlNewInputFromFile(ctxt, (const char *) resource);
4029 if ((resource != NULL) && (resource != (xmlChar *) URL))
4030 xmlFree(resource);
4031 return (ret);
4032}
4033
4034static xmlExternalEntityLoader xmlCurrentExternalEntityLoader =
4035 xmlDefaultExternalEntityLoader;
4036
4037/**
4038 * xmlSetExternalEntityLoader:
4039 * @f: the new entity resolver function
4040 *
4041 * Changes the defaultexternal entity resolver function for the application
4042 */
4043void
4044xmlSetExternalEntityLoader(xmlExternalEntityLoader f) {
4045 xmlCurrentExternalEntityLoader = f;
4046}
4047
4048/**
4049 * xmlGetExternalEntityLoader:
4050 *
4051 * Get the default external entity resolver function for the application
4052 *
4053 * Returns the xmlExternalEntityLoader function pointer
4054 */
4055xmlExternalEntityLoader
4056xmlGetExternalEntityLoader(void) {
4057 return(xmlCurrentExternalEntityLoader);
4058}
4059
4060/**
4061 * xmlLoadExternalEntity:
4062 * @URL: the URL for the entity to load
4063 * @ID: the Public ID for the entity to load
4064 * @ctxt: the context in which the entity is called or NULL
4065 *
4066 * Load an external entity, note that the use of this function for
4067 * unparsed entities may generate problems
4068 *
4069 * Returns the xmlParserInputPtr or NULL
4070 */
4071xmlParserInputPtr
4072xmlLoadExternalEntity(const char *URL, const char *ID,
4073 xmlParserCtxtPtr ctxt) {
4074 if ((URL != NULL) && (xmlNoNetExists(URL) == 0)) {
4075 char *canonicFilename;
4076 xmlParserInputPtr ret;
4077
4078 canonicFilename = (char *) xmlCanonicPath((const xmlChar *) URL);
4079 if (canonicFilename == NULL) {
4080 xmlIOErrMemory("building canonical path\n");
4081 return(NULL);
4082 }
4083
4084 ret = xmlCurrentExternalEntityLoader(canonicFilename, ID, ctxt);
4085 xmlFree(canonicFilename);
4086 return(ret);
4087 }
4088 return(xmlCurrentExternalEntityLoader(URL, ID, ctxt));
4089}
4090
4091/************************************************************************
4092 * *
4093 * Disabling Network access *
4094 * *
4095 ************************************************************************/
4096
4097/**
4098 * xmlNoNetExternalEntityLoader:
4099 * @URL: the URL for the entity to load
4100 * @ID: the System ID for the entity to load
4101 * @ctxt: the context in which the entity is called or NULL
4102 *
4103 * A specific entity loader disabling network accesses, though still
4104 * allowing local catalog accesses for resolution.
4105 *
4106 * Returns a new allocated xmlParserInputPtr, or NULL.
4107 */
4108xmlParserInputPtr
4109xmlNoNetExternalEntityLoader(const char *URL, const char *ID,
4110 xmlParserCtxtPtr ctxt) {
4111 xmlParserInputPtr input = NULL;
4112 xmlChar *resource = NULL;
4113
4114#ifdef LIBXML_CATALOG_ENABLED
4115 resource = xmlResolveResourceFromCatalog(URL, ID, ctxt);
4116#endif
4117
4118 if (resource == NULL)
4119 resource = (xmlChar *) URL;
4120
4121 if (resource != NULL) {
4122 if ((!xmlStrncasecmp(BAD_CAST resource, BAD_CAST "ftp://", 6)) ||
4123 (!xmlStrncasecmp(BAD_CAST resource, BAD_CAST "http://", 7))) {
4124 xmlIOErr(XML_IO_NETWORK_ATTEMPT, (const char *) resource);
4125 if (resource != (xmlChar *) URL)
4126 xmlFree(resource);
4127 return(NULL);
4128 }
4129 }
4130 input = xmlDefaultExternalEntityLoader((const char *) resource, ID, ctxt);
4131 if (resource != (xmlChar *) URL)
4132 xmlFree(resource);
4133 return(input);
4134}
4135
4136#define bottom_xmlIO
4137#include "elfgcchack.h"
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette