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