icuSources/common/udataswp.c

   1 /*
   2 *******************************************************************************
   3 *
   4 *   Copyright (C) 2003, International Business Machines
   5 *   Corporation and others.  All Rights Reserved.
   6 *
   7 *******************************************************************************
   8 *   file name:  udataswp.c
   9 *   encoding:   US-ASCII
  10 *   tab size:   8 (not used)
  11 *   indentation:4
  12 *
  13 *   created on: 2003jun05
  14 *   created by: Markus W. Scherer
  15 *
  16 *   Definitions for ICU data transformations for different platforms,
  17 *   changing between big- and little-endian data and/or between
  18 *   charset families (ASCII<->EBCDIC).
  19 */
  20
  21 #include <stdarg.h>
  22 #include "unicode/utypes.h"
  23 #include "unicode/udata.h" /* UDataInfo */
  24 #include "ucmndata.h" /* DataHeader */
  25 #include "cmemory.h"
  26 #include "udataswp.h"
  27
  28 /* swapping primitives ------------------------------------------------------ */
  29
  30 static int32_t U_CALLCONV
  31 uprv_swapArray16(const UDataSwapper *ds,
  32                  const void *inData, int32_t length, void *outData,
  33                  UErrorCode *pErrorCode) {
  34     const uint16_t *p;
  35     uint16_t *q;
  36     int32_t count;
  37     uint16_t x;
  38
  39     if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
  40         return 0;
  41     }
  42     if(ds==NULL || inData==NULL || length<0 || (length&1)!=0 || outData==NULL) {
  43         *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
  44         return 0;
  45     }
  46
  47     /* setup and swapping */
  48     p=(const uint16_t *)inData;
  49     q=(uint16_t *)outData;
  50     count=length/2;
  51     while(count>0) {
  52         x=*p++;
  53         *q++=(uint16_t)((x<<8)|(x>>8));
  54         --count;
  55     }
  56
  57     return length;
  58 }
  59
  60 static int32_t U_CALLCONV
  61 uprv_copyArray16(const UDataSwapper *ds,
  62                  const void *inData, int32_t length, void *outData,
  63                  UErrorCode *pErrorCode) {
  64     if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
  65         return 0;
  66     }
  67     if(ds==NULL || inData==NULL || length<0 || (length&1)!=0 || outData==NULL) {
  68         *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
  69         return 0;
  70     }
  71
  72     if(length>0 && inData!=outData) {
  73         uprv_memcpy(outData, inData, length);
  74     }
  75     return length;
  76 }
  77
  78 static int32_t U_CALLCONV
  79 uprv_swapArray32(const UDataSwapper *ds,
  80                  const void *inData, int32_t length, void *outData,
  81                  UErrorCode *pErrorCode) {
  82     const uint32_t *p;
  83     uint32_t *q;
  84     int32_t count;
  85     uint32_t x;
  86
  87     if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
  88         return 0;
  89     }
  90     if(ds==NULL || inData==NULL || length<0 || (length&3)!=0 || outData==NULL) {
  91         *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
  92         return 0;
  93     }
  94
  95     /* setup and swapping */
  96     p=(const uint32_t *)inData;
  97     q=(uint32_t *)outData;
  98     count=length/4;
  99     while(count>0) {
 100         x=*p++;
 101         *q++=(uint32_t)((x<<24)|((x<<8)&0xff0000)|((x>>8)&0xff00)|(x>>24));
 102         --count;
 103     }
 104
 105     return length;
 106 }
 107
 108 static int32_t U_CALLCONV
 109 uprv_copyArray32(const UDataSwapper *ds,
 110                  const void *inData, int32_t length, void *outData,
 111                  UErrorCode *pErrorCode) {
 112     if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
 113         return 0;
 114     }
 115     if(ds==NULL || inData==NULL || length<0 || (length&3)!=0 || outData==NULL) {
 116         *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
 117         return 0;
 118     }
 119
 120     if(length>0 && inData!=outData) {
 121         uprv_memcpy(outData, inData, length);
 122     }
 123     return length;
 124 }
 125
 126 static uint16_t U_CALLCONV
 127 uprv_readSwapUInt16(uint16_t x) {
 128     return (uint16_t)((x<<8)|(x>>8));
 129 }
 130
 131 static uint16_t U_CALLCONV
 132 uprv_readDirectUInt16(uint16_t x) {
 133     return x;
 134 }
 135
 136 static uint32_t U_CALLCONV
 137 uprv_readSwapUInt32(uint32_t x) {
 138     return (uint32_t)((x<<24)|((x<<8)&0xff0000)|((x>>8)&0xff00)|(x>>24));
 139 }
 140
 141 static uint32_t U_CALLCONV
 142 uprv_readDirectUInt32(uint32_t x) {
 143     return x;
 144 }
 145
 146 static void U_CALLCONV
 147 uprv_writeSwapUInt16(uint16_t *p, uint16_t x) {
 148     *p=(uint16_t)((x<<8)|(x>>8));
 149 }
 150
 151 static void U_CALLCONV
 152 uprv_writeDirectUInt16(uint16_t *p, uint16_t x) {
 153     *p=x;
 154 }
 155
 156 static void U_CALLCONV
 157 uprv_writeSwapUInt32(uint32_t *p, uint32_t x) {
 158     *p=(uint32_t)((x<<24)|((x<<8)&0xff0000)|((x>>8)&0xff00)|(x>>24));
 159 }
 160
 161 static void U_CALLCONV
 162 uprv_writeDirectUInt32(uint32_t *p, uint32_t x) {
 163     *p=x;
 164 }
 165
 166 U_CAPI int16_t U_EXPORT2
 167 udata_readInt16(const UDataSwapper *ds, int16_t x) {
 168     return (int16_t)ds->readUInt16((uint16_t)x);
 169 }
 170
 171 U_CAPI int32_t U_EXPORT2
 172 udata_readInt32(const UDataSwapper *ds, int32_t x) {
 173     return (int32_t)ds->readUInt32((uint32_t)x);
 174 }
 175
 176 /**
 177  * Swap a block of invariant, NUL-terminated strings, but not padding
 178  * bytes after the last string.
 179  * @internal
 180  */
 181 U_CAPI int32_t U_EXPORT2
 182 udata_swapInvStringBlock(const UDataSwapper *ds,
 183                          const void *inData, int32_t length, void *outData,
 184                          UErrorCode *pErrorCode) {
 185     const char *inChars;
 186     int32_t stringsLength;
 187
 188     if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
 189         return 0;
 190     }
 191     if(ds==NULL || inData==NULL || length<0 || (length>0 && outData==NULL)) {
 192         *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
 193         return 0;
 194     }
 195
 196     /* reduce the strings length to not include bytes after the last NUL */
 197     inChars=(const char *)inData;
 198     stringsLength=length;
 199     while(stringsLength>0 && inChars[stringsLength-1]!=0) {
 200         --stringsLength;
 201     }
 202
 203     /* swap up to the last NUL */
 204     ds->swapInvChars(ds, inData, stringsLength, outData, pErrorCode);
 205
 206     /* copy the bytes after the last NUL */
 207     if(inData!=outData && length>stringsLength) {
 208         uprv_memcpy((char *)outData+stringsLength, inChars+stringsLength, length-stringsLength);
 209     }
 210
 211     /* return the length including padding bytes */
 212     if(U_SUCCESS(*pErrorCode)) {
 213         return length;
 214     } else {
 215         return 0;
 216     }
 217 }
 218
 219 U_CAPI void U_EXPORT2
 220 udata_printError(const UDataSwapper *ds,
 221                  const char *fmt,
 222                  ...) {
 223     va_list args;
 224
 225     if(ds->printError!=NULL) {
 226         va_start(args, fmt);
 227         ds->printError(ds->printErrorContext, fmt, args);
 228         va_end(args);
 229     }
 230 }
 231
 232 /* swap a data header ------------------------------------------------------- */
 233
 234 U_CAPI int32_t U_EXPORT2
 235 udata_swapDataHeader(const UDataSwapper *ds,
 236                      const void *inData, int32_t length, void *outData,
 237                      UErrorCode *pErrorCode) {
 238     const DataHeader *pHeader;
 239     uint16_t headerSize, infoSize;
 240
 241     /* argument checking */
 242     if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
 243         return 0;
 244     }
 245     if(ds==NULL || inData==NULL || length<-1 || (length>0 && outData==NULL)) {
 246         *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
 247         return 0;
 248     }
 249
 250     /* check minimum length and magic bytes */
 251     pHeader=(const DataHeader *)inData;
 252     if( (length>=0 && length<sizeof(DataHeader)) ||
 253         pHeader->dataHeader.magic1!=0xda ||
 254         pHeader->dataHeader.magic2!=0x27 ||
 255         pHeader->info.sizeofUChar!=2
 256     ) {
 257         udata_printError(ds, "udata_swapDataHeader(): initial bytes do not look like ICU data\n");
 258         *pErrorCode=U_UNSUPPORTED_ERROR;
 259         return 0;
 260     }
 261
 262     headerSize=ds->readUInt16(pHeader->dataHeader.headerSize);
 263     infoSize=ds->readUInt16(pHeader->info.size);
 264
 265     if( headerSize<sizeof(DataHeader) ||
 266         infoSize<sizeof(UDataInfo) ||
 267         headerSize<(sizeof(pHeader->dataHeader)+infoSize) ||
 268         (length>=0 && length<headerSize)
 269     ) {
 270         udata_printError(ds, "udata_swapDataHeader(): header size mismatch - headerSize %d infoSize %d length %d\n",
 271                          headerSize, infoSize, length);
 272         *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
 273         return 0;
 274     }
 275
 276     if(length>0) {
 277         DataHeader *outHeader;
 278         const char *s;
 279         int32_t maxLength;
 280
 281         /* Most of the fields are just bytes and need no swapping. */
 282         if(inData!=outData) {
 283             uprv_memcpy(outData, inData, headerSize);
 284         }
 285         outHeader=(DataHeader *)outData;
 286
 287         outHeader->info.isBigEndian = ds->outIsBigEndian;
 288         outHeader->info.charsetFamily = ds->outCharset;
 289
 290         /* swap headerSize */
 291         ds->swapArray16(ds, &pHeader->dataHeader.headerSize, 2, &outHeader->dataHeader.headerSize, pErrorCode);
 292
 293         /* swap UDataInfo size and reservedWord */
 294         ds->swapArray16(ds, &pHeader->info.size, 4, &outHeader->info.size, pErrorCode);
 295
 296         /* swap copyright statement after the UDataInfo */
 297         infoSize+=sizeof(pHeader->dataHeader);
 298         s=(const char *)inData+infoSize;
 299         maxLength=headerSize-infoSize;
 300         /* get the length of the string */
 301         for(length=0; length<maxLength && s[length]!=0; ++length) {}
 302         /* swap the string contents */
 303         ds->swapInvChars(ds, s, length, (char *)outData+infoSize, pErrorCode);
 304     }
 305
 306     return headerSize;
 307 }
 308
 309 /* API functions ------------------------------------------------------------ */
 310
 311 U_CAPI UDataSwapper * U_EXPORT2
 312 udata_openSwapper(UBool inIsBigEndian, uint8_t inCharset,
 313                   UBool outIsBigEndian, uint8_t outCharset,
 314                   UErrorCode *pErrorCode) {
 315     UDataSwapper *swapper;
 316
 317     if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
 318         return NULL;
 319     }
 320     if(inCharset>U_EBCDIC_FAMILY || outCharset>U_EBCDIC_FAMILY) {
 321         *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
 322         return NULL;
 323     }
 324
 325     /* allocate the swapper */
 326     swapper=uprv_malloc(sizeof(UDataSwapper));
 327     if(swapper==NULL) {
 328         *pErrorCode=U_MEMORY_ALLOCATION_ERROR;
 329         return NULL;
 330     }
 331     uprv_memset(swapper, 0, sizeof(UDataSwapper));
 332
 333     /* set values and functions pointers according to in/out parameters */
 334     swapper->inIsBigEndian=inIsBigEndian;
 335     swapper->inCharset=inCharset;
 336     swapper->outIsBigEndian=outIsBigEndian;
 337     swapper->outCharset=outCharset;
 338
 339     swapper->readUInt16= inIsBigEndian==U_IS_BIG_ENDIAN ? uprv_readDirectUInt16 : uprv_readSwapUInt16;
 340     swapper->readUInt32= inIsBigEndian==U_IS_BIG_ENDIAN ? uprv_readDirectUInt32 : uprv_readSwapUInt32;
 341
 342     swapper->writeUInt16= outIsBigEndian==U_IS_BIG_ENDIAN ? uprv_writeDirectUInt16 : uprv_writeSwapUInt16;
 343     swapper->writeUInt32= outIsBigEndian==U_IS_BIG_ENDIAN ? uprv_writeDirectUInt32 : uprv_writeSwapUInt32;
 344
 345     swapper->compareInvChars= outCharset==U_ASCII_FAMILY ? uprv_compareInvAscii : uprv_compareInvEbcdic;
 346
 347     swapper->swapArray16= inIsBigEndian==outIsBigEndian ? uprv_copyArray16 : uprv_swapArray16;
 348     swapper->swapArray32= inIsBigEndian==outIsBigEndian ? uprv_copyArray32 : uprv_swapArray32;
 349
 350     if(inCharset==U_ASCII_FAMILY) {
 351         swapper->swapInvChars= outCharset==U_ASCII_FAMILY ? uprv_copyAscii : uprv_ebcdicFromAscii;
 352     } else /* U_EBCDIC_FAMILY */ {
 353         swapper->swapInvChars= outCharset==U_EBCDIC_FAMILY ? uprv_copyEbcdic : uprv_asciiFromEbcdic;
 354     }
 355
 356     return swapper;
 357 }
 358
 359 U_CAPI UDataSwapper * U_EXPORT2
 360 udata_openSwapperForInputData(const void *data, int32_t length,
 361                               UBool outIsBigEndian, uint8_t outCharset,
 362                               UErrorCode *pErrorCode) {
 363     const DataHeader *pHeader;
 364     uint16_t headerSize, infoSize;
 365     UBool inIsBigEndian;
 366     int8_t inCharset;
 367
 368     if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
 369         return NULL;
 370     }
 371     if( data==NULL ||
 372         (length>=0 && length<sizeof(DataHeader)) ||
 373         outCharset>U_EBCDIC_FAMILY
 374     ) {
 375         *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
 376         return NULL;
 377     }
 378
 379     pHeader=(const DataHeader *)data;
 380     if( (length>=0 && length<sizeof(DataHeader)) ||
 381         pHeader->dataHeader.magic1!=0xda ||
 382         pHeader->dataHeader.magic2!=0x27 ||
 383         pHeader->info.sizeofUChar!=2
 384     ) {
 385         *pErrorCode=U_UNSUPPORTED_ERROR;
 386         return 0;
 387     }
 388
 389     inIsBigEndian=(UBool)pHeader->info.isBigEndian;
 390     inCharset=pHeader->info.charsetFamily;
 391
 392     if(inIsBigEndian==U_IS_BIG_ENDIAN) {
 393         headerSize=pHeader->dataHeader.headerSize;
 394         infoSize=pHeader->info.size;
 395     } else {
 396         headerSize=uprv_readSwapUInt16(pHeader->dataHeader.headerSize);
 397         infoSize=uprv_readSwapUInt16(pHeader->info.size);
 398     }
 399
 400     if( headerSize<sizeof(DataHeader) ||
 401         infoSize<sizeof(UDataInfo) ||
 402         headerSize<(sizeof(pHeader->dataHeader)+infoSize) ||
 403         (length>=0 && length<headerSize)
 404     ) {
 405         *pErrorCode=U_UNSUPPORTED_ERROR;
 406         return 0;
 407     }
 408
 409     return udata_openSwapper(inIsBigEndian, inCharset, outIsBigEndian, outCharset, pErrorCode);
 410 }
 411
 412 U_CAPI void U_EXPORT2
 413 udata_closeSwapper(UDataSwapper *ds) {
 414     uprv_free(ds);
 415 }