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