Add a condition to FcCacheOffsetsValid() for detecting empty data of cache
[platform/upstream/fontconfig.git] / src / fccache.c
index 610b8f0..f9e66e8 100644 (file)
@@ -20,9 +20,6 @@
  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  * PERFORMANCE OF THIS SOFTWARE.
  */
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
 #include "fcint.h"
 #include "fcarch.h"
 #include <stdio.h>
 #include <fcntl.h>
 #include <dirent.h>
 #include <string.h>
+#include <limits.h>
 #include <sys/types.h>
-#include <time.h>
+#include <sys/stat.h>
 #include <assert.h>
 #if defined(HAVE_MMAP) || defined(__CYGWIN__)
 #  include <unistd.h>
 #  include <sys/mman.h>
 #endif
+#if defined(_WIN32)
+#include <sys/locking.h>
+#endif
 
 #ifndef O_BINARY
 #define O_BINARY 0
@@ -125,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);
 
@@ -134,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);
@@ -176,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 (FcStatChecksum (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);
 
@@ -198,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)
            {
@@ -238,6 +257,7 @@ struct _FcCacheSkip {
     dev_t          cache_dev;
     ino_t          cache_ino;
     time_t         cache_mtime;
+    long           cache_mtime_nano;
     FcCacheSkip            *next[1];
 };
 
@@ -253,62 +273,6 @@ static FcCacheSkip *fcCacheChains[FC_CACHE_MAX_LEVEL];
 static int             fcCacheMaxLevel;
 
 
-static int32_t
-FcRandom(void)
-{
-    int32_t result;
-
-#if HAVE_RANDOM_R
-    static struct random_data fcrandbuf;
-    static char statebuf[256];
-    static FcBool initialized = FcFalse;
-
-    if (initialized != FcTrue)
-    {
-       initstate_r(time(NULL), statebuf, 256, &fcrandbuf);
-       initialized = FcTrue;
-    }
-
-    random_r(&fcrandbuf, &result);
-#elif HAVE_RANDOM
-    static char statebuf[256];
-    char *state;
-    static FcBool initialized = FcFalse;
-
-    if (initialized != FcTrue)
-    {
-       state = initstate(time(NULL), statebuf, 256);
-       initialized = FcTrue;
-    }
-    else
-       state = setstate(statebuf);
-
-    result = random();
-
-    setstate(state);
-#elif HAVE_LRAND48
-    result = lrand48();
-#elif HAVE_RAND_R
-    static unsigned int seed = time(NULL);
-
-    result = rand_r(&seed);
-#elif HAVE_RAND
-    static FcBool initialized = FcFalse;
-
-    if (initialized != FcTrue)
-    {
-       srand(time(NULL));
-       initialized = FcTrue;
-    }
-    result = rand();
-#else
-# error no random number generator function available.
-#endif
-
-    return result;
-}
-
-
 static FcMutex *cache_lock;
 
 static void
@@ -421,12 +385,18 @@ FcCacheInsert (FcCache *cache, struct stat *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;
     }
 
     /*
@@ -514,6 +484,10 @@ FcCacheFindByStat (struct stat *cache_stat)
            s->cache_ino == cache_stat->st_ino &&
            s->cache_mtime == cache_stat->st_mtime)
        {
+#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;
@@ -578,37 +552,151 @@ FcCacheFini (void)
 }
 
 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 (FcStatChecksum (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 checksum %d dir checksum %d\n",
                FcCacheDir (cache), cache->checksum, (int) dir_stat->st_mtime);
-    return 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 < (int) 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;
@@ -622,7 +710,7 @@ FcDirCacheMapFd (int fd, struct stat *fd_stat, struct stat *dir_stat)
     {
 #if defined(HAVE_MMAP) || defined(__CYGWIN__)
        cache = mmap (0, fd_stat->st_size, PROT_READ, MAP_SHARED, fd, 0);
-#ifdef HAVE_POSIX_FADVISE
+#if (HAVE_POSIX_FADVISE) && defined(POSIX_FADV_WILLNEED)
        posix_fadvise (fd, 0, fd_stat->st_size, POSIX_FADV_WILLNEED);
 #endif
        if (cache == MAP_FAILED)
@@ -657,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->version < FC_CACHE_VERSION_NUMBER ||
        cache->size != (intptr_t) fd_stat->st_size ||
-       !FcCacheTimeValid (cache, dir_stat) ||
+        !FcCacheOffsetsValid (cache) ||
+       !FcCacheTimeValid (config, cache, dir_stat) ||
        !FcCacheInsert (cache, fd_stat))
     {
        if (allocated)
@@ -698,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;
@@ -717,6 +806,7 @@ FcDirCacheLoad (const FcChar8 *dir, FcConfig *config, FcChar8 **cache_file)
                            FcDirCacheMapHelper,
                            &cache, cache_file))
        return NULL;
+
     return cache;
 }
 
@@ -732,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;
 }
@@ -742,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 FC_UNUSED)
+FcDirCacheValidateHelper (FcConfig *config, int fd, struct stat *fd_stat, struct stat *dir_stat, void *closure FC_UNUSED)
 {
     FcBool  ret = FcTrue;
     FcCache    c;
@@ -751,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.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;
 }
 
@@ -828,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->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
@@ -877,32 +974,17 @@ bail1:
     return NULL;
 }
 
-
-#ifdef _WIN32
-#include <direct.h>
-#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 */
@@ -916,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;
     unsigned int    magic;
     int                    written;
+    const FcChar8   *sysroot = FcConfigGetSysRoot (config);
 
     /*
      * Write it to the first directory in the list which is writable
@@ -929,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) == 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
@@ -940,35 +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 (cache_dir);
+                   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 (cache_dir);
+               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",
@@ -1021,6 +1115,11 @@ FcDirCacheWrite (FcCache *cache, FcConfig *config)
            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 ();
     }
@@ -1046,31 +1145,37 @@ FcDirCacheClean (const FcChar8 *cache_dir, FcBool verbose)
 {
     DIR                *d;
     struct dirent *ent;
-    FcChar8    *dir_base;
+    FcChar8    *dir;
     FcBool     ret = FcTrue;
     FcBool     remove;
     FcCache    *cache;
     struct stat        target_stat;
+    const FcChar8 *sysroot;
 
-    dir_base = FcStrPlus (cache_dir, (FcChar8 *) FC_DIR_SEPARATOR_S);
-    if (!dir_base)
+    /* 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 *) cache_dir, W_OK) != 0)
+    if (access ((char *) dir, W_OK) != 0)
     {
        if (verbose || FcDebug () & FC_DBG_CACHE)
-           printf ("%s: not cleaning %s cache directory\n", cache_dir,
-                   access ((char *) cache_dir, F_OK) == 0 ? "unwritable" : "non-existent");
+           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", cache_dir);
-    d = opendir ((char *) cache_dir);
+       printf ("%s: cleaning cache directory\n", dir);
+    d = opendir ((char *) dir);
     if (!d)
     {
-       perror ((char *) cache_dir);
+       perror ((char *) dir);
        ret = FcFalse;
        goto bail0;
     }
@@ -1087,10 +1192,10 @@ FcDirCacheClean (const FcChar8 *cache_dir, FcBool verbose)
            strcmp(ent->d_name + 32, "-" FC_ARCHITECTURE FC_CACHE_SUFFIX))
            continue;
 
-       file_name = FcStrPlus (dir_base, (FcChar8 *) ent->d_name);
+       file_name = FcStrBuildFilename (dir, (FcChar8 *)ent->d_name, NULL);
        if (!file_name)
        {
-           fprintf (stderr, "Fontconfig error: %s: allocation failure\n", cache_dir);
+           fprintf (stderr, "Fontconfig error: %s: allocation failure\n", dir);
            ret = FcFalse;
            break;
        }
@@ -1099,20 +1204,27 @@ FcDirCacheClean (const FcChar8 *cache_dir, FcBool verbose)
        if (!cache)
        {
            if (verbose || FcDebug () & FC_DBG_CACHE)
-               printf ("%s: invalid cache file: %s\n", cache_dir, ent->d_name);
+               printf ("%s: invalid cache file: %s\n", dir, ent->d_name);
            remove = FcTrue;
        }
        else
        {
+           FcChar8 *s;
+
            target_dir = FcCacheDir (cache);
-           if (stat ((char *) target_dir, &target_stat) < 0)
+           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",
-                           cache_dir, ent->d_name, target_dir);
+                           dir, ent->d_name, s);
                remove = FcTrue;
            }
            FcDirCacheUnload (cache);
+           FcStrFree (s);
        }
        if (remove)
        {
@@ -1127,11 +1239,87 @@ FcDirCacheClean (const FcChar8 *cache_dir, FcBool verbose)
 
     closedir (d);
   bail0:
-    FcStrFree (dir_base);
+    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
@@ -1451,7 +1639,7 @@ FcDirCacheCreateTagFile (const FcChar8 *cache_dir)
     if (access ((char *) cache_dir, W_OK) == 0)
     {
        /* Create CACHEDIR.TAG */
-       cache_tag = FcStrPlus (cache_dir, (const FcChar8 *) FC_DIR_SEPARATOR_S "CACHEDIR.TAG");
+       cache_tag = FcStrBuildFilename (cache_dir, "CACHEDIR.TAG", NULL);
        if (!cache_tag)
            return FcFalse;
        atomic = FcAtomicCreate ((FcChar8 *)cache_tag);
@@ -1495,8 +1683,9 @@ FcDirCacheCreateTagFile (const FcChar8 *cache_dir)
 void
 FcCacheCreateTagFile (const FcConfig *config)
 {
-    FcChar8   *cache_dir = NULL;
+    FcChar8   *cache_dir = NULL, *d = NULL;
     FcStrList *list;
+    const FcChar8 *sysroot = FcConfigGetSysRoot (config);
 
     list = FcConfigGetCacheDirs (config);
     if (!list)
@@ -1504,9 +1693,17 @@ FcCacheCreateTagFile (const FcConfig *config)
 
     while ((cache_dir = FcStrListNext (list)))
     {
-       if (FcDirCacheCreateTagFile (cache_dir))
+       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);
 }