[PATCH] checkout-cache fix

Fix checkout-cache when existing work tree interferes with the checkout.

This is essentially the same one as the last one I sent to the
GIT list, except that the patch is rebased to the current tip of
the git-pb tree, and an unnecessary call to create_directories()
removed.

The checkout-cache command gets confused when checking out a
file in a subdirectory and the work tree has a symlink to the
subdirectory.  Also it fails to check things out when there is a
non-directory in the work tree when cache expects a directory
there, and vice versa.  This patch fixes the first problem by
making sure all the leading paths in the file being checked out
are indeed directories, and also fixes directory vs
non-directory conflicts when '-f' is specified by removing the
offending paths.

Signed-off-by: Junio C Hamano <junkio@cox.net>
Signed-off-by: Petr Baudis <pasky@ucw.cz>

diff --git a/checkout-cache.c b/checkout-cache.c
index b561ef487ee093207ba2034e1142614276d1e5a9..18729374fc5da8a6c7b568fe571bac58e705545d 100644 (file)
--- a/checkout-cache.c
+++ b/checkout-cache.c
@@ -32,6 +32,8 @@
  * of "-a" causing problems (not possible in the above example,
  * but get used to it in scripting!).
  */
+#include <sys/types.h>
+#include <dirent.h>
 #include "cache.h"
 
 static int force = 0, quiet = 0, not_new = 0;
@@ -46,20 +48,61 @@ static void create_directories(const char *path)
                len = slash - path;
                memcpy(buf, path, len);
                buf[len] = 0;
-               mkdir(buf, 0755);
+               if (mkdir(buf, 0755)) {
+                       if (errno == EEXIST) {
+                               struct stat st;
+                               if (!lstat(buf, &st) && S_ISDIR(st.st_mode))
+                                       continue; /* ok */
+                               if (force && !unlink(buf) && !mkdir(buf, 0755))
+                                       continue;
+                       }
+                       die("cannot create directory at %s", buf);
+               }
        }
        free(buf);
 }
 
+static void remove_subtree(const char *path)
+{
+       DIR *dir = opendir(path);
+       struct dirent *de;
+       char pathbuf[PATH_MAX];
+       char *name;
+       
+       if (!dir)
+               die("cannot opendir %s", path);
+       strcpy(pathbuf, path);
+       name = pathbuf + strlen(path);
+       *name++ = '/';
+       while ((de = readdir(dir)) != NULL) {
+               struct stat st;
+               if ((de->d_name[0] == '.') &&
+                   ((de->d_name[1] == 0) ||
+                    ((de->d_name[1] == '.') && de->d_name[2] == 0)))
+                       continue;
+               strcpy(name, de->d_name);
+               if (lstat(pathbuf, &st))
+                       die("cannot lstat %s", pathbuf);
+               if (S_ISDIR(st.st_mode))
+                       remove_subtree(pathbuf);
+               else if (unlink(pathbuf))
+                       die("cannot unlink %s", pathbuf);
+       }
+       closedir(dir);
+       if (rmdir(path))
+               die("cannot rmdir %s", path);
+}
+
 static int create_file(const char *path, unsigned int mode)
 {
        int fd;
 
        mode = (mode & 0100) ? 0777 : 0666;
+       create_directories(path);
        fd = open(path, O_WRONLY | O_TRUNC | O_CREAT, mode);
        if (fd < 0) {
-               if (errno == ENOENT) {
-                       create_directories(path);
+               if (errno == EISDIR && force) {
+                       remove_subtree(path);
                        fd = open(path, O_WRONLY | O_TRUNC | O_CREAT, mode);
                }
        }