← Back to branch summary

~ubuntu-branches/ubuntu/hardy/ghostscript/hardy

« back to all changes in this revision

Viewing changes to expat/xmlwf/xmlfile.c

  • Committer: Bazaar Package Importer
  • Author(s): Till Kamppeter
  • Date: 2007-11-22 12:17:43 UTC
  • mfrom: (1.1.7 upstream)
  • Revision ID: james.westby@ubuntu.com-20071122121743-cd70s3ypq0r243mp
Tags: 8.61.dfsg.1-0ubtuntu1
* New upstream release
  o Final 8.61 release
* debian/patches/09_ijs_krgb_support.dpatch: Adapted to upstream changes.
* debian/rules: Updated CUPS-related variables for "make install" calls.
* debian/rules: Remove /usr/include/ghostscript from the ghostscript
  package, they go into lings-dev.

Show diffs side-by-side

added added

removed removed

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