X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;ds=sidebyside;f=src%2Ffccache.c;h=f9e66e83ff7ab4f3631b2da1030e8214055b9e1f;hb=995fff208e528f7dc99fbd9c4f736b0b0695c9ec;hp=c38a7050edd837cba58165ab42614ec7224d85df;hpb=647569d029d0c01ce36ae7d94095ea83f40728de;p=platform%2Fupstream%2Ffontconfig.git diff --git a/src/fccache.c b/src/fccache.c index c38a705..f9e66e8 100644 --- a/src/fccache.c +++ b/src/fccache.c @@ -20,21 +20,23 @@ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR * PERFORMANCE OF THIS SOFTWARE. */ - #include "fcint.h" #include "fcarch.h" #include +#include #include #include #include +#include #include +#include #include #if defined(HAVE_MMAP) || defined(__CYGWIN__) # include # include -#elif defined(_WIN32) -# define _WIN32_WINNT 0x0500 -# include +#endif +#if defined(_WIN32) +#include #endif #ifndef O_BINARY @@ -55,94 +57,37 @@ static void MD5Transform(FcChar32 buf[4], FcChar32 in[16]); #define CACHEBASE_LEN (1 + 32 + 1 + sizeof (FC_ARCHITECTURE) + sizeof (FC_CACHE_SUFFIX)) -#ifdef _WIN32 - -#include - -#ifdef __GNUC__ -typedef long long INT64; -#define EPOCH_OFFSET 11644473600ll -#else -#define EPOCH_OFFSET 11644473600i64 -typedef __int64 INT64; -#endif - -/* Workaround for problems in the stat() in the Microsoft C library: - * - * 1) stat() uses FindFirstFile() to get the file - * attributes. Unfortunately this API doesn't return correct values - * for modification time of a directory until some time after a file - * or subdirectory has been added to the directory. (This causes - * run-test.sh to fail, for instance.) GetFileAttributesEx() is - * better, it returns the updated timestamp right away. - * - * 2) stat() does some strange things related to backward - * compatibility with the local time timestamps on FAT volumes and - * daylight saving time. This causes problems after the switches - * to/from daylight saving time. See - * http://bugzilla.gnome.org/show_bug.cgi?id=154968 , especially - * comment #30, and http://www.codeproject.com/datetime/dstbugs.asp . - * We don't need any of that, FAT and Win9x are as good as dead. So - * just use the UTC timestamps from NTFS, converted to the Unix epoch. - */ - -int -FcStat (const FcChar8 *file, struct stat *statb) +static FcBool +FcCacheIsMmapSafe (int fd) { - WIN32_FILE_ATTRIBUTE_DATA wfad; - char full_path_name[MAX_PATH]; - char *basename; - DWORD rc; + enum { + MMAP_NOT_INITIALIZED = 0, + MMAP_USE, + MMAP_DONT_USE, + MMAP_CHECK_FS, + } status; + static void *static_status; - if (!GetFileAttributesEx (file, GetFileExInfoStandard, &wfad)) - return -1; - - statb->st_dev = 0; - - /* Calculate a pseudo inode number as a hash of the full path name. - * Call GetLongPathName() to get the spelling of the path name as it - * is on disk. - */ - rc = GetFullPathName (file, sizeof (full_path_name), full_path_name, &basename); - if (rc == 0 || rc > sizeof (full_path_name)) - return -1; - - rc = GetLongPathName (full_path_name, full_path_name, sizeof (full_path_name)); - statb->st_ino = FcStringHash (full_path_name); + status = (intptr_t) fc_atomic_ptr_get (&static_status); - statb->st_mode = _S_IREAD | _S_IWRITE; - statb->st_mode |= (statb->st_mode >> 3) | (statb->st_mode >> 6); + if (status == MMAP_NOT_INITIALIZED) + { + const char *env = getenv ("FONTCONFIG_USE_MMAP"); + FcBool use; + if (env && FcNameBool ((const FcChar8 *) env, &use)) + status = use ? MMAP_USE : MMAP_DONT_USE; + else + status = MMAP_CHECK_FS; + (void) fc_atomic_ptr_cmpexch (&static_status, NULL, (void *) status); + } - if (wfad.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) - statb->st_mode |= _S_IFDIR; + if (status == MMAP_CHECK_FS) + return FcIsFsMmapSafe (fd); else - statb->st_mode |= _S_IFREG; - - statb->st_nlink = 1; - statb->st_uid = statb->st_gid = 0; - statb->st_rdev = 0; - - if (wfad.nFileSizeHigh > 0) - return -1; - statb->st_size = wfad.nFileSizeLow; + return status == MMAP_USE; - statb->st_atime = (*(INT64 *)&wfad.ftLastAccessTime)/10000000 - EPOCH_OFFSET; - statb->st_mtime = (*(INT64 *)&wfad.ftLastWriteTime)/10000000 - EPOCH_OFFSET; - statb->st_ctime = statb->st_mtime; - - return 0; } -#else - -int -FcStat (const FcChar8 *file, struct stat *statb) -{ - return stat ((char *) file, statb); -} - -#endif - static const char bin2hex[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', @@ -181,6 +126,7 @@ FcDirCacheUnlink (const FcChar8 *dir, FcConfig *config) FcChar8 cache_base[CACHEBASE_LEN]; FcStrList *list; FcChar8 *cache_dir; + const FcChar8 *sysroot = FcConfigGetSysRoot (config); FcDirCacheBasename (dir, cache_base); @@ -190,7 +136,10 @@ FcDirCacheUnlink (const FcChar8 *dir, FcConfig *config) while ((cache_dir = FcStrListNext (list))) { - cache_hashed = FcStrPlus (cache_dir, cache_base); + if (sysroot) + cache_hashed = FcStrBuildFilename (sysroot, cache_dir, cache_base, NULL); + else + cache_hashed = FcStrBuildFilename (cache_dir, cache_base, NULL); if (!cache_hashed) break; (void) unlink ((char *) cache_hashed); @@ -212,7 +161,7 @@ FcDirCacheOpenFile (const FcChar8 *cache_file, struct stat *file_stat) if (FcStat (cache_file, file_stat) < 0) return -1; #endif - fd = open((char *) cache_file, O_RDONLY | O_BINARY); + fd = FcOpen((char *) cache_file, O_RDONLY | O_BINARY); if (fd < 0) return fd; #ifndef _WIN32 @@ -232,19 +181,28 @@ FcDirCacheOpenFile (const FcChar8 *cache_file, struct stat *file_stat) */ static FcBool FcDirCacheProcess (FcConfig *config, const FcChar8 *dir, - FcBool (*callback) (int fd, struct stat *fd_stat, + FcBool (*callback) (FcConfig *config, int fd, struct stat *fd_stat, struct stat *dir_stat, void *closure), void *closure, FcChar8 **cache_file_ret) { int fd = -1; FcChar8 cache_base[CACHEBASE_LEN]; FcStrList *list; - FcChar8 *cache_dir; + FcChar8 *cache_dir, *d; struct stat file_stat, dir_stat; FcBool ret = FcFalse; + const FcChar8 *sysroot = FcConfigGetSysRoot (config); - if (FcStat (dir, &dir_stat) < 0) + if (sysroot) + d = FcStrBuildFilename (sysroot, dir, NULL); + else + d = FcStrdup (dir); + if (FcStatChecksum (d, &dir_stat) < 0) + { + FcStrFree (d); return FcFalse; + } + FcStrFree (d); FcDirCacheBasename (dir, cache_base); @@ -254,12 +212,17 @@ FcDirCacheProcess (FcConfig *config, const FcChar8 *dir, while ((cache_dir = FcStrListNext (list))) { - FcChar8 *cache_hashed = FcStrPlus (cache_dir, cache_base); + FcChar8 *cache_hashed; + + if (sysroot) + cache_hashed = FcStrBuildFilename (sysroot, cache_dir, cache_base, NULL); + else + cache_hashed = FcStrBuildFilename (cache_dir, cache_base, NULL); if (!cache_hashed) break; fd = FcDirCacheOpenFile (cache_hashed, &file_stat); if (fd >= 0) { - ret = (*callback) (fd, &file_stat, &dir_stat, closure); + ret = (*callback) (config, fd, &file_stat, &dir_stat, closure); close (fd); if (ret) { @@ -289,11 +252,12 @@ typedef struct _FcCacheSkip FcCacheSkip; struct _FcCacheSkip { FcCache *cache; - int ref; + FcRef ref; intptr_t size; dev_t cache_dev; ino_t cache_ino; time_t cache_mtime; + long cache_mtime_nano; FcCacheSkip *next[1]; }; @@ -304,20 +268,54 @@ struct _FcCacheSkip { #define FC_CACHE_MAX_LEVEL 16 +/* Protected by cache_lock below */ static FcCacheSkip *fcCacheChains[FC_CACHE_MAX_LEVEL]; static int fcCacheMaxLevel; -#if HAVE_RANDOM -# define FcRandom() random() -#else -# if HAVE_LRAND48 -# define FcRandom() lrand48() -# else -# if HAVE_RAND -# define FcRandom() rand() -# endif -# endif -#endif + +static FcMutex *cache_lock; + +static void +lock_cache (void) +{ + FcMutex *lock; +retry: + lock = fc_atomic_ptr_get (&cache_lock); + if (!lock) { + lock = (FcMutex *) malloc (sizeof (FcMutex)); + FcMutexInit (lock); + if (!fc_atomic_ptr_cmpexch (&cache_lock, NULL, lock)) { + FcMutexFinish (lock); + goto retry; + } + + FcMutexLock (lock); + /* Initialize random state */ + FcRandom (); + return; + } + FcMutexLock (lock); +} + +static void +unlock_cache (void) +{ + FcMutexUnlock (cache_lock); +} + +static void +free_lock (void) +{ + FcMutex *lock; + lock = fc_atomic_ptr_get (&cache_lock); + if (lock && fc_atomic_ptr_cmpexch (&cache_lock, lock, NULL)) { + FcMutexFinish (lock); + free (lock); + } +} + + + /* * Generate a random level number, distributed * so that each level is 1/4 as likely as the one before @@ -350,6 +348,8 @@ FcCacheInsert (FcCache *cache, struct stat *cache_stat) FcCacheSkip *s, **next; int i, level; + lock_cache (); + /* * Find links along each chain */ @@ -379,18 +379,24 @@ FcCacheInsert (FcCache *cache, struct stat *cache_stat) s->cache = cache; s->size = cache->size; - s->ref = 1; + FcRefInit (&s->ref, 1); if (cache_stat) { s->cache_dev = cache_stat->st_dev; s->cache_ino = cache_stat->st_ino; s->cache_mtime = cache_stat->st_mtime; +#ifdef HAVE_STRUCT_STAT_ST_MTIM + s->cache_mtime_nano = cache_stat->st_mtim.tv_nsec; +#else + s->cache_mtime_nano = 0; +#endif } else { s->cache_dev = 0; s->cache_ino = 0; s->cache_mtime = 0; + s->cache_mtime_nano = 0; } /* @@ -401,16 +407,21 @@ FcCacheInsert (FcCache *cache, struct stat *cache_stat) s->next[i] = *update[i]; *update[i] = s; } + + unlock_cache (); return FcTrue; } static FcCacheSkip * -FcCacheFindByAddr (void *object) +FcCacheFindByAddrUnlocked (void *object) { int i; FcCacheSkip **next = fcCacheChains; FcCacheSkip *s; + if (!object) + return NULL; + /* * Walk chain pointers one level at a time */ @@ -426,8 +437,18 @@ FcCacheFindByAddr (void *object) return NULL; } +static FcCacheSkip * +FcCacheFindByAddr (void *object) +{ + FcCacheSkip *ret; + lock_cache (); + ret = FcCacheFindByAddrUnlocked (object); + unlock_cache (); + return ret; +} + static void -FcCacheRemove (FcCache *cache) +FcCacheRemoveUnlocked (FcCache *cache) { FcCacheSkip **update[FC_CACHE_MAX_LEVEL]; FcCacheSkip *s, **next; @@ -457,20 +478,29 @@ FcCacheFindByStat (struct stat *cache_stat) { FcCacheSkip *s; + lock_cache (); for (s = fcCacheChains[0]; s; s = s->next[0]) if (s->cache_dev == cache_stat->st_dev && s->cache_ino == cache_stat->st_ino && s->cache_mtime == cache_stat->st_mtime) { - s->ref++; +#ifdef HAVE_STRUCT_STAT_ST_MTIM + if (s->cache_mtime != cache_stat->st_mtim.tv_nsec) + continue; +#endif + FcRefInc (&s->ref); + unlock_cache (); return s->cache; } + unlock_cache (); return NULL; } static void -FcDirCacheDispose (FcCache *cache) +FcDirCacheDisposeUnlocked (FcCache *cache) { + FcCacheRemoveUnlocked (cache); + switch (cache->magic) { case FC_CACHE_MAGIC_ALLOC: free (cache); @@ -483,7 +513,6 @@ FcDirCacheDispose (FcCache *cache) #endif break; } - FcCacheRemove (cache); } void @@ -492,20 +521,22 @@ FcCacheObjectReference (void *object) FcCacheSkip *skip = FcCacheFindByAddr (object); if (skip) - skip->ref++; + FcRefInc (&skip->ref); } void FcCacheObjectDereference (void *object) { - FcCacheSkip *skip = FcCacheFindByAddr (object); + FcCacheSkip *skip; + lock_cache (); + skip = FcCacheFindByAddrUnlocked (object); if (skip) { - skip->ref--; - if (skip->ref <= 0) - FcDirCacheDispose (skip->cache); + if (FcRefDec (&skip->ref) == 1) + FcDirCacheDisposeUnlocked (skip->cache); } + unlock_cache (); } void @@ -516,53 +547,172 @@ FcCacheFini (void) for (i = 0; i < FC_CACHE_MAX_LEVEL; i++) assert (fcCacheChains[i] == NULL); assert (fcCacheMaxLevel == 0); + + free_lock (); } static FcBool -FcCacheTimeValid (FcCache *cache, struct stat *dir_stat) +FcCacheTimeValid (FcConfig *config, FcCache *cache, struct stat *dir_stat) { struct stat dir_static; + FcBool fnano = FcTrue; if (!dir_stat) { - if (FcStat (FcCacheDir (cache), &dir_static) < 0) + const FcChar8 *sysroot = FcConfigGetSysRoot (config); + FcChar8 *d; + + if (sysroot) + d = FcStrBuildFilename (sysroot, FcCacheDir (cache), NULL); + else + d = FcStrdup (FcCacheDir (cache)); + if (FcStatChecksum (d, &dir_static) < 0) + { + FcStrFree (d); return FcFalse; + } + FcStrFree (d); dir_stat = &dir_static; } +#ifdef HAVE_STRUCT_STAT_ST_MTIM + fnano = (cache->checksum_nano == dir_stat->st_mtim.tv_nsec); + if (FcDebug () & FC_DBG_CACHE) + printf ("FcCacheTimeValid dir \"%s\" cache checksum %d.%ld dir checksum %d.%ld\n", + FcCacheDir (cache), cache->checksum, (long)cache->checksum_nano, (int) dir_stat->st_mtime, dir_stat->st_mtim.tv_nsec); +#else if (FcDebug () & FC_DBG_CACHE) - printf ("FcCacheTimeValid dir \"%s\" cache time %d dir time %d\n", - FcCacheDir (cache), cache->mtime, (int) dir_stat->st_mtime); - return cache->mtime == (int) dir_stat->st_mtime; + printf ("FcCacheTimeValid dir \"%s\" cache checksum %d dir checksum %d\n", + FcCacheDir (cache), cache->checksum, (int) dir_stat->st_mtime); +#endif + + return cache->checksum == (int) dir_stat->st_mtime && fnano; +} + +static FcBool +FcCacheOffsetsValid (FcCache *cache) +{ + char *base = (char *)cache; + char *end = base + cache->size; + intptr_t *dirs; + FcFontSet *fs; + int i, j; + + if (cache->dir < 0 || cache->dir > cache->size - sizeof (intptr_t) || + memchr (base + cache->dir, '\0', cache->size - cache->dir) == NULL) + return FcFalse; + + if (cache->dirs < 0 || cache->dirs >= cache->size || + cache->dirs_count < 0 || + cache->dirs_count > (cache->size - cache->dirs) / sizeof (intptr_t)) + return FcFalse; + + dirs = FcCacheDirs (cache); + if (dirs) + { + for (i = 0; i < cache->dirs_count; i++) + { + FcChar8 *dir; + + if (dirs[i] < 0 || + dirs[i] > end - (char *) dirs - sizeof (intptr_t)) + return FcFalse; + + dir = FcOffsetToPtr (dirs, dirs[i], FcChar8); + if (memchr (dir, '\0', end - (char *) dir) == NULL) + return FcFalse; + } + } + + if (cache->set < 0 || cache->set > cache->size - sizeof (FcFontSet)) + return FcFalse; + + fs = FcCacheSet (cache); + if (fs) + { + if (fs->nfont > (end - (char *) fs) / sizeof (FcPattern)) + return FcFalse; + + if (fs->fonts != 0 && !FcIsEncodedOffset(fs->fonts)) + return FcFalse; + + for (i = 0; i < fs->nfont; i++) + { + FcPattern *font = FcFontSetFont (fs, i); + FcPatternElt *e; + FcValueListPtr l; + char *last_offset; + + /* TIZEN_ONLY(20171013): Add a condition to FcCacheOffsetsValid() for detecting empty data of cache + if ((char *) font < base || + (char *) font > end - sizeof (FcFontSet) || + font->elts_offset < 0 || + font->elts_offset > end - (char *) font || + font->num > (end - (char *) font - font->elts_offset) / sizeof (FcPatternElt)) + return FcFalse; + */ + if ((char *) font < base || + (char *) font > end - sizeof (FcFontSet) || + font->elts_offset < 0 || + font->elts_offset > end - (char *) font || + font->num > (end - (char *) font - font->elts_offset) / sizeof (FcPatternElt) || + !FcRefIsConst (&font->ref)) + return FcFalse; + /* END */ + + + e = FcPatternElts(font); + if (e->values != 0 && !FcIsEncodedOffset(e->values)) + return FcFalse; + + for (j = 0; j < font->num; j++) + { + last_offset = (char *) font + font->elts_offset; + for (l = FcPatternEltValues(&e[j]); l; l = FcValueListNext(l)) + { + if ((char *) l < last_offset || (char *) l > end - sizeof (*l) || + (l->next != NULL && !FcIsEncodedOffset(l->next))) + return FcFalse; + last_offset = (char *) l + 1; + } + } + } + } + + return FcTrue; } /* * Map a cache file into memory */ static FcCache * -FcDirCacheMapFd (int fd, struct stat *fd_stat, struct stat *dir_stat) +FcDirCacheMapFd (FcConfig *config, int fd, struct stat *fd_stat, struct stat *dir_stat) { FcCache *cache; FcBool allocated = FcFalse; - if (fd_stat->st_size < sizeof (FcCache)) + if (fd_stat->st_size > INTPTR_MAX || + fd_stat->st_size < (int) sizeof (FcCache)) return NULL; cache = FcCacheFindByStat (fd_stat); if (cache) { - if (FcCacheTimeValid (cache, dir_stat)) + if (FcCacheTimeValid (config, cache, dir_stat)) return cache; FcDirCacheUnload (cache); cache = NULL; } /* - * Lage cache files are mmap'ed, smaller cache files are read. This + * Large cache files are mmap'ed, smaller cache files are read. This * balances the system cost of mmap against per-process memory usage. */ - if (fd_stat->st_size >= FC_CACHE_MIN_MMAP) + if (FcCacheIsMmapSafe (fd) && fd_stat->st_size >= FC_CACHE_MIN_MMAP) { #if defined(HAVE_MMAP) || defined(__CYGWIN__) cache = mmap (0, fd_stat->st_size, PROT_READ, MAP_SHARED, fd, 0); +#if (HAVE_POSIX_FADVISE) && defined(POSIX_FADV_WILLNEED) + posix_fadvise (fd, 0, fd_stat->st_size, POSIX_FADV_WILLNEED); +#endif if (cache == MAP_FAILED) cache = NULL; #elif defined(_WIN32) @@ -595,9 +745,10 @@ FcDirCacheMapFd (int fd, struct stat *fd_stat, struct stat *dir_stat) allocated = FcTrue; } if (cache->magic != FC_CACHE_MAGIC_MMAP || - cache->version < FC_CACHE_CONTENT_VERSION || - cache->size != fd_stat->st_size || - !FcCacheTimeValid (cache, dir_stat) || + cache->version < FC_CACHE_VERSION_NUMBER || + cache->size != (intptr_t) fd_stat->st_size || + !FcCacheOffsetsValid (cache) || + !FcCacheTimeValid (config, cache, dir_stat) || !FcCacheInsert (cache, fd_stat)) { if (allocated) @@ -626,7 +777,7 @@ FcDirCacheReference (FcCache *cache, int nref) FcCacheSkip *skip = FcCacheFindByAddr (cache); if (skip) - skip->ref += nref; + FcRefAdd (&skip->ref, nref); } void @@ -636,9 +787,9 @@ FcDirCacheUnload (FcCache *cache) } static FcBool -FcDirCacheMapHelper (int fd, struct stat *fd_stat, struct stat *dir_stat, void *closure) +FcDirCacheMapHelper (FcConfig *config, int fd, struct stat *fd_stat, struct stat *dir_stat, void *closure) { - FcCache *cache = FcDirCacheMapFd (fd, fd_stat, dir_stat); + FcCache *cache = FcDirCacheMapFd (config, fd, fd_stat, dir_stat); if (!cache) return FcFalse; @@ -655,6 +806,7 @@ FcDirCacheLoad (const FcChar8 *dir, FcConfig *config, FcChar8 **cache_file) FcDirCacheMapHelper, &cache, cache_file)) return NULL; + return cache; } @@ -670,7 +822,7 @@ FcDirCacheLoadFile (const FcChar8 *cache_file, struct stat *file_stat) fd = FcDirCacheOpenFile (cache_file, file_stat); if (fd < 0) return NULL; - cache = FcDirCacheMapFd (fd, file_stat, NULL); + cache = FcDirCacheMapFd (FcConfigGetCurrent (), fd, file_stat, NULL); close (fd); return cache; } @@ -680,7 +832,7 @@ FcDirCacheLoadFile (const FcChar8 *cache_file, struct stat *file_stat) * the magic number and the size field */ static FcBool -FcDirCacheValidateHelper (int fd, struct stat *fd_stat, struct stat *dir_stat, void *closure) +FcDirCacheValidateHelper (FcConfig *config, int fd, struct stat *fd_stat, struct stat *dir_stat, void *closure FC_UNUSED) { FcBool ret = FcTrue; FcCache c; @@ -689,12 +841,16 @@ FcDirCacheValidateHelper (int fd, struct stat *fd_stat, struct stat *dir_stat, v ret = FcFalse; else if (c.magic != FC_CACHE_MAGIC_MMAP) ret = FcFalse; - else if (c.version < FC_CACHE_CONTENT_VERSION) + else if (c.version < FC_CACHE_VERSION_NUMBER) ret = FcFalse; else if (fd_stat->st_size != c.size) ret = FcFalse; - else if (c.mtime != (int) dir_stat->st_mtime) + else if (c.checksum != (int) dir_stat->st_mtime) + ret = FcFalse; +#ifdef HAVE_STRUCT_STAT_ST_MTIM + else if (c.checksum_nano != dir_stat->st_mtim.tv_nsec) ret = FcFalse; +#endif return ret; } @@ -766,9 +922,12 @@ FcDirCacheBuild (FcFontSet *set, const FcChar8 *dir, struct stat *dir_stat, FcSt serialize->linear = cache; cache->magic = FC_CACHE_MAGIC_ALLOC; - cache->version = FC_CACHE_CONTENT_VERSION; + cache->version = FC_CACHE_VERSION_NUMBER; cache->size = serialize->size; - cache->mtime = (int) dir_stat->st_mtime; + cache->checksum = (int) dir_stat->st_mtime; +#ifdef HAVE_STRUCT_STAT_ST_MTIM + cache->checksum_nano = dir_stat->st_mtim.tv_nsec; +#endif /* * Serialize directory name @@ -815,31 +974,17 @@ bail1: return NULL; } - -#ifdef _WIN32 -#define mkdir(path,mode) _mkdir(path) -#endif - -static FcBool -FcMakeDirectory (const FcChar8 *dir) +FcCache * +FcDirCacheRebuild (FcCache *cache, struct stat *dir_stat, FcStrSet *dirs) { - FcChar8 *parent; - FcBool ret; + FcCache *new; + FcFontSet *set = FcFontSetDeserialize (FcCacheSet (cache)); + const FcChar8 *dir = FcCacheDir (cache); - if (strlen ((char *) dir) == 0) - return FcFalse; + new = FcDirCacheBuild (set, dir, dir_stat, dirs); + FcFontSetDestroy (set); - parent = FcStrDirname (dir); - if (!parent) - return FcFalse; - if (access ((char *) parent, F_OK) == 0) - ret = mkdir ((char *) dir, 0755) == 0 && chmod ((char *) dir, 0755) == 0; - else if (access ((char *) parent, F_OK) == -1) - ret = FcMakeDirectory (parent) && (mkdir ((char *) dir, 0755) == 0) && chmod ((char *) dir, 0755) == 0; - else - ret = FcFalse; - FcStrFree (parent); - return ret; + return new; } /* write serialized state to the cache file */ @@ -853,11 +998,12 @@ FcDirCacheWrite (FcCache *cache, FcConfig *config) FcAtomic *atomic; FcStrList *list; FcChar8 *cache_dir = NULL; - FcChar8 *test_dir; + FcChar8 *test_dir, *d = NULL; FcCacheSkip *skip; struct stat cache_stat; - int magic; + unsigned int magic; int written; + const FcChar8 *sysroot = FcConfigGetSysRoot (config); /* * Write it to the first directory in the list which is writable @@ -866,10 +1012,18 @@ FcDirCacheWrite (FcCache *cache, FcConfig *config) list = FcStrListCreate (config->cacheDirs); if (!list) return FcFalse; - while ((test_dir = FcStrListNext (list))) { - if (access ((char *) test_dir, W_OK|X_OK) == 0) + while ((test_dir = FcStrListNext (list))) + { + if (d) + FcStrFree (d); + if (sysroot) + d = FcStrBuildFilename (sysroot, test_dir, NULL); + else + d = FcStrCopyFilename (test_dir); + + if (access ((char *) d, W_OK) == 0) { - cache_dir = test_dir; + cache_dir = FcStrCopyFilename (d); break; } else @@ -877,31 +1031,38 @@ FcDirCacheWrite (FcCache *cache, FcConfig *config) /* * If the directory doesn't exist, try to create it */ - if (access ((char *) test_dir, F_OK) == -1) { - if (FcMakeDirectory (test_dir)) + if (access ((char *) d, F_OK) == -1) { + if (FcMakeDirectory (d)) { - cache_dir = test_dir; + cache_dir = FcStrCopyFilename (d); + /* Create CACHEDIR.TAG */ + FcDirCacheCreateTagFile (d); break; } } /* * Otherwise, try making it writable */ - else if (chmod ((char *) test_dir, 0755) == 0) + else if (chmod ((char *) d, 0755) == 0) { - cache_dir = test_dir; + cache_dir = FcStrCopyFilename (d); + /* Try to create CACHEDIR.TAG too */ + FcDirCacheCreateTagFile (d); break; } } } + if (d) + FcStrFree (d); FcStrListDone (list); if (!cache_dir) return FcFalse; FcDirCacheBasename (dir, cache_base); - cache_hashed = FcStrPlus (cache_dir, cache_base); + cache_hashed = FcStrBuildFilename (cache_dir, cache_base, NULL); if (!cache_hashed) return FcFalse; + FcStrFree (cache_dir); if (FcDebug () & FC_DBG_CACHE) printf ("FcDirCacheWriteDir dir \"%s\" file \"%s\"\n", @@ -914,7 +1075,7 @@ FcDirCacheWrite (FcCache *cache, FcConfig *config) if (!FcAtomicLock (atomic)) goto bail3; - fd = open((char *)FcAtomicNewFile (atomic), O_RDWR | O_CREAT | O_BINARY, 0666); + fd = FcOpen((char *)FcAtomicNewFile (atomic), O_RDWR | O_CREAT | O_BINARY, 0666); if (fd == -1) goto bail4; @@ -946,13 +1107,21 @@ FcDirCacheWrite (FcCache *cache, FcConfig *config) * new cache file is not read again. If it's large, we don't do that * such that we reload it, using mmap, which is shared across processes. */ - if (cache->size < FC_CACHE_MIN_MMAP && - (skip = FcCacheFindByAddr (cache)) && - FcStat (cache_hashed, &cache_stat)) + if (cache->size < FC_CACHE_MIN_MMAP && FcStat (cache_hashed, &cache_stat)) { - skip->cache_dev = cache_stat.st_dev; - skip->cache_ino = cache_stat.st_ino; - skip->cache_mtime = cache_stat.st_mtime; + lock_cache (); + if ((skip = FcCacheFindByAddrUnlocked (cache))) + { + skip->cache_dev = cache_stat.st_dev; + skip->cache_ino = cache_stat.st_ino; + skip->cache_mtime = cache_stat.st_mtime; +#ifdef HAVE_STRUCT_STAT_ST_MTIM + skip->cache_mtime_nano = cache_stat.st_mtim.tv_nsec; +#else + skip->cache_mtime_nano = 0; +#endif + } + unlock_cache (); } FcStrFree (cache_hashed); @@ -971,6 +1140,186 @@ FcDirCacheWrite (FcCache *cache, FcConfig *config) return FcFalse; } +FcBool +FcDirCacheClean (const FcChar8 *cache_dir, FcBool verbose) +{ + DIR *d; + struct dirent *ent; + FcChar8 *dir; + FcBool ret = FcTrue; + FcBool remove; + FcCache *cache; + struct stat target_stat; + const FcChar8 *sysroot; + + /* FIXME: this API needs to support non-current FcConfig */ + sysroot = FcConfigGetSysRoot (NULL); + if (sysroot) + dir = FcStrBuildFilename (sysroot, cache_dir, NULL); + else + dir = FcStrCopyFilename (cache_dir); + if (!dir) + { + fprintf (stderr, "Fontconfig error: %s: out of memory\n", cache_dir); + return FcFalse; + } + if (access ((char *) dir, W_OK) != 0) + { + if (verbose || FcDebug () & FC_DBG_CACHE) + printf ("%s: not cleaning %s cache directory\n", dir, + access ((char *) dir, F_OK) == 0 ? "unwritable" : "non-existent"); + goto bail0; + } + if (verbose || FcDebug () & FC_DBG_CACHE) + printf ("%s: cleaning cache directory\n", dir); + d = opendir ((char *) dir); + if (!d) + { + perror ((char *) dir); + ret = FcFalse; + goto bail0; + } + while ((ent = readdir (d))) + { + FcChar8 *file_name; + const FcChar8 *target_dir; + + if (ent->d_name[0] == '.') + continue; + /* skip cache files for different architectures and */ + /* files which are not cache files at all */ + if (strlen(ent->d_name) != 32 + strlen ("-" FC_ARCHITECTURE FC_CACHE_SUFFIX) || + strcmp(ent->d_name + 32, "-" FC_ARCHITECTURE FC_CACHE_SUFFIX)) + continue; + + file_name = FcStrBuildFilename (dir, (FcChar8 *)ent->d_name, NULL); + if (!file_name) + { + fprintf (stderr, "Fontconfig error: %s: allocation failure\n", dir); + ret = FcFalse; + break; + } + remove = FcFalse; + cache = FcDirCacheLoadFile (file_name, NULL); + if (!cache) + { + if (verbose || FcDebug () & FC_DBG_CACHE) + printf ("%s: invalid cache file: %s\n", dir, ent->d_name); + remove = FcTrue; + } + else + { + FcChar8 *s; + + target_dir = FcCacheDir (cache); + if (sysroot) + s = FcStrBuildFilename (sysroot, target_dir, NULL); + else + s = FcStrdup (target_dir); + if (stat ((char *) s, &target_stat) < 0) + { + if (verbose || FcDebug () & FC_DBG_CACHE) + printf ("%s: %s: missing directory: %s \n", + dir, ent->d_name, s); + remove = FcTrue; + } + FcDirCacheUnload (cache); + FcStrFree (s); + } + if (remove) + { + if (unlink ((char *) file_name) < 0) + { + perror ((char *) file_name); + ret = FcFalse; + } + } + FcStrFree (file_name); + } + + closedir (d); + bail0: + FcStrFree (dir); + + return ret; +} + +int +FcDirCacheLock (const FcChar8 *dir, + FcConfig *config) +{ + FcChar8 *cache_hashed = NULL; + FcChar8 cache_base[CACHEBASE_LEN]; + FcStrList *list; + FcChar8 *cache_dir; + const FcChar8 *sysroot = FcConfigGetSysRoot (config); + int fd = -1; + + FcDirCacheBasename (dir, cache_base); + list = FcStrListCreate (config->cacheDirs); + if (!list) + return -1; + + while ((cache_dir = FcStrListNext (list))) + { + if (sysroot) + cache_hashed = FcStrBuildFilename (sysroot, cache_dir, cache_base, NULL); + else + cache_hashed = FcStrBuildFilename (cache_dir, cache_base, NULL); + if (!cache_hashed) + break; + fd = FcOpen ((const char *)cache_hashed, O_RDWR); + FcStrFree (cache_hashed); + /* No caches in that directory. simply retry with another one */ + if (fd != -1) + { +#if defined(_WIN32) + if (_locking (fd, _LK_LOCK, 1) == -1) + goto bail; +#else + struct flock fl; + + fl.l_type = F_WRLCK; + fl.l_whence = SEEK_SET; + fl.l_start = 0; + fl.l_len = 0; + fl.l_pid = getpid (); + if (fcntl (fd, F_SETLKW, &fl) == -1) + goto bail; +#endif + break; + } + } + FcStrListDone (list); + return fd; +bail: + FcStrListDone (list); + if (fd != -1) + close (fd); + return -1; +} + +void +FcDirCacheUnlock (int fd) +{ + if (fd != -1) + { +#if defined(_WIN32) + _locking (fd, _LK_UNLCK, 1); +#else + struct flock fl; + + fl.l_type = F_UNLCK; + fl.l_whence = SEEK_SET; + fl.l_start = 0; + fl.l_len = 0; + fl.l_pid = getpid (); + fcntl (fd, F_SETLK, &fl); +#endif + close (fd); + } +} + /* * Hokey little macro trick to permit the definitions of C functions * with the same name as CPP macros @@ -1268,6 +1617,96 @@ static void MD5Transform(FcChar32 buf[4], FcChar32 in[16]) buf[2] += c; buf[3] += d; } + +FcBool +FcDirCacheCreateTagFile (const FcChar8 *cache_dir) +{ + FcChar8 *cache_tag; + int fd; + FILE *fp; + FcAtomic *atomic; + static const FcChar8 cache_tag_contents[] = + "Signature: 8a477f597d28d172789f06886806bc55\n" + "# This file is a cache directory tag created by fontconfig.\n" + "# For information about cache directory tags, see:\n" + "# http://www.brynosaurus.com/cachedir/\n"; + static size_t cache_tag_contents_size = sizeof (cache_tag_contents) - 1; + FcBool ret = FcFalse; + + if (!cache_dir) + return FcFalse; + + if (access ((char *) cache_dir, W_OK) == 0) + { + /* Create CACHEDIR.TAG */ + cache_tag = FcStrBuildFilename (cache_dir, "CACHEDIR.TAG", NULL); + if (!cache_tag) + return FcFalse; + atomic = FcAtomicCreate ((FcChar8 *)cache_tag); + if (!atomic) + goto bail1; + if (!FcAtomicLock (atomic)) + goto bail2; + fd = FcOpen((char *)FcAtomicNewFile (atomic), O_RDWR | O_CREAT, 0644); + if (fd == -1) + goto bail3; + fp = fdopen(fd, "wb"); + if (fp == NULL) + goto bail3; + + fwrite(cache_tag_contents, cache_tag_contents_size, sizeof (FcChar8), fp); + fclose(fp); + + if (!FcAtomicReplaceOrig(atomic)) + goto bail3; + + ret = FcTrue; + bail3: + FcAtomicUnlock (atomic); + bail2: + FcAtomicDestroy (atomic); + bail1: + FcStrFree (cache_tag); + } + + if (FcDebug () & FC_DBG_CACHE) + { + if (ret) + printf ("Created CACHEDIR.TAG at %s\n", cache_dir); + else + printf ("Unable to create CACHEDIR.TAG at %s\n", cache_dir); + } + + return ret; +} + +void +FcCacheCreateTagFile (const FcConfig *config) +{ + FcChar8 *cache_dir = NULL, *d = NULL; + FcStrList *list; + const FcChar8 *sysroot = FcConfigGetSysRoot (config); + + list = FcConfigGetCacheDirs (config); + if (!list) + return; + + while ((cache_dir = FcStrListNext (list))) + { + if (d) + FcStrFree (d); + if (sysroot) + d = FcStrBuildFilename (sysroot, cache_dir, NULL); + else + d = FcStrCopyFilename (cache_dir); + if (FcDirCacheCreateTagFile (d)) + break; + } + if (d) + FcStrFree (d); + FcStrListDone (list); +} + #define __fccache__ #include "fcaliastail.h" #undef __fccache__