diff options
Diffstat (limited to 'entry.c')
| -rw-r--r-- | entry.c | 314 |
1 files changed, 209 insertions, 105 deletions
@@ -1,59 +1,76 @@ #include "cache.h" #include "blob.h" +#include "dir.h" +#include "streaming.h" -static void create_directories(const char *path, struct checkout *state) +static void create_directories(const char *path, int path_len, + const struct checkout *state) { - int len = strlen(path); - char *buf = xmalloc(len + 1); - const char *slash = path; + char *buf = xmalloc(path_len + 1); + int len = 0; - while ((slash = strchr(slash+1, '/')) != NULL) { - len = slash - path; - memcpy(buf, path, len); + while (len < path_len) { + do { + buf[len] = path[len]; + len++; + } while (len < path_len && path[len] != '/'); + if (len >= path_len) + break; buf[len] = 0; + + /* + * For 'checkout-index --prefix=<dir>', <dir> is + * allowed to be a symlink to an existing directory, + * and we set 'state->base_dir_len' below, such that + * we test the path components of the prefix with the + * stat() function instead of the lstat() function. + */ + if (has_dirs_only_path(buf, len, state->base_dir_len)) + continue; /* ok, it is already a directory. */ + + /* + * If this mkdir() would fail, it could be that there + * is already a symlink or something else exists + * there, therefore we then try to unlink it and try + * one more time to create the directory. + */ if (mkdir(buf, 0777)) { - if (errno == EEXIST) { - struct stat st; - if (len > state->base_dir_len && state->force && !unlink(buf) && !mkdir(buf, 0777)) - continue; - if (!stat(buf, &st) && S_ISDIR(st.st_mode)) - continue; /* ok */ - } - die("cannot create directory at %s", buf); + if (errno == EEXIST && state->force && + !unlink_or_warn(buf) && !mkdir(buf, 0777)) + continue; + die_errno("cannot create directory at '%s'", buf); } } free(buf); } -static void remove_subtree(const char *path) +static void remove_subtree(struct strbuf *path) { - DIR *dir = opendir(path); + DIR *dir = opendir(path->buf); struct dirent *de; - char pathbuf[PATH_MAX]; - char *name; - + int origlen = path->len; + if (!dir) - die("cannot opendir %s", path); - strcpy(pathbuf, path); - name = pathbuf + strlen(path); - *name++ = '/'; + die_errno("cannot opendir '%s'", path->buf); while ((de = readdir(dir)) != NULL) { struct stat st; - if ((de->d_name[0] == '.') && - ((de->d_name[1] == 0) || - ((de->d_name[1] == '.') && de->d_name[2] == 0))) + + if (is_dot_or_dotdot(de->d_name)) continue; - strcpy(name, de->d_name); - if (lstat(pathbuf, &st)) - die("cannot lstat %s", pathbuf); + + strbuf_addch(path, '/'); + strbuf_addstr(path, de->d_name); + if (lstat(path->buf, &st)) + die_errno("cannot lstat '%s'", path->buf); if (S_ISDIR(st.st_mode)) - remove_subtree(pathbuf); - else if (unlink(pathbuf)) - die("cannot unlink %s", pathbuf); + remove_subtree(path); + else if (unlink(path->buf)) + die_errno("cannot unlink '%s'", path->buf); + strbuf_setlen(path, origlen); } closedir(dir); - if (rmdir(path)) - die("cannot rmdir %s", path); + if (rmdir(path->buf)) + die_errno("cannot rmdir '%s'", path->buf); } static int create_file(const char *path, unsigned int mode) @@ -62,112 +79,194 @@ static int create_file(const char *path, unsigned int mode) return open(path, O_WRONLY | O_CREAT | O_EXCL, mode); } -static int write_entry(struct cache_entry *ce, char *path, struct checkout *state, int to_tempfile) +static void *read_blob_entry(const struct cache_entry *ce, unsigned long *size) +{ + enum object_type type; + void *new = read_sha1_file(ce->sha1, &type, size); + + if (new) { + if (type == OBJ_BLOB) + return new; + free(new); + } + return NULL; +} + +static int open_output_fd(char *path, const struct cache_entry *ce, int to_tempfile) +{ + int symlink = (ce->ce_mode & S_IFMT) != S_IFREG; + if (to_tempfile) { + strcpy(path, symlink + ? ".merge_link_XXXXXX" : ".merge_file_XXXXXX"); + return mkstemp(path); + } else { + return create_file(path, !symlink ? ce->ce_mode : 0666); + } +} + +static int fstat_output(int fd, const struct checkout *state, struct stat *st) { + /* use fstat() only when path == ce->name */ + if (fstat_is_reliable() && + state->refresh_cache && !state->base_dir_len) { + fstat(fd, st); + return 1; + } + return 0; +} + +static int streaming_write_entry(const struct cache_entry *ce, char *path, + struct stream_filter *filter, + const struct checkout *state, int to_tempfile, + int *fstat_done, struct stat *statbuf) +{ + int result = 0; int fd; - void *new; + + fd = open_output_fd(path, ce, to_tempfile); + if (fd < 0) + return -1; + + result |= stream_blob_to_fd(fd, ce->sha1, filter, 1); + *fstat_done = fstat_output(fd, state, statbuf); + result |= close(fd); + + if (result) + unlink(path); + return result; +} + +static int write_entry(struct cache_entry *ce, + char *path, const struct checkout *state, int to_tempfile) +{ + unsigned int ce_mode_s_ifmt = ce->ce_mode & S_IFMT; + int fd, ret, fstat_done = 0; + char *new; + struct strbuf buf = STRBUF_INIT; unsigned long size; - long wrote; - enum object_type type; + size_t wrote, newsize = 0; + struct stat st; - new = read_sha1_file(ce->sha1, &type, &size); - if (!new || type != OBJ_BLOB) { - if (new) - free(new); - return error("git-checkout-index: unable to read sha1 file of %s (%s)", - path, sha1_to_hex(ce->sha1)); + if (ce_mode_s_ifmt == S_IFREG) { + struct stream_filter *filter = get_stream_filter(ce->name, ce->sha1); + if (filter && + !streaming_write_entry(ce, path, filter, + state, to_tempfile, + &fstat_done, &st)) + goto finish; } - switch (ntohl(ce->ce_mode) & S_IFMT) { - char *buf; - unsigned long nsize; + switch (ce_mode_s_ifmt) { case S_IFREG: - if (to_tempfile) { - strcpy(path, ".merge_file_XXXXXX"); - fd = mkstemp(path); - } else - fd = create_file(path, ntohl(ce->ce_mode)); - if (fd < 0) { + case S_IFLNK: + new = read_blob_entry(ce, &size); + if (!new) + return error("unable to read sha1 file of %s (%s)", + path, sha1_to_hex(ce->sha1)); + + if (ce_mode_s_ifmt == S_IFLNK && has_symlinks && !to_tempfile) { + ret = symlink(new, path); free(new); - return error("git-checkout-index: unable to create file %s (%s)", - path, strerror(errno)); + if (ret) + return error("unable to create symlink %s (%s)", + path, strerror(errno)); + break; } /* * Convert from git internal format to working tree format */ - buf = new; - nsize = size; - if (convert_to_working_tree(ce->name, &buf, &nsize)) { + if (ce_mode_s_ifmt == S_IFREG && + convert_to_working_tree(ce->name, new, size, &buf)) { free(new); - new = buf; - size = nsize; + new = strbuf_detach(&buf, &newsize); + size = newsize; + } + + fd = open_output_fd(path, ce, to_tempfile); + if (fd < 0) { + free(new); + return error("unable to create file %s (%s)", + path, strerror(errno)); } wrote = write_in_full(fd, new, size); + if (!to_tempfile) + fstat_done = fstat_output(fd, state, &st); close(fd); free(new); if (wrote != size) - return error("git-checkout-index: unable to write file %s", path); + return error("unable to write file %s", path); break; - case S_IFLNK: - if (to_tempfile || !has_symlinks) { - if (to_tempfile) { - strcpy(path, ".merge_link_XXXXXX"); - fd = mkstemp(path); - } else - fd = create_file(path, 0666); - if (fd < 0) { - free(new); - return error("git-checkout-index: unable to create " - "file %s (%s)", path, strerror(errno)); - } - wrote = write_in_full(fd, new, size); - close(fd); - free(new); - if (wrote != size) - return error("git-checkout-index: unable to write file %s", - path); - } else { - wrote = symlink(new, path); - free(new); - if (wrote) - return error("git-checkout-index: unable to create " - "symlink %s (%s)", path, strerror(errno)); - } + case S_IFGITLINK: + if (to_tempfile) + return error("cannot create temporary submodule %s", path); + if (mkdir(path, 0777) < 0) + return error("cannot create submodule directory %s", path); break; default: - free(new); - return error("git-checkout-index: unknown file mode for %s", path); + return error("unknown file mode for %s in index", path); } +finish: if (state->refresh_cache) { - struct stat st; - lstat(ce->name, &st); + assert(state->istate); + if (!fstat_done) + lstat(ce->name, &st); fill_stat_cache_info(ce, &st); + ce->ce_flags |= CE_UPDATE_IN_BASE; + state->istate->cache_changed |= CE_ENTRY_CHANGED; } return 0; } -int checkout_entry(struct cache_entry *ce, struct checkout *state, char *topath) +/* + * This is like 'lstat()', except it refuses to follow symlinks + * in the path, after skipping "skiplen". + */ +static int check_path(const char *path, int len, struct stat *st, int skiplen) { - static char path[PATH_MAX + 1]; + const char *slash = path + len; + + while (path < slash && *slash != '/') + slash--; + if (!has_dirs_only_path(path, slash - path, skiplen)) { + errno = ENOENT; + return -1; + } + return lstat(path, st); +} + +/* + * Write the contents from ce out to the working tree. + * + * When topath[] is not NULL, instead of writing to the working tree + * file named by ce, a temporary file is created by this function and + * its name is returned in topath[], which must be able to hold at + * least TEMPORARY_FILENAME_LENGTH bytes long. + */ +int checkout_entry(struct cache_entry *ce, + const struct checkout *state, char *topath) +{ + static struct strbuf path = STRBUF_INIT; struct stat st; - int len = state->base_dir_len; if (topath) return write_entry(ce, topath, state, 1); - memcpy(path, state->base_dir, len); - strcpy(path + len, ce->name); + strbuf_reset(&path); + strbuf_add(&path, state->base_dir, state->base_dir_len); + strbuf_add(&path, ce->name, ce_namelen(ce)); - if (!lstat(path, &st)) { - unsigned changed = ce_match_stat(ce, &st, 1); + if (!check_path(path.buf, path.len, &st, state->base_dir_len)) { + unsigned changed = ce_match_stat(ce, &st, CE_MATCH_IGNORE_VALID|CE_MATCH_IGNORE_SKIP_WORKTREE); if (!changed) return 0; if (!state->force) { if (!state->quiet) - fprintf(stderr, "git-checkout-index: %s already exists\n", path); + fprintf(stderr, + "%s already exists, no checkout\n", + path.buf); return -1; } @@ -177,14 +276,19 @@ int checkout_entry(struct cache_entry *ce, struct checkout *state, char *topath) * to emulate by hand - much easier to let the system * just do the right thing) */ - unlink(path); if (S_ISDIR(st.st_mode)) { + /* If it is a gitlink, leave it alone! */ + if (S_ISGITLINK(ce->ce_mode)) + return 0; if (!state->force) - return error("%s is a directory", path); - remove_subtree(path); - } + return error("%s is a directory", path.buf); + remove_subtree(&path); + } else if (unlink(path.buf)) + return error("unable to unlink old '%s' (%s)", + path.buf, strerror(errno)); } else if (state->not_new) return 0; - create_directories(path, state); - return write_entry(ce, path, state, 0); + + create_directories(path.buf, path.len, state); + return write_entry(ce, path.buf, state, 0); } |