intl/icu/source/common/ucmndata.c@129ffea94266
intl/icu/source/common/ucmndata.c
Sat, 03 Jan 2015 20:18:00 +0100
- author
- Michael Schloh von Bennewitz <michael@schloh.com>
- date
- Sat, 03 Jan 2015 20:18:00 +0100
- branch
- TOR_BUG_3246
- changeset 7
- 129ffea94266
- permissions
- -rw-r--r--
Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.
1 /*
2 ******************************************************************************
3 *
4 * Copyright (C) 1999-2011, International Business Machines
5 * Corporation and others. All Rights Reserved.
6 *
7 ******************************************************************************/
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 */
23 #include "unicode/utypes.h"
24 #include "unicode/udata.h"
25 #include "cstring.h"
26 #include "ucmndata.h"
27 #include "udatamem.h"
29 #if defined(UDATA_DEBUG) || defined(UDATA_DEBUG_DUMP)
30 # include <stdio.h>
31 #endif
33 U_CFUNC uint16_t
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 }
47 U_CFUNC uint16_t
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 }
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;
75 typedef struct {
76 uint32_t count;
77 uint32_t reserved;
78 PointerTOCEntry entry[2]; /* Actual size is from count. */
79 } PointerTOC;
82 /* definition of OffsetTOC struct types moved to ucmndata.h */
84 /*-----------------------------------------------------------------------------*
85 * *
86 * entry point lookup implementations *
87 * *
88 *-----------------------------------------------------------------------------*/
90 #ifndef MIN
91 #define MIN(a,b) (((a)<(b)) ? (a) : (b))
92 #endif
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
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 }
117 static int32_t
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 }
163 static int32_t
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 }
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 }
217 static const DataHeader *
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;
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
258 return pData->pHeader;
259 }
260 }
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 }
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;
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 }
302 static const commonDataFuncs CmnDFuncs = {offsetTOCLookupFn, offsetTOCEntryCount};
303 static const commonDataFuncs ToCPFuncs = {pointerTOCLookupFn, pointerTOCEntryCount};
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 *----------------------------------------------------------------------*/
315 U_CFUNC void udata_checkCommonData(UDataMemory *udm, UErrorCode *err) {
316 if (U_FAILURE(*err)) {
317 return;
318 }
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 }
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 }
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 */
