xmlwf/xmlfile.c

   1 /* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
   2    See the file COPYING for copying permission.
   3 */
   4
   5 #include <stdio.h>
   6 #include <stdlib.h>
   7 #include <stddef.h>
   8 #include <string.h>
   9 #include <fcntl.h>
  10 #ifdef COMPILED_FROM_DSP
  11 #include "winconfig.h"
  12 #else
  13 #include "expat_config.h"
  14 #endif
  15 #include "expat.h"
  16 #include "xmlfile.h"
  17 #include "xmltchar.h"
  18 #include "filemap.h"
  19
  20 #ifdef _MSC_VER
  21 #include <io.h>
  22 #endif
  23
  24 #ifdef HAVE_UNISTD_H
  25 #include <unistd.h>
  26 #endif
  27
  28 #ifndef O_BINARY
  29 #ifdef _O_BINARY
  30 #define O_BINARY _O_BINARY
  31 #else
  32 #define O_BINARY 0
  33 #endif
  34 #endif
  35
  36 #ifdef _DEBUG
  37 #define READ_SIZE 16
  38 #else
  39 #define READ_SIZE (1024*8)
  40 #endif
  41
  42
  43 typedef struct {
  44   XML_Parser parser;
  45   int *retPtr;
  46 } PROCESS_ARGS;
  47
  48 static void
  49 reportError(XML_Parser parser, const XML_Char *filename)
  50 {
  51   int code = XML_GetErrorCode(parser);
  52   const XML_Char *message = XML_ErrorString(code);
  53   if (message)
  54     ftprintf(stdout, T("%s:%d:%d: %s\n"),
  55              filename,
  56              XML_GetErrorLineNumber(parser),
  57              XML_GetErrorColumnNumber(parser),
  58              message);
  59   else
  60     ftprintf(stderr, T("%s: (unknown message %d)\n"), filename, code);
  61 }
  62
  63 static void
  64 processFile(const void *data, size_t size,
  65             const XML_Char *filename, void *args)
  66 {
  67   XML_Parser parser = ((PROCESS_ARGS *)args)->parser;
  68   int *retPtr = ((PROCESS_ARGS *)args)->retPtr;
  69   if (XML_Parse(parser, data, size, 1) == XML_STATUS_ERROR) {
  70     reportError(parser, filename);
  71     *retPtr = 0;
  72   }
  73   else
  74     *retPtr = 1;
  75 }
  76
  77 #ifdef WIN32
  78
  79 static int
  80 isAsciiLetter(XML_Char c)
  81 {
  82   return (T('a') <= c && c <= T('z')) || (T('A') <= c && c <= T('Z'));
  83 }
  84
  85 #endif /* WIN32 */
  86
  87 static const XML_Char *
  88 resolveSystemId(const XML_Char *base, const XML_Char *systemId,
  89                 XML_Char **toFree)
  90 {
  91   XML_Char *s;
  92   *toFree = 0;
  93   if (!base
  94       || *systemId == T('/')
  95 #ifdef WIN32
  96       || *systemId == T('\\')
  97       || (isAsciiLetter(systemId[0]) && systemId[1] == T(':'))
  98 #endif
  99      )
 100     return systemId;
 101   *toFree = (XML_Char *)malloc((tcslen(base) + tcslen(systemId) + 2)
 102                                * sizeof(XML_Char));
 103   if (!*toFree)
 104     return systemId;
 105   tcscpy(*toFree, base);
 106   s = *toFree;
 107   if (tcsrchr(s, T('/')))
 108     s = tcsrchr(s, T('/')) + 1;
 109 #ifdef WIN32
 110   if (tcsrchr(s, T('\\')))
 111     s = tcsrchr(s, T('\\')) + 1;
 112 #endif
 113   tcscpy(s, systemId);
 114   return *toFree;
 115 }
 116
 117 static int
 118 externalEntityRefFilemap(XML_Parser parser,
 119                          const XML_Char *context,
 120                          const XML_Char *base,
 121                          const XML_Char *systemId,
 122                          const XML_Char *publicId)
 123 {
 124   int result;
 125   XML_Char *s;
 126   const XML_Char *filename;
 127   XML_Parser entParser = XML_ExternalEntityParserCreate(parser, context, 0);
 128   PROCESS_ARGS args;
 129   args.retPtr = &result;
 130   args.parser = entParser;
 131   filename = resolveSystemId(base, systemId, &s);
 132   XML_SetBase(entParser, filename);
 133   if (!filemap(filename, processFile, &args))
 134     result = 0;
 135   free(s);
 136   XML_ParserFree(entParser);
 137   return result;
 138 }
 139
 140 static int
 141 processStream(const XML_Char *filename, XML_Parser parser)
 142 {
 143   /* passing NULL for filename means read intput from stdin */
 144   int fd = 0;   /* 0 is the fileno for stdin */
 145
 146   if (filename != NULL) {
 147     fd = topen(filename, O_BINARY|O_RDONLY);
 148     if (fd < 0) {
 149       tperror(filename);
 150       return 0;
 151     }
 152   }
 153   for (;;) {
 154     int nread;
 155     char *buf = XML_GetBuffer(parser, READ_SIZE);
 156     if (!buf) {
 157       if (filename != NULL)
 158         close(fd);
 159       ftprintf(stderr, T("%s: out of memory\n"),
 160                filename != NULL ? filename : "xmlwf");
 161       return 0;
 162     }
 163     nread = read(fd, buf, READ_SIZE);
 164     if (nread < 0) {
 165       tperror(filename != NULL ? filename : "STDIN");
 166       if (filename != NULL)
 167         close(fd);
 168       return 0;
 169     }
 170     if (XML_ParseBuffer(parser, nread, nread == 0) == XML_STATUS_ERROR) {
 171       reportError(parser, filename != NULL ? filename : "STDIN");
 172       if (filename != NULL)
 173         close(fd);
 174       return 0;
 175     }
 176     if (nread == 0) {
 177       if (filename != NULL)
 178         close(fd);
 179       break;;
 180     }
 181   }
 182   return 1;
 183 }
 184
 185 static int
 186 externalEntityRefStream(XML_Parser parser,
 187                         const XML_Char *context,
 188                         const XML_Char *base,
 189                         const XML_Char *systemId,
 190                         const XML_Char *publicId)
 191 {
 192   XML_Char *s;
 193   const XML_Char *filename;
 194   int ret;
 195   XML_Parser entParser = XML_ExternalEntityParserCreate(parser, context, 0);
 196   filename = resolveSystemId(base, systemId, &s);
 197   XML_SetBase(entParser, filename);
 198   ret = processStream(filename, entParser);
 199   free(s);
 200   XML_ParserFree(entParser);
 201   return ret;
 202 }
 203
 204 int
 205 XML_ProcessFile(XML_Parser parser,
 206                 const XML_Char *filename,
 207                 unsigned flags)
 208 {
 209   int result;
 210
 211   if (!XML_SetBase(parser, filename)) {
 212     ftprintf(stderr, T("%s: out of memory"), filename);
 213     exit(1);
 214   }
 215
 216   if (flags & XML_EXTERNAL_ENTITIES)
 217       XML_SetExternalEntityRefHandler(parser,
 218                                       (flags & XML_MAP_FILE)
 219                                       ? externalEntityRefFilemap
 220                                       : externalEntityRefStream);
 221   if (flags & XML_MAP_FILE) {
 222     PROCESS_ARGS args;
 223     args.retPtr = &result;
 224     args.parser = parser;
 225     if (!filemap(filename, processFile, &args))
 226       result = 0;
 227   }
 228   else
 229     result = processStream(filename, parser);
 230   return result;
 231 }