sjero.net Git - linphone/blob - p2pproxy/dependencies-src/jxse-src-2.5/api/src/sun/net/www/protocol/urn/Handler.java

   1 /*
   2  * Copyright (c) 2001-2007 Sun Microsystems, Inc.  All rights reserved.
   3  *
   4  *  The Sun Project JXTA(TM) Software License
   5  *
   6  *  Redistribution and use in source and binary forms, with or without
   7  *  modification, are permitted provided that the following conditions are met:
   8  *
   9  *  1. Redistributions of source code must retain the above copyright notice,
  10  *     this list of conditions and the following disclaimer.
  11  *
  12  *  2. Redistributions in binary form must reproduce the above copyright notice,
  13  *     this list of conditions and the following disclaimer in the documentation
  14  *     and/or other materials provided with the distribution.
  15  *
  16  *  3. The end-user documentation included with the redistribution, if any, must
  17  *     include the following acknowledgment: "This product includes software
  18  *     developed by Sun Microsystems, Inc. for JXTA(TM) technology."
  19  *     Alternately, this acknowledgment may appear in the software itself, if
  20  *     and wherever such third-party acknowledgments normally appear.
  21  *
  22  *  4. The names "Sun", "Sun Microsystems, Inc.", "JXTA" and "Project JXTA" must
  23  *     not be used to endorse or promote products derived from this software
  24  *     without prior written permission. For written permission, please contact
  25  *     Project JXTA at http://www.jxta.org.
  26  *
  27  *  5. Products derived from this software may not be called "JXTA", nor may
  28  *     "JXTA" appear in their name, without prior written permission of Sun.
  29  *
  30  *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
  31  *  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
  32  *  FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SUN
  33  *  MICROSYSTEMS OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  34  *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  35  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
  36  *  OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  37  *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  38  *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  39  *  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  40  *
  41  *  JXTA is a registered trademark of Sun Microsystems, Inc. in the United
  42  *  States and other countries.
  43  *
  44  *  Please see the license information page at :
  45  *  <http://www.jxta.org/project/www/license.html> for instructions on use of
  46  *  the license in source files.
  47  *
  48  *  ====================================================================
  49  *
  50  *  This software consists of voluntary contributions made by many individuals
  51  *  on behalf of Project JXTA. For more information on Project JXTA, please see
  52  *  http://www.jxta.org.
  53  *
  54  *  This license is based on the BSD license adopted by the Apache Foundation.
  55  */
  56
  57 package sun.net.www.protocol.urn;
  58
  59
  60 import java.net.URL;
  61 import java.net.URLConnection;
  62 import java.net.URLStreamHandler;
  63
  64 import java.io.IOException;
  65
  66
  67 /**
  68  * Handler for URN
  69  *
  70  * @deprecated Use the URI interfaces for JXTA IDs instead of the URLs.
  71  */
  72 @Deprecated
  73 public final class Handler extends URLStreamHandler {
  74
  75     public static Handler handler = new Handler();
  76
  77     /**
  78      * Creates new Handler
  79      **/
  80     public Handler() {}
  81
  82     /**
  83      *
  84      **/
  85     @Override
  86     public URLConnection openConnection(URL connect) throws
  87                 IOException {
  88         return null;
  89     }
  90
  91     /**
  92      *
  93      *  Private replacement for toHexString since we need the leading 0 digits.
  94      *  Returns a String containing byte value encoded as 2 hex characters.
  95      *
  96      *  @param  theByte a byte containing the value to be encoded.
  97      *  @return String containing byte value encoded as 2 hex characters.
  98      */
  99     private static String toHexDigits(byte theByte) {
 100         final char[] HEXDIGITS = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
 101         StringBuilder result = new StringBuilder(2);
 102
 103         result.append(HEXDIGITS[(theByte >>> 4) & 15]);
 104         result.append(HEXDIGITS[theByte & 15]);
 105
 106         return result.toString();
 107     }
 108
 109     /**
 110      *
 111      * 2.4 of RFC2141 says we have to encode these chars.
 112      *
 113      **/
 114     static final String needsEncoding = "%/?#" + "\\\"&<>[]^`{|}~";
 115
 116     /**
 117      *
 118      * The byte values of the chars we have to encode.
 119      *
 120      **/
 121     static final byte[] encodesTo = new byte[] {
 122         0x25, 0x2F, 0x3F, 0x23, 0x5c, 0x22, 0x26, 0x3C, 0x3E, 0x5B, 0x5D, 0x5E, 0x60, 0x7B, 0x7C, 0x7D, 0x7E
 123     };
 124
 125     /**
 126      *  Encode a string such that it is in a form acceptable for presentation
 127      *  as a URN. First the string is encoded as UTF8 so that any high byte
 128      *  unicode chars are ascii representable. Then any special characters in
 129      *  the string are escaped using the URN % syntax.
 130      *
 131      *  @param source   the string to encode
 132      *  @return String containing the URN acceptable presentation form.
 133      **/
 134     public static String encodeURN(String source) {
 135         String asISO8559_1 = null;
 136
 137         try {
 138             // first we get its bytes using UTF to encode its characters.
 139             byte[] asBytes = source.getBytes("UTF8");
 140
 141             // then read it back in as ISO-8859-1. This allows us to see the
 142             // bytes with no translation. This string will have chars in the
 143             // range 0-255 only.
 144             asISO8559_1 = new String(asBytes, "ISO-8859-1");
 145         } catch (java.io.UnsupportedEncodingException never) {
 146             // these 2 encodings are required by all java implementations
 147             // so this exception will never happen.
 148             ;
 149         }
 150
 151         StringBuilder result = new StringBuilder(asISO8559_1.length());
 152
 153         // now do the % encoding for all chars which need it.
 154         for (int eachChar = 0; eachChar < asISO8559_1.length(); eachChar++) {
 155             char aChar = asISO8559_1.charAt(eachChar);
 156
 157             // null char is bad
 158             if (0 == aChar) {
 159                 throw new IllegalArgumentException("URN string cannot contain null char");
 160             }
 161
 162             // in the excluded range
 163             if ((aChar <= 32) || (aChar >= 127)) {
 164                 result.append('%');
 165                 result.append(toHexDigits((byte) aChar));
 166             } else {
 167                 int inSpecials = needsEncoding.indexOf(aChar);
 168
 169                 // one of the special chars which must be encoded?
 170                 if (-1 != inSpecials) {
 171                     result.append('%');
 172                     result.append(toHexDigits(encodesTo[inSpecials]));
 173                 } else {
 174                     result.append(aChar);
 175                 } // needed no encoding
 176             }
 177         }
 178
 179         return result.toString();
 180     }
 181
 182     /**
 183      *  Converts a string which was previously conveted to URN format back into
 184      *  the unencoded format.
 185      *
 186      *  @param source   the string to decode
 187      *  @return String containing the decoded form of the URN.
 188      **/
 189     public static String decodeURN(String source) {
 190         StringBuilder result = new StringBuilder(source.length());
 191
 192         // remove the % encoding for all chars which needed it.
 193         for (int eachChar = 0; eachChar < source.length(); eachChar++) {
 194             char aChar = source.charAt(eachChar);
 195
 196             if ('%' != aChar) {
 197                 result.append(aChar);
 198             } else {
 199                 String twoChars = source.substring(eachChar + 1, eachChar + 3);
 200
 201                 result.append((char) Integer.parseInt(twoChars, 16));
 202                 eachChar += 2;
 203             }
 204         }
 205         String fromUTF8 = null;
 206
 207         try {
 208             // first we get its bytes using ISO-8859-1 to encode its characters.
 209             // ISO-8859-1 does no mapping. Each byte is the same as the character.
 210             byte[] asBytes = result.toString().getBytes("ISO-8859-1");
 211
 212             // then read it back in as UTF8. This gets us any high byte chars back
 213             fromUTF8 = new String(asBytes, "UTF8");
 214         } catch (java.io.UnsupportedEncodingException never) {
 215             // these 2 encodings are required so this exception will never happen
 216             ;
 217         }
 218         return fromUTF8;
 219     }
 220 }