]> git.proxmox.com Git - libgit2.git/blob - src/repository.c
projects / libgit2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
New upstream version 1.1.0+dfsg.1
[libgit2.git] / src / repository.c
1 /*
2 * Copyright (C) the libgit2 contributors. All rights reserved.
3 *
4 * This file is part of libgit2, distributed under the GNU GPL v2 with
5 * a Linking Exception. For full terms see the included COPYING file.
6 */
7
8 #include "repository.h"
9
10 #include <ctype.h>
11
12 #include "git2/object.h"
13 #include "git2/sys/repository.h"
14
15 #include "common.h"
16 #include "commit.h"
17 #include "tag.h"
18 #include "blob.h"
19 #include "futils.h"
20 #include "sysdir.h"
21 #include "filebuf.h"
22 #include "index.h"
23 #include "config.h"
24 #include "refs.h"
25 #include "filter.h"
26 #include "odb.h"
27 #include "refdb.h"
28 #include "remote.h"
29 #include "merge.h"
30 #include "diff_driver.h"
31 #include "annotated_commit.h"
32 #include "submodule.h"
33 #include "worktree.h"
34
35 #include "strmap.h"
36
37 #ifdef GIT_WIN32
38 # include "win32/w32_util.h"
39 #endif
40
41 bool git_repository__fsync_gitdir = false;
42
43 static const struct {
44 git_repository_item_t parent;
45 git_repository_item_t fallback;
46 const char *name;
47 bool directory;
48 } items[] = {
49 { GIT_REPOSITORY_ITEM_GITDIR, GIT_REPOSITORY_ITEM__LAST, NULL, true },
50 { GIT_REPOSITORY_ITEM_WORKDIR, GIT_REPOSITORY_ITEM__LAST, NULL, true },
51 { GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM__LAST, NULL, true },
52 { GIT_REPOSITORY_ITEM_GITDIR, GIT_REPOSITORY_ITEM__LAST, "index", false },
53 { GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM_GITDIR, "objects", true },
54 { GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM_GITDIR, "refs", true },
55 { GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM_GITDIR, "packed-refs", false },
56 { GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM_GITDIR, "remotes", true },
57 { GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM_GITDIR, "config", false },
58 { GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM_GITDIR, "info", true },
59 { GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM_GITDIR, "hooks", true },
60 { GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM_GITDIR, "logs", true },
61 { GIT_REPOSITORY_ITEM_GITDIR, GIT_REPOSITORY_ITEM__LAST, "modules", true },
62 { GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM_GITDIR, "worktrees", true }
63 };
64
65 static int check_repositoryformatversion(int *version, git_config *config);
66 static int check_extensions(git_config *config, int version);
67
68 #define GIT_COMMONDIR_FILE "commondir"
69 #define GIT_GITDIR_FILE "gitdir"
70
71 #define GIT_FILE_CONTENT_PREFIX "gitdir:"
72
73 #define GIT_BRANCH_DEFAULT "master"
74
75 #define GIT_REPO_VERSION 0
76 #define GIT_REPO_MAX_VERSION 1
77
78 git_buf git_repository__reserved_names_win32[] = {
79 { DOT_GIT, 0, CONST_STRLEN(DOT_GIT) },
80 { GIT_DIR_SHORTNAME, 0, CONST_STRLEN(GIT_DIR_SHORTNAME) }
81 };
82 size_t git_repository__reserved_names_win32_len = 2;
83
84 git_buf git_repository__reserved_names_posix[] = {
85 { DOT_GIT, 0, CONST_STRLEN(DOT_GIT) },
86 };
87 size_t git_repository__reserved_names_posix_len = 1;
88
89 static void set_odb(git_repository *repo, git_odb *odb)
90 {
91 if (odb) {
92 GIT_REFCOUNT_OWN(odb, repo);
93 GIT_REFCOUNT_INC(odb);
94 }
95
96 if ((odb = git__swap(repo->_odb, odb)) != NULL) {
97 GIT_REFCOUNT_OWN(odb, NULL);
98 git_odb_free(odb);
99 }
100 }
101
102 static void set_refdb(git_repository *repo, git_refdb *refdb)
103 {
104 if (refdb) {
105 GIT_REFCOUNT_OWN(refdb, repo);
106 GIT_REFCOUNT_INC(refdb);
107 }
108
109 if ((refdb = git__swap(repo->_refdb, refdb)) != NULL) {
110 GIT_REFCOUNT_OWN(refdb, NULL);
111 git_refdb_free(refdb);
112 }
113 }
114
115 static void set_config(git_repository *repo, git_config *config)
116 {
117 if (config) {
118 GIT_REFCOUNT_OWN(config, repo);
119 GIT_REFCOUNT_INC(config);
120 }
121
122 if ((config = git__swap(repo->_config, config)) != NULL) {
123 GIT_REFCOUNT_OWN(config, NULL);
124 git_config_free(config);
125 }
126
127 git_repository__configmap_lookup_cache_clear(repo);
128 }
129
130 static void set_index(git_repository *repo, git_index *index)
131 {
132 if (index) {
133 GIT_REFCOUNT_OWN(index, repo);
134 GIT_REFCOUNT_INC(index);
135 }
136
137 if ((index = git__swap(repo->_index, index)) != NULL) {
138 GIT_REFCOUNT_OWN(index, NULL);
139 git_index_free(index);
140 }
141 }
142
143 int git_repository__cleanup(git_repository *repo)
144 {
145 assert(repo);
146
147 git_repository_submodule_cache_clear(repo);
148 git_cache_clear(&repo->objects);
149 git_attr_cache_flush(repo);
150
151 set_config(repo, NULL);
152 set_index(repo, NULL);
153 set_odb(repo, NULL);
154 set_refdb(repo, NULL);
155
156 return 0;
157 }
158
159 void git_repository_free(git_repository *repo)
160 {
161 size_t i;
162
163 if (repo == NULL)
164 return;
165
166 git_repository__cleanup(repo);
167
168 git_cache_dispose(&repo->objects);
169
170 git_diff_driver_registry_free(repo->diff_drivers);
171 repo->diff_drivers = NULL;
172
173 for (i = 0; i < repo->reserved_names.size; i++)
174 git_buf_dispose(git_array_get(repo->reserved_names, i));
175 git_array_clear(repo->reserved_names);
176
177 git__free(repo->gitlink);
178 git__free(repo->gitdir);
179 git__free(repo->commondir);
180 git__free(repo->workdir);
181 git__free(repo->namespace);
182 git__free(repo->ident_name);
183 git__free(repo->ident_email);
184
185 git__memzero(repo, sizeof(*repo));
186 git__free(repo);
187 }
188
189 /*
190 * Git repository open methods
191 *
192 * Open a repository object from its path
193 */
194 static int is_valid_repository_path(bool *out, git_buf *repository_path, git_buf *common_path)
195 {
196 int error;
197
198 *out = false;
199
200 /* Check if we have a separate commondir (e.g. we have a
201 * worktree) */
202 if (git_path_contains_file(repository_path, GIT_COMMONDIR_FILE)) {
203 git_buf common_link = GIT_BUF_INIT;
204
205 if ((error = git_buf_joinpath(&common_link, repository_path->ptr, GIT_COMMONDIR_FILE)) < 0 ||
206 (error = git_futils_readbuffer(&common_link, common_link.ptr)) < 0)
207 return error;
208
209 git_buf_rtrim(&common_link);
210 if (git_path_is_relative(common_link.ptr)) {
211 if ((error = git_buf_joinpath(common_path, repository_path->ptr, common_link.ptr)) < 0)
212 return error;
213 } else {
214 git_buf_swap(common_path, &common_link);
215 }
216
217 git_buf_dispose(&common_link);
218 }
219 else {
220 if ((error = git_buf_set(common_path, repository_path->ptr, repository_path->size)) < 0)
221 return error;
222 }
223
224 /* Make sure the commondir path always has a trailing * slash */
225 if (git_buf_rfind(common_path, '/') != (ssize_t)common_path->size - 1)
226 if ((error = git_buf_putc(common_path, '/')) < 0)
227 return error;
228
229 /* Ensure HEAD file exists */
230 if (git_path_contains_file(repository_path, GIT_HEAD_FILE) == false)
231 return 0;
232 /* Check files in common dir */
233 if (git_path_contains_dir(common_path, GIT_OBJECTS_DIR) == false)
234 return 0;
235 if (git_path_contains_dir(common_path, GIT_REFS_DIR) == false)
236 return 0;
237
238 *out = true;
239 return 0;
240 }
241
242 static git_repository *repository_alloc(void)
243 {
244 git_repository *repo = git__calloc(1, sizeof(git_repository));
245
246 if (repo == NULL ||
247 git_cache_init(&repo->objects) < 0)
248 goto on_error;
249
250 git_array_init_to_size(repo->reserved_names, 4);
251 if (!repo->reserved_names.ptr)
252 goto on_error;
253
254 /* set all the entries in the configmap cache to `unset` */
255 git_repository__configmap_lookup_cache_clear(repo);
256
257 return repo;
258
259 on_error:
260 if (repo)
261 git_cache_dispose(&repo->objects);
262
263 git__free(repo);
264 return NULL;
265 }
266
267 int git_repository_new(git_repository **out)
268 {
269 git_repository *repo;
270
271 *out = repo = repository_alloc();
272 GIT_ERROR_CHECK_ALLOC(repo);
273
274 repo->is_bare = 1;
275 repo->is_worktree = 0;
276
277 return 0;
278 }
279
280 static int load_config_data(git_repository *repo, const git_config *config)
281 {
282 int is_bare;
283
284 int err = git_config_get_bool(&is_bare, config, "core.bare");
285 if (err < 0 && err != GIT_ENOTFOUND)
286 return err;
287
288 /* Try to figure out if it's bare, default to non-bare if it's not set */
289 if (err != GIT_ENOTFOUND)
290 repo->is_bare = is_bare && !repo->is_worktree;
291 else
292 repo->is_bare = 0;
293
294 return 0;
295 }
296
297 static int load_workdir(git_repository *repo, git_config *config, git_buf *parent_path)
298 {
299 int error;
300 git_config_entry *ce;
301 git_buf worktree = GIT_BUF_INIT;
302 git_buf path = GIT_BUF_INIT;
303
304 if (repo->is_bare)
305 return 0;
306
307 if ((error = git_config__lookup_entry(
308 &ce, config, "core.worktree", false)) < 0)
309 return error;
310
311 if (repo->is_worktree) {
312 char *gitlink = git_worktree__read_link(repo->gitdir, GIT_GITDIR_FILE);
313 if (!gitlink) {
314 error = -1;
315 goto cleanup;
316 }
317
318 git_buf_attach(&worktree, gitlink, 0);
319
320 if ((git_path_dirname_r(&worktree, worktree.ptr)) < 0 ||
321 git_path_to_dir(&worktree) < 0) {
322 error = -1;
323 goto cleanup;
324 }
325
326 repo->workdir = git_buf_detach(&worktree);
327 }
328 else if (ce && ce->value) {
329 if ((error = git_path_prettify_dir(
330 &worktree, ce->value, repo->gitdir)) < 0)
331 goto cleanup;
332
333 repo->workdir = git_buf_detach(&worktree);
334 }
335 else if (parent_path && git_path_isdir(parent_path->ptr))
336 repo->workdir = git_buf_detach(parent_path);
337 else {
338 if (git_path_dirname_r(&worktree, repo->gitdir) < 0 ||
339 git_path_to_dir(&worktree) < 0) {
340 error = -1;
341 goto cleanup;
342 }
343
344 repo->workdir = git_buf_detach(&worktree);
345 }
346
347 GIT_ERROR_CHECK_ALLOC(repo->workdir);
348 cleanup:
349 git_buf_dispose(&path);
350 git_config_entry_free(ce);
351 return error;
352 }
353
354 /*
355 * This function returns furthest offset into path where a ceiling dir
356 * is found, so we can stop processing the path at that point.
357 *
358 * Note: converting this to use git_bufs instead of GIT_PATH_MAX buffers on
359 * the stack could remove directories name limits, but at the cost of doing
360 * repeated malloc/frees inside the loop below, so let's not do it now.
361 */
362 static size_t find_ceiling_dir_offset(
363 const char *path,
364 const char *ceiling_directories)
365 {
366 char buf[GIT_PATH_MAX + 1];
367 char buf2[GIT_PATH_MAX + 1];
368 const char *ceil, *sep;
369 size_t len, max_len = 0, min_len;
370
371 assert(path);
372
373 min_len = (size_t)(git_path_root(path) + 1);
374
375 if (ceiling_directories == NULL || min_len == 0)
376 return min_len;
377
378 for (sep = ceil = ceiling_directories; *sep; ceil = sep + 1) {
379 for (sep = ceil; *sep && *sep != GIT_PATH_LIST_SEPARATOR; sep++);
380 len = sep - ceil;
381
382 if (len == 0 || len >= sizeof(buf) || git_path_root(ceil) == -1)
383 continue;
384
385 strncpy(buf, ceil, len);
386 buf[len] = '\0';
387
388 if (p_realpath(buf, buf2) == NULL)
389 continue;
390
391 len = strlen(buf2);
392 if (len > 0 && buf2[len-1] == '/')
393 buf[--len] = '\0';
394
395 if (!strncmp(path, buf2, len) &&
396 (path[len] == '/' || !path[len]) &&
397 len > max_len)
398 {
399 max_len = len;
400 }
401 }
402
403 return (max_len <= min_len ? min_len : max_len);
404 }
405
406 /*
407 * Read the contents of `file_path` and set `path_out` to the repo dir that
408 * it points to. Before calling, set `path_out` to the base directory that
409 * should be used if the contents of `file_path` are a relative path.
410 */
411 static int read_gitfile(git_buf *path_out, const char *file_path)
412 {
413 int error = 0;
414 git_buf file = GIT_BUF_INIT;
415 size_t prefix_len = strlen(GIT_FILE_CONTENT_PREFIX);
416
417 assert(path_out && file_path);
418
419 if (git_futils_readbuffer(&file, file_path) < 0)
420 return -1;
421
422 git_buf_rtrim(&file);
423 /* apparently on Windows, some people use backslashes in paths */
424 git_path_mkposix(file.ptr);
425
426 if (git_buf_len(&file) <= prefix_len ||
427 memcmp(git_buf_cstr(&file), GIT_FILE_CONTENT_PREFIX, prefix_len) != 0)
428 {
429 git_error_set(GIT_ERROR_REPOSITORY,
430 "the `.git` file at '%s' is malformed", file_path);
431 error = -1;
432 }
433 else if ((error = git_path_dirname_r(path_out, file_path)) >= 0) {
434 const char *gitlink = git_buf_cstr(&file) + prefix_len;
435 while (*gitlink && git__isspace(*gitlink)) gitlink++;
436
437 error = git_path_prettify_dir(
438 path_out, gitlink, git_buf_cstr(path_out));
439 }
440
441 git_buf_dispose(&file);
442 return error;
443 }
444
445 static int find_repo(
446 git_buf *gitdir_path,
447 git_buf *workdir_path,
448 git_buf *gitlink_path,
449 git_buf *commondir_path,
450 const char *start_path,
451 uint32_t flags,
452 const char *ceiling_dirs)
453 {
454 git_buf path = GIT_BUF_INIT;
455 git_buf repo_link = GIT_BUF_INIT;
456 git_buf common_link = GIT_BUF_INIT;
457 struct stat st;
458 dev_t initial_device = 0;
459 int min_iterations;
460 bool in_dot_git, is_valid;
461 size_t ceiling_offset = 0;
462 int error;
463
464 git_buf_clear(gitdir_path);
465
466 error = git_path_prettify(&path, start_path, NULL);
467 if (error < 0)
468 return error;
469
470 /* in_dot_git toggles each loop:
471 * /a/b/c/.git, /a/b/c, /a/b/.git, /a/b, /a/.git, /a
472 * With GIT_REPOSITORY_OPEN_BARE or GIT_REPOSITORY_OPEN_NO_DOTGIT, we
473 * assume we started with /a/b/c.git and don't append .git the first
474 * time through.
475 * min_iterations indicates the number of iterations left before going
476 * further counts as a search. */
477 if (flags & (GIT_REPOSITORY_OPEN_BARE | GIT_REPOSITORY_OPEN_NO_DOTGIT)) {
478 in_dot_git = true;
479 min_iterations = 1;
480 } else {
481 in_dot_git = false;
482 min_iterations = 2;
483 }
484
485 for (;;) {
486 if (!(flags & GIT_REPOSITORY_OPEN_NO_DOTGIT)) {
487 if (!in_dot_git) {
488 if ((error = git_buf_joinpath(&path, path.ptr, DOT_GIT)) < 0)
489 goto out;
490 }
491 in_dot_git = !in_dot_git;
492 }
493
494 if (p_stat(path.ptr, &st) == 0) {
495 /* check that we have not crossed device boundaries */
496 if (initial_device == 0)
497 initial_device = st.st_dev;
498 else if (st.st_dev != initial_device &&
499 !(flags & GIT_REPOSITORY_OPEN_CROSS_FS))
500 break;
501
502 if (S_ISDIR(st.st_mode)) {
503 if ((error = is_valid_repository_path(&is_valid, &path, &common_link)) < 0)
504 goto out;
505
506 if (is_valid) {
507 if ((error = git_path_to_dir(&path)) < 0 ||
508 (error = git_buf_set(gitdir_path, path.ptr, path.size)) < 0)
509 goto out;
510
511 if (gitlink_path)
512 if ((error = git_buf_attach(gitlink_path, git_worktree__read_link(path.ptr, GIT_GITDIR_FILE), 0)) < 0)
513 goto out;
514 if (commondir_path)
515 git_buf_swap(&common_link, commondir_path);
516
517 break;
518 }
519 } else if (S_ISREG(st.st_mode) && git__suffixcmp(path.ptr, "/" DOT_GIT) == 0) {
520 if ((error = read_gitfile(&repo_link, path.ptr)) < 0 ||
521 (error = is_valid_repository_path(&is_valid, &repo_link, &common_link)) < 0)
522 goto out;
523
524 if (is_valid) {
525 git_buf_swap(gitdir_path, &repo_link);
526
527 if (gitlink_path)
528 if ((error = git_buf_put(gitlink_path, path.ptr, path.size)) < 0)
529 goto out;
530 if (commondir_path)
531 git_buf_swap(&common_link, commondir_path);
532 }
533 break;
534 }
535 }
536
537 /* Move up one directory. If we're in_dot_git, we'll search the
538 * parent itself next. If we're !in_dot_git, we'll search .git
539 * in the parent directory next (added at the top of the loop). */
540 if ((error = git_path_dirname_r(&path, path.ptr)) < 0)
541 goto out;
542
543 /* Once we've checked the directory (and .git if applicable),
544 * find the ceiling for a search. */
545 if (min_iterations && (--min_iterations == 0))
546 ceiling_offset = find_ceiling_dir_offset(path.ptr, ceiling_dirs);
547
548 /* Check if we should stop searching here. */
549 if (min_iterations == 0 &&
550 (path.ptr[ceiling_offset] == 0 || (flags & GIT_REPOSITORY_OPEN_NO_SEARCH)))
551 break;
552 }
553
554 if (workdir_path && !(flags & GIT_REPOSITORY_OPEN_BARE)) {
555 if (!git_buf_len(gitdir_path))
556 git_buf_clear(workdir_path);
557 else if ((error = git_path_dirname_r(workdir_path, path.ptr)) < 0 ||
558 (error = git_path_to_dir(workdir_path)) < 0)
559 goto out;
560 }
561
562 /* If we didn't find the repository, and we don't have any other error
563 * to report, report that. */
564 if (!git_buf_len(gitdir_path)) {
565 git_error_set(GIT_ERROR_REPOSITORY, "could not find repository from '%s'", start_path);
566 error = GIT_ENOTFOUND;
567 goto out;
568 }
569
570 out:
571 git_buf_dispose(&path);
572 git_buf_dispose(&repo_link);
573 git_buf_dispose(&common_link);
574 return error;
575 }
576
577 int git_repository_open_bare(
578 git_repository **repo_ptr,
579 const char *bare_path)
580 {
581 git_buf path = GIT_BUF_INIT, common_path = GIT_BUF_INIT;
582 git_repository *repo = NULL;
583 bool is_valid;
584 int error;
585
586 if ((error = git_path_prettify_dir(&path, bare_path, NULL)) < 0 ||
587 (error = is_valid_repository_path(&is_valid, &path, &common_path)) < 0)
588 return error;
589
590 if (!is_valid) {
591 git_buf_dispose(&path);
592 git_buf_dispose(&common_path);
593 git_error_set(GIT_ERROR_REPOSITORY, "path is not a repository: %s", bare_path);
594 return GIT_ENOTFOUND;
595 }
596
597 repo = repository_alloc();
598 GIT_ERROR_CHECK_ALLOC(repo);
599
600 repo->gitdir = git_buf_detach(&path);
601 GIT_ERROR_CHECK_ALLOC(repo->gitdir);
602 repo->commondir = git_buf_detach(&common_path);
603 GIT_ERROR_CHECK_ALLOC(repo->commondir);
604
605 /* of course we're bare! */
606 repo->is_bare = 1;
607 repo->is_worktree = 0;
608 repo->workdir = NULL;
609
610 *repo_ptr = repo;
611 return 0;
612 }
613
614 static int _git_repository_open_ext_from_env(
615 git_repository **out,
616 const char *start_path)
617 {
618 git_repository *repo = NULL;
619 git_index *index = NULL;
620 git_odb *odb = NULL;
621 git_buf dir_buf = GIT_BUF_INIT;
622 git_buf ceiling_dirs_buf = GIT_BUF_INIT;
623 git_buf across_fs_buf = GIT_BUF_INIT;
624 git_buf index_file_buf = GIT_BUF_INIT;
625 git_buf namespace_buf = GIT_BUF_INIT;
626 git_buf object_dir_buf = GIT_BUF_INIT;
627 git_buf alts_buf = GIT_BUF_INIT;
628 git_buf work_tree_buf = GIT_BUF_INIT;
629 git_buf common_dir_buf = GIT_BUF_INIT;
630 const char *ceiling_dirs = NULL;
631 unsigned flags = 0;
632 int error;
633
634 if (!start_path) {
635 error = git__getenv(&dir_buf, "GIT_DIR");
636 if (error == GIT_ENOTFOUND) {
637 git_error_clear();
638 start_path = ".";
639 } else if (error < 0)
640 goto error;
641 else {
642 start_path = git_buf_cstr(&dir_buf);
643 flags |= GIT_REPOSITORY_OPEN_NO_SEARCH;
644 flags |= GIT_REPOSITORY_OPEN_NO_DOTGIT;
645 }
646 }
647
648 error = git__getenv(&ceiling_dirs_buf, "GIT_CEILING_DIRECTORIES");
649 if (error == GIT_ENOTFOUND)
650 git_error_clear();
651 else if (error < 0)
652 goto error;
653 else
654 ceiling_dirs = git_buf_cstr(&ceiling_dirs_buf);
655
656 error = git__getenv(&across_fs_buf, "GIT_DISCOVERY_ACROSS_FILESYSTEM");
657 if (error == GIT_ENOTFOUND)
658 git_error_clear();
659 else if (error < 0)
660 goto error;
661 else {
662 int across_fs = 0;
663 error = git_config_parse_bool(&across_fs, git_buf_cstr(&across_fs_buf));
664 if (error < 0)
665 goto error;
666 if (across_fs)
667 flags |= GIT_REPOSITORY_OPEN_CROSS_FS;
668 }
669
670 error = git__getenv(&index_file_buf, "GIT_INDEX_FILE");
671 if (error == GIT_ENOTFOUND)
672 git_error_clear();
673 else if (error < 0)
674 goto error;
675 else {
676 error = git_index_open(&index, git_buf_cstr(&index_file_buf));
677 if (error < 0)
678 goto error;
679 }
680
681 error = git__getenv(&namespace_buf, "GIT_NAMESPACE");
682 if (error == GIT_ENOTFOUND)
683 git_error_clear();
684 else if (error < 0)
685 goto error;
686
687 error = git__getenv(&object_dir_buf, "GIT_OBJECT_DIRECTORY");
688 if (error == GIT_ENOTFOUND)
689 git_error_clear();
690 else if (error < 0)
691 goto error;
692 else {
693 error = git_odb_open(&odb, git_buf_cstr(&object_dir_buf));
694 if (error < 0)
695 goto error;
696 }
697
698 error = git__getenv(&work_tree_buf, "GIT_WORK_TREE");
699 if (error == GIT_ENOTFOUND)
700 git_error_clear();
701 else if (error < 0)
702 goto error;
703 else {
704 git_error_set(GIT_ERROR_INVALID, "GIT_WORK_TREE unimplemented");
705 error = GIT_ERROR;
706 goto error;
707 }
708
709 error = git__getenv(&work_tree_buf, "GIT_COMMON_DIR");
710 if (error == GIT_ENOTFOUND)
711 git_error_clear();
712 else if (error < 0)
713 goto error;
714 else {
715 git_error_set(GIT_ERROR_INVALID, "GIT_COMMON_DIR unimplemented");
716 error = GIT_ERROR;
717 goto error;
718 }
719
720 error = git_repository_open_ext(&repo, start_path, flags, ceiling_dirs);
721 if (error < 0)
722 goto error;
723
724 if (odb)
725 git_repository_set_odb(repo, odb);
726
727 error = git__getenv(&alts_buf, "GIT_ALTERNATE_OBJECT_DIRECTORIES");
728 if (error == GIT_ENOTFOUND) {
729 git_error_clear();
730 error = 0;
731 } else if (error < 0)
732 goto error;
733 else {
734 const char *end;
735 char *alt, *sep;
736 if (!odb) {
737 error = git_repository_odb(&odb, repo);
738 if (error < 0)
739 goto error;
740 }
741
742 end = git_buf_cstr(&alts_buf) + git_buf_len(&alts_buf);
743 for (sep = alt = alts_buf.ptr; sep != end; alt = sep+1) {
744 for (sep = alt; *sep && *sep != GIT_PATH_LIST_SEPARATOR; sep++)
745 ;
746 if (*sep)
747 *sep = '\0';
748 error = git_odb_add_disk_alternate(odb, alt);
749 if (error < 0)
750 goto error;
751 }
752 }
753
754 if (git_buf_len(&namespace_buf)) {
755 error = git_repository_set_namespace(repo, git_buf_cstr(&namespace_buf));
756 if (error < 0)
757 goto error;
758 }
759
760 git_repository_set_index(repo, index);
761
762 if (out) {
763 *out = repo;
764 goto success;
765 }
766 error:
767 git_repository_free(repo);
768 success:
769 git_odb_free(odb);
770 git_index_free(index);
771 git_buf_dispose(&common_dir_buf);
772 git_buf_dispose(&work_tree_buf);
773 git_buf_dispose(&alts_buf);
774 git_buf_dispose(&object_dir_buf);
775 git_buf_dispose(&namespace_buf);
776 git_buf_dispose(&index_file_buf);
777 git_buf_dispose(&across_fs_buf);
778 git_buf_dispose(&ceiling_dirs_buf);
779 git_buf_dispose(&dir_buf);
780 return error;
781 }
782
783 static int repo_is_worktree(unsigned *out, const git_repository *repo)
784 {
785 git_buf gitdir_link = GIT_BUF_INIT;
786 int error;
787
788 /* Worktrees cannot have the same commondir and gitdir */
789 if (repo->commondir && repo->gitdir
790 && !strcmp(repo->commondir, repo->gitdir)) {
791 *out = 0;
792 return 0;
793 }
794
795 if ((error = git_buf_joinpath(&gitdir_link, repo->gitdir, "gitdir")) < 0)
796 return -1;
797
798 /* A 'gitdir' file inside a git directory is currently
799 * only used when the repository is a working tree. */
800 *out = !!git_path_exists(gitdir_link.ptr);
801
802 git_buf_dispose(&gitdir_link);
803 return error;
804 }
805
806 int git_repository_open_ext(
807 git_repository **repo_ptr,
808 const char *start_path,
809 unsigned int flags,
810 const char *ceiling_dirs)
811 {
812 int error;
813 unsigned is_worktree;
814 git_buf gitdir = GIT_BUF_INIT, workdir = GIT_BUF_INIT,
815 gitlink = GIT_BUF_INIT, commondir = GIT_BUF_INIT;
816 git_repository *repo = NULL;
817 git_config *config = NULL;
818 int version = 0;
819
820 if (flags & GIT_REPOSITORY_OPEN_FROM_ENV)
821 return _git_repository_open_ext_from_env(repo_ptr, start_path);
822
823 if (repo_ptr)
824 *repo_ptr = NULL;
825
826 error = find_repo(
827 &gitdir, &workdir, &gitlink, &commondir, start_path, flags, ceiling_dirs);
828
829 if (error < 0 || !repo_ptr)
830 goto cleanup;
831
832 repo = repository_alloc();
833 GIT_ERROR_CHECK_ALLOC(repo);
834
835 repo->gitdir = git_buf_detach(&gitdir);
836 GIT_ERROR_CHECK_ALLOC(repo->gitdir);
837
838 if (gitlink.size) {
839 repo->gitlink = git_buf_detach(&gitlink);
840 GIT_ERROR_CHECK_ALLOC(repo->gitlink);
841 }
842 if (commondir.size) {
843 repo->commondir = git_buf_detach(&commondir);
844 GIT_ERROR_CHECK_ALLOC(repo->commondir);
845 }
846
847 if ((error = repo_is_worktree(&is_worktree, repo)) < 0)
848 goto cleanup;
849 repo->is_worktree = is_worktree;
850
851 /*
852 * We'd like to have the config, but git doesn't particularly
853 * care if it's not there, so we need to deal with that.
854 */
855
856 error = git_repository_config_snapshot(&config, repo);
857 if (error < 0 && error != GIT_ENOTFOUND)
858 goto cleanup;
859
860 if (config && (error = check_repositoryformatversion(&version, config)) < 0)
861 goto cleanup;
862
863 if ((error = check_extensions(config, version)) < 0)
864 goto cleanup;
865
866 if ((flags & GIT_REPOSITORY_OPEN_BARE) != 0)
867 repo->is_bare = 1;
868 else {
869
870 if (config &&
871 ((error = load_config_data(repo, config)) < 0 ||
872 (error = load_workdir(repo, config, &workdir)) < 0))
873 goto cleanup;
874 }
875
876 cleanup:
877 git_buf_dispose(&gitdir);
878 git_buf_dispose(&workdir);
879 git_buf_dispose(&gitlink);
880 git_buf_dispose(&commondir);
881 git_config_free(config);
882
883 if (error < 0)
884 git_repository_free(repo);
885 else if (repo_ptr)
886 *repo_ptr = repo;
887
888 return error;
889 }
890
891 int git_repository_open(git_repository **repo_out, const char *path)
892 {
893 return git_repository_open_ext(
894 repo_out, path, GIT_REPOSITORY_OPEN_NO_SEARCH, NULL);
895 }
896
897 int git_repository_open_from_worktree(git_repository **repo_out, git_worktree *wt)
898 {
899 git_buf path = GIT_BUF_INIT;
900 git_repository *repo = NULL;
901 size_t len;
902 int err;
903
904 assert(repo_out && wt);
905
906 *repo_out = NULL;
907 len = strlen(wt->gitlink_path);
908
909 if (len <= 4 || strcasecmp(wt->gitlink_path + len - 4, ".git")) {
910 err = -1;
911 goto out;
912 }
913
914 if ((err = git_buf_set(&path, wt->gitlink_path, len - 4)) < 0)
915 goto out;
916
917 if ((err = git_repository_open(&repo, path.ptr)) < 0)
918 goto out;
919
920 *repo_out = repo;
921
922 out:
923 git_buf_dispose(&path);
924
925 return err;
926 }
927
928 int git_repository_wrap_odb(git_repository **repo_out, git_odb *odb)
929 {
930 git_repository *repo;
931
932 repo = repository_alloc();
933 GIT_ERROR_CHECK_ALLOC(repo);
934
935 git_repository_set_odb(repo, odb);
936 *repo_out = repo;
937
938 return 0;
939 }
940
941 int git_repository_discover(
942 git_buf *out,
943 const char *start_path,
944 int across_fs,
945 const char *ceiling_dirs)
946 {
947 uint32_t flags = across_fs ? GIT_REPOSITORY_OPEN_CROSS_FS : 0;
948
949 assert(start_path);
950
951 git_buf_sanitize(out);
952
953 return find_repo(out, NULL, NULL, NULL, start_path, flags, ceiling_dirs);
954 }
955
956 static int load_config(
957 git_config **out,
958 git_repository *repo,
959 const char *global_config_path,
960 const char *xdg_config_path,
961 const char *system_config_path,
962 const char *programdata_path)
963 {
964 int error;
965 git_buf config_path = GIT_BUF_INIT;
966 git_config *cfg = NULL;
967
968 assert(out);
969
970 if ((error = git_config_new(&cfg)) < 0)
971 return error;
972
973 if (repo) {
974 if ((error = git_repository_item_path(&config_path, repo, GIT_REPOSITORY_ITEM_CONFIG)) == 0)
975 error = git_config_add_file_ondisk(cfg, config_path.ptr, GIT_CONFIG_LEVEL_LOCAL, repo, 0);
976
977 if (error && error != GIT_ENOTFOUND)
978 goto on_error;
979
980 git_buf_dispose(&config_path);
981 }
982
983 if (global_config_path != NULL &&
984 (error = git_config_add_file_ondisk(
985 cfg, global_config_path, GIT_CONFIG_LEVEL_GLOBAL, repo, 0)) < 0 &&
986 error != GIT_ENOTFOUND)
987 goto on_error;
988
989 if (xdg_config_path != NULL &&
990 (error = git_config_add_file_ondisk(
991 cfg, xdg_config_path, GIT_CONFIG_LEVEL_XDG, repo, 0)) < 0 &&
992 error != GIT_ENOTFOUND)
993 goto on_error;
994
995 if (system_config_path != NULL &&
996 (error = git_config_add_file_ondisk(
997 cfg, system_config_path, GIT_CONFIG_LEVEL_SYSTEM, repo, 0)) < 0 &&
998 error != GIT_ENOTFOUND)
999 goto on_error;
1000
1001 if (programdata_path != NULL &&
1002 (error = git_config_add_file_ondisk(
1003 cfg, programdata_path, GIT_CONFIG_LEVEL_PROGRAMDATA, repo, 0)) < 0 &&
1004 error != GIT_ENOTFOUND)
1005 goto on_error;
1006
1007 git_error_clear(); /* clear any lingering ENOTFOUND errors */
1008
1009 *out = cfg;
1010 return 0;
1011
1012 on_error:
1013 git_buf_dispose(&config_path);
1014 git_config_free(cfg);
1015 *out = NULL;
1016 return error;
1017 }
1018
1019 static const char *path_unless_empty(git_buf *buf)
1020 {
1021 return git_buf_len(buf) > 0 ? git_buf_cstr(buf) : NULL;
1022 }
1023
1024 int git_repository_config__weakptr(git_config **out, git_repository *repo)
1025 {
1026 int error = 0;
1027
1028 if (repo->_config == NULL) {
1029 git_buf global_buf = GIT_BUF_INIT;
1030 git_buf xdg_buf = GIT_BUF_INIT;
1031 git_buf system_buf = GIT_BUF_INIT;
1032 git_buf programdata_buf = GIT_BUF_INIT;
1033 git_config *config;
1034
1035 git_config_find_global(&global_buf);
1036 git_config_find_xdg(&xdg_buf);
1037 git_config_find_system(&system_buf);
1038 git_config_find_programdata(&programdata_buf);
1039
1040 /* If there is no global file, open a backend for it anyway */
1041 if (git_buf_len(&global_buf) == 0)
1042 git_config__global_location(&global_buf);
1043
1044 error = load_config(
1045 &config, repo,
1046 path_unless_empty(&global_buf),
1047 path_unless_empty(&xdg_buf),
1048 path_unless_empty(&system_buf),
1049 path_unless_empty(&programdata_buf));
1050 if (!error) {
1051 GIT_REFCOUNT_OWN(config, repo);
1052
1053 config = git__compare_and_swap(&repo->_config, NULL, config);
1054 if (config != NULL) {
1055 GIT_REFCOUNT_OWN(config, NULL);
1056 git_config_free(config);
1057 }
1058 }
1059
1060 git_buf_dispose(&global_buf);
1061 git_buf_dispose(&xdg_buf);
1062 git_buf_dispose(&system_buf);
1063 git_buf_dispose(&programdata_buf);
1064 }
1065
1066 *out = repo->_config;
1067 return error;
1068 }
1069
1070 int git_repository_config(git_config **out, git_repository *repo)
1071 {
1072 if (git_repository_config__weakptr(out, repo) < 0)
1073 return -1;
1074
1075 GIT_REFCOUNT_INC(*out);
1076 return 0;
1077 }
1078
1079 int git_repository_config_snapshot(git_config **out, git_repository *repo)
1080 {
1081 int error;
1082 git_config *weak;
1083
1084 if ((error = git_repository_config__weakptr(&weak, repo)) < 0)
1085 return error;
1086
1087 return git_config_snapshot(out, weak);
1088 }
1089
1090 int git_repository_set_config(git_repository *repo, git_config *config)
1091 {
1092 assert(repo && config);
1093 set_config(repo, config);
1094 return 0;
1095 }
1096
1097 int git_repository_odb__weakptr(git_odb **out, git_repository *repo)
1098 {
1099 int error = 0;
1100
1101 assert(repo && out);
1102
1103 if (repo->_odb == NULL) {
1104 git_buf odb_path = GIT_BUF_INIT;
1105 git_odb *odb;
1106
1107 if ((error = git_repository_item_path(&odb_path, repo,
1108 GIT_REPOSITORY_ITEM_OBJECTS)) < 0 ||
1109 (error = git_odb_new(&odb)) < 0)
1110 return error;
1111
1112 GIT_REFCOUNT_OWN(odb, repo);
1113
1114 if ((error = git_odb__set_caps(odb, GIT_ODB_CAP_FROM_OWNER)) < 0 ||
1115 (error = git_odb__add_default_backends(odb, odb_path.ptr, 0, 0)) < 0) {
1116 git_odb_free(odb);
1117 return error;
1118 }
1119
1120 odb = git__compare_and_swap(&repo->_odb, NULL, odb);
1121 if (odb != NULL) {
1122 GIT_REFCOUNT_OWN(odb, NULL);
1123 git_odb_free(odb);
1124 }
1125
1126 git_buf_dispose(&odb_path);
1127 }
1128
1129 *out = repo->_odb;
1130 return error;
1131 }
1132
1133 int git_repository_odb(git_odb **out, git_repository *repo)
1134 {
1135 if (git_repository_odb__weakptr(out, repo) < 0)
1136 return -1;
1137
1138 GIT_REFCOUNT_INC(*out);
1139 return 0;
1140 }
1141
1142 int git_repository_set_odb(git_repository *repo, git_odb *odb)
1143 {
1144 assert(repo && odb);
1145 set_odb(repo, odb);
1146 return 0;
1147 }
1148
1149 int git_repository_refdb__weakptr(git_refdb **out, git_repository *repo)
1150 {
1151 int error = 0;
1152
1153 assert(out && repo);
1154
1155 if (repo->_refdb == NULL) {
1156 git_refdb *refdb;
1157
1158 error = git_refdb_open(&refdb, repo);
1159 if (!error) {
1160 GIT_REFCOUNT_OWN(refdb, repo);
1161
1162 refdb = git__compare_and_swap(&repo->_refdb, NULL, refdb);
1163 if (refdb != NULL) {
1164 GIT_REFCOUNT_OWN(refdb, NULL);
1165 git_refdb_free(refdb);
1166 }
1167 }
1168 }
1169
1170 *out = repo->_refdb;
1171 return error;
1172 }
1173
1174 int git_repository_refdb(git_refdb **out, git_repository *repo)
1175 {
1176 if (git_repository_refdb__weakptr(out, repo) < 0)
1177 return -1;
1178
1179 GIT_REFCOUNT_INC(*out);
1180 return 0;
1181 }
1182
1183 int git_repository_set_refdb(git_repository *repo, git_refdb *refdb)
1184 {
1185 assert(repo && refdb);
1186 set_refdb(repo, refdb);
1187 return 0;
1188 }
1189
1190 int git_repository_index__weakptr(git_index **out, git_repository *repo)
1191 {
1192 int error = 0;
1193
1194 assert(out && repo);
1195
1196 if (repo->_index == NULL) {
1197 git_buf index_path = GIT_BUF_INIT;
1198 git_index *index;
1199
1200 if ((error = git_buf_joinpath(&index_path, repo->gitdir, GIT_INDEX_FILE)) < 0)
1201 return error;
1202
1203 error = git_index_open(&index, index_path.ptr);
1204 if (!error) {
1205 GIT_REFCOUNT_OWN(index, repo);
1206
1207 index = git__compare_and_swap(&repo->_index, NULL, index);
1208 if (index != NULL) {
1209 GIT_REFCOUNT_OWN(index, NULL);
1210 git_index_free(index);
1211 }
1212
1213 error = git_index_set_caps(repo->_index,
1214 GIT_INDEX_CAPABILITY_FROM_OWNER);
1215 }
1216
1217 git_buf_dispose(&index_path);
1218 }
1219
1220 *out = repo->_index;
1221 return error;
1222 }
1223
1224 int git_repository_index(git_index **out, git_repository *repo)
1225 {
1226 if (git_repository_index__weakptr(out, repo) < 0)
1227 return -1;
1228
1229 GIT_REFCOUNT_INC(*out);
1230 return 0;
1231 }
1232
1233 int git_repository_set_index(git_repository *repo, git_index *index)
1234 {
1235 assert(repo);
1236 set_index(repo, index);
1237 return 0;
1238 }
1239
1240 int git_repository_set_namespace(git_repository *repo, const char *namespace)
1241 {
1242 git__free(repo->namespace);
1243
1244 if (namespace == NULL) {
1245 repo->namespace = NULL;
1246 return 0;
1247 }
1248
1249 return (repo->namespace = git__strdup(namespace)) ? 0 : -1;
1250 }
1251
1252 const char *git_repository_get_namespace(git_repository *repo)
1253 {
1254 return repo->namespace;
1255 }
1256
1257 #ifdef GIT_WIN32
1258 static int reserved_names_add8dot3(git_repository *repo, const char *path)
1259 {
1260 char *name = git_win32_path_8dot3_name(path);
1261 const char *def = GIT_DIR_SHORTNAME;
1262 const char *def_dot_git = DOT_GIT;
1263 size_t name_len, def_len = CONST_STRLEN(GIT_DIR_SHORTNAME);
1264 size_t def_dot_git_len = CONST_STRLEN(DOT_GIT);
1265 git_buf *buf;
1266
1267 if (!name)
1268 return 0;
1269
1270 name_len = strlen(name);
1271
1272 if ((name_len == def_len && memcmp(name, def, def_len) == 0) ||
1273 (name_len == def_dot_git_len && memcmp(name, def_dot_git, def_dot_git_len) == 0)) {
1274 git__free(name);
1275 return 0;
1276 }
1277
1278 if ((buf = git_array_alloc(repo->reserved_names)) == NULL)
1279 return -1;
1280
1281 git_buf_attach(buf, name, name_len);
1282 return true;
1283 }
1284
1285 bool git_repository__reserved_names(
1286 git_buf **out, size_t *outlen, git_repository *repo, bool include_ntfs)
1287 {
1288 GIT_UNUSED(include_ntfs);
1289
1290 if (repo->reserved_names.size == 0) {
1291 git_buf *buf;
1292 size_t i;
1293
1294 /* Add the static defaults */
1295 for (i = 0; i < git_repository__reserved_names_win32_len; i++) {
1296 if ((buf = git_array_alloc(repo->reserved_names)) == NULL)
1297 goto on_error;
1298
1299 buf->ptr = git_repository__reserved_names_win32[i].ptr;
1300 buf->size = git_repository__reserved_names_win32[i].size;
1301 }
1302
1303 /* Try to add any repo-specific reserved names - the gitlink file
1304 * within a submodule or the repository (if the repository directory
1305 * is beneath the workdir). These are typically `.git`, but should
1306 * be protected in case they are not. Note, repo and workdir paths
1307 * are always prettified to end in `/`, so a prefixcmp is safe.
1308 */
1309 if (!repo->is_bare) {
1310 int (*prefixcmp)(const char *, const char *);
1311 int error, ignorecase;
1312
1313 error = git_repository__configmap_lookup(
1314 &ignorecase, repo, GIT_CONFIGMAP_IGNORECASE);
1315 prefixcmp = (error || ignorecase) ? git__prefixcmp_icase :
1316 git__prefixcmp;
1317
1318 if (repo->gitlink &&
1319 reserved_names_add8dot3(repo, repo->gitlink) < 0)
1320 goto on_error;
1321
1322 if (repo->gitdir &&
1323 prefixcmp(repo->gitdir, repo->workdir) == 0 &&
1324 reserved_names_add8dot3(repo, repo->gitdir) < 0)
1325 goto on_error;
1326 }
1327 }
1328
1329 *out = repo->reserved_names.ptr;
1330 *outlen = repo->reserved_names.size;
1331
1332 return true;
1333
1334 /* Always give good defaults, even on OOM */
1335 on_error:
1336 *out = git_repository__reserved_names_win32;
1337 *outlen = git_repository__reserved_names_win32_len;
1338
1339 return false;
1340 }
1341 #else
1342 bool git_repository__reserved_names(
1343 git_buf **out, size_t *outlen, git_repository *repo, bool include_ntfs)
1344 {
1345 GIT_UNUSED(repo);
1346
1347 if (include_ntfs) {
1348 *out = git_repository__reserved_names_win32;
1349 *outlen = git_repository__reserved_names_win32_len;
1350 } else {
1351 *out = git_repository__reserved_names_posix;
1352 *outlen = git_repository__reserved_names_posix_len;
1353 }
1354
1355 return true;
1356 }
1357 #endif
1358
1359 static int check_repositoryformatversion(int *version, git_config *config)
1360 {
1361 int error;
1362
1363 error = git_config_get_int32(version, config, "core.repositoryformatversion");
1364 /* git ignores this if the config variable isn't there */
1365 if (error == GIT_ENOTFOUND)
1366 return 0;
1367
1368 if (error < 0)
1369 return -1;
1370
1371 if (GIT_REPO_MAX_VERSION < *version) {
1372 git_error_set(GIT_ERROR_REPOSITORY,
1373 "unsupported repository version %d; only versions up to %d are supported",
1374 *version, GIT_REPO_MAX_VERSION);
1375 return -1;
1376 }
1377
1378 return 0;
1379 }
1380
1381 static int check_valid_extension(const git_config_entry *entry, void *payload)
1382 {
1383 GIT_UNUSED(payload);
1384
1385 if (!strcmp(entry->name, "extensions.noop"))
1386 return 0;
1387
1388 git_error_set(GIT_ERROR_REPOSITORY, "unsupported extension name %s", entry->name);
1389 return -1;
1390 }
1391
1392 static int check_extensions(git_config *config, int version)
1393 {
1394 if (version < 1)
1395 return 0;
1396
1397 return git_config_foreach_match(config, "^extensions\\.", check_valid_extension, NULL);
1398 }
1399
1400 int git_repository_create_head(const char *git_dir, const char *ref_name)
1401 {
1402 git_buf ref_path = GIT_BUF_INIT;
1403 git_filebuf ref = GIT_FILEBUF_INIT;
1404 const char *fmt;
1405 int error;
1406
1407 if ((error = git_buf_joinpath(&ref_path, git_dir, GIT_HEAD_FILE)) < 0 ||
1408 (error = git_filebuf_open(&ref, ref_path.ptr, 0, GIT_REFS_FILE_MODE)) < 0)
1409 goto out;
1410
1411 if (git__prefixcmp(ref_name, GIT_REFS_DIR) == 0)
1412 fmt = "ref: %s\n";
1413 else
1414 fmt = "ref: " GIT_REFS_HEADS_DIR "%s\n";
1415
1416 if ((error = git_filebuf_printf(&ref, fmt, ref_name)) < 0 ||
1417 (error = git_filebuf_commit(&ref)) < 0)
1418 goto out;
1419
1420 out:
1421 git_buf_dispose(&ref_path);
1422 git_filebuf_cleanup(&ref);
1423 return error;
1424 }
1425
1426 static bool is_chmod_supported(const char *file_path)
1427 {
1428 struct stat st1, st2;
1429
1430 if (p_stat(file_path, &st1) < 0)
1431 return false;
1432
1433 if (p_chmod(file_path, st1.st_mode ^ S_IXUSR) < 0)
1434 return false;
1435
1436 if (p_stat(file_path, &st2) < 0)
1437 return false;
1438
1439 return (st1.st_mode != st2.st_mode);
1440 }
1441
1442 static bool is_filesystem_case_insensitive(const char *gitdir_path)
1443 {
1444 git_buf path = GIT_BUF_INIT;
1445 int is_insensitive = -1;
1446
1447 if (!git_buf_joinpath(&path, gitdir_path, "CoNfIg"))
1448 is_insensitive = git_path_exists(git_buf_cstr(&path));
1449
1450 git_buf_dispose(&path);
1451 return is_insensitive;
1452 }
1453
1454 static bool are_symlinks_supported(const char *wd_path)
1455 {
1456 git_config *config = NULL;
1457 git_buf global_buf = GIT_BUF_INIT;
1458 git_buf xdg_buf = GIT_BUF_INIT;
1459 git_buf system_buf = GIT_BUF_INIT;
1460 git_buf programdata_buf = GIT_BUF_INIT;
1461 int symlinks = 0;
1462
1463 /*
1464 * To emulate Git for Windows, symlinks on Windows must be explicitly
1465 * opted-in. We examine the system configuration for a core.symlinks
1466 * set to true. If found, we then examine the filesystem to see if
1467 * symlinks are _actually_ supported by the current user. If that is
1468 * _not_ set, then we do not test or enable symlink support.
1469 */
1470 #ifdef GIT_WIN32
1471 git_config_find_global(&global_buf);
1472 git_config_find_xdg(&xdg_buf);
1473 git_config_find_system(&system_buf);
1474 git_config_find_programdata(&programdata_buf);
1475
1476 if (load_config(&config, NULL,
1477 path_unless_empty(&global_buf),
1478 path_unless_empty(&xdg_buf),
1479 path_unless_empty(&system_buf),
1480 path_unless_empty(&programdata_buf)) < 0)
1481 goto done;
1482
1483 if (git_config_get_bool(&symlinks, config, "core.symlinks") < 0 || !symlinks)
1484 goto done;
1485 #endif
1486
1487 if (!(symlinks = git_path_supports_symlinks(wd_path)))
1488 goto done;
1489
1490 done:
1491 git_buf_dispose(&global_buf);
1492 git_buf_dispose(&xdg_buf);
1493 git_buf_dispose(&system_buf);
1494 git_buf_dispose(&programdata_buf);
1495 git_config_free(config);
1496 return symlinks != 0;
1497 }
1498
1499 static int create_empty_file(const char *path, mode_t mode)
1500 {
1501 int fd;
1502
1503 if ((fd = p_creat(path, mode)) < 0) {
1504 git_error_set(GIT_ERROR_OS, "error while creating '%s'", path);
1505 return -1;
1506 }
1507
1508 if (p_close(fd) < 0) {
1509 git_error_set(GIT_ERROR_OS, "error while closing '%s'", path);
1510 return -1;
1511 }
1512
1513 return 0;
1514 }
1515
1516 static int repo_local_config(
1517 git_config **out,
1518 git_buf *config_dir,
1519 git_repository *repo,
1520 const char *repo_dir)
1521 {
1522 int error = 0;
1523 git_config *parent;
1524 const char *cfg_path;
1525
1526 if (git_buf_joinpath(config_dir, repo_dir, GIT_CONFIG_FILENAME_INREPO) < 0)
1527 return -1;
1528 cfg_path = git_buf_cstr(config_dir);
1529
1530 /* make LOCAL config if missing */
1531 if (!git_path_isfile(cfg_path) &&
1532 (error = create_empty_file(cfg_path, GIT_CONFIG_FILE_MODE)) < 0)
1533 return error;
1534
1535 /* if no repo, just open that file directly */
1536 if (!repo)
1537 return git_config_open_ondisk(out, cfg_path);
1538
1539 /* otherwise, open parent config and get that level */
1540 if ((error = git_repository_config__weakptr(&parent, repo)) < 0)
1541 return error;
1542
1543 if (git_config_open_level(out, parent, GIT_CONFIG_LEVEL_LOCAL) < 0) {
1544 git_error_clear();
1545
1546 if (!(error = git_config_add_file_ondisk(
1547 parent, cfg_path, GIT_CONFIG_LEVEL_LOCAL, repo, false)))
1548 error = git_config_open_level(out, parent, GIT_CONFIG_LEVEL_LOCAL);
1549 }
1550
1551 git_config_free(parent);
1552
1553 return error;
1554 }
1555
1556 static int repo_init_fs_configs(
1557 git_config *cfg,
1558 const char *cfg_path,
1559 const char *repo_dir,
1560 const char *work_dir,
1561 bool update_ignorecase)
1562 {
1563 int error = 0;
1564
1565 if (!work_dir)
1566 work_dir = repo_dir;
1567
1568 if ((error = git_config_set_bool(
1569 cfg, "core.filemode", is_chmod_supported(cfg_path))) < 0)
1570 return error;
1571
1572 if (!are_symlinks_supported(work_dir)) {
1573 if ((error = git_config_set_bool(cfg, "core.symlinks", false)) < 0)
1574 return error;
1575 } else if (git_config_delete_entry(cfg, "core.symlinks") < 0)
1576 git_error_clear();
1577
1578 if (update_ignorecase) {
1579 if (is_filesystem_case_insensitive(repo_dir)) {
1580 if ((error = git_config_set_bool(cfg, "core.ignorecase", true)) < 0)
1581 return error;
1582 } else if (git_config_delete_entry(cfg, "core.ignorecase") < 0)
1583 git_error_clear();
1584 }
1585
1586 #ifdef GIT_USE_ICONV
1587 if ((error = git_config_set_bool(
1588 cfg, "core.precomposeunicode",
1589 git_path_does_fs_decompose_unicode(work_dir))) < 0)
1590 return error;
1591 /* on non-iconv platforms, don't even set core.precomposeunicode */
1592 #endif
1593
1594 return 0;
1595 }
1596
1597 static int repo_init_config(
1598 const char *repo_dir,
1599 const char *work_dir,
1600 uint32_t flags,
1601 uint32_t mode)
1602 {
1603 int error = 0;
1604 git_buf cfg_path = GIT_BUF_INIT, worktree_path = GIT_BUF_INIT;
1605 git_config *config = NULL;
1606 bool is_bare = ((flags & GIT_REPOSITORY_INIT_BARE) != 0);
1607 bool is_reinit = ((flags & GIT_REPOSITORY_INIT__IS_REINIT) != 0);
1608 int version = 0;
1609
1610 if ((error = repo_local_config(&config, &cfg_path, NULL, repo_dir)) < 0)
1611 goto cleanup;
1612
1613 if (is_reinit && (error = check_repositoryformatversion(&version, config)) < 0)
1614 goto cleanup;
1615
1616 if ((error = check_extensions(config, version)) < 0)
1617 goto cleanup;
1618
1619 #define SET_REPO_CONFIG(TYPE, NAME, VAL) do { \
1620 if ((error = git_config_set_##TYPE(config, NAME, VAL)) < 0) \
1621 goto cleanup; } while (0)
1622
1623 SET_REPO_CONFIG(bool, "core.bare", is_bare);
1624 SET_REPO_CONFIG(int32, "core.repositoryformatversion", GIT_REPO_VERSION);
1625
1626 if ((error = repo_init_fs_configs(
1627 config, cfg_path.ptr, repo_dir, work_dir, !is_reinit)) < 0)
1628 goto cleanup;
1629
1630 if (!is_bare) {
1631 SET_REPO_CONFIG(bool, "core.logallrefupdates", true);
1632
1633 if (!(flags & GIT_REPOSITORY_INIT__NATURAL_WD)) {
1634 if ((error = git_buf_sets(&worktree_path, work_dir)) < 0)
1635 goto cleanup;
1636
1637 if ((flags & GIT_REPOSITORY_INIT_RELATIVE_GITLINK))
1638 if ((error = git_path_make_relative(&worktree_path, repo_dir)) < 0)
1639 goto cleanup;
1640
1641 SET_REPO_CONFIG(string, "core.worktree", worktree_path.ptr);
1642 } else if (is_reinit) {
1643 if (git_config_delete_entry(config, "core.worktree") < 0)
1644 git_error_clear();
1645 }
1646 }
1647
1648 if (mode == GIT_REPOSITORY_INIT_SHARED_GROUP) {
1649 SET_REPO_CONFIG(int32, "core.sharedrepository", 1);
1650 SET_REPO_CONFIG(bool, "receive.denyNonFastforwards", true);
1651 }
1652 else if (mode == GIT_REPOSITORY_INIT_SHARED_ALL) {
1653 SET_REPO_CONFIG(int32, "core.sharedrepository", 2);
1654 SET_REPO_CONFIG(bool, "receive.denyNonFastforwards", true);
1655 }
1656
1657 cleanup:
1658 git_buf_dispose(&cfg_path);
1659 git_buf_dispose(&worktree_path);
1660 git_config_free(config);
1661
1662 return error;
1663 }
1664
1665 static int repo_reinit_submodule_fs(git_submodule *sm, const char *n, void *p)
1666 {
1667 git_repository *smrepo = NULL;
1668 GIT_UNUSED(n); GIT_UNUSED(p);
1669
1670 if (git_submodule_open(&smrepo, sm) < 0 ||
1671 git_repository_reinit_filesystem(smrepo, true) < 0)
1672 git_error_clear();
1673 git_repository_free(smrepo);
1674
1675 return 0;
1676 }
1677
1678 int git_repository_reinit_filesystem(git_repository *repo, int recurse)
1679 {
1680 int error = 0;
1681 git_buf path = GIT_BUF_INIT;
1682 git_config *config = NULL;
1683 const char *repo_dir = git_repository_path(repo);
1684
1685 if (!(error = repo_local_config(&config, &path, repo, repo_dir)))
1686 error = repo_init_fs_configs(
1687 config, path.ptr, repo_dir, git_repository_workdir(repo), true);
1688
1689 git_config_free(config);
1690 git_buf_dispose(&path);
1691
1692 git_repository__configmap_lookup_cache_clear(repo);
1693
1694 if (!repo->is_bare && recurse)
1695 (void)git_submodule_foreach(repo, repo_reinit_submodule_fs, NULL);
1696
1697 return error;
1698 }
1699
1700 static int repo_write_template(
1701 const char *git_dir,
1702 bool allow_overwrite,
1703 const char *file,
1704 mode_t mode,
1705 bool hidden,
1706 const char *content)
1707 {
1708 git_buf path = GIT_BUF_INIT;
1709 int fd, error = 0, flags;
1710
1711 if (git_buf_joinpath(&path, git_dir, file) < 0)
1712 return -1;
1713
1714 if (allow_overwrite)
1715 flags = O_WRONLY | O_CREAT | O_TRUNC;
1716 else
1717 flags = O_WRONLY | O_CREAT | O_EXCL;
1718
1719 fd = p_open(git_buf_cstr(&path), flags, mode);
1720
1721 if (fd >= 0) {
1722 error = p_write(fd, content, strlen(content));
1723
1724 p_close(fd);
1725 }
1726 else if (errno != EEXIST)
1727 error = fd;
1728
1729 #ifdef GIT_WIN32
1730 if (!error && hidden) {
1731 if (git_win32__set_hidden(path.ptr, true) < 0)
1732 error = -1;
1733 }
1734 #else
1735 GIT_UNUSED(hidden);
1736 #endif
1737
1738 git_buf_dispose(&path);
1739
1740 if (error)
1741 git_error_set(GIT_ERROR_OS,
1742 "failed to initialize repository with template '%s'", file);
1743
1744 return error;
1745 }
1746
1747 static int repo_write_gitlink(
1748 const char *in_dir, const char *to_repo, bool use_relative_path)
1749 {
1750 int error;
1751 git_buf buf = GIT_BUF_INIT;
1752 git_buf path_to_repo = GIT_BUF_INIT;
1753 struct stat st;
1754
1755 git_path_dirname_r(&buf, to_repo);
1756 git_path_to_dir(&buf);
1757 if (git_buf_oom(&buf))
1758 return -1;
1759
1760 /* don't write gitlink to natural workdir */
1761 if (git__suffixcmp(to_repo, "/" DOT_GIT "/") == 0 &&
1762 strcmp(in_dir, buf.ptr) == 0)
1763 {
1764 error = GIT_PASSTHROUGH;
1765 goto cleanup;
1766 }
1767
1768 if ((error = git_buf_joinpath(&buf, in_dir, DOT_GIT)) < 0)
1769 goto cleanup;
1770
1771 if (!p_stat(buf.ptr, &st) && !S_ISREG(st.st_mode)) {
1772 git_error_set(GIT_ERROR_REPOSITORY,
1773 "cannot overwrite gitlink file into path '%s'", in_dir);
1774 error = GIT_EEXISTS;
1775 goto cleanup;
1776 }
1777
1778 git_buf_clear(&buf);
1779
1780 error = git_buf_sets(&path_to_repo, to_repo);
1781
1782 if (!error && use_relative_path)
1783 error = git_path_make_relative(&path_to_repo, in_dir);
1784
1785 if (!error)
1786 error = git_buf_join(&buf, ' ', GIT_FILE_CONTENT_PREFIX, path_to_repo.ptr);
1787
1788 if (!error)
1789 error = repo_write_template(in_dir, true, DOT_GIT, 0666, true, buf.ptr);
1790
1791 cleanup:
1792 git_buf_dispose(&buf);
1793 git_buf_dispose(&path_to_repo);
1794 return error;
1795 }
1796
1797 static mode_t pick_dir_mode(git_repository_init_options *opts)
1798 {
1799 if (opts->mode == GIT_REPOSITORY_INIT_SHARED_UMASK)
1800 return 0777;
1801 if (opts->mode == GIT_REPOSITORY_INIT_SHARED_GROUP)
1802 return (0775 | S_ISGID);
1803 if (opts->mode == GIT_REPOSITORY_INIT_SHARED_ALL)
1804 return (0777 | S_ISGID);
1805 return opts->mode;
1806 }
1807
1808 #include "repo_template.h"
1809
1810 static int repo_init_structure(
1811 const char *repo_dir,
1812 const char *work_dir,
1813 git_repository_init_options *opts)
1814 {
1815 int error = 0;
1816 repo_template_item *tpl;
1817 bool external_tpl =
1818 ((opts->flags & GIT_REPOSITORY_INIT_EXTERNAL_TEMPLATE) != 0);
1819 mode_t dmode = pick_dir_mode(opts);
1820 bool chmod = opts->mode != GIT_REPOSITORY_INIT_SHARED_UMASK;
1821
1822 /* Hide the ".git" directory */
1823 #ifdef GIT_WIN32
1824 if ((opts->flags & GIT_REPOSITORY_INIT__HAS_DOTGIT) != 0) {
1825 if (git_win32__set_hidden(repo_dir, true) < 0) {
1826 git_error_set(GIT_ERROR_OS,
1827 "failed to mark Git repository folder as hidden");
1828 return -1;
1829 }
1830 }
1831 #endif
1832
1833 /* Create the .git gitlink if appropriate */
1834 if ((opts->flags & GIT_REPOSITORY_INIT_BARE) == 0 &&
1835 (opts->flags & GIT_REPOSITORY_INIT__NATURAL_WD) == 0)
1836 {
1837 if (repo_write_gitlink(work_dir, repo_dir, opts->flags & GIT_REPOSITORY_INIT_RELATIVE_GITLINK) < 0)
1838 return -1;
1839 }
1840
1841 /* Copy external template if requested */
1842 if (external_tpl) {
1843 git_config *cfg = NULL;
1844 const char *tdir = NULL;
1845 bool default_template = false;
1846 git_buf template_buf = GIT_BUF_INIT;
1847
1848 if (opts->template_path)
1849 tdir = opts->template_path;
1850 else if ((error = git_config_open_default(&cfg)) >= 0) {
1851 if (!git_config_get_path(&template_buf, cfg, "init.templatedir"))
1852 tdir = template_buf.ptr;
1853 git_error_clear();
1854 }
1855
1856 if (!tdir) {
1857 if (!(error = git_sysdir_find_template_dir(&template_buf)))
1858 tdir = template_buf.ptr;
1859 default_template = true;
1860 }
1861
1862 /*
1863 * If tdir was the empty string, treat it like tdir was a path to an
1864 * empty directory (so, don't do any copying). This is the behavior
1865 * that git(1) exhibits, although it doesn't seem to be officially
1866 * documented.
1867 */
1868 if (tdir && git__strcmp(tdir, "") != 0) {
1869 uint32_t cpflags = GIT_CPDIR_COPY_SYMLINKS |
1870 GIT_CPDIR_SIMPLE_TO_MODE |
1871 GIT_CPDIR_COPY_DOTFILES;
1872 if (opts->mode != GIT_REPOSITORY_INIT_SHARED_UMASK)
1873 cpflags |= GIT_CPDIR_CHMOD_DIRS;
1874 error = git_futils_cp_r(tdir, repo_dir, cpflags, dmode);
1875 }
1876
1877 git_buf_dispose(&template_buf);
1878 git_config_free(cfg);
1879
1880 if (error < 0) {
1881 if (!default_template)
1882 return error;
1883
1884 /* if template was default, ignore error and use internal */
1885 git_error_clear();
1886 external_tpl = false;
1887 error = 0;
1888 }
1889 }
1890
1891 /* Copy internal template
1892 * - always ensure existence of dirs
1893 * - only create files if no external template was specified
1894 */
1895 for (tpl = repo_template; !error && tpl->path; ++tpl) {
1896 if (!tpl->content) {
1897 uint32_t mkdir_flags = GIT_MKDIR_PATH;
1898 if (chmod)
1899 mkdir_flags |= GIT_MKDIR_CHMOD;
1900
1901 error = git_futils_mkdir_relative(
1902 tpl->path, repo_dir, dmode, mkdir_flags, NULL);
1903 }
1904 else if (!external_tpl) {
1905 const char *content = tpl->content;
1906
1907 if (opts->description && strcmp(tpl->path, GIT_DESC_FILE) == 0)
1908 content = opts->description;
1909
1910 error = repo_write_template(
1911 repo_dir, false, tpl->path, tpl->mode, false, content);
1912 }
1913 }
1914
1915 return error;
1916 }
1917
1918 static int mkdir_parent(git_buf *buf, uint32_t mode, bool skip2)
1919 {
1920 /* When making parent directories during repository initialization
1921 * don't try to set gid or grant world write access
1922 */
1923 return git_futils_mkdir(
1924 buf->ptr, mode & ~(S_ISGID | 0002),
1925 GIT_MKDIR_PATH | GIT_MKDIR_VERIFY_DIR |
1926 (skip2 ? GIT_MKDIR_SKIP_LAST2 : GIT_MKDIR_SKIP_LAST));
1927 }
1928
1929 static int repo_init_directories(
1930 git_buf *repo_path,
1931 git_buf *wd_path,
1932 const char *given_repo,
1933 git_repository_init_options *opts)
1934 {
1935 int error = 0;
1936 bool is_bare, add_dotgit, has_dotgit, natural_wd;
1937 mode_t dirmode;
1938
1939 /* There are three possible rules for what we are allowed to create:
1940 * - MKPATH means anything we need
1941 * - MKDIR means just the .git directory and its parent and the workdir
1942 * - Neither means only the .git directory can be created
1943 *
1944 * There are 5 "segments" of path that we might need to deal with:
1945 * 1. The .git directory
1946 * 2. The parent of the .git directory
1947 * 3. Everything above the parent of the .git directory
1948 * 4. The working directory (often the same as #2)
1949 * 5. Everything above the working directory (often the same as #3)
1950 *
1951 * For all directories created, we start with the init_mode value for
1952 * permissions and then strip off bits in some cases:
1953 *
1954 * For MKPATH, we create #3 (and #5) paths without S_ISGID or S_IWOTH
1955 * For MKPATH and MKDIR, we create #2 (and #4) without S_ISGID
1956 * For all rules, we create #1 using the untouched init_mode
1957 */
1958
1959 /* set up repo path */
1960
1961 is_bare = ((opts->flags & GIT_REPOSITORY_INIT_BARE) != 0);
1962
1963 add_dotgit =
1964 (opts->flags & GIT_REPOSITORY_INIT_NO_DOTGIT_DIR) == 0 &&
1965 !is_bare &&
1966 git__suffixcmp(given_repo, "/" DOT_GIT) != 0 &&
1967 git__suffixcmp(given_repo, "/" GIT_DIR) != 0;
1968
1969 if (git_buf_joinpath(repo_path, given_repo, add_dotgit ? GIT_DIR : "") < 0)
1970 return -1;
1971
1972 has_dotgit = (git__suffixcmp(repo_path->ptr, "/" GIT_DIR) == 0);
1973 if (has_dotgit)
1974 opts->flags |= GIT_REPOSITORY_INIT__HAS_DOTGIT;
1975
1976 /* set up workdir path */
1977
1978 if (!is_bare) {
1979 if (opts->workdir_path) {
1980 if (git_path_join_unrooted(
1981 wd_path, opts->workdir_path, repo_path->ptr, NULL) < 0)
1982 return -1;
1983 } else if (has_dotgit) {
1984 if (git_path_dirname_r(wd_path, repo_path->ptr) < 0)
1985 return -1;
1986 } else {
1987 git_error_set(GIT_ERROR_REPOSITORY, "cannot pick working directory"
1988 " for non-bare repository that isn't a '.git' directory");
1989 return -1;
1990 }
1991
1992 if (git_path_to_dir(wd_path) < 0)
1993 return -1;
1994 } else {
1995 git_buf_clear(wd_path);
1996 }
1997
1998 natural_wd =
1999 has_dotgit &&
2000 wd_path->size > 0 &&
2001 wd_path->size + strlen(GIT_DIR) == repo_path->size &&
2002 memcmp(repo_path->ptr, wd_path->ptr, wd_path->size) == 0;
2003 if (natural_wd)
2004 opts->flags |= GIT_REPOSITORY_INIT__NATURAL_WD;
2005
2006 /* create directories as needed / requested */
2007
2008 dirmode = pick_dir_mode(opts);
2009
2010 if ((opts->flags & GIT_REPOSITORY_INIT_MKPATH) != 0) {
2011 /* create path #5 */
2012 if (wd_path->size > 0 &&
2013 (error = mkdir_parent(wd_path, dirmode, false)) < 0)
2014 return error;
2015
2016 /* create path #3 (if not the same as #5) */
2017 if (!natural_wd &&
2018 (error = mkdir_parent(repo_path, dirmode, has_dotgit)) < 0)
2019 return error;
2020 }
2021
2022 if ((opts->flags & GIT_REPOSITORY_INIT_MKDIR) != 0 ||
2023 (opts->flags & GIT_REPOSITORY_INIT_MKPATH) != 0)
2024 {
2025 /* create path #4 */
2026 if (wd_path->size > 0 &&
2027 (error = git_futils_mkdir(
2028 wd_path->ptr, dirmode & ~S_ISGID,
2029 GIT_MKDIR_VERIFY_DIR)) < 0)
2030 return error;
2031
2032 /* create path #2 (if not the same as #4) */
2033 if (!natural_wd &&
2034 (error = git_futils_mkdir(
2035 repo_path->ptr, dirmode & ~S_ISGID,
2036 GIT_MKDIR_VERIFY_DIR | GIT_MKDIR_SKIP_LAST)) < 0)
2037 return error;
2038 }
2039
2040 if ((opts->flags & GIT_REPOSITORY_INIT_MKDIR) != 0 ||
2041 (opts->flags & GIT_REPOSITORY_INIT_MKPATH) != 0 ||
2042 has_dotgit)
2043 {
2044 /* create path #1 */
2045 error = git_futils_mkdir(repo_path->ptr, dirmode,
2046 GIT_MKDIR_VERIFY_DIR | ((dirmode & S_ISGID) ? GIT_MKDIR_CHMOD : 0));
2047 }
2048
2049 /* prettify both directories now that they are created */
2050
2051 if (!error) {
2052 error = git_path_prettify_dir(repo_path, repo_path->ptr, NULL);
2053
2054 if (!error && wd_path->size > 0)
2055 error = git_path_prettify_dir(wd_path, wd_path->ptr, NULL);
2056 }
2057
2058 return error;
2059 }
2060
2061 static int repo_init_head(const char *repo_dir, const char *given)
2062 {
2063 git_config *cfg = NULL;
2064 git_buf head_path = GIT_BUF_INIT, cfg_branch = GIT_BUF_INIT;
2065 const char *initial_head = NULL;
2066 int error;
2067
2068 if ((error = git_buf_joinpath(&head_path, repo_dir, GIT_HEAD_FILE)) < 0)
2069 goto out;
2070
2071 /*
2072 * A template may have set a HEAD; use that unless it's been
2073 * overridden by the caller's given initial head setting.
2074 */
2075 if (git_path_exists(head_path.ptr) && !given)
2076 goto out;
2077
2078 if (given) {
2079 initial_head = given;
2080 } else if ((error = git_config_open_default(&cfg)) >= 0 &&
2081 (error = git_config_get_string_buf(&cfg_branch, cfg, "init.defaultbranch")) >= 0) {
2082 initial_head = cfg_branch.ptr;
2083 }
2084
2085 if (!initial_head)
2086 initial_head = GIT_BRANCH_DEFAULT;
2087
2088 error = git_repository_create_head(repo_dir, initial_head);
2089
2090 out:
2091 git_config_free(cfg);
2092 git_buf_dispose(&head_path);
2093 git_buf_dispose(&cfg_branch);
2094
2095 return error;
2096 }
2097
2098 static int repo_init_create_origin(git_repository *repo, const char *url)
2099 {
2100 int error;
2101 git_remote *remote;
2102
2103 if (!(error = git_remote_create(&remote, repo, GIT_REMOTE_ORIGIN, url))) {
2104 git_remote_free(remote);
2105 }
2106
2107 return error;
2108 }
2109
2110 int git_repository_init(
2111 git_repository **repo_out, const char *path, unsigned is_bare)
2112 {
2113 git_repository_init_options opts = GIT_REPOSITORY_INIT_OPTIONS_INIT;
2114
2115 opts.flags = GIT_REPOSITORY_INIT_MKPATH; /* don't love this default */
2116 if (is_bare)
2117 opts.flags |= GIT_REPOSITORY_INIT_BARE;
2118
2119 return git_repository_init_ext(repo_out, path, &opts);
2120 }
2121
2122 int git_repository_init_ext(
2123 git_repository **out,
2124 const char *given_repo,
2125 git_repository_init_options *opts)
2126 {
2127 git_buf repo_path = GIT_BUF_INIT, wd_path = GIT_BUF_INIT,
2128 common_path = GIT_BUF_INIT;
2129 const char *wd;
2130 bool is_valid;
2131 int error;
2132
2133 assert(out && given_repo && opts);
2134
2135 GIT_ERROR_CHECK_VERSION(opts, GIT_REPOSITORY_INIT_OPTIONS_VERSION, "git_repository_init_options");
2136
2137 if ((error = repo_init_directories(&repo_path, &wd_path, given_repo, opts)) < 0)
2138 goto out;
2139
2140 wd = (opts->flags & GIT_REPOSITORY_INIT_BARE) ? NULL : git_buf_cstr(&wd_path);
2141
2142 if ((error = is_valid_repository_path(&is_valid, &repo_path, &common_path)) < 0)
2143 goto out;
2144
2145 if (is_valid) {
2146 if ((opts->flags & GIT_REPOSITORY_INIT_NO_REINIT) != 0) {
2147 git_error_set(GIT_ERROR_REPOSITORY,
2148 "attempt to reinitialize '%s'", given_repo);
2149 error = GIT_EEXISTS;
2150 goto out;
2151 }
2152
2153 opts->flags |= GIT_REPOSITORY_INIT__IS_REINIT;
2154
2155 if ((error = repo_init_config(repo_path.ptr, wd, opts->flags, opts->mode)) < 0)
2156 goto out;
2157
2158 /* TODO: reinitialize the templates */
2159 } else {
2160 if ((error = repo_init_structure(repo_path.ptr, wd, opts)) < 0 ||
2161 (error = repo_init_config(repo_path.ptr, wd, opts->flags, opts->mode)) < 0 ||
2162 (error = repo_init_head(repo_path.ptr, opts->initial_head)) < 0)
2163 goto out;
2164 }
2165
2166 if ((error = git_repository_open(out, repo_path.ptr)) < 0)
2167 goto out;
2168
2169 if (opts->origin_url &&
2170 (error = repo_init_create_origin(*out, opts->origin_url)) < 0)
2171 goto out;
2172
2173 out:
2174 git_buf_dispose(&common_path);
2175 git_buf_dispose(&repo_path);
2176 git_buf_dispose(&wd_path);
2177
2178 return error;
2179 }
2180
2181 int git_repository_head_detached(git_repository *repo)
2182 {
2183 git_reference *ref;
2184 git_odb *odb = NULL;
2185 int exists;
2186
2187 if (git_repository_odb__weakptr(&odb, repo) < 0)
2188 return -1;
2189
2190 if (git_reference_lookup(&ref, repo, GIT_HEAD_FILE) < 0)
2191 return -1;
2192
2193 if (git_reference_type(ref) == GIT_REFERENCE_SYMBOLIC) {
2194 git_reference_free(ref);
2195 return 0;
2196 }
2197
2198 exists = git_odb_exists(odb, git_reference_target(ref));
2199
2200 git_reference_free(ref);
2201 return exists;
2202 }
2203
2204 int git_repository_head_detached_for_worktree(git_repository *repo, const char *name)
2205 {
2206 git_reference *ref = NULL;
2207 int error;
2208
2209 assert(repo && name);
2210
2211 if ((error = git_repository_head_for_worktree(&ref, repo, name)) < 0)
2212 goto out;
2213
2214 error = (git_reference_type(ref) != GIT_REFERENCE_SYMBOLIC);
2215 out:
2216 git_reference_free(ref);
2217
2218 return error;
2219 }
2220
2221 int git_repository_head(git_reference **head_out, git_repository *repo)
2222 {
2223 git_reference *head;
2224 int error;
2225
2226 assert(head_out);
2227
2228 if ((error = git_reference_lookup(&head, repo, GIT_HEAD_FILE)) < 0)
2229 return error;
2230
2231 if (git_reference_type(head) == GIT_REFERENCE_DIRECT) {
2232 *head_out = head;
2233 return 0;
2234 }
2235
2236 error = git_reference_lookup_resolved(head_out, repo, git_reference_symbolic_target(head), -1);
2237 git_reference_free(head);
2238
2239 return error == GIT_ENOTFOUND ? GIT_EUNBORNBRANCH : error;
2240 }
2241
2242 int git_repository_head_for_worktree(git_reference **out, git_repository *repo, const char *name)
2243 {
2244 git_repository *worktree_repo = NULL;
2245 git_worktree *worktree = NULL;
2246 git_reference *head = NULL;
2247 int error;
2248
2249 assert(out && repo && name);
2250
2251 *out = NULL;
2252
2253 if ((error = git_worktree_lookup(&worktree, repo, name)) < 0 ||
2254 (error = git_repository_open_from_worktree(&worktree_repo, worktree)) < 0 ||
2255 (error = git_reference_lookup(&head, worktree_repo, GIT_HEAD_FILE)) < 0)
2256 goto out;
2257
2258 if (git_reference_type(head) != GIT_REFERENCE_DIRECT) {
2259 if ((error = git_reference_lookup_resolved(out, worktree_repo, git_reference_symbolic_target(head), -1)) < 0)
2260 goto out;
2261 } else {
2262 *out = head;
2263 head = NULL;
2264 }
2265
2266 out:
2267 git_reference_free(head);
2268 git_worktree_free(worktree);
2269 git_repository_free(worktree_repo);
2270 return error;
2271 }
2272
2273 int git_repository_foreach_worktree(git_repository *repo,
2274 git_repository_foreach_worktree_cb cb,
2275 void *payload)
2276 {
2277 git_strarray worktrees = {0};
2278 git_repository *worktree_repo = NULL;
2279 git_worktree *worktree = NULL;
2280 int error;
2281 size_t i;
2282
2283 if ((error = git_repository_open(&worktree_repo, repo->commondir)) < 0 ||
2284 (error = cb(worktree_repo, payload) != 0))
2285 goto out;
2286
2287 git_repository_free(worktree_repo);
2288 worktree_repo = NULL;
2289
2290 if ((error = git_worktree_list(&worktrees, repo)) < 0)
2291 goto out;
2292
2293 for (i = 0; i < worktrees.count; i++) {
2294 git_repository_free(worktree_repo);
2295 worktree_repo = NULL;
2296 git_worktree_free(worktree);
2297 worktree = NULL;
2298
2299 if ((error = git_worktree_lookup(&worktree, repo, worktrees.strings[i]) < 0) ||
2300 (error = git_repository_open_from_worktree(&worktree_repo, worktree)) < 0) {
2301 if (error != GIT_ENOTFOUND)
2302 goto out;
2303 error = 0;
2304 continue;
2305 }
2306
2307 if ((error = cb(worktree_repo, payload)) != 0)
2308 goto out;
2309 }
2310
2311 out:
2312 git_strarray_dispose(&worktrees);
2313 git_repository_free(worktree_repo);
2314 git_worktree_free(worktree);
2315 return error;
2316 }
2317
2318 int git_repository_head_unborn(git_repository *repo)
2319 {
2320 git_reference *ref = NULL;
2321 int error;
2322
2323 error = git_repository_head(&ref, repo);
2324 git_reference_free(ref);
2325
2326 if (error == GIT_EUNBORNBRANCH) {
2327 git_error_clear();
2328 return 1;
2329 }
2330
2331 if (error < 0)
2332 return -1;
2333
2334 return 0;
2335 }
2336
2337 static int at_least_one_cb(const char *refname, void *payload)
2338 {
2339 GIT_UNUSED(refname);
2340 GIT_UNUSED(payload);
2341 return GIT_PASSTHROUGH;
2342 }
2343
2344 static int repo_contains_no_reference(git_repository *repo)
2345 {
2346 int error = git_reference_foreach_name(repo, &at_least_one_cb, NULL);
2347
2348 if (error == GIT_PASSTHROUGH)
2349 return 0;
2350
2351 if (!error)
2352 return 1;
2353
2354 return error;
2355 }
2356
2357 int git_repository_initialbranch(git_buf *out, git_repository *repo)
2358 {
2359 git_config *config;
2360 git_config_entry *entry = NULL;
2361 const char *branch;
2362 int error;
2363
2364 if ((error = git_repository_config__weakptr(&config, repo)) < 0)
2365 return error;
2366
2367 if ((error = git_config_get_entry(&entry, config, "init.defaultbranch")) == 0) {
2368 branch = entry->value;
2369 }
2370 else if (error == GIT_ENOTFOUND) {
2371 branch = GIT_BRANCH_DEFAULT;
2372 }
2373 else {
2374 goto done;
2375 }
2376
2377 if ((error = git_buf_puts(out, GIT_REFS_HEADS_DIR)) < 0 ||
2378 (error = git_buf_puts(out, branch)) < 0)
2379 goto done;
2380
2381 if (!git_reference_is_valid_name(out->ptr)) {
2382 git_error_set(GIT_ERROR_INVALID, "the value of init.defaultBranch is not a valid reference name");
2383 error = -1;
2384 }
2385
2386 done:
2387 git_config_entry_free(entry);
2388 return error;
2389 }
2390
2391 int git_repository_is_empty(git_repository *repo)
2392 {
2393 git_reference *head = NULL;
2394 git_buf initialbranch = GIT_BUF_INIT;
2395 int result = 0;
2396
2397 if ((result = git_reference_lookup(&head, repo, GIT_HEAD_FILE)) < 0 ||
2398 (result = git_repository_initialbranch(&initialbranch, repo)) < 0)
2399 goto done;
2400
2401 result = (git_reference_type(head) == GIT_REFERENCE_SYMBOLIC &&
2402 strcmp(git_reference_symbolic_target(head), initialbranch.ptr) == 0 &&
2403 repo_contains_no_reference(repo));
2404
2405 done:
2406 git_reference_free(head);
2407 git_buf_dispose(&initialbranch);
2408
2409 return result;
2410 }
2411
2412 static const char *resolved_parent_path(const git_repository *repo, git_repository_item_t item, git_repository_item_t fallback)
2413 {
2414 const char *parent;
2415
2416 switch (item) {
2417 case GIT_REPOSITORY_ITEM_GITDIR:
2418 parent = git_repository_path(repo);
2419 break;
2420 case GIT_REPOSITORY_ITEM_WORKDIR:
2421 parent = git_repository_workdir(repo);
2422 break;
2423 case GIT_REPOSITORY_ITEM_COMMONDIR:
2424 parent = git_repository_commondir(repo);
2425 break;
2426 default:
2427 git_error_set(GIT_ERROR_INVALID, "invalid item directory");
2428 return NULL;
2429 }
2430 if (!parent && fallback != GIT_REPOSITORY_ITEM__LAST)
2431 return resolved_parent_path(repo, fallback, GIT_REPOSITORY_ITEM__LAST);
2432
2433 return parent;
2434 }
2435
2436 int git_repository_item_path(git_buf *out, const git_repository *repo, git_repository_item_t item)
2437 {
2438 const char *parent = resolved_parent_path(repo, items[item].parent, items[item].fallback);
2439 if (parent == NULL) {
2440 git_error_set(GIT_ERROR_INVALID, "path cannot exist in repository");
2441 return GIT_ENOTFOUND;
2442 }
2443
2444 if (git_buf_sets(out, parent) < 0)
2445 return -1;
2446
2447 if (items[item].name) {
2448 if (git_buf_joinpath(out, parent, items[item].name) < 0)
2449 return -1;
2450 }
2451
2452 if (items[item].directory) {
2453 if (git_path_to_dir(out) < 0)
2454 return -1;
2455 }
2456
2457 return 0;
2458 }
2459
2460 const char *git_repository_path(const git_repository *repo)
2461 {
2462 assert(repo);
2463 return repo->gitdir;
2464 }
2465
2466 const char *git_repository_workdir(const git_repository *repo)
2467 {
2468 assert(repo);
2469
2470 if (repo->is_bare)
2471 return NULL;
2472
2473 return repo->workdir;
2474 }
2475
2476 const char *git_repository_commondir(const git_repository *repo)
2477 {
2478 assert(repo);
2479 return repo->commondir;
2480 }
2481
2482 int git_repository_set_workdir(
2483 git_repository *repo, const char *workdir, int update_gitlink)
2484 {
2485 int error = 0;
2486 git_buf path = GIT_BUF_INIT;
2487
2488 assert(repo && workdir);
2489
2490 if (git_path_prettify_dir(&path, workdir, NULL) < 0)
2491 return -1;
2492
2493 if (repo->workdir && strcmp(repo->workdir, path.ptr) == 0)
2494 return 0;
2495
2496 if (update_gitlink) {
2497 git_config *config;
2498
2499 if (git_repository_config__weakptr(&config, repo) < 0)
2500 return -1;
2501
2502 error = repo_write_gitlink(path.ptr, git_repository_path(repo), false);
2503
2504 /* passthrough error means gitlink is unnecessary */
2505 if (error == GIT_PASSTHROUGH)
2506 error = git_config_delete_entry(config, "core.worktree");
2507 else if (!error)
2508 error = git_config_set_string(config, "core.worktree", path.ptr);
2509
2510 if (!error)
2511 error = git_config_set_bool(config, "core.bare", false);
2512 }
2513
2514 if (!error) {
2515 char *old_workdir = repo->workdir;
2516
2517 repo->workdir = git_buf_detach(&path);
2518 repo->is_bare = 0;
2519
2520 git__free(old_workdir);
2521 }
2522
2523 return error;
2524 }
2525
2526 int git_repository_is_bare(const git_repository *repo)
2527 {
2528 assert(repo);
2529 return repo->is_bare;
2530 }
2531
2532 int git_repository_is_worktree(const git_repository *repo)
2533 {
2534 assert(repo);
2535 return repo->is_worktree;
2536 }
2537
2538 int git_repository_set_bare(git_repository *repo)
2539 {
2540 int error;
2541 git_config *config;
2542
2543 assert(repo);
2544
2545 if (repo->is_bare)
2546 return 0;
2547
2548 if ((error = git_repository_config__weakptr(&config, repo)) < 0)
2549 return error;
2550
2551 if ((error = git_config_set_bool(config, "core.bare", true)) < 0)
2552 return error;
2553
2554 if ((error = git_config__update_entry(config, "core.worktree", NULL, true, true)) < 0)
2555 return error;
2556
2557 git__free(repo->workdir);
2558 repo->workdir = NULL;
2559 repo->is_bare = 1;
2560
2561 return 0;
2562 }
2563
2564 int git_repository_head_tree(git_tree **tree, git_repository *repo)
2565 {
2566 git_reference *head;
2567 git_object *obj;
2568 int error;
2569
2570 if ((error = git_repository_head(&head, repo)) < 0)
2571 return error;
2572
2573 if ((error = git_reference_peel(&obj, head, GIT_OBJECT_TREE)) < 0)
2574 goto cleanup;
2575
2576 *tree = (git_tree *)obj;
2577
2578 cleanup:
2579 git_reference_free(head);
2580 return error;
2581 }
2582
2583 int git_repository__set_orig_head(git_repository *repo, const git_oid *orig_head)
2584 {
2585 git_filebuf file = GIT_FILEBUF_INIT;
2586 git_buf file_path = GIT_BUF_INIT;
2587 char orig_head_str[GIT_OID_HEXSZ];
2588 int error = 0;
2589
2590 git_oid_fmt(orig_head_str, orig_head);
2591
2592 if ((error = git_buf_joinpath(&file_path, repo->gitdir, GIT_ORIG_HEAD_FILE)) == 0 &&
2593 (error = git_filebuf_open(&file, file_path.ptr, GIT_FILEBUF_CREATE_LEADING_DIRS, GIT_MERGE_FILE_MODE)) == 0 &&
2594 (error = git_filebuf_printf(&file, "%.*s\n", GIT_OID_HEXSZ, orig_head_str)) == 0)
2595 error = git_filebuf_commit(&file);
2596
2597 if (error < 0)
2598 git_filebuf_cleanup(&file);
2599
2600 git_buf_dispose(&file_path);
2601
2602 return error;
2603 }
2604
2605 int git_repository_message(git_buf *out, git_repository *repo)
2606 {
2607 git_buf path = GIT_BUF_INIT;
2608 struct stat st;
2609 int error;
2610
2611 git_buf_sanitize(out);
2612
2613 if (git_buf_joinpath(&path, repo->gitdir, GIT_MERGE_MSG_FILE) < 0)
2614 return -1;
2615
2616 if ((error = p_stat(git_buf_cstr(&path), &st)) < 0) {
2617 if (errno == ENOENT)
2618 error = GIT_ENOTFOUND;
2619 git_error_set(GIT_ERROR_OS, "could not access message file");
2620 } else {
2621 error = git_futils_readbuffer(out, git_buf_cstr(&path));
2622 }
2623
2624 git_buf_dispose(&path);
2625
2626 return error;
2627 }
2628
2629 int git_repository_message_remove(git_repository *repo)
2630 {
2631 git_buf path = GIT_BUF_INIT;
2632 int error;
2633
2634 if (git_buf_joinpath(&path, repo->gitdir, GIT_MERGE_MSG_FILE) < 0)
2635 return -1;
2636
2637 error = p_unlink(git_buf_cstr(&path));
2638 git_buf_dispose(&path);
2639
2640 return error;
2641 }
2642
2643 int git_repository_hashfile(
2644 git_oid *out,
2645 git_repository *repo,
2646 const char *path,
2647 git_object_t type,
2648 const char *as_path)
2649 {
2650 int error;
2651 git_filter_list *fl = NULL;
2652 git_file fd = -1;
2653 uint64_t len;
2654 git_buf full_path = GIT_BUF_INIT;
2655
2656 assert(out && path && repo); /* as_path can be NULL */
2657
2658 /* At some point, it would be nice if repo could be NULL to just
2659 * apply filter rules defined in system and global files, but for
2660 * now that is not possible because git_filters_load() needs it.
2661 */
2662
2663 error = git_path_join_unrooted(
2664 &full_path, path, git_repository_workdir(repo), NULL);
2665 if (error < 0)
2666 return error;
2667
2668 if (!as_path)
2669 as_path = path;
2670
2671 /* passing empty string for "as_path" indicated --no-filters */
2672 if (strlen(as_path) > 0) {
2673 error = git_filter_list_load(
2674 &fl, repo, NULL, as_path,
2675 GIT_FILTER_TO_ODB, GIT_FILTER_DEFAULT);
2676 if (error < 0)
2677 return error;
2678 } else {
2679 error = 0;
2680 }
2681
2682 /* at this point, error is a count of the number of loaded filters */
2683
2684 fd = git_futils_open_ro(full_path.ptr);
2685 if (fd < 0) {
2686 error = fd;
2687 goto cleanup;
2688 }
2689
2690 if ((error = git_futils_filesize(&len, fd)) < 0)
2691 goto cleanup;
2692
2693 if (!git__is_sizet(len)) {
2694 git_error_set(GIT_ERROR_OS, "file size overflow for 32-bit systems");
2695 error = -1;
2696 goto cleanup;
2697 }
2698
2699 error = git_odb__hashfd_filtered(out, fd, (size_t)len, type, fl);
2700
2701 cleanup:
2702 if (fd >= 0)
2703 p_close(fd);
2704 git_filter_list_free(fl);
2705 git_buf_dispose(&full_path);
2706
2707 return error;
2708 }
2709
2710 static int checkout_message(git_buf *out, git_reference *old, const char *new)
2711 {
2712 git_buf_puts(out, "checkout: moving from ");
2713
2714 if (git_reference_type(old) == GIT_REFERENCE_SYMBOLIC)
2715 git_buf_puts(out, git_reference__shorthand(git_reference_symbolic_target(old)));
2716 else
2717 git_buf_puts(out, git_oid_tostr_s(git_reference_target(old)));
2718
2719 git_buf_puts(out, " to ");
2720
2721 if (git_reference__is_branch(new) ||
2722 git_reference__is_tag(new) ||
2723 git_reference__is_remote(new))
2724 git_buf_puts(out, git_reference__shorthand(new));
2725 else
2726 git_buf_puts(out, new);
2727
2728 if (git_buf_oom(out))
2729 return -1;
2730
2731 return 0;
2732 }
2733
2734 static int detach(git_repository *repo, const git_oid *id, const char *new)
2735 {
2736 int error;
2737 git_buf log_message = GIT_BUF_INIT;
2738 git_object *object = NULL, *peeled = NULL;
2739 git_reference *new_head = NULL, *current = NULL;
2740
2741 assert(repo && id);
2742
2743 if ((error = git_reference_lookup(&current, repo, GIT_HEAD_FILE)) < 0)
2744 return error;
2745
2746 if ((error = git_object_lookup(&object, repo, id, GIT_OBJECT_ANY)) < 0)
2747 goto cleanup;
2748
2749 if ((error = git_object_peel(&peeled, object, GIT_OBJECT_COMMIT)) < 0)
2750 goto cleanup;
2751
2752 if (new == NULL)
2753 new = git_oid_tostr_s(git_object_id(peeled));
2754
2755 if ((error = checkout_message(&log_message, current, new)) < 0)
2756 goto cleanup;
2757
2758 error = git_reference_create(&new_head, repo, GIT_HEAD_FILE, git_object_id(peeled), true, git_buf_cstr(&log_message));
2759
2760 cleanup:
2761 git_buf_dispose(&log_message);
2762 git_object_free(object);
2763 git_object_free(peeled);
2764 git_reference_free(current);
2765 git_reference_free(new_head);
2766 return error;
2767 }
2768
2769 int git_repository_set_head(
2770 git_repository* repo,
2771 const char* refname)
2772 {
2773 git_reference *ref = NULL, *current = NULL, *new_head = NULL;
2774 git_buf log_message = GIT_BUF_INIT;
2775 int error;
2776
2777 assert(repo && refname);
2778
2779 if ((error = git_reference_lookup(&current, repo, GIT_HEAD_FILE)) < 0)
2780 return error;
2781
2782 if ((error = checkout_message(&log_message, current, refname)) < 0)
2783 goto cleanup;
2784
2785 error = git_reference_lookup(&ref, repo, refname);
2786 if (error < 0 && error != GIT_ENOTFOUND)
2787 goto cleanup;
2788
2789 if (ref && current->type == GIT_REFERENCE_SYMBOLIC && git__strcmp(current->target.symbolic, ref->name) &&
2790 git_reference_is_branch(ref) && git_branch_is_checked_out(ref)) {
2791 git_error_set(GIT_ERROR_REPOSITORY, "cannot set HEAD to reference '%s' as it is the current HEAD "
2792 "of a linked repository.", git_reference_name(ref));
2793 error = -1;
2794 goto cleanup;
2795 }
2796
2797 if (!error) {
2798 if (git_reference_is_branch(ref)) {
2799 error = git_reference_symbolic_create(&new_head, repo, GIT_HEAD_FILE,
2800 git_reference_name(ref), true, git_buf_cstr(&log_message));
2801 } else {
2802 error = detach(repo, git_reference_target(ref),
2803 git_reference_is_tag(ref) || git_reference_is_remote(ref) ? refname : NULL);
2804 }
2805 } else if (git_reference__is_branch(refname)) {
2806 error = git_reference_symbolic_create(&new_head, repo, GIT_HEAD_FILE, refname,
2807 true, git_buf_cstr(&log_message));
2808 }
2809
2810 cleanup:
2811 git_buf_dispose(&log_message);
2812 git_reference_free(current);
2813 git_reference_free(ref);
2814 git_reference_free(new_head);
2815 return error;
2816 }
2817
2818 int git_repository_set_head_detached(
2819 git_repository* repo,
2820 const git_oid* commitish)
2821 {
2822 return detach(repo, commitish, NULL);
2823 }
2824
2825 int git_repository_set_head_detached_from_annotated(
2826 git_repository *repo,
2827 const git_annotated_commit *commitish)
2828 {
2829 assert(repo && commitish);
2830
2831 return detach(repo, git_annotated_commit_id(commitish), commitish->description);
2832 }
2833
2834 int git_repository_detach_head(git_repository* repo)
2835 {
2836 git_reference *old_head = NULL, *new_head = NULL, *current = NULL;
2837 git_object *object = NULL;
2838 git_buf log_message = GIT_BUF_INIT;
2839 int error;
2840
2841 assert(repo);
2842
2843 if ((error = git_reference_lookup(&current, repo, GIT_HEAD_FILE)) < 0)
2844 return error;
2845
2846 if ((error = git_repository_head(&old_head, repo)) < 0)
2847 goto cleanup;
2848
2849 if ((error = git_object_lookup(&object, repo, git_reference_target(old_head), GIT_OBJECT_COMMIT)) < 0)
2850 goto cleanup;
2851
2852 if ((error = checkout_message(&log_message, current, git_oid_tostr_s(git_object_id(object)))) < 0)
2853 goto cleanup;
2854
2855 error = git_reference_create(&new_head, repo, GIT_HEAD_FILE, git_reference_target(old_head),
2856 1, git_buf_cstr(&log_message));
2857
2858 cleanup:
2859 git_buf_dispose(&log_message);
2860 git_object_free(object);
2861 git_reference_free(old_head);
2862 git_reference_free(new_head);
2863 git_reference_free(current);
2864 return error;
2865 }
2866
2867 /**
2868 * Loosely ported from git.git
2869 * https://github.com/git/git/blob/master/contrib/completion/git-prompt.sh#L198-289
2870 */
2871 int git_repository_state(git_repository *repo)
2872 {
2873 git_buf repo_path = GIT_BUF_INIT;
2874 int state = GIT_REPOSITORY_STATE_NONE;
2875
2876 assert(repo);
2877
2878 if (git_buf_puts(&repo_path, repo->gitdir) < 0)
2879 return -1;
2880
2881 if (git_path_contains_file(&repo_path, GIT_REBASE_MERGE_INTERACTIVE_FILE))
2882 state = GIT_REPOSITORY_STATE_REBASE_INTERACTIVE;
2883 else if (git_path_contains_dir(&repo_path, GIT_REBASE_MERGE_DIR))
2884 state = GIT_REPOSITORY_STATE_REBASE_MERGE;
2885 else if (git_path_contains_file(&repo_path, GIT_REBASE_APPLY_REBASING_FILE))
2886 state = GIT_REPOSITORY_STATE_REBASE;
2887 else if (git_path_contains_file(&repo_path, GIT_REBASE_APPLY_APPLYING_FILE))
2888 state = GIT_REPOSITORY_STATE_APPLY_MAILBOX;
2889 else if (git_path_contains_dir(&repo_path, GIT_REBASE_APPLY_DIR))
2890 state = GIT_REPOSITORY_STATE_APPLY_MAILBOX_OR_REBASE;
2891 else if (git_path_contains_file(&repo_path, GIT_MERGE_HEAD_FILE))
2892 state = GIT_REPOSITORY_STATE_MERGE;
2893 else if (git_path_contains_file(&repo_path, GIT_REVERT_HEAD_FILE)) {
2894 state = GIT_REPOSITORY_STATE_REVERT;
2895 if (git_path_contains_file(&repo_path, GIT_SEQUENCER_TODO_FILE)) {
2896 state = GIT_REPOSITORY_STATE_REVERT_SEQUENCE;
2897 }
2898 } else if (git_path_contains_file(&repo_path, GIT_CHERRYPICK_HEAD_FILE)) {
2899 state = GIT_REPOSITORY_STATE_CHERRYPICK;
2900 if (git_path_contains_file(&repo_path, GIT_SEQUENCER_TODO_FILE)) {
2901 state = GIT_REPOSITORY_STATE_CHERRYPICK_SEQUENCE;
2902 }
2903 } else if (git_path_contains_file(&repo_path, GIT_BISECT_LOG_FILE))
2904 state = GIT_REPOSITORY_STATE_BISECT;
2905
2906 git_buf_dispose(&repo_path);
2907 return state;
2908 }
2909
2910 int git_repository__cleanup_files(
2911 git_repository *repo, const char *files[], size_t files_len)
2912 {
2913 git_buf buf = GIT_BUF_INIT;
2914 size_t i;
2915 int error;
2916
2917 for (error = 0, i = 0; !error && i < files_len; ++i) {
2918 const char *path;
2919
2920 if (git_buf_joinpath(&buf, repo->gitdir, files[i]) < 0)
2921 return -1;
2922
2923 path = git_buf_cstr(&buf);
2924
2925 if (git_path_isfile(path)) {
2926 error = p_unlink(path);
2927 } else if (git_path_isdir(path)) {
2928 error = git_futils_rmdir_r(path, NULL,
2929 GIT_RMDIR_REMOVE_FILES | GIT_RMDIR_REMOVE_BLOCKERS);
2930 }
2931
2932 git_buf_clear(&buf);
2933 }
2934
2935 git_buf_dispose(&buf);
2936 return error;
2937 }
2938
2939 static const char *state_files[] = {
2940 GIT_MERGE_HEAD_FILE,
2941 GIT_MERGE_MODE_FILE,
2942 GIT_MERGE_MSG_FILE,
2943 GIT_REVERT_HEAD_FILE,
2944 GIT_CHERRYPICK_HEAD_FILE,
2945 GIT_BISECT_LOG_FILE,
2946 GIT_REBASE_MERGE_DIR,
2947 GIT_REBASE_APPLY_DIR,
2948 GIT_SEQUENCER_DIR,
2949 };
2950
2951 int git_repository_state_cleanup(git_repository *repo)
2952 {
2953 assert(repo);
2954
2955 return git_repository__cleanup_files(repo, state_files, ARRAY_SIZE(state_files));
2956 }
2957
2958 int git_repository_is_shallow(git_repository *repo)
2959 {
2960 git_buf path = GIT_BUF_INIT;
2961 struct stat st;
2962 int error;
2963
2964 if ((error = git_buf_joinpath(&path, repo->gitdir, "shallow")) < 0)
2965 return error;
2966
2967 error = git_path_lstat(path.ptr, &st);
2968 git_buf_dispose(&path);
2969
2970 if (error == GIT_ENOTFOUND) {
2971 git_error_clear();
2972 return 0;
2973 }
2974
2975 if (error < 0)
2976 return error;
2977 return st.st_size == 0 ? 0 : 1;
2978 }
2979
2980 int git_repository_init_options_init(
2981 git_repository_init_options *opts, unsigned int version)
2982 {
2983 GIT_INIT_STRUCTURE_FROM_TEMPLATE(
2984 opts, version, git_repository_init_options,
2985 GIT_REPOSITORY_INIT_OPTIONS_INIT);
2986 return 0;
2987 }
2988
2989 #ifndef GIT_DEPRECATE_HARD
2990 int git_repository_init_init_options(
2991 git_repository_init_options *opts, unsigned int version)
2992 {
2993 return git_repository_init_options_init(opts, version);
2994 }
2995 #endif
2996
2997 int git_repository_ident(const char **name, const char **email, const git_repository *repo)
2998 {
2999 *name = repo->ident_name;
3000 *email = repo->ident_email;
3001
3002 return 0;
3003 }
3004
3005 int git_repository_set_ident(git_repository *repo, const char *name, const char *email)
3006 {
3007 char *tmp_name = NULL, *tmp_email = NULL;
3008
3009 if (name) {
3010 tmp_name = git__strdup(name);
3011 GIT_ERROR_CHECK_ALLOC(tmp_name);
3012 }
3013
3014 if (email) {
3015 tmp_email = git__strdup(email);
3016 GIT_ERROR_CHECK_ALLOC(tmp_email);
3017 }
3018
3019 tmp_name = git__swap(repo->ident_name, tmp_name);
3020 tmp_email = git__swap(repo->ident_email, tmp_email);
3021
3022 git__free(tmp_name);
3023 git__free(tmp_email);
3024
3025 return 0;
3026 }
3027
3028 int git_repository_submodule_cache_all(git_repository *repo)
3029 {
3030 int error;
3031
3032 assert(repo);
3033
3034 if ((error = git_strmap_new(&repo->submodule_cache)))
3035 return error;
3036
3037 error = git_submodule__map(repo, repo->submodule_cache);
3038 return error;
3039 }
3040
3041 int git_repository_submodule_cache_clear(git_repository *repo)
3042 {
3043 git_submodule *sm;
3044 assert(repo);
3045 if (repo->submodule_cache == NULL) {
3046 return 0;
3047 }
3048 git_strmap_foreach_value(repo->submodule_cache, sm, {
3049 git_submodule_free(sm);
3050 });
3051 git_strmap_free(repo->submodule_cache);
3052 repo->submodule_cache = 0;
3053 return 0;
3054 }
The git library used in some Proxmox tool chains