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