1 /*
2 * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23 package test.auctionportal;
24
25 import java.io.OutputStream;
26 import java.io.OutputStreamWriter;
27 import java.io.PrintWriter;
28 import java.io.UnsupportedEncodingException;
29 import java.util.stream.Collectors;
30
31 import org.xml.sax.Attributes;
32 import org.xml.sax.SAXException;
33 import org.xml.sax.SAXParseException;
34 import org.xml.sax.ext.LexicalHandler;
35 import org.xml.sax.helpers.DefaultHandler;
36
37 /**
38 * A SAX2 event handlers.
39 * This SAX2 ContentHandler receives callback event then print whole document
40 * that is parsed.
41 */
42 public class XInclHandler extends DefaultHandler implements LexicalHandler {
43 /**
44 * Print writer.
45 */
46 private final PrintWriter fOut;
47
48 /**
49 * Canonical output.
50 */
51 private volatile boolean fCanonical;
52
53 /**
54 * Element depth.
55 */
56 private volatile int fElementDepth;
57
58 /**
59 * Sets whether output is canonical.
60 */
61 public void setCanonical(boolean canonical) {
62 fCanonical = canonical;
63 }
64
65 /**
66 * Sets the output stream for printing.
67 * @param stream OutputStream for message output.
68 * @param encoding File encoding for message output.
69 */
70 public XInclHandler(OutputStream stream, String encoding)
71 throws UnsupportedEncodingException {
72 // At least set one encoding.
73 if (encoding == null) {
74 encoding = "UTF8";
75 }
76
77 fOut = new PrintWriter(new OutputStreamWriter(stream, encoding), false);
78 }
79
80 /**
81 * Receive notification of the beginning of the document. Write the start
82 * document tag if it's not canonical mode.
83 * @exception org.xml.sax.SAXException Any SAX exception, possibly
84 * wrapping another exception.
85 */
86 @Override
87 public void startDocument() throws SAXException {
88 fElementDepth = 0;
89
90 if (!fCanonical) {
91 writeFlush("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
92 }
93 }
94
95 /**
96 * Receive notification of a processing instruction.
97 * @param target The processing instruction target.
98 * @param data The processing instruction data, or null if
99 * none is supplied.
100 * @exception org.xml.sax.SAXException Any SAX exception, possibly
101 * wrapping another exception.
102 */
103 @Override
104 public void processingInstruction (String target, String data)
105 throws SAXException {
106 if (fElementDepth > 0) {
107 StringBuilder instruction = new StringBuilder("<?").append(target);
108 if (data != null && data.length() > 0) {
109 instruction.append(' ').append(data);
110 }
111 instruction.append("?>");
112 writeFlush(instruction.toString());
113 }
114 }
115
116 /**
117 * Receive notification of the start of an element then write the normalized
118 * output to the file.
119 * @param uri The Namespace URI, or the empty string if the
120 * element has no Namespace URI or if Namespace
121 * processing is not being performed.
122 * @param localName The local name (without prefix), or the
123 * empty string if Namespace processing is not being
124 * performed.
125 * @param qName The qualified name (with prefix), or the
126 * empty string if qualified names are not available.
127 * @param attributes The attributes attached to the element. If
128 * there are no attributes, it shall be an empty
129 * Attributes object.
130 */
131 @Override
132 public void startElement(String uri, String local, String raw,
133 Attributes attrs) throws SAXException {
134 fElementDepth++;
135 StringBuilder start = new StringBuilder().append('<').append(raw);
136 if (attrs != null) {
137 for (int i = 0; i < attrs.getLength(); i++) {
138 start.append(' ').append(attrs.getQName(i)).append("=\"").
139 append(normalizeAndPrint(attrs.getValue(i))).append('"');
140 }
141 }
142 start.append('>');
143 writeFlush(start.toString());
144 }
145
146 /**
147 * Receive notification of character data inside an element and write
148 * normalized characters to file.
149 * @param ch The characters.
150 * @param start The start position in the character array.
151 * @param length The number of characters to use from the
152 * character array.
153 * @exception org.xml.sax.SAXException Any SAX exception, possibly
154 * wrapping another exception.
155 */
156 @Override
157 public void characters(char ch[], int start, int length)
158 throws SAXException {
159 writeFlush(normalizeAndPrint(ch, start, length));
160 }
161
162 /**
163 * Receiving notification of ignorable whitespace in element content and
164 * writing normalized ignorable characters to file.
165 * @param ch The characters.
166 * @param start The start position in the character array.
167 * @param length The number of characters to use from the
168 * character array.
169 * @exception org.xml.sax.SAXException Any SAX exception, possibly
170 * wrapping another exception.
171 */
172 @Override
173 public void ignorableWhitespace(char ch[], int start, int length)
174 throws SAXException {
175 characters(ch, start, length);
176 }
177
178 /**
179 * Receive notification of the end of an element and print end element.
180 *
181 * @param uri The Namespace URI, or the empty string if the
182 * element has no Namespace URI or if Namespace
183 * processing is not being performed.
184 * @param localName The local name (without prefix), or the
185 * empty string if Namespace processing is not being
186 * performed.
187 * @param qName The qualified name (with prefix), or the
188 * empty string if qualified names are not available.
189 */
190 @Override
191 public void endElement(String uri, String local, String raw)
192 throws SAXException {
193 fElementDepth--;
194 writeFlush("</" + raw + ">");
195 }
196
197 /**
198 * Receive notification of a parser warning and print it out.
199 * @param e The warning information encoded as an exception.
200 * @exception org.xml.sax.SAXException Any SAX exception, possibly
201 * wrapping another exception.
202 */
203 @Override
204 public void warning(SAXParseException ex) throws SAXException {
205 printError("Warning", ex);
206 }
207
208 /**
209 * Receive notification of a parser error and print it out.
210 * @param e The error information encoded as an exception.
211 * @exception org.xml.sax.SAXException Any SAX exception, possibly
212 * wrapping another exception.
213
214 */
215 @Override
216 public void error(SAXParseException ex) throws SAXException {
217 printError("Error", ex);
218 }
219
220 /**
221 * Receive notification of a parser fatal error. Throw out fatal error
222 * following print fatal error message.
223 * @param e The fatal error information encoded as an exception.
224 * @exception org.xml.sax.SAXException Any SAX exception, possibly
225 * wrapping another exception.
226
227 */
228 @Override
229 public void fatalError(SAXParseException ex) throws SAXException {
230 printError("Fatal Error", ex);
231 throw ex;
232 }
233
234 /**
235 * Do nothing on start DTD.
236 * @param name The document type name.
237 * @param publicId The declared public identifier for the
238 * external DTD subset, or null if none was declared.
239 * @param systemId The declared system identifier for the
240 * external DTD subset, or null if none was declared.
241 * (Note that this is not resolved against the document
242 * base URI.)
243 * @exception SAXException The application may raise an
244 * exception.
245 */
246 @Override
247 public void startDTD(String name, String publicId, String systemId)
248 throws SAXException {
249 }
250
251 /**
252 * Do nothing on end DTD.
253 * @exception SAXException The application may raise an exception.
254 */
255 @Override
256 public void endDTD() throws SAXException {
257 }
258
259 /**
260 * Do nothing on start entity.
261 * @param name The name of the entity. If it is a parameter
262 * entity, the name will begin with '%', and if it is the
263 * external DTD subset, it will be "[dtd]".
264 * @exception SAXException The application may raise an exception.
265 */
266 @Override
267 public void startEntity(String name) throws SAXException {
268 }
269
270 /**
271 * Do nothing on end entity.
272 * @param name The name of the entity. If it is a parameter
273 * entity, the name will begin with '%', and if it is the
274 * external DTD subset, it will be "[dtd]".
275 * @exception SAXException The application may raise an exception.
276 */
277 @Override
278 public void endEntity(String name) throws SAXException {
279 }
280
281 /**
282 * Do nothing on start CDATA section.
283 * @exception SAXException The application may raise an exception.
284 */
285 @Override
286 public void startCDATA() throws SAXException {
287 }
288
289 /**
290 * Do nothing on end CDATA section.
291 * @exception SAXException The application may raise an exception.
292 */
293 @Override
294 public void endCDATA() throws SAXException {
295 }
296
297 /**
298 * Report an normalized XML comment when receive a comment in the document.
299 *
300 * @param ch An array holding the characters in the comment.
301 * @param start The starting position in the array.
302 * @param length The number of characters to use from the array.
303 * @exception SAXException The application may raise an exception.
304 */
305 @Override
306 public void comment(char ch[], int start, int length) throws SAXException {
307 if (!fCanonical && fElementDepth > 0) {
308 writeFlush("<!--" + normalizeAndPrint(ch, start, length) + "-->");
309 }
310 }
311
312 /**
313 * Normalizes and prints the given string.
314 * @param s String to be normalized
315 */
316 private String normalizeAndPrint(String s) {
317 return s.chars().mapToObj(c -> normalizeAndPrint((char)c)).
318 collect(Collectors.joining());
319 }
320
321 /**
322 * Normalizes and prints the given array of characters.
323 * @param ch The characters to be normalized.
324 * @param start The start position in the character array.
325 * @param length The number of characters to use from the
326 * character array.
327 */
328 private String normalizeAndPrint(char[] ch, int offset, int length) {
329 return normalizeAndPrint(new String(ch, offset, length));
330 }
331
332 /**
333 * Normalizes given character.
334 * @param c char to be normalized.
335 */
336 private String normalizeAndPrint(char c) {
337 switch (c) {
338 case '<':
339 return "<";
340 case '>':
341 return ">";
342 case '&':
343 return "&";
344 case '"':
345 return """;
346 case '\r':
347 case '\n':
348 return fCanonical ? "&#" + Integer.toString(c) + ";" : String.valueOf(c);
349 default:
350 return String.valueOf(c);
351 }
352 }
353
354 /**
355 * Prints the error message.
356 * @param type error type
357 * @param ex exception that need to be printed
358 */
359 private void printError(String type, SAXParseException ex) {
360 System.err.print("[" + type + "] ");
361 String systemId = ex.getSystemId();
362 if (systemId != null) {
363 int index = systemId.lastIndexOf('/');
364 if (index != -1)
365 systemId = systemId.substring(index + 1);
366 System.err.print(systemId);
367 }
368 System.err.print(':' + ex.getLineNumber());
369 System.err.print(':' + ex.getColumnNumber());
370 System.err.println(": " + ex.getMessage());
371 System.err.flush();
372 }
373
374 /**
375 * Write out and flush.
376 * @param out string to be written.
377 */
378 private void writeFlush(String out) {
379 fOut.print(out);
380 fOut.flush();
381 }
382 }