1 /*
2 * Copyright (c) 1997, 2015, 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. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package com.sun.xml.internal.ws.api.streaming;
27
28 import com.sun.istack.internal.NotNull;
29 import com.sun.istack.internal.Nullable;
30 import com.sun.xml.internal.ws.streaming.XMLReaderException;
31 import com.sun.xml.internal.ws.util.xml.XmlUtil;
32 import org.xml.sax.InputSource;
33
34 import javax.xml.stream.XMLInputFactory;
35 import javax.xml.stream.XMLStreamException;
36 import javax.xml.stream.XMLStreamReader;
37 import java.io.IOException;
38 import java.io.InputStream;
39 import java.io.InputStreamReader;
40 import java.io.Reader;
41 import java.io.StringReader;
42 import java.io.UnsupportedEncodingException;
43 import java.lang.reflect.InvocationTargetException;
44 import java.lang.reflect.Method;
45 import java.net.URL;
46 import java.security.AccessController;
47 import java.util.logging.Level;
48 import java.util.logging.Logger;
49
50 import com.sun.xml.internal.ws.resources.StreamingMessages;
51
52 /**
53 * Factory for {@link XMLStreamReader}.
54 *
55 * <p>
56 * This wraps {@link XMLInputFactory} and allows us to reuse {@link XMLStreamReader} instances
57 * when appropriate.
58 *
59 * @author Kohsuke Kawaguchi
60 */
61 @SuppressWarnings("StaticNonFinalUsedInInitialization")
62 public abstract class XMLStreamReaderFactory {
63
64 private static final Logger LOGGER = Logger.getLogger(XMLStreamReaderFactory.class.getName());
65
66 private static final String CLASS_NAME_OF_WSTXINPUTFACTORY = "com.ctc.wstx.stax.WstxInputFactory";
67
68 /**
69 * Singleton instance.
70 */
71 private static volatile ContextClassloaderLocal<XMLStreamReaderFactory> streamReader =
72 new ContextClassloaderLocal<XMLStreamReaderFactory>() {
73
74 @Override
75 protected XMLStreamReaderFactory initialValue() {
76
77 XMLInputFactory xif = getXMLInputFactory();
78 XMLStreamReaderFactory f=null;
79
80 // this system property can be used to disable the pooling altogether,
81 // in case someone hits an issue with pooling in the production system.
82 if(!getProperty(XMLStreamReaderFactory.class.getName()+".noPool")) {
83 f = Zephyr.newInstance(xif);
84 }
85
86 if(f==null) {
87 // is this Woodstox?
88 if (xif.getClass().getName().equals(CLASS_NAME_OF_WSTXINPUTFACTORY)) {
89 f = new Woodstox(xif);
90 }
91 }
92
93 if (f==null) {
94 f = new Default();
95 }
96
97 if (LOGGER.isLoggable(Level.FINE)) {
98 LOGGER.log(Level.FINE, "XMLStreamReaderFactory instance is = {0}", f);
99 }
100 return f;
101 }
102 };
103
104 private static XMLInputFactory getXMLInputFactory() {
105 XMLInputFactory xif = null;
106 if (getProperty(XMLStreamReaderFactory.class.getName()+".woodstox")) {
107 try {
108 xif = (XMLInputFactory)Class.forName("com.ctc.wstx.stax.WstxInputFactory").newInstance();
109 } catch (Exception e) {
110 if (LOGGER.isLoggable(Level.WARNING)) {
111 LOGGER.log(Level.WARNING, StreamingMessages.WOODSTOX_CANT_LOAD(CLASS_NAME_OF_WSTXINPUTFACTORY), e);
112 }
113 }
114 }
115 if (xif == null) {
116 xif = XmlUtil.newXMLInputFactory(true);
117 }
118 xif.setProperty(XMLInputFactory.IS_NAMESPACE_AWARE, true);
119 xif.setProperty(XMLInputFactory.SUPPORT_DTD, false);
120 xif.setProperty(XMLInputFactory.IS_COALESCING, true);
121
122 return xif;
123 }
124
125 /**
126 * Overrides the singleton {@link XMLStreamReaderFactory} instance that
127 * the JAX-WS RI uses.
128 */
129 public static void set(XMLStreamReaderFactory f) {
130 if(f==null) {
131 throw new IllegalArgumentException();
132 }
133 streamReader.set(f);
134 }
135
136 public static XMLStreamReaderFactory get() {
137 return streamReader.get();
138 }
139
140 public static XMLStreamReader create(InputSource source, boolean rejectDTDs) {
141 try {
142 // Char stream available?
143 if (source.getCharacterStream() != null) {
144 return get().doCreate(source.getSystemId(), source.getCharacterStream(), rejectDTDs);
145 }
146
147 // Byte stream available?
148 if (source.getByteStream() != null) {
149 return get().doCreate(source.getSystemId(), source.getByteStream(), rejectDTDs);
150 }
151
152 // Otherwise, open URI
153 return get().doCreate(source.getSystemId(), new URL(source.getSystemId()).openStream(),rejectDTDs);
154 } catch (IOException e) {
155 throw new XMLReaderException("stax.cantCreate",e);
156 }
157 }
158
159 public static XMLStreamReader create(@Nullable String systemId, InputStream in, boolean rejectDTDs) {
160 return get().doCreate(systemId,in,rejectDTDs);
161 }
162
163 public static XMLStreamReader create(@Nullable String systemId, InputStream in, @Nullable String encoding, boolean rejectDTDs) {
164 return (encoding == null)
165 ? create(systemId, in, rejectDTDs)
166 : get().doCreate(systemId,in,encoding,rejectDTDs);
167 }
168
169 public static XMLStreamReader create(@Nullable String systemId, Reader reader, boolean rejectDTDs) {
170 return get().doCreate(systemId,reader,rejectDTDs);
171 }
172
173 /**
174 * Should be invoked when the code finished using an {@link XMLStreamReader}.
175 *
176 * <p>
177 * If the recycled instance implements {@link RecycleAware},
178 * {@link RecycleAware#onRecycled()} will be invoked to let the instance
179 * know that it's being recycled.
180 *
181 * <p>
182 * It is not a hard requirement to call this method on every {@link XMLStreamReader}
183 * instance. Not doing so just reduces the performance by throwing away
184 * possibly reusable instances. So the caller should always consider the effort
185 * it takes to recycle vs the possible performance gain by doing so.
186 *
187 * <p>
188 * This method may be invoked by multiple threads concurrently.
189 *
190 * @param r
191 * The {@link XMLStreamReader} instance that the caller finished using.
192 * This could be any {@link XMLStreamReader} implementation, not just
193 * the ones that were created from this factory. So the implementation
194 * of this class needs to be aware of that.
195 */
196 public static void recycle(XMLStreamReader r) {
197 /* the XMLStreamReaderFactory recycle becomes expenisve in the threadLocal get operation.
198 get().doRecycle(r);
199 if (r instanceof RecycleAware) {
200 ((RecycleAware)r).onRecycled();
201 }*/
202 }
203
204 // implementations
205
206 public abstract XMLStreamReader doCreate(String systemId, InputStream in, boolean rejectDTDs);
207
208 private XMLStreamReader doCreate(String systemId, InputStream in, @NotNull String encoding, boolean rejectDTDs) {
209 Reader reader;
210 try {
211 reader = new InputStreamReader(in, encoding);
212 } catch(UnsupportedEncodingException ue) {
213 throw new XMLReaderException("stax.cantCreate", ue);
214 }
215 return doCreate(systemId, reader, rejectDTDs);
216 }
217
218 public abstract XMLStreamReader doCreate(String systemId, Reader reader, boolean rejectDTDs);
219
220 public abstract void doRecycle(XMLStreamReader r);
221
222 /**
223 * Interface that can be implemented by {@link XMLStreamReader} to
224 * be notified when it's recycled.
225 *
226 * <p>
227 * This provides a filtering {@link XMLStreamReader} an opportunity to
228 * recycle its inner {@link XMLStreamReader}.
229 */
230 public interface RecycleAware {
231 void onRecycled();
232 }
233
234 /**
235 * {@link XMLStreamReaderFactory} implementation for SJSXP/JAXP RI.
236 */
237 private static final class Zephyr extends XMLStreamReaderFactory {
238 private final XMLInputFactory xif;
239
240 private final ThreadLocal<XMLStreamReader> pool = new ThreadLocal<XMLStreamReader>();
241
242 /**
243 * Sun StAX impl <code>XMLReaderImpl.setInputSource()</code> method via reflection.
244 */
245 private final Method setInputSourceMethod;
246
247 /**
248 * Sun StAX impl <code>XMLReaderImpl.reset()</code> method via reflection.
249 */
250 private final Method resetMethod;
251
252 /**
253 * The Sun StAX impl's {@link XMLStreamReader} implementation clas.
254 */
255 private final Class zephyrClass;
256
257 /**
258 * Creates {@link Zephyr} instance if the given {@link XMLInputFactory} is the one
259 * from Zephyr.
260 */
261 public static @Nullable
262 XMLStreamReaderFactory newInstance(XMLInputFactory xif) {
263 // check if this is from Zephyr
264 try {
265 Class<?> clazz = xif.createXMLStreamReader(new StringReader("<foo/>")).getClass();
266 // JDK has different XMLStreamReader impl class. Even if we check for that,
267 // it doesn't have setInputSource(InputSource). Let it use Default
268 if(!(clazz.getName().startsWith("com.sun.xml.internal.stream.")) )
269 return null; // nope
270 return new Zephyr(xif,clazz);
271 } catch (NoSuchMethodException e) {
272 return null; // this factory is not for zephyr
273 } catch (XMLStreamException e) {
274 return null; // impossible to fail to parse <foo/>, but anyway
275 }
276 }
277
278 public Zephyr(XMLInputFactory xif, Class clazz) throws NoSuchMethodException {
279 zephyrClass = clazz;
280 setInputSourceMethod = clazz.getMethod("setInputSource", InputSource.class);
281 resetMethod = clazz.getMethod("reset");
282
283 try {
284 // Turn OFF internal factory caching in Zephyr.
285 // Santiago told me that this makes it thread-safe.
286 xif.setProperty("reuse-instance", false);
287 } catch (IllegalArgumentException e) {
288 // falls through
289 }
290 this.xif = xif;
291 }
292
293 /**
294 * Fetchs an instance from the pool if available, otherwise null.
295 */
296 private @Nullable XMLStreamReader fetch() {
297 XMLStreamReader sr = pool.get();
298 if(sr==null) return null;
299 pool.set(null);
300 return sr;
301 }
302
303 @Override
304 public void doRecycle(XMLStreamReader r) {
305 if(zephyrClass.isInstance(r))
306 pool.set(r);
307 }
308
309 @Override
310 public XMLStreamReader doCreate(String systemId, InputStream in, boolean rejectDTDs) {
311 try {
312 XMLStreamReader xsr = fetch();
313 if(xsr==null)
314 return xif.createXMLStreamReader(systemId,in);
315
316 // try re-using this instance.
317 InputSource is = new InputSource(systemId);
318 is.setByteStream(in);
319 reuse(xsr,is);
320 return xsr;
321 } catch (IllegalAccessException e) {
322 throw new XMLReaderException("stax.cantCreate",e);
323 } catch (InvocationTargetException e) {
324 throw new XMLReaderException("stax.cantCreate",e);
325 } catch (XMLStreamException e) {
326 throw new XMLReaderException("stax.cantCreate",e);
327 }
328 }
329
330 @Override
331 public XMLStreamReader doCreate(String systemId, Reader in, boolean rejectDTDs) {
332 try {
333 XMLStreamReader xsr = fetch();
334 if(xsr==null)
335 return xif.createXMLStreamReader(systemId,in);
336
337 // try re-using this instance.
338 InputSource is = new InputSource(systemId);
339 is.setCharacterStream(in);
340 reuse(xsr,is);
341 return xsr;
342 } catch (IllegalAccessException e) {
343 throw new XMLReaderException("stax.cantCreate",e);
344 } catch (InvocationTargetException e) {
345 Throwable cause = e.getCause();
346 if (cause == null) {
347 cause = e;
348 }
349 throw new XMLReaderException("stax.cantCreate", cause);
350 } catch (XMLStreamException e) {
351 throw new XMLReaderException("stax.cantCreate",e);
352 }
353 }
354
355 private void reuse(XMLStreamReader xsr, InputSource in) throws IllegalAccessException, InvocationTargetException {
356 resetMethod.invoke(xsr);
357 setInputSourceMethod.invoke(xsr,in);
358 }
359 }
360
361 /**
362 * Default {@link XMLStreamReaderFactory} implementation
363 * that can work with any {@link XMLInputFactory}.
364 *
365 * <p>
366 * {@link XMLInputFactory} is not required to be thread-safe, but
367 * if the create method on this implementation is synchronized,
368 * it may run into (see <a href="https://jax-ws.dev.java.net/issues/show_bug.cgi?id=555">
369 * race condition</a>). Hence, using a XMLInputFactory per thread.
370 */
371 public static final class Default extends XMLStreamReaderFactory {
372
373 private final ThreadLocal<XMLInputFactory> xif = new ThreadLocal<XMLInputFactory>() {
374 @Override
375 public XMLInputFactory initialValue() {
376 return getXMLInputFactory();
377 }
378 };
379
380 @Override
381 public XMLStreamReader doCreate(String systemId, InputStream in, boolean rejectDTDs) {
382 try {
383 return xif.get().createXMLStreamReader(systemId,in);
384 } catch (XMLStreamException e) {
385 throw new XMLReaderException("stax.cantCreate",e);
386 }
387 }
388
389 @Override
390 public XMLStreamReader doCreate(String systemId, Reader in, boolean rejectDTDs) {
391 try {
392 return xif.get().createXMLStreamReader(systemId,in);
393 } catch (XMLStreamException e) {
394 throw new XMLReaderException("stax.cantCreate",e);
395 }
396 }
397
398 @Override
399 public void doRecycle(XMLStreamReader r) {
400 // there's no way to recycle with the default StAX API.
401 }
402
403 }
404
405 /**
406 * Similar to {@link Default} but doesn't do any synchronization.
407 *
408 * <p>
409 * This is useful when you know your {@link XMLInputFactory} is thread-safe by itself.
410 */
411 public static class NoLock extends XMLStreamReaderFactory {
412 private final XMLInputFactory xif;
413
414 public NoLock(XMLInputFactory xif) {
415 this.xif = xif;
416 }
417
418 @Override
419 public XMLStreamReader doCreate(String systemId, InputStream in, boolean rejectDTDs) {
420 try {
421 return xif.createXMLStreamReader(systemId,in);
422 } catch (XMLStreamException e) {
423 throw new XMLReaderException("stax.cantCreate",e);
424 }
425 }
426
427 @Override
428 public XMLStreamReader doCreate(String systemId, Reader in, boolean rejectDTDs) {
429 try {
430 return xif.createXMLStreamReader(systemId,in);
431 } catch (XMLStreamException e) {
432 throw new XMLReaderException("stax.cantCreate",e);
433 }
434 }
435
436 @Override
437 public void doRecycle(XMLStreamReader r) {
438 // there's no way to recycle with the default StAX API.
439 }
440 }
441
442 /**
443 * Handles Woodstox's XIF, but sets properties to do the string interning, sets various limits, ...
444 * Woodstox {@link XMLInputFactory} is thread safe.
445 */
446 public static final class Woodstox extends NoLock {
447
448 public final static String PROPERTY_MAX_ATTRIBUTES_PER_ELEMENT = "xml.ws.maximum.AttributesPerElement";
449 public final static String PROPERTY_MAX_ATTRIBUTE_SIZE = "xml.ws.maximum.AttributeSize";
450 public final static String PROPERTY_MAX_CHILDREN_PER_ELEMENT = "xml.ws.maximum.ChildrenPerElement";
451 public final static String PROPERTY_MAX_ELEMENT_COUNT = "xml.ws.maximum.ElementCount";
452 public final static String PROPERTY_MAX_ELEMENT_DEPTH = "xml.ws.maximum.ElementDepth";
453 public final static String PROPERTY_MAX_CHARACTERS = "xml.ws.maximum.Characters";
454
455 private static final int DEFAULT_MAX_ATTRIBUTES_PER_ELEMENT = 500;
456 private static final int DEFAULT_MAX_ATTRIBUTE_SIZE = 65536 * 8;
457 private static final int DEFAULT_MAX_CHILDREN_PER_ELEMENT = Integer.MAX_VALUE;
458 private static final int DEFAULT_MAX_ELEMENT_DEPTH = 500;
459 private static final long DEFAULT_MAX_ELEMENT_COUNT = Integer.MAX_VALUE;
460 private static final long DEFAULT_MAX_CHARACTERS = Long.MAX_VALUE;
461
462 /* Woodstox default setting:
463 int mMaxAttributesPerElement = 1000;
464 int mMaxAttributeSize = 65536 * 8;
465 int mMaxChildrenPerElement = Integer.MAX_VALUE;
466 int mMaxElementDepth = 1000;
467 long mMaxElementCount = Long.MAX_VALUE;
468 long mMaxCharacters = Long.MAX_VALUE;
469 */
470
471 private int maxAttributesPerElement = DEFAULT_MAX_ATTRIBUTES_PER_ELEMENT;
472 private int maxAttributeSize = DEFAULT_MAX_ATTRIBUTE_SIZE;
473 private int maxChildrenPerElement = DEFAULT_MAX_CHILDREN_PER_ELEMENT;
474 private int maxElementDepth = DEFAULT_MAX_ELEMENT_DEPTH;
475 private long maxElementCount = DEFAULT_MAX_ELEMENT_COUNT;
476 private long maxCharacters = DEFAULT_MAX_CHARACTERS;
477
478 // Note: this is a copy from com.ctc.wstx.api.WstxInputProperties, to be removed in the future
479 private static final java.lang.String P_MAX_ATTRIBUTES_PER_ELEMENT = "com.ctc.wstx.maxAttributesPerElement";
480 private static final java.lang.String P_MAX_ATTRIBUTE_SIZE = "com.ctc.wstx.maxAttributeSize";
481 private static final java.lang.String P_MAX_CHILDREN_PER_ELEMENT = "com.ctc.wstx.maxChildrenPerElement";
482 private static final java.lang.String P_MAX_ELEMENT_COUNT = "com.ctc.wstx.maxElementCount";
483 private static final java.lang.String P_MAX_ELEMENT_DEPTH = "com.ctc.wstx.maxElementDepth";
484 private static final java.lang.String P_MAX_CHARACTERS = "com.ctc.wstx.maxCharacters";
485 private static final java.lang.String P_INTERN_NSURIS = "org.codehaus.stax2.internNsUris";
486 private static final java.lang.String P_RETURN_NULL_FOR_DEFAULT_NAMESPACE = "com.ctc.wstx.returnNullForDefaultNamespace";
487
488 public Woodstox(XMLInputFactory xif) {
489 super(xif);
490
491 if (xif.isPropertySupported(P_INTERN_NSURIS)) {
492 xif.setProperty(P_INTERN_NSURIS, true);
493 if (LOGGER.isLoggable(Level.FINE)) {
494 LOGGER.log(Level.FINE, P_INTERN_NSURIS + " is {0}", true);
495 }
496 }
497
498 if (xif.isPropertySupported(P_MAX_ATTRIBUTES_PER_ELEMENT)) {
499 maxAttributesPerElement = Integer.valueOf(buildIntegerValue(
500 PROPERTY_MAX_ATTRIBUTES_PER_ELEMENT, DEFAULT_MAX_ATTRIBUTES_PER_ELEMENT)
501 );
502 xif.setProperty(P_MAX_ATTRIBUTES_PER_ELEMENT, maxAttributesPerElement);
503 if (LOGGER.isLoggable(Level.FINE)) {
504 LOGGER.log(Level.FINE, P_MAX_ATTRIBUTES_PER_ELEMENT + " is {0}", maxAttributesPerElement);
505 }
506 }
507
508 if (xif.isPropertySupported(P_MAX_ATTRIBUTE_SIZE)) {
509 maxAttributeSize = Integer.valueOf(buildIntegerValue(
510 PROPERTY_MAX_ATTRIBUTE_SIZE, DEFAULT_MAX_ATTRIBUTE_SIZE)
511 );
512 xif.setProperty(P_MAX_ATTRIBUTE_SIZE, maxAttributeSize);
513 if (LOGGER.isLoggable(Level.FINE)) {
514 LOGGER.log(Level.FINE, P_MAX_ATTRIBUTE_SIZE + " is {0}", maxAttributeSize);
515 }
516 }
517
518 if (xif.isPropertySupported(P_MAX_CHILDREN_PER_ELEMENT)) {
519 maxChildrenPerElement = Integer.valueOf(buildIntegerValue(
520 PROPERTY_MAX_CHILDREN_PER_ELEMENT, DEFAULT_MAX_CHILDREN_PER_ELEMENT)
521 );
522 xif.setProperty(P_MAX_CHILDREN_PER_ELEMENT, maxChildrenPerElement);
523 if (LOGGER.isLoggable(Level.FINE)) {
524 LOGGER.log(Level.FINE, P_MAX_CHILDREN_PER_ELEMENT + " is {0}", maxChildrenPerElement);
525 }
526 }
527
528 if (xif.isPropertySupported(P_MAX_ELEMENT_DEPTH)) {
529 maxElementDepth = Integer.valueOf(buildIntegerValue(
530 PROPERTY_MAX_ELEMENT_DEPTH, DEFAULT_MAX_ELEMENT_DEPTH)
531 );
532 xif.setProperty(P_MAX_ELEMENT_DEPTH, maxElementDepth);
533 if (LOGGER.isLoggable(Level.FINE)) {
534 LOGGER.log(Level.FINE, P_MAX_ELEMENT_DEPTH + " is {0}", maxElementDepth);
535 }
536 }
537
538 if (xif.isPropertySupported(P_MAX_ELEMENT_COUNT)) {
539 maxElementCount = Long.valueOf(buildLongValue(
540 PROPERTY_MAX_ELEMENT_COUNT, DEFAULT_MAX_ELEMENT_COUNT)
541 );
542 xif.setProperty(P_MAX_ELEMENT_COUNT, maxElementCount);
543 if (LOGGER.isLoggable(Level.FINE)) {
544 LOGGER.log(Level.FINE, P_MAX_ELEMENT_COUNT + " is {0}", maxElementCount);
545 }
546 }
547
548 if (xif.isPropertySupported(P_MAX_CHARACTERS)) {
549 maxCharacters = Long.valueOf(buildLongValue(
550 PROPERTY_MAX_CHARACTERS, DEFAULT_MAX_CHARACTERS)
551 );
552 xif.setProperty(P_MAX_CHARACTERS, maxCharacters);
553 if (LOGGER.isLoggable(Level.FINE)) {
554 LOGGER.log(Level.FINE, P_MAX_CHARACTERS + " is {0}", maxCharacters);
555 }
556 }
557 //Using try/catch instead of isPropertySupported because Woodstox
558 //isPropertySupported is not always reliable
559 try {
560 //this is needed to make sure Woodstox behavior is spec compliant for
561 //calls to XMLStreamReader.getNamespacePrefix
562 xif.setProperty(P_RETURN_NULL_FOR_DEFAULT_NAMESPACE, Boolean.TRUE);
563 if (LOGGER.isLoggable(Level.FINE)) {
564 LOGGER.log(Level.FINE, P_RETURN_NULL_FOR_DEFAULT_NAMESPACE + " is {0}", xif.getProperty(P_RETURN_NULL_FOR_DEFAULT_NAMESPACE));
565 }
566 } catch (Throwable t) {
567 //ignore - this should not happen Woodstox 4.1.2 or later (maybe older version of Woodstox).
568 LOGGER.log(Level.WARNING, "Expected property not found in Woodstox input factory: '{0}'", P_RETURN_NULL_FOR_DEFAULT_NAMESPACE);
569 }
570 }
571
572 @Override
573 public XMLStreamReader doCreate(String systemId, InputStream in, boolean rejectDTDs) {
574 return super.doCreate(systemId, in, rejectDTDs);
575 }
576
577 @Override
578 public XMLStreamReader doCreate(String systemId, Reader in, boolean rejectDTDs) {
579 return super.doCreate(systemId, in, rejectDTDs);
580 }
581 }
582
583 private static int buildIntegerValue(String propertyName, int defaultValue) {
584 String propVal = System.getProperty(propertyName);
585 if (propVal != null && propVal.length() > 0) {
586 try {
587 Integer value = Integer.parseInt(propVal);
588 if (value > 0) {
589 // return with the value in System property
590 return value;
591 }
592 } catch (NumberFormatException nfe) {
593 if (LOGGER.isLoggable(Level.WARNING)) {
594 LOGGER.log(Level.WARNING, StreamingMessages.INVALID_PROPERTY_VALUE_INTEGER(propertyName, propVal, Integer.toString(defaultValue)), nfe);
595 }
596 }
597 }
598 // return with the default value
599 return defaultValue;
600 }
601
602 private static long buildLongValue(String propertyName, long defaultValue) {
603 String propVal = System.getProperty(propertyName);
604 if (propVal != null && propVal.length() > 0) {
605 try {
606 long value = Long.parseLong(propVal);
607 if (value > 0L) {
608 // return with the value in System property
609 return value;
610 }
611 } catch (NumberFormatException nfe) {
612 // defult will be returned
613 if (LOGGER.isLoggable(Level.WARNING)) {
614 LOGGER.log(Level.WARNING, StreamingMessages.INVALID_PROPERTY_VALUE_LONG(propertyName, propVal, Long.toString(defaultValue)), nfe);
615 }
616 }
617 }
618 // return with the default value
619 return defaultValue;
620 }
621
622 private static Boolean getProperty(final String prop) {
623 return AccessController.doPrivileged(
624 new java.security.PrivilegedAction<Boolean>() {
625 @Override
626 public Boolean run() {
627 String value = System.getProperty(prop);
628 return value != null ? Boolean.valueOf(value) : Boolean.FALSE;
629 }
630 }
631 );
632 }
633
634 }