diff.c

   1 /*
   2  * Copyright (C) 2005 Junio C Hamano
   3  */
   4 #include <sys/types.h>
   5 #include <sys/wait.h>
   6 #include <signal.h>
   7 #include "cache.h"
   8 #include "diff.h"
   9
  10 static char *diff_opts = "-pu";
  11
  12 static const char *external_diff(void)
  13 {
  14         static char *external_diff_cmd = NULL;
  15         static int done_preparing = 0;
  16
  17         if (done_preparing)
  18                 return external_diff_cmd;
  19
  20         /*
  21          * Default values above are meant to match the
  22          * Linux kernel development style.  Examples of
  23          * alternative styles you can specify via environment
  24          * variables are:
  25          *
  26          * GIT_DIFF_OPTS="-c";
  27          */
  28         if (getenv("GIT_EXTERNAL_DIFF"))
  29                 external_diff_cmd = getenv("GIT_EXTERNAL_DIFF");
  30
  31         /* In case external diff fails... */
  32         diff_opts = getenv("GIT_DIFF_OPTS") ? : diff_opts;
  33
  34         done_preparing = 1;
  35         return external_diff_cmd;
  36 }
  37
  38 /* Help to copy the thing properly quoted for the shell safety.
  39  * any single quote is replaced with '\'', and the caller is
  40  * expected to enclose the result within a single quote pair.
  41  *
  42  * E.g.
  43  *  original     sq_expand     result
  44  *  name     ==> name      ==> 'name'
  45  *  a b      ==> a b       ==> 'a b'
  46  *  a'b      ==> a'\''b    ==> 'a'\''b'
  47  */
  48 static char *sq_expand(const char *src)
  49 {
  50         static char *buf = NULL;
  51         int cnt, c;
  52         const char *cp;
  53         char *bp;
  54
  55         /* count bytes needed to store the quoted string. */
  56         for (cnt = 1, cp = src; *cp; cnt++, cp++)
  57                 if (*cp == '\'')
  58                         cnt += 3;
  59
  60         buf = xmalloc(cnt);
  61         bp = buf;
  62         while ((c = *src++)) {
  63                 if (c != '\'')
  64                         *bp++ = c;
  65                 else {
  66                         bp = strcpy(bp, "'\\''");
  67                         bp += 4;
  68                 }
  69         }
  70         *bp = 0;
  71         return buf;
  72 }
  73
  74 static struct diff_tempfile {
  75         const char *name;
  76         char hex[41];
  77         char mode[10];
  78         char tmp_path[50];
  79 } diff_temp[2];
  80
  81 static void builtin_diff(const char *name,
  82                          struct diff_tempfile *temp)
  83 {
  84         int i, next_at;
  85         const char *diff_cmd = "diff -L'%s%s' -L'%s%s'";
  86         const char *diff_arg  = "'%s' '%s'||:"; /* "||:" is to return 0 */
  87         const char *input_name_sq[2];
  88         const char *path0[2];
  89         const char *path1[2];
  90         const char *name_sq = sq_expand(name);
  91         char *cmd;
  92
  93         /* diff_cmd and diff_arg have 6 %s in total which makes
  94          * the sum of these strings 12 bytes larger than required.
  95          * we use 2 spaces around diff-opts, and we need to count
  96          * terminating NUL, so we subtract 9 here.
  97          */
  98         int cmd_size = (strlen(diff_cmd) + strlen(diff_opts) +
  99                         strlen(diff_arg) - 9);
 100         for (i = 0; i < 2; i++) {
 101                 input_name_sq[i] = sq_expand(temp[i].name);
 102                 if (!strcmp(temp[i].name, "/dev/null")) {
 103                         path0[i] = "/dev/null";
 104                         path1[i] = "";
 105                 } else {
 106                         path0[i] = i ? "b/" : "a/";
 107                         path1[i] = name_sq;
 108                 }
 109                 cmd_size += (strlen(path0[i]) + strlen(path1[i]) +
 110                              strlen(input_name_sq[i]));
 111         }
 112
 113         cmd = xmalloc(cmd_size);
 114
 115         next_at = 0;
 116         next_at += snprintf(cmd+next_at, cmd_size-next_at,
 117                             diff_cmd,
 118                             path0[0], path1[0], path0[1], path1[1]);
 119         next_at += snprintf(cmd+next_at, cmd_size-next_at,
 120                             " %s ", diff_opts);
 121         next_at += snprintf(cmd+next_at, cmd_size-next_at,
 122                             diff_arg, input_name_sq[0], input_name_sq[1]);
 123
 124         if (!path1[0][0])
 125                 printf("Created: %s (mode:%s)\n", name, temp[1].mode);
 126         else if (!path1[1][0])
 127                 printf("Deleted: %s\n", name);
 128         else if (strcmp(temp[0].mode, temp[1].mode))
 129                 printf("Mode changed: %s (%s->%s)\n", name,
 130                        temp[0].mode, temp[1].mode);
 131         fflush(NULL);
 132         execlp("/bin/sh","sh", "-c", cmd, NULL);
 133 }
 134
 135 /*
 136  * Given a name and sha1 pair, if the dircache tells us the file in
 137  * the work tree has that object contents, return true, so that
 138  * prepare_temp_file() does not have to inflate and extract.
 139  */
 140 static int work_tree_matches(const char *name, const unsigned char *sha1)
 141 {
 142         struct cache_entry *ce;
 143         struct stat st;
 144         int pos, len;
 145
 146         /* We do not read the cache ourselves here, because the
 147          * benchmark with my previous version that always reads cache
 148          * shows that it makes things worse for diff-tree comparing
 149          * two linux-2.6 kernel trees in an already checked out work
 150          * tree.  This is because most diff-tree comparison deals with
 151          * only a small number of files, while reading the cache is
 152          * expensive for a large project, and its cost outweighs the
 153          * savings we get by not inflating the object to a temporary
 154          * file.  Practically, this code only helps when we are used
 155          * by diff-cache --cached, which does read the cache before
 156          * calling us.
 157          */
 158         if (!active_cache)
 159                 return 0;
 160
 161         len = strlen(name);
 162         pos = cache_name_pos(name, len);
 163         if (pos < 0)
 164                 return 0;
 165         ce = active_cache[pos];
 166         if ((stat(name, &st) < 0) ||
 167             cache_match_stat(ce, &st) ||
 168             memcmp(sha1, ce->sha1, 20))
 169                 return 0;
 170         return 1;
 171 }
 172
 173 static void prepare_temp_file(const char *name,
 174                               struct diff_tempfile *temp,
 175                               struct diff_spec *one)
 176 {
 177         static unsigned char null_sha1[20] = { 0, };
 178         int use_work_tree = 0;
 179
 180         if (!one->file_valid) {
 181         not_a_valid_file:
 182                 /* A '-' entry produces this for file-2, and
 183                  * a '+' entry produces this for file-1.
 184                  */
 185                 temp->name = "/dev/null";
 186                 strcpy(temp->hex, ".");
 187                 strcpy(temp->mode, ".");
 188                 return;
 189         }
 190
 191         if (one->sha1_valid &&
 192             (!memcmp(one->blob_sha1, null_sha1, sizeof(null_sha1)) ||
 193              work_tree_matches(name, one->blob_sha1)))
 194                 use_work_tree = 1;
 195
 196         if (!one->sha1_valid || use_work_tree) {
 197                 struct stat st;
 198                 temp->name = name;
 199                 if (stat(temp->name, &st) < 0) {
 200                         if (errno == ENOENT)
 201                                 goto not_a_valid_file;
 202                         die("stat(%s): %s", temp->name, strerror(errno));
 203                 }
 204                 if (!one->sha1_valid)
 205                         strcpy(temp->hex, sha1_to_hex(null_sha1));
 206                 else
 207                         strcpy(temp->hex, sha1_to_hex(one->blob_sha1));
 208                 sprintf(temp->mode, "%06o",
 209                         S_IFREG |ce_permissions(st.st_mode));
 210         }
 211         else {
 212                 int fd;
 213                 void *blob;
 214                 char type[20];
 215                 unsigned long size;
 216
 217                 blob = read_sha1_file(one->blob_sha1, type, &size);
 218                 if (!blob || strcmp(type, "blob"))
 219                         die("unable to read blob object for %s (%s)",
 220                             name, sha1_to_hex(one->blob_sha1));
 221
 222                 strcpy(temp->tmp_path, ".diff_XXXXXX");
 223                 fd = mkstemp(temp->tmp_path);
 224                 if (fd < 0)
 225                         die("unable to create temp-file");
 226                 if (write(fd, blob, size) != size)
 227                         die("unable to write temp-file");
 228                 close(fd);
 229                 free(blob);
 230                 temp->name = temp->tmp_path;
 231                 strcpy(temp->hex, sha1_to_hex(one->blob_sha1));
 232                 temp->hex[40] = 0;
 233                 sprintf(temp->mode, "%06o", one->mode);
 234         }
 235 }
 236
 237 static void remove_tempfile(void)
 238 {
 239         int i;
 240
 241         for (i = 0; i < 2; i++)
 242                 if (diff_temp[i].name == diff_temp[i].tmp_path) {
 243                         unlink(diff_temp[i].name);
 244                         diff_temp[i].name = NULL;
 245                 }
 246 }
 247
 248 static void remove_tempfile_on_signal(int signo)
 249 {
 250         remove_tempfile();
 251 }
 252
 253 /* An external diff command takes:
 254  *
 255  * diff-cmd name infile1 infile1-sha1 infile1-mode \
 256  *               infile2 infile2-sha1 infile2-mode.
 257  *
 258  */
 259 void run_external_diff(const char *name,
 260                        struct diff_spec *one,
 261                        struct diff_spec *two)
 262 {
 263         struct diff_tempfile *temp = diff_temp;
 264         pid_t pid;
 265         int status;
 266         static int atexit_asked = 0;
 267
 268         if (one && two) {
 269                 prepare_temp_file(name, &temp[0], one);
 270                 prepare_temp_file(name, &temp[1], two);
 271                 if (! atexit_asked &&
 272                     (temp[0].name == temp[0].tmp_path ||
 273                      temp[1].name == temp[1].tmp_path)) {
 274                         atexit_asked = 1;
 275                         atexit(remove_tempfile);
 276                 }
 277                 signal(SIGINT, remove_tempfile_on_signal);
 278         }
 279
 280         fflush(NULL);
 281         pid = fork();
 282         if (pid < 0)
 283                 die("unable to fork");
 284         if (!pid) {
 285                 const char *pgm = external_diff();
 286                 if (pgm) {
 287                         if (one && two)
 288                                 execlp(pgm, pgm,
 289                                        name,
 290                                        temp[0].name, temp[0].hex, temp[0].mode,
 291                                        temp[1].name, temp[1].hex, temp[1].mode,
 292                                        NULL);
 293                         else
 294                                 execlp(pgm, pgm, name, NULL);
 295                 }
 296                 /*
 297                  * otherwise we use the built-in one.
 298                  */
 299                 if (one && two)
 300                         builtin_diff(name, temp);
 301                 else
 302                         printf("* Unmerged path %s\n", name);
 303                 exit(0);
 304         }
 305         if (waitpid(pid, &status, 0) < 0 ||
 306             !WIFEXITED(status) || WEXITSTATUS(status)) {
 307                 /* Earlier we did not check the exit status because
 308                  * diff exits non-zero if files are different, and
 309                  * we are not interested in knowing that.  It was a
 310                  * mistake which made it harder to quit a diff-*
 311                  * session that uses the git-apply-patch-script as
 312                  * the GIT_EXTERNAL_DIFF.  A custom GIT_EXTERNAL_DIFF
 313                  * should also exit non-zero only when it wants to
 314                  * abort the entire diff-* session.
 315                  */
 316                 remove_tempfile();
 317                 fprintf(stderr, "external diff died, stopping at %s.\n", name);
 318                 exit(1);
 319         }
 320         remove_tempfile();
 321 }
 322
 323 void diff_addremove(int addremove, unsigned mode,
 324                     const unsigned char *sha1,
 325                     const char *base, const char *path)
 326 {
 327         char concatpath[PATH_MAX];
 328         struct diff_spec spec[2], *one, *two;
 329
 330         memcpy(spec[0].blob_sha1, sha1, 20);
 331         spec[0].mode = mode;
 332         spec[0].sha1_valid = spec[0].file_valid = 1;
 333         spec[1].file_valid = 0;
 334
 335         if (addremove == '+') {
 336                 one = spec + 1; two = spec;
 337         } else {
 338                 one = spec; two = one + 1;
 339         }
 340
 341         if (path) {
 342                 strcpy(concatpath, base);
 343                 strcat(concatpath, path);
 344         }
 345         run_external_diff(path ? concatpath : base, one, two);
 346 }
 347
 348 void diff_change(unsigned old_mode, unsigned new_mode,
 349                  const unsigned char *old_sha1,
 350                  const unsigned char *new_sha1,
 351                  const char *base, const char *path) {
 352         char concatpath[PATH_MAX];
 353         struct diff_spec spec[2];
 354
 355         memcpy(spec[0].blob_sha1, old_sha1, 20);
 356         spec[0].mode = old_mode;
 357         memcpy(spec[1].blob_sha1, new_sha1, 20);
 358         spec[1].mode = new_mode;
 359         spec[0].sha1_valid = spec[0].file_valid = 1;
 360         spec[1].sha1_valid = spec[1].file_valid = 1;
 361
 362         if (path) {
 363                 strcpy(concatpath, base);
 364                 strcat(concatpath, path);
 365         }
 366         run_external_diff(path ? concatpath : base, &spec[0], &spec[1]);
 367 }
 368
 369 void diff_unmerge(const char *path)
 370 {
 371         run_external_diff(path, NULL, NULL);
 372 }