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