Linus Torvalds | 12dccc1 | 2005-06-05 21:59:54 -0700 | [diff] [blame] | 1 | #include "cache.h" |
Peter Eriksen | 8e44025 | 2006-04-02 14:44:09 +0200 | [diff] [blame] | 2 | #include "blob.h" |
Alexander Potashev | 8ca12c0 | 2009-01-10 15:07:50 +0300 | [diff] [blame] | 3 | #include "dir.h" |
Junio C Hamano | dd8e912 | 2011-05-12 14:31:08 -0700 | [diff] [blame] | 4 | #include "streaming.h" |
Linus Torvalds | 12dccc1 | 2005-06-05 21:59:54 -0700 | [diff] [blame] | 5 | |
Kjetil Barvik | 81a9aa6 | 2009-02-09 21:54:08 +0100 | [diff] [blame] | 6 | static void create_directories(const char *path, int path_len, |
| 7 | const struct checkout *state) |
Linus Torvalds | 12dccc1 | 2005-06-05 21:59:54 -0700 | [diff] [blame] | 8 | { |
Kjetil Barvik | 81a9aa6 | 2009-02-09 21:54:08 +0100 | [diff] [blame] | 9 | char *buf = xmalloc(path_len + 1); |
| 10 | int len = 0; |
Linus Torvalds | 12dccc1 | 2005-06-05 21:59:54 -0700 | [diff] [blame] | 11 | |
Kjetil Barvik | 81a9aa6 | 2009-02-09 21:54:08 +0100 | [diff] [blame] | 12 | while (len < path_len) { |
| 13 | do { |
| 14 | buf[len] = path[len]; |
| 15 | len++; |
| 16 | } while (len < path_len && path[len] != '/'); |
| 17 | if (len >= path_len) |
| 18 | break; |
Linus Torvalds | 12dccc1 | 2005-06-05 21:59:54 -0700 | [diff] [blame] | 19 | buf[len] = 0; |
Junio C Hamano | fa2e71c | 2007-07-17 22:58:28 -0700 | [diff] [blame] | 20 | |
Kjetil Barvik | bad4a54 | 2009-01-18 16:14:52 +0100 | [diff] [blame] | 21 | /* |
| 22 | * For 'checkout-index --prefix=<dir>', <dir> is |
| 23 | * allowed to be a symlink to an existing directory, |
| 24 | * and we set 'state->base_dir_len' below, such that |
| 25 | * we test the path components of the prefix with the |
| 26 | * stat() function instead of the lstat() function. |
| 27 | */ |
Kjetil Barvik | 5719989 | 2009-02-09 21:54:06 +0100 | [diff] [blame] | 28 | if (has_dirs_only_path(buf, len, state->base_dir_len)) |
Junio C Hamano | fa2e71c | 2007-07-17 22:58:28 -0700 | [diff] [blame] | 29 | continue; /* ok, it is already a directory. */ |
| 30 | |
| 31 | /* |
Kjetil Barvik | bad4a54 | 2009-01-18 16:14:52 +0100 | [diff] [blame] | 32 | * If this mkdir() would fail, it could be that there |
| 33 | * is already a symlink or something else exists |
| 34 | * there, therefore we then try to unlink it and try |
| 35 | * one more time to create the directory. |
Junio C Hamano | fa2e71c | 2007-07-17 22:58:28 -0700 | [diff] [blame] | 36 | */ |
Junio C Hamano | f312de0 | 2005-07-06 01:21:46 -0700 | [diff] [blame] | 37 | if (mkdir(buf, 0777)) { |
Junio C Hamano | fa2e71c | 2007-07-17 22:58:28 -0700 | [diff] [blame] | 38 | if (errno == EEXIST && state->force && |
Alex Riesen | 691f1a2 | 2009-04-29 23:22:56 +0200 | [diff] [blame] | 39 | !unlink_or_warn(buf) && !mkdir(buf, 0777)) |
Junio C Hamano | fa2e71c | 2007-07-17 22:58:28 -0700 | [diff] [blame] | 40 | continue; |
Thomas Rast | 0721c31 | 2009-06-27 17:58:47 +0200 | [diff] [blame] | 41 | die_errno("cannot create directory at '%s'", buf); |
Linus Torvalds | 12dccc1 | 2005-06-05 21:59:54 -0700 | [diff] [blame] | 42 | } |
| 43 | } |
| 44 | free(buf); |
| 45 | } |
| 46 | |
| 47 | static void remove_subtree(const char *path) |
| 48 | { |
| 49 | DIR *dir = opendir(path); |
| 50 | struct dirent *de; |
| 51 | char pathbuf[PATH_MAX]; |
| 52 | char *name; |
Junio C Hamano | a6080a0 | 2007-06-07 00:04:01 -0700 | [diff] [blame] | 53 | |
Linus Torvalds | 12dccc1 | 2005-06-05 21:59:54 -0700 | [diff] [blame] | 54 | if (!dir) |
Thomas Rast | d824cbb | 2009-06-27 17:58:46 +0200 | [diff] [blame] | 55 | die_errno("cannot opendir '%s'", path); |
Linus Torvalds | 12dccc1 | 2005-06-05 21:59:54 -0700 | [diff] [blame] | 56 | strcpy(pathbuf, path); |
| 57 | name = pathbuf + strlen(path); |
| 58 | *name++ = '/'; |
| 59 | while ((de = readdir(dir)) != NULL) { |
| 60 | struct stat st; |
Alexander Potashev | 8ca12c0 | 2009-01-10 15:07:50 +0300 | [diff] [blame] | 61 | if (is_dot_or_dotdot(de->d_name)) |
Linus Torvalds | 12dccc1 | 2005-06-05 21:59:54 -0700 | [diff] [blame] | 62 | continue; |
| 63 | strcpy(name, de->d_name); |
| 64 | if (lstat(pathbuf, &st)) |
Thomas Rast | d824cbb | 2009-06-27 17:58:46 +0200 | [diff] [blame] | 65 | die_errno("cannot lstat '%s'", pathbuf); |
Linus Torvalds | 12dccc1 | 2005-06-05 21:59:54 -0700 | [diff] [blame] | 66 | if (S_ISDIR(st.st_mode)) |
| 67 | remove_subtree(pathbuf); |
| 68 | else if (unlink(pathbuf)) |
Thomas Rast | d824cbb | 2009-06-27 17:58:46 +0200 | [diff] [blame] | 69 | die_errno("cannot unlink '%s'", pathbuf); |
Linus Torvalds | 12dccc1 | 2005-06-05 21:59:54 -0700 | [diff] [blame] | 70 | } |
| 71 | closedir(dir); |
| 72 | if (rmdir(path)) |
Thomas Rast | d824cbb | 2009-06-27 17:58:46 +0200 | [diff] [blame] | 73 | die_errno("cannot rmdir '%s'", path); |
Linus Torvalds | 12dccc1 | 2005-06-05 21:59:54 -0700 | [diff] [blame] | 74 | } |
| 75 | |
Linus Torvalds | d48a72f | 2005-07-14 09:58:45 -0700 | [diff] [blame] | 76 | static int create_file(const char *path, unsigned int mode) |
Linus Torvalds | 12dccc1 | 2005-06-05 21:59:54 -0700 | [diff] [blame] | 77 | { |
Linus Torvalds | 12dccc1 | 2005-06-05 21:59:54 -0700 | [diff] [blame] | 78 | mode = (mode & 0100) ? 0777 : 0666; |
Alex Riesen | 781411e | 2006-01-05 09:58:06 +0100 | [diff] [blame] | 79 | return open(path, O_WRONLY | O_CREAT | O_EXCL, mode); |
Linus Torvalds | 12dccc1 | 2005-06-05 21:59:54 -0700 | [diff] [blame] | 80 | } |
| 81 | |
Kjetil Barvik | 4857c76 | 2009-02-09 21:54:50 +0100 | [diff] [blame] | 82 | static void *read_blob_entry(struct cache_entry *ce, unsigned long *size) |
Linus Torvalds | f0807e6 | 2007-04-13 09:26:04 -0700 | [diff] [blame] | 83 | { |
| 84 | enum object_type type; |
| 85 | void *new = read_sha1_file(ce->sha1, &type, size); |
| 86 | |
| 87 | if (new) { |
| 88 | if (type == OBJ_BLOB) |
| 89 | return new; |
| 90 | free(new); |
| 91 | } |
| 92 | return NULL; |
| 93 | } |
| 94 | |
Junio C Hamano | fd5db55 | 2011-05-12 21:36:42 -0700 | [diff] [blame] | 95 | static int open_output_fd(char *path, struct cache_entry *ce, int to_tempfile) |
| 96 | { |
| 97 | int symlink = (ce->ce_mode & S_IFMT) != S_IFREG; |
| 98 | if (to_tempfile) { |
| 99 | strcpy(path, symlink |
| 100 | ? ".merge_link_XXXXXX" : ".merge_file_XXXXXX"); |
| 101 | return mkstemp(path); |
| 102 | } else { |
| 103 | return create_file(path, !symlink ? ce->ce_mode : 0666); |
| 104 | } |
| 105 | } |
| 106 | |
| 107 | static int fstat_output(int fd, const struct checkout *state, struct stat *st) |
| 108 | { |
| 109 | /* use fstat() only when path == ce->name */ |
| 110 | if (fstat_is_reliable() && |
| 111 | state->refresh_cache && !state->base_dir_len) { |
| 112 | fstat(fd, st); |
| 113 | return 1; |
| 114 | } |
| 115 | return 0; |
| 116 | } |
| 117 | |
Junio C Hamano | dd8e912 | 2011-05-12 14:31:08 -0700 | [diff] [blame] | 118 | static int streaming_write_entry(struct cache_entry *ce, char *path, |
Junio C Hamano | b669109 | 2011-05-20 14:33:31 -0700 | [diff] [blame] | 119 | struct stream_filter *filter, |
Junio C Hamano | dd8e912 | 2011-05-12 14:31:08 -0700 | [diff] [blame] | 120 | const struct checkout *state, int to_tempfile, |
| 121 | int *fstat_done, struct stat *statbuf) |
| 122 | { |
Junio C Hamano | dd8e912 | 2011-05-12 14:31:08 -0700 | [diff] [blame] | 123 | int result = -1; |
Junio C Hamano | 47a02ff | 2012-03-07 17:54:15 +0700 | [diff] [blame] | 124 | int fd; |
Junio C Hamano | dd8e912 | 2011-05-12 14:31:08 -0700 | [diff] [blame] | 125 | |
| 126 | fd = open_output_fd(path, ce, to_tempfile); |
Junio C Hamano | 47a02ff | 2012-03-07 17:54:15 +0700 | [diff] [blame] | 127 | if (0 <= fd) { |
| 128 | result = stream_blob_to_fd(fd, ce->sha1, filter, 1); |
| 129 | *fstat_done = fstat_output(fd, state, statbuf); |
Junio C Hamano | dd8e912 | 2011-05-12 14:31:08 -0700 | [diff] [blame] | 130 | result = close(fd); |
Junio C Hamano | 47a02ff | 2012-03-07 17:54:15 +0700 | [diff] [blame] | 131 | } |
Junio C Hamano | dd8e912 | 2011-05-12 14:31:08 -0700 | [diff] [blame] | 132 | if (result && 0 <= fd) |
| 133 | unlink(path); |
| 134 | return result; |
| 135 | } |
| 136 | |
Luiz Fernando N. Capitulino | efbc583 | 2007-04-25 11:18:08 -0300 | [diff] [blame] | 137 | static int write_entry(struct cache_entry *ce, char *path, const struct checkout *state, int to_tempfile) |
Linus Torvalds | 12dccc1 | 2005-06-05 21:59:54 -0700 | [diff] [blame] | 138 | { |
Kjetil Barvik | 4857c76 | 2009-02-09 21:54:50 +0100 | [diff] [blame] | 139 | unsigned int ce_mode_s_ifmt = ce->ce_mode & S_IFMT; |
Kjetil Barvik | e4c7292 | 2009-02-09 21:54:51 +0100 | [diff] [blame] | 140 | int fd, ret, fstat_done = 0; |
Kjetil Barvik | 4857c76 | 2009-02-09 21:54:50 +0100 | [diff] [blame] | 141 | char *new; |
| 142 | struct strbuf buf = STRBUF_INIT; |
| 143 | unsigned long size; |
| 144 | size_t wrote, newsize = 0; |
Kjetil Barvik | e4c7292 | 2009-02-09 21:54:51 +0100 | [diff] [blame] | 145 | struct stat st; |
Linus Torvalds | 12dccc1 | 2005-06-05 21:59:54 -0700 | [diff] [blame] | 146 | |
Junio C Hamano | b669109 | 2011-05-20 14:33:31 -0700 | [diff] [blame] | 147 | if (ce_mode_s_ifmt == S_IFREG) { |
| 148 | struct stream_filter *filter = get_stream_filter(path, ce->sha1); |
| 149 | if (filter && |
| 150 | !streaming_write_entry(ce, path, filter, |
| 151 | state, to_tempfile, |
| 152 | &fstat_done, &st)) |
| 153 | goto finish; |
| 154 | } |
Junio C Hamano | dd8e912 | 2011-05-12 14:31:08 -0700 | [diff] [blame] | 155 | |
Kjetil Barvik | 4857c76 | 2009-02-09 21:54:50 +0100 | [diff] [blame] | 156 | switch (ce_mode_s_ifmt) { |
Linus Torvalds | 12dccc1 | 2005-06-05 21:59:54 -0700 | [diff] [blame] | 157 | case S_IFREG: |
Kjetil Barvik | 4857c76 | 2009-02-09 21:54:50 +0100 | [diff] [blame] | 158 | case S_IFLNK: |
| 159 | new = read_blob_entry(ce, &size); |
Linus Torvalds | f0807e6 | 2007-04-13 09:26:04 -0700 | [diff] [blame] | 160 | if (!new) |
Nguyễn Thái Ngọc Duy | d43e907 | 2010-11-28 11:36:38 +0700 | [diff] [blame] | 161 | return error("unable to read sha1 file of %s (%s)", |
Linus Torvalds | f0807e6 | 2007-04-13 09:26:04 -0700 | [diff] [blame] | 162 | path, sha1_to_hex(ce->sha1)); |
Junio C Hamano | 1a9d7e9 | 2007-08-14 01:41:02 -0700 | [diff] [blame] | 163 | |
Kjetil Barvik | 4857c76 | 2009-02-09 21:54:50 +0100 | [diff] [blame] | 164 | if (ce_mode_s_ifmt == S_IFLNK && has_symlinks && !to_tempfile) { |
| 165 | ret = symlink(new, path); |
| 166 | free(new); |
| 167 | if (ret) |
Nguyễn Thái Ngọc Duy | d43e907 | 2010-11-28 11:36:38 +0700 | [diff] [blame] | 168 | return error("unable to create symlink %s (%s)", |
Kjetil Barvik | 4857c76 | 2009-02-09 21:54:50 +0100 | [diff] [blame] | 169 | path, strerror(errno)); |
| 170 | break; |
| 171 | } |
| 172 | |
Junio C Hamano | 1a9d7e9 | 2007-08-14 01:41:02 -0700 | [diff] [blame] | 173 | /* |
| 174 | * Convert from git internal format to working tree format |
| 175 | */ |
Kjetil Barvik | 4857c76 | 2009-02-09 21:54:50 +0100 | [diff] [blame] | 176 | if (ce_mode_s_ifmt == S_IFREG && |
| 177 | convert_to_working_tree(ce->name, new, size, &buf)) { |
Junio C Hamano | 1a9d7e9 | 2007-08-14 01:41:02 -0700 | [diff] [blame] | 178 | free(new); |
René Scharfe | c32f749 | 2007-10-21 11:23:49 +0200 | [diff] [blame] | 179 | new = strbuf_detach(&buf, &newsize); |
| 180 | size = newsize; |
Junio C Hamano | 1a9d7e9 | 2007-08-14 01:41:02 -0700 | [diff] [blame] | 181 | } |
| 182 | |
Junio C Hamano | fd5db55 | 2011-05-12 21:36:42 -0700 | [diff] [blame] | 183 | fd = open_output_fd(path, ce, to_tempfile); |
Linus Torvalds | 12dccc1 | 2005-06-05 21:59:54 -0700 | [diff] [blame] | 184 | if (fd < 0) { |
| 185 | free(new); |
Nguyễn Thái Ngọc Duy | d43e907 | 2010-11-28 11:36:38 +0700 | [diff] [blame] | 186 | return error("unable to create file %s (%s)", |
Linus Torvalds | 12dccc1 | 2005-06-05 21:59:54 -0700 | [diff] [blame] | 187 | path, strerror(errno)); |
| 188 | } |
Linus Torvalds | 6c510be | 2007-02-13 11:07:23 -0800 | [diff] [blame] | 189 | |
Andy Whitcroft | 93822c2 | 2007-01-08 15:58:23 +0000 | [diff] [blame] | 190 | wrote = write_in_full(fd, new, size); |
Junio C Hamano | fd5db55 | 2011-05-12 21:36:42 -0700 | [diff] [blame] | 191 | if (!to_tempfile) |
| 192 | fstat_done = fstat_output(fd, state, &st); |
Linus Torvalds | 12dccc1 | 2005-06-05 21:59:54 -0700 | [diff] [blame] | 193 | close(fd); |
| 194 | free(new); |
| 195 | if (wrote != size) |
Nguyễn Thái Ngọc Duy | d43e907 | 2010-11-28 11:36:38 +0700 | [diff] [blame] | 196 | return error("unable to write file %s", path); |
Linus Torvalds | 12dccc1 | 2005-06-05 21:59:54 -0700 | [diff] [blame] | 197 | break; |
Martin Waitz | 302b928 | 2007-05-21 22:08:28 +0200 | [diff] [blame] | 198 | case S_IFGITLINK: |
Linus Torvalds | f0807e6 | 2007-04-13 09:26:04 -0700 | [diff] [blame] | 199 | if (to_tempfile) |
Nguyễn Thái Ngọc Duy | d43e907 | 2010-11-28 11:36:38 +0700 | [diff] [blame] | 200 | return error("cannot create temporary subproject %s", path); |
Linus Torvalds | f0807e6 | 2007-04-13 09:26:04 -0700 | [diff] [blame] | 201 | if (mkdir(path, 0777) < 0) |
Nguyễn Thái Ngọc Duy | d43e907 | 2010-11-28 11:36:38 +0700 | [diff] [blame] | 202 | return error("cannot create subproject directory %s", path); |
Linus Torvalds | f0807e6 | 2007-04-13 09:26:04 -0700 | [diff] [blame] | 203 | break; |
Linus Torvalds | 12dccc1 | 2005-06-05 21:59:54 -0700 | [diff] [blame] | 204 | default: |
Nguyễn Thái Ngọc Duy | d43e907 | 2010-11-28 11:36:38 +0700 | [diff] [blame] | 205 | return error("unknown file mode for %s in index", path); |
Linus Torvalds | 12dccc1 | 2005-06-05 21:59:54 -0700 | [diff] [blame] | 206 | } |
| 207 | |
Junio C Hamano | dd8e912 | 2011-05-12 14:31:08 -0700 | [diff] [blame] | 208 | finish: |
Linus Torvalds | 6ee67f2 | 2005-06-05 23:15:40 -0700 | [diff] [blame] | 209 | if (state->refresh_cache) { |
Kjetil Barvik | e4c7292 | 2009-02-09 21:54:51 +0100 | [diff] [blame] | 210 | if (!fstat_done) |
| 211 | lstat(ce->name, &st); |
Linus Torvalds | 12dccc1 | 2005-06-05 21:59:54 -0700 | [diff] [blame] | 212 | fill_stat_cache_info(ce, &st); |
| 213 | } |
| 214 | return 0; |
| 215 | } |
| 216 | |
Linus Torvalds | b6986d8 | 2009-07-29 20:22:25 -0700 | [diff] [blame] | 217 | /* |
| 218 | * This is like 'lstat()', except it refuses to follow symlinks |
Junio C Hamano | da02ca5 | 2009-08-16 23:53:12 -0700 | [diff] [blame] | 219 | * in the path, after skipping "skiplen". |
Linus Torvalds | b6986d8 | 2009-07-29 20:22:25 -0700 | [diff] [blame] | 220 | */ |
Junio C Hamano | 61b97df | 2010-01-11 22:27:31 -0800 | [diff] [blame] | 221 | static int check_path(const char *path, int len, struct stat *st, int skiplen) |
Linus Torvalds | b6986d8 | 2009-07-29 20:22:25 -0700 | [diff] [blame] | 222 | { |
Junio C Hamano | da02ca5 | 2009-08-16 23:53:12 -0700 | [diff] [blame] | 223 | const char *slash = path + len; |
| 224 | |
| 225 | while (path < slash && *slash != '/') |
| 226 | slash--; |
| 227 | if (!has_dirs_only_path(path, slash - path, skiplen)) { |
Linus Torvalds | b6986d8 | 2009-07-29 20:22:25 -0700 | [diff] [blame] | 228 | errno = ENOENT; |
| 229 | return -1; |
| 230 | } |
| 231 | return lstat(path, st); |
| 232 | } |
| 233 | |
Luiz Fernando N. Capitulino | efbc583 | 2007-04-25 11:18:08 -0300 | [diff] [blame] | 234 | int checkout_entry(struct cache_entry *ce, const struct checkout *state, char *topath) |
Linus Torvalds | 12dccc1 | 2005-06-05 21:59:54 -0700 | [diff] [blame] | 235 | { |
Jonas Fonseca | 095c424 | 2006-08-26 16:09:17 +0200 | [diff] [blame] | 236 | static char path[PATH_MAX + 1]; |
Shawn Pearce | de84f99 | 2006-03-05 03:24:15 -0500 | [diff] [blame] | 237 | struct stat st; |
Linus Torvalds | 12dccc1 | 2005-06-05 21:59:54 -0700 | [diff] [blame] | 238 | int len = state->base_dir_len; |
| 239 | |
Shawn Pearce | de84f99 | 2006-03-05 03:24:15 -0500 | [diff] [blame] | 240 | if (topath) |
| 241 | return write_entry(ce, topath, state, 1); |
| 242 | |
Linus Torvalds | 12dccc1 | 2005-06-05 21:59:54 -0700 | [diff] [blame] | 243 | memcpy(path, state->base_dir, len); |
| 244 | strcpy(path + len, ce->name); |
Kjetil Barvik | 81a9aa6 | 2009-02-09 21:54:08 +0100 | [diff] [blame] | 245 | len += ce_namelen(ce); |
Linus Torvalds | 12dccc1 | 2005-06-05 21:59:54 -0700 | [diff] [blame] | 246 | |
Junio C Hamano | da02ca5 | 2009-08-16 23:53:12 -0700 | [diff] [blame] | 247 | if (!check_path(path, len, &st, state->base_dir_len)) { |
Nguyễn Thái Ngọc Duy | 56cac48 | 2009-12-14 18:43:58 +0700 | [diff] [blame] | 248 | unsigned changed = ce_match_stat(ce, &st, CE_MATCH_IGNORE_VALID|CE_MATCH_IGNORE_SKIP_WORKTREE); |
Linus Torvalds | 12dccc1 | 2005-06-05 21:59:54 -0700 | [diff] [blame] | 249 | if (!changed) |
| 250 | return 0; |
| 251 | if (!state->force) { |
| 252 | if (!state->quiet) |
Nguyễn Thái Ngọc Duy | d43e907 | 2010-11-28 11:36:38 +0700 | [diff] [blame] | 253 | fprintf(stderr, "%s already exists, no checkout\n", path); |
Junio C Hamano | 4b12dae | 2005-10-03 12:44:48 -0700 | [diff] [blame] | 254 | return -1; |
Linus Torvalds | 12dccc1 | 2005-06-05 21:59:54 -0700 | [diff] [blame] | 255 | } |
| 256 | |
| 257 | /* |
| 258 | * We unlink the old file, to get the new one with the |
| 259 | * right permissions (including umask, which is nasty |
| 260 | * to emulate by hand - much easier to let the system |
| 261 | * just do the right thing) |
| 262 | */ |
Linus Torvalds | d48a72f | 2005-07-14 09:58:45 -0700 | [diff] [blame] | 263 | if (S_ISDIR(st.st_mode)) { |
Linus Torvalds | f0807e6 | 2007-04-13 09:26:04 -0700 | [diff] [blame] | 264 | /* If it is a gitlink, leave it alone! */ |
Linus Torvalds | 7a51ed6 | 2008-01-14 16:03:17 -0800 | [diff] [blame] | 265 | if (S_ISGITLINK(ce->ce_mode)) |
Linus Torvalds | f0807e6 | 2007-04-13 09:26:04 -0700 | [diff] [blame] | 266 | return 0; |
Linus Torvalds | d48a72f | 2005-07-14 09:58:45 -0700 | [diff] [blame] | 267 | if (!state->force) |
| 268 | return error("%s is a directory", path); |
| 269 | remove_subtree(path); |
Linus Torvalds | 971f229 | 2008-03-17 08:56:27 -0700 | [diff] [blame] | 270 | } else if (unlink(path)) |
| 271 | return error("unable to unlink old '%s' (%s)", path, strerror(errno)); |
Shawn Pearce | de84f99 | 2006-03-05 03:24:15 -0500 | [diff] [blame] | 272 | } else if (state->not_new) |
Linus Torvalds | 12dccc1 | 2005-06-05 21:59:54 -0700 | [diff] [blame] | 273 | return 0; |
Kjetil Barvik | 81a9aa6 | 2009-02-09 21:54:08 +0100 | [diff] [blame] | 274 | create_directories(path, len, state); |
Shawn Pearce | de84f99 | 2006-03-05 03:24:15 -0500 | [diff] [blame] | 275 | return write_entry(ce, path, state, 0); |
Linus Torvalds | 12dccc1 | 2005-06-05 21:59:54 -0700 | [diff] [blame] | 276 | } |