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