Fixed a leak in read-tree

[git.git] / diff.c

diff --git a/diff.c b/diff.c
index 8dfa624..3230997 100644 (file)
--- a/diff.c
+++ b/diff.c
@@ -4,14 +4,15 @@
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <signal.h>
+#include <limits.h>
 #include "cache.h"
 #include "diff.h"
 
-static char *diff_opts = "-pu";
+static const char *diff_opts = "-pu";
 
 static const char *external_diff(void)
 {
-       static char *external_diff_cmd = NULL;
+       static const char *external_diff_cmd = NULL;
        static int done_preparing = 0;
 
        if (done_preparing)
@@ -25,11 +26,11 @@ static const char *external_diff(void)
         *
         * GIT_DIFF_OPTS="-c";
         */
-       if (getenv("GIT_EXTERNAL_DIFF"))
-               external_diff_cmd = getenv("GIT_EXTERNAL_DIFF");
+       if (gitenv("GIT_EXTERNAL_DIFF"))
+               external_diff_cmd = gitenv("GIT_EXTERNAL_DIFF");
 
        /* In case external diff fails... */
-       diff_opts = getenv("GIT_DIFF_OPTS") ? : diff_opts;
+       diff_opts = gitenv("GIT_DIFF_OPTS") ? : diff_opts;
 
        done_preparing = 1;
        return external_diff_cmd;
@@ -125,9 +126,16 @@ static void builtin_diff(const char *name,
                printf("Created: %s (mode:%s)\n", name, temp[1].mode);
        else if (!path1[1][0])
                printf("Deleted: %s\n", name);
-       else if (strcmp(temp[0].mode, temp[1].mode))
+       else if (strcmp(temp[0].mode, temp[1].mode)) {
                printf("Mode changed: %s (%s->%s)\n", name,
                       temp[0].mode, temp[1].mode);
+               /* Be careful.  We do not want to diff between
+                * symlink and a file.
+                */
+               if (strncmp(temp[0].mode, "120", 3) !=
+                   strncmp(temp[1].mode, "120", 3))
+                       exit(0);
+       }
        fflush(NULL);
        execlp("/bin/sh","sh", "-c", cmd, NULL);
 }
@@ -163,13 +171,35 @@ static int work_tree_matches(const char *name, const unsigned char *sha1)
        if (pos < 0)
                return 0;
        ce = active_cache[pos];
-       if ((stat(name, &st) < 0) ||
+       if ((lstat(name, &st) < 0) ||
+           !S_ISREG(st.st_mode) ||
            cache_match_stat(ce, &st) ||
            memcmp(sha1, ce->sha1, 20))
                return 0;
        return 1;
 }
 
+static void prep_temp_blob(struct diff_tempfile *temp,
+                          void *blob,
+                          unsigned long size,
+                          unsigned char *sha1,
+                          int mode)
+{
+       int fd;
+
+       strcpy(temp->tmp_path, ".diff_XXXXXX");
+       fd = mkstemp(temp->tmp_path);
+       if (fd < 0)
+               die("unable to create temp-file");
+       if (write(fd, blob, size) != size)
+               die("unable to write temp-file");
+       close(fd);
+       temp->name = temp->tmp_path;
+       strcpy(temp->hex, sha1_to_hex(sha1));
+       temp->hex[40] = 0;
+       sprintf(temp->mode, "%06o", mode);
+}
+
 static void prepare_temp_file(const char *name,
                              struct diff_tempfile *temp,
                              struct diff_spec *one)
@@ -196,20 +226,36 @@ static void prepare_temp_file(const char *name,
        if (!one->sha1_valid || use_work_tree) {
                struct stat st;
                temp->name = name;
-               if (stat(temp->name, &st) < 0) {
+               if (lstat(temp->name, &st) < 0) {
                        if (errno == ENOENT)
                                goto not_a_valid_file;
                        die("stat(%s): %s", temp->name, strerror(errno));
                }
-               if (!one->sha1_valid)
-                       strcpy(temp->hex, sha1_to_hex(null_sha1));
-               else
-                       strcpy(temp->hex, sha1_to_hex(one->blob_sha1));
-               sprintf(temp->mode, "%06o",
-                       S_IFREG |ce_permissions(st.st_mode));
+               if (S_ISLNK(st.st_mode)) {
+                       int ret;
+                       char *buf, buf_[1024];
+                       buf = ((sizeof(buf_) < st.st_size) ?
+                              xmalloc(st.st_size) : buf_);
+                       ret = readlink(name, buf, st.st_size);
+                       if (ret < 0)
+                               die("readlink(%s)", name);
+                       prep_temp_blob(temp, buf, st.st_size,
+                                      (one->sha1_valid ?
+                                       one->blob_sha1 : null_sha1),
+                                      (one->sha1_valid ?
+                                       one->mode : S_IFLNK));
+               }
+               else {
+                       if (!one->sha1_valid)
+                               strcpy(temp->hex, sha1_to_hex(null_sha1));
+                       else
+                               strcpy(temp->hex, sha1_to_hex(one->blob_sha1));
+                       sprintf(temp->mode, "%06o",
+                               S_IFREG |ce_permissions(st.st_mode));
+               }
+               return;
        }
        else {
-               int fd;
                void *blob;
                char type[20];
                unsigned long size;
@@ -218,19 +264,8 @@ static void prepare_temp_file(const char *name,
                if (!blob || strcmp(type, "blob"))
                        die("unable to read blob object for %s (%s)",
                            name, sha1_to_hex(one->blob_sha1));
-
-               strcpy(temp->tmp_path, ".diff_XXXXXX");
-               fd = mkstemp(temp->tmp_path);
-               if (fd < 0)
-                       die("unable to create temp-file");
-               if (write(fd, blob, size) != size)
-                       die("unable to write temp-file");
-               close(fd);
+               prep_temp_blob(temp, blob, size, one->blob_sha1, one->mode);
                free(blob);
-               temp->name = temp->tmp_path;
-               strcpy(temp->hex, sha1_to_hex(one->blob_sha1));
-               temp->hex[40] = 0;
-               sprintf(temp->mode, "%06o", one->mode);
        }
 }