Andrew's git / gitweb.git / refs.c
?
refs.con commit wt-status: use simplified resolve_ref to find current branch (f62363f)
   1#include "refs.h"
   2#include "cache.h"
   3
   4#include <errno.h>
   5
   6struct ref_list {
   7        struct ref_list *next;
   8        unsigned char sha1[20];
   9        char name[FLEX_ARRAY];
  10};
  11
  12static const char *parse_ref_line(char *line, unsigned char *sha1)
  13{
  14        /*
  15         * 42: the answer to everything.
  16         *
  17         * In this case, it happens to be the answer to
  18         *  40 (length of sha1 hex representation)
  19         *  +1 (space in between hex and name)
  20         *  +1 (newline at the end of the line)
  21         */
  22        int len = strlen(line) - 42;
  23
  24        if (len <= 0)
  25                return NULL;
  26        if (get_sha1_hex(line, sha1) < 0)
  27                return NULL;
  28        if (!isspace(line[40]))
  29                return NULL;
  30        line += 41;
  31        if (isspace(*line))
  32                return NULL;
  33        if (line[len] != '\n')
  34                return NULL;
  35        line[len] = 0;
  36        return line;
  37}
  38
  39static struct ref_list *add_ref(const char *name, const unsigned char *sha1, struct ref_list *list)
  40{
  41        int len;
  42        struct ref_list **p = &list, *entry;
  43
  44        /* Find the place to insert the ref into.. */
  45        while ((entry = *p) != NULL) {
  46                int cmp = strcmp(entry->name, name);
  47                if (cmp > 0)
  48                        break;
  49
  50                /* Same as existing entry? */
  51                if (!cmp)
  52                        return list;
  53                p = &entry->next;
  54        }
  55
  56        /* Allocate it and add it in.. */
  57        len = strlen(name) + 1;
  58        entry = xmalloc(sizeof(struct ref_list) + len);
  59        hashcpy(entry->sha1, sha1);
  60        memcpy(entry->name, name, len);
  61        entry->next = *p;
  62        *p = entry;
  63        return list;
  64}
  65
  66static struct ref_list *get_packed_refs(void)
  67{
  68        static int did_refs = 0;
  69        static struct ref_list *refs = NULL;
  70
  71        if (!did_refs) {
  72                FILE *f = fopen(git_path("packed-refs"), "r");
  73                if (f) {
  74                        struct ref_list *list = NULL;
  75                        char refline[PATH_MAX];
  76                        while (fgets(refline, sizeof(refline), f)) {
  77                                unsigned char sha1[20];
  78                                const char *name = parse_ref_line(refline, sha1);
  79                                if (!name)
  80                                        continue;
  81                                list = add_ref(name, sha1, list);
  82                        }
  83                        fclose(f);
  84                        refs = list;
  85                }
  86                did_refs = 1;
  87        }
  88        return refs;
  89}
  90
  91static struct ref_list *get_ref_dir(const char *base, struct ref_list *list)
  92{
  93        DIR *dir = opendir(git_path("%s", base));
  94
  95        if (dir) {
  96                struct dirent *de;
  97                int baselen = strlen(base);
  98                char *ref = xmalloc(baselen + 257);
  99
 100                memcpy(ref, base, baselen);
 101                if (baselen && base[baselen-1] != '/')
 102                        ref[baselen++] = '/';
 103
 104                while ((de = readdir(dir)) != NULL) {
 105                        unsigned char sha1[20];
 106                        struct stat st;
 107                        int namelen;
 108
 109                        if (de->d_name[0] == '.')
 110                                continue;
 111                        namelen = strlen(de->d_name);
 112                        if (namelen > 255)
 113                                continue;
 114                        if (has_extension(de->d_name, ".lock"))
 115                                continue;
 116                        memcpy(ref + baselen, de->d_name, namelen+1);
 117                        if (stat(git_path("%s", ref), &st) < 0)
 118                                continue;
 119                        if (S_ISDIR(st.st_mode)) {
 120                                list = get_ref_dir(ref, list);
 121                                continue;
 122                        }
 123                        if (read_ref(ref, sha1) < 0) {
 124                                error("%s points nowhere!", ref);
 125                                continue;
 126                        }
 127                        list = add_ref(ref, sha1, list);
 128                }
 129                free(ref);
 130                closedir(dir);
 131        }
 132        return list;
 133}
 134
 135static struct ref_list *get_loose_refs(void)
 136{
 137        static int did_refs = 0;
 138        static struct ref_list *refs = NULL;
 139
 140        if (!did_refs) {
 141                refs = get_ref_dir("refs", NULL);
 142                did_refs = 1;
 143        }
 144        return refs;
 145}
 146
 147/* We allow "recursive" symbolic refs. Only within reason, though */
 148#define MAXDEPTH 5
 149
 150const char *resolve_ref(const char *ref, unsigned char *sha1, int reading)
 151{
 152        int depth = MAXDEPTH, len;
 153        char buffer[256];
 154        static char ref_buffer[256];
 155
 156        for (;;) {
 157                const char *path = git_path("%s", ref);
 158                struct stat st;
 159                char *buf;
 160                int fd;
 161
 162                if (--depth < 0)
 163                        return NULL;
 164
 165                /* Special case: non-existing file.
 166                 * Not having the refs/heads/new-branch is OK
 167                 * if we are writing into it, so is .git/HEAD
 168                 * that points at refs/heads/master still to be
 169                 * born.  It is NOT OK if we are resolving for
 170                 * reading.
 171                 */
 172                if (lstat(path, &st) < 0) {
 173                        struct ref_list *list = get_packed_refs();
 174                        while (list) {
 175                                if (!strcmp(ref, list->name)) {
 176                                        hashcpy(sha1, list->sha1);
 177                                        return ref;
 178                                }
 179                                list = list->next;
 180                        }
 181                        if (reading || errno != ENOENT)
 182                                return NULL;
 183                        hashclr(sha1);
 184                        return ref;
 185                }
 186
 187                /* Follow "normalized" - ie "refs/.." symlinks by hand */
 188                if (S_ISLNK(st.st_mode)) {
 189                        len = readlink(path, buffer, sizeof(buffer)-1);
 190                        if (len >= 5 && !memcmp("refs/", buffer, 5)) {
 191                                buffer[len] = 0;
 192                                strcpy(ref_buffer, buffer);
 193                                ref = ref_buffer;
 194                                continue;
 195                        }
 196                }
 197
 198                /*
 199                 * Anything else, just open it and try to use it as
 200                 * a ref
 201                 */
 202                fd = open(path, O_RDONLY);
 203                if (fd < 0)
 204                        return NULL;
 205                len = read(fd, buffer, sizeof(buffer)-1);
 206                close(fd);
 207
 208                /*
 209                 * Is it a symbolic ref?
 210                 */
 211                if (len < 4 || memcmp("ref:", buffer, 4))
 212                        break;
 213                buf = buffer + 4;
 214                len -= 4;
 215                while (len && isspace(*buf))
 216                        buf++, len--;
 217                while (len && isspace(buf[len-1]))
 218                        len--;
 219                buf[len] = 0;
 220                memcpy(ref_buffer, buf, len + 1);
 221                ref = ref_buffer;
 222        }
 223        if (len < 40 || get_sha1_hex(buffer, sha1))
 224                return NULL;
 225        return ref;
 226}
 227
 228int create_symref(const char *ref_target, const char *refs_heads_master)
 229{
 230        const char *lockpath;
 231        char ref[1000];
 232        int fd, len, written;
 233        const char *git_HEAD = git_path("%s", ref_target);
 234
 235#ifndef NO_SYMLINK_HEAD
 236        if (prefer_symlink_refs) {
 237                unlink(git_HEAD);
 238                if (!symlink(refs_heads_master, git_HEAD))
 239                        return 0;
 240                fprintf(stderr, "no symlink - falling back to symbolic ref\n");
 241        }
 242#endif
 243
 244        len = snprintf(ref, sizeof(ref), "ref: %s\n", refs_heads_master);
 245        if (sizeof(ref) <= len) {
 246                error("refname too long: %s", refs_heads_master);
 247                return -1;
 248        }
 249        lockpath = mkpath("%s.lock", git_HEAD);
 250        fd = open(lockpath, O_CREAT | O_EXCL | O_WRONLY, 0666); 
 251        written = write(fd, ref, len);
 252        close(fd);
 253        if (written != len) {
 254                unlink(lockpath);
 255                error("Unable to write to %s", lockpath);
 256                return -2;
 257        }
 258        if (rename(lockpath, git_HEAD) < 0) {
 259                unlink(lockpath);
 260                error("Unable to create %s", git_HEAD);
 261                return -3;
 262        }
 263        if (adjust_shared_perm(git_HEAD)) {
 264                unlink(lockpath);
 265                error("Unable to fix permissions on %s", lockpath);
 266                return -4;
 267        }
 268        return 0;
 269}
 270
 271int read_ref(const char *ref, unsigned char *sha1)
 272{
 273        if (resolve_ref(ref, sha1, 1))
 274                return 0;
 275        return -1;
 276}
 277
 278static int do_for_each_ref(const char *base, int (*fn)(const char *path, const unsigned char *sha1), int trim)
 279{
 280        int retval;
 281        struct ref_list *packed = get_packed_refs();
 282        struct ref_list *loose = get_loose_refs();
 283
 284        while (packed && loose) {
 285                struct ref_list *entry;
 286                int cmp = strcmp(packed->name, loose->name);
 287                if (!cmp) {
 288                        packed = packed->next;
 289                        continue;
 290                }
 291                if (cmp > 0) {
 292                        entry = loose;
 293                        loose = loose->next;
 294                } else {
 295                        entry = packed;
 296                        packed = packed->next;
 297                }
 298                if (strncmp(base, entry->name, trim))
 299                        continue;
 300                if (is_null_sha1(entry->sha1))
 301                        continue;
 302                if (!has_sha1_file(entry->sha1)) {
 303                        error("%s does not point to a valid object!", entry->name);
 304                        continue;
 305                }
 306                retval = fn(entry->name + trim, entry->sha1);
 307                if (retval)
 308                        return retval;
 309        }
 310
 311        packed = packed ? packed : loose;
 312        while (packed) {
 313                if (!strncmp(base, packed->name, trim)) {
 314                        retval = fn(packed->name + trim, packed->sha1);
 315                        if (retval)
 316                                return retval;
 317                }
 318                packed = packed->next;
 319        }
 320        return 0;
 321}
 322
 323int head_ref(int (*fn)(const char *path, const unsigned char *sha1))
 324{
 325        unsigned char sha1[20];
 326        if (!read_ref("HEAD", sha1))
 327                return fn("HEAD", sha1);
 328        return 0;
 329}
 330
 331int for_each_ref(int (*fn)(const char *path, const unsigned char *sha1))
 332{
 333        return do_for_each_ref("refs/", fn, 0);
 334}
 335
 336int for_each_tag_ref(int (*fn)(const char *path, const unsigned char *sha1))
 337{
 338        return do_for_each_ref("refs/tags/", fn, 10);
 339}
 340
 341int for_each_branch_ref(int (*fn)(const char *path, const unsigned char *sha1))
 342{
 343        return do_for_each_ref("refs/heads/", fn, 11);
 344}
 345
 346int for_each_remote_ref(int (*fn)(const char *path, const unsigned char *sha1))
 347{
 348        return do_for_each_ref("refs/remotes/", fn, 13);
 349}
 350
 351int get_ref_sha1(const char *ref, unsigned char *sha1)
 352{
 353        if (check_ref_format(ref))
 354                return -1;
 355        return read_ref(mkpath("refs/%s", ref), sha1);
 356}
 357
 358/*
 359 * Make sure "ref" is something reasonable to have under ".git/refs/";
 360 * We do not like it if:
 361 *
 362 * - any path component of it begins with ".", or
 363 * - it has double dots "..", or
 364 * - it has ASCII control character, "~", "^", ":" or SP, anywhere, or
 365 * - it ends with a "/".
 366 */
 367
 368static inline int bad_ref_char(int ch)
 369{
 370        return (((unsigned) ch) <= ' ' ||
 371                ch == '~' || ch == '^' || ch == ':' ||
 372                /* 2.13 Pattern Matching Notation */
 373                ch == '?' || ch == '*' || ch == '[');
 374}
 375
 376int check_ref_format(const char *ref)
 377{
 378        int ch, level;
 379        const char *cp = ref;
 380
 381        level = 0;
 382        while (1) {
 383                while ((ch = *cp++) == '/')
 384                        ; /* tolerate duplicated slashes */
 385                if (!ch)
 386                        return -1; /* should not end with slashes */
 387
 388                /* we are at the beginning of the path component */
 389                if (ch == '.' || bad_ref_char(ch))
 390                        return -1;
 391
 392                /* scan the rest of the path component */
 393                while ((ch = *cp++) != 0) {
 394                        if (bad_ref_char(ch))
 395                                return -1;
 396                        if (ch == '/')
 397                                break;
 398                        if (ch == '.' && *cp == '.')
 399                                return -1;
 400                }
 401                level++;
 402                if (!ch) {
 403                        if (level < 2)
 404                                return -1; /* at least of form "heads/blah" */
 405                        return 0;
 406                }
 407        }
 408}
 409
 410static struct ref_lock *verify_lock(struct ref_lock *lock,
 411        const unsigned char *old_sha1, int mustexist)
 412{
 413        if (!resolve_ref(lock->ref_name, lock->old_sha1, mustexist)) {
 414                error("Can't verify ref %s", lock->ref_name);
 415                unlock_ref(lock);
 416                return NULL;
 417        }
 418        if (hashcmp(lock->old_sha1, old_sha1)) {
 419                error("Ref %s is at %s but expected %s", lock->ref_name,
 420                        sha1_to_hex(lock->old_sha1), sha1_to_hex(old_sha1));
 421                unlock_ref(lock);
 422                return NULL;
 423        }
 424        return lock;
 425}
 426
 427static struct ref_lock *lock_ref_sha1_basic(const char *ref,
 428        int plen,
 429        const unsigned char *old_sha1, int mustexist)
 430{
 431        char *ref_file;
 432        const char *orig_ref = ref;
 433        struct ref_lock *lock;
 434        struct stat st;
 435
 436        lock = xcalloc(1, sizeof(struct ref_lock));
 437        lock->lock_fd = -1;
 438
 439        ref = resolve_ref(ref, lock->old_sha1, mustexist);
 440        if (!ref) {
 441                int last_errno = errno;
 442                error("unable to resolve reference %s: %s",
 443                        orig_ref, strerror(errno));
 444                unlock_ref(lock);
 445                errno = last_errno;
 446                return NULL;
 447        }
 448        lock->lk = xcalloc(1, sizeof(struct lock_file));
 449
 450        lock->ref_name = xstrdup(ref);
 451        lock->log_file = xstrdup(git_path("logs/%s", ref));
 452        ref_file = git_path(ref);
 453        lock->force_write = lstat(ref_file, &st) && errno == ENOENT;
 454
 455        if (safe_create_leading_directories(ref_file))
 456                die("unable to create directory for %s", ref_file);
 457        lock->lock_fd = hold_lock_file_for_update(lock->lk, ref_file, 1);
 458
 459        return old_sha1 ? verify_lock(lock, old_sha1, mustexist) : lock;
 460}
 461
 462struct ref_lock *lock_ref_sha1(const char *ref,
 463        const unsigned char *old_sha1, int mustexist)
 464{
 465        if (check_ref_format(ref))
 466                return NULL;
 467        return lock_ref_sha1_basic(mkpath("refs/%s", ref),
 468                5 + strlen(ref), old_sha1, mustexist);
 469}
 470
 471struct ref_lock *lock_any_ref_for_update(const char *ref,
 472        const unsigned char *old_sha1, int mustexist)
 473{
 474        return lock_ref_sha1_basic(ref, strlen(ref), old_sha1, mustexist);
 475}
 476
 477void unlock_ref(struct ref_lock *lock)
 478{
 479        if (lock->lock_fd >= 0) {
 480                close(lock->lock_fd);
 481                /* Do not free lock->lk -- atexit() still looks at them */
 482                if (lock->lk)
 483                        rollback_lock_file(lock->lk);
 484        }
 485        free(lock->ref_name);
 486        free(lock->log_file);
 487        free(lock);
 488}
 489
 490static int log_ref_write(struct ref_lock *lock,
 491        const unsigned char *sha1, const char *msg)
 492{
 493        int logfd, written, oflags = O_APPEND | O_WRONLY;
 494        unsigned maxlen, len;
 495        char *logrec;
 496        const char *committer;
 497
 498        if (log_all_ref_updates) {
 499                if (safe_create_leading_directories(lock->log_file) < 0)
 500                        return error("unable to create directory for %s",
 501                                lock->log_file);
 502                oflags |= O_CREAT;
 503        }
 504
 505        logfd = open(lock->log_file, oflags, 0666);
 506        if (logfd < 0) {
 507                if (!log_all_ref_updates && errno == ENOENT)
 508                        return 0;
 509                return error("Unable to append to %s: %s",
 510                        lock->log_file, strerror(errno));
 511        }
 512
 513        committer = git_committer_info(1);
 514        if (msg) {
 515                maxlen = strlen(committer) + strlen(msg) + 2*40 + 5;
 516                logrec = xmalloc(maxlen);
 517                len = snprintf(logrec, maxlen, "%s %s %s\t%s\n",
 518                        sha1_to_hex(lock->old_sha1),
 519                        sha1_to_hex(sha1),
 520                        committer,
 521                        msg);
 522        }
 523        else {
 524                maxlen = strlen(committer) + 2*40 + 4;
 525                logrec = xmalloc(maxlen);
 526                len = snprintf(logrec, maxlen, "%s %s %s\n",
 527                        sha1_to_hex(lock->old_sha1),
 528                        sha1_to_hex(sha1),
 529                        committer);
 530        }
 531        written = len <= maxlen ? write(logfd, logrec, len) : -1;
 532        free(logrec);
 533        close(logfd);
 534        if (written != len)
 535                return error("Unable to append to %s", lock->log_file);
 536        return 0;
 537}
 538
 539int write_ref_sha1(struct ref_lock *lock,
 540        const unsigned char *sha1, const char *logmsg)
 541{
 542        static char term = '\n';
 543
 544        if (!lock)
 545                return -1;
 546        if (!lock->force_write && !hashcmp(lock->old_sha1, sha1)) {
 547                unlock_ref(lock);
 548                return 0;
 549        }
 550        if (write(lock->lock_fd, sha1_to_hex(sha1), 40) != 40 ||
 551            write(lock->lock_fd, &term, 1) != 1
 552                || close(lock->lock_fd) < 0) {
 553                error("Couldn't write %s", lock->lk->filename);
 554                unlock_ref(lock);
 555                return -1;
 556        }
 557        if (log_ref_write(lock, sha1, logmsg) < 0) {
 558                unlock_ref(lock);
 559                return -1;
 560        }
 561        if (commit_lock_file(lock->lk)) {
 562                error("Couldn't set %s", lock->ref_name);
 563                unlock_ref(lock);
 564                return -1;
 565        }
 566        lock->lock_fd = -1;
 567        unlock_ref(lock);
 568        return 0;
 569}
 570
 571int read_ref_at(const char *ref, unsigned long at_time, unsigned char *sha1)
 572{
 573        const char *logfile, *logdata, *logend, *rec, *lastgt, *lastrec;
 574        char *tz_c;
 575        int logfd, tz;
 576        struct stat st;
 577        unsigned long date;
 578        unsigned char logged_sha1[20];
 579
 580        logfile = git_path("logs/%s", ref);
 581        logfd = open(logfile, O_RDONLY, 0);
 582        if (logfd < 0)
 583                die("Unable to read log %s: %s", logfile, strerror(errno));
 584        fstat(logfd, &st);
 585        if (!st.st_size)
 586                die("Log %s is empty.", logfile);
 587        logdata = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, logfd, 0);
 588        close(logfd);
 589
 590        lastrec = NULL;
 591        rec = logend = logdata + st.st_size;
 592        while (logdata < rec) {
 593                if (logdata < rec && *(rec-1) == '\n')
 594                        rec--;
 595                lastgt = NULL;
 596                while (logdata < rec && *(rec-1) != '\n') {
 597                        rec--;
 598                        if (*rec == '>')
 599                                lastgt = rec;
 600                }
 601                if (!lastgt)
 602                        die("Log %s is corrupt.", logfile);
 603                date = strtoul(lastgt + 1, &tz_c, 10);
 604                if (date <= at_time) {
 605                        if (lastrec) {
 606                                if (get_sha1_hex(lastrec, logged_sha1))
 607                                        die("Log %s is corrupt.", logfile);
 608                                if (get_sha1_hex(rec + 41, sha1))
 609                                        die("Log %s is corrupt.", logfile);
 610                                if (hashcmp(logged_sha1, sha1)) {
 611                                        tz = strtoul(tz_c, NULL, 10);
 612                                        fprintf(stderr,
 613                                                "warning: Log %s has gap after %s.\n",
 614                                                logfile, show_rfc2822_date(date, tz));
 615                                }
 616                        }
 617                        else if (date == at_time) {
 618                                if (get_sha1_hex(rec + 41, sha1))
 619                                        die("Log %s is corrupt.", logfile);
 620                        }
 621                        else {
 622                                if (get_sha1_hex(rec + 41, logged_sha1))
 623                                        die("Log %s is corrupt.", logfile);
 624                                if (hashcmp(logged_sha1, sha1)) {
 625                                        tz = strtoul(tz_c, NULL, 10);
 626                                        fprintf(stderr,
 627                                                "warning: Log %s unexpectedly ended on %s.\n",
 628                                                logfile, show_rfc2822_date(date, tz));
 629                                }
 630                        }
 631                        munmap((void*)logdata, st.st_size);
 632                        return 0;
 633                }
 634                lastrec = rec;
 635        }
 636
 637        rec = logdata;
 638        while (rec < logend && *rec != '>' && *rec != '\n')
 639                rec++;
 640        if (rec == logend || *rec == '\n')
 641                die("Log %s is corrupt.", logfile);
 642        date = strtoul(rec + 1, &tz_c, 10);
 643        tz = strtoul(tz_c, NULL, 10);
 644        if (get_sha1_hex(logdata, sha1))
 645                die("Log %s is corrupt.", logfile);
 646        munmap((void*)logdata, st.st_size);
 647        fprintf(stderr, "warning: Log %s only goes back to %s.\n",
 648                logfile, show_rfc2822_date(date, tz));
 649        return 0;
 650}