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