X-Git-Url: https://git.wh0rd.org/?a=blobdiff_plain;f=src%2Ffccache.c;h=020230e3e6530f287cde4c8bb9dd274de340ce6c;hb=cf65c0557e9fa1b86003d1ec8643f44f4344ebd2;hp=aafc485cd6bba2fd59aa8090fa4f954e0a90be63;hpb=a81f23c0cecdc5d4cb7a443fdd4527b5f0dbca8a;p=fontconfig.git diff --git a/src/fccache.c b/src/fccache.c index aafc485..020230e 100644 --- a/src/fccache.c +++ b/src/fccache.c @@ -23,24 +23,30 @@ * PERFORMANCE OF THIS SOFTWARE. */ +#include "fcint.h" +#include "../fc-arch/fcarch.h" #include #include #include -#include -#include #include -#include -#include "fcint.h" -#include +#if defined(HAVE_MMAP) || defined(__CYGWIN__) +# include +# include +#elif defined(_WIN32) +# include +#endif #define ENDIAN_TEST 0x12345678 -#define MACHINE_SIGNATURE_SIZE 9 + 5*20 + 1 +#define MACHINE_SIGNATURE_SIZE (9 + 5*20 + 1) +/* for when we don't have sysconf: */ +#define FC_HARDCODED_PAGESIZE 8192 -static int -FcDirCacheOpen (const FcChar8 * dir); +#ifndef O_BINARY +#define O_BINARY 0 +#endif -static char * -FcDirCacheHashName (char * cache_file, int collisions); +static int +FcDirCacheOpen (FcConfig *config, const FcChar8 *dir, FcChar8 **cache_path); static off_t FcCacheSkipToArch (int fd, const char * arch); @@ -165,6 +171,8 @@ FcGlobalCacheDestroy (FcGlobalCache *cache) FcGlobalCacheDirDestroy (d); } FcMemFree (FC_MEM_CACHE, sizeof (FcGlobalCache)); + if (cache->fd != -1) + close (cache->fd); free (cache); } @@ -187,7 +195,7 @@ FcGlobalCacheLoad (FcGlobalCache *cache, if (stat ((char *) cache_file, &cache_stat) < 0) return; - cache->fd = open ((char *) cache_file, O_RDONLY); + cache->fd = open ((char *) cache_file, O_RDONLY | O_BINARY); if (cache->fd == -1) return; @@ -202,7 +210,7 @@ FcGlobalCacheLoad (FcGlobalCache *cache, current_arch_start = FcCacheSkipToArch(cache->fd, current_arch_machine_name); if (current_arch_start < 0) - goto bail_and_destroy; + goto bail1; lseek (cache->fd, current_arch_start, SEEK_SET); if (!FcCacheReadString (cache->fd, candidate_arch_machine_name, @@ -228,7 +236,7 @@ FcGlobalCacheLoad (FcGlobalCache *cache, FcCache md; off_t off; - FcStrSetAdd (staleDirs, FcStrCopy ((FcChar8 *)name_buf)); + FcStrSetAdd (staleDirs, (FcChar8 *)name_buf); /* skip subdirs */ while (FcCacheReadString (cache->fd, subdirName, @@ -312,9 +320,6 @@ FcGlobalCacheReadDir (FcFontSet *set, FcStrSet *dirs, FcGlobalCache * cache, con if (cache->fd == -1) return FcFalse; - if (!(dir = (char *)FcConfigNormalizeFontDir (config, (FcChar8 *)dir))) - return FcFalse; /* non-existing directory */ - for (d = cache->dirs; d; d = d->next) { if (strcmp (d->name, dir) == 0) @@ -358,20 +363,12 @@ FcGlobalCacheDirFind (FcGlobalCache *cache, const char *name) FcBool FcGlobalCacheUpdate (FcGlobalCache *cache, FcStrSet *dirs, - const char *orig_name, + const char *name, FcFontSet *set, FcConfig *config) { FcGlobalCacheDir *d; int i; - const char *name; - - name = (char *)FcConfigNormalizeFontDir (config, (FcChar8 *)orig_name); - if (!name) - { - fprintf(stderr, "Invalid directory name %s\n", orig_name); - return FcFalse; - } d = FcGlobalCacheDirFind (cache, name); @@ -406,7 +403,7 @@ FcGlobalCacheSave (FcGlobalCache *cache, const FcChar8 *cache_file, FcConfig *config) { - int fd, fd_orig, i; + int fd, fd_orig; FcGlobalCacheDir *dir; FcAtomic *atomic; off_t current_arch_start = 0, truncate_to; @@ -427,13 +424,13 @@ FcGlobalCacheSave (FcGlobalCache *cache, if (!FcAtomicLock (atomic)) goto bail1; - fd = open ((char *) FcAtomicNewFile(atomic), O_RDWR | O_CREAT, + fd = open ((char *) FcAtomicNewFile(atomic), O_RDWR | O_CREAT | O_BINARY, S_IRUSR | S_IWUSR); if (fd == -1) goto bail2; FcCacheWriteString (fd, FC_GLOBAL_MAGIC_COOKIE); - fd_orig = open ((char *) FcAtomicOrigFile(atomic), O_RDONLY); + fd_orig = open ((char *) FcAtomicOrigFile(atomic), O_RDONLY | O_BINARY); current_arch_machine_name = FcCacheMachineSignature (); if (fd_orig == -1) @@ -454,8 +451,17 @@ FcGlobalCacheSave (FcGlobalCache *cache, goto bail3; current_arch_start = lseek(fd, 0, SEEK_CUR); +#if defined (HAVE_FTRUNCATE) if (ftruncate (fd, current_arch_start) == -1) goto bail3; +#else +#if defined (HAVE_CHSIZE) + if (chsize (fd, current_arch_start) == -1) + goto bail3; +#else + goto bail3; +#endif +#endif header = malloc (10 + strlen (current_arch_machine_name)); if (!header) @@ -464,6 +470,8 @@ FcGlobalCacheSave (FcGlobalCache *cache, truncate_to = current_arch_start + strlen(current_arch_machine_name) + 11; for (dir = cache->dirs; dir; dir = dir->next) { + int i; + if (dir->state == FcGCDirDisabled) continue; truncate_to += strlen(dir->name) + 1; @@ -482,14 +490,17 @@ FcGlobalCacheSave (FcGlobalCache *cache, if (!FcCacheWriteString (fd, header)) goto bail4; + free (header); + for (dir = cache->dirs; dir; dir = dir->next) { + int i; const char * d; off_t off; if (!dir->name || dir->state == FcGCDirDisabled) continue; - d = (const char *)FcConfigNormalizeFontDir (config, (const FcChar8 *)dir->name); + d = dir->name; if (!d) continue; @@ -594,8 +605,16 @@ static int FcCacheNextOffset(off_t w) { static long pagesize = -1; + + if (w == -1) + return w; + if (pagesize == -1) +#if defined (HAVE_SYSCONF) pagesize = sysconf(_SC_PAGESIZE); +#else + pagesize = FC_HARDCODED_PAGESIZE; +#endif if (w % pagesize == 0) return w; else @@ -630,7 +649,7 @@ FcCacheSkipToArch (int fd, const char * arch) return -1; bs = strtol(candidate_arch_machine_name_count, &candidate_arch, 16); - // count = 0 should probably be distinguished from the !bs condition + /* count = 0 should probably be distinguished from the !bs condition */ if (!bs || bs < strlen (candidate_arch_machine_name_count)) return -1; @@ -639,9 +658,8 @@ FcCacheSkipToArch (int fd, const char * arch) if (strcmp (candidate_arch, arch)==0) return current_arch_start; current_arch_start += bs; + current_arch_start = FcCacheNextOffset (current_arch_start); } - - return -1; } /* Cuts out the segment at the file pointer (moves everything else @@ -661,6 +679,7 @@ FcCacheCopyOld (int fd, int fd_orig, off_t start) loc = 0; lseek (fd, 0, SEEK_SET); lseek (fd_orig, 0, SEEK_SET); + FcCacheSkipString (fd); FcCacheSkipString (fd_orig); do { int b = 8192; @@ -711,56 +730,55 @@ FcCacheCopyOld (int fd, int fd_orig, off_t start) } /* Does not check that the cache has the appropriate arch section. */ -/* Also, this can be fooled if the original location has a stale - * cache, and the hashed location has an up-to-date cache. Oh well, - * sucks to be you in that case! */ FcBool -FcDirCacheValid (const FcChar8 *dir) +FcDirCacheValid (const FcChar8 *dir, FcConfig *config) { - struct stat file_stat, dir_stat; int fd; - if (stat ((char *) dir, &dir_stat) < 0) - return FcFalse; - - fd = FcDirCacheOpen (dir); + fd = FcDirCacheOpen (config, dir, NULL); if (fd < 0) - goto bail; - if (fstat (fd, &file_stat) < 0) - goto bail; - + return FcFalse; close (fd); - /* - * If the directory has been modified more recently than - * the cache file, the cache is not valid - */ - if (dir_stat.st_mtime > file_stat.st_mtime) - return FcFalse; - return FcTrue; - - bail: - close (fd); - return FcFalse; } /* Assumes that the cache file in 'dir' exists. * Checks that the cache has the appropriate arch section. */ FcBool -FcDirCacheHasCurrentArch (const FcChar8 *dir) +FcDirCacheHasCurrentArch (const FcChar8 *dir, FcConfig *config) { int fd; off_t current_arch_start; char *current_arch_machine_name; + FcCache metadata; + char subdirName[FC_MAX_FILE_LEN + 1 + 12 + 1]; - fd = FcDirCacheOpen (dir); + fd = FcDirCacheOpen (config, dir, NULL); if (fd < 0) goto bail; current_arch_machine_name = FcCacheMachineSignature(); current_arch_start = FcCacheSkipToArch(fd, current_arch_machine_name); + + if (current_arch_start >= 0) + { + if (lseek (fd, current_arch_start, SEEK_SET) != current_arch_start) + goto bail1; + + FcCacheSkipString (fd); + + while (FcCacheReadString (fd, subdirName, sizeof (subdirName)) && strlen (subdirName) > 0) + ; + + if (read(fd, &metadata, sizeof(FcCache)) != sizeof(FcCache)) + goto bail1; + + if (metadata.magic != FC_CACHE_MAGIC) + goto bail1; + } + close (fd); if (current_arch_start < 0) @@ -768,72 +786,85 @@ FcDirCacheHasCurrentArch (const FcChar8 *dir) return FcTrue; + bail1: + close (fd); bail: return FcFalse; } -FcBool -FcDirCacheUnlink (const FcChar8 *dir, FcConfig *config) +#define CACHEBASE_LEN (1 + 32 + 1 + sizeof (FC_ARCHITECTURE) + sizeof (FC_CACHE_SUFFIX)) + +static const char bin2hex[] = { '0', '1', '2', '3', + '4', '5', '6', '7', + '8', '9', 'a', 'b', + 'c', 'd', 'e', 'f' }; + +static FcChar8 * +FcDirCacheBasename (const FcChar8 * dir, FcChar8 cache_base[CACHEBASE_LEN]) { - char *cache_file; - char *cache_hashed = 0; - int fd, collisions; - struct stat cache_stat; - char name_buf[FC_MAX_FILE_LEN]; - - dir = FcConfigNormalizeFontDir (config, dir); - cache_file = (char *)FcStrPlus (dir, (FcChar8 *) "/" FC_DIR_CACHE_FILE); - if (!cache_file) - return FcFalse; + unsigned char hash[16]; + FcChar8 *hex_hash; + int cnt; + struct MD5Context ctx; - /* First remove normal cache file. */ - if (stat ((char *) cache_file, &cache_stat) == 0 && - unlink ((char *)cache_file) != 0) - goto bail; + MD5Init (&ctx); + MD5Update (&ctx, (unsigned char *)dir, strlen ((char *) dir)); - /* Next remove any applicable hashed files. */ - fd = -1; collisions = 0; - do - { - if (cache_hashed) - FcStrFree ((FcChar8 *)cache_hashed); + MD5Final (hash, &ctx); - cache_hashed = FcDirCacheHashName (cache_file, collisions++); - if (!cache_hashed) - goto bail; + cache_base[0] = '/'; + hex_hash = cache_base + 1; + for (cnt = 0; cnt < 16; ++cnt) + { + hex_hash[2*cnt ] = bin2hex[hash[cnt] >> 4]; + hex_hash[2*cnt+1] = bin2hex[hash[cnt] & 0xf]; + } + hex_hash[2*cnt] = 0; + strcat ((char *) cache_base, "-" FC_ARCHITECTURE FC_CACHE_SUFFIX); - if (fd > 0) - close (fd); - fd = open(cache_hashed, O_RDONLY); - if (fd == -1) - { - FcStrFree ((FcChar8 *)cache_file); - return FcTrue; - } + return cache_base; +} - if (!FcCacheReadString (fd, name_buf, sizeof (name_buf)) || !strlen(name_buf)) - { - FcStrFree ((FcChar8 *)cache_hashed); - goto bail; - } - } while (strcmp (name_buf, cache_file) != 0); +FcBool +FcDirCacheUnlink (const FcChar8 *dir, FcConfig *config) +{ + int fd = -1; + FcChar8 *cache_hashed = NULL; + FcChar8 cache_base[CACHEBASE_LEN]; + FcStrList *list; + FcChar8 *cache_dir; + char dir_buf[FC_MAX_FILE_LEN]; - close (fd); + FcDirCacheBasename (dir, cache_base); - if (stat ((char *) cache_hashed, &cache_stat) == 0 && - unlink ((char *)cache_hashed) != 0) + list = FcStrListCreate (config->cacheDirs); + if (!list) + return FcFalse; + + while ((cache_dir = FcStrListNext (list))) { - FcStrFree ((FcChar8 *)cache_hashed); - goto bail; + cache_hashed = FcStrPlus (cache_dir, cache_base); + if (!cache_hashed) + break; + fd = open((char *) cache_hashed, O_RDONLY | O_BINARY); + FcStrFree (cache_hashed); + if (fd >= 0) + { + if (FcCacheReadString (fd, dir_buf, sizeof (dir_buf)) && + strcmp (dir_buf, (char *) dir) == 0) + { + close (fd); + if (unlink ((char *) cache_hashed) < 0) + break; + } else + close (fd); + } } - - FcStrFree ((FcChar8 *)cache_file); - FcStrFree ((FcChar8 *)cache_hashed); + FcStrListDone (list); + /* return FcFalse if something went wrong */ + if (cache_dir) + return FcFalse; return FcTrue; - - bail: - FcStrFree ((FcChar8 *)cache_file); - return FcFalse; } static int @@ -842,10 +873,8 @@ FcCacheReadDirs (FcConfig * config, FcGlobalCache * cache, { int ret = 0; FcChar8 *dir; - const FcChar8 *name; FcStrSet *subdirs; FcStrList *sublist; - struct stat statb; FcGlobalCacheDir *d; /* @@ -858,14 +887,13 @@ FcCacheReadDirs (FcConfig * config, FcGlobalCache * cache, /* Skip this directory if already updated * to avoid the looped directories via symlinks + * Clearly a dir not in fonts.conf shouldn't be globally cached. */ - name = FcConfigNormalizeFontDir (config, dir); - if (name) - { - if (FcStrSetMember (processed_dirs, dir)) - continue; - FcStrSetAdd (processed_dirs, dir); - } + + if (FcStrSetMember (processed_dirs, dir)) + continue; + if (!FcStrSetAdd (processed_dirs, dir)) + continue; subdirs = FcStrSetCreate (); if (!subdirs) @@ -875,39 +903,10 @@ FcCacheReadDirs (FcConfig * config, FcGlobalCache * cache, continue; } - if (access ((char *) dir, X_OK) < 0) - { - switch (errno) { - case ENOENT: - case ENOTDIR: - case EACCES: - break; - default: - fprintf (stderr, "\"%s\": ", dir); - perror (""); - ret++; - } - FcStrSetDestroy (subdirs); - continue; - } - if (stat ((char *) dir, &statb) == -1) - { - fprintf (stderr, "\"%s\": ", dir); - perror (""); - FcStrSetDestroy (subdirs); - ret++; - continue; - } - if (!S_ISDIR (statb.st_mode)) - { - fprintf (stderr, "\"%s\": not a directory, skipping\n", dir); - FcStrSetDestroy (subdirs); - continue; - } - if (FcDirCacheValid (dir) && FcDirCacheRead (set, subdirs, dir, config)) + if (FcDirCacheRead (set, subdirs, dir, config)) { /* if an old entry is found in the global cache, disable it */ - if ((d = FcGlobalCacheDirFind (cache, (const char *)name)) != NULL) + if ((d = FcGlobalCacheDirFind (cache, (const char *)dir)) != NULL) { d->state = FcGCDirDisabled; /* save the updated config later without this entry */ @@ -962,111 +961,67 @@ FcCacheRead (FcConfig *config, FcGlobalCache * cache) return 0; } -static const char bin2hex[] = { '0', '1', '2', '3', - '4', '5', '6', '7', - '8', '9', 'a', 'b', - 'c', 'd', 'e', 'f' }; - -static char * -FcDirCacheHashName (char * cache_file, int collisions) +/* Opens the cache file for 'dir' for reading. + * This searches the list of cache dirs for the relevant cache file, + * returning the first one found. + */ +static int +FcDirCacheOpen (FcConfig *config, const FcChar8 *dir, FcChar8 **cache_path) { - unsigned char hash[16], hex_hash[33]; - char *cache_hashed; - unsigned char uscore = '_'; - int cnt, i; - FcChar8 *tmp; - struct MD5Context ctx; - - MD5Init (&ctx); - MD5Update (&ctx, (unsigned char *)cache_file, strlen (cache_file)); + int fd = -1; + FcChar8 *cache_hashed = NULL; + FcChar8 cache_base[CACHEBASE_LEN]; + FcStrList *list; + FcChar8 *cache_dir; + char dir_buf[FC_MAX_FILE_LEN]; + struct stat file_stat, dir_stat; - for (i = 0; i < collisions; i++) - MD5Update (&ctx, &uscore, 1); + if (stat ((char *) dir, &dir_stat) < 0) + return -1; - MD5Final (hash, &ctx); + FcDirCacheBasename (dir, cache_base); - for (cnt = 0; cnt < 16; ++cnt) + list = FcStrListCreate (config->cacheDirs); + if (!list) + return -1; + + while ((cache_dir = FcStrListNext (list))) { - hex_hash[2*cnt] = bin2hex[hash[cnt] >> 4]; - hex_hash[2*cnt+1] = bin2hex[hash[cnt] & 0xf]; + cache_hashed = FcStrPlus (cache_dir, cache_base); + if (!cache_hashed) + break; + fd = open((char *) cache_hashed, O_RDONLY | O_BINARY); + if (fd >= 0) { + if (fstat (fd, &file_stat) >= 0 && + dir_stat.st_mtime <= file_stat.st_mtime) + { + break; + } + close (fd); + fd = -1; + } + FcStrFree (cache_hashed); + cache_hashed = NULL; } - hex_hash[32] = 0; - - tmp = FcStrPlus ((FcChar8 *)hex_hash, (FcChar8 *)FC_CACHE_SUFFIX); - if (!tmp) - return 0; - - cache_hashed = (char *)FcStrPlus ((FcChar8 *)PKGCACHEDIR"/", tmp); - free (tmp); - - return cache_hashed; -} - -/* Opens the hashed name for cache_file. - * This would fail in the unlikely event of a collision and subsequent - * removal of the file which originally caused the collision. */ -static int -FcDirCacheOpen (const FcChar8 *dir) -{ - FcBool found; - int fd = -1, collisions = 0; - char *cache_file, *cache_hashed; - char name_buf[FC_MAX_FILE_LEN]; - struct stat dir_stat; - - cache_file = (char *)FcStrPlus (dir, (FcChar8 *) "/" FC_DIR_CACHE_FILE); - if (!cache_file) - return -1; - - fd = open(cache_file, O_RDONLY); - if (fd != -1) - return fd; + FcStrListDone (list); - if (stat ((char *)dir, &dir_stat) == -1) + if (fd < 0) return -1; - - found = FcFalse; - do + + if (!FcCacheReadString (fd, dir_buf, sizeof (dir_buf)) || + strcmp (dir_buf, (char *) dir) != 0) { - struct stat c; - FcChar8 * name_buf_dir; - - cache_hashed = FcDirCacheHashName (cache_file, collisions++); - if (!cache_hashed) - { - FcStrFree ((FcChar8 *)cache_file); - return -1; - } - - if (fd > 0) - close (fd); - fd = open(cache_hashed, O_RDONLY); - FcStrFree ((FcChar8 *)cache_hashed); - - if (fd == -1) - { - FcStrFree ((FcChar8 *)cache_file); - return -1; - } - if (!FcCacheReadString (fd, name_buf, sizeof (name_buf)) || !strlen(name_buf)) - goto bail; + close (fd); + FcStrFree (cache_hashed); + return -1; + } + + if (cache_path) + *cache_path = cache_hashed; + else + FcStrFree (cache_hashed); - name_buf_dir = FcStrDirname ((FcChar8 *)name_buf); - if (stat ((char *)name_buf_dir, &c) == -1) - { - FcStrFree (name_buf_dir); - continue; - } - FcStrFree (name_buf_dir); - found = (c.st_ino == dir_stat.st_ino) && (c.st_dev == dir_stat.st_dev); - } while (!found); - FcStrFree ((FcChar8 *)cache_file); return fd; - - bail: - FcStrFree ((FcChar8 *)cache_file); - close (fd); - return -1; } /* read serialized state from the cache file */ @@ -1079,7 +1034,7 @@ FcDirCacheRead (FcFontSet * set, FcStrSet * dirs, const FcChar8 *dir, FcConfig * off_t current_arch_start = 0; char subdirName[FC_MAX_FILE_LEN + 1 + 12 + 1]; - fd = FcDirCacheOpen (dir); + fd = FcDirCacheOpen (config, dir, NULL); if (fd < 0) goto bail; @@ -1114,7 +1069,7 @@ FcDirCacheConsume (int fd, const char * dir, FcFontSet *set, FcConfig *config) { FcCache metadata; void * current_dir_block; - off_t pos; + off_t pos, endpos; if (read(fd, &metadata, sizeof(FcCache)) != sizeof(FcCache)) return FcFalse; @@ -1131,20 +1086,65 @@ FcDirCacheConsume (int fd, const char * dir, FcFontSet *set, FcConfig *config) } pos = FcCacheNextOffset (lseek(fd, 0, SEEK_CUR)); + + /* This is not failsafe (multi-arches can break it), + * but fd has got to have at least as many bytes as + * metadata.count, or something's going to go horribly wrong. */ + if (pos == (off_t)-1) + return FcFalse; + + endpos = lseek (fd, 0, SEEK_END); + if (endpos == (off_t)-1 || endpos - pos < metadata.count) + return FcFalse; + if (lseek (fd, pos, SEEK_SET) == -1) + return FcFalse; + +#if defined(HAVE_MMAP) || defined(__CYGWIN__) current_dir_block = mmap (0, metadata.count, PROT_READ, MAP_SHARED, fd, pos); - lseek (fd, pos+metadata.count, SEEK_SET); if (current_dir_block == MAP_FAILED) return FcFalse; +#elif defined(_WIN32) + { + HANDLE hFileMap; + + hFileMap = CreateFileMapping((HANDLE) _get_osfhandle(fd), NULL, PAGE_READONLY, 0, 0, NULL); + if (hFileMap == NULL) + return FcFalse; + + current_dir_block = MapViewOfFile (hFileMap, FILE_MAP_READ, 0, 0, metadata.count + pos); + if (current_dir_block == NULL) + { + CloseHandle (hFileMap); + return FcFalse; + } + + current_dir_block = (void *)((char *)current_dir_block + pos); + } +#else + current_dir_block = malloc (metadata.count); + if (!current_dir_block) + return FcFalse; + + /* could also use CreateMappedViewOfFile under MinGW... */ + if (read (fd, current_dir_block, metadata.count) != metadata.count) + goto bail; +#endif + lseek (fd, pos+metadata.count, SEEK_SET); FcCacheAddBankDir (metadata.bank, dir); if (config) FcConfigAddFontDir (config, (FcChar8 *)dir); if (!FcFontSetUnserialize (&metadata, set, current_dir_block)) - return FcFalse; + goto bail; return FcTrue; + bail: +#if !(defined(HAVE_MMAP) || defined(__CYGWIN__)) + free (current_dir_block); +#endif + return FcFalse; } static void * @@ -1154,12 +1154,24 @@ FcDirCacheProduce (FcFontSet *set, FcCache *metadata) static unsigned int rand_state = 0; int bank, needed_bytes_no_align; +#if defined (HAVE_RAND_R) if (!rand_state) rand_state = time(0L); bank = rand_r(&rand_state); while (FcCacheHaveBank(bank)) bank = rand_r(&rand_state); +#else + if (!rand_state) + { + rand_state = 1; + srand (time (0L)); + } + bank = rand(); + + while (FcCacheHaveBank(bank)) + bank = rand(); +#endif memset (metadata, 0, sizeof(FcCache)); FcFontSetNewBank(); @@ -1179,7 +1191,7 @@ FcDirCacheProduce (FcFontSet *set, FcCache *metadata) current_dir_block = malloc (metadata->count); if (!current_dir_block) goto bail; - // shut up valgrind + /* shut up valgrind */ memset (current_dir_block, 0, metadata->count); final_dir_block = FcFontSetDistributeBytes (metadata, current_dir_block); @@ -1196,55 +1208,78 @@ FcDirCacheProduce (FcFontSet *set, FcCache *metadata) return 0; } +static FcBool +FcMakeDirectory (const FcChar8 *dir) +{ + FcChar8 *parent; + FcBool ret; + + if (strlen ((char *) dir) == 0) + return FcFalse; + + parent = FcStrDirname (dir); + if (!parent) + return FcFalse; + if (access ((char *) parent, W_OK|X_OK) == 0) + ret = mkdir ((char *) dir, 0777) == 0; + else if (access ((char *) parent, F_OK) == -1) + ret = FcMakeDirectory (parent) && (mkdir ((char *) dir, 0777) == 0); + else + ret = FcFalse; + FcStrFree (parent); + return ret; +} + /* write serialized state to the cache file */ FcBool -FcDirCacheWrite (FcFontSet *set, FcStrSet *dirs, const FcChar8 *dir) +FcDirCacheWrite (FcFontSet *set, FcStrSet *dirs, const FcChar8 *dir, FcConfig *config) { - char *cache_file; - char *cache_hashed; + FcChar8 cache_base[CACHEBASE_LEN]; + FcChar8 *cache_hashed; int fd, fd_orig, i, dirs_count; FcAtomic *atomic; FcCache metadata; off_t current_arch_start = 0, truncate_to; - char name_buf[FC_MAX_FILE_LEN]; - int collisions; - + FcStrList *list; char *current_arch_machine_name, * header; void *current_dir_block = 0; + FcChar8 *cache_dir = NULL; + FcChar8 *test_dir; - dir = FcConfigNormalizeFontDir (FcConfigGetCurrent(), dir); - if (!dir) + /* + * Write it to the first directory in the list which is writable + */ + + list = FcStrListCreate (config->cacheDirs); + if (!list) return FcFalse; - - cache_file = (char *)FcStrPlus (dir, (FcChar8 *) "/" FC_DIR_CACHE_FILE); - if (!cache_file) - goto bail; - - /* Ensure that we're not trampling a cache for some other dir. */ - /* This is slightly different from FcDirCacheOpen, since it - * needs the filename, not the file descriptor. */ - fd = -1; collisions = 0; - do - { - cache_hashed = FcDirCacheHashName (cache_file, collisions++); - if (!cache_hashed) - goto bail0; - - if (fd > 0) - close (fd); - fd = open(cache_hashed, O_RDONLY); - if (fd == -1) - break; - if(!FcCacheReadString (fd, name_buf, sizeof (name_buf)) || !strlen(name_buf)) + while ((test_dir = FcStrListNext (list))) { + if (access ((char *) test_dir, W_OK|X_OK) == 0) { - close (fd); + cache_dir = test_dir; break; } - close (fd); - - if (strcmp (name_buf, cache_file) != 0) - continue; - } while (0); + else + { + /* + * If the directory doesn't exist, try to create it + */ + if (access ((char *) test_dir, F_OK) == -1) { + if (FcMakeDirectory (test_dir)) + { + cache_dir = test_dir; + break; + } + } + } + } + FcStrListDone (list); + if (!cache_dir) + return FcFalse; + FcDirCacheBasename (dir, cache_base); + cache_hashed = FcStrPlus (cache_dir, cache_base); + if (!cache_hashed) + return FcFalse; current_dir_block = FcDirCacheProduce (set, &metadata); @@ -1252,38 +1287,24 @@ FcDirCacheWrite (FcFontSet *set, FcStrSet *dirs, const FcChar8 *dir) goto bail1; if (FcDebug () & FC_DBG_CACHE) - printf ("FcDirCacheWriteDir cache_file \"%s\"\n", cache_file); + printf ("FcDirCacheWriteDir dir \"%s\" file \"%s\"\n", + dir, cache_hashed); atomic = FcAtomicCreate ((FcChar8 *)cache_hashed); if (!atomic) goto bail1; if (!FcAtomicLock (atomic)) - { - /* Now try rewriting the original version of the file. */ - FcAtomicDestroy (atomic); - - atomic = FcAtomicCreate ((FcChar8 *)cache_file); - fd_orig = open (cache_file, O_RDONLY); - if (fd_orig == -1) - fd_orig = open((char *)FcAtomicOrigFile (atomic), O_RDONLY); - - fd = open((char *)FcAtomicNewFile (atomic), O_RDWR | O_CREAT, 0666); - if (fd == -1) - goto bail2; - } + goto bail2; - /* In all cases, try opening the real location of the cache file first. */ - /* (even if that's not atomic.) */ - fd_orig = open (cache_file, O_RDONLY); - if (fd_orig == -1) - fd_orig = open((char *)FcAtomicOrigFile (atomic), O_RDONLY); + /* open the original file to save relevant portions */ + fd_orig = open((char *)FcAtomicOrigFile (atomic), O_RDONLY | O_BINARY); - fd = open((char *)FcAtomicNewFile (atomic), O_RDWR | O_CREAT, 0666); + fd = open((char *)FcAtomicNewFile (atomic), O_RDWR | O_CREAT | O_BINARY, 0666); if (fd == -1) goto bail3; - FcCacheWriteString (fd, cache_file); + FcCacheWriteString (fd, (char *) dir); current_arch_machine_name = FcCacheMachineSignature (); current_arch_start = 0; @@ -1294,10 +1315,8 @@ FcDirCacheWrite (FcFontSet *set, FcStrSet *dirs, const FcChar8 *dir) if (current_arch_start < 0) { - off_t i = lseek(fd_orig, 0, SEEK_END); - if (i < strlen (FC_GLOBAL_MAGIC_COOKIE)+1) - i = strlen (FC_GLOBAL_MAGIC_COOKIE)+1; - current_arch_start = FcCacheNextOffset (i); + off_t offset = lseek(fd_orig, 0, SEEK_END); + current_arch_start = FcCacheNextOffset (offset); } if (fd_orig != -1 && !FcCacheCopyOld(fd, fd_orig, current_arch_start)) @@ -1307,8 +1326,17 @@ FcDirCacheWrite (FcFontSet *set, FcStrSet *dirs, const FcChar8 *dir) close (fd_orig); current_arch_start = lseek(fd, 0, SEEK_CUR); +#if defined (HAVE_FTRUNCATE) if (ftruncate (fd, current_arch_start) == -1) goto bail4; +#else +#if defined (HAVE_CHSIZE) + if (chsize (fd, current_arch_start) == -1) + goto bail4; +#else + goto bail4; +#endif +#endif /* allocate space for subdir names in this block */ dirs_count = 0; @@ -1344,18 +1372,27 @@ FcDirCacheWrite (FcFontSet *set, FcStrSet *dirs, const FcChar8 *dir) metadata.count) perror("write current_dir_block"); free (current_dir_block); + current_dir_block = 0; } /* this actually serves to pad out the cache file, if needed */ +#if defined (HAVE_FTRUNCATE) if (ftruncate (fd, current_arch_start + truncate_to) == -1) goto bail5; +#else +#if defined (HAVE_CHSIZE) + if (chsize (fd, current_arch_start + truncate_to) == -1) + goto bail5; +#else + goto bail5; +#endif +#endif free (header); close(fd); if (!FcAtomicReplaceOrig(atomic)) - goto bail5; + goto bail3; FcStrFree ((FcChar8 *)cache_hashed); - FcStrFree ((FcChar8 *)cache_file); FcAtomicUnlock (atomic); FcAtomicDestroy (atomic); return FcTrue; @@ -1370,12 +1407,8 @@ FcDirCacheWrite (FcFontSet *set, FcStrSet *dirs, const FcChar8 *dir) FcAtomicDestroy (atomic); bail1: FcStrFree ((FcChar8 *)cache_hashed); - bail0: - unlink ((char *)cache_file); - FcStrFree ((FcChar8 *)cache_file); if (current_dir_block) free (current_dir_block); - bail: return FcFalse; } @@ -1409,7 +1442,11 @@ FcCacheMachineSignature () (unsigned int)sizeof (FcCharLeaf), (unsigned int)sizeof (FcChar32), (unsigned int)sizeof (FcCache), +#if defined (HAVE_SYSCONF) (unsigned int)sysconf(_SC_PAGESIZE)); +#else + (unsigned int)FC_HARDCODED_PAGESIZE); +#endif return buf; }