[jbossws-commits] JBossWS SVN: r19496 - in common/trunk: src/main/java/org/jboss/ws/common/utils and 1 other directory.

Author: asoldano Date: 2015-02-23 16:12:51 -0500 (Mon, 23 Feb 2015) New Revision: 19496 Added: common/trunk/src/main/java/org/jboss/ws/common/utils/Base64.java common/trunk/src/main/java/org/jboss/ws/common/utils/JBossEntityResolver.java common/trunk/src/main/java/org/jboss/ws/common/utils/NotImplementedException.java common/trunk/src/main/java/org/jboss/ws/common/utils/StringPropertyReplacer.java Modified: common/trunk/pom.xml common/trunk/src/main/java/org/jboss/ws/common/utils/JBossWSEntityResolver.java Log: [JBWS-3871] Remove dependency on org.jboss:jboss-common-core (my copying the few required classes...) Modified: common/trunk/pom.xml =================================================================== --- common/trunk/pom.xml 2015-02-23 21:11:41 UTC (rev 19495) +++ common/trunk/pom.xml 2015-02-23 21:12:51 UTC (rev 19496) @@ -77,18 +77,6 @@ <scope>provided</scope> </dependency> <dependency> - <groupId>org.jboss</groupId> - <artifactId>jboss-common-core</artifactId> - <version>${jboss.common.core.version}</version> - <scope>provided</scope> - <exclusions> - <exclusion> - <groupId>org.jboss.logging</groupId> - <artifactId>jboss-logging-spi</artifactId> - </exclusion> - </exclusions> - </dependency> - <dependency> <groupId>org.jboss.logging</groupId> <artifactId>jboss-logging</artifactId> <version>${jboss-logging.version}</version> Added: common/trunk/src/main/java/org/jboss/ws/common/utils/Base64.java =================================================================== --- common/trunk/src/main/java/org/jboss/ws/common/utils/Base64.java (rev 0) +++ common/trunk/src/main/java/org/jboss/ws/common/utils/Base64.java 2015-02-23 21:12:51 UTC (rev 19496) @@ -0,0 +1,1482 @@ +/* + * JBoss, Home of Professional Open Source. + * Copyright 2015, Red Hat Middleware LLC, and individual contributors + * as indicated by the @author tags. See the copyright.txt file in the + * distribution for a full listing of individual contributors. + * + * This is free software; you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2.1 of + * the License, or (at your option) any later version. + * + * This software is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this software; if not, write to the Free + * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + * 02110-1301 USA, or see the FSF site: http://www.fsf.org. + */ +package org.jboss.ws.common.utils; + +import java.io.IOException; + +import org.jboss.logging.Logger; + +/** + * Encodes and decodes to and from Base64 notation. + * + * <p> + * Change Log: + * </p> + * <ul> + * <li>v2.1 - Cleaned up javadoc comments and unused variables and methods. Added + * some convenience methods for reading and writing to and from files.</li> + * <li>v2.0.2 - Now specifies UTF-8 encoding in places where the code fails on systems + * with other encodings (like EBCDIC).</li> + * <li>v2.0.1 - Fixed an error when decoding a single byte, that is, when the + * encoded data was a single byte.</li> + * <li>v2.0 - I got rid of methods that used booleans to set options. + * Now everything is more consolidated and cleaner. The code now detects + * when data that's being decoded is gzip-compressed and will decompress it + * automatically. Generally things are cleaner. You'll probably have to + * change some method calls that you were making to support the new + * options format (<tt>int</tt>s that you "OR" together).</li> + * <li>v1.5.1 - Fixed bug when decompressing and decoding to a + * byte[] using <tt>decode( String s, boolean gzipCompressed )</tt>. + * Added the ability to "suspend" encoding in the Output Stream so + * you can turn on and off the encoding if you need to embed base64 + * data in an otherwise "normal" stream (like an XML file).</li> + * <li>v1.5 - Output stream pases on flush() command but doesn't do anything itself. + * This helps when using GZIP streams. + * Added the ability to GZip-compress objects before encoding them.</li> + * <li>v1.4 - Added helper methods to read/write files.</li> + * <li>v1.3.6 - Fixed OutputStream.flush() so that 'position' is reset.</li> + * <li>v1.3.5 - Added flag to turn on and off line breaks. Fixed bug in input stream + * where last buffer being read, if not completely full, was not returned.</li> + * <li>v1.3.4 - Fixed when "improperly padded stream" error was thrown at the wrong time.</li> + * <li>v1.3.3 - Fixed I/O streams which were totally messed up.</li> + * </ul> + * + * <p> + * I am placing this code in the Public Domain. Do with it as you will. + * This software comes with no guarantees or warranties but with + * plenty of well-wishing instead! + * Please visit <a href="http://iharder.net/base64">http://iharder.net/base64&l... + * periodically to check for updates or to contribute improvements. + * </p> + * + * @author Robert Harder + * @author rob(a)iharder.net + * @version 2.1 + */ +public class Base64 +{ + // provide logging + private static final Logger log = Logger.getLogger(Base64.class); + + /* ******** P U B L I C F I E L D S ******** */ + + /** No options specified. Value is zero. */ + public final static int NO_OPTIONS = 0; + + /** Specify encoding. */ + public final static int ENCODE = 1; + + /** Specify decoding. */ + public final static int DECODE = 0; + + /** Specify that data should be gzip-compressed. */ + public final static int GZIP = 2; + + /** Don't break lines when encoding (violates strict Base64 specification) */ + public final static int DONT_BREAK_LINES = 8; + + /* ******** P R I V A T E F I E L D S ******** */ + + /** Maximum line length (76) of Base64 output. */ + private final static int MAX_LINE_LENGTH = 76; + + /** The equals sign (=) as a byte. */ + private final static byte EQUALS_SIGN = (byte)'='; + + /** The new line character (\n) as a byte. */ + private final static byte NEW_LINE = (byte)'\n'; + + /** Preferred encoding. */ + private final static String PREFERRED_ENCODING = "UTF-8"; + + /** The 64 valid Base64 values. */ + private final static byte[] ALPHABET; + private final static byte[] _NATIVE_ALPHABET = /* May be something funny like EBCDIC */ + { (byte)'A', (byte)'B', (byte)'C', (byte)'D', (byte)'E', (byte)'F', (byte)'G', (byte)'H', (byte)'I', (byte)'J', (byte)'K', (byte)'L', (byte)'M', (byte)'N', + (byte)'O', (byte)'P', (byte)'Q', (byte)'R', (byte)'S', (byte)'T', (byte)'U', (byte)'V', (byte)'W', (byte)'X', (byte)'Y', (byte)'Z', (byte)'a', (byte)'b', + (byte)'c', (byte)'d', (byte)'e', (byte)'f', (byte)'g', (byte)'h', (byte)'i', (byte)'j', (byte)'k', (byte)'l', (byte)'m', (byte)'n', (byte)'o', (byte)'p', + (byte)'q', (byte)'r', (byte)'s', (byte)'t', (byte)'u', (byte)'v', (byte)'w', (byte)'x', (byte)'y', (byte)'z', (byte)'0', (byte)'1', (byte)'2', (byte)'3', + (byte)'4', (byte)'5', (byte)'6', (byte)'7', (byte)'8', (byte)'9', (byte)'+', (byte)'/' }; + + /** Determine which ALPHABET to use. */ + static + { + byte[] __bytes; + try + { + __bytes = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".getBytes(PREFERRED_ENCODING); + } // end try + catch (java.io.UnsupportedEncodingException use) + { + __bytes = _NATIVE_ALPHABET; // Fall back to native encoding + } // end catch + ALPHABET = __bytes; + } // end static + + /** + * Translates a Base64 value to either its 6-bit reconstruction value + * or a negative number indicating some other meaning. + **/ + private final static byte[] DECODABET = { -9, -9, -9, -9, -9, -9, -9, -9, -9, // Decimal 0 - 8 + -5, -5, // Whitespace: Tab and Linefeed + -9, -9, // Decimal 11 - 12 + -5, // Whitespace: Carriage Return + -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, // Decimal 14 - 26 + -9, -9, -9, -9, -9, // Decimal 27 - 31 + -5, // Whitespace: Space + -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, // Decimal 33 - 42 + 62, // Plus sign at decimal 43 + -9, -9, -9, // Decimal 44 - 46 + 63, // Slash at decimal 47 + 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, // Numbers zero through nine + -9, -9, -9, // Decimal 58 - 60 + -1, // Equals sign at decimal 61 + -9, -9, -9, // Decimal 62 - 64 + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, // Letters 'A' through 'N' + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, // Letters 'O' through 'Z' + -9, -9, -9, -9, -9, -9, // Decimal 91 - 96 + 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, // Letters 'a' through 'm' + 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, // Letters 'n' through 'z' + -9, -9, -9, -9 // Decimal 123 - 126 + /*,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 127 - 139 + -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 140 - 152 + -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 153 - 165 + -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 166 - 178 + -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 179 - 191 + -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 192 - 204 + -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 205 - 217 + -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 218 - 230 + -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 231 - 243 + -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9 // Decimal 244 - 255 */ + }; + + // I think I end up not using the BAD_ENCODING indicator. + //private final static byte BAD_ENCODING = -9; // Indicates error in encoding + private final static byte WHITE_SPACE_ENC = -5; // Indicates white space in encoding + private final static byte EQUALS_SIGN_ENC = -1; // Indicates equals sign in encoding + + /** Defeats instantiation. */ + private Base64() + { + } + + /* ******** E N C O D I N G M E T H O D S ******** */ + + /** + * Encodes up to the first three bytes of array <var>threeBytes</var> + * and returns a four-byte array in Base64 notation. + * The actual number of significant bytes in your array is + * given by <var>numSigBytes</var>. + * The array <var>threeBytes</var> needs only be as big as + * <var>numSigBytes</var>. + * Code can reuse a byte array by passing a four-byte array as <var>b4</var>. + * + * @param b4 A reusable byte array to reduce array instantiation + * @param threeBytes the array to convert + * @param numSigBytes the number of significant bytes in your array + * @return four byte array in Base64 notation. + * @since 1.5.1 + */ + private static byte[] encode3to4(byte[] b4, byte[] threeBytes, int numSigBytes) + { + encode3to4(threeBytes, 0, numSigBytes, b4, 0); + return b4; + } // end encode3to4 + + /** + * Encodes up to three bytes of the array <var>source</var> + * and writes the resulting four Base64 bytes to <var>destination</var>. + * The source and destination arrays can be manipulated + * anywhere along their length by specifying + * <var>srcOffset</var> and <var>destOffset</var>. + * This method does not check to make sure your arrays + * are large enough to accomodate <var>srcOffset</var> + 3 for + * the <var>source</var> array or <var>destOffset</var> + 4 for + * the <var>destination</var> array. + * The actual number of significant bytes in your array is + * given by <var>numSigBytes</var>. + * + * @param source the array to convert + * @param srcOffset the index where conversion begins + * @param numSigBytes the number of significant bytes in your array + * @param destination the array to hold the conversion + * @param destOffset the index where output will be put + * @return the <var>destination</var> array + * @since 1.3 + */ + private static byte[] encode3to4(byte[] source, int srcOffset, int numSigBytes, byte[] destination, int destOffset) + { + // 1 2 3 + // 01234567890123456789012345678901 Bit position + // --------000000001111111122222222 Array position from threeBytes + // --------| || || || | Six bit groups to index ALPHABET + // >>18 >>12 >> 6 >> 0 Right shift necessary + // 0x3f 0x3f 0x3f Additional AND + + // Create buffer with zero-padding if there are only one or two + // significant bytes passed in the array. + // We have to shift left 24 in order to flush out the 1's that appear + // when Java treats a value as negative that is cast from a byte to an int. + int inBuff = (numSigBytes > 0 ? ((source[srcOffset] << 24) >>> 8) : 0) | (numSigBytes > 1 ? ((source[srcOffset + 1] << 24) >>> 16) : 0) + | (numSigBytes > 2 ? ((source[srcOffset + 2] << 24) >>> 24) : 0); + + switch (numSigBytes) + { + case 3: + destination[destOffset] = ALPHABET[(inBuff >>> 18)]; + destination[destOffset + 1] = ALPHABET[(inBuff >>> 12) & 0x3f]; + destination[destOffset + 2] = ALPHABET[(inBuff >>> 6) & 0x3f]; + destination[destOffset + 3] = ALPHABET[(inBuff) & 0x3f]; + return destination; + + case 2: + destination[destOffset] = ALPHABET[(inBuff >>> 18)]; + destination[destOffset + 1] = ALPHABET[(inBuff >>> 12) & 0x3f]; + destination[destOffset + 2] = ALPHABET[(inBuff >>> 6) & 0x3f]; + destination[destOffset + 3] = EQUALS_SIGN; + return destination; + + case 1: + destination[destOffset] = ALPHABET[(inBuff >>> 18)]; + destination[destOffset + 1] = ALPHABET[(inBuff >>> 12) & 0x3f]; + destination[destOffset + 2] = EQUALS_SIGN; + destination[destOffset + 3] = EQUALS_SIGN; + return destination; + + default: + return destination; + } // end switch + } // end encode3to4 + + /** + * Serializes an object and returns the Base64-encoded + * version of that serialized object. If the object + * cannot be serialized or there is another error, + * the method will return <tt>null</tt>. + * The object is not GZip-compressed before being encoded. + * + * @param serializableObject The object to encode + * @return The Base64-encoded object + * @since 1.4 + */ + public static String encodeObject(java.io.Serializable serializableObject) + { + return encodeObject(serializableObject, NO_OPTIONS); + } // end encodeObject + + /** + * Serializes an object and returns the Base64-encoded + * version of that serialized object. If the object + * cannot be serialized or there is another error, + * the method will return <tt>null</tt>. + * <p> + * Valid options:<pre> + * GZIP: gzip-compresses object before encoding it. + * DONT_BREAK_LINES: don't break lines at 76 characters + * <i>Note: Technically, this makes your encoding non-compliant.</i> + * </pre> + * <p> + * Example: <code>encodeObject( myObj, Base64.GZIP )</code> or + * <p> + * Example: <code>encodeObject( myObj, Base64.GZIP | Base64.DONT_BREAK_LINES )</code> + * + * @param serializableObject The object to encode + * @param options Specified options + * @return The Base64-encoded object + * @see Base64#GZIP + * @see Base64#DONT_BREAK_LINES + * @since 2.0 + */ + public static String encodeObject(java.io.Serializable serializableObject, int options) + { + // Streams + java.io.ByteArrayOutputStream baos = null; + java.io.OutputStream b64os = null; + java.io.ObjectOutputStream oos = null; + java.util.zip.GZIPOutputStream gzos = null; + + // Isolate options + int gzip = (options & GZIP); + int dontBreakLines = (options & DONT_BREAK_LINES); + + try + { + // ObjectOutputStream -> (GZIP) -> Base64 -> ByteArrayOutputStream + baos = new java.io.ByteArrayOutputStream(); + b64os = new Base64.OutputStream(baos, ENCODE | dontBreakLines); + + // GZip? + if (gzip == GZIP) + { + gzos = new java.util.zip.GZIPOutputStream(b64os); + oos = new java.io.ObjectOutputStream(gzos); + } // end if: gzip + else oos = new java.io.ObjectOutputStream(b64os); + + oos.writeObject(serializableObject); + } // end try + catch (java.io.IOException e) + { + e.printStackTrace(); + return null; + } // end catch + finally + { + try + { + oos.close(); + } + catch (Exception e) + { + } + try + { + gzos.close(); + } + catch (Exception e) + { + } + try + { + b64os.close(); + } + catch (Exception e) + { + } + try + { + baos.close(); + } + catch (Exception e) + { + } + } // end finally + + // Return value according to relevant encoding. + try + { + return new String(baos.toByteArray(), PREFERRED_ENCODING); + } // end try + catch (java.io.UnsupportedEncodingException uue) + { + return new String(baos.toByteArray()); + } // end catch + + } // end encode + + /** + * Encodes a byte array into Base64 notation. + * Does not GZip-compress data. + * + * @param source The data to convert + * @return the encode bytes + * @since 1.4 + */ + public static String encodeBytes(byte[] source) + { + return encodeBytes(source, 0, source.length, NO_OPTIONS); + } // end encodeBytes + + /** + * Encodes a byte array into Base64 notation. + * <p> + * Valid options:<pre> + * GZIP: gzip-compresses object before encoding it. + * DONT_BREAK_LINES: don't break lines at 76 characters + * <i>Note: Technically, this makes your encoding non-compliant.</i> + * </pre> + * <p> + * Example: <code>encodeBytes( myData, Base64.GZIP )</code> or + * <p> + * Example: <code>encodeBytes( myData, Base64.GZIP | Base64.DONT_BREAK_LINES )</code> + * + * + * @param source The data to convert + * @param options Specified options + * @return the encoded bytes + * @see Base64#GZIP + * @see Base64#DONT_BREAK_LINES + * @since 2.0 + */ + public static String encodeBytes(byte[] source, int options) + { + return encodeBytes(source, 0, source.length, options); + } // end encodeBytes + + /** + * Encodes a byte array into Base64 notation. + * Does not GZip-compress data. + * + * @param source The data to convert + * @param off Offset in array where conversion should begin + * @param len Length of data to convert + * @return the text node + * @since 1.4 + */ + public static String encodeBytes(byte[] source, int off, int len) + { + return encodeBytes(source, off, len, NO_OPTIONS); + } // end encodeBytes + + /** + * Encodes a byte array into Base64 notation. + * <p> + * Valid options:<pre> + * GZIP: gzip-compresses object before encoding it. + * DONT_BREAK_LINES: don't break lines at 76 characters + * <i>Note: Technically, this makes your encoding non-compliant.</i> + * </pre> + * <p> + * Example: <code>encodeBytes( myData, Base64.GZIP )</code> or + * <p> + * Example: <code>encodeBytes( myData, Base64.GZIP | Base64.DONT_BREAK_LINES )</code> + * + * + * @param source The data to convert + * @param off Offset in array where conversion should begin + * @param len Length of data to convert + * @param options Specified options + * @see Base64#GZIP + * @see Base64#DONT_BREAK_LINES + * @return the text node + * @since 2.0 + */ + public static String encodeBytes(byte[] source, int off, int len, int options) + { + // Isolate options + int dontBreakLines = (options & DONT_BREAK_LINES); + int gzip = (options & GZIP); + + // Compress? + if (gzip == GZIP) + { + java.io.ByteArrayOutputStream baos = null; + java.util.zip.GZIPOutputStream gzos = null; + Base64.OutputStream b64os = null; + + try + { + // GZip -> Base64 -> ByteArray + baos = new java.io.ByteArrayOutputStream(); + b64os = new Base64.OutputStream(baos, ENCODE | dontBreakLines); + gzos = new java.util.zip.GZIPOutputStream(b64os); + + gzos.write(source, off, len); + gzos.close(); + } // end try + catch (java.io.IOException e) + { + e.printStackTrace(); + return null; + } // end catch + finally + { + try + { + gzos.close(); + } + catch (Exception e) + { + } + try + { + b64os.close(); + } + catch (Exception e) + { + } + try + { + baos.close(); + } + catch (Exception e) + { + } + } // end finally + + // Return value according to relevant encoding. + try + { + return new String(baos.toByteArray(), PREFERRED_ENCODING); + } // end try + catch (java.io.UnsupportedEncodingException uue) + { + return new String(baos.toByteArray()); + } // end catch + } // end if: compress + + // Else, don't compress. Better not to use streams at all then. + else + { + // Convert option to boolean in way that code likes it. + boolean breakLines = dontBreakLines == 0; + + int len43 = len * 4 / 3; + byte[] outBuff = new byte[(len43) // Main 4:3 + + ((len % 3) > 0 ? 4 : 0) // Account for padding + + (breakLines ? (len43 / MAX_LINE_LENGTH) : 0)]; // New lines + int d = 0; + int e = 0; + int len2 = len - 2; + int lineLength = 0; + for (; d < len2; d += 3, e += 4) + { + encode3to4(source, d + off, 3, outBuff, e); + + lineLength += 4; + if (breakLines && lineLength == MAX_LINE_LENGTH) + { + outBuff[e + 4] = NEW_LINE; + e++; + lineLength = 0; + } // end if: end of line + } // en dfor: each piece of array + + if (d < len) + { + encode3to4(source, d + off, len - d, outBuff, e); + e += 4; + } // end if: some padding needed + + // Return value according to relevant encoding. + try + { + return new String(outBuff, 0, e, PREFERRED_ENCODING); + } // end try + catch (java.io.UnsupportedEncodingException uue) + { + return new String(outBuff, 0, e); + } // end catch + + } // end else: don't compress + + } // end encodeBytes + + /* ******** D E C O D I N G M E T H O D S ******** */ + + /** + * Decodes four bytes from array <var>source</var> + * and writes the resulting bytes (up to three of them) + * to <var>destination</var>. + * The source and destination arrays can be manipulated + * anywhere along their length by specifying + * <var>srcOffset</var> and <var>destOffset</var>. + * This method does not check to make sure your arrays + * are large enough to accomodate <var>srcOffset</var> + 4 for + * the <var>source</var> array or <var>destOffset</var> + 3 for + * the <var>destination</var> array. + * This method returns the actual number of bytes that + * were converted from the Base64 encoding. + * + * + * @param source the array to convert + * @param srcOffset the index where conversion begins + * @param destination the array to hold the conversion + * @param destOffset the index where output will be put + * @return the number of decoded bytes converted + * @since 1.3 + */ + private static int decode4to3(byte[] source, int srcOffset, byte[] destination, int destOffset) + { + // Example: Dk== + if (source[srcOffset + 2] == EQUALS_SIGN) + { + // Two ways to do the same thing. Don't know which way I like best. + //int outBuff = ( ( DECODABET[ source[ srcOffset ] ] << 24 ) >>> 6 ) + // | ( ( DECODABET[ source[ srcOffset + 1] ] << 24 ) >>> 12 ); + int outBuff = ((DECODABET[source[srcOffset]] & 0xFF) << 18) | ((DECODABET[source[srcOffset + 1]] & 0xFF) << 12); + + destination[destOffset] = (byte)(outBuff >>> 16); + return 1; + } + + // Example: DkL= + else if (source[srcOffset + 3] == EQUALS_SIGN) + { + // Two ways to do the same thing. Don't know which way I like best. + //int outBuff = ( ( DECODABET[ source[ srcOffset ] ] << 24 ) >>> 6 ) + // | ( ( DECODABET[ source[ srcOffset + 1 ] ] << 24 ) >>> 12 ) + // | ( ( DECODABET[ source[ srcOffset + 2 ] ] << 24 ) >>> 18 ); + int outBuff = ((DECODABET[source[srcOffset]] & 0xFF) << 18) | ((DECODABET[source[srcOffset + 1]] & 0xFF) << 12) + | ((DECODABET[source[srcOffset + 2]] & 0xFF) << 6); + + destination[destOffset] = (byte)(outBuff >>> 16); + destination[destOffset + 1] = (byte)(outBuff >>> 8); + return 2; + } + + // Example: DkLE + else + { + try + { + // Two ways to do the same thing. Don't know which way I like best. + //int outBuff = ( ( DECODABET[ source[ srcOffset ] ] << 24 ) >>> 6 ) + // | ( ( DECODABET[ source[ srcOffset + 1 ] ] << 24 ) >>> 12 ) + // | ( ( DECODABET[ source[ srcOffset + 2 ] ] << 24 ) >>> 18 ) + // | ( ( DECODABET[ source[ srcOffset + 3 ] ] << 24 ) >>> 24 ); + int outBuff = ((DECODABET[source[srcOffset]] & 0xFF) << 18) | ((DECODABET[source[srcOffset + 1]] & 0xFF) << 12) + | ((DECODABET[source[srcOffset + 2]] & 0xFF) << 6) | ((DECODABET[source[srcOffset + 3]] & 0xFF)); + + destination[destOffset] = (byte)(outBuff >> 16); + destination[destOffset + 1] = (byte)(outBuff >> 8); + destination[destOffset + 2] = (byte)(outBuff); + + return 3; + } + catch (Exception e) + { + log.error("" + source[srcOffset] + ": " + (DECODABET[source[srcOffset]])); + log.error("" + source[srcOffset + 1] + ": " + (DECODABET[source[srcOffset + 1]])); + log.error("" + source[srcOffset + 2] + ": " + (DECODABET[source[srcOffset + 2]])); + log.error("" + source[srcOffset + 3] + ": " + (DECODABET[source[srcOffset + 3]])); + return -1; + } //end catch + } + } // end decodeToBytes + + /** + * Very low-level access to decoding ASCII characters in + * the form of a byte array. Does not support automatically + * gunzipping or any other "fancy" features. + * + * @param source The Base64 encoded data + * @param off The offset of where to begin decoding + * @param len The length of characters to decode + * @return decoded data + * @since 1.3 + */ + public static byte[] decode(byte[] source, int off, int len) + { + int len34 = len * 3 / 4; + byte[] outBuff = new byte[len34]; // Upper limit on size of output + int outBuffPosn = 0; + + byte[] b4 = new byte[4]; + int b4Posn = 0; + int i = 0; + byte sbiCrop = 0; + byte sbiDecode = 0; + for (i = off; i < off + len; i++) + { + sbiCrop = (byte)(source[i] & 0x7f); // Only the low seven bits + sbiDecode = DECODABET[sbiCrop]; + + if (sbiDecode >= WHITE_SPACE_ENC) // White space, Equals sign or better + { + if (sbiDecode >= EQUALS_SIGN_ENC) + { + b4[b4Posn++] = sbiCrop; + if (b4Posn > 3) + { + outBuffPosn += decode4to3(b4, 0, outBuff, outBuffPosn); + b4Posn = 0; + + // If that was the equals sign, break out of 'for' loop + if (sbiCrop == EQUALS_SIGN) + break; + } // end if: quartet built + + } // end if: equals sign or better + + } // end if: white space, equals sign or better + else + { + throw new IllegalStateException("Bad Base64 input character at " + i + ": " + source[i] + "(decimal)"); + } // end else: + } // each input character + + byte[] out = new byte[outBuffPosn]; + System.arraycopy(outBuff, 0, out, 0, outBuffPosn); + return out; + } // end decode + + /** + * Decodes data from Base64 notation, automatically + * detecting gzip-compressed data and decompressing it. + * + * @param s the string to decode + * @return the decoded data + * @since 1.4 + */ + public static byte[] decode(String s) + { + byte[] bytes; + try + { + bytes = s.getBytes(PREFERRED_ENCODING); + } // end try + catch (java.io.UnsupportedEncodingException uee) + { + bytes = s.getBytes(); + } // end catch + //</change> + + // Decode + bytes = decode(bytes, 0, bytes.length); + + // Check to see if it's gzip-compressed + // GZIP Magic Two-Byte Number: 0x8b1f (35615) + if (bytes != null && bytes.length >= 4) + { + + int head = (bytes[0] & 0xff) | ((bytes[1] << 8) & 0xff00); + if (java.util.zip.GZIPInputStream.GZIP_MAGIC == head) + { + java.io.ByteArrayInputStream bais = null; + java.util.zip.GZIPInputStream gzis = null; + java.io.ByteArrayOutputStream baos = null; + byte[] buffer = new byte[2048]; + int length = 0; + + try + { + baos = new java.io.ByteArrayOutputStream(); + bais = new java.io.ByteArrayInputStream(bytes); + gzis = new java.util.zip.GZIPInputStream(bais); + + while ((length = gzis.read(buffer)) >= 0) + { + baos.write(buffer, 0, length); + } // end while: reading input + + // No error? Get new bytes. + bytes = baos.toByteArray(); + + } // end try + catch (java.io.IOException e) + { + // Just return originally-decoded bytes + } // end catch + finally + { + try + { + baos.close(); + } + catch (Exception e) + { + } + try + { + gzis.close(); + } + catch (Exception e) + { + } + try + { + bais.close(); + } + catch (Exception e) + { + } + } // end finally + + } // end if: gzipped + } // end if: bytes.length >= 2 + + return bytes; + } // end decode + + /** + * Attempts to decode Base64 data and deserialize a Java + * Object within. Returns <tt>null</tt> if there was an error. + * + * @param encodedObject The Base64 data to decode + * @return The decoded and deserialized object + * @since 1.5 + */ + public static Object decodeToObject(String encodedObject) + { + // Decode and gunzip if necessary + byte[] objBytes = decode(encodedObject); + + java.io.ByteArrayInputStream bais = null; + java.io.ObjectInputStream ois = null; + Object obj = null; + + try + { + bais = new java.io.ByteArrayInputStream(objBytes); + ois = new java.io.ObjectInputStream(bais); + + obj = ois.readObject(); + } // end try + catch (java.io.IOException e) + { + e.printStackTrace(); + obj = null; + } // end catch + catch (java.lang.ClassNotFoundException e) + { + e.printStackTrace(); + obj = null; + } // end catch + finally + { + try + { + bais.close(); + } + catch (Exception e) + { + } + try + { + ois.close(); + } + catch (Exception e) + { + } + } // end finally + + return obj; + } // end decodeObject + + /** + * Convenience method for encoding data to a file. + * + * @param dataToEncode byte array of data to encode in base64 form + * @param filename Filename for saving encoded data + * @return <tt>true</tt> if successful, <tt>false</tt> otherwise + * + * @since 2.1 + */ + public static boolean encodeToFile(byte[] dataToEncode, String filename) + { + boolean success = false; + Base64.OutputStream bos = null; + try + { + bos = new Base64.OutputStream(new java.io.FileOutputStream(filename), Base64.ENCODE); + bos.write(dataToEncode); + success = true; + } // end try + catch (java.io.IOException e) + { + + success = false; + } // end catch: IOException + finally + { + try + { + bos.close(); + } + catch (Exception e) + { + } + } // end finally + + return success; + } // end encodeToFile + + /** + * Convenience method for decoding data to a file. + * + * @param dataToDecode Base64-encoded data as a string + * @param filename Filename for saving decoded data + * @return <tt>true</tt> if successful, <tt>false</tt> otherwise + * + * @since 2.1 + */ + public static boolean decodeToFile(String dataToDecode, String filename) + { + boolean success = false; + Base64.OutputStream bos = null; + try + { + bos = new Base64.OutputStream(new java.io.FileOutputStream(filename), Base64.DECODE); + bos.write(dataToDecode.getBytes(PREFERRED_ENCODING)); + success = true; + } // end try + catch (java.io.IOException e) + { + success = false; + } // end catch: IOException + finally + { + try + { + bos.close(); + } + catch (Exception e) + { + } + } // end finally + + return success; + } // end decodeToFile + + /** + * Convenience method for reading a base64-encoded + * file and decoding it. + * + * @param filename Filename for reading encoded data + * @return decoded byte array or null if unsuccessful + * + * @since 2.1 + */ + public static byte[] decodeFromFile(String filename) + { + byte[] decodedData = null; + Base64.InputStream bis = null; + try + { + // Set up some useful variables + java.io.File file = new java.io.File(filename); + byte[] buffer = null; + int length = 0; + int numBytes = 0; + + // Check for size of file + if (file.length() > Integer.MAX_VALUE) + { + throw new IllegalStateException("File is too big for this convenience method (" + file.length() + " bytes)."); + } // end if: file too big for int index + buffer = new byte[(int)file.length()]; + + // Open a stream + bis = new Base64.InputStream(new java.io.BufferedInputStream(new java.io.FileInputStream(file)), Base64.DECODE); + + // Read until done + while ((numBytes = bis.read(buffer, length, 4096)) >= 0) + length += numBytes; + + // Save in a variable to return + decodedData = new byte[length]; + System.arraycopy(buffer, 0, decodedData, 0, length); + + } // end try + catch (java.io.IOException e) + { + throw new IllegalStateException("Error decoding from file " + filename); + } // end catch: IOException + finally + { + try + { + bis.close(); + } + catch (Exception e) + { + } + } // end finally + + return decodedData; + } // end decodeFromFile + + /** + * Convenience method for reading a binary file + * and base64-encoding it. + * + * @param filename Filename for reading binary data + * @return base64-encoded string or null if unsuccessful + * + * @since 2.1 + */ + public static String encodeFromFile(String filename) + { + String encodedData = null; + Base64.InputStream bis = null; + try + { + // Set up some useful variables + java.io.File file = new java.io.File(filename); + byte[] buffer = new byte[(int)(file.length() * 1.4)]; + int length = 0; + int numBytes = 0; + + // Open a stream + bis = new Base64.InputStream(new java.io.BufferedInputStream(new java.io.FileInputStream(file)), Base64.ENCODE); + + // Read until done + while ((numBytes = bis.read(buffer, length, 4096)) >= 0) + length += numBytes; + + // Save in a variable to return + encodedData = new String(buffer, 0, length, Base64.PREFERRED_ENCODING); + + } // end try + catch (java.io.IOException e) + { + throw new IllegalStateException("Error encoding from file " + filename); + } // end catch: IOException + finally + { + try + { + bis.close(); + } + catch (Exception e) + { + } + } // end finally + + return encodedData; + } // end encodeFromFile + + /* ******** I N N E R C L A S S I N P U T S T R E A M ******** */ + + /** + * A {@link Base64.InputStream} will read data from another + * <tt>java.io.InputStream</tt>, given in the constructor, + * and encode/decode to/from Base64 notation on the fly. + * + * @see Base64 + * @since 1.3 + */ + public static class InputStream extends java.io.FilterInputStream + { + private boolean encode; // Encoding or decoding + private int position; // Current position in the buffer + private byte[] buffer; // Small buffer holding converted data + private int bufferLength; // Length of buffer (3 or 4) + private int numSigBytes; // Number of meaningful bytes in the buffer + private int lineLength; + private boolean breakLines; // Break lines at less than 80 characters + + /** + * Constructs a {@link Base64.InputStream} in DECODE mode. + * + * @param in the <tt>java.io.InputStream</tt> from which to read data. + * @since 1.3 + */ + public InputStream(java.io.InputStream in) + { + this(in, DECODE); + } // end constructor + + /** + * Constructs a {@link Base64.InputStream} in + * either ENCODE or DECODE mode. + * <p> + * Valid options:<pre> + * ENCODE or DECODE: Encode or Decode as data is read. + * DONT_BREAK_LINES: don't break lines at 76 characters + * (only meaningful when encoding) + * <i>Note: Technically, this makes your encoding non-compliant.</i> + * </pre> + * <p> + * Example: <code>new Base64.InputStream( in, Base64.DECODE )</code> + * + * + * @param in the <tt>java.io.InputStream</tt> from which to read data. + * @param options Specified options + * @see Base64#ENCODE + * @see Base64#DECODE + * @see Base64#DONT_BREAK_LINES + * @since 2.0 + */ + public InputStream(java.io.InputStream in, int options) + { + super(in); + this.breakLines = (options & DONT_BREAK_LINES) != DONT_BREAK_LINES; + this.encode = (options & ENCODE) == ENCODE; + this.bufferLength = encode ? 4 : 3; + this.buffer = new byte[bufferLength]; + this.position = -1; + this.lineLength = 0; + } // end constructor + + /** + * Reads enough of the input stream to convert + * to/from Base64 and returns the next byte. + * + * @return next byte + * @since 1.3 + */ + public int read() throws java.io.IOException + { + // Do we need to get data? + if (position < 0) + { + if (encode) + { + byte[] b3 = new byte[3]; + int numBinaryBytes = 0; + for (int i = 0; i < 3; i++) + { + try + { + int b = in.read(); + + // If end of stream, b is -1. + if (b >= 0) + { + b3[i] = (byte)b; + numBinaryBytes++; + } // end if: not end of stream + + } // end try: read + catch (java.io.IOException e) + { + // Only a problem if we got no data at all. + if (i == 0) + throw e; + + } // end catch + } // end for: each needed input byte + + if (numBinaryBytes > 0) + { + encode3to4(b3, 0, numBinaryBytes, buffer, 0); + position = 0; + numSigBytes = 4; + } // end if: got data + else + { + return -1; + } // end else + } // end if: encoding + + // Else decoding + else + { + byte[] b4 = new byte[4]; + int i = 0; + for (i = 0; i < 4; i++) + { + // Read four "meaningful" bytes: + int b = 0; + do + { + b = in.read(); + } + while (b >= 0 && DECODABET[b & 0x7f] <= WHITE_SPACE_ENC); + + if (b < 0) + break; // Reads a -1 if end of stream + + b4[i] = (byte)b; + } // end for: each needed input byte + + if (i == 4) + { + numSigBytes = decode4to3(b4, 0, buffer, 0); + position = 0; + } // end if: got four characters + else if (i == 0) + { + return -1; + } // end else if: also padded correctly + else + { + // Must have broken out from above. + throw new java.io.IOException("Improperly padded Base64 input."); + } // end + + } // end else: decode + } // end else: get data + + // Got data? + if (position >= 0) + { + // End of relevant data? + if (/*!encode &&*/position >= numSigBytes) + return -1; + + if (encode && breakLines && lineLength >= MAX_LINE_LENGTH) + { + lineLength = 0; + return '\n'; + } // end if + else + { + lineLength++; // This isn't important when decoding + // but throwing an extra "if" seems + // just as wasteful. + + int b = buffer[position++]; + + if (position >= bufferLength) + position = -1; + + return b & 0xFF; // This is how you "cast" a byte that's + // intended to be unsigned. + } // end else + } // end if: position >= 0 + + // Else error + else + { + // When JDK1.4 is more accepted, use an assertion here. + throw new java.io.IOException("Error in Base64 code reading stream."); + } // end else + } // end read + + /** + * Calls {@link #read()} repeatedly until the end of stream + * is reached or <var>len</var> bytes are read. + * Returns number of bytes read into array or -1 if + * end of stream is encountered. + * + * @param dest array to hold values + * @param off offset for array + * @param len max number of bytes to read into array + * @return bytes read into array or -1 if end of stream is encountered. + * @since 1.3 + */ + public int read(byte[] dest, int off, int len) throws java.io.IOException + { + int i; + int b; + for (i = 0; i < len; i++) + { + b = read(); + + //if( b < 0 && i == 0 ) + // return -1; + + if (b >= 0) + dest[off + i] = (byte)b; + else if (i == 0) + return -1; + else break; // Out of 'for' loop + } // end for: each byte read + return i; + } // end read + + } // end inner class InputStream + + /* ******** I N N E R C L A S S O U T P U T S T R E A M ******** */ + + /** + * A {@link Base64.OutputStream} will write data to another + * <tt>java.io.OutputStream</tt>, given in the constructor, + * and encode/decode to/from Base64 notation on the fly. + * + * @see Base64 + * @since 1.3 + */ + public static class OutputStream extends java.io.FilterOutputStream + { + private boolean encode; + private int position; + private byte[] buffer; + private int bufferLength; + private int lineLength; + private boolean breakLines; + private byte[] b4; // Scratch used in a few places + private boolean suspendEncoding; + + /** + * Constructs a {@link Base64.OutputStream} in ENCODE mode. + * + * @param out the <tt>java.io.OutputStream</tt> to which data will be written. + * @since 1.3 + */ + public OutputStream(java.io.OutputStream out) + { + this(out, ENCODE); + } // end constructor + + /** + * Constructs a {@link Base64.OutputStream} in + * either ENCODE or DECODE mode. + * <p> + * Valid options:<pre> + * ENCODE or DECODE: Encode or Decode as data is read. + * DONT_BREAK_LINES: don't break lines at 76 characters + * (only meaningful when encoding) + * <i>Note: Technically, this makes your encoding non-compliant.</i> + * </pre> + * <p> + * Example: <code>new Base64.OutputStream( out, Base64.ENCODE )</code> + * + * @param out the <tt>java.io.OutputStream</tt> to which data will be written. + * @param options Specified options. + * @see Base64#ENCODE + * @see Base64#DECODE + * @see Base64#DONT_BREAK_LINES + * @since 1.3 + */ + public OutputStream(java.io.OutputStream out, int options) + { + super(out); + this.breakLines = (options & DONT_BREAK_LINES) != DONT_BREAK_LINES; + this.encode = (options & ENCODE) == ENCODE; + this.bufferLength = encode ? 3 : 4; + this.buffer = new byte[bufferLength]; + this.position = 0; + this.lineLength = 0; + this.suspendEncoding = false; + this.b4 = new byte[4]; + } // end constructor + + /** + * Writes the byte to the output stream after + * converting to/from Base64 notation. + * When encoding, bytes are buffered three + * at a time before the output stream actually + * gets a write() call. + * When decoding, bytes are buffered four + * at a time. + * + * @param theByte the byte to write + * @since 1.3 + */ + public void write(int theByte) throws java.io.IOException + { + // Encoding suspended? + if (suspendEncoding) + { + super.out.write(theByte); + return; + } // end if: supsended + + // Encode? + if (encode) + { + buffer[position++] = (byte)theByte; + if (position >= bufferLength) // Enough to encode. + { + out.write(encode3to4(b4, buffer, bufferLength)); + + lineLength += 4; + if (breakLines && lineLength >= MAX_LINE_LENGTH) + { + out.write(NEW_LINE); + lineLength = 0; + } // end if: end of line + + position = 0; + } // end if: enough to output + } // end if: encoding + + // Else, Decoding + else + { + // Meaningful Base64 character? + if (DECODABET[theByte & 0x7f] > WHITE_SPACE_ENC) + { + buffer[position++] = (byte)theByte; + if (position >= bufferLength) // Enough to output. + { + int len = Base64.decode4to3(buffer, 0, b4, 0); + out.write(b4, 0, len); + //out.write( Base64.decode4to3( buffer ) ); + position = 0; + } // end if: enough to output + } // end if: meaningful base64 character + else if (DECODABET[theByte & 0x7f] != WHITE_SPACE_ENC) + { + throw new java.io.IOException("Invalid character in Base64 data."); + } // end else: not white space either + } // end else: decoding + } // end write + + /** + * Calls {@link #write(int)} repeatedly until <var>len</var> + * bytes are written. + * + * @param theBytes array from which to read bytes + * @param off offset for array + * @param len max number of bytes to read into array + * @since 1.3 + */ + public void write(byte[] theBytes, int off, int len) throws java.io.IOException + { + // Encoding suspended? + if (suspendEncoding) + { + super.out.write(theBytes, off, len); + return; + } // end if: supsended + + for (int i = 0; i < len; i++) + { + write(theBytes[off + i]); + } // end for: each byte written + + } // end write + + /** + * Method added by PHIL. [Thanks, PHIL. -Rob] + * This pads the buffer without closing the stream. + * @throws IOException + */ + public void flushBase64() throws java.io.IOException + { + if (position > 0) + { + if (encode) + { + out.write(encode3to4(b4, buffer, position)); + position = 0; + } // end if: encoding + else + { + throw new java.io.IOException("Base64 input not properly padded."); + } // end else: decoding + } // end if: buffer partially full + + } // end flush + + /** + * Flushes and closes (I think, in the superclass) the stream. + * + * @since 1.3 + */ + public void close() throws java.io.IOException + { + // 1. Ensure that pending characters are written + flushBase64(); + + // 2. Actually close the stream + // Base class both flushes and closes. + super.close(); + + buffer = null; + out = null; + } // end close + + /** + * Suspends encoding of the stream. + * May be helpful if you need to embed a piece of + * base640-encoded data in a stream. + * + * @since 1.5.1 + * @throws IOException + */ + public void suspendEncoding() throws java.io.IOException + { + flushBase64(); + this.suspendEncoding = true; + } // end suspendEncoding + + /** + * Resumes encoding of the stream. + * May be helpful if you need to embed a piece of + * base640-encoded data in a stream. + * + * @since 1.5.1 + */ + public void resumeEncoding() + { + this.suspendEncoding = false; + } // end resumeEncoding + + } // end inner class OutputStream + +} // end class Base64 Property changes on: common/trunk/src/main/java/org/jboss/ws/common/utils/Base64.java ___________________________________________________________________ Added: svn:keywords + Rev Date Added: svn:eol-style + native Added: common/trunk/src/main/java/org/jboss/ws/common/utils/JBossEntityResolver.java =================================================================== --- common/trunk/src/main/java/org/jboss/ws/common/utils/JBossEntityResolver.java (rev 0) +++ common/trunk/src/main/java/org/jboss/ws/common/utils/JBossEntityResolver.java 2015-02-23 21:12:51 UTC (rev 19496) @@ -0,0 +1,715 @@ +/* + * JBoss, Home of Professional Open Source. + * Copyright 2015, Red Hat Middleware LLC, and individual contributors + * as indicated by the @author tags. See the copyright.txt file in the + * distribution for a full listing of individual contributors. + * + * This is free software; you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2.1 of + * the License, or (at your option) any later version. + * + * This software is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this software; if not, write to the Free + * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + * 02110-1301 USA, or see the FSF site: http://www.fsf.org. + */ +package org.jboss.ws.common.utils; + +import java.io.IOException; +import java.io.InputStream; +import java.io.Reader; +import java.net.MalformedURLException; +import java.net.URI; +import java.net.URISyntaxException; +import java.net.URL; +import java.security.AccessController; +import java.security.PrivilegedAction; +import java.util.Collections; +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; + +import org.jboss.logging.Logger; +import org.w3c.dom.ls.LSInput; +import org.w3c.dom.ls.LSResourceResolver; +import org.xml.sax.EntityResolver; +import org.xml.sax.InputSource; +import org.xml.sax.SAXException; + +/** +* Local entity resolver to handle standard J2EE DTDs and Schemas as well as JBoss +* specific DTDs. +* <p/> +* Function boolean isEntityResolved() is here to avoid validation errors in +* descriptors that do not have a DOCTYPE declaration. +* +* @author Scott.Stark(a)jboss.org +* @author Thomas.Diesler(a)jboss.org +* @author Dimitris.Andreadis(a)jboss.org +*/ +@SuppressWarnings({"unchecked", "rawtypes"}) +public class JBossEntityResolver implements EntityResolver, LSResourceResolver +{ + private static final Logger log = Logger.getLogger(JBossEntityResolver.class); + + /** A class wide Map<String, String> of publicId/systemId to dtd/xsd file */ + private static Map entities = new ConcurrentHashMap (); + /** A class flag indicating whether an attempt to resolve a systemID as a + non-file URL should produce a warning rather than a trace level log msg. + */ + private static boolean warnOnNonFileURLs; + + /** Should system property refs in system ids be replaced */ + private boolean replaceSystemProperties = true; + + /** A local entities map that overrides the class level entities */ + private Map localEntities; + + private ThreadLocal<Boolean> entityResolved = new ThreadLocal<Boolean>(); + + static + { + AccessController.doPrivileged(new PrivilegedAction() + { + public Object run() + { + warnOnNonFileURLs = new Boolean(System.getProperty("org.jboss.resolver.warning", "false")).booleanValue(); + return null; + } + }); + + // xml + registerEntity("-//W3C//DTD/XMLSCHEMA 200102//EN", "XMLSchema.dtd"); + registerEntity("http://www.w3.org/2001/XMLSchema.dtd";, "XMLSchema.dtd"); + registerEntity("datatypes", "datatypes.dtd"); // This dtd doesn't have a publicId - see XMLSchema.dtd + registerEntity("http://www.w3.org/XML/1998/namespace";, "xml.xsd"); + registerEntity("http://www.w3.org/2001/xml.xsd";, "xml.xsd"); + registerEntity("http://www.w3.org/2005/05/xmlmime";, "xml-media-types.xsd"); + + // Java EE common + registerEntity("http://java.sun.com/xml/ns/j2ee/j2ee_1_4.xsd";, "j2ee_1_4.xsd"); + registerEntity("http://java.sun.com/xml/ns/javaee/javaee_5.xsd";, "javaee_5.xsd"); + // JBoss common + registerEntity("http://www.jboss.org/j2ee/schema/jboss-common_5_1.xs...;, "jboss-common_5_1.xsd"); + + // Java EE WS + registerEntity("http://schemas.xmlsoap.org/soap/encoding/";, "soap-encoding_1_1.xsd"); + registerEntity("http://www.ibm.com/webservices/xsd/j2ee_web_services...;, "j2ee_web_services_client_1_1.xsd"); + registerEntity("http://www.ibm.com/webservices/xsd/j2ee_web_services...;, "j2ee_web_services_1_1.xsd"); + registerEntity("http://www.ibm.com/webservices/xsd/j2ee_jaxrpc_mappi...;, "j2ee_jaxrpc_mapping_1_1.xsd"); + registerEntity("http://java.sun.com/xml/ns/javaee/javaee_web_service...;, "javaee_web_services_client_1_2.xsd"); + + // ejb + registerEntity("-//Sun Microsystems, Inc.//DTD Enterprise JavaBeans 1.1//EN", "ejb-jar_1_1.dtd"); + registerEntity("-//Sun Microsystems, Inc.//DTD Enterprise JavaBeans 2.0//EN", "ejb-jar_2_0.dtd"); + registerEntity("http://java.sun.com/xml/ns/j2ee/ejb-jar_2_1.xsd";, "ejb-jar_2_1.xsd"); + // ejb3 + registerEntity("http://java.sun.com/xml/ns/javaee/ejb-jar_3_0.xsd";, "ejb-jar_3_0.xsd"); + // jboss ejb2 + registerEntity("-//JBoss//DTD JBOSS//EN", "jboss.dtd"); + registerEntity("-//JBoss//DTD JBOSS 2.4//EN", "jboss_2_4.dtd"); + registerEntity("-//JBoss//DTD JBOSS 3.0//EN", "jboss_3_0.dtd"); + registerEntity("-//JBoss//DTD JBOSS 3.2//EN", "jboss_3_2.dtd"); + registerEntity("-//JBoss//DTD JBOSS 4.0//EN", "jboss_4_0.dtd"); + registerEntity("-//JBoss//DTD JBOSS 4.2//EN", "jboss_4_2.dtd"); + registerEntity("-//JBoss//DTD JBOSS 5.0//EN", "jboss_5_0.dtd"); + registerEntity("-//JBoss//DTD JBOSS 5.1.EAP//EN", "jboss_5_1_eap.dtd"); + registerEntity("-//JBoss//DTD JBOSS 6.0//EN", "jboss_6_0.dtd"); + registerEntity("-//JBoss//DTD JBOSSCMP-JDBC 3.0//EN", "jbosscmp-jdbc_3_0.dtd"); + registerEntity("-//JBoss//DTD JBOSSCMP-JDBC 3.2//EN", "jbosscmp-jdbc_3_2.dtd"); + registerEntity("-//JBoss//DTD JBOSSCMP-JDBC 4.0//EN", "jbosscmp-jdbc_4_0.dtd"); + registerEntity("-//JBoss//DTD JBOSSCMP-JDBC 4.2//EN", "jbosscmp-jdbc_4_2.dtd"); + // jboss ejb3 + registerEntity("http://www.jboss.org/j2ee/schema/jboss_5_0.xsd";, "jboss_5_0.xsd"); + registerEntity("http://www.jboss.org/j2ee/schema/jboss_5_1.xsd";, "jboss_5_1.xsd"); + + // ear stuff + registerEntity("-//Sun Microsystems, Inc.//DTD J2EE Application 1.2//EN", "application_1_2.dtd"); + registerEntity("-//Sun Microsystems, Inc.//DTD J2EE Application 1.3//EN", "application_1_3.dtd"); + registerEntity("-//Sun Microsystems, Inc.//DTD J2EE Application Client 1.3//EN", "application-client_1_3.dtd"); + registerEntity("http://java.sun.com/xml/ns/j2ee/application_1_4.xsd&...;, "application_1_4.xsd"); + registerEntity("http://java.sun.com/xml/ns/javaee/application_5.xsd&...;, "application_5.xsd"); + // jboss-app + registerEntity("-//JBoss//DTD J2EE Application 1.3//EN", "jboss-app_3_0.dtd"); + registerEntity("-//JBoss//DTD J2EE Application 1.3V2//EN", "jboss-app_3_2.dtd"); + registerEntity("-//JBoss//DTD J2EE Application 1.4//EN", "jboss-app_4_0.dtd"); + registerEntity("-//JBoss//DTD J2EE Application 4.2//EN", "jboss-app_4_2.dtd"); + registerEntity("-//JBoss//DTD Java EE Application 5.0//EN", "jboss-app_5_0.dtd"); + + // connector descriptors + registerEntity("-//Sun Microsystems, Inc.//DTD Connector 1.0//EN", "connector_1_0.dtd"); + registerEntity("http://java.sun.com/xml/ns/j2ee/connector_1_5.xsd";, "connector_1_5.xsd"); + registerEntity("http://java.sun.com/xml/ns/j2ee/connector_1_6.xsd";, "connector_1_6.xsd"); + // jboss-ds + registerEntity("-//JBoss//DTD JBOSS JCA Config 1.0//EN", "jboss-ds_1_0.dtd"); + registerEntity("-//JBoss//DTD JBOSS JCA Config 1.5//EN", "jboss-ds_1_5.dtd"); + registerEntity("http://www.jboss.org/j2ee/schema/jboss-ds_5_0.xsd";, "jboss-ds_5_0.xsd"); + // jboss-ra + registerEntity("http://www.jboss.org/j2ee/schema/jboss-ra_1_0.xsd";, "jboss-ra_1_0.xsd"); + + // war meta-data + registerEntity("-//Sun Microsystems, Inc.//DTD Web Application 2.2//EN", "web-app_2_2.dtd"); + registerEntity("-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN", "web-app_2_3.dtd"); + registerEntity("http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd";, "web-app_2_4.xsd"); + registerEntity("http://java.sun.com/xml/ns/j2ee/web-app_2_5.xsd";, "web-app_2_5.xsd"); + registerEntity("http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd";, "web-app_3_0.xsd"); + // jboss-web + registerEntity("-//JBoss//DTD Web Application 2.2//EN", "jboss-web.dtd"); + registerEntity("-//JBoss//DTD Web Application 2.3//EN", "jboss-web_3_0.dtd"); + registerEntity("-//JBoss//DTD Web Application 2.3V2//EN", "jboss-web_3_2.dtd"); + registerEntity("-//JBoss//DTD Web Application 2.4//EN", "jboss-web_4_0.dtd"); + registerEntity("-//JBoss//DTD Web Application 4.2//EN", "jboss-web_4_2.dtd"); + registerEntity("-//JBoss//DTD Web Application 5.0//EN", "jboss-web_5_0.dtd"); + registerEntity("http://www.jboss.org/j2ee/schema/jboss-web_5_1.xsd";, "jboss-web_5_1.xsd"); + + // application client + registerEntity("http://java.sun.com/xml/ns/j2ee/application-client_1...;, "application-client_1_4.xsd"); + registerEntity("http://java.sun.com/xml/ns/javaee/application-client...;, "application-client_5.xsd"); + // jboss-client + registerEntity("-//JBoss//DTD Application Client 3.2//EN", "jboss-client_3_2.dtd"); + registerEntity("-//JBoss//DTD Application Client 4.0//EN", "jboss-client_4_0.dtd"); + registerEntity("-//JBoss//DTD Application Client 4.2//EN", "jboss-client_4_2.dtd"); + registerEntity("-//JBoss//DTD Application Client 5.0//EN", "jboss-client_5_0.dtd"); + registerEntity("http://www.jboss.org/j2ee/schema/jboss-client_5_1.xs...;, "jboss-client_5_1.xsd"); + + // jboss-specific + registerEntity("-//JBoss//DTD Web Service Reference 4.0//EN", "service-ref_4_0.dtd"); + registerEntity("-//JBoss//DTD Web Service Reference 4.2//EN", "service-ref_4_2.dtd"); + registerEntity("-//JBoss//DTD Web Service Reference 5.0//EN", "service-ref_5_0.dtd"); + registerEntity("-//JBoss//DTD MBean Service 3.2//EN", "jboss-service_3_2.dtd"); + registerEntity("-//JBoss//DTD MBean Service 4.0//EN", "jboss-service_4_0.dtd"); + registerEntity("-//JBoss//DTD MBean Service 4.2//EN", "jboss-service_4_2.dtd"); + registerEntity("-//JBoss//DTD MBean Service 5.0//EN", "jboss-service_5_0.dtd"); + registerEntity("-//JBoss//DTD JBOSS XMBEAN 1.0//EN", "jboss_xmbean_1_0.dtd"); + registerEntity("-//JBoss//DTD JBOSS XMBEAN 1.1//EN", "jboss_xmbean_1_1.dtd"); + registerEntity("-//JBoss//DTD JBOSS XMBEAN 1.2//EN", "jboss_xmbean_1_2.dtd"); + registerEntity("-//JBoss//DTD JBOSS Security Config 3.0//EN", "security_config.dtd"); + registerEntity("http://www.jboss.org/j2ee/schema/security-config_4_0...;, "security-config_4_0.xsd"); + registerEntity("urn:jboss:aop-deployer", "aop-deployer_1_1.xsd"); + registerEntity("urn:jboss:aop-beans:1.0", "aop-beans_1_0.xsd"); + registerEntity("urn:jboss:bean-deployer", "bean-deployer_1_0.xsd"); + registerEntity("urn:jboss:bean-deployer:2.0", "bean-deployer_2_0.xsd"); + registerEntity("urn:jboss:javabean:1.0", "javabean_1_0.xsd"); + registerEntity("urn:jboss:javabean:2.0", "javabean_2_0.xsd"); + registerEntity("urn:jboss:spring-beans:2.0", "mc-spring-beans_2_0.xsd"); + registerEntity("urn:jboss:policy:1.0", "policy_1_0.xsd"); + registerEntity("urn:jboss:osgi-beans:1.0", "osgi-beans_1_0.xsd"); + registerEntity("urn:jboss:seam-components:1.0", "seam-components_1_0.xsd"); + registerEntity("urn:jboss:security-config:4.1", "security-config_4_1.xsd"); + registerEntity("urn:jboss:security-config:5.0", "security-config_5_0.xsd"); + registerEntity("urn:jboss:jndi-binding-service:1.0", "jndi-binding-service_1_0.xsd"); + registerEntity("urn:jboss:user-roles:1.0", "user-roles_1_0.xsd"); + } + + /** + Obtain a read-only view of the current entity map. + + @return Map<String, String> of the publicID/systemID to dtd/schema file name + */ + public static Map getEntityMap() + { + return Collections.unmodifiableMap(entities); + } + + public static boolean isWarnOnNonFileURLs() + { + return warnOnNonFileURLs; + } + + public static void setWarnOnNonFileURLs(boolean warnOnNonFileURLs) + { + JBossEntityResolver.warnOnNonFileURLs = warnOnNonFileURLs; + } + + /** + * Register the mapping from the public id/system id to the dtd/xsd file + * name. This overwrites any existing mapping. + * + * @param id the DOCTYPE public id or system id such as + * "-//Sun Microsystems, Inc.//DTD Enterprise JavaBeans 1.1//EN" + * @param dtdFileName the simple dtd/xsd file name, "ejb-jar.dtd" + */ + public static void registerEntity(String id, String dtdFileName) + { + entities.put(id, dtdFileName); + } + + + public boolean isReplaceSystemProperties() + { + return replaceSystemProperties; + } + + public void setReplaceSystemProperties(boolean replaceSystemProperties) + { + this.replaceSystemProperties = replaceSystemProperties; + } + + /** + * Register the mapping from the public id/system id to the dtd/xsd file + * name. This overwrites any existing mapping. + * + * @param id the DOCTYPE public id or system id such as + * "-//Sun Microsystems, Inc.//DTD Enterprise JavaBeans 1.1//EN" + * @param dtdOrSchema the simple dtd/xsd file name, "ejb-jar.dtd" + */ + public synchronized void registerLocalEntity(String id, String dtdOrSchema) + { + if( localEntities == null ) + localEntities = new ConcurrentHashMap(); + localEntities.put(id, dtdOrSchema); + } + + /** + Returns DTD/Schema inputSource. The resolution logic is: + + 1. Check the publicId against the current registered values in the class + mapping of entity name to dtd/schema file name. If found, the resulting + file name is passed to the loadClasspathResource to locate the file as a + classpath resource. + + 2. Check the systemId against the current registered values in the class + mapping of entity name to dtd/schema file name. If found, the resulting + file name is passed to the loadClasspathResource to locate the file as a + classpath resource. + + 3. Strip the systemId name down to the simple file name by removing an URL + style path elements (myschemas/x.dtd becomes x.dtd), and call + loadClasspathResource to locate the simple file name as a classpath resource. + + 4. Attempt to resolve the systemId as a URL from which the schema can be + read. If the URL input stream can be opened this returned as the resolved + input. + + @param publicId - Public ID of DTD, or null if it is a schema + @param systemId - the system ID of DTD or Schema + @return InputSource of entity + */ + public InputSource resolveEntity(String publicId, String systemId) throws SAXException, IOException + { + entityResolved.set(Boolean.FALSE); + + // nothing to resolve + if( publicId == null && systemId == null ) + return null; + + boolean trace = log.isTraceEnabled(); + + boolean resolvePublicIdFirst = true; + if(publicId != null && systemId != null) + { + String registeredSystemId = null; + if(localEntities != null) + registeredSystemId = (String) localEntities.get(publicId); + if(registeredSystemId == null) + registeredSystemId = (String) entities.get(publicId); + + if(registeredSystemId != null && !registeredSystemId.equals(systemId)) + { + resolvePublicIdFirst = false; + if(trace) + log.trace("systemId argument '" + systemId + "' for publicId '" + + publicId + "' is different from the registered systemId '" + + registeredSystemId + "', resolution will be based on the argument"); + } + } + + InputSource inputSource = null; + + if(resolvePublicIdFirst) + { + // Look for a registered publicID + inputSource = resolvePublicID(publicId, trace); + } + + if( inputSource == null ) + { + // Try to resolve the systemID from the registry + inputSource = resolveSystemID(systemId, trace); + } + + if( inputSource == null ) + { + // Try to resolve the systemID as a classpath reference under dtd or schema + inputSource = resolveClasspathName(systemId, trace); + } + + if( inputSource == null ) + { + // Try to resolve the systemID as a absolute URL + inputSource = resolveSystemIDasURL(systemId, trace); + } + + entityResolved.set(new Boolean(inputSource != null)); + + if (inputSource == null) + log.debug("Cannot resolve [publicID=" + publicId + ",systemID=" + systemId + "]"); + + return inputSource; + } + + /** + * Returns the boolean value to inform id DTD was found in the XML file or not + * + * @return boolean - true if DTD was found in XML + */ + public boolean isEntityResolved() + { + Boolean value = entityResolved.get(); + return value != null ? value.booleanValue() : false; + } + + /** + Load the schema from the class entity to schema file mapping. + @see #registerEntity(String, String) + + @param publicId - the public entity name of the schema + @param trace - trace level logging flag + @return the InputSource for the schema file found on the classpath, null + if the publicId is not registered or found. + */ + protected InputSource resolvePublicID(String publicId, boolean trace) + { + if( publicId == null ) + return null; + + if (trace) + log.trace("resolvePublicID, publicId=" + publicId); + + InputSource inputSource = null; + + String filename = null; + if( localEntities != null ) + filename = (String) localEntities.get(publicId); + if( filename == null ) + filename = (String) entities.get(publicId); + + if( filename != null ) + { + if (trace) + log.trace("Found entity from publicId=" + publicId + " fileName=" + filename); + + InputStream ins = loadClasspathResource(filename, trace); + if( ins != null ) + { + inputSource = new InputSource(ins); + inputSource.setPublicId(publicId); + } + else + { + log.trace("Cannot load publicId from classpath resource: " + filename); + + // Try the file name as a URI + inputSource = resolveSystemIDasURL(filename, trace); + + if (inputSource == null) + log.warn("Cannot load publicId from resource: " + filename); + } + } + + return inputSource; + } + + /** + Attempt to use the systemId as a URL from which the schema can be read. This + checks to see whether the systemId is a key to an entry in the class + entity map. + + @param systemId - the systemId + @param trace - trace level logging flag + @return the URL InputSource if the URL input stream can be opened, null + if the systemId is not a URL or could not be opened. + */ + protected InputSource resolveSystemID(String systemId, boolean trace) + { + if( systemId == null ) + return null; + + if( trace ) + log.trace("resolveSystemID, systemId="+systemId); + + InputSource inputSource = null; + + // Try to resolve the systemId as an entity key + String filename = null; + if( localEntities != null ) + filename = (String) localEntities.get(systemId); + if( filename == null ) + filename = (String) entities.get(systemId); + + if ( filename != null ) + { + if( trace ) + log.trace("Found entity systemId=" + systemId + " fileName=" + filename); + + InputStream ins = loadClasspathResource(filename, trace); + if( ins != null ) + { + inputSource = new InputSource(ins); + inputSource.setSystemId(systemId); + } + else + { + log.warn("Cannot load systemId from resource: " + filename); + } + } + + return inputSource; + } + + /** + Attempt to use the systemId as a URL from which the schema can be read. This + uses the systemID as a URL. + + @param systemId - the systemId + @param trace - trace level logging flag + @return the URL InputSource if the URL input stream can be opened, null + if the systemId is not a URL or could not be opened. + */ + protected InputSource resolveSystemIDasURL(String systemId, boolean trace) + { + if( systemId == null ) + return null; + + if( trace ) + log.trace("resolveSystemIDasURL, systemId="+systemId); + + InputSource inputSource = null; + + // Try to use the systemId as a URL to the schema + try + { + if (trace) + log.trace("Trying to resolve systemId as a URL"); + // Replace any system property refs if isReplaceSystemProperties is true + if(isReplaceSystemProperties()) + systemId = StringPropertyReplacer.replaceProperties(systemId); + URL url = new URL(systemId); + if (warnOnNonFileURLs + && url.getProtocol().equalsIgnoreCase("file") == false + && url.getProtocol().equalsIgnoreCase("vfszip") == false) + { + log.warn("Trying to resolve systemId as a non-file URL: " + systemId); + } + + InputStream ins = url.openStream(); + if (ins != null) + { + inputSource = new InputSource(ins); + inputSource.setSystemId(systemId); + } + else + { + log.warn("Cannot load systemId as URL: " + systemId); + } + + if (trace) + log.trace("Resolved systemId as a URL"); + } + catch (MalformedURLException ignored) + { + if (trace) + log.trace("SystemId is not a url: " + systemId, ignored); + } + catch (IOException e) + { + if (trace) + log.trace("Failed to obtain URL.InputStream from systemId: " + systemId, e); + } + return inputSource; + } + + /** + Resolve the systemId as a classpath resource. If not found, the + systemId is simply used as a classpath resource name. + + @param systemId - the system ID of DTD or Schema + @param trace - trace level logging flag + @return the InputSource for the schema file found on the classpath, null + if the systemId is not registered or found. + */ + protected InputSource resolveClasspathName(String systemId, boolean trace) + { + if( systemId == null ) + return null; + + if( trace ) + log.trace("resolveClasspathName, systemId="+systemId); + String filename = systemId; + // Parse the systemId as a uri to get the final path component + try + { + URI url = new URI(systemId); + String path = url.getPath(); + if( path == null ) + path = url.getSchemeSpecificPart(); + int slash = path.lastIndexOf('/'); + if( slash >= 0 ) + filename = path.substring(slash + 1); + else + filename = path; + + if(filename.length() == 0) + return null; + + if (trace) + log.trace("Mapped systemId to filename: " + filename); + } + catch (URISyntaxException e) + { + if (trace) + log.trace("systemId: is not a URI, using systemId as resource", e); + } + + // Resolve the filename as a classpath resource + InputStream is = loadClasspathResource(filename, trace); + InputSource inputSource = null; + if( is != null ) + { + inputSource = new InputSource(is); + inputSource.setSystemId(systemId); + } + return inputSource; + } + + /** + Look for the resource name on the thread context loader resource path. This + first simply tries the resource name as is, and if not found, the resource + is prepended with either "dtd/" or "schema/" depending on whether the + resource ends in ".dtd" or ".xsd". + + @param resource - the classpath resource name of the schema + @param trace - trace level logging flag + @return the resource InputStream if found, null if not found. + */ + protected InputStream loadClasspathResource(String resource, boolean trace) + { + ClassLoader loader = Thread.currentThread().getContextClassLoader(); + URL url = loader.getResource(resource); + if( url == null ) + { + /* Prefix the simple filename with the schema type patch as this is the + naming convention for the jboss bundled schemas. + */ + if( resource.endsWith(".dtd") ) + resource = "dtd/" + resource; + else if( resource.endsWith(".xsd") ) + resource = "schema/" + resource; + url = loader.getResource(resource); + } + + InputStream inputStream = null; + if( url != null ) + { + if( trace ) + log.trace(resource+" maps to URL: "+url); + try + { + inputStream = url.openStream(); + } + catch(IOException e) + { + log.debug("Failed to open url stream", e); + } + } + return inputStream; + } + + public LSInput resolveResource(String type, String namespaceURI, String publicId, String systemId, String baseURI) { + InputSource inputSource = null; + try { + inputSource = resolveEntity(publicId, systemId); + } catch (Exception e) { + log.debug("Failed to resolve resource", e); + } + LSInput result = null; + if (inputSource != null) { + result = new LSInputImpl(publicId, systemId, baseURI, inputSource); + } + return result; + } + + private static class LSInputImpl implements LSInput { + + private final String systemID; + private final String publicID; + private final String baseURI; + private final InputSource inputSource; + + public LSInputImpl(String publicID, String systemID, String baseURI, InputSource inputSource) { + this.inputSource = inputSource; + this.systemID = systemID; + this.publicID = publicID; + this.baseURI = baseURI; + } + + public Reader getCharacterStream() { + return inputSource.getCharacterStream(); + } + + public void setCharacterStream(Reader characterStream) { + throw new NotImplementedException(); + } + + public InputStream getByteStream() { + return inputSource.getByteStream(); + } + + public void setByteStream(InputStream byteStream) { + throw new NotImplementedException(); + } + + public String getStringData() { + return null; + } + + public void setStringData(String stringData) { + throw new NotImplementedException(); + } + + public String getSystemId() { + return systemID; + } + + public void setSystemId(String systemId) { + throw new NotImplementedException(); + } + + public String getPublicId() { + return publicID; + } + + public void setPublicId(String publicId) { + throw new NotImplementedException(); + } + + public String getBaseURI() { + return baseURI; + } + + public void setBaseURI(String baseURI) { + throw new NotImplementedException(); + } + + public String getEncoding() { + return null; + } + + public void setEncoding(String encoding) { + throw new NotImplementedException(); + } + + public boolean getCertifiedText() { + return false; + } + + public void setCertifiedText(boolean certifiedText) { + throw new NotImplementedException(); + } + } +} \ No newline at end of file Property changes on: common/trunk/src/main/java/org/jboss/ws/common/utils/JBossEntityResolver.java ___________________________________________________________________ Added: svn:keywords + Rev Date Added: svn:eol-style + native Modified: common/trunk/src/main/java/org/jboss/ws/common/utils/JBossWSEntityResolver.java =================================================================== --- common/trunk/src/main/java/org/jboss/ws/common/utils/JBossWSEntityResolver.java 2015-02-23 21:11:41 UTC (rev 19495) +++ common/trunk/src/main/java/org/jboss/ws/common/utils/JBossWSEntityResolver.java 2015-02-23 21:12:51 UTC (rev 19496) @@ -37,7 +37,6 @@ import java.util.WeakHashMap; import java.util.concurrent.ConcurrentHashMap; -import org.jboss.util.xml.JBossEntityResolver; import org.jboss.wsf.spi.classloading.ClassLoaderProvider; import org.xml.sax.InputSource; import org.xml.sax.SAXException; Added: common/trunk/src/main/java/org/jboss/ws/common/utils/NotImplementedException.java =================================================================== --- common/trunk/src/main/java/org/jboss/ws/common/utils/NotImplementedException.java (rev 0) +++ common/trunk/src/main/java/org/jboss/ws/common/utils/NotImplementedException.java 2015-02-23 21:12:51 UTC (rev 19496) @@ -0,0 +1,24 @@ +package org.jboss.ws.common.utils; + +public class NotImplementedException extends RuntimeException +{ + private static final long serialVersionUID = 1366726477562496595L; + + /** + * Construct a <tt>NotImplementedException</tt> with a detail message. + * + * @param msg Detail message. + */ + public NotImplementedException(final String msg) + { + super(msg); + } + + /** + * Construct a <tt>NotImplementedException</tt> with no detail. + */ + public NotImplementedException() + { + super(); + } +} \ No newline at end of file Property changes on: common/trunk/src/main/java/org/jboss/ws/common/utils/NotImplementedException.java ___________________________________________________________________ Added: svn:keywords + Rev Date Added: svn:eol-style + native Added: common/trunk/src/main/java/org/jboss/ws/common/utils/StringPropertyReplacer.java =================================================================== --- common/trunk/src/main/java/org/jboss/ws/common/utils/StringPropertyReplacer.java (rev 0) +++ common/trunk/src/main/java/org/jboss/ws/common/utils/StringPropertyReplacer.java 2015-02-23 21:12:51 UTC (rev 19496) @@ -0,0 +1,302 @@ +/* + * JBoss, Home of Professional Open Source + * Copyright 2015, JBoss Inc., and individual contributors as indicated + * by the @authors tag. See the copyright.txt in the distribution for a + * full listing of individual contributors. + * + * This is free software; you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2.1 of + * the License, or (at your option) any later version. + * + * This software is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this software; if not, write to the Free + * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + * 02110-1301 USA, or see the FSF site: http://www.fsf.org. + */ +package org.jboss.ws.common.utils; + +import java.security.AccessController; +import java.security.PrivilegedAction; +import java.util.Properties; +import java.io.File; + +/** +* A utility class for replacing properties in strings. +* +* @author <a href="mailto:jason@planet57.com">Jason Dillon</a> +* @author <a href=&quot;Scott.Stark(a)jboss.org&quot;&gt;Scott Stark</a> +* @author <a href=&quot;claudio.vesco(a)previnet.it&quot;&gt;Claudio Vesco</a> +* @author <a href="mailto:adrian@jboss.com">Adrian Brock</a> +* @author <a href="mailto:dimitris@jboss.org">Dimitris Andreadis</a> +* @version <tt>$Revision$</tt> +*/ +public final class StringPropertyReplacer +{ + /** New line string constant */ + public static final String NEWLINE = getProperty("line.separator", "\n"); + + /** File separator value */ + private static final String FILE_SEPARATOR = File.separator; + + /** Path separator value */ + private static final String PATH_SEPARATOR = File.pathSeparator; + + /** File separator alias */ + private static final String FILE_SEPARATOR_ALIAS = "/"; + + /** Path separator alias */ + private static final String PATH_SEPARATOR_ALIAS = ":"; + + // States used in property parsing + private static final int NORMAL = 0; + private static final int SEEN_DOLLAR = 1; + private static final int IN_BRACKET = 2; + + /** + * Go through the input string and replace any occurance of ${p} with + * the System.getProperty(p) value. If there is no such property p defined, + * then the ${p} reference will remain unchanged. + * + * If the property reference is of the form ${p:v} and there is no such property p, + * then the default value v will be returned. + * + * If the property reference is of the form ${p1,p2} or ${p1,p2:v} then + * the primary and the secondary properties will be tried in turn, before + * returning either the unchanged input, or the default value. + * + * The property ${/} is replaced with System.getProperty("file.separator") + * value and the property ${:} is replaced with System.getProperty("path.separator"). + * + * @param string - the string with possible ${} references + * @return the input string with all property references replaced if any. + * If there are no valid references the input string will be returned. + */ + public static String replaceProperties(final String string) + { + return replaceProperties(string, null); + } + + /** + * Go through the input string and replace any occurance of ${p} with + * the props.getProperty(p) value. If there is no such property p defined, + * then the ${p} reference will remain unchanged. + * + * If the property reference is of the form ${p:v} and there is no such property p, + * then the default value v will be returned. + * + * If the property reference is of the form ${p1,p2} or ${p1,p2:v} then + * the primary and the secondary properties will be tried in turn, before + * returning either the unchanged input, or the default value. + * + * The property ${/} is replaced with System.getProperty("file.separator") + * value and the property ${:} is replaced with System.getProperty("path.separator"). + * + * @param string - the string with possible ${} references + * @param props - the source for ${x} property ref values, null means use System.getProperty() + * @return the input string with all property references replaced if any. + * If there are no valid references the input string will be returned. + */ + public static String replaceProperties(final String string, final Properties props) + { + final char[] chars = string.toCharArray(); + StringBuffer buffer = new StringBuffer(); + boolean properties = false; + int state = NORMAL; + int start = 0; + for (int i = 0; i < chars.length; ++i) + { + char c = chars[i]; + + // Dollar sign outside brackets + if (c == '$' && state != IN_BRACKET) + state = SEEN_DOLLAR; + + // Open bracket immediatley after dollar + else if (c == '{' && state == SEEN_DOLLAR) + { + buffer.append(string.substring(start, i - 1)); + state = IN_BRACKET; + start = i - 1; + } + + // No open bracket after dollar + else if (state == SEEN_DOLLAR) + state = NORMAL; + + // Closed bracket after open bracket + else if (c == '}' && state == IN_BRACKET) + { + // No content + if (start + 2 == i) + { + buffer.append("${}"); // REVIEW: Correct? + } + else // Collect the system property + { + String value = null; + + String key = string.substring(start + 2, i); + + // check for alias + if (FILE_SEPARATOR_ALIAS.equals(key)) + { + value = FILE_SEPARATOR; + } + else if (PATH_SEPARATOR_ALIAS.equals(key)) + { + value = PATH_SEPARATOR; + } + else + { + // check from the properties + if (props != null) + value = props.getProperty(key); + else + value = System.getProperty(key); + + if (value == null) + { + // Check for a default value ${key:default} + int colon = key.indexOf(':'); + if (colon > 0) + { + String realKey = key.substring(0, colon); + if (props != null) + value = props.getProperty(realKey); + else + value = System.getProperty(realKey); + + if (value == null) + { + // Check for a composite key, "key1,key2" + value = resolveCompositeKey(realKey, props); + + // Not a composite key either, use the specified default + if (value == null) + value = key.substring(colon+1); + } + } + else + { + // No default, check for a composite key, "key1,key2" + value = resolveCompositeKey(key, props); + } + } + } + + if (value != null) + { + properties = true; + buffer.append(value); + } + else + { + buffer.append("${"); + buffer.append(key); + buffer.append('}'); + } + + } + start = i + 1; + state = NORMAL; + } + } + + // No properties + if (properties == false) + return string; + + // Collect the trailing characters + if (start != chars.length) + buffer.append(string.substring(start, chars.length)); + + // Done + return buffer.toString(); + } + + /** + * Try to resolve a "key" from the provided properties by + * checking if it is actually a "key1,key2", in which case + * try first "key1", then "key2". If all fails, return null. + * + * It also accepts "key1," and ",key2". + * + * @param key the key to resolve + * @param props the properties to use + * @return the resolved key or null + */ + private static String resolveCompositeKey(String key, Properties props) + { + String value = null; + + // Look for the comma + int comma = key.indexOf(','); + if (comma > -1) + { + // If we have a first part, try resolve it + if (comma > 0) + { + // Check the first part + String key1 = key.substring(0, comma); + if (props != null) + value = props.getProperty(key1); + else + value = System.getProperty(key1); + } + // Check the second part, if there is one and first lookup failed + if (value == null && comma < key.length() - 1) + { + String key2 = key.substring(comma + 1); + if (props != null) + value = props.getProperty(key2); + else + value = System.getProperty(key2); + } + } + // Return whatever we've found or null + return value; + } + + private interface SysProps + { + SysProps NON_PRIVILEDGED = new SysProps() + { + public String getProperty(final String name, final String defaultValue) + { + return System.getProperty(name, defaultValue); + } + }; + SysProps PRIVILEDGED = new SysProps() + { + @SuppressWarnings({"rawtypes", "unchecked"}) + public String getProperty(final String name, final String defaultValue) + { + PrivilegedAction action = new PrivilegedAction() + { + public Object run() + { + return System.getProperty(name, defaultValue); + } + }; + return (String) AccessController.doPrivileged(action); + } + }; + String getProperty(String name, String defaultValue); + } + + private static String getProperty(String name, String defaultValue) + { + String prop; + if( System.getSecurityManager() == null ) + prop = SysProps.NON_PRIVILEDGED.getProperty(name, defaultValue); + else + prop = SysProps.PRIVILEDGED.getProperty(name, defaultValue); + return prop; + } +} \ No newline at end of file Property changes on: common/trunk/src/main/java/org/jboss/ws/common/utils/StringPropertyReplacer.java ___________________________________________________________________ Added: svn:keywords + Rev Date Added: svn:eol-style + native