* 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
+ * documentation, and that the name of the author(s) not be used in
* advertising or publicity pertaining to distribution of the software without
- * specific, written prior permission. Keith Packard makes no
+ * specific, written prior permission. The authors make 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,
+ * THE AUTHOR(S) 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
+ * EVENT SHALL THE AUTHOR(S) 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
*/
#include "fcint.h"
-#include "../fc-arch/fcarch.h"
+#include "fcarch.h"
#include <stdio.h>
#include <fcntl.h>
#include <dirent.h>
#define O_BINARY 0
#endif
+
struct MD5Context {
FcChar32 buf[4];
FcChar32 bits[2];
*/
int
-FcStat (const char *file, struct stat *statb)
+FcStat (FcConfig *config, const FcChar8 *file, struct stat *statb)
{
WIN32_FILE_ATTRIBUTE_DATA wfad;
char full_path_name[MAX_PATH];
char *basename;
DWORD rc;
-
+
if (!GetFileAttributesEx (file, GetFileExInfoStandard, &wfad))
return -1;
-
+
statb->st_dev = 0;
/* Calculate a pseudo inode number as a hash of the full path name.
rc = GetLongPathName (full_path_name, full_path_name, sizeof (full_path_name));
statb->st_ino = FcStringHash (full_path_name);
-
+
statb->st_mode = _S_IREAD | _S_IWRITE;
statb->st_mode |= (statb->st_mode >> 3) | (statb->st_mode >> 6);
statb->st_mode |= _S_IFDIR;
else
statb->st_mode |= _S_IFREG;
-
+
statb->st_nlink = 1;
statb->st_uid = statb->st_gid = 0;
statb->st_rdev = 0;
-
+
if (wfad.nFileSizeHigh > 0)
return -1;
statb->st_size = wfad.nFileSizeLow;
-
+
statb->st_atime = (*(INT64 *)&wfad.ftLastAccessTime)/10000000 - EPOCH_OFFSET;
statb->st_mtime = (*(INT64 *)&wfad.ftLastWriteTime)/10000000 - EPOCH_OFFSET;
statb->st_ctime = statb->st_mtime;
-
+
return 0;
}
+
+#else
+
+int
+FcStat (FcConfig *config, const FcChar8 *file, struct stat *statb)
+{
+ int ret;
+ FcChar8 *fullFile = FcConfigGetRootPlus (config, file);
+
+ if (fullFile)
+ file = fullFile;
+ ret = stat ((char *) file, statb);
+ if (fullFile)
+ FcStrFree (fullFile);
+
+ return ret;
+}
+
#endif
static const char bin2hex[] = { '0', '1', '2', '3',
}
static int
-FcDirCacheOpenFile (const FcChar8 *cache_file, struct stat *file_stat)
+FcDirCacheOpenFile (FcConfig *config, const FcChar8 *cache_file, struct stat *file_stat)
{
int fd;
+ FcChar8 *fullFile;
#ifdef _WIN32
- if (FcStat (cache_file, file_stat) < 0)
+ if (FcStat (config, cache_file, file_stat) < 0)
return -1;
#endif
- fd = open((char *) cache_file, O_RDONLY | O_BINARY);
+ fullFile = FcConfigGetRootPlus (config, cache_file);
+ if (fullFile)
+ cache_file = fullFile;
+ fd = open ((char *) cache_file, O_RDONLY | O_BINARY);
+ if (fullFile)
+ FcStrFree (fullFile);
if (fd < 0)
return fd;
#ifndef _WIN32
return fd;
}
-/*
+/*
* Look for a cache file for the specified dir. Attempt
* to use each one we find, stopping when the callback
* indicates success
*/
static FcBool
-FcDirCacheProcess (FcConfig *config, const FcChar8 *dir,
- FcBool (*callback) (int fd, struct stat *fd_stat,
+FcDirCacheProcess (FcConfig *config, const FcChar8 *dir,
+ FcBool (*callback) (FcConfig *config, int fd, struct stat *fd_stat,
struct stat *dir_stat, void *closure),
void *closure, FcChar8 **cache_file_ret)
{
struct stat file_stat, dir_stat;
FcBool ret = FcFalse;
- if (FcStat ((char *) dir, &dir_stat) < 0)
+ if (FcStat (config, dir, &dir_stat) < 0)
return FcFalse;
FcDirCacheBasename (dir, cache_base);
FcChar8 *cache_hashed = FcStrPlus (cache_dir, cache_base);
if (!cache_hashed)
break;
- fd = FcDirCacheOpenFile (cache_hashed, &file_stat);
+ fd = FcDirCacheOpenFile (config, 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)
{
FcStrFree (cache_hashed);
}
FcStrListDone (list);
-
+
return ret;
}
update[fcCacheMaxLevel] = &fcCacheChains[fcCacheMaxLevel];
fcCacheMaxLevel = level;
}
-
+
s = malloc (sizeof (FcCacheSkip) + (level - 1) * sizeof (FcCacheSkip *));
if (!s)
return FcFalse;
s->cache_ino = 0;
s->cache_mtime = 0;
}
-
+
/*
* Insert into all fcCacheChains
*/
}
static FcBool
-FcCacheTimeValid (FcCache *cache, struct stat *dir_stat)
+FcCacheTimeValid (FcConfig *config, FcCache *cache, struct stat *dir_stat)
{
struct stat dir_static;
if (!dir_stat)
{
- if (FcStat ((const char *) FcCacheDir (cache), &dir_static) < 0)
+ if (FcStat (config, FcCacheDir (cache), &dir_static) < 0)
return FcFalse;
dir_stat = &dir_static;
}
* 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;
return NULL;
cache = FcCacheFindByStat (fd_stat);
if (cache)
- return cache;
+ {
+ if (FcCacheTimeValid (config, cache, dir_stat))
+ return cache;
+ FcDirCacheUnload (cache);
+ cache = NULL;
+ }
+
/*
* Lage cache files are mmap'ed, smaller cache files are read. This
* balances the system cost of mmap against per-process memory usage.
{
#if defined(HAVE_MMAP) || defined(__CYGWIN__)
cache = mmap (0, fd_stat->st_size, PROT_READ, MAP_SHARED, fd, 0);
+ if (cache == MAP_FAILED)
+ cache = NULL;
#elif defined(_WIN32)
{
HANDLE hFileMap;
PAGE_READONLY, 0, 0, NULL);
if (hFileMap != NULL)
{
- cache = MapViewOfFile (hFileMap, FILE_MAP_READ, 0, 0,
+ cache = MapViewOfFile (hFileMap, FILE_MAP_READ, 0, 0,
fd_stat->st_size);
CloseHandle (hFileMap);
}
return NULL;
}
allocated = FcTrue;
- }
- if (cache->magic != FC_CACHE_MAGIC_MMAP ||
+ }
+ if (cache->magic != FC_CACHE_MAGIC_MMAP ||
cache->version < FC_CACHE_CONTENT_VERSION ||
cache->size != fd_stat->st_size ||
- !FcCacheTimeValid (cache, dir_stat) ||
+ !FcCacheTimeValid (config, cache, dir_stat) ||
!FcCacheInsert (cache, fd_stat))
{
if (allocated)
}
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;
FcCache *
FcDirCacheLoadFile (const FcChar8 *cache_file, struct stat *file_stat)
+{
+ return FcDirCacheLoadFile2 (cache_file, FcConfigGetCurrent (), file_stat);
+}
+
+FcCache *
+FcDirCacheLoadFile2 (const FcChar8 *cache_file, FcConfig *config, struct stat *file_stat)
{
int fd;
FcCache *cache;
if (!file_stat)
file_stat = &my_file_stat;
- fd = FcDirCacheOpenFile (cache_file, file_stat);
+ fd = FcDirCacheOpenFile (config, cache_file, file_stat);
if (fd < 0)
return NULL;
- cache = FcDirCacheMapFd (fd, file_stat, NULL);
+ cache = FcDirCacheMapFd (config, fd, file_stat, NULL);
close (fd);
return cache;
}
* the magic number and the size field
*/
static FcBool
-FcDirCacheValidateHelper (int fd, struct stat *fd_stat, struct stat *dir_stat, void *closure)
+FcDirCacheValidateHelper (FcConfig *config, int fd, struct stat *fd_stat, struct stat *dir_stat, void *closure)
{
FcBool ret = FcTrue;
FcCache c;
-
+
if (read (fd, &c, sizeof (FcCache)) != sizeof (FcCache))
ret = FcFalse;
else if (c.magic != FC_CACHE_MAGIC_MMAP)
static FcBool
FcDirCacheValidConfig (const FcChar8 *dir, FcConfig *config)
{
- return FcDirCacheProcess (config, dir,
+ return FcDirCacheProcess (config, dir,
FcDirCacheValidateHelper,
NULL, NULL);
}
FcDirCacheValid (const FcChar8 *dir)
{
FcConfig *config;
-
+
config = FcConfigGetCurrent ();
if (!config)
return FcFalse;
FcSerialize *serialize = FcSerializeCreate ();
FcCache *cache;
int i;
- intptr_t cache_offset;
- intptr_t dirs_offset;
FcChar8 *dir_serialize;
intptr_t *dirs_serialize;
FcFontSet *set_serialize;
-
+
if (!serialize)
return NULL;
/*
* Space for cache structure
*/
- cache_offset = FcSerializeReserve (serialize, sizeof (FcCache));
+ FcSerializeReserve (serialize, sizeof (FcCache));
/*
* Directory name
*/
/*
* Subdirs
*/
- dirs_offset = FcSerializeAlloc (serialize, dirs, dirs->num * sizeof (FcChar8 *));
+ FcSerializeAlloc (serialize, dirs, dirs->num * sizeof (FcChar8 *));
for (i = 0; i < dirs->num; i++)
if (!FcStrSerializeAlloc (serialize, dirs->strs[i]))
goto bail1;
*/
if (!FcFontSetSerializeAlloc (serialize, set))
goto bail1;
-
+
/* Serialize layout complete. Now allocate space and fill it */
cache = malloc (serialize->size);
if (!cache)
if (!dir_serialize)
goto bail2;
cache->dir = FcPtrToOffset (cache, dir_serialize);
-
+
/*
* Serialize sub dirs
*/
goto bail2;
cache->dirs = FcPtrToOffset (cache, dirs_serialize);
cache->dirs_count = dirs->num;
- for (i = 0; i < dirs->num; i++)
+ for (i = 0; i < dirs->num; i++)
{
FcChar8 *d_serialize = FcStrSerialize (serialize, dirs->strs[i]);
if (!d_serialize)
goto bail2;
dirs_serialize[i] = FcPtrToOffset (dirs_serialize, d_serialize);
}
-
+
/*
* Serialize font set
*/
cache->set = FcPtrToOffset (cache, set_serialize);
FcSerializeDestroy (serialize);
-
+
FcCacheInsert (cache, NULL);
return cache;
{
FcChar8 *parent;
FcBool ret;
-
+
if (strlen ((char *) dir) == 0)
return FcFalse;
-
+
parent = FcStrDirname (dir);
if (!parent)
return FcFalse;
FcStrList *list;
FcChar8 *cache_dir = NULL;
FcChar8 *test_dir;
+ FcChar8 *full_test_dir;
+ FcBool free_test_dir;
+ FcCacheSkip *skip;
+ struct stat cache_stat;
int magic;
int written;
/*
* Write it to the first directory in the list which is writable
*/
-
+
list = FcStrListCreate (config->cacheDirs);
if (!list)
return FcFalse;
+ free_test_dir = FcFalse;
while ((test_dir = FcStrListNext (list))) {
+ if (free_test_dir)
+ FcStrFree (full_test_dir);
+ free_test_dir = FcFalse;
+
+ full_test_dir = FcConfigGetRootPlus (config, test_dir);
+ if (full_test_dir)
+ {
+ free_test_dir = FcTrue;
+ test_dir = full_test_dir;
+ }
+
if (access ((char *) test_dir, W_OK|X_OK) == 0)
{
cache_dir = test_dir;
}
FcStrListDone (list);
if (!cache_dir)
- return FcFalse;
+ goto bail0;
FcDirCacheBasename (dir, cache_base);
cache_hashed = FcStrPlus (cache_dir, cache_base);
if (!cache_hashed)
- return FcFalse;
+ goto bail0;
if (FcDebug () & FC_DBG_CACHE)
printf ("FcDirCacheWriteDir dir \"%s\" file \"%s\"\n",
if (!atomic)
goto bail1;
- if (!FcAtomicLock (atomic))
+ if (!FcAtomicLock2 (config, atomic))
goto bail3;
fd = open((char *)FcAtomicNewFile (atomic), O_RDWR | O_CREAT | O_BINARY, 0666);
if (fd == -1)
goto bail4;
-
+
/* Temporarily switch magic to MMAP while writing to file */
magic = cache->magic;
if (magic != FC_CACHE_MAGIC_MMAP)
cache->magic = FC_CACHE_MAGIC_MMAP;
-
+
/*
* Write cache contents to file
*/
written = write (fd, cache, cache->size);
-
+
/* Switch magic back */
if (magic != FC_CACHE_MAGIC_MMAP)
cache->magic = magic;
-
+
if (written != cache->size)
{
perror ("write cache");
close(fd);
if (!FcAtomicReplaceOrig(atomic))
goto bail4;
+
+ /* If the file is small, update the cache chain entry such that the
+ * new cache file is not read again. If it's large, we don't do that
+ * such that we reload it, using mmap, which is shared across processes.
+ */
+ if (cache->size < FC_CACHE_MIN_MMAP &&
+ (skip = FcCacheFindByAddr (cache)) &&
+ FcStat (config, cache_hashed, &cache_stat))
+ {
+ skip->cache_dev = cache_stat.st_dev;
+ skip->cache_ino = cache_stat.st_ino;
+ skip->cache_mtime = cache_stat.st_mtime;
+ }
+
FcStrFree (cache_hashed);
FcAtomicUnlock (atomic);
FcAtomicDestroy (atomic);
FcAtomicDestroy (atomic);
bail1:
FcStrFree (cache_hashed);
+ bail0:
+ if (free_test_dir)
+ FcStrFree (full_test_dir);
+ return FcFalse;
+}
+
+static void
+align_fd (int fd, off_t *pos, int align)
+{
+ int adj = *pos & (align - 1);
+ if (adj)
+ {
+ lseek (fd, adj, SEEK_CUR);
+ *pos += adj;
+ }
+}
+
+static uint64_t
+_conv_num (int src_fd, int dst_fd, off_t *src_pos, off_t *dst_pos,
+ FcBool src_be, FcBool dst_be, int src_psize, int dst_psize,
+ int src_read, int dst_write)
+{
+ unsigned char src[8], dst[8], *s, *d;
+ int i, src_step, dst_step;
+ uint64_t ret;
+
+ align_fd (src_fd, src_pos, src_read);
+ read (src_fd, src, src_read);
+ *src_pos += src_read;
+
+ if (src_be)
+ s = &src[src_read - 1], src_step = -1;
+ else
+ s = src, src_step = 1;
+ if (dst_be)
+ d = &dst[dst_write - 1], dst_step = -1;
+ else
+ d = dst, dst_step = 1;
+
+ ret = 0;
+ for (i = 0; i < src_read; ++i)
+ {
+ ret |= ((uint64_t) *s) << (8 * i);
+ *d = *s;
+ s += src_step;
+ d += dst_step;
+ }
+ for (; i < dst_write; ++i)
+ {
+ *d = 0;
+ d += dst_step;
+ }
+
+ align_fd (dst_fd, dst_pos, dst_write);
+ write (dst_fd, dst, dst_write);
+ *dst_pos += dst_write;
+
+ return ret;
+}
+#define conv_num(r, w) _conv_num (src_fd, dst_fd, &src_pos, &dst_pos, src_be, dst_be, src_psize, dst_psize, r, w)
+#define conv_ptr() conv_num (src_psize, dst_psize)
+#define conv_int() conv_num (4, 4)
+
+FcBool
+FcDirCacheConvert (const FcChar8 *src_cache, const FcChar8 *src_type,
+ const FcChar8 *dst_cache, const FcChar8 *dst_type)
+{
+ /* See fcarch.h for the spec used here */
+ FcCache c;
+ FcBool src_be;
+ FcBool dst_be;
+ int src_psize;
+ int dst_psize;
+ int src_dalign;
+ int dst_dalign;
+ int src_fd;
+ int dst_fd;
+ off_t src_pos;
+ off_t dst_pos;
+ struct stat src_st;
+
+ src_be = !strncmp ((const char *) src_type, "be", 2);
+ dst_be = !strncmp ((const char *) dst_type, "be", 2);
+
+ src_psize = !strncmp ((const char *) src_type + 2, "32", 2) ? 4 : 8;
+ dst_psize = !strncmp ((const char *) dst_type + 2, "32", 2) ? 4 : 8;
+
+ if (src_psize == 4)
+ src_dalign = !strncmp ((const char *) src_type + 4, "d4", 2) ? 4 : 8;
+ else
+ src_dalign = src_psize;
+
+ if (dst_psize == 4)
+ dst_dalign = !strncmp ((const char *) dst_type + 4, "d4", 2) ? 4 : 8;
+ else
+ dst_dalign = dst_psize;
+
+ src_fd = open ((const char *) src_cache, O_RDONLY);
+ if (src_fd == -1)
+ return FcFalse;
+ dst_fd = open ((const char *) dst_cache, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0666);
+ if (dst_fd == -1)
+ {
+ close (src_fd);
+ return FcFalse;
+ }
+ src_pos = dst_pos = 0;
+
+ /* Process FcCache at start of file */
+ c.magic = conv_int ();
+ c.version = conv_int ();
+ c.size = conv_ptr ();
+ c.dir = conv_ptr ();
+ c.dirs = conv_ptr ();
+ c.dirs_count = conv_int ();
+ c.set = conv_ptr ();
+ c.mtime = conv_int ();
+ align_fd (dst_fd, &dst_pos, dst_psize);
+
return FcFalse;
}
FcFontSet *old = FcCacheSet (c);
FcFontSet *new = FcFontSetCreate ();
int i;
-
+
if (!new)
return NULL;
for (i = 0; i < old->nfont; i++)
}
/*
- * Final wrapup - pad to 64-byte boundary with the bit pattern
+ * Final wrapup - pad to 64-byte boundary with the bit pattern
* 1 0* (64-bit count of bits processed, MSB-first)
*/
static void MD5Final(unsigned char digest[16], struct MD5Context *ctx)
MD5Transform(ctx->buf, (FcChar32 *) ctx->in);
byteReverse((unsigned char *) ctx->buf, 4);
memcpy(digest, ctx->buf, 16);
- memset(ctx, 0, sizeof(ctx)); /* In case it's sensitive */
+ memset(ctx, 0, sizeof(*ctx)); /* In case it's sensitive */
}
git.wh0rd.org / fontconfig.git / blobdiff