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