/*
* Check for the alias from the string or alias resource res.
*/
static void
checkAlias(const char *itemName,
Resource res, const UChar *alias, int32_t length, UBool useResSuffix,
CheckDependency check, void *context, UErrorCode *pErrorCode) {
int32_t i;
if(!uprv_isInvariantUString(alias, length)) {
fprintf(stderr, "icupkg/ures_enumDependencies(%s res=%08x) alias string contains non-invariant characters\n",
itemName, res);
*pErrorCode=U_INVALID_CHAR_FOUND;
return;
}
// extract the locale ID from alias strings like
// locale_ID/key1/key2/key3
// locale_ID
// search for the first slash
for(i=0; i<length && alias[i]!=SLASH; ++i) {}
if(res_getPublicType(res)==URES_ALIAS) {
// ignore aliases with an initial slash:
// /ICUDATA/... and /pkgname/... go to a different package
// /LOCALE/... are for dynamic sideways fallbacks and don't go to a fixed bundle
if(i==0) {
return; // initial slash ('/')
}
// ignore the intra-bundle path starting from the first slash ('/')
length=i;
} else /* URES_STRING */ {
// the whole string should only consist of a locale ID
if(i!=length) {
fprintf(stderr, "icupkg/ures_enumDependencies(%s res=%08x) %%ALIAS contains a '/'\n",
itemName, res);
*pErrorCode=U_UNSUPPORTED_ERROR;
return;
}
}
// convert the Unicode string to char *
char localeID[32];
if(length>=(int32_t)sizeof(localeID)) {
fprintf(stderr, "icupkg/ures_enumDependencies(%s res=%08x) alias locale ID length %ld too long\n",
itemName, res, (long)length);
*pErrorCode=U_BUFFER_OVERFLOW_ERROR;
return;
}
u_UCharsToChars(alias, localeID, length);
localeID[length]=0;
checkIDSuffix(itemName, localeID, -1, (useResSuffix ? ".res" : ""), check, context, pErrorCode);
}
/* assemble the target item name from the item's parent item name */
static void
checkParent(const char *itemName, CheckDependency check, void *context,
UErrorCode *pErrorCode) {
const char *itemID, *parent, *parentLimit, *suffix;
int32_t parentLength;
// get the item basename
itemID=strrchr(itemName, '/');
if(itemID!=NULL) {
++itemID;
} else {
itemID=itemName;
}
// get the item suffix
suffix=strrchr(itemID, '.');
if(suffix==NULL) {
// empty suffix, point to the end of the string
suffix=strrchr(itemID, 0);
}
// get the position of the last '_'
for(parentLimit=suffix; parentLimit>itemID && *--parentLimit!='_';) {}
if(parentLimit!=itemID) {
// get the parent item name by truncating the last part of this item's name */
parent=itemID;
parentLength=(int32_t)(parentLimit-itemID);
} else {
// no '_' in the item name: the parent is the root bundle
parent="root";
parentLength=4;
if((suffix-itemID)==parentLength && 0==memcmp(itemID, parent, parentLength)) {
// the item itself is "root", which does not depend on a parent
return;
}
}
checkIDSuffix(itemName, parent, parentLength, suffix, check, context, pErrorCode);
}
/* code adapted from ucnv_swap() */
static void
ucnv_enumDependencies(const UDataSwapper *ds,
const char *itemName, const UDataInfo *pInfo,
const uint8_t *inBytes, int32_t length,
CheckDependency check, void *context,
UErrorCode *pErrorCode) {
uint32_t staticDataSize;
const UConverterStaticData *inStaticData;
const _MBCSHeader *inMBCSHeader;
uint8_t outputType;
/* check format version */
if(!(
pInfo->formatVersion[0]==6 &&
pInfo->formatVersion[1]>=2
)) {
fprintf(stderr, "icupkg/ucnv_enumDependencies(): .cnv format version %02x.%02x not supported\n",
pInfo->formatVersion[0], pInfo->formatVersion[1]);
exit(U_UNSUPPORTED_ERROR);
}
/* read the initial UConverterStaticData structure after the UDataInfo header */
inStaticData=(const UConverterStaticData *)inBytes;
if( length<(int32_t)sizeof(UConverterStaticData) ||
(uint32_t)length<(staticDataSize=ds->readUInt32(inStaticData->structSize))
) {
udata_printError(ds, "icupkg/ucnv_enumDependencies(): too few bytes (%d after header) for an ICU .cnv conversion table\n",
length);
*pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
return;
}
inBytes+=staticDataSize;
length-=(int32_t)staticDataSize;
/* check for supported conversionType values */
if(inStaticData->conversionType==UCNV_MBCS) {
/* MBCS data */
uint32_t mbcsHeaderLength, mbcsHeaderFlags, mbcsHeaderOptions;
int32_t extOffset;
inMBCSHeader=(const _MBCSHeader *)inBytes;
if(length<(int32_t)sizeof(_MBCSHeader)) {
udata_printError(ds, "icupkg/ucnv_enumDependencies(): too few bytes (%d after headers) for an ICU MBCS .cnv conversion table\n",
length);
*pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
return;
}
if(inMBCSHeader->version[0]==4 && inMBCSHeader->version[1]>=1) {
mbcsHeaderLength=MBCS_HEADER_V4_LENGTH;
} else if(inMBCSHeader->version[0]==5 && inMBCSHeader->version[1]>=3 &&
((mbcsHeaderOptions=ds->readUInt32(inMBCSHeader->options))&
MBCS_OPT_UNKNOWN_INCOMPATIBLE_MASK)==0
) {
mbcsHeaderLength=mbcsHeaderOptions&MBCS_OPT_LENGTH_MASK;
} else {
udata_printError(ds, "icupkg/ucnv_enumDependencies(): unsupported _MBCSHeader.version %d.%d\n",
inMBCSHeader->version[0], inMBCSHeader->version[1]);
*pErrorCode=U_UNSUPPORTED_ERROR;
return;
}
mbcsHeaderFlags=ds->readUInt32(inMBCSHeader->flags);
extOffset=(int32_t)(mbcsHeaderFlags>>8);
outputType=(uint8_t)mbcsHeaderFlags;
if(outputType==MBCS_OUTPUT_EXT_ONLY) {
/*
* extension-only file,
* contains a base name instead of normal base table data
*/
char baseName[32];
int32_t baseNameLength;
/* there is extension data after the base data, see ucnv_ext.h */
if(length<(extOffset+UCNV_EXT_INDEXES_MIN_LENGTH*4)) {
udata_printError(ds, "icupkg/ucnv_enumDependencies(): too few bytes (%d after headers) for an ICU MBCS .cnv conversion table with extension data\n",
length);
*pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
return;
}
/* swap the base name, between the header and the extension data */
const char *inBaseName=(const char *)inBytes+mbcsHeaderLength*4;
baseNameLength=(int32_t)strlen(inBaseName);
if(baseNameLength>=(int32_t)sizeof(baseName)) {
udata_printError(ds, "icupkg/ucnv_enumDependencies(%s): base name length %ld too long\n",
itemName, baseNameLength);
*pErrorCode=U_UNSUPPORTED_ERROR;
return;
}
ds->swapInvChars(ds, inBaseName, baseNameLength+1, baseName, pErrorCode);
checkIDSuffix(itemName, baseName, -1, ".cnv", check, context, pErrorCode);
}
}
/*
* Enumerate one resource item and its children and extract dependencies from
* aliases.
* Code adapted from ures_preflightResource() and ures_swapResource().
*/
static void
ures_enumDependencies(const UDataSwapper *ds,
const char *itemName,
const Resource *inBundle, int32_t length,
Resource res, const char *inKey, int32_t depth,
CheckDependency check, void *context,
UErrorCode *pErrorCode) {
const Resource *p;
int32_t offset;
if(res==0 || RES_GET_TYPE(res)==URES_INT) {
/* empty string or integer, nothing to do */
return;
}
/* all other types use an offset to point to their data */
offset=(int32_t)RES_GET_OFFSET(res);
if(0<=length && length<=offset) {
udata_printError(ds, "icupkg/ures_enumDependencies(%s res=%08x) resource offset exceeds bundle length %d\n",
itemName, res, length);
*pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
return;
}
p=inBundle+offset;
switch(RES_GET_TYPE(res)) {
/* strings and aliases have physically the same value layout */
case URES_STRING:
// we ignore all strings except top-level strings with a %%ALIAS key
if(depth!=1) {
break;
} else {
char key[8];
int32_t keyLength;
keyLength=(int32_t)strlen(inKey);
if(keyLength!=gAliasKeyLength) {
break;
}
ds->swapInvChars(ds, inKey, gAliasKeyLength+1, key, pErrorCode);
if(U_FAILURE(*pErrorCode)) {
udata_printError(ds, "icupkg/ures_enumDependencies(%s res=%08x) string key contains variant characters\n",
itemName, res);
return;
}
if(0!=strcmp(key, gAliasKey)) {
break;
}
}
// for the top-level %%ALIAS string fall through to URES_ALIAS
case URES_ALIAS:
{
char localeID[32];
const uint16_t *p16;
int32_t i, stringLength;
uint16_t u16, ored16;
stringLength=udata_readInt32(ds, (int32_t)*p);
/* top=offset+1+(string length +1)/2 rounded up */
offset+=1+((stringLength+1)+1)/2;
if(offset>length) {
break; // the resource does not fit into the bundle, print error below
}
// extract the locale ID from alias strings like
// locale_ID/key1/key2/key3
// locale_ID
if(U_IS_BIG_ENDIAN==ds->inIsBigEndian) {
u16=0x2f; // slash in local endianness
} else {
u16=0x2f00; // slash in opposite endianness
}
p16=(const uint16_t *)(p+1); // Unicode string contents
// search for the first slash
for(i=0; i<stringLength && p16[i]!=u16; ++i) {}
if(RES_GET_TYPE(res)==URES_ALIAS) {
// ignore aliases with an initial slash:
// /ICUDATA/... and /pkgname/... go to a different package
// /LOCALE/... are for dynamic sideways fallbacks and don't go to a fixed bundle
if(i==0) {
break; // initial slash ('/')
}
// ignore the intra-bundle path starting from the first slash ('/')
stringLength=i;
} else /* URES_STRING */ {
// the whole string should only consist of a locale ID
if(i!=stringLength) {
udata_printError(ds, "icupkg/ures_enumDependencies(%s res=%08x) %%ALIAS contains a '/'\n",
itemName, res);
*pErrorCode=U_UNSUPPORTED_ERROR;
return;
}
}
// convert the Unicode string to char * and
// check that it has a bundle path but no package
if(stringLength>=(int32_t)sizeof(localeID)) {
udata_printError(ds, "icupkg/ures_enumDependencies(%s res=%08x) alias locale ID length %ld too long\n",
itemName, res, stringLength);
*pErrorCode=U_BUFFER_OVERFLOW_ERROR;
return;
}
// convert the alias Unicode string to US-ASCII
ored16=0;
if(U_IS_BIG_ENDIAN==ds->inIsBigEndian) {
for(i=0; i<stringLength; ++i) {
u16=p16[i];
ored16|=u16;
localeID[i]=(char)u16;
}
} else {
for(i=0; i<stringLength; ++i) {
u16=p16[i];
ored16|=u16;
localeID[i]=(char)(u16>>8);
}
ored16=(uint16_t)((ored16<<8)|(ored16>>8));
}
localeID[stringLength]=0;
if(ored16>0x7f) {
udata_printError(ds, "icupkg/ures_enumDependencies(%s res=%08x) alias string contains non-ASCII characters\n",
itemName, res);
*pErrorCode=U_INVALID_CHAR_FOUND;
return;
}
#if (U_CHARSET_FAMILY==U_EBCDIC_FAMILY)
// swap to EBCDIC
// our swapper is probably not the right one, but
// the function uses it only for printing errors
uprv_ebcdicFromAscii(ds, localeID, stringLength, localeID, pErrorCode);
if(U_FAILURE(*pErrorCode)) {
return;
}
#endif
#if U_CHARSET_FAMILY!=U_ASCII_FAMILY && U_CHARSET_FAMILY!=U_EBCDIC_FAMILY
# error Unknown U_CHARSET_FAMILY value!
#endif
checkIDSuffix(itemName, localeID, -1, ".res", check, context, pErrorCode);
}
break;
case URES_TABLE:
case URES_TABLE32:
{
const uint16_t *pKey16;
const int32_t *pKey32;
Resource item;
int32_t i, count;
if(RES_GET_TYPE(res)==URES_TABLE) {
/* get table item count */
pKey16=(const uint16_t *)p;
count=ds->readUInt16(*pKey16++);
pKey32=NULL;
/* top=((1+ table item count)/2 rounded up)+(table item count) */
offset+=((1+count)+1)/2;
} else {
/* get table item count */
pKey32=(const int32_t *)p;
count=udata_readInt32(ds, *pKey32++);
pKey16=NULL;
/* top=(1+ table item count)+(table item count) */
offset+=1+count;
}
p=inBundle+offset; /* pointer to table resources */
offset+=count;
if(offset>length) {
break; // the resource does not fit into the bundle, print error below
}
/* recurse */
for(i=0; i<count; ++i) {
item=ds->readUInt32(*p++);
ures_enumDependencies(
ds, itemName, inBundle, length, item,
((const char *)inBundle)+
(pKey16!=NULL ?
ds->readUInt16(pKey16[i]) :
udata_readInt32(ds, pKey32[i])),
depth+1,
check, context,
pErrorCode);
if(U_FAILURE(*pErrorCode)) {
udata_printError(ds, "icupkg/ures_enumDependencies(%s table res=%08x)[%d].recurse(%08x) failed\n",
itemName, res, i, item);
break;
}
}
}
break;
case URES_ARRAY:
{
Resource item;
int32_t i, count;
/* top=offset+1+(array length) */
count=udata_readInt32(ds, (int32_t)*p++);
offset+=1+count;
if(offset>length) {
break; // the resource does not fit into the bundle, print error below
}
/* recurse */
for(i=0; i<count; ++i) {
item=ds->readUInt32(*p++);
ures_enumDependencies(
ds, itemName, inBundle, length,
item, NULL, depth+1,
check, context,
pErrorCode);
if(U_FAILURE(*pErrorCode)) {
udata_printError(ds, "icupkg/ures_enumDependencies(%s array res=%08x)[%d].recurse(%08x) failed\n",
itemName, res, i, item);
break;
}
}
}
break;
default:
break;
}
if(U_FAILURE(*pErrorCode)) {
/* nothing to do */
} else if(0<=length && length<offset) {
udata_printError(ds, "icupkg/ures_enumDependencies(%s res=%08x) resource limit exceeds bundle length %d\n",
itemName, res, length);
*pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
}
}