[PATCH] git-export complains about mising cat-file

diff --git a/update-cache.c b/update-cache.c
index 4353b80890ba2afbe22248a4dc25060aa4a429b2..d53c9b5c3519ad36628db2e9b8648fe84934c31b 100644 (file)
--- a/update-cache.c
+++ b/update-cache.c
@@ -3,6 +3,7 @@
  *
  * Copyright (C) Linus Torvalds, 2005
  */
+#include <signal.h>
 #include "cache.h"
 
 /*
@@ -12,15 +13,31 @@
  * like "update-cache *" and suddenly having all the object
  * files be revision controlled.
  */
-static int allow_add = 0, allow_remove = 0;
+static int allow_add = 0, allow_remove = 0, not_new = 0;
+
+/* 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;
+}
 
 static int index_fd(unsigned char *sha1, int fd, struct stat *st)
 {
        z_stream stream;
        unsigned long size = st->st_size;
        int max_out_bytes = size + 200;
-       void *out = malloc(max_out_bytes);
-       void *metadata = malloc(200);
+       void *out = xmalloc(max_out_bytes);
+       void *metadata = xmalloc(200);
        int metadata_size;
        void *in;
        SHA_CTX c;
@@ -94,7 +111,7 @@ static int add_file_to_cache(char *path)
 
        fd = open(path, O_RDONLY);
        if (fd < 0) {
-               if (errno == ENOENT) {
+               if (errno == ENOENT || errno == ENOTDIR) {
                        if (allow_remove)
                                return remove_file_from_cache(path);
                }
@@ -106,7 +123,7 @@ static int add_file_to_cache(char *path)
        }
        namelen = strlen(path);
        size = cache_entry_size(namelen);
-       ce = malloc(size);
+       ce = xmalloc(size);
        memset(ce, 0, size);
        memcpy(ce->name, path, namelen);
        fill_stat_cache_info(ce, &st);
@@ -172,7 +189,7 @@ static struct cache_entry *refresh_entry(struct cache_entry *ce)
        int changed, size;
 
        if (stat(ce->name, &st) < 0)
-               return NULL;
+               return ERR_PTR(-errno);
 
        changed = cache_match_stat(ce, &st);
        if (!changed)
@@ -183,27 +200,29 @@ static struct cache_entry *refresh_entry(struct cache_entry *ce)
         * to refresh the entry - it's not going to match
         */
        if (changed & MODE_CHANGED)
-               return NULL;
+               return ERR_PTR(-EINVAL);
 
        if (compare_data(ce, st.st_size))
-               return NULL;
+               return ERR_PTR(-EINVAL);
 
        size = ce_size(ce);
-       updated = malloc(size);
+       updated = xmalloc(size);
        memcpy(updated, ce, size);
        fill_stat_cache_info(updated, &st);
        return updated;
 }
 
-static void refresh_cache(void)
+static int refresh_cache(void)
 {
        int i;
+       int has_errors = 0;
 
        for (i = 0; i < active_nr; i++) {
                struct cache_entry *ce, *new;
                ce = active_cache[i];
                if (ce_stage(ce)) {
                        printf("%s: needs merge\n", ce->name);
+                       has_errors = 1;
                        while ((i < active_nr) &&
                               ! strcmp(active_cache[i]->name, ce->name))
                                i++;
@@ -212,12 +231,16 @@ static void refresh_cache(void)
                }
 
                new = refresh_entry(ce);
-               if (!new) {
-                       printf("%s: needs update\n", ce->name);
+               if (IS_ERR(new)) {
+                       if (!(not_new && PTR_ERR(new) == -ENOENT)) {
+                               printf("%s: needs update\n", ce->name);
+                               has_errors = 1;
+                       }
                        continue;
                }
                active_cache[i] = new;
        }
+       return has_errors;
 }
 
 /*
@@ -264,7 +287,7 @@ static int add_cacheinfo(char *arg1, char *arg2, char *arg3)
 
        len = strlen(arg3);
        size = cache_entry_size(len);
-       ce = malloc(size);
+       ce = xmalloc(size);
        memset(ce, 0, size);
 
        memcpy(ce->sha1, sha1, 20);
@@ -282,9 +305,14 @@ static void remove_lock_file(void)
                unlink(lockfile_name);
 }
 
+static void remove_lock_file_on_signal(int signo)
+{
+       remove_lock_file();
+}
+
 int main(int argc, char **argv)
 {
-       int i, newfd, entries;
+       int i, newfd, entries, has_errors = 0;
        int allow_options = 1;
        static char lockfile[MAXPATHLEN+1];
        const char *indexfile = get_index_file();
@@ -295,6 +323,7 @@ int main(int argc, char **argv)
        if (newfd < 0)
                die("unable to create new cachefile");
 
+       signal(SIGINT, remove_lock_file_on_signal);
        atexit(remove_lock_file);
        lockfile_name = lockfile;
 
@@ -319,7 +348,7 @@ int main(int argc, char **argv)
                                continue;
                        }
                        if (!strcmp(path, "--refresh")) {
-                               refresh_cache();
+                               has_errors |= refresh_cache();
                                continue;
                        }
                        if (!strcmp(path, "--cacheinfo")) {
@@ -328,6 +357,10 @@ int main(int argc, char **argv)
                                i += 3;
                                continue;
                        }
+                       if (!strcmp(path, "--ignore-missing")) {
+                               not_new = 1;
+                               continue;
+                       }
                        die("unknown option %s", path);
                }
                if (!verify_path(path)) {
@@ -341,5 +374,5 @@ int main(int argc, char **argv)
                die("Unable to write new cachefile");
 
        lockfile_name = NULL;
-       return 0;
+       return has_errors;
 }