| /* |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code 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 General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| /* |
| /* |
| ******************************************************************************* |
| * Copyright (C) 2003-2004, International Business Machines Corporation and * |
| * others. All Rights Reserved. * |
| ******************************************************************************* |
| */ |
| // |
| // CHANGELOG |
| // 2005-05-19 Edward Wang |
| // - copy this file from icu4jsrc_3_2/src/com/ibm/icu/text/StringPrep.java |
| // - move from package com.ibm.icu.text to package sun.net.idn |
| // - use ParseException instead of StringPrepParseException |
| // - change 'Normalizer.getUnicodeVersion()' to 'NormalizerImpl.getUnicodeVersion()' |
| // - remove all @deprecated tag to make compiler happy |
| // 2007-08-14 Martin Buchholz |
| // - remove redundant casts |
| // |
| package sun.net.idn; |
| |
| import java.io.BufferedInputStream; |
| import java.io.ByteArrayInputStream; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.text.ParseException; |
| |
| import sun.text.Normalizer; |
| import sun.text.normalizer.CharTrie; |
| import sun.text.normalizer.Trie; |
| import sun.text.normalizer.VersionInfo; |
| import sun.text.normalizer.UCharacter; |
| import sun.text.normalizer.UCharacterIterator; |
| import sun.text.normalizer.UTF16; |
| import sun.net.idn.UCharacterDirection; |
| import sun.net.idn.StringPrepDataReader; |
| |
| /** |
| * StringPrep API implements the StingPrep framework as described by |
| * <a href="http://www.ietf.org/rfc/rfc3454.txt">RFC 3454</a>. |
| * StringPrep prepares Unicode strings for use in network protocols. |
| * Profiles of StingPrep are set of rules and data according to which the |
| * Unicode Strings are prepared. Each profiles contains tables which describe |
| * how a code point should be treated. The tables are broadly classied into |
| * <ul> |
| * <li> Unassigned Table: Contains code points that are unassigned |
| * in the Unicode Version supported by StringPrep. Currently |
| * RFC 3454 supports Unicode 3.2. </li> |
| * <li> Prohibited Table: Contains code points that are prohibted from |
| * the output of the StringPrep processing function. </li> |
| * <li> Mapping Table: Contains code ponts that are deleted from the output or case mapped. </li> |
| * </ul> |
| * |
| * The procedure for preparing Unicode strings: |
| * <ol> |
| * <li> Map: For each character in the input, check if it has a mapping |
| * and, if so, replace it with its mapping. </li> |
| * <li> Normalize: Possibly normalize the result of step 1 using Unicode |
| * normalization. </li> |
| * <li> Prohibit: Check for any characters that are not allowed in the |
| * output. If any are found, return an error.</li> |
| * <li> Check bidi: Possibly check for right-to-left characters, and if |
| * any are found, make sure that the whole string satisfies the |
| * requirements for bidirectional strings. If the string does not |
| * satisfy the requirements for bidirectional strings, return an |
| * error. </li> |
| * </ol> |
| * @author Ram Viswanadha |
| * @draft ICU 2.8 |
| */ |
| public final class StringPrep { |
| /** |
| * Option to prohibit processing of unassigned code points in the input |
| * |
| * @see #prepare |
| * @draft ICU 2.8 |
| */ |
| public static final int DEFAULT = 0x0000; |
| |
| /** |
| * Option to allow processing of unassigned code points in the input |
| * |
| * @see #prepare |
| * @draft ICU 2.8 |
| */ |
| public static final int ALLOW_UNASSIGNED = 0x0001; |
| |
| private static final int UNASSIGNED = 0x0000; |
| private static final int MAP = 0x0001; |
| private static final int PROHIBITED = 0x0002; |
| private static final int DELETE = 0x0003; |
| private static final int TYPE_LIMIT = 0x0004; |
| |
| private static final int NORMALIZATION_ON = 0x0001; |
| private static final int CHECK_BIDI_ON = 0x0002; |
| |
| private static final int TYPE_THRESHOLD = 0xFFF0; |
| private static final int MAX_INDEX_VALUE = 0x3FBF; /*16139*/ |
| private static final int MAX_INDEX_TOP_LENGTH = 0x0003; |
| |
| /* indexes[] value names */ |
| private static final int INDEX_TRIE_SIZE = 0; /* number of bytes in normalization trie */ |
| private static final int INDEX_MAPPING_DATA_SIZE = 1; /* The array that contains the mapping */ |
| private static final int NORM_CORRECTNS_LAST_UNI_VERSION = 2; /* The index of Unicode version of last entry in NormalizationCorrections.txt */ |
| private static final int ONE_UCHAR_MAPPING_INDEX_START = 3; /* The starting index of 1 UChar mapping index in the mapping data array */ |
| private static final int TWO_UCHARS_MAPPING_INDEX_START = 4; /* The starting index of 2 UChars mapping index in the mapping data array */ |
| private static final int THREE_UCHARS_MAPPING_INDEX_START = 5; |
| private static final int FOUR_UCHARS_MAPPING_INDEX_START = 6; |
| private static final int OPTIONS = 7; /* Bit set of options to turn on in the profile */ |
| private static final int INDEX_TOP = 16; /* changing this requires a new formatVersion */ |
| |
| |
| /** |
| * Default buffer size of datafile |
| */ |
| private static final int DATA_BUFFER_SIZE = 25000; |
| |
| /* Wrappers for Trie implementations */ |
| private static final class StringPrepTrieImpl implements Trie.DataManipulate{ |
| private CharTrie sprepTrie = null; |
| /** |
| * Called by com.ibm.icu.util.Trie to extract from a lead surrogate's |
| * data the index array offset of the indexes for that lead surrogate. |
| * @param property data value for a surrogate from the trie, including |
| * the folding offset |
| * @return data offset or 0 if there is no data for the lead surrogate |
| */ |
| public int getFoldingOffset(int value){ |
| return value; |
| } |
| } |
| |
| // CharTrie implementation for reading the trie data |
| private StringPrepTrieImpl sprepTrieImpl; |
| // Indexes read from the data file |
| private int[] indexes; |
| // mapping data read from the data file |
| private char[] mappingData; |
| // format version of the data file |
| private byte[] formatVersion; |
| // the version of Unicode supported by the data file |
| private VersionInfo sprepUniVer; |
| // the Unicode version of last entry in the |
| // NormalizationCorrections.txt file if normalization |
| // is turned on |
| private VersionInfo normCorrVer; |
| // Option to turn on Normalization |
| private boolean doNFKC; |
| // Option to turn on checking for BiDi rules |
| private boolean checkBiDi; |
| |
| |
| private char getCodePointValue(int ch){ |
| return sprepTrieImpl.sprepTrie.getCodePointValue(ch); |
| } |
| |
| private static VersionInfo getVersionInfo(int comp){ |
| int micro = comp & 0xFF; |
| int milli =(comp >> 8) & 0xFF; |
| int minor =(comp >> 16) & 0xFF; |
| int major =(comp >> 24) & 0xFF; |
| return VersionInfo.getInstance(major,minor,milli,micro); |
| } |
| private static VersionInfo getVersionInfo(byte[] version){ |
| if(version.length != 4){ |
| return null; |
| } |
| return VersionInfo.getInstance((int)version[0],(int) version[1],(int) version[2],(int) version[3]); |
| } |
| /** |
| * Creates an StringPrep object after reading the input stream. |
| * The object does not hold a reference to the input steam, so the stream can be |
| * closed after the method returns. |
| * |
| * @param inputStream The stream for reading the StringPrep profile binarySun |
| * @throws IOException |
| * @draft ICU 2.8 |
| */ |
| public StringPrep(InputStream inputStream) throws IOException{ |
| |
| BufferedInputStream b = new BufferedInputStream(inputStream,DATA_BUFFER_SIZE); |
| |
| StringPrepDataReader reader = new StringPrepDataReader(b); |
| |
| // read the indexes |
| indexes = reader.readIndexes(INDEX_TOP); |
| |
| byte[] sprepBytes = new byte[indexes[INDEX_TRIE_SIZE]]; |
| |
| |
| //indexes[INDEX_MAPPING_DATA_SIZE] store the size of mappingData in bytes |
| mappingData = new char[indexes[INDEX_MAPPING_DATA_SIZE]/2]; |
| // load the rest of the data data and initialize the data members |
| reader.read(sprepBytes,mappingData); |
| |
| sprepTrieImpl = new StringPrepTrieImpl(); |
| sprepTrieImpl.sprepTrie = new CharTrie( new ByteArrayInputStream(sprepBytes),sprepTrieImpl ); |
| |
| // get the data format version |
| formatVersion = reader.getDataFormatVersion(); |
| |
| // get the options |
| doNFKC = ((indexes[OPTIONS] & NORMALIZATION_ON) > 0); |
| checkBiDi = ((indexes[OPTIONS] & CHECK_BIDI_ON) > 0); |
| sprepUniVer = getVersionInfo(reader.getUnicodeVersion()); |
| normCorrVer = getVersionInfo(indexes[NORM_CORRECTNS_LAST_UNI_VERSION]); |
| VersionInfo normUniVer = UCharacter.getUnicodeVersion(); |
| if(normUniVer.compareTo(sprepUniVer) < 0 && /* the Unicode version of SPREP file must be less than the Unicode Vesion of the normalization data */ |
| normUniVer.compareTo(normCorrVer) < 0 && /* the Unicode version of the NormalizationCorrections.txt file should be less than the Unicode Vesion of the normalization data */ |
| ((indexes[OPTIONS] & NORMALIZATION_ON) > 0) /* normalization turned on*/ |
| ){ |
| throw new IOException("Normalization Correction version not supported"); |
| } |
| b.close(); |
| } |
| |
| private static final class Values{ |
| boolean isIndex; |
| int value; |
| int type; |
| public void reset(){ |
| isIndex = false; |
| value = 0; |
| type = -1; |
| } |
| } |
| |
| private static final void getValues(char trieWord,Values values){ |
| values.reset(); |
| if(trieWord == 0){ |
| /* |
| * Initial value stored in the mapping table |
| * just return TYPE_LIMIT .. so that |
| * the source codepoint is copied to the destination |
| */ |
| values.type = TYPE_LIMIT; |
| }else if(trieWord >= TYPE_THRESHOLD){ |
| values.type = (trieWord - TYPE_THRESHOLD); |
| }else{ |
| /* get the type */ |
| values.type = MAP; |
| /* ascertain if the value is index or delta */ |
| if((trieWord & 0x02)>0){ |
| values.isIndex = true; |
| values.value = trieWord >> 2; //mask off the lower 2 bits and shift |
| |
| }else{ |
| values.isIndex = false; |
| values.value = (trieWord<<16)>>16; |
| values.value = (values.value >> 2); |
| |
| } |
| |
| if((trieWord>>2) == MAX_INDEX_VALUE){ |
| values.type = DELETE; |
| values.isIndex = false; |
| values.value = 0; |
| } |
| } |
| } |
| |
| |
| |
| private StringBuffer map( UCharacterIterator iter, int options) |
| throws ParseException { |
| |
| Values val = new Values(); |
| char result = 0; |
| int ch = UCharacterIterator.DONE; |
| StringBuffer dest = new StringBuffer(); |
| boolean allowUnassigned = ((options & ALLOW_UNASSIGNED)>0); |
| |
| while((ch=iter.nextCodePoint())!= UCharacterIterator.DONE){ |
| |
| result = getCodePointValue(ch); |
| getValues(result,val); |
| |
| // check if the source codepoint is unassigned |
| if(val.type == UNASSIGNED && allowUnassigned == false){ |
| throw new ParseException("An unassigned code point was found in the input " + |
| iter.getText(), iter.getIndex()); |
| }else if((val.type == MAP)){ |
| int index, length; |
| |
| if(val.isIndex){ |
| index = val.value; |
| if(index >= indexes[ONE_UCHAR_MAPPING_INDEX_START] && |
| index < indexes[TWO_UCHARS_MAPPING_INDEX_START]){ |
| length = 1; |
| }else if(index >= indexes[TWO_UCHARS_MAPPING_INDEX_START] && |
| index < indexes[THREE_UCHARS_MAPPING_INDEX_START]){ |
| length = 2; |
| }else if(index >= indexes[THREE_UCHARS_MAPPING_INDEX_START] && |
| index < indexes[FOUR_UCHARS_MAPPING_INDEX_START]){ |
| length = 3; |
| }else{ |
| length = mappingData[index++]; |
| } |
| /* copy mapping to destination */ |
| dest.append(mappingData,index,length); |
| continue; |
| |
| }else{ |
| ch -= val.value; |
| } |
| }else if(val.type == DELETE){ |
| // just consume the codepoint and contine |
| continue; |
| } |
| //copy the source into destination |
| UTF16.append(dest,ch); |
| } |
| |
| return dest; |
| } |
| |
| |
| private StringBuffer normalize(StringBuffer src){ |
| /* |
| * Option UNORM_BEFORE_PRI_29: |
| * |
| * IDNA as interpreted by IETF members (see unicode mailing list 2004H1) |
| * requires strict adherence to Unicode 3.2 normalization, |
| * including buggy composition from before fixing Public Review Issue #29. |
| * Note that this results in some valid but nonsensical text to be |
| * either corrupted or rejected, depending on the text. |
| * See http://www.unicode.org/review/resolved-pri.html#pri29 |
| * See unorm.cpp and cnormtst.c |
| */ |
| return new StringBuffer( |
| Normalizer.normalize( |
| src.toString(), |
| java.text.Normalizer.Form.NFKC, |
| Normalizer.UNICODE_3_2)); |
| } |
| /* |
| boolean isLabelSeparator(int ch){ |
| int result = getCodePointValue(ch); |
| if( (result & 0x07) == LABEL_SEPARATOR){ |
| return true; |
| } |
| return false; |
| } |
| */ |
| /* |
| 1) Map -- For each character in the input, check if it has a mapping |
| and, if so, replace it with its mapping. |
| |
| 2) Normalize -- Possibly normalize the result of step 1 using Unicode |
| normalization. |
| |
| 3) Prohibit -- Check for any characters that are not allowed in the |
| output. If any are found, return an error. |
| |
| 4) Check bidi -- Possibly check for right-to-left characters, and if |
| any are found, make sure that the whole string satisfies the |
| requirements for bidirectional strings. If the string does not |
| satisfy the requirements for bidirectional strings, return an |
| error. |
| [Unicode3.2] defines several bidirectional categories; each character |
| has one bidirectional category assigned to it. For the purposes of |
| the requirements below, an "RandALCat character" is a character that |
| has Unicode bidirectional categories "R" or "AL"; an "LCat character" |
| is a character that has Unicode bidirectional category "L". Note |
| |
| |
| that there are many characters which fall in neither of the above |
| definitions; Latin digits (<U+0030> through <U+0039>) are examples of |
| this because they have bidirectional category "EN". |
| |
| In any profile that specifies bidirectional character handling, all |
| three of the following requirements MUST be met: |
| |
| 1) The characters in section 5.8 MUST be prohibited. |
| |
| 2) If a string contains any RandALCat character, the string MUST NOT |
| contain any LCat character. |
| |
| 3) If a string contains any RandALCat character, a RandALCat |
| character MUST be the first character of the string, and a |
| RandALCat character MUST be the last character of the string. |
| */ |
| /** |
| * Prepare the input buffer for use in applications with the given profile. This operation maps, normalizes(NFKC), |
| * checks for prohited and BiDi characters in the order defined by RFC 3454 |
| * depending on the options specified in the profile. |
| * |
| * @param src A UCharacterIterator object containing the source string |
| * @param options A bit set of options: |
| * |
| * - StringPrep.NONE Prohibit processing of unassigned code points in the input |
| * |
| * - StringPrep.ALLOW_UNASSIGNED Treat the unassigned code points are in the input |
| * as normal Unicode code points. |
| * |
| * @return StringBuffer A StringBuffer containing the output |
| * @throws ParseException |
| * @draft ICU 2.8 |
| */ |
| public StringBuffer prepare(UCharacterIterator src, int options) |
| throws ParseException{ |
| |
| // map |
| StringBuffer mapOut = map(src,options); |
| StringBuffer normOut = mapOut;// initialize |
| |
| if(doNFKC){ |
| // normalize |
| normOut = normalize(mapOut); |
| } |
| |
| int ch; |
| char result; |
| UCharacterIterator iter = UCharacterIterator.getInstance(normOut); |
| Values val = new Values(); |
| int direction=UCharacterDirection.CHAR_DIRECTION_COUNT, |
| firstCharDir=UCharacterDirection.CHAR_DIRECTION_COUNT; |
| int rtlPos=-1, ltrPos=-1; |
| boolean rightToLeft=false, leftToRight=false; |
| |
| while((ch=iter.nextCodePoint())!= UCharacterIterator.DONE){ |
| result = getCodePointValue(ch); |
| getValues(result,val); |
| |
| if(val.type == PROHIBITED ){ |
| throw new ParseException("A prohibited code point was found in the input" + |
| iter.getText(), val.value); |
| } |
| |
| direction = UCharacter.getDirection(ch); |
| if(firstCharDir == UCharacterDirection.CHAR_DIRECTION_COUNT){ |
| firstCharDir = direction; |
| } |
| if(direction == UCharacterDirection.LEFT_TO_RIGHT){ |
| leftToRight = true; |
| ltrPos = iter.getIndex()-1; |
| } |
| if(direction == UCharacterDirection.RIGHT_TO_LEFT || direction == UCharacterDirection.RIGHT_TO_LEFT_ARABIC){ |
| rightToLeft = true; |
| rtlPos = iter.getIndex()-1; |
| } |
| } |
| if(checkBiDi == true){ |
| // satisfy 2 |
| if( leftToRight == true && rightToLeft == true){ |
| throw new ParseException("The input does not conform to the rules for BiDi code points." + |
| iter.getText(), |
| (rtlPos>ltrPos) ? rtlPos : ltrPos); |
| } |
| |
| //satisfy 3 |
| if( rightToLeft == true && |
| !((firstCharDir == UCharacterDirection.RIGHT_TO_LEFT || firstCharDir == UCharacterDirection.RIGHT_TO_LEFT_ARABIC) && |
| (direction == UCharacterDirection.RIGHT_TO_LEFT || direction == UCharacterDirection.RIGHT_TO_LEFT_ARABIC)) |
| ){ |
| throw new ParseException("The input does not conform to the rules for BiDi code points." + |
| iter.getText(), |
| (rtlPos>ltrPos) ? rtlPos : ltrPos); |
| } |
| } |
| return normOut; |
| |
| } |
| } |