| /* |
| ********************************************************************** |
| * Copyright (C) 2008-2011, International Business Machines |
| * Corporation and others. All Rights Reserved. |
| ********************************************************************** |
| */ |
| |
| #include "unicode/utypes.h" |
| #include "unicode/uspoof.h" |
| #include "unicode/unorm.h" |
| #include "unicode/uchar.h" |
| #include "unicode/uniset.h" |
| #include "unicode/utf16.h" |
| #include "utrie2.h" |
| #include "cmemory.h" |
| #include "cstring.h" |
| #include "udatamem.h" |
| #include "umutex.h" |
| #include "udataswp.h" |
| #include "uassert.h" |
| #include "uspoof_impl.h" |
| |
| #if !UCONFIG_NO_NORMALIZATION |
| |
| |
| U_NAMESPACE_BEGIN |
| |
| UOBJECT_DEFINE_RTTI_IMPLEMENTATION(SpoofImpl) |
| |
| SpoofImpl::SpoofImpl(SpoofData *data, UErrorCode &status) : |
| fMagic(0), fSpoofData(NULL), fAllowedCharsSet(NULL) , fAllowedLocales(uprv_strdup("")) { |
| if (U_FAILURE(status)) { |
| return; |
| } |
| fMagic = USPOOF_MAGIC; |
| fSpoofData = data; |
| fChecks = USPOOF_ALL_CHECKS; |
| UnicodeSet *allowedCharsSet = new UnicodeSet(0, 0x10ffff); |
| if (allowedCharsSet == NULL || fAllowedLocales == NULL) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| return; |
| } |
| allowedCharsSet->freeze(); |
| fAllowedCharsSet = allowedCharsSet; |
| } |
| |
| |
| SpoofImpl::SpoofImpl() { |
| fMagic = USPOOF_MAGIC; |
| fSpoofData = NULL; |
| fChecks = USPOOF_ALL_CHECKS; |
| UnicodeSet *allowedCharsSet = new UnicodeSet(0, 0x10ffff); |
| allowedCharsSet->freeze(); |
| fAllowedCharsSet = allowedCharsSet; |
| fAllowedLocales = uprv_strdup(""); |
| } |
| |
| |
| // Copy Constructor, used by the user level clone() function. |
| SpoofImpl::SpoofImpl(const SpoofImpl &src, UErrorCode &status) : |
| fMagic(0), fSpoofData(NULL), fAllowedCharsSet(NULL) { |
| if (U_FAILURE(status)) { |
| return; |
| } |
| fMagic = src.fMagic; |
| fChecks = src.fChecks; |
| if (src.fSpoofData != NULL) { |
| fSpoofData = src.fSpoofData->addReference(); |
| } |
| fAllowedCharsSet = static_cast<const UnicodeSet *>(src.fAllowedCharsSet->clone()); |
| if (fAllowedCharsSet == NULL) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| } |
| fAllowedLocales = uprv_strdup(src.fAllowedLocales); |
| } |
| |
| SpoofImpl::~SpoofImpl() { |
| fMagic = 0; // head off application errors by preventing use of |
| // of deleted objects. |
| if (fSpoofData != NULL) { |
| fSpoofData->removeReference(); // Will delete if refCount goes to zero. |
| } |
| delete fAllowedCharsSet; |
| uprv_free((void *)fAllowedLocales); |
| } |
| |
| // |
| // Incoming parameter check on Status and the SpoofChecker object |
| // received from the C API. |
| // |
| const SpoofImpl *SpoofImpl::validateThis(const USpoofChecker *sc, UErrorCode &status) { |
| if (U_FAILURE(status)) { |
| return NULL; |
| } |
| if (sc == NULL) { |
| status = U_ILLEGAL_ARGUMENT_ERROR; |
| return NULL; |
| }; |
| SpoofImpl *This = (SpoofImpl *)sc; |
| if (This->fMagic != USPOOF_MAGIC || |
| This->fSpoofData == NULL) { |
| status = U_INVALID_FORMAT_ERROR; |
| return NULL; |
| } |
| if (!SpoofData::validateDataVersion(This->fSpoofData->fRawData, status)) { |
| return NULL; |
| } |
| return This; |
| } |
| |
| SpoofImpl *SpoofImpl::validateThis(USpoofChecker *sc, UErrorCode &status) { |
| return const_cast<SpoofImpl *> |
| (SpoofImpl::validateThis(const_cast<const USpoofChecker *>(sc), status)); |
| } |
| |
| |
| |
| //-------------------------------------------------------------------------------------- |
| // |
| // confusableLookup() This is the heart of the confusable skeleton generation |
| // implementation. |
| // |
| // Given a source character, produce the corresponding |
| // replacement character(s) |
| // |
| //--------------------------------------------------------------------------------------- |
| int32_t SpoofImpl::confusableLookup(UChar32 inChar, int32_t tableMask, UChar *destBuf) const { |
| |
| // Binary search the spoof data key table for the inChar |
| int32_t *low = fSpoofData->fCFUKeys; |
| int32_t *mid = NULL; |
| int32_t *limit = low + fSpoofData->fRawData->fCFUKeysSize; |
| UChar32 midc; |
| do { |
| int32_t delta = ((int32_t)(limit-low))/2; |
| mid = low + delta; |
| midc = *mid & 0x1fffff; |
| if (inChar == midc) { |
| goto foundChar; |
| } else if (inChar < midc) { |
| limit = mid; |
| } else { |
| low = mid; |
| } |
| } while (low < limit-1); |
| mid = low; |
| midc = *mid & 0x1fffff; |
| if (inChar != midc) { |
| // Char not found. It maps to itself. |
| int i = 0; |
| U16_APPEND_UNSAFE(destBuf, i, inChar) |
| return i; |
| } |
| foundChar: |
| int32_t keyFlags = *mid & 0xff000000; |
| if ((keyFlags & tableMask) == 0) { |
| // We found the right key char, but the entry doesn't pertain to the |
| // table we need. See if there is an adjacent key that does |
| if (keyFlags & USPOOF_KEY_MULTIPLE_VALUES) { |
| int32_t *altMid; |
| for (altMid = mid-1; (*altMid&0x00ffffff) == inChar; altMid--) { |
| keyFlags = *altMid & 0xff000000; |
| if (keyFlags & tableMask) { |
| mid = altMid; |
| goto foundKey; |
| } |
| } |
| for (altMid = mid+1; (*altMid&0x00ffffff) == inChar; altMid++) { |
| keyFlags = *altMid & 0xff000000; |
| if (keyFlags & tableMask) { |
| mid = altMid; |
| goto foundKey; |
| } |
| } |
| } |
| // No key entry for this char & table. |
| // The input char maps to itself. |
| int i = 0; |
| U16_APPEND_UNSAFE(destBuf, i, inChar) |
| return i; |
| } |
| |
| foundKey: |
| int32_t stringLen = USPOOF_KEY_LENGTH_FIELD(keyFlags) + 1; |
| int32_t keyTableIndex = (int32_t)(mid - fSpoofData->fCFUKeys); |
| |
| // Value is either a UChar (for strings of length 1) or |
| // an index into the string table (for longer strings) |
| uint16_t value = fSpoofData->fCFUValues[keyTableIndex]; |
| if (stringLen == 1) { |
| destBuf[0] = value; |
| return 1; |
| } |
| |
| // String length of 4 from the above lookup is used for all strings of length >= 4. |
| // For these, get the real length from the string lengths table, |
| // which maps string table indexes to lengths. |
| // All strings of the same length are stored contiguously in the string table. |
| // 'value' from the lookup above is the starting index for the desired string. |
| |
| int32_t ix; |
| if (stringLen == 4) { |
| int32_t stringLengthsLimit = fSpoofData->fRawData->fCFUStringLengthsSize; |
| for (ix = 0; ix < stringLengthsLimit; ix++) { |
| if (fSpoofData->fCFUStringLengths[ix].fLastString >= value) { |
| stringLen = fSpoofData->fCFUStringLengths[ix].fStrLength; |
| break; |
| } |
| } |
| U_ASSERT(ix < stringLengthsLimit); |
| } |
| |
| U_ASSERT(value + stringLen <= fSpoofData->fRawData->fCFUStringTableLen); |
| UChar *src = &fSpoofData->fCFUStrings[value]; |
| for (ix=0; ix<stringLen; ix++) { |
| destBuf[ix] = src[ix]; |
| } |
| return stringLen; |
| } |
| |
| |
| //--------------------------------------------------------------------------------------- |
| // |
| // wholeScriptCheck() |
| // |
| // Input text is already normalized to NFD |
| // Return the set of scripts, each of which can represent something that is |
| // confusable with the input text. The script of the input text |
| // is included; input consisting of characters from a single script will |
| // always produce a result consisting of a set containing that script. |
| // |
| //--------------------------------------------------------------------------------------- |
| void SpoofImpl::wholeScriptCheck( |
| const UChar *text, int32_t length, ScriptSet *result, UErrorCode &status) const { |
| |
| int32_t inputIdx = 0; |
| UChar32 c; |
| |
| UTrie2 *table = |
| (fChecks & USPOOF_ANY_CASE) ? fSpoofData->fAnyCaseTrie : fSpoofData->fLowerCaseTrie; |
| result->setAll(); |
| while (inputIdx < length) { |
| U16_NEXT(text, inputIdx, length, c); |
| uint32_t index = utrie2_get32(table, c); |
| if (index == 0) { |
| // No confusables in another script for this char. |
| // TODO: we should change the data to have sets with just the single script |
| // bit for the script of this char. Gets rid of this special case. |
| // Until then, grab the script from the char and intersect it with the set. |
| UScriptCode cpScript = uscript_getScript(c, &status); |
| U_ASSERT(cpScript > USCRIPT_INHERITED); |
| result->intersect(cpScript); |
| } else if (index == 1) { |
| // Script == Common or Inherited. Nothing to do. |
| } else { |
| result->intersect(fSpoofData->fScriptSets[index]); |
| } |
| } |
| } |
| |
| |
| void SpoofImpl::setAllowedLocales(const char *localesList, UErrorCode &status) { |
| UnicodeSet allowedChars; |
| UnicodeSet *tmpSet = NULL; |
| const char *locStart = localesList; |
| const char *locEnd = NULL; |
| const char *localesListEnd = localesList + uprv_strlen(localesList); |
| int32_t localeListCount = 0; // Number of locales provided by caller. |
| |
| // Loop runs once per locale from the localesList, a comma separated list of locales. |
| do { |
| locEnd = uprv_strchr(locStart, ','); |
| if (locEnd == NULL) { |
| locEnd = localesListEnd; |
| } |
| while (*locStart == ' ') { |
| locStart++; |
| } |
| const char *trimmedEnd = locEnd-1; |
| while (trimmedEnd > locStart && *trimmedEnd == ' ') { |
| trimmedEnd--; |
| } |
| if (trimmedEnd <= locStart) { |
| break; |
| } |
| const char *locale = uprv_strndup(locStart, (int32_t)(trimmedEnd + 1 - locStart)); |
| localeListCount++; |
| |
| // We have one locale from the locales list. |
| // Add the script chars for this locale to the accumulating set of allowed chars. |
| // If the locale is no good, we will be notified back via status. |
| addScriptChars(locale, &allowedChars, status); |
| uprv_free((void *)locale); |
| if (U_FAILURE(status)) { |
| break; |
| } |
| locStart = locEnd + 1; |
| } while (locStart < localesListEnd); |
| |
| // If our caller provided an empty list of locales, we disable the allowed characters checking |
| if (localeListCount == 0) { |
| uprv_free((void *)fAllowedLocales); |
| fAllowedLocales = uprv_strdup(""); |
| tmpSet = new UnicodeSet(0, 0x10ffff); |
| if (fAllowedLocales == NULL || tmpSet == NULL) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| return; |
| } |
| tmpSet->freeze(); |
| delete fAllowedCharsSet; |
| fAllowedCharsSet = tmpSet; |
| fChecks &= ~USPOOF_CHAR_LIMIT; |
| return; |
| } |
| |
| |
| // Add all common and inherited characters to the set of allowed chars. |
| UnicodeSet tempSet; |
| tempSet.applyIntPropertyValue(UCHAR_SCRIPT, USCRIPT_COMMON, status); |
| allowedChars.addAll(tempSet); |
| tempSet.applyIntPropertyValue(UCHAR_SCRIPT, USCRIPT_INHERITED, status); |
| allowedChars.addAll(tempSet); |
| |
| // If anything went wrong, we bail out without changing |
| // the state of the spoof checker. |
| if (U_FAILURE(status)) { |
| return; |
| } |
| |
| // Store the updated spoof checker state. |
| tmpSet = static_cast<UnicodeSet *>(allowedChars.clone()); |
| const char *tmpLocalesList = uprv_strdup(localesList); |
| if (tmpSet == NULL || tmpLocalesList == NULL) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| return; |
| } |
| uprv_free((void *)fAllowedLocales); |
| fAllowedLocales = tmpLocalesList; |
| tmpSet->freeze(); |
| delete fAllowedCharsSet; |
| fAllowedCharsSet = tmpSet; |
| fChecks |= USPOOF_CHAR_LIMIT; |
| } |
| |
| |
| const char * SpoofImpl::getAllowedLocales(UErrorCode &/*status*/) { |
| return fAllowedLocales; |
| } |
| |
| |
| // Given a locale (a language), add all the characters from all of the scripts used with that language |
| // to the allowedChars UnicodeSet |
| |
| void SpoofImpl::addScriptChars(const char *locale, UnicodeSet *allowedChars, UErrorCode &status) { |
| UScriptCode scripts[30]; |
| |
| int32_t numScripts = uscript_getCode(locale, scripts, sizeof(scripts)/sizeof(UScriptCode), &status); |
| if (U_FAILURE(status)) { |
| return; |
| } |
| if (status == U_USING_DEFAULT_WARNING) { |
| status = U_ILLEGAL_ARGUMENT_ERROR; |
| return; |
| } |
| UnicodeSet tmpSet; |
| int32_t i; |
| for (i=0; i<numScripts; i++) { |
| tmpSet.applyIntPropertyValue(UCHAR_SCRIPT, scripts[i], status); |
| allowedChars->addAll(tmpSet); |
| } |
| } |
| |
| |
| int32_t SpoofImpl::scriptScan |
| (const UChar *text, int32_t length, int32_t &pos, UErrorCode &status) const { |
| if (U_FAILURE(status)) { |
| return 0; |
| } |
| int32_t inputIdx = 0; |
| UChar32 c; |
| int32_t scriptCount = 0; |
| UScriptCode lastScript = USCRIPT_INVALID_CODE; |
| UScriptCode sc = USCRIPT_INVALID_CODE; |
| while ((inputIdx < length || length == -1) && scriptCount < 2) { |
| U16_NEXT(text, inputIdx, length, c); |
| if (c == 0 && length == -1) { |
| break; |
| } |
| sc = uscript_getScript(c, &status); |
| if (sc == USCRIPT_COMMON || sc == USCRIPT_INHERITED || sc == USCRIPT_UNKNOWN) { |
| continue; |
| } |
| |
| // Temporary fix: fold Japanese Hiragana and Katakana into Han. |
| // Names are allowed to mix these scripts. |
| // A more general solution will follow later for characters that are |
| // used with multiple scripts. |
| |
| if (sc == USCRIPT_HIRAGANA || sc == USCRIPT_KATAKANA || sc == USCRIPT_HANGUL) { |
| sc = USCRIPT_HAN; |
| } |
| |
| if (sc != lastScript) { |
| scriptCount++; |
| lastScript = sc; |
| } |
| } |
| if (scriptCount == 2) { |
| pos = inputIdx; |
| } |
| return scriptCount; |
| } |
| |
| |
| // Convert a text format hex number. Utility function used by builder code. Static. |
| // Input: UChar *string text. Output: a UChar32 |
| // Input has been pre-checked, and will have no non-hex chars. |
| // The number must fall in the code point range of 0..0x10ffff |
| // Static Function. |
| UChar32 SpoofImpl::ScanHex(const UChar *s, int32_t start, int32_t limit, UErrorCode &status) { |
| if (U_FAILURE(status)) { |
| return 0; |
| } |
| U_ASSERT(limit-start > 0); |
| uint32_t val = 0; |
| int i; |
| for (i=start; i<limit; i++) { |
| int digitVal = s[i] - 0x30; |
| if (digitVal>9) { |
| digitVal = 0xa + (s[i] - 0x41); // Upper Case 'A' |
| } |
| if (digitVal>15) { |
| digitVal = 0xa + (s[i] - 0x61); // Lower Case 'a' |
| } |
| U_ASSERT(digitVal <= 0xf); |
| val <<= 4; |
| val += digitVal; |
| } |
| if (val > 0x10ffff) { |
| status = U_PARSE_ERROR; |
| val = 0; |
| } |
| return (UChar32)val; |
| } |
| |
| |
| |
| //---------------------------------------------------------------------------------------------- |
| // |
| // class SpoofData Implementation |
| // |
| //---------------------------------------------------------------------------------------------- |
| |
| |
| UBool SpoofData::validateDataVersion(const SpoofDataHeader *rawData, UErrorCode &status) { |
| if (U_FAILURE(status) || |
| rawData == NULL || |
| rawData->fMagic != USPOOF_MAGIC || |
| rawData->fFormatVersion[0] > 1 || |
| rawData->fFormatVersion[1] > 0) { |
| status = U_INVALID_FORMAT_ERROR; |
| return FALSE; |
| } |
| return TRUE; |
| } |
| |
| // |
| // SpoofData::getDefault() - return a wrapper around the spoof data that is |
| // baked into the default ICU data. |
| // |
| SpoofData *SpoofData::getDefault(UErrorCode &status) { |
| // TODO: Cache it. Lazy create, keep until cleanup. |
| |
| UDataMemory *udm = udata_open(NULL, "cfu", "confusables", &status); |
| if (U_FAILURE(status)) { |
| return NULL; |
| } |
| SpoofData *This = new SpoofData(udm, status); |
| if (U_FAILURE(status)) { |
| delete This; |
| return NULL; |
| } |
| if (This == NULL) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| } |
| return This; |
| } |
| |
| |
| SpoofData::SpoofData(UDataMemory *udm, UErrorCode &status) |
| { |
| reset(); |
| if (U_FAILURE(status)) { |
| return; |
| } |
| fRawData = reinterpret_cast<SpoofDataHeader *> |
| ((char *)(udm->pHeader) + udm->pHeader->dataHeader.headerSize); |
| fUDM = udm; |
| validateDataVersion(fRawData, status); |
| initPtrs(status); |
| } |
| |
| |
| SpoofData::SpoofData(const void *data, int32_t length, UErrorCode &status) |
| { |
| reset(); |
| if (U_FAILURE(status)) { |
| return; |
| } |
| if ((size_t)length < sizeof(SpoofDataHeader)) { |
| status = U_INVALID_FORMAT_ERROR; |
| return; |
| } |
| void *ncData = const_cast<void *>(data); |
| fRawData = static_cast<SpoofDataHeader *>(ncData); |
| if (length < fRawData->fLength) { |
| status = U_INVALID_FORMAT_ERROR; |
| return; |
| } |
| validateDataVersion(fRawData, status); |
| initPtrs(status); |
| } |
| |
| |
| // Spoof Data constructor for use from data builder. |
| // Initializes a new, empty data area that will be populated later. |
| SpoofData::SpoofData(UErrorCode &status) { |
| reset(); |
| if (U_FAILURE(status)) { |
| return; |
| } |
| fDataOwned = true; |
| fRefCount = 1; |
| |
| // The spoof header should already be sized to be a multiple of 16 bytes. |
| // Just in case it's not, round it up. |
| uint32_t initialSize = (sizeof(SpoofDataHeader) + 15) & ~15; |
| U_ASSERT(initialSize == sizeof(SpoofDataHeader)); |
| |
| fRawData = static_cast<SpoofDataHeader *>(uprv_malloc(initialSize)); |
| fMemLimit = initialSize; |
| if (fRawData == NULL) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| return; |
| } |
| uprv_memset(fRawData, 0, initialSize); |
| |
| fRawData->fMagic = USPOOF_MAGIC; |
| fRawData->fFormatVersion[0] = 1; |
| fRawData->fFormatVersion[1] = 0; |
| fRawData->fFormatVersion[2] = 0; |
| fRawData->fFormatVersion[3] = 0; |
| initPtrs(status); |
| } |
| |
| // reset() - initialize all fields. |
| // Should be updated if any new fields are added. |
| // Called by constructors to put things in a known initial state. |
| void SpoofData::reset() { |
| fRawData = NULL; |
| fDataOwned = FALSE; |
| fUDM = NULL; |
| fMemLimit = 0; |
| fRefCount = 1; |
| fCFUKeys = NULL; |
| fCFUValues = NULL; |
| fCFUStringLengths = NULL; |
| fCFUStrings = NULL; |
| fAnyCaseTrie = NULL; |
| fLowerCaseTrie = NULL; |
| fScriptSets = NULL; |
| } |
| |
| |
| // SpoofData::initPtrs() |
| // Initialize the pointers to the various sections of the raw data. |
| // |
| // This function is used both during the Trie building process (multiple |
| // times, as the individual data sections are added), and |
| // during the opening of a Spoof Checker from prebuilt data. |
| // |
| // The pointers for non-existent data sections (identified by an offset of 0) |
| // are set to NULL. |
| // |
| // Note: During building the data, adding each new data section |
| // reallocs the raw data area, which likely relocates it, which |
| // in turn requires reinitializing all of the pointers into it, hence |
| // multiple calls to this function during building. |
| // |
| void SpoofData::initPtrs(UErrorCode &status) { |
| fCFUKeys = NULL; |
| fCFUValues = NULL; |
| fCFUStringLengths = NULL; |
| fCFUStrings = NULL; |
| if (U_FAILURE(status)) { |
| return; |
| } |
| if (fRawData->fCFUKeys != 0) { |
| fCFUKeys = (int32_t *)((char *)fRawData + fRawData->fCFUKeys); |
| } |
| if (fRawData->fCFUStringIndex != 0) { |
| fCFUValues = (uint16_t *)((char *)fRawData + fRawData->fCFUStringIndex); |
| } |
| if (fRawData->fCFUStringLengths != 0) { |
| fCFUStringLengths = (SpoofStringLengthsElement *)((char *)fRawData + fRawData->fCFUStringLengths); |
| } |
| if (fRawData->fCFUStringTable != 0) { |
| fCFUStrings = (UChar *)((char *)fRawData + fRawData->fCFUStringTable); |
| } |
| |
| if (fAnyCaseTrie == NULL && fRawData->fAnyCaseTrie != 0) { |
| fAnyCaseTrie = utrie2_openFromSerialized(UTRIE2_16_VALUE_BITS, |
| (char *)fRawData + fRawData->fAnyCaseTrie, fRawData->fAnyCaseTrieLength, NULL, &status); |
| } |
| if (fLowerCaseTrie == NULL && fRawData->fLowerCaseTrie != 0) { |
| fLowerCaseTrie = utrie2_openFromSerialized(UTRIE2_16_VALUE_BITS, |
| (char *)fRawData + fRawData->fLowerCaseTrie, fRawData->fLowerCaseTrieLength, NULL, &status); |
| } |
| |
| if (fRawData->fScriptSets != 0) { |
| fScriptSets = (ScriptSet *)((char *)fRawData + fRawData->fScriptSets); |
| } |
| } |
| |
| |
| SpoofData::~SpoofData() { |
| utrie2_close(fAnyCaseTrie); |
| fAnyCaseTrie = NULL; |
| utrie2_close(fLowerCaseTrie); |
| fLowerCaseTrie = NULL; |
| if (fDataOwned) { |
| uprv_free(fRawData); |
| } |
| fRawData = NULL; |
| if (fUDM != NULL) { |
| udata_close(fUDM); |
| } |
| fUDM = NULL; |
| } |
| |
| |
| void SpoofData::removeReference() { |
| if (umtx_atomic_dec(&fRefCount) == 0) { |
| delete this; |
| } |
| } |
| |
| |
| SpoofData *SpoofData::addReference() { |
| umtx_atomic_inc(&fRefCount); |
| return this; |
| } |
| |
| |
| void *SpoofData::reserveSpace(int32_t numBytes, UErrorCode &status) { |
| if (U_FAILURE(status)) { |
| return NULL; |
| } |
| if (!fDataOwned) { |
| U_ASSERT(FALSE); |
| status = U_INTERNAL_PROGRAM_ERROR; |
| return NULL; |
| } |
| |
| numBytes = (numBytes + 15) & ~15; // Round up to a multiple of 16 |
| uint32_t returnOffset = fMemLimit; |
| fMemLimit += numBytes; |
| fRawData = static_cast<SpoofDataHeader *>(uprv_realloc(fRawData, fMemLimit)); |
| fRawData->fLength = fMemLimit; |
| uprv_memset((char *)fRawData + returnOffset, 0, numBytes); |
| initPtrs(status); |
| return (char *)fRawData + returnOffset; |
| } |
| |
| |
| //---------------------------------------------------------------------------- |
| // |
| // ScriptSet implementation |
| // |
| //---------------------------------------------------------------------------- |
| ScriptSet::ScriptSet() { |
| for (uint32_t i=0; i<sizeof(bits)/sizeof(uint32_t); i++) { |
| bits[i] = 0; |
| } |
| } |
| |
| ScriptSet::~ScriptSet() { |
| } |
| |
| UBool ScriptSet::operator == (const ScriptSet &other) { |
| for (uint32_t i=0; i<sizeof(bits)/sizeof(uint32_t); i++) { |
| if (bits[i] != other.bits[i]) { |
| return FALSE; |
| } |
| } |
| return TRUE; |
| } |
| |
| void ScriptSet::Union(UScriptCode script) { |
| uint32_t index = script / 32; |
| uint32_t bit = 1 << (script & 31); |
| U_ASSERT(index < sizeof(bits)*4); |
| bits[index] |= bit; |
| } |
| |
| |
| void ScriptSet::Union(const ScriptSet &other) { |
| for (uint32_t i=0; i<sizeof(bits)/sizeof(uint32_t); i++) { |
| bits[i] |= other.bits[i]; |
| } |
| } |
| |
| void ScriptSet::intersect(const ScriptSet &other) { |
| for (uint32_t i=0; i<sizeof(bits)/sizeof(uint32_t); i++) { |
| bits[i] &= other.bits[i]; |
| } |
| } |
| |
| void ScriptSet::intersect(UScriptCode script) { |
| uint32_t index = script / 32; |
| uint32_t bit = 1 << (script & 31); |
| U_ASSERT(index < sizeof(bits)*4); |
| uint32_t i; |
| for (i=0; i<index; i++) { |
| bits[i] = 0; |
| } |
| bits[index] &= bit; |
| for (i=index+1; i<sizeof(bits)/sizeof(uint32_t); i++) { |
| bits[i] = 0; |
| } |
| } |
| |
| |
| ScriptSet & ScriptSet::operator =(const ScriptSet &other) { |
| for (uint32_t i=0; i<sizeof(bits)/sizeof(uint32_t); i++) { |
| bits[i] = other.bits[i]; |
| } |
| return *this; |
| } |
| |
| |
| void ScriptSet::setAll() { |
| for (uint32_t i=0; i<sizeof(bits)/sizeof(uint32_t); i++) { |
| bits[i] = 0xffffffffu; |
| } |
| } |
| |
| |
| void ScriptSet::resetAll() { |
| for (uint32_t i=0; i<sizeof(bits)/sizeof(uint32_t); i++) { |
| bits[i] = 0; |
| } |
| } |
| |
| int32_t ScriptSet::countMembers() { |
| // This bit counter is good for sparse numbers of '1's, which is |
| // very much the case that we will usually have. |
| int32_t count = 0; |
| for (uint32_t i=0; i<sizeof(bits)/sizeof(uint32_t); i++) { |
| uint32_t x = bits[i]; |
| while (x > 0) { |
| count++; |
| x &= (x - 1); // and off the least significant one bit. |
| } |
| } |
| return count; |
| } |
| |
| |
| |
| //----------------------------------------------------------------------------- |
| // |
| // NFDBuffer Implementation. |
| // |
| //----------------------------------------------------------------------------- |
| |
| NFDBuffer::NFDBuffer(const UChar *text, int32_t length, UErrorCode &status) { |
| fNormalizedText = NULL; |
| fNormalizedTextLength = 0; |
| fOriginalText = text; |
| if (U_FAILURE(status)) { |
| return; |
| } |
| fNormalizedText = fSmallBuf; |
| fNormalizedTextLength = unorm_normalize( |
| text, length, UNORM_NFD, 0, fNormalizedText, USPOOF_STACK_BUFFER_SIZE, &status); |
| if (status == U_BUFFER_OVERFLOW_ERROR) { |
| status = U_ZERO_ERROR; |
| fNormalizedText = (UChar *)uprv_malloc((fNormalizedTextLength+1)*sizeof(UChar)); |
| if (fNormalizedText == NULL) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| } else { |
| fNormalizedTextLength = unorm_normalize(text, length, UNORM_NFD, 0, |
| fNormalizedText, fNormalizedTextLength+1, &status); |
| } |
| } |
| } |
| |
| |
| NFDBuffer::~NFDBuffer() { |
| if (fNormalizedText != fSmallBuf) { |
| uprv_free(fNormalizedText); |
| } |
| fNormalizedText = 0; |
| } |
| |
| const UChar *NFDBuffer::getBuffer() { |
| return fNormalizedText; |
| } |
| |
| int32_t NFDBuffer::getLength() { |
| return fNormalizedTextLength; |
| } |
| |
| |
| |
| |
| |
| U_NAMESPACE_END |
| |
| U_NAMESPACE_USE |
| |
| //----------------------------------------------------------------------------- |
| // |
| // uspoof_swap - byte swap and char encoding swap of spoof data |
| // |
| //----------------------------------------------------------------------------- |
| U_CAPI int32_t U_EXPORT2 |
| uspoof_swap(const UDataSwapper *ds, const void *inData, int32_t length, void *outData, |
| UErrorCode *status) { |
| |
| if (status == NULL || U_FAILURE(*status)) { |
| return 0; |
| } |
| if(ds==NULL || inData==NULL || length<-1 || (length>0 && outData==NULL)) { |
| *status=U_ILLEGAL_ARGUMENT_ERROR; |
| return 0; |
| } |
| |
| // |
| // Check that the data header is for spoof data. |
| // (Header contents are defined in gencfu.cpp) |
| // |
| const UDataInfo *pInfo = (const UDataInfo *)((const char *)inData+4); |
| if(!( pInfo->dataFormat[0]==0x43 && /* dataFormat="Cfu " */ |
| pInfo->dataFormat[1]==0x66 && |
| pInfo->dataFormat[2]==0x75 && |
| pInfo->dataFormat[3]==0x20 && |
| pInfo->formatVersion[0]==1 )) { |
| udata_printError(ds, "uspoof_swap(): data format %02x.%02x.%02x.%02x " |
| "(format version %02x %02x %02x %02x) is not recognized\n", |
| pInfo->dataFormat[0], pInfo->dataFormat[1], |
| pInfo->dataFormat[2], pInfo->dataFormat[3], |
| pInfo->formatVersion[0], pInfo->formatVersion[1], |
| pInfo->formatVersion[2], pInfo->formatVersion[3]); |
| *status=U_UNSUPPORTED_ERROR; |
| return 0; |
| } |
| |
| // |
| // Swap the data header. (This is the generic ICU Data Header, not the uspoof Specific |
| // header). This swap also conveniently gets us |
| // the size of the ICU d.h., which lets us locate the start |
| // of the uspoof specific data. |
| // |
| int32_t headerSize=udata_swapDataHeader(ds, inData, length, outData, status); |
| |
| |
| // |
| // Get the Spoof Data Header, and check that it appears to be OK. |
| // |
| // |
| const uint8_t *inBytes =(const uint8_t *)inData+headerSize; |
| SpoofDataHeader *spoofDH = (SpoofDataHeader *)inBytes; |
| if (ds->readUInt32(spoofDH->fMagic) != USPOOF_MAGIC || |
| ds->readUInt32(spoofDH->fLength) < sizeof(SpoofDataHeader)) |
| { |
| udata_printError(ds, "uspoof_swap(): Spoof Data header is invalid.\n"); |
| *status=U_UNSUPPORTED_ERROR; |
| return 0; |
| } |
| |
| // |
| // Prefight operation? Just return the size |
| // |
| int32_t spoofDataLength = ds->readUInt32(spoofDH->fLength); |
| int32_t totalSize = headerSize + spoofDataLength; |
| if (length < 0) { |
| return totalSize; |
| } |
| |
| // |
| // Check that length passed in is consistent with length from Spoof data header. |
| // |
| if (length < totalSize) { |
| udata_printError(ds, "uspoof_swap(): too few bytes (%d after ICU Data header) for spoof data.\n", |
| spoofDataLength); |
| *status=U_INDEX_OUTOFBOUNDS_ERROR; |
| return 0; |
| } |
| |
| |
| // |
| // Swap the Data. Do the data itself first, then the Spoof Data Header, because |
| // we need to reference the header to locate the data, and an |
| // inplace swap of the header leaves it unusable. |
| // |
| uint8_t *outBytes = (uint8_t *)outData + headerSize; |
| SpoofDataHeader *outputDH = (SpoofDataHeader *)outBytes; |
| |
| int32_t sectionStart; |
| int32_t sectionLength; |
| |
| // |
| // If not swapping in place, zero out the output buffer before starting. |
| // Gaps may exist between the individual sections, and these must be zeroed in |
| // the output buffer. The simplest way to do that is to just zero the whole thing. |
| // |
| if (inBytes != outBytes) { |
| uprv_memset(outBytes, 0, spoofDataLength); |
| } |
| |
| // Confusables Keys Section (fCFUKeys) |
| sectionStart = ds->readUInt32(spoofDH->fCFUKeys); |
| sectionLength = ds->readUInt32(spoofDH->fCFUKeysSize) * 4; |
| ds->swapArray32(ds, inBytes+sectionStart, sectionLength, outBytes+sectionStart, status); |
| |
| // String Index Section |
| sectionStart = ds->readUInt32(spoofDH->fCFUStringIndex); |
| sectionLength = ds->readUInt32(spoofDH->fCFUStringIndexSize) * 2; |
| ds->swapArray16(ds, inBytes+sectionStart, sectionLength, outBytes+sectionStart, status); |
| |
| // String Table Section |
| sectionStart = ds->readUInt32(spoofDH->fCFUStringTable); |
| sectionLength = ds->readUInt32(spoofDH->fCFUStringTableLen) * 2; |
| ds->swapArray16(ds, inBytes+sectionStart, sectionLength, outBytes+sectionStart, status); |
| |
| // String Lengths Section |
| sectionStart = ds->readUInt32(spoofDH->fCFUStringLengths); |
| sectionLength = ds->readUInt32(spoofDH->fCFUStringLengthsSize) * 4; |
| ds->swapArray16(ds, inBytes+sectionStart, sectionLength, outBytes+sectionStart, status); |
| |
| // Any Case Trie |
| sectionStart = ds->readUInt32(spoofDH->fAnyCaseTrie); |
| sectionLength = ds->readUInt32(spoofDH->fAnyCaseTrieLength); |
| utrie2_swap(ds, inBytes+sectionStart, sectionLength, outBytes+sectionStart, status); |
| |
| // Lower Case Trie |
| sectionStart = ds->readUInt32(spoofDH->fLowerCaseTrie); |
| sectionLength = ds->readUInt32(spoofDH->fLowerCaseTrieLength); |
| utrie2_swap(ds, inBytes+sectionStart, sectionLength, outBytes+sectionStart, status); |
| |
| // Script Sets. The data is an array of int32_t |
| sectionStart = ds->readUInt32(spoofDH->fScriptSets); |
| sectionLength = ds->readUInt32(spoofDH->fScriptSetsLength) * sizeof(ScriptSet); |
| ds->swapArray32(ds, inBytes+sectionStart, sectionLength, outBytes+sectionStart, status); |
| |
| // And, last, swap the header itself. |
| // int32_t fMagic // swap this |
| // uint8_t fFormatVersion[4] // Do not swap this, just copy |
| // int32_t fLength and all the rest // Swap the rest, all is 32 bit stuff. |
| // |
| uint32_t magic = ds->readUInt32(spoofDH->fMagic); |
| ds->writeUInt32((uint32_t *)&outputDH->fMagic, magic); |
| |
| if (outputDH->fFormatVersion != spoofDH->fFormatVersion) { |
| uprv_memcpy(outputDH->fFormatVersion, spoofDH->fFormatVersion, sizeof(spoofDH->fFormatVersion)); |
| } |
| // swap starting at fLength |
| ds->swapArray32(ds, &spoofDH->fLength, sizeof(SpoofDataHeader)-8 /* minus magic and fFormatVersion[4] */, &outputDH->fLength, status); |
| |
| return totalSize; |
| } |
| |
| #endif |
| |
| |
