2 * $RCSId: xc/lib/fontconfig/src/fccache.c,v 1.12 2002/08/22 07:36:44 keithp Exp $
4 * Copyright © 2000 Keith Packard
5 * Copyright © 2005 Patrick Lam
7 * Permission to use, copy, modify, distribute, and sell this software and its
8 * documentation for any purpose is hereby granted without fee, provided that
9 * the above copyright notice appear in all copies and that both that
10 * copyright notice and this permission notice appear in supporting
11 * documentation, and that the name of Keith Packard not be used in
12 * advertising or publicity pertaining to distribution of the software without
13 * specific, written prior permission. Keith Packard makes no
14 * representations about the suitability of this software for any purpose. It
15 * is provided "as is" without express or implied warranty.
17 * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
18 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
19 * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
20 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
21 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
22 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
23 * PERFORMANCE OF THIS SOFTWARE.
29 #include <sys/utsname.h>
30 #include <sys/types.h>
34 #define ENDIAN_TEST 0x12345678
35 #define MACHINE_SIGNATURE_SIZE 9 + 5*19 + 1
38 FcCacheSkipToArch (int fd, const char * arch);
41 FcCacheCopyOld (int fd, int fd_orig, off_t start);
44 FcDirCacheProduce (FcFontSet *set, FcCache * metadata);
47 FcDirCacheConsume (int fd, FcFontSet *set);
50 FcDirCacheRead (FcFontSet * set, FcStrSet * dirs, const FcChar8 *dir);
53 FcCacheNextOffset(off_t w);
56 FcCacheMachineSignature (void);
59 FcCacheHaveBank (int bank);
61 #define FC_DBG_CACHE_REF 1024
64 FcCacheReadString (int fd, char *dest, int len)
77 while (read (fd, &c, 1) == 1)
104 FcCacheWriteString (int fd, const char *chars)
106 if (write (fd, chars, strlen(chars)+1) != strlen(chars)+1)
112 FcGlobalCacheDirDestroy (FcGlobalCacheDir *d)
114 FcMemFree (FC_MEM_STRING, strlen (d->name)+1);
116 FcMemFree (FC_MEM_CACHE, sizeof (FcGlobalCacheDir));
121 FcGlobalCacheCreate (void)
123 FcGlobalCache *cache;
125 cache = malloc (sizeof (FcGlobalCache));
128 FcMemAlloc (FC_MEM_CACHE, sizeof (FcGlobalCache));
130 cache->updated = FcFalse;
136 FcGlobalCacheDestroy (FcGlobalCache *cache)
138 FcGlobalCacheDir *d, *next;
140 for (d = cache->dirs; d; d = next)
143 FcGlobalCacheDirDestroy (d);
145 FcMemFree (FC_MEM_CACHE, sizeof (FcGlobalCache));
150 FcGlobalCacheLoad (FcGlobalCache *cache,
152 const FcChar8 *cache_file)
155 FcGlobalCacheDir *d, *next;
156 char * current_arch_machine_name;
157 char candidate_arch_machine_name[MACHINE_SIGNATURE_SIZE + 9];
158 off_t current_arch_start;
160 struct stat cache_stat, dir_stat;
162 if (stat ((char *) cache_file, &cache_stat) < 0)
165 cache->fd = open ((char *) cache_file, O_RDONLY);
169 cache->updated = FcFalse;
171 current_arch_machine_name = FcCacheMachineSignature ();
172 current_arch_start = FcCacheSkipToArch(cache->fd,
173 current_arch_machine_name);
174 if (current_arch_start < 0)
177 lseek (cache->fd, current_arch_start, SEEK_SET);
178 FcCacheReadString (cache->fd, candidate_arch_machine_name,
179 sizeof (candidate_arch_machine_name));
180 if (strlen(candidate_arch_machine_name) == 0)
187 FcCacheReadString (cache->fd, name_buf, sizeof (name_buf));
188 if (!strlen(name_buf))
191 if (stat ((char *) name_buf, &dir_stat) < 0 ||
192 dir_stat.st_mtime > cache_stat.st_mtime)
196 FcStrSetAdd (staleDirs, FcStrCopy ((FcChar8 *)name_buf));
197 read (cache->fd, &md, sizeof (FcCache));
198 lseek (cache->fd, FcCacheNextOffset (lseek(cache->fd, 0, SEEK_CUR)) + md.count, SEEK_SET);
202 d = malloc (sizeof (FcGlobalCacheDir));
206 d->next = cache->dirs;
209 d->name = (char *)FcStrCopy ((FcChar8 *)name_buf);
211 d->offset = lseek (cache->fd, 0, SEEK_CUR);
212 if (read (cache->fd, &d->metadata, sizeof (FcCache)) != sizeof (FcCache))
214 targ = FcCacheNextOffset (lseek(cache->fd, 0, SEEK_CUR)) + d->metadata.count;
215 if (lseek (cache->fd, targ, SEEK_SET) != targ)
221 for (d = cache->dirs; d; d = next)
234 FcGlobalCacheReadDir (FcFontSet *set, FcStrSet *dirs, FcGlobalCache * cache, const char *dir, FcConfig *config)
237 FcBool ret = FcFalse;
242 for (d = cache->dirs; d; d = d->next)
244 if (strncmp (d->name, dir, strlen(dir)) == 0)
246 lseek (cache->fd, d->offset, SEEK_SET);
247 if (!FcDirCacheConsume (cache->fd, set))
249 if (strcmp (d->name, dir) == 0)
258 FcGlobalCacheUpdate (FcGlobalCache *cache,
262 FcGlobalCacheDir * d;
267 for (d = cache->dirs; d; d = d->next)
269 if (strcmp(d->name, name) == 0)
275 d = malloc (sizeof (FcGlobalCacheDir));
278 d->next = cache->dirs;
282 cache->updated = FcTrue;
284 d->name = (char *)FcStrCopy ((FcChar8 *)name);
285 d->ent = FcDirCacheProduce (set, &d->metadata);
291 FcGlobalCacheSave (FcGlobalCache *cache,
292 const FcChar8 *cache_file)
295 FcGlobalCacheDir *dir;
297 off_t current_arch_start = 0, truncate_to;
298 char * current_arch_machine_name, * header;
303 #if defined (HAVE_GETUID) && defined (HAVE_GETEUID)
304 /* Set-UID programs can't safely update the cache */
305 if (getuid () != geteuid ())
309 atomic = FcAtomicCreate (cache_file);
313 if (!FcAtomicLock (atomic))
315 fd = open ((char *) FcAtomicNewFile(atomic), O_RDWR | O_CREAT,
320 fd_orig = open ((char *) FcAtomicOrigFile(atomic), O_RDONLY);
322 current_arch_machine_name = FcCacheMachineSignature ();
324 current_arch_start = 0;
326 current_arch_start = FcCacheSkipToArch (fd_orig,
327 current_arch_machine_name);
329 if (current_arch_start < 0)
330 current_arch_start = FcCacheNextOffset (lseek(fd_orig, 0, SEEK_END));
332 if (!FcCacheCopyOld(fd, fd_orig, current_arch_start))
338 current_arch_start = lseek(fd, 0, SEEK_CUR);
339 if (ftruncate (fd, current_arch_start) == -1)
342 header = malloc (10 + strlen (current_arch_machine_name));
346 truncate_to = current_arch_start + strlen(current_arch_machine_name) + 11;
347 for (dir = cache->dirs; dir; dir = dir->next)
349 truncate_to += strlen(dir->name) + 1;
350 truncate_to += sizeof (FcCache);
351 truncate_to = FcCacheNextOffset (current_arch_start + truncate_to);
352 truncate_to += dir->metadata.count;
354 truncate_to -= current_arch_start;
356 sprintf (header, "%8x ", (int)truncate_to);
357 strcat (header, current_arch_machine_name);
358 if (!FcCacheWriteString (fd, header))
361 for (dir = cache->dirs; dir; dir = dir->next)
365 FcCacheWriteString (fd, dir->name);
366 write (fd, &dir->metadata, sizeof(FcCache));
367 lseek (fd, FcCacheNextOffset (lseek(fd, 0, SEEK_CUR)), SEEK_SET);
368 write (fd, dir->ent, dir->metadata.count);
372 FcCacheWriteString (fd, "");
374 if (close (fd) == -1)
377 if (!FcAtomicReplaceOrig (atomic))
380 FcAtomicUnlock (atomic);
381 FcAtomicDestroy (atomic);
383 cache->updated = FcFalse;
394 FcAtomicDeleteNew (atomic);
396 FcAtomicUnlock (atomic);
398 FcAtomicDestroy (atomic);
402 #define PAGESIZE 8192
404 * Find the next presumably-mmapable offset after the supplied file
408 FcCacheNextOffset(off_t w)
410 if (w % PAGESIZE == 0)
413 return ((w / PAGESIZE)+1)*PAGESIZE;
416 /* return the address of the segment for the provided arch,
417 * or -1 if arch not found */
419 FcCacheSkipToArch (int fd, const char * arch)
421 char candidate_arch_machine_name_count[MACHINE_SIGNATURE_SIZE + 9];
422 char * candidate_arch;
423 off_t current_arch_start = 0;
425 /* skip arches that are not the current arch */
430 if (lseek (fd, current_arch_start, SEEK_SET) != current_arch_start)
433 if (FcCacheReadString (fd, candidate_arch_machine_name_count,
434 sizeof (candidate_arch_machine_name_count)) == 0)
436 if (!strlen(candidate_arch_machine_name_count))
438 bs = strtol(candidate_arch_machine_name_count, &candidate_arch, 16);
440 // count = 0 should probably be distinguished from the !bs condition
441 if (!bs || bs < strlen (candidate_arch_machine_name_count))
444 candidate_arch++; /* skip leading space */
446 if (strcmp (candidate_arch, arch)==0)
447 return current_arch_start;
448 current_arch_start += bs;
454 /* Cuts out the segment at the file pointer (moves everything else
455 * down to cover it), and leaves the file pointer at the end of the
458 FcCacheCopyOld (int fd, int fd_orig, off_t start)
460 char * buf = malloc (8192);
461 char candidate_arch_machine_name[MACHINE_SIGNATURE_SIZE + 9];
463 int c, bytes_skipped;
470 lseek (fd, 0, SEEK_SET); lseek (fd_orig, 0, SEEK_SET);
477 if ((c = read (fd_orig, buf, b)) <= 0)
479 if (write (fd, buf, c) < 0)
486 lseek (fd, start, SEEK_SET);
487 if (FcCacheReadString (fd, candidate_arch_machine_name,
488 sizeof (candidate_arch_machine_name)) == 0)
490 if (!strlen(candidate_arch_machine_name))
493 bs = strtol(candidate_arch_machine_name, 0, 16);
500 lseek (fd, start+bs+bytes_skipped, SEEK_SET);
501 if ((c = read (fd, buf, 8192)) <= 0)
503 lseek (fd, start+bytes_skipped, SEEK_SET);
504 if (write (fd, buf, c) < 0)
509 lseek (fd, start+bytes_skipped, SEEK_SET);
520 /* Does not check that the cache has the appropriate arch section. */
522 FcDirCacheValid (const FcChar8 *dir)
524 FcChar8 *cache_file = FcStrPlus (dir, (FcChar8 *) "/" FC_DIR_CACHE_FILE);
525 struct stat file_stat, dir_stat;
527 if (stat ((char *) dir, &dir_stat) < 0)
529 FcStrFree (cache_file);
532 if (stat ((char *) cache_file, &file_stat) < 0)
534 FcStrFree (cache_file);
538 FcStrFree (cache_file);
540 * If the directory has been modified more recently than
541 * the cache file, the cache is not valid
543 if (dir_stat.st_mtime - file_stat.st_mtime > 0)
548 /* Assumes that the cache file in 'dir' exists.
549 * Checks that the cache has the appropriate arch section. */
551 FcDirCacheHasCurrentArch (const FcChar8 *dir)
553 FcChar8 *cache_file = FcStrPlus (dir, (FcChar8 *) "/" FC_DIR_CACHE_FILE);
555 off_t current_arch_start;
556 char *current_arch_machine_name;
558 current_arch_machine_name = FcCacheMachineSignature();
559 fd = open ((char *)cache_file, O_RDONLY);
563 current_arch_start = FcCacheSkipToArch(fd, current_arch_machine_name);
566 if (current_arch_start < 0)
573 FcDirCacheUnlink (const FcChar8 *dir)
575 FcChar8 *cache_file = FcStrPlus (dir, (FcChar8 *) "/" FC_DIR_CACHE_FILE);
577 if (unlink ((char *)cache_file) != 0)
579 FcStrFree (cache_file);
583 FcStrFree (cache_file);
588 FcCacheReadDirs (FcConfig * config, FcGlobalCache * cache,
589 FcStrList *list, FcFontSet * set)
593 FcChar8 *file, *base;
599 * Read in the results from 'list'.
601 while ((dir = FcStrListNext (list)))
604 file = (FcChar8 *) malloc (strlen ((char *) dir) + 1 + FC_MAX_FILE_LEN + 1);
608 strcpy ((char *) file, (char *) dir);
609 strcat ((char *) file, "/");
610 base = file + strlen ((char *) file);
612 subdirs = FcStrSetCreate ();
615 fprintf (stderr, "Can't create directory set\n");
621 if (access ((char *) dir, X_OK) < 0)
629 fprintf (stderr, "\"%s\": ", dir);
633 FcStrSetDestroy (subdirs);
637 if (stat ((char *) dir, &statb) == -1)
639 fprintf (stderr, "\"%s\": ", dir);
641 FcStrSetDestroy (subdirs);
646 if (!S_ISDIR (statb.st_mode))
648 fprintf (stderr, "\"%s\": not a directory, skipping\n", dir);
649 FcStrSetDestroy (subdirs);
653 if (!FcDirCacheValid (dir) || !FcDirCacheRead (set, subdirs, dir))
655 if (FcDebug () & FC_DBG_FONTSET)
656 printf ("cache scan dir %s\n", dir);
658 FcDirScanConfig (set, subdirs, cache,
659 config->blanks, dir, FcFalse, config);
661 sublist = FcStrListCreate (subdirs);
662 FcStrSetDestroy (subdirs);
665 fprintf (stderr, "Can't create subdir list in \"%s\"\n", dir);
670 ret += FcCacheReadDirs (config, cache, sublist, set);
673 FcStrListDone (list);
678 FcCacheRead (FcConfig *config, FcGlobalCache * cache)
680 FcFontSet * s = FcFontSetCreate();
684 if (FcCacheReadDirs (config, cache, FcConfigGetConfigDirs (config), s))
690 FcFontSetDestroy (s);
694 /* read serialized state from the cache file */
696 FcDirCacheRead (FcFontSet * set, FcStrSet * dirs, const FcChar8 *dir)
698 char *cache_file = (char *)FcStrPlus (dir, (FcChar8 *) "/" FC_DIR_CACHE_FILE);
700 char * current_arch_machine_name;
701 char candidate_arch_machine_name[9+MACHINE_SIGNATURE_SIZE];
702 off_t current_arch_start = 0;
703 char subdirName[FC_MAX_FILE_LEN + 1 + 12 + 1];
708 current_arch_machine_name = FcCacheMachineSignature();
709 fd = open(cache_file, O_RDONLY);
713 current_arch_start = FcCacheSkipToArch(fd, current_arch_machine_name);
714 if (current_arch_start < 0)
717 lseek (fd, current_arch_start, SEEK_SET);
718 if (FcCacheReadString (fd, candidate_arch_machine_name,
719 sizeof (candidate_arch_machine_name)) == 0)
722 while (strlen(FcCacheReadString (fd, subdirName, sizeof (subdirName))) > 0)
723 FcStrSetAdd (dirs, (FcChar8 *)subdirName);
725 if (!FcDirCacheConsume (fd, set))
740 FcDirCacheConsume (int fd, FcFontSet *set)
743 void * current_dir_block;
746 read(fd, &metadata, sizeof(FcCache));
747 if (metadata.magic != FC_CACHE_MAGIC)
753 pos = FcCacheNextOffset (lseek(fd, 0, SEEK_CUR));
754 current_dir_block = mmap (0, metadata.count,
755 PROT_READ, MAP_SHARED, fd, pos);
756 if (current_dir_block == MAP_FAILED)
759 if (!FcFontSetUnserialize (metadata, set, current_dir_block))
766 FcDirCacheProduce (FcFontSet *set, FcCache *metadata)
768 void * current_dir_block, * final_dir_block;
769 static unsigned int rand_state = 0;
773 rand_state = time(0L);
774 bank = rand_r(&rand_state);
776 while (FcCacheHaveBank(bank))
777 bank = rand_r(&rand_state);
779 memset (metadata, 0, sizeof(FcCache));
781 metadata->count = FcFontSetNeededBytes (set);
782 metadata->magic = FC_CACHE_MAGIC;
783 metadata->bank = bank;
785 if (!metadata->count) /* not a failure, no fonts to write */
788 current_dir_block = malloc (metadata->count);
789 if (!current_dir_block)
791 final_dir_block = FcFontSetDistributeBytes (metadata, current_dir_block);
793 if ((char *)current_dir_block + metadata->count != final_dir_block)
796 if (!FcFontSetSerialize (bank, set))
799 return current_dir_block;
802 free (current_dir_block);
806 /* write serialized state to the cache file */
808 FcDirCacheWrite (FcFontSet *set, FcStrSet *dirs, const FcChar8 *dir)
810 FcChar8 *cache_file = FcStrPlus (dir, (FcChar8 *) "/" FC_DIR_CACHE_FILE);
811 int fd, fd_orig, i, dirs_count;
814 off_t current_arch_start = 0, truncate_to;
816 char *current_arch_machine_name, * header;
817 void *current_dir_block;
822 current_dir_block = FcDirCacheProduce (set, &metadata);
824 if (metadata.count && !current_dir_block)
827 if (FcDebug () & FC_DBG_CACHE)
828 printf ("FcDirCacheWriteDir cache_file \"%s\"\n", cache_file);
830 atomic = FcAtomicCreate (cache_file);
834 if (!FcAtomicLock (atomic))
837 fd_orig = open((char *)FcAtomicOrigFile (atomic), O_RDONLY, 0666);
839 fd = open((char *)FcAtomicNewFile (atomic), O_RDWR | O_CREAT, 0666);
843 current_arch_machine_name = FcCacheMachineSignature ();
844 current_arch_start = 0;
848 FcCacheSkipToArch(fd_orig, current_arch_machine_name);
850 if (current_arch_start < 0)
851 current_arch_start = FcCacheNextOffset (lseek(fd_orig, 0, SEEK_END));
853 if (fd_orig != -1 && !FcCacheCopyOld(fd, fd_orig, current_arch_start))
859 current_arch_start = lseek(fd, 0, SEEK_CUR);
860 if (ftruncate (fd, current_arch_start) == -1)
863 /* allocate space for subdir names in this block */
865 for (i = 0; i < dirs->size; i++)
866 dirs_count += strlen((char *)dirs->strs[i]) + 1;
869 /* now write the address of the next offset */
870 truncate_to = FcCacheNextOffset (FcCacheNextOffset (current_arch_start + sizeof (FcCache) + dirs_count) + metadata.count) - current_arch_start;
871 header = malloc (10 + strlen (current_arch_machine_name));
874 sprintf (header, "%8x ", (int)truncate_to);
875 strcat (header, current_arch_machine_name);
876 if (!FcCacheWriteString (fd, header))
879 for (i = 0; i < dirs->size; i++)
880 FcCacheWriteString (fd, (char *)dirs->strs[i]);
881 FcCacheWriteString (fd, "");
883 write (fd, &metadata, sizeof(FcCache));
886 lseek (fd, FcCacheNextOffset (lseek(fd, 0, SEEK_END)), SEEK_SET);
887 write (fd, current_dir_block, metadata.count);
888 free (current_dir_block);
891 /* this actually serves to pad out the cache file, if needed */
892 if (ftruncate (fd, current_arch_start + truncate_to) == -1)
896 if (!FcAtomicReplaceOrig(atomic))
898 FcAtomicUnlock (atomic);
899 FcAtomicDestroy (atomic);
907 FcAtomicUnlock (atomic);
909 FcAtomicDestroy (atomic);
911 unlink ((char *)cache_file);
913 if (current_dir_block)
914 free (current_dir_block);
920 FcCacheMachineSignature ()
922 static char buf[MACHINE_SIGNATURE_SIZE];
923 int magic = ENDIAN_TEST;
924 char * m = (char *)&magic;
926 sprintf (buf, "%2x%2x%2x%2x "
927 "%4x %4x %4x %4x %4x %4x %4x %4x %4x %4x %4x %4x "
928 "%4x %4x %4x %4x %4x %4x %4x\n",
929 m[0], m[1], m[2], m[3],
930 (unsigned int)sizeof (char),
931 (unsigned int)sizeof (char *),
932 (unsigned int)sizeof (int),
933 (unsigned int)sizeof (FcPattern),
934 (unsigned int)sizeof (FcPatternEltPtr),
935 (unsigned int)sizeof (struct _FcPatternElt *),
936 (unsigned int)sizeof (FcPatternElt),
937 (unsigned int)sizeof (FcObjectPtr),
938 (unsigned int)sizeof (FcValueListPtr),
939 (unsigned int)sizeof (FcValue),
940 (unsigned int)sizeof (FcValueBinding),
941 (unsigned int)sizeof (struct _FcValueList *),
942 (unsigned int)sizeof (FcCharSet),
943 (unsigned int)sizeof (FcCharLeaf **),
944 (unsigned int)sizeof (FcChar16 *),
945 (unsigned int)sizeof (FcChar16),
946 (unsigned int)sizeof (FcCharLeaf),
947 (unsigned int)sizeof (FcChar32),
948 (unsigned int)sizeof (FcCache));
953 static int banks_ptr = 0, banks_alloc = 0;
954 static int * bankId = 0, * bankIdx = 0;
957 FcCacheHaveBank (int bank)
961 if (bank < FC_BANK_FIRST)
964 for (i = 0; i < banks_ptr; i++)
965 if (bankId[i] == bank)
972 FcCacheBankToIndex (int bank)
976 for (i = 0; i < banks_ptr; i++)
977 if (bankId[bankIdx[i]] == bank)
981 for (j = i; j > 0; j--)
982 bankIdx[j] = bankIdx[j-1];
987 if (banks_ptr >= banks_alloc)
990 b = realloc (bankId, (banks_alloc + 4) * sizeof(int));
995 bidx = realloc (bankIdx, (banks_alloc + 4) * sizeof(int));