X-Git-Url: https://git.wh0rd.org/?a=blobdiff_plain;f=src%2Ffccache.c;h=020230e3e6530f287cde4c8bb9dd274de340ce6c;hb=cf65c0557e9fa1b86003d1ec8643f44f4344ebd2;hp=042439ee342cba14245e6bc87cb56a5826b75957;hpb=c814c301ee4dcc67eeacee9608fb716e67534356;p=fontconfig.git

diff --git a/src/fccache.c b/src/fccache.c
index 042439e..020230e 100644
--- a/src/fccache.c
+++ b/src/fccache.c
@@ -23,16 +23,17 @@
  * PERFORMANCE OF THIS SOFTWARE.
  */
 
+#include "fcint.h"
+#include "../fc-arch/fcarch.h"
 #include <fcntl.h>
 #include <dirent.h>
 #include <string.h>
 #include <sys/types.h>
-#include <unistd.h>
-#include "fcint.h"
-#include <unistd.h>
 #if defined(HAVE_MMAP) || defined(__CYGWIN__)
+#  include <unistd.h>
 #  include <sys/mman.h>
-#  include <sys/utsname.h>
+#elif defined(_WIN32)
+#  include <windows.h>
 #endif
 
 #define ENDIAN_TEST 0x12345678
@@ -45,10 +46,7 @@
 #endif
 
 static int
-FcDirCacheOpen (const FcChar8 * dir);
-
-static char *
-FcDirCacheHashName (char * cache_file, int collisions);
+FcDirCacheOpen (FcConfig *config, const FcChar8 *dir, FcChar8 **cache_path);
 
 static off_t
 FcCacheSkipToArch (int fd, const char * arch);
@@ -173,6 +171,8 @@ FcGlobalCacheDestroy (FcGlobalCache *cache)
 	FcGlobalCacheDirDestroy (d);
     }
     FcMemFree (FC_MEM_CACHE, sizeof (FcGlobalCache));
+    if (cache->fd != -1)
+	close (cache->fd);
     free (cache);
 }
 
@@ -320,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)
@@ -366,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);
 
@@ -511,7 +500,7 @@ FcGlobalCacheSave (FcGlobalCache    *cache,
 
 	if (!dir->name || dir->state == FcGCDirDisabled)
 	    continue;
-	d = (const char *)FcConfigNormalizeFontDir (config, (const FcChar8 *)dir->name);
+	d = dir->name;
 	if (!d) 
 	    continue;
 	    
@@ -616,6 +605,10 @@ 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);
@@ -737,45 +730,24 @@ 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)
 	return FcFalse;
-    if (fstat (fd, &file_stat) < 0)
-	goto bail;
-
     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;
@@ -783,7 +755,7 @@ FcDirCacheHasCurrentArch (const FcChar8 *dir)
     FcCache	metadata;
     char 	subdirName[FC_MAX_FILE_LEN + 1 + 12 + 1];
 
-    fd = FcDirCacheOpen (dir);
+    fd = FcDirCacheOpen (config, dir, NULL);
     if (fd < 0)
 	goto bail;
 
@@ -820,67 +792,79 @@ FcDirCacheHasCurrentArch (const FcChar8 *dir)
     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);
+    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 | O_BINARY);
-	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
@@ -891,7 +875,6 @@ FcCacheReadDirs (FcConfig * config, FcGlobalCache * cache,
     FcChar8		*dir;
     FcStrSet		*subdirs;
     FcStrList		*sublist;
-    struct stat		statb;
     FcGlobalCacheDir   *d;
 
     /*
@@ -906,9 +889,6 @@ FcCacheReadDirs (FcConfig * config, FcGlobalCache * cache,
 	 * to avoid the looped directories via symlinks
 	 * Clearly a dir not in fonts.conf shouldn't be globally cached.
 	 */
-	dir = (FcChar8 *)FcConfigNormalizeFontDir (config, dir);
-	if (!dir)
-	    continue;
 
 	if (FcStrSetMember (processed_dirs, dir))
 	    continue;
@@ -923,38 +903,7 @@ 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) && 
-	    FcDirCacheHasCurrentArch (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 *)dir)) != NULL)
@@ -1012,108 +961,66 @@ 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)
-{
-    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));
-
-    for (i = 0; i < collisions; i++)
-	MD5Update (&ctx, &uscore, 1);
-
-    MD5Final (hash, &ctx);
-
-    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[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. */
+/* 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 (const FcChar8 *dir)
+FcDirCacheOpen (FcConfig *config, const FcChar8 *dir, FcChar8 **cache_path)
 {
-    FcBool	found;
-    int		fd = -1, collisions = 0;
-    char	*cache_file, *cache_hashed;
-    char	name_buf[FC_MAX_FILE_LEN];
-    struct stat dir_stat;
+    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;
 
-    if (stat ((char *)dir, &dir_stat) == -1)
-	return -1;
+    if (stat ((char *) dir, &dir_stat) < 0)
+        return -1;
 
-    cache_file = (char *)FcStrPlus (dir, (FcChar8 *) "/" FC_DIR_CACHE_FILE);
-    if (!cache_file)
-	return -1;
+    FcDirCacheBasename (dir, cache_base);
 
-    found = FcFalse;
-    do
+    list = FcStrListCreate (config->cacheDirs);
+    if (!list)
+        return -1;
+	
+    while ((cache_dir = FcStrListNext (list)))
     {
-	struct stat 	c;
-	FcChar8 	*name_buf_dir;
-
-	if (fd >= 0)
-	    close (fd);
-
-	cache_hashed = FcDirCacheHashName (cache_file, collisions++);
-	if (!cache_hashed)
-	{
-	    FcStrFree ((FcChar8 *)cache_file);
-	    return -1;
-	}
-
-	fd = open(cache_hashed, O_RDONLY | O_BINARY);
-	FcStrFree ((FcChar8 *)cache_hashed);
-
-	if (fd == -1)
-	    break;
-	if (!FcCacheReadString (fd, name_buf, sizeof (name_buf)) || 
-	    !strlen(name_buf))
+        cache_hashed = FcStrPlus (cache_dir, cache_base);
+        if (!cache_hashed)
 	    break;
-
-	name_buf_dir = FcStrDirname ((FcChar8 *)name_buf);
-	if (stat ((char *)name_buf_dir, &c) == -1)
-	{
-	    FcStrFree (name_buf_dir);
-	    continue;
+        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 (name_buf_dir);
-	found = (c.st_ino == dir_stat.st_ino) && (c.st_dev == dir_stat.st_dev);
-    } while (!found);
+	FcStrFree (cache_hashed);
+	cache_hashed = NULL;
+    }
+    FcStrListDone (list);
 
-    if (!found || fd < 0) 
+    if (fd < 0)
+	return -1;
+    
+    if (!FcCacheReadString (fd, dir_buf, sizeof (dir_buf)) ||
+	strcmp (dir_buf, (char *) dir) != 0)
     {
-	if (fd >= 0)
-	    close (fd);
-	fd = open(cache_file, O_RDONLY | O_BINARY);
+    	close (fd);
+        FcStrFree (cache_hashed);
+        return -1;
     }
+    
+    if (cache_path)
+	*cache_path = cache_hashed;
+    else
+	FcStrFree (cache_hashed);
 
-    FcStrFree ((FcChar8 *)cache_file);
     return fd;
 }
 
@@ -1127,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;
 
@@ -1162,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;
@@ -1179,11 +1086,41 @@ 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);
     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)
@@ -1271,61 +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 | O_BINARY);
-	if (fd == -1)
+    while ((test_dir = FcStrListNext (list))) {
+	if (access ((char *) test_dir, W_OK|X_OK) == 0)
+	{
+	    cache_dir = test_dir;
 	    break;
-	if(!FcCacheReadString (fd, name_buf, sizeof (name_buf)) || !strlen(name_buf))
+	}
+	else
 	{
-	    close (fd);
-            FcStrFree ((FcChar8 *)cache_hashed);
-	    continue;
+	    /*
+	     * 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;
+		}
+	    }
 	}
-	close (fd);
-
-	if (strcmp (name_buf, cache_file) != 0) 
-        {
-            FcStrFree ((FcChar8 *)cache_hashed);
-	    continue;
-        }
-
-	break;
-    } while (1);
+    }
+    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);
 
@@ -1333,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 | O_BINARY);
-	if (fd_orig == -1)
-	    fd_orig = open((char *)FcAtomicOrigFile (atomic), O_RDONLY | O_BINARY);
-
-	fd = open((char *)FcAtomicNewFile (atomic), O_RDWR | O_CREAT | O_BINARY, 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 | O_BINARY);
-    if (fd_orig == -1)
-	fd_orig = open((char *)FcAtomicOrigFile (atomic), O_RDONLY | O_BINARY);
+    /* 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 | 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;
@@ -1453,7 +1393,6 @@ FcDirCacheWrite (FcFontSet *set, FcStrSet *dirs, const FcChar8 *dir)
     if (!FcAtomicReplaceOrig(atomic))
         goto bail3;
     FcStrFree ((FcChar8 *)cache_hashed);
-    FcStrFree ((FcChar8 *)cache_file);
     FcAtomicUnlock (atomic);
     FcAtomicDestroy (atomic);
     return FcTrue;
@@ -1468,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;
 }