Merge with http://members.cox.net/junkio/git-jc.git
[git.git] / checkout-cache.c
1 /*
2  * Check-out files from the "current cache directory"
3  *
4  * Copyright (C) 2005 Linus Torvalds
5  *
6  * Careful: order of argument flags does matter. For example,
7  *
8  *      checkout-cache -a -f file.c
9  *
10  * Will first check out all files listed in the cache (but not
11  * overwrite any old ones), and then force-checkout "file.c" a
12  * second time (ie that one _will_ overwrite any old contents
13  * with the same filename).
14  *
15  * Also, just doing "checkout-cache" does nothing. You probably
16  * meant "checkout-cache -a". And if you want to force it, you
17  * want "checkout-cache -f -a".
18  *
19  * Intuitiveness is not the goal here. Repeatability is. The
20  * reason for the "no arguments means no work" thing is that
21  * from scripts you are supposed to be able to do things like
22  *
23  *      find . -name '*.h' -print0 | xargs -0 checkout-cache -f --
24  *
25  * which will force all existing *.h files to be replaced with
26  * their cached copies. If an empty command line implied "all",
27  * then this would force-refresh everything in the cache, which
28  * was not the point.
29  *
30  * Oh, and the "--" is just a good idea when you know the rest
31  * will be filenames. Just so that you wouldn't have a filename
32  * of "-a" causing problems (not possible in the above example,
33  * but get used to it in scripting!).
34  */
35 #include "cache.h"
36
37 static int force = 0, quiet = 0, not_new = 0;
38
39 static void create_directories(const char *path)
40 {
41         int len = strlen(path);
42         char *buf = xmalloc(len + 1);
43         const char *slash = path;
44
45         while ((slash = strchr(slash+1, '/')) != NULL) {
46                 len = slash - path;
47                 memcpy(buf, path, len);
48                 buf[len] = 0;
49                 mkdir(buf, 0755);
50         }
51         free(buf);
52 }
53
54 static int create_file(const char *path, unsigned int mode)
55 {
56         int fd;
57
58         mode = (mode & 0100) ? 0777 : 0666;
59         fd = open(path, O_WRONLY | O_TRUNC | O_CREAT, mode);
60         if (fd < 0) {
61                 if (errno == ENOENT) {
62                         create_directories(path);
63                         fd = open(path, O_WRONLY | O_TRUNC | O_CREAT, mode);
64                 }
65         }
66         return fd;
67 }
68
69 static int write_entry(struct cache_entry *ce, const char *path)
70 {
71         int fd;
72         void *new;
73         unsigned long size;
74         long wrote;
75         char type[20];
76         char target[1024];
77
78         new = read_sha1_file(ce->sha1, type, &size);
79         if (!new || strcmp(type, "blob")) {
80                 return error("checkout-cache: unable to read sha1 file of %s (%s)",
81                         path, sha1_to_hex(ce->sha1));
82         }
83         switch (ntohl(ce->ce_mode) & S_IFMT) {
84         case S_IFREG:
85                 fd = create_file(path, ntohl(ce->ce_mode));
86                 if (fd < 0) {
87                         free(new);
88                         return error("checkout-cache: unable to create file %s (%s)",
89                                 path, strerror(errno));
90                 }
91                 wrote = write(fd, new, size);
92                 close(fd);
93                 free(new);
94                 if (wrote != size)
95                         return error("checkout-cache: unable to write file %s", path);
96                 break;
97         case S_IFLNK:
98                 memcpy(target, new, size);
99                 target[size] = '\0';
100                 create_directories(path);
101                 if (symlink(target, path)) {
102                         free(new);
103                         return error("checkout-cache: unable to create symlink %s (%s)",
104                                 path, strerror(errno));
105                 }
106                 free(new);
107                 break;
108         default:
109                 free(new);
110                 return error("checkout-cache: unknown file mode for %s", path);
111         }
112         return 0;
113 }
114
115 static int checkout_entry(struct cache_entry *ce, const char *base_dir)
116 {
117         struct stat st;
118         static char path[MAXPATHLEN+1];
119         int len = strlen(base_dir);
120
121         memcpy(path, base_dir, len);
122         strcpy(path + len, ce->name);
123
124         if (!lstat(path, &st)) {
125                 unsigned changed = cache_match_stat(ce, &st);
126                 if (!changed)
127                         return 0;
128                 if (!force) {
129                         if (!quiet)
130                                 fprintf(stderr, "checkout-cache: %s already exists\n", path);
131                         return 0;
132                 }
133
134                 /*
135                  * We unlink the old file, to get the new one with the
136                  * right permissions (including umask, which is nasty
137                  * to emulate by hand - much easier to let the system
138                  * just do the right thing)
139                  */
140                 unlink(path);
141         } else if (not_new) 
142                 return 0;
143         return write_entry(ce, path);
144 }
145
146 static int checkout_file(const char *name, const char *base_dir)
147 {
148         int pos = cache_name_pos(name, strlen(name));
149         if (pos < 0) {
150                 if (!quiet) {
151                         pos = -pos - 1;
152                         fprintf(stderr,
153                                 "checkout-cache: %s is %s.\n",
154                                 name,
155                                 (pos < active_nr &&
156                                  !strcmp(active_cache[pos]->name, name)) ?
157                                 "unmerged" : "not in the cache");
158                 }
159                 return -1;
160         }
161         return checkout_entry(active_cache[pos], base_dir);
162 }
163
164 static int checkout_all(const char *base_dir)
165 {
166         int i;
167
168         for (i = 0; i < active_nr ; i++) {
169                 struct cache_entry *ce = active_cache[i];
170                 if (ce_stage(ce))
171                         continue;
172                 if (checkout_entry(ce, base_dir) < 0)
173                         return -1;
174         }
175         return 0;
176 }
177
178 int main(int argc, char **argv)
179 {
180         int i, force_filename = 0;
181         const char *base_dir = "";
182
183         if (read_cache() < 0) {
184                 die("invalid cache");
185         }
186
187         for (i = 1; i < argc; i++) {
188                 const char *arg = argv[i];
189                 if (!force_filename) {
190                         if (!strcmp(arg, "-a")) {
191                                 checkout_all(base_dir);
192                                 continue;
193                         }
194                         if (!strcmp(arg, "--")) {
195                                 force_filename = 1;
196                                 continue;
197                         }
198                         if (!strcmp(arg, "-f")) {
199                                 force = 1;
200                                 continue;
201                         }
202                         if (!strcmp(arg, "-q")) {
203                                 quiet = 1;
204                                 continue;
205                         }
206                         if (!strcmp(arg, "-n")) {
207                                 not_new = 1;
208                                 continue;
209                         }
210                         if (!memcmp(arg, "--prefix=", 9)) {
211                                 base_dir = arg+9;
212                                 continue;
213                         }
214                 }
215                 checkout_file(arg, base_dir);
216         }
217         return 0;
218 }