lockfile.c: document the various states of lock_file objects
[git/git.git] / refs.c
CommitLineData
95fc7512 1#include "cache.h"
85023577 2#include "refs.h"
cf0adba7
JH
3#include "object.h"
4#include "tag.h"
7155b727 5#include "dir.h"
daebaa78 6#include "string-list.h"
95fc7512 7
bc5fd6d3 8/*
dde8a902
DT
9 * How to handle various characters in refnames:
10 * 0: An acceptable character for refs
5e650228
JH
11 * 1: End-of-component
12 * 2: ., look for a preceding . to reject .. in refs
13 * 3: {, look for a preceding @ to reject @{ in refs
14 * 4: A bad character: ASCII control characters, "~", "^", ":" or SP
dde8a902
DT
15 */
16static unsigned char refname_disposition[256] = {
5e650228
JH
17 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
18 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
19 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 2, 1,
20 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 4,
dde8a902 21 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5e650228
JH
22 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 0, 4, 0,
23 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
24 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 4, 4
dde8a902
DT
25};
26
029cdb4a
RS
27/*
28 * Used as a flag to ref_transaction_delete when a loose ref is being
29 * pruned.
30 */
31#define REF_ISPRUNING 0x0100
dde8a902
DT
32/*
33 * Try to read one refname component from the front of refname.
34 * Return the length of the component found, or -1 if the component is
35 * not legal. It is legal if it is something reasonable to have under
36 * ".git/refs/"; We do not like it if:
bc5fd6d3
MH
37 *
38 * - any path component of it begins with ".", or
39 * - it has double dots "..", or
40 * - it has ASCII control character, "~", "^", ":" or SP, anywhere, or
5e650228
JH
41 * - it ends with a "/".
42 * - it ends with ".lock"
bc5fd6d3
MH
43 * - it contains a "\" (backslash)
44 */
bc5fd6d3
MH
45static int check_refname_component(const char *refname, int flags)
46{
47 const char *cp;
48 char last = '\0';
49
50 for (cp = refname; ; cp++) {
dde8a902
DT
51 int ch = *cp & 255;
52 unsigned char disp = refname_disposition[ch];
53 switch (disp) {
5e650228 54 case 1:
dde8a902 55 goto out;
5e650228 56 case 2:
dde8a902
DT
57 if (last == '.')
58 return -1; /* Refname contains "..". */
59 break;
5e650228 60 case 3:
dde8a902
DT
61 if (last == '@')
62 return -1; /* Refname contains "@{". */
bc5fd6d3 63 break;
5e650228 64 case 4:
dde8a902
DT
65 return -1;
66 }
bc5fd6d3
MH
67 last = ch;
68 }
dde8a902 69out:
bc5fd6d3 70 if (cp == refname)
dac529e4 71 return 0; /* Component has zero length. */
bc5fd6d3
MH
72 if (refname[0] == '.') {
73 if (!(flags & REFNAME_DOT_COMPONENT))
74 return -1; /* Component starts with '.'. */
75 /*
76 * Even if leading dots are allowed, don't allow "."
77 * as a component (".." is prevented by a rule above).
78 */
79 if (refname[1] == '\0')
80 return -1; /* Component equals ".". */
81 }
82 if (cp - refname >= 5 && !memcmp(cp - 5, ".lock", 5))
83 return -1; /* Refname ends with ".lock". */
84 return cp - refname;
85}
86
5e650228 87int check_refname_format(const char *refname, int flags)
bc5fd6d3
MH
88{
89 int component_len, component_count = 0;
90
9ba89f48
FC
91 if (!strcmp(refname, "@"))
92 /* Refname is a single character '@'. */
93 return -1;
94
bc5fd6d3
MH
95 while (1) {
96 /* We are at the start of a path component. */
97 component_len = check_refname_component(refname, flags);
dac529e4 98 if (component_len <= 0) {
bc5fd6d3
MH
99 if ((flags & REFNAME_REFSPEC_PATTERN) &&
100 refname[0] == '*' &&
101 (refname[1] == '\0' || refname[1] == '/')) {
102 /* Accept one wildcard as a full refname component. */
103 flags &= ~REFNAME_REFSPEC_PATTERN;
104 component_len = 1;
105 } else {
106 return -1;
107 }
108 }
109 component_count++;
110 if (refname[component_len] == '\0')
111 break;
112 /* Skip to next component. */
113 refname += component_len + 1;
114 }
115
116 if (refname[component_len - 1] == '.')
117 return -1; /* Refname ends with '.'. */
118 if (!(flags & REFNAME_ALLOW_ONELEVEL) && component_count < 2)
119 return -1; /* Refname has only one component. */
120 return 0;
121}
122
123struct ref_entry;
e1e22e37 124
28e6a34e
MH
125/*
126 * Information used (along with the information in ref_entry) to
127 * describe a single cached reference. This data structure only
128 * occurs embedded in a union in struct ref_entry, and only when
129 * (ref_entry->flag & REF_DIR) is zero.
130 */
593f1bb8 131struct ref_value {
6c6f58df
MH
132 /*
133 * The name of the object to which this reference resolves
134 * (which may be a tag object). If REF_ISBROKEN, this is
135 * null. If REF_ISSYMREF, then this is the name of the object
136 * referred to by the last reference in the symlink chain.
137 */
593f1bb8 138 unsigned char sha1[20];
6c6f58df
MH
139
140 /*
141 * If REF_KNOWS_PEELED, then this field holds the peeled value
142 * of this reference, or null if the reference is known not to
2312a793
MH
143 * be peelable. See the documentation for peel_ref() for an
144 * exact definition of "peelable".
6c6f58df 145 */
593f1bb8
MH
146 unsigned char peeled[20];
147};
148
f006c42a
MH
149struct ref_cache;
150
28e6a34e
MH
151/*
152 * Information used (along with the information in ref_entry) to
153 * describe a level in the hierarchy of references. This data
154 * structure only occurs embedded in a union in struct ref_entry, and
155 * only when (ref_entry.flag & REF_DIR) is set. In that case,
156 * (ref_entry.flag & REF_INCOMPLETE) determines whether the references
157 * in the directory have already been read:
158 *
159 * (ref_entry.flag & REF_INCOMPLETE) unset -- a directory of loose
160 * or packed references, already read.
161 *
162 * (ref_entry.flag & REF_INCOMPLETE) set -- a directory of loose
163 * references that hasn't been read yet (nor has any of its
164 * subdirectories).
165 *
166 * Entries within a directory are stored within a growable array of
167 * pointers to ref_entries (entries, nr, alloc). Entries 0 <= i <
168 * sorted are sorted by their component name in strcmp() order and the
169 * remaining entries are unsorted.
170 *
171 * Loose references are read lazily, one directory at a time. When a
172 * directory of loose references is read, then all of the references
173 * in that directory are stored, and REF_INCOMPLETE stubs are created
174 * for any subdirectories, but the subdirectories themselves are not
175 * read. The reading is triggered by get_ref_dir().
176 */
d3177275 177struct ref_dir {
e9c4c111 178 int nr, alloc;
e6ed3ca6
MH
179
180 /*
181 * Entries with index 0 <= i < sorted are sorted by name. New
182 * entries are appended to the list unsorted, and are sorted
183 * only when required; thus we avoid the need to sort the list
184 * after the addition of every reference.
185 */
186 int sorted;
187
f006c42a
MH
188 /* A pointer to the ref_cache that contains this ref_dir. */
189 struct ref_cache *ref_cache;
190
d3177275 191 struct ref_entry **entries;
e9c4c111
JP
192};
193
89df9c84
MH
194/*
195 * Bit values for ref_entry::flag. REF_ISSYMREF=0x01,
196 * REF_ISPACKED=0x02, and REF_ISBROKEN=0x04 are public values; see
197 * refs.h.
198 */
199
200/*
201 * The field ref_entry->u.value.peeled of this value entry contains
202 * the correct peeled value for the reference, which might be
203 * null_sha1 if the reference is not a tag or if it is broken.
204 */
432ad41e 205#define REF_KNOWS_PEELED 0x08
28e6a34e
MH
206
207/* ref_entry represents a directory of references */
432ad41e 208#define REF_DIR 0x10
cf0adba7 209
28e6a34e
MH
210/*
211 * Entry has not yet been read from disk (used only for REF_DIR
212 * entries representing loose references)
213 */
214#define REF_INCOMPLETE 0x20
215
432ad41e
MH
216/*
217 * A ref_entry represents either a reference or a "subdirectory" of
28e6a34e
MH
218 * references.
219 *
220 * Each directory in the reference namespace is represented by a
221 * ref_entry with (flags & REF_DIR) set and containing a subdir member
222 * that holds the entries in that directory that have been read so
223 * far. If (flags & REF_INCOMPLETE) is set, then the directory and
224 * its subdirectories haven't been read yet. REF_INCOMPLETE is only
225 * used for loose reference directories.
226 *
227 * References are represented by a ref_entry with (flags & REF_DIR)
228 * unset and a value member that describes the reference's value. The
229 * flag member is at the ref_entry level, but it is also needed to
230 * interpret the contents of the value field (in other words, a
231 * ref_value object is not very much use without the enclosing
232 * ref_entry).
432ad41e
MH
233 *
234 * Reference names cannot end with slash and directories' names are
235 * always stored with a trailing slash (except for the top-level
236 * directory, which is always denoted by ""). This has two nice
237 * consequences: (1) when the entries in each subdir are sorted
238 * lexicographically by name (as they usually are), the references in
239 * a whole tree can be generated in lexicographic order by traversing
240 * the tree in left-to-right, depth-first order; (2) the names of
241 * references and subdirectories cannot conflict, and therefore the
242 * presence of an empty subdirectory does not block the creation of a
243 * similarly-named reference. (The fact that reference names with the
244 * same leading components can conflict *with each other* is a
245 * separate issue that is regulated by is_refname_available().)
246 *
247 * Please note that the name field contains the fully-qualified
248 * reference (or subdirectory) name. Space could be saved by only
249 * storing the relative names. But that would require the full names
250 * to be generated on the fly when iterating in do_for_each_ref(), and
251 * would break callback functions, who have always been able to assume
252 * that the name strings that they are passed will not be freed during
253 * the iteration.
254 */
bc5fd6d3
MH
255struct ref_entry {
256 unsigned char flag; /* ISSYMREF? ISPACKED? */
593f1bb8 257 union {
432ad41e
MH
258 struct ref_value value; /* if not (flags&REF_DIR) */
259 struct ref_dir subdir; /* if (flags&REF_DIR) */
593f1bb8 260 } u;
432ad41e
MH
261 /*
262 * The full name of the reference (e.g., "refs/heads/master")
263 * or the full name of the directory with a trailing slash
264 * (e.g., "refs/heads/"):
265 */
bc5fd6d3
MH
266 char name[FLEX_ARRAY];
267};
e1e22e37 268
28e6a34e
MH
269static void read_loose_refs(const char *dirname, struct ref_dir *dir);
270
d7826d54
MH
271static struct ref_dir *get_ref_dir(struct ref_entry *entry)
272{
28e6a34e 273 struct ref_dir *dir;
d7826d54 274 assert(entry->flag & REF_DIR);
28e6a34e
MH
275 dir = &entry->u.subdir;
276 if (entry->flag & REF_INCOMPLETE) {
277 read_loose_refs(entry->name, dir);
278 entry->flag &= ~REF_INCOMPLETE;
279 }
280 return dir;
d7826d54
MH
281}
282
cddc4258
MH
283static struct ref_entry *create_ref_entry(const char *refname,
284 const unsigned char *sha1, int flag,
285 int check_name)
e1e22e37
LT
286{
287 int len;
cddc4258 288 struct ref_entry *ref;
e1e22e37 289
09116a1c 290 if (check_name &&
dfefa935
MH
291 check_refname_format(refname, REFNAME_ALLOW_ONELEVEL|REFNAME_DOT_COMPONENT))
292 die("Reference has invalid format: '%s'", refname);
cddc4258
MH
293 len = strlen(refname) + 1;
294 ref = xmalloc(sizeof(struct ref_entry) + len);
593f1bb8
MH
295 hashcpy(ref->u.value.sha1, sha1);
296 hashclr(ref->u.value.peeled);
cddc4258
MH
297 memcpy(ref->name, refname, len);
298 ref->flag = flag;
299 return ref;
300}
301
432ad41e
MH
302static void clear_ref_dir(struct ref_dir *dir);
303
732134ed
MH
304static void free_ref_entry(struct ref_entry *entry)
305{
27b5587c
MH
306 if (entry->flag & REF_DIR) {
307 /*
308 * Do not use get_ref_dir() here, as that might
309 * trigger the reading of loose refs.
310 */
311 clear_ref_dir(&entry->u.subdir);
312 }
732134ed
MH
313 free(entry);
314}
315
432ad41e
MH
316/*
317 * Add a ref_entry to the end of dir (unsorted). Entry is always
318 * stored directly in dir; no recursion into subdirectories is
319 * done.
320 */
321static void add_entry_to_dir(struct ref_dir *dir, struct ref_entry *entry)
cddc4258 322{
432ad41e
MH
323 ALLOC_GROW(dir->entries, dir->nr + 1, dir->alloc);
324 dir->entries[dir->nr++] = entry;
654ad400
MH
325 /* optimize for the case that entries are added in order */
326 if (dir->nr == 1 ||
327 (dir->nr == dir->sorted + 1 &&
328 strcmp(dir->entries[dir->nr - 2]->name,
329 dir->entries[dir->nr - 1]->name) < 0))
330 dir->sorted = dir->nr;
c774aab9
JP
331}
332
432ad41e
MH
333/*
334 * Clear and free all entries in dir, recursively.
335 */
d3177275 336static void clear_ref_dir(struct ref_dir *dir)
bc5fd6d3
MH
337{
338 int i;
d3177275
MH
339 for (i = 0; i < dir->nr; i++)
340 free_ref_entry(dir->entries[i]);
341 free(dir->entries);
342 dir->sorted = dir->nr = dir->alloc = 0;
343 dir->entries = NULL;
bc5fd6d3
MH
344}
345
432ad41e
MH
346/*
347 * Create a struct ref_entry object for the specified dirname.
348 * dirname is the name of the directory with a trailing slash (e.g.,
349 * "refs/heads/") or "" for the top-level directory.
350 */
f006c42a 351static struct ref_entry *create_dir_entry(struct ref_cache *ref_cache,
b9146f51
RS
352 const char *dirname, size_t len,
353 int incomplete)
432ad41e
MH
354{
355 struct ref_entry *direntry;
432ad41e 356 direntry = xcalloc(1, sizeof(struct ref_entry) + len + 1);
b9146f51
RS
357 memcpy(direntry->name, dirname, len);
358 direntry->name[len] = '\0';
f006c42a 359 direntry->u.subdir.ref_cache = ref_cache;
28e6a34e 360 direntry->flag = REF_DIR | (incomplete ? REF_INCOMPLETE : 0);
432ad41e
MH
361 return direntry;
362}
363
e9c4c111 364static int ref_entry_cmp(const void *a, const void *b)
c774aab9 365{
e9c4c111
JP
366 struct ref_entry *one = *(struct ref_entry **)a;
367 struct ref_entry *two = *(struct ref_entry **)b;
368 return strcmp(one->name, two->name);
369}
c774aab9 370
d3177275 371static void sort_ref_dir(struct ref_dir *dir);
bc5fd6d3 372
e1980c9d
JH
373struct string_slice {
374 size_t len;
375 const char *str;
376};
377
378static int ref_entry_cmp_sslice(const void *key_, const void *ent_)
379{
c971ddfd
RS
380 const struct string_slice *key = key_;
381 const struct ref_entry *ent = *(const struct ref_entry * const *)ent_;
382 int cmp = strncmp(key->str, ent->name, key->len);
e1980c9d
JH
383 if (cmp)
384 return cmp;
c971ddfd 385 return '\0' - (unsigned char)ent->name[key->len];
e1980c9d
JH
386}
387
432ad41e 388/*
9fc0a648
MH
389 * Return the index of the entry with the given refname from the
390 * ref_dir (non-recursively), sorting dir if necessary. Return -1 if
391 * no such entry is found. dir must already be complete.
432ad41e 392 */
9fc0a648 393static int search_ref_dir(struct ref_dir *dir, const char *refname, size_t len)
bc5fd6d3 394{
e1980c9d
JH
395 struct ref_entry **r;
396 struct string_slice key;
bc5fd6d3 397
432ad41e 398 if (refname == NULL || !dir->nr)
9fc0a648 399 return -1;
bc5fd6d3 400
d3177275 401 sort_ref_dir(dir);
e1980c9d
JH
402 key.len = len;
403 key.str = refname;
404 r = bsearch(&key, dir->entries, dir->nr, sizeof(*dir->entries),
405 ref_entry_cmp_sslice);
bc5fd6d3
MH
406
407 if (r == NULL)
9fc0a648 408 return -1;
bc5fd6d3 409
9fc0a648 410 return r - dir->entries;
bc5fd6d3
MH
411}
412
f348ac92
MH
413/*
414 * Search for a directory entry directly within dir (without
415 * recursing). Sort dir if necessary. subdirname must be a directory
416 * name (i.e., end in '/'). If mkdir is set, then create the
417 * directory if it is missing; otherwise, return NULL if the desired
28e6a34e 418 * directory cannot be found. dir must already be complete.
f348ac92 419 */
3f3aa1bc 420static struct ref_dir *search_for_subdir(struct ref_dir *dir,
dd02e728
RS
421 const char *subdirname, size_t len,
422 int mkdir)
f348ac92 423{
9fc0a648
MH
424 int entry_index = search_ref_dir(dir, subdirname, len);
425 struct ref_entry *entry;
426 if (entry_index == -1) {
f348ac92
MH
427 if (!mkdir)
428 return NULL;
28e6a34e
MH
429 /*
430 * Since dir is complete, the absence of a subdir
431 * means that the subdir really doesn't exist;
432 * therefore, create an empty record for it but mark
433 * the record complete.
434 */
b9146f51 435 entry = create_dir_entry(dir->ref_cache, subdirname, len, 0);
f348ac92 436 add_entry_to_dir(dir, entry);
9fc0a648
MH
437 } else {
438 entry = dir->entries[entry_index];
f348ac92 439 }
3f3aa1bc 440 return get_ref_dir(entry);
f348ac92
MH
441}
442
432ad41e
MH
443/*
444 * If refname is a reference name, find the ref_dir within the dir
445 * tree that should hold refname. If refname is a directory name
446 * (i.e., ends in '/'), then return that ref_dir itself. dir must
28e6a34e
MH
447 * represent the top-level directory and must already be complete.
448 * Sort ref_dirs and recurse into subdirectories as necessary. If
449 * mkdir is set, then create any missing directories; otherwise,
450 * return NULL if the desired directory cannot be found.
432ad41e
MH
451 */
452static struct ref_dir *find_containing_dir(struct ref_dir *dir,
453 const char *refname, int mkdir)
454{
5fa04418 455 const char *slash;
5fa04418 456 for (slash = strchr(refname, '/'); slash; slash = strchr(slash + 1, '/')) {
dd02e728 457 size_t dirnamelen = slash - refname + 1;
3f3aa1bc 458 struct ref_dir *subdir;
dd02e728 459 subdir = search_for_subdir(dir, refname, dirnamelen, mkdir);
663c1295
JH
460 if (!subdir) {
461 dir = NULL;
f348ac92 462 break;
432ad41e 463 }
3f3aa1bc 464 dir = subdir;
432ad41e
MH
465 }
466
432ad41e
MH
467 return dir;
468}
469
470/*
471 * Find the value entry with the given name in dir, sorting ref_dirs
472 * and recursing into subdirectories as necessary. If the name is not
473 * found or it corresponds to a directory entry, return NULL.
474 */
475static struct ref_entry *find_ref(struct ref_dir *dir, const char *refname)
476{
9fc0a648 477 int entry_index;
432ad41e
MH
478 struct ref_entry *entry;
479 dir = find_containing_dir(dir, refname, 0);
480 if (!dir)
481 return NULL;
9fc0a648
MH
482 entry_index = search_ref_dir(dir, refname, strlen(refname));
483 if (entry_index == -1)
484 return NULL;
485 entry = dir->entries[entry_index];
486 return (entry->flag & REF_DIR) ? NULL : entry;
432ad41e
MH
487}
488
506a760d
MH
489/*
490 * Remove the entry with the given name from dir, recursing into
491 * subdirectories as necessary. If refname is the name of a directory
492 * (i.e., ends with '/'), then remove the directory and its contents.
493 * If the removal was successful, return the number of entries
494 * remaining in the directory entry that contained the deleted entry.
495 * If the name was not found, return -1. Please note that this
496 * function only deletes the entry from the cache; it does not delete
497 * it from the filesystem or ensure that other cache entries (which
498 * might be symbolic references to the removed entry) are updated.
499 * Nor does it remove any containing dir entries that might be made
500 * empty by the removal. dir must represent the top-level directory
501 * and must already be complete.
502 */
503static int remove_entry(struct ref_dir *dir, const char *refname)
504{
505 int refname_len = strlen(refname);
506 int entry_index;
507 struct ref_entry *entry;
508 int is_dir = refname[refname_len - 1] == '/';
509 if (is_dir) {
510 /*
511 * refname represents a reference directory. Remove
512 * the trailing slash; otherwise we will get the
513 * directory *representing* refname rather than the
514 * one *containing* it.
515 */
516 char *dirname = xmemdupz(refname, refname_len - 1);
517 dir = find_containing_dir(dir, dirname, 0);
518 free(dirname);
519 } else {
520 dir = find_containing_dir(dir, refname, 0);
521 }
522 if (!dir)
523 return -1;
524 entry_index = search_ref_dir(dir, refname, refname_len);
525 if (entry_index == -1)
526 return -1;
527 entry = dir->entries[entry_index];
528
529 memmove(&dir->entries[entry_index],
530 &dir->entries[entry_index + 1],
531 (dir->nr - entry_index - 1) * sizeof(*dir->entries)
532 );
533 dir->nr--;
534 if (dir->sorted > entry_index)
535 dir->sorted--;
536 free_ref_entry(entry);
537 return dir->nr;
432ad41e
MH
538}
539
540/*
541 * Add a ref_entry to the ref_dir (unsorted), recursing into
542 * subdirectories as necessary. dir must represent the top-level
543 * directory. Return 0 on success.
544 */
545static int add_ref(struct ref_dir *dir, struct ref_entry *ref)
546{
547 dir = find_containing_dir(dir, ref->name, 1);
548 if (!dir)
549 return -1;
550 add_entry_to_dir(dir, ref);
551 return 0;
552}
553
202a56a9
MH
554/*
555 * Emit a warning and return true iff ref1 and ref2 have the same name
556 * and the same sha1. Die if they have the same name but different
557 * sha1s.
558 */
559static int is_dup_ref(const struct ref_entry *ref1, const struct ref_entry *ref2)
560{
432ad41e 561 if (strcmp(ref1->name, ref2->name))
202a56a9 562 return 0;
432ad41e
MH
563
564 /* Duplicate name; make sure that they don't conflict: */
565
566 if ((ref1->flag & REF_DIR) || (ref2->flag & REF_DIR))
567 /* This is impossible by construction */
568 die("Reference directory conflict: %s", ref1->name);
569
570 if (hashcmp(ref1->u.value.sha1, ref2->u.value.sha1))
571 die("Duplicated ref, and SHA1s don't match: %s", ref1->name);
572
573 warning("Duplicated ref: %s", ref1->name);
574 return 1;
202a56a9
MH
575}
576
e6ed3ca6 577/*
432ad41e
MH
578 * Sort the entries in dir non-recursively (if they are not already
579 * sorted) and remove any duplicate entries.
e6ed3ca6 580 */
d3177275 581static void sort_ref_dir(struct ref_dir *dir)
e9c4c111 582{
202a56a9 583 int i, j;
81a79d8e 584 struct ref_entry *last = NULL;
c774aab9 585
e6ed3ca6
MH
586 /*
587 * This check also prevents passing a zero-length array to qsort(),
588 * which is a problem on some platforms.
589 */
d3177275 590 if (dir->sorted == dir->nr)
e9c4c111 591 return;
c774aab9 592
d3177275 593 qsort(dir->entries, dir->nr, sizeof(*dir->entries), ref_entry_cmp);
c774aab9 594
81a79d8e
MH
595 /* Remove any duplicates: */
596 for (i = 0, j = 0; j < dir->nr; j++) {
597 struct ref_entry *entry = dir->entries[j];
598 if (last && is_dup_ref(last, entry))
599 free_ref_entry(entry);
600 else
601 last = dir->entries[i++] = entry;
e9c4c111 602 }
81a79d8e 603 dir->sorted = dir->nr = i;
e9c4c111 604}
c774aab9 605
fcce1703
MH
606/* Include broken references in a do_for_each_ref*() iteration: */
607#define DO_FOR_EACH_INCLUDE_BROKEN 0x01
c774aab9 608
662428f4
MH
609/*
610 * Return true iff the reference described by entry can be resolved to
611 * an object in the database. Emit a warning if the referred-to
612 * object does not exist.
613 */
614static int ref_resolves_to_object(struct ref_entry *entry)
615{
616 if (entry->flag & REF_ISBROKEN)
617 return 0;
618 if (!has_sha1_file(entry->u.value.sha1)) {
619 error("%s does not point to a valid object!", entry->name);
620 return 0;
621 }
622 return 1;
623}
c774aab9 624
7d76fdc8
MH
625/*
626 * current_ref is a performance hack: when iterating over references
627 * using the for_each_ref*() functions, current_ref is set to the
628 * current reference's entry before calling the callback function. If
629 * the callback function calls peel_ref(), then peel_ref() first
630 * checks whether the reference to be peeled is the current reference
631 * (it usually is) and if so, returns that reference's peeled version
632 * if it is available. This avoids a refname lookup in a common case.
633 */
bc5fd6d3 634static struct ref_entry *current_ref;
c774aab9 635
624cac35
MH
636typedef int each_ref_entry_fn(struct ref_entry *entry, void *cb_data);
637
638struct ref_entry_cb {
639 const char *base;
640 int trim;
641 int flags;
642 each_ref_fn *fn;
643 void *cb_data;
644};
645
fcce1703 646/*
624cac35
MH
647 * Handle one reference in a do_for_each_ref*()-style iteration,
648 * calling an each_ref_fn for each entry.
fcce1703 649 */
624cac35 650static int do_one_ref(struct ref_entry *entry, void *cb_data)
bc5fd6d3 651{
624cac35 652 struct ref_entry_cb *data = cb_data;
d0cf51e9 653 struct ref_entry *old_current_ref;
429213e4 654 int retval;
d0cf51e9 655
59556548 656 if (!starts_with(entry->name, data->base))
bc5fd6d3 657 return 0;
c774aab9 658
624cac35 659 if (!(data->flags & DO_FOR_EACH_INCLUDE_BROKEN) &&
662428f4 660 !ref_resolves_to_object(entry))
bc5fd6d3 661 return 0;
c774aab9 662
d0cf51e9
MH
663 /* Store the old value, in case this is a recursive call: */
664 old_current_ref = current_ref;
bc5fd6d3 665 current_ref = entry;
624cac35
MH
666 retval = data->fn(entry->name + data->trim, entry->u.value.sha1,
667 entry->flag, data->cb_data);
d0cf51e9 668 current_ref = old_current_ref;
429213e4 669 return retval;
bc5fd6d3 670}
c774aab9 671
c36b5bc2 672/*
d3177275 673 * Call fn for each reference in dir that has index in the range
432ad41e
MH
674 * offset <= index < dir->nr. Recurse into subdirectories that are in
675 * that index range, sorting them before iterating. This function
624cac35
MH
676 * does not sort dir itself; it should be sorted beforehand. fn is
677 * called for all references, including broken ones.
c36b5bc2 678 */
624cac35
MH
679static int do_for_each_entry_in_dir(struct ref_dir *dir, int offset,
680 each_ref_entry_fn fn, void *cb_data)
c36b5bc2
MH
681{
682 int i;
d3177275
MH
683 assert(dir->sorted == dir->nr);
684 for (i = offset; i < dir->nr; i++) {
432ad41e
MH
685 struct ref_entry *entry = dir->entries[i];
686 int retval;
687 if (entry->flag & REF_DIR) {
d7826d54
MH
688 struct ref_dir *subdir = get_ref_dir(entry);
689 sort_ref_dir(subdir);
624cac35 690 retval = do_for_each_entry_in_dir(subdir, 0, fn, cb_data);
432ad41e 691 } else {
624cac35 692 retval = fn(entry, cb_data);
432ad41e 693 }
c36b5bc2
MH
694 if (retval)
695 return retval;
696 }
697 return 0;
698}
699
b3fd060f 700/*
d3177275 701 * Call fn for each reference in the union of dir1 and dir2, in order
432ad41e
MH
702 * by refname. Recurse into subdirectories. If a value entry appears
703 * in both dir1 and dir2, then only process the version that is in
704 * dir2. The input dirs must already be sorted, but subdirs will be
624cac35
MH
705 * sorted as needed. fn is called for all references, including
706 * broken ones.
b3fd060f 707 */
624cac35
MH
708static int do_for_each_entry_in_dirs(struct ref_dir *dir1,
709 struct ref_dir *dir2,
710 each_ref_entry_fn fn, void *cb_data)
b3fd060f
MH
711{
712 int retval;
713 int i1 = 0, i2 = 0;
714
d3177275
MH
715 assert(dir1->sorted == dir1->nr);
716 assert(dir2->sorted == dir2->nr);
432ad41e
MH
717 while (1) {
718 struct ref_entry *e1, *e2;
719 int cmp;
720 if (i1 == dir1->nr) {
624cac35 721 return do_for_each_entry_in_dir(dir2, i2, fn, cb_data);
432ad41e
MH
722 }
723 if (i2 == dir2->nr) {
624cac35 724 return do_for_each_entry_in_dir(dir1, i1, fn, cb_data);
432ad41e
MH
725 }
726 e1 = dir1->entries[i1];
727 e2 = dir2->entries[i2];
728 cmp = strcmp(e1->name, e2->name);
729 if (cmp == 0) {
730 if ((e1->flag & REF_DIR) && (e2->flag & REF_DIR)) {
731 /* Both are directories; descend them in parallel. */
d7826d54
MH
732 struct ref_dir *subdir1 = get_ref_dir(e1);
733 struct ref_dir *subdir2 = get_ref_dir(e2);
734 sort_ref_dir(subdir1);
735 sort_ref_dir(subdir2);
624cac35
MH
736 retval = do_for_each_entry_in_dirs(
737 subdir1, subdir2, fn, cb_data);
432ad41e
MH
738 i1++;
739 i2++;
740 } else if (!(e1->flag & REF_DIR) && !(e2->flag & REF_DIR)) {
741 /* Both are references; ignore the one from dir1. */
624cac35 742 retval = fn(e2, cb_data);
432ad41e
MH
743 i1++;
744 i2++;
745 } else {
746 die("conflict between reference and directory: %s",
747 e1->name);
748 }
b3fd060f 749 } else {
432ad41e
MH
750 struct ref_entry *e;
751 if (cmp < 0) {
752 e = e1;
b3fd060f 753 i1++;
432ad41e
MH
754 } else {
755 e = e2;
756 i2++;
757 }
758 if (e->flag & REF_DIR) {
d7826d54
MH
759 struct ref_dir *subdir = get_ref_dir(e);
760 sort_ref_dir(subdir);
624cac35
MH
761 retval = do_for_each_entry_in_dir(
762 subdir, 0, fn, cb_data);
432ad41e 763 } else {
624cac35 764 retval = fn(e, cb_data);
b3fd060f
MH
765 }
766 }
767 if (retval)
768 return retval;
769 }
b3fd060f
MH
770}
771
98eeb09e
JK
772/*
773 * Load all of the refs from the dir into our in-memory cache. The hard work
774 * of loading loose refs is done by get_ref_dir(), so we just need to recurse
775 * through all of the sub-directories. We do not even need to care about
776 * sorting, as traversal order does not matter to us.
777 */
778static void prime_ref_dir(struct ref_dir *dir)
779{
780 int i;
781 for (i = 0; i < dir->nr; i++) {
782 struct ref_entry *entry = dir->entries[i];
783 if (entry->flag & REF_DIR)
784 prime_ref_dir(get_ref_dir(entry));
785 }
786}
cbe73331
JK
787
788static int entry_matches(struct ref_entry *entry, const char *refname)
d66da478 789{
cbe73331 790 return refname && !strcmp(entry->name, refname);
5a4d4947
MH
791}
792
cbe73331
JK
793struct nonmatching_ref_data {
794 const char *skip;
795 struct ref_entry *found;
5a4d4947
MH
796};
797
cbe73331 798static int nonmatching_ref_fn(struct ref_entry *entry, void *vdata)
5a4d4947 799{
cbe73331
JK
800 struct nonmatching_ref_data *data = vdata;
801
802 if (entry_matches(entry, data->skip))
5a4d4947 803 return 0;
cbe73331
JK
804
805 data->found = entry;
806 return 1;
807}
808
809static void report_refname_conflict(struct ref_entry *entry,
810 const char *refname)
811{
812 error("'%s' exists; cannot create '%s'", entry->name, refname);
d66da478
MH
813}
814
bc5fd6d3
MH
815/*
816 * Return true iff a reference named refname could be created without
624cac35 817 * conflicting with the name of an existing reference in dir. If
5a4d4947
MH
818 * oldrefname is non-NULL, ignore potential conflicts with oldrefname
819 * (e.g., because oldrefname is scheduled for deletion in the same
bc5fd6d3 820 * operation).
cbe73331
JK
821 *
822 * Two reference names conflict if one of them exactly matches the
823 * leading components of the other; e.g., "foo/bar" conflicts with
824 * both "foo" and with "foo/bar/baz" but not with "foo/bar" or
825 * "foo/barbados".
bc5fd6d3
MH
826 */
827static int is_refname_available(const char *refname, const char *oldrefname,
d3177275 828 struct ref_dir *dir)
bc5fd6d3 829{
cbe73331
JK
830 const char *slash;
831 size_t len;
832 int pos;
833 char *dirname;
5a4d4947 834
cbe73331
JK
835 for (slash = strchr(refname, '/'); slash; slash = strchr(slash + 1, '/')) {
836 /*
837 * We are still at a leading dir of the refname; we are
838 * looking for a conflict with a leaf entry.
839 *
840 * If we find one, we still must make sure it is
841 * not "oldrefname".
842 */
843 pos = search_ref_dir(dir, refname, slash - refname);
844 if (pos >= 0) {
845 struct ref_entry *entry = dir->entries[pos];
846 if (entry_matches(entry, oldrefname))
847 return 1;
848 report_refname_conflict(entry, refname);
849 return 0;
850 }
851
852
853 /*
854 * Otherwise, we can try to continue our search with
855 * the next component; if we come up empty, we know
856 * there is nothing under this whole prefix.
857 */
858 pos = search_ref_dir(dir, refname, slash + 1 - refname);
859 if (pos < 0)
860 return 1;
861
862 dir = get_ref_dir(dir->entries[pos]);
863 }
864
865 /*
866 * We are at the leaf of our refname; we want to
867 * make sure there are no directories which match it.
868 */
869 len = strlen(refname);
870 dirname = xmallocz(len + 1);
871 sprintf(dirname, "%s/", refname);
872 pos = search_ref_dir(dir, dirname, len + 1);
873 free(dirname);
874
875 if (pos >= 0) {
876 /*
877 * We found a directory named "refname". It is a
878 * problem iff it contains any ref that is not
879 * "oldrefname".
880 */
881 struct ref_entry *entry = dir->entries[pos];
882 struct ref_dir *dir = get_ref_dir(entry);
883 struct nonmatching_ref_data data;
884
885 data.skip = oldrefname;
886 sort_ref_dir(dir);
887 if (!do_for_each_entry_in_dir(dir, 0, nonmatching_ref_fn, &data))
888 return 1;
889
890 report_refname_conflict(data.found, refname);
5a4d4947 891 return 0;
bc5fd6d3 892 }
cbe73331
JK
893
894 /*
895 * There is no point in searching for another leaf
896 * node which matches it; such an entry would be the
897 * ref we are looking for, not a conflict.
898 */
bc5fd6d3 899 return 1;
e1e22e37
LT
900}
901
2fff7812
MH
902struct packed_ref_cache {
903 struct ref_entry *root;
9f69d297 904
5f5e2a88
MH
905 /*
906 * Count of references to the data structure in this instance,
907 * including the pointer from ref_cache::packed if any. The
908 * data will not be freed as long as the reference count is
909 * nonzero.
910 */
911 unsigned int referrers;
912
9f69d297
MH
913 /*
914 * Iff the packed-refs file associated with this instance is
915 * currently locked for writing, this points at the associated
4f6b83e3
MH
916 * lock (which is owned by somebody else). The referrer count
917 * is also incremented when the file is locked and decremented
918 * when it is unlocked.
9f69d297
MH
919 */
920 struct lock_file *lock;
ca919930
JK
921
922 /* The metadata from when this packed-refs cache was read */
923 struct stat_validity validity;
2fff7812
MH
924};
925
5e290ff7
JH
926/*
927 * Future: need to be in "struct repository"
928 * when doing a full libification.
929 */
79c7ca54
MH
930static struct ref_cache {
931 struct ref_cache *next;
d12229f5 932 struct ref_entry *loose;
2fff7812 933 struct packed_ref_cache *packed;
9da31cb0
MH
934 /*
935 * The submodule name, or "" for the main repo. We allocate
936 * length 1 rather than FLEX_ARRAY so that the main ref_cache
937 * is initialized correctly.
938 */
939 char name[1];
940} ref_cache, *submodule_ref_caches;
0e88c130 941
9f69d297
MH
942/* Lock used for the main packed-refs file: */
943static struct lock_file packlock;
944
5f5e2a88
MH
945/*
946 * Increment the reference count of *packed_refs.
947 */
948static void acquire_packed_ref_cache(struct packed_ref_cache *packed_refs)
949{
950 packed_refs->referrers++;
951}
952
953/*
954 * Decrease the reference count of *packed_refs. If it goes to zero,
955 * free *packed_refs and return true; otherwise return false.
956 */
957static int release_packed_ref_cache(struct packed_ref_cache *packed_refs)
958{
959 if (!--packed_refs->referrers) {
960 free_ref_entry(packed_refs->root);
ca919930 961 stat_validity_clear(&packed_refs->validity);
5f5e2a88
MH
962 free(packed_refs);
963 return 1;
964 } else {
965 return 0;
966 }
967}
968
760c4512 969static void clear_packed_ref_cache(struct ref_cache *refs)
e1e22e37 970{
d12229f5 971 if (refs->packed) {
5f5e2a88
MH
972 struct packed_ref_cache *packed_refs = refs->packed;
973
974 if (packed_refs->lock)
9f69d297 975 die("internal error: packed-ref cache cleared while locked");
d12229f5 976 refs->packed = NULL;
5f5e2a88 977 release_packed_ref_cache(packed_refs);
d12229f5 978 }
5e290ff7 979}
e1e22e37 980
760c4512
MH
981static void clear_loose_ref_cache(struct ref_cache *refs)
982{
d12229f5
MH
983 if (refs->loose) {
984 free_ref_entry(refs->loose);
985 refs->loose = NULL;
986 }
760c4512
MH
987}
988
79c7ca54 989static struct ref_cache *create_ref_cache(const char *submodule)
e5dbf605 990{
ce40979c 991 int len;
79c7ca54 992 struct ref_cache *refs;
ce40979c
MH
993 if (!submodule)
994 submodule = "";
995 len = strlen(submodule) + 1;
79c7ca54 996 refs = xcalloc(1, sizeof(struct ref_cache) + len);
ce40979c 997 memcpy(refs->name, submodule, len);
e5dbf605
MH
998 return refs;
999}
1000
4349a668 1001/*
79c7ca54 1002 * Return a pointer to a ref_cache for the specified submodule. For
4349a668
MH
1003 * the main repository, use submodule==NULL. The returned structure
1004 * will be allocated and initialized but not necessarily populated; it
1005 * should not be freed.
1006 */
79c7ca54 1007static struct ref_cache *get_ref_cache(const char *submodule)
4349a668 1008{
9da31cb0
MH
1009 struct ref_cache *refs;
1010
1011 if (!submodule || !*submodule)
1012 return &ref_cache;
1013
1014 for (refs = submodule_ref_caches; refs; refs = refs->next)
0e88c130
MH
1015 if (!strcmp(submodule, refs->name))
1016 return refs;
0e88c130 1017
79c7ca54 1018 refs = create_ref_cache(submodule);
9da31cb0
MH
1019 refs->next = submodule_ref_caches;
1020 submodule_ref_caches = refs;
0e88c130 1021 return refs;
4349a668
MH
1022}
1023
3feb4f0c
MH
1024/* The length of a peeled reference line in packed-refs, including EOL: */
1025#define PEELED_LINE_LENGTH 42
1026
694b7a19
MH
1027/*
1028 * The packed-refs header line that we write out. Perhaps other
1029 * traits will be added later. The trailing space is required.
1030 */
1031static const char PACKED_REFS_HEADER[] =
1032 "# pack-refs with: peeled fully-peeled \n";
1033
bc5fd6d3
MH
1034/*
1035 * Parse one line from a packed-refs file. Write the SHA1 to sha1.
1036 * Return a pointer to the refname within the line (null-terminated),
1037 * or NULL if there was a problem.
1038 */
1039static const char *parse_ref_line(char *line, unsigned char *sha1)
1040{
1041 /*
1042 * 42: the answer to everything.
1043 *
1044 * In this case, it happens to be the answer to
1045 * 40 (length of sha1 hex representation)
1046 * +1 (space in between hex and name)
1047 * +1 (newline at the end of the line)
1048 */
1049 int len = strlen(line) - 42;
1050
1051 if (len <= 0)
1052 return NULL;
1053 if (get_sha1_hex(line, sha1) < 0)
1054 return NULL;
1055 if (!isspace(line[40]))
1056 return NULL;
1057 line += 41;
1058 if (isspace(*line))
1059 return NULL;
1060 if (line[len] != '\n')
1061 return NULL;
1062 line[len] = 0;
1063
1064 return line;
1065}
1066
c29c46fa
MH
1067/*
1068 * Read f, which is a packed-refs file, into dir.
1069 *
1070 * A comment line of the form "# pack-refs with: " may contain zero or
1071 * more traits. We interpret the traits as follows:
1072 *
1073 * No traits:
1074 *
1075 * Probably no references are peeled. But if the file contains a
1076 * peeled value for a reference, we will use it.
1077 *
1078 * peeled:
1079 *
1080 * References under "refs/tags/", if they *can* be peeled, *are*
1081 * peeled in this file. References outside of "refs/tags/" are
1082 * probably not peeled even if they could have been, but if we find
1083 * a peeled value for such a reference we will use it.
1084 *
1085 * fully-peeled:
1086 *
1087 * All references in the file that can be peeled are peeled.
1088 * Inversely (and this is more important), any references in the
1089 * file for which no peeled value is recorded is not peelable. This
1090 * trait should typically be written alongside "peeled" for
1091 * compatibility with older clients, but we do not require it
1092 * (i.e., "peeled" is a no-op if "fully-peeled" is set).
1093 */
d3177275 1094static void read_packed_refs(FILE *f, struct ref_dir *dir)
f4204ab9 1095{
e9c4c111 1096 struct ref_entry *last = NULL;
f4204ab9 1097 char refline[PATH_MAX];
c29c46fa 1098 enum { PEELED_NONE, PEELED_TAGS, PEELED_FULLY } peeled = PEELED_NONE;
f4204ab9
JH
1099
1100 while (fgets(refline, sizeof(refline), f)) {
1101 unsigned char sha1[20];
dfefa935 1102 const char *refname;
f4204ab9
JH
1103 static const char header[] = "# pack-refs with:";
1104
1105 if (!strncmp(refline, header, sizeof(header)-1)) {
1106 const char *traits = refline + sizeof(header) - 1;
c29c46fa
MH
1107 if (strstr(traits, " fully-peeled "))
1108 peeled = PEELED_FULLY;
1109 else if (strstr(traits, " peeled "))
1110 peeled = PEELED_TAGS;
f4204ab9
JH
1111 /* perhaps other traits later as well */
1112 continue;
1113 }
1114
dfefa935
MH
1115 refname = parse_ref_line(refline, sha1);
1116 if (refname) {
c29c46fa
MH
1117 last = create_ref_entry(refname, sha1, REF_ISPACKED, 1);
1118 if (peeled == PEELED_FULLY ||
59556548 1119 (peeled == PEELED_TAGS && starts_with(refname, "refs/tags/")))
c29c46fa 1120 last->flag |= REF_KNOWS_PEELED;
d3177275 1121 add_ref(dir, last);
f4204ab9
JH
1122 continue;
1123 }
1124 if (last &&
1125 refline[0] == '^' &&
3feb4f0c
MH
1126 strlen(refline) == PEELED_LINE_LENGTH &&
1127 refline[PEELED_LINE_LENGTH - 1] == '\n' &&
c29c46fa 1128 !get_sha1_hex(refline + 1, sha1)) {
593f1bb8 1129 hashcpy(last->u.value.peeled, sha1);
c29c46fa
MH
1130 /*
1131 * Regardless of what the file header said,
1132 * we definitely know the value of *this*
1133 * reference:
1134 */
1135 last->flag |= REF_KNOWS_PEELED;
1136 }
f4204ab9 1137 }
f4204ab9
JH
1138}
1139
2fff7812
MH
1140/*
1141 * Get the packed_ref_cache for the specified ref_cache, creating it
1142 * if necessary.
1143 */
1144static struct packed_ref_cache *get_packed_ref_cache(struct ref_cache *refs)
5e290ff7 1145{
ca919930
JK
1146 const char *packed_refs_file;
1147
1148 if (*refs->name)
1149 packed_refs_file = git_path_submodule(refs->name, "packed-refs");
1150 else
1151 packed_refs_file = git_path("packed-refs");
1152
1153 if (refs->packed &&
1154 !stat_validity_check(&refs->packed->validity, packed_refs_file))
1155 clear_packed_ref_cache(refs);
1156
d12229f5 1157 if (!refs->packed) {
4349a668 1158 FILE *f;
0bad611b 1159
2fff7812 1160 refs->packed = xcalloc(1, sizeof(*refs->packed));
5f5e2a88 1161 acquire_packed_ref_cache(refs->packed);
2fff7812 1162 refs->packed->root = create_dir_entry(refs, "", 0, 0);
4349a668 1163 f = fopen(packed_refs_file, "r");
e1e22e37 1164 if (f) {
ca919930 1165 stat_validity_update(&refs->packed->validity, fileno(f));
2fff7812 1166 read_packed_refs(f, get_ref_dir(refs->packed->root));
e1e22e37 1167 fclose(f);
e1e22e37 1168 }
e1e22e37 1169 }
2fff7812
MH
1170 return refs->packed;
1171}
1172
1173static struct ref_dir *get_packed_ref_dir(struct packed_ref_cache *packed_ref_cache)
1174{
1175 return get_ref_dir(packed_ref_cache->root);
1176}
1177
1178static struct ref_dir *get_packed_refs(struct ref_cache *refs)
1179{
1180 return get_packed_ref_dir(get_packed_ref_cache(refs));
e1e22e37
LT
1181}
1182
30249ee6
MH
1183void add_packed_ref(const char *refname, const unsigned char *sha1)
1184{
9f69d297
MH
1185 struct packed_ref_cache *packed_ref_cache =
1186 get_packed_ref_cache(&ref_cache);
1187
1188 if (!packed_ref_cache->lock)
1189 die("internal error: packed refs not locked");
1190 add_ref(get_packed_ref_dir(packed_ref_cache),
9da31cb0 1191 create_ref_entry(refname, sha1, REF_ISPACKED, 1));
30249ee6
MH
1192}
1193
abc39098 1194/*
28e6a34e
MH
1195 * Read the loose references from the namespace dirname into dir
1196 * (without recursing). dirname must end with '/'. dir must be the
1197 * directory entry corresponding to dirname.
abc39098 1198 */
423a1afc 1199static void read_loose_refs(const char *dirname, struct ref_dir *dir)
e1e22e37 1200{
423a1afc 1201 struct ref_cache *refs = dir->ref_cache;
d3177275 1202 DIR *d;
0bad611b 1203 const char *path;
d5fdae67 1204 struct dirent *de;
abc39098 1205 int dirnamelen = strlen(dirname);
72b64b44 1206 struct strbuf refname;
0bad611b 1207
3b124823 1208 if (*refs->name)
66a3d20b 1209 path = git_path_submodule(refs->name, "%s", dirname);
0bad611b 1210 else
66a3d20b 1211 path = git_path("%s", dirname);
0bad611b 1212
d3177275 1213 d = opendir(path);
d5fdae67
MH
1214 if (!d)
1215 return;
1216
66a3d20b
MH
1217 strbuf_init(&refname, dirnamelen + 257);
1218 strbuf_add(&refname, dirname, dirnamelen);
d5fdae67
MH
1219
1220 while ((de = readdir(d)) != NULL) {
1221 unsigned char sha1[20];
1222 struct stat st;
1223 int flag;
d5fdae67
MH
1224 const char *refdir;
1225
1226 if (de->d_name[0] == '.')
1227 continue;
2975c770 1228 if (ends_with(de->d_name, ".lock"))
d5fdae67 1229 continue;
72b64b44 1230 strbuf_addstr(&refname, de->d_name);
d5fdae67 1231 refdir = *refs->name
72b64b44
MH
1232 ? git_path_submodule(refs->name, "%s", refname.buf)
1233 : git_path("%s", refname.buf);
1234 if (stat(refdir, &st) < 0) {
1235 ; /* silently ignore */
1236 } else if (S_ISDIR(st.st_mode)) {
abc39098 1237 strbuf_addch(&refname, '/');
28e6a34e 1238 add_entry_to_dir(dir,
b9146f51
RS
1239 create_dir_entry(refs, refname.buf,
1240 refname.len, 1));
72b64b44 1241 } else {
3b124823 1242 if (*refs->name) {
f8948e2f 1243 hashclr(sha1);
0bad611b 1244 flag = 0;
72b64b44 1245 if (resolve_gitlink_ref(refs->name, refname.buf, sha1) < 0) {
0bad611b 1246 hashclr(sha1);
98ac34b2 1247 flag |= REF_ISBROKEN;
0bad611b 1248 }
72b64b44 1249 } else if (read_ref_full(refname.buf, sha1, 1, &flag)) {
09116a1c
JH
1250 hashclr(sha1);
1251 flag |= REF_ISBROKEN;
1252 }
9f2fb4a3
MH
1253 add_entry_to_dir(dir,
1254 create_ref_entry(refname.buf, sha1, flag, 1));
e1e22e37 1255 }
66a3d20b 1256 strbuf_setlen(&refname, dirnamelen);
e1e22e37 1257 }
72b64b44 1258 strbuf_release(&refname);
d5fdae67 1259 closedir(d);
e1e22e37
LT
1260}
1261
d3177275 1262static struct ref_dir *get_loose_refs(struct ref_cache *refs)
e1e22e37 1263{
d12229f5 1264 if (!refs->loose) {
28e6a34e
MH
1265 /*
1266 * Mark the top-level directory complete because we
1267 * are about to read the only subdirectory that can
1268 * hold references:
1269 */
b9146f51 1270 refs->loose = create_dir_entry(refs, "", 0, 0);
28e6a34e
MH
1271 /*
1272 * Create an incomplete entry for "refs/":
1273 */
1274 add_entry_to_dir(get_ref_dir(refs->loose),
b9146f51 1275 create_dir_entry(refs, "refs/", 5, 1));
e1e22e37 1276 }
d7826d54 1277 return get_ref_dir(refs->loose);
e1e22e37
LT
1278}
1279
ca8db142
LT
1280/* We allow "recursive" symbolic refs. Only within reason, though */
1281#define MAXDEPTH 5
0ebde32c
LT
1282#define MAXREFLEN (1024)
1283
e5fa45c1
JH
1284/*
1285 * Called by resolve_gitlink_ref_recursive() after it failed to read
b0626608
MH
1286 * from the loose refs in ref_cache refs. Find <refname> in the
1287 * packed-refs file for the submodule.
e5fa45c1 1288 */
b0626608 1289static int resolve_gitlink_packed_ref(struct ref_cache *refs,
85be1fe3 1290 const char *refname, unsigned char *sha1)
0ebde32c 1291{
2c5c66be 1292 struct ref_entry *ref;
d3177275 1293 struct ref_dir *dir = get_packed_refs(refs);
0ebde32c 1294
432ad41e 1295 ref = find_ref(dir, refname);
b0626608
MH
1296 if (ref == NULL)
1297 return -1;
1298
50546b15 1299 hashcpy(sha1, ref->u.value.sha1);
b0626608 1300 return 0;
0ebde32c
LT
1301}
1302
b0626608 1303static int resolve_gitlink_ref_recursive(struct ref_cache *refs,
85be1fe3 1304 const char *refname, unsigned char *sha1,
dfefa935 1305 int recursion)
0ebde32c 1306{
064d51dc 1307 int fd, len;
0ebde32c 1308 char buffer[128], *p;
064d51dc 1309 char *path;
0ebde32c 1310
064d51dc 1311 if (recursion > MAXDEPTH || strlen(refname) > MAXREFLEN)
0ebde32c 1312 return -1;
064d51dc
MH
1313 path = *refs->name
1314 ? git_path_submodule(refs->name, "%s", refname)
1315 : git_path("%s", refname);
1316 fd = open(path, O_RDONLY);
0ebde32c 1317 if (fd < 0)
b0626608 1318 return resolve_gitlink_packed_ref(refs, refname, sha1);
0ebde32c
LT
1319
1320 len = read(fd, buffer, sizeof(buffer)-1);
1321 close(fd);
1322 if (len < 0)
1323 return -1;
1324 while (len && isspace(buffer[len-1]))
1325 len--;
1326 buffer[len] = 0;
1327
1328 /* Was it a detached head or an old-fashioned symlink? */
85be1fe3 1329 if (!get_sha1_hex(buffer, sha1))
0ebde32c
LT
1330 return 0;
1331
1332 /* Symref? */
1333 if (strncmp(buffer, "ref:", 4))
1334 return -1;
1335 p = buffer + 4;
1336 while (isspace(*p))
1337 p++;
1338
064d51dc 1339 return resolve_gitlink_ref_recursive(refs, p, sha1, recursion+1);
0ebde32c
LT
1340}
1341
85be1fe3 1342int resolve_gitlink_ref(const char *path, const char *refname, unsigned char *sha1)
0ebde32c
LT
1343{
1344 int len = strlen(path), retval;
064d51dc 1345 char *submodule;
b0626608 1346 struct ref_cache *refs;
0ebde32c
LT
1347
1348 while (len && path[len-1] == '/')
1349 len--;
1350 if (!len)
1351 return -1;
b0626608
MH
1352 submodule = xstrndup(path, len);
1353 refs = get_ref_cache(submodule);
1354 free(submodule);
1355
064d51dc 1356 retval = resolve_gitlink_ref_recursive(refs, refname, sha1, 0);
0ebde32c
LT
1357 return retval;
1358}
ca8db142 1359
4886b89f 1360/*
63331581
MH
1361 * Return the ref_entry for the given refname from the packed
1362 * references. If it does not exist, return NULL.
4886b89f 1363 */
63331581 1364static struct ref_entry *get_packed_ref(const char *refname)
c224ca7f 1365{
9da31cb0 1366 return find_ref(get_packed_refs(&ref_cache), refname);
c224ca7f
MH
1367}
1368
47f534bf
MH
1369/*
1370 * A loose ref file doesn't exist; check for a packed ref. The
1371 * options are forwarded from resolve_safe_unsafe().
1372 */
1373static const char *handle_missing_loose_ref(const char *refname,
1374 unsigned char *sha1,
1375 int reading,
1376 int *flag)
1377{
1378 struct ref_entry *entry;
1379
1380 /*
1381 * The loose reference file does not exist; check for a packed
1382 * reference.
1383 */
1384 entry = get_packed_ref(refname);
1385 if (entry) {
1386 hashcpy(sha1, entry->u.value.sha1);
1387 if (flag)
1388 *flag |= REF_ISPACKED;
1389 return refname;
1390 }
1391 /* The reference is not a packed reference, either. */
1392 if (reading) {
1393 return NULL;
1394 } else {
1395 hashclr(sha1);
1396 return refname;
1397 }
1398}
1399
76d70dc0 1400/* This function needs to return a meaningful errno on failure */
8d68493f 1401const char *resolve_ref_unsafe(const char *refname, unsigned char *sha1, int reading, int *flag)
8a65ff76 1402{
0104ca09
HO
1403 int depth = MAXDEPTH;
1404 ssize_t len;
a876ed83 1405 char buffer[256];
dfefa935 1406 static char refname_buffer[256];
ca8db142 1407
8da19775
JH
1408 if (flag)
1409 *flag = 0;
1410
76d70dc0
RS
1411 if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL)) {
1412 errno = EINVAL;
8384d788 1413 return NULL;
76d70dc0 1414 }
8384d788 1415
a876ed83 1416 for (;;) {
55956350 1417 char path[PATH_MAX];
a876ed83
JH
1418 struct stat st;
1419 char *buf;
1420 int fd;
8a65ff76 1421
76d70dc0
RS
1422 if (--depth < 0) {
1423 errno = ELOOP;
a876ed83 1424 return NULL;
76d70dc0 1425 }
ca8db142 1426
dfefa935 1427 git_snpath(path, sizeof(path), "%s", refname);
c224ca7f 1428
fcb7c762
MH
1429 /*
1430 * We might have to loop back here to avoid a race
1431 * condition: first we lstat() the file, then we try
1432 * to read it as a link or as a file. But if somebody
1433 * changes the type of the file (file <-> directory
1434 * <-> symlink) between the lstat() and reading, then
1435 * we don't want to report that as an error but rather
1436 * try again starting with the lstat().
1437 */
1438 stat_ref:
a876ed83 1439 if (lstat(path, &st) < 0) {
47f534bf
MH
1440 if (errno == ENOENT)
1441 return handle_missing_loose_ref(refname, sha1,
1442 reading, flag);
1443 else
a876ed83 1444 return NULL;
a876ed83 1445 }
ca8db142 1446
a876ed83
JH
1447 /* Follow "normalized" - ie "refs/.." symlinks by hand */
1448 if (S_ISLNK(st.st_mode)) {
1449 len = readlink(path, buffer, sizeof(buffer)-1);
fcb7c762
MH
1450 if (len < 0) {
1451 if (errno == ENOENT || errno == EINVAL)
1452 /* inconsistent with lstat; retry */
1453 goto stat_ref;
1454 else
1455 return NULL;
1456 }
b54cb795 1457 buffer[len] = 0;
59556548 1458 if (starts_with(buffer, "refs/") &&
1f58a038 1459 !check_refname_format(buffer, 0)) {
dfefa935
MH
1460 strcpy(refname_buffer, buffer);
1461 refname = refname_buffer;
8da19775
JH
1462 if (flag)
1463 *flag |= REF_ISSYMREF;
a876ed83
JH
1464 continue;
1465 }
ca8db142 1466 }
a876ed83 1467
7a21632f
DS
1468 /* Is it a directory? */
1469 if (S_ISDIR(st.st_mode)) {
1470 errno = EISDIR;
1471 return NULL;
1472 }
1473
a876ed83
JH
1474 /*
1475 * Anything else, just open it and try to use it as
1476 * a ref
1477 */
1478 fd = open(path, O_RDONLY);
fcb7c762
MH
1479 if (fd < 0) {
1480 if (errno == ENOENT)
1481 /* inconsistent with lstat; retry */
1482 goto stat_ref;
1483 else
1484 return NULL;
1485 }
93d26e4c 1486 len = read_in_full(fd, buffer, sizeof(buffer)-1);
76d70dc0
RS
1487 if (len < 0) {
1488 int save_errno = errno;
1489 close(fd);
1490 errno = save_errno;
28775050 1491 return NULL;
76d70dc0
RS
1492 }
1493 close(fd);
28775050
MH
1494 while (len && isspace(buffer[len-1]))
1495 len--;
1496 buffer[len] = '\0';
a876ed83
JH
1497
1498 /*
1499 * Is it a symbolic ref?
1500 */
59556548 1501 if (!starts_with(buffer, "ref:")) {
2884c06a
MH
1502 /*
1503 * Please note that FETCH_HEAD has a second
1504 * line containing other data.
1505 */
1506 if (get_sha1_hex(buffer, sha1) ||
1507 (buffer[40] != '\0' && !isspace(buffer[40]))) {
1508 if (flag)
1509 *flag |= REF_ISBROKEN;
76d70dc0 1510 errno = EINVAL;
2884c06a
MH
1511 return NULL;
1512 }
1513 return refname;
1514 }
55956350
JH
1515 if (flag)
1516 *flag |= REF_ISSYMREF;
a876ed83 1517 buf = buffer + 4;
28775050
MH
1518 while (isspace(*buf))
1519 buf++;
313fb010 1520 if (check_refname_format(buf, REFNAME_ALLOW_ONELEVEL)) {
55956350
JH
1521 if (flag)
1522 *flag |= REF_ISBROKEN;
76d70dc0 1523 errno = EINVAL;
313fb010
MH
1524 return NULL;
1525 }
dfefa935 1526 refname = strcpy(refname_buffer, buf);
8a65ff76 1527 }
a876ed83
JH
1528}
1529
96ec7b1e
NTND
1530char *resolve_refdup(const char *ref, unsigned char *sha1, int reading, int *flag)
1531{
8cad4744 1532 const char *ret = resolve_ref_unsafe(ref, sha1, reading, flag);
96ec7b1e
NTND
1533 return ret ? xstrdup(ret) : NULL;
1534}
1535
d08bae7e
IL
1536/* The argument to filter_refs */
1537struct ref_filter {
1538 const char *pattern;
1539 each_ref_fn *fn;
1540 void *cb_data;
1541};
1542
dfefa935 1543int read_ref_full(const char *refname, unsigned char *sha1, int reading, int *flags)
a876ed83 1544{
8d68493f 1545 if (resolve_ref_unsafe(refname, sha1, reading, flags))
a876ed83
JH
1546 return 0;
1547 return -1;
8a65ff76
LT
1548}
1549
dfefa935 1550int read_ref(const char *refname, unsigned char *sha1)
c6893323 1551{
dfefa935 1552 return read_ref_full(refname, sha1, 1, NULL);
c6893323
NTND
1553}
1554
bc5fd6d3 1555int ref_exists(const char *refname)
ef06b918 1556{
bc5fd6d3
MH
1557 unsigned char sha1[20];
1558 return !!resolve_ref_unsafe(refname, sha1, 1, NULL);
ef06b918
JH
1559}
1560
85be1fe3 1561static int filter_refs(const char *refname, const unsigned char *sha1, int flags,
dfefa935 1562 void *data)
d08bae7e
IL
1563{
1564 struct ref_filter *filter = (struct ref_filter *)data;
eb07894f 1565 if (wildmatch(filter->pattern, refname, 0, NULL))
d08bae7e 1566 return 0;
85be1fe3 1567 return filter->fn(refname, sha1, flags, filter->cb_data);
d08bae7e
IL
1568}
1569
68cf8703
MH
1570enum peel_status {
1571 /* object was peeled successfully: */
1572 PEEL_PEELED = 0,
1573
1574 /*
1575 * object cannot be peeled because the named object (or an
1576 * object referred to by a tag in the peel chain), does not
1577 * exist.
1578 */
1579 PEEL_INVALID = -1,
1580
1581 /* object cannot be peeled because it is not a tag: */
9a489f3c
MH
1582 PEEL_NON_TAG = -2,
1583
1584 /* ref_entry contains no peeled value because it is a symref: */
1585 PEEL_IS_SYMREF = -3,
1586
1587 /*
1588 * ref_entry cannot be peeled because it is broken (i.e., the
1589 * symbolic reference cannot even be resolved to an object
1590 * name):
1591 */
1592 PEEL_BROKEN = -4
68cf8703
MH
1593};
1594
cb2ae1c4
MH
1595/*
1596 * Peel the named object; i.e., if the object is a tag, resolve the
68cf8703
MH
1597 * tag recursively until a non-tag is found. If successful, store the
1598 * result to sha1 and return PEEL_PEELED. If the object is not a tag
1599 * or is not valid, return PEEL_NON_TAG or PEEL_INVALID, respectively,
1600 * and leave sha1 unchanged.
cb2ae1c4 1601 */
68cf8703 1602static enum peel_status peel_object(const unsigned char *name, unsigned char *sha1)
cb2ae1c4
MH
1603{
1604 struct object *o = lookup_unknown_object(name);
1605
1606 if (o->type == OBJ_NONE) {
1607 int type = sha1_object_info(name, NULL);
8ff226a9 1608 if (type < 0 || !object_as_type(o, type, 0))
68cf8703 1609 return PEEL_INVALID;
cb2ae1c4
MH
1610 }
1611
1612 if (o->type != OBJ_TAG)
68cf8703 1613 return PEEL_NON_TAG;
cb2ae1c4
MH
1614
1615 o = deref_tag_noverify(o);
1616 if (!o)
68cf8703 1617 return PEEL_INVALID;
cb2ae1c4
MH
1618
1619 hashcpy(sha1, o->sha1);
68cf8703 1620 return PEEL_PEELED;
cb2ae1c4
MH
1621}
1622
9a489f3c 1623/*
f85354b5
MH
1624 * Peel the entry (if possible) and return its new peel_status. If
1625 * repeel is true, re-peel the entry even if there is an old peeled
1626 * value that is already stored in it.
694b7a19
MH
1627 *
1628 * It is OK to call this function with a packed reference entry that
1629 * might be stale and might even refer to an object that has since
1630 * been garbage-collected. In such a case, if the entry has
1631 * REF_KNOWS_PEELED then leave the status unchanged and return
1632 * PEEL_PEELED or PEEL_NON_TAG; otherwise, return PEEL_INVALID.
9a489f3c 1633 */
f85354b5 1634static enum peel_status peel_entry(struct ref_entry *entry, int repeel)
9a489f3c
MH
1635{
1636 enum peel_status status;
1637
f85354b5
MH
1638 if (entry->flag & REF_KNOWS_PEELED) {
1639 if (repeel) {
1640 entry->flag &= ~REF_KNOWS_PEELED;
1641 hashclr(entry->u.value.peeled);
1642 } else {
1643 return is_null_sha1(entry->u.value.peeled) ?
1644 PEEL_NON_TAG : PEEL_PEELED;
1645 }
1646 }
9a489f3c
MH
1647 if (entry->flag & REF_ISBROKEN)
1648 return PEEL_BROKEN;
1649 if (entry->flag & REF_ISSYMREF)
1650 return PEEL_IS_SYMREF;
1651
1652 status = peel_object(entry->u.value.sha1, entry->u.value.peeled);
1653 if (status == PEEL_PEELED || status == PEEL_NON_TAG)
1654 entry->flag |= REF_KNOWS_PEELED;
1655 return status;
1656}
1657
dfefa935 1658int peel_ref(const char *refname, unsigned char *sha1)
cf0adba7
JH
1659{
1660 int flag;
1661 unsigned char base[20];
cf0adba7 1662
dfefa935 1663 if (current_ref && (current_ref->name == refname
9a489f3c 1664 || !strcmp(current_ref->name, refname))) {
f85354b5 1665 if (peel_entry(current_ref, 0))
9a489f3c
MH
1666 return -1;
1667 hashcpy(sha1, current_ref->u.value.peeled);
1668 return 0;
0ae91be0
SP
1669 }
1670
dfefa935 1671 if (read_ref_full(refname, base, 1, &flag))
cf0adba7
JH
1672 return -1;
1673
9a489f3c
MH
1674 /*
1675 * If the reference is packed, read its ref_entry from the
1676 * cache in the hope that we already know its peeled value.
1677 * We only try this optimization on packed references because
1678 * (a) forcing the filling of the loose reference cache could
1679 * be expensive and (b) loose references anyway usually do not
1680 * have REF_KNOWS_PEELED.
1681 */
1682 if (flag & REF_ISPACKED) {
f361baeb 1683 struct ref_entry *r = get_packed_ref(refname);
9a489f3c 1684 if (r) {
f85354b5 1685 if (peel_entry(r, 0))
9a489f3c 1686 return -1;
593f1bb8 1687 hashcpy(sha1, r->u.value.peeled);
e9c4c111 1688 return 0;
cf0adba7 1689 }
cf0adba7
JH
1690 }
1691
cb2ae1c4 1692 return peel_object(base, sha1);
cf0adba7
JH
1693}
1694
bc5fd6d3
MH
1695struct warn_if_dangling_data {
1696 FILE *fp;
1697 const char *refname;
e6bea66d 1698 const struct string_list *refnames;
bc5fd6d3
MH
1699 const char *msg_fmt;
1700};
1701
1702static int warn_if_dangling_symref(const char *refname, const unsigned char *sha1,
1703 int flags, void *cb_data)
1704{
1705 struct warn_if_dangling_data *d = cb_data;
1706 const char *resolves_to;
1707 unsigned char junk[20];
1708
1709 if (!(flags & REF_ISSYMREF))
1710 return 0;
1711
1712 resolves_to = resolve_ref_unsafe(refname, junk, 0, NULL);
e6bea66d
JL
1713 if (!resolves_to
1714 || (d->refname
1715 ? strcmp(resolves_to, d->refname)
1716 : !string_list_has_string(d->refnames, resolves_to))) {
bc5fd6d3 1717 return 0;
e6bea66d 1718 }
bc5fd6d3
MH
1719
1720 fprintf(d->fp, d->msg_fmt, refname);
1be65eda 1721 fputc('\n', d->fp);
bc5fd6d3
MH
1722 return 0;
1723}
1724
1725void warn_dangling_symref(FILE *fp, const char *msg_fmt, const char *refname)
1726{
1727 struct warn_if_dangling_data data;
1728
1729 data.fp = fp;
1730 data.refname = refname;
e6bea66d
JL
1731 data.refnames = NULL;
1732 data.msg_fmt = msg_fmt;
1733 for_each_rawref(warn_if_dangling_symref, &data);
1734}
1735
1736void warn_dangling_symrefs(FILE *fp, const char *msg_fmt, const struct string_list *refnames)
1737{
1738 struct warn_if_dangling_data data;
1739
1740 data.fp = fp;
1741 data.refname = NULL;
1742 data.refnames = refnames;
bc5fd6d3
MH
1743 data.msg_fmt = msg_fmt;
1744 for_each_rawref(warn_if_dangling_symref, &data);
1745}
1746
fcce1703 1747/*
65cf102b 1748 * Call fn for each reference in the specified ref_cache, omitting
624cac35
MH
1749 * references not in the containing_dir of base. fn is called for all
1750 * references, including broken ones. If fn ever returns a non-zero
fcce1703
MH
1751 * value, stop the iteration and return that value; otherwise, return
1752 * 0.
1753 */
65cf102b 1754static int do_for_each_entry(struct ref_cache *refs, const char *base,
624cac35 1755 each_ref_entry_fn fn, void *cb_data)
8a65ff76 1756{
98eeb09e
JK
1757 struct packed_ref_cache *packed_ref_cache;
1758 struct ref_dir *loose_dir;
1759 struct ref_dir *packed_dir;
933ac036
MH
1760 int retval = 0;
1761
98eeb09e
JK
1762 /*
1763 * We must make sure that all loose refs are read before accessing the
1764 * packed-refs file; this avoids a race condition in which loose refs
1765 * are migrated to the packed-refs file by a simultaneous process, but
1766 * our in-memory view is from before the migration. get_packed_ref_cache()
1767 * takes care of making sure our view is up to date with what is on
1768 * disk.
1769 */
1770 loose_dir = get_loose_refs(refs);
933ac036 1771 if (base && *base) {
933ac036
MH
1772 loose_dir = find_containing_dir(loose_dir, base, 0);
1773 }
98eeb09e
JK
1774 if (loose_dir)
1775 prime_ref_dir(loose_dir);
1776
1777 packed_ref_cache = get_packed_ref_cache(refs);
8baf2bb9 1778 acquire_packed_ref_cache(packed_ref_cache);
98eeb09e 1779 packed_dir = get_packed_ref_dir(packed_ref_cache);
933ac036
MH
1780 if (base && *base) {
1781 packed_dir = find_containing_dir(packed_dir, base, 0);
933ac036
MH
1782 }
1783
1784 if (packed_dir && loose_dir) {
1785 sort_ref_dir(packed_dir);
1786 sort_ref_dir(loose_dir);
624cac35
MH
1787 retval = do_for_each_entry_in_dirs(
1788 packed_dir, loose_dir, fn, cb_data);
933ac036
MH
1789 } else if (packed_dir) {
1790 sort_ref_dir(packed_dir);
624cac35
MH
1791 retval = do_for_each_entry_in_dir(
1792 packed_dir, 0, fn, cb_data);
933ac036
MH
1793 } else if (loose_dir) {
1794 sort_ref_dir(loose_dir);
624cac35
MH
1795 retval = do_for_each_entry_in_dir(
1796 loose_dir, 0, fn, cb_data);
933ac036
MH
1797 }
1798
8baf2bb9 1799 release_packed_ref_cache(packed_ref_cache);
933ac036 1800 return retval;
8a65ff76
LT
1801}
1802
624cac35 1803/*
65cf102b 1804 * Call fn for each reference in the specified ref_cache for which the
624cac35
MH
1805 * refname begins with base. If trim is non-zero, then trim that many
1806 * characters off the beginning of each refname before passing the
1807 * refname to fn. flags can be DO_FOR_EACH_INCLUDE_BROKEN to include
1808 * broken references in the iteration. If fn ever returns a non-zero
1809 * value, stop the iteration and return that value; otherwise, return
1810 * 0.
1811 */
65cf102b
MH
1812static int do_for_each_ref(struct ref_cache *refs, const char *base,
1813 each_ref_fn fn, int trim, int flags, void *cb_data)
624cac35
MH
1814{
1815 struct ref_entry_cb data;
1816 data.base = base;
1817 data.trim = trim;
1818 data.flags = flags;
1819 data.fn = fn;
1820 data.cb_data = cb_data;
1821
65cf102b 1822 return do_for_each_entry(refs, base, do_one_ref, &data);
624cac35
MH
1823}
1824
0bad611b 1825static int do_head_ref(const char *submodule, each_ref_fn fn, void *cb_data)
723c31fe
LT
1826{
1827 unsigned char sha1[20];
8da19775
JH
1828 int flag;
1829
0bad611b
HV
1830 if (submodule) {
1831 if (resolve_gitlink_ref(submodule, "HEAD", sha1) == 0)
1832 return fn("HEAD", sha1, 0, cb_data);
1833
1834 return 0;
1835 }
1836
c6893323 1837 if (!read_ref_full("HEAD", sha1, 1, &flag))
8da19775 1838 return fn("HEAD", sha1, flag, cb_data);
0bad611b 1839
2f34ba32 1840 return 0;
723c31fe
LT
1841}
1842
0bad611b
HV
1843int head_ref(each_ref_fn fn, void *cb_data)
1844{
1845 return do_head_ref(NULL, fn, cb_data);
1846}
1847
9ef6aeb0
HV
1848int head_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)
1849{
1850 return do_head_ref(submodule, fn, cb_data);
1851}
1852
cb5d709f 1853int for_each_ref(each_ref_fn fn, void *cb_data)
8a65ff76 1854{
9da31cb0 1855 return do_for_each_ref(&ref_cache, "", fn, 0, 0, cb_data);
a62be77f
SE
1856}
1857
9ef6aeb0
HV
1858int for_each_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)
1859{
65cf102b 1860 return do_for_each_ref(get_ref_cache(submodule), "", fn, 0, 0, cb_data);
a62be77f
SE
1861}
1862
2a8177b6
CC
1863int for_each_ref_in(const char *prefix, each_ref_fn fn, void *cb_data)
1864{
9da31cb0 1865 return do_for_each_ref(&ref_cache, prefix, fn, strlen(prefix), 0, cb_data);
2a8177b6
CC
1866}
1867
9ef6aeb0
HV
1868int for_each_ref_in_submodule(const char *submodule, const char *prefix,
1869 each_ref_fn fn, void *cb_data)
1870{
65cf102b 1871 return do_for_each_ref(get_ref_cache(submodule), prefix, fn, strlen(prefix), 0, cb_data);
2a8177b6
CC
1872}
1873
cb5d709f 1874int for_each_tag_ref(each_ref_fn fn, void *cb_data)
a62be77f 1875{
2a8177b6 1876 return for_each_ref_in("refs/tags/", fn, cb_data);
a62be77f
SE
1877}
1878
9ef6aeb0
HV
1879int for_each_tag_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)
1880{
1881 return for_each_ref_in_submodule(submodule, "refs/tags/", fn, cb_data);
1882}
1883
cb5d709f 1884int for_each_branch_ref(each_ref_fn fn, void *cb_data)
a62be77f 1885{
2a8177b6 1886 return for_each_ref_in("refs/heads/", fn, cb_data);
a62be77f
SE
1887}
1888
9ef6aeb0
HV
1889int for_each_branch_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)
1890{
1891 return for_each_ref_in_submodule(submodule, "refs/heads/", fn, cb_data);
1892}
1893
cb5d709f 1894int for_each_remote_ref(each_ref_fn fn, void *cb_data)
a62be77f 1895{
2a8177b6 1896 return for_each_ref_in("refs/remotes/", fn, cb_data);
f8948e2f
JH
1897}
1898
9ef6aeb0
HV
1899int for_each_remote_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)
1900{
1901 return for_each_ref_in_submodule(submodule, "refs/remotes/", fn, cb_data);
1902}
1903
29268700
CC
1904int for_each_replace_ref(each_ref_fn fn, void *cb_data)
1905{
9da31cb0 1906 return do_for_each_ref(&ref_cache, "refs/replace/", fn, 13, 0, cb_data);
29268700
CC
1907}
1908
a1bea2c1
JT
1909int head_ref_namespaced(each_ref_fn fn, void *cb_data)
1910{
1911 struct strbuf buf = STRBUF_INIT;
1912 int ret = 0;
1913 unsigned char sha1[20];
1914 int flag;
1915
1916 strbuf_addf(&buf, "%sHEAD", get_git_namespace());
c6893323 1917 if (!read_ref_full(buf.buf, sha1, 1, &flag))
a1bea2c1
JT
1918 ret = fn(buf.buf, sha1, flag, cb_data);
1919 strbuf_release(&buf);
1920
1921 return ret;
1922}
1923
1924int for_each_namespaced_ref(each_ref_fn fn, void *cb_data)
1925{
1926 struct strbuf buf = STRBUF_INIT;
1927 int ret;
1928 strbuf_addf(&buf, "%srefs/", get_git_namespace());
9da31cb0 1929 ret = do_for_each_ref(&ref_cache, buf.buf, fn, 0, 0, cb_data);
a1bea2c1
JT
1930 strbuf_release(&buf);
1931 return ret;
1932}
1933
b09fe971
IL
1934int for_each_glob_ref_in(each_ref_fn fn, const char *pattern,
1935 const char *prefix, void *cb_data)
d08bae7e
IL
1936{
1937 struct strbuf real_pattern = STRBUF_INIT;
1938 struct ref_filter filter;
d08bae7e
IL
1939 int ret;
1940
59556548 1941 if (!prefix && !starts_with(pattern, "refs/"))
d08bae7e 1942 strbuf_addstr(&real_pattern, "refs/");
b09fe971
IL
1943 else if (prefix)
1944 strbuf_addstr(&real_pattern, prefix);
d08bae7e
IL
1945 strbuf_addstr(&real_pattern, pattern);
1946
894a9d33 1947 if (!has_glob_specials(pattern)) {
9517e6b8 1948 /* Append implied '/' '*' if not present. */
d08bae7e
IL
1949 if (real_pattern.buf[real_pattern.len - 1] != '/')
1950 strbuf_addch(&real_pattern, '/');
1951 /* No need to check for '*', there is none. */
1952 strbuf_addch(&real_pattern, '*');
1953 }
1954
1955 filter.pattern = real_pattern.buf;
1956 filter.fn = fn;
1957 filter.cb_data = cb_data;
1958 ret = for_each_ref(filter_refs, &filter);
1959
1960 strbuf_release(&real_pattern);
1961 return ret;
1962}
1963
b09fe971
IL
1964int for_each_glob_ref(each_ref_fn fn, const char *pattern, void *cb_data)
1965{
1966 return for_each_glob_ref_in(fn, pattern, NULL, cb_data);
1967}
1968
f8948e2f
JH
1969int for_each_rawref(each_ref_fn fn, void *cb_data)
1970{
9da31cb0 1971 return do_for_each_ref(&ref_cache, "", fn, 0,
f8948e2f 1972 DO_FOR_EACH_INCLUDE_BROKEN, cb_data);
8a65ff76
LT
1973}
1974
4577e483 1975const char *prettify_refname(const char *name)
a9c37a72 1976{
a9c37a72 1977 return name + (
59556548
CC
1978 starts_with(name, "refs/heads/") ? 11 :
1979 starts_with(name, "refs/tags/") ? 10 :
1980 starts_with(name, "refs/remotes/") ? 13 :
a9c37a72
DB
1981 0);
1982}
1983
54457fe5 1984static const char *ref_rev_parse_rules[] = {
79803322
SP
1985 "%.*s",
1986 "refs/%.*s",
1987 "refs/tags/%.*s",
1988 "refs/heads/%.*s",
1989 "refs/remotes/%.*s",
1990 "refs/remotes/%.*s/HEAD",
1991 NULL
1992};
1993
54457fe5 1994int refname_match(const char *abbrev_name, const char *full_name)
79803322
SP
1995{
1996 const char **p;
1997 const int abbrev_name_len = strlen(abbrev_name);
1998
54457fe5 1999 for (p = ref_rev_parse_rules; *p; p++) {
79803322
SP
2000 if (!strcmp(full_name, mkpath(*p, abbrev_name_len, abbrev_name))) {
2001 return 1;
2002 }
2003 }
2004
2005 return 0;
2006}
2007
835e3c99 2008/* This function should make sure errno is meaningful on error */
e5f38ec3 2009static struct ref_lock *verify_lock(struct ref_lock *lock,
4bd18c43
SP
2010 const unsigned char *old_sha1, int mustexist)
2011{
c6893323 2012 if (read_ref_full(lock->ref_name, lock->old_sha1, mustexist, NULL)) {
835e3c99 2013 int save_errno = errno;
434cd0cd 2014 error("Can't verify ref %s", lock->ref_name);
4bd18c43 2015 unlock_ref(lock);
835e3c99 2016 errno = save_errno;
4bd18c43
SP
2017 return NULL;
2018 }
a89fccd2 2019 if (hashcmp(lock->old_sha1, old_sha1)) {
434cd0cd 2020 error("Ref %s is at %s but expected %s", lock->ref_name,
4bd18c43
SP
2021 sha1_to_hex(lock->old_sha1), sha1_to_hex(old_sha1));
2022 unlock_ref(lock);
835e3c99 2023 errno = EBUSY;
4bd18c43
SP
2024 return NULL;
2025 }
2026 return lock;
2027}
2028
7155b727 2029static int remove_empty_directories(const char *file)
bc7127ef
JH
2030{
2031 /* we want to create a file but there is a directory there;
2032 * if that is an empty directory (or a directory that contains
2033 * only empty directories), remove them.
2034 */
7155b727 2035 struct strbuf path;
470a91ef 2036 int result, save_errno;
bc7127ef 2037
7155b727
JS
2038 strbuf_init(&path, 20);
2039 strbuf_addstr(&path, file);
2040
a0f4afbe 2041 result = remove_dir_recursively(&path, REMOVE_DIR_EMPTY_ONLY);
470a91ef 2042 save_errno = errno;
7155b727
JS
2043
2044 strbuf_release(&path);
470a91ef 2045 errno = save_errno;
7155b727
JS
2046
2047 return result;
bc7127ef
JH
2048}
2049
ff74f7f1
JH
2050/*
2051 * *string and *len will only be substituted, and *string returned (for
2052 * later free()ing) if the string passed in is a magic short-hand form
2053 * to name a branch.
2054 */
2055static char *substitute_branch_name(const char **string, int *len)
2056{
2057 struct strbuf buf = STRBUF_INIT;
cf99a761 2058 int ret = interpret_branch_name(*string, *len, &buf);
ff74f7f1
JH
2059
2060 if (ret == *len) {
2061 size_t size;
2062 *string = strbuf_detach(&buf, &size);
2063 *len = size;
2064 return (char *)*string;
2065 }
2066
2067 return NULL;
2068}
2069
2070int dwim_ref(const char *str, int len, unsigned char *sha1, char **ref)
2071{
2072 char *last_branch = substitute_branch_name(&str, &len);
2073 const char **p, *r;
2074 int refs_found = 0;
2075
2076 *ref = NULL;
2077 for (p = ref_rev_parse_rules; *p; p++) {
2078 char fullref[PATH_MAX];
2079 unsigned char sha1_from_ref[20];
2080 unsigned char *this_result;
2081 int flag;
2082
2083 this_result = refs_found ? sha1_from_ref : sha1;
2084 mksnpath(fullref, sizeof(fullref), *p, len, str);
8cad4744 2085 r = resolve_ref_unsafe(fullref, this_result, 1, &flag);
ff74f7f1
JH
2086 if (r) {
2087 if (!refs_found++)
2088 *ref = xstrdup(r);
2089 if (!warn_ambiguous_refs)
2090 break;
55956350 2091 } else if ((flag & REF_ISSYMREF) && strcmp(fullref, "HEAD")) {
ff74f7f1 2092 warning("ignoring dangling symref %s.", fullref);
55956350
JH
2093 } else if ((flag & REF_ISBROKEN) && strchr(fullref, '/')) {
2094 warning("ignoring broken ref %s.", fullref);
2095 }
ff74f7f1
JH
2096 }
2097 free(last_branch);
2098 return refs_found;
2099}
2100
2101int dwim_log(const char *str, int len, unsigned char *sha1, char **log)
2102{
2103 char *last_branch = substitute_branch_name(&str, &len);
2104 const char **p;
2105 int logs_found = 0;
2106
2107 *log = NULL;
2108 for (p = ref_rev_parse_rules; *p; p++) {
ff74f7f1
JH
2109 unsigned char hash[20];
2110 char path[PATH_MAX];
2111 const char *ref, *it;
2112
2113 mksnpath(path, sizeof(path), *p, len, str);
8cad4744 2114 ref = resolve_ref_unsafe(path, hash, 1, NULL);
ff74f7f1
JH
2115 if (!ref)
2116 continue;
4da58835 2117 if (reflog_exists(path))
ff74f7f1 2118 it = path;
4da58835 2119 else if (strcmp(ref, path) && reflog_exists(ref))
ff74f7f1
JH
2120 it = ref;
2121 else
2122 continue;
2123 if (!logs_found++) {
2124 *log = xstrdup(it);
2125 hashcpy(sha1, hash);
2126 }
2127 if (!warn_ambiguous_refs)
2128 break;
2129 }
2130 free(last_branch);
2131 return logs_found;
2132}
2133
88b680ae
RS
2134/*
2135 * Locks a "refs/" ref returning the lock on success and NULL on failure.
2136 * On failure errno is set to something meaningful.
2137 */
dfefa935
MH
2138static struct ref_lock *lock_ref_sha1_basic(const char *refname,
2139 const unsigned char *old_sha1,
2140 int flags, int *type_p)
4bd18c43 2141{
434cd0cd 2142 char *ref_file;
dfefa935 2143 const char *orig_refname = refname;
4bd18c43 2144 struct ref_lock *lock;
5cc3cef9 2145 int last_errno = 0;
acd3b9ec 2146 int type, lflags;
4431fcc4 2147 int mustexist = (old_sha1 && !is_null_sha1(old_sha1));
5bdd8d4a 2148 int missing = 0;
c4c61c76 2149 int attempts_remaining = 3;
4bd18c43
SP
2150
2151 lock = xcalloc(1, sizeof(struct ref_lock));
2152 lock->lock_fd = -1;
2153
8d68493f 2154 refname = resolve_ref_unsafe(refname, lock->old_sha1, mustexist, &type);
dfefa935 2155 if (!refname && errno == EISDIR) {
bc7127ef
JH
2156 /* we are trying to lock foo but we used to
2157 * have foo/bar which now does not exist;
2158 * it is normal for the empty directory 'foo'
2159 * to remain.
2160 */
dfefa935 2161 ref_file = git_path("%s", orig_refname);
5cc3cef9
JH
2162 if (remove_empty_directories(ref_file)) {
2163 last_errno = errno;
dfefa935 2164 error("there are still refs under '%s'", orig_refname);
5cc3cef9
JH
2165 goto error_return;
2166 }
8d68493f 2167 refname = resolve_ref_unsafe(orig_refname, lock->old_sha1, mustexist, &type);
bc7127ef 2168 }
68db31cc
SV
2169 if (type_p)
2170 *type_p = type;
dfefa935 2171 if (!refname) {
5cc3cef9 2172 last_errno = errno;
818f477c 2173 error("unable to resolve reference %s: %s",
dfefa935 2174 orig_refname, strerror(errno));
5cc3cef9 2175 goto error_return;
4bd18c43 2176 }
5bdd8d4a 2177 missing = is_null_sha1(lock->old_sha1);
c976d415
LH
2178 /* When the ref did not exist and we are creating it,
2179 * make sure there is no existing ref that is packed
2180 * whose name begins with our refname, nor a ref whose
2181 * name is a proper prefix of our refname.
2182 */
5bdd8d4a 2183 if (missing &&
9da31cb0 2184 !is_refname_available(refname, NULL, get_packed_refs(&ref_cache))) {
f475e08e 2185 last_errno = ENOTDIR;
c976d415 2186 goto error_return;
f475e08e 2187 }
22a3844e 2188
c33d5174 2189 lock->lk = xcalloc(1, sizeof(struct lock_file));
4bd18c43 2190
e5c223e9 2191 lflags = 0;
acd3b9ec 2192 if (flags & REF_NODEREF) {
dfefa935 2193 refname = orig_refname;
acd3b9ec
JH
2194 lflags |= LOCK_NODEREF;
2195 }
dfefa935
MH
2196 lock->ref_name = xstrdup(refname);
2197 lock->orig_ref_name = xstrdup(orig_refname);
2198 ref_file = git_path("%s", refname);
5bdd8d4a 2199 if (missing)
68db31cc
SV
2200 lock->force_write = 1;
2201 if ((flags & REF_NODEREF) && (type & REF_ISSYMREF))
2202 lock->force_write = 1;
4bd18c43 2203
c4c61c76
MH
2204 retry:
2205 switch (safe_create_leading_directories(ref_file)) {
2206 case SCLD_OK:
2207 break; /* success */
2208 case SCLD_VANISHED:
2209 if (--attempts_remaining > 0)
2210 goto retry;
2211 /* fall through */
2212 default:
5cc3cef9
JH
2213 last_errno = errno;
2214 error("unable to create directory for %s", ref_file);
2215 goto error_return;
2216 }
4bd18c43 2217
acd3b9ec 2218 lock->lock_fd = hold_lock_file_for_update(lock->lk, ref_file, lflags);
e5c223e9
MH
2219 if (lock->lock_fd < 0) {
2220 if (errno == ENOENT && --attempts_remaining > 0)
2221 /*
2222 * Maybe somebody just deleted one of the
2223 * directories leading to ref_file. Try
2224 * again:
2225 */
2226 goto retry;
2227 else
e197c218 2228 unable_to_lock_die(ref_file, errno);
e5c223e9 2229 }
4bd18c43 2230 return old_sha1 ? verify_lock(lock, old_sha1, mustexist) : lock;
5cc3cef9
JH
2231
2232 error_return:
2233 unlock_ref(lock);
2234 errno = last_errno;
2235 return NULL;
4bd18c43
SP
2236}
2237
dfefa935 2238struct ref_lock *lock_any_ref_for_update(const char *refname,
9bbb0fa1
BK
2239 const unsigned char *old_sha1,
2240 int flags, int *type_p)
4bd18c43 2241{
dfefa935 2242 if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL))
257f3020 2243 return NULL;
9bbb0fa1 2244 return lock_ref_sha1_basic(refname, old_sha1, flags, type_p);
c0277d15
JH
2245}
2246
fec3137f
MH
2247/*
2248 * Write an entry to the packed-refs file for the specified refname.
2249 * If peeled is non-NULL, write it as the entry's peeled value.
2250 */
9540ce50 2251static void write_packed_entry(FILE *fh, char *refname, unsigned char *sha1,
fec3137f 2252 unsigned char *peeled)
d66da478 2253{
9540ce50
JK
2254 fprintf_or_die(fh, "%s %s\n", sha1_to_hex(sha1), refname);
2255 if (peeled)
2256 fprintf_or_die(fh, "^%s\n", sha1_to_hex(peeled));
fec3137f
MH
2257}
2258
7b40d396
MH
2259/*
2260 * An each_ref_entry_fn that writes the entry to a packed-refs file.
2261 */
2262static int write_packed_entry_fn(struct ref_entry *entry, void *cb_data)
2263{
7b40d396
MH
2264 enum peel_status peel_status = peel_entry(entry, 0);
2265
2266 if (peel_status != PEEL_PEELED && peel_status != PEEL_NON_TAG)
2267 error("internal error: %s is not a valid packed reference!",
2268 entry->name);
9540ce50 2269 write_packed_entry(cb_data, entry->name, entry->u.value.sha1,
7b40d396
MH
2270 peel_status == PEEL_PEELED ?
2271 entry->u.value.peeled : NULL);
2272 return 0;
2273}
2274
447ff1bf 2275/* This should return a meaningful errno on failure */
9f69d297
MH
2276int lock_packed_refs(int flags)
2277{
2278 struct packed_ref_cache *packed_ref_cache;
2279
9f69d297
MH
2280 if (hold_lock_file_for_update(&packlock, git_path("packed-refs"), flags) < 0)
2281 return -1;
5d478f5c
MH
2282 /*
2283 * Get the current packed-refs while holding the lock. If the
2284 * packed-refs file has been modified since we last read it,
2285 * this will automatically invalidate the cache and re-read
2286 * the packed-refs file.
2287 */
9f69d297
MH
2288 packed_ref_cache = get_packed_ref_cache(&ref_cache);
2289 packed_ref_cache->lock = &packlock;
4f6b83e3
MH
2290 /* Increment the reference count to prevent it from being freed: */
2291 acquire_packed_ref_cache(packed_ref_cache);
9f69d297
MH
2292 return 0;
2293}
2294
d3f66555
RS
2295/*
2296 * Commit the packed refs changes.
2297 * On error we must make sure that errno contains a meaningful value.
2298 */
9f69d297
MH
2299int commit_packed_refs(void)
2300{
2301 struct packed_ref_cache *packed_ref_cache =
2302 get_packed_ref_cache(&ref_cache);
2303 int error = 0;
d3f66555 2304 int save_errno = 0;
9540ce50 2305 FILE *out;
9f69d297
MH
2306
2307 if (!packed_ref_cache->lock)
2308 die("internal error: packed-refs not locked");
9f69d297 2309
9540ce50
JK
2310 out = fdopen(packed_ref_cache->lock->fd, "w");
2311 if (!out)
2312 die_errno("unable to fdopen packed-refs descriptor");
2313
2314 fprintf_or_die(out, "%s", PACKED_REFS_HEADER);
9f69d297 2315 do_for_each_entry_in_dir(get_packed_ref_dir(packed_ref_cache),
9540ce50
JK
2316 0, write_packed_entry_fn, out);
2317 if (fclose(out))
2318 die_errno("write error");
2319 packed_ref_cache->lock->fd = -1;
2320
d3f66555
RS
2321 if (commit_lock_file(packed_ref_cache->lock)) {
2322 save_errno = errno;
9f69d297 2323 error = -1;
d3f66555 2324 }
9f69d297 2325 packed_ref_cache->lock = NULL;
4f6b83e3 2326 release_packed_ref_cache(packed_ref_cache);
d3f66555 2327 errno = save_errno;
9f69d297
MH
2328 return error;
2329}
2330
2331void rollback_packed_refs(void)
2332{
2333 struct packed_ref_cache *packed_ref_cache =
2334 get_packed_ref_cache(&ref_cache);
2335
2336 if (!packed_ref_cache->lock)
2337 die("internal error: packed-refs not locked");
2338 rollback_lock_file(packed_ref_cache->lock);
2339 packed_ref_cache->lock = NULL;
4f6b83e3 2340 release_packed_ref_cache(packed_ref_cache);
9f69d297
MH
2341 clear_packed_ref_cache(&ref_cache);
2342}
2343
32d462ce
MH
2344struct ref_to_prune {
2345 struct ref_to_prune *next;
2346 unsigned char sha1[20];
2347 char name[FLEX_ARRAY];
2348};
2349
2350struct pack_refs_cb_data {
2351 unsigned int flags;
267f9a8c 2352 struct ref_dir *packed_refs;
32d462ce 2353 struct ref_to_prune *ref_to_prune;
32d462ce
MH
2354};
2355
267f9a8c
MH
2356/*
2357 * An each_ref_entry_fn that is run over loose references only. If
2358 * the loose reference can be packed, add an entry in the packed ref
2359 * cache. If the reference should be pruned, also add it to
2360 * ref_to_prune in the pack_refs_cb_data.
2361 */
2362static int pack_if_possible_fn(struct ref_entry *entry, void *cb_data)
32d462ce
MH
2363{
2364 struct pack_refs_cb_data *cb = cb_data;
f85354b5 2365 enum peel_status peel_status;
267f9a8c 2366 struct ref_entry *packed_entry;
59556548 2367 int is_tag_ref = starts_with(entry->name, "refs/tags/");
32d462ce 2368
267f9a8c
MH
2369 /* ALWAYS pack tags */
2370 if (!(cb->flags & PACK_REFS_ALL) && !is_tag_ref)
32d462ce
MH
2371 return 0;
2372
b2a8226d
MH
2373 /* Do not pack symbolic or broken refs: */
2374 if ((entry->flag & REF_ISSYMREF) || !ref_resolves_to_object(entry))
2375 return 0;
2376
267f9a8c 2377 /* Add a packed ref cache entry equivalent to the loose entry. */
f85354b5 2378 peel_status = peel_entry(entry, 1);
0f29920f 2379 if (peel_status != PEEL_PEELED && peel_status != PEEL_NON_TAG)
f85354b5
MH
2380 die("internal error peeling reference %s (%s)",
2381 entry->name, sha1_to_hex(entry->u.value.sha1));
267f9a8c
MH
2382 packed_entry = find_ref(cb->packed_refs, entry->name);
2383 if (packed_entry) {
2384 /* Overwrite existing packed entry with info from loose entry */
2385 packed_entry->flag = REF_ISPACKED | REF_KNOWS_PEELED;
2386 hashcpy(packed_entry->u.value.sha1, entry->u.value.sha1);
2387 } else {
2388 packed_entry = create_ref_entry(entry->name, entry->u.value.sha1,
2389 REF_ISPACKED | REF_KNOWS_PEELED, 0);
2390 add_ref(cb->packed_refs, packed_entry);
2391 }
2392 hashcpy(packed_entry->u.value.peeled, entry->u.value.peeled);
32d462ce 2393
267f9a8c
MH
2394 /* Schedule the loose reference for pruning if requested. */
2395 if ((cb->flags & PACK_REFS_PRUNE)) {
12e77559 2396 int namelen = strlen(entry->name) + 1;
32d462ce 2397 struct ref_to_prune *n = xcalloc(1, sizeof(*n) + namelen);
12e77559
MH
2398 hashcpy(n->sha1, entry->u.value.sha1);
2399 strcpy(n->name, entry->name);
32d462ce
MH
2400 n->next = cb->ref_to_prune;
2401 cb->ref_to_prune = n;
2402 }
d66da478
MH
2403 return 0;
2404}
2405
32d462ce
MH
2406/*
2407 * Remove empty parents, but spare refs/ and immediate subdirs.
2408 * Note: munges *name.
2409 */
2410static void try_remove_empty_parents(char *name)
2411{
2412 char *p, *q;
2413 int i;
2414 p = name;
2415 for (i = 0; i < 2; i++) { /* refs/{heads,tags,...}/ */
2416 while (*p && *p != '/')
2417 p++;
2418 /* tolerate duplicate slashes; see check_refname_format() */
2419 while (*p == '/')
2420 p++;
2421 }
2422 for (q = p; *q; q++)
2423 ;
2424 while (1) {
2425 while (q > p && *q != '/')
2426 q--;
2427 while (q > p && *(q-1) == '/')
2428 q--;
2429 if (q == p)
2430 break;
2431 *q = '\0';
2432 if (rmdir(git_path("%s", name)))
2433 break;
2434 }
2435}
2436
2437/* make sure nobody touched the ref, and unlink */
2438static void prune_ref(struct ref_to_prune *r)
2439{
029cdb4a
RS
2440 struct ref_transaction *transaction;
2441 struct strbuf err = STRBUF_INIT;
32d462ce 2442
88e7dff9 2443 if (check_refname_format(r->name, 0))
cba12021 2444 return;
32d462ce 2445
029cdb4a
RS
2446 transaction = ref_transaction_begin(&err);
2447 if (!transaction ||
2448 ref_transaction_delete(transaction, r->name, r->sha1,
2449 REF_ISPRUNING, 1, &err) ||
2450 ref_transaction_commit(transaction, NULL, &err)) {
2451 ref_transaction_free(transaction);
2452 error("%s", err.buf);
2453 strbuf_release(&err);
2454 return;
32d462ce 2455 }
029cdb4a
RS
2456 ref_transaction_free(transaction);
2457 strbuf_release(&err);
2458 try_remove_empty_parents(r->name);
32d462ce
MH
2459}
2460
2461static void prune_refs(struct ref_to_prune *r)
2462{
2463 while (r) {
2464 prune_ref(r);
2465 r = r->next;
2466 }
2467}
2468
32d462ce
MH
2469int pack_refs(unsigned int flags)
2470{
32d462ce
MH
2471 struct pack_refs_cb_data cbdata;
2472
2473 memset(&cbdata, 0, sizeof(cbdata));
2474 cbdata.flags = flags;
2475
9f69d297 2476 lock_packed_refs(LOCK_DIE_ON_ERROR);
267f9a8c 2477 cbdata.packed_refs = get_packed_refs(&ref_cache);
32d462ce 2478
267f9a8c
MH
2479 do_for_each_entry_in_dir(get_loose_refs(&ref_cache), 0,
2480 pack_if_possible_fn, &cbdata);
32d462ce 2481
9f69d297 2482 if (commit_packed_refs())
32d462ce 2483 die_errno("unable to overwrite old ref-pack file");
9f69d297 2484
32d462ce
MH
2485 prune_refs(cbdata.ref_to_prune);
2486 return 0;
2487}
2488
7b40d396
MH
2489/*
2490 * If entry is no longer needed in packed-refs, add it to the string
2491 * list pointed to by cb_data. Reasons for deleting entries:
2492 *
2493 * - Entry is broken.
2494 * - Entry is overridden by a loose ref.
2495 * - Entry does not point at a valid object.
2496 *
2497 * In the first and third cases, also emit an error message because these
2498 * are indications of repository corruption.
2499 */
2500static int curate_packed_ref_fn(struct ref_entry *entry, void *cb_data)
c0277d15 2501{
7b40d396 2502 struct string_list *refs_to_delete = cb_data;
fec3137f 2503
ab292bc4
MH
2504 if (entry->flag & REF_ISBROKEN) {
2505 /* This shouldn't happen to packed refs. */
2506 error("%s is broken!", entry->name);
7b40d396 2507 string_list_append(refs_to_delete, entry->name);
c0277d15 2508 return 0;
ab292bc4
MH
2509 }
2510 if (!has_sha1_file(entry->u.value.sha1)) {
2511 unsigned char sha1[20];
2512 int flags;
2513
2514 if (read_ref_full(entry->name, sha1, 0, &flags))
2515 /* We should at least have found the packed ref. */
2516 die("Internal error");
7b40d396 2517 if ((flags & REF_ISSYMREF) || !(flags & REF_ISPACKED)) {
ab292bc4
MH
2518 /*
2519 * This packed reference is overridden by a
2520 * loose reference, so it is OK that its value
2521 * is no longer valid; for example, it might
2522 * refer to an object that has been garbage
2523 * collected. For this purpose we don't even
2524 * care whether the loose reference itself is
2525 * invalid, broken, symbolic, etc. Silently
7b40d396 2526 * remove the packed reference.
ab292bc4 2527 */
7b40d396 2528 string_list_append(refs_to_delete, entry->name);
ab292bc4 2529 return 0;
7b40d396 2530 }
ab292bc4
MH
2531 /*
2532 * There is no overriding loose reference, so the fact
2533 * that this reference doesn't refer to a valid object
2534 * indicates some kind of repository corruption.
2535 * Report the problem, then omit the reference from
2536 * the output.
2537 */
2538 error("%s does not point to a valid object!", entry->name);
7b40d396 2539 string_list_append(refs_to_delete, entry->name);
ab292bc4
MH
2540 return 0;
2541 }
2542
d66da478
MH
2543 return 0;
2544}
2545
60bca085 2546int repack_without_refs(const char **refnames, int n, struct strbuf *err)
c0277d15 2547{
7618fd80 2548 struct ref_dir *packed;
7b40d396
MH
2549 struct string_list refs_to_delete = STRING_LIST_INIT_DUP;
2550 struct string_list_item *ref_to_delete;
60bca085 2551 int i, ret, removed = 0;
61cee0db
BK
2552
2553 /* Look for a packed ref */
2554 for (i = 0; i < n; i++)
2555 if (get_packed_ref(refnames[i]))
2556 break;
7618fd80 2557
61cee0db
BK
2558 /* Avoid locking if we have nothing to do */
2559 if (i == n)
2560 return 0; /* no refname exists in packed refs */
7618fd80 2561
9f69d297 2562 if (lock_packed_refs(0)) {
60bca085
RS
2563 if (err) {
2564 unable_to_lock_message(git_path("packed-refs"), errno,
2565 err);
2566 return -1;
2567 }
1b018fd9 2568 unable_to_lock_error(git_path("packed-refs"), errno);
61cee0db 2569 return error("cannot delete '%s' from packed refs", refnames[i]);
1b018fd9 2570 }
9da31cb0 2571 packed = get_packed_refs(&ref_cache);
7b40d396 2572
61cee0db
BK
2573 /* Remove refnames from the cache */
2574 for (i = 0; i < n; i++)
2575 if (remove_entry(packed, refnames[i]) != -1)
2576 removed = 1;
2577 if (!removed) {
506a760d 2578 /*
61cee0db 2579 * All packed entries disappeared while we were
506a760d
MH
2580 * acquiring the lock.
2581 */
9f69d297 2582 rollback_packed_refs();
506a760d
MH
2583 return 0;
2584 }
7b40d396 2585
61cee0db 2586 /* Remove any other accumulated cruft */
7b40d396
MH
2587 do_for_each_entry_in_dir(packed, 0, curate_packed_ref_fn, &refs_to_delete);
2588 for_each_string_list_item(ref_to_delete, &refs_to_delete) {
2589 if (remove_entry(packed, ref_to_delete->string) == -1)
2590 die("internal error");
2591 }
2592
61cee0db 2593 /* Write what remains */
60bca085
RS
2594 ret = commit_packed_refs();
2595 if (ret && err)
2596 strbuf_addf(err, "unable to overwrite old ref-pack file: %s",
2597 strerror(errno));
2598 return ret;
c0277d15
JH
2599}
2600
2ddb5d17
BK
2601static int delete_ref_loose(struct ref_lock *lock, int flag)
2602{
045a476f 2603 if (!(flag & REF_ISPACKED) || flag & REF_ISSYMREF) {
c0277d15 2604 /* loose */
2ddb5d17
BK
2605 int err, i = strlen(lock->lk->filename) - 5; /* .lock */
2606
547d058f
RS
2607 lock->lk->filename[i] = 0;
2608 err = unlink_or_warn(lock->lk->filename);
547d058f 2609 lock->lk->filename[i] = '.';
2ddb5d17
BK
2610 if (err && errno != ENOENT)
2611 return 1;
c0277d15 2612 }
2ddb5d17
BK
2613 return 0;
2614}
2615
eca35a25 2616int delete_ref(const char *refname, const unsigned char *sha1, int delopt)
c0277d15 2617{
7521cc46
RS
2618 struct ref_transaction *transaction;
2619 struct strbuf err = STRBUF_INIT;
c0277d15 2620
7521cc46
RS
2621 transaction = ref_transaction_begin(&err);
2622 if (!transaction ||
2623 ref_transaction_delete(transaction, refname, sha1, delopt,
2624 sha1 && !is_null_sha1(sha1), &err) ||
2625 ref_transaction_commit(transaction, NULL, &err)) {
2626 error("%s", err.buf);
2627 ref_transaction_free(transaction);
2628 strbuf_release(&err);
c0277d15 2629 return 1;
7521cc46
RS
2630 }
2631 ref_transaction_free(transaction);
2632 strbuf_release(&err);
2633 return 0;
4bd18c43
SP
2634}
2635
765c2258
PH
2636/*
2637 * People using contrib's git-new-workdir have .git/logs/refs ->
2638 * /some/other/path/.git/logs/refs, and that may live on another device.
2639 *
2640 * IOW, to avoid cross device rename errors, the temporary renamed log must
2641 * live into logs/refs.
2642 */
2643#define TMP_RENAMED_LOG "logs/refs/.tmp-renamed-log"
2644
fa59ae79
MH
2645static int rename_tmp_log(const char *newrefname)
2646{
f1e9e9a4 2647 int attempts_remaining = 4;
ae4a283e
MH
2648
2649 retry:
08f555cb
MH
2650 switch (safe_create_leading_directories(git_path("logs/%s", newrefname))) {
2651 case SCLD_OK:
2652 break; /* success */
2653 case SCLD_VANISHED:
2654 if (--attempts_remaining > 0)
2655 goto retry;
2656 /* fall through */
2657 default:
fa59ae79
MH
2658 error("unable to create directory for %s", newrefname);
2659 return -1;
2660 }
2661
fa59ae79 2662 if (rename(git_path(TMP_RENAMED_LOG), git_path("logs/%s", newrefname))) {
f1e9e9a4 2663 if ((errno==EISDIR || errno==ENOTDIR) && --attempts_remaining > 0) {
fa59ae79
MH
2664 /*
2665 * rename(a, b) when b is an existing
2666 * directory ought to result in ISDIR, but
2667 * Solaris 5.8 gives ENOTDIR. Sheesh.
2668 */
2669 if (remove_empty_directories(git_path("logs/%s", newrefname))) {
2670 error("Directory not empty: logs/%s", newrefname);
2671 return -1;
2672 }
2673 goto retry;
ae4a283e
MH
2674 } else if (errno == ENOENT && --attempts_remaining > 0) {
2675 /*
2676 * Maybe another process just deleted one of
2677 * the directories in the path to newrefname.
2678 * Try again from the beginning.
2679 */
2680 goto retry;
fa59ae79
MH
2681 } else {
2682 error("unable to move logfile "TMP_RENAMED_LOG" to logs/%s: %s",
2683 newrefname, strerror(errno));
2684 return -1;
2685 }
2686 }
2687 return 0;
2688}
2689
dfefa935 2690int rename_ref(const char *oldrefname, const char *newrefname, const char *logmsg)
c976d415 2691{
c976d415
LH
2692 unsigned char sha1[20], orig_sha1[20];
2693 int flag = 0, logmoved = 0;
2694 struct ref_lock *lock;
c976d415 2695 struct stat loginfo;
dfefa935 2696 int log = !lstat(git_path("logs/%s", oldrefname), &loginfo);
eca35a25 2697 const char *symref = NULL;
c976d415 2698
450d4c0f 2699 if (log && S_ISLNK(loginfo.st_mode))
dfefa935 2700 return error("reflog for %s is a symlink", oldrefname);
c976d415 2701
8d68493f 2702 symref = resolve_ref_unsafe(oldrefname, orig_sha1, 1, &flag);
eca35a25 2703 if (flag & REF_ISSYMREF)
fa58186c 2704 return error("refname %s is a symbolic ref, renaming it is not supported",
dfefa935 2705 oldrefname);
eca35a25 2706 if (!symref)
dfefa935 2707 return error("refname %s not found", oldrefname);
c976d415 2708
9da31cb0 2709 if (!is_refname_available(newrefname, oldrefname, get_packed_refs(&ref_cache)))
c976d415
LH
2710 return 1;
2711
9da31cb0 2712 if (!is_refname_available(newrefname, oldrefname, get_loose_refs(&ref_cache)))
c976d415
LH
2713 return 1;
2714
dfefa935 2715 if (log && rename(git_path("logs/%s", oldrefname), git_path(TMP_RENAMED_LOG)))
765c2258 2716 return error("unable to move logfile logs/%s to "TMP_RENAMED_LOG": %s",
dfefa935 2717 oldrefname, strerror(errno));
c976d415 2718
dfefa935
MH
2719 if (delete_ref(oldrefname, orig_sha1, REF_NODEREF)) {
2720 error("unable to delete old %s", oldrefname);
c976d415
LH
2721 goto rollback;
2722 }
2723
dfefa935
MH
2724 if (!read_ref_full(newrefname, sha1, 1, &flag) &&
2725 delete_ref(newrefname, sha1, REF_NODEREF)) {
c976d415 2726 if (errno==EISDIR) {
dfefa935
MH
2727 if (remove_empty_directories(git_path("%s", newrefname))) {
2728 error("Directory not empty: %s", newrefname);
c976d415
LH
2729 goto rollback;
2730 }
2731 } else {
dfefa935 2732 error("unable to delete existing %s", newrefname);
c976d415
LH
2733 goto rollback;
2734 }
2735 }
2736
fa59ae79 2737 if (log && rename_tmp_log(newrefname))
c976d415 2738 goto rollback;
c976d415 2739
c976d415
LH
2740 logmoved = log;
2741
dfefa935 2742 lock = lock_ref_sha1_basic(newrefname, NULL, 0, NULL);
c976d415 2743 if (!lock) {
dfefa935 2744 error("unable to lock %s for update", newrefname);
c976d415
LH
2745 goto rollback;
2746 }
c976d415
LH
2747 lock->force_write = 1;
2748 hashcpy(lock->old_sha1, orig_sha1);
678d0f4c 2749 if (write_ref_sha1(lock, orig_sha1, logmsg)) {
dfefa935 2750 error("unable to write current sha1 into %s", newrefname);
c976d415
LH
2751 goto rollback;
2752 }
2753
2754 return 0;
2755
2756 rollback:
dfefa935 2757 lock = lock_ref_sha1_basic(oldrefname, NULL, 0, NULL);
c976d415 2758 if (!lock) {
dfefa935 2759 error("unable to lock %s for rollback", oldrefname);
c976d415
LH
2760 goto rollbacklog;
2761 }
2762
2763 lock->force_write = 1;
2764 flag = log_all_ref_updates;
2765 log_all_ref_updates = 0;
2766 if (write_ref_sha1(lock, orig_sha1, NULL))
dfefa935 2767 error("unable to write current sha1 into %s", oldrefname);
c976d415
LH
2768 log_all_ref_updates = flag;
2769
2770 rollbacklog:
dfefa935 2771 if (logmoved && rename(git_path("logs/%s", newrefname), git_path("logs/%s", oldrefname)))
c976d415 2772 error("unable to restore logfile %s from %s: %s",
dfefa935 2773 oldrefname, newrefname, strerror(errno));
c976d415 2774 if (!logmoved && log &&
dfefa935 2775 rename(git_path(TMP_RENAMED_LOG), git_path("logs/%s", oldrefname)))
765c2258 2776 error("unable to restore logfile %s from "TMP_RENAMED_LOG": %s",
dfefa935 2777 oldrefname, strerror(errno));
c976d415
LH
2778
2779 return 1;
2780}
2781
435fc852 2782int close_ref(struct ref_lock *lock)
b531394d
BC
2783{
2784 if (close_lock_file(lock->lk))
2785 return -1;
2786 lock->lock_fd = -1;
2787 return 0;
2788}
2789
435fc852 2790int commit_ref(struct ref_lock *lock)
b531394d
BC
2791{
2792 if (commit_lock_file(lock->lk))
2793 return -1;
2794 lock->lock_fd = -1;
2795 return 0;
2796}
2797
e5f38ec3 2798void unlock_ref(struct ref_lock *lock)
4bd18c43 2799{
4ed7cd3a
BC
2800 /* Do not free lock->lk -- atexit() still looks at them */
2801 if (lock->lk)
2802 rollback_lock_file(lock->lk);
434cd0cd 2803 free(lock->ref_name);
1655707c 2804 free(lock->orig_ref_name);
4bd18c43
SP
2805 free(lock);
2806}
2807
0ec29a47
JH
2808/*
2809 * copy the reflog message msg to buf, which has been allocated sufficiently
2810 * large, while cleaning up the whitespaces. Especially, convert LF to space,
2811 * because reflog file is one line per entry.
2812 */
2813static int copy_msg(char *buf, const char *msg)
2814{
2815 char *cp = buf;
2816 char c;
2817 int wasspace = 1;
2818
2819 *cp++ = '\t';
2820 while ((c = *msg++)) {
2821 if (wasspace && isspace(c))
2822 continue;
2823 wasspace = isspace(c);
2824 if (wasspace)
2825 c = ' ';
2826 *cp++ = c;
2827 }
2828 while (buf < cp && isspace(cp[-1]))
2829 cp--;
2830 *cp++ = '\n';
2831 return cp - buf;
2832}
2833
bd3b02da 2834/* This function must set a meaningful errno on failure */
dfefa935 2835int log_ref_setup(const char *refname, char *logfile, int bufsize)
6de08ae6 2836{
859c3017 2837 int logfd, oflags = O_APPEND | O_WRONLY;
9a13f0b7 2838
dfefa935 2839 git_snpath(logfile, bufsize, "logs/%s", refname);
4057deb5 2840 if (log_all_ref_updates &&
59556548
CC
2841 (starts_with(refname, "refs/heads/") ||
2842 starts_with(refname, "refs/remotes/") ||
2843 starts_with(refname, "refs/notes/") ||
dfefa935 2844 !strcmp(refname, "HEAD"))) {
bd3b02da
RS
2845 if (safe_create_leading_directories(logfile) < 0) {
2846 int save_errno = errno;
2847 error("unable to create directory for %s", logfile);
2848 errno = save_errno;
2849 return -1;
2850 }
6de08ae6
SP
2851 oflags |= O_CREAT;
2852 }
2853
157aaea5 2854 logfd = open(logfile, oflags, 0666);
6de08ae6 2855 if (logfd < 0) {
1974bf62 2856 if (!(oflags & O_CREAT) && errno == ENOENT)
6de08ae6 2857 return 0;
3b463c3f
JH
2858
2859 if ((oflags & O_CREAT) && errno == EISDIR) {
157aaea5 2860 if (remove_empty_directories(logfile)) {
bd3b02da
RS
2861 int save_errno = errno;
2862 error("There are still logs under '%s'",
2863 logfile);
2864 errno = save_errno;
2865 return -1;
3b463c3f 2866 }
157aaea5 2867 logfd = open(logfile, oflags, 0666);
3b463c3f
JH
2868 }
2869
bd3b02da
RS
2870 if (logfd < 0) {
2871 int save_errno = errno;
2872 error("Unable to append to %s: %s", logfile,
2873 strerror(errno));
2874 errno = save_errno;
2875 return -1;
2876 }
6de08ae6
SP
2877 }
2878
157aaea5 2879 adjust_shared_perm(logfile);
859c3017
EM
2880 close(logfd);
2881 return 0;
2882}
443b92b6 2883
dfefa935 2884static int log_ref_write(const char *refname, const unsigned char *old_sha1,
859c3017
EM
2885 const unsigned char *new_sha1, const char *msg)
2886{
2887 int logfd, result, written, oflags = O_APPEND | O_WRONLY;
2888 unsigned maxlen, len;
2889 int msglen;
157aaea5 2890 char log_file[PATH_MAX];
859c3017
EM
2891 char *logrec;
2892 const char *committer;
2893
2894 if (log_all_ref_updates < 0)
2895 log_all_ref_updates = !is_bare_repository();
2896
dfefa935 2897 result = log_ref_setup(refname, log_file, sizeof(log_file));
859c3017
EM
2898 if (result)
2899 return result;
2900
2901 logfd = open(log_file, oflags);
2902 if (logfd < 0)
2903 return 0;
0ec29a47 2904 msglen = msg ? strlen(msg) : 0;
774751a8 2905 committer = git_committer_info(0);
8ac65937
JH
2906 maxlen = strlen(committer) + msglen + 100;
2907 logrec = xmalloc(maxlen);
2908 len = sprintf(logrec, "%s %s %s\n",
9a13f0b7
NP
2909 sha1_to_hex(old_sha1),
2910 sha1_to_hex(new_sha1),
8ac65937
JH
2911 committer);
2912 if (msglen)
0ec29a47 2913 len += copy_msg(logrec + len - 1, msg) - 1;
93822c22 2914 written = len <= maxlen ? write_in_full(logfd, logrec, len) : -1;
6de08ae6 2915 free(logrec);
dc615de8
RS
2916 if (written != len) {
2917 int save_errno = errno;
2918 close(logfd);
2919 error("Unable to append to %s", log_file);
2920 errno = save_errno;
2921 return -1;
2922 }
2923 if (close(logfd)) {
2924 int save_errno = errno;
2925 error("Unable to append to %s", log_file);
2926 errno = save_errno;
2927 return -1;
2928 }
6de08ae6
SP
2929 return 0;
2930}
2931
e7e0f26e 2932int is_branch(const char *refname)
c3b0dec5 2933{
59556548 2934 return !strcmp(refname, "HEAD") || starts_with(refname, "refs/heads/");
c3b0dec5
LT
2935}
2936
dc615de8 2937/* This function must return a meaningful errno */
4bd18c43
SP
2938int write_ref_sha1(struct ref_lock *lock,
2939 const unsigned char *sha1, const char *logmsg)
2940{
2941 static char term = '\n';
c3b0dec5 2942 struct object *o;
4bd18c43 2943
dc615de8
RS
2944 if (!lock) {
2945 errno = EINVAL;
95fc7512 2946 return -1;
dc615de8 2947 }
a89fccd2 2948 if (!lock->force_write && !hashcmp(lock->old_sha1, sha1)) {
4bd18c43
SP
2949 unlock_ref(lock);
2950 return 0;
95fc7512 2951 }
c3b0dec5
LT
2952 o = parse_object(sha1);
2953 if (!o) {
7be8b3ba 2954 error("Trying to write ref %s with nonexistent object %s",
c3b0dec5
LT
2955 lock->ref_name, sha1_to_hex(sha1));
2956 unlock_ref(lock);
dc615de8 2957 errno = EINVAL;
c3b0dec5
LT
2958 return -1;
2959 }
2960 if (o->type != OBJ_COMMIT && is_branch(lock->ref_name)) {
2961 error("Trying to write non-commit object %s to branch %s",
2962 sha1_to_hex(sha1), lock->ref_name);
2963 unlock_ref(lock);
dc615de8 2964 errno = EINVAL;
c3b0dec5
LT
2965 return -1;
2966 }
93822c22 2967 if (write_in_full(lock->lock_fd, sha1_to_hex(sha1), 40) != 40 ||
dc615de8
RS
2968 write_in_full(lock->lock_fd, &term, 1) != 1 ||
2969 close_ref(lock) < 0) {
2970 int save_errno = errno;
c33d5174 2971 error("Couldn't write %s", lock->lk->filename);
4bd18c43 2972 unlock_ref(lock);
dc615de8 2973 errno = save_errno;
4bd18c43
SP
2974 return -1;
2975 }
9da31cb0 2976 clear_loose_ref_cache(&ref_cache);
bd104db1
NP
2977 if (log_ref_write(lock->ref_name, lock->old_sha1, sha1, logmsg) < 0 ||
2978 (strcmp(lock->ref_name, lock->orig_ref_name) &&
2979 log_ref_write(lock->orig_ref_name, lock->old_sha1, sha1, logmsg) < 0)) {
6de08ae6
SP
2980 unlock_ref(lock);
2981 return -1;
2982 }
605fac8b
NP
2983 if (strcmp(lock->orig_ref_name, "HEAD") != 0) {
2984 /*
2985 * Special hack: If a branch is updated directly and HEAD
2986 * points to it (may happen on the remote side of a push
2987 * for example) then logically the HEAD reflog should be
2988 * updated too.
2989 * A generic solution implies reverse symref information,
2990 * but finding all symrefs pointing to the given branch
2991 * would be rather costly for this rare event (the direct
2992 * update of a branch) to be worth it. So let's cheat and
2993 * check with HEAD only which should cover 99% of all usage
2994 * scenarios (even 100% of the default ones).
2995 */
2996 unsigned char head_sha1[20];
2997 int head_flag;
2998 const char *head_ref;
8cad4744 2999 head_ref = resolve_ref_unsafe("HEAD", head_sha1, 1, &head_flag);
605fac8b
NP
3000 if (head_ref && (head_flag & REF_ISSYMREF) &&
3001 !strcmp(head_ref, lock->ref_name))
3002 log_ref_write("HEAD", lock->old_sha1, sha1, logmsg);
3003 }
b531394d 3004 if (commit_ref(lock)) {
434cd0cd 3005 error("Couldn't set %s", lock->ref_name);
4bd18c43
SP
3006 unlock_ref(lock);
3007 return -1;
3008 }
4bd18c43
SP
3009 unlock_ref(lock);
3010 return 0;
95fc7512 3011}
d556fae2 3012
8b5157e4
NP
3013int create_symref(const char *ref_target, const char *refs_heads_master,
3014 const char *logmsg)
41b625b0
NP
3015{
3016 const char *lockpath;
3017 char ref[1000];
3018 int fd, len, written;
a4f34cbb 3019 char *git_HEAD = git_pathdup("%s", ref_target);
8b5157e4
NP
3020 unsigned char old_sha1[20], new_sha1[20];
3021
3022 if (logmsg && read_ref(ref_target, old_sha1))
3023 hashclr(old_sha1);
41b625b0 3024
d48744d1
JH
3025 if (safe_create_leading_directories(git_HEAD) < 0)
3026 return error("unable to create directory for %s", git_HEAD);
3027
41b625b0
NP
3028#ifndef NO_SYMLINK_HEAD
3029 if (prefer_symlink_refs) {
3030 unlink(git_HEAD);
3031 if (!symlink(refs_heads_master, git_HEAD))
8b5157e4 3032 goto done;
41b625b0
NP
3033 fprintf(stderr, "no symlink - falling back to symbolic ref\n");
3034 }
3035#endif
3036
3037 len = snprintf(ref, sizeof(ref), "ref: %s\n", refs_heads_master);
3038 if (sizeof(ref) <= len) {
3039 error("refname too long: %s", refs_heads_master);
47fc52e2 3040 goto error_free_return;
41b625b0
NP
3041 }
3042 lockpath = mkpath("%s.lock", git_HEAD);
3043 fd = open(lockpath, O_CREAT | O_EXCL | O_WRONLY, 0666);
3044 if (fd < 0) {
3045 error("Unable to open %s for writing", lockpath);
47fc52e2 3046 goto error_free_return;
41b625b0
NP
3047 }
3048 written = write_in_full(fd, ref, len);
91c8d590 3049 if (close(fd) != 0 || written != len) {
41b625b0 3050 error("Unable to write to %s", lockpath);
47fc52e2 3051 goto error_unlink_return;
41b625b0
NP
3052 }
3053 if (rename(lockpath, git_HEAD) < 0) {
41b625b0 3054 error("Unable to create %s", git_HEAD);
47fc52e2 3055 goto error_unlink_return;
41b625b0
NP
3056 }
3057 if (adjust_shared_perm(git_HEAD)) {
41b625b0 3058 error("Unable to fix permissions on %s", lockpath);
47fc52e2 3059 error_unlink_return:
691f1a28 3060 unlink_or_warn(lockpath);
47fc52e2
JH
3061 error_free_return:
3062 free(git_HEAD);
3063 return -1;
41b625b0 3064 }
8b5157e4 3065
ee96d11b 3066#ifndef NO_SYMLINK_HEAD
8b5157e4 3067 done:
ee96d11b 3068#endif
8b5157e4
NP
3069 if (logmsg && !read_ref(refs_heads_master, new_sha1))
3070 log_ref_write(ref_target, old_sha1, new_sha1, logmsg);
3071
47fc52e2 3072 free(git_HEAD);
41b625b0
NP
3073 return 0;
3074}
3075
4207ed28
RS
3076struct read_ref_at_cb {
3077 const char *refname;
3078 unsigned long at_time;
3079 int cnt;
3080 int reccnt;
3081 unsigned char *sha1;
3082 int found_it;
3083
3084 unsigned char osha1[20];
3085 unsigned char nsha1[20];
3086 int tz;
3087 unsigned long date;
3088 char **msg;
3089 unsigned long *cutoff_time;
3090 int *cutoff_tz;
3091 int *cutoff_cnt;
3092};
3093
3094static int read_ref_at_ent(unsigned char *osha1, unsigned char *nsha1,
3095 const char *email, unsigned long timestamp, int tz,
3096 const char *message, void *cb_data)
3097{
3098 struct read_ref_at_cb *cb = cb_data;
3099
3100 cb->reccnt++;
3101 cb->tz = tz;
3102 cb->date = timestamp;
3103
3104 if (timestamp <= cb->at_time || cb->cnt == 0) {
3105 if (cb->msg)
3106 *cb->msg = xstrdup(message);
3107 if (cb->cutoff_time)
3108 *cb->cutoff_time = timestamp;
3109 if (cb->cutoff_tz)
3110 *cb->cutoff_tz = tz;
3111 if (cb->cutoff_cnt)
3112 *cb->cutoff_cnt = cb->reccnt - 1;
3113 /*
3114 * we have not yet updated cb->[n|o]sha1 so they still
3115 * hold the values for the previous record.
3116 */
3117 if (!is_null_sha1(cb->osha1)) {
3118 hashcpy(cb->sha1, nsha1);
3119 if (hashcmp(cb->osha1, nsha1))
3120 warning("Log for ref %s has gap after %s.",
3121 cb->refname, show_date(cb->date, cb->tz, DATE_RFC2822));
3122 }
3123 else if (cb->date == cb->at_time)
3124 hashcpy(cb->sha1, nsha1);
3125 else if (hashcmp(nsha1, cb->sha1))
3126 warning("Log for ref %s unexpectedly ended on %s.",
3127 cb->refname, show_date(cb->date, cb->tz,
3128 DATE_RFC2822));
3129 hashcpy(cb->osha1, osha1);
3130 hashcpy(cb->nsha1, nsha1);
3131 cb->found_it = 1;
3132 return 1;
3133 }
3134 hashcpy(cb->osha1, osha1);
3135 hashcpy(cb->nsha1, nsha1);
3136 if (cb->cnt > 0)
3137 cb->cnt--;
3138 return 0;
3139}
3140
3141static int read_ref_at_ent_oldest(unsigned char *osha1, unsigned char *nsha1,
3142 const char *email, unsigned long timestamp,
3143 int tz, const char *message, void *cb_data)
3144{
3145 struct read_ref_at_cb *cb = cb_data;
3146
3147 if (cb->msg)
3148 *cb->msg = xstrdup(message);
3149 if (cb->cutoff_time)
3150 *cb->cutoff_time = timestamp;
3151 if (cb->cutoff_tz)
3152 *cb->cutoff_tz = tz;
3153 if (cb->cutoff_cnt)
3154 *cb->cutoff_cnt = cb->reccnt;
3155 hashcpy(cb->sha1, osha1);
3156 if (is_null_sha1(cb->sha1))
3157 hashcpy(cb->sha1, nsha1);
3158 /* We just want the first entry */
3159 return 1;
16d7cc90
JH
3160}
3161
c41a87dd 3162int read_ref_at(const char *refname, unsigned int flags, unsigned long at_time, int cnt,
dfefa935
MH
3163 unsigned char *sha1, char **msg,
3164 unsigned long *cutoff_time, int *cutoff_tz, int *cutoff_cnt)
d556fae2 3165{
4207ed28 3166 struct read_ref_at_cb cb;
d556fae2 3167
4207ed28
RS
3168 memset(&cb, 0, sizeof(cb));
3169 cb.refname = refname;
3170 cb.at_time = at_time;
3171 cb.cnt = cnt;
3172 cb.msg = msg;
3173 cb.cutoff_time = cutoff_time;
3174 cb.cutoff_tz = cutoff_tz;
3175 cb.cutoff_cnt = cutoff_cnt;
3176 cb.sha1 = sha1;
3177
3178 for_each_reflog_ent_reverse(refname, read_ref_at_ent, &cb);
3179
c41a87dd
DA
3180 if (!cb.reccnt) {
3181 if (flags & GET_SHA1_QUIETLY)
3182 exit(128);
3183 else
3184 die("Log for %s is empty.", refname);
3185 }
4207ed28
RS
3186 if (cb.found_it)
3187 return 0;
3188
3189 for_each_reflog_ent(refname, read_ref_at_ent_oldest, &cb);
d556fae2 3190
16d7cc90 3191 return 1;
d556fae2 3192}
2ff81662 3193
4da58835
RS
3194int reflog_exists(const char *refname)
3195{
3196 struct stat st;
3197
3198 return !lstat(git_path("logs/%s", refname), &st) &&
3199 S_ISREG(st.st_mode);
3200}
3201
3202int delete_reflog(const char *refname)
3203{
3204 return remove_path(git_path("logs/%s", refname));
3205}
3206
9a7a183b
JH
3207static int show_one_reflog_ent(struct strbuf *sb, each_reflog_ent_fn fn, void *cb_data)
3208{
3209 unsigned char osha1[20], nsha1[20];
3210 char *email_end, *message;
3211 unsigned long timestamp;
3212 int tz;
3213
3214 /* old SP new SP name <email> SP time TAB msg LF */
3215 if (sb->len < 83 || sb->buf[sb->len - 1] != '\n' ||
3216 get_sha1_hex(sb->buf, osha1) || sb->buf[40] != ' ' ||
3217 get_sha1_hex(sb->buf + 41, nsha1) || sb->buf[81] != ' ' ||
3218 !(email_end = strchr(sb->buf + 82, '>')) ||
3219 email_end[1] != ' ' ||
3220 !(timestamp = strtoul(email_end + 2, &message, 10)) ||
3221 !message || message[0] != ' ' ||
3222 (message[1] != '+' && message[1] != '-') ||
3223 !isdigit(message[2]) || !isdigit(message[3]) ||
3224 !isdigit(message[4]) || !isdigit(message[5]))
3225 return 0; /* corrupt? */
3226 email_end[1] = '\0';
3227 tz = strtol(message + 1, NULL, 10);
3228 if (message[6] != '\t')
3229 message += 6;
3230 else
3231 message += 7;
3232 return fn(osha1, nsha1, sb->buf + 82, timestamp, tz, message, cb_data);
3233}
3234
98f85ff4
JH
3235static char *find_beginning_of_line(char *bob, char *scan)
3236{
3237 while (bob < scan && *(--scan) != '\n')
3238 ; /* keep scanning backwards */
3239 /*
3240 * Return either beginning of the buffer, or LF at the end of
3241 * the previous line.
3242 */
3243 return scan;
3244}
3245
3246int for_each_reflog_ent_reverse(const char *refname, each_reflog_ent_fn fn, void *cb_data)
2ff81662 3247{
8ca78803 3248 struct strbuf sb = STRBUF_INIT;
98f85ff4
JH
3249 FILE *logfp;
3250 long pos;
3251 int ret = 0, at_tail = 1;
2ff81662 3252
7ae07c1b 3253 logfp = fopen(git_path("logs/%s", refname), "r");
2ff81662 3254 if (!logfp)
883d60fa 3255 return -1;
101d15e0 3256
98f85ff4
JH
3257 /* Jump to the end */
3258 if (fseek(logfp, 0, SEEK_END) < 0)
3259 return error("cannot seek back reflog for %s: %s",
3260 refname, strerror(errno));
3261 pos = ftell(logfp);
3262 while (!ret && 0 < pos) {
3263 int cnt;
3264 size_t nread;
3265 char buf[BUFSIZ];
3266 char *endp, *scanp;
3267
3268 /* Fill next block from the end */
3269 cnt = (sizeof(buf) < pos) ? sizeof(buf) : pos;
3270 if (fseek(logfp, pos - cnt, SEEK_SET))
3271 return error("cannot seek back reflog for %s: %s",
3272 refname, strerror(errno));
3273 nread = fread(buf, cnt, 1, logfp);
e4ca819a 3274 if (nread != 1)
98f85ff4
JH
3275 return error("cannot read %d bytes from reflog for %s: %s",
3276 cnt, refname, strerror(errno));
3277 pos -= cnt;
3278
3279 scanp = endp = buf + cnt;
3280 if (at_tail && scanp[-1] == '\n')
3281 /* Looking at the final LF at the end of the file */
3282 scanp--;
3283 at_tail = 0;
3284
3285 while (buf < scanp) {
3286 /*
3287 * terminating LF of the previous line, or the beginning
3288 * of the buffer.
3289 */
3290 char *bp;
3291
3292 bp = find_beginning_of_line(buf, scanp);
3293
3294 if (*bp != '\n') {
3295 strbuf_splice(&sb, 0, 0, buf, endp - buf);
3296 if (pos)
3297 break; /* need to fill another block */
3298 scanp = buf - 1; /* leave loop */
3299 } else {
3300 /*
3301 * (bp + 1) thru endp is the beginning of the
3302 * current line we have in sb
3303 */
3304 strbuf_splice(&sb, 0, 0, bp + 1, endp - (bp + 1));
3305 scanp = bp;
3306 endp = bp + 1;
3307 }
3308 ret = show_one_reflog_ent(&sb, fn, cb_data);
3309 strbuf_reset(&sb);
3310 if (ret)
3311 break;
9d33f7c2 3312 }
101d15e0 3313
2ff81662 3314 }
98f85ff4 3315 if (!ret && sb.len)
9a7a183b 3316 ret = show_one_reflog_ent(&sb, fn, cb_data);
98f85ff4 3317
2ff81662 3318 fclose(logfp);
8ca78803 3319 strbuf_release(&sb);
2266bf27 3320 return ret;
2ff81662 3321}
e29cb53a 3322
dfefa935 3323int for_each_reflog_ent(const char *refname, each_reflog_ent_fn fn, void *cb_data)
101d15e0 3324{
98f85ff4
JH
3325 FILE *logfp;
3326 struct strbuf sb = STRBUF_INIT;
3327 int ret = 0;
3328
3329 logfp = fopen(git_path("logs/%s", refname), "r");
3330 if (!logfp)
3331 return -1;
101d15e0 3332
98f85ff4
JH
3333 while (!ret && !strbuf_getwholeline(&sb, logfp, '\n'))
3334 ret = show_one_reflog_ent(&sb, fn, cb_data);
3335 fclose(logfp);
3336 strbuf_release(&sb);
3337 return ret;
3338}
989c0e5d
MH
3339/*
3340 * Call fn for each reflog in the namespace indicated by name. name
3341 * must be empty or end with '/'. Name will be used as a scratch
3342 * space, but its contents will be restored before return.
3343 */
3344static int do_for_each_reflog(struct strbuf *name, each_ref_fn fn, void *cb_data)
eb8381c8 3345{
989c0e5d 3346 DIR *d = opendir(git_path("logs/%s", name->buf));
fcee5a14 3347 int retval = 0;
93c603fc 3348 struct dirent *de;
989c0e5d 3349 int oldlen = name->len;
eb8381c8 3350
93c603fc 3351 if (!d)
989c0e5d 3352 return name->len ? errno : 0;
eb8381c8 3353
93c603fc
MH
3354 while ((de = readdir(d)) != NULL) {
3355 struct stat st;
eb8381c8 3356
93c603fc
MH
3357 if (de->d_name[0] == '.')
3358 continue;
2975c770 3359 if (ends_with(de->d_name, ".lock"))
93c603fc 3360 continue;
989c0e5d
MH
3361 strbuf_addstr(name, de->d_name);
3362 if (stat(git_path("logs/%s", name->buf), &st) < 0) {
3363 ; /* silently ignore */
93c603fc 3364 } else {
eb8381c8 3365 if (S_ISDIR(st.st_mode)) {
989c0e5d
MH
3366 strbuf_addch(name, '/');
3367 retval = do_for_each_reflog(name, fn, cb_data);
eb8381c8
NP
3368 } else {
3369 unsigned char sha1[20];
989c0e5d
MH
3370 if (read_ref_full(name->buf, sha1, 0, NULL))
3371 retval = error("bad ref for %s", name->buf);
eb8381c8 3372 else
989c0e5d 3373 retval = fn(name->buf, sha1, 0, cb_data);
eb8381c8
NP
3374 }
3375 if (retval)
3376 break;
3377 }
989c0e5d 3378 strbuf_setlen(name, oldlen);
eb8381c8 3379 }
93c603fc 3380 closedir(d);
eb8381c8
NP
3381 return retval;
3382}
3383
3384int for_each_reflog(each_ref_fn fn, void *cb_data)
3385{
989c0e5d
MH
3386 int retval;
3387 struct strbuf name;
3388 strbuf_init(&name, PATH_MAX);
3389 retval = do_for_each_reflog(&name, fn, cb_data);
3390 strbuf_release(&name);
3391 return retval;
eb8381c8 3392}
3d9f037c 3393
b5c8ea2a
MH
3394/**
3395 * Information needed for a single ref update. Set new_sha1 to the
3396 * new value or to zero to delete the ref. To check the old value
3397 * while locking the ref, set have_old to 1 and set old_sha1 to the
3398 * value or to zero to ensure the ref does not exist before update.
3399 */
3400struct ref_update {
b5c8ea2a
MH
3401 unsigned char new_sha1[20];
3402 unsigned char old_sha1[20];
3403 int flags; /* REF_NODEREF? */
3404 int have_old; /* 1 if old_sha1 is valid, 0 otherwise */
81c960e4 3405 struct ref_lock *lock;
84178db7 3406 int type;
88615910 3407 const char refname[FLEX_ARRAY];
b5c8ea2a
MH
3408};
3409
2bdc785f
RS
3410/*
3411 * Transaction states.
3412 * OPEN: The transaction is in a valid state and can accept new updates.
3413 * An OPEN transaction can be committed.
3414 * CLOSED: A closed transaction is no longer active and no other operations
3415 * than free can be used on it in this state.
3416 * A transaction can either become closed by successfully committing
3417 * an active transaction or if there is a failure while building
3418 * the transaction thus rendering it failed/inactive.
3419 */
3420enum ref_transaction_state {
3421 REF_TRANSACTION_OPEN = 0,
3422 REF_TRANSACTION_CLOSED = 1
3423};
3424
caa4046c
MH
3425/*
3426 * Data structure for holding a reference transaction, which can
3427 * consist of checks and updates to multiple references, carried out
3428 * as atomically as possible. This structure is opaque to callers.
3429 */
3430struct ref_transaction {
3431 struct ref_update **updates;
3432 size_t alloc;
3433 size_t nr;
2bdc785f 3434 enum ref_transaction_state state;
caa4046c
MH
3435};
3436
93a644ea 3437struct ref_transaction *ref_transaction_begin(struct strbuf *err)
caa4046c
MH
3438{
3439 return xcalloc(1, sizeof(struct ref_transaction));
3440}
3441
026bd1d3 3442void ref_transaction_free(struct ref_transaction *transaction)
caa4046c
MH
3443{
3444 int i;
3445
1b07255c
RS
3446 if (!transaction)
3447 return;
3448
88615910
MH
3449 for (i = 0; i < transaction->nr; i++)
3450 free(transaction->updates[i]);
caa4046c
MH
3451
3452 free(transaction->updates);
3453 free(transaction);
3454}
3455
caa4046c
MH
3456static struct ref_update *add_update(struct ref_transaction *transaction,
3457 const char *refname)
3458{
88615910
MH
3459 size_t len = strlen(refname);
3460 struct ref_update *update = xcalloc(1, sizeof(*update) + len + 1);
caa4046c 3461
88615910 3462 strcpy((char *)update->refname, refname);
caa4046c
MH
3463 ALLOC_GROW(transaction->updates, transaction->nr + 1, transaction->alloc);
3464 transaction->updates[transaction->nr++] = update;
3465 return update;
3466}
3467
8e34800e
RS
3468int ref_transaction_update(struct ref_transaction *transaction,
3469 const char *refname,
3470 const unsigned char *new_sha1,
3471 const unsigned char *old_sha1,
3472 int flags, int have_old,
3473 struct strbuf *err)
caa4046c 3474{
8e34800e 3475 struct ref_update *update;
caa4046c 3476
2bdc785f
RS
3477 if (transaction->state != REF_TRANSACTION_OPEN)
3478 die("BUG: update called for transaction that is not open");
3479
8e34800e
RS
3480 if (have_old && !old_sha1)
3481 die("BUG: have_old is true but old_sha1 is NULL");
caa4046c 3482
8e34800e 3483 update = add_update(transaction, refname);
caa4046c
MH
3484 hashcpy(update->new_sha1, new_sha1);
3485 update->flags = flags;
3486 update->have_old = have_old;
3487 if (have_old)
3488 hashcpy(update->old_sha1, old_sha1);
8e34800e 3489 return 0;
caa4046c
MH
3490}
3491
b416af5b
RS
3492int ref_transaction_create(struct ref_transaction *transaction,
3493 const char *refname,
3494 const unsigned char *new_sha1,
3495 int flags,
3496 struct strbuf *err)
caa4046c 3497{
b416af5b
RS
3498 struct ref_update *update;
3499
2bdc785f
RS
3500 if (transaction->state != REF_TRANSACTION_OPEN)
3501 die("BUG: create called for transaction that is not open");
3502
b416af5b
RS
3503 if (!new_sha1 || is_null_sha1(new_sha1))
3504 die("BUG: create ref with null new_sha1");
3505
3506 update = add_update(transaction, refname);
caa4046c 3507
caa4046c
MH
3508 hashcpy(update->new_sha1, new_sha1);
3509 hashclr(update->old_sha1);
3510 update->flags = flags;
3511 update->have_old = 1;
b416af5b 3512 return 0;
caa4046c
MH
3513}
3514
8c8bdc0d
RS
3515int ref_transaction_delete(struct ref_transaction *transaction,
3516 const char *refname,
3517 const unsigned char *old_sha1,
3518 int flags, int have_old,
3519 struct strbuf *err)
caa4046c 3520{
8c8bdc0d 3521 struct ref_update *update;
caa4046c 3522
2bdc785f
RS
3523 if (transaction->state != REF_TRANSACTION_OPEN)
3524 die("BUG: delete called for transaction that is not open");
3525
8c8bdc0d
RS
3526 if (have_old && !old_sha1)
3527 die("BUG: have_old is true but old_sha1 is NULL");
3528
3529 update = add_update(transaction, refname);
caa4046c
MH
3530 update->flags = flags;
3531 update->have_old = have_old;
3532 if (have_old) {
3533 assert(!is_null_sha1(old_sha1));
3534 hashcpy(update->old_sha1, old_sha1);
3535 }
8c8bdc0d 3536 return 0;
caa4046c
MH
3537}
3538
4738a333
BK
3539int update_ref(const char *action, const char *refname,
3540 const unsigned char *sha1, const unsigned char *oldval,
3541 int flags, enum action_on_err onerr)
3542{
b4d75ac1
RS
3543 struct ref_transaction *t;
3544 struct strbuf err = STRBUF_INIT;
3545
3546 t = ref_transaction_begin(&err);
3547 if (!t ||
3548 ref_transaction_update(t, refname, sha1, oldval, flags,
3549 !!oldval, &err) ||
3550 ref_transaction_commit(t, action, &err)) {
3551 const char *str = "update_ref failed for ref '%s': %s";
3552
3553 ref_transaction_free(t);
3554 switch (onerr) {
3555 case UPDATE_REFS_MSG_ON_ERR:
3556 error(str, refname, err.buf);
3557 break;
3558 case UPDATE_REFS_DIE_ON_ERR:
3559 die(str, refname, err.buf);
3560 break;
3561 case UPDATE_REFS_QUIET_ON_ERR:
3562 break;
3563 }
3564 strbuf_release(&err);
4738a333 3565 return 1;
b4d75ac1
RS
3566 }
3567 strbuf_release(&err);
3568 ref_transaction_free(t);
3569 return 0;
4738a333
BK
3570}
3571
98aee92d
BK
3572static int ref_update_compare(const void *r1, const void *r2)
3573{
3574 const struct ref_update * const *u1 = r1;
3575 const struct ref_update * const *u2 = r2;
5524e241 3576 return strcmp((*u1)->refname, (*u2)->refname);
98aee92d
BK
3577}
3578
3579static int ref_update_reject_duplicates(struct ref_update **updates, int n,
01319837 3580 struct strbuf *err)
98aee92d
BK
3581{
3582 int i;
3583 for (i = 1; i < n; i++)
5524e241 3584 if (!strcmp(updates[i - 1]->refname, updates[i]->refname)) {
98aee92d
BK
3585 const char *str =
3586 "Multiple updates for ref '%s' not allowed.";
038d0051
RS
3587 if (err)
3588 strbuf_addf(err, str, updates[i]->refname);
3589
98aee92d
BK
3590 return 1;
3591 }
3592 return 0;
3593}
3594
b5c8ea2a 3595int ref_transaction_commit(struct ref_transaction *transaction,
01319837 3596 const char *msg, struct strbuf *err)
98aee92d
BK
3597{
3598 int ret = 0, delnum = 0, i;
98aee92d 3599 const char **delnames;
b5c8ea2a 3600 int n = transaction->nr;
6a402338 3601 struct ref_update **updates = transaction->updates;
98aee92d 3602
2bdc785f
RS
3603 if (transaction->state != REF_TRANSACTION_OPEN)
3604 die("BUG: commit called for transaction that is not open");
3605
3606 if (!n) {
3607 transaction->state = REF_TRANSACTION_CLOSED;
98aee92d 3608 return 0;
2bdc785f 3609 }
98aee92d
BK
3610
3611 /* Allocate work space */
98aee92d
BK
3612 delnames = xmalloc(sizeof(*delnames) * n);
3613
3614 /* Copy, sort, and reject duplicate refs */
98aee92d 3615 qsort(updates, n, sizeof(*updates), ref_update_compare);
01319837 3616 ret = ref_update_reject_duplicates(updates, n, err);
98aee92d
BK
3617 if (ret)