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