]> git.wh0rd.org - fontconfig.git/blobdiff - fc-cache/fc-cache.c
Pass directory information around in FcCache structure. Freeze charsets.
[fontconfig.git] / fc-cache / fc-cache.c
index 00cf7fde4fb77004b4349ed0e98867a3153d66ab..6957a65b9ba8d28b685dc12f6f94b7f3ee0c8b60 100644 (file)
@@ -1,7 +1,7 @@
 /*
- * $XFree86: xc/lib/fontconfig/fc-cache/fc-cache.c,v 1.7 2002/08/11 15:09:33 keithp Exp $
+ * $RCSId: xc/lib/fontconfig/fc-cache/fc-cache.c,v 1.8tsi Exp $
  *
- * Copyright © 2002 Keith Packard, member of The XFree86 Project, Inc.
+ * Copyright © 2002 Keith Packard
  *
  * Permission to use, copy, modify, distribute, and sell this software and its
  * documentation for any purpose is hereby granted without fee, provided that
  * PERFORMANCE OF THIS SOFTWARE.
  */
 
-#include <fontconfig/fontconfig.h>
-#include <stdio.h>
-#include <unistd.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <errno.h>
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #else
 #define HAVE_GETOPT 1
 #endif
 
+#include "fcint.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <dirent.h>
+
+#if defined (_WIN32)
+#define STRICT
+#include <windows.h>
+#define sleep(x) Sleep((x) * 1000)
+#undef STRICT
+#endif
+
+#ifndef O_BINARY
+#define O_BINARY 0
+#endif
+
 #ifndef HAVE_GETOPT
 #define HAVE_GETOPT 0
 #endif
@@ -50,6 +65,8 @@
 #include <getopt.h>
 const struct option longopts[] = {
     {"force", 0, 0, 'f'},
+    {"really-force", 0, 0, 'r'},
+    {"system-only", 0, 0, 's'},
     {"version", 0, 0, 'V'},
     {"verbose", 0, 0, 'v'},
     {"help", 0, 0, '?'},
@@ -65,18 +82,36 @@ extern int optind, opterr, optopt;
 static void
 usage (char *program)
 {
-    fprintf (stderr, "usage: %s [-fvV?] [--force] [--verbose] [--version] [--help] [dirs]\n",
+#if HAVE_GETOPT_LONG
+    fprintf (stderr, "usage: %s [-frsvV?] [--force|--really-force] [--system-only] [--verbose] [--version] [--help] [dirs]\n",
+            program);
+#else
+    fprintf (stderr, "usage: %s [-frsvV?] [dirs]\n",
             program);
+#endif
     fprintf (stderr, "Build font information caches in [dirs]\n"
             "(all directories in font configuration by default).\n");
     fprintf (stderr, "\n");
+#if HAVE_GETOPT_LONG
     fprintf (stderr, "  -f, --force          scan directories with apparently valid caches\n");
+    fprintf (stderr, "  -r, --really-force   erase all existing caches, then rescan\n");
+    fprintf (stderr, "  -s, --system-only    scan system-wide directories only\n");
     fprintf (stderr, "  -v, --verbose        display status information while busy\n");
     fprintf (stderr, "  -V, --version        display font config version and exit\n");
     fprintf (stderr, "  -?, --help           display this help and exit\n");
+#else
+    fprintf (stderr, "  -f         (force)   scan directories with apparently valid caches\n");
+    fprintf (stderr, "  -r,   (really force) erase all existing caches, then rescan\n");
+    fprintf (stderr, "  -s         (system)  scan system-wide directories only\n");
+    fprintf (stderr, "  -v         (verbose) display status information while busy\n");
+    fprintf (stderr, "  -V         (version) display font config version and exit\n");
+    fprintf (stderr, "  -?         (help)    display this help and exit\n");
+#endif
     exit (1);
 }
 
+static FcStrSet *processed_dirs;
+
 static int
 nsubdirs (FcStrSet *set)
 {
@@ -93,14 +128,17 @@ nsubdirs (FcStrSet *set)
 }
 
 static int
-scanDirs (FcStrList *list, FcConfig *config, char *program, FcBool force, FcBool verbose)
+scanDirs (FcStrList *list, FcConfig *config, FcBool force, FcBool really_force, FcBool verbose)
 {
     int                ret = 0;
-    FcChar8    *dir;
+    const FcChar8 *dir;
     FcFontSet  *set;
     FcStrSet   *subdirs;
     FcStrList  *sublist;
+    FcCache    *cache;
     struct stat        statb;
+    FcBool     was_valid;
+    int                i;
     
     /*
      * Now scan all of the directories into separate databases
@@ -110,37 +148,51 @@ scanDirs (FcStrList *list, FcConfig *config, char *program, FcBool force, FcBool
     {
        if (verbose)
        {
-           printf ("%s: \"%s\": ", program, dir);
+           printf ("%s: ", dir);
            fflush (stdout);
        }
-       set = FcFontSetCreate ();
-       if (!set)
+       
+       if (!dir)
        {
-           fprintf (stderr, "Can't create font set\n");
-           ret++;
+           if (verbose)
+               printf ("skipping, no such directory\n");
            continue;
        }
-       subdirs = FcStrSetCreate ();
-       if (!subdirs)
+       
+       if (FcStrSetMember (processed_dirs, dir))
        {
-           fprintf (stderr, "Can't create directory set\n");
-           ret++;
+           if (verbose)
+               printf ("skipping, looped directory detected\n");
            continue;
        }
-       
-       if (stat ((char *) dir, &statb) == -1)
+
+       if (access ((char *) dir, W_OK) < 0)
        {
-           if (errno == ENOENT || errno == ENOTDIR)
-           {
+           switch (errno) {
+           case ENOENT:
+           case ENOTDIR:
                if (verbose)
-                   printf ("no such directory, skipping\n");
-           }
-           else
-           {
+                   printf ("skipping, no such directory\n");
+               continue;
+           case EACCES:
+           case EROFS:
+               /* That's ok, caches go to /var anyway. */
+               /* Ideally we'd do an access on the hashed_name. */
+               /* But we hid that behind an abstraction barrier. */
+               break;
+           default:
                fprintf (stderr, "\"%s\": ", dir);
                perror ("");
                ret++;
+
+               continue;
            }
+       }
+       if (stat ((char *) dir, &statb) == -1)
+       {
+           fprintf (stderr, "\"%s\": ", dir);
+           perror ("");
+           ret++;
            continue;
        }
        if (!S_ISDIR (statb.st_mode))
@@ -148,44 +200,181 @@ scanDirs (FcStrList *list, FcConfig *config, char *program, FcBool force, FcBool
            fprintf (stderr, "\"%s\": not a directory, skipping\n", dir);
            continue;
        }
-       if (!FcDirScan (set, subdirs, 0, FcConfigGetBlanks (config), dir, force))
+
+       if (really_force)
+           FcDirCacheUnlink (dir, config);
+
+       cache = NULL;
+       was_valid = FcFalse;
+       if (!force) {
+           cache = FcDirCacheLoad (dir, config, NULL);
+           if (cache)
+               was_valid = FcTrue;
+       }
+       
+       if (!cache)
        {
-           fprintf (stderr, "\"%s\": error scanning\n", dir);
-           ret++;
-           continue;
+           cache = FcDirCacheRead (dir, FcTrue, config);
+           if (!cache)
+           {
+               fprintf (stderr, "%s: error scanning\n", dir);
+               ret++;
+               continue;
+           }
        }
-       if (!force && FcDirCacheValid (dir))
+
+       set = FcCacheSet (cache);
+
+       if (was_valid)
        {
            if (verbose)
                printf ("skipping, %d fonts, %d dirs\n",
-                       set->nfont, nsubdirs(subdirs));
+                       set->nfont, cache->dirs_count);
        }
        else
        {
            if (verbose)
                printf ("caching, %d fonts, %d dirs\n", 
-                       set->nfont, nsubdirs (subdirs));
-           if (!FcDirSave (set, subdirs, dir))
+                       set->nfont, cache->dirs_count);
+
+           if (!FcDirCacheValid (dir))
            {
-               fprintf (stderr, "Can't save cache in \"%s\"\n", dir);
+               fprintf (stderr, "%s: failed to write cache\n", dir);
+               (void) FcDirCacheUnlink (dir, config);
                ret++;
            }
        }
-       FcFontSetDestroy (set);
+       
+       subdirs = FcStrSetCreate ();
+       if (!subdirs)
+       {
+           fprintf (stderr, "%s: Can't create subdir set\n", dir);
+           ret++;
+           FcDirCacheUnload (cache);
+           continue;
+       }
+       for (i = 0; i < cache->dirs_count; i++)
+           FcStrSetAdd (subdirs, FcCacheSubdir (cache, i));
+       
+       FcDirCacheUnload (cache);
+       
        sublist = FcStrListCreate (subdirs);
+       FcStrSetDestroy (subdirs);
        if (!sublist)
        {
-           fprintf (stderr, "Can't create subdir list in \"%s\"\n", dir);
+           fprintf (stderr, "%s: Can't create subdir list\n", dir);
            ret++;
+           FcDirCacheUnload (cache);
            continue;
        }
-       ret += scanDirs (sublist, config, program, force, verbose);
-       FcStrSetDestroy (subdirs);
+       FcStrSetAdd (processed_dirs, dir);
+       ret += scanDirs (sublist, config, force, really_force, verbose);
     }
     FcStrListDone (list);
     return ret;
 }
 
+static FcBool
+cleanCacheDirectory (FcConfig *config, FcChar8 *dir, FcBool verbose)
+{
+    DIR                *d;
+    struct dirent *ent;
+    char       *dir_base;
+    FcBool     ret = FcTrue;
+    FcBool     remove;
+    FcCache    *cache;
+    struct stat        file_stat;
+    struct stat        target_stat;
+
+    dir_base = FcStrPlus (dir, "/");
+    if (access ((char *) dir, W_OK|X_OK) != 0)
+    {
+       if (verbose)
+           printf ("%s: not cleaning unwritable cache directory\n", dir);
+       return FcTrue;
+    }
+    if (verbose)
+       printf ("%s: cleaning cache directory\n", dir);
+    d = opendir (dir);
+    if (!d)
+    {
+       perror (dir);
+       return FcFalse;
+    }
+    while ((ent = readdir (d)))
+    {
+       FcChar8 *file_name;
+       FcChar8 *target_dir;
+
+       if (ent->d_name[0] == '.')
+           continue;
+       file_name = FcStrPlus (dir_base, ent->d_name);
+       if (!file_name)
+       {
+           fprintf (stderr, "%s: allocation failure\n", dir);
+           ret = FcFalse;
+           break;
+       }
+       cache = FcDirCacheLoadFile (file_name, &file_stat);
+       if (!cache)
+       {
+           fprintf (stderr, "%s: invalid cache file: %s\n", dir, ent->d_name);
+           FcStrFree (file_name);
+           ret = FcFalse;
+           continue;
+       }
+       target_dir = FcCacheDir (cache);
+       remove = FcFalse;
+       if (stat (target_dir, &target_stat) < 0)
+       {
+           if (verbose)
+               printf ("%s: %s: missing directory: %s \n",
+                       dir, ent->d_name, target_dir);
+           remove = FcTrue;
+       }
+       else if (target_stat.st_mtime > file_stat.st_mtime)
+       {
+           if (verbose)
+               printf ("%s: %s: cache outdated: %s\n",
+                       dir, ent->d_name, target_dir);
+           remove = FcTrue;
+       }
+       if (remove)
+       {
+           if (unlink (file_name) < 0)
+           {
+               perror (file_name);
+               ret = FcFalse;
+           }
+       }
+        FcStrFree (file_name);
+    }
+    
+    closedir (d);
+    return ret;
+}
+
+static FcBool
+cleanCacheDirectories (FcConfig *config, FcBool verbose)
+{
+    FcStrList  *cache_dirs = FcConfigGetCacheDirs (config);
+    FcChar8    *cache_dir;
+    FcBool     ret = FcTrue;
+
+    if (!cache_dirs)
+       return FcFalse;
+    while ((cache_dir = FcStrListNext (cache_dirs)))
+    {
+       if (!cleanCacheDirectory (config, cache_dir, verbose))
+       {
+           ret = FcFalse;
+           break;
+       }
+    }
+    FcStrListDone (cache_dirs);
+    return ret;
+}
+
 int
 main (int argc, char **argv)
 {
@@ -193,6 +382,8 @@ main (int argc, char **argv)
     FcStrList  *list;
     FcBool     verbose = FcFalse;
     FcBool     force = FcFalse;
+    FcBool     really_force = FcFalse;
+    FcBool     systemOnly = FcFalse;
     FcConfig   *config;
     int                i;
     int                ret;
@@ -200,15 +391,21 @@ main (int argc, char **argv)
     int                c;
 
 #if HAVE_GETOPT_LONG
-    while ((c = getopt_long (argc, argv, "fVv?", longopts, NULL)) != -1)
+    while ((c = getopt_long (argc, argv, "frsVv?", longopts, NULL)) != -1)
 #else
-    while ((c = getopt (argc, argv, "fVv?")) != -1)
+    while ((c = getopt (argc, argv, "frsVv?")) != -1)
 #endif
     {
        switch (c) {
+       case 'r':
+           really_force = FcTrue;
+           /* fall through */
        case 'f':
            force = FcTrue;
            break;
+       case 's':
+           systemOnly = FcTrue;
+           break;
        case 'V':
            fprintf (stderr, "fontconfig version %d.%d.%d\n", 
                     FC_MAJOR, FC_MINOR, FC_REVISION);
@@ -225,12 +422,16 @@ main (int argc, char **argv)
     i = 1;
 #endif
 
+    if (systemOnly)
+       FcConfigEnableHome (FcFalse);
     config = FcInitLoadConfig ();
     if (!config)
     {
        fprintf (stderr, "%s: Can't init font config library\n", argv[0]);
        return 1;
     }
+    FcConfigSetCurrent (config);
+
     if (argv[i])
     {
        dirs = FcStrSetCreate ();
@@ -254,7 +455,27 @@ main (int argc, char **argv)
     }
     else
        list = FcConfigGetConfigDirs (config);
-    ret = scanDirs (list, config, argv[0], force, verbose);
+
+    if ((processed_dirs = FcStrSetCreate()) == NULL) {
+       fprintf(stderr, "Cannot malloc\n");
+       return 1;
+    }
+       
+    ret = scanDirs (list, config, force, really_force, verbose);
+
+    FcStrSetDestroy (processed_dirs);
+
+    cleanCacheDirectories (config, verbose);
+
+    /* 
+     * Now we need to sleep a second  (or two, to be extra sure), to make
+     * sure that timestamps for changes after this run of fc-cache are later
+     * then any timestamps we wrote.  We don't use gettimeofday() because
+     * sleep(3) can't be interrupted by a signal here -- this isn't in the
+     * library, and there aren't any signals flying around here.
+     */
+    FcConfigDestroy (config);
+    sleep (2);
     if (verbose)
        printf ("%s: %s\n", argv[0], ret ? "failed" : "succeeded");
     return ret;