[apple/icu.git] / icuSources / common / umapfile.c

/*
******************************************************************************
*
*   Copyright (C) 1999-2013, International Business Machines
*   Corporation and others.  All Rights Reserved.
*
******************************************************************************/


/*----------------------------------------------------------------------------
 *
 *       Memory mapped file wrappers for use by the ICU Data Implementation
 *       All of the platform-specific implementation for mapping data files
 *         is here.  The rest of the ICU Data implementation uses only the
 *         wrapper functions.
 *
 *----------------------------------------------------------------------------*/
/* Defines _XOPEN_SOURCE for access to POSIX functions.
 * Must be before any other #includes. */
#include "uposixdefs.h"

#include "unicode/putil.h"
#include "udatamem.h"
#include "umapfile.h"

/* memory-mapping base definitions ------------------------------------------ */

#if MAP_IMPLEMENTATION==MAP_WIN32
#   define WIN32_LEAN_AND_MEAN
#   define VC_EXTRALEAN
#   define NOUSER
#   define NOSERVICE
#   define NOIME
#   define NOMCX
#   include <windows.h>
#   include "cmemory.h"

    typedef HANDLE MemoryMap;

#   define IS_MAP(map) ((map)!=NULL)
#elif MAP_IMPLEMENTATION==MAP_POSIX || MAP_IMPLEMENTATION==MAP_390DLL
    typedef size_t MemoryMap;

#   define IS_MAP(map) ((map)!=0)

#   include <unistd.h>
#   include <sys/mman.h>
#   include <sys/stat.h>
#   include <fcntl.h>

#   ifndef MAP_FAILED
#       define MAP_FAILED ((void*)-1)
#   endif

#   if MAP_IMPLEMENTATION==MAP_390DLL
        /*   No memory mapping for 390 batch mode.  Fake it using dll loading.  */
#       include <dll.h>
#       include "cstring.h"
#       include "cmemory.h"
#       include "unicode/udata.h"
#       define LIB_PREFIX "lib"
#       define LIB_SUFFIX ".dll"
        /* This is inconvienient until we figure out what to do with U_ICUDATA_NAME in utypes.h */
#       define U_ICUDATA_ENTRY_NAME "icudt" U_ICU_VERSION_SHORT U_LIB_SUFFIX_C_NAME_STRING "_dat"
#   endif
#elif MAP_IMPLEMENTATION==MAP_STDIO
#   include <stdio.h>
#   include "cmemory.h"

    typedef void *MemoryMap;

#   define IS_MAP(map) ((map)!=NULL)
#endif

/*----------------------------------------------------------------------------*
 *                                                                            *
 *   Memory Mapped File support.  Platform dependent implementation of        *
 *                           functions used by the rest of the implementation.*
 *                                                                            *
 *----------------------------------------------------------------------------*/
#if MAP_IMPLEMENTATION==MAP_NONE
    U_CFUNC UBool
    uprv_mapFile(UDataMemory *pData, const char *path) {
        UDataMemory_init(pData); /* Clear the output struct. */
        return FALSE;            /* no file access */
    }

    U_CFUNC void uprv_unmapFile(UDataMemory *pData) {
        /* nothing to do */
    }
#elif MAP_IMPLEMENTATION==MAP_WIN32
    U_CFUNC UBool
    uprv_mapFile(
         UDataMemory *pData,    /* Fill in with info on the result doing the mapping. */
                                /*   Output only; any original contents are cleared.  */
         const char *path       /* File path to be opened/mapped                      */
         )
    {
        HANDLE map;
        HANDLE file;
        SECURITY_ATTRIBUTES mappingAttributes;
        SECURITY_ATTRIBUTES *mappingAttributesPtr = NULL;
        SECURITY_DESCRIPTOR securityDesc;

        UDataMemory_init(pData); /* Clear the output struct.        */

        /* open the input file */
        file=CreateFileA(path, GENERIC_READ, FILE_SHARE_READ, NULL,
            OPEN_EXISTING,
            FILE_ATTRIBUTE_NORMAL|FILE_FLAG_RANDOM_ACCESS, NULL);
        if(file==INVALID_HANDLE_VALUE) {
            return FALSE;
        }

        /* Declare and initialize a security descriptor.
           This is required for multiuser systems on Windows 2000 SP4 and beyond */
        if (InitializeSecurityDescriptor(&securityDesc, SECURITY_DESCRIPTOR_REVISION)) {
            /* give the security descriptor a Null Dacl done using the  "TRUE, (PACL)NULL" here	*/
            if (SetSecurityDescriptorDacl(&securityDesc, TRUE, (PACL)NULL, FALSE)) {
                /* Make the security attributes point to the security descriptor */
                uprv_memset(&mappingAttributes, 0, sizeof(mappingAttributes));
                mappingAttributes.nLength = sizeof(mappingAttributes);
                mappingAttributes.lpSecurityDescriptor = &securityDesc;
                mappingAttributes.bInheritHandle = FALSE; /* object uninheritable */
                mappingAttributesPtr = &mappingAttributes;
            }
        }
        /* else creating security descriptors can fail when we are on Windows 98,
           and mappingAttributesPtr == NULL for that case. */

        /* create an unnamed Windows file-mapping object for the specified file */
        map=CreateFileMapping(file, mappingAttributesPtr, PAGE_READONLY, 0, 0, NULL);
        CloseHandle(file);
        if(map==NULL) {
            return FALSE;
        }

        /* map a view of the file into our address space */
        pData->pHeader=(const DataHeader *)MapViewOfFile(map, FILE_MAP_READ, 0, 0, 0);
        if(pData->pHeader==NULL) {
            CloseHandle(map);
            return FALSE;
        }
        pData->map=map;
        return TRUE;
    }

    U_CFUNC void
    uprv_unmapFile(UDataMemory *pData) {
        if(pData!=NULL && pData->map!=NULL) {
            UnmapViewOfFile(pData->pHeader);
            CloseHandle(pData->map);
            pData->pHeader=NULL;
            pData->map=NULL;
        }
    }


#elif MAP_IMPLEMENTATION==MAP_POSIX
    U_CFUNC UBool
    uprv_mapFile(UDataMemory *pData, const char *path) {
        int fd;
        int length;
        struct stat mystat;
        void *data;

        UDataMemory_init(pData); /* Clear the output struct.        */

        /* determine the length of the file */
        if(stat(path, &mystat)!=0 || mystat.st_size<=0) {
            return FALSE;
        }
        length=mystat.st_size;

        /* open the file */
        fd=open(path, O_RDONLY);
        if(fd==-1) {
            return FALSE;
        }

        /* get a view of the mapping */
#if U_PLATFORM != U_PF_HPUX
        data=mmap(0, length, PROT_READ, MAP_SHARED,  fd, 0);
#else
        data=mmap(0, length, PROT_READ, MAP_PRIVATE, fd, 0);
#endif
        close(fd); /* no longer needed */
        if(data==MAP_FAILED) {
            return FALSE;
        }

        pData->map = (char *)data + length;
        pData->pHeader=(const DataHeader *)data;
        pData->mapAddr = data;
#if U_PLATFORM == U_PF_IPHONE
        posix_madvise(data, length, POSIX_MADV_RANDOM);
#endif
        return TRUE;
    }

    U_CFUNC void
    uprv_unmapFile(UDataMemory *pData) {
        if(pData!=NULL && pData->map!=NULL) {
            size_t dataLen = (char *)pData->map - (char *)pData->mapAddr;
            if(munmap(pData->mapAddr, dataLen)==-1) {
            }
            pData->pHeader=NULL;
            pData->map=0;
            pData->mapAddr=NULL;
        }
    }


#elif MAP_IMPLEMENTATION==MAP_STDIO
    /* copy of the filestrm.c/T_FileStream_size() implementation */
    static int32_t
    umap_fsize(FILE *f) {
        int32_t savedPos = ftell(f);
        int32_t size = 0;

        /*Changes by Bertrand A. D. doesn't affect the current position
        goes to the end of the file before ftell*/
        fseek(f, 0, SEEK_END);
        size = (int32_t)ftell(f);
        fseek(f, savedPos, SEEK_SET);
        return size;
    }

    U_CFUNC UBool
    uprv_mapFile(UDataMemory *pData, const char *path) {
        FILE *file;
        int32_t fileLength;
        void *p;

        UDataMemory_init(pData); /* Clear the output struct.        */
        /* open the input file */
        file=fopen(path, "rb");
        if(file==NULL) {
            return FALSE;
        }

        /* get the file length */
        fileLength=umap_fsize(file);
        if(ferror(file) || fileLength<=20) {
            fclose(file);
            return FALSE;
        }

        /* allocate the memory to hold the file data */
        p=uprv_malloc(fileLength);
        if(p==NULL) {
            fclose(file);
            return FALSE;
        }

        /* read the file */
        if(fileLength!=fread(p, 1, fileLength, file)) {
            uprv_free(p);
            fclose(file);
            return FALSE;
        }

        fclose(file);
        pData->map=p;
        pData->pHeader=(const DataHeader *)p;
        pData->mapAddr=p;
        return TRUE;
    }

    U_CFUNC void
    uprv_unmapFile(UDataMemory *pData) {
        if(pData!=NULL && pData->map!=NULL) {
            uprv_free(pData->map);
            pData->map     = NULL;
            pData->mapAddr = NULL;
            pData->pHeader = NULL;
        }
    }


#elif MAP_IMPLEMENTATION==MAP_390DLL
    /*  390 specific Library Loading.
     *  This is the only platform left that dynamically loads an ICU Data Library.
     *  All other platforms use .data files when dynamic loading is required, but
     *  this turn out to be awkward to support in 390 batch mode.
     *
     *  The idea here is to hide the fact that 390 is using dll loading from the
     *   rest of ICU, and make it look like there is file loading happening.
     *
     */

    static char *strcpy_returnEnd(char *dest, const char *src)
    {
        while((*dest=*src)!=0) {
            ++dest;
            ++src;
        }
        return dest;
    }
    
    /*------------------------------------------------------------------------------
     *                                                                              
     *  computeDirPath   given a user-supplied path of an item to be opened,             
     *                         compute and return 
     *                            - the full directory path to be used 
     *                              when opening the file.
     *                            - Pointer to null at end of above returned path    
     *
     *                       Parameters:
     *                          path:        input path.  Buffer is not altered.
     *                          pathBuffer:  Output buffer.  Any contents are overwritten.
     *
     *                       Returns:
     *                          Pointer to null termination in returned pathBuffer.
     *
     *                    TODO:  This works the way ICU historically has, but the
     *                           whole data fallback search path is so complicated that
     *                           proabably almost no one will ever really understand it,
     *                           the potential for confusion is large.  (It's not just 
     *                           this one function, but the whole scheme.)
     *                            
     *------------------------------------------------------------------------------*/
    static char *uprv_computeDirPath(const char *path, char *pathBuffer)
    {
        char   *finalSlash;       /* Ptr to last dir separator in input path, or null if none. */
        int32_t pathLen;          /* Length of the returned directory path                     */
        
        finalSlash = 0;
        if (path != 0) {
            finalSlash = uprv_strrchr(path, U_FILE_SEP_CHAR);
        }
        
        *pathBuffer = 0;
        if (finalSlash == 0) {
        /* No user-supplied path.  
            * Copy the ICU_DATA path to the path buffer and return that*/
            const char *icuDataDir;
            icuDataDir=u_getDataDirectory();
            if(icuDataDir!=NULL && *icuDataDir!=0) {
                return strcpy_returnEnd(pathBuffer, icuDataDir);
            } else {
                /* there is no icuDataDir either.  Just return the empty pathBuffer. */
                return pathBuffer;
            }
        } 
        
        /* User supplied path did contain a directory portion.
        * Copy it to the output path buffer */
        pathLen = (int32_t)(finalSlash - path + 1);
        uprv_memcpy(pathBuffer, path, pathLen);
        *(pathBuffer+pathLen) = 0;
        return pathBuffer+pathLen;
    }
    

#   define DATA_TYPE "dat"

    U_CFUNC UBool uprv_mapFile(UDataMemory *pData, const char *path) {
        const char *inBasename;
        char *basename;
        char pathBuffer[1024];
        const DataHeader *pHeader;
        dllhandle *handle;
        void *val=0;

        inBasename=uprv_strrchr(path, U_FILE_SEP_CHAR);
        if(inBasename==NULL) {
            inBasename = path;
        } else {
            inBasename++;
        }
        basename=uprv_computeDirPath(path, pathBuffer);
        if(uprv_strcmp(inBasename, U_ICUDATA_NAME".dat") != 0) {
            /* must mmap file... for build */
            int fd;
            int length;
            struct stat mystat;
            void *data;
            UDataMemory_init(pData); /* Clear the output struct. */

            /* determine the length of the file */
            if(stat(path, &mystat)!=0 || mystat.st_size<=0) {
                return FALSE;
            }
            length=mystat.st_size;

            /* open the file */
            fd=open(path, O_RDONLY);
            if(fd==-1) {
                return FALSE;
            }

            /* get a view of the mapping */
            data=mmap(0, length, PROT_READ, MAP_PRIVATE, fd, 0);
            close(fd); /* no longer needed */
            if(data==MAP_FAILED) {
                return FALSE;
            }
            pData->map = (char *)data + length;
            pData->pHeader=(const DataHeader *)data;
            pData->mapAddr = data;
            return TRUE;
        }

#       ifdef OS390BATCH
            /* ### hack: we still need to get u_getDataDirectory() fixed
            for OS/390 (batch mode - always return "//"? )
            and this here straightened out with LIB_PREFIX and LIB_SUFFIX (both empty?!)
            This is probably due to the strange file system on OS/390.  It's more like
            a database with short entry names than a typical file system. */
            /* U_ICUDATA_NAME should always have the correct name */
            /* BUT FOR BATCH MODE IT IS AN EXCEPTION BECAUSE */
            /* THE FIRST THREE LETTERS ARE PREASSIGNED TO THE */
            /* PROJECT!!!!! */
            uprv_strcpy(pathBuffer, "IXMI" U_ICU_VERSION_SHORT "DA");
#       else
            /* set up the library name */
            uprv_strcpy(basename, LIB_PREFIX U_LIBICUDATA_NAME U_ICU_VERSION_SHORT LIB_SUFFIX);
#       endif

#       ifdef UDATA_DEBUG
             fprintf(stderr, "dllload: %s ", pathBuffer);
#       endif

        handle=dllload(pathBuffer);

#       ifdef UDATA_DEBUG
               fprintf(stderr, " -> %08X\n", handle );
#       endif

        if(handle != NULL) {
               /* we have a data DLL - what kind of lookup do we need here? */
               /* try to find the Table of Contents */
               UDataMemory_init(pData); /* Clear the output struct.        */
               val=dllqueryvar((dllhandle*)handle, U_ICUDATA_ENTRY_NAME);
               if(val == 0) {
                    /* failed... so keep looking */
                    return FALSE;
               }
#              ifdef UDATA_DEBUG
                    fprintf(stderr, "dllqueryvar(%08X, %s) -> %08X\n", handle, U_ICUDATA_ENTRY_NAME, val);
#              endif

               pData->pHeader=(const DataHeader *)val;
               return TRUE;
         } else {
               return FALSE; /* no handle */
         }
    }

    U_CFUNC void uprv_unmapFile(UDataMemory *pData) {
        if(pData!=NULL && pData->map!=NULL) {
            uprv_free(pData->map);
            pData->map     = NULL;
            pData->mapAddr = NULL;
            pData->pHeader = NULL;
        }   
    }

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