2005-04-07 22:16:10 +00:00
|
|
|
/*
|
|
|
|
* GIT - The information manager from hell
|
|
|
|
*
|
|
|
|
* Copyright (C) Linus Torvalds, 2005
|
|
|
|
*/
|
2005-04-07 22:13:13 +00:00
|
|
|
#include "cache.h"
|
|
|
|
|
2005-04-10 18:32:54 +00:00
|
|
|
/*
|
|
|
|
* Default to not allowing changes to the list of files. The
|
|
|
|
* tool doesn't actually care, but this makes it harder to add
|
|
|
|
* files to the revision control by mistake by doing something
|
2005-05-19 11:17:16 +00:00
|
|
|
* like "git-update-cache *" and suddenly having all the object
|
2005-04-10 18:32:54 +00:00
|
|
|
* files be revision controlled.
|
|
|
|
*/
|
2005-05-08 04:55:21 +00:00
|
|
|
static int allow_add = 0, allow_remove = 0, allow_replace = 0, not_new = 0;
|
2005-05-31 16:52:43 +00:00
|
|
|
static int force_remove;
|
2005-04-24 22:14:16 +00:00
|
|
|
|
|
|
|
/* Three functions to allow overloaded pointer return; see linux/err.h */
|
|
|
|
static inline void *ERR_PTR(long error)
|
|
|
|
{
|
|
|
|
return (void *) error;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline long PTR_ERR(const void *ptr)
|
|
|
|
{
|
|
|
|
return (long) ptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline long IS_ERR(const void *ptr)
|
|
|
|
{
|
|
|
|
return (unsigned long)ptr > (unsigned long)-1000L;
|
|
|
|
}
|
2005-04-10 18:32:54 +00:00
|
|
|
|
2005-05-06 23:48:43 +00:00
|
|
|
static int add_file_to_cache(char *path)
|
2005-04-07 22:13:13 +00:00
|
|
|
{
|
2005-05-08 07:05:18 +00:00
|
|
|
int size, namelen, option, status;
|
2005-04-07 22:13:13 +00:00
|
|
|
struct cache_entry *ce;
|
|
|
|
struct stat st;
|
|
|
|
int fd;
|
2005-05-06 13:45:01 +00:00
|
|
|
char *target;
|
2005-04-07 22:13:13 +00:00
|
|
|
|
2005-05-08 07:05:18 +00:00
|
|
|
status = lstat(path, &st);
|
|
|
|
if (status < 0 || S_ISDIR(st.st_mode)) {
|
|
|
|
/* When we used to have "path" and now we want to add
|
|
|
|
* "path/file", we need a way to remove "path" before
|
|
|
|
* being able to add "path/file". However,
|
|
|
|
* "git-update-cache --remove path" would not work.
|
|
|
|
* --force-remove can be used but this is more user
|
|
|
|
* friendly, especially since we can do the opposite
|
|
|
|
* case just fine without --force-remove.
|
|
|
|
*/
|
|
|
|
if (status == 0 || (errno == ENOENT || errno == ENOTDIR)) {
|
2005-04-10 18:32:54 +00:00
|
|
|
if (allow_remove)
|
|
|
|
return remove_file_from_cache(path);
|
|
|
|
}
|
2005-04-26 19:04:55 +00:00
|
|
|
return error("open(\"%s\"): %s", path, strerror(errno));
|
2005-04-07 22:13:13 +00:00
|
|
|
}
|
|
|
|
namelen = strlen(path);
|
|
|
|
size = cache_entry_size(namelen);
|
2005-04-26 19:00:58 +00:00
|
|
|
ce = xmalloc(size);
|
2005-04-07 22:13:13 +00:00
|
|
|
memset(ce, 0, size);
|
|
|
|
memcpy(ce->name, path, namelen);
|
2005-04-11 16:39:21 +00:00
|
|
|
fill_stat_cache_info(ce, &st);
|
2005-04-17 05:26:31 +00:00
|
|
|
ce->ce_mode = create_ce_mode(st.st_mode);
|
2005-04-16 04:45:38 +00:00
|
|
|
ce->ce_flags = htons(namelen);
|
2005-05-05 12:38:25 +00:00
|
|
|
switch (st.st_mode & S_IFMT) {
|
|
|
|
case S_IFREG:
|
|
|
|
fd = open(path, O_RDONLY);
|
|
|
|
if (fd < 0)
|
|
|
|
return -1;
|
|
|
|
if (index_fd(ce->sha1, fd, &st) < 0)
|
|
|
|
return -1;
|
|
|
|
break;
|
|
|
|
case S_IFLNK:
|
2005-05-06 13:45:01 +00:00
|
|
|
target = xmalloc(st.st_size+1);
|
|
|
|
if (readlink(path, target, st.st_size+1) != st.st_size) {
|
|
|
|
free(target);
|
2005-05-05 12:38:25 +00:00
|
|
|
return -1;
|
2005-05-06 13:45:01 +00:00
|
|
|
}
|
|
|
|
if (write_sha1_file(target, st.st_size, "blob", ce->sha1))
|
2005-05-05 12:38:25 +00:00
|
|
|
return -1;
|
2005-05-06 13:45:01 +00:00
|
|
|
free(target);
|
2005-05-05 12:38:25 +00:00
|
|
|
break;
|
|
|
|
default:
|
2005-04-07 22:13:13 +00:00
|
|
|
return -1;
|
2005-05-05 12:38:25 +00:00
|
|
|
}
|
2005-05-08 04:55:21 +00:00
|
|
|
option = allow_add ? ADD_CACHE_OK_TO_ADD : 0;
|
|
|
|
option |= allow_replace ? ADD_CACHE_OK_TO_REPLACE : 0;
|
|
|
|
return add_cache_entry(ce, option);
|
2005-04-10 18:32:54 +00:00
|
|
|
}
|
|
|
|
|
2005-04-11 16:39:21 +00:00
|
|
|
static int match_data(int fd, void *buffer, unsigned long size)
|
|
|
|
{
|
|
|
|
while (size) {
|
|
|
|
char compare[1024];
|
|
|
|
int ret = read(fd, compare, sizeof(compare));
|
|
|
|
|
|
|
|
if (ret <= 0 || ret > size || memcmp(buffer, compare, ret))
|
|
|
|
return -1;
|
|
|
|
size -= ret;
|
|
|
|
buffer += ret;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-11 18:33:58 +00:00
|
|
|
static int compare_data(struct cache_entry *ce, unsigned long expected_size)
|
2005-04-10 18:32:54 +00:00
|
|
|
{
|
2005-04-11 16:39:21 +00:00
|
|
|
int match = -1;
|
|
|
|
int fd = open(ce->name, O_RDONLY);
|
|
|
|
|
|
|
|
if (fd >= 0) {
|
|
|
|
void *buffer;
|
|
|
|
unsigned long size;
|
[patch] git: fix overflow in update-cache.c
this patch fixes a 1-byte overflow in update-cache.c (probably not
exploitable). A specially crafted db object might trigger this overflow.
the bug is that normally the 'type' field is parsed by read_sha1_file(),
via:
if (sscanf(buffer, "%10s %lu", type, size) != 2)
i.e. 0-10 long strings, which take 1-11 bytes of space. Normally the
type strings are stored in char [20] arrays, but in update-cache.c that
is char [10], so a 1 byte overflow might occur.
This should not happen with a 'friendly' DB, as the longest type string
("commit") is 7 bytes long. The fix is to use the customary char [20].
(someone might want to clean those open-coded constants up with a
TYPE_LEN define, they do tend to cause problems like this. I'm not
against open-coded constants (they make code much more readable), but
for fields that get filled in from possibly hostile objects this is
playing with fire.)
hey, this might be the first true security fix for GIT? ;-)
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Petr Baudis <pasky@ucw.cz>
2005-04-14 11:18:19 +00:00
|
|
|
char type[20];
|
2005-04-11 16:39:21 +00:00
|
|
|
|
|
|
|
buffer = read_sha1_file(ce->sha1, type, &size);
|
|
|
|
if (buffer) {
|
2005-04-11 18:33:58 +00:00
|
|
|
if (size == expected_size && !strcmp(type, "blob"))
|
2005-04-11 16:39:21 +00:00
|
|
|
match = match_data(fd, buffer, size);
|
|
|
|
free(buffer);
|
|
|
|
}
|
|
|
|
close(fd);
|
|
|
|
}
|
|
|
|
return match;
|
|
|
|
}
|
|
|
|
|
2005-05-06 13:45:01 +00:00
|
|
|
static int compare_link(struct cache_entry *ce, unsigned long expected_size)
|
|
|
|
{
|
|
|
|
int match = -1;
|
|
|
|
char *target;
|
|
|
|
void *buffer;
|
|
|
|
unsigned long size;
|
|
|
|
char type[10];
|
|
|
|
int len;
|
|
|
|
|
|
|
|
target = xmalloc(expected_size);
|
|
|
|
len = readlink(ce->name, target, expected_size);
|
|
|
|
if (len != expected_size) {
|
|
|
|
free(target);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
buffer = read_sha1_file(ce->sha1, type, &size);
|
|
|
|
if (!buffer) {
|
|
|
|
free(target);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (size == expected_size)
|
|
|
|
match = memcmp(buffer, target, size);
|
|
|
|
free(buffer);
|
|
|
|
free(target);
|
|
|
|
return match;
|
|
|
|
}
|
|
|
|
|
2005-04-11 16:39:21 +00:00
|
|
|
/*
|
|
|
|
* "refresh" does not calculate a new sha1 file or bring the
|
|
|
|
* cache up-to-date for mode/content changes. But what it
|
|
|
|
* _does_ do is to "re-match" the stat information of a file
|
|
|
|
* with the cache, so that you can refresh the cache for a
|
|
|
|
* file that hasn't been changed but where the stat entry is
|
|
|
|
* out of date.
|
|
|
|
*
|
2005-05-19 11:17:16 +00:00
|
|
|
* For example, you'd want to do this after doing a "git-read-tree",
|
2005-04-11 16:39:21 +00:00
|
|
|
* to link up the stat cache details with the proper files.
|
|
|
|
*/
|
|
|
|
static struct cache_entry *refresh_entry(struct cache_entry *ce)
|
|
|
|
{
|
|
|
|
struct stat st;
|
|
|
|
struct cache_entry *updated;
|
|
|
|
int changed, size;
|
|
|
|
|
2005-05-05 12:38:25 +00:00
|
|
|
if (lstat(ce->name, &st) < 0)
|
2005-04-24 22:14:16 +00:00
|
|
|
return ERR_PTR(-errno);
|
2005-04-11 16:39:21 +00:00
|
|
|
|
2005-05-15 02:04:25 +00:00
|
|
|
changed = ce_match_stat(ce, &st);
|
2005-04-11 16:39:21 +00:00
|
|
|
if (!changed)
|
|
|
|
return ce;
|
|
|
|
|
2005-04-10 18:32:54 +00:00
|
|
|
/*
|
2005-05-05 12:38:25 +00:00
|
|
|
* If the mode or type has changed, there's no point in trying
|
2005-04-11 16:39:21 +00:00
|
|
|
* to refresh the entry - it's not going to match
|
2005-04-10 18:32:54 +00:00
|
|
|
*/
|
2005-05-05 12:38:25 +00:00
|
|
|
if (changed & (MODE_CHANGED | TYPE_CHANGED))
|
2005-04-24 22:14:16 +00:00
|
|
|
return ERR_PTR(-EINVAL);
|
2005-04-11 16:39:21 +00:00
|
|
|
|
2005-05-06 13:45:01 +00:00
|
|
|
switch (st.st_mode & S_IFMT) {
|
|
|
|
case S_IFREG:
|
|
|
|
if (compare_data(ce, st.st_size))
|
|
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
break;
|
|
|
|
case S_IFLNK:
|
|
|
|
if (compare_link(ce, st.st_size))
|
|
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
break;
|
|
|
|
default:
|
2005-04-24 22:14:16 +00:00
|
|
|
return ERR_PTR(-EINVAL);
|
2005-05-06 13:45:01 +00:00
|
|
|
}
|
2005-04-11 16:39:21 +00:00
|
|
|
|
|
|
|
size = ce_size(ce);
|
2005-04-26 19:00:58 +00:00
|
|
|
updated = xmalloc(size);
|
2005-04-11 16:39:21 +00:00
|
|
|
memcpy(updated, ce, size);
|
|
|
|
fill_stat_cache_info(updated, &st);
|
|
|
|
return updated;
|
2005-04-10 18:32:54 +00:00
|
|
|
}
|
|
|
|
|
2005-05-02 04:07:40 +00:00
|
|
|
static int refresh_cache(void)
|
2005-04-10 18:32:54 +00:00
|
|
|
{
|
|
|
|
int i;
|
2005-05-02 04:07:40 +00:00
|
|
|
int has_errors = 0;
|
2005-04-10 18:32:54 +00:00
|
|
|
|
2005-04-11 16:39:21 +00:00
|
|
|
for (i = 0; i < active_nr; i++) {
|
2005-04-18 17:42:48 +00:00
|
|
|
struct cache_entry *ce, *new;
|
|
|
|
ce = active_cache[i];
|
|
|
|
if (ce_stage(ce)) {
|
|
|
|
printf("%s: needs merge\n", ce->name);
|
2005-05-02 04:07:40 +00:00
|
|
|
has_errors = 1;
|
2005-04-18 17:42:48 +00:00
|
|
|
while ((i < active_nr) &&
|
|
|
|
! strcmp(active_cache[i]->name, ce->name))
|
|
|
|
i++;
|
|
|
|
i--;
|
|
|
|
continue;
|
|
|
|
}
|
2005-04-11 16:39:21 +00:00
|
|
|
|
2005-04-18 17:42:48 +00:00
|
|
|
new = refresh_entry(ce);
|
2005-04-24 22:14:16 +00:00
|
|
|
if (IS_ERR(new)) {
|
2005-05-02 04:07:40 +00:00
|
|
|
if (!(not_new && PTR_ERR(new) == -ENOENT)) {
|
2005-04-24 22:14:16 +00:00
|
|
|
printf("%s: needs update\n", ce->name);
|
2005-05-02 04:07:40 +00:00
|
|
|
has_errors = 1;
|
|
|
|
}
|
2005-04-11 16:39:21 +00:00
|
|
|
continue;
|
|
|
|
}
|
2005-05-06 23:48:43 +00:00
|
|
|
active_cache_changed = 1;
|
2005-04-17 21:34:51 +00:00
|
|
|
/* You can NOT just free active_cache[i] here, since it
|
|
|
|
* might not be necessarily malloc()ed but can also come
|
|
|
|
* from mmap(). */
|
2005-04-11 16:39:21 +00:00
|
|
|
active_cache[i] = new;
|
|
|
|
}
|
2005-05-02 04:07:40 +00:00
|
|
|
return has_errors;
|
2005-04-07 22:13:13 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We fundamentally don't like some paths: we don't want
|
2005-05-24 21:40:28 +00:00
|
|
|
* dot or dot-dot anywhere, and for obvious reasons don't
|
|
|
|
* want to recurse into ".git" either.
|
2005-04-07 22:13:13 +00:00
|
|
|
*
|
|
|
|
* Also, we don't want double slashes or slashes at the
|
2005-04-12 18:36:26 +00:00
|
|
|
* end that can make pathnames ambiguous.
|
2005-04-07 22:13:13 +00:00
|
|
|
*/
|
2005-05-24 21:40:28 +00:00
|
|
|
static int verify_dotfile(const char *rest)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* The first character was '.', but that
|
|
|
|
* has already been discarded, we now test
|
|
|
|
* the rest.
|
|
|
|
*/
|
|
|
|
switch (*rest) {
|
|
|
|
/* "." is not allowed */
|
|
|
|
case '\0': case '/':
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* ".git" followed by NUL or slash is bad. This
|
|
|
|
* shares the path end test with the ".." case.
|
|
|
|
*/
|
|
|
|
case 'g':
|
|
|
|
if (rest[1] != 'i')
|
|
|
|
break;
|
|
|
|
if (rest[2] != 't')
|
|
|
|
break;
|
|
|
|
rest += 2;
|
|
|
|
/* fallthrough */
|
|
|
|
case '.':
|
|
|
|
if (rest[1] == '\0' || rest[1] == '/')
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2005-04-07 22:13:13 +00:00
|
|
|
static int verify_path(char *path)
|
|
|
|
{
|
|
|
|
char c;
|
|
|
|
|
|
|
|
goto inside;
|
|
|
|
for (;;) {
|
|
|
|
if (!c)
|
|
|
|
return 1;
|
|
|
|
if (c == '/') {
|
|
|
|
inside:
|
|
|
|
c = *path++;
|
2005-05-24 21:40:28 +00:00
|
|
|
switch (c) {
|
|
|
|
default:
|
2005-04-07 22:13:13 +00:00
|
|
|
continue;
|
2005-05-24 21:40:28 +00:00
|
|
|
case '/': case '\0':
|
|
|
|
break;
|
|
|
|
case '.':
|
|
|
|
if (verify_dotfile(path))
|
|
|
|
continue;
|
|
|
|
}
|
2005-04-07 22:13:13 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
c = *path++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-15 18:08:33 +00:00
|
|
|
static int add_cacheinfo(char *arg1, char *arg2, char *arg3)
|
|
|
|
{
|
2005-05-08 04:55:21 +00:00
|
|
|
int size, len, option;
|
2005-04-15 18:08:33 +00:00
|
|
|
unsigned int mode;
|
|
|
|
unsigned char sha1[20];
|
|
|
|
struct cache_entry *ce;
|
|
|
|
|
|
|
|
if (sscanf(arg1, "%o", &mode) != 1)
|
|
|
|
return -1;
|
|
|
|
if (get_sha1_hex(arg2, sha1))
|
|
|
|
return -1;
|
|
|
|
if (!verify_path(arg3))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
len = strlen(arg3);
|
|
|
|
size = cache_entry_size(len);
|
2005-04-26 19:00:58 +00:00
|
|
|
ce = xmalloc(size);
|
2005-04-15 18:08:33 +00:00
|
|
|
memset(ce, 0, size);
|
|
|
|
|
|
|
|
memcpy(ce->sha1, sha1, 20);
|
|
|
|
memcpy(ce->name, arg3, len);
|
2005-04-16 04:45:38 +00:00
|
|
|
ce->ce_flags = htons(len);
|
2005-04-17 05:26:31 +00:00
|
|
|
ce->ce_mode = create_ce_mode(mode);
|
2005-05-08 04:55:21 +00:00
|
|
|
option = allow_add ? ADD_CACHE_OK_TO_ADD : 0;
|
|
|
|
option |= allow_replace ? ADD_CACHE_OK_TO_REPLACE : 0;
|
|
|
|
return add_cache_entry(ce, option);
|
2005-04-15 18:08:33 +00:00
|
|
|
}
|
|
|
|
|
2005-05-20 18:46:10 +00:00
|
|
|
static struct cache_file cache_file;
|
2005-04-26 18:55:42 +00:00
|
|
|
|
2005-04-07 22:13:13 +00:00
|
|
|
int main(int argc, char **argv)
|
|
|
|
{
|
2005-05-02 04:07:40 +00:00
|
|
|
int i, newfd, entries, has_errors = 0;
|
2005-04-10 18:32:54 +00:00
|
|
|
int allow_options = 1;
|
2005-04-21 17:55:18 +00:00
|
|
|
|
2005-05-15 21:23:12 +00:00
|
|
|
newfd = hold_index_file_for_update(&cache_file, get_index_file());
|
2005-04-11 22:39:26 +00:00
|
|
|
if (newfd < 0)
|
2005-04-13 09:28:48 +00:00
|
|
|
die("unable to create new cachefile");
|
2005-04-11 22:39:26 +00:00
|
|
|
|
2005-04-07 22:13:13 +00:00
|
|
|
entries = read_cache();
|
2005-04-11 22:39:26 +00:00
|
|
|
if (entries < 0)
|
2005-04-13 09:28:48 +00:00
|
|
|
die("cache corrupted");
|
2005-04-07 22:13:13 +00:00
|
|
|
|
|
|
|
for (i = 1 ; i < argc; i++) {
|
|
|
|
char *path = argv[i];
|
2005-04-10 18:32:54 +00:00
|
|
|
|
|
|
|
if (allow_options && *path == '-') {
|
|
|
|
if (!strcmp(path, "--")) {
|
|
|
|
allow_options = 0;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (!strcmp(path, "--add")) {
|
|
|
|
allow_add = 1;
|
|
|
|
continue;
|
|
|
|
}
|
2005-05-08 04:55:21 +00:00
|
|
|
if (!strcmp(path, "--replace")) {
|
|
|
|
allow_replace = 1;
|
|
|
|
continue;
|
|
|
|
}
|
2005-04-10 18:32:54 +00:00
|
|
|
if (!strcmp(path, "--remove")) {
|
|
|
|
allow_remove = 1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (!strcmp(path, "--refresh")) {
|
2005-05-02 04:07:40 +00:00
|
|
|
has_errors |= refresh_cache();
|
2005-04-10 18:32:54 +00:00
|
|
|
continue;
|
|
|
|
}
|
2005-04-15 18:08:33 +00:00
|
|
|
if (!strcmp(path, "--cacheinfo")) {
|
2005-05-08 22:31:33 +00:00
|
|
|
if (i+3 >= argc)
|
2005-05-19 11:17:16 +00:00
|
|
|
die("git-update-cache: --cacheinfo <mode> <sha1> <path>");
|
2005-05-08 22:31:33 +00:00
|
|
|
if (add_cacheinfo(argv[i+1], argv[i+2], argv[i+3]))
|
2005-05-19 11:17:16 +00:00
|
|
|
die("git-update-cache: --cacheinfo cannot add %s", argv[i+3]);
|
2005-04-15 18:08:33 +00:00
|
|
|
i += 3;
|
|
|
|
continue;
|
|
|
|
}
|
2005-05-02 06:50:51 +00:00
|
|
|
if (!strcmp(path, "--force-remove")) {
|
2005-05-31 16:52:43 +00:00
|
|
|
force_remove = 1;
|
2005-05-02 06:50:51 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2005-04-24 22:14:16 +00:00
|
|
|
if (!strcmp(path, "--ignore-missing")) {
|
|
|
|
not_new = 1;
|
|
|
|
continue;
|
|
|
|
}
|
2005-04-13 09:28:48 +00:00
|
|
|
die("unknown option %s", path);
|
2005-04-10 18:32:54 +00:00
|
|
|
}
|
2005-04-07 22:13:13 +00:00
|
|
|
if (!verify_path(path)) {
|
|
|
|
fprintf(stderr, "Ignoring path %s\n", argv[i]);
|
|
|
|
continue;
|
|
|
|
}
|
2005-05-31 16:52:43 +00:00
|
|
|
if (force_remove) {
|
|
|
|
if (remove_file_from_cache(path))
|
|
|
|
die("git-update-cache: --force-remove cannot remove %s", path);
|
|
|
|
continue;
|
|
|
|
}
|
2005-04-11 22:39:26 +00:00
|
|
|
if (add_file_to_cache(path))
|
2005-04-13 09:28:48 +00:00
|
|
|
die("Unable to add %s to database", path);
|
2005-04-07 22:13:13 +00:00
|
|
|
}
|
2005-05-15 21:23:12 +00:00
|
|
|
if (write_cache(newfd, active_cache, active_nr) ||
|
|
|
|
commit_index_file(&cache_file))
|
2005-04-13 09:28:48 +00:00
|
|
|
die("Unable to write new cachefile");
|
2005-04-11 22:39:26 +00:00
|
|
|
|
2005-05-05 22:29:06 +00:00
|
|
|
return has_errors ? 1 : 0;
|
2005-04-07 22:13:13 +00:00
|
|
|
}
|