[PATCH] show-diff.c: check unreadbale blob.
[git.git] / show-diff.c
1 /*
2  * GIT - The information manager from hell
3  *
4  * Copyright (C) Linus Torvalds, 2005
5  */
6 #include "cache.h"
7
8 static char *diff_cmd = "diff -L '%s' -u -N  - '%s'";
9
10 /* Help to copy the thing properly quoted for the shell safety.
11  * any single quote is replaced with '\'', and the caller is
12  * expected to enclose the result within a single quote pair.
13  *
14  * E.g.
15  *  original     sq_expand     result
16  *  name     ==> name      ==> 'name'
17  *  a b      ==> a b       ==> 'a b'
18  *  a'b      ==> a'\''b    ==> 'a'\''b'
19  *
20  * NOTE! The returned memory belongs to this function so
21  * do not free it.
22  */
23 static char *sq_expand(char *src)
24 {
25         static char *buf = NULL;
26         int cnt, c;
27         char *cp;
28
29         /* count bytes needed to store the quoted string. */ 
30         for (cnt = 1, cp = src; *cp; cnt++, cp++)
31                 if (*cp == '\'')
32                         cnt += 3;
33
34         if (! (buf = malloc(cnt)))
35             return buf;
36         cp = buf;
37         while ((c = *src++)) {
38                 if (c != '\'')
39                         *cp++ = c;
40                 else {
41                         cp = strcpy(cp, "'\\''");
42                         cp += 4;
43                 }
44         }
45         *cp = 0;
46         return buf;
47 }
48
49 static void show_differences(char *name, void *old_contents,
50                              unsigned long long old_size)
51 {
52         FILE *f;
53         char *name_sq = sq_expand(name);
54         int cmd_size = strlen(name_sq) * 2 + strlen(diff_cmd);
55         char *cmd = malloc(cmd_size);
56
57         snprintf(cmd, cmd_size, diff_cmd, name_sq, name_sq);
58         f = popen(cmd, "w");
59         if (old_size)
60                 fwrite(old_contents, old_size, 1, f);
61         pclose(f);
62         free(name_sq);
63         free(cmd);
64 }
65
66 static void show_diff_empty(struct cache_entry *ce)
67 {
68         char *old;
69         unsigned long int size;
70         int lines=0;
71         unsigned char type[20], *p, *end;
72
73         old = read_sha1_file(ce->sha1, type, &size);
74         if (! old) {
75                 error("unable to read blob object for %s (%s)", ce->name,
76                       sha1_to_hex(ce->sha1));
77                 return;
78         }
79         if (size > 0) {
80                 int startline = 1;
81                 int c = 0;
82
83                 printf("--- %s\n", ce->name);
84                 printf("+++ /dev/null\n");
85                 p = old;
86                 end = old + size;
87                 while (p < end)
88                         if (*p++ == '\n')
89                                 lines ++;
90                 printf("@@ -1,%d +0,0 @@\n", lines);
91                 p = old;
92                 while (p < end) {
93                         c = *p++;
94                         if (startline) {
95                                 putchar('-');
96                                 startline = 0;
97                         }
98                         putchar(c);
99                         if (c == '\n')
100                                 startline = 1;
101                 }
102                 if (c!='\n')
103                         printf("\n");
104                 fflush(stdout);
105         }
106 }
107
108 static const char *show_diff_usage = "show-diff [-q] [-s] [-z] [paths...]";
109
110 static int matches_pathspec(struct cache_entry *ce, char **spec, int cnt)
111 {
112         int i;
113         int namelen = ce_namelen(ce);
114         for (i = 0; i < cnt; i++) {
115                 int speclen = strlen(spec[i]);
116                 if (! strncmp(spec[i], ce->name, speclen) &&
117                     speclen <= namelen &&
118                     (ce->name[speclen] == 0 ||
119                      ce->name[speclen] == '/'))
120                         return 1;
121         }
122         return 0;
123 }
124
125 int main(int argc, char **argv)
126 {
127         int silent = 0;
128         int silent_on_nonexisting_files = 0;
129         int machine_readable = 0;
130         int entries = read_cache();
131         int i;
132
133         while (1 < argc && argv[1][0] == '-') {
134                 if (!strcmp(argv[1], "-s"))
135                         silent_on_nonexisting_files = silent = 1;
136                 else if (!strcmp(argv[1], "-q"))
137                         silent_on_nonexisting_files = 1;
138                 else if (!strcmp(argv[1], "-z"))
139                         machine_readable = 1;
140                 else
141                         usage(show_diff_usage);
142                 argv++; argc--;
143         }
144
145         /* At this point, if argc == 1, then we are doing everything.
146          * Otherwise argv[1] .. argv[argc-1] have the explicit paths.
147          */
148         if (entries < 0) {
149                 perror("read_cache");
150                 exit(1);
151         }
152         for (i = 0; i < entries; i++) {
153                 struct stat st;
154                 struct cache_entry *ce = active_cache[i];
155                 int changed;
156                 unsigned long size;
157                 char type[20];
158                 void *old;
159
160                 if (1 < argc &&
161                     ! matches_pathspec(ce, argv+1, argc-1))
162                         continue;
163
164                 if (ce_stage(ce)) {
165                         if (machine_readable)
166                                 printf("U %s%c", ce->name, 0);
167                         else
168                                 printf("%s: Unmerged\n",
169                                        ce->name);
170                         while (i < entries &&
171                                !strcmp(ce->name, active_cache[i]->name))
172                                 i++;
173                         i--; /* compensate for loop control increments */
174                         continue;
175                 }
176  
177                 if (stat(ce->name, &st) < 0) {
178                         if (errno == ENOENT && silent_on_nonexisting_files)
179                                 continue;
180                         if (machine_readable)
181                                 printf("X %s%c", ce->name, 0);
182                         else {
183                                 printf("%s: %s\n", ce->name, strerror(errno));
184                                 if (errno == ENOENT)
185                                         show_diff_empty(ce);
186                         }
187                         continue;
188                 }
189                 changed = cache_match_stat(ce, &st);
190                 if (!changed)
191                         continue;
192                 if (!machine_readable)
193                         printf("%s: %s\n", ce->name, sha1_to_hex(ce->sha1));
194                 else {
195                         printf("%s %s%c", sha1_to_hex(ce->sha1), ce->name, 0);
196                         continue;
197                 }
198                 fflush(stdout);
199                 if (silent)
200                         continue;
201
202                 old = read_sha1_file(ce->sha1, type, &size);
203                 if (! old)
204                         error("unable to read blob object for %s (%s)",
205                               ce->name, sha1_to_hex(ce->sha1));
206                 else
207                         show_differences(ce->name, old, size);
208                 free(old);
209         }
210         return 0;
211 }