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