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