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