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 }