show-branch: use DATE_RELATIVE instead of magic number
[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 {
f5517074
MH
1376 int read_ok;
1377
3b124823 1378 if (*refs->name) {
f8948e2f 1379 hashclr(sha1);
0bad611b 1380 flag = 0;
f5517074
MH
1381 read_ok = !resolve_gitlink_ref(refs->name,
1382 refname.buf, sha1);
1383 } else {
1384 read_ok = !read_ref_full(refname.buf,
1385 RESOLVE_REF_READING,
1386 sha1, &flag);
1387 }
1388
1389 if (!read_ok) {
09116a1c
JH
1390 hashclr(sha1);
1391 flag |= REF_ISBROKEN;
501cf47c
MH
1392 } else if (is_null_sha1(sha1)) {
1393 /*
1394 * It is so astronomically unlikely
1395 * that NULL_SHA1 is the SHA-1 of an
1396 * actual object that we consider its
1397 * appearance in a loose reference
1398 * file to be repo corruption
1399 * (probably due to a software bug).
1400 */
1401 flag |= REF_ISBROKEN;
09116a1c 1402 }
f5517074 1403
d0f810f0
RS
1404 if (check_refname_format(refname.buf,
1405 REFNAME_ALLOW_ONELEVEL)) {
03afcbee
JK
1406 if (!refname_is_safe(refname.buf))
1407 die("loose refname is dangerous: %s", refname.buf);
d0f810f0
RS
1408 hashclr(sha1);
1409 flag |= REF_BAD_NAME | REF_ISBROKEN;
1410 }
9f2fb4a3 1411 add_entry_to_dir(dir,
d0f810f0 1412 create_ref_entry(refname.buf, sha1, flag, 0));
e1e22e37 1413 }
66a3d20b 1414 strbuf_setlen(&refname, dirnamelen);
e1e22e37 1415 }
72b64b44 1416 strbuf_release(&refname);
d5fdae67 1417 closedir(d);
e1e22e37
LT
1418}
1419
d3177275 1420static struct ref_dir *get_loose_refs(struct ref_cache *refs)
e1e22e37 1421{
d12229f5 1422 if (!refs->loose) {
28e6a34e
MH
1423 /*
1424 * Mark the top-level directory complete because we
1425 * are about to read the only subdirectory that can
1426 * hold references:
1427 */
b9146f51 1428 refs->loose = create_dir_entry(refs, "", 0, 0);
28e6a34e
MH
1429 /*
1430 * Create an incomplete entry for "refs/":
1431 */
1432 add_entry_to_dir(get_ref_dir(refs->loose),
b9146f51 1433 create_dir_entry(refs, "refs/", 5, 1));
e1e22e37 1434 }
d7826d54 1435 return get_ref_dir(refs->loose);
e1e22e37
LT
1436}
1437
ca8db142
LT
1438/* We allow "recursive" symbolic refs. Only within reason, though */
1439#define MAXDEPTH 5
0ebde32c
LT
1440#define MAXREFLEN (1024)
1441
e5fa45c1
JH
1442/*
1443 * Called by resolve_gitlink_ref_recursive() after it failed to read
b0626608
MH
1444 * from the loose refs in ref_cache refs. Find <refname> in the
1445 * packed-refs file for the submodule.
e5fa45c1 1446 */
b0626608 1447static int resolve_gitlink_packed_ref(struct ref_cache *refs,
85be1fe3 1448 const char *refname, unsigned char *sha1)
0ebde32c 1449{
2c5c66be 1450 struct ref_entry *ref;
d3177275 1451 struct ref_dir *dir = get_packed_refs(refs);
0ebde32c 1452
432ad41e 1453 ref = find_ref(dir, refname);
b0626608
MH
1454 if (ref == NULL)
1455 return -1;
1456
8353847e 1457 hashcpy(sha1, ref->u.value.oid.hash);
b0626608 1458 return 0;
0ebde32c
LT
1459}
1460
b0626608 1461static int resolve_gitlink_ref_recursive(struct ref_cache *refs,
85be1fe3 1462 const char *refname, unsigned char *sha1,
dfefa935 1463 int recursion)
0ebde32c 1464{
064d51dc 1465 int fd, len;
0ebde32c 1466 char buffer[128], *p;
dcf69262 1467 const char *path;
0ebde32c 1468
064d51dc 1469 if (recursion > MAXDEPTH || strlen(refname) > MAXREFLEN)
0ebde32c 1470 return -1;
064d51dc
MH
1471 path = *refs->name
1472 ? git_path_submodule(refs->name, "%s", refname)
1473 : git_path("%s", refname);
1474 fd = open(path, O_RDONLY);
0ebde32c 1475 if (fd < 0)
b0626608 1476 return resolve_gitlink_packed_ref(refs, refname, sha1);
0ebde32c
LT
1477
1478 len = read(fd, buffer, sizeof(buffer)-1);
1479 close(fd);
1480 if (len < 0)
1481 return -1;
1482 while (len && isspace(buffer[len-1]))
1483 len--;
1484 buffer[len] = 0;
1485
1486 /* Was it a detached head or an old-fashioned symlink? */
85be1fe3 1487 if (!get_sha1_hex(buffer, sha1))
0ebde32c
LT
1488 return 0;
1489
1490 /* Symref? */
1491 if (strncmp(buffer, "ref:", 4))
1492 return -1;
1493 p = buffer + 4;
1494 while (isspace(*p))
1495 p++;
1496
064d51dc 1497 return resolve_gitlink_ref_recursive(refs, p, sha1, recursion+1);
0ebde32c
LT
1498}
1499
85be1fe3 1500int resolve_gitlink_ref(const char *path, const char *refname, unsigned char *sha1)
0ebde32c
LT
1501{
1502 int len = strlen(path), retval;
064d51dc 1503 char *submodule;
b0626608 1504 struct ref_cache *refs;
0ebde32c
LT
1505
1506 while (len && path[len-1] == '/')
1507 len--;
1508 if (!len)
1509 return -1;
b0626608
MH
1510 submodule = xstrndup(path, len);
1511 refs = get_ref_cache(submodule);
1512 free(submodule);
1513
064d51dc 1514 retval = resolve_gitlink_ref_recursive(refs, refname, sha1, 0);
0ebde32c
LT
1515 return retval;
1516}
ca8db142 1517
4886b89f 1518/*
63331581
MH
1519 * Return the ref_entry for the given refname from the packed
1520 * references. If it does not exist, return NULL.
4886b89f 1521 */
63331581 1522static struct ref_entry *get_packed_ref(const char *refname)
c224ca7f 1523{
9da31cb0 1524 return find_ref(get_packed_refs(&ref_cache), refname);
c224ca7f
MH
1525}
1526
47f534bf
MH
1527/*
1528 * A loose ref file doesn't exist; check for a packed ref. The
1529 * options are forwarded from resolve_safe_unsafe().
1530 */
d0f810f0
RS
1531static int resolve_missing_loose_ref(const char *refname,
1532 int resolve_flags,
1533 unsigned char *sha1,
1534 int *flags)
47f534bf
MH
1535{
1536 struct ref_entry *entry;
1537
1538 /*
1539 * The loose reference file does not exist; check for a packed
1540 * reference.
1541 */
1542 entry = get_packed_ref(refname);
1543 if (entry) {
8353847e 1544 hashcpy(sha1, entry->u.value.oid.hash);
7695d118
RS
1545 if (flags)
1546 *flags |= REF_ISPACKED;
d0f810f0 1547 return 0;
47f534bf
MH
1548 }
1549 /* The reference is not a packed reference, either. */
7695d118 1550 if (resolve_flags & RESOLVE_REF_READING) {
d0f810f0
RS
1551 errno = ENOENT;
1552 return -1;
47f534bf
MH
1553 } else {
1554 hashclr(sha1);
d0f810f0 1555 return 0;
47f534bf
MH
1556 }
1557}
1558
76d70dc0 1559/* This function needs to return a meaningful errno on failure */
1a83c240
NTND
1560static const char *resolve_ref_unsafe_1(const char *refname,
1561 int resolve_flags,
1562 unsigned char *sha1,
1563 int *flags,
1564 struct strbuf *sb_path)
8a65ff76 1565{
0104ca09
HO
1566 int depth = MAXDEPTH;
1567 ssize_t len;
a876ed83 1568 char buffer[256];
dfefa935 1569 static char refname_buffer[256];
d0f810f0 1570 int bad_name = 0;
ca8db142 1571
7695d118
RS
1572 if (flags)
1573 *flags = 0;
8da19775 1574
76d70dc0 1575 if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL)) {
d0f810f0
RS
1576 if (flags)
1577 *flags |= REF_BAD_NAME;
1578
1579 if (!(resolve_flags & RESOLVE_REF_ALLOW_BAD_NAME) ||
1580 !refname_is_safe(refname)) {
1581 errno = EINVAL;
1582 return NULL;
1583 }
1584 /*
1585 * dwim_ref() uses REF_ISBROKEN to distinguish between
1586 * missing refs and refs that were present but invalid,
1587 * to complain about the latter to stderr.
1588 *
1589 * We don't know whether the ref exists, so don't set
1590 * REF_ISBROKEN yet.
1591 */
1592 bad_name = 1;
76d70dc0 1593 }
a876ed83 1594 for (;;) {
1a83c240 1595 const char *path;
a876ed83
JH
1596 struct stat st;
1597 char *buf;
1598 int fd;
8a65ff76 1599
76d70dc0
RS
1600 if (--depth < 0) {
1601 errno = ELOOP;
a876ed83 1602 return NULL;
76d70dc0 1603 }
ca8db142 1604
1a83c240
NTND
1605 strbuf_reset(sb_path);
1606 strbuf_git_path(sb_path, "%s", refname);
1607 path = sb_path->buf;
c224ca7f 1608
fcb7c762
MH
1609 /*
1610 * We might have to loop back here to avoid a race
1611 * condition: first we lstat() the file, then we try
1612 * to read it as a link or as a file. But if somebody
1613 * changes the type of the file (file <-> directory
1614 * <-> symlink) between the lstat() and reading, then
1615 * we don't want to report that as an error but rather
1616 * try again starting with the lstat().
1617 */
1618 stat_ref:
a876ed83 1619 if (lstat(path, &st) < 0) {
d0f810f0
RS
1620 if (errno != ENOENT)
1621 return NULL;
1622 if (resolve_missing_loose_ref(refname, resolve_flags,
1623 sha1, flags))
a876ed83 1624 return NULL;
d0f810f0
RS
1625 if (bad_name) {
1626 hashclr(sha1);
1627 if (flags)
1628 *flags |= REF_ISBROKEN;
1629 }
1630 return refname;
a876ed83 1631 }
ca8db142 1632
a876ed83
JH
1633 /* Follow "normalized" - ie "refs/.." symlinks by hand */
1634 if (S_ISLNK(st.st_mode)) {
1635 len = readlink(path, buffer, sizeof(buffer)-1);
fcb7c762
MH
1636 if (len < 0) {
1637 if (errno == ENOENT || errno == EINVAL)
1638 /* inconsistent with lstat; retry */
1639 goto stat_ref;
1640 else
1641 return NULL;
1642 }
b54cb795 1643 buffer[len] = 0;
59556548 1644 if (starts_with(buffer, "refs/") &&
1f58a038 1645 !check_refname_format(buffer, 0)) {
dfefa935
MH
1646 strcpy(refname_buffer, buffer);
1647 refname = refname_buffer;
7695d118
RS
1648 if (flags)
1649 *flags |= REF_ISSYMREF;
62a2d525
JN
1650 if (resolve_flags & RESOLVE_REF_NO_RECURSE) {
1651 hashclr(sha1);
1652 return refname;
1653 }
a876ed83
JH
1654 continue;
1655 }
ca8db142 1656 }
a876ed83 1657
7a21632f
DS
1658 /* Is it a directory? */
1659 if (S_ISDIR(st.st_mode)) {
1660 errno = EISDIR;
1661 return NULL;
1662 }
1663
a876ed83
JH
1664 /*
1665 * Anything else, just open it and try to use it as
1666 * a ref
1667 */
1668 fd = open(path, O_RDONLY);
fcb7c762
MH
1669 if (fd < 0) {
1670 if (errno == ENOENT)
1671 /* inconsistent with lstat; retry */
1672 goto stat_ref;
1673 else
1674 return NULL;
1675 }
93d26e4c 1676 len = read_in_full(fd, buffer, sizeof(buffer)-1);
76d70dc0
RS
1677 if (len < 0) {
1678 int save_errno = errno;
1679 close(fd);
1680 errno = save_errno;
28775050 1681 return NULL;
76d70dc0
RS
1682 }
1683 close(fd);
28775050
MH
1684 while (len && isspace(buffer[len-1]))
1685 len--;
1686 buffer[len] = '\0';
a876ed83
JH
1687
1688 /*
1689 * Is it a symbolic ref?
1690 */
59556548 1691 if (!starts_with(buffer, "ref:")) {
2884c06a
MH
1692 /*
1693 * Please note that FETCH_HEAD has a second
1694 * line containing other data.
1695 */
1696 if (get_sha1_hex(buffer, sha1) ||
1697 (buffer[40] != '\0' && !isspace(buffer[40]))) {
7695d118
RS
1698 if (flags)
1699 *flags |= REF_ISBROKEN;
76d70dc0 1700 errno = EINVAL;
2884c06a
MH
1701 return NULL;
1702 }
d0f810f0
RS
1703 if (bad_name) {
1704 hashclr(sha1);
1705 if (flags)
1706 *flags |= REF_ISBROKEN;
1707 }
2884c06a
MH
1708 return refname;
1709 }
7695d118
RS
1710 if (flags)
1711 *flags |= REF_ISSYMREF;
a876ed83 1712 buf = buffer + 4;
28775050
MH
1713 while (isspace(*buf))
1714 buf++;
62a2d525
JN
1715 refname = strcpy(refname_buffer, buf);
1716 if (resolve_flags & RESOLVE_REF_NO_RECURSE) {
1717 hashclr(sha1);
1718 return refname;
1719 }
313fb010 1720 if (check_refname_format(buf, REFNAME_ALLOW_ONELEVEL)) {
7695d118
RS
1721 if (flags)
1722 *flags |= REF_ISBROKEN;
d0f810f0
RS
1723
1724 if (!(resolve_flags & RESOLVE_REF_ALLOW_BAD_NAME) ||
1725 !refname_is_safe(buf)) {
1726 errno = EINVAL;
1727 return NULL;
1728 }
1729 bad_name = 1;
313fb010 1730 }
8a65ff76 1731 }
a876ed83
JH
1732}
1733
1a83c240
NTND
1734const char *resolve_ref_unsafe(const char *refname, int resolve_flags,
1735 unsigned char *sha1, int *flags)
1736{
1737 struct strbuf sb_path = STRBUF_INIT;
1738 const char *ret = resolve_ref_unsafe_1(refname, resolve_flags,
1739 sha1, flags, &sb_path);
1740 strbuf_release(&sb_path);
1741 return ret;
1742}
1743
7695d118 1744char *resolve_refdup(const char *ref, int resolve_flags, unsigned char *sha1, int *flags)
96ec7b1e 1745{
092c4be7 1746 return xstrdup_or_null(resolve_ref_unsafe(ref, resolve_flags, sha1, flags));
96ec7b1e
NTND
1747}
1748
d08bae7e
IL
1749/* The argument to filter_refs */
1750struct ref_filter {
1751 const char *pattern;
1752 each_ref_fn *fn;
1753 void *cb_data;
1754};
1755
7695d118 1756int read_ref_full(const char *refname, int resolve_flags, unsigned char *sha1, int *flags)
a876ed83 1757{
7695d118 1758 if (resolve_ref_unsafe(refname, resolve_flags, sha1, flags))
a876ed83
JH
1759 return 0;
1760 return -1;
8a65ff76
LT
1761}
1762
dfefa935 1763int read_ref(const char *refname, unsigned char *sha1)
c6893323 1764{
7695d118 1765 return read_ref_full(refname, RESOLVE_REF_READING, sha1, NULL);
c6893323
NTND
1766}
1767
bc5fd6d3 1768int ref_exists(const char *refname)
ef06b918 1769{
bc5fd6d3 1770 unsigned char sha1[20];
7695d118 1771 return !!resolve_ref_unsafe(refname, RESOLVE_REF_READING, sha1, NULL);
ef06b918
JH
1772}
1773
2b2a5be3 1774static int filter_refs(const char *refname, const struct object_id *oid,
4e675d17 1775 int flags, void *data)
d08bae7e
IL
1776{
1777 struct ref_filter *filter = (struct ref_filter *)data;
2b2a5be3 1778
eb07894f 1779 if (wildmatch(filter->pattern, refname, 0, NULL))
d08bae7e 1780 return 0;
2b2a5be3 1781 return filter->fn(refname, oid, flags, filter->cb_data);
d08bae7e
IL
1782}
1783
68cf8703
MH
1784enum peel_status {
1785 /* object was peeled successfully: */
1786 PEEL_PEELED = 0,
1787
1788 /*
1789 * object cannot be peeled because the named object (or an
1790 * object referred to by a tag in the peel chain), does not
1791 * exist.
1792 */
1793 PEEL_INVALID = -1,
1794
1795 /* object cannot be peeled because it is not a tag: */
9a489f3c
MH
1796 PEEL_NON_TAG = -2,
1797
1798 /* ref_entry contains no peeled value because it is a symref: */
1799 PEEL_IS_SYMREF = -3,
1800
1801 /*
1802 * ref_entry cannot be peeled because it is broken (i.e., the
1803 * symbolic reference cannot even be resolved to an object
1804 * name):
1805 */
1806 PEEL_BROKEN = -4
68cf8703
MH
1807};
1808
cb2ae1c4
MH
1809/*
1810 * Peel the named object; i.e., if the object is a tag, resolve the
68cf8703
MH
1811 * tag recursively until a non-tag is found. If successful, store the
1812 * result to sha1 and return PEEL_PEELED. If the object is not a tag
1813 * or is not valid, return PEEL_NON_TAG or PEEL_INVALID, respectively,
1814 * and leave sha1 unchanged.
cb2ae1c4 1815 */
68cf8703 1816static enum peel_status peel_object(const unsigned char *name, unsigned char *sha1)
cb2ae1c4
MH
1817{
1818 struct object *o = lookup_unknown_object(name);
1819
1820 if (o->type == OBJ_NONE) {
1821 int type = sha1_object_info(name, NULL);
8ff226a9 1822 if (type < 0 || !object_as_type(o, type, 0))
68cf8703 1823 return PEEL_INVALID;
cb2ae1c4
MH
1824 }
1825
1826 if (o->type != OBJ_TAG)
68cf8703 1827 return PEEL_NON_TAG;
cb2ae1c4
MH
1828
1829 o = deref_tag_noverify(o);
1830 if (!o)
68cf8703 1831 return PEEL_INVALID;
cb2ae1c4
MH
1832
1833 hashcpy(sha1, o->sha1);
68cf8703 1834 return PEEL_PEELED;
cb2ae1c4
MH
1835}
1836
9a489f3c 1837/*
f85354b5
MH
1838 * Peel the entry (if possible) and return its new peel_status. If
1839 * repeel is true, re-peel the entry even if there is an old peeled
1840 * value that is already stored in it.
694b7a19
MH
1841 *
1842 * It is OK to call this function with a packed reference entry that
1843 * might be stale and might even refer to an object that has since
1844 * been garbage-collected. In such a case, if the entry has
1845 * REF_KNOWS_PEELED then leave the status unchanged and return
1846 * PEEL_PEELED or PEEL_NON_TAG; otherwise, return PEEL_INVALID.
9a489f3c 1847 */
f85354b5 1848static enum peel_status peel_entry(struct ref_entry *entry, int repeel)
9a489f3c
MH
1849{
1850 enum peel_status status;
1851
f85354b5
MH
1852 if (entry->flag & REF_KNOWS_PEELED) {
1853 if (repeel) {
1854 entry->flag &= ~REF_KNOWS_PEELED;
8353847e 1855 oidclr(&entry->u.value.peeled);
f85354b5 1856 } else {
8353847e 1857 return is_null_oid(&entry->u.value.peeled) ?
f85354b5
MH
1858 PEEL_NON_TAG : PEEL_PEELED;
1859 }
1860 }
9a489f3c
MH
1861 if (entry->flag & REF_ISBROKEN)
1862 return PEEL_BROKEN;
1863 if (entry->flag & REF_ISSYMREF)
1864 return PEEL_IS_SYMREF;
1865
8353847e 1866 status = peel_object(entry->u.value.oid.hash, entry->u.value.peeled.hash);
9a489f3c
MH
1867 if (status == PEEL_PEELED || status == PEEL_NON_TAG)
1868 entry->flag |= REF_KNOWS_PEELED;
1869 return status;
1870}
1871
dfefa935 1872int peel_ref(const char *refname, unsigned char *sha1)
cf0adba7
JH
1873{
1874 int flag;
1875 unsigned char base[20];
cf0adba7 1876
dfefa935 1877 if (current_ref && (current_ref->name == refname
9a489f3c 1878 || !strcmp(current_ref->name, refname))) {
f85354b5 1879 if (peel_entry(current_ref, 0))
9a489f3c 1880 return -1;
8353847e 1881 hashcpy(sha1, current_ref->u.value.peeled.hash);
9a489f3c 1882 return 0;
0ae91be0
SP
1883 }
1884
7695d118 1885 if (read_ref_full(refname, RESOLVE_REF_READING, base, &flag))
cf0adba7
JH
1886 return -1;
1887
9a489f3c
MH
1888 /*
1889 * If the reference is packed, read its ref_entry from the
1890 * cache in the hope that we already know its peeled value.
1891 * We only try this optimization on packed references because
1892 * (a) forcing the filling of the loose reference cache could
1893 * be expensive and (b) loose references anyway usually do not
1894 * have REF_KNOWS_PEELED.
1895 */
1896 if (flag & REF_ISPACKED) {
f361baeb 1897 struct ref_entry *r = get_packed_ref(refname);
9a489f3c 1898 if (r) {
f85354b5 1899 if (peel_entry(r, 0))
9a489f3c 1900 return -1;
8353847e 1901 hashcpy(sha1, r->u.value.peeled.hash);
e9c4c111 1902 return 0;
cf0adba7 1903 }
cf0adba7
JH
1904 }
1905
cb2ae1c4 1906 return peel_object(base, sha1);
cf0adba7
JH
1907}
1908
bc5fd6d3
MH
1909struct warn_if_dangling_data {
1910 FILE *fp;
1911 const char *refname;
e6bea66d 1912 const struct string_list *refnames;
bc5fd6d3
MH
1913 const char *msg_fmt;
1914};
1915
2b2a5be3 1916static int warn_if_dangling_symref(const char *refname, const struct object_id *oid,
bc5fd6d3
MH
1917 int flags, void *cb_data)
1918{
1919 struct warn_if_dangling_data *d = cb_data;
1920 const char *resolves_to;
4e675d17 1921 struct object_id junk;
bc5fd6d3
MH
1922
1923 if (!(flags & REF_ISSYMREF))
1924 return 0;
1925
4e675d17 1926 resolves_to = resolve_ref_unsafe(refname, 0, junk.hash, NULL);
e6bea66d
JL
1927 if (!resolves_to
1928 || (d->refname
1929 ? strcmp(resolves_to, d->refname)
1930 : !string_list_has_string(d->refnames, resolves_to))) {
bc5fd6d3 1931 return 0;
e6bea66d 1932 }
bc5fd6d3
MH
1933
1934 fprintf(d->fp, d->msg_fmt, refname);
1be65eda 1935 fputc('\n', d->fp);
bc5fd6d3
MH
1936 return 0;
1937}
1938
1939void warn_dangling_symref(FILE *fp, const char *msg_fmt, const char *refname)
1940{
1941 struct warn_if_dangling_data data;
1942
1943 data.fp = fp;
1944 data.refname = refname;
e6bea66d
JL
1945 data.refnames = NULL;
1946 data.msg_fmt = msg_fmt;
1947 for_each_rawref(warn_if_dangling_symref, &data);
1948}
1949
1950void warn_dangling_symrefs(FILE *fp, const char *msg_fmt, const struct string_list *refnames)
1951{
1952 struct warn_if_dangling_data data;
1953
1954 data.fp = fp;
1955 data.refname = NULL;
1956 data.refnames = refnames;
bc5fd6d3
MH
1957 data.msg_fmt = msg_fmt;
1958 for_each_rawref(warn_if_dangling_symref, &data);
1959}
1960
fcce1703 1961/*
65cf102b 1962 * Call fn for each reference in the specified ref_cache, omitting
624cac35
MH
1963 * references not in the containing_dir of base. fn is called for all
1964 * references, including broken ones. If fn ever returns a non-zero
fcce1703
MH
1965 * value, stop the iteration and return that value; otherwise, return
1966 * 0.
1967 */
65cf102b 1968static int do_for_each_entry(struct ref_cache *refs, const char *base,
624cac35 1969 each_ref_entry_fn fn, void *cb_data)
8a65ff76 1970{
98eeb09e
JK
1971 struct packed_ref_cache *packed_ref_cache;
1972 struct ref_dir *loose_dir;
1973 struct ref_dir *packed_dir;
933ac036
MH
1974 int retval = 0;
1975
98eeb09e
JK
1976 /*
1977 * We must make sure that all loose refs are read before accessing the
1978 * packed-refs file; this avoids a race condition in which loose refs
1979 * are migrated to the packed-refs file by a simultaneous process, but
1980 * our in-memory view is from before the migration. get_packed_ref_cache()
1981 * takes care of making sure our view is up to date with what is on
1982 * disk.
1983 */
1984 loose_dir = get_loose_refs(refs);
933ac036 1985 if (base && *base) {
933ac036
MH
1986 loose_dir = find_containing_dir(loose_dir, base, 0);
1987 }
98eeb09e
JK
1988 if (loose_dir)
1989 prime_ref_dir(loose_dir);
1990
1991 packed_ref_cache = get_packed_ref_cache(refs);
8baf2bb9 1992 acquire_packed_ref_cache(packed_ref_cache);
98eeb09e 1993 packed_dir = get_packed_ref_dir(packed_ref_cache);
933ac036
MH
1994 if (base && *base) {
1995 packed_dir = find_containing_dir(packed_dir, base, 0);
933ac036
MH
1996 }
1997
1998 if (packed_dir && loose_dir) {
1999 sort_ref_dir(packed_dir);
2000 sort_ref_dir(loose_dir);
624cac35
MH
2001 retval = do_for_each_entry_in_dirs(
2002 packed_dir, loose_dir, fn, cb_data);
933ac036
MH
2003 } else if (packed_dir) {
2004 sort_ref_dir(packed_dir);
624cac35
MH
2005 retval = do_for_each_entry_in_dir(
2006 packed_dir, 0, fn, cb_data);
933ac036
MH
2007 } else if (loose_dir) {
2008 sort_ref_dir(loose_dir);
624cac35
MH
2009 retval = do_for_each_entry_in_dir(
2010 loose_dir, 0, fn, cb_data);
933ac036
MH
2011 }
2012
8baf2bb9 2013 release_packed_ref_cache(packed_ref_cache);
933ac036 2014 return retval;
8a65ff76
LT
2015}
2016
624cac35 2017/*
65cf102b 2018 * Call fn for each reference in the specified ref_cache for which the
624cac35
MH
2019 * refname begins with base. If trim is non-zero, then trim that many
2020 * characters off the beginning of each refname before passing the
2021 * refname to fn. flags can be DO_FOR_EACH_INCLUDE_BROKEN to include
2022 * broken references in the iteration. If fn ever returns a non-zero
2023 * value, stop the iteration and return that value; otherwise, return
2024 * 0.
2025 */
65cf102b
MH
2026static int do_for_each_ref(struct ref_cache *refs, const char *base,
2027 each_ref_fn fn, int trim, int flags, void *cb_data)
624cac35
MH
2028{
2029 struct ref_entry_cb data;
2030 data.base = base;
2031 data.trim = trim;
2032 data.flags = flags;
2033 data.fn = fn;
2034 data.cb_data = cb_data;
2035
49672f26
JK
2036 if (ref_paranoia < 0)
2037 ref_paranoia = git_env_bool("GIT_REF_PARANOIA", 0);
2038 if (ref_paranoia)
2039 data.flags |= DO_FOR_EACH_INCLUDE_BROKEN;
2040
65cf102b 2041 return do_for_each_entry(refs, base, do_one_ref, &data);
624cac35
MH
2042}
2043
0bad611b 2044static int do_head_ref(const char *submodule, each_ref_fn fn, void *cb_data)
723c31fe 2045{
2b2a5be3 2046 struct object_id oid;
8da19775
JH
2047 int flag;
2048
0bad611b 2049 if (submodule) {
2b2a5be3
MH
2050 if (resolve_gitlink_ref(submodule, "HEAD", oid.hash) == 0)
2051 return fn("HEAD", &oid, 0, cb_data);
0bad611b
HV
2052
2053 return 0;
2054 }
2055
2b2a5be3
MH
2056 if (!read_ref_full("HEAD", RESOLVE_REF_READING, oid.hash, &flag))
2057 return fn("HEAD", &oid, flag, cb_data);
0bad611b 2058
2f34ba32 2059 return 0;
723c31fe
LT
2060}
2061
0bad611b
HV
2062int head_ref(each_ref_fn fn, void *cb_data)
2063{
2064 return do_head_ref(NULL, fn, cb_data);
2065}
2066
9ef6aeb0
HV
2067int head_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)
2068{
2069 return do_head_ref(submodule, fn, cb_data);
2070}
2071
cb5d709f 2072int for_each_ref(each_ref_fn fn, void *cb_data)
8a65ff76 2073{
9da31cb0 2074 return do_for_each_ref(&ref_cache, "", fn, 0, 0, cb_data);
a62be77f
SE
2075}
2076
9ef6aeb0
HV
2077int for_each_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)
2078{
65cf102b 2079 return do_for_each_ref(get_ref_cache(submodule), "", fn, 0, 0, cb_data);
a62be77f
SE
2080}
2081
2a8177b6
CC
2082int for_each_ref_in(const char *prefix, each_ref_fn fn, void *cb_data)
2083{
9da31cb0 2084 return do_for_each_ref(&ref_cache, prefix, fn, strlen(prefix), 0, cb_data);
2a8177b6
CC
2085}
2086
9ef6aeb0
HV
2087int for_each_ref_in_submodule(const char *submodule, const char *prefix,
2088 each_ref_fn fn, void *cb_data)
2089{
65cf102b 2090 return do_for_each_ref(get_ref_cache(submodule), prefix, fn, strlen(prefix), 0, cb_data);
2a8177b6
CC
2091}
2092
cb5d709f 2093int for_each_tag_ref(each_ref_fn fn, void *cb_data)
a62be77f 2094{
2a8177b6 2095 return for_each_ref_in("refs/tags/", fn, cb_data);
a62be77f
SE
2096}
2097
9ef6aeb0
HV
2098int for_each_tag_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)
2099{
2100 return for_each_ref_in_submodule(submodule, "refs/tags/", fn, cb_data);
2101}
2102
cb5d709f 2103int for_each_branch_ref(each_ref_fn fn, void *cb_data)
a62be77f 2104{
2a8177b6 2105 return for_each_ref_in("refs/heads/", fn, cb_data);
a62be77f
SE
2106}
2107
9ef6aeb0
HV
2108int for_each_branch_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)
2109{
2110 return for_each_ref_in_submodule(submodule, "refs/heads/", fn, cb_data);
2111}
2112
cb5d709f 2113int for_each_remote_ref(each_ref_fn fn, void *cb_data)
a62be77f 2114{
2a8177b6 2115 return for_each_ref_in("refs/remotes/", fn, cb_data);
f8948e2f
JH
2116}
2117
9ef6aeb0
HV
2118int for_each_remote_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)
2119{
2120 return for_each_ref_in_submodule(submodule, "refs/remotes/", fn, cb_data);
2121}
2122
29268700
CC
2123int for_each_replace_ref(each_ref_fn fn, void *cb_data)
2124{
9da31cb0 2125 return do_for_each_ref(&ref_cache, "refs/replace/", fn, 13, 0, cb_data);
29268700
CC
2126}
2127
a1bea2c1
JT
2128int head_ref_namespaced(each_ref_fn fn, void *cb_data)
2129{
2130 struct strbuf buf = STRBUF_INIT;
2131 int ret = 0;
2b2a5be3 2132 struct object_id oid;
a1bea2c1
JT
2133 int flag;
2134
2135 strbuf_addf(&buf, "%sHEAD", get_git_namespace());
2b2a5be3
MH
2136 if (!read_ref_full(buf.buf, RESOLVE_REF_READING, oid.hash, &flag))
2137 ret = fn(buf.buf, &oid, flag, cb_data);
a1bea2c1
JT
2138 strbuf_release(&buf);
2139
2140 return ret;
2141}
2142
2143int for_each_namespaced_ref(each_ref_fn fn, void *cb_data)
2144{
2145 struct strbuf buf = STRBUF_INIT;
2146 int ret;
2147 strbuf_addf(&buf, "%srefs/", get_git_namespace());
9da31cb0 2148 ret = do_for_each_ref(&ref_cache, buf.buf, fn, 0, 0, cb_data);
a1bea2c1
JT
2149 strbuf_release(&buf);
2150 return ret;
2151}
2152
b09fe971
IL
2153int for_each_glob_ref_in(each_ref_fn fn, const char *pattern,
2154 const char *prefix, void *cb_data)
d08bae7e
IL
2155{
2156 struct strbuf real_pattern = STRBUF_INIT;
2157 struct ref_filter filter;
d08bae7e
IL
2158 int ret;
2159
59556548 2160 if (!prefix && !starts_with(pattern, "refs/"))
d08bae7e 2161 strbuf_addstr(&real_pattern, "refs/");
b09fe971
IL
2162 else if (prefix)
2163 strbuf_addstr(&real_pattern, prefix);
d08bae7e
IL
2164 strbuf_addstr(&real_pattern, pattern);
2165
894a9d33 2166 if (!has_glob_specials(pattern)) {
9517e6b8 2167 /* Append implied '/' '*' if not present. */
d08bae7e
IL
2168 if (real_pattern.buf[real_pattern.len - 1] != '/')
2169 strbuf_addch(&real_pattern, '/');
2170 /* No need to check for '*', there is none. */
2171 strbuf_addch(&real_pattern, '*');
2172 }
2173
2174 filter.pattern = real_pattern.buf;
2175 filter.fn = fn;
2176 filter.cb_data = cb_data;
2177 ret = for_each_ref(filter_refs, &filter);
2178
2179 strbuf_release(&real_pattern);
2180 return ret;
2181}
2182
b09fe971
IL
2183int for_each_glob_ref(each_ref_fn fn, const char *pattern, void *cb_data)
2184{
2185 return for_each_glob_ref_in(fn, pattern, NULL, cb_data);
2186}
2187
f8948e2f
JH
2188int for_each_rawref(each_ref_fn fn, void *cb_data)
2189{
9da31cb0 2190 return do_for_each_ref(&ref_cache, "", fn, 0,
f8948e2f 2191 DO_FOR_EACH_INCLUDE_BROKEN, cb_data);
8a65ff76
LT
2192}
2193
4577e483 2194const char *prettify_refname(const char *name)
a9c37a72 2195{
a9c37a72 2196 return name + (
59556548
CC
2197 starts_with(name, "refs/heads/") ? 11 :
2198 starts_with(name, "refs/tags/") ? 10 :
2199 starts_with(name, "refs/remotes/") ? 13 :
a9c37a72
DB
2200 0);
2201}
2202
54457fe5 2203static const char *ref_rev_parse_rules[] = {
79803322
SP
2204 "%.*s",
2205 "refs/%.*s",
2206 "refs/tags/%.*s",
2207 "refs/heads/%.*s",
2208 "refs/remotes/%.*s",
2209 "refs/remotes/%.*s/HEAD",
2210 NULL
2211};
2212
54457fe5 2213int refname_match(const char *abbrev_name, const char *full_name)
79803322
SP
2214{
2215 const char **p;
2216 const int abbrev_name_len = strlen(abbrev_name);
2217
54457fe5 2218 for (p = ref_rev_parse_rules; *p; p++) {
79803322
SP
2219 if (!strcmp(full_name, mkpath(*p, abbrev_name_len, abbrev_name))) {
2220 return 1;
2221 }
2222 }
2223
2224 return 0;
2225}
2226
0b1e6548
RS
2227static void unlock_ref(struct ref_lock *lock)
2228{
2229 /* Do not free lock->lk -- atexit() still looks at them */
2230 if (lock->lk)
2231 rollback_lock_file(lock->lk);
2232 free(lock->ref_name);
2233 free(lock->orig_ref_name);
2234 free(lock);
2235}
2236
a5e2499e
MH
2237/*
2238 * Verify that the reference locked by lock has the value old_sha1.
2239 * Fail if the reference doesn't exist and mustexist is set. Return 0
33ffc176
MH
2240 * on success. On error, write an error message to err, set errno, and
2241 * return a negative value.
a5e2499e
MH
2242 */
2243static int verify_lock(struct ref_lock *lock,
33ffc176
MH
2244 const unsigned char *old_sha1, int mustexist,
2245 struct strbuf *err)
4bd18c43 2246{
33ffc176
MH
2247 assert(err);
2248
7695d118
RS
2249 if (read_ref_full(lock->ref_name,
2250 mustexist ? RESOLVE_REF_READING : 0,
5cb901a4 2251 lock->old_oid.hash, NULL)) {
835e3c99 2252 int save_errno = errno;
000f0da5 2253 strbuf_addf(err, "can't verify ref %s", lock->ref_name);
835e3c99 2254 errno = save_errno;
a5e2499e 2255 return -1;
4bd18c43 2256 }
5cb901a4 2257 if (hashcmp(lock->old_oid.hash, old_sha1)) {
000f0da5 2258 strbuf_addf(err, "ref %s is at %s but expected %s",
33ffc176 2259 lock->ref_name,
829f03e9 2260 sha1_to_hex(lock->old_oid.hash),
33ffc176 2261 sha1_to_hex(old_sha1));
835e3c99 2262 errno = EBUSY;
a5e2499e 2263 return -1;
4bd18c43 2264 }
a5e2499e 2265 return 0;
4bd18c43
SP
2266}
2267
7155b727 2268static int remove_empty_directories(const char *file)
bc7127ef
JH
2269{
2270 /* we want to create a file but there is a directory there;
2271 * if that is an empty directory (or a directory that contains
2272 * only empty directories), remove them.
2273 */
7155b727 2274 struct strbuf path;
470a91ef 2275 int result, save_errno;
bc7127ef 2276
7155b727
JS
2277 strbuf_init(&path, 20);
2278 strbuf_addstr(&path, file);
2279
a0f4afbe 2280 result = remove_dir_recursively(&path, REMOVE_DIR_EMPTY_ONLY);
470a91ef 2281 save_errno = errno;
7155b727
JS
2282
2283 strbuf_release(&path);
470a91ef 2284 errno = save_errno;
7155b727
JS
2285
2286 return result;
bc7127ef
JH
2287}
2288
ff74f7f1
JH
2289/*
2290 * *string and *len will only be substituted, and *string returned (for
2291 * later free()ing) if the string passed in is a magic short-hand form
2292 * to name a branch.
2293 */
2294static char *substitute_branch_name(const char **string, int *len)
2295{
2296 struct strbuf buf = STRBUF_INIT;
cf99a761 2297 int ret = interpret_branch_name(*string, *len, &buf);
ff74f7f1
JH
2298
2299 if (ret == *len) {
2300 size_t size;
2301 *string = strbuf_detach(&buf, &size);
2302 *len = size;
2303 return (char *)*string;
2304 }
2305
2306 return NULL;
2307}
2308
2309int dwim_ref(const char *str, int len, unsigned char *sha1, char **ref)
2310{
2311 char *last_branch = substitute_branch_name(&str, &len);
2312 const char **p, *r;
2313 int refs_found = 0;
2314
2315 *ref = NULL;
2316 for (p = ref_rev_parse_rules; *p; p++) {
2317 char fullref[PATH_MAX];
2318 unsigned char sha1_from_ref[20];
2319 unsigned char *this_result;
2320 int flag;
2321
2322 this_result = refs_found ? sha1_from_ref : sha1;
2323 mksnpath(fullref, sizeof(fullref), *p, len, str);
7695d118
RS
2324 r = resolve_ref_unsafe(fullref, RESOLVE_REF_READING,
2325 this_result, &flag);
ff74f7f1
JH
2326 if (r) {
2327 if (!refs_found++)
2328 *ref = xstrdup(r);
2329 if (!warn_ambiguous_refs)
2330 break;
55956350 2331 } else if ((flag & REF_ISSYMREF) && strcmp(fullref, "HEAD")) {
ff74f7f1 2332 warning("ignoring dangling symref %s.", fullref);
55956350
JH
2333 } else if ((flag & REF_ISBROKEN) && strchr(fullref, '/')) {
2334 warning("ignoring broken ref %s.", fullref);
2335 }
ff74f7f1
JH
2336 }
2337 free(last_branch);
2338 return refs_found;
2339}
2340
2341int dwim_log(const char *str, int len, unsigned char *sha1, char **log)
2342{
2343 char *last_branch = substitute_branch_name(&str, &len);
2344 const char **p;
2345 int logs_found = 0;
2346
2347 *log = NULL;
2348 for (p = ref_rev_parse_rules; *p; p++) {
ff74f7f1
JH
2349 unsigned char hash[20];
2350 char path[PATH_MAX];
2351 const char *ref, *it;
2352
2353 mksnpath(path, sizeof(path), *p, len, str);
7695d118
RS
2354 ref = resolve_ref_unsafe(path, RESOLVE_REF_READING,
2355 hash, NULL);
ff74f7f1
JH
2356 if (!ref)
2357 continue;
4da58835 2358 if (reflog_exists(path))
ff74f7f1 2359 it = path;
4da58835 2360 else if (strcmp(ref, path) && reflog_exists(ref))
ff74f7f1
JH
2361 it = ref;
2362 else
2363 continue;
2364 if (!logs_found++) {
2365 *log = xstrdup(it);
2366 hashcpy(sha1, hash);
2367 }
2368 if (!warn_ambiguous_refs)
2369 break;
2370 }
2371 free(last_branch);
2372 return logs_found;
2373}
2374
88b680ae 2375/*
3c93c847 2376 * Locks a ref returning the lock on success and NULL on failure.
88b680ae
RS
2377 * On failure errno is set to something meaningful.
2378 */
dfefa935
MH
2379static struct ref_lock *lock_ref_sha1_basic(const char *refname,
2380 const unsigned char *old_sha1,
e911104c 2381 const struct string_list *extras,
5fe7d825 2382 const struct string_list *skip,
4a32b2e0
MH
2383 unsigned int flags, int *type_p,
2384 struct strbuf *err)
4bd18c43 2385{
dcf69262 2386 const char *ref_file;
dfefa935 2387 const char *orig_refname = refname;
4bd18c43 2388 struct ref_lock *lock;
5cc3cef9 2389 int last_errno = 0;
acd3b9ec 2390 int type, lflags;
4431fcc4 2391 int mustexist = (old_sha1 && !is_null_sha1(old_sha1));
7695d118 2392 int resolve_flags = 0;
c4c61c76 2393 int attempts_remaining = 3;
4bd18c43 2394
4a32b2e0 2395 assert(err);
4bd18c43
SP
2396
2397 lock = xcalloc(1, sizeof(struct ref_lock));
4bd18c43 2398
7695d118
RS
2399 if (mustexist)
2400 resolve_flags |= RESOLVE_REF_READING;
d0f810f0
RS
2401 if (flags & REF_DELETING) {
2402 resolve_flags |= RESOLVE_REF_ALLOW_BAD_NAME;
2403 if (flags & REF_NODEREF)
2404 resolve_flags |= RESOLVE_REF_NO_RECURSE;
2405 }
7695d118
RS
2406
2407 refname = resolve_ref_unsafe(refname, resolve_flags,
5cb901a4 2408 lock->old_oid.hash, &type);
dfefa935 2409 if (!refname && errno == EISDIR) {
bc7127ef
JH
2410 /* we are trying to lock foo but we used to
2411 * have foo/bar which now does not exist;
2412 * it is normal for the empty directory 'foo'
2413 * to remain.
2414 */
dfefa935 2415 ref_file = git_path("%s", orig_refname);
5cc3cef9
JH
2416 if (remove_empty_directories(ref_file)) {
2417 last_errno = errno;
5b2d8d6f
MH
2418
2419 if (!verify_refname_available(orig_refname, extras, skip,
2420 get_loose_refs(&ref_cache), err))
2421 strbuf_addf(err, "there are still refs under '%s'",
2422 orig_refname);
2423
5cc3cef9
JH
2424 goto error_return;
2425 }
7695d118 2426 refname = resolve_ref_unsafe(orig_refname, resolve_flags,
5cb901a4 2427 lock->old_oid.hash, &type);
bc7127ef 2428 }
68db31cc
SV
2429 if (type_p)
2430 *type_p = type;
dfefa935 2431 if (!refname) {
5cc3cef9 2432 last_errno = errno;
5b2d8d6f
MH
2433 if (last_errno != ENOTDIR ||
2434 !verify_refname_available(orig_refname, extras, skip,
2435 get_loose_refs(&ref_cache), err))
2436 strbuf_addf(err, "unable to resolve reference %s: %s",
2437 orig_refname, strerror(last_errno));
2438
5cc3cef9 2439 goto error_return;
4bd18c43 2440 }
074336e5
MH
2441 /*
2442 * If the ref did not exist and we are creating it, make sure
2443 * there is no existing packed ref whose name begins with our
2444 * refname, nor a packed ref whose name is a proper prefix of
2445 * our refname.
c976d415 2446 */
5cb901a4 2447 if (is_null_oid(&lock->old_oid) &&
1146f17e 2448 verify_refname_available(refname, extras, skip,
4a32b2e0 2449 get_packed_refs(&ref_cache), err)) {
f475e08e 2450 last_errno = ENOTDIR;
c976d415 2451 goto error_return;
f475e08e 2452 }
22a3844e 2453
c33d5174 2454 lock->lk = xcalloc(1, sizeof(struct lock_file));
4bd18c43 2455
e5c223e9 2456 lflags = 0;
acd3b9ec 2457 if (flags & REF_NODEREF) {
dfefa935 2458 refname = orig_refname;
47ba4662 2459 lflags |= LOCK_NO_DEREF;
acd3b9ec 2460 }
dfefa935
MH
2461 lock->ref_name = xstrdup(refname);
2462 lock->orig_ref_name = xstrdup(orig_refname);
2463 ref_file = git_path("%s", refname);
4bd18c43 2464
c4c61c76 2465 retry:
dcf69262 2466 switch (safe_create_leading_directories_const(ref_file)) {
c4c61c76
MH
2467 case SCLD_OK:
2468 break; /* success */
2469 case SCLD_VANISHED:
2470 if (--attempts_remaining > 0)
2471 goto retry;
2472 /* fall through */
2473 default:
5cc3cef9 2474 last_errno = errno;
4a32b2e0 2475 strbuf_addf(err, "unable to create directory for %s", ref_file);
5cc3cef9
JH
2476 goto error_return;
2477 }
4bd18c43 2478
1238ac8c 2479 if (hold_lock_file_for_update(lock->lk, ref_file, lflags) < 0) {
06839515 2480 last_errno = errno;
e5c223e9
MH
2481 if (errno == ENOENT && --attempts_remaining > 0)
2482 /*
2483 * Maybe somebody just deleted one of the
2484 * directories leading to ref_file. Try
2485 * again:
2486 */
2487 goto retry;
06839515 2488 else {
4a32b2e0 2489 unable_to_lock_message(ref_file, errno, err);
06839515
RS
2490 goto error_return;
2491 }
e5c223e9 2492 }
33ffc176 2493 if (old_sha1 && verify_lock(lock, old_sha1, mustexist, err)) {
f41d6329
MH
2494 last_errno = errno;
2495 goto error_return;
2496 }
a5e2499e 2497 return lock;
5cc3cef9
JH
2498
2499 error_return:
2500 unlock_ref(lock);
2501 errno = last_errno;
2502 return NULL;
4bd18c43
SP
2503}
2504
fec3137f
MH
2505/*
2506 * Write an entry to the packed-refs file for the specified refname.
2507 * If peeled is non-NULL, write it as the entry's peeled value.
2508 */
9540ce50 2509static void write_packed_entry(FILE *fh, char *refname, unsigned char *sha1,
fec3137f 2510 unsigned char *peeled)
d66da478 2511{
9540ce50
JK
2512 fprintf_or_die(fh, "%s %s\n", sha1_to_hex(sha1), refname);
2513 if (peeled)
2514 fprintf_or_die(fh, "^%s\n", sha1_to_hex(peeled));
fec3137f
MH
2515}
2516
7b40d396
MH
2517/*
2518 * An each_ref_entry_fn that writes the entry to a packed-refs file.
2519 */
2520static int write_packed_entry_fn(struct ref_entry *entry, void *cb_data)
2521{
7b40d396
MH
2522 enum peel_status peel_status = peel_entry(entry, 0);
2523
2524 if (peel_status != PEEL_PEELED && peel_status != PEEL_NON_TAG)
2525 error("internal error: %s is not a valid packed reference!",
2526 entry->name);
8353847e 2527 write_packed_entry(cb_data, entry->name, entry->u.value.oid.hash,
7b40d396 2528 peel_status == PEEL_PEELED ?
8353847e 2529 entry->u.value.peeled.hash : NULL);
7b40d396
MH
2530 return 0;
2531}
2532
447ff1bf 2533/* This should return a meaningful errno on failure */
9f69d297
MH
2534int lock_packed_refs(int flags)
2535{
f4ab4f3a
MH
2536 static int timeout_configured = 0;
2537 static int timeout_value = 1000;
2538
9f69d297
MH
2539 struct packed_ref_cache *packed_ref_cache;
2540
f4ab4f3a
MH
2541 if (!timeout_configured) {
2542 git_config_get_int("core.packedrefstimeout", &timeout_value);
2543 timeout_configured = 1;
2544 }
2545
2546 if (hold_lock_file_for_update_timeout(
2547 &packlock, git_path("packed-refs"),
2548 flags, timeout_value) < 0)
9f69d297 2549 return -1;
5d478f5c
MH
2550 /*
2551 * Get the current packed-refs while holding the lock. If the
2552 * packed-refs file has been modified since we last read it,
2553 * this will automatically invalidate the cache and re-read
2554 * the packed-refs file.
2555 */
9f69d297
MH
2556 packed_ref_cache = get_packed_ref_cache(&ref_cache);
2557 packed_ref_cache->lock = &packlock;
4f6b83e3
MH
2558 /* Increment the reference count to prevent it from being freed: */
2559 acquire_packed_ref_cache(packed_ref_cache);
9f69d297
MH
2560 return 0;
2561}
2562
d3f66555
RS
2563/*
2564 * Commit the packed refs changes.
2565 * On error we must make sure that errno contains a meaningful value.
2566 */
9f69d297
MH
2567int commit_packed_refs(void)
2568{
2569 struct packed_ref_cache *packed_ref_cache =
2570 get_packed_ref_cache(&ref_cache);
2571 int error = 0;
d3f66555 2572 int save_errno = 0;
9540ce50 2573 FILE *out;
9f69d297
MH
2574
2575 if (!packed_ref_cache->lock)
2576 die("internal error: packed-refs not locked");
9f69d297 2577
6e578a31 2578 out = fdopen_lock_file(packed_ref_cache->lock, "w");
9540ce50
JK
2579 if (!out)
2580 die_errno("unable to fdopen packed-refs descriptor");
2581
2582 fprintf_or_die(out, "%s", PACKED_REFS_HEADER);
9f69d297 2583 do_for_each_entry_in_dir(get_packed_ref_dir(packed_ref_cache),
9540ce50 2584 0, write_packed_entry_fn, out);
9540ce50 2585
d3f66555
RS
2586 if (commit_lock_file(packed_ref_cache->lock)) {
2587 save_errno = errno;
9f69d297 2588 error = -1;
d3f66555 2589 }
9f69d297 2590 packed_ref_cache->lock = NULL;
4f6b83e3 2591 release_packed_ref_cache(packed_ref_cache);
d3f66555 2592 errno = save_errno;
9f69d297
MH
2593 return error;
2594}
2595
2596void rollback_packed_refs(void)
2597{
2598 struct packed_ref_cache *packed_ref_cache =
2599 get_packed_ref_cache(&ref_cache);
2600
2601 if (!packed_ref_cache->lock)
2602 die("internal error: packed-refs not locked");
2603 rollback_lock_file(packed_ref_cache->lock);
2604 packed_ref_cache->lock = NULL;
4f6b83e3 2605 release_packed_ref_cache(packed_ref_cache);
9f69d297
MH
2606 clear_packed_ref_cache(&ref_cache);
2607}
2608
32d462ce
MH
2609struct ref_to_prune {
2610 struct ref_to_prune *next;
2611 unsigned char sha1[20];
2612 char name[FLEX_ARRAY];
2613};
2614
2615struct pack_refs_cb_data {
2616 unsigned int flags;
267f9a8c 2617 struct ref_dir *packed_refs;
32d462ce 2618 struct ref_to_prune *ref_to_prune;
32d462ce
MH
2619};
2620
267f9a8c
MH
2621/*
2622 * An each_ref_entry_fn that is run over loose references only. If
2623 * the loose reference can be packed, add an entry in the packed ref
2624 * cache. If the reference should be pruned, also add it to
2625 * ref_to_prune in the pack_refs_cb_data.
2626 */
2627static int pack_if_possible_fn(struct ref_entry *entry, void *cb_data)
32d462ce
MH
2628{
2629 struct pack_refs_cb_data *cb = cb_data;
f85354b5 2630 enum peel_status peel_status;
267f9a8c 2631 struct ref_entry *packed_entry;
59556548 2632 int is_tag_ref = starts_with(entry->name, "refs/tags/");
32d462ce 2633
267f9a8c
MH
2634 /* ALWAYS pack tags */
2635 if (!(cb->flags & PACK_REFS_ALL) && !is_tag_ref)
32d462ce
MH
2636 return 0;
2637
b2a8226d
MH
2638 /* Do not pack symbolic or broken refs: */
2639 if ((entry->flag & REF_ISSYMREF) || !ref_resolves_to_object(entry))
2640 return 0;
2641
267f9a8c 2642 /* Add a packed ref cache entry equivalent to the loose entry. */
f85354b5 2643 peel_status = peel_entry(entry, 1);
0f29920f 2644 if (peel_status != PEEL_PEELED && peel_status != PEEL_NON_TAG)
f85354b5 2645 die("internal error peeling reference %s (%s)",
8353847e 2646 entry->name, oid_to_hex(&entry->u.value.oid));
267f9a8c
MH
2647 packed_entry = find_ref(cb->packed_refs, entry->name);
2648 if (packed_entry) {
2649 /* Overwrite existing packed entry with info from loose entry */
2650 packed_entry->flag = REF_ISPACKED | REF_KNOWS_PEELED;
8353847e 2651 oidcpy(&packed_entry->u.value.oid, &entry->u.value.oid);
267f9a8c 2652 } else {
8353847e 2653 packed_entry = create_ref_entry(entry->name, entry->u.value.oid.hash,
267f9a8c
MH
2654 REF_ISPACKED | REF_KNOWS_PEELED, 0);
2655 add_ref(cb->packed_refs, packed_entry);
2656 }
8353847e 2657 oidcpy(&packed_entry->u.value.peeled, &entry->u.value.peeled);
32d462ce 2658
267f9a8c
MH
2659 /* Schedule the loose reference for pruning if requested. */
2660 if ((cb->flags & PACK_REFS_PRUNE)) {
12e77559 2661 int namelen = strlen(entry->name) + 1;
32d462ce 2662 struct ref_to_prune *n = xcalloc(1, sizeof(*n) + namelen);
8353847e 2663 hashcpy(n->sha1, entry->u.value.oid.hash);
12e77559 2664 strcpy(n->name, entry->name);
32d462ce
MH
2665 n->next = cb->ref_to_prune;
2666 cb->ref_to_prune = n;
2667 }
d66da478
MH
2668 return 0;
2669}
2670
32d462ce
MH
2671/*
2672 * Remove empty parents, but spare refs/ and immediate subdirs.
2673 * Note: munges *name.
2674 */
2675static void try_remove_empty_parents(char *name)
2676{
2677 char *p, *q;
2678 int i;
2679 p = name;
2680 for (i = 0; i < 2; i++) { /* refs/{heads,tags,...}/ */
2681 while (*p && *p != '/')
2682 p++;
2683 /* tolerate duplicate slashes; see check_refname_format() */
2684 while (*p == '/')
2685 p++;
2686 }
2687 for (q = p; *q; q++)
2688 ;
2689 while (1) {
2690 while (q > p && *q != '/')
2691 q--;
2692 while (q > p && *(q-1) == '/')
2693 q--;
2694 if (q == p)
2695 break;
2696 *q = '\0';
2697 if (rmdir(git_path("%s", name)))
2698 break;
2699 }
2700}
2701
2702/* make sure nobody touched the ref, and unlink */
2703static void prune_ref(struct ref_to_prune *r)
2704{
029cdb4a
RS
2705 struct ref_transaction *transaction;
2706 struct strbuf err = STRBUF_INIT;
32d462ce 2707
88e7dff9 2708 if (check_refname_format(r->name, 0))
cba12021 2709 return;
32d462ce 2710
029cdb4a
RS
2711 transaction = ref_transaction_begin(&err);
2712 if (!transaction ||
2713 ref_transaction_delete(transaction, r->name, r->sha1,
fb5a6bb6 2714 REF_ISPRUNING, NULL, &err) ||
db7516ab 2715 ref_transaction_commit(transaction, &err)) {
029cdb4a
RS
2716 ref_transaction_free(transaction);
2717 error("%s", err.buf);
2718 strbuf_release(&err);
2719 return;
32d462ce 2720 }
029cdb4a
RS
2721 ref_transaction_free(transaction);
2722 strbuf_release(&err);
2723 try_remove_empty_parents(r->name);
32d462ce
MH
2724}
2725
2726static void prune_refs(struct ref_to_prune *r)
2727{
2728 while (r) {
2729 prune_ref(r);
2730 r = r->next;
2731 }
2732}
2733
32d462ce
MH
2734int pack_refs(unsigned int flags)
2735{
32d462ce
MH
2736 struct pack_refs_cb_data cbdata;
2737
2738 memset(&cbdata, 0, sizeof(cbdata));
2739 cbdata.flags = flags;
2740
9f69d297 2741 lock_packed_refs(LOCK_DIE_ON_ERROR);
267f9a8c 2742 cbdata.packed_refs = get_packed_refs(&ref_cache);
32d462ce 2743
267f9a8c
MH
2744 do_for_each_entry_in_dir(get_loose_refs(&ref_cache), 0,
2745 pack_if_possible_fn, &cbdata);
32d462ce 2746
9f69d297 2747 if (commit_packed_refs())
32d462ce 2748 die_errno("unable to overwrite old ref-pack file");
9f69d297 2749
32d462ce
MH
2750 prune_refs(cbdata.ref_to_prune);
2751 return 0;
2752}
2753
4a45b2f3 2754int repack_without_refs(struct string_list *refnames, struct strbuf *err)
c0277d15 2755{
7618fd80 2756 struct ref_dir *packed;
ea56c4e0 2757 struct string_list_item *refname;
4a45b2f3 2758 int ret, needs_repacking = 0, removed = 0;
61cee0db 2759
5a603b04
JN
2760 assert(err);
2761
61cee0db 2762 /* Look for a packed ref */
4a45b2f3
MH
2763 for_each_string_list_item(refname, refnames) {
2764 if (get_packed_ref(refname->string)) {
2765 needs_repacking = 1;
61cee0db 2766 break;
4a45b2f3
MH
2767 }
2768 }
7618fd80 2769
61cee0db 2770 /* Avoid locking if we have nothing to do */
4a45b2f3 2771 if (!needs_repacking)
61cee0db 2772 return 0; /* no refname exists in packed refs */
7618fd80 2773
9f69d297 2774 if (lock_packed_refs(0)) {
5a603b04
JN
2775 unable_to_lock_message(git_path("packed-refs"), errno, err);
2776 return -1;
1b018fd9 2777 }
9da31cb0 2778 packed = get_packed_refs(&ref_cache);
7b40d396 2779
61cee0db 2780 /* Remove refnames from the cache */
4a45b2f3
MH
2781 for_each_string_list_item(refname, refnames)
2782 if (remove_entry(packed, refname->string) != -1)
61cee0db
BK
2783 removed = 1;
2784 if (!removed) {
506a760d 2785 /*
61cee0db 2786 * All packed entries disappeared while we were
506a760d
MH
2787 * acquiring the lock.
2788 */
9f69d297 2789 rollback_packed_refs();
506a760d
MH
2790 return 0;
2791 }
7b40d396 2792
61cee0db 2793 /* Write what remains */
60bca085 2794 ret = commit_packed_refs();
5a603b04 2795 if (ret)
60bca085
RS
2796 strbuf_addf(err, "unable to overwrite old ref-pack file: %s",
2797 strerror(errno));
2798 return ret;
c0277d15
JH
2799}
2800
dbdcac7d 2801static int delete_ref_loose(struct ref_lock *lock, int flag, struct strbuf *err)
2ddb5d17 2802{
5a603b04
JN
2803 assert(err);
2804
045a476f 2805 if (!(flag & REF_ISPACKED) || flag & REF_ISSYMREF) {
91f1f191
MH
2806 /*
2807 * loose. The loose file name is the same as the
2808 * lockfile name, minus ".lock":
2809 */
ec38b4e4 2810 char *loose_filename = get_locked_file_path(lock->lk);
dbdcac7d 2811 int res = unlink_or_msg(loose_filename, err);
91f1f191 2812 free(loose_filename);
dbdcac7d 2813 if (res)
2ddb5d17 2814 return 1;
c0277d15 2815 }
2ddb5d17
BK
2816 return 0;
2817}
2818
fec14ec3 2819int delete_ref(const char *refname, const unsigned char *sha1, unsigned int flags)
c0277d15 2820{
7521cc46
RS
2821 struct ref_transaction *transaction;
2822 struct strbuf err = STRBUF_INIT;
c0277d15 2823
7521cc46
RS
2824 transaction = ref_transaction_begin(&err);
2825 if (!transaction ||
fb5a6bb6
MH
2826 ref_transaction_delete(transaction, refname,
2827 (sha1 && !is_null_sha1(sha1)) ? sha1 : NULL,
2828 flags, NULL, &err) ||
db7516ab 2829 ref_transaction_commit(transaction, &err)) {
7521cc46
RS
2830 error("%s", err.buf);
2831 ref_transaction_free(transaction);
2832 strbuf_release(&err);
c0277d15 2833 return 1;
7521cc46
RS
2834 }
2835 ref_transaction_free(transaction);
2836 strbuf_release(&err);
2837 return 0;
4bd18c43
SP
2838}
2839
765c2258
PH
2840/*
2841 * People using contrib's git-new-workdir have .git/logs/refs ->
2842 * /some/other/path/.git/logs/refs, and that may live on another device.
2843 *
2844 * IOW, to avoid cross device rename errors, the temporary renamed log must
2845 * live into logs/refs.
2846 */
2847#define TMP_RENAMED_LOG "logs/refs/.tmp-renamed-log"
2848
fa59ae79
MH
2849static int rename_tmp_log(const char *newrefname)
2850{
f1e9e9a4 2851 int attempts_remaining = 4;
ae4a283e
MH
2852
2853 retry:
dcf69262 2854 switch (safe_create_leading_directories_const(git_path("logs/%s", newrefname))) {
08f555cb
MH
2855 case SCLD_OK:
2856 break; /* success */
2857 case SCLD_VANISHED:
2858 if (--attempts_remaining > 0)
2859 goto retry;
2860 /* fall through */
2861 default:
fa59ae79
MH
2862 error("unable to create directory for %s", newrefname);
2863 return -1;
2864 }
2865
fa59ae79 2866 if (rename(git_path(TMP_RENAMED_LOG), git_path("logs/%s", newrefname))) {
f1e9e9a4 2867 if ((errno==EISDIR || errno==ENOTDIR) && --attempts_remaining > 0) {
fa59ae79
MH
2868 /*
2869 * rename(a, b) when b is an existing
2870 * directory ought to result in ISDIR, but
2871 * Solaris 5.8 gives ENOTDIR. Sheesh.
2872 */
2873 if (remove_empty_directories(git_path("logs/%s", newrefname))) {
2874 error("Directory not empty: logs/%s", newrefname);
2875 return -1;
2876 }
2877 goto retry;
ae4a283e
MH
2878 } else if (errno == ENOENT && --attempts_remaining > 0) {
2879 /*
2880 * Maybe another process just deleted one of
2881 * the directories in the path to newrefname.
2882 * Try again from the beginning.
2883 */
2884 goto retry;
fa59ae79
MH
2885 } else {
2886 error("unable to move logfile "TMP_RENAMED_LOG" to logs/%s: %s",
2887 newrefname, strerror(errno));
2888 return -1;
2889 }
2890 }
2891 return 0;
2892}
2893
5fe7d825
RS
2894static int rename_ref_available(const char *oldname, const char *newname)
2895{
2896 struct string_list skip = STRING_LIST_INIT_NODUP;
1146f17e 2897 struct strbuf err = STRBUF_INIT;
5fe7d825
RS
2898 int ret;
2899
2900 string_list_insert(&skip, oldname);
5baf37d3 2901 ret = !verify_refname_available(newname, NULL, &skip,
1146f17e 2902 get_packed_refs(&ref_cache), &err)
5baf37d3 2903 && !verify_refname_available(newname, NULL, &skip,
1146f17e
MH
2904 get_loose_refs(&ref_cache), &err);
2905 if (!ret)
2906 error("%s", err.buf);
2907
5fe7d825 2908 string_list_clear(&skip, 0);
1146f17e 2909 strbuf_release(&err);
5fe7d825
RS
2910 return ret;
2911}
2912
ba43b7f2
MH
2913static int write_ref_to_lockfile(struct ref_lock *lock, const unsigned char *sha1);
2914static int commit_ref_update(struct ref_lock *lock,
2915 const unsigned char *sha1, const char *logmsg);
aae383db 2916
dfefa935 2917int rename_ref(const char *oldrefname, const char *newrefname, const char *logmsg)
c976d415 2918{
c976d415
LH
2919 unsigned char sha1[20], orig_sha1[20];
2920 int flag = 0, logmoved = 0;
2921 struct ref_lock *lock;
c976d415 2922 struct stat loginfo;
dfefa935 2923 int log = !lstat(git_path("logs/%s", oldrefname), &loginfo);
eca35a25 2924 const char *symref = NULL;
4a32b2e0 2925 struct strbuf err = STRBUF_INIT;
c976d415 2926
450d4c0f 2927 if (log && S_ISLNK(loginfo.st_mode))
dfefa935 2928 return error("reflog for %s is a symlink", oldrefname);
c976d415 2929
7695d118
RS
2930 symref = resolve_ref_unsafe(oldrefname, RESOLVE_REF_READING,
2931 orig_sha1, &flag);
eca35a25 2932 if (flag & REF_ISSYMREF)
fa58186c 2933 return error("refname %s is a symbolic ref, renaming it is not supported",
dfefa935 2934 oldrefname);
eca35a25 2935 if (!symref)
dfefa935 2936 return error("refname %s not found", oldrefname);
c976d415 2937
5fe7d825 2938 if (!rename_ref_available(oldrefname, newrefname))
c976d415
LH
2939 return 1;
2940
dfefa935 2941 if (log && rename(git_path("logs/%s", oldrefname), git_path(TMP_RENAMED_LOG)))
765c2258 2942 return error("unable to move logfile logs/%s to "TMP_RENAMED_LOG": %s",
dfefa935 2943 oldrefname, strerror(errno));
c976d415 2944
dfefa935
MH
2945 if (delete_ref(oldrefname, orig_sha1, REF_NODEREF)) {
2946 error("unable to delete old %s", oldrefname);
c976d415
LH
2947 goto rollback;
2948 }
2949
7695d118 2950 if (!read_ref_full(newrefname, RESOLVE_REF_READING, sha1, NULL) &&
dfefa935 2951 delete_ref(newrefname, sha1, REF_NODEREF)) {
c976d415 2952 if (errno==EISDIR) {
dfefa935
MH
2953 if (remove_empty_directories(git_path("%s", newrefname))) {
2954 error("Directory not empty: %s", newrefname);
c976d415
LH
2955 goto rollback;
2956 }
2957 } else {
dfefa935 2958 error("unable to delete existing %s", newrefname);
c976d415
LH
2959 goto rollback;
2960 }
2961 }
2962
fa59ae79 2963 if (log && rename_tmp_log(newrefname))
c976d415 2964 goto rollback;
c976d415 2965
c976d415
LH
2966 logmoved = log;
2967
4a32b2e0 2968 lock = lock_ref_sha1_basic(newrefname, NULL, NULL, NULL, 0, NULL, &err);
c976d415 2969 if (!lock) {
abeef9c8 2970 error("unable to rename '%s' to '%s': %s", oldrefname, newrefname, err.buf);
4a32b2e0 2971 strbuf_release(&err);
c976d415
LH
2972 goto rollback;
2973 }
5cb901a4 2974 hashcpy(lock->old_oid.hash, orig_sha1);
ba43b7f2
MH
2975
2976 if (write_ref_to_lockfile(lock, orig_sha1) ||
2977 commit_ref_update(lock, orig_sha1, logmsg)) {
dfefa935 2978 error("unable to write current sha1 into %s", newrefname);
c976d415
LH
2979 goto rollback;
2980 }
2981
2982 return 0;
2983
2984 rollback:
4a32b2e0 2985 lock = lock_ref_sha1_basic(oldrefname, NULL, NULL, NULL, 0, NULL, &err);
c976d415 2986 if (!lock) {
abeef9c8 2987 error("unable to lock %s for rollback: %s", oldrefname, err.buf);
4a32b2e0 2988 strbuf_release(&err);
c976d415
LH
2989 goto rollbacklog;
2990 }
2991
c976d415
LH
2992 flag = log_all_ref_updates;
2993 log_all_ref_updates = 0;
ba43b7f2
MH
2994 if (write_ref_to_lockfile(lock, orig_sha1) ||
2995 commit_ref_update(lock, orig_sha1, NULL))
dfefa935 2996 error("unable to write current sha1 into %s", oldrefname);
c976d415
LH
2997 log_all_ref_updates = flag;
2998
2999 rollbacklog:
dfefa935 3000 if (logmoved && rename(git_path("logs/%s", newrefname), git_path("logs/%s", oldrefname)))
c976d415 3001 error("unable to restore logfile %s from %s: %s",
dfefa935 3002 oldrefname, newrefname, strerror(errno));
c976d415 3003 if (!logmoved && log &&
dfefa935 3004 rename(git_path(TMP_RENAMED_LOG), git_path("logs/%s", oldrefname)))
765c2258 3005 error("unable to restore logfile %s from "TMP_RENAMED_LOG": %s",
dfefa935 3006 oldrefname, strerror(errno));
c976d415
LH
3007
3008 return 1;
3009}
3010
0b1e6548 3011static int close_ref(struct ref_lock *lock)
b531394d
BC
3012{
3013 if (close_lock_file(lock->lk))
3014 return -1;
b531394d
BC
3015 return 0;
3016}
3017
0b1e6548 3018static int commit_ref(struct ref_lock *lock)
b531394d
BC
3019{
3020 if (commit_lock_file(lock->lk))
3021 return -1;
b531394d
BC
3022 return 0;
3023}
3024
0ec29a47
JH
3025/*
3026 * copy the reflog message msg to buf, which has been allocated sufficiently
3027 * large, while cleaning up the whitespaces. Especially, convert LF to space,
3028 * because reflog file is one line per entry.
3029 */
3030static int copy_msg(char *buf, const char *msg)
3031{
3032 char *cp = buf;
3033 char c;
3034 int wasspace = 1;
3035
3036 *cp++ = '\t';
3037 while ((c = *msg++)) {
3038 if (wasspace && isspace(c))
3039 continue;
3040 wasspace = isspace(c);
3041 if (wasspace)
3042 c = ' ';
3043 *cp++ = c;
3044 }
3045 while (buf < cp && isspace(cp[-1]))
3046 cp--;
3047 *cp++ = '\n';
3048 return cp - buf;
3049}
3050
bd3b02da 3051/* This function must set a meaningful errno on failure */
1a83c240 3052int log_ref_setup(const char *refname, struct strbuf *sb_logfile)
6de08ae6 3053{
859c3017 3054 int logfd, oflags = O_APPEND | O_WRONLY;
1a83c240 3055 char *logfile;
9a13f0b7 3056
1a83c240
NTND
3057 strbuf_git_path(sb_logfile, "logs/%s", refname);
3058 logfile = sb_logfile->buf;
3059 /* make sure the rest of the function can't change "logfile" */
3060 sb_logfile = NULL;
4057deb5 3061 if (log_all_ref_updates &&
59556548
CC
3062 (starts_with(refname, "refs/heads/") ||
3063 starts_with(refname, "refs/remotes/") ||
3064 starts_with(refname, "refs/notes/") ||
dfefa935 3065 !strcmp(refname, "HEAD"))) {
bd3b02da
RS
3066 if (safe_create_leading_directories(logfile) < 0) {
3067 int save_errno = errno;
3068 error("unable to create directory for %s", logfile);
3069 errno = save_errno;
3070 return -1;
3071 }
6de08ae6
SP
3072 oflags |= O_CREAT;
3073 }
3074
157aaea5 3075 logfd = open(logfile, oflags, 0666);
6de08ae6 3076 if (logfd < 0) {
9233887c 3077 if (!(oflags & O_CREAT) && (errno == ENOENT || errno == EISDIR))
6de08ae6 3078 return 0;
3b463c3f 3079
9233887c 3080 if (errno == EISDIR) {
157aaea5 3081 if (remove_empty_directories(logfile)) {
bd3b02da
RS
3082 int save_errno = errno;
3083 error("There are still logs under '%s'",
3084 logfile);
3085 errno = save_errno;
3086 return -1;
3b463c3f 3087 }
157aaea5 3088 logfd = open(logfile, oflags, 0666);
3b463c3f
JH
3089 }
3090
bd3b02da
RS
3091 if (logfd < 0) {
3092 int save_errno = errno;
3093 error("Unable to append to %s: %s", logfile,
3094 strerror(errno));
3095 errno = save_errno;
3096 return -1;
3097 }
6de08ae6
SP
3098 }
3099
157aaea5 3100 adjust_shared_perm(logfile);
859c3017
EM
3101 close(logfd);
3102 return 0;
3103}
443b92b6 3104
2c6207ab
RS
3105static int log_ref_write_fd(int fd, const unsigned char *old_sha1,
3106 const unsigned char *new_sha1,
3107 const char *committer, const char *msg)
3108{
3109 int msglen, written;
3110 unsigned maxlen, len;
3111 char *logrec;
3112
3113 msglen = msg ? strlen(msg) : 0;
3114 maxlen = strlen(committer) + msglen + 100;
3115 logrec = xmalloc(maxlen);
3116 len = sprintf(logrec, "%s %s %s\n",
3117 sha1_to_hex(old_sha1),
3118 sha1_to_hex(new_sha1),
3119 committer);
3120 if (msglen)
3121 len += copy_msg(logrec + len - 1, msg) - 1;
3122
3123 written = len <= maxlen ? write_in_full(fd, logrec, len) : -1;
3124 free(logrec);
3125 if (written != len)
3126 return -1;
3127
3128 return 0;
3129}
3130
1a83c240
NTND
3131static int log_ref_write_1(const char *refname, const unsigned char *old_sha1,
3132 const unsigned char *new_sha1, const char *msg,
3133 struct strbuf *sb_log_file)
859c3017 3134{
2c6207ab 3135 int logfd, result, oflags = O_APPEND | O_WRONLY;
68a2e6a2 3136 char *log_file;
859c3017
EM
3137
3138 if (log_all_ref_updates < 0)
3139 log_all_ref_updates = !is_bare_repository();
3140
1a83c240 3141 result = log_ref_setup(refname, sb_log_file);
859c3017
EM
3142 if (result)
3143 return result;
1a83c240
NTND
3144 log_file = sb_log_file->buf;
3145 /* make sure the rest of the function can't change "log_file" */
3146 sb_log_file = NULL;
859c3017
EM
3147
3148 logfd = open(log_file, oflags);
3149 if (logfd < 0)
3150 return 0;
2c6207ab
RS
3151 result = log_ref_write_fd(logfd, old_sha1, new_sha1,
3152 git_committer_info(0), msg);
3153 if (result) {
dc615de8
RS
3154 int save_errno = errno;
3155 close(logfd);
3156 error("Unable to append to %s", log_file);
3157 errno = save_errno;
3158 return -1;
3159 }
3160 if (close(logfd)) {
3161 int save_errno = errno;
3162 error("Unable to append to %s", log_file);
3163 errno = save_errno;
3164 return -1;
3165 }
6de08ae6
SP
3166 return 0;
3167}
3168
1a83c240
NTND
3169static int log_ref_write(const char *refname, const unsigned char *old_sha1,
3170 const unsigned char *new_sha1, const char *msg)
3171{
3172 struct strbuf sb = STRBUF_INIT;
3173 int ret = log_ref_write_1(refname, old_sha1, new_sha1, msg, &sb);
3174 strbuf_release(&sb);
3175 return ret;
3176}
3177
e7e0f26e 3178int is_branch(const char *refname)
c3b0dec5 3179{
59556548 3180 return !strcmp(refname, "HEAD") || starts_with(refname, "refs/heads/");
c3b0dec5
LT
3181}
3182
aae383db 3183/*
e6fd3c67
MH
3184 * Write sha1 into the open lockfile, then close the lockfile. On
3185 * errors, rollback the lockfile and set errno to reflect the problem.
aae383db 3186 */
e6fd3c67
MH
3187static int write_ref_to_lockfile(struct ref_lock *lock,
3188 const unsigned char *sha1)
4bd18c43
SP
3189{
3190 static char term = '\n';
c3b0dec5 3191 struct object *o;
4bd18c43 3192
c3b0dec5
LT
3193 o = parse_object(sha1);
3194 if (!o) {
7be8b3ba 3195 error("Trying to write ref %s with nonexistent object %s",
c3b0dec5
LT
3196 lock->ref_name, sha1_to_hex(sha1));
3197 unlock_ref(lock);
dc615de8 3198 errno = EINVAL;
c3b0dec5
LT
3199 return -1;
3200 }
3201 if (o->type != OBJ_COMMIT && is_branch(lock->ref_name)) {
3202 error("Trying to write non-commit object %s to branch %s",
3203 sha1_to_hex(sha1), lock->ref_name);
3204 unlock_ref(lock);
dc615de8 3205 errno = EINVAL;
c3b0dec5
LT
3206 return -1;
3207 }
1238ac8c
SB
3208 if (write_in_full(lock->lk->fd, sha1_to_hex(sha1), 40) != 40 ||
3209 write_in_full(lock->lk->fd, &term, 1) != 1 ||
dc615de8
RS
3210 close_ref(lock) < 0) {
3211 int save_errno = errno;
cf6950d3 3212 error("Couldn't write %s", lock->lk->filename.buf);
4bd18c43 3213 unlock_ref(lock);
dc615de8 3214 errno = save_errno;
4bd18c43
SP
3215 return -1;
3216 }
e6fd3c67
MH
3217 return 0;
3218}
3219
3220/*
ad4cd6c2
MH
3221 * Commit a change to a loose reference that has already been written
3222 * to the loose reference lockfile. Also update the reflogs if
3223 * necessary, using the specified lockmsg (which can be NULL).
e6fd3c67 3224 */
ad4cd6c2
MH
3225static int commit_ref_update(struct ref_lock *lock,
3226 const unsigned char *sha1, const char *logmsg)
e6fd3c67 3227{
9da31cb0 3228 clear_loose_ref_cache(&ref_cache);
5cb901a4 3229 if (log_ref_write(lock->ref_name, lock->old_oid.hash, sha1, logmsg) < 0 ||
bd104db1 3230 (strcmp(lock->ref_name, lock->orig_ref_name) &&
5cb901a4 3231 log_ref_write(lock->orig_ref_name, lock->old_oid.hash, sha1, logmsg) < 0)) {
6de08ae6
SP
3232 unlock_ref(lock);
3233 return -1;
3234 }
605fac8b
NP
3235 if (strcmp(lock->orig_ref_name, "HEAD") != 0) {
3236 /*
3237 * Special hack: If a branch is updated directly and HEAD
3238 * points to it (may happen on the remote side of a push
3239 * for example) then logically the HEAD reflog should be
3240 * updated too.
3241 * A generic solution implies reverse symref information,
3242 * but finding all symrefs pointing to the given branch
3243 * would be rather costly for this rare event (the direct
3244 * update of a branch) to be worth it. So let's cheat and
3245 * check with HEAD only which should cover 99% of all usage
3246 * scenarios (even 100% of the default ones).
3247 */
3248 unsigned char head_sha1[20];
3249 int head_flag;
3250 const char *head_ref;
7695d118
RS
3251 head_ref = resolve_ref_unsafe("HEAD", RESOLVE_REF_READING,
3252 head_sha1, &head_flag);
605fac8b
NP
3253 if (head_ref && (head_flag & REF_ISSYMREF) &&
3254 !strcmp(head_ref, lock->ref_name))
5cb901a4 3255 log_ref_write("HEAD", lock->old_oid.hash, sha1, logmsg);
605fac8b 3256 }
b531394d 3257 if (commit_ref(lock)) {
434cd0cd 3258 error("Couldn't set %s", lock->ref_name);
4bd18c43
SP
3259 unlock_ref(lock);
3260 return -1;
3261 }
4bd18c43
SP
3262 unlock_ref(lock);
3263 return 0;
95fc7512 3264}
d556fae2 3265
8b5157e4
NP
3266int create_symref(const char *ref_target, const char *refs_heads_master,
3267 const char *logmsg)
41b625b0
NP
3268{
3269 const char *lockpath;
3270 char ref[1000];
3271 int fd, len, written;
a4f34cbb 3272 char *git_HEAD = git_pathdup("%s", ref_target);
8b5157e4
NP
3273 unsigned char old_sha1[20], new_sha1[20];
3274
3275 if (logmsg && read_ref(ref_target, old_sha1))
3276 hashclr(old_sha1);
41b625b0 3277
d48744d1
JH
3278 if (safe_create_leading_directories(git_HEAD) < 0)
3279 return error("unable to create directory for %s", git_HEAD);
3280
41b625b0
NP
3281#ifndef NO_SYMLINK_HEAD
3282 if (prefer_symlink_refs) {
3283 unlink(git_HEAD);
3284 if (!symlink(refs_heads_master, git_HEAD))
8b5157e4 3285 goto done;
41b625b0
NP
3286 fprintf(stderr, "no symlink - falling back to symbolic ref\n");
3287 }
3288#endif
3289
3290 len = snprintf(ref, sizeof(ref), "ref: %s\n", refs_heads_master);
3291 if (sizeof(ref) <= len) {
3292 error("refname too long: %s", refs_heads_master);
47fc52e2 3293 goto error_free_return;
41b625b0
NP
3294 }
3295 lockpath = mkpath("%s.lock", git_HEAD);
3296 fd = open(lockpath, O_CREAT | O_EXCL | O_WRONLY, 0666);
3297 if (fd < 0) {
3298 error("Unable to open %s for writing", lockpath);
47fc52e2 3299 goto error_free_return;
41b625b0
NP
3300 }
3301 written = write_in_full(fd, ref, len);
91c8d590 3302 if (close(fd) != 0 || written != len) {
41b625b0 3303 error("Unable to write to %s", lockpath);
47fc52e2 3304 goto error_unlink_return;
41b625b0
NP
3305 }
3306 if (rename(lockpath, git_HEAD) < 0) {
41b625b0 3307 error("Unable to create %s", git_HEAD);
47fc52e2 3308 goto error_unlink_return;
41b625b0
NP
3309 }
3310 if (adjust_shared_perm(git_HEAD)) {
41b625b0 3311 error("Unable to fix permissions on %s", lockpath);
47fc52e2 3312 error_unlink_return:
691f1a28 3313 unlink_or_warn(lockpath);
47fc52e2
JH
3314 error_free_return:
3315 free(git_HEAD);
3316 return -1;
41b625b0 3317 }
8b5157e4 3318
ee96d11b 3319#ifndef NO_SYMLINK_HEAD
8b5157e4 3320 done:
ee96d11b 3321#endif
8b5157e4
NP
3322 if (logmsg && !read_ref(refs_heads_master, new_sha1))
3323 log_ref_write(ref_target, old_sha1, new_sha1, logmsg);
3324
47fc52e2 3325 free(git_HEAD);
41b625b0
NP
3326 return 0;
3327}
3328
4207ed28
RS
3329struct read_ref_at_cb {
3330 const char *refname;
3331 unsigned long at_time;
3332 int cnt;
3333 int reccnt;
3334 unsigned char *sha1;
3335 int found_it;
3336
3337 unsigned char osha1[20];
3338 unsigned char nsha1[20];
3339 int tz;
3340 unsigned long date;
3341 char **msg;
3342 unsigned long *cutoff_time;
3343 int *cutoff_tz;
3344 int *cutoff_cnt;
3345};
3346
3347static int read_ref_at_ent(unsigned char *osha1, unsigned char *nsha1,
3348 const char *email, unsigned long timestamp, int tz,
3349 const char *message, void *cb_data)
3350{
3351 struct read_ref_at_cb *cb = cb_data;
3352
3353 cb->reccnt++;
3354 cb->tz = tz;
3355 cb->date = timestamp;
3356
3357 if (timestamp <= cb->at_time || cb->cnt == 0) {
3358 if (cb->msg)
3359 *cb->msg = xstrdup(message);
3360 if (cb->cutoff_time)
3361 *cb->cutoff_time = timestamp;
3362 if (cb->cutoff_tz)
3363 *cb->cutoff_tz = tz;
3364 if (cb->cutoff_cnt)
3365 *cb->cutoff_cnt = cb->reccnt - 1;
3366 /*
3367 * we have not yet updated cb->[n|o]sha1 so they still
3368 * hold the values for the previous record.
3369 */
3370 if (!is_null_sha1(cb->osha1)) {
3371 hashcpy(cb->sha1, nsha1);
3372 if (hashcmp(cb->osha1, nsha1))
3373 warning("Log for ref %s has gap after %s.",
3374 cb->refname, show_date(cb->date, cb->tz, DATE_RFC2822));
3375 }
3376 else if (cb->date == cb->at_time)
3377 hashcpy(cb->sha1, nsha1);
3378 else if (hashcmp(nsha1, cb->sha1))
3379 warning("Log for ref %s unexpectedly ended on %s.",
3380 cb->refname, show_date(cb->date, cb->tz,
3381 DATE_RFC2822));
3382 hashcpy(cb->osha1, osha1);
3383 hashcpy(cb->nsha1, nsha1);
3384 cb->found_it = 1;
3385 return 1;
3386 }
3387 hashcpy(cb->osha1, osha1);
3388 hashcpy(cb->nsha1, nsha1);
3389 if (cb->cnt > 0)
3390 cb->cnt--;
3391 return 0;
3392}
3393
3394static int read_ref_at_ent_oldest(unsigned char *osha1, unsigned char *nsha1,
3395 const char *email, unsigned long timestamp,
3396 int tz, const char *message, void *cb_data)
3397{
3398 struct read_ref_at_cb *cb = cb_data;
3399
3400 if (cb->msg)
3401 *cb->msg = xstrdup(message);
3402 if (cb->cutoff_time)
3403 *cb->cutoff_time = timestamp;
3404 if (cb->cutoff_tz)
3405 *cb->cutoff_tz = tz;
3406 if (cb->cutoff_cnt)
3407 *cb->cutoff_cnt = cb->reccnt;
3408 hashcpy(cb->sha1, osha1);
3409 if (is_null_sha1(cb->sha1))
3410 hashcpy(cb->sha1, nsha1);
3411 /* We just want the first entry */
3412 return 1;
16d7cc90
JH
3413}
3414
c41a87dd 3415int read_ref_at(const char *refname, unsigned int flags, unsigned long at_time, int cnt,
dfefa935
MH
3416 unsigned char *sha1, char **msg,
3417 unsigned long *cutoff_time, int *cutoff_tz, int *cutoff_cnt)
d556fae2 3418{
4207ed28 3419 struct read_ref_at_cb cb;
d556fae2 3420
4207ed28
RS
3421 memset(&cb, 0, sizeof(cb));
3422 cb.refname = refname;
3423 cb.at_time = at_time;
3424 cb.cnt = cnt;
3425 cb.msg = msg;
3426 cb.cutoff_time = cutoff_time;
3427 cb.cutoff_tz = cutoff_tz;
3428 cb.cutoff_cnt = cutoff_cnt;
3429 cb.sha1 = sha1;
3430
3431 for_each_reflog_ent_reverse(refname, read_ref_at_ent, &cb);
3432
c41a87dd
DA
3433 if (!cb.reccnt) {
3434 if (flags & GET_SHA1_QUIETLY)
3435 exit(128);
3436 else
3437 die("Log for %s is empty.", refname);
3438 }
4207ed28
RS
3439 if (cb.found_it)
3440 return 0;
3441
3442 for_each_reflog_ent(refname, read_ref_at_ent_oldest, &cb);
d556fae2 3443
16d7cc90 3444 return 1;
d556fae2 3445}
2ff81662 3446
4da58835
RS
3447int reflog_exists(const char *refname)
3448{
3449 struct stat st;
3450
3451 return !lstat(git_path("logs/%s", refname), &st) &&
3452 S_ISREG(st.st_mode);
3453}
3454
3455int delete_reflog(const char *refname)
3456{
3457 return remove_path(git_path("logs/%s", refname));
3458}
3459
9a7a183b
JH
3460static int show_one_reflog_ent(struct strbuf *sb, each_reflog_ent_fn fn, void *cb_data)
3461{
3462 unsigned char osha1[20], nsha1[20];
3463 char *email_end, *message;
3464 unsigned long timestamp;
3465 int tz;
3466
3467 /* old SP new SP name <email> SP time TAB msg LF */
3468 if (sb->len < 83 || sb->buf[sb->len - 1] != '\n' ||
3469 get_sha1_hex(sb->buf, osha1) || sb->buf[40] != ' ' ||
3470 get_sha1_hex(sb->buf + 41, nsha1) || sb->buf[81] != ' ' ||
3471 !(email_end = strchr(sb->buf + 82, '>')) ||
3472 email_end[1] != ' ' ||
3473 !(timestamp = strtoul(email_end + 2, &message, 10)) ||
3474 !message || message[0] != ' ' ||
3475 (message[1] != '+' && message[1] != '-') ||
3476 !isdigit(message[2]) || !isdigit(message[3]) ||
3477 !isdigit(message[4]) || !isdigit(message[5]))
3478 return 0; /* corrupt? */
3479 email_end[1] = '\0';
3480 tz = strtol(message + 1, NULL, 10);
3481 if (message[6] != '\t')
3482 message += 6;
3483 else
3484 message += 7;
3485 return fn(osha1, nsha1, sb->buf + 82, timestamp, tz, message, cb_data);
3486}
3487
98f85ff4
JH
3488static char *find_beginning_of_line(char *bob, char *scan)
3489{
3490 while (bob < scan && *(--scan) != '\n')
3491 ; /* keep scanning backwards */
3492 /*
3493 * Return either beginning of the buffer, or LF at the end of
3494 * the previous line.
3495 */
3496 return scan;
3497}
3498
3499int for_each_reflog_ent_reverse(const char *refname, each_reflog_ent_fn fn, void *cb_data)
2ff81662 3500{
8ca78803 3501 struct strbuf sb = STRBUF_INIT;
98f85ff4
JH
3502 FILE *logfp;
3503 long pos;
3504 int ret = 0, at_tail = 1;
2ff81662 3505
7ae07c1b 3506 logfp = fopen(git_path("logs/%s", refname), "r");
2ff81662 3507 if (!logfp)
883d60fa 3508 return -1;
101d15e0 3509
98f85ff4
JH
3510 /* Jump to the end */
3511 if (fseek(logfp, 0, SEEK_END) < 0)
3512 return error("cannot seek back reflog for %s: %s",
3513 refname, strerror(errno));
3514 pos = ftell(logfp);
3515 while (!ret && 0 < pos) {
3516 int cnt;
3517 size_t nread;
3518 char buf[BUFSIZ];
3519 char *endp, *scanp;
3520
3521 /* Fill next block from the end */
3522 cnt = (sizeof(buf) < pos) ? sizeof(buf) : pos;
3523 if (fseek(logfp, pos - cnt, SEEK_SET))
3524 return error("cannot seek back reflog for %s: %s",
3525 refname, strerror(errno));
3526 nread = fread(buf, cnt, 1, logfp);
e4ca819a 3527 if (nread != 1)
98f85ff4
JH
3528 return error("cannot read %d bytes from reflog for %s: %s",
3529 cnt, refname, strerror(errno));
3530 pos -= cnt;
3531
3532 scanp = endp = buf + cnt;
3533 if (at_tail && scanp[-1] == '\n')
3534 /* Looking at the final LF at the end of the file */
3535 scanp--;
3536 at_tail = 0;
3537
3538 while (buf < scanp) {
3539 /*
3540 * terminating LF of the previous line, or the beginning
3541 * of the buffer.
3542 */
3543 char *bp;
3544
3545 bp = find_beginning_of_line(buf, scanp);
3546
e5e73ff2 3547 if (*bp == '\n') {
98f85ff4 3548 /*
e5e73ff2
JK
3549 * The newline is the end of the previous line,