path: root/contrib/libs/icu/i18n/uspoof_impl.cpp

// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html 
/* 
********************************************************************** 
*   Copyright (C) 2008-2016, International Business Machines 
*   Corporation and others.  All Rights Reserved. 
********************************************************************** 
*/ 
 
#include "unicode/utypes.h" 
#include "unicode/uspoof.h" 
#include "unicode/uchar.h" 
#include "unicode/uniset.h" 
#include "unicode/utf16.h" 
#include "utrie2.h" 
#include "cmemory.h" 
#include "cstring.h" 
#include "scriptset.h" 
#include "umutex.h" 
#include "udataswp.h" 
#include "uassert.h" 
#include "ucln_in.h" 
#include "uspoof_impl.h" 
 
#if !UCONFIG_NO_NORMALIZATION 
 
 
U_NAMESPACE_BEGIN 
 
UOBJECT_DEFINE_RTTI_IMPLEMENTATION(SpoofImpl) 
 
SpoofImpl::SpoofImpl(SpoofData *data, UErrorCode& status) { 
    construct(status); 
    fSpoofData = data; 
} 
 
SpoofImpl::SpoofImpl(UErrorCode& status) { 
    construct(status); 
 
    // TODO: Call this method where it is actually needed, instead of in the 
    // constructor, to allow for lazy data loading.  See #12696. 
    fSpoofData = SpoofData::getDefault(status); 
} 
 
SpoofImpl::SpoofImpl() { 
    UErrorCode status = U_ZERO_ERROR; 
    construct(status); 
 
    // TODO: Call this method where it is actually needed, instead of in the 
    // constructor, to allow for lazy data loading.  See #12696. 
    fSpoofData = SpoofData::getDefault(status); 
} 
 
void SpoofImpl::construct(UErrorCode& status) { 
    fChecks = USPOOF_ALL_CHECKS; 
    fSpoofData = NULL; 
    fAllowedCharsSet = NULL; 
    fAllowedLocales = NULL; 
    fRestrictionLevel = USPOOF_HIGHLY_RESTRICTIVE; 
 
    if (U_FAILURE(status)) { return; } 
 
    UnicodeSet *allowedCharsSet = new UnicodeSet(0, 0x10ffff); 
    fAllowedCharsSet = allowedCharsSet; 
    fAllowedLocales  = uprv_strdup(""); 
    if (fAllowedCharsSet == NULL || fAllowedLocales == NULL) { 
        status = U_MEMORY_ALLOCATION_ERROR; 
        return; 
    } 
    allowedCharsSet->freeze(); 
} 
 
 
// Copy Constructor, used by the user level clone() function. 
SpoofImpl::SpoofImpl(const SpoofImpl &src, UErrorCode &status)  : 
        fChecks(USPOOF_ALL_CHECKS), fSpoofData(NULL), fAllowedCharsSet(NULL) , 
        fAllowedLocales(NULL) { 
    if (U_FAILURE(status)) { 
        return; 
    } 
    fChecks = src.fChecks; 
    if (src.fSpoofData != NULL) { 
        fSpoofData = src.fSpoofData->addReference(); 
    } 
    fAllowedCharsSet = src.fAllowedCharsSet->clone();
    fAllowedLocales = uprv_strdup(src.fAllowedLocales); 
    if (fAllowedCharsSet == NULL || fAllowedLocales == NULL) { 
        status = U_MEMORY_ALLOCATION_ERROR; 
    } 
    fRestrictionLevel = src.fRestrictionLevel; 
} 
 
SpoofImpl::~SpoofImpl() { 
    if (fSpoofData != NULL) { 
        fSpoofData->removeReference();   // Will delete if refCount goes to zero. 
    } 
    delete fAllowedCharsSet; 
    uprv_free((void *)fAllowedLocales); 
} 
 
//  Cast this instance as a USpoofChecker for the C API. 
USpoofChecker *SpoofImpl::asUSpoofChecker() { 
    return exportForC();
} 
 
// 
//  Incoming parameter check on Status and the SpoofChecker object 
//    received from the C API. 
// 
const SpoofImpl *SpoofImpl::validateThis(const USpoofChecker *sc, UErrorCode &status) { 
    auto* This = validate(sc, status);
    if (U_FAILURE(status)) { 
        return NULL; 
    } 
    if (This->fSpoofData != NULL && !This->fSpoofData->validateDataVersion(status)) { 
        return NULL; 
    } 
    return This; 
} 
 
SpoofImpl *SpoofImpl::validateThis(USpoofChecker *sc, UErrorCode &status) { 
    return const_cast<SpoofImpl *> 
        (SpoofImpl::validateThis(const_cast<const USpoofChecker *>(sc), status)); 
} 
 
 
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 = 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, UPRV_LENGTHOF(scripts), &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); 
    } 
} 
 
// Computes the augmented script set for a code point, according to UTS 39 section 5.1. 
void SpoofImpl::getAugmentedScriptSet(UChar32 codePoint, ScriptSet& result, UErrorCode& status) { 
    result.resetAll(); 
    result.setScriptExtensions(codePoint, status); 
    if (U_FAILURE(status)) { return; } 
 
    // Section 5.1 step 1 
    if (result.test(USCRIPT_HAN, status)) { 
        result.set(USCRIPT_HAN_WITH_BOPOMOFO, status); 
        result.set(USCRIPT_JAPANESE, status); 
        result.set(USCRIPT_KOREAN, status); 
    } 
    if (result.test(USCRIPT_HIRAGANA, status)) { 
        result.set(USCRIPT_JAPANESE, status); 
    } 
    if (result.test(USCRIPT_KATAKANA, status)) { 
        result.set(USCRIPT_JAPANESE, status); 
    } 
    if (result.test(USCRIPT_HANGUL, status)) { 
        result.set(USCRIPT_KOREAN, status); 
    } 
    if (result.test(USCRIPT_BOPOMOFO, status)) { 
        result.set(USCRIPT_HAN_WITH_BOPOMOFO, status); 
    } 
 
    // Section 5.1 step 2 
    if (result.test(USCRIPT_COMMON, status) || result.test(USCRIPT_INHERITED, status)) { 
        result.setAll(); 
    } 
} 
 
// Computes the resolved script set for a string, according to UTS 39 section 5.1. 
void SpoofImpl::getResolvedScriptSet(const UnicodeString& input, ScriptSet& result, UErrorCode& status) const { 
    getResolvedScriptSetWithout(input, USCRIPT_CODE_LIMIT, result, status); 
} 
 
// Computes the resolved script set for a string, omitting characters having the specified script. 
// If USCRIPT_CODE_LIMIT is passed as the second argument, all characters are included. 
void SpoofImpl::getResolvedScriptSetWithout(const UnicodeString& input, UScriptCode script, ScriptSet& result, UErrorCode& status) const { 
    result.setAll(); 
 
    ScriptSet temp; 
    UChar32 codePoint; 
    for (int32_t i = 0; i < input.length(); i += U16_LENGTH(codePoint)) { 
        codePoint = input.char32At(i); 
 
        // Compute the augmented script set for the character 
        getAugmentedScriptSet(codePoint, temp, status); 
        if (U_FAILURE(status)) { return; } 
 
        // Intersect the augmented script set with the resolved script set, but only if the character doesn't 
        // have the script specified in the function call 
        if (script == USCRIPT_CODE_LIMIT || !temp.test(script, status)) { 
            result.intersect(temp); 
        } 
    } 
} 
 
// Computes the set of numerics for a string, according to UTS 39 section 5.3. 
void SpoofImpl::getNumerics(const UnicodeString& input, UnicodeSet& result, UErrorCode& /*status*/) const { 
    result.clear(); 
 
    UChar32 codePoint; 
    for (int32_t i = 0; i < input.length(); i += U16_LENGTH(codePoint)) { 
        codePoint = input.char32At(i); 
 
        // Store a representative character for each kind of decimal digit 
        if (u_charType(codePoint) == U_DECIMAL_DIGIT_NUMBER) { 
            // Store the zero character as a representative for comparison. 
            // Unicode guarantees it is codePoint - value 
            result.add(codePoint - (UChar32)u_getNumericValue(codePoint)); 
        } 
    } 
} 
 
// Computes the restriction level of a string, according to UTS 39 section 5.2. 
URestrictionLevel SpoofImpl::getRestrictionLevel(const UnicodeString& input, UErrorCode& status) const { 
    // Section 5.2 step 1: 
    if (!fAllowedCharsSet->containsAll(input)) { 
        return USPOOF_UNRESTRICTIVE; 
    } 
 
    // Section 5.2 step 2 
    // Java use a static UnicodeSet for this test.  In C++, avoid the static variable 
    // and just do a simple for loop. 
    UBool allASCII = TRUE; 
    for (int32_t i=0, length=input.length(); i<length; i++) { 
        if (input.charAt(i) > 0x7f) { 
            allASCII = FALSE; 
            break; 
        } 
    } 
    if (allASCII) { 
        return USPOOF_ASCII; 
    } 
 
    // Section 5.2 steps 3: 
    ScriptSet resolvedScriptSet; 
    getResolvedScriptSet(input, resolvedScriptSet, status); 
    if (U_FAILURE(status)) { return USPOOF_UNRESTRICTIVE; } 
 
    // Section 5.2 step 4: 
    if (!resolvedScriptSet.isEmpty()) { 
        return USPOOF_SINGLE_SCRIPT_RESTRICTIVE; 
    } 
 
    // Section 5.2 step 5: 
    ScriptSet resolvedNoLatn; 
    getResolvedScriptSetWithout(input, USCRIPT_LATIN, resolvedNoLatn, status); 
    if (U_FAILURE(status)) { return USPOOF_UNRESTRICTIVE; } 
 
    // Section 5.2 step 6: 
    if (resolvedNoLatn.test(USCRIPT_HAN_WITH_BOPOMOFO, status) 
            || resolvedNoLatn.test(USCRIPT_JAPANESE, status) 
            || resolvedNoLatn.test(USCRIPT_KOREAN, status)) { 
        return USPOOF_HIGHLY_RESTRICTIVE; 
    } 
 
    // Section 5.2 step 7: 
    if (!resolvedNoLatn.isEmpty() 
            && !resolvedNoLatn.test(USCRIPT_CYRILLIC, status) 
            && !resolvedNoLatn.test(USCRIPT_GREEK, status) 
            && !resolvedNoLatn.test(USCRIPT_CHEROKEE, status)) { 
        return USPOOF_MODERATELY_RESTRICTIVE; 
    } 
 
    // Section 5.2 step 8: 
    return USPOOF_MINIMALLY_RESTRICTIVE; 
} 
 
int32_t SpoofImpl::findHiddenOverlay(const UnicodeString& input, UErrorCode&) const {
    bool sawLeadCharacter = false;
    for (int32_t i=0; i<input.length();) {
        UChar32 cp = input.char32At(i);
        if (sawLeadCharacter && cp == 0x0307) {
            return i;
        }
        uint8_t combiningClass = u_getCombiningClass(cp);
        // Skip over characters except for those with combining class 0 (non-combining characters) or with
        // combining class 230 (same class as U+0307)
        U_ASSERT(u_getCombiningClass(0x0307) == 230);
        if (combiningClass == 0 || combiningClass == 230) {
            sawLeadCharacter = isIllegalCombiningDotLeadCharacter(cp);
        }
        i += U16_LENGTH(cp);
    }
    return -1;
}
 
static inline bool isIllegalCombiningDotLeadCharacterNoLookup(UChar32 cp) {
    return cp == u'i' || cp == u'j' || cp == u'ı' || cp == u'ȷ' || cp == u'l' ||
           u_hasBinaryProperty(cp, UCHAR_SOFT_DOTTED);
}
 
bool SpoofImpl::isIllegalCombiningDotLeadCharacter(UChar32 cp) const {
    if (isIllegalCombiningDotLeadCharacterNoLookup(cp)) {
        return true;
    }
    UnicodeString skelStr;
    fSpoofData->confusableLookup(cp, skelStr);
    UChar32 finalCp = skelStr.char32At(skelStr.moveIndex32(skelStr.length(), -1));
    if (finalCp != cp && isIllegalCombiningDotLeadCharacterNoLookup(finalCp)) {
        return true;
    }
    return false;
}



// 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 CheckResult Implementation 
// 
//----------------------------------------- 
 
CheckResult::CheckResult() {
    clear(); 
} 
 
USpoofCheckResult* CheckResult::asUSpoofCheckResult() { 
    return exportForC();
} 
 
// 
//  Incoming parameter check on Status and the CheckResult object 
//    received from the C API. 
// 
const CheckResult* CheckResult::validateThis(const USpoofCheckResult *ptr, UErrorCode &status) { 
    return validate(ptr, status);
} 
 
CheckResult* CheckResult::validateThis(USpoofCheckResult *ptr, UErrorCode &status) { 
    return validate(ptr, status);
} 
 
void CheckResult::clear() { 
    fChecks = 0; 
    fNumerics.clear(); 
    fRestrictionLevel = USPOOF_UNDEFINED_RESTRICTIVE; 
} 
 
int32_t CheckResult::toCombinedBitmask(int32_t enabledChecks) { 
    if ((enabledChecks & USPOOF_AUX_INFO) != 0 && fRestrictionLevel != USPOOF_UNDEFINED_RESTRICTIVE) { 
        return fChecks | fRestrictionLevel; 
    } else { 
        return fChecks; 
    } 
} 
 
CheckResult::~CheckResult() { 
} 
 
//---------------------------------------------------------------------------------------------- 
// 
//   class SpoofData Implementation 
// 
//---------------------------------------------------------------------------------------------- 
 
 
UBool SpoofData::validateDataVersion(UErrorCode &status) const { 
    if (U_FAILURE(status) || 
        fRawData == NULL || 
        fRawData->fMagic != USPOOF_MAGIC || 
        fRawData->fFormatVersion[0] != USPOOF_CONFUSABLE_DATA_FORMAT_VERSION || 
        fRawData->fFormatVersion[1] != 0 || 
        fRawData->fFormatVersion[2] != 0 || 
        fRawData->fFormatVersion[3] != 0) { 
            status = U_INVALID_FORMAT_ERROR; 
            return FALSE; 
    } 
    return TRUE; 
} 
 
static UBool U_CALLCONV 
spoofDataIsAcceptable(void *context, 
                        const char * /* type */, const char * /*name*/, 
                        const UDataInfo *pInfo) { 
    if( 
        pInfo->size >= 20 && 
        pInfo->isBigEndian == U_IS_BIG_ENDIAN && 
        pInfo->charsetFamily == U_CHARSET_FAMILY && 
        pInfo->dataFormat[0] == 0x43 &&  // dataFormat="Cfu " 
        pInfo->dataFormat[1] == 0x66 && 
        pInfo->dataFormat[2] == 0x75 && 
        pInfo->dataFormat[3] == 0x20 && 
        pInfo->formatVersion[0] == USPOOF_CONFUSABLE_DATA_FORMAT_VERSION 
    ) { 
        UVersionInfo *version = static_cast<UVersionInfo *>(context); 
        if(version != NULL) { 
            uprv_memcpy(version, pInfo->dataVersion, 4); 
        } 
        return TRUE; 
    } else { 
        return FALSE; 
    } 
} 
 
//  Methods for the loading of the default confusables data file.  The confusable 
//  data is loaded only when it is needed. 
// 
//  SpoofData::getDefault() - Return the default confusables data, and call the 
//                            initOnce() if it is not available.  Adds a reference 
//                            to the SpoofData that the caller is responsible for 
//                            decrementing when they are done with the data. 
// 
//  uspoof_loadDefaultData - Called once, from initOnce().  The resulting SpoofData 
//                           is shared by all spoof checkers using the default data. 
// 
//  uspoof_cleanupDefaultData - Called during cleanup. 
// 
 
static UInitOnce gSpoofInitDefaultOnce = U_INITONCE_INITIALIZER; 
static SpoofData* gDefaultSpoofData; 
 
static UBool U_CALLCONV 
uspoof_cleanupDefaultData(void) { 
    if (gDefaultSpoofData) { 
        // Will delete, assuming all user-level spoof checkers were closed. 
        gDefaultSpoofData->removeReference(); 
        gDefaultSpoofData = nullptr;
        gSpoofInitDefaultOnce.reset(); 
    } 
    return TRUE; 
} 
 
static void U_CALLCONV uspoof_loadDefaultData(UErrorCode& status) { 
    UDataMemory *udm = udata_openChoice(nullptr, "cfu", "confusables",
                                        spoofDataIsAcceptable,  
                                        nullptr,       // context, would receive dataVersion if supplied.
                                        &status); 
    if (U_FAILURE(status)) { return; } 
    gDefaultSpoofData = new SpoofData(udm, status); 
    if (U_FAILURE(status)) { 
        delete gDefaultSpoofData; 
        gDefaultSpoofData = nullptr;
        return; 
    } 
    if (gDefaultSpoofData == nullptr) {
        status = U_MEMORY_ALLOCATION_ERROR; 
        return; 
    } 
    ucln_i18n_registerCleanup(UCLN_I18N_SPOOFDATA, uspoof_cleanupDefaultData); 
} 
 
SpoofData* SpoofData::getDefault(UErrorCode& status) { 
    umtx_initOnce(gSpoofInitDefaultOnce, &uspoof_loadDefaultData, status); 
    if (U_FAILURE(status)) { return NULL; } 
    gDefaultSpoofData->addReference(); 
    return gDefaultSpoofData; 
} 
 
 
 
SpoofData::SpoofData(UDataMemory *udm, UErrorCode &status) 
{ 
    reset(); 
    if (U_FAILURE(status)) { 
        return; 
    } 
    fUDM = udm; 
    // fRawData is non-const because it may be constructed by the data builder. 
    fRawData = reinterpret_cast<SpoofDataHeader *>( 
            const_cast<void *>(udata_getMemory(udm))); 
    validateDataVersion(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; 
    } 
    if (data == NULL) {
        status = U_ILLEGAL_ARGUMENT_ERROR;
        return;
    }
    void *ncData = const_cast<void *>(data); 
    fRawData = static_cast<SpoofDataHeader *>(ncData); 
    if (length < fRawData->fLength) { 
        status = U_INVALID_FORMAT_ERROR; 
        return; 
    } 
    validateDataVersion(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; 
 
    // 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] = USPOOF_CONFUSABLE_DATA_FORMAT_VERSION; 
    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; 
   fCFUStrings = 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; 
    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->fCFUStringTable != 0) { 
        fCFUStrings = (UChar *)((char *)fRawData + fRawData->fCFUStringTable); 
    } 
} 
 
 
SpoofData::~SpoofData() { 
    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) { 
        UPRV_UNREACHABLE;
    } 
 
    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; 
} 
 
int32_t SpoofData::serialize(void *buf, int32_t capacity, UErrorCode &status) const { 
    int32_t dataSize = fRawData->fLength; 
    if (capacity < dataSize) { 
        status = U_BUFFER_OVERFLOW_ERROR; 
        return dataSize; 
    } 
    uprv_memcpy(buf, fRawData, dataSize); 
    return dataSize; 
} 
 
int32_t SpoofData::size() const { 
    return fRawData->fLength; 
} 
 
//------------------------------- 
// 
// Front-end APIs for SpoofData 
// 
//------------------------------- 
 
int32_t SpoofData::confusableLookup(UChar32 inChar, UnicodeString &dest) const { 
    // Perform a binary search. 
    // [lo, hi), i.e lo is inclusive, hi is exclusive. 
    // The result after the loop will be in lo. 
    int32_t lo = 0; 
    int32_t hi = length(); 
    do { 
        int32_t mid = (lo + hi) / 2; 
        if (codePointAt(mid) > inChar) { 
            hi = mid; 
        } else if (codePointAt(mid) < inChar) { 
            lo = mid; 
        } else { 
            // Found result.  Break early. 
            lo = mid; 
            break; 
        } 
    } while (hi - lo > 1); 
 
    // Did we find an entry?  If not, the char maps to itself. 
    if (codePointAt(lo) != inChar) { 
        dest.append(inChar); 
        return 1; 
    } 
 
    // Add the element to the string builder and return. 
    return appendValueTo(lo, dest); 
} 
 
int32_t SpoofData::length() const { 
    return fRawData->fCFUKeysSize; 
} 
 
UChar32 SpoofData::codePointAt(int32_t index) const { 
    return ConfusableDataUtils::keyToCodePoint(fCFUKeys[index]); 
} 
 
int32_t SpoofData::appendValueTo(int32_t index, UnicodeString& dest) const { 
    int32_t stringLength = ConfusableDataUtils::keyToLength(fCFUKeys[index]); 
 
    // Value is either a char (for strings of length 1) or 
    // an index into the string table (for longer strings) 
    uint16_t value = fCFUValues[index]; 
    if (stringLength == 1) { 
        dest.append((UChar)value); 
    } else { 
        dest.append(fCFUStrings + value, stringLength); 
    } 
 
    return stringLength; 
} 
 
 
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]==USPOOF_CONFUSABLE_DATA_FORMAT_VERSION && 
           pInfo->formatVersion[1]==0 && 
           pInfo->formatVersion[2]==0 && 
           pInfo->formatVersion[3]==0  )) { 
        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); 
 
    // 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