t1404: new tests of ref D/F conflicts within transactions
[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
5fe7d825 844static int entry_matches(struct ref_entry *entry, const struct string_list *list)
d66da478 845{
5fe7d825 846 return list && string_list_has_string(list, entry->name);
5a4d4947
MH
847}
848
cbe73331 849struct nonmatching_ref_data {
5fe7d825 850 const struct string_list *skip;
cbe73331 851 struct ref_entry *found;
5a4d4947
MH
852};
853
cbe73331 854static int nonmatching_ref_fn(struct ref_entry *entry, void *vdata)
5a4d4947 855{
cbe73331
JK
856 struct nonmatching_ref_data *data = vdata;
857
858 if (entry_matches(entry, data->skip))
5a4d4947 859 return 0;
cbe73331
JK
860
861 data->found = entry;
862 return 1;
863}
864
865static void report_refname_conflict(struct ref_entry *entry,
866 const char *refname)
867{
868 error("'%s' exists; cannot create '%s'", entry->name, refname);
d66da478
MH
869}
870
bc5fd6d3
MH
871/*
872 * Return true iff a reference named refname could be created without
624cac35 873 * conflicting with the name of an existing reference in dir. If
5fe7d825
RS
874 * skip is non-NULL, ignore potential conflicts with refs in skip
875 * (e.g., because they are scheduled for deletion in the same
bc5fd6d3 876 * operation).
cbe73331
JK
877 *
878 * Two reference names conflict if one of them exactly matches the
879 * leading components of the other; e.g., "foo/bar" conflicts with
880 * both "foo" and with "foo/bar/baz" but not with "foo/bar" or
881 * "foo/barbados".
5fe7d825
RS
882 *
883 * skip must be sorted.
bc5fd6d3 884 */
5fe7d825
RS
885static int is_refname_available(const char *refname,
886 const struct string_list *skip,
d3177275 887 struct ref_dir *dir)
bc5fd6d3 888{
cbe73331
JK
889 const char *slash;
890 size_t len;
891 int pos;
892 char *dirname;
5a4d4947 893
cbe73331
JK
894 for (slash = strchr(refname, '/'); slash; slash = strchr(slash + 1, '/')) {
895 /*
896 * We are still at a leading dir of the refname; we are
897 * looking for a conflict with a leaf entry.
898 *
899 * If we find one, we still must make sure it is
5fe7d825 900 * not in "skip".
cbe73331
JK
901 */
902 pos = search_ref_dir(dir, refname, slash - refname);
903 if (pos >= 0) {
904 struct ref_entry *entry = dir->entries[pos];
5fe7d825 905 if (entry_matches(entry, skip))
cbe73331
JK
906 return 1;
907 report_refname_conflict(entry, refname);
908 return 0;
909 }
910
911
912 /*
913 * Otherwise, we can try to continue our search with
914 * the next component; if we come up empty, we know
915 * there is nothing under this whole prefix.
916 */
917 pos = search_ref_dir(dir, refname, slash + 1 - refname);
918 if (pos < 0)
919 return 1;
920
921 dir = get_ref_dir(dir->entries[pos]);
922 }
923
924 /*
925 * We are at the leaf of our refname; we want to
926 * make sure there are no directories which match it.
927 */
928 len = strlen(refname);
929 dirname = xmallocz(len + 1);
930 sprintf(dirname, "%s/", refname);
931 pos = search_ref_dir(dir, dirname, len + 1);
932 free(dirname);
933
934 if (pos >= 0) {
935 /*
936 * We found a directory named "refname". It is a
937 * problem iff it contains any ref that is not
5fe7d825 938 * in "skip".
cbe73331
JK
939 */
940 struct ref_entry *entry = dir->entries[pos];
941 struct ref_dir *dir = get_ref_dir(entry);
942 struct nonmatching_ref_data data;
943
5fe7d825 944 data.skip = skip;
cbe73331
JK
945 sort_ref_dir(dir);
946 if (!do_for_each_entry_in_dir(dir, 0, nonmatching_ref_fn, &data))
947 return 1;
948
949 report_refname_conflict(data.found, refname);
5a4d4947 950 return 0;
bc5fd6d3 951 }
cbe73331
JK
952
953 /*
954 * There is no point in searching for another leaf
955 * node which matches it; such an entry would be the
956 * ref we are looking for, not a conflict.
957 */
bc5fd6d3 958 return 1;
e1e22e37
LT
959}
960
2fff7812
MH
961struct packed_ref_cache {
962 struct ref_entry *root;
9f69d297 963
5f5e2a88
MH
964 /*
965 * Count of references to the data structure in this instance,
966 * including the pointer from ref_cache::packed if any. The
967 * data will not be freed as long as the reference count is
968 * nonzero.
969 */
970 unsigned int referrers;
971
9f69d297
MH
972 /*
973 * Iff the packed-refs file associated with this instance is
974 * currently locked for writing, this points at the associated
4f6b83e3
MH
975 * lock (which is owned by somebody else). The referrer count
976 * is also incremented when the file is locked and decremented
977 * when it is unlocked.
9f69d297
MH
978 */
979 struct lock_file *lock;
ca919930
JK
980
981 /* The metadata from when this packed-refs cache was read */
982 struct stat_validity validity;
2fff7812
MH
983};
984
5e290ff7
JH
985/*
986 * Future: need to be in "struct repository"
987 * when doing a full libification.
988 */
79c7ca54
MH
989static struct ref_cache {
990 struct ref_cache *next;
d12229f5 991 struct ref_entry *loose;
2fff7812 992 struct packed_ref_cache *packed;
9da31cb0
MH
993 /*
994 * The submodule name, or "" for the main repo. We allocate
995 * length 1 rather than FLEX_ARRAY so that the main ref_cache
996 * is initialized correctly.
997 */
998 char name[1];
999} ref_cache, *submodule_ref_caches;
0e88c130 1000
9f69d297
MH
1001/* Lock used for the main packed-refs file: */
1002static struct lock_file packlock;
1003
5f5e2a88
MH
1004/*
1005 * Increment the reference count of *packed_refs.
1006 */
1007static void acquire_packed_ref_cache(struct packed_ref_cache *packed_refs)
1008{
1009 packed_refs->referrers++;
1010}
1011
1012/*
1013 * Decrease the reference count of *packed_refs. If it goes to zero,
1014 * free *packed_refs and return true; otherwise return false.
1015 */
1016static int release_packed_ref_cache(struct packed_ref_cache *packed_refs)
1017{
1018 if (!--packed_refs->referrers) {
1019 free_ref_entry(packed_refs->root);
ca919930 1020 stat_validity_clear(&packed_refs->validity);
5f5e2a88
MH
1021 free(packed_refs);
1022 return 1;
1023 } else {
1024 return 0;
1025 }
1026}
1027
760c4512 1028static void clear_packed_ref_cache(struct ref_cache *refs)
e1e22e37 1029{
d12229f5 1030 if (refs->packed) {
5f5e2a88
MH
1031 struct packed_ref_cache *packed_refs = refs->packed;
1032
1033 if (packed_refs->lock)
9f69d297 1034 die("internal error: packed-ref cache cleared while locked");
d12229f5 1035 refs->packed = NULL;
5f5e2a88 1036 release_packed_ref_cache(packed_refs);
d12229f5 1037 }
5e290ff7 1038}
e1e22e37 1039
760c4512
MH
1040static void clear_loose_ref_cache(struct ref_cache *refs)
1041{
d12229f5
MH
1042 if (refs->loose) {
1043 free_ref_entry(refs->loose);
1044 refs->loose = NULL;
1045 }
760c4512
MH
1046}
1047
79c7ca54 1048static struct ref_cache *create_ref_cache(const char *submodule)
e5dbf605 1049{
ce40979c 1050 int len;
79c7ca54 1051 struct ref_cache *refs;
ce40979c
MH
1052 if (!submodule)
1053 submodule = "";
1054 len = strlen(submodule) + 1;
79c7ca54 1055 refs = xcalloc(1, sizeof(struct ref_cache) + len);
ce40979c 1056 memcpy(refs->name, submodule, len);
e5dbf605
MH
1057 return refs;
1058}
1059
4349a668 1060/*
79c7ca54 1061 * Return a pointer to a ref_cache for the specified submodule. For
4349a668
MH
1062 * the main repository, use submodule==NULL. The returned structure
1063 * will be allocated and initialized but not necessarily populated; it
1064 * should not be freed.
1065 */
79c7ca54 1066static struct ref_cache *get_ref_cache(const char *submodule)
4349a668 1067{
9da31cb0
MH
1068 struct ref_cache *refs;
1069
1070 if (!submodule || !*submodule)
1071 return &ref_cache;
1072
1073 for (refs = submodule_ref_caches; refs; refs = refs->next)
0e88c130
MH
1074 if (!strcmp(submodule, refs->name))
1075 return refs;
0e88c130 1076
79c7ca54 1077 refs = create_ref_cache(submodule);
9da31cb0
MH
1078 refs->next = submodule_ref_caches;
1079 submodule_ref_caches = refs;
0e88c130 1080 return refs;
4349a668
MH
1081}
1082
3feb4f0c
MH
1083/* The length of a peeled reference line in packed-refs, including EOL: */
1084#define PEELED_LINE_LENGTH 42
1085
694b7a19
MH
1086/*
1087 * The packed-refs header line that we write out. Perhaps other
1088 * traits will be added later. The trailing space is required.
1089 */
1090static const char PACKED_REFS_HEADER[] =
1091 "# pack-refs with: peeled fully-peeled \n";
1092
bc5fd6d3
MH
1093/*
1094 * Parse one line from a packed-refs file. Write the SHA1 to sha1.
1095 * Return a pointer to the refname within the line (null-terminated),
1096 * or NULL if there was a problem.
1097 */
6a49870a 1098static const char *parse_ref_line(struct strbuf *line, unsigned char *sha1)
bc5fd6d3 1099{
6a49870a
JK
1100 const char *ref;
1101
bc5fd6d3
MH
1102 /*
1103 * 42: the answer to everything.
1104 *
1105 * In this case, it happens to be the answer to
1106 * 40 (length of sha1 hex representation)
1107 * +1 (space in between hex and name)
1108 * +1 (newline at the end of the line)
1109 */
6a49870a 1110 if (line->len <= 42)
bc5fd6d3 1111 return NULL;
6a49870a
JK
1112
1113 if (get_sha1_hex(line->buf, sha1) < 0)
bc5fd6d3 1114 return NULL;
6a49870a 1115 if (!isspace(line->buf[40]))
bc5fd6d3 1116 return NULL;
6a49870a
JK
1117
1118 ref = line->buf + 41;
1119 if (isspace(*ref))
bc5fd6d3 1120 return NULL;
6a49870a
JK
1121
1122 if (line->buf[line->len - 1] != '\n')
bc5fd6d3 1123 return NULL;
6a49870a 1124 line->buf[--line->len] = 0;
bc5fd6d3 1125
6a49870a 1126 return ref;
bc5fd6d3
MH
1127}
1128
c29c46fa
MH
1129/*
1130 * Read f, which is a packed-refs file, into dir.
1131 *
1132 * A comment line of the form "# pack-refs with: " may contain zero or
1133 * more traits. We interpret the traits as follows:
1134 *
1135 * No traits:
1136 *
1137 * Probably no references are peeled. But if the file contains a
1138 * peeled value for a reference, we will use it.
1139 *
1140 * peeled:
1141 *
1142 * References under "refs/tags/", if they *can* be peeled, *are*
1143 * peeled in this file. References outside of "refs/tags/" are
1144 * probably not peeled even if they could have been, but if we find
1145 * a peeled value for such a reference we will use it.
1146 *
1147 * fully-peeled:
1148 *
1149 * All references in the file that can be peeled are peeled.
1150 * Inversely (and this is more important), any references in the
1151 * file for which no peeled value is recorded is not peelable. This
1152 * trait should typically be written alongside "peeled" for
1153 * compatibility with older clients, but we do not require it
1154 * (i.e., "peeled" is a no-op if "fully-peeled" is set).
1155 */
d3177275 1156static void read_packed_refs(FILE *f, struct ref_dir *dir)
f4204ab9 1157{
e9c4c111 1158 struct ref_entry *last = NULL;
10c497aa 1159 struct strbuf line = STRBUF_INIT;
c29c46fa 1160 enum { PEELED_NONE, PEELED_TAGS, PEELED_FULLY } peeled = PEELED_NONE;
f4204ab9 1161
10c497aa 1162 while (strbuf_getwholeline(&line, f, '\n') != EOF) {
f4204ab9 1163 unsigned char sha1[20];
dfefa935 1164 const char *refname;
ea417833 1165 const char *traits;
f4204ab9 1166
ea417833 1167 if (skip_prefix(line.buf, "# pack-refs with:", &traits)) {
c29c46fa
MH
1168 if (strstr(traits, " fully-peeled "))
1169 peeled = PEELED_FULLY;
1170 else if (strstr(traits, " peeled "))
1171 peeled = PEELED_TAGS;
f4204ab9
JH
1172 /* perhaps other traits later as well */
1173 continue;
1174 }
1175
6a49870a 1176 refname = parse_ref_line(&line, sha1);
dfefa935 1177 if (refname) {
d0f810f0
RS
1178 int flag = REF_ISPACKED;
1179
1180 if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL)) {
1181 hashclr(sha1);
1182 flag |= REF_BAD_NAME | REF_ISBROKEN;
1183 }
1184 last = create_ref_entry(refname, sha1, flag, 0);
c29c46fa 1185 if (peeled == PEELED_FULLY ||
59556548 1186 (peeled == PEELED_TAGS && starts_with(refname, "refs/tags/")))
c29c46fa 1187 last->flag |= REF_KNOWS_PEELED;
d3177275 1188 add_ref(dir, last);
f4204ab9
JH
1189 continue;
1190 }
1191 if (last &&
10c497aa
JK
1192 line.buf[0] == '^' &&
1193 line.len == PEELED_LINE_LENGTH &&
1194 line.buf[PEELED_LINE_LENGTH - 1] == '\n' &&
1195 !get_sha1_hex(line.buf + 1, sha1)) {
593f1bb8 1196 hashcpy(last->u.value.peeled, sha1);
c29c46fa
MH
1197 /*
1198 * Regardless of what the file header said,
1199 * we definitely know the value of *this*
1200 * reference:
1201 */
1202 last->flag |= REF_KNOWS_PEELED;
1203 }
f4204ab9 1204 }
10c497aa
JK
1205
1206 strbuf_release(&line);
f4204ab9
JH
1207}
1208
2fff7812
MH
1209/*
1210 * Get the packed_ref_cache for the specified ref_cache, creating it
1211 * if necessary.
1212 */
1213static struct packed_ref_cache *get_packed_ref_cache(struct ref_cache *refs)
5e290ff7 1214{
ca919930
JK
1215 const char *packed_refs_file;
1216
1217 if (*refs->name)
1218 packed_refs_file = git_path_submodule(refs->name, "packed-refs");
1219 else
1220 packed_refs_file = git_path("packed-refs");
1221
1222 if (refs->packed &&
1223 !stat_validity_check(&refs->packed->validity, packed_refs_file))
1224 clear_packed_ref_cache(refs);
1225
d12229f5 1226 if (!refs->packed) {
4349a668 1227 FILE *f;
0bad611b 1228
2fff7812 1229 refs->packed = xcalloc(1, sizeof(*refs->packed));
5f5e2a88 1230 acquire_packed_ref_cache(refs->packed);
2fff7812 1231 refs->packed->root = create_dir_entry(refs, "", 0, 0);
4349a668 1232 f = fopen(packed_refs_file, "r");
e1e22e37 1233 if (f) {
ca919930 1234 stat_validity_update(&refs->packed->validity, fileno(f));
2fff7812 1235 read_packed_refs(f, get_ref_dir(refs->packed->root));
e1e22e37 1236 fclose(f);
e1e22e37 1237 }
e1e22e37 1238 }
2fff7812
MH
1239 return refs->packed;
1240}
1241
1242static struct ref_dir *get_packed_ref_dir(struct packed_ref_cache *packed_ref_cache)
1243{
1244 return get_ref_dir(packed_ref_cache->root);
1245}
1246
1247static struct ref_dir *get_packed_refs(struct ref_cache *refs)
1248{
1249 return get_packed_ref_dir(get_packed_ref_cache(refs));
e1e22e37
LT
1250}
1251
30249ee6
MH
1252void add_packed_ref(const char *refname, const unsigned char *sha1)
1253{
9f69d297
MH
1254 struct packed_ref_cache *packed_ref_cache =
1255 get_packed_ref_cache(&ref_cache);
1256
1257 if (!packed_ref_cache->lock)
1258 die("internal error: packed refs not locked");
1259 add_ref(get_packed_ref_dir(packed_ref_cache),
9da31cb0 1260 create_ref_entry(refname, sha1, REF_ISPACKED, 1));
30249ee6
MH
1261}
1262
abc39098 1263/*
28e6a34e
MH
1264 * Read the loose references from the namespace dirname into dir
1265 * (without recursing). dirname must end with '/'. dir must be the
1266 * directory entry corresponding to dirname.
abc39098 1267 */
423a1afc 1268static void read_loose_refs(const char *dirname, struct ref_dir *dir)
e1e22e37 1269{
423a1afc 1270 struct ref_cache *refs = dir->ref_cache;
d3177275 1271 DIR *d;
0bad611b 1272 const char *path;
d5fdae67 1273 struct dirent *de;
abc39098 1274 int dirnamelen = strlen(dirname);
72b64b44 1275 struct strbuf refname;
0bad611b 1276
3b124823 1277 if (*refs->name)
66a3d20b 1278 path = git_path_submodule(refs->name, "%s", dirname);
0bad611b 1279 else
66a3d20b 1280 path = git_path("%s", dirname);
0bad611b 1281
d3177275 1282 d = opendir(path);
d5fdae67
MH
1283 if (!d)
1284 return;
1285
66a3d20b
MH
1286 strbuf_init(&refname, dirnamelen + 257);
1287 strbuf_add(&refname, dirname, dirnamelen);
d5fdae67
MH
1288
1289 while ((de = readdir(d)) != NULL) {
1290 unsigned char sha1[20];
1291 struct stat st;
1292 int flag;
d5fdae67
MH
1293 const char *refdir;
1294
1295 if (de->d_name[0] == '.')
1296 continue;
2975c770 1297 if (ends_with(de->d_name, ".lock"))
d5fdae67 1298 continue;
72b64b44 1299 strbuf_addstr(&refname, de->d_name);
d5fdae67 1300 refdir = *refs->name
72b64b44
MH
1301 ? git_path_submodule(refs->name, "%s", refname.buf)
1302 : git_path("%s", refname.buf);
1303 if (stat(refdir, &st) < 0) {
1304 ; /* silently ignore */
1305 } else if (S_ISDIR(st.st_mode)) {
abc39098 1306 strbuf_addch(&refname, '/');
28e6a34e 1307 add_entry_to_dir(dir,
b9146f51
RS
1308 create_dir_entry(refs, refname.buf,
1309 refname.len, 1));
72b64b44 1310 } else {
3b124823 1311 if (*refs->name) {
f8948e2f 1312 hashclr(sha1);
0bad611b 1313 flag = 0;
72b64b44 1314 if (resolve_gitlink_ref(refs->name, refname.buf, sha1) < 0) {
0bad611b 1315 hashclr(sha1);
98ac34b2 1316 flag |= REF_ISBROKEN;
0bad611b 1317 }
7695d118
RS
1318 } else if (read_ref_full(refname.buf,
1319 RESOLVE_REF_READING,
1320 sha1, &flag)) {
09116a1c
JH
1321 hashclr(sha1);
1322 flag |= REF_ISBROKEN;
1323 }
d0f810f0
RS
1324 if (check_refname_format(refname.buf,
1325 REFNAME_ALLOW_ONELEVEL)) {
1326 hashclr(sha1);
1327 flag |= REF_BAD_NAME | REF_ISBROKEN;
1328 }
9f2fb4a3 1329 add_entry_to_dir(dir,
d0f810f0 1330 create_ref_entry(refname.buf, sha1, flag, 0));
e1e22e37 1331 }
66a3d20b 1332 strbuf_setlen(&refname, dirnamelen);
e1e22e37 1333 }
72b64b44 1334 strbuf_release(&refname);
d5fdae67 1335 closedir(d);
e1e22e37
LT
1336}
1337
d3177275 1338static struct ref_dir *get_loose_refs(struct ref_cache *refs)
e1e22e37 1339{
d12229f5 1340 if (!refs->loose) {
28e6a34e
MH
1341 /*
1342 * Mark the top-level directory complete because we
1343 * are about to read the only subdirectory that can
1344 * hold references:
1345 */
b9146f51 1346 refs->loose = create_dir_entry(refs, "", 0, 0);
28e6a34e
MH
1347 /*
1348 * Create an incomplete entry for "refs/":
1349 */
1350 add_entry_to_dir(get_ref_dir(refs->loose),
b9146f51 1351 create_dir_entry(refs, "refs/", 5, 1));
e1e22e37 1352 }
d7826d54 1353 return get_ref_dir(refs->loose);
e1e22e37
LT
1354}
1355
ca8db142
LT
1356/* We allow "recursive" symbolic refs. Only within reason, though */
1357#define MAXDEPTH 5
0ebde32c
LT
1358#define MAXREFLEN (1024)
1359
e5fa45c1
JH
1360/*
1361 * Called by resolve_gitlink_ref_recursive() after it failed to read
b0626608
MH
1362 * from the loose refs in ref_cache refs. Find <refname> in the
1363 * packed-refs file for the submodule.
e5fa45c1 1364 */
b0626608 1365static int resolve_gitlink_packed_ref(struct ref_cache *refs,
85be1fe3 1366 const char *refname, unsigned char *sha1)
0ebde32c 1367{
2c5c66be 1368 struct ref_entry *ref;
d3177275 1369 struct ref_dir *dir = get_packed_refs(refs);
0ebde32c 1370
432ad41e 1371 ref = find_ref(dir, refname);
b0626608
MH
1372 if (ref == NULL)
1373 return -1;
1374
50546b15 1375 hashcpy(sha1, ref->u.value.sha1);
b0626608 1376 return 0;
0ebde32c
LT
1377}
1378
b0626608 1379static int resolve_gitlink_ref_recursive(struct ref_cache *refs,
85be1fe3 1380 const char *refname, unsigned char *sha1,
dfefa935 1381 int recursion)
0ebde32c 1382{
064d51dc 1383 int fd, len;
0ebde32c 1384 char buffer[128], *p;
064d51dc 1385 char *path;
0ebde32c 1386
064d51dc 1387 if (recursion > MAXDEPTH || strlen(refname) > MAXREFLEN)
0ebde32c 1388 return -1;
064d51dc
MH
1389 path = *refs->name
1390 ? git_path_submodule(refs->name, "%s", refname)
1391 : git_path("%s", refname);
1392 fd = open(path, O_RDONLY);
0ebde32c 1393 if (fd < 0)
b0626608 1394 return resolve_gitlink_packed_ref(refs, refname, sha1);
0ebde32c
LT
1395
1396 len = read(fd, buffer, sizeof(buffer)-1);
1397 close(fd);
1398 if (len < 0)
1399 return -1;
1400 while (len && isspace(buffer[len-1]))
1401 len--;
1402 buffer[len] = 0;
1403
1404 /* Was it a detached head or an old-fashioned symlink? */
85be1fe3 1405 if (!get_sha1_hex(buffer, sha1))
0ebde32c
LT
1406 return 0;
1407
1408 /* Symref? */
1409 if (strncmp(buffer, "ref:", 4))
1410 return -1;
1411 p = buffer + 4;
1412 while (isspace(*p))
1413 p++;
1414
064d51dc 1415 return resolve_gitlink_ref_recursive(refs, p, sha1, recursion+1);
0ebde32c
LT
1416}
1417
85be1fe3 1418int resolve_gitlink_ref(const char *path, const char *refname, unsigned char *sha1)
0ebde32c
LT
1419{
1420 int len = strlen(path), retval;
064d51dc 1421 char *submodule;
b0626608 1422 struct ref_cache *refs;
0ebde32c
LT
1423
1424 while (len && path[len-1] == '/')
1425 len--;
1426 if (!len)
1427 return -1;
b0626608
MH
1428 submodule = xstrndup(path, len);
1429 refs = get_ref_cache(submodule);
1430 free(submodule);
1431
064d51dc 1432 retval = resolve_gitlink_ref_recursive(refs, refname, sha1, 0);
0ebde32c
LT
1433 return retval;
1434}
ca8db142 1435
4886b89f 1436/*
63331581
MH
1437 * Return the ref_entry for the given refname from the packed
1438 * references. If it does not exist, return NULL.
4886b89f 1439 */
63331581 1440static struct ref_entry *get_packed_ref(const char *refname)
c224ca7f 1441{
9da31cb0 1442 return find_ref(get_packed_refs(&ref_cache), refname);
c224ca7f
MH
1443}
1444
47f534bf
MH
1445/*
1446 * A loose ref file doesn't exist; check for a packed ref. The
1447 * options are forwarded from resolve_safe_unsafe().
1448 */
d0f810f0
RS
1449static int resolve_missing_loose_ref(const char *refname,
1450 int resolve_flags,
1451 unsigned char *sha1,
1452 int *flags)
47f534bf
MH
1453{
1454 struct ref_entry *entry;
1455
1456 /*
1457 * The loose reference file does not exist; check for a packed
1458 * reference.
1459 */
1460 entry = get_packed_ref(refname);
1461 if (entry) {
1462 hashcpy(sha1, entry->u.value.sha1);
7695d118
RS
1463 if (flags)
1464 *flags |= REF_ISPACKED;
d0f810f0 1465 return 0;
47f534bf
MH
1466 }
1467 /* The reference is not a packed reference, either. */
7695d118 1468 if (resolve_flags & RESOLVE_REF_READING) {
d0f810f0
RS
1469 errno = ENOENT;
1470 return -1;
47f534bf
MH
1471 } else {
1472 hashclr(sha1);
d0f810f0 1473 return 0;
47f534bf
MH
1474 }
1475}
1476
76d70dc0 1477/* This function needs to return a meaningful errno on failure */
7695d118 1478const char *resolve_ref_unsafe(const char *refname, int resolve_flags, unsigned char *sha1, int *flags)
8a65ff76 1479{
0104ca09
HO
1480 int depth = MAXDEPTH;
1481 ssize_t len;
a876ed83 1482 char buffer[256];
dfefa935 1483 static char refname_buffer[256];
d0f810f0 1484 int bad_name = 0;
ca8db142 1485
7695d118
RS
1486 if (flags)
1487 *flags = 0;
8da19775 1488
76d70dc0 1489 if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL)) {
d0f810f0
RS
1490 if (flags)
1491 *flags |= REF_BAD_NAME;
1492
1493 if (!(resolve_flags & RESOLVE_REF_ALLOW_BAD_NAME) ||
1494 !refname_is_safe(refname)) {
1495 errno = EINVAL;
1496 return NULL;
1497 }
1498 /*
1499 * dwim_ref() uses REF_ISBROKEN to distinguish between
1500 * missing refs and refs that were present but invalid,
1501 * to complain about the latter to stderr.
1502 *
1503 * We don't know whether the ref exists, so don't set
1504 * REF_ISBROKEN yet.
1505 */
1506 bad_name = 1;
76d70dc0 1507 }
a876ed83 1508 for (;;) {
55956350 1509 char path[PATH_MAX];
a876ed83
JH
1510 struct stat st;
1511 char *buf;
1512 int fd;
8a65ff76 1513
76d70dc0
RS
1514 if (--depth < 0) {
1515 errno = ELOOP;
a876ed83 1516 return NULL;
76d70dc0 1517 }
ca8db142 1518
dfefa935 1519 git_snpath(path, sizeof(path), "%s", refname);
c224ca7f 1520
fcb7c762
MH
1521 /*
1522 * We might have to loop back here to avoid a race
1523 * condition: first we lstat() the file, then we try
1524 * to read it as a link or as a file. But if somebody
1525 * changes the type of the file (file <-> directory
1526 * <-> symlink) between the lstat() and reading, then
1527 * we don't want to report that as an error but rather
1528 * try again starting with the lstat().
1529 */
1530 stat_ref:
a876ed83 1531 if (lstat(path, &st) < 0) {
d0f810f0
RS
1532 if (errno != ENOENT)
1533 return NULL;
1534 if (resolve_missing_loose_ref(refname, resolve_flags,
1535 sha1, flags))
a876ed83 1536 return NULL;
d0f810f0
RS
1537 if (bad_name) {
1538 hashclr(sha1);
1539 if (flags)
1540 *flags |= REF_ISBROKEN;
1541 }
1542 return refname;
a876ed83 1543 }
ca8db142 1544
a876ed83
JH
1545 /* Follow "normalized" - ie "refs/.." symlinks by hand */
1546 if (S_ISLNK(st.st_mode)) {
1547 len = readlink(path, buffer, sizeof(buffer)-1);
fcb7c762
MH
1548 if (len < 0) {
1549 if (errno == ENOENT || errno == EINVAL)
1550 /* inconsistent with lstat; retry */
1551 goto stat_ref;
1552 else
1553 return NULL;
1554 }
b54cb795 1555 buffer[len] = 0;
59556548 1556 if (starts_with(buffer, "refs/") &&
1f58a038 1557 !check_refname_format(buffer, 0)) {
dfefa935
MH
1558 strcpy(refname_buffer, buffer);
1559 refname = refname_buffer;
7695d118
RS
1560 if (flags)
1561 *flags |= REF_ISSYMREF;
62a2d525
JN
1562 if (resolve_flags & RESOLVE_REF_NO_RECURSE) {
1563 hashclr(sha1);
1564 return refname;
1565 }
a876ed83
JH
1566 continue;
1567 }
ca8db142 1568 }
a876ed83 1569
7a21632f
DS
1570 /* Is it a directory? */
1571 if (S_ISDIR(st.st_mode)) {
1572 errno = EISDIR;
1573 return NULL;
1574 }
1575
a876ed83
JH
1576 /*
1577 * Anything else, just open it and try to use it as
1578 * a ref
1579 */
1580 fd = open(path, O_RDONLY);
fcb7c762
MH
1581 if (fd < 0) {
1582 if (errno == ENOENT)
1583 /* inconsistent with lstat; retry */
1584 goto stat_ref;
1585 else
1586 return NULL;
1587 }
93d26e4c 1588 len = read_in_full(fd, buffer, sizeof(buffer)-1);
76d70dc0
RS
1589 if (len < 0) {
1590 int save_errno = errno;
1591 close(fd);
1592 errno = save_errno;
28775050 1593 return NULL;
76d70dc0
RS
1594 }
1595 close(fd);
28775050
MH
1596 while (len && isspace(buffer[len-1]))
1597 len--;
1598 buffer[len] = '\0';
a876ed83
JH
1599
1600 /*
1601 * Is it a symbolic ref?
1602 */
59556548 1603 if (!starts_with(buffer, "ref:")) {
2884c06a
MH
1604 /*
1605 * Please note that FETCH_HEAD has a second
1606 * line containing other data.
1607 */
1608 if (get_sha1_hex(buffer, sha1) ||
1609 (buffer[40] != '\0' && !isspace(buffer[40]))) {
7695d118
RS
1610 if (flags)
1611 *flags |= REF_ISBROKEN;
76d70dc0 1612 errno = EINVAL;
2884c06a
MH
1613 return NULL;
1614 }
d0f810f0
RS
1615 if (bad_name) {
1616 hashclr(sha1);
1617 if (flags)
1618 *flags |= REF_ISBROKEN;
1619 }
2884c06a
MH
1620 return refname;
1621 }
7695d118
RS
1622 if (flags)
1623 *flags |= REF_ISSYMREF;
a876ed83 1624 buf = buffer + 4;
28775050
MH
1625 while (isspace(*buf))
1626 buf++;
62a2d525
JN
1627 refname = strcpy(refname_buffer, buf);
1628 if (resolve_flags & RESOLVE_REF_NO_RECURSE) {
1629 hashclr(sha1);
1630 return refname;
1631 }
313fb010 1632 if (check_refname_format(buf, REFNAME_ALLOW_ONELEVEL)) {
7695d118
RS
1633 if (flags)
1634 *flags |= REF_ISBROKEN;
d0f810f0
RS
1635
1636 if (!(resolve_flags & RESOLVE_REF_ALLOW_BAD_NAME) ||
1637 !refname_is_safe(buf)) {
1638 errno = EINVAL;
1639 return NULL;
1640 }
1641 bad_name = 1;
313fb010 1642 }
8a65ff76 1643 }
a876ed83
JH
1644}
1645
7695d118 1646char *resolve_refdup(const char *ref, int resolve_flags, unsigned char *sha1, int *flags)
96ec7b1e 1647{
092c4be7 1648 return xstrdup_or_null(resolve_ref_unsafe(ref, resolve_flags, sha1, flags));
96ec7b1e
NTND
1649}
1650
d08bae7e
IL
1651/* The argument to filter_refs */
1652struct ref_filter {
1653 const char *pattern;
1654 each_ref_fn *fn;
1655 void *cb_data;
1656};
1657
7695d118 1658int read_ref_full(const char *refname, int resolve_flags, unsigned char *sha1, int *flags)
a876ed83 1659{
7695d118 1660 if (resolve_ref_unsafe(refname, resolve_flags, sha1, flags))
a876ed83
JH
1661 return 0;
1662 return -1;
8a65ff76
LT
1663}
1664
dfefa935 1665int read_ref(const char *refname, unsigned char *sha1)
c6893323 1666{
7695d118 1667 return read_ref_full(refname, RESOLVE_REF_READING, sha1, NULL);
c6893323
NTND
1668}
1669
bc5fd6d3 1670int ref_exists(const char *refname)
ef06b918 1671{
bc5fd6d3 1672 unsigned char sha1[20];
7695d118 1673 return !!resolve_ref_unsafe(refname, RESOLVE_REF_READING, sha1, NULL);
ef06b918
JH
1674}
1675
85be1fe3 1676static int filter_refs(const char *refname, const unsigned char *sha1, int flags,
dfefa935 1677 void *data)
d08bae7e
IL
1678{
1679 struct ref_filter *filter = (struct ref_filter *)data;
eb07894f 1680 if (wildmatch(filter->pattern, refname, 0, NULL))
d08bae7e 1681 return 0;
85be1fe3 1682 return filter->fn(refname, sha1, flags, filter->cb_data);
d08bae7e
IL
1683}
1684
68cf8703
MH
1685enum peel_status {
1686 /* object was peeled successfully: */
1687 PEEL_PEELED = 0,
1688
1689 /*
1690 * object cannot be peeled because the named object (or an
1691 * object referred to by a tag in the peel chain), does not
1692 * exist.
1693 */
1694 PEEL_INVALID = -1,
1695
1696 /* object cannot be peeled because it is not a tag: */
9a489f3c
MH
1697 PEEL_NON_TAG = -2,
1698
1699 /* ref_entry contains no peeled value because it is a symref: */
1700 PEEL_IS_SYMREF = -3,
1701
1702 /*
1703 * ref_entry cannot be peeled because it is broken (i.e., the
1704 * symbolic reference cannot even be resolved to an object
1705 * name):
1706 */
1707 PEEL_BROKEN = -4
68cf8703
MH
1708};
1709
cb2ae1c4
MH
1710/*
1711 * Peel the named object; i.e., if the object is a tag, resolve the
68cf8703
MH
1712 * tag recursively until a non-tag is found. If successful, store the
1713 * result to sha1 and return PEEL_PEELED. If the object is not a tag
1714 * or is not valid, return PEEL_NON_TAG or PEEL_INVALID, respectively,
1715 * and leave sha1 unchanged.
cb2ae1c4 1716 */
68cf8703 1717static enum peel_status peel_object(const unsigned char *name, unsigned char *sha1)
cb2ae1c4
MH
1718{
1719 struct object *o = lookup_unknown_object(name);
1720
1721 if (o->type == OBJ_NONE) {
1722 int type = sha1_object_info(name, NULL);
8ff226a9 1723 if (type < 0 || !object_as_type(o, type, 0))
68cf8703 1724 return PEEL_INVALID;
cb2ae1c4
MH
1725 }
1726
1727 if (o->type != OBJ_TAG)
68cf8703 1728 return PEEL_NON_TAG;
cb2ae1c4
MH
1729
1730 o = deref_tag_noverify(o);
1731 if (!o)
68cf8703 1732 return PEEL_INVALID;
cb2ae1c4
MH
1733
1734 hashcpy(sha1, o->sha1);
68cf8703 1735 return PEEL_PEELED;
cb2ae1c4
MH
1736}
1737
9a489f3c 1738/*
f85354b5
MH
1739 * Peel the entry (if possible) and return its new peel_status. If
1740 * repeel is true, re-peel the entry even if there is an old peeled
1741 * value that is already stored in it.
694b7a19
MH
1742 *
1743 * It is OK to call this function with a packed reference entry that
1744 * might be stale and might even refer to an object that has since
1745 * been garbage-collected. In such a case, if the entry has
1746 * REF_KNOWS_PEELED then leave the status unchanged and return
1747 * PEEL_PEELED or PEEL_NON_TAG; otherwise, return PEEL_INVALID.
9a489f3c 1748 */
f85354b5 1749static enum peel_status peel_entry(struct ref_entry *entry, int repeel)
9a489f3c
MH
1750{
1751 enum peel_status status;
1752
f85354b5
MH
1753 if (entry->flag & REF_KNOWS_PEELED) {
1754 if (repeel) {
1755 entry->flag &= ~REF_KNOWS_PEELED;
1756 hashclr(entry->u.value.peeled);
1757 } else {
1758 return is_null_sha1(entry->u.value.peeled) ?
1759 PEEL_NON_TAG : PEEL_PEELED;
1760 }
1761 }
9a489f3c
MH
1762 if (entry->flag & REF_ISBROKEN)
1763 return PEEL_BROKEN;
1764 if (entry->flag & REF_ISSYMREF)
1765 return PEEL_IS_SYMREF;
1766
1767 status = peel_object(entry->u.value.sha1, entry->u.value.peeled);
1768 if (status == PEEL_PEELED || status == PEEL_NON_TAG)
1769 entry->flag |= REF_KNOWS_PEELED;
1770 return status;
1771}
1772
dfefa935 1773int peel_ref(const char *refname, unsigned char *sha1)
cf0adba7
JH
1774{
1775 int flag;
1776 unsigned char base[20];
cf0adba7 1777
dfefa935 1778 if (current_ref && (current_ref->name == refname
9a489f3c 1779 || !strcmp(current_ref->name, refname))) {
f85354b5 1780 if (peel_entry(current_ref, 0))
9a489f3c
MH
1781 return -1;
1782 hashcpy(sha1, current_ref->u.value.peeled);
1783 return 0;
0ae91be0
SP
1784 }
1785
7695d118 1786 if (read_ref_full(refname, RESOLVE_REF_READING, base, &flag))
cf0adba7
JH
1787 return -1;
1788
9a489f3c
MH
1789 /*
1790 * If the reference is packed, read its ref_entry from the
1791 * cache in the hope that we already know its peeled value.
1792 * We only try this optimization on packed references because
1793 * (a) forcing the filling of the loose reference cache could
1794 * be expensive and (b) loose references anyway usually do not
1795 * have REF_KNOWS_PEELED.
1796 */
1797 if (flag & REF_ISPACKED) {
f361baeb 1798 struct ref_entry *r = get_packed_ref(refname);
9a489f3c 1799 if (r) {
f85354b5 1800 if (peel_entry(r, 0))
9a489f3c 1801 return -1;
593f1bb8 1802 hashcpy(sha1, r->u.value.peeled);
e9c4c111 1803 return 0;
cf0adba7 1804 }
cf0adba7
JH
1805 }
1806
cb2ae1c4 1807 return peel_object(base, sha1);
cf0adba7
JH
1808}
1809
bc5fd6d3
MH
1810struct warn_if_dangling_data {
1811 FILE *fp;
1812 const char *refname;
e6bea66d 1813 const struct string_list *refnames;
bc5fd6d3
MH
1814 const char *msg_fmt;
1815};
1816
1817static int warn_if_dangling_symref(const char *refname, const unsigned char *sha1,
1818 int flags, void *cb_data)
1819{
1820 struct warn_if_dangling_data *d = cb_data;
1821 const char *resolves_to;
1822 unsigned char junk[20];
1823
1824 if (!(flags & REF_ISSYMREF))
1825 return 0;
1826
7695d118 1827 resolves_to = resolve_ref_unsafe(refname, 0, junk, NULL);
e6bea66d
JL
1828 if (!resolves_to
1829 || (d->refname
1830 ? strcmp(resolves_to, d->refname)
1831 : !string_list_has_string(d->refnames, resolves_to))) {
bc5fd6d3 1832 return 0;
e6bea66d 1833 }
bc5fd6d3
MH
1834
1835 fprintf(d->fp, d->msg_fmt, refname);
1be65eda 1836 fputc('\n', d->fp);
bc5fd6d3
MH
1837 return 0;
1838}
1839
1840void warn_dangling_symref(FILE *fp, const char *msg_fmt, const char *refname)
1841{
1842 struct warn_if_dangling_data data;
1843
1844 data.fp = fp;
1845 data.refname = refname;
e6bea66d
JL
1846 data.refnames = NULL;
1847 data.msg_fmt = msg_fmt;
1848 for_each_rawref(warn_if_dangling_symref, &data);
1849}
1850
1851void warn_dangling_symrefs(FILE *fp, const char *msg_fmt, const struct string_list *refnames)
1852{
1853 struct warn_if_dangling_data data;
1854
1855 data.fp = fp;
1856 data.refname = NULL;
1857 data.refnames = refnames;
bc5fd6d3
MH
1858 data.msg_fmt = msg_fmt;
1859 for_each_rawref(warn_if_dangling_symref, &data);
1860}
1861
fcce1703 1862/*
65cf102b 1863 * Call fn for each reference in the specified ref_cache, omitting
624cac35
MH
1864 * references not in the containing_dir of base. fn is called for all
1865 * references, including broken ones. If fn ever returns a non-zero
fcce1703
MH
1866 * value, stop the iteration and return that value; otherwise, return
1867 * 0.
1868 */
65cf102b 1869static int do_for_each_entry(struct ref_cache *refs, const char *base,
624cac35 1870 each_ref_entry_fn fn, void *cb_data)
8a65ff76 1871{
98eeb09e
JK
1872 struct packed_ref_cache *packed_ref_cache;
1873 struct ref_dir *loose_dir;
1874 struct ref_dir *packed_dir;
933ac036
MH
1875 int retval = 0;
1876
98eeb09e
JK
1877 /*
1878 * We must make sure that all loose refs are read before accessing the
1879 * packed-refs file; this avoids a race condition in which loose refs
1880 * are migrated to the packed-refs file by a simultaneous process, but
1881 * our in-memory view is from before the migration. get_packed_ref_cache()
1882 * takes care of making sure our view is up to date with what is on
1883 * disk.
1884 */
1885 loose_dir = get_loose_refs(refs);
933ac036 1886 if (base && *base) {
933ac036
MH
1887 loose_dir = find_containing_dir(loose_dir, base, 0);
1888 }
98eeb09e
JK
1889 if (loose_dir)
1890 prime_ref_dir(loose_dir);
1891
1892 packed_ref_cache = get_packed_ref_cache(refs);
8baf2bb9 1893 acquire_packed_ref_cache(packed_ref_cache);
98eeb09e 1894 packed_dir = get_packed_ref_dir(packed_ref_cache);
933ac036
MH
1895 if (base && *base) {
1896 packed_dir = find_containing_dir(packed_dir, base, 0);
933ac036
MH
1897 }
1898
1899 if (packed_dir && loose_dir) {
1900 sort_ref_dir(packed_dir);
1901 sort_ref_dir(loose_dir);
624cac35
MH
1902 retval = do_for_each_entry_in_dirs(
1903 packed_dir, loose_dir, fn, cb_data);
933ac036
MH
1904 } else if (packed_dir) {
1905 sort_ref_dir(packed_dir);
624cac35
MH
1906 retval = do_for_each_entry_in_dir(
1907 packed_dir, 0, fn, cb_data);
933ac036
MH
1908 } else if (loose_dir) {
1909 sort_ref_dir(loose_dir);
624cac35
MH
1910 retval = do_for_each_entry_in_dir(
1911 loose_dir, 0, fn, cb_data);
933ac036
MH
1912 }
1913
8baf2bb9 1914 release_packed_ref_cache(packed_ref_cache);
933ac036 1915 return retval;
8a65ff76
LT
1916}
1917
624cac35 1918/*
65cf102b 1919 * Call fn for each reference in the specified ref_cache for which the
624cac35
MH
1920 * refname begins with base. If trim is non-zero, then trim that many
1921 * characters off the beginning of each refname before passing the
1922 * refname to fn. flags can be DO_FOR_EACH_INCLUDE_BROKEN to include
1923 * broken references in the iteration. If fn ever returns a non-zero
1924 * value, stop the iteration and return that value; otherwise, return
1925 * 0.
1926 */
65cf102b
MH
1927static int do_for_each_ref(struct ref_cache *refs, const char *base,
1928 each_ref_fn fn, int trim, int flags, void *cb_data)
624cac35
MH
1929{
1930 struct ref_entry_cb data;
1931 data.base = base;
1932 data.trim = trim;
1933 data.flags = flags;
1934 data.fn = fn;
1935 data.cb_data = cb_data;
1936
49672f26
JK
1937 if (ref_paranoia < 0)
1938 ref_paranoia = git_env_bool("GIT_REF_PARANOIA", 0);
1939 if (ref_paranoia)
1940 data.flags |= DO_FOR_EACH_INCLUDE_BROKEN;
1941
65cf102b 1942 return do_for_each_entry(refs, base, do_one_ref, &data);
624cac35
MH
1943}
1944
0bad611b 1945static int do_head_ref(const char *submodule, each_ref_fn fn, void *cb_data)
723c31fe
LT
1946{
1947 unsigned char sha1[20];
8da19775
JH
1948 int flag;
1949
0bad611b
HV
1950 if (submodule) {
1951 if (resolve_gitlink_ref(submodule, "HEAD", sha1) == 0)
1952 return fn("HEAD", sha1, 0, cb_data);
1953
1954 return 0;
1955 }
1956
7695d118 1957 if (!read_ref_full("HEAD", RESOLVE_REF_READING, sha1, &flag))
8da19775 1958 return fn("HEAD", sha1, flag, cb_data);
0bad611b 1959
2f34ba32 1960 return 0;
723c31fe
LT
1961}
1962
0bad611b
HV
1963int head_ref(each_ref_fn fn, void *cb_data)
1964{
1965 return do_head_ref(NULL, fn, cb_data);
1966}
1967
9ef6aeb0
HV
1968int head_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)
1969{
1970 return do_head_ref(submodule, fn, cb_data);
1971}
1972
cb5d709f 1973int for_each_ref(each_ref_fn fn, void *cb_data)
8a65ff76 1974{
9da31cb0 1975 return do_for_each_ref(&ref_cache, "", fn, 0, 0, cb_data);
a62be77f
SE
1976}
1977
9ef6aeb0
HV
1978int for_each_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)
1979{
65cf102b 1980 return do_for_each_ref(get_ref_cache(submodule), "", fn, 0, 0, cb_data);
a62be77f
SE
1981}
1982
2a8177b6
CC
1983int for_each_ref_in(const char *prefix, each_ref_fn fn, void *cb_data)
1984{
9da31cb0 1985 return do_for_each_ref(&ref_cache, prefix, fn, strlen(prefix), 0, cb_data);
2a8177b6
CC
1986}
1987
9ef6aeb0
HV
1988int for_each_ref_in_submodule(const char *submodule, const char *prefix,
1989 each_ref_fn fn, void *cb_data)
1990{
65cf102b 1991 return do_for_each_ref(get_ref_cache(submodule), prefix, fn, strlen(prefix), 0, cb_data);
2a8177b6
CC
1992}
1993
cb5d709f 1994int for_each_tag_ref(each_ref_fn fn, void *cb_data)
a62be77f 1995{
2a8177b6 1996 return for_each_ref_in("refs/tags/", fn, cb_data);
a62be77f
SE
1997}
1998
9ef6aeb0
HV
1999int for_each_tag_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)
2000{
2001 return for_each_ref_in_submodule(submodule, "refs/tags/", fn, cb_data);
2002}
2003
cb5d709f 2004int for_each_branch_ref(each_ref_fn fn, void *cb_data)
a62be77f 2005{
2a8177b6 2006 return for_each_ref_in("refs/heads/", fn, cb_data);
a62be77f
SE
2007}
2008
9ef6aeb0
HV
2009int for_each_branch_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)
2010{
2011 return for_each_ref_in_submodule(submodule, "refs/heads/", fn, cb_data);
2012}
2013
cb5d709f 2014int for_each_remote_ref(each_ref_fn fn, void *cb_data)
a62be77f 2015{
2a8177b6 2016 return for_each_ref_in("refs/remotes/", fn, cb_data);
f8948e2f
JH
2017}
2018
9ef6aeb0
HV
2019int for_each_remote_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)
2020{
2021 return for_each_ref_in_submodule(submodule, "refs/remotes/", fn, cb_data);
2022}
2023
29268700
CC
2024int for_each_replace_ref(each_ref_fn fn, void *cb_data)
2025{
9da31cb0 2026 return do_for_each_ref(&ref_cache, "refs/replace/", fn, 13, 0, cb_data);
29268700
CC
2027}
2028
a1bea2c1
JT
2029int head_ref_namespaced(each_ref_fn fn, void *cb_data)
2030{
2031 struct strbuf buf = STRBUF_INIT;
2032 int ret = 0;
2033 unsigned char sha1[20];
2034 int flag;
2035
2036 strbuf_addf(&buf, "%sHEAD", get_git_namespace());
7695d118 2037 if (!read_ref_full(buf.buf, RESOLVE_REF_READING, sha1, &flag))
a1bea2c1
JT
2038 ret = fn(buf.buf, sha1, flag, cb_data);
2039 strbuf_release(&buf);
2040
2041 return ret;
2042}
2043
2044int for_each_namespaced_ref(each_ref_fn fn, void *cb_data)
2045{
2046 struct strbuf buf = STRBUF_INIT;
2047 int ret;
2048 strbuf_addf(&buf, "%srefs/", get_git_namespace());
9da31cb0 2049 ret = do_for_each_ref(&ref_cache, buf.buf, fn, 0, 0, cb_data);
a1bea2c1
JT
2050 strbuf_release(&buf);
2051 return ret;
2052}
2053
b09fe971
IL
2054int for_each_glob_ref_in(each_ref_fn fn, const char *pattern,
2055 const char *prefix, void *cb_data)
d08bae7e
IL
2056{
2057 struct strbuf real_pattern = STRBUF_INIT;
2058 struct ref_filter filter;
d08bae7e
IL
2059 int ret;
2060
59556548 2061 if (!prefix && !starts_with(pattern, "refs/"))
d08bae7e 2062 strbuf_addstr(&real_pattern, "refs/");
b09fe971
IL
2063 else if (prefix)
2064 strbuf_addstr(&real_pattern, prefix);
d08bae7e
IL
2065 strbuf_addstr(&real_pattern, pattern);
2066
894a9d33 2067 if (!has_glob_specials(pattern)) {
9517e6b8 2068 /* Append implied '/' '*' if not present. */
d08bae7e
IL
2069 if (real_pattern.buf[real_pattern.len - 1] != '/')
2070 strbuf_addch(&real_pattern, '/');
2071 /* No need to check for '*', there is none. */
2072 strbuf_addch(&real_pattern, '*');
2073 }
2074
2075 filter.pattern = real_pattern.buf;
2076 filter.fn = fn;
2077 filter.cb_data = cb_data;
2078 ret = for_each_ref(filter_refs, &filter);
2079
2080 strbuf_release(&real_pattern);
2081 return ret;
2082}
2083
b09fe971
IL
2084int for_each_glob_ref(each_ref_fn fn, const char *pattern, void *cb_data)
2085{
2086 return for_each_glob_ref_in(fn, pattern, NULL, cb_data);
2087}
2088
f8948e2f
JH
2089int for_each_rawref(each_ref_fn fn, void *cb_data)
2090{
9da31cb0 2091 return do_for_each_ref(&ref_cache, "", fn, 0,
f8948e2f 2092 DO_FOR_EACH_INCLUDE_BROKEN, cb_data);
8a65ff76
LT
2093}
2094
4577e483 2095const char *prettify_refname(const char *name)
a9c37a72 2096{
a9c37a72 2097 return name + (
59556548
CC
2098 starts_with(name, "refs/heads/") ? 11 :
2099 starts_with(name, "refs/tags/") ? 10 :
2100 starts_with(name, "refs/remotes/") ? 13 :
a9c37a72
DB
2101 0);
2102}
2103
54457fe5 2104static const char *ref_rev_parse_rules[] = {
79803322
SP
2105 "%.*s",
2106 "refs/%.*s",
2107 "refs/tags/%.*s",
2108 "refs/heads/%.*s",
2109 "refs/remotes/%.*s",
2110 "refs/remotes/%.*s/HEAD",
2111 NULL
2112};
2113
54457fe5 2114int refname_match(const char *abbrev_name, const char *full_name)
79803322
SP
2115{
2116 const char **p;
2117 const int abbrev_name_len = strlen(abbrev_name);
2118
54457fe5 2119 for (p = ref_rev_parse_rules; *p; p++) {
79803322
SP
2120 if (!strcmp(full_name, mkpath(*p, abbrev_name_len, abbrev_name))) {
2121 return 1;
2122 }
2123 }
2124
2125 return 0;
2126}
2127
0b1e6548
RS
2128static void unlock_ref(struct ref_lock *lock)
2129{
2130 /* Do not free lock->lk -- atexit() still looks at them */
2131 if (lock->lk)
2132 rollback_lock_file(lock->lk);
2133 free(lock->ref_name);
2134 free(lock->orig_ref_name);
2135 free(lock);
2136}
2137
835e3c99 2138/* This function should make sure errno is meaningful on error */
e5f38ec3 2139static struct ref_lock *verify_lock(struct ref_lock *lock,
4bd18c43
SP
2140 const unsigned char *old_sha1, int mustexist)
2141{
7695d118
RS
2142 if (read_ref_full(lock->ref_name,
2143 mustexist ? RESOLVE_REF_READING : 0,
2144 lock->old_sha1, NULL)) {
835e3c99 2145 int save_errno = errno;
434cd0cd 2146 error("Can't verify ref %s", lock->ref_name);
4bd18c43 2147 unlock_ref(lock);
835e3c99 2148 errno = save_errno;
4bd18c43
SP
2149 return NULL;
2150 }
a89fccd2 2151 if (hashcmp(lock->old_sha1, old_sha1)) {
434cd0cd 2152 error("Ref %s is at %s but expected %s", lock->ref_name,
4bd18c43
SP
2153 sha1_to_hex(lock->old_sha1), sha1_to_hex(old_sha1));
2154 unlock_ref(lock);
835e3c99 2155 errno = EBUSY;
4bd18c43
SP
2156 return NULL;
2157 }
2158 return lock;
2159}
2160
7155b727 2161static int remove_empty_directories(const char *file)
bc7127ef
JH
2162{
2163 /* we want to create a file but there is a directory there;
2164 * if that is an empty directory (or a directory that contains
2165 * only empty directories), remove them.
2166 */
7155b727 2167 struct strbuf path;
470a91ef 2168 int result, save_errno;
bc7127ef 2169
7155b727
JS
2170 strbuf_init(&path, 20);
2171 strbuf_addstr(&path, file);
2172
a0f4afbe 2173 result = remove_dir_recursively(&path, REMOVE_DIR_EMPTY_ONLY);
470a91ef 2174 save_errno = errno;
7155b727
JS
2175
2176 strbuf_release(&path);
470a91ef 2177 errno = save_errno;
7155b727
JS
2178
2179 return result;
bc7127ef
JH
2180}
2181
ff74f7f1
JH
2182/*
2183 * *string and *len will only be substituted, and *string returned (for
2184 * later free()ing) if the string passed in is a magic short-hand form
2185 * to name a branch.
2186 */
2187static char *substitute_branch_name(const char **string, int *len)
2188{
2189 struct strbuf buf = STRBUF_INIT;
cf99a761 2190 int ret = interpret_branch_name(*string, *len, &buf);
ff74f7f1
JH
2191
2192 if (ret == *len) {
2193 size_t size;
2194 *string = strbuf_detach(&buf, &size);
2195 *len = size;
2196 return (char *)*string;
2197 }
2198
2199 return NULL;
2200}
2201
2202int dwim_ref(const char *str, int len, unsigned char *sha1, char **ref)
2203{
2204 char *last_branch = substitute_branch_name(&str, &len);
2205 const char **p, *r;
2206 int refs_found = 0;
2207
2208 *ref = NULL;
2209 for (p = ref_rev_parse_rules; *p; p++) {
2210 char fullref[PATH_MAX];
2211 unsigned char sha1_from_ref[20];
2212 unsigned char *this_result;
2213 int flag;
2214
2215 this_result = refs_found ? sha1_from_ref : sha1;
2216 mksnpath(fullref, sizeof(fullref), *p, len, str);
7695d118
RS
2217 r = resolve_ref_unsafe(fullref, RESOLVE_REF_READING,
2218 this_result, &flag);
ff74f7f1
JH
2219 if (r) {
2220 if (!refs_found++)
2221 *ref = xstrdup(r);
2222 if (!warn_ambiguous_refs)
2223 break;
55956350 2224 } else if ((flag & REF_ISSYMREF) && strcmp(fullref, "HEAD")) {
ff74f7f1 2225 warning("ignoring dangling symref %s.", fullref);
55956350
JH
2226 } else if ((flag & REF_ISBROKEN) && strchr(fullref, '/')) {
2227 warning("ignoring broken ref %s.", fullref);
2228 }
ff74f7f1
JH
2229 }
2230 free(last_branch);
2231 return refs_found;
2232}
2233
2234int dwim_log(const char *str, int len, unsigned char *sha1, char **log)
2235{
2236 char *last_branch = substitute_branch_name(&str, &len);
2237 const char **p;
2238 int logs_found = 0;
2239
2240 *log = NULL;
2241 for (p = ref_rev_parse_rules; *p; p++) {
ff74f7f1
JH
2242 unsigned char hash[20];
2243 char path[PATH_MAX];
2244 const char *ref, *it;
2245
2246 mksnpath(path, sizeof(path), *p, len, str);
7695d118
RS
2247 ref = resolve_ref_unsafe(path, RESOLVE_REF_READING,
2248 hash, NULL);
ff74f7f1
JH
2249 if (!ref)
2250 continue;
4da58835 2251 if (reflog_exists(path))
ff74f7f1 2252 it = path;
4da58835 2253 else if (strcmp(ref, path) && reflog_exists(ref))
ff74f7f1
JH
2254 it = ref;
2255 else
2256 continue;
2257 if (!logs_found++) {
2258 *log = xstrdup(it);
2259 hashcpy(sha1, hash);
2260 }
2261 if (!warn_ambiguous_refs)
2262 break;
2263 }
2264 free(last_branch);
2265 return logs_found;
2266}
2267
88b680ae 2268/*
3c93c847 2269 * Locks a ref returning the lock on success and NULL on failure.
88b680ae
RS
2270 * On failure errno is set to something meaningful.
2271 */
dfefa935
MH
2272static struct ref_lock *lock_ref_sha1_basic(const char *refname,
2273 const unsigned char *old_sha1,
5fe7d825 2274 const struct string_list *skip,
fec14ec3 2275 unsigned int flags, int *type_p)
4bd18c43 2276{
434cd0cd 2277 char *ref_file;
dfefa935 2278 const char *orig_refname = refname;
4bd18c43 2279 struct ref_lock *lock;
5cc3cef9 2280 int last_errno = 0;
acd3b9ec 2281 int type, lflags;
4431fcc4 2282 int mustexist = (old_sha1 && !is_null_sha1(old_sha1));
7695d118 2283 int resolve_flags = 0;
c4c61c76 2284 int attempts_remaining = 3;
4bd18c43
SP
2285
2286 lock = xcalloc(1, sizeof(struct ref_lock));
2287 lock->lock_fd = -1;
2288
7695d118
RS
2289 if (mustexist)
2290 resolve_flags |= RESOLVE_REF_READING;
d0f810f0
RS
2291 if (flags & REF_DELETING) {
2292 resolve_flags |= RESOLVE_REF_ALLOW_BAD_NAME;
2293 if (flags & REF_NODEREF)
2294 resolve_flags |= RESOLVE_REF_NO_RECURSE;
2295 }
7695d118
RS
2296
2297 refname = resolve_ref_unsafe(refname, resolve_flags,
2298 lock->old_sha1, &type);
dfefa935 2299 if (!refname && errno == EISDIR) {
bc7127ef
JH
2300 /* we are trying to lock foo but we used to
2301 * have foo/bar which now does not exist;
2302 * it is normal for the empty directory 'foo'
2303 * to remain.
2304 */
dfefa935 2305 ref_file = git_path("%s", orig_refname);
5cc3cef9
JH
2306 if (remove_empty_directories(ref_file)) {
2307 last_errno = errno;
dfefa935 2308 error("there are still refs under '%s'", orig_refname);
5cc3cef9
JH
2309 goto error_return;
2310 }
7695d118
RS
2311 refname = resolve_ref_unsafe(orig_refname, resolve_flags,
2312 lock->old_sha1, &type);
bc7127ef 2313 }
68db31cc
SV
2314 if (type_p)
2315 *type_p = type;
dfefa935 2316 if (!refname) {
5cc3cef9 2317 last_errno = errno;
818f477c 2318 error("unable to resolve reference %s: %s",
dfefa935 2319 orig_refname, strerror(errno));
5cc3cef9 2320 goto error_return;
4bd18c43 2321 }
074336e5
MH
2322 /*
2323 * If the ref did not exist and we are creating it, make sure
2324 * there is no existing packed ref whose name begins with our
2325 * refname, nor a packed ref whose name is a proper prefix of
2326 * our refname.
c976d415 2327 */
074336e5 2328 if (is_null_sha1(lock->old_sha1) &&
5fe7d825 2329 !is_refname_available(refname, skip, get_packed_refs(&ref_cache))) {
f475e08e 2330 last_errno = ENOTDIR;
c976d415 2331 goto error_return;
f475e08e 2332 }
22a3844e 2333
c33d5174 2334 lock->lk = xcalloc(1, sizeof(struct lock_file));
4bd18c43 2335
e5c223e9 2336 lflags = 0;
acd3b9ec 2337 if (flags & REF_NODEREF) {
dfefa935 2338 refname = orig_refname;
47ba4662 2339 lflags |= LOCK_NO_DEREF;
acd3b9ec 2340 }
dfefa935
MH
2341 lock->ref_name = xstrdup(refname);
2342 lock->orig_ref_name = xstrdup(orig_refname);
2343 ref_file = git_path("%s", refname);
4bd18c43 2344
c4c61c76
MH
2345 retry:
2346 switch (safe_create_leading_directories(ref_file)) {
2347 case SCLD_OK:
2348 break; /* success */
2349 case SCLD_VANISHED:
2350 if (--attempts_remaining > 0)
2351 goto retry;
2352 /* fall through */
2353 default:
5cc3cef9
JH
2354 last_errno = errno;
2355 error("unable to create directory for %s", ref_file);
2356 goto error_return;
2357 }
4bd18c43 2358
acd3b9ec 2359 lock->lock_fd = hold_lock_file_for_update(lock->lk, ref_file, lflags);
e5c223e9 2360 if (lock->lock_fd < 0) {
06839515 2361 last_errno = errno;
e5c223e9
MH
2362 if (errno == ENOENT && --attempts_remaining > 0)
2363 /*
2364 * Maybe somebody just deleted one of the
2365 * directories leading to ref_file. Try
2366 * again:
2367 */
2368 goto retry;
06839515
RS
2369 else {
2370 struct strbuf err = STRBUF_INIT;
2371 unable_to_lock_message(ref_file, errno, &err);
2372 error("%s", err.buf);
33adc83d 2373 strbuf_release(&err);
06839515
RS
2374 goto error_return;
2375 }
e5c223e9 2376 }
4bd18c43 2377 return old_sha1 ? verify_lock(lock, old_sha1, mustexist) : lock;
5cc3cef9
JH
2378
2379 error_return:
2380 unlock_ref(lock);
2381 errno = last_errno;
2382 return NULL;
4bd18c43
SP
2383}
2384
fec3137f
MH
2385/*
2386 * Write an entry to the packed-refs file for the specified refname.
2387 * If peeled is non-NULL, write it as the entry's peeled value.
2388 */
9540ce50 2389static void write_packed_entry(FILE *fh, char *refname, unsigned char *sha1,
fec3137f 2390 unsigned char *peeled)
d66da478 2391{
9540ce50
JK
2392 fprintf_or_die(fh, "%s %s\n", sha1_to_hex(sha1), refname);
2393 if (peeled)
2394 fprintf_or_die(fh, "^%s\n", sha1_to_hex(peeled));
fec3137f
MH
2395}
2396
7b40d396
MH
2397/*
2398 * An each_ref_entry_fn that writes the entry to a packed-refs file.
2399 */
2400static int write_packed_entry_fn(struct ref_entry *entry, void *cb_data)
2401{
7b40d396
MH
2402 enum peel_status peel_status = peel_entry(entry, 0);
2403
2404 if (peel_status != PEEL_PEELED && peel_status != PEEL_NON_TAG)
2405 error("internal error: %s is not a valid packed reference!",
2406 entry->name);
9540ce50 2407 write_packed_entry(cb_data, entry->name, entry->u.value.sha1,
7b40d396
MH
2408 peel_status == PEEL_PEELED ?
2409 entry->u.value.peeled : NULL);
2410 return 0;
2411}
2412
447ff1bf 2413/* This should return a meaningful errno on failure */
9f69d297
MH
2414int lock_packed_refs(int flags)
2415{
2416 struct packed_ref_cache *packed_ref_cache;
2417
9f69d297
MH
2418 if (hold_lock_file_for_update(&packlock, git_path("packed-refs"), flags) < 0)
2419 return -1;
5d478f5c
MH
2420 /*
2421 * Get the current packed-refs while holding the lock. If the
2422 * packed-refs file has been modified since we last read it,
2423 * this will automatically invalidate the cache and re-read
2424 * the packed-refs file.
2425 */
9f69d297
MH
2426 packed_ref_cache = get_packed_ref_cache(&ref_cache);
2427 packed_ref_cache->lock = &packlock;
4f6b83e3
MH
2428 /* Increment the reference count to prevent it from being freed: */
2429 acquire_packed_ref_cache(packed_ref_cache);
9f69d297
MH
2430 return 0;
2431}
2432
d3f66555
RS
2433/*
2434 * Commit the packed refs changes.
2435 * On error we must make sure that errno contains a meaningful value.
2436 */
9f69d297
MH
2437int commit_packed_refs(void)
2438{
2439 struct packed_ref_cache *packed_ref_cache =
2440 get_packed_ref_cache(&ref_cache);
2441 int error = 0;
d3f66555 2442 int save_errno = 0;
9540ce50 2443 FILE *out;
9f69d297
MH
2444
2445 if (!packed_ref_cache->lock)
2446 die("internal error: packed-refs not locked");
9f69d297 2447
6e578a31 2448 out = fdopen_lock_file(packed_ref_cache->lock, "w");
9540ce50
JK
2449 if (!out)
2450 die_errno("unable to fdopen packed-refs descriptor");
2451
2452 fprintf_or_die(out, "%s", PACKED_REFS_HEADER);
9f69d297 2453 do_for_each_entry_in_dir(get_packed_ref_dir(packed_ref_cache),
9540ce50 2454 0, write_packed_entry_fn, out);
9540ce50 2455
d3f66555
RS
2456 if (commit_lock_file(packed_ref_cache->lock)) {
2457 save_errno = errno;
9f69d297 2458 error = -1;
d3f66555 2459 }
9f69d297 2460 packed_ref_cache->lock = NULL;
4f6b83e3 2461 release_packed_ref_cache(packed_ref_cache);
d3f66555 2462 errno = save_errno;
9f69d297
MH
2463 return error;
2464}
2465
2466void rollback_packed_refs(void)
2467{
2468 struct packed_ref_cache *packed_ref_cache =
2469 get_packed_ref_cache(&ref_cache);
2470
2471 if (!packed_ref_cache->lock)
2472 die("internal error: packed-refs not locked");
2473 rollback_lock_file(packed_ref_cache->lock);
2474 packed_ref_cache->lock = NULL;
4f6b83e3 2475 release_packed_ref_cache(packed_ref_cache);
9f69d297
MH
2476 clear_packed_ref_cache(&ref_cache);
2477}
2478
32d462ce
MH
2479struct ref_to_prune {
2480 struct ref_to_prune *next;
2481 unsigned char sha1[20];
2482 char name[FLEX_ARRAY];
2483};
2484
2485struct pack_refs_cb_data {
2486 unsigned int flags;
267f9a8c 2487 struct ref_dir *packed_refs;
32d462ce 2488 struct ref_to_prune *ref_to_prune;
32d462ce
MH
2489};
2490
267f9a8c
MH
2491/*
2492 * An each_ref_entry_fn that is run over loose references only. If
2493 * the loose reference can be packed, add an entry in the packed ref
2494 * cache. If the reference should be pruned, also add it to
2495 * ref_to_prune in the pack_refs_cb_data.
2496 */
2497static int pack_if_possible_fn(struct ref_entry *entry, void *cb_data)
32d462ce
MH
2498{
2499 struct pack_refs_cb_data *cb = cb_data;
f85354b5 2500 enum peel_status peel_status;
267f9a8c 2501 struct ref_entry *packed_entry;
59556548 2502 int is_tag_ref = starts_with(entry->name, "refs/tags/");
32d462ce 2503
267f9a8c
MH
2504 /* ALWAYS pack tags */
2505 if (!(cb->flags & PACK_REFS_ALL) && !is_tag_ref)
32d462ce
MH
2506 return 0;
2507
b2a8226d
MH
2508 /* Do not pack symbolic or broken refs: */
2509 if ((entry->flag & REF_ISSYMREF) || !ref_resolves_to_object(entry))
2510 return 0;
2511
267f9a8c 2512 /* Add a packed ref cache entry equivalent to the loose entry. */
f85354b5 2513 peel_status = peel_entry(entry, 1);
0f29920f 2514 if (peel_status != PEEL_PEELED && peel_status != PEEL_NON_TAG)
f85354b5
MH
2515 die("internal error peeling reference %s (%s)",
2516 entry->name, sha1_to_hex(entry->u.value.sha1));
267f9a8c
MH
2517 packed_entry = find_ref(cb->packed_refs, entry->name);
2518 if (packed_entry) {
2519 /* Overwrite existing packed entry with info from loose entry */
2520 packed_entry->flag = REF_ISPACKED | REF_KNOWS_PEELED;
2521 hashcpy(packed_entry->u.value.sha1, entry->u.value.sha1);
2522 } else {
2523 packed_entry = create_ref_entry(entry->name, entry->u.value.sha1,
2524 REF_ISPACKED | REF_KNOWS_PEELED, 0);
2525 add_ref(cb->packed_refs, packed_entry);
2526 }
2527 hashcpy(packed_entry->u.value.peeled, entry->u.value.peeled);
32d462ce 2528
267f9a8c
MH
2529 /* Schedule the loose reference for pruning if requested. */
2530 if ((cb->flags & PACK_REFS_PRUNE)) {
12e77559 2531 int namelen = strlen(entry->name) + 1;
32d462ce 2532 struct ref_to_prune *n = xcalloc(1, sizeof(*n) + namelen);
12e77559
MH
2533 hashcpy(n->sha1, entry->u.value.sha1);
2534 strcpy(n->name, entry->name);
32d462ce
MH
2535 n->next = cb->ref_to_prune;
2536 cb->ref_to_prune = n;
2537 }
d66da478
MH
2538 return 0;
2539}
2540
32d462ce
MH
2541/*
2542 * Remove empty parents, but spare refs/ and immediate subdirs.
2543 * Note: munges *name.
2544 */
2545static void try_remove_empty_parents(char *name)
2546{
2547 char *p, *q;
2548 int i;
2549 p = name;
2550 for (i = 0; i < 2; i++) { /* refs/{heads,tags,...}/ */
2551 while (*p && *p != '/')
2552 p++;
2553 /* tolerate duplicate slashes; see check_refname_format() */
2554 while (*p == '/')
2555 p++;
2556 }
2557 for (q = p; *q; q++)
2558 ;
2559 while (1) {
2560 while (q > p && *q != '/')
2561 q--;
2562 while (q > p && *(q-1) == '/')
2563 q--;
2564 if (q == p)
2565 break;
2566 *q = '\0';
2567 if (rmdir(git_path("%s", name)))
2568 break;
2569 }
2570}
2571
2572/* make sure nobody touched the ref, and unlink */
2573static void prune_ref(struct ref_to_prune *r)
2574{
029cdb4a
RS
2575 struct ref_transaction *transaction;
2576 struct strbuf err = STRBUF_INIT;
32d462ce 2577
88e7dff9 2578 if (check_refname_format(r->name, 0))
cba12021 2579 return;
32d462ce 2580
029cdb4a
RS
2581 transaction = ref_transaction_begin(&err);
2582 if (!transaction ||
2583 ref_transaction_delete(transaction, r->name, r->sha1,
fb5a6bb6 2584 REF_ISPRUNING, NULL, &err) ||
db7516ab 2585 ref_transaction_commit(transaction, &err)) {
029cdb4a
RS
2586 ref_transaction_free(transaction);
2587 error("%s", err.buf);
2588 strbuf_release(&err);
2589 return;
32d462ce 2590 }
029cdb4a
RS
2591 ref_transaction_free(transaction);
2592 strbuf_release(&err);
2593 try_remove_empty_parents(r->name);
32d462ce
MH
2594}
2595
2596static void prune_refs(struct ref_to_prune *r)
2597{
2598 while (r) {
2599 prune_ref(r);
2600 r = r->next;
2601 }
2602}
2603
32d462ce
MH
2604int pack_refs(unsigned int flags)
2605{
32d462ce
MH
2606 struct pack_refs_cb_data cbdata;
2607
2608 memset(&cbdata, 0, sizeof(cbdata));
2609 cbdata.flags = flags;
2610
9f69d297 2611 lock_packed_refs(LOCK_DIE_ON_ERROR);
267f9a8c 2612 cbdata.packed_refs = get_packed_refs(&ref_cache);
32d462ce 2613
267f9a8c
MH
2614 do_for_each_entry_in_dir(get_loose_refs(&ref_cache), 0,
2615 pack_if_possible_fn, &cbdata);
32d462ce 2616
9f69d297 2617 if (commit_packed_refs())
32d462ce 2618 die_errno("unable to overwrite old ref-pack file");
9f69d297 2619
32d462ce
MH
2620 prune_refs(cbdata.ref_to_prune);
2621 return 0;
2622}
2623
4a45b2f3 2624int repack_without_refs(struct string_list *refnames, struct strbuf *err)
c0277d15 2625{
7618fd80 2626 struct ref_dir *packed;
ea56c4e0 2627 struct string_list_item *refname;
4a45b2f3 2628 int ret, needs_repacking = 0, removed = 0;
61cee0db 2629
5a603b04
JN
2630 assert(err);
2631
61cee0db 2632 /* Look for a packed ref */
4a45b2f3
MH
2633 for_each_string_list_item(refname, refnames) {
2634 if (get_packed_ref(refname->string)) {
2635 needs_repacking = 1;
61cee0db 2636 break;
4a45b2f3
MH
2637 }
2638 }
7618fd80 2639
61cee0db 2640 /* Avoid locking if we have nothing to do */
4a45b2f3 2641 if (!needs_repacking)
61cee0db 2642 return 0; /* no refname exists in packed refs */
7618fd80 2643
9f69d297 2644 if (lock_packed_refs(0)) {
5a603b04
JN
2645 unable_to_lock_message(git_path("packed-refs"), errno, err);
2646 return -1;
1b018fd9 2647 }
9da31cb0 2648 packed = get_packed_refs(&ref_cache);
7b40d396 2649
61cee0db 2650 /* Remove refnames from the cache */
4a45b2f3
MH
2651 for_each_string_list_item(refname, refnames)
2652 if (remove_entry(packed, refname->string) != -1)
61cee0db
BK
2653 removed = 1;
2654 if (!removed) {
506a760d 2655 /*
61cee0db 2656 * All packed entries disappeared while we were
506a760d
MH
2657 * acquiring the lock.
2658 */
9f69d297 2659 rollback_packed_refs();
506a760d
MH
2660 return 0;
2661 }
7b40d396 2662
61cee0db 2663 /* Write what remains */
60bca085 2664 ret = commit_packed_refs();
5a603b04 2665 if (ret)
60bca085
RS
2666 strbuf_addf(err, "unable to overwrite old ref-pack file: %s",
2667 strerror(errno));
2668 return ret;
c0277d15
JH
2669}
2670
dbdcac7d 2671static int delete_ref_loose(struct ref_lock *lock, int flag, struct strbuf *err)
2ddb5d17 2672{
5a603b04
JN
2673 assert(err);
2674
045a476f 2675 if (!(flag & REF_ISPACKED) || flag & REF_ISSYMREF) {
91f1f191
MH
2676 /*
2677 * loose. The loose file name is the same as the
2678 * lockfile name, minus ".lock":
2679 */
ec38b4e4 2680 char *loose_filename = get_locked_file_path(lock->lk);
dbdcac7d 2681 int res = unlink_or_msg(loose_filename, err);
91f1f191 2682 free(loose_filename);
dbdcac7d 2683 if (res)
2ddb5d17 2684 return 1;
c0277d15 2685 }
2ddb5d17
BK
2686 return 0;
2687}
2688
fec14ec3 2689int delete_ref(const char *refname, const unsigned char *sha1, unsigned int flags)
c0277d15 2690{
7521cc46
RS
2691 struct ref_transaction *transaction;
2692 struct strbuf err = STRBUF_INIT;
c0277d15 2693
7521cc46
RS
2694 transaction = ref_transaction_begin(&err);
2695 if (!transaction ||
fb5a6bb6
MH
2696 ref_transaction_delete(transaction, refname,
2697 (sha1 && !is_null_sha1(sha1)) ? sha1 : NULL,
2698 flags, NULL, &err) ||
db7516ab 2699 ref_transaction_commit(transaction, &err)) {
7521cc46
RS
2700 error("%s", err.buf);
2701 ref_transaction_free(transaction);
2702 strbuf_release(&err);
c0277d15 2703 return 1;
7521cc46
RS
2704 }
2705 ref_transaction_free(transaction);
2706 strbuf_release(&err);
2707 return 0;
4bd18c43
SP
2708}
2709
765c2258
PH
2710/*
2711 * People using contrib's git-new-workdir have .git/logs/refs ->
2712 * /some/other/path/.git/logs/refs, and that may live on another device.
2713 *
2714 * IOW, to avoid cross device rename errors, the temporary renamed log must
2715 * live into logs/refs.
2716 */
2717#define TMP_RENAMED_LOG "logs/refs/.tmp-renamed-log"
2718
fa59ae79
MH
2719static int rename_tmp_log(const char *newrefname)
2720{
f1e9e9a4 2721 int attempts_remaining = 4;
ae4a283e
MH
2722
2723 retry:
08f555cb
MH
2724 switch (safe_create_leading_directories(git_path("logs/%s", newrefname))) {
2725 case SCLD_OK:
2726 break; /* success */
2727 case SCLD_VANISHED:
2728 if (--attempts_remaining > 0)
2729 goto retry;
2730 /* fall through */
2731 default:
fa59ae79
MH
2732 error("unable to create directory for %s", newrefname);
2733 return -1;
2734 }
2735
fa59ae79 2736 if (rename(git_path(TMP_RENAMED_LOG), git_path("logs/%s", newrefname))) {
f1e9e9a4 2737 if ((errno==EISDIR || errno==ENOTDIR) && --attempts_remaining > 0) {
fa59ae79
MH
2738 /*
2739 * rename(a, b) when b is an existing
2740 * directory ought to result in ISDIR, but
2741 * Solaris 5.8 gives ENOTDIR. Sheesh.
2742 */
2743 if (remove_empty_directories(git_path("logs/%s", newrefname))) {
2744 error("Directory not empty: logs/%s", newrefname);
2745 return -1;
2746 }
2747 goto retry;
ae4a283e
MH
2748 } else if (errno == ENOENT && --attempts_remaining > 0) {
2749 /*
2750 * Maybe another process just deleted one of
2751 * the directories in the path to newrefname.
2752 * Try again from the beginning.
2753 */
2754 goto retry;
fa59ae79
MH
2755 } else {
2756 error("unable to move logfile "TMP_RENAMED_LOG" to logs/%s: %s",
2757 newrefname, strerror(errno));
2758 return -1;
2759 }
2760 }
2761 return 0;
2762}
2763
5fe7d825
RS
2764static int rename_ref_available(const char *oldname, const char *newname)
2765{
2766 struct string_list skip = STRING_LIST_INIT_NODUP;
2767 int ret;
2768
2769 string_list_insert(&skip, oldname);
2770 ret = is_refname_available(newname, &skip, get_packed_refs(&ref_cache))
2771 && is_refname_available(newname, &skip, get_loose_refs(&ref_cache));
2772 string_list_clear(&skip, 0);
2773 return ret;
2774}
2775
aae383db
RS
2776static int write_ref_sha1(struct ref_lock *lock, const unsigned char *sha1,
2777 const char *logmsg);
2778
dfefa935 2779int rename_ref(const char *oldrefname, const char *newrefname, const char *logmsg)
c976d415 2780{
c976d415
LH
2781 unsigned char sha1[20], orig_sha1[20];
2782 int flag = 0, logmoved = 0;
2783 struct ref_lock *lock;
c976d415 2784 struct stat loginfo;
dfefa935 2785 int log = !lstat(git_path("logs/%s", oldrefname), &loginfo);
eca35a25 2786 const char *symref = NULL;
c976d415 2787
450d4c0f 2788 if (log && S_ISLNK(loginfo.st_mode))
dfefa935 2789 return error("reflog for %s is a symlink", oldrefname);
c976d415 2790
7695d118
RS
2791 symref = resolve_ref_unsafe(oldrefname, RESOLVE_REF_READING,
2792 orig_sha1, &flag);
eca35a25 2793 if (flag & REF_ISSYMREF)
fa58186c 2794 return error("refname %s is a symbolic ref, renaming it is not supported",
dfefa935 2795 oldrefname);
eca35a25 2796 if (!symref)
dfefa935 2797 return error("refname %s not found", oldrefname);
c976d415 2798
5fe7d825 2799 if (!rename_ref_available(oldrefname, newrefname))
c976d415
LH
2800 return 1;
2801
dfefa935 2802 if (log && rename(git_path("logs/%s", oldrefname), git_path(TMP_RENAMED_LOG)))
765c2258 2803 return error("unable to move logfile logs/%s to "TMP_RENAMED_LOG": %s",
dfefa935 2804 oldrefname, strerror(errno));
c976d415 2805
dfefa935
MH
2806 if (delete_ref(oldrefname, orig_sha1, REF_NODEREF)) {
2807 error("unable to delete old %s", oldrefname);
c976d415
LH
2808 goto rollback;
2809 }
2810
7695d118 2811 if (!read_ref_full(newrefname, RESOLVE_REF_READING, sha1, NULL) &&
dfefa935 2812 delete_ref(newrefname, sha1, REF_NODEREF)) {
c976d415 2813 if (errno==EISDIR) {
dfefa935
MH
2814 if (remove_empty_directories(git_path("%s", newrefname))) {
2815 error("Directory not empty: %s", newrefname);
c976d415
LH
2816 goto rollback;
2817 }
2818 } else {
dfefa935 2819 error("unable to delete existing %s", newrefname);
c976d415
LH
2820 goto rollback;
2821 }
2822 }
2823
fa59ae79 2824 if (log && rename_tmp_log(newrefname))
c976d415 2825 goto rollback;
c976d415 2826
c976d415
LH
2827 logmoved = log;
2828
5fe7d825 2829 lock = lock_ref_sha1_basic(newrefname, NULL, NULL, 0, NULL);
c976d415 2830 if (!lock) {
dfefa935 2831 error("unable to lock %s for update", newrefname);
c976d415
LH
2832 goto rollback;
2833 }
c976d415 2834 hashcpy(lock->old_sha1, orig_sha1);
678d0f4c 2835 if (write_ref_sha1(lock, orig_sha1, logmsg)) {
dfefa935 2836 error("unable to write current sha1 into %s", newrefname);
c976d415
LH
2837 goto rollback;
2838 }
2839
2840 return 0;
2841
2842 rollback:
5fe7d825 2843 lock = lock_ref_sha1_basic(oldrefname, NULL, NULL, 0, NULL);
c976d415 2844 if (!lock) {
dfefa935 2845 error("unable to lock %s for rollback", oldrefname);
c976d415
LH
2846 goto rollbacklog;
2847 }
2848
c976d415
LH
2849 flag = log_all_ref_updates;
2850 log_all_ref_updates = 0;
2851 if (write_ref_sha1(lock, orig_sha1, NULL))
dfefa935 2852 error("unable to write current sha1 into %s", oldrefname);
c976d415
LH
2853 log_all_ref_updates = flag;
2854
2855 rollbacklog:
dfefa935 2856 if (logmoved && rename(git_path("logs/%s", newrefname), git_path("logs/%s", oldrefname)))
c976d415 2857 error("unable to restore logfile %s from %s: %s",
dfefa935 2858 oldrefname, newrefname, strerror(errno));
c976d415 2859 if (!logmoved && log &&
dfefa935 2860 rename(git_path(TMP_RENAMED_LOG), git_path("logs/%s", oldrefname)))
765c2258 2861 error("unable to restore logfile %s from "TMP_RENAMED_LOG": %s",
dfefa935 2862 oldrefname, strerror(errno));
c976d415
LH
2863
2864 return 1;
2865}
2866
0b1e6548 2867static int close_ref(struct ref_lock *lock)
b531394d
BC
2868{
2869 if (close_lock_file(lock->lk))
2870 return -1;
2871 lock->lock_fd = -1;
2872 return 0;
2873}
2874
0b1e6548 2875static int commit_ref(struct ref_lock *lock)
b531394d
BC
2876{
2877 if (commit_lock_file(lock->lk))
2878 return -1;
2879 lock->lock_fd = -1;
2880 return 0;
2881}
2882
0ec29a47
JH
2883/*
2884 * copy the reflog message msg to buf, which has been allocated sufficiently
2885 * large, while cleaning up the whitespaces. Especially, convert LF to space,
2886 * because reflog file is one line per entry.
2887 */
2888static int copy_msg(char *buf, const char *msg)
2889{
2890 char *cp = buf;
2891 char c;
2892 int wasspace = 1;
2893
2894 *cp++ = '\t';
2895 while ((c = *msg++)) {
2896 if (wasspace && isspace(c))
2897 continue;
2898 wasspace = isspace(c);
2899 if (wasspace)
2900 c = ' ';
2901 *cp++ = c;
2902 }
2903 while (buf < cp && isspace(cp[-1]))
2904 cp--;
2905 *cp++ = '\n';
2906 return cp - buf;
2907}
2908
bd3b02da 2909/* This function must set a meaningful errno on failure */
dfefa935 2910int log_ref_setup(const char *refname, char *logfile, int bufsize)
6de08ae6 2911{
859c3017 2912 int logfd, oflags = O_APPEND | O_WRONLY;
9a13f0b7 2913
dfefa935 2914 git_snpath(logfile, bufsize, "logs/%s", refname);
4057deb5 2915 if (log_all_ref_updates &&
59556548
CC
2916 (starts_with(refname, "refs/heads/") ||
2917 starts_with(refname, "refs/remotes/") ||
2918 starts_with(refname, "refs/notes/") ||
dfefa935 2919 !strcmp(refname, "HEAD"))) {
bd3b02da
RS
2920 if (safe_create_leading_directories(logfile) < 0) {
2921 int save_errno = errno;
2922 error("unable to create directory for %s", logfile);
2923 errno = save_errno;
2924 return -1;
2925 }
6de08ae6
SP
2926 oflags |= O_CREAT;
2927 }
2928
157aaea5 2929 logfd = open(logfile, oflags, 0666);
6de08ae6 2930 if (logfd < 0) {
9233887c 2931 if (!(oflags & O_CREAT) && (errno == ENOENT || errno == EISDIR))
6de08ae6 2932 return 0;
3b463c3f 2933
9233887c 2934 if (errno == EISDIR) {
157aaea5 2935 if (remove_empty_directories(logfile)) {
bd3b02da
RS
2936 int save_errno = errno;
2937 error("There are still logs under '%s'",
2938 logfile);
2939 errno = save_errno;
2940 return -1;
3b463c3f 2941 }
157aaea5 2942 logfd = open(logfile, oflags, 0666);
3b463c3f
JH
2943 }
2944
bd3b02da
RS
2945 if (logfd < 0) {
2946 int save_errno = errno;
2947 error("Unable to append to %s: %s", logfile,
2948 strerror(errno));
2949 errno = save_errno;
2950 return -1;
2951 }
6de08ae6
SP
2952 }
2953
157aaea5 2954 adjust_shared_perm(logfile);
859c3017
EM
2955 close(logfd);
2956 return 0;
2957}
443b92b6 2958
2c6207ab
RS
2959static int log_ref_write_fd(int fd, const unsigned char *old_sha1,
2960 const unsigned char *new_sha1,
2961 const char *committer, const char *msg)
2962{
2963 int msglen, written;
2964 unsigned maxlen, len;
2965 char *logrec;
2966
2967 msglen = msg ? strlen(msg) : 0;
2968 maxlen = strlen(committer) + msglen + 100;
2969 logrec = xmalloc(maxlen);
2970 len = sprintf(logrec, "%s %s %s\n",
2971 sha1_to_hex(old_sha1),
2972 sha1_to_hex(new_sha1),
2973 committer);
2974 if (msglen)
2975 len += copy_msg(logrec + len - 1, msg) - 1;
2976
2977 written = len <= maxlen ? write_in_full(fd, logrec, len) : -1;
2978 free(logrec);
2979 if (written != len)
2980 return -1;
2981
2982 return 0;
2983}
2984
dfefa935 2985static int log_ref_write(const char *refname, const unsigned char *old_sha1,
859c3017
EM
2986 const unsigned char *new_sha1, const char *msg)
2987{
2c6207ab 2988 int logfd, result, oflags = O_APPEND | O_WRONLY;
157aaea5 2989 char log_file[PATH_MAX];
859c3017
EM
2990
2991 if (log_all_ref_updates < 0)
2992 log_all_ref_updates = !is_bare_repository();
2993
dfefa935 2994 result = log_ref_setup(refname, log_file, sizeof(log_file));
859c3017
EM
2995 if (result)
2996 return result;
2997
2998 logfd = open(log_file, oflags);
2999 if (logfd < 0)
3000 return 0;
2c6207ab
RS
3001 result = log_ref_write_fd(logfd, old_sha1, new_sha1,
3002 git_committer_info(0), msg);
3003 if (result) {
dc615de8
RS
3004 int save_errno = errno;
3005 close(logfd);
3006 error("Unable to append to %s", log_file);
3007 errno = save_errno;
3008 return -1;
3009 }
3010 if (close(logfd)) {
3011 int save_errno = errno;
3012 error("Unable to append to %s", log_file);
3013 errno = save_errno;
3014 return -1;
3015 }
6de08ae6
SP
3016 return 0;
3017}
3018
e7e0f26e 3019int is_branch(const char *refname)
c3b0dec5 3020{
59556548 3021 return !strcmp(refname, "HEAD") || starts_with(refname, "refs/heads/");
c3b0dec5
LT
3022}
3023
aae383db
RS
3024/*
3025 * Write sha1 into the ref specified by the lock. Make sure that errno
3026 * is sane on error.
3027 */
3028static int write_ref_sha1(struct ref_lock *lock,
4bd18c43
SP
3029 const unsigned char *sha1, const char *logmsg)
3030{
3031 static char term = '\n';
c3b0dec5 3032 struct object *o;
4bd18c43 3033
c3b0dec5
LT
3034 o = parse_object(sha1);
3035 if (!o) {
7be8b3ba 3036 error("Trying to write ref %s with nonexistent object %s",
c3b0dec5
LT
3037 lock->ref_name, sha1_to_hex(sha1));
3038 unlock_ref(lock);
dc615de8 3039 errno = EINVAL;
c3b0dec5
LT
3040 return -1;
3041 }
3042 if (o->type != OBJ_COMMIT && is_branch(lock->ref_name)) {
3043 error("Trying to write non-commit object %s to branch %s",
3044 sha1_to_hex(sha1), lock->ref_name);
3045 unlock_ref(lock);
dc615de8 3046 errno = EINVAL;
c3b0dec5
LT
3047 return -1;
3048 }
93822c22 3049 if (write_in_full(lock->lock_fd, sha1_to_hex(sha1), 40) != 40 ||
dc615de8
RS
3050 write_in_full(lock->lock_fd, &term, 1) != 1 ||
3051 close_ref(lock) < 0) {
3052 int save_errno = errno;
cf6950d3 3053 error("Couldn't write %s", lock->lk->filename.buf);
4bd18c43 3054 unlock_ref(lock);
dc615de8 3055 errno = save_errno;
4bd18c43
SP
3056 return -1;
3057 }
9da31cb0 3058 clear_loose_ref_cache(&ref_cache);
bd104db1
NP
3059 if (log_ref_write(lock->ref_name, lock->old_sha1, sha1, logmsg) < 0 ||
3060 (strcmp(lock->ref_name, lock->orig_ref_name) &&
3061 log_ref_write(lock->orig_ref_name, lock->old_sha1, sha1, logmsg) < 0)) {
6de08ae6
SP
3062 unlock_ref(lock);
3063 return -1;
3064 }
605fac8b
NP
3065 if (strcmp(lock->orig_ref_name, "HEAD") != 0) {
3066 /*
3067 * Special hack: If a branch is updated directly and HEAD
3068 * points to it (may happen on the remote side of a push
3069 * for example) then logically the HEAD reflog should be
3070 * updated too.
3071 * A generic solution implies reverse symref information,
3072 * but finding all symrefs pointing to the given branch
3073 * would be rather costly for this rare event (the direct
3074 * update of a branch) to be worth it. So let's cheat and
3075 * check with HEAD only which should cover 99% of all usage
3076 * scenarios (even 100% of the default ones).
3077 */
3078 unsigned char head_sha1[20];
3079 int head_flag;
3080 const char *head_ref;
7695d118
RS
3081 head_ref = resolve_ref_unsafe("HEAD", RESOLVE_REF_READING,
3082 head_sha1, &head_flag);
605fac8b
NP
3083 if (head_ref && (head_flag & REF_ISSYMREF) &&
3084 !strcmp(head_ref, lock->ref_name))
3085 log_ref_write("HEAD", lock->old_sha1, sha1, logmsg);
3086 }
b531394d 3087 if (commit_ref(lock)) {
434cd0cd 3088 error("Couldn't set %s", lock->ref_name);
4bd18c43
SP
3089 unlock_ref(lock);
3090 return -1;
3091 }
4bd18c43
SP
3092 unlock_ref(lock);
3093 return 0;
95fc7512 3094}
d556fae2 3095
8b5157e4
NP
3096int create_symref(const char *ref_target, const char *refs_heads_master,
3097 const char *logmsg)
41b625b0
NP
3098{
3099 const char *lockpath;
3100 char ref[1000];
3101 int fd, len, written;
a4f34cbb 3102 char *git_HEAD = git_pathdup("%s", ref_target);
8b5157e4
NP
3103 unsigned char old_sha1[20], new_sha1[20];
3104
3105 if (logmsg && read_ref(ref_target, old_sha1))
3106 hashclr(old_sha1);
41b625b0 3107
d48744d1
JH
3108 if (safe_create_leading_directories(git_HEAD) < 0)
3109 return error("unable to create directory for %s", git_HEAD);
3110
41b625b0
NP
3111#ifndef NO_SYMLINK_HEAD
3112 if (prefer_symlink_refs) {
3113 unlink(git_HEAD);
3114 if (!symlink(refs_heads_master, git_HEAD))
8b5157e4 3115 goto done;
41b625b0
NP
3116 fprintf(stderr, "no symlink - falling back to symbolic ref\n");
3117 }
3118#endif
3119
3120 len = snprintf(ref, sizeof(ref), "ref: %s\n", refs_heads_master);
3121 if (sizeof(ref) <= len) {
3122 error("refname too long: %s", refs_heads_master);
47fc52e2 3123 goto error_free_return;
41b625b0
NP
3124 }
3125 lockpath = mkpath("%s.lock", git_HEAD);
3126 fd = open(lockpath, O_CREAT | O_EXCL | O_WRONLY, 0666);
3127 if (fd < 0) {
3128 error("Unable to open %s for writing", lockpath);
47fc52e2 3129 goto error_free_return;
41b625b0
NP
3130 }
3131 written = write_in_full(fd, ref, len);
91c8d590 3132 if (close(fd) != 0 || written != len) {
41b625b0 3133 error("Unable to write to %s", lockpath);
47fc52e2 3134 goto error_unlink_return;
41b625b0
NP
3135 }
3136 if (rename(lockpath, git_HEAD) < 0) {
41b625b0 3137 error("Unable to create %s", git_HEAD);
47fc52e2 3138 goto error_unlink_return;
41b625b0
NP
3139 }
3140 if (adjust_shared_perm(git_HEAD)) {
41b625b0 3141 error("Unable to fix permissions on %s", lockpath);
47fc52e2 3142 error_unlink_return:
691f1a28 3143 unlink_or_warn(lockpath);
47fc52e2
JH
3144 error_free_return:
3145 free(git_HEAD);
3146 return -1;
41b625b0 3147 }
8b5157e4 3148
ee96d11b 3149#ifndef NO_SYMLINK_HEAD
8b5157e4 3150 done:
ee96d11b 3151#endif
8b5157e4
NP
3152 if (logmsg && !read_ref(refs_heads_master, new_sha1))
3153 log_ref_write(ref_target, old_sha1, new_sha1, logmsg);
3154
47fc52e2 3155 free(git_HEAD);
41b625b0
NP
3156 return 0;
3157}
3158
4207ed28
RS
3159struct read_ref_at_cb {
3160 const char *refname;
3161 unsigned long at_time;
3162 int cnt;
3163 int reccnt;
3164 unsigned char *sha1;
3165 int found_it;
3166
3167 unsigned char osha1[20];
3168 unsigned char nsha1[20];
3169 int tz;
3170 unsigned long date;
3171 char **msg;
3172 unsigned long *cutoff_time;
3173 int *cutoff_tz;
3174 int *cutoff_cnt;
3175};
3176
3177static int read_ref_at_ent(unsigned char *osha1, unsigned char *nsha1,
3178 const char *email, unsigned long timestamp, int tz,
3179 const char *message, void *cb_data)
3180{
3181 struct read_ref_at_cb *cb = cb_data;
3182
3183 cb->reccnt++;
3184 cb->tz = tz;
3185 cb->date = timestamp;
3186
3187 if (timestamp <= cb->at_time || cb->cnt == 0) {
3188 if (cb->msg)
3189 *cb->msg = xstrdup(message);
3190 if (cb->cutoff_time)
3191 *cb->cutoff_time = timestamp;
3192 if (cb->cutoff_tz)
3193 *cb->cutoff_tz = tz;
3194 if (cb->cutoff_cnt)
3195 *cb->cutoff_cnt = cb->reccnt - 1;
3196 /*
3197 * we have not yet updated cb->[n|o]sha1 so they still
3198 * hold the values for the previous record.
3199 */
3200 if (!is_null_sha1(cb->osha1)) {
3201 hashcpy(cb->sha1, nsha1);
3202 if (hashcmp(cb->osha1, nsha1))
3203 warning("Log for ref %s has gap after %s.",
3204 cb->refname, show_date(cb->date, cb->tz, DATE_RFC2822));
3205 }
3206 else if (cb->date == cb->at_time)
3207 hashcpy(cb->sha1, nsha1);
3208 else if (hashcmp(nsha1, cb->sha1))
3209 warning("Log for ref %s unexpectedly ended on %s.",
3210 cb->refname, show_date(cb->date, cb->tz,
3211 DATE_RFC2822));
3212 hashcpy(cb->osha1, osha1);
3213 hashcpy(cb->nsha1, nsha1);
3214 cb->found_it = 1;
3215 return 1;
3216 }
3217 hashcpy(cb->osha1, osha1);
3218 hashcpy(cb->nsha1, nsha1);
3219 if (cb->cnt > 0)
3220 cb->cnt--;
3221 return 0;
3222}
3223
3224static int read_ref_at_ent_oldest(unsigned char *osha1, unsigned char *nsha1,
3225 const char *email, unsigned long timestamp,
3226 int tz, const char *message, void *cb_data)
3227{
3228 struct read_ref_at_cb *cb = cb_data;
3229
3230 if (cb->msg)
3231 *cb->msg = xstrdup(message);
3232 if (cb->cutoff_time)
3233 *cb->cutoff_time = timestamp;
3234 if (cb->cutoff_tz)
3235 *cb->cutoff_tz = tz;
3236 if (cb->cutoff_cnt)
3237 *cb->cutoff_cnt = cb->reccnt;
3238 hashcpy(cb->sha1, osha1);
3239 if (is_null_sha1(cb->sha1))
3240 hashcpy(cb->sha1, nsha1);
3241 /* We just want the first entry */
3242 return 1;
16d7cc90
JH
3243}
3244
c41a87dd 3245int read_ref_at(const char *refname, unsigned int flags, unsigned long at_time, int cnt,
dfefa935
MH
3246 unsigned char *sha1, char **msg,
3247 unsigned long *cutoff_time, int *cutoff_tz, int *cutoff_cnt)
d556fae2 3248{
4207ed28 3249 struct read_ref_at_cb cb;
d556fae2 3250
4207ed28
RS
3251 memset(&cb, 0, sizeof(cb));
3252 cb.refname = refname;
3253 cb.at_time = at_time;
3254 cb.cnt = cnt;
3255 cb.msg = msg;
3256 cb.cutoff_time = cutoff_time;
3257 cb.cutoff_tz = cutoff_tz;
3258 cb.cutoff_cnt = cutoff_cnt;
3259 cb.sha1 = sha1;
3260
3261 for_each_reflog_ent_reverse(refname, read_ref_at_ent, &cb);
3262
c41a87dd
DA
3263 if (!cb.reccnt) {
3264 if (flags & GET_SHA1_QUIETLY)
3265 exit(128);
3266 else
3267 die("Log for %s is empty.", refname);
3268 }
4207ed28
RS
3269 if (cb.found_it)
3270 return 0;
3271
3272 for_each_reflog_ent(refname, read_ref_at_ent_oldest, &cb);
d556fae2 3273
16d7cc90 3274 return 1;
d556fae2 3275}
2ff81662 3276
4da58835
RS
3277int reflog_exists(const char *refname)
3278{
3279 struct stat st;
3280
3281 return !lstat(git_path("logs/%s", refname), &st) &&
3282 S_ISREG(st.st_mode);
3283}
3284
3285int delete_reflog(const char *refname)
3286{
3287 return remove_path(git_path("logs/%s", refname));
3288}
3289
9a7a183b
JH
3290static int show_one_reflog_ent(struct strbuf *sb, each_reflog_ent_fn fn, void *cb_data)
3291{
3292 unsigned char osha1[20], nsha1[20];
3293 char *email_end, *message;
3294 unsigned long timestamp;
3295 int tz;
3296
3297 /* old SP new SP name <email> SP time TAB msg LF */
3298 if (sb->len < 83 || sb->buf[sb->len - 1] != '\n' ||
3299 get_sha1_hex(sb->buf, osha1) || sb->buf[40] != ' ' ||
3300 get_sha1_hex(sb->buf + 41, nsha1) || sb->buf[81] != ' ' ||
3301 !(email_end = strchr(sb->buf + 82, '>')) ||
3302 email_end[1] != ' ' ||
3303 !(timestamp = strtoul(email_end + 2, &message, 10)) ||
3304 !message || message[0] != ' ' ||
3305 (message[1] != '+' && message[1] != '-') ||
3306 !isdigit(message[2]) || !isdigit(message[3]) ||
3307 !isdigit(message[4]) || !isdigit(message[5]))
3308 return 0; /* corrupt? */
3309 email_end[1] = '\0';
3310 tz = strtol(message + 1, NULL, 10);
3311 if (message[6] != '\t')
3312 message += 6;
3313 else
3314 message += 7;
3315 return fn(osha1, nsha1, sb->buf + 82, timestamp, tz, message, cb_data);
3316}
3317
98f85ff4
JH
3318static char *find_beginning_of_line(char *bob, char *scan)
3319{
3320 while (bob < scan && *(--scan) != '\n')
3321 ; /* keep scanning backwards */
3322 /*
3323 * Return either beginning of the buffer, or LF at the end of
3324 * the previous line.
3325 */
3326 return scan;
3327}
3328
3329int for_each_reflog_ent_reverse(const char *refname, each_reflog_ent_fn fn, void *cb_data)
2ff81662 3330{
8ca78803 3331 struct strbuf sb = STRBUF_INIT;
98f85ff4
JH
3332 FILE *logfp;
3333 long pos;
3334 int ret = 0, at_tail = 1;
2ff81662 3335
7ae07c1b 3336 logfp = fopen(git_path("logs/%s", refname), "r");
2ff81662 3337 if (!logfp)
883d60fa 3338 return -1;
101d15e0 3339
98f85ff4
JH
3340 /* Jump to the end */
3341 if (fseek(logfp, 0, SEEK_END) < 0)
3342 return error("cannot seek back reflog for %s: %s",
3343 refname, strerror(errno));
3344 pos = ftell(logfp);
3345 while (!ret && 0 < pos) {
3346 int cnt;
3347 size_t nread;
3348 char buf[BUFSIZ];
3349 char *endp, *scanp;
3350
3351 /* Fill next block from the end */
3352 cnt = (sizeof(buf) < pos) ? sizeof(buf) : pos;
3353 if (fseek(logfp, pos - cnt, SEEK_SET))
3354 return error("cannot seek back reflog for %s: %s",
3355 refname, strerror(errno));
3356 nread = fread(buf, cnt, 1, logfp);
e4ca819a 3357 if (nread != 1)
98f85ff4
JH
3358 return error("cannot read %d bytes from reflog for %s: %s",
3359 cnt, refname, strerror(errno));
3360 pos -= cnt;
3361
3362 scanp = endp = buf + cnt;
3363 if (at_tail && scanp[-1] == '\n')
3364 /* Looking at the final LF at the end of the file */
3365 scanp--;
3366 at_tail = 0;
3367
3368 while (buf < scanp) {
3369 /*
3370 * terminating LF of the previous line, or the beginning
3371 * of the buffer.
3372 */
3373 char *bp;
3374
3375 bp = find_beginning_of_line(buf, scanp);
3376
e5e73ff2 3377 if (*bp == '\n') {
98f85ff4 3378 /*
e5e73ff2
JK
3379 * The newline is the end of the previous line,
3380 * so we know we have complete line starting
3381 * at (bp + 1). Prefix it onto any prior data
3382 * we collected for the line and process it.
98f85ff4
JH
3383 */
3384 strbuf_splice(&sb, 0, 0, bp + 1, endp - (bp + 1));
3385 scanp = bp;
3386 endp = bp + 1;
e5e73ff2
JK
3387 ret = show_one_reflog_ent(&sb, fn, cb_data);
3388 strbuf_reset(&sb);
3389 if (ret)
3390 break;
3391 } else if (!pos) {
3392 /*
3393 * We are at the start of the buffer, and the
3394 * start of the file; there is no previous
3395 * line, and we have everything for this one.
3396 * Process it, and we can end the loop.
3397 */
3398 strbuf_splice(&sb, 0, 0, buf, endp - buf);
3399 ret = show_one_reflog_ent(&sb, fn, cb_data);
3400 strbuf_reset(&sb);
3401 break;
98f85ff4 3402 }
e5e73ff2
JK
3403
3404 if (bp == buf) {
3405 /*
3406 * We are at the start of the buffer, and there
3407 * is more file to read backwards. Which means
3408 * we are in the middle of a line. Note that we
3409 * may get here even if *bp was a newline; that
3410 * just means we are at the exact end of the
3411 * previous line, rather than some spot in the
3412 * middle.
3413 *
3414 * Save away what we have to be combined with
3415 * the data from the next read.
3416 */
3417 strbuf_splice(&sb, 0, 0, buf, endp - buf);
98f85ff4 3418 break;
e5e73ff2 3419 }
9d33f7c2 3420 }
101d15e0 3421
2ff81662 3422 }
98f85ff4 3423 if (!ret && sb.len)
69216bf7 3424 die("BUG: reverse reflog parser had leftover data");
98f85ff4 3425
2ff81662 3426 fclose(logfp);
8ca78803 3427 strbuf_release(&sb);
2266bf27 3428 return ret;
2ff81662 3429}
e29cb53a 3430
dfefa935 3431int for_each_reflog_ent(const char *refname, each_reflog_ent_fn fn, void *cb_data)
101d15e0 3432{
98f85ff4
JH
3433 FILE *logfp;
3434 struct strbuf sb = STRBUF_INIT;
3435 int ret = 0;
3436
3437 logfp = fopen(git_path("logs/%s", refname), "r");
3438 if (!logfp)
3439 return -1;
101d15e0 3440
98f85ff4
JH
3441 while (!ret && !strbuf_getwholeline(&sb, logfp, '\n'))
3442 ret = show_one_reflog_ent(&sb, fn, cb_data);
3443 fclose(logfp);
3444 strbuf_release(&sb);
3445 return ret;
3446}
989c0e5d
MH
3447/*
3448 * Call fn for each reflog in the namespace indicated by name. name
3449 * must be empty or end with '/'. Name will be used as a scratch
3450 * space, but its contents will be restored before return.
3451 */
3452static int do_for_each_reflog(struct strbuf *name, each_ref_fn fn, void *cb_data)
eb8381c8 3453{
989c0e5d 3454 DIR *d = opendir(git_path("logs/%s", name->buf));
fcee5a14 3455 int retval = 0;
93c603fc 3456 struct dirent *de;
989c0e5d 3457 int oldlen = name->len;
eb8381c8 3458
93c603fc 3459 if (!d)
989c0e5d 3460 return name->len ? errno : 0;
eb8381c8 3461
93c603fc
MH
3462 while ((de = readdir(d)) != NULL) {
3463 struct stat st;
eb8381c8 3464
93c603fc
MH
3465 if (de->d_name[0] == '.')
3466 continue;
2975c770 3467 if (ends_with(de->d_name, ".lock"))
93c603fc 3468 continue;
989c0e5d
MH
3469 strbuf_addstr(name, de->d_name);
3470 if (stat(git_path("logs/%s", name->buf), &st) < 0) {
3471 ; /* silently ignore */
93c603fc 3472 } else {
eb8381c8 3473 if (S_ISDIR(st.st_mode)) {
989c0e5d
MH
3474 strbuf_addch(name, '/');
3475 retval = do_for_each_reflog(name, fn, cb_data);
eb8381c8
NP
3476 } else {
3477 unsigned char sha1[20];
7695d118 3478 if (read_ref_full(name->buf, 0, sha1, NULL))
989c0e5d 3479 retval = error("bad ref for %s", name->buf);
eb8381c8 3480 else
989c0e5d 3481 retval = fn(name->buf, sha1, 0, cb_data);
eb8381c8
NP
3482 }
3483 if (retval)
3484 break;
3485 }
989c0e5d 3486 strbuf_setlen(name, oldlen);
eb8381c8 3487 }
93c603fc 3488 closedir(d);
eb8381c8
NP
3489 return retval;
3490}
3491
3492int for_each_reflog(each_ref_fn fn, void *cb_data)
3493{
989c0e5d
MH
3494 int retval;
3495 struct strbuf name;
3496 strbuf_init(&name, PATH_MAX);
3497 retval = do_for_each_reflog(&name, fn, cb_data);
3498 strbuf_release(&name);
3499 return retval;
eb8381c8 3500}
3d9f037c 3501
b5c8ea2a 3502/**
8df4e511
MH
3503 * Information needed for a single ref update. Set new_sha1 to the new
3504 * value or to null_sha1 to delete the ref. To check the old value
3505 * while the ref is locked, set (flags & REF_HAVE_OLD) and set
3506 * old_sha1 to the old value, or to null_sha1 to ensure the ref does
3507 * not exist before update.
b5c8ea2a
MH
3508 */
3509struct ref_update {
16180334
MH
3510 /*
3511 * If (flags & REF_HAVE_NEW), set the reference to this value:
3512 */
b5c8ea2a 3513 unsigned char new_sha1[20];
16180334
MH
3514 /*
3515 * If (flags & REF_HAVE_OLD), check that the reference
3516 * previously had this value:
3517 */
b5c8ea2a 3518 unsigned char old_sha1[20];
8df4e511 3519 /*
16180334 3520 * One or more of REF_HAVE_NEW, REF_HAVE_OLD, REF_NODEREF,
8df4e511
MH
3521 * REF_DELETING, and REF_ISPRUNING:
3522 */
3523 unsigned int flags;
81c960e4 3524 struct ref_lock *lock;
84178db7 3525 int type;
db7516ab 3526 char *msg;
88615910 3527 const char refname[FLEX_ARRAY];
b5c8ea2a
MH
3528};
3529
2bdc785f
RS
3530/*
3531 * Transaction states.
3532 * OPEN: The transaction is in a valid state and can accept new updates.
3533 * An OPEN transaction can be committed.
3534 * CLOSED: A closed transaction is no longer active and no other operations
3535 * than free can be used on it in this state.
3536 * A transaction can either become closed by successfully committing
3537 * an active transaction or if there is a failure while building
3538 * the transaction thus rendering it failed/inactive.
3539 */
3540enum ref_transaction_state {
3541 REF_TRANSACTION_OPEN = 0,
3542 REF_TRANSACTION_CLOSED = 1
3543};
3544
caa4046c
MH
3545/*
3546 * Data structure for holding a reference transaction, which can
3547 * consist of checks and updates to multiple references, carried out
3548 * as atomically as possible. This structure is opaque to callers.
3549 */
3550struct ref_transaction {
3551 struct ref_update **updates;
3552 size_t alloc;
3553 size_t nr;
2bdc785f 3554 enum ref_transaction_state state;
caa4046c
MH
3555};
3556
93a644ea 3557struct ref_transaction *ref_transaction_begin(struct strbuf *err)
caa4046c 3558{
5a603b04
JN
3559 assert(err);
3560
caa4046c
MH
3561 return xcalloc(1, sizeof(struct ref_transaction));
3562}
3563
026bd1d3 3564void ref_transaction_free(struct ref_transaction *transaction)
caa4046c
MH
3565{
3566 int i;
3567
1b07255c
RS
3568 if (!transaction)
3569 return;
3570
db7516ab
RS
3571 for (i = 0; i < transaction->nr; i++) {
3572 free(transaction->updates[i]->msg);
88615910 3573 free(transaction->updates[i]);
db7516ab 3574 }
caa4046c
MH
3575 free(transaction->updates);
3576 free(transaction);
3577}
3578
caa4046c
MH
3579static struct ref_update *add_update(struct ref_transaction *transaction,
3580 const char *refname)
3581{
88615910
MH
3582 size_t len = strlen(refname);
3583 struct ref_update *update = xcalloc(1, sizeof(*update) + len + 1);
caa4046c 3584
88615910 3585 strcpy((char *)update->refname, refname);
caa4046c
MH
3586 ALLOC_GROW(transaction->updates, transaction->nr + 1, transaction->alloc);
3587 transaction->updates[transaction->nr++] = update;
3588 return update;
3589}
3590
8e34800e
RS
3591int ref_transaction_update(struct ref_transaction *transaction,
3592 const char *refname,
3593 const unsigned char *new_sha1,
3594 const unsigned char *old_sha1,
1d147bdf