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