fontconfig/src/fccache.c

634 lines
13 KiB
C

/*
* $XFree86: xc/lib/fontconfig/src/fccache.c,v 1.4 2002/03/01 01:00:54 keithp Exp $
*
* Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software and its
* documentation for any purpose is hereby granted without fee, provided that
* the above copyright notice appear in all copies and that both that
* copyright notice and this permission notice appear in supporting
* documentation, and that the name of Keith Packard not be used in
* advertising or publicity pertaining to distribution of the software without
* specific, written prior permission. Keith Packard makes no
* representations about the suitability of this software for any purpose. It
* is provided "as is" without express or implied warranty.
*
* KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
* EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
#include "fcint.h"
static unsigned int
FcFileCacheHash (const FcChar8 *string)
{
unsigned int h = 0;
FcChar8 c;
while ((c = *string++))
h = (h << 1) ^ c;
return h;
}
FcChar8 *
FcFileCacheFind (FcFileCache *cache,
const FcChar8 *file,
int id,
int *count)
{
unsigned int hash;
const FcChar8 *match;
FcFileCacheEnt *c, *name;
int maxid;
struct stat statb;
match = file;
hash = FcFileCacheHash (match);
name = 0;
maxid = -1;
for (c = cache->ents[hash % FC_FILE_CACHE_HASH_SIZE]; c; c = c->next)
{
if (c->hash == hash && !strcmp ((const char *) match, (const char *) c->file))
{
if (c->id > maxid)
maxid = c->id;
if (c->id == id)
{
if (stat ((char *) file, &statb) < 0)
{
if (FcDebug () & FC_DBG_CACHE)
printf (" file missing\n");
return 0;
}
if (statb.st_mtime != c->time)
{
if (FcDebug () & FC_DBG_CACHE)
printf (" timestamp mismatch (was %d is %d)\n",
(int) c->time, (int) statb.st_mtime);
return 0;
}
if (!c->referenced)
{
cache->referenced++;
c->referenced = FcTrue;
}
name = c;
}
}
}
if (!name)
return 0;
*count = maxid + 1;
return name->name;
}
/*
* Cache file syntax is quite simple:
*
* "file_name" id time "font_name" \n
*/
static FcChar8 *
FcFileCacheReadString (FILE *f, FcChar8 *dest, int len)
{
int c;
FcBool escape;
FcChar8 *d;
int size;
int i;
while ((c = getc (f)) != EOF)
if (c == '"')
break;
if (c == EOF)
return FcFalse;
if (len == 0)
return FcFalse;
size = len;
i = 0;
d = dest;
escape = FcFalse;
while ((c = getc (f)) != EOF)
{
if (!escape)
{
switch (c) {
case '"':
c = '\0';
break;
case '\\':
escape = FcTrue;
continue;
}
}
if (i == size)
{
FcChar8 *new = malloc (size * 2);
if (!new)
break;
memcpy (new, d, size);
size *= 2;
if (d != dest)
free (d);
d = new;
}
d[i++] = c;
if (c == '\0')
return d;
escape = FcFalse;
}
if (d != dest)
free (d);
return 0;
}
static FcBool
FcFileCacheReadUlong (FILE *f, unsigned long *dest)
{
unsigned long t;
int c;
while ((c = getc (f)) != EOF)
{
if (!isspace (c))
break;
}
if (c == EOF)
return FcFalse;
t = 0;
for (;;)
{
if (c == EOF || isspace (c))
break;
if (!isdigit (c))
return FcFalse;
t = t * 10 + (c - '0');
c = getc (f);
}
*dest = t;
return FcTrue;
}
static FcBool
FcFileCacheReadInt (FILE *f, int *dest)
{
unsigned long t;
FcBool ret;
ret = FcFileCacheReadUlong (f, &t);
if (ret)
*dest = (int) t;
return ret;
}
static FcBool
FcFileCacheReadTime (FILE *f, time_t *dest)
{
unsigned long t;
FcBool ret;
ret = FcFileCacheReadUlong (f, &t);
if (ret)
*dest = (time_t) t;
return ret;
}
static FcBool
FcFileCacheAdd (FcFileCache *cache,
const FcChar8 *file,
int id,
time_t time,
const FcChar8 *name,
FcBool replace)
{
FcFileCacheEnt *c;
FcFileCacheEnt **prev, *old;
unsigned int hash;
if (FcDebug () & FC_DBG_CACHE)
{
printf ("%s face %s/%d as %s\n", replace ? "Replace" : "Add",
file, id, name);
}
hash = FcFileCacheHash (file);
for (prev = &cache->ents[hash % FC_FILE_CACHE_HASH_SIZE];
(old = *prev);
prev = &(*prev)->next)
{
if (old->hash == hash && old->id == id && !strcmp ((const char *) old->file,
(const char *) file))
break;
}
if (*prev)
{
if (!replace)
return FcFalse;
old = *prev;
if (old->referenced)
cache->referenced--;
*prev = old->next;
free (old);
cache->entries--;
}
c = malloc (sizeof (FcFileCacheEnt) +
strlen ((char *) file) + 1 +
strlen ((char *) name) + 1);
if (!c)
return FcFalse;
c->next = *prev;
*prev = c;
c->hash = hash;
c->file = (FcChar8 *) (c + 1);
c->id = id;
c->name = c->file + strlen ((char *) file) + 1;
strcpy ((char *) c->file, (const char *) file);
c->time = time;
c->referenced = replace;
strcpy ((char *) c->name, (const char *) name);
cache->entries++;
return FcTrue;
}
FcFileCache *
FcFileCacheCreate (void)
{
FcFileCache *cache;
int h;
cache = malloc (sizeof (FcFileCache));
if (!cache)
return 0;
for (h = 0; h < FC_FILE_CACHE_HASH_SIZE; h++)
cache->ents[h] = 0;
cache->entries = 0;
cache->referenced = 0;
cache->updated = FcFalse;
return cache;
}
void
FcFileCacheDestroy (FcFileCache *cache)
{
FcFileCacheEnt *c, *next;
int h;
for (h = 0; h < FC_FILE_CACHE_HASH_SIZE; h++)
{
for (c = cache->ents[h]; c; c = next)
{
next = c->next;
free (c);
}
}
free (cache);
}
void
FcFileCacheLoad (FcFileCache *cache,
const FcChar8 *cache_file)
{
FILE *f;
FcChar8 file_buf[8192], *file;
int id;
time_t time;
FcChar8 name_buf[8192], *name;
f = fopen ((char *) cache_file, "r");
if (!f)
return;
cache->updated = FcFalse;
file = 0;
name = 0;
while ((file = FcFileCacheReadString (f, file_buf, sizeof (file_buf))) &&
FcFileCacheReadInt (f, &id) &&
FcFileCacheReadTime (f, &time) &&
(name = FcFileCacheReadString (f, name_buf, sizeof (name_buf))))
{
(void) FcFileCacheAdd (cache, file, id, time, name, FcFalse);
if (file != file_buf)
free (file);
if (name != name_buf)
free (name);
file = 0;
name = 0;
}
if (file && file != file_buf)
free (file);
if (name && name != name_buf)
free (name);
fclose (f);
}
FcBool
FcFileCacheUpdate (FcFileCache *cache,
const FcChar8 *file,
int id,
const FcChar8 *name)
{
const FcChar8 *match;
struct stat statb;
FcBool ret;
match = file;
if (stat ((char *) file, &statb) < 0)
return FcFalse;
ret = FcFileCacheAdd (cache, match, id,
statb.st_mtime, name, FcTrue);
if (ret)
cache->updated = FcTrue;
return ret;
}
static FcBool
FcFileCacheWriteString (FILE *f, const FcChar8 *string)
{
char c;
if (putc ('"', f) == EOF)
return FcFalse;
while ((c = *string++))
{
switch (c) {
case '"':
case '\\':
if (putc ('\\', f) == EOF)
return FcFalse;
/* fall through */
default:
if (putc (c, f) == EOF)
return FcFalse;
}
}
if (putc ('"', f) == EOF)
return FcFalse;
return FcTrue;
}
static FcBool
FcFileCacheWriteUlong (FILE *f, unsigned long t)
{
int pow;
unsigned long temp, digit;
temp = t;
pow = 1;
while (temp >= 10)
{
temp /= 10;
pow *= 10;
}
temp = t;
while (pow)
{
digit = temp / pow;
if (putc ((char) digit + '0', f) == EOF)
return FcFalse;
temp = temp - pow * digit;
pow = pow / 10;
}
return FcTrue;
}
static FcBool
FcFileCacheWriteInt (FILE *f, int i)
{
return FcFileCacheWriteUlong (f, (unsigned long) i);
}
static FcBool
FcFileCacheWriteTime (FILE *f, time_t t)
{
return FcFileCacheWriteUlong (f, (unsigned long) t);
}
FcBool
FcFileCacheSave (FcFileCache *cache,
const FcChar8 *cache_file)
{
FILE *f;
int h;
FcFileCacheEnt *c;
FcAtomic *atomic;
if (!cache->updated && cache->referenced == cache->entries)
return FcTrue;
/* Set-UID programs can't safely update the cache */
if (getuid () != geteuid ())
return FcFalse;
atomic = FcAtomicCreate (cache_file);
if (!atomic)
goto bail0;
if (!FcAtomicLock (atomic))
goto bail1;
f = fopen ((char *) FcAtomicNewFile(atomic), "w");
if (!f)
goto bail2;
for (h = 0; h < FC_FILE_CACHE_HASH_SIZE; h++)
{
for (c = cache->ents[h]; c; c = c->next)
{
if (!c->referenced)
continue;
if (!FcFileCacheWriteString (f, c->file))
goto bail4;
if (putc (' ', f) == EOF)
goto bail4;
if (!FcFileCacheWriteInt (f, c->id))
goto bail4;
if (putc (' ', f) == EOF)
goto bail4;
if (!FcFileCacheWriteTime (f, c->time))
goto bail4;
if (putc (' ', f) == EOF)
goto bail4;
if (!FcFileCacheWriteString (f, c->name))
goto bail4;
if (putc ('\n', f) == EOF)
goto bail4;
}
}
if (fclose (f) == EOF)
goto bail3;
if (!FcAtomicReplaceOrig (atomic))
goto bail3;
FcAtomicUnlock (atomic);
FcAtomicDestroy (atomic);
cache->updated = FcFalse;
return FcTrue;
bail4:
fclose (f);
bail3:
FcAtomicDeleteNew (atomic);
bail2:
FcAtomicUnlock (atomic);
bail1:
FcAtomicDestroy (atomic);
bail0:
return FcFalse;
}
FcBool
FcFileCacheReadDir (FcFontSet *set, const FcChar8 *cache_file)
{
FcPattern *font;
FILE *f;
FcChar8 *path;
FcChar8 *base;
FcChar8 file_buf[8192], *file;
int id;
FcChar8 name_buf[8192], *name;
FcBool ret = FcFalse;
if (FcDebug () & FC_DBG_CACHE)
{
printf ("FcFileCacheReadDir cache_file \"%s\"\n", cache_file);
}
f = fopen ((char *) cache_file, "r");
if (!f)
{
if (FcDebug () & FC_DBG_CACHE)
{
printf (" no cache file\n");
}
goto bail0;
}
base = (FcChar8 *) strrchr ((char *) cache_file, '/');
if (!base)
goto bail1;
base++;
path = malloc (base - cache_file + 8192 + 1);
if (!path)
goto bail1;
memcpy (path, cache_file, base - cache_file);
base = path + (base - cache_file);
file = 0;
name = 0;
while ((file = FcFileCacheReadString (f, file_buf, sizeof (file_buf))) &&
FcFileCacheReadInt (f, &id) &&
(name = FcFileCacheReadString (f, name_buf, sizeof (name_buf))))
{
font = FcNameParse (name);
if (font)
{
strcpy ((char *) base, (const char *) file);
if (FcDebug () & FC_DBG_CACHEV)
{
printf (" dir cache file \"%s\"\n", file);
}
FcPatternAddString (font, FC_FILE, path);
if (!FcFontSetAdd (set, font))
goto bail2;
}
if (file != file_buf)
free (file);
if (name != name_buf)
free (name);
file = name = 0;
}
if (FcDebug () & FC_DBG_CACHE)
{
printf (" cache loaded\n");
}
ret = FcTrue;
bail2:
free (path);
if (file && file != file_buf)
free (file);
if (name && name != name_buf)
free (name);
bail1:
fclose (f);
bail0:
return ret;
}
FcBool
FcFileCacheWriteDir (FcFontSet *set, const FcChar8 *cache_file)
{
FcPattern *font;
FILE *f;
FcChar8 *name;
const FcChar8 *file, *base;
int n;
int id;
FcBool ret;
if (FcDebug () & FC_DBG_CACHE)
printf ("FcFileCacheWriteDir cache_file \"%s\"\n", cache_file);
f = fopen ((char *) cache_file, "w");
if (!f)
{
if (FcDebug () & FC_DBG_CACHE)
printf (" can't create \"%s\"\n", cache_file);
goto bail0;
}
for (n = 0; n < set->nfont; n++)
{
font = set->fonts[n];
if (FcPatternGetString (font, FC_FILE, 0, (FcChar8 **) &file) != FcResultMatch)
goto bail1;
base = (FcChar8 *) strrchr ((char *) file, '/');
if (base)
base = base + 1;
else
base = file;
if (FcPatternGetInteger (font, FC_INDEX, 0, &id) != FcResultMatch)
goto bail1;
if (FcDebug () & FC_DBG_CACHEV)
printf (" write file \"%s\"\n", base);
if (!FcFileCacheWriteString (f, base))
goto bail1;
if (putc (' ', f) == EOF)
goto bail1;
if (!FcFileCacheWriteInt (f, id))
goto bail1;
if (putc (' ', f) == EOF)
goto bail1;
name = FcNameUnparse (font);
if (!name)
goto bail1;
ret = FcFileCacheWriteString (f, name);
free (name);
if (!ret)
goto bail1;
if (putc ('\n', f) == EOF)
goto bail1;
}
if (fclose (f) == EOF)
goto bail0;
if (FcDebug () & FC_DBG_CACHE)
printf (" cache written\n");
return FcTrue;
bail1:
fclose (f);
bail0:
unlink ((char *) cache_file);
return FcFalse;
}