[PATCH] rsh.c env and quoting cleanup, take 2
[git.git] / update-index.c
1 /*
2  * GIT - The information manager from hell
3  *
4  * Copyright (C) Linus Torvalds, 2005
5  */
6 #include "cache.h"
7
8 /*
9  * Default to not allowing changes to the list of files. The
10  * tool doesn't actually care, but this makes it harder to add
11  * files to the revision control by mistake by doing something
12  * like "git-update-index *" and suddenly having all the object
13  * files be revision controlled.
14  */
15 static int allow_add = 0, allow_remove = 0, allow_replace = 0, not_new = 0, quiet = 0, info_only = 0;
16 static int force_remove;
17
18 /* Three functions to allow overloaded pointer return; see linux/err.h */
19 static inline void *ERR_PTR(long error)
20 {
21         return (void *) error;
22 }
23
24 static inline long PTR_ERR(const void *ptr)
25 {
26         return (long) ptr;
27 }
28
29 static inline long IS_ERR(const void *ptr)
30 {
31         return (unsigned long)ptr > (unsigned long)-1000L;
32 }
33
34 static int add_file_to_cache(char *path)
35 {
36         int size, namelen, option, status;
37         struct cache_entry *ce;
38         struct stat st;
39         int fd;
40         char *target;
41
42         status = lstat(path, &st);
43         if (status < 0 || S_ISDIR(st.st_mode)) {
44                 /* When we used to have "path" and now we want to add
45                  * "path/file", we need a way to remove "path" before
46                  * being able to add "path/file".  However,
47                  * "git-update-index --remove path" would not work.
48                  * --force-remove can be used but this is more user
49                  * friendly, especially since we can do the opposite
50                  * case just fine without --force-remove.
51                  */
52                 if (status == 0 || (errno == ENOENT || errno == ENOTDIR)) {
53                         if (allow_remove)
54                                 return remove_file_from_cache(path);
55                 }
56                 if (0 == status)
57                         return error("%s: is a directory", path);
58                 else
59                         return error("lstat(\"%s\"): %s", path,
60                                      strerror(errno));
61         }
62         namelen = strlen(path);
63         size = cache_entry_size(namelen);
64         ce = xmalloc(size);
65         memset(ce, 0, size);
66         memcpy(ce->name, path, namelen);
67         fill_stat_cache_info(ce, &st);
68         ce->ce_mode = create_ce_mode(st.st_mode);
69         ce->ce_flags = htons(namelen);
70         switch (st.st_mode & S_IFMT) {
71         case S_IFREG:
72                 fd = open(path, O_RDONLY);
73                 if (fd < 0)
74                         return -1;
75                 if (index_fd(ce->sha1, fd, &st, !info_only, NULL) < 0)
76                         return -1;
77                 break;
78         case S_IFLNK:
79                 target = xmalloc(st.st_size+1);
80                 if (readlink(path, target, st.st_size+1) != st.st_size) {
81                         free(target);
82                         return -1;
83                 }
84                 if (info_only) {
85                         unsigned char hdr[50];
86                         int hdrlen;
87                         write_sha1_file_prepare(target, st.st_size, "blob",
88                                                 ce->sha1, hdr, &hdrlen);
89                 } else if (write_sha1_file(target, st.st_size, "blob", ce->sha1))
90                         return -1;
91                 free(target);
92                 break;
93         default:
94                 return -1;
95         }
96         option = allow_add ? ADD_CACHE_OK_TO_ADD : 0;
97         option |= allow_replace ? ADD_CACHE_OK_TO_REPLACE : 0;
98         return add_cache_entry(ce, option);
99 }
100
101 static int compare_data(struct cache_entry *ce, struct stat *st)
102 {
103         int match = -1;
104         int fd = open(ce->name, O_RDONLY);
105
106         if (fd >= 0) {
107                 unsigned char sha1[20];
108                 if (!index_fd(sha1, fd, st, 0, NULL))
109                         match = memcmp(sha1, ce->sha1, 20);
110                 close(fd);
111         }
112         return match;
113 }
114
115 static int compare_link(struct cache_entry *ce, unsigned long expected_size)
116 {
117         int match = -1;
118         char *target;
119         void *buffer;
120         unsigned long size;
121         char type[10];
122         int len;
123
124         target = xmalloc(expected_size);
125         len = readlink(ce->name, target, expected_size);
126         if (len != expected_size) {
127                 free(target);
128                 return -1;
129         }
130         buffer = read_sha1_file(ce->sha1, type, &size);
131         if (!buffer) {
132                 free(target);
133                 return -1;
134         }
135         if (size == expected_size)
136                 match = memcmp(buffer, target, size);
137         free(buffer);
138         free(target);
139         return match;
140 }
141
142 /*
143  * "refresh" does not calculate a new sha1 file or bring the
144  * cache up-to-date for mode/content changes. But what it
145  * _does_ do is to "re-match" the stat information of a file
146  * with the cache, so that you can refresh the cache for a
147  * file that hasn't been changed but where the stat entry is
148  * out of date.
149  *
150  * For example, you'd want to do this after doing a "git-read-tree",
151  * to link up the stat cache details with the proper files.
152  */
153 static struct cache_entry *refresh_entry(struct cache_entry *ce)
154 {
155         struct stat st;
156         struct cache_entry *updated;
157         int changed, size;
158
159         if (lstat(ce->name, &st) < 0)
160                 return ERR_PTR(-errno);
161
162         changed = ce_match_stat(ce, &st);
163         if (!changed)
164                 return ce;
165
166         /*
167          * If the mode or type has changed, there's no point in trying
168          * to refresh the entry - it's not going to match
169          */
170         if (changed & (MODE_CHANGED | TYPE_CHANGED))
171                 return ERR_PTR(-EINVAL);
172
173         switch (st.st_mode & S_IFMT) {
174         case S_IFREG:
175                 if (compare_data(ce, &st))
176                         return ERR_PTR(-EINVAL);
177                 break;
178         case S_IFLNK:
179                 if (compare_link(ce, st.st_size))
180                         return ERR_PTR(-EINVAL);
181                 break;
182         default:
183                 return ERR_PTR(-EINVAL);
184         }
185
186         size = ce_size(ce);
187         updated = xmalloc(size);
188         memcpy(updated, ce, size);
189         fill_stat_cache_info(updated, &st);
190         return updated;
191 }
192
193 static int refresh_cache(void)
194 {
195         int i;
196         int has_errors = 0;
197
198         for (i = 0; i < active_nr; i++) {
199                 struct cache_entry *ce, *new;
200                 ce = active_cache[i];
201                 if (ce_stage(ce)) {
202                         printf("%s: needs merge\n", ce->name);
203                         has_errors = 1;
204                         while ((i < active_nr) &&
205                                ! strcmp(active_cache[i]->name, ce->name))
206                                 i++;
207                         i--;
208                         continue;
209                 }
210
211                 new = refresh_entry(ce);
212                 if (IS_ERR(new)) {
213                         if (not_new && PTR_ERR(new) == -ENOENT)
214                                 continue;
215                         if (quiet)
216                                 continue;
217                         printf("%s: needs update\n", ce->name);
218                         has_errors = 1;
219                         continue;
220                 }
221                 active_cache_changed = 1;
222                 /* You can NOT just free active_cache[i] here, since it
223                  * might not be necessarily malloc()ed but can also come
224                  * from mmap(). */
225                 active_cache[i] = new;
226         }
227         return has_errors;
228 }
229
230 /*
231  * We fundamentally don't like some paths: we don't want
232  * dot or dot-dot anywhere, and for obvious reasons don't
233  * want to recurse into ".git" either.
234  *
235  * Also, we don't want double slashes or slashes at the
236  * end that can make pathnames ambiguous.
237  */
238 static int verify_dotfile(const char *rest)
239 {
240         /*
241          * The first character was '.', but that
242          * has already been discarded, we now test
243          * the rest.
244          */
245         switch (*rest) {
246         /* "." is not allowed */
247         case '\0': case '/':
248                 return 0;
249
250         /*
251          * ".git" followed by  NUL or slash is bad. This
252          * shares the path end test with the ".." case.
253          */
254         case 'g':
255                 if (rest[1] != 'i')
256                         break;
257                 if (rest[2] != 't')
258                         break;
259                 rest += 2;
260         /* fallthrough */
261         case '.':
262                 if (rest[1] == '\0' || rest[1] == '/')
263                         return 0;
264         }
265         return 1;
266 }
267
268 static int verify_path(char *path)
269 {
270         char c;
271
272         goto inside;
273         for (;;) {
274                 if (!c)
275                         return 1;
276                 if (c == '/') {
277 inside:
278                         c = *path++;
279                         switch (c) {
280                         default:
281                                 continue;
282                         case '/': case '\0':
283                                 break;
284                         case '.':
285                                 if (verify_dotfile(path))
286                                         continue;
287                         }
288                         return 0;
289                 }
290                 c = *path++;
291         }
292 }
293
294 static int add_cacheinfo(char *arg1, char *arg2, char *arg3)
295 {
296         int size, len, option;
297         unsigned int mode;
298         unsigned char sha1[20];
299         struct cache_entry *ce;
300
301         if (sscanf(arg1, "%o", &mode) != 1)
302                 return -1;
303         if (get_sha1_hex(arg2, sha1))
304                 return -1;
305         if (!verify_path(arg3))
306                 return -1;
307
308         len = strlen(arg3);
309         size = cache_entry_size(len);
310         ce = xmalloc(size);
311         memset(ce, 0, size);
312
313         memcpy(ce->sha1, sha1, 20);
314         memcpy(ce->name, arg3, len);
315         ce->ce_flags = htons(len);
316         ce->ce_mode = create_ce_mode(mode);
317         option = allow_add ? ADD_CACHE_OK_TO_ADD : 0;
318         option |= allow_replace ? ADD_CACHE_OK_TO_REPLACE : 0;
319         return add_cache_entry(ce, option);
320 }
321
322 static struct cache_file cache_file;
323
324 int main(int argc, char **argv)
325 {
326         int i, newfd, entries, has_errors = 0;
327         int allow_options = 1;
328         const char *prefix = setup_git_directory();
329
330         newfd = hold_index_file_for_update(&cache_file, get_index_file());
331         if (newfd < 0)
332                 die("unable to create new cachefile");
333
334         entries = read_cache();
335         if (entries < 0)
336                 die("cache corrupted");
337
338         for (i = 1 ; i < argc; i++) {
339                 char *path = argv[i];
340
341                 if (allow_options && *path == '-') {
342                         if (!strcmp(path, "--")) {
343                                 allow_options = 0;
344                                 continue;
345                         }
346                         if (!strcmp(path, "-q")) {
347                                 quiet = 1;
348                                 continue;
349                         }
350                         if (!strcmp(path, "--add")) {
351                                 allow_add = 1;
352                                 continue;
353                         }
354                         if (!strcmp(path, "--replace")) {
355                                 allow_replace = 1;
356                                 continue;
357                         }
358                         if (!strcmp(path, "--remove")) {
359                                 allow_remove = 1;
360                                 continue;
361                         }
362                         if (!strcmp(path, "--refresh")) {
363                                 has_errors |= refresh_cache();
364                                 continue;
365                         }
366                         if (!strcmp(path, "--cacheinfo")) {
367                                 if (i+3 >= argc)
368                                         die("git-update-index: --cacheinfo <mode> <sha1> <path>");
369                                 if (add_cacheinfo(argv[i+1], argv[i+2], argv[i+3]))
370                                         die("git-update-index: --cacheinfo cannot add %s", argv[i+3]);
371                                 i += 3;
372                                 continue;
373                         }
374                         if (!strcmp(path, "--info-only")) {
375                                 info_only = 1;
376                                 continue;
377                         }
378                         if (!strcmp(path, "--force-remove")) {
379                                 force_remove = 1;
380                                 continue;
381                         }
382
383                         if (!strcmp(path, "--ignore-missing")) {
384                                 not_new = 1;
385                                 continue;
386                         }
387                         die("unknown option %s", path);
388                 }
389                 path = prefix_path(prefix, prefix ? strlen(prefix) : 0, path);
390                 if (!verify_path(path)) {
391                         fprintf(stderr, "Ignoring path %s\n", argv[i]);
392                         continue;
393                 }
394                 if (force_remove) {
395                         if (remove_file_from_cache(path))
396                                 die("git-update-index: --force-remove cannot remove %s", path);
397                         continue;
398                 }
399                 if (add_file_to_cache(path))
400                         die("Unable to add %s to database; maybe you want to use --add option?", path);
401         }
402         if (write_cache(newfd, active_cache, active_nr) ||
403             commit_index_file(&cache_file))
404                 die("Unable to write new cachefile");
405
406         return has_errors ? 1 : 0;
407 }