icuSources/common/ucol_swp.cpp

   1 /*
   2 *******************************************************************************
   3 *
   4 *   Copyright (C) 2003-2010, International Business Machines
   5 *   Corporation and others.  All Rights Reserved.
   6 *
   7 *******************************************************************************
   8 *   file name:  ucol_swp.c
   9 *   encoding:   US-ASCII
  10 *   tab size:   8 (not used)
  11 *   indentation:4
  12 *
  13 *   created on: 2003sep10
  14 *   created by: Markus W. Scherer
  15 *
  16 *   Swap collation binaries.
  17 */
  18
  19 #include "unicode/udata.h" /* UDataInfo */
  20 #include "utrie.h"
  21 #include "udataswp.h"
  22 #include "cmemory.h"
  23 #include "ucol_imp.h"
  24 #include "ucol_swp.h"
  25
  26 /* swapping ----------------------------------------------------------------- */
  27
  28 /*
  29  * This performs data swapping for a folded trie (see utrie.c for details).
  30  */
  31
  32 U_CAPI int32_t U_EXPORT2
  33 utrie_swap(const UDataSwapper *ds,
  34            const void *inData, int32_t length, void *outData,
  35            UErrorCode *pErrorCode) {
  36     const UTrieHeader *inTrie;
  37     UTrieHeader trie;
  38     int32_t size;
  39     UBool dataIs32;
  40
  41     if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
  42         return 0;
  43     }
  44     if(ds==NULL || inData==NULL || (length>=0 && outData==NULL)) {
  45         *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
  46         return 0;
  47     }
  48
  49     /* setup and swapping */
  50     if(length>=0 && (uint32_t)length<sizeof(UTrieHeader)) {
  51         *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
  52         return 0;
  53     }
  54
  55     inTrie=(const UTrieHeader *)inData;
  56     trie.signature=ds->readUInt32(inTrie->signature);
  57     trie.options=ds->readUInt32(inTrie->options);
  58     trie.indexLength=udata_readInt32(ds, inTrie->indexLength);
  59     trie.dataLength=udata_readInt32(ds, inTrie->dataLength);
  60
  61     if( trie.signature!=0x54726965 ||
  62         (trie.options&UTRIE_OPTIONS_SHIFT_MASK)!=UTRIE_SHIFT ||
  63         ((trie.options>>UTRIE_OPTIONS_INDEX_SHIFT)&UTRIE_OPTIONS_SHIFT_MASK)!=UTRIE_INDEX_SHIFT ||
  64         trie.indexLength<UTRIE_BMP_INDEX_LENGTH ||
  65         (trie.indexLength&(UTRIE_SURROGATE_BLOCK_COUNT-1))!=0 ||
  66         trie.dataLength<UTRIE_DATA_BLOCK_LENGTH ||
  67         (trie.dataLength&(UTRIE_DATA_GRANULARITY-1))!=0 ||
  68         ((trie.options&UTRIE_OPTIONS_LATIN1_IS_LINEAR)!=0 && trie.dataLength<(UTRIE_DATA_BLOCK_LENGTH+0x100))
  69     ) {
  70         *pErrorCode=U_INVALID_FORMAT_ERROR; /* not a UTrie */
  71         return 0;
  72     }
  73
  74     dataIs32=(UBool)((trie.options&UTRIE_OPTIONS_DATA_IS_32_BIT)!=0);
  75     size=sizeof(UTrieHeader)+trie.indexLength*2+trie.dataLength*(dataIs32?4:2);
  76
  77     if(length>=0) {
  78         UTrieHeader *outTrie;
  79
  80         if(length<size) {
  81             *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
  82             return 0;
  83         }
  84
  85         outTrie=(UTrieHeader *)outData;
  86
  87         /* swap the header */
  88         ds->swapArray32(ds, inTrie, sizeof(UTrieHeader), outTrie, pErrorCode);
  89
  90         /* swap the index and the data */
  91         if(dataIs32) {
  92             ds->swapArray16(ds, inTrie+1, trie.indexLength*2, outTrie+1, pErrorCode);
  93             ds->swapArray32(ds, (const uint16_t *)(inTrie+1)+trie.indexLength, trie.dataLength*4,
  94                                      (uint16_t *)(outTrie+1)+trie.indexLength, pErrorCode);
  95         } else {
  96             ds->swapArray16(ds, inTrie+1, (trie.indexLength+trie.dataLength)*2, outTrie+1, pErrorCode);
  97         }
  98     }
  99
 100     return size;
 101 }
 102
 103 #if !UCONFIG_NO_COLLATION
 104
 105 /* Modified copy of the beginning of ucol_swapBinary(). */
 106 U_CAPI UBool U_EXPORT2
 107 ucol_looksLikeCollationBinary(const UDataSwapper *ds,
 108                               const void *inData, int32_t length) {
 109     const uint8_t *inBytes;
 110     const UCATableHeader *inHeader;
 111     UCATableHeader header;
 112
 113     if(ds==NULL || inData==NULL || length<-1) {
 114         return FALSE;
 115     }
 116
 117     inBytes=(const uint8_t *)inData;
 118     inHeader=(const UCATableHeader *)inData;
 119
 120     /*
 121      * The collation binary must contain at least the UCATableHeader,
 122      * starting with its size field.
 123      * sizeof(UCATableHeader)==42*4 in ICU 2.8
 124      * check the length against the header size before reading the size field
 125      */
 126     uprv_memset(&header, 0, sizeof(header));
 127     if(length<0) {
 128         header.size=udata_readInt32(ds, inHeader->size);
 129     } else if((length<(42*4) || length<(header.size=udata_readInt32(ds, inHeader->size)))) {
 130         return FALSE;
 131     }
 132
 133     header.magic=ds->readUInt32(inHeader->magic);
 134     if(!(
 135         header.magic==UCOL_HEADER_MAGIC &&
 136         inHeader->formatVersion[0]==3 /*&&
 137         inHeader->formatVersion[1]>=0*/
 138     )) {
 139         return FALSE;
 140     }
 141
 142     if(inHeader->isBigEndian!=ds->inIsBigEndian || inHeader->charSetFamily!=ds->inCharset) {
 143         return FALSE;
 144     }
 145
 146     return TRUE;
 147 }
 148
 149 /* swap a header-less collation binary, inside a resource bundle or ucadata.icu */
 150 U_CAPI int32_t U_EXPORT2
 151 ucol_swapBinary(const UDataSwapper *ds,
 152                 const void *inData, int32_t length, void *outData,
 153                 UErrorCode *pErrorCode) {
 154     const uint8_t *inBytes;
 155     uint8_t *outBytes;
 156
 157     const UCATableHeader *inHeader;
 158     UCATableHeader *outHeader;
 159     UCATableHeader header;
 160
 161     uint32_t count;
 162
 163     /* argument checking in case we were not called from ucol_swap() */
 164     if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
 165         return 0;
 166     }
 167     if(ds==NULL || inData==NULL || length<-1 || (length>0 && outData==NULL)) {
 168         *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
 169         return 0;
 170     }
 171
 172     inBytes=(const uint8_t *)inData;
 173     outBytes=(uint8_t *)outData;
 174
 175     inHeader=(const UCATableHeader *)inData;
 176     outHeader=(UCATableHeader *)outData;
 177
 178     /*
 179      * The collation binary must contain at least the UCATableHeader,
 180      * starting with its size field.
 181      * sizeof(UCATableHeader)==42*4 in ICU 2.8
 182      * check the length against the header size before reading the size field
 183      */
 184     uprv_memset(&header, 0, sizeof(header));
 185     if(length<0) {
 186         header.size=udata_readInt32(ds, inHeader->size);
 187     } else if((length<(42*4) || length<(header.size=udata_readInt32(ds, inHeader->size)))) {
 188         udata_printError(ds, "ucol_swapBinary(): too few bytes (%d after header) for collation data\n",
 189                          length);
 190         *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
 191         return 0;
 192     }
 193
 194     header.magic=ds->readUInt32(inHeader->magic);
 195     if(!(
 196         header.magic==UCOL_HEADER_MAGIC &&
 197         inHeader->formatVersion[0]==3 /*&&
 198         inHeader->formatVersion[1]>=0*/
 199     )) {
 200         udata_printError(ds, "ucol_swapBinary(): magic 0x%08x or format version %02x.%02x is not a collation binary\n",
 201                          header.magic,
 202                          inHeader->formatVersion[0], inHeader->formatVersion[1]);
 203         *pErrorCode=U_UNSUPPORTED_ERROR;
 204         return 0;
 205     }
 206
 207     if(inHeader->isBigEndian!=ds->inIsBigEndian || inHeader->charSetFamily!=ds->inCharset) {
 208         udata_printError(ds, "ucol_swapBinary(): endianness %d or charset %d does not match the swapper\n",
 209                          inHeader->isBigEndian, inHeader->charSetFamily);
 210         *pErrorCode=U_INVALID_FORMAT_ERROR;
 211         return 0;
 212     }
 213
 214     if(length>=0) {
 215         /* copy everything, takes care of data that needs no swapping */
 216         if(inBytes!=outBytes) {
 217             uprv_memcpy(outBytes, inBytes, header.size);
 218         }
 219
 220         /* swap the necessary pieces in the order of their occurrence in the data */
 221
 222         /* read more of the UCATableHeader (the size field was read above) */
 223         header.options=                 ds->readUInt32(inHeader->options);
 224         header.UCAConsts=               ds->readUInt32(inHeader->UCAConsts);
 225         header.contractionUCACombos=    ds->readUInt32(inHeader->contractionUCACombos);
 226         header.mappingPosition=         ds->readUInt32(inHeader->mappingPosition);
 227         header.expansion=               ds->readUInt32(inHeader->expansion);
 228         header.contractionIndex=        ds->readUInt32(inHeader->contractionIndex);
 229         header.contractionCEs=          ds->readUInt32(inHeader->contractionCEs);
 230         header.contractionSize=         ds->readUInt32(inHeader->contractionSize);
 231         header.endExpansionCE=          ds->readUInt32(inHeader->endExpansionCE);
 232         header.expansionCESize=         ds->readUInt32(inHeader->expansionCESize);
 233         header.endExpansionCECount=     udata_readInt32(ds, inHeader->endExpansionCECount);
 234         header.contractionUCACombosSize=udata_readInt32(ds, inHeader->contractionUCACombosSize);
 235         header.scriptToLeadByte=        ds->readUInt32(inHeader->scriptToLeadByte);
 236         header.leadByteToScript=        ds->readUInt32(inHeader->leadByteToScript);
 237
 238         /* swap the 32-bit integers in the header */
 239         ds->swapArray32(ds, inHeader, (int32_t)((const char *)&inHeader->jamoSpecial-(const char *)inHeader),
 240                            outHeader, pErrorCode);
 241         ds->swapArray32(ds, &(inHeader->scriptToLeadByte), sizeof(header.scriptToLeadByte) + sizeof(header.leadByteToScript),
 242                            &(outHeader->scriptToLeadByte), pErrorCode);
 243         /* set the output platform properties */
 244         outHeader->isBigEndian=ds->outIsBigEndian;
 245         outHeader->charSetFamily=ds->outCharset;
 246
 247         /* swap the options */
 248         if(header.options!=0) {
 249             ds->swapArray32(ds, inBytes+header.options, header.expansion-header.options,
 250                                outBytes+header.options, pErrorCode);
 251         }
 252
 253         /* swap the expansions */
 254         if(header.mappingPosition!=0 && header.expansion!=0) {
 255             if(header.contractionIndex!=0) {
 256                 /* expansions bounded by contractions */
 257                 count=header.contractionIndex-header.expansion;
 258             } else {
 259                 /* no contractions: expansions bounded by the main trie */
 260                 count=header.mappingPosition-header.expansion;
 261             }
 262             ds->swapArray32(ds, inBytes+header.expansion, (int32_t)count,
 263                                outBytes+header.expansion, pErrorCode);
 264         }
 265
 266         /* swap the contractions */
 267         if(header.contractionSize!=0) {
 268             /* contractionIndex: UChar[] */
 269             ds->swapArray16(ds, inBytes+header.contractionIndex, header.contractionSize*2,
 270                                outBytes+header.contractionIndex, pErrorCode);
 271
 272             /* contractionCEs: CEs[] */
 273             ds->swapArray32(ds, inBytes+header.contractionCEs, header.contractionSize*4,
 274                                outBytes+header.contractionCEs, pErrorCode);
 275         }
 276
 277         /* swap the main trie */
 278         if(header.mappingPosition!=0) {
 279             count=header.endExpansionCE-header.mappingPosition;
 280             utrie_swap(ds, inBytes+header.mappingPosition, (int32_t)count,
 281                           outBytes+header.mappingPosition, pErrorCode);
 282         }
 283
 284         /* swap the max expansion table */
 285         if(header.endExpansionCECount!=0) {
 286             ds->swapArray32(ds, inBytes+header.endExpansionCE, header.endExpansionCECount*4,
 287                                outBytes+header.endExpansionCE, pErrorCode);
 288         }
 289
 290         /* expansionCESize, unsafeCP, contrEndCP: uint8_t[], no need to swap */
 291
 292         /* swap UCA constants */
 293         if(header.UCAConsts!=0) {
 294             /*
 295              * if UCAConsts!=0 then contractionUCACombos because we are swapping
 296              * the UCA data file, and we know that the UCA contains contractions
 297              */
 298             count=header.contractionUCACombos-header.UCAConsts;
 299             ds->swapArray32(ds, inBytes+header.UCAConsts, header.contractionUCACombos-header.UCAConsts,
 300                                outBytes+header.UCAConsts, pErrorCode);
 301         }
 302
 303         /* swap UCA contractions */
 304         if(header.contractionUCACombosSize!=0) {
 305             count=header.contractionUCACombosSize*inHeader->contractionUCACombosWidth*U_SIZEOF_UCHAR;
 306             ds->swapArray16(ds, inBytes+header.contractionUCACombos, (int32_t)count,
 307                                outBytes+header.contractionUCACombos, pErrorCode);
 308         }
 309
 310         /* swap the script to lead bytes */
 311         if(header.scriptToLeadByte!=0) {
 312             int indexCount = ds->readUInt16(*((uint16_t*)(inBytes+header.scriptToLeadByte))); // each entry = 2 * uint16
 313             int dataCount = ds->readUInt16(*((uint16_t*)(inBytes+header.scriptToLeadByte + 2))); // each entry = uint16
 314             ds->swapArray16(ds, inBytes+header.scriptToLeadByte,
 315                                 4 + (4 * indexCount) + (2 * dataCount),
 316                                 outBytes+header.scriptToLeadByte, pErrorCode);
 317         }
 318
 319         /* swap the lead byte to scripts */
 320         if(header.leadByteToScript!=0) {
 321             int indexCount = ds->readUInt16(*((uint16_t*)(inBytes+header.leadByteToScript))); // each entry = uint16
 322             int dataCount = ds->readUInt16(*((uint16_t*)(inBytes+header.leadByteToScript + 2))); // each entry = uint16
 323             ds->swapArray16(ds, inBytes+header.leadByteToScript,
 324                                 4 + (2 * indexCount) + (2 * dataCount),
 325                                 outBytes+header.leadByteToScript, pErrorCode);
 326         }
 327     }
 328
 329     return header.size;
 330 }
 331
 332 /* swap ICU collation data like ucadata.icu */
 333 U_CAPI int32_t U_EXPORT2
 334 ucol_swap(const UDataSwapper *ds,
 335           const void *inData, int32_t length, void *outData,
 336           UErrorCode *pErrorCode) {
 337
 338     const UDataInfo *pInfo;
 339     int32_t headerSize, collationSize;
 340
 341     /* udata_swapDataHeader checks the arguments */
 342     headerSize=udata_swapDataHeader(ds, inData, length, outData, pErrorCode);
 343     if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
 344         return 0;
 345     }
 346
 347     /* check data format and format version */
 348     pInfo=(const UDataInfo *)((const char *)inData+4);
 349     if(!(
 350         pInfo->dataFormat[0]==0x55 &&   /* dataFormat="UCol" */
 351         pInfo->dataFormat[1]==0x43 &&
 352         pInfo->dataFormat[2]==0x6f &&
 353         pInfo->dataFormat[3]==0x6c &&
 354         pInfo->formatVersion[0]==3 /*&&
 355         pInfo->formatVersion[1]>=0*/
 356     )) {
 357         udata_printError(ds, "ucol_swap(): data format %02x.%02x.%02x.%02x (format version %02x.%02x) is not a collation file\n",
 358                          pInfo->dataFormat[0], pInfo->dataFormat[1],
 359                          pInfo->dataFormat[2], pInfo->dataFormat[3],
 360                          pInfo->formatVersion[0], pInfo->formatVersion[1]);
 361         *pErrorCode=U_UNSUPPORTED_ERROR;
 362         return 0;
 363     }
 364
 365     collationSize=ucol_swapBinary(ds,
 366                         (const char *)inData+headerSize,
 367                         length>=0 ? length-headerSize : -1,
 368                         (char *)outData+headerSize,
 369                         pErrorCode);
 370     if(U_SUCCESS(*pErrorCode)) {
 371         return headerSize+collationSize;
 372     } else {
 373         return 0;
 374     }
 375 }
 376
 377 /* swap inverse UCA collation data (invuca.icu) */
 378 U_CAPI int32_t U_EXPORT2
 379 ucol_swapInverseUCA(const UDataSwapper *ds,
 380                     const void *inData, int32_t length, void *outData,
 381                     UErrorCode *pErrorCode) {
 382     const UDataInfo *pInfo;
 383     int32_t headerSize;
 384
 385     const uint8_t *inBytes;
 386     uint8_t *outBytes;
 387
 388     const InverseUCATableHeader *inHeader;
 389     InverseUCATableHeader *outHeader;
 390     InverseUCATableHeader header={ 0,0,0,0,0,{0,0,0,0},{0,0,0,0,0,0,0,0} };
 391
 392     /* udata_swapDataHeader checks the arguments */
 393     headerSize=udata_swapDataHeader(ds, inData, length, outData, pErrorCode);
 394     if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
 395         return 0;
 396     }
 397
 398     /* check data format and format version */
 399     pInfo=(const UDataInfo *)((const char *)inData+4);
 400     if(!(
 401         pInfo->dataFormat[0]==0x49 &&   /* dataFormat="InvC" */
 402         pInfo->dataFormat[1]==0x6e &&
 403         pInfo->dataFormat[2]==0x76 &&
 404         pInfo->dataFormat[3]==0x43 &&
 405         pInfo->formatVersion[0]==2 &&
 406         pInfo->formatVersion[1]>=1
 407     )) {
 408         udata_printError(ds, "ucol_swapInverseUCA(): data format %02x.%02x.%02x.%02x (format version %02x.%02x) is not an inverse UCA collation file\n",
 409                          pInfo->dataFormat[0], pInfo->dataFormat[1],
 410                          pInfo->dataFormat[2], pInfo->dataFormat[3],
 411                          pInfo->formatVersion[0], pInfo->formatVersion[1]);
 412         *pErrorCode=U_UNSUPPORTED_ERROR;
 413         return 0;
 414     }
 415
 416     inBytes=(const uint8_t *)inData+headerSize;
 417     outBytes=(uint8_t *)outData+headerSize;
 418
 419     inHeader=(const InverseUCATableHeader *)inBytes;
 420     outHeader=(InverseUCATableHeader *)outBytes;
 421
 422     /*
 423      * The inverse UCA collation binary must contain at least the InverseUCATableHeader,
 424      * starting with its size field.
 425      * sizeof(UCATableHeader)==8*4 in ICU 2.8
 426      * check the length against the header size before reading the size field
 427      */
 428     if(length<0) {
 429         header.byteSize=udata_readInt32(ds, inHeader->byteSize);
 430     } else if(
 431         ((length-headerSize)<(8*4) ||
 432          (uint32_t)(length-headerSize)<(header.byteSize=udata_readInt32(ds, inHeader->byteSize)))
 433     ) {
 434         udata_printError(ds, "ucol_swapInverseUCA(): too few bytes (%d after header) for inverse UCA collation data\n",
 435                          length);
 436         *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
 437         return 0;
 438     }
 439
 440     if(length>=0) {
 441         /* copy everything, takes care of data that needs no swapping */
 442         if(inBytes!=outBytes) {
 443             uprv_memcpy(outBytes, inBytes, header.byteSize);
 444         }
 445
 446         /* swap the necessary pieces in the order of their occurrence in the data */
 447
 448         /* read more of the InverseUCATableHeader (the byteSize field was read above) */
 449         header.tableSize=   ds->readUInt32(inHeader->tableSize);
 450         header.contsSize=   ds->readUInt32(inHeader->contsSize);
 451         header.table=       ds->readUInt32(inHeader->table);
 452         header.conts=       ds->readUInt32(inHeader->conts);
 453
 454         /* swap the 32-bit integers in the header */
 455         ds->swapArray32(ds, inHeader, 5*4, outHeader, pErrorCode);
 456
 457         /* swap the inverse table; tableSize counts uint32_t[3] rows */
 458         ds->swapArray32(ds, inBytes+header.table, header.tableSize*3*4,
 459                            outBytes+header.table, pErrorCode);
 460
 461         /* swap the continuation table; contsSize counts UChars */
 462         ds->swapArray16(ds, inBytes+header.conts, header.contsSize*U_SIZEOF_UCHAR,
 463                            outBytes+header.conts, pErrorCode);
 464     }
 465
 466     return headerSize+header.byteSize;
 467 }
 468
 469 #endif /* #if !UCONFIG_NO_COLLATION */