1 /*
2 ******************************************************************************
3 *
4 *   Copyright (C) 1999-2011, International Business Machines
5 *   Corporation and others.  All Rights Reserved.
6 *
7 ******************************************************************************/
8 
9 
10 /*------------------------------------------------------------------------------
11  *
12  *   UCommonData   An abstract interface for dealing with ICU Common Data Files.
13  *                 ICU Common Data Files are a grouping of a number of individual
14  *                 data items (resources, converters, tables, anything) into a
15  *                 single file or dll.  The combined format includes a table of
16  *                 contents for locating the individual items by name.
17  *
18  *                 Two formats for the table of contents are supported, which is
19  *                 why there is an abstract inteface involved.
20  *
21  */
22 
23 #include "unicode/utypes.h"
24 #include "unicode/udata.h"
25 #include "cstring.h"
26 #include "ucmndata.h"
27 #include "udatamem.h"
28 
29 #if defined(UDATA_DEBUG) || defined(UDATA_DEBUG_DUMP)
30 #   include <stdio.h>
31 #endif
32 
33 U_CFUNC uint16_t
udata_getHeaderSize(const DataHeader * udh)34 udata_getHeaderSize(const DataHeader *udh) {
35     if(udh==NULL) {
36         return 0;
37     } else if(udh->info.isBigEndian==U_IS_BIG_ENDIAN) {
38         /* same endianness */
39         return udh->dataHeader.headerSize;
40     } else {
41         /* opposite endianness */
42         uint16_t x=udh->dataHeader.headerSize;
43         return (uint16_t)((x<<8)|(x>>8));
44     }
45 }
46 
47 U_CFUNC uint16_t
udata_getInfoSize(const UDataInfo * info)48 udata_getInfoSize(const UDataInfo *info) {
49     if(info==NULL) {
50         return 0;
51     } else if(info->isBigEndian==U_IS_BIG_ENDIAN) {
52         /* same endianness */
53         return info->size;
54     } else {
55         /* opposite endianness */
56         uint16_t x=info->size;
57         return (uint16_t)((x<<8)|(x>>8));
58     }
59 }
60 
61 /*-----------------------------------------------------------------------------*
62  *                                                                             *
63  *  Pointer TOCs.   TODO: This form of table-of-contents should be removed     *
64  *                  because DLLs must be relocated on loading to correct the   *
65  *                  pointer values and this operation makes shared memory      *
66  *                  mapping of the data much less likely to work.              *
67  *                                                                             *
68  *-----------------------------------------------------------------------------*/
69 typedef struct {
70     const char       *entryName;
71     const DataHeader *pHeader;
72 } PointerTOCEntry;
73 
74 
75 typedef struct  {
76     uint32_t          count;
77     uint32_t          reserved;
78     PointerTOCEntry   entry[2];   /* Actual size is from count. */
79 }  PointerTOC;
80 
81 
82 /* definition of OffsetTOC struct types moved to ucmndata.h */
83 
84 /*-----------------------------------------------------------------------------*
85  *                                                                             *
86  *    entry point lookup implementations                                       *
87  *                                                                             *
88  *-----------------------------------------------------------------------------*/
89 
90 #ifndef MIN
91 #define MIN(a,b) (((a)<(b)) ? (a) : (b))
92 #endif
93 
94 /**
95  * Compare strings where we know the shared prefix length,
96  * and advance the prefix length as we find that the strings share even more characters.
97  */
98 static int32_t
strcmpAfterPrefix(const char * s1,const char * s2,int32_t * pPrefixLength)99 strcmpAfterPrefix(const char *s1, const char *s2, int32_t *pPrefixLength) {
100     int32_t pl=*pPrefixLength;
101     int32_t cmp=0;
102     s1+=pl;
103     s2+=pl;
104     for(;;) {
105         int32_t c1=(uint8_t)*s1++;
106         int32_t c2=(uint8_t)*s2++;
107         cmp=c1-c2;
108         if(cmp!=0 || c1==0) {  /* different or done */
109             break;
110         }
111         ++pl;  /* increment shared same-prefix length */
112     }
113     *pPrefixLength=pl;
114     return cmp;
115 }
116 
117 static int32_t
offsetTOCPrefixBinarySearch(const char * s,const char * names,const UDataOffsetTOCEntry * toc,int32_t count)118 offsetTOCPrefixBinarySearch(const char *s, const char *names,
119                             const UDataOffsetTOCEntry *toc, int32_t count) {
120     int32_t start=0;
121     int32_t limit=count;
122     /*
123      * Remember the shared prefix between s, start and limit,
124      * and don't compare that shared prefix again.
125      * The shared prefix should get longer as we narrow the [start, limit[ range.
126      */
127     int32_t startPrefixLength=0;
128     int32_t limitPrefixLength=0;
129     if(count==0) {
130         return -1;
131     }
132     /*
133      * Prime the prefix lengths so that we don't keep prefixLength at 0 until
134      * both the start and limit indexes have moved.
135      * At the same time, we find if s is one of the start and (limit-1) names,
136      * and if not, exclude them from the actual binary search.
137      */
138     if(0==strcmpAfterPrefix(s, names+toc[0].nameOffset, &startPrefixLength)) {
139         return 0;
140     }
141     ++start;
142     --limit;
143     if(0==strcmpAfterPrefix(s, names+toc[limit].nameOffset, &limitPrefixLength)) {
144         return limit;
145     }
146     while(start<limit) {
147         int32_t i=(start+limit)/2;
148         int32_t prefixLength=MIN(startPrefixLength, limitPrefixLength);
149         int32_t cmp=strcmpAfterPrefix(s, names+toc[i].nameOffset, &prefixLength);
150         if(cmp<0) {
151             limit=i;
152             limitPrefixLength=prefixLength;
153         } else if(cmp==0) {
154             return i;
155         } else {
156             start=i+1;
157             startPrefixLength=prefixLength;
158         }
159     }
160     return -1;
161 }
162 
163 static int32_t
pointerTOCPrefixBinarySearch(const char * s,const PointerTOCEntry * toc,int32_t count)164 pointerTOCPrefixBinarySearch(const char *s, const PointerTOCEntry *toc, int32_t count) {
165     int32_t start=0;
166     int32_t limit=count;
167     /*
168      * Remember the shared prefix between s, start and limit,
169      * and don't compare that shared prefix again.
170      * The shared prefix should get longer as we narrow the [start, limit[ range.
171      */
172     int32_t startPrefixLength=0;
173     int32_t limitPrefixLength=0;
174     if(count==0) {
175         return -1;
176     }
177     /*
178      * Prime the prefix lengths so that we don't keep prefixLength at 0 until
179      * both the start and limit indexes have moved.
180      * At the same time, we find if s is one of the start and (limit-1) names,
181      * and if not, exclude them from the actual binary search.
182      */
183     if(0==strcmpAfterPrefix(s, toc[0].entryName, &startPrefixLength)) {
184         return 0;
185     }
186     ++start;
187     --limit;
188     if(0==strcmpAfterPrefix(s, toc[limit].entryName, &limitPrefixLength)) {
189         return limit;
190     }
191     while(start<limit) {
192         int32_t i=(start+limit)/2;
193         int32_t prefixLength=MIN(startPrefixLength, limitPrefixLength);
194         int32_t cmp=strcmpAfterPrefix(s, toc[i].entryName, &prefixLength);
195         if(cmp<0) {
196             limit=i;
197             limitPrefixLength=prefixLength;
198         } else if(cmp==0) {
199             return i;
200         } else {
201             start=i+1;
202             startPrefixLength=prefixLength;
203         }
204     }
205     return -1;
206 }
207 
offsetTOCEntryCount(const UDataMemory * pData)208 static uint32_t offsetTOCEntryCount(const UDataMemory *pData) {
209     int32_t          retVal=0;
210     const UDataOffsetTOC *toc = (UDataOffsetTOC *)pData->toc;
211     if (toc != NULL) {
212         retVal = toc->count;
213     }
214     return retVal;
215 }
216 
217 static const DataHeader *
offsetTOCLookupFn(const UDataMemory * pData,const char * tocEntryName,int32_t * pLength,UErrorCode * pErrorCode)218 offsetTOCLookupFn(const UDataMemory *pData,
219                   const char *tocEntryName,
220                   int32_t *pLength,
221                   UErrorCode *pErrorCode) {
222     const UDataOffsetTOC  *toc = (UDataOffsetTOC *)pData->toc;
223     if(toc!=NULL) {
224         const char *base=(const char *)toc;
225         int32_t number, count=(int32_t)toc->count;
226 
227         /* perform a binary search for the data in the common data's table of contents */
228 #if defined (UDATA_DEBUG_DUMP)
229         /* list the contents of the TOC each time .. not recommended */
230         for(number=0; number<count; ++number) {
231             fprintf(stderr, "\tx%d: %s\n", number, &base[toc->entry[number].nameOffset]);
232         }
233 #endif
234         number=offsetTOCPrefixBinarySearch(tocEntryName, base, toc->entry, count);
235         if(number>=0) {
236             /* found it */
237             const UDataOffsetTOCEntry *entry=toc->entry+number;
238 #ifdef UDATA_DEBUG
239             fprintf(stderr, "%s: Found.\n", tocEntryName);
240 #endif
241             if((number+1) < count) {
242                 *pLength = (int32_t)(entry[1].dataOffset - entry->dataOffset);
243             } else {
244                 *pLength = -1;
245             }
246             return (const DataHeader *)(base+entry->dataOffset);
247         } else {
248 #ifdef UDATA_DEBUG
249             fprintf(stderr, "%s: Not found.\n", tocEntryName);
250 #endif
251             return NULL;
252         }
253     } else {
254 #ifdef UDATA_DEBUG
255         fprintf(stderr, "returning header\n");
256 #endif
257 
258         return pData->pHeader;
259     }
260 }
261 
262 
pointerTOCEntryCount(const UDataMemory * pData)263 static uint32_t pointerTOCEntryCount(const UDataMemory *pData) {
264     const PointerTOC *toc = (PointerTOC *)pData->toc;
265     return (uint32_t)((toc != NULL) ? (toc->count) : 0);
266 }
267 
268 
pointerTOCLookupFn(const UDataMemory * pData,const char * name,int32_t * pLength,UErrorCode * pErrorCode)269 static const DataHeader *pointerTOCLookupFn(const UDataMemory *pData,
270                    const char *name,
271                    int32_t *pLength,
272                    UErrorCode *pErrorCode) {
273     if(pData->toc!=NULL) {
274         const PointerTOC *toc = (PointerTOC *)pData->toc;
275         int32_t number, count=(int32_t)toc->count;
276 
277 #if defined (UDATA_DEBUG_DUMP)
278         /* list the contents of the TOC each time .. not recommended */
279         for(number=0; number<count; ++number) {
280             fprintf(stderr, "\tx%d: %s\n", number, toc->entry[number].entryName);
281         }
282 #endif
283         number=pointerTOCPrefixBinarySearch(name, toc->entry, count);
284         if(number>=0) {
285             /* found it */
286 #ifdef UDATA_DEBUG
287             fprintf(stderr, "%s: Found.\n", toc->entry[number].entryName);
288 #endif
289             *pLength=-1;
290             return UDataMemory_normalizeDataPointer(toc->entry[number].pHeader);
291         } else {
292 #ifdef UDATA_DEBUG
293             fprintf(stderr, "%s: Not found.\n", name);
294 #endif
295             return NULL;
296         }
297     } else {
298         return pData->pHeader;
299     }
300 }
301 
302 static const commonDataFuncs CmnDFuncs = {offsetTOCLookupFn,  offsetTOCEntryCount};
303 static const commonDataFuncs ToCPFuncs = {pointerTOCLookupFn, pointerTOCEntryCount};
304 
305 
306 
307 /*----------------------------------------------------------------------*
308  *                                                                      *
309  *  checkCommonData   Validate the format of a common data file.        *
310  *                    Fill in the virtual function ptr based on TOC type *
311  *                    If the data is invalid, close the UDataMemory     *
312  *                    and set the appropriate error code.               *
313  *                                                                      *
314  *----------------------------------------------------------------------*/
udata_checkCommonData(UDataMemory * udm,UErrorCode * err)315 U_CFUNC void udata_checkCommonData(UDataMemory *udm, UErrorCode *err) {
316     if (U_FAILURE(*err)) {
317         return;
318     }
319 
320     if(udm==NULL || udm->pHeader==NULL) {
321       *err=U_INVALID_FORMAT_ERROR;
322     } else if(!(udm->pHeader->dataHeader.magic1==0xda &&
323         udm->pHeader->dataHeader.magic2==0x27 &&
324         udm->pHeader->info.isBigEndian==U_IS_BIG_ENDIAN &&
325         udm->pHeader->info.charsetFamily==U_CHARSET_FAMILY)
326         ) {
327         /* header not valid */
328         *err=U_INVALID_FORMAT_ERROR;
329     }
330     else if (udm->pHeader->info.dataFormat[0]==0x43 &&
331         udm->pHeader->info.dataFormat[1]==0x6d &&
332         udm->pHeader->info.dataFormat[2]==0x6e &&
333         udm->pHeader->info.dataFormat[3]==0x44 &&
334         udm->pHeader->info.formatVersion[0]==1
335         ) {
336         /* dataFormat="CmnD" */
337         udm->vFuncs = &CmnDFuncs;
338         udm->toc=(const char *)udm->pHeader+udata_getHeaderSize(udm->pHeader);
339     }
340     else if(udm->pHeader->info.dataFormat[0]==0x54 &&
341         udm->pHeader->info.dataFormat[1]==0x6f &&
342         udm->pHeader->info.dataFormat[2]==0x43 &&
343         udm->pHeader->info.dataFormat[3]==0x50 &&
344         udm->pHeader->info.formatVersion[0]==1
345         ) {
346         /* dataFormat="ToCP" */
347         udm->vFuncs = &ToCPFuncs;
348         udm->toc=(const char *)udm->pHeader+udata_getHeaderSize(udm->pHeader);
349     }
350     else {
351         /* dataFormat not recognized */
352         *err=U_INVALID_FORMAT_ERROR;
353     }
354 
355     if (U_FAILURE(*err)) {
356         /* If the data is no good and we memory-mapped it ourselves,
357          *  close the memory mapping so it doesn't leak.  Note that this has
358          *  no effect on non-memory mapped data, other than clearing fields in udm.
359          */
360         udata_close(udm);
361     }
362 }
363 
364 /*
365  * TODO: Add a udata_swapPackageHeader() function that swaps an ICU .dat package
366  * header but not its sub-items.
367  * This function will be needed for automatic runtime swapping.
368  * Sub-items should not be swapped to limit the swapping to the parts of the
369  * package that are actually used.
370  *
371  * Since lengths of items are implicit in the order and offsets of their
372  * ToC entries, and since offsets are relative to the start of the ToC,
373  * a swapped version may need to generate a different data structure
374  * with pointers to the original data items and with their lengths
375  * (-1 for the last one if it is not known), and maybe even pointers to the
376  * swapped versions of the items.
377  * These pointers to swapped versions would establish a cache;
378  * instead, each open data item could simply own the storage for its swapped
379  * data. This fits better with the current design.
380  *
381  * markus 2003sep18 Jitterbug 2235
382  */
383