001/*
002 * Licensed to the Apache Software Foundation (ASF) under one or more
003 * contributor license agreements.  See the NOTICE file distributed with
004 * this work for additional information regarding copyright ownership.
005 * The ASF licenses this file to You under the Apache License, Version 2.0
006 * (the "License"); you may not use this file except in compliance with
007 * the License.  You may obtain a copy of the License at
008 *
009 *      http://www.apache.org/licenses/LICENSE-2.0
010 *
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS,
013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 * See the License for the specific language governing permissions and
015 * limitations under the License.
016 */
017package org.apache.commons.io.input;
018
019import java.io.BufferedInputStream;
020import java.io.BufferedReader;
021import java.io.File;
022import java.io.IOException;
023import java.io.InputStream;
024import java.io.InputStreamReader;
025import java.io.Reader;
026import java.io.StringReader;
027import java.net.HttpURLConnection;
028import java.net.URL;
029import java.net.URLConnection;
030import java.nio.charset.Charset;
031import java.nio.charset.StandardCharsets;
032import java.nio.file.Files;
033import java.nio.file.Path;
034import java.text.MessageFormat;
035import java.util.Locale;
036import java.util.Objects;
037import java.util.regex.Matcher;
038import java.util.regex.Pattern;
039
040import org.apache.commons.io.ByteOrderMark;
041import org.apache.commons.io.Charsets;
042import org.apache.commons.io.IOUtils;
043import org.apache.commons.io.build.AbstractStreamBuilder;
044import org.apache.commons.io.function.IOConsumer;
045import org.apache.commons.io.output.XmlStreamWriter;
046
047/**
048 * Character stream that handles all the necessary Voodoo to figure out the charset encoding of the XML document within the stream.
049 * <p>
050 * IMPORTANT: This class is not related in any way to the org.xml.sax.XMLReader. This one IS a character stream.
051 * </p>
052 * <p>
053 * All this has to be done without consuming characters from the stream, if not the XML parser will not recognized the document as a valid XML. This is not 100%
054 * true, but it's close enough (UTF-8 BOM is not handled by all parsers right now, XmlStreamReader handles it and things work in all parsers).
055 * </p>
056 * <p>
057 * The XmlStreamReader class handles the charset encoding of XML documents in Files, raw streams and HTTP streams by offering a wide set of constructors.
058 * </p>
059 * <p>
060 * By default the charset encoding detection is lenient, the constructor with the lenient flag can be used for a script (following HTTP MIME and XML
061 * specifications). All this is nicely explained by Mark Pilgrim in his blog, <a href="http://diveintomark.org/archives/2004/02/13/xml-media-types"> Determining
062 * the character encoding of a feed</a>.
063 * </p>
064 * <p>
065 * To build an instance, see {@link Builder}.
066 * </p>
067 * <p>
068 * Originally developed for <a href="http://rome.dev.java.net">ROME</a> under Apache License 2.0.
069 * </p>
070 *
071 * @see org.apache.commons.io.output.XmlStreamWriter
072 * @since 2.0
073 */
074public class XmlStreamReader extends Reader {
075
076    /**
077     * Builds a new {@link XmlStreamWriter} instance.
078     *
079     * Constructs a Reader using an InputStream and the associated content-type header. This constructor is lenient regarding the encoding detection.
080     * <p>
081     * First it checks if the stream has BOM. If there is not BOM checks the content-type encoding. If there is not content-type encoding checks the XML prolog
082     * encoding. If there is not XML prolog encoding uses the default encoding mandated by the content-type MIME type.
083     * </p>
084     * <p>
085     * If lenient detection is indicated and the detection above fails as per specifications it then attempts the following:
086     * </p>
087     * <p>
088     * If the content type was 'text/html' it replaces it with 'text/xml' and tries the detection again.
089     * </p>
090     * <p>
091     * Else if the XML prolog had a charset encoding that encoding is used.
092     * </p>
093     * <p>
094     * Else if the content type had a charset encoding that encoding is used.
095     * </p>
096     * <p>
097     * Else 'UTF-8' is used.
098     * </p>
099     * <p>
100     * If lenient detection is indicated an XmlStreamReaderException is never thrown.
101     * </p>
102     * <p>
103     * For example:
104     * </p>
105     *
106     * <pre>{@code
107     * XmlStreamReader r = XmlStreamReader.builder()
108     *   .setPath(path)
109     *   .setCharset(StandardCharsets.UTF_8)
110     *   .get();}
111     * </pre>
112     *
113     * @since 2.12.0
114     */
115    public static class Builder extends AbstractStreamBuilder<XmlStreamReader, Builder> {
116
117        private boolean nullCharset = true;
118        private boolean lenient = true;
119        private String httpContentType;
120
121        /**
122         * Constructs a new instance.
123         * <p>
124         * This builder use the aspect InputStream, OpenOption[], httpContentType, lenient, and defaultEncoding.
125         * </p>
126         * <p>
127         * You must provide an origin that can be converted to an InputStream by this builder, otherwise, this call will throw an
128         * {@link UnsupportedOperationException}.
129         * </p>
130         *
131         * @return a new instance.
132         * @throws UnsupportedOperationException if the origin cannot provide an InputStream.
133         * @throws IOException                   thrown if there is a problem reading the stream.
134         * @throws XmlStreamReaderException      thrown if the charset encoding could not be determined according to the specification.
135         * @see #getInputStream()
136         */
137        @SuppressWarnings("resource")
138        @Override
139        public XmlStreamReader get() throws IOException {
140            final String defaultEncoding = nullCharset ? null : getCharset().name();
141            // @formatter:off
142            return httpContentType == null
143                    ? new XmlStreamReader(getInputStream(), lenient, defaultEncoding)
144                    : new XmlStreamReader(getInputStream(), httpContentType, lenient, defaultEncoding);
145            // @formatter:on
146        }
147
148        @Override
149        public Builder setCharset(final Charset charset) {
150            nullCharset = charset == null;
151            return super.setCharset(charset);
152        }
153
154        @Override
155        public Builder setCharset(final String charset) {
156            nullCharset = charset == null;
157            return super.setCharset(Charsets.toCharset(charset, getCharsetDefault()));
158        }
159
160        public Builder setHttpContentType(final String httpContentType) {
161            this.httpContentType = httpContentType;
162            return this;
163        }
164
165        public Builder setLenient(final boolean lenient) {
166            this.lenient = lenient;
167            return this;
168        }
169
170    }
171
172    private static final String UTF_8 = StandardCharsets.UTF_8.name();
173
174    private static final String US_ASCII = StandardCharsets.US_ASCII.name();
175
176    private static final String UTF_16BE = StandardCharsets.UTF_16BE.name();
177
178    private static final String UTF_16LE = StandardCharsets.UTF_16LE.name();
179
180    private static final String UTF_32BE = "UTF-32BE";
181
182    private static final String UTF_32LE = "UTF-32LE";
183
184    private static final String UTF_16 = StandardCharsets.UTF_16.name();
185
186    private static final String UTF_32 = "UTF-32";
187
188    private static final String EBCDIC = "CP1047";
189
190    private static final ByteOrderMark[] BOMS = { ByteOrderMark.UTF_8, ByteOrderMark.UTF_16BE, ByteOrderMark.UTF_16LE, ByteOrderMark.UTF_32BE,
191            ByteOrderMark.UTF_32LE };
192
193    /** UTF_16LE and UTF_32LE have the same two starting BOM bytes. */
194    private static final ByteOrderMark[] XML_GUESS_BYTES = { new ByteOrderMark(UTF_8, 0x3C, 0x3F, 0x78, 0x6D),
195            new ByteOrderMark(UTF_16BE, 0x00, 0x3C, 0x00, 0x3F), new ByteOrderMark(UTF_16LE, 0x3C, 0x00, 0x3F, 0x00),
196            new ByteOrderMark(UTF_32BE, 0x00, 0x00, 0x00, 0x3C, 0x00, 0x00, 0x00, 0x3F, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x6D),
197            new ByteOrderMark(UTF_32LE, 0x3C, 0x00, 0x00, 0x00, 0x3F, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x6D, 0x00, 0x00, 0x00),
198            new ByteOrderMark(EBCDIC, 0x4C, 0x6F, 0xA7, 0x94) };
199
200    private static final Pattern CHARSET_PATTERN = Pattern.compile("charset=[\"']?([.[^; \"']]*)[\"']?");
201
202    /**
203     * Pattern capturing the encoding of the "xml" processing instruction.
204     */
205    public static final Pattern ENCODING_PATTERN = Pattern.compile("<\\?xml.*encoding[\\s]*=[\\s]*((?:\".[^\"]*\")|(?:'.[^']*'))", Pattern.MULTILINE);
206
207    private static final String RAW_EX_1 = "Illegal encoding, BOM [{0}] XML guess [{1}] XML prolog [{2}] encoding mismatch";
208
209    private static final String RAW_EX_2 = "Illegal encoding, BOM [{0}] XML guess [{1}] XML prolog [{2}] unknown BOM";
210
211    private static final String HTTP_EX_1 = "Illegal encoding, CT-MIME [{0}] CT-Enc [{1}] BOM [{2}] XML guess [{3}] XML prolog [{4}], BOM must be NULL";
212
213    private static final String HTTP_EX_2 = "Illegal encoding, CT-MIME [{0}] CT-Enc [{1}] BOM [{2}] XML guess [{3}] XML prolog [{4}], encoding mismatch";
214
215    private static final String HTTP_EX_3 = "Illegal encoding, CT-MIME [{0}] CT-Enc [{1}] BOM [{2}] XML guess [{3}] XML prolog [{4}], Illegal MIME";
216
217    /**
218     * Constructs a new {@link Builder}.
219     *
220     * @return a new {@link Builder}.
221     * @since 2.12.0
222     */
223    public static Builder builder() {
224        return new Builder();
225    }
226
227    /**
228     * Gets the charset parameter value, NULL if not present, NULL if httpContentType is NULL.
229     *
230     * @param httpContentType the HTTP content type
231     * @return The content type encoding (upcased)
232     */
233    static String getContentTypeEncoding(final String httpContentType) {
234        String encoding = null;
235        if (httpContentType != null) {
236            final int i = httpContentType.indexOf(";");
237            if (i > -1) {
238                final String postMime = httpContentType.substring(i + 1);
239                final Matcher m = CHARSET_PATTERN.matcher(postMime);
240                encoding = m.find() ? m.group(1) : null;
241                encoding = encoding != null ? encoding.toUpperCase(Locale.ROOT) : null;
242            }
243        }
244        return encoding;
245    }
246
247    /**
248     * Gets the MIME type or NULL if httpContentType is NULL.
249     *
250     * @param httpContentType the HTTP content type
251     * @return The mime content type
252     */
253    static String getContentTypeMime(final String httpContentType) {
254        String mime = null;
255        if (httpContentType != null) {
256            final int i = httpContentType.indexOf(";");
257            if (i >= 0) {
258                mime = httpContentType.substring(0, i);
259            } else {
260                mime = httpContentType;
261            }
262            mime = mime.trim();
263        }
264        return mime;
265    }
266
267    /**
268     * Gets the encoding declared in the <?xml encoding=...?>, NULL if none.
269     *
270     * @param inputStream InputStream to create the reader from.
271     * @param guessedEnc  guessed encoding
272     * @return the encoding declared in the <?xml encoding=...?>
273     * @throws IOException thrown if there is a problem reading the stream.
274     */
275    private static String getXmlProlog(final InputStream inputStream, final String guessedEnc) throws IOException {
276        String encoding = null;
277        if (guessedEnc != null) {
278            final byte[] bytes = IOUtils.byteArray();
279            inputStream.mark(IOUtils.DEFAULT_BUFFER_SIZE);
280            int offset = 0;
281            int max = IOUtils.DEFAULT_BUFFER_SIZE;
282            int c = inputStream.read(bytes, offset, max);
283            int firstGT = -1;
284            String xmlProlog = ""; // avoid possible NPE warning (cannot happen; this just silences the warning)
285            while (c != -1 && firstGT == -1 && offset < IOUtils.DEFAULT_BUFFER_SIZE) {
286                offset += c;
287                max -= c;
288                c = inputStream.read(bytes, offset, max);
289                xmlProlog = new String(bytes, 0, offset, guessedEnc);
290                firstGT = xmlProlog.indexOf('>');
291            }
292            if (firstGT == -1) {
293                if (c == -1) {
294                    throw new IOException("Unexpected end of XML stream");
295                }
296                throw new IOException("XML prolog or ROOT element not found on first " + offset + " bytes");
297            }
298            final int bytesRead = offset;
299            if (bytesRead > 0) {
300                inputStream.reset();
301                final BufferedReader bReader = new BufferedReader(new StringReader(xmlProlog.substring(0, firstGT + 1)));
302                final StringBuilder prolog = new StringBuilder();
303                IOConsumer.forEach(bReader.lines(), prolog::append);
304                final Matcher m = ENCODING_PATTERN.matcher(prolog);
305                if (m.find()) {
306                    encoding = m.group(1).toUpperCase(Locale.ROOT);
307                    encoding = encoding.substring(1, encoding.length() - 1);
308                }
309            }
310        }
311        return encoding;
312    }
313
314    /**
315     * Tests if the MIME type belongs to the APPLICATION XML family.
316     *
317     * @param mime The mime type
318     * @return true if the mime type belongs to the APPLICATION XML family, otherwise false
319     */
320    static boolean isAppXml(final String mime) {
321        return mime != null && (mime.equals("application/xml") || mime.equals("application/xml-dtd") || mime.equals("application/xml-external-parsed-entity")
322                || mime.startsWith("application/") && mime.endsWith("+xml"));
323    }
324
325    /**
326     * Tests if the MIME type belongs to the TEXT XML family.
327     *
328     * @param mime The mime type
329     * @return true if the mime type belongs to the TEXT XML family, otherwise false
330     */
331    static boolean isTextXml(final String mime) {
332        return mime != null && (mime.equals("text/xml") || mime.equals("text/xml-external-parsed-entity") || mime.startsWith("text/") && mime.endsWith("+xml"));
333    }
334
335    private final Reader reader;
336
337    private final String encoding;
338
339    private final String defaultEncoding;
340
341    /**
342     * Constructs a Reader for a File.
343     * <p>
344     * It looks for the UTF-8 BOM first, if none sniffs the XML prolog charset, if this is also missing defaults to UTF-8.
345     * </p>
346     * <p>
347     * It does a lenient charset encoding detection, check the constructor with the lenient parameter for details.
348     * </p>
349     *
350     * @param file File to create a Reader from.
351     * @throws NullPointerException if the input is {@code null}.
352     * @throws IOException thrown if there is a problem reading the file.
353     * @deprecated Use {@link #builder()}, {@link Builder}, and {@link Builder#get()}
354     */
355    @Deprecated
356    public XmlStreamReader(final File file) throws IOException {
357        this(Objects.requireNonNull(file, "file").toPath());
358    }
359
360    /**
361     * Constructs a Reader for a raw InputStream.
362     * <p>
363     * It follows the same logic used for files.
364     * </p>
365     * <p>
366     * It does a lenient charset encoding detection, check the constructor with the lenient parameter for details.
367     * </p>
368     *
369     * @param inputStream InputStream to create a Reader from.
370     * @throws NullPointerException if the input stream is {@code null}.
371     * @throws IOException thrown if there is a problem reading the stream.
372     * @deprecated Use {@link #builder()}, {@link Builder}, and {@link Builder#get()}
373     */
374    @Deprecated
375    public XmlStreamReader(final InputStream inputStream) throws IOException {
376        this(inputStream, true);
377    }
378
379    /**
380     * Constructs a Reader for a raw InputStream.
381     * <p>
382     * It follows the same logic used for files.
383     * </p>
384     * <p>
385     * If lenient detection is indicated and the detection above fails as per specifications it then attempts the following:
386     * </p>
387     * <p>
388     * If the content type was 'text/html' it replaces it with 'text/xml' and tries the detection again.
389     * </p>
390     * <p>
391     * Else if the XML prolog had a charset encoding that encoding is used.
392     * </p>
393     * <p>
394     * Else if the content type had a charset encoding that encoding is used.
395     * </p>
396     * <p>
397     * Else 'UTF-8' is used.
398     * </p>
399     * <p>
400     * If lenient detection is indicated an XmlStreamReaderException is never thrown.
401     * </p>
402     *
403     * @param inputStream InputStream to create a Reader from.
404     * @param lenient     indicates if the charset encoding detection should be relaxed.
405     * @throws NullPointerException if the input stream is {@code null}.
406     * @throws IOException              thrown if there is a problem reading the stream.
407     * @throws XmlStreamReaderException thrown if the charset encoding could not be determined according to the specification.
408     * @deprecated Use {@link #builder()}, {@link Builder}, and {@link Builder#get()}
409     */
410    @Deprecated
411    public XmlStreamReader(final InputStream inputStream, final boolean lenient) throws IOException {
412        this(inputStream, lenient, null);
413    }
414
415    /**
416     * Constructs a Reader for a raw InputStream.
417     * <p>
418     * It follows the same logic used for files.
419     * </p>
420     * <p>
421     * If lenient detection is indicated and the detection above fails as per specifications it then attempts the following:
422     * </p>
423     * <p>
424     * If the content type was 'text/html' it replaces it with 'text/xml' and tries the detection again.
425     * </p>
426     * <p>
427     * Else if the XML prolog had a charset encoding that encoding is used.
428     * </p>
429     * <p>
430     * Else if the content type had a charset encoding that encoding is used.
431     * </p>
432     * <p>
433     * Else 'UTF-8' is used.
434     * </p>
435     * <p>
436     * If lenient detection is indicated an XmlStreamReaderException is never thrown.
437     * </p>
438     *
439     * @param inputStream     InputStream to create a Reader from.
440     * @param lenient         indicates if the charset encoding detection should be relaxed.
441     * @param defaultEncoding The default encoding
442     * @throws NullPointerException if the input stream is {@code null}.
443     * @throws IOException              thrown if there is a problem reading the stream.
444     * @throws XmlStreamReaderException thrown if the charset encoding could not be determined according to the specification.
445     * @deprecated Use {@link #builder()}, {@link Builder}, and {@link Builder#get()}
446     */
447    @Deprecated
448    @SuppressWarnings("resource") // InputStream is managed through a InputStreamReader in this instance.
449    public XmlStreamReader(final InputStream inputStream, final boolean lenient, final String defaultEncoding) throws IOException {
450        Objects.requireNonNull(inputStream, "inputStream");
451        this.defaultEncoding = defaultEncoding;
452        final BOMInputStream bom = new BOMInputStream(new BufferedInputStream(inputStream, IOUtils.DEFAULT_BUFFER_SIZE), false, BOMS);
453        final BOMInputStream pis = new BOMInputStream(bom, true, XML_GUESS_BYTES);
454        this.encoding = doRawStream(bom, pis, lenient);
455        this.reader = new InputStreamReader(pis, encoding);
456    }
457
458    /**
459     * Constructs a Reader using an InputStream and the associated content-type header.
460     * <p>
461     * First it checks if the stream has BOM. If there is not BOM checks the content-type encoding. If there is not content-type encoding checks the XML prolog
462     * encoding. If there is not XML prolog encoding uses the default encoding mandated by the content-type MIME type.
463     * </p>
464     * <p>
465     * It does a lenient charset encoding detection, check the constructor with the lenient parameter for details.
466     * </p>
467     *
468     * @param inputStream     InputStream to create the reader from.
469     * @param httpContentType content-type header to use for the resolution of the charset encoding.
470     * @throws NullPointerException if the input stream is {@code null}.
471     * @throws IOException thrown if there is a problem reading the file.
472     * @deprecated Use {@link #builder()}, {@link Builder}, and {@link Builder#get()}
473     */
474    @Deprecated
475    public XmlStreamReader(final InputStream inputStream, final String httpContentType) throws IOException {
476        this(inputStream, httpContentType, true);
477    }
478
479    /**
480     * Constructs a Reader using an InputStream and the associated content-type header. This constructor is lenient regarding the encoding detection.
481     * <p>
482     * First it checks if the stream has BOM. If there is not BOM checks the content-type encoding. If there is not content-type encoding checks the XML prolog
483     * encoding. If there is not XML prolog encoding uses the default encoding mandated by the content-type MIME type.
484     * </p>
485     * <p>
486     * If lenient detection is indicated and the detection above fails as per specifications it then attempts the following:
487     * </p>
488     * <p>
489     * If the content type was 'text/html' it replaces it with 'text/xml' and tries the detection again.
490     * </p>
491     * <p>
492     * Else if the XML prolog had a charset encoding that encoding is used.
493     * </p>
494     * <p>
495     * Else if the content type had a charset encoding that encoding is used.
496     * </p>
497     * <p>
498     * Else 'UTF-8' is used.
499     * </p>
500     * <p>
501     * If lenient detection is indicated an XmlStreamReaderException is never thrown.
502     * </p>
503     *
504     * @param inputStream     InputStream to create the reader from.
505     * @param httpContentType content-type header to use for the resolution of the charset encoding.
506     * @param lenient         indicates if the charset encoding detection should be relaxed.
507     * @throws NullPointerException if the input stream is {@code null}.
508     * @throws IOException              thrown if there is a problem reading the file.
509     * @throws XmlStreamReaderException thrown if the charset encoding could not be determined according to the specification.
510     * @deprecated Use {@link #builder()}, {@link Builder}, and {@link Builder#get()}
511     */
512    @Deprecated
513    public XmlStreamReader(final InputStream inputStream, final String httpContentType, final boolean lenient) throws IOException {
514        this(inputStream, httpContentType, lenient, null);
515    }
516
517    /**
518     * Constructs a Reader using an InputStream and the associated content-type header. This constructor is lenient regarding the encoding detection.
519     * <p>
520     * First it checks if the stream has BOM. If there is not BOM checks the content-type encoding. If there is not content-type encoding checks the XML prolog
521     * encoding. If there is not XML prolog encoding uses the default encoding mandated by the content-type MIME type.
522     * </p>
523     * <p>
524     * If lenient detection is indicated and the detection above fails as per specifications it then attempts the following:
525     * </p>
526     * <p>
527     * If the content type was 'text/html' it replaces it with 'text/xml' and tries the detection again.
528     * </p>
529     * <p>
530     * Else if the XML prolog had a charset encoding that encoding is used.
531     * </p>
532     * <p>
533     * Else if the content type had a charset encoding that encoding is used.
534     * </p>
535     * <p>
536     * Else 'UTF-8' is used.
537     * </p>
538     * <p>
539     * If lenient detection is indicated an XmlStreamReaderException is never thrown.
540     * </p>
541     *
542     * @param inputStream     InputStream to create the reader from.
543     * @param httpContentType content-type header to use for the resolution of the charset encoding.
544     * @param lenient         indicates if the charset encoding detection should be relaxed.
545     * @param defaultEncoding The default encoding
546     * @throws NullPointerException if the input stream is {@code null}.
547     * @throws IOException              thrown if there is a problem reading the file.
548     * @throws XmlStreamReaderException thrown if the charset encoding could not be determined according to the specification.
549     * @deprecated Use {@link #builder()}, {@link Builder}, and {@link Builder#get()}
550     */
551    @Deprecated
552    @SuppressWarnings("resource") // InputStream is managed through a InputStreamReader in this instance.
553    public XmlStreamReader(final InputStream inputStream, final String httpContentType, final boolean lenient, final String defaultEncoding)
554            throws IOException {
555        Objects.requireNonNull(inputStream, "inputStream");
556        this.defaultEncoding = defaultEncoding;
557        final BOMInputStream bom = new BOMInputStream(new BufferedInputStream(inputStream, IOUtils.DEFAULT_BUFFER_SIZE), false, BOMS);
558        final BOMInputStream pis = new BOMInputStream(bom, true, XML_GUESS_BYTES);
559        this.encoding = processHttpStream(bom, pis, httpContentType, lenient);
560        this.reader = new InputStreamReader(pis, encoding);
561    }
562
563    /**
564     * Constructs a Reader for a File.
565     * <p>
566     * It looks for the UTF-8 BOM first, if none sniffs the XML prolog charset, if this is also missing defaults to UTF-8.
567     * </p>
568     * <p>
569     * It does a lenient charset encoding detection, check the constructor with the lenient parameter for details.
570     * </p>
571     *
572     * @param file File to create a Reader from.
573     * @throws NullPointerException if the input is {@code null}.
574     * @throws IOException thrown if there is a problem reading the file.
575     * @since 2.11.0
576     * @deprecated Use {@link #builder()}, {@link Builder}, and {@link Builder#get()}
577     */
578    @Deprecated
579    @SuppressWarnings("resource") // InputStream is managed through another reader in this instance.
580    public XmlStreamReader(final Path file) throws IOException {
581        this(Files.newInputStream(Objects.requireNonNull(file, "file")));
582    }
583
584    /**
585     * Constructs a Reader using the InputStream of a URL.
586     * <p>
587     * If the URL is not of type HTTP and there is not 'content-type' header in the fetched data it uses the same logic used for Files.
588     * </p>
589     * <p>
590     * If the URL is a HTTP Url or there is a 'content-type' header in the fetched data it uses the same logic used for an InputStream with content-type.
591     * </p>
592     * <p>
593     * It does a lenient charset encoding detection, check the constructor with the lenient parameter for details.
594     * </p>
595     *
596     * @param url URL to create a Reader from.
597     * @throws NullPointerException if the input is {@code null}.
598     * @throws IOException thrown if there is a problem reading the stream of the URL.
599     */
600    public XmlStreamReader(final URL url) throws IOException {
601        this(Objects.requireNonNull(url, "url").openConnection(), null);
602    }
603
604    /**
605     * Constructs a Reader using the InputStream of a URLConnection.
606     * <p>
607     * If the URLConnection is not of type HttpURLConnection and there is not 'content-type' header in the fetched data it uses the same logic used for files.
608     * </p>
609     * <p>
610     * If the URLConnection is a HTTP Url or there is a 'content-type' header in the fetched data it uses the same logic used for an InputStream with
611     * content-type.
612     * </p>
613     * <p>
614     * It does a lenient charset encoding detection, check the constructor with the lenient parameter for details.
615     * </p>
616     *
617     * @param urlConnection   URLConnection to create a Reader from.
618     * @param defaultEncoding The default encoding
619     * @throws NullPointerException if the input is {@code null}.
620     * @throws IOException thrown if there is a problem reading the stream of the URLConnection.
621     */
622    public XmlStreamReader(final URLConnection urlConnection, final String defaultEncoding) throws IOException {
623        Objects.requireNonNull(urlConnection, "urlConnection");
624        this.defaultEncoding = defaultEncoding;
625        final boolean lenient = true;
626        final String contentType = urlConnection.getContentType();
627        final InputStream inputStream = urlConnection.getInputStream();
628        @SuppressWarnings("resource") // managed by the InputStreamReader tracked by this instance
629        // @formatter:off
630        final BOMInputStream bomInput = BOMInputStream.builder()
631            .setInputStream(new BufferedInputStream(inputStream, IOUtils.DEFAULT_BUFFER_SIZE))
632            .setInclude(false)
633            .setByteOrderMarks(BOMS)
634            .get();
635        @SuppressWarnings("resource")
636        final BOMInputStream piInput = BOMInputStream.builder()
637            .setInputStream(new BufferedInputStream(bomInput, IOUtils.DEFAULT_BUFFER_SIZE))
638            .setInclude(true)
639            .setByteOrderMarks(XML_GUESS_BYTES)
640            .get();
641        // @formatter:on
642        if (urlConnection instanceof HttpURLConnection || contentType != null) {
643            this.encoding = processHttpStream(bomInput, piInput, contentType, lenient);
644        } else {
645            this.encoding = doRawStream(bomInput, piInput, lenient);
646        }
647        this.reader = new InputStreamReader(piInput, encoding);
648    }
649
650    /**
651     * Calculates the HTTP encoding.
652     *
653     * @param httpContentType The HTTP content type
654     * @param bomEnc          BOM encoding
655     * @param xmlGuessEnc     XML Guess encoding
656     * @param xmlEnc          XML encoding
657     * @param lenient         indicates if the charset encoding detection should be relaxed.
658     * @return the HTTP encoding
659     * @throws IOException thrown if there is a problem reading the stream.
660     */
661    String calculateHttpEncoding(final String httpContentType, final String bomEnc, final String xmlGuessEnc, final String xmlEnc, final boolean lenient)
662            throws IOException {
663
664        // Lenient and has XML encoding
665        if (lenient && xmlEnc != null) {
666            return xmlEnc;
667        }
668
669        // Determine mime/encoding content types from HTTP Content Type
670        final String cTMime = getContentTypeMime(httpContentType);
671        final String cTEnc = getContentTypeEncoding(httpContentType);
672        final boolean appXml = isAppXml(cTMime);
673        final boolean textXml = isTextXml(cTMime);
674
675        // Mime type NOT "application/xml" or "text/xml"
676        if (!appXml && !textXml) {
677            final String msg = MessageFormat.format(HTTP_EX_3, cTMime, cTEnc, bomEnc, xmlGuessEnc, xmlEnc);
678            throw new XmlStreamReaderException(msg, cTMime, cTEnc, bomEnc, xmlGuessEnc, xmlEnc);
679        }
680
681        // No content type encoding
682        if (cTEnc == null) {
683            if (appXml) {
684                return calculateRawEncoding(bomEnc, xmlGuessEnc, xmlEnc);
685            }
686            return defaultEncoding == null ? US_ASCII : defaultEncoding;
687        }
688
689        // UTF-16BE or UTF-16LE content type encoding
690        if (cTEnc.equals(UTF_16BE) || cTEnc.equals(UTF_16LE)) {
691            if (bomEnc != null) {
692                final String msg = MessageFormat.format(HTTP_EX_1, cTMime, cTEnc, bomEnc, xmlGuessEnc, xmlEnc);
693                throw new XmlStreamReaderException(msg, cTMime, cTEnc, bomEnc, xmlGuessEnc, xmlEnc);
694            }
695            return cTEnc;
696        }
697
698        // UTF-16 content type encoding
699        if (cTEnc.equals(UTF_16)) {
700            if (bomEnc != null && bomEnc.startsWith(UTF_16)) {
701                return bomEnc;
702            }
703            final String msg = MessageFormat.format(HTTP_EX_2, cTMime, cTEnc, bomEnc, xmlGuessEnc, xmlEnc);
704            throw new XmlStreamReaderException(msg, cTMime, cTEnc, bomEnc, xmlGuessEnc, xmlEnc);
705        }
706
707        // UTF-32BE or UTF-132E content type encoding
708        if (cTEnc.equals(UTF_32BE) || cTEnc.equals(UTF_32LE)) {
709            if (bomEnc != null) {
710                final String msg = MessageFormat.format(HTTP_EX_1, cTMime, cTEnc, bomEnc, xmlGuessEnc, xmlEnc);
711                throw new XmlStreamReaderException(msg, cTMime, cTEnc, bomEnc, xmlGuessEnc, xmlEnc);
712            }
713            return cTEnc;
714        }
715
716        // UTF-32 content type encoding
717        if (cTEnc.equals(UTF_32)) {
718            if (bomEnc != null && bomEnc.startsWith(UTF_32)) {
719                return bomEnc;
720            }
721            final String msg = MessageFormat.format(HTTP_EX_2, cTMime, cTEnc, bomEnc, xmlGuessEnc, xmlEnc);
722            throw new XmlStreamReaderException(msg, cTMime, cTEnc, bomEnc, xmlGuessEnc, xmlEnc);
723        }
724
725        return cTEnc;
726    }
727
728    /**
729     * Calculate the raw encoding.
730     *
731     * @param bomEnc      BOM encoding
732     * @param xmlGuessEnc XML Guess encoding
733     * @param xmlEnc      XML encoding
734     * @return the raw encoding
735     * @throws IOException thrown if there is a problem reading the stream.
736     */
737    String calculateRawEncoding(final String bomEnc, final String xmlGuessEnc, final String xmlEnc) throws IOException {
738
739        // BOM is Null
740        if (bomEnc == null) {
741            if (xmlGuessEnc == null || xmlEnc == null) {
742                return defaultEncoding == null ? UTF_8 : defaultEncoding;
743            }
744            if (xmlEnc.equals(UTF_16) && (xmlGuessEnc.equals(UTF_16BE) || xmlGuessEnc.equals(UTF_16LE))) {
745                return xmlGuessEnc;
746            }
747            return xmlEnc;
748        }
749
750        // BOM is UTF-8
751        if (bomEnc.equals(UTF_8)) {
752            if (xmlGuessEnc != null && !xmlGuessEnc.equals(UTF_8)) {
753                final String msg = MessageFormat.format(RAW_EX_1, bomEnc, xmlGuessEnc, xmlEnc);
754                throw new XmlStreamReaderException(msg, bomEnc, xmlGuessEnc, xmlEnc);
755            }
756            if (xmlEnc != null && !xmlEnc.equals(UTF_8)) {
757                final String msg = MessageFormat.format(RAW_EX_1, bomEnc, xmlGuessEnc, xmlEnc);
758                throw new XmlStreamReaderException(msg, bomEnc, xmlGuessEnc, xmlEnc);
759            }
760            return bomEnc;
761        }
762
763        // BOM is UTF-16BE or UTF-16LE
764        if (bomEnc.equals(UTF_16BE) || bomEnc.equals(UTF_16LE)) {
765            if (xmlGuessEnc != null && !xmlGuessEnc.equals(bomEnc)) {
766                final String msg = MessageFormat.format(RAW_EX_1, bomEnc, xmlGuessEnc, xmlEnc);
767                throw new XmlStreamReaderException(msg, bomEnc, xmlGuessEnc, xmlEnc);
768            }
769            if (xmlEnc != null && !xmlEnc.equals(UTF_16) && !xmlEnc.equals(bomEnc)) {
770                final String msg = MessageFormat.format(RAW_EX_1, bomEnc, xmlGuessEnc, xmlEnc);
771                throw new XmlStreamReaderException(msg, bomEnc, xmlGuessEnc, xmlEnc);
772            }
773            return bomEnc;
774        }
775
776        // BOM is UTF-32BE or UTF-32LE
777        if (bomEnc.equals(UTF_32BE) || bomEnc.equals(UTF_32LE)) {
778            if (xmlGuessEnc != null && !xmlGuessEnc.equals(bomEnc)) {
779                final String msg = MessageFormat.format(RAW_EX_1, bomEnc, xmlGuessEnc, xmlEnc);
780                throw new XmlStreamReaderException(msg, bomEnc, xmlGuessEnc, xmlEnc);
781            }
782            if (xmlEnc != null && !xmlEnc.equals(UTF_32) && !xmlEnc.equals(bomEnc)) {
783                final String msg = MessageFormat.format(RAW_EX_1, bomEnc, xmlGuessEnc, xmlEnc);
784                throw new XmlStreamReaderException(msg, bomEnc, xmlGuessEnc, xmlEnc);
785            }
786            return bomEnc;
787        }
788
789        // BOM is something else
790        final String msg = MessageFormat.format(RAW_EX_2, bomEnc, xmlGuessEnc, xmlEnc);
791        throw new XmlStreamReaderException(msg, bomEnc, xmlGuessEnc, xmlEnc);
792    }
793
794    /**
795     * Closes the XmlStreamReader stream.
796     *
797     * @throws IOException thrown if there was a problem closing the stream.
798     */
799    @Override
800    public void close() throws IOException {
801        reader.close();
802    }
803
804    /**
805     * Does lenient detection.
806     *
807     * @param httpContentType content-type header to use for the resolution of the charset encoding.
808     * @param ex              The thrown exception
809     * @return the encoding
810     * @throws IOException thrown if there is a problem reading the stream.
811     */
812    private String doLenientDetection(String httpContentType, XmlStreamReaderException ex) throws IOException {
813        if (httpContentType != null && httpContentType.startsWith("text/html")) {
814            httpContentType = httpContentType.substring("text/html".length());
815            httpContentType = "text/xml" + httpContentType;
816            try {
817                return calculateHttpEncoding(httpContentType, ex.getBomEncoding(), ex.getXmlGuessEncoding(), ex.getXmlEncoding(), true);
818            } catch (final XmlStreamReaderException ex2) {
819                ex = ex2;
820            }
821        }
822        String encoding = ex.getXmlEncoding();
823        if (encoding == null) {
824            encoding = ex.getContentTypeEncoding();
825        }
826        if (encoding == null) {
827            encoding = defaultEncoding == null ? UTF_8 : defaultEncoding;
828        }
829        return encoding;
830    }
831
832    /**
833     * Process the raw stream.
834     *
835     * @param bom     BOMInputStream to detect byte order marks
836     * @param pis     BOMInputStream to guess XML encoding
837     * @param lenient indicates if the charset encoding detection should be relaxed.
838     * @return the encoding to be used
839     * @throws IOException thrown if there is a problem reading the stream.
840     */
841    private String doRawStream(final BOMInputStream bom, final BOMInputStream pis, final boolean lenient) throws IOException {
842        final String bomEnc = bom.getBOMCharsetName();
843        final String xmlGuessEnc = pis.getBOMCharsetName();
844        final String xmlEnc = getXmlProlog(pis, xmlGuessEnc);
845        try {
846            return calculateRawEncoding(bomEnc, xmlGuessEnc, xmlEnc);
847        } catch (final XmlStreamReaderException ex) {
848            if (lenient) {
849                return doLenientDetection(null, ex);
850            }
851            throw ex;
852        }
853    }
854
855    /**
856     * Gets the default encoding to use if none is set in HTTP content-type, XML prolog and the rules based on content-type are not adequate.
857     * <p>
858     * If it is NULL the content-type based rules are used.
859     * </p>
860     *
861     * @return the default encoding to use.
862     */
863    public String getDefaultEncoding() {
864        return defaultEncoding;
865    }
866
867    /**
868     * Gets the charset encoding of the XmlStreamReader.
869     *
870     * @return charset encoding.
871     */
872    public String getEncoding() {
873        return encoding;
874    }
875
876    /**
877     * Processes an HTTP stream.
878     *
879     * @param bomInput        BOMInputStream to detect byte order marks
880     * @param piInput         BOMInputStream to guess XML encoding
881     * @param httpContentType The HTTP content type
882     * @param lenient         indicates if the charset encoding detection should be relaxed.
883     * @return the encoding to be used
884     * @throws IOException thrown if there is a problem reading the stream.
885     */
886    private String processHttpStream(final BOMInputStream bomInput, final BOMInputStream piInput, final String httpContentType, final boolean lenient)
887            throws IOException {
888        final String bomEnc = bomInput.getBOMCharsetName();
889        final String xmlGuessEnc = piInput.getBOMCharsetName();
890        final String xmlEnc = getXmlProlog(piInput, xmlGuessEnc);
891        try {
892            return calculateHttpEncoding(httpContentType, bomEnc, xmlGuessEnc, xmlEnc, lenient);
893        } catch (final XmlStreamReaderException ex) {
894            if (lenient) {
895                return doLenientDetection(httpContentType, ex);
896            }
897            throw ex;
898        }
899    }
900
901    /**
902     * Reads the underlying reader's {@code read(char[], int, int)} method.
903     *
904     * @param buf    the buffer to read the characters into
905     * @param offset The start offset
906     * @param len    The number of bytes to read
907     * @return the number of characters read or -1 if the end of stream
908     * @throws IOException if an I/O error occurs.
909     */
910    @Override
911    public int read(final char[] buf, final int offset, final int len) throws IOException {
912        return reader.read(buf, offset, len);
913    }
914
915}