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