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