1 /* 2 ****************************************************************************** 3 * 4 * Copyright (C) 1999-2010, International Business Machines 5 * Corporation and others. All Rights Reserved. 6 * 7 ******************************************************************************/ 8 9 10 /*---------------------------------------------------------------------------- 11 * 12 * Memory mapped file wrappers for use by the ICU Data Implementation 13 * All of the platform-specific implementation for mapping data files 14 * is here. The rest of the ICU Data implementation uses only the 15 * wrapper functions. 16 * 17 *----------------------------------------------------------------------------*/ 18 19 #include "unicode/putil.h" 20 #include "udatamem.h" 21 #include "umapfile.h" 22 23 /* memory-mapping base definitions ------------------------------------------ */ 24 25 #if MAP_IMPLEMENTATION==MAP_WIN32 26 # define WIN32_LEAN_AND_MEAN 27 # define VC_EXTRALEAN 28 # define NOUSER 29 # define NOSERVICE 30 # define NOIME 31 # define NOMCX 32 # include <windows.h> 33 # include "cmemory.h" 34 35 typedef HANDLE MemoryMap; 36 37 # define IS_MAP(map) ((map)!=NULL) 38 #elif MAP_IMPLEMENTATION==MAP_POSIX || MAP_IMPLEMENTATION==MAP_390DLL 39 typedef size_t MemoryMap; 40 41 # define IS_MAP(map) ((map)!=0) 42 43 # include <unistd.h> 44 # include <sys/mman.h> 45 # include <sys/stat.h> 46 # include <fcntl.h> 47 48 # ifndef MAP_FAILED 49 # define MAP_FAILED ((void*)-1) 50 # endif 51 52 # if MAP_IMPLEMENTATION==MAP_390DLL 53 /* No memory mapping for 390 batch mode. Fake it using dll loading. */ 54 # include <dll.h> 55 # include "cstring.h" 56 # include "cmemory.h" 57 # include "unicode/udata.h" 58 # define LIB_PREFIX "lib" 59 # define LIB_SUFFIX ".dll" 60 /* This is inconvienient until we figure out what to do with U_ICUDATA_NAME in utypes.h */ 61 # define U_ICUDATA_ENTRY_NAME "icudt" U_ICU_VERSION_SHORT U_LIB_SUFFIX_C_NAME_STRING "_dat" 62 # else 63 # if defined(U_DARWIN) 64 # include <TargetConditionals.h> 65 # endif 66 # endif 67 #elif MAP_IMPLEMENTATION==MAP_STDIO 68 # include <stdio.h> 69 # include "cmemory.h" 70 71 typedef void *MemoryMap; 72 73 # define IS_MAP(map) ((map)!=NULL) 74 #endif 75 76 /*----------------------------------------------------------------------------* 77 * * 78 * Memory Mapped File support. Platform dependent implementation of * 79 * functions used by the rest of the implementation.* 80 * * 81 *----------------------------------------------------------------------------*/ 82 #if MAP_IMPLEMENTATION==MAP_NONE 83 U_CFUNC UBool 84 uprv_mapFile(UDataMemory *pData, const char *path) { 85 UDataMemory_init(pData); /* Clear the output struct. */ 86 return FALSE; /* no file access */ 87 } 88 89 U_CFUNC void uprv_unmapFile(UDataMemory *pData) { 90 /* nothing to do */ 91 } 92 #elif MAP_IMPLEMENTATION==MAP_WIN32 93 U_CFUNC UBool 94 uprv_mapFile( 95 UDataMemory *pData, /* Fill in with info on the result doing the mapping. */ 96 /* Output only; any original contents are cleared. */ 97 const char *path /* File path to be opened/mapped */ 98 ) 99 { 100 HANDLE map; 101 HANDLE file; 102 SECURITY_ATTRIBUTES mappingAttributes; 103 SECURITY_ATTRIBUTES *mappingAttributesPtr = NULL; 104 SECURITY_DESCRIPTOR securityDesc; 105 106 UDataMemory_init(pData); /* Clear the output struct. */ 107 108 /* open the input file */ 109 file=CreateFileA(path, GENERIC_READ, FILE_SHARE_READ, NULL, 110 OPEN_EXISTING, 111 FILE_ATTRIBUTE_NORMAL|FILE_FLAG_RANDOM_ACCESS, NULL); 112 if(file==INVALID_HANDLE_VALUE) { 113 return FALSE; 114 } 115 116 /* Declare and initialize a security descriptor. 117 This is required for multiuser systems on Windows 2000 SP4 and beyond */ 118 if (InitializeSecurityDescriptor(&securityDesc, SECURITY_DESCRIPTOR_REVISION)) { 119 /* give the security descriptor a Null Dacl done using the "TRUE, (PACL)NULL" here */ 120 if (SetSecurityDescriptorDacl(&securityDesc, TRUE, (PACL)NULL, FALSE)) { 121 /* Make the security attributes point to the security descriptor */ 122 uprv_memset(&mappingAttributes, 0, sizeof(mappingAttributes)); 123 mappingAttributes.nLength = sizeof(mappingAttributes); 124 mappingAttributes.lpSecurityDescriptor = &securityDesc; 125 mappingAttributes.bInheritHandle = FALSE; /* object uninheritable */ 126 mappingAttributesPtr = &mappingAttributes; 127 } 128 } 129 /* else creating security descriptors can fail when we are on Windows 98, 130 and mappingAttributesPtr == NULL for that case. */ 131 132 /* create an unnamed Windows file-mapping object for the specified file */ 133 map=CreateFileMapping(file, mappingAttributesPtr, PAGE_READONLY, 0, 0, NULL); 134 CloseHandle(file); 135 if(map==NULL) { 136 return FALSE; 137 } 138 139 /* map a view of the file into our address space */ 140 pData->pHeader=(const DataHeader *)MapViewOfFile(map, FILE_MAP_READ, 0, 0, 0); 141 if(pData->pHeader==NULL) { 142 CloseHandle(map); 143 return FALSE; 144 } 145 pData->map=map; 146 return TRUE; 147 } 148 149 U_CFUNC void 150 uprv_unmapFile(UDataMemory *pData) { 151 if(pData!=NULL && pData->map!=NULL) { 152 UnmapViewOfFile(pData->pHeader); 153 CloseHandle(pData->map); 154 pData->pHeader=NULL; 155 pData->map=NULL; 156 } 157 } 158 159 160 161 #elif MAP_IMPLEMENTATION==MAP_POSIX 162 U_CFUNC UBool 163 uprv_mapFile(UDataMemory *pData, const char *path) { 164 int fd; 165 int length; 166 struct stat mystat; 167 void *data; 168 169 UDataMemory_init(pData); /* Clear the output struct. */ 170 171 /* determine the length of the file */ 172 if(stat(path, &mystat)!=0 || mystat.st_size<=0) { 173 return FALSE; 174 } 175 length=mystat.st_size; 176 177 /* open the file */ 178 fd=open(path, O_RDONLY); 179 if(fd==-1) { 180 return FALSE; 181 } 182 183 /* get a view of the mapping */ 184 #ifndef U_HPUX 185 data=mmap(0, length, PROT_READ, MAP_SHARED, fd, 0); 186 #else 187 data=mmap(0, length, PROT_READ, MAP_PRIVATE, fd, 0); 188 #endif 189 close(fd); /* no longer needed */ 190 if(data==MAP_FAILED) { 191 return FALSE; 192 } 193 194 pData->map = (char *)data + length; 195 pData->pHeader=(const DataHeader *)data; 196 pData->mapAddr = data; 197 #if defined(U_DARWIN) && TARGET_OS_IPHONE 198 posix_madvise(data, length, POSIX_MADV_RANDOM); 199 #endif 200 return TRUE; 201 } 202 203 U_CFUNC void 204 uprv_unmapFile(UDataMemory *pData) { 205 if(pData!=NULL && pData->map!=NULL) { 206 size_t dataLen = (char *)pData->map - (char *)pData->mapAddr; 207 if(munmap(pData->mapAddr, dataLen)==-1) { 208 } 209 pData->pHeader=NULL; 210 pData->map=0; 211 pData->mapAddr=NULL; 212 } 213 } 214 215 216 217 #elif MAP_IMPLEMENTATION==MAP_STDIO 218 /* copy of the filestrm.c/T_FileStream_size() implementation */ 219 static int32_t 220 umap_fsize(FILE *f) { 221 int32_t savedPos = ftell(f); 222 int32_t size = 0; 223 224 /*Changes by Bertrand A. D. doesn't affect the current position 225 goes to the end of the file before ftell*/ 226 fseek(f, 0, SEEK_END); 227 size = (int32_t)ftell(f); 228 fseek(f, savedPos, SEEK_SET); 229 return size; 230 } 231 232 U_CFUNC UBool 233 uprv_mapFile(UDataMemory *pData, const char *path) { 234 FILE *file; 235 int32_t fileLength; 236 void *p; 237 238 UDataMemory_init(pData); /* Clear the output struct. */ 239 /* open the input file */ 240 file=fopen(path, "rb"); 241 if(file==NULL) { 242 return FALSE; 243 } 244 245 /* get the file length */ 246 fileLength=umap_fsize(file); 247 if(ferror(file) || fileLength<=20) { 248 fclose(file); 249 return FALSE; 250 } 251 252 /* allocate the memory to hold the file data */ 253 p=uprv_malloc(fileLength); 254 if(p==NULL) { 255 fclose(file); 256 return FALSE; 257 } 258 259 /* read the file */ 260 if(fileLength!=fread(p, 1, fileLength, file)) { 261 uprv_free(p); 262 fclose(file); 263 return FALSE; 264 } 265 266 fclose(file); 267 pData->map=p; 268 pData->pHeader=(const DataHeader *)p; 269 pData->mapAddr=p; 270 return TRUE; 271 } 272 273 U_CFUNC void 274 uprv_unmapFile(UDataMemory *pData) { 275 if(pData!=NULL && pData->map!=NULL) { 276 uprv_free(pData->map); 277 pData->map = NULL; 278 pData->mapAddr = NULL; 279 pData->pHeader = NULL; 280 } 281 } 282 283 284 #elif MAP_IMPLEMENTATION==MAP_390DLL 285 /* 390 specific Library Loading. 286 * This is the only platform left that dynamically loads an ICU Data Library. 287 * All other platforms use .data files when dynamic loading is required, but 288 * this turn out to be awkward to support in 390 batch mode. 289 * 290 * The idea here is to hide the fact that 390 is using dll loading from the 291 * rest of ICU, and make it look like there is file loading happening. 292 * 293 */ 294 295 static char *strcpy_returnEnd(char *dest, const char *src) 296 { 297 while((*dest=*src)!=0) { 298 ++dest; 299 ++src; 300 } 301 return dest; 302 } 303 304 /*------------------------------------------------------------------------------ 305 * 306 * computeDirPath given a user-supplied path of an item to be opened, 307 * compute and return 308 * - the full directory path to be used 309 * when opening the file. 310 * - Pointer to null at end of above returned path 311 * 312 * Parameters: 313 * path: input path. Buffer is not altered. 314 * pathBuffer: Output buffer. Any contents are overwritten. 315 * 316 * Returns: 317 * Pointer to null termination in returned pathBuffer. 318 * 319 * TODO: This works the way ICU historically has, but the 320 * whole data fallback search path is so complicated that 321 * proabably almost no one will ever really understand it, 322 * the potential for confusion is large. (It's not just 323 * this one function, but the whole scheme.) 324 * 325 *------------------------------------------------------------------------------*/ 326 static char *uprv_computeDirPath(const char *path, char *pathBuffer) 327 { 328 char *finalSlash; /* Ptr to last dir separator in input path, or null if none. */ 329 int32_t pathLen; /* Length of the returned directory path */ 330 331 finalSlash = 0; 332 if (path != 0) { 333 finalSlash = uprv_strrchr(path, U_FILE_SEP_CHAR); 334 } 335 336 *pathBuffer = 0; 337 if (finalSlash == 0) { 338 /* No user-supplied path. 339 * Copy the ICU_DATA path to the path buffer and return that*/ 340 const char *icuDataDir; 341 icuDataDir=u_getDataDirectory(); 342 if(icuDataDir!=NULL && *icuDataDir!=0) { 343 return strcpy_returnEnd(pathBuffer, icuDataDir); 344 } else { 345 /* there is no icuDataDir either. Just return the empty pathBuffer. */ 346 return pathBuffer; 347 } 348 } 349 350 /* User supplied path did contain a directory portion. 351 * Copy it to the output path buffer */ 352 pathLen = (int32_t)(finalSlash - path + 1); 353 uprv_memcpy(pathBuffer, path, pathLen); 354 *(pathBuffer+pathLen) = 0; 355 return pathBuffer+pathLen; 356 } 357 358 359 # define DATA_TYPE "dat" 360 361 U_CFUNC UBool uprv_mapFile(UDataMemory *pData, const char *path) { 362 const char *inBasename; 363 char *basename; 364 char pathBuffer[1024]; 365 const DataHeader *pHeader; 366 dllhandle *handle; 367 void *val=0; 368 369 inBasename=uprv_strrchr(path, U_FILE_SEP_CHAR); 370 if(inBasename==NULL) { 371 inBasename = path; 372 } else { 373 inBasename++; 374 } 375 basename=uprv_computeDirPath(path, pathBuffer); 376 if(uprv_strcmp(inBasename, U_ICUDATA_NAME".dat") != 0) { 377 /* must mmap file... for build */ 378 int fd; 379 int length; 380 struct stat mystat; 381 void *data; 382 UDataMemory_init(pData); /* Clear the output struct. */ 383 384 /* determine the length of the file */ 385 if(stat(path, &mystat)!=0 || mystat.st_size<=0) { 386 return FALSE; 387 } 388 length=mystat.st_size; 389 390 /* open the file */ 391 fd=open(path, O_RDONLY); 392 if(fd==-1) { 393 return FALSE; 394 } 395 396 /* get a view of the mapping */ 397 data=mmap(0, length, PROT_READ, MAP_PRIVATE, fd, 0); 398 close(fd); /* no longer needed */ 399 if(data==MAP_FAILED) { 400 return FALSE; 401 } 402 pData->map = (char *)data + length; 403 pData->pHeader=(const DataHeader *)data; 404 pData->mapAddr = data; 405 return TRUE; 406 } 407 408 # ifdef OS390BATCH 409 /* ### hack: we still need to get u_getDataDirectory() fixed 410 for OS/390 (batch mode - always return "//"? ) 411 and this here straightened out with LIB_PREFIX and LIB_SUFFIX (both empty?!) 412 This is probably due to the strange file system on OS/390. It's more like 413 a database with short entry names than a typical file system. */ 414 /* U_ICUDATA_NAME should always have the correct name */ 415 /* BUT FOR BATCH MODE IT IS AN EXCEPTION BECAUSE */ 416 /* THE FIRST THREE LETTERS ARE PREASSIGNED TO THE */ 417 /* PROJECT!!!!! */ 418 uprv_strcpy(pathBuffer, "IXMI" U_ICU_VERSION_SHORT "DA"); 419 # else 420 /* set up the library name */ 421 uprv_strcpy(basename, LIB_PREFIX U_LIBICUDATA_NAME U_ICU_VERSION_SHORT LIB_SUFFIX); 422 # endif 423 424 # ifdef UDATA_DEBUG 425 fprintf(stderr, "dllload: %s ", pathBuffer); 426 # endif 427 428 handle=dllload(pathBuffer); 429 430 # ifdef UDATA_DEBUG 431 fprintf(stderr, " -> %08X\n", handle ); 432 # endif 433 434 if(handle != NULL) { 435 /* we have a data DLL - what kind of lookup do we need here? */ 436 /* try to find the Table of Contents */ 437 UDataMemory_init(pData); /* Clear the output struct. */ 438 val=dllqueryvar((dllhandle*)handle, U_ICUDATA_ENTRY_NAME); 439 if(val == 0) { 440 /* failed... so keep looking */ 441 return FALSE; 442 } 443 # ifdef UDATA_DEBUG 444 fprintf(stderr, "dllqueryvar(%08X, %s) -> %08X\n", handle, U_ICUDATA_ENTRY_NAME, val); 445 # endif 446 447 pData->pHeader=(const DataHeader *)val; 448 return TRUE; 449 } else { 450 return FALSE; /* no handle */ 451 } 452 } 453 454 U_CFUNC void uprv_unmapFile(UDataMemory *pData) { 455 if(pData!=NULL && pData->map!=NULL) { 456 uprv_free(pData->map); 457 pData->map = NULL; 458 pData->mapAddr = NULL; 459 pData->pHeader = NULL; 460 } 461 } 462 463 #else 464 # error MAP_IMPLEMENTATION is set incorrectly 465 #endif 466
