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