7 static void create_directories(const char *path
, int path_len
,
8 const struct checkout
*state
)
10 char *buf
= xmallocz(path_len
);
13 while (len
< path_len
) {
17 } while (len
< path_len
&& path
[len
] != '/');
23 * For 'checkout-index --prefix=<dir>', <dir> is
24 * allowed to be a symlink to an existing directory,
25 * and we set 'state->base_dir_len' below, such that
26 * we test the path components of the prefix with the
27 * stat() function instead of the lstat() function.
29 if (has_dirs_only_path(buf
, len
, state
->base_dir_len
))
30 continue; /* ok, it is already a directory. */
33 * If this mkdir() would fail, it could be that there
34 * is already a symlink or something else exists
35 * there, therefore we then try to unlink it and try
36 * one more time to create the directory.
38 if (mkdir(buf
, 0777)) {
39 if (errno
== EEXIST
&& state
->force
&&
40 !unlink_or_warn(buf
) && !mkdir(buf
, 0777))
42 die_errno("cannot create directory at '%s'", buf
);
48 static void remove_subtree(struct strbuf
*path
)
50 DIR *dir
= opendir(path
->buf
);
52 int origlen
= path
->len
;
55 die_errno("cannot opendir '%s'", path
->buf
);
56 while ((de
= readdir(dir
)) != NULL
) {
59 if (is_dot_or_dotdot(de
->d_name
))
62 strbuf_addch(path
, '/');
63 strbuf_addstr(path
, de
->d_name
);
64 if (lstat(path
->buf
, &st
))
65 die_errno("cannot lstat '%s'", path
->buf
);
66 if (S_ISDIR(st
.st_mode
))
68 else if (unlink(path
->buf
))
69 die_errno("cannot unlink '%s'", path
->buf
);
70 strbuf_setlen(path
, origlen
);
74 die_errno("cannot rmdir '%s'", path
->buf
);
77 static int create_file(const char *path
, unsigned int mode
)
79 mode
= (mode
& 0100) ? 0777 : 0666;
80 return open(path
, O_WRONLY
| O_CREAT
| O_EXCL
, mode
);
83 static void *read_blob_entry(const struct cache_entry
*ce
, unsigned long *size
)
85 enum object_type type
;
86 void *new = read_sha1_file(ce
->oid
.hash
, &type
, size
);
96 static int open_output_fd(char *path
, const struct cache_entry
*ce
, int to_tempfile
)
98 int symlink
= (ce
->ce_mode
& S_IFMT
) != S_IFREG
;
100 xsnprintf(path
, TEMPORARY_FILENAME_LENGTH
, "%s",
101 symlink
? ".merge_link_XXXXXX" : ".merge_file_XXXXXX");
102 return mkstemp(path
);
104 return create_file(path
, !symlink
? ce
->ce_mode
: 0666);
108 static int fstat_output(int fd
, const struct checkout
*state
, struct stat
*st
)
110 /* use fstat() only when path == ce->name */
111 if (fstat_is_reliable() &&
112 state
->refresh_cache
&& !state
->base_dir_len
) {
119 static int streaming_write_entry(const struct cache_entry
*ce
, char *path
,
120 struct stream_filter
*filter
,
121 const struct checkout
*state
, int to_tempfile
,
122 int *fstat_done
, struct stat
*statbuf
)
127 fd
= open_output_fd(path
, ce
, to_tempfile
);
131 result
|= stream_blob_to_fd(fd
, &ce
->oid
, filter
, 1);
132 *fstat_done
= fstat_output(fd
, state
, statbuf
);
140 void enable_delayed_checkout(struct checkout
*state
)
142 if (!state
->delayed_checkout
) {
143 state
->delayed_checkout
= xmalloc(sizeof(*state
->delayed_checkout
));
144 state
->delayed_checkout
->state
= CE_CAN_DELAY
;
145 string_list_init(&state
->delayed_checkout
->filters
, 0);
146 string_list_init(&state
->delayed_checkout
->paths
, 0);
150 static int remove_available_paths(struct string_list_item
*item
, void *cb_data
)
152 struct string_list
*available_paths
= cb_data
;
153 struct string_list_item
*available
;
155 available
= string_list_lookup(available_paths
, item
->string
);
157 available
->util
= (void *)item
->string
;
161 int finish_delayed_checkout(struct checkout
*state
)
164 struct string_list_item
*filter
, *path
;
165 struct delayed_checkout
*dco
= state
->delayed_checkout
;
167 if (!state
->delayed_checkout
)
170 dco
->state
= CE_RETRY
;
171 while (dco
->filters
.nr
> 0) {
172 for_each_string_list_item(filter
, &dco
->filters
) {
173 struct string_list available_paths
= STRING_LIST_INIT_NODUP
;
175 if (!async_query_available_blobs(filter
->string
, &available_paths
)) {
176 /* Filter reported an error */
181 if (available_paths
.nr
<= 0) {
183 * Filter responded with no entries. That means
184 * the filter is done and we can remove the
185 * filter from the list (see
186 * "string_list_remove_empty_items" call below).
193 * In dco->paths we store a list of all delayed paths.
194 * The filter just send us a list of available paths.
195 * Remove them from the list.
197 filter_string_list(&dco
->paths
, 0,
198 &remove_available_paths
, &available_paths
);
200 for_each_string_list_item(path
, &available_paths
) {
201 struct cache_entry
* ce
;
204 error("external filter '%s' signaled that '%s' "
205 "is now available although it has not been "
207 filter
->string
, path
->string
);
211 * Do not ask the filter for available blobs,
212 * again, as the filter is likely buggy.
217 ce
= index_file_exists(state
->istate
, path
->string
,
218 strlen(path
->string
), 0);
219 errs
|= (ce
? checkout_entry(ce
, state
, NULL
) : 1);
222 string_list_remove_empty_items(&dco
->filters
, 0);
224 string_list_clear(&dco
->filters
, 0);
226 /* At this point we should not have any delayed paths anymore. */
227 errs
|= dco
->paths
.nr
;
228 for_each_string_list_item(path
, &dco
->paths
) {
229 error("'%s' was not filtered properly", path
->string
);
231 string_list_clear(&dco
->paths
, 0);
234 state
->delayed_checkout
= NULL
;
239 static int write_entry(struct cache_entry
*ce
,
240 char *path
, const struct checkout
*state
, int to_tempfile
)
242 unsigned int ce_mode_s_ifmt
= ce
->ce_mode
& S_IFMT
;
243 int fd
, ret
, fstat_done
= 0;
245 struct strbuf buf
= STRBUF_INIT
;
247 size_t wrote
, newsize
= 0;
249 const struct submodule
*sub
;
251 if (ce_mode_s_ifmt
== S_IFREG
) {
252 struct stream_filter
*filter
= get_stream_filter(ce
->name
,
255 !streaming_write_entry(ce
, path
, filter
,
261 switch (ce_mode_s_ifmt
) {
264 new = read_blob_entry(ce
, &size
);
266 return error("unable to read sha1 file of %s (%s)",
267 path
, oid_to_hex(&ce
->oid
));
269 if (ce_mode_s_ifmt
== S_IFLNK
&& has_symlinks
&& !to_tempfile
) {
270 ret
= symlink(new, path
);
273 return error_errno("unable to create symlink %s",
279 * Convert from git internal format to working tree format
281 if (ce_mode_s_ifmt
== S_IFREG
) {
282 struct delayed_checkout
*dco
= state
->delayed_checkout
;
283 if (dco
&& dco
->state
!= CE_NO_DELAY
) {
284 /* Do not send the blob in case of a retry. */
285 if (dco
->state
== CE_RETRY
) {
289 ret
= async_convert_to_working_tree(
290 ce
->name
, new, size
, &buf
, dco
);
291 if (ret
&& string_list_has_string(&dco
->paths
, ce
->name
)) {
296 ret
= convert_to_working_tree(
297 ce
->name
, new, size
, &buf
);
301 new = strbuf_detach(&buf
, &newsize
);
305 * No "else" here as errors from convert are OK at this
306 * point. If the error would have been fatal (e.g.
307 * filter is required), then we would have died already.
311 fd
= open_output_fd(path
, ce
, to_tempfile
);
314 return error_errno("unable to create file %s", path
);
317 wrote
= write_in_full(fd
, new, size
);
319 fstat_done
= fstat_output(fd
, state
, &st
);
323 return error("unable to write file %s", path
);
327 return error("cannot create temporary submodule %s", path
);
328 if (mkdir(path
, 0777) < 0)
329 return error("cannot create submodule directory %s", path
);
330 sub
= submodule_from_ce(ce
);
332 return submodule_move_head(ce
->name
,
333 NULL
, oid_to_hex(&ce
->oid
),
334 state
->force
? SUBMODULE_MOVE_HEAD_FORCE
: 0);
337 return error("unknown file mode for %s in index", path
);
341 if (state
->refresh_cache
) {
342 assert(state
->istate
);
344 lstat(ce
->name
, &st
);
345 fill_stat_cache_info(ce
, &st
);
346 ce
->ce_flags
|= CE_UPDATE_IN_BASE
;
347 state
->istate
->cache_changed
|= CE_ENTRY_CHANGED
;
353 * This is like 'lstat()', except it refuses to follow symlinks
354 * in the path, after skipping "skiplen".
356 static int check_path(const char *path
, int len
, struct stat
*st
, int skiplen
)
358 const char *slash
= path
+ len
;
360 while (path
< slash
&& *slash
!= '/')
362 if (!has_dirs_only_path(path
, slash
- path
, skiplen
)) {
366 return lstat(path
, st
);
370 * Write the contents from ce out to the working tree.
372 * When topath[] is not NULL, instead of writing to the working tree
373 * file named by ce, a temporary file is created by this function and
374 * its name is returned in topath[], which must be able to hold at
375 * least TEMPORARY_FILENAME_LENGTH bytes long.
377 int checkout_entry(struct cache_entry
*ce
,
378 const struct checkout
*state
, char *topath
)
380 static struct strbuf path
= STRBUF_INIT
;
384 return write_entry(ce
, topath
, state
, 1);
387 strbuf_add(&path
, state
->base_dir
, state
->base_dir_len
);
388 strbuf_add(&path
, ce
->name
, ce_namelen(ce
));
390 if (!check_path(path
.buf
, path
.len
, &st
, state
->base_dir_len
)) {
391 const struct submodule
*sub
;
392 unsigned changed
= ce_match_stat(ce
, &st
, CE_MATCH_IGNORE_VALID
|CE_MATCH_IGNORE_SKIP_WORKTREE
);
394 * Needs to be checked before !changed returns early,
395 * as the possibly empty directory was not changed
397 sub
= submodule_from_ce(ce
);
400 if (!is_submodule_populated_gently(ce
->name
, &err
)) {
402 if (lstat(ce
->name
, &sb
))
403 die(_("could not stat file '%s'"), ce
->name
);
404 if (!(st
.st_mode
& S_IFDIR
))
405 unlink_or_warn(ce
->name
);
407 return submodule_move_head(ce
->name
,
408 NULL
, oid_to_hex(&ce
->oid
), 0);
410 return submodule_move_head(ce
->name
,
411 "HEAD", oid_to_hex(&ce
->oid
),
412 state
->force
? SUBMODULE_MOVE_HEAD_FORCE
: 0);
420 "%s already exists, no checkout\n",
426 * We unlink the old file, to get the new one with the
427 * right permissions (including umask, which is nasty
428 * to emulate by hand - much easier to let the system
429 * just do the right thing)
431 if (S_ISDIR(st
.st_mode
)) {
432 /* If it is a gitlink, leave it alone! */
433 if (S_ISGITLINK(ce
->ce_mode
))
436 return error("%s is a directory", path
.buf
);
437 remove_subtree(&path
);
438 } else if (unlink(path
.buf
))
439 return error_errno("unable to unlink old '%s'", path
.buf
);
440 } else if (state
->not_new
)
443 create_directories(path
.buf
, path
.len
, state
);
444 return write_entry(ce
, path
.buf
, state
, 0);