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