From 35c340779af55f6b8d501de79988b0345b311c70 Mon Sep 17 00:00:00 2001 From: Gregory Herrero Date: Tue, 3 Dec 2019 15:38:29 +0100 Subject: [PATCH 001/608] worktree: mimic 'git worktree add' behavior. When adding a worktree using 'git worktree add ', if a reference named 'refs/heads/$(basename )' already exist, it is checkouted in the worktree. Mimic this behavior in libgit2. Signed-off-by: Gregory Herrero --- src/worktree.c | 26 +++++++++++++++++----- tests/worktree/worktree.c | 47 ++++++++++++++++++++++++++++++++++++--- 2 files changed, 64 insertions(+), 9 deletions(-) diff --git a/src/worktree.c b/src/worktree.c index ef4ebfda83c..c5edcb86bf2 100644 --- a/src/worktree.c +++ b/src/worktree.c @@ -278,7 +278,8 @@ int git_worktree_add(git_worktree **out, git_repository *repo, const char *name, const char *worktree, const git_worktree_add_options *opts) { - git_buf gitdir = GIT_BUF_INIT, wddir = GIT_BUF_INIT, buf = GIT_BUF_INIT; + git_buf gitdir = GIT_BUF_INIT, wddir = GIT_BUF_INIT; + git_buf buf = GIT_BUF_INIT, ref_buf = GIT_BUF_INIT; git_reference *ref = NULL, *head = NULL; git_commit *commit = NULL; git_repository *wt = NULL; @@ -365,12 +366,24 @@ int git_worktree_add(git_worktree **out, git_repository *repo, if ((err = git_reference_dup(&ref, wtopts.ref)) < 0) goto out; } else { - if ((err = git_repository_head(&head, repo)) < 0) - goto out; - if ((err = git_commit_lookup(&commit, repo, &head->target.oid)) < 0) - goto out; - if ((err = git_branch_create(&ref, repo, name, commit, false)) < 0) + if ((err = git_buf_printf(&ref_buf, "refs/heads/%s", name)) < 0) goto out; + if (!git_reference_lookup(&ref, repo, ref_buf.ptr)) { + if (git_branch_is_checked_out(ref)) { + git_error_set(GIT_ERROR_WORKTREE, + "reference %s is already checked out", + ref_buf.ptr); + err = -1; + goto out; + } + } else { + if ((err = git_repository_head(&head, repo)) < 0) + goto out; + if ((err = git_commit_lookup(&commit, repo, &head->target.oid)) < 0) + goto out; + if ((err = git_branch_create(&ref, repo, name, commit, false)) < 0) + goto out; + } } /* Set worktree's HEAD */ @@ -392,6 +405,7 @@ int git_worktree_add(git_worktree **out, git_repository *repo, git_buf_dispose(&gitdir); git_buf_dispose(&wddir); git_buf_dispose(&buf); + git_buf_dispose(&ref_buf); git_reference_free(ref); git_reference_free(head); git_commit_free(commit); diff --git a/tests/worktree/worktree.c b/tests/worktree/worktree.c index 5e99dbf616b..9ef08320163 100644 --- a/tests/worktree/worktree.c +++ b/tests/worktree/worktree.c @@ -216,6 +216,46 @@ void test_worktree_worktree__init(void) git_repository_free(repo); } +void test_worktree_worktree__add_remove_add(void) +{ + git_worktree *wt; + git_repository *repo; + git_reference *branch; + git_buf path = GIT_BUF_INIT; + + git_worktree_prune_options opts = GIT_WORKTREE_PRUNE_OPTIONS_INIT; + + /* Add the worktree */ + cl_git_pass(git_buf_joinpath(&path, fixture.repo->workdir, "../worktree-add-remove-add")); + cl_git_pass(git_worktree_add(&wt, fixture.repo, "worktree-add-remove-add", path.ptr, NULL)); + + /* Open and verify created repo */ + cl_git_pass(git_repository_open(&repo, path.ptr)); + cl_assert(git__suffixcmp(git_repository_workdir(repo), "worktree-add-remove-add/") == 0); + cl_git_pass(git_branch_lookup(&branch, repo, "worktree-add-remove-add", GIT_BRANCH_LOCAL)); + git_repository_free(repo); + + /* Prune the worktree */ + opts.flags = GIT_WORKTREE_PRUNE_VALID|GIT_WORKTREE_PRUNE_WORKING_TREE; + cl_git_pass(git_worktree_prune(wt, &opts)); + cl_assert(!git_path_exists(wt->gitdir_path)); + cl_assert(!git_path_exists(wt->gitlink_path)); + git_worktree_free(wt); + + /* Add the worktree back */ + cl_git_pass(git_worktree_add(&wt, fixture.repo, "worktree-add-remove-add", path.ptr, NULL)); + + /* Open and verify created repo */ + cl_git_pass(git_repository_open(&repo, path.ptr)); + cl_assert(git__suffixcmp(git_repository_workdir(repo), "worktree-add-remove-add/") == 0); + cl_git_pass(git_branch_lookup(&branch, repo, "worktree-add-remove-add", GIT_BRANCH_LOCAL)); + + git_buf_dispose(&path); + git_worktree_free(wt); + git_reference_free(branch); + git_repository_free(repo); +} + void test_worktree_worktree__add_locked(void) { git_worktree *wt; @@ -250,12 +290,13 @@ void test_worktree_worktree__init_existing_branch(void) cl_git_pass(git_repository_head(&head, fixture.repo)); cl_git_pass(git_commit_lookup(&commit, fixture.repo, &head->target.oid)); - cl_git_pass(git_branch_create(&branch, fixture.repo, "worktree-new", commit, false)); + cl_git_pass(git_branch_create(&branch, fixture.repo, "worktree-new-exist", commit, false)); - cl_git_pass(git_buf_joinpath(&path, fixture.repo->workdir, "../worktree-new")); - cl_git_fail(git_worktree_add(&wt, fixture.repo, "worktree-new", path.ptr, NULL)); + cl_git_pass(git_buf_joinpath(&path, fixture.repo->workdir, "../worktree-new-exist")); + cl_git_pass(git_worktree_add(&wt, fixture.repo, "worktree-new-exist", path.ptr, NULL)); git_buf_dispose(&path); + git_worktree_free(wt); git_commit_free(commit); git_reference_free(head); git_reference_free(branch); From ea5028ab68584268ba9055e76eb99e5e2e6cac8e Mon Sep 17 00:00:00 2001 From: Patrick Steinhardt Date: Fri, 24 Jan 2020 12:46:59 +0100 Subject: [PATCH 002/608] worktree: add flag to allow re-using existing branches for new worktrees In this commit's parent, we have introduced logic that will automatically re-use of existing branches if the new worktree name matches the branch name. While this is a handy feature, it changes behaviour in a backwards-incompatible way and might thus surprise users. Furthermore, it's impossible to tell whether we have created the worktree with a new or an existing reference. To fix this, introduce a new option `checkout_existing` that toggles this behaviour. Only if the flag is set will we now allow re-use of existing branches, while it's set to "off" by default. --- include/git2/worktree.h | 9 ++++---- src/worktree.c | 47 +++++++++++++-------------------------- tests/worktree/worktree.c | 32 +++++++++++++++++--------- 3 files changed, 41 insertions(+), 47 deletions(-) diff --git a/include/git2/worktree.h b/include/git2/worktree.h index 049511da121..3f1acbdb0ff 100644 --- a/include/git2/worktree.h +++ b/include/git2/worktree.h @@ -84,12 +84,13 @@ GIT_EXTERN(int) git_worktree_validate(const git_worktree *wt); typedef struct git_worktree_add_options { unsigned int version; - int lock; /**< lock newly created worktree */ - git_reference *ref; /**< reference to use for the new worktree HEAD */ + int lock; /**< lock newly created worktree */ + int checkout_existing; /**< allow checkout of existing branch matching worktree name */ + git_reference *ref; /**< reference to use for the new worktree HEAD */ } git_worktree_add_options; -#define GIT_WORKTREE_ADD_OPTIONS_VERSION 1 -#define GIT_WORKTREE_ADD_OPTIONS_INIT {GIT_WORKTREE_ADD_OPTIONS_VERSION,0,NULL} +#define GIT_WORKTREE_ADD_OPTIONS_VERSION 2 +#define GIT_WORKTREE_ADD_OPTIONS_INIT {GIT_WORKTREE_ADD_OPTIONS_VERSION,0,0,NULL} /** * Initialize git_worktree_add_options structure diff --git a/src/worktree.c b/src/worktree.c index c5edcb86bf2..5e4255b91e9 100644 --- a/src/worktree.c +++ b/src/worktree.c @@ -278,8 +278,7 @@ int git_worktree_add(git_worktree **out, git_repository *repo, const char *name, const char *worktree, const git_worktree_add_options *opts) { - git_buf gitdir = GIT_BUF_INIT, wddir = GIT_BUF_INIT; - git_buf buf = GIT_BUF_INIT, ref_buf = GIT_BUF_INIT; + git_buf gitdir = GIT_BUF_INIT, wddir = GIT_BUF_INIT, buf = GIT_BUF_INIT; git_reference *ref = NULL, *head = NULL; git_commit *commit = NULL; git_repository *wt = NULL; @@ -304,11 +303,21 @@ int git_worktree_add(git_worktree **out, git_repository *repo, goto out; } - if (git_branch_is_checked_out(wtopts.ref)) { - git_error_set(GIT_ERROR_WORKTREE, "reference is already checked out"); - err = -1; + if ((err = git_reference_dup(&ref, wtopts.ref)) < 0) goto out; - } + } else if (wtopts.checkout_existing && git_branch_lookup(&ref, repo, name, GIT_BRANCH_LOCAL) == 0) { + /* Do nothing */ + } else if ((err = git_repository_head(&head, repo)) < 0 || + (err = git_commit_lookup(&commit, repo, &head->target.oid)) < 0 || + (err = git_branch_create(&ref, repo, name, commit, false)) < 0) { + goto out; + } + + if (git_branch_is_checked_out(ref)) { + git_error_set(GIT_ERROR_WORKTREE, "reference %s is already checked out", + git_reference_name(ref)); + err = -1; + goto out; } /* Create gitdir directory ".git/worktrees/" */ @@ -361,31 +370,6 @@ int git_worktree_add(git_worktree **out, git_repository *repo, || (err = write_wtfile(gitdir.ptr, "gitdir", &buf)) < 0) goto out; - /* Set up worktree reference */ - if (wtopts.ref) { - if ((err = git_reference_dup(&ref, wtopts.ref)) < 0) - goto out; - } else { - if ((err = git_buf_printf(&ref_buf, "refs/heads/%s", name)) < 0) - goto out; - if (!git_reference_lookup(&ref, repo, ref_buf.ptr)) { - if (git_branch_is_checked_out(ref)) { - git_error_set(GIT_ERROR_WORKTREE, - "reference %s is already checked out", - ref_buf.ptr); - err = -1; - goto out; - } - } else { - if ((err = git_repository_head(&head, repo)) < 0) - goto out; - if ((err = git_commit_lookup(&commit, repo, &head->target.oid)) < 0) - goto out; - if ((err = git_branch_create(&ref, repo, name, commit, false)) < 0) - goto out; - } - } - /* Set worktree's HEAD */ if ((err = git_repository_create_head(gitdir.ptr, git_reference_name(ref))) < 0) goto out; @@ -405,7 +389,6 @@ int git_worktree_add(git_worktree **out, git_repository *repo, git_buf_dispose(&gitdir); git_buf_dispose(&wddir); git_buf_dispose(&buf); - git_buf_dispose(&ref_buf); git_reference_free(ref); git_reference_free(head); git_commit_free(commit); diff --git a/tests/worktree/worktree.c b/tests/worktree/worktree.c index 9ef08320163..6a709476a1b 100644 --- a/tests/worktree/worktree.c +++ b/tests/worktree/worktree.c @@ -218,12 +218,12 @@ void test_worktree_worktree__init(void) void test_worktree_worktree__add_remove_add(void) { - git_worktree *wt; - git_repository *repo; - git_reference *branch; - git_buf path = GIT_BUF_INIT; - + git_worktree_add_options add_opts = GIT_WORKTREE_ADD_OPTIONS_INIT; git_worktree_prune_options opts = GIT_WORKTREE_PRUNE_OPTIONS_INIT; + git_buf path = GIT_BUF_INIT; + git_reference *branch; + git_repository *repo; + git_worktree *wt; /* Add the worktree */ cl_git_pass(git_buf_joinpath(&path, fixture.repo->workdir, "../worktree-add-remove-add")); @@ -233,6 +233,7 @@ void test_worktree_worktree__add_remove_add(void) cl_git_pass(git_repository_open(&repo, path.ptr)); cl_assert(git__suffixcmp(git_repository_workdir(repo), "worktree-add-remove-add/") == 0); cl_git_pass(git_branch_lookup(&branch, repo, "worktree-add-remove-add", GIT_BRANCH_LOCAL)); + git_reference_free(branch); git_repository_free(repo); /* Prune the worktree */ @@ -242,18 +243,21 @@ void test_worktree_worktree__add_remove_add(void) cl_assert(!git_path_exists(wt->gitlink_path)); git_worktree_free(wt); - /* Add the worktree back */ - cl_git_pass(git_worktree_add(&wt, fixture.repo, "worktree-add-remove-add", path.ptr, NULL)); + /* Add the worktree back with default options should fail. */ + cl_git_fail(git_worktree_add(&wt, fixture.repo, "worktree-add-remove-add", path.ptr, &add_opts)); + /* If allowing checkout of existing branches, it should succeed. */ + add_opts.checkout_existing = 1; + cl_git_pass(git_worktree_add(&wt, fixture.repo, "worktree-add-remove-add", path.ptr, &add_opts)); /* Open and verify created repo */ cl_git_pass(git_repository_open(&repo, path.ptr)); cl_assert(git__suffixcmp(git_repository_workdir(repo), "worktree-add-remove-add/") == 0); cl_git_pass(git_branch_lookup(&branch, repo, "worktree-add-remove-add", GIT_BRANCH_LOCAL)); + git_reference_free(branch); + git_repository_free(repo); git_buf_dispose(&path); git_worktree_free(wt); - git_reference_free(branch); - git_repository_free(repo); } void test_worktree_worktree__add_locked(void) @@ -283,6 +287,7 @@ void test_worktree_worktree__add_locked(void) void test_worktree_worktree__init_existing_branch(void) { + git_worktree_add_options opts = GIT_WORKTREE_ADD_OPTIONS_INIT; git_reference *head, *branch; git_commit *commit; git_worktree *wt; @@ -293,7 +298,12 @@ void test_worktree_worktree__init_existing_branch(void) cl_git_pass(git_branch_create(&branch, fixture.repo, "worktree-new-exist", commit, false)); cl_git_pass(git_buf_joinpath(&path, fixture.repo->workdir, "../worktree-new-exist")); - cl_git_pass(git_worktree_add(&wt, fixture.repo, "worktree-new-exist", path.ptr, NULL)); + + /* Add the worktree back with default options should fail. */ + cl_git_fail(git_worktree_add(&wt, fixture.repo, "worktree-new-exist", path.ptr, NULL)); + /* If allowing checkout of existing branches, it should succeed. */ + opts.checkout_existing = 1; + cl_git_pass(git_worktree_add(&wt, fixture.repo, "worktree-new-exist", path.ptr, &opts)); git_buf_dispose(&path); git_worktree_free(wt); @@ -421,7 +431,7 @@ void test_worktree_worktree__name(void) cl_git_pass(git_worktree_lookup(&wt, fixture.repo, "testrepo-worktree")); cl_assert_equal_s(git_worktree_name(wt), "testrepo-worktree"); - + git_worktree_free(wt); } From 0668384efe29a4d92ce1e9d1108187599ac9a067 Mon Sep 17 00:00:00 2001 From: Etienne Samson Date: Thu, 2 Aug 2018 21:38:40 +0200 Subject: [PATCH 003/608] repo: basic graft API This represents (old-style) grafted commits, a.k.a an array of overridden parents for a commit's OID. --- src/graft.c | 80 +++++++++++++++++++++++++++++++++++++++++++++++++++++ src/graft.h | 29 +++++++++++++++++++ 2 files changed, 109 insertions(+) create mode 100644 src/graft.c create mode 100644 src/graft.h diff --git a/src/graft.c b/src/graft.c new file mode 100644 index 00000000000..21d32fb3846 --- /dev/null +++ b/src/graft.c @@ -0,0 +1,80 @@ +/* + * Copyright (C) the libgit2 contributors. All rights reserved. + * + * This file is part of libgit2, distributed under the GNU GPL v2 with + * a Linking Exception. For full terms see the included COPYING file. + */ + +#include "graft.h" + +int git__graft_register(git_graftmap *grafts, const git_oid *oid, git_array_oid_t parents) +{ + git_commit_graft *graft; + git_oid *parent_oid; + int error; + size_t i; + + assert(grafts && oid); + + graft = git__calloc(1, sizeof(*graft)); + GIT_ERROR_CHECK_ALLOC(graft); + + git_array_init_to_size(graft->parents, git_array_size(parents)); + git_array_foreach(parents, i, parent_oid) { + git_oid *id = git_array_alloc(graft->parents); + GIT_ERROR_CHECK_ALLOC(id); + + git_oid_cpy(id, parent_oid); + } + git_oid_cpy(&graft->oid, oid); + + if ((error = git_oidmap_set(grafts, &graft->oid, graft)) < 0) + goto cleanup; + + return 0; + +cleanup: + git_array_clear(graft->parents); + git__free(graft); + return error; +} + +int git__graft_unregister(git_graftmap *grafts, const git_oid *oid) +{ + git_commit_graft *graft; + int error; + + assert(grafts && oid); + + if ((graft = git_oidmap_get(grafts, oid)) == NULL) + return GIT_ENOTFOUND; + + if ((error = git_oidmap_delete(grafts, oid)) < 0) + return error; + + git__free(graft); + + return 0; +} + +void git__graft_clear(git_graftmap *grafts) +{ + git_commit_graft *graft; + + assert(grafts); + + git_oidmap_foreach_value(grafts, graft, { + git__free(graft->parents.ptr); + git__free(graft); + }); + + git_oidmap_clear(grafts); +} + +int git__graft_for_oid(git_commit_graft **out, git_graftmap *grafts, const git_oid *oid) +{ + assert(out && grafts && oid); + if ((*out = git_oidmap_get(grafts, oid)) == NULL) + return GIT_ENOTFOUND; + return 0; +} diff --git a/src/graft.h b/src/graft.h new file mode 100644 index 00000000000..e2afb971131 --- /dev/null +++ b/src/graft.h @@ -0,0 +1,29 @@ +/* + * Copyright (C) the libgit2 contributors. All rights reserved. + * + * This file is part of libgit2, distributed under the GNU GPL v2 with + * a Linking Exception. For full terms see the included COPYING file. + */ +#ifndef INCLUDE_graft_h__ +#define INCLUDE_graft_h__ + +#include "common.h" +#include "oidarray.h" +#include "oidmap.h" + +/** graft commit */ +typedef struct { + git_oid oid; + git_array_oid_t parents; +} git_commit_graft; + +/* A special type of git_oidmap with git_commit_grafts as values */ +typedef git_oidmap git_graftmap; + +int git__graft_register(git_graftmap *grafts, const git_oid *oid, git_array_oid_t parents); +int git__graft_unregister(git_graftmap *grafts, const git_oid *oid); +void git__graft_clear(git_graftmap *grafts); + +int git__graft_for_oid(git_commit_graft **out, git_graftmap *grafts, const git_oid *oid); + +#endif From 919501a92dbafac6e6e876aa7160c3f46f8afe55 Mon Sep 17 00:00:00 2001 From: Etienne Samson Date: Thu, 2 Aug 2018 21:38:42 +0200 Subject: [PATCH 004/608] repo: load grafts on open This wires git_repository to open the .git/info/grafts file and load its contents as git_commit_grafts objects. --- src/buffer.h | 5 +++ src/commit.c | 1 + src/repository.c | 81 ++++++++++++++++++++++++++++++++++++++++++++++++ src/repository.h | 4 +++ 4 files changed, 91 insertions(+) diff --git a/src/buffer.h b/src/buffer.h index 6b717d2e90c..fc8fe140055 100644 --- a/src/buffer.h +++ b/src/buffer.h @@ -219,4 +219,9 @@ int git_buf_splice( const char *data, size_t nb_to_insert); +/* warning: this will wreck your buf contents */ +#define git_buf_foreach_line(line_start, line_end, line_num, buf) \ + while (((line_start) = git__strsep(&(buf)->ptr, "\n")) != NULL && \ + ((line_end) = (line_start) + strlen((line_start))) != NULL && ++(line_num)) + #endif diff --git a/src/commit.c b/src/commit.c index cf9902d022b..e2003d2181a 100644 --- a/src/commit.c +++ b/src/commit.c @@ -22,6 +22,7 @@ #include "object.h" #include "array.h" #include "oidarray.h" +#include "graft.h" void git_commit__free(void *_commit) { diff --git a/src/repository.c b/src/repository.c index 5e818fb8289..bcd91509d3d 100644 --- a/src/repository.c +++ b/src/repository.c @@ -148,6 +148,9 @@ int git_repository__cleanup(git_repository *repo) git_cache_clear(&repo->objects); git_attr_cache_flush(repo); + git__graft_clear(repo->grafts); + git_oidmap_free(repo->grafts); + set_config(repo, NULL); set_index(repo, NULL); set_odb(repo, NULL); @@ -254,6 +257,9 @@ static git_repository *repository_alloc(void) /* set all the entries in the configmap cache to `unset` */ git_repository__configmap_lookup_cache_clear(repo); + if (git_oidmap_new(&repo->grafts) < 0) + goto on_error; + return repo; on_error: @@ -574,6 +580,78 @@ static int find_repo( return error; } +static int load_grafts(git_repository *repo) +{ + git_buf graft_path = GIT_BUF_INIT; + git_buf contents = GIT_BUF_INIT; + git_buf dup_contents; + const char *line_start; + const char *line_end; + int line_num = 0; + int error, updated; + git_array_oid_t parents = GIT_ARRAY_INIT; + + if ((error = git_repository_item_path(&graft_path, repo, GIT_REPOSITORY_ITEM_INFO)) < 0) + return error; + + if (git_buf_joinpath(&graft_path, graft_path.ptr, "grafts")) { + git_buf_dispose(&graft_path); + return error; + } + + error = git_futils_readbuffer_updated(&contents, git_buf_cstr(&graft_path), &repo->graft_checksum, &updated); + git_buf_dispose(&graft_path); + + if (error == GIT_ENOTFOUND || !updated) + return 0; + + if (error < 0) + goto cleanup; + + if (updated) { + git__graft_clear(repo->grafts); + } + + dup_contents.ptr = contents.ptr; + git_buf_foreach_line(line_start, line_end, line_num, &dup_contents) { + git_oid graft_oid, parent_oid; + + error = git_oid_fromstrn(&graft_oid, line_start, GIT_OID_HEXSZ); + if (error < 0) { + git_error_set(GIT_ERROR_REPOSITORY, "Invalid OID at line %d", line_num); + error = -1; + } + line_start += GIT_OID_HEXSZ; + + if (*(line_start++) == ' ') { + while (git_oid_fromstrn(&parent_oid, line_start, GIT_OID_HEXSZ) == 0) { + git_oid *id = git_array_alloc(parents); + + git_oid_cpy(id, &parent_oid); + line_start += GIT_OID_HEXSZ; + if (line_start >= line_end) { + break; + } + line_start += 1; + } + } + + if (git__graft_register(repo->grafts, &graft_oid, parents) < 0) { + git_error_set(GIT_ERROR_REPOSITORY, "Invalid graft at line %d", line_num); + error = -1; + goto cleanup; + } + git_array_clear(parents); + line_num++; + } + +cleanup: + git_array_clear(parents); + git_buf_dispose(&contents); + + return error; +} + int git_repository_open_bare( git_repository **repo_ptr, const char *bare_path) @@ -863,6 +941,9 @@ int git_repository_open_ext( if ((error = check_extensions(config, version) < 0)) goto cleanup; + if ((error = load_grafts(repo)) < 0) + goto cleanup; + if ((flags & GIT_REPOSITORY_OPEN_BARE) != 0) repo->is_bare = 1; else { diff --git a/src/repository.h b/src/repository.h index bafdb589697..98d266d839b 100644 --- a/src/repository.h +++ b/src/repository.h @@ -24,6 +24,7 @@ #include "attrcache.h" #include "submodule.h" #include "diff_driver.h" +#include "graft.h" #define DOT_GIT ".git" #define GIT_DIR DOT_GIT "/" @@ -152,6 +153,9 @@ struct git_repository { unsigned int lru_counter; + git_graftmap *grafts; + git_oid graft_checksum; + git_atomic attr_session_key; git_configmap_value configmap_cache[GIT_CONFIGMAP_CACHE_MAX]; From 3c17f22976d62e5fc2743186b4b1b567aadf104a Mon Sep 17 00:00:00 2001 From: Etienne Samson Date: Thu, 10 Oct 2019 11:32:16 +0200 Subject: [PATCH 005/608] repo: load shallow roots --- include/git2/repository.h | 12 +++++++ src/repository.c | 75 +++++++++++++++++++++++++++++++++++++++ src/repository.h | 6 ++++ 3 files changed, 93 insertions(+) diff --git a/include/git2/repository.h b/include/git2/repository.h index 9ddcd340420..5a27cf08e8d 100644 --- a/include/git2/repository.h +++ b/include/git2/repository.h @@ -11,6 +11,7 @@ #include "types.h" #include "oid.h" #include "buffer.h" +#include "oidarray.h" /** * @file git2/repository.h @@ -874,6 +875,17 @@ GIT_EXTERN(const char *) git_repository_get_namespace(git_repository *repo); */ GIT_EXTERN(int) git_repository_is_shallow(git_repository *repo); +/** + * Determine the shallow roots of the repository + * + * This oidarray is owned by the library. Do not free it. + * + * @param out An array of shallow oids. + * @param repo The repository + * @return 0 on success, an error otherwise. + */ +GIT_EXTERN(int) git_repository_shallow_roots(git_oidarray *out, git_repository *repo); + /** * Retrieve the configured identity to use for reflogs * diff --git a/src/repository.c b/src/repository.c index bcd91509d3d..da27f545b15 100644 --- a/src/repository.c +++ b/src/repository.c @@ -151,6 +151,8 @@ int git_repository__cleanup(git_repository *repo) git__graft_clear(repo->grafts); git_oidmap_free(repo->grafts); + git_array_clear(repo->shallow_oids); + set_config(repo, NULL); set_index(repo, NULL); set_odb(repo, NULL); @@ -2978,6 +2980,79 @@ int git_repository_state_cleanup(git_repository *repo) return git_repository__cleanup_files(repo, state_files, ARRAY_SIZE(state_files)); } +int git_repository__shallow_roots(git_array_oid_t *out, git_repository *repo) +{ + git_buf path = GIT_BUF_INIT; + git_buf contents = GIT_BUF_INIT; + int error, updated, line_num = 1; + char *line; + char *buffer; + + assert(out && repo); + + if ((error = git_buf_joinpath(&path, repo->gitdir, "shallow")) < 0) + return error; + + error = git_futils_readbuffer_updated(&contents, git_buf_cstr(&path), &repo->shallow_checksum, &updated); + git_buf_dispose(&path); + + if (error < 0 && error != GIT_ENOTFOUND) + return error; + + /* cancel out GIT_ENOTFOUND */ + git_error_clear(); + error = 0; + + if (!updated) { + *out = repo->shallow_oids; + goto cleanup; + } + + git_array_clear(repo->shallow_oids); + + buffer = contents.ptr; + while ((line = git__strsep(&buffer, "\n")) != NULL) { + git_oid *oid = git_array_alloc(repo->shallow_oids); + + error = git_oid_fromstr(oid, line); + if (error < 0) { + git_error_set(GIT_ERROR_REPOSITORY, "Invalid OID at line %d", line_num); + git_array_clear(repo->shallow_oids); + error = -1; + goto cleanup; + } + ++line_num; + } + + if (*buffer) { + git_error_set(GIT_ERROR_REPOSITORY, "No EOL at line %d", line_num); + git_array_clear(repo->shallow_oids); + error = -1; + goto cleanup; + } + + *out = repo->shallow_oids; + +cleanup: + git_buf_dispose(&contents); + + return error; +} + +int git_repository_shallow_roots(git_oidarray *out, git_repository *repo) +{ + int ret; + git_array_oid_t array = GIT_ARRAY_INIT; + + assert(out); + + ret = git_repository__shallow_roots(&array, repo); + + git_oidarray__from_array(out, &array); + + return ret; +} + int git_repository_is_shallow(git_repository *repo) { git_buf path = GIT_BUF_INIT; diff --git a/src/repository.h b/src/repository.h index 98d266d839b..f7c25f589e7 100644 --- a/src/repository.h +++ b/src/repository.h @@ -25,6 +25,7 @@ #include "submodule.h" #include "diff_driver.h" #include "graft.h" +#include "oidarray.h" #define DOT_GIT ".git" #define GIT_DIR DOT_GIT "/" @@ -156,6 +157,9 @@ struct git_repository { git_graftmap *grafts; git_oid graft_checksum; + git_oid shallow_checksum; + git_array_oid_t shallow_oids; + git_atomic attr_session_key; git_configmap_value configmap_cache[GIT_CONFIGMAP_CACHE_MAX]; @@ -259,4 +263,6 @@ extern size_t git_repository__reserved_names_posix_len; bool git_repository__reserved_names( git_buf **out, size_t *outlen, git_repository *repo, bool include_ntfs); +int git_repository__shallow_roots(git_array_oid_t *out, git_repository *repo); + #endif From a8b1d5156cf25c6b24feb084c55e8133b43d6390 Mon Sep 17 00:00:00 2001 From: Etienne Samson Date: Thu, 2 Aug 2018 21:40:51 +0200 Subject: [PATCH 006/608] repo: graft shallow roots on open --- src/repository.c | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) diff --git a/src/repository.c b/src/repository.c index da27f545b15..977c7100285 100644 --- a/src/repository.c +++ b/src/repository.c @@ -654,6 +654,27 @@ static int load_grafts(git_repository *repo) return error; } +static int load_shallow(git_repository *repo) +{ + int error = 0; + git_array_oid_t roots = GIT_ARRAY_INIT; + git_array_oid_t parents = GIT_ARRAY_INIT; + size_t i; + git_oid *graft_oid; + + /* Graft shallow roots */ + if ((error = git_repository__shallow_roots(&roots, repo)) < 0) { + return error; + } + + git_array_foreach(roots, i, graft_oid) { + if ((error = git__graft_register(repo->grafts, graft_oid, parents)) < 0) { + return error; + } + } + return 0; +} + int git_repository_open_bare( git_repository **repo_ptr, const char *bare_path) @@ -946,6 +967,9 @@ int git_repository_open_ext( if ((error = load_grafts(repo)) < 0) goto cleanup; + if ((error = load_shallow(repo)) < 0) + goto cleanup; + if ((flags & GIT_REPOSITORY_OPEN_BARE) != 0) repo->is_bare = 1; else { From a35cc402fa615b316ab1a02d700de3c36482ad39 Mon Sep 17 00:00:00 2001 From: Etienne Samson Date: Thu, 2 Aug 2018 21:38:43 +0200 Subject: [PATCH 007/608] commit: apply grafts when parsing --- src/commit.c | 28 +++++++++++++++++++++++----- 1 file changed, 23 insertions(+), 5 deletions(-) diff --git a/src/commit.c b/src/commit.c index e2003d2181a..ac8fb32501b 100644 --- a/src/commit.c +++ b/src/commit.c @@ -412,10 +412,6 @@ static int commit_parse(git_commit *commit, const char *data, size_t size, unsig buffer += tree_len; } - /* - * TODO: commit grafts! - */ - while (git_oid__parse(&parent_id, &buffer, buffer_end, "parent ") == 0) { git_oid *new_id = git_array_alloc(commit->parent_ids); GIT_ERROR_CHECK_ALLOC(new_id); @@ -499,7 +495,29 @@ int git_commit__parse_raw(void *commit, const char *data, size_t size) int git_commit__parse_ext(git_commit *commit, git_odb_object *odb_obj, unsigned int flags) { - return commit_parse(commit, git_odb_object_data(odb_obj), git_odb_object_size(odb_obj), flags); + git_repository *repo = git_object_owner((git_object *)commit); + git_commit_graft *graft; + int error; + + if ((error = commit_parse(commit, git_odb_object_data(odb_obj), + git_odb_object_size(odb_obj), flags)) < 0) + return error; + + /* Perform necessary grafts */ + if (git__graft_for_oid(&graft, repo->grafts, git_odb_object_id(odb_obj)) != GIT_ENOTFOUND) { + size_t idx; + git_oid *oid; + git_array_clear(commit->parent_ids); + git_array_init_to_size(commit->parent_ids, git_array_size(graft->parents)); + git_array_foreach(graft->parents, idx, oid) { + git_oid *id = git_array_alloc(commit->parent_ids); + GIT_ERROR_CHECK_ALLOC(id); + + git_oid_cpy(id, oid); + } + } + + return 0; } int git_commit__parse(void *_commit, git_odb_object *odb_obj) From d54c00814bbba7eb39c43a8556e1720674cab3f3 Mon Sep 17 00:00:00 2001 From: Etienne Samson Date: Thu, 2 Aug 2018 21:38:45 +0200 Subject: [PATCH 008/608] tests: graft commits --- tests/grafts/basic.c | 122 ++++++++++++++++ tests/grafts/shallow.c | 130 ++++++++++++++++++ tests/repo/shallow.c | 39 ------ tests/resources/grafted.git/HEAD | 1 + tests/resources/grafted.git/config | 6 + tests/resources/grafted.git/info/grafts | 3 + .../05/12adebd3782157f0d5c9b22b043f87b4aaff9e | Bin 0 -> 133 bytes .../1c/18e80a276611bb9b146590616bbc5aebdf2945 | Bin 0 -> 170 bytes .../1c/3f11eca55d76bc1bf7353ca7e4226246d353ed | Bin 0 -> 46 bytes .../2a/f02ebff1fc0142d2380c98758d81c67b365869 | Bin 0 -> 73 bytes .../2b/ecadd3f1ecad07a054392421edf9c0e1c375b2 | Bin 0 -> 74 bytes .../2f/3053cbff8a4ca2f0666de364ddb734a28a31a9 | Bin 0 -> 133 bytes .../45/342912745ba6f8893b1e126df4653a4355df1a | Bin 0 -> 50 bytes .../48/b2b333732644eafb385771a992b923fa88f135 | Bin 0 -> 49 bytes .../5d/31bf4b437e1191b6c709c665f1bd329d0ed0bf | Bin 0 -> 74 bytes .../66/cc22a015f6ca75b34c82d28f78ba663876bade | 2 + .../6c/f192eb71cd3243c9fbbe2551012c4449de3fcf | Bin 0 -> 36 bytes .../7c/9da502b2744b70522bb694cd607fb00104a233 | Bin 0 -> 76 bytes .../8a/00e91619098618be97c0d2ceabb05a2c58edd9 | 2 + .../a0/4de168dd5c43aa2af594d794d62e922f8b3b34 | Bin 0 -> 42 bytes .../b2/b4f9e5fe5dacbb2f98bd71d1dc86c7b571ddd1 | Bin 0 -> 54 bytes .../ba/54010f8d41532eb130eba420f50248881f7fc2 | Bin 0 -> 37 bytes .../d7/224d49d6d5aff6ade596ed74f4bcd4f77b29e2 | 2 + .../db/8e43f297a313c439530c977b733aaa8c10d54e | Bin 0 -> 35 bytes .../e4/14f42f4e6bc6934563a2349a8600f0ab68618e | Bin 0 -> 139 bytes .../e6/7b587a57850c69f6f9351ee10c7c8a41dacc78 | Bin 0 -> 74 bytes .../f0/7330bc2e4ed4bd0bf2301505f6c6bbad01aa2a | Bin 0 -> 77 bytes .../f5/03807ffa920e407a600cfaee96b7152259acc7 | 2 + tests/resources/grafted.git/refs/heads/bottom | 1 + tests/resources/grafted.git/refs/heads/branch | 1 + tests/resources/grafted.git/refs/heads/master | 1 + tests/resources/grafted.git/refs/heads/top | 1 + 32 files changed, 274 insertions(+), 39 deletions(-) create mode 100644 tests/grafts/basic.c create mode 100644 tests/grafts/shallow.c delete mode 100644 tests/repo/shallow.c create mode 100644 tests/resources/grafted.git/HEAD create mode 100644 tests/resources/grafted.git/config create mode 100644 tests/resources/grafted.git/info/grafts create mode 100644 tests/resources/grafted.git/objects/05/12adebd3782157f0d5c9b22b043f87b4aaff9e create mode 100644 tests/resources/grafted.git/objects/1c/18e80a276611bb9b146590616bbc5aebdf2945 create mode 100644 tests/resources/grafted.git/objects/1c/3f11eca55d76bc1bf7353ca7e4226246d353ed create mode 100644 tests/resources/grafted.git/objects/2a/f02ebff1fc0142d2380c98758d81c67b365869 create mode 100644 tests/resources/grafted.git/objects/2b/ecadd3f1ecad07a054392421edf9c0e1c375b2 create mode 100644 tests/resources/grafted.git/objects/2f/3053cbff8a4ca2f0666de364ddb734a28a31a9 create mode 100644 tests/resources/grafted.git/objects/45/342912745ba6f8893b1e126df4653a4355df1a create mode 100644 tests/resources/grafted.git/objects/48/b2b333732644eafb385771a992b923fa88f135 create mode 100644 tests/resources/grafted.git/objects/5d/31bf4b437e1191b6c709c665f1bd329d0ed0bf create mode 100644 tests/resources/grafted.git/objects/66/cc22a015f6ca75b34c82d28f78ba663876bade create mode 100644 tests/resources/grafted.git/objects/6c/f192eb71cd3243c9fbbe2551012c4449de3fcf create mode 100644 tests/resources/grafted.git/objects/7c/9da502b2744b70522bb694cd607fb00104a233 create mode 100644 tests/resources/grafted.git/objects/8a/00e91619098618be97c0d2ceabb05a2c58edd9 create mode 100644 tests/resources/grafted.git/objects/a0/4de168dd5c43aa2af594d794d62e922f8b3b34 create mode 100644 tests/resources/grafted.git/objects/b2/b4f9e5fe5dacbb2f98bd71d1dc86c7b571ddd1 create mode 100644 tests/resources/grafted.git/objects/ba/54010f8d41532eb130eba420f50248881f7fc2 create mode 100644 tests/resources/grafted.git/objects/d7/224d49d6d5aff6ade596ed74f4bcd4f77b29e2 create mode 100644 tests/resources/grafted.git/objects/db/8e43f297a313c439530c977b733aaa8c10d54e create mode 100644 tests/resources/grafted.git/objects/e4/14f42f4e6bc6934563a2349a8600f0ab68618e create mode 100644 tests/resources/grafted.git/objects/e6/7b587a57850c69f6f9351ee10c7c8a41dacc78 create mode 100644 tests/resources/grafted.git/objects/f0/7330bc2e4ed4bd0bf2301505f6c6bbad01aa2a create mode 100644 tests/resources/grafted.git/objects/f5/03807ffa920e407a600cfaee96b7152259acc7 create mode 100644 tests/resources/grafted.git/refs/heads/bottom create mode 100644 tests/resources/grafted.git/refs/heads/branch create mode 100644 tests/resources/grafted.git/refs/heads/master create mode 100644 tests/resources/grafted.git/refs/heads/top diff --git a/tests/grafts/basic.c b/tests/grafts/basic.c new file mode 100644 index 00000000000..39755ee8224 --- /dev/null +++ b/tests/grafts/basic.c @@ -0,0 +1,122 @@ +#include "clar_libgit2.h" + +#include "futils.h" +#include "graft.h" + +static git_repository *g_repo; + +void test_grafts_basic__initialize(void) +{ + g_repo = cl_git_sandbox_init("grafted.git"); +} + +void test_grafts_basic__cleanup(void) +{ + cl_git_sandbox_cleanup(); +} + +void test_grafts_basic__graft_add(void) +{ + git_oid oid_src, *oid1; + git_commit_graft *graft; + git_graftmap *grafts; + git_array_oid_t parents = GIT_ARRAY_INIT; + + cl_git_pass(git_oidmap_new(&grafts)); + + cl_assert(oid1 = git_array_alloc(parents)); + cl_git_pass(git_oid_fromstr(&oid_src, "2f3053cbff8a4ca2f0666de364ddb734a28a31a9")); + git_oid_cpy(oid1, &oid_src); + + git_oid_fromstr(&oid_src, "f503807ffa920e407a600cfaee96b7152259acc7"); + cl_git_pass(git__graft_register(grafts, &oid_src, parents)); + git_array_clear(parents); + + cl_assert_equal_i(1, git_oidmap_size(grafts)); + cl_git_pass(git__graft_for_oid(&graft, grafts, &oid_src)); + cl_assert_equal_s("f503807ffa920e407a600cfaee96b7152259acc7", git_oid_tostr_s(&graft->oid)); + cl_assert_equal_i(1, git_array_size(graft->parents)); + cl_assert_equal_s("2f3053cbff8a4ca2f0666de364ddb734a28a31a9", git_oid_tostr_s(git_array_get(graft->parents, 0))); + + git__graft_clear(grafts); + git_oidmap_free(grafts); +} + +void test_grafts_basic__grafted_revwalk(void) +{ + git_revwalk *w; + git_oid oids[10]; + size_t i = 0; + git_commit *commit; + + cl_git_pass(git_revwalk_new(&w, g_repo)); + cl_git_pass(git_revwalk_push_ref(w, "refs/heads/branch")); + + cl_git_pass(git_revwalk_next(&oids[i++], w)); + cl_assert_equal_s(git_oid_tostr_s(&oids[0]), "8a00e91619098618be97c0d2ceabb05a2c58edd9"); + cl_git_pass(git_revwalk_next(&oids[i++], w)); + cl_assert_equal_s(git_oid_tostr_s(&oids[1]), "f503807ffa920e407a600cfaee96b7152259acc7"); + cl_git_pass(git_revwalk_next(&oids[i++], w)); + cl_assert_equal_s(git_oid_tostr_s(&oids[2]), "2f3053cbff8a4ca2f0666de364ddb734a28a31a9"); + + cl_git_fail_with(GIT_ITEROVER, git_revwalk_next(&oids[i++], w)); + + cl_git_pass(git_commit_lookup(&commit, g_repo, &oids[0])); + + cl_assert_equal_i(1, git_commit_parentcount(commit)); + + git_commit_free(commit); + git_revwalk_free(w); +} + +void test_grafts_basic__grafted_objects(void) +{ + git_oid oid; + git_commit *commit; + + cl_git_pass(git_oid_fromstr(&oid, "f503807ffa920e407a600cfaee96b7152259acc7")); + cl_git_pass(git_commit_lookup(&commit, g_repo, &oid)); + cl_assert_equal_i(1, git_commit_parentcount(commit)); + git_commit_free(commit); + + cl_git_pass(git_oid_fromstr(&oid, "0512adebd3782157f0d5c9b22b043f87b4aaff9e")); + cl_git_pass(git_commit_lookup(&commit, g_repo, &oid)); + cl_assert_equal_i(1, git_commit_parentcount(commit)); + git_commit_free(commit); + + cl_git_pass(git_oid_fromstr(&oid, "66cc22a015f6ca75b34c82d28f78ba663876bade")); + cl_git_pass(git_commit_lookup(&commit, g_repo, &oid)); + cl_assert_equal_i(4, git_commit_parentcount(commit)); + git_commit_free(commit); +} + +void test_grafts_basic__grafted_merge_revwalk(void) +{ + git_revwalk *w; + git_oid oids[10]; + size_t i = 0; + + cl_git_pass(git_revwalk_new(&w, g_repo)); + cl_git_pass(git_revwalk_push_ref(w, "refs/heads/bottom")); + + cl_git_pass(git_revwalk_next(&oids[i++], w)); + cl_assert_equal_s(git_oid_tostr_s(&oids[i - 1]), "66cc22a015f6ca75b34c82d28f78ba663876bade"); + cl_git_pass(git_revwalk_next(&oids[i++], w)); + cl_assert_equal_s(git_oid_tostr_s(&oids[i - 1]), "e414f42f4e6bc6934563a2349a8600f0ab68618e"); + cl_git_pass(git_revwalk_next(&oids[i++], w)); + cl_assert_equal_s(git_oid_tostr_s(&oids[i - 1]), "8a00e91619098618be97c0d2ceabb05a2c58edd9"); + cl_git_pass(git_revwalk_next(&oids[i++], w)); + cl_assert_equal_s(git_oid_tostr_s(&oids[i - 1]), "1c18e80a276611bb9b146590616bbc5aebdf2945"); + cl_git_pass(git_revwalk_next(&oids[i++], w)); + cl_assert_equal_s(git_oid_tostr_s(&oids[i - 1]), "d7224d49d6d5aff6ade596ed74f4bcd4f77b29e2"); + cl_git_pass(git_revwalk_next(&oids[i++], w)); + cl_assert_equal_s(git_oid_tostr_s(&oids[i - 1]), "0512adebd3782157f0d5c9b22b043f87b4aaff9e"); + cl_git_pass(git_revwalk_next(&oids[i++], w)); + cl_assert_equal_s(git_oid_tostr_s(&oids[i - 1]), "f503807ffa920e407a600cfaee96b7152259acc7"); + cl_git_pass(git_revwalk_next(&oids[i++], w)); + cl_assert_equal_s(git_oid_tostr_s(&oids[i - 1]), "2f3053cbff8a4ca2f0666de364ddb734a28a31a9"); + + cl_git_fail_with(GIT_ITEROVER, git_revwalk_next(&oids[i++], w)); + + git_revwalk_free(w); +} diff --git a/tests/grafts/shallow.c b/tests/grafts/shallow.c new file mode 100644 index 00000000000..e4a0f741f0b --- /dev/null +++ b/tests/grafts/shallow.c @@ -0,0 +1,130 @@ +#include "clar_libgit2.h" +#include "futils.h" + +static git_repository *g_repo; +static git_oid g_shallow_oid; + +void test_grafts_shallow__initialize(void) +{ + cl_git_pass(git_oid_fromstr(&g_shallow_oid, "be3563ae3f795b2b4353bcce3a527ad0a4f7f644")); +} + +void test_grafts_shallow__cleanup(void) +{ + cl_git_sandbox_cleanup(); +} + +void test_grafts_shallow__no_shallow_file(void) +{ + g_repo = cl_git_sandbox_init("testrepo.git"); + cl_assert_equal_i(0, git_repository_is_shallow(g_repo)); +} + +void test_grafts_shallow__empty_shallow_file(void) +{ + g_repo = cl_git_sandbox_init("testrepo.git"); + cl_git_mkfile("testrepo.git/shallow", ""); + cl_assert_equal_i(0, git_repository_is_shallow(g_repo)); +} + +void test_grafts_shallow__shallow_repo(void) +{ + g_repo = cl_git_sandbox_init("shallow.git"); + cl_assert_equal_i(1, git_repository_is_shallow(g_repo)); +} + +void test_grafts_shallow__clears_errors(void) +{ + g_repo = cl_git_sandbox_init("testrepo.git"); + cl_assert_equal_i(0, git_repository_is_shallow(g_repo)); + cl_assert_equal_p(NULL, git_error_last()); +} + +void test_grafts_shallow__shallow_oids(void) +{ + git_oidarray oids, oids2; + g_repo = cl_git_sandbox_init("shallow.git"); + + cl_git_pass(git_repository_shallow_roots(&oids, g_repo)); + cl_assert_equal_i(1, oids.count); + cl_assert_equal_oid(&g_shallow_oid, &oids.ids[0]); + + cl_git_pass(git_repository_shallow_roots(&oids2, g_repo)); + cl_assert_equal_p(oids.ids, oids2.ids); +} + +void test_grafts_shallow__cache_clearing(void) +{ + git_oidarray oids, oids2; + git_oid tmp_oid; + + git_oid_fromstr(&tmp_oid, "0000000000000000000000000000000000000000"); + g_repo = cl_git_sandbox_init("shallow.git"); + + cl_git_pass(git_repository_shallow_roots(&oids, g_repo)); + cl_assert_equal_i(1, oids.count); + cl_assert_equal_oid(&g_shallow_oid, &oids.ids[0]); + + cl_git_mkfile("shallow.git/shallow", + "be3563ae3f795b2b4353bcce3a527ad0a4f7f644\n" + "0000000000000000000000000000000000000000\n" + ); + + cl_git_pass(git_repository_shallow_roots(&oids2, g_repo)); + cl_assert_equal_i(2, oids2.count); + cl_assert_equal_oid(&g_shallow_oid, &oids2.ids[0]); + cl_assert_equal_oid(&tmp_oid, &oids2.ids[1]); + + cl_git_pass(p_unlink("shallow.git/shallow")); + cl_git_pass(git_repository_shallow_roots(&oids, g_repo)); + cl_assert_equal_i(0, oids.count); + git_oidarray_free(&oids); +} + +void test_grafts_shallow__errors_on_borked(void) +{ + git_oidarray oids; + + g_repo = cl_git_sandbox_init("shallow.git"); + + cl_git_mkfile("shallow.git/shallow", "lolno"); + + cl_git_fail_with(-1, git_repository_shallow_roots(&oids, g_repo)); + + cl_git_mkfile("shallow.git/shallow", "lolno\n"); + + cl_git_fail_with(-1, git_repository_shallow_roots(&oids, g_repo)); +} + +void test_grafts_shallow__revwalk_behavior(void) +{ + git_revwalk *w; + git_oid oid_1, oid_2, oid_3; + + g_repo = cl_git_sandbox_init("shallow.git"); + + cl_git_pass(git_revwalk_new(&w, g_repo)); + cl_git_pass(git_revwalk_push_head(w)); + + cl_git_pass(git_revwalk_next(&oid_1, w)); // a65fedf39aefe402d3bb6e24df4d4f5fe4547750 + cl_git_pass(git_revwalk_next(&oid_2, w)); // be3563ae3f795b2b4353bcce3a527ad0a4f7f644 + cl_git_fail_with(GIT_ITEROVER, git_revwalk_next(&oid_3, w)); + + cl_assert_equal_s(git_oid_tostr_s(&oid_1), "a65fedf39aefe402d3bb6e24df4d4f5fe4547750"); + cl_assert_equal_s(git_oid_tostr_s(&oid_2), "be3563ae3f795b2b4353bcce3a527ad0a4f7f644"); + + git_revwalk_free(w); +} + +void test_grafts_shallow__grafted_object(void) +{ + git_commit *commit; + + g_repo = cl_git_sandbox_init("shallow.git"); + + cl_git_pass(git_commit_lookup(&commit, g_repo, &g_shallow_oid)); + + cl_assert_equal_i(0, git_commit_parentcount(commit)); + + git_commit_free(commit); +} diff --git a/tests/repo/shallow.c b/tests/repo/shallow.c deleted file mode 100644 index adb7a9e44b5..00000000000 --- a/tests/repo/shallow.c +++ /dev/null @@ -1,39 +0,0 @@ -#include "clar_libgit2.h" -#include "futils.h" - -static git_repository *g_repo; - -void test_repo_shallow__initialize(void) -{ -} - -void test_repo_shallow__cleanup(void) -{ - cl_git_sandbox_cleanup(); -} - -void test_repo_shallow__no_shallow_file(void) -{ - g_repo = cl_git_sandbox_init("testrepo.git"); - cl_assert_equal_i(0, git_repository_is_shallow(g_repo)); -} - -void test_repo_shallow__empty_shallow_file(void) -{ - g_repo = cl_git_sandbox_init("testrepo.git"); - cl_git_mkfile("testrepo.git/shallow", ""); - cl_assert_equal_i(0, git_repository_is_shallow(g_repo)); -} - -void test_repo_shallow__shallow_repo(void) -{ - g_repo = cl_git_sandbox_init("shallow.git"); - cl_assert_equal_i(1, git_repository_is_shallow(g_repo)); -} - -void test_repo_shallow__clears_errors(void) -{ - g_repo = cl_git_sandbox_init("testrepo.git"); - cl_assert_equal_i(0, git_repository_is_shallow(g_repo)); - cl_assert_equal_p(NULL, git_error_last()); -} diff --git a/tests/resources/grafted.git/HEAD b/tests/resources/grafted.git/HEAD new file mode 100644 index 00000000000..cb089cd89a7 --- /dev/null +++ b/tests/resources/grafted.git/HEAD @@ -0,0 +1 @@ +ref: refs/heads/master diff --git a/tests/resources/grafted.git/config b/tests/resources/grafted.git/config new file mode 100644 index 00000000000..e6da231579b --- /dev/null +++ b/tests/resources/grafted.git/config @@ -0,0 +1,6 @@ +[core] + repositoryformatversion = 0 + filemode = true + bare = true + ignorecase = true + precomposeunicode = true diff --git a/tests/resources/grafted.git/info/grafts b/tests/resources/grafted.git/info/grafts new file mode 100644 index 00000000000..bb9df8c0a80 --- /dev/null +++ b/tests/resources/grafted.git/info/grafts @@ -0,0 +1,3 @@ +f503807ffa920e407a600cfaee96b7152259acc7 2f3053cbff8a4ca2f0666de364ddb734a28a31a9 +0512adebd3782157f0d5c9b22b043f87b4aaff9e 2f3053cbff8a4ca2f0666de364ddb734a28a31a9 +66cc22a015f6ca75b34c82d28f78ba663876bade e414f42f4e6bc6934563a2349a8600f0ab68618e 8a00e91619098618be97c0d2ceabb05a2c58edd9 1c18e80a276611bb9b146590616bbc5aebdf2945 2f3053cbff8a4ca2f0666de364ddb734a28a31a9 diff --git a/tests/resources/grafted.git/objects/05/12adebd3782157f0d5c9b22b043f87b4aaff9e b/tests/resources/grafted.git/objects/05/12adebd3782157f0d5c9b22b043f87b4aaff9e new file mode 100644 index 0000000000000000000000000000000000000000..16880d596e5be78d02e1ea264f4b2ee69d02c680 GIT binary patch literal 133 zcmV;00DAv;oTZIH3d0}}0DJZodoP6D7!5)R?V&H|3)EdxAu1&H|Aq7kJq^rZCbm*? z2Xf}pcM&kGDWoY(dKMx_!NwU~wALgFtVhQvj3Fui>F>6~vuCMQ;N{EFD%_5fgZ%V; nEk18UY-Is5sL{-X4z4&Ns(7xu{1s6T=3G}uc@wR^E=)i_XyrVi literal 0 HcmV?d00001 diff --git a/tests/resources/grafted.git/objects/1c/18e80a276611bb9b146590616bbc5aebdf2945 b/tests/resources/grafted.git/objects/1c/18e80a276611bb9b146590616bbc5aebdf2945 new file mode 100644 index 0000000000000000000000000000000000000000..2c057b85d87270c2fb5dd4f9ee40b4c34158b122 GIT binary patch literal 170 zcmV;b09F5ZoTZOF3IZ_@My+#-=>^Ho<`+b4Y;8P2HZ!9OCXwBU*H`oiRu8`7@x9zi znLD6~o4zmuCeg@~$RJq{1_{TYa}3@F3PW~&8l4R;sz+M5b|8;v$V75vlZZ>iHaaG6 z#7votct2reRO#7oZGlstxmJctDr>8-U%%Y(Z$4g2n(w>Z$^izeM{Pg)09%b(tNgv% Y`7en&^9y9Y^9Z@s{z+KX8>doGwo)cfs{jB1 literal 0 HcmV?d00001 diff --git a/tests/resources/grafted.git/objects/1c/3f11eca55d76bc1bf7353ca7e4226246d353ed b/tests/resources/grafted.git/objects/1c/3f11eca55d76bc1bf7353ca7e4226246d353ed new file mode 100644 index 0000000000000000000000000000000000000000..b92a3047f1804ae188cc86555e7179093185915b GIT binary patch literal 46 zcmV+}0MY+=oJ-2dPf{>8V2I2wRVYf$%`Zz;D9K1wNXyJgRY=ayD@n~ODc0ix0Qf`< E_1_m1iU0rr literal 0 HcmV?d00001 diff --git a/tests/resources/grafted.git/objects/2a/f02ebff1fc0142d2380c98758d81c67b365869 b/tests/resources/grafted.git/objects/2a/f02ebff1fc0142d2380c98758d81c67b365869 new file mode 100644 index 0000000000000000000000000000000000000000..ed3f874a7bddb6d5d2f46ac5823f8181b09105dd GIT binary patch literal 73 zcmV-P0Ji^loGU3xO;s>6WiT`_Ff%bxNXyJgWw_nv{Av1P;Ukv8JkzU-tyc92T=hee fH)hxs!pPt27_7I^;Pn!PuS^~t^7V%Rkc%1M+}9*@ literal 0 HcmV?d00001 diff --git a/tests/resources/grafted.git/objects/2b/ecadd3f1ecad07a054392421edf9c0e1c375b2 b/tests/resources/grafted.git/objects/2b/ecadd3f1ecad07a054392421edf9c0e1c375b2 new file mode 100644 index 0000000000000000000000000000000000000000..724eedbb2ecf35e1e3f3ba08ec2445092841ba5f GIT binary patch literal 74 zcmV-Q0JZ;koGU3xO;s>6WiT`_Ff%bxNXyJgWw_nv{Av1P;Ukv8JkzU-tyc92T=hee gH)fEr7kslcwrr2|cT=0?Pn43}E(gB_0GnVNGu+-H00000 literal 0 HcmV?d00001 diff --git a/tests/resources/grafted.git/objects/2f/3053cbff8a4ca2f0666de364ddb734a28a31a9 b/tests/resources/grafted.git/objects/2f/3053cbff8a4ca2f0666de364ddb734a28a31a9 new file mode 100644 index 0000000000000000000000000000000000000000..3d124a6735246418d158e34e43266d782f20f0b9 GIT binary patch literal 133 zcmV;00DAv;oTZIH3d0}}0DJZodoKjt)u<3kFFo|!7p!5^3Q-}k|1Ts@=xJaMGjl5? zcQDak`X&N4Buqr)2}f&%mqfvNZ#YIw5ozHN7DG<)w}09OkDjGgfftv(RhagJgPi*Q nE}Yk4Zsi8XX^dmk7U8N8VQ|dLFUd$P(orbR$xP2E$*ELG$xKU2ElSNRQAo?oNj2dD I05rx9iB#hjJ^%m! literal 0 HcmV?d00001 diff --git a/tests/resources/grafted.git/objects/48/b2b333732644eafb385771a992b923fa88f135 b/tests/resources/grafted.git/objects/48/b2b333732644eafb385771a992b923fa88f135 new file mode 100644 index 0000000000000000000000000000000000000000..ac640636beb3e853d58759fdcbe76da2e6396e3e GIT binary patch literal 49 zcmV-10M7q-oGU3xO;s>9VlXr?Ff%bxNXyJgWw_nv{Av1P;Ukv8JkzU-tyc92T=fG0 H3L_4b`6Lx1 literal 0 HcmV?d00001 diff --git a/tests/resources/grafted.git/objects/5d/31bf4b437e1191b6c709c665f1bd329d0ed0bf b/tests/resources/grafted.git/objects/5d/31bf4b437e1191b6c709c665f1bd329d0ed0bf new file mode 100644 index 0000000000000000000000000000000000000000..47a05377ef383fe0018c4ae10588e3aa6e87115a GIT binary patch literal 74 zcmV-Q0JZ;koGU3xO;s>6WiT`_Ff%bxNXyJgWw_nv{Av1P;Ukv8JkzU-tyc92T=hee gH)dGi`!M5fjPok3uT!p1xu!QszuVdb0JJ+B_4OnqA^-pY literal 0 HcmV?d00001 diff --git a/tests/resources/grafted.git/objects/66/cc22a015f6ca75b34c82d28f78ba663876bade b/tests/resources/grafted.git/objects/66/cc22a015f6ca75b34c82d28f78ba663876bade new file mode 100644 index 00000000000..c68b2cd4fb1 --- /dev/null +++ b/tests/resources/grafted.git/objects/66/cc22a015f6ca75b34c82d28f78ba663876bade @@ -0,0 +1,2 @@ +xM +0F]$Dx=4N4Fϯ#x|260dvmap1 a}NhL!E&}BTO^dn )$~ꖜl,=bF|:W{myrY uN~t/ѫM, \ No newline at end of file diff --git a/tests/resources/grafted.git/objects/6c/f192eb71cd3243c9fbbe2551012c4449de3fcf b/tests/resources/grafted.git/objects/6c/f192eb71cd3243c9fbbe2551012c4449de3fcf new file mode 100644 index 0000000000000000000000000000000000000000..a437f24320485d43a36754c301df4ec942291628 GIT binary patch literal 36 scmb=J<9+I+e~^Ju630o8&=Y6%y+SokdazFFbX{3hRTaZ9g^SY$02^Em9RL6T literal 0 HcmV?d00001 diff --git a/tests/resources/grafted.git/objects/7c/9da502b2744b70522bb694cd607fb00104a233 b/tests/resources/grafted.git/objects/7c/9da502b2744b70522bb694cd607fb00104a233 new file mode 100644 index 0000000000000000000000000000000000000000..b363584fd9ab216bee5892efa1ce7ae800d72ec3 GIT binary patch literal 76 zcmV-S0JHyioGU3xO;xb8U@$Z=Ff%bxNXyJgWw_nv{Av1P;Ukv8JkzU-tyc92T=hee iHzK6Kgu&HBQ>Y|**^f?ZIicJysaDRR_oV>MU?ur-;U+Nv literal 0 HcmV?d00001 diff --git a/tests/resources/grafted.git/objects/8a/00e91619098618be97c0d2ceabb05a2c58edd9 b/tests/resources/grafted.git/objects/8a/00e91619098618be97c0d2ceabb05a2c58edd9 new file mode 100644 index 00000000000..887778a60a0 --- /dev/null +++ b/tests/resources/grafted.git/objects/8a/00e91619098618be97c0d2ceabb05a2c58edd9 @@ -0,0 +1,2 @@ +xA +0E]t4Dt <$@J#ч@B5@b$'[ig&V/^6H ]J<AbH,2ȎSne{R˶T8ovשp |d~_u1 RŨߚNC \ No newline at end of file diff --git a/tests/resources/grafted.git/objects/a0/4de168dd5c43aa2af594d794d62e922f8b3b34 b/tests/resources/grafted.git/objects/a0/4de168dd5c43aa2af594d794d62e922f8b3b34 new file mode 100644 index 0000000000000000000000000000000000000000..1ed3ed906abd905893455c38a9597e7ef259df59 GIT binary patch literal 42 ycmb=J<9+I+e~^JuazTj4x%0XnXHK6vAMA1ZjAy8aj)sS?j#k(cCWb@G+%5p0ClPP} literal 0 HcmV?d00001 diff --git a/tests/resources/grafted.git/objects/b2/b4f9e5fe5dacbb2f98bd71d1dc86c7b571ddd1 b/tests/resources/grafted.git/objects/b2/b4f9e5fe5dacbb2f98bd71d1dc86c7b571ddd1 new file mode 100644 index 0000000000000000000000000000000000000000..2adc857219eb17dcbb6489b39e2e9d520e9ec1d0 GIT binary patch literal 54 zcmV-60LlM&oGU3xO;s>6WiT`_Ff%bxNXyJgWw_nv{Av1P;Ukv8JkzU-tyc92T=hee MH^Qm_0IJ^`DtJ*CmjD0& literal 0 HcmV?d00001 diff --git a/tests/resources/grafted.git/objects/ba/54010f8d41532eb130eba420f50248881f7fc2 b/tests/resources/grafted.git/objects/ba/54010f8d41532eb130eba420f50248881f7fc2 new file mode 100644 index 0000000000000000000000000000000000000000..52a8872747197a2a017978f343a13d5fafaa5b8c GIT binary patch literal 37 tcmb=J<9+I+e~^Ju$_Jf5{V)x0-BlqTzTT&O&iS0x4t&DI(D{Kg0ste34+H=J literal 0 HcmV?d00001 diff --git a/tests/resources/grafted.git/objects/d7/224d49d6d5aff6ade596ed74f4bcd4f77b29e2 b/tests/resources/grafted.git/objects/d7/224d49d6d5aff6ade596ed74f4bcd4f77b29e2 new file mode 100644 index 00000000000..5b41b6778f8 --- /dev/null +++ b/tests/resources/grafted.git/objects/d7/224d49d6d5aff6ade596ed74f4bcd4f77b29e2 @@ -0,0 +1,2 @@ +xA +0E]dҐDx=$hI_Gp/Ԁ,"%p&/1ތԓƀq֓z"ZMG%6co|Ϝ(^8IJr^kú|e.|mѠuH*lW%Q%Y ZڧbUoaRj \ No newline at end of file diff --git a/tests/resources/grafted.git/objects/db/8e43f297a313c439530c977b733aaa8c10d54e b/tests/resources/grafted.git/objects/db/8e43f297a313c439530c977b733aaa8c10d54e new file mode 100644 index 0000000000000000000000000000000000000000..b9cf5947b705184a4ba4a8e3d19140da9eb41356 GIT binary patch literal 35 rcmb=J<9+I+e~`hJl!A~G-n!u)r_XqXdgy3)`08jqV`3jUvmdN{IG$9V?CXd*oVbWUhyDfEtXG>Cwz>D)<3tabuo&5BD t&YadR)O>^9qDJfV#ljg0QH5jO literal 0 HcmV?d00001 diff --git a/tests/resources/grafted.git/objects/e6/7b587a57850c69f6f9351ee10c7c8a41dacc78 b/tests/resources/grafted.git/objects/e6/7b587a57850c69f6f9351ee10c7c8a41dacc78 new file mode 100644 index 0000000000000000000000000000000000000000..213f9ac22ef650e98e03036bd3ba542f0c498454 GIT binary patch literal 74 zcmV-Q0JZ;koGU3xO;s>6V=y!@Ff%bxNXyJgHDb8k=lp5+4m2we3; gQeeX1YN9Dr620t4r?s3=?w3?6=g|970GyW@mfHIx)c^nh literal 0 HcmV?d00001 diff --git a/tests/resources/grafted.git/objects/f0/7330bc2e4ed4bd0bf2301505f6c6bbad01aa2a b/tests/resources/grafted.git/objects/f0/7330bc2e4ed4bd0bf2301505f6c6bbad01aa2a new file mode 100644 index 0000000000000000000000000000000000000000..f2d64889207b6c5a5676af3ef9addc92077d3b14 GIT binary patch literal 77 zcmV-T0J8shoGU3xO;xb8U@$Z=Ff%bxNXyJgWw_nv{Av1P;Ukv8JkzU-tyc92T=hee jHzK6KgdykSq}PRKjhs*Z-lrPKsN>>!&;C3B_1!3bz$Ga8 literal 0 HcmV?d00001 diff --git a/tests/resources/grafted.git/objects/f5/03807ffa920e407a600cfaee96b7152259acc7 b/tests/resources/grafted.git/objects/f5/03807ffa920e407a600cfaee96b7152259acc7 new file mode 100644 index 00000000000..21436c177e9 --- /dev/null +++ b/tests/resources/grafted.git/objects/f5/03807ffa920e407a600cfaee96b7152259acc7 @@ -0,0 +1,2 @@ +xA +0E]J&6) @@#xZ)z{D/ɋMb9P&yyBF&7헙Qw =KPV;Oߖ:P+3Ə6Z+:Qw\Hy>zA \ No newline at end of file diff --git a/tests/resources/grafted.git/refs/heads/bottom b/tests/resources/grafted.git/refs/heads/bottom new file mode 100644 index 00000000000..10513e69877 --- /dev/null +++ b/tests/resources/grafted.git/refs/heads/bottom @@ -0,0 +1 @@ +66cc22a015f6ca75b34c82d28f78ba663876bade diff --git a/tests/resources/grafted.git/refs/heads/branch b/tests/resources/grafted.git/refs/heads/branch new file mode 100644 index 00000000000..d0fe5c28390 --- /dev/null +++ b/tests/resources/grafted.git/refs/heads/branch @@ -0,0 +1 @@ +8a00e91619098618be97c0d2ceabb05a2c58edd9 diff --git a/tests/resources/grafted.git/refs/heads/master b/tests/resources/grafted.git/refs/heads/master new file mode 100644 index 00000000000..de809b9421a --- /dev/null +++ b/tests/resources/grafted.git/refs/heads/master @@ -0,0 +1 @@ +2f3053cbff8a4ca2f0666de364ddb734a28a31a9 diff --git a/tests/resources/grafted.git/refs/heads/top b/tests/resources/grafted.git/refs/heads/top new file mode 100644 index 00000000000..ce226110b8e --- /dev/null +++ b/tests/resources/grafted.git/refs/heads/top @@ -0,0 +1 @@ +1c18e80a276611bb9b146590616bbc5aebdf2945 From 22f201b158f4a3b7bfcf3bac2324ab3fa77bac06 Mon Sep 17 00:00:00 2001 From: Patrick Steinhardt Date: Thu, 3 Oct 2019 10:40:41 +0200 Subject: [PATCH 009/608] grafts: make the structure self-contained and opaque In order to increase maintainability in the future, we should try to make structures as self-contained and opaque to its users as possible. Thus it is probably not a good idea to just typedef `git_graftmap` to `git_oidmap`, as that will make it a lot harder in the future to extend the API in the future, if this need ever arises. Refactor the code to instead declare a real structure `git_grafts`, which is completely opaque to its callers. --- src/commit.c | 4 +- src/graft.c | 80 -------------------------- src/grafts.c | 115 ++++++++++++++++++++++++++++++++++++++ src/{graft.h => grafts.h} | 14 +++-- src/repository.c | 17 ++---- src/repository.h | 4 +- tests/grafts/basic.c | 17 +++--- 7 files changed, 141 insertions(+), 110 deletions(-) delete mode 100644 src/graft.c create mode 100644 src/grafts.c rename src/{graft.h => grafts.h} (50%) diff --git a/src/commit.c b/src/commit.c index ac8fb32501b..e06faafe781 100644 --- a/src/commit.c +++ b/src/commit.c @@ -22,7 +22,7 @@ #include "object.h" #include "array.h" #include "oidarray.h" -#include "graft.h" +#include "grafts.h" void git_commit__free(void *_commit) { @@ -504,7 +504,7 @@ int git_commit__parse_ext(git_commit *commit, git_odb_object *odb_obj, unsigned return error; /* Perform necessary grafts */ - if (git__graft_for_oid(&graft, repo->grafts, git_odb_object_id(odb_obj)) != GIT_ENOTFOUND) { + if (git_grafts_get(&graft, repo->grafts, git_odb_object_id(odb_obj)) != GIT_ENOTFOUND) { size_t idx; git_oid *oid; git_array_clear(commit->parent_ids); diff --git a/src/graft.c b/src/graft.c deleted file mode 100644 index 21d32fb3846..00000000000 --- a/src/graft.c +++ /dev/null @@ -1,80 +0,0 @@ -/* - * Copyright (C) the libgit2 contributors. All rights reserved. - * - * This file is part of libgit2, distributed under the GNU GPL v2 with - * a Linking Exception. For full terms see the included COPYING file. - */ - -#include "graft.h" - -int git__graft_register(git_graftmap *grafts, const git_oid *oid, git_array_oid_t parents) -{ - git_commit_graft *graft; - git_oid *parent_oid; - int error; - size_t i; - - assert(grafts && oid); - - graft = git__calloc(1, sizeof(*graft)); - GIT_ERROR_CHECK_ALLOC(graft); - - git_array_init_to_size(graft->parents, git_array_size(parents)); - git_array_foreach(parents, i, parent_oid) { - git_oid *id = git_array_alloc(graft->parents); - GIT_ERROR_CHECK_ALLOC(id); - - git_oid_cpy(id, parent_oid); - } - git_oid_cpy(&graft->oid, oid); - - if ((error = git_oidmap_set(grafts, &graft->oid, graft)) < 0) - goto cleanup; - - return 0; - -cleanup: - git_array_clear(graft->parents); - git__free(graft); - return error; -} - -int git__graft_unregister(git_graftmap *grafts, const git_oid *oid) -{ - git_commit_graft *graft; - int error; - - assert(grafts && oid); - - if ((graft = git_oidmap_get(grafts, oid)) == NULL) - return GIT_ENOTFOUND; - - if ((error = git_oidmap_delete(grafts, oid)) < 0) - return error; - - git__free(graft); - - return 0; -} - -void git__graft_clear(git_graftmap *grafts) -{ - git_commit_graft *graft; - - assert(grafts); - - git_oidmap_foreach_value(grafts, graft, { - git__free(graft->parents.ptr); - git__free(graft); - }); - - git_oidmap_clear(grafts); -} - -int git__graft_for_oid(git_commit_graft **out, git_graftmap *grafts, const git_oid *oid) -{ - assert(out && grafts && oid); - if ((*out = git_oidmap_get(grafts, oid)) == NULL) - return GIT_ENOTFOUND; - return 0; -} diff --git a/src/grafts.c b/src/grafts.c new file mode 100644 index 00000000000..90490d0ac29 --- /dev/null +++ b/src/grafts.c @@ -0,0 +1,115 @@ +/* + * Copyright (C) the libgit2 contributors. All rights reserved. + * + * This file is part of libgit2, distributed under the GNU GPL v2 with + * a Linking Exception. For full terms see the included COPYING file. + */ + +#include "grafts.h" + +struct git_grafts { + /* Map of `git_commit_graft`s */ + git_oidmap *commits; +}; + +int git_grafts_new(git_grafts **out) +{ + git_grafts *grafts; + + grafts = git__calloc(1, sizeof(*grafts)); + GIT_ERROR_CHECK_ALLOC(grafts); + + if ((git_oidmap_new(&grafts->commits)) < 0) { + git__free(grafts); + return -1; + } + + *out = grafts; + return 0; +} + +void git_grafts_free(git_grafts *grafts) +{ + if (!grafts) + return; + git_grafts_clear(grafts); + git_oidmap_free(grafts->commits); + git__free(grafts); +} + +void git_grafts_clear(git_grafts *grafts) +{ + git_commit_graft *graft; + + assert(grafts); + + git_oidmap_foreach_value(grafts->commits, graft, { + git__free(graft->parents.ptr); + git__free(graft); + }); + + git_oidmap_clear(grafts->commits); +} + +int git_grafts_add(git_grafts *grafts, const git_oid *oid, git_array_oid_t parents) +{ + git_commit_graft *graft; + git_oid *parent_oid; + int error; + size_t i; + + assert(grafts && oid); + + graft = git__calloc(1, sizeof(*graft)); + GIT_ERROR_CHECK_ALLOC(graft); + + git_array_init_to_size(graft->parents, git_array_size(parents)); + git_array_foreach(parents, i, parent_oid) { + git_oid *id = git_array_alloc(graft->parents); + GIT_ERROR_CHECK_ALLOC(id); + + git_oid_cpy(id, parent_oid); + } + git_oid_cpy(&graft->oid, oid); + + if ((error = git_oidmap_set(grafts->commits, &graft->oid, graft)) < 0) + goto cleanup; + + return 0; + +cleanup: + git_array_clear(graft->parents); + git__free(graft); + return error; +} + +int git_grafts_remove(git_grafts *grafts, const git_oid *oid) +{ + git_commit_graft *graft; + int error; + + assert(grafts && oid); + + if ((graft = git_oidmap_get(grafts->commits, oid)) == NULL) + return GIT_ENOTFOUND; + + if ((error = git_oidmap_delete(grafts->commits, oid)) < 0) + return error; + + git__free(graft); + + return 0; +} + +int git_grafts_get(git_commit_graft **out, git_grafts *grafts, const git_oid *oid) +{ + assert(out && grafts && oid); + if ((*out = git_oidmap_get(grafts->commits, oid)) == NULL) + return GIT_ENOTFOUND; + return 0; +} + +size_t git_grafts_size(git_grafts *grafts) +{ + return git_oidmap_size(grafts->commits); +} diff --git a/src/graft.h b/src/grafts.h similarity index 50% rename from src/graft.h rename to src/grafts.h index e2afb971131..76e8d3f2966 100644 --- a/src/graft.h +++ b/src/grafts.h @@ -17,13 +17,15 @@ typedef struct { git_array_oid_t parents; } git_commit_graft; -/* A special type of git_oidmap with git_commit_grafts as values */ -typedef git_oidmap git_graftmap; +typedef struct git_grafts git_grafts; -int git__graft_register(git_graftmap *grafts, const git_oid *oid, git_array_oid_t parents); -int git__graft_unregister(git_graftmap *grafts, const git_oid *oid); -void git__graft_clear(git_graftmap *grafts); +int git_grafts_new(git_grafts **out); +void git_grafts_free(git_grafts *grafts); +void git_grafts_clear(git_grafts *grafts); -int git__graft_for_oid(git_commit_graft **out, git_graftmap *grafts, const git_oid *oid); +int git_grafts_add(git_grafts *grafts, const git_oid *oid, git_array_oid_t parents); +int git_grafts_remove(git_grafts *grafts, const git_oid *oid); +int git_grafts_get(git_commit_graft **out, git_grafts *grafts, const git_oid *oid); +size_t git_grafts_size(git_grafts *grafts); #endif diff --git a/src/repository.c b/src/repository.c index 977c7100285..57b91410711 100644 --- a/src/repository.c +++ b/src/repository.c @@ -147,10 +147,7 @@ int git_repository__cleanup(git_repository *repo) git_repository_submodule_cache_clear(repo); git_cache_clear(&repo->objects); git_attr_cache_flush(repo); - - git__graft_clear(repo->grafts); - git_oidmap_free(repo->grafts); - + git_grafts_free(repo->grafts); git_array_clear(repo->shallow_oids); set_config(repo, NULL); @@ -259,7 +256,7 @@ static git_repository *repository_alloc(void) /* set all the entries in the configmap cache to `unset` */ git_repository__configmap_lookup_cache_clear(repo); - if (git_oidmap_new(&repo->grafts) < 0) + if (git_grafts_new(&repo->grafts) < 0) goto on_error; return repo; @@ -610,9 +607,8 @@ static int load_grafts(git_repository *repo) if (error < 0) goto cleanup; - if (updated) { - git__graft_clear(repo->grafts); - } + if (updated) + git_grafts_clear(repo->grafts); dup_contents.ptr = contents.ptr; git_buf_foreach_line(line_start, line_end, line_num, &dup_contents) { @@ -638,7 +634,7 @@ static int load_grafts(git_repository *repo) } } - if (git__graft_register(repo->grafts, &graft_oid, parents) < 0) { + if (git_grafts_add(repo->grafts, &graft_oid, parents) < 0) { git_error_set(GIT_ERROR_REPOSITORY, "Invalid graft at line %d", line_num); error = -1; goto cleanup; @@ -668,9 +664,8 @@ static int load_shallow(git_repository *repo) } git_array_foreach(roots, i, graft_oid) { - if ((error = git__graft_register(repo->grafts, graft_oid, parents)) < 0) { + if ((error = git_grafts_add(repo->grafts, graft_oid, parents)) < 0) return error; - } } return 0; } diff --git a/src/repository.h b/src/repository.h index f7c25f589e7..fd7c274a8dc 100644 --- a/src/repository.h +++ b/src/repository.h @@ -24,7 +24,7 @@ #include "attrcache.h" #include "submodule.h" #include "diff_driver.h" -#include "graft.h" +#include "grafts.h" #include "oidarray.h" #define DOT_GIT ".git" @@ -154,7 +154,7 @@ struct git_repository { unsigned int lru_counter; - git_graftmap *grafts; + git_grafts *grafts; git_oid graft_checksum; git_oid shallow_checksum; diff --git a/tests/grafts/basic.c b/tests/grafts/basic.c index 39755ee8224..f91397002d0 100644 --- a/tests/grafts/basic.c +++ b/tests/grafts/basic.c @@ -1,7 +1,7 @@ #include "clar_libgit2.h" #include "futils.h" -#include "graft.h" +#include "grafts.h" static git_repository *g_repo; @@ -17,29 +17,28 @@ void test_grafts_basic__cleanup(void) void test_grafts_basic__graft_add(void) { + git_array_oid_t parents = GIT_ARRAY_INIT; git_oid oid_src, *oid1; git_commit_graft *graft; - git_graftmap *grafts; - git_array_oid_t parents = GIT_ARRAY_INIT; + git_grafts *grafts; - cl_git_pass(git_oidmap_new(&grafts)); + cl_git_pass(git_grafts_new(&grafts)); cl_assert(oid1 = git_array_alloc(parents)); cl_git_pass(git_oid_fromstr(&oid_src, "2f3053cbff8a4ca2f0666de364ddb734a28a31a9")); git_oid_cpy(oid1, &oid_src); git_oid_fromstr(&oid_src, "f503807ffa920e407a600cfaee96b7152259acc7"); - cl_git_pass(git__graft_register(grafts, &oid_src, parents)); + cl_git_pass(git_grafts_add(grafts, &oid_src, parents)); git_array_clear(parents); - cl_assert_equal_i(1, git_oidmap_size(grafts)); - cl_git_pass(git__graft_for_oid(&graft, grafts, &oid_src)); + cl_assert_equal_i(1, git_grafts_size(grafts)); + cl_git_pass(git_grafts_get(&graft, grafts, &oid_src)); cl_assert_equal_s("f503807ffa920e407a600cfaee96b7152259acc7", git_oid_tostr_s(&graft->oid)); cl_assert_equal_i(1, git_array_size(graft->parents)); cl_assert_equal_s("2f3053cbff8a4ca2f0666de364ddb734a28a31a9", git_oid_tostr_s(git_array_get(graft->parents, 0))); - git__graft_clear(grafts); - git_oidmap_free(grafts); + git_grafts_free(grafts); } void test_grafts_basic__grafted_revwalk(void) From 14a309ab384a8732f692e468ac56c0d1831fce2f Mon Sep 17 00:00:00 2001 From: Patrick Steinhardt Date: Thu, 3 Oct 2019 11:17:10 +0200 Subject: [PATCH 010/608] repository: convert grafts parsing to use parse context Instead of using the newly introduced `git_buf_foreach_line`, which modifies the buffer itself, we should try to use our existing parsing infrastructure in "parse.h". Convert the grafts parsing code to make use of `git_parse_ctx`. Remove the `git_buf_foreach_line` macro, as grafts have been its sole user. --- src/buffer.h | 5 ---- src/repository.c | 68 +++++++++++++++++++++++------------------------- 2 files changed, 32 insertions(+), 41 deletions(-) diff --git a/src/buffer.h b/src/buffer.h index fc8fe140055..6b717d2e90c 100644 --- a/src/buffer.h +++ b/src/buffer.h @@ -219,9 +219,4 @@ int git_buf_splice( const char *data, size_t nb_to_insert); -/* warning: this will wreck your buf contents */ -#define git_buf_foreach_line(line_start, line_end, line_num, buf) \ - while (((line_start) = git__strsep(&(buf)->ptr, "\n")) != NULL && \ - ((line_end) = (line_start) + strlen((line_start))) != NULL && ++(line_num)) - #endif diff --git a/src/repository.c b/src/repository.c index 57b91410711..4465d8e7968 100644 --- a/src/repository.c +++ b/src/repository.c @@ -31,6 +31,7 @@ #include "annotated_commit.h" #include "submodule.h" #include "worktree.h" +#include "parse.h" #include "strmap.h" @@ -581,14 +582,11 @@ static int find_repo( static int load_grafts(git_repository *repo) { + git_array_oid_t parents = GIT_ARRAY_INIT; git_buf graft_path = GIT_BUF_INIT; git_buf contents = GIT_BUF_INIT; - git_buf dup_contents; - const char *line_start; - const char *line_end; - int line_num = 0; + git_parse_ctx parser; int error, updated; - git_array_oid_t parents = GIT_ARRAY_INIT; if ((error = git_repository_item_path(&graft_path, repo, GIT_REPOSITORY_ITEM_INFO)) < 0) return error; @@ -598,54 +596,52 @@ static int load_grafts(git_repository *repo) return error; } - error = git_futils_readbuffer_updated(&contents, git_buf_cstr(&graft_path), &repo->graft_checksum, &updated); - git_buf_dispose(&graft_path); + error = git_futils_readbuffer_updated(&contents, git_buf_cstr(&graft_path), + &repo->graft_checksum, &updated); + if (error < 0 || error == GIT_ENOTFOUND || !updated) { + if (error == GIT_ENOTFOUND) + error = 0; + goto cleanup; + } - if (error == GIT_ENOTFOUND || !updated) - return 0; + git_grafts_clear(repo->grafts); - if (error < 0) + if ((error = git_parse_ctx_init(&parser, contents.ptr, contents.size)) < 0) goto cleanup; - if (updated) - git_grafts_clear(repo->grafts); - - dup_contents.ptr = contents.ptr; - git_buf_foreach_line(line_start, line_end, line_num, &dup_contents) { - git_oid graft_oid, parent_oid; + for (; parser.remain_len; git_parse_advance_line(&parser)) { + const char *line_start = parser.line, *line_end = parser.line + parser.line_len; + git_oid graft_oid; - error = git_oid_fromstrn(&graft_oid, line_start, GIT_OID_HEXSZ); - if (error < 0) { - git_error_set(GIT_ERROR_REPOSITORY, "Invalid OID at line %d", line_num); - error = -1; - } + if (git_oid_fromstrn(&graft_oid, line_start, GIT_OID_HEXSZ) < 0) + goto invalid_oid; line_start += GIT_OID_HEXSZ; - if (*(line_start++) == ' ') { - while (git_oid_fromstrn(&parent_oid, line_start, GIT_OID_HEXSZ) == 0) { - git_oid *id = git_array_alloc(parents); + while (line_start < line_end && *line_start == ' ') { + git_oid *id = git_array_alloc(parents); + GIT_ERROR_CHECK_ALLOC(id); - git_oid_cpy(id, &parent_oid); - line_start += GIT_OID_HEXSZ; - if (line_start >= line_end) { - break; - } - line_start += 1; - } + if (git_oid_fromstrn(id, ++line_start, GIT_OID_HEXSZ) < 0) + goto invalid_oid; + line_start += GIT_OID_HEXSZ; } - if (git_grafts_add(repo->grafts, &graft_oid, parents) < 0) { - git_error_set(GIT_ERROR_REPOSITORY, "Invalid graft at line %d", line_num); - error = -1; + if ((error = git_grafts_add(repo->grafts, &graft_oid, parents)) < 0) goto cleanup; - } + git_array_clear(parents); - line_num++; + continue; + +invalid_oid: + git_error_set(GIT_ERROR_REPOSITORY, "invalid OID at line %" PRIuZ, parser.line_num); + error = -1; + goto cleanup; } cleanup: git_array_clear(parents); git_buf_dispose(&contents); + git_buf_dispose(&graft_path); return error; } From 05e286fba318d21147347a572b05b0d1dac79610 Mon Sep 17 00:00:00 2001 From: Patrick Steinhardt Date: Tue, 12 May 2020 11:30:27 +0200 Subject: [PATCH 011/608] grafts: move parsing into grafts module Parsing of grafts files is currently contained in the repository code. To make grafts-related logic more self-contained, move it into "grafts.c" instead. --- include/git2/errors.h | 3 +- src/grafts.c | 46 +++++++++++++ src/grafts.h | 1 + src/repository.c | 37 +---------- tests/grafts/parse.c | 149 ++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 199 insertions(+), 37 deletions(-) create mode 100644 tests/grafts/parse.c diff --git a/include/git2/errors.h b/include/git2/errors.h index 8887b329901..47a79b76ccb 100644 --- a/include/git2/errors.h +++ b/include/git2/errors.h @@ -108,7 +108,8 @@ typedef enum { GIT_ERROR_WORKTREE, GIT_ERROR_SHA1, GIT_ERROR_HTTP, - GIT_ERROR_INTERNAL + GIT_ERROR_INTERNAL, + GIT_ERROR_GRAFTS } git_error_t; /** diff --git a/src/grafts.c b/src/grafts.c index 90490d0ac29..8ae39f4ac0b 100644 --- a/src/grafts.c +++ b/src/grafts.c @@ -7,6 +7,8 @@ #include "grafts.h" +#include "parse.h" + struct git_grafts { /* Map of `git_commit_graft`s */ git_oidmap *commits; @@ -51,6 +53,50 @@ void git_grafts_clear(git_grafts *grafts) git_oidmap_clear(grafts->commits); } +int git_grafts_parse(git_grafts *grafts, const char *content, size_t contentlen) +{ + git_array_oid_t parents = GIT_ARRAY_INIT; + git_parse_ctx parser; + int error; + + git_grafts_clear(grafts); + + if ((error = git_parse_ctx_init(&parser, content, contentlen)) < 0) + goto error; + + for (; parser.remain_len; git_parse_advance_line(&parser)) { + const char *line_start = parser.line, *line_end = parser.line + parser.line_len; + git_oid graft_oid; + + if ((error = git_oid_fromstrn(&graft_oid, line_start, GIT_OID_HEXSZ)) < 0) { + git_error_set(GIT_ERROR_GRAFTS, "invalid graft OID at line %" PRIuZ, parser.line_num); + goto error; + } + line_start += GIT_OID_HEXSZ; + + while (line_start < line_end && *line_start == ' ') { + git_oid *id = git_array_alloc(parents); + GIT_ERROR_CHECK_ALLOC(id); + + if ((error = git_oid_fromstrn(id, ++line_start, GIT_OID_HEXSZ)) < 0) { + git_error_set(GIT_ERROR_GRAFTS, "invalid parent OID at line %" PRIuZ, parser.line_num); + goto error; + } + + line_start += GIT_OID_HEXSZ; + } + + if ((error = git_grafts_add(grafts, &graft_oid, parents)) < 0) + goto error; + + git_array_clear(parents); + } + +error: + git_array_clear(parents); + return error; +} + int git_grafts_add(git_grafts *grafts, const git_oid *oid, git_array_oid_t parents) { git_commit_graft *graft; diff --git a/src/grafts.h b/src/grafts.h index 76e8d3f2966..723792ded83 100644 --- a/src/grafts.h +++ b/src/grafts.h @@ -23,6 +23,7 @@ int git_grafts_new(git_grafts **out); void git_grafts_free(git_grafts *grafts); void git_grafts_clear(git_grafts *grafts); +int git_grafts_parse(git_grafts *grafts, const char *content, size_t contentlen); int git_grafts_add(git_grafts *grafts, const git_oid *oid, git_array_oid_t parents); int git_grafts_remove(git_grafts *grafts, const git_oid *oid); int git_grafts_get(git_commit_graft **out, git_grafts *grafts, const git_oid *oid); diff --git a/src/repository.c b/src/repository.c index 4465d8e7968..7721c3cd00a 100644 --- a/src/repository.c +++ b/src/repository.c @@ -31,7 +31,6 @@ #include "annotated_commit.h" #include "submodule.h" #include "worktree.h" -#include "parse.h" #include "strmap.h" @@ -582,10 +581,8 @@ static int find_repo( static int load_grafts(git_repository *repo) { - git_array_oid_t parents = GIT_ARRAY_INIT; git_buf graft_path = GIT_BUF_INIT; git_buf contents = GIT_BUF_INIT; - git_parse_ctx parser; int error, updated; if ((error = git_repository_item_path(&graft_path, repo, GIT_REPOSITORY_ITEM_INFO)) < 0) @@ -604,42 +601,10 @@ static int load_grafts(git_repository *repo) goto cleanup; } - git_grafts_clear(repo->grafts); - - if ((error = git_parse_ctx_init(&parser, contents.ptr, contents.size)) < 0) - goto cleanup; - - for (; parser.remain_len; git_parse_advance_line(&parser)) { - const char *line_start = parser.line, *line_end = parser.line + parser.line_len; - git_oid graft_oid; - - if (git_oid_fromstrn(&graft_oid, line_start, GIT_OID_HEXSZ) < 0) - goto invalid_oid; - line_start += GIT_OID_HEXSZ; - - while (line_start < line_end && *line_start == ' ') { - git_oid *id = git_array_alloc(parents); - GIT_ERROR_CHECK_ALLOC(id); - - if (git_oid_fromstrn(id, ++line_start, GIT_OID_HEXSZ) < 0) - goto invalid_oid; - line_start += GIT_OID_HEXSZ; - } - - if ((error = git_grafts_add(repo->grafts, &graft_oid, parents)) < 0) - goto cleanup; - - git_array_clear(parents); - continue; - -invalid_oid: - git_error_set(GIT_ERROR_REPOSITORY, "invalid OID at line %" PRIuZ, parser.line_num); - error = -1; + if ((error = git_grafts_parse(repo->grafts, contents.ptr, contents.size)) < 0) goto cleanup; - } cleanup: - git_array_clear(parents); git_buf_dispose(&contents); git_buf_dispose(&graft_path); diff --git a/tests/grafts/parse.c b/tests/grafts/parse.c new file mode 100644 index 00000000000..de110c90110 --- /dev/null +++ b/tests/grafts/parse.c @@ -0,0 +1,149 @@ +#include "clar_libgit2.h" + +#include "grafts.h" + +#define OID0 "c0368f9f9743e950e6cfe1f45a649f8a9dfcd97e" +#define OID1 "cfc50a0db87ce908fb8a8c5b8f7b4ab96eee8643" +#define OID2 "6914d97cd08b9edf5e855fca211c750fa82fd80a" +#define OID3 "516521937d0e9ce9d0d836149a0702671f326b4a" +#define OID4 "e2c29d67ef2f217650196f94c796f0532b8caad6" +#define OID5 "79bcb936596cb50353fe7be28b7444e66e4a2842" +#define OID6 "b9c54107d57c17dbcaf646c4d52f66eb9e69d23d" +#define OID7 "9f8a746e9ad7b58cc840016bc3944d5ad262acb5" +#define OID8 "392f4beef7d0d15b2bc5b1abe1a754eba0ec36da" + +#define OID_TRUNCATED "392f4beef7d0d15b2bc5b1abe1a754eba0ec36d" +#define OID_NONHEX "9f8a746e9ax7b58cc840016bc3944d5ad262acb5" + +static git_grafts *grafts; + +void test_grafts_parse__initialize(void) +{ + cl_git_pass(git_grafts_new(&grafts)); +} + +void test_grafts_parse__cleanup(void) +{ + git_grafts_free(grafts); + grafts = NULL; +} + +static void assert_parse_succeeds(git_grafts *grafts, const char *string, size_t n) +{ + cl_git_pass(git_grafts_parse(grafts, string, strlen(string))); + cl_assert_equal_i(git_grafts_size(grafts), n); +} + +static void assert_parse_fails(git_grafts *grafts, const char *string) +{ + cl_git_fail(git_grafts_parse(grafts, string, strlen(string))); +} + +static void assert_graft_contains(git_grafts *grafts, const char *graft, size_t n, ...) +{ + git_commit_graft *commit; + git_oid oid; + va_list ap; + size_t i = 0; + + cl_git_pass(git_oid_fromstr(&oid, graft)); + cl_git_pass(git_grafts_get(&commit, grafts, &oid)); + cl_assert_equal_oid(&commit->oid, &oid); + cl_assert_equal_i(commit->parents.size, n); + + va_start(ap, n); + while (i < n) { + cl_git_pass(git_oid_fromstr(&oid, va_arg(ap, const char *))); + cl_assert_equal_oid(&commit->parents.ptr[i], &oid); + i++; + } + va_end(ap); +} + +void test_grafts_parse__single_oid(void) +{ + assert_parse_succeeds(grafts, OID1, 1); + assert_graft_contains(grafts, OID1, 0); +} + +void test_grafts_parse__single_oid_with_newline(void) +{ + assert_parse_succeeds(grafts, OID1 "\n", 1); + assert_graft_contains(grafts, OID1, 0); +} + +void test_grafts_parse__multiple_oids(void) +{ + assert_parse_succeeds(grafts, OID1 "\n" OID2 "\n" OID3, 3); + assert_graft_contains(grafts, OID1, 0); + assert_graft_contains(grafts, OID2, 0); + assert_graft_contains(grafts, OID3, 0); +} + +void test_grafts_parse__same_oid(void) +{ + assert_parse_succeeds(grafts, OID1 "\n" OID1, 1); + assert_graft_contains(grafts, OID1, 0); +} + +void test_grafts_parse__oid_with_parent(void) +{ + assert_parse_succeeds(grafts, OID1 " " OID2, 1); + assert_graft_contains(grafts, OID1, 1, OID2); +} + +void test_grafts_parse__oid_with_parent_and_newline(void) +{ + assert_parse_succeeds(grafts, OID1 " " OID2 "\n", 1); + assert_graft_contains(grafts, OID1, 1, OID2); +} + +void test_grafts_parse__oid_with_multiple_parents(void) +{ + assert_parse_succeeds(grafts, OID1 " " OID2 " " OID3 " " OID4 " " OID5, 1); + assert_graft_contains(grafts, OID1, 4, OID2, OID3, OID4, OID5); +} + +void test_grafts_parse__multiple_oids_with_multiple_parents(void) +{ + assert_parse_succeeds(grafts, + OID1 " " OID2 " " OID3 " " OID4 " " OID5 "\n" + OID6 " " OID7 " " OID8 "\n" , 2); + assert_graft_contains(grafts, OID1, 4, OID2, OID3, OID4, OID5); + assert_graft_contains(grafts, OID6, 2, OID7, OID8); +} + +void test_grafts_parse__multiple_spaces_fails(void) +{ + assert_parse_fails(grafts, OID1 " " OID2); +} + +void test_grafts_parse__trailing_space_fails(void) +{ + assert_parse_fails(grafts, OID1 " " OID2 " "); +} + +void test_grafts_parse__invalid_character_inbetween_fails(void) +{ + assert_parse_fails(grafts, OID1 " x " OID2); +} + +void test_grafts_parse__truncated_oid_fails(void) +{ + assert_parse_fails(grafts, OID_TRUNCATED); +} + +void test_grafts_parse__truncated_parent_fails(void) +{ + assert_parse_fails(grafts, OID1 " " OID_TRUNCATED); +} + +void test_grafts_parse__invalid_oid_fails(void) +{ + assert_parse_fails(grafts, OID_NONHEX); +} + +void test_grafts_parse__invalid_parent_fails(void) +{ + assert_parse_fails(grafts, OID1 " " OID_NONHEX); +} From a11026ecbb3575b02638ae060b20e77227e2291c Mon Sep 17 00:00:00 2001 From: Patrick Steinhardt Date: Thu, 24 Oct 2019 13:30:24 +0200 Subject: [PATCH 012/608] repository: reuse grafts for shallow roots The shallow roots are in fact another user of the grafting mechanism, and in essence they do use the same file format for grafted commits. Thus, instead of hand-coding the parsing logic a second time, we can just reuse the `git_grafts` structure for shallow commits, as well. --- include/git2/repository.h | 3 +- src/grafts.c | 21 ++++++++ src/grafts.h | 1 + src/repository.c | 103 ++++++++++++-------------------------- src/repository.h | 4 +- tests/grafts/shallow.c | 21 ++++---- 6 files changed, 68 insertions(+), 85 deletions(-) diff --git a/include/git2/repository.h b/include/git2/repository.h index 5a27cf08e8d..59e938710c7 100644 --- a/include/git2/repository.h +++ b/include/git2/repository.h @@ -878,7 +878,8 @@ GIT_EXTERN(int) git_repository_is_shallow(git_repository *repo); /** * Determine the shallow roots of the repository * - * This oidarray is owned by the library. Do not free it. + * The resulting OID array needs to be free'd by calling + * `git_oidarray_free`. * * @param out An array of shallow oids. * @param repo The repository diff --git a/src/grafts.c b/src/grafts.c index 8ae39f4ac0b..23b012ce8eb 100644 --- a/src/grafts.c +++ b/src/grafts.c @@ -7,6 +7,7 @@ #include "grafts.h" +#include "oidarray.h" #include "parse.h" struct git_grafts { @@ -155,6 +156,26 @@ int git_grafts_get(git_commit_graft **out, git_grafts *grafts, const git_oid *oi return 0; } +int git_grafts_get_oids(git_oidarray *out, git_grafts *grafts) +{ + git_array_oid_t oids = GIT_ARRAY_INIT; + const git_oid *oid; + size_t i = 0; + int error; + + assert(out && grafts); + + while ((error = git_oidmap_iterate(NULL, grafts->commits, &i, &oid)) == 0) { + git_oid *cpy = git_array_alloc(oids); + GIT_ERROR_CHECK_ALLOC(cpy); + git_oid_cpy(cpy, oid); + } + + git_oidarray__from_array(out, &oids); + + return 0; +} + size_t git_grafts_size(git_grafts *grafts) { return git_oidmap_size(grafts->commits); diff --git a/src/grafts.h b/src/grafts.h index 723792ded83..305b0d61adf 100644 --- a/src/grafts.h +++ b/src/grafts.h @@ -27,6 +27,7 @@ int git_grafts_parse(git_grafts *grafts, const char *content, size_t contentlen) int git_grafts_add(git_grafts *grafts, const git_oid *oid, git_array_oid_t parents); int git_grafts_remove(git_grafts *grafts, const git_oid *oid); int git_grafts_get(git_commit_graft **out, git_grafts *grafts, const git_oid *oid); +int git_grafts_get_oids(git_oidarray *out, git_grafts *grafts); size_t git_grafts_size(git_grafts *grafts); #endif diff --git a/src/repository.c b/src/repository.c index 7721c3cd00a..fc14ef4d6e2 100644 --- a/src/repository.c +++ b/src/repository.c @@ -148,7 +148,7 @@ int git_repository__cleanup(git_repository *repo) git_cache_clear(&repo->objects); git_attr_cache_flush(repo); git_grafts_free(repo->grafts); - git_array_clear(repo->shallow_oids); + git_grafts_free(repo->shallow_grafts); set_config(repo, NULL); set_index(repo, NULL); @@ -613,22 +613,22 @@ static int load_grafts(git_repository *repo) static int load_shallow(git_repository *repo) { - int error = 0; - git_array_oid_t roots = GIT_ARRAY_INIT; git_array_oid_t parents = GIT_ARRAY_INIT; + git_oidarray roots; + int error; size_t i; - git_oid *graft_oid; /* Graft shallow roots */ - if ((error = git_repository__shallow_roots(&roots, repo)) < 0) { - return error; - } + if ((error = git_repository_shallow_roots(&roots, repo)) < 0) + goto out; - git_array_foreach(roots, i, graft_oid) { - if ((error = git_grafts_add(repo->grafts, graft_oid, parents)) < 0) - return error; - } - return 0; + for (i = 0; i < roots.count; i++) + if ((error = git_grafts_add(repo->grafts, &roots.ids[i], parents)) < 0) + goto out; + +out: + git_oidarray_free(&roots); + return error; } int git_repository_open_bare( @@ -2960,79 +2960,38 @@ int git_repository_state_cleanup(git_repository *repo) return git_repository__cleanup_files(repo, state_files, ARRAY_SIZE(state_files)); } -int git_repository__shallow_roots(git_array_oid_t *out, git_repository *repo) +int git_repository_shallow_roots(git_oidarray *out, git_repository *repo) { - git_buf path = GIT_BUF_INIT; - git_buf contents = GIT_BUF_INIT; - int error, updated, line_num = 1; - char *line; - char *buffer; - - assert(out && repo); - - if ((error = git_buf_joinpath(&path, repo->gitdir, "shallow")) < 0) - return error; - - error = git_futils_readbuffer_updated(&contents, git_buf_cstr(&path), &repo->shallow_checksum, &updated); - git_buf_dispose(&path); + git_buf path = GIT_BUF_INIT, contents = GIT_BUF_INIT; + int error, updated = 0; - if (error < 0 && error != GIT_ENOTFOUND) - return error; - - /* cancel out GIT_ENOTFOUND */ - git_error_clear(); - error = 0; - - if (!updated) { - *out = repo->shallow_oids; - goto cleanup; - } + assert(out && repo); - git_array_clear(repo->shallow_oids); + memset(out, 0, sizeof(*out)); - buffer = contents.ptr; - while ((line = git__strsep(&buffer, "\n")) != NULL) { - git_oid *oid = git_array_alloc(repo->shallow_oids); + if (!repo->shallow_grafts && (error = git_grafts_new(&repo->shallow_grafts)) < 0) + goto error; - error = git_oid_fromstr(oid, line); - if (error < 0) { - git_error_set(GIT_ERROR_REPOSITORY, "Invalid OID at line %d", line_num); - git_array_clear(repo->shallow_oids); - error = -1; - goto cleanup; - } - ++line_num; + if ((error = git_buf_joinpath(&path, repo->gitdir, "shallow")) < 0 || + (error = git_futils_readbuffer_updated(&contents, git_buf_cstr(&path), + &repo->shallow_checksum, &updated)) < 0) { + if (error == GIT_ENOTFOUND) + error = 0; + goto error; } - if (*buffer) { - git_error_set(GIT_ERROR_REPOSITORY, "No EOL at line %d", line_num); - git_array_clear(repo->shallow_oids); - error = -1; - goto cleanup; - } + if (updated && (error = git_grafts_parse(repo->shallow_grafts, contents.ptr, contents.size)) < 0) + goto error; - *out = repo->shallow_oids; + if ((error = git_grafts_get_oids(out, repo->shallow_grafts)) < 0) + goto error; -cleanup: +error: + git_buf_dispose(&path); git_buf_dispose(&contents); - return error; } -int git_repository_shallow_roots(git_oidarray *out, git_repository *repo) -{ - int ret; - git_array_oid_t array = GIT_ARRAY_INIT; - - assert(out); - - ret = git_repository__shallow_roots(&array, repo); - - git_oidarray__from_array(out, &array); - - return ret; -} - int git_repository_is_shallow(git_repository *repo) { git_buf path = GIT_BUF_INIT; diff --git a/src/repository.h b/src/repository.h index fd7c274a8dc..14b2665675e 100644 --- a/src/repository.h +++ b/src/repository.h @@ -157,8 +157,8 @@ struct git_repository { git_grafts *grafts; git_oid graft_checksum; + git_grafts *shallow_grafts; git_oid shallow_checksum; - git_array_oid_t shallow_oids; git_atomic attr_session_key; @@ -263,6 +263,4 @@ extern size_t git_repository__reserved_names_posix_len; bool git_repository__reserved_names( git_buf **out, size_t *outlen, git_repository *repo, bool include_ntfs); -int git_repository__shallow_roots(git_array_oid_t *out, git_repository *repo); - #endif diff --git a/tests/grafts/shallow.c b/tests/grafts/shallow.c index e4a0f741f0b..fc74de4385b 100644 --- a/tests/grafts/shallow.c +++ b/tests/grafts/shallow.c @@ -42,38 +42,41 @@ void test_grafts_shallow__clears_errors(void) void test_grafts_shallow__shallow_oids(void) { - git_oidarray oids, oids2; + git_oidarray oids; g_repo = cl_git_sandbox_init("shallow.git"); cl_git_pass(git_repository_shallow_roots(&oids, g_repo)); cl_assert_equal_i(1, oids.count); cl_assert_equal_oid(&g_shallow_oid, &oids.ids[0]); - cl_git_pass(git_repository_shallow_roots(&oids2, g_repo)); - cl_assert_equal_p(oids.ids, oids2.ids); + git_oidarray_free(&oids); } void test_grafts_shallow__cache_clearing(void) { - git_oidarray oids, oids2; + git_oidarray oids; git_oid tmp_oid; - git_oid_fromstr(&tmp_oid, "0000000000000000000000000000000000000000"); + cl_git_pass(git_oid_fromstr(&tmp_oid, "0000000000000000000000000000000000000000")); g_repo = cl_git_sandbox_init("shallow.git"); cl_git_pass(git_repository_shallow_roots(&oids, g_repo)); cl_assert_equal_i(1, oids.count); cl_assert_equal_oid(&g_shallow_oid, &oids.ids[0]); + git_oidarray_free(&oids); cl_git_mkfile("shallow.git/shallow", "be3563ae3f795b2b4353bcce3a527ad0a4f7f644\n" "0000000000000000000000000000000000000000\n" ); - cl_git_pass(git_repository_shallow_roots(&oids2, g_repo)); - cl_assert_equal_i(2, oids2.count); - cl_assert_equal_oid(&g_shallow_oid, &oids2.ids[0]); - cl_assert_equal_oid(&tmp_oid, &oids2.ids[1]); + cl_git_pass(git_repository_shallow_roots(&oids, g_repo)); + cl_assert_equal_i(2, oids.count); + cl_assert((git_oid_equal(&g_shallow_oid, &oids.ids[0]) && + git_oid_equal(&tmp_oid, &oids.ids[1])) || + (git_oid_equal(&g_shallow_oid, &oids.ids[1]) && + git_oid_equal(&tmp_oid, &oids.ids[0]))); + git_oidarray_free(&oids); cl_git_pass(p_unlink("shallow.git/shallow")); cl_git_pass(git_repository_shallow_roots(&oids, g_repo)); From 70867f7c594ea6960c07d10fef32c932f7fa3bbb Mon Sep 17 00:00:00 2001 From: Patrick Steinhardt Date: Thu, 3 Oct 2019 13:08:24 +0200 Subject: [PATCH 013/608] repository: disentangle shallow and normal grafts When loading shallow grafts, we add each of the grafting commits to the grafts backed by ".git/info/grafts". Keeping track of both grafts separately, but partially storing them in a common grafts structure is likely to lead to inconsistencies. In fact, there already are inconsistencies if refreshing shallow grafts at a later point, as we only refresh the shallows, but not the normal grafts in that case. Disentangle both grafting stores and instead check both separately when parsing commits. --- src/commit.c | 3 ++- src/repository.c | 11 ++--------- 2 files changed, 4 insertions(+), 10 deletions(-) diff --git a/src/commit.c b/src/commit.c index e06faafe781..b498fd77eb7 100644 --- a/src/commit.c +++ b/src/commit.c @@ -504,7 +504,8 @@ int git_commit__parse_ext(git_commit *commit, git_odb_object *odb_obj, unsigned return error; /* Perform necessary grafts */ - if (git_grafts_get(&graft, repo->grafts, git_odb_object_id(odb_obj)) != GIT_ENOTFOUND) { + if (git_grafts_get(&graft, repo->grafts, git_odb_object_id(odb_obj)) == 0 || + git_grafts_get(&graft, repo->shallow_grafts, git_odb_object_id(odb_obj)) == 0) { size_t idx; git_oid *oid; git_array_clear(commit->parent_ids); diff --git a/src/repository.c b/src/repository.c index fc14ef4d6e2..cad80845d32 100644 --- a/src/repository.c +++ b/src/repository.c @@ -613,22 +613,15 @@ static int load_grafts(git_repository *repo) static int load_shallow(git_repository *repo) { - git_array_oid_t parents = GIT_ARRAY_INIT; git_oidarray roots; int error; - size_t i; /* Graft shallow roots */ if ((error = git_repository_shallow_roots(&roots, repo)) < 0) - goto out; - - for (i = 0; i < roots.count; i++) - if ((error = git_grafts_add(repo->grafts, &roots.ids[i], parents)) < 0) - goto out; + return error; -out: git_oidarray_free(&roots); - return error; + return 0; } int git_repository_open_bare( From fd2398b2fc09e3ae292fb33f2ec2a45b6bf8e3e9 Mon Sep 17 00:00:00 2001 From: Patrick Steinhardt Date: Thu, 3 Oct 2019 13:24:25 +0200 Subject: [PATCH 014/608] grafts: move refresh logic into grafts code The refresh logic for both "normal" and shallow grafts are currently part of the repository code and implemented twice. Unify them into the grafts code by introducing two new functions to create grafts from a file and to refresh a grafts structure. --- src/grafts.c | 55 ++++++++++++++++++++++++++++++++++++ src/grafts.h | 2 ++ src/repository.c | 73 ++++++++++-------------------------------------- src/repository.h | 3 -- 4 files changed, 72 insertions(+), 61 deletions(-) diff --git a/src/grafts.c b/src/grafts.c index 23b012ce8eb..da5bd10504b 100644 --- a/src/grafts.c +++ b/src/grafts.c @@ -7,12 +7,17 @@ #include "grafts.h" +#include "futils.h" #include "oidarray.h" #include "parse.h" struct git_grafts { /* Map of `git_commit_graft`s */ git_oidmap *commits; + + /* File backing the graft. NULL if it's an in-memory graft */ + char *path; + git_oid path_checksum; }; int git_grafts_new(git_grafts **out) @@ -31,10 +36,32 @@ int git_grafts_new(git_grafts **out) return 0; } +int git_grafts_from_file(git_grafts **out, const char *path) +{ + git_grafts *grafts = NULL; + int error; + + if ((error = git_grafts_new(&grafts)) < 0) + goto error; + + grafts->path = git__strdup(path); + GIT_ERROR_CHECK_ALLOC(grafts->path); + + if ((error = git_grafts_refresh(grafts)) < 0) + goto error; + + *out = grafts; +error: + if (error < 0) + git_grafts_free(grafts); + return error; +} + void git_grafts_free(git_grafts *grafts) { if (!grafts) return; + git__free(grafts->path); git_grafts_clear(grafts); git_oidmap_free(grafts->commits); git__free(grafts); @@ -54,6 +81,34 @@ void git_grafts_clear(git_grafts *grafts) git_oidmap_clear(grafts->commits); } +int git_grafts_refresh(git_grafts *grafts) +{ + git_buf contents = GIT_BUF_INIT; + int error, updated = 0; + + assert(grafts); + + if (!grafts->path) + return 0; + + error = git_futils_readbuffer_updated(&contents, grafts->path, + &grafts->path_checksum, &updated); + if (error < 0 || error == GIT_ENOTFOUND || !updated) { + if (error == GIT_ENOTFOUND) { + git_grafts_clear(grafts); + error = 0; + } + goto cleanup; + } + + if ((error = git_grafts_parse(grafts, contents.ptr, contents.size)) < 0) + goto cleanup; + +cleanup: + git_buf_dispose(&contents); + return error; +} + int git_grafts_parse(git_grafts *grafts, const char *content, size_t contentlen) { git_array_oid_t parents = GIT_ARRAY_INIT; diff --git a/src/grafts.h b/src/grafts.h index 305b0d61adf..30062725e27 100644 --- a/src/grafts.h +++ b/src/grafts.h @@ -20,9 +20,11 @@ typedef struct { typedef struct git_grafts git_grafts; int git_grafts_new(git_grafts **out); +int git_grafts_from_file(git_grafts **out, const char *path); void git_grafts_free(git_grafts *grafts); void git_grafts_clear(git_grafts *grafts); +int git_grafts_refresh(git_grafts *grafts); int git_grafts_parse(git_grafts *grafts, const char *content, size_t contentlen); int git_grafts_add(git_grafts *grafts, const git_oid *oid, git_array_oid_t parents); int git_grafts_remove(git_grafts *grafts, const git_oid *oid); diff --git a/src/repository.c b/src/repository.c index cad80845d32..730f19c20c7 100644 --- a/src/repository.c +++ b/src/repository.c @@ -256,9 +256,6 @@ static git_repository *repository_alloc(void) /* set all the entries in the configmap cache to `unset` */ git_repository__configmap_lookup_cache_clear(repo); - if (git_grafts_new(&repo->grafts) < 0) - goto on_error; - return repo; on_error: @@ -581,49 +578,25 @@ static int find_repo( static int load_grafts(git_repository *repo) { - git_buf graft_path = GIT_BUF_INIT; - git_buf contents = GIT_BUF_INIT; - int error, updated; - - if ((error = git_repository_item_path(&graft_path, repo, GIT_REPOSITORY_ITEM_INFO)) < 0) - return error; - - if (git_buf_joinpath(&graft_path, graft_path.ptr, "grafts")) { - git_buf_dispose(&graft_path); - return error; - } + git_buf path = GIT_BUF_INIT; + int error; - error = git_futils_readbuffer_updated(&contents, git_buf_cstr(&graft_path), - &repo->graft_checksum, &updated); - if (error < 0 || error == GIT_ENOTFOUND || !updated) { - if (error == GIT_ENOTFOUND) - error = 0; - goto cleanup; - } + if ((error = git_repository_item_path(&path, repo, GIT_REPOSITORY_ITEM_INFO)) < 0 || + (error = git_buf_joinpath(&path, path.ptr, "grafts")) < 0 || + (error = git_grafts_from_file(&repo->grafts, path.ptr)) < 0) + goto error; - if ((error = git_grafts_parse(repo->grafts, contents.ptr, contents.size)) < 0) - goto cleanup; + git_buf_clear(&path); -cleanup: - git_buf_dispose(&contents); - git_buf_dispose(&graft_path); + if ((error = git_buf_joinpath(&path, repo->gitdir, "shallow")) < 0 || + (error = git_grafts_from_file(&repo->shallow_grafts, path.ptr)) < 0) + goto error; +error: + git_buf_dispose(&path); return error; } -static int load_shallow(git_repository *repo) -{ - git_oidarray roots; - int error; - - /* Graft shallow roots */ - if ((error = git_repository_shallow_roots(&roots, repo)) < 0) - return error; - - git_oidarray_free(&roots); - return 0; -} - int git_repository_open_bare( git_repository **repo_ptr, const char *bare_path) @@ -916,9 +889,6 @@ int git_repository_open_ext( if ((error = load_grafts(repo)) < 0) goto cleanup; - if ((error = load_shallow(repo)) < 0) - goto cleanup; - if ((flags & GIT_REPOSITORY_OPEN_BARE) != 0) repo->is_bare = 1; else { @@ -2956,27 +2926,14 @@ int git_repository_state_cleanup(git_repository *repo) int git_repository_shallow_roots(git_oidarray *out, git_repository *repo) { git_buf path = GIT_BUF_INIT, contents = GIT_BUF_INIT; - int error, updated = 0; + int error; assert(out && repo); memset(out, 0, sizeof(*out)); - if (!repo->shallow_grafts && (error = git_grafts_new(&repo->shallow_grafts)) < 0) - goto error; - - if ((error = git_buf_joinpath(&path, repo->gitdir, "shallow")) < 0 || - (error = git_futils_readbuffer_updated(&contents, git_buf_cstr(&path), - &repo->shallow_checksum, &updated)) < 0) { - if (error == GIT_ENOTFOUND) - error = 0; - goto error; - } - - if (updated && (error = git_grafts_parse(repo->shallow_grafts, contents.ptr, contents.size)) < 0) - goto error; - - if ((error = git_grafts_get_oids(out, repo->shallow_grafts)) < 0) + if ((error = git_grafts_refresh(repo->shallow_grafts)) < 0 || + (error = git_grafts_get_oids(out, repo->shallow_grafts)) < 0) goto error; error: diff --git a/src/repository.h b/src/repository.h index 14b2665675e..81f2bc10114 100644 --- a/src/repository.h +++ b/src/repository.h @@ -155,10 +155,7 @@ struct git_repository { unsigned int lru_counter; git_grafts *grafts; - git_oid graft_checksum; - git_grafts *shallow_grafts; - git_oid shallow_checksum; git_atomic attr_session_key; From a4803c3c5ae2d3e038d56fcfe52215bc2364521a Mon Sep 17 00:00:00 2001 From: Patrick Steinhardt Date: Thu, 10 Oct 2019 13:40:22 +0200 Subject: [PATCH 015/608] grafts: fix memory leak if replacing pre-existing graft If replacing an already existing graft in the grafts map, then we need to free the previous `git_commit_graft` structure. --- src/grafts.c | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/grafts.c b/src/grafts.c index da5bd10504b..55eb33615ab 100644 --- a/src/grafts.c +++ b/src/grafts.c @@ -174,6 +174,8 @@ int git_grafts_add(git_grafts *grafts, const git_oid *oid, git_array_oid_t paren } git_oid_cpy(&graft->oid, oid); + if ((error = git_grafts_remove(grafts, &graft->oid)) < 0 && error != GIT_ENOTFOUND) + goto cleanup; if ((error = git_oidmap_set(grafts->commits, &graft->oid, graft)) < 0) goto cleanup; @@ -198,6 +200,7 @@ int git_grafts_remove(git_grafts *grafts, const git_oid *oid) if ((error = git_oidmap_delete(grafts->commits, oid)) < 0) return error; + git__free(graft->parents.ptr); git__free(graft); return 0; From 79af067665c37b6dc0b31edb35596c362b0cd9a0 Mon Sep 17 00:00:00 2001 From: Patrick Steinhardt Date: Thu, 24 Oct 2019 13:54:42 +0200 Subject: [PATCH 016/608] repository: do not expose grafting mechanism Currently, we expose the function `git_repository_shallow_roots` to get all grafted roots of the repository. This already paints us into a corner, though, as we certainly need to experiment with some functionality of the grafting mechanism before we can happily expose some of its functionality. Most importantly, we need to get right when to refresh grafts and when not. Thus, this commit removes the public function with no public replacement. We should first try and see what usecases people come up with to e.g. expose the `git_grafts` mechanism directly in the future or do something different altogether. Instead, we provide an internal interface to get weak pointers to the grafting structs part of the repository itself. --- include/git2/repository.h | 12 --------- src/repository.c | 33 +++++++++++------------- src/repository.h | 2 ++ tests/grafts/shallow.c | 53 ++++++++++++++++++++------------------- 4 files changed, 43 insertions(+), 57 deletions(-) diff --git a/include/git2/repository.h b/include/git2/repository.h index 59e938710c7..aa81e384352 100644 --- a/include/git2/repository.h +++ b/include/git2/repository.h @@ -875,18 +875,6 @@ GIT_EXTERN(const char *) git_repository_get_namespace(git_repository *repo); */ GIT_EXTERN(int) git_repository_is_shallow(git_repository *repo); -/** - * Determine the shallow roots of the repository - * - * The resulting OID array needs to be free'd by calling - * `git_oidarray_free`. - * - * @param out An array of shallow oids. - * @param repo The repository - * @return 0 on success, an error otherwise. - */ -GIT_EXTERN(int) git_repository_shallow_roots(git_oidarray *out, git_repository *repo); - /** * Retrieve the configured identity to use for reflogs * diff --git a/src/repository.c b/src/repository.c index 730f19c20c7..bc5ee6ac059 100644 --- a/src/repository.c +++ b/src/repository.c @@ -1263,6 +1263,20 @@ int git_repository_set_index(git_repository *repo, git_index *index) return 0; } +int git_repository_grafts__weakptr(git_grafts **out, git_repository *repo) +{ + assert(out && repo && repo->shallow_grafts); + *out = repo->grafts; + return 0; +} + +int git_repository_shallow_grafts__weakptr(git_grafts **out, git_repository *repo) +{ + assert(out && repo && repo->shallow_grafts); + *out = repo->shallow_grafts; + return 0; +} + int git_repository_set_namespace(git_repository *repo, const char *namespace) { git__free(repo->namespace); @@ -2923,25 +2937,6 @@ int git_repository_state_cleanup(git_repository *repo) return git_repository__cleanup_files(repo, state_files, ARRAY_SIZE(state_files)); } -int git_repository_shallow_roots(git_oidarray *out, git_repository *repo) -{ - git_buf path = GIT_BUF_INIT, contents = GIT_BUF_INIT; - int error; - - assert(out && repo); - - memset(out, 0, sizeof(*out)); - - if ((error = git_grafts_refresh(repo->shallow_grafts)) < 0 || - (error = git_grafts_get_oids(out, repo->shallow_grafts)) < 0) - goto error; - -error: - git_buf_dispose(&path); - git_buf_dispose(&contents); - return error; -} - int git_repository_is_shallow(git_repository *repo) { git_buf path = GIT_BUF_INIT; diff --git a/src/repository.h b/src/repository.h index 81f2bc10114..5922bf02a07 100644 --- a/src/repository.h +++ b/src/repository.h @@ -211,6 +211,8 @@ int git_repository_config__weakptr(git_config **out, git_repository *repo); int git_repository_odb__weakptr(git_odb **out, git_repository *repo); int git_repository_refdb__weakptr(git_refdb **out, git_repository *repo); int git_repository_index__weakptr(git_index **out, git_repository *repo); +int git_repository_grafts__weakptr(git_grafts **out, git_repository *repo); +int git_repository_shallow_grafts__weakptr(git_grafts **out, git_repository *repo); /* * Configuration map cache diff --git a/tests/grafts/shallow.c b/tests/grafts/shallow.c index fc74de4385b..8fe3421f280 100644 --- a/tests/grafts/shallow.c +++ b/tests/grafts/shallow.c @@ -1,5 +1,8 @@ #include "clar_libgit2.h" + #include "futils.h" +#include "grafts.h" +#include "repository.h" static git_repository *g_repo; static git_oid g_shallow_oid; @@ -42,61 +45,59 @@ void test_grafts_shallow__clears_errors(void) void test_grafts_shallow__shallow_oids(void) { - git_oidarray oids; - g_repo = cl_git_sandbox_init("shallow.git"); + git_commit_graft *graft; + git_grafts *grafts; - cl_git_pass(git_repository_shallow_roots(&oids, g_repo)); - cl_assert_equal_i(1, oids.count); - cl_assert_equal_oid(&g_shallow_oid, &oids.ids[0]); + g_repo = cl_git_sandbox_init("shallow.git"); - git_oidarray_free(&oids); + cl_git_pass(git_repository_shallow_grafts__weakptr(&grafts, g_repo)); + cl_assert_equal_i(1, git_grafts_size(grafts)); + cl_git_pass(git_grafts_get(&graft, grafts, &g_shallow_oid)); } void test_grafts_shallow__cache_clearing(void) { - git_oidarray oids; + git_commit_graft *graft; + git_grafts *grafts; git_oid tmp_oid; cl_git_pass(git_oid_fromstr(&tmp_oid, "0000000000000000000000000000000000000000")); g_repo = cl_git_sandbox_init("shallow.git"); + cl_git_pass(git_repository_shallow_grafts__weakptr(&grafts, g_repo)); - cl_git_pass(git_repository_shallow_roots(&oids, g_repo)); - cl_assert_equal_i(1, oids.count); - cl_assert_equal_oid(&g_shallow_oid, &oids.ids[0]); - git_oidarray_free(&oids); + cl_assert_equal_i(1, git_grafts_size(grafts)); + cl_git_pass(git_grafts_get(&graft, grafts, &g_shallow_oid)); cl_git_mkfile("shallow.git/shallow", "be3563ae3f795b2b4353bcce3a527ad0a4f7f644\n" "0000000000000000000000000000000000000000\n" ); - cl_git_pass(git_repository_shallow_roots(&oids, g_repo)); - cl_assert_equal_i(2, oids.count); - cl_assert((git_oid_equal(&g_shallow_oid, &oids.ids[0]) && - git_oid_equal(&tmp_oid, &oids.ids[1])) || - (git_oid_equal(&g_shallow_oid, &oids.ids[1]) && - git_oid_equal(&tmp_oid, &oids.ids[0]))); - git_oidarray_free(&oids); + cl_git_pass(git_grafts_refresh(grafts)); + cl_assert_equal_i(2, git_grafts_size(grafts)); + cl_git_pass(git_grafts_get(&graft, grafts, &g_shallow_oid)); + cl_git_pass(git_grafts_get(&graft, grafts, &tmp_oid)); cl_git_pass(p_unlink("shallow.git/shallow")); - cl_git_pass(git_repository_shallow_roots(&oids, g_repo)); - cl_assert_equal_i(0, oids.count); - git_oidarray_free(&oids); + cl_git_pass(git_grafts_refresh(grafts)); + cl_assert_equal_i(0, git_grafts_size(grafts)); } void test_grafts_shallow__errors_on_borked(void) { - git_oidarray oids; + git_grafts *grafts; g_repo = cl_git_sandbox_init("shallow.git"); cl_git_mkfile("shallow.git/shallow", "lolno"); - - cl_git_fail_with(-1, git_repository_shallow_roots(&oids, g_repo)); + cl_git_pass(git_repository_shallow_grafts__weakptr(&grafts, g_repo)); + cl_git_fail(git_grafts_refresh(grafts)); + cl_assert_equal_i(0, git_grafts_size(grafts)); cl_git_mkfile("shallow.git/shallow", "lolno\n"); - - cl_git_fail_with(-1, git_repository_shallow_roots(&oids, g_repo)); + cl_git_pass(git_repository_shallow_grafts__weakptr(&grafts, g_repo)); + cl_git_fail(git_grafts_refresh(grafts)); + cl_assert_equal_i(0, git_grafts_size(grafts)); } void test_grafts_shallow__revwalk_behavior(void) From 7ed00c5c92682edea3a67581c534ea5e970db038 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Patrick=20L=C3=BChne?= Date: Wed, 2 Jun 2021 16:31:54 +0200 Subject: [PATCH 017/608] Support authentication in push example This adds basic support for user/password and SSH authentication to the push example. Authentication is implemented by using the cred_acquire_cb credential callback defined in examples/common.c. Co-authored-by: Marius Knaust --- examples/push.c | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/examples/push.c b/examples/push.c index bcf307607b0..5113eed394b 100644 --- a/examples/push.c +++ b/examples/push.c @@ -32,6 +32,7 @@ /** Entry point for this command */ int lg2_push(git_repository *repo, int argc, char **argv) { git_push_options options; + git_remote_callbacks callbacks; git_remote* remote = NULL; char *refspec = "refs/heads/master"; const git_strarray refspecs = { @@ -47,7 +48,11 @@ int lg2_push(git_repository *repo, int argc, char **argv) { check_lg2(git_remote_lookup(&remote, repo, "origin" ), "Unable to lookup remote", NULL); + check_lg2(git_remote_init_callbacks(&callbacks, GIT_REMOTE_CALLBACKS_VERSION), "Error initializing remote callbacks", NULL); + callbacks.credentials = cred_acquire_cb; + check_lg2(git_push_options_init(&options, GIT_PUSH_OPTIONS_VERSION ), "Error initializing push", NULL); + options.callbacks = callbacks; check_lg2(git_remote_push(remote, &refspecs, &options), "Error pushing", NULL); From ed241cea1a2b1d195722d5de7e3295be9ea3a5e3 Mon Sep 17 00:00:00 2001 From: xphoniex Date: Mon, 28 Feb 2022 18:07:53 +0000 Subject: [PATCH 018/608] Swap `GIT_DIFF_LINE_(ADD|DEL)_EOFNL` to match other Diffs Signed-off-by: xphoniex --- src/libgit2/patch_parse.c | 4 ++-- tests/libgit2/diff/parse.c | 25 +++++++++++++++++++++++++ 2 files changed, 27 insertions(+), 2 deletions(-) diff --git a/src/libgit2/patch_parse.c b/src/libgit2/patch_parse.c index 78cd96252f8..be765febd0a 100644 --- a/src/libgit2/patch_parse.c +++ b/src/libgit2/patch_parse.c @@ -558,9 +558,9 @@ static int parse_hunk_header( static int eof_for_origin(int origin) { if (origin == GIT_DIFF_LINE_ADDITION) - return GIT_DIFF_LINE_ADD_EOFNL; - if (origin == GIT_DIFF_LINE_DELETION) return GIT_DIFF_LINE_DEL_EOFNL; + if (origin == GIT_DIFF_LINE_DELETION) + return GIT_DIFF_LINE_ADD_EOFNL; return GIT_DIFF_LINE_CONTEXT_EOFNL; } diff --git a/tests/libgit2/diff/parse.c b/tests/libgit2/diff/parse.c index d3a0c8de6d4..48f924fe087 100644 --- a/tests/libgit2/diff/parse.c +++ b/tests/libgit2/diff/parse.c @@ -279,6 +279,31 @@ static int file_cb(const git_diff_delta *delta, float progress, void *payload) return 0; } +void test_diff_parse__eof_nl_missing(void) +{ + const char patch[] = + "diff --git a/.env b/.env\n" + "index f89e4c0..7c56eb7 100644\n" + "--- a/.env\n" + "+++ b/.env\n" + "@@ -1 +1 @@\n" + "-hello=12345\n" + "+hello=123456\n" + "\\ No newline at end of file\n"; + git_diff *diff; + git_patch *ret_patch; + git_diff_line *line; + + cl_git_pass(git_diff_from_buffer(&diff, patch, strlen(patch))); + cl_git_pass(git_patch_from_diff(&ret_patch, diff, 0)); + + cl_assert((line = git_array_get(ret_patch->lines, 2)) != NULL); + cl_assert(line->origin == GIT_DIFF_LINE_DEL_EOFNL); + + git_diff_free(diff); + git_patch_free(ret_patch); +} + void test_diff_parse__foreach_works_with_parsed_patch(void) { const char patch[] = From 13bd14d930006bc01b89f9fd4d0b074c387ef92f Mon Sep 17 00:00:00 2001 From: Yuang Li Date: Mon, 27 Jun 2022 10:56:02 +0100 Subject: [PATCH 019/608] add feature flag for shallow clone support --- include/git2/common.h | 6 +++++- src/libgit2.c | 4 ++++ 2 files changed, 9 insertions(+), 1 deletion(-) diff --git a/include/git2/common.h b/include/git2/common.h index 2ee82902529..dff64103d87 100644 --- a/include/git2/common.h +++ b/include/git2/common.h @@ -211,7 +211,8 @@ typedef enum { GIT_OPT_SET_ODB_PACKED_PRIORITY, GIT_OPT_SET_ODB_LOOSE_PRIORITY, GIT_OPT_GET_EXTENSIONS, - GIT_OPT_SET_EXTENSIONS + GIT_OPT_SET_EXTENSIONS, + GIT_OPT_ENABLE_SHALLOW } git_libgit2_opt_t; /** @@ -448,6 +449,9 @@ typedef enum { * > { "!noop", "newext" } indicates that the caller does not want * > to support repositories with the `noop` extension but does want * > to support repositories with the `newext` extension. + * + * opts(GIT_OPT_ENABLE_SHALLOW, int enabled) + * > Enable or disable shallow clone support completely. * * @param option Option key * @param ... value to set the option diff --git a/src/libgit2.c b/src/libgit2.c index cc793b4587f..4eef2c618c4 100644 --- a/src/libgit2.c +++ b/src/libgit2.c @@ -390,6 +390,10 @@ int git_libgit2_opts(int key, ...) } break; + case GIT_OPT_ENABLE_SHALLOW: + git_cache__enabled = (va_arg(ap, int) != 0); + break; + default: git_error_set(GIT_ERROR_INVALID, "invalid option key"); error = -1; From 7a936258ddc93e012be8182a08f3c3e220bc6cbc Mon Sep 17 00:00:00 2001 From: Yuang Li Date: Mon, 27 Jun 2022 13:35:46 +0100 Subject: [PATCH 020/608] add test for shallow feature flag --- tests/shallow/feature_flag.c | 11 +++++++++++ 1 file changed, 11 insertions(+) create mode 100644 tests/shallow/feature_flag.c diff --git a/tests/shallow/feature_flag.c b/tests/shallow/feature_flag.c new file mode 100644 index 00000000000..25d283a4489 --- /dev/null +++ b/tests/shallow/feature_flag.c @@ -0,0 +1,11 @@ +#include "clar_libgit2.h" + +void test_shallow_feature_flag__set_feature_flag(void) +{ + cl_must_pass(git_libgit2_opts(GIT_OPT_ENABLE_SHALLOW, 1)); +} + +void test_shallow_feature_flag__unset_feature_flag(void) +{ + cl_must_pass(git_libgit2_opts(GIT_OPT_ENABLE_SHALLOW, 0)); +} From 89494f6787407269c1eaa868058e30e35145b02f Mon Sep 17 00:00:00 2001 From: Yuang Li Date: Mon, 27 Jun 2022 14:10:32 +0100 Subject: [PATCH 021/608] add shallow.h --- src/libgit2.c | 2 +- src/shallow.h | 3 +++ 2 files changed, 4 insertions(+), 1 deletion(-) create mode 100644 src/shallow.h diff --git a/src/libgit2.c b/src/libgit2.c index 4eef2c618c4..b6d2f0a80f7 100644 --- a/src/libgit2.c +++ b/src/libgit2.c @@ -391,7 +391,7 @@ int git_libgit2_opts(int key, ...) break; case GIT_OPT_ENABLE_SHALLOW: - git_cache__enabled = (va_arg(ap, int) != 0); + git_shallow__enabled = (va_arg(ap, int) != 0); break; default: diff --git a/src/shallow.h b/src/shallow.h new file mode 100644 index 00000000000..6e2bbbb5f6c --- /dev/null +++ b/src/shallow.h @@ -0,0 +1,3 @@ +#include "common.h" + +extern bool git_shallow__enabled; From 562246b415edf6abe9988d44e9044a8504989868 Mon Sep 17 00:00:00 2001 From: Yuang Li Date: Mon, 27 Jun 2022 15:34:35 +0100 Subject: [PATCH 022/608] move declaration of feature flag to graft.h/graft.c --- src/grafts.c | 2 ++ src/grafts.h | 2 ++ src/shallow.h | 3 --- 3 files changed, 4 insertions(+), 3 deletions(-) delete mode 100644 src/shallow.h diff --git a/src/grafts.c b/src/grafts.c index 55eb33615ab..94bbf7de2d5 100644 --- a/src/grafts.c +++ b/src/grafts.c @@ -11,6 +11,8 @@ #include "oidarray.h" #include "parse.h" +bool git_cache__enabled = true; + struct git_grafts { /* Map of `git_commit_graft`s */ git_oidmap *commits; diff --git a/src/grafts.h b/src/grafts.h index 30062725e27..fd9ef673698 100644 --- a/src/grafts.h +++ b/src/grafts.h @@ -19,6 +19,8 @@ typedef struct { typedef struct git_grafts git_grafts; +extern bool git_shallow__enabled; + int git_grafts_new(git_grafts **out); int git_grafts_from_file(git_grafts **out, const char *path); void git_grafts_free(git_grafts *grafts); diff --git a/src/shallow.h b/src/shallow.h deleted file mode 100644 index 6e2bbbb5f6c..00000000000 --- a/src/shallow.h +++ /dev/null @@ -1,3 +0,0 @@ -#include "common.h" - -extern bool git_shallow__enabled; From 6bab22f4d3c659a7d4282080ac4d662066411f55 Mon Sep 17 00:00:00 2001 From: Yuang Li Date: Mon, 27 Jun 2022 15:49:54 +0100 Subject: [PATCH 023/608] move feature flag tests to tests/grafts/shallow.c --- src/libgit2.c | 1 + tests/grafts/shallow.c | 10 ++++++++++ tests/shallow/feature_flag.c | 11 ----------- 3 files changed, 11 insertions(+), 11 deletions(-) delete mode 100644 tests/shallow/feature_flag.c diff --git a/src/libgit2.c b/src/libgit2.c index b6d2f0a80f7..a4f0b4007b8 100644 --- a/src/libgit2.c +++ b/src/libgit2.c @@ -12,6 +12,7 @@ #include "cache.h" #include "common.h" #include "filter.h" +#include "grafts.h" #include "hash.h" #include "index.h" #include "merge_driver.h" diff --git a/tests/grafts/shallow.c b/tests/grafts/shallow.c index 8fe3421f280..ac1d686af8f 100644 --- a/tests/grafts/shallow.c +++ b/tests/grafts/shallow.c @@ -7,6 +7,16 @@ static git_repository *g_repo; static git_oid g_shallow_oid; +void test_grafts_shallow__set_feature_flag(void) +{ + cl_git_pass(git_libgit2_opts(GIT_OPT_ENABLE_SHALLOW, 1)); +} + +void test_grafts_shallow__unset_feature_flag(void) +{ + cl_git_pass(git_libgit2_opts(GIT_OPT_ENABLE_SHALLOW, 0)); +} + void test_grafts_shallow__initialize(void) { cl_git_pass(git_oid_fromstr(&g_shallow_oid, "be3563ae3f795b2b4353bcce3a527ad0a4f7f644")); diff --git a/tests/shallow/feature_flag.c b/tests/shallow/feature_flag.c deleted file mode 100644 index 25d283a4489..00000000000 --- a/tests/shallow/feature_flag.c +++ /dev/null @@ -1,11 +0,0 @@ -#include "clar_libgit2.h" - -void test_shallow_feature_flag__set_feature_flag(void) -{ - cl_must_pass(git_libgit2_opts(GIT_OPT_ENABLE_SHALLOW, 1)); -} - -void test_shallow_feature_flag__unset_feature_flag(void) -{ - cl_must_pass(git_libgit2_opts(GIT_OPT_ENABLE_SHALLOW, 0)); -} From ad5635525131b3435a6dffab29eae439e932f2cd Mon Sep 17 00:00:00 2001 From: Yuang Li Date: Mon, 27 Jun 2022 16:27:00 +0100 Subject: [PATCH 024/608] use shallow feature flag in shallow clone support source code --- src/commit.c | 38 ++++++++++++++++++++++---------------- src/repository.c | 2 +- 2 files changed, 23 insertions(+), 17 deletions(-) diff --git a/src/commit.c b/src/commit.c index 2a1bafae23a..ab68634815f 100644 --- a/src/commit.c +++ b/src/commit.c @@ -500,29 +500,35 @@ int git_commit__parse_raw(void *commit, const char *data, size_t size) int git_commit__parse_ext(git_commit *commit, git_odb_object *odb_obj, unsigned int flags) { - git_repository *repo = git_object_owner((git_object *)commit); - git_commit_graft *graft; - int error; + int error; + if ((error = commit_parse(commit, git_odb_object_data(odb_obj), git_odb_object_size(odb_obj), flags)) < 0) return error; - /* Perform necessary grafts */ - if (git_grafts_get(&graft, repo->grafts, git_odb_object_id(odb_obj)) == 0 || - git_grafts_get(&graft, repo->shallow_grafts, git_odb_object_id(odb_obj)) == 0) { - size_t idx; - git_oid *oid; - git_array_clear(commit->parent_ids); - git_array_init_to_size(commit->parent_ids, git_array_size(graft->parents)); - git_array_foreach(graft->parents, idx, oid) { - git_oid *id = git_array_alloc(commit->parent_ids); - GIT_ERROR_CHECK_ALLOC(id); - - git_oid_cpy(id, oid); + if (GIT_OPT_ENABLE_SHALLOW) { + + git_repository *repo = git_object_owner((git_object *)commit); + git_commit_graft *graft; + + /* Perform necessary grafts */ + if (git_grafts_get(&graft, repo->grafts, git_odb_object_id(odb_obj)) == 0 || + git_grafts_get(&graft, repo->shallow_grafts, git_odb_object_id(odb_obj)) == 0) { + size_t idx; + git_oid *oid; + git_array_clear(commit->parent_ids); + git_array_init_to_size(commit->parent_ids, git_array_size(graft->parents)); + git_array_foreach(graft->parents, idx, oid) { + git_oid *id = git_array_alloc(commit->parent_ids); + GIT_ERROR_CHECK_ALLOC(id); + + git_oid_cpy(id, oid); + } } - } + } + return 0; } diff --git a/src/repository.c b/src/repository.c index 5297a884046..f9b34445c1f 100644 --- a/src/repository.c +++ b/src/repository.c @@ -926,7 +926,7 @@ int git_repository_open_ext( if ((error = check_extensions(config, version)) < 0) goto cleanup; - if ((error = load_grafts(repo)) < 0) + if (GIT_OPT_ENABLE_SHALLOW && (error = load_grafts(repo)) < 0) goto cleanup; if ((flags & GIT_REPOSITORY_OPEN_BARE) != 0) From c4cd9a54b83700bd9166a78af3986df0e42e1e92 Mon Sep 17 00:00:00 2001 From: Yuang Li Date: Mon, 27 Jun 2022 16:31:22 +0100 Subject: [PATCH 025/608] correct naming of feature flag --- src/grafts.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/grafts.c b/src/grafts.c index 94bbf7de2d5..0ffe4677a59 100644 --- a/src/grafts.c +++ b/src/grafts.c @@ -11,7 +11,7 @@ #include "oidarray.h" #include "parse.h" -bool git_cache__enabled = true; +bool git_shallow__enabled = true; struct git_grafts { /* Map of `git_commit_graft`s */ From 59189757116e2f793f0901afdfa0dea916d34444 Mon Sep 17 00:00:00 2001 From: Yuang Li Date: Tue, 28 Jun 2022 09:29:10 +0100 Subject: [PATCH 026/608] disable shallow clone support by default --- src/grafts.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/grafts.c b/src/grafts.c index 0ffe4677a59..00352261670 100644 --- a/src/grafts.c +++ b/src/grafts.c @@ -11,7 +11,7 @@ #include "oidarray.h" #include "parse.h" -bool git_shallow__enabled = true; +bool git_shallow__enabled = false; struct git_grafts { /* Map of `git_commit_graft`s */ From 397753f01701ed7e5148f147e3a126a0abbd33e4 Mon Sep 17 00:00:00 2001 From: Yuang Li Date: Tue, 28 Jun 2022 09:29:55 +0100 Subject: [PATCH 027/608] enable shallow clone support in tests when necessary --- tests/grafts/basic.c | 1 + tests/grafts/shallow.c | 1 + 2 files changed, 2 insertions(+) diff --git a/tests/grafts/basic.c b/tests/grafts/basic.c index f91397002d0..3d3c65aeb8b 100644 --- a/tests/grafts/basic.c +++ b/tests/grafts/basic.c @@ -7,6 +7,7 @@ static git_repository *g_repo; void test_grafts_basic__initialize(void) { + git_libgit2_opts(GIT_OPT_ENABLE_SHALLOW, 1); g_repo = cl_git_sandbox_init("grafted.git"); } diff --git a/tests/grafts/shallow.c b/tests/grafts/shallow.c index ac1d686af8f..339235860f2 100644 --- a/tests/grafts/shallow.c +++ b/tests/grafts/shallow.c @@ -19,6 +19,7 @@ void test_grafts_shallow__unset_feature_flag(void) void test_grafts_shallow__initialize(void) { + git_libgit2_opts(GIT_OPT_ENABLE_SHALLOW, 1); cl_git_pass(git_oid_fromstr(&g_shallow_oid, "be3563ae3f795b2b4353bcce3a527ad0a4f7f644")); } From 9d1507d1d36d640669d82f80d2b0151e11dbab2f Mon Sep 17 00:00:00 2001 From: Yuang Li Date: Tue, 28 Jun 2022 09:35:51 +0100 Subject: [PATCH 028/608] correct use of feature flag --- src/commit.c | 36 +++++++++++++++++------------------- src/repository.c | 3 ++- 2 files changed, 19 insertions(+), 20 deletions(-) diff --git a/src/commit.c b/src/commit.c index ab68634815f..a4899ed57cb 100644 --- a/src/commit.c +++ b/src/commit.c @@ -502,31 +502,29 @@ int git_commit__parse_ext(git_commit *commit, git_odb_object *odb_obj, unsigned { int error; - if ((error = commit_parse(commit, git_odb_object_data(odb_obj), git_odb_object_size(odb_obj), flags)) < 0) return error; - if (GIT_OPT_ENABLE_SHALLOW) { - - git_repository *repo = git_object_owner((git_object *)commit); - git_commit_graft *graft; - - /* Perform necessary grafts */ - if (git_grafts_get(&graft, repo->grafts, git_odb_object_id(odb_obj)) == 0 || - git_grafts_get(&graft, repo->shallow_grafts, git_odb_object_id(odb_obj)) == 0) { - size_t idx; - git_oid *oid; - git_array_clear(commit->parent_ids); - git_array_init_to_size(commit->parent_ids, git_array_size(graft->parents)); - git_array_foreach(graft->parents, idx, oid) { - git_oid *id = git_array_alloc(commit->parent_ids); - GIT_ERROR_CHECK_ALLOC(id); + if (!git_shallow__enabled) + return 0; - git_oid_cpy(id, oid); - } + git_repository *repo = git_object_owner((git_object *)commit); + git_commit_graft *graft; + + /* Perform necessary grafts */ + if (git_grafts_get(&graft, repo->grafts, git_odb_object_id(odb_obj)) == 0 || + git_grafts_get(&graft, repo->shallow_grafts, git_odb_object_id(odb_obj)) == 0) { + size_t idx; + git_oid *oid; + git_array_clear(commit->parent_ids); + git_array_init_to_size(commit->parent_ids, git_array_size(graft->parents)); + git_array_foreach(graft->parents, idx, oid) { + git_oid *id = git_array_alloc(commit->parent_ids); + GIT_ERROR_CHECK_ALLOC(id); + + git_oid_cpy(id, oid); } - } return 0; diff --git a/src/repository.c b/src/repository.c index f9b34445c1f..87874feceb2 100644 --- a/src/repository.c +++ b/src/repository.c @@ -14,6 +14,7 @@ #include "common.h" #include "commit.h" +#include "grafts.h" #include "tag.h" #include "blob.h" #include "futils.h" @@ -926,7 +927,7 @@ int git_repository_open_ext( if ((error = check_extensions(config, version)) < 0) goto cleanup; - if (GIT_OPT_ENABLE_SHALLOW && (error = load_grafts(repo)) < 0) + if (git_shallow__enabled && (error = load_grafts(repo)) < 0) goto cleanup; if ((flags & GIT_REPOSITORY_OPEN_BARE) != 0) From 06eacb91679f4d7c828c64c71081500219926f22 Mon Sep 17 00:00:00 2001 From: Yuang Li Date: Tue, 28 Jun 2022 11:23:59 +0100 Subject: [PATCH 029/608] fix graft assertion --- src/repository.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/repository.c b/src/repository.c index 87874feceb2..ab575379580 100644 --- a/src/repository.c +++ b/src/repository.c @@ -1315,7 +1315,7 @@ int git_repository_set_index(git_repository *repo, git_index *index) int git_repository_grafts__weakptr(git_grafts **out, git_repository *repo) { - assert(out && repo && repo->shallow_grafts); + assert(out && repo && repo->grafts); *out = repo->grafts; return 0; } From 70a332a51b6364507d19bd1821b22fabbd1f2e08 Mon Sep 17 00:00:00 2001 From: Yuang Li Date: Tue, 28 Jun 2022 11:57:50 +0100 Subject: [PATCH 030/608] disable shallow clone feature flag in test cleanup --- tests/grafts/basic.c | 1 + tests/grafts/shallow.c | 1 + 2 files changed, 2 insertions(+) diff --git a/tests/grafts/basic.c b/tests/grafts/basic.c index 3d3c65aeb8b..4be4a12bfc2 100644 --- a/tests/grafts/basic.c +++ b/tests/grafts/basic.c @@ -13,6 +13,7 @@ void test_grafts_basic__initialize(void) void test_grafts_basic__cleanup(void) { + git_libgit2_opts(GIT_OPT_ENABLE_SHALLOW, 0); cl_git_sandbox_cleanup(); } diff --git a/tests/grafts/shallow.c b/tests/grafts/shallow.c index 339235860f2..a75b5a0519b 100644 --- a/tests/grafts/shallow.c +++ b/tests/grafts/shallow.c @@ -25,6 +25,7 @@ void test_grafts_shallow__initialize(void) void test_grafts_shallow__cleanup(void) { + git_libgit2_opts(GIT_OPT_ENABLE_SHALLOW, 0); cl_git_sandbox_cleanup(); } From b29b9e8e29b4d96e8c1e3de1e902d56fab3e5320 Mon Sep 17 00:00:00 2001 From: nathannaveen <42319948+nathannaveen@users.noreply.github.com> Date: Sun, 3 Jul 2022 00:58:19 +0000 Subject: [PATCH 031/608] chore: Set permissions for GitHub actions MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Restrict the GitHub token permissions only to the required ones; this way, even if the attackers will succeed in compromising your workflow, they won’t be able to do much. - Included permissions for the action. https://github.com/ossf/scorecard/blob/main/docs/checks.md#token-permissions https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#permissions https://docs.github.com/en/actions/using-jobs/assigning-permissions-to-jobs [Keeping your GitHub Actions and workflows secure Part 1: Preventing pwn requests](https://securitylab.github.com/research/github-actions-preventing-pwn-requests/) Signed-off-by: nathannaveen <42319948+nathannaveen@users.noreply.github.com> --- .github/workflows/benchmark.yml | 3 +++ .github/workflows/codeql.yml | 7 +++++++ .github/workflows/nightly.yml | 3 +++ 3 files changed, 13 insertions(+) diff --git a/.github/workflows/benchmark.yml b/.github/workflows/benchmark.yml index 7ae14ca7e76..f7fcea1fbc9 100644 --- a/.github/workflows/benchmark.yml +++ b/.github/workflows/benchmark.yml @@ -6,6 +6,9 @@ on: schedule: - cron: '15 4 * * *' +permissions: + contents: read + jobs: # Run our nightly builds. We build a matrix with the various build # targets and their details. Then we build either in a docker container diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml index de1ec5e33e3..de6fbc22ecc 100644 --- a/.github/workflows/codeql.yml +++ b/.github/workflows/codeql.yml @@ -8,8 +8,15 @@ on: env: docker-registry: ghcr.io +permissions: + contents: read + jobs: analyze: + permissions: + actions: read # for github/codeql-action/init to get workflow details + contents: read # for actions/checkout to fetch code + security-events: write # for github/codeql-action/analyze to upload SARIF results name: Analyze runs-on: ubuntu-latest diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml index 5f80ed010b8..74001a4ea31 100644 --- a/.github/workflows/nightly.yml +++ b/.github/workflows/nightly.yml @@ -10,6 +10,9 @@ env: docker-registry: ghcr.io docker-config-path: source/ci/docker +permissions: + contents: read + jobs: # Run our nightly builds. We build a matrix with the various build # targets and their details. Then we build either in a docker container From afa79ca05862c24baa0360324ab7b63c0df90689 Mon Sep 17 00:00:00 2001 From: yuangli Date: Mon, 4 Jul 2022 17:08:04 +0100 Subject: [PATCH 032/608] Merge branch 'pr/tiennou/4747' into transportPR --- include/git2/remote.h | 7 +- include/git2/repository.h | 11 +++ include/git2/sys/transport.h | 17 ++++- src/array.h | 4 +- src/fetch.c | 22 +++++- src/object.c | 21 +++++- src/object.h | 6 ++ src/remote.h | 1 + src/repository.c | 89 +++++++++++++++++++++++ src/repository.h | 3 + src/transports/local.c | 6 +- src/transports/smart.c | 28 +++++++ src/transports/smart.h | 21 +++++- src/transports/smart_pkt.c | 90 +++++++++++++++++++++-- src/transports/smart_protocol.c | 63 +++++++++++++++- tests/clone/shallow.c | 55 ++++++++++++++ tests/repo/grafts.c | 119 ++++++++++++++++++++++++++++++ tests/repo/shallow.c | 125 ++++++++++++++++++++++++++++++++ 18 files changed, 659 insertions(+), 29 deletions(-) create mode 100644 tests/clone/shallow.c create mode 100644 tests/repo/grafts.c create mode 100644 tests/repo/shallow.c diff --git a/include/git2/remote.h b/include/git2/remote.h index 4d57eaaf74f..e577f8a7bde 100644 --- a/include/git2/remote.h +++ b/include/git2/remote.h @@ -738,11 +738,16 @@ typedef struct { * Extra headers for this fetch operation */ git_strarray custom_headers; + + /** + * Depth of the fetch to perform + */ + int depth; } git_fetch_options; #define GIT_FETCH_OPTIONS_VERSION 1 #define GIT_FETCH_OPTIONS_INIT { GIT_FETCH_OPTIONS_VERSION, GIT_REMOTE_CALLBACKS_INIT, GIT_FETCH_PRUNE_UNSPECIFIED, 1, \ - GIT_REMOTE_DOWNLOAD_TAGS_UNSPECIFIED, GIT_PROXY_OPTIONS_INIT } + GIT_REMOTE_DOWNLOAD_TAGS_UNSPECIFIED, GIT_PROXY_OPTIONS_INIT, { NULL }, -1 } /** * Initialize git_fetch_options structure diff --git a/include/git2/repository.h b/include/git2/repository.h index ec8adfb293b..bbf3ae4cd85 100644 --- a/include/git2/repository.h +++ b/include/git2/repository.h @@ -920,6 +920,17 @@ GIT_EXTERN(const char *) git_repository_get_namespace(git_repository *repo); */ GIT_EXTERN(int) git_repository_is_shallow(git_repository *repo); +/** + * Determine the shallow roots of the repository + * + * This oidarray is owned by the library. Do not free it. + * + * @param out An array of shallow oids. + * @param repo The repository + * @return 0 on success, an error otherwise. + */ +GIT_EXTERN(int) git_repository_shallow_roots(git_oidarray *out, git_repository *repo); + /** * Retrieve the configured identity to use for reflogs * diff --git a/include/git2/sys/transport.h b/include/git2/sys/transport.h index fee34544fa9..ea8bcb64b07 100644 --- a/include/git2/sys/transport.h +++ b/include/git2/sys/transport.h @@ -33,6 +33,15 @@ typedef enum { GIT_TRANSPORTFLAGS_NONE = 0, } git_transport_flags_t; +typedef struct git_shallowarray git_shallowarray; + +typedef struct { + const git_remote_head * const *refs; + size_t count; + git_shallowarray *shallow_roots; + int depth; +} git_fetch_negotiation; + struct git_transport { unsigned int version; /**< The struct version */ @@ -87,8 +96,7 @@ struct git_transport { int GIT_CALLBACK(negotiate_fetch)( git_transport *transport, git_repository *repo, - const git_remote_head * const *refs, - size_t count); + const git_fetch_negotiation *fetch_data); /** * Start downloading the packfile from the remote repository. @@ -435,6 +443,11 @@ GIT_EXTERN(int) git_smart_subtransport_ssh( git_transport *owner, void *param); +GIT_EXTERN(size_t) git_shallowarray_count(git_shallowarray *array); +GIT_EXTERN(const git_oid *) git_shallowarray_get(git_shallowarray *array, size_t idx); +GIT_EXTERN(int) git_shallowarray_add(git_shallowarray *array, git_oid *oid); +GIT_EXTERN(int) git_shallowarray_remove(git_shallowarray *array, git_oid *oid); + /** @} */ GIT_END_DECL #endif diff --git a/src/array.h b/src/array.h index e97688b365f..3d6c9113ce4 100644 --- a/src/array.h +++ b/src/array.h @@ -85,12 +85,14 @@ GIT_INLINE(int) git_array_grow(void *_a, size_t item_size) #define git_array_foreach(a, i, element) \ for ((i) = 0; (i) < (a).size && ((element) = &(a).ptr[(i)]); (i)++) +typedef int (*git_array_compare_cb)(const void *, const void *); + GIT_INLINE(int) git_array__search( size_t *out, void *array_ptr, size_t item_size, size_t array_len, - int (*compare)(const void *, const void *), + git_array_compare_cb compare, const void *key) { size_t lim; diff --git a/src/fetch.c b/src/fetch.c index dedbb54fa54..e08671db357 100644 --- a/src/fetch.c +++ b/src/fetch.c @@ -18,6 +18,7 @@ #include "netops.h" #include "repository.h" #include "refs.h" +#include "transports/smart.h" static int maybe_want(git_remote *remote, git_remote_head *head, git_odb *odb, git_refspec *tagspec, git_remote_autotag_option_t tagopt) { @@ -128,10 +129,18 @@ int git_fetch_negotiate(git_remote *remote, const git_fetch_options *opts) * Now we have everything set up so we can start tell the * server what we want and what we have. */ + remote->nego.refs = (const git_remote_head * const *)remote->refs.contents; + remote->nego.count = remote->refs.length; + remote->nego.depth = opts->depth; + remote->nego.shallow_roots = git__malloc(sizeof(git_shallowarray)); + + git_array_init(remote->nego.shallow_roots->array); + + git_repository__shallow_roots(&remote->nego.shallow_roots->array, remote->repo); + return t->negotiate_fetch(t, remote->repo, - (const git_remote_head * const *)remote->refs.contents, - remote->refs.length); + &remote->nego); } int git_fetch_download_pack(git_remote *remote, const git_remote_callbacks *callbacks) @@ -139,6 +148,7 @@ int git_fetch_download_pack(git_remote *remote, const git_remote_callbacks *call git_transport *t = remote->transport; git_indexer_progress_cb progress = NULL; void *payload = NULL; + int error; if (!remote->need_pack) return 0; @@ -148,7 +158,13 @@ int git_fetch_download_pack(git_remote *remote, const git_remote_callbacks *call payload = callbacks->payload; } - return t->download_pack(t, remote->repo, &remote->stats, progress, payload); + if ((error = t->download_pack(t, remote->repo, &remote->stats, progress, payload)) < 0) + return error; + + if ((error = git_repository__shallow_roots_write(remote->repo, remote->nego.shallow_roots->array)) < 0) + return error; + + return 0; } int git_fetch_options_init(git_fetch_options *opts, unsigned int version) diff --git a/src/object.c b/src/object.c index 42e1e46bcc5..b58f01a34e9 100644 --- a/src/object.c +++ b/src/object.c @@ -104,15 +104,13 @@ int git_object__from_raw( return 0; } -int git_object__from_odb_object( +int git_object__init_from_odb_object( git_object **object_out, git_repository *repo, git_odb_object *odb_obj, git_object_t type) { - int error; size_t object_size; - git_object_def *def; git_object *object = NULL; GIT_ASSERT_ARG(object_out); @@ -139,6 +137,23 @@ int git_object__from_odb_object( object->cached.size = odb_obj->cached.size; object->repo = repo; + *object_out = object; + return 0; +} + +int git_object__from_odb_object( + git_object **object_out, + git_repository *repo, + git_odb_object *odb_obj, + git_object_t type) +{ + int error; + git_object_def *def; + git_object *object = NULL; + + if ((error = git_object__init_from_odb_object(&object, repo, odb_obj, type)) < 0) + return error; + /* Parse raw object data */ def = &git_objects_table[odb_obj->cached.type]; GIT_ASSERT(def->free && def->parse); diff --git a/src/object.h b/src/object.h index 4b67936127e..71a966a92c2 100644 --- a/src/object.h +++ b/src/object.h @@ -35,6 +35,12 @@ int git_object__from_raw( size_t size, git_object_t type); +int git_object__init_from_odb_object( + git_object **object_out, + git_repository *repo, + git_odb_object *odb_obj, + git_object_t type); + int git_object__from_odb_object( git_object **object_out, git_repository *repo, diff --git a/src/remote.h b/src/remote.h index ce92db76aa5..8297af197f6 100644 --- a/src/remote.h +++ b/src/remote.h @@ -35,6 +35,7 @@ struct git_remote { git_remote_autotag_option_t download_tags; int prune_refs; int passed_refspecs; + git_fetch_negotiation nego; }; typedef struct git_remote_connection_opts { diff --git a/src/repository.c b/src/repository.c index ab575379580..537622273fd 100644 --- a/src/repository.c +++ b/src/repository.c @@ -3192,6 +3192,95 @@ int git_repository_state_cleanup(git_repository *repo) return git_repository__cleanup_files(repo, state_files, ARRAY_SIZE(state_files)); } +int git_repository__shallow_roots(git_array_oid_t *out, git_repository *repo) +{ + git_buf path = GIT_BUF_INIT; + git_buf contents = GIT_BUF_INIT; + int error, updated, line_num = 1; + char *line; + char *buffer; + + assert(out && repo); + + if ((error = git_buf_joinpath(&path, repo->gitdir, "shallow")) < 0) + return error; + + error = git_futils_readbuffer_updated(&contents, git_buf_cstr(&path), &repo->shallow_checksum, &updated); + git_buf_dispose(&path); + + if (error < 0 && error != GIT_ENOTFOUND) + return error; + + /* cancel out GIT_ENOTFOUND */ + git_error_clear(); + error = 0; + + if (!updated) { + *out = repo->shallow_oids; + goto cleanup; + } + + git_array_clear(repo->shallow_oids); + + buffer = contents.ptr; + while ((line = git__strsep(&buffer, "\n")) != NULL) { + git_oid *oid = git_array_alloc(repo->shallow_oids); + + error = git_oid_fromstr(oid, line); + if (error < 0) { + git_error_set(GIT_ERROR_REPOSITORY, "Invalid OID at line %d", line_num); + git_array_clear(repo->shallow_oids); + error = -1; + goto cleanup; + } + ++line_num; + } + + if (*buffer) { + git_error_set(GIT_ERROR_REPOSITORY, "No EOL at line %d", line_num); + git_array_clear(repo->shallow_oids); + error = -1; + goto cleanup; + } + + *out = repo->shallow_oids; + +cleanup: + git_buf_dispose(&contents); + + return error; +} + +int git_repository__shallow_roots_write(git_repository *repo, git_array_oid_t roots) +{ + git_filebuf file = GIT_FILEBUF_INIT; + git_buf path = GIT_BUF_INIT; + int error = 0; + size_t idx; + git_oid *oid; + + assert(repo); + + if ((error = git_buf_joinpath(&path, repo->gitdir, "shallow")) < 0) + return error; + + if ((error = git_filebuf_open(&file, git_buf_cstr(&path), GIT_FILEBUF_HASH_CONTENTS, 0666)) < 0) + return error; + + git_array_foreach(roots, idx, oid) { + git_filebuf_write(&file, git_oid_tostr_s(oid), GIT_OID_HEXSZ); + git_filebuf_write(&file, "\n", 1); + } + + git_filebuf_commit(&file); + + /* WIP: reload shallow */ + if (load_shallow(repo) < 0) + return -1; + + return 0; +} + int git_repository_is_shallow(git_repository *repo) { git_buf path = GIT_BUF_INIT; diff --git a/src/repository.h b/src/repository.h index 8da65652d16..4b6004bea44 100644 --- a/src/repository.h +++ b/src/repository.h @@ -242,6 +242,9 @@ extern size_t git_repository__reserved_names_posix_len; bool git_repository__reserved_names( git_buf **out, size_t *outlen, git_repository *repo, bool include_ntfs); +int git_repository__shallow_roots(git_array_oid_t *out, git_repository *repo); +int git_repository__shallow_roots_write(git_repository *repo, git_array_oid_t roots); + /* * The default branch for the repository; the `init.defaultBranch` * configuration option, if set, or `master` if it is not. diff --git a/src/transports/local.c b/src/transports/local.c index bb31b134580..17905d2223c 100644 --- a/src/transports/local.c +++ b/src/transports/local.c @@ -268,15 +268,13 @@ static int local_ls(const git_remote_head ***out, size_t *size, git_transport *t static int local_negotiate_fetch( git_transport *transport, git_repository *repo, - const git_remote_head * const *refs, - size_t count) + const git_fetch_negotiation *wants) { transport_local *t = (transport_local*)transport; git_remote_head *rhead; unsigned int i; - GIT_UNUSED(refs); - GIT_UNUSED(count); + GIT_UNUSED(wants); /* Fill in the loids */ git_vector_foreach(&t->refs, i, rhead) { diff --git a/src/transports/smart.c b/src/transports/smart.c index 587f1435889..a26bf79ecf3 100644 --- a/src/transports/smart.c +++ b/src/transports/smart.c @@ -558,3 +558,31 @@ int git_transport_smart(git_transport **out, git_remote *owner, void *param) *out = (git_transport *) t; return 0; } + +size_t git_shallowarray_count(git_shallowarray *array) +{ + return git_array_size(array->array); +} + +const git_oid * git_shallowarray_get(git_shallowarray *array, size_t idx) +{ + return git_array_get(array->array, idx); +} + +int git_shallowarray_add(git_shallowarray *array, git_oid *oid) +{ + size_t oid_index; + if (git_array_search(&oid_index, array->array, (git_array_compare_cb)git_oid_cmp, &oid) < 0) { + git_oid *tmp = git_array_alloc(array->array); + git_oid_cpy(tmp, oid); + } + return 0; +} + +int git_shallowarray_remove(git_shallowarray *array, git_oid *oid) +{ + GIT_UNUSED(array); + GIT_UNUSED(oid); + /* no git_array_remove… meh */ + return -1; +} diff --git a/src/transports/smart.h b/src/transports/smart.h index a05d4c9e3a2..6e49237ea6f 100644 --- a/src/transports/smart.h +++ b/src/transports/smart.h @@ -14,6 +14,7 @@ #include "netops.h" #include "buffer.h" #include "push.h" +#include "oidarray.h" #include "git2/sys/transport.h" #define GIT_SIDE_BAND_DATA 1 @@ -30,6 +31,7 @@ #define GIT_CAP_REPORT_STATUS "report-status" #define GIT_CAP_THIN_PACK "thin-pack" #define GIT_CAP_SYMREF "symref" +#define GIT_CAP_SHALLOW "shallow" extern bool git_smart__ofs_delta_enabled; @@ -47,6 +49,8 @@ typedef enum { GIT_PKT_OK, GIT_PKT_NG, GIT_PKT_UNPACK, + GIT_PKT_SHALLOW, + GIT_PKT_UNSHALLOW, } git_pkt_type; /* Used for multi_ack and multi_ack_detailed */ @@ -118,6 +122,11 @@ typedef struct { int unpack_ok; } git_pkt_unpack; +typedef struct { + git_pkt_type type; + git_oid oid; +} git_pkt_shallow; + typedef struct transport_smart_caps { int common:1, ofs_delta:1, @@ -128,7 +137,8 @@ typedef struct transport_smart_caps { include_tag:1, delete_refs:1, report_status:1, - thin_pack:1; + thin_pack:1, + shallow:1; } transport_smart_caps; typedef int (*packetsize_cb)(size_t received, void *payload); @@ -171,8 +181,7 @@ int git_smart__push(git_transport *transport, git_push *push, const git_remote_c int git_smart__negotiate_fetch( git_transport *transport, git_repository *repo, - const git_remote_head * const *refs, - size_t count); + const git_fetch_negotiation *wants); int git_smart__download_pack( git_transport *transport, @@ -192,8 +201,12 @@ int git_pkt_parse_line(git_pkt **head, const char **endptr, const char *line, si int git_pkt_buffer_flush(git_buf *buf); int git_pkt_send_flush(GIT_SOCKET s); int git_pkt_buffer_done(git_buf *buf); -int git_pkt_buffer_wants(const git_remote_head * const *refs, size_t count, transport_smart_caps *caps, git_buf *buf); +int git_pkt_buffer_wants(const git_fetch_negotiation *wants, transport_smart_caps *caps, git_buf *buf); int git_pkt_buffer_have(git_oid *oid, git_buf *buf); void git_pkt_free(git_pkt *pkt); +struct git_shallowarray { + git_array_oid_t array; +}; + #endif diff --git a/src/transports/smart_pkt.c b/src/transports/smart_pkt.c index 56b680d281e..6a1e842eeb9 100644 --- a/src/transports/smart_pkt.c +++ b/src/transports/smart_pkt.c @@ -363,6 +363,50 @@ static int unpack_pkt(git_pkt **out, const char *line, size_t len) return 0; } +static int shallow_pkt(git_pkt **out, const char *line, size_t len) +{ + git_pkt_shallow *pkt; + + pkt = git__calloc(1, sizeof(git_pkt_shallow)); + GIT_ERROR_CHECK_ALLOC(pkt); + + pkt->type = GIT_PKT_SHALLOW; + line += 7; + len -= 7; + + if (len >= GIT_OID_HEXSZ) { + git_oid_fromstr(&pkt->oid, line + 1); + line += GIT_OID_HEXSZ + 1; + len -= GIT_OID_HEXSZ + 1; + } + + *out = (git_pkt *) pkt; + + return 0; +} + +static int unshallow_pkt(git_pkt **out, const char *line, size_t len) +{ + git_pkt_shallow *pkt; + + pkt = git__calloc(1, sizeof(git_pkt_shallow)); + GIT_ERROR_CHECK_ALLOC(pkt); + + pkt->type = GIT_PKT_UNSHALLOW; + line += 9; + len -= 9; + + if (len >= GIT_OID_HEXSZ) { + git_oid_fromstr(&pkt->oid, line + 1); + line += GIT_OID_HEXSZ + 1; + len -= GIT_OID_HEXSZ + 1; + } + + *out = (git_pkt *) pkt; + + return 0; +} + static int parse_len(size_t *out, const char *line, size_t linelen) { char num[PKT_LEN_SIZE + 1]; @@ -489,6 +533,10 @@ int git_pkt_parse_line( error = ng_pkt(pkt, line, len); else if (!git__prefixncmp(line, len, "unpack")) error = unpack_pkt(pkt, line, len); + else if (!git__prefixcmp(line, "shallow")) + error = shallow_pkt(pkt, line, len); + else if (!git__prefixcmp(line, "unshallow")) + error = unshallow_pkt(pkt, line, len); else error = ref_pkt(pkt, line, len); @@ -554,6 +602,9 @@ static int buffer_want_with_caps(const git_remote_head *head, transport_smart_ca if (caps->ofs_delta) git_buf_puts(&str, GIT_CAP_OFS_DELTA " "); + if (caps->shallow) + git_buf_puts(&str, GIT_CAP_SHALLOW " "); + if (git_buf_oom(&str)) return -1; @@ -583,8 +634,7 @@ static int buffer_want_with_caps(const git_remote_head *head, transport_smart_ca */ int git_pkt_buffer_wants( - const git_remote_head * const *refs, - size_t count, + const git_fetch_negotiation *wants, transport_smart_caps *caps, git_buf *buf) { @@ -592,22 +642,22 @@ int git_pkt_buffer_wants( const git_remote_head *head; if (caps->common) { - for (; i < count; ++i) { - head = refs[i]; + for (; i < wants->count; ++i) { + head = wants->refs[i]; if (!head->local) break; } - if (buffer_want_with_caps(refs[i], caps, buf) < 0) + if (buffer_want_with_caps(wants->refs[i], caps, buf) < 0) return -1; i++; } - for (; i < count; ++i) { + for (; i < wants->count; ++i) { char oid[GIT_OID_HEXSZ]; - head = refs[i]; + head = wants->refs[i]; if (head->local) continue; @@ -619,6 +669,32 @@ int git_pkt_buffer_wants( return -1; } + /* Tell the server about our shallow objects */ + for (i = 0; i < git_shallowarray_count(wants->shallow_roots); i++) { + char oid[GIT_OID_HEXSZ]; + git_buf shallow_buf = GIT_BUF_INIT; + + git_oid_fmt(oid, git_shallowarray_get(wants->shallow_roots, i)); + git_buf_puts(&shallow_buf, "shallow "); + git_buf_put(&shallow_buf, oid, GIT_OID_HEXSZ); + git_buf_putc(&shallow_buf, '\n'); + + git_buf_printf(buf, "%04x%s", (unsigned int)git_buf_len(&shallow_buf) + 4, git_buf_cstr(&shallow_buf)); + + if (git_buf_oom(buf)) + return -1; + } + + if (wants->depth > 0) { + git_buf deepen_buf = GIT_BUF_INIT; + + git_buf_printf(&deepen_buf, "deepen %d\n", wants->depth); + git_buf_printf(buf,"%04x%s", (unsigned int)git_buf_len(&deepen_buf) + 4, git_buf_cstr(&deepen_buf)); + + if (git_buf_oom(buf)) + return -1; + } + return git_pkt_buffer_flush(buf); } diff --git a/src/transports/smart_protocol.c b/src/transports/smart_protocol.c index 91de163e91f..df19311914a 100644 --- a/src/transports/smart_protocol.c +++ b/src/transports/smart_protocol.c @@ -205,6 +205,12 @@ int git_smart__detect_caps(git_pkt_ref *pkt, transport_smart_caps *caps, git_vec continue; } + if (!git__prefixcmp(ptr, GIT_CAP_SHALLOW)) { + caps->common = caps->shallow = 1; + ptr += strlen(GIT_CAP_SHALLOW); + continue; + } + /* We don't know this capability, so skip it */ ptr = strchr(ptr, ' '); } @@ -305,7 +311,26 @@ static int wait_while_ack(gitno_buffer *buf) return 0; } -int git_smart__negotiate_fetch(git_transport *transport, git_repository *repo, const git_remote_head * const *wants, size_t count) +static int cap_not_sup_err(const char *cap_name) +{ + git_error_set(GIT_ERROR_NET, "server doesn't support %s", cap_name); + return GIT_EINVALID; +} + +/* Disables server capabilities we're not interested in */ +static int setup_caps(transport_smart_caps *caps, const git_fetch_negotiation *wants) +{ + if (wants->depth) { + if (!caps->shallow) + return cap_not_sup_err(GIT_CAP_SHALLOW); + } else { + caps->shallow = 0; + } + + return 0; +} + +int git_smart__negotiate_fetch(git_transport *transport, git_repository *repo, const git_fetch_negotiation *wants) { transport_smart *t = (transport_smart *)transport; git_revwalk__push_options opts = GIT_REVWALK__PUSH_OPTIONS_INIT; @@ -317,7 +342,10 @@ int git_smart__negotiate_fetch(git_transport *transport, git_repository *repo, c unsigned int i; git_oid oid; - if ((error = git_pkt_buffer_wants(wants, count, &t->caps, &data)) < 0) + if ((error = setup_caps(&t->caps, wants)) < 0) + return error; + + if ((error = git_pkt_buffer_wants(wants, &t->caps, &data)) < 0) return error; if ((error = git_revwalk_new(&walk, repo)) < 0) @@ -327,6 +355,33 @@ int git_smart__negotiate_fetch(git_transport *transport, git_repository *repo, c if ((error = git_revwalk__push_glob(walk, "refs/*", &opts)) < 0) goto on_error; + if (wants->depth > 0) { + git_pkt_shallow *pkt; + + if ((error = git_smart__negotiation_step(&t->parent, data.ptr, data.size)) < 0) + goto on_error; + + while ((error = recv_pkt((git_pkt **)&pkt, NULL, buf)) == 0) { + + if (pkt->type == GIT_PKT_SHALLOW) { + printf("shallow %s\n", git_oid_tostr_s(&pkt->oid)); + git_shallowarray_add(wants->shallow_roots, &pkt->oid); + } else if (pkt->type == GIT_PKT_UNSHALLOW) { + printf("unshallow %s\n", git_oid_tostr_s(&pkt->oid)); + git_shallowarray_remove(wants->shallow_roots, &pkt->oid); + } else if (pkt->type == GIT_PKT_FLUSH) { + /* Server is done, stop processing shallow oids */ + break; + } else { + git_error_set(GIT_ERROR_NET, "Unexpected pkt type"); + goto on_error; + } + } + + if (error < 0) { + goto on_error; + } + } /* * Our support for ACK extensions is simply to parse them. On * the first ACK we will accept that as enough common @@ -389,7 +444,7 @@ int git_smart__negotiate_fetch(git_transport *transport, git_repository *repo, c git_pkt_ack *pkt; unsigned int j; - if ((error = git_pkt_buffer_wants(wants, count, &t->caps, &data)) < 0) + if ((error = git_pkt_buffer_wants(wants, &t->caps, &data)) < 0) goto on_error; git_vector_foreach(&t->common, j, pkt) { @@ -409,7 +464,7 @@ int git_smart__negotiate_fetch(git_transport *transport, git_repository *repo, c git_pkt_ack *pkt; unsigned int j; - if ((error = git_pkt_buffer_wants(wants, count, &t->caps, &data)) < 0) + if ((error = git_pkt_buffer_wants(wants, &t->caps, &data)) < 0) goto on_error; git_vector_foreach(&t->common, j, pkt) { diff --git a/tests/clone/shallow.c b/tests/clone/shallow.c new file mode 100644 index 00000000000..d0527206597 --- /dev/null +++ b/tests/clone/shallow.c @@ -0,0 +1,55 @@ +#include "clar_libgit2.h" +#include "futils.h" + +void test_clone_shallow__initialize(void) +{ + +} + +void test_clone_shallow__cleanup(void) +{ + cl_git_sandbox_cleanup(); +} + + +#define CLONE_DEPTH 5 + +void test_clone_shallow__clone_depth(void) +{ + git_buf path = GIT_BUF_INIT; + git_repository *repo; + git_revwalk *walk; + git_clone_options clone_opts = GIT_CLONE_OPTIONS_INIT; + git_oid oid; + git_oidarray roots; + size_t depth = 0; + int error = 0; + + clone_opts.fetch_opts.depth = CLONE_DEPTH; + + git_buf_joinpath(&path, clar_sandbox_path(), "shallowclone"); + + cl_git_pass(git_clone(&repo, "https://github.com/libgit2/TestGitRepository", git_buf_cstr(&path), &clone_opts)); + + cl_assert_equal_b(true, git_repository_is_shallow(repo)); + + cl_git_pass(git_repository_shallow_roots(&roots, repo)); + cl_assert_equal_i(1, roots.count); + cl_assert_equal_s("83834a7afdaa1a1260568567f6ad90020389f664", git_oid_tostr_s(&roots.ids[0])); + + git_revwalk_new(&walk, repo); + + git_revwalk_push_head(walk); + + while ((error = git_revwalk_next(&oid, walk)) == GIT_OK) { + if (depth + 1 > CLONE_DEPTH) + cl_fail("expected depth mismatch"); + depth++; + } + + cl_git_pass(error); + + git_buf_dispose(&path); + git_revwalk_free(walk); + git_repository_free(repo); +} diff --git a/tests/repo/grafts.c b/tests/repo/grafts.c new file mode 100644 index 00000000000..82bd0ad7a21 --- /dev/null +++ b/tests/repo/grafts.c @@ -0,0 +1,119 @@ +#include "clar_libgit2.h" +#include "futils.h" +#include "grafts.h" + +static git_repository *g_repo; + +void test_repo_grafts__initialize(void) +{ + g_repo = cl_git_sandbox_init("grafted.git"); +} + +void test_repo_grafts__cleanup(void) +{ + cl_git_sandbox_cleanup(); +} + +void test_repo_grafts__graft_register(void) +{ + git_oid oid_src; + git_commit_graft *graft; + git_graftmap *grafts = git_oidmap_alloc(); + git_array_oid_t parents = GIT_ARRAY_INIT; + + git_oid *oid1 = git_array_alloc(parents); + cl_git_pass(git_oid_fromstr(&oid_src, "2f3053cbff8a4ca2f0666de364ddb734a28a31a9")); + git_oid_cpy(oid1, &oid_src); + + git_oid_fromstr(&oid_src, "f503807ffa920e407a600cfaee96b7152259acc7"); + cl_git_pass(git__graft_register(grafts, &oid_src, parents)); + git_array_clear(parents); + + cl_assert_equal_i(1, git_oidmap_size(grafts)); + cl_git_pass(git__graft_for_oid(&graft, grafts, &oid_src)); + cl_assert_equal_s("f503807ffa920e407a600cfaee96b7152259acc7", git_oid_tostr_s(&graft->oid)); + cl_assert_equal_i(1, git_array_size(graft->parents)); + cl_assert_equal_s("2f3053cbff8a4ca2f0666de364ddb734a28a31a9", git_oid_tostr_s(git_array_get(graft->parents, 0))); + + git__graft_clear(grafts); + git_oidmap_free(grafts); +} + +void test_repo_grafts__grafted_revwalk(void) +{ + git_revwalk *w; + git_oid oids[10]; + size_t i = 0; + git_commit *commit; + + cl_git_pass(git_revwalk_new(&w, g_repo)); + cl_git_pass(git_revwalk_push_ref(w, "refs/heads/branch")); + + cl_git_pass(git_revwalk_next(&oids[i++], w)); + cl_assert_equal_s(git_oid_tostr_s(&oids[0]), "8a00e91619098618be97c0d2ceabb05a2c58edd9"); + cl_git_pass(git_revwalk_next(&oids[i++], w)); + cl_assert_equal_s(git_oid_tostr_s(&oids[1]), "f503807ffa920e407a600cfaee96b7152259acc7"); + cl_git_pass(git_revwalk_next(&oids[i++], w)); + cl_assert_equal_s(git_oid_tostr_s(&oids[2]), "2f3053cbff8a4ca2f0666de364ddb734a28a31a9"); + + cl_git_fail_with(GIT_ITEROVER, git_revwalk_next(&oids[i++], w)); + + cl_git_pass(git_commit_lookup(&commit, g_repo, &oids[0])); + + cl_assert_equal_i(1, git_commit_parentcount(commit)); + + git_commit_free(commit); + git_revwalk_free(w); +} + +void test_repo_grafts__grafted_objects(void) +{ + git_oid oid; + git_commit *commit; + + cl_git_pass(git_oid_fromstr(&oid, "f503807ffa920e407a600cfaee96b7152259acc7")); + cl_git_pass(git_commit_lookup(&commit, g_repo, &oid)); + cl_assert_equal_i(1, git_commit_parentcount(commit)); + git_commit_free(commit); + + cl_git_pass(git_oid_fromstr(&oid, "0512adebd3782157f0d5c9b22b043f87b4aaff9e")); + cl_git_pass(git_commit_lookup(&commit, g_repo, &oid)); + cl_assert_equal_i(1, git_commit_parentcount(commit)); + git_commit_free(commit); + + cl_git_pass(git_oid_fromstr(&oid, "66cc22a015f6ca75b34c82d28f78ba663876bade")); + cl_git_pass(git_commit_lookup(&commit, g_repo, &oid)); + cl_assert_equal_i(4, git_commit_parentcount(commit)); + git_commit_free(commit); +} + +void test_repo_grafts__grafted_merge_revwalk(void) +{ + git_revwalk *w; + git_oid oids[10]; + size_t i = 0; + + cl_git_pass(git_revwalk_new(&w, g_repo)); + cl_git_pass(git_revwalk_push_ref(w, "refs/heads/bottom")); + + cl_git_pass(git_revwalk_next(&oids[i++], w)); + cl_assert_equal_s(git_oid_tostr_s(&oids[i - 1]), "66cc22a015f6ca75b34c82d28f78ba663876bade"); + cl_git_pass(git_revwalk_next(&oids[i++], w)); + cl_assert_equal_s(git_oid_tostr_s(&oids[i - 1]), "e414f42f4e6bc6934563a2349a8600f0ab68618e"); + cl_git_pass(git_revwalk_next(&oids[i++], w)); + cl_assert_equal_s(git_oid_tostr_s(&oids[i - 1]), "8a00e91619098618be97c0d2ceabb05a2c58edd9"); + cl_git_pass(git_revwalk_next(&oids[i++], w)); + cl_assert_equal_s(git_oid_tostr_s(&oids[i - 1]), "1c18e80a276611bb9b146590616bbc5aebdf2945"); + cl_git_pass(git_revwalk_next(&oids[i++], w)); + cl_assert_equal_s(git_oid_tostr_s(&oids[i - 1]), "d7224d49d6d5aff6ade596ed74f4bcd4f77b29e2"); + cl_git_pass(git_revwalk_next(&oids[i++], w)); + cl_assert_equal_s(git_oid_tostr_s(&oids[i - 1]), "0512adebd3782157f0d5c9b22b043f87b4aaff9e"); + cl_git_pass(git_revwalk_next(&oids[i++], w)); + cl_assert_equal_s(git_oid_tostr_s(&oids[i - 1]), "f503807ffa920e407a600cfaee96b7152259acc7"); + cl_git_pass(git_revwalk_next(&oids[i++], w)); + cl_assert_equal_s(git_oid_tostr_s(&oids[i - 1]), "2f3053cbff8a4ca2f0666de364ddb734a28a31a9"); + + cl_git_fail_with(GIT_ITEROVER, git_revwalk_next(&oids[i++], w)); + + git_revwalk_free(w); +} diff --git a/tests/repo/shallow.c b/tests/repo/shallow.c new file mode 100644 index 00000000000..a73dfc013b3 --- /dev/null +++ b/tests/repo/shallow.c @@ -0,0 +1,125 @@ +#include "clar_libgit2.h" +#include "futils.h" + +static git_repository *g_repo; +static git_oid g_shallow_oid; + +void test_repo_shallow__initialize(void) +{ + cl_git_pass(git_oid_fromstr(&g_shallow_oid, "be3563ae3f795b2b4353bcce3a527ad0a4f7f644")); +} + +void test_repo_shallow__cleanup(void) +{ + cl_git_sandbox_cleanup(); +} + +void test_repo_shallow__no_shallow_file(void) +{ + g_repo = cl_git_sandbox_init("testrepo.git"); + cl_assert_equal_i(0, git_repository_is_shallow(g_repo)); +} + +void test_repo_shallow__empty_shallow_file(void) +{ + g_repo = cl_git_sandbox_init("testrepo.git"); + cl_git_mkfile("testrepo.git/shallow", ""); + cl_assert_equal_i(0, git_repository_is_shallow(g_repo)); +} + +void test_repo_shallow__shallow_repo(void) +{ + g_repo = cl_git_sandbox_init("shallow.git"); + cl_assert_equal_i(1, git_repository_is_shallow(g_repo)); +} + +void test_repo_shallow__clears_errors(void) +{ + g_repo = cl_git_sandbox_init("testrepo.git"); + cl_assert_equal_i(0, git_repository_is_shallow(g_repo)); + cl_assert_equal_p(NULL, git_error_last()); +} + +void test_repo_shallow__shallow_oids(void) +{ + git_oidarray oids, oids2; + g_repo = cl_git_sandbox_init("shallow.git"); + + cl_git_pass(git_repository_shallow_roots(&oids, g_repo)); + cl_assert_equal_i(1, oids.count); + cl_assert_equal_oid(&g_shallow_oid, &oids.ids[0]); + + cl_git_pass(git_repository_shallow_roots(&oids2, g_repo)); + cl_assert_equal_p(oids.ids, oids2.ids); +} + +void test_repo_shallow__cache_clearing(void) +{ + git_oidarray oids, oids2; + git_oid tmp_oid; + + git_oid_fromstr(&tmp_oid, "0000000000000000000000000000000000000000"); + g_repo = cl_git_sandbox_init("shallow.git"); + + cl_git_pass(git_repository_shallow_roots(&oids, g_repo)); + cl_assert_equal_i(1, oids.count); + cl_assert_equal_oid(&g_shallow_oid, &oids.ids[0]); + + cl_git_mkfile("shallow.git/shallow", + "be3563ae3f795b2b4353bcce3a527ad0a4f7f644\n" + "0000000000000000000000000000000000000000\n" + ); + + cl_git_pass(git_repository_shallow_roots(&oids2, g_repo)); + cl_assert_equal_i(2, oids2.count); + cl_assert_equal_oid(&g_shallow_oid, &oids2.ids[0]); + cl_assert_equal_oid(&tmp_oid, &oids2.ids[1]); +} + +void test_repo_shallow__errors_on_borked(void) +{ + git_oidarray oids; + + g_repo = cl_git_sandbox_init("shallow.git"); + + cl_git_mkfile("shallow.git/shallow", "lolno"); + + cl_git_fail_with(-1, git_repository_shallow_roots(&oids, g_repo)); + + cl_git_mkfile("shallow.git/shallow", "lolno\n"); + + cl_git_fail_with(-1, git_repository_shallow_roots(&oids, g_repo)); +} + +void test_repo_shallow__revwalk_behavior(void) +{ + git_revwalk *w; + git_oid oid_1, oid_2, oid_3; + + g_repo = cl_git_sandbox_init("shallow.git"); + + cl_git_pass(git_revwalk_new(&w, g_repo)); + cl_git_pass(git_revwalk_push_head(w)); + + cl_git_pass(git_revwalk_next(&oid_1, w)); // a65fedf39aefe402d3bb6e24df4d4f5fe4547750 + cl_git_pass(git_revwalk_next(&oid_2, w)); // be3563ae3f795b2b4353bcce3a527ad0a4f7f644 + cl_git_fail_with(GIT_ITEROVER, git_revwalk_next(&oid_3, w)); + + cl_assert_equal_s(git_oid_tostr_s(&oid_1), "a65fedf39aefe402d3bb6e24df4d4f5fe4547750"); + cl_assert_equal_s(git_oid_tostr_s(&oid_2), "be3563ae3f795b2b4353bcce3a527ad0a4f7f644"); + + git_revwalk_free(w); +} + +void test_repo_shallow__grafted_object(void) +{ + git_commit *commit; + + g_repo = cl_git_sandbox_init("shallow.git"); + + cl_git_pass(git_commit_lookup(&commit, g_repo, &g_shallow_oid)); + + cl_assert_equal_i(0, git_commit_parentcount(commit)); + + git_commit_free(commit); +} From 10e2573550b0753f4aa0728bb2bbacf57d2377d0 Mon Sep 17 00:00:00 2001 From: yuangli Date: Tue, 5 Jul 2022 09:22:31 +0100 Subject: [PATCH 033/608] attempt to build --- src/repository.c | 148 +++++++++++++++++++++--------------------- tests/clone/shallow.c | 3 +- tests/repo/grafts.c | 119 --------------------------------- tests/repo/shallow.c | 125 ----------------------------------- 4 files changed, 77 insertions(+), 318 deletions(-) delete mode 100644 tests/repo/grafts.c delete mode 100644 tests/repo/shallow.c diff --git a/src/repository.c b/src/repository.c index 537622273fd..bef719f4a2c 100644 --- a/src/repository.c +++ b/src/repository.c @@ -3194,89 +3194,91 @@ int git_repository_state_cleanup(git_repository *repo) int git_repository__shallow_roots(git_array_oid_t *out, git_repository *repo) { - git_buf path = GIT_BUF_INIT; - git_buf contents = GIT_BUF_INIT; - int error, updated, line_num = 1; - char *line; - char *buffer; - - assert(out && repo); - - if ((error = git_buf_joinpath(&path, repo->gitdir, "shallow")) < 0) - return error; - - error = git_futils_readbuffer_updated(&contents, git_buf_cstr(&path), &repo->shallow_checksum, &updated); - git_buf_dispose(&path); - - if (error < 0 && error != GIT_ENOTFOUND) - return error; - - /* cancel out GIT_ENOTFOUND */ - git_error_clear(); - error = 0; - - if (!updated) { - *out = repo->shallow_oids; - goto cleanup; - } - - git_array_clear(repo->shallow_oids); - - buffer = contents.ptr; - while ((line = git__strsep(&buffer, "\n")) != NULL) { - git_oid *oid = git_array_alloc(repo->shallow_oids); - - error = git_oid_fromstr(oid, line); - if (error < 0) { - git_error_set(GIT_ERROR_REPOSITORY, "Invalid OID at line %d", line_num); - git_array_clear(repo->shallow_oids); - error = -1; - goto cleanup; - } - ++line_num; - } - - if (*buffer) { - git_error_set(GIT_ERROR_REPOSITORY, "No EOL at line %d", line_num); - git_array_clear(repo->shallow_oids); - error = -1; - goto cleanup; - } - - *out = repo->shallow_oids; - -cleanup: - git_buf_dispose(&contents); - - return error; +// git_buf path = GIT_BUF_INIT; +// git_buf contents = GIT_BUF_INIT; +// int error, updated, line_num = 1; +// char *line; +// char *buffer; + +// assert(out && repo); + +// if ((error = git_buf_joinpath(&path, repo->gitdir, "shallow")) < 0) +// return error; + +// //error = git_futils_readbuffer_updated(&contents, git_buf_cstr(&path), &repo->shallow_checksum, &updated); +// error = git_futils_readbuffer_updated(&contents, git_buf_cstr(&path), &repo->shallow_grafts->git_grafts->path_checksum, &updated); +// git_buf_dispose(&path); + +// if (error < 0 && error != GIT_ENOTFOUND) +// return error; + +// /* cancel out GIT_ENOTFOUND */ +// git_error_clear(); +// error = 0; + +// if (!updated) { +// out = repo->shallow_grafts; +// goto cleanup; +// } + +// git_array_clear(repo->shallow_grafts); + +// buffer = contents.ptr; +// while ((line = git__strsep(&buffer, "\n")) != NULL) { +// git_oid *oid = git_array_alloc(repo->shallow_grafts); + +// error = git_oid_fromstr(oid, line); +// if (error < 0) { +// git_error_set(GIT_ERROR_REPOSITORY, "Invalid OID at line %d", line_num); +// git_array_clear(repo->shallow_grafts); +// error = -1; +// goto cleanup; +// } +// ++line_num; +// } + +// if (*buffer) { +// git_error_set(GIT_ERROR_REPOSITORY, "No EOL at line %d", line_num); +// git_array_clear(repo->shallow_grafts); +// error = -1; +// goto cleanup; +// } + +// *out = repo->shallow_grafts; + +// cleanup: +// git_buf_dispose(&contents); + + // return error; + return 0; } int git_repository__shallow_roots_write(git_repository *repo, git_array_oid_t roots) { - git_filebuf file = GIT_FILEBUF_INIT; - git_buf path = GIT_BUF_INIT; - int error = 0; - size_t idx; - git_oid *oid; + // git_filebuf file = GIT_FILEBUF_INIT; + // git_buf path = GIT_BUF_INIT; + // int error = 0; + // size_t idx; + // git_oid *oid; - assert(repo); + // assert(repo); - if ((error = git_buf_joinpath(&path, repo->gitdir, "shallow")) < 0) - return error; + // if ((error = git_buf_joinpath(&path, repo->gitdir, "shallow")) < 0) + // return error; - if ((error = git_filebuf_open(&file, git_buf_cstr(&path), GIT_FILEBUF_HASH_CONTENTS, 0666)) < 0) - return error; + // if ((error = git_filebuf_open(&file, git_buf_cstr(&path), GIT_FILEBUF_HASH_CONTENTS, 0666)) < 0) + // return error; - git_array_foreach(roots, idx, oid) { - git_filebuf_write(&file, git_oid_tostr_s(oid), GIT_OID_HEXSZ); - git_filebuf_write(&file, "\n", 1); - } + // git_array_foreach(roots, idx, oid) { + // git_filebuf_write(&file, git_oid_tostr_s(oid), GIT_OID_HEXSZ); + // git_filebuf_write(&file, "\n", 1); + // } - git_filebuf_commit(&file); + // git_filebuf_commit(&file); - /* WIP: reload shallow */ - if (load_shallow(repo) < 0) - return -1; + // /* WIP: reload shallow */ + // if (load_shallow(repo) < 0) + // return -1; return 0; } diff --git a/tests/clone/shallow.c b/tests/clone/shallow.c index d0527206597..6bd98ab0a24 100644 --- a/tests/clone/shallow.c +++ b/tests/clone/shallow.c @@ -1,5 +1,6 @@ #include "clar_libgit2.h" #include "futils.h" +#include "repository.h" void test_clone_shallow__initialize(void) { @@ -33,7 +34,7 @@ void test_clone_shallow__clone_depth(void) cl_assert_equal_b(true, git_repository_is_shallow(repo)); - cl_git_pass(git_repository_shallow_roots(&roots, repo)); + cl_git_pass(git_repository__shallow_roots(&roots, repo)); cl_assert_equal_i(1, roots.count); cl_assert_equal_s("83834a7afdaa1a1260568567f6ad90020389f664", git_oid_tostr_s(&roots.ids[0])); diff --git a/tests/repo/grafts.c b/tests/repo/grafts.c deleted file mode 100644 index 82bd0ad7a21..00000000000 --- a/tests/repo/grafts.c +++ /dev/null @@ -1,119 +0,0 @@ -#include "clar_libgit2.h" -#include "futils.h" -#include "grafts.h" - -static git_repository *g_repo; - -void test_repo_grafts__initialize(void) -{ - g_repo = cl_git_sandbox_init("grafted.git"); -} - -void test_repo_grafts__cleanup(void) -{ - cl_git_sandbox_cleanup(); -} - -void test_repo_grafts__graft_register(void) -{ - git_oid oid_src; - git_commit_graft *graft; - git_graftmap *grafts = git_oidmap_alloc(); - git_array_oid_t parents = GIT_ARRAY_INIT; - - git_oid *oid1 = git_array_alloc(parents); - cl_git_pass(git_oid_fromstr(&oid_src, "2f3053cbff8a4ca2f0666de364ddb734a28a31a9")); - git_oid_cpy(oid1, &oid_src); - - git_oid_fromstr(&oid_src, "f503807ffa920e407a600cfaee96b7152259acc7"); - cl_git_pass(git__graft_register(grafts, &oid_src, parents)); - git_array_clear(parents); - - cl_assert_equal_i(1, git_oidmap_size(grafts)); - cl_git_pass(git__graft_for_oid(&graft, grafts, &oid_src)); - cl_assert_equal_s("f503807ffa920e407a600cfaee96b7152259acc7", git_oid_tostr_s(&graft->oid)); - cl_assert_equal_i(1, git_array_size(graft->parents)); - cl_assert_equal_s("2f3053cbff8a4ca2f0666de364ddb734a28a31a9", git_oid_tostr_s(git_array_get(graft->parents, 0))); - - git__graft_clear(grafts); - git_oidmap_free(grafts); -} - -void test_repo_grafts__grafted_revwalk(void) -{ - git_revwalk *w; - git_oid oids[10]; - size_t i = 0; - git_commit *commit; - - cl_git_pass(git_revwalk_new(&w, g_repo)); - cl_git_pass(git_revwalk_push_ref(w, "refs/heads/branch")); - - cl_git_pass(git_revwalk_next(&oids[i++], w)); - cl_assert_equal_s(git_oid_tostr_s(&oids[0]), "8a00e91619098618be97c0d2ceabb05a2c58edd9"); - cl_git_pass(git_revwalk_next(&oids[i++], w)); - cl_assert_equal_s(git_oid_tostr_s(&oids[1]), "f503807ffa920e407a600cfaee96b7152259acc7"); - cl_git_pass(git_revwalk_next(&oids[i++], w)); - cl_assert_equal_s(git_oid_tostr_s(&oids[2]), "2f3053cbff8a4ca2f0666de364ddb734a28a31a9"); - - cl_git_fail_with(GIT_ITEROVER, git_revwalk_next(&oids[i++], w)); - - cl_git_pass(git_commit_lookup(&commit, g_repo, &oids[0])); - - cl_assert_equal_i(1, git_commit_parentcount(commit)); - - git_commit_free(commit); - git_revwalk_free(w); -} - -void test_repo_grafts__grafted_objects(void) -{ - git_oid oid; - git_commit *commit; - - cl_git_pass(git_oid_fromstr(&oid, "f503807ffa920e407a600cfaee96b7152259acc7")); - cl_git_pass(git_commit_lookup(&commit, g_repo, &oid)); - cl_assert_equal_i(1, git_commit_parentcount(commit)); - git_commit_free(commit); - - cl_git_pass(git_oid_fromstr(&oid, "0512adebd3782157f0d5c9b22b043f87b4aaff9e")); - cl_git_pass(git_commit_lookup(&commit, g_repo, &oid)); - cl_assert_equal_i(1, git_commit_parentcount(commit)); - git_commit_free(commit); - - cl_git_pass(git_oid_fromstr(&oid, "66cc22a015f6ca75b34c82d28f78ba663876bade")); - cl_git_pass(git_commit_lookup(&commit, g_repo, &oid)); - cl_assert_equal_i(4, git_commit_parentcount(commit)); - git_commit_free(commit); -} - -void test_repo_grafts__grafted_merge_revwalk(void) -{ - git_revwalk *w; - git_oid oids[10]; - size_t i = 0; - - cl_git_pass(git_revwalk_new(&w, g_repo)); - cl_git_pass(git_revwalk_push_ref(w, "refs/heads/bottom")); - - cl_git_pass(git_revwalk_next(&oids[i++], w)); - cl_assert_equal_s(git_oid_tostr_s(&oids[i - 1]), "66cc22a015f6ca75b34c82d28f78ba663876bade"); - cl_git_pass(git_revwalk_next(&oids[i++], w)); - cl_assert_equal_s(git_oid_tostr_s(&oids[i - 1]), "e414f42f4e6bc6934563a2349a8600f0ab68618e"); - cl_git_pass(git_revwalk_next(&oids[i++], w)); - cl_assert_equal_s(git_oid_tostr_s(&oids[i - 1]), "8a00e91619098618be97c0d2ceabb05a2c58edd9"); - cl_git_pass(git_revwalk_next(&oids[i++], w)); - cl_assert_equal_s(git_oid_tostr_s(&oids[i - 1]), "1c18e80a276611bb9b146590616bbc5aebdf2945"); - cl_git_pass(git_revwalk_next(&oids[i++], w)); - cl_assert_equal_s(git_oid_tostr_s(&oids[i - 1]), "d7224d49d6d5aff6ade596ed74f4bcd4f77b29e2"); - cl_git_pass(git_revwalk_next(&oids[i++], w)); - cl_assert_equal_s(git_oid_tostr_s(&oids[i - 1]), "0512adebd3782157f0d5c9b22b043f87b4aaff9e"); - cl_git_pass(git_revwalk_next(&oids[i++], w)); - cl_assert_equal_s(git_oid_tostr_s(&oids[i - 1]), "f503807ffa920e407a600cfaee96b7152259acc7"); - cl_git_pass(git_revwalk_next(&oids[i++], w)); - cl_assert_equal_s(git_oid_tostr_s(&oids[i - 1]), "2f3053cbff8a4ca2f0666de364ddb734a28a31a9"); - - cl_git_fail_with(GIT_ITEROVER, git_revwalk_next(&oids[i++], w)); - - git_revwalk_free(w); -} diff --git a/tests/repo/shallow.c b/tests/repo/shallow.c deleted file mode 100644 index a73dfc013b3..00000000000 --- a/tests/repo/shallow.c +++ /dev/null @@ -1,125 +0,0 @@ -#include "clar_libgit2.h" -#include "futils.h" - -static git_repository *g_repo; -static git_oid g_shallow_oid; - -void test_repo_shallow__initialize(void) -{ - cl_git_pass(git_oid_fromstr(&g_shallow_oid, "be3563ae3f795b2b4353bcce3a527ad0a4f7f644")); -} - -void test_repo_shallow__cleanup(void) -{ - cl_git_sandbox_cleanup(); -} - -void test_repo_shallow__no_shallow_file(void) -{ - g_repo = cl_git_sandbox_init("testrepo.git"); - cl_assert_equal_i(0, git_repository_is_shallow(g_repo)); -} - -void test_repo_shallow__empty_shallow_file(void) -{ - g_repo = cl_git_sandbox_init("testrepo.git"); - cl_git_mkfile("testrepo.git/shallow", ""); - cl_assert_equal_i(0, git_repository_is_shallow(g_repo)); -} - -void test_repo_shallow__shallow_repo(void) -{ - g_repo = cl_git_sandbox_init("shallow.git"); - cl_assert_equal_i(1, git_repository_is_shallow(g_repo)); -} - -void test_repo_shallow__clears_errors(void) -{ - g_repo = cl_git_sandbox_init("testrepo.git"); - cl_assert_equal_i(0, git_repository_is_shallow(g_repo)); - cl_assert_equal_p(NULL, git_error_last()); -} - -void test_repo_shallow__shallow_oids(void) -{ - git_oidarray oids, oids2; - g_repo = cl_git_sandbox_init("shallow.git"); - - cl_git_pass(git_repository_shallow_roots(&oids, g_repo)); - cl_assert_equal_i(1, oids.count); - cl_assert_equal_oid(&g_shallow_oid, &oids.ids[0]); - - cl_git_pass(git_repository_shallow_roots(&oids2, g_repo)); - cl_assert_equal_p(oids.ids, oids2.ids); -} - -void test_repo_shallow__cache_clearing(void) -{ - git_oidarray oids, oids2; - git_oid tmp_oid; - - git_oid_fromstr(&tmp_oid, "0000000000000000000000000000000000000000"); - g_repo = cl_git_sandbox_init("shallow.git"); - - cl_git_pass(git_repository_shallow_roots(&oids, g_repo)); - cl_assert_equal_i(1, oids.count); - cl_assert_equal_oid(&g_shallow_oid, &oids.ids[0]); - - cl_git_mkfile("shallow.git/shallow", - "be3563ae3f795b2b4353bcce3a527ad0a4f7f644\n" - "0000000000000000000000000000000000000000\n" - ); - - cl_git_pass(git_repository_shallow_roots(&oids2, g_repo)); - cl_assert_equal_i(2, oids2.count); - cl_assert_equal_oid(&g_shallow_oid, &oids2.ids[0]); - cl_assert_equal_oid(&tmp_oid, &oids2.ids[1]); -} - -void test_repo_shallow__errors_on_borked(void) -{ - git_oidarray oids; - - g_repo = cl_git_sandbox_init("shallow.git"); - - cl_git_mkfile("shallow.git/shallow", "lolno"); - - cl_git_fail_with(-1, git_repository_shallow_roots(&oids, g_repo)); - - cl_git_mkfile("shallow.git/shallow", "lolno\n"); - - cl_git_fail_with(-1, git_repository_shallow_roots(&oids, g_repo)); -} - -void test_repo_shallow__revwalk_behavior(void) -{ - git_revwalk *w; - git_oid oid_1, oid_2, oid_3; - - g_repo = cl_git_sandbox_init("shallow.git"); - - cl_git_pass(git_revwalk_new(&w, g_repo)); - cl_git_pass(git_revwalk_push_head(w)); - - cl_git_pass(git_revwalk_next(&oid_1, w)); // a65fedf39aefe402d3bb6e24df4d4f5fe4547750 - cl_git_pass(git_revwalk_next(&oid_2, w)); // be3563ae3f795b2b4353bcce3a527ad0a4f7f644 - cl_git_fail_with(GIT_ITEROVER, git_revwalk_next(&oid_3, w)); - - cl_assert_equal_s(git_oid_tostr_s(&oid_1), "a65fedf39aefe402d3bb6e24df4d4f5fe4547750"); - cl_assert_equal_s(git_oid_tostr_s(&oid_2), "be3563ae3f795b2b4353bcce3a527ad0a4f7f644"); - - git_revwalk_free(w); -} - -void test_repo_shallow__grafted_object(void) -{ - git_commit *commit; - - g_repo = cl_git_sandbox_init("shallow.git"); - - cl_git_pass(git_commit_lookup(&commit, g_repo, &g_shallow_oid)); - - cl_assert_equal_i(0, git_commit_parentcount(commit)); - - git_commit_free(commit); -} From 2546030d7ed8aea9f050b092e0954b7146978ecf Mon Sep 17 00:00:00 2001 From: Miguel Arroz <750683+arroz@users.noreply.github.com> Date: Wed, 6 Jul 2022 19:04:39 -0700 Subject: [PATCH 034/608] Fixes #6344: git_branch_move now renames the reflog instead of deleting. --- src/libgit2/refdb_fs.c | 21 ++++++++++++++++----- tests/libgit2/refs/branches/move.c | 22 ++++++++++++++++++++++ 2 files changed, 38 insertions(+), 5 deletions(-) diff --git a/src/libgit2/refdb_fs.c b/src/libgit2/refdb_fs.c index 0f49b16bba0..8f7febbc8d7 100644 --- a/src/libgit2/refdb_fs.c +++ b/src/libgit2/refdb_fs.c @@ -1769,6 +1769,15 @@ static int refdb_fs_backend__rename( (error = refdb_fs_backend__lookup(&old, _backend, old_name)) < 0) return error; + /* Try to rename the refog; it's ok if the old doesn't exist */ + /* Must be done before calling refdb_fs_backend__delete, otherwise */ + /* the reflog is deleted before being renamed. */ + error = refdb_reflog_fs__rename(_backend, old_name, new_name); + if ((error != 0) && (error != GIT_ENOTFOUND)) { + git_reference_free(old); + return error; + } + if ((error = refdb_fs_backend__delete(_backend, old_name, NULL, NULL)) < 0) { git_reference_free(old); return error; @@ -1785,10 +1794,7 @@ static int refdb_fs_backend__rename( return error; } - /* Try to rename the refog; it's ok if the old doesn't exist */ - error = refdb_reflog_fs__rename(_backend, old_name, new_name); - if (((error == 0) || (error == GIT_ENOTFOUND)) && - ((error = reflog_append(backend, new, git_reference_target(new), NULL, who, message)) < 0)) { + if ((error = reflog_append(backend, new, git_reference_target(new), NULL, who, message)) < 0) { git_reference_free(new); git_filebuf_cleanup(&file); return error; @@ -2368,7 +2374,12 @@ static int refdb_reflog_fs__delete(git_refdb_backend *_backend, const char *name if ((error = reflog_path(&path, backend->repo, name)) < 0) goto out; - if (!git_fs_path_exists(path.ptr)) + /* + * If a reference was moved downwards, eg refs/heads/br2 -> refs/heads/br2/new-name, + * refs/heads/br2 does exist but it's a directory. That's a valid situation. + * Proceed only if it's a file. + */ + if (!git_fs_path_isfile(path.ptr)) goto out; if ((error = p_unlink(path.ptr)) < 0) diff --git a/tests/libgit2/refs/branches/move.c b/tests/libgit2/refs/branches/move.c index 46a5082d2fd..f261b2bbba3 100644 --- a/tests/libgit2/refs/branches/move.c +++ b/tests/libgit2/refs/branches/move.c @@ -210,3 +210,25 @@ void test_refs_branches_move__can_move_with_unicode(void) git_reference_free(original_ref); git_reference_free(new_ref); } + +void test_refs_branches_move__moves_reflog_correctly(void) +{ + git_reference *original_ref, *new_ref; + git_reflog *original_reflog, *new_reflog; + + cl_git_pass(git_reference_lookup(&original_ref, repo, "refs/heads/br2")); + + cl_git_pass(git_reflog_read(&original_reflog, repo, "refs/heads/br2")); + cl_assert_equal_i(2, git_reflog_entrycount(original_reflog)); + + cl_git_pass(git_branch_move(&new_ref, original_ref, NEW_BRANCH_NAME, 0)); + cl_assert_equal_s(GIT_REFS_HEADS_DIR NEW_BRANCH_NAME, git_reference_name(new_ref)); + + cl_git_pass(git_reflog_read(&new_reflog, repo, GIT_REFS_HEADS_DIR NEW_BRANCH_NAME)); + cl_assert_equal_i(3, git_reflog_entrycount(new_reflog)); + + git_reference_free(original_ref); + git_reference_free(new_ref); + git_reflog_free(original_reflog); + git_reflog_free(new_reflog); +} From 3c79bafcf832a7bcfd1bdf6559f7ff85f6734d9f Mon Sep 17 00:00:00 2001 From: Miguel Arroz <750683+arroz@users.noreply.github.com> Date: Wed, 6 Jul 2022 19:21:13 -0700 Subject: [PATCH 035/608] Add reverting reflog move if an error happens. --- src/libgit2/refdb_fs.c | 3 +++ tests/libgit2/refs/branches/move.c | 16 ++++++++++++++++ 2 files changed, 19 insertions(+) diff --git a/src/libgit2/refdb_fs.c b/src/libgit2/refdb_fs.c index 8f7febbc8d7..11daffdb098 100644 --- a/src/libgit2/refdb_fs.c +++ b/src/libgit2/refdb_fs.c @@ -1779,17 +1779,20 @@ static int refdb_fs_backend__rename( } if ((error = refdb_fs_backend__delete(_backend, old_name, NULL, NULL)) < 0) { + refdb_reflog_fs__rename(_backend, new_name, old_name); git_reference_free(old); return error; } new = git_reference__realloc(&old, new_name); if (!new) { + refdb_reflog_fs__rename(_backend, new_name, old_name); git_reference_free(old); return -1; } if ((error = loose_lock(&file, backend, new->name)) < 0) { + refdb_reflog_fs__rename(_backend, new_name, old_name); git_reference_free(new); return error; } diff --git a/tests/libgit2/refs/branches/move.c b/tests/libgit2/refs/branches/move.c index f261b2bbba3..4cfb7b83ae6 100644 --- a/tests/libgit2/refs/branches/move.c +++ b/tests/libgit2/refs/branches/move.c @@ -232,3 +232,19 @@ void test_refs_branches_move__moves_reflog_correctly(void) git_reflog_free(original_reflog); git_reflog_free(new_reflog); } + +void test_refs_branches_move__failed_move_restores_reflog(void) +{ + git_reference *original_ref, *new_ref; + git_reflog *recovered_reflog; + + cl_git_pass(git_reference_lookup(&original_ref, repo, "refs/heads/br2")); + + cl_assert_equal_i(GIT_EINVALIDSPEC, git_branch_move(&new_ref, original_ref, "Inv@{id", 0)); + + cl_git_pass(git_reflog_read(&recovered_reflog, repo, "refs/heads/br2")); + cl_assert_equal_i(2, git_reflog_entrycount(recovered_reflog)); + + git_reference_free(original_ref); + git_reflog_free(recovered_reflog); +} From 0365f4531f548da842b56be17fd6a6a253bc6763 Mon Sep 17 00:00:00 2001 From: Miguel Arroz <750683+arroz@users.noreply.github.com> Date: Wed, 6 Jul 2022 19:33:16 -0700 Subject: [PATCH 036/608] Codestyle (whitespaces) adjustment. --- src/libgit2/refdb_fs.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/libgit2/refdb_fs.c b/src/libgit2/refdb_fs.c index 11daffdb098..8a7051dead6 100644 --- a/src/libgit2/refdb_fs.c +++ b/src/libgit2/refdb_fs.c @@ -2377,11 +2377,11 @@ static int refdb_reflog_fs__delete(git_refdb_backend *_backend, const char *name if ((error = reflog_path(&path, backend->repo, name)) < 0) goto out; - /* - * If a reference was moved downwards, eg refs/heads/br2 -> refs/heads/br2/new-name, - * refs/heads/br2 does exist but it's a directory. That's a valid situation. - * Proceed only if it's a file. - */ + /* + * If a reference was moved downwards, eg refs/heads/br2 -> refs/heads/br2/new-name, + * refs/heads/br2 does exist but it's a directory. That's a valid situation. + * Proceed only if it's a file. + */ if (!git_fs_path_isfile(path.ptr)) goto out; From 3e64f150ccfae3b7828a293fdd78daaf61e76ccf Mon Sep 17 00:00:00 2001 From: yuangli Date: Thu, 7 Jul 2022 09:26:18 +0100 Subject: [PATCH 037/608] rewrite shallow_root --- src/repository.c | 110 +++++++++++++++++++++++++++++++++--------- tests/clone/shallow.c | 10 ++-- 2 files changed, 94 insertions(+), 26 deletions(-) diff --git a/src/repository.c b/src/repository.c index bef719f4a2c..42ee263a3a4 100644 --- a/src/repository.c +++ b/src/repository.c @@ -3192,13 +3192,56 @@ int git_repository_state_cleanup(git_repository *repo) return git_repository__cleanup_files(repo, state_files, ARRAY_SIZE(state_files)); } -int git_repository__shallow_roots(git_array_oid_t *out, git_repository *repo) -{ +// int git_repository__shallow_roots(git_array_oid_t *out, git_repository *repo) +// { // git_buf path = GIT_BUF_INIT; // git_buf contents = GIT_BUF_INIT; // int error, updated, line_num = 1; // char *line; -// char *buffer; +// chror = git_futils_readbuffer_updated(&contents, git_buf_cstr(&path), &repo->shallow_grafts->git_grafts->path_checksum, &updated); +// git_buf_dispose(&path); + +// if (error < 0 && error != GIT_ENOTFOUND) +// return error; + +// /* cancel out GIT_ENOTFOUND */ +// git_error_clear(); +// error = 0; + +// if (!updated) { +// out = repo->shallow_grafts; +// goto cleanup; +// } + +// git_array_clear(repo->shallow_grafts); + +// buffer = contents.ptr; +// while ((line = git__strsep(&buffer, "\n")) != NULL) { +// git_oid *oid = git_array_alloc(repo->shallow_grafts); + +// error = git_oid_fromstr(oid, line); +// if (error < 0) { +// git_error_set(GIT_ERROR_REPOSITORY, "Invalid OID at line %d", line_num); +// git_array_clear(repo->shallow_grafts); +// error = -1; +// goto cleanup; +// } +// ++line_num; +// } + +// if (*buffer) { +// git_error_set(GIT_ERROR_REPOSITORY, "No EOL at line %d", line_num); +// git_array_clear(repo->shallow_grafts); +// error = -1; +// goto cleanup; +// } + +// *out = repo->shallow_grafts; + +// cleanup: +// git_buf_dispose(&contents); + +// return error;ar *buffer; // assert(out && repo); @@ -3249,40 +3292,61 @@ int git_repository__shallow_roots(git_array_oid_t *out, git_repository *repo) // cleanup: // git_buf_dispose(&contents); - // return error; - return 0; +// return error; +// } + +int git_repository__shallow_roots(git_array_oid_t *out, git_repository *repo) { + int error =0; + if (!repo->shallow_grafts) + load_grafts(repo); + + git_grafts_refresh(repo->shallow_grafts); + return git_grafts_get_oids(out, repo->shallow_grafts); } int git_repository__shallow_roots_write(git_repository *repo, git_array_oid_t roots) { - // git_filebuf file = GIT_FILEBUF_INIT; - // git_buf path = GIT_BUF_INIT; - // int error = 0; - // size_t idx; - // git_oid *oid; + git_filebuf file = GIT_FILEBUF_INIT; + git_buf path = GIT_BUF_INIT; + int error = 0; + size_t idx; + git_oid *oid; - // assert(repo); + assert(repo); - // if ((error = git_buf_joinpath(&path, repo->gitdir, "shallow")) < 0) - // return error; + if ((error = git_buf_joinpath(&path, repo->gitdir, "shallow")) < 0) + return error; - // if ((error = git_filebuf_open(&file, git_buf_cstr(&path), GIT_FILEBUF_HASH_CONTENTS, 0666)) < 0) - // return error; + if ((error = git_filebuf_open(&file, git_buf_cstr(&path), GIT_FILEBUF_HASH_CONTENTS, 0666)) < 0) + return error; - // git_array_foreach(roots, idx, oid) { - // git_filebuf_write(&file, git_oid_tostr_s(oid), GIT_OID_HEXSZ); - // git_filebuf_write(&file, "\n", 1); - // } + git_array_foreach(roots, idx, oid) { + git_filebuf_write(&file, git_oid_tostr_s(oid), GIT_OID_HEXSZ); + git_filebuf_write(&file, "\n", 1); + } - // git_filebuf_commit(&file); + git_filebuf_commit(&file); - // /* WIP: reload shallow */ - // if (load_shallow(repo) < 0) - // return -1; + if (load_grafts(repo) < 0) + return -1; return 0; } +int git_repository_shallow_roots(git_oidarray *out, git_repository *repo) +{ + int ret; + git_array_oid_t array = GIT_ARRAY_INIT; + + assert(out); + + ret = git_repository__shallow_roots(&array, repo); + + git_oidarray__from_array(out, &array); + + return ret; +} + int git_repository_is_shallow(git_repository *repo) { git_buf path = GIT_BUF_INIT; diff --git a/tests/clone/shallow.c b/tests/clone/shallow.c index 6bd98ab0a24..b41e28d6611 100644 --- a/tests/clone/shallow.c +++ b/tests/clone/shallow.c @@ -34,7 +34,7 @@ void test_clone_shallow__clone_depth(void) cl_assert_equal_b(true, git_repository_is_shallow(repo)); - cl_git_pass(git_repository__shallow_roots(&roots, repo)); + cl_git_pass(git_repository_shallow_roots(&roots, repo)); cl_assert_equal_i(1, roots.count); cl_assert_equal_s("83834a7afdaa1a1260568567f6ad90020389f664", git_oid_tostr_s(&roots.ids[0])); @@ -43,8 +43,12 @@ void test_clone_shallow__clone_depth(void) git_revwalk_push_head(walk); while ((error = git_revwalk_next(&oid, walk)) == GIT_OK) { - if (depth + 1 > CLONE_DEPTH) - cl_fail("expected depth mismatch"); + //if (depth + 1 > CLONE_DEPTH) + //cl_fail("expected depth mismatch"); + char str[GIT_OID_HEXSZ +1]; + git_oid_fmt(str, &oid); + printf(str); + printf("\n"); depth++; } From 8dc78a0f620c252ec37832bc8a75140346f0ad62 Mon Sep 17 00:00:00 2001 From: Jacob Watson Date: Tue, 21 Jun 2022 15:23:33 -0700 Subject: [PATCH 038/608] stash: implement partial stashing by path --- include/git2/stash.h | 66 ++++++++++++- src/libgit2/stash.c | 220 ++++++++++++++++++++++++++++++++++++++----- 2 files changed, 260 insertions(+), 26 deletions(-) diff --git a/include/git2/stash.h b/include/git2/stash.h index 32e6f95764c..3b89081953d 100644 --- a/include/git2/stash.h +++ b/include/git2/stash.h @@ -44,7 +44,12 @@ typedef enum { * All ignored files are also stashed and then cleaned up from * the working directory */ - GIT_STASH_INCLUDE_IGNORED = (1 << 2) + GIT_STASH_INCLUDE_IGNORED = (1 << 2), + + /** + * All changes in the index and working directory are left intact + */ + GIT_STASH_KEEP_ALL = (1 << 3) } git_stash_flags; /** @@ -71,6 +76,65 @@ GIT_EXTERN(int) git_stash_save( const char *message, uint32_t flags); +/** + * Stash save options structure + * + * Initialize with `GIT_STASH_SAVE_OPTIONS_INIT`. Alternatively, you can + * use `git_stash_save_options_init`. + * + */ +typedef struct git_stash_save_options { + unsigned int version; + + /** The identity of the person performing the stashing. */ + const git_signature *stasher; + + /** Optional description along with the stashed state. */ + const char *message; + + /** Flags to control the stashing process. (see GIT_STASH_* above) */ + uint32_t flags; + + /** Optional paths that control which files are stashed. */ + git_strarray paths; +} git_stash_save_options; + +#define GIT_STASH_SAVE_OPTIONS_VERSION 1 +#define GIT_STASH_SAVE_OPTIONS_INIT { \ + GIT_STASH_SAVE_OPTIONS_VERSION, \ + NULL, \ + NULL, \ + GIT_STASH_DEFAULT } + +/** + * Initialize git_stash_save_options structure + * + * Initializes a `git_stash_save_options` with default values. Equivalent to + * creating an instance with `GIT_STASH_SAVE_OPTIONS_INIT`. + * + * @param opts The `git_stash_save_options` struct to initialize. + * @param version The struct version; pass `GIT_STASH_SAVE_OPTIONS_VERSION`. + * @return Zero on success; -1 on failure. + */ +GIT_EXTERN(int) git_stash_save_options_init( + git_stash_save_options *opts, unsigned int version); + +/** + * Save the local modifications to a new stash, with options. + * + * @param out Object id of the commit containing the stashed state. + * This commit is also the target of the direct reference refs/stash. + * + * @param repo The owning repository. + * + * @param opts The stash options. + * + * @return 0 on success, GIT_ENOTFOUND where there's nothing to stash, + * or error code. + */ +GIT_EXTERN(int) git_stash_save_with_opts( + git_oid *out, git_repository *repo, git_stash_save_options *opts); + /** Stash application flags. */ typedef enum { GIT_STASH_APPLY_DEFAULT = 0, diff --git a/src/libgit2/stash.c b/src/libgit2/stash.c index 5fc01ac36dd..91ff89889ac 100644 --- a/src/libgit2/stash.c +++ b/src/libgit2/stash.c @@ -193,6 +193,30 @@ static int stash_to_index( return git_index_add(index, &entry); } +static int stash_update_index_from_paths( + git_repository *repo, + git_index *index, + git_strarray *paths) +{ + unsigned int status_flags; + size_t i, error = 0; + + for(i = 0; i < paths->count; i++) { + git_status_file(&status_flags, repo, paths->strings[i]); + + if (status_flags & (GIT_STATUS_WT_DELETED | GIT_STATUS_INDEX_DELETED)) { + if ((error = git_index_remove(index, paths->strings[i], 0)) < 0) + return error; + } + else { + if ((error = stash_to_index(repo, index, paths->strings[i])) < 0) + return error; + } + } + + return error; +} + static int stash_update_index_from_diff( git_repository *repo, git_index *index, @@ -388,24 +412,80 @@ static int build_workdir_tree( return error; } -static int commit_worktree( +static int build_stash_commit_from_tree( git_oid *w_commit_oid, git_repository *repo, const git_signature *stasher, const char *message, git_commit *i_commit, git_commit *b_commit, - git_commit *u_commit) + git_commit *u_commit, + git_tree *tree) { const git_commit *parents[] = { NULL, NULL, NULL }; - git_index *i_index = NULL, *r_index = NULL; - git_tree *w_tree = NULL; - int error = 0, ignorecase; parents[0] = b_commit; parents[1] = i_commit; parents[2] = u_commit; + return git_commit_create( + w_commit_oid, + repo, + NULL, + stasher, + stasher, + NULL, + message, + tree, + u_commit ? 3 : 2, + parents); +} + +static int build_stash_commit_from_index( + git_oid *w_commit_oid, + git_repository *repo, + const git_signature *stasher, + const char *message, + git_commit *i_commit, + git_commit *b_commit, + git_commit *u_commit, + git_index *index) +{ + git_tree *tree; + int error; + + if ((error = build_tree_from_index(&tree, repo, index)) < 0) + goto cleanup; + + error = build_stash_commit_from_tree( + w_commit_oid, + repo, + stasher, + message, + i_commit, + b_commit, + u_commit, + tree + ); + +cleanup: + git_tree_free(tree); + return error; +} + +static int commit_worktree( + git_oid *w_commit_oid, + git_repository *repo, + const git_signature *stasher, + const char *message, + git_commit *i_commit, + git_commit *b_commit, + git_commit *u_commit) +{ + git_index *i_index = NULL, *r_index = NULL; + git_tree *w_tree = NULL; + int error = 0, ignorecase; + if ((error = git_repository_index(&r_index, repo) < 0) || (error = git_index_new(&i_index)) < 0 || (error = git_index__fill(i_index, &r_index->entries) < 0) || @@ -417,17 +497,16 @@ static int commit_worktree( if ((error = build_workdir_tree(&w_tree, repo, i_index, b_commit)) < 0) goto cleanup; - error = git_commit_create( + error = build_stash_commit_from_tree( w_commit_oid, repo, - NULL, - stasher, stasher, - NULL, message, - w_tree, - u_commit ? 3 : 2, - parents); + i_commit, + b_commit, + u_commit, + w_tree + ); cleanup: git_tree_free(w_tree); @@ -520,6 +599,50 @@ static int ensure_there_are_changes_to_stash(git_repository *repo, uint32_t flag return error; } +static int has_changes_cb(const char *path, unsigned int status, void *payload) { + GIT_UNUSED(path); + GIT_UNUSED(status); + GIT_UNUSED(payload); + + if (status == GIT_STATUS_CURRENT) + return GIT_ENOTFOUND; + + return 0; +} + +static int ensure_there_are_changes_to_stash_paths( + git_repository *repo, + uint32_t flags, + git_strarray *paths) +{ + int error; + git_status_options opts = GIT_STATUS_OPTIONS_INIT; + + opts.show = GIT_STATUS_SHOW_INDEX_AND_WORKDIR; + opts.flags = GIT_STATUS_OPT_EXCLUDE_SUBMODULES + | GIT_STATUS_OPT_INCLUDE_UNMODIFIED + | GIT_STATUS_OPT_DISABLE_PATHSPEC_MATCH; + + if (flags & GIT_STASH_INCLUDE_UNTRACKED) + opts.flags |= GIT_STATUS_OPT_INCLUDE_UNTRACKED | + GIT_STATUS_OPT_RECURSE_UNTRACKED_DIRS; + + if (flags & GIT_STASH_INCLUDE_IGNORED) + opts.flags |= GIT_STATUS_OPT_INCLUDE_IGNORED | + GIT_STATUS_OPT_RECURSE_IGNORED_DIRS; + + git_strarray_copy(&opts.pathspec, paths); + + error = git_status_foreach_ext(repo, &opts, has_changes_cb, NULL); + + git_strarray_dispose(&opts.pathspec); + + if (error == GIT_ENOTFOUND) + return create_error(GIT_ENOTFOUND, "one of the files does not have any changes to stash."); + + return error; +} + static int reset_index_and_workdir(git_repository *repo, git_commit *commit, uint32_t flags) { git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT; @@ -540,14 +663,25 @@ int git_stash_save( const char *message, uint32_t flags) { - git_index *index = NULL; + git_stash_save_options opts = GIT_STASH_SAVE_OPTIONS_INIT; + opts.stasher = stasher; + opts.message = message; + opts.flags = flags; + return git_stash_save_with_opts(out, repo, &opts); +} + +int git_stash_save_with_opts( + git_oid *out, git_repository *repo, git_stash_save_options *opts) +{ + git_index *index = NULL, *paths_index = NULL; git_commit *b_commit = NULL, *i_commit = NULL, *u_commit = NULL; git_str msg = GIT_STR_INIT; + git_tree *tree = NULL; + git_reference *head = NULL; int error; GIT_ASSERT_ARG(out); GIT_ASSERT_ARG(repo); - GIT_ASSERT_ARG(stasher); if ((error = git_repository__ensure_not_bare(repo, "stash save")) < 0) return error; @@ -555,35 +689,61 @@ int git_stash_save( if ((error = retrieve_base_commit_and_message(&b_commit, &msg, repo)) < 0) goto cleanup; - if ((error = ensure_there_are_changes_to_stash(repo, flags)) < 0) + if (opts->paths.count == 0 && + (error = ensure_there_are_changes_to_stash(repo, opts->flags)) < 0) + goto cleanup; + else if (opts->paths.count > 0 && + (error = ensure_there_are_changes_to_stash_paths( + repo, opts->flags, &opts->paths)) < 0) goto cleanup; if ((error = git_repository_index(&index, repo)) < 0) goto cleanup; - if ((error = commit_index(&i_commit, repo, index, stasher, + if ((error = commit_index(&i_commit, repo, index, opts->stasher, git_str_cstr(&msg), b_commit)) < 0) goto cleanup; - if ((flags & (GIT_STASH_INCLUDE_UNTRACKED | GIT_STASH_INCLUDE_IGNORED)) && - (error = commit_untracked(&u_commit, repo, stasher, - git_str_cstr(&msg), i_commit, flags)) < 0) + if ((opts->flags & (GIT_STASH_INCLUDE_UNTRACKED | GIT_STASH_INCLUDE_IGNORED)) && + (error = commit_untracked(&u_commit, repo, opts->stasher, + git_str_cstr(&msg), i_commit, opts->flags)) < 0) goto cleanup; - if ((error = prepare_worktree_commit_message(&msg, message)) < 0) + if ((error = prepare_worktree_commit_message(&msg, opts->message)) < 0) goto cleanup; - if ((error = commit_worktree(out, repo, stasher, git_str_cstr(&msg), - i_commit, b_commit, u_commit)) < 0) - goto cleanup; + if (opts->paths.count == 0) { + if ((error = commit_worktree(out, repo, opts->stasher, git_str_cstr(&msg), + i_commit, b_commit, u_commit)) < 0) + goto cleanup; + } else { + if ((error = git_index_new(&paths_index)) < 0) + goto cleanup; + + if ((error = retrieve_head(&head, repo)) < 0) + goto cleanup; + + if ((error = git_reference_peel((git_object**)&tree, head, GIT_OBJECT_TREE)) < 0) + goto cleanup; + + if ((error = git_index_read_tree(paths_index, tree)) < 0) + goto cleanup; + + if ((error = stash_update_index_from_paths(repo, paths_index, &opts->paths)) < 0) + goto cleanup; + + if ((error = build_stash_commit_from_index(out, repo, opts->stasher, git_str_cstr(&msg), + i_commit, b_commit, u_commit, paths_index)) < 0) + goto cleanup; + } git_str_rtrim(&msg); if ((error = update_reflog(out, repo, git_str_cstr(&msg))) < 0) goto cleanup; - if ((error = reset_index_and_workdir(repo, (flags & GIT_STASH_KEEP_INDEX) ? i_commit : b_commit, - flags)) < 0) + if (!(opts->flags & GIT_STASH_KEEP_ALL) && (error = reset_index_and_workdir(repo, + (opts->flags & GIT_STASH_KEEP_INDEX) ? i_commit : b_commit, opts->flags)) < 0) goto cleanup; cleanup: @@ -592,7 +752,10 @@ int git_stash_save( git_commit_free(i_commit); git_commit_free(b_commit); git_commit_free(u_commit); + git_tree_free(tree); + git_reference_free(head); git_index_free(index); + git_index_free(paths_index); return error; } @@ -777,6 +940,13 @@ int git_stash_apply_options_init(git_stash_apply_options *opts, unsigned int ver return 0; } +int git_stash_save_options_init(git_stash_save_options *opts, unsigned int version) +{ + GIT_INIT_STRUCTURE_FROM_TEMPLATE( + opts, version, git_stash_save_options, GIT_STASH_SAVE_OPTIONS_INIT); + return 0; +} + #ifndef GIT_DEPRECATE_HARD int git_stash_apply_init_options(git_stash_apply_options *opts, unsigned int version) { From d91de9b070da4f5f1bab1007fef5d628a5c27066 Mon Sep 17 00:00:00 2001 From: Jacob Watson Date: Fri, 17 Jun 2022 11:17:04 -0700 Subject: [PATCH 039/608] stash: implement CI testing --- tests/libgit2/stash/save.c | 37 +++++++++++++++++++++++++++++++++++++ 1 file changed, 37 insertions(+) diff --git a/tests/libgit2/stash/save.c b/tests/libgit2/stash/save.c index f574211d794..23f3c1cbb41 100644 --- a/tests/libgit2/stash/save.c +++ b/tests/libgit2/stash/save.c @@ -130,6 +130,19 @@ void test_stash_save__can_keep_index(void) assert_status(repo, "just.ignore", GIT_STATUS_IGNORED); } +void test_stash_save__can_keep_all(void) +{ + cl_git_pass(git_stash_save(&stash_tip_oid, repo, signature, NULL, GIT_STASH_KEEP_ALL)); + + assert_status(repo, "what", GIT_STATUS_WT_MODIFIED | GIT_STATUS_INDEX_MODIFIED); + assert_status(repo, "how", GIT_STATUS_INDEX_MODIFIED); + assert_status(repo, "who", GIT_STATUS_WT_MODIFIED); + assert_status(repo, "when", GIT_STATUS_WT_NEW); + assert_status(repo, "why", GIT_STATUS_INDEX_NEW); + assert_status(repo, "where", GIT_STATUS_WT_MODIFIED | GIT_STATUS_INDEX_NEW); + assert_status(repo, "just.ignore", GIT_STATUS_IGNORED); +} + static void assert_commit_message_contains(const char *revision, const char *fragment) { git_commit *commit; @@ -488,3 +501,27 @@ void test_stash_save__deleted_in_index_modified_in_workdir(void) git_index_free(index); } + +void test_stash_save__option_paths(void) +{ + git_stash_save_options options = GIT_STASH_SAVE_OPTIONS_INIT; + char *paths[2] = { "who", "where" }; + + options.paths = (git_strarray){ + paths, + 2 + }; + options.stasher = signature; + + cl_git_pass(git_stash_save_with_opts(&stash_tip_oid, repo, &options)); + + assert_blob_oid("refs/stash:who", "a0400d4954659306a976567af43125a0b1aa8595"); + assert_blob_oid("refs/stash:where", "e3d6434ec12eb76af8dfa843a64ba6ab91014a0b"); + + assert_blob_oid("refs/stash:what", "ce013625030ba8dba906f756967f9e9ca394464a"); + assert_blob_oid("refs/stash:how", "ac790413e2d7a26c3767e78c57bb28716686eebc"); + assert_blob_oid("refs/stash:when", NULL); + assert_blob_oid("refs/stash:why", NULL); + assert_blob_oid("refs/stash:.gitignore", "ac4d88de61733173d9959e4b77c69b9f17a00980"); + assert_blob_oid("refs/stash:just.ignore", NULL); +} From d0155f1089113bb022aa614254b15a7e1ffcd4a2 Mon Sep 17 00:00:00 2001 From: Jacob Watson Date: Thu, 14 Jul 2022 10:23:18 -0700 Subject: [PATCH 040/608] stash: better option validation for stash save --- src/libgit2/stash.c | 23 +++++++++++++++++------ 1 file changed, 17 insertions(+), 6 deletions(-) diff --git a/src/libgit2/stash.c b/src/libgit2/stash.c index 91ff89889ac..d801a04eeaf 100644 --- a/src/libgit2/stash.c +++ b/src/libgit2/stash.c @@ -664,6 +664,9 @@ int git_stash_save( uint32_t flags) { git_stash_save_options opts = GIT_STASH_SAVE_OPTIONS_INIT; + + GIT_ASSERT_ARG(stasher); + opts.stasher = stasher; opts.message = message; opts.flags = flags; @@ -678,10 +681,15 @@ int git_stash_save_with_opts( git_str msg = GIT_STR_INIT; git_tree *tree = NULL; git_reference *head = NULL; + bool has_paths = false; + int error; GIT_ASSERT_ARG(out); GIT_ASSERT_ARG(repo); + GIT_ASSERT_ARG(opts && opts->stasher); + + has_paths = opts->paths.count > 0; if ((error = git_repository__ensure_not_bare(repo, "stash save")) < 0) return error; @@ -689,10 +697,10 @@ int git_stash_save_with_opts( if ((error = retrieve_base_commit_and_message(&b_commit, &msg, repo)) < 0) goto cleanup; - if (opts->paths.count == 0 && + if (!has_paths && (error = ensure_there_are_changes_to_stash(repo, opts->flags)) < 0) goto cleanup; - else if (opts->paths.count > 0 && + else if (has_paths && (error = ensure_there_are_changes_to_stash_paths( repo, opts->flags, &opts->paths)) < 0) goto cleanup; @@ -712,7 +720,7 @@ int git_stash_save_with_opts( if ((error = prepare_worktree_commit_message(&msg, opts->message)) < 0) goto cleanup; - if (opts->paths.count == 0) { + if (!has_paths) { if ((error = commit_worktree(out, repo, opts->stasher, git_str_cstr(&msg), i_commit, b_commit, u_commit)) < 0) goto cleanup; @@ -753,9 +761,12 @@ int git_stash_save_with_opts( git_commit_free(b_commit); git_commit_free(u_commit); git_tree_free(tree); - git_reference_free(head); - git_index_free(index); - git_index_free(paths_index); + + if (has_paths) { + git_reference_free(head); + git_index_free(index); + git_index_free(paths_index); + } return error; } From fc9d28970a9fe970025f529c2108a6a3fef03555 Mon Sep 17 00:00:00 2001 From: Jacob Watson Date: Wed, 13 Jul 2022 15:58:52 -0700 Subject: [PATCH 041/608] stash: add `const` to arguments --- include/git2/stash.h | 4 +++- src/libgit2/stash.c | 8 ++++---- 2 files changed, 7 insertions(+), 5 deletions(-) diff --git a/include/git2/stash.h b/include/git2/stash.h index 3b89081953d..3d70b36c310 100644 --- a/include/git2/stash.h +++ b/include/git2/stash.h @@ -133,7 +133,9 @@ GIT_EXTERN(int) git_stash_save_options_init( * or error code. */ GIT_EXTERN(int) git_stash_save_with_opts( - git_oid *out, git_repository *repo, git_stash_save_options *opts); + git_oid *out, + git_repository *repo, + const git_stash_save_options *opts); /** Stash application flags. */ typedef enum { diff --git a/src/libgit2/stash.c b/src/libgit2/stash.c index d801a04eeaf..af65aae3c4d 100644 --- a/src/libgit2/stash.c +++ b/src/libgit2/stash.c @@ -196,7 +196,7 @@ static int stash_to_index( static int stash_update_index_from_paths( git_repository *repo, git_index *index, - git_strarray *paths) + const git_strarray *paths) { unsigned int status_flags; size_t i, error = 0; @@ -420,7 +420,7 @@ static int build_stash_commit_from_tree( git_commit *i_commit, git_commit *b_commit, git_commit *u_commit, - git_tree *tree) + const git_tree *tree) { const git_commit *parents[] = { NULL, NULL, NULL }; @@ -613,7 +613,7 @@ static int has_changes_cb(const char *path, unsigned int status, void *payload) static int ensure_there_are_changes_to_stash_paths( git_repository *repo, uint32_t flags, - git_strarray *paths) + const git_strarray *paths) { int error; git_status_options opts = GIT_STATUS_OPTIONS_INIT; @@ -674,7 +674,7 @@ int git_stash_save( } int git_stash_save_with_opts( - git_oid *out, git_repository *repo, git_stash_save_options *opts) + git_oid *out, git_repository *repo, const git_stash_save_options *opts) { git_index *index = NULL, *paths_index = NULL; git_commit *b_commit = NULL, *i_commit = NULL, *u_commit = NULL; From fb9515abc80c945dfe74713989dfb4f41d03d106 Mon Sep 17 00:00:00 2001 From: Jacob Watson Date: Wed, 13 Jul 2022 16:50:02 -0700 Subject: [PATCH 042/608] stash: test save options init --- tests/libgit2/core/structinit.c | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/tests/libgit2/core/structinit.c b/tests/libgit2/core/structinit.c index 160e2f61218..8a6e48d2a9c 100644 --- a/tests/libgit2/core/structinit.c +++ b/tests/libgit2/core/structinit.c @@ -160,6 +160,11 @@ void test_core_structinit__compare(void) git_stash_apply_options, GIT_STASH_APPLY_OPTIONS_VERSION, \ GIT_STASH_APPLY_OPTIONS_INIT, git_stash_apply_options_init); + /* stash save */ + CHECK_MACRO_FUNC_INIT_EQUAL( \ + git_stash_save_options, GIT_STASH_SAVE_OPTIONS_VERSION, \ + GIT_STASH_SAVE_OPTIONS_INIT, git_stash_save_options_init); + /* status */ CHECK_MACRO_FUNC_INIT_EQUAL( \ git_status_options, GIT_STATUS_OPTIONS_VERSION, \ From d9de12f88bfb025d0092eaa18f266978577c11f2 Mon Sep 17 00:00:00 2001 From: Alberto Fanjul Date: Sun, 17 Jul 2022 23:52:11 +0200 Subject: [PATCH 043/608] fix log example --- examples/log.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/examples/log.c b/examples/log.c index 4b0a95dcd0d..e9ebe377c87 100644 --- a/examples/log.c +++ b/examples/log.c @@ -81,9 +81,11 @@ int lg2_log(git_repository *repo, int argc, char *argv[]) git_commit *commit = NULL; git_pathspec *ps = NULL; + memset(&s, 0, sizeof(s)); + /** Parse arguments and set up revwalker. */ - last_arg = parse_options(&s, &opt, argc, argv); s.repo = repo; + last_arg = parse_options(&s, &opt, argc, argv); diffopts.pathspec.strings = &argv[last_arg]; diffopts.pathspec.count = argc - last_arg; @@ -407,8 +409,6 @@ static int parse_options( struct log_state *s, struct log_options *opt, int argc, char **argv) { struct args_info args = ARGS_INFO_INIT; - - memset(s, 0, sizeof(*s)); s->sorting = GIT_SORT_TIME; memset(opt, 0, sizeof(*opt)); From 6b86332465b8740b8845043acf377f7d383f6014 Mon Sep 17 00:00:00 2001 From: Alberto Fanjul Date: Mon, 18 Jul 2022 07:57:21 +0200 Subject: [PATCH 044/608] parse arguments correctly --- examples/log.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/log.c b/examples/log.c index e9ebe377c87..84de5510985 100644 --- a/examples/log.c +++ b/examples/log.c @@ -424,7 +424,7 @@ static int parse_options( else /** Try failed revision parse as filename. */ break; - } else if (!match_arg_separator(&args)) { + } else if (match_arg_separator(&args)) { break; } else if (!strcmp(a, "--date-order")) From c97989e48deb4a68b4a3ca43af4278131dfbd288 Mon Sep 17 00:00:00 2001 From: Alberto Fanjul Date: Mon, 18 Jul 2022 08:02:41 +0200 Subject: [PATCH 045/608] Add oneline option --- examples/log.c | 48 +++++++++++++++++++++++++++++++----------------- 1 file changed, 31 insertions(+), 17 deletions(-) diff --git a/examples/log.c b/examples/log.c index 84de5510985..62a6eb5858f 100644 --- a/examples/log.c +++ b/examples/log.c @@ -50,6 +50,7 @@ static int add_revision(struct log_state *s, const char *revstr); /** log_options holds other command line options that affect log output */ struct log_options { int show_diff; + int show_oneline; int show_log_size; int skip, limit; int min_parents, max_parents; @@ -337,34 +338,45 @@ static void print_commit(git_commit *commit, struct log_options *opts) const char *scan, *eol; git_oid_tostr(buf, sizeof(buf), git_commit_id(commit)); - printf("commit %s\n", buf); - if (opts->show_log_size) { - printf("log size %d\n", (int)strlen(git_commit_message(commit))); - } + if (opts->show_oneline) { + printf("%s ", buf); + } else { + printf("commit %s\n", buf); - if ((count = (int)git_commit_parentcount(commit)) > 1) { - printf("Merge:"); - for (i = 0; i < count; ++i) { - git_oid_tostr(buf, 8, git_commit_parent_id(commit, i)); - printf(" %s", buf); + if (opts->show_log_size) { + printf("log size %d\n", (int)strlen(git_commit_message(commit))); + } + + if ((count = (int)git_commit_parentcount(commit)) > 1) { + printf("Merge:"); + for (i = 0; i < count; ++i) { + git_oid_tostr(buf, 8, git_commit_parent_id(commit, i)); + printf(" %s", buf); + } + printf("\n"); } - printf("\n"); - } - if ((sig = git_commit_author(commit)) != NULL) { - printf("Author: %s <%s>\n", sig->name, sig->email); - print_time(&sig->when, "Date: "); + if ((sig = git_commit_author(commit)) != NULL) { + printf("Author: %s <%s>\n", sig->name, sig->email); + print_time(&sig->when, "Date: "); + } + printf("\n"); } - printf("\n"); for (scan = git_commit_message(commit); scan && *scan; ) { for (eol = scan; *eol && *eol != '\n'; ++eol) /* find eol */; - printf(" %.*s\n", (int)(eol - scan), scan); + if (opts->show_oneline) + printf("%.*s\n", (int)(eol - scan), scan); + else + printf(" %.*s\n", (int)(eol - scan), scan); scan = *eol ? eol + 1 : NULL; + if (opts->show_oneline) + break; } - printf("\n"); + if (!opts->show_oneline) + printf("\n"); } /** Helper to find how many files in a commit changed from its nth parent. */ @@ -474,6 +486,8 @@ static int parse_options( opt->show_diff = 1; else if (!strcmp(a, "--log-size")) opt->show_log_size = 1; + else if (!strcmp(a, "--oneline")) + opt->show_oneline = 1; else usage("Unsupported argument", a); } From c652f3d13372398fc86c72a7b05c90002d1cc763 Mon Sep 17 00:00:00 2001 From: yuangli Date: Tue, 19 Jul 2022 13:54:33 +0100 Subject: [PATCH 046/608] enable cloning of shallow repo --- src/clone.c | 3 ++- tests/clone/shallow.c | 25 ++++++++++++++++--------- 2 files changed, 18 insertions(+), 10 deletions(-) diff --git a/src/clone.c b/src/clone.c index 752df3b92d8..5750a71af39 100644 --- a/src/clone.c +++ b/src/clone.c @@ -409,7 +409,8 @@ static int clone_into(git_repository *repo, git_remote *_remote, const git_fetch memcpy(&fetch_opts, opts, sizeof(git_fetch_options)); fetch_opts.update_fetchhead = 0; - fetch_opts.download_tags = GIT_REMOTE_DOWNLOAD_TAGS_ALL; + if (fetch_opts.depth == -1) + fetch_opts.download_tags = GIT_REMOTE_DOWNLOAD_TAGS_ALL; git_buf_printf(&reflog_message, "clone: from %s", git_remote_url(remote)); if ((error = git_remote_fetch(remote, NULL, &fetch_opts, git_buf_cstr(&reflog_message))) != 0) diff --git a/tests/clone/shallow.c b/tests/clone/shallow.c index b41e28d6611..b3e8f161716 100644 --- a/tests/clone/shallow.c +++ b/tests/clone/shallow.c @@ -15,6 +15,15 @@ void test_clone_shallow__cleanup(void) #define CLONE_DEPTH 5 +static int remote_single_branch(git_remote **out, git_repository *repo, const char *name, const char *url, void *payload) +{ + GIT_UNUSED(payload); + + cl_git_pass(git_remote_create_with_fetchspec(out, repo, name, url, "+refs/heads/master:refs/remotes/origin/master")); + + return 0; +} + void test_clone_shallow__clone_depth(void) { git_buf path = GIT_BUF_INIT; @@ -27,6 +36,7 @@ void test_clone_shallow__clone_depth(void) int error = 0; clone_opts.fetch_opts.depth = CLONE_DEPTH; + clone_opts.remote_cb = remote_single_branch; git_buf_joinpath(&path, clar_sandbox_path(), "shallowclone"); @@ -35,21 +45,18 @@ void test_clone_shallow__clone_depth(void) cl_assert_equal_b(true, git_repository_is_shallow(repo)); cl_git_pass(git_repository_shallow_roots(&roots, repo)); - cl_assert_equal_i(1, roots.count); - cl_assert_equal_s("83834a7afdaa1a1260568567f6ad90020389f664", git_oid_tostr_s(&roots.ids[0])); + cl_assert_equal_i(3, roots.count); + cl_assert_equal_s("c070ad8c08840c8116da865b2d65593a6bb9cd2a", git_oid_tostr_s(&roots.ids[0])); + cl_assert_equal_s("0966a434eb1a025db6b71485ab63a3bfbea520b6", git_oid_tostr_s(&roots.ids[1])); + cl_assert_equal_s("83834a7afdaa1a1260568567f6ad90020389f664", git_oid_tostr_s(&roots.ids[2])); git_revwalk_new(&walk, repo); git_revwalk_push_head(walk); while ((error = git_revwalk_next(&oid, walk)) == GIT_OK) { - //if (depth + 1 > CLONE_DEPTH) - //cl_fail("expected depth mismatch"); - char str[GIT_OID_HEXSZ +1]; - git_oid_fmt(str, &oid); - printf(str); - printf("\n"); - depth++; + if (depth + 1 > CLONE_DEPTH) + cl_fail("expected depth mismatch"); } cl_git_pass(error); From f19ffc8a6d88432146a87cd3fb2ca21528478be4 Mon Sep 17 00:00:00 2001 From: yuangli Date: Tue, 19 Jul 2022 15:42:12 +0100 Subject: [PATCH 047/608] add test for shallow repo depth 1 --- tests/clone/shallow.c | 60 +++++++++++++++++++++++++++++++++++-------- 1 file changed, 49 insertions(+), 11 deletions(-) diff --git a/tests/clone/shallow.c b/tests/clone/shallow.c index b3e8f161716..01852dfeddf 100644 --- a/tests/clone/shallow.c +++ b/tests/clone/shallow.c @@ -4,17 +4,15 @@ void test_clone_shallow__initialize(void) { - + cl_git_pass(git_libgit2_opts(GIT_OPT_ENABLE_SHALLOW, 1)); } void test_clone_shallow__cleanup(void) { + git_libgit2_opts(GIT_OPT_ENABLE_SHALLOW, 0); cl_git_sandbox_cleanup(); } - -#define CLONE_DEPTH 5 - static int remote_single_branch(git_remote **out, git_repository *repo, const char *name, const char *url, void *payload) { GIT_UNUSED(payload); @@ -24,7 +22,47 @@ static int remote_single_branch(git_remote **out, git_repository *repo, const ch return 0; } -void test_clone_shallow__clone_depth(void) +void test_clone_shallow__clone_depth_one(void) +{ + git_buf path = GIT_BUF_INIT; + git_repository *repo; + git_revwalk *walk; + git_clone_options clone_opts = GIT_CLONE_OPTIONS_INIT; + git_oid oid; + git_oidarray roots; + size_t num_commits = 0; + int error = 0; + + clone_opts.fetch_opts.depth = 1; + clone_opts.remote_cb = remote_single_branch; + + git_buf_joinpath(&path, clar_sandbox_path(), "shallowclone_1"); + + cl_git_pass(git_clone(&repo, "https://github.com/libgit2/TestGitRepository", git_buf_cstr(&path), &clone_opts)); + + cl_assert_equal_b(true, git_repository_is_shallow(repo)); + + cl_git_pass(git_repository_shallow_roots(&roots, repo)); + cl_assert_equal_i(1, roots.count); + cl_assert_equal_s("49322bb17d3acc9146f98c97d078513228bbf3c0", git_oid_tostr_s(&roots.ids[0])); + + git_revwalk_new(&walk, repo); + + git_revwalk_push_head(walk); + + while ((error = git_revwalk_next(&oid, walk)) == GIT_OK) { + num_commits++; + } + + cl_assert_equal_i(num_commits, 1); + cl_assert_equal_i(error, GIT_ITEROVER); + + git_buf_dispose(&path); + git_revwalk_free(walk); + git_repository_free(repo); +} + +void test_clone_shallow__clone_depth_five(void) { git_buf path = GIT_BUF_INIT; git_repository *repo; @@ -32,13 +70,13 @@ void test_clone_shallow__clone_depth(void) git_clone_options clone_opts = GIT_CLONE_OPTIONS_INIT; git_oid oid; git_oidarray roots; - size_t depth = 0; + size_t num_commits = 0; int error = 0; - clone_opts.fetch_opts.depth = CLONE_DEPTH; + clone_opts.fetch_opts.depth = 5; clone_opts.remote_cb = remote_single_branch; - git_buf_joinpath(&path, clar_sandbox_path(), "shallowclone"); + git_buf_joinpath(&path, clar_sandbox_path(), "shallowclone_5"); cl_git_pass(git_clone(&repo, "https://github.com/libgit2/TestGitRepository", git_buf_cstr(&path), &clone_opts)); @@ -55,11 +93,11 @@ void test_clone_shallow__clone_depth(void) git_revwalk_push_head(walk); while ((error = git_revwalk_next(&oid, walk)) == GIT_OK) { - if (depth + 1 > CLONE_DEPTH) - cl_fail("expected depth mismatch"); + num_commits++; } - cl_git_pass(error); + cl_assert_equal_i(num_commits, 13); + cl_assert_equal_i(error, GIT_ITEROVER); git_buf_dispose(&path); git_revwalk_free(walk); From 7f46bfac14f0502711f8441348fd361175953fd5 Mon Sep 17 00:00:00 2001 From: Yuang Li Date: Tue, 26 Jul 2022 13:59:00 +0100 Subject: [PATCH 048/608] unset GIT_RAND_GETENTROPY to avoid linux GLIBC issues (#3) --- src/CMakeLists.txt | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index e108b2e79ce..b81ad272f44 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -70,7 +70,11 @@ check_function_exists(qsort_s GIT_QSORT_S) # random / entropy data -check_function_exists(getentropy GIT_RAND_GETENTROPY) +# The flag has been unset to prevent issues +# related to Linux GLIBC version dependency + +# check_function_exists(getentropy GIT_RAND_GETENTROPY) +unset(GIT_RAND_GETENTROPY) check_function_exists(getloadavg GIT_RAND_GETLOADAVG) # determine architecture of the machine From 83f71b12e1f26943d3c544901846fb1d55785735 Mon Sep 17 00:00:00 2001 From: yuangli Date: Tue, 26 Jul 2022 16:57:30 +0100 Subject: [PATCH 049/608] fix build errors --- .gitignore | 1 + include/git2/common.h | 2 +- src/{ => libgit2}/grafts.c | 0 src/{ => libgit2}/grafts.h | 0 src/libgit2/repository.c | 6 +++--- 5 files changed, 5 insertions(+), 4 deletions(-) rename src/{ => libgit2}/grafts.c (100%) rename src/{ => libgit2}/grafts.h (100%) diff --git a/.gitignore b/.gitignore index 1b482f038af..d43bd9c7863 100644 --- a/.gitignore +++ b/.gitignore @@ -6,3 +6,4 @@ CMakeSettings.json .vs .idea +.cache diff --git a/include/git2/common.h b/include/git2/common.h index ac035f0afee..4e47488d73f 100644 --- a/include/git2/common.h +++ b/include/git2/common.h @@ -227,7 +227,7 @@ typedef enum { GIT_OPT_GET_EXTENSIONS, GIT_OPT_SET_EXTENSIONS, GIT_OPT_GET_OWNER_VALIDATION, - GIT_OPT_SET_OWNER_VALIDATION + GIT_OPT_SET_OWNER_VALIDATION, GIT_OPT_ENABLE_SHALLOW } git_libgit2_opt_t; diff --git a/src/grafts.c b/src/libgit2/grafts.c similarity index 100% rename from src/grafts.c rename to src/libgit2/grafts.c diff --git a/src/grafts.h b/src/libgit2/grafts.h similarity index 100% rename from src/grafts.h rename to src/libgit2/grafts.h diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index 2ecc510b223..e58ab529a0a 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -736,13 +736,13 @@ static int load_grafts(git_repository *repo) int error; if ((error = git_repository_item_path(&path, repo, GIT_REPOSITORY_ITEM_INFO)) < 0 || - (error = git_buf_joinpath(&path, path.ptr, "grafts")) < 0 || + (error = git_str_joinpath(&path, path.ptr, "grafts")) < 0 || (error = git_grafts_from_file(&repo->grafts, path.ptr)) < 0) goto error; - git_buf_clear(&path); + git_str_clear(&path); - if ((error = git_buf_joinpath(&path, repo->gitdir, "shallow")) < 0 || + if ((error = git_str_joinpath(&path, repo->gitdir, "shallow")) < 0 || (error = git_grafts_from_file(&repo->shallow_grafts, path.ptr)) < 0) goto error; From cfc2ae68b4792f0c64152888869ef69d868079d7 Mon Sep 17 00:00:00 2001 From: yuangli Date: Wed, 27 Jul 2022 11:53:37 +0100 Subject: [PATCH 050/608] eliminate build warnings --- src/libgit2/commit.c | 7 +++---- src/libgit2/grafts.c | 6 +++--- src/libgit2/libgit2.c | 2 ++ src/libgit2/repository.c | 6 +++--- tests/{ => libgit2}/grafts/basic.c | 0 tests/{ => libgit2}/grafts/parse.c | 0 tests/{ => libgit2}/grafts/shallow.c | 0 7 files changed, 11 insertions(+), 10 deletions(-) rename tests/{ => libgit2}/grafts/basic.c (100%) rename tests/{ => libgit2}/grafts/parse.c (100%) rename tests/{ => libgit2}/grafts/shallow.c (100%) diff --git a/src/libgit2/commit.c b/src/libgit2/commit.c index 7432ef4ec53..2138d6eb210 100644 --- a/src/libgit2/commit.c +++ b/src/libgit2/commit.c @@ -501,8 +501,10 @@ int git_commit__parse_raw(void *commit, const char *data, size_t size) int git_commit__parse_ext(git_commit *commit, git_odb_object *odb_obj, unsigned int flags) { - + git_repository *repo = git_object_owner((git_object *)commit); + git_commit_graft *graft; int error; + if ((error = commit_parse(commit, git_odb_object_data(odb_obj), git_odb_object_size(odb_obj), flags)) < 0) return error; @@ -510,9 +512,6 @@ int git_commit__parse_ext(git_commit *commit, git_odb_object *odb_obj, unsigned if (!git_shallow__enabled) return 0; - git_repository *repo = git_object_owner((git_object *)commit); - git_commit_graft *graft; - /* Perform necessary grafts */ if (git_grafts_get(&graft, repo->grafts, git_odb_object_id(odb_obj)) == 0 || git_grafts_get(&graft, repo->shallow_grafts, git_odb_object_id(odb_obj)) == 0) { diff --git a/src/libgit2/grafts.c b/src/libgit2/grafts.c index 00352261670..8bcefbab9e5 100644 --- a/src/libgit2/grafts.c +++ b/src/libgit2/grafts.c @@ -85,7 +85,7 @@ void git_grafts_clear(git_grafts *grafts) int git_grafts_refresh(git_grafts *grafts) { - git_buf contents = GIT_BUF_INIT; + git_str contents = GIT_STR_INIT; int error, updated = 0; assert(grafts); @@ -94,7 +94,7 @@ int git_grafts_refresh(git_grafts *grafts) return 0; error = git_futils_readbuffer_updated(&contents, grafts->path, - &grafts->path_checksum, &updated); + (grafts->path_checksum).id, &updated); if (error < 0 || error == GIT_ENOTFOUND || !updated) { if (error == GIT_ENOTFOUND) { git_grafts_clear(grafts); @@ -107,7 +107,7 @@ int git_grafts_refresh(git_grafts *grafts) goto cleanup; cleanup: - git_buf_dispose(&contents); + git_str_dispose(&contents); return error; } diff --git a/src/libgit2/libgit2.c b/src/libgit2/libgit2.c index b76728e0ce4..2537730cf57 100644 --- a/src/libgit2/libgit2.c +++ b/src/libgit2/libgit2.c @@ -413,6 +413,8 @@ int git_libgit2_opts(int key, ...) case GIT_OPT_SET_OWNER_VALIDATION: git_repository__validate_ownership = (va_arg(ap, int) != 0); + break; + case GIT_OPT_ENABLE_SHALLOW: git_shallow__enabled = (va_arg(ap, int) != 0); break; diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index e58ab529a0a..809617276f0 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -732,10 +732,10 @@ static int find_repo( static int load_grafts(git_repository *repo) { - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; int error; - if ((error = git_repository_item_path(&path, repo, GIT_REPOSITORY_ITEM_INFO)) < 0 || + if ((error = git_repository__item_path(&path, repo, GIT_REPOSITORY_ITEM_INFO)) < 0 || (error = git_str_joinpath(&path, path.ptr, "grafts")) < 0 || (error = git_grafts_from_file(&repo->grafts, path.ptr)) < 0) goto error; @@ -747,7 +747,7 @@ static int load_grafts(git_repository *repo) goto error; error: - git_buf_dispose(&path); + git_str_dispose(&path); return error; } diff --git a/tests/grafts/basic.c b/tests/libgit2/grafts/basic.c similarity index 100% rename from tests/grafts/basic.c rename to tests/libgit2/grafts/basic.c diff --git a/tests/grafts/parse.c b/tests/libgit2/grafts/parse.c similarity index 100% rename from tests/grafts/parse.c rename to tests/libgit2/grafts/parse.c diff --git a/tests/grafts/shallow.c b/tests/libgit2/grafts/shallow.c similarity index 100% rename from tests/grafts/shallow.c rename to tests/libgit2/grafts/shallow.c From c01b7841b77c08189eae916d21d591027962a831 Mon Sep 17 00:00:00 2001 From: yuangli Date: Thu, 28 Jul 2022 14:24:18 +0100 Subject: [PATCH 051/608] improve error handling --- .gitignore | 1 - include/git2/repository.h | 1 - src/libgit2/grafts.c | 10 +++++++--- src/libgit2/repository.c | 7 ------- src/libgit2/repository.h | 1 - 5 files changed, 7 insertions(+), 13 deletions(-) diff --git a/.gitignore b/.gitignore index d43bd9c7863..1b482f038af 100644 --- a/.gitignore +++ b/.gitignore @@ -6,4 +6,3 @@ CMakeSettings.json .vs .idea -.cache diff --git a/include/git2/repository.h b/include/git2/repository.h index 258b9ac00a7..c87f3c96252 100644 --- a/include/git2/repository.h +++ b/include/git2/repository.h @@ -11,7 +11,6 @@ #include "types.h" #include "oid.h" #include "buffer.h" -#include "oidarray.h" /** * @file git2/repository.h diff --git a/src/libgit2/grafts.c b/src/libgit2/grafts.c index 8bcefbab9e5..82be2a68069 100644 --- a/src/libgit2/grafts.c +++ b/src/libgit2/grafts.c @@ -93,13 +93,17 @@ int git_grafts_refresh(git_grafts *grafts) if (!grafts->path) return 0; - error = git_futils_readbuffer_updated(&contents, grafts->path, - (grafts->path_checksum).id, &updated); - if (error < 0 || error == GIT_ENOTFOUND || !updated) { + if ((error = git_futils_readbuffer_updated(&contents, grafts->path, + (grafts->path_checksum).id, &updated)) < 0) { if (error == GIT_ENOTFOUND) { git_grafts_clear(grafts); error = 0; } + + goto cleanup; + } + + if (!updated) { goto cleanup; } diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index 809617276f0..c36666c436c 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -735,13 +735,6 @@ static int load_grafts(git_repository *repo) git_str path = GIT_STR_INIT; int error; - if ((error = git_repository__item_path(&path, repo, GIT_REPOSITORY_ITEM_INFO)) < 0 || - (error = git_str_joinpath(&path, path.ptr, "grafts")) < 0 || - (error = git_grafts_from_file(&repo->grafts, path.ptr)) < 0) - goto error; - - git_str_clear(&path); - if ((error = git_str_joinpath(&path, repo->gitdir, "shallow")) < 0 || (error = git_grafts_from_file(&repo->shallow_grafts, path.ptr)) < 0) goto error; diff --git a/src/libgit2/repository.h b/src/libgit2/repository.h index 6d39bb92af7..3cca53b3e54 100644 --- a/src/libgit2/repository.h +++ b/src/libgit2/repository.h @@ -25,7 +25,6 @@ #include "submodule.h" #include "diff_driver.h" #include "grafts.h" -#include "oidarray.h" #define DOT_GIT ".git" #define GIT_DIR DOT_GIT "/" From 14d2a60a5bdb6fe62b65751bda0ce01a66ac5e99 Mon Sep 17 00:00:00 2001 From: yuangli Date: Thu, 28 Jul 2022 14:30:30 +0100 Subject: [PATCH 052/608] fix load_grafts --- src/libgit2/repository.c | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index c36666c436c..809617276f0 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -735,6 +735,13 @@ static int load_grafts(git_repository *repo) git_str path = GIT_STR_INIT; int error; + if ((error = git_repository__item_path(&path, repo, GIT_REPOSITORY_ITEM_INFO)) < 0 || + (error = git_str_joinpath(&path, path.ptr, "grafts")) < 0 || + (error = git_grafts_from_file(&repo->grafts, path.ptr)) < 0) + goto error; + + git_str_clear(&path); + if ((error = git_str_joinpath(&path, repo->gitdir, "shallow")) < 0 || (error = git_grafts_from_file(&repo->shallow_grafts, path.ptr)) < 0) goto error; From 62cc77a16d62410140e31960189e566f16b22772 Mon Sep 17 00:00:00 2001 From: yuangli Date: Thu, 28 Jul 2022 16:03:59 +0100 Subject: [PATCH 053/608] refactor commit parent assignment with graft --- src/libgit2/commit.c | 36 +++++++++++++++++++++--------------- 1 file changed, 21 insertions(+), 15 deletions(-) diff --git a/src/libgit2/commit.c b/src/libgit2/commit.c index 2138d6eb210..6f689e36216 100644 --- a/src/libgit2/commit.c +++ b/src/libgit2/commit.c @@ -499,6 +499,22 @@ int git_commit__parse_raw(void *commit, const char *data, size_t size) return commit_parse(commit, data, size, 0); } +static int assign_parents_from_graft(git_commit *commit, git_commit_graft *graft) { + size_t idx; + git_oid *oid; + + git_array_clear(commit->parent_ids); + git_array_init_to_size(commit->parent_ids, git_array_size(graft->parents)); + git_array_foreach(graft->parents, idx, oid) { + git_oid *id = git_array_alloc(commit->parent_ids); + GIT_ERROR_CHECK_ALLOC(id); + + git_oid_cpy(id, oid); + } + + return 0; +} + int git_commit__parse_ext(git_commit *commit, git_odb_object *odb_obj, unsigned int flags) { git_repository *repo = git_object_owner((git_object *)commit); @@ -513,21 +529,11 @@ int git_commit__parse_ext(git_commit *commit, git_odb_object *odb_obj, unsigned return 0; /* Perform necessary grafts */ - if (git_grafts_get(&graft, repo->grafts, git_odb_object_id(odb_obj)) == 0 || - git_grafts_get(&graft, repo->shallow_grafts, git_odb_object_id(odb_obj)) == 0) { - size_t idx; - git_oid *oid; - git_array_clear(commit->parent_ids); - git_array_init_to_size(commit->parent_ids, git_array_size(graft->parents)); - git_array_foreach(graft->parents, idx, oid) { - git_oid *id = git_array_alloc(commit->parent_ids); - GIT_ERROR_CHECK_ALLOC(id); - - git_oid_cpy(id, oid); - } - } - - return 0; + if (git_grafts_get(&graft, repo->grafts, git_odb_object_id(odb_obj)) != 0 && + git_grafts_get(&graft, repo->shallow_grafts, git_odb_object_id(odb_obj)) != 0) + return 0; + + return assign_parents_from_graft(commit, graft); } int git_commit__parse(void *_commit, git_odb_object *odb_obj) From a544a91058cc310a0e36e290debe5ad59040fab1 Mon Sep 17 00:00:00 2001 From: yuangli Date: Thu, 28 Jul 2022 16:05:21 +0100 Subject: [PATCH 054/608] rename function assign_parents_from_graft --- src/libgit2/commit.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/libgit2/commit.c b/src/libgit2/commit.c index 6f689e36216..43d04b2c028 100644 --- a/src/libgit2/commit.c +++ b/src/libgit2/commit.c @@ -499,7 +499,7 @@ int git_commit__parse_raw(void *commit, const char *data, size_t size) return commit_parse(commit, data, size, 0); } -static int assign_parents_from_graft(git_commit *commit, git_commit_graft *graft) { +static int assign_commit_parents_from_graft(git_commit *commit, git_commit_graft *graft) { size_t idx; git_oid *oid; @@ -533,7 +533,7 @@ int git_commit__parse_ext(git_commit *commit, git_odb_object *odb_obj, unsigned git_grafts_get(&graft, repo->shallow_grafts, git_odb_object_id(odb_obj)) != 0) return 0; - return assign_parents_from_graft(commit, graft); + return assign_commit_parents_from_graft(commit, graft); } int git_commit__parse(void *_commit, git_odb_object *odb_obj) From 73d25f0e7b026d7b744e249d922f248376bcce5d Mon Sep 17 00:00:00 2001 From: yuangli Date: Fri, 29 Jul 2022 13:53:29 +0100 Subject: [PATCH 055/608] remove build errors --- include/git2/remote.h | 12 ++-- include/git2/repository.h | 1 + src/libgit2/clone.c | 2 +- src/libgit2/commit.c | 2 +- src/libgit2/fetch.c | 7 +- src/libgit2/repository.c | 109 +---------------------------- src/libgit2/transports/smart_pkt.c | 16 ++--- 7 files changed, 21 insertions(+), 128 deletions(-) diff --git a/include/git2/remote.h b/include/git2/remote.h index 871d898e582..33f5103ceaf 100644 --- a/include/git2/remote.h +++ b/include/git2/remote.h @@ -743,6 +743,11 @@ typedef struct { */ git_proxy_options proxy_opts; + /** + * Depth of the fetch to perform + */ + int depth; + /** * Whether to allow off-site redirects. If this is not * specified, the `http.followRedirects` configuration setting @@ -754,16 +759,11 @@ typedef struct { * Extra headers for this fetch operation */ git_strarray custom_headers; - - /** - * Depth of the fetch to perform - */ - int depth; } git_fetch_options; #define GIT_FETCH_OPTIONS_VERSION 1 #define GIT_FETCH_OPTIONS_INIT { GIT_FETCH_OPTIONS_VERSION, GIT_REMOTE_CALLBACKS_INIT, GIT_FETCH_PRUNE_UNSPECIFIED, 1, \ - GIT_REMOTE_DOWNLOAD_TAGS_UNSPECIFIED, GIT_PROXY_OPTIONS_INIT, { NULL }, -1 } + GIT_REMOTE_DOWNLOAD_TAGS_UNSPECIFIED, GIT_PROXY_OPTIONS_INIT, -1 } /** * Initialize git_fetch_options structure diff --git a/include/git2/repository.h b/include/git2/repository.h index 24a94118be9..d6b054dc30f 100644 --- a/include/git2/repository.h +++ b/include/git2/repository.h @@ -11,6 +11,7 @@ #include "types.h" #include "oid.h" #include "buffer.h" +#include "oidarray.h" /** * @file git2/repository.h diff --git a/src/libgit2/clone.c b/src/libgit2/clone.c index 101c741b1f7..ee1f2b892d0 100644 --- a/src/libgit2/clone.c +++ b/src/libgit2/clone.c @@ -411,7 +411,7 @@ static int clone_into(git_repository *repo, git_remote *_remote, const git_fetch fetch_opts.update_fetchhead = 0; if (fetch_opts.depth == -1) fetch_opts.download_tags = GIT_REMOTE_DOWNLOAD_TAGS_ALL; - git_buf_printf(&reflog_message, "clone: from %s", git_remote_url(remote)); + git_str_printf(&reflog_message, "clone: from %s", git_remote_url(remote)); if ((error = git_remote_fetch(remote, NULL, &fetch_opts, git_str_cstr(&reflog_message))) != 0) goto cleanup; diff --git a/src/libgit2/commit.c b/src/libgit2/commit.c index 75cc8837c73..528d8beb79d 100644 --- a/src/libgit2/commit.c +++ b/src/libgit2/commit.c @@ -422,7 +422,7 @@ static int commit_parse(git_commit *commit, const char *data, size_t size, unsig buffer += tree_len; } - while (git_oid__parse(&parent_id, &buffer, buffer_end, "parent ") == 0) { + while (git_object__parse_oid_header(&parent_id, &buffer, buffer_end, "parent ", GIT_OID_SHA1) == 0) { git_oid *new_id = git_array_alloc(commit->parent_ids); GIT_ERROR_CHECK_ALLOC(new_id); diff --git a/src/libgit2/fetch.c b/src/libgit2/fetch.c index 10155662dd4..e4a8f038263 100644 --- a/src/libgit2/fetch.c +++ b/src/libgit2/fetch.c @@ -209,12 +209,7 @@ int git_fetch_download_pack(git_remote *remote) if (!remote->need_pack) return 0; - if (callbacks) { - progress = callbacks->transfer_progress; - payload = callbacks->payload; - } - - if ((error = t->download_pack(t, remote->repo, &remote->stats, progress, payload)) < 0) + if ((error = t->download_pack(t, remote->repo, &remote->stats)) < 0) return error; if ((error = git_repository__shallow_roots_write(remote->repo, remote->nego.shallow_roots->array)) < 0) diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index adb4721ad82..d9bc537febc 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -3340,109 +3340,6 @@ int git_repository_state_cleanup(git_repository *repo) return git_repository__cleanup_files(repo, state_files, ARRAY_SIZE(state_files)); } -// int git_repository__shallow_roots(git_array_oid_t *out, git_repository *repo) -// { -// git_buf path = GIT_BUF_INIT; -// git_buf contents = GIT_BUF_INIT; -// int error, updated, line_num = 1; -// char *line; -// chror = git_futils_readbuffer_updated(&contents, git_buf_cstr(&path), &repo->shallow_grafts->git_grafts->path_checksum, &updated); -// git_buf_dispose(&path); - -// if (error < 0 && error != GIT_ENOTFOUND) -// return error; - -// /* cancel out GIT_ENOTFOUND */ -// git_error_clear(); -// error = 0; - -// if (!updated) { -// out = repo->shallow_grafts; -// goto cleanup; -// } - -// git_array_clear(repo->shallow_grafts); - -// buffer = contents.ptr; -// while ((line = git__strsep(&buffer, "\n")) != NULL) { -// git_oid *oid = git_array_alloc(repo->shallow_grafts); - -// error = git_oid_fromstr(oid, line); -// if (error < 0) { -// git_error_set(GIT_ERROR_REPOSITORY, "Invalid OID at line %d", line_num); -// git_array_clear(repo->shallow_grafts); -// error = -1; -// goto cleanup; -// } -// ++line_num; -// } - -// if (*buffer) { -// git_error_set(GIT_ERROR_REPOSITORY, "No EOL at line %d", line_num); -// git_array_clear(repo->shallow_grafts); -// error = -1; -// goto cleanup; -// } - -// *out = repo->shallow_grafts; - -// cleanup: -// git_buf_dispose(&contents); - -// return error;ar *buffer; - -// assert(out && repo); - -// if ((error = git_buf_joinpath(&path, repo->gitdir, "shallow")) < 0) -// return error; - -// //error = git_futils_readbuffer_updated(&contents, git_buf_cstr(&path), &repo->shallow_checksum, &updated); -// error = git_futils_readbuffer_updated(&contents, git_buf_cstr(&path), &repo->shallow_grafts->git_grafts->path_checksum, &updated); -// git_buf_dispose(&path); - -// if (error < 0 && error != GIT_ENOTFOUND) -// return error; - -// /* cancel out GIT_ENOTFOUND */ -// git_error_clear(); -// error = 0; - -// if (!updated) { -// out = repo->shallow_grafts; -// goto cleanup; -// } - -// git_array_clear(repo->shallow_grafts); - -// buffer = contents.ptr; -// while ((line = git__strsep(&buffer, "\n")) != NULL) { -// git_oid *oid = git_array_alloc(repo->shallow_grafts); - -// error = git_oid_fromstr(oid, line); -// if (error < 0) { -// git_error_set(GIT_ERROR_REPOSITORY, "Invalid OID at line %d", line_num); -// git_array_clear(repo->shallow_grafts); -// error = -1; -// goto cleanup; -// } -// ++line_num; -// } - -// if (*buffer) { -// git_error_set(GIT_ERROR_REPOSITORY, "No EOL at line %d", line_num); -// git_array_clear(repo->shallow_grafts); -// error = -1; -// goto cleanup; -// } - -// *out = repo->shallow_grafts; - -// cleanup: -// git_buf_dispose(&contents); - -// return error; -// } - int git_repository__shallow_roots(git_array_oid_t *out, git_repository *repo) { int error =0; if (!repo->shallow_grafts) @@ -3455,17 +3352,17 @@ int git_repository__shallow_roots(git_array_oid_t *out, git_repository *repo) { int git_repository__shallow_roots_write(git_repository *repo, git_array_oid_t roots) { git_filebuf file = GIT_FILEBUF_INIT; - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; int error = 0; size_t idx; git_oid *oid; assert(repo); - if ((error = git_buf_joinpath(&path, repo->gitdir, "shallow")) < 0) + if ((error = git_str_joinpath(&path, repo->gitdir, "shallow")) < 0) return error; - if ((error = git_filebuf_open(&file, git_buf_cstr(&path), GIT_FILEBUF_HASH_CONTENTS, 0666)) < 0) + if ((error = git_filebuf_open(&file, git_str_cstr(&path), GIT_FILEBUF_HASH_CONTENTS, 0666)) < 0) return error; git_array_foreach(roots, idx, oid) { diff --git a/src/libgit2/transports/smart_pkt.c b/src/libgit2/transports/smart_pkt.c index e368cb7e235..f9fde00f1c8 100644 --- a/src/libgit2/transports/smart_pkt.c +++ b/src/libgit2/transports/smart_pkt.c @@ -678,23 +678,23 @@ int git_pkt_buffer_wants( git_buf shallow_buf = GIT_BUF_INIT; git_oid_fmt(oid, git_shallowarray_get(wants->shallow_roots, i)); - git_buf_puts(&shallow_buf, "shallow "); - git_buf_put(&shallow_buf, oid, GIT_OID_HEXSZ); - git_buf_putc(&shallow_buf, '\n'); + git_str_puts(&shallow_buf, "shallow "); + git_str_put(&shallow_buf, oid, GIT_OID_HEXSZ); + git_str_putc(&shallow_buf, '\n'); - git_buf_printf(buf, "%04x%s", (unsigned int)git_buf_len(&shallow_buf) + 4, git_buf_cstr(&shallow_buf)); + git_str_printf(buf, "%04x%s", (unsigned int)git_str_len(&shallow_buf) + 4, git_str_cstr(&shallow_buf)); - if (git_buf_oom(buf)) + if (git_str_oom(buf)) return -1; } if (wants->depth > 0) { git_buf deepen_buf = GIT_BUF_INIT; - git_buf_printf(&deepen_buf, "deepen %d\n", wants->depth); - git_buf_printf(buf,"%04x%s", (unsigned int)git_buf_len(&deepen_buf) + 4, git_buf_cstr(&deepen_buf)); + git_str_printf(&deepen_buf, "deepen %d\n", wants->depth); + git_str_printf(buf,"%04x%s", (unsigned int)git_str_len(&deepen_buf) + 4, git_str_cstr(&deepen_buf)); - if (git_buf_oom(buf)) + if (git_str_oom(buf)) return -1; } From 598ec303c6862f581c22c49228d543442e30257a Mon Sep 17 00:00:00 2001 From: yuangli Date: Fri, 29 Jul 2022 15:04:17 +0100 Subject: [PATCH 056/608] eliminate build warnings --- src/libgit2/fetch.c | 2 -- src/libgit2/grafts.c | 7 ++----- src/libgit2/grafts.h | 2 +- src/libgit2/repository.c | 18 +++++++++++++----- src/libgit2/transports/smart_pkt.c | 4 ++-- tests/{ => libgit2}/clone/shallow.c | 18 +++++++++--------- 6 files changed, 27 insertions(+), 24 deletions(-) rename tests/{ => libgit2}/clone/shallow.c (87%) diff --git a/src/libgit2/fetch.c b/src/libgit2/fetch.c index e4a8f038263..b90ce2ee857 100644 --- a/src/libgit2/fetch.c +++ b/src/libgit2/fetch.c @@ -202,8 +202,6 @@ int git_fetch_negotiate(git_remote *remote, const git_fetch_options *opts) int git_fetch_download_pack(git_remote *remote) { git_transport *t = remote->transport; - git_indexer_progress_cb progress = NULL; - void *payload = NULL; int error; if (!remote->need_pack) diff --git a/src/libgit2/grafts.c b/src/libgit2/grafts.c index 82be2a68069..f1054fa36ea 100644 --- a/src/libgit2/grafts.c +++ b/src/libgit2/grafts.c @@ -220,9 +220,8 @@ int git_grafts_get(git_commit_graft **out, git_grafts *grafts, const git_oid *oi return 0; } -int git_grafts_get_oids(git_oidarray *out, git_grafts *grafts) +int git_grafts_get_oids(git_array_oid_t *out, git_grafts *grafts) { - git_array_oid_t oids = GIT_ARRAY_INIT; const git_oid *oid; size_t i = 0; int error; @@ -230,13 +229,11 @@ int git_grafts_get_oids(git_oidarray *out, git_grafts *grafts) assert(out && grafts); while ((error = git_oidmap_iterate(NULL, grafts->commits, &i, &oid)) == 0) { - git_oid *cpy = git_array_alloc(oids); + git_oid *cpy = git_array_alloc(*out); GIT_ERROR_CHECK_ALLOC(cpy); git_oid_cpy(cpy, oid); } - git_oidarray__from_array(out, &oids); - return 0; } diff --git a/src/libgit2/grafts.h b/src/libgit2/grafts.h index fd9ef673698..4139438bba7 100644 --- a/src/libgit2/grafts.h +++ b/src/libgit2/grafts.h @@ -31,7 +31,7 @@ int git_grafts_parse(git_grafts *grafts, const char *content, size_t contentlen) int git_grafts_add(git_grafts *grafts, const git_oid *oid, git_array_oid_t parents); int git_grafts_remove(git_grafts *grafts, const git_oid *oid); int git_grafts_get(git_commit_graft **out, git_grafts *grafts, const git_oid *oid); -int git_grafts_get_oids(git_oidarray *out, git_grafts *grafts); +int git_grafts_get_oids(git_array_oid_t *out, git_grafts *grafts); size_t git_grafts_size(git_grafts *grafts); #endif diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index d9bc537febc..bc2aba32413 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -3341,12 +3341,20 @@ int git_repository_state_cleanup(git_repository *repo) } int git_repository__shallow_roots(git_array_oid_t *out, git_repository *repo) { - int error =0; - if (!repo->shallow_grafts) - load_grafts(repo); + int error = 0; + + if (!repo->shallow_grafts && (error = load_grafts(repo)) < 0) + return error; + + if ((error = git_grafts_refresh(repo->shallow_grafts)) < 0) { + return error; + } - git_grafts_refresh(repo->shallow_grafts); - return git_grafts_get_oids(out, repo->shallow_grafts); + if ((error = git_grafts_get_oids(out, repo->shallow_grafts)) < 0) { + return error; + } + + return 0; } int git_repository__shallow_roots_write(git_repository *repo, git_array_oid_t roots) diff --git a/src/libgit2/transports/smart_pkt.c b/src/libgit2/transports/smart_pkt.c index f9fde00f1c8..951356c29b6 100644 --- a/src/libgit2/transports/smart_pkt.c +++ b/src/libgit2/transports/smart_pkt.c @@ -675,7 +675,7 @@ int git_pkt_buffer_wants( /* Tell the server about our shallow objects */ for (i = 0; i < git_shallowarray_count(wants->shallow_roots); i++) { char oid[GIT_OID_HEXSZ]; - git_buf shallow_buf = GIT_BUF_INIT; + git_str shallow_buf = GIT_STR_INIT; git_oid_fmt(oid, git_shallowarray_get(wants->shallow_roots, i)); git_str_puts(&shallow_buf, "shallow "); @@ -689,7 +689,7 @@ int git_pkt_buffer_wants( } if (wants->depth > 0) { - git_buf deepen_buf = GIT_BUF_INIT; + git_str deepen_buf = GIT_STR_INIT; git_str_printf(&deepen_buf, "deepen %d\n", wants->depth); git_str_printf(buf,"%04x%s", (unsigned int)git_str_len(&deepen_buf) + 4, git_str_cstr(&deepen_buf)); diff --git a/tests/clone/shallow.c b/tests/libgit2/clone/shallow.c similarity index 87% rename from tests/clone/shallow.c rename to tests/libgit2/clone/shallow.c index 01852dfeddf..2cd3d6caca9 100644 --- a/tests/clone/shallow.c +++ b/tests/libgit2/clone/shallow.c @@ -24,21 +24,21 @@ static int remote_single_branch(git_remote **out, git_repository *repo, const ch void test_clone_shallow__clone_depth_one(void) { - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; git_repository *repo; git_revwalk *walk; git_clone_options clone_opts = GIT_CLONE_OPTIONS_INIT; git_oid oid; - git_oidarray roots; + roots; size_t num_commits = 0; int error = 0; clone_opts.fetch_opts.depth = 1; clone_opts.remote_cb = remote_single_branch; - git_buf_joinpath(&path, clar_sandbox_path(), "shallowclone_1"); + git_str_joinpath(&path, clar_sandbox_path(), "shallowclone_1"); - cl_git_pass(git_clone(&repo, "https://github.com/libgit2/TestGitRepository", git_buf_cstr(&path), &clone_opts)); + cl_git_pass(git_clone(&repo, "https://github.com/libgit2/TestGitRepository", git_str_cstr(&path), &clone_opts)); cl_assert_equal_b(true, git_repository_is_shallow(repo)); @@ -57,14 +57,14 @@ void test_clone_shallow__clone_depth_one(void) cl_assert_equal_i(num_commits, 1); cl_assert_equal_i(error, GIT_ITEROVER); - git_buf_dispose(&path); + git_str_dispose(&path); git_revwalk_free(walk); git_repository_free(repo); } void test_clone_shallow__clone_depth_five(void) { - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; git_repository *repo; git_revwalk *walk; git_clone_options clone_opts = GIT_CLONE_OPTIONS_INIT; @@ -76,9 +76,9 @@ void test_clone_shallow__clone_depth_five(void) clone_opts.fetch_opts.depth = 5; clone_opts.remote_cb = remote_single_branch; - git_buf_joinpath(&path, clar_sandbox_path(), "shallowclone_5"); + git_str_joinpath(&path, clar_sandbox_path(), "shallowclone_5"); - cl_git_pass(git_clone(&repo, "https://github.com/libgit2/TestGitRepository", git_buf_cstr(&path), &clone_opts)); + cl_git_pass(git_clone(&repo, "https://github.com/libgit2/TestGitRepository", git_str_cstr(&path), &clone_opts)); cl_assert_equal_b(true, git_repository_is_shallow(repo)); @@ -99,7 +99,7 @@ void test_clone_shallow__clone_depth_five(void) cl_assert_equal_i(num_commits, 13); cl_assert_equal_i(error, GIT_ITEROVER); - git_buf_dispose(&path); + git_str_dispose(&path); git_revwalk_free(walk); git_repository_free(repo); } From 179aac788d45d3683a93ad478bfb7371c549ca98 Mon Sep 17 00:00:00 2001 From: yuangli Date: Fri, 29 Jul 2022 16:04:43 +0100 Subject: [PATCH 057/608] fix clone::shallow test behaviour --- src/libgit2/transports/smart_protocol.c | 2 -- tests/libgit2/clone/shallow.c | 2 +- 2 files changed, 1 insertion(+), 3 deletions(-) diff --git a/src/libgit2/transports/smart_protocol.c b/src/libgit2/transports/smart_protocol.c index cd90db43f75..f2a6ac50892 100644 --- a/src/libgit2/transports/smart_protocol.c +++ b/src/libgit2/transports/smart_protocol.c @@ -375,10 +375,8 @@ int git_smart__negotiate_fetch(git_transport *transport, git_repository *repo, c while ((error = recv_pkt((git_pkt **)&pkt, NULL, buf)) == 0) { if (pkt->type == GIT_PKT_SHALLOW) { - printf("shallow %s\n", git_oid_tostr_s(&pkt->oid)); git_shallowarray_add(wants->shallow_roots, &pkt->oid); } else if (pkt->type == GIT_PKT_UNSHALLOW) { - printf("unshallow %s\n", git_oid_tostr_s(&pkt->oid)); git_shallowarray_remove(wants->shallow_roots, &pkt->oid); } else if (pkt->type == GIT_PKT_FLUSH) { /* Server is done, stop processing shallow oids */ diff --git a/tests/libgit2/clone/shallow.c b/tests/libgit2/clone/shallow.c index 2cd3d6caca9..4b27b27a959 100644 --- a/tests/libgit2/clone/shallow.c +++ b/tests/libgit2/clone/shallow.c @@ -29,7 +29,7 @@ void test_clone_shallow__clone_depth_one(void) git_revwalk *walk; git_clone_options clone_opts = GIT_CLONE_OPTIONS_INIT; git_oid oid; - roots; + git_oidarray roots; size_t num_commits = 0; int error = 0; From e7294e870398d72b79a436b628170ffcaaa1713c Mon Sep 17 00:00:00 2001 From: yuangli Date: Mon, 1 Aug 2022 21:42:11 +0100 Subject: [PATCH 058/608] fix memory leaks about packets --- src/libgit2/transports/smart_pkt.c | 2 ++ src/libgit2/transports/smart_protocol.c | 4 ++++ 2 files changed, 6 insertions(+) diff --git a/src/libgit2/transports/smart_pkt.c b/src/libgit2/transports/smart_pkt.c index 951356c29b6..5808b8816a9 100644 --- a/src/libgit2/transports/smart_pkt.c +++ b/src/libgit2/transports/smart_pkt.c @@ -694,6 +694,8 @@ int git_pkt_buffer_wants( git_str_printf(&deepen_buf, "deepen %d\n", wants->depth); git_str_printf(buf,"%04x%s", (unsigned int)git_str_len(&deepen_buf) + 4, git_str_cstr(&deepen_buf)); + git_str_dispose(&deepen_buf); + if (git_str_oom(buf)) return -1; } diff --git a/src/libgit2/transports/smart_protocol.c b/src/libgit2/transports/smart_protocol.c index f2a6ac50892..a44d0c85369 100644 --- a/src/libgit2/transports/smart_protocol.c +++ b/src/libgit2/transports/smart_protocol.c @@ -385,8 +385,12 @@ int git_smart__negotiate_fetch(git_transport *transport, git_repository *repo, c git_error_set(GIT_ERROR_NET, "Unexpected pkt type"); goto on_error; } + + git_pkt_free((git_pkt *) pkt); } + git_pkt_free((git_pkt *) pkt); + if (error < 0) { goto on_error; } From 2d33fe78858354c508afb77d80f32a5a747b801e Mon Sep 17 00:00:00 2001 From: yuangli Date: Tue, 2 Aug 2022 13:15:22 +0100 Subject: [PATCH 059/608] refactor git_fetch_option.depth and usage --- include/git2/remote.h | 4 +++- src/libgit2/clone.c | 9 ++++++++- 2 files changed, 11 insertions(+), 2 deletions(-) diff --git a/include/git2/remote.h b/include/git2/remote.h index 33f5103ceaf..f3415d843ec 100644 --- a/include/git2/remote.h +++ b/include/git2/remote.h @@ -744,7 +744,9 @@ typedef struct { git_proxy_options proxy_opts; /** - * Depth of the fetch to perform + * Depth of the fetch to perform, has to be a positive integer. + * + * The default is -1, which will fetch the full history. */ int depth; diff --git a/src/libgit2/clone.c b/src/libgit2/clone.c index ee1f2b892d0..95bddeae6a6 100644 --- a/src/libgit2/clone.c +++ b/src/libgit2/clone.c @@ -389,6 +389,11 @@ static int checkout_branch(git_repository *repo, git_remote *remote, const git_c return error; } +static int git_fetch_is_shallow(git_fetch_options *opts) +{ + return opts->depth > 0; +} + static int clone_into(git_repository *repo, git_remote *_remote, const git_fetch_options *opts, const git_checkout_options *co_opts, const char *branch) { int error; @@ -409,8 +414,10 @@ static int clone_into(git_repository *repo, git_remote *_remote, const git_fetch memcpy(&fetch_opts, opts, sizeof(git_fetch_options)); fetch_opts.update_fetchhead = 0; - if (fetch_opts.depth == -1) + + if (!git_fetch_is_shallow(opts)) fetch_opts.download_tags = GIT_REMOTE_DOWNLOAD_TAGS_ALL; + git_str_printf(&reflog_message, "clone: from %s", git_remote_url(remote)); if ((error = git_remote_fetch(remote, NULL, &fetch_opts, git_str_cstr(&reflog_message))) != 0) From 4536477ee1f884501717b3a4a67da3bc4974e7f8 Mon Sep 17 00:00:00 2001 From: yuangli Date: Tue, 2 Aug 2022 14:35:08 +0100 Subject: [PATCH 060/608] fix memory leak --- src/libgit2/repository.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index bc2aba32413..105ea647fa7 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -3380,6 +3380,8 @@ int git_repository__shallow_roots_write(git_repository *repo, git_array_oid_t ro git_filebuf_commit(&file); + git_str_dispose(&path); + if (load_grafts(repo) < 0) return -1; From e93d0815a8de2806667851e31dbd06578db00f95 Mon Sep 17 00:00:00 2001 From: yuangli Date: Tue, 2 Aug 2022 14:35:27 +0100 Subject: [PATCH 061/608] attempt to fix nego.shallowarray memory leak --- src/libgit2/remote.c | 3 +++ src/libgit2/transports/smart.c | 6 ++++++ src/libgit2/transports/smart.h | 2 ++ 3 files changed, 11 insertions(+) diff --git a/src/libgit2/remote.c b/src/libgit2/remote.c index 02d271d7d9d..c3d3af530a5 100644 --- a/src/libgit2/remote.c +++ b/src/libgit2/remote.c @@ -22,6 +22,7 @@ #include "git2/types.h" #include "git2/oid.h" #include "git2/net.h" +#include "transports/smart.h" #define CONFIG_URL_FMT "remote.%s.url" #define CONFIG_PUSHURL_FMT "remote.%s.pushurl" @@ -2163,6 +2164,8 @@ void git_remote_free(git_remote *remote) free_heads(&remote->local_heads); git_vector_free(&remote->local_heads); + git_shallowarray_free((remote->nego).shallow_roots); + git_push_free(remote->push); git__free(remote->url); git__free(remote->pushurl); diff --git a/src/libgit2/transports/smart.c b/src/libgit2/transports/smart.c index 9d1afeb05f5..df8e4da4ab9 100644 --- a/src/libgit2/transports/smart.c +++ b/src/libgit2/transports/smart.c @@ -510,3 +510,9 @@ int git_shallowarray_remove(git_shallowarray *array, git_oid *oid) /* no git_array_remove… meh */ return -1; } + +void git_shallowarray_free(git_shallowarray *array) +{ + git_array_clear(array->array); + git__free(array); +} diff --git a/src/libgit2/transports/smart.h b/src/libgit2/transports/smart.h index bc072d2feab..f9577cdee0b 100644 --- a/src/libgit2/transports/smart.h +++ b/src/libgit2/transports/smart.h @@ -203,4 +203,6 @@ struct git_shallowarray { git_array_oid_t array; }; +void git_shallowarray_free(git_shallowarray *array); + #endif From da04d3fc5e737b990e884129241f2ea3cba4cf6a Mon Sep 17 00:00:00 2001 From: yuangli Date: Tue, 2 Aug 2022 16:30:48 +0100 Subject: [PATCH 062/608] fix grafts and shallowarray memory leaks --- src/libgit2/grafts.c | 3 +++ src/libgit2/remote.c | 7 +++++-- src/libgit2/repository.c | 6 ++---- src/libgit2/transports/smart.c | 6 ------ src/libgit2/transports/smart.h | 2 -- 5 files changed, 10 insertions(+), 14 deletions(-) diff --git a/src/libgit2/grafts.c b/src/libgit2/grafts.c index f1054fa36ea..dd1be34342c 100644 --- a/src/libgit2/grafts.c +++ b/src/libgit2/grafts.c @@ -43,6 +43,9 @@ int git_grafts_from_file(git_grafts **out, const char *path) git_grafts *grafts = NULL; int error; + if (*out) + return git_grafts_refresh(*out); + if ((error = git_grafts_new(&grafts)) < 0) goto error; diff --git a/src/libgit2/remote.c b/src/libgit2/remote.c index c3d3af530a5..63346e9411c 100644 --- a/src/libgit2/remote.c +++ b/src/libgit2/remote.c @@ -2150,6 +2150,11 @@ void git_remote_free(git_remote *remote) remote->transport = NULL; } + if (remote->nego.shallow_roots) { + git_array_clear(remote->nego.shallow_roots->array); + git__free(remote->nego.shallow_roots); + } + git_vector_free(&remote->refs); free_refspecs(&remote->refspecs); @@ -2164,8 +2169,6 @@ void git_remote_free(git_remote *remote) free_heads(&remote->local_heads); git_vector_free(&remote->local_heads); - git_shallowarray_free((remote->nego).shallow_roots); - git_push_free(remote->push); git__free(remote->url); git__free(remote->pushurl); diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index 105ea647fa7..0d149a6264f 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -3346,13 +3346,11 @@ int git_repository__shallow_roots(git_array_oid_t *out, git_repository *repo) { if (!repo->shallow_grafts && (error = load_grafts(repo)) < 0) return error; - if ((error = git_grafts_refresh(repo->shallow_grafts)) < 0) { + if ((error = git_grafts_refresh(repo->shallow_grafts)) < 0) return error; - } - if ((error = git_grafts_get_oids(out, repo->shallow_grafts)) < 0) { + if ((error = git_grafts_get_oids(out, repo->shallow_grafts)) < 0) return error; - } return 0; } diff --git a/src/libgit2/transports/smart.c b/src/libgit2/transports/smart.c index df8e4da4ab9..9d1afeb05f5 100644 --- a/src/libgit2/transports/smart.c +++ b/src/libgit2/transports/smart.c @@ -510,9 +510,3 @@ int git_shallowarray_remove(git_shallowarray *array, git_oid *oid) /* no git_array_remove… meh */ return -1; } - -void git_shallowarray_free(git_shallowarray *array) -{ - git_array_clear(array->array); - git__free(array); -} diff --git a/src/libgit2/transports/smart.h b/src/libgit2/transports/smart.h index f9577cdee0b..bc072d2feab 100644 --- a/src/libgit2/transports/smart.h +++ b/src/libgit2/transports/smart.h @@ -203,6 +203,4 @@ struct git_shallowarray { git_array_oid_t array; }; -void git_shallowarray_free(git_shallowarray *array); - #endif From 8ef492fafcc05ccfa90481057eccc8ba4f5e730a Mon Sep 17 00:00:00 2001 From: yuangli Date: Tue, 2 Aug 2022 16:46:44 +0100 Subject: [PATCH 063/608] fix build warning --- src/libgit2/clone.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/libgit2/clone.c b/src/libgit2/clone.c index 95bddeae6a6..5e07dc73371 100644 --- a/src/libgit2/clone.c +++ b/src/libgit2/clone.c @@ -389,7 +389,7 @@ static int checkout_branch(git_repository *repo, git_remote *remote, const git_c return error; } -static int git_fetch_is_shallow(git_fetch_options *opts) +static int git_fetch_is_shallow(const git_fetch_options *opts) { return opts->depth > 0; } From 829555a9382f74af5280ab6cc2ac505534a4cecb Mon Sep 17 00:00:00 2001 From: yuangli Date: Tue, 2 Aug 2022 16:47:01 +0100 Subject: [PATCH 064/608] edit tests for shallow clones --- tests/libgit2/clone/shallow.c | 48 +++++++++++++++++++++++++++-------- 1 file changed, 38 insertions(+), 10 deletions(-) diff --git a/tests/libgit2/clone/shallow.c b/tests/libgit2/clone/shallow.c index 4b27b27a959..7fb056f9155 100644 --- a/tests/libgit2/clone/shallow.c +++ b/tests/libgit2/clone/shallow.c @@ -22,6 +22,32 @@ static int remote_single_branch(git_remote **out, git_repository *repo, const ch return 0; } +void test_clone_shallow__clone_depth_zero(void) +{ + git_str path = GIT_STR_INIT; + git_repository *repo; + git_clone_options clone_opts = GIT_CLONE_OPTIONS_INIT; + git_array_oid_t roots = GIT_ARRAY_INIT; + + clone_opts.fetch_opts.depth = 0; + clone_opts.remote_cb = remote_single_branch; + + git_str_joinpath(&path, clar_sandbox_path(), "shallowclone_0"); + + cl_git_pass(git_clone(&repo, "https://github.com/libgit2/TestGitRepository", git_str_cstr(&path), &clone_opts)); + + /* cloning with depth 0 results in a full clone. */ + cl_assert_equal_b(false, git_repository_is_shallow(repo)); + + /* full clones do not have shallow roots. */ + cl_git_pass(git_repository__shallow_roots(&roots, repo)); + cl_assert_equal_i(0, roots.size); + + git_array_clear(roots); + git_str_dispose(&path); + git_repository_free(repo); +} + void test_clone_shallow__clone_depth_one(void) { git_str path = GIT_STR_INIT; @@ -29,7 +55,7 @@ void test_clone_shallow__clone_depth_one(void) git_revwalk *walk; git_clone_options clone_opts = GIT_CLONE_OPTIONS_INIT; git_oid oid; - git_oidarray roots; + git_array_oid_t roots = GIT_ARRAY_INIT; size_t num_commits = 0; int error = 0; @@ -42,9 +68,9 @@ void test_clone_shallow__clone_depth_one(void) cl_assert_equal_b(true, git_repository_is_shallow(repo)); - cl_git_pass(git_repository_shallow_roots(&roots, repo)); - cl_assert_equal_i(1, roots.count); - cl_assert_equal_s("49322bb17d3acc9146f98c97d078513228bbf3c0", git_oid_tostr_s(&roots.ids[0])); + cl_git_pass(git_repository__shallow_roots(&roots, repo)); + cl_assert_equal_i(1, roots.size); + cl_assert_equal_s("49322bb17d3acc9146f98c97d078513228bbf3c0", git_oid_tostr_s(&roots.ptr[0])); git_revwalk_new(&walk, repo); @@ -57,6 +83,7 @@ void test_clone_shallow__clone_depth_one(void) cl_assert_equal_i(num_commits, 1); cl_assert_equal_i(error, GIT_ITEROVER); + git_array_clear(roots); git_str_dispose(&path); git_revwalk_free(walk); git_repository_free(repo); @@ -69,7 +96,7 @@ void test_clone_shallow__clone_depth_five(void) git_revwalk *walk; git_clone_options clone_opts = GIT_CLONE_OPTIONS_INIT; git_oid oid; - git_oidarray roots; + git_array_oid_t roots = GIT_ARRAY_INIT; size_t num_commits = 0; int error = 0; @@ -82,11 +109,11 @@ void test_clone_shallow__clone_depth_five(void) cl_assert_equal_b(true, git_repository_is_shallow(repo)); - cl_git_pass(git_repository_shallow_roots(&roots, repo)); - cl_assert_equal_i(3, roots.count); - cl_assert_equal_s("c070ad8c08840c8116da865b2d65593a6bb9cd2a", git_oid_tostr_s(&roots.ids[0])); - cl_assert_equal_s("0966a434eb1a025db6b71485ab63a3bfbea520b6", git_oid_tostr_s(&roots.ids[1])); - cl_assert_equal_s("83834a7afdaa1a1260568567f6ad90020389f664", git_oid_tostr_s(&roots.ids[2])); + cl_git_pass(git_repository__shallow_roots(&roots, repo)); + cl_assert_equal_i(3, roots.size); + cl_assert_equal_s("c070ad8c08840c8116da865b2d65593a6bb9cd2a", git_oid_tostr_s(&roots.ptr[0])); + cl_assert_equal_s("0966a434eb1a025db6b71485ab63a3bfbea520b6", git_oid_tostr_s(&roots.ptr[1])); + cl_assert_equal_s("83834a7afdaa1a1260568567f6ad90020389f664", git_oid_tostr_s(&roots.ptr[2])); git_revwalk_new(&walk, repo); @@ -99,6 +126,7 @@ void test_clone_shallow__clone_depth_five(void) cl_assert_equal_i(num_commits, 13); cl_assert_equal_i(error, GIT_ITEROVER); + git_array_clear(roots); git_str_dispose(&path); git_revwalk_free(walk); git_repository_free(repo); From bd986b18e36a93dca952b11616238e0eb5c1cb4b Mon Sep 17 00:00:00 2001 From: Victor Tran Date: Mon, 8 Aug 2022 21:51:44 +1000 Subject: [PATCH 065/608] Fix EMBED_SSH_PATH --- src/cli/CMakeLists.txt | 3 ++- src/libgit2/CMakeLists.txt | 12 ++---------- 2 files changed, 4 insertions(+), 11 deletions(-) diff --git a/src/cli/CMakeLists.txt b/src/cli/CMakeLists.txt index 46f4d63b504..ac1659c17fe 100644 --- a/src/cli/CMakeLists.txt +++ b/src/cli/CMakeLists.txt @@ -4,7 +4,8 @@ set(CLI_INCLUDES "${libgit2_BINARY_DIR}/include/git2" "${libgit2_SOURCE_DIR}/src/util" "${libgit2_SOURCE_DIR}/src/cli" - "${libgit2_SOURCE_DIR}/include") + "${libgit2_SOURCE_DIR}/include" + "${LIBGIT2_DEPENDENCY_INCLUDES}") if(WIN32 AND NOT CYGWIN) file(GLOB CLI_SRC_OS win32/*.c) diff --git a/src/libgit2/CMakeLists.txt b/src/libgit2/CMakeLists.txt index 3462b795e22..3d1fb90ea77 100644 --- a/src/libgit2/CMakeLists.txt +++ b/src/libgit2/CMakeLists.txt @@ -15,16 +15,6 @@ set(LIBGIT2_INCLUDES "${PROJECT_SOURCE_DIR}/src/util" "${PROJECT_SOURCE_DIR}/include") -if(WIN32 AND EMBED_SSH_PATH) - file(GLOB SRC_SSH "${EMBED_SSH_PATH}/src/*.c") - list(SORT SRC_SSH) - target_sources(libgit2 PRIVATE ${SRC_SSH}) - - list(APPEND LIBGIT2_SYSTEM_INCLUDES "${EMBED_SSH_PATH}/include") - file(WRITE "${EMBED_SSH_PATH}/src/libssh2_config.h" "#define HAVE_WINCNG\n#define LIBSSH2_WINCNG\n#include \"../win32/libssh2_config.h\"") - set(GIT_SSH 1) -endif() - # Collect sourcefiles file(GLOB SRC_H "${PROJECT_SOURCE_DIR}/include/git2.h" @@ -69,6 +59,7 @@ endif() ide_split_sources(libgit2) list(APPEND LIBGIT2_OBJECTS $ $ ${LIBGIT2_DEPENDENCY_OBJECTS}) +list(APPEND LIBGIT2_INCLUDES ${LIBGIT2_DEPENDENCY_INCLUDES}) target_include_directories(libgit2 PRIVATE ${LIBGIT2_INCLUDES} ${LIBGIT2_DEPENDENCY_INCLUDES} PUBLIC ${PROJECT_SOURCE_DIR}/include) target_include_directories(libgit2 SYSTEM PRIVATE ${LIBGIT2_SYSTEM_INCLUDES}) @@ -86,6 +77,7 @@ set(LIBGIT2_SYSTEM_LIBS ${LIBGIT2_SYSTEM_LIBS} PARENT_SCOPE) add_library(libgit2package ${SRC_RC} ${LIBGIT2_OBJECTS}) target_link_libraries(libgit2package ${LIBGIT2_SYSTEM_LIBS}) +target_include_directories(libgit2package SYSTEM PRIVATE ${LIBGIT2_INCLUDES}) set_target_properties(libgit2package PROPERTIES C_STANDARD 90) set_target_properties(libgit2package PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}) From e8ce8060f4552dccd4b561acc4e9783b526c7aed Mon Sep 17 00:00:00 2001 From: Kai Luo Date: Tue, 9 Aug 2022 10:12:49 +0800 Subject: [PATCH 066/608] On AIX, `off64_t` is equivalent to `long long`. See `/usr/include/sys/types.h` on AIX. --- src/util/posix.h | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/util/posix.h b/src/util/posix.h index c8f8cd9d2cc..607aa9dceb3 100644 --- a/src/util/posix.h +++ b/src/util/posix.h @@ -104,6 +104,8 @@ typedef __int64 off64_t; typedef __haiku_std_int64 off64_t; #elif defined(__APPLE__) typedef __int64_t off64_t; +#elif defined(_AIX) +typedef long long off64_t; #else typedef int64_t off64_t; #endif From 09b3d33d6dba7f4804b478a72dec3258405856c2 Mon Sep 17 00:00:00 2001 From: yuangli Date: Tue, 9 Aug 2022 19:23:54 +0100 Subject: [PATCH 067/608] fix memory leak --- src/libgit2/transports/smart_pkt.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/libgit2/transports/smart_pkt.c b/src/libgit2/transports/smart_pkt.c index 5808b8816a9..832da450c88 100644 --- a/src/libgit2/transports/smart_pkt.c +++ b/src/libgit2/transports/smart_pkt.c @@ -684,6 +684,8 @@ int git_pkt_buffer_wants( git_str_printf(buf, "%04x%s", (unsigned int)git_str_len(&shallow_buf) + 4, git_str_cstr(&shallow_buf)); + git_str_dispose(&shallow_buf); + if (git_str_oom(buf)) return -1; } From df5eb3239b1419b3f4382d7bcca9a5d85611d7d3 Mon Sep 17 00:00:00 2001 From: yuangli Date: Tue, 9 Aug 2022 19:24:57 +0100 Subject: [PATCH 068/608] support fetch unshallow option on shallow repos --- include/git2/remote.h | 9 +++- src/libgit2/clone.c | 7 +-- src/libgit2/fetch.c | 9 +++- src/libgit2/repository.c | 19 ++++--- src/libgit2/transports/smart.c | 26 ++++++++-- tests/libgit2/clone/shallow.c | 41 +++++++++++++++ tests/libgit2/transports/smart/shallowarray.c | 52 +++++++++++++++++++ 7 files changed, 144 insertions(+), 19 deletions(-) create mode 100644 tests/libgit2/transports/smart/shallowarray.c diff --git a/include/git2/remote.h b/include/git2/remote.h index f3415d843ec..240e5aa4edf 100644 --- a/include/git2/remote.h +++ b/include/git2/remote.h @@ -750,6 +750,13 @@ typedef struct { */ int depth; + /** + * Unshallow flag of the fetch to perform. + * + * The default is 0, which means the flag is off. + */ + int unshallow; + /** * Whether to allow off-site redirects. If this is not * specified, the `http.followRedirects` configuration setting @@ -765,7 +772,7 @@ typedef struct { #define GIT_FETCH_OPTIONS_VERSION 1 #define GIT_FETCH_OPTIONS_INIT { GIT_FETCH_OPTIONS_VERSION, GIT_REMOTE_CALLBACKS_INIT, GIT_FETCH_PRUNE_UNSPECIFIED, 1, \ - GIT_REMOTE_DOWNLOAD_TAGS_UNSPECIFIED, GIT_PROXY_OPTIONS_INIT, -1 } + GIT_REMOTE_DOWNLOAD_TAGS_UNSPECIFIED, GIT_PROXY_OPTIONS_INIT, -1, 0 } /** * Initialize git_fetch_options structure diff --git a/src/libgit2/clone.c b/src/libgit2/clone.c index 5e07dc73371..6f34cb7ca35 100644 --- a/src/libgit2/clone.c +++ b/src/libgit2/clone.c @@ -389,11 +389,6 @@ static int checkout_branch(git_repository *repo, git_remote *remote, const git_c return error; } -static int git_fetch_is_shallow(const git_fetch_options *opts) -{ - return opts->depth > 0; -} - static int clone_into(git_repository *repo, git_remote *_remote, const git_fetch_options *opts, const git_checkout_options *co_opts, const char *branch) { int error; @@ -415,7 +410,7 @@ static int clone_into(git_repository *repo, git_remote *_remote, const git_fetch memcpy(&fetch_opts, opts, sizeof(git_fetch_options)); fetch_opts.update_fetchhead = 0; - if (!git_fetch_is_shallow(opts)) + if (opts->depth <= 0) fetch_opts.download_tags = GIT_REMOTE_DOWNLOAD_TAGS_ALL; git_str_printf(&reflog_message, "clone: from %s", git_remote_url(remote)); diff --git a/src/libgit2/fetch.c b/src/libgit2/fetch.c index b90ce2ee857..a015cfbd330 100644 --- a/src/libgit2/fetch.c +++ b/src/libgit2/fetch.c @@ -61,7 +61,7 @@ static int mark_local(git_remote *remote) git_vector_foreach(&remote->refs, i, head) { /* If we have the object, mark it so we don't ask for it */ - if (git_odb_exists(odb, &head->oid)) + if (remote->nego.depth != INT_MAX && git_odb_exists(odb, &head->oid)) head->local = 1; else remote->need_pack = 1; @@ -173,6 +173,7 @@ int git_fetch_negotiate(git_remote *remote, const git_fetch_options *opts) git_transport *t = remote->transport; remote->need_pack = 0; + remote->nego.depth = opts->unshallow ? INT_MAX : opts->depth; if (filter_wants(remote, opts) < 0) return -1; @@ -181,13 +182,17 @@ int git_fetch_negotiate(git_remote *remote, const git_fetch_options *opts) if (!remote->need_pack) return 0; + if (opts->unshallow && opts->depth > 0) { + git_error_set(GIT_ERROR_INVALID, "options '--depth' and '--unshallow' cannot be used together"); + return -1; + } + /* * Now we have everything set up so we can start tell the * server what we want and what we have. */ remote->nego.refs = (const git_remote_head * const *)remote->refs.contents; remote->nego.count = remote->refs.length; - remote->nego.depth = opts->depth; remote->nego.shallow_roots = git__malloc(sizeof(git_shallowarray)); git_array_init(remote->nego.shallow_roots->array); diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index 0d149a6264f..13559ef07bb 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -3366,10 +3366,10 @@ int git_repository__shallow_roots_write(git_repository *repo, git_array_oid_t ro assert(repo); if ((error = git_str_joinpath(&path, repo->gitdir, "shallow")) < 0) - return error; + goto on_error; if ((error = git_filebuf_open(&file, git_str_cstr(&path), GIT_FILEBUF_HASH_CONTENTS, 0666)) < 0) - return error; + goto on_error; git_array_foreach(roots, idx, oid) { git_filebuf_write(&file, git_oid_tostr_s(oid), GIT_OID_HEXSZ); @@ -3378,12 +3378,19 @@ int git_repository__shallow_roots_write(git_repository *repo, git_array_oid_t ro git_filebuf_commit(&file); - git_str_dispose(&path); + if ((error = load_grafts(repo)) < 0) { + error = -1; + goto on_error; + } - if (load_grafts(repo) < 0) - return -1; + if (git_array_size(roots) == 0) { + remove(path.ptr); + } - return 0; +on_error: + git_str_dispose(&path); + + return error; } int git_repository_shallow_roots(git_oidarray *out, git_repository *repo) diff --git a/src/libgit2/transports/smart.c b/src/libgit2/transports/smart.c index 9d1afeb05f5..b0925c8bb57 100644 --- a/src/libgit2/transports/smart.c +++ b/src/libgit2/transports/smart.c @@ -496,17 +496,35 @@ const git_oid * git_shallowarray_get(git_shallowarray *array, size_t idx) int git_shallowarray_add(git_shallowarray *array, git_oid *oid) { size_t oid_index; + if (git_array_search(&oid_index, array->array, (git_array_compare_cb)git_oid_cmp, &oid) < 0) { git_oid *tmp = git_array_alloc(array->array); + GIT_ERROR_CHECK_ALLOC(tmp); + git_oid_cpy(tmp, oid); } + return 0; } int git_shallowarray_remove(git_shallowarray *array, git_oid *oid) { - GIT_UNUSED(array); - GIT_UNUSED(oid); - /* no git_array_remove… meh */ - return -1; + git_array_oid_t new_array = GIT_ARRAY_INIT; + git_oid *element; + git_oid *tmp; + size_t i; + + git_array_foreach(array->array, i, element) { + if (git_oid_cmp(oid, element)) { + tmp = git_array_alloc(new_array); + GIT_ERROR_CHECK_ALLOC(tmp); + + git_oid_cpy(tmp, element); + } + } + + git_array_clear(array->array); + array->array = new_array; + + return 0; } diff --git a/tests/libgit2/clone/shallow.c b/tests/libgit2/clone/shallow.c index 7fb056f9155..2a88d5d057c 100644 --- a/tests/libgit2/clone/shallow.c +++ b/tests/libgit2/clone/shallow.c @@ -131,3 +131,44 @@ void test_clone_shallow__clone_depth_five(void) git_revwalk_free(walk); git_repository_free(repo); } + +void test_clone_shallow__unshallow(void) +{ + git_str path = GIT_STR_INIT; + git_repository *repo; + git_revwalk *walk; + git_clone_options clone_opts = GIT_CLONE_OPTIONS_INIT; + git_fetch_options fetch_opts = GIT_FETCH_OPTIONS_INIT; + git_remote *origin = NULL; + git_oid oid; + size_t num_commits = 0; + int error = 0; + + clone_opts.fetch_opts.depth = 5; + clone_opts.remote_cb = remote_single_branch; + + git_str_joinpath(&path, clar_sandbox_path(), "unshallow"); + cl_git_pass(git_clone(&repo, "https://github.com/libgit2/TestGitRepository", git_str_cstr(&path), &clone_opts)); + cl_assert_equal_b(true, git_repository_is_shallow(repo)); + + fetch_opts.unshallow = 1; + cl_git_pass(git_remote_lookup(&origin, repo, "origin")); + + cl_git_pass(git_remote_fetch(origin, NULL, &fetch_opts, NULL)); + cl_assert_equal_b(false, git_repository_is_shallow(repo)); + + git_revwalk_new(&walk, repo); + git_revwalk_push_head(walk); + + while ((error = git_revwalk_next(&oid, walk)) == GIT_OK) { + num_commits++; + } + + cl_assert_equal_i(num_commits, 21); + cl_assert_equal_i(error, GIT_ITEROVER); + + git_remote_free(origin); + git_str_dispose(&path); + git_revwalk_free(walk); + git_repository_free(repo); +} diff --git a/tests/libgit2/transports/smart/shallowarray.c b/tests/libgit2/transports/smart/shallowarray.c new file mode 100644 index 00000000000..c51e62713d3 --- /dev/null +++ b/tests/libgit2/transports/smart/shallowarray.c @@ -0,0 +1,52 @@ +#include "clar_libgit2.h" + +#include "git2/oid.h" +#include "git2/transport.h" + +#include "common.h" +#include "transports/smart.h" +#include "oid.h" + +#include + +#define oid_0 "c070ad8c08840c8116da865b2d65593a6bb9cd2a" +#define oid_1 "0966a434eb1a025db6b71485ab63a3bfbea520b6" +#define oid_2 "83834a7afdaa1a1260568567f6ad90020389f664" + +void test_transports_smart_shallowarray__add_and_remove_oid_from_shallowarray(void) +{ + git_oid oid_0_obj, oid_1_obj, oid_2_obj; + git_shallowarray *shallow_roots = git__malloc(sizeof(git_shallowarray)); + git_array_init(shallow_roots->array); + + git_oid_fromstr(&oid_0_obj, oid_0); + git_oid_fromstr(&oid_1_obj, oid_1); + git_oid_fromstr(&oid_2_obj, oid_2); + + git_shallowarray_add(shallow_roots, &oid_0_obj); + git_shallowarray_add(shallow_roots, &oid_1_obj); + git_shallowarray_add(shallow_roots, &oid_2_obj); + + cl_assert_equal_i(3, shallow_roots->array.size); + cl_assert_equal_s("c070ad8c08840c8116da865b2d65593a6bb9cd2a", git_oid_tostr_s(&shallow_roots->array.ptr[0])); + cl_assert_equal_s("0966a434eb1a025db6b71485ab63a3bfbea520b6", git_oid_tostr_s(&shallow_roots->array.ptr[1])); + cl_assert_equal_s("83834a7afdaa1a1260568567f6ad90020389f664", git_oid_tostr_s(&shallow_roots->array.ptr[2])); + + git_shallowarray_remove(shallow_roots, &oid_2_obj); + + cl_assert_equal_i(2, shallow_roots->array.size); + cl_assert_equal_s("c070ad8c08840c8116da865b2d65593a6bb9cd2a", git_oid_tostr_s(&shallow_roots->array.ptr[0])); + cl_assert_equal_s("0966a434eb1a025db6b71485ab63a3bfbea520b6", git_oid_tostr_s(&shallow_roots->array.ptr[1])); + + git_shallowarray_remove(shallow_roots, &oid_1_obj); + + cl_assert_equal_i(1, shallow_roots->array.size); + cl_assert_equal_s("c070ad8c08840c8116da865b2d65593a6bb9cd2a", git_oid_tostr_s(&shallow_roots->array.ptr[0])); + + git_shallowarray_remove(shallow_roots, &oid_0_obj); + + cl_assert_equal_i(0, shallow_roots->array.size); + + git_array_clear(shallow_roots->array); + git__free(shallow_roots); +} From 49e641be8c5549f6f5731d6d72e9e6902e71d0e1 Mon Sep 17 00:00:00 2001 From: yuangli Date: Thu, 11 Aug 2022 09:32:28 +0100 Subject: [PATCH 069/608] remove unused api --- include/git2/remote.h | 2 +- include/git2/repository.h | 11 ----------- src/libgit2/repository.c | 14 -------------- 3 files changed, 1 insertion(+), 26 deletions(-) diff --git a/include/git2/remote.h b/include/git2/remote.h index 240e5aa4edf..f1cee17aa97 100644 --- a/include/git2/remote.h +++ b/include/git2/remote.h @@ -751,7 +751,7 @@ typedef struct { int depth; /** - * Unshallow flag of the fetch to perform. + * Convert a shallow repository to a full repository. * * The default is 0, which means the flag is off. */ diff --git a/include/git2/repository.h b/include/git2/repository.h index d6b054dc30f..258b9ac00a7 100644 --- a/include/git2/repository.h +++ b/include/git2/repository.h @@ -923,17 +923,6 @@ GIT_EXTERN(const char *) git_repository_get_namespace(git_repository *repo); */ GIT_EXTERN(int) git_repository_is_shallow(git_repository *repo); -/** - * Determine the shallow roots of the repository - * - * This oidarray is owned by the library. Do not free it. - * - * @param out An array of shallow oids. - * @param repo The repository - * @return 0 on success, an error otherwise. - */ -GIT_EXTERN(int) git_repository_shallow_roots(git_oidarray *out, git_repository *repo); - /** * Retrieve the configured identity to use for reflogs * diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index 13559ef07bb..6b77007aaf2 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -3393,20 +3393,6 @@ int git_repository__shallow_roots_write(git_repository *repo, git_array_oid_t ro return error; } -int git_repository_shallow_roots(git_oidarray *out, git_repository *repo) -{ - int ret; - git_array_oid_t array = GIT_ARRAY_INIT; - - assert(out); - - ret = git_repository__shallow_roots(&array, repo); - - git_oidarray__from_array(out, &array); - - return ret; -} - int git_repository_is_shallow(git_repository *repo) { git_str path = GIT_STR_INIT; From 8b521f018b734f58db2b9aec184e0f96422f140e Mon Sep 17 00:00:00 2001 From: yuangli Date: Thu, 11 Aug 2022 09:38:21 +0100 Subject: [PATCH 070/608] document unshallow behaviour in fetch.c --- src/libgit2/fetch.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/libgit2/fetch.c b/src/libgit2/fetch.c index a015cfbd330..3216b261c90 100644 --- a/src/libgit2/fetch.c +++ b/src/libgit2/fetch.c @@ -60,7 +60,9 @@ static int mark_local(git_remote *remote) return -1; git_vector_foreach(&remote->refs, i, head) { - /* If we have the object, mark it so we don't ask for it */ + /* If we have the object, mark it so we don't ask for it. + However if we are unshallowing, we need to ask for it + even though the head exists locally. */ if (remote->nego.depth != INT_MAX && git_odb_exists(odb, &head->oid)) head->local = 1; else From ca0103671f6720c06751b6770269487b9111f661 Mon Sep 17 00:00:00 2001 From: Sven Strickroth Date: Thu, 18 Aug 2022 14:05:42 +0200 Subject: [PATCH 071/608] Extend list of per worktree refs Signed-off-by: Sven Strickroth --- src/libgit2/refdb_fs.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/libgit2/refdb_fs.c b/src/libgit2/refdb_fs.c index 43283b3e472..586d2561ab3 100644 --- a/src/libgit2/refdb_fs.c +++ b/src/libgit2/refdb_fs.c @@ -403,7 +403,9 @@ static const char *loose_parse_symbolic(git_str *file_content) static bool is_per_worktree_ref(const char *ref_name) { return git__prefixcmp(ref_name, "refs/") != 0 || - git__prefixcmp(ref_name, "refs/bisect/") == 0; + git__prefixcmp(ref_name, "refs/bisect/") == 0 || + git__prefixcmp(ref_name, "refs/worktree/") == 0 || + git__prefixcmp(ref_name, "refs/rewritten/") == 0; } static int loose_lookup( From 4b289c190b6ba434541081d8ca2844c7a03b0384 Mon Sep 17 00:00:00 2001 From: Sven Strickroth Date: Thu, 18 Aug 2022 15:08:23 +0200 Subject: [PATCH 072/608] Make refdb_fs fully aware of per worktree refs Fixes issue isse #5492. Signed-off-by: Sven Strickroth --- src/libgit2/refdb_fs.c | 45 ++++++++++++++++++++++ tests/libgit2/worktree/refs.c | 70 ++++++++++++++++++++++++++++++++++- 2 files changed, 114 insertions(+), 1 deletion(-) diff --git a/src/libgit2/refdb_fs.c b/src/libgit2/refdb_fs.c index 586d2561ab3..4628e01dc99 100644 --- a/src/libgit2/refdb_fs.c +++ b/src/libgit2/refdb_fs.c @@ -853,6 +853,8 @@ static int iter_load_loose_paths(refdb_fs_backend *backend, refdb_fs_iter *iter) git_str_truncate(&path, ref_prefix_len); git_str_puts(&path, entry->path); ref_name = git_str_cstr(&path); + if (git_repository_is_worktree(backend->repo) == 1 && is_per_worktree_ref(ref_name)) + continue; if (git__suffixcmp(ref_name, ".lock") == 0 || (iter->glob && wildmatch(iter->glob, ref_name, 0) != 0)) @@ -865,6 +867,49 @@ static int iter_load_loose_paths(refdb_fs_backend *backend, refdb_fs_iter *iter) error = git_vector_insert(&iter->loose, ref_dup); } + if (!error && git_repository_is_worktree(backend->repo) == 1) { + git_iterator_free(fsit); + git_str_clear(&path); + if ((error = git_str_puts(&path, backend->gitpath)) < 0 || + (error = git_str_put(&path, ref_prefix, ref_prefix_len)) < 0 || + !git_fs_path_exists(git_str_cstr(&path))) { + git_str_dispose(&path); + return error; + } + + if ((error = git_iterator_for_filesystem( + &fsit, path.ptr, &fsit_opts)) < 0) { + git_str_dispose(&path); + return (iter->glob && error == GIT_ENOTFOUND) ? 0 : error; + } + + error = git_str_sets(&path, ref_prefix); + + while (!error && !git_iterator_advance(&entry, fsit)) { + const char *ref_name; + char *ref_dup; + + git_str_truncate(&path, ref_prefix_len); + git_str_puts(&path, entry->path); + ref_name = git_str_cstr(&path); + + if (!is_per_worktree_ref(ref_name)) + continue; + + if (git__suffixcmp(ref_name, ".lock") == 0 || + (iter->glob && + wildmatch(iter->glob, ref_name, 0) != 0)) + continue; + + ref_dup = git_pool_strdup(&iter->pool, ref_name); + if (!ref_dup) + error = -1; + else + error = git_vector_insert( + &iter->loose, ref_dup); + } + } + git_iterator_free(fsit); git_str_dispose(&path); diff --git a/tests/libgit2/worktree/refs.c b/tests/libgit2/worktree/refs.c index 557726aafb6..6bcf7aa9dac 100644 --- a/tests/libgit2/worktree/refs.c +++ b/tests/libgit2/worktree/refs.c @@ -20,7 +20,7 @@ void test_worktree_refs__cleanup(void) cleanup_fixture_worktree(&fixture); } -void test_worktree_refs__list(void) +void test_worktree_refs__list_no_difference_in_worktree(void) { git_strarray refs, wtrefs; unsigned i, j; @@ -61,6 +61,74 @@ void test_worktree_refs__list(void) cl_git_pass(error); } +void test_worktree_refs__list_worktree_specific(void) +{ + git_strarray refs, wtrefs; + git_reference *ref, *new_branch; + int error = 0; + git_oid oid; + + cl_git_pass(git_reference_name_to_id(&oid, fixture.repo, "refs/heads/dir")); + cl_git_fail(git_reference_lookup(&ref, fixture.repo, "refs/bisect/a-bisect-ref")); + cl_git_pass(git_reference_create( + &new_branch, fixture.worktree, "refs/bisect/a-bisect-ref", &oid, + 0, "test")); + + cl_git_fail(git_reference_lookup(&ref, fixture.repo, "refs/bisect/a-bisect-ref")); + cl_git_pass(git_reference_lookup(&ref, fixture.worktree, "refs/bisect/a-bisect-ref")); + + cl_git_pass(git_reference_list(&refs, fixture.repo)); + cl_git_pass(git_reference_list(&wtrefs, fixture.worktree)); + + if (refs.count + 1 != wtrefs.count) { + error = GIT_ERROR; + goto exit; + } + +exit: + git_reference_free(ref); + git_reference_free(new_branch); + git_strarray_dispose(&refs); + git_strarray_dispose(&wtrefs); + cl_git_pass(error); +} + +void test_worktree_refs__list_worktree_specific_hidden_in_main_repo(void) +{ + git_strarray refs, wtrefs; + git_reference *ref, *new_branch; + int error = 0; + git_oid oid; + + cl_git_pass( + git_reference_name_to_id(&oid, fixture.repo, "refs/heads/dir")); + cl_git_fail(git_reference_lookup( + &ref, fixture.worktree, "refs/bisect/a-bisect-ref")); + cl_git_pass(git_reference_create( + &new_branch, fixture.repo, "refs/bisect/a-bisect-ref", &oid, + 0, "test")); + + cl_git_fail(git_reference_lookup( + &ref, fixture.worktree, "refs/bisect/a-bisect-ref")); + cl_git_pass(git_reference_lookup( + &ref, fixture.repo, "refs/bisect/a-bisect-ref")); + + cl_git_pass(git_reference_list(&refs, fixture.repo)); + cl_git_pass(git_reference_list(&wtrefs, fixture.worktree)); + + if (refs.count != wtrefs.count + 1) { + error = GIT_ERROR; + goto exit; + } + +exit: + git_reference_free(ref); + git_reference_free(new_branch); + git_strarray_dispose(&refs); + git_strarray_dispose(&wtrefs); + cl_git_pass(error); +} + void test_worktree_refs__read_head(void) { git_reference *head; From 75b2787091d47f141385c21a1ff2de326da1abed Mon Sep 17 00:00:00 2001 From: Miguel Arroz <750683+arroz@users.noreply.github.com> Date: Tue, 30 Aug 2022 16:55:29 -0700 Subject: [PATCH 073/608] Changed implementation according to review. --- src/libgit2/refdb_fs.c | 30 +++++++++++------------------- 1 file changed, 11 insertions(+), 19 deletions(-) diff --git a/src/libgit2/refdb_fs.c b/src/libgit2/refdb_fs.c index 8a7051dead6..1058a7bd708 100644 --- a/src/libgit2/refdb_fs.c +++ b/src/libgit2/refdb_fs.c @@ -1769,49 +1769,41 @@ static int refdb_fs_backend__rename( (error = refdb_fs_backend__lookup(&old, _backend, old_name)) < 0) return error; - /* Try to rename the refog; it's ok if the old doesn't exist */ - /* Must be done before calling refdb_fs_backend__delete, otherwise */ - /* the reflog is deleted before being renamed. */ - error = refdb_reflog_fs__rename(_backend, old_name, new_name); - if ((error != 0) && (error != GIT_ENOTFOUND)) { - git_reference_free(old); - return error; - } - - if ((error = refdb_fs_backend__delete(_backend, old_name, NULL, NULL)) < 0) { - refdb_reflog_fs__rename(_backend, new_name, old_name); + if ((error = loose_lock(&file, backend, old->name)) < 0) { git_reference_free(old); return error; } new = git_reference__realloc(&old, new_name); if (!new) { - refdb_reflog_fs__rename(_backend, new_name, old_name); git_reference_free(old); + git_filebuf_cleanup(&file); return -1; } - if ((error = loose_lock(&file, backend, new->name)) < 0) { - refdb_reflog_fs__rename(_backend, new_name, old_name); + if ((error = refdb_fs_backend__delete_tail(_backend, &file, old_name, NULL, NULL)) < 0) { git_reference_free(new); + git_filebuf_cleanup(&file); return error; } - if ((error = reflog_append(backend, new, git_reference_target(new), NULL, who, message)) < 0) { - git_reference_free(new); - git_filebuf_cleanup(&file); + if ((error = loose_lock(&file, backend, new_name)) < 0) { + git_reference_free(old); return error; } - if (error < 0) { + /* Try to rename the refog; it's ok if the old doesn't exist */ + error = refdb_reflog_fs__rename(_backend, old_name, new_name); + if (((error == 0) || (error == GIT_ENOTFOUND)) && + ((error = reflog_append(backend, new, git_reference_target(new), NULL, who, message)) < 0)) { git_reference_free(new); git_filebuf_cleanup(&file); return error; } - if ((error = loose_commit(&file, new)) < 0 || out == NULL) { git_reference_free(new); + git_filebuf_cleanup(&file); return error; } From 3e8f4703ca4586d50623b3c6c6404ac69a875f6d Mon Sep 17 00:00:00 2001 From: Miguel Arroz <750683+arroz@users.noreply.github.com> Date: Tue, 30 Aug 2022 17:30:03 -0700 Subject: [PATCH 074/608] Free the correct reference if an error occurrs. It should be the `new` pointer, not the `old` one. --- src/libgit2/refdb_fs.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/libgit2/refdb_fs.c b/src/libgit2/refdb_fs.c index 1058a7bd708..87b5f875c19 100644 --- a/src/libgit2/refdb_fs.c +++ b/src/libgit2/refdb_fs.c @@ -1788,7 +1788,7 @@ static int refdb_fs_backend__rename( } if ((error = loose_lock(&file, backend, new_name)) < 0) { - git_reference_free(old); + git_reference_free(new); return error; } From a3bfd284c2d49ef148a7e12fbeb0134b5246b5e6 Mon Sep 17 00:00:00 2001 From: Yuang Li Date: Wed, 31 Aug 2022 11:09:49 +0100 Subject: [PATCH 075/608] Use GIT_OID_SHA1_HEXSIZE --- src/libgit2/grafts.c | 8 ++++---- src/libgit2/repository.c | 2 +- src/libgit2/transports/smart_pkt.c | 16 ++++++++-------- 3 files changed, 13 insertions(+), 13 deletions(-) diff --git a/src/libgit2/grafts.c b/src/libgit2/grafts.c index dd1be34342c..5b078b01db8 100644 --- a/src/libgit2/grafts.c +++ b/src/libgit2/grafts.c @@ -133,22 +133,22 @@ int git_grafts_parse(git_grafts *grafts, const char *content, size_t contentlen) const char *line_start = parser.line, *line_end = parser.line + parser.line_len; git_oid graft_oid; - if ((error = git_oid_fromstrn(&graft_oid, line_start, GIT_OID_HEXSZ)) < 0) { + if ((error = git_oid_fromstrn(&graft_oid, line_start, GIT_OID_SHA1_HEXSIZE)) < 0) { git_error_set(GIT_ERROR_GRAFTS, "invalid graft OID at line %" PRIuZ, parser.line_num); goto error; } - line_start += GIT_OID_HEXSZ; + line_start += GIT_OID_SHA1_HEXSIZE; while (line_start < line_end && *line_start == ' ') { git_oid *id = git_array_alloc(parents); GIT_ERROR_CHECK_ALLOC(id); - if ((error = git_oid_fromstrn(id, ++line_start, GIT_OID_HEXSZ)) < 0) { + if ((error = git_oid_fromstrn(id, ++line_start, GIT_OID_SHA1_HEXSIZE)) < 0) { git_error_set(GIT_ERROR_GRAFTS, "invalid parent OID at line %" PRIuZ, parser.line_num); goto error; } - line_start += GIT_OID_HEXSZ; + line_start += GIT_OID_SHA1_HEXSIZE; } if ((error = git_grafts_add(grafts, &graft_oid, parents)) < 0) diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index 6b77007aaf2..0eb16c22342 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -3372,7 +3372,7 @@ int git_repository__shallow_roots_write(git_repository *repo, git_array_oid_t ro goto on_error; git_array_foreach(roots, idx, oid) { - git_filebuf_write(&file, git_oid_tostr_s(oid), GIT_OID_HEXSZ); + git_filebuf_write(&file, git_oid_tostr_s(oid), GIT_OID_SHA1_HEXSIZE); git_filebuf_write(&file, "\n", 1); } diff --git a/src/libgit2/transports/smart_pkt.c b/src/libgit2/transports/smart_pkt.c index 832da450c88..cfdf362444b 100644 --- a/src/libgit2/transports/smart_pkt.c +++ b/src/libgit2/transports/smart_pkt.c @@ -377,10 +377,10 @@ static int shallow_pkt(git_pkt **out, const char *line, size_t len) line += 7; len -= 7; - if (len >= GIT_OID_HEXSZ) { + if (len >= GIT_OID_SHA1_HEXSIZE) { git_oid_fromstr(&pkt->oid, line + 1); - line += GIT_OID_HEXSZ + 1; - len -= GIT_OID_HEXSZ + 1; + line += GIT_OID_SHA1_HEXSIZE + 1; + len -= GIT_OID_SHA1_HEXSIZE + 1; } *out = (git_pkt *) pkt; @@ -399,10 +399,10 @@ static int unshallow_pkt(git_pkt **out, const char *line, size_t len) line += 9; len -= 9; - if (len >= GIT_OID_HEXSZ) { + if (len >= GIT_OID_SHA1_HEXSIZE) { git_oid_fromstr(&pkt->oid, line + 1); - line += GIT_OID_HEXSZ + 1; - len -= GIT_OID_HEXSZ + 1; + line += GIT_OID_SHA1_HEXSIZE + 1; + len -= GIT_OID_SHA1_HEXSIZE + 1; } *out = (git_pkt *) pkt; @@ -674,12 +674,12 @@ int git_pkt_buffer_wants( /* Tell the server about our shallow objects */ for (i = 0; i < git_shallowarray_count(wants->shallow_roots); i++) { - char oid[GIT_OID_HEXSZ]; + char oid[GIT_OID_SHA1_HEXSIZE]; git_str shallow_buf = GIT_STR_INIT; git_oid_fmt(oid, git_shallowarray_get(wants->shallow_roots, i)); git_str_puts(&shallow_buf, "shallow "); - git_str_put(&shallow_buf, oid, GIT_OID_HEXSZ); + git_str_put(&shallow_buf, oid, GIT_OID_SHA1_HEXSIZE); git_str_putc(&shallow_buf, '\n'); git_str_printf(buf, "%04x%s", (unsigned int)git_str_len(&shallow_buf) + 4, git_str_cstr(&shallow_buf)); From 01cb90be1578b2308f7c69be3b34dd44b0dbbe95 Mon Sep 17 00:00:00 2001 From: Yuang Li Date: Wed, 31 Aug 2022 14:32:09 +0100 Subject: [PATCH 076/608] restore GIT_RAND_GETENTROPY --- src/CMakeLists.txt | 5 ----- 1 file changed, 5 deletions(-) diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index b81ad272f44..14ffa6c4032 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -70,11 +70,6 @@ check_function_exists(qsort_s GIT_QSORT_S) # random / entropy data -# The flag has been unset to prevent issues -# related to Linux GLIBC version dependency - -# check_function_exists(getentropy GIT_RAND_GETENTROPY) -unset(GIT_RAND_GETENTROPY) check_function_exists(getloadavg GIT_RAND_GETLOADAVG) # determine architecture of the machine From b20f013c129a27a86b5207a2f6ad1d858113f46c Mon Sep 17 00:00:00 2001 From: Yuang Li Date: Wed, 31 Aug 2022 14:33:59 +0100 Subject: [PATCH 077/608] restore getentropy --- src/CMakeLists.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 14ffa6c4032..e108b2e79ce 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -70,6 +70,7 @@ check_function_exists(qsort_s GIT_QSORT_S) # random / entropy data +check_function_exists(getentropy GIT_RAND_GETENTROPY) check_function_exists(getloadavg GIT_RAND_GETLOADAVG) # determine architecture of the machine From f1f9b45dd20b408953eac2d515e8dfa0264aa631 Mon Sep 17 00:00:00 2001 From: Yuang Li Date: Wed, 31 Aug 2022 15:34:06 +0100 Subject: [PATCH 078/608] fix test failures --- src/libgit2/fetch.c | 6 ++++-- src/libgit2/grafts.c | 4 ++-- 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/src/libgit2/fetch.c b/src/libgit2/fetch.c index 3216b261c90..69794ed1f3e 100644 --- a/src/libgit2/fetch.c +++ b/src/libgit2/fetch.c @@ -21,6 +21,7 @@ #include "repository.h" #include "refs.h" #include "transports/smart.h" +#include static int maybe_want(git_remote *remote, git_remote_head *head, git_refspec *tagspec, git_remote_autotag_option_t tagopt) { @@ -175,7 +176,8 @@ int git_fetch_negotiate(git_remote *remote, const git_fetch_options *opts) git_transport *t = remote->transport; remote->need_pack = 0; - remote->nego.depth = opts->unshallow ? INT_MAX : opts->depth; + + remote->nego.depth = (opts && !opts->unshallow) ? opts->depth : INT_MAX; if (filter_wants(remote, opts) < 0) return -1; @@ -184,7 +186,7 @@ int git_fetch_negotiate(git_remote *remote, const git_fetch_options *opts) if (!remote->need_pack) return 0; - if (opts->unshallow && opts->depth > 0) { + if (opts && opts->unshallow && opts->depth > 0) { git_error_set(GIT_ERROR_INVALID, "options '--depth' and '--unshallow' cannot be used together"); return -1; } diff --git a/src/libgit2/grafts.c b/src/libgit2/grafts.c index 5b078b01db8..6662f500901 100644 --- a/src/libgit2/grafts.c +++ b/src/libgit2/grafts.c @@ -133,7 +133,7 @@ int git_grafts_parse(git_grafts *grafts, const char *content, size_t contentlen) const char *line_start = parser.line, *line_end = parser.line + parser.line_len; git_oid graft_oid; - if ((error = git_oid_fromstrn(&graft_oid, line_start, GIT_OID_SHA1_HEXSIZE)) < 0) { + if ((error = git_oid__fromstrn(&graft_oid, line_start, GIT_OID_SHA1_HEXSIZE, GIT_OID_SHA1)) < 0) { git_error_set(GIT_ERROR_GRAFTS, "invalid graft OID at line %" PRIuZ, parser.line_num); goto error; } @@ -143,7 +143,7 @@ int git_grafts_parse(git_grafts *grafts, const char *content, size_t contentlen) git_oid *id = git_array_alloc(parents); GIT_ERROR_CHECK_ALLOC(id); - if ((error = git_oid_fromstrn(id, ++line_start, GIT_OID_SHA1_HEXSIZE)) < 0) { + if ((error = git_oid__fromstrn(id, ++line_start, GIT_OID_SHA1_HEXSIZE, GIT_OID_SHA1)) < 0) { git_error_set(GIT_ERROR_GRAFTS, "invalid parent OID at line %" PRIuZ, parser.line_num); goto error; } From 6c46b58e9b284c536168c8b333bbcf50c3431f83 Mon Sep 17 00:00:00 2001 From: Yuang Li Date: Wed, 31 Aug 2022 15:39:33 +0100 Subject: [PATCH 079/608] include oid.h in grafts.c --- src/libgit2/grafts.c | 1 + 1 file changed, 1 insertion(+) diff --git a/src/libgit2/grafts.c b/src/libgit2/grafts.c index 6662f500901..7cbb1dd7683 100644 --- a/src/libgit2/grafts.c +++ b/src/libgit2/grafts.c @@ -8,6 +8,7 @@ #include "grafts.h" #include "futils.h" +#include "oid.h" #include "oidarray.h" #include "parse.h" From 4cf19add64e2a705bdf1c87ece4874edef77d290 Mon Sep 17 00:00:00 2001 From: Yuang Li Date: Wed, 31 Aug 2022 16:02:42 +0100 Subject: [PATCH 080/608] refactor smart_pkt --- src/libgit2/transports/smart_pkt.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/libgit2/transports/smart_pkt.c b/src/libgit2/transports/smart_pkt.c index cfdf362444b..9e9bda02053 100644 --- a/src/libgit2/transports/smart_pkt.c +++ b/src/libgit2/transports/smart_pkt.c @@ -378,7 +378,7 @@ static int shallow_pkt(git_pkt **out, const char *line, size_t len) len -= 7; if (len >= GIT_OID_SHA1_HEXSIZE) { - git_oid_fromstr(&pkt->oid, line + 1); + git_oid__fromstr(&pkt->oid, line + 1, GIT_OID_SHA1); line += GIT_OID_SHA1_HEXSIZE + 1; len -= GIT_OID_SHA1_HEXSIZE + 1; } @@ -400,7 +400,7 @@ static int unshallow_pkt(git_pkt **out, const char *line, size_t len) len -= 9; if (len >= GIT_OID_SHA1_HEXSIZE) { - git_oid_fromstr(&pkt->oid, line + 1); + git_oid__fromstr(&pkt->oid, line + 1, GIT_OID_SHA1); line += GIT_OID_SHA1_HEXSIZE + 1; len -= GIT_OID_SHA1_HEXSIZE + 1; } From d0eba8ae58092f0db061e3776f194256d0a56fde Mon Sep 17 00:00:00 2001 From: Yuang Li Date: Wed, 31 Aug 2022 17:03:53 +0100 Subject: [PATCH 081/608] fix shallowarray test --- tests/libgit2/transports/smart/shallowarray.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/tests/libgit2/transports/smart/shallowarray.c b/tests/libgit2/transports/smart/shallowarray.c index c51e62713d3..ec4388e42d3 100644 --- a/tests/libgit2/transports/smart/shallowarray.c +++ b/tests/libgit2/transports/smart/shallowarray.c @@ -19,9 +19,9 @@ void test_transports_smart_shallowarray__add_and_remove_oid_from_shallowarray(vo git_shallowarray *shallow_roots = git__malloc(sizeof(git_shallowarray)); git_array_init(shallow_roots->array); - git_oid_fromstr(&oid_0_obj, oid_0); - git_oid_fromstr(&oid_1_obj, oid_1); - git_oid_fromstr(&oid_2_obj, oid_2); + git_oid__fromstr(&oid_0_obj, oid_0, GIT_OID_SHA1); + git_oid__fromstr(&oid_1_obj, oid_1, GIT_OID_SHA1); + git_oid__fromstr(&oid_2_obj, oid_2, GIT_OID_SHA1); git_shallowarray_add(shallow_roots, &oid_0_obj); git_shallowarray_add(shallow_roots, &oid_1_obj); From 89c1b019b7026406834ce0f68a18f255f4b36f99 Mon Sep 17 00:00:00 2001 From: Yuang Li Date: Wed, 31 Aug 2022 17:28:27 +0100 Subject: [PATCH 082/608] fix free error --- tests/libgit2/clone/nonetwork.c | 2 -- 1 file changed, 2 deletions(-) diff --git a/tests/libgit2/clone/nonetwork.c b/tests/libgit2/clone/nonetwork.c index eab63363516..0c4e5a87db4 100644 --- a/tests/libgit2/clone/nonetwork.c +++ b/tests/libgit2/clone/nonetwork.c @@ -296,8 +296,6 @@ void test_clone_nonetwork__clone_tag_to_tree(void) cl_git_pass(git_tree_entry_bypath(&tentry, tree, file_path)); git_tree_entry_free(tentry); git_tree_free(tree); - - cl_fixture_cleanup("testrepo.git"); } static void assert_correct_reflog(const char *name) From 34de5c87fb118ffa177bf2e6a023aee72c4f46f7 Mon Sep 17 00:00:00 2001 From: Yuang Li Date: Mon, 5 Sep 2022 10:38:53 +0100 Subject: [PATCH 083/608] fix seg faults --- tests/libgit2/clone/nonetwork.c | 2 ++ tests/libgit2/clone/shallow.c | 2 +- 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/tests/libgit2/clone/nonetwork.c b/tests/libgit2/clone/nonetwork.c index 0c4e5a87db4..eab63363516 100644 --- a/tests/libgit2/clone/nonetwork.c +++ b/tests/libgit2/clone/nonetwork.c @@ -296,6 +296,8 @@ void test_clone_nonetwork__clone_tag_to_tree(void) cl_git_pass(git_tree_entry_bypath(&tentry, tree, file_path)); git_tree_entry_free(tentry); git_tree_free(tree); + + cl_fixture_cleanup("testrepo.git"); } static void assert_correct_reflog(const char *name) diff --git a/tests/libgit2/clone/shallow.c b/tests/libgit2/clone/shallow.c index 2a88d5d057c..b0114081c3e 100644 --- a/tests/libgit2/clone/shallow.c +++ b/tests/libgit2/clone/shallow.c @@ -10,7 +10,7 @@ void test_clone_shallow__initialize(void) void test_clone_shallow__cleanup(void) { git_libgit2_opts(GIT_OPT_ENABLE_SHALLOW, 0); - cl_git_sandbox_cleanup(); + /*cl_git_sandbox_cleanup();*/ } static int remote_single_branch(git_remote **out, git_repository *repo, const char *name, const char *url, void *payload) From 7122fcd2e4da67905df0d293d0223371b4ffdf01 Mon Sep 17 00:00:00 2001 From: Yuang Li Date: Mon, 5 Sep 2022 16:24:38 +0100 Subject: [PATCH 084/608] fix depth initialisation --- src/libgit2/fetch.c | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/src/libgit2/fetch.c b/src/libgit2/fetch.c index 69794ed1f3e..df8f0a15484 100644 --- a/src/libgit2/fetch.c +++ b/src/libgit2/fetch.c @@ -62,8 +62,8 @@ static int mark_local(git_remote *remote) git_vector_foreach(&remote->refs, i, head) { /* If we have the object, mark it so we don't ask for it. - However if we are unshallowing, we need to ask for it - even though the head exists locally. */ + However if we are unshallowing, we need to ask for it + even though the head exists locally. */ if (remote->nego.depth != INT_MAX && git_odb_exists(odb, &head->oid)) head->local = 1; else @@ -177,7 +177,10 @@ int git_fetch_negotiate(git_remote *remote, const git_fetch_options *opts) remote->need_pack = 0; - remote->nego.depth = (opts && !opts->unshallow) ? opts->depth : INT_MAX; + if (!opts) + remote->nego.depth = -1; + else + remote->nego.depth = opts->unshallow ? INT_MAX : opts->depth; if (filter_wants(remote, opts) < 0) return -1; From 47f36a937f2ea5c3dc33ed940057134af967b062 Mon Sep 17 00:00:00 2001 From: Yuang Li Date: Mon, 5 Sep 2022 19:28:29 +0100 Subject: [PATCH 085/608] fix error handling --- src/libgit2/fetch.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/libgit2/fetch.c b/src/libgit2/fetch.c index df8f0a15484..874813b4e5d 100644 --- a/src/libgit2/fetch.c +++ b/src/libgit2/fetch.c @@ -219,10 +219,10 @@ int git_fetch_download_pack(git_remote *remote) if (!remote->need_pack) return 0; - if ((error = t->download_pack(t, remote->repo, &remote->stats)) < 0) + if ((error = t->download_pack(t, remote->repo, &remote->stats)) != 0) return error; - if ((error = git_repository__shallow_roots_write(remote->repo, remote->nego.shallow_roots->array)) < 0) + if ((error = git_repository__shallow_roots_write(remote->repo, remote->nego.shallow_roots->array)) != 0) return error; return 0; From d23a7903d107528f9d62608f9b236251d9756b00 Mon Sep 17 00:00:00 2001 From: Yuang Li Date: Mon, 5 Sep 2022 19:44:49 +0100 Subject: [PATCH 086/608] remove unused statements --- src/libgit2/fetch.c | 1 - tests/libgit2/clone/shallow.c | 1 - 2 files changed, 2 deletions(-) diff --git a/src/libgit2/fetch.c b/src/libgit2/fetch.c index 874813b4e5d..2a419534ef2 100644 --- a/src/libgit2/fetch.c +++ b/src/libgit2/fetch.c @@ -21,7 +21,6 @@ #include "repository.h" #include "refs.h" #include "transports/smart.h" -#include static int maybe_want(git_remote *remote, git_remote_head *head, git_refspec *tagspec, git_remote_autotag_option_t tagopt) { diff --git a/tests/libgit2/clone/shallow.c b/tests/libgit2/clone/shallow.c index b0114081c3e..eacfe1bcfa6 100644 --- a/tests/libgit2/clone/shallow.c +++ b/tests/libgit2/clone/shallow.c @@ -10,7 +10,6 @@ void test_clone_shallow__initialize(void) void test_clone_shallow__cleanup(void) { git_libgit2_opts(GIT_OPT_ENABLE_SHALLOW, 0); - /*cl_git_sandbox_cleanup();*/ } static int remote_single_branch(git_remote **out, git_repository *repo, const char *name, const char *url, void *payload) From 4f2f91a34f2e66a4511ebf0a650f379bd1c0e41f Mon Sep 17 00:00:00 2001 From: Yuang Li Date: Tue, 6 Sep 2022 15:45:07 +0100 Subject: [PATCH 087/608] fix shallow array search --- src/libgit2/transports/smart.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/libgit2/transports/smart.c b/src/libgit2/transports/smart.c index b0925c8bb57..04ee7e74096 100644 --- a/src/libgit2/transports/smart.c +++ b/src/libgit2/transports/smart.c @@ -497,7 +497,7 @@ int git_shallowarray_add(git_shallowarray *array, git_oid *oid) { size_t oid_index; - if (git_array_search(&oid_index, array->array, (git_array_compare_cb)git_oid_cmp, &oid) < 0) { + if (git_array_search(&oid_index, array->array, (git_array_compare_cb)git_oid_cmp, oid) < 0) { git_oid *tmp = git_array_alloc(array->array); GIT_ERROR_CHECK_ALLOC(tmp); From a9793ac643a0cd82b00970d0d6e0b67681ec3112 Mon Sep 17 00:00:00 2001 From: Yuang Li Date: Tue, 6 Sep 2022 16:01:52 +0100 Subject: [PATCH 088/608] refactor grafts tests --- tests/libgit2/grafts/basic.c | 10 +++++----- tests/libgit2/grafts/parse.c | 4 ++-- tests/libgit2/grafts/shallow.c | 4 ++-- 3 files changed, 9 insertions(+), 9 deletions(-) diff --git a/tests/libgit2/grafts/basic.c b/tests/libgit2/grafts/basic.c index 4be4a12bfc2..5ad437b195c 100644 --- a/tests/libgit2/grafts/basic.c +++ b/tests/libgit2/grafts/basic.c @@ -27,10 +27,10 @@ void test_grafts_basic__graft_add(void) cl_git_pass(git_grafts_new(&grafts)); cl_assert(oid1 = git_array_alloc(parents)); - cl_git_pass(git_oid_fromstr(&oid_src, "2f3053cbff8a4ca2f0666de364ddb734a28a31a9")); + cl_git_pass(git_oid__fromstr(&oid_src, "2f3053cbff8a4ca2f0666de364ddb734a28a31a9", GIT_OID_SHA1)); git_oid_cpy(oid1, &oid_src); - git_oid_fromstr(&oid_src, "f503807ffa920e407a600cfaee96b7152259acc7"); + git_oid__fromstr(&oid_src, "f503807ffa920e407a600cfaee96b7152259acc7", GIT_OID_SHA1); cl_git_pass(git_grafts_add(grafts, &oid_src, parents)); git_array_clear(parents); @@ -75,17 +75,17 @@ void test_grafts_basic__grafted_objects(void) git_oid oid; git_commit *commit; - cl_git_pass(git_oid_fromstr(&oid, "f503807ffa920e407a600cfaee96b7152259acc7")); + cl_git_pass(git_oid__fromstr(&oid, "f503807ffa920e407a600cfaee96b7152259acc7", GIT_OID_SHA1)); cl_git_pass(git_commit_lookup(&commit, g_repo, &oid)); cl_assert_equal_i(1, git_commit_parentcount(commit)); git_commit_free(commit); - cl_git_pass(git_oid_fromstr(&oid, "0512adebd3782157f0d5c9b22b043f87b4aaff9e")); + cl_git_pass(git_oid__fromstr(&oid, "0512adebd3782157f0d5c9b22b043f87b4aaff9e", GIT_OID_SHA1)); cl_git_pass(git_commit_lookup(&commit, g_repo, &oid)); cl_assert_equal_i(1, git_commit_parentcount(commit)); git_commit_free(commit); - cl_git_pass(git_oid_fromstr(&oid, "66cc22a015f6ca75b34c82d28f78ba663876bade")); + cl_git_pass(git_oid__fromstr(&oid, "66cc22a015f6ca75b34c82d28f78ba663876bade", GIT_OID_SHA1)); cl_git_pass(git_commit_lookup(&commit, g_repo, &oid)); cl_assert_equal_i(4, git_commit_parentcount(commit)); git_commit_free(commit); diff --git a/tests/libgit2/grafts/parse.c b/tests/libgit2/grafts/parse.c index de110c90110..149b01c8c7b 100644 --- a/tests/libgit2/grafts/parse.c +++ b/tests/libgit2/grafts/parse.c @@ -46,14 +46,14 @@ static void assert_graft_contains(git_grafts *grafts, const char *graft, size_t va_list ap; size_t i = 0; - cl_git_pass(git_oid_fromstr(&oid, graft)); + cl_git_pass(git_oid__fromstr(&oid, graft, GIT_OID_SHA1)); cl_git_pass(git_grafts_get(&commit, grafts, &oid)); cl_assert_equal_oid(&commit->oid, &oid); cl_assert_equal_i(commit->parents.size, n); va_start(ap, n); while (i < n) { - cl_git_pass(git_oid_fromstr(&oid, va_arg(ap, const char *))); + cl_git_pass(git_oid__fromstr(&oid, va_arg(ap, const char *), GIT_OID_SHA1)); cl_assert_equal_oid(&commit->parents.ptr[i], &oid); i++; } diff --git a/tests/libgit2/grafts/shallow.c b/tests/libgit2/grafts/shallow.c index a75b5a0519b..8c272392243 100644 --- a/tests/libgit2/grafts/shallow.c +++ b/tests/libgit2/grafts/shallow.c @@ -20,7 +20,7 @@ void test_grafts_shallow__unset_feature_flag(void) void test_grafts_shallow__initialize(void) { git_libgit2_opts(GIT_OPT_ENABLE_SHALLOW, 1); - cl_git_pass(git_oid_fromstr(&g_shallow_oid, "be3563ae3f795b2b4353bcce3a527ad0a4f7f644")); + cl_git_pass(git_oid__fromstr(&g_shallow_oid, "be3563ae3f795b2b4353bcce3a527ad0a4f7f644", GIT_OID_SHA1)); } void test_grafts_shallow__cleanup(void) @@ -73,7 +73,7 @@ void test_grafts_shallow__cache_clearing(void) git_grafts *grafts; git_oid tmp_oid; - cl_git_pass(git_oid_fromstr(&tmp_oid, "0000000000000000000000000000000000000000")); + cl_git_pass(git_oid__fromstr(&tmp_oid, "0000000000000000000000000000000000000000", GIT_OID_SHA1)); g_repo = cl_git_sandbox_init("shallow.git"); cl_git_pass(git_repository_shallow_grafts__weakptr(&grafts, g_repo)); From 1fde70bb607c7ba471db359f045affd1f5625e5d Mon Sep 17 00:00:00 2001 From: Kai Luo Date: Thu, 22 Sep 2022 14:14:57 +0800 Subject: [PATCH 089/608] Include --- src/util/posix.h | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/util/posix.h b/src/util/posix.h index 607aa9dceb3..1e37bba2ff5 100644 --- a/src/util/posix.h +++ b/src/util/posix.h @@ -9,6 +9,7 @@ #include "git2_util.h" +#include #include #include #include @@ -104,8 +105,6 @@ typedef __int64 off64_t; typedef __haiku_std_int64 off64_t; #elif defined(__APPLE__) typedef __int64_t off64_t; -#elif defined(_AIX) -typedef long long off64_t; #else typedef int64_t off64_t; #endif From 062f5697d1d8640911138cbe319ad29798b69240 Mon Sep 17 00:00:00 2001 From: Kai Luo Date: Thu, 22 Sep 2022 16:34:21 +0800 Subject: [PATCH 090/608] Revert "Include " This reverts commit 1fde70bb607c7ba471db359f045affd1f5625e5d. --- src/util/posix.h | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/util/posix.h b/src/util/posix.h index 1e37bba2ff5..607aa9dceb3 100644 --- a/src/util/posix.h +++ b/src/util/posix.h @@ -9,7 +9,6 @@ #include "git2_util.h" -#include #include #include #include @@ -105,6 +104,8 @@ typedef __int64 off64_t; typedef __haiku_std_int64 off64_t; #elif defined(__APPLE__) typedef __int64_t off64_t; +#elif defined(_AIX) +typedef long long off64_t; #else typedef int64_t off64_t; #endif From b57221e82919b798983ea0d3c3fd1a5de9170809 Mon Sep 17 00:00:00 2001 From: Miguel Arroz <750683+arroz@users.noreply.github.com> Date: Thu, 3 Nov 2022 11:26:30 -0700 Subject: [PATCH 091/608] #6422: handle dangling symbolic refs gracefully --- src/libgit2/revwalk.c | 6 +++++- tests/libgit2/revwalk/basic.c | 17 +++++++++++++++++ 2 files changed, 22 insertions(+), 1 deletion(-) diff --git a/src/libgit2/revwalk.c b/src/libgit2/revwalk.c index 553e0497a14..3269d9279b6 100644 --- a/src/libgit2/revwalk.c +++ b/src/libgit2/revwalk.c @@ -121,8 +121,12 @@ int git_revwalk__push_ref(git_revwalk *walk, const char *refname, const git_revw { git_oid oid; - if (git_reference_name_to_id(&oid, walk->repo, refname) < 0) + int error = git_reference_name_to_id(&oid, walk->repo, refname); + if (opts->from_glob && (error == GIT_ENOTFOUND || error == GIT_EINVALIDSPEC || error == GIT_EPEEL)) { + return 0; + } else if (error < 0) { return -1; + } return git_revwalk__push_commit(walk, &oid, opts); } diff --git a/tests/libgit2/revwalk/basic.c b/tests/libgit2/revwalk/basic.c index 62a57aaa3c0..41090a1dac8 100644 --- a/tests/libgit2/revwalk/basic.c +++ b/tests/libgit2/revwalk/basic.c @@ -180,6 +180,23 @@ void test_revwalk_basic__glob_heads_with_invalid(void) cl_assert_equal_i(20, i); } +void test_revwalk_basic__glob_invalid_symbolic_ref(void) +{ + int i; + git_oid oid; + + revwalk_basic_setup_walk("testrepo"); + + cl_git_mkfile("testrepo/.git/refs/heads/broken-sym-ref", "ref: refs/heads/does-not-exist"); + cl_git_pass(git_revwalk_push_glob(_walk, "heads")); + + for (i = 0; !git_revwalk_next(&oid, _walk); ++i) + /* walking */; + + /* git log --branches --oneline | wc -l => 16 */ + cl_assert_equal_i(20, i); +} + void test_revwalk_basic__push_head(void) { int i = 0; From ecc6f2fb8399d84e5b2bf043376dfc51f43f3e90 Mon Sep 17 00:00:00 2001 From: Russell Sim Date: Fri, 25 Nov 2022 13:35:08 +0100 Subject: [PATCH 092/608] push: support push-options Push options are an optional capability of a git server. If they are listed in the servers capabilities, when the client lists push-options in it's list of capabilities, then the client sends it's list of push options followed by a flush-pkt. So, If we have any declared push options, then we will list it as a client capability, and send the options. If the request contains push options but the server has no push options capability, then error. --- include/git2/remote.h | 5 +++++ include/git2/sys/remote.h | 3 +++ src/libgit2/push.c | 25 +++++++++++++++++++++++++ src/libgit2/push.h | 1 + src/libgit2/remote.c | 7 +++++++ src/libgit2/transports/smart.c | 3 +++ src/libgit2/transports/smart.h | 4 +++- src/libgit2/transports/smart_protocol.c | 19 +++++++++++++++++++ 8 files changed, 66 insertions(+), 1 deletion(-) diff --git a/include/git2/remote.h b/include/git2/remote.h index 8c9c26f3fd5..108fcfe716e 100644 --- a/include/git2/remote.h +++ b/include/git2/remote.h @@ -812,6 +812,11 @@ typedef struct { * Extra headers for this push operation */ git_strarray custom_headers; + + /** + * Push options + */ + git_strarray push_options; } git_push_options; #define GIT_PUSH_OPTIONS_VERSION 1 diff --git a/include/git2/sys/remote.h b/include/git2/sys/remote.h index 0eae9234deb..07309ab09b6 100644 --- a/include/git2/sys/remote.h +++ b/include/git2/sys/remote.h @@ -26,6 +26,9 @@ typedef enum { /** Remote supports fetching an individual reachable object. */ GIT_REMOTE_CAPABILITY_REACHABLE_OID = (1 << 1), + + /** Remote supports push options. */ + GIT_REMOTE_CAPABILITY_PUSH_OPTIONS = (1 << 2), } git_remote_capability_t; /** diff --git a/src/libgit2/push.c b/src/libgit2/push.c index d477b4f0dc6..b1cbcd4ae10 100644 --- a/src/libgit2/push.c +++ b/src/libgit2/push.c @@ -68,6 +68,14 @@ int git_push_new(git_push **out, git_remote *remote, const git_push_options *opt return -1; } + if (git_vector_init(&p->push_options, 0, git__strcmp_cb) < 0) { + git_vector_free(&p->status); + git_vector_free(&p->specs); + git_vector_free(&p->updates); + git__free(p); + return -1; + } + *out = p; return 0; } @@ -472,12 +480,23 @@ static int filter_refs(git_remote *remote) int git_push_finish(git_push *push) { int error; + unsigned int remote_caps; if (!git_remote_connected(push->remote)) { git_error_set(GIT_ERROR_NET, "remote is disconnected"); return -1; } + if ((error = git_remote_capabilities(&remote_caps, push->remote)) < 0){ + git_error_set(GIT_ERROR_INVALID, "remote capabilities not available"); + return -1; + } + + if (git_vector_length(&push->push_options) > 0 && !(remote_caps & GIT_REMOTE_CAPABILITY_PUSH_OPTIONS)) { + git_error_set(GIT_ERROR_INVALID, "push-options not supported by remote"); + return -1; + } + if ((error = filter_refs(push->remote)) < 0 || (error = do_push(push)) < 0) return error; @@ -521,6 +540,7 @@ void git_push_free(git_push *push) push_spec *spec; push_status *status; git_push_update *update; + char *option; unsigned int i; if (push == NULL) @@ -543,6 +563,11 @@ void git_push_free(git_push *push) } git_vector_free(&push->updates); + git_vector_foreach(&push->push_options, i, option) { + git__free(option); + } + git_vector_free(&push->push_options); + git__free(push); } diff --git a/src/libgit2/push.h b/src/libgit2/push.h index fc72e845eee..17c3e2f6845 100644 --- a/src/libgit2/push.h +++ b/src/libgit2/push.h @@ -34,6 +34,7 @@ struct git_push { git_vector specs; git_vector updates; bool report_status; + git_vector push_options; /* report-status */ bool unpack_ok; diff --git a/src/libgit2/remote.c b/src/libgit2/remote.c index 02d271d7d9d..a1be7162906 100644 --- a/src/libgit2/remote.c +++ b/src/libgit2/remote.c @@ -2958,6 +2958,13 @@ int git_remote_upload( } } + if (opts && opts->push_options.count > 0) + for (i = 0; i < opts->push_options.count; ++i) { + if ((error = git_vector_insert(&push->push_options, git__strdup(opts->push_options.strings[i]))) < 0) { + goto cleanup; + } + } + if ((error = git_push_finish(push)) < 0) goto cleanup; diff --git a/src/libgit2/transports/smart.c b/src/libgit2/transports/smart.c index 7f57dba2a42..4de8a3d78a4 100644 --- a/src/libgit2/transports/smart.c +++ b/src/libgit2/transports/smart.c @@ -233,6 +233,9 @@ static int git_smart__capabilities(unsigned int *capabilities, git_transport *tr *capabilities = 0; + if (t->caps.push_options) + *capabilities |= GIT_REMOTE_CAPABILITY_PUSH_OPTIONS; + if (t->caps.want_tip_sha1) *capabilities |= GIT_REMOTE_CAPABILITY_TIP_OID; diff --git a/src/libgit2/transports/smart.h b/src/libgit2/transports/smart.h index 9323d6c444e..2aea414e940 100644 --- a/src/libgit2/transports/smart.h +++ b/src/libgit2/transports/smart.h @@ -32,6 +32,7 @@ #define GIT_CAP_SYMREF "symref" #define GIT_CAP_WANT_TIP_SHA1 "allow-tip-sha1-in-want" #define GIT_CAP_WANT_REACHABLE_SHA1 "allow-reachable-sha1-in-want" +#define GIT_CAP_PUSH_OPTIONS "push-options" extern bool git_smart__ofs_delta_enabled; @@ -132,7 +133,8 @@ typedef struct transport_smart_caps { report_status:1, thin_pack:1, want_tip_sha1:1, - want_reachable_sha1:1; + want_reachable_sha1:1, + push_options:1; } transport_smart_caps; typedef int (*packetsize_cb)(size_t received, void *payload); diff --git a/src/libgit2/transports/smart_protocol.c b/src/libgit2/transports/smart_protocol.c index 09778b33575..525053f420e 100644 --- a/src/libgit2/transports/smart_protocol.c +++ b/src/libgit2/transports/smart_protocol.c @@ -190,6 +190,12 @@ int git_smart__detect_caps(git_pkt_ref *pkt, transport_smart_caps *caps, git_vec continue; } + if (!git__prefixcmp(ptr, GIT_CAP_PUSH_OPTIONS)) { + caps->common = caps->push_options = 1; + ptr += strlen(GIT_CAP_PUSH_OPTIONS); + continue; + } + if (!git__prefixcmp(ptr, GIT_CAP_THIN_PACK)) { caps->common = caps->thin_pack = 1; ptr += strlen(GIT_CAP_THIN_PACK); @@ -642,6 +648,7 @@ int git_smart__download_pack( static int gen_pktline(git_str *buf, git_push *push) { push_spec *spec; + char *option; size_t i, len; char old_id[GIT_OID_SHA1_HEXSIZE+1], new_id[GIT_OID_SHA1_HEXSIZE+1]; @@ -654,6 +661,8 @@ static int gen_pktline(git_str *buf, git_push *push) ++len; /* '\0' */ if (push->report_status) len += strlen(GIT_CAP_REPORT_STATUS) + 1; + if (git_vector_length(&push->push_options) > 0) + len += strlen(GIT_CAP_PUSH_OPTIONS) + 1; len += strlen(GIT_CAP_SIDE_BAND_64K) + 1; } @@ -669,6 +678,10 @@ static int gen_pktline(git_str *buf, git_push *push) git_str_putc(buf, ' '); git_str_printf(buf, GIT_CAP_REPORT_STATUS); } + if (git_vector_length(&push->push_options) > 0) { + git_str_putc(buf, ' '); + git_str_printf(buf, GIT_CAP_PUSH_OPTIONS); + } git_str_putc(buf, ' '); git_str_printf(buf, GIT_CAP_SIDE_BAND_64K); } @@ -676,6 +689,12 @@ static int gen_pktline(git_str *buf, git_push *push) git_str_putc(buf, '\n'); } + if (git_vector_length(&push->push_options) > 0) { + git_str_printf(buf, "0000"); + git_vector_foreach(&push->push_options, i, option) { + git_str_printf(buf, "%04"PRIxZ"%s", strlen(option) + 4 , option); + } + } git_str_puts(buf, "0000"); return git_str_oom(buf) ? -1 : 0; } From c45d1c6e889dd5740970d402eb3642fe8e93e482 Mon Sep 17 00:00:00 2001 From: bansheerubber Date: Tue, 19 Apr 2022 16:23:46 -0700 Subject: [PATCH 093/608] push: implement ci tests We found that the best way to test push options was to receive them via a git hooks script, and output them to a location that the CI tests could read to check and see if the push options were interpreted by git correctly. Co-Authored-By: pireads Co-Authored-By: lotdeef Co-Authored-By: PSI497 <497.psi.497@gmail.com> --- .github/workflows/main.yml | 11 +++ ci/hooks/pre-receive | 2 + ci/test.sh | 46 +++++++++++- tests/libgit2/online/push.c | 144 +++++++++++++++++++++++++++--------- 4 files changed, 168 insertions(+), 35 deletions(-) create mode 100755 ci/hooks/pre-receive diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index ec1c828d67c..005d830b3ec 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -84,6 +84,17 @@ jobs: strategy: matrix: platform: + - name: "Linux (Focal, Clang, mbedTLS, push-options)" + id: focal-clang-mbedtls + container: + name: focal + env: + CC: clang-10 + CMAKE_GENERATOR: Ninja + CMAKE_OPTIONS: -DUSE_HTTPS=mbedTLS -DUSE_SHA1=HTTPS -DREGEX_BACKEND=pcre -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=ON + RUN_PUSH_OPTONS_TESTS: true + SKIP_SSH_TESTS: true + os: ubuntu-latest - name: "Linux (Xenial, GCC, OpenSSL)" id: xenial-gcc-openssl container: diff --git a/ci/hooks/pre-receive b/ci/hooks/pre-receive new file mode 100755 index 00000000000..92be65ce01f --- /dev/null +++ b/ci/hooks/pre-receive @@ -0,0 +1,2 @@ +#!/bin/sh +printf "$GIT_PUSH_OPTION_0$GIT_PUSH_OPTION_1$GIT_PUSH_OPTION_2" > %file% diff --git a/ci/test.sh b/ci/test.sh index 0e1d39e8d4f..63062f07f78 100755 --- a/ci/test.sh +++ b/ci/test.sh @@ -1,6 +1,6 @@ #!/usr/bin/env bash -set -e +set -ex if [ -n "$SKIP_TESTS" ]; then exit 0 @@ -106,7 +106,15 @@ if [ -z "$SKIP_GITDAEMON_TESTS" ]; then echo "Starting git daemon (standard)..." GIT_STANDARD_DIR=`mktemp -d ${TMPDIR}/git_standard.XXXXXXXX` git init --bare "${GIT_STANDARD_DIR}/test.git" >/dev/null + git config --file "${GIT_STANDARD_DIR}/test.git/config" receive.advertisePushOptions true + for f in $(ls ${SOURCE_DIR}/ci/hooks) + do + sed "s=%file%=${TMPDIR}/push-option-result-git-daemon=g" "${SOURCE_DIR}/ci/hooks/$f" > "${GIT_STANDARD_DIR}/test.git/hooks/${f}" + chmod +x "$GIT_STANDARD_DIR/test.git/hooks/${f}" + done + git daemon --listen=localhost --export-all --enable=receive-pack --base-path="${GIT_STANDARD_DIR}" "${GIT_STANDARD_DIR}" 2>/dev/null & + GIT_STANDARD_PID=$! echo "Starting git daemon (namespace)..." @@ -134,6 +142,14 @@ if [ -z "$SKIP_NTLM_TESTS" -o -z "$SKIP_ONLINE_TESTS" ]; then echo "Starting HTTP server..." HTTP_DIR=`mktemp -d ${TMPDIR}/http.XXXXXXXX` git init --bare "${HTTP_DIR}/test.git" + git config --file "${HTTP_DIR}/test.git/config" receive.advertisePushOptions true + + for f in $(ls ${SOURCE_DIR}/ci/hooks) + do + sed "s=%file%=${TMPDIR}/push-option-result-git-ntlm=g" "${SOURCE_DIR}/ci/hooks/$f" > "${HTTP_DIR}/test.git/hooks/${f}" + chmod +x "$HTTP_DIR/test.git/hooks/${f}" + done + java -jar poxygit.jar --address 127.0.0.1 --port 9000 --credentials foo:baz --quiet "${HTTP_DIR}" & HTTP_PID=$! fi @@ -143,6 +159,14 @@ if [ -z "$SKIP_SSH_TESTS" ]; then HOME=`mktemp -d ${TMPDIR}/home.XXXXXXXX` SSHD_DIR=`mktemp -d ${TMPDIR}/sshd.XXXXXXXX` git init --bare "${SSHD_DIR}/test.git" >/dev/null + git config --file "${SSHD_DIR}/test.git/config" receive.advertisePushOptions true + + for f in $(ls ${SOURCE_DIR}/ci/hooks) + do + sed "s=%file%=${TMPDIR}/push-option-result-git-ssh=g" "${SOURCE_DIR}/ci/hooks/$f" > "${SSHD_DIR}/test.git/hooks/${f}" + chmod +x "$SSHD_DIR/test.git/hooks/${f}" + done + cat >"${SSHD_DIR}/sshd_config" <<-EOF Port 2222 ListenAddress 0.0.0.0 @@ -243,8 +267,12 @@ if [ -z "$SKIP_GITDAEMON_TESTS" ]; then echo "Running gitdaemon (standard) tests" echo "" + if [[ "$RUN_PUSH_OPTONS_TESTS" = "true " ]]; then + export GITTEST_PUSH_OPTION_RESULT="${TMPDIR}/push-option-result-git-daemon" + fi export GITTEST_REMOTE_URL="git://localhost/test.git" run_test gitdaemon + unset GITTEST_PUSH_OPTION_RESULT unset GITTEST_REMOTE_URL echo "" @@ -289,10 +317,14 @@ if [ -z "$SKIP_NTLM_TESTS" ]; then echo "Running NTLM tests (IIS emulation)" echo "" + if [[ "$RUN_PUSH_OPTONS_TESTS" = "true " ]]; then + export GITTEST_PUSH_OPTION_RESULT="${TMPDIR}/push-option-result-git-ntlm" + fi export GITTEST_REMOTE_URL="http://localhost:9000/ntlm/test.git" export GITTEST_REMOTE_USER="foo" export GITTEST_REMOTE_PASS="baz" run_test auth_clone_and_push + unset GITTEST_PUSH_OPTION_RESULT unset GITTEST_REMOTE_URL unset GITTEST_REMOTE_USER unset GITTEST_REMOTE_PASS @@ -301,10 +333,14 @@ if [ -z "$SKIP_NTLM_TESTS" ]; then echo "Running NTLM tests (Apache emulation)" echo "" + if [[ "$RUN_PUSH_OPTONS_TESTS" == "true " ]]; then + export GITTEST_PUSH_OPTION_RESULT="${TMPDIR}/push-option-result-git-ntlm" + fi export GITTEST_REMOTE_URL="http://localhost:9000/broken-ntlm/test.git" export GITTEST_REMOTE_USER="foo" export GITTEST_REMOTE_PASS="baz" run_test auth_clone_and_push + unset GITTEST_PUSH_OPTION_RESULT unset GITTEST_REMOTE_URL unset GITTEST_REMOTE_USER unset GITTEST_REMOTE_PASS @@ -354,16 +390,24 @@ if [ -z "$SKIP_SSH_TESTS" ]; then echo "Running ssh tests" echo "" + if [[ "$RUN_PUSH_OPTONS_TESTS" == "true " ]]; then + export GITTEST_PUSH_OPTION_RESULT="${TMPDIR}/push-option-result-ssh" + fi export GITTEST_REMOTE_URL="ssh://localhost:2222/$SSHD_DIR/test.git" run_test ssh + unset GITTEST_PUSH_OPTION_RESULT unset GITTEST_REMOTE_URL echo "" echo "Running ssh tests (scp-style paths)" echo "" + if [[ "$RUN_PUSH_OPTONS_TESTS" == "true " ]]; then + export GITTEST_PUSH_OPTION_RESULT="${TMPDIR}/push-option-result-ssh" + fi export GITTEST_REMOTE_URL="[localhost:2222]:$SSHD_DIR/test.git" run_test ssh + unset GITTEST_PUSH_OPTION_RESULT unset GITTEST_REMOTE_URL unset GITTEST_REMOTE_USER diff --git a/tests/libgit2/online/push.c b/tests/libgit2/online/push.c index d9208d28a7c..d7dbda3bcad 100644 --- a/tests/libgit2/online/push.c +++ b/tests/libgit2/online/push.c @@ -5,6 +5,7 @@ #include "push_util.h" #include "refspec.h" #include "remote.h" +#include "futils.h" static git_repository *_repo; @@ -20,6 +21,8 @@ static char *_remote_ssh_passphrase = NULL; static char *_remote_default = NULL; static char *_remote_expectcontinue = NULL; +static char *_remote_push_options_result = NULL; + static int cred_acquire_cb(git_credential **, const char *, const char *, unsigned int, void *); static git_remote *_remote; @@ -367,6 +370,7 @@ void test_online_push__initialize(void) _remote_ssh_passphrase = cl_getenv("GITTEST_REMOTE_SSH_PASSPHRASE"); _remote_default = cl_getenv("GITTEST_REMOTE_DEFAULT"); _remote_expectcontinue = cl_getenv("GITTEST_REMOTE_EXPECTCONTINUE"); + _remote_push_options_result = cl_getenv("GITTEST_PUSH_OPTION_RESULT"); _remote = NULL; /* Skip the test if we're missing the remote URL */ @@ -422,6 +426,7 @@ void test_online_push__cleanup(void) git__free(_remote_ssh_passphrase); git__free(_remote_default); git__free(_remote_expectcontinue); + git__free(_remote_push_options_result); /* Freed by cl_git_sandbox_cleanup */ _repo = NULL; @@ -472,7 +477,8 @@ static void do_push( const char *refspecs[], size_t refspecs_len, push_status expected_statuses[], size_t expected_statuses_len, expected_ref expected_refs[], size_t expected_refs_len, - int expected_ret, int check_progress_cb, int check_update_tips_cb) + int expected_ret, int check_progress_cb, int check_update_tips_cb, + git_strarray push_options) { git_push_options opts = GIT_PUSH_OPTIONS_INIT; size_t i; @@ -484,6 +490,9 @@ static void do_push( /* Auto-detect the number of threads to use */ opts.pb_parallelism = 0; + if(push_options.count != 0) + opts.push_options = push_options; + memcpy(&opts.callbacks, &_record_cbs, sizeof(git_remote_callbacks)); data = opts.callbacks.payload; @@ -533,7 +542,8 @@ static void do_push( /* Call push_finish() without ever calling git_push_add_refspec() */ void test_online_push__noop(void) { - do_push(NULL, 0, NULL, 0, NULL, 0, 0, 0, 1); + git_strarray push_options = { 0 }; + do_push(NULL, 0, NULL, 0, NULL, 0, 0, 0, 1, push_options); } void test_online_push__b1(void) @@ -541,9 +551,10 @@ void test_online_push__b1(void) const char *specs[] = { "refs/heads/b1:refs/heads/b1" }; push_status exp_stats[] = { { "refs/heads/b1", 1 } }; expected_ref exp_refs[] = { { "refs/heads/b1", &_oid_b1 } }; + git_strarray push_options = { 0 }; do_push(specs, ARRAY_SIZE(specs), exp_stats, ARRAY_SIZE(exp_stats), - exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1); + exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1, push_options); } void test_online_push__b2(void) @@ -551,9 +562,10 @@ void test_online_push__b2(void) const char *specs[] = { "refs/heads/b2:refs/heads/b2" }; push_status exp_stats[] = { { "refs/heads/b2", 1 } }; expected_ref exp_refs[] = { { "refs/heads/b2", &_oid_b2 } }; + git_strarray push_options = { 0 }; do_push(specs, ARRAY_SIZE(specs), exp_stats, ARRAY_SIZE(exp_stats), - exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1); + exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1, push_options); } void test_online_push__b3(void) @@ -561,9 +573,10 @@ void test_online_push__b3(void) const char *specs[] = { "refs/heads/b3:refs/heads/b3" }; push_status exp_stats[] = { { "refs/heads/b3", 1 } }; expected_ref exp_refs[] = { { "refs/heads/b3", &_oid_b3 } }; + git_strarray push_options = { 0 }; do_push(specs, ARRAY_SIZE(specs), exp_stats, ARRAY_SIZE(exp_stats), - exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1); + exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1, push_options); } void test_online_push__b4(void) @@ -571,9 +584,10 @@ void test_online_push__b4(void) const char *specs[] = { "refs/heads/b4:refs/heads/b4" }; push_status exp_stats[] = { { "refs/heads/b4", 1 } }; expected_ref exp_refs[] = { { "refs/heads/b4", &_oid_b4 } }; + git_strarray push_options = { 0 }; do_push(specs, ARRAY_SIZE(specs), exp_stats, ARRAY_SIZE(exp_stats), - exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1); + exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1, push_options); } void test_online_push__b5(void) @@ -581,15 +595,17 @@ void test_online_push__b5(void) const char *specs[] = { "refs/heads/b5:refs/heads/b5" }; push_status exp_stats[] = { { "refs/heads/b5", 1 } }; expected_ref exp_refs[] = { { "refs/heads/b5", &_oid_b5 } }; + git_strarray push_options = { 0 }; do_push(specs, ARRAY_SIZE(specs), exp_stats, ARRAY_SIZE(exp_stats), - exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1); + exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1, push_options); } void test_online_push__b5_cancel(void) { const char *specs[] = { "refs/heads/b5:refs/heads/b5" }; - do_push(specs, ARRAY_SIZE(specs), NULL, 0, NULL, 0, GIT_EUSER, 1, 1); + git_strarray push_options = { 0 }; + do_push(specs, ARRAY_SIZE(specs), NULL, 0, NULL, 0, GIT_EUSER, 1, 1, push_options); } void test_online_push__multi(void) @@ -618,9 +634,10 @@ void test_online_push__multi(void) { "refs/heads/b4", &_oid_b4 }, { "refs/heads/b5", &_oid_b5 } }; + git_strarray push_options = { 0 }; do_push(specs, ARRAY_SIZE(specs), exp_stats, ARRAY_SIZE(exp_stats), - exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1); + exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1, push_options); cl_git_pass(git_reflog_read(&log, _repo, "refs/remotes/test/b1")); entry = git_reflog_entry_byindex(log, 0); @@ -645,12 +662,14 @@ void test_online_push__implicit_tgt(void) { "refs/heads/b2", &_oid_b2 } }; + git_strarray push_options = { 0 }; do_push(specs1, ARRAY_SIZE(specs1), exp_stats1, ARRAY_SIZE(exp_stats1), - exp_refs1, ARRAY_SIZE(exp_refs1), 0, 1, 1); + exp_refs1, ARRAY_SIZE(exp_refs1), 0, 1, 1, push_options); + do_push(specs2, ARRAY_SIZE(specs2), exp_stats2, ARRAY_SIZE(exp_stats2), - exp_refs2, ARRAY_SIZE(exp_refs2), 0, 0, 0); + exp_refs2, ARRAY_SIZE(exp_refs2), 0, 0, 0, push_options); } void test_online_push__fast_fwd(void) @@ -670,21 +689,22 @@ void test_online_push__fast_fwd(void) /* Force should have no effect on a fast forward push */ const char *specs_ff_force[] = { "+refs/heads/b6:refs/heads/b1" }; + git_strarray push_options = { 0 }; do_push(specs_init, ARRAY_SIZE(specs_init), exp_stats_init, ARRAY_SIZE(exp_stats_init), - exp_refs_init, ARRAY_SIZE(exp_refs_init), 0, 1, 1); + exp_refs_init, ARRAY_SIZE(exp_refs_init), 0, 1, 1, push_options); do_push(specs_ff, ARRAY_SIZE(specs_ff), exp_stats_ff, ARRAY_SIZE(exp_stats_ff), - exp_refs_ff, ARRAY_SIZE(exp_refs_ff), 0, 0, 0); + exp_refs_ff, ARRAY_SIZE(exp_refs_ff), 0, 0, 0, push_options); do_push(specs_reset, ARRAY_SIZE(specs_reset), exp_stats_init, ARRAY_SIZE(exp_stats_init), - exp_refs_init, ARRAY_SIZE(exp_refs_init), 0, 0, 0); + exp_refs_init, ARRAY_SIZE(exp_refs_init), 0, 0, 0, push_options); do_push(specs_ff_force, ARRAY_SIZE(specs_ff_force), exp_stats_ff, ARRAY_SIZE(exp_stats_ff), - exp_refs_ff, ARRAY_SIZE(exp_refs_ff), 0, 0, 0); + exp_refs_ff, ARRAY_SIZE(exp_refs_ff), 0, 0, 0, push_options); } void test_online_push__tag_commit(void) @@ -692,9 +712,10 @@ void test_online_push__tag_commit(void) const char *specs[] = { "refs/tags/tag-commit:refs/tags/tag-commit" }; push_status exp_stats[] = { { "refs/tags/tag-commit", 1 } }; expected_ref exp_refs[] = { { "refs/tags/tag-commit", &_tag_commit } }; + git_strarray push_options = { 0 }; do_push(specs, ARRAY_SIZE(specs), exp_stats, ARRAY_SIZE(exp_stats), - exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1); + exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1, push_options); } void test_online_push__tag_tree(void) @@ -702,9 +723,10 @@ void test_online_push__tag_tree(void) const char *specs[] = { "refs/tags/tag-tree:refs/tags/tag-tree" }; push_status exp_stats[] = { { "refs/tags/tag-tree", 1 } }; expected_ref exp_refs[] = { { "refs/tags/tag-tree", &_tag_tree } }; + git_strarray push_options = { 0 }; do_push(specs, ARRAY_SIZE(specs), exp_stats, ARRAY_SIZE(exp_stats), - exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1); + exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1, push_options); } void test_online_push__tag_blob(void) @@ -712,9 +734,10 @@ void test_online_push__tag_blob(void) const char *specs[] = { "refs/tags/tag-blob:refs/tags/tag-blob" }; push_status exp_stats[] = { { "refs/tags/tag-blob", 1 } }; expected_ref exp_refs[] = { { "refs/tags/tag-blob", &_tag_blob } }; + git_strarray push_options = { 0 }; do_push(specs, ARRAY_SIZE(specs), exp_stats, ARRAY_SIZE(exp_stats), - exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1); + exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1, push_options); } void test_online_push__tag_lightweight(void) @@ -722,9 +745,10 @@ void test_online_push__tag_lightweight(void) const char *specs[] = { "refs/tags/tag-lightweight:refs/tags/tag-lightweight" }; push_status exp_stats[] = { { "refs/tags/tag-lightweight", 1 } }; expected_ref exp_refs[] = { { "refs/tags/tag-lightweight", &_tag_lightweight } }; + git_strarray push_options = { 0 }; do_push(specs, ARRAY_SIZE(specs), exp_stats, ARRAY_SIZE(exp_stats), - exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1); + exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1, push_options); } void test_online_push__tag_to_tag(void) @@ -732,9 +756,10 @@ void test_online_push__tag_to_tag(void) const char *specs[] = { "refs/tags/tag-tag:refs/tags/tag-tag" }; push_status exp_stats[] = { { "refs/tags/tag-tag", 1 } }; expected_ref exp_refs[] = { { "refs/tags/tag-tag", &_tag_tag } }; + git_strarray push_options = { 0 }; do_push(specs, ARRAY_SIZE(specs), exp_stats, ARRAY_SIZE(exp_stats), - exp_refs, ARRAY_SIZE(exp_refs), 0, 0, 0); + exp_refs, ARRAY_SIZE(exp_refs), 0, 0, 0, push_options); } void test_online_push__force(void) @@ -749,19 +774,64 @@ void test_online_push__force(void) push_status exp_stats2_force[] = { { "refs/heads/tgt", 1 } }; expected_ref exp_refs2_force[] = { { "refs/heads/tgt", &_oid_b4 } }; + git_strarray push_options = { 0 }; do_push(specs1, ARRAY_SIZE(specs1), exp_stats1, ARRAY_SIZE(exp_stats1), - exp_refs1, ARRAY_SIZE(exp_refs1), 0, 1, 1); + exp_refs1, ARRAY_SIZE(exp_refs1), 0, 1, 1, push_options); do_push(specs2, ARRAY_SIZE(specs2), NULL, 0, - exp_refs1, ARRAY_SIZE(exp_refs1), GIT_ENONFASTFORWARD, 0, 0); + exp_refs1, ARRAY_SIZE(exp_refs1), GIT_ENONFASTFORWARD, 0, 0, push_options); /* Non-fast-forward update with force should pass. */ record_callbacks_data_clear(&_record_cbs_data); do_push(specs2_force, ARRAY_SIZE(specs2_force), exp_stats2_force, ARRAY_SIZE(exp_stats2_force), - exp_refs2_force, ARRAY_SIZE(exp_refs2_force), 0, 1, 1); + exp_refs2_force, ARRAY_SIZE(exp_refs2_force), 0, 1, 1, push_options); +} + +static void push_option_test(git_strarray push_options, const char *expected_option) +{ + const char *specs[] = { "refs/heads/b1:refs/heads/b1" }; + push_status exp_stats[] = { { "refs/heads/b1", 1 } }; + expected_ref exp_refs[] = { { "refs/heads/b1", &_oid_b1 } }; + git_str push_options_result = GIT_STR_INIT; + + /* Skip the test if we're missing the push options result file */ + if (!_remote_push_options_result) + cl_skip(); + + do_push(specs, ARRAY_SIZE(specs), + exp_stats, ARRAY_SIZE(exp_stats), + exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1, push_options); + + if (git_futils_readbuffer(&push_options_result, _remote_push_options_result) < 0) + cl_fail("Failed to read push options result file"); + + cl_assert_equal_strn(expected_option, git_str_cstr(&push_options_result), + strlen(expected_option)); + + git_str_dispose(&push_options_result); +} + +void test_online_push__options(void) +{ + char *push_options_string_args_test_1[1] = { "test_string" }; + git_strarray push_options_test_1 = { push_options_string_args_test_1, 1 }; + + char *push_options_string_args_test_2[2] = { "test_string", "another arg?" }; + git_strarray push_options_test_2 = { push_options_string_args_test_2, 2 }; + + char *push_options_string_args_test_3[1] = { "👨🏿‍💻 but can it do unicode? 🇺🇦" }; + git_strarray push_options_test_3 = { push_options_string_args_test_3, 1 }; + + char *push_options_string_args_test_4[3] = { "\0", "\0", "\0" }; + git_strarray push_options_test_4 = { push_options_string_args_test_4, 3 }; + + push_option_test(push_options_test_1, "test_string"); + push_option_test(push_options_test_2, "test_stringanother arg?"); + push_option_test(push_options_test_3, "👨🏿‍💻 but can it do unicode? 🇺🇦"); + push_option_test(push_options_test_4, "\0\0\0"); } void test_online_push__delete(void) @@ -790,9 +860,10 @@ void test_online_push__delete(void) /* Force has no effect for delete. */ const char *specs_delete_force[] = { "+:refs/heads/tgt1" }; + git_strarray push_options = { 0 }; do_push(specs1, ARRAY_SIZE(specs1), exp_stats1, ARRAY_SIZE(exp_stats1), - exp_refs1, ARRAY_SIZE(exp_refs1), 0, 1, 1); + exp_refs1, ARRAY_SIZE(exp_refs1), 0, 1, 1, push_options); /* When deleting a non-existent branch, the git client sends zero for both * the old and new commit id. This should succeed on the server with the @@ -802,23 +873,25 @@ void test_online_push__delete(void) */ do_push(specs_del_fake, ARRAY_SIZE(specs_del_fake), exp_stats_fake, 1, - exp_refs1, ARRAY_SIZE(exp_refs1), 0, 0, 0); + exp_refs1, ARRAY_SIZE(exp_refs1), 0, 0, 0, push_options); + do_push(specs_del_fake_force, ARRAY_SIZE(specs_del_fake_force), exp_stats_fake, 1, - exp_refs1, ARRAY_SIZE(exp_refs1), 0, 0, 0); + exp_refs1, ARRAY_SIZE(exp_refs1), 0, 0, 0, push_options); /* Delete one of the pushed branches. */ do_push(specs_delete, ARRAY_SIZE(specs_delete), exp_stats_delete, ARRAY_SIZE(exp_stats_delete), - exp_refs_delete, ARRAY_SIZE(exp_refs_delete), 0, 0, 0); + exp_refs_delete, ARRAY_SIZE(exp_refs_delete), 0, 0, 0, push_options); /* Re-push branches and retry delete with force. */ do_push(specs1, ARRAY_SIZE(specs1), exp_stats1, ARRAY_SIZE(exp_stats1), - exp_refs1, ARRAY_SIZE(exp_refs1), 0, 0, 0); + exp_refs1, ARRAY_SIZE(exp_refs1), 0, 0, 0, push_options); + do_push(specs_delete_force, ARRAY_SIZE(specs_delete_force), exp_stats_delete, ARRAY_SIZE(exp_stats_delete), - exp_refs_delete, ARRAY_SIZE(exp_refs_delete), 0, 0, 0); + exp_refs_delete, ARRAY_SIZE(exp_refs_delete), 0, 0, 0, push_options); } void test_online_push__bad_refspecs(void) @@ -845,15 +918,17 @@ void test_online_push__expressions(void) const char *specs_left_expr[] = { "refs/heads/b2~1:refs/heads/b2" }; /* TODO: Find a more precise way of checking errors than a exit code of -1. */ + git_strarray push_options = { 0 }; do_push(specs_left_expr, ARRAY_SIZE(specs_left_expr), NULL, 0, - NULL, 0, -1, 0, 0); + NULL, 0, -1, 0, 0, push_options); } void test_online_push__notes(void) { git_oid note_oid, *target_oid, expected_oid; git_signature *signature; + git_strarray push_options = { 0 }; const char *specs[] = { "refs/notes/commits:refs/notes/commits" }; push_status exp_stats[] = { { "refs/notes/commits", 1 } }; expected_ref exp_refs[] = { { "refs/notes/commits", &expected_oid } }; @@ -869,13 +944,13 @@ void test_online_push__notes(void) do_push(specs, ARRAY_SIZE(specs), exp_stats, ARRAY_SIZE(exp_stats), - exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1); + exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1, push_options); /* And make sure to delete the note */ do_push(specs_del, ARRAY_SIZE(specs_del), exp_stats, 1, - NULL, 0, 0, 0, 0); + NULL, 0, 0, 0, 0, push_options); git_signature_free(signature); } @@ -885,6 +960,7 @@ void test_online_push__configured(void) git_oid note_oid, *target_oid, expected_oid; git_signature *signature; git_remote *old_remote; + git_strarray push_options = { 0 }; const char *specs[] = { "refs/notes/commits:refs/notes/commits" }; push_status exp_stats[] = { { "refs/notes/commits", 1 } }; expected_ref exp_refs[] = { { "refs/notes/commits", &expected_oid } }; @@ -905,13 +981,13 @@ void test_online_push__configured(void) do_push(NULL, 0, exp_stats, ARRAY_SIZE(exp_stats), - exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1); + exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1, push_options); /* And make sure to delete the note */ do_push(specs_del, ARRAY_SIZE(specs_del), exp_stats, 1, - NULL, 0, 0, 0, 0); + NULL, 0, 0, 0, 0, push_options); git_signature_free(signature); } From 655158fa7a28c5ba76f455d5f46c9ea8b94faf74 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 2 Feb 2023 07:54:16 -0500 Subject: [PATCH 094/608] Add OpenSSL deprection warning Add `OPENSSL_API_COMPAT=0x10100000L` since we use the now-deprecated low-level hash functions. --- deps/ntlmclient/CMakeLists.txt | 2 ++ src/util/CMakeLists.txt | 2 ++ 2 files changed, 4 insertions(+) diff --git a/deps/ntlmclient/CMakeLists.txt b/deps/ntlmclient/CMakeLists.txt index 9c5e23d6002..8356d472367 100644 --- a/deps/ntlmclient/CMakeLists.txt +++ b/deps/ntlmclient/CMakeLists.txt @@ -20,11 +20,13 @@ if(USE_HTTPS STREQUAL "SecureTransport") set_source_files_properties("crypt_commoncrypto.c" COMPILE_FLAGS "-Wno-deprecated") elseif(USE_HTTPS STREQUAL "OpenSSL") add_definitions(-DCRYPT_OPENSSL) + add_definitions(-DOPENSSL_API_COMPAT=0x10100000L) include_directories(${OPENSSL_INCLUDE_DIR}) set(SRC_NTLMCLIENT_CRYPTO "crypt_openssl.c" "crypt_openssl.h") elseif(USE_HTTPS STREQUAL "OpenSSL-Dynamic") add_definitions(-DCRYPT_OPENSSL) add_definitions(-DCRYPT_OPENSSL_DYNAMIC) + add_definitions(-DOPENSSL_API_COMPAT=0x10100000L) set(SRC_NTLMCLIENT_CRYPTO "crypt_openssl.c" "crypt_openssl.h") elseif(USE_HTTPS STREQUAL "mbedTLS") add_definitions(-DCRYPT_MBEDTLS) diff --git a/src/util/CMakeLists.txt b/src/util/CMakeLists.txt index b12ce409b85..2207041ef1a 100644 --- a/src/util/CMakeLists.txt +++ b/src/util/CMakeLists.txt @@ -38,6 +38,7 @@ if(USE_SHA1 STREQUAL "CollisionDetection") target_compile_definitions(util PRIVATE SHA1DC_CUSTOM_INCLUDE_SHA1_C=\"git2_util.h\") target_compile_definitions(util PRIVATE SHA1DC_CUSTOM_INCLUDE_UBC_CHECK_C=\"git2_util.h\") elseif(USE_SHA1 STREQUAL "OpenSSL" OR USE_SHA1 STREQUAL "OpenSSL-Dynamic") + add_definitions(-DOPENSSL_API_COMPAT=0x10100000L) file(GLOB UTIL_SRC_SHA1 hash/openssl.*) elseif(USE_SHA1 STREQUAL "CommonCrypto") file(GLOB UTIL_SRC_SHA1 hash/common_crypto.*) @@ -54,6 +55,7 @@ list(SORT UTIL_SRC_SHA1) if(USE_SHA256 STREQUAL "Builtin") file(GLOB UTIL_SRC_SHA256 hash/builtin.* hash/rfc6234/*) elseif(USE_SHA256 STREQUAL "OpenSSL" OR USE_SHA256 STREQUAL "OpenSSL-Dynamic") + add_definitions(-DOPENSSL_API_COMPAT=0x10100000L) file(GLOB UTIL_SRC_SHA256 hash/openssl.*) elseif(USE_SHA256 STREQUAL "CommonCrypto") file(GLOB UTIL_SRC_SHA256 hash/common_crypto.*) From 9a9863645de0c750525a4119bbd3534e231d7360 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sun, 22 Jan 2023 15:33:01 +0000 Subject: [PATCH 095/608] sysdir: move windows sysdir functions out of shared util The windows sysdir functions are libgit2-specific and for git compatibility only; remove them from the shared util directory and bring them into the libgit2 source tree. --- src/libgit2/sysdir.c | 275 +++++++++++++++++++++++++++++- src/libgit2/sysdir.h | 6 + src/util/futils.c | 3 - src/util/win32/findfile.c | 286 -------------------------------- src/util/win32/findfile.h | 22 --- tests/libgit2/win32/systemdir.c | 1 - 6 files changed, 275 insertions(+), 318 deletions(-) delete mode 100644 src/util/win32/findfile.c delete mode 100644 src/util/win32/findfile.h diff --git a/src/libgit2/sysdir.c b/src/libgit2/sysdir.c index 450cb509b81..8456f47a99c 100644 --- a/src/libgit2/sysdir.c +++ b/src/libgit2/sysdir.c @@ -12,16 +12,262 @@ #include "fs_path.h" #include #if GIT_WIN32 -#include "win32/findfile.h" +# include "fs_path.h" +# include "win32/path_w32.h" +# include "win32/utf-conv.h" #else -#include -#include +# include +# include #endif +#ifdef GIT_WIN32 +# define REG_GITFORWINDOWS_KEY L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\Git_is1" +# define REG_GITFORWINDOWS_KEY_WOW64 L"SOFTWARE\\Wow6432Node\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\Git_is1" + +static int expand_win32_path(git_win32_path dest, const wchar_t *src) +{ + DWORD len = ExpandEnvironmentStringsW(src, dest, GIT_WIN_PATH_UTF16); + + if (!len || len > GIT_WIN_PATH_UTF16) + return -1; + + return 0; +} + +static int win32_path_to_utf8(git_str *dest, const wchar_t *src) +{ + git_win32_utf8_path utf8_path; + + if (git_win32_path_to_utf8(utf8_path, src) < 0) { + git_error_set(GIT_ERROR_OS, "unable to convert path to UTF-8"); + return -1; + } + + /* Convert backslashes to forward slashes */ + git_fs_path_mkposix(utf8_path); + + return git_str_sets(dest, utf8_path); +} + +static git_win32_path mock_registry; +static bool mock_registry_set; + +extern int git_win32__set_registry_system_dir(const wchar_t *mock_sysdir) +{ + if (!mock_sysdir) { + mock_registry[0] = L'\0'; + mock_registry_set = false; + } else { + size_t len = wcslen(mock_sysdir); + + if (len > GIT_WIN_PATH_MAX) { + git_error_set(GIT_ERROR_INVALID, "mock path too long"); + return -1; + } + + wcscpy(mock_registry, mock_sysdir); + mock_registry_set = true; + } + + return 0; +} + +static int lookup_registry_key( + git_win32_path out, + const HKEY hive, + const wchar_t* key, + const wchar_t *value) +{ + HKEY hkey; + DWORD type, size; + int error = GIT_ENOTFOUND; + + /* + * Registry data may not be NUL terminated, provide room to do + * it ourselves. + */ + size = (DWORD)((sizeof(git_win32_path) - 1) * sizeof(wchar_t)); + + if (RegOpenKeyExW(hive, key, 0, KEY_READ, &hkey) != 0) + return GIT_ENOTFOUND; + + if (RegQueryValueExW(hkey, value, NULL, &type, (LPBYTE)out, &size) == 0 && + type == REG_SZ && + size > 0 && + size < sizeof(git_win32_path)) { + size_t wsize = size / sizeof(wchar_t); + size_t len = wsize - 1; + + if (out[wsize - 1] != L'\0') { + len = wsize; + out[wsize] = L'\0'; + } + + if (out[len - 1] == L'\\') + out[len - 1] = L'\0'; + + if (_waccess(out, F_OK) == 0) + error = 0; + } + + RegCloseKey(hkey); + return error; +} + +static int find_sysdir_in_registry(git_win32_path out) +{ + if (mock_registry_set) { + if (mock_registry[0] == L'\0') + return GIT_ENOTFOUND; + + wcscpy(out, mock_registry); + return 0; + } + + if (lookup_registry_key(out, HKEY_CURRENT_USER, REG_GITFORWINDOWS_KEY, L"InstallLocation") == 0 || + lookup_registry_key(out, HKEY_CURRENT_USER, REG_GITFORWINDOWS_KEY_WOW64, L"InstallLocation") == 0 || + lookup_registry_key(out, HKEY_LOCAL_MACHINE, REG_GITFORWINDOWS_KEY, L"InstallLocation") == 0 || + lookup_registry_key(out, HKEY_LOCAL_MACHINE, REG_GITFORWINDOWS_KEY_WOW64, L"InstallLocation") == 0) + return 0; + + return GIT_ENOTFOUND; +} + +static int find_sysdir_in_path(git_win32_path out) +{ + size_t out_len; + + if (git_win32_path_find_executable(out, L"git.exe") < 0 && + git_win32_path_find_executable(out, L"git.cmd") < 0) + return GIT_ENOTFOUND; + + out_len = wcslen(out); + + /* Trim the file name */ + if (out_len <= CONST_STRLEN(L"git.exe")) + return GIT_ENOTFOUND; + + out_len -= CONST_STRLEN(L"git.exe"); + + if (out_len && out[out_len - 1] == L'\\') + out_len--; + + /* + * Git for Windows usually places the command in a 'bin' or + * 'cmd' directory, trim that. + */ + if (out_len >= CONST_STRLEN(L"\\bin") && + wcsncmp(&out[out_len - CONST_STRLEN(L"\\bin")], L"\\bin", CONST_STRLEN(L"\\bin")) == 0) + out_len -= CONST_STRLEN(L"\\bin"); + else if (out_len >= CONST_STRLEN(L"\\cmd") && + wcsncmp(&out[out_len - CONST_STRLEN(L"\\cmd")], L"\\cmd", CONST_STRLEN(L"\\cmd")) == 0) + out_len -= CONST_STRLEN(L"\\cmd"); + + if (!out_len) + return GIT_ENOTFOUND; + + out[out_len] = L'\0'; + return 0; +} + +static int find_win32_dirs( + git_str *out, + const wchar_t* tmpl[]) +{ + git_win32_path path16; + git_str buf = GIT_STR_INIT; + + git_str_clear(out); + + for (; *tmpl != NULL; tmpl++) { + if (!expand_win32_path(path16, *tmpl) && + path16[0] != L'%' && + !_waccess(path16, F_OK)) { + win32_path_to_utf8(&buf, path16); + + if (buf.size) + git_str_join(out, GIT_PATH_LIST_SEPARATOR, out->ptr, buf.ptr); + } + } + + git_str_dispose(&buf); + + return (git_str_oom(out) ? -1 : 0); +} + +static int append_subdir(git_str *out, git_str *path, const char *subdir) +{ + static const char* architecture_roots[] = { + "", + "mingw64", + "mingw32", + NULL + }; + const char **root; + size_t orig_path_len = path->size; + + for (root = architecture_roots; *root; root++) { + if ((*root[0] && git_str_joinpath(path, path->ptr, *root) < 0) || + git_str_joinpath(path, path->ptr, subdir) < 0) + return -1; + + if (git_fs_path_exists(path->ptr) && + git_str_join(out, GIT_PATH_LIST_SEPARATOR, out->ptr, path->ptr) < 0) + return -1; + + git_str_truncate(path, orig_path_len); + } + + return 0; +} + +int git_win32__find_system_dirs(git_str *out, const char *subdir) +{ + git_win32_path pathdir, regdir; + git_str path8 = GIT_STR_INIT; + bool has_pathdir, has_regdir; + int error; + + has_pathdir = (find_sysdir_in_path(pathdir) == 0); + has_regdir = (find_sysdir_in_registry(regdir) == 0); + + if (!has_pathdir && !has_regdir) + return 0; + + /* + * Usually the git in the path is the same git in the registry, + * in this case there's no need to duplicate the paths. + */ + if (has_pathdir && has_regdir && wcscmp(pathdir, regdir) == 0) + has_regdir = false; + + if (has_pathdir) { + if ((error = win32_path_to_utf8(&path8, pathdir)) < 0 || + (error = append_subdir(out, &path8, subdir)) < 0) + goto done; + } + + if (has_regdir) { + if ((error = win32_path_to_utf8(&path8, regdir)) < 0 || + (error = append_subdir(out, &path8, subdir)) < 0) + goto done; + } + +done: + git_str_dispose(&path8); + return error; +} +#endif /* WIN32 */ + static int git_sysdir_guess_programdata_dirs(git_str *out) { #ifdef GIT_WIN32 - return git_win32__find_programdata_dirs(out); + static const wchar_t *programdata_tmpls[2] = { + L"%PROGRAMDATA%\\Git", + NULL, + }; + + return find_win32_dirs(out, programdata_tmpls); #else git_str_clear(out); return 0; @@ -78,7 +324,14 @@ static int get_passwd_home(git_str *out, uid_t uid) static int git_sysdir_guess_global_dirs(git_str *out) { #ifdef GIT_WIN32 - return git_win32__find_global_dirs(out); + static const wchar_t *global_tmpls[4] = { + L"%HOME%\\", + L"%HOMEDRIVE%%HOMEPATH%\\", + L"%USERPROFILE%\\", + NULL, + }; + + return find_win32_dirs(out, global_tmpls); #else int error; uid_t uid, euid; @@ -117,7 +370,17 @@ static int git_sysdir_guess_global_dirs(git_str *out) static int git_sysdir_guess_xdg_dirs(git_str *out) { #ifdef GIT_WIN32 - return git_win32__find_xdg_dirs(out); + static const wchar_t *global_tmpls[7] = { + L"%XDG_CONFIG_HOME%\\git", + L"%APPDATA%\\git", + L"%LOCALAPPDATA%\\git", + L"%HOME%\\.config\\git", + L"%HOMEDRIVE%%HOMEPATH%\\.config\\git", + L"%USERPROFILE%\\.config\\git", + NULL, + }; + + return find_win32_dirs(out, global_tmpls); #else git_str env = GIT_STR_INIT; int error; diff --git a/src/libgit2/sysdir.h b/src/libgit2/sysdir.h index 568f27940c8..fde55f57a8b 100644 --- a/src/libgit2/sysdir.h +++ b/src/libgit2/sysdir.h @@ -110,4 +110,10 @@ extern int git_sysdir_set(git_sysdir_t which, const char *paths); */ extern int git_sysdir_reset(void); +/** Sets the registry system dir to a mock; for testing. */ +extern int git_win32__set_registry_system_dir(const wchar_t *mock_sysdir); + +/** Find the given system dir; for testing. */ +extern int git_win32__find_system_dirs(git_str *out, const char *subdir); + #endif diff --git a/src/util/futils.c b/src/util/futils.c index cb872de09f6..084f1cd2820 100644 --- a/src/util/futils.c +++ b/src/util/futils.c @@ -13,9 +13,6 @@ #include "rand.h" #include -#if GIT_WIN32 -#include "win32/findfile.h" -#endif #define GIT_FILEMODE_DEFAULT 0100666 diff --git a/src/util/win32/findfile.c b/src/util/win32/findfile.c deleted file mode 100644 index 725a90167f2..00000000000 --- a/src/util/win32/findfile.c +++ /dev/null @@ -1,286 +0,0 @@ -/* - * Copyright (C) the libgit2 contributors. All rights reserved. - * - * This file is part of libgit2, distributed under the GNU GPL v2 with - * a Linking Exception. For full terms see the included COPYING file. - */ - -#include "findfile.h" - -#include "path_w32.h" -#include "utf-conv.h" -#include "fs_path.h" - -#define REG_GITFORWINDOWS_KEY L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\Git_is1" -#define REG_GITFORWINDOWS_KEY_WOW64 L"SOFTWARE\\Wow6432Node\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\Git_is1" - -static int git_win32__expand_path(git_win32_path dest, const wchar_t *src) -{ - DWORD len = ExpandEnvironmentStringsW(src, dest, GIT_WIN_PATH_UTF16); - - if (!len || len > GIT_WIN_PATH_UTF16) - return -1; - - return 0; -} - -static int win32_path_to_8(git_str *dest, const wchar_t *src) -{ - git_win32_utf8_path utf8_path; - - if (git_win32_path_to_utf8(utf8_path, src) < 0) { - git_error_set(GIT_ERROR_OS, "unable to convert path to UTF-8"); - return -1; - } - - /* Convert backslashes to forward slashes */ - git_fs_path_mkposix(utf8_path); - - return git_str_sets(dest, utf8_path); -} - -static git_win32_path mock_registry; -static bool mock_registry_set; - -extern int git_win32__set_registry_system_dir(const wchar_t *mock_sysdir) -{ - if (!mock_sysdir) { - mock_registry[0] = L'\0'; - mock_registry_set = false; - } else { - size_t len = wcslen(mock_sysdir); - - if (len > GIT_WIN_PATH_MAX) { - git_error_set(GIT_ERROR_INVALID, "mock path too long"); - return -1; - } - - wcscpy(mock_registry, mock_sysdir); - mock_registry_set = true; - } - - return 0; -} - -static int lookup_registry_key( - git_win32_path out, - const HKEY hive, - const wchar_t* key, - const wchar_t *value) -{ - HKEY hkey; - DWORD type, size; - int error = GIT_ENOTFOUND; - - /* - * Registry data may not be NUL terminated, provide room to do - * it ourselves. - */ - size = (DWORD)((sizeof(git_win32_path) - 1) * sizeof(wchar_t)); - - if (RegOpenKeyExW(hive, key, 0, KEY_READ, &hkey) != 0) - return GIT_ENOTFOUND; - - if (RegQueryValueExW(hkey, value, NULL, &type, (LPBYTE)out, &size) == 0 && - type == REG_SZ && - size > 0 && - size < sizeof(git_win32_path)) { - size_t wsize = size / sizeof(wchar_t); - size_t len = wsize - 1; - - if (out[wsize - 1] != L'\0') { - len = wsize; - out[wsize] = L'\0'; - } - - if (out[len - 1] == L'\\') - out[len - 1] = L'\0'; - - if (_waccess(out, F_OK) == 0) - error = 0; - } - - RegCloseKey(hkey); - return error; -} - -static int find_sysdir_in_registry(git_win32_path out) -{ - if (mock_registry_set) { - if (mock_registry[0] == L'\0') - return GIT_ENOTFOUND; - - wcscpy(out, mock_registry); - return 0; - } - - if (lookup_registry_key(out, HKEY_CURRENT_USER, REG_GITFORWINDOWS_KEY, L"InstallLocation") == 0 || - lookup_registry_key(out, HKEY_CURRENT_USER, REG_GITFORWINDOWS_KEY_WOW64, L"InstallLocation") == 0 || - lookup_registry_key(out, HKEY_LOCAL_MACHINE, REG_GITFORWINDOWS_KEY, L"InstallLocation") == 0 || - lookup_registry_key(out, HKEY_LOCAL_MACHINE, REG_GITFORWINDOWS_KEY_WOW64, L"InstallLocation") == 0) - return 0; - - return GIT_ENOTFOUND; -} - -static int find_sysdir_in_path(git_win32_path out) -{ - size_t out_len; - - if (git_win32_path_find_executable(out, L"git.exe") < 0 && - git_win32_path_find_executable(out, L"git.cmd") < 0) - return GIT_ENOTFOUND; - - out_len = wcslen(out); - - /* Trim the file name */ - if (out_len <= CONST_STRLEN(L"git.exe")) - return GIT_ENOTFOUND; - - out_len -= CONST_STRLEN(L"git.exe"); - - if (out_len && out[out_len - 1] == L'\\') - out_len--; - - /* - * Git for Windows usually places the command in a 'bin' or - * 'cmd' directory, trim that. - */ - if (out_len >= CONST_STRLEN(L"\\bin") && - wcsncmp(&out[out_len - CONST_STRLEN(L"\\bin")], L"\\bin", CONST_STRLEN(L"\\bin")) == 0) - out_len -= CONST_STRLEN(L"\\bin"); - else if (out_len >= CONST_STRLEN(L"\\cmd") && - wcsncmp(&out[out_len - CONST_STRLEN(L"\\cmd")], L"\\cmd", CONST_STRLEN(L"\\cmd")) == 0) - out_len -= CONST_STRLEN(L"\\cmd"); - - if (!out_len) - return GIT_ENOTFOUND; - - out[out_len] = L'\0'; - return 0; -} - -static int win32_find_existing_dirs( - git_str* out, - const wchar_t* tmpl[]) -{ - git_win32_path path16; - git_str buf = GIT_STR_INIT; - - git_str_clear(out); - - for (; *tmpl != NULL; tmpl++) { - if (!git_win32__expand_path(path16, *tmpl) && - path16[0] != L'%' && - !_waccess(path16, F_OK)) { - win32_path_to_8(&buf, path16); - - if (buf.size) - git_str_join(out, GIT_PATH_LIST_SEPARATOR, out->ptr, buf.ptr); - } - } - - git_str_dispose(&buf); - - return (git_str_oom(out) ? -1 : 0); -} - -static int append_subdir(git_str *out, git_str *path, const char *subdir) -{ - static const char* architecture_roots[] = { - "", - "mingw64", - "mingw32", - NULL - }; - const char **root; - size_t orig_path_len = path->size; - - for (root = architecture_roots; *root; root++) { - if ((*root[0] && git_str_joinpath(path, path->ptr, *root) < 0) || - git_str_joinpath(path, path->ptr, subdir) < 0) - return -1; - - if (git_fs_path_exists(path->ptr) && - git_str_join(out, GIT_PATH_LIST_SEPARATOR, out->ptr, path->ptr) < 0) - return -1; - - git_str_truncate(path, orig_path_len); - } - - return 0; -} - -int git_win32__find_system_dirs(git_str *out, const char *subdir) -{ - git_win32_path pathdir, regdir; - git_str path8 = GIT_STR_INIT; - bool has_pathdir, has_regdir; - int error; - - has_pathdir = (find_sysdir_in_path(pathdir) == 0); - has_regdir = (find_sysdir_in_registry(regdir) == 0); - - if (!has_pathdir && !has_regdir) - return 0; - - /* - * Usually the git in the path is the same git in the registry, - * in this case there's no need to duplicate the paths. - */ - if (has_pathdir && has_regdir && wcscmp(pathdir, regdir) == 0) - has_regdir = false; - - if (has_pathdir) { - if ((error = win32_path_to_8(&path8, pathdir)) < 0 || - (error = append_subdir(out, &path8, subdir)) < 0) - goto done; - } - - if (has_regdir) { - if ((error = win32_path_to_8(&path8, regdir)) < 0 || - (error = append_subdir(out, &path8, subdir)) < 0) - goto done; - } - -done: - git_str_dispose(&path8); - return error; -} - -int git_win32__find_global_dirs(git_str *out) -{ - static const wchar_t *global_tmpls[4] = { - L"%HOME%\\", - L"%HOMEDRIVE%%HOMEPATH%\\", - L"%USERPROFILE%\\", - NULL, - }; - - return win32_find_existing_dirs(out, global_tmpls); -} - -int git_win32__find_xdg_dirs(git_str *out) -{ - static const wchar_t *global_tmpls[7] = { - L"%XDG_CONFIG_HOME%\\git", - L"%APPDATA%\\git", - L"%LOCALAPPDATA%\\git", - L"%HOME%\\.config\\git", - L"%HOMEDRIVE%%HOMEPATH%\\.config\\git", - L"%USERPROFILE%\\.config\\git", - NULL, - }; - - return win32_find_existing_dirs(out, global_tmpls); -} - -int git_win32__find_programdata_dirs(git_str *out) -{ - static const wchar_t *programdata_tmpls[2] = { - L"%PROGRAMDATA%\\Git", - NULL, - }; - - return win32_find_existing_dirs(out, programdata_tmpls); -} diff --git a/src/util/win32/findfile.h b/src/util/win32/findfile.h deleted file mode 100644 index 7b191d1feff..00000000000 --- a/src/util/win32/findfile.h +++ /dev/null @@ -1,22 +0,0 @@ -/* - * Copyright (C) the libgit2 contributors. All rights reserved. - * - * This file is part of libgit2, distributed under the GNU GPL v2 with - * a Linking Exception. For full terms see the included COPYING file. - */ - -#ifndef INCLUDE_win32_findfile_h__ -#define INCLUDE_win32_findfile_h__ - -#include "git2_util.h" - -/** Sets the mock registry root for Git for Windows for testing. */ -extern int git_win32__set_registry_system_dir(const wchar_t *mock_sysdir); - -extern int git_win32__find_system_dirs(git_str *out, const char *subpath); -extern int git_win32__find_global_dirs(git_str *out); -extern int git_win32__find_xdg_dirs(git_str *out); -extern int git_win32__find_programdata_dirs(git_str *out); - -#endif - diff --git a/tests/libgit2/win32/systemdir.c b/tests/libgit2/win32/systemdir.c index 52c1784a1b7..9039f05b21a 100644 --- a/tests/libgit2/win32/systemdir.c +++ b/tests/libgit2/win32/systemdir.c @@ -1,7 +1,6 @@ #include "clar_libgit2.h" #include "futils.h" #include "sysdir.h" -#include "win32/findfile.h" #ifdef GIT_WIN32 static char *path_save; From bce17198f561ed85c0788adc8f0a3259a18a545d Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sun, 22 Jan 2023 15:23:10 +0000 Subject: [PATCH 096/608] sysdir: provide actual home directory Provide a mechanism to look up the user's home directory, using the same mechanism that we use for locating the global configuration path (a fancy name for saying "the home directory"). SSH known hosts lookups now use this, instead of simply looking at the HOME environment variable, to support Windows-style home directory lookups in `HOME`, `HOMEPATH`, or `USERPROFILE`. --- src/libgit2/sysdir.c | 26 +++++++++++++++++++++++++- src/libgit2/sysdir.h | 42 +++++++++++++++++++++++++++++++++--------- 2 files changed, 58 insertions(+), 10 deletions(-) diff --git a/src/libgit2/sysdir.c b/src/libgit2/sysdir.c index 8456f47a99c..7838a6789c5 100644 --- a/src/libgit2/sysdir.c +++ b/src/libgit2/sysdir.c @@ -321,7 +321,7 @@ static int get_passwd_home(git_str *out, uid_t uid) } #endif -static int git_sysdir_guess_global_dirs(git_str *out) +static int git_sysdir_guess_home_dirs(git_str *out) { #ifdef GIT_WIN32 static const wchar_t *global_tmpls[4] = { @@ -367,6 +367,11 @@ static int git_sysdir_guess_global_dirs(git_str *out) #endif } +static int git_sysdir_guess_global_dirs(git_str *out) +{ + return git_sysdir_guess_home_dirs(out); +} + static int git_sysdir_guess_xdg_dirs(git_str *out) { #ifdef GIT_WIN32 @@ -434,6 +439,7 @@ static struct git_sysdir__dir git_sysdir__dirs[] = { { GIT_STR_INIT, git_sysdir_guess_xdg_dirs }, { GIT_STR_INIT, git_sysdir_guess_programdata_dirs }, { GIT_STR_INIT, git_sysdir_guess_template_dirs }, + { GIT_STR_INIT, git_sysdir_guess_home_dirs } }; static void git_sysdir_global_shutdown(void) @@ -613,6 +619,12 @@ int git_sysdir_find_template_dir(git_str *path) path, NULL, GIT_SYSDIR_TEMPLATE, "template"); } +int git_sysdir_find_homedir(git_str *path) +{ + return git_sysdir_find_in_dirlist( + path, NULL, GIT_SYSDIR_HOME, "home directory"); +} + int git_sysdir_expand_global_file(git_str *path, const char *filename) { int error; @@ -624,3 +636,15 @@ int git_sysdir_expand_global_file(git_str *path, const char *filename) return error; } + +int git_sysdir_expand_homedir_file(git_str *path, const char *filename) +{ + int error; + + if ((error = git_sysdir_find_homedir(path)) == 0) { + if (filename) + error = git_str_joinpath(path, path->ptr, filename); + } + + return error; +} diff --git a/src/libgit2/sysdir.h b/src/libgit2/sysdir.h index fde55f57a8b..1d15bbf43dd 100644 --- a/src/libgit2/sysdir.h +++ b/src/libgit2/sysdir.h @@ -57,10 +57,22 @@ extern int git_sysdir_find_programdata_file(git_str *path, const char *filename) extern int git_sysdir_find_template_dir(git_str *path); /** - * Expand the name of a "global" file (i.e. one in a user's home - * directory). Unlike `find_global_file` (above), this makes no - * attempt to check for the existence of the file, and is useful if - * you want the full path regardless of existence. + * Find the home directory. On Windows, this will look at the `HOME`, + * `HOMEPATH`, and `USERPROFILE` environment variables (in that order) + * and return the first path that is set and exists. On other systems, + * this will simply return the contents of the `HOME` environment variable. + * + * @param path buffer to write the full path into + * @return 0 if found, GIT_ENOTFOUND if not found, or -1 on other OS error + */ +extern int git_sysdir_find_homedir(git_str *path); + +/** + * Expand the name of a "global" file -- by default inside the user's + * home directory, but can be overridden by the user configuration. + * Unlike `find_global_file` (above), this makes no attempt to check + * for the existence of the file, and is useful if you want the full + * path regardless of existence. * * @param path buffer to write the full path into * @param filename name of file in the home directory @@ -68,13 +80,25 @@ extern int git_sysdir_find_template_dir(git_str *path); */ extern int git_sysdir_expand_global_file(git_str *path, const char *filename); +/** + * Expand the name of a file in the user's home directory. This + * function makes no attempt to check for the existence of the file, + * and is useful if you want the full path regardless of existence. + * + * @param path buffer to write the full path into + * @param filename name of file in the home directory + * @return 0 on success or -1 on error + */ +extern int git_sysdir_expand_homedir_file(git_str *path, const char *filename); + typedef enum { - GIT_SYSDIR_SYSTEM = 0, - GIT_SYSDIR_GLOBAL = 1, - GIT_SYSDIR_XDG = 2, + GIT_SYSDIR_SYSTEM = 0, + GIT_SYSDIR_GLOBAL = 1, + GIT_SYSDIR_XDG = 2, GIT_SYSDIR_PROGRAMDATA = 3, - GIT_SYSDIR_TEMPLATE = 4, - GIT_SYSDIR__MAX = 5 + GIT_SYSDIR_TEMPLATE = 4, + GIT_SYSDIR_HOME = 5, + GIT_SYSDIR__MAX = 6 } git_sysdir_t; /** From 00893d2f4520416a0b3de5a5f42c2ae68b7fc873 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sun, 22 Jan 2023 21:10:58 +0000 Subject: [PATCH 097/608] ssh: support windows `known_hosts` files Use `git_sysdir_find_homedir_file` to identify the path to the home directory's `.ssh/known_hosts`; this takes Windows paths into account by preferring `HOME`, then falling back to `HOMEPATH` and `USERPROFILE` directories. --- src/libgit2/transports/ssh.c | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/src/libgit2/transports/ssh.c b/src/libgit2/transports/ssh.c index 85e779744d2..d9d43ad657d 100644 --- a/src/libgit2/transports/ssh.c +++ b/src/libgit2/transports/ssh.c @@ -16,6 +16,7 @@ #include "netops.h" #include "smart.h" #include "streams/socket.h" +#include "sysdir.h" #include "git2/credential.h" #include "git2/sys/credential.h" @@ -421,7 +422,8 @@ static int request_creds(git_credential **out, ssh_subtransport *t, const char * return 0; } -#define KNOWN_HOSTS_FILE ".ssh/known_hosts" +#define SSH_DIR ".ssh" +#define KNOWN_HOSTS_FILE "known_hosts" /* * Load the known_hosts file. @@ -430,16 +432,14 @@ static int request_creds(git_credential **out, ssh_subtransport *t, const char * */ static int load_known_hosts(LIBSSH2_KNOWNHOSTS **hosts, LIBSSH2_SESSION *session) { - git_str path = GIT_STR_INIT, home = GIT_STR_INIT; + git_str path = GIT_STR_INIT, sshdir = GIT_STR_INIT; LIBSSH2_KNOWNHOSTS *known_hosts = NULL; int error; GIT_ASSERT_ARG(hosts); - if ((error = git__getenv(&home, "HOME")) < 0) - return error; - - if ((error = git_str_joinpath(&path, git_str_cstr(&home), KNOWN_HOSTS_FILE)) < 0) + if ((error = git_sysdir_expand_homedir_file(&sshdir, SSH_DIR)) < 0 || + (error = git_str_joinpath(&path, git_str_cstr(&sshdir), KNOWN_HOSTS_FILE)) < 0) goto out; if ((known_hosts = libssh2_knownhost_init(session)) == NULL) { @@ -461,8 +461,8 @@ static int load_known_hosts(LIBSSH2_KNOWNHOSTS **hosts, LIBSSH2_SESSION *session out: *hosts = known_hosts; - git_str_clear(&home); - git_str_clear(&path); + git_str_dispose(&sshdir); + git_str_dispose(&path); return error; } From 523d8b64ba06cfd89fc0b4be2949cd4ed43e4cc7 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Tue, 24 Jan 2023 11:50:31 +0000 Subject: [PATCH 098/608] ssh: give a realistic error message I spent an hour banging my head against this, when it was because the remote didn't trust my key. --- src/libgit2/transports/ssh.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/libgit2/transports/ssh.c b/src/libgit2/transports/ssh.c index d9d43ad657d..a7cdf1d0db8 100644 --- a/src/libgit2/transports/ssh.c +++ b/src/libgit2/transports/ssh.c @@ -753,7 +753,7 @@ static int check_certificate( if (error == GIT_PASSTHROUGH) { error = git_error_state_restore(&previous_error); } else if (error < 0 && !git_error_last()) { - git_error_set(GIT_ERROR_NET, "user canceled hostkey check"); + git_error_set(GIT_ERROR_NET, "unknown remote host key"); } git_error_state_free(&previous_error); @@ -1009,7 +1009,7 @@ static int list_auth_methods(int *out, LIBSSH2_SESSION *session, const char *use /* either error, or the remote accepts NONE auth, which is bizarre, let's punt */ if (list == NULL && !libssh2_userauth_authenticated(session)) { - ssh_error(session, "Failed to retrieve list of SSH authentication methods"); + ssh_error(session, "remote rejected authentication"); return GIT_EAUTH; } From 2d08ead9c34317b6727d13d3a4a2a46d429557cb Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 23 Jan 2023 13:00:01 +0000 Subject: [PATCH 099/608] attr: use home directory for `~` includes Users can specify an attribute file to be included in the home directory using `~/filename` syntax. Instead of looking in the global configuration location (which may be overridden), use the user's _actual_ home directory. This allows callers to change the global configuration location separately from the home directory. --- src/libgit2/attrcache.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/libgit2/attrcache.c b/src/libgit2/attrcache.c index b16d95c3c02..405944ed156 100644 --- a/src/libgit2/attrcache.c +++ b/src/libgit2/attrcache.c @@ -300,7 +300,7 @@ static int attr_cache__lookup_path( /* expand leading ~/ as needed */ if (cfgval && cfgval[0] == '~' && cfgval[1] == '/') { - if (! (error = git_sysdir_expand_global_file(&buf, &cfgval[2]))) + if (! (error = git_sysdir_expand_homedir_file(&buf, &cfgval[2]))) *out = git_str_detach(&buf); } else if (cfgval) { *out = git__strdup(cfgval); From cdf5ae9ff6aab6655a1cc361e998462f260bcf0b Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 23 Jan 2023 13:00:32 +0000 Subject: [PATCH 100/608] config: use home directory for `~` includes Users can specify a config file to be included in the home directory using `~/filename` syntax. Instead of looking in the global configuration location (which may be overridden), use the user's _actual_ home directory. This allows callers to change the global configuration location separately from the home directory. --- src/libgit2/config.c | 2 +- src/libgit2/config_file.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/libgit2/config.c b/src/libgit2/config.c index 5c366e22189..6d15a8db6d4 100644 --- a/src/libgit2/config.c +++ b/src/libgit2/config.c @@ -860,7 +860,7 @@ static int git_config__parse_path(git_str *out, const char *value) return -1; } - return git_sysdir_expand_global_file(out, value[1] ? &value[2] : NULL); + return git_sysdir_expand_homedir_file(out, value[1] ? &value[2] : NULL); } return git_str_sets(out, value); diff --git a/src/libgit2/config_file.c b/src/libgit2/config_file.c index 66fcb8ae295..932ca76014e 100644 --- a/src/libgit2/config_file.c +++ b/src/libgit2/config_file.c @@ -528,7 +528,7 @@ static int included_path(git_str *out, const char *dir, const char *path) { /* From the user's home */ if (path[0] == '~' && path[1] == '/') - return git_sysdir_expand_global_file(out, &path[1]); + return git_sysdir_expand_homedir_file(out, &path[1]); return git_fs_path_join_unrooted(out, path, dir, NULL); } @@ -616,7 +616,7 @@ static int do_match_gitdir( git_fs_path_dirname_r(&pattern, cfg_file); git_str_joinpath(&pattern, pattern.ptr, condition + 2); } else if (condition[0] == '~' && git_fs_path_is_dirsep(condition[1])) - git_sysdir_expand_global_file(&pattern, condition + 1); + git_sysdir_expand_homedir_file(&pattern, condition + 1); else if (!git_fs_path_is_absolute(condition)) git_str_joinpath(&pattern, "**", condition); else From 894543827d7ad62c7b70901e949305beea34cdbd Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 23 Jan 2023 15:46:14 +0000 Subject: [PATCH 101/608] core: allow users to configure home directory Some callers -- like our test suite and the test suites of our language bindings -- want to isolate the home directory to avoid accidentally including the executing user's actual home directory data. Previously, we combined the notion of a home directory and global configuration -- now that this is separated, we provide users the ability to configure both. --- include/git2/common.h | 14 +++++++++++++- src/libgit2/libgit2.c | 19 +++++++++++++++++++ 2 files changed, 32 insertions(+), 1 deletion(-) diff --git a/include/git2/common.h b/include/git2/common.h index ccf66334a66..f968deb233a 100644 --- a/include/git2/common.h +++ b/include/git2/common.h @@ -222,7 +222,9 @@ typedef enum { GIT_OPT_GET_EXTENSIONS, GIT_OPT_SET_EXTENSIONS, GIT_OPT_GET_OWNER_VALIDATION, - GIT_OPT_SET_OWNER_VALIDATION + GIT_OPT_SET_OWNER_VALIDATION, + GIT_OPT_GET_HOMEDIR, + GIT_OPT_SET_HOMEDIR } git_libgit2_opt_t; /** @@ -468,6 +470,16 @@ typedef enum { * > Set that repository directories should be owned by the current * > user. The default is to validate ownership. * + * opts(GIT_OPT_GET_HOMEDIR, git_buf *out) + * > Gets the current user's home directory, as it will be used + * > for file lookups. The path is written to the `out` buffer. + * + * opts(GIT_OPT_SET_HOMEDIR, const char *path) + * > Sets the directory used as the current user's home directory, + * > for file lookups. + * > + * > - `path` directory of home directory. + * * @param option Option key * @param ... value to set the option * @return 0 on success, <0 on failure diff --git a/src/libgit2/libgit2.c b/src/libgit2/libgit2.c index 2fda0722ece..f225122e548 100644 --- a/src/libgit2/libgit2.c +++ b/src/libgit2/libgit2.c @@ -414,6 +414,25 @@ int git_libgit2_opts(int key, ...) git_repository__validate_ownership = (va_arg(ap, int) != 0); break; + case GIT_OPT_GET_HOMEDIR: + { + git_buf *out = va_arg(ap, git_buf *); + git_str str = GIT_STR_INIT; + const git_str *tmp; + + if ((error = git_buf_tostr(&str, out)) < 0 || + (error = git_sysdir_get(&tmp, GIT_SYSDIR_HOME)) < 0 || + (error = git_str_put(&str, tmp->ptr, tmp->size)) < 0) + break; + + error = git_buf_fromstr(out, &str); + } + break; + + case GIT_OPT_SET_HOMEDIR: + error = git_sysdir_set(GIT_SYSDIR_HOME, va_arg(ap, const char *)); + break; + default: git_error_set(GIT_ERROR_INVALID, "invalid option key"); error = -1; From f32ec999b0dfcef6ac53afb754f21c5a758057a8 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 23 Jan 2023 15:49:09 +0000 Subject: [PATCH 102/608] tests: configure temporary homedirs correctly Now that we've split the notion of the home directory from the global configuration store, our tests should use the appropriate one based on what they're doing. --- tests/clar/clar_libgit2.c | 71 ++++++++++++++++++++++++++------ tests/clar/clar_libgit2.h | 20 ++++++--- tests/libgit2/config/include.c | 12 +++++- tests/libgit2/config/read.c | 9 +--- tests/libgit2/ignore/path.c | 10 +++-- tests/libgit2/ignore/status.c | 8 +++- tests/libgit2/remote/httpproxy.c | 4 +- 7 files changed, 98 insertions(+), 36 deletions(-) diff --git a/tests/clar/clar_libgit2.c b/tests/clar/clar_libgit2.c index 783b457f958..cc953915da7 100644 --- a/tests/clar/clar_libgit2.c +++ b/tests/clar/clar_libgit2.c @@ -1,6 +1,7 @@ #include "clar_libgit2.h" #include "posix.h" #include "fs_path.h" +#include "futils.h" #include "git2/sys/repository.h" void cl_git_report_failure( @@ -548,33 +549,77 @@ void clar__assert_equal_file( (size_t)expected_bytes, (size_t)total_bytes); } -static git_buf _cl_restore_home = GIT_BUF_INIT; +#define FAKE_HOMEDIR_NAME "cl_fake_home" -void cl_fake_home_cleanup(void *payload) +static git_buf _cl_restore_homedir = GIT_BUF_INIT; + +void cl_fake_homedir_cleanup(void *payload) { GIT_UNUSED(payload); - if (_cl_restore_home.ptr) { - cl_git_pass(git_libgit2_opts( - GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, _cl_restore_home.ptr)); - git_buf_dispose(&_cl_restore_home); + if (_cl_restore_homedir.ptr) { + cl_git_pass(git_futils_rmdir_r(FAKE_HOMEDIR_NAME, NULL, GIT_RMDIR_REMOVE_FILES)); + + cl_git_pass(git_libgit2_opts(GIT_OPT_SET_HOMEDIR, _cl_restore_homedir.ptr)); + git_buf_dispose(&_cl_restore_homedir); } } -void cl_fake_home(void) +void cl_fake_homedir(git_str *out) { git_str path = GIT_STR_INIT; cl_git_pass(git_libgit2_opts( - GIT_OPT_GET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, &_cl_restore_home)); + GIT_OPT_GET_HOMEDIR, &_cl_restore_homedir)); + + cl_set_cleanup(cl_fake_homedir_cleanup, NULL); + + /* TOC/TOU but merely attempts to prevent accidental cleanup. */ + cl_assert(!git_fs_path_exists(FAKE_HOMEDIR_NAME)); + cl_must_pass(p_mkdir(FAKE_HOMEDIR_NAME, 0777)); + cl_git_pass(git_fs_path_prettify(&path, FAKE_HOMEDIR_NAME, NULL)); + cl_git_pass(git_libgit2_opts(GIT_OPT_SET_HOMEDIR, path.ptr)); - cl_set_cleanup(cl_fake_home_cleanup, NULL); + if (out) + git_str_swap(out, &path); + + git_str_dispose(&path); +} + +#define FAKE_GLOBALCONFIG_NAME "cl_fake_global" + +static git_buf _cl_restore_globalconfig = GIT_BUF_INIT; + +void cl_fake_globalconfig_cleanup(void *payload) +{ + GIT_UNUSED(payload); + + if (_cl_restore_globalconfig.ptr) { + cl_git_pass(git_futils_rmdir_r(FAKE_GLOBALCONFIG_NAME, NULL, GIT_RMDIR_REMOVE_FILES)); + + cl_git_pass(git_libgit2_opts(GIT_OPT_SET_HOMEDIR, _cl_restore_globalconfig.ptr)); + git_buf_dispose(&_cl_restore_globalconfig); + } +} + +void cl_fake_globalconfig(git_str *out) +{ + git_str path = GIT_STR_INIT; - if (!git_fs_path_exists("home")) - cl_must_pass(p_mkdir("home", 0777)); - cl_git_pass(git_fs_path_prettify(&path, "home", NULL)); cl_git_pass(git_libgit2_opts( - GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, path.ptr)); + GIT_OPT_GET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, &_cl_restore_globalconfig)); + + cl_set_cleanup(cl_fake_globalconfig_cleanup, NULL); + + /* TOC/TOU but merely attempts to prevent accidental cleanup. */ + cl_assert(!git_fs_path_exists(FAKE_GLOBALCONFIG_NAME)); + cl_must_pass(p_mkdir(FAKE_GLOBALCONFIG_NAME, 0777)); + cl_git_pass(git_fs_path_prettify(&path, FAKE_GLOBALCONFIG_NAME, NULL)); + cl_git_pass(git_libgit2_opts(GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, path.ptr)); + + if (out) + git_str_swap(out, &path); + git_str_dispose(&path); } diff --git a/tests/clar/clar_libgit2.h b/tests/clar/clar_libgit2.h index d2d9da0aaf1..87f1f9bd9d4 100644 --- a/tests/clar/clar_libgit2.h +++ b/tests/clar/clar_libgit2.h @@ -233,13 +233,21 @@ int cl_repo_get_bool(git_repository *repo, const char *cfg); void cl_repo_set_string(git_repository *repo, const char *cfg, const char *value); -/* set up a fake "home" directory and set libgit2 GLOBAL search path. - * - * automatically configures cleanup function to restore the regular search - * path, although you can call it explicitly if you wish (with NULL). +/* + * set up a fake "home" directory -- automatically configures cleanup + * function to restore the home directory, although you can call it + * explicitly if you wish (with NULL). + */ +void cl_fake_homedir(git_str *); +void cl_fake_homedir_cleanup(void *); + +/* + * set up a fake global configuration directory -- automatically + * configures cleanup function to restore the global config + * although you can call it explicitly if you wish (with NULL). */ -void cl_fake_home(void); -void cl_fake_home_cleanup(void *); +void cl_fake_globalconfig(git_str *); +void cl_fake_globalconfig_cleanup(void *); void cl_sandbox_set_search_path_defaults(void); void cl_sandbox_disable_ownership_validation(void); diff --git a/tests/libgit2/config/include.c b/tests/libgit2/config/include.c index 9328f3cf649..1b55fdc86fd 100644 --- a/tests/libgit2/config/include.c +++ b/tests/libgit2/config/include.c @@ -42,8 +42,13 @@ void test_config_include__absolute(void) void test_config_include__homedir(void) { - cl_git_pass(git_libgit2_opts(GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, cl_fixture("config"))); + git_str homefile = GIT_STR_INIT; + + cl_fake_homedir(&homefile); + cl_git_pass(git_str_joinpath(&homefile, homefile.ptr, "config-included")); + cl_git_mkfile("config-include-homedir", "[include]\npath = ~/config-included"); + cl_git_mkfile(homefile.ptr, "[foo \"bar\"]\n\tbaz = huzzah\n"); cl_git_pass(git_config_open_ondisk(&cfg, "config-include-homedir")); @@ -53,6 +58,8 @@ void test_config_include__homedir(void) cl_sandbox_set_search_path_defaults(); cl_git_pass(p_unlink("config-include-homedir")); + + git_str_dispose(&homefile); } /* We need to pretend that the variables were defined where the file was included */ @@ -113,7 +120,8 @@ void test_config_include__missing(void) void test_config_include__missing_homedir(void) { - cl_git_pass(git_libgit2_opts(GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, cl_fixture("config"))); + cl_fake_homedir(NULL); + cl_git_mkfile("including", "[include]\npath = ~/.nonexistentfile\n[foo]\nbar = baz"); git_error_clear(); diff --git a/tests/libgit2/config/read.c b/tests/libgit2/config/read.c index a2e668c207b..ac6459b9ea6 100644 --- a/tests/libgit2/config/read.c +++ b/tests/libgit2/config/read.c @@ -728,14 +728,11 @@ void test_config_read__path(void) { git_config *cfg; git_buf path = GIT_BUF_INIT; - git_buf old_path = GIT_BUF_INIT; git_str home_path = GIT_STR_INIT; git_str expected_path = GIT_STR_INIT; - cl_git_pass(p_mkdir("fakehome", 0777)); - cl_git_pass(git_fs_path_prettify(&home_path, "fakehome", NULL)); - cl_git_pass(git_libgit2_opts(GIT_OPT_GET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, &old_path)); - cl_git_pass(git_libgit2_opts(GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, home_path.ptr)); + cl_fake_homedir(&home_path); + cl_git_mkfile("./testconfig", "[some]\n path = ~/somefile"); cl_git_pass(git_fs_path_join_unrooted(&expected_path, "somefile", home_path.ptr, NULL)); @@ -761,8 +758,6 @@ void test_config_read__path(void) cl_git_mkfile("./testconfig", "[some]\n path = ~user/foo"); cl_git_fail(git_config_get_path(&path, cfg, "some.path")); - cl_git_pass(git_libgit2_opts(GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, old_path.ptr)); - git_buf_dispose(&old_path); git_str_dispose(&home_path); git_str_dispose(&expected_path); git_config_free(cfg); diff --git a/tests/libgit2/ignore/path.c b/tests/libgit2/ignore/path.c index a574d1d799d..17f28bc5d89 100644 --- a/tests/libgit2/ignore/path.c +++ b/tests/libgit2/ignore/path.c @@ -286,14 +286,16 @@ void test_ignore_path__subdirectory_gitignore(void) void test_ignore_path__expand_tilde_to_homedir(void) { + git_str homefile = GIT_STR_INIT; git_config *cfg; assert_is_ignored(false, "example.global_with_tilde"); - cl_fake_home(); + cl_fake_homedir(&homefile); + cl_git_pass(git_str_joinpath(&homefile, homefile.ptr, "globalexclude")); /* construct fake home with fake global excludes */ - cl_git_mkfile("home/globalexclude", "# found me\n*.global_with_tilde\n"); + cl_git_mkfile(homefile.ptr, "# found me\n*.global_with_tilde\n"); cl_git_pass(git_repository_config(&cfg, g_repo)); cl_git_pass(git_config_set_string(cfg, "core.excludesfile", "~/globalexclude")); @@ -305,11 +307,13 @@ void test_ignore_path__expand_tilde_to_homedir(void) cl_git_pass(git_futils_rmdir_r("home", NULL, GIT_RMDIR_REMOVE_FILES)); - cl_fake_home_cleanup(NULL); + cl_fake_homedir_cleanup(NULL); git_attr_cache_flush(g_repo); /* must reset to pick up change */ assert_is_ignored(false, "example.global_with_tilde"); + + git_str_dispose(&homefile); } /* Ensure that the .gitignore in the subdirectory only affects diff --git a/tests/libgit2/ignore/status.c b/tests/libgit2/ignore/status.c index deb7175900e..a007774d7c0 100644 --- a/tests/libgit2/ignore/status.c +++ b/tests/libgit2/ignore/status.c @@ -363,6 +363,7 @@ void test_ignore_status__subdirectories_not_at_root(void) void test_ignore_status__leading_slash_ignores(void) { + git_str homedir = GIT_STR_INIT; git_status_options opts = GIT_STATUS_OPTIONS_INIT; status_entry_counts counts; static const char *paths_2[] = { @@ -385,8 +386,9 @@ void test_ignore_status__leading_slash_ignores(void) make_test_data(test_repo_1, test_files_1); - cl_fake_home(); - cl_git_mkfile("home/.gitignore", "/ignore_me\n"); + cl_fake_homedir(&homedir); + cl_git_pass(git_str_joinpath(&homedir, homedir.ptr, ".gitignore")); + cl_git_mkfile(homedir.ptr, "/ignore_me\n"); { git_config *cfg; cl_git_pass(git_repository_config(&cfg, g_repo)); @@ -412,6 +414,8 @@ void test_ignore_status__leading_slash_ignores(void) cl_assert_equal_i(counts.expected_entry_count, counts.entry_count); cl_assert_equal_i(0, counts.wrong_status_flags_count); cl_assert_equal_i(0, counts.wrong_sorted_path); + + git_str_dispose(&homedir); } void test_ignore_status__multiple_leading_slash(void) diff --git a/tests/libgit2/remote/httpproxy.c b/tests/libgit2/remote/httpproxy.c index f62a2545bac..6ba00b7c951 100644 --- a/tests/libgit2/remote/httpproxy.c +++ b/tests/libgit2/remote/httpproxy.c @@ -132,7 +132,7 @@ static void assert_global_config_match(const char *config, const char *expected) void test_remote_httpproxy__config_overrides_detached_remote(void) { - cl_fake_home(); + cl_fake_globalconfig(NULL); assert_global_config_match(NULL, NULL); assert_global_config_match("http.proxy", "http://localhost:1/"); @@ -141,8 +141,6 @@ void test_remote_httpproxy__config_overrides_detached_remote(void) assert_global_config_match("http.https://github.com/libgit2.proxy", "http://localhost:4/"); assert_global_config_match("http.https://github.com/libgit2/.proxy", "http://localhost:5/"); assert_global_config_match("http.https://github.com/libgit2/libgit2.proxy", "http://localhost:6/"); - - cl_git_pass(git_futils_rmdir_r("home", NULL, GIT_RMDIR_REMOVE_FILES)); } void test_remote_httpproxy__env(void) From ff67b5e11724b075d145931aa6ac2c8817d791e2 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 23 Jan 2023 16:23:37 +0000 Subject: [PATCH 103/608] tests: use a dummy homedir Use a dummy home directory for tests to avoid user data leaking into test execution. --- tests/clar/clar_libgit2.c | 18 ++++++++++++++++++ tests/clar/clar_libgit2.h | 1 + tests/clar/main.c | 1 + 3 files changed, 20 insertions(+) diff --git a/tests/clar/clar_libgit2.c b/tests/clar/clar_libgit2.c index cc953915da7..312e1210353 100644 --- a/tests/clar/clar_libgit2.c +++ b/tests/clar/clar_libgit2.c @@ -623,6 +623,24 @@ void cl_fake_globalconfig(git_str *out) git_str_dispose(&path); } +void cl_sandbox_set_homedir(const char *home) +{ + git_str path = GIT_STR_INIT; + + if (home) { + git_libgit2_opts(GIT_OPT_SET_HOMEDIR, home); + } else { + git_str_joinpath(&path, clar_sandbox_path(), "__home"); + + if (!git_fs_path_exists(path.ptr)) + cl_must_pass(p_mkdir(path.ptr, 0777)); + + git_libgit2_opts(GIT_OPT_SET_HOMEDIR, path.ptr); + } + + git_str_dispose(&path); +} + void cl_sandbox_set_search_path_defaults(void) { git_str path = GIT_STR_INIT; diff --git a/tests/clar/clar_libgit2.h b/tests/clar/clar_libgit2.h index 87f1f9bd9d4..84405d21ce4 100644 --- a/tests/clar/clar_libgit2.h +++ b/tests/clar/clar_libgit2.h @@ -249,6 +249,7 @@ void cl_fake_homedir_cleanup(void *); void cl_fake_globalconfig(git_str *); void cl_fake_globalconfig_cleanup(void *); +void cl_sandbox_set_homedir(const char *); void cl_sandbox_set_search_path_defaults(void); void cl_sandbox_disable_ownership_validation(void); diff --git a/tests/clar/main.c b/tests/clar/main.c index d879073a825..e3f4fe740bd 100644 --- a/tests/clar/main.c +++ b/tests/clar/main.c @@ -25,6 +25,7 @@ int main(int argc, char *argv[]) } cl_global_trace_register(); + cl_sandbox_set_homedir(getenv("CLAR_HOMEDIR")); cl_sandbox_set_search_path_defaults(); cl_sandbox_disable_ownership_validation(); From ea4ce92aea6cbe5da688b97988dceb6b33382f66 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 23 Jan 2023 16:26:59 +0000 Subject: [PATCH 104/608] ci: isolate the home directory for test execution libgit2 can now isolate its home directory, and our test runner (by default) isolates the home directory. In our CI environment, we want to set up some pieces (like ssh configuration) in a fake homedir. Continue to do so and propagate that to clar. --- ci/test.sh | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/ci/test.sh b/ci/test.sh index 230daaaa0a4..47629e9eb9a 100755 --- a/ci/test.sh +++ b/ci/test.sh @@ -16,6 +16,9 @@ BUILD_DIR=$(pwd) TMPDIR=${TMPDIR:-/tmp} USER=${USER:-$(whoami)} +HOME=`mktemp -d ${TMPDIR}/home.XXXXXXXX` +export CLAR_HOMEDIR=${HOME} + SUCCESS=1 CONTINUE_ON_FAILURE=0 @@ -140,7 +143,6 @@ fi if [ -z "$SKIP_SSH_TESTS" ]; then echo "Starting SSH server..." - HOME=`mktemp -d ${TMPDIR}/home.XXXXXXXX` SSHD_DIR=`mktemp -d ${TMPDIR}/sshd.XXXXXXXX` git init --bare "${SSHD_DIR}/test.git" >/dev/null cat >"${SSHD_DIR}/sshd_config" <<-EOF From 5288aa301c80c17cdedc7fbe457b8821b5d4f842 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 23 Jan 2023 22:25:27 +0000 Subject: [PATCH 105/608] ci: use latest ci-dependencies release for mingw --- ci/setup-mingw-build.sh | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ci/setup-mingw-build.sh b/ci/setup-mingw-build.sh index 3d72b24eb50..6c444f584e2 100755 --- a/ci/setup-mingw-build.sh +++ b/ci/setup-mingw-build.sh @@ -11,9 +11,9 @@ BUILD_TEMP=$(cygpath $BUILD_TEMP) case "$ARCH" in amd64) - MINGW_URI="https://github.com/libgit2/ci-dependencies/releases/download/2021-05-04/mingw-x86_64-8.1.0-release-win32-sjlj-rt_v6-rev0.zip";; + MINGW_URI="https://github.com/libgit2/ci-dependencies/releases/download/2023-01-23/mingw-x86_64-8.1.0-release-win32-sjlj-rt_v6-rev0.zip";; x86) - MINGW_URI="https://github.com/libgit2/ci-dependencies/releases/download/2021-05-04/mingw-i686-8.1.0-release-win32-sjlj-rt_v6-rev0.zip";; + MINGW_URI="https://github.com/libgit2/ci-dependencies/releases/download/2023-01-23/mingw-i686-8.1.0-release-win32-sjlj-rt_v6-rev0.zip";; esac if [ -z "$MINGW_URI" ]; then From d1411ed85643fb56d21e6a560714582b52bf8ded Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 23 Jan 2023 22:36:09 +0000 Subject: [PATCH 106/608] ci: compile against libssh2 on windows --- .github/workflows/main.yml | 10 ++++++++-- ci/setup-win32-build.sh | 27 +++++++++++++++++++++++++++ 2 files changed, 35 insertions(+), 2 deletions(-) create mode 100755 ci/setup-win32-build.sh diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 39cefdb192d..65d19d9bb99 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -133,19 +133,25 @@ jobs: - name: "Windows (amd64, Visual Studio)" id: windows-amd64-vs os: windows-2019 + setup-script: win32 env: ARCH: amd64 CMAKE_GENERATOR: Visual Studio 16 2019 - CMAKE_OPTIONS: -A x64 -DWIN32_LEAKCHECK=ON -DDEPRECATE_HARD=ON + CMAKE_OPTIONS: -A x64 -DWIN32_LEAKCHECK=ON -DDEPRECATE_HARD=ON -DUSE_SSH=ON -DCMAKE_PREFIX_PATH=D:\Temp\libssh2 + BUILD_PATH: C:\Windows\system32;C:\Windows;C:\Windows\System32\Wbem;C:\Program Files (x86)\CMake\bin;D:\Temp\libssh2\bin + BUILD_TEMP: D:\Temp SKIP_SSH_TESTS: true SKIP_NEGOTIATE_TESTS: true - name: "Windows (x86, Visual Studio)" id: windows-x86-vs os: windows-2019 + setup-script: win32 env: ARCH: x86 CMAKE_GENERATOR: Visual Studio 16 2019 - CMAKE_OPTIONS: -A Win32 -DWIN32_LEAKCHECK=ON -DDEPRECATE_HARD=ON -DUSE_SHA1=HTTPS -DUSE_BUNDLED_ZLIB=ON + CMAKE_OPTIONS: -A Win32 -DWIN32_LEAKCHECK=ON -DDEPRECATE_HARD=ON -DUSE_SHA1=HTTPS -DUSE_BUNDLED_ZLIB=ON -DUSE_SSH=ON -DCMAKE_PREFIX_PATH=D:\Temp\libssh2 + BUILD_PATH: C:\Windows\system32;C:\Windows;C:\Windows\System32\Wbem;C:\Program Files (x86)\CMake\bin;D:\Temp\libssh2\bin + BUILD_TEMP: D:\Temp SKIP_SSH_TESTS: true SKIP_NEGOTIATE_TESTS: true - name: "Windows (amd64, mingw)" diff --git a/ci/setup-win32-build.sh b/ci/setup-win32-build.sh new file mode 100755 index 00000000000..a8b81e5ef6e --- /dev/null +++ b/ci/setup-win32-build.sh @@ -0,0 +1,27 @@ +#!/bin/sh + +set -ex + +echo "##############################################################################" +echo "## Downloading libssh2" +echo "##############################################################################" + +BUILD_TEMP=${BUILD_TEMP:=$TEMP} +BUILD_TEMP=$(cygpath $BUILD_TEMP) + +case "$ARCH" in + amd64) + LIBSSH2_URI="https://github.com/libgit2/ci-dependencies/releases/download/2023-02-01/libssh2-20230201-amd64.zip";; + x86) + LIBSSH2_URI="https://github.com/libgit2/ci-dependencies/releases/download/2023-02-01-v2/libssh2-20230201-x86.zip";; +esac + +if [ -z "$LIBSSH2_URI" ]; then + echo "No URL" + exit 1 +fi + +mkdir -p "$BUILD_TEMP" + +curl -s -L "$LIBSSH2_URI" -o "$BUILD_TEMP"/libssh2-"$ARCH".zip +unzip -q "$BUILD_TEMP"/libssh2-"$ARCH".zip -d "$BUILD_TEMP" From 247474fdbde41c0fe4ee769a31fc98f92c6dc808 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Tue, 24 Jan 2023 12:15:23 +0000 Subject: [PATCH 107/608] tests: known_hosts manipulating ssh clone tests Teach the clone tests how to clone from github.com, when given a keypair with a passphrase and known_hosts data. This allows us to better exercise our known_hosts checking and ensure that the lifecycle of the certificate callback matches our expectations. --- .github/workflows/main.yml | 4 + tests/libgit2/online/clone.c | 163 ++++++++++++++++++++++++++++++----- 2 files changed, 145 insertions(+), 22 deletions(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 65d19d9bb99..f47469ca654 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -289,6 +289,10 @@ jobs: - name: Build and test run: | export GITTEST_NEGOTIATE_PASSWORD="${{ secrets.GITTEST_NEGOTIATE_PASSWORD }}" + export GITTEST_GITHUB_SSH_KEY="${{ secrets.GITTEST_GITHUB_SSH_KEY }}" + export GITTEST_GITHUB_SSH_PUBKEY="${{ secrets.GITTEST_GITHUB_SSH_PUBKEY }}" + export GITTEST_GITHUB_SSH_PASSPHRASE="${{ secrets.GITTEST_GITHUB_SSH_PASSPHRASE }}" + export GITTEST_GITHUB_SSH_REMOTE_HOSTKEY="${{ secrets.GITTEST_GITHUB_SSH_REMOTE_HOSTKEY }}" if [ -n "${{ matrix.platform.container.name }}" ]; then mkdir build diff --git a/tests/libgit2/online/clone.c b/tests/libgit2/online/clone.c index 96ff66ae06a..ce469fa84fc 100644 --- a/tests/libgit2/online/clone.c +++ b/tests/libgit2/online/clone.c @@ -36,6 +36,11 @@ static char *_remote_expectcontinue = NULL; static char *_remote_redirect_initial = NULL; static char *_remote_redirect_subsequent = NULL; +static char *_github_ssh_pubkey = NULL; +static char *_github_ssh_privkey = NULL; +static char *_github_ssh_passphrase = NULL; +static char *_github_ssh_remotehostkey = NULL; + static int _orig_proxies_need_reset = 0; static char *_orig_http_proxy = NULL; static char *_orig_https_proxy = NULL; @@ -85,6 +90,11 @@ void test_online_clone__initialize(void) _remote_redirect_initial = cl_getenv("GITTEST_REMOTE_REDIRECT_INITIAL"); _remote_redirect_subsequent = cl_getenv("GITTEST_REMOTE_REDIRECT_SUBSEQUENT"); + _github_ssh_pubkey = cl_getenv("GITTEST_GITHUB_SSH_PUBKEY"); + _github_ssh_privkey = cl_getenv("GITTEST_GITHUB_SSH_KEY"); + _github_ssh_passphrase = cl_getenv("GITTEST_GITHUB_SSH_PASSPHRASE"); + _github_ssh_remotehostkey = cl_getenv("GITTEST_GITHUB_SSH_REMOTE_HOSTKEY"); + if (_remote_expectcontinue) git_libgit2_opts(GIT_OPT_ENABLE_HTTP_EXPECT_CONTINUE, 1); @@ -119,6 +129,11 @@ void test_online_clone__cleanup(void) git__free(_remote_redirect_initial); git__free(_remote_redirect_subsequent); + git__free(_github_ssh_pubkey); + git__free(_github_ssh_privkey); + git__free(_github_ssh_passphrase); + git__free(_github_ssh_remotehostkey); + if (_orig_proxies_need_reset) { cl_setenv("HTTP_PROXY", _orig_http_proxy); cl_setenv("HTTPS_PROXY", _orig_https_proxy); @@ -554,6 +569,68 @@ static int check_ssh_auth_methods(git_credential **cred, const char *url, const return GIT_EUSER; } +static int succeed_certificate_check(git_cert *cert, int valid, const char *host, void *payload) +{ + GIT_UNUSED(cert); + GIT_UNUSED(valid); + GIT_UNUSED(payload); + + cl_assert_equal_s("github.com", host); + + return 0; +} + +static int fail_certificate_check(git_cert *cert, int valid, const char *host, void *payload) +{ + GIT_UNUSED(cert); + GIT_UNUSED(valid); + GIT_UNUSED(host); + GIT_UNUSED(payload); + + return GIT_ECERTIFICATE; +} + +static int github_credentials( + git_credential **cred, + const char *url, + const char *username_from_url, + unsigned int allowed_types, + void *data) +{ + GIT_UNUSED(url); + GIT_UNUSED(username_from_url); + GIT_UNUSED(data); + + if ((allowed_types & GIT_CREDENTIAL_USERNAME) != 0) { + return git_credential_username_new(cred, "git"); + } + + cl_assert((allowed_types & GIT_CREDENTIAL_SSH_KEY) != 0); + + return git_credential_ssh_key_memory_new(cred, + "git", + _github_ssh_pubkey, + _github_ssh_privkey, + _github_ssh_passphrase); +} + +void test_online_clone__ssh_github(void) +{ +#if !defined(GIT_SSH) || !defined(GIT_SSH_MEMORY_CREDENTIALS) + clar__skip(); +#endif + + if (!_github_ssh_pubkey || !_github_ssh_privkey) + clar__skip(); + + cl_fake_homedir(NULL); + + g_options.fetch_opts.callbacks.credentials = github_credentials; + g_options.fetch_opts.callbacks.certificate_check = succeed_certificate_check; + + cl_git_pass(git_clone(&g_repo, SSH_REPO_URL, "./foo", &g_options)); +} + void test_online_clone__ssh_auth_methods(void) { int with_user; @@ -563,7 +640,7 @@ void test_online_clone__ssh_auth_methods(void) #endif g_options.fetch_opts.callbacks.credentials = check_ssh_auth_methods; g_options.fetch_opts.callbacks.payload = &with_user; - g_options.fetch_opts.callbacks.certificate_check = NULL; + g_options.fetch_opts.callbacks.certificate_check = succeed_certificate_check; with_user = 0; cl_git_fail_with(GIT_EUSER, @@ -574,6 +651,69 @@ void test_online_clone__ssh_auth_methods(void) git_clone(&g_repo, "ssh://git@github.com/libgit2/TestGitRepository", "./foo", &g_options)); } +/* + * Ensure that the certificate check callback is still called, and + * can accept a host key that is not in the known hosts file. + */ +void test_online_clone__ssh_certcheck_accepts_unknown(void) +{ +#if !defined(GIT_SSH) || !defined(GIT_SSH_MEMORY_CREDENTIALS) + clar__skip(); +#endif + + if (!_github_ssh_pubkey || !_github_ssh_privkey) + clar__skip(); + + cl_fake_homedir(NULL); + + g_options.fetch_opts.callbacks.credentials = github_credentials; + + /* Ensure we fail without the certificate check */ + cl_git_fail_with(GIT_ECERTIFICATE, + git_clone(&g_repo, SSH_REPO_URL, "./foo", NULL)); + + /* Set the callback to accept the certificate */ + g_options.fetch_opts.callbacks.certificate_check = succeed_certificate_check; + + cl_git_pass(git_clone(&g_repo, SSH_REPO_URL, "./foo", &g_options)); +} + +/* + * Ensure that the known hosts file is read and the certificate check + * callback is still called after that. + */ +void test_online_clone__ssh_certcheck_override_knownhosts(void) +{ + git_str knownhostsfile = GIT_STR_INIT; + +#if !defined(GIT_SSH) || !defined(GIT_SSH_MEMORY_CREDENTIALS) + clar__skip(); +#endif + + if (!_github_ssh_pubkey || !_github_ssh_privkey || !_github_ssh_remotehostkey) + clar__skip(); + + g_options.fetch_opts.callbacks.credentials = github_credentials; + + cl_fake_homedir(&knownhostsfile); + cl_git_pass(git_str_joinpath(&knownhostsfile, knownhostsfile.ptr, ".ssh")); + cl_git_pass(p_mkdir(knownhostsfile.ptr, 0777)); + + cl_git_pass(git_str_joinpath(&knownhostsfile, knownhostsfile.ptr, "known_hosts")); + cl_git_rewritefile(knownhostsfile.ptr, _github_ssh_remotehostkey); + + /* Ensure we succeed without the certificate check */ + cl_git_pass(git_clone(&g_repo, SSH_REPO_URL, "./foo", &g_options)); + git_repository_free(g_repo); + g_repo = NULL; + + /* Set the callback to reject the certificate */ + g_options.fetch_opts.callbacks.certificate_check = fail_certificate_check; + cl_git_fail_with(GIT_ECERTIFICATE, git_clone(&g_repo, SSH_REPO_URL, "./bar", &g_options)); + + git_str_dispose(&knownhostsfile); +} + static int custom_remote_ssh_with_paths( git_remote **out, git_repository *repo, @@ -746,16 +886,6 @@ void test_online_clone__ssh_memory_auth(void) cl_git_pass(git_clone(&g_repo, _remote_url, "./foo", &g_options)); } -static int fail_certificate_check(git_cert *cert, int valid, const char *host, void *payload) -{ - GIT_UNUSED(cert); - GIT_UNUSED(valid); - GIT_UNUSED(host); - GIT_UNUSED(payload); - - return GIT_ECERTIFICATE; -} - void test_online_clone__certificate_invalid(void) { g_options.fetch_opts.callbacks.certificate_check = fail_certificate_check; @@ -769,17 +899,6 @@ void test_online_clone__certificate_invalid(void) #endif } -static int succeed_certificate_check(git_cert *cert, int valid, const char *host, void *payload) -{ - GIT_UNUSED(cert); - GIT_UNUSED(valid); - GIT_UNUSED(payload); - - cl_assert_equal_s("github.com", host); - - return 0; -} - void test_online_clone__certificate_valid(void) { g_options.fetch_opts.callbacks.certificate_check = succeed_certificate_check; From 9b546b2ba1306afdf6d986ca0a298133be584a5c Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Tue, 24 Jan 2023 16:17:42 +0000 Subject: [PATCH 108/608] ci: run clone tests in online --- tests/libgit2/CMakeLists.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/libgit2/CMakeLists.txt b/tests/libgit2/CMakeLists.txt index f581d3075b6..49691e1c140 100644 --- a/tests/libgit2/CMakeLists.txt +++ b/tests/libgit2/CMakeLists.txt @@ -66,7 +66,7 @@ endif() include(AddClarTest) add_clar_test(libgit2_tests offline -v -xonline) add_clar_test(libgit2_tests invasive -v -sfilter::stream::bigfile -sodb::largefiles -siterator::workdir::filesystem_gunk -srepo::init -srepo::init::at_filesystem_root) -add_clar_test(libgit2_tests online -v -sonline -xonline::customcert -xonline::clone::ssh_auth_methods) +add_clar_test(libgit2_tests online -v -sonline -xonline::customcert) add_clar_test(libgit2_tests online_customcert -v -sonline::customcert) add_clar_test(libgit2_tests gitdaemon -v -sonline::push) add_clar_test(libgit2_tests gitdaemon_namespace -v -sonline::clone::namespace) From a7bc32edd553b41b1d4f02233379934e6d4b47a9 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Tue, 31 Jan 2023 12:17:09 +0000 Subject: [PATCH 109/608] ci: limit test runner to build path We provide `BUILD_PATH` to our build script; provide it and mutate `PATH` when running our tests as well. --- ci/test.sh | 22 ++++++++++++++++++++-- 1 file changed, 20 insertions(+), 2 deletions(-) diff --git a/ci/test.sh b/ci/test.sh index 47629e9eb9a..d86fb3cf0f0 100755 --- a/ci/test.sh +++ b/ci/test.sh @@ -13,6 +13,8 @@ fi SOURCE_DIR=${SOURCE_DIR:-$( cd "$( dirname "${BASH_SOURCE[0]}" )" && dirname $( pwd ) )} BUILD_DIR=$(pwd) +BUILD_PATH=${BUILD_PATH:=$PATH} +CTEST=$(which ctest) TMPDIR=${TMPDIR:-/tmp} USER=${USER:-$(whoami)} @@ -75,7 +77,11 @@ run_test() { RETURN_CODE=0 - CLAR_SUMMARY="${BUILD_DIR}/results_${1}.xml" ctest -V -R "^${1}$" || RETURN_CODE=$? && true + ( + export PATH="${BUILD_PATH}" + export CLAR_SUMMARY="${BUILD_DIR}/results_${1}.xml" + "${CTEST}" -V -R "^${1}$" + ) || RETURN_CODE=$? && true if [ "$RETURN_CODE" -eq 0 ]; then FAILED=0 @@ -96,9 +102,21 @@ run_test() { fi } +indent() { sed "s/^/ /"; } + +if [[ "$(uname -s)" == MINGW* ]]; then + BUILD_PATH=$(cygpath "$BUILD_PATH") +fi + + # Configure the test environment; run them early so that we're certain # that they're started by the time we need them. +echo "CTest version:" +env PATH="${BUILD_PATH}" "${CTEST}" --version | head -1 2>&1 | indent + +echo "" + echo "##############################################################################" echo "## Configuring test environment" echo "##############################################################################" @@ -386,7 +404,7 @@ if [ -z "$SKIP_FUZZERS" ]; then echo "## Running fuzzers" echo "##############################################################################" - ctest -V -R 'fuzzer' + env PATH="${BUILD_PATH}" "${CTEST}" -V -R 'fuzzer' fi cleanup From b857122f1673c65571c8a11b9200ff7bad2d404a Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Tue, 31 Jan 2023 12:17:37 +0000 Subject: [PATCH 110/608] ci: convert PATH correctly to Cygwin format on Windows We provide `BUILD_PATH` to our build script; provide it and mutate `PATH` when running our tests as well. We were previously using `cygpath` to try to convert a _list_ of Windows paths into cygwin / Unix style `PATH` format. This does not work -- it treats the path list as a single path (with semicolons -- understandably as those are allowed characters in a Windows path). For example, `C:\One;C:\Two;C:\Three` is converted to `/c/one;c:/two;c:/three`. Add a new function to convert path lists, so that paths are split by semicolon and fed to `cygpath` independently, then re-joined with a colon. This means that our example `C:\One;C:\Two;C:\Three` is correctly converted to `/c/one:/c/two:/c/three`. --- ci/build.sh | 20 +++++++++++++++++--- ci/test.sh | 12 +++++++++++- 2 files changed, 28 insertions(+), 4 deletions(-) diff --git a/ci/build.sh b/ci/build.sh index 21a45af5f58..80e7a61aecb 100755 --- a/ci/build.sh +++ b/ci/build.sh @@ -13,16 +13,30 @@ BUILD_PATH=${BUILD_PATH:=$PATH} CMAKE=$(which cmake) CMAKE_GENERATOR=${CMAKE_GENERATOR:-Unix Makefiles} +indent() { sed "s/^/ /"; } + +cygfullpath() { + result=$(echo "${1}" | tr \; \\n | while read -r element; do + if [ "${last}" != "" ]; then echo -n ":"; fi + echo -n $(cygpath "${element}") + last="${element}" + done) + if [ "${result}" = "" ]; then exit 1; fi + echo "${result}" +} + if [[ "$(uname -s)" == MINGW* ]]; then - BUILD_PATH=$(cygpath "$BUILD_PATH") + BUILD_PATH=$(cygfullpath "${BUILD_PATH}") fi -indent() { sed "s/^/ /"; } echo "Source directory: ${SOURCE_DIR}" echo "Build directory: ${BUILD_DIR}" echo "" +echo "Platform:" +uname -s | indent + if [ "$(uname -s)" = "Darwin" ]; then echo "macOS version:" sw_vers | indent @@ -40,7 +54,7 @@ echo "Kernel version:" uname -a 2>&1 | indent echo "CMake version:" -env PATH="${BUILD_PATH}" "${CMAKE}" --version 2>&1 | indent +env PATH="${BUILD_PATH}" "${CMAKE}" --version | head -1 2>&1 | indent if test -n "${CC}"; then echo "Compiler version:" diff --git a/ci/test.sh b/ci/test.sh index d86fb3cf0f0..e8bd22e03a6 100755 --- a/ci/test.sh +++ b/ci/test.sh @@ -104,8 +104,18 @@ run_test() { indent() { sed "s/^/ /"; } +cygfullpath() { + result=$(echo "${1}" | tr \; \\n | while read -r element; do + if [ "${last}" != "" ]; then echo -n ":"; fi + echo -n $(cygpath "${element}") + last="${element}" + done) + if [ "${result}" = "" ]; then exit 1; fi + echo "${result}" +} + if [[ "$(uname -s)" == MINGW* ]]; then - BUILD_PATH=$(cygpath "$BUILD_PATH") + BUILD_PATH=$(cygfullpath "$BUILD_PATH") fi From e0220e6a222b056ab44d68f41a62012077d2a3f3 Mon Sep 17 00:00:00 2001 From: Eric Huss Date: Sat, 4 Feb 2023 12:17:03 -0800 Subject: [PATCH 111/608] Set all SSH hostkey preferences that are available --- src/libgit2/transports/ssh.c | 85 ++++++++++++++++++------------------ 1 file changed, 42 insertions(+), 43 deletions(-) diff --git a/src/libgit2/transports/ssh.c b/src/libgit2/transports/ssh.c index a7cdf1d0db8..e90ab07e8f8 100644 --- a/src/libgit2/transports/ssh.c +++ b/src/libgit2/transports/ssh.c @@ -467,28 +467,26 @@ static int load_known_hosts(LIBSSH2_KNOWNHOSTS **hosts, LIBSSH2_SESSION *session return error; } -static const char *hostkey_type_to_string(int type) +static void add_hostkey_pref_if_avail( + LIBSSH2_KNOWNHOSTS *known_hosts, + const char *hostname, + int port, + git_str *prefs, + int type, + const char *type_name) { - switch (type) { - case LIBSSH2_KNOWNHOST_KEY_SSHRSA: - return "ssh-rsa"; - case LIBSSH2_KNOWNHOST_KEY_SSHDSS: - return "ssh-dss"; -#ifdef LIBSSH2_KNOWNHOST_KEY_ECDSA_256 - case LIBSSH2_KNOWNHOST_KEY_ECDSA_256: - return "ecdsa-sha2-nistp256"; - case LIBSSH2_KNOWNHOST_KEY_ECDSA_384: - return "ecdsa-sha2-nistp384"; - case LIBSSH2_KNOWNHOST_KEY_ECDSA_521: - return "ecdsa-sha2-nistp521"; -#endif -#ifdef LIBSSH2_KNOWNHOST_KEY_ED25519 - case LIBSSH2_KNOWNHOST_KEY_ED25519: - return "ssh-ed25519"; -#endif - } + struct libssh2_knownhost *host = NULL; + const char key = '\0'; + int mask = LIBSSH2_KNOWNHOST_TYPE_PLAIN | LIBSSH2_KNOWNHOST_KEYENC_RAW | type; + int error; - return NULL; + error = libssh2_knownhost_checkp(known_hosts, hostname, port, &key, 1, mask, &host); + if (error == LIBSSH2_KNOWNHOST_CHECK_MISMATCH) { + if (git_str_len(prefs) > 0) { + git_str_putc(prefs, ','); + } + git_str_puts(prefs, type_name); + } } /* @@ -496,27 +494,27 @@ static const char *hostkey_type_to_string(int type) * look it up with a nonsense key and using that mismatch to figure out what key * we do have stored for the host. * - * Returns the string to pass to libssh2_session_method_pref or NULL if we were - * unable to find anything or an error happened. + * Populates prefs with the string to pass to libssh2_session_method_pref. */ -static const char *find_hostkey_preference(LIBSSH2_KNOWNHOSTS *known_hosts, const char *hostname, int port) +static void find_hostkey_preference( + LIBSSH2_KNOWNHOSTS *known_hosts, + const char *hostname, + int port, + git_str *prefs) { - struct libssh2_knownhost *host = NULL; - /* Specify no key type so we don't filter on that */ - int type = LIBSSH2_KNOWNHOST_TYPE_PLAIN | LIBSSH2_KNOWNHOST_KEYENC_RAW; - const char key = '\0'; - int error; - /* - * In case of mismatch, we can find the type of key from known_hosts in - * the returned host's information as it means that an entry was found - * but our nonsense key obviously didn't match. + * The order here is important as it indicates the priority of what will + * be preferred. */ - error = libssh2_knownhost_checkp(known_hosts, hostname, port, &key, 1, type, &host); - if (error == LIBSSH2_KNOWNHOST_CHECK_MISMATCH) - return hostkey_type_to_string(host->typemask & LIBSSH2_KNOWNHOST_KEY_MASK); - - return NULL; +#ifdef LIBSSH2_KNOWNHOST_KEY_ED25519 + add_hostkey_pref_if_avail(known_hosts, hostname, port, prefs, LIBSSH2_KNOWNHOST_KEY_ED25519, "ssh-ed25519"); +#endif +#ifdef LIBSSH2_KNOWNHOST_KEY_ECDSA_256 + add_hostkey_pref_if_avail(known_hosts, hostname, port, prefs, LIBSSH2_KNOWNHOST_KEY_ECDSA_256, "ecdsa-sha2-nistp256"); + add_hostkey_pref_if_avail(known_hosts, hostname, port, prefs, LIBSSH2_KNOWNHOST_KEY_ECDSA_384, "ecdsa-sha2-nistp384"); + add_hostkey_pref_if_avail(known_hosts, hostname, port, prefs, LIBSSH2_KNOWNHOST_KEY_ECDSA_521, "ecdsa-sha2-nistp521"); +#endif + add_hostkey_pref_if_avail(known_hosts, hostname, port, prefs, LIBSSH2_KNOWNHOST_KEY_SSHRSA, "ssh-rsa"); } static int _git_ssh_session_create( @@ -526,11 +524,11 @@ static int _git_ssh_session_create( int port, git_stream *io) { - int rc = 0; + git_socket_stream *socket = GIT_CONTAINER_OF(io, git_socket_stream, parent); LIBSSH2_SESSION *s; LIBSSH2_KNOWNHOSTS *known_hosts; - git_socket_stream *socket = GIT_CONTAINER_OF(io, git_socket_stream, parent); - const char *keytype = NULL; + git_str prefs = GIT_STR_INIT; + int rc = 0; GIT_ASSERT_ARG(session); GIT_ASSERT_ARG(hosts); @@ -547,16 +545,17 @@ static int _git_ssh_session_create( return -1; } - if ((keytype = find_hostkey_preference(known_hosts, hostname, port)) != NULL) { + find_hostkey_preference(known_hosts, hostname, port, &prefs); + if (git_str_len(&prefs) > 0) { do { - rc = libssh2_session_method_pref(s, LIBSSH2_METHOD_HOSTKEY, keytype); + rc = libssh2_session_method_pref(s, LIBSSH2_METHOD_HOSTKEY, git_str_cstr(&prefs)); } while (LIBSSH2_ERROR_EAGAIN == rc || LIBSSH2_ERROR_TIMEOUT == rc); if (rc != LIBSSH2_ERROR_NONE) { ssh_error(s, "failed to set hostkey preference"); goto on_error; } } - + git_str_dispose(&prefs); do { rc = libssh2_session_handshake(s, socket->s); From 4083e46f475cd3026a3c65a1e46c4b73d5c22513 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 3 Dec 2022 13:14:38 +0000 Subject: [PATCH 112/608] oid: provide type lookups by enum value or name --- src/libgit2/oid.h | 41 ++++++++++++++++++++++++++++++++++++++++ tests/libgit2/core/oid.c | 19 +++++++++++++++++++ 2 files changed, 60 insertions(+) diff --git a/src/libgit2/oid.h b/src/libgit2/oid.h index d775e180b4e..7b6b09d8bb6 100644 --- a/src/libgit2/oid.h +++ b/src/libgit2/oid.h @@ -66,6 +66,47 @@ GIT_INLINE(size_t) git_oid_hexsize(git_oid_t type) return 0; } +GIT_INLINE(const char *) git_oid_type_name(git_oid_t type) +{ + switch (type) { + case GIT_OID_SHA1: + return "sha1"; + +#ifdef GIT_EXPERIMENTAL_SHA256 + case GIT_OID_SHA256: + return "sha256"; +#endif + } + + return "unknown"; +} + +GIT_INLINE(git_oid_t) git_oid_type_fromstr(const char *name) +{ + if (strcmp(name, "sha1") == 0) + return GIT_OID_SHA1; + +#ifdef GIT_EXPERIMENTAL_SHA256 + if (strcmp(name, "sha256") == 0) + return GIT_OID_SHA256; +#endif + + return 0; +} + +GIT_INLINE(git_oid_t) git_oid_type_fromstrn(const char *name, size_t len) +{ + if (len == CONST_STRLEN("sha1") && strncmp(name, "sha1", len) == 0) + return GIT_OID_SHA1; + +#ifdef GIT_EXPERIMENTAL_SHA256 + if (len == CONST_STRLEN("sha256") && strncmp(name, "sha256", len) == 0) + return GIT_OID_SHA256; +#endif + + return 0; +} + GIT_INLINE(git_hash_algorithm_t) git_oid_algorithm(git_oid_t type) { switch (type) { diff --git a/tests/libgit2/core/oid.c b/tests/libgit2/core/oid.c index 90fb37514ba..a405b3344d7 100644 --- a/tests/libgit2/core/oid.c +++ b/tests/libgit2/core/oid.c @@ -192,3 +192,22 @@ void test_core_oid__fmt_substr_sha1(void) git_oid_fmt_substr(buf, &id_sha1, 5, 6); cl_assert_equal_s(buf, "12eea6"); } + +void test_core_oid__type_lookup(void) +{ + cl_assert_equal_i(GIT_OID_SHA1, git_oid_type_fromstr("sha1")); + cl_assert_equal_i(GIT_OID_SHA1, git_oid_type_fromstrn("sha1...", 4)); + cl_assert_equal_s("sha1", git_oid_type_name(GIT_OID_SHA1)); + +#ifdef GIT_EXPERIMENTAL_SHA256 + cl_assert_equal_i(GIT_OID_SHA256, git_oid_type_fromstr("sha256")); + cl_assert_equal_i(GIT_OID_SHA256, git_oid_type_fromstrn("sha256...", 6)); + cl_assert_equal_s("sha256", git_oid_type_name(GIT_OID_SHA256)); +#endif + + cl_assert_equal_i(0, git_oid_type_fromstr("sha42")); + cl_assert_equal_i(0, git_oid_type_fromstrn("sha1", 3)); + cl_assert_equal_i(0, git_oid_type_fromstrn("sha1...", 5)); + cl_assert_equal_s("unknown", git_oid_type_name(0)); + cl_assert_equal_s("unknown", git_oid_type_name(42)); +} From e9fb5af7cb3f6cffc3432813bba6238c88c46533 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 10 Feb 2023 05:00:21 -0500 Subject: [PATCH 113/608] openssl: retry initialization on failure When we fail to initialize the OpenSSL subsystem, don't assume that we're "initialized". Subsequent initialization requests -- if there are any -- should replay initialization and fail again. --- src/libgit2/streams/openssl.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/libgit2/streams/openssl.c b/src/libgit2/streams/openssl.c index 89c96780c14..5e0e2c939db 100644 --- a/src/libgit2/streams/openssl.c +++ b/src/libgit2/streams/openssl.c @@ -198,7 +198,7 @@ static int openssl_ensure_initialized(void) if ((error = git_openssl_stream_dynamic_init()) == 0) error = openssl_init(); - openssl_initialized = true; + openssl_initialized = !error; } error |= git_mutex_unlock(&openssl_mutex); From b379c401a9d886e6a5916d73fb070d4acb8c8c20 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 10 Feb 2023 05:01:50 -0500 Subject: [PATCH 114/608] openssl: support OpenSSL 3 in dynamic mode Try to load OpenSSL 3 libraries when compiled with OpenSSL-Dynamic support. Handle the deprecated symbol renaming of SSL_get_peer_certificate to SSL_get1_peer_certificate -- try to load the old name and if it fails, use the new one. --- src/libgit2/streams/openssl_dynamic.c | 10 +++++++--- src/util/hash/openssl.c | 7 ++++--- 2 files changed, 11 insertions(+), 6 deletions(-) diff --git a/src/libgit2/streams/openssl_dynamic.c b/src/libgit2/streams/openssl_dynamic.c index da16b6ed70c..222c1099d6b 100644 --- a/src/libgit2/streams/openssl_dynamic.c +++ b/src/libgit2/streams/openssl_dynamic.c @@ -91,7 +91,7 @@ int (*sk_num)(const void *sk); void *(*sk_value)(const void *sk, int i); void (*sk_free)(void *sk); -void *openssl_handle; +static void *openssl_handle; GIT_INLINE(void *) openssl_sym(int *err, const char *name, bool required) { @@ -125,7 +125,8 @@ int git_openssl_stream_dynamic_init(void) (openssl_handle = dlopen("libssl.1.1.dylib", RTLD_NOW)) == NULL && (openssl_handle = dlopen("libssl.so.1.0.0", RTLD_NOW)) == NULL && (openssl_handle = dlopen("libssl.1.0.0.dylib", RTLD_NOW)) == NULL && - (openssl_handle = dlopen("libssl.so.10", RTLD_NOW)) == NULL) { + (openssl_handle = dlopen("libssl.so.10", RTLD_NOW)) == NULL && + (openssl_handle = dlopen("libssl.so.3", RTLD_NOW)) == NULL) { git_error_set(GIT_ERROR_SSL, "could not load ssl libraries"); return -1; } @@ -175,7 +176,6 @@ int git_openssl_stream_dynamic_init(void) SSL_connect = (int (*)(SSL *))openssl_sym(&err, "SSL_connect", true); SSL_ctrl = (long (*)(SSL *, int, long, void *))openssl_sym(&err, "SSL_ctrl", true); - SSL_get_peer_certificate = (X509 *(*)(const SSL *))openssl_sym(&err, "SSL_get_peer_certificate", true); SSL_library_init = (int (*)(void))openssl_sym(&err, "SSL_library_init", false); SSL_free = (void (*)(SSL *))openssl_sym(&err, "SSL_free", true); SSL_get_error = (int (*)(SSL *, int))openssl_sym(&err, "SSL_get_error", true); @@ -187,6 +187,10 @@ int git_openssl_stream_dynamic_init(void) SSL_shutdown = (int (*)(SSL *ssl))openssl_sym(&err, "SSL_shutdown", true); SSL_write = (int (*)(SSL *, const void *, int))openssl_sym(&err, "SSL_write", true); + if (!(SSL_get_peer_certificate = (X509 *(*)(const SSL *))openssl_sym(&err, "SSL_get_peer_certificate", false))) { + SSL_get_peer_certificate = (X509 *(*)(const SSL *))openssl_sym(&err, "SSL_get1_peer_certificate", true); + } + SSL_CTX_ctrl = (long (*)(SSL_CTX *, int, long, void *))openssl_sym(&err, "SSL_CTX_ctrl", true); SSL_CTX_free = (void (*)(SSL_CTX *))openssl_sym(&err, "SSL_CTX_free", true); SSL_CTX_new = (SSL_CTX *(*)(const SSL_METHOD *))openssl_sym(&err, "SSL_CTX_new", true); diff --git a/src/util/hash/openssl.c b/src/util/hash/openssl.c index 649358ca2a6..eaf91e74c1d 100644 --- a/src/util/hash/openssl.c +++ b/src/util/hash/openssl.c @@ -10,8 +10,8 @@ #ifdef GIT_OPENSSL_DYNAMIC # include -int handle_count; -void *openssl_handle; +static int handle_count; +static void *openssl_handle; static int git_hash_openssl_global_shutdown(void) { @@ -30,7 +30,8 @@ static int git_hash_openssl_global_init(void) (openssl_handle = dlopen("libssl.1.1.dylib", RTLD_NOW)) == NULL && (openssl_handle = dlopen("libssl.so.1.0.0", RTLD_NOW)) == NULL && (openssl_handle = dlopen("libssl.1.0.0.dylib", RTLD_NOW)) == NULL && - (openssl_handle = dlopen("libssl.so.10", RTLD_NOW)) == NULL) { + (openssl_handle = dlopen("libssl.so.10", RTLD_NOW)) == NULL && + (openssl_handle = dlopen("libssl.so.3", RTLD_NOW)) == NULL) { git_error_set(GIT_ERROR_SSL, "could not load ssl libraries"); return -1; } From acb00e4eae66bfed84046bccb60bf59707fe9626 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 19 Sep 2022 10:39:58 -0400 Subject: [PATCH 115/608] repo: understand the `objectformat` extension Teach the repository about the `objectformat` extension, supporting `sha1` always and `sha256` when the experimental sha256 support is active. --- include/git2/repository.h | 8 ++++ src/libgit2/repository.c | 50 +++++++++++++++++++--- src/libgit2/repository.h | 1 + tests/libgit2/core/opts.c | 15 ++++--- tests/libgit2/repo/objectformat.c | 69 +++++++++++++++++++++++++++++++ 5 files changed, 132 insertions(+), 11 deletions(-) create mode 100644 tests/libgit2/repo/objectformat.c diff --git a/include/git2/repository.h b/include/git2/repository.h index c87f3c96252..9b56599d75d 100644 --- a/include/git2/repository.h +++ b/include/git2/repository.h @@ -949,6 +949,14 @@ GIT_EXTERN(int) git_repository_ident(const char **name, const char **email, cons */ GIT_EXTERN(int) git_repository_set_ident(git_repository *repo, const char *name, const char *email); +/** + * Gets the object type used by this repository. + * + * @param repo the repository + * @return the object id type + */ +GIT_EXTERN(git_oid_t) git_repository_oid_type(git_repository *repo); + /** @} */ GIT_END_DECL #endif diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index df41f581c22..5d51be6b758 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -67,6 +67,7 @@ static const struct { static int check_repositoryformatversion(int *version, git_config *config); static int check_extensions(git_config *config, int version); static int load_global_config(git_config **config); +static int load_objectformat(git_repository *repo, git_config *config); #define GIT_COMMONDIR_FILE "commondir" #define GIT_GITDIR_FILE "gitdir" @@ -240,7 +241,7 @@ GIT_INLINE(int) validate_repo_path(git_str *path) */ static size_t suffix_len = CONST_STRLEN("objects/pack/pack-.pack.lock") + - GIT_OID_SHA1_HEXSIZE; + GIT_OID_MAX_HEXSIZE; return git_fs_path_validate_str_length_with_suffix( path, suffix_len); @@ -1030,6 +1031,13 @@ int git_repository_open_ext( goto cleanup; } + if (version > 0) { + if ((error = load_objectformat(repo, config)) < 0) + goto cleanup; + } else { + repo->oid_type = GIT_OID_SHA1; + } + /* * Ensure that the git directory and worktree are * owned by the current user. @@ -1549,7 +1557,8 @@ static int check_repositoryformatversion(int *version, git_config *config) } static const char *builtin_extensions[] = { - "noop" + "noop", + "objectformat" }; static git_vector user_extensions = GIT_VECTOR_INIT; @@ -1613,6 +1622,32 @@ static int check_extensions(git_config *config, int version) return git_config_foreach_match(config, "^extensions\\.", check_valid_extension, NULL); } +static int load_objectformat(git_repository *repo, git_config *config) +{ + git_config_entry *entry = NULL; + int error; + + if ((error = git_config_get_entry(&entry, config, "extensions.objectformat")) < 0) { + if (error == GIT_ENOTFOUND) { + repo->oid_type = GIT_OID_SHA1; + git_error_clear(); + error = 0; + } + + goto done; + } + + if ((repo->oid_type = git_oid_type_fromstr(entry->value)) == 0) { + git_error_set(GIT_ERROR_REPOSITORY, + "unknown object format '%s'", entry->value); + error = GIT_EINVALID; + } + +done: + git_config_entry_free(entry); + return error; +} + int git_repository__extensions(char ***out, size_t *out_len) { git_vector extensions; @@ -2922,14 +2957,14 @@ int git_repository__set_orig_head(git_repository *repo, const git_oid *orig_head { git_filebuf file = GIT_FILEBUF_INIT; git_str file_path = GIT_STR_INIT; - char orig_head_str[GIT_OID_SHA1_HEXSIZE]; + char orig_head_str[GIT_OID_MAX_HEXSIZE]; int error = 0; git_oid_fmt(orig_head_str, orig_head); if ((error = git_str_joinpath(&file_path, repo->gitdir, GIT_ORIG_HEAD_FILE)) == 0 && (error = git_filebuf_open(&file, file_path.ptr, GIT_FILEBUF_CREATE_LEADING_DIRS, GIT_MERGE_FILE_MODE)) == 0 && - (error = git_filebuf_printf(&file, "%.*s\n", GIT_OID_SHA1_HEXSIZE, orig_head_str)) == 0) + (error = git_filebuf_printf(&file, "%.*s\n", (int)git_oid_hexsize(repo->oid_type), orig_head_str)) == 0) error = git_filebuf_commit(&file); if (error < 0) @@ -3042,7 +3077,7 @@ int git_repository_hashfile( goto cleanup; } - error = git_odb__hashfd_filtered(out, fd, (size_t)len, type, GIT_OID_SHA1, fl); + error = git_odb__hashfd_filtered(out, fd, (size_t)len, type, repo->oid_type, fl); cleanup: if (fd >= 0) @@ -3389,3 +3424,8 @@ int git_repository_submodule_cache_clear(git_repository *repo) repo->submodule_cache = NULL; return error; } + +git_oid_t git_repository_oid_type(git_repository *repo) +{ + return repo ? repo->oid_type : 0; +} diff --git a/src/libgit2/repository.h b/src/libgit2/repository.h index a488f2bf2fe..b1e212a32b2 100644 --- a/src/libgit2/repository.h +++ b/src/libgit2/repository.h @@ -153,6 +153,7 @@ struct git_repository { unsigned is_bare:1; unsigned is_worktree:1; + git_oid_t oid_type; unsigned int lru_counter; diff --git a/tests/libgit2/core/opts.c b/tests/libgit2/core/opts.c index e8f65d51017..486ff58c6e7 100644 --- a/tests/libgit2/core/opts.c +++ b/tests/libgit2/core/opts.c @@ -34,8 +34,9 @@ void test_core_opts__extensions_query(void) cl_git_pass(git_libgit2_opts(GIT_OPT_GET_EXTENSIONS, &out)); - cl_assert_equal_sz(out.count, 1); + cl_assert_equal_sz(out.count, 2); cl_assert_equal_s("noop", out.strings[0]); + cl_assert_equal_s("objectformat", out.strings[1]); git_strarray_dispose(&out); } @@ -48,9 +49,10 @@ void test_core_opts__extensions_add(void) cl_git_pass(git_libgit2_opts(GIT_OPT_SET_EXTENSIONS, in, ARRAY_SIZE(in))); cl_git_pass(git_libgit2_opts(GIT_OPT_GET_EXTENSIONS, &out)); - cl_assert_equal_sz(out.count, 2); + cl_assert_equal_sz(out.count, 3); cl_assert_equal_s("noop", out.strings[0]); - cl_assert_equal_s("foo", out.strings[1]); + cl_assert_equal_s("objectformat", out.strings[1]); + cl_assert_equal_s("foo", out.strings[2]); git_strarray_dispose(&out); } @@ -63,9 +65,10 @@ void test_core_opts__extensions_remove(void) cl_git_pass(git_libgit2_opts(GIT_OPT_SET_EXTENSIONS, in, ARRAY_SIZE(in))); cl_git_pass(git_libgit2_opts(GIT_OPT_GET_EXTENSIONS, &out)); - cl_assert_equal_sz(out.count, 2); - cl_assert_equal_s("bar", out.strings[0]); - cl_assert_equal_s("baz", out.strings[1]); + cl_assert_equal_sz(out.count, 3); + cl_assert_equal_s("objectformat", out.strings[0]); + cl_assert_equal_s("bar", out.strings[1]); + cl_assert_equal_s("baz", out.strings[2]); git_strarray_dispose(&out); } diff --git a/tests/libgit2/repo/objectformat.c b/tests/libgit2/repo/objectformat.c new file mode 100644 index 00000000000..3518115f4d9 --- /dev/null +++ b/tests/libgit2/repo/objectformat.c @@ -0,0 +1,69 @@ +#include "clar_libgit2.h" +#include "futils.h" +#include "sysdir.h" +#include "repository.h" +#include + +git_repository *repo; +git_config *config; + +void test_repo_objectformat__initialize(void) +{ + repo = cl_git_sandbox_init("empty_bare.git"); + + cl_git_pass(git_repository_config(&config, repo)); + cl_git_pass(git_config_set_int32(config, "core.repositoryformatversion", 1)); +} + +void test_repo_objectformat__cleanup(void) +{ + git_config_free(config); + cl_git_sandbox_cleanup(); +} + +void test_repo_objectformat__unspecified(void) +{ + git_repository *other; + + cl_git_pass(git_repository_open(&other, "empty_bare.git")); + cl_assert_equal_i(GIT_OID_SHA1, git_repository_oid_type(other)); + git_repository_free(other); +} + +void test_repo_objectformat__sha1(void) +{ + git_repository *other; + + cl_git_pass(git_config_set_string(config, "extensions.objectformat", "sha1")); + + cl_git_pass(git_repository_open(&other, "empty_bare.git")); + cl_assert_equal_i(GIT_OID_SHA1, git_repository_oid_type(other)); + git_repository_free(other); +} + +void test_repo_objectformat__sha256(void) +{ +#ifndef GIT_EXPERIMENTAL_SHA256 + cl_skip(); +#else + git_repository *other; + + cl_git_pass(git_config_set_string(config, "extensions.objectformat", "sha256")); + + cl_git_pass(git_repository_open(&other, "empty_bare.git")); + cl_assert_equal_i(GIT_OID_SHA256, git_repository_oid_type(other)); + git_repository_free(other); +#endif +} + +void test_repo_objectformat__invalid(void) +{ + git_repository *other; + + cl_git_pass(git_config_set_string(config, "extensions.objectformat", "bogus")); + + cl_git_fail_with(GIT_EINVALID, git_repository_open(&other, "empty_bare.git")); + cl_assert_equal_s("unknown object format 'bogus'", git_error_last()->message); + git_repository_free(other); +} + From 3dfc12d5e210a6e15c7c54f3514eeeb12fb2108a Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 3 Dec 2022 13:07:23 +0000 Subject: [PATCH 116/608] repo: internal setter for `objectformat` Provide an internal function to set the repository's `objectformat`, both in the internal object and in the configuration. --- src/libgit2/repository.c | 30 ++++++++++++++++++++++++++++++ src/libgit2/repository.h | 8 ++++++++ 2 files changed, 38 insertions(+) diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index 5d51be6b758..9c55aaca5e1 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -1648,6 +1648,36 @@ static int load_objectformat(git_repository *repo, git_config *config) return error; } +int git_repository__set_objectformat( + git_repository *repo, + git_oid_t oid_type) +{ + git_config *cfg; + + /* + * Older clients do not necessarily understand the + * `objectformat` extension, even when it's set to an + * object format that they understand (SHA1). Do not set + * the objectformat extension unless we're not using the + * default object format. + */ + if (oid_type == GIT_OID_DEFAULT) + return 0; + + if (git_repository_config__weakptr(&cfg, repo) < 0) + return -1; + + if (git_config_set_int32(cfg, + "core.repositoryformatversion", 1) < 0 || + git_config_set_string(cfg, "extensions.objectformat", + git_oid_type_name(oid_type)) < 0) + return -1; + + repo->oid_type = oid_type; + + return 0; +} + int git_repository__extensions(char ***out, size_t *out_len) { git_vector extensions; diff --git a/src/libgit2/repository.h b/src/libgit2/repository.h index b1e212a32b2..75380ae5347 100644 --- a/src/libgit2/repository.h +++ b/src/libgit2/repository.h @@ -257,4 +257,12 @@ int git_repository__extensions(char ***out, size_t *out_len); int git_repository__set_extensions(const char **extensions, size_t len); void git_repository__free_extensions(void); +/* + * Set the object format (OID type) for a repository; this will set + * both the configuration and the internal value for the oid type. + */ +int git_repository__set_objectformat( + git_repository *repo, + git_oid_t oid_type); + #endif From 366973f3785b7a2cf95a118fc4e13210ca277529 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 3 Dec 2022 14:32:32 +0000 Subject: [PATCH 117/608] repo: don't overwrite repo format version on reinit Ensure that we maintain the `core.repositoryFormatVersion` value instead of always overwriting it with the default. --- src/libgit2/repository.c | 24 ++++++++++++++++-------- tests/libgit2/repo/init.c | 33 ++++++++++++++++++++++++++------- 2 files changed, 42 insertions(+), 15 deletions(-) diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index 9c55aaca5e1..043cfd1fd6f 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -76,8 +76,8 @@ static int load_objectformat(git_repository *repo, git_config *config); #define GIT_BRANCH_DEFAULT "master" -#define GIT_REPO_VERSION 0 -#define GIT_REPO_MAX_VERSION 1 +#define GIT_REPO_VERSION_DEFAULT 0 +#define GIT_REPO_VERSION_MAX 1 git_str git_repository__reserved_names_win32[] = { { DOT_GIT, 0, CONST_STRLEN(DOT_GIT) }, @@ -1016,7 +1016,8 @@ int git_repository_open_ext( if (error < 0 && error != GIT_ENOTFOUND) goto cleanup; - if (config && (error = check_repositoryformatversion(&version, config)) < 0) + if (config && + (error = check_repositoryformatversion(&version, config)) < 0) goto cleanup; if ((error = check_extensions(config, version)) < 0) @@ -1539,6 +1540,7 @@ static int check_repositoryformatversion(int *version, git_config *config) int error; error = git_config_get_int32(version, config, "core.repositoryformatversion"); + /* git ignores this if the config variable isn't there */ if (error == GIT_ENOTFOUND) return 0; @@ -1546,10 +1548,15 @@ static int check_repositoryformatversion(int *version, git_config *config) if (error < 0) return -1; - if (GIT_REPO_MAX_VERSION < *version) { + if (*version < 0) { + git_error_set(GIT_ERROR_REPOSITORY, + "invalid repository version %d", *version); + } + + if (GIT_REPO_VERSION_MAX < *version) { git_error_set(GIT_ERROR_REPOSITORY, "unsupported repository version %d; only versions up to %d are supported", - *version, GIT_REPO_MAX_VERSION); + *version, GIT_REPO_VERSION_MAX); return -1; } @@ -1963,12 +1970,13 @@ static int repo_init_config( git_config *config = NULL; bool is_bare = ((flags & GIT_REPOSITORY_INIT_BARE) != 0); bool is_reinit = ((flags & GIT_REPOSITORY_INIT__IS_REINIT) != 0); - int version = 0; + int version = GIT_REPO_VERSION_DEFAULT; if ((error = repo_local_config(&config, &cfg_path, NULL, repo_dir)) < 0) goto cleanup; - if (is_reinit && (error = check_repositoryformatversion(&version, config)) < 0) + if (is_reinit && + (error = check_repositoryformatversion(&version, config)) < 0) goto cleanup; if ((error = check_extensions(config, version)) < 0) @@ -1979,7 +1987,7 @@ static int repo_init_config( goto cleanup; } while (0) SET_REPO_CONFIG(bool, "core.bare", is_bare); - SET_REPO_CONFIG(int32, "core.repositoryformatversion", GIT_REPO_VERSION); + SET_REPO_CONFIG(int32, "core.repositoryformatversion", version); if ((error = repo_init_fs_configs( config, cfg_path.ptr, repo_dir, work_dir, !is_reinit)) < 0) diff --git a/tests/libgit2/repo/init.c b/tests/libgit2/repo/init.c index adcd9e02551..637d4a90355 100644 --- a/tests/libgit2/repo/init.c +++ b/tests/libgit2/repo/init.c @@ -142,27 +142,46 @@ void test_repo_init__reinit_bare_repo(void) cl_git_pass(git_repository_init(&g_repo, "reinit.git", 1)); } -void test_repo_init__reinit_too_recent_bare_repo(void) +void test_repo_init__reinit_nondefault_version(void) { git_config *config; + cl_set_cleanup(&cleanup_repository, "reinit.git"); + /* Initialize the repository */ cl_git_pass(git_repository_init(&g_repo, "reinit.git", 1)); git_repository_config(&config, g_repo); + /* Set the config to a supported but not default version */ + cl_repo_set_string(g_repo, "core.repositoryformatversion", "1"); + git_config_free(config); + git_repository_free(g_repo); + g_repo = NULL; + + /* Try to reinitialize the repository */ + cl_git_pass(git_repository_init(&g_repo, "reinit.git", 1)); + cl_assert_equal_i(1, cl_repo_get_int(g_repo, "core.repositoryformatversion")); + + cl_fixture_cleanup("reinit.git"); +} + +void test_repo_init__reinit_unsupported_version(void) +{ + cl_set_cleanup(&cleanup_repository, "reinit.git"); + + /* Initialize the repository */ + cl_git_pass(git_repository_init(&g_repo, "reinit.git", 1)); + /* * Hack the config of the repository to make it look like it has - * been created by a recenter version of git/libgit2 + * been created by a too new and unsupported version of git/libgit2 */ - cl_git_pass(git_config_set_int32(config, "core.repositoryformatversion", 42)); - - git_config_free(config); + cl_repo_set_string(g_repo, "core.repositoryformatversion", "42"); git_repository_free(g_repo); g_repo = NULL; - /* Try to reinitialize the repository */ + /* Try and fail to reinitialize the repository */ cl_git_fail(git_repository_init(&g_repo, "reinit.git", 1)); - cl_fixture_cleanup("reinit.git"); } From f6dbf9c5949e731b928b75090e793150d522afd1 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 3 Dec 2022 14:33:11 +0000 Subject: [PATCH 118/608] tests: helpers for getting ints from configuration --- tests/clar/clar_libgit2.c | 19 +++++++++++++++++++ tests/clar/clar_libgit2.h | 3 +++ 2 files changed, 22 insertions(+) diff --git a/tests/clar/clar_libgit2.c b/tests/clar/clar_libgit2.c index 783b457f958..2ba272706e1 100644 --- a/tests/clar/clar_libgit2.c +++ b/tests/clar/clar_libgit2.c @@ -476,6 +476,25 @@ int cl_repo_get_bool(git_repository *repo, const char *cfg) return val; } +void cl_repo_set_int(git_repository *repo, const char *cfg, int value) +{ + git_config *config; + cl_git_pass(git_repository_config(&config, repo)); + cl_git_pass(git_config_set_int32(config, cfg, value)); + git_config_free(config); +} + +int cl_repo_get_int(git_repository *repo, const char *cfg) +{ + int val = 0; + git_config *config; + cl_git_pass(git_repository_config(&config, repo)); + if (git_config_get_int32(&val, config, cfg) < 0) + git_error_clear(); + git_config_free(config); + return val; +} + void cl_repo_set_string(git_repository *repo, const char *cfg, const char *value) { git_config *config; diff --git a/tests/clar/clar_libgit2.h b/tests/clar/clar_libgit2.h index d2d9da0aaf1..a002a6d14f0 100644 --- a/tests/clar/clar_libgit2.h +++ b/tests/clar/clar_libgit2.h @@ -231,6 +231,9 @@ void cl_repo_commit_from_index( void cl_repo_set_bool(git_repository *repo, const char *cfg, int value); int cl_repo_get_bool(git_repository *repo, const char *cfg); +void cl_repo_set_int(git_repository *repo, const char *cfg, int value); +int cl_repo_get_int(git_repository *repo, const char *cfg); + void cl_repo_set_string(git_repository *repo, const char *cfg, const char *value); /* set up a fake "home" directory and set libgit2 GLOBAL search path. From 1bde753db4e302f657eb968f7eba178c2bc20205 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sun, 24 Jul 2022 13:13:32 -0400 Subject: [PATCH 119/608] ci: run sha256 builds during our nightly runs --- .github/workflows/nightly.yml | 32 +++++++++++++++++++++++++++++++- 1 file changed, 31 insertions(+), 1 deletion(-) diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml index 425a6e89ae0..5a0b7d12b0b 100644 --- a/.github/workflows/nightly.yml +++ b/.github/workflows/nightly.yml @@ -265,10 +265,40 @@ jobs: RUN_INVASIVE_TESTS: true SKIP_PROXY_TESTS: true os: ubuntu-latest + + # Experimental: SHA256 support + - name: "Linux (SHA256, Xenial, Clang, OpenSSL)" + id: xenial-clang-openssl + container: + name: xenial + env: + CC: clang + CMAKE_GENERATOR: Ninja + CMAKE_OPTIONS: -DUSE_HTTPS=OpenSSL -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=ON + os: ubuntu-latest + - name: "macOS (SHA256)" + id: macos + os: macos-10.15 + env: + CC: clang + CMAKE_OPTIONS: -DREGEX_BACKEND=regcomp_l -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=leaks -DUSE_GSSAPI=ON -DEXPERIMENTAL_SHA256=ON + PKG_CONFIG_PATH: /usr/local/opt/openssl/lib/pkgconfig + SKIP_SSH_TESTS: true + SKIP_NEGOTIATE_TESTS: true + setup-script: osx + - name: "Windows (SHA256, amd64, Visual Studio)" + id: windows-amd64-vs + os: windows-2019 + env: + ARCH: amd64 + CMAKE_GENERATOR: Visual Studio 16 2019 + CMAKE_OPTIONS: -A x64 -DWIN32_LEAKCHECK=ON -DDEPRECATE_HARD=ON -DEXPERIMENTAL_SHA256=ON + SKIP_SSH_TESTS: true + SKIP_NEGOTIATE_TESTS: true fail-fast: false - name: "Build ${{ matrix.platform.name }}" env: ${{ matrix.platform.env }} runs-on: ${{ matrix.platform.os }} + name: "Build ${{ matrix.platform.name }}" steps: - name: Check out repository uses: actions/checkout@v3 From 23df884ea7fa1a563865e9548bebe2b3eedd602b Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sun, 24 Jul 2022 13:13:45 -0400 Subject: [PATCH 120/608] tests: add a sha256 repository This is a conversion of the testrepo.git to SHA256 support. --- tests/resources/testrepo_256.git/FETCH_HEAD | 2 + tests/resources/testrepo_256.git/HEAD | 1 + tests/resources/testrepo_256.git/HEAD_TRACKER | 1 + tests/resources/testrepo_256.git/config | 8 + tests/resources/testrepo_256.git/description | 1 + .../hooks/applypatch-msg.sample | 15 + .../testrepo_256.git/hooks/commit-msg.sample | 24 + .../hooks/fsmonitor-watchman.sample | 173 ++ .../testrepo_256.git/hooks/post-update.sample | 8 + .../hooks/pre-applypatch.sample | 14 + .../testrepo_256.git/hooks/pre-commit.sample | 49 + .../hooks/pre-merge-commit.sample | 13 + .../testrepo_256.git/hooks/pre-push.sample | 53 + .../testrepo_256.git/hooks/pre-rebase.sample | 169 ++ .../testrepo_256.git/hooks/pre-receive.sample | 24 + .../hooks/prepare-commit-msg.sample | 42 + .../hooks/push-to-checkout.sample | 78 + .../testrepo_256.git/hooks/update.sample | 128 ++ tests/resources/testrepo_256.git/index | Bin 0 -> 11148 bytes tests/resources/testrepo_256.git/info/exclude | 6 + tests/resources/testrepo_256.git/logs/HEAD | 7 + .../testrepo_256.git/logs/refs/heads/br2 | 2 + .../testrepo_256.git/logs/refs/heads/master | 2 + .../testrepo_256.git/logs/refs/heads/not-good | 1 + .../logs/refs/heads/with-empty-log | 0 .../logs/refs/remotes/origin/HEAD | 1 + .../logs/refs/remotes/test/master | 2 + tests/resources/testrepo_256.git/object-idx | 1700 +++++++++++++++++ ...925bdc34ccdab778bd1d824f5562aaa319c6c8f045 | Bin 0 -> 267 bytes ...6d13866742a9070b56fd0ba9ab8dff828fc36c1f78 | 1 + ...16acdd727ea9364f7d48c55afed2f7dd889804065b | Bin 0 -> 103 bytes ...fcd19f12cc38faf337d10ec03ef4363d1a86f63750 | Bin 0 -> 21 bytes ...ba8801fe9bda46b66593291f5b9f7cd5f8888af12f | 1 + ...7e8ddfc9c8c47820fab5615cc04d904989ce800498 | Bin 0 -> 64 bytes ...4acca4ce4e1ea8508dfd77c24cefd461b65cead09e | Bin 0 -> 92 bytes ...da9be93f4afc2279623bb5b36c9194a660b7623c24 | Bin 0 -> 236 bytes ...50334e36a8015a546f0740bea4505e10d81a946f61 | Bin 0 -> 162 bytes ...08d88e14af624bb07fced6390997a0fa6abdad950a | Bin 0 -> 143 bytes ...e50a12b15f26aace3718749624f008bde68670352a | Bin 0 -> 202 bytes ...8644c307e17d0afe29b55f6488398cb59f13feb2f2 | Bin 0 -> 238 bytes ...0efa0433ac0cbd2d44679f68f2df3a9ae7014cf2a8 | Bin 0 -> 19 bytes ...830c2134815a31d9629e6aa9773338fedaab90976b | 1 + ...f2f30d79af178374166daeceefbf11e2f058d30d60 | Bin 0 -> 21 bytes ...eeca6bfffd9a0fe641784db85de2eb0f57b7553869 | Bin 0 -> 106 bytes ...89aa396d10f71c69e168d5c48ea23de59734ec3ab1 | Bin 0 -> 38 bytes ...917e3db8fde0045ee66305fd5e634b0c793c536a1b | 1 + ...e3b1e9a7dcda1185436fe141f7749120a303721813 | Bin 0 -> 15 bytes ...31b132e66ef18f564d41efb055804ec1dd28efb3f5 | Bin 0 -> 28 bytes ...2170996ce459d39e3a441e9759b635b0bc4ecc43fd | Bin 0 -> 57 bytes ...8c22b7898baaa0eda205a21cafdcb7e0f94b07bb9b | Bin 0 -> 64 bytes ...44523eb1ddeeef4bce03e35864640b452f84d26848 | 1 + ...635ab9fbee66d65fe5dda47dd0ac5f01dd69a84c6f | 3 + ...39b79f964c293db8620d679ea3596673c8a326446e | Bin 0 -> 157 bytes ...492f1bf1fcdf5dca09dab24cf331e05111b4cfc1a3 | Bin 0 -> 24 bytes ...b8f436e3ca0a82b25eddefd237bf5a26a0441c2aa7 | Bin 0 -> 107 bytes ...e660a4d510603c3f36e782a1a32ebd0388db6411ed | Bin 0 -> 181 bytes ...8aeb2c7811556538e7673e4b325307c71685fbf5b6 | Bin 0 -> 108 bytes ...417f9d5ccaf22b877c5a4522b6d1d2b16090ee2f6f | Bin 0 -> 141 bytes ...bccadee60065d8664a9af7648a1455100c4f772e1c | 2 + ...da9b3179f2419717275e3bfd2055b303489dbbfa47 | 1 + ...908dc44452ed38911cffa54ccc06076f30a1ffb1bf | Bin 0 -> 108 bytes ...c5d3f23bac1dded688b2bd314cc32b7f157e100724 | 1 + ...0b96786ebaa9ee6535fb698ec01b5f7a800fa27cbe | Bin 0 -> 137 bytes ...c294c441d08b89b455903c0c14e9b16587fec081f5 | Bin 0 -> 188 bytes ...cddea4259aea6b2961eb0822bd2c0c3f6029030045 | Bin 0 -> 18 bytes ...db7fc3a850e94f8c5ac1d71b9afa365a89005aff54 | Bin 0 -> 221 bytes ...8cc3cf4602c270a369beebc7d0b67238897bbc426b | 1 + ...24297e83e4a285f58bf5eabb1db270351388603c95 | Bin 0 -> 244 bytes ...ea61f40c14bdfc5b101b60fde4f44b58dd06667640 | Bin 0 -> 63 bytes ...3fdeed5502fd56b182af01b7740d297a24459333c5 | Bin 0 -> 26 bytes ...a3497ade7f62d2cd818bf388775cfa721de4068ebd | Bin 0 -> 54 bytes ...4ebf05e11d9c591b04cfdaff7cc860310356d71827 | 1 + ...82c5c09c22053675e2db24ea6b4b28cc75e9c10890 | Bin 0 -> 37 bytes ...a7ab8c68929bdc91b69ad54ef94979b93eba3f6022 | Bin 0 -> 190 bytes ...157ee4aad97814279fe500340eb3465797cbd3be23 | Bin 0 -> 23 bytes ...444b12c412210e9689c17e51bfc318ce4bb4360f19 | Bin 0 -> 57 bytes ...aaa96359f304c3dc97e95f336269ed474ea846ada5 | Bin 0 -> 198 bytes ...411d955520e0375fcbbcc14b7636a70f7536c32ef6 | 2 + ...787c5e94ba024ac9a4f763cb1d9bfd8e63aa7f7269 | Bin 0 -> 182 bytes ...621f5a228cb33dc84192980ca426cf9ab2a48cb9f0 | Bin 0 -> 187 bytes ...abfa899655d1b00e6529101a40d42f6acb059dff9f | Bin 0 -> 21 bytes ...3d137b654c602721c469c1b0a58e7e95647a9cf1c0 | 3 + ...8e201abb820a414de03eb63c065b06a2ab37d3f5ca | 1 + ...d3d4a80ced03101555e1fd8913b3544026c0717d4f | Bin 0 -> 181 bytes ...a5d92b78e54493fdaa78f72268d4cc69b61d5feee1 | Bin 0 -> 21 bytes ...55e9cb3cb46e348fca3b9dba3db64f7c9f64b8a736 | Bin 0 -> 157 bytes ...441f0b3f387faeddde1b37d0ad2f3f6a63f5327978 | Bin 0 -> 192 bytes ...24c75107423d5773066922ea5e55eaeb6490979562 | Bin 0 -> 157 bytes ...6e7643653c03e7f91faa27b767e3eb8225f0f6.idx | Bin 0 -> 1336 bytes ...e7643653c03e7f91faa27b767e3eb8225f0f6.pack | Bin 0 -> 569 bytes ...791b9b270067124b2609019b74f33f256f33fa.idx | Bin 0 -> 66216 bytes ...91b9b270067124b2609019b74f33f256f33fa.pack | Bin 0 -> 562646 bytes ...80b24ee981cf102db76764c383f9b87935d0d3.idx | Bin 0 -> 1336 bytes ...0b24ee981cf102db76764c383f9b87935d0d3.pack | Bin 0 -> 612 bytes tests/resources/testrepo_256.git/packed-refs | 3 + .../refs/blobs/annotated_tag_to_blob | 1 + .../resources/testrepo_256.git/refs/heads/br2 | 1 + .../testrepo_256.git/refs/heads/cannot-fetch | 1 + .../testrepo_256.git/refs/heads/chomped | 1 + .../testrepo_256.git/refs/heads/haacked | 1 + .../testrepo_256.git/refs/heads/master | 1 + .../testrepo_256.git/refs/heads/not-good | 1 + .../testrepo_256.git/refs/heads/packed-test | 1 + .../testrepo_256.git/refs/heads/subtrees | 1 + .../testrepo_256.git/refs/heads/test | 1 + .../testrepo_256.git/refs/heads/track-local | 1 + .../testrepo_256.git/refs/heads/trailing | 1 + .../refs/heads/with-empty-log | 1 + .../testrepo_256.git/refs/notes/fanout | 1 + .../testrepo_256.git/refs/remotes/test/master | 1 + .../refs/tags/annotated_tag_to_blob | 1 + .../testrepo_256.git/refs/tags/e90810b | 1 + .../testrepo_256.git/refs/tags/hard_tag | 1 + .../testrepo_256.git/refs/tags/point_to_blob | 1 + .../testrepo_256.git/refs/tags/taggerless | 1 + .../resources/testrepo_256.git/refs/tags/test | 1 + .../testrepo_256.git/refs/tags/wrapped_tag | 1 + 117 files changed, 2569 insertions(+) create mode 100644 tests/resources/testrepo_256.git/FETCH_HEAD create mode 100644 tests/resources/testrepo_256.git/HEAD create mode 100644 tests/resources/testrepo_256.git/HEAD_TRACKER create mode 100644 tests/resources/testrepo_256.git/config create mode 100644 tests/resources/testrepo_256.git/description create mode 100755 tests/resources/testrepo_256.git/hooks/applypatch-msg.sample create mode 100755 tests/resources/testrepo_256.git/hooks/commit-msg.sample create mode 100755 tests/resources/testrepo_256.git/hooks/fsmonitor-watchman.sample create mode 100755 tests/resources/testrepo_256.git/hooks/post-update.sample create mode 100755 tests/resources/testrepo_256.git/hooks/pre-applypatch.sample create mode 100755 tests/resources/testrepo_256.git/hooks/pre-commit.sample create mode 100755 tests/resources/testrepo_256.git/hooks/pre-merge-commit.sample create mode 100755 tests/resources/testrepo_256.git/hooks/pre-push.sample create mode 100755 tests/resources/testrepo_256.git/hooks/pre-rebase.sample create mode 100755 tests/resources/testrepo_256.git/hooks/pre-receive.sample create mode 100755 tests/resources/testrepo_256.git/hooks/prepare-commit-msg.sample create mode 100755 tests/resources/testrepo_256.git/hooks/push-to-checkout.sample create mode 100755 tests/resources/testrepo_256.git/hooks/update.sample create mode 100644 tests/resources/testrepo_256.git/index create mode 100644 tests/resources/testrepo_256.git/info/exclude create mode 100644 tests/resources/testrepo_256.git/logs/HEAD create mode 100644 tests/resources/testrepo_256.git/logs/refs/heads/br2 create mode 100644 tests/resources/testrepo_256.git/logs/refs/heads/master create mode 100644 tests/resources/testrepo_256.git/logs/refs/heads/not-good create mode 100644 tests/resources/testrepo_256.git/logs/refs/heads/with-empty-log create mode 100644 tests/resources/testrepo_256.git/logs/refs/remotes/origin/HEAD create mode 100644 tests/resources/testrepo_256.git/logs/refs/remotes/test/master create mode 100644 tests/resources/testrepo_256.git/object-idx create mode 100644 tests/resources/testrepo_256.git/objects/00/404e6179d86039bbc01a925bdc34ccdab778bd1d824f5562aaa319c6c8f045 create mode 100644 tests/resources/testrepo_256.git/objects/01/18010feb81fe41b9df646d13866742a9070b56fd0ba9ab8dff828fc36c1f78 create mode 100644 tests/resources/testrepo_256.git/objects/02/df938cfb169b0b6ba0dd16acdd727ea9364f7d48c55afed2f7dd889804065b create mode 100644 tests/resources/testrepo_256.git/objects/05/f7b70a01b0ade8afa5a5fcd19f12cc38faf337d10ec03ef4363d1a86f63750 create mode 100644 tests/resources/testrepo_256.git/objects/14/bd335f9d7188c778d44eba8801fe9bda46b66593291f5b9f7cd5f8888af12f create mode 100644 tests/resources/testrepo_256.git/objects/17/9496410f66032c03bd2b7e8ddfc9c8c47820fab5615cc04d904989ce800498 create mode 100644 tests/resources/testrepo_256.git/objects/19/0a1349522cc11f8682e34acca4ce4e1ea8508dfd77c24cefd461b65cead09e create mode 100644 tests/resources/testrepo_256.git/objects/1b/4b74772bd83ff28bf44cda9be93f4afc2279623bb5b36c9194a660b7623c24 create mode 100644 tests/resources/testrepo_256.git/objects/21/e1e1ebe45b2c1ef79ab050334e36a8015a546f0740bea4505e10d81a946f61 create mode 100644 tests/resources/testrepo_256.git/objects/23/8a501cf11a036f2f248008d88e14af624bb07fced6390997a0fa6abdad950a create mode 100644 tests/resources/testrepo_256.git/objects/26/149bf1ac4612f24b532ae50a12b15f26aace3718749624f008bde68670352a create mode 100644 tests/resources/testrepo_256.git/objects/2d/b6069c27ca4c08b784048644c307e17d0afe29b55f6488398cb59f13feb2f2 create mode 100644 tests/resources/testrepo_256.git/objects/33/e415b835a670bb5c3c760efa0433ac0cbd2d44679f68f2df3a9ae7014cf2a8 create mode 100644 tests/resources/testrepo_256.git/objects/34/f79ad1c813b93d2ee11c830c2134815a31d9629e6aa9773338fedaab90976b create mode 100644 tests/resources/testrepo_256.git/objects/36/eac24505d4c4405864ccf2f30d79af178374166daeceefbf11e2f058d30d60 create mode 100644 tests/resources/testrepo_256.git/objects/39/bf1ac28cc3f8432ba7cfeeca6bfffd9a0fe641784db85de2eb0f57b7553869 create mode 100644 tests/resources/testrepo_256.git/objects/3b/58565ee067f13349cd4f89aa396d10f71c69e168d5c48ea23de59734ec3ab1 create mode 100644 tests/resources/testrepo_256.git/objects/43/e084a4599ca42c476919917e3db8fde0045ee66305fd5e634b0c793c536a1b create mode 100644 tests/resources/testrepo_256.git/objects/47/3a0f4c3be8a93681a267e3b1e9a7dcda1185436fe141f7749120a303721813 create mode 100644 tests/resources/testrepo_256.git/objects/4b/c142808884e472ee6cc331b132e66ef18f564d41efb055804ec1dd28efb3f5 create mode 100644 tests/resources/testrepo_256.git/objects/4d/f8ed86acaac5dc82b5652170996ce459d39e3a441e9759b635b0bc4ecc43fd create mode 100644 tests/resources/testrepo_256.git/objects/5a/2d5699fea33657b42ba98c22b7898baaa0eda205a21cafdcb7e0f94b07bb9b create mode 100644 tests/resources/testrepo_256.git/objects/5c/a8959deb2b8327458e0344523eb1ddeeef4bce03e35864640b452f84d26848 create mode 100644 tests/resources/testrepo_256.git/objects/5d/bb1fff5c0094b31b25b4635ab9fbee66d65fe5dda47dd0ac5f01dd69a84c6f create mode 100644 tests/resources/testrepo_256.git/objects/61/489e9e831f1d9001084d39b79f964c293db8620d679ea3596673c8a326446e create mode 100644 tests/resources/testrepo_256.git/objects/6d/5fd291bb0f67444e99ab492f1bf1fcdf5dca09dab24cf331e05111b4cfc1a3 create mode 100644 tests/resources/testrepo_256.git/objects/70/30f925768d9beb65654ab8f436e3ca0a82b25eddefd237bf5a26a0441c2aa7 create mode 100644 tests/resources/testrepo_256.git/objects/73/8ff86401dbc5af692c83e660a4d510603c3f36e782a1a32ebd0388db6411ed create mode 100644 tests/resources/testrepo_256.git/objects/73/b4f3c4f3182e6c8dd2c98aeb2c7811556538e7673e4b325307c71685fbf5b6 create mode 100644 tests/resources/testrepo_256.git/objects/7e/4633ae1b0e83503dbea4417f9d5ccaf22b877c5a4522b6d1d2b16090ee2f6f create mode 100644 tests/resources/testrepo_256.git/objects/7e/9424c06052ca33bfc599bccadee60065d8664a9af7648a1455100c4f772e1c create mode 100644 tests/resources/testrepo_256.git/objects/80/91b686de8bf697ef632dda9b3179f2419717275e3bfd2055b303489dbbfa47 create mode 100644 tests/resources/testrepo_256.git/objects/81/55958bbda08eed88c8ac908dc44452ed38911cffa54ccc06076f30a1ffb1bf create mode 100644 tests/resources/testrepo_256.git/objects/90/1505c3355518bee35475c5d3f23bac1dded688b2bd314cc32b7f157e100724 create mode 100644 tests/resources/testrepo_256.git/objects/93/1093620e5f050e2127fb0b96786ebaa9ee6535fb698ec01b5f7a800fa27cbe create mode 100644 tests/resources/testrepo_256.git/objects/94/ed253efa9e86fc636805c294c441d08b89b455903c0c14e9b16587fec081f5 create mode 100644 tests/resources/testrepo_256.git/objects/96/c18f0297e38d01f4b2dacddea4259aea6b2961eb0822bd2c0c3f6029030045 create mode 100644 tests/resources/testrepo_256.git/objects/9c/cfa556cd7f73b426a7bedb7fc3a850e94f8c5ac1d71b9afa365a89005aff54 create mode 100644 tests/resources/testrepo_256.git/objects/9d/aab17c25f647d652c72c8cc3cf4602c270a369beebc7d0b67238897bbc426b create mode 100644 tests/resources/testrepo_256.git/objects/a4/813ef6708e6011e8187224297e83e4a285f58bf5eabb1db270351388603c95 create mode 100644 tests/resources/testrepo_256.git/objects/ab/ee32b3339d1566d75613ea61f40c14bdfc5b101b60fde4f44b58dd06667640 create mode 100644 tests/resources/testrepo_256.git/objects/ae/a29dc305d40e362df25c3fdeed5502fd56b182af01b7740d297a24459333c5 create mode 100644 tests/resources/testrepo_256.git/objects/b1/95873b48c824d995c974a3497ade7f62d2cd818bf388775cfa721de4068ebd create mode 100644 tests/resources/testrepo_256.git/objects/b2/1c8c27a05a3f0bf9f0f44ebf05e11d9c591b04cfdaff7cc860310356d71827 create mode 100644 tests/resources/testrepo_256.git/objects/b6/1b940a8cd979a32e005682c5c09c22053675e2db24ea6b4b28cc75e9c10890 create mode 100644 tests/resources/testrepo_256.git/objects/b8/3624f6ac0995273c0034a7ab8c68929bdc91b69ad54ef94979b93eba3f6022 create mode 100644 tests/resources/testrepo_256.git/objects/bd/f2066a28e11603a1af04157ee4aad97814279fe500340eb3465797cbd3be23 create mode 100644 tests/resources/testrepo_256.git/objects/bf/a3b3b9a161d354e2254a444b12c412210e9689c17e51bfc318ce4bb4360f19 create mode 100644 tests/resources/testrepo_256.git/objects/bf/cc4074ac517ed24d61b0aaa96359f304c3dc97e95f336269ed474ea846ada5 create mode 100644 tests/resources/testrepo_256.git/objects/c2/58f010a08328a29cde33411d955520e0375fcbbcc14b7636a70f7536c32ef6 create mode 100644 tests/resources/testrepo_256.git/objects/ca/31f7336e882a233a2943787c5e94ba024ac9a4f763cb1d9bfd8e63aa7f7269 create mode 100644 tests/resources/testrepo_256.git/objects/cb/282e7c15fd8aeb2265cd621f5a228cb33dc84192980ca426cf9ab2a48cb9f0 create mode 100644 tests/resources/testrepo_256.git/objects/cc/b5a03da85607c230d111abfa899655d1b00e6529101a40d42f6acb059dff9f create mode 100644 tests/resources/testrepo_256.git/objects/cf/84e5be57f8d5d51f136d3d137b654c602721c469c1b0a58e7e95647a9cf1c0 create mode 100644 tests/resources/testrepo_256.git/objects/d8/8b60d2641df3656381dc8e201abb820a414de03eb63c065b06a2ab37d3f5ca create mode 100644 tests/resources/testrepo_256.git/objects/de/caff3051968d1f3a2defd3d4a80ced03101555e1fd8913b3544026c0717d4f create mode 100644 tests/resources/testrepo_256.git/objects/eb/ead5965196dfaeab52b1a5d92b78e54493fdaa78f72268d4cc69b61d5feee1 create mode 100644 tests/resources/testrepo_256.git/objects/f2/a108f86a3b4fd9ad75ed55e9cb3cb46e348fca3b9dba3db64f7c9f64b8a736 create mode 100644 tests/resources/testrepo_256.git/objects/f2/c8da1a7c2eb49ff25c47441f0b3f387faeddde1b37d0ad2f3f6a63f5327978 create mode 100644 tests/resources/testrepo_256.git/objects/f3/1459efb9367c5a19c9dd24c75107423d5773066922ea5e55eaeb6490979562 create mode 100644 tests/resources/testrepo_256.git/objects/pack/pack-b87f1f214098b19ce092afb9ef6e7643653c03e7f91faa27b767e3eb8225f0f6.idx create mode 100644 tests/resources/testrepo_256.git/objects/pack/pack-b87f1f214098b19ce092afb9ef6e7643653c03e7f91faa27b767e3eb8225f0f6.pack create mode 100644 tests/resources/testrepo_256.git/objects/pack/pack-e2f07f30db7e480ea84a0e64ee791b9b270067124b2609019b74f33f256f33fa.idx create mode 100644 tests/resources/testrepo_256.git/objects/pack/pack-e2f07f30db7e480ea84a0e64ee791b9b270067124b2609019b74f33f256f33fa.pack create mode 100644 tests/resources/testrepo_256.git/objects/pack/pack-f72bbfa35af982c2a60735152c80b24ee981cf102db76764c383f9b87935d0d3.idx create mode 100644 tests/resources/testrepo_256.git/objects/pack/pack-f72bbfa35af982c2a60735152c80b24ee981cf102db76764c383f9b87935d0d3.pack create mode 100644 tests/resources/testrepo_256.git/packed-refs create mode 100644 tests/resources/testrepo_256.git/refs/blobs/annotated_tag_to_blob create mode 100644 tests/resources/testrepo_256.git/refs/heads/br2 create mode 100644 tests/resources/testrepo_256.git/refs/heads/cannot-fetch create mode 100644 tests/resources/testrepo_256.git/refs/heads/chomped create mode 100644 tests/resources/testrepo_256.git/refs/heads/haacked create mode 100644 tests/resources/testrepo_256.git/refs/heads/master create mode 100644 tests/resources/testrepo_256.git/refs/heads/not-good create mode 100644 tests/resources/testrepo_256.git/refs/heads/packed-test create mode 100644 tests/resources/testrepo_256.git/refs/heads/subtrees create mode 100644 tests/resources/testrepo_256.git/refs/heads/test create mode 100644 tests/resources/testrepo_256.git/refs/heads/track-local create mode 100644 tests/resources/testrepo_256.git/refs/heads/trailing create mode 100644 tests/resources/testrepo_256.git/refs/heads/with-empty-log create mode 100644 tests/resources/testrepo_256.git/refs/notes/fanout create mode 100644 tests/resources/testrepo_256.git/refs/remotes/test/master create mode 100644 tests/resources/testrepo_256.git/refs/tags/annotated_tag_to_blob create mode 100644 tests/resources/testrepo_256.git/refs/tags/e90810b create mode 100644 tests/resources/testrepo_256.git/refs/tags/hard_tag create mode 100644 tests/resources/testrepo_256.git/refs/tags/point_to_blob create mode 100644 tests/resources/testrepo_256.git/refs/tags/taggerless create mode 100644 tests/resources/testrepo_256.git/refs/tags/test create mode 100644 tests/resources/testrepo_256.git/refs/tags/wrapped_tag diff --git a/tests/resources/testrepo_256.git/FETCH_HEAD b/tests/resources/testrepo_256.git/FETCH_HEAD new file mode 100644 index 00000000000..4562d90261c --- /dev/null +++ b/tests/resources/testrepo_256.git/FETCH_HEAD @@ -0,0 +1,2 @@ +decaff3051968d1f3a2defd3d4a80ced03101555e1fd8913b3544026c0717d4f branch 'master' of git://example.com/git/testrepo.git +7e9424c06052ca33bfc599bccadee60065d8664a9af7648a1455100c4f772e1c not-for-merge branch 'haacked' of git://example.com/git/testrepo.git diff --git a/tests/resources/testrepo_256.git/HEAD b/tests/resources/testrepo_256.git/HEAD new file mode 100644 index 00000000000..cb089cd89a7 --- /dev/null +++ b/tests/resources/testrepo_256.git/HEAD @@ -0,0 +1 @@ +ref: refs/heads/master diff --git a/tests/resources/testrepo_256.git/HEAD_TRACKER b/tests/resources/testrepo_256.git/HEAD_TRACKER new file mode 100644 index 00000000000..40d876b4c67 --- /dev/null +++ b/tests/resources/testrepo_256.git/HEAD_TRACKER @@ -0,0 +1 @@ +ref: HEAD diff --git a/tests/resources/testrepo_256.git/config b/tests/resources/testrepo_256.git/config new file mode 100644 index 00000000000..c1aac4a0392 --- /dev/null +++ b/tests/resources/testrepo_256.git/config @@ -0,0 +1,8 @@ +[core] + repositoryFormatVersion = 1 + filemode = true + bare = true + ignorecase = true + precomposeunicode = true +[extensions] + objectFormat = sha256 diff --git a/tests/resources/testrepo_256.git/description b/tests/resources/testrepo_256.git/description new file mode 100644 index 00000000000..498b267a8c7 --- /dev/null +++ b/tests/resources/testrepo_256.git/description @@ -0,0 +1 @@ +Unnamed repository; edit this file 'description' to name the repository. diff --git a/tests/resources/testrepo_256.git/hooks/applypatch-msg.sample b/tests/resources/testrepo_256.git/hooks/applypatch-msg.sample new file mode 100755 index 00000000000..a5d7b84a673 --- /dev/null +++ b/tests/resources/testrepo_256.git/hooks/applypatch-msg.sample @@ -0,0 +1,15 @@ +#!/bin/sh +# +# An example hook script to check the commit log message taken by +# applypatch from an e-mail message. +# +# The hook should exit with non-zero status after issuing an +# appropriate message if it wants to stop the commit. The hook is +# allowed to edit the commit message file. +# +# To enable this hook, rename this file to "applypatch-msg". + +. git-sh-setup +commitmsg="$(git rev-parse --git-path hooks/commit-msg)" +test -x "$commitmsg" && exec "$commitmsg" ${1+"$@"} +: diff --git a/tests/resources/testrepo_256.git/hooks/commit-msg.sample b/tests/resources/testrepo_256.git/hooks/commit-msg.sample new file mode 100755 index 00000000000..b58d1184a9d --- /dev/null +++ b/tests/resources/testrepo_256.git/hooks/commit-msg.sample @@ -0,0 +1,24 @@ +#!/bin/sh +# +# An example hook script to check the commit log message. +# Called by "git commit" with one argument, the name of the file +# that has the commit message. The hook should exit with non-zero +# status after issuing an appropriate message if it wants to stop the +# commit. The hook is allowed to edit the commit message file. +# +# To enable this hook, rename this file to "commit-msg". + +# Uncomment the below to add a Signed-off-by line to the message. +# Doing this in a hook is a bad idea in general, but the prepare-commit-msg +# hook is more suited to it. +# +# SOB=$(git var GIT_AUTHOR_IDENT | sed -n 's/^\(.*>\).*$/Signed-off-by: \1/p') +# grep -qs "^$SOB" "$1" || echo "$SOB" >> "$1" + +# This example catches duplicate Signed-off-by lines. + +test "" = "$(grep '^Signed-off-by: ' "$1" | + sort | uniq -c | sed -e '/^[ ]*1[ ]/d')" || { + echo >&2 Duplicate Signed-off-by lines. + exit 1 +} diff --git a/tests/resources/testrepo_256.git/hooks/fsmonitor-watchman.sample b/tests/resources/testrepo_256.git/hooks/fsmonitor-watchman.sample new file mode 100755 index 00000000000..14ed0aa42de --- /dev/null +++ b/tests/resources/testrepo_256.git/hooks/fsmonitor-watchman.sample @@ -0,0 +1,173 @@ +#!/usr/bin/perl + +use strict; +use warnings; +use IPC::Open2; + +# An example hook script to integrate Watchman +# (https://facebook.github.io/watchman/) with git to speed up detecting +# new and modified files. +# +# The hook is passed a version (currently 2) and last update token +# formatted as a string and outputs to stdout a new update token and +# all files that have been modified since the update token. Paths must +# be relative to the root of the working tree and separated by a single NUL. +# +# To enable this hook, rename this file to "query-watchman" and set +# 'git config core.fsmonitor .git/hooks/query-watchman' +# +my ($version, $last_update_token) = @ARGV; + +# Uncomment for debugging +# print STDERR "$0 $version $last_update_token\n"; + +# Check the hook interface version +if ($version ne 2) { + die "Unsupported query-fsmonitor hook version '$version'.\n" . + "Falling back to scanning...\n"; +} + +my $git_work_tree = get_working_dir(); + +my $retry = 1; + +my $json_pkg; +eval { + require JSON::XS; + $json_pkg = "JSON::XS"; + 1; +} or do { + require JSON::PP; + $json_pkg = "JSON::PP"; +}; + +launch_watchman(); + +sub launch_watchman { + my $o = watchman_query(); + if (is_work_tree_watched($o)) { + output_result($o->{clock}, @{$o->{files}}); + } +} + +sub output_result { + my ($clockid, @files) = @_; + + # Uncomment for debugging watchman output + # open (my $fh, ">", ".git/watchman-output.out"); + # binmode $fh, ":utf8"; + # print $fh "$clockid\n@files\n"; + # close $fh; + + binmode STDOUT, ":utf8"; + print $clockid; + print "\0"; + local $, = "\0"; + print @files; +} + +sub watchman_clock { + my $response = qx/watchman clock "$git_work_tree"/; + die "Failed to get clock id on '$git_work_tree'.\n" . + "Falling back to scanning...\n" if $? != 0; + + return $json_pkg->new->utf8->decode($response); +} + +sub watchman_query { + my $pid = open2(\*CHLD_OUT, \*CHLD_IN, 'watchman -j --no-pretty') + or die "open2() failed: $!\n" . + "Falling back to scanning...\n"; + + # In the query expression below we're asking for names of files that + # changed since $last_update_token but not from the .git folder. + # + # To accomplish this, we're using the "since" generator to use the + # recency index to select candidate nodes and "fields" to limit the + # output to file names only. Then we're using the "expression" term to + # further constrain the results. + if (substr($last_update_token, 0, 1) eq "c") { + $last_update_token = "\"$last_update_token\""; + } + my $query = <<" END"; + ["query", "$git_work_tree", { + "since": $last_update_token, + "fields": ["name"], + "expression": ["not", ["dirname", ".git"]] + }] + END + + # Uncomment for debugging the watchman query + # open (my $fh, ">", ".git/watchman-query.json"); + # print $fh $query; + # close $fh; + + print CHLD_IN $query; + close CHLD_IN; + my $response = do {local $/; }; + + # Uncomment for debugging the watch response + # open ($fh, ">", ".git/watchman-response.json"); + # print $fh $response; + # close $fh; + + die "Watchman: command returned no output.\n" . + "Falling back to scanning...\n" if $response eq ""; + die "Watchman: command returned invalid output: $response\n" . + "Falling back to scanning...\n" unless $response =~ /^\{/; + + return $json_pkg->new->utf8->decode($response); +} + +sub is_work_tree_watched { + my ($output) = @_; + my $error = $output->{error}; + if ($retry > 0 and $error and $error =~ m/unable to resolve root .* directory (.*) is not watched/) { + $retry--; + my $response = qx/watchman watch "$git_work_tree"/; + die "Failed to make watchman watch '$git_work_tree'.\n" . + "Falling back to scanning...\n" if $? != 0; + $output = $json_pkg->new->utf8->decode($response); + $error = $output->{error}; + die "Watchman: $error.\n" . + "Falling back to scanning...\n" if $error; + + # Uncomment for debugging watchman output + # open (my $fh, ">", ".git/watchman-output.out"); + # close $fh; + + # Watchman will always return all files on the first query so + # return the fast "everything is dirty" flag to git and do the + # Watchman query just to get it over with now so we won't pay + # the cost in git to look up each individual file. + my $o = watchman_clock(); + $error = $output->{error}; + + die "Watchman: $error.\n" . + "Falling back to scanning...\n" if $error; + + output_result($o->{clock}, ("/")); + $last_update_token = $o->{clock}; + + eval { launch_watchman() }; + return 0; + } + + die "Watchman: $error.\n" . + "Falling back to scanning...\n" if $error; + + return 1; +} + +sub get_working_dir { + my $working_dir; + if ($^O =~ 'msys' || $^O =~ 'cygwin') { + $working_dir = Win32::GetCwd(); + $working_dir =~ tr/\\/\//; + } else { + require Cwd; + $working_dir = Cwd::cwd(); + } + + return $working_dir; +} diff --git a/tests/resources/testrepo_256.git/hooks/post-update.sample b/tests/resources/testrepo_256.git/hooks/post-update.sample new file mode 100755 index 00000000000..ec17ec1939b --- /dev/null +++ b/tests/resources/testrepo_256.git/hooks/post-update.sample @@ -0,0 +1,8 @@ +#!/bin/sh +# +# An example hook script to prepare a packed repository for use over +# dumb transports. +# +# To enable this hook, rename this file to "post-update". + +exec git update-server-info diff --git a/tests/resources/testrepo_256.git/hooks/pre-applypatch.sample b/tests/resources/testrepo_256.git/hooks/pre-applypatch.sample new file mode 100755 index 00000000000..4142082bcb9 --- /dev/null +++ b/tests/resources/testrepo_256.git/hooks/pre-applypatch.sample @@ -0,0 +1,14 @@ +#!/bin/sh +# +# An example hook script to verify what is about to be committed +# by applypatch from an e-mail message. +# +# The hook should exit with non-zero status after issuing an +# appropriate message if it wants to stop the commit. +# +# To enable this hook, rename this file to "pre-applypatch". + +. git-sh-setup +precommit="$(git rev-parse --git-path hooks/pre-commit)" +test -x "$precommit" && exec "$precommit" ${1+"$@"} +: diff --git a/tests/resources/testrepo_256.git/hooks/pre-commit.sample b/tests/resources/testrepo_256.git/hooks/pre-commit.sample new file mode 100755 index 00000000000..e144712c85c --- /dev/null +++ b/tests/resources/testrepo_256.git/hooks/pre-commit.sample @@ -0,0 +1,49 @@ +#!/bin/sh +# +# An example hook script to verify what is about to be committed. +# Called by "git commit" with no arguments. The hook should +# exit with non-zero status after issuing an appropriate message if +# it wants to stop the commit. +# +# To enable this hook, rename this file to "pre-commit". + +if git rev-parse --verify HEAD >/dev/null 2>&1 +then + against=HEAD +else + # Initial commit: diff against an empty tree object + against=$(git hash-object -t tree /dev/null) +fi + +# If you want to allow non-ASCII filenames set this variable to true. +allownonascii=$(git config --type=bool hooks.allownonascii) + +# Redirect output to stderr. +exec 1>&2 + +# Cross platform projects tend to avoid non-ASCII filenames; prevent +# them from being added to the repository. We exploit the fact that the +# printable range starts at the space character and ends with tilde. +if [ "$allownonascii" != "true" ] && + # Note that the use of brackets around a tr range is ok here, (it's + # even required, for portability to Solaris 10's /usr/bin/tr), since + # the square bracket bytes happen to fall in the designated range. + test $(git diff --cached --name-only --diff-filter=A -z $against | + LC_ALL=C tr -d '[ -~]\0' | wc -c) != 0 +then + cat <<\EOF +Error: Attempt to add a non-ASCII file name. + +This can cause problems if you want to work with people on other platforms. + +To be portable it is advisable to rename the file. + +If you know what you are doing you can disable this check using: + + git config hooks.allownonascii true +EOF + exit 1 +fi + +# If there are whitespace errors, print the offending file names and fail. +exec git diff-index --check --cached $against -- diff --git a/tests/resources/testrepo_256.git/hooks/pre-merge-commit.sample b/tests/resources/testrepo_256.git/hooks/pre-merge-commit.sample new file mode 100755 index 00000000000..399eab1924e --- /dev/null +++ b/tests/resources/testrepo_256.git/hooks/pre-merge-commit.sample @@ -0,0 +1,13 @@ +#!/bin/sh +# +# An example hook script to verify what is about to be committed. +# Called by "git merge" with no arguments. The hook should +# exit with non-zero status after issuing an appropriate message to +# stderr if it wants to stop the merge commit. +# +# To enable this hook, rename this file to "pre-merge-commit". + +. git-sh-setup +test -x "$GIT_DIR/hooks/pre-commit" && + exec "$GIT_DIR/hooks/pre-commit" +: diff --git a/tests/resources/testrepo_256.git/hooks/pre-push.sample b/tests/resources/testrepo_256.git/hooks/pre-push.sample new file mode 100755 index 00000000000..4ce688d32b7 --- /dev/null +++ b/tests/resources/testrepo_256.git/hooks/pre-push.sample @@ -0,0 +1,53 @@ +#!/bin/sh + +# An example hook script to verify what is about to be pushed. Called by "git +# push" after it has checked the remote status, but before anything has been +# pushed. If this script exits with a non-zero status nothing will be pushed. +# +# This hook is called with the following parameters: +# +# $1 -- Name of the remote to which the push is being done +# $2 -- URL to which the push is being done +# +# If pushing without using a named remote those arguments will be equal. +# +# Information about the commits which are being pushed is supplied as lines to +# the standard input in the form: +# +# +# +# This sample shows how to prevent push of commits where the log message starts +# with "WIP" (work in progress). + +remote="$1" +url="$2" + +zero=$(git hash-object --stdin &2 "Found WIP commit in $local_ref, not pushing" + exit 1 + fi + fi +done + +exit 0 diff --git a/tests/resources/testrepo_256.git/hooks/pre-rebase.sample b/tests/resources/testrepo_256.git/hooks/pre-rebase.sample new file mode 100755 index 00000000000..6cbef5c370d --- /dev/null +++ b/tests/resources/testrepo_256.git/hooks/pre-rebase.sample @@ -0,0 +1,169 @@ +#!/bin/sh +# +# Copyright (c) 2006, 2008 Junio C Hamano +# +# The "pre-rebase" hook is run just before "git rebase" starts doing +# its job, and can prevent the command from running by exiting with +# non-zero status. +# +# The hook is called with the following parameters: +# +# $1 -- the upstream the series was forked from. +# $2 -- the branch being rebased (or empty when rebasing the current branch). +# +# This sample shows how to prevent topic branches that are already +# merged to 'next' branch from getting rebased, because allowing it +# would result in rebasing already published history. + +publish=next +basebranch="$1" +if test "$#" = 2 +then + topic="refs/heads/$2" +else + topic=`git symbolic-ref HEAD` || + exit 0 ;# we do not interrupt rebasing detached HEAD +fi + +case "$topic" in +refs/heads/??/*) + ;; +*) + exit 0 ;# we do not interrupt others. + ;; +esac + +# Now we are dealing with a topic branch being rebased +# on top of master. Is it OK to rebase it? + +# Does the topic really exist? +git show-ref -q "$topic" || { + echo >&2 "No such branch $topic" + exit 1 +} + +# Is topic fully merged to master? +not_in_master=`git rev-list --pretty=oneline ^master "$topic"` +if test -z "$not_in_master" +then + echo >&2 "$topic is fully merged to master; better remove it." + exit 1 ;# we could allow it, but there is no point. +fi + +# Is topic ever merged to next? If so you should not be rebasing it. +only_next_1=`git rev-list ^master "^$topic" ${publish} | sort` +only_next_2=`git rev-list ^master ${publish} | sort` +if test "$only_next_1" = "$only_next_2" +then + not_in_topic=`git rev-list "^$topic" master` + if test -z "$not_in_topic" + then + echo >&2 "$topic is already up to date with master" + exit 1 ;# we could allow it, but there is no point. + else + exit 0 + fi +else + not_in_next=`git rev-list --pretty=oneline ^${publish} "$topic"` + /usr/bin/perl -e ' + my $topic = $ARGV[0]; + my $msg = "* $topic has commits already merged to public branch:\n"; + my (%not_in_next) = map { + /^([0-9a-f]+) /; + ($1 => 1); + } split(/\n/, $ARGV[1]); + for my $elem (map { + /^([0-9a-f]+) (.*)$/; + [$1 => $2]; + } split(/\n/, $ARGV[2])) { + if (!exists $not_in_next{$elem->[0]}) { + if ($msg) { + print STDERR $msg; + undef $msg; + } + print STDERR " $elem->[1]\n"; + } + } + ' "$topic" "$not_in_next" "$not_in_master" + exit 1 +fi + +<<\DOC_END + +This sample hook safeguards topic branches that have been +published from being rewound. + +The workflow assumed here is: + + * Once a topic branch forks from "master", "master" is never + merged into it again (either directly or indirectly). + + * Once a topic branch is fully cooked and merged into "master", + it is deleted. If you need to build on top of it to correct + earlier mistakes, a new topic branch is created by forking at + the tip of the "master". This is not strictly necessary, but + it makes it easier to keep your history simple. + + * Whenever you need to test or publish your changes to topic + branches, merge them into "next" branch. + +The script, being an example, hardcodes the publish branch name +to be "next", but it is trivial to make it configurable via +$GIT_DIR/config mechanism. + +With this workflow, you would want to know: + +(1) ... if a topic branch has ever been merged to "next". Young + topic branches can have stupid mistakes you would rather + clean up before publishing, and things that have not been + merged into other branches can be easily rebased without + affecting other people. But once it is published, you would + not want to rewind it. + +(2) ... if a topic branch has been fully merged to "master". + Then you can delete it. More importantly, you should not + build on top of it -- other people may already want to + change things related to the topic as patches against your + "master", so if you need further changes, it is better to + fork the topic (perhaps with the same name) afresh from the + tip of "master". + +Let's look at this example: + + o---o---o---o---o---o---o---o---o---o "next" + / / / / + / a---a---b A / / + / / / / + / / c---c---c---c B / + / / / \ / + / / / b---b C \ / + / / / / \ / + ---o---o---o---o---o---o---o---o---o---o---o "master" + + +A, B and C are topic branches. + + * A has one fix since it was merged up to "next". + + * B has finished. It has been fully merged up to "master" and "next", + and is ready to be deleted. + + * C has not merged to "next" at all. + +We would want to allow C to be rebased, refuse A, and encourage +B to be deleted. + +To compute (1): + + git rev-list ^master ^topic next + git rev-list ^master next + + if these match, topic has not merged in next at all. + +To compute (2): + + git rev-list master..topic + + if this is empty, it is fully merged to "master". + +DOC_END diff --git a/tests/resources/testrepo_256.git/hooks/pre-receive.sample b/tests/resources/testrepo_256.git/hooks/pre-receive.sample new file mode 100755 index 00000000000..a1fd29ec148 --- /dev/null +++ b/tests/resources/testrepo_256.git/hooks/pre-receive.sample @@ -0,0 +1,24 @@ +#!/bin/sh +# +# An example hook script to make use of push options. +# The example simply echoes all push options that start with 'echoback=' +# and rejects all pushes when the "reject" push option is used. +# +# To enable this hook, rename this file to "pre-receive". + +if test -n "$GIT_PUSH_OPTION_COUNT" +then + i=0 + while test "$i" -lt "$GIT_PUSH_OPTION_COUNT" + do + eval "value=\$GIT_PUSH_OPTION_$i" + case "$value" in + echoback=*) + echo "echo from the pre-receive-hook: ${value#*=}" >&2 + ;; + reject) + exit 1 + esac + i=$((i + 1)) + done +fi diff --git a/tests/resources/testrepo_256.git/hooks/prepare-commit-msg.sample b/tests/resources/testrepo_256.git/hooks/prepare-commit-msg.sample new file mode 100755 index 00000000000..10fa14c5ab0 --- /dev/null +++ b/tests/resources/testrepo_256.git/hooks/prepare-commit-msg.sample @@ -0,0 +1,42 @@ +#!/bin/sh +# +# An example hook script to prepare the commit log message. +# Called by "git commit" with the name of the file that has the +# commit message, followed by the description of the commit +# message's source. The hook's purpose is to edit the commit +# message file. If the hook fails with a non-zero status, +# the commit is aborted. +# +# To enable this hook, rename this file to "prepare-commit-msg". + +# This hook includes three examples. The first one removes the +# "# Please enter the commit message..." help message. +# +# The second includes the output of "git diff --name-status -r" +# into the message, just before the "git status" output. It is +# commented because it doesn't cope with --amend or with squashed +# commits. +# +# The third example adds a Signed-off-by line to the message, that can +# still be edited. This is rarely a good idea. + +COMMIT_MSG_FILE=$1 +COMMIT_SOURCE=$2 +SHA1=$3 + +/usr/bin/perl -i.bak -ne 'print unless(m/^. Please enter the commit message/..m/^#$/)' "$COMMIT_MSG_FILE" + +# case "$COMMIT_SOURCE,$SHA1" in +# ,|template,) +# /usr/bin/perl -i.bak -pe ' +# print "\n" . `git diff --cached --name-status -r` +# if /^#/ && $first++ == 0' "$COMMIT_MSG_FILE" ;; +# *) ;; +# esac + +# SOB=$(git var GIT_COMMITTER_IDENT | sed -n 's/^\(.*>\).*$/Signed-off-by: \1/p') +# git interpret-trailers --in-place --trailer "$SOB" "$COMMIT_MSG_FILE" +# if test -z "$COMMIT_SOURCE" +# then +# /usr/bin/perl -i.bak -pe 'print "\n" if !$first_line++' "$COMMIT_MSG_FILE" +# fi diff --git a/tests/resources/testrepo_256.git/hooks/push-to-checkout.sample b/tests/resources/testrepo_256.git/hooks/push-to-checkout.sample new file mode 100755 index 00000000000..af5a0c0018b --- /dev/null +++ b/tests/resources/testrepo_256.git/hooks/push-to-checkout.sample @@ -0,0 +1,78 @@ +#!/bin/sh + +# An example hook script to update a checked-out tree on a git push. +# +# This hook is invoked by git-receive-pack(1) when it reacts to git +# push and updates reference(s) in its repository, and when the push +# tries to update the branch that is currently checked out and the +# receive.denyCurrentBranch configuration variable is set to +# updateInstead. +# +# By default, such a push is refused if the working tree and the index +# of the remote repository has any difference from the currently +# checked out commit; when both the working tree and the index match +# the current commit, they are updated to match the newly pushed tip +# of the branch. This hook is to be used to override the default +# behaviour; however the code below reimplements the default behaviour +# as a starting point for convenient modification. +# +# The hook receives the commit with which the tip of the current +# branch is going to be updated: +commit=$1 + +# It can exit with a non-zero status to refuse the push (when it does +# so, it must not modify the index or the working tree). +die () { + echo >&2 "$*" + exit 1 +} + +# Or it can make any necessary changes to the working tree and to the +# index to bring them to the desired state when the tip of the current +# branch is updated to the new commit, and exit with a zero status. +# +# For example, the hook can simply run git read-tree -u -m HEAD "$1" +# in order to emulate git fetch that is run in the reverse direction +# with git push, as the two-tree form of git read-tree -u -m is +# essentially the same as git switch or git checkout that switches +# branches while keeping the local changes in the working tree that do +# not interfere with the difference between the branches. + +# The below is a more-or-less exact translation to shell of the C code +# for the default behaviour for git's push-to-checkout hook defined in +# the push_to_deploy() function in builtin/receive-pack.c. +# +# Note that the hook will be executed from the repository directory, +# not from the working tree, so if you want to perform operations on +# the working tree, you will have to adapt your code accordingly, e.g. +# by adding "cd .." or using relative paths. + +if ! git update-index -q --ignore-submodules --refresh +then + die "Up-to-date check failed" +fi + +if ! git diff-files --quiet --ignore-submodules -- +then + die "Working directory has unstaged changes" +fi + +# This is a rough translation of: +# +# head_has_history() ? "HEAD" : EMPTY_TREE_SHA1_HEX +if git cat-file -e HEAD 2>/dev/null +then + head=HEAD +else + head=$(git hash-object -t tree --stdin &2 + echo " (if you want, you could supply GIT_DIR then run" >&2 + echo " $0 )" >&2 + exit 1 +fi + +if [ -z "$refname" -o -z "$oldrev" -o -z "$newrev" ]; then + echo "usage: $0 " >&2 + exit 1 +fi + +# --- Config +allowunannotated=$(git config --type=bool hooks.allowunannotated) +allowdeletebranch=$(git config --type=bool hooks.allowdeletebranch) +denycreatebranch=$(git config --type=bool hooks.denycreatebranch) +allowdeletetag=$(git config --type=bool hooks.allowdeletetag) +allowmodifytag=$(git config --type=bool hooks.allowmodifytag) + +# check for no description +projectdesc=$(sed -e '1q' "$GIT_DIR/description") +case "$projectdesc" in +"Unnamed repository"* | "") + echo "*** Project description file hasn't been set" >&2 + exit 1 + ;; +esac + +# --- Check types +# if $newrev is 0000...0000, it's a commit to delete a ref. +zero=$(git hash-object --stdin &2 + echo "*** Use 'git tag [ -a | -s ]' for tags you want to propagate." >&2 + exit 1 + fi + ;; + refs/tags/*,delete) + # delete tag + if [ "$allowdeletetag" != "true" ]; then + echo "*** Deleting a tag is not allowed in this repository" >&2 + exit 1 + fi + ;; + refs/tags/*,tag) + # annotated tag + if [ "$allowmodifytag" != "true" ] && git rev-parse $refname > /dev/null 2>&1 + then + echo "*** Tag '$refname' already exists." >&2 + echo "*** Modifying a tag is not allowed in this repository." >&2 + exit 1 + fi + ;; + refs/heads/*,commit) + # branch + if [ "$oldrev" = "$zero" -a "$denycreatebranch" = "true" ]; then + echo "*** Creating a branch is not allowed in this repository" >&2 + exit 1 + fi + ;; + refs/heads/*,delete) + # delete branch + if [ "$allowdeletebranch" != "true" ]; then + echo "*** Deleting a branch is not allowed in this repository" >&2 + exit 1 + fi + ;; + refs/remotes/*,commit) + # tracking branch + ;; + refs/remotes/*,delete) + # delete tracking branch + if [ "$allowdeletebranch" != "true" ]; then + echo "*** Deleting a tracking branch is not allowed in this repository" >&2 + exit 1 + fi + ;; + *) + # Anything else (is there anything else?) + echo "*** Update hook: unknown type of update to ref $refname of type $newrev_type" >&2 + exit 1 + ;; +esac + +# --- Finished +exit 0 diff --git a/tests/resources/testrepo_256.git/index b/tests/resources/testrepo_256.git/index new file mode 100644 index 0000000000000000000000000000000000000000..838e73883bae7a33e15607de712e2771ac91b236 GIT binary patch literal 11148 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 literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/info/exclude b/tests/resources/testrepo_256.git/info/exclude new file mode 100644 index 00000000000..a5196d1be8f --- /dev/null +++ b/tests/resources/testrepo_256.git/info/exclude @@ -0,0 +1,6 @@ +# git ls-files --others --exclude-from=.git/info/exclude +# Lines that start with '#' are comments. +# For a project mostly in C, the following would be a good set of +# exclude patterns (uncomment them if you want to use them): +# *.[oa] +# *~ diff --git a/tests/resources/testrepo_256.git/logs/HEAD b/tests/resources/testrepo_256.git/logs/HEAD new file mode 100644 index 00000000000..59a4bb5f049 --- /dev/null +++ b/tests/resources/testrepo_256.git/logs/HEAD @@ -0,0 +1,7 @@ +0000000000000000000000000000000000000000000000000000000000000000 1b4b74772bd83ff28bf44cda9be93f4afc2279623bb5b36c9194a660b7623c24 Ben Straub 1335806563 -0700 clone: from /Users/ben/src/libgit2/tests/resources/testrepo.git +1b4b74772bd83ff28bf44cda9be93f4afc2279623bb5b36c9194a660b7623c24 decaff3051968d1f3a2defd3d4a80ced03101555e1fd8913b3544026c0717d4f Ben Straub 1335806603 -0900 commit: +decaff3051968d1f3a2defd3d4a80ced03101555e1fd8913b3544026c0717d4f cb282e7c15fd8aeb2265cd621f5a228cb33dc84192980ca426cf9ab2a48cb9f0 Ben Straub 1335806604 -0900 checkout: moving from master to 5b5b025 +cb282e7c15fd8aeb2265cd621f5a228cb33dc84192980ca426cf9ab2a48cb9f0 decaff3051968d1f3a2defd3d4a80ced03101555e1fd8913b3544026c0717d4f Ben Straub 1335806605 -0900 checkout: moving from 5b5b025 to master +decaff3051968d1f3a2defd3d4a80ced03101555e1fd8913b3544026c0717d4f 901505c3355518bee35475c5d3f23bac1dded688b2bd314cc32b7f157e100724 Ben Straub 1335806608 -0900 checkout: moving from master to br2 +901505c3355518bee35475c5d3f23bac1dded688b2bd314cc32b7f157e100724 a4813ef6708e6011e8187224297e83e4a285f58bf5eabb1db270351388603c95 Ben Straub 1335806617 -0900 commit: checking in +a4813ef6708e6011e8187224297e83e4a285f58bf5eabb1db270351388603c95 decaff3051968d1f3a2defd3d4a80ced03101555e1fd8913b3544026c0717d4f Ben Straub 1335806621 -0900 checkout: moving from br2 to master diff --git a/tests/resources/testrepo_256.git/logs/refs/heads/br2 b/tests/resources/testrepo_256.git/logs/refs/heads/br2 new file mode 100644 index 00000000000..e8ada81930a --- /dev/null +++ b/tests/resources/testrepo_256.git/logs/refs/heads/br2 @@ -0,0 +1,2 @@ +0000000000000000000000000000000000000000000000000000000000000000 901505c3355518bee35475c5d3f23bac1dded688b2bd314cc32b7f157e100724 Ben Straub 1335806608 -0700 branch: Created from refs/remotes/origin/br2 +a4813ef6708e6011e8187224297e83e4a285f58bf5eabb1db270351388603c95 a4813ef6708e6011e8187224297e83e4a285f58bf5eabb1db270351388603c95 Ben Straub 1335806617 -0700 commit: checking in diff --git a/tests/resources/testrepo_256.git/logs/refs/heads/master b/tests/resources/testrepo_256.git/logs/refs/heads/master new file mode 100644 index 00000000000..4b4c53f42bc --- /dev/null +++ b/tests/resources/testrepo_256.git/logs/refs/heads/master @@ -0,0 +1,2 @@ +0000000000000000000000000000000000000000000000000000000000000000 1b4b74772bd83ff28bf44cda9be93f4afc2279623bb5b36c9194a660b7623c24 Ben Straub 1335806563 -0800 clone: from /Users/ben/src/libgit2/tests/resources/testrepo.git +1b4b74772bd83ff28bf44cda9be93f4afc2279623bb5b36c9194a660b7623c24 decaff3051968d1f3a2defd3d4a80ced03101555e1fd8913b3544026c0717d4f Ben Straub 1335806603 -0800 commit: checking in diff --git a/tests/resources/testrepo_256.git/logs/refs/heads/not-good b/tests/resources/testrepo_256.git/logs/refs/heads/not-good new file mode 100644 index 00000000000..6bac45bec14 --- /dev/null +++ b/tests/resources/testrepo_256.git/logs/refs/heads/not-good @@ -0,0 +1 @@ +0000000000000000000000000000000000000000000000000000000000000000 decaff3051968d1f3a2defd3d4a80ced03101555e1fd8913b3544026c0717d4f Ben Straub 1336761944 -0700 branch: Created from master diff --git a/tests/resources/testrepo_256.git/logs/refs/heads/with-empty-log b/tests/resources/testrepo_256.git/logs/refs/heads/with-empty-log new file mode 100644 index 00000000000..e69de29bb2d diff --git a/tests/resources/testrepo_256.git/logs/refs/remotes/origin/HEAD b/tests/resources/testrepo_256.git/logs/refs/remotes/origin/HEAD new file mode 100644 index 00000000000..c1c020cff3e --- /dev/null +++ b/tests/resources/testrepo_256.git/logs/refs/remotes/origin/HEAD @@ -0,0 +1 @@ +0000000000000000000000000000000000000000000000000000000000000000 1b4b74772bd83ff28bf44cda9be93f4afc2279623bb5b36c9194a660b7623c24 Ben Straub 1335806563 -0700 clone: from /Users/ben/src/libgit2/tests/resources/testrepo.git diff --git a/tests/resources/testrepo_256.git/logs/refs/remotes/test/master b/tests/resources/testrepo_256.git/logs/refs/remotes/test/master new file mode 100644 index 00000000000..42bdaa27fc1 --- /dev/null +++ b/tests/resources/testrepo_256.git/logs/refs/remotes/test/master @@ -0,0 +1,2 @@ +0000000000000000000000000000000000000000000000000000000000000000 decaff3051968d1f3a2defd3d4a80ced03101555e1fd8913b3544026c0717d4f Ben Straub 1335806565 -0800 update by push +decaff3051968d1f3a2defd3d4a80ced03101555e1fd8913b3544026c0717d4f 1b4b74772bd83ff28bf44cda9be93f4afc2279623bb5b36c9194a660b7623c24 Ben Straub 1335806688 -0800 update by push diff --git a/tests/resources/testrepo_256.git/object-idx b/tests/resources/testrepo_256.git/object-idx new file mode 100644 index 00000000000..c4ce7c4bfde --- /dev/null +++ b/tests/resources/testrepo_256.git/object-idx @@ -0,0 +1,1700 @@ +0007e4a07f4c922a647ac9930790e6640c61b8555d0e0195d164bce8685f2390 05bf6713e26fca9af0b116adf6fa1a0e4a3a957c +002bf814b089dd7941f9cdd449e8c3a52815e8f8f5fdc918c4ff3fe4a2a88119 3e590fb2221ea3c117b7347956843d24132ac22b +00404e6179d86039bbc01a925bdc34ccdab778bd1d824f5562aaa319c6c8f045 b91e763008b10db366442469339f90a2b8400d0a +0052fc5cfde91bf84d96ea764b24ccd20ce9d98a354bf69a6bd89c2ad38f977b 00c5bdc46d8f91dda9f64086347d60c18d1a1f8f +0092a5b445971910ad22ef5636caf11f6926695fa8eeaf34a4fb7abecc4a0e44 404e1182dc52d4caf284d0f39567cde79649b651 +00b1f32aab597e7bff93f9790bf580b030f4ed71d620a7178b2d9a2bad5b1f86 27c3c27807e7fd3c053e0bffc6da68051f343ba2 +0113a79463a552823f5865aeaa641137ad8741ac85ef923014a6a7c0c36aa1a3 73630ef121eb0e4a601df784dff973b321813f02 +01177bbe7923049c27d557ed912d7440e2925bda5a37492744a83c1ff2fdda1f 5f10ae02d45a1f030cf0255ff813d62fcf7e5575 +0118010feb81fe41b9df646d13866742a9070b56fd0ba9ab8dff828fc36c1f78 763d71aadf09a7951596c9746c024e7eece7c7af +01731a6f97a36dc0299d3bd87b16f0679d675dc8bfc484dfc1173e3dea5914de 5f340851194fa963878fa70e6ef4b19bd2c74ee2 +01a1e78e1078db69cb6197fbc564851bb5861e6938638169c9111bfd08b608b0 11d973c9507b5768f2c312ad9ffa35f0baae8793 +01d396efb693b1b691ada667e623864b802bf4b57bd4fade0fb6d75688a9b99b d5d4b8cd7faeb7749015896a303f1d5331638d00 +0210a4981f476c0d98929dded65b4dc0ff653f0876c45ff08a6e7a1d647a4b2a d39941396f81224f394f1d59c31f64e2d0424fab +0216b94271c2795357116d8f9ae45facd9bb1658c5a42ef38ea54e57833ffa3f bdf2334251d8e65a999b96fc99547ba99e2f0205 +0244a04d70a80f0e5baaefe7ac1cd73dcb00692f982e1e3af824252a5d48fb3d 182f2b39391ff4db4008554e97753fdba4e1b57e +024e2a82f18d1034c0954bc91c96af19c98029aaab3f6aa8fde5ff1f5e70afe6 f57c220bb0949ba4d6da1967bbbbc7544c18c0d0 +027d76e06b173a74af36c5d1a10761c830b59ed8dc03acc58d1ae008b176160e 1b24fa1fb836589fef658723c5a68cda9a2647dc +0285241dd82eda29ba38b91c04f6385fae1b1b88990f8d0c86a88b5e6401a495 7c25137751c32c3971a57cc66c564dfc321328e1 +028e02901e7de25b3a0079c438da76f03df181cba76d986d3445be0675af21c2 f206b37de925edb8e36dce24fddb125e493d2cc9 +02a6da582f284e708f78ab9360628740395d9003bae9cc9cd5dc47e042a95e58 39e01811cd58f4ea0f5f5612d24b3115ad0736f4 +02c3ca38a3cadcb769643ed692998c0f3984429600365a39e143e5984c33c871 a42df0a3df3e2524c532f9f75aea0ac69c3984c3 +02df938cfb169b0b6ba0dd16acdd727ea9364f7d48c55afed2f7dd889804065b b235959d89084af8d3544fbdf675e47944f86524 +02dfdb9fccff7beaad58de3ae93694e3f957cefa10945d4652b3b1af4ecc1e41 a84d1309159aa125367376b01ec4c76847a4f514 +03063757ec40cebe0042c667ddb85bc4404925390abe9ce38fbf89761b9929e7 820e02ccef8c90470ec7f351464f9212f9dc0651 +033de70fa8afc174d134a3dfda7a8477b550dc12019904d418d9d0bb77d75c11 336ab27f4ead4627cc51ed162c31bc01f13b793e +03653094a4e4d102cb4ea4d29ca5d17dcd99a0d6997d0a6ea590b774333a4afa 03a9cba35dd9060f15a7309b438afaa246e80d5c +037bb440672e051dfb647627dd961209d4d5f65a3134aa561e9a22dea0c2ddff 6e9fb9dad8184cde865b1b062163dc209042f88d +039df023a072d4c4dedc8d69bdfd04955c9661ad0a6032d59417fae3d9a6e66f 93a16f146306fea6df405db1e6e065e52994ee5f +03c29c5b092a27c7d22553dabbf94cdd05ea9892de6a017bb7ebad8cd381a72e 8529bb1ac5647c96f1af4e933f34de2e9d8921fb +041ee569b4648c25a375895bf0e615b1e967164142dde5e3b74f42aebaa8b1db 15bffce9f7ce45f3b17d9357931667485a890455 +041f178780c21ca66c1a644e406bcc631e3374d3d3ff12963f27b7a2e4dcb98f f2ee83a040d7c1c26b85729558e7afc121d35651 +044fbdc5fa0794e3fe81c4cb6735792a7e2224ef108533d9e4d64dcc2f79f727 4738f4f3ea24fd89b4b4b27aa115eb6eaff9b397 +04504468bbc5da740dff1ee1bc21644ceac33a5a39e186624ac9c1700a005802 34a1dba52a7a0f2309c3bcca5ebd76dc8d2627c5 +046ec406f62cf062f45bcaa8881c901563595ad5e4e3eda3915979c8e8ac8786 c7417a02d56346deb435359fdba3de19c0be2f62 +048a56b75d20462e59f0b0c4f8c326013116a117654226fbd086eafc417b227b 894a57d31fdc8326a97814ad2403a45e7c8b6371 +04c49256444a1cca25ef7a6d0f6fb13db62c3a7d887c2b3bd0daf02b36665923 0e115c5be6bf252aa8cba76141eefb67f1541a06 +04cbb5dec4810b725cedad9ed47b8e070ebf7912e7f8a38b1524c7a5d18d6711 62ab0af99d2955901133fff37560bff1962e9b14 +050224b1d07966f578ce168d709148391b41eb6fd4b08e51fec8a549654a6780 c36f4cf1e38ec1bb9d9ad146ed572b89ecfc9f18 +05257051a1b3dc12041d32d8392ef288a18aa225b138ee92058a76f6453ffeed b6d7472f568134d9662dbe0753e692b7d57ed993 +052e483d293dd8832a959201ae52fbe0a3578a53dc964260c1ccd00563109d05 e8b17444a9abd2c9be360b44a8f8e13a4a2fdf27 +053bb083785b3e6287242a1e9b7cdebe356a25574b5f063538bfcf01d646f0d8 f15336fafccff5f3a05b4f4d1527254f25a364ef +0541301a56755c364219db68258da2e70e9146e9cad185e78b188d560dfbfc38 45504b7b9013d55e193001c8336f3db0ec2a81ed +058ec10e754833d209791fc619b8651f9f8738eceb4af6c9c4e096656b4b5d0c 639753339cadc1e57823094276afd3b57bdd6b62 +05a40f056205025b75b15337629dd90b2abe57a2622ca7968db2ffd4fa1198a7 77c0fe987fc4a3c24843c77615c3b6d2f53e27ab +05a580d164ba0fb859466759e0db1d63795eee186a48ad7b6684337933ed16b7 448a7a7cf218a5988f12274945613e86e1c2de11 +05f7b70a01b0ade8afa5a5fcd19f12cc38faf337d10ec03ef4363d1a86f63750 e7b4ad382349ff96dd8199000580b9b1e2042eb0 +060c18716f5e2d8c74a30960f002096e43a4a8b0344e3df4f81222d0b7d73b89 7322d43c8aecf06b61944b8fd63d60758680a957 +061079b6d522c910cfe03f6549a63ab4ab43e212aaaf7dce90bdecd4c4f616d5 4b8e8b32c1ea1bee8c8c01795e46aa97006bb065 +06240c7992e7306c80b1d058777029034fc2a9028931dd93c5611bd56332b99a d5f668c547ff80ee9c5ec24613a2e552cb531c59 +062835d273525fdde70fef08a703cdff6fba048a2e1ef3e49a4a6f60e7e5c7e4 3e00d3bc4d8a36c974bbe91608da3b6b1af69caa +063517f949bd44147862a7eb7210fc0baccdf6c5c02c18c51459c7f317d803ad 2e2a9ece460a44d8f30f3df9af1e3686a8e609ec +0636b4292bfdd7274a977cb6f8b2ded8f315ea1bcd8dbedfca37964c2ed3d085 236e7579fed7763be77209efb8708960982f3cb3 +0642ed9f6735aa25854c90e266798a4843922fe3736a04252809e824bd4093d2 5db59540265ec48b82f604cd251907ca5d79b6fe +06665948a581e547ac1dc883b35bab54682fc311f7a87d5563a76501ecba55fc 4f0adcd0e61eabe06fe32be66b16559537124b7a +0676bc9e224b7a050b3e88cf7dd8f7fb148f521594a6d4132f0400bba6b1da83 8e9d2f904854c0dab03de84dcef103c1904b2115 +0709e20677dfeeb21242f9f7fa277ec464fbbfb56d303f8006c7e60c8e2be458 b3a2f90e54bcb32a88d13539e5672993c5037638 +0722571dc44f703576daf0dc43370557e6e9d83784b9454c98a7246ea3e0ab91 215da649e1c68079fb03f4f9bc0f196cca9855c8 +07314e5bfe0b98c1e061219664284ea9567e1d739530b3be8e3a6ef9527d59b9 9d3c39dfd8210faa558b0cc6fb427b680db343e7 +074acdefc8d17e7337df33b74c1ec5349ef0a0b18a7ec5fed41a2cf420db4f5e d8310141b69fa36657a620a045acad4e4ce0920c +074e9049747d5816aa03be67451eb42c425d1e328730b4d999dee78c4d2579f5 caa7d9e0c8f8671cf8b8c9c16eb18d31ca4802d8 +07571960f3f64bbb4d31f24f79abe05daae0498f6b4b77cca3d8e8ceccbd75d3 ad7cf03cce61aba463b9a687e388260395c8e727 +075e288bb4b170c21e5a569c3cafec80736aead134829acee0f9d4ba5b966a24 e9f5e87781e88aa3afa7679783c204604479f9e9 +076202d7d8fb1d193628801f76208f3a4967fa031a7f94d9236a0fbbe6f022f5 221c73c758cdfd3e7f7dc45b10576d1ced8232b5 +0763eb50fe80aa21eda853b7da406425b172b1d0ec7bdb41369a15868fddfb6f 02e741c6fca96b6d2bb89d064c3d1e31625d474c +076800113a06dabe75d578f2ce6018fc23027a83dc74cfd66f69f3c50f037ba0 270eb8c6bfbcece0f3abdf20f16f5a2c0b0e65e3 +078baf54914fab56842798c90fec863f15f67a22041e8aa54a88c43f059da050 3184a3abdfea231992254929ff4e275898e5bbf6 +07c31b4be5f3ec8f82c7ad6c91cbdf07ae876bb73041903d64fe8bac64bbcb6e 4ea481c61c59ab55169b7cbaae536ad50b49d6f0 +07dcde657a4d8046d02962b4fd67ee5b6ac27f712de66ae22c11d14406ecf092 b39843f3e42c8e062a29b2a64e3c3ce6a16eb72f +08198b33785f1eaf950aaa9ade1961e1513461f7f799905a6a625946ebf2db8e 1f9a9b4edab6da73b1625fc99e57fd84b88feaf7 +0838ea9dbbfb9167ea97d3b395b06abce5c951386d5549d87b3c4fe1ea8cbfd2 52261e14080afcd9cb0b1b17dc4146f2b6b252bc +083c2b8b445640d171e7aa667b0b32007006f786711032ebb82931cca69cc15b fd8430bc864cfcd5f10e5590f8a447e01b942bfe +083cf84e4ec87e8df6bb8cf4b5e95a5bf0e6b97b892fb99286d652362f0f1a8e 2e5faa78b12048d2818bf37986516cd287219f9b +083dc854acb0f53c854ca89defefdd7c9bc76bd6158a461045057c8febdee51d 2c4b7707f7e1d591ec1765ab7057a03283841c3e +08896c87dca842ffa2e7f9ca1941fc1b231b4f0cf966c992251fffc01be4eb0c ee5f4b6e2c16c9cf2510fd7ea60afb830a3e89b2 +08af1ef3969b835c4058d3c19fd6f30d0dca883b9553061823f016db50b935be f4153cc66a588da14bfb5e0ce59dcd638e6cad2d +092184eacb4296d03cd379da1e30b23163a3174e74f5f072b71dad644565d5bd e7bed373b521d9d5e20c3f7a2372a7eae76ae66a +09ca781675e86449d0910da772dfad9c80525b52452ea837a9820c3bc349296f fb799dfe77c7a1c9e2806c0021d659b5588d9105 +09f22926cfddb415baa1a22193d765facfea02edfb140702fae90714dcd402c2 621dbe6381d0b5239b6ca2f206fee56877326d5c +0a13ff7efebb553b2dc091008c6b27ae8fd8da265a0fc672ee0349533574a1d6 892bb2941b4c993ee188ba1d2da6c305dd5f6ff4 +0a280fa035c75607e5399cebe0e2e4ab44de35bd4d5c46a1accb47c8ea2bbee4 417f0abc9b41f01520df863567b25efd03bd281c +0a45b25fa6ba0d67638d8230be426a7a61baf23ea734ceea38312a380dd42181 a78bbeca7f7efad6ff1652d4ab03d4fbf8bb4c48 +0a58869d818eb06ab4b6601c466755db3a7e0d310e87f9f5f340f4ff8f3d84af 55eee3fca2f24bdaef26ea42ce12b98682b8988e +0a8400e1a7dfc68b38c9e82bb4d64f94a20f75ba0f026eb14d29ec978f66dd3a 41fb16c71644d9acab037f4a43d23627545d6d86 +0a85ae1fd17b2a87e83699ba3dac6e0ebb2efd62948ea70dcc127a250323b066 6dc05568057b37706c8453b3e24645a351fef6a3 +0a8c0add81b065b97451f7b47a9935f0e240251c5f90a89ced885cb7d4efc2ba b0a3077f9ef6e093f8d9869bdb0c07095bd722cb +0abaf90248f239f967d2361480e8111858721d240de6e928a9537af9a495062b b6d031157980136043dfbca0e49514a19c973759 +0ad45dbb04ca242774c42f4d7283094c9d0018db25224ec4e2b1512bd3e21e5a 45fb9738926af78da7280cb84ea022e8f7da98c9 +0aea420f9ece0be17a656910e5a64f71a591f2bb4a8938090680925a262fb511 0bf364b355f1dff3c70116f8629774848dadb9db +0aefd477d9e5b3f8d708a3cf6d78be6b670dfa2e2ec41244634f3b8f115d8e04 775e4b4c1296e9e3104f2a36ca9cf9356a130959 +0af326907c9f9a1c91cdfcba6e241582f97ade4535b16a1863b03938ca983104 29a210a471a1964a68f7f1f15214c626c58c1701 +0b1a932c7db41cb113d42e06acf29eddd00aaae9e39398328d475754930c6cb8 343a4b52f37094d193a27fde5ff20825d6d1e7c3 +0b2613505624d7fb949258282f13add0019ba5521f3075ad0f61bc1306b6d828 faa612641fdc2590a969e9a8600af696be701f07 +0b41ced8fc49173b868c15cba070c0167cc83eaf7c0bc62a19e2081d1e7f2676 2876a4c21cb5848079e2f2700312e54d4988c76f +0b6b4c4b598c420ebc1b9e404f53bbac59c8992100a92fb557d679a65e6c7bd5 ee2eb6fafc239de8d88016a1579314908b643b87 +0b99d2b73b57e4d477d096a82661320656f2e61f1d6811f569abb99e2d321b5d 3864bcd2aa1fe77365e8310662c037309d4db56c +0bb1a5866d49c4f22b173586a2d0f2a3d6a91d8ed4d8f6fc43a624df4afe00d3 1b9191dd8a427addca8309a59decc90267082bae +0bb5c743db0d4ef0b30982921e78fe42863d48ea34a6a917bf740ac2d677f281 9689311c952655dd9e315aaef81ea7bfc60d7c7a +0bd7502a0ec038d7740979ad9c9d2198f61b51bcf75b20259aa56e845c62c884 13edd1b7d5996a6b1ac38ca113f6fd751bf77827 +0bf8e96a28828be201f392a2f8d511d4b0d88296db716d64bd9e8268a5cf912a f019bd17a1769103dd82b885d7b46bb9a30bdc29 +0c0a6e5b0322e1f51e3a53c3e302901e9f6acfd0e3f9cf227bd02e61ddefd401 cd2c3cc64b9c003e5049d8a3efe4fed7154e6e3d +0c4f26749b1dbfbf4487590dea5b6bb49564712cb3f8343434092fd9b2ef0a0f 5ac6648ec382ec2f2c9ef81e6ded0f2fe5819a5c +0c55511a79e278b18657bfc60a0893d002d266c05809f54aa49337a0973a1eb9 6013ffa66ef5d856b2c4c72c44b1a63a7ccc2b57 +0c889bfb5e530a62c89b8c18ba11f4bf3417582a28c70b51f075ae74ab1c9a6c 5152c60f1d88042a52d66344b1d628d2465fef6c +0cffbec3386e267c6d32c541b5eb3e0492851a5b35b05a506dc60b8de0410b46 7828fb1437298bbf3f31da65581775665eece9cd +0d15b51f164a1237b5a6ea2f35f32d3f953c4476c1ca7edc91890cd5fb5d8541 18eb2b8adddc7eb7e2a0165e8d759ec5172a65a8 +0d737e3eab91d43f8080513e45fa2d708b3626020ff4b6900b236a613af8cb6e 34ff3378eac2b37e5220195e235a25a21f9b7e25 +0d8b5fe52e725773014a0487616540efea381d2af971ab5a18ab25d33ead1390 9aa923b26f49d08404fd272e0688f57c899d9116 +0da6d514fdcd1a5248f1ae2343991a7b08ee5da3169da9326ade767fe50bf166 74c7fe4f3a657d606a4a004c87336749079c0edf +0def2b73f560d08d26ce006d956af37c429277d3b492839521d00403060fc189 50d97878f49fd4c950a7a494b8dafb0d4797b57c +0e1ee44bdd5aeffc3a6601c83744e64a421a38d1c9355cd5aa20a1dd7c55d849 73473718290fe068243e8596fe649f200e8a6f34 +0e265ece40fee110c5a6cd29be1534c268f16e4f3c488bcfb9f3c8d1f46a4791 711223894375fe1186ac5bfffdc48fb1fa1e65cc +0e278cfd338b1dcc4f15bebb53ea527e756337a337e46d29806ed28c23f5469c f5124bfd46444f572c5faef3d45b084635c106a0 +0e31ba4e455789640544ac02d4e478fcd75d39de130241e0d2bc80db11c7b7f2 8722a77ec384aa0bc87b8f8f6c1c7ab6aeffae83 +0e3e687c74a6be88d4c09233ebe1d1a75748e349f7013284742e200c56821d9a 58f7931837dc08b3f94dce8ffe743afa40b15f0f +0e4970dd94378fe30b6519edf25dcff7679e395072715c12e6f365b74ef94415 624320d5f878cb1603c31bfd8cf1427fb6474443 +0e49790ea8b918a427928eab3e17f8925efc10e2c1a8c5bdef4c0eb20cac0c77 0e40ca2e7c706ac2f46af7f4f2d4bccb90bfbb5f +0e51009a15c1599ba55888c464d5d806694702f0593bd59895e4a134026bd34b 9e41833ef25a52288a46441ed9ad03dccd0b16c0 +0e6a1aaa2118384e5ceb8af69725827ff4bd942200a9b831522dddfb7aac8287 763dd65d1e7ca14658649d7c4d1cc1e4bfd2c671 +0e85ff7bdd5c6ef0a1a449461d1d01b6a0bcd3393a994bc5113915d173810071 e17a3f5673e0dc4d9ade34a0a276e6c202506fdf +0ea35e446e65bc1894a303aaff5ed807151bdbbdc8ab257510abab4e83fbf13b ab42d1514cd6b1007d794885dbcc0e7918e91b1f +0ec37a6fc3216ad07f16cba63ab57f80dea7e4091484cb25e6d677abca268fb0 9e210cb8bb8d3ad9204d90a584098d43c456a5e8 +0ee0fc56010269854bdcbd4a1a55675b2fc29c4410217004dbf77d3ec948954a b5cadb77fd216aee5dc133012142de6f78d4d47f +0ef8005c1111d4e19e9636d02032c8c3c295ba6f94598e4e782eb28cff273062 408509eef776dff28a36b63e8785ff04f7cf9846 +0ef9ad163c0b4599adf0444b293ad267012e784ca37dca8d8c286fa36914001e 3a6b70664b4c5bc0ea2e6d3fa8fb3b3b54d724dc +0f89c2e306e636e3084aa0bfe57938fbcd22981e809b7fc031ff90250befb83b 226eca421e206b16826b86f9aa9706aa31680240 +0f8caf733b3a1530869d8d6faf6d4069acec05cebdc33f15a8effbf0c7daf370 e92aec82dae6f9fc5d96b0ca7ce39d750905d7db +0fc8f0a12ec6889419fd677c9830b2d3feec2e9abf89415147cf0b3c6d444a35 182859f51a5cdd6ae9a1f75e21eb8d3f95d0a833 +1056c834175ba8749080270f4772ed2aad4ac1b74896a7cd36a75fa8a1aa53af 628c97ce7d9539e1009702b53fc7aab98c7f7759 +10b531c577e3e3fac1dee215ea33ea21202309a23b93352e1a9f09d6e9f45f4b 169d698699b441e9912283936a81aaab8e59c6ec +10d12b721c027f4041d0a52d5c02da1cadaa1ae0d05051421a36b861c4df210b c960d6a3f97ebd360dc3c9ea00fdb3cd5dc56224 +112e60f7f4409f6427a2bc302108becea27da72e31f92ee3476c31347cda4cb0 d22990a266f309c6eca013259c35ce567a0dfe08 +117e89c749a48a0c10b47e9433f26efd38192395676086af83ea2d48306b9f9f b4164f93a830a383b69daec35b6902f0cfe7ac21 +11bd4567822919bcbbf44a1323a1af5a0fcf9e2c6e3d2ad1329990eb1c0e9f5d 83de31463c02d36138f1d76cc22c18613920cd3b +11d0463a82345c2512bd704dd00211aefb7d5b8590ca92809122fd09486a9f06 d0a0d63086fae3b0682af7261df21f7d0f7f066d +11d187fe3c4fde36184f7e171e9b6afd066563b4ed568d9e1e3195b8488be47e 7f8a1d79534d90ed868ba664343b058258ddc64d +11f2111f69ec85dbbb408d68349c750a9ed94722b094e971f595f8aca5028713 0b19f4634685fdf3c2e58564038e614b8a8a563c +11f58a21e063f88f8aca15a05a6bb5148056acdc619be09214bba78819727a92 58840c6f7e9973b3700eae294e6f219c34cc6962 +12240f46f98af843abb3e12053abd997a1a5cf7ca50ec460775b6dfec9594346 2c9eb23012b2c0effdf247a9dfdeda4dcc6ad8b5 +122a2103f404b68ff8cce6c6ae82effa1026b8a254212401bf5473d27d70efba e97179b6de293c8f288957dc556239a44fa52e3e +1258e0cba7f787b1c74e00872bcf43799e5a7c77202685dc0ba60adc20da977b b2dea1ed674386234946b2604df68d71b677d2c1 +127437808b4e14417e5654a8e00dac615d334a14747d78d2ba1bd0df426ddc18 60711175510355240283174b84d16ee85fd599ec +12a834fdb798b91600e94c6851fc231cfd20f3eb65dcd736f39fecf96bff2788 edc438eedf6854c51e1a0d7954a6849046f5a4f6 +12e4e4e3649c0817fd80bf805c8daf890b40fe6788fd479db758575278bb58a3 91e5038d62abc64e8be483f3f764e51b0496de27 +12e8b48d89fb071c73fb0736f784c6ef0fcc2d4178a1fe17ed6d7a8950e6943b 01316e2444ef01a3a2939d6d891b1c7ee49bd05d +1331f4c99429b5934be1c4186c592069ee9167e73e65807cf8004ba54a151fc1 e740db6f334253940722dccd42ee45c96ee4f56f +137343a187f9ed56ddc750ccbdc5f284c1240ca1061854f609b4893cfc0ee035 b24cf42e6753bfe5763fdd7639f9cd8b629907e1 +13c8c9dae9fa63b1ec48b8abb12312fc8df61b9414678f504fa68164a48eef28 31438e245492d85fd6da4d1406eba0fbde8332a4 +13e9b8e6cd38ad58df3b3d9dd3480c06e69ea21f02639404c44c57f376ff2ec9 cb8e90b049ec87e0a999952544839c3c17f88e37 +1402d1979a18fa32944a3e584bc2bf63f08fd50fd16b228690b7c8614923b603 62860787aba2b59b1dd0bb7b9a810fbf3428cf75 +14386136c01f7aa705d82984066e49b9a3380d4f7a7f42dd5cc51511314e9a11 a43ff639453d9a5e374cd655bfb562d2d87b9edd +14747f3fe457467be5310c526d23808fcc18f5bf29feca812a3b3c74dba53a39 77c39760447694c5e9f5c7d09acbc788560a322d +1483e39b34bf45eeceada3f43bd76b8f1d8af079128291ee1f0ff9868fff8539 483b17569d2655bd9945ceac8e95c4279b2f2b2a +14a40b61fbea11fffdac7e51616ec7a7264e88a16a9021b4e252d443794d50d2 a27fb9c96feb433fb28a2713a863a7356d45eed7 +14ab853cff3d477dc79386905229f0854da0bd832125d6e8c3f3186073ec0709 b6d1b7d59f42493a4aa5440ce24070bbc4044f88 +14bd335f9d7188c778d44eba8801fe9bda46b66593291f5b9f7cd5f8888af12f 4a23e2e65ad4e31c4c9db7dc746650bfad082679 +15011ec9c79d290af2e08c865de53631aab299a27fc2a681903b3e3efab7dd47 b5cc24e623d5257f37da86627b8b314609945cde +1503ed3428050930a44def1fb250fbee95bb021a61f3ebe831502871c7df0035 f78cfc187cfead79cbeafb6e0c30f882a9d7c14f +15041151380e43cd57db1e6b758b00a2ec32782a3004e2b1ededc5e8bbd2e815 09fbd28ab7ae43f75acdf7c8adc6d148b8e78d57 +151c7527acc5b731199a03a932ae374331e16e5ae29256e98cb652f37669889b 91d973263a55708fa8255867b3202d81ef9c2868 +153c7d90e1734b2c9d1b32035aede6299a2a2eaeec425fabcd86706c8afc6194 faf2dae9a5d206471233bfa8698ecbdfb24785d1 +158217c424b47fba461c300c9f99cc27b50f7122c6156d4264c648197e634fd6 c14aa17cb87c64a3cc0f21e343389bcba1992d32 +15a4a79b6ab927befa6798c2028d37fa6cb4f6fe0bf80fdce6444a2fd9e67eca c72d81b5de8042aaefed06ca1abc1a248bfd0a4b +15bef585bbfec8410833ebdcb1760b7013d1dc3e4a7085902f199ed303f26098 89217d8f1a70da2916d611c989e6b046cdb94fca +15f128540ddf555e902e837a9e4bc39d752d70af7de1c91b9b0048c1bdf4ba31 f70dcd0924f1d58e9b68ec47fae83d29696865d7 +15f8faf9eb65aa6ddc66cd5a1519d7fd4ac08cde54d6b25e6fe1698c55661335 0c51be2c8e9c40f947c9527b1c633c78c3d56e0b +160a14259c471b4d0ef1594494f33126d5763d958ae31bb14e95818399f6e3ee 01e0d82509eadc367a67209ac1150e299447cb25 +1632e799dac6927cdf520ba3cba8987a1258382dedacf72dd5b3316af2fd619f ad2fd2eb9ab0a392524bc5d4a90888d550bcbc0d +165ec90aa4190bbe12ee415b294fd6d204c64afcf1ca64dd815782872b24ea26 904c0ac12b23548de524adae712241b423d765a3 +167fd44243abde82c97106ac315e0f026b447dcf1016918ee42c0777533e6c0e e7cd3468b748fba2eab5162991ff781e2ca8507b +169a47e7a7d688f8e6ee34ba57c07f3d1654f0886d7e0be582ec76cb445af1d3 d1aa69929be363f0798f1ff226078c9912415f5f +16e15f2497ec3aca6b94a96dd1ae3e2c8c5a351112345e16c1013ddb23fe9131 89d3150640c0ed5b386bc8113ac8999b20371ece +175515c1c0df4fd74f9f4683321b84cedcac3419563a268562f08560ad7684ad 3b8ab0b93539049b0f7c4a09f5dad48a1d89cd49 +1784913c0c472812c39dd12870f8fb69346327bda8383d7c2ef22d611c808513 ea9fa2b55f597931edb375c234b42833321e6ebf +179496410f66032c03bd2b7e8ddfc9c8c47820fab5615cc04d904989ce800498 3259a6bd5b57fb9c1281bb7ed3167b50f224cb54 +17c8bb815beb9afed2efb9fad7e2fff9ad127e2bbf742e7688d70ced51875c11 4575d8b63290baafbdc8345a297945514542f2e8 +181a0d8c3fae35ec8f21046d043457cfb07975ef6ee20b3b2a2b75ef47e6b54f 017867366494259fa88e71955be05758b17f2568 +185248d640acd5ef59cd18b373ebeebe0c8f5d31e8d0da8a39b69509b82a8b38 3cc1e1683dfe9fa759c81ee61b2871cf95f0a3b8 +188d0f5e289ebe28d3eb0027212ea0b1af1c84ebb0229c452922d277ad4f6b41 086ab3e1892c5375fccb647a4b1e2d9ed55ab750 +18c2e619f1850cba3b69767e9433d37b9eba4616521994568a09e6620fdc32c5 46c7d0de2393b0064ff2b909a34944f30a80d8c3 +18ca8ae1ea1ab24474fefe881b7ad27805bd8942051fa9421c277b0ea0909361 069a41c3acd6dfeba2d5ebd1ce0e568d5ce3ad51 +18cc02db4956ff4c1ac8b49430ac9aa889482ebdf985e8f218415038466e870f 83fc82fc80ee42dc76405745ac74a80f7b7a9fd0 +18d28fe4d7da8143a66562a085a1082caf7abdc6ee0dc13c48a509f82ef9a6b2 72afab8fbae47da683ed24f4a3b5deb01c73ea9e +18de7aa78fb2acafc30a3bfb0b5620543d2d9c21b8474f0d02ea94ac16b3e414 c1f22c54fb7ae97543f8fe6c6ceff95734f4f9c3 +18de852cc5d52a03ac90027225dd12cad93079ca8e1a2dfb11214ee8dc06deea b447fb5a08337aa08134b854f8d65369f03c37c2 +18f2403ff16f42833737b7746497f5f79c014e1cb33bd639c47d7869cb07873b 480cc70e318d8a80657f36fb55967477050cf3ec +190a1349522cc11f8682e34acca4ce4e1ea8508dfd77c24cefd461b65cead09e d71aab4f9b04b45ce09bcaa636a9be6231474759 +191782022d7767a9a15579163f106741358f2503fec2f9c4c093a6718c0c764e e5f6ef80021c1a1ce27300c4de4bc720a08ccfe1 +191cea84239bce688afb3e171e9e4b3aaae9d419515dd5629b3c01902210334b 2a7e671b12478a4246a11e8f3db61ac76f241e5e +19762806906133d4265885d96213490c2b04f17560b8d724f91770913531488e 422ef9df86d2b3647e8d9a0525318b1d33dd9f34 +19ac68c5ed3b0a7a8b9f5a4a7098d002d70e0578f8735105ff622805287dc356 8e8169ce53213d649d52304e3a8f98ea04c35801 +19c0e0233f0ce56698402b2e9bc0c77a02e5089c3e28d03f55c9a3bcd6c1df57 76a8c44727406a76d251102bdee607871887a119 +19cd37eadbdbee580b4e2d650374b1e2517600ef4f45666547f9030a1de25a40 a23bec23d8075a05cd04df2f52fb2fddc8ab4185 +19e5ca97ae44d0f46334d1bbed31bcecc2b753ab4de4413e03c3020a2ca0e68e 8157f9e57bd9de5ab95b89fb9c7192a5668322f4 +19fb1c78b11f0f8bda658d6fa6cc63c0b573c0f6760ee5a9c2df6ce2cde00c5c 09fe9364461cf60dd1c46b0e9545b1e47bb1a297 +1a002e34aa1589da6dec7e55014927ebbfb007d33aa6d93dc1aea53a9711c061 e9c9018f4b898a2be9aa0d053153cb7d8c8af22c +1a08ad814e0d9ee5f719a39c4efe32a55b5fa1bcfc7fde7cb527b30e2fdcf33a 1b30c5d6f15d06aaf5e4edc55d33d440890416fc +1a174438f39a3ef0bb9d11bc1532ba677dfd530d2c71429eff281102f8128793 3517bc697600fa61730369f35cd91da86e12d595 +1a372ad827add2ebf07d3508c8636f891bf9fa15d173b7299614d543fab4208f efa3c49e538c7d0724cbd9c32b24bbcde100b3cb +1a6a20523216002f961c5b6b0e2b9f93fd002adee3fb48c0b038c4219dd46b35 5e78a5bc12d1dcd94751e36dff18badcfd9dc89d +1aa24b7ebd910f39a676f2ccab8e9a79f14842c20b55ed18e3dc297bdbaca279 70957110ce446c4e250f865760fb3da513cdcc92 +1ab4fa663d22416f45cb1a007d767a58d0abf5255bf86f888393dae637b37c3b d0a44bd6ed0be21b725a96c0891bbc79bc1a540c +1afe3af49295268534bff09062da89d993de8bf539031ae5b5deed8c74e2ed76 b371c056bb696430f0dfcef0d5e2bf62944ff323 +1b01b7b52d7ef909782114be3168d4c11d9125138c36dbec219de41bcc729c1b 7f7103b840176225a27d40ff95c541ecaf74bb59 +1b0218569c4ddcbca6d3c5793c5e822ec57ae0a1132ba51edb9131b68b361946 a916c9b256fe6e1c75540972d2c6ec07acd46384 +1b1b914f2ebd1179c06130fee875bbdb44fba22bcd879e460c8cd295854120c8 a0571e5b921af9cc8aeaf14688ee22fe9146371f +1b4b74772bd83ff28bf44cda9be93f4afc2279623bb5b36c9194a660b7623c24 be3563ae3f795b2b4353bcce3a527ad0a4f7f644 +1b8fc08818cc6f44cc340576ad2f114f2b15e4f8bc4d306e86e97f65e2043eaa bd1a70b317032b45e10b9d24515905c86baa071a +1bd6ab383a4cbd2611367ec21c4742326fbeead3ff912f194af0f853e7b63304 004393eb8ee7f51fc57f25ebfee55193d74b3b07 +1c24b0165ded9e7bd0c8848c667f0b08a8212496303aeddf741d5e0e4da3f81a ac04bdf6e0ee6bb4286343bc70d745146eb1e506 +1c34ba81c57a802a66d3026e14cce495dfd8263ba7a98233c4927a74e441aa3f 08d5d00056a7237bf6c60f85a6e72b7549cf9133 +1c4cfeabeb57c496034724e4649ab5acbff04788b6dbef87c50167e16e91b571 5a408036aa992bffa67a0000ddd163e45be5f457 +1c7bbd4852fde2f3dbb2990d329a20e76ddb3b2b570416e4c6ba5633972f67eb bbd29af5b49251be2a6498bd84b488bb4304ae96 +1cfb8ae71e9e576d1b16b7bd1a62156d0641c6e51f5d76877be6de4f26410623 b1bb1d888f0c5e19278536d49fa77db035fac7ae +1d2005951bd5058f1b001eeac119a95f15ae052239a17e43180fe02624d1ee54 a77eac7c388ce4cc9da95c0c66f0be2416eb1197 +1d3847d94a4153fa5b4171642f366908c7613ae239f8135f47a38baf47812292 2cf16038b9c815d6c2be936c90f76049483af23f +1d4b030078160a5498398766e70bf11699359798f01d47bed25d1883eed4c139 c0972c6411e01048c50c98361c50ab1969ef8bcd +1d7bd64ed18b5ce0ef15a15ca1294e92e403b58fdc621382e4dd8125b736a203 ac8abfa28ae1dcb1ff4bcc297a7269ad64e8f486 +1dacd6409a61346885f7998a7b2abc74bd00a588d100800217a3732b55d7e027 1763ca88b7bda3bb7e98f1dca8d49bb9dfa3373b +1dd44fb999c3043ff69a7d846378969eb6b425971eaa49d14628fdb85ce58345 c23841c833ab35d82b32553d0659e815859e6c01 +1de74dd7ee94c061dfcf5906456ad25ee317925d6f6545ed7e5c8deb4dc2ef1e 7c106af8cc957a256d2a9dccecbe6b974a49a9c9 +1df5ac46362cb6d1e92e3b62ab4833c8b9db62bf69faec2456b88eee8d1922e8 14599df1093c4dd512ad3d54892c03102f7aeaac +1e0acf5db1f4a90ada03fc3df61f0196d3ea09f3c592de0a83f2cc6d5fbb15a2 9bffded46b22351f3c12eb5c020ae005e57cbc90 +1e0ce38d00e8f3e613febc0f8b275e0fd7fbef8af293fd62698be46dfbbc937d 8ec696a4734f16479d091bc70574d23dd9fe7443 +1e82caea1fba091c1795671232b6de19e3c9b18015bb66a158ad4728bfc8e0b1 8b2e33413c0e43bda8a98c5ef090561605a366ab +1e8a2396a612e14b5a4a7f23ab5cfc15df6abbcc5ab6ff9c89a3788ab450f0dd 3cc606359d5ac5c869901d89d8f25cac348f4c98 +1e9c076a9357a539b2126c275c8774c961ab8bda2dd6cd37750ca969dac15d6b 2944c0cded94117886bb85e4e41f7d4a3a553245 +1eaafe5b4dff4769bcb95b0adc254d77016aa32c1acf1d765cf44fb85c5c8b4b e2ec61507666a29ef12e60eed443146f8431edad +1eb53bfa2e681bf9a76be9dd3a9c2a5deff28be13d29b2f633f74f9281eab61b ccbb507cc3bb0c961c35d08c7a1d18009ac3bf64 +1ebb7c1f5a6a2f0151c4bbec3788d0d065bae1f0bcd152c9a3ee35b41e1db2b6 efaa4277c709be26d6d475927569d592db39b4dc +1ed3f54cc02a9ca7528af4986af6870319d1f9ea1d2a2ac59c45cc75277c34f8 575cdc563801dcbef0ff667322c8d00176771516 +1ef82afd4f727427bf8d10690824f403713558c930ab46a90c2572e214bf7aff a9d70a87634c0932d8c03976c80467cc5de7522b +1f6ea2cab887a2ff4bb1557a36dd6bac9931ef1f36794ddd22b4b7b7276051fb bff8618112330763327cfa6ce6e914db84f51ddf +1f7bf17705d025c6ec01f2c3e48ac73674b061f4d33704527b12220d34fbb32f 81657de62397e72bf47229c7a0a27f0325ddb8ff +1f8268dfb6d72ca7bb47bef89869a745d98b950af1dd62d716b70edf33850f33 c5e5c7d94109f5b26ebb69ffceb81f0530fde633 +1f9efce84e985329c26351dbdc81516bcdf02d1e5d64a92fe097b62f9fda8228 8601554dda0b46a69fda76189c126fef0aaf1ba2 +1ffe1f5d30a25e6517f439e1a05b59bca7ca16fa26870557901218e2b3cdbd7a 6b0b66190924ec57928b827412a75ca7643ecc97 +200f1e71b8c5655069f997534192616f9a3344ea45caf96b889cace34b547572 2ed634540823fb7131f54c5f1179c8ff1c59dbbf +204b6601aea846e40b93e2859b47760350d0d29d2e100def2f89a4d9aeee4e00 58653f4e36c26ebc8e3622e8f3922773082cb328 +206acf23f3313f369c63f14e9d85276e95b0dbaa3cf271e9ab13f6b03b70979e 9cb1d49a7a94f9cb757f414ae46186f1bb36b839 +20ce0489de3716bd85f6b5787f155d53bfc81ba930bf4329ed57dbe4bd99a367 818d98c0665384ae6ef6f7bb0f8d4b0c34acf9b5 +20d7a7a6fda600c0c703114b07d8469a9d188dbdbf1fb3494ac72b2af899905c 09e1e12190d1de05ea714c98cedc81777eb40545 +211597b7b8ae016a314953731f661ce2fb4061ca2f867668fb6114f1b2693b3e 46b55d1d63bd191a9f364400bc1c9112349c5ee9 +21492c6dbc50134219f63a081f52e3aa674d90070674a43332eccd2f4fde17eb 97603e2d1760651b6749067ce3d980ccab9c715f +214e2d61bdf436636b18c56a7ff55107de6315c85e7d60ab793607b173413a17 ae692bf0e91255fb9ad8393edfb73c6065eb82e8 +21824283eef83846585f59963be963b547ec08faedd27f5a994ef76281d0d2d9 f5a98ad911c9ffe375ce43fe23c1a3e4ef47e999 +21ac834dcd64c8c3759d851ed4ebd3a9121338d2a77c5ee0853046cf13f7bd4a 19c6a202cea3421fb72f7e4c4eb90fa35c391554 +21c3050b5f1069492acf40767ef180b24b7949a9928d7bf52e4278b53b64467e 4430a3812186c60d7a3cc7048f97a4e05f3048be +21c709ef5ac66209b70aef877fd0c8bd77701fde29e7e6343eaae9cfea3ddc7f 7ce8cf840e9a4d86680c0c13788fb744636658f8 +21d1e21f58b5003ebc6c47526f1efc9834c4fd77df0b7c201bb0809c881d5ed9 b290b470aa40a42fc5b24a408ab9250443aed5da +21e1e1ebe45b2c1ef79ab050334e36a8015a546f0740bea4505e10d81a946f61 7b4384978d2493e851f9cca7858815fac9b10980 +2252e803f7d4a9c197725e54f40d4d10272edaa05570832be4ff849ae4431fbc c6736542ff91f0d0c6b6a8ecf08eccd70f202cbb +22a3c8f57f9465c979a96ae07e60850d2b19bda93021c982fb9dcef491bd9aa2 c863948af21d4a58a4daaf359f38881263b3568f +22b6705b86e4aa9120eff203af24709d483698d9f78695e86e82de121784b570 dfae6ed8f6dd8acc3b40a31811ea316239223559 +22ba8f17bfeeb46d141280d030a87674e2be73e2360c6b60f0d925778a894cff 791826cd86946d8aed19ccdf7d7530da2023585d +22c61fc7b3feb0f7cb851cfc5fb6a3d84f11a63a4a32d9f06bb6ac0a332f4888 a4af2dd790a63f6312e6916dd0881bfee2cb3201 +22da3f3c129409fa9d299e05428fec54d0a4e49e69400d6808d9caf21d3e7253 880aa99fe67ce18436b9d253ca15565e22423f15 +22ea84a1b29b0fcc3889c026a418eaf785cd2f87702b023045e60c76021203b5 d74679498086d0fc2293dceb59155c696b11b86c +23380226b60b663254cf2334626a2918975dbe0029ded408c957de839706747e 6110c89446f2281e5db9b798a0fa020fad6e63e1 +233c055cc3c747f868b73686726307a307dcadbb562d3271007e4ad25520330e 1e00a3436acf0452f969a8394ceb4ffaaabae689 +2370e245ad47ad0b2c88ad121138fbe3b4931a7c9a5b2102f27eaffb5f09f892 05664605d827b3b2d88b6de331f0c39a4b9ac09e +23715dc3ee50fd82c9eca67b6bdd7a51c4c65d7508e32096bb42e755489b01fd b3e8a0abbf795114ca87ef5e714d0d2f36b84f04 +238a501cf11a036f2f248008d88e14af624bb07fced6390997a0fa6abdad950a f1425cef211cc08caa31e7b545ffb232acb098c3 +23b010f4991fbff884638d5e894e14280a3f59b07749acc5c40a35d2f955fa92 40a7c27acc737f9efa912a66cbdd29d75bf44c74 +23b3583e5e642fb73f2f025263c7016caa285589bbd8ab905f7b87af6269c3b7 813b24636f71e0ebf9aaf9afbcad21518f4e1072 +23cb97c200205dc84109c248be5bd719c23bdab52b52c51ec92fef9a48790833 6fdccd49f442a7204399ca9b418f017322dbded8 +23cea2b49eed4993c5b92a9d5f0b82efe4fae3837ea707d921de645d04479015 b0fb7372f242233d1d35ce7d8e74d3990cbc5841 +2470dca53501f9587cae6103c471eecfc8089cadc68de24d72eaabb17da90f51 1ff4954e2b4c365a517362e7a9b285532a79e52c +24893e425252bc0e02b5f056663284f32bd3db39f8ee746c54835db081369516 1a039633309bdb88eb5e6c46d1f8c2ade51f09e6 +24aea63796fb2d407b9f1c63d19dcfe927f7f26af79966636c957bdf7dff58a1 ebae795e1fd8502328b176c3f63a4320c91de800 +24b7406da6799c945658578a2cac92132d7ecb27d03655c05ca8a6eb5971cf9f 3e0fb8fb56426d4645a50ce85fead9ad93ce59ba +2545649a60be2cd66432e449bb1e0ebe15a05bcc82b50292ed406464e4e66c92 1937579fc4f2bc5d813f3c8b77688b37829b394e +25579ffadad7d6abcb2a12feb00a49c2160a35b6e2806adf77445a20e5a90b1a 4c64f551d91b63e8b58d08d9d0674e1fd59b2afd +255a9457976612734498fea47aec5875822a07030bfb87462afb021e7caba0da 9db3e7f23c37f8764357828dfd6e9ea4a58365f5 +25648e64000f520ab94d539a63eb0fe4fe2a32306a70a9ae5b32444071f8df65 982cc52d0e7c0a9ece1606c37d6b8d00f682f471 +25a4efebb38c55b8f2309ce5e3116b2b9287239952cc2fa174074e05c6e5875a fe3a6a42c87ff1239370c741a265f3997add87c1 +26149bf1ac4612f24b532ae50a12b15f26aace3718749624f008bde68670352a b204707bbc546a1a770ef6ced37c7089cc3bfe6b +263939ccfe22fbd0bc6475d50b830395233a3417bca1fe7d1e74c35e9292f723 116caa6ac8ce8e28cfd7d2eb29670554cba3a71b +263d72fa5cd7aa029340ef5e0bc8c409aa33ff8d1f5a4054919799e16c4c6967 46d8b885bd65158e8cb53266ba4b627b5991bce8 +2643ed9ec1615eb7e3504de7e9365473464cc93211b953392894f4e262d9f55c ced645ea9ca4170bd75c17cb9c2c8f19f935491d +265b89b438f5161c93ce2d8346739c1f0462bc9688a4d549e93f4c0b03093ff7 02283e8165fe86c4974c7082aa1c255fc07ae3e1 +269f91868728e97e447d745490b0e7418e8d1bb6cb8ee5d8e766e1ae9a559b62 28c77740506e6099df65d8c7d40f9800c9574068 +26a2dac21f8f0939566570e48f7f4fcf89239c2746ef8d3dbf31d179c691808f af3b99d5be330dbbce0b9250c3a5fb05911908cc +2726a64752aeac8c0bf4921a99e722dde7cebe782428c471fbb8dad1b2784b63 9469a286a2240165c93b1940280a86802daa5f85 +27783ad60355fe63839b8ab4d1f4e74675d2da204757b708dff7038b02bce77f e71445c43ca0d573e2f61300e454ceee357624b4 +27a8b0bdddea1bad3b442452d2cd2178ad738d0a595153f52a61b0759ce6c2bc 1a4bb64d48619e2a1ef0106be89bba17768bff63 +27db440f99ec1ff5418253bd4f354807842fea54c31053e2064de6ed0a45638e 66108a6375b0a3572ea897ddcf4470534c6d4247 +28129011003ebf7100cd50ea6bb41f61d88db419df95564bf4252aa70771b7fd 1ce3f92bf1c7b10aa4c76d1fd51094641ef53cbc +281c36286eab5e534f1c2121a4cf2cd48a32b3773a3e78df500bed3f3c9747f3 fda23b974899e7e1f938619099280bfda13bdca9 +282258be802767efbdf8c3ae693049d0dd652b161ed25c75b85568bc32931ad4 e0ed676cdefdc14fc274668b67ebb2be310fc2d6 +28772383fe514695504d51d0dcbaebb5af526f76b3e262ccf54fb3b6001a7768 209849a44961d4fb86fc51710affec6d8c407cf7 +28aec9a4450d9de98db98a021f97026bf12f1328f66e53319669eb5adce5ed3e 4f6eadeb08b9d0d1e8b1b3eac8a34940adf29a2d +28d4103b9d69469f94bcc9b762b5ff31b05b404eea961bcebc14e320209d9563 540240e7bb85dff664406a35eaeb222890228c0b +28fc5830291e38452b4b43c54c5d5a7613ccb39c4866de51b890b55cc35207cf 98fffeb8462945a9c9f19d6e8bd40470afea58e0 +290d84a2cf108c074d3764ca8dc56e1215a5a7482837f098dff7a55e23d89d5f 4f9339df943c53117a5fc8e86e2f38716ff3a668 +297b1f32141df100021efd1a47d8315833d19d47097fccb14c80c9217d8840d9 ca481fc4f12cec56b71bd50ae72e3f088b69021f +29aee3837e46aab84222310330ff8fd255096d4a22be608ddf847df5053debea 3f61a75703b0430062d1908fc0e3e682cb8b95e7 +29af12bc8b8dfc24018ada712ee5727e1185bf8db62cf5a0b693ec59995ced37 a2e130b3f5a8978bbcb28cf5743d7672c5ea10a6 +29c3d5b0abae694f9694c2f7f63eb20b80de152886642e5d0f5282b4792cf84c 3e89665eb6d5ab75051dc59fc8b63316908b19d1 +29c86d618bdd9b53a1df6ec30dd246a221bc2670aef3319b6d688a1965a78e65 4141dd83e5a7b99c7f2fb295709e2ec5a66aecc8 +2a23921ccd2ac045bb0bea1a077d8834d23f2c5292284511cc2ab2380eb5925d 0395b97d1e2df4bc7cf46a9a82b753a8908157b0 +2a497c0a14d1f5cb4d497b659b5ca43d2abd353a35ee86aa5ebd22b79e5b48e8 abf5681c033e83f92198fdce8d30c799a6e42af4 +2a53e939a3578ca6e258a421658d15fc90a4bfd310f8c6b1dce41a26bb09e2bb 4730b7224276579fcc8fc7fdb9bf796ef158fde4 +2a6348df1ac5a449ad2de13641b2993f5707c5aa37ec0108bc02caca9d93c4c6 dd1a5b5b3b7a1e3abd956a0808675001ee06347e +2a6e55b7502ae9e503aa71712eb38a7db4a400f3476d3c8c91b0de39bf4a050b 279d8e37642a9aa06a4aff44694ab7a6eb68a60a +2a744551456986934ef43201eee6334a89b1ae4e4c919ee2f8f09f893a6a1c51 2cb51104bbd83bed39bc8a178ea172b234a3d55e +2a7492a020b054d3af4f1c6ad11021a153198359f50989c9cb2d3a58d347fa8f 1a57ba73220bc222e2d290820bd9f4157c8a504e +2a7adfdbe35f2b25328c964f8e40855b92eae773accd60a2e3aa1717b6b70341 a6a1a6fa11f7d0c989afae4695d4661514cda8c8 +2aa41eec6c80ed40eeb14896e1716f9439c6a5e99725168bef1f876d0e48ebd3 12b66564dafa01d8a13b8ecf53474b1d305ea771 +2abdec884f1cda652bc5132328df25b97083f3c0d4527dbae2aacdd789ee134c f31fd16adbc7a2165c0091c22e89e50811f95df9 +2af226bda5c9ca85442284f6c50145bc14e632bf62258127f56c7ae77d295771 40721f6b1297f2a48aeb5c9a3ac095767b1153bf +2b3b4a4a848d85bc2993d0a7e3bb36e354b5053e7cb6165dac164bee2dd9712b fa19c3ef71b1ec077434b0e08bf0757ddbaa22ae +2b59f9fbfad86c6d61e684b441eddac921c532c40dd645884be08058db3d7fcb 8cb3e7d4c2c5ae36a7ec398299007af302bab6a3 +2b72c9f2e8b8a2b0e041410a14d94e9374b1d8fbbaeba9dd02dad3995d5700d8 7c982100f3c7b81e576b552484d58470631f2cbe +2b86b328af6dac7919c87c258ed08cc08fddfc033eb0c8c197c45165ef435219 b7058c66c000c55f92fc4ffd7274a16b41b196f8 +2bc0fd59c1b97b08b6018f1243a34a00e0aa32742ae2319c07ed5bdb3d9b4269 e5aedc0644f6be56bba890d932e552cf9e08e717 +2bcdebb6b95252485caa69957ca19c85b9c4f99ee36e4292a74c8505fb8158f1 158e2b76aef44441ab2bfd42ee69873822a4d67b +2bd621e4518cfff39970c47c32f704838519c36d67380758666e19699ed387ea d54b77f23f9cf4f0016dca8ceadeed48b1ad5686 +2c045ed1bfe1436578328ce00e3d7b6cf2e80742ff260b5c2b524f2dccdf97c7 86897ebdca9adf45f7789399e9c4786d819e09f9 +2c0f52f9ae1f34f280dfc1c755cbfaf2b9968fd3bab1f1eb16d3ac0fafd71940 8fac94df3035405c2e60b3799153ce7c428af6b9 +2c2688f8f004501fa4917b31de04513365c6ccb796a9319862e0f6d8ced5dbfc 0e46b1d04f022804f08de3466b5cb6b91fd366c0 +2c97e388a515dd8871f47fee997fda7ddb7626f68fabe2e2dfbed0d9e5410f04 13ce9f1b96279187249d56cc641252ff617fa35a +2c9b933ff2dabc5a043061d2aab80d967e41b01840b9790a87c981afde9bc0a6 a256495f5eb22ac2e5de21f37b22ae3c497b3580 +2cc2ff33694c392abbde2169365b575e662405af09624502d3e151d205d50c25 e6823108533f65740e0e5e75d0fc335e97439b75 +2cdcfa2499b832dbf7b855e5a7d210d538be9674dd2dc3ac301a21783eb7b333 c7f0591ff41fa0633796122d09212d3fc325b4d6 +2d22bd62fa3abdac2de06753deca74c77bd2f4a00df6014e0bba6507c076d6ba 3dd02e2850f34d7bcbfa3ccd4e909867dc89598b +2d851572773ae43b2bb09543fea4f36091522c46c0a9c494bded5cb3d0f302e1 f82a8eb4cb20e88d1030fd10d89286215a715396 +2db6069c27ca4c08b784048644c307e17d0afe29b55f6488398cb59f13feb2f2 dbc0be625bed24b5d8f5d9a927484f2065d321af +2dc5fcaaf371da4d552fdcbfb79da7a4cec2792c823c9bd09a90defaf73b437e 698d940f85a59f00286c49af24b390be7cd8466d +2dd4d7ceabcce385003eaf8bdf8c53fbc262cc3dbc2041eabc72a7fa4b6ddf1f 0b8979fc62c435ff5b984d0c13ee42d7ac2e03dd +2def5408c21e4c0611f22321783bf0d4c21f8a9006a3b6522cf295f493ec34f2 5de89cbd8c0a0c8bf4fc43938f09e58936b8c2c7 +2df3172408416389faa2bb43248e82a2220d09c9f4b56b1d2093286d9a53843e fb20a5a4b6185d9188d82c874db3d9729ef31f3b +2dff3f4b2fe826157fc7c3fc1b4c9736259160f718bfb7fdb4892bed18378c60 856017fbf64464e3797689463e95d75496c0d554 +2e2aa456dbbb8889923eb6713672427854020298a764967c50235a9a76d7ce4b cf5f7235b9c9689b133f6ea12015720b411329bd +2e51a5916d344edef37d84ade43e3b93524ed39456a7ea3054bbdbe06e2534b6 d4191884cffeb8b2481197c4c4b7dae933493174 +2e5fde11fa87cedb853bea73f5ebcc9ed34830584c5a7ef74f083916cdd4e900 e896d00181e2053cf3cf6441732a13f6ca83f104 +2e900cde6077a860354bc38e8ccade669cadf2cdfa60396a3071215c5d32cbe4 33a790ddf892b1b7922a6bf78e4362965c7fb51c +2ea5535daa4731ac4a94a7551a891f08e3c6f29cc2a864be5b164652f2f53630 11f76e30c38265404b042b0a4347e86b66132713 +2ecc823b86990906263a4369e86108176e5971872da7307b73c46f4ac7ed8a38 9890c3f69ebe264206de411473f6220fe2f9627c +2f18dee4a944014c0e20e1a96046373cd58710db5cc74b584ed7d96a324f998f 4188d28f1c38240392d896fc79561cc461fb12c0 +2f403b3668fc75cd5a4b4dc572dcba3769ddc02d13bdaa3e1c0a144e976aff0a 6586dbd5849fb1369f4719df685763ed9ba48d5b +2f468a1542ddd517af3dd118fead80293c5c77790af57e351189155e96dedc24 7a2b79d3e2f273750e3855d7a0b15a4c6acaccd4 +2faffb9919a0b6717066117ee9f156a40371e8ba0eb585170188a65ec89a8082 ab5685026cc2b70c18e2c43689a57944eacf59ed +30312e4b199c64d45ad2bc917e2ac5364ca8f8901adf7ebd1492b7adc21ba915 e412d5a411cf4e9cad80ff3fb315c42a7e718ea1 +304352ddad641770fcc94ee4d9f957cde7aaf4c107dbf8b5ba14d543640bf7dd d0e7959d4b95ffec6198df6f5a7ae259b23a5f50 +307109fcf8b70083d2fb902f2316b8a0f790c3d9f73f7870f4eb774b00bbf44d d8603ed901d4af4d0d2b493d1164c74eae34f147 +31138d44b7d0bdc213b18a0845bd56025bd976cdbc1fc323901e9c50238b30e6 81723c22eae0570f3774ac588b572636f34a7467 +312f60f6c352b8c7367e976ec359c92196d0b17d491066d47279d4e1e2f44cad efa59b726a6d367badc5c39d83e86a1664616da2 +31ae8919eaf87822e8d11a589c35fee500b0d9ca51d0548c2bdb99d4fb299310 7c6be4f3fc4d952d4eab59ba2e553c6b77725bfa +31b05c73b9305a342be592d83d59408dcd54a5adc94f0da7fb6dba61acc2929f e719ec29cf9da6022610b46b463b80d393d22778 +31cbc27193bede4e2ff534542aa46c1a8ed7c4d2f5e9c9e462bb99d73e5f7691 c27b446edd6db301478ee29880aaabfe2bb66539 +31d5e6deb4c8fb548582ca4d37fd37f2605231277340f5b402fd64904c542ebf 5e8220f46ca2e7002bba745d8c0708622c64150f +31e01e45015260b88c5131254e3a3f72df292442143d2ae03224d61aa5177c24 8ea17a2c5a5bbf0f5aa72f73e6f980136d72e6b5 +31fccc3f5f0b0e514673895b4aba0dc2a54b7bf1441abe8c41b348ac997c5566 79038fb3d450dd7b37328281a717f275cb7eb7e0 +32ec9339b53b2bdc73e027642a1c990d3ada79a168de1cbcea2afd29fedc9709 027a51a064c6a3d91392f31f32b041bb1920ec60 +3302d4fbb5614b19c697d3f3bcae7ff785944cebcb095ceb418ae601dacfd986 75e6d95a87b9c6a5683a6f4b56fbfc9ae6e53a7e +33139bd70082e3948104945187410076178d57d31dd2b50542b9e2b321e85776 e65ddb38019b6e2c268f8ab9c28eb19bb162b032 +3315093132a8f28bd202c0a9562d04eebea4943dcd1e1c754341b0389722042f cfe3a027ab12506d4144ee8a35669ae8fc4b7ab1 +3317ced38dfcc6285ecd4187b6fda9e9027cd26fe11a4a81e537e770a892745b 39c222290d1392e028478037e250bfd215635cb1 +332d62e05adc040df538a64bb4cdaa02cf5bcc83fc8a0c3a19081be7956fe1dc aa0c0f471d53ead366e80077a9fc82649edbb4bc +335633f31770ec3147c2fa9305b5eb1fe95372bb00fc07b8f5a28d0aa40e9769 bb61d8117a8cae026fe4061e15c29a96aea3496e +3366326706d1691a8e07d043d23df3a4a96945bf9377cbe95d4ca9e695ae34bc be876eda8beabd473360e2dbd1a2ae5e80f6455e +3381a5bc62348132331d43b4c62f99c69e9d927072eb35fab9f10b9911d805de 15595ebcc29767ee05eb33adb216fc2e92af85f4 +338aa6b9127d19d369e1973f72e10306d02fae93bbefe85e40160dc40417db80 7aa92d44ad52b314e335fa1aa45096ebf284cc30 +33a9bfeba76f77472d80e57af9f6362744595f3dec1fb9e011446ccc43f0db0b 5d7f65df66f2bc9f3581ecb1a7932b31b8c98aa1 +33cba02acdd63428702757d61751c0dc47d51b011ba0f006774a2347763c5dd1 089c2d931b6b68dd82527430da51881d23bbd9a6 +33e415b835a670bb5c3c760efa0433ac0cbd2d44679f68f2df3a9ae7014cf2a8 1385f264afb75a56a5bec74243be9b367ba4ca08 +3447c9eb6bbfce8c4048e647e17d5c170564bb373efbafa65e3f2c64f56bd7f1 5dddf7c855f9c8e43954a99a6f85c098dfc7ed41 +345d2fbf1d306c7ea46a05f497793308357e9e17ab0e866446d2b9894378ddce d0d7e736e536a41bcb885005f8bf258c61cad682 +34e4e17c4c3b2175b0c8eff812e9c3c6bc689829b435c0f529cd73a69cdd7f2b 20c4a63e8cd8a70bc0f894ada6a54afbdefffadf +34f79ad1c813b93d2ee11c830c2134815a31d9629e6aa9773338fedaab90976b 849a5e34a26815e821f865b8479f5815a47af0fe +35511d2821ee472ed03f36d2e481f6d1d47a85d03ef56996b67f43b401e2732b 7a750b897cf8d5321db7b7f8a06e7d098b13a74b +3576c3885a36e2e498004c5eb560a8b98ddb87778d2680aa24bf12c2a34a8870 e8d0c5322cff755bc73d89db95334482f920ccdd +35f9aa36440bb182dd897a1a2c212fc1dc45e17ffd5cac859c87ec4ded0a36da 698b078c75c911b8361318db385d70cc84543a13 +3609a41c0506fe19d01fb8b4729923362675f191fe5f63fab3111ef804c48fdf ed1ea164cdbe3c4b200fb4fa19861ea90eaee222 +3612a2a9b865800bd6450c6cf21330676dadf843a578eb12d2e6cc6092ba3eb5 088a731f00a39fb3158dc9150b7c8d176df51867 +3612a2cc30e97df2d2bc86ec0aa57d7f332642cdc370d2b0df18eaa6a53bf220 0474870ab94adafa0bfca2fe128d6ea7fa2f3c99 +36693b61b675ecfe1babc324bbcef2e01bee0275b422152cd8c48593555d27ec a57e9a8cc15b61ae1ab908b362fd829b3e36e513 +3669ab580ce27ccc1dea9e89c70fdc98d0853d961dbac4dd0d56130f1784ac12 0bfeb8244a6a16625a0b6df594118e041f16a185 +36809d2768524a8d74cb2513e3f0e4d07e765b54230f7dcdde40298fe58a90e5 e3059f59ca36951d3817675131aad82c626c6d97 +3682fbc67dccfd36dc615ba17e3ade5fb7f1dcd6ebb425104317593be72e529f da5f70ee04085d85be124739bacefe69e829c0e1 +3699821b431131e6a684f5faa9e940a1097dd276bc5fd41e6a9f9424b442fbf2 098db3d369e28b5e5355db956df3fb45241f4feb +36d63bb74fd24718c0d6113c70db5bc718357bf0a9b336dd23e0a08a51fdfe6a 4275617b02912a72f62ca7d2a1b8f22602af4de5 +36eac24505d4c4405864ccf2f30d79af178374166daeceefbf11e2f058d30d60 270b8ea76056d5cad83af921837702d3e3c2924d +36eba302d2fb99d0b1c79bcec1198f1cbba6cc8c804a19d3bf2bd3883e5d9fbd 4e0d6d864d3632a820d8bf3dd89ff333b9bbd34d +37113624744ef096dff48983ffb612b765818092c6b30fc0756f22050e9c9cdd 03c3f39467c727707a5522e6ecdb4fd2ef09f8b1 +3740df04c191176e7dcfb8ffc9eaa32a49474fad69a959fd03a1234ea1e5dae0 5b209c9654c83719b07d9fc1d2287ca361663fe1 +375f69d3d41e36d6904bfa86221690ec49de2a030664a362abaf86c426f9f7e0 df48000ac4f48570054e3a71a81916357997b680 +37930b649e0a232d9d5068e3eca85924117dd83095ee0855e2e9524fe227ab30 864af6d01aff80a76f16241ceb82c74d9df49e34 +37a3d0dc04bf341eba75c9a147cda7995d68a8f9ff1c7a43871b9c7a7e3a9ff8 e24efbdd0d24660b10a736020ecbb98453bcd99c +37c7c3d1205434567f6127eb53c246e5760f03742e2157813c5809152d461491 f15b75039d7d4db8e989b85fc085e6f1412ea318 +37efd2fcbb9d39295e0c1521d7a4c53b9be48cc20028ebb1718aaff90149ab2a 7e78a9c8d5aba74a0c85d77ef590a9a9a6426bbb +37fd90d6abe96a2b664d80443bc426a3d47ab5d60c68e06b29bb32b82c9c702c c0d11745152c0a3bd8bd0e94a8996ac952604ab4 +38245b6deef0fde5656f71d86a9d89a86886d42298e46ed740756281cc07ca18 4638c830017efa737b74da9e55236bd515ac569d +3829e422229d9c5b4bc01df9388483e29b4e52935c4cf4c531904edf80f012b7 375649f879c2d828c5a10ab61992e5d84c016dbe +384d76a2f80b78ad569d3619586c957e6dff985e2fadfcc99f2f58e4f1690be1 9e2cd50ab5fa56644adcaa13bef9e3dfc7bf8cee +389af1fc5e97b1e7d9cb01b1e387b08862e26d67c3650788f51b8714c9f5fd6e 60f4720d8ef4cbbd09f7f9ad8e41bd77b4814cb8 +38ba5ee9660e8ec8b261e2edb1441987798bdaa4f19d478241a76df16b88d0e5 dea66ba25c0b724e0dbfdf494d50f7f3f2ca780b +39bf1ac28cc3f8432ba7cfeeca6bfffd9a0fe641784db85de2eb0f57b7553869 b6361fc6a97178d8fc8639fdeed71c775ab52593 +3a0a4805f179ea4e115d542497fc755a2c1ea5792853609a25b26b299553df6d 684a1d3d44cbbc86381f61d4d9305012799d9f5d +3a0cd33a47fcd0c7b8f8c1d407aaa53f648e25f2ffe2533a7e9c09c3d1b9da75 2f9b6b6e3d9250ba09360734aa47973a993b59d1 +3a103fcd415b1565358ec83f4341844d2b4cb68e1db409778a7604cc47ee8663 92ff6464177928722632f05a3083dfd9c5dcf47a +3a1b33e58ce33cb9658a2ed1cb6215a4120f4d8d066cb7f4c5979db9070fa59a 1fcdf832d88aaf0f7abe480f5636d0cea10aa109 +3a32ac3a0452f13635a41fbef02879bffb3733491b4b791fc1766b6f208acb59 3a612bc5fb913bcd8dd90fc3042f23882d626a91 +3a3735b8a28278539697e5f6af5c45670d526fb7538ff1594e99df6331c382b4 495eefc6e0986083b95f87974942afebde688173 +3a70044491dcb883ea825b2e299c512f1877761862d5568028f7ac185cf38604 17e194d81de579d956587ed7411eeb77f88df277 +3aae8af9b31d378f55fe8390becba6e9d7a4cc07c2df45fad2289083bcc090cc 12dcefefdbc9972cf851906ca5c8e8fea46d1fcc +3ab0a48f387c62d22abef3b52bab7bc7e41a3bce649e573912d0de4c79b68af4 0aaf8708b0f67ed9b99f1c1e2fd28492a671123d +3b1b991ae70d1f5388ad16b63d2285e99ada7a618c6f5d01e50a6d4b33c4767d 2f06098183b0d7be350acbe39cdbaccff2df0c4a +3b58565ee067f13349cd4f89aa396d10f71c69e168d5c48ea23de59734ec3ab1 f0a2a10243ca64f935dbe3dccb89ec8bf16bdace +3b76cee4a13d688c4c7f83c2394d6a0b3908fb4289d917c439431d85e53e08d6 b3e014dd4810983396c9ab09edc7be1e0ed1ff51 +3b80aefa5801cc70308cfbb6300e7e04f9eeaae97703e0ced39d05f6ccb3a552 a74605e0562a64dd538a56a3f29ea85322f4220b +3bb429f2e42b885e937592255fa2da4014dcdc63fadfcf62413f0660f438a85f 79ca2edcd4e7a801400fa33c2c705b8f03a5d7f5 +3bba055be795e5d49a89496f0219ea2f43cd9eb6cb084669eae97dc69bfeb459 a7f70745f85f445596125cae6e357e84b84cb925 +3bcdf0dbf3cf72b38fd65d0dbd8d6c6c4d9e3ddbf3916f03e1e6e4de72785c77 20d191c80cedbcc63ed52096b8b0e180c6bc16b1 +3bf9e14c7f197bfefdff9d52063713de4bff0b857f53b799db0f4050bd62d3c5 52f3dfe9b5593c9dd45980c36e2499f2e9de701d +3c75c9f9f003694aaaff66b2efb4932dfb0216bb85d6ba5500d6f4a05e92b0b5 eeae5bdbc9a3075ff9ee6a08af804b5df11154ec +3c96c1697a81679472afac3dd2723abe86f34f50cb2804eece8b0c942b3a6d9c d4d88ab7e48adcc92099c41b7a5e85d580f9d77f +3cb25d62ced555f8409804796b32e06540c096ef858ad45c864f31503dbd4982 e3409fb59571d2eabd07d4d7c09a0fcf07b6cc5e +3ccee1f77ce4b4db6e6ec7162538efcaf479f3ddd950ada7ac800abe7e9661d3 fe3c74b75812f161cf1838602ad7567143bcb593 +3ce006ae57f23548f85a5527e5cfd9ab29ae42aa1ba90057a807346404f8174f 94f7fb59f74edb08d375562d1814645dbe7ffcf2 +3d14ff2d57c0186871a99a497966bbdcd17e61c41739cbeb860efb0f7be31c18 dc5b2ce5d1c4c9c38b94af511ba60946b8761681 +3d45b4ff158011774b796fe55f7041f932df6dfdaaac2dee934a0b6f2a2e5d4f 8b049129be2405e428a3bae21ea9b99387a96afc +3d47ad957bcd83e6603d706016af1b6158878b32c902fbc86d28918d640feb0c d490452617988fed2ef9cc3ff667396532426903 +3d8632d47f3f70b96b9391e692c79b6237506bf999a012e50c1c3b15998748c5 7fb15ecd2e65e379b6f3af1f25be0024c0be27ad +3d8a6f490eba51281c43d4b67e0336a2947896a4bfaac3c0449a7dfc84411128 1e4ac7e37cb4d50c35b7a52202c646a81e5c3dac +3dbaa90e18232adedec438665cb022c35cb97c999ede79097d3ba17b1810df0b ce4344fa507b0c6330a3559850c9cd186d1b052d +3dbc65bd993e6e700790c5c51ff0e0027b55f55699293e73fcda7c5e53a8a3a8 1b6dfa9817a8f324f234f0f31cdc79c016b40264 +3de437349b8b47ba5cd83d5f70956594de271cda393792922fb2416e3f327f5a b7b0d0ed2d91c83b59914db77c3dbc34e36e2c0a +3e00d8cae2726dc33879adf876b30c306f50e7a85b15c8add4a27f84d88616d7 1088490171d9b984d68b8b9be9ca003f4eafff59 +3e24bd404d914a9195b89466b1801a0bce6e55fec958ca7ca9a778a08fae6fa2 010f258ae4bf72c23d01e8902d7f5dc8e4533ab1 +3e29ebc6f1b56a649256d7c35fc227c530f1477638fcc68981b3626e49746928 ac7d251b493d022de34162880d30392aaf88cd3c +3e5411e6190b46bd834ffe79f2bff3fe5a9f99ff2d4b5520bfe84cb22e295b38 6624a3e24af09a12acd9b5b98c3109fca580410e +3e9c52a7e147ac9dc1a9e23ed7193642e108276f5e74397201c630bc1dcf20d8 c8df0297553b2e8c273ced67b3bd3d1603c9d4c7 +3eab74a6894d790767f3d92615a6887dcccaffa9e48fdd2ce482b5f17efcf9b9 111d5ccf0bb010c4e8d7af3eedfa12ef4c5e265b +3ebff01bceb09f6f4e2a24596d6e281587981dde381be64240283c0d161e753b 64c993e1ed74492bfe41ddfaa8e5f7999b5b3952 +3ec0a36347125293ae217e7d4049dbda22951ff9cd0d5207118f6e963a7428d5 60ea5e87d97ab72853fe358b4de61a68ca7a3908 +3eee10d9f6089f9d03d64c65b9aea882217f833ed9538e7dc49c2ff73ec9e41d 0ccf3c2464ea829a6320156b5ee131337898f2cd +3ef82d40c8f2f25a1f20d1e459d083eba406bad227af5881c6fe97aec74ca7ab a0b61b552c08fb538365870b3ff49d936a46c21a +3f0764d48b89e7d99138b291b09ec88b9132fab0a60de5b6505ff9d9b383e843 8e9e423eddd73420ca4b824f54211208f33628c6 +3f429bf36329d28d40103a6b1813f92b8322bdffb7bd5943cea40569196e6838 eccaf6f8e31a3c87b89243153770455805ed4c1d +3f5dca26a2f512d6681ce1957b8afba5e031bf63d52fd52d8f57093bf92391a4 7033f9ee0e52b08cb5679cd49b7b7999eaf9eaf8 +3f7fdefa5ab3f52b546c3cf59cd50d61c29efbe4a2c40b1d5ab8e50ef34fa398 3aed57726754bd5c09bcd425d9b99add5db50a78 +3f838c3c9c70ea829eb28dcb763341b8c730131251979eb1f60ed6819f6a500f ff02f4077fc8420d328c8b91c1f5b2e71a7c19c8 +3f881332ff93d2176b18dcd38c990146ff160b3eb83a262bc77462edbc246a32 66ce77617726f19d295e56cf7de330c848325646 +3f933cd9565bcc7b8be630d5626c9dede75c7aeca14473b2bc2b88d26417c7f8 29f0e90ff41bd7079d3e620e15370e3a8385884f +3fb315ae00172e2f6cffb933843a407277ea426015fa6224865a7c63ecc37d8f 2dbdb824f0cfbf5f583e6b94aec753f276ed3368 +3fdd086cf7ac8ab728ff01b763ad65b9d1b7122580d88aee652b8ced232647fc 175396917d98ba13e5bc959bc3dc237cdd492036 +3fe6ac134c9e29c44bef2dbd0b11718e203347e4b867cecdedc20e3466bd9896 69dca959508cd04b226b3747c0c07f89f3bd1a87 +3feda025daa440402e3c020cd88a0e9378dd2442e55ed409c466376d5b424730 ea790f337b0e401f5e4acabf9af9c2bc756d5f3b +40154096dfe3b0b1abf64230345d327bfb530fdc2eea093d407bc245a94cd71f d15e94c0d4eb0fe06dd1e25d7e9e3c4940417f56 +402b3758191ee821d652dc759baf30a8949a66e3b7d073e7e79d91c053a7207e caebc63b34886497fa2b6ed9814a327d3c91e545 +404b795df44dc8a0830397f7598ed7383ffc5c227c2c8a2223bcf9cac3e6a4cf cb98fecad0c4379496f32a3f7ce3aea2ca553b3a +4066249c68b0d3c8b39ebe02c9188935900465acad02a49269710f56720fa58e d0fdf2dcff2f548952eec536ccc6d266550041bc +4071ba3d3cd2494d4951a322550a934507c44cc7278c90d5f7458c512407fc8c e58c5633474c35eb16f9dec209d57aaf881b97cc +40799f33b8cd9ca41f36a2f89d8ac8550537ad01dfb21fbc76f01eeb62f512d4 bfaf8c42eb8842abe206179fee864cfba87e3ca9 +40c6785bdf24b49d3b75f3f1f918dcdff55b2a001b66afd0a411b3e8439c9066 979709bdbc7b1c91505138e1aeab9f8b714480ed +410cbca5119f2d6f16c3e42b52d56148d5f72d45679c92ffa3b6d9a2edb756ce 80176fc970e2964677967ca1a2a3689364513593 +4187fa8d107c1c86d8615ef4712f1f7c64829749a52a1e68c715ad9a531a6e2e 33f0f5ce19ce81d7d32752b140dd9f5871d72eca +41aa03e11a4af5047dceb683d7a03cdeeb904c85f8a58464c99709defc5c0301 c45579ca160b99e14290db789f3c690c406b6dc0 +41b613b0200cd70a7f5f0dd85a98cff80cf770d2b69e3a270fda0ed2ea9e3577 4a9c7f5656c7c53f5172e16174b96ab44606de35 +41c166c241a4e878f444932a193501e12ab38ba0634747291df70e619dccee1c 3188ffdbb3a3d52e0f78f30c484533899224436e +41ddb608f05a0551ca421a4c6031f9f0b0d1c165d8268462155614a741db2f50 ec66baf57304fbc94d8b1bf55a6264b6a34c5972 +41f0c76d526a391e6642bf1724a2f32c926d1d10262aad6183d7cacade456c87 cc7301d8a23a16789de6d298a6b1d2ad7c686184 +42582993ace8a3488078298b40b08e2e48bf576ab05b1bd36bb4884a9ce853d4 6add857acd3537b186d2c8d2c0e3027c364872c9 +426317ab5167d24de98d3d49614d713fa8e5ba435e1d9600c3b95d2fe9f2d785 f3489977f6f6d5839be9f17118bb723fbac74a89 +4277a22c721ffe0b89f6fad5e7779f6fe80a708bc471ab49bba329d41d5843ad b1bdce4f69d6893727df16ed00fed96d701fac06 +432fa95d99227269dcc7298e892e53873ae8b6a283041bab4febeb298fd3ae10 eda57c53e981161ad7cb25103fbccb31661181e5 +43630957599e6247ff790ed2a0021c6dd072687ea8952d64b767251f79135d42 53d25eef40016eb27787814df58e0b56e76d9326 +43723656763f3659a5e094a87df27c5b43d270840870dbe1734142e2a9466d7b 1711eef6e71be6d243016b5e138766b3777e08ef +43989c902407cb7bc3753f4338f4847b21f53f49c4e9f750cb866507b64ab669 b438016ecda7648426036e66c4ed17fc93e71cfa +43e084a4599ca42c476919917e3db8fde0045ee66305fd5e634b0c793c536a1b 4a202b346bb0fb0db7eff3cffeb3c70babbd2045 +43f15e413a5b988bfff18d10d4b3bd546b13084560e0a723f4500fc094e13558 783257d3b6a3279dc62d194bea3b7f301a899351 +43fc14cd889029d5ad6e285b60f162e73c9576d49068607e879a2a0e5127fa5a 44b6a517f15303e5ca4cadb090c2ae47cbdf0c68 +441eb4d681a9c013e67255dd2fa2fd722863bccb7fa9d9a9230b7aaf5f107ae0 47b0273228dd08a6ce617f8f3ab2092a2d4dca57 +443f41124cbcc448cff03bf4ed757ad88a5f5b711f761764bf37c64f7e900869 608d33fa676aab1ed350312cc07e02cd7f94847d +4481293fc62420e43723b5402eb6ad4042f5f2951f9c9413c4ac3235edd4553a 08167bdf6e553be1acfce09de11aa69b1c3a807e +44be0bb4fa20d53c8b321492e98794e9054b66ea200d626b9d9f8c990344b32a a41bae0b8aab4991d9d4bf9cddbaac3c6f38ef9e +44c505e4121cbe40d889b39082f5bb700ccae8e93019335df7242e6c84f8e2dd 13b8725687aa88dbac7a9a34865984d6fa68dbbf +44db3dd46bf12039f93ff4752baebc137f2f638089fb0e1a217c99528c3602d4 9fd8412e652899d03576190cbafe0ae194357827 +4516b0e63349c81abc6584cb11ce84ab8ba38b105f9de39d0d0a1455dba2478d dff79e27d3d2cdc09790ded80fe2ea8ff5d61034 +45b27cc016ef3dfa31290c1e564c82266dfd4e626d65c10e4b84717f59acaef6 76f293894f4ca1846f52513b420dd68bcb8da127 +460ad78c6b885a65e795a6ac9a4c85d5a6083b49f2a168cf14701b1aac7ab51e ad9f7df6bcf1b6e69be44c85641380848eea36b3 +461f1d5cecafb15ce791d599ac2114b5cd320cefeaebb90732970655e6f85050 aee8b26e6322bee55403a61634d7e01b77aea4c1 +46333d32b3801cf11d9f80b557245c9e32b0e05deca61dae968914fde159f0e5 0cfd861bd547b6520d1fc2e190e8359e0a9c9b90 +46698c7215f6b45759d9cc387e8d3121ee1ebaac4330cc1e1f38358b5d67b973 9bd5c5f028c505f9777c63ea85c5399bcb9cbfb8 +466cdfec4c74f3ed4fe53165e468a52df5dff9c6533ec433cdf235a73e099d32 5052bf355d9f8c52446561a39733a8767bf31e37 +4686fa9fcfbd200774f6b6e55dd719a3eea3da7933217c7da0efd14fa9fc3242 ed2292c12cde99459c5859362b45712deb1d5136 +46cf6ef7c306ad8d79ae690f643ffbda6d1cc3481e46f4202a166c6dd141cfb3 d3b23e08fe7235ea387b45453424409fb54ab7f4 +46fe85670f28bcacc7894ef9227f4816ff018994a67425ca92ca71f58f57c5a1 f5607b58a0364fa99eb1bab8e1c06fd948cc701b +471b08f85206aaa22b74d87e57de5caf02fca30587512ffc81bbf32d63e9915d 58a948216a0b01a66b21ab7a2116adfd536cf922 +471fa4fc2da467dd94e57babb1912bbdb5e40b96c8129d46fc709c0bfc009bca b0a8568a7614806378a54db5706ee3b06ae58693 +473a0f4c3be8a93681a267e3b1e9a7dcda1185436fe141f7749120a303721813 e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 +477a19a87cb58e25978dc3302ae5f089d4e4997257fa09e259f2f03ffc5572e4 c5bf0cd945f7bb251ab2d30ecec98e982bbeb49c +47f06c894892f592fde64369a0850fd5d7b78d0e3ef825f66a064acf6781fa9e b923f2f97dc26e981c18da93b98bd5e7b44c3b79 +4815816fa5a372f9391088eb904b85bcd83b0f5117772b597691dc43fbf5bced 5df58dda56789631c78aeed62708e1b694440195 +48206be797f7ae1a97312fbc167d2f1d68a7a739844105ee0829635ad3db5001 5cb9d1b563afb84d201d9cfc98aa774d7c714266 +489243ccce2df9992af678d0bac3bbe47d19de6cf9577e4e993e036efb0b194a e6b63299b2cbc04ba8720f77425cb58c7774d4aa +4892b87dbc8972e6de31028fdef2e8ef01f4adadb782e61e2995424a4e660c1b 55ea3a1ed6a61ba508ad6f9e8b70169fbd7746a4 +48d25469668795d0d0fcaa9964a1c7555b750a8d700869d5d8cd466b1f3b0881 2434915bce998e8aec539a19419f2c50f26fa6f9 +48fc94b3d4233d194db85973d6028ef5da29aa21aed20f8096539b837fdb9cbb 171aaf21d9f7582270c390962f61d3d2613c4d59 +49235ddeecf412d250153a630dd1372fa0ea2953f64edf66f9cc712c4e003504 41e13b227932a121b8971909081382da4236d674 +494fc3881f4dd0afeb9c67b9d03ee0a7bfbdc344db53d35ca91b23b27b8a25b1 8a208841484daebf2dc98866e6d2e44bd9467cf7 +49818c2e41a63cac45e51f99834d583c2623c48a2add67395238eb16609c7f43 d90233146d40105f042773fce6917fa4687b94a1 +4981f3f393dad6299538f859bfc10bfd1a46e6c1a76991a35f66c4a63563bf74 42fd40db68e5e5797531dc1f5de7aef39a2262c0 +49a226f8527a921c15864067e049ef18fe0e56672cd9be551eb1ac520cc2fbe0 29d1016d5fd281f10d5fd8183fd8bd2f1aa37121 +49d34d8e410e2bc0d4e83f55f013feff99a8412092b44fe18c388e2cb61539d9 01ef4fad010ce3b90426982172b2d93a9409797a +49d6ca3fd96a83a837867c38d32bebffa599cd8f0e1442ec38f9881b33184f78 a1d34bc000cee6d72c3b5e329faa58424641611f +49ea7b53ee934be208c963260e61d8939898040d12b4e1c166222b5a7400eb42 0ef9d2aa934d6e5861206e8c5dd829dc09f4026a +49f1fcadf4ffce148c8dc15c655c325b0c52315f3e093ca5e60184b826f1d575 9b17380391d7e2e4cc26654ee4423ec14d379d28 +49f7c79a7b31b51b469de45d980e77ecb6540a138121dd60bdf399d0000db2da 29e77b4c60769b427a0cebf6573bcbe3b8779bec +4a1b9c078e7bb20759a2d75e3a4b96827c851446c0261750b96aa5f286efe378 cf33ac7a3d8b2b8f6bb266518aadbf59de397608 +4a2c51c855f0dae37a9d35532cca06e82c6c00e1e35cdd5a1294ea79a0c89b8d 8b9579b77d705268991880156c59a6ecf3a00e32 +4a4ebb837e3c9883f35d0ecdc26d4bc76a0f665568b08f3e967096f2fd3fa537 502acd164fb115768d723144da2e7bb5a24891bb +4a7732457b004efb34e8eb1405a9a26f66d28866d8f043ba3d732b4a640174bd 150bce88353a5b322b1600a5989e126cf8288562 +4a98d245f29b382f3bcfe34639530bb5d04f6d5074d9c22359b6c8a1d5b25540 1dd35dc8e28b539e6b2e15ea2a99d43ee4d2f282 +4ab6132f0fb323c66309c552e3d84cbe8a374258ac42bb51b727e02d881b04df 007e075337848055a92e218bdfe137451a4c9635 +4ac0a355c8c8c1d9f943292761fcbaf0f9a342b6dafa1ece1145903e2a07ab44 75d584305598407be4c53d42c85eca3cd58c973c +4ae0fd2cd8725f4c1af5517529f28e608f1dae886966739d3a6889b8722e71a1 bde6fd7aa4ede6f79d41fa5be13567d12388c79c +4ae3f76027b14d13e85f0f5498a4a697583940df57ac8733aa56d82900112a80 ec250c6e18e56d12714f9010e1b15e5feec5f473 +4ba2e6fe88717d069f04f6504a12052b38307bb7d50adf36b19152f50b533082 4a869a273478d93810045203fa44e2404d0e32a2 +4bb30c70803cdc8f5945d4f61437010efb53e992301ed4f406b0706d0edd26c8 3f84b7d30bcee174491ff0015816fe8831b1440a +4bc0f94102287f8e84de5459edd04872cdb10a27652c49499a9689fa073566ed a6a793147da3bbdf15931e03128af729b5d0c4bb +4bc142808884e472ee6cc331b132e66ef18f564d41efb055804ec1dd28efb3f5 a71586c1dfe8a71c6cbf6c129f404c5642ff31bd +4bdc2bd639e67ab657405823281a1f4e8185eecbb81a4942278212d1fd47d941 4b09c08aefb8298b3ef03691eb8b4970ecadb1a3 +4bf5c64f79284904a0c0d54bbd380a63b7c7be4ded56619ac7aba0ac763345b1 d25c9bb2bf4c052f41ead5328a068f6828d75ba2 +4bff6d41212764361eba5a8167bc0168cb027f50724f3c53e00e2c435c92fd06 46f4e377719b3df0279e66f4d8d7677c7fa16dd2 +4c288bf404c8e93868ae54b4a9e93124c56c1c61184466629d03310065031e88 388e9c621a9deb2180cd601e30a540cdbd310b53 +4c989a75733680cdbe9068f0896f30aba0cb9c8cd4334e349dd815a2e6ae6b7c ae3a1615a8ab6b9a13ef98fb3f60efe727615310 +4ca78a50e220f784d9f0d792184efb85d2e78ca1bc8aa01713c794cb099c0cee c79dded300f279a6d8660b13f4fca3c684533449 +4cb34795575974e851198c515d39f43c8482c0f82f39518e7ea31b862168a6c5 ff5f93335a52245a405e12e9ad1091f4cb875b5a +4cd983d076e60b69cf7cc6c645f66eba7df5032d271c9ee95d74193b8e3dcc79 795f44a7d7e1728199aa9ecacf35a55d3722e06c +4ceb14f374b242ce6b94a527429bf46799f37071e59d43add03c79cc3f78f7ea 04e8824004970f6889b9df126b5db343013c82c9 +4d068ba9c35443df0a7723e96ec1eb1b0c86dafd4b6892a93491a5d818d944ad 98f3b5407694b1977ed2b4fe548831916e788ab8 +4d400cf49a7d61e1829d382168d34818c10f174e6141909e6f253142c48bc725 62496552534d8c5a4fc1839c20c33b0de4ba2b9b +4d46d9719e425ef2dfb5bfba098d0b62e21b2b92d0731892eef70db0870e3744 e90810b8df3e80c413d903f631643c716887138d +4d95fd7a1a738b7b73ff5b0c595d8953497404cb61a91b787ea266450bacb2ce 1d1be8ee22a69ad37b6cab510bf5f480dc6df779 +4dd37b9df07bcc7b45ce72a44e3f5fcaf5f0a9a5f3148963714eac4c99a60388 d03f567593f346a1ca96a57f8191def098d126e3 +4de260deee1620a10ad5f497cd446e3c6bea110a5baf5b82fc510bc6ce5074f1 c620f25d7fb92598b819001c8265d0d324275546 +4df8ed86acaac5dc82b5652170996ce459d39e3a441e9759b635b0bc4ecc43fd 4b22b35d44b5a4f589edf3dc89196399771796ea +4e04d7c66334581183749a291a12d263492195f3418d12a06ad507705dcb8f5f 290ba2a03a1b3c4d6d76737df0c9a8964c0fc192 +4e731979325f7c7ea26f941615779e107442e05af41f66959ee130f0a6d0864b 37eb3fae578d0c74cd43af472a96e58eeb29c7d6 +4e7d3270a3ec5957db4fb47c36ca53e140252a975ae3019565280787952f28c6 8be856d8f8c8aab89f093583f091979aa2a4b8e3 +4e8061916861af6c1400709d97a34eb696efb43e9d862c53d9920fa0c71a76fe b580f2da89f867e9031f9d5dd8f58a20baf20b33 +4e8deea38a82e0ea12ef279bdb6669f3b31e1b10862ecfdf0f4a2b1c37ae14d0 96e4df3bdb0802fef56077e3f2b24fbe4b72b4a3 +4ed01278b8fd34390518ee993e4454928b40d85760ebc6fdfbc8e66e45ef7fa9 abb8a36f30d20e6f6c1ec2f5639c014e3cc18535 +4edae24c115b595fcb68ac98ea93339b9f2f168ecabacfab22cd6a8bab93114a f2a98a88cf3372bdb57d72c7136be6d42b5be1b4 +4eff51656a824127b4d8c5d9a6f4880830c91fe325fa8d213fd1afd6790affce cac5d927b51bf378cf599a02d38538cf7ab70146 +4f67cba8f2b69fb809b5b8303d82624e443647408af3466e59c10aedb2422e7f 0c7fda8e41f67823610884815c71cf47c6dde496 +4f79bfa3bbbcee0f835fb81706a3ea7264ea4ce29533000a24ee291748193d18 491442f97ec18dfdfa88912d20c2304d6ded378f +4fccb0e68f9445601a507d0ee3d00531a914a409bd2fceed6c07bf3189c25362 1ca0fbb0838e8859d5928cfab9acd749e618b6ec +4fe798a4c86598a3d39cc2e8e7cd4166f110d79e49d14fc0ce656016142b9ea7 018fce57e6ca903bffe9abadd2b8faf1e60c3899 +4fef7f7c937fa759ef00bce38f77e622a67b3bee32d6d98d50c84630e74c40dd 2bf93fa1071c3df7f43926c8e6c3bd2353d78160 +50085f68f619f133f16b57b7e3d18636eaa349151ebdcc0eac3f6de491de0828 e323fc5116fcc4fd39bbe3dbbeab1e2712052e09 +50141d4c9e46aed05c08d59a50a230e5507cf172166784d0f5bb6a1edca97377 c5696427b6d53a3f79baad35ea33c556884a410a +502a0aef29fd792e608b9d0e312dec720cd1b1bbc41a22a5ff05b5679ac9de94 6c31ebf84bd6eff927f1e6cb5fdcb4ebf56e1e4c +503680aa43ed7beea11c79ba04a43cfcbc84741e7e8b9fceeecf7eb3a3e46e62 7f12e62c5139c9c43ed54c3d44cd3a32263d245d +505fee9e489599e4e4d0a3f966a981a7aa7ac60ba8c774b2b942f0dba4b60ca7 16ba02bda9682555bec1bfc9225921d7e949f16e +50a8f69b7ad3d2fc73678d3b5a7d474998c04c83af503e57b2368a78e8e4975b 1cfb0ff4b6193c409e846a5992683559afd4be07 +50f19348faeb431dd64cbc6c14ffd04d1ed09f3cc7582d56d449cbef87a52b72 84a5237f8ce73ff4cdf8b644ddfa9f0bcedb45df +50fae421c835c89e59c0103070a489a071ad663c992308b67cfb346218d1da78 f16c489d96a9a046cddb3de04198e96b65f73330 +51555c7599dab2ffe66391540f293df885d8f5859b17b8de3bb3ff7db3832619 a5ab36d1d5a5b73d0df5425e5b0ff25eda320563 +5216691483e994addc87468ca4d0e29b4ed2d2e85cdded14f5a0ff5604edf733 3bbeff3fc22b75c1a26f4ab9b64449b33002aea5 +52cc121e697beb8a03c666a7cef327534c6093ec79c3a53babcd5e8daf5beb4e a4e23d6af621573f5e01adeae0c34099f66df32f +52dd20196726c4c9586b9fdd025af66adc7eb0373f5c62aba864fefb526cea55 64a47c01426a36cdb7e598d17018d5791e54bb97 +52e11d5ceb65af472f4665ebe312542aad2b6cd032093254539db22126f7f7e9 1906f2369d2906cfd4affeab0852b67c4a91ddca +5327a985a8eae90deba5b4061d53c803cfd87ce7d5b6102b6ba8a440f1708a8d 32d5e64646c0c3a5229e2008e21a45a741e197f4 +5329dd2fd8557be5ad06b57882cf42e23d767cdc8a4b25e464fdb00890649e07 af795e498d411142ddb073e8ca2c5447c3295a4c +532bf3caadaf4a236b802370418cfcf91668947474f540cfa8cfd54223435efd f9660220534f2ff457939a16634bdd5bc55b7984 +534f1da60db89d7c6279315acf64e3ccdd1d2892938f9bcd0ec9850f127bec92 38c513b9d1f6c19f191927003c5befd2fa70da9a +538bde541f9512cf48fe308a110a279cd36ae036d3845db0bb7574832dda72f1 e667e1741dc49767b8563796879f344bc2b08197 +5398744baee56c62882d02aea2750298ac9f54415fbb62894d246d9c0a332676 94eb865e6b5e041f6ca6ad16ad102ece39ca3482 +540354213f70c39f4f6e39fafc65ea211a96e6925403a3857955d42097f52e39 8839d5b02bf316795bf8716c33efe255c3b6c8cd +54139ddc224333e61424ecd3e0d1d3657422696d8215228bd5b26db14f63647c 0d9380246ef66cb3702c70bb9c1733fd200739ee +548f39b3c94981fd63b03b135f58b8790e2acf91bcb754546c7ac87820fed04b 425aa0032cbe69c0ca70f1467e54e862fbc572fc +548fc7632f9b3793ae8ca2f9bbf4c60d640973910cdf5567d252d5074dd79e8b 581a704418ba8f49517cbec2bbe44e281c2f5042 +54ac7856186ec30cf5e419d09fc567128eb24a7e73244f70f55b4860065fe055 74766fd92581310d08c6faff6998dbf307800282 +54e3102db46f8f1304dc4ab62763a71f915e4918ce4c7dba10c015a4f807fe6a f4e43ffc62d7d238e971ecdd8617d45ddac81caf +5522689ad5f3e1754f7cc5daae217735eb70d0f68d55890333e8e7522ada298c 62da145b914438c95116b46e7ddf11ac3a56883b +553b8a974a6f8d2a8cec357147161961adc5a0ad4b9f5fca91eb383d8043a16a f9d0c1adb25cdce71cac5f01e8333f201208a781 +561439ae8748339d28a29eb0497876fc8d47cf78c515a3c989739b674ed7df01 351cfa4a4983e1f9241542a855d53d93c951fb5f +561c1a1f3786c440d90fa9d2fe5549290d95cf10881d334c11fb919d3c81b4bf 5d1e7929bb93b783b52bb144372985b8e5b9ba2c +5629b9b5e602665557c9c7c31f9b2ab72e235ecf54ce1943c344dee027db8564 a1c0728d12b170e1e643f219fab53b03cd4e1b09 +56359702cb503f029d099bd51e6c54d47b0166dd43efa99ad2d05eb548773970 933cb118437ee8a4422e956197a8a4f09fd7e9df +564017a60020eafdc626cf1a2caf4c57f128c489d23845e70e0c3c4dca8a187a 9ae72bd6780d6cd354719a1d84120e0690ffb5a7 +564d38d384f7e08bf03f021d1088837f3f4dd0c1b2c495fc3733c241e7586e19 58abd58a7f232ec3468da806682f39267d5b23bd +567e9815220b48ce3e8b3710364d499f84be5e1beafbf04e4e9d0772839e6213 72ea4e962dcc9bc157391d5679f13276a21f8c37 +56abb178ac61ea5ad9e6d2e0eb7dd731c1ae88bd15af3c65623f8d93212b48c1 630785638fdad6d35d47213ba2867a702777dcd5 +56b44edb90e571e38446121cf36270dc284556d8b5e1150ec03f9fb2f9059a58 83f7e7bb0a88634bfee2c4cf3434a2418c5f2880 +56b5280262679ad90e14567f62e22ebc108c9765f8421beb643e2ce0499671ee 95d21f5564cb13338520ecc7fc50b55866a32b24 +56b6ff774f9a813cb058c31144b98d4254329cee2d00e595fb26336be9fa9b96 b376cb120f0113294b80e7fd540d5dc197797764 +57ab87cb9eaf3afb28933d81fb2e3ca43e699cc1f02da50a56c3afef103b7673 ae31ebb7078c0bb2fe5a3dd697195e2d9068dd92 +57b1d9ea18f9cc3a9c596ecec921938223879a49c375968ea034608e077283b6 76d50675cca89a89b263f23d2014c7de7f59565f +580474d948cd2ebd2e5ce7a5b81b872d87ba4639c1ac4c0fa7a11a8eddf9827c 412ec4e4a6a7419bc1be00561fe474e54cb499fe +5818ece015b48860c7e518f12b06399b60d7868b92c3fdea05f2d25d0077e476 498bccdfec1fc223c27c0d84030ff419058e452d +582841d0c8af7a4d254d30790f1b07b3ac8f3f1c947be0a31791e84e307da00d 9de0a701bebd5d07bbae73bbdb3f8c39e204bd20 +585d35a8f1d6c41b0d48ab5722811c0daa8bb51164f24d77bb4459f95cb05169 44181c23ea6c39d51a4b481dc59ecf2cc3967e76 +587d967295661afcdb5a1a7162f59927c824268d19cb4d9b81fb5962d55b9bf2 225fe21522a98075bdc18dae90ce459f797ac366 +588e7ecc3c2704834f904a41fb90bd1091ac1eac8b5112bd60fb2382087aea82 9a827fad4fddacb757be5c6eb3e8c5f323ff9952 +58923faa87c7d559d308a114ec2b164e5d6046c889420ed1def6eef2d55106a2 785d3fe8e7db5ade2c2242fecd46c32a7f4dc59f +58c150d2dbb9c2ee86c46b5124a9508f632c1fb35325d8a8fd1c59dae3bb4b42 6dafd0566786a417cfe1131ab804b162fcc79d15 +58cbb3fd7fb9820caf0f9c15b066ab41df8de6fdf1c83d72f3bb460a9922b2d3 7b08db51663cabc4794305fe36fb5e09c575d883 +5905b697743f4998b3deeb3da29d5270ea6bb52c90d4dadff6f28f0f72edb968 2ad730b25892080b9bcc990c05079a8d605946d9 +593b262bd7c0c40d61962a36f9e9983402bf8b4b585a6245a47b161a31193807 7c3f1a8504912d590d12048d32cd31d2d75d69ac +59a1967792d9b5338bfe0bfb7658a932bd7a65b3aa8c8401dcd6f149bbe1e4ec 046c8a0d9a405b354f298c7a73e8755081a949b0 +59cc00acc478955e567e5d9eb9b888b8b538165673147538b6132b4113010171 e815adf588053e45a5f5410d44a586f69e66c1db +5a025657f0e06e135eff8536b93877c7725b74f2317b6844c002ea135797c531 425b3cd58cc77a921d6970967aafaa4391cb7f4a +5a0eac41da13655a7cfa4f4586d152049b9ef83b5cbb41c290e3529a856c7fbf 2a0665949d7f96b9776b6f36f60940351b47cdf4 +5a1fa5495a4229c962054c7a09623056643e55db9601d584db08039af54bd01b 33fb00b13d006c5497ac0152361769b650397dd6 +5a2d5699fea33657b42ba98c22b7898baaa0eda205a21cafdcb7e0f94b07bb9b 9a03079b8a8ee85a0bee58bf9be3da8b62414ed4 +5a417fc113d54074a22bcbf157923fd439fae36ef7c22cf96e6a99542809495b 200a9469e6f76a538b8539d671161a573c3ac91a +5a48249041aa1dc714d3f4337776768d827320553e118cb4d99673dceb9c975e 0ebbc36594071221b685805590415d74624f41e3 +5a4fa7cf1e417c1032786472b9906074d75df51bd0a5870b34125d3e386d5b8d 4c67e2e95f0bb6f0e214bd7bf052f914d365f129 +5a9353a7576920c090a94ebf978f786d43418c111468ae2a343eb561324dfdf3 3442b9486ece0187998e802a3e98f9c97258133f +5a9391ddc692a70f59eb4640f4f221bbdddcb4dc9ce0e8abcbbfb15ccb9a1513 beaa5abd55600b276ceba3363285fadddb906433 +5afcaa3ebee991ad963e8bc7d3d947da769dea7095973e5e6be1254138855e2b a62239680a8bbdf85cb5602325caa42abd141d66 +5b0f9a00dc1ccc48a7d52f512338cecd3f4f5b9706c227c5f8fd158419862da2 c63cb6a816126549e95c8585a65942981ff4d634 +5b264a6c0568f6e60ca657ca41b3608fca3a6ae87bd77ef9635edc75b5e421ec 6d681ba6396167845281717f4ae90389f884de48 +5b92057969cd5f96af9b9f1504b532bd3fa93b9dcd5d58c4d650c3ff640e54a2 b8d515dc02a663f0d260c69e23c6cc42a363d5d6 +5ba7253f47d390ee2c7c7afe8fd9a963a7a2674bbdadeb9a927665c9246306c4 e04529998989ba8ae3419538dd57969af819b241 +5c05f5112a30ead09ff2ff553056755dbf568c06127dccecdce9e2696fb41398 634a64b10a627e64f1a4370d085eed0be242b6ed +5c14a1005d727dc5ce74effcae1dadc76a77533167c76347e04844c290aa7ad7 4c3bbc923330f9896bf5789864212cec21a8ca0b +5c18ce500d2a3c3085f74b3e68dc4ebe703a6210b3343f50796cc15cb18c7f8e 20e7f426c3d56ba9e4b55f31a61835dd0031b464 +5c3bddffe44de776f2d7715ee97a62b190049e623d3b278ec131336f0a1cdd70 2506dae36e0f9cab6f81fdd825d808a9e4c12dd1 +5c54a41a0ef2f1b7f505d12cc7902120b6ba3ada7e023307792b56537fef2a49 e98f74e52cd1231424378d9d26ea40d1ee4d7fa2 +5c89f33a737d292d062924589b856045d9d24630fd3bd1afe5e65e53166cae89 192678b55c30d0652356a5021b521f8e205f3428 +5c8b348f9e152d98efd79d2990dbe4c702eabb06d4a1427472c1435be0a13cc9 50b20c4bd550428a6f33137bd52db4b69799f1ef +5c8bea399f78d3d6a037a41cee2e763d00024180b66f2ec738d443b6a3dd7081 fd899f45951c15c1c5f7c34b1c864e91bd6556c6 +5ca8959deb2b8327458e0344523eb1ddeeef4bce03e35864640b452f84d26848 8e73b769e97678d684b809b163bebdae2911720f +5cebe9f8fc63534c919bac2f0c8695c707e33647d44792b16e28702d26e0ed4e d25d5d3bce20e400407b010132579541d116a8c2 +5d021306f157c028290dc5eef52bad4a3998b50006fcaf283cad4e6918157c6a 54b9460fee5219cb5a57118bce066697704ef3f8 +5d2460e61d9d5cb4fbdb9a017d4761827f339c067ec209c8c44529a5d9c93239 36f0f61fc8578478a9dc9b33a1a0d07cdb98a5e5 +5d2e103059f5a5629d12e4bbec2e6abd1d89f225dee891dc630f67ac331209cd 96f34447e508c58b5444992d4522d93687c9ddc9 +5d33684397a6875ee09f048a93202b5ddcc468807ff5faa382f9508833af38d8 7ca4ceed50400af7e36b25ff200a7be95f0bc61f +5d4e078cdc4960b27c7a0f8470c9d797ae21983e08efc65d0cf36583737b183d 0129895fa52dfb06cfe4f1f456d57d8e16453686 +5d7a52475763e50597142ac2dc2d1b33d771ab83f3a719fdc0e7b880bce4513a e589dde541c522ea4096a32308ee1db9bad53079 +5d809610df93ede304c638ccebbfb2aea1010020d5a04e25836320a890e40381 b20f1d8a6eba1c138a6a41206ed45ba0dfb7323e +5dbb1fff5c0094b31b25b4635ab9fbee66d65fe5dda47dd0ac5f01dd69a84c6f 43da5ec3274dd061df152ff5e69853d562b01842 +5e0bdcfea7ab39bfe79b8e00a459a68f5b60b2b0e7600bd01c09a526734cc769 399b7d5ee364ac49da9ed64fcbcc4ce2e0badf56 +5e4e3a2f07a2d26f7ac4ae12b4157a7c6201141b08a04a296d5c3d32bfe9d4cf 5720bbffa1377642eccac7fbc34b35a4b44fae4e +5e53b0f3e603756d985e82d66a1186c2467f2c5b027a1f4baae651a5a68d1aa0 c2ef0cadc189a076b8ed0d855da1e58502210507 +5e60eccf824d865dcee2ee9ad6c947207c3649dfc0bef1cb940c6d05168ff55b 627513e78ae0c8dbcdb62e371ea674495c841aca +5e7c2a3395be2546d41331f9e310217396252fbff62f139e41493df6f47a548d f9fce2b42184f2181a5ceff90dab05f7cff12697 +5e92f55d41b34d254a0fc5e5270c7f78ba48d70743484489a2e81e0c9b420527 52f2390b4308fe51ecceecbc35a87bf6e74e9aa8 +5ecf05b5a0c0b45065f977149190b13ac8bcb18342c35cca02ad93a3e7236ee4 5213c69284b521c5a60ff677baadd36c97a5b333 +5f191eb81f39438560c516e2f091de40fe3b7e090b89b854d013caf446b0aa8e 51fcd3cac86ed8f6ec215146b79b0989d407ec48 +5f45642bfa66a6eabdfed22c7dc5fc170dbd9a4d93fad22e402b38cbbcc28444 bd0d32c74ae66ddafc9c875b391717e1bdfd6f8c +5f45a18f90f2934e7c7985d05b2b5b3584886fd057c9202f26f562d6c3080038 112998d425717bb922ce74e8f6f0f831d8dc4510 +5f53944c9390e883fcd33819062a750cbbc9b483c15b554eedd351696583d215 f85c76fe4882c7a4befdea9224fa8c01574fdfce +5f5f4cc82137a85080f6995d5fa9ed50980e07b0d68bf96c0d8c9834f8d4ae64 66a4bfac99c07b79d75c015aed8f5972f0a4a336 +5f877d011f066c0131dd3a53b96dd2f776651a96c610e7194fbc07de06d9e851 56846420552d85e7d5e8a19109594ce4e9792b7d +5f884e140db9164254a551fec3b2da3596f9404b80a9e322ea01ae3a46f45247 6c1a2d8c39d1becfee3cbc738c9a126a29f98c92 +5fd43a5fd154026f2952c2974e251c98989a7350228cf84f27c58f0925eccc50 fa33b5202315671c762ee1612d5d153c55f728ed +5fde3c5b024dee434df0642b1f2068bd65894a9fbc346e15d7bb75608f948ebf 32e41390c34dbd3f59c8cd78aa18adcc45bf57f9 +6004573477242428d7b6ee1f642da73ddc68de2218e36b8b037b068bc3de006b 0d65e1969a5c01a5ec64b6950f17f132bac18a2e +60087c8cdabb0c7a8fc1cb6134747d82f02a2a920d4c2eb7dd783e7ab1f37850 b3715dc1acad54598fea69d118c992fff7ea4ee6 +60b2cd28c2b0b58ab103d838cf2ef4522a1c42490cb93e425df77f39d7105e03 458c271d8dc57f36e3c6824d54a7a4462bd3866d +60c64d140395cf067197db3df59b33830a8ca7410c0732a1c1643dfbab2ed069 2ce6f8018fbaf125ed50e66adc46ff4f9d0a9288 +61068c6c7b2f2254e55c83317eadfd4ae210a6dd362dfdf4925e1ca20c345d17 b231ef3acdcf396dba5f83f89488be7519da551a +610894ea28aa99982aba7156a1a6ee0d18652d43f7ed7b2dfd89fe1252b9e645 93d96a8a0e09ccd1526ae4e769b5d41c239db3fb +6111c38997cbd2dffd851ad4d840c9dc45bf992d342b827bab5114ff519ab57b 1a2e9c0f19f0143c69fa2c4d5d95da3d5ccf1357 +6129f1672465ee7b9e2edef53fbf3846ab5d06e8e6a1d7fb51e31666a8b411f8 b0941f9c70ffe67f0387a827b338e64ecf3190f0 +613faf6e366095154ba6b9cefa47d7c3a664401174497daeba14a13c3e444fc7 77e9dca7958f1ef5a01dd17de6e5fd1175a13ec6 +61489e9e831f1d9001084d39b79f964c293db8620d679ea3596673c8a326446e 1810dff58d8a660512d4832e740f692884338ccd +6152d01aacb9fd63bdb908a5153ec9319bc837b50a22322aed77ac01764364c2 32d6b9111a767ee0a7500f132f797280dd042367 +617e5bac096ddc00f0c17e6dcd6a084cd21ae6d4ef7369ba888060f3c7e0a988 2917c22c87060a43fedc431c0a125cb15c1e3bc2 +61894490bc16340ae5eabaddab9816b93d2231629f5c5709f0c09d4c9dccee4c c985f0cf48b852798f4c5752da322a34f6d386c0 +619f24a7f37f8ca922c83b3a1b9a384eb6a444ff3a2a52c712f3c60dde6f24fb af55d0cdeb280af2db8697e5afa506e081012719 +61d09b305f785a367a8e1cb85347dc38d4ae9de484dd3f2a5bffcb1af3b2417a 803a6b4d418c4b2d7463bf23a86a09cb2359ec98 +61decb10e8bcf036b7b0668b5f1e158381a26ad14f4420bff686801f9824aee4 1f8435d47ad5fcd9e92a80d1cb2b8836fb711366 +6257fc48e458a95396b6781a738dbae7866999cddfccef63eb16f0919bc2cb82 4d25aed8f9ae7653206031efdb0b682d62ece767 +627d6943fa03029b8c4d730ab2acd266509261d14042b1445c477505b29fee21 3ae3c85110b04ee92aa528c3da0956391e038cf7 +629e9c4fa5465689d98c29fe048a1aa7f52da0235c5d67842322cf5d183e1175 b72ca26740c71371258bd178188a3d981e39701e +62b1222084376703ecc7737181def068375c47640206721dc4674491b8980a5f cd874895197adf33e41cb14cc4b5fa2fe7ff758f +62b4aed734e93df5fa848ee90fcc38fa472e13581d05fa42f11f6aa8a388da89 4a143abf80a82b6e51a3a32e0be40b4e559f6a17 +62cc32311fb4f113536d2004edf25611cacaf657bc1f59552032c7cae29cfd6c 65912dec2c33ed1cbae320dfe24f868e10f30ee1 +62f462260b2bf90079c917b3ad2cbe8eb2c8bc136512961c839ac53845f7bdce 784b10b4b075a60fa18c703b88a744a30fa7eb3b +63071afc7376250fef5787562b2463404ff4002698f92a61a774bda0a21a6ff8 22b3e83e3cdca53a20808202a795c73fb47880d9 +631b70c3c1335f8aec14d98eea4a36890c3a00bb2367761e8f7d1e209baf74d4 1b858839e1f08792f2e5e1165bb4fcffcc95fa86 +63fee1d7ec8c84e8854fe394dcd134a633d8f3de7c6a5749b7c12cb26b8912cc 99228417f71549fc6392a359d59d33050c055733 +6408a234856eb88bf60ecf977da417e65d38cca482547247a143aff624e66872 7ce66fdc1f7778999b3b3b87608771eb2f5c124e +643cb3995f617257573a639e4b8639b46bd96335f61bf6d98ee3706397c75544 47ee6e20700957518dc21886f769ef415a592568 +646b7e4bee30efd073aa27ddca866ae7ff72bb284b035acf721306ac5dab00c0 56f77b95f87e01b56f732417c1d557f0b6dc0be9 +64887aae9bb21a35ea8a484354297a8a079b3bc20d11d253b71afc1ec36b1f74 0269c3f82d4a93b859ff58582b7c6f1843dbbbcc +64dab4ad3eb854bcf575c7d9c9e9673021ba74203147d130a209ec2f04a98715 850cf44e8347194a57fd1fb637f0a12f1838ad38 +64f0605de2dcad18e95b1cbf6cbb85064f916406f63e8f76c9c223a4e59d1e55 eee3d3f684fda02fc8614dc4ea5c399ee71e7e4f +650f6cd874aaa3fcfbfdaf49d6683dd6a3e9e3e45d21987dcd6d67d11bd12632 7cd60e59edbd298d5e2790e2e62aa5c4dd55e8a7 +652412419a24ba62a1d897f40aeb80eecbf873797b04a1bbb8d71918653ef65b 6dcf9bf7541ee10456529833502442f385010c3d +653aedbf79f7c6e9377832bb81f3d408988d1ef51e130b08c29217a9a53daeec 4a59d93f4f618c2b2ede1b21c807cab24453056f +656dac701c40a400c97a4d145190117d6f226b41ac39801032b5ce2f8a67881d db31e1df61d8586c1992036ce4585a69fa82076c +659c01981f8ecb286bf26d7759cdf0e59f3250dbad69c5d74e38c5ca5c8ebd36 c1052be270f379ac8e245838c8362f89528c8e34 +65caa3413382890c53fa78aec55069027f1918985bf6e62c97716cb846b74f0f 0b59a10d29ac9446320f6b9424e427ca7548af77 +65e0543438a38463238bf25be5064d5e6a9a9b80f0d67c3babe8bac7a3f9b269 edf57b4b98fe7845c0f37b6d261f15eaa6a27556 +662c71991cb89a89f8b0d3479839daa1c3837455808983dcaa3c89131757d4dd 408de023c9bae4e7cbfdbf7ea65f0e41012f5a4c +663848827efd772f21ab7953f2c3edfcca12400bccf92de5616e9ef57aa09897 7ab2d5413945768710d357e69ebe6ea89d0e0f75 +663ba0d9c53f18f52af699fcc1f7e1600098961324a48f3e264b98718e189498 c9c7b0e147c44682c9d4a100dce290c14762ff85 +6675306226a1869a0e696a57ae9f8172511d961199a2ec17ae6827e39e4304c3 52e47ee702754a385a930079d5e127486e52bf68 +66a993bb9ea76040f448de0e3bd65d1f9d88dd5192921cbf12f234c813466452 75e1e84d121120833cdaefc7e764878b7cd7d602 +66c5b943797fa9a7bfe9194d4f1550a9c4ad05d69c6d1a1be4e97932cf06a813 4c9a39732942f763191d47be51b414bbc81bbbfd +66f3606b5eb16bb5a34fcea47edad9a68a54c2804c09da37afbed6bf512d5221 ac8237e18da19ff375f051a973bac91d6dbb2f56 +66f736d33cf07582c5d6366a9a1bc39d39937714e729dba38a7b61faf2b156b8 67b430937482d4d1d877ed3bc4a6ee743028c3ff +66fe8385c6378bfa5ca5573bd0fdd773e4eadb0e86416b483f2c50c839859ecb 41bc8c69075bbdb46c5c6f0566cc8cc5b46e8bd9 +670332674a169ca0bb0f1d14bda945c03bd6687b756b4a54bd8da9208403fd07 5e9e1f22cc64d3a31b37e3d0c865228a71c4415f +6705ab009e12496e243d5fae60f7ce6c77fe68325a8818ec75ff317ae80c5e78 eba91472284330a048142950c1de90afbbbe2c0a +6727e691fc664f1f28bb23cc30d6b84c34382029e56edb264b2498117398f8fa eaa63e1496702ae9c36436969edddcf7e9817545 +673e079162dc9e99a8bc43698e05492357041a3a661b104d1d40fb37e89cf965 dab2ff4ba3ebf8cb58f5b52975a58c308b2ed283 +678d331b936a897f3ada21a29b403968b075611588c9b176abf5a05d415e275e c8d42b9bd1b6e45f48feadb5b02e152c5e5f1f62 +683b60d7962844415b532765aa212699c5414b0833974f292c233c6c8c380dda f2b93d4124d2a46ec7070cf6a40a3863e2c15556 +684b9226d707a7b783f0705986600b2c9c7decfbc9cc72938cedd113a8f0dc83 7e44c57fbdc0eefa79348d25870369b2f4b43ed0 +68a467e533bb9e4b2c5ad712d0f8d1b484bab740dd667814f1c9cac3a4a30fc8 19af3949ca8ce2831049a4755bce3091d7f4bceb +69136323b1d7ba81e8cad8626dd83cba0c41f780caa43421f0e5f2462d78acf6 cb3ab00e68da089aecd496ba4e39b1c706ed7c68 +695bdb545f636d454b4825effd29db96c46d81772dda6c104f97dffe2ec509f1 4e8cda27ddc8be7db875ceb0f360c37734724c6d +696503760a18787240ba52ad1abec3be6517bb802238e9469b3a8999cbd6432c c07204a1897aeeaa3c248d29dbfa9b033baf9755 +69c1a2bb3151164052ca0435160424d460eb6268858cbd027cc551a174a52785 5fdc7166eac68b0b0923439b8685a29ff4c2be27 +6a23c1c1d0570cfa36151e678751e16ae587b0a8c262efd011a4716555b345e2 4d503f884a241c507ec4e474e3e3463c2e394d52 +6a28b5afbed89366932ea57b68cdc739f347d242f0d6e6a0f8e9a794205a5213 11fd982b055012bc932fe17b6187629555000b76 +6a3ddbe9560f1509d2a15cf4f580ece49e83b83f9baecbc0f5ea512ee93e63aa e35ef00595a0767f16bbae5182f7dd1c07138834 +6a44891d48bbbe85ec77c332a4d809ed1d7bdd39be781785d7e8b4b31a97f586 963f3cc863ffc5d238de5ac3f425df6ef1e3e3ea +6a4f8e777996a56c3d69559f2006bc0f0a990130aee3d2b29aa29fb3cf7fc437 1b1e2deb5f90be7f267af8d3d335bb47d648944e +6a5f397f63599bff44400a30cf482d44d5b76808fd9b24c043e8da3909b7971d 85a843cc1363932d8cd5d1e88024b9357f0d5572 +6a837864fb44516a249c5df72b8674fb3f16107af84e2f38c9c4f2ae7bf8676a 357bf823711de56d93f51d9f4618ec2068d2244f +6aaf452708cf86455c8ebef269c0cbcbf873993e9cf003e3eaae8569eb997da8 a1a73455eb3d2a9571208c4d4af74f4ec1b1d161 +6aee1b075ec6d9f63ec6ff0689e80f4df81dbd2c0c2bb17a8627d7f0602345fd ec6a1926d4465e61364a7a8450e8f4c86ed841f0 +6c04b20ecceba56f5ef3dff0d5b93a551d0c6b56311599a3633ef16c3f2604aa 0051f09759ad432aefbacba58fd306dba4a13f79 +6c14ae62c1369df64a8feb0dc01acc99445e13708726f5687343ca15185a3e9c 86dcfa927930bc90239e647cfaad5c7706b9f609 +6c18ed11d243aac62a14a6863430458296354e445f0ac7927d5231161ad90033 c945829d434378a0bd235640ce08144ec35a8cb3 +6c3b3ad04c2ed7bb11f59cc76d0a980cc087bc6b0b27d96d395af4ead3950200 e272b10388ebc4b7ed9fe2b42dd46e367193c218 +6ca4b09e9c92f8cfcddf218cfb39cd76062c88e0ddb2fa387bce031b902247cc 0a902f96c80acaf50a534832e1892cdc99ac6d31 +6cc829640a9596f33442bdd65ce68aa387caa63b8b0ca914a3af4b8143ead15e 8a6be5524f20162044c8e48a530abdabefefc083 +6d0df366aa3aa46ebc26fd4099838660b562e9d140ced9631fc091bdd5f72b32 3ba86b2be1383df8e6ac574538dba7d1d5d0120f +6d159afbb9fc4660e17efcb7a3a0e1944cfec34d8f8b7d1794faa8507e5d42d0 19190397b94cd8b56e6cecbcbb4ed24c3d454d77 +6d16425f59d59f573f029a4128206020fb89e849280d0ef894b8cbfe38803af6 c994bb473428299c9d568c99805ff1b49949aef2 +6d429bf11e88cdcde78b43bd5227e273911cfbe30b8f56aa170ea00227811ba9 82b1db3b35e34c87862172bf3f4705c4aca8cc98 +6d47966640b12cf618c9bac61c60c2cc245ec18723ed4056fcb5e771e313b8d5 09cc79a662b98af20006f2601826d8fd6085a37b +6d5fd291bb0f67444e99ab492f1bf1fcdf5dca09dab24cf331e05111b4cfc1a3 fa49b077972391ad58037050f2a75f74e3671e92 +6daeb00c6942fb4696f08232d22ca0dfa56d416450633b39cf491a18c6e2ef76 e8beee4c04ff7775b7180a7675acbe95d5af64f1 +6e22fb1278de7b49fe6b298192ffcbc3a2b1e8abcde77b9cb2ff67f3faacf3ed d9eea640862b43efa179924882eec554fcbce684 +6e490b63a52e4f2327be88b4b91812a05e62cb2500f8dcbaee56563803b47fa3 241514f3af6dd20d6d647db9ed37a6dc21d9532a +6e657f9f175e434bad449932ac6211bbb129f4df1c9502f4ecce7a5cc1fb5fd6 2525ae8a3e074a4c65659ffaad29315fdeffb698 +6e6f43fbb89dcd1526fc897e2a42008f8af30ed890af079de9961befe36ed36b 1699efc4217d925c50abee60d196d9f6e738a72e +6eab2abd4d5c1d1ffe7e473b3c8b2889bc8801457737f43255166f3ade399992 f68f0b1b936c397976127b08400c6e30c07cdfc8 +6ef8ae778c5f998b9beae6b2da18a6ea674b268a249c3b55fec38d1b8cadfaa4 9475785cffaf1ab6216a9a5f1e1b4daeee718657 +6f0055a8c0d2d3b66d21dbc546e605d7097533d949fdd85f08c5874c01ef1723 ce022069960b6347b20ee2f90681ffe7802d953f +6f11d93bfb269ee8c7a506178f60c430abfac5d424acfd9c0b0b27b98e6ab49b aefe66d192771201e369fde830530f4475beec30 +6f26102d332afdc855dd129b9486952f8c6b7c071fd96a6f1f762c95a79a3d67 064301cc3528ec3bccd07dafe9af824d87a50dba +6f3876830557f53900630d24eb67e39e64f116501ee781f18d5d3c1c823f255c eb815f96b04732b893bc17c209665b211e3cab0f +6f6ea36739eba39758b45f4a0b0e7ac3d5c3facb390751101e2a8998c3a6f190 0f39781c25a06c1d38877adef4ff5a6a5f67f1ca +6f7d74e7c76bad67c52697562414ac40cce152a6197b3621342f4009c141ca4e 556c36fd15024aa7e888c3739d74dadedc6ed424 +6fae137ba81d0d81c2a85759b99322e7ea8103bd7c8b85be3163b7e91e18c125 cfe96f31dfad7bab49977aa1df7302f7fafcb025 +702a6340ce839f0cd2601cf6fee0e4bb5b308fc8c0a731aee40d1bd1b0ed5f6d 4498654c7989a59db451179ed264ac43d3b7131f +7030f925768d9beb65654ab8f436e3ca0a82b25eddefd237bf5a26a0441c2aa7 814889a078c031f61ed08ab5fa863aea9314344d +7039e3408aab6a7cd4c16bc8ae9fa81407ac415c427466a602bee592d3ebb243 0238a56890c6185070331056033f4dfe61a275f7 +70bc69623357648bb7ce7526e92d8abea0299a9273b9fd28fe5f9ad55048445c 73dcf2876fecab9adba9ec9bc148ccbab431af12 +70c467f2c60c4c2b12e0a8343c454edcb457bb7daee059b6f7f625db44827ded 12a30e261b490439ded615bddd7d6e3a135fcd13 +70db96a9031877b2d11791f4a75ee2e2db4c6c657c9f1d5e30975e69108ee95d 4078e70ce62371860584b6f42312097b1fae94f8 +70e04bc26c957ee1d57dbd0ff0dc8d8086ebad49e3dd4fbc7b158b544eba4b21 c20cadb993d1ade2db86def0b3e107765d2ab3ee +712b2b96ef712f696523967fc471a5c5d446dbefd9bd46853e6f3030fc4e42df d1ea30c399629de48ac3fe68869a21171ad131eb +7151491618209e86b24c84d0bf4962828c4b1ece1924a44ee1d3cec82d0c7ef1 8b6f008edad28fec6e3732fce75c20b0608e4c46 +715588dc06122ab123e11c9590ef6fadb817b103da857e89d619f98381e194fb 33458aee86009abe87f4f182120e0a01dd828ed1 +715ac0c5f0e08622ce2dba0358e6180103dc26aaad65f463fe319ea28227c991 7ce510638eb4f25e6d74a788e941e27557831291 +716e598151cf540036a73177dbf04dff847cc5f0123027bad6111a2b747d6403 4b44ce23b4357ded8bdbdac545ef49a39d5bd6ea +71fb49e1a6feda729eacebd50518cd5e0dac988101fff035bd27e66a2d1c020b 54b5223aaa8e0c973ad508f4741e2a96961c0f3f +727a5310c154efc27b636efe2503aa36928392b543a121fd4c67e991e53be3e7 efdf2bd1d646b85961828b897633374b09249fcd +72b2b1341efde56221a00b934ea70e0e0bac428cf3853f7f0432371cfb2694be 744e1c78fbfc9438ed8c947aa87beb000fe4bab9 +72c472319cf7d5d59bf9fea9e90b9785d7ab39340003fbc68619c11a9e583c2f 2f205b20fc16423c42b3ba51b2ea78d7b9ff3578 +72e5af4874e5dfd926179a7df9b22f5c784d0953c08f52f57b74ea4c429bcdad 3e337843bf57f0fd5b29d56e8678d23bedb78b49 +7348a064c19fb5f536cf9df91b0241da4dc493b2e4eac9b886b7de3f96b0c414 ca4bb51f66396b06853c444a1f3d259267a7bafa +7350dbb12c8f696a5c1f758da310e02cbca318c96c7854e13ed9383a313c4a09 3c6a4c09f57517d0670e5e1d78587c643afb7d80 +737b6922276ec4b8ff150f102403c48c4ec60e6b3d4ff6904261bbe2ba2d61d0 552e23ba566d975b4dd48163b91021892504f021 +738ff86401dbc5af692c83e660a4d510603c3f36e782a1a32ebd0388db6411ed fd4959ce7510db09d4d8217fa2d1780413e05a09 +73a5d42076f213bc0ec6816f8a51e3786d5fb0eedb6d672b9793d582eec8477f a7c60cfc6d3af29669ef5cba9df325719b9f30cf +73b4f3c4f3182e6c8dd2c98aeb2c7811556538e7673e4b325307c71685fbf5b6 fd093bff70906175335656e6ce6ae05783708765 +73de6bd126ba92253a3968a1081da3bb585f9010339fa8b9c02ab1c37f253bcb 6522d02a70408e526425ca1579215bcb6bc505a7 +73e67e592fa176648ad7fe7a65c8e3e782902ed1e6a2a03b2fdda1ce0648d705 0db888dbd4366d6fb2e5871a6bba39530e3bca70 +740441a445c2ab20d2ba91f9237116e39c25aacb7527bff9252a15a376ccf1cc ebd94df2050b09575346ce82a94079dba504f057 +7436189d4ef74b65e205d88fbe33f8b130e907b7951f03e12366ed6124342aab 88c3c7230f3d49807323df8f01546b8a7fdce9fc +7453e1303e8cc0bc8fa0debfa7545e7f6b8b0036ffaf950c1d86f86710ca3bcc 562c86cad456bc709af6982e24256844661fa5c1 +74a75a34793adfc5dc91b0997b113e820f1a08ce3f2582580b21a63a22db2dce 977c1793305b307275e2a12335b22346efb342af +74b69ca7e493351440a95d92487789420cadf3ced93cc3c4f9451e4483d7a1b4 1c2df27a59b90ce934bee51a95ba617efce1c77a +74e28415489b8056cb9537fc207015aea0e828fafaacc5bccdc93b2f1609e479 be01c47996d638f76c9149a90a25939f624b6cb9 +7509f5f98d13f7a093342e712ea0876cf17e747f8e2d04738d8592401da74586 32a550a0213bc2254d0e46285d7df4e154573009 +753ddabab8ae9c1e733cda15e8e3c83dd43f5a2d939ae32cc3b30b0be1e91f96 4d8d0fd9cb6045075385701c3f933ec13345e9c4 +755b0be6d86fcd39eb376f2324bc61103ad7268463b6eef46314e079a4d2c34b db31c0661cd0bb4fc5104aa0f27b1986ffbf9214 +757f587c2ab935eefe8ac8e05e3ca862e9bb838cd525a6c4402839f532713b5e 360b107978af0651ca59f07430fd71ed52150e4a +75b0ed5f4a2d5c810f34d867dbca51db6a596d4739abfaf24fcc0f05d99097a8 10b759e734e8299aa0dca08be935d95d886127b6 +75d6f2e4eba19cf2adaab6f58e16c9e3eecce4909efc53d6690f865a4f89b53a ce524c6b3a984455f474968d01ef86156e92db15 +7609c608c1097270356a6fe336a8756ff124d4a9c2e941bba26a6e8c3becdeb1 2ef4e5d838b6507bd61d457cf6466662b791c5c0 +762099bfceec4cf75e4f0cf913c7ac6a0ba6754249fb45579f7d820466045d26 933888647a5d500b90c472b5c99fadd6b8691c86 +7655c1e83698d9a5d2fa841438e1a0ec815d7daddbc7a21a7e930587c880a2e2 0817229bc1a1fd88bfdf4f35e2ca11172054756e +7671193d6cd77b8b81681438be0bf15db49ef9b60f5389ee74b907d7254f403a 5069c192113c59f791d5f566c0a57f6714bb856a +76c1bc10fdf66c17d7f9c02a12c80cda9d1f14fcf9a467e85160993f807abfa5 7cc26c12adbe5ab35986e2e57a572145c86bbc05 +76d5d21efad0c83f17a63c2a68ebd39136b56fc25f97e0697ccc6c73973c9753 81aba2b4fc907644c29735ebcceffa4ce01dd23a +774fc4ddd5efeac3ba9d525a968612df8097a9c903ba0b5b33625ca86eece2b0 9a4973ba6bf406aafc48b98677422fe6e54cf764 +775a1415621a751174ecc0bd86be251ae64c305f39c0b6423f8bb5a2c4cace70 60811b0baebdec5b8663134d8b754b912039b6c4 +7771d48bc8502e2b23c5f87c5f82b446f90060d54a8094d4dd829da9cb5d716e b3178627077e4c6b240ed61c4e9a3f80e42d6c21 +778c14d7c53286273b58bbaf5f42aa7ce8bff5c63737cb1b5d3dd99fe43fa32a 46a29b40df56c1885fcc16a59a95bf319048fcdf +77b15f8f906ba92609d8e70d038973964661a30ae5a1b9ab52f96dee694459b1 0ba17ded678e92f9150df14c2e9a310ff5a79baa +78247330cfbfe12044d4a85428ab774b9a88413b618ed91d812cbdb1694be9eb 7e7c39379436c6c048670386fd4d470444232e30 +784989941709ad0a0f4a6e7c9065f081561dd146e7c84a535a38b8c2b89389e0 84b9cec72cc98dea3353325e42ef78b3f7e7c79e +78568215f27ed3fe1e34ab5c944349511304e3f2b9721610599b3fe24ef90f60 42c07750c431b6bd77c6a9e1ff4997285932e352 +786ea2ae3bc3abb0f17a985bd588c7e95934a332b0ff095ded0e2192e29d42c1 938317c9319e3280b38d705ad1cf74830cb39eff +78ec10765ac8bd54fb141ff1601aa5fce9abe86141d2b5457c0a3dcad48dbc61 166bd0fc25eac4f184a3185eb5994988cfd6c201 +790bf70318c215c3fd3d8bbf2c6aa799f7a9407409aaa79a6f286940dff143fb c96d985df9957e7c042290d868d44feed8a4fc08 +790f39b54161d26f82f98c7ebf3620b0fb7763fce49a5d2d1f6213671c2b1bae 8be50a412d448035b974312389e9a6703e71e8cb +79239b015d62fe6c9c543e6f394372f63ac181b2219bf7eb451d397836377890 d48d51dea1dd8e90bb8c960e68afe72cabc5f6aa +7941b4226958aa66c7f44e76550ed49408f8665dd32d823fc6c59eaa16ab8f02 6e2b3105c1c5fa82ae4e33a8c24d50d69c50782c +795db8a78b6836d82b72af2904b6df4587356b800c06e74159d39b83f2ca76db ebe2b33d7c2366205d44620e57da3b0afde2524f +7989c0a71ef11028135720da34e14d29e795c8e78e450cd85a49d0bc7913a8b1 1a7bae4d0f9d9314b905109b5b321219b7e6be3b +79bc735b91f8dfa9379d1d6c21e2d519ac1bf0d04d48534864c9ff571df5297d e0637ddfbea67c8d7f557c709e095af8906e9176 +7a07cb0fae32a92c8faaa8f6aebee30b9e10b25e1d4f49726d28f223f4bd5255 c34eacedfaf132a6f506d2125588a9094eb82812 +7a135043f1708123027e529d2fc8102581d11dcc2dc51e32913014ead7132ddb 065d464e42f271efe08daf3f5b69dbe266266880 +7a1ae05e508530aed4f9bed33082bd4191feb167f2d351fa27180970fa375b09 b3be0fc7562d51df415c14abf671deb37d8f89ef +7a1d4d9971f84fc5afe7f66d5925e78e67a8ea58e5569a519c40f671f44d0b8f fc3ab91bb4df267ae9de1f7b4ab596406485cffe +7a5d59089d4a3dc1b9df7f4259be2ec0cf9f9819397b775d53a6592d62c471ff 4c65453197fd21460f0ddf2b722ec2fed6af221f +7a7d3b7a1c17103608948e990a24f4a67f6728b7c8a5dbb3f369e55972a55d4c 73c4dd9253f8d43c436fc88e64096910f4f1b8ee +7a907433347ef815623322907d4cc216939ba2c065306fa81b2fbbd49ac42789 4852017de90aab7f3f2af89ce8ce29fe8226af34 +7ac8c1830b6a44dfa1a41203f9368e79de094e5b62134bc3783069ca70080cd8 0acd9f8ba026c0e6845ca4cdb920cd27503752dc +7b0d0dfa23c212f76f2317ba39d30710ab0014c9ac4bad0f5ae54ece22cba249 04dfbd14950661cefcaae35a7ee273c8775d1bf2 +7b5110bda6ac70764dc1801b16e91b662364cbeb80884b3f6a0ab3e4c4028ba7 f7c4cf4a40255c3b0ca8d8981121e329478a92dd +7b5359b4e59ca2f60b3c528c5effabb858b81b1a9b5cbdbf70977379230f8f5e 2da4231d050f9761ba615b77fae3ad00a7d479a3 +7b761468247f90725be8d05d9744bea962f660617685c76bf7b2c58fb125dfd2 b55dd77ea78ddd49d9ee082e2785b3c1ad9de7d5 +7b9d5e67db60bd61f55eeed5ba200583330d36ff4ecb53a6c341c2a6eb3f681a 4063e6c4aa51155f18adbc2bcda3d0ee63880c2e +7b9d61429850c13d9e3f280d37d51b2e0e3873495d610f371ab45807cf0b3bd3 e8a952561c4e59ca308d1973de46fc32ad91a022 +7bcb94b54e168e6e26a3cb840139c11c0ae7634203e8a614c3caf1eafcef5fcd 792a1db7cf2e1cdddaee0446a8cab4bf0bf2f6fb +7bddd447d756b99d30b72a45986b2324e161a728cd3af6d44a089656395b60d0 d23f6863f89e23c82bf14b91de931cb446294af6 +7c0d59b28a150c519159ac4562b1a4dbc1348bc3caedf70af29584fe226988fc 431007a7fb7a938d3061cfbbb438ddc42ae95c8d +7c2ef1ea335fde84cc76d1a10e4d4012c1f5238e170499606509ad3c4530ab39 ae23486285f4e16896afd53b20dd11180d26381a +7c41edf4209d1b0b0e793a714e78107e7322d7f473fcef602d52aa5664bb5735 367ab010d69ec4fff533c770eba5b1882f79cb41 +7c50daf12d9002ad995f31e02d6dbf7851a586bba49118d87f69fa8ee71ff890 9e90ed0d151be3fe089cbabe216980e2f00ab242 +7c73285498380b4af00105c8d1f887472d50fe26cfd3acc2dab9725a716f3efa 6d091399f96a97ba9bf5f3d82b43179c82a93312 +7c79b5d0b74a35d095bd72c42c8855851df2a6f2b07e926259a819306ed7a657 a1a5bf7f5e8c069ac59fab62d2f7a9aedf198413 +7ca86b4b5f7fa4d66a6dd5715334af377f3627977caa9d68a3472a6e7c3433bc f971ce419affdcf8545527ed3e55e6310ab8731f +7d31d02993384dd0237937ba6ca89cc504fff2d366aba10bb81110a82f4de656 2cb057eeac11a10cd4864a66d8cf4b5210bbe308 +7d3909567be3abdfc8a087e14457d7238887602385f1700ef81ad5d65f47d130 47fd30c3508b95c97bc9177a59fd0e2d0a034277 +7d3b8d28c951267a7fa4c1c75dc171d8f0bb826b9b919bfbad2aa6d181a53a52 ac3e84651504dfc63c144d35e6802a111fc7d75e +7d41257ee4425e8a204c6d6a4ab54f46f3a370a01dcb5d5abcf54060f411c944 ab9e1881cb3b612e775f1ba27f22dad911fd0cc5 +7d991a5ee9468d8278d9d790567db72ca7c907b7397136758e18c267e39ead17 caa749d19261a3d284833bad6d8344bf33ba6e7a +7da15ff8e29e2eac38e6f4fac5611f4c4a396ac483e0be7cae06c9186d2808b7 f5e3dd78875f51a20d22e4bbe3adbbaa20974387 +7da21d9aac71e4797714dcc6ca3350b265f7e144e43715e9f39a401c4bc96816 767f20ca88fcb1617bedd49d413884875befc79b +7e4633ae1b0e83503dbea4417f9d5ccaf22b877c5a4522b6d1d2b16090ee2f6f 8496071c1b46c854b31185ea97743be6a8774479 +7e6e4b147775fef8d337da248ecaedb10ed1f00cd308c85cd142055b5ed414e6 78abdb650f92cb34a78cd9ff17a013f383dac0f9 +7e9424c06052ca33bfc599bccadee60065d8664a9af7648a1455100c4f772e1c 258f0e2a959a364e40ed6603d5d44fbb24765b10 +7e9a1ff18073a5033098583da250301e2f813fb87a718e66b6c21e6b9d78b8c1 960678d19dd854cb3d5f1d234959a680bb8656ed +7f14ad6df05c4b6444d964a5b963c3c753e8ea8a6d4b2f51819a90b841f788cc 7dd8a9f71052cc12f8dd9c1eec2e99afbf08df76 +7f1c021c028dbba42ebf0688415150e8d9eebb1470b5b23ad41f9b4bc5149406 6267cbc52698d2158581d2d63a4667ada2d1df22 +7f1ff49eb6a35b7a50e8e1054e0690127b6fcb866cc2c32283a0b595c39a3a42 0e6e7fdcbf9cf558f09a1e2b1d9ae76b4209ccf0 +7f2d965918db64ad856f1b565281d55dc401d04493a57079b85724ebf834b6a7 b51eb250ed0cbda59d3108d04569fab9413909fd +7f2f7afccb317bb3fdd28555f126846dc4eebe5d9ae7b8d8a1456e8ff85422ce d76d8a6390d1cf32138d98a91b1eb7e0275a12f5 +7fa1afc6ba5045aa7a04b5c88edb03a13ad98702fe1a98f7effaf0a128a83ec9 8669fbeeb6d19f564281bd064a21a31206bd18d2 +7fc47fb594ba964d7397406b5a2ea930a40e870652c0ce3a30c16797d537bb79 eb9264e3ac14439f2036d9e47d31f6f94f073187 +807dc79b9af571de3b9c82133b77e38f81eb8ebc766bcaf2b2b2c7fd58feee7e d9903730e055e85e16e62356b11ba755093e72b0 +807faa3586b7f1aff2797a7c39c135b0196647c9ae7ee8843322accc960b2f22 6faad60901e36538634f0d8b8ff3f21f83503c71 +8091b686de8bf697ef632dda9b3179f2419717275e3bfd2055b303489dbbfa47 1b8cbad43e867676df601306689fe7c3def5e689 +80c5983f528a83fb288b30f073e52614f1530e85904c71974a5343fc4b16a40a 8030223178f0bc0ba83a453e0b7d1585de4adc9d +80ec1e36b983e68664e8357c538cd35b30638bb0cb99626f906d145e2d2e2558 fc3c3a2083e9f6f89e6bd53e9420e70d1e357c9b +80f961fefc9978d410b73aecb091bc67e255e94f7e7c601f8a6addad6866b290 13de54b9267a98310d25bc6cb06caf569b2bc26d +80fe2c1b41caeccb5aef5b42580afcb065b928c4f95a1094d46b9ca1e3702428 f3d6802e942425bc120b6971e3bd8545059eb063 +81274306bb28af9ffe7c212be4e48209b9e13f2c82ab3821bd402b175a10851a 72b9511ad87afa7591ea80101da12f8c17bef161 +812be9eef0a2edf14229e1d392ca8d4957eaa2e45c8d3949b90dc3aea7950648 0fcfda73c48cc5cbdc6b0a328b9fdd7f2ed43837 +814681285f754a19aa21096d18507b24910a4eccca24cfc30918e830f6de83f6 83131fe4c37bbc26706764ee63732315906beb89 +8155958bbda08eed88c8ac908dc44452ed38911cffa54ccc06076f30a1ffb1bf f60079018b664e4e79329a7ef9559c8d9e0378d1 +81a810b2374dd6ddede7ca2b3daf3cf470b54b7e9290d280c6d7e4e92f076247 3e9360aff20efa836e3592d1c017edaf881b936d +81b4939f4b31e1107a389c4964f1a987098da179f9c574cf7e5449a4e50f537c d3231f4399eb8a1887fb901798d5ba4abc02df4d +81ba4e67aa59ccb078e3dc9ff3075f50084ec1696bd867e8e4284fcfc34fe3cf 2ef4faa0f82efa00eeac6cae9e8b2abccc8566ee +81c13819eb19176803f7052925538cd08f8d0e3036dcb6caba2e27f862dabe9d 0c68adb5d31b9605bd13b92ac56a3ca6c76e8ee7 +822761cc7e699abcf0acadbf1c7717045de822f5373bb9bcec7c56cfe35e2c60 b9de2100b3991e6ed3252d4b240eb84b87e0aa0a +82462a4bf3fd4d0de14197547370d4708ffeb5c3bd75236ef485d67fcf04ef6a f34fd002b826e94e60ed67347ffbedd93793fb0c +8259bf4baab8beb19e2e194f36fb573863dab4cf1898f9c3be52efb0620137fd b433410c8d0c3f8345621e9b7f1603656972c5cc +825ca0a496df92f4a70387d4e605a509d083b4f990830ababe6062e70592373d 68b3dbceec6248d67e7bd8b3065fd8d5ff417c22 +826057e0780d68f304f3a202e8444b7283d92c1394c75866249e67f312fbe4ef 0a6dcaf4b0c72cb913e860eb634535704233ba66 +8265075eadf051a5d5ba5eb3d620ad0a859693239c82128869450a057638ae9e 49306beee0b66c81741bee1e004706b7e5c9921b +827595cea6baed7b3a76e99c658c2efe68f41efd0b9c71e76c39849e0f11f4c4 06d6e03af9a9bcfd3c97687f1afde4516bdeec57 +827fdde8c1c0714a38efeaa0325f252745eedaaa32837a45bf68e0d58354571c 195d1f67da1749b0a8d39adc087c5cc196238b59 +829deacf4c5316eb399ee7ed590a2d51192977c8ff901b8143384dc649be1e22 56931d1ab4de660b27c56ce488245e78f8c713c3 +833ecfb032c26b1a04cd46875e99367a6162e1720c81ee410ce504d7f6aa7eed 255a0dabb28beb56096af18dc20187deca4a545c +835a70ea81f05845bae544217f94ccb867c80850d363f7a237df4e3242bc96c9 4a65039859952e2ffe776d2e1afbe0c7ea02d14c +836c31befd72ff44f39e142cad83023dfcd5d58816cee2aca9740b4566150c46 ca52813342a2d2cc406c3173f6b6d65a752fb783 +838057f426dadbb890b29a79f70d68f566b8c1d19d1d954036e0d95a681d2a28 8c57e3ed53bfd1cb5f5d907a171a86140be37e06 +83b17ae4b422cbf5002107b436fb2e5ca0fa6c3d0ec1838ddeca4362bec37624 25263fda46ebc849617f65306ce5c626f5575340 +83b6edb74bd99f1b5042e0ecc2403959f19e61674663c245e76084ace8db9a9b 640fbbfd48119f1c4217e81c644b28e31362e269 +83b9e2440ea84e5e467bcf921ebd6fda90c09a1d781e8976b1550e3b0302969a 0dac883d02d2cd142a85f44f642afad79853e982 +84005e38a65f4115d5c94790010dc57e1a3297f4aa89744f5927f208af758bd0 10aa3fa72afab7ee31e116ae06442fe0f7b79df2 +84503271d3c088446000ba59060bdd4ac4119f6a7cc021cbaae918e86f220c17 9979e66b2e87b085ea23db0b4839b52e09639d55 +848b4725950462479038f34889436ddad0d3842332417707821571cb0627a31b 760529d873e72200ecd6cf05179fa0573ce77fe1 +848e2e89858bf76ddc3208ce52d8a6633d0b9c86e74b9d447fa0aff3911666d0 5a6fa6e57189ab9577c62bcb4fefa2b80cc16730 +84cfd6056673cb703ce9fc11316be0f4e9bd58b0c69af563ec8fd8b36a105847 37e46f4918c08ff7af7145dc364481a316b34c44 +850a21529a706f522be5a979f4b2dc685755658d9bb42c9c929673a99cbb09ca 6baba0d067c8ce4f23a148cb1b7a256e6fbd76b3 +85513265e2670ddd1ee23214af654254e62ac330883340cc73f1329014e53c48 b7c891c629d298f2d82310d8ced2ee2e48084213 +8553f7236da96bd44bc84c4281b4b3c059510a908ea6a4bdb06ee01bfe39a4c4 d7f80d5fb81b7f1ca8443a2298bdc07eb3a144d6 +8559f031d21ea80c51c33842e3df2b69a4eadd01786fbb119b321d457b40fb6d 4e7596567f9f86fead9cd398d3e3b056a2867fdb +855d77c6095e55b8d217076bf2f6bdaaf5852cc4b7c189660454cb311c6e3be3 f101cec32d82654159d264d177ed9ae0de42b6d7 +85b09a51ca2cbbbb68cffe492c905d4b20e8c3a4f988f5baf7f5032e2683e84a b3039beea6d0637e131b24e8b6d61005cc1f6515 +85c1508d2b524c0ca3001873e6f0f8d2f291be2dad43d12375faf37ce19f72e8 de2220a48fcf7901432f8093d3223e65f4072ff7 +85c2f81898a85957ef3bf6783a34d161a568cffde615c3248f7ccd0021b36060 18a7f61c29ea8c5c9a48e3b30bead7f058d06293 +85cb06c94423ebb8ec44805dcfb22cd56419a0d502cd6a7eb3d1e157fa0b0c27 cbf7144d8b79387bb97f115273515b9453e94b2f +85e0897e275601bcfa3d653d02bf6b49530d66d5ba2fa2977a6638059cff46d4 4195117c1ca5211c7c74366ba45b4dd2c8f4ec0f +8618d77ee61738f3e6679b5892a7ce404bd0177775fa65d647892fd42dd4736d 56933fffb8f2329d098fb9ad6085045a14c9ec2c +865c71423b25f5c4d2565a0189352e4162207a3e3d711488eb05f6e6553dc664 7f09466ca8150a7bb9eb9728841b0099b340dccc +867eab070ee07beadb0193608a62052fde41f94ee70c3574395679fc30c6f021 186a08f4b6d4a08b1692365cfef59755bd8c0485 +8699dbbfab2d020fa8fee7abebf6ce00fada2ca40eb0d09de73224daab3838ee e8cc449fe9c99f9ca35088e3247ab9c0088081fe +86e228d9904af64586e9a8378005ba654681ff5be3c43ca930bf6b1f28d4395f 6336846bd5c88d32f93ae57d846683e61ab5c530 +86f7012dddeb074d3313851cb47e7e6d2a89fed1d23b030131b7b9796c63beb7 71d0a2d522bfbc72bd8f518ba69939b2123e3f68 +86fb56a271a202b67ce596425048d4a2d0b5d0f320a196d3a4c9b6ceddedf1ce 5001298e0c09ad9c34e4249bc5801c75e9754fa5 +8727c60dc37a204127adefe3fd92fb6e1740225f3a1d8985ce29458c322ff169 ce4be0c1c06f8e311b68f70c89165cff698d5c85 +87ca3d9823e24cb99700ca833ba7aaec3cb8d34eca32240779930de95fe7caff 27aa76e5ab35a01a87512c5f6b215d1c9c736bb0 +8810957e46cdfefbea090991ec0a237fe844f0b4cad1eefa99f05f3c421f3e3b d76261e048bdda2e6d2211aa308e675507bb434a +882f8c78660ab5efc60c2259e8fdc601ccf75c16c5f787e689314197cd345793 796cf9d0a06b922a730ec98984876982c2d5bfd5 +884130c0e07babd81f0679e1ab15f50bcde3fd076fd540f42c5f7a450647c811 f5be02b49b5b3ae73bcebdc94a84893a012bf46c +8864b5746d7c5780083bb98449a3f5bf78d8281e8c5e3fd12a8ccd9103eb3a1f fd0ec0333948dfe23265ac46be0205a436a8c3a5 +886637d6a4c8dc11525f740a2e3723692bc67f42753e7b7a75d4e9207027989f b2899380601ba014c011ae9cf00a675689764856 +8873ad21d0ff871dcd53e0b2c4446a7da3439519da9c7ee509bf9a09cbe20e16 e2fd2428625c296a3dcca706dab7873368ae2818 +88a6c8138e7dcc2f7dc252dedf17830b3bdcd67021df4538c05dae27293ee343 ca65c747f8fd5110284f21d624fddbf87f41f836 +88ea074339e8277b932e8ccd92bb661e1b3dba88d86d31e5029577b41da793d5 5e15176dac8b0baa6f7950f5f763608c83b29093 +88eee581883a2bf8cc278592faec71b3964b36033590ea99e211b298101d2357 c47baa4adba9bc69f3e4a78e4b6e295b1f20634a +88fecc715077807bd7ee9e6a1dff65fde000379e0bf2a15cc2404469cef4c82b 5018a35e0b7e2eec7ce5050baf9c7343f3f74164 +890bb959ac8c20db603bf083bc82f55f9f42b6dca6581d941d0b361188abae3b e032d863f512c47b479bd984f8b6c8061f66b7d4 +89117557e4b6f0e5fde4d058c32582418fda69ed651551c0d682b0bd9a4f5343 ff87c872c7846c5725ec711b6d2005febab7d6be +894fb499b85985208f105302d3cf3d9c5ef13b6e4c51ba4233656ca6aea65cf5 8add01539268300564482f854412cfe9839e980c +897f5f26ba1178254ba5170ce0cb7a23a83dcfb1e528c87ad3e26b89c62cf9bd 44debd80c4908e439d4a505ad7f6de367635b0eb +89cdf765f35bfe191fc18ece04228795566f412e0cd6fadb80102a8268c99085 605324ba5ba92d44cff024069be576817e41c7de +89dc8ca30d409ad37a872d80b88661ef50d6c226a37989cd089e60c183609b35 6ca549d9a75628c1703ed6d2d06877351a268a88 +89f819abdee0700e804a202787da29c6c14aae8dd6d3b8cc04c50cef70c44756 802589d07105d24bc88c908c9e62edb3fd679895 +8a0042d434a2f8a2e8d47caa4eb454f388752fb3fe71150c1cea12e807cfdf1c dec93efc79e60f2680de3e666755d335967eec30 +8a1e1a6cc00519c4df8ce404c987751446fa299662308622cb63576fb52996d7 6f2cd729ae42988c1dd43588d3a6661ba48ad7a0 +8a5dc4432a7a135282a588c0249f63895f8cdd2d68906a2e94924ca31c89189d eb9ac8b7622f3c144605733fb4321b7cad8c41f9 +8a5df168a787cdbb8fc1560d31fa917061c53071da52148a8b63ebb16335091d 16d9bd5394fcbe6cc3dd5cae5124bd8400343e10 +8a9b600a21987e6ffddbad745f38c115797eacef9117043bd9d2da4835ee3cc4 0fd7e4bfba5b3a82be88d1057757ca8b2c5e6d26 +8ab64652ae74f7d9866fcecf118eb9994a0083fa7e52a4bc49a29e9887a2dd7f 9bdf5bf0bb8dfa08e11ea902931100c4605d1d09 +8acc0ab2fd3b22535ef3f534e51a9843fc8aa927903e1157434c9d72b1ff1503 257bd746cf4b3f1e048a640202493c3e3bcdc1ae +8b399358a71ffc0adbbe2d3160310e19b5a08da84565b0b74f4ed24d572bd476 ba0bfb30cd31b4d6bcebfe9ff614794e4f5881b9 +8b592ef1a82b329ecbc463843ddb64c4378787bb632999461b743c8c41ec0d82 2683a6b43d73cae20a876eaf50b541b8efc18e82 +8b9acba2b7d2bbc3947820166fd0b7fe6e274a1387957cd6488730d243d762da ce02d0ef9ea8dc621df41d3f244858bd60f41d48 +8be5e8938f38464bf1cc68f917fc9538d598bd4e35462ce33777a65bfb98b504 e6e4e04556df092bce179810d25ce5330b34d8d5 +8bfa45d9dceeee0ca326757a5c7feb70c3bbec6084ffba27c44acf73270484c1 80829e69e76fcaf3eecf606794fb5beaf3561f17 +8c0f41bacf4388237e1e53c564f3a0fbd1dad819856035fd41370942389cfac0 01b905d074ca43b1b84f507264d3175e5659acb7 +8c1b59c9c4abecdd5107384206e51fff8ebb6eda359c6acc8ae9d608f777920b 3b104436374b9785fcca167c9d3bf1e751c1e56f +8c241c359f8adedf6fd0497cc05f5821570e05b6d92537d7ad8d5d12fdccebc2 bca03c4e40b1f29603ff131d702c46591b8ff960 +8c53c0f9f0972a1c77e40549170b9ae51d365c200ffc4cb220628c5bce3dd0b2 d047b47aadf88501238f36f5c17dd0a50dc62087 +8c834cad51361fc89cee23325b17dfe11294cf9241f2b7579671e6b2cd45d79f 8844825b8244e0cc54c96d73469a956b507bbf8c +8cb46741dbbee92758abcded6eca24fc2b74f43720c8525633a80410ff0e2b7e 331578fb1d3ff7013b312914fa9c78ee61d8ce52 +8ce4527e0214a617e08c7aca94006d77ae31755ddb5f757f635c0bafb35f2afd e8919be6068c14b5c99b828af9fb84769ce1d79e +8cf83523411bffb0b74c7f8b5f9576b23ca2b2578f93ab8ba59bc6948efc74fb 974a17ff165327d457cb3d50324e122542255524 +8d4fd5f56519059e2797709107cd15d1e62715e26d83a27eec8160fcaa57a7e4 06a1c29eb70dd0b5f43cb58052641dfc6e8dd2fa +8d79784fd1848028802597c0ca8342ae4b7c7eecdcec8a9f806f537798f74110 b5e02a3b76c602bcd6230826850672f828e67d23 +8d9d39e6fd6ad7cdda32b877633dc72a1fb7f4da9ef96aba6c284ee9f32ed71c d44cfd460e2c52d67dea14838b03219967cf9cb9 +8da4f409d9349020273e9fd00dc8f7a0aaa655b5351af47c9a220ee542a31ae9 7b2a0b6f0d56e59dacf05a30087b58c1ff93cad6 +8db27a1dfe3454a225917713da4b0ae56c617de64876e549541e8ab991f2d1a4 5ad63728f19e4c606be7455a8a7101c9255b2b21 +8de876e616d65723cf46a842086e338036f8d9ad6c6969ba07ce2abdb27271a6 0f6d2f4cd1a1391a98c6a89e2ee6a69c0afc0c9d +8dfd647590d3913a31bb0d11ccea6df7655b8c1c2898c49e85550fd5491cc3b1 07b63040096107db747c6c80b02b0619e6983ec5 +8e3ce5aaff68c05137728f5845d627de532b2294b665c3d05eddf79972439909 b27d0a8066fd0fbddfcf8a30b4e77760147b0817 +8e50c5148de4a8ba9fc799c67dc669d6f82cf0a10ee9f03bfa2b5a3641762466 d1621f2e35b6db0d27cee8c6b1b03c2199d7dbd1 +8e579056a6928f364735405ea0694fd779e51a2a873fa32f3c1eee7db4ac186d 45bb348411937ed17e912aad83a14c151f922215 +8e61988c998c96a131cfe72225fce43e555bec4e590fa8c239373172a9d485ce 11261fbff21758444d426356ff6327ee01e90752 +8e67ab781e8d1b4f8c35972ebc695bd8645f51718ebc866be72ca3863956c3f8 b864df623e3b89ad678a888dce4b0d4c997f1ac3 +8e786640865ee4f226cc81422201c22dc4229852bcc61018a2ab7c73cc9c8e7c c3b53a3518b99b4ce31aa3f6e51dfecc5bc772e2 +8e7caefe45c938cd9dbba149c377c1cb4392457f11b1d8a258f464a24752a40c cc57d8aaae44f013e3caeefbf401ae96d858ec9b +8ee7bff2cdb8e47b525d8d472fef394ba46ead8db298dd5bc09c89313bc4b1a5 e313f6d036812969a06ace47a56c539fbdf8e82f +8eff6924525965875cdc054d19a4b3a00c5e7c57538ef7ede78461bb6829c818 5ddbd5edf83e034a62499a1a9c94645d7b9030dc +8f74f6adef88cea42ab0854fae5f0e3f195edf161acfb12d5f65a5e9717f0cac e235f89f548d732c4e05baa54b8b3dbbaf5537e0 +8f9cede149494538f4de2ae7c79d5abf3e8309762ed0846a9d2839031cb7b456 7dd46af6b7c177bb38c3875ee6d79a78dc1076a9 +8ff22fe4eca09e4f6bec8e71cdda911f37d836532f568bffa0da55d90822320b 6bb7aa1318f7f31a346c71ef81d2b33c6fd41600 +90115fca32a9cd85c4c9c0ad4c23e1d2772e2e91a105d3ac3c92b76f895f8b92 5c0b005b617d01c512a8dbf9e9dc1aded652f244 +901505c3355518bee35475c5d3f23bac1dded688b2bd314cc32b7f157e100724 c47800c7266a2be04c571c04d5a6614691ea99bd +902a50088f5721565b264e26665043ef0de4e9d2841414ede099b24b3793b1b2 e2401d52544ebf052730a63e8acfe4ccfb8fa0d0 +90445c1dd3c04315c85766841ef3f61e3bd6cf0685e03382dba4376426d365fc b6c9e4203b69a576ac5c462241a7e2f676cf551e +906ddb4156860b47274ea8ecdac5f374ee64306d9b9f03c34bfc9df5afdeb7b4 74eff33f8be680e821d9674ab12da3c0b76dad23 +908288eddd0888db0d536666139e193ae7e2867d214033fae2557701a5d8a9f9 80133dad8aa9b6d8bec7050a77d603c53ecd8512 +90884a4cca02648ee29efaeb429c0af915e0d2eff2d9aa281aa8dfb2d86f415b 470704779e16fdd3872fd111089ded59aa12a576 +909cfa7665c9be2db4a58346155ac887ba00f6079b76f71b4f7d4ed9939cf0b9 eb942285420814778642962e7b4cc95636bce88f +90d744132ccf86487aaf3f51ebc92ca3315c59c48e12b4d576e253be91a0c460 50acd0c53572be81b5c54379b2442b19ee240953 +9107412362d36b5e2350e5b3e3b6950ed4519963bc036b84509f452bfb73e580 a24f1bb1a8d16429bb17455a5f332eec88e777f8 +9112f74e9c8db2d4574bb1d568099294486e293e7625b3d6baa257970ac1f81a 1765d783910805c69509416785b2b780d9b36866 +912aafce2240cef7a68ef8c0e53e10b0d7450818c471f5b09f8f718458ef9c4e 1e564f1ef0e3a4a5fe861b46024daf93bde4834d +9197064ab68802fb19dde16fbffd2a40053b37850ea393274d10b3cf5fbfbaf4 d337abf625b6912fb8501993b7fb2b472d5ebcd3 +91c9d8df151e1161258091beb0822444b9af63bdebb8aec39417153503c0b669 f528160ee7dcb57d2c56341befcc00aa80393b5d +92128dfb792caea934f5218807ec993867b0c8487a3de69ebac33e067f64d38a 700f55d91d7b55665594676a4bada1f1457a0598 +921be768179935cee45bce4a0b2d27ebdcf05ed06c7d10fff2d9cf900298024c 78f9923320d8c6ff69015ffa8c0410f6599a3499 +924786a7e975fc305e917d97cda11a71eafae57d7b3c916cd84536a0c2487a76 685145309c964db9a49d6b7ef96140db6830c131 +929ca73a254eb7b0dee0a7476e09ba2a53c0b6975473c9d7574afc0228c34e73 c22bd2f5514799cef5657d67dec855c6b32a7eb7 +92a2ce8258f27dd45ea652d5336dc3685dd3d60627011f6215e923318f7325af 15c883bae698321aba3b162df438254512b316eb +92e6474ccbb1fde2326731bf69e57142cb428ea3e916b71b2980e4348ede2a15 0e3ce9a193137134d355caabb98126cab35ac236 +92eb919acbba3d8094a46d43a4fcfaeb6243859c3c15b2897e0f7f50be66af37 4e67695cb9de10a3dd32f78cfa01eed91ebf155d +92ee0adc53ff899c85d7f42cece06277f063d89e0b496e735fb68b25d02e2b93 c1044cde11b3aaad524cb3ea49d75227ed7e5f48 +92f0bd5f6ea173aba9d25ffe352a2a7246dc32e30f0aa2905cf566464db2182b c117a5386c76f01b4c444f608f4cddae9d1d2233 +93010571894137ed6a1d91c6caaa46adf9437aa37e672ec4ea55ae0fc434d601 f6baaae117d058baa0865206b834cd8e32fa4e6e +930d5c174308a2d7109171b86756093b656cf7f129524b1fd121f66a840f63b5 2351b9dd3b52f5421a6dd9e2effb503497b1c447 +931093620e5f050e2127fb0b96786ebaa9ee6535fb698ec01b5f7a800fa27cbe 1a443023183e3f2bfbef8ac923cd81c1018a18fd +9315ebbeb52ce6c79a2998a3bd9486831c6d2b2b3925326a3308aff6e5d879e7 524570f2c3b95b5a9f1c8df74893451e04f1017a +9391424f1c846bd6e8aa6a2ab9d1c9896f415068f516217c20484705763082d2 04c9c16e55c53fc12c2eed43e3d7e42f78fe7005 +939db02ed91a33c32932ca7c00f3c5f18bca0c2d348c06efe566f70bd3b2d18d 96f702218fe6bccb09568c2ec24cc186ace8c575 +93b0ac3a6caa8be7b891ec756913b8f3f3071a20ac1de863b16c8037e2f4c21a 84a13dc9b196c2b0db6b0f664e4ab2bf9d6ce9ac +93c3547a4e0bdce7c7dc444b4cc7204be32bea44e740daf0a41cd32a069fbabf 948171a894ff8a25635232606c5afa7bc3224e38 +9454571eb895fa350d59a9fec2b5b2ca135e1938dace531702ca77bc342424d5 4633dd81e3462424635f7d231a2373971ce736d4 +94a67a2dfa7ceb5a3416e25db885e3bfceba064499fc4b817d7945cd271b1b75 1801cf406d4b17f019a789ffeb9346c1cdb29491 +94db24aca3f8e07f481744f62633730feb4fc47605280381a08be510ae971ffe 91822c50ebe4f9bf5bbb8308ecf9f6557062775c +94ed253efa9e86fc636805c294c441d08b89b455903c0c14e9b16587fec081f5 43e968a905a821532069bb413801d35b200631cf +94f81211f6452f3b46656d5ffe4ced3377ddab58a2e9063a6a4b15cba49cc08f cf16919dcf33635a64999185522263bee1428e26 +9558e844b96edf250889c0660f121678993205d280a3e488cec0605b979f370a 7b6c856c6e276e9a3689914797d2598a37f4e1f9 +9565fe314fe3bf77a01611ffc14a48246459ad6a19ea01d4082522622fbd001c 1cd20d3af067093c571be764bef038be1a39b502 +957a8f955cfabb1507ba2fb3bd3a859a9f74b4707424dac86ac543db0d69c667 09845e76453ec9527128f73fd5ac7114e9158432 +959c738f7d2c764ebe052a66001643400118c7851aba3b836377623501a14222 1b9e92c73bd223661fe63dffa0c9138da4e1ea80 +95a2dc8f7a4fd47c27fc95dc9d90923d11032f4f436c410c60beb6f4d5b6984b e2337f39c3a4ab046b7a572fce89df27451fd2bb +95bb14319c7449829409166e9e1d1a750938bc52ba7523d752150636556803cb 5440906feb5e41241a699ee413475b7911284c41 +95c49d1abdc7b172424e8d7db1f142590e40c04a882441728b1e9b2268848cf8 8953b6cefc86a339924d5d0ceb7fd523a149fddc +963954464526b415ff976b8a59efb85e521ba5239faac654bed92979fa976f92 14dc301e7f99cd5f88098e32366951f803e9832b +9670e7ceb635f35942559001b8c628211efb5bc4f57380909523fd828c706f93 73bb602a74eda507838372d66093c8e85246159d +969287ad751eaab33d0109bb39436e2babafaecd5ef8405734713431c64250cb 468b12adb15f5546e7c5536f72204605fbd83f6d +9699ea5560b7b35db0fdcd4c7d50269402d5624d72cb1a8646b33b65dd416c07 42608eb49e4be32002462b51e86065368b342c05 +96c18f0297e38d01f4b2dacddea4259aea6b2961eb0822bd2c0c3f6029030045 45b983be36b73c0788dc9cbcb76cbb80fc7bb057 +975c9b644598f22c51616e9c8afdadff852639aad6c08b6c7bae1a34e2d812ee e34dee0c7f0ac8abf228369e1016eb6016c40758 +97a021b36da9610ff840213c9277124fe653804e85f2081f6dedba953b5706df 8a7d625f53726fc7703dc0a413686d1ec15488e0 +97b0e3661fa0caa6200c50381233f8320b907540ceb9d17ac94fedc66fd093c2 cf6cccf1297284833a9a03138a1f5738fa1c6c94 +97ba6db30e1bcc6f9e5916915fea9dc0e205599c97586f7846b9a456e5e9b6b5 b47ba8387c1d7209d4976af9c3928f6ce93ed545 +97e00ba4c8028ea91e7131c8c7596227cd03d3d2d14ed2d179fe0f305ebbca39 6f6a17db05a83620cef4572761831c20a70ba9b9 +97f425b009376be705660ee81095773e10fc99bee7ad513046fa0108bdec5d22 1594f6c292f52e077142ffc0f35b544e2c5dc108 +9832b7f86876eb62f53f0fc649fbcae18dd43f2ea05ac7302239f7f91848d554 db01475e9527b251dc429b03a96ecfdb2928aa1d +98488e25f5011c5d690f33397fd78528c38921473a0a4bb4b3a4d70b0f5a8d84 8a8cd3e5f3aebdbf53e677b176e3a434231a26f5 +984ef110535289c1e7afa6a33058e1ced09d7e0da058e419d8ddf8e8ca060b24 07f4f5f82f7825893865e8404eb2bfcf4a2e6932 +9862a961bf9c8b544304d2dc638c340b9c9aa6168ab4eb93e309326adb2f4499 657cec1480bf4d4bc58119da119f12a5b0545b8a +987d206013d0289d45845304b00c8f9adfa2255ccbb3545db0157f79c7cb8ce5 655d381a1948783d7d26ff9ec5ef54ed6bbefb29 +987db14ff31dd4b8eb26b09aa1abcfaab773ba9c27b6040d47033678e7cfd0e7 121c862c3a2bc66c12b64903e508d8bb8d2904c3 +988a04ad188e91c521853685421f1b7d8b0a00767a6fee4c58a98bd1d449c3fb 710a14e927dc232d94caf0fe87a42f0ffffe4b79 +98ab296fe0c2cb1cf8c37553f659614482e37c84f0b50fbb63e9eb33cdf1f85a 94b6d09da1161aceeaa537f55802d794cf021627 +98bdca06d862a2b96154af5b34e7567f60421b307d1b067a0218d6f3532eea0e 6cdf0445fc0de286fdb7a343a5dfcd1937666132 +98ea93628189727f2a49d3fc8800e24062ee013433b4914e2f8a6406be1b733c 944a1233c2873c5e21f941460c3940f8a563bdf6 +991cd4eb50d0bd943326a09398c691e3715278549d2e62720c1a90495996fb85 51eb2f90a1469542799823e0f3249520bf8f9cf3 +9932236d190601ab8f93e8ce8ce0fa59dba7f393d917390c1d53b34ef05b41dd 5614dc18f626902796fee9c87f1f703694e59295 +993f6b6de11fdbd469b7f1fab0d06ae9c97e47b4b15fea92903cc8a5f1dd981a 5b9c679bf878b9eec21b022f662da96601343fdf +99556a8adf928dd8b307733e4ecb5a8ef495b490011158d71960ee1b0a0e0718 e3fe32b6a4ecb340fa7c9802285711cc52b8a101 +995d546eb0fbe7f94b918920c68b83f8f92a2c433e48fb458374d347982cdc33 35df53402ea1bd8079cab9bdbd887c79319baff6 +995f00a0542d56fea94d5ec6bd4912016c7bfcd9f0609103766bb8c8a0d1fd50 daee7af942c5f7d25a00e3ec4d25eb587c61ac94 +99676bb02a367fe46c82e0d17e7c0f3e85a6c39c3a7f51233c85bfc73a20401d 8c870fcebb8f625a8e172a49a44153af8f37c8b7 +9969afffd2839b9abfae52451171231fa3d701bd6b3d0be45c2381cc993278cf c7cc7cc6e3a1480a18fafcd08574a337648f68f8 +99836286369db283d666122f999d6bae55d099525ecfa19678919c75de3ef920 558d6aece77743bc4be56a0a62ca9838131d217f +998a830952adcca170929a187cdf235190873515a9d8577dc7610373720be0dc 05504cd34d6ed35cbc7c99708d226758a1cf8b57 +998da46ec222491d7911e92bdd6711408dae8e47f65007634cf0286f78d042f4 0daa6cdcad92746551f78edfa93be0bc188d4f4a +9998dfc144a21e3e124bef5dc0f9a60e0feb92d600ac1e0fa77a329b69f0d256 4319860c60d84ec2513be34ee1a65dec5eceb6c4 +99add46dddd278865eff998db5c7e17e806ab0696d7cc8514ca638873fd4c6be 3fdbbc28dc8eef8c0bc32fa6940a9468307f2dc9 +99e8fd0d2d4d41d946a1bd932c4dc4c600ec25ec1ca10d3dbcbac0542c85f01d 84675cbcb6c1213c1e662afac915c861999fad7c +99f3b405443221141eb0fd1e0cca5d355f893983749b7fb455769fba434e7945 0266163a49e280c4f5ed1e08facd36a2bd716bcf +99f81d6e58403d464cb05e5425c6db0219ac6a03dd4b12d8db19f8ad7894eadb d435e706e0daa21e06d16f00d0605d598fc21b38 +9a2db41cb4dfbd68346f5aae4ef7a75a2756853da451e62b52999bd40712fa08 f57d4aab1617ffb4b923ba461db47073df131478 +9a3436818efa95ceed279b481957c3881d4387824b3ac7d6a4e5c4cf57d1339f 9a2edb897c93a7d1bfc28aaaab1b9634dd684ff9 +9abb7801e72353060a1490ffa3331674d6882558e7d6458de397b4b00d31ff8c 50330c02bd4fd95c9db1fcf2f97f4218e42b7226 +9ac1548112cb48d9fbe867db82c9a73eb6557f77d941f8fce68ff14d276d3e87 2e6776cae6c71d745beb9e102a4a18429f3c4cb6 +9ac284bc88212994d14f96edf294d17a7a4796193e3138f84f9e60eb1294cca2 dbafe4e0c5def65ebcbf13789a84e996cdf8aa25 +9ac9dca313f55249c085fcaff33f161594a35636e465e10368e4ab9e7b977b87 91f3b517f65492e5225d853826e3837d404c6ca4 +9b66436f2b9350f6d20d44171b51b0dc1b8859499ceb556249635125a86578d0 f2e2e7e17751b629cc3c13b0a7d0cab059cd1df4 +9b91942519f6ea0ba7841d14598c082615cbf66066995e85859813d3eedb43d1 62ee0b89958479ae19eb68f18bb23de238a6a2f0 +9bd609366724dee19ab10d3f795965cbedf785ce8572f56dcddd42f48454ac91 16b9dc5202084b857d167c8af606422df771b8ab +9c0f06e8344fe1af55ae50f4be06d090a443c24455252539371c9aab581699cc 1213764b28dcd72fce1be359db724fef38265ad5 +9c486e5fab95b06f1208424d889811dfaa8d498ba8a64af6faf2eab78e005baf d4594747a02e72be9399b3a54018676e0799be22 +9c4b7bf896a50fcad21d07e1a9c21786876c78350dffa6bf7309ceee396942a3 3d3552e8fd709214634435ee188e6fb4930e7b39 +9c627d7d80e595ff49c610c35fdf73d3e04757b12c75b724270cc51b1778f781 8c08cf624be754f3ba55777638f6cf54007dc516 +9c67024053a5a19e5c5f27bbd02419c09194a13d4cdce62d5873b9d6289a5e55 e5ff267406ab4a456be0b46e38fadf8fe822e13b +9c72eecdf03014bab3444907a5c9b1abacf3068537c5c7651f9492326205cb5c ca88eb6224eb55fefdf6ed43963b5d34c3558d03 +9c7b63b5572f9c6e49382f5ccb71e77747a7fb3723d13dc91f62fe6e3bbaa5ba b3099082e5108151c0cc93ec6bbf8b7d6a28c4fb +9c84470c221d8722ddc005be2e4e9f662bd4ddedbdbcdf0999328b84b7aa14ed 20bb1bec4aac38a69c0a6fcc62919a472e33a136 +9c9d32c9c37ea95e0e7a22420e60f28c4ec7d16076fbdbeb9e16485fd7323975 3aeb4c1456431b730322d7a7d88f5a2ff60299ad +9ca320473e41a10134f39c3d2361a6bc82c68bf5328ece73146233bddb2bbecf 485eaa8bb045019e615302bafa10302f86a01553 +9ccfa556cd7f73b426a7bedb7fc3a850e94f8c5ac1d71b9afa365a89005aff54 db793a00a5615eca1aac97e42b3a68b1acfa8bfd +9cfa4ebe14380d4922f098d03f17be12019fa52ed3e602b9925ff90f55c5a314 c94eb4aa7665d04c8412a72f3554401d2e89e03c +9d59e5d73d2bf09ae93c4a9d7afd5d4b7e983a20fbffbdf97ad78eb4d949f3c5 1554ef7957dd89f4d94f00dfbcf7989d3a409306 +9da6f7f0cc86c1260d40470e395f1e86aad5ab8e27d29bea60cec1d35c017b64 b946f1a6f5fd8b14500fe986d18d1d008cd00f18 +9daab17c25f647d652c72c8cc3cf4602c270a369beebc7d0b67238897bbc426b ae90f12eea699729ed24555e40b9fd669da12a12 +9db520a5a88c7d75b86a4faa1ce9010edf38af922f400c69a4a93aef69e25c4c 32581d0093429770d044a60eb0e9cc0462bedb13 +9dd0778372a1290bbaef59f6c04ad41776480beb00e529f6534550ccdec849bd aeb13951b1f97e44e4274201683e090cd7644046 +9e0c79efc2ddaf22864c1fde0db347832bc1a4e132fae802e95b6b0c5853c2cb 8399c6e8a4fce8eb0448429ad557eae77d2d78ab +9e2bad8166fbe654963d974e55a2f08da38a9e3d1db676a5a2c14ac3714b01d5 ee0be6f12e1e53703f2320e67389b85643305422 +9e77f6b7446eb082bcc2cccff17f7b83c69fbcb03117ea110012cb8bbfc37515 93407057f0107cacd2ec2fd97f940ed842caba94 +9e9f5a22329db59e32b25d8bded97e479d9fd505c6b61a52e6fd3113af5e88cd ed6e85be8971b49a86ef11745b5a27bfa4f4cb2f +9eb5ebb282122e48e20e161b3715061c4381c5e6a24512b0109c195d2f2ba73d 154eeb7642b8abbce7954016ba549e399ffeea24 +9ebb9db12bca36755036e35e51abff05eecdd42a23c620a2a372d7cfa55fee52 213e720ca80207fe1bb48ad95e2c422e17281a9a +9ec93e31545ade8f8122f1ba534269ea72fd84f1ce0b71c51f40f74b23cae7b3 a399208309046656ecc01f7653c5d5b8905fc16e +9eee45dbee480fe07ecda366c972abae9c1a4f322f4e2a00143638b6b877fe10 8929a79acf82b9414cc37bb9f464c9d0bcb384d8 +9f063b7c95baf5482f968577719e51ae9feafc11121b1d1c2b1460ed47ac713f a870abdd5f33c3cdd75c9c6229207346d1a3e5a7 +9f61cea7f0b3e6e51d51b3c63cdf7a875704cf5d8bdc20d1b4a05daff2275286 f863bba4dd0964e82908ab6ddec36bfc26f8bc48 +9f61f57710e2f3a52ba694faac763f14fa68329d758e713152956f67156aad3e eb160e949ef7a76c384dbbfa0d61d580a11d095b +9f6353cd9e03b3325fd0ea23ff06cca2e7871b39d0dd546d023743ed4d0e9c81 47d75e0475f54c1f51fa4f3a508e3a71bb3cf27a +9f68e485be09cb4f0406832c3043ff73bbaba9057dd32ca5120bf58fb968dcd8 c341bd71e5bc97d012fe7d788f5d95ad61f421c9 +9f7d9c3ff7c7873a474c6e71d117de23c0ca92afd7dd838e6425de0259d807a7 d17bf1cee2b79f0c371cffa58246faec7fa70292 +a05508af8a460097b5be87d0d1adebd9965d001c00c0342d5823d62f5d504147 d8b9e83ad587491de5e0ce5e105d6732da7efd02 +a0806f2837164079433fb98454b3beb353b38625d7f1f2e5b2737909a2fd7f3d 9b52f4120bf54829149cb3ef756dba5018fb812f +a0a1c80c937e6f8c7f4b9deacd53dd76b6f9bda0710ef14762f26b5c7722d85c 488de7f1158680124370c16d9b5787f2cffb290f +a0b19bf38b63a7127318ca02600424c2cd491023af9dce6d707c0e5891751207 bd65f47097a6ff27de3e1d908ec1d53cc6b0fe48 +a0e4131177d5b53a0a0008fd5ffa88bc29c07ee6c3020adb8f45751e28eb16c7 5c7507cc2e5b04fb9acba04042d900f15271da8e +a0f3dac8fa0e22dcf356aecbbdf79440715687c1053bc59b83354f276d688ceb b196a807b323f2748ffc6b1d42cd0812d04c9a40 +a0f8444fdfdc6276b3b2ab225d14358833ac50141d73bc10cd016a063437e6e9 d7fbfe155fbddb41936407612fbce9c34276b671 +a1034d13a76b0d29b83f6dadc5a44826ada4accc7889f4b2f6ba880763f2ec36 634e22b2323599edd0d177e2eaf69e7ddafe49b2 +a1053628fac1667c26c16ef757cfb87f4bc6553b90a659cd39bb1d46c39bbcf5 ee1765e529ab6b44adbcc6a0ff6e9ac1359c6cd6 +a13eb24e3a3948f74a9d83f553c937e82cc6e2fbdb7948bd12f2794d822fbb6f cb5245e80f90f14c1b8daadf95bfc08d29c2467b +a13ecbc514b571721a9a1c92af7f89d473a5fe13228904f8d17368e71f273ea1 702bd70595a7b19afc48a1f784a6505be68469d4 +a14fd01f6c75813480bc15c6f3ec6f8a2b18c541212c93fd96f6287fe82bc104 6829e2c4923538bd75c6ad6a2590c1aca8d4a212 +a15a130a98c1cae5e6dd70c309b31bc21fcb9ea731653d21054e0df82d4f252f c18626eef6cbd1b420b85fc9f8a44d5031ad2fcd +a1b4063379bedd4c5c0940aa2dc8c07b509d3a5164a853f1b5a20d156a7c5c33 b4440c0becb8f009bab65b3b3c901a409c49add2 +a1d1162067d6018f0b1d90daa0ea14dc570052758b6a3171d7895073fc15d992 7350e6337a2d94c2d2a105845fc78ba0ddc89ea5 +a204c52c18c7bcbf5cfd33f2739b6a67af9938ef27d904cbf102f5dda766044c 0c3aa34742a8470a4ab4acc60e061bbd9a85650b +a2127a5161de12892e23011d647ef0e291101a6120b75de2a8cad765e56311f7 880dd9e150364fa22ada592cb5daf913e775cfbd +a215658dd4f0927c758ffcd6487b359161f0ddacd2543cf0fe86bf085c174bda 870880896dd1c399bb940510903a3639ee61bf68 +a27bb9f32d0647d311aca00a8f7664d5b30182a0eda31b1352f003bbf22eb58b 36cf0f3c2a9b192dde9ab57992dd730a54a2e302 +a31067ab4135316257f12ca5852ee49031e0cc3c62fc7e36857356a1311f864e bc7ab9aaf82cd5778fe998117b465b5feeb58c41 +a33b7c23c1f42033a24b58f5ea0d33aba4b6fe18d4bff86f0f70a4d266b66b69 64b5d4fbe7bb8ac0a5dbde1fef81dd84b593324e +a344b247217e51783935ecdcea5837be2f47a56172d3dcc2069936ef3d25dea5 7c866536731236d38f1d75711a2af253d479dd8f +a37c93ab010ecc9c7f017623c38324ae2b7d06385eca57fc6da35102a2c54a54 e5a2858907d153905dbc09d1445779caac0adc6d +a389c085c2a136c9a2c2b4a818b851a87af9904f933d7fd6aa99846208efe800 f501265f976a745e5c0d21104635d695227171cd +a3a074de072e21878238d9d7b7b1081fd4dbf3bdc50c145e85e6e4d7a09d7909 0967f654549002d2b6e8495c10cd0bb20ff3afff +a3b7619b6d836ece7d4dcd5d35eb3cd636b6ad1fb22bfea768ea5d4102cc9ece efd690f67a58c2ea1c3984397c2aefebd716d7ce +a3c8832d145147c568d4954618aca12117705d399fc02f00272fa32f3ff95ae0 dca7499de88fd02b75a47bee8def272c14b5f7bf +a3d3035f44784137774392f722a38f0d5a43b9df0a631531d0e47c48779cd940 141d3dd299cb117c277cfe0907b0ddaccdaa75ac +a3e39ed0693d43349755e98d7e125ac17b5d3d2a5dc232b8d5b2ba01302ace04 c15c5619a51d0a0dc6bec0d9961f9ef50c5c2178 +a43230765f7a5a3d422ba2e7cfeed85ad722551db2ac6784b04f6f8b0e1001b5 ea2adb2520150efa688d3c48f03a66de3312bd4c +a46ca0d0e30ed9fed1eb8939c497f79aba95b9e8e4e712079d73a6e6ebc70d72 f0374c882b77ba4a05ea2d50f506239da26a60fd +a4813ef6708e6011e8187224297e83e4a285f58bf5eabb1db270351388603c95 a4a7dce85cf63874e984719f4fdd239f5145052f +a4c29fb8becd3a01d36d8cae4b12b4d3709e6b45eea54d27f2ae2e43c9ba9ae7 e8b638f771ea8e8ed9049b56148fcb2a86625f7a +a4f0c2fd0cdb1ab3dacb8758af443e9536c5987f7c66c5fa89e2cc79a1b61c92 da7791a0235d172e7be4f5c299387ed1c95c0921 +a4f8a0eab46e58b3afa198ed68ef78d6fec944abd7ffa6fab63a8af923aa973a 521b4e69c6e0a257724d59f3c803f4eb11e0521f +a50ed806c69fd2c6864e9658b0294feb4f7c24970cd4a785b3788beb190266d1 a7fcf7cf6ab5763af5a332041327182130235ab4 +a5191d9e8f879091e1ba926dd387711ad308a6a0b110dc58a4c9897209b14605 523412bef70b1d4cb92c574c89bf7225e205d489 +a52d36b5dd7c95a9e8596f01aded392be81ae538591f5d990459592bed96be7b cc5aaa5fa825a103a547d381c7a5c0524c4853cd +a560d1fa1edf114f57b402e16d662c17b1e3b7e8601ff7dcea6615ba7f1e48ef a20d733a9fa79fa5b4cbb9639864f93325ec27a6 +a564b979c786a7a32c6e8477e940a2a43238c57e8fa6be1f8ef7954944c41b89 571a65a81061ea62a11fa210ea6819322be4cba6 +a5ab6e423fa4649571d39b9a29484a0bb17cc70534ee6a410882d72ab1e31597 45a5f836b0bbdb163a13ce0e1ba1e8f7acffb5e6 +a5ad182a309ce0243d95b53ca5eecd2a139795321ff24f6fbc548ebe1f425729 f52cd06b7d0641754c6f7124382b9fb397e4070e +a630a33919b24191dc33f2e09b46196fbc7cb4b866b6416b8980431735146a5e 0392558815cbd6674d2187260948cf5a1fb22e6e +a657e241eb57d29d515eeb128f31ad3a8012e71be44872b0778f278df6ab9e4b 0735f982dd5a183a7fa901b0103ea4b0719af5e1 +a66bda0109d2b3c9bc87970da81bd91076b5f871febbc860f09ae997668b6800 12bf5f3e3470d90db177ccf1b5e8126409377fc6 +a679511b71b78a1b0781d6cf5e3c4524c1f213d671a5acc777ef36a2ec9b0f37 b98b09da1d6c4ec25911b2fd859282a41f4225e1 +a6ce423d816299e53b9b87164b3153dc3a4bcd733c33be1c2a13f41f140b69a4 f494e47725e1cb76e98b5aeb9bdb7f8d8271537f +a710c2c837a5a6f27f2b7f5a198c7797f148ae6a37a2209748845adc9d0bef8e 0087a575a0655d2e53e8ba4feffcc321dcb8cbc3 +a766d34d210e448439135e553915e30b62f09b926c669b7e2d5cb073e96bccfb 3bc2493e6ac633c6119b7899505a5a0513ae4e44 +a787901c8e7f31a8450a152bd8aa7033203693d8ce807348e53125a47afd7c24 eadc9ce6cb6cb722723e228d9e44f001d4236b4c +a7b3a389f8d3a36403a8b2bdc6b9b2579c81d79f91347655f50ce4356b4f2831 7f07667d4c520a81c4fd6b5631c119bf2de791e9 +a7b9c8cf9c7469bf18c8fd079039fb8d1de1867de46294726c110899d94b5ae1 3d2577feb4985c61a7e393777d78cd9a8e8a516c +a7bf36aba7ea2fc2eca014f1ff42ae012ef82b450220cdd5e77d7c5bee306c71 c10a39190029484263750293825632cbdaa9757a +a7dc9999e70a00c97b97f71fa0fa877e92e29a09ef6eae72de2ee112d3854ff0 42150e0aa48a3ee95ffe74b7f937111a4afe17cf +a7f778c6ab0c219aa051ebca04abf1397864be8c9c69873792c6bc8953426874 ae5ceb4b269403c6d1653c7bb32e71ede7398892 +a7fb6dbb2154115eab700f4e4a6a6eeddc30d3f8a14f0ccacfa98d9347ccff8d 4893b75d346a20df101789352b198beee55901a0 +a86aa44f58a3f3c347dbd0f99a84c1ff6ddd41c58b19697c49d3193f65873a08 c8f5cfa836b403abafe7256ce964e65b24b3fc0b +a8a227647205ac1f01b263c1a81b8776337124a6e519b67ac69ffd4d2274f682 ce53c27f666673c2af8d406447078ea03bd95f6b +a8c3ec591a4e8c04a28e1251e391aa6218df72cf9b5f0ae0eba6eca6877902b6 94996dfd9511a12bfa9190d97d33d2bf6599f1fd +a8c79d136e0c69d1c0d2281bdf7acfeac0f55d6239b0141e17a6de422628c7d4 696bbac1204a1d56b0f482568b1a7d504747138a +a8d8a08205cfdf47585c32111e5327b328c0fe68098eeb58c939cab2e83785e7 3f88988aa04971faf2b1170fb8a5f7a0e2cf5f8a +a8eea8c78cf7e55ec2cfa539d860b5e5bcc4760277d1403f2c3d06c583e3905a a0cfd1297d1eed63d0690c167d67e50ce06b6791 +a91887e522da2b66ed048d77858041c9cdb2fbfb0b4d463b971911217aa3a4a6 c2550609e37e0778814d328c47eb84a7ede6931f +a91e8591cdbcab2353f3d0f75a016d31c14157fa7ba9657bb72bea1772be10de 82bca8633fcfbafe94997fac9fb855bd93e36bcc +aa11e156cf0329ca3cf624ca8a185356315552962035a549ddf6f09268402084 18c321ca3c1f1d360c8f6c793cd48afeddb4b54e +aa4089cbc630982cab278c49d506c357fc9a8dc27c002ae1a6f8af32d5bb3e89 966f3c578c405f92510a54de59ef2263a8b217a9 +aa61d4adf622265ec814c1a97198d2bcd3f58fb08989cb9beda32a4d0aab6697 bf92206f8b633b88a66dca4a911777630b06fbac +aa65747207487983a77cd65713928d62e1b326b93a330ab74e9c9517b42f9ec0 75d979718393e2d0e6d1399e6c1e760cd739ce35 +aa77e77d6dbd35635d786aa503c8a85b08274c73ddc420ce75b66b8dfac4860e 6e9df7119d93ba93371c317285688b49a40f56c9 +aa793f0e9d9d746eba8a7a60cb4981f7e24ce9691910350d7df9b9e94c7567b9 e01b107b4f77f8f98645adac0206a504f2d29d7c +aa83de8b0f4b0c6d26c97e1048eebff482698b79131cf68b0671eafc40444d08 8654e891d437bfac94db90e4c1f6878e0efd052e +aa8c472ac90d32654157b4a43e31135a9a864a3f02c2358c3b78316cf175b5fd 1cdb9a4f4f307b8d0a3439d6d496e7ffa0a19917 +aaa1b07f32e2a452b7c24d7068bd63f27349668ad1c834cca9d9a2abc2ce49b1 4260699b37a7a0cc6be231d232d424a858a7d111 +aaa6f15815044f9acc8541d8d28612affafc1cc820a084798ef762ac6978784d 6bdfcbc41317d86eda9bb191e87a57651e8c6245 +aad6240d16f18620120c221b902c9777d220fff8c5a0cbc8071ef6e826f6c630 4801a2389fa38676d2a42061f5e3841324667b10 +aafa750212c82433e5b7a0ade7048fa1951800536992c59f6d66c46b2337ba6b 3cd8b687d5dc8006a5eae9e9c4dac212e8df67d1 +ab2a5eb5541f5accca9d9491bf53002b131b547493d6c248c1f51628468b91ee 157999b26778bbe322028a30869648267bee7995 +ab4ca17ec21ddc7e0bb1bff660ed18d90053425adf7d85aa320454e873a18b75 c29a831c884ea240437bd2459e60ffb383dcd149 +abee32b3339d1566d75613ea61f40c14bdfc5b101b60fde4f44b58dd06667640 181037049a54a1eb5fab404658a3a250b44335d7 +ac2a850fed51b1da02abb706f3da5768337aa2d49b414add21a668e2497ae125 2cd78883e494f23858067087893c38219aa4fe76 +ac2b785aef8cb5a9b563764be378ea45a50cf163d8bc37daea68fe2cabe064e8 6eef8dddafa405da3230fc1dbfbfc7ee8565fa26 +ac49410f64fad10760838866a40107573e42c86908c83ece433d64b7a8b57f7f 2f1c5d509ac5bffb3c62f710a1c2c542e126dfd1 +ac7908fb8ac8b6f3aec395f7b5a82f320ac634496b34c4e5534bb291bed1a8e2 c6039d8f24940f4bebcb7391e705b6b375f8fb93 +ac88849a26c126b03fc6fcb17cb23ec563e87a5f63b7afe800ad0f436128ce98 af292c99c6148d772af3315a1c74e83330e7ead7 +acc7061eeb4b06b989b9b95db3a726463793a54752bdaf978f2b643064e61650 37870a4c5009c19f3da47997b40b786f6f2f8b58 +ad00202dae3bd195b18e458e7f527e04135398a1d5f9aa3c25291803c26482de b6fca797357066296e2cd9bc9bdbbcd2489a67a4 +ad05c66a177f844f8239a1d186a1f803a4daa6286c959538838e222bc6337dc9 4ff1dd0992dd6baafdb5e166be6f9f23b59bdf87 +ad150ac016bb6e3d11d5d640927038619573205f34285a0270426b5d0d9171ca c867e4ff48cb00173ab50011a7cd593ab9d3905e +ad69d65326774c8e0f1a8fe7b218d2f4786db7657a5d6b03d8f43d8265fd3c44 3d35c193ff6508d92b3986a52c103b2c1fddea0f +ad90f638cb67720b20b904478471504acebacc7bb36e5dcad3e882acec496fed bed08a0b30b72a9d4aed7f1af8c8ca124e8d64b9 +adbab8789a2829bab3ae26bae696810557ec48f125e57e26e25b22a7f375a551 c405f734c2050e2e4ad3469d087368a29a98d27e +adced03f19d05aee4179e749bf666dbadbf031a12cd11796e4e463b0e2eba5ed 5ec2b329adcb74a8bdf99871f0f6c048fc90de70 +add26f5a369d9230fda1aee868bff357cfb63e39bbc21abcbe5e87a77dd70393 8e0a161f97b84d42c44757798dfc0449b1ad3c9a +adde54361f01131673d95e3f74e73b5b4645913941e061efc66bd5c85c40bb02 a0c0512a8bb09a7fc87c41528ba63083b44056fd +ade7d297ede7bb58008da582de1253f0a55cb76e82d1cd376f82ccf97f70bced cf7992bde17ce7a79cab5f0c1fcbe8a0108721ed +adf2fe0b01c0f20184cc5f4cafbaa7dd71f292a8f06ed0ae3690b21be95f661d 615cef56af79a5f5b39e4f337cc5d6e5e5c1759a +adfb7008e983eca01cd37bbe9717a22ab7f62bc731f2d5bae26fb99589628853 e33a4bd5f9681cae1b8956247dc73812a7406615 +ae235704494a6aa176dc2c4dad7705e40ca8932b44796287278bb70878206bb7 b92ae7738d06508c5fbfd1f2d08fb5190343ffc8 +ae29942a0032a27d0dd5dd802d5feebf1500cec3f37b9b0997070e9ade4df219 f6b73d281810e3ecb7e984ab7c951ba52b72c10c +ae52d4711e8115fa72fbb0397f995fd9163849ddd522582c1efee23a4371b846 bc95d2dc839d6993e4ed0a13966361fff93c270f +ae558ea7cc33669b88e4cba1d9448d5638f5ad5c6effc852948555f57f8321af 8baf75bedd0f29bcb61efc7c7c95761dabce5e63 +ae8542d347eead448e089ffb0c35067c2df35b7abfd9eec4f62eeb701c59b05b b7af25b7c9b2f436fd6a5cbabf9d974d6111f6d1 +aea29dc305d40e362df25c3fdeed5502fd56b182af01b7740d297a24459333c5 a8233120f6ad708f843d861ce2b7228ec4e3dec6 +af17bf05f3b3dbd780997fd54887b276c0c972aa0615ec4cf8da9bd960d560ec 1181cfdd77061b39dfcd72660eafcc1c578fef0b +af2ed32dc25c587ab2afe464a73b49a0c5454fa2bf12ae538a2165c373ac2de5 bab41e61c338ed174de4cad036da7a5edb40d28c +af34d66ddd3c768aae865ba6958dd9158ea5f5c47fbb5348a8e359f85f89cbef 9e4700a6033d42474c800cac6dc0095bebb14c76 +af4b69c54262883b42d42c72e8383a20843ca1521021808f73dad9216c5af6cf 6607b1c62646fb35b6f55f22c11a1aa14f0a1145 +af8cc9a93a75ef2e04ebd8aac5c62beb755ce4c1162d8c045ef578dcfe25ceb1 d9f106b9f6fe553c649cf682ed66b72567dcc367 +af90f5cacbfe4caeb5726627f9ac36e5bb49e8497b1d5428858cbe64a332cec0 f161ce12cbe824defc0e445bcfdbbb6f3d5050c6 +afcd6780d3255be3d03402a43209f1c5c32cdb3bcb23068b94e6e9247ad13e7c dcc1b764890f85180542055150c2eb8a7f3cb9f5 +afe1fad6f6b22eea530ff7b373d6b9b787b39792f720e6fcd0692ba6ef99e02f c0220fca67f48b8a5d4163d53b1486224be3a198 +b01b505b9db0c6fe12355a5dd4384184eb067779e23028ac2e1ab9a504bb1bf0 14be9ebaa30a1d6085e889eecaf2a24968eea24e +b01e2a8d4c07527e6492e7fad1f749dff75216d4f129e0d11ca5caf9ab6d8273 b60488e1d7564716dc2ae7ce078a415280bd7df6 +b0516a64349a18f3d4a48850359ab66ec681ee6575103523acf4fc9b5e201e08 739bfc1798bb97563e72c0491ccf8fdfecaf6a47 +b0675d24f637e6c2c05b09b88dd2169fa169c37dbfade733a5e0af0bb1e8080e 4386ee2acbcbbf1fdf06c75b91da3a9653075c6f +b06e3a0bfe758a68c5c6b9720f281b2526c19564179a19a0ba1844a45b089e9a 8ec389978cc56e25a6a5bdf6be993c7664e762b5 +b0a25f084f327104a3da545a926c6b89526d5399fdfec65d1accf43c8f197bf0 6e9ac9c85e1329debc18a30c520e59130d5b190e +b0a6aa2b450048e43155fd6d655cada03ba242a2c1b31438f93638a69e891727 94093ddb4164980ef98d78b1de318eb0ed74d933 +b0cb0a55f09a8192d882c14405fa0e8a366db3d07c17214f41614fa571566ff2 3e1d42b7d980e29595572e550d5ce58c0a34f15f +b0e890ff4d407faf502bc1eda5a18bb9f08f5761c2da4f3d6a6d563dd2f0b1e5 ffb55c532ccc1cb3c47eeeaac6c64240ab88fe29 +b1328b04eba6d6c573e7c7aa9eff201a654a1cd2c077ec9fdfad0499d259e7bf 2ca59d57a4451602a6db44da4b2d37a505a84698 +b167ee336fa10383d04670681af258d040347e6e1edc71d61af722cd19f1192e f2ddf1eecca39a307ab8544c2076a59441eaf5e0 +b185929191c7ff2f9df80b08b2698ec2811f3466cfd520aa4df2a8b777aea135 89b765b0e9f0b54f9dc85fa0a982774d07a935fa +b186cc0087e119842e1b7c70dc70f705d7da0013de7eb434a6f48dc299acec75 57b5df4e635d8324ca75b0dd33cb96271b426e23 +b195873b48c824d995c974a3497ade7f62d2cd818bf388775cfa721de4068ebd 08b041783f40edfe12bb406c9c9a8a040177c125 +b1a61b0e46d4d5ff7268e381a6f7d32eee81e5c1304481e62ae5fba97870c960 9eebf8791489850089738a95773d2f3c1d56d89e +b1c6b80f177e1869b39215b2ee4089474d685459fbda1bc4936457567036812c 7e822f212370d60dc701504a5512544891f3ae05 +b1d6e5441c09075f9ee5aa32d8501acaa0c57f5812b316a74bd7911786dbb1b2 4915947ace431f2d1b4fe920d4cc446ca2388169 +b1d8511cbdce9fa2ff79665dc3ada50e6ea82b506cf11decd40539e6478b4458 c1b62b2eded035d22584c427487503335f519d4c +b21c8c27a05a3f0bf9f0f44ebf05e11d9c591b04cfdaff7cc860310356d71827 db4df74a2fc340a0d0cb0cafc0db471fdfff1048 +b22a9ce429c6518de3a48dc441da4387fcec90fc88631499e61702ee5a8f8b30 345881abc471d0c65c8bb7e4cb3be10571cd32ee +b236af68cc7637d84a5cfa565e8b666c303570844c3d3dda6534a30b4824c352 eb2da5c7c3cbd270a1f945007ad098eadb4a68cd +b2732eaa1b3cb8942b40bf8da2ba51b735540dcb5605c29b694d7bf1cd500e9e cc15381ea2855139cb87d3a5d9aa64841f98c1fd +b2bc5b027b583a336347be589add47e0a89fecc19dd8a154b826c363af9a4345 da7ad841bb28fffb5546b529a00463206e47c8e1 +b2d355727ea29d217971a84e2a88527e0f6996015bcd01e4a2adb18910dc3aad fe6f9f29340241491470ad8296ce178ebcb428f4 +b30bc6949534a21693aeb43b8379df1b6dc621136a2c6c356e3f6bb86b9858f2 d570b36d8ea2d61450a40ca03c3cff9b144bd147 +b3364fd9c7680d53ca88929ade181defe8a00009e26e073ad7204fb7571aeca8 da8182721657446127a006281e0f1bb4219be952 +b34f4bbdec1daaa7d6e1e99aaa1e6cded1bec27170881f5c6527fffaf55adce7 1bb11859357114684a1a740e471edf1a7541b82a +b370899e23e1a0b5e50780586fe822e2e6e17dc03a2e56020cc1d11e072f5160 a9984a4e60291958a7cf0045758f47db3d214040 +b3836efc8cd5eb1c0ecc0d99df3644902cbccf9b6c7c38c3fc65900492cacb21 41c1bdce587d5c8b8ca03a5a8691ea3f09f16316 +b38a7a2ee69d55f021efa91caf59e23bccdaf6b8a9c3f83acd978aa177587537 bff873e9853ed99fed52c25f7ad29f78b27dcec2 +b38c89863825241eef7e7090bb11233910a0117436211183502d501ecc5b2879 e4e56117de8b3bd0bd899701da4712caee27c7d6 +b3ac32466d95d82432e7aa5a2080be9e3cf9b69f8620177053557d982a5f6eea 6909925086c86d40934c73e6d7a4b3886d5037c1 +b3fbad0e2e846628da5954b92c1c9b9bce24236f166547c5352503d7abe6984d d132e975594a1f22a5f3a480f5695e6001367b53 +b487428ddffd22b992094ae29527df9741cc33075a2ec0f4533bdf26459724ba 3316387b546b1d495ce646422e95dc209cd23705 +b4b7236050c279fcd2b6b05b6539c178614db05615eca1895ee1e9de98d73b44 a57d1866c26829f12095fd4f20f359e7552c52f9 +b4c3e22b042d111d7546f8d3bb4d3468236d28caf926732b8ef6c93eefbad39d 0cd5264e932f5dfc68959d11b5a3bb3a8714aa87 +b4ff5a6d6ac893413f20f16c9b3c999a5703e5e1238c50585ed32a64368a54d9 334fff1495c554746ca66f2359281b7de69f35be +b51d286a9549d2d2d6ee18aa839b2fedb8f3b4235bd763553a2a415548e7c81f 6e0fa05b58c140a42ef25dc74041e30f25772b2c +b5454cc2a66d713d5be85d5297def275ddd102817d96014c46f438814446e29e 5e98d798bcc9613cc34a083719c378d5c66bb9a2 +b61b940a8cd979a32e005682c5c09c22053675e2db24ea6b4b28cc75e9c10890 5f34cd6e3285089647165983482cf90873d50940 +b6cff922b0be268a213f763aad8e357bf2f30e905ce7ee47d586eff02c5ad26a 1aaa4daefcdf508ae661e81131d810472fba488b +b6e8427e3afe1cf0095d0f5aeca0642c4fb12d4e529f62e8264b6c4db72f04b4 6fe7568fc3861c334cb008fd85d57d9647249ef5 +b71ee6c8837efa5b3ba3361f88c321d391ac05f41d5b2506cad39319e80716e4 c02d0b160b82ee72469c269f13de4c26a7ea09cb +b7238ffe9e20cb2e62107858809248620802f8f15c603594daace4681810bfca acf362a92101202f5f09c9b51db352be27b5bf7e +b73c6046e934b9a76e5b9c587c18a20b7a69852801d6b3517bafe09b78d1cec4 964c192fbc2997e871c6101cb63f69b3ec377b66 +b75cad007d473a24d06563276d7b254378f2a0935d231cd82b5332944f22ad1c 7b6e8067ec96acef9a4184b43210d583b6d2f99a +b790ebf3f307102c84da36abefd196078e569ec4279f9cba04bec0ed68ae93fa ffc359bfbb59bdfc5ca1fc95c9bdc618f89dd8d7 +b7bbec7e6e8cc5a640d966739b0c7ff09f5710f534b278ddda5a5edd554dbac1 d42e47121844049cea15900ad772f51164397573 +b7e7455bb13e40eb23c5521f75bd912da55c7cc4882f62cb1a5ab0780f04faf8 a732c71d3e34cd444e9e0386b797207bc116ca42 +b7f1e115ee187338ff5720b118395dafd6087ee4ebbd63883bcb4c239cc1ec2d a59b93fe881d5983360984cc2f81b4d12d306d8a +b83624f6ac0995273c0034a7ab8c68929bdc91b69ad54ef94979b93eba3f6022 9fd738e8f7967c078dceed8190330fc8648ee56a +b88071883c4741b0f044dd83f33c8b7fd514a6534f212aff1c00efbd96cb0220 7f11132869231c5461b911c054577d101cff4b1b +b884efcbb7ccfbdb587e2049b9b28a7d025d3a1a5f9c1d7708f39a2a2431fe89 04133b0608f824a5d662b85c866b2e84244ec0c9 +b89ca9872ffc92ed33fbf3e18f6acf5f9ac58c70a7408137a6f042b7ced845f7 40e1af83bd6b13b718c52673d2ad68edf54b6d6f +b9134c331629e9cb29d1bbc03904d911a942b451e087543fc16deb0116391297 6fc72e46de3df0c3842dab302bbacf697a63abab +b96f8b46286c8c2a0e73d2e320abf35334e7821e561a888f85db612b2871a1d1 f4113b8f6c796edfd95d2d178dd27140e8d5eb40 +b98e3de756c625603d536f742b69bf11955d439631f286712927f5975d560e1f d2ef83fcdc0c9cad633e7b654ab789d17f583f30 +b9fa227a38b8d66e3c2acc8a463ea37768496b746d370b95c4803505fb79b84e ff4fd6b1cde132c6cc6278ad7873d7047c897d2f +ba038509caf46d121547a01557da21517aace95267ee6ae54bb7db1776fb5825 ccd7ccdd6a61f941642d75c3870d82cdea9e6fa6 +ba0a8d2454aefb8f2723fb6fa5a1424439b63bf2f6f47d575aee73a76a542a73 b4b1f3118c4afc6034b5f99eddd18f7dbf15e5d5 +ba0dc4a1787f9159a174b1e010018af3ad2f5f84c8e8eab98f67540663ae82b9 fe4db4d4c93b5fc5d85aab2198393dcfdfd390a3 +ba312594582a5a746b8fe46d639f8db0314522ead4339ee6b7299802443ba5c0 d9a9eb65ed8db7f1200aa017e5ea2204266e7ae4 +ba3e0a5d754cb8fb417f0b8826d943fce3007ea5fa332abca0eaf31ceb99caab 41cb5ab070140451804663d84b8190d1c5d546cc +bb04bb109db80e12067bb064a5e3eb34c5090e41b4ea8f289c2542efd21fd8a2 662a69f7b8260cdd2461918f55353740451b0ae3 +bb5497a9ce810703e014a2ac6fa1eaf22625ab103c7d141ef40343fbd9db2a71 89442107982a1e968f643808a9e4c9227c1cba2e +bb5d090bb1914554341daf6c1dd6fe4e5c25e466818e5012ebae812392b58934 bc2c876e099e4a12b7b28779abba186216355c53 +bb680fba7ce88de98d4881df75bbc7921b97102a8c67ea9d9b45baf765a4c354 0a420998aa494c4b9152041bf5d8ebb80a2c4cb9 +bb6a768c5f4888cb5f37b641ae0475c1e8806f53e1e55acf6befc7ca727a170e d1487fd5790bffdaa06c181d53cb966a4521e899 +bba3e6952c7a791c03cb65d4919df3ad767346cde441854153327e24a829c1d0 860bc8dfd43318cc0513e98d4696df7378b6077c +bbe6aae28af3c8f82c5f1d6cf882f4eda9165750e08de45e9796134a294bf83d e074873b8c02e2a3d3beef03dd3c8ee02cf3ce9e +bc1b9a106a7ea9414b5149bc9a25a49df09cbbd91a99e5ffd53f52462792e28d 5abe9edb69b20ea386597b062e94f2679cb81fc6 +bc3c9e7c3339eec5a01dbac0a679b06e04124c4f51c79fbc16ea8a68323c0654 fbbfdf9f13e92da2dc31b56081302f09fdb62e49 +bca7f0c01fb672c05f86199908ae2f853f58f0adffb9b97b897b37c2b5633cf4 0cc8c5d79ad42f4673374b0e9cb00c3777e55a8b +bcbb54aab5ec52d387c70baaceb1ae313b312d354319b95c58b59d5140bef0fe bc584bb33674be3b3925c7bbc129f1f53af21869 +bcbc6e0586bfa74313dcd57a61c4e958abc0ac7abb3be0f2d82d0d08a3d5b357 755a4f75d2184b2ad4ef107932c86c7eecd0806d +bcc4fa242e55c5e08f64900407dca1cf2451806830905be616f339bf7a5580aa 50298f44a45eda3a29dae82dbe911b5aa176ac07 +bce08cb2060cdbba7216cdee466762f3cc8e3dd655387e5f5092a748ead67f6d c3ffa781d527d08ddd3cf626ade4685fadce498c +bce2be789b7c5f0d236cb597083143d261c705c2a66a88f4ed547ed9e2065793 87f7f37296ff41d6f2c8603d68f159cdabd4510d +bd15edba8822cf76e60aec16a0edca6b464f22bedb2f9d55078f51cfc7134405 9ddea2008d33878aded26b0c64ae82ef6def49b4 +bd32ba8cf33cd3049b5dbb3c18c0b0478a52389cfcddc7e7b80f66577dd3ad0e 6524d538430cad9215962d6d01b078afd7720bc6 +bd531ed2f7d5971c642a86f8fbd5347e3b85e2619c891ecd4bcb4e23976f35b4 0bc152bdf2707576e6ef9331189607c89f9ef8a1 +bd69bb8de277fcd70b2accb62a064eacd6ad2e01817188f5577eae25cee3a35b ba6f870d2cccbb6439c43979a9fdfa72c05b1a73 +bda24eb65236b353a3c5ce73585fca46ac4339a386a463afd3e28f69fcae213d 8c7af5e16d87c12dee61f9aaa6cfd06ed93a08ea +bdc530e0b98dd736cd812408eeed9aa0d393bbd0630b355eb7601e61f0dbc7c4 90f9ff6755330b685feff6c3d81782ee3592ab04 +bdc6e8229c3beab1f6fb0439687b325467e2a8fcd6267373881c429f2f9a3f78 4711d372e66dfac8218c4d5eafcf03dbdd4706ef +bdddc903f4cb49c257ce31b6e651349f9808d82c320223c339a66a03a9f7829a ab415d59cdf8cd11da6d5281c75423691c0a34e4 +bdf2066a28e11603a1af04157ee4aad97814279fe500340eb3465797cbd3be23 3697d64be941a53d4ae8f6a271e4e3fa56b022cc +be173dd892e4502149db328c9372962a08ccfe705a22fbfc89190dd52ac9f939 2a6d97c7907f685ae4b18d31d2ef6ec7099298f6 +be218dbc2fc82105b177a9a07b4e0f615ead9b9be02b13b2a239265812c1e739 8c1460102ab097ef014291e939693cc38daa7e98 +be3a95fe895bbfaa243ae46c89573d9836914465791d41ef6404c14453ad9e2f c51355c1972fbaf3cbb5c7be21939d2f4445e9bd +be7648b598b8c830353f3d8a9da3b434ab4b636edd7c5755171912682061e943 e5d1faefab1bb51f3d0fff2d5e2cfe4fe96a9c22 +be954c7dd99bb22f2730f3c65b8a6ae9d1940cb909cc89e6d83de1aa5ded6946 690624bdfc9dde7d14609ca798b61bbf5fc9e9c1 +bee70212dae887b4181f4c256a008a0509792568c82ce6f78ea5170dc5141b82 58b932645c948010c10a9edb2e7f1f51fc165230 +bf148c977af56b2c4f132adeb987da6eb63b309d7e1755889bd8c17cc9e28520 ecb100a9c8feb1d3bcdd6e13ebd4097eae84be9a +bf278d619d1bd8cb9e47d70df1929ff019a1f6c4d8bbe070628213778238551c 1f798df229a70aaa4ee221ecc0e24025ad92ed9a +bf37e4ecb48fa5813c8c587c13b1dbf65c9de2278ca1093b02d241bd148aa36b bb2bad2a2f6cf5dca3d3157b68112ef9cd0c5817 +bf409f1aa76256282ebf1a7cc6c9f4220be9ffc47b2cc42248fcc5cbb67bce1f 30c62a2d5a8d644f1311d4f7fe3f6a788e4c8188 +bf543f7bbd00b73f6ab1cd8203c5279ee3c319705580525916a86f2916a5cbe2 a0d9ac96c359e218d35b6faff16e63ff6271f1bc +bf575bb55d3a86838a50d8c74f46cb4f00515f36e639a1c169ade92eb7ed5822 82324ac1a5ec79069877ed5d807c87762a16ed9d +bf66badfda7b5d2157db65c5310cfdc4e904d7d5da57ac5abe17542de612f856 8f0c4b543f4bb6eb1518ecfc3d4699e43108d393 +bfa3b3b9a161d354e2254a444b12c412210e9689c17e51bfc318ce4bb4360f19 2d59075e0681f540482d4f6223a68e0fef790bc7 +bfb8433faf78ecf75ed9fc3bd8a717827bc186db50e525ec46ad318d6182f91a 0a7ee40d31baff4e6d9b302446547e53bdd08b64 +bfbe326cc9d9fd4dc3904de4c9fb919194f3215baff612b6d3f403e2522fe163 8382cd353101c0963d5f401bbbeab5f6e0248f07 +bfc0ee6fe04854c11011539f38cc6b9b73e0c445bac2008de2fb877123efc2e3 e044baa468a1c74f9f9da36805445f6888358b49 +bfcc4074ac517ed24d61b0aaa96359f304c3dc97e95f336269ed474ea846ada5 5d0f8f7891e872d284beef38254882dc879b2602 +bfde5e9939f87db0b49bb0ad5303c14d555a32b2db03dc63218af87fc9ae7cbd d7a09674532ffc0bda73e7c6e028bb78120c85e6 +c0011465109f2622a12479cb68d0117547513d48254a74c1a905ee88943263c2 e8dc745f5603c43ab9d69e790ba6d600f24d108d +c06ee60e4559ac134deab08997476c059b4baf28973f75ac00310f9c0c0df532 e8abd2f25c5cfb7e6f296699f1bc120a78bcb7ba +c07142deecd175549344fbf31f3987ff54e6fdd013b15d502e83f67edee4be4c 67df18d487d28edf3fbd965836f212f7edd2fa6c +c09c5282575731a965aa96bc17770d001552a22577cd80110737c2889a2b4833 4b09231a1e78cfc8e19477c2302ab80b689cb8cf +c0abe8f37fbbea90e1ff3d571c86ea4c6fadfa7f7f12a4a712c821b065f2b0a5 a0a6eea81880dcc9841f68766351df223be95f1c +c0b3f002ab7ed5b861ba27d5566f8d54ce86ae8e3f0d7039eebf52941a164e0a 0867c7b57704e5c98cbf67d46df03dfd549cb0b0 +c0c38ad9820923073ff986beaedb4daf3217b3028e48622bca80411442ef6047 629bac23f626ff2f0aff71580b3f46742643b14c +c0f1323124d0f0a45ad1511ff43041f766fe110e56d0b063d41deaa9f443b61f 5fac2a68ae5bcead128415169a68fc21d9e0f038 +c0f85283375a304cb98d2b47d3b0456a10b934bf1f89bc3f80d6c4df2087460d bcc85e9ef60749eb8a4cd9db1c9f7b3b974ff407 +c11677e589c7d737baef01be425cd0c2912b78f6e426f1750a3b7d5cfdb123ee e45535849cb7187e22c9fd11d14e0eb37f5d7dc8 +c123679643c715765e9fe6859d5a5eece56404b03f29266eea7c0e83ae14263a 6d646a4ddbd3c0fa824b193aa83b48b38b48848f +c13a073132718d2674e3aa4bc56a039582e61cedc9e178ef9862588a7f8c7675 5cae6c25279bdd525124b7686d67072059bb0fd5 +c15299caeb002894ed0743a79dfd1cc520d3aa71a2a84e377ed2fd7827096969 1b61137f9a2d6f90f46ea3a7fa7b89b8f839b202 +c159593092a4a8e5c4dfd9ca42fbc98c67ef75060f87b92c4bc677b809be0a80 ca3939e682a3198a3d18f42b7fbf84823312dc61 +c1599569b3f7b5ab531371b6c762c9d578a794e6289a1943f6e6e45ca02ea05d 00f43bfc81fc4ee3a1f92d56808aacfc8089766a +c194ab25a95d8b7d4897515a6fb62a723e809afd7c1039b7a50fcda3c2edb2db 475fe13a56409b64b9ebbcfa1a0e77b27d21d189 +c1f503e2869f51ae5487b9c89dc93892aa92e58dff2cdbf19348056997a17a8d 94c3c71da52ca3d4761c4e9041b384d9bc75ad9b +c223ddc0bf50e860fd0e85b9b4d47b74409106098826fe330a9d98f2e3a8ba7d 1ae06d0bcc8ac256710c81ba92a16a644edbf456 +c223f1b579bad18635efdeffa7a8ff40567d03fa427e08bb90d9878f958d8021 deb106bfd2d36ecf9f0079224c12022201a39ad1 +c23068515ad0d427ea509d3b0a3b2a6c5d6ab433d6531a10da6b7d63ca0d3594 8a3653350f78e3e8e91f2e14747d6dca4b435d8a +c258f010a08328a29cde33411d955520e0375fcbbcc14b7636a70f7536c32ef6 b25fa35b38051e4ae45d4222e795f9df2e43f1d1 +c259153848cb0a2d858dbcbf7b4f40546f2fb60c31421f9726da11953cfea9eb 8997caa24765077a3c3b70deb995819488bceb90 +c268fbe2c4169776699a64bf021f1767ca74c21970090388777465437910c3cd 5ee2fe777c41d9ad9e7eb9fece56fe21f830c5cd +c284394baf0418c32e379cb3bcd5caf190e83e7a8b5056789d800f27be6462aa c5c58a0dad7a0cf18859f29326a0b7a44f23e4ca +c28e313f349b558f23f9b4c7d209d5f0faa3ad79edb8260fb3fb154e5f578905 22bef3bc97a19b18125656bcd77b517680168970 +c2b1f6e286be2959e3725a1d890e178cda1c31116467d5cc0c799825b17c8d74 6a5c2bc91cc42f38753da59a3291a6d9bad0c852 +c2b535bfc3501f0b4e179d5d6f0e2cea613940fa3813be5923db7e71e190849f e00e46abe4c542e17c8bc83d72cf5be8018d7b0e +c2c43938f901a6206679cf488e48f38742c36dd7bee0e027fc298093b88d9cf2 b3106cd34a7b69d2d3b3913415423bb2c45701f2 +c3055d62611a3247b1863e5b5955ebd263d8b8e3367d8efe283bfe0462b4db1d 19d13c65e11f45c3be6666c6c4c9732c6f4ab40a +c30d06fd49797e3135652d654db0de122dd83f8400df1c7a0e95ca3720defb0d c073337a4dd7276931b4b3fdbc3f0040e9441793 +c31ec989f2f75e339b9b7b106d5c1f5386197bd4bb16140fa8e0305e03ced1d7 5b7487bee63e7f5cb6ea1d9090d52ae631296cd8 +c339c838d5d21d9c6c6e4b7efede56c1580e7e957b5da395cee2f689f108709c d3cf2a0e30b4d3ab11340efb3d9af75e61b7de8b +c3f4fedca384b7225c7bbecd31c52d6158b1ee4872d0a85fce2d44ad357a6b3c 581dc350d5e699a9428caaf6a59fca78709f4bbe +c436565f09dca3e9556afa41fcc79ecb57c448a462d6c310df86b8b35d5fb604 43bb43402ea3fdb9ed6b4aa82876c38f46d1eb72 +c494dee1d03eddaa9eb923ea640f07f660eecb9661499495899c1601b885c2cc 81d3ab652c6af3483f72ed93b089edb999e7d140 +c4b306fe1f9564616cf048af4e566ea7b404ad069c972ef433d21469dd93056e 4caa8962a6af9fac72ab81afb03779bc3acff910 +c4fb0a710b3cafe7f8f43319d72d308a678c12cebf0682860b1035352cb5d4cc 2ba363e5885997c504921f8c8f7278a97fbe753a +c51ca339b4668e4ff289c3e9ed3f6c11de42c85e2c5491fcecdad93432a2b13d b8fce12b6878b56b0d7be4ce7123b4feef44c2c3 +c51eb1e41d61d89ddebdd78357baaec018226bff72a4c9296934b1c48fd785f7 f1b16987ec81874cb9cc3d6a2e7d533c950fa68f +c52bf4d013448d7c53a6598f85de0cfdbd2eb110a058974534ffc27c174a9ff0 92142d22d55a2d449d5c563f6e72d827512cdd49 +c5446a46d4c6637c2f45ce4fa113c64ced344a4eaccd3ecbf2107a85fbe18fd8 47015c6bbd6b6736985a562bf227a989c6340df8 +c564b89940661e3223cd7ded73de0206cfc21827bc0b9bc44e95d411d1df1b0e 01768b00b6b8cf1f5e34f7f416e0d506497cfec8 +c57f2bab01f9798f75e61c27f55a91c743b8d23075728699e84b9280dcaaf900 2812156aaff1a1d7785d56809e8cc6643083ac4c +c5afc2ee84f7b25ef38420d60f97b8906c178cfa90497d9f5ac5d1825b0e0cb3 f76c2592b57baa77423bb382d2e86898992d883e +c5dd7dbd64522fc4b9b92c6a56065eba728d026a8d9274c30ae26cca30525d46 b38ab8c4a1c9e346c9520ff9377be3ca45b62f23 +c5fa0af1a59da387fa8082d801573bdb342bdd59346f7599b5f8e9697dc1f076 89039682651474c6e2bf9abcc02cb71897f8b4e1 +c64531faf49ed50c4fb19066a734fd236e6bfe093efd59596dd7d802fd311d71 02e4e5bb290f13ce81d239c1d590621e2d146671 +c67a633f4eb848ff63a1941b3ca756dd08b5226684821768d918e0d839ccc4ee 833ae912e8d5bd6309a2ebab027b9ce85253587a +c67e84e246ad6aefab06f12ef980425062b46b04a66efe482927dd937b5b76f5 eeeb57b574aa97501bd7f477330a2bca8d1bdfe3 +c6bb20cd7be8c9ff8b9cd6246f5dd2928d2428b6a0b2e38e7012e565bf7d9bae c6ebb4a9404e6cb7ed09f0d775c093f33a82f9b8 +c6e7cde92dc4e7be645bf8ec2b6d2ae9953f7c9ae934cea12fb087a9673629be 64883249d3cbf1db4523d95beceaf0f9f8e6485c +c72158b0050e8c9fb81af7d4265c0cdc389cae3cf235232051eadd50f4c1f931 c4c199245f930c01729a0d7c60dc05d9dfc5f53b +c733169129f390cf971099f88fec9eea3e23de7bedb2c72a0599010d6f9030df 6018dbfa702b818590ae682bf9bbede716ef290e +c76564a8a44e38ab10e01f08b5064779775d050848ca85b41ef2b58cd07fb661 a1c96890e1b1fa314c4b4a3746c86a31e4a9d78b +c76e3695d0e5e27713dc9b34d2e93cbe8a3c780f0c829ebe2fbbc9561fe2b0af 621c87ce34d888782dc907b62eece21f94b951dd +c7aa36af51e9e39744a3d71a524f3228eb0ed8c7816cd863c81daa83bc33394b ecd016dbd912f8176bf9d8ade8b896e0e200ddab +c7b0a7eae7a77dd7a50c57b9221b7955c083c8aa2401b20ab7db4738d93faf88 7b5d9df4c3cff229a132e5684f5e5e7bf6219463 +c7c775e8d426131b0ccf13245977f948f9e6f92f11bcdc748f2e005e8662eb84 84f7ad61f33939cd7bf04d8db04cc9ae7cecd8ed +c7ff2786a6ce3a0531eb2f4ed36456392a5bfe79b2b53e8f55ff987b31058eb1 1e5dd57214dbec1b166c881c1c44c8930923da17 +c85e35eec23dea4089aee7a2dc7f6d937ad7e13c66bdbd7eef37bd6336418609 b10489944b9ead17427551759d180d10203e06ba +c87c2cf84057545f38b55aba1b610af68236dbe0dcd196a81f69a050489572c1 088171c4dcffec240af3df4cfb03580d5bbc2a6e +c9158067646a4f730de9e833b1c57412e5fdbac9391f1d374eacbef4d5906f48 f269af47f67816813da4b4a06935bec131ad7155 +c95f52be90f0078415cd38052e756f4937c8d98dd5404b2833e7d1505744d6dd 89525c4620a1065dd47fd7d3960cc560a289d3ae +c9a1e208a73a83131879e9a986b05691ff7b082a45f79bd840f1b87e3bd34948 7335ffc31f110ce77ba291719841231921dcb17b +c9ae9e3895579effbbee5aa744a268beacd3be882e7306a8361eaffd7de9d89c c16281e3250d7103ad6149960c6918b2ffa459ff +c9dc53358a0d83bee1caae40ee81d752abf4962a9f206702e24a447b766b5bd7 fdbec189efb657c8325962b494875987881a356b +c9ef872fd3e8065a122b989550e08b24e38c91b6598be9d4e8b13cd17f55067f b74eefdaa96e4a781d649d043524fe7620aa7e86 +ca1bf49cb84d97e4e068bb833a4f2f151401bffcd3aad55fdaf496aca3cf7001 1ddf7a3bc63dd2ffbd9438c3b25881de9ac0bff3 +ca2b746be39b1d1ae42925727ddfdc75ba08bc650657647da081931ed1a905fd ce9eddc98909836d71b0cbacbc05951b90880964 +ca31f7336e882a233a2943787c5e94ba024ac9a4f763cb1d9bfd8e63aa7f7269 9f13f7d0a9402c681f91dc590cf7b5470e6a77d2 +ca3660522468fd1d803bbf34a9c1685a0cbdd1b923528d69e6103955b03d749b 784536a2a4cb6805d0f64821337ea0b4b20daf0a +ca5237cc6b66c598930504f24af69c3011786d0d9aa5d5da2219f2f10bdde3fe 22237f6c06ff14efd3c233debc41b91c3df29514 +ca72a5c3e0c926b9e8abb95d8cd4110646dfd0dc5f2b283d48b781cbe7ac80e3 7b592ecfb272916e95ec2180a02361f23ed1bb37 +ca9468483c7625c1ec1fc8e19a3a2cc3697d9caa3c4d9df9e51d80791658d4ce 70aab459aa2df8f13b828a06976969ba83612f36 +cacc70435c5fd40c4e75ac083c898a5f35105b072d3863bab571cc63b424cdf0 6b7d1f7996feac885365b05637efc5a4e40a0e5f +cb1bb869adbd4a5bf2861b40afacd0f89906ed7f2d2ff4ceefec444f0166373c 0985c00bcf2bc8403f5d0c4957f3c2c8bc2808b4 +cb252a39ce30cd7b6859222db23553977f7805004501de9bf5ce2b5cb05bee7f e25bc23dbed506f090c7b7794568171d992785d0 +cb282e7c15fd8aeb2265cd621f5a228cb33dc84192980ca426cf9ab2a48cb9f0 5b5b025afb0b4c913b4c338a42934a3863bf3644 +cbdba7ee4f46c2afb421f33275c78d6bef60194f81571e5f9b027416872d1efa 7f5dd37769557fb8ce6eb0f82dbca7394eb94fcc +cc360fbcb49b10d8e9b6c5b95564133fd0ca52489f158e37422fc9d6c09a10fb 61650ac5909362f425cb2c1056cbae080c594b24 +cc3d272d457c7e26c5d611923841511a1766bcd58e5be66433698627e6fb3f9d 90bbaa9a809c3a768d873a9cc7d52b4f3bf3d1b9 +cc8a9debdfda8ea2c6c7ff5e0c9b5d63cc23455e53a1653d42f58c1ad34c8db2 cedb2a22e6914c3bbbed90bbedf8fd2095bf5a7d +cc9e079a90406c7642c6177117674d5e542b08b2db88464291eab80ceefd84ea 19970ce5d4f01cf1e0c540623e7ca9cd6e0d9c7e +cc9f9094162658c03f18809a18b701a42499695da0c257c9e85c33abbf55b43f 1137d90e655031d2c56e925d51af666d0eb0b949 +cca7b385bd43a402abd3527290d1acd5f68bcee3f331bafdc389a2b4d1cee92b 48bef82ec4dd52cd440661294e511e4ec183988e +ccafd013fd2ea60aab89c7548df3ef5ec8ec2e7bfb8c1bd50236790fce491c3c 8d330c18a62adc01b16cdd3cf19fde92ef0dafba +ccb5a03da85607c230d111abfa899655d1b00e6529101a40d42f6acb059dff9f d6c93164c249c8000205dd4ec5cbca1b516d487f +cce687695f024952191b9a882f65d6659e2bf75ff6d70311c35d1a17a7a72be3 028ef0de72da1ad4d1b2ee4a125ede81e3f2ebed +cd0eac51035ebff474d4995e000cbf329bb0793da89b81dabab277ee3977140a 6acffa8eb2a20e3391b5f64c961d7176315f1c1f +cd179a62d181b98a8b7e7dbbeae518694d9cb6314a7ed06c67c5c44c64a6bf17 1764376034ce4f4c899f141c121e1be9167d1e83 +cd9398b37060a3710a0ea0125ea12e0fbfff1ad1f5a835ea880ebab058545bee 0428026e2169038ce215dc7a616cf2f85d9833ba +ce00531bf1b7ed6c57f8dd8a02fd86e7f9e961019962d5ad5093fafb7d851888 d74fb65670afa5bd44b5d9b996a2dc8e409d1d92 +ce354c4274883074fbfc8f1db21fd783e76450619fe4c09ccb8234f308c9ca14 095a3d15445daaad79df8ea9edb4c7b78ba2cfa6 +ce3ac8622b4d6f466e837b0c7cff550d040be27d80b941950b3f5515ad66cfcf 523f154de39d4da383a9e790d513d111a68b7c51 +ce55f9f5ab1d799a9ffaa839539af196d13f35677b3d0761b0fe034e764f8d07 1093c8ff4cb78fcf5f79dbbeedcb6e824bd4e253 +ce601c82543fb1fd705d7c45deceabca8dfcd7b1f156aa4cce6a8ad1efe7d61a efaa56ae9705f9dbc24ff0b27daff60c382efb9a +ce82899d44732510ed59ffdf65793e8b87aba085bbe791592648c2e54149e31c 66a0d3e080b950bd021b41e88344b320ff6cd788 +cea0392913fe99400ea093a60cc9bfdf9bbf5595c3b431c19e55e2fc6817edf2 59b80d2729ddb3883b6033165586e4a8ba206e1b +cea8d32b6932211a24dda86e4f78a7ae9ab96f7473e401a644fd050f3cf98722 238e54bcfff45d477a17cc5a0f51f8ee4bc68bad +cf03eedf2689e76a91a1a230b386e6c9d74167205fe089f44062a96bf7470e89 770de6abbf0bb31fb200f0ea0f86ba2cdafda441 +cf096f21a02aa07d39587714d828e04cd237457a026545866f3fe520ec55646b 3e9e69098af2014a0c3fe9e46cddcb5365dd538b +cf1d995805102eaa9b331c1f6175a3bc900d02712c0136d5eb4994acd628955d 0856dd76baf3d609acb5ffe3b13753cd5a046482 +cf21a1ff89546dc52c6a7d5fcb6d95bdde4210fca4b6fe3e7e61945c09c37ab8 840fb8b7cb13069c2c5f691beb30c8039b384526 +cf329ab6c0737e02eeb28014efc5968aeb023de5ac3bc00f18b254deb46deb0f d6694db21c2f0a7e111ea1b0d9686cadfbd2c7b8 +cf8449d51d5dd28842df865aa457d144e93f12aa1491e553137780ee78f12cc6 1fec05920387b516347793c23c32667b08208fd9 +cf84e5be57f8d5d51f136d3d137b654c602721c469c1b0a58e7e95647a9cf1c0 d07b0f9a8c89f1d9e74dc4fce6421dec5ef8a659 +cf8e9045fd1d957f8010c75d60039bcab5510d34cd0d74ee63d3e5d35c135b6d 28f9832928c52e08c7db5a0d31fde054f51fc475 +cf9d92824b6450da8a2dc21ffe27b92d49b9f4fe7625aef81eb2ffc9023d2d25 60b2b64f87b2e7956a2a1b5cbc5b08ace8140703 +cfaeef6c51a5ff131946932d81b5d0adf3ea351c12c69d11a6ea24c579063914 93bf51fc98691be66471275974cf020974864199 +cfd1c700cc165ffae0f209da9e257bf5a81073b72f99c65b9229ffb7863ce861 54bdf67864a5d9dc16fc548f2748462b3fb63697 +cfdd565f4cbc315760c287d57714852e1a4894eef9c715332fd556f2e114a9f1 bf2fe2acca17d13356ce802ba9dc8343f710dfb7 +d045e845cde8405d26b094b960aea32e0ac01d5822b9e9bed9a62e036e453a1c 6e19d89f34fc5516f5c01542ab0050bf127fabd1 +d04809ed41a6c0d0b713efd6d7e586a7a05287929a296a4b963938c7c01cc317 c545d2d17706399afcf4482163359b03b485fa7c +d048ba2ef4fafa502a44cbc1a50cd58359b9bc243b84a08f541a08ca5f621137 a93f42a5b5e9de40fa645a9ff1e276a021c9542b +d06600e96b3e787b0487b24a3a1ebc255fce0bac6f59d24fcd84814628032faf 56d0888fe6c6144ff623eecb768013569e9458dc +d0665f4f91544ffe89e66d84e7c24b6d87186fbbe3866bdefc5027d8068f1fa3 61950787a1b26ddd5e6f28ccfb381b91c7cf5236 +d088ed0704b46349ee0f8758cb05f1ca5fae4ef74383034d29ecd87b010f6c10 dd95fb53d92f45a9901b5b5e983760a850d98850 +d09b74a21594a6ea4388732a10b7d1d73eae0f94fe3d5f4855fc80444d885372 0c01d80a09b0908856d5494d3c7ac7e6d22f1126 +d0c992aae9cde855b17ac826234a73255ecb09534cdcfa633d90640f6a4324d9 affd84ed8ec7ce67612fe3c12a80f8164b101f6a +d0fc7f52dc42358506e7f3f3be72f5271994abb104b9397ab3e19bb42361504d 53fc32d17276939fc79ed05badaef2db09990016 +d19c2efd2154cd79d3b430619d99438464b038da8540cf407f76119204ab0782 5a646197ed0c131e5326b5fcd95ad88a1fa3f2de +d1a49a45a5f109805fbf478a95715b528644d0e0f10b03dd2dacb4261dbe0094 28cdde6f9faf5a78c048dbc17259f89dd4b26e29 +d1d60af9799c7be57ab4d80713420c9038e360c0164a540247614916996a4af5 3bf9a46136794395a845084011283d07ebc3e958 +d1ddefb4e0093d5a1626d9a1b6757ba2b63a062fbdf2df846f8ed602f2af6166 89b6f61f7b4d3ac809de9427927a8cd515b4bc1e +d1e8c4b8fbda2e1696c9b9ff4e0aa9ed3b7caee2017c01c06525d08e982e2c3b bc23042895607cd8127e5de36f3d330cf20edb57 +d1f527040a42190f2005017fd900e895a77f9f8849deb117f24450a437c27527 749a91d742b7535e1a746ae6708350705e270748 +d1fae456ffe8eac24049a507d590380f8b9e44593bc33e465fcf94be9cc88cee 89cadd27f3c2f56f5c943e55416dab3ee2d4fb40 +d217cd3b30193bf232ef480c7338f40d2abe46d5c104b485edb6e5997e4606cf 383d52d47751e52c11b097d54e14b436bd41ddd8 +d21854ac4b6ae500514b5e6d7874258bb86400934d411ed47345853edc50bdf4 ab3f234e5f33426172ecead8d964b927bb281850 +d252ef75129500a3f78f16cabc6e0a824d4c1bc3e86b9e0a18bad7d389353cc6 7d685c7221b01af31c9808145ccd5a356dc67f27 +d279a299cec8dc4fcfcf8f6bd4c3ec5769628693a3d459f1dde581754c3b2745 d65577e1580cc68402df5827fd9ab4154edc0fe6 +d297d0f4a84ed8d5cbeac8e262906504d1238d59e9bb0adc45699eaf1da67372 199447c2a54e662c9db370c9a6c89219a32f9fc3 +d29c10f22acb667743faf888201a16d5a52dfdd3168c434bc7b6418d24f0bc87 2d38f94e73d3a6df5d650ddc6835d75498437d22 +d2ab425d6092770366bc3dff5276e3a869221bc7b6d22e99c089d556e7eb8331 d01f7573ac34c2f502bd1cf18cde73480c741151 +d36979c8da3118ed133cc999f0d4bb1aac029f59b2a6975893f41ed2d5c97342 a73891d7c5aab19750b0f1999120759e6ab0eb32 +d37ab9a95d602c7979d3dfae35fca327b313836f11e8511e1f29dd3eebe0e5aa 3d1f0e5811ec9f56650e70f8b27acaba9f34e602 +d3834b1c2da88ed1e98a742f7e8f326cd53ab464cbc726887d9cb019eed6ebc2 1a895dd787a5699c21d7925e9cdffa66f23605c4 +d3c2cc39665ee7d8e3f16069e0e27f35813e27c802d5a98be106dda765effd1d 3f541ffa6803066aa2db492a8229e0b35b5862c3 +d3cc02106ea9b78cc5d1ebf609a4931036ae3ff283ced382252ee713ddd5417b 5690f02e87e4fd31dfa9fd7c9c01aba03603cde8 +d3e3ade60c7ad970e4ee6eeab5fded32ee932e29d6dcb3656d7ed3bc9cfbe3ff bc403249eeeb37ce4cf73dc66711c13c5d19639e +d3fa679ce39641a538cc30576fd8980999a6edbebfb8a4ad187dd406e2dc4156 bc874e116fb4e785081344c2ae39aed3bd072288 +d3faee8d75868598e59a88279f0509327844800b54e51fa96283d3c8e3e7578f 6533aadc21270052d8d05835b1e30d8b13a2f164 +d451619d5bee5af825ded81f99b3862ae60fe8b182ff10b72db8d005c173dd6d a7335c5170f4a963c8d67782fa35222d03d8a16b +d455043371b8730cc74f280b64e25183233fdd330acf54ff76526861d513bda5 f92446126451b27205551041c92f5f7f84bf6d99 +d4698b848903dbdef9f5ffcc0496b1c82bcff777107819638591bc5c93fa2942 dba81bc591c332550be284f9414350861b6b066a +d46a8a40c5bba0b053951a958ab021f19eedf8fa4e5a75fe1927d33ca498c973 a920633902d32a6fcba87c729b14e08341bfa097 +d47674eaf38c4547b4a490e5fcfa7d68ca91e8aeed2386942daf07bd1f96ca97 f29249340c11b069e46b70fc145c1d7fbe213b94 +d4923d7b828b897cc6628e6e026fc956a347002f62e1f6f52c022c2c9c664954 418382dff1ffb8bdfba833f4d8bbcde58b1e7f47 +d4fab9558c0aae0a9010ac44434c891492e63358a30960b40e48b0d0e5f70694 9a9e5abd7e7d2ce46fd6dff590360da875b81247 +d4fb1e12bb875235a16a5037ebaa06cca35204c1fa89c9abff02282beb74820b 9655ff12d31716c9049912eb6378a305346652c4 +d4ff08d0ea45b6d8eb47fafd430e2496b132b2a0617b6cd77809eab2612f9823 eab36c05f0ca151dc5732210223d0abc9e9ab321 +d509bbc6e4420c5d0b833045f466b02c02922bc4bee55f91d4b6751eb1a87074 061605020c8f212d696a2a3d28e20c7091c09443 +d509fa76ff5944e25f48c2476736b6239a53f0463cba6ebc488464d087951951 100746511cc45c9f1ad6721c4ef5be49222fee4d +d5473cb18ca962ea72ddc29df047c3fc1aba13e5cef68e600f5563135730b357 7e02841efbb3d464e61bd4dee8d6031afccc6a70 +d58aa1f4d8c35426d90279e0a0b81669fbe25bd200f969fe75440f8022f98ec7 b81dd80e8cb77046b6196a1dec3f8f356307fcfb +d5a9b3e16e2756a30bc62fa92552f73d9d3e02a344f047e3b24ae1392ae90c69 59c513fca0ea668f5c815cfff903279a4e859731 +d5abb2bf61fa4675ce068d8842ac6bcbe7c097d035ed5e79ab83694b92e3b8ae d5ef6a1381ec4cbb9b78979d2ea7c6459a48efa4 +d5c255a2cc319613a97ec8b66dd44e5a8c4d8328a3559840627511c05625b4bb 9514445e534ffb33b50c8752a7c9267e3db3a4bb +d5d0a313ddd0d6d451ce2178da7d7ba19e1f968f3603b80193699ad5a8b51744 068817d917a1c86a5fc33e7925fbee9e2128d648 +d5dee571df1d0b72a7e820d9a08d770561776d044894b626c3ea556cb804b64b ed473e2431c5c013f214e0ee975e3535b6196679 +d6569dea7a2dbf053eb60492f35432622090918137696fd26f01fc69b4dcd67d b32af570d6088f5ec58b08d0f7ad3a74265667f4 +d6a3a68c9c9ac80171333351683d26ca70792679a830155047ca4f85207be32a d4b9769056bc3f7d22860c87fffbe9d4a9065c03 +d6d2e87e6de8690efd26b8c5b58de28dcb3c9bd2b7659eccf34468d71a7a4478 bf55f407d6d9418e51f42ea7a3a6aadf17388349 +d70b0c834e8a1efde1158c15681472b3c7d12da4d1167ed62581e0ca64d184e7 a9e9df3b695e91894be66c30366f0e2bcc73ff96 +d714f59c54cb4bc5a57b9c68b44bf21e2ce63a45f1030baf115ab3c6e7af9709 ef810961d54761c4954df5566da929cba3459561 +d73158b62753ea4eed99124b3dcdc4c873a4ac449204a932b46f46a4da4c4778 8e5a43b2781f75268ca9cbb71993b377cd1d6106 +d79e913b4137117b7f8fc2a8d184373f657d6f71bbeaca0fe83b7757ce486108 def425bf8568b9c1e20879bf5be6f9c52b7361c4 +d7a0fa6d2cc7b83596b51ba9029ee05c553c79eaf3f22298a407c7cbfde61d07 f8588696bcb81e3cf38fc47f2536cf8e25331c7a +d81b2839dc735c3ea774b024636a3f0cb13fe75373e9d1e81365fb1013090e81 89ec4c021467168e5507cf91b712b6873ebe8ade +d88b60d2641df3656381dc8e201abb820a414de03eb63c065b06a2ab37d3f5ca 521d87c1ec3aef9824daf6d96cc0ae3710766d91 +d8bbcaceb334b4a84eae3db74b9201390a13f9cdc2705f5fd68d1c124baf745b 126a72cbe290b3a6a8caf8732e886d3d21c6bed1 +d91051fa024310949c3ea677750d8dded9dd9091ff410826644521c852b15ef6 259ad1a27fc30dc0167d8dd506cb800bd128abc5 +d91df71dc184de6b93ac0d3fced0cdccbdb3f8bedfa433f57aeec533ec657861 65ee31bd49393a45dac5fd1593aba0d332c829f6 +d963a010dcf03c6b21fca8bb99725da1d2443a9dc0a610c5ecbd25f46858a7a2 2bf7e29956df690eb8462a49aa1f8ad9a85047bc +d970d1a6296d149bfb8283b8b4a9a6f7e9ee320c5d46a5ef216e10400df2d281 90d4d2f0fc362beabbbf76b4ffda0828229c198d +d9750ce4daa558910affe057a0a21ff130abafffa5cd3b9bd8857ccff7875543 b370dc5521c2dea03a3d2d1d1209b2691de80323 +d990f65cc071cb0668259dd2f7c1acff8710fe2196fc56e4f43496208ec0edc2 eb7100b307f2c35e7a2d1b05125cb58702da2897 +d9c20b21c4037980a27b4cf716771f1877ccebce89f08b9d07f5b35f4bfff8e4 42281e007e15713713b2ff4324d60360332e194e +da38f65b32fb03ce332e0c4238edae0a733e4cd793d849522bb4e0bdd0af608c 8ef9060a954118a698fc10e20acdc430566a100f +db5ffb15114676bd1246296817d68013ead717c9efd093ffcbbccc805e2b50dd ccb8c44ae6da1b71f65c26324aa39ca35206271b +dbc10ea8c211fef2c138839705ebcf10b6d1261f9af7fb1da206fb8b19050222 bbbf64b0d5c1b962db9d58cadeff78c11bd5c515 +dbd89b614245ebb6f859f64e47f5caccdc93ca05609e83ca5ca2ba478f2d6f31 436cda88b3b747c66549eb0fc0c89d1102f967c1 +dbf3df54acf12a89a09b6f1e7fa9aa29685f419e9a595ec6389181ecd9880bf0 c470e0e0a392d57a681df5d337fd64fbbd9928f2 +dc1d3d6e12bd685f89221ca5051ed749c4ccd59083e2c26d815e6326b8bf8cd7 98822557cf753bf7219fb362c32c9330d35e5f60 +dc8a2c27640a60ce6b6c5424325abfd5d6ca1ee7fcdbf49b7772c107fc0a6cc5 0cf02ff92d5c08516ff2253f59daad1c4c582d8f +dd2e1251481bdf69c7e256ee65ce366ecd4ea43c6aaa61b30bc2d4be17b3fe57 c9280f9f1b0482a337c3250f951431030f9fc91b +dd60b4f51b88aef523ee1cbd6e71b8166b9427c3656cd2d1524cacd9e768e4fb c15648cbd059b92c177586ab1701a167222c7681 +dd6281df774f9e6af8b68a79fbd7c3bb5eab20c85c3385980b8c98141d080c72 36fd65cf283151b18e93dcb5e625fefec79762d9 +dd81a2885ff56d3d275ea52e79809d2c2665fc64949bf3add600d0b19d169f59 2733c6ad2584625f9849e9824927829190fadad1 +dd9b1d5ca653752cef167e034324198971ab6f2f38f3db9db571cb2985759f00 8ed341c55ed4d6f4cdc8bf4f0ca18a08c93f6962 +ddc8a477387d01547a809399b37acb2456faf0b527b5795b3caa5c2d1cd3ecfe 9b3577eda0e6bb13d18a304763b91665575adfd3 +ddcf2e7ae93da5f152a605d82c821b530f88d8f09e5600a09e44e7c89463b3cb 2061cfee59ecd5074bfcc0eac7dc5b3637d290f5 +de11650c5186daa434fa253c05372fc92c34c69af7afdc4137aa62adffe216d5 f9395075e3c7bef6cee2ca5140610896f4855c72 +de82cc04db42cf7ec85c7d6847517ab322ffd81674669fff30b2092c4d10d319 71628d165d4273c15f1ad2320ec382c8f29f566a +deae56ba25b1e1fd5c971fc027ba413e4efebc393c1edab6aa887881d111ce46 21648b45356a49c76d58acf3590bd98ad12b3d58 +deb5d5c69e8ec5f11412724decfcb6913ae501fcecd381350521e3dd30a84cb3 098ac57a13165290bad223e4949fc6f13960b604 +decaff3051968d1f3a2defd3d4a80ced03101555e1fd8913b3544026c0717d4f a65fedf39aefe402d3bb6e24df4d4f5fe4547750 +def8ae3f46a6251e846b25383d6989ff7931be0906da0e6049d25669df260c7e 53495ca95b5d1fb2db527d35e6a8825bea12b51f +df21e6bbf78ab81e603c9a0eb8a3f2c2edc2659101553405ca57f48d13d49773 5189d8ea8bb07be6dbcc0aaae2294f2b1840d335 +df70ff5ce6431e87f4ecb612cf69aee57b2d8c514e51da1728af6e140ad2ef9d 4870103f0d85d833fafcac9f3eea8b17f9151125 +df7592900e9c0c8191e659cdb9b7a02f0eafc08333ca122bb65f90c466993bbf bbb0d9beb03f3f2d2d81c2199525e7b459f1216a +df773ded7bc7739ffa988358979e1ecf8cba729f6eb8234fe48bd3804d909194 5673434fff718d93ac738a03403442f16abeecba +df7c2829b803b4d008d50676565314253dc23a2f8b80a9d2abec2f8fc027e1f1 6a133ac4d1120d3bbf563d61338bbcdfad4b6ebe +df7ca8caf338f34197d9bc1e346c66690321f27dedcef793f2eb8f99976cfd57 9eb7976448bf684dfb41993ef6c76098978ff933 +e01ed58736f8d22949babb858e5b7c9e9e8c6da45f125c92ff74e4ebc30f678f 6c48d15ce6a8b8cc415eacb9192c5a7b93c3dc94 +e0243b96d2d6668ddccbf4e1744c365b8bb828f0edccc3adeed9cee2fcc0718b 11bb049bdddf1d203dfe8fd6031c4dba328a7525 +e08ee0ca30e32a912f051a443280fd3bbcf593f5e23b5c5a60cd40dfb8b31c38 e3805dff27023ffc98b1e8bb5f8e71e613f134f8 +e08ff41efc23feee5e8dadf3d3901ddbd0e80d4f39c1a893a9b1a4ca6e457c2b 24f3b8d8e8c8f3a1b495bac67d0c493d425ab6e3 +e0920162225ac182b02b72a4999007ce63491fcc0d5fb5b130c8ab6ace46d5e9 36b7cdb6a1a2e685c7141406808366d4c4b9f98e +e0c95bbc34c21872d8a284055d1861b542037744cfcec048c261b5dcaf0d8c4b 15f71b9429442ed616b66b986814e94f983d4050 +e0d289871eae81a3c89d3760d65ec61601a007c010a129ee02f3762961389ac5 e96aa1e25e4ad7dab5d397227ba8f14d302bb393 +e0e636769168575a7c6a7f262ab2e3f24d15aef148224a75949b19bec3204555 09b79f8c2ea7aac83efa086f2ee2377b11c4986e +e13a3a7900774366f6927fbd5006c86b97e0c500873120a4ee73fea158b0a0a7 1ae36609fa336f5d3373eedc18f00c4f05194931 +e153a6b70868bf54a33528407abb749a5ec4a278e36ad587585a807439e75792 001d938dbe69b6251f4a03cf374235c72fd0a0d2 +e15e12b19203d0869a45ad94af16bbad57b91dcfd8d70a23291da3eb39d1db70 87a63e99a903a009e04760bc4fdc195ea25922ee +e1853ed6756da2e3c8c3902b9d373d06158e0e42daf8cd1b364059bcf705825c b42f3f731f6709055f7baf5bce3f39881d4c62ac +e1e91e53ba1b4c377a3a86f493517ed6af162dfcd79191cf0c6ed6cd1846eb64 9c3d59f42c90513a69cb72d3680656ecd6fcc309 +e1f458e5f0d9f51709fecc937aa77830d32d5a06c35fb5a71f37beeaeb5e14e5 9e300586fb4dbcd7a7e7592e8bd36bae946bcf61 +e2040ad7e0b914aab16f77a98f629a8df48c3d5c6346c591a5bf0b6bb19cc6b1 d4627ae2e5d2510b641c806f023335206bb4b575 +e207a266e228414023223530eb77c64b10f2f5124f3354deb45aff04c1db98b9 c059510ad1b45ab58390e042d7dee1ac46703854 +e207de850c812ada0f0196143822e6f60237a7de1f189bad75ad55337706ba73 eb1228f46b3c2adf90a4a4f4093dc12434c71bcf +e2199e776f22c6c9a6f60a74711cf168914dddabef1082bb18027baa9d224c0d c6dbfe02ff6359247b49b0bfbd55dbe659a90def +e2b8d0a4730f8678f5c0bf72165f12a58aea0b5bba85405da8e17aa3e4c672ab d7ae061cab626313265730ce7c33203ea371b497 +e305332f5c4735afd3f441fb9fe7c270df8e8cd77ee73e6f9c00c5cb2cd74c5f 66ae897b9fa0efb9ca0097531be2be366c82d125 +e32cf5f9c0e63f632a2e85c2f57b4d74e352d382fd9e449c5660d5f42696b5b9 88db4b005a4f3883f127d8ff0fa39ea7344d5b35 +e3c7bbc5d5fc396e20897c2124898b3601c494e6051e1a5162938d664e872477 5e95e5342bb02f75240eb1b5978246e2f10c2810 +e43f7ff09259618dd58412fa34610db1c46f6b1f11d7e61c74d8ee91f15afee1 c62b80f26a9b4253aab953c3d860d18ee042bd5c +e486f397c337cb2ab4ed93f7e4bdfe0e96eb2f19b4666b4189d60cc961db4d56 40aa5f7bd409d7467369818208e9eeacae39523f +e488ea88853da32feb570d822cd2458bb7b525f7c946d5956967ea6c2ebde4d5 6a10662131e014c3753a6490644428760fbf1c9a +e4891afff0042d2e3ec44f05b0c973d9bac7bff295b053b614f62377aebb4014 ab9c9b9ee553fd11f9f6d5534e09337c769904d8 +e4cb9e225a817b0f5695fc52c0ce05860a23b345e8338987c7038fd68b46747f 8dfd652805e877abaca7383ad28d8eaa5b9a7e04 +e50daa85ddf947a33ee311516011a786e12a1e5cd1b9b60fe34fcff79af97c6e 0703e6ccf92d6f62c552c7be1af34bfc45fafe34 +e51625cf3375b401cb07f27c258fbe0deed231836136c72670c9beb02f022b52 a45b803b8bc607c1d8fe2ad0f559359574231548 +e51d1f186aaa3e81f6545e45e30138f520f9cddac17f121e3a6dfff5f4286185 d9bb4c3ba46cf7de51761352c7b04a2d49633bcd +e5714ecc9e216d2d23e0c9265aeb7f94917f5445a06e988f40677020a557c1b4 ff7c7576aad8b6d87100eb1a62c0bfcdd6e24e01 +e5a8af67e6a6ef9eab9989c16c19bfeb1503a4d9b3c2100e6a98d07155b0c16f 789527fb457255cc90b2b79dab55b67023c7b8d2 +e5dd60bc585584073807044262f8c611f3c23cbba01562c81ceeb7a046226b28 2e3e1ba4b6f21a028ff2d8f17febfe22fe93afe3 +e5ea38108d603a6ed8dbb0b8455abe6d971f2d60920207e67ba646d267ece305 6f4e2c42d9138bfbf3e0f908f1308828cc6f2178 +e60d23fb634bb7ba008578d69619ecb715555c539e5e1a09995c9fc1a2fc8f89 4324de04e80f5cee8a6d8d72ae7eff4a7d7e632e +e625f75b91fa95253eeb059ff3a4329509939b2af57d406ca6eadbd385441136 6d8e93b8384392ca44be9693c850dfa04b9469af +e64b4ef0c042862ed0071ccc2b2dc8766392d69a1c69ddf9f6e04f61b79bf424 f8ed08a88d6f982e040feeeb2240fec0b5e4b151 +e64ee640eb592c7f2d9592b700c416b96e395d114c13752555ac220d850bc739 2b1ad31b77c1c1e9de3af7863e3916f2fcbdd1ee +e6ffc310d72a72943da3796f9716d5bf6ec72c477eba5d55cd44b542ed50bb8c 2cdc4544233b503a5aff7dd1baa4ba8743fef7ab +e702c3dc4fc84a70aa440a441e905982e17e8c5bf0bdfb58ccf6862ddfe02d2f 963dd0fe0fdb9581df0159efeff615de0771709f +e71ffd37f2119fcce2a02248cfc164238040138822152ce6c8959b35486036ef 06d2a40e85256ae9426dcf3847b0384c547c2252 +e7481fdba48ca2efe4928cbd4a631e313450ec901be85092bfc2428544ea7dfb 1fd98a61779c499739cbc3f34f351eb40d3cb4ee +e7675558e5b9b4a8f0eb006d18979a6019cc8493836ad5b7f06ca75acce29892 02f498e4bb85187f9fbc0b0e2eee06d5c9c27a0d +e77505da06f70c52541f5c07441cf6205da770f7a4fee730757d12962172b93b ed10f7124a75cec05081b751801b6a0a0e42e56c +e77be3b1ba3bd6211b30953bbcb31b52e8c0ac0c68f89ed62bc708caa489cd2d f89099c671ed8df50e040b7a62989b451366d084 +e84639624a2e2f2f89bd215bf640e61374cc0f3385b646d0d59a85bd7baafd62 c770eeb29c9c95d27b9df2d30b6f47d62e78d07b +e85c03d559c7b05c4b6ed5b796dd42a5d018e9f3cfcfdd4645a110e3695f32d6 5071d53225a4dad9e07bd0c9f04a45d0948bad06 +e86d64b9d11cfd3d2a06196fcb3785d0b716500d06b1daba9f582a0368c78b27 0617d6a892682a5d4b4081a759f84ad57b28c577 +e8965fae4238a25fba359135d62087dd0e7fccbae626d5004601b6e9c50461f8 0e7fa1fe6837a46fad03e7fa9a3df0815364982d +e8a865ff7fc36bb0f8cc2460fd7b2977189b5b6144c69e14500d5478cbc9ad6d a79612435aa5b1996ff8ab70e789c8864e55ad00 +e8bbf40ee280bc43b33c04df2250903b75e92f2497e91759cf1cad753c23be6c fc58168adf502d0c0ef614c3111a7038fc8c09c8 +e8dcc2ca3e4e882fb1a824c72543408d014ceaaa04f0657432baab8ee69e1195 8d762aafd2108c0f4fee8133dd2213e3658c66af +e8ef4c26d3c9ea277e490ff6e7d270093e14dbd1c01a3f9d78dc972bac88d87c 46fccbd742b48fecb83be48e16885b86bb299027 +e8fd9ef5c4543a16e74c80cd9bbee3e2b387072a14c7bc653e8f96864b7a4bfe d1adf1be64991ef9c94d836d8075f232b73b640f +e91c29c398d4ba343251bf45e859ee4820c2e5cabef1148565809bfeaf000f5f 2e997a35970424b1d6a6de26f5182898c6bcb1f2 +e92d166df3d560dde2087eb6bb14e2951618a37fced2fba2cce748ea2e159382 a651bba3601c34d3ea21c2cd5b898fad29854433 +e9570c71d360e851fd1945be15a2c4875ebeeba9d9dca7848b72c0e35a562bb0 6457fa0a84176ab4efb565b64170dff4175d68b9 +e986254345a65c0b48ecb229c1f47d9c7b8c03b1dd8cf6cf5bb6a877efac7086 97ba57f428e6d74fdbbe4144b8c9bb46b9ba5315 +e9b7c2531cbe327ebf55552276f330835034014be5e5d603b9f1e1ee5dc28465 9285c652cadce66ec115e1b079648e64a9bf0c67 +e9b83772d89c5948ee301059939d6c37f803e5f6055894a2d169715421d3f0ab 5fc06ac83625f97d0b03000c4c224aa86c3a350f +e9ba6f1e38d419a6e3e66a8859ab291f70cc042192866fe0f0c76229f7acf18d 498bc0906810bd43c6fbc73385fecb7f2d04be3a +ea2ec997ce482c0d1d2b83f7e5bb6c3ec634c2018b8dd4e4a67cb3a108bf1f57 3a2aabdce127a367aa27a4c27025199230e26c15 +ea462d69e697a2d9c70e2445739290c6a4a2d649561c0544f5bb027f9a90248b 58b0cbea74c160c61ec70768568e150c4d31f633 +ea926306b1bab6d3f25f45609907eb6dff91a1460b25e63bf4a0494c70e7a269 9fcf811e00fa469688943a9152c16d4ee90fb9a9 +eacf702e5d2a14313d65279dfe65a9d1be0188107a3cbe5573b268cebe483876 1eea99f3a439dfa65fc9d86f7fb4bc2338fd7dc0 +eb128916f9450004d9468de8c8458ded8db58ba01fbf36201aa16f7255269e30 bc4153d7a1038ee96648f97f75aff45c22501412 +eb38ab81898b34d0060be1e38fffc4e04545dc24ab8aa517550d801e1d98865b 798d19706dbf082766df35d66087d40b1a685a7d +eb61f971c9c8dceec3dfe54fbedbaa9a07e2ebbb0cd44fc38617431fa213ea44 aeef9c0679084b1a3048b81831d4ef3d9d7eb10f +ebb24827556f1cfccf502c909626674796e7e1e1cfd08ca430f3490e9f1622f2 e6fe30dc427d63dde4107715ec219c92a017c864 +ebd4e93650254bfaeae56dbe5ba868427274f867d5d859e406f5981f3ce454f9 4df1521318774135d66161a37fd1a06423d0dc7d +ebead5965196dfaeab52b1a5d92b78e54493fdaa78f72268d4cc69b61d5feee1 1f67fc4386b2d171e0d21be1c447e12660561f9b +ec05ea37ad15fbda3b72d3de3cddfd82b411da97a4dd5dea9bd4c5be71f2fdbf 89528ef257ac5bd32f4980146df41872732ba2ac +ec0afa8e0f8d3f924ae29e9ce6e314f06a3327a596763e7c0afea13c6deff8d3 2066aa3e804f6344b131387e17e64dd20df24cf8 +ec0e609764571fd852ef82c0f2272fd4940fc593dfa28a1a2aa4118f764babd0 f5121b1e6ac7f7e40c08e5c072c05a936d6237c6 +ec12fa9a4f7c288ea3ca253b0cde3250f01f2420de8da0e882e15f7c1e875d3d 2c09181f38234634e478130191323c7f74958c33 +ec1866b39026366e69ab8e167c15312c27f5eda4c0afdf9367ac3d76f56bf8e7 4e7e9f60b7e2049b7f5697daf133161a18ef688f +ec21b1d718a46155b66932c5ea66255e651ff00131904f5c15b13e278ed394ab ee3f1ebf8ca0d0bb7040a888fcefc14873cc1484 +ec9d0c0503395aba37c14bad6f94e30773413e51f4c4192f637be5079922e9b8 37334566347064df74299d0479ba44ee7cd844e4 +ecbf01d97e2c2d6c04e428632edbfe9b67dbbc2f22967c35610d634f8534ece2 838bceb4b87e6a65042f955c90fdc809b34ba3ba +ecc250a19bce5bb071ba73708879b69c8d93cc655ba47964873087260da82532 872ad88d663eb6eac5365bd64f0d2ed2820b2017 +ed1002021629a4a96d2d53168633fd4bec45fc52a4dc3514d09becfb1f4846d1 52121c9b19c8a7625126766102b2a8145c1c0632 +ed10f9520d5f0d6bbd9c467ed83a239df0cba94ae9031602e02f6ad6256c459e 4fc3874b118752e40de556b1c3e7b4a9f1737d00 +ed41f28b6dec2c88eb9b4825a1ec79f770ddd524ff8e8c8dc117697cd8f3f039 1f3ae5e22cbbd99f678fddf3eb1a86726cbca831 +ed994d1acd346cb201da40004ad4f59cd42270537a086298c89f81873ed078d5 0fa9bc03e0832bd0e4f9b9a4735a3301bb37a8d7 +edf6e0dbfaf8a7ad89b05b5768981eeedd7a2bda4b1d0fae07aa2a9d49bb39df 32679a9544d83e5403202c4d5efb61ad02492847 +ee16964dd77360202417cb8e958673a3be107fcb1551a7b71f6985d2102c472e 7c297e8eb9ca1fedca286fb5877353c7356c380d +ee4981c3f6d4d973a1f7d99998848fe4b778ed2762a31cae46f9090bf47aa0e1 a7c182c59414cece10c819989bce3f1247f4eacc +eed74bc11a8f6e68a63c093bcb7b793c3a77b18239d9340a75dd690b4e790dc1 ddc1e625381d4fcb00107f5640030d0dbedcfd0e +eee9bb8a199012d24a2f94bb633930f5bbdd4b59d7aeddd430d7d5b0c0abde4a 960ca1d7799e02b72ca828373c3fff04e2cf0334 +ef08c989d6195b9dbc09f3053b94f642d84925d5d5f3a2dfd28be482d77f1d97 3aa9ebb63e642246946ca397c8498df46fe6db0a +ef461668dec669ddde121af3bfcc11f173be86c4fee529001cc95e22ead79a2b 8e9e1e4f95e44ecfc1230a91036257ccbefe605b +ef5dd9207c9041337f20818723f4baa003a8e0e55646ca726a62b4e7f831583c e3c672819ce10dd2207fd8df6a52eade74f00996 +ef9f17d60e921db4ae02169736de6f4da6b6ea76cf3419ca30494fbe2a40f0ac 77bad856f6306f1c1243ce0f4e363477205d3cbb +efc4b8fd4b0b2586fce256b107ee2a052d11d26f99d85ce0478c3d49d1b2186b 8edc2805f1f11b63e44bf81f4557f8b473612b69 +f00a3d864ac7cc74bfc0d238ba10b171fe7b6f5f2dbe7aa08ea07f99865bafd2 5bcc94ea49a378e97626436c5b28be17b54eeac6 +f02b8fcaa64271d82d9021dfea900a09fd74997a61c21642da82fee6e6b20f21 f3687dc858ea475e3691834bf4ec00a2fe8c3b27 +f039acbef00c0dffe624ad124760b27a085358a81f9ddfc071a2eb2e44035097 5841342a0a9453dca640dc53d2ea18ed70409c86 +f043d8f788777ec076d2e6072c36ecebc8772847e7effbd7fb04256181ea1e65 f09aecf46ef68bfb4da47e593082805ebc644d5a +f08cad6328b43e133362254e1468ead13b1a5f39a22d45fd956a90a0a860b401 32db4c9153f750f183f5f6a11e4a1e5f093a739a +f09899f54bb2a1feee2a205c24b5c2e9ffad5ead4fe15b2f21285ae0c973ec60 18f4b6b56c084ab586170cc47e5f8d55ffe1add5 +f0a7a226654089b999b5c92b34d304a9a7c7c874a6484b2437909a6dd225e382 a4f863af4d0055126435eb01278940aaf727d2b3 +f0b7aba704d8816667f0465022228bbd93ec18502f1ba75d0e4105c49ddf1a99 0b30644f7cc496eaceba0130713c7be51021bd72 +f1982fbf726534f88311eb2eac67ebb828c10bbedbe596ddb956413b5e9e1f17 4033d6b8cb15107abc2288b64f405d595f4d68f1 +f1b2af9976ce14a31b39e96b27b97a72606393c5f87c500b933795959fbc5122 9bdb75947178f72df30314d66bc9bcc90df643d7 +f1d8da2c2039b56e385ff2f76f1f2585b5d708ef1b8b5527f253a335ada68d83 88ccfe32b8a8455a7d6e709666494c33c7387050 +f28ac33bebcfce2579b1e8e91bd6749c7b06a7e5825bd6fc2375e3e724f20612 5235041760e8186f96bd757bfa378ce5adc90b4b +f2a108f86a3b4fd9ad75ed55e9cb3cb46e348fca3b9dba3db64f7c9f64b8a736 944c0f6e4dfa41595e6eb3ceecdb14f50fe18162 +f2b78ab9d3df69f23d3e9a9e03b63a466a06c760c4eead34f90e10187f86acc2 487addc854add2a93bfb25f29cd7a5c2ce3bc40f +f2c8da1a7c2eb49ff25c47441f0b3f387faeddde1b37d0ad2f3f6a63f5327978 bd758010071961f28336333bc41e9c64c9a64866 +f2ccc71ac9c89dd36f44b911594484abb969c62f640f9cbf60c853896b6d1d13 93a527ab2bf2555e28fbdfdf31960326c4055d2f +f2d5807c5279cfdfcf302fe93d1ac90025a03a57132ea1d852f80f0ba0a1158e 898dabc73fa99e31f117c366498046cb33c8a24b +f2f432405c8298ed098d704a9590d7f41451b16c834520580fc1270fae0f8b17 bce499af70d434e89c9a110374f1b7c6dd3621df +f31459efb9367c5a19c9dd24c75107423d5773066922ea5e55eaeb6490979562 75057dd4114e74cca1d750d0aee1647c903cb60a +f32ab793f10b04cea82cb3bda32a0b9595b5f69ca89608f88d3572914de6f720 feb1bd8ab25180e447be9862c852a45143e98375 +f34224f82528a95407c2202f0340d08ce68435c02c440932d4a098ace60907cb 022d8b4e47f1ee40270ad3beafaeb5c025ea1b76 +f355aa3c4819d7e2e235e2638c11eefff5ea1872c2304889bee6e843da7a382b 3d40a87326d25342300fb50d78744671440c5408 +f362826c827aa3bcbeb3ff8b71bba08d7440b89ab53fe95d61b8922d01f46e28 e0743ad4031231e71700abdc6fdbe94f189d20e5 +f3c7b2b4491f7edb2150c74d063ef6f49c81ed818d8b447215f3b6c3f6091cbd ea59a210dbab63d18bbb616fc27087d68dc59777 +f4076ec94766226a8ee1d52c84ffe070d8d58cfa111e845bfc7e3e99e314f19f 43288a0733c1dc0a506a1e45087bb7f9bd87d047 +f430e24c70cbfe819b5f201e3ebc34a3dad712ceb08ee4f13fd8bd07a6fa6d44 ea28d017cc7a2b9a329dec6bd91236f5424d72b6 +f47bbbbe82207974769ce35769b74de8abc56d4770efca4a2cb755d55c150390 6a840ebc2b332a23243a5590965eefaeeb460bcb +f47e3b2db30186f550ec8c5c0182409514e10cdd3e66a936e0ce57349df8eddf bf05bcbabc31dc7627bccd33535c5bcc6be2498e +f47ffce6447e860dd48eefbbd7aacc7aca083eefbf2df94f9b96113c58c08206 ed8ab62f1be3062011dbb3c6033952e4657abd94 +f54e47e3fb25c0fdedf1a58eae2aafa499f95c821b702623778455cbe8cba53b 2e85427e16f2823de8324bb47d07f6f78a38746c +f5656eab7d016da5fbe176ba06fd46f809e8f3163fc143887055f4dadfd829a2 86726c5a8c1200f732412fd3ec7601f3d2100801 +f5a821e9f70620ad45e86113ee0ee42211caedeb0db3ff3088500dda553c046f 00a27258320f37a893d4c8e52a991997706c730c +f5be968ddbfc5aba6d676304dd513eaf8b5fb877235c1d5b8c76e8a93f24bd0c 5fcb851f4bbff2968e56b9792ce8310a2eb50002 +f5bf0317f8e2f3280613bd0f1574b5d9f2f0760b0335091ed3fabcab327af221 1fd9c75f95b22df3f52a0891dd36d3c18e9fc0d2 +f5c6feab3b2b51d205f6bc4b3d8fa2a8307ea5f61031b711204778104bfdcb4a 61bfa90a8f4300c31966e3309cd2461507b02264 +f5ef3ebcfc8f054e80fd190746057638615b9479d3917b594e00838ae2b69890 7b7d17f9b6bcb21de339efa2e1ffdef5f15cc5d3 +f5f86c720ab7d820ae97ab3ee2efb1009109a3a54dafb4e986b4f810b7016d21 8c7833b361ef6a4c68d72865bbf312fc3d806ce1 +f63c392c2e03143c9c3b37fdeea26691076a424f336b45bbafe3dcb4537ad29f 129156d84004e59c894c7e273ba9b5824bb9ea0f +f63c4d6eb84809e54f87f531118170c28758305df7888104365e74742cdac390 2ee716e9a389bfbb76261371c1e65348ed1b9a38 +f64b9eec0c8df9ad7a5a2a50b9bbdb9f8da4b55c9f3176cde323aff07de313c8 e2b5e2857b75278155944594c2beee36079b6b1d +f64f370eb4726c47b6c90efe54938119ebc024e49fe07e7eec0207b42827b98b e7ed799defef0499d47c8d8330955ab387ad8852 +f65ec16ed7554295cfdd98a0a5b67c1995c0b7b2a6778c8b36ea2e5b94cc5902 75f541f109d783d298a774cb9f6e1e7891965949 +f6633a3ba290c6e9f4b37ee0d3532e47cdf16cb2a43a7049ff3a3210044e3121 29c52c3a0cda152f11dd39d6217b46f6f246bb40 +f66691f32eb9b23a029b43251bfa994d16481fe97903057e121b76e4e78f6ff4 c01c3fae7251098d7af1b459bcd0786e81d4616d +f66c29d989b01cf3feb6fb2bb7329f8acab284376c3b860f3d7e0fff904c4298 532a2f46e4a8ffc15bb5a13d9a02364197115d63 +f69bc64f14b90aa437c84a4b4d0e4ace3bb8c911a16ea8d77a6ed781c1956a02 9396ec28d49129250ff79463cf588e1a8512984f +f69f3d4f7b8713dbb3e3adf1f64d6b8f88eadb77bf4f358fc28c32c756b5df9f d42c7e287c39463759ee11e4fe7bc9d722e487f6 +f705853cd543d8f69b6e57c3bd580ae4cd8b6ebcac63460fb322e0133cd0dfa9 406ee23fcb2900af9eaaff243f20ec9e07494920 +f718026e4badd0b9b38989a5538a627858e3319cd8b155925f00daff5768c138 7f73f247cd1be8def4d07063ddb72bbb2e6ade45 +f76f10b126720bb7d7577603fb3b54f0cf0ca722fdbc29c924379f4ccff97c14 09197a342b635784bfbaddcf6b8afc01d142f8f1 +f7c7c0e0d32eefee600c90a65bfca1564c643d30451276d3a4085930586db81d 8a086f872a3bb2cf8e437f0e374ea18e5cbaa899 +f7cbb8c92f729f08203f027870bcf2a1a71c94199408c3bc6bb7f06859212989 187613a431e241f9aff9884bfee28c3ca82ae1eb +f7e772589bf8ab335ea3a7bb2c2d8158755e0b2bc08b34d80eaf50d070fe6607 083f644dce33ceb8318ab7f1fcae008d6bae2b7d +f7ee8274a6a3963b96ba1b041f25ff1136cbb2ff07ffe04566f321f02f4099dc 2b8988ea7a90b45116bc4d4101fbdc678c48b410 +f7f06b26124f95366b331eea19be3182ff9dc0ea208ea1de2235e22249683a1e fafedcb78f9bf54e54f0a819ad1461c2ae3b4463 +f82729f2cc042ac51302f20404d9e218148448a3ed6d6c7936b063aa4532eb80 4d5b2a922151ea86d986e012971896622f5d3f77 +f88e32bdeb55ef0690249212cf64c42a4255101a95b74e3dbf78e6ba34f67def ac7c4c450b9a90d66957511688dcddcd011281fd +f8b2eda314c8c39ac692033eade0bc766ca39c8e8c0a40fc0a25c67fcda825da 3a33c7b37f55d5bd30ff944625499e64919b9a9d +f8b45f792840019909fd35f9dcb98082b3bc39373268d467e1b00f1da5ac71e5 cff54d138945ef4de384e9d2759291d0c13ea90a +f8e91f003a1b5b5c5c842f5a27be8f5054c71bbd97ec516d0d8293f4eff40372 160148d67a3f12f0f393e23bc4b7e4e58c0eb921 +f92a00b48199229aedc6c30dc4157eb40b364efc1d843f91b67fe7113681ecb3 5130f2343aa863e7f17ddc0c65f71a993b061a07 +f979948512aa2fcdcad17b3fb76c3cbb196f28f88af5aecb1c29b2f2bbfa51a1 ca9840588d1718b996d4e0987b2caee0931e92f2 +f99100a033a521b0bb725db49ff10e6f27bf21ee6a18c3bfdfce294a3c70eb93 d4043ee9d97031e94f205110996d2381dd26c540 +f9bc81246e5d5f703bc5cfcf7dc637f1ac952dfbb4ece2f84d68d84e1bef99ff 713417dfe4608035e6615918b57a6edd78a3955f +f9e46cd8f3f9eba5b9530820893f31ec9b135df075cde7e1331ec1834616a405 29a61a7f86f3703914b82d1d06b1c6e2775c684d +fa2a467607e74eeb7d2865994f8a105837ad47c7f34d930a219544a187899dae 4428dfb78da0d5cb229763c8ff3278f6f4ee5bfc +fa2ded3190944dfaf1a56eee66b9e298edc098aa834ed57952f04771f7ad5f45 de141d4bb983dad861835e181e7ecd5692a58aba +fa50bed23c21de9e38ae6492dda179c028b9b618cfffec62311cd8e52bd90a12 d0f0c327029d770d1b10efc7a6c93080ed7d6844 +fa6a2b7e588e57115d2772c0d5250d886757404fc510a5956be8de4926e94c01 4f1355c91100d12f9e7202f91b245df0c110867c +fa9b280330449aaf7fbd9709144d458cd54593a29045c6562a840a8580a80554 8cc293419bf3b5eaf51c8a90f3a1a86c2b415121 +faa7ca59426e17f6b34fa407d06cd634faaabeb4abe26df12296e05a17c98eef bfe05675d4e8f6b59d50932add8790f1a06b10ee +fafc05a1d0b7614ba32f428eb52f3439ffbfed9a817e5ae069364cfc3fa3e4d4 fe1ca6bd22b5d8353ce6c2f3aba80805c438a7a5 +fb21dc7e0744c92621f4d94df822be5c275d509431d647c5e1cdd0cee85a57ad 2e7e8953cd4d7bd21729b29e1f7eae3ccf941b20 +fb56a4825bdf67a9ccfaf2d3962c16c49294fb565743f8ef3b3adf6ff721e729 47c31f584e09d79f3674987582a60c7bb6b673c0 +fb74b8e06683d2154d9ca50317e5e3581e1d0dea24229d4aad83ff0296e384bb 44bc212b00ca8cbdcc2751bd48534ee274318445 +fb93630decf348bd577c39423a6905f7f119e371eb098d0199e888fbee4154fe 0be51ee21b376c8848207ef5608aa7b3798d5020 +fbb6481c1ce45e504fe1233d0aaf228384b9739908d69d753da9fa7baffdb64a bc5aba43f785c144c9b5c6406ffbce6a7fec5304 +fbc60a067b3286e1547e78c5d195099580125b2b80e8e44716a313a4ebb66e6f 7a3b12fc4fb66960d4660e3e24af873bc07ac932 +fbc712543e696976405b7a070164abf6ac7f379b66f74dc2538563d4380a2004 7a6cf8153799563464d6f1761e55352c327b4122 +fc2157d0df676f018ad7a001a8150b8c5cae4313e50a69021f90cc82d8c0366d f9e43c1b9b200572edf0dbf333184151db14b711 +fc36ce993654a9c2f2ba5944b90d9fbb8b52bf3e45da4efcff1b137812573e63 8ba79944d51268d80b65372d508cf4d0ba239a4d +fc7d032290d1d7af6b021e29f190d7a534aa3a31ecd9fd72e4a246ba7dc13e96 edc21d065b345f6af9ab4c3f07acc3f137436b27 +fc899c4e3fd5e61b944f9a9d4bc143888a80f4a11836024d441d0fef00cd355d 75636f4771c5ccf864814b83431ab7cebb091506 +fcc409c956764fbd4904916ec1a1dfb00ad9492ad11aa85fc272b94ff2412517 427c5e85811a8c7062c2c4621342e4e9c445817d +fcfa61e2c38f220b1cf11a62ae7f6120b699c6f4fcdc0b0e02d31cfc2f1550f4 661900993cf98d9854e4d9c8584ae215e1eba148 +fd21b90bdf88489115886ad6a66f842e4b3b99f2c47c74f107a3012206a0975d dd583895e15b6ddbcca3ee7e8a1f7d8b39c25d1e +fd6ab50ef7201a166b711edd386b9649ea052562bbab8a09ae5714f5f9c5a24d c215be4120385fc5f358e8a0609c94f6998184e7 +fd77de19e02087045739e074b6368724fd41d66a3e196b96c4092efc76b9a325 f83b69a6538188e9dad0b6dc09e5476bf36c9a1e +fdf50c9b7119e7018b4a2f5c3235802104674e7d467f86608c7fee73c22321df b2bc567f25e3e07d0d6d55fab16f33423d863107 +fdf78aeb5b52940bbb069a7e2ae5495b1e77fcf4f9bb699bbe2b8372526bd3b3 b31b32f52231610f4e8c2c98e1ba5834b323555d +fe191677f9b0be2d6232dffe0d8cf68edec0106e1c57efb1f084205ab56389b4 88bb8fe275f64c587e9d2f960cffa059d2b76fb7 +fe20b68ee605e6b7aeed310d188b6b597f7c184dc10166f645a683d77bdcfd7a 03770969aa16f40d4192c733408f152fc17b1f19 +fe9a766dd36f1a877fcec8eedede85556ff031d42678699c5350ee9117498a28 339a0ed36a822ace408b5084f8e3bc3e63b868aa +fea0d6a630e0c517db1c57ab26a4229f48ac0cb61563777509633198bb60eadf a5274d8192aca15b24b1c7ddcba42726f5418ea4 +feae789c354caab8c9f38b38e18c04c41d7381d402eab1ca87befdeb5fa62539 65654b679591001c402b3925a31ea80f9e083969 +fec50a36447cf7f413ee48757b0f3d80322f3939d984556bda46600139cb5a89 0234c186bacb5144ca13f69f0dc9bfcc8ec7a075 +ff04d2f2105e9fc8f103e4b5840b46b3914a317e9c53cf523be81ca59cb5f023 6d34f01ce0ab2a3a198bd43ec250a5062d8e1217 +ff14a5e654a9963042a8183b2c7c356bb52440bc05f62ec193ba77a94c1f5290 bed3229b555ecd18bc7824c3ead7d2372b5f4f5a +ff1854a73752a8779bf1d78e840d85b7e406fcc16a4cb7d1bb6a35bc60da49bb a52aa75b56d579790985af4ade1e73437d50b414 +ff3f1e98e17179dc0503307f2a01732096ea309288c2ceddcf71dbcce290691a fe9d965dc040c687edc1acefeb5a7919b14c6340 +ff503ebb130051b71bc883c83861389f4f4a66ebcfd5c05d5b2a7b805e45e773 143b052f17fbb3ac1310ecdb2bce4a10b9d2821e +ff77a7e762c77408890442669da2a3a6ae2d0f130e8b953ce85edd0b81cb6f5e f7cce7c2d30260da7e0cc04e14ec618b832ce327 +ff77d10d1335090c32371bfb5179f915266de4425afaf4387dfca0bf2f6f98a2 86ff216d8fe665daecde956b38de7ec33b074477 +ffbbfce866283c7571b728f367b998d05b3767cb26600953db1b237b442fc0bd 16a67770b7d8d72317c4b775213c23a8bd74f5e0 +fff5cbc10ffea865d69aba64082ae17479c522e8e0305e678469749282bf0a18 afadc73a392f8cc8e2cc77dd62a7433dd3bafa8c diff --git a/tests/resources/testrepo_256.git/objects/00/404e6179d86039bbc01a925bdc34ccdab778bd1d824f5562aaa319c6c8f045 b/tests/resources/testrepo_256.git/objects/00/404e6179d86039bbc01a925bdc34ccdab778bd1d824f5562aaa319c6c8f045 new file mode 100644 index 0000000000000000000000000000000000000000..8d8d1d8e82826ef293e6194fd62fe58b610a64a9 GIT binary patch literal 267 zcmV+m0rdWO0iBRBP6ROwMXBc$>9zvdiQ_mDLNt_gTp&*D-IdrKG|YL6N#fP{&9f?`+(G`CnaXJ-;gRl4TtnA|jaTt3=n z*F6BD0K$ZVZiHIL+~Lp@3%g0orO)8SWCrd*Y5>rsv~%Ki%}9 zua~EQv7}g#D2Mx550*)%o!$O>zr5OZwD21f4wS62%-3_1h&jb+T9u{~z>%^>08ZHb R5YE?q4eR@e%QrEBc<=pegz5kQ literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/01/18010feb81fe41b9df646d13866742a9070b56fd0ba9ab8dff828fc36c1f78 b/tests/resources/testrepo_256.git/objects/01/18010feb81fe41b9df646d13866742a9070b56fd0ba9ab8dff828fc36c1f78 new file mode 100644 index 00000000000..c7fbd7e9ec8 --- /dev/null +++ b/tests/resources/testrepo_256.git/objects/01/18010feb81fe41b9df646d13866742a9070b56fd0ba9ab8dff828fc36c1f78 @@ -0,0 +1 @@ +x[N0 *t8Bq iP~Gg42zo /k^rfKFO%BI"NdwVeb8vb<\LB6k< UtŖ%Y#SC\c<5~7:<Ξ:n3&Wl7S>KktkҦ_ \ No newline at end of file diff --git a/tests/resources/testrepo_256.git/objects/02/df938cfb169b0b6ba0dd16acdd727ea9364f7d48c55afed2f7dd889804065b b/tests/resources/testrepo_256.git/objects/02/df938cfb169b0b6ba0dd16acdd727ea9364f7d48c55afed2f7dd889804065b new file mode 100644 index 0000000000000000000000000000000000000000..cdfafaca76c5125ec895dd2db23dacb7deb81805 GIT binary patch literal 103 zcmV-t0GR)H0V^p=O;xb4WH2-^Ff%bx2y%6F@pWY|ej>WVbXmdf7@IP_Uo6IJc=qbL zq|eXzbl+;$b4H&}E1;_Lb5a<#Nl)SGxmmebk0Gq-=z%#(tY)Q;ZmYb?_SQI4`tl&h J1OSNDCE&90Gx`7k literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/05/f7b70a01b0ade8afa5a5fcd19f12cc38faf337d10ec03ef4363d1a86f63750 b/tests/resources/testrepo_256.git/objects/05/f7b70a01b0ade8afa5a5fcd19f12cc38faf337d10ec03ef4363d1a86f63750 new file mode 100644 index 0000000000000000000000000000000000000000..b135eccdafadfd5a8e548e5fd10adbb00a8af34f GIT binary patch literal 21 dcmb003G-2nPTF literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/14/bd335f9d7188c778d44eba8801fe9bda46b66593291f5b9f7cd5f8888af12f b/tests/resources/testrepo_256.git/objects/14/bd335f9d7188c778d44eba8801fe9bda46b66593291f5b9f7cd5f8888af12f new file mode 100644 index 00000000000..58b2d0932a9 --- /dev/null +++ b/tests/resources/testrepo_256.git/objects/14/bd335f9d7188c778d44eba8801fe9bda46b66593291f5b9f7cd5f8888af12f @@ -0,0 +1 @@ +x ̱0 Ԟ#B k‘ j}(^rݫi3g _ܜ8H֍N] }P8Yo;o\Ww  \ No newline at end of file diff --git a/tests/resources/testrepo_256.git/objects/17/9496410f66032c03bd2b7e8ddfc9c8c47820fab5615cc04d904989ce800498 b/tests/resources/testrepo_256.git/objects/17/9496410f66032c03bd2b7e8ddfc9c8c47820fab5615cc04d904989ce800498 new file mode 100644 index 0000000000000000000000000000000000000000..97157644b1b473df7cc6a9233900fe07123c0b02 GIT binary patch literal 64 zcmV-G0Kflu0Rc4t%Kvn7Wn~~VH2^U%Fg7$aATcgeZG}mfxK8yPV&{~SjE literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/19/0a1349522cc11f8682e34acca4ce4e1ea8508dfd77c24cefd461b65cead09e b/tests/resources/testrepo_256.git/objects/19/0a1349522cc11f8682e34acca4ce4e1ea8508dfd77c24cefd461b65cead09e new file mode 100644 index 0000000000000000000000000000000000000000..554d191b3aca70ffde00fcf101d4e9a9875cc1a9 GIT binary patch literal 92 zcmV-i0HgnS0V^p=O;s>AV=y!@Ff%bxFfcbvHcT=xOSUjINisGxv@lIgv@|z2F-}S~ yOSAwoOw27AHcoA~_Bf$(bLz>G#hz97>XR;=ZS4NsQ6BTFNcIU^-(CO?b{=3|pCc*& literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/1b/4b74772bd83ff28bf44cda9be93f4afc2279623bb5b36c9194a660b7623c24 b/tests/resources/testrepo_256.git/objects/1b/4b74772bd83ff28bf44cda9be93f4afc2279623bb5b36c9194a660b7623c24 new file mode 100644 index 0000000000000000000000000000000000000000..d5c518ecc8c721f8632f0bb8ea332f8a97a5497e GIT binary patch literal 236 zcmV_=Q@ zvc^JrmF}Qg=!O7r?zLNUX-aCt6-~5{l4I4ZRZTgp^D02}=TX1{#hFVf*erreuEopX zmDsxD7%`+ZBO8p_oyqEor3M02%1i&Am;Fd@zR#InF5UNQdi?U=@O<9-`^SUt+fzcS mxgjgmbPp9^xwW@vX8dQnyvA{kWJkaHC7tY`)A9qv31^C*IC|Ou literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/21/e1e1ebe45b2c1ef79ab050334e36a8015a546f0740bea4505e10d81a946f61 b/tests/resources/testrepo_256.git/objects/21/e1e1ebe45b2c1ef79ab050334e36a8015a546f0740bea4505e10d81a946f61 new file mode 100644 index 0000000000000000000000000000000000000000..31aa9e5f53d3533a3a8776bb36eae93699a46384 GIT binary patch literal 162 zcmV;T0A2rh0Tqlv4uUWc06q5=dp9B5rPwwx#t(Qi-n(?cDg^@7gx`zF9Og1pLJ!*E zVd9sx1xz%j=&kl*sF99h#|?KJ(7T9yA|cJho+8>>J5M5=#mML^N^Ol%Wt#=sDd$vF z+27*PY2?56vcMy?G8VXnr6f3)Fi!8!wa+09)gE0ylhciLbz|X(gs9a0nO4{d@RenQ QHRX8_*msrs0f5OkO$&%m&j0`b literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/23/8a501cf11a036f2f248008d88e14af624bb07fced6390997a0fa6abdad950a b/tests/resources/testrepo_256.git/objects/23/8a501cf11a036f2f248008d88e14af624bb07fced6390997a0fa6abdad950a new file mode 100644 index 0000000000000000000000000000000000000000..66dc15db4869b30415e10f5559c83bd21e1cc737 GIT binary patch literal 143 zcmV;A0C4|!0V^p=O;s>7GGj0_FfcPQQ83XfsVHGMvvq;(iZJ#=1{Vca|LU9;dT|3^ zs-}RH!xjCk)2ws<&o?mu0)=FTDBZA`{}!8tZ_!@aqqM!Vd)0!si&z)QtiQAU!B21Y x-LoO;Qc@W#_e&k>IsC&}d-?fyr?UV5oyGsmvBGyp?4#HG;oCzkG66E(I?6KoNm2j+ literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/26/149bf1ac4612f24b532ae50a12b15f26aace3718749624f008bde68670352a b/tests/resources/testrepo_256.git/objects/26/149bf1ac4612f24b532ae50a12b15f26aace3718749624f008bde68670352a new file mode 100644 index 0000000000000000000000000000000000000000..bee6a42d79b08c80d27f1ff7f4f95189f55eb8fa GIT binary patch literal 202 zcmV;*05$)30d>z&N(3~>FKgs_E z!mZY07>DpMx`cxEQtzPe1=EZwDosY5K@}CF97|2nW9;RP@0Itze E*nhHQlK=n! literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/2d/b6069c27ca4c08b784048644c307e17d0afe29b55f6488398cb59f13feb2f2 b/tests/resources/testrepo_256.git/objects/2d/b6069c27ca4c08b784048644c307e17d0afe29b55f6488398cb59f13feb2f2 new file mode 100644 index 0000000000000000000000000000000000000000..3dfd5463ba9d6f8014964d36504bcb9b30ea3e74 GIT binary patch literal 238 zcmV5HexU|FfcPQQ3!H%bn$g%Fn%Js!*p4}?iiagzF#cHYk2nR zx}?v~_;lZD)^kRmPb*9efIuNJi9xw5K<1+qbH2Vx1ILX%k@ZR58|u$pv*et<;8)h( zwNtsE#wHad<|Svur)B1(>XlTKFibnx&oupUFXNX@x6a;MqB`qUwr1jM4yC<1JoX8i z%nYtjZF#BXVCA{-mnQD!Pj~T~x!O}-`s1Jbv8On1ZSwhS_#jYl%lU(gp~~}fQW&;L oPvPphS-Dt`A*|`>fjLU7W~GmAtGvqg);Lr8@*u|q05@b{udX9}%>V!Z literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/33/e415b835a670bb5c3c760efa0433ac0cbd2d44679f68f2df3a9ae7014cf2a8 b/tests/resources/testrepo_256.git/objects/33/e415b835a670bb5c3c760efa0433ac0cbd2d44679f68f2df3a9ae7014cf2a8 new file mode 100644 index 0000000000000000000000000000000000000000..cedb2a22e6914c3bbbed90bbedf8fd2095bf5a7d GIT binary patch literal 19 acmb-^#&K@VmFECanOevRMB$i#Rc`n6$Pz)g@z MiOzronCJc{NQdPt6aWAK literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/3b/58565ee067f13349cd4f89aa396d10f71c69e168d5c48ea23de59734ec3ab1 b/tests/resources/testrepo_256.git/objects/3b/58565ee067f13349cd4f89aa396d10f71c69e168d5c48ea23de59734ec3ab1 new file mode 100644 index 0000000000000000000000000000000000000000..1b299dc257b712a486bb7ec5bd07720d88001374 GIT binary patch literal 38 ucmbxW_q!r`tZ֬t=?~V1fT \ No newline at end of file diff --git a/tests/resources/testrepo_256.git/objects/47/3a0f4c3be8a93681a267e3b1e9a7dcda1185436fe141f7749120a303721813 b/tests/resources/testrepo_256.git/objects/47/3a0f4c3be8a93681a267e3b1e9a7dcda1185436fe141f7749120a303721813 new file mode 100644 index 0000000000000000000000000000000000000000..711223894375fe1186ac5bfffdc48fb1fa1e65cc GIT binary patch literal 15 WcmbBQQQ6W+Sv9;eTEK4oHX{LN+y0Ic;3tpET3 literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/4d/f8ed86acaac5dc82b5652170996ce459d39e3a441e9759b635b0bc4ecc43fd b/tests/resources/testrepo_256.git/objects/4d/f8ed86acaac5dc82b5652170996ce459d39e3a441e9759b635b0bc4ecc43fd new file mode 100644 index 0000000000000000000000000000000000000000..8dc1932822c30e3289f0b6a74ce1d27f99fbca04 GIT binary patch literal 57 zcmV-90LK4#0V^p=O;s>4WH2!R0tHJm21zbq&mf(H@@-9zz0NE-=O?!!p!aY2A)ohG P61T;?x-bs_fTI)&EzuSA literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/5a/2d5699fea33657b42ba98c22b7898baaa0eda205a21cafdcb7e0f94b07bb9b b/tests/resources/testrepo_256.git/objects/5a/2d5699fea33657b42ba98c22b7898baaa0eda205a21cafdcb7e0f94b07bb9b new file mode 100644 index 0000000000000000000000000000000000000000..dd993131694c0525737a02638048b52c66a7e051 GIT binary patch literal 64 zcmV-G0Kflu0Rc4t%Kvn7Wn~~VH2^U%Fg7$aATus>cys_Z>cT|@)WkqoWX$sO4SBB@ WgLD>cuFmhj5#sPz(+yzy7#1e#x*6;M literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/5c/a8959deb2b8327458e0344523eb1ddeeef4bce03e35864640b452f84d26848 b/tests/resources/testrepo_256.git/objects/5c/a8959deb2b8327458e0344523eb1ddeeef4bce03e35864640b452f84d26848 new file mode 100644 index 00000000000..39e27c06a34 --- /dev/null +++ b/tests/resources/testrepo_256.git/objects/5c/a8959deb2b8327458e0344523eb1ddeeef4bce03e35864640b452f84d26848 @@ -0,0 +1 @@ +x1N1ERKPqx]#Sp'/}.ơj\1KRP8RDImP!D>p[ˡ0ൕD hSf !@-yZ S>\nS ]ɐClT[#GM|->~Sj־n^uGz?_zۛ.y,b0S ˤ/zQvYvɷ죛~/(jrS \ No newline at end of file diff --git a/tests/resources/testrepo_256.git/objects/5d/bb1fff5c0094b31b25b4635ab9fbee66d65fe5dda47dd0ac5f01dd69a84c6f b/tests/resources/testrepo_256.git/objects/5d/bb1fff5c0094b31b25b4635ab9fbee66d65fe5dda47dd0ac5f01dd69a84c6f new file mode 100644 index 00000000000..17fae64f464 --- /dev/null +++ b/tests/resources/testrepo_256.git/objects/5d/bb1fff5c0094b31b25b4635ab9fbee66d65fe5dda47dd0ac5f01dd69a84c6f @@ -0,0 +1,3 @@ +xuKj1DS !'H.Og3 +96rݶ2> +d=-b5싓dŕĄP(De{+6;>4KĆrLf ,o} >rޖ/N-\W<[`1hǣ =KݮZN/{"?7bW \ No newline at end of file diff --git a/tests/resources/testrepo_256.git/objects/61/489e9e831f1d9001084d39b79f964c293db8620d679ea3596673c8a326446e b/tests/resources/testrepo_256.git/objects/61/489e9e831f1d9001084d39b79f964c293db8620d679ea3596673c8a326446e new file mode 100644 index 0000000000000000000000000000000000000000..0bece845b96b3be7ca7f12ebd967e1764ce64fa8 GIT binary patch literal 157 zcmV;O0Al}m0V^p=O;s>7v0yMXFfcPQQ3!H%bn$g%Shr~IVb&{rX1bqZ?C-q|W%?Vo zv1vWy_7YyrDizns#zlZq1ak~8AdGILV(N-9birXB2On*O+#@yn)LXYVaho%JeP zGx0Tt(q0`N`vgs923M%Iywq~Aa_@sq4IM2{ir(cMHr#0REbn7~n6Kme4WSKw2k&aU L-~1H-4}m~Ae2hy! literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/6d/5fd291bb0f67444e99ab492f1bf1fcdf5dca09dab24cf331e05111b4cfc1a3 b/tests/resources/testrepo_256.git/objects/6d/5fd291bb0f67444e99ab492f1bf1fcdf5dca09dab24cf331e05111b4cfc1a3 new file mode 100644 index 0000000000000000000000000000000000000000..112998d425717bb922ce74e8f6f0f831d8dc4510 GIT binary patch literal 24 gcmbBwx}Rd~@4XFW`Wv>f zX+7ii5?;+J71zneN1>|oQp@#9DoPl<4>~n;v^*(#mvh)~qtUaxkNsi3j_)^wHuxR9 NtMPvGR{&K(Dn}t?GcEuC literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/73/8ff86401dbc5af692c83e660a4d510603c3f36e782a1a32ebd0388db6411ed b/tests/resources/testrepo_256.git/objects/73/8ff86401dbc5af692c83e660a4d510603c3f36e782a1a32ebd0388db6411ed new file mode 100644 index 0000000000000000000000000000000000000000..4c973ea83afb1efa8040be2204a65922df718df6 GIT binary patch literal 181 zcmV;m080OO0iBOAP6ROwMX7U&^hn5d;v|+3+6z!|g4l61Be4t`viIMGBhY-k;=SVA zalP&>8mP{?jXCQ!Je}|U;BMlVp*fLKANE=x! literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/73/b4f3c4f3182e6c8dd2c98aeb2c7811556538e7673e4b325307c71685fbf5b6 b/tests/resources/testrepo_256.git/objects/73/b4f3c4f3182e6c8dd2c98aeb2c7811556538e7673e4b325307c71685fbf5b6 new file mode 100644 index 0000000000000000000000000000000000000000..67b84c462af40737559130399874eeb4b77a3873 GIT binary patch literal 108 zcmV-y0F(cC0V^p=O;xZoW-v4`Ff%bx2y%6F@pWZbw`lHR)+>Bwx}Rd~@4XFW`Wv>f zX+7ii5?;+J71zneN1>|oQp@#9DoPk~<1bCz&7bb#H*>Y8zVydG_hV0S-rD5z+3-Q2 O;Fj|T7Xtu2R4DnfG&Y$4 literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/7e/4633ae1b0e83503dbea4417f9d5ccaf22b877c5a4522b6d1d2b16090ee2f6f b/tests/resources/testrepo_256.git/objects/7e/4633ae1b0e83503dbea4417f9d5ccaf22b877c5a4522b6d1d2b16090ee2f6f new file mode 100644 index 0000000000000000000000000000000000000000..993a62b1637039118d63bec43013bdb924745aa8 GIT binary patch literal 141 zcmV;80CN9$0iBLp3c@fD0R7G>asg$xn`|nG2p+)`sd4(!0hkIsFwuiRDb vbB?*M_O|CAJf;?x_a*msw>ShM1{&F(Apn@e9w#dQv_@suWu43yI6^)tb_75M literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/7e/9424c06052ca33bfc599bccadee60065d8664a9af7648a1455100c4f772e1c b/tests/resources/testrepo_256.git/objects/7e/9424c06052ca33bfc599bccadee60065d8664a9af7648a1455100c4f772e1c new file mode 100644 index 00000000000..70bf64e16bf --- /dev/null +++ b/tests/resources/testrepo_256.git/objects/7e/9424c06052ca33bfc599bccadee60065d8664a9af7648a1455100c4f772e1c @@ -0,0 +1,2 @@ +xAj1 -i,B(](ti2 =~]znxe_ץf]b$a9)yI '2iYTU[fWVa5su,Q +:POCp*)?~'x]6x˹\^žz٩WVbXmdf7@IP_Uo6IJc=qbL zq|eXzbl+;$b4H&}E1;_LQp@#9DoPk~<1bCz&7bb#H*>Y8zVydG_hV0S-rD5z+3-Q2 O;Fj|T7Xtt@NhwLRz&0BI literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/90/1505c3355518bee35475c5d3f23bac1dded688b2bd314cc32b7f157e100724 b/tests/resources/testrepo_256.git/objects/90/1505c3355518bee35475c5d3f23bac1dded688b2bd314cc32b7f157e100724 new file mode 100644 index 00000000000..09d0abfa7b4 --- /dev/null +++ b/tests/resources/testrepo_256.git/objects/90/1505c3355518bee35475c5d3f23bac1dded688b2bd314cc32b7f157e100724 @@ -0,0 +1 @@ +xQJ1 })zM<'HZ7mf`t}yN3?R6BYwJeHR(LḾӎA#8z āPԵ5d(:XH2t_7yۗ]O:grrBp{=Zk ?s?TU \ No newline at end of file diff --git a/tests/resources/testrepo_256.git/objects/93/1093620e5f050e2127fb0b96786ebaa9ee6535fb698ec01b5f7a800fa27cbe b/tests/resources/testrepo_256.git/objects/93/1093620e5f050e2127fb0b96786ebaa9ee6535fb698ec01b5f7a800fa27cbe new file mode 100644 index 0000000000000000000000000000000000000000..70431af8128d71fe97407bd3333bfd6953435891 GIT binary patch literal 137 zcmV;40CxX)0iBLb3c@fDMqTF=vlk?jO#VQ`3%K$GnaPv}EQOlh-|7+Ee7wbb@X5L? zeE{Zs8k;Iaov<*Wb3uZSWkNwqjY7*U2c2qR8xjZ4NK9O~_|jUUrgHcWP2I=5Zt&ks34~NnJYDK-@s& literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/94/ed253efa9e86fc636805c294c441d08b89b455903c0c14e9b16587fec081f5 b/tests/resources/testrepo_256.git/objects/94/ed253efa9e86fc636805c294c441d08b89b455903c0c14e9b16587fec081f5 new file mode 100644 index 0000000000000000000000000000000000000000..41bcd18afbb47ff313b90874fa27decf3a34b5cb GIT binary patch literal 188 zcmV;t07L(H0iBQ0O$0FvMETw-(g4VD5<8I)x*s~A0Vj6Ylh_Mda=P{jE%5i|Nu$xU zaU9p_knw4rW)4t$3Ay#^sZ^*`1ynsrQ)Oh65-4`om|IHHO>qUyxnzhysczqL+HE?v zNFj*%3YJ5Hpw%Qs&%J1BO*&%D%q>Yw3rW4=nuG#o*r{)FpZhr7yFTPp_py)TXWZPY qE&E58&+FXp^`(vD&3WX2M8%VP1_s!cU9YD7x4(@q-F^W(?^Up9reI0hYPWM?<@LE8o(K`PkZiyW2X8cRHOfV>{BnkIcb` X82t2c`iq#_jy^W?S6Y4mjhI&pAZBds literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/9d/aab17c25f647d652c72c8cc3cf4602c270a369beebc7d0b67238897bbc426b b/tests/resources/testrepo_256.git/objects/9d/aab17c25f647d652c72c8cc3cf4602c270a369beebc7d0b67238897bbc426b new file mode 100644 index 00000000000..74b8385edc1 --- /dev/null +++ b/tests/resources/testrepo_256.git/objects/9d/aab17c25f647d652c72c8cc3cf4602c270a369beebc7d0b67238897bbc426b @@ -0,0 +1 @@ +x+)JMU0d040031Qrutue0~"tY2_,kx꺤tjsFO+L @!1A+@sJǍ>I]䜾W޵S&%%għeT0L;4q/M[:Ufk:< Pmy`&OwS_8oml PpTO \ No newline at end of file diff --git a/tests/resources/testrepo_256.git/objects/a4/813ef6708e6011e8187224297e83e4a285f58bf5eabb1db270351388603c95 b/tests/resources/testrepo_256.git/objects/a4/813ef6708e6011e8187224297e83e4a285f58bf5eabb1db270351388603c95 new file mode 100644 index 0000000000000000000000000000000000000000..2419974cbc27d6c1afe3e38ab5a7b41ee67782a9 GIT binary patch literal 244 zcmVj1=F9WRbosttAR+ya|(cx z7H!qI3QFrHv9V~+$!AGYqzQRbni&u${T|DHgb&-t2yctpzJ=$z{f5`;s<+Q4+t-&6 uv7{OkAcaRL0Mkj&XNLc$JH7jH_0SI8YzdcD@2BSyZrj*Th|>?YL2LiRRDL}G literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/ab/ee32b3339d1566d75613ea61f40c14bdfc5b101b60fde4f44b58dd06667640 b/tests/resources/testrepo_256.git/objects/ab/ee32b3339d1566d75613ea61f40c14bdfc5b101b60fde4f44b58dd06667640 new file mode 100644 index 0000000000000000000000000000000000000000..b390250e308a62f1afc44c5f8e99e8196c1949ae GIT binary patch literal 63 zcmV-F0Korv0V^p=O;s>4V=y!@Ff%bx2y%6F@pWY|ej>WVbXmdf7@IP_Uo6IJc=qbL Vq|eXzbl+;$b4H&}D*(}y6gC9)8?68U literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/ae/a29dc305d40e362df25c3fdeed5502fd56b182af01b7740d297a24459333c5 b/tests/resources/testrepo_256.git/objects/ae/a29dc305d40e362df25c3fdeed5502fd56b182af01b7740d297a24459333c5 new file mode 100644 index 0000000000000000000000000000000000000000..18a7f61c29ea8c5c9a48e3b30bead7f058d06293 GIT binary patch literal 26 icmb4W(dj1ELH%b#5{%koD_wmqQt!93`H&goVE$TEmshD literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/b8/3624f6ac0995273c0034a7ab8c68929bdc91b69ad54ef94979b93eba3f6022 b/tests/resources/testrepo_256.git/objects/b8/3624f6ac0995273c0034a7ab8c68929bdc91b69ad54ef94979b93eba3f6022 new file mode 100644 index 0000000000000000000000000000000000000000..3e36331ea660f96ddc6389c51c0b5b04bae31f94 GIT binary patch literal 190 zcmV;v073tF0iBOqN(3j0%EkJD$BPXewzWa z!-|SjiYX>T;Sx)U;<=r*<^V|U%o(URa?V)6q-3Ma8tbC>xs4-y*qAfCZ))QfUVrR& sTt0Wbe!bY(-$G1+k|I$F&maKHNzX^q|Klzi`nVr+3xAd60TLfo5g`3pC;$Ke literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/bd/f2066a28e11603a1af04157ee4aad97814279fe500340eb3465797cbd3be23 b/tests/resources/testrepo_256.git/objects/bd/f2066a28e11603a1af04157ee4aad97814279fe500340eb3465797cbd3be23 new file mode 100644 index 0000000000000000000000000000000000000000..9bb5b623bdbc11a70db482867b5b26d0d7b3215c GIT binary patch literal 23 fcmb4WH2!R0tE{b2HziV+t#c)dZ%e?s$#*+oF|c&=UKVPO^@7W Px?zvs8Rx$M(km5$Qz#fi literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/bf/cc4074ac517ed24d61b0aaa96359f304c3dc97e95f336269ed474ea846ada5 b/tests/resources/testrepo_256.git/objects/bf/cc4074ac517ed24d61b0aaa96359f304c3dc97e95f336269ed474ea846ada5 new file mode 100644 index 0000000000000000000000000000000000000000..be8b99bba80435c6152a727a07b56daeefda6569 GIT binary patch literal 198 zcmV;%06G770V^p=O;s?ouw*baFfcPQQ3!H%bn$g%Fn%Js!*p4}?iiagzF#cHYk2nR zx}?v~_;lZD)^kRmPb*9efIuNJi9xw5K<1+qbH2Vx1ILX%k@ZR58|u$pv*et<;8)h( zwNtsE#wHad<|Svur)B1(>XlTKFibnx&oupUFXNX@x6a;MqB`qUwr1jM4yC<1JoX8i z%nYtjZF#BXVCB{kVQ~-AKN@?U_3vC|nJe&JCi7v&)gyh2Y@bdyd1JK^0G=>TfAl9| Ae*gdg literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/c2/58f010a08328a29cde33411d955520e0375fcbbcc14b7636a70f7536c32ef6 b/tests/resources/testrepo_256.git/objects/c2/58f010a08328a29cde33411d955520e0375fcbbcc14b7636a70f7536c32ef6 new file mode 100644 index 00000000000..9d2ceb1fff9 --- /dev/null +++ b/tests/resources/testrepo_256.git/objects/c2/58f010a08328a29cde33411d955520e0375fcbbcc14b7636a70f7536c32ef6 @@ -0,0 +1,2 @@ +x0D=+nbvK[Jb?x֥փ/I^ P1=%+X5IO6u =V*pD]hvG/H,o r1@eLp +0s>?H!"s}t3,ͳIm3 \ No newline at end of file diff --git a/tests/resources/testrepo_256.git/objects/ca/31f7336e882a233a2943787c5e94ba024ac9a4f763cb1d9bfd8e63aa7f7269 b/tests/resources/testrepo_256.git/objects/ca/31f7336e882a233a2943787c5e94ba024ac9a4f763cb1d9bfd8e63aa7f7269 new file mode 100644 index 0000000000000000000000000000000000000000..cfcdac3069711e3c0e4779477c932e2e4dea8d59 GIT binary patch literal 182 zcmV;n07?IN0iBOAP6ROwMX7U&^hn5#9Vd|x+6z!|f;e_GBe4t`viIMGBhY-k;=SUJ z<9gj!Oaf2qbdTZ_n=+=9MLKjX*PZtCZX kuRjmE{LagMyhS9gML1QC&yWDZ_&c=xA8DX)2hjgc&6D$5qyPW_ literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/cb/282e7c15fd8aeb2265cd621f5a228cb33dc84192980ca426cf9ab2a48cb9f0 b/tests/resources/testrepo_256.git/objects/cb/282e7c15fd8aeb2265cd621f5a228cb33dc84192980ca426cf9ab2a48cb9f0 new file mode 100644 index 0000000000000000000000000000000000000000..77d9ec27d546841923f4d7688b1675af7e8e4d09 GIT binary patch literal 187 zcmV;s07U014!Q&1J`S7%pUi!~ zFHa>stW(ujOsS>X`(UW5qgJUb4eF2>VWG)N3h{_=-}`0|#}?&_IpZ=o@DON9;t+k5QzLE6aaV8>(SExxQ>sxwoCnsxF4}jRtl?nS=|5t literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/cc/b5a03da85607c230d111abfa899655d1b00e6529101a40d42f6acb059dff9f b/tests/resources/testrepo_256.git/objects/cc/b5a03da85607c230d111abfa899655d1b00e6529101a40d42f6acb059dff9f new file mode 100644 index 0000000000000000000000000000000000000000..a67d6e647ccc1f3faad53aa928441dcf66808c42 GIT binary patch literal 21 dcmbtwae_U^_9p60<==wtq&H!0qWh{lmAp z@3$2T<)?Lw5xq!G%^L|QdS~f%8-3dbn}R9Q0Bmk&<*ou<3B4LSp*E>N;aiSzUok6c z#afH@2JWS)BU%^M!Qd!vrBtQ@s+$5CXGS4PT2E&MgFM!C9`VEGTJilVHt+HE$Nu2* jxy$YA#peDNGvvYuR46{Dno>CJ`Dl&*Y(w}3o8?f{IrmoS literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/eb/ead5965196dfaeab52b1a5d92b78e54493fdaa78f72268d4cc69b61d5feee1 b/tests/resources/testrepo_256.git/objects/eb/ead5965196dfaeab52b1a5d92b78e54493fdaa78f72268d4cc69b61d5feee1 new file mode 100644 index 0000000000000000000000000000000000000000..225c45734e0bc525ec231bcba0d6ffd2e335a5d0 GIT binary patch literal 21 dcmb7v0yMXFfcPQQ3!H%bn$g%Shr~IVb&{rX1bqZ?C-q|W%?Vo zv1vWy_7YyrDizns#zlZq1ak~8AdGILV(N-9bi_I_f^(s(Gwyl_2>Xx)=lH!DQc z=RajI;oIyMKK=CNeacX6d8y@K<=zLK8ai5@6urwiY`D?rS>DI~Fki>_8$uiW4&K#x LzxgWw+t)xa*56Lu literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/f2/c8da1a7c2eb49ff25c47441f0b3f387faeddde1b37d0ad2f3f6a63f5327978 b/tests/resources/testrepo_256.git/objects/f2/c8da1a7c2eb49ff25c47441f0b3f387faeddde1b37d0ad2f3f6a63f5327978 new file mode 100644 index 0000000000000000000000000000000000000000..04bf5eb0621c5e6a453ac232bf04198f7a6a04ce GIT binary patch literal 192 zcmV;x06+hD0iBP*ZNo4O0Q>e7TA&4KQIrG}ML*e~3s52%=V3c=6=eOmEA)3b;2zia zb-j%+=lV7dv(UVEf=tpAX49FJv4MzGj;VSC>QQ^mR+GobGgni}WKxJlB~5oZY#RX( z3m~|)f^LMZsxz@-EX7v0yMXFfcPQQ3!H%bn$g%Fn%Js!*p4}?iiagzF#cHYk2nR zx}?v~_;lZD)^kRmPb;9RlZq1ak~8AdGILV(N-9birXB2On*O+#@yn)LXYVaho%JeP zGx0Tt(q0`N`vgs923M%Iywq~A^4$1K6L<5cyZFsq?Wr&Q@z4F(Q=GRp`Fu8f5Gc6i L{K3Tl{;EGa8DLRL literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/pack/pack-b87f1f214098b19ce092afb9ef6e7643653c03e7f91faa27b767e3eb8225f0f6.idx b/tests/resources/testrepo_256.git/objects/pack/pack-b87f1f214098b19ce092afb9ef6e7643653c03e7f91faa27b767e3eb8225f0f6.idx new file mode 100644 index 0000000000000000000000000000000000000000..897e8a478fcd5da84a4faf07f1d47e873809c40c GIT binary patch literal 1336 zcmexg;-AdGz`z8=LlH0n9gPix{4*FaGtgb6ViusDfyAsp`$sY9VZa6qw;_XdTSbe? zt)5tGZM8A@8Pr~PYgJ!anh zD`si9^@YFJi=Vu@&DZ9b?P0GIaKf^6-s!gAVT%eEF>R}PI?XA-h^~1Nyk|gsYf%8$~m*)2`Jr>GVb$z9txX6d+H=mR&5mLJN9RQC) BmmmND literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/pack/pack-b87f1f214098b19ce092afb9ef6e7643653c03e7f91faa27b767e3eb8225f0f6.pack b/tests/resources/testrepo_256.git/objects/pack/pack-b87f1f214098b19ce092afb9ef6e7643653c03e7f91faa27b767e3eb8225f0f6.pack new file mode 100644 index 0000000000000000000000000000000000000000..9c8557886c820187eb37b4d68a70c42aeaccc895 GIT binary patch literal 569 zcmV-90>=GNK|@Ob00062000J-5qO-Pj$uj!F$_lk&nbEVB~6od3bF`$1W%Bpsk`WG zWwzq=9rXtO`*`pk-`w2;wv{6nEG3CkQdEV?l)4M`l%YmOG|C22jVfvL#-^!3PkD}hK!yfe5D3>oHH~qFf%bxNX*MG$w)2I zE2$`9h_qJIzJA~cZ{jp9v!5?#m@w_{_Kt{3a$Qm_CS@pT!EOlAQkp9Tt4u9XNX*MG$w)0y zNXyJgZmc$_QGNGwrE%gjl&=K=s2`2)UmErk_wcRJ)dE3lPA{-pC@ky0#1 zz^TNPz3p7H(DMS}c$`Z$o?r|B1B3xwxPKoZK$x+d;F7Po?{0QOWjq7t`5&q$w`b$) Hf+g_whLjGt literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/pack/pack-e2f07f30db7e480ea84a0e64ee791b9b270067124b2609019b74f33f256f33fa.idx b/tests/resources/testrepo_256.git/objects/pack/pack-e2f07f30db7e480ea84a0e64ee791b9b270067124b2609019b74f33f256f33fa.idx new file mode 100644 index 0000000000000000000000000000000000000000..9e2ec99c546e6de5f8279f1abfc0f254565d625b GIT binary patch literal 66216 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%0D&XxF~7)M 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�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 z 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

    9=o=@S6W*>`s-(zXqsv0npSQxIwyF$! zAQFx+P`qqSK4xO;iprLWC9{+oqPA2~U##HA11}E7JhVIS^kzZllfhBj7z{o4)Kr3k z6A3`*1Ri|{F;X#s{=iTG_a(GnHS+veci@1*^DY8!2FT%#JSL6L2O5nmp!VOMr_skD zgilhq@g|@sE{Uf81 zPv{*IF7bzC

    Vovz`T)T`;Ya#$Z0SHa|PfeI+1{6}s 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�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 z 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

      9=o=@S6W*>`s-(zXqsv0npSQxIwyF$! zAQFx+P`qqSK4xO;iprLWC9{+oqPA2~U##HA11}E7JhVIS^kzZllfhBj7z{o4)Kr3k z6A3`*1Ri|{F;X#s{=iTG_a(GnHS+veci@1*^DY8!2FT%#JSL6L2O5nmp!VOMr_skD zgilhq@g|@sE{Uf81 zPv{*IF7bzC

      Vovz`T)T`;Ya#$Z0SHa|PfeI+1{6}s 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

      =mM5&%b zy3Bb4+v>zb2A2^VotgtvR{I=}`Ni|m+X@8)#bh5y_VFyEgW?SgKc*>hh4e4JBCfua zy_t+%T;y|(y2MZ?Yd4-Jh9ZRpYpYS@YOKP z#zMjrehAbp^VhJ{-D|@9gOk-V1wlPN?NL2tZ!}lidSIXiy={pe?7T`s9MpC96WU~1 zZA}tq`gxNG4OG|R^^C50!cbpPch4T&1tsq>HYm{2VN>ig_@9V20RQ%Hj<~-BNciPf zZ#I<6uP8&a(`<2l0PB?IdIFiL8oC4QKfa$XhrnF^w_RppZ*Ob=o5-tt5CZo^3Zf;n zrA4Q%h*XpmjK z`qg+?I(B$oGAv&jsVLe^ddg@}HVbuuOQJSxam71>*O7NtKlAmvNFZ6-^8(YC7o!yH zwjG!IT=zU5zNs z2>O$mK-<%)-?Q>=xgB1B23r-ni@I8&+> zW^Gs1-Hs&}2OqRnQ>E!{)mlDy>^EX42GN>&R%QupmvLsPFJ`7Y_c4Guy1Re(rcOZQ ze95~3WyTo+P9``&54MX8i;6)^y|bd#|G>r`*<;w&hjj@7BVbYB&;__bV4ktODiC}8 zI%c+W)MMCtT7QVIG)GZ783Y(B>fozJRWbeZj<=3TUD~LdJr_*RQ-YKzK=oP54pz0# zcU2Sv_=`Xo4Tth5@Y0Vb2mMdz;Jw=4NCwX&Gvmisl^MpIM_}u#a<==Hh*!kRQ{D%V zvXUehP}|Gzie8h=*QOfXydABaBYPA?R^Mu4!j#$|TPGMxofI58Ex^|(ICNbz@doXl zwHIJ=@zwQt{X9%1ivugo2cUz5MM4MMEAHBjF&6?Bmsl!E%u5%3lOQN5iiZ~RC-lgS z+09N)2l@9Qn|SHLPXP}KE|w?|TRN)^qh_NddxR370(2CxG2zOe|EhtizXIb68ljgdn9ax>Me;}( z$b91~-fI=o#YqI}ZPB4Sx?T(faG)pxAlqo35Nf-(Z*KiDGH zklMpEEvh+#zHljDPQn%uzO_>f6SHMWPd<5~#1(^S)=dZvdV@rP#Nc{uYjFa(^|7xw zU-DdiA1$&@wq_RTgm9`N=mGQs_YXIhHhae6Q`nZ{o)CfXJHQgIfV+vz5`_j)oprPJ z12Z&rPxp+$s`)5LZH_(R{VP#OIRTrB4QW@8HUn^hE7B=$X`}T*5kO)ZkWlZy2t$`S zv;!gWU*60-lj&<`-%n{%yFvvN#3o_5t%W6702^;)Tq@4JO0tDx?c-JKY78Jp!%Qt) z0@_ZQ_M||~{Vg-<&nH4S3)1aYC?8WYxKml&gX%P@a}uK$!39+I0CYgF%MV*2 zLS&=qeeJ>rY9J~NaFdsRav^@tPY*#4L8~)>@%lK}pMVSTP2DENqr`851$(U*J2yAU zUMYOznj_P%f8U3ZKGfS>`Tq^jvI{a3lQiPg)1&(8)t6wCyREO8?iVdp6A&9TtM?8U zeuACR=Mq`9Mk5I}eHelby9fKGiH9UiV~2(sRMTu%#fD`XWpV9})@zCtJTT2K9W?6j9iCjykq>TZnrMx68MZ^khHQD$@NQcErB2ox^ z>?Msi{l^(KJZfOezs~iVk*g{UPHH-?Zf{uNqHD}Y^h07?Z}=Uh#CooZknkFosm;i= zZBH^CA1|mDu()!tLLd8u1LZpU9YYq=-Q$F4eB;!K<0mL;!KHGeV-n+ZKpIo%cFOq=!(lo% z(UaV&9@IB02pI@4PrBaK?*%v}`|5?UL4^eV0`UsxyH_o#+F7`__5HjoOxg_=`?=3T zqnKpstIKaI-ivF$dGBVJq%bPOJu{H)S6&Whjyb+)wet-hao5?u4UKi^(to|FIXEeD z5R9A$g1lSs2Nz@9aJ|yG9N9Aw{z!eulv%iU|rU`BiPcm$2Yqj>(8I!XEt%dzYG$etg8osxg=OBX1-jAy}95 zTsJ;p(dcb|T~z!RiWxB`W56w*+(MQ$uba+fZdO|t_KwUJb>@%*AM=~yl#27l$xUmH zX_7HY0cqi3VxsZBuVVPtyxBuz`XkQFisQ)QYt>Ux0KU+jVQ`gJ@_V85CDin4w2T^r zf8sT9N}VR8wu?hotYOs|eT#7wGP6Xl%4Ng?DNJWYoFTyk<@jj1{$s1))t(D$U_&Jx zQsBlFj{*|+-95|2{s#mOaC?)Wwfc1qny)kj=YdD(PtgX#^Rva?(PSU3U{ChRI_;wi z-0?Wd{Tr`|kMhp~su|sOPg7q;>zfbQaDAkQJTHsa>!)Skz-H$Y))1D@Y2~~=)X=sg zuE)5Ih#&@4#t;hHJ8S1MR~J0JzK?e-B7183P+LoIaAe%9XJG&qe?yW9asPEhi+E%q z62SVXZj$y1*Gq7&<<6~Di;gP`FGw4Rk9u`{`R&1Wz|eBvKzjb*>;7K6i~{2$sc()J zJp|Vb$^r#bO$xbXYI?fhlLr2RDTMxozmnupcLIzKIv#|)`Hv`MU-DZ8qAcrZ7g6DX z@SwqT0K2j=CpR~ch|~cqtYsI|iI7pMnSEqg>8)U$KhMl7`5Q6{r7V#9gGbD3 zFfJ%Yk>WB?CcDF*fMnsY_Xb1X;S>_;H!_M9DR+$i$m@EhJ?Ip=z{`h;RB*i4Zl-zz zl!~}f(+;q_)i!s035l{Q_D>VbkbN1etcZZH9{Sjs}B6;1>{f7Q^1M;2F;;H zP<*PyW4`v?=pIxVeZFo~*~8=9kHX*(;4_?G^L zN@Qp8Yk@XiE*X;rp$U%h8%i)ptG0$|M^pvp`li#0A7WR=@?D+;CjWzALE$QsnXZ`` zD*&1^O4x_v2dC*mKLw?+x8(=UtB&*;YLpQX3IpXn0UQ>XtSXAg*&)4Z>i!IiKGkmM ziI)>$Vr@Mzx;ugcV;u_Pf*$mnm=_*@Zl#6akMUU~nPs(Y33W_WH+Qiim6NwGu>Ppv zbg<4ziSc4%-a+yMJ(m8Y5xT2-$^87~iKBi{Kd!Zx3f;6B6`+-J)kkl8jrYNmwMECw zuS_)T1=AnuEa>D(mIJthB+wEW=+N*JBMQGs=Ct=S`^7L%ESnwTTCA~;6Dgos@CLKx zUG;MXd`)rGA;Xz$vYmZ>f;uV(=ZlxH1ut5hG^rb9q)^BBoG4}?J+x++}0}9nFVJHt$ zo)xC2X)%xoK1-+(pG-`;_qAtwc&FWpYiX3#v|rQ&+CfP=4rVn|)yi%t1G}tK43*g7@rUlnZ6YfbOPDdd)@KDs40P z*{{P$wXTD_>N~p~LyWv*v`4 zH*dKRPtvN&@aq=f>a~Ejn_Kx_BVhWe_BJj>Sz{_{UQr8z!Vb z+&-bS19C$@@i42` z1ZQV)&TuTN4|$2|AIL?W&Tkct2;n8EyQ_C|)eQ@KJ`YyHZ+z<>^Hyia<{KE4St)GQ zcos#`_gh3qj>cIJU#LQ=!bz0WRh~=P8`Rq($j!Avsk?EG6MQL;>D)PHeR`JYRZ~t1 zk1MoR5mN9r@>?-yIH=CPHq@UVwZO||4$)UPN6mmRS6KNn2hm1if@Oi9Df^UA%ac+E zyGu>$=20WVPIHb)#pu~xmNO1mXvO}L(SV^n%SxED;$ihx+1S-9o=Mks-$6hds(RQj zUoX4oYZ<}1kTX*E@$?4rgOR{~1=+Cs(B2oq4Zb~XM4Ggy-1DG`P>@wvK_{=WL4lsR z$N;?czt`W#>BzY%EbFplp2_QLaXsL1bNfAZIW zFO~(W`A=QJ35=iiBc9~T{V_~Y01k>q#3xeJ(R+Q<6y3nUWaQcNRiWuRP2dnvd?r&y zGl*#m%qYkyp&6c={1OY1t~i&`BOU3I{e(*9_BV4P(N=7L-mSuhR4+ZEx9)qGk=Hb@ z6?=EmNOrjrOdbN`m4P_cEb%(4 zAM>Bbn=O>FU}ATEdA7wwllNHNo?L!fYlXgfd}!k5M%SZJjLs_iUr7$}Vd@zvQ^Xo^ zW-ffahV;82Qy8txgNc5$_IH&#Sr?yQnYu68qeq2`9r&P9iqEedSWAT4Si8 zX=t6WQKc&N-zbTq^hKfrEYD6zbJz!9g zX*2O(^Tx*AhTO(r8)`y~r3v_YE2!+baXZzwm^o`Ush{H2rb%<~lvHNb**bA$=kQj9 zSVr?!#5~GBR&2O}S^i}#>R#PiN+yh>@>=}LZ#riDGC8Fp14kz6O=i7j1I#!oqvtdm ztciV7rB_BS$QOI$QO*+aa}Ey}y_Vfv63sbTuti*~ug14Ye7DtbSik|L;4l0bLi zM#X^g3}&_|cu!cI!o&=rEKBJ(1sI4hK0`SiCJ)*$Cdy?G1FI=wzr6`E-{b{;}{B!sFOFkWY_M1iMU-JeT zWqn8<4)7mZbGIM^rX30Y+DV1!^a)YABP;q9g#0AVG78m;SfeqI`AQ4eT+G7`#mM;W zq$;$LhHs$%%6$Fb_UQi#9gx4O(^KHG zi%>}k^-Jq$IwOzOrHh*an9*Vyw0jjHCjl_Q0TBGxXM^qDXhIn5D@?;m9|Qcxl!4pV zUoh|>v)He6sPea#w-WGOssOoUyj-|_InXXQc?#l7K{>F*)mdr0r;*!YeeoYvBZ|TkCrfw7DD+IgsD6-_8#`f+R z@X}wR8DJqVMTx7KMUcRr!oMr1(|}$Sz+~v6g2{A{q00aPK^1L z6WQc?+O&0##;c5h*)@R@HAQjm5x%@%Qw6IMmV&;5aXD;ZkQ$>*mi?_!j{cWb=;<)d zpn`o@5;5}Hn#?%n;6rH#VJzl?$x+Io?~Q`5>XzqO6satXt}^at@QIT5?UVWgzSu|JxaBC3@_kXz@~aXisG zN{ij`Op|5vJh3kLVi2Q@+(2+Y$t-PQoEOu5(k%YP2(Ij%GQ{#W-G_(8lLP!>zAG05 z>Yvo@_w!{h7m-o4X+I~D9r+PSVvo_3>uhIr8s|h*DsieUd^c&f^i@A1bInPsf?N1o zL}0U}(1dc9NM9bd)Yw+@cfq{{Dm@i?kx{%$plt0cJVN5aV}1Pftw)!*=IOpp0$lbV zOQg;G+Lqft5%1o+ztsHlV2WrZ_b7!HmyHi|{d}jaZPC!`%6xyCc92U~9IDMn)6g9O z#N^_39BGTF+J|Aq{D`t@JfCQCaE!QO78b8 zLM|iaCX_Xi=Pr(Kd64u_iJ8Pe z*N)~zhhtt;#1S9>e*THVNON{o9+1*|Ogcqc_KZXZFVq47;q-&Ebru5{llIisY*$$k zeHuT)q+sS^X~-<_4oHL&-7{*&pwdxC<1iKN>i0Z$sXXbx{*o@;!xtVz{r4>jbDd#ftjrKyy_?rEavQp2bSc%moJ zYm3e6013zJPgh*O_}qK6OKyTCYbsq*czz$f99(|2x|+zk^(ZK2H4(@!BC~_#n_6_q zCy%E@F`)k+0x(RoI-STAMY1^tw>tB6p0i~K!e8*w$ zOLP?$=oESe;vJ^`zGWW=kzG4UC_E+7kHPXt;@797{9q@>jf(?{`w*W)_rq^5w%O$8 ztN8k;;-%yxZWIeg)n^rgtzEFfx~FlFPS5YA2dCr9R_Dkj2pwuB{h~3+D`S;99qVd& zyV=Z`5!A`LouI4c=Z%ZBSJknOSmGRb0BBw&&R^hfQs5x%fs z<>wuvoFo!XC52T}$Q(^>5xqpBU|8F?rK9!CU@QFCQ>@7zmYq+=&}^HHVc$}a@iai7eJLx>=#=Gc&-Sd78g0>5arW?&zLhpbbu{LRn&qMEQ%G>YT?bWVP~! zHIV1TeJs^T$X-5-P!mdQ1~=-xv&SMYdclCAh4~6OqqYRZ+(||UO6pr0YNM?p^jy$U zxsYkJ+ZDM!zFPQb8lvscqWjayvWn~5&9Y&bpX%!1<&CAbmL>*IC}2mG+yJGXjy|Yyd_-zN+V3#0iXp%>!wen{9YK~YR6OcbA+1v zeh;{Hx@H(v@faHn#=RZr-d;${&##@lf-jEa(- zvxYBx6Uzggoi;Of3UlE393p`ZUR1wqkY*?IJ#(DS^rl3N;a)~Qml%p_2dL^KLI>R= zBb%xwY%x01=;x=et1Vea&aB_K85yk$R7fp46kkqXq%cPF$bx ze+Z(2V&7k_=9&*m1+!&(B8!8rZ-!dOXmKd31!Q9Hv?6GNN>*O!M$>YpuVU7W314A2 zxmXf$9J?|NeZx&?GCy7`Y*ve@P$eABmE4VvOdx)*$D-@vk+C@_I=Sv*61q-!H@>S+ zt>E&o;y5e$9vV#JU)wp7;k|41boNri<6K`&_C>cjL9OevtM|#GhFqDv7rf(>M{oTl zkB-V6*yc{kdbj#viCP^maZcvx<^AxuzW67-Ni=%l0%R^cOR#2&uZ!3irr7VWAh%)5 zSlwk_=L}VthHkdSgO}H!G9mtXz~7G6t}qg~l=D8zS%~@HH*&QSh~CH#&{@J5^+%G~ zxQ35N1-RwKf*D?K{fwxz$&(=8g0Tr|+>w>u7kd)A4SCz;)#}}}15)_0$>+V~DF+s1 zPXH%>5#6vA40!v z7YY}bj4q&Zg8U!Xz!eq?N~A8*Q3#mP2elY8x31PrChj_xpi8$rekO0+!hrdU(wY3) zWrTkNdmSZ<_l;OoOFEEf1*F~oPlXB{cn2M7>PYpYN7qsbkDInkC+|$Kp7G>P?2^-) zeNo9c1CSC3OX(AcG!Q^}(Zt9ds;hTk-7UgOp!{G(=Esa$Q~UTbN|VEjMLi=$G8&WVGd6 z@2Q%FVNhJ&oW|AK-ghTyE;5n7!yy-D4!x}pE#TisoBJCgw%tbsfkXi%qZjJ9 zB+JwdZ>nKi#HMi^JS2^m(=ydIDzZ`XZoOt7vzE5^|)<|}F zPGcaczUT_@2Js*pec$3YKVI$#p<_ORzBTFtOI>^qtj;HpNeAMTJrroo)&D=Fy=7FL z-?HwBySux)y9IYA5Fog_26uONcXto&4#6FQySw+wf8TR@_Z@vZXOA9(FML^Ru6NX1 zvue(Ip5GHXP`7beJ4)-al=6WM2<432>?(_)12f**gPRGcMY6m46nv1BtO!|WAl2w- zX4UR*0-G!*F=}%#T=}A%L5e$&lP`x}cZjec5|FQz-H1|+QcB32d8`$=VDQh5G+fX@ zfiMbjp~{$Oo*^YzVNUyjZNx}HJq7GRTz1NW(u>*>rX!EN7|THd7CmVYaWpdp|oNxYgsEnc`Rm)FsBD-=KPQ8xI*~Asu7u+#=m9I0P!DRAD3x@|HxVKGyO;v-&pu%zY0%rt7TjV0 z{Bs0#)N*B6!7>Y|*y;-Adl`Rb%2qwV1V@d2TtjKN0Qz!qo>l+r;_fdN#7Zap2sFLC z39!P~eB+3z8ZS3`_n)VQdM22fb69vb*Ji7nixy#I&kVna=_^accgu*io;wUtvk4dT z5@u9e#t_2C{G%jtu-a%fRz2l#qDp>zs$L|Mjxc&Xml>CjUIsdiAC~ABRpqOL|-V}T>cguPXiW2l&pmAHAnTPT^uqU%reLn>wF18e}M}dQQ znY!bB7j%OJmKU zYlz9XxSW6g@}jOTAj(DgLm^rzNhb<-KLp9^4x@@{x=c%oI6>cfkBc7{ZMDO>5X60+ zMtIHQkj(kcKam_bo+&kiCHY`*#mI93oH^ydQZ3__aa&?xlIO8PKd!SLDTBT4&7)-b z{6Zw|99#@t120&MJ{4N!DY!`0iO3V0zKjjgRM!&=?clI5UuJZ{Ab>PWyDSA#{xD(u z`S^FCE+-Ph_vx~U3K*X3d6E7TGZ}~XjYGECjo{Y;8`>%#1SXeiyDpaOJ%rOicfJ{Y zME+14raO|vc@_Jzw9Lp+TC{=}F9L)9n1qqxAEsQ;1gzAuNsk(7VQa- z7c8|}(bNS9lDL@TXmyTLe5n}WO6)|5y(m6+J;cyfm##Xg-k${GLtX-YTM2U-D``NK zlHhy;AfL^AM)mbBw)v1lUEV4(~oZWYat0Cu@E0* zJ9lmcoq|?$lJ4f+1CY;a>>P1Ez~71y8?GS!cHjdz#?b@H`R5qt|80(+E+awkX0<~T zj7fjCycIs#`%5jBP@5Y}$f#eOXenBu80ZJB+|H;g>bDX0H+xVU{ zoiPy31DMKxdgJyDyg9{5P%5=y^OQe7OWE$kvWYHses$~NCI->ryv^*-joW-WCU|!M zpgqr0vsM8d2z^YvhvV}nB~mncTY`nOggQ~#LpAd>8Sjwy$cglk%^2{$Uv7-=qu0&F zAzs@&u56fIW@}kb&p8W20Mt0YQiX6c^*U*6=mI7k}v#Q*5}Hm_qp-21k1?V6pE>)fVlr-twqs;;vLJGE+5XOsaL}%>u0=xgDtR%1ON=-rpsb0}vnaOWbQ4SF zJI;n*9b)5N9T){SPMMsG)4v1Lm9UgA@!f6b?kyq5{q{moU@M zwtVF&3$pC!t*2}n34p7w+KUPH3@W;D#$$qpL&jd6k(PUFo7}Xc)I+|Bg{_o1Eu%x< zUSKg^T!wf#*lS=;i<$^a661hIZW4w4cDgLmSl2%?Xk;~tRqCBvuh+Sq9Z@UnFYL0Y z=3;?;YmfsKigY2toE`Pk!Fm{;)GG$YBI_P8BqY}+7rTa2m}_0(E}&Wr2?X*2^xZqS z1~wHxfI`Gi8R0MqOWNnQU&OxN2W-^^dL|WvtYqermbX$3q7mEzs8Ix}D&jF0%3rt^ zhT2AU8O78-?S_PTLlqb!*@iPDeg)u)C2egAGI)tMSX~vG_z~d?1f27;0J>}I(6?#Q zD++oMdvK4Pj6F#iwk`kuP^VsExwIj?_P)_isj(6Nl3L7;~pGC-TkZR+Xnv5C>?N zLY##21)F~A?B%n|IYL|{4`1oH6pgxN}nZt}v&F zh0rG?A4xn^s{Nd9r7z~Lh|*?8RU8@4YD{jK<+_mgU}brvoQn?+QAYq#pdkNS~z*yuJQW3gV}*df^uV52m0smu{8q(YrD)_ZPYV#jIYn#m5w`*?dW*P1ms ztivyO_DQqniPwoLeg>@fkCe^Fdd_jock$ykIH>tKtIl${i#(-)9RihF&v%$#jy!C3 zK#Q^88R&N?JsK6etWT5AQz31|1qqBi_4!|a+A&Ym1)J>kRcG96Vk_i{uJ~FfnQg(h zgzxi-3oek~k(<3#LUSuK}XZc*n^ZK4i79h;W-G?X`nNt zaAThNJ!Zlxt+L{0qDDJqgxV?wfPq~NkQRJ-)?kga7bC`igzjF7(yMq*@|AkMZ($GQ zYvflRv6uyJgU(9xs9kUF_!Q6_NWnG8&dvF{}+Y5SeK1k4ZPU|_SeEKS4XEkSa{%-GeGA^Q!yEeUPz z4*bP})>|W59r-(@L(c*^e5k3qkisBRQIh4+rWD1oEMN!te^@ERqeQ*B(N&kR-4lmG zo~3b_){aQJ^B-jY>=%IWF`5hi_pWi8CB3=F(HrEV-WTn1Fgg4bgnz%1w+9ic9>9{f zK1KAQr|h`~|63mlSim23!#`r?0-`x{w~2{Q+`vSC6RiNQL=HgQ`YHR~VE(o*|2dy-3bOQn9^%0$c8~f;5;Tt%<+`PJ_{6kC zBnQsU4&JKQT9T6%R$MGB7bOgr0s=+EHqidWGdx^S{ut$Q=L~!dM8i- z{@2}>6B7#)3%!G}zLAx!t)nr3&sp_q2X!29mWwy%(UpRkPt)>1JIs8u@N>tuEh)?( zR3)Jf1e*xvL>Mu93U=Gw*c@rUSi!z1?xtNjj0+mVH(ry1u?ach1Vo1D%?p$yc4n!@ z5`=*II(Dgut(=GXY~|fyFJJtpSFb?wKTww_g@t=#Z18N#6uUUcN%WZmO7tD;fPC*W zKfSkd^^(2+TIc@_b%FTNkxe4w4h}02I_6l{`wRA=(O<*u4A0 zg1f!taIAxI1OkekfENCb-+1=tat=}0I{%F@cN{um#@=>uZ5|%=i8t4op~B=eo9NpHaamO}s`sti>1&l~?o z9VF^UEjUC*w8u%>B*f5MB_w=*lSG)Ah&oWo!hSxl#sjc~yCNFIE8uQ4iB`A?>pwmh zv_jq#9?_vwje9#=U14L%uj2;{gI5Aqb&(gmfc#Bu1o-+tcpKx(BuvvbYX z#A}1%2jEN4&a5j^@5{PSgCVlOmzbn+CrRT4=(r6vfJ|BS^*i9w3e79qXHe|b0Mcg1 zX)R$bzk0V2M49pm@~0jaoOC{2HA-2Ws&>_p&sJOFIakzD*E|$aMu+a8nM&)?cv@IywkonYfl)TX~Rc>1~ZI4tp6dr!oWa)(R%55U93TGPnXYKfu zW+$Wit6htqg|uZw=-?ZR_IW5jzlP1rKOF05mP8h(ctsQAsagGYNK;-1yOgOm?Wzi4 zfRBelOi|&gRVb7yEZZTyp=ebdsm2?2F1(Ae_)TO*Vv&P;YF2e&?EC#xIBBdPF~m1B zU-3odN>cWlUsEFKnJ?Ic2M_y%J~}PF#g9fM0ZLF)nIv{gTInT{CF&4?-&liO&+{wu z6J7z{wZ?szXNbH-OJ>>BBIfL#h%(&dCk&|}1$cIW0lv}7BKhUv!N-;rgU;lrm%)j7 z=Qj;h6(H~Z-vjo9rkVY5R8ht@oO2o;LA&_5x;FNd6F3BFp~KV4g$6KKqW4VG=5+>2 zyIQOtNQ(qwlP*>>Gs4qQvjH<^VqffklT<_q^u`-{Mq*srCd1;$T^{Y4ap1~fy7cq6 z+~_ptp#jl|2A@^_>H;Qs_+Uzl+UhsHWB3`3;R43OP%!Akk~6nI87c0>n@*p9edEqn zu(p5pU?Kqg=t%9tvPU%Bj+9CdubM5*sJi_Fr8@u%znoTi41B=cn1pziEmn zN}nh;w>vky>MeM$xd~izn6t%Y<_?Bj0=uO|0k=XU%7l~RlQYKaD({v4y6sLnvkg$X6)7fsbWZ!c@Z<;6TkftAFlqx;CCIxW8qxqbq zbWEdL#WQUWY>d|#P#_=9lXM3+Y>K25h94(*>NF(}5@ri3&=oLlP7rNS5qkoo$$Y(~ z$XS+1r|L__fJL;81Bq^};x&zNiz%y*;_U!2$Q$kH}J%;*r^hIm?6y~80($&G?g;Nh&K}sf1Ouan0|piuW^Dg3fC|y9p97V*dk&}`ju{PegKKjW+UKlK2C?aN7DNTFY}ed#E7FV3%?BG;${1jho@6&IX6 zgQzq+LIWJcx4@J$@koL@!h9zFo8BAK>v#FzJEx0=d?>R%ff_s0avBE#d2ZvY{-4YF zckTD^fZM$0ZLV)ih@kN}8+eSYdR$@&dV`C-xnwju6md9W!}sBDkDUc%TG3f(ST9Ae z{#*h#n;V^vq9>B%Jju{wTrJaSRx}$QX&qkW2ogMFm#aGAE)G(@_M) zS=MJAPG67P^?6|Y6TAg;1v=$aDWH)keX)uK&@_W)Q^w+;KNI6f(G%EZLh_5Yd?7B7 zs7e{$*LCJ^wdw|aJ|nv+d-v~5uIKg~cyzU8hgi4ZzgPH>IVTm{og1x?Cd3laex=Nt z?W+!hC2qpbA+9dQjCd6MaDT_`N2tHY_{l4iXRu~(T03d4%J<72;s>p@fOb^1sF#lN z{I&4&Jn&U$F31m!loQp8bq?|xW!u!7z;nq%qujI$U$B7;xxiqV93Jn@t%J(#X_<2# z@^!bOhZ9aMm7zBx;ACHpjJ%ye^GD631IL7h>~@z&Lo!BRx!3pI;iDqn7$-KY2?7O5 z@f3~Ncphi(>sHq+*f<8$dC}97NOU|9Q~9l%g+1YuT7$R3rlsi>pz=sm!)5b~I~_RnJ^%Oc7r3k z%Z7_4=Se+jxRGj16jrW#4XC{>^A!t_KfHBTc*VD042?ydY0>JPu3)N7L{jhDd!eEC z6G<$+;iJ#^qu-}dW4$>wnbywts~p+WW<>O34E$zvShiWC zm*7)d4DR+}O9S?FjLPKiW(dd|6`CF#Ng^EeH>L>s8>(bE)+VWrJaw1@g{$~q=jX^O zO0`8phaNWBq=jwDuGDo9Di&?L*}ow0munn$*UWSeLwSGC>b8nKiE}xHSQ!Wjx_S`l zeBMsLvv9ce$`6~@t{JQl2+f-gCA3(DnqpWFhWwa6;1a|~@|Gw$gZ^?D=)(WSc2hNn z6z0)&+08KYW~VOSASV15suHG=Kr9&zN*_MM00ZjXgZ^&$v)KI)FEZ!K_}{v5gO6e@ z3;)zV?+Ux(NblI6=qfZxo?ooGlz^xuP-_!q6a}1$*uwEV@M~&a=soa9HmU4fzh!b_`q{Q;Ep);;gpXnBq;UaHAdjHC4~C;vdaS%ScCLo z@U|C>LE`ROyNQt2#{-8^6oEkpGpsLgK!chCHIpEu1@h@27>TxE%#XC^z zb&F%k!!Uyv0^jQW{Iz1e!>V!Z*E~QH-IvHOn~SIAyX%(OEF_hMV(6TWVgsZ777FU8 z7@ANfL_t0AlzH6DihL7FTX+K^NiNJl;1o<-fTeZ|MQkhj*paNF$0aV;_A67xb&m!p zY!rGRER$S5k%1SJ;ESzUq>=Ii$2XJ0caZm7$rJ=C!rj)?JU5ovd6tQd!g@$WoOpyw z3n3_6UusvBOfCdWvaNV}g5e1@b5PI5EPie!ynG+m=ANBpe*Gi!-_^w#?FtK)Kf9eB zonEk*fQ4zQD5PbT&56I#?_ziu*c4|{*E7~kc(a!=8o0Gh`bA1{OUwY$EmL6GV&8Nh zjvkr5XI%(q=L}N%2Jh4C*<;4W_IJZ7`ius0v|$KtlHFzUXhqnwkb1$E7j@3m**7DX zvu*rbENhQtYj}uX7x#J4Et4O=x^SG+y;||_Z9M`oECluF2t`2Lw!o{b$n3}Xi}47G zpF_8{nTkgk?uhK{xKIyR@RSuI&>6kovd#5H!a(y66%+<7-f&{8Tg|`KxVO0cc*LPz z6If9R7!I6c8+&7aZh5SOkia0|*#X86^6O)ouyG`WZ5E+M`9@UAh?mXJ5o^i+qZqSUWjU!$j8v#q5GXvD- zmvE$RfKprX%B1*dc}d7zyY%PZ46`Qdy2G#Ty3aL*(z_J zaZt;-sN!DIvzp!w^0rr6g1$2AqWszJ~_RMh`Or_@jjh z1^jE7dnoR0e!M0drwA9qq{$h zcc;Y@KT?^du-a9ll_zU66{QW9)}0&mV5k)bQLtkNc{j^(3X|<)yod36~WLc7)Q7WCqGRU;9*( zp<0_m627)@o~?ANOoVTE$;Q8dT0{d+51H)fIXMUA>;zw1Vcl7|@cw8~o1Ia-CQX#C zoz=|7sRVW|kS_%yj+sOz@5${Y5 zf!NcrzjHIk&`lrYoY>hMqtmI1w=!A+-^(&TQk&o>Oxcb$X_{z;VwXw5StSVJBaBW*BG>;I;VrgUu!Qf- z<63{LF%`~Y=Aip!M)Km#_@cx9!!|ZEsr4P?ZzoWIR`0)!0|9nb294EAY{&ffFM-j= zh!b2d5)7ys_~0+X*Mt_O1)-~9|JYT5Ph#LVbO2@@&eg5|WV;Wm&+xWPNh>HlUPgo< zq99W3I2xM!SWSGF`o)Lz%9EDW42;sJ%d8EqUg)Vcd`iE0PYrI~=?;EYo#`&qI?QM< z74%+u`>OL%?xkJ!_4e`$n| z0HcW*HFBH+{S+QPT$M?d+^vw9l%=Vfl*1|8fGt6w3 zUdk)rTiWaX3dghoZDBU)=gx%N$ibF{Z{UGJnst|=J|wCY1+CCc>0J{v5uX%!xzel7 z`D81L9OZPW)7;w=pcsx&^<)m>ck;Ny-0e|ih?}8CJx=$!YWl!taPqIem~a$pKm$-c z1uXQyq{W}PBJ3@7C1b|*ltCbkYt4JIfzDwg1xi?{j;S2NnJ1crleW>cQ5+zP$F1Ncf}>F?3-H#o2mqyFhhQv8w-Z z&6&14GBu|@p!gmSCGZP2lN-3VQ5zaZiB52q60~t5vRWoWT+7DESpDwp;3bnfl;Qpj z7DXlga7!#7poPa?E1ctW5RAQ;KD*s)bNbXj`3P9Rxtp3ge-JZ$in>ro<0t*>s1p{r z4ynU@(~o2vibyGZ?E4aiF$?y%aO+Qfm}u#Y*y=-bJ5SyjWmB&M!V2yWgYB zxWI%;P|!msn~pH;A>}s{38fahjs*jF2c@HoW}W^mG+yR<#L;XrZ*?K>q{1W1=b<9v zxAr6IqSs=ZqB$%>d}3~UoZ{>6OX!f7kztPkG>x>wxpJp|dQRM8vb(d%NaZ!-n$Rpf zV%0`O#L=slb06`&jS3XcmCD%KRau0LGT45%-oi=(5*iS zTb2qhJ|Sp>8>nimE8Vb1JjtVfMfSvOynzbTj`XGsC>dXhC}RV%(7&+-1Vd3-J`-j! zEwR?;BGZ7yKQUkhT6rjFhn)=0JIE|p;`AMeNSf`mg7?bfh%RqHYsl=fBso%79)pvP zZ2UJ-Faw+H{-`{$@lFCsGp5YKUj;A;vSoP6kLR(KzAqSL@Bzn?AhF6Ipt3mEg1TnT zDbS6`jw&!5%ra6-(@p(an3buL+@GBum6e{RW1gjzJeZvwhujfm2!#Xk*g()}ngvvP zSzomrSH;o1O?(E^awC;+q?%q;arlN(mkYu8Lbdti#w&}^SHqUon&KI)PqsE2eiHey z|Ij2jTgbj#x0NX<-J&dnHKqIQ-)q(N!evicl5lL~2F~Z}kw*S|RBnPa*_Sa5gjhxK z8{RnB=ay}?ao`)L_O&I!^&LU0FFPt-9`ar36)`-v#uw0B8@H1n9LzbgeI1OMfkr8p z;mGHGfLHU}EW~`~Df}@!KokWQuM;3kQ@@kJ^)p0^MmaHFdIW78UDvcPCKa*s@rIE= zY#!{WChfN>1b>9EMFlmg$@tMd^e+z_%QYG%i?GHP{y|cQ5!0-V9sp zsCe2D9CwCK7Z2gIp6}4shN0w$(E&rq9QCGMo-&S@5p$*-Wr;5*G&*uOML+mnH}DAr zH@wM#-9gGh@DwGzFHS6TEwY*M%Kt_w0CS_BS(FUj=etIH)wUhB*jWRd_Lyo z1I%~H41XD%*adzh>NLKqAPI!@e~0c|5=TTmtzg?WfG?=HRY<_zOcKv1mg3B}t|OqzjGkJmm<(rDf6MXdOVL!(lxykFS;Zub86x=AP_(L=WvEg18-FP%7k zf#v?)yt*d>vB9erqN_1MR@DwoqgN22HCocnfr*QK|HTfsC0{LU*L-HXE#U)k{R%Dj`LbX#k z7Lbq{c=si4zwC+_w!TZ1)^dMB5I=flLKG?EK~-3PVt4MC?UYd)miV?rAF!`?%(amQ zp5#Tl7&~uAg;bHf6b9g1fXhj{si^6msd0*>jq@lkgk*!i6aY~G|4MzGRYBja2=RZ+ zv+)lJP7Dc--SHeBRFHW3!b2&3`F^!j2fbKIWy;@3CnHHaR2Qeob)T9twnyOL12scb zadR%{m=a7{F+*$GRMuHnVZU*0fHi4KINY#rB;ZJ^kR^OAAGp@oQnpAYTuZnpdG(nR z8lHv}bgIJKxTWQxQ5;H-$sS%+A)ONM!L8l8tM;B1!)euT0RN4+KtM*d+gRMZVXQMK z`T2KYhDJ$J1Yf%(;vLT7+WONjW@ib1y8m~MGJQL)&28q$Znu^S)Xx}k*yg5u?5N@3 zv-zWJxm3YSdeelU<9RLQB(bz<0_-+Mu9j!mV<&>O_ri62iCDqMeW~&A!A{Is{2ao7 zEO%zl7%R$;pAUslPwtpHkeApTCCDb8Dyn5)%oomFhlVKis-(MU+3AJ5S@B09)C6^j z1|F=^6#QpK)-4G=MX+sq;`K6-{HGy3IZ}Uqz1QKC$`bTSL0vnb3)em)Zy&(v+(BM0 zwBTPehKpMGmSxXsJKg$Y^5J=jL%@ma@Pfz(hy8(3XP!{=Zd9u=e@dlWNtk1JrSwY7 zikVAsBY`BBa>LrJ9TL4vvXdf7%$E%Az@9+n^~OM;{UpHK^6Q}ihq~@+OmT+w1!sT! zWp~xG1GCzeN59P{LGwaa5gKUn8*E<1oZc(Q-|j^KJHWpw;z=7c1ayoTTLc+FlnsZ0 zt;(s?!rGTBVs$-2Y7ET#TmH=FxY?oHzH|K#rV5nDZRUi~)Xe8*X~Cd~b72R*lUXRA zgdOF>RxpggLa|7pXDEM7wp2i=sK)1$&&Ut=1cA8)_k=d+h3u&zsym2IXr}Iq-=A?? zAIA1+f8CwJT4$Pf25N|gIEZM{gx14q8(yzdR1ZD6WfGl{nC!og{37>z(Prh4a^FmH z{h8aLhR_hLCZX-2ud<`DG<8v=sxxSn_XNnK!Gf4(-UzO#7PC+^h;aDV*H(jIB_@#N z?nWOWxm_s~N*qG)GR)U?S8>IW4bsU|$IB6}U4I~EJUA2vQ6z~zy~<37IGAEZoZ?&W zX&c`8?`m+JdseYSKvAIWDoUkI!4N$a?!#lvg7Csyj;MrX6MHWDaRN6p!q>$cwN@qH zz4)I$gu;W^pN+SjGWB24Sy>U*RpAiD!oi0mJR5rC*X>w!C)lC_#KRn*f5uI>FI(`Q zcZ!eK%W8DufaaKN>&k0^5Ildu%+;(*XE#lz-UwMNOcUMdHBznA;jW=kDmfFkU+lbX z7K@cA6XU6*7%p|T4;Z|g&870-%w_@+04`nru%AKcBny3$NnNBLt%<-jT+5rd+F@2q z%VOd(dOwc)NCQ>?I}OMR`Xn^={EnS)BUiNIV6l`qY=gv%=nFC8FoT|wl9O_l1R`Uo zAn|N!&a1A+oE51pBk%C@Ep4syd#Wb%SDt6SN5u;O`gi5s=vCG*yPXu@lnlKembdaC z!sPphW;5ZOe)^@hxO65Q=}BidOP63uJPB1-JQjT&9wC#$(EH%0P`WtWE6A75eV-bo3tPgW2hHUS8S zSFr!V@BBC44OLK8VnMt990eQhmp9`RVw~iIcvaAXAUCynqLh0E?mrdTFUg+_cP}rB zG@|3ZMQ{rN-`YCJcms1|RB@ojbPbR>wMa-O+F$=vSD5C2Df&Cs7j#>cmfzOawlCHz zvCzb9c_PFC$8jqG_EvuE?8yLn;LnZEE`|DiTDD0x!qB^m*HIm```19cKJM=gseS({ ztxW%vR`6Evh@L6_(=E^uW-!1dAO_if%jD1s*Ps0l!4e}r<6!Oj$m0aQgSC0ga-C4_ zI(R}D%C(E^Aojy7f{9LHDJBzJVmcP9d$syQZx(!x8|M0;769Y^%j7=3Jm!2IPz83) zT5A;ko-9mLD)QZ0R8{J(mBBBfphumDy5G>;C|XncNhO~dM8x`nH|xd8?MG_reixxB z)9{OtNq6SeK8Oa#jR-R?1_Q->xuOpuyQybaXz3F*9eIAcy&rUi0A>6502UFZV0Gcn zlt=C}h;vgC#pqvga)5x6>f|!uG-?I9=M>ubT@pw}9lYoL`%Lsibp4UU-w0R+Qk+pD zEqaf%eR*v*3HBWriywKG3Iy4IUqoHM2j%Ku0Q#s3^%Cjv99K~=@ymI7VC1HJ2qptf z6Nld9mhZh3PDpaw7@DO;0J^nCaOx3lT6<7fd+G-1?aqq@x2}|6EI_jnLbe+iDaeS~ zpA^qb#c*Muntf<`c@^2)MdJ@ak|&_WN?6Z(;)NVo>n!`}w`o}rB8D7FXM7DIzJ!@W z!5WB;@TUTcs>jz>u}4=@P!!(vt%Cm2Njo3u*Jh~n+ru1)>kH_PXCVOCf;6mK!s_#L!yOtZLcx0x0{5Ggv0Z@WfAe#Ou!MF*sV;+(9 zOC5#DMa*sL^`;mo#z_uRebR8(NR7CEq_~+qt~^lsozxVw6p*0GKMdC_+WItk(_sU% zrtp67*^KW~rEIF)X<9B00O~J}IxjxOG?PMR<-@Y{VoI zf!X-kvGP^Ts&?flY|v3m*Yv=UBd%m^F=tmo4dacZEs-uk5A0tdu91^Z!+CIjrbgyl z*X~zBqxd`PsPG;cP^+ppXx%o@EEbcgYUCsa#DW7)MF~?!N2{%r9X0Z#yOxieC0ZVr zmM`PX7QvD}NAQF}t)qF~q&nu^&A;YR5&yUK+%-JhL5K}Q}m#O$s(u;jF* z&k>8B#9y4$i}`>vP<&BJ?Y?HNVr~gX4>eN503e1cw)^mF%G)ixD~~;Uw21FP(!)Qp z5iT-uIt@ru^}v4{t%?2+h*$s;deda!YNL$m_DRA0^~h2ik zS!SrIsibgVD1x(Mxf0krP@1WLQLJ)~tBP?B@-i~gtY>_iQ#j{l^_bv*8%@-G1E{5L zl9pl2`wxc)lLNY|vgtUL*7R*I!`z%L=Kw*p>!K^aE zY!qko(OIZ#B~hp9TK5O-e7kZ9>TT%f0m@N={!xP;@44ii5^=e^Gji|EmA1|1J<)Wp z5xEA@IWJJ2Rawbu$xQWV@yVQg_N|7C8TYhFmr5=5#DBl8H-$bkit(3_6oZPrL1q_8 z);T@Jo?2XDy7%Nbu0eL(a&uhUt!H-@c)bp!;CM~{=PipxT?HR~=S0fKKybBlbs^nh zL9d^^=P$KR@&d(`*Z^1lN@epR(8;kVo0PN1vhm19xTR(qXX$HHU@rDV*v(WQbe7m*m(OR?4*V10q?7!&Da89VBX{3(0=Y*u@P#NgzO*joLQ&}Xp)y> z)rZF8=iiv>exEX3@`}}!da2x$+?RvMyDp~s7LFOw)j|Mc&6SvuKd={rdLx+j>T_@l z^0(d|uoaR5t$!Bbq+r)df;G5+eS$P}LVkh*^CW~rQYYNNwk5Q}!X@;>8N5{>z~&48 zw;|sznQ6LF+39gcY2#(ig_4JZGr5-&h@2QP7vs(jt{_v&!?Y<=PAkIdaIcJG6R4T( zjMS|3I^w3cqF{tPQNK)#ax>z;CBigYC5ap!8$z%;eXV$O)iLJ9`!M}_ znTG>W6*BH!$@%l=S~Y6*IMPu~t~e-Fa1~yrdWz6OXZXuch8+Pm*2gH&ISa@al#7_K9=G&V=Y}D-1S1pa_ zGc{DU3SP3^3!}vD%Z2?<)O+$yfj21cuE|tzDO##A6cs(3r4NSRt}AaQeiQpAUUP$( z=GLFZUh7wL3*TdIT;$JXPoTtS%_8&TPLohSI~>;$E0kHmvl(s~wRx`RY-;3T<(q@0 zlq_Dfz_)Rt{G#a@$LN5~H3hd%%jP~k7p>`~RX*E>&W>%SF|!xyiE*mbiEdHk}$;rNaX zXB+4}c~diUq~$5Skbao0)C1{;9^}yptHZ`0Srca&(#$W9zXT zi|cq#M#hnMqF$~tMZ3c>oA2$SCVctZnFZHrEWR7I?V)`Ztij@USO_}JZQ8SW;Wo1bvb+U@)liy)s{xgiBf}BTHY4B()wQkNF&-}gsW>ch$ z>}1_Ywb-cr8%a>vEUo>G6#{ozo+Y`k|HgtEDETR&h53ms(T_|TRw*iZ%Tp*(n-@x| zM4_@Y&iQwwZd@bu&wxNW$K4=3ZifTfd{pgTQ+E360=G9UeYC4fuS zFKr?p1V_)B%!XKb`(;N67m9GfmxTtt$9qP5BHqJST*2E0h&Pa)Ol5y{b!LDjFS!HL z1s(`pIiK8R(ia($voAEAR+1I4EB(9ASEyqZ@vqMi{7IGH^#h_7UIija*sGb|`_SF# z(BnG@7=J8u&VHbazk>X2ycFOszhkkJUaPUax?{}mXp*Hz$Hsv$QLDzQrdam1txt%p z=RMJSFg<>dPshd2rX*4@roJ#j5 zf?ztjtQ1|K@?qg+^_$ZJ#dF(&RGzVc`=J>-lcY7c74> zw_pP;-}Kyab1%MoO9v#wf&SbK5W7dIC@GLIBY7XHPe>W~ipH+bQDj2{&&zSK`5ttn z6ragAOrAG;SabS!Z>E8(D@l1;@XTGl7H>_!xzitgiO(c&rZPSEVXgQPndd64d;K;#Q6)wQ}~-pp?*D^yRTma|^`JNG}#7 zx~FowD%f0y^&{tKfMJIgRjo$B?Rx-7^=?vYy4+{zi~+N|Ra2U)y3i`JL0fv{V82sc zr0t=w)Ak*jfY|m8CR_m(58>3$z^wv7r2bq;jYNGdOV9&ImZjTQ<{8%X9Xa1LpT!wl z0LHJ)_etV-iwRRM&u$kUT>2dtJP zV#l)Jr%~D_U^RM{exBMcA&txN^SqPqJ_K5)D))_d@8sIX-D6?JX{Dl;eujqlNLuHd z|LMfOzcV90Ow5N#B!DHwueiw!g31VLm&zYDT{rpq{S2j03fp^IL|Q-Eh-yVujI0Y0 zU!3br*IWXGxIoS|#J4=$BNo!xg#L^ znzy>cNwmuK6Q;a3CDqJ^#5tk4R!62LM+uCDIB|Z(c4Uiw=Y%nnPo0u5YtwXxr@>a= z>*kl2jxmM@@E1E}>;E{8JJHX7hLTMGIDk3B$UPsk6jvbWT4T&ogN#v{9!3=f{}abs za%dDc5Py$jU<076|D)vbZz{!q&_#bEm;58c_;N*Q^8^y!EUsMb^tcjiJ2j0Q-IgW| z6!7A$T-YI%pPd?#zv1)09V&q!6{ZqOSiz^pXKgNO$@P313qt)E(7g(`amP1um!UD* zLr%T{|J!*B;6wk+ndd|0|AP(u8>6Ga4A>Ne=o|?I1cSP;%$i;WBbfDF=1lBOxp18w z?N`RxE1{(L3}Diqm2!yK{{#4MngGDj6X^3+^`BMK|>TS395veN~ zIoYeE`9G@*vf^aJE?q45W5!zyCZ?$^;d&(0yz&{;*IWP*13dx!cBExosu;@x6Q9+`M zqXoq^Q!ZKt(Vqz^aQaT&>J9_~-lA{N?#gd9(DzH!^*j>QEKraTciHE6*r(RXiz#o` z{?MUFmE~U1gk-2#4`&qBMHe^zL}mLe z>g_Ac-{Kb#l@&m$|HsUvyUC{oB6lGocV$FNNMzP&944L9!DfTL)b6YolNjCoM~r>` z@O$m$siZ2bR!iM1mEdB-opx0QAF&#;oF+@EoqMaU-w>Ec6*X&}M1=JKjqGgh_spEJ z6N$OCKRQXoLcMjJf}xQoKz5Q$bjP$KYd8Mkm!V5UAke{9u)2gYRU5r`Ex6nXS^Q!x z`VV+*Jx+e3n;x*G$Lm`5F`*4^y;3tk<@V_#S0JY3KGgOO+q%vLwO@~NPIg>d`+^B#hntq~R{(<@6U8882CDpxExbe#L-OmE zrDPro8j}{-ZH)a$G)A-Ggk>xPx&Y73+fUahC}m%U$tD$ytExL4zXioax9TYHxScQJ z)F7O}>aqG5dDQNlpt7d89BCoCR*jlb%{u+ygpiV&kyV_#zFxr<_f~CsmGF}k>t$CD zFadyBSi*_5J;An5uz)S#2?wo(4c}wANvCUM#SX^=Z)EKonW_)kMCGuH+cf}Xy99bB z-?Jw`Oii+C$_7B>HK|Y+hBrj(khP9Vgsm4V0!N5ztUU}8Q!3VjS12q(b6@ZK3f3;~ zA^tdO79eB0tEzCh3o=D@^p@h-0C3(+Sj;=uSfP=i$10$&<6(AndQSgd6Fu}!=(zg{ zWNx>$_W%)w?5w`me6|0+_e-On-2Y3=s`C=ge{E;Ff{F+rw~T)zIQu^j@K`hd z(eDlZm#Xi{RaZgq(ax|SZ2XMk12FO}Ges>YrB*vSK}!wL@6j)g*Jfn)E(@lmjOK*N zxZR*p7@OqI?|I37;Ts+OIr`iN;6J%zODB9wBc;S-Spx$42qxZt1^JtR2@uhLZvXzp z$00H)OK8t7(G$9p+(h7A{7#q^x}g*wkJpWI!#08{ZlqkNM+iL9hU)nS{5O)0Yv$VU zW3Y<|$K0Mc1^C58N9G@#S^Sv){3K&)p9WBd7>wu5f55K*2ANPRlFsM{llBCbp@f9` zkCQ+LZaR{Mci9&iC8>^d^1`gE%=Q(WwEfQoL1l5u_?@UfNnjEbUGN6tZ|MT?$o{{| z6PQ4t?UJpb2(Hm1+QvnN#C$~OpNJqfb#l~aDKRD+Jaw#PAVk2J9$jvvV40K)>gRFv zPC`5JTC19zQk0^le1tdetAzi&yHeOxVAmjjODX`!#;E;oy_%~LT)$u1Z1F#?{N43@gv&>XJ!1qn0w2vxYs8OlbI#1%Gi%meIsbR}1N5&StzEV2soI)iEalVJ0#BKHUDoRn zVe_7QyjE#oy~7{prF4ET*}e@r^b7c(78kT+(qL78SJef96aG|~vBCF7d$fJ3;P6V; zSwv_5ygEy)`Vs&27pIU-gD6NBg_Cdxj{wuOnAiJONn2zKz@pf}f zspn4tL!xpC{8thr3I8KO5*zk0*@X-?)j~BStCY5s1`{w1@jm+hKsP%k2aDa+U0I2* z|NDA8Sx%Q){fD@3*wv)z?L2PC)%;chr9{Fu>P9lAo&pSV-6;|g>sl0b9@(@FR{@?5e`k=L`>t<|ly&E)kgdfiJUrSm8nSj|vJOC5FJ3bjx?)WJy{ zEywCj2K20>f+G9>(7nuek;k#A55a-*o*UQZ79s7tM47Y6EA4kWW6eHJMP&Ou;4W)a z=V#!brUp8YzbS*iMBwPb2@PI1=a0ku_WfnI;#MY^^O+W|*4#~1KG%1CtTGEm9*LC& zuLi!uKxhmGWk_oiKuTZyaQ&I7vYRkP#B!8wW6Ef?=AojCGYTe4lBjfJ>@3^a&BMyd z7pr^Cq*44`%hb6(56j=)^q=-G*uy_TdfBjfwPixM(lUhkXkH0J91&W(Uen4}YHVCP z!}(Jldfg^=CLSoBdpzveu(mqkwT@2oj7zjj|GZ$CI1fD{)T7Usrt$FB+;h@-=e0@S z`5MpQ6S%i?99a7_-S}pA>wNx$5|wm=YW`({EOVE^{{wcr(m&jQ`uyG1&!sc*eGV>{eZ9W<0AyD28)O-RpqU>M}yALN9EH z4$zhgQgKLZglJRu8^igU^@H7E*m*I~C=_*b`UMK?a$1dvw64-sPlgW;-K4#D)yRh+ z(EG)~l^XGmoP^xQw+Mfl!XQaqSTDwWRFSq#(K@x$^!*vtrio;mUbf!_?PUO3pCB=k z9<+g7zBWk^oMB<3c!{rNwOjzs03phX5xM>+XS12KYH(FHu;sH8umB+|dK#!4a_;Yq z{Z-Byfd_Huf*c57J&3REazoDo`my>YiWFaZFg)dr&u57k?6RER$Xd)Z;~`>Cg^(zim~FV6UfReMS~g$X_jFxe>9nF~ zQJaLbw0SP`yu-o_%CAS-{#kfTNdsCrN7kleZGU>=O+=BOb;J$BXBM9-_I!uPYe6Q?sl}h#`8E9 zbZd87dK`gHll*)ic_4dzx1!YZXUPLx|1@imGuU$x?BTQ1H9BsS2r!T{qk;WP)IT-#0IOaX@Ppj}>r{EIm5~^bA z9pO`~0sQfmc&my#hajg3#N7qfmdz1NI3RgH=;>5I={1=Mb>tk76arp`84=w}jg8VXwquK)C;)7Ih?_pKefmz8p z_+t7f@Z6swn#4d7P71^&gsH;} z7N^Y;QoBotKY;&=+j+YIp7){nC_{{Wr5D5<{r zS7dx>B|n)e9&Q>Y30`~T@k zkWQE+9zk{kz|}HAWa99e_owU*CKBU>m8_}Goqvz09_|<2+T|Gh;pz!;@GOvidLL39 znI>kA}^RBQg(C}JSQ@MJ_2ktp@?G=u0OHog&_Fih8y z2|6cM1F>si>;z2DeUH`ulfCl@xB#3NMftt+d=L@|ga*X)Ak0b%(g7B?jBekq2DjHD z;8BL~=pOtVFI2StN=9;Fi;zhK#Agx}aBNN^93*Kx{wKEmvF3d_Ki^UWU~Aq={*mnQCSoLR7Bj0 zRet`>08)C)ugh`B(%ebZonQ^Xis_6?YJP6VXK zWL_4;r`95Vlfiov@EAw3FL7qsSbcu+`S(3J&e?)G?-cp7XfWrMQcPpwfm`>8CAiSW zgxe5|jrqzh#MfFIfq)`oeK4ySXVPgFK%dC^?MdenAJDHu*FM zuy185w^{I%XVxHSXW}yBur(38142Ig77(u^RIC^goxnPDoA_{4}l_V><9 za3W?2yb8o!}p z=Ro2-`97Z##@+8I>`j3wz3GqqO5g;^T1H#5H~sy2(PGvvkN>8vdV zVJIuVy&FVi)42jxGKPX5<O5jd)I2~uMmw_iwsqM9cDC)W>n_a;^ z_^{H{TD1o(w&e=4s|xgQ%6WZO+LX+LU#lD4_$a_;9Nzc70sn+@ATve}Ht}`|)e05G zPiUA1NFsa8esR-^pZ@TP`!{otI(n9ny?wWv$fJ2gcq3p9tYFI-I^ilz?R* zf3_s$(fO%+H)ihiYRsq}gn8`n#^AaSr|k^Fm44SyLm^ZYu=kO`h-VaR zMjLPtGngd`+_1C^m>XkagQ#qam=^&W%Rlp#>+Y0P4ex3upl2Z+l@(FRc)B?0L%$bI zl^oMYc2I0y{1t{Fqx^b>_!IbmKCBJ)<8P=K2FQ0`zpmu?)e~#FwT&|L((0*Jo{HN} z6zYu83YW3CnsNUhIS-vc4*&tAIe=l6Q?b!v>dw&+JE0G04@{?zF2; z%uS}Oi(!Q_(eCt6Cliq~7daIbp`!_!(}T&eP%ZNy^dWtJmdAE)wsB4!z@%#`(phj0 z@zXbRFEn(A%Zk%lLjGhZO?-TO1JyIToIqS&Zh$||P`*k0c6N>+p12eNYyq{Bz3`3m z-omA|!L=WWF0ne4>$ORvO-oa~!kuhq-CM}KQWABWEB9_Qk~mziW{He<;JO+b$zGd5 z6vES=@B(#~r!=@f&!EFV%=8hNN|i2H<6$InTPEeZMpvYD@qkNs;U#cvOqW$>g?4io z!`P8-O>+bTU!HTnm3q|4r)S2<@x(T*Tzyc!h{ag#Q*-kANZV*Azn;&6NvlugG zqmd`ZN?U77+UlBP%e`EF{5}0jA^4lsGv%w4A=#a&|0;QjEyfqZ5+pBW>AL9vx+DzS zyvt_sn5=})Yc)dC^kE~?s;C^P;L+U(YHB6gc*7xR*GgzdcC*;;;B)kEJ{T-~OYukW zr#Vj^xNu7xzUIZK+~wy;Vt7Xprw|t(ioDtTo{;0Z9DIsHZOfLcQeAgdDWSZm$Ql2e zoB^qbVV$NneK;5f1LlWg(d!KTciY{#c3OhD#y+|zMrt1z<}tO2$;j7#oy^7;REaxv zmqvXwUMj(!7B;D0LMh-oycnd?j=kpr#wtMf*{ik)^`FU4LG|!Fzu1f4o(6Y)D&>_K z+p2*5@z>ohCmM*;>83%{~d8z@Kl8yC5v|iM&nTYu9jQV(C2RIxy?g{c{JN$Wzx8_=GsL4 zOF~*7xc-tzXK$I)0=cH*%wA~8gMQ!O)z;YhTquwli8mBV2F7l^g2PR1V zAiR){v6h>0E_k81jC6Uhb_(kZ@QFl&YMZWPLac22OGMEQO*y87o4zixgb(CTtBK;~ zHaym0ZwcLXLR;wCojQ;9lXd3&Gre!r64nKZJeicDjqoHNz7iAVG#xNAC`Wy8fB`m< zl?5P^8ls?Or!ak#-z)CFnwgA+G55z4E~s~7|8M;R4QN6-zmY(8o2`0*$%sT)E9MvS zD9DyRlw`ts+rppFENvn;CuVSzjeU55oFoXc;i^X2&SA~Xwb8f^g(3Pe{yRJ=O=~-u zq`9f#LDLn;iv|W{!F*?Z!)B58PY))|&u)+$ZJ#qsGnA`q%b$4)cvuR~!*b;3*a~MO zOKHcO%I++m&~MpkMYJ1lvc?Riv&LN2Aug-Sht~1P8uyBeFCBKAo%0<(p_?u!l_J_? zS@N`aF!Drx=$gMG3zIvT3Cn{8ScWXIh^1hCqYDRX&A#h9Ka6s_p7v2)GdqN7dFEHS zIsYoIY3jr%u!BD9JkmWmSkY=BD-|T)u6!}P(4}g#75ucGWoz(*AcWLAiJN^2C1=%G zU*bM3^~XVjV)}#LEfTLj-$R_Go-?=Kr^pKeKB=~TV80I`BHOQ*BF1NDzE^;1t>AUbnF5_=R^a5uJw;=rk05;I0@&+2e_*Fyt zP0XaFQ3G~`Oxg)xn)4BR9M4hnTDCz`GgJ};aizAhF23MTU#T2X?nam)!mmeS?(bJX z8OiYHDP%nVv>9$Z2&eI=`|pHrQTK!@Vi?f#^9+Q%3*8I@Xalm6lk(yc(&Ho3N)_^- zCbm<|$4OaSh*O(j2T-G2_|*m88>f-0uwYR1_)KvZqNO@;WY_?~`q`+OZ-9jJ1^F-e zU>*JMK1f0>h^C}thPSp8RDYJ}r=h-2j?x505(Vx8F5Ol}!GC9G{d=~zXMX92`}D-X z;X%|pd!3Djd~|aG5QoE`x&JAV44Ns?m6WS5YIi3{LrHL%yNaVPBYm3 z%O-=HkNe|Z`QTpfQ4DJTwoaa5ERnl}!xs}48s3v}PXU9t477HH2yC*lVTAGHu{Cvy zl}(cjYLyJwCav(>^Myg!NN_FXq1lV%Xj2d8gwMW1PbXK;1{aU#Y3`nG;^?xWD)+b7 zxA&Ock?Z{iw*l&z<<}%EluI3fVS=w z)1YNaGU^KEqVLwJSmFSRB5jb%mrE$U13cC``eWR$xsvB3J}ax5RQpQI*e|;9*?4Zh z^xRcmd0SOUwO#mDE`JG&xbR)F%84WI5KxD>XL4Cmf|>5lv$Mh_6X8qcz7kH{#o!Q z*}@2asU0iw36Fcjp5b$UjrT7ge>Xy8(}V*p#$_*rnv`&EFX0Z8WsB^=k(oh z3738!T6;yKs8HI)4;Ar!EHz@jtTY<+BxLx&CAh45=6A{}O2!t{w`%fmoZ;kr&R|md zNSq3GeQe*5Kf@Jil+UR(URH2@i&e~l}qSObZ@LFfF zv|*y9$DQbIkJy5f!Ldwz*o~k^LSY{T^P`+8W zACRH*mJZ<&++D?(vc$0JqA&vTL)J}m(3IGrZWtR0!j&YewXB6p(kUqxbhUWq61qh$5g(6#Z(ZV z<1d{(QyayswmUj)gNxK+*q>Mm;i!v;X`l{e2LTzmr;@ubbWWjyrM|az0CJ+Ok+!Xj ziA1rFf`rlJS4YvOQTZ_Luv7wu)^BOg;Ubg@9AqrCO!Qxfc&bTh`FJ_r6-wmrD+2m9 zfY?!xO4%EySjYsY2j9$l{EJE0a7yJUR1^V2GusL>qf|2K?m;5yEPsuXiOY;?dYkiB z1N8LEGzrkd$--9*@jta2e+#hwyOgMkNadmLjrba9-^3JoMN_ z6S?`P&M9*(2PD|~HO1+F46D%G_cAgAp5eF6Vb`?>>Kf;}jc&p8jWGdp3as>q*b%>B z^-&Y8?*;fL00zP8@7_CqajGC0^*^~7f61u##G%yv$3sr?sFc0Jn`t;AuSoe(GG1J7 z*OW$42M#axj@5Z@d}8nSke?gSzrFzfG`W8cc?C$ARhfDfYEXb|hdBh)1t;wq{ftCX zo<3$_?T(-t?SKsR7sFe1_+kGF@b8G0x&KA9IJf}7M64h&?tuur#_sm{Z9y{~F-%9B zlLac`Tc7U$jDGfXgmB6}cqyQ9{j=oOv|NM&dOScxGotO%q+@va-Y%Ip?fl)=;ZJ{) zqhyc5=^Lu z6qVZd9Pp=x%^;%K)5qosrVlCq#Gn#N0rM@>UZVn0ayO$TYC4!HlxF9mUV)NM-cLR7=MMIRxL!3Yz< zMP7h^IxGJ*oWD*1CV($k})zx6u>;qF6W^n@5ocU>ZG74Xn1JR|qoY?ygUvxs&6@lUIfHJPU z+~(E>^~%)hS+Xbl+nYAm02352=|OB7$nuK5z_@Ji?)s_qwQgL`*f5!O8_t8bHf6W! zonM<}RgNK$j|nSa63w173T|frHbq;lk=|;Qyx_z$IuTA4Grp5v%jvW z?-&#{o@wsixZ4jptQWElgM!!$ldWR{dt7flS%r!~Ek7p^?e+<7KZM`xi_J%TOxO#a z0<@}gVHNaxp6_l#B#?F+)kZ!P4x(f!a!TdwtnGPlj2LzS;=Z0=?%mLv%wlTbLLt&P z;4&`70!;{xPVJ_VPhN;Oj)zd$YW88i(7^CN1Mz)^4hfoIa53V)Av4ykVQmdoen)FI z`k`7TM%g~FQ3*N_|0GUD$1U%=A8!nN1uNvec=4U6CM^T<#z%{!br}~-yYv#d&Mo1m?Adso)h2v)#pF|Qw|4K zl|b|g)8$60D3(==drgB;oq$>JcOeWGR8#H0E{7^VF|7NaUVMTQnuCvi4&A(cqls9v zm;my52#7bpzws7cHO+mYNkT#1LZ^{qpL5@6WRg*()K7!jXcvCj;X9HR9r>H(RHTy?sxMyU9S>);3 z|DE`pg{fc$#OeW33I8;ezvJKJvKfojDdzy~x8(5J{!P#CrWGa@?gR2t`RsvwGkt9* z1eCxs5P{9~ccILH^v4NMEhy@Bo02hg_ph@T{es(V8#NaBvRxGFm#CG*w%A*+VF;;xdF9FsieJSjcgBAW zFXr_XIFHS8-%XucZpL$ElG=^49c@1NS)(^J+*PjVRjM{LLl>6I%ZFI#nPM1}TC#*b z`8HkMOuT*;^gc$rnA>Z%GRlLEg~m&IJQMs&W=x7=Okt|3T$Cb={Y+7IULZl5((;4; z&DcT)jgPtI9sNr1{9MJ&!kY8rLrOruDzo7yVeu9h!lpcu&3nb*$R+cHYLuV#4zirj zcW6fil9g~fvO`%Z3ZWsFp&{N0>|~+k2vY6aPgV1COq2B!p1sprV>VUOm&fE-eFR7{6)sEgb#04TyY@w>p%+;!_<%*hk#k{mk6fEsvU%gj~ zy(Zhk&x*=W>#A_y3%;_GV7!w|yC3H5ymTr*?yg&+_^cRW z3(jG*b{*jg&B94i$^LFX3O7O8{hK!ZXylXoTlZ|b@{cO+MZJJ*CJc&YkC93h12z9r zPG5n;%-O`xinHp{w_Zt6_9a)l+it5mw8?oHmaTVn1>2Jvs_eT3q=4|Tsf8xb_3%NH z*qa39Z)rT14~s7`(}8B==+DlL?jeFoQJ-Rd!3AWKhy>WR>9le_?X}0#Hx|@u>sXj{ zbv!?*rfv%qxqM)K{M4IF#UC3v^s#OwW^V7T=<0m9{+7e%E={KAz)$M=YIjZ=B}W9u z;zvlR!tfA^U6nWXBl5TFk>ljLiSuVWvROXaW5JyDdy&g>_OB+Esx_AqM;y%XSa61E z{p<*~=x9ksJAAAf@+oifJ3~W4^mtD6LqkWEo_1Cwqz$1=$naQ#kC7Bdbq)Mi81x;4L87OZBQ3w4 zx6Mgf;hG2euueEaXhLu7>`<=A%^0=7z}}C;KY9MUh+^!&BZ_Zs@4#q$AjqGAk8*8O z+(c^`>_5N8tp0H6plqze9Dh63XTV+9p;?3lm8|?PfQO`HnX*&RS=~cCgD!YC`exMx z9zutIwVfhirMtJ&zx~@Vb_$|ty+ZuSgn~Z&J2N^7JqcZr0g(T=@<^K8z_@(Z@MWi9 z3Tc+TEx~@3w!8EbHjy)Lef56}?HQSv8(LZ0(HVp70lQaZ2PCYEg<*y9qttvhJ;OB4 zTc1=%ZUbo7H)!dr&j9*BF1?QwPw)N>mwqYj;*($aKheFkjbWvyrKNs`cEGAIe0gwf z5pYnXD3}Zz^rjz+6SnbzstCnwlnsgz9~lhHe;CcrRc{T{4WQ+mwZ6hAR0ki;*E`#E zQdXF-{Wjn`K@#cDZIDlq|IF{=vn%>^;sb{J4m`sB-#8R)!tO$FTf4lXh;(3t`QQ@w zKtDM~o9T`qVO_8$HOTj?5P2D?)hKmm{_pONGFhC3Y&+u<>MUf>0-nVUY=qLZF z_q;;MbpmxJ;Wywf31K%!GmZIdJXD%&kbC}L(EA^^h4{PELlkGAO@RBlN%*mB<4*K9 zKJIiYRBJbj-N_?QbTQf9>k}5=|KE0cD5YkNG5DEy(wTmDlumqifXB|~6_9J_;9`DW zCBB+V;{UeU1n2!aB>r&>>=1;LEv!!ECbs4xa|*jCG}#<89wBG=^6V;2w9R+((X70v zJP#mKNy{1diu3JJ)%2vTAjt$B4?i)#t0{wNF#h1OyF;>6#YHK)2J>K-!Z2P5Jr`Ij z!r<@k13_$4H* z5g9N`jneo$mZrerm8AH~zq8(LbbVtf>^s6o32CXp!Et)XMU})oS_SRLvwp)X4Qh{q zHOuYhd+$BQ{@|ognbJuc72ymb6K285265)vyP?3(EO{?pKV6hkWu%_1oksJJQW4*l zZtZ%4+}3?eq-g1a$Hhmf#A&G^4<8kWOPM!+-P|ln*`^RsXzG|&4Go=-j<$=)qBout z^BA+ir~ZTsU=wUNdYCu9rsd5u9km;$-0*D)>1thrpijZ?n;)p{Um`vl8k7PqO&@vP zm=%*Aao-$3pe&AuXuIdrJyO=Y$gigM`SF!>CGrW(M|Ykpe-HjFWe4i5zp7iwy4AjB zrTGR<+h{;-t9P5aeu;015$&)|ZnO)aec<6pz8n1(*}BP+AfudIy3QxTOXohiILv+} z(tqX@LG%X3wQg7W1pY5>(?1@f24K#6?qaZC?S4yDjVT!8mz=jFa%3^^MOi$1PLao`Hjy(7}*V5b00i^U@+Ub zK4?{~=u5dVIF4MXHbqhu`)~QG|0A=g)dcuNJqG?)lt_pYcMJP3KqMbb?Jp3C${{>r zFYyizWuAb1zqu9p*0UiZvO-!Cl85mH{yRQiQh-Ku_p!q9Au`=U48WIO8{4rWbkZd?8;E4ECRUQooa zCS-oFOTVkFCbdfkdI0CB)M-Vz1(B$hKCO5gK2N_44;ydYV(15EHSX_O zcbfWrLJBx@38`qLExnb4_0J>xQaq86XQpS>$s!MBANQ5}`ozr9!ihw?osVhzO_bkX zLWTRu-Qz6+MeSB=KF2)wtNyR=uC)5V3Ujf%hkQubB8Dcp=IE?ifodC@orE^SMyZ?} z?(G8=4+`Hs{O}z-~gAZJ87ngnNhx7WMA!6oUm(WsO#J0yWoT|yYW0RB|d1~Re3 z^_f;e*r0#>ip3f{YVmOz^M@1;tAHq&Zyc2Sf4rw@IfP=o0zUxES7|&XdigCreW5pu z5o30!`b@3MG;QO*?OIJ9D*X%aPrDD=)8E;U|8kBA^Tz~vy!DfJxKabrB^eY~I3-8z zxS85;sZp*8P~V&6R<{9Sf%QblWN(0fvsCVyE<$url4_ntL%Y-w;Zm{f*07clzs7VI z-9vN&VZerc-{*r^l|LKxf3Pa_{9LTY&km#NlG44lD@|-Bs~xl`t;M{!u&6SLrf;yn zSrrcs7-hGulJ$YCz)fM5d6J+&T@wEbYlM63**P7t$xpx6r|&zN@xADuyPl;hN?T3y zBYjbT*tVF(fnv}4VauB^_jBJ{C?%^WA{BB#xi$WS%iiizBC;I5Z!*w<~lB#yL$JK7>r?$hq1iRB*)~n;B zeUj-j2qCgAMIEcdTOO_rK1)o6`A^Ntdj~|V_pVpdL$1wv^2CFAu7N%$SA&N}3$?d6 zcu737xgn}$(QerYpXa*@k6`eT5f00QB-?#Hoi?J(k_*#`sDYj+_CT5`FyG?n_2&Z7 zIU{TO2O7ZNqi&i+LVTkD__plZ)6g4L#0z7M!-eSC%t9wyS<4l)F+q$PXA25IH3B2I zm&l|0=mG5zngfP_YF#TLL>-;cz+viNw=E_9q`DjyTjO-EEWB9Og>POl{s%!<^A6Z= zfepoSO4#z|cjD!i1M%U+xG0|$j$KT031X2v)_yezm${fKp@gDAg^O0BrF!WV#A;8a zN}%o#Gi0Bgr}UXI=Y4!33)Rh*G%3jnlhLa4&78kqdM%;4n#$O5%AKp z{7DDqKE~J=+2%j??MJ`Zy#Js6ok~gI za7H=j6J;!q_Y)m=F0V;i=Q(X2ta5kx84{PH-EaSniGT*`5%4EZ5L7nh6l-%J-3N2$ zoUZ9B^vn01rj`~eGaQ@eVmv%pJTh$0GjNIhR)g{B-53)coFMzjPgpx%srlH2&k8g( z8?6)Nx?!NT`lpi^TT#ksUL3mD5Pj@mg3@qx1%*vminni2Y5tw<*L4^6Z)0(@f{t_v z@h7ta`tWboI{)_;KL7}0(h4}qWa=x{HVVWnVVbBFJL*6PH#n~%@eHKwma&V)0-6x+ zH(w+C`raZ`%?-XzEEmP)a6nI*cz~fcj$7uyP10r#LO(wM_ZwNze_F27-XO$R?tFZw zz4*+vP=Mj%))}xYw?lR;TE-Br=ktIKD%ZJ@z_4p90kPpHs*+aA>`1)jUcFfyGcaji zmp$-S&>i&I&bw*>{eW9?Ib<}3_|M+C$PFTIPh(N8auL)0`jd)w1HKtpWA5uCVvJ(M zu~g%_Z7rHBQr{-aDxxK}C?m5wKX?+7^4%|Ph!5lzDjK}0WPb* z1YsORb?%U+xUzmcJ)wB=5onIGP4*s}wuR+a5Bm?pks~V&?&Mf=#F})D4~(8l$RuHv z&@h|C6naH0!>XVL@*u=h!KYMTKMTAc_9la2+a1~Y!Z=#@Jz3}nvXOs`E}CU7GgRso zooJC?jb|8jS+bmhl6mJf~1vZO4ks5rGtjppNm}F4vJ`YJ}i-ehX z3bh^Cdg?;vR;ku95Q}1~KN`K68y)Q+b+TJR2Mri5RM^`37)N|+VMdQhGhv50;MP*F2Q5tQhx4^om^{)jz7@}dw#GJf{7S# z$cc#_Ql%uUbm^VLX4|_>m-Jmb)K<-6b9w_~$=>0@$(|v(%Z%NFp;*5Eyj*w3te4rp z7CuuE@gllXsD40me6{*uCE>le6wJb66MSFcQK$ZZI!xX-+FCw$jbUKQg&n zz1w6nL-seT8K#t80zs&GlLMIy1IVZ_Ir9bwH>SUo;6G zS;usSvxhW^UMJ)Ofs0>N|4!Q#WG6is4o9Crw_~JJf?^5em<7O6qVES2Ehmo<81V2g zd#hOnY);9HVm`7&l%%Q~;KbCTX|YyjnV`rRle<`8H4qoYntscw?OnrG%T-BJ`D3t7 z$?%JAtiTt2H{{cW4cS42beOaQQm59PuT}X<0d(Sl;*B+3r`XcvC!fG9KA5t-FSa^<4u{HY#wm`u(_Gdi zevU5SS8d55QI2cbweQo%XxtN0>?YrXH&=3WwlNH+xU?FeF8w7@*IIOK5Jl=4pL}-eV$AE>4i=9${a^|4p?0fb-FP*rAn80A69onz{39{L! z{?qj97;TnCMXLmZPf2#f^{B(`uNzY{z602+&LU>@voDbZ5b@F+mkoJNt~@iZDf2{| z_l|duZQ}Ta$4G(Bi%T?8Dks_=_iYuELBwB6vu1bk?jgJdz*_2rc>|y}KRa^4aem=S zm(?@2y#@9!Zuf_0LGJfBZQ4Vtxt0Z57-|;qslmaE(!_7COT}K5?)6AYkX?{6jx}WU z*Ke?YmT?aAiPS9Nf%HQ>7OOo{{AhI6yB7PX+4v@xw9?9gW|7Gnqj*DBG-jEA!%>TpnOr>XV%gaiis?3X*Nd&u$BI`ZI z1MEZCxyGMty>ptsqI4vV2+|kFJhCcVXiX%-T!rlTF2>S%7!E?ay#I+?t+X4m{C5 z<{>e6Jgx#@-kv3hIUW~iCHPt3B+oz-N})Yd7){l0ER94W6YEHqh@JsX+my`iAb1#_ z_)bni$1kL38{!~=vCA>$(@kww$`q9uxdY*eE|mvlKnN{rJj;6;+xiTxf-nzBBmJ%O z_1XNd4=OdtV^a6tM^v(h5GUi?-Ws24>l<-_+*sAfY}88ij-5#LNO-xB!t#Y^G!46w z;}GO)wR$oo{q@B3sG=+8BC95zeb5n6pEsHv!0IErzRyoz990d;`LgmtOHfy<3xteL zpmx)V9?uylbHyAp4jH0snMAf)_gtu>iird@e5;B+ld<@CTAM&PF9p;KMkHJ zK!6+9DUzbq8QOQy+M1P<=s_$Wm_&3 zCPs0ZP^I$m&F=jawGcTB`L&t|5Zw&1uG3-x!Z30ia@z7OPTXm)HDSXZ z^{q%Gf?ez6yjp#c{n_@cYjc)Svd-MLIHS|r{Pwg8y>p`TvU+cW=b`;}zG3%xv+T=v zG`xyP!1(Htb>nBm<8&iSfcN}v2Y0u)CjT#wN!n^z6p2TyT|Wxf6vq~qOWI9N(Jz5a z%%2$Rk^eBZf;e%Pe1@)*tgKMr)ouMFpCJvj4?0ILhT5=8HIvoa2%W=Us_Vi-3WfTg zpOYm%&-pDX=T?bv#m3Sz=P}B$O3reQ>n21`bS8f`F#w{SF2Ky$;tj-Ai7Sv#hm)Z+ z(a*<{X-U#5ewdbSi-?ys*paj_OguF-ji0oiG$iO!=z?U80hBo*@N7Hp8ger;F9?7A z&JFdQfkc`Z8kJt&2$!_;bf`*4Qo@S{(y@!2c$_#^y-D$IDlh#=)j}yi4m+?#r1V-W z@O+dUUM4dHZ7|OU7S)j{DAdcQ9{8kF(jOpaURfYX%nVf>JG=sVb?Ci zvoN&>6&9F2ZqyA{2)%B5hy-P>A^RFT80L;n4ozYo_HKB*Vna z9`ay$KJH~byRYNCY1naRU1i1N%}!dL4z|zsIG?4LzD7vPjVN&t55-lI@_ptT@4=oV zNbFrxG!;^oi|1g3VWMD6*i!CgD8s|h!*_y7INo|OzHn^PjACodyIV8gl}4{`P0?_n zf3E@yL+u=Jtni~6?^5r&xwG^Q9qG)L8K2e?<|~|7=%6ld!KS?^{;G3zZ(%#G8&i|o zm}UMIpdnLIZ7?bw_ot76qe0dszmZ^XUCcdgkMRdBTscz0F{MXjVt8D&!P8}r-Jo!I z@L$(^O7cVHVs&AolS`RvD-q=L&@QO9E=@JkXeE_#}$C_)>+|rKK3a+I5lZc7J$zLumO)Hud7l*)) zzSO8YWNZTBY|gR1FGXJQPbq%P6cEN43EDsKb;to~AE%|W8?86wuKMb}aN9~ADe1kL zK@XJj@n8Bq_o!#_Qi1!tlraf?bW#;B4EwbV&0P4dW5VO@n6V9?Ryoo4X!5HA%YLNR z*XSvi1M{a*mea2&t4C;ioYAlzE$<4E?L(doIbrkqUevkNC8cekZuh zHc&^5>`kcXSAJi_#P*HyE-AkEr>dIy-?BP7FxOAn;(7&l`xvE^J$V}e$ z60E!lOcSg0Qrxx%P39kG_gUBM@we{RePS{(9I}h*#oa~n#<_hOc)eb2o&-+V@&#Vs z$1NTQYLK8;cY@twxLvsPpoB-59&Bz@?VmJn`SQ~BPfOlAKXe4*uobna^lEKR?5?p` zw<|Xw575G$!0;Y2+BhK%qH2LX9X3;?AnalCZuvu9Tdi^~@b@KmR1RV*_O^;&m4)qK z1t{|_c(G#6X?woaB`T~K{%A*q{W=)ub2VTIj&ME|@$HLUYmvsU4obf%)oCR9FxSzK z)b~isbb`N9aV(k9dumcj2l|V>wqdJf4+A$KsF6@+T14vwu8y?GSK+Gx^J)#s2eq9o zs#=5UH#Cg(swRCMVXnw8PJ7aorksf-78SlwvFEITxi zD=U&&7Io56G5r%bJHe9?9>yR0@2yjCLs1r9Ul&agsZU+YIeAA;NmJ7TVH(}vi@2}*u! zb}chJsPBGpP(r@)6#Ot_#)>5Ooy&_vFVL6`1Y&=$PJ+V^d9Xkl;TikOjC+_+S(JA;bMn8Fqt3 za26IdR(;Fw%l#A%g39hea=ug;61G2qnEp1@+g_{0I?}=G zvTX~7P>3^yxZ{ucJlsoKu$M`o_P+;>v9FcL6DUY}l$;ApUB!&KV!Y9`pm43Iu7n$S zUG_OKV9Ar`QBNECK4y@qYb9*6Bl(GU<=I@)bJjN{c*0^AafW0%MRcRp463r{^40;( zV~yIRa>b8-QIP56imxn$iJf0utUOn^3(T1%E`Zjs9T0&?IJyerafdu#(pv*I=!sk! z5FB9N29E5(loh5ziEX1oVS4Mby%6)ii_yLECiuMz?g3?kQMUw}a~8}`h6}M!mPeHB zA5x&#NyUaH8gaYc8dq9 zX;V{lVCZ`j=r4Pa!>_j#{Gyd~!2UZvDXf`@RQxeQMKUYpo(OuYJk~ehPA5Ma{KgFB z+7Z65?Ih+L?4H@S$SPjEvT2=%!U1$&N?h~s8l5=kZ4IBEg*PQ~ZzP5Ko?mBvvarf) zp;E26ZL2e;P^RNu(!te9!Q; z^-(bWRY1C2$Ix#DA)&1$Z9FE`LDu=%kMXA>NB-OVVaiMzWoh1>Q_-#)>R0zO`s6a? zR)0Bvh=V4HA!AkpTI4k++id8>Z0Vt|!=l{77XsP>@3r?PrLN<17l*T!zp4ehPE(B* zJa=_H@BHejE6@y9FX_kTr-{o@72xs8%(1r+2I!%93IfK>D$C++Dd`G^2vuHwC{-}3 z*2;s)p_|M_@wL=8v@czgoWn-grPDE1O;7Aks4DXic0fcMa%TEq$zhzkGEdUs3#-y5 z31@Nd6FJ3_i&(hIebUUWVIC1|tOHm3HSX|S|7fYje*)3V1Y;K1Sj#?ktwqZt(V8>8 z%KyL%K?6d$EMDg1QSuBa#+lKLUWoPOE${|-PNrL4u7{CRcfl5J$6>>^Y~(G!K|~#> zBx{^FB=40(J2;54+G^N!%CqKr8Mwq(0%yl!#u9Iv*Hv94QXJ>^^zR4~Tt40wZOVD{ z4Ck-%kB)hvZ0K7N)vyj`+r_Gx(sr>4*Is#{?ez))oD>4bcj?rv7iV9}upHFDzhx8E zmeSpX!G-SY)9kz&>-v*-A0it!pi8Bdd7?$87SMLC%=S9>&K`-ov!Gh)3Y5ssTNZ0% zYvo4_pmbmsER46nefh3Q?k%F6%v(yNxYgXrBUC1!y5z;%P&z^mSrx7_$VwBAzPrek z7*C29mZ-YZEsvopGXlxG?lwk(6;*|tqpWe;!RlpEQ0v=Ioo$v>)jw$`Ha^agvA{pX z>gj}MK~X_)e!p_C_wGlSw6d3aj0yhIm}{nIwL0Ls*z!GYmQIPT2u96I zobl7#>m5&}UPd3m8b~foG3dL*3g7itak-S9x}WTt0o&j&&#+yre&Hxe1qD@wD46fQXCxw(RTwps2lA{=fq|reUex3KEU=W0>5hQ27fTJdHQ>m!xOiuDP^722{I2+ ziP_azWOXZ)Iu1a88m>^uRZZXVrAbAkTRtrmowLD6oU=WWnxZuSwINICj<3j2`l#I{ zh^9b2zOtvAVyf}wt=)a+{6a)%E10ZfZ@4Q+D^TtMgk(j47bOw;Df3enxNyv=>QupQ zmX#p9CDiiB6+XYS3gA%ud%fiIPZ$Vq=8!E_KaYXwB!(9oCeAI%ICVL0J zW>nyRoTKYeP8~S`qDnl26e-Sp#Ty`+Epy5%k>~K6dG(-#wzB&F%+U=JYu11xL}mZL zxu2uZgmW9_>cGl{C;>D%#% zV?H0fvuL>)V`Qqeb9s5ZtY(Ftse(zC+JGYCNEs9vMll&`Smj8eUZTrz+Ry3HDFu1# zkON^%_7jnn#u+d4RYuNIFQ?;q&@7%n7wFsqw=jQ7NPe{AC0w4t|Npdv9NQ(2!+j87 zi9UhO0H+pTr_t5Q!*cp7iun}~km6?^Qh@*ANA%v~+LH-i ztSO?k2-z~=+y6c1NUu~FXU8hPaqauHa+jYcL0Nt_QN8$>QMGM#)1I8Q=>zyJ3ZQeo zg8T_00)F`af!CA3L?g-^V>adkDGA_USJHPGjL05#@M(qfDk9Zc&e#>nzmU0uk|oRo;OA2QmJ4$wbNcAHMD3&ifloATb+PhZn#% zm6gqb`vjkogr()p;c)-n$M{UV<_9S{OhJ6JEcZatsY|J+n8>ssF|aj0HF2n|QCT)h z6?zB$rt(g05os(AAv2-uV_?gcVep2?V~)XOOjK&wDEgn6vpex z^Z^R%suvBMTse;TBlI0mMMDuXg0_5zp0+^jwB=_=j^ElSrA`(Ch`bt4cexIHCs*MT zSQDs&L+4=+CUM_>v>II9p3Tng(_=}aAGpQ$n(1PQmFB(f)v_;AAV1)oIXtmxttd|= zG6zhTvu0qDOpc~lJ!UzBQp52F26TyQ3VN6KYB9!Q*TBLB^#G};eQG)Uw@e^iFN00Ez0TU8b<*oPw>>_I7$ zgovL>v zAK>T#w)k2-!1x1IJ%<%WG+&CYZE0R43%FLd6<8A-8!OE4UeVGb-(lu((B!~qyyCBF zuNQ6K;2Rod(?a_@@7G)ezU>qZnU1i84O--lJ?4qV6+uZ+`N;N{=PlOxn`!twi}G3Ts5ASIes*g)anu#1|wtlSrc+Mb@SS(uBS-F=Wx|)Kr{$WvjP|b!@P~qJ zzX+$Fgx-o*iXvB_i3Lu}22IbJih?L11PaJe%PpmCB>u&W_hp4@O^EHJmMa5wN1 z*HNq3lGVt|2WO1qVm$FrQy=oi^ieJh@A_Tyq4=%rrA?VycRBerMJQyAq|j5yA;)(E zgGT%xDTt3DnhHI5BL@4B0{ROv!5g7a%V`UWiz`_6w?dkghZ>WOqAwqmZW zYJ-Fsj@T5QjJZ@K*l5zo_NW*_?Cbn6)2{KH$W?31sUgqPGqjQIRo*Kl7m}I4zFUoN z4Nk+Q^O!E@GHXdArEJ<6k4@Cx;r=C@nQBBmN(^H;AEJ&sB0MC9ua8BcQlz43*;xBC zid@_ZQ@RiV`VBZ-9lxN4_5c-2!Q9b>4~(L@n`W+x>T7%rvUxbD+@sAmJqifsf?B@i z7#Uls*5`7I>|T9dVnC~sr$XNBxsLOX%u}br@3X_rHP%6*%O^x2U4i0dn-hMxR8CmZ za+^C7C#Q`j+5K(&{=q1amYh~kjg<$sybKR<_hEgYG&ia%r8edFjayMK^Vqp@9ycAn zzxvESITK`U`X2iU9f~WQoAcy#RannFy@31)8T|V)Nrp&u&Wny)w8f&N}zaH<ej^`WS2v$CbpJZeW_?E^h%m=a3w6q1qPDYg^2mb4%?GFqj+q1OTF2A3W$Fn?aQk@EFVAc z&Zv90xPGd*KKpPOQx5yY`_KOB{HzW2?JXUrh{{d@!e;|3`NzhDo$m#Nann4EQ3l69 zojTPg%dms8#U7__BiE%M;gf277<2uGwt5NrXKVf{xhsNdhm0MmX9boACZZWXX=+hc zmeeh?O7h9g2yW?r%-XRRjxUxC27eCFy!?w86YRu%dZqaj?FXnMW)HeNF#QRSY@5Ei z^es}MGrwox81s0?gs(;NoIEtMQrODLI%0oc`f<2D;TP7m9L99gkhGNCgn|?s`;4R% zt(5AN`qb2r>~!O(Y&d(^JlmXVO|25+4B($KW6l0H?L>uiG=tL6kZO%u_Y~wJ#JtJ) zzyNeyy&5AcBXe!mn1yMRXJHlG&TfL&jIm<9G7U^bxxcu@eiD_bmWv#}VV-4LQ4TPN z9vvMMLstVCHx0%i2Dq#dxE^?)rkou8#BebEc3B2^>*q%)t;=D-Sz9JG+|;z6*4hep z%)hfT$f)=q!vbD*$FrmpK;eT_*;u8oBUomyl~vHIkXi4*cyI)v{lf zRW0i(pxeNPB!~=fv8gOS5xLsft22%oFSk!wmk|NMdCcP3SvKPP*vvLj2#M1gGe5uQkfNp7KKwp zp`k{TN^jBIJ^moYzn}^K_lq^WW-)q}tUeDf_7;L~mR4dy8j0d|i7><2)HvgY{DeOF z8ao&HKS+>pFVoBMzQ3*?4^A@(=Y?q`+d#WZn@)8gC(p3az$7gY%*D@I(9VQnK;vl_ z(G&$0)^gJTW*Ghxn6#m^}uqC{Y0Hq zShz(jlLkGmqGKBeP2w(F-A$KxHJvpoyX);km4IxSRg8SUbOV(B28!#|7ftMl31e!sU@hkUMaH|wn1tYST18-x$_-R9?7o9^>n0ji0?5kn;_*$84G-^kgMxXw+^^ulI< z6PO}k3^WQ(lYTyGJr%KE%6HUrQ<4n4?eGRb333<$!Y%y$7`~e}g>#X`ye^rPB8-2$ zaq>{S0F6s1;q;`y_@;ipx8sm-jEI``wo679&Gt-??>{z9W<09x8~C5L7+~Xkblt{$ zY#df#rSt`8b_=qNt+ZNr0Z%Qn(X;#DiD2hjyYY45o3E-BasQ(m3KW7v<5X~>6G-@{ z#rhAOenBa6E||`YotUoh&$y|d4(fw}VL&F8KS?%x1C(Q|YuGugvLn6Ge&`Xa#v8;p z5FU_=OhIG@&_c(ft;T`}(kj*Bq_UE=>No9oU7SlwB^np6`ui?_?wE0kwiNUYUQ4yRG89~A&rN77l{ z+mj6%qwxt3SOyo`g&W_aaOy;P=J664uNU#=ghx0=6+OI8)y&^mp=zc8t#%{VtyFnh z&AK2OEc=b8Ff1N|Oz4~7Ba@GkCrsZXH?Bz1J243vDccEq!F~yzg3`LVkUI!B1n(U+ zjX@sR4$7L(*uB!)C<~PI0|7!bXLVeXs-r7das72V&BGJ=N@hX~W&L$58Q)FB#GW>i zteyEU`bqCP={xE29^;;)z0<3kRrfe5*;t;+14ibqESxUCjCIk)?2Rsgj?QyWCzXBe z7fgHB?spe~GTKOMh4`~7(q)q*`o-`N>A?q!Zuxz4+J)p8(_$hcR$9~?VW-wBp4MX zi$=GTrwIKEr$;BTUzO|K^)p6V%4(KsNkl-Aj+%*L^ylJK$GW^MCN6T@Syxy?b(o%v z&wbvmK9Q2{L#yv+QLPl8o*_4A;6(%a`sv7NL`&$@;78W4Rl{kudqR>+^;0Qjr z65FG@xQ$y4qXE3bOOPUx+ol0har^TkRfZmnHIKIAIVv8>8gleXS#@xbZg4beTeVgU z?J?FP>wf0F;E6Jb{81&0SJuDCj}XIN%*>|ttJUpE_3XRJpTHF1L-U=Bnj z)=1C#RFW|ClZmbKQkwLrQ-xMoYH9|b!*(2Y7CwDP5cJ2{ZQ(Q5@MCGs{xkag%ptW2?2$v2nyXp?=s-Gr2*2{@w=+w{`Ht!yoIHzcQJ2QVh~4 z+DIdqKmxxaK9nc~F=}J7cH+`Q@Z28hI(+{{xTe+bd*9Cei;L&2H-8@oK2&0$^%y9F z&jKXurH@~sLQ>&CRU+4iDJo>pg4X0qSpC=HRp=G${i6K1ANLR{o7h^VNLem@QuKO| zlH}8g#~Hijl-j;HB%C|f_Xuh1n7ts|&J=a6lH%!{y7cX!{2U{Q+FYks1T+0+lNqw1j}&bP9k77ddKN%D%mG!5QJO26(M9J zlReEE@=q0OsuF`>QUzf_@SClJ5PX6++tt<<`KZpOt<^V)gjB|Vp`iS; z>*bn93dA{uO%KX8DdxI;Nutzua0k{(dV*7LrsrDBIqd<~kO_(c%4Akb3Iz%@n-7be z2z9JJG6gluaMl~;XDkwZ_<5PQZ>(TfQ)dKpmxQUc^bcr$aNsjb6};?21l}mbqAHU0ar}ZI zBP_H`=1?axveZxFG3uT##WOV+-?U6bgRMZ_U&C8%W(bPP%r$dejhObds* zUPrOV+M<4o(M|#bvk2KrB3-PNkjea9X^?_c+jgpkzeHo0e<3=RYdof1B|*W#%h^mD z6S=7B5}8-;n)n?!C8c?+<+mK9abL>4YvkcE!yMa#YT8(q8Cv(fI^#qAK~`~4 z@3oTWwT}gD5Kb1G&!OhBB~qH5brci#*yZ+V6Z!7oyocLXNEQhnh+>EW9bwC&DxsEp zl~?6t!95u0qll0*2E8Q2V#b3GT>U$tP*$GNKSrp!ss%U*SC`GV;M25&vBX48t=ubq zAS{rcH0ml}E~uqG5Ng{H%JeJ9pRg<-!C`S>@r$UZpxgcs^EJl%XAfj}#H=#wi+afX zFopu#QhW6z^@W9^-R{IVhU``p&{tOE{@=g|Ql1DUEm#GV@!!h%F(2afUy!zYN(MSE zWD)A%D&X7!yg*tbzYQoUqKjJTj5$4log5Hb0669Ie?mijutguGHZ_^RgfpsE=AlVb zQ!izyrn!S^I&Lu0j!;(fOXK1;ggj6IAD%8Sp;2Cf|JhUE4~e@EEDjJa(ER2%#!Cqn zq!24D^c>rP6jwn|5vhdIVfaiM2<3GgSlg!tO!Oxw>p4L*fK!o4P5HMDh;{@Nd@cuO|j7DAB%*{O@kz z5c(-dyfGTOq0c7q3u$;(>yLMv3P#Q8H)IJcpt|K#XvTNIe;WA+5Q6{2DdZ?ZNNVBJ z-WF4w;NtVL4<04345ZEh31~35#9FlwcoS9ge3od~J=CIIiqb>5|%h=U;y^FQ9dw`TU`zQA^c z&s(2cAzsBFpbxJx1bRfm9Mx`Cel2~<`|JIiD@#r6^QWgZU_h(#T22iBeC;!g`SJph zAcDhpdVatdxsM3|d^&$k0Kiaf0Zag(#TaOEG9r?M=@;@wwY0XZjgt&0h%fn=0Fb*o z$qDYoNE>6m&xi1fm!S@fS+P}U^)WAmaB~Z}e?gP5;j8qs#T15Zs63cmbg?bH=HiM- zbe=FIy4TSS1m9Pj9>`)dONc3o9G1KQ`5!>)1I>A}s-2Qm4b14&n(Oag_cyC{T*y=> zb+T25!R#KFdUZq0n%b1ees9q1X}IOg{)_KKnxJ2Jd8^*2NqXlBb*s+pM??3nET)7UHLcwFw+tl;2+EzC1P1YTTEz`Lum$Z5!PhypZZ0;HYNGZcgyMsyBMNs1=qtC`?odSG}9qiv&?Q^E{+e5ga)&fN?Bg z)k)KrODz;$gWw~0SP(LE`ll=eM&dajLsUmpE7McKtAXb48RI|uT=^a`6i8>jZG^iD z%qO-;WTwel)(X);s8_3tRHQSzq!D805nr#vnKm}iqbsa$(tx$@o4k=SGF^PVf02Vk z+4;aPmh%^LY-tKI;At3sRY{T~$5!KRIMwtQo8J0n(D}iO~X6VRAuC z;-Or68S71se!9_!nD(byg_J-mBQm2B$*!d_)?Nl*<__}iYXV**gq#O33zlFQUKTG; z-@%W3;sL7Q|L`(+A=a4sW#IrEv6ur~f({#{TP1?J2V(_77&{iY)Xi@9al$n5pn^O> z{^=|NoG@NM!T)uuPnjDi#HlL0h40&aJ?NFO3&nD1+X=DRcu}NWf`}o^ukG^#k-w&H zPPl{xn<$~J@5rZyO-gFK%P2{PdWdFoj+5KJC;H#3A+Ref2hMn4ydtx;r5#hIKo$|e zJswk#iBAe7+_I|DZGleeF4%r+BC(uEFK@OIeZ!b@toL2yqA!N@WC|rgj^;H`?PoqI7wC6Olc>4R z!vzbR^l^c}r)6`Rxtk592t7NuJn$X}w7QO$%Id*1CnMDacA|o)d+{g7@2(AJ3*Kos zxV&SWC0g-~^<0+{(cE59B0)pUq+sDYm-f4O*VtjWPB zNt17SzK$%}PwFoy&@}lj+1|yNlAu?w2zRHPv@RU)b5iW;je-<8%rL7Ts1JdGRrcgBFdR8`Wrg{oHu#D9T7$9Pka%^%2k5 z?FWj)1aRnk%Olg^Av;E7Q?4$J32}S6Jg#+hbQl-UxIu>UGJ-jLYoE{WCuwUZgzt#J zCwYlD0p?mTRR}FOm^RX&%;|;pCi0lQZ2Y>_ooCslM-&+YTc4tm88_i*bDU1CV&@w6 z9O5A=WLB~nZ7Wema9^pPBK28&RoAQ#?%&o91S8wBUt55)dwdP|hl5Gi3Gc5dui$kK z_Sk&>lpF!nRgc^Ty97bb?x)JyqyUkqgZ15j{|CG5?{!Cf?PeXR{PvEJu>%8yzc)d= z)o#^OKk>V~toZ1wl;oHEz3#}_O9iP%^`h6?#Qu#Ow2VDID85l7m-toI;wWy9XXn6{ zi1P6T>QDO?up6U*T>gvi{_-bA|I1mO$lUj?nwXQ>@21N^tDE}(Xh|@`{@wnKQk{hjT`uLKoX})}Hq_=i(f)0&3 zQtjD+3H3owoR=ZuTUIAs=f$)HrE^dE5GLt9KV=*u^0@jgl}q3ub(E-a^;gWS@>3*= ztxtN3h~dg$+jB3eKOPMarth-)Pd;+%VBDuy3}HUvWMQN~`hYlOC6Faz%Mum)&pA!i zqe?fPa>*s9AvDjRZE2qGVHdXSMJ4oPUejWuWCInA*98~mDaJ2QrraKfDuF2X@TQB& za|(I>Zcv3M#**b z7%&CG;wl~H9tW3&0u*|`CQJLz>Fh3=RHa#oaDYtr~Avl32E^>A0Ft!y@6rxuC)N+|*MdRLDM#WFl^0 z%)pt*=%>N3hHjbY-o{U?*zxQzY^I2W-&Yl`U&x3Uu6ePY1L5xW9&>{mfm;lTo%CY0EXK5jo)1Iebw+o)!*$&r!!s_4OWr8xyWXXj~b0 zgN}c`Oe^>z<>JoId_5*-#JfLi+Y*fN0Ea8f+veUMI&EbVLy&8}@E6k=#D}O{`qq2n zJSgO>)qP-Fueo=>Dwf4(itFLEME~8y<2r*($($F&047C`!RvE)U2;$b>dL;dWT*ZK zpG;MN0?_PFscEJGA)7n#_Wp9hWV8ZlFs5>*OYi}v8WSABb^^j$;aQO1i}Z}0S&7H5V+$tt3bkV9;w=K{g=co9ckD`rlB^N&X$OySIs6tasThn? zcX#x>mE0<`cGah_WD7C(O6Cul&9F`57Zbn-e_^oSc@4q8wqwqJnxFTdHp`7&*}_r3B}^lI8`ri(wW%@ji#cmFgZOt_c_QV>CD>P*H25cp0g5EzdH-doYj!f zfHc@Bo3)AaIQW7TPmCkR&E0fhfFAt}IiNHP*(~gl;RX=ZT4jXeTkHySM39RbTlVdn zq8pC@5<`%IJvA?3Mu%IwP$i3vcD;M+}kGT=S?qD^a|2!&27^``$MB$;_!C4T31sj>dY_0E^+IXgk=on zZMQ|OdUO{I_Fdc%s;vPl%*UG#K$1dPDlfUUh_TVtR^Sot%6tio;K;+&?Vby6t_N(siofq?JZjFNppkqp%iw21c0C4)GBONQxFB6z z#V^IUx@~-L{7P;cbV3eYycusx=4AXNWOK6tXXia61oH(?<`anNXI&5s9u84_a@a0IwL^OsSd8vD4+_$4Ima6_8N!AJ}<{@sT2Dq*AyDB|D=vN2# zoEz5z*@!A-*Xy>8W1^~^Gkp#D2)Q6B^LIPY2c3$d{47B^Nq0Um;I=%y)jTz&YQxm; zgz$VzC^Z&`QPBdutim0z61_e>K9;Uwq=OqTVwhM^95afFN9WU**<227*mt~sRa8`s*{&Gb%I^1jQRb$nWBzB!3|TJIsC zA&__ryWo8#s2WE)?2YQ*hRexP+ncm;xlf}QR5ztFhqWKUC>DlY_t~35wJCTqfg8tD|Gjq$?|0v1v;U+&sawSS=B?rOQ)n+b?;Wl2k za43}qS+SBiZuDa8Q_^)P7r8!`Put=PeAPJAVRznKe`3bVi*c+kWRQ85*LV)o9$nk@ zRm&H%Z`8W_YCkN4vpv@fyU>p_Qd1>yq7_*QG@_QeM;2MWgwEa5STpgu)9zQ)Kbn?R zAUz!0cYhBO*g}x|kO2m0_8uSJc0IAF#k*xa-2{f8T8J_5t6=&juC|w)%bE0Mt8I;D z=bQ`~deC(DlNGg?npN4?Xr^BpTyRu<2~1vNLT_Pw9(V9WY>ph_c1C5n_D_Dv${2gz zuOHm_jUz)@F1v6+NKS~^xqoVw@tC)B&odbN1&H`NBm6%`oqlPAm;Nq=po}S+e0hqD z1PlQJKfIj2nK$(k*kpSA==nS9^wj%N9BIkEMB`lj39RXtSSXu~KODq?kk)K^(ACK2 z)%{4avpeuV;aC9b{HS*Six?9EmCxt#A?>*#V#$-yygi0zDKBVx!5#n>mS9IRY$2v$l{-R{;!U8;Z#yb!K z8Iig#Q~3v=VX<~#ks$L$r5-fbaB0QT1ZAoQgm&6&3YmJ8nn%~)uVAe=poX_%v#98# zy=3p9$D6g(0ivU1CqL7ICRKmYwAlL!S4q#+v_pwl8MtK{=VEZk!w-e6g>z&gvu{>0 zM}$-2Kw)AbPm0)!CmOy(1|^bG!_j4-nPu&=e}?|K%e1o;Rj$5Sbd7o1s^R!HX>J!h zu>f)61eF@U(%rD=@Hvg{1m%_K7I7byCDs?bUg87)u702sUkU>z6vS{9?WW2(%oSPl3t_c+Fvo3eM^eN%;a<31VhlO(wXFiBq%Lq`sg9M774l7;Mp69cHv6DHrN3(r$j_EW{~v@-fbmz zfw=K^5NIu>=bXg@hZ#HXdhcphX?=^jU~T4pA5vuL#Wl6lqJR~R-oCx7DV=pL7r zP6wexB6ZQ!&L_1xg#C3y%>#_Y>QM)OjP zNM~p&u!7VI$(X#j>fI4@oGNLaqY0rb#hgDvwMEm4IS1fg2%umUS-cZei3tE><{FrL z|LOe)NM3ih#=G?l*#rjLZp&)L0L+tOD+<&OH@wRt!&-cn_taEU54V!%=yWlN1W| zp;Al~W?vq{Uu|JbpABgZf-cK3LrjkXAK7 z*x$#mdGHwBG%Q@=;CT2X86J5$NNE;dQE(viO%wE;yYVY*oWrTf81&Juvsh&|#b3QQdVr}qp#EpHv&6Y@5GtpcV*M!i+FSg*b1m=x+ z=p?^PcUaE|Laikp#_*fad@^OXzgW)eC2E#njy^;YGq{||?;@jot1tC_2C8?20p9}S z1$`YRxDwAWXSwm$JU#2&U^7D{1UO0OKa+9!k#uZuO}bdXH(8QFyN6(^6mj%s+PEsC z8mdVg#v{_awdeD$)ae~nO244YmCc82u8o|86GTjOiss4uI=U;TUb(vyP?JT-16k*h zl(lyD6fIKem>+?_*v5cESP4V2BMK>?Pm_>k%2XY|WG=0c|G~X}XkQ2_mxh}p(iqUn zck{DE(_zY+Yc6Dfw(kI<-1Iy=EglmX4_F|^0v7M~z&~h^Bq2f)QODEJSP(}DeV~C-TgZllWc}J8P#T9r$fUu{1JYqVUoj@^x`&VQ~TCF&F6AC zW%9{3&;607eZO*Fr8kFrrE+!izlphVGq=0O2?wA#}3u=_&82HOQ=G*ix*MvuE{EuX6eGhmJ ztex7)kYleoh-L>jk4NPnkZka5bTnYLu%O47D6I(i6*{6}+tv7TxzXyh>P#i!QL5C;`-r(RjA`*tPZiUZhD!b)s_nOKgUiE57L3HL zu0%`#b>lqfQwFfoP;|hl@~acQ_X+q<#}7b@fyztTHE>s)j*gwZD%Jz>d(JTGasj)0 zZDBnSkUI(#-3thBa*vf)fJLHnbp_vyGk0gmwSwX(71;SiBwQj5w_OI{#QS>>g|85~ z->$HJ1d*(rwREF`_;tP`V4v%0x8DjH-XIT)e(>DY-%+bxLH>lA06+Zq>fM-0nESJzv?$&$%=VNwzO*T2IzsBqiRwG!d?yo1LPY@ruiQd|YNNAux$a>Dm+ z+}#tnFc`|T-{5~*1b}ObK-K?6;ZLt$G;BiiX=6|<=Qg={=QVLdFmzn~`s(m)0pzOM z$h@{s5rk;w`_xT|{L=jB@zAz$tQpueX|&c+8_b%RRaP~Ak&E+3&NsgHlffm}pN13w zh}N<8G|%3Fa0R)>nJZ=GSu~J9UKvo~z#oa|{_SJ!sww_~%JQXvQMA_j(&j6sOyXwA zGx1{?!;ewKK(8_AHEl3}m;87wOs^o^&r3c9WUok!V?O_UZm8{jynCE3&b%xA&=ZQ%riT$aK-&Zp8poY90pdia|G-Qu`*8~Bp9)$QXABu z5T^OY<<%km6p#0tA0gb|gZA%eV{d+bLcJQ-eYb8;y^q z1t*qG2)pAt=I?2kKpCP-LoIbrPz9t%%z8%eEt~haPAR@NFLg zZ_Y|FG!!?ZclEy~qe_30dEonNzc66Q)ZKynDF6ZDLgVd;o`E~2xZ+L=fFACbyl`L# z3P=_hr$US5L&}4L{rv;E33FE4Ip!_ZqrTw#}c)8+=D~ z79`=^Sg|6{U(b?7Hq|%t~Ei*9K%@f2!xMJ2k(ip?3dOZWN(m1HjkLe28Dh` zeikodC3YD%u=w11{Z>fGUmhE@MSE6~vx>jaZ(sb*Deq|xW}FLv)(2j%cEhWa&WfwIT9OC@3twtn5cm|CEJrN zOFcv;EODpEbeX~A9gyEir;>{kBs}B+{P^owkP9vF%Z#E_?W@6%sQob<{&*I4S@M># ziXYa4K%iUKbNxegOX}dNHy@khPRMGv)6<>ZbK5OpP1752UWYEm14vfmNnIccz2r6m z1}+CW1fEF1zN)1v5wjKjbF&`jo{w}02@P(!v_|Y@QZ6A;FRy%G`hgoikSveLN?V6Xc$?hex;zt{L7C#e0D|3ooQ@I|pP}5GWt# z3{E{J!vn~lPNaV?%wKeX11QmNk)``Ecfan>Gy9OV?58I~?o<*77tf2&VB|&t#{_0+ z4rqIA0)PjyiXLEKE}HMRF9X56OILM;t2qqI5LyXt0jwbnW~Z>Zn$EP2g+#;A_0#Vg zG&)k^%u6pskuDQ_8u!O#46p-Y!1V+3FMiC0jS1*plH7nL^yU!V^d`@#^h|HA;cR|jPaZ6*&4nro$@q;V6Ivv6123vtN!ZZze){xX ze79-^zpwWaJD|_~+%+*&d&yAjO@aXC>3f@^E`}1TEUBc?rxmdj$s^DR zV?EZ8F=LWVWnlesaO(L;PT}w-Fw%NX4uO*7Sf82HDIjt);(EVnE2s%nOsQacV_mIa zt!eOBvarbR@f8IB0N)0lQ!jJFwZ~VE@g)9$=Vn15{A8C9yW|y z?|D5#OIZo9WEa<@X$-7%C6@=qWB^xB<)NDTxw!j9&)9*P7w(8Sm~a|w5wn^>>gn@C z2;RXGN1{GMJ%bbrkQsy?QUIY+jLpN@JD--}4`wj_(`5vQaFKYy4p0X2%$!BN@n;NN zx0I3!P9p{0z#5?D%}2efpRF1D^G)@6sG|&N0WlyD1oG%No0Zq`2&Q`L+R7@uj(ps;3O= zBv)jduvPuCebw~kWBc=v_JcQgiRII=Vt2lR~k83Qg*eZM-qf_cWEqEGaoY*JeZ~v8)q|K_wF|F^ZQzE!Cp;_+SK#h-Qh3k`YV6PE`_}k z1=NT6yAK0cmFx@ypi?eB5g=VHRO(CJjd9>vp9)_4W@579VenZ4EP6Gug8rn18Ek^aJ_W6b#;v36) z*=RrO*COZN;%GF~2|Q1Kcqyst#@%Om;eN-F{nfeKvJgm+?i+|1@>UfeBTTluwHHp+e8 zd6p8$=ZNuwU4LT07QB`s!VYPY=kqiS$$C|M;Rd7@us$x@PnKDSD+bxJS6|i}=A<7( zC!%c#jTJ((?O~G<-V&;AA0`$_f)TZWsWZ^8gq73T1L^%tF#!>!+5!HUS8s97gYASe zfX@dU!fed@4BA-5B5sqiO2%?rp-tr9oy+&!k{3#ZX|JN@lTM>&dj^1)(@n`1foq~F zjJ|F&@$L!&gbD&0F_WDrQxT{a;PJtKDvH@Czcd~HRFS#xoe+$r2bIE#poStMDE2e9c z3()mMaWgy0db~KXAzpAyfp$--7!n?Pf6nULcwk_Z{+`PI4FRTnw|=%Qk~YB@*mqbo zln-~nu3}W5>+7LWS(Jci6>$m=-W&JTyoWL|cr0-FT<_NzDGDMMqP0qTzYx4=8T&@& z3DORY10>Zeemor4FHseVFtKsFZ+mC9FnZmBZcZ=PcY8Es@{DTAn2zL7!{90yto(O$pPiSQ(6Dn!|CJZr8s`5ecX5>dA7g(h*F*Qkj1|W}btSr7Q;C_9BSAKDUM03;r2MJi>jLfn zt_LdVd;=6SB8l^ENo_2+$gDH6(0E=sq1PYZxW+A>z?&yuTZ-J$rT;1)7;&~6BNsI4nk`-xN=UGTWPpTPCI#j31nN{1M`TZ;2#)N@#q9x^jI-f- z+)G?7Rj~U|1|R^sxd4$oS**NHMZ@sDhGZ1ewMq?F+y|EmG&<(8Sc+%lW<2txT=77o zx>9X@ky&L|ETlzE3Vnu82gFFT0%yz=?wY?sXh)~+J2zCuq;#Jf*6atCm8k~o1zQC; zwd%M_&3w&pxXK~$T>os#H35G6CeDnOtz+PD!Ign=Tn|h(#yzyL+7NjTujf-nJF5e;h>!7pb zL9mf=Wj*KQjicI3%=ASFa8-mmtx~OY4DcCx9kg7K-QK)o`){m9#T#Cyk?Q6n@U!Dd z=D?c1t;$7+a@F79U~Y1Y|HX|u3e znOJf*wI0vGD0eP6v~}*m27Jx@TVE?2V#EBl#Ub$)M!Q@pLpAQ?%$q#Vk_rPh0X+ia z(CL`GFVFgj))}O&8DuN|Gf6Dk?7i}RE-Uvk=$^zJ*N%lAS2ICN#f8r&t8E?*_n5|+ zAQ2N08S!lwDD+B2`HN7XNDoT6`V#BU4u~b`z&shkGGH*0p!jlaDSDdhJK?jl3}eu1 zFPc=GH=n$rw|5_bO+v+48%aYjqUZFhVuZ~UGdcWN>prG51O3dp9<&fSJ44rwr4-jR zFX_Ii(=Ej7xKaUu{FN5&6)o%3;>IXyI3?d!|LIXu>`o zD~S&BT|*;6?CmBdtyHGK#|}m0=#o0EZn&av-D{MvOaXHpVHNT zqRou@!*`HHEBsYtpE_0UQKO%DLoi?D>&F-CV==KGA3Tr0_4xNjiz=D}yu#9xjHqGNf(!m?~jpg!j;3(e)TvFc)s zb3E}hD|@4KPtS#Fc;y{9>hL5fj!RtTdeZzE^DTvIDZNXcU7T*8)2-y|YkD&nAbLpg zDdrnQ+~MD0CfQk<7gw5BDGuoQ7I|c9_ArG9l!FVs{Rze&X(xryu0(|=ve@Da%2AN) zo?6sXG0-cT>GKvWgiHk(hNMT#cYxq%j5A#gt&NM@$`Xx@Em3-59?cpZfOhuwolu<| zZ<5#@m2c6S&?#UW)8*t%B6i;Vi^CGo=>)jL=rQ}(y_4iJQGu9qabjOV{w_WOaF_nn z+x!VX#0wIE$Mzw(NV3jDdk_v||1crU3*)*tmwp%<{F!QECG!ogUSAP7NCGA03S{GU zN44sjCL%w}j=-6DSR1MhX(2|ffM+Tf%j9Bo(Gj6a0c`{`}1a-e_&%LHz$kvqS?@m5%=DpmNQ-s%UV!j{YrAImBBIM*PV>6Ikg z?-eupNN;3RdCw*H54K_3a7o<7I=8m%v^MEC4Oi!jgjT66&9J29Gc%wSJvz-!Cf0%S zCWnWw=dz!4>N|9s*^Eylit@U*HCyM93K~L7r5NaknCPHex1~<8dGAYR^D1vv0~vhO_7ov>Qd>#wyW@Xb@fG3H_j8-^(el*J#R)p z2By(20!B1BDmudSr>pxl{&=u~UPip{ZSobrajk$FeIfNi&*jN~qH0}$J~j}?9ESyq zgbj}|TT}0_^2|zcjB%>lL$0T5GWiTLYKXG?inZ)puazMX7|dw~Ib3-u1}_e$%MI9P zg{B)DQBt|CvZ450s~OJ%tdr{xo5$lYoSX#BY+&b6?PVjay?go(xl~xj7W%io&Vyx^ znCx;D`pnnlra0`CTv0$XccS~5vx%Z|%W8^O0a?lRB@d^YuFKlgNo9rBZLbZLn-d#s zRTp1rl-U!=G@gyaWp;)y%qx7m+MCSG!{8T?U>KI&MlU)g8RpFARI(1HFpBkWodS$+ zreIbC(g>YCrOZsP7m(lDR+Cd+5KHV9^86~HF^I&ENrQ@cYC(>1ub4cY+4yk z7O};y4tQ8uFFj7K?X$##G6$~sWR5QF1aubyH z8A2v>-syG+NBcMp6X`?f$(jkn%6N|p=`PV5DnZAwuA>6&E+MXhnRw{%{1~y(5K%k4 z4Vs?wtjU@!@a&-g$fj{~yL?%8f2 zUls@nWBE$QIq|H9FxJmS^|l3~kljlxkkYBQP1kAe@d)4c&7ux`3j9g1+K=<6Ww3e% zzh8Y_#V~=x&kg?OeNa=GzF00Ef_d_XOTxPRt2+Om__7+6r)F)rei;!-*ven{cxAYS z^VnJSSv;6Yw{*cA(cn+J_~6^%<|sH{bhGj#)b@ft;B`~TLjO~9(z(~|p5?6vPiozq z2E{BgZ!iMhUt$@4_e<4xZ4W{t>5n<7b3h}whuy^Iw?*kP*NY&*D+VW6ks6#_iVxcB zw+YZSqWIAhy#grU!nDHJ(C;lt)>cZ?PA)|nDE5byT{c^YAEqQ6E*XYkHg#mrs!%bk z7dDjlFf^$bHr16k)wPVw4NU!#)*vixi4$M?^Aa27_v!Ke>2ZaUvQ~UWxuQ;@W?}}M zS``q=hV@`~W`=-(fCMprBUv|9a~05N?pw4BG7!5v^Y#s>F<)bbo`Iu=29Hs$OelAg z)tV9e1Mb6G?7qEG+K8GcV1^j4wC%erX{o}Vrc&NYmRbSqm}%XqsevNZf9CK97*yuT zbVgM+BK}u82?rA>Ga6z43G|;B)5ip}|GhEg%NR;wy-jqIR#8Sz24IA{q}$thmW6wk zWC}vlN(dl{0W|4-G)x^}u}caYnw=?6ido64w*nF0}} zflhyd{$0uvfI|d;dO!2k57p|j!IJ90Xp^$R&>Arz~4|Xsl0~p3b~t1V-;>922OtoSR-!>kLuE? zCcIs&ud%Td)B{529Skl~mIL&;V~-v*KqQ3VmVU7Y>CqX{so$Arj!DSh4!)>;y^z;J zEbHgyWOgiH44DS(?!NCtvjM`y0X$u9(q}y&zr&gY5$evobhOK-Z@h+MtttXx{rCj%FgH@;AE-MIMTcDk$>DJ}mX(4NQi~8JV`PLVxa2;pXW6y} zQrW9{ddql@xojV?vdO=S!T(A?5NsDbZf+wS_lYk_tr_lW?0}-t0zV&~pZ_8IQ%HTf z+bE*Uv2FPN1=rRtHQp5Qj1b?Wwz^L~3_^G1F7+uz&EGKNsl+{ISgD9>`q~`1H2wPd z=v^Wq4});j+{JnH7$)FhIY;UXMyaL%~k3vo## zvjK}R7p@JXST_{RB zU1x4b;9;gt{28LvzgA%o0VTuh@74>D*GKatavs2_9^*sd10wzo=KCLi<^vx$9RnyD zUp6o2`(=S?0;Hv|0;`o+NA3P*lZxkj-k;CRBtf;j2LA_}{YQJ?&t?O(2l9Nf1s+Gj zcqC+P9p*5%Nqff=Yge{{VvWhSL9|vOOaIayaDl#mjzN9QPhw+mV8{=%zV>zYi=_v1 ziU~;+#4i;K{c9;KdC7C`{t<9{i?{f1;FgQpIwFf;3I_tD7z^om1N={xvYpi#m{SEH z=@r($g!bzuP0gHS-7Z``5}V zf(<6Bi%R2-lmGU#LA0yqZ=vJy3HPSuon6185U=a>!FPW1 zXj#9Yer`ESSZ=6S;fOWNL2eQJki#!f%L%vHMDqRy3FZd1)@VTXIcbIREvdhozT||` zsjMX;=8xdGel*qsHvpRwaEXI8zub#2~tn!p8ZX6Ode2k$-kk; zEX{a2-F2WC5lHi0{LB$ZRje-~F<_9Pg%nBcGsnSPY1eSrKv9+_iI^39#U%Y5R^BLS-TbO- z2FTVzDt@}3`Ti8fDNoK09FaB_qK77EXe3l@kj%JEyB3)8%Ufh;4bzEWBapyY2+U6z zu+qs~y~%2t>yf=tDaQR^47~Cf)I1coLu!792m6-v^;kiB_=Q8qm-yz6{J{%gshd(#8;R;hr2YcCs*ku9w*)h$^%G8;FY;C4j1)b<-M9JZpI|2Ag+i=> z5pXIm?lnV-79f7uSm|FMj_A@Htbd5NDj)(*%Ack*f5k!UiQv(j2{EKmIGan(7};;> z1ycA#UHis;HxnY@mR`Sw2qnbN6QKuU4w5zbwTt61!R2L4QZ^$xkPM^S2pbPeV*45? zEdOC@V380__7DIVLh*f;159wCzkOlmbTWH0Ayslj%zuuNh*EhU9RZJ;$NqxDWHP^2DkQV!U@!9bGMPL$i)U71LiMc!4k_6YX|Dk7xD~L^w$_F zn^spSryLc+H`4I*3vNUUGa@Cd7^qKuwRDqin@vZwLd?LmU1=dKS1-p8YP=NP48X62E^2l*6;*Rkk z?O0tPTU_IkkFcd}gbkarcuOj*2##=If{}ehnv@V5f<7E;bC8L8ul#8N!|EU#|f5!YJHK`IYA-Ea@hK2dVyH+hE+NK#@v|cCyBez^BC?fd0yf!YVrPf;T$q z4e0hxT(4n@0NoMU2gv31@z0Ipxk@TXn%aI^NK&rxUDo*bt#&FZ`TnA3mN7}b&)0a< zvHmy$LV=R!-&rbg2qX@B*T)|mfdc}T(frk z)O_N{cwI7Dw!A!>s&?JkAj+)=O!$Fm;ob_@ftH}UR$b^9VbOh`3w_`@4YWsu^Am-h z)qnp0D>-n3ZB{>z6Z$UAd3?a-gKW+dk~B5gNcNFL2f-VgS8_@4QgaOBZFmfWZ}_0F z^Lw81#ONK8N1j*G^Y4f!fH>gL{5VUWuhAH@I1u^=80Z^_c9Ke|h6Pb?e7Ss2TAaI$ zh)^^#nt2Tk+m~ho7Pz{onLZoBpNii;xCO6{iijCp^%t9EQVTT} z(7xkuz6~(rVj%7RGGI=MB!#2*e#s_d9_5xlef2}&X|cNiiXUTvuQ}6q30;{5|1w}k zb~ZM4wt!v^AQ)}J4*eb~8pt+rnFo4RYaJMxLq!a?vBmNlK>{xVe^_>tdGW~@6q>yP zSpJznH1$HzGdy(*R4^ zdTVwuUhYAiVW9)WWe@&(1@#YX!5`G{U$#IAc~+b!kWGgirORG!76iHG)#qzS{CJ{& z0?9kHq-7q&|Er9BVx#m@LA<}ViTIYqWhBPxw?4K)fChnH7Kk%O7(KyDLf>~H2skVU zJ6-x{=R#=xD-dW~k)pCXHhKQLClr#|))n4}KgNT#gPrmg`0q>+0PoMdrFsNz4R%IH zxW1s)zGr$TC?No8&qBRifutLj8}wvHsfvKjZyH6j!DeTcU_>^ZC+$PCSZ*+iW&l=c zx<1+{aDTAQ0~KHNd6QpcFGpvK|9$V9PL2-;D{BQ4C{W`Lbnz4D-`P8WTixp$=@Ymj z`uo0MoVwg1!=oJLGMD(8Ahz$C_)8y5Xc9Pf2jz@O_E1%JCaZ@);qZYmMaNWB`W+T9 z^BhX&e|*jALlP4bMm`yHo?xLGEMofu2-!?$mWV3kZpvESYQD4oc^Izd(Qj{{{_a8o zu2~?E&tKQ94is4F@3Qp&%a$7f{at=2Nfr2-D4Gn9Juh;5$8J{2yH`(>SOWpPWsRJ3 zr8?#t%KPMbf07BvTdzLv!7a!?ieQLY4&XC<-%A`!oHP#kSAGQ`Bv~+J_hXw`zI#Rm z7znl$;q?tf=E1cE?Czgtd)>ZhBhR3J*Om_uXC8D9bLgibWyqT> zGNc9nMwoJzJz11IS)dKRm3=pfLdtO5ls)JipIj>KVyf#XZy`-1nF$Ld@rJs32cD1y zA>9%V@`}B+YuEEmBM8pR8G=xlL@9^VIHT9oeg~NMzf;#we{edkW@|}aG9hUt@@g-QVigD!kOM1Hg zMMZ8s7W-QNMev+-NSV;3D}laP$9piG(QpDsyUraE?B(e%$1aC};^GC+%jW<8(FOed zpZco5o~dafa0W?!YW~$Anv_J~8s*oYg&L76o2kP3eUr1`Mo2l}377qzBB%^qF#xIP zUm9`>xKc>`BRvIRVL*=hN$)&d5r(})wRm4aNPpQZvMvm;VJm#y;wPfq>-k-oYiE>r zVVR=B<&UkQ*5g_G;xf}MeWOXimXkMSJ5AYF?HCX{Km;Gy_oZ90ZS#3cU++*!eK7HX zq)YqsjceTj{sIS9zOg@_!lyoq~J`-GLP&RiSJ6ij^%i#SMuVq zhP$FvRb+**kaWvoz$^3wRpr8Wzu;2RprP(Q{rY|<^&L86XUj8`-v0D<VJ#e6iI8a_&*0f6DwFoUjiPISF7Cb)I=9$jfnKZ>4Tk<}2GP{YK{oV3DeW|nk*?pY6E32i5eqc9cJk7`d6 zGglJDHIJ2~xjtHkWH~3&Zow=7CDZ15vaXFT94g*Dwlgud^af;%w+sT7?WkDk=nTdY zMwRzfLWu?r-{pnhdWmPk8QLc8?OVH|^H&H8p1n7t0t;owTq~+`bk)@CC$d}0vfuS` z+N<4yQM?GW_Rcg_k>RDW2rN@n?6BxQiKC(FBsY9=KfxK>x!!5H@beaU zJ?}j=>tk>1ER-H#(rJ1yv0E6@%pI|QSsA~xTpZ{~(N1+mzcW#ShYBhimL{HhA?~ef7hb4bu(oVvx|Ry?I|&LaDczfpdT6iFk1DGF*zEHe~T7M z`|1*x0mtdfmozwDeP2s~DVHM9^Q{=?Qu<`X5yZn-yc#l<*jgnStLx0>^czDs@xH_G zCW-mtx}sEwI~E9hupX{EKG*3*Z3BAcmkFR2%G+NDne_?}}>e>}2alzdaU?<{?ukR6SisV5~qNS3`ZUEp79U4W&b2;&-M!v08VK}Ke3u9__bwJ$LJgx29CQEboI3k-be>5 z2x;x-`yrofUs_$BEwxL&(sBlK47Koxf$xZ^op!ulES=vkdoOUPV;nC(dDMD&FP&cK z2#)}qQjM(k&ZA~o_pbM@Zo5QYo{eH+hOb{^G77XR6?QZ*a2!KKjo+Gl5#J*F{Qc*@ z1~!OG^~<}Q4j8GJ`sxC7P-K{L;XZ&z5p;v@|51F*bK7o!HFavU>bfec_4*?zW0JHF z6v&bSN~#*~e~=JnWoGEcWM?KArA<~jmr5UwF63U$AoAkG+)TPUxkAh+k29vtIIRh5 zB7L$>O`+zL0EzbYKg?CnF}TX{yp^L%cDdNK(&e(&7lUpyQCyqZ- zxGU^E)OHKdeUDtyKGe&cOic~VSwJj#YOv}9QfkdU5XygREE>9BYEEjI-Hxeh5nloL z(TtFO{rG9xIw*Nb06C|*bH9753bJ#)`%`e#wV6m=?-GU=s#XuBt*qf-fy(|g0il(I zzAJVA2q{^ov2mR({d$i5o^3mwPcZs6BN|78hpe3&0$a=kmjepZBVhVxe(sFNDYLk) zUG`LY^^B?=0qHLc-cxH6T(@E)zujVqKY;{p+r!ELahU(s(73gCadv<={8=}5=?d-i zL-Wa7O`E+HSp<0Fu|*iTaD|r*eugf~iD@0Ff)9`lWaVefu?Spen>v_SO&1~c=JD-TIvimie zi0RjzxHQkhGjcCm?in+N_#@R{QbE8CLY*Qd29su?TRj`~oId@;fcn=H&*yk(cds91 zs%MF3F{fb4D}`xk34qDLqB;{J)00!jd2O}XQQ3i}nHA$P_3@g6pzFGNJ=?JIfUT@} z9|4}>N&SqTa$4>ISHRJXN`T>YKAFN{80+~e>y(qV; z+#XR(j{Ph)1P7fpZHc#D*K9?43mnfHVTPl=^2IO^P() ztI{$?^mo6uoItt_t=F}gCL(jIoI8HbgfHm59v^tWhf@-=wh?Ax0R;#ze}^<4{25E-;4Pe+M4{ ze%9#nc#8qA*f%Vcd^@Sy z50VUALMMPrH2QZJ;&2Kq$7F#m=eX~7xE4l~tseP@WE)Seez2i0-)BqJ$fglO=o)s7 z7e*EoQ?WA-A(fr#&rYh;VzZTWnz-qHd90mO3Yn;c!K}Vwt?jsL70zL0MHNXxR$Oox z3Wu-q=D&55^yw+U7;qXfoaV_=C>e(dsJ(>n=6*uG{IR%~_yp)ynjfqCS*fQ&u610l zz?eSjtA4k~>M|$MHWhWY%|`L2h2H%J-5v`U+6p2oYnUmcesl&A)r|dl@4Np(X+DOp zk^tMd^OpK(-w|F#%E`=%Xg>CPY^>Ani`NBwZM}2Dxbgdk(v8Ee)wJ$#1|yGej}zQ8 zBv8CUaqAmM&$ey`_mfXuQ&wHI3TU64nl?+r2I!^{apaTVSdDkrzk4s)z(m8xQ>XNU z$KA$XpDt)^07pi^JM)xn`a5G?Sh*Pob@v~ikRTcpPyzN2H@q)cDPYSk&`ioEc$MbJ z=d{N0t8=#DVe~qD%VxI6Z;!ZI%fpp1;%KR?kn}ff;9hwY_ve4a7xWYH4dP{$0gwd8 z50H+0lEgF_tUso2@?e3&$YIh7asTJh`agQD0u1)es+SU6mOd#zs}4Ta>-v69Z1h{f zObm6nm|4`uq}m0Y**`qOI^Dxw-#x;b#&^6e9s4h59}0cbGd1?HGE41zx=pD{U7q8v zF_T`hlJ)Iv1{3vsX=ANpDYx!a%y?+t%ht5(6GfD<7+HDN;J5?-;H_U|U83y*uGr*c z=4Gd6rA*m<+p2TV;}6}14qLBHjcPiR@{sj-y!}yD|FKl3fGDQ!8(g74H@YY@R$C^k zFlB_)T%L1PxBAtrrU}_;alnOkwjvdSv?C9uX z=%;&OPUXF0h0jz~8pScjnVq>_hHXh3;(ze^c$qb7HUV6z1;FfO#}pWj<{7D_>859w z=4GlS59jA6AooNWpb&u;SYg~6^8QQH!fAmE=>zXQ5?_(H-4ORlyv882s01E0Q6BG7 zKei*9mNx=owUcc{00@s^oe-nVLXmmqy6q65q8%lBsfFk<()>xpGV z=m=Cl(pZu6cnWnS2Tmg68%vIMS0rQWK21KzeLGI5(SG1(+6>CT;;OBnyIv`#NV? z6q3I^+qGv(jMxwc@p1S#zX_|iG-{K!+1e69srG1(PAW7mj(>Pqc0RS~ZN-NiCthuyhxYYK2olj?i_m6f z*Y5LYDV~#)!0p42LP``S!@33^I$Vk13O~i>2oxkD;r!3{2uy?@Spns80m{IPxE#s8 zsECB)*S8f!JCirQjr8N=kyZx{vJ((Dg?K?jj3* zI8-&fX*yWdFOt?7Pi|;ee&PAvK@OVB7FG1!xLI7_uoDZz2&Bh~F075z6KD%I9O=rG zEoUE%AN=AQa;8oL164&vkzs>2%%Ki;wx!gFd*8-37Gn@!*}N()9`wdwoPo6-sStEp zinkQwjFjCc^tngwN)tv;T?~$`@2<`|nahn5=Zub)!0=8p3xgt@vV~U|F0e*=O34N^9n^4(Ut(;NMufU^zS&_}2$`d(7Ywk7D zNpH+_57nGy^kI(nsW|VK34}v1Bl9mHpKf#TsO->iES$KnN*>SX6gCIK+AnupK5zLw zjCSb-|BAXaf;NK2FA!xL`uO-CrhG~bBMs>7I4%5?(5R<#X(gkC8^XnOe+)>t?H!av zSA2y02gAAng@68Q*hBb=kgaEl!Y}*CO8Us9p}RB$I&*C;i2DjNkD1Tjwh6b+vhm^4 zvg07ev3t2M=fc@A&*(qrf8VTCP~nvAG_2YQef{@%7yaVObmioJ2+)_>sGVq)*M7rE z{!SvHvrfm-7a5x!!oYwp_FWNwy;3`Xc6>;_!+s%4C4tctvOZtcE3QaGWa-MGwzR8p zrIUb`g`*Q^n=>DJep`sga71UjRgh2)$y8e_>%$Q^mc+p8VN^7 z!IKn`Y#qhw5`4M))gf93u~7lj4)rElvFCU#$OD)i$jZz@F|9?Y-JJy6gN%7hubmbp zbh3vN9EwX>+fNb?!WYM|?w9v0D0PdLAR_qxwQ1Qr4{CU*`8sO z8Z_-~zZCp?SI^+9Me@nVz~f)dS$(!d#XwiuS|o0nv1FqBDPS8GH6&-PVBx2Dq$loG zb5gf;u`g()aj)1L%x)vL!nl|{zz#z$N!c1Z*YFDPYWhI?I~2&9`NnUml0Kixd|uif zi|ZRI`fFXxe!Uj|^KSw}-MnXjBI=Pe7Io!)>91K$OKz|cb%q3Fwn6^-Cu0&6tSO9s13Li4E7`-Eov)(V&8VqirCjxg8Qjukns=FAQVdB%&uP;EVg73=OUTi#S z8NuUjVKvkw-XHkh-^D|Bp_`rFNG2RkriGBQq@F-1ZefadvJ~3(fuD$Gg}XVnf~$^` zcm=bh`LXu~A~4d6COCg*hyi`$w zTIP)r@*~4VcHv%D1y0y(&3IWOa!owu9`(r_(|5JZfzUcswdtIgVt@RbSH!Zic2{|1 zP}95}Ioj0G&(iFi8a(W$+<_+{$_N8Kn0%n8^+xOqR3H%}T71`8tgqz3y}i=0UH^P*5yS37P79GGDcwNVhY8-|RDXDyS4GAhOaY zFNJy6c6s|hzLu%h=2n`X|0suV`!$L0tdKmBMBytK12N%)sTFSCoK3el%^Hua8g)sF zx#QscjN;`i6H14N_$Izy;t8gtg3;6z5!;;pevqtH=h9jTLfb8l(gIKyhTS#2;CX~F z^@BXfuzR@~wzkA=VxxX&?EFpNs?3l|^@5m}p+ENw3QZh*HX)ok%eUaMPQcW_Y*dIT z?|gsd*ot3mEM~FmKuZtL&FzkiDPh+X z{|@N!r|_LhLkRQ4JD*RLjlGl$oeGA1Sev++q*1gFi6kR+Y^WIX=k9Mzi()`g5h*l~ z%Ao9%_usv^fP^z+-Bf!ybiSd>Vtx23YDr}+6xJ}Cs4lZc+A%kYJ#tBU@onacLK^N82{T|WE+ zusm$L31qM9a(m+@Ff}kE4@Jcfy*~nceX)NDP}gGp(p@jJ<|bkg!^3EyQeGlyPIg&&=$xcpIU%PCJOhFiBHS>qdnm_Wupc@wZoqI&duMp$@ zYlSAd*uS9gp|X^@sS==@h-MusVVnVMn&axdZl1t-f@)Lri;R1HzG9rSt5#$6Q=n;U5KR0h+dlCGJ_m$CDR> z+U|Xz6S3k*gGrjM^O4|&vR5BFb91Be0XfPR72ow2_oOBe?`e)(HQ%0`<29Cz-UY`F zP1&DQPKm+HLC^#|20f|!{3PwUNKIRis%*x8*vgGEd_-P+r zfBv9!>^hA>2RmtiUhWY@pR}}tJQzo ztxF=kM}J0I$XCFTLl>>^o_be{Dob)BhxeAHMbTKfN5;s~D!vW}TA8Ay7#|45|UZf>dcDAsg) zauBs7m0-08)W>qZ#GskdRY1ZZi7e>>7;rH5NN>O5EQ+}W5wtpH)Q$T60c|RvPq=MfEy67<^?vn>(gP`EH8eUbqtnSqI%pVP= zjKYgKYzu~rQ%geb4SJu696E zSTS3t_VxaA)(D_K2qw3#ha6eb2ksqx`M<)=y@DSfVksvMd}ErnC6o6UWk*e*k$8g$ zQzGu53T7YJmG$U#kQ6aeZ+QRUW*rtsfgGI7%ZN05!&3z3G&&!;croSc5*^=1Z!U#J zEYG({K4gAg_PFS;{9@bigzAchfir-_k3vhw69~3&QeMrt*LT;Sv_u|d|0UE3xu4frelP@|MR>(v0`=XXz6kY!%ctME}f>lKA zxF`)V&?Z$b=u}~&Upx|h)%4Jf?)Khl`-8JKpr#Vnj`_pNoKqryt3|sy`J66h4tj*9 zhqKW3^gIj|NBVrO!8Jt2l$&%9Q#8NIdpW^8ZUW5CC!CHnZQHw(=s#%wF7+qi+>GRy_jrZ=O zzc;}u#R{&>PW(0!ydoaGEToVOKJ(a~BFb(?e?2Cga1h83uHkXL*}5<8<1-OIapd1R zEnCj#e=BUa&sVBc)V0Cx!K*x4)@@ap7Va=F_(YcNz~%pysvy%CTH-7!d6Tj1opiDT zLpbhD@ja~$Xa~!Nl{Xy(sbS@H{9MG|Y5N1xvvzJKZ=msgK`KbnCjMz&QL)t3AZDNQ zPTb)t9IlkrjqR)a&X@Y?>Be3B#pGw2|)w*j5^e4zh1h?&4fKJ7KXCD6Vhlybp z68|q|VuX;rHs3&`-B`rDfaG7dka?p?d=fU2j5{GCwSNZ>i3uF!yrNwYvM$3{rF=!ObzhOMc85Y)IM4cgy z>&zD|bO9d-=vw9vjJ(QW|Bsk&d_jMhZxcd)G2h5vz&V;10Y-mIed|xJZ@<(JK(BAn z#Gb@EH5vbWRvyrA7-ZBO`LtkK1%@On7U8P=cE3Kmc@q=OXD(a9x-P~jeqXw|^}HhK zIVmmLjQvz2Ua_J!t<=~(|ESqxPr?;TBgVwZZL2X}uIr4xwi7oj8;ABz?F^o4sHVt& z`c1c>2$d7;7c5jij+@-ep3ep!^efWZ5Ct?6^zaUMk?99mYc`gbDxy2M1L#g)u^Ok@ zGMjM!J^Li4n*!q1AuJqc>u+03H)sop5VXvwRAkv%rY#PT5)J2 zSmleHVkZ5yNpM0`=VFL=b?8y02jd3cH6}9VA(o%ov4j#ZY1M_tmSEGE+M!Zx*9%~K zCHr`O1qwE)Q+?3QMn_sX!ySQfD1Tp7U)n6pVuSOkOWjEwuMhv5h8{X#bFZ)$g#OcnT zd>Zmo91=@R7)hUZOh9ygdMHWIx#ixSg5p*T>G*J24!Wrst`Q?)WO%sWGoeLRGpnPf z7#<1;Mbe(YqQT2c2=G^P++CPj)wU{9?zKM1f%YSuaZA>92lKL-9VVE3h zNWmj{LMbL{5D?FXpPHf$B&+4JeKP_Jc}ba6L8X0?BTA`*hBVc0`(dH9CNEKE9P0V*gC^$DaDUKEpn0d=)mP| zxM-iY-m$H9o*3?so;RTB{CU+F|06^I#sEy<_#XD)#~rS^`Pu~$COKQRe;Eq$ED)0@ z1O?0*%oNV%o$QIJL<{q4wLUKV936}4oHYh{W4xqWvN4q41NJT~{{FG*E(a&!9lab^ z#ZaL%Sv|h+o2eI$6la#^|3lhaM)kccUBbA#YjAgWx8Uxsf#4q89fG^NLvXj??hxGF z-QoS`+;g9~vu56vd)9nmEk4lnuez(cYxk~QYg=SLhVPC^5;x!Pk3vodSM>P}7i>72 zOwE$iF5k9+#Sari?`h0Px}_Jcyc_BGyrJ#iFE3|7!{`u{q6Qu*)|1}8x)OUbHb=wt zi}XAAGqrOCg&Wid4I6-9%ygK_$RQZOsAnHyqv(o)nb;O9tK8QQ7|#(UzF9gxotTQQ zGaB*^!=pY^ z9_pNdUu7{^>v+Nj3ZgLtjmLS>6`dGr4@F+|6v9!Nh=8~ff8K@yKdJV`Q-cY zNBc_NLE@pOR{nQBJ2{EMgw*j+oze}?KBO0k83~Dw631W!LcY#km|2Tz*=7+D?$ZH4 zxQsFR?-smn)?dG|EY%_@_!32QhTY)k^_an4Z+glU2r9oq?DlYAnGjzP*VP%QD+l5f z4glfg!_*H#m5PT_#Yo+Q?V>w2d}@#t z-07{A#AX??im|l^Az{QOnuN#!b;)QQ)UKkzemYm@sN@&NCn|}k>T5?IR@Vea70LdS zHa7;*FIU)mxc2elMeYy-BO)0;@tGAUPe|kX9EVv$imELc{Xg@sV`qGwh0J1wzl1$es;TFj^ z@Lb3n4R%)eDn>YP$cjxFA@LFYYWxU#_r1>I9qg_%DQe|atJV68G1!_S06f-jb|ull z*N${KEEOQ_fCC(-azHizLal`eO+wwP(raA8Ts8G3wL#Ffmgh!rHZo+x})N4uL z6l>@}$by=_2;{$$;0KnV7$OAZf*GYgi$BuvtfY;jeq#jL6g^Em;JXNesUTba_b0>uW72=U8xqO^o)AHR@H628 zufhHsyzA1}M+7-uAq_yXsP%R?3-fmH*3&X;)f?D_D55shP2L0=%rRK}Ho5tjqaYw4 zFYqufkUFMGp8ms~|pqn(nzn0o6;?_m9*PA;P$N`K?IK z@3f8RTuT5BM7K|{Pp?4HxbWD41`t^mIQlI(>+Y7P3=fg>kD-f4l%w8(cJmafdbaL6 zs&U7nj5Qw`03tWmp6VvTogZC!lJt=W@4vU6_$0pri|2#0Hu=`}HR`-=Sa0=7%f05E z96~Th0dPN68Y5iu$r0I>=^VvIU8rq%_J3c_llMNoVjHsb(9C`g?YBV(>P;iQe+K{4 z|*~~dpsP0fF%X6b;lkt;+xk1mpuSm*LH;y3D79YCwTRa`3qDEsUoN9uco)dqt<3!%{BN@65K3oEKM$ zT!~@fOny%et<7C&;D|He+z0`zQ0~RIkfoQ08}7wQVw%V#8KUlW(_d4voU$yiFaBcd z4%?-4Ufj{YynVXe5+P;*J9d-g3n}$M!;#dnDFDUiH`*n{kPG}tjHS!DZRCZ0<(>n{ zr4rd06;lSLko)ll>(zC-Hn!Mf;=-a2p=ABs1TAnjW2c!fuGMX*BkWSteCU z0lDHE9vhF2J;7D2Y92fm+ST5|=Mcg?s7icyy%t6z&^|n7d}xXWkYWoWYb2d;>u4S6 zy(u_B@+^jdPN9Pn1bpM%_ZTnzaXF^r&-5=I&n`g9|XMW_3s1 zXlNdC$;Ox92Z_(*4aF!wl1d{x;tpO2PQjn+-t!#xT~d05!`yAqPz-_m=Lpm{z~Vf8Ulj~>i61py1Ux(l%4v@7mWuBIl#XLQPY_@Uh+Qv zsf&p-p#EXNJw{Uc%gffQdGxRmTkfYW{M$==<4Z}ch26vL9o(O9dOOsF1cujHcJ-PR zpS}~jiP}QF47x^}J9|lN)oDaSza8Wd;TrGv0ksc)PKJCE&4P1X&yqB{GI(2Aa-Q9* zwskEX(}jN1;f|qG#4AHA(8jbr|l?Rbv z1+96nBmC{HYn5BofeGK)CoQ@B?(W#ztzRsB_GOzd`FhMc{U=))>h&Fv=jon_b=A1D zo{0$ur2{iHVs^!Q1JL#ga8Q`i1v5cPVsjZRk*rDNh-6dwY)4r>M7t=*_|r~*&F5;u zjDbk(hM+U3duh|um4ex=*UnEHtIriE5F@wefkyay@5tIw#J4-{fd!{0b z7L@?LF5RIV74u@Brzk!|d#coQWx;o%Pw|OkQwzu{ChgIg)!3J4N-iqY4(?3#A$o-T z5*;y9G}1hkPYz7_6RixMTgDGTlZe!wycg5(BSUq;NaOpeqvx3vY{z`bn0Fxu;@|gF zpXA4=$~4G3e1P@Q)J{G?p4<|GP|6s_N2Walnyh%+ux%+H!|$p_@u+IA+nyD30fjw8 zUK;KJSh&XPCfJSok#6axzg(I9IZxx#yX;N_m>3+^j91$MONb2Q#e`Va83zbjQK~C8 zxEx4c3*P;G;2@Go3{um{^f-d{bP~QK(5-}w;lepd3CZK(Ix#vtUt@hPu#b%-)zbLM zh`&sXwb*&h%almQ>v(7#3L}4qIfx0h6jHQ>3YO;}a2<8kaz`vZ7+r^%%G-7>{-_K%z%h9jd&!Ey-3X z&`lL)aPFpN@a4^$+Lt~ZI;{=-8i(8{N_>!+0kKz-W{K*0e_J6UhcW(L>I*@p#xt8E z3AVeuG40O$iJ5lIJpqmS}dihja*9e)S*H7+@IbY;^AU;XyJlY8K z(WZ5b#ljJPc?;l`c>tXN_A#UlJve~RxR3RawyMoJySRzC3!kggYa)@zSVRRCrA|dL z6y6lCw3@oyKgIZEVBj>Mpfi-LiT$9_WKVRHlm8?y$8F9?5uHw$%-Hi>mLH)A_4t0NsPuuzMJI~qr&lQSgA z@zf8Nv|F2^hfHMn;`}WGPuR0TDQn{)!eZUf5qdf$dR3&>%au?8!pKi6=y48ycHD_n zfhyuPBlFQ4nrMwbpgxc3%k-0bQ$3B_C@!S;T;?uz^^SCaugvCsDdviDd6DUS_@sR+ zjhp<_(=VSDfl|a(oq_R(w#JFkgn$M?^SyFN)kee0BIa3k^$K0ucOIF0YDw=IavJK= z!&Ai&8k&RTC(XF-Lu%M>X@OW1NS}k}=me5v=vdK4;*1@b;zS9s{n%z6-Z?Fx! zk@SQoUOmSKSRHb-?jJdLU%eLs7fUOmv6p+iHPuGA-&}SAcN_;#l&+ZVQFMpMC7I+~FQzcAi> zWukgbxVfOYHfdOuj6;9K>SBIGrwZQhH70Od3;29B@w$BS=(B3v#b2o5kBK`miQVqf z46z};fD4XbW}R|Tm8WM>Tf7jvA_uLhpMFThE!Kr7(_h{2b_G|)+FQ3{~Zw`<^AKFqa*X5bK77XZZZ;eK(VUK$oD(D1V`nJym`%C-qWXAEamdY#wGP9`6lOuMnOcrZyI}UZ_!4!J zokQj-BSt^weWShJdq!OQeYJ0lH;1f?g5sw0>9mHUePCvoI{xlOVt6p9n#%+GOXuO^ z+XT}t0npEI^VnCAnt^6SOm8fUx;XUObHOkPS#uT5mu1|(coTIsJ9a->z|Hn|o%Fv^ z(#xjuVz6I+W?wGF6^Mx=I^s{U6c})ebrFQX`!Y9hQh%eQwH7FuuONJ4^&jZI$ga|E zwtM<^LQl*a)^BAMbm#F>u(s6nx`6cluYv!14L<@V1a`!+P0qLOrpn~`<$-beCG(5! zP*-2zMh_-G-?1jzdOS49YneV8h3B6t904Z@v9sXUUc97nT#Y0ISv1`JV+2_V+SwQh>?H!J+=K9jzsj%miy_@3Dqk2k;Djj*;s1gpiyGs=YQG*zce= z&;Pb#M*=#=8_1t54zS~IHKV`w3!o74Mws-GjIvY(@+Tn!sNhuOejr;nttd3}Tuw^G zJ~ZSgpjuoFIJOZ5;sfkY*%)Bt|B>a$C8YZhkY+d}NB0@*eZ`eYW+#g^c);pvdaDnk zIm6GltCe#m=LxXR@5LPKveDAGYW=nb!l=dy%AwCAK;ugPEl8DCzPRuDFWxfIV zQ=K*-`V34DGa2$Xd6wd+*yz8uj`t$XeOU#Q$pL=-M7Kf&fxo zhy3*lGR8+iC+6u*-oJnx$0?+UgK5@2|6P0EgvBD5V*f=T^KXy*%hmaS3G;KD)*^|#>PPLW)+hB{PU&$6fh}!gp#^@M3}r7ojWse*;*``H3E{OEAanf@B9`= z`uE=P_gOpa>9&{Ryg1Hb)+eJ7J6|qi4saLiGT)pJP*KMN6wz`MMmybCUW85*Q2z*$ zuhK^lz}DNqz?rO}(>EoB90iXXr^0zO9o(juXbTJ^6srpQt zbk<$p6bpmf3SzN-`B*%EKOlIF`Mr0hJkXgR6kOBPm`lq< zrm$Mm$cWWD)QD$UM<$=N;#LS~P*{62A9!9!-giIGcd+hQwd*%zGQy%2e3Kp`hEy3C zmhd^BH@qDfBXCz@vE465a=IWx4plWtO742r`ZSMSYiOP{+iiWxe0MsuidoSPq#v7- zyal#jE9bU>v0yu!mx)wqri_VFs|}3xhj30_=dE^2$$?Vr_Imb}&%Q3hMgC;Z9djf` z&+CA*2%^%f4JTAH>(BZEW}{l&n`gCXMq}o*8>arC@T)Pk-mpCu>;6i8q+g^19`|yz z`DXHHu)|K$sWW6O!NrY2Kyo;m5s7^saV$}r57Dy(2kWC+GfxA#3^I!uSbMLN2%~D1 zG2(_TgR&Vz;TCErR)i;Viz@kCsTuM6&dNZVv+)?4ao-IwLp=MabF9a0%nnr88*)>W z3uB_8n06k&_Oc$EB;|Bj{SxAWON4GsrrJA=)t2eeTq8179?;Rw-dS+kIc6B%GW)s* za?I*0z7!Mled&YsOt81gemqw`4*z7W*YnfrTI|qaEV|u{Sit4|yGsip8I^IKFLwO6 zI8^5vq`nA2ZLlS7{xzo4%gGy?f1HH`-)Ke zV1gBVa+n7P-501_;-Z8SsY|DFd+c@E-fkb!Lfu#(0`!(H9*NJm%d)!H%%xfcVFYHx z_$$lCW&Qe9wa#`>+Ik3)HLs~^3N%kuO3ftbDu=F1P26r#$_t?jiSN;vYKu%1>`Xrh z?tre|w`2*VZbO5!=DZ{Bs({2(r|xL3+Mt=fqb*BCo8C%n8gY}qnkjn#Vd(-?{v+ub z+Fl~JK?&~fy_D46X|_(g!+&8L$a^D+GDM0L8W<#OE0d$~numJ!>315Mz^ z;H>`vNYEx#_$xRJXM%ae>-kXo)H-n*ze!>Os@$Mk6UWY=D>u4|+ zwxHSVqeztG<^W~ZV(nW-oX2KesUhBy>Y?BSW)S-_cKR}Y=d$*T#ZcNj(?P9CrV?NPWsKs?Or5F4;D+PxH3Jv%Xx1V%1lu6SXL@df6yG zy|RJ0*h+WwAN%;ihCB5&whSh;y)1Ns7P(#rXtlcs+V1-a$Rb(QV)Oc@d&J3_ZP>&^ zI4|kVA?`5XXUtgJ>tr~6nbcV=wODnz(rpnnfLM*(Q65fN5pJ%BuBd{psDq9S__an< z-g>a-0q?z+@qu&c{00*5OT!t1`R2)BzaM@5l1v>$)--oZ3D9frq?RA^qzTiojGKn z^htqB9$$|1hA>{gWt5)O-SLi4c=D~f zp2>}w6oZ;^G?RLzc6WK|8;Zi9y%iQ*qxnW1EQ8>yu0Bo`au2VtWDZ+H9hHB1wDoT$ z;QL=54U0sv*?uclkZ4X{@cCaJo!76oqk5`q=?b6Q@%oUy1Vm(g?mqL>3*+XR^(EWQ zjJIeB(3!%J8jh5BN3bi+k&(KFrpOI|a*7vY;42dYU9hGBvkf(TOSo7qIm#-H z=@{Fugn&J6jvSN+yS40Ywq%{U-yV&Myc!xR-Rq^{U>z7|w~Y$PqM+a_=>~VxAmS=H z`7Ix^6^6kOgJ=+nP(~gk!dOV#ATa>#TN`7arQpzp1tEY0SSXvw{sT$+e1_hX+`&+B zgoQ{q7TWCsDRuBXW3VtC}C?yx3{hlekpDxdv$)cBD+O$1*V`Q=fce`>rZ6y|HD44{wVvD_L-y zpSS8eZjuQJ-U@va-0Fy)Hp80m^G~{fP#~ zIKnXWJRFSS)J)1^@gO^~2JNK*v@)L193Q;6vO8qBS!9@jS>d-A z|1XcO4yUvijkccby#RRh4_AOkUwZ&NdK{JY@@8j8FnNGq_P0lO5Uc|OJla)oLLrTB zrAHv1GqzheQhs|J2X-ZKPTGKEf`(hdsTWfYGHRxMd+fG-4lM{E{zE*z9hYYw@Jj<6 z7Z)5=mR?Q{9I8a|GtJ0k)a2*NQ1MyD)MOe^pt(0Jw<)6t(WIp>Ds|OKN&QK^O z%a)8uxG!Qb)+EKc8acV;HzoN@ZAETH5Xq~t%g9d52v+256%WTB?Q=;CwcZGBWreOs zX2r3#buqlk)5C-fy|b@QjtWSrn})T^{#Ys(i{1-oCD#gBEpq0f&ArtVXqw>}eA8Lg3K6{qEPW zMDC*c7wfCZq6NWcX4o@j85?pR&)FYh zN@;7vbc6P^$B)(3z*V0>f~CZJY{8IlH_wI{`1Jk z!j(%u$9w#UPQRp8#CDW05bCQ`}Rp1w&eUkbsTK*&B=|;P8V7S;=9JKSm}4*Xik{W;gpyg zo+Pjv7GpkWGX4TiIJh{$+LRvxejW5xX;eZ#9utSjA}E&vv4eh%MizAoN0MJJuc%zL z0(z)wPtRu32jWBSo|iTaRM{_X=uAq^x+^1|==3G*KIw;0XcF;hT^`yXt-i~C1tAkNNi*oAT`*zZm2CTj(21U-J?7s45_cwOVzRq$75AS> zJ%Hsn|5G(@j427V)O)DWdQMI&QZ|4xUo}P0$Qij?jjX=yHy-m-5H$gytNe#79Wd~J z;xY53bz3$RYWc7O45egB4}6*YAo-$~5<9h0TU^vfa29{zF@0yKxvwC9O27Y}@^8(l z-`#3YP{J^t#DKs6wO@xrVo_&N4G}p6UF?K7xwa0fBs^x{H~rcHwcSf1K%C|28&;HbwbAHa1Tyxb{Kf-dtLkq%8>cF@wl> zR^up?xW)02*FgGvz2;xWo;*Rf`p3pLfy!eIvT2UEN0?0ZD!|;=y=zw8FdY{!$N zf&#DR!+Je~OyqD;p}waIBILvu!3}q9q<5(%_SQ4?WT|eynq!__12)BPA+o=%57~<= zy?1jO?LSy)6+5~CSrua0#3&TQXYw9VVbV4Vs9o)z2*udC2L97B{lzwk^6AwkU)c8V z%iA9JNy+*F1SB5|#q$cn^Ry-7gYEJD_K~Rs!GXFi{Q(=~qui9bf+(oaVKfVnLI2;d zahINUq_=x3%*Cf}YLp?k18Dg};}3-4WgUA1`+#uI6xG`RSS> zB&RUM9>K@=Hk)O(jIU$iM+;C7u5qw`E%zKgI`A{dpLWLIX8c>v?N6_=0EWm22PV`N zhyj>7t1BrfUgKG1iV{1gHl@MDIF~CBTe%4iculsu;1mudA!Cyd7|4 z^m}9NyBRYHD&U3V1e)P)z?)ZaM$e!^A%V>)x_!n z2M;$UBZD^cSI5%uJ3xb;0;cw{#_|#~i;Z1VvL*?(cf5zR*CFZmFWNY3tSNVk>Aw|j z+|8f^4u~5FgjC~AL|5=;2)=bDKMrChRXIB9m#hx33Gs$_3jkqvxUm=`kpOAvay|Zt z0^F9?Q~_dqOh|ke@8Nz@rW~X}SxtmQXhfue3Vx3DSMI10QTR*i#9EIRnO71Ek|Hb8 z41A_%*j;Wn`y>Q`Cb}DToK|9k^UI!EpY~f~Ffe{Lel2oaLwn>RVW}U->ZF?PHeYWt zX58k<)-;$&dWz;X9@WYRp8%><&EjJ?k`*!&bTsqt5=RV?w!5kEh(1p>&z-sim+NTb zajY!#uVYEk+u-*MT2#lfp|7H^vX#CbONmn(%0iVXYB_5N9R9-H0lo=}uh8p}vaY)! z`|v_S1b`^GC%1n2#&J_qb zoX93vfbzZUoVy?9TE$wZu@LSdSgWuOl_*?4c&@&Fv016&kS3^m3i6E*?MzGWtfQP#6Y;Ph?p!q8Nv#4u5bh^9 z{LW$ZCTP1z8#@JhzQTS{^PXu{IisMWs==~uw!pSi_q|Efqe+__H%pXd0?lCi=O=8& zIVM(3Z)Z}41NtI;Qjf1^--=8}?$0B~B!%pCbGwaB1A$q?aotRE`!C=l&cYu-YLBBu zA+G%p0T@)dw9(=V-PkIQOF5g`n5=D*p;0|9q{c(&{qohhwam;sdWBMa)dH-H^U^2< zs8PdqR0-XMUN9~6yJwT0De>+)f(+S5`Ul$r)s0PY|2&(Oya38YC`O``3x|sdYTJbM zMzi{Mtz^~6*Oc%;ymz_;(Ps)Tw+i(e;6K$y0Lqv9+!7png~izm=koGi^TyS&_ELal z10XT0G5_b?_w&T$_&DwKsDT})8nTzZ>8Q@h%p`%2)N0EIn^uGnxAj{PnSZ)I=VWS( zS*SvGHl#||!E|T%65Cb#2$y!TBNn&56z_z)xu)7+aubm=2SH7cd~lgO9rXwUHAER^ z`=;5v2}(Y7eN*=XNc?8&M#FR^s+{cCl#<)zSrSWrToo@sA2Nlj$q}kb;qu$btX2){ zF1|stCX>#A=&I@yxlwbQ=lU1*P2rU7F|?fRG+%83X9~v3Ol;dnK@L|RvCWyrHED9G z)so5A`3If%L9mkTyt&%zz6`4zh?X_BYemiHNIwaeE~blSJ0j=BUPKRih)kW=38#pR z(;{mHcrt9U(lDylLb6mYLc{_)T4sy!mFc&ri`Uy_vh7JDx(Qkf7%B(-!}j;|k-A9Y zlB%){nHa>0rf+(QQ5|zzPF-|gB_G9-lkbJgMalW$G3af-sb47`U;$NF7v=rq7+v4H zO#?=UjPES|INK)6YEEKJIr2pANb~)EnE#@6HuHCk&iR45`VRi5Xbw04^?-8!^%TSk ztSCSBV?R1U%m7Eh3t?vpoT(J80J?)=;>-%Niz)15}r^c8Jr;4ts zSr(qa6^@#&QD$YrqvC(xwc{8$)V&;ZHgU0b(B?{^>Vd}?X*&b0 zi@WX=#$cHs^MzSQFnPYg;U;C7ayN?)j-Q14~j4#M@#S$4Q(Fcr-7lDTHuww=Td zd9ar8;!G6gGaPU4jyWP9hq%R%Bjw236*xWSqu0_Y`yRg-g++sd5jd< ziXWuG9CDzr!=l4%6BM9HZa7t>mt=u4kj5a79M_;|a&KUz3du zM_qFsF~3%+uu@WKbSvJ2M3=%MyPloqmlUVqbnM3kylXU@nAo3ZbGU>*T_{Wd0za|$((6-^@V82gpn?oYH9e2m0j_pN47Oh6z(072?tYR!$*Ac5EDDxY^c4y8Lc{pWCXWcgk*@Co}z zwa5PCHlJ(v0ZQ4>>sO=T;mC@h%)-b_9$ZqU@O| zW(k16Z@G=#{v;_5NXaHxQ!V^A`U>)akYz#V%klpo&O3pV-OT=<`T@L%_3xS=OL{U+ zBioF16s3r%ELjy<>UL>z}8slMOJg!Ri4)G2zw3EGs zv(FeQq_;JgY_Q&B+}yv9(P4)+%ia9iTWrwiQ*YyS`z_()st|&E9XRfm z$IK%Pt|eJUfh3dP5~qhrNhbTgo@qa8h6>nhB_23BZ)Po%Lj@ulIO__i3WmILZ=P+b zCz-=@TFV@mh4lC~w%t_O@0CJk-x^EEwlH<|mSHPVQXg40n%lQ@`z11sftLHnT52J_ zWhhU`j7m$&Dqr3@-a|XvM*+%H!v0mB5i(yM5RjY^d5O9UuMXs~>H*<6f~mXziO&GI zZVfpmfAPN<5Cvuj!hr!jtpe1i0Mi3afBb#8I@?%$12mH8Nhl{P)s67_oUEv2+eq!e z@0<4KiNw`Zh&Z1A^Q?9yCLc}n|N5uKK$7ykp#-v1)h8KWTBi6ni@Q2{MOTz(bxLtb zYCXcqYHGpILF;^f=Rqp6wzGo2MahkTpc{JLphA@odqgFFsLW8>2Rei=tUI^=TyJn$ zlm)%*VySak1`^}5-$L{FvcAG$o8>r-n1d)uM7LXuCfFqo^@H1$$E*+OzSS?1iqT*C zBvJ-9#2O)G8*^E(ux0E))c;G=_D^3LFit~iSndag*(I1FVd!3|6b=h2mgb~X1+_ps zn#e@0o|PERl%O;mDBMxKy(0jxvKEBr$2(qxQ_v_CZJ(lbZ!9&aNCXvN%0)O!oIaHOe=Icz1?u zm9)|Xf)r-D{(gyWM_wEHMtUx~z?qcyJZrPmMS3?)>#gCKYw7TvD||;TiL78fqMb^l zTW6LYjd=R}H^+VMErMVu-T46y*jS=)Mt%bON zS4gk6k`KNUlFyyR4*b&!dwoCAf&(YhB{02wfZin3A{O`;P+BB5BRGDS!CB5FTJ?Nn z8xO2i0t;sUD+yVyK>>C;uG?91#GVmbqk!Xt8!fFwDrRH!7FTdXxe_>y^QEfnTX(%Y zX_4r`dy}0SjZq~^g@KVlTSQ3a8y1L z%I!U{k^1ZBU5!%Zq{eSJj!~@#!4|3G8)Fy7Cm5Hp=|4yP0qr%vxQ+4(rSq{ca22zX zIp-^K?dVU?qv6Vl%X(}*K+$lpU~YpbWt7nmcUe9j^` zSt29j5d+pv)17$Bz`i2tux%*TD$6y-9Wp224N8)P&qc>HMK4iZl!@vzlU~fDDI$bK z%ujPsaV+e>kp7Ol_thHrGlbNF1lO~BOFL&pX1B!*>&24uaxtmGSjvIa>I7*kVU1b(G_3s(46K%K zC-UYrpw0n^1+Qrus&vEDT$Ozg#iK-h^n#;q?Bz_)9z+`>JrC|Or72jb46+Ky``B9W6X3r~sw)OivKvh}9byvj z<9qS)w{kyU9$meLL=UP**Y5Ps$M&VfX3TD89gl|>6$~S8WXhOF&D^qBBgK}HIRcNz&?P{WXS^e1JBxTLw z_vT&fT(d1*qmLvDWV)PIf)8H*jP5wA&*r^Mkhw}6p7x@~N3?bqyc4X7+@N7vzzXxp zby}Rn54xQ189F!ycnh@trsqb>*$G<0GOB7HW{}wX@rb$(PwuD$9+=PW&@&p)l9KQQ za?(1=;_9|;HZhuWHyrk;Ymzs6;NVMb<&lvkU5AN!URJy0hN=B%k}Zo>nc}2HqLWpG z7y%{2lJ`Q;B18lzHf4FQOSRWJcMcNW1b94rwQ75*s0?y&dg3uFdu=nh#Rr%%yHnAs zmZ8wk2U2t#tX9h!k9qxX4S5{)4%eTIkOh>kj&kcqv=~2Xzcy4dnNhmBrmpE?$hyYQ zzXDpH2bA#(!1uS(r?>fPqzWJ0N*Nl$w&n*Qo`&m5wJa^Zn5mzaGkmaq;v(s4u!OZk z$Zu3{n{v5)1h-!tnd@efQSvJYPJfbu(58qx?bU~~^mT=Pe%b7NT~oB#j$+`vx)-kUJ z8l^~y!?UW~lJ46+m|L>ih&aPJ-{i`xK`a}x?x(zH-+av;F1A;fi|eAvz{azCC6&m$ zYP9Vz=Dq4&Rnj7=eBpn*ix9CTLvq2-zb||=1}|$SJM$EEmfS@QoX{IBeJ;2?7G3=F zThq*U7WCzcR>|Y!%4I-7Qa;%N%)0fDnRo@6jhA1^z%sq%{WE@y-jzt+apBs!=f9k= zH~783s0SQ|rytr@@=z_H2+m9|b;)%Ly8M$c{F4KBqaFWKhWy(~7Y+rsgW(uS}B4js#|S+b@EKBMiYV<}Ze5SG5*A z{D503y_1l60LRNdv5Oix5U~Up(Lb4sFj?20+F+mbldOQp@qId#)uV3K>%nk^hVB#T zmJ_!1k@H_iLcTwWrDzk;(n$U zcY!>RJMp44O_dKv(%`6+7`%~BQ&`W$yRH8UoNHT7E0W z{`&y6>HO;eP5X}n)P}nIuLG1`Vpn_=-^CRmg40zlFhy`O78jS1=S$za){@Oa!WWEK z39S(SiQ5Ue0-8zC3V9Am`Pc z6n!Xdr(SiH{MRWJk_tX&tL2oGoAkF+^i3Y~`iV<9V}ky*T@XVk4H33$$9{~BgXm9n zZyw>Ch2;Bu&l7E#zGs$e4l?-?`d}Cl~s}_2hcFB3T7F0->m_fD&!|7KTg7 zF*{0wDRm9#2&Srv4+)@zrP~U`c|t0>#bFi(h_RZg&ocsQ3HmFsGbrnh(kcowS;dtX zsnkCbc*CJp)SRJ~RNdboG}*acVQs`f1#x1DG6MGoCyTQuo9BHEAq z^gV#$F;!gI%Z~xGUXxpkStyA?uU!L8Q57>HxwJ?O*}d?}NYS7;vO|N^*6N2ZLZSz! zlyFHm9}FO9LMtxFe^enk~dO$aLP!2Bi_P$ljkfY!0Y$YQQSrO zo_2G|yUBGrmyta-rL^5(a*}}AWJ0CP;(>}md8j&Ptrn$;lB3iUr~@LI{i&c26sKrQ z8sy9EtIB7Nn83sg!qlW(4D$Y^;YIo*P$lu9*HYfvGmtON0|-WH5~Pu3cHq<-q&v$>}$GuJ3dxp z`096iZnPZE^LU`w>m<$o9N|s$_O3E;$X-jzVy+?X)ls-07p`5ZjR*>Tn$%p&cFC0% zcFz8nn-A{47^yjACXn6)d|VYYxS+|zS9e=g8;!3o6y0rEH5c?#hhB>9UNyeX^_RzT;7qr1=9~4zn_}5aDSG{>4cR zg74r;T$Oc|Wg7MqmnL^-MUBy1w2-XB;LSG+&I`S&8Wr*fk$9eTCmXE>$4d_cnosiY z(cR@t(0i|5b}l4clRi1s0M%LC>D83)Bk*Eo-39jyqBED_|2PbSc)4s^VsblGv-eNu zLK+S+He~%;1+D0h!r6qXalt_N9R@Q>P*Pm~6fXf%zf_Ns1|rCiKyYy&i_ai}_N{!p zGm^5BiuuH9CQzO5Px7 zMVOnB?js36)~;1d&bll5&OXLEu+???)Ng=c6TYJXdH(6&{}wXlRJ02~xG{s>S5X7P zF$N9&r*rv}tTA9N^91PVuOJ-xQ>$QIte;w)hjS&yi&J&YOP)UP+(klgGu*wovmgI6 zLj_Q(`q#WVOq3Yp-z_z--%VG)!66^t-1r_VTd_|@%G1Ii zHc4e2teLfty_nS=aU9ulynMnWl^6JQ45FT$oRnIXoD1l~v-v8qYc&WqUT%5Anup3y z&exQx zk3&xVws$*}HVL7cogD|J@>=Nr&`BON5?9L=-OJMS(y8Iay4bP#M#YeMmaA?ono80A z7mBNY_-%BemTc(;-^ZiRVj;SCd-2K3)yC|8-qSHZEmlCHyAKEo?K%ScoQ8kpt-~@z z$A6r*6F))#-`#`Knb^1l`lR%dq2s4|5vGVNofI97{MazW|Hs~2aMhKrTZ0>ScXtgE z+}+*XJ-E9Chv4oIAV6@3;KAM9gL`nd-l?kZ-l}uH9#!X#9^GSf_a9h$y=%XZ&u7jI zUZMA|NmIjh6%z7%Af6sSAs;%Q+i38+|Fg;(PyplzH|yX60x6f*$e(Eo+(P;b85+nFqc-LcjOJnCnHT9{?y?% zGC$_iRi5_lhFHWBz1Q{8^)EK%SpZ@o!&>){X`jF=uw&x;NJ7{{gnboO zPs?EW-^d$^&ryDUH61}g{?$Q2`k|ecA5UjjE$O~&(GqP& z$Zd^O?&KF+mVbW3L-Rn@;5PwI8OA!J{Ciwe#+tNVndLi%++YBL;7}89;Qzp~{xn=# z=|cS4jq-Zg#Tk?eaXf+CI7La6arZ=!5BU^{0|83j;gHEo{4 zf8nEr#IYaY2$^icR78NRS#HVIqy_sh5J~l$X?Md@lz9H#!Z7f?d+q}rh4*@wy#ScU z;I?JB|31_Cf6f^^&`1ehb*i4NFMLtdQfA+G^w@LTz$%N~Yr$$0*e$H%yS9p=z5@Rp z!~jQNzogYj?%lC%AImxRc%k~t-FY@XHrkP4Z>P#~xeuN83j*cG)Z^P{(c0;L8Yfeo z-q&PuQ7mGQR48u>&t}Aj@mi>HKYVTcwM4AMY&U{yNidNLx<8j$+q3aza0txWH;G7} zc3~#-TinehZl=`A70-4nl@MFff6r;q!CY-+{VlROV=KZ&!pv!*Lz8*UFLtTlKY45UI>H>fw; zcwFtZbMRQ#wGC5;5np!CEe-@)&K7V$S6f zQXa+`p-#BP=i{6G@q#vk(fmL!faiIw<%#~((<`rbUwo-{lRPxyV_0N^&6b5$;D^Jo zgE9Smp#w(Qeai>>@SNOndTnUF4Mj#hX6a_D%DROm98^cKHz$8op*r@IH#xVFN1wga zB~pB`ZR;Qdac=VEM#gJXrPMV$BHBC|bqtY7-7X7K4Dy7}Gq~uwKICm{-WOHF__Ajt;UV{O@`*rAlE8aqHLl#=7>52OhQGNN?;8)e zKu3TJn`h@26jjnAp&>>l^B(B0!3B)i>;G~iwKZsfC(yrhIKT)0TJ}8w?*MuPVt!SW zJsddk_8^5<&&$rMSMA*NH+mU0;?4uvS_T>&&YB)?kZuL^oPT8I9?_1%_rIAr1-R6I ze8dvMkod8-GBTB`$vbTjTc$1{jYsbiGw-H%M_5iB$m_q3I8=%5=k@m|^zNA+U^cq! z@0p7N;Ie_I{KxN72iKpJ%$kpxSXs{#X-cTx zX_)hUmHDtcm$KSAEqGx%bJo1yA-l?B9UlRLO#Q_o<$c?r+>)o#UR4EVrs=EY)jZrv zAE?I?`}#7QfN&(&wnr29?9Q)oGt0@Xe;j|4kzYq{inOU+PUwdx_$6=5>4_|SRvVAL z9q9_APb?}QKRwBGRQPT<+C|KVs=v8j_}nHq-t~PMx1Wtx(0i<{&apt~MR@3gPsGuJ z;~^N^FdvfVb+bxdSE@O?=5!Q|lv`kc@_O%1jCH*B|>!E?>pK>uH&I0D{ zx*o7|iU~?d8EN@C+6n0@@b#1uTNOVj_SFXJMN=BmvA?m)vD`RE>~r&%un#KA9#IA{ zvFqW$rxqF9*LI)v&&^cH^GavL4Ld0{b6oD)Rq|A(U(Js&ykh_bytxb+{Kpr;1zhNh zSa%umbW8jLnIqW_)uQ*pKoNLjqn);}$$u2`cqIi{iL_+v|$V+gj#rhSx`VSH;A z9pc8=7Ygdl5DF^X`g&$gXm7EE^MkYFUJ8iZ3}hyB68NLWjMbIdp0YTip2BBO!4Zz9 z8h+y}o9@cKFUBkn%-(c>h(-OlJCJ$x>?1GwP6+-+@PsQ>W@F;G_y7(|`)PZSXUqE4 zd0&sLV>FKm0TNr2V-`v`J|qnZtcA~GVx!KQ0NW&JjsNt2Iu*K%v^}8+0sp5na%@kpfBst5R6GFeDR8Yf@PBY){*?9q-7oyg`uQX( zlD)@*_6+$P3^A+lj5Na{nTJ5125qV1qfL>H;eWY}rLW}arT>QKl`)@W;C?vlixI;k z}_o=U4WRMcUlimkBc_8Mti~aLZ{0^Bz?@i z2=ij$GCw|QuJHMf)V%iw$-Bd8dj_q>Q`E_>?tevP)7G2i6be3ubobnPPhHM{+gu3V zig*4m30?7Odip*rV8}c5j_C7am|wzH2F#gVrPDgYChAOx!uhWoa-51OTZ#Oy)zW`- zL(cinXX2#_I;wW{C3jZf2*oTooJxw1JiNv;<{u*0SWhcRdVk9uYTTX#By(5Z3v4LJ zP%v{Sh}8Rrp76mPTF4{fvbPyK70$o!1Bzz%y-;k-cbsuHiCT-4y|sAodk=kkGFIN_ zIO;EE@YT|ssDs=J{U@kE6e}wwD=klBdG^U2nkKb*y4Q=(>msYWnHi2uZ`N;QX63k} z(Qqxfu;rNyZ%60X5!^xQEho^<;tkqr%dL8_Yb?y?6*#qb^wgtp9C{!LWZsF^F(;YZG1D3Q=?%MEJ_gAgKi*l0KVbp89%2WV zVqh{f7WOPfseEL;>{uF3hJ&MmTW+|?KgpL_E+a>p|ejC}D>Aq|mt6$A` zCQyEZUIM?{)29hH|FdP1R6~|X`++TmuysP|>_Kd+ZZFzrnX2>T!@fUT7IKt;S^cHW zaeN}w{3EqMn`&h-ha<`HE*pDdpyF#GV*Wn>>F76)hgk{&;-IYuMbkRl%hvU%_ z->avc^!y<{dq&u*dxv5i0QkoOrAJT>6n1hK`SX;G>xiJYM${&=fR73Nbx7Y`?MWdJ zv$EFy8a#2Wh?SW!0gNg5I@XBqauZ(wwCmeXlHaR2dr7iqt=WK1SqTPJuEE_SD;r3K znF(BnzV+*)C9N&#X&Kg0(ls(ULT*OJNuac%6~#0rL#cw`lzZ){qZ{c<PF$SKgee`GiqK;)lG-aQYNsPtanpp1|uVKmFw%yDE`-Yj^Dsfw2<4(J1~b z=L$3z&C5}KF@*U(^9u?>9kfWz6qc|WhTcR9Xve-z*}<({%SW$;c~f%&u!;m>zzDv` z&$H047ku(#*KkPULKRpb-*PVDDOe1cQ3X2YgVGq$!eJP7qb~)LWlxPGwQxLBixp~6{%$> zvwB3+=%;ntvhOUONCog18Gl@HY0n(rmM($cHE7`+x9;7`Hgg|uQ_UVRJHk7}DSh2x-sAdFP7>?0jp+m82#ZD5d9Q44m&=^A>*Xw|cEE@ef4IGO^uOUO##4{#N(G z>HOAU*OcJ(FM8C5rS#r$^mb~s>n8_&Atw=3@QvfGj$xi-Q~D)P_;@3|_p-n6%)i6j zk~c*rmQADS-MagwO8rQ2su;9o`g9nkU0-#(e&?`zq`fe) zx4FKPyruL}ZydWHwTb{=ov48fqe(4nK>}>8<{#Yjkf~uZiq(OQ6`-n4&Zq_N$VNX8 zm8D@08_$?QXyklvgUZv*xuJ+^PtT-}L;>9Lv+0xqUz+6)oId1?pcX=(`%f>dlQ9N9 z%V)O>X|-dB)~fWG#yK8)BOldr1b|`zs_i|f%=ZT&P-_2};B{54(@9CEu^Lz^Gdd}$ zjFgB+C^qv`pj)Q~EWF)--hfuCfe^!7(ojyU)nl~e<&z{Xm_1G$fu260LxDaXLZPqD zf_8rzKs)vMM{V}3KicdJ??C`$vk-<~5dX`9{#ao9N9l}6`0sf7))%5L6Sir&XT^o6 z>6yhO%lsm@IU(09R8Riw;IRK`i{tMrTR;V}KG-b;Ci8y!a({x)hB92i$k#M4R83C$)ABp|xjH7R z%NL_u;4<>ybDXCLdqHZ$wQR|L+hrGlbzkEWZ9_+vYZ+|~l|ae`jYehDMSQLH{}OJm z_BFO+Ze8)!7)4mQ4=gEB`B^fuTFaWtD&?POlGCo_JG)a6#SNJAA~pQ;6$$kYEa45X zZAwXdR&Fq2TM#HQak81eyK%=K)1at$d6PV$1qh>{BLDAltNRP(oGxi@ZptDt0cl?Y zf5Ab=!}ggC@V!fRx!22AIOlj0VP8K&Mc;v1v~J%9i)(8nh_zP6^-){jeeHlPUyVqx zn&VlvQ$n7ex&1=3qGPiIvppuxHx#ZFCZVgNW!~t6;8>{%+oBY`^tgD%1%8=GM#UEm zbX6JPX5r*B<6P?<8;xp8(wHZHPV?Gb-%&yHPlz)G&qEuec3iSyUXUVA7KpF+!UH;P zDfB}*XZI^)@^yZ^7@gy1tEaB`ot;*x?9(hn15{XV_pzz}QiZQdYL3$$Fsb3qp+T85|4ZwHHMD_l= zN&>jKK;feIK?HSRM>VDjKnMWey#qCY!hLpjqd+>-2vdJYZX&2~4WLYWpfxIXY5$y$ zYyWG~O9fbb+X2}DiR&dsB}Wo}_;fE)R<}v4Qnr+uS2*EQh}diBu4DT;q$MKmJBC*H z2%fY;US4qj!(S3h^p=vv8R=M|*A0RiEZ}qGE^=im(JK%}+|?fC-Q$Vr8e+vT{%eE> zY%W4nB#~QJYFjff#0dfu_kcjmD7FWI$Y)crdAg4K`utf{gm33Q>QaEOvN*B-!~{To z&80TMHo>Z`L8OJ&8llg%A(V!Nab*pe9?q+$y37_SgN-rN(Tjyv7!`jXOgTH50E`5x z?AQ&HF=UFG#~&pYdWuX1QCy^aD_hX>c=<&Y1`-=U=mf*bKmFMVAni(qxEpj#*Fb>hN_GjEx ztqO6J8dtn+Vb1-L{{Hflai59*jwvAidqesh>ck@`-wp?BW~4-m?joOoL$X=YIu-sh z7e_(@W37;#0JFdLACLX*Z{#EXJ3{Dqy|8{7jKOEnRy`QFns_l)R)Q)Ug85f@U5Xv^ zfEY#8{>o~8IDK=+-=DoTH+wHA^1KtAIiE~ zG$%%asP`|SC;j=;g%Z%8DcB2KJ-LZy2kwu{={3mKs4HJMn~retPfRN_Jukojd?`@b z|F`~wibnm_xrcv^yx{50!@J{VjfXgn3hmWzI}9`AYsFBu&L0zgo|J6lpJjXn2Hw;M z>%JG}cE>ymu;^#4+W6sm#g&$Ki#Y$2+Kj3?I5Vm2>j&M9TX}vl_vX{=C~s-h*t*vA zvZWTJ4U@s&TOR5(-|A+QE-XaHT15BALe9o>f27sjYMzm84gUUqNfY)EEQU#EqA_FI-MmaK@HJmuh&|LFJ_E1Z_+!AzxO zYIfU|yF1irlXLs--F|1iLx|!xJ!ZfbAk*K+m2bJ_TV)oZGw(9S!S*2EtbjIsV#YRI zPaPcG<{?oEFzujrG5F9UkTM2Z9zh47Oah<%Q&al?Pgnn(uKo(DgTLo{W}0f26CCb# zQtOqKrNJ{f(Hle$ZKFx(?{_O+ny(5KEFa~=kGAqnLq(r%Jk4QL#M)C&dGAJE9yiTs z5CbW48jjr}=;~{nF9Z;kw0_gCK|FP;JL;;DAYBAs>dxU}n{a zL+S$Tm7+28V@_M==CtW^?$0c%t#sT*Wcxh-98H9|dIdKa*|CqjJX^Jb z0E|6h-adl<{Xu^l4%~na{BrP2l@T~c_a3ANQ@EO0Y_Ge3>ZM_&N!6%#E9tXOG>ORZ z-@_(KFja0qEwEnic2%@458S|gU2OIQC<1Y5>Tj|(igzvbc>7x2*4q=oxADl&oF|f7y zvw-m-UIo>n1_*R%P@VcEK;qNbVH^hF{YkCk84e_PgayvP{)+A9RggkkB&kM1cej(I?G|ry%PEy7;ufbmJMG#Iiz1 zBz@(dABS4agp#(sYhzd`2lLqbxi-nTXkfGAel*4>0Zg()V}|R z^yYmU*4f!SMC}74QQa*#3B)o?%G9oYfW!bsU2{LuPtlV=S` zCeujd!;MwQ(i$ob=2Goo)qK+uYUGWRV^fRynTF^9Htf({aa@)yL9woiY7xvpxIJf7 zz#JQH!W9 z%YgNz{hec!0aaVciA4^zdi)4B9}5N%r*+m9&HkBgxbhQ8PhaNH&er}ABUU2Qe3@(p z9}&DCbEA!yoQKT1j=TEXZQJ$HdarYg#7I-89~<_0^m8`9SVzqTnt+Zp(oE{LlBJ(c z))eR3?HqPk_jLc%kJzpVY`!dci63W)WRU|Ds1b%}(!<5NKn_;E^)1jU1CunD%}dmU zhc?ZvV-4OaQw}YDqG)VqWp2FaQz>ZPzV$1-;f)Q*jaN!uoafwRf!gP@={In@Er{?( zoVuq9M228<>SZm}W;*=L%yDuudrUKlJ~j%lg|fXgIgc#0I3al;1%?=hjj?MVOlZ0C zJ88s8H8ql6ND_$oDb5`BP(zJda2S%LAO|pY2a#3rP&bZ8mN#GjH@XhYja)314i;UW zic)?o(rO}}Q0fMyK==4L@fzlO|$C)@{Xs1Rwa6* zNB3^N@6a;`h>M2=bO&HS`z~m_CupNlkd|E_c{uCG5+hv2e0Bd=^#M{9Y;36j!Q4VB z$W{S_DBkGAAbTF|$XFh(22zsaQZ=X7TCIpwV(delIHTAzR9(mxZ9vQyx7an7LsDVs zaQX05nRv4tk84ajJEG-1$GT>_jAY3zE<*gIrep;;$amgX$q_@zp~@>ii}P3E3)-93;^o?$H^$|P%`tq}4#_lIxf82UFu>Okw6gXo z;4a9Vy3#LMV!w$h&d-ceKbED!+FAP)7aWzr(g_A{Yk6_%C6`1gl*vlSm#g18&ZtM! zGcd)N(0d32$#>Q+em-@y&iuFzm$$5$%VExbx3wWpbIA@D+g$=zYAaUqekW;`pR>IZ zbQBbZ3~FAV}`vcD{KywUi?`n)TJ#-Li@q<-lmuTJkQ?Y*1IAsPWAb{M1a zcNA`r-;|%OGB&Mi`&>(=e=t&mogPV{n<2hBXly&GPB7);y5P>(F6}RP*L3(g`aFG8 z3ynfRkrNzM6eD({*p}ogsfRU=K2dNp6;L?>&R3_~8Ysx9Ku3VAK3o-Km|Dqq&?)%a zcD47MIt(8;+lyO`65xv?pCb7hkA&FrSYc!-mF89TfoE zR<&s{`_3&H6s%uXjB3-OQaE~o?NWzMZTKN?oeQ;boZ=YkkmKp;RDsG*+;R1}!xgSd`$XkPHc!WKO(v;)#a`=AK;owl11lov79h^!eNxD|1H&7&gQS_UR;9QdiQnUK%)qVz*75 zF5^C@Q2gQN&#W?Xg9f;vEvl~%j*}seqsX6F@%VXgv&1jgC3NFAzCVH_cpTYpUo2ZD zd0OkKateJzD$qS%L^yl<^vys4vkYnbc*w<- zi*T)X=TP}!_K;aH8Cz}<1ln%7t1(sfNHw0+u(i`3XI)|LCo4?bCg@EL!=mfvxz?syT$ zoqeYJo!zQQIC*;E{3XLf21R72b-M04g+Z;3iDaYEcKI=|b6goDffC&&D6UPow+|q7o08(gZBO?q|j5piI)xo*8N4 z5K*teN)+qLGSX6*dpk`^fnsNh-O4%#feHboDDI`)z01Z}S)|*zAb#njQoCev^5wo_!el@xLh69! z+ojXxeaerUh~2L{78!%4Dm!@{49Ul|+qtrRgr;3z_4EKRK^nb%OE=%oy_DX~w2$mV zO^rR^AB=yT3=-qWCA}l`d@0t37%vyOTC=Nqc1UT)0K?sR6LqO`A?sX)dE@J3$~zU-(T&uB_&TO|Ml`bj z6Rr*4e1eQ}#~n|1^ws`h7R6e#yG_v@4vfRA3_*OEp%0j)nCR^PB-s6>fO&CW$N51V z2Cl*N!=;fujQmAt-ijZ`I;9te;n}UZfa1Rk7&uBaMRoFpr=$c;YDTn*Ns!D!Wuo`4 z6-Y*HXpoJI)V~Ut0}+z!zl1wB?TTl6FphO&?e^@`tBP~@?NTufa~`iXHQkhp!MdY7 zT7aQ3YT!Q!cfX-K2Y%Hrx5SoaU~aJ39!`QS$`!aBJsoCPtshA_55+UNBhp9aMd%VS zL6~AuPyzoQ@b1gLB|iCu4Tw&~lv|Hn>Rh)~Som=(t6awWG8Le%1RmA^;uTP%8yA29 zZ|skNm*d|D;wuHZ;KqGY$Pn5RlZ`8RD(IH7JM@`in36UgSBm1|)9anDgx06kqGL## zKLTFISx2kNTe*lu{W6V2$uRka{W}V-#78Kj-MHJLFPa}}nU%(M8ff@Nd111zqYGEb zY1f>Qvy!>vQ=a7$QrX>2r_U#LpF>*EwjVjcZ+$FFr5&FWIx~FwEXuWB z?T-07gKLq~Zv3!{pdYEqqse)=oc_m#V6s_3(7jN31ZPd#Bt$MAFGW8I$ng|d>qhmR zO5sX0#I-H#AXc6z>k?Re*GKkjdhsMsvG!7@Lm zmB5PP6K_lM4}ZHh4mwdl>f={FLerAc+smd&O~IR)>v zG@~P#CXZ7)>D;ggSR5537V;OufO2zd?vG(Ft|zpj$J)n#cOg}@C2xm&Ctk>R#+3lO#OzBxLq7iR8;cir-2W6}1Z zOIflL8La8b&g<+h^jGvjHed>6AFp|>d4k}D?|7R-7jKu#lDE^a?Ic{g2{etbuHR&1 zz237%H%xS}Uq1=AY@1X$J%o^;mo)jzALfQ^wIj5Vc6K=Wl3y&YgltEvee|@oQ3OUj zOx}D^kCBlqZAD!Nz*YsDnUI0W3lA{j?m=y4OZC7e_oki>9u)@}5ww1t)kqEYNm!BfF1HROBq9*SFg97#MiF&YS$T zHQ^?Q`0Ec9z11mF?PuK|kz&*zr`4MsS<`}lNU02wwBx*YZGb2Y1^xrw+%s&MUhROyn6Mm z>~7AvSC{53D`Oosh#9kvu6(iVT-dfH?*kqz?{$-MMtJk`3oCE|TU}@}ThZd(rCsmvG+*xjVCu+-E@#rc9^P zpIyI4C1K{0+e5aSU(5OF$>l%5@L%|)TKj9$1d=sC1XQU7!MH-k>6OyqbRW)yxAL6~ zzeytVn(~^97erWTy!neM?PAq`_r0pJ&Z9gaiWiZ5tvU`^_p|FBV=QfW6t?mqc7Fv} z9J|E+rvX!6o|_RWf7;%ww-U7;!^_7Q1RW3hvowvZE+2E};p_x3V18&pvHw>$FJr#= z>`kAmFO$(3V_v`+nbVwILXuiEr-M zjM^IuB6tSYjl?&7l}@bk3RW|nqfIzR_s$7Ar<@_nU&GgQ&mpctniBYx-JI+Xl}{M9 z?LZCo?dq-F2y4yGLGiNM>=s_FONiD*wBOsWpW4KZ%aN+q&ugs2ujgX68Oh`@@oeuW zaGp{W9H$GK<)KJuWmHunWj^76`td388hIJ(?|^^=1yW?g!7danjjHY~s$Z>;OKojc zzyhcpfpN? zwjUb;{T;V9j0fH^nzZp&K+()mIinyNG{WyB(!8HhAn{F>@df^cZRn4c#-e9r)aSiY z`_q&Rytj${3de`FIh08KS}ikAU^>XWFDUS*U4huevxZAntFl3`hhfD8E z)VhU~N(43rixo9^z^C-6gxXSIauKbrq_86StD45{>Y<>9n4aNtM3NH`rk?_*h|&I% zSRUOjf7`MIq(u9ucGJ1RaSSdDClQal$a8f%%CRwefAU3yD#Gxf9#FIp9RI$8! z3ogS_MiOg^X9itpN8&`+Yq z1ot}1(*Vu;wAfJqf2Db-}Vv<`M{d<|x#*FfncJ^papLM4GLwr}`LEaIv` z!zSOJj;>B$(l$(-e7rj2fwgqJoZ_ge7^xf0cCt^LCqXal)SX+OU(qZTa3YY-(P+FU zYRI+zuEG+dnc8}dN|U)imHdTOr-(IceL8j1hd-;R2`hGWm}g0thWzWt-)iX~pT(yu z5B^8+)Xjk%ZYg^hQ`rO;Zhg8B%$YNBcA;0SIP_Iv&MjKw_U4gH-wY(1Q%Qo_bVCMD z=7o1d;Ds$aQ}5|}4^XlhK9CX1Q#r%LW5$=4dbUoG)+`GXEBPy7@I2_nZS-MU5{%i| zB_3i3%S$sT*Tcy&0WHezO8UC;m39^V ziX`>CLqZU>S#JCrulBc)AFXcXojAkew-ki8;Ln>h;r0m>u{0_PNC-&`t1au&XwNI? zpKAn=W=_m=WM`x_t~J_o>%i-D;Ir+#!TJe`5NdsBBCx*e)6m?Fge@j3K4_I)&dB++ zI>Aoq8x1y8l}wX5AfL)P;yr$d*l(zF6;sH*)bU%SoI+^4c<^4y89j$TuEs!S6r|VE z?ihDINfCqrDoPb%-{iw{a~52w#CA$g znbIo4bC4ZTmUZuZGp`%xvvd42>ezf@4+b@5 zRvHz5ic|6_vywT^GpH_dcre&QTS_=e4KUNJCsiAA3l}>2!+RF06v0RHH!UOrq}tQh z~Lrq|*0&L&OGnF+KN!gt9aemh} z?WO2bhM7?=lA|f#MSn(gnEa|;iM~aS1vwPEHd3H4^CK(~*{JKVqSo2Sic*NneIENwP+Fc!CR9^ueOd95!Vp3r=Mw=wJpzGaAkGlv?18nsl>fT@O0l5rQ(C*=WBWw;j*O4PuZn zKC5eBzzyy90zGM31wIc~aCE_*Xwx3WuLt+0IP?tWbq~fu%moe94l=pfxjFO`^6T;H zNibSJ@DVv-d`^36Gdl$c1Q*Zu5|kbwhM`u%g>{`pBh(kyyfO2++v+Tf%H}I*VS7kz z+aDg|`P}t+SxcYni`_ojg`f3$o1_WA7?DRwyHIeo7f(m%noL(pf6Tk=GfBUDn?m;0 z@Xxt@1L2flb@|ssZp088twwj@rxCA)$y6Ic4u+Y(*V=>zK8Bu8ZJmc(%f`)96u^H2 zP0Htmq#14_TrwUb+-knaKA1s&jAR#wK!QOZZ& z992=G>TRy7B%%Cjwirv+RN$T0MS9CY!Rnrvt358-YdNgJE4ZEnWDf&R<)U&fK_|g+ zGtaCY_nYUaV$*eM&3q0-75_+Ej;9sde;{GL?Q1voE%?_^0LbgQ4BW0>=``M=?!uIB z=?|rVAQd83`$C(#m!dwutRJTK5@0hkt@?cTGe+vDJ|tlW9kIY{f2=K?W1A0MD~*l} zQM_+tSV7c*o8!7CY-Kb1>-sJ!cXsaaqv`GD(Q;?HZwr%W%U8d9Gqv!O@oBb*OA6Ra zGq%YF7aEp6S@ONTb%jppuby;k?AW1Z2-izD=q!9gw6*qh@#oxCxqA=J&LeRG)2SF` zqR^ye#0;0SxmU@}qtcG47tq~Y?*ug;74*=U(m=;0CQ0cz`5{3>Jo&AMVCw@lMo1Gi zsD^ny1Zsidb95mFG=gSRN8ON{uZB0TqO$a-jlD#$OfIx08B1-I=?`~ado9x%(A#x> zhc@lR)#BpA8~l`4h)%D>{+a!;pyLrMuXvmG_y^aumA~SE%hVb5aVQ?$BThdQNi?x<6y}#QrS1EPRVGUtn5;*ITMEy25>our!E5QH)55qAO%FPx7Rc^%8iEOkw zyo+Asm2e3MD6`^`aPdlFnA=LXA4Tkn25(V*!+X%M%Ws(7%G)Gtx+>aS7TA-b@L@kn zreyF>!j=j~6CAD?9{&ztieV^E^l0O z3fF_QuA~Lg&9$v!lkUx6=D3|Om=9~`wYjRl!?USVmyss1tt8f!Y%4H%w@j3r+L&yK zKeGet1^bZ7WjUAhr4Q^yY=Gd7O65q;&4TgE2Gez*ufIvqb46~sZ$WPPg<8uqC?=Hp zTW8B}eL7qFEpebUre7cHfvO8Hg}FzfdIsZ*Y`|uE^?112 z?&K(l%2Eis;(_cA4{YEWZL%YnT~C*zisodq|F>+0&6Ia`X~9|z38W!B@lIx*fQePj zJPchZ^dK$jq3?DckY(9-ImkI;K|qS(#P?wgA}++ak{~0@LRH@_&ykq)tS?4=my#3mkrDIoL6u=?W)truU6n|!al}5rU9g=Us(y%3f0xH=4yUup z{&{Li(DHh@x_dskEJ~QjG0Kq6|FrzwmS5Nl@kkQlAkk^Cw#k*tW}e!CH@q42WMo7b z2iIq42@rZyTurTEf+>xHzU_qK@fhNP#w#rKB-E!c3m(~+ITiRS$at@Bws$n%KaN+h zB#KuMG(Oi~*^u^$CR63p;22zB<*3J0Ap3S&-bN@RnVQ*Vah2`N z1L$e`_o-j6tD{J=_`CNV_>qb)wm(eJ`|r6@2SC6^Mb)y%HWSQ?tlw=vj8VD32#C5X zJwr?OlYc7S?gOPna)vg-9Nz}cf3U`l8nY${F->;-x;)>Bz+Spx@z#ZiCtIvCk=VYw zkU%dGb72lb5OKuKaYDD;8=`gJ$YD_^pQT2w5~%tl?nhRQz^-sS)^oy?u}-=}U3?2( z%@#QOb%p7n%oF~{z&l>kBN!f7xG?hrJ`^s>EXj)Kg$F2Gpf*pKgQu^n>%;3&*hm>5 zB{J?)`+-Y~aAEB*=d+C-<+a1r$W&Q_0~U2GXfe@-I|C%x{h*4JAofo3(A9+{H z@aLq=>^NqcW*p_1%0ZSKkpyBR4yoxw(hV+J#3H0C$F?kmi|}S~ZK>&Fiil~~Z{&w} zJbDcA(+m1oU>{C>a4Q{fd8JF+K&()J0tTyb^Ig(M*D&QK{hQa2w(bsZTjiVNMv)jm zmL{;y6kyvScN6lYQqxkZk7-rr*!;#whvw&)=Y0uh7kGw=kh( z{-^~G;WmzffEVk|-EJHdftPDFBRYI>&bEtUs-uiUf#Qa(?>y32UZo+?4AmB+Dbf>e zCaSWFOPpO=fDoWqAuV6P>r^t0m#V;5q9>WX5>vwrUZc{kw8FtKlnSm)jZ!bNeoP6% zzO_L^sAwv<(S)p61%;yqPi!Zo$4GpUi`J6r1((JFY}!fnSQ}6U+yfIZ0to_tkH3}A zXMMBE)f&A8p1SOdO;zW~8coHAKX*(9**_txu8DZ7{wdkW-2JO-E6O3{r{SNG)oK|| z)=0DGUcsW?dRZKp`}IIdsf5{RwH`CPVCH$S%@TS|D^@>#wj{!@!T1`~;a+T)si+bY z29s@FHZQ_6tTEc{Z`mf;tR-Ix*7l)6Lh@DyWTHT45OjWk2038H-w6ee-OR+Ds|8U% zEKt99g!|Hg&*#8gDnv|BTp%M#NijWDK<&p|)3|4}G3_kXcvhSHBb!e^)*PT`f6s^) z=KuDMY57@hKm26)oP%59{wyWn@$GZ=<~#C zj6JpN@yCSgcO6k;*eKYwfNHa57p1#;uXMKaEkO!=gSf9*r{TIyvuE8c@n)$lSD5mR zQozhXNk<{*J+^OAXTDKHK(K7(yP;WAybnH0k=`t!_4PK<=!1Z4+_%<36D1SYR^A6E zP`-Vh{p;h8SeEO`kT;=oatY4Nx`&3)%m{=-WYPiI1@;O4C+bnHg+&?E=f`)CJ+*U}BV~i<$Ki=taZ#a@FOXgvo1I5hq zYZLy`$~w*_itr$1cqn>vPLOggG5WWd)D}WS7%@N0>ID&=ljA4vDHE$@0jox_u~dkH z_j;RbrkO{tAo|@LpDl0uakM7a4MU)5>Uqcqm3a|b1xm3Ojwh8iN;-Fk+$a^>X7W;R zwfjui6uv4y5SUAk*bH^X3U&6vF5F1T)X$-Irom7uE8$F=4w|*JH9%Ou4iA?Lu(Ss7 zZBfzseae5Yd{L+OJbFX9$twKnicEy_Hc(J?aV6kAIPo&{^X1iaAo2DR#8Fj?`wni%SEN(uF!dp zyzm2=!Higdg%Lwal8ljwLrsOGA)mZ~S|N{4fJF?%R9xFq-^r(~mRV9AjJ(uxtS~D* zHA^KUq4YC&BL$a06**hg7wiv8=K2xBcE;v8;(X!Bnn^k31#wyNnqNK_LhK}2I;kaY zVZuLMERSg=X)D9Jv;?qe&|?7vI@J@NL31H_e3DykBpFje+#Pe2DszvXQBd&+@ZX^u zo=TKE3INfPeQQ1K0rAOXy=RV6XGA(3lupD|?3DzoYN)7JXb0kei`z%2wvVL`zk;V(;hlNMJlb8k^#0efOE zD3uGdXAsu!LN^Y-ihmu~o5c+exRM zwYIwZINsg;1Md0ho&)o|#x*Jfx7`mqrIsE|-QK34n)M;6_{cobgtG$JJa<8odKsuA z=ZY!pb7$mpjfjn}V@VNV?;y}Q7J3lM%a855kq%*15@%g2K{C5ELW8{4si>Tcw_hkn zgQ##?aLrO|R$|V%dWT$N5$LQ=CJ3DSSOGQ@5%QWYYJf);C%@qPQfq`;qay2P#uvg3Zf!fa9AdnFKE7n-*U*f(1@-?Z>Cj93I5 zKt!)kfqMszBXm*;tA`#3cw=y0|J@D!1dtrqrP z?$m~q9i};|M0VmBeR2C7X8H)k?fyQE?iZ6(7lE(Qsi$C^l`<#{G&yphs0`aP7*_Gq zhDVuGWz`JW>$kM|YJwikj_Vg=ccd{o{(ORYf%+!B7(3VoFQ3O{rvFPO)zX5tl?(TJ z@*;NXE7=G5{ClB(In00J7mDvej*a&TlrAH%YP{->Xlw=76cC>+1(vz{eqwOt^k+z_ z!_JGa6`zBTJnfKgqsT$h8;*4GpSWG0sy)RL^;3$uI`r`$mB)jor}?oCndl2$=2FiM zlwL2$PPmvb9p|kElHM-wE|o`@avdk{M+|}+e{_d5JkdH|sqZ`v%N9mB9gvys{8A=N z8>-XW&niMc8y9c;-2KlEdtQktNNA`EXcDd$y`}Sb0D{exKi`4sJ2ink)i{|9MZ489 zHbl2ebI*ITm-Ccb$@&dzG6aSHJ>m0jnLR;iKDm(tXeB;iytuXmJFkDT9G^bh3ewOM0F=z6098`Zz~ zExk+on8Y*hd|v4{4`+pGEd%!bI?%%WBTh*n@3`j*`;SbPb-*J6JCZ4$>1Jp8?4Ww+ z6vY;$Z1SIk=f8|cWk;UfUAW4+6yclkB!4rW%)g8$34L*PDy7^46XXg@Q9@Lo>YMT0 z8C5*nF=_va{>yk=Cp9VpY?KMV8IMQYe=?p7*msqbMw^0v7|-6n84u1kLch@v(d?VOjoxamB=o&|YevN^ZRF;k82W8`h|M$m1ABZ%^FnevMkm z2)1KS-B~qu;!d5|aP(x-3~l=m9`J|2+mqlGV^0foOtmM@QAMZEJii=COdxaLaRA~>knyT9Haqg2e|t?pO(oX_b3 z<3Qb^q817JVRn+2_XQ(cS4DDunR)B2$qKf6@nL9nW52s|9M3s0>>JT>W-BV|M<^vp zi?)oP-B=X#K}9U9H>_5xWGj9{9^1c=r$$A%3VYf&TXFSm-RR|X@0l#Kx_Y=kGoYKk z7$!SP=J-vr;^yANR`9;Sk&;DG4BgapM6wlNP5`>)O2UZC;6O6wYjT`+O6<~N1VRMT zVuI$z^XKpl4sf`vj*86x(TxhJ-z?Y#zA=*-tO z%7E&q!Jt>^NGKW>s?FSaA>`*$ZviPE?A^i!cjjSY^>K}_1Yp)VJ#G657!2hEWZ|{O zeT`q2JdDa~=(6n0k?^0R7uIfVu3$4;`kX(Ox%noL$pMcSi5Gm@c&WHjXJ*&NM^c7A%r_ zdRZMj9wJrEk6vKpHbZiO5WcR%j>RjWcd7i#v{ws{GM#kQ8TQ!qV znnP$ELmep9ZNX#Z^-(L15B%FVyjVWPV=&}>63A&K3&(Dr6DOUR0+c?4 zU@+!|#Zx!p7IHQ;7puT`wIKSM+|M?Nf4I&~94B+1FJy|Y$p^^)B7#c;)PMa)1lLRe zbvK{XO{vMuMFnYM?BXlq%AV9#8(5U<|1yG8%KwhwtOSEKeV0K`^*VP!1dH>#MZ9 zQLl00-nklsvjLiLFbztIB!B)#h-XaIF-$&<7ARHnogf`qG`baaZMgADyU6C zDWu|FG3M5awmp%+IteNkZfo(DtHPzOJ{kQ z86gUXusiAX_eK&Vnnu-?ubnLtayj6rCO7U@1_swhmJe=n&QUq#A8Mv5P|gFASOMQh z(MW$gj$irK+H;7SVTbcvZU0Rk0_kcECDBlp|I*q!95#c32ppaY=6G7yj9KN)2=QlI1~~_MqpA(gdjcMnh?ua5uo<#buZ-H zRAM7AxrMpLdUWJFcdS!XnIqPzskHx99_A+A?@d}u1m56!<4KhS+IuW*>3`=AT!}pX z;BUbZGMUvZyr(ag3>{yev0c0t`3Wvylzc)=Xai=nO)>MYQN0YZ)Rv{dAJR4@iJ2=1 z%hQEc#v}YXri4VAYNgz%{1g|Of0c)L3ny8NK)X(ii3sL+y_79mISmk%%?M)ix=O;t zJ-jc)%@Ah?ll!!ox_SFXqxVkcd*8X^+pJ&pZn+45`bI9zlU||$fXOX(9tl!(RRi7G zNB?i`0Os`c_3?SUd=G87qurPSTR%VP?Tu$luXYgUdyAu5)BL*KwQrK3cdq$n7{TIJqd;?SO72`Cg7m(+Jpi?lyj2s-mIoJ z*-t@#Q(;mDKp*qQGq0LnxxrTgF50FgQ0c_bDKT{C#4gE&bCl-8<#wm1jMuen%*)3a zfywEGoBP#^Z@aA59Y4DLBJct5xJaZLEYySVAEtY$v^gVw8xjz~=8QPJiS?O17OOdMci z%bnvw$!S?J`*q)w5f)*oS1u87=re&X1FEA!NS3nh02I$@6@Eo4ubu0hASfMI%Ty~H z{XWm(QMtAaDq>^}$)zD1lsamlArND_yuzv&U=6*N>s5vd4FI~;(PXa>pa7?`rG6++ z$K=Ahn@Oj%O_|{bNUFU#f^6C1QFdHsdWfssU-VuG?E;e9sujV=HXT>44Js=c5o1?a zH_9pES5Md1SpH~A9Z~Suk%F7qb*7V0qDM}PU^`I{azbv<@f?xUZ(xf&S&ah$M9Oq{ zFKPzwyJxbjEN`u})UkyuS3ao_z=;yzo7DbP+w`4l1rzM_Jv~sB;8;>fkDJhS>X)z( zy72>}J=H+rYXYaLvea48r$hkX+vbc3j!3tU?ULBDkE=M&&3NXm-dMlFH(&cdoLo*Q zus$Vsua6`+O*gjahxJrty8Cbn-nQyoMR4uuG|X|oV%zpYavYzuz2Cv_KOi?*OHjT* z__W8!@*j{E&2V;-JtN+Vwi$X17w8sfVpSozUWnrhzXRl72g1KuB5sbLD_^Erfwe)g zU~tM&O?OPBQjnt{q|mTtZa3Eay_%3G{?3x%IxYP{vOe$gl9E7+q^a-Zt4gOzc1M$r zkV0d7)bU*JuMFMe;75!Hj%Syc!pH92T75b!V+O&I^%@tIDhS&CP`e6KDxK-sw=cz{ zcd}=|p~weIB>=`a2;%>S2mdog`;VW21pyQK)LiuY5QWYpe`xbZ*$I%>AKM))3I7AO zBfHWBC(ZZ>jp;nphj$>L{xSA~vGo>nBi_Y?^eA|aAb}JBRt=6F!Gkm@rV;!9Tes8K z#M09*hYu}-o~>;QM}4Z#@$;1(xm%rh&BuNxE-3eJx8rwa|8 zPPWxkvrp=ZZKLD=-tGJ%fKm&|_K&HxXl&NQ5iwO>QD% z)S6BzUrKxTvxE%0zjrj%Ggeq}%VWH-9OS6m3<$?d`4dxfS7UVy{qAZ|W?HW50j$(! zYv5v`VIo5**jcy^=Pr4)7*t>o%PZA+bUoc3li1-XIs&?*sJqTuc^X(QOFc3#Ia*UH zB|B+&+~D4R>O18B^Dh4rV#)IKDWEC2*h-Sei}3RDDP4GqiQ}K8xc@eh%BwNi;9E*W zGd;T0Id*S--!?xIuYL%?wxy1EPN*N@F@uB`a<-Re><`6c>hZAEc)rR`5r`UF6r}sA ziPk*(qSw%sCqC^R-DQIWSTM}@YWd%qL(u{t@WXi3(|*5l#Y@}v(ZhsHKdbJ`fndf- z;8ZZ6LIuhw22u#@1xY}WDwxYb!+d^Z`2Zl_@4wdRa@7Q~H&go&eyPWZ;+@3HX;;sZ z0ow8Qycyy%WrsPrp|{H3FAULvZ#kFv3-d{kJ_D2saBj!Xx|?d zn0E4vOH~_F$1ZKkgyi8(f$MrS&T@kcpEpj$6ix|sOew9IeU7oC@M9%VqaI=-C-oVz zQ;peHY7Is0BU-vNCJnf^OBxr??(-U#n+@I@2Fi`9h*&)#ZF;x@Aeg<0Q7?(LQv)E} zkcm;37I}It<0f^KLv?1QG&o5H1i~bb$aO);O_`;j=V#QPim})ez&)W6+g>_M*KkUI z+trM{;e_VX#TK7^QJz8=bSB0Sg}`20{5U%(m)bqILQW7dS!I2)?zkR^!qT|vuho=W z%aw0RrXm)4Dhp0*DnhXtI#!y>p`IImGEEA*?;R?~Sa#~`DiXd1XkmZ)l#xLH0#It2 z4fyZ3Jfusc!-IEC%OoAQV@+iDH`r4(K_rLoC7y40ARkTV?QK|IL_TR9`(*-Xgv+Ba-{)UrEJ}cduYbR3#Hhxp6eq;8in9FF`DHG< z23G@jR$4{`~pC6|CV9i6WQ$*|TmrYG({BD$#c~`XvFjJR}ma87G z??CXG;bJ{!ixuiSHFCMR8LVu3%`i{qW}c-ecNvc^9zhX*$1gDjpoo3ba$%+Vyb%HP z5pwi$q7RsEuuvtJ`1jNi?lZ%z^51!^BYFJ3 z9(RJ%RkCO}MR z1gWP=ZB8er&e@){${hT)INZy3YS z<&jJ`_7VIXG;)r-a?Ns|2-93uIdH1bog^A{0IAmoeriol`h!%XMLU_mA5KEik&aY! z1h$*}x>HB0(VCanI&*|#`?L89j?Nx``#*lpbh^*m(^t+-C(TyZ`k1SDLl|47tr6<| zrj3TPpJ6g*;OYRn`-qh+sa|iP&P+L zKCd5qlL&ddeDI|@w=GhGBJQ7;nq^%t<5MK~%NkzWnwVR2$)T4=+?;QIAK+7o3{r^;?{MD7UX4(rZ4NQgrpn8BXe1h+Aa=HV!3Yt77_;$&G zjaa5`4+4ZT5ENcIe&(sw{wn#tSv~;%-#2R-D4x!WLP}gvSVmD8K;K8R64H7d;JVkx zdeQJQf8{FS45dzhcz-SBo|L=oIF*ii1Dp%9rAwb~!DXR=--sW9^;!3}Pa zXP7`Hv;TE{Ms!#%`*==&hF2fuulrgjdMxd5n{;*gT(NZ-vhs&OHiB_)w$y)TkPB65 z+dUB^o>(8@UPrYxy>sb${GVCW0`fHJ(CPCD^X$BkH1)<0AqLPS#)6QyTX*H+5=q>n zdJZE$fG7OsHfnfvlzV75bl{IO*11a*_-f7~B$Uf;g^k(Nj;h3r+sh@p))!V$NFt+L zl8LnCj9rY&&&L$d>(}STk}}8gRJChHlcEk~8!F5V8N2?J8DYbXD$J@RV{0!_7Fe6> zIEBP|&{)0~=#fuPR?z0G2w6l(F;&;MMwj=P3%>1Aw?<5qM^dt2PF>6V_73?7o?Yl z2o2-qOB?#lKxCmfDb>DKnxCS*U?VLK#zksvR3$-kclz7Qa3E#Uz%w0(2_~u8j#qvp zdUxd6Gv5-c3_UrMhKpp{inT*v$&_AwE>@v!Ja6`#R?mD>>zKkeQ#3-yt)O{a8`1=kwWSz^-5P?H*x9 zdYrkyuujj)RzcrWa@obRWm%v{_7KTb6Pu*xO|MfC=1kEBdbG!K;=y=)PsJr)gaYgV zfF2UwFoL}2&1{)zMmT(6M8Z(E6FATS=TODjR>3}EJ|vyp-}^V?z_Abx7I)F6eRnso z79h6{1>~VC{wr$lwlR*&h4F9OGD1?RCFk^?Sp@T=nWDS?hTx<(UKr#)jItooeRf9a zvBLMgPeNY9&*mcs7<1fcaPK75&hS(OwB37GJKT>n!9H@IalizNPVq#3gCH%w{k>P2YlA}Q~0mCX#jL% z)_S+QbWqbZnyM(#rrUMWtlHG*&;p;9zo*rY@%)4{t_b?jJF^5(>~P0vJ3$s@M} zILfgszc68JYA!C`eTp1~t1dE|v^7$&80v1*4!)E%6v-^xlH{V1mhc&rA2D`4hx(cY zeX#(An*eYczrI%L>2DGT<)q&A7?3vSMMP})O`thA*jhps4^Kn%AABm(xJrKnogoZN z2fAA6k*V86FU&*^NjL*u(A?;cbv0eX352r|XpbjUw*aieV%25}_CrIw^x6+LQ<9E5 zZTy_>)X^P>Q*>4d*f4<<4yC|<66+Sr9yiYH@6eV%IRbLfq<#hSIf2>2g+gV-y`>>` z1Gu>#Jx@W!xYEfeFK@5Aw=w>~HV~1WX~JHsPVjXY&Aq&grTx22(8Ji=_7M5>BV2iM zSq~0$ZgSk{tU-YF;$%v@{{ct|*>RQU+km7;8NVvD$xq)v6>R|4zhk#f;aJfLdsF*v zx%)JNoJ7HRrAu%UpDWj>T;c}iR_dmG6W`D$8C4c&1nUY#b$2Fs7kos)ZgkyHZtdVf zSv3@tm@ak!tPJj9tt9nvq0UUlCIfW~#wYjZ4^EI3P8t8!i&<0TZ*6iGBrC3Z*T_0vUQ!KTO z;X;dW4j*-U{dusv1d4n~1+@cKchT;7Yj6g4*7dt?k;w#=@|D!@PdPNd52EFO}_HMyDvV3_58+7slUFYMA zjIqNJv?~dR-tWm0^h+PJJc+vyvipkCN9cdtWWBKn4&l@Y8+g{+*~)F6Y4+6|QQ2+9 zT{UqiTNQg(vY4(bbyhr<2jC_9I3}`DYd;ip^@iK82()XRw$F73y43Df8Gewp0Q6T9 z#!vIR$chN`qkF2{!1!MGD0tueam7hMr#2{f*u}}RqN2tTAvgdzHdnZH=vln44WzQx z+*HR{$Fin9HN9XHS!}R7lh8v-7aBU@5~4iVOfQTN#Cx+>RQggPLbY?jfuV<l?dDof`8}7i#aN?RPB>qU#>Lxw&U=N0Z>2@bAfFQR>t||Urr!L- z>y>i+$-=g3JKCGs3!pWcfUf#Nt|}i;20sOX9>H7qu{Z@R+;dXv_$Rv`=i|2~tD05W zx?kvXa_&WyUM6Sis=G~;KG6P_j!+vQ1R8R?N8c?gSy9^dFG+k-h4ENLTix&G8AY;2 zjuWO6A3Q5Cn1uzDWG3O{|NQ9A%Nmfb3*}iR7)gI(DR{fmJ?1(nL5}`BQp_@QO2p39 zb`ACP`BQzTi1V>W`bsay<>Zu(^WtA@hY3%+!Tp+tt9ybm4`e zT=FIR-H;`*k=Cwi|GLzkpx)7*{X%B~_M*tISfItB?ZP&AV{Lk)SNJ_H=8e5^yf$~A z^A3|Rl;UBV<;7l^EqkHG(AZ^Y?4|P}R^;hYVrL>iDX^srhOetnrmSlyB8e3@oX|Tv zfiMK=p>r~OqtdHMz~K8g!>~;gmlmzi<#QHUO$=!?I07Q=_6BWmQfmbzQx5 z)uPR;vTtK){nras&rS>Z&9n-%p_q9>rZuTQI8gSI3RI$fM`dLB596*e2n;1E$>eph zNQsJip$|`TwsKPIAlk*&QS|x*mt3{fKZ_HsAjUFlTAJ$2%GKs;$5o6(-lw%{5{gP~ z>tVNWSidEA`R7w6IBUvfV-~8>u<(2uIuH;t=_ncIdhLERQCNYE#47sZ5Y|ihOsb$D znFh;-`m&Yw6DPlr=|T$nzGuKa`NBasQex4tR^rB|ndnzGMx!<=luM0b z=iwU>PQYK*pu`%AM+u22W(Hk^U`4vD+bj!3!Ir)7M1ttpL3Bgo5mG%NZD6# zu88PJTw$i(iOr3ewV<^w;n+&hh~oSJ0#RFDlc*(<_1sIfs4L%>m=E4o9sJ2CX2+aEK#-yNuSvz5TUWZp~(YI`H=G||%p2VoQ0@2% z*MILsz~Dx0_9EQc9u(VDCfmu=pXp~vZr+~Kk@M>lh&FV5+c&@gSZ9y`{@*&0H0M%d z+0gvMq{z>?O`i;hy7DpajKb`^LHI9s$eQ5dEOnzWx!hcErLV$0WzmWYgO8=1PHE0m zt&SF3@(`fB8x!P#SrR zCW6Nu8o}tdDr>_5CeIpm9-HYB$9=m<5!Xo@^n1C`2LEfP<@)->sO1VvD{6TgJ3rA& z`j5=qS~|U~^&xfU7xa>-(f}2HAD@^Qfp4R4`*0woQ6ul_mBeW~aa*5J<0*Faa8YOg z1slBPx~A_gJ6T0qc25kU>qs?e8;Am!$y4i*K4t@w29(Q^i$05J`0{5BPRl_o{jAyN zTlc980evL1CxCN%g^qF;rRu`MU>NNPm88Y}p5l^1fyTnQl6|Pdvg99vsGo29n#WDaZbO0%KI;s$bhNYjhiYfN+T40g6@6hm>Pyi$cpMTZQk z5}Qd0G){X-Wj`NiRz34{yN6NOx>B%7*W#(Q^3&1wYKiMqlMyR;jf3LPW?L?hdE@I8 z`-Y~K8^x}cUPdr^W6taf1`sDn((llF=Eh0Rh2u&q-85GMR%?|fii9Ny!J;Zo zNu?E)I#aKllNg{T#iFtmf)|sH3#yF^#HeIEvycesIFWclBGX=Gn)j7C4SQumR>5*g zJLu<-kF^XN0K0YmHoqqdxz+6j#Dxs$r-?y(ik4;-jwS4*Mk=A8CA&7|>g&}4iCB$4aIrhf&0w+QJxYgcV(NqRXPr zknyJ~>;rq<4VfeLB(RAy*?a`8g#Ki`;ZTt6}BW)&MUWOkQv=))Fr5ckWt+Is!fFA{Z`1f}9}r5Wl7pm8sv zU9OYJ{fvhr#1cb^aiJ)E@`pG*V4UcX z?JsZ1kyGNQp1Z)uC9!#rV7uG)A z3kmjrfoPoB0^z^>P9zP>{2wcOLAS7I4mT;a2(+Wx53$+vg>jUl4+bcO`$IH%f%i+Sp4jfFQ|`%_&z zwg3K**V{ahr_cqB)|)n%4aU3w2sy|3O(R>7qWwPImqMW)50N>VDU0lC!3dnNnZ z2@Dw;e)I#w62W69-K4yad&J!qFfQ|L@xVfMQ$Qgnx#%I4Wko+4bI^-3SlRW$j%WfD zonX02axkyOJEx*~xsk*mm$p=H`WTs|FzxCY>%sy0j+59%MkoxC)y)>2`nB z*ckqCd@)YDgMLSoOL+-XYTV6oF(rn4^oy2AY9S@r1cB|WM<@%6{3wNj-y zs+E21v+ljS6?(9DbY;pq=sp_?7yWwv4)5ol*(}U#1h2Qf(P;Tll6Odrnp&$HR^YN^ z%ej$D#U3ZinXl4jJgpC*?5|`|#$OG@R<8~|Q92k0+Y7FnfgxSRgVjM_l$N*T4_mEs zW|-ZApN2ml;{a&+3L)w)mF9?ESJPTh11`WLhvY~)Je<97$`8(_`_Y|`K|}N3(c_x^ zm!3oqNuM<1Uz16B&p>nU3K^3j6Ei6vynk91pRUaX3n8+8zvnB+N6!630K=ET@?K!m z=f>|0Nyy<1Yb1J=lh|R8X^61Z&y>ozVeKI7Xln@D7rl>tmL1S7Y*;(YSPc2e*ucfK z^)&f(bh1U>vzfz9(1DlDZ8Arl^e((7sW6d}MWNl` zrs-VR8~^%n6?!y@nrjG!nu3a@q@wl*$_Xt0;urcBeH~&@|L^Lv=JwDe>ruC1HKTdXDR# zW~FTl+A-zIj%i^et`hB%YoIQtJj9C$=VL$GI`%!pvmqi8e@|pHw=STM)HuFD4A%VV zge|riL~4DEDGUM)6iCX_4%;7k;0lt2N2kDW^CEUA?@1QFgfzu5*B!6N^c}j$^=;NjfxY&$Gi}!fBt%H1uIVRjr$VPlg zq*^0Ml*Af+p*m$0x3p*22!4$hQ$jN*cH`YH@v>$bpXUoaNz!NG2I&9%gLP0WQZ^GN zXUqFKVtF#}naIfeAd~s0zQ~`i4;Teoj{qpWg)DpraMI0QBr^qD zEHwZuQ0t9*EcA1qEjk?aR>0+rH5=vyDbhlqS`Fz+_$%I>6@t>n1=1CkRJSHU5M{+U zjDSkrL(gMI?|Q^USZ)b||P;aVlM`E*jY@Dwb(zV=FU@9(s~jTTMNJ zj6(N`VVh22B~!AP4jt8*|Co_&uhoPT>!um6X1svY%X-W)NoxhdWX42zK(yK*$i<~$ zc15jK|Dz1|V|^)0*L4eg5{YGR_ENE@CHiXM-huC;Yi9oQ`r5H)*^d+VE3kkFXb9*j^;BGZB-y z!R=U}r^TrMIptDlSC-&LgfVHQAku@XA&hvFs8CdqZnTgOx+|!-!3e9QkH`5ZjL~Um zPA76Ns>4q$q$i>=iflLiXE6JBgm4gy&0btclCx-m*-+r^pJaX0A$Bhgx4py(Fu0pe zlwRRXrHH=|NMi*}z-<(7#$h~K3x9Xq4G|UHEuGhXXa>lU`=*3(P2naLHppj;TBSf@ z4cl+0$qGBrdB<g;E2yfS&@#o{nws^cgRdPw<_*pP_A%NG z@XlTh9vEw)eBjY!tIVLA>0%?zyESnX7~4vp{5i~pp)#J|kHBkqgCqzDZ{x^{p{3g{ z`s8j5CGDA55sge^5h%wkcfRY|Wi`65w8uj%wugdX2iyCo_hj3S5hH_2d3mP_Zbsek zA{J%L3?GEwZe^yD&c{{Rh_e@Ygcg!i?gHL(l+|I*kZ2h_+DUN^WZKl-YT$ceQ<07@ zB?VK`yVMK*s8(?_cT=;TBN#ycJfj?~uKL`$P7!tXzJ$;B;llLn;>T=j8-pW_3NIjx z{jn6Di{4q>*Qq3mgga4Ht}Mlv;vM-OuWq{-Y@I^rC*|RL-2R*Y}HK zW~kTUd&G*hN-$sGuYC4^PvD-PxmYCzDipLmSYAV;_e9VqUjv@h14Lr)gX7JfQ~2MK z7-|P0qwjEA`Cs7{J+(UpEj1t|K=51aP%iK{i}4m3-%hGgNb{JD88cSp355KA5y9RL#>dF3aL~z# zxgOC+?Uvdv6EO{e;RRCKA-1&fiQ73@BG)ZZ9yB^@#l2Odz5}` zYa(`G=M5n;0aWy&lw|TlBVd-w_ToOO$2w{LFi~-jfT{aiNvJPh9BsQ-kdE~hbc?MR zOaOqqD+$3a)9-Frsn=$Y9p>8(HQ*R1(0s@IN>LARPz4DvCOdiG#F0`<(;Rd_gebGaW+gM#Sgd6W1cvjS5KkPGMc+HeWIA6wwfbaB^^CzSZyDxupOJ=mE? z=^NTmuiu5fU4gAsr+cmUg|7aU7aPg7K|eCP?1Gb%q2E-Ki*05GJyL0xf5A;QY;U98 z{pCut8-%R$Z(lHbIPfQfH_?Far6L;T*aq6BeNV_uwz(s)+mE)DSW5<%>>wy87Dke- z4}qS=GdC;|q%eM)plfL$$mamyLBvUS#oljJKYr&-<~3*EEPaiFaOI@m4uKRk6W4o^ zGs(M|-hYis0pLe%lQcO`E~oR(+bVY06(V>3^cx zDeNZu&WSDqkm#zmPUNX2w`}OdXkqtuEiiu5Y|}r>+-R$2R3a?op0ik$i)M>4)p(LD z_iHS8lW`Pq8e4rcJj#@QOFvFf!^TB{S`|yhILE%s4;53n*f_5!O|^ZX1G>2OIl$n# z1^9DX#G&X{62W4o76Be>T;)taMbMaV{Gl>ggfUPUpl}%>x@8`NVyd{+hbJj&3bdMI zdi8b4q%iG0t&28pGfNe#qAT6i0&bU6$;HoE;g7taCsdehG@VP=fn>1uHkIn}{X*sewak92Z2z z^A_r%J_2L2iDdQmSz_X54CZECkf2PiahFWS%>5(2VrF|Df&m0 zVYyu2gkht zzX9juY7jAIH{~$aYe#Ob_=slbE`Sa-V<{YdFd*0HgiU^%!HnM}ng(KL)&;0|n239Q z*Os(#V^Xs}uTdHkSlYgyz9JPQB_eN8<`bMR7!@nqEZP8qPm!;@n}ntMimmN=G>^3v zQa5j%H)etSy;A_CMDE%Bg+z99zE2+gdot~JU^C)jwFMxN2BGip`o8?i(~h^S2t1)Z z29k7;dt^_CMpl3s46F~aaxzi1!g7|>BF%}TPTgN!vWy@JwjRfXn9+@Ik6kTi2j-0V zkT1^CB3*dxDN$BM?uiS;mlukZR0}R57q2oWAwr7sTM`PeP3>$&PHbEY5O@5Z)-hG0 zSLIxBtgLHz&Retcsund8`V8DiB7ej)3QjrIXGf3Oly_!ug+hIi*qy7kl-_wLJ(a`p{(GpZ@Y$=sN% zBOXe8?w@ioRq>(q61Z@}>41?VNi^O7;8P?|eS4XezSw-*h(zZJ1+!=I%Ow9wzUXB+ zxB$VNdV(hacOKAdL=xf>HqAP}Js3+2rsQcby}clZhlwQ>N73JAmUk);>wgE)%6AX`!5LS7X4SL&npO+%$}r z)cf{Re;U;exWn;h9$9d(xUb`JIXe=UM?-YQ+v{2v;g?`z7okJm=2y?O?({<&0KmXr ztVzoIrr$;A2CeXJI3j^fbdjMO4>3J4UWb{m`$Kmv@spv+w;o~FL-rsH9r;jhq z8S|2Bsf0SZ=odSBNV=C89>aV2Gh;=e-9uyXJ*&7O1QU^wazq8|bq(oQ)MS*xWzK~n zy#Xs#pcL^!<}G_ig|zzCpntC8yQ;}8Gc2(o*$ONesEz~X*=jtj>UlD+Y5L*+uHAlq zI6JfPOg1Sjy$tQ60a+PSqu)fQT$t)8b!aKCZz=b{=tXNPdDErsg|qQQI@qdjZ($G8 z64>uQzJ%jb>M}Q*x}$mZOCOxkq3r>h*J!zwn z#{o?jsVL$UTC+X)r*`R%N5TG(L&f)Z13iJhfzWG4Y|ZbZYb&?OsExOhl1{Dcb4-%E zcZvxpjS2~Vo%`>dyGWq5Y9?bwzK;d~fOtsKKJyk4KLj#n|-a%JUqBBFdzxVluF|>5Atm%kYTIlPA!_X!1yD ztV3N}{s*OewNQJca}#Qql8W;W+tem%hlsnRlw^W*MP=%7q2pxD^x*?w=}5*3srJ-| zs0an)3iGNptQW28;(DEkr)xr{y^=hLii5_T6&%}OAx#&-fJ&Fk8@g)ie z%A9n_4>gt+SDSGarD?o%5)mkMMZU77fUo<)78T}*)J=$L_DU4j zs3a(B6&28y@{?{lJzTm0XNQX&*^)Xb?t|t}D2Za3^3uv)Er6T|+#Q@DpS+en#F zR=!@C*Ewi5DA&Ctw{^|d!D5>#o*1bEKKS6&Fr)BcxzXBi+$a## zbi35d%A8MDuDf=&W=QlScf<}an6U_$FU7PUhQ$*1vL{iXj}TOgejVKH^UAXB`(+U& z6y~$bP((JeT2#MoNHE?A=VCcYIJq0OBXb!{(Q)KbmpSf;phQ#7y5-Mx-KhOS@b}>` zMl^s^Sq=!6cK{oRk>lu?uz3RtD;`1&O&llmVFPKYTA7o%{9spXkq7h>an2^N>f<oa7*mlCL^+1D8e&|{2gy>hlcN4G1z`7O{~aPi1PgYEOuThyoQb38|XVlYsPN8#CI ziFQ7N_WLK-YLt-jGp6-1X)LTZuTjqAe07Z8sZaS_wqx~k&7M7#KzBF)D!*qVFTjJ{Ipz=@qwJyN{htdi^(_>}jcn^4>YP%M z_^penZY+@^4{3qq&hZ;NvWC`q+2cv6cY9}P-Q$j%YTG|wn4UbVTdI{B0H-aWPQU!k zwn+MbaP>Ne*$3GBp8akR_mGEYSqdiPpf>>SxK+MQS9oa3`F z-_I6Y#;bA7Q;e+%|E9gyQAc{y+rZA+d>t>E4cfl`$v|@qqJ1qZFU2+D`J`N|O?`Qu z7DT=JA^@(<+)tC;As}(oCT;L#@%5S^BXe9U={s8y{rT`vHyb(75MsG>`Zg9oDd`u*~Y+UTcW(iU?U#^u^L}Z zc!>CIg~zb~yj?uhW-1;?HJ@$60uxsc*&4jKzRx1L(J=UrP$@|*mF}L&(Z+-cs3{9} z+!Oqliz?6BoQfcL59u;U7eU3@+T>&@>aUi6OWWF%JFGRTxkEta>4T*RoHz>QUh7}D`O z&zu#M6-J&bsb-)rTh2Z5a#Ov5tRiHjyqe`LG_6*Y7vk|IiS+SjsHjs}vSWBFu+W|> zn%_tovfqw@Gw*DAqQn|u#i}gaC{RaW4{?oQYE8k;w9=}V+0On6Zy)W znAz@wm{PFR#?@R|xpiLZwgARr0$cqfQ7~5Q>*!;)+dQdXlca@0roh3j>|{(8j#-61 zCO{%vKMRfpk!Q1JSaJ>>VZUISiMY!uwnHc=+z(>yv401|C0+v6WFDs-EpKHTrdx5* z*1L@xU}+Q!j`Em>8+H1y$vd~>#$)rrui~_cP#6*zb_;{sV#Ds{?OQ~n>i|fUeUwRH z=y&FvvUwLKOuuH3z@Jv#f~iaGs8(!0zzE2XgvcnB$i3Gvuq6&Xejjb95+Vh+ckd-H$w_6^*5Zfm=5)W%Mu#x@%} zX_Cf`t;V*|*tTukwv9HnZJ)Pm?QfsG$JyUlUE_S`{DEgYbIyC-^SZ8EAE~Zp9dmez zpc2P*`l_vhqO|+JrCYAdvQMBSvkgRnl=@Kb=^(wwEDbSBgWlD&kHxS?>Ic!P+W)}5 zuC9GYJ;YD#!}glVwn9uT2$!)vju8!Kz<}MKwH|0lJ?d`etm3y%6djtTS!F;l@JY2t zMk&(V-RAug^sS+neWEY9G6W2%_VX%EwjWQ5V-;2o^uqFa<1`qDmrz` z9s!D@Z-m^>aCTJh2R1Tk-fF(FQ7IFWJ&|~{@2qPdKgoC|05=#yC*i~{N&N^2zqP6mG)cTL)rcao3IC$nXpx|_fpzi z%)Y7Na#eWj6IHNR{qS^qup52f)?lCG&>+3G+6SvCg?eQbR6&!v5fCt~dZoS5!g@Hz zi>$P>an3iwX~~RwGtjT=#+4V^U82XBFXV?FlHEHS5Tp1>g3NKX!!d)barZj+2q$i# zrC~nd;hL$ljcWZ`)*s#M)9d8Gov@SrO~#zWf#aroN3sw9CG=}2%=isqmm=j6t zdrrEz{qUh(C6q>US0M+PacO1|)xd|voTOSl&3NusJJtf(elWEb&opyLS*tAAiWMxRpfI*72%T$%AE138PK- zfzR>#?Gz5%&*Zm~KrGf2+9-_Nz7|MSZpBepO30Wv^EsU9xj>(VzVaruclsfv=EXO& z%~mr!EERF@e_%eXmDv-nr>tmp+pvJe(>MI>xgUis;G*9RQ1VgJZWukbz=GB8g@)gP($&qufs7QOB|e+U5vJ8^sMz zer(miT0FyfCDwDnVzHw6f!PvL_60w?HNL;>;C;nWd2JpHEnjbq-3bY-Rh!tR2yP`H zAA4DEeV|0LdoKj_gEdB_(06nQ-|H=M$$Mt;Z=oyBpk0o&0UdCa9ZFCrpqt?LHfT1b z0dUB4V(ciiUC!G9DxEn^Fv?)rY<`h+&cR8>$3N#YqQFB9EA@gpIs;jE2&7r-k3tKO z>{E5b5fn9}ZGgcKa7C5sV2GLw4l&rqbHNBY6|0Dkm2{ONAM)@&XkvKCe5@df&-9nJ zDS#bvnTfmsYEGRfy9KoIt)*_)NMHOFE0h^Bwy?@{3P;3QXq$ZWA)csuxR!l8)m&^z zwVjUOH+Zpp_qGk8)Q}x(h4kd2E}6wKN4MB2$6?~RY%+qNHhL1nzr9P+roH{by@Xqm zX{{@8WK7yv7b!v^9&HwP$%eI2RWX&d3WhM{RmT}#YIaQ}#Uh{ZTv@Qu?b1b`9@#ek z3E`yjL#CI9OInb|)Wo$Iosb#sC3}dQa0>&Ps%@9>%Y!vPd#h#pZKbWj&J0j?@^Jn% zRnD!k&IE&i%YMPTwvzzW5gUo1&}R`- zk@yg+q)uI-8f+#C-A>HbuW4?SVmC%*BQ&8SC%K+2wK*aPcB=$i;?S#kK&IEd<^i?CS^rL4Cdry0ywJ zrOI52hBJDM*=pL`f(=V|_|F>q8G9cR;Fd%b(~fo0m>VkBJiV<~?`1GftUn%Iv}|io z?VKwX&RJ~ThVi|DjDUrP)dGoK9I%7$7EqZI>Ck0qBlenaVqJmI3#x}2j24%*c8Asr z2@ev>CYXY+{`~edF5|GNHzkMw)qnM{nu2t82HNOTSf0f+!MPw<;JSii|4D$?&$nFS zjH8B!?VB3;5;T0kZ^&BM^tB zdNduwtfiDH&yJ_$jT$u$&NKRX?9H_#o+M~k>dRo~ZraPIPVZ1^D>6E7v>OcNvDI`= zvm8YS;{xL!<4s+2Ctv4c@^ArV_69kE67<}&i{Z`c@a82EnE*qJ!)fMb>=!cRR40OA zOeonh_`p-RQNRY=)Z2R|W+xGFvf{Xvk60_sm#uZKOJ04V?cZoS*zEO#It45mfTaZ>{7m=WF5BSne;2zq1 zayfL9%A~oUrr8=&dw;W>4?ib$IU+YMxfufoUf??$1&?^Zj9$NYE z_9IcbYuIRz()3xi1LlV`eOj!=yr=7ePq@>As zG5C!XuaIZV7zc%%7{)q0_!$U9x`*CZ5BP0s3Zzqz3RTH)O;}i;h|3#I;&&hRj-(l; zvmC~SpxuygKeGrZk7GPS3>_(i$iUNqKx34QNTde46vMPfRv8Z$P={cCwl%5Uj$VO( z+KRThr+35L*zTSwXd|faYHi$~v_!w}O(2U%J4FpG%Y=hTG}pFmzDz7hs`#2L*CHTH8yNL_f-dj znfr89y@H^955k`Lj|X6k1icem6L`kr3sC?BEnCz(<_F6X|x$vRK0 zP0-UFaAOStNHRH;P-wFjW$zJSGPBUafyzyHgP-L;=m-moFo2*N%s&hHpMkVV@d@f7 ziHQ+9G5yA+#zLZ3)ABNxW!bi2|0WKTB2U@;(bv{ntRBBG+rC{9ECD;VrzgLrM?a^> zCkUp%28r4Y>jgv(uDfjEu86fH(xF3FCFRBWefMd}SYsnJf0K&~JBJ$>2Yu1f5Y3(> z*MNYwve2kF!4>mV;mgsHbYwGfe~QRD?Cml*rA~N)Nq}T{V?HWr z9XLQwBR+O-?8d*62YEjM_iHdZIjxvMA;mmol1|sjjaSr7Zy(;tX*0;%?6{Vu?f(3D zc44<$ixyx5(thL>9CzkMqLVVUKsNX~(d0G&40Gz?5QmboFZJ`NJ((Nxy;G_w>I->w zSBPyjUO{%8m_0B!YNDxYVPftk?8b$TUhuC;Dt`nR{!Ctx5!Mn936bL$?*hsFtaB+W zl`@3KP6hxR24KwGfc#Z4tW)Zd?!y3ASA0_=xpTHScHmE^xmYBCG8H8BCCG1${Yi56 zX0f&YdMTV^^XK#*!LfHm#UKA^4Wbj&LDJ(BV`J1)z$r?Hhqgv47Fp)kA&Z#@cRX>c zZG*GQoMBS~Cn2A6LY8uz{V`k^F&Ygue_G(YZi_wm8B@(7hb?yVaK|K!AwDNJx$JRi z5FIEpb3ZuqaU0LWSm4$r+!x=N?`HU{;gQmhCX$v`=dMYOxeDuK^u}U}x?IXde}`|0 zp4+jqyYq(YlFQ3?Fqe5|J3EQc^7xwfMm$HiM4e<^jUg%cPEaK)*L?iu@U$NmDa3sl z?;CK?ds7&1xUFW;o-R=AFnzk2bU7o8R zL+MjAh2Gd4<3a7j!PCN2J9bVf_Vt6^fu;OQ4XD(l)&TYv67BYq+q2CAI8m%%*^yxs z+iI_Rx8|QRDDuv)ug+jE3H7pMnDXe#elSNgtw`5C8LnLdQ#{nkj2N(~KBwi9NObqM z(`Q3t85@Qf6~LzCFSik8EkflS1y-INFo2hxzQ;$9AKmv-`De3r=%h)Lw7m;{O z9tO61>2&QQj0{P9ff*zsU|C}=rx&sAv4+^s&LkZu> zwqOV4T$Y+fka&yzwe?O7pCmcY!dG2)&=*($OAc6g%L2^;tpowVPo}B;Si9C{#B8Zr zE_GL+N~Y+?o%?l{N;WBF_C4|=r1UBh$_1pGExCLm8;saF2*lvjeSip!%q!`{OlkMe zCL2|2OP)vIN4)?ZZ^K~2V3DHuH}_^X&<%_Dx1EX>UKhQ@YUHu?^Z zI%cM{Mu4zt7o1mS`D~IXN0gu9&^u;2?z^H6J745+gPWo*r*g~BxSk$Cbux$xt~^7F z2nRViu#?%O>T`wOI4ETYkgxjTRxOF2fPed|X#dw1M1ICU)A)h!7Rk@#iSHFablsc@ zR=B>SC_HRqqFcLn&!Ef|rQaGSfy&zG4J3np3QHDCK*forLl+;tPH#|bYC!XQZuBvh zsCtgW_f{k-8*+=9Wqrql_&NNyRi>8O?Ab3p=s_*E?6$k3llxBs+>+!ePSG@ z9bY6D=a`YAp|M6*vx$3QMB=~!=9YdN24g*nt;(91%py^)cPw&yzr63tY9!o2E-}AwRGQ)dlME=3t*ePyBFnke|FRK)WNbgws=J=Gh>1~z`9~T`~<#kdqI`@L% zeu*KpcNHE3?w|_l9nDz`$SKE8-H#mSs3_2ngtv(I$_P1%q63}zN$7-0QYS_8AhJ3; zP&^7H$MJodg2*nWXtjfc(0;QA9fm!W#1Pa3Q)h z+GLy4G=JU@RIrBZRA3gv{z9AC1JKX0X(5BG4G{izv{GpbwatpkV_0z!04d<{;-XMW@s}E4We#`}3s7dpP@U%TtFf**#+!iv&A3qRM z3{sDg>Au;HiB~EY>)Ua+Ip9De=~`e;Es%;N5$NyN7S9QndaSgGc%ng;e3eBgc9;X# zJLX@wAWTT^<0%k>+rLtEvUiodVaU#jyWnIFKh+`~pxYc-@0T%WM2P+1EJkGNrh;P4%wKy6u{{u!t z{72X>GnuBsSD78@FOT8d!s&=9fD(xOEstF|2KWSK`u@qrgu#P{ zDzzxft!%t>Qv0cz!6VibAuJh|t-_~Na0ks&iiU-)r+)cv5zC7Yf^V2`Z=Xn%GqdhN z$?y;()e%48xkYB6J43zIw>P&_C>`yXcB)Z-_?BYx?L3`-W+dW$#LXDxQbww-+5zd+ zEgfM|3D*<&Z+KO4K<$6I6!B%MdG=kGdL=$(B62J|DKEd%kw&a90%YFEQ!gSv_@new z@z;mcTA8~sY!_>IA?Xg(k*3MZ0zCmMh>w#m5o|c557dxtz5KELKF1eotVx zTj*3a+QV-%Vqd&k2tT8u5$>4l&)1ZyRkT&N4P=qOxf&k(MQVB+k5sK*u&%jXjipXK z`Gj}y9UPporugz=II$SOb;|D zS=h$Woq(0gvzx_l`x4ZRkzcYG+2$~7iQTQ=Z6#D)2XyZvl2tGTBC45Puk;_0VP5Ey z@aEF>lAwmy!OTXAn@oE7GWX*^S$ldr*-fhW@x+E>NcYtZ=hRgDi4;LIj&>9Z%Vic5 z&=1t_IUyO6I($l(1-P5$F6;{7gwBf2M^hj4+LSUCgk;!lj z)_*=|>e8n<0b$p4g?!Z3KPCs`7ZpqMaAhV3s|MSh#xO^q?@0E>D?~L}!2BFrC4ex6 z^f8OkEqZ-<7|C;5@gO?*Ll%`d>_&U^PkM-a+~)ec;5=@xBi*IXgeMw~g>qGKw|Y2- zjthtk4EfWSU;PF~tN|KP0}`{#-l53V+py(dB@2g5Rk@6+V3=>AZMRE^Kc!eddGKgi zGz2YMzBJVW^)ioll_f(6G>`t*1y7QKKGhGVEsp@qkA(iBx|*<3%l(E*jUP_#4Ie-G zDfYWCBKdeN$EXYla)7_WQo|Q-7+TV)Ck@9MljErq5s}@;7hIt-)(}gsk*iwCi}su- zH}1`NA;Y~zNy|3bh?=B|HXh*&eztX!ic_81{dD0_18P6EZ{qj-C7q0wD>p=ICt>JD z#vU3W(m`9Shsw;QjxF$W2j&cP))&MfG~fU=6|@Jr!POZkQZmRN;aJcVb$ z^84hJTNun&JZMyYxI9nI19+&&azqoJ`$5msE7{j?4~?qmAv@1FQz>Hx?m%y_&mH5> znnBANfAl#VZ+Y@|T4DZ#H?7nZ^cq=jup0~ia4uxCQQ z+R^Myh1>8+n;y}E<20Q5mjm;a7lB(m~~4H=!zI}4}i zww$e$+GcRRQ65#9%kodWVnJ6#9I=@OW|8@LdA$sIyJUP(rBEOvtC4n!?~Z9CVvdin zKJ1I-reoZUBg;G(ngBce`g4x1{cR;)9VyEn<{j0r814y`hhBe7+WAJliL+9{geNig z1H~7<0PdgGI$sz()%q5|o=q727(oT5dvjb3f^I}Q(~VE zn1!~%#W(inXBN(pm4Mva;}BCVP1iJM#%ljj)J(W4xEb(MX^*GGoy5MRg(ucBwZXwm zD|@dD6Wi+UU?}NC>?vkFdi94orrH2goCR>NPqgDaX@oK9m?G4>5{un?RU6$iXJ&Gd z%&7lJD+LamV-dSUPN~sm?I;~wjVpg&TA?qWVBqR^e4Z~40GrWS0o z+>o~YgwELX_3{QJj_e9=cCJlFcP%@sy#^cLRo+?a_FL3|qW({6fItesX8=cd`7m@A zKsU4hP8FFdF-~SZgm^17s$M1JV0OQXYsymr*iSRHrTl^aTaOw`{(bb2xxe zKNC$h#aTFQW|{W%kn-wU?tFnv>1v$>*-s7K@ue{!FKO&&->8V z+j8<@tTjmzz~bOC@gw%E4N>u|ej@A@?NaQrvjJ@&6>@nOf#Pc&GVoq64a;(H8(9;^ z0RqAl0za`ee&OSGbM&ycd|)S)retLEi}zzn+I==Zd|D4(7QBs)hj9>mH#W2?#TO3f zp$F$anGXGYK-~$l-6Az*B=oc*MIm2l{a6e5f_H5$)CfwMeiA)8(O?#~&@9MDZwJ~Z z&<@nl1eY6AYH1Y8)uw=-7WJI;X&&ebfhmh!ZbO@Xz@|}8nbu;!ji?_x`>~h^ya+7T z&{ZHsW7W?M82rpJ>s0hF8imnF09`Ny7LVTwMQiH*NwO?X)qx~y4SdG)w>XxV9vC*+ zFLK5&MJ5cOYy!9Vy8z&?9KRP0cpvgfI(%N%EWX;xNI2hTpDxzfITNND7rO9t!)wO{F< z5%l&tTG~ihxpFw>ALKfX=huE+QSv47Y`D3Fg~)scoEZ)i*7p8~X5u}sI$ksF`Up=w z3`#s3o(+_OLLGBLQXPkY*)FCYToMHzwr;bQ%6LVio4MBma+0Hqem$&2INZ|ZO}Lu6 z^=kdS1wT=;Kdk=?{8e5&nV<3gNkTEZ!(|Ba-N>6rv3)qX^E11Pi`oslGcnvhD!Td9 z+S?nJt_m{dDmE&JTd+-&KI>k`4v(Oe5WQd|x8RzmFn|EB{JZ?8hP{jjtrrvXUha|v z13BC`Sl&BvZLw0d$=$G{m+?V%P{8SFFT30C8104BKa3X38HAeY9pn=@m_B`M?)DVu zh*a)$YTlIlSW@PEk~_3TUSxwE6NlI@y8KVHn2S%!&OZ7|_%zw7XFmty0~SZb!HnLT z_3Dmm*P|I7eMc14%Z>lg>P2j!p=HI{H!Eav?zsrmh>iOMf!OE zTe??M-+$>|A>F<3WQe9)3Ua~#a|XzzC(yq#N#K7|0cQWC`EK}=pZ7nH?el4nR>n4I zm*>zzcj71$HXXG8$fpIf_{{OKDwP(b+XY4L`nN=tTSYscPXl^*@Igb^Y|5->8;Qf< z09lat9DjE^Tfkco(;DHC-?>)mqi4RuH2RP)`{fX)d{ScxplQ=$Chc&UnR-V80_HvJZ0ci}wyOEY7g6{umpW;#Tfb zWaE8OiY2z&2j+IgObA?H3~kAp_l@OcmM!59R+X=!ceJh+eEL*Otlle$gRQ` zHYT4}HY5#K@MPYsQ`#M!0Zc<2Y>jdDp&<$g_V0*Ms?49$)9ObC@bp0x6(anfLgU2D zh_+Kt0zEg0`m6BdQ$AS6>`jHl1~13MYc?%K8Hx9c{%Q#w2I2K~0r3F|6Z5mg^PQnV zADY*Rq9u#Oa?C6Fb)Kh&q_>;W{7N0BaSCbXFEy`c;NtbB?-*iv{W~q2$2n^HQsie7S%j7fIBwkx1^Agr@wZ?B5X?>&EGV4FhrhUG-r- zn|^LdW2exBMI%_q?c+?@4($ezA5~cgS3H1xDWL?aK51~M&{bx?7?`9bHY*}`NQbUA zdYs;%&D6IUP-FeRPl$!Wd4MLG!kyB1@&w|0Bo)ZZHBLdXVA+Bp&02BzwN~dVe@2&< znFB+kw3qKJ#)difCp$#FV(=JkW=QFv4v&~QjqVqa7cC5t@VG>xC7C1jG>M2Yuu!)g zH}v_wV@{giD$u-CeEI9U+%a#@8!2>j1)Z!WtecUa6;*RcC>gA^1DPYJ!nPr?Jt?h5?A%3GP18Q!n>DD9=& zE!Tc*0p0D6QCK!oa2(N*{f*oN76_5I@YMnZW#6iPP9UQL20ptt zk-R@0a;hr(E{%DdMUfGb?UHV&W7@1g1^rE8TLF-NeIFUx6Uy}&X=z7YI^dhn^4RkV z41$VNOyF3~NFdq|=Q4=i{U9H!Ok!viW+JAbIlaj*&OW_JRT{;MR`etE$T6hPrj2&n zgS%XuiXI$&7m$+vyv_id%bSMx4lA~xV?N?6%UiHJQFOGXD`;tZ8+va_$|JV{(<$lk zKt5F1M%*AxeTwj$rIM|%oX7QvIny&bNA!r57M9U{Zpt3u4tFN*F5v&P=PyCGp&u&v!<@OXJ%%GqWe*O1`TwZ|0aIlLHKda2`=8I zSSaY|R0Jk8f8TI28^zS@c&cj^%C9D78(Mk##SsQ}s4cXWP zx4HR8w)^$vS8ztTPSD{ZX9{Ti8+CPDTK@g!@4<|b5Ybn*wpUl3y4qpX_}nO#=12ev znYob$+3)nxWYXWLK>%U03}fa0yHDxgjgj6vakM-_v@jCSf3DaVZR=@rR1SJf; zbjtPhCLLV>ICS6VA=ot)HS=3N1NNT(Cufi+8Lr2S2B47rw{zg3W(>Ro9Zi3q9LZNUr@}QQBj9g>LJSPxuE6!LQpp7E{AP8^pH(KX?VHir)7!{@^mcfT%>@>nY>w)r-e=GD zqQW5-u<=re^HX)y3cV*S$c&551rAcoP=cLHNn&L8Zo>fl+`x~&|Gns;s@|W`LsLvL z80%o^f0i5D@j(L9yZ@ejkg5gMvfX_67&A`eBW#*1ADBD$<$zZL1`LY#PL&O@ z`w{f7tmxmJr#fmDK*PqpZ`|(exg4i#z{F9G!EoT4$hxRdcVw~40?>KZ*r1WR{f?-@ z&i_r2;mLq1yon1y;0f;ach@&pQr)5RC~QCeE-X->)O2L8Ghy=6iKcUjkFj|4R%3Z} z%ZE?@_x9ftj17~lJhA2&5y*fX3!}JJYQ3)Y&T#E0Febi$rH$UwJv^VlXJh-x;bnvl z7%QkXlz?-ZEW2zp+^iowO;FM_t8G%o8&-@cC18Ru@|leXrV@*VKa>~bVVH~*6VjHx z7Gu2-b>ui-mKpA*n3n#+;icS;U7D8yvz!CNd+ARzHjXQ=+Kn=M+4r?%($TD3E^XH| zfT~+l$$Qw}$%?s)cl5zkbN_Xl{gKg?e&zjtHL*693IYv;LJg;*6_b>h0$c=N#Z;sI zQAVX5{VyWYO%esPY7#}V`kZ=dk})(^FufptelI#PsbN9B(f2UG0XXH{_U1OVjVKKT z&9I!+9c&N+yuE`19DM!mCbc(YHfB^zhE{5@uJ<4FLy@)wrJq2-@z4XlcYn+`!_t%D zGadbg%Vak*^M)MHOV*IRz1$Q5qz@xc!Hzy;OL}xH3qvT2AM-+FQRFslFRw!6KK&~7 zLY0lSLuHg>F8funszL~__IHhkAGS3QDTBuHL(evq?3|A1+#Stl!_?@vocbTxCk=|@ zR)eVSkDz~LV*h?QR7L@%y-snOiXIy2O^tz#b!;CLZBgyn>QSipQ9wYfftMpW7shF{V^_&@Anw}0j-M?t@>D`jTmUC@_QyycB?rY!ooP22@22uAf% zo|&UNH(@!YYD7wlgE1iXojsstk=@92J>lvywn+UL>(#5b3!$Hdw&#~ILwLD2c*`tf zAKkcfN@ArGQuWfm$OqBbk9fVA%)pHmz*C(^ub3P-Yjd$cdfkAJ4%S{uw1Qh`?8PF+ zFbL$4ytjBLFWh-r<~bXrr$sP2 z=aIOqmed9?KDnM3)v&A(t!D;*eR(x;^FjR|aIjz@txm2z1WEervJ@WhKMbRHLd9vd zUg?;}G~J)F$s8SSe?=(<(QJbwS~+-^(~aYE`~|$b&&JWyv0B}D^N-nHCbGK@vHuKG z$f|kd{h(yuZAp*UEu<+4ZmfJPF}aR-4&NPWNKdjXuM(b#?5ez7hHxE%`Fi$|D#P_u zdSu1^$!9|#Eo5^ho$Jf$`Tosx1AtrB05}8s?`_!5Asb?tHiyOHQf1?3)pqj)JR0q2 z(D%SzzQWUn$6FBIvnZth1259orZ8ze6wA@JhC3JA`*QpD#IeRl9_E>@#y-ve`r3SYi#DAz!C~6B9ovZ)KL9G>EjnC(%eSXG3bHJ13)Eu)aDRfwZ=QS7FL{W<7mC5_ojPNu VkO2&l#Yv$+QtYmHNi3Nj{}+t}`m6u| literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256/.gitted/objects/pack/pack-f72bbfa35af982c2a60735152c80b24ee981cf102db76764c383f9b87935d0d3.idx b/tests/resources/testrepo_256/.gitted/objects/pack/pack-f72bbfa35af982c2a60735152c80b24ee981cf102db76764c383f9b87935d0d3.idx new file mode 100644 index 0000000000000000000000000000000000000000..1d197e87085e32a838da41a976b0dbf13938628b GIT binary patch literal 1336 zcmexg;-AdGz`z8=qk!}fU<7KRB?iUIKx1a08>od@fM!t>vjWW|?pt)*BaNFAyuP`%y7il{<)*l^up!FyVBLILX1~6UNj$>y7hv+?ty1Foih&9c8$9gZVTN(b|vv=+n z%vY#cef;}9o3l0T7e94ekq+)qb=qWeh$CyJ*trPpZY`#4Uej*2!>e|k<5Vsvk1x8F z`%9#=a4pwHFQtQVS#mr{Q3uw%)UbRqOEe-N)H^;`N0UujbJgVEHTHi0cWu3Y$MxLK zpUXA3KYsl0)3(#!e%|Q&dsA7I#cSe0dj`fGuHSS0ez(6`_s#Zi{DH~88P9h5PoBX8 za<(VeAqN45_n*7=abMb;A|~*W`QDLge}8v&U#5+p>zV&KtO$0Tx=zVq?E{J0XHvmM z5#?NM6N)^_4mjvcoe{j&?$m`Dv!>6vyUucog_rS`m&K6}??tAyYOlTZaEXcj`nR8E ztk~bb$0vP*UUZ3}2tRvCN80w_@TvAe#gqFFUfn%$QOBLO{Y5s*lYAdr>(2I0yPnUfJA41>o9i!$GHl)_^lURw zGqx${veU9^^TXL&loJDdfzC2AGQx0KM)i`y;->57*SAgA zJ|i7bzI2!Azy7+KBWX(y{>!QC)t>f|L13~N&sIhpE@NT{O=oZWuDyS8)X%0v%h*jt abs9GLy=*)$pu0Ui<#6-Q9hIgRE&~9e7#2MM literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256/.gitted/packed-refs b/tests/resources/testrepo_256/.gitted/packed-refs new file mode 100644 index 00000000000..75626adfed4 --- /dev/null +++ b/tests/resources/testrepo_256/.gitted/packed-refs @@ -0,0 +1,27 @@ +# pack-refs with: peeled fully-peeled sorted +a4813ef6708e6011e8187224297e83e4a285f58bf5eabb1db270351388603c95 refs/remotes/origin/br2 +a4813ef6708e6011e8187224297e83e4a285f58bf5eabb1db270351388603c95 refs/remotes/origin/cannot-fetch +4d46d9719e425ef2dfb5bfba098d0b62e21b2b92d0731892eef70db0870e3744 refs/remotes/origin/chomped +7e9424c06052ca33bfc599bccadee60065d8664a9af7648a1455100c4f772e1c refs/remotes/origin/haacked +decaff3051968d1f3a2defd3d4a80ced03101555e1fd8913b3544026c0717d4f refs/remotes/origin/master +decaff3051968d1f3a2defd3d4a80ced03101555e1fd8913b3544026c0717d4f refs/remotes/origin/not-good +66fe8385c6378bfa5ca5573bd0fdd773e4eadb0e86416b483f2c50c839859ecb refs/remotes/origin/packed +43e084a4599ca42c476919917e3db8fde0045ee66305fd5e634b0c793c536a1b refs/remotes/origin/packed-test +0118010feb81fe41b9df646d13866742a9070b56fd0ba9ab8dff828fc36c1f78 refs/remotes/origin/subtrees +4d46d9719e425ef2dfb5bfba098d0b62e21b2b92d0731892eef70db0870e3744 refs/remotes/origin/test +b83624f6ac0995273c0034a7ab8c68929bdc91b69ad54ef94979b93eba3f6022 refs/remotes/origin/track-local +4d46d9719e425ef2dfb5bfba098d0b62e21b2b92d0731892eef70db0870e3744 refs/remotes/origin/trailing +7e4633ae1b0e83503dbea4417f9d5ccaf22b877c5a4522b6d1d2b16090ee2f6f refs/remotes/origin/with-empty-log +d88b60d2641df3656381dc8e201abb820a414de03eb63c065b06a2ab37d3f5ca refs/tags/annotated_tag_to_blob +^33e415b835a670bb5c3c760efa0433ac0cbd2d44679f68f2df3a9ae7014cf2a8 +21e1e1ebe45b2c1ef79ab050334e36a8015a546f0740bea4505e10d81a946f61 refs/tags/e90810b +^4d46d9719e425ef2dfb5bfba098d0b62e21b2b92d0731892eef70db0870e3744 +34f79ad1c813b93d2ee11c830c2134815a31d9629e6aa9773338fedaab90976b refs/tags/hard_tag +^decaff3051968d1f3a2defd3d4a80ced03101555e1fd8913b3544026c0717d4f +33e415b835a670bb5c3c760efa0433ac0cbd2d44679f68f2df3a9ae7014cf2a8 refs/tags/point_to_blob +14bd335f9d7188c778d44eba8801fe9bda46b66593291f5b9f7cd5f8888af12f refs/tags/taggerless +^4d46d9719e425ef2dfb5bfba098d0b62e21b2b92d0731892eef70db0870e3744 +c258f010a08328a29cde33411d955520e0375fcbbcc14b7636a70f7536c32ef6 refs/tags/test +^4d46d9719e425ef2dfb5bfba098d0b62e21b2b92d0731892eef70db0870e3744 +34f79ad1c813b93d2ee11c830c2134815a31d9629e6aa9773338fedaab90976b refs/tags/wrapped_tag +^decaff3051968d1f3a2defd3d4a80ced03101555e1fd8913b3544026c0717d4f diff --git a/tests/resources/testrepo_256/.gitted/refs/heads/master b/tests/resources/testrepo_256/.gitted/refs/heads/master new file mode 100644 index 00000000000..106231c4cfa --- /dev/null +++ b/tests/resources/testrepo_256/.gitted/refs/heads/master @@ -0,0 +1 @@ +decaff3051968d1f3a2defd3d4a80ced03101555e1fd8913b3544026c0717d4f diff --git a/tests/resources/testrepo_256/.gitted/refs/remotes/origin/HEAD b/tests/resources/testrepo_256/.gitted/refs/remotes/origin/HEAD new file mode 100644 index 00000000000..6efe28fff83 --- /dev/null +++ b/tests/resources/testrepo_256/.gitted/refs/remotes/origin/HEAD @@ -0,0 +1 @@ +ref: refs/remotes/origin/master diff --git a/tests/resources/testrepo_256/README b/tests/resources/testrepo_256/README new file mode 100644 index 00000000000..a8233120f6a --- /dev/null +++ b/tests/resources/testrepo_256/README @@ -0,0 +1 @@ +hey there diff --git a/tests/resources/testrepo_256/branch_file.txt b/tests/resources/testrepo_256/branch_file.txt new file mode 100644 index 00000000000..3697d64be94 --- /dev/null +++ b/tests/resources/testrepo_256/branch_file.txt @@ -0,0 +1,2 @@ +hi +bye! diff --git a/tests/resources/testrepo_256/new.txt b/tests/resources/testrepo_256/new.txt new file mode 100644 index 00000000000..a71586c1dfe --- /dev/null +++ b/tests/resources/testrepo_256/new.txt @@ -0,0 +1 @@ +my new file From c0178ef365fcfabfa475906f2be8463e5afb4266 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Wed, 5 Apr 2023 10:48:24 +0100 Subject: [PATCH 208/608] refs: honor sha256 during allocation --- src/libgit2/refs.c | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/src/libgit2/refs.c b/src/libgit2/refs.c index 8e4abaccc1f..5e2fe97e76f 100644 --- a/src/libgit2/refs.c +++ b/src/libgit2/refs.c @@ -72,6 +72,7 @@ git_reference *git_reference__alloc( const git_oid *oid, const git_oid *peel) { + git_oid_t oid_type; git_reference *ref; GIT_ASSERT_ARG_WITH_RETVAL(name, NULL); @@ -84,10 +85,16 @@ git_reference *git_reference__alloc( ref->type = GIT_REFERENCE_DIRECT; git_oid_cpy(&ref->target.oid, oid); +#ifdef GIT_EXPERIMENTAL_SHA256 + oid_type = oid->type; +#else + oid_type = GIT_OID_SHA1; +#endif + if (peel != NULL) git_oid_cpy(&ref->peel, peel); else - git_oid_clear(&ref->peel, GIT_OID_SHA1); + git_oid_clear(&ref->peel, oid_type); return ref; } From 46365f6860dc3459e84c4ecf6b40f8754d443c83 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Wed, 5 Apr 2023 10:50:29 +0100 Subject: [PATCH 209/608] odb_pack: handle sha256 short lookups --- src/libgit2/odb_pack.c | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/src/libgit2/odb_pack.c b/src/libgit2/odb_pack.c index 1b1d122b06c..c6151f4e729 100644 --- a/src/libgit2/odb_pack.c +++ b/src/libgit2/odb_pack.c @@ -309,11 +309,17 @@ static int pack_entry_find_prefix( { int error; size_t i; - git_oid found_full_oid = GIT_OID_SHA1_ZERO; + git_oid found_full_oid; bool found = false; struct git_pack_file *last_found = backend->last_found, *p; git_midx_entry midx_entry; +#ifdef GIT_EXPERIMENTAL_SHA256 + git_oid_clear(&found_full_oid, short_oid->type); +#else + git_oid_clear(&found_full_oid, GIT_OID_SHA1); +#endif + if (backend->midx) { error = git_midx_entry_find(&midx_entry, backend->midx, short_oid, len); if (error == GIT_EAMBIGUOUS) From 53a46b40af65562a6ce87e15addc1843bbe762ed Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Wed, 5 Apr 2023 10:52:04 +0100 Subject: [PATCH 210/608] oid: support sha256 in tostr_s Our thread-local sha string buffer should be sized to support SHA256 strings. --- src/libgit2/threadstate.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/libgit2/threadstate.h b/src/libgit2/threadstate.h index f9e7ba7bfe0..65edec71723 100644 --- a/src/libgit2/threadstate.h +++ b/src/libgit2/threadstate.h @@ -13,7 +13,7 @@ typedef struct { git_error *last_error; git_error error_t; git_str error_buf; - char oid_fmt[GIT_OID_SHA1_HEXSIZE+1]; + char oid_fmt[GIT_OID_MAX_HEXSIZE+1]; } git_threadstate; extern int git_threadstate_global_init(void); From a850a4211a498f37688ad32b487a942c88eb31a8 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Wed, 5 Apr 2023 10:52:48 +0100 Subject: [PATCH 211/608] submodule: document OID as "oid" not "SHA1" --- src/libgit2/submodule.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/libgit2/submodule.h b/src/libgit2/submodule.h index 7fa98248620..40b7b70f777 100644 --- a/src/libgit2/submodule.h +++ b/src/libgit2/submodule.h @@ -69,9 +69,9 @@ * - `repo` is the parent repository that contains this submodule. * - `flags` after for internal use, tracking where this submodule has been * found (head, index, config, workdir) and known status info, etc. - * - `head_oid` is the SHA1 for the submodule path in the repo HEAD. - * - `index_oid` is the SHA1 for the submodule recorded in the index. - * - `wd_oid` is the SHA1 for the HEAD of the checked out submodule. + * - `head_oid` is the oid for the submodule path in the repo HEAD. + * - `index_oid` is the oid for the submodule recorded in the index. + * - `wd_oid` is the oid for the HEAD of the checked out submodule. * * If the submodule has been added to .gitmodules but not yet git added, * then the `index_oid` will be zero but still marked valid. If the From e61fac75520eacc4ea45b293d50af339662d8312 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Wed, 5 Apr 2023 12:23:05 +0100 Subject: [PATCH 212/608] packbuilder: write sha256 trailers when expected --- src/libgit2/pack-objects.c | 18 +++++++++++++----- src/libgit2/pack-objects.h | 2 ++ 2 files changed, 15 insertions(+), 5 deletions(-) diff --git a/src/libgit2/pack-objects.c b/src/libgit2/pack-objects.c index 20a5dfcbdd5..d6fd603268e 100644 --- a/src/libgit2/pack-objects.c +++ b/src/libgit2/pack-objects.c @@ -127,6 +127,7 @@ static int packbuilder_config(git_packbuilder *pb) int git_packbuilder_new(git_packbuilder **out, git_repository *repo) { + git_hash_algorithm_t hash_algorithm; git_packbuilder *pb; *out = NULL; @@ -134,6 +135,11 @@ int git_packbuilder_new(git_packbuilder **out, git_repository *repo) pb = git__calloc(1, sizeof(*pb)); GIT_ERROR_CHECK_ALLOC(pb); + pb->oid_type = repo->oid_type; + + hash_algorithm = git_oid_algorithm(pb->oid_type); + GIT_ASSERT(hash_algorithm); + if (git_oidmap_new(&pb->object_ix) < 0 || git_oidmap_new(&pb->walk_objects) < 0 || git_pool_init(&pb->object_pool, sizeof(struct walk_object)) < 0) @@ -142,7 +148,7 @@ int git_packbuilder_new(git_packbuilder **out, git_repository *repo) pb->repo = repo; pb->nr_threads = 1; /* do not spawn any thread by default */ - if (git_hash_ctx_init(&pb->ctx, GIT_HASH_ALGORITHM_SHA1) < 0 || + if (git_hash_ctx_init(&pb->ctx, hash_algorithm) < 0 || git_zstream_init(&pb->zstream, GIT_ZSTREAM_DEFLATE) < 0 || git_repository_odb(&pb->odb, repo) < 0 || packbuilder_config(pb) < 0) @@ -315,9 +321,11 @@ static int write_object( git_object_t type; unsigned char hdr[10], *zbuf = NULL; void *data = NULL; - size_t hdr_len, zbuf_len = COMPRESS_BUFLEN, data_len; + size_t hdr_len, zbuf_len = COMPRESS_BUFLEN, data_len, oid_size; int error; + oid_size = git_oid_size(pb->oid_type); + /* * If we have a delta base, let's use the delta to save space. * Otherwise load the whole object. 'data' ends up pointing to @@ -347,8 +355,8 @@ static int write_object( goto done; if (type == GIT_OBJECT_REF_DELTA) { - if ((error = write_cb(po->delta->id.id, GIT_OID_SHA1_SIZE, cb_data)) < 0 || - (error = git_hash_update(&pb->ctx, po->delta->id.id, GIT_OID_SHA1_SIZE)) < 0) + if ((error = write_cb(po->delta->id.id, oid_size, cb_data)) < 0 || + (error = git_hash_update(&pb->ctx, po->delta->id.id, oid_size)) < 0) goto done; } @@ -668,7 +676,7 @@ static int write_pack(git_packbuilder *pb, if ((error = git_hash_final(entry_oid.id, &pb->ctx)) < 0) goto done; - error = write_cb(entry_oid.id, GIT_OID_SHA1_SIZE, cb_data); + error = write_cb(entry_oid.id, git_oid_size(pb->oid_type), cb_data); done: /* if callback cancelled writing, we must still free delta_data */ diff --git a/src/libgit2/pack-objects.h b/src/libgit2/pack-objects.h index 2faa3ec7f51..c6bc52fdc5e 100644 --- a/src/libgit2/pack-objects.h +++ b/src/libgit2/pack-objects.h @@ -56,6 +56,8 @@ struct git_packbuilder { git_repository *repo; /* associated repository */ git_odb *odb; /* associated object database */ + git_oid_t oid_type; + git_hash_ctx ctx; git_zstream zstream; From 27e29472b5151635203e2f96a42457d0d6014421 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Wed, 5 Apr 2023 12:27:27 +0100 Subject: [PATCH 213/608] config: use sha256 as file checksum The config file checksum is only used to detect changes internally -- it is not stored within the repository. Therefore this need not be configurable. Use SHA256 everywhere, regardless of the repository object format. --- src/libgit2/config_file.c | 18 ++++++++---------- 1 file changed, 8 insertions(+), 10 deletions(-) diff --git a/src/libgit2/config_file.c b/src/libgit2/config_file.c index f3b87578d9c..716924de600 100644 --- a/src/libgit2/config_file.c +++ b/src/libgit2/config_file.c @@ -26,7 +26,7 @@ typedef struct config_file { git_futils_filestamp stamp; - unsigned char checksum[GIT_HASH_SHA1_SIZE]; + unsigned char checksum[GIT_HASH_SHA256_SIZE]; char *path; git_array_t(struct config_file) includes; } config_file; @@ -133,7 +133,7 @@ static int config_file_is_modified(int *modified, config_file *file) { config_file *include; git_str buf = GIT_STR_INIT; - unsigned char checksum[GIT_HASH_SHA1_SIZE]; + unsigned char checksum[GIT_HASH_SHA256_SIZE]; uint32_t i; int error = 0; @@ -145,10 +145,10 @@ static int config_file_is_modified(int *modified, config_file *file) if ((error = git_futils_readbuffer(&buf, file->path)) < 0) goto out; - if ((error = git_hash_buf(checksum, buf.ptr, buf.size, GIT_HASH_ALGORITHM_SHA1)) < 0) + if ((error = git_hash_buf(checksum, buf.ptr, buf.size, GIT_HASH_ALGORITHM_SHA256)) < 0) goto out; - if (memcmp(checksum, file->checksum, GIT_HASH_SHA1_SIZE) != 0) { + if (memcmp(checksum, file->checksum, GIT_HASH_SHA256_SIZE) != 0) { *modified = 1; goto out; } @@ -881,7 +881,7 @@ static int config_file_read( goto out; git_futils_filestamp_set_from_stat(&file->stamp, &st); - if ((error = git_hash_buf(file->checksum, contents.ptr, contents.size, GIT_HASH_ALGORITHM_SHA1)) < 0) + if ((error = git_hash_buf(file->checksum, contents.ptr, contents.size, GIT_HASH_ALGORITHM_SHA256)) < 0) goto out; if ((error = config_file_read_buffer(entries, repo, file, level, depth, @@ -1129,10 +1129,7 @@ static int config_file_write( git_config_parser parser = GIT_CONFIG_PARSER_INIT; git_filebuf file = GIT_FILEBUF_INIT; struct write_data write_data; - int filebuf_hash, error; - - filebuf_hash = git_filebuf_hash_flags(git_oid_algorithm(GIT_OID_SHA1)); - GIT_ASSERT(filebuf_hash); + int error; memset(&write_data, 0, sizeof(write_data)); @@ -1140,7 +1137,8 @@ static int config_file_write( error = git_str_puts(&contents, git_str_cstr(&cfg->locked_content) == NULL ? "" : git_str_cstr(&cfg->locked_content)); } else { if ((error = git_filebuf_open(&file, cfg->file.path, - filebuf_hash, GIT_CONFIG_FILE_MODE)) < 0) + GIT_FILEBUF_HASH_SHA256, + GIT_CONFIG_FILE_MODE)) < 0) goto done; /* We need to read in our own config file */ From 93e55a029818ec872d61da1f5776f3baf385f956 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Wed, 5 Apr 2023 12:42:43 +0100 Subject: [PATCH 214/608] object: sha256 lookups --- src/libgit2/object.c | 34 ++++++++++++++++++++++------------ 1 file changed, 22 insertions(+), 12 deletions(-) diff --git a/src/libgit2/object.c b/src/libgit2/object.c index d87d40cf16d..b7796f0574e 100644 --- a/src/libgit2/object.c +++ b/src/libgit2/object.c @@ -181,6 +181,7 @@ int git_object_lookup_prefix( git_object *object = NULL; git_odb *odb = NULL; git_odb_object *odb_obj = NULL; + size_t oid_hexsize; int error = 0; GIT_ASSERT_ARG(repo); @@ -196,10 +197,12 @@ int git_object_lookup_prefix( if (error < 0) return error; - if (len > GIT_OID_SHA1_HEXSIZE) - len = GIT_OID_SHA1_HEXSIZE; + oid_hexsize = git_oid_hexsize(repo->oid_type); - if (len == GIT_OID_SHA1_HEXSIZE) { + if (len > oid_hexsize) + len = oid_hexsize; + + if (len == oid_hexsize) { git_cached_obj *cached = NULL; /* We want to match the full id : we can first look up in the cache, @@ -233,8 +236,9 @@ int git_object_lookup_prefix( error = git_odb_read(&odb_obj, odb, id); } } else { - git_oid short_oid = GIT_OID_SHA1_ZERO; + git_oid short_oid; + git_oid_clear(&short_oid, repo->oid_type); git_oid__cpy_prefix(&short_oid, id, len); /* If len < GIT_OID_SHA1_HEXSIZE (a strict short oid was given), we have @@ -262,7 +266,8 @@ int git_object_lookup_prefix( } int git_object_lookup(git_object **object_out, git_repository *repo, const git_oid *id, git_object_t type) { - return git_object_lookup_prefix(object_out, repo, id, GIT_OID_SHA1_HEXSIZE, type); + return git_object_lookup_prefix(object_out, + repo, id, git_oid_hexsize(repo->oid_type), type); } void git_object_free(git_object *object) @@ -503,31 +508,36 @@ int git_object_lookup_bypath( static int git_object__short_id(git_str *out, const git_object *obj) { git_repository *repo; - int len = GIT_ABBREV_DEFAULT, error; - git_oid id = GIT_OID_SHA1_ZERO; + git_oid id; git_odb *odb; + size_t oid_hexsize; + int len = GIT_ABBREV_DEFAULT, error; GIT_ASSERT_ARG(out); GIT_ASSERT_ARG(obj); repo = git_object_owner(obj); + git_oid_clear(&id, repo->oid_type); + oid_hexsize = git_oid_hexsize(repo->oid_type); + if ((error = git_repository__configmap_lookup(&len, repo, GIT_CONFIGMAP_ABBREV)) < 0) return error; + if (len < 0 || (size_t)len > oid_hexsize) { + git_error_set(GIT_ERROR_CONFIG, "invalid oid abbreviation setting: '%d'", len); + return -1; + } + if ((error = git_repository_odb(&odb, repo)) < 0) return error; - while (len < GIT_OID_SHA1_HEXSIZE) { + while ((size_t)len < oid_hexsize) { /* set up short oid */ memcpy(&id.id, &obj->cached.oid.id, (len + 1) / 2); if (len & 1) id.id[len / 2] &= 0xf0; -#ifdef GIT_EXPERIMENTAL_SHA256 - id.type = GIT_OID_SHA1; -#endif - error = git_odb_exists_prefix(NULL, odb, &id, len); if (error != GIT_EAMBIGUOUS) break; From d1c92a9568a5d1d974b2601bed41a5c0504cf232 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Wed, 5 Apr 2023 12:48:00 +0100 Subject: [PATCH 215/608] refdb: handle SHA256 references --- src/libgit2/parse.c | 11 +++++++---- src/libgit2/parse.h | 2 +- src/libgit2/refdb_fs.c | 4 ++-- 3 files changed, 10 insertions(+), 7 deletions(-) diff --git a/src/libgit2/parse.c b/src/libgit2/parse.c index 55d3cb10ec9..9eb86a3f584 100644 --- a/src/libgit2/parse.c +++ b/src/libgit2/parse.c @@ -102,13 +102,16 @@ int git_parse_advance_digit(int64_t *out, git_parse_ctx *ctx, int base) return 0; } -int git_parse_advance_oid(git_oid *out, git_parse_ctx *ctx) +int git_parse_advance_oid(git_oid *out, git_parse_ctx *ctx, git_oid_t oid_type) { - if (ctx->line_len < GIT_OID_SHA1_HEXSIZE) + size_t oid_hexsize = git_oid_hexsize(oid_type); + GIT_ASSERT(oid_hexsize); + + if (ctx->line_len < oid_hexsize) return -1; - if ((git_oid__fromstrn(out, ctx->line, GIT_OID_SHA1_HEXSIZE, GIT_OID_SHA1)) < 0) + if ((git_oid__fromstrn(out, ctx->line, oid_hexsize, oid_type)) < 0) return -1; - git_parse_advance_chars(ctx, GIT_OID_SHA1_HEXSIZE); + git_parse_advance_chars(ctx, oid_hexsize); return 0; } diff --git a/src/libgit2/parse.h b/src/libgit2/parse.h index 0ecb7c103b9..beef1de12fb 100644 --- a/src/libgit2/parse.h +++ b/src/libgit2/parse.h @@ -50,7 +50,7 @@ int git_parse_advance_expected( int git_parse_advance_ws(git_parse_ctx *ctx); int git_parse_advance_nl(git_parse_ctx *ctx); int git_parse_advance_digit(int64_t *out, git_parse_ctx *ctx, int base); -int git_parse_advance_oid(git_oid *out, git_parse_ctx *ctx); +int git_parse_advance_oid(git_oid *out, git_parse_ctx *ctx, git_oid_t oid_type); enum GIT_PARSE_PEEK_FLAGS { GIT_PARSE_PEEK_SKIP_WHITESPACE = (1 << 0) diff --git a/src/libgit2/refdb_fs.c b/src/libgit2/refdb_fs.c index 9ce1a960833..6000dafb3fc 100644 --- a/src/libgit2/refdb_fs.c +++ b/src/libgit2/refdb_fs.c @@ -1949,9 +1949,9 @@ static int reflog_parse(git_reflog *log, const char *buf, size_t buf_size) entry->committer = git__calloc(1, sizeof(*entry->committer)); GIT_ERROR_CHECK_ALLOC(entry->committer); - if (git_parse_advance_oid(&entry->oid_old, &parser) < 0 || + if (git_parse_advance_oid(&entry->oid_old, &parser, log->oid_type) < 0 || git_parse_advance_expected(&parser, " ", 1) < 0 || - git_parse_advance_oid(&entry->oid_cur, &parser) < 0) + git_parse_advance_oid(&entry->oid_cur, &parser, log->oid_type) < 0) goto next; sig = parser.line; From bd5e3082fd494429a515db55353aab64b441a166 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 6 Apr 2023 09:26:02 +0100 Subject: [PATCH 216/608] remote: support SHA256 for remote refs --- src/libgit2/remote.c | 20 ++++++++++++++------ 1 file changed, 14 insertions(+), 6 deletions(-) diff --git a/src/libgit2/remote.c b/src/libgit2/remote.c index c3e2a324d23..c1dccbe3281 100644 --- a/src/libgit2/remote.c +++ b/src/libgit2/remote.c @@ -1631,7 +1631,10 @@ int git_remote_prune(git_remote *remote, const git_remote_callbacks *callbacks) const git_refspec *spec; const char *refname; int error; - git_oid zero_id = GIT_OID_SHA1_ZERO; + git_oid zero_id; + + GIT_ASSERT(remote && remote->repo); + git_oid_clear(&zero_id, remote->repo->oid_type); if (callbacks) GIT_ERROR_CHECK_VERSION(callbacks, GIT_REMOTE_CALLBACKS_VERSION, "git_remote_callbacks"); @@ -1733,9 +1736,12 @@ static int update_ref( const git_remote_callbacks *callbacks) { git_reference *ref; - git_oid old_id = GIT_OID_SHA1_ZERO; + git_oid old_id; int error; + GIT_ASSERT(remote && remote->repo); + git_oid_clear(&old_id, remote->repo->oid_type); + error = git_reference_name_to_id(&old_id, remote->repo, ref_name); if (error < 0 && error != GIT_ENOTFOUND) @@ -1779,6 +1785,8 @@ static int update_one_tip( int valid; int error; + GIT_ASSERT(remote && remote->repo); + if ((error = git_repository_odb__weakptr(&odb, remote->repo)) < 0) goto done; @@ -1839,7 +1847,7 @@ static int update_one_tip( } if (error == GIT_ENOTFOUND) { - git_oid_clear(&old, GIT_OID_SHA1); + git_oid_clear(&old, remote->repo->oid_type); error = 0; if (autotag && (error = git_vector_insert(update_heads, head)) < 0) @@ -1885,7 +1893,7 @@ static int update_tips_for_spec( int error = 0; size_t i; - GIT_ASSERT_ARG(remote); + GIT_ASSERT_ARG(remote && remote->repo); if (git_refspec__parse(&tagspec, GIT_REFSPEC_TAGS, true) < 0) return -1; @@ -1901,10 +1909,10 @@ static int update_tips_for_spec( } /* Handle specified oid sources */ - if (git_oid__is_hexstr(spec->src, GIT_OID_SHA1)) { + if (git_oid__is_hexstr(spec->src, remote->repo->oid_type)) { git_oid id; - if ((error = git_oid__fromstr(&id, spec->src, GIT_OID_SHA1)) < 0) + if ((error = git_oid__fromstr(&id, spec->src, remote->repo->oid_type)) < 0) goto on_error; if (spec->dst && From d16731e445eda35192f9c338d750a773d343d59a Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 6 Apr 2023 09:27:29 +0100 Subject: [PATCH 217/608] push: support SHA256 refs --- src/libgit2/push.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/libgit2/push.c b/src/libgit2/push.c index e256818707a..8b47abc2463 100644 --- a/src/libgit2/push.c +++ b/src/libgit2/push.c @@ -118,8 +118,8 @@ static int parse_refspec(git_push *push, push_spec **spec, const char *str) s = git__calloc(1, sizeof(*s)); GIT_ERROR_CHECK_ALLOC(s); - git_oid_clear(&s->loid, GIT_OID_SHA1); - git_oid_clear(&s->roid, GIT_OID_SHA1); + git_oid_clear(&s->loid, push->repo->oid_type); + git_oid_clear(&s->roid, push->repo->oid_type); if (git_refspec__parse(&s->refspec, str, false) < 0) { git_error_set(GIT_ERROR_INVALID, "invalid refspec %s", str); From 440b1995ab45ae205dd63366a374f2c491bd16a9 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 6 Apr 2023 09:30:20 +0100 Subject: [PATCH 218/608] fetch: support SHA256 refs --- src/libgit2/fetch.c | 4 ++-- src/libgit2/fetchhead.c | 20 +++++++++++--------- 2 files changed, 13 insertions(+), 11 deletions(-) diff --git a/src/libgit2/fetch.c b/src/libgit2/fetch.c index 003b5198ae8..ff10bde024f 100644 --- a/src/libgit2/fetch.c +++ b/src/libgit2/fetch.c @@ -76,7 +76,7 @@ static int maybe_want_oid(git_remote *remote, git_refspec *spec) oid_head = git__calloc(1, sizeof(git_remote_head)); GIT_ERROR_CHECK_ALLOC(oid_head); - git_oid__fromstr(&oid_head->oid, spec->src, GIT_OID_SHA1); + git_oid__fromstr(&oid_head->oid, spec->src, remote->repo->oid_type); if (spec->dst) { oid_head->name = git__strdup(spec->dst); @@ -137,7 +137,7 @@ static int filter_wants(git_remote *remote, const git_fetch_options *opts) /* Handle explicitly specified OID specs */ git_vector_foreach(&remote->active_refspecs, i, spec) { - if (!git_oid__is_hexstr(spec->src, GIT_OID_SHA1)) + if (!git_oid__is_hexstr(spec->src, remote->repo->oid_type)) continue; if (!(remote_caps & oid_mask)) { diff --git a/src/libgit2/fetchhead.c b/src/libgit2/fetchhead.c index 0ebfe5c439b..2f276e5265e 100644 --- a/src/libgit2/fetchhead.c +++ b/src/libgit2/fetchhead.c @@ -105,15 +105,14 @@ static int fetchhead_ref_write( git_filebuf *file, git_fetchhead_ref *fetchhead_ref) { - char oid[GIT_OID_SHA1_HEXSIZE + 1]; + char oid[GIT_OID_MAX_HEXSIZE + 1]; const char *type, *name; int head = 0; GIT_ASSERT_ARG(file); GIT_ASSERT_ARG(fetchhead_ref); - git_oid_fmt(oid, &fetchhead_ref->oid); - oid[GIT_OID_SHA1_HEXSIZE] = '\0'; + git_oid_tostr(oid, GIT_OID_MAX_HEXSIZE + 1, &fetchhead_ref->oid); if (git__prefixcmp(fetchhead_ref->ref_name, GIT_REFS_HEADS_DIR) == 0) { type = "branch "; @@ -174,7 +173,8 @@ static int fetchhead_ref_parse( git_str *ref_name, const char **remote_url, char *line, - size_t line_num) + size_t line_num, + git_oid_t oid_type) { char *oid_str, *is_merge_str, *desc, *name = NULL; const char *type = NULL; @@ -196,13 +196,13 @@ static int fetchhead_ref_parse( *is_merge = 1; } - if (strlen(oid_str) != GIT_OID_SHA1_HEXSIZE) { + if (strlen(oid_str) != git_oid_hexsize(oid_type)) { git_error_set(GIT_ERROR_FETCHHEAD, "invalid object ID in FETCH_HEAD line %"PRIuZ, line_num); return -1; } - if (git_oid__fromstr(oid, oid_str, GIT_OID_SHA1) < 0) { + if (git_oid__fromstr(oid, oid_str, oid_type) < 0) { const git_error *oid_err = git_error_last(); const char *err_msg = oid_err ? oid_err->message : "invalid object ID"; @@ -269,7 +269,8 @@ static int fetchhead_ref_parse( return error; } -int git_repository_fetchhead_foreach(git_repository *repo, +int git_repository_fetchhead_foreach( + git_repository *repo, git_repository_fetchhead_foreach_cb cb, void *payload) { @@ -296,8 +297,9 @@ int git_repository_fetchhead_foreach(git_repository *repo, while ((line = git__strsep(&buffer, "\n")) != NULL) { ++line_num; - if ((error = fetchhead_ref_parse( - &oid, &is_merge, &name, &remote_url, line, line_num)) < 0) + if ((error = fetchhead_ref_parse(&oid, &is_merge, &name, + &remote_url, line, line_num, + repo->oid_type)) < 0) goto done; if (git_str_len(&name) > 0) From 14fc473a4d7f08d8b18878ecbf78ae03d6d756eb Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 6 Apr 2023 09:34:09 +0100 Subject: [PATCH 219/608] branch: support sha256 OIDs for branch refs --- src/libgit2/branch.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/libgit2/branch.c b/src/libgit2/branch.c index 4cbd1e26f7a..9a31c9c6ffc 100644 --- a/src/libgit2/branch.c +++ b/src/libgit2/branch.c @@ -134,9 +134,9 @@ int git_branch_create( const git_commit *commit, int force) { - char commit_id[GIT_OID_SHA1_HEXSIZE + 1]; + char commit_id[GIT_OID_MAX_HEXSIZE + 1]; - git_oid_tostr(commit_id, GIT_OID_SHA1_HEXSIZE + 1, git_commit_id(commit)); + git_oid_tostr(commit_id, GIT_OID_MAX_HEXSIZE + 1, git_commit_id(commit)); return create_branch(ref_out, repository, branch_name, commit, commit_id, force); } From cf6faa882e14fffcf988103659b4086d62f7d3dd Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 6 Apr 2023 10:23:38 +0100 Subject: [PATCH 220/608] revert: support SHA256 oids --- src/libgit2/revert.c | 19 ++++++++----------- 1 file changed, 8 insertions(+), 11 deletions(-) diff --git a/src/libgit2/revert.c b/src/libgit2/revert.c index 1106dfe2f2c..4a31ad40a1a 100644 --- a/src/libgit2/revert.c +++ b/src/libgit2/revert.c @@ -107,12 +107,10 @@ static int revert_state_cleanup(git_repository *repo) static int revert_seterr(git_commit *commit, const char *fmt) { - char commit_oidstr[GIT_OID_SHA1_HEXSIZE + 1]; + char commit_id[GIT_OID_MAX_HEXSIZE + 1]; - git_oid_fmt(commit_oidstr, git_commit_id(commit)); - commit_oidstr[GIT_OID_SHA1_HEXSIZE] = '\0'; - - git_error_set(GIT_ERROR_REVERT, fmt, commit_oidstr); + git_oid_tostr(commit_id, GIT_OID_MAX_HEXSIZE + 1, git_commit_id(commit)); + git_error_set(GIT_ERROR_REVERT, fmt, commit_id); return -1; } @@ -176,7 +174,7 @@ int git_revert( git_revert_options opts; git_reference *our_ref = NULL; git_commit *our_commit = NULL; - char commit_oidstr[GIT_OID_SHA1_HEXSIZE + 1]; + char commit_id[GIT_OID_MAX_HEXSIZE + 1]; const char *commit_msg; git_str their_label = GIT_STR_INIT; git_index *index = NULL; @@ -191,19 +189,18 @@ int git_revert( if ((error = git_repository__ensure_not_bare(repo, "revert")) < 0) return error; - git_oid_fmt(commit_oidstr, git_commit_id(commit)); - commit_oidstr[GIT_OID_SHA1_HEXSIZE] = '\0'; + git_oid_tostr(commit_id, GIT_OID_MAX_HEXSIZE + 1, git_commit_id(commit)); if ((commit_msg = git_commit_summary(commit)) == NULL) { error = -1; goto on_error; } - if ((error = git_str_printf(&their_label, "parent of %.7s... %s", commit_oidstr, commit_msg)) < 0 || + if ((error = git_str_printf(&their_label, "parent of %.7s... %s", commit_id, commit_msg)) < 0 || (error = revert_normalize_opts(repo, &opts, given_opts, git_str_cstr(&their_label))) < 0 || (error = git_indexwriter_init_for_operation(&indexwriter, repo, &opts.checkout_opts.checkout_strategy)) < 0 || - (error = write_revert_head(repo, commit_oidstr)) < 0 || - (error = write_merge_msg(repo, commit_oidstr, commit_msg)) < 0 || + (error = write_revert_head(repo, commit_id)) < 0 || + (error = write_merge_msg(repo, commit_id, commit_msg)) < 0 || (error = git_repository_head(&our_ref, repo)) < 0 || (error = git_reference_peel((git_object **)&our_commit, our_ref, GIT_OBJECT_COMMIT)) < 0 || (error = git_revert_commit(&index, repo, commit, our_commit, opts.mainline, &opts.merge_opts)) < 0 || From bd2c3786d719d39403f7de0634c06e5cf155604e Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 6 Apr 2023 10:23:44 +0100 Subject: [PATCH 221/608] rebase: support SHA256 oids --- src/libgit2/rebase.c | 156 ++++++++++++++++++++----------------------- 1 file changed, 72 insertions(+), 84 deletions(-) diff --git a/src/libgit2/rebase.c b/src/libgit2/rebase.c index 1970d5ddc60..77e442e981d 100644 --- a/src/libgit2/rebase.c +++ b/src/libgit2/rebase.c @@ -65,6 +65,9 @@ struct git_rebase { git_rebase_t type; char *state_path; + /* Temporary buffer for paths within the state path. */ + git_str state_filename; + unsigned int head_detached:1, inmemory:1, quiet:1, @@ -134,33 +137,42 @@ static int rebase_state_type( GIT_INLINE(int) rebase_readfile( git_str *out, - git_str *state_path, + git_rebase *rebase, const char *filename) { - size_t state_path_len = state_path->size; + /* + * `rebase->state_filename` is a temporary buffer to avoid + * unnecessary allocations and copies of `rebase->state_path`. + * At the start and end of this function it always contains the + * contents of `rebase->state_path` itself. + */ + size_t state_path_len = rebase->state_filename.size; int error; git_str_clear(out); - if ((error = git_str_joinpath(state_path, state_path->ptr, filename)) < 0 || - (error = git_futils_readbuffer(out, state_path->ptr)) < 0) + if ((error = git_str_joinpath(&rebase->state_filename, rebase->state_filename.ptr, filename)) < 0 || + (error = git_futils_readbuffer(out, rebase->state_filename.ptr)) < 0) goto done; git_str_rtrim(out); done: - git_str_truncate(state_path, state_path_len); + git_str_truncate(&rebase->state_filename, state_path_len); return error; } GIT_INLINE(int) rebase_readint( - size_t *out, git_str *asc_out, git_str *state_path, const char *filename) + size_t *out, + git_str *asc_out, + git_rebase *rebase, + const char *filename) { int32_t num; const char *eol; int error = 0; - if ((error = rebase_readfile(asc_out, state_path, filename)) < 0) + if ((error = rebase_readfile(asc_out, rebase, filename)) < 0) return error; if (git__strntol32(&num, asc_out->ptr, asc_out->size, &eol, 10) < 0 || num < 0 || *eol) { @@ -174,15 +186,18 @@ GIT_INLINE(int) rebase_readint( } GIT_INLINE(int) rebase_readoid( - git_oid *out, git_str *str_out, git_str *state_path, const char *filename) + git_oid *out, + git_str *str_out, + git_rebase *rebase, + const char *filename) { int error; - if ((error = rebase_readfile(str_out, state_path, filename)) < 0) + if ((error = rebase_readfile(str_out, rebase, filename)) < 0) return error; - if (str_out->size != GIT_OID_SHA1_HEXSIZE || - git_oid__fromstr(out, str_out->ptr, GIT_OID_SHA1) < 0) { + if (str_out->size != git_oid_hexsize(rebase->repo->oid_type) || + git_oid__fromstr(out, str_out->ptr, rebase->repo->oid_type) < 0) { git_error_set(GIT_ERROR_REBASE, "the file '%s' contains an invalid object ID", filename); return -1; } @@ -213,17 +228,14 @@ static git_rebase_operation *rebase_operation_alloc( static int rebase_open_merge(git_rebase *rebase) { - git_str state_path = GIT_STR_INIT, buf = GIT_STR_INIT, cmt = GIT_STR_INIT; + git_str buf = GIT_STR_INIT, cmt = GIT_STR_INIT; git_oid id; git_rebase_operation *operation; size_t i, msgnum = 0, end; int error; - if ((error = git_str_puts(&state_path, rebase->state_path)) < 0) - goto done; - /* Read 'msgnum' if it exists (otherwise, let msgnum = 0) */ - if ((error = rebase_readint(&msgnum, &buf, &state_path, MSGNUM_FILE)) < 0 && + if ((error = rebase_readint(&msgnum, &buf, rebase, MSGNUM_FILE)) < 0 && error != GIT_ENOTFOUND) goto done; @@ -233,11 +245,11 @@ static int rebase_open_merge(git_rebase *rebase) } /* Read 'end' */ - if ((error = rebase_readint(&end, &buf, &state_path, END_FILE)) < 0) + if ((error = rebase_readint(&end, &buf, rebase, END_FILE)) < 0) goto done; /* Read 'current' if it exists */ - if ((error = rebase_readoid(&id, &buf, &state_path, CURRENT_FILE)) < 0 && + if ((error = rebase_readoid(&id, &buf, rebase, CURRENT_FILE)) < 0 && error != GIT_ENOTFOUND) goto done; @@ -249,7 +261,7 @@ static int rebase_open_merge(git_rebase *rebase) git_str_clear(&cmt); if ((error = git_str_printf(&cmt, "cmt.%" PRIuZ, (i+1))) < 0 || - (error = rebase_readoid(&id, &buf, &state_path, cmt.ptr)) < 0) + (error = rebase_readoid(&id, &buf, rebase, cmt.ptr)) < 0) goto done; operation = rebase_operation_alloc(rebase, GIT_REBASE_OPERATION_PICK, &id, NULL); @@ -257,14 +269,13 @@ static int rebase_open_merge(git_rebase *rebase) } /* Read 'onto_name' */ - if ((error = rebase_readfile(&buf, &state_path, ONTO_NAME_FILE)) < 0) + if ((error = rebase_readfile(&buf, rebase, ONTO_NAME_FILE)) < 0) goto done; rebase->onto_name = git_str_detach(&buf); done: git_str_dispose(&cmt); - git_str_dispose(&state_path); git_str_dispose(&buf); return error; @@ -308,9 +319,9 @@ int git_rebase_open( const git_rebase_options *given_opts) { git_rebase *rebase; - git_str path = GIT_STR_INIT, orig_head_name = GIT_STR_INIT, - orig_head_id = GIT_STR_INIT, onto_id = GIT_STR_INIT; - size_t state_path_len; + git_str orig_head_name = GIT_STR_INIT, + orig_head_id = GIT_STR_INIT, + onto_id = GIT_STR_INIT; int error; GIT_ASSERT_ARG(repo); @@ -332,13 +343,10 @@ int git_rebase_open( goto done; } - if ((error = git_str_puts(&path, rebase->state_path)) < 0) + if ((error = git_str_puts(&rebase->state_filename, rebase->state_path)) < 0) goto done; - state_path_len = git_str_len(&path); - - if ((error = git_str_joinpath(&path, path.ptr, HEAD_NAME_FILE)) < 0 || - (error = git_futils_readbuffer(&orig_head_name, path.ptr)) < 0) + if ((error = rebase_readfile(&orig_head_name, rebase, HEAD_NAME_FILE)) < 0) goto done; git_str_rtrim(&orig_head_name); @@ -346,36 +354,16 @@ int git_rebase_open( if (strcmp(ORIG_DETACHED_HEAD, orig_head_name.ptr) == 0) rebase->head_detached = 1; - git_str_truncate(&path, state_path_len); - - if ((error = git_str_joinpath(&path, path.ptr, ORIG_HEAD_FILE)) < 0) - goto done; - - if (!git_fs_path_isfile(path.ptr)) { + if ((error = rebase_readoid(&rebase->orig_head_id, &orig_head_id, rebase, ORIG_HEAD_FILE)) < 0) { /* Previous versions of git.git used 'head' here; support that. */ - git_str_truncate(&path, state_path_len); + if (error == GIT_ENOTFOUND) + error = rebase_readoid(&rebase->orig_head_id, &orig_head_id, rebase, HEAD_FILE); - if ((error = git_str_joinpath(&path, path.ptr, HEAD_FILE)) < 0) + if (error < 0) goto done; } - if ((error = git_futils_readbuffer(&orig_head_id, path.ptr)) < 0) - goto done; - - git_str_rtrim(&orig_head_id); - - if ((error = git_oid__fromstr(&rebase->orig_head_id, orig_head_id.ptr, GIT_OID_SHA1)) < 0) - goto done; - - git_str_truncate(&path, state_path_len); - - if ((error = git_str_joinpath(&path, path.ptr, ONTO_FILE)) < 0 || - (error = git_futils_readbuffer(&onto_id, path.ptr)) < 0) - goto done; - - git_str_rtrim(&onto_id); - - if ((error = git_oid__fromstr(&rebase->onto_id, onto_id.ptr, GIT_OID_SHA1)) < 0) + if ((error = rebase_readoid(&rebase->onto_id, &onto_id, rebase, ONTO_FILE)) < 0) goto done; if (!rebase->head_detached) @@ -403,7 +391,6 @@ int git_rebase_open( else git_rebase_free(rebase); - git_str_dispose(&path); git_str_dispose(&orig_head_name); git_str_dispose(&orig_head_id); git_str_dispose(&onto_id); @@ -453,13 +440,13 @@ static const char *rebase_onto_name(const git_annotated_commit *onto) static int rebase_setupfiles_merge(git_rebase *rebase) { git_str commit_filename = GIT_STR_INIT; - char id_str[GIT_OID_SHA1_HEXSIZE]; + char id_str[GIT_OID_MAX_HEXSIZE + 1]; git_rebase_operation *operation; size_t i; int error = 0; if ((error = rebase_setupfile(rebase, END_FILE, 0, "%" PRIuZ "\n", git_array_size(rebase->operations))) < 0 || - (error = rebase_setupfile(rebase, ONTO_NAME_FILE, 0, "%s\n", rebase->onto_name)) < 0) + (error = rebase_setupfile(rebase, ONTO_NAME_FILE, 0, "%s\n", rebase->onto_name)) < 0) goto done; for (i = 0; i < git_array_size(rebase->operations); i++) { @@ -468,10 +455,9 @@ static int rebase_setupfiles_merge(git_rebase *rebase) git_str_clear(&commit_filename); git_str_printf(&commit_filename, CMT_FILE_FMT, i+1); - git_oid_fmt(id_str, &operation->id); + git_oid_tostr(id_str, GIT_OID_MAX_HEXSIZE + 1, &operation->id); - if ((error = rebase_setupfile(rebase, commit_filename.ptr, 0, - "%.*s\n", GIT_OID_SHA1_HEXSIZE, id_str)) < 0) + if ((error = rebase_setupfile(rebase, commit_filename.ptr, 0, "%s\n", id_str)) < 0) goto done; } @@ -482,11 +468,11 @@ static int rebase_setupfiles_merge(git_rebase *rebase) static int rebase_setupfiles(git_rebase *rebase) { - char onto[GIT_OID_SHA1_HEXSIZE], orig_head[GIT_OID_SHA1_HEXSIZE]; + char onto[GIT_OID_MAX_HEXSIZE + 1], orig_head[GIT_OID_MAX_HEXSIZE + 1]; const char *orig_head_name; - git_oid_fmt(onto, &rebase->onto_id); - git_oid_fmt(orig_head, &rebase->orig_head_id); + git_oid_tostr(onto, GIT_OID_MAX_HEXSIZE + 1, &rebase->onto_id); + git_oid_tostr(orig_head, GIT_OID_MAX_HEXSIZE + 1, &rebase->orig_head_id); if (p_mkdir(rebase->state_path, REBASE_DIR_MODE) < 0) { git_error_set(GIT_ERROR_OS, "failed to create rebase directory '%s'", rebase->state_path); @@ -498,8 +484,8 @@ static int rebase_setupfiles(git_rebase *rebase) if (git_repository__set_orig_head(rebase->repo, &rebase->orig_head_id) < 0 || rebase_setupfile(rebase, HEAD_NAME_FILE, 0, "%s\n", orig_head_name) < 0 || - rebase_setupfile(rebase, ONTO_FILE, 0, "%.*s\n", GIT_OID_SHA1_HEXSIZE, onto) < 0 || - rebase_setupfile(rebase, ORIG_HEAD_FILE, 0, "%.*s\n", GIT_OID_SHA1_HEXSIZE, orig_head) < 0 || + rebase_setupfile(rebase, ONTO_FILE, 0, "%s\n", onto) < 0 || + rebase_setupfile(rebase, ORIG_HEAD_FILE, 0, "%s\n", orig_head) < 0 || rebase_setupfile(rebase, QUIET_FILE, 0, rebase->quiet ? "t\n" : "\n") < 0) return -1; @@ -644,7 +630,8 @@ static int rebase_init_merge( GIT_UNUSED(upstream); - if ((error = git_str_joinpath(&state_path, repo->gitdir, REBASE_MERGE_DIR)) < 0) + if ((error = git_str_joinpath(&state_path, repo->gitdir, REBASE_MERGE_DIR)) < 0 || + (error = git_str_put(&rebase->state_filename, state_path.ptr, state_path.size)) < 0) goto done; rebase->state_path = git_str_detach(&state_path); @@ -814,7 +801,7 @@ static int rebase_next_merge( git_indexwriter indexwriter = GIT_INDEXWRITER_INIT; git_rebase_operation *operation; git_checkout_options checkout_opts; - char current_idstr[GIT_OID_SHA1_HEXSIZE]; + char current_idstr[GIT_OID_MAX_HEXSIZE + 1]; unsigned int parent_count; int error; @@ -837,13 +824,13 @@ static int rebase_next_merge( goto done; } - git_oid_fmt(current_idstr, &operation->id); + git_oid_tostr(current_idstr, GIT_OID_MAX_HEXSIZE + 1, &operation->id); normalize_checkout_options_for_apply(&checkout_opts, rebase, current_commit); if ((error = git_indexwriter_init_for_operation(&indexwriter, rebase->repo, &checkout_opts.checkout_strategy)) < 0 || (error = rebase_setupfile(rebase, MSGNUM_FILE, 0, "%" PRIuZ "\n", rebase->current+1)) < 0 || - (error = rebase_setupfile(rebase, CURRENT_FILE, 0, "%.*s\n", GIT_OID_SHA1_HEXSIZE, current_idstr)) < 0 || + (error = rebase_setupfile(rebase, CURRENT_FILE, 0, "%s\n", current_idstr)) < 0 || (error = git_merge_trees(&index, rebase->repo, parent_tree, head_tree, current_tree, &rebase->options.merge_options)) < 0 || (error = git_merge__check_result(rebase->repo, index)) < 0 || (error = git_checkout_index(rebase->repo, index, &checkout_opts)) < 0 || @@ -1103,7 +1090,7 @@ static int rebase_commit_merge( git_reference *head = NULL; git_commit *head_commit = NULL, *commit = NULL; git_index *index = NULL; - char old_idstr[GIT_OID_SHA1_HEXSIZE], new_idstr[GIT_OID_SHA1_HEXSIZE]; + char old_idstr[GIT_OID_MAX_HEXSIZE + 1], new_idstr[GIT_OID_MAX_HEXSIZE + 1]; int error; operation = git_array_get(rebase->operations, rebase->current); @@ -1119,11 +1106,11 @@ static int rebase_commit_merge( rebase->repo, NULL, "HEAD", git_commit_id(commit), "rebase")) < 0) goto done; - git_oid_fmt(old_idstr, &operation->id); - git_oid_fmt(new_idstr, git_commit_id(commit)); + git_oid_tostr(old_idstr, GIT_OID_MAX_HEXSIZE + 1, &operation->id); + git_oid_tostr(new_idstr, GIT_OID_MAX_HEXSIZE + 1, git_commit_id(commit)); if ((error = rebase_setupfile(rebase, REWRITTEN_FILE, O_CREAT|O_WRONLY|O_APPEND, - "%.*s %.*s\n", GIT_OID_SHA1_HEXSIZE, old_idstr, GIT_OID_SHA1_HEXSIZE, new_idstr)) < 0) + "%s %s\n", old_idstr, new_idstr)) < 0) goto done; git_oid_cpy(commit_id, git_commit_id(commit)); @@ -1306,7 +1293,9 @@ static int rebase_copy_notes( git_rebase *rebase, const git_signature *committer) { - git_str path = GIT_STR_INIT, rewritten = GIT_STR_INIT, notes_ref = GIT_STR_INIT; + git_str path = GIT_STR_INIT, + rewritten = GIT_STR_INIT, + notes_ref = GIT_STR_INIT; char *pair_list, *fromstr, *tostr, *end; git_oid from, to; unsigned int linenum = 1; @@ -1342,10 +1331,10 @@ static int rebase_copy_notes( tostr = end+1; *end = '\0'; - if (strlen(fromstr) != GIT_OID_SHA1_HEXSIZE || - strlen(tostr) != GIT_OID_SHA1_HEXSIZE || - git_oid__fromstr(&from, fromstr, GIT_OID_SHA1) < 0 || - git_oid__fromstr(&to, tostr, GIT_OID_SHA1) < 0) + if (strlen(fromstr) != git_oid_hexsize(rebase->repo->oid_type) || + strlen(tostr) != git_oid_hexsize(rebase->repo->oid_type) || + git_oid__fromstr(&from, fromstr, rebase->repo->oid_type) < 0 || + git_oid__fromstr(&to, tostr, rebase->repo->oid_type) < 0) goto on_error; if ((error = rebase_copy_note(rebase, notes_ref.ptr, &from, &to, committer)) < 0) @@ -1373,17 +1362,15 @@ static int return_to_orig_head(git_rebase *rebase) git_reference *terminal_ref = NULL, *branch_ref = NULL, *head_ref = NULL; git_commit *terminal_commit = NULL; git_str branch_msg = GIT_STR_INIT, head_msg = GIT_STR_INIT; - char onto[GIT_OID_SHA1_HEXSIZE]; + char onto[GIT_OID_MAX_HEXSIZE + 1]; int error = 0; - git_oid_fmt(onto, &rebase->onto_id); + git_oid_tostr(onto, GIT_OID_MAX_HEXSIZE + 1, &rebase->onto_id); if ((error = git_str_printf(&branch_msg, - "rebase finished: %s onto %.*s", - rebase->orig_head_name, GIT_OID_SHA1_HEXSIZE, onto)) == 0 && + "rebase finished: %s onto %s", rebase->orig_head_name, onto)) == 0 && (error = git_str_printf(&head_msg, - "rebase finished: returning to %s", - rebase->orig_head_name)) == 0 && + "rebase finished: returning to %s", rebase->orig_head_name)) == 0 && (error = git_repository_head(&terminal_ref, rebase->repo)) == 0 && (error = git_reference_peel((git_object **)&terminal_commit, terminal_ref, GIT_OBJECT_COMMIT)) == 0 && @@ -1475,6 +1462,7 @@ void git_rebase_free(git_rebase *rebase) git__free(rebase->onto_name); git__free(rebase->orig_head_name); git__free(rebase->state_path); + git_str_dispose(&rebase->state_filename); git_array_clear(rebase->operations); git__free((char *)rebase->options.rewrite_notes_ref); git__free(rebase); From 6238d81c1bc13e6f3985226b0a4f7bc0b4a1a117 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 6 Apr 2023 10:24:44 +0100 Subject: [PATCH 222/608] notes: support SHA256 --- src/libgit2/notes.c | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-) diff --git a/src/libgit2/notes.c b/src/libgit2/notes.c index 1b1935330e9..13ca3824bf1 100644 --- a/src/libgit2/notes.c +++ b/src/libgit2/notes.c @@ -460,7 +460,7 @@ int git_note_commit_read( { int error; git_tree *tree = NULL; - char target[GIT_OID_SHA1_HEXSIZE + 1]; + char target[GIT_OID_MAX_HEXSIZE + 1]; git_oid_tostr(target, sizeof(target), oid); @@ -507,7 +507,7 @@ int git_note_commit_create( { int error; git_tree *tree = NULL; - char target[GIT_OID_SHA1_HEXSIZE + 1]; + char target[GIT_OID_MAX_HEXSIZE + 1]; git_oid_tostr(target, sizeof(target), oid); @@ -578,7 +578,7 @@ int git_note_commit_remove( { int error; git_tree *tree = NULL; - char target[GIT_OID_SHA1_HEXSIZE + 1]; + char target[GIT_OID_MAX_HEXSIZE + 1]; git_oid_tostr(target, sizeof(target), oid); @@ -665,8 +665,9 @@ void git_note_free(git_note *note) } static int process_entry_path( - const char *entry_path, - git_oid *annotated_object_id) + git_oid *annotated_object_id, + git_note_iterator *it, + const char *entry_path) { int error = 0; size_t i = 0, j = 0, len; @@ -698,12 +699,12 @@ static int process_entry_path( buf.ptr[j] = '\0'; buf.size = j; - if (j != GIT_OID_SHA1_HEXSIZE) { + if (j != git_oid_hexsize(it->repo->oid_type)) { /* This is not a note entry */ goto cleanup; } - error = git_oid__fromstr(annotated_object_id, buf.ptr, GIT_OID_SHA1); + error = git_oid__fromstr(annotated_object_id, buf.ptr, it->repo->oid_type); cleanup: git_str_dispose(&buf); @@ -799,7 +800,7 @@ int git_note_next( git_oid_cpy(note_id, &item->id); - if ((error = process_entry_path(item->path, annotated_id)) < 0) + if ((error = process_entry_path(annotated_id, it, item->path)) < 0) return error; if ((error = git_iterator_advance(NULL, it)) < 0 && error != GIT_ITEROVER) From 5fa2e4cb3a6b973b475de8506d806550d77be579 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 6 Apr 2023 10:24:56 +0100 Subject: [PATCH 223/608] reset: support SHA256 --- src/libgit2/reset.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/libgit2/reset.c b/src/libgit2/reset.c index 9574819cb16..605c4afd5e2 100644 --- a/src/libgit2/reset.c +++ b/src/libgit2/reset.c @@ -188,9 +188,9 @@ int git_reset( git_reset_t reset_type, const git_checkout_options *checkout_opts) { - char to[GIT_OID_SHA1_HEXSIZE + 1]; + char to[GIT_OID_MAX_HEXSIZE + 1]; - git_oid_tostr(to, GIT_OID_SHA1_HEXSIZE + 1, git_object_id(target)); + git_oid_tostr(to, GIT_OID_MAX_HEXSIZE + 1, git_object_id(target)); return reset(repo, target, to, reset_type, checkout_opts); } From 7f70484799df14dbc666b3c395ded690d1a5a402 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 6 Apr 2023 10:26:06 +0100 Subject: [PATCH 224/608] apply: support SHA256 --- src/libgit2/reader.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/libgit2/reader.c b/src/libgit2/reader.c index be29bb41c11..df2b2807f55 100644 --- a/src/libgit2/reader.c +++ b/src/libgit2/reader.c @@ -125,7 +125,7 @@ static int workdir_reader_read( goto done; if (out_id || reader->index) { - if ((error = git_odb__hash(&id, out->ptr, out->size, GIT_OBJECT_BLOB, GIT_OID_SHA1)) < 0) + if ((error = git_odb__hash(&id, out->ptr, out->size, GIT_OBJECT_BLOB, reader->repo->oid_type)) < 0) goto done; } From db2a794dda2b6f92291b3758507f863f39314c72 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 7 Apr 2023 15:28:58 +0100 Subject: [PATCH 225/608] diff: parse patches with sha256 --- examples/diff.c | 8 +++++ include/git2/diff.h | 44 ++++++++++++++++++++++-- src/libgit2/diff.c | 23 +++++++++---- src/libgit2/diff.h | 12 +++---- src/libgit2/diff_file.c | 12 +++---- src/libgit2/diff_generate.c | 51 +++++++++++++++++++--------- src/libgit2/diff_parse.c | 24 ++++++++++--- src/libgit2/diff_print.c | 33 ++++++++++++++---- src/libgit2/diff_tform.c | 8 ++--- src/libgit2/patch.h | 8 ++++- src/libgit2/patch_generate.c | 29 +++++++++++++--- src/libgit2/patch_parse.c | 24 ++++++++----- tests/libgit2/apply/apply_helpers.h | 1 + tests/libgit2/apply/both.c | 52 ++++++++++++++--------------- tests/libgit2/apply/callbacks.c | 6 ++-- tests/libgit2/apply/check.c | 6 ++-- tests/libgit2/apply/index.c | 16 ++++----- tests/libgit2/apply/tree.c | 2 +- tests/libgit2/apply/workdir.c | 20 +++++------ tests/libgit2/diff/diff_helpers.c | 17 ++++++++++ tests/libgit2/diff/diff_helpers.h | 4 +++ tests/libgit2/diff/parse.c | 40 +++++++++++----------- tests/libgit2/diff/patchid.c | 3 +- tests/libgit2/diff/stats.c | 3 +- 24 files changed, 307 insertions(+), 139 deletions(-) diff --git a/examples/diff.c b/examples/diff.c index a9fb5d4428a..80c5200e908 100644 --- a/examples/diff.c +++ b/examples/diff.c @@ -188,9 +188,17 @@ static void compute_diff_no_index(git_diff **diff, struct diff_options *o) { check_lg2( git_patch_to_buf(&buf, patch), "patch to buf", NULL); + +#ifdef GIT_EXPERIMENTAL_SHA256 + check_lg2( + git_diff_from_buffer(diff, buf.ptr, buf.size, NULL), + "diff from patch", NULL); +#else check_lg2( git_diff_from_buffer(diff, buf.ptr, buf.size), "diff from patch", NULL); +#endif + git_patch_free(patch); git_buf_dispose(&buf); free(file1_str); diff --git a/include/git2/diff.h b/include/git2/diff.h index 850d215a613..384b6e74570 100644 --- a/include/git2/diff.h +++ b/include/git2/diff.h @@ -421,6 +421,22 @@ typedef struct { */ uint32_t interhunk_lines; + /** + * The object ID type to emit in diffs; this is used by functions + * that operate without a repository - namely `git_diff_buffers`, + * or `git_diff_blobs` and `git_diff_blob_to_buffer` when one blob + * is `NULL`. + * + * This may be omitted (set to `0`). If a repository is available, + * the object ID format of the repository will be used. If no + * repository is available then the default is `GIT_OID_SHA`. + * + * If this is specified and a repository is available, then the + * specified `oid_type` must match the repository's object ID + * format. + */ + git_oid_t oid_type; + /** * The abbreviation length to use when formatting object ids. * Defaults to the value of 'core.abbrev' from the config, or 7 if unset. @@ -1153,9 +1169,8 @@ GIT_EXTERN(int) git_diff_to_buf( /**@}*/ - /* - * Misc + * Low-level file comparison, invoking callbacks per difference. */ /** @@ -1271,6 +1286,25 @@ GIT_EXTERN(int) git_diff_buffers( git_diff_line_cb line_cb, void *payload); +/* Patch file parsing. */ + +/** + * Options for parsing a diff / patch file. + */ +typedef struct { + unsigned int version; + git_oid_t oid_type; +} git_diff_parse_options; + +/* The current version of the diff parse options structure */ +#define GIT_DIFF_PARSE_OPTIONS_VERSION 1 + +/* Stack initializer for diff parse options. Alternatively use + * `git_diff_parse_options_init` programmatic initialization. + */ +#define GIT_DIFF_PARSE_OPTIONS_INIT \ + { GIT_DIFF_PARSE_OPTIONS_VERSION, GIT_OID_DEFAULT } + /** * Read the contents of a git patch file into a `git_diff` object. * @@ -1293,7 +1327,11 @@ GIT_EXTERN(int) git_diff_buffers( GIT_EXTERN(int) git_diff_from_buffer( git_diff **out, const char *content, - size_t content_len); + size_t content_len +#ifdef GIT_EXPERIMENTAL_SHA256 + , git_diff_parse_options *opts +#endif + ); /** * This is an opaque structure which is allocated by `git_diff_get_stats`. diff --git a/src/libgit2/diff.c b/src/libgit2/diff.c index 20a18c4b9b0..db12ccd6809 100644 --- a/src/libgit2/diff.c +++ b/src/libgit2/diff.c @@ -19,8 +19,10 @@ #include "git2/email.h" struct patch_id_args { + git_diff *diff; git_hash_ctx ctx; git_oid result; + git_oid_t oid_type; int first_file; }; @@ -280,17 +282,19 @@ int git_diff_find_options_init( return 0; } -static int flush_hunk(git_oid *result, git_hash_ctx *ctx) +static int flush_hunk(git_oid *result, struct patch_id_args *args) { + git_hash_ctx *ctx = &args->ctx; git_oid hash; unsigned short carry = 0; - int error, i; + size_t i; + int error; if ((error = git_hash_final(hash.id, ctx)) < 0 || (error = git_hash_init(ctx)) < 0) return error; - for (i = 0; i < GIT_OID_SHA1_SIZE; i++) { + for (i = 0; i < git_oid_size(args->oid_type); i++) { carry += result->id[i] + hash.id[i]; result->id[i] = (unsigned char)carry; carry >>= 8; @@ -338,7 +342,7 @@ static int diff_patchid_print_callback_to_buf( if (line->origin == GIT_DIFF_LINE_FILE_HDR && !args->first_file && - (error = flush_hunk(&args->result, &args->ctx) < 0)) + (error = flush_hunk(&args->result, args) < 0)) goto out; if ((error = git_hash_update(&args->ctx, buf.ptr, buf.size)) < 0) @@ -362,14 +366,19 @@ int git_diff_patchid_options_init(git_diff_patchid_options *opts, unsigned int v int git_diff_patchid(git_oid *out, git_diff *diff, git_diff_patchid_options *opts) { struct patch_id_args args; + git_hash_algorithm_t algorithm; int error; GIT_ERROR_CHECK_VERSION( opts, GIT_DIFF_PATCHID_OPTIONS_VERSION, "git_diff_patchid_options"); + algorithm = git_oid_algorithm(diff->opts.oid_type); + memset(&args, 0, sizeof(args)); + args.diff = diff; args.first_file = 1; - if ((error = git_hash_ctx_init(&args.ctx, GIT_HASH_ALGORITHM_SHA1)) < 0) + args.oid_type = diff->opts.oid_type; + if ((error = git_hash_ctx_init(&args.ctx, algorithm)) < 0) goto out; if ((error = git_diff_print(diff, @@ -378,11 +387,11 @@ int git_diff_patchid(git_oid *out, git_diff *diff, git_diff_patchid_options *opt &args)) < 0) goto out; - if ((error = (flush_hunk(&args.result, &args.ctx))) < 0) + if ((error = (flush_hunk(&args.result, &args))) < 0) goto out; #ifdef GIT_EXPERIMENTAL_SHA256 - args.result.type = GIT_OID_SHA1; + args.result.type = diff->opts.oid_type; #endif git_oid_cpy(out, &args.result); diff --git a/src/libgit2/diff.h b/src/libgit2/diff.h index 2cc35e65b7c..f21b2764505 100644 --- a/src/libgit2/diff.h +++ b/src/libgit2/diff.h @@ -30,15 +30,15 @@ typedef enum { } git_diff_origin_t; struct git_diff { - git_refcount rc; + git_refcount rc; git_repository *repo; - git_attr_session attrsession; + git_attr_session attrsession; git_diff_origin_t type; - git_diff_options opts; - git_vector deltas; /* vector of git_diff_delta */ + git_diff_options opts; + git_vector deltas; /* vector of git_diff_delta */ git_pool pool; - git_iterator_t old_src; - git_iterator_t new_src; + git_iterator_t old_src; + git_iterator_t new_src; git_diff_perfdata perf; int (*strcomp)(const char *, const char *); diff --git a/src/libgit2/diff_file.c b/src/libgit2/diff_file.c index c2d08675ab0..6b7f9590caa 100644 --- a/src/libgit2/diff_file.c +++ b/src/libgit2/diff_file.c @@ -144,7 +144,7 @@ int git_diff_file_content__init_from_src( if (!src->blob && !src->buf) { fc->flags |= GIT_DIFF_FLAG__NO_DATA; - git_oid_clear(&fc->file->id, GIT_OID_SHA1); + git_oid_clear(&fc->file->id, opts->oid_type); } else { fc->flags |= GIT_DIFF_FLAG__LOADED; fc->file->flags |= GIT_DIFF_FLAG_VALID_ID; @@ -154,7 +154,7 @@ int git_diff_file_content__init_from_src( git_blob_dup((git_blob **)&fc->blob, (git_blob *) src->blob); fc->file->size = git_blob_rawsize(src->blob); git_oid_cpy(&fc->file->id, git_blob_id(src->blob)); - fc->file->id_abbrev = GIT_OID_SHA1_HEXSIZE; + fc->file->id_abbrev = (uint16_t)git_oid_hexsize(repo->oid_type); fc->map.len = (size_t)fc->file->size; fc->map.data = (char *)git_blob_rawcontent(src->blob); @@ -162,10 +162,10 @@ int git_diff_file_content__init_from_src( fc->flags |= GIT_DIFF_FLAG__FREE_BLOB; } else { int error; - if ((error = git_odb__hash(&fc->file->id, src->buf, src->buflen, GIT_OBJECT_BLOB, GIT_OID_SHA1)) < 0) + if ((error = git_odb__hash(&fc->file->id, src->buf, src->buflen, GIT_OBJECT_BLOB, opts->oid_type)) < 0) return error; fc->file->size = src->buflen; - fc->file->id_abbrev = GIT_OID_SHA1_HEXSIZE; + fc->file->id_abbrev = (uint16_t)git_oid_hexsize(opts->oid_type); fc->map.len = src->buflen; fc->map.data = (char *)src->buf; @@ -178,7 +178,7 @@ int git_diff_file_content__init_from_src( static int diff_file_content_commit_to_str( git_diff_file_content *fc, bool check_status) { - char oid[GIT_OID_SHA1_HEXSIZE+1]; + char oid[GIT_OID_MAX_HEXSIZE+1]; git_str content = GIT_STR_INIT; const char *status = ""; @@ -420,7 +420,7 @@ static int diff_file_content_load_workdir( if (!error && (fc->file->flags & GIT_DIFF_FLAG_VALID_ID) == 0) { error = git_odb__hash( &fc->file->id, fc->map.data, fc->map.len, - GIT_OBJECT_BLOB, GIT_OID_SHA1); + GIT_OBJECT_BLOB, diff_opts->oid_type); fc->file->flags |= GIT_DIFF_FLAG_VALID_ID; } diff --git a/src/libgit2/diff_generate.c b/src/libgit2/diff_generate.c index a88ce8c3230..78fe510e748 100644 --- a/src/libgit2/diff_generate.c +++ b/src/libgit2/diff_generate.c @@ -61,8 +61,8 @@ static git_diff_delta *diff_delta__alloc( } delta->status = status; - git_oid_clear(&delta->old_file.id, GIT_OID_SHA1); - git_oid_clear(&delta->new_file.id, GIT_OID_SHA1); + git_oid_clear(&delta->old_file.id, diff->base.opts.oid_type); + git_oid_clear(&delta->new_file.id, diff->base.opts.oid_type); return delta; } @@ -149,10 +149,13 @@ static int diff_delta__from_one( const git_index_entry *entry = nitem; bool has_old = false; git_diff_delta *delta; + git_oid_t oid_type; const char *matched_pathspec; GIT_ASSERT_ARG((oitem != NULL) ^ (nitem != NULL)); + oid_type = diff->base.opts.oid_type; + if (oitem) { entry = oitem; has_old = true; @@ -186,20 +189,23 @@ static int diff_delta__from_one( GIT_ASSERT(status != GIT_DELTA_MODIFIED); delta->nfiles = 1; + git_oid_clear(&delta->old_file.id, diff->base.opts.oid_type); + git_oid_clear(&delta->new_file.id, diff->base.opts.oid_type); + if (has_old) { delta->old_file.mode = entry->mode; delta->old_file.size = entry->file_size; delta->old_file.flags |= GIT_DIFF_FLAG_EXISTS; git_oid_cpy(&delta->old_file.id, &entry->id); - git_oid_clear(&delta->new_file.id, GIT_OID_SHA1); - delta->old_file.id_abbrev = GIT_OID_SHA1_HEXSIZE; + git_oid_clear(&delta->new_file.id, oid_type); + delta->old_file.id_abbrev = (uint16_t)git_oid_hexsize(oid_type); } else /* ADDED, IGNORED, UNTRACKED */ { delta->new_file.mode = entry->mode; delta->new_file.size = entry->file_size; delta->new_file.flags |= GIT_DIFF_FLAG_EXISTS; - git_oid_clear(&delta->old_file.id, GIT_OID_SHA1); + git_oid_clear(&delta->old_file.id, oid_type); git_oid_cpy(&delta->new_file.id, &entry->id); - delta->new_file.id_abbrev = GIT_OID_SHA1_HEXSIZE; + delta->new_file.id_abbrev = (uint16_t)git_oid_hexsize(oid_type); } delta->old_file.flags |= GIT_DIFF_FLAG_VALID_ID; @@ -225,6 +231,9 @@ static int diff_delta__from_two( const git_oid *old_id = &old_entry->id; git_diff_delta *delta; const char *canonical_path = old_entry->path; + git_oid_t oid_type; + + oid_type = diff->base.opts.oid_type; if (status == GIT_DELTA_UNMODIFIED && DIFF_FLAG_ISNT_SET(diff, GIT_DIFF_INCLUDE_UNMODIFIED)) @@ -254,14 +263,14 @@ static int diff_delta__from_two( delta->old_file.size = old_entry->file_size; delta->old_file.mode = old_mode; git_oid_cpy(&delta->old_file.id, old_id); - delta->old_file.id_abbrev = GIT_OID_SHA1_HEXSIZE; + delta->old_file.id_abbrev = (uint16_t)git_oid_hexsize(oid_type); delta->old_file.flags |= GIT_DIFF_FLAG_VALID_ID | GIT_DIFF_FLAG_EXISTS; } if (!git_index_entry_is_conflict(new_entry)) { git_oid_cpy(&delta->new_file.id, new_id); - delta->new_file.id_abbrev = GIT_OID_SHA1_HEXSIZE; + delta->new_file.id_abbrev = (uint16_t)git_oid_hexsize(oid_type); delta->new_file.size = new_entry->file_size; delta->new_file.mode = new_mode; delta->old_file.flags |= GIT_DIFF_FLAG_EXISTS; @@ -490,6 +499,14 @@ static int diff_generated_apply_options( return -1; } + if (!diff->base.opts.oid_type) { + diff->base.opts.oid_type = repo->oid_type; + } else if (diff->base.opts.oid_type != repo->oid_type) { + git_error_set(GIT_ERROR_INVALID, + "specified object ID type does not match repository object ID type"); + return -1; + } + /* flag INCLUDE_TYPECHANGE_TREES implies INCLUDE_TYPECHANGE */ if (DIFF_FLAG_IS_SET(diff, GIT_DIFF_INCLUDE_TYPECHANGE_TREES)) diff->base.opts.flags |= GIT_DIFF_INCLUDE_TYPECHANGE; @@ -603,7 +620,7 @@ int git_diff__oid_for_file( entry.mode = mode; entry.file_size = (uint32_t)size; entry.path = (char *)path; - git_oid_clear(&entry.id, GIT_OID_SHA1); + git_oid_clear(&entry.id, diff->opts.oid_type); return git_diff__oid_for_entry(out, diff, &entry, mode, NULL); } @@ -624,7 +641,7 @@ int git_diff__oid_for_entry( GIT_ASSERT(d->type == GIT_DIFF_TYPE_GENERATED); diff = (git_diff_generated *)d; - git_oid_clear(out, GIT_OID_SHA1); + git_oid_clear(out, diff->base.opts.oid_type); if (git_repository_workdir_path(&full_path, diff->base.repo, entry.path) < 0) return -1; @@ -660,7 +677,8 @@ int git_diff__oid_for_entry( git_error_clear(); } } else if (S_ISLNK(mode)) { - error = git_odb__hashlink(out, full_path.ptr, GIT_OID_SHA1); + error = git_odb__hashlink(out, full_path.ptr, + diff->base.opts.oid_type); diff->base.perf.oid_calculations++; } else if (!git__is_sizet(entry.file_size)) { git_error_set(GIT_ERROR_NOMEMORY, "file size overflow (for 32-bits) on '%s'", @@ -676,7 +694,8 @@ int git_diff__oid_for_entry( else { error = git_odb__hashfd_filtered( out, fd, (size_t)entry.file_size, - GIT_OBJECT_BLOB, GIT_OID_SHA1, fl); + GIT_OBJECT_BLOB, diff->base.opts.oid_type, + fl); p_close(fd); diff->base.perf.oid_calculations++; } @@ -785,7 +804,7 @@ static int maybe_modified( git_diff_generated *diff, diff_in_progress *info) { - git_oid noid = GIT_OID_SHA1_ZERO; + git_oid noid; git_delta_t status = GIT_DELTA_MODIFIED; const git_index_entry *oitem = info->oitem; const git_index_entry *nitem = info->nitem; @@ -796,6 +815,8 @@ static int maybe_modified( const char *matched_pathspec; int error = 0; + git_oid_clear(&noid, diff->base.opts.oid_type); + if (!diff_pathspec_match(&matched_pathspec, diff, oitem)) return 0; @@ -1700,11 +1721,11 @@ int git_diff__commit( *out = NULL; if ((parents = git_commit_parentcount(commit)) > 1) { - char commit_oidstr[GIT_OID_SHA1_HEXSIZE + 1]; + char commit_oidstr[GIT_OID_MAX_HEXSIZE + 1]; error = -1; git_error_set(GIT_ERROR_INVALID, "commit %s is a merge commit", - git_oid_tostr(commit_oidstr, GIT_OID_SHA1_HEXSIZE + 1, git_commit_id(commit))); + git_oid_tostr(commit_oidstr, GIT_OID_MAX_HEXSIZE + 1, git_commit_id(commit))); goto on_error; } diff --git a/src/libgit2/diff_parse.c b/src/libgit2/diff_parse.c index 75e41a5443b..04603969e40 100644 --- a/src/libgit2/diff_parse.c +++ b/src/libgit2/diff_parse.c @@ -29,7 +29,7 @@ static void diff_parsed_free(git_diff *d) git__free(diff); } -static git_diff_parsed *diff_parsed_alloc(void) +static git_diff_parsed *diff_parsed_alloc(git_oid_t oid_type) { git_diff_parsed *diff; @@ -51,6 +51,7 @@ static git_diff_parsed *diff_parsed_alloc(void) } diff->base.opts.flags &= ~GIT_DIFF_IGNORE_CASE; + diff->base.opts.oid_type = oid_type; if (git_pool_init(&diff->base.pool, 1) < 0 || git_vector_init(&diff->patches, 0, NULL) < 0 || @@ -67,19 +68,34 @@ static git_diff_parsed *diff_parsed_alloc(void) int git_diff_from_buffer( git_diff **out, const char *content, - size_t content_len) + size_t content_len +#ifdef GIT_EXPERIMENTAL_SHA256 + , git_diff_parse_options *opts +#endif + ) { git_diff_parsed *diff; git_patch *patch; git_patch_parse_ctx *ctx = NULL; + git_patch_options patch_opts = GIT_PATCH_OPTIONS_INIT; + git_oid_t oid_type; int error = 0; *out = NULL; - diff = diff_parsed_alloc(); +#ifdef GIT_EXPERIMENTAL_SHA256 + oid_type = (opts && opts->oid_type) ? opts->oid_type : + GIT_OID_DEFAULT; +#else + oid_type = GIT_OID_DEFAULT; +#endif + + patch_opts.oid_type = oid_type; + + diff = diff_parsed_alloc(oid_type); GIT_ERROR_CHECK_ALLOC(diff); - ctx = git_patch_parse_ctx_init(content, content_len, NULL); + ctx = git_patch_parse_ctx_init(content, content_len, &patch_opts); GIT_ERROR_CHECK_ALLOC(ctx); while (ctx->parse_ctx.remain_len) { diff --git a/src/libgit2/diff_print.c b/src/libgit2/diff_print.c index 3077e11e157..32c93682679 100644 --- a/src/libgit2/diff_print.c +++ b/src/libgit2/diff_print.c @@ -29,6 +29,7 @@ typedef struct { const char *new_prefix; uint32_t flags; int id_strlen; + git_oid_t oid_type; int (*strcomp)(const char *, const char *); } diff_print_info; @@ -46,6 +47,8 @@ static int diff_print_info_init__common( pi->payload = payload; pi->buf = out; + GIT_ASSERT(pi->oid_type); + if (!pi->id_strlen) { if (!repo) pi->id_strlen = GIT_ABBREV_DEFAULT; @@ -53,8 +56,9 @@ static int diff_print_info_init__common( return -1; } - if (pi->id_strlen > GIT_OID_SHA1_HEXSIZE) - pi->id_strlen = GIT_OID_SHA1_HEXSIZE; + if (pi->id_strlen > 0 && + (size_t)pi->id_strlen > git_oid_hexsize(pi->oid_type)) + pi->id_strlen = (int)git_oid_hexsize(pi->oid_type); memset(&pi->line, 0, sizeof(pi->line)); pi->line.old_lineno = -1; @@ -78,6 +82,7 @@ static int diff_print_info_init_fromdiff( if (diff) { pi->flags = diff->opts.flags; + pi->oid_type = diff->opts.oid_type; pi->id_strlen = diff->opts.id_abbrev; pi->old_prefix = diff->opts.old_prefix; pi->new_prefix = diff->opts.new_prefix; @@ -101,6 +106,7 @@ static int diff_print_info_init_frompatch( memset(pi, 0, sizeof(diff_print_info)); pi->flags = patch->diff_opts.flags; + pi->oid_type = patch->diff_opts.oid_type; pi->id_strlen = patch->diff_opts.id_abbrev; pi->old_prefix = patch->diff_opts.old_prefix; pi->new_prefix = patch->diff_opts.new_prefix; @@ -212,7 +218,10 @@ static int diff_print_one_raw( git_str *out = pi->buf; int id_abbrev; char code = git_diff_status_char(delta->status); - char start_oid[GIT_OID_SHA1_HEXSIZE+1], end_oid[GIT_OID_SHA1_HEXSIZE+1]; + char start_oid[GIT_OID_MAX_HEXSIZE + 1], + end_oid[GIT_OID_MAX_HEXSIZE + 1]; + size_t oid_hexsize; + bool id_is_abbrev; GIT_UNUSED(progress); @@ -231,12 +240,21 @@ static int diff_print_one_raw( return -1; } +#ifdef GIT_EXPERIMENTAL_SHA256 + GIT_ASSERT(delta->old_file.id.type == delta->new_file.id.type); + oid_hexsize = git_oid_hexsize(delta->old_file.id.type); +#else + oid_hexsize = GIT_OID_SHA1_HEXSIZE; +#endif + + id_is_abbrev = (pi->id_strlen > 0 && + (size_t)pi->id_strlen <= oid_hexsize); + git_oid_tostr(start_oid, pi->id_strlen + 1, &delta->old_file.id); git_oid_tostr(end_oid, pi->id_strlen + 1, &delta->new_file.id); - git_str_printf( - out, (pi->id_strlen <= GIT_OID_SHA1_HEXSIZE) ? - ":%06o %06o %s... %s... %c" : ":%06o %06o %s %s %c", + git_str_printf(out, + id_is_abbrev ? ":%06o %06o %s... %s... %c" : ":%06o %06o %s %s %c", delta->old_file.mode, delta->new_file.mode, start_oid, end_oid, code); if (delta->similarity > 0) @@ -273,7 +291,8 @@ static int diff_print_oid_range( git_str *out, const git_diff_delta *delta, int id_strlen, bool print_index) { - char start_oid[GIT_OID_SHA1_HEXSIZE+1], end_oid[GIT_OID_SHA1_HEXSIZE+1]; + char start_oid[GIT_OID_MAX_HEXSIZE + 1], + end_oid[GIT_OID_MAX_HEXSIZE + 1]; if (delta->old_file.mode && id_strlen > delta->old_file.id_abbrev) { diff --git a/src/libgit2/diff_tform.c b/src/libgit2/diff_tform.c index 8c0c1b7fc5e..4a156c7a341 100644 --- a/src/libgit2/diff_tform.c +++ b/src/libgit2/diff_tform.c @@ -364,7 +364,7 @@ static int insert_delete_side_of_split( memset(&deleted->new_file, 0, sizeof(deleted->new_file)); deleted->new_file.path = deleted->old_file.path; deleted->new_file.flags |= GIT_DIFF_FLAG_VALID_ID; - git_oid_clear(&deleted->new_file.id, GIT_OID_SHA1); + git_oid_clear(&deleted->new_file.id, diff->opts.oid_type); return git_vector_insert(onto, deleted); } @@ -398,7 +398,7 @@ static int apply_splits_and_deletes( memset(&delta->old_file, 0, sizeof(delta->old_file)); delta->old_file.path = delta->new_file.path; delta->old_file.flags |= GIT_DIFF_FLAG_VALID_ID; - git_oid_clear(&delta->old_file.id, GIT_OID_SHA1); + git_oid_clear(&delta->old_file.id, diff->opts.oid_type); } /* clean up delta before inserting into new list */ @@ -997,7 +997,7 @@ int git_diff_find_similar( memset(&src->new_file, 0, sizeof(src->new_file)); src->new_file.path = src->old_file.path; src->new_file.flags |= GIT_DIFF_FLAG_VALID_ID; - git_oid_clear(&src->new_file.id, GIT_OID_SHA1); + git_oid_clear(&src->new_file.id, diff->opts.oid_type); num_updates++; @@ -1023,7 +1023,7 @@ int git_diff_find_similar( memset(&src->old_file, 0, sizeof(src->old_file)); src->old_file.path = src->new_file.path; src->old_file.flags |= GIT_DIFF_FLAG_VALID_ID; - git_oid_clear(&src->old_file.id, GIT_OID_SHA1); + git_oid_clear(&src->old_file.id, diff->opts.oid_type); src->flags &= ~GIT_DIFF_FLAG__TO_SPLIT; num_rewrites--; diff --git a/src/libgit2/patch.h b/src/libgit2/patch.h index 1e1471ed613..86328e886e7 100644 --- a/src/libgit2/patch.h +++ b/src/libgit2/patch.h @@ -59,9 +59,15 @@ typedef struct { * This prefix will be removed when looking for files. The default is 1. */ uint32_t prefix_len; + + /** + * The type of object IDs in the patch file. The default is + * `GIT_OID_DEFAULT`. + */ + git_oid_t oid_type; } git_patch_options; -#define GIT_PATCH_OPTIONS_INIT { 1 } +#define GIT_PATCH_OPTIONS_INIT { 1, GIT_OID_DEFAULT } extern int git_patch__to_buf(git_str *out, git_patch *patch); extern void git_patch_free(git_patch *patch); diff --git a/src/libgit2/patch_generate.c b/src/libgit2/patch_generate.c index bc598fea870..079bc53ae9b 100644 --- a/src/libgit2/patch_generate.c +++ b/src/libgit2/patch_generate.c @@ -81,7 +81,8 @@ static void patch_generated_init_common(git_patch_generated *patch) static int patch_generated_normalize_options( git_diff_options *out, - const git_diff_options *opts) + const git_diff_options *opts, + git_repository *repo) { if (opts) { GIT_ERROR_CHECK_VERSION(opts, GIT_DIFF_OPTIONS_VERSION, "git_diff_options"); @@ -91,6 +92,23 @@ static int patch_generated_normalize_options( memcpy(out, &default_opts, sizeof(git_diff_options)); } + if (repo && opts && opts->oid_type && repo->oid_type != opts->oid_type) { + /* + * This limitation feels unnecessary - we should consider + * allowing users to generate diffs with a different object + * ID format than the repository. + */ + git_error_set(GIT_ERROR_INVALID, + "specified object ID type does not match repository object ID type"); + return -1; + } else if (repo) { + out->oid_type = repo->oid_type; + } else if (opts && opts->oid_type) { + out->oid_type = opts->oid_type; + } else { + out->oid_type = GIT_OID_DEFAULT; + } + out->old_prefix = opts && opts->old_prefix ? git__strdup(opts->old_prefix) : git__strdup(DIFF_OLD_PREFIX_DEFAULT); @@ -118,7 +136,7 @@ static int patch_generated_init( patch->delta_index = delta_index; if ((error = patch_generated_normalize_options( - &patch->base.diff_opts, &diff->opts)) < 0 || + &patch->base.diff_opts, &diff->opts, diff->repo)) < 0 || (error = git_diff_file_content__init_from_diff( &patch->ofile, diff, patch->base.delta, true)) < 0 || (error = git_diff_file_content__init_from_diff( @@ -449,7 +467,7 @@ static int patch_generated_from_sources( git_xdiff_output *xo, git_diff_file_content_src *oldsrc, git_diff_file_content_src *newsrc, - const git_diff_options *opts) + const git_diff_options *given_opts) { int error = 0; git_repository *repo = @@ -457,11 +475,12 @@ static int patch_generated_from_sources( newsrc->blob ? git_blob_owner(newsrc->blob) : NULL; git_diff_file *lfile = &pd->delta.old_file, *rfile = &pd->delta.new_file; git_diff_file_content *ldata = &pd->patch.ofile, *rdata = &pd->patch.nfile; + git_diff_options *opts = &pd->patch.base.diff_opts; - if ((error = patch_generated_normalize_options(&pd->patch.base.diff_opts, opts)) < 0) + if ((error = patch_generated_normalize_options(opts, given_opts, repo)) < 0) return error; - if (opts && (opts->flags & GIT_DIFF_REVERSE) != 0) { + if ((opts->flags & GIT_DIFF_REVERSE) != 0) { void *tmp = lfile; lfile = rfile; rfile = tmp; tmp = ldata; ldata = rdata; rdata = tmp; } diff --git a/src/libgit2/patch_parse.c b/src/libgit2/patch_parse.c index ffdb99231a2..c06915537f2 100644 --- a/src/libgit2/patch_parse.c +++ b/src/libgit2/patch_parse.c @@ -166,15 +166,19 @@ static int parse_header_oid( uint16_t *oid_len, git_patch_parse_ctx *ctx) { - size_t len; + size_t hexsize, len; + + hexsize = git_oid_hexsize(ctx->opts.oid_type); - for (len = 0; len < ctx->parse_ctx.line_len && len < GIT_OID_SHA1_HEXSIZE; len++) { + for (len = 0; + len < ctx->parse_ctx.line_len && len < hexsize; + len++) { if (!git__isxdigit(ctx->parse_ctx.line[len])) break; } - if (len < GIT_OID_MINPREFIXLEN || len > GIT_OID_SHA1_HEXSIZE || - git_oid__fromstrn(oid, ctx->parse_ctx.line, len, GIT_OID_SHA1) < 0) + if (len < GIT_OID_MINPREFIXLEN || len > hexsize || + git_oid__fromstrn(oid, ctx->parse_ctx.line, len, ctx->opts.oid_type) < 0) return git_parse_err("invalid hex formatted object id at line %"PRIuZ, ctx->parse_ctx.line_num); @@ -1065,12 +1069,14 @@ static int check_patch(git_patch_parsed *patch) return git_parse_err("patch with no hunks"); if (delta->status == GIT_DELTA_ADDED) { - git_oid_clear(&delta->old_file.id, GIT_OID_SHA1); + git_oid_clear(&delta->old_file.id, + patch->base.diff_opts.oid_type); delta->old_file.id_abbrev = 0; } if (delta->status == GIT_DELTA_DELETED) { - git_oid_clear(&delta->new_file.id, GIT_OID_SHA1); + git_oid_clear(&delta->new_file.id, + patch->base.diff_opts.oid_type); delta->new_file.id_abbrev = 0; } @@ -1187,11 +1193,13 @@ int git_patch_parse( patch->base.delta->status = GIT_DELTA_MODIFIED; patch->base.delta->nfiles = 2; + patch->base.diff_opts.oid_type = ctx->opts.oid_type; + start = ctx->parse_ctx.remain_len; if ((error = parse_patch_header(patch, ctx)) < 0 || - (error = parse_patch_body(patch, ctx)) < 0 || - (error = check_patch(patch)) < 0) + (error = parse_patch_body(patch, ctx)) < 0 || + (error = check_patch(patch)) < 0) goto done; used = start - ctx->parse_ctx.remain_len; diff --git a/tests/libgit2/apply/apply_helpers.h b/tests/libgit2/apply/apply_helpers.h index 82094773e15..b1a1479de45 100644 --- a/tests/libgit2/apply/apply_helpers.h +++ b/tests/libgit2/apply/apply_helpers.h @@ -1,4 +1,5 @@ #include "../merge/merge_helpers.h" +#include "../diff/diff_helpers.h" #define TEST_REPO_PATH "merge-recursive" diff --git a/tests/libgit2/apply/both.c b/tests/libgit2/apply/both.c index 1331e7ea452..44c5b19371f 100644 --- a/tests/libgit2/apply/both.c +++ b/tests/libgit2/apply/both.c @@ -78,7 +78,7 @@ void test_apply_both__parsed_diff(void) size_t both_expected_cnt = sizeof(both_expected) / sizeof(struct merge_index_entry); - cl_git_pass(git_diff_from_buffer(&diff, + cl_git_pass(diff_from_buffer(&diff, DIFF_MODIFY_TWO_FILES, strlen(DIFF_MODIFY_TWO_FILES))); cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL)); @@ -102,7 +102,7 @@ void test_apply_both__removes_file(void) size_t both_expected_cnt = sizeof(both_expected) / sizeof(struct merge_index_entry); - cl_git_pass(git_diff_from_buffer(&diff, DIFF_DELETE_FILE, + cl_git_pass(diff_from_buffer(&diff, DIFF_DELETE_FILE, strlen(DIFF_DELETE_FILE))); cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL)); @@ -128,7 +128,7 @@ void test_apply_both__adds_file(void) size_t both_expected_cnt = sizeof(both_expected) / sizeof(struct merge_index_entry); - cl_git_pass(git_diff_from_buffer(&diff, + cl_git_pass(diff_from_buffer(&diff, DIFF_ADD_FILE, strlen(DIFF_ADD_FILE))); cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL)); @@ -161,7 +161,7 @@ void test_apply_both__application_failure_leaves_index_unmodified(void) cl_git_pass(git_index_write(index)); git_index_free(index); - cl_git_pass(git_diff_from_buffer(&diff, diff_file, strlen(diff_file))); + cl_git_pass(diff_from_buffer(&diff, diff_file, strlen(diff_file))); cl_git_fail_with(GIT_EAPPLYFAIL, git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL)); validate_apply_index(repo, index_expected, index_expected_cnt); @@ -198,7 +198,7 @@ void test_apply_both__index_must_match_workdir(void) cl_git_pass(git_index_write(index)); git_index_free(index); - cl_git_pass(git_diff_from_buffer(&diff, diff_file, strlen(diff_file))); + cl_git_pass(diff_from_buffer(&diff, diff_file, strlen(diff_file))); cl_git_fail_with(GIT_EAPPLYFAIL, git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL)); git_diff_free(diff); @@ -214,7 +214,7 @@ void test_apply_both__index_mode_must_match_workdir(void) /* Set a file in the working directory executable. */ cl_must_pass(p_chmod("merge-recursive/asparagus.txt", 0755)); - cl_git_pass(git_diff_from_buffer(&diff, DIFF_MODIFY_TWO_FILES, + cl_git_pass(diff_from_buffer(&diff, DIFF_MODIFY_TWO_FILES, strlen(DIFF_MODIFY_TWO_FILES))); cl_git_fail_with(GIT_EAPPLYFAIL, git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL)); @@ -248,7 +248,7 @@ void test_apply_both__application_failure_leaves_workdir_unmodified(void) cl_git_pass(git_index_write(index)); git_index_free(index); - cl_git_pass(git_diff_from_buffer(&diff, diff_file, strlen(diff_file))); + cl_git_pass(diff_from_buffer(&diff, diff_file, strlen(diff_file))); cl_git_fail_with(GIT_EAPPLYFAIL, git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL)); validate_apply_workdir(repo, workdir_expected, workdir_expected_cnt); @@ -301,7 +301,7 @@ void test_apply_both__keeps_nonconflicting_changes(void) cl_git_rmfile("merge-recursive/oyster.txt"); cl_git_rewritefile("merge-recursive/gravy.txt", "Hello, world.\n"); - cl_git_pass(git_diff_from_buffer(&diff, diff_file, strlen(diff_file))); + cl_git_pass(diff_from_buffer(&diff, diff_file, strlen(diff_file))); cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL)); validate_apply_index(repo, index_expected, index_expected_cnt); @@ -341,7 +341,7 @@ void test_apply_both__can_apply_nonconflicting_file_changes(void) cl_git_pass(git_index_write(index)); git_index_free(index); - cl_git_pass(git_diff_from_buffer(&diff, diff_file, strlen(diff_file))); + cl_git_pass(diff_from_buffer(&diff, diff_file, strlen(diff_file))); cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL)); validate_apply_index(repo, both_expected, both_expected_cnt); @@ -391,7 +391,7 @@ void test_apply_both__honors_crlf_attributes(void) cl_git_pass(git_reset(repo, (git_object *)commit, GIT_RESET_HARD, NULL)); git_commit_free(commit); - cl_git_pass(git_diff_from_buffer(&diff, diff_file, strlen(diff_file))); + cl_git_pass(diff_from_buffer(&diff, diff_file, strlen(diff_file))); cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL)); validate_apply_index(repo, index_expected, index_expected_cnt); @@ -415,7 +415,7 @@ void test_apply_both__rename(void) size_t both_expected_cnt = sizeof(both_expected) / sizeof(struct merge_index_entry); - cl_git_pass(git_diff_from_buffer(&diff, DIFF_RENAME_FILE, + cl_git_pass(diff_from_buffer(&diff, DIFF_RENAME_FILE, strlen(DIFF_RENAME_FILE))); cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL)); @@ -440,7 +440,7 @@ void test_apply_both__rename_and_modify(void) size_t both_expected_cnt = sizeof(both_expected) / sizeof(struct merge_index_entry); - cl_git_pass(git_diff_from_buffer(&diff, DIFF_RENAME_AND_MODIFY_FILE, + cl_git_pass(diff_from_buffer(&diff, DIFF_RENAME_AND_MODIFY_FILE, strlen(DIFF_RENAME_AND_MODIFY_FILE))); cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL)); @@ -465,7 +465,7 @@ void test_apply_both__rename_a_to_b_to_c(void) size_t both_expected_cnt = sizeof(both_expected) / sizeof(struct merge_index_entry); - cl_git_pass(git_diff_from_buffer(&diff, DIFF_RENAME_A_TO_B_TO_C, + cl_git_pass(diff_from_buffer(&diff, DIFF_RENAME_A_TO_B_TO_C, strlen(DIFF_RENAME_A_TO_B_TO_C))); cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL)); @@ -490,7 +490,7 @@ void test_apply_both__rename_a_to_b_to_c_exact(void) size_t both_expected_cnt = sizeof(both_expected) / sizeof(struct merge_index_entry); - cl_git_pass(git_diff_from_buffer(&diff, DIFF_RENAME_A_TO_B_TO_C_EXACT, + cl_git_pass(diff_from_buffer(&diff, DIFF_RENAME_A_TO_B_TO_C_EXACT, strlen(DIFF_RENAME_A_TO_B_TO_C_EXACT))); cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL)); @@ -515,7 +515,7 @@ void test_apply_both__rename_circular(void) size_t both_expected_cnt = sizeof(both_expected) / sizeof(struct merge_index_entry); - cl_git_pass(git_diff_from_buffer(&diff, DIFF_RENAME_CIRCULAR, + cl_git_pass(diff_from_buffer(&diff, DIFF_RENAME_CIRCULAR, strlen(DIFF_RENAME_CIRCULAR))); cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL)); @@ -539,7 +539,7 @@ void test_apply_both__rename_2_to_1(void) size_t both_expected_cnt = sizeof(both_expected) / sizeof(struct merge_index_entry); - cl_git_pass(git_diff_from_buffer(&diff, DIFF_RENAME_2_TO_1, + cl_git_pass(diff_from_buffer(&diff, DIFF_RENAME_2_TO_1, strlen(DIFF_RENAME_2_TO_1))); cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL)); @@ -565,7 +565,7 @@ void test_apply_both__rename_1_to_2(void) size_t both_expected_cnt = sizeof(both_expected) / sizeof(struct merge_index_entry); - cl_git_pass(git_diff_from_buffer(&diff, DIFF_RENAME_1_TO_2, + cl_git_pass(diff_from_buffer(&diff, DIFF_RENAME_1_TO_2, strlen(DIFF_RENAME_1_TO_2))); cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL)); @@ -590,7 +590,7 @@ void test_apply_both__two_deltas_one_file(void) size_t both_expected_cnt = sizeof(both_expected) / sizeof(struct merge_index_entry); - cl_git_pass(git_diff_from_buffer(&diff, DIFF_TWO_DELTAS_ONE_FILE, + cl_git_pass(diff_from_buffer(&diff, DIFF_TWO_DELTAS_ONE_FILE, strlen(DIFF_TWO_DELTAS_ONE_FILE))); cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL)); @@ -616,7 +616,7 @@ void test_apply_both__two_deltas_one_new_file(void) size_t both_expected_cnt = sizeof(both_expected) / sizeof(struct merge_index_entry); - cl_git_pass(git_diff_from_buffer(&diff, DIFF_TWO_DELTAS_ONE_NEW_FILE, + cl_git_pass(diff_from_buffer(&diff, DIFF_TWO_DELTAS_ONE_NEW_FILE, strlen(DIFF_TWO_DELTAS_ONE_NEW_FILE))); cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL)); @@ -641,7 +641,7 @@ void test_apply_both__rename_and_modify_deltas(void) size_t both_expected_cnt = sizeof(both_expected) / sizeof(struct merge_index_entry); - cl_git_pass(git_diff_from_buffer(&diff, DIFF_RENAME_AND_MODIFY_DELTAS, + cl_git_pass(diff_from_buffer(&diff, DIFF_RENAME_AND_MODIFY_DELTAS, strlen(DIFF_RENAME_AND_MODIFY_DELTAS))); cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL)); @@ -667,7 +667,7 @@ void test_apply_both__rename_delta_after_modify_delta(void) size_t both_expected_cnt = sizeof(both_expected) / sizeof(struct merge_index_entry); - cl_git_pass(git_diff_from_buffer(&diff, DIFF_RENAME_AFTER_MODIFY, + cl_git_pass(diff_from_buffer(&diff, DIFF_RENAME_AFTER_MODIFY, strlen(DIFF_RENAME_AFTER_MODIFY))); cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL)); @@ -681,7 +681,7 @@ void test_apply_both__cant_rename_after_modify_nonexistent_target_path(void) { git_diff *diff; - cl_git_pass(git_diff_from_buffer(&diff, DIFF_RENAME_AFTER_MODIFY_TARGET_PATH, + cl_git_pass(diff_from_buffer(&diff, DIFF_RENAME_AFTER_MODIFY_TARGET_PATH, strlen(DIFF_RENAME_AFTER_MODIFY_TARGET_PATH))); cl_git_fail(git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL)); @@ -692,7 +692,7 @@ void test_apply_both__cant_modify_source_path_after_rename(void) { git_diff *diff; - cl_git_pass(git_diff_from_buffer(&diff, DIFF_RENAME_AND_MODIFY_SOURCE_PATH, + cl_git_pass(diff_from_buffer(&diff, DIFF_RENAME_AND_MODIFY_SOURCE_PATH, strlen(DIFF_RENAME_AND_MODIFY_SOURCE_PATH))); cl_git_fail(git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL)); @@ -714,7 +714,7 @@ void test_apply_both__readd_deleted_file(void) size_t both_expected_cnt = sizeof(both_expected) / sizeof(struct merge_index_entry); - cl_git_pass(git_diff_from_buffer(&diff, DIFF_DELETE_AND_READD_FILE, + cl_git_pass(diff_from_buffer(&diff, DIFF_DELETE_AND_READD_FILE, strlen(DIFF_DELETE_AND_READD_FILE))); cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL)); @@ -728,7 +728,7 @@ void test_apply_both__cant_remove_file_twice(void) { git_diff *diff; - cl_git_pass(git_diff_from_buffer(&diff, DIFF_REMOVE_FILE_TWICE, + cl_git_pass(diff_from_buffer(&diff, DIFF_REMOVE_FILE_TWICE, strlen(DIFF_REMOVE_FILE_TWICE))); cl_git_fail(git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL)); @@ -739,7 +739,7 @@ void test_apply_both__cant_add_invalid_filename(void) { git_diff *diff; - cl_git_pass(git_diff_from_buffer(&diff, DIFF_ADD_INVALID_FILENAME, + cl_git_pass(diff_from_buffer(&diff, DIFF_ADD_INVALID_FILENAME, strlen(DIFF_ADD_INVALID_FILENAME))); cl_git_fail(git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL)); diff --git a/tests/libgit2/apply/callbacks.c b/tests/libgit2/apply/callbacks.c index 2f9af310161..f076ca48622 100644 --- a/tests/libgit2/apply/callbacks.c +++ b/tests/libgit2/apply/callbacks.c @@ -40,7 +40,7 @@ void test_apply_callbacks__delta_aborts(void) opts.delta_cb = delta_abort_cb; - cl_git_pass(git_diff_from_buffer(&diff, + cl_git_pass(diff_from_buffer(&diff, DIFF_MODIFY_TWO_FILES, strlen(DIFF_MODIFY_TWO_FILES))); cl_git_fail_with(-99, git_apply(repo, diff, GIT_APPLY_LOCATION_INDEX, &opts)); @@ -79,7 +79,7 @@ void test_apply_callbacks__delta_can_skip(void) opts.delta_cb = delta_skip_cb; - cl_git_pass(git_diff_from_buffer(&diff, + cl_git_pass(diff_from_buffer(&diff, DIFF_MODIFY_TWO_FILES, strlen(DIFF_MODIFY_TWO_FILES))); cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_WORKDIR, &opts)); @@ -117,7 +117,7 @@ void test_apply_callbacks__hunk_can_skip(void) opts.hunk_cb = hunk_skip_odds_cb; opts.payload = &count; - cl_git_pass(git_diff_from_buffer(&diff, + cl_git_pass(diff_from_buffer(&diff, DIFF_MANY_CHANGES_ONE, strlen(DIFF_MANY_CHANGES_ONE))); cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_WORKDIR, &opts)); diff --git a/tests/libgit2/apply/check.c b/tests/libgit2/apply/check.c index d055d455b8f..0c1f86dc531 100644 --- a/tests/libgit2/apply/check.c +++ b/tests/libgit2/apply/check.c @@ -60,7 +60,7 @@ void test_apply_check__parsed_diff(void) git_apply_options opts = GIT_APPLY_OPTIONS_INIT; opts.flags |= GIT_APPLY_CHECK; - cl_git_pass(git_diff_from_buffer(&diff, + cl_git_pass(diff_from_buffer(&diff, DIFF_MODIFY_TWO_FILES, strlen(DIFF_MODIFY_TWO_FILES))); cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_INDEX, &opts)); @@ -76,7 +76,7 @@ void test_apply_check__binary(void) git_apply_options opts = GIT_APPLY_OPTIONS_INIT; opts.flags |= GIT_APPLY_CHECK; - cl_git_pass(git_diff_from_buffer(&diff, + cl_git_pass(diff_from_buffer(&diff, DIFF_MODIFY_TWO_FILES_BINARY, strlen(DIFF_MODIFY_TWO_FILES_BINARY))); cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_INDEX, &opts)); @@ -112,7 +112,7 @@ void test_apply_check__does_not_apply(void) git_index_free(index); opts.flags |= GIT_APPLY_CHECK; - cl_git_pass(git_diff_from_buffer(&diff, diff_file, strlen(diff_file))); + cl_git_pass(diff_from_buffer(&diff, diff_file, strlen(diff_file))); cl_git_fail_with(GIT_EAPPLYFAIL, git_apply(repo, diff, GIT_APPLY_LOCATION_INDEX, &opts)); validate_apply_index(repo, index_expected, index_expected_cnt); diff --git a/tests/libgit2/apply/index.c b/tests/libgit2/apply/index.c index 2dc0d53cb34..564d55c8c1c 100644 --- a/tests/libgit2/apply/index.c +++ b/tests/libgit2/apply/index.c @@ -78,7 +78,7 @@ void test_apply_index__parsed_diff(void) size_t index_expected_cnt = sizeof(index_expected) / sizeof(struct merge_index_entry); - cl_git_pass(git_diff_from_buffer(&diff, + cl_git_pass(diff_from_buffer(&diff, DIFF_MODIFY_TWO_FILES, strlen(DIFF_MODIFY_TWO_FILES))); cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_INDEX, NULL)); @@ -102,7 +102,7 @@ void test_apply_index__removes_file(void) size_t index_expected_cnt = sizeof(index_expected) / sizeof(struct merge_index_entry); - cl_git_pass(git_diff_from_buffer(&diff, DIFF_DELETE_FILE, + cl_git_pass(diff_from_buffer(&diff, DIFF_DELETE_FILE, strlen(DIFF_DELETE_FILE))); cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_INDEX, NULL)); @@ -128,7 +128,7 @@ void test_apply_index__adds_file(void) size_t index_expected_cnt = sizeof(index_expected) / sizeof(struct merge_index_entry); - cl_git_pass(git_diff_from_buffer(&diff, + cl_git_pass(diff_from_buffer(&diff, DIFF_ADD_FILE, strlen(DIFF_ADD_FILE))); cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_INDEX, NULL)); @@ -169,7 +169,7 @@ void test_apply_index__modified_workdir_with_unmodified_index_is_ok(void) cl_git_rmfile("merge-recursive/asparagus.txt"); cl_git_rewritefile("merge-recursive/veal.txt", "Hello, world.\n"); - cl_git_pass(git_diff_from_buffer(&diff, diff_file, strlen(diff_file))); + cl_git_pass(diff_from_buffer(&diff, diff_file, strlen(diff_file))); cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_INDEX, NULL)); validate_apply_index(repo, index_expected, index_expected_cnt); @@ -201,7 +201,7 @@ void test_apply_index__application_failure_leaves_index_unmodified(void) cl_git_pass(git_index_write(index)); git_index_free(index); - cl_git_pass(git_diff_from_buffer(&diff, diff_file, strlen(diff_file))); + cl_git_pass(diff_from_buffer(&diff, diff_file, strlen(diff_file))); cl_git_fail_with(GIT_EAPPLYFAIL, git_apply(repo, diff, GIT_APPLY_LOCATION_INDEX, NULL)); validate_apply_index(repo, index_expected, index_expected_cnt); @@ -240,7 +240,7 @@ void test_apply_index__keeps_nonconflicting_changes(void) cl_git_pass(git_index_write(index)); git_index_free(index); - cl_git_pass(git_diff_from_buffer(&diff, diff_file, strlen(diff_file))); + cl_git_pass(diff_from_buffer(&diff, diff_file, strlen(diff_file))); cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_INDEX, NULL)); validate_apply_index(repo, index_expected, index_expected_cnt); @@ -285,7 +285,7 @@ void test_apply_index__can_apply_nonconflicting_file_changes(void) cl_git_pass(git_index_write(index)); git_index_free(index); - cl_git_pass(git_diff_from_buffer(&diff, diff_file, strlen(diff_file))); + cl_git_pass(diff_from_buffer(&diff, diff_file, strlen(diff_file))); cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_INDEX, NULL)); validate_apply_index(repo, index_expected, index_expected_cnt); @@ -311,7 +311,7 @@ void test_apply_index__change_mode(void) size_t index_expected_cnt = sizeof(index_expected) / sizeof(struct merge_index_entry); - cl_git_pass(git_diff_from_buffer(&diff, diff_file, strlen(diff_file))); + cl_git_pass(diff_from_buffer(&diff, diff_file, strlen(diff_file))); cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_INDEX, NULL)); validate_apply_index(repo, index_expected, index_expected_cnt); diff --git a/tests/libgit2/apply/tree.c b/tests/libgit2/apply/tree.c index 667bb9d401a..b97fe8d352b 100644 --- a/tests/libgit2/apply/tree.c +++ b/tests/libgit2/apply/tree.c @@ -81,7 +81,7 @@ void test_apply_tree__adds_file(void) cl_git_pass(git_commit_tree(&a_tree, a_commit)); - cl_git_pass(git_diff_from_buffer(&diff, + cl_git_pass(diff_from_buffer(&diff, DIFF_ADD_FILE, strlen(DIFF_ADD_FILE))); cl_git_pass(git_apply_to_tree(&index, repo, a_tree, diff, NULL)); diff --git a/tests/libgit2/apply/workdir.c b/tests/libgit2/apply/workdir.c index e1011d114cc..5ae56847a80 100644 --- a/tests/libgit2/apply/workdir.c +++ b/tests/libgit2/apply/workdir.c @@ -77,7 +77,7 @@ void test_apply_workdir__parsed_diff(void) size_t workdir_expected_cnt = sizeof(workdir_expected) / sizeof(struct merge_index_entry); - cl_git_pass(git_diff_from_buffer(&diff, + cl_git_pass(diff_from_buffer(&diff, DIFF_MODIFY_TWO_FILES, strlen(DIFF_MODIFY_TWO_FILES))); cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_WORKDIR, NULL)); @@ -101,7 +101,7 @@ void test_apply_workdir__removes_file(void) size_t workdir_expected_cnt = sizeof(workdir_expected) / sizeof(struct merge_index_entry); - cl_git_pass(git_diff_from_buffer(&diff, DIFF_DELETE_FILE, + cl_git_pass(diff_from_buffer(&diff, DIFF_DELETE_FILE, strlen(DIFF_DELETE_FILE))); cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_WORKDIR, NULL)); @@ -127,7 +127,7 @@ void test_apply_workdir__adds_file(void) size_t workdir_expected_cnt = sizeof(workdir_expected) / sizeof(struct merge_index_entry); - cl_git_pass(git_diff_from_buffer(&diff, + cl_git_pass(diff_from_buffer(&diff, DIFF_ADD_FILE, strlen(DIFF_ADD_FILE))); cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_WORKDIR, NULL)); @@ -177,7 +177,7 @@ void test_apply_workdir__modified_index_with_unmodified_workdir_is_ok(void) cl_git_pass(git_index_remove(index, "asparagus.txt", 0)); cl_git_pass(git_index_write(index)); - cl_git_pass(git_diff_from_buffer(&diff, diff_file, strlen(diff_file))); + cl_git_pass(diff_from_buffer(&diff, diff_file, strlen(diff_file))); cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_WORKDIR, NULL)); validate_apply_index(repo, index_expected, index_expected_cnt); @@ -208,7 +208,7 @@ void test_apply_workdir__application_failure_leaves_workdir_unmodified(void) cl_git_rewritefile("merge-recursive/veal.txt", "This is a modification.\n"); - cl_git_pass(git_diff_from_buffer(&diff, diff_file, strlen(diff_file))); + cl_git_pass(diff_from_buffer(&diff, diff_file, strlen(diff_file))); cl_git_fail_with(GIT_EAPPLYFAIL, git_apply(repo, diff, GIT_APPLY_LOCATION_WORKDIR, NULL)); validate_apply_workdir(repo, workdir_expected, workdir_expected_cnt); @@ -233,7 +233,7 @@ void test_apply_workdir__keeps_nonconflicting_changes(void) cl_git_rmfile("merge-recursive/oyster.txt"); cl_git_rewritefile("merge-recursive/gravy.txt", "Hello, world.\n"); - cl_git_pass(git_diff_from_buffer(&diff, + cl_git_pass(diff_from_buffer(&diff, DIFF_MODIFY_TWO_FILES, strlen(DIFF_MODIFY_TWO_FILES))); cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_WORKDIR, NULL)); @@ -268,7 +268,7 @@ void test_apply_workdir__can_apply_nonconflicting_file_changes(void) cl_git_append2file("merge-recursive/asparagus.txt", "This line is added in the workdir.\n"); - cl_git_pass(git_diff_from_buffer(&diff, diff_file, strlen(diff_file))); + cl_git_pass(diff_from_buffer(&diff, diff_file, strlen(diff_file))); cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_WORKDIR, NULL)); validate_index_unchanged(repo); @@ -295,7 +295,7 @@ void test_apply_workdir__change_mode(void) size_t workdir_expected_cnt = sizeof(workdir_expected) / sizeof(struct merge_index_entry); - cl_git_pass(git_diff_from_buffer(&diff, diff_file, strlen(diff_file))); + cl_git_pass(diff_from_buffer(&diff, diff_file, strlen(diff_file))); cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_WORKDIR, NULL)); validate_index_unchanged(repo); @@ -321,7 +321,7 @@ void test_apply_workdir__apply_many_changes_one(void) size_t workdir_expected_cnt = sizeof(workdir_expected) / sizeof(struct merge_index_entry); - cl_git_pass(git_diff_from_buffer(&diff, + cl_git_pass(diff_from_buffer(&diff, DIFF_MANY_CHANGES_ONE, strlen(DIFF_MANY_CHANGES_ONE))); cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_WORKDIR, &opts)); @@ -347,7 +347,7 @@ void test_apply_workdir__apply_many_changes_two(void) size_t workdir_expected_cnt = sizeof(workdir_expected) / sizeof(struct merge_index_entry); - cl_git_pass(git_diff_from_buffer(&diff, + cl_git_pass(diff_from_buffer(&diff, DIFF_MANY_CHANGES_TWO, strlen(DIFF_MANY_CHANGES_TWO))); cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_WORKDIR, &opts)); diff --git a/tests/libgit2/diff/diff_helpers.c b/tests/libgit2/diff/diff_helpers.c index 341b0a448a3..5daebffeb3c 100644 --- a/tests/libgit2/diff/diff_helpers.c +++ b/tests/libgit2/diff/diff_helpers.c @@ -314,3 +314,20 @@ void diff_assert_equal(git_diff *a, git_diff *b) } } +#ifdef GIT_EXPERIMENTAL_SHA256 +int diff_from_buffer( + git_diff **out, + const char *content, + size_t content_len) +{ + return git_diff_from_buffer(out, content, content_len, NULL); +} +#else +int diff_from_buffer( + git_diff **out, + const char *content, + size_t content_len) +{ + return git_diff_from_buffer(out, content, content_len); +} +#endif diff --git a/tests/libgit2/diff/diff_helpers.h b/tests/libgit2/diff/diff_helpers.h index af855ce684f..1be4b47801c 100644 --- a/tests/libgit2/diff/diff_helpers.h +++ b/tests/libgit2/diff/diff_helpers.h @@ -71,3 +71,7 @@ extern void diff_print_raw(FILE *fp, git_diff *diff); extern void diff_assert_equal(git_diff *a, git_diff *b); +extern int diff_from_buffer( + git_diff **out, + const char *content, + size_t content_len); diff --git a/tests/libgit2/diff/parse.c b/tests/libgit2/diff/parse.c index cae843cc836..79745b99503 100644 --- a/tests/libgit2/diff/parse.c +++ b/tests/libgit2/diff/parse.c @@ -19,19 +19,19 @@ void test_diff_parse__nonpatches_fail_with_notfound(void) const char *not_with_both = "Lead.\n" PATCH_NOT_A_PATCH "Trail.\n"; cl_git_fail_with(GIT_ENOTFOUND, - git_diff_from_buffer(&diff, + diff_from_buffer(&diff, not, strlen(not))); cl_git_fail_with(GIT_ENOTFOUND, - git_diff_from_buffer(&diff, + diff_from_buffer(&diff, not_with_leading, strlen(not_with_leading))); cl_git_fail_with(GIT_ENOTFOUND, - git_diff_from_buffer(&diff, + diff_from_buffer(&diff, not_with_trailing, strlen(not_with_trailing))); cl_git_fail_with(GIT_ENOTFOUND, - git_diff_from_buffer(&diff, + diff_from_buffer(&diff, not_with_both, strlen(not_with_both))); } @@ -51,7 +51,7 @@ static void test_parse_invalid_diff(const char *invalid_diff) git_str_puts(&buf, PATCH_BINARY_LITERAL); cl_git_fail_with(GIT_ERROR, - git_diff_from_buffer(&diff, buf.ptr, buf.size)); + diff_from_buffer(&diff, buf.ptr, buf.size)); git_str_dispose(&buf); } @@ -72,7 +72,7 @@ void test_diff_parse__exact_rename(void) "2.9.3\n"; git_diff *diff; - cl_git_pass(git_diff_from_buffer( + cl_git_pass(diff_from_buffer( &diff, content, strlen(content))); git_diff_free(diff); } @@ -92,7 +92,7 @@ void test_diff_parse__empty_file(void) "2.20.1\n"; git_diff *diff; - cl_git_pass(git_diff_from_buffer( + cl_git_pass(diff_from_buffer( &diff, content, strlen(content))); git_diff_free(diff); } @@ -102,7 +102,7 @@ void test_diff_parse__no_extended_headers(void) const char *content = PATCH_NO_EXTENDED_HEADERS; git_diff *diff; - cl_git_pass(git_diff_from_buffer( + cl_git_pass(diff_from_buffer( &diff, content, strlen(content))); git_diff_free(diff); } @@ -125,7 +125,7 @@ void test_diff_parse__add_delete_no_index(void) "-three\n"; git_diff *diff; - cl_git_pass(git_diff_from_buffer( + cl_git_pass(diff_from_buffer( &diff, content, strlen(content))); git_diff_free(diff); } @@ -166,7 +166,7 @@ static void test_tree_to_tree_computed_to_parsed( cl_git_pass(git_diff_to_buf(&computed_buf, computed, GIT_DIFF_FORMAT_PATCH)); - cl_git_pass(git_diff_from_buffer(&parsed, + cl_git_pass(diff_from_buffer(&parsed, computed_buf.ptr, computed_buf.size)); diff_assert_equal(computed, parsed); @@ -248,7 +248,7 @@ void test_diff_parse__get_patch_from_diff(void) computed, GIT_DIFF_FORMAT_PATCH)); cl_git_pass(git_patch_from_diff(&patch_computed, computed, 0)); - cl_git_pass(git_diff_from_buffer(&parsed, + cl_git_pass(diff_from_buffer(&parsed, computed_buf.ptr, computed_buf.size)); cl_git_pass(git_patch_from_diff(&patch_parsed, parsed, 0)); @@ -292,7 +292,7 @@ void test_diff_parse__foreach_works_with_parsed_patch(void) int called = 0; git_diff *diff; - cl_git_pass(git_diff_from_buffer(&diff, patch, strlen(patch))); + cl_git_pass(diff_from_buffer(&diff, patch, strlen(patch))); cl_git_pass(git_diff_foreach(diff, file_cb, NULL, NULL, NULL, &called)); cl_assert_equal_i(called, 1); @@ -312,7 +312,7 @@ void test_diff_parse__parsing_minimal_patch_succeeds(void) git_buf buf = GIT_BUF_INIT; git_diff *diff; - cl_git_pass(git_diff_from_buffer(&diff, patch, strlen(patch))); + cl_git_pass(diff_from_buffer(&diff, patch, strlen(patch))); cl_git_pass(git_diff_to_buf(&buf, diff, GIT_DIFF_FORMAT_PATCH)); cl_assert_equal_s(patch, buf.ptr); @@ -330,7 +330,7 @@ void test_diff_parse__patch_roundtrip_succeeds(void) cl_git_pass(git_patch_from_buffers(&patch, buf1, strlen(buf1), "obj1", buf2, strlen(buf2), "obj2", NULL)); cl_git_pass(git_patch_to_buf(&patchbuf, patch)); - cl_git_pass(git_diff_from_buffer(&diff, patchbuf.ptr, patchbuf.size)); + cl_git_pass(diff_from_buffer(&diff, patchbuf.ptr, patchbuf.size)); cl_git_pass(git_diff_to_buf(&diffbuf, diff, GIT_DIFF_FORMAT_PATCH)); cl_assert_equal_s(patchbuf.ptr, diffbuf.ptr); @@ -372,7 +372,7 @@ void test_diff_parse__issue4672(void) const git_diff_hunk *hunk; size_t n, l = 0; - cl_git_pass(git_diff_from_buffer(&diff, text, strlen(text))); + cl_git_pass(diff_from_buffer(&diff, text, strlen(text))); cl_git_pass(git_patch_from_diff(&patch, diff, 0)); cl_git_pass(git_patch_get_hunk(&hunk, &n, patch, 0)); @@ -393,7 +393,7 @@ void test_diff_parse__lineinfo(void) const git_diff_hunk *hunk; size_t n, l = 0; - cl_git_pass(git_diff_from_buffer(&diff, text, strlen(text))); + cl_git_pass(diff_from_buffer(&diff, text, strlen(text))); cl_git_pass(git_patch_from_diff(&patch, diff, 0)); cl_git_pass(git_patch_get_hunk(&hunk, &n, patch, 0)); @@ -419,7 +419,7 @@ void test_diff_parse__new_file_with_space(void) git_patch *patch; git_diff *diff; - cl_git_pass(git_diff_from_buffer(&diff, content, strlen(content))); + cl_git_pass(diff_from_buffer(&diff, content, strlen(content))); cl_git_pass(git_patch_from_diff((git_patch **) &patch, diff, 0)); cl_assert_equal_p(patch->diff_opts.old_prefix, NULL); @@ -437,7 +437,7 @@ void test_diff_parse__new_file_with_space_and_regenerate_patch(void) git_diff *diff = NULL; git_buf buf = GIT_BUF_INIT; - cl_git_pass(git_diff_from_buffer(&diff, content, strlen(content))); + cl_git_pass(diff_from_buffer(&diff, content, strlen(content))); cl_git_pass(git_diff_to_buf(&buf, diff, GIT_DIFF_FORMAT_PATCH)); git_buf_dispose(&buf); @@ -450,7 +450,7 @@ void test_diff_parse__delete_file_with_space_and_regenerate_patch(void) git_diff *diff = NULL; git_buf buf = GIT_BUF_INIT; - cl_git_pass(git_diff_from_buffer(&diff, content, strlen(content))); + cl_git_pass(diff_from_buffer(&diff, content, strlen(content))); cl_git_pass(git_diff_to_buf(&buf, diff, GIT_DIFF_FORMAT_PATCH)); git_buf_dispose(&buf); @@ -464,7 +464,7 @@ void test_diff_parse__crlf(void) git_patch *patch; const git_diff_delta *delta; - cl_git_pass(git_diff_from_buffer(&diff, text, strlen(text))); + cl_git_pass(diff_from_buffer(&diff, text, strlen(text))); cl_git_pass(git_patch_from_diff(&patch, diff, 0)); delta = git_patch_get_delta(patch); diff --git a/tests/libgit2/diff/patchid.c b/tests/libgit2/diff/patchid.c index 1cc368e2193..91807e7b747 100644 --- a/tests/libgit2/diff/patchid.c +++ b/tests/libgit2/diff/patchid.c @@ -1,5 +1,6 @@ #include "clar_libgit2.h" #include "patch/patch_common.h" +#include "diff_helpers.h" static void verify_patch_id(const char *diff_content, const char *expected_id) { @@ -7,7 +8,7 @@ static void verify_patch_id(const char *diff_content, const char *expected_id) git_diff *diff; cl_git_pass(git_oid__fromstr(&expected_oid, expected_id, GIT_OID_SHA1)); - cl_git_pass(git_diff_from_buffer(&diff, diff_content, strlen(diff_content))); + cl_git_pass(diff_from_buffer(&diff, diff_content, strlen(diff_content))); cl_git_pass(git_diff_patchid(&actual_oid, diff, NULL)); cl_assert_equal_oid(&expected_oid, &actual_oid); diff --git a/tests/libgit2/diff/stats.c b/tests/libgit2/diff/stats.c index b076ad5a93d..7af89155084 100644 --- a/tests/libgit2/diff/stats.c +++ b/tests/libgit2/diff/stats.c @@ -4,6 +4,7 @@ #include "commit.h" #include "diff.h" #include "diff_generate.h" +#include "diff_helpers.h" static git_repository *_repo; static git_diff_stats *_stats; @@ -368,7 +369,7 @@ void test_diff_stats__new_file(void) " 1 file changed, 1 insertion(+)\n" " create mode 100644 Gurjeet Singh\n"; - cl_git_pass(git_diff_from_buffer(&diff, input, strlen(input))); + cl_git_pass(diff_from_buffer(&diff, input, strlen(input))); cl_git_pass(git_diff_get_stats(&_stats, diff)); cl_git_pass(git_diff_stats_to_buf(&buf, _stats, GIT_DIFF_STATS_FULL | GIT_DIFF_STATS_INCLUDE_SUMMARY, 0)); cl_assert_equal_s(stat, buf.ptr); From 47868ee45bc1f8680288caebec5a0443bceda12d Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 8 Apr 2023 20:32:10 +0100 Subject: [PATCH 226/608] repo: use `GIT_OID_DEFAULT` for default oid type --- src/libgit2/repository.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index 4bf92dcdca3..804e436abeb 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -934,7 +934,7 @@ static int obtain_config_and_set_oid_type( if ((error = load_objectformat(repo, config)) < 0) goto out; } else { - repo->oid_type = GIT_OID_SHA1; + repo->oid_type = GIT_OID_DEFAULT; } out: @@ -1804,7 +1804,7 @@ static int load_objectformat(git_repository *repo, git_config *config) if ((error = git_config_get_entry(&entry, config, "extensions.objectformat")) < 0) { if (error == GIT_ENOTFOUND) { - repo->oid_type = GIT_OID_SHA1; + repo->oid_type = GIT_OID_DEFAULT; git_error_clear(); error = 0; } @@ -2240,7 +2240,7 @@ static int repo_init_config( SET_REPO_CONFIG(bool, "receive.denyNonFastforwards", true); } - if (oid_type != GIT_OID_SHA1) { + if (oid_type != GIT_OID_DEFAULT) { SET_REPO_CONFIG(int32, "core.repositoryformatversion", 1); SET_REPO_CONFIG(string, "extensions.objectformat", git_oid_type_name(oid_type)); } From f4774446ef1c314dfa7802d8d2b27d6bedb44c67 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 8 Apr 2023 21:19:33 +0100 Subject: [PATCH 227/608] merge: support sha256 --- src/libgit2/annotated_commit.c | 4 ++-- src/libgit2/annotated_commit.h | 2 +- src/libgit2/merge.c | 8 +++++--- 3 files changed, 8 insertions(+), 6 deletions(-) diff --git a/src/libgit2/annotated_commit.c b/src/libgit2/annotated_commit.c index 7bd8b6077f9..c5c8ace789d 100644 --- a/src/libgit2/annotated_commit.c +++ b/src/libgit2/annotated_commit.c @@ -39,8 +39,8 @@ static int annotated_commit_init( if ((error = git_commit_dup(&annotated_commit->commit, commit)) < 0) goto done; - git_oid_fmt(annotated_commit->id_str, git_commit_id(commit)); - annotated_commit->id_str[GIT_OID_SHA1_HEXSIZE] = '\0'; + git_oid_tostr(annotated_commit->id_str, GIT_OID_MAX_HEXSIZE + 1, + git_commit_id(commit)); if (!description) description = annotated_commit->id_str; diff --git a/src/libgit2/annotated_commit.h b/src/libgit2/annotated_commit.h index c87eaa8057b..1f805fe9bda 100644 --- a/src/libgit2/annotated_commit.h +++ b/src/libgit2/annotated_commit.h @@ -41,7 +41,7 @@ struct git_annotated_commit { const char *ref_name; const char *remote_url; - char id_str[GIT_OID_SHA1_HEXSIZE+1]; + char id_str[GIT_OID_MAX_HEXSIZE + 1]; }; extern int git_annotated_commit_from_head(git_annotated_commit **out, diff --git a/src/libgit2/merge.c b/src/libgit2/merge.c index 9a52b9f786b..0114e4b75a0 100644 --- a/src/libgit2/merge.c +++ b/src/libgit2/merge.c @@ -611,13 +611,13 @@ int git_repository_mergehead_foreach( buffer = merge_head_file.ptr; while ((line = git__strsep(&buffer, "\n")) != NULL) { - if (strlen(line) != GIT_OID_SHA1_HEXSIZE) { + if (strlen(line) != git_oid_hexsize(repo->oid_type)) { git_error_set(GIT_ERROR_INVALID, "unable to parse OID - invalid length"); error = -1; goto cleanup; } - if ((error = git_oid__fromstr(&oid, line, GIT_OID_SHA1)) < 0) + if ((error = git_oid__fromstr(&oid, line, repo->oid_type)) < 0) goto cleanup; if ((error = cb(&oid, payload)) != 0) { @@ -1061,7 +1061,7 @@ static int index_entry_similarity_calc( const git_merge_options *opts) { git_blob *blob; - git_diff_file diff_file = { GIT_OID_SHA1_ZERO }; + git_diff_file diff_file; git_object_size_t blobsize; int error; @@ -1070,6 +1070,8 @@ static int index_entry_similarity_calc( *out = NULL; + git_oid_clear(&diff_file.id, repo->oid_type); + if ((error = git_blob_lookup(&blob, repo, &entry->id)) < 0) return error; From e01df92875a5005ac9337bbcc0a7681cc25e6738 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 8 Apr 2023 21:24:00 +0100 Subject: [PATCH 228/608] cherrypick: support sha256 --- src/libgit2/cherrypick.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/libgit2/cherrypick.c b/src/libgit2/cherrypick.c index 04812b1c6f5..3ef42d5e78e 100644 --- a/src/libgit2/cherrypick.c +++ b/src/libgit2/cherrypick.c @@ -106,10 +106,10 @@ static int cherrypick_state_cleanup(git_repository *repo) static int cherrypick_seterr(git_commit *commit, const char *fmt) { - char commit_oidstr[GIT_OID_SHA1_HEXSIZE + 1]; + char commit_oidstr[GIT_OID_MAX_HEXSIZE + 1]; git_error_set(GIT_ERROR_CHERRYPICK, fmt, - git_oid_tostr(commit_oidstr, GIT_OID_SHA1_HEXSIZE + 1, git_commit_id(commit))); + git_oid_tostr(commit_oidstr, GIT_OID_MAX_HEXSIZE + 1, git_commit_id(commit))); return -1; } @@ -173,7 +173,7 @@ int git_cherrypick( git_cherrypick_options opts; git_reference *our_ref = NULL; git_commit *our_commit = NULL; - char commit_oidstr[GIT_OID_SHA1_HEXSIZE + 1]; + char commit_oidstr[GIT_OID_MAX_HEXSIZE + 1]; const char *commit_msg, *commit_summary; git_str their_label = GIT_STR_INIT; git_index *index = NULL; From 8961f5b92efd7703783e0a0e1f7edd1d65c778fd Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 8 Apr 2023 21:27:48 +0100 Subject: [PATCH 229/608] describe: support sha256 --- src/libgit2/describe.c | 17 ++++++++++------- 1 file changed, 10 insertions(+), 7 deletions(-) diff --git a/src/libgit2/describe.c b/src/libgit2/describe.c index 3f73d87d63f..04453472330 100644 --- a/src/libgit2/describe.c +++ b/src/libgit2/describe.c @@ -363,12 +363,15 @@ static int find_unique_abbrev_size( size_t size = abbreviated_size; git_odb *odb; git_oid dummy; + size_t hexsize; int error; if ((error = git_repository_odb__weakptr(&odb, repo)) < 0) return error; - while (size < GIT_OID_SHA1_HEXSIZE) { + hexsize = git_oid_hexsize(repo->oid_type); + + while (size < hexsize) { if ((error = git_odb_exists_prefix(&dummy, odb, oid_in, size)) == 0) { *out = (int) size; return 0; @@ -383,7 +386,7 @@ static int find_unique_abbrev_size( } /* If we didn't find any shorter prefix, we have to do the whole thing */ - *out = GIT_OID_SHA1_HEXSIZE; + *out = (int)hexsize; return 0; } @@ -397,7 +400,7 @@ static int show_suffix( { int error, size = 0; - char hex_oid[GIT_OID_SHA1_HEXSIZE]; + char hex_oid[GIT_OID_MAX_HEXSIZE]; if ((error = find_unique_abbrev_size(&size, repo, id, abbrev_size)) < 0) return error; @@ -414,7 +417,7 @@ static int show_suffix( #define MAX_CANDIDATES_TAGS FLAG_BITS - 1 static int describe_not_found(const git_oid *oid, const char *message_format) { - char oid_str[GIT_OID_SHA1_HEXSIZE + 1]; + char oid_str[GIT_OID_MAX_HEXSIZE + 1]; git_oid_tostr(oid_str, sizeof(oid_str), oid); git_error_set(GIT_ERROR_DESCRIBE, message_format, oid_str); @@ -525,7 +528,7 @@ static int describe( if (annotated_cnt && (git_pqueue_size(&list) == 0)) { /* if (debug) { - char oid_str[GIT_OID_SHA1_HEXSIZE + 1]; + char oid_str[GIT_OID_MAX_HEXSIZE + 1]; git_oid_tostr(oid_str, sizeof(oid_str), &c->oid); fprintf(stderr, "finished search at %s\n", oid_str); @@ -592,7 +595,7 @@ static int describe( "head", "lightweight", "annotated", }; - char oid_str[GIT_OID_SHA1_HEXSIZE + 1]; + char oid_str[GIT_OID_MAX_HEXSIZE + 1]; if (debug) { for (cur_match = 0; cur_match < match_cnt; cur_match++) { @@ -816,7 +819,7 @@ static int git_describe__format( /* If we didn't find *any* tags, we fall back to the commit's id */ if (result->fallback_to_id) { - char hex_oid[GIT_OID_SHA1_HEXSIZE + 1] = {0}; + char hex_oid[GIT_OID_MAX_HEXSIZE + 1] = {0}; int size = 0; if ((error = find_unique_abbrev_size( From 4875d998de40d929ab6af8e26a76c9570d84121c Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 8 Apr 2023 21:30:31 +0100 Subject: [PATCH 230/608] commit_list: support sha256 --- src/libgit2/commit_list.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/libgit2/commit_list.c b/src/libgit2/commit_list.c index 12b329b251e..485871db36f 100644 --- a/src/libgit2/commit_list.c +++ b/src/libgit2/commit_list.c @@ -125,7 +125,7 @@ static int commit_quick_parse( git_oid *parent_oid; git_commit *commit; git_commit__parse_options parse_opts = { - GIT_OID_SHA1, + walk->repo->oid_type, GIT_COMMIT_PARSE_QUICK }; size_t i; @@ -176,7 +176,9 @@ int git_commit_list_parse(git_revwalk *walk, git_commit_list_node *commit) if (cgraph_file) { git_commit_graph_entry e; - error = git_commit_graph_entry_find(&e, cgraph_file, &commit->oid, GIT_OID_SHA1_SIZE); + error = git_commit_graph_entry_find(&e, cgraph_file, + &commit->oid, git_oid_size(walk->repo->oid_type)); + if (error == 0 && git__is_uint16(e.parent_count)) { size_t i; commit->generation = (uint32_t)e.generation; From a47bc4eacbe9c1d4e8e546fba7abcd22fca537b1 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 8 Apr 2023 21:32:45 +0100 Subject: [PATCH 231/608] email: support sha256 --- src/libgit2/email.c | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/src/libgit2/email.c b/src/libgit2/email.c index 0a75021c8db..8a10a12b75f 100644 --- a/src/libgit2/email.c +++ b/src/libgit2/email.c @@ -130,11 +130,12 @@ static int append_header( const git_signature *author, git_email_create_options *opts) { - char id[GIT_OID_SHA1_HEXSIZE]; + char id[GIT_OID_MAX_HEXSIZE + 1]; int error; - if ((error = git_oid_fmt(id, commit_id)) < 0 || - (error = git_str_printf(out, "From %.*s %s\n", GIT_OID_SHA1_HEXSIZE, id, EMAIL_TIMESTAMP)) < 0 || + git_oid_tostr(id, GIT_OID_MAX_HEXSIZE + 1, commit_id); + + if ((error = git_str_printf(out, "From %s %s\n", id, EMAIL_TIMESTAMP)) < 0 || (error = git_str_printf(out, "From: %s <%s>\n", author->name, author->email)) < 0 || (error = append_date(out, &author->when)) < 0 || (error = append_subject(out, patch_idx, patch_count, summary, opts)) < 0) From cf06de46edcabd43a642a51e31480ed1ff29bd4b Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sun, 9 Apr 2023 22:10:49 +0100 Subject: [PATCH 232/608] iterator: support sha256 --- src/libgit2/iterator.c | 25 ++++++++++++++++++++----- src/libgit2/iterator.h | 3 +++ src/libgit2/refdb_fs.c | 5 ++++- 3 files changed, 27 insertions(+), 6 deletions(-) diff --git a/src/libgit2/iterator.c b/src/libgit2/iterator.c index 1ee8e25f505..95ded1046dc 100644 --- a/src/libgit2/iterator.c +++ b/src/libgit2/iterator.c @@ -1036,6 +1036,8 @@ typedef struct { git_index *index; git_vector index_snapshot; + git_oid_t oid_type; + git_array_t(filesystem_iterator_frame) frames; git_ignores ignores; @@ -1271,7 +1273,7 @@ static int filesystem_iterator_entry_hash( int error; if (S_ISDIR(entry->st.st_mode)) { - memset(&entry->id, 0, GIT_OID_SHA1_SIZE); + memset(&entry->id, 0, git_oid_size(iter->oid_type)); return 0; } @@ -1281,7 +1283,7 @@ static int filesystem_iterator_entry_hash( if (!(error = git_str_joinpath(&fullpath, iter->root, entry->path)) && !(error = git_path_validate_str_length(iter->base.repo, &fullpath))) - error = git_odb__hashfile(&entry->id, fullpath.ptr, GIT_OBJECT_BLOB, GIT_OID_SHA1); + error = git_odb__hashfile(&entry->id, fullpath.ptr, GIT_OBJECT_BLOB, iter->oid_type); git_str_dispose(&fullpath); return error; @@ -1530,7 +1532,7 @@ static void filesystem_iterator_set_current( if (iter->base.flags & GIT_ITERATOR_INCLUDE_HASH) git_oid_cpy(&iter->entry.id, &entry->id); else - git_oid_clear(&iter->entry.id, GIT_OID_SHA1); + git_oid_clear(&iter->entry.id, iter->oid_type); iter->entry.path = entry->path; @@ -1975,6 +1977,8 @@ static int iterator_for_filesystem( (iterator__flag(&iter->base, PRECOMPOSE_UNICODE) ? GIT_FS_PATH_DIR_PRECOMPOSE_UNICODE : 0); + iter->oid_type = options->oid_type; + if ((error = filesystem_iterator_init(iter)) < 0) goto on_error; @@ -1989,10 +1993,15 @@ static int iterator_for_filesystem( int git_iterator_for_filesystem( git_iterator **out, const char *root, - git_iterator_options *options) + git_iterator_options *given_opts) { + git_iterator_options options = GIT_ITERATOR_OPTIONS_INIT; + + if (given_opts) + memcpy(&options, given_opts, sizeof(git_iterator_options)); + return iterator_for_filesystem(out, - NULL, root, NULL, NULL, GIT_ITERATOR_FS, options); + NULL, root, NULL, NULL, GIT_ITERATOR_FS, &options); } int git_iterator_for_workdir_ext( @@ -2019,6 +2028,12 @@ int git_iterator_for_workdir_ext( options.flags |= GIT_ITERATOR_HONOR_IGNORES | GIT_ITERATOR_IGNORE_DOT_GIT; + if (!options.oid_type) + options.oid_type = repo->oid_type; + else if (options.oid_type != repo->oid_type) + git_error_set(GIT_ERROR_INVALID, + "specified object ID type does not match repository object ID type"); + return iterator_for_filesystem(out, repo, repo_workdir, index, tree, GIT_ITERATOR_WORKDIR, &options); } diff --git a/src/libgit2/iterator.h b/src/libgit2/iterator.h index 6bb8489d035..7963ce7e22c 100644 --- a/src/libgit2/iterator.h +++ b/src/libgit2/iterator.h @@ -63,6 +63,9 @@ typedef struct { /* flags, from above */ unsigned int flags; + + /* oid type - necessary for non-workdir filesystem iterators */ + git_oid_t oid_type; } git_iterator_options; #define GIT_ITERATOR_OPTIONS_INIT {0} diff --git a/src/libgit2/refdb_fs.c b/src/libgit2/refdb_fs.c index 6000dafb3fc..c5b292ae329 100644 --- a/src/libgit2/refdb_fs.c +++ b/src/libgit2/refdb_fs.c @@ -805,7 +805,9 @@ static void refdb_fs_backend__iterator_free(git_reference_iterator *_iter) git__free(iter); } -static int iter_load_loose_paths(refdb_fs_backend *backend, refdb_fs_iter *iter) +static int iter_load_loose_paths( + refdb_fs_backend *backend, + refdb_fs_iter *iter) { int error = 0; git_str path = GIT_STR_INIT; @@ -819,6 +821,7 @@ static int iter_load_loose_paths(refdb_fs_backend *backend, refdb_fs_iter *iter) return 0; fsit_opts.flags = backend->iterator_flags; + fsit_opts.oid_type = backend->oid_type; if (iter->glob) { const char *last_sep = NULL; From 26b9c0564b6ba27b4587e667cc30a938e8878152 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sun, 9 Apr 2023 22:13:45 +0100 Subject: [PATCH 233/608] ident: support sha256 --- src/libgit2/ident.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/libgit2/ident.c b/src/libgit2/ident.c index bf9a4998e55..97110c66410 100644 --- a/src/libgit2/ident.c +++ b/src/libgit2/ident.c @@ -42,7 +42,7 @@ static int ident_find_id( static int ident_insert_id( git_str *to, const git_str *from, const git_filter_source *src) { - char oid[GIT_OID_SHA1_HEXSIZE+1]; + char oid[GIT_OID_MAX_HEXSIZE + 1]; const char *id_start, *id_end, *from_end = from->ptr + from->size; size_t need_size; @@ -57,7 +57,7 @@ static int ident_insert_id( return GIT_PASSTHROUGH; need_size = (size_t)(id_start - from->ptr) + - 5 /* "$Id: " */ + GIT_OID_SHA1_HEXSIZE + 2 /* " $" */ + + 5 /* "$Id: " */ + GIT_OID_MAX_HEXSIZE + 2 /* " $" */ + (size_t)(from_end - id_end); if (git_str_grow(to, need_size) < 0) @@ -65,7 +65,7 @@ static int ident_insert_id( git_str_set(to, from->ptr, (size_t)(id_start - from->ptr)); git_str_put(to, "$Id: ", 5); - git_str_put(to, oid, GIT_OID_SHA1_HEXSIZE); + git_str_puts(to, oid); git_str_put(to, " $", 2); git_str_put(to, id_end, (size_t)(from_end - id_end)); From 87727409b5a497f0419b5135dff441b7a6213f67 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sun, 9 Apr 2023 22:26:03 +0100 Subject: [PATCH 234/608] blame: support sha256 --- src/libgit2/blame.c | 39 +++++++++++++++++++++++---------------- 1 file changed, 23 insertions(+), 16 deletions(-) diff --git a/src/libgit2/blame.c b/src/libgit2/blame.c index b70cd615ec8..d93dd5e76b1 100644 --- a/src/libgit2/blame.c +++ b/src/libgit2/blame.c @@ -60,10 +60,11 @@ static bool hunk_starts_at_or_after_line(git_blame_hunk *hunk, size_t line) } static git_blame_hunk *new_hunk( - size_t start, - size_t lines, - size_t orig_start, - const char *path) + size_t start, + size_t lines, + size_t orig_start, + const char *path, + git_blame *blame) { git_blame_hunk *hunk = git__calloc(1, sizeof(git_blame_hunk)); if (!hunk) return NULL; @@ -72,8 +73,8 @@ static git_blame_hunk *new_hunk( hunk->final_start_line_number = start; hunk->orig_start_line_number = orig_start; hunk->orig_path = path ? git__strdup(path) : NULL; - git_oid_clear(&hunk->orig_commit_id, GIT_OID_SHA1); - git_oid_clear(&hunk->final_commit_id, GIT_OID_SHA1); + git_oid_clear(&hunk->orig_commit_id, blame->repository->oid_type); + git_oid_clear(&hunk->final_commit_id, blame->repository->oid_type); return hunk; } @@ -86,13 +87,14 @@ static void free_hunk(git_blame_hunk *hunk) git__free(hunk); } -static git_blame_hunk *dup_hunk(git_blame_hunk *hunk) +static git_blame_hunk *dup_hunk(git_blame_hunk *hunk, git_blame *blame) { git_blame_hunk *newhunk = new_hunk( hunk->final_start_line_number, hunk->lines_in_hunk, hunk->orig_start_line_number, - hunk->orig_path); + hunk->orig_path, + blame); if (!newhunk) return NULL; @@ -237,7 +239,8 @@ static git_blame_hunk *split_hunk_in_vector( git_vector *vec, git_blame_hunk *hunk, size_t rel_line, - bool return_new) + bool return_new, + git_blame *blame) { size_t new_line_count; git_blame_hunk *nh; @@ -250,8 +253,9 @@ static git_blame_hunk *split_hunk_in_vector( } new_line_count = hunk->lines_in_hunk - rel_line; - nh = new_hunk(hunk->final_start_line_number + rel_line, new_line_count, - hunk->orig_start_line_number + rel_line, hunk->orig_path); + nh = new_hunk(hunk->final_start_line_number + rel_line, + new_line_count, hunk->orig_start_line_number + rel_line, + hunk->orig_path, blame); if (!nh) return NULL; @@ -304,7 +308,8 @@ static int index_blob_lines(git_blame *blame) static git_blame_hunk *hunk_from_entry(git_blame__entry *e, git_blame *blame) { git_blame_hunk *h = new_hunk( - e->lno+1, e->num_lines, e->s_lno+1, e->suspect->path); + e->lno+1, e->num_lines, e->s_lno+1, e->suspect->path, + blame); if (!h) return NULL; @@ -445,14 +450,16 @@ static int buffer_hunk_cb( blame->current_hunk = (git_blame_hunk*)git_blame_get_hunk_byline(blame, wedge_line); if (!blame->current_hunk) { /* Line added at the end of the file */ - blame->current_hunk = new_hunk(wedge_line, 0, wedge_line, blame->path); + blame->current_hunk = new_hunk(wedge_line, 0, wedge_line, + blame->path, blame); GIT_ERROR_CHECK_ALLOC(blame->current_hunk); git_vector_insert(&blame->hunks, blame->current_hunk); } else if (!hunk_starts_at_or_after_line(blame->current_hunk, wedge_line)){ /* If this hunk doesn't start between existing hunks, split a hunk up so it does */ blame->current_hunk = split_hunk_in_vector(&blame->hunks, blame->current_hunk, - wedge_line - blame->current_hunk->orig_start_line_number, true); + wedge_line - blame->current_hunk->orig_start_line_number, true, + blame); GIT_ERROR_CHECK_ALLOC(blame->current_hunk); } @@ -481,7 +488,7 @@ static int buffer_line_cb( } else { /* Create a new buffer-blame hunk with this line */ shift_hunks_by(&blame->hunks, blame->current_diff_line, 1); - blame->current_hunk = new_hunk(blame->current_diff_line, 1, 0, blame->path); + blame->current_hunk = new_hunk(blame->current_diff_line, 1, 0, blame->path, blame); GIT_ERROR_CHECK_ALLOC(blame->current_hunk); git_vector_insert_sorted(&blame->hunks, blame->current_hunk, NULL); @@ -529,7 +536,7 @@ int git_blame_buffer( /* Duplicate all of the hunk structures in the reference blame */ git_vector_foreach(&reference->hunks, i, hunk) { - git_blame_hunk *h = dup_hunk(hunk); + git_blame_hunk *h = dup_hunk(hunk, blame); GIT_ERROR_CHECK_ALLOC(h); git_vector_insert(&blame->hunks, h); From be484d355b1b41748689fd29381bdcdcbd4c45bb Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 10 Apr 2023 09:47:05 +0100 Subject: [PATCH 235/608] midx: support sha256 --- include/git2/sys/midx.h | 6 ++- src/libgit2/midx.c | 92 +++++++++++++++++++++++++++------------ src/libgit2/midx.h | 16 +++++-- src/libgit2/odb_pack.c | 11 ++++- tests/libgit2/pack/midx.c | 7 ++- 5 files changed, 96 insertions(+), 36 deletions(-) diff --git a/include/git2/sys/midx.h b/include/git2/sys/midx.h index e3d7498298c..3a87484d2b5 100644 --- a/include/git2/sys/midx.h +++ b/include/git2/sys/midx.h @@ -29,7 +29,11 @@ GIT_BEGIN_DECL */ GIT_EXTERN(int) git_midx_writer_new( git_midx_writer **out, - const char *pack_dir); + const char *pack_dir +#ifdef GIT_EXPERIMENTAL_SHA256 + , git_oid_t oid_type +#endif + ); /** * Free the multi-pack-index writer and its resources. diff --git a/src/libgit2/midx.c b/src/libgit2/midx.c index b0905523713..f6071f0bbbd 100644 --- a/src/libgit2/midx.c +++ b/src/libgit2/midx.c @@ -115,19 +115,20 @@ static int midx_parse_oid_lookup( struct git_midx_chunk *chunk_oid_lookup) { uint32_t i; - unsigned char *oid, *prev_oid, zero_oid[GIT_OID_SHA1_SIZE] = {0}; + unsigned char *oid, *prev_oid, zero_oid[GIT_OID_MAX_SIZE] = {0}; + size_t oid_size = git_oid_size(idx->oid_type); if (chunk_oid_lookup->offset == 0) return midx_error("missing OID Lookup chunk"); if (chunk_oid_lookup->length == 0) return midx_error("empty OID Lookup chunk"); - if (chunk_oid_lookup->length != idx->num_objects * GIT_OID_SHA1_SIZE) + if (chunk_oid_lookup->length != idx->num_objects * oid_size) return midx_error("OID Lookup chunk has wrong length"); idx->oid_lookup = oid = (unsigned char *)(data + chunk_oid_lookup->offset); prev_oid = zero_oid; - for (i = 0; i < idx->num_objects; ++i, oid += GIT_OID_SHA1_SIZE) { - if (git_oid_raw_cmp(prev_oid, oid, GIT_OID_SHA1_SIZE) >= 0) + for (i = 0; i < idx->num_objects; ++i, oid += oid_size) { + if (git_oid_raw_cmp(prev_oid, oid, oid_size) >= 0) return midx_error("OID Lookup index is non-monotonic"); prev_oid = oid; } @@ -178,7 +179,7 @@ int git_midx_parse( struct git_midx_chunk *last_chunk; uint32_t i; off64_t last_chunk_offset, chunk_offset, trailer_offset; - size_t checksum_size; + size_t checksum_size, oid_size; int error; struct git_midx_chunk chunk_packfile_names = {0}, chunk_oid_fanout = {0}, @@ -188,7 +189,9 @@ int git_midx_parse( GIT_ASSERT_ARG(idx); - if (size < sizeof(struct git_midx_header) + GIT_OID_SHA1_SIZE) + oid_size = git_oid_size(idx->oid_type); + + if (size < sizeof(struct git_midx_header) + oid_size) return midx_error("multi-pack index is too short"); hdr = ((struct git_midx_header *)data); @@ -209,7 +212,7 @@ int git_midx_parse( sizeof(struct git_midx_header) + (1 + hdr->chunks) * 12; - checksum_size = GIT_HASH_SHA1_SIZE; + checksum_size = oid_size; trailer_offset = size - checksum_size; if (trailer_offset < last_chunk_offset) @@ -287,8 +290,9 @@ int git_midx_parse( } int git_midx_open( - git_midx_file **idx_out, - const char *path) + git_midx_file **idx_out, + const char *path, + git_oid_t oid_type) { git_midx_file *idx; git_file fd = -1; @@ -296,6 +300,8 @@ int git_midx_open( struct stat st; int error; + GIT_ASSERT_ARG(idx_out && path && oid_type); + /* TODO: properly open the file without access time using O_NOATIME */ fd = git_futils_open_ro(path); if (fd < 0) @@ -317,6 +323,8 @@ int git_midx_open( idx = git__calloc(1, sizeof(git_midx_file)); GIT_ERROR_CHECK_ALLOC(idx); + idx->oid_type = oid_type; + error = git_str_sets(&idx->filename, path); if (error < 0) return error; @@ -344,7 +352,7 @@ bool git_midx_needs_refresh( git_file fd = -1; struct stat st; ssize_t bytes_read; - unsigned char checksum[GIT_HASH_SHA1_SIZE]; + unsigned char checksum[GIT_HASH_MAX_SIZE]; size_t checksum_size; /* TODO: properly open the file without access time using O_NOATIME */ @@ -364,8 +372,8 @@ bool git_midx_needs_refresh( return true; } - checksum_size = GIT_HASH_SHA1_SIZE; - bytes_read = p_pread(fd, checksum, checksum_size, st.st_size - GIT_OID_SHA1_SIZE); + checksum_size = git_oid_size(idx->oid_type); + bytes_read = p_pread(fd, checksum, checksum_size, st.st_size - checksum_size); p_close(fd); if (bytes_read != (ssize_t)checksum_size) @@ -381,7 +389,7 @@ int git_midx_entry_find( size_t len) { int pos, found = 0; - size_t pack_index; + size_t pack_index, oid_size, oid_hexsize; uint32_t hi, lo; unsigned char *current = NULL; const unsigned char *object_offset; @@ -389,30 +397,33 @@ int git_midx_entry_find( GIT_ASSERT_ARG(idx); + oid_size = git_oid_size(idx->oid_type); + oid_hexsize = git_oid_hexsize(idx->oid_type); + hi = ntohl(idx->oid_fanout[(int)short_oid->id[0]]); lo = ((short_oid->id[0] == 0x0) ? 0 : ntohl(idx->oid_fanout[(int)short_oid->id[0] - 1])); - pos = git_pack__lookup_id(idx->oid_lookup, GIT_OID_SHA1_SIZE, lo, hi, short_oid->id, GIT_OID_SHA1); + pos = git_pack__lookup_id(idx->oid_lookup, oid_size, lo, hi, short_oid->id, idx->oid_type); if (pos >= 0) { /* An object matching exactly the oid was found */ found = 1; - current = idx->oid_lookup + (pos * GIT_OID_SHA1_SIZE); + current = idx->oid_lookup + (pos * oid_size); } else { /* No object was found */ /* pos refers to the object with the "closest" oid to short_oid */ pos = -1 - pos; if (pos < (int)idx->num_objects) { - current = idx->oid_lookup + (pos * GIT_OID_SHA1_SIZE); + current = idx->oid_lookup + (pos * oid_size); if (!git_oid_raw_ncmp(short_oid->id, current, len)) found = 1; } } - if (found && len != GIT_OID_SHA1_HEXSIZE && pos + 1 < (int)idx->num_objects) { + if (found && len != oid_hexsize && pos + 1 < (int)idx->num_objects) { /* Check for ambiguousity */ - const unsigned char *next = current + GIT_OID_SHA1_SIZE; + const unsigned char *next = current + oid_size; if (!git_oid_raw_ncmp(short_oid->id, next, len)) found = 2; @@ -443,7 +454,7 @@ int git_midx_entry_find( return midx_error("invalid index into the packfile names table"); e->pack_index = pack_index; e->offset = offset; - git_oid__fromraw(&e->sha1, current, GIT_OID_SHA1); + git_oid__fromraw(&e->sha1, current, idx->oid_type); return 0; } @@ -453,13 +464,15 @@ int git_midx_foreach_entry( void *data) { git_oid oid; - size_t i; + size_t oid_size, i; int error; GIT_ASSERT_ARG(idx); + oid_size = git_oid_size(idx->oid_type); + for (i = 0; i < idx->num_objects; ++i) { - if ((error = git_oid__fromraw(&oid, &idx->oid_lookup[i * GIT_OID_SHA1_SIZE], GIT_OID_SHA1)) < 0) + if ((error = git_oid__fromraw(&oid, &idx->oid_lookup[i * oid_size], idx->oid_type)) < 0) return error; if ((error = cb(&oid, data)) != 0) @@ -501,9 +514,21 @@ static int packfile__cmp(const void *a_, const void *b_) int git_midx_writer_new( git_midx_writer **out, - const char *pack_dir) + const char *pack_dir +#ifdef GIT_EXPERIMENTAL_SHA256 + , git_oid_t oid_type +#endif + ) { - git_midx_writer *w = git__calloc(1, sizeof(git_midx_writer)); + git_midx_writer *w; + +#ifndef GIT_EXPERIMENTAL_SHA256 + git_oid_t oid_type = GIT_OID_SHA1; +#endif + + GIT_ASSERT_ARG(out && pack_dir && oid_type); + + w = git__calloc(1, sizeof(git_midx_writer)); GIT_ERROR_CHECK_ALLOC(w); if (git_str_sets(&w->pack_dir, pack_dir) < 0) { @@ -518,6 +543,8 @@ int git_midx_writer_new( return -1; } + w->oid_type = oid_type; + *out = w; return 0; } @@ -662,12 +689,13 @@ static int midx_write( oid_lookup = GIT_STR_INIT, object_offsets = GIT_STR_INIT, object_large_offsets = GIT_STR_INIT; - unsigned char checksum[GIT_HASH_SHA1_SIZE]; - size_t checksum_size; + unsigned char checksum[GIT_HASH_MAX_SIZE]; + size_t checksum_size, oid_size; git_midx_entry *entry; object_entry_array_t object_entries_array = GIT_ARRAY_INIT; git_vector object_entries = GIT_VECTOR_INIT; git_hash_ctx ctx; + git_hash_algorithm_t checksum_type; struct midx_write_hash_context hash_cb_data = {0}; hdr.signature = htonl(MIDX_SIGNATURE); @@ -679,10 +707,14 @@ static int midx_write( hash_cb_data.cb_data = cb_data; hash_cb_data.ctx = &ctx; - checksum_size = GIT_HASH_SHA1_SIZE; - error = git_hash_ctx_init(&ctx, GIT_HASH_ALGORITHM_SHA1); - if (error < 0) + oid_size = git_oid_size(w->oid_type); + + GIT_ASSERT((checksum_type = git_oid_algorithm(w->oid_type))); + checksum_size = git_hash_size(checksum_type); + + if ((error = git_hash_ctx_init(&ctx, checksum_type)) < 0) return error; + cb_data = &hash_cb_data; write_cb = midx_write_hash; @@ -749,7 +781,9 @@ static int midx_write( /* Fill the OID Lookup table. */ git_vector_foreach (&object_entries, i, entry) { - error = git_str_put(&oid_lookup, (char *)&entry->sha1.id, GIT_OID_SHA1_SIZE); + error = git_str_put(&oid_lookup, + (char *)&entry->sha1.id, oid_size); + if (error < 0) goto cleanup; } diff --git a/src/libgit2/midx.h b/src/libgit2/midx.h index bcb0d9a0abd..5107f69cba3 100644 --- a/src/libgit2/midx.h +++ b/src/libgit2/midx.h @@ -51,8 +51,14 @@ typedef struct git_midx_file { /* The number of entries in the Object Large Offsets table. Each entry has an 8-byte with an offset */ size_t num_object_large_offsets; - /* The trailer of the file. Contains the SHA1-checksum of the whole file. */ - unsigned char checksum[GIT_HASH_SHA1_SIZE]; + /* + * The trailer of the file. Contains the checksum of the whole + * file, in the repository's object format hash. + */ + unsigned char checksum[GIT_HASH_MAX_SIZE]; + + /* The type of object IDs in the midx. */ + git_oid_t oid_type; /* something like ".git/objects/pack/multi-pack-index". */ git_str filename; @@ -82,11 +88,15 @@ struct git_midx_writer { /* The list of `git_pack_file`s. */ git_vector packs; + + /* The object ID type of the writer. */ + git_oid_t oid_type; }; int git_midx_open( git_midx_file **idx_out, - const char *path); + const char *path, + git_oid_t oid_type); bool git_midx_needs_refresh( const git_midx_file *idx, const char *path); diff --git a/src/libgit2/odb_pack.c b/src/libgit2/odb_pack.c index c6151f4e729..fc533ae83e2 100644 --- a/src/libgit2/odb_pack.c +++ b/src/libgit2/odb_pack.c @@ -479,7 +479,9 @@ static int refresh_multi_pack_index(struct pack_backend *backend) } } - error = git_midx_open(&backend->midx, git_str_cstr(&midx_path)); + error = git_midx_open(&backend->midx, git_str_cstr(&midx_path), + backend->opts.oid_type); + git_str_dispose(&midx_path); if (error < 0) return error; @@ -798,7 +800,12 @@ static int pack_backend__writemidx(git_odb_backend *_backend) backend = (struct pack_backend *)_backend; - error = git_midx_writer_new(&w, backend->pack_folder); + error = git_midx_writer_new(&w, backend->pack_folder +#ifdef GIT_EXPERIMENTAL_SHA256 + , backend->opts.oid_type +#endif + ); + if (error < 0) return error; diff --git a/tests/libgit2/pack/midx.c b/tests/libgit2/pack/midx.c index f7d680165bc..4c4dfc51178 100644 --- a/tests/libgit2/pack/midx.c +++ b/tests/libgit2/pack/midx.c @@ -16,7 +16,7 @@ void test_pack_midx__parse(void) cl_git_pass(git_repository_open(&repo, cl_fixture("testrepo.git"))); cl_git_pass(git_str_joinpath(&midx_path, git_repository_path(repo), "objects/pack/multi-pack-index")); - cl_git_pass(git_midx_open(&idx, git_str_cstr(&midx_path))); + cl_git_pass(git_midx_open(&idx, git_str_cstr(&midx_path), GIT_OID_SHA1)); cl_assert_equal_i(git_midx_needs_refresh(idx, git_str_cstr(&midx_path)), 0); cl_git_pass(git_oid__fromstr(&id, "5001298e0c09ad9c34e4249bc5801c75e9754fa5", GIT_OID_SHA1)); @@ -57,7 +57,12 @@ void test_pack_midx__writer(void) cl_git_pass(git_repository_open(&repo, cl_fixture("testrepo.git"))); cl_git_pass(git_str_joinpath(&path, git_repository_path(repo), "objects/pack")); + +#ifdef GIT_EXPERIMENTAL_SHA256 + cl_git_pass(git_midx_writer_new(&w, git_str_cstr(&path), GIT_OID_SHA1)); +#else cl_git_pass(git_midx_writer_new(&w, git_str_cstr(&path))); +#endif cl_git_pass(git_midx_writer_add(w, "pack-d7c6adf9f61318f041845b01440d09aa7a91e1b5.idx")); cl_git_pass(git_midx_writer_add(w, "pack-d85f5d483273108c9d8dd0e4728ccf0b2982423a.idx")); From b899fda3d88dc92f50e73544fb7524a1c3c70354 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 10 Apr 2023 10:34:20 +0100 Subject: [PATCH 236/608] commit graph: support sha256 --- include/git2/sys/commit_graph.h | 14 ++- src/libgit2/commit_graph.c | 153 +++++++++++++++++++++--------- src/libgit2/commit_graph.h | 24 ++++- src/libgit2/odb.c | 3 +- tests/libgit2/graph/commitgraph.c | 17 +++- 5 files changed, 159 insertions(+), 52 deletions(-) diff --git a/include/git2/sys/commit_graph.h b/include/git2/sys/commit_graph.h index 823c7ed579b..06e045fcd2b 100644 --- a/include/git2/sys/commit_graph.h +++ b/include/git2/sys/commit_graph.h @@ -28,7 +28,13 @@ GIT_BEGIN_DECL * @param objects_dir the path to a git objects directory. * @return Zero on success; -1 on failure. */ -GIT_EXTERN(int) git_commit_graph_open(git_commit_graph **cgraph_out, const char *objects_dir); +GIT_EXTERN(int) git_commit_graph_open( + git_commit_graph **cgraph_out, + const char *objects_dir +#ifdef GIT_EXPERIMENTAL_SHA256 + , git_oid_t oid_type +#endif + ); /** * Frees commit-graph data. This should only be called when memory allocated @@ -50,7 +56,11 @@ GIT_EXTERN(void) git_commit_graph_free(git_commit_graph *cgraph); */ GIT_EXTERN(int) git_commit_graph_writer_new( git_commit_graph_writer **out, - const char *objects_info_dir); + const char *objects_info_dir +#ifdef GIT_EXPERIMENTAL_SHA256 + , git_oid_t oid_type +#endif + ); /** * Free the commit-graph writer and its resources. diff --git a/src/libgit2/commit_graph.c b/src/libgit2/commit_graph.c index bf557f7ad66..4edd7110640 100644 --- a/src/libgit2/commit_graph.c +++ b/src/libgit2/commit_graph.c @@ -138,19 +138,22 @@ static int commit_graph_parse_oid_lookup( struct git_commit_graph_chunk *chunk_oid_lookup) { uint32_t i; - unsigned char *oid, *prev_oid, zero_oid[GIT_OID_SHA1_SIZE] = {0}; + unsigned char *oid, *prev_oid, zero_oid[GIT_OID_MAX_SIZE] = {0}; + size_t oid_size; + + oid_size = git_oid_size(file->oid_type); if (chunk_oid_lookup->offset == 0) return commit_graph_error("missing OID Lookup chunk"); if (chunk_oid_lookup->length == 0) return commit_graph_error("empty OID Lookup chunk"); - if (chunk_oid_lookup->length != file->num_commits * GIT_OID_SHA1_SIZE) + if (chunk_oid_lookup->length != file->num_commits * oid_size) return commit_graph_error("OID Lookup chunk has wrong length"); file->oid_lookup = oid = (unsigned char *)(data + chunk_oid_lookup->offset); prev_oid = zero_oid; - for (i = 0; i < file->num_commits; ++i, oid += GIT_OID_SHA1_SIZE) { - if (git_oid_raw_cmp(prev_oid, oid, GIT_OID_SHA1_SIZE) >= 0) + for (i = 0; i < file->num_commits; ++i, oid += oid_size) { + if (git_oid_raw_cmp(prev_oid, oid, oid_size) >= 0) return commit_graph_error("OID Lookup index is non-monotonic"); prev_oid = oid; } @@ -163,11 +166,13 @@ static int commit_graph_parse_commit_data( const unsigned char *data, struct git_commit_graph_chunk *chunk_commit_data) { + size_t oid_size = git_oid_size(file->oid_type); + if (chunk_commit_data->offset == 0) return commit_graph_error("missing Commit Data chunk"); if (chunk_commit_data->length == 0) return commit_graph_error("empty Commit Data chunk"); - if (chunk_commit_data->length != file->num_commits * (GIT_OID_SHA1_SIZE + 16)) + if (chunk_commit_data->length != file->num_commits * (oid_size + 16)) return commit_graph_error("Commit Data chunk has wrong length"); file->commit_data = data + chunk_commit_data->offset; @@ -209,7 +214,9 @@ int git_commit_graph_file_parse( GIT_ASSERT_ARG(file); - if (size < sizeof(struct git_commit_graph_header) + GIT_OID_SHA1_SIZE) + checksum_size = git_oid_size(file->oid_type); + + if (size < sizeof(struct git_commit_graph_header) + checksum_size) return commit_graph_error("commit-graph is too short"); hdr = ((struct git_commit_graph_header *)data); @@ -226,8 +233,7 @@ int git_commit_graph_file_parse( * headers, and a special zero chunk. */ last_chunk_offset = sizeof(struct git_commit_graph_header) + (1 + hdr->chunks) * 12; - trailer_offset = size - GIT_OID_SHA1_SIZE; - checksum_size = GIT_HASH_SHA1_SIZE; + trailer_offset = size - checksum_size; if (trailer_offset < last_chunk_offset) return commit_graph_error("wrong commit-graph size"); @@ -295,25 +301,35 @@ int git_commit_graph_file_parse( return 0; } -int git_commit_graph_new(git_commit_graph **cgraph_out, const char *objects_dir, bool open_file) +int git_commit_graph_new( + git_commit_graph **cgraph_out, + const char *objects_dir, + bool open_file, + git_oid_t oid_type) { git_commit_graph *cgraph = NULL; int error = 0; GIT_ASSERT_ARG(cgraph_out); GIT_ASSERT_ARG(objects_dir); + GIT_ASSERT_ARG(oid_type); cgraph = git__calloc(1, sizeof(git_commit_graph)); GIT_ERROR_CHECK_ALLOC(cgraph); + cgraph->oid_type = oid_type; + error = git_str_joinpath(&cgraph->filename, objects_dir, "info/commit-graph"); if (error < 0) goto error; if (open_file) { - error = git_commit_graph_file_open(&cgraph->file, git_str_cstr(&cgraph->filename)); + error = git_commit_graph_file_open(&cgraph->file, + git_str_cstr(&cgraph->filename), oid_type); + if (error < 0) goto error; + cgraph->checked = 1; } @@ -326,14 +342,18 @@ int git_commit_graph_new(git_commit_graph **cgraph_out, const char *objects_dir, } int git_commit_graph_validate(git_commit_graph *cgraph) { - unsigned char checksum[GIT_HASH_SHA1_SIZE]; - size_t checksum_size = GIT_HASH_SHA1_SIZE; - size_t trailer_offset = cgraph->file->graph_map.len - checksum_size; + unsigned char checksum[GIT_HASH_MAX_SIZE]; + git_hash_algorithm_t checksum_type; + size_t checksum_size, trailer_offset; + + checksum_type = git_oid_algorithm(cgraph->oid_type); + checksum_size = git_hash_size(checksum_type); + trailer_offset = cgraph->file->graph_map.len - checksum_size; if (cgraph->file->graph_map.len < checksum_size) return commit_graph_error("map length too small"); - if (git_hash_buf(checksum, cgraph->file->graph_map.data, trailer_offset, GIT_HASH_ALGORITHM_SHA1) < 0) + if (git_hash_buf(checksum, cgraph->file->graph_map.data, trailer_offset, checksum_type) < 0) return commit_graph_error("could not calculate signature"); if (memcmp(checksum, cgraph->file->checksum, checksum_size) != 0) return commit_graph_error("index signature mismatch"); @@ -341,16 +361,32 @@ int git_commit_graph_validate(git_commit_graph *cgraph) { return 0; } -int git_commit_graph_open(git_commit_graph **cgraph_out, const char *objects_dir) +int git_commit_graph_open( + git_commit_graph **cgraph_out, + const char *objects_dir +#ifdef GIT_EXPERIMENTAL_SHA256 + , git_oid_t oid_type +#endif + ) { - int error = git_commit_graph_new(cgraph_out, objects_dir, true); - if (!error) { +#ifndef GIT_EXPERIMENTAL_SHA256 + git_oid_t oid_type = GIT_OID_SHA1; +#endif + int error; + + error = git_commit_graph_new(cgraph_out, objects_dir, true, + oid_type); + + if (!error) return git_commit_graph_validate(*cgraph_out); - } + return error; } -int git_commit_graph_file_open(git_commit_graph_file **file_out, const char *path) +int git_commit_graph_file_open( + git_commit_graph_file **file_out, + const char *path, + git_oid_t oid_type) { git_commit_graph_file *file; git_file fd = -1; @@ -379,6 +415,8 @@ int git_commit_graph_file_open(git_commit_graph_file **file_out, const char *pat file = git__calloc(1, sizeof(git_commit_graph_file)); GIT_ERROR_CHECK_ALLOC(file); + file->oid_type = oid_type; + error = git_futils_mmap_ro(&file->graph_map, fd, 0, cgraph_size); p_close(fd); if (error < 0) { @@ -395,7 +433,9 @@ int git_commit_graph_file_open(git_commit_graph_file **file_out, const char *pat return 0; } -int git_commit_graph_get_file(git_commit_graph_file **file_out, git_commit_graph *cgraph) +int git_commit_graph_get_file( + git_commit_graph_file **file_out, + git_commit_graph *cgraph) { if (!cgraph->checked) { int error = 0; @@ -405,7 +445,8 @@ int git_commit_graph_get_file(git_commit_graph_file **file_out, git_commit_graph cgraph->checked = 1; /* Best effort */ - error = git_commit_graph_file_open(&result, git_str_cstr(&cgraph->filename)); + error = git_commit_graph_file_open(&result, + git_str_cstr(&cgraph->filename), cgraph->oid_type); if (error < 0) return error; @@ -441,6 +482,7 @@ static int git_commit_graph_entry_get_byindex( size_t pos) { const unsigned char *commit_data; + size_t oid_size = git_oid_size(file->oid_type); GIT_ASSERT_ARG(e); GIT_ASSERT_ARG(file); @@ -450,15 +492,15 @@ static int git_commit_graph_entry_get_byindex( return GIT_ENOTFOUND; } - commit_data = file->commit_data + pos * (GIT_OID_SHA1_SIZE + 4 * sizeof(uint32_t)); - git_oid__fromraw(&e->tree_oid, commit_data, GIT_OID_SHA1); - e->parent_indices[0] = ntohl(*((uint32_t *)(commit_data + GIT_OID_SHA1_SIZE))); + commit_data = file->commit_data + pos * (oid_size + 4 * sizeof(uint32_t)); + git_oid__fromraw(&e->tree_oid, commit_data, file->oid_type); + e->parent_indices[0] = ntohl(*((uint32_t *)(commit_data + oid_size))); e->parent_indices[1] = ntohl( - *((uint32_t *)(commit_data + GIT_OID_SHA1_SIZE + sizeof(uint32_t)))); + *((uint32_t *)(commit_data + oid_size + sizeof(uint32_t)))); e->parent_count = (e->parent_indices[0] != GIT_COMMIT_GRAPH_MISSING_PARENT) + (e->parent_indices[1] != GIT_COMMIT_GRAPH_MISSING_PARENT); - e->generation = ntohl(*((uint32_t *)(commit_data + GIT_OID_SHA1_SIZE + 2 * sizeof(uint32_t)))); - e->commit_time = ntohl(*((uint32_t *)(commit_data + GIT_OID_SHA1_SIZE + 3 * sizeof(uint32_t)))); + e->generation = ntohl(*((uint32_t *)(commit_data + oid_size + 2 * sizeof(uint32_t)))); + e->commit_time = ntohl(*((uint32_t *)(commit_data + oid_size + 3 * sizeof(uint32_t)))); e->commit_time |= (e->generation & UINT64_C(0x3)) << UINT64_C(32); e->generation >>= 2u; @@ -485,7 +527,7 @@ static int git_commit_graph_entry_get_byindex( } } - git_oid__fromraw(&e->sha1, &file->oid_lookup[pos * GIT_OID_SHA1_SIZE], GIT_OID_SHA1); + git_oid__fromraw(&e->sha1, &file->oid_lookup[pos * oid_size], file->oid_type); return 0; } @@ -494,8 +536,8 @@ bool git_commit_graph_file_needs_refresh(const git_commit_graph_file *file, cons git_file fd = -1; struct stat st; ssize_t bytes_read; - unsigned char checksum[GIT_HASH_SHA1_SIZE]; - size_t checksum_size = GIT_HASH_SHA1_SIZE; + unsigned char checksum[GIT_HASH_MAX_SIZE]; + size_t checksum_size = git_oid_size(file->oid_type); /* TODO: properly open the file without access time using O_NOATIME */ fd = git_futils_open_ro(path); @@ -530,35 +572,40 @@ int git_commit_graph_entry_find( int pos, found = 0; uint32_t hi, lo; const unsigned char *current = NULL; + size_t oid_size, oid_hexsize; GIT_ASSERT_ARG(e); GIT_ASSERT_ARG(file); GIT_ASSERT_ARG(short_oid); + oid_size = git_oid_size(file->oid_type); + oid_hexsize = git_oid_hexsize(file->oid_type); + hi = ntohl(file->oid_fanout[(int)short_oid->id[0]]); lo = ((short_oid->id[0] == 0x0) ? 0 : ntohl(file->oid_fanout[(int)short_oid->id[0] - 1])); - pos = git_pack__lookup_id(file->oid_lookup, GIT_OID_SHA1_SIZE, lo, hi, short_oid->id, GIT_OID_SHA1); + pos = git_pack__lookup_id(file->oid_lookup, oid_size, lo, hi, + short_oid->id, file->oid_type); if (pos >= 0) { /* An object matching exactly the oid was found */ found = 1; - current = file->oid_lookup + (pos * GIT_OID_SHA1_SIZE); + current = file->oid_lookup + (pos * oid_size); } else { /* No object was found */ /* pos refers to the object with the "closest" oid to short_oid */ pos = -1 - pos; if (pos < (int)file->num_commits) { - current = file->oid_lookup + (pos * GIT_OID_SHA1_SIZE); + current = file->oid_lookup + (pos * oid_size); if (!git_oid_raw_ncmp(short_oid->id, current, len)) found = 1; } } - if (found && len != GIT_OID_SHA1_HEXSIZE && pos + 1 < (int)file->num_commits) { + if (found && len != oid_hexsize && pos + 1 < (int)file->num_commits) { /* Check for ambiguousity */ - const unsigned char *next = current + GIT_OID_SHA1_SIZE; + const unsigned char *next = current + oid_size; if (!git_oid_raw_ncmp(short_oid->id, next, len)) found = 2; @@ -637,11 +684,27 @@ static int packed_commit__cmp(const void *a_, const void *b_) return git_oid_cmp(&a->sha1, &b->sha1); } -int git_commit_graph_writer_new(git_commit_graph_writer **out, const char *objects_info_dir) +int git_commit_graph_writer_new( + git_commit_graph_writer **out, + const char *objects_info_dir +#ifdef GIT_EXPERIMENTAL_SHA256 + , git_oid_t oid_type +#endif + ) { - git_commit_graph_writer *w = git__calloc(1, sizeof(git_commit_graph_writer)); + git_commit_graph_writer *w; + +#ifndef GIT_EXPERIMENTAL_SHA256 + git_oid_t oid_type = GIT_OID_SHA1; +#endif + + GIT_ASSERT_ARG(out && objects_info_dir && oid_type); + + w = git__calloc(1, sizeof(git_commit_graph_writer)); GIT_ERROR_CHECK_ALLOC(w); + w->oid_type = oid_type; + if (git_str_sets(&w->objects_info_dir, objects_info_dir) < 0) { git__free(w); return -1; @@ -993,8 +1056,9 @@ static int commit_graph_write( off64_t offset; git_str oid_lookup = GIT_STR_INIT, commit_data = GIT_STR_INIT, extra_edge_list = GIT_STR_INIT; - unsigned char checksum[GIT_HASH_SHA1_SIZE]; - size_t checksum_size; + unsigned char checksum[GIT_HASH_MAX_SIZE]; + git_hash_algorithm_t checksum_type; + size_t checksum_size, oid_size; git_hash_ctx ctx; struct commit_graph_write_hash_context hash_cb_data = {0}; @@ -1007,8 +1071,11 @@ static int commit_graph_write( hash_cb_data.cb_data = cb_data; hash_cb_data.ctx = &ctx; - checksum_size = GIT_HASH_SHA1_SIZE; - error = git_hash_ctx_init(&ctx, GIT_HASH_ALGORITHM_SHA1); + oid_size = git_oid_size(w->oid_type); + checksum_type = git_oid_algorithm(w->oid_type); + checksum_size = git_hash_size(checksum_type); + + error = git_hash_ctx_init(&ctx, checksum_type); if (error < 0) return error; cb_data = &hash_cb_data; @@ -1035,7 +1102,7 @@ static int commit_graph_write( git_vector_foreach (&w->commits, i, packed_commit) { error = git_str_put(&oid_lookup, (const char *)&packed_commit->sha1.id, - GIT_OID_SHA1_SIZE); + oid_size); if (error < 0) goto cleanup; @@ -1052,7 +1119,7 @@ static int commit_graph_write( error = git_str_put(&commit_data, (const char *)&packed_commit->tree_oid.id, - GIT_OID_SHA1_SIZE); + oid_size); if (error < 0) goto cleanup; diff --git a/src/libgit2/commit_graph.h b/src/libgit2/commit_graph.h index 517abb2390b..ecf4379bdb6 100644 --- a/src/libgit2/commit_graph.h +++ b/src/libgit2/commit_graph.h @@ -30,6 +30,9 @@ typedef struct git_commit_graph_file { git_map graph_map; + /* The type of object IDs in the commit graph file. */ + git_oid_t oid_type; + /* The OID Fanout table. */ const uint32_t *oid_fanout; /* The total number of commits in the graph. */ @@ -84,10 +87,10 @@ typedef struct git_commit_graph_entry { /* The index within the Extra Edge List of any parent after the first two. */ size_t extra_parents_index; - /* The SHA-1 hash of the root tree of the commit. */ + /* The object ID of the root tree of the commit. */ git_oid tree_oid; - /* The SHA-1 hash of the requested commit. */ + /* The object ID hash of the requested commit. */ git_oid sha1; } git_commit_graph_entry; @@ -99,18 +102,28 @@ struct git_commit_graph { /* The underlying commit-graph file. */ git_commit_graph_file *file; + /* The object ID types in the commit graph. */ + git_oid_t oid_type; + /* Whether the commit-graph file was already checked for validity. */ bool checked; }; /** Create a new commit-graph, optionally opening the underlying file. */ -int git_commit_graph_new(git_commit_graph **cgraph_out, const char *objects_dir, bool open_file); +int git_commit_graph_new( + git_commit_graph **cgraph_out, + const char *objects_dir, + bool open_file, + git_oid_t oid_type); /** Validate the checksum of a commit graph */ int git_commit_graph_validate(git_commit_graph *cgraph); /** Open and validate a commit-graph file. */ -int git_commit_graph_file_open(git_commit_graph_file **file_out, const char *path); +int git_commit_graph_file_open( + git_commit_graph_file **file_out, + const char *path, + git_oid_t oid_type); /* * Attempt to get the git_commit_graph's commit-graph file. This object is @@ -134,6 +147,9 @@ struct git_commit_graph_writer { */ git_str objects_info_dir; + /* The object ID type of the commit graph. */ + git_oid_t oid_type; + /* The list of packed commits. */ git_vector commits; }; diff --git a/src/libgit2/odb.c b/src/libgit2/odb.c index 0fc48035af2..68872e1a197 100644 --- a/src/libgit2/odb.c +++ b/src/libgit2/odb.c @@ -748,7 +748,8 @@ int git_odb__add_default_backends( git_error_set(GIT_ERROR_ODB, "failed to acquire the odb lock"); return -1; } - if (!db->cgraph && git_commit_graph_new(&db->cgraph, objects_dir, false) < 0) { + if (!db->cgraph && + git_commit_graph_new(&db->cgraph, objects_dir, false, db->options.oid_type) < 0) { git_mutex_unlock(&db->lock); return -1; } diff --git a/tests/libgit2/graph/commitgraph.c b/tests/libgit2/graph/commitgraph.c index 82f7f936f97..53869d61db0 100644 --- a/tests/libgit2/graph/commitgraph.c +++ b/tests/libgit2/graph/commitgraph.c @@ -16,7 +16,7 @@ void test_graph_commitgraph__parse(void) cl_git_pass(git_repository_open(&repo, cl_fixture("testrepo.git"))); cl_git_pass(git_str_joinpath(&commit_graph_path, git_repository_path(repo), "objects/info/commit-graph")); - cl_git_pass(git_commit_graph_file_open(&file, git_str_cstr(&commit_graph_path))); + cl_git_pass(git_commit_graph_file_open(&file, git_str_cstr(&commit_graph_path), GIT_OID_SHA1)); cl_assert_equal_i(git_commit_graph_file_needs_refresh(file, git_str_cstr(&commit_graph_path)), 0); cl_git_pass(git_oid__fromstr(&id, "5001298e0c09ad9c34e4249bc5801c75e9754fa5", GIT_OID_SHA1)); @@ -60,7 +60,7 @@ void test_graph_commitgraph__parse_octopus_merge(void) cl_git_pass(git_repository_open(&repo, cl_fixture("merge-recursive/.gitted"))); cl_git_pass(git_str_joinpath(&commit_graph_path, git_repository_path(repo), "objects/info/commit-graph")); - cl_git_pass(git_commit_graph_file_open(&file, git_str_cstr(&commit_graph_path))); + cl_git_pass(git_commit_graph_file_open(&file, git_str_cstr(&commit_graph_path), GIT_OID_SHA1)); cl_git_pass(git_oid__fromstr(&id, "d71c24b3b113fd1d1909998c5bfe33b86a65ee03", GIT_OID_SHA1)); cl_git_pass(git_commit_graph_entry_find(&e, file, &id, GIT_OID_SHA1_HEXSIZE)); @@ -103,7 +103,12 @@ void test_graph_commitgraph__writer(void) cl_git_pass(git_repository_open(&repo, cl_fixture("testrepo.git"))); cl_git_pass(git_str_joinpath(&path, git_repository_path(repo), "objects/info")); + +#ifdef GIT_EXPERIMENTAL_SHA256 + cl_git_pass(git_commit_graph_writer_new(&w, git_str_cstr(&path), GIT_OID_SHA1)); +#else cl_git_pass(git_commit_graph_writer_new(&w, git_str_cstr(&path))); +#endif /* This is equivalent to `git commit-graph write --reachable`. */ cl_git_pass(git_revwalk_new(&walk, repo)); @@ -135,7 +140,11 @@ void test_graph_commitgraph__validate(void) cl_git_pass(git_str_joinpath(&objects_dir, git_repository_path(repo), "objects")); /* git_commit_graph_open() calls git_commit_graph_validate() */ +#ifdef GIT_EXPERIMENTAL_SHA256 + cl_git_pass(git_commit_graph_open(&cgraph, git_str_cstr(&objects_dir), GIT_OID_SHA1)); +#else cl_git_pass(git_commit_graph_open(&cgraph, git_str_cstr(&objects_dir))); +#endif git_commit_graph_free(cgraph); git_str_dispose(&objects_dir); @@ -158,7 +167,11 @@ void test_graph_commitgraph__validate_corrupt(void) cl_must_pass(p_close(fd)); /* git_commit_graph_open() calls git_commit_graph_validate() */ +#ifdef GIT_EXPERIMENTAL_SHA256 + cl_git_fail(git_commit_graph_open(&cgraph, cl_git_sandbox_path(1, "testrepo.git", "objects", NULL), GIT_OID_SHA1)); +#else cl_git_fail(git_commit_graph_open(&cgraph, cl_git_sandbox_path(1, "testrepo.git", "objects", NULL))); +#endif git_commit_graph_free(cgraph); git_repository_free(repo); From 54bcafeb1e1db31336ac834ad34f491d0eaf2b83 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Tue, 11 Apr 2023 10:13:46 +0100 Subject: [PATCH 237/608] config: return `GIT_ENOTFOUND` for missing programdata When the programdata path is missing, ensure that we pass down the `GIT_ENOTFOUND` error to the caller instead of converting it to a generic `-1`. --- src/libgit2/config.c | 7 +++++-- tests/libgit2/config/find.c | 11 +++++++++++ 2 files changed, 16 insertions(+), 2 deletions(-) create mode 100644 tests/libgit2/config/find.c diff --git a/src/libgit2/config.c b/src/libgit2/config.c index 6d15a8db6d4..23a8f9ffad1 100644 --- a/src/libgit2/config.c +++ b/src/libgit2/config.c @@ -1174,9 +1174,12 @@ int git_config__find_programdata(git_str *path) GIT_FS_PATH_OWNER_CURRENT_USER | GIT_FS_PATH_OWNER_ADMINISTRATOR; bool is_safe; + int error; + + if ((error = git_sysdir_find_programdata_file(path, GIT_CONFIG_FILENAME_PROGRAMDATA)) < 0) + return error; - if (git_sysdir_find_programdata_file(path, GIT_CONFIG_FILENAME_PROGRAMDATA) < 0 || - git_fs_path_owner_is(&is_safe, path->ptr, owner_level) < 0) + if (git_fs_path_owner_is(&is_safe, path->ptr, owner_level) < 0) return -1; if (!is_safe) { diff --git a/tests/libgit2/config/find.c b/tests/libgit2/config/find.c new file mode 100644 index 00000000000..7ca8ec767e1 --- /dev/null +++ b/tests/libgit2/config/find.c @@ -0,0 +1,11 @@ +#include "clar_libgit2.h" + +void test_config_find__one(void) +{ + git_buf buf = GIT_BUF_INIT; + + cl_git_fail_with(GIT_ENOTFOUND, git_config_find_global(&buf)); + cl_git_fail_with(GIT_ENOTFOUND, git_config_find_xdg(&buf)); + cl_git_fail_with(GIT_ENOTFOUND, git_config_find_system(&buf)); + cl_git_fail_with(GIT_ENOTFOUND, git_config_find_programdata(&buf)); +} From 363088309458e285d03a73e14d7f43a3983b54f9 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 23 Feb 2023 00:37:56 +0000 Subject: [PATCH 238/608] meta: the main branch is now v1.7.0 --- CMakeLists.txt | 2 +- include/git2/version.h | 10 +++++----- package.json | 2 +- 3 files changed, 7 insertions(+), 7 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index fa516753805..b505b181c34 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -6,7 +6,7 @@ cmake_minimum_required(VERSION 3.5.1) -project(libgit2 VERSION "1.6.3" LANGUAGES C) +project(libgit2 VERSION "1.7.0" LANGUAGES C) # Add find modules to the path set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${PROJECT_SOURCE_DIR}/cmake") diff --git a/include/git2/version.h b/include/git2/version.h index 78750740aca..bed47f51e49 100644 --- a/include/git2/version.h +++ b/include/git2/version.h @@ -11,16 +11,16 @@ * The version string for libgit2. This string follows semantic * versioning (v2) guidelines. */ -#define LIBGIT2_VERSION "1.6.3" +#define LIBGIT2_VERSION "1.7.0-alpha" /** The major version number for this version of libgit2. */ #define LIBGIT2_VER_MAJOR 1 /** The minor version number for this version of libgit2. */ -#define LIBGIT2_VER_MINOR 6 +#define LIBGIT2_VER_MINOR 7 /** The revision ("teeny") version number for this version of libgit2. */ -#define LIBGIT2_VER_REVISION 3 +#define LIBGIT2_VER_REVISION 0 /** The Windows DLL patch number for this version of libgit2. */ #define LIBGIT2_VER_PATCH 0 @@ -31,9 +31,9 @@ * a prerelease name like "beta" or "rc1". For final releases, this will * be `NULL`. */ -#define LIBGIT2_VER_PRERELEASE NULL +#define LIBGIT2_VER_PRERELEASE "alpha" /** The library ABI soversion for this version of libgit2. */ -#define LIBGIT2_SOVERSION "1.6" +#define LIBGIT2_SOVERSION "1.7" #endif diff --git a/package.json b/package.json index 5665b4edd02..398446ea5f4 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "libgit2", - "version": "1.6.3", + "version": "1.7.0-alpha", "repo": "https://github.com/libgit2/libgit2", "description": " A cross-platform, linkable library implementation of Git that you can use in your application.", "install": "mkdir build && cd build && cmake .. && cmake --build ." From dd15c615bde54eb02c5cec17257a83dcd8528371 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 22 Apr 2023 23:19:59 +0100 Subject: [PATCH 239/608] shallow: remove feature flag The opt mechanism isn't _really_ meant to be for feature flags, and it's weird to feature flag shallow / unshallow at all. --- include/git2/common.h | 6 +----- src/libgit2/commit.c | 5 +---- src/libgit2/grafts.c | 6 ++---- src/libgit2/grafts.h | 2 -- src/libgit2/libgit2.c | 4 ---- src/libgit2/repository.c | 2 +- tests/libgit2/clone/shallow.c | 2 -- tests/libgit2/grafts/basic.c | 2 -- tests/libgit2/grafts/shallow.c | 12 ------------ 9 files changed, 5 insertions(+), 36 deletions(-) diff --git a/include/git2/common.h b/include/git2/common.h index b09b078a1f7..f968deb233a 100644 --- a/include/git2/common.h +++ b/include/git2/common.h @@ -224,8 +224,7 @@ typedef enum { GIT_OPT_GET_OWNER_VALIDATION, GIT_OPT_SET_OWNER_VALIDATION, GIT_OPT_GET_HOMEDIR, - GIT_OPT_SET_HOMEDIR, - GIT_OPT_ENABLE_SHALLOW + GIT_OPT_SET_HOMEDIR } git_libgit2_opt_t; /** @@ -462,9 +461,6 @@ typedef enum { * > { "!noop", "newext" } indicates that the caller does not want * > to support repositories with the `noop` extension but does want * > to support repositories with the `newext` extension. - * - * opts(GIT_OPT_ENABLE_SHALLOW, int enabled) - * > Enable or disable shallow clone support completely. * * opts(GIT_OPT_GET_OWNER_VALIDATION, int *enabled) * > Gets the owner validation setting for repository diff --git a/src/libgit2/commit.c b/src/libgit2/commit.c index a7d83111509..f7be73acf3f 100644 --- a/src/libgit2/commit.c +++ b/src/libgit2/commit.c @@ -553,14 +553,11 @@ int git_commit__parse_ext( git_repository *repo = git_object_owner((git_object *)commit); git_commit_graft *graft; int error; - + if ((error = commit_parse(commit, git_odb_object_data(odb_obj), git_odb_object_size(odb_obj), parse_opts)) < 0) return error; - if (!git_shallow__enabled) - return 0; - /* Perform necessary grafts */ if (git_grafts_get(&graft, repo->grafts, git_odb_object_id(odb_obj)) != 0 && git_grafts_get(&graft, repo->shallow_grafts, git_odb_object_id(odb_obj)) != 0) diff --git a/src/libgit2/grafts.c b/src/libgit2/grafts.c index 7cbb1dd7683..13c33aad0e1 100644 --- a/src/libgit2/grafts.c +++ b/src/libgit2/grafts.c @@ -12,8 +12,6 @@ #include "oidarray.h" #include "parse.h" -bool git_shallow__enabled = false; - struct git_grafts { /* Map of `git_commit_graft`s */ git_oidmap *commits; @@ -97,13 +95,13 @@ int git_grafts_refresh(git_grafts *grafts) if (!grafts->path) return 0; - if ((error = git_futils_readbuffer_updated(&contents, grafts->path, + if ((error = git_futils_readbuffer_updated(&contents, grafts->path, (grafts->path_checksum).id, &updated)) < 0) { if (error == GIT_ENOTFOUND) { git_grafts_clear(grafts); error = 0; } - + goto cleanup; } diff --git a/src/libgit2/grafts.h b/src/libgit2/grafts.h index 4139438bba7..fc61468f576 100644 --- a/src/libgit2/grafts.h +++ b/src/libgit2/grafts.h @@ -19,8 +19,6 @@ typedef struct { typedef struct git_grafts git_grafts; -extern bool git_shallow__enabled; - int git_grafts_new(git_grafts **out); int git_grafts_from_file(git_grafts **out, const char *path); void git_grafts_free(git_grafts *grafts); diff --git a/src/libgit2/libgit2.c b/src/libgit2/libgit2.c index c5a9287fb6f..178880c9eb9 100644 --- a/src/libgit2/libgit2.c +++ b/src/libgit2/libgit2.c @@ -436,10 +436,6 @@ int git_libgit2_opts(int key, ...) error = git_sysdir_set(GIT_SYSDIR_HOME, va_arg(ap, const char *)); break; - case GIT_OPT_ENABLE_SHALLOW: - git_shallow__enabled = (va_arg(ap, int) != 0); - break; - default: git_error_set(GIT_ERROR_INVALID, "invalid option key"); error = -1; diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index 1e356c84e05..99982b724f0 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -1099,7 +1099,7 @@ int git_repository_open_ext( if (error < 0) goto cleanup; - if (git_shallow__enabled && (error = load_grafts(repo)) < 0) + if ((error = load_grafts(repo)) < 0) goto cleanup; if ((flags & GIT_REPOSITORY_OPEN_BARE) != 0) { diff --git a/tests/libgit2/clone/shallow.c b/tests/libgit2/clone/shallow.c index eacfe1bcfa6..28b0116fadc 100644 --- a/tests/libgit2/clone/shallow.c +++ b/tests/libgit2/clone/shallow.c @@ -4,12 +4,10 @@ void test_clone_shallow__initialize(void) { - cl_git_pass(git_libgit2_opts(GIT_OPT_ENABLE_SHALLOW, 1)); } void test_clone_shallow__cleanup(void) { - git_libgit2_opts(GIT_OPT_ENABLE_SHALLOW, 0); } static int remote_single_branch(git_remote **out, git_repository *repo, const char *name, const char *url, void *payload) diff --git a/tests/libgit2/grafts/basic.c b/tests/libgit2/grafts/basic.c index 5ad437b195c..fe747709715 100644 --- a/tests/libgit2/grafts/basic.c +++ b/tests/libgit2/grafts/basic.c @@ -7,13 +7,11 @@ static git_repository *g_repo; void test_grafts_basic__initialize(void) { - git_libgit2_opts(GIT_OPT_ENABLE_SHALLOW, 1); g_repo = cl_git_sandbox_init("grafted.git"); } void test_grafts_basic__cleanup(void) { - git_libgit2_opts(GIT_OPT_ENABLE_SHALLOW, 0); cl_git_sandbox_cleanup(); } diff --git a/tests/libgit2/grafts/shallow.c b/tests/libgit2/grafts/shallow.c index 8c272392243..5911a26aabc 100644 --- a/tests/libgit2/grafts/shallow.c +++ b/tests/libgit2/grafts/shallow.c @@ -7,25 +7,13 @@ static git_repository *g_repo; static git_oid g_shallow_oid; -void test_grafts_shallow__set_feature_flag(void) -{ - cl_git_pass(git_libgit2_opts(GIT_OPT_ENABLE_SHALLOW, 1)); -} - -void test_grafts_shallow__unset_feature_flag(void) -{ - cl_git_pass(git_libgit2_opts(GIT_OPT_ENABLE_SHALLOW, 0)); -} - void test_grafts_shallow__initialize(void) { - git_libgit2_opts(GIT_OPT_ENABLE_SHALLOW, 1); cl_git_pass(git_oid__fromstr(&g_shallow_oid, "be3563ae3f795b2b4353bcce3a527ad0a4f7f644", GIT_OID_SHA1)); } void test_grafts_shallow__cleanup(void) { - git_libgit2_opts(GIT_OPT_ENABLE_SHALLOW, 0); cl_git_sandbox_cleanup(); } From 6cec01b4d8498203ae3a03949ffd480845269a3d Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 22 Apr 2023 23:38:52 +0100 Subject: [PATCH 240/608] shallow: move tests to online --- tests/libgit2/{clone => online}/shallow.c | 16 ++++------------ 1 file changed, 4 insertions(+), 12 deletions(-) rename tests/libgit2/{clone => online}/shallow.c (94%) diff --git a/tests/libgit2/clone/shallow.c b/tests/libgit2/online/shallow.c similarity index 94% rename from tests/libgit2/clone/shallow.c rename to tests/libgit2/online/shallow.c index 28b0116fadc..a889a68cd6f 100644 --- a/tests/libgit2/clone/shallow.c +++ b/tests/libgit2/online/shallow.c @@ -2,14 +2,6 @@ #include "futils.h" #include "repository.h" -void test_clone_shallow__initialize(void) -{ -} - -void test_clone_shallow__cleanup(void) -{ -} - static int remote_single_branch(git_remote **out, git_repository *repo, const char *name, const char *url, void *payload) { GIT_UNUSED(payload); @@ -19,7 +11,7 @@ static int remote_single_branch(git_remote **out, git_repository *repo, const ch return 0; } -void test_clone_shallow__clone_depth_zero(void) +void test_online_shallow__clone_depth_zero(void) { git_str path = GIT_STR_INIT; git_repository *repo; @@ -45,7 +37,7 @@ void test_clone_shallow__clone_depth_zero(void) git_repository_free(repo); } -void test_clone_shallow__clone_depth_one(void) +void test_online_shallow__clone_depth_one(void) { git_str path = GIT_STR_INIT; git_repository *repo; @@ -86,7 +78,7 @@ void test_clone_shallow__clone_depth_one(void) git_repository_free(repo); } -void test_clone_shallow__clone_depth_five(void) +void test_online_shallow__clone_depth_five(void) { git_str path = GIT_STR_INIT; git_repository *repo; @@ -129,7 +121,7 @@ void test_clone_shallow__clone_depth_five(void) git_repository_free(repo); } -void test_clone_shallow__unshallow(void) +void test_online_shallow__unshallow(void) { git_str path = GIT_STR_INIT; git_repository *repo; From 48273490e7ccfaa56b784c69cb488111bd06f357 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 22 Apr 2023 23:42:41 +0100 Subject: [PATCH 241/608] shallow: use GIT_ASSERT (not assert) --- src/libgit2/grafts.c | 13 +++++++------ src/libgit2/repository.c | 11 ++++++----- 2 files changed, 13 insertions(+), 11 deletions(-) diff --git a/src/libgit2/grafts.c b/src/libgit2/grafts.c index 13c33aad0e1..1bfdc500e9f 100644 --- a/src/libgit2/grafts.c +++ b/src/libgit2/grafts.c @@ -75,7 +75,8 @@ void git_grafts_clear(git_grafts *grafts) { git_commit_graft *graft; - assert(grafts); + if (!grafts) + return; git_oidmap_foreach_value(grafts->commits, graft, { git__free(graft->parents.ptr); @@ -90,7 +91,7 @@ int git_grafts_refresh(git_grafts *grafts) git_str contents = GIT_STR_INIT; int error, updated = 0; - assert(grafts); + GIT_ASSERT_ARG(grafts); if (!grafts->path) return 0; @@ -168,7 +169,7 @@ int git_grafts_add(git_grafts *grafts, const git_oid *oid, git_array_oid_t paren int error; size_t i; - assert(grafts && oid); + GIT_ASSERT_ARG(grafts && oid); graft = git__calloc(1, sizeof(*graft)); GIT_ERROR_CHECK_ALLOC(graft); @@ -200,7 +201,7 @@ int git_grafts_remove(git_grafts *grafts, const git_oid *oid) git_commit_graft *graft; int error; - assert(grafts && oid); + GIT_ASSERT_ARG(grafts && oid); if ((graft = git_oidmap_get(grafts->commits, oid)) == NULL) return GIT_ENOTFOUND; @@ -216,7 +217,7 @@ int git_grafts_remove(git_grafts *grafts, const git_oid *oid) int git_grafts_get(git_commit_graft **out, git_grafts *grafts, const git_oid *oid) { - assert(out && grafts && oid); + GIT_ASSERT_ARG(out && grafts && oid); if ((*out = git_oidmap_get(grafts->commits, oid)) == NULL) return GIT_ENOTFOUND; return 0; @@ -228,7 +229,7 @@ int git_grafts_get_oids(git_array_oid_t *out, git_grafts *grafts) size_t i = 0; int error; - assert(out && grafts); + GIT_ASSERT_ARG(out && grafts); while ((error = git_oidmap_iterate(NULL, grafts->commits, &i, &oid)) == 0) { git_oid *cpy = git_array_alloc(*out); diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index 99982b724f0..3b6ecae243a 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -1613,14 +1613,16 @@ int git_repository_set_index(git_repository *repo, git_index *index) int git_repository_grafts__weakptr(git_grafts **out, git_repository *repo) { - assert(out && repo && repo->grafts); + GIT_ASSERT_ARG(out && repo); + GIT_ASSERT(repo->grafts); *out = repo->grafts; return 0; } int git_repository_shallow_grafts__weakptr(git_grafts **out, git_repository *repo) { - assert(out && repo && repo->shallow_grafts); + GIT_ASSERT_ARG(out && repo); + GIT_ASSERT(repo->shallow_grafts); *out = repo->shallow_grafts; return 0; } @@ -3672,7 +3674,7 @@ int git_repository__shallow_roots_write(git_repository *repo, git_array_oid_t ro git_oid *oid; int filebuf_hash, error = 0; - assert(repo); + GIT_ASSERT_ARG(repo); filebuf_hash = git_filebuf_hash_flags(git_oid_algorithm(GIT_OID_SHA1)); GIT_ASSERT(filebuf_hash); @@ -3695,9 +3697,8 @@ int git_repository__shallow_roots_write(git_repository *repo, git_array_oid_t ro goto on_error; } - if (git_array_size(roots) == 0) { + if (git_array_size(roots) == 0) remove(path.ptr); - } on_error: git_str_dispose(&path); From 3853ba8de64a0e774c6e73aacb5831707f841621 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 22 Apr 2023 23:55:44 +0100 Subject: [PATCH 242/608] smart: validate shallow/unshallow pkts --- src/libgit2/transports/smart_pkt.c | 30 ++++++++++++++++++++++++------ 1 file changed, 24 insertions(+), 6 deletions(-) diff --git a/src/libgit2/transports/smart_pkt.c b/src/libgit2/transports/smart_pkt.c index ec9764a87a6..e8c87cb8df8 100644 --- a/src/libgit2/transports/smart_pkt.c +++ b/src/libgit2/transports/smart_pkt.c @@ -444,11 +444,15 @@ static int shallow_pkt(git_pkt **out, const char *line, size_t len) GIT_ERROR_CHECK_ALLOC(pkt); pkt->type = GIT_PKT_SHALLOW; - line += 7; - len -= 7; + + if (git__prefixncmp(line, len, "shallow ")) + goto out_err; + + line += 8; + len -= 8; if (len >= GIT_OID_SHA1_HEXSIZE) { - git_oid__fromstr(&pkt->oid, line + 1, GIT_OID_SHA1); + git_oid__fromstr(&pkt->oid, line, GIT_OID_SHA1); line += GIT_OID_SHA1_HEXSIZE + 1; len -= GIT_OID_SHA1_HEXSIZE + 1; } @@ -456,6 +460,11 @@ static int shallow_pkt(git_pkt **out, const char *line, size_t len) *out = (git_pkt *) pkt; return 0; + +out_err: + git_error_set(GIT_ERROR_NET, "invalid packet line"); + git__free(pkt); + return -1; } static int unshallow_pkt(git_pkt **out, const char *line, size_t len) @@ -466,11 +475,15 @@ static int unshallow_pkt(git_pkt **out, const char *line, size_t len) GIT_ERROR_CHECK_ALLOC(pkt); pkt->type = GIT_PKT_UNSHALLOW; - line += 9; - len -= 9; + + if (git__prefixncmp(line, len, "unshallow ")) + goto out_err; + + line += 10; + len -= 10; if (len >= GIT_OID_SHA1_HEXSIZE) { - git_oid__fromstr(&pkt->oid, line + 1, GIT_OID_SHA1); + git_oid__fromstr(&pkt->oid, line, GIT_OID_SHA1); line += GIT_OID_SHA1_HEXSIZE + 1; len -= GIT_OID_SHA1_HEXSIZE + 1; } @@ -478,6 +491,11 @@ static int unshallow_pkt(git_pkt **out, const char *line, size_t len) *out = (git_pkt *) pkt; return 0; + +out_err: + git_error_set(GIT_ERROR_NET, "invalid packet line"); + git__free(pkt); + return -1; } static int parse_len(size_t *out, const char *line, size_t linelen) From 72139ef289383dafeea355ace222359c48d98563 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sun, 23 Apr 2023 00:07:06 +0100 Subject: [PATCH 243/608] shallow: don't assume SHA1 --- src/libgit2/repository.c | 6 ++- src/libgit2/transports/smart_pkt.c | 66 +++++++++++++++++++----------- 2 files changed, 46 insertions(+), 26 deletions(-) diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index 3b6ecae243a..a60fb23fa0a 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -3670,13 +3670,14 @@ int git_repository__shallow_roots_write(git_repository *repo, git_array_oid_t ro { git_filebuf file = GIT_FILEBUF_INIT; git_str path = GIT_STR_INIT; + char oid_str[GIT_OID_MAX_HEXSIZE + 1]; size_t idx; git_oid *oid; int filebuf_hash, error = 0; GIT_ASSERT_ARG(repo); - filebuf_hash = git_filebuf_hash_flags(git_oid_algorithm(GIT_OID_SHA1)); + filebuf_hash = git_filebuf_hash_flags(git_oid_algorithm(repo->oid_type)); GIT_ASSERT(filebuf_hash); if ((error = git_str_joinpath(&path, repo->gitdir, "shallow")) < 0) @@ -3686,7 +3687,8 @@ int git_repository__shallow_roots_write(git_repository *repo, git_array_oid_t ro goto on_error; git_array_foreach(roots, idx, oid) { - git_filebuf_write(&file, git_oid_tostr_s(oid), GIT_OID_SHA1_HEXSIZE); + git_oid_tostr(oid_str, sizeof(oid_str), oid); + git_filebuf_write(&file, oid_str, git_oid_hexsize(repo->oid_type)); git_filebuf_write(&file, "\n", 1); } diff --git a/src/libgit2/transports/smart_pkt.c b/src/libgit2/transports/smart_pkt.c index e8c87cb8df8..3199c18f000 100644 --- a/src/libgit2/transports/smart_pkt.c +++ b/src/libgit2/transports/smart_pkt.c @@ -44,9 +44,14 @@ static int flush_pkt(git_pkt **out) } /* the rest of the line will be useful for multi_ack and multi_ack_detailed */ -static int ack_pkt(git_pkt **out, const char *line, size_t len) +static int ack_pkt( + git_pkt **out, + const char *line, + size_t len, + git_pkt_parse_data *data) { git_pkt_ack *pkt; + size_t oid_hexsize = git_oid_hexsize(data->oid_type); pkt = git__calloc(1, sizeof(git_pkt_ack)); GIT_ERROR_CHECK_ALLOC(pkt); @@ -57,11 +62,11 @@ static int ack_pkt(git_pkt **out, const char *line, size_t len) line += 4; len -= 4; - if (len < GIT_OID_SHA1_HEXSIZE || - git_oid__fromstr(&pkt->oid, line, GIT_OID_SHA1) < 0) + if (len < oid_hexsize || + git_oid__fromstr(&pkt->oid, line, data->oid_type) < 0) goto out_err; - line += GIT_OID_SHA1_HEXSIZE; - len -= GIT_OID_SHA1_HEXSIZE; + line += oid_hexsize; + len -= oid_hexsize; if (len && line[0] == ' ') { line++; @@ -436,9 +441,14 @@ static int unpack_pkt(git_pkt **out, const char *line, size_t len) return 0; } -static int shallow_pkt(git_pkt **out, const char *line, size_t len) +static int shallow_pkt( + git_pkt **out, + const char *line, + size_t len, + git_pkt_parse_data *data) { git_pkt_shallow *pkt; + size_t oid_hexsize = git_oid_hexsize(data->oid_type); pkt = git__calloc(1, sizeof(git_pkt_shallow)); GIT_ERROR_CHECK_ALLOC(pkt); @@ -451,13 +461,14 @@ static int shallow_pkt(git_pkt **out, const char *line, size_t len) line += 8; len -= 8; - if (len >= GIT_OID_SHA1_HEXSIZE) { - git_oid__fromstr(&pkt->oid, line, GIT_OID_SHA1); - line += GIT_OID_SHA1_HEXSIZE + 1; - len -= GIT_OID_SHA1_HEXSIZE + 1; - } + if (len != oid_hexsize) + goto out_err; - *out = (git_pkt *) pkt; + git_oid__fromstr(&pkt->oid, line, data->oid_type); + line += oid_hexsize + 1; + len -= oid_hexsize + 1; + + *out = (git_pkt *)pkt; return 0; @@ -467,9 +478,14 @@ static int shallow_pkt(git_pkt **out, const char *line, size_t len) return -1; } -static int unshallow_pkt(git_pkt **out, const char *line, size_t len) +static int unshallow_pkt( + git_pkt **out, + const char *line, + size_t len, + git_pkt_parse_data *data) { git_pkt_shallow *pkt; + size_t oid_hexsize = git_oid_hexsize(data->oid_type); pkt = git__calloc(1, sizeof(git_pkt_shallow)); GIT_ERROR_CHECK_ALLOC(pkt); @@ -482,11 +498,12 @@ static int unshallow_pkt(git_pkt **out, const char *line, size_t len) line += 10; len -= 10; - if (len >= GIT_OID_SHA1_HEXSIZE) { - git_oid__fromstr(&pkt->oid, line, GIT_OID_SHA1); - line += GIT_OID_SHA1_HEXSIZE + 1; - len -= GIT_OID_SHA1_HEXSIZE + 1; - } + if (len != oid_hexsize) + goto out_err; + + git_oid__fromstr(&pkt->oid, line, data->oid_type); + line += oid_hexsize + 1; + len -= oid_hexsize + 1; *out = (git_pkt *) pkt; @@ -615,7 +632,7 @@ int git_pkt_parse_line( else if (*line == GIT_SIDE_BAND_ERROR) error = sideband_error_pkt(pkt, line, len); else if (!git__prefixncmp(line, len, "ACK")) - error = ack_pkt(pkt, line, len); + error = ack_pkt(pkt, line, len, data); else if (!git__prefixncmp(line, len, "NAK")) error = nak_pkt(pkt); else if (!git__prefixncmp(line, len, "ERR")) @@ -629,9 +646,9 @@ int git_pkt_parse_line( else if (!git__prefixncmp(line, len, "unpack")) error = unpack_pkt(pkt, line, len); else if (!git__prefixcmp(line, "shallow")) - error = shallow_pkt(pkt, line, len); + error = shallow_pkt(pkt, line, len, data); else if (!git__prefixcmp(line, "unshallow")) - error = unshallow_pkt(pkt, line, len); + error = unshallow_pkt(pkt, line, len, data); else error = ref_pkt(pkt, line, len, data); @@ -788,12 +805,13 @@ int git_pkt_buffer_wants( /* Tell the server about our shallow objects */ for (i = 0; i < git_shallowarray_count(wants->shallow_roots); i++) { - char oid[GIT_OID_SHA1_HEXSIZE]; + char oid[GIT_OID_MAX_HEXSIZE + 1]; git_str shallow_buf = GIT_STR_INIT; - git_oid_fmt(oid, git_shallowarray_get(wants->shallow_roots, i)); + git_oid_tostr(oid, GIT_OID_MAX_HEXSIZE + 1, + git_shallowarray_get(wants->shallow_roots, i)); git_str_puts(&shallow_buf, "shallow "); - git_str_put(&shallow_buf, oid, GIT_OID_SHA1_HEXSIZE); + git_str_puts(&shallow_buf, oid); git_str_putc(&shallow_buf, '\n'); git_str_printf(buf, "%04x%s", (unsigned int)git_str_len(&shallow_buf) + 4, git_str_cstr(&shallow_buf)); From d69c7a72386c9e01f4b0c8945724f870bf9aa4f6 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 24 Apr 2023 11:43:03 +0100 Subject: [PATCH 244/608] transport: transports understand oid type Teach the smart transport more about oid types, instead of assuming SHA1. --- src/libgit2/transports/smart_pkt.c | 6 ++++++ src/libgit2/transports/smart_protocol.c | 26 +++++++++++++++---------- tests/libgit2/transports/smart/packet.c | 4 ++-- 3 files changed, 24 insertions(+), 12 deletions(-) diff --git a/src/libgit2/transports/smart_pkt.c b/src/libgit2/transports/smart_pkt.c index 3199c18f000..f2c9eea8e5e 100644 --- a/src/libgit2/transports/smart_pkt.c +++ b/src/libgit2/transports/smart_pkt.c @@ -53,6 +53,8 @@ static int ack_pkt( git_pkt_ack *pkt; size_t oid_hexsize = git_oid_hexsize(data->oid_type); + GIT_ASSERT(data && data->oid_type); + pkt = git__calloc(1, sizeof(git_pkt_ack)); GIT_ERROR_CHECK_ALLOC(pkt); pkt->type = GIT_PKT_ACK; @@ -450,6 +452,8 @@ static int shallow_pkt( git_pkt_shallow *pkt; size_t oid_hexsize = git_oid_hexsize(data->oid_type); + GIT_ASSERT(data && data->oid_type); + pkt = git__calloc(1, sizeof(git_pkt_shallow)); GIT_ERROR_CHECK_ALLOC(pkt); @@ -487,6 +491,8 @@ static int unshallow_pkt( git_pkt_shallow *pkt; size_t oid_hexsize = git_oid_hexsize(data->oid_type); + GIT_ASSERT(data && data->oid_type); + pkt = git__calloc(1, sizeof(git_pkt_shallow)); GIT_ERROR_CHECK_ALLOC(pkt); diff --git a/src/libgit2/transports/smart_protocol.c b/src/libgit2/transports/smart_protocol.c index c37c3cc8dcb..eb2bc5be4f8 100644 --- a/src/libgit2/transports/smart_protocol.c +++ b/src/libgit2/transports/smart_protocol.c @@ -256,13 +256,20 @@ int git_smart__detect_caps( return 0; } -static int recv_pkt(git_pkt **out_pkt, git_pkt_type *out_type, gitno_buffer *buf) +static int recv_pkt( + git_pkt **out_pkt, + git_pkt_type *out_type, + transport_smart *t, + gitno_buffer *buf) { const char *ptr = buf->data, *line_end = ptr; git_pkt *pkt = NULL; git_pkt_parse_data pkt_parse_data = { 0 }; int error = 0, ret; + pkt_parse_data.oid_type = t->owner->repo->oid_type; + pkt_parse_data.seen_capabilities = 1; + do { if (buf->offset > 0) error = git_pkt_parse_line(&pkt, &line_end, ptr, buf->offset, &pkt_parse_data); @@ -303,7 +310,7 @@ static int store_common(transport_smart *t) int error; do { - if ((error = recv_pkt(&pkt, NULL, buf)) < 0) + if ((error = recv_pkt(&pkt, NULL, t, buf)) < 0) return error; if (pkt->type != GIT_PKT_ACK) { @@ -320,7 +327,7 @@ static int store_common(transport_smart *t) return 0; } -static int wait_while_ack(gitno_buffer *buf) +static int wait_while_ack(transport_smart *t, gitno_buffer *buf) { int error; git_pkt *pkt = NULL; @@ -329,7 +336,7 @@ static int wait_while_ack(gitno_buffer *buf) while (1) { git_pkt_free(pkt); - if ((error = recv_pkt(&pkt, NULL, buf)) < 0) + if ((error = recv_pkt(&pkt, NULL, t, buf)) < 0) return error; if (pkt->type == GIT_PKT_NAK) @@ -400,8 +407,7 @@ int git_smart__negotiate_fetch(git_transport *transport, git_repository *repo, c if ((error = git_smart__negotiation_step(&t->parent, data.ptr, data.size)) < 0) goto on_error; - while ((error = recv_pkt((git_pkt **)&pkt, NULL, buf)) == 0) { - + while ((error = recv_pkt((git_pkt **)&pkt, NULL, t, buf)) == 0) { if (pkt->type == GIT_PKT_SHALLOW) { git_shallowarray_add(wants->shallow_roots, &pkt->oid); } else if (pkt->type == GIT_PKT_UNSHALLOW) { @@ -463,7 +469,7 @@ int git_smart__negotiate_fetch(git_transport *transport, git_repository *repo, c if ((error = store_common(t)) < 0) goto on_error; } else { - if ((error = recv_pkt(NULL, &pkt_type, buf)) < 0) + if ((error = recv_pkt(NULL, &pkt_type, t, buf)) < 0) goto on_error; if (pkt_type == GIT_PKT_ACK) { @@ -535,7 +541,7 @@ int git_smart__negotiate_fetch(git_transport *transport, git_repository *repo, c /* Now let's eat up whatever the server gives us */ if (!t->caps.multi_ack && !t->caps.multi_ack_detailed) { - if ((error = recv_pkt(NULL, &pkt_type, buf)) < 0) + if ((error = recv_pkt(NULL, &pkt_type, t, buf)) < 0) return error; if (pkt_type != GIT_PKT_ACK && pkt_type != GIT_PKT_NAK) { @@ -543,7 +549,7 @@ int git_smart__negotiate_fetch(git_transport *transport, git_repository *repo, c return -1; } } else { - error = wait_while_ack(buf); + error = wait_while_ack(t, buf); } return error; @@ -659,7 +665,7 @@ int git_smart__download_pack( goto done; } - if ((error = recv_pkt(&pkt, NULL, buf)) >= 0) { + if ((error = recv_pkt(&pkt, NULL, t, buf)) >= 0) { /* Check cancellation after network call */ if (t->cancelled.val) { git_error_clear(); diff --git a/tests/libgit2/transports/smart/packet.c b/tests/libgit2/transports/smart/packet.c index 2035e3b65d0..a775a4cfab4 100644 --- a/tests/libgit2/transports/smart/packet.c +++ b/tests/libgit2/transports/smart/packet.c @@ -25,7 +25,7 @@ static void assert_data_pkt_parses(const char *line, const char *expected_data, size_t linelen = strlen(line) + 1; const char *endptr; git_pkt_data *pkt; - git_pkt_parse_data pkt_parse_data = { 0 }; + git_pkt_parse_data pkt_parse_data = { 1, GIT_OID_SHA1 }; cl_git_pass(git_pkt_parse_line((git_pkt **) &pkt, &endptr, line, linelen, &pkt_parse_data)); cl_assert_equal_i(pkt->type, GIT_PKT_DATA); @@ -71,7 +71,7 @@ static void assert_ack_parses(const char *line, const char *expected_oid, enum g const char *endptr; git_pkt_ack *pkt; git_oid oid; - git_pkt_parse_data pkt_parse_data = { 0 }; + git_pkt_parse_data pkt_parse_data = { 1, GIT_OID_SHA1 }; cl_git_pass(git_oid__fromstr(&oid, expected_oid, GIT_OID_SHA1)); From 47ebf589250159d6a98bd91625aefd2e1383ec26 Mon Sep 17 00:00:00 2001 From: Oliver Reiche Date: Wed, 3 May 2023 12:57:06 +0200 Subject: [PATCH 245/608] Fix missing oid type for "fake" repositories ... otherwise git_tree__parse_raw() will fail to obtain the correct oid size, which causes the entire parse to fail. --- src/libgit2/repository.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index 804e436abeb..c45c5855058 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -1152,6 +1152,8 @@ int git_repository_wrap_odb(git_repository **repo_out, git_odb *odb) repo = repository_alloc(); GIT_ERROR_CHECK_ALLOC(repo); + repo->oid_type = GIT_OID_DEFAULT; + git_repository_set_odb(repo, odb); *repo_out = repo; From f1ef8ebee3ee21afba3ad1ad1335d34371a61d05 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 5 May 2023 16:13:40 +0100 Subject: [PATCH 246/608] odb: test object lookups from git_repository_wrap_odb --- tests/libgit2/odb/backend/loose.c | 21 ++++++++++++++++++++- 1 file changed, 20 insertions(+), 1 deletion(-) diff --git a/tests/libgit2/odb/backend/loose.c b/tests/libgit2/odb/backend/loose.c index 781b61d9ff9..f5a0b4f5caf 100644 --- a/tests/libgit2/odb/backend/loose.c +++ b/tests/libgit2/odb/backend/loose.c @@ -32,7 +32,7 @@ void test_odb_backend_loose__cleanup(void) cl_fixture_cleanup("testrepo.git"); } -void test_odb_backend_loose__read(void) +void test_odb_backend_loose__read_from_odb(void) { git_oid oid; git_odb_object *obj; @@ -40,4 +40,23 @@ void test_odb_backend_loose__read(void) cl_git_pass(git_oid__fromstr(&oid, "1385f264afb75a56a5bec74243be9b367ba4ca08", GIT_OID_SHA1)); cl_git_pass(git_odb_read(&obj, _odb, &oid)); git_odb_object_free(obj); + + cl_git_pass(git_oid__fromstr(&oid, "fd093bff70906175335656e6ce6ae05783708765", GIT_OID_SHA1)); + cl_git_pass(git_odb_read(&obj, _odb, &oid)); + git_odb_object_free(obj); +} + +void test_odb_backend_loose__read_from_repo(void) +{ + git_oid oid; + git_blob *blob; + git_tree *tree; + + cl_git_pass(git_oid__fromstr(&oid, "1385f264afb75a56a5bec74243be9b367ba4ca08", GIT_OID_SHA1)); + cl_git_pass(git_blob_lookup(&blob, _repo, &oid)); + git_blob_free(blob); + + cl_git_pass(git_oid__fromstr(&oid, "fd093bff70906175335656e6ce6ae05783708765", GIT_OID_SHA1)); + cl_git_pass(git_tree_lookup(&tree, _repo, &oid)); + git_tree_free(tree); } From 161d8a12e70936222a55b5571098299957cdee04 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 5 May 2023 16:29:58 +0100 Subject: [PATCH 247/608] sha256: wrap_odb supports SHA256 --- include/git2/repository.h | 14 ++++++++++++-- src/libgit2/repository.c | 24 +++++++++++++++++++++--- src/libgit2/repository.h | 5 +++++ tests/libgit2/odb/backend/loose.c | 2 +- tests/libgit2/odb/backend/mempack.c | 2 +- tests/libgit2/refs/iterator.c | 3 ++- 6 files changed, 42 insertions(+), 8 deletions(-) diff --git a/include/git2/repository.h b/include/git2/repository.h index 560e70ab6df..6ec2ac8220c 100644 --- a/include/git2/repository.h +++ b/include/git2/repository.h @@ -56,9 +56,19 @@ GIT_EXTERN(int) git_repository_open_from_worktree(git_repository **out, git_work * * @param out pointer to the repo * @param odb the object database to wrap + * @param oid_type the oid type of the object database * @return 0 or an error code */ -GIT_EXTERN(int) git_repository_wrap_odb(git_repository **out, git_odb *odb); +#ifdef GIT_EXPERIMENTAL_SHA256 +GIT_EXTERN(int) git_repository_wrap_odb( + git_repository **out, + git_odb *odb, + git_oid_t oid_type); +#else +GIT_EXTERN(int) git_repository_wrap_odb( + git_repository **out, + git_odb *odb); +#endif /** * Look for a git repository and copy its path in the given buffer. @@ -536,7 +546,7 @@ GIT_EXTERN(const char *) git_repository_workdir(const git_repository *repo); /** * Get the path of the shared common directory for this repository. - * + * * If the repository is bare, it is the root directory for the repository. * If the repository is a worktree, it is the parent repo's gitdir. * Otherwise, it is the gitdir. diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index c45c5855058..473f3b146a9 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -1145,21 +1145,39 @@ int git_repository_open_from_worktree(git_repository **repo_out, git_worktree *w return err; } -int git_repository_wrap_odb(git_repository **repo_out, git_odb *odb) +int git_repository__wrap_odb( + git_repository **out, + git_odb *odb, + git_oid_t oid_type) { git_repository *repo; repo = repository_alloc(); GIT_ERROR_CHECK_ALLOC(repo); - repo->oid_type = GIT_OID_DEFAULT; + repo->oid_type = oid_type; git_repository_set_odb(repo, odb); - *repo_out = repo; + *out = repo; return 0; } +#ifdef GIT_EXPERIMENTAL_SHA256 +int git_repository_wrap_odb( + git_repository **out, + git_odb *odb, + git_oid_t oid_type) +{ + return git_repository__wrap_odb(out, odb, oid_type); +} +#else +int git_repository_wrap_odb(git_repository **out, git_odb *odb) +{ + return git_repository__wrap_odb(out, odb, GIT_OID_DEFAULT); +} +#endif + int git_repository_discover( git_buf *out, const char *start_path, diff --git a/src/libgit2/repository.h b/src/libgit2/repository.h index 9a36ef97210..b2208b8a695 100644 --- a/src/libgit2/repository.h +++ b/src/libgit2/repository.h @@ -190,6 +190,11 @@ int git_repository_odb__weakptr(git_odb **out, git_repository *repo); int git_repository_refdb__weakptr(git_refdb **out, git_repository *repo); int git_repository_index__weakptr(git_index **out, git_repository *repo); +int git_repository__wrap_odb( + git_repository **out, + git_odb *odb, + git_oid_t oid_type); + /* * Configuration map cache * diff --git a/tests/libgit2/odb/backend/loose.c b/tests/libgit2/odb/backend/loose.c index f5a0b4f5caf..02227945d71 100644 --- a/tests/libgit2/odb/backend/loose.c +++ b/tests/libgit2/odb/backend/loose.c @@ -21,7 +21,7 @@ void test_odb_backend_loose__initialize(void) cl_git_pass(git_odb__new(&_odb, NULL)); cl_git_pass(git_odb_add_backend(_odb, backend, 10)); - cl_git_pass(git_repository_wrap_odb(&_repo, _odb)); + cl_git_pass(git_repository__wrap_odb(&_repo, _odb, GIT_OID_SHA1)); } void test_odb_backend_loose__cleanup(void) diff --git a/tests/libgit2/odb/backend/mempack.c b/tests/libgit2/odb/backend/mempack.c index eb8ab3cb0b2..c8a86a2ae95 100644 --- a/tests/libgit2/odb/backend/mempack.c +++ b/tests/libgit2/odb/backend/mempack.c @@ -16,7 +16,7 @@ void test_odb_backend_mempack__initialize(void) cl_git_pass(git_mempack_new(&backend)); cl_git_pass(git_odb__new(&_odb, NULL)); cl_git_pass(git_odb_add_backend(_odb, backend, 10)); - cl_git_pass(git_repository_wrap_odb(&_repo, _odb)); + cl_git_pass(git_repository__wrap_odb(&_repo, _odb, GIT_OID_SHA1)); } void test_odb_backend_mempack__cleanup(void) diff --git a/tests/libgit2/refs/iterator.c b/tests/libgit2/refs/iterator.c index f40d35d1171..706fd1ef7e0 100644 --- a/tests/libgit2/refs/iterator.c +++ b/tests/libgit2/refs/iterator.c @@ -2,6 +2,7 @@ #include "refs.h" #include "vector.h" #include "odb.h" +#include "repository.h" static git_repository *repo; @@ -128,7 +129,7 @@ void test_refs_iterator__empty(void) git_repository *empty; cl_git_pass(git_odb__new(&odb, NULL)); - cl_git_pass(git_repository_wrap_odb(&empty, odb)); + cl_git_pass(git_repository__wrap_odb(&empty, odb, GIT_OID_SHA1)); cl_git_pass(git_reference_iterator_new(&iter, empty)); cl_assert_equal_i(GIT_ITEROVER, git_reference_next(&ref, iter)); From 8f7fc2ee505a0abe2186270a79b287e321c748c4 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 24 Apr 2023 11:16:47 +0100 Subject: [PATCH 248/608] shallow: avoid unnecessary pkt free Looks like a double-free here. --- src/libgit2/transports/smart_protocol.c | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-) diff --git a/src/libgit2/transports/smart_protocol.c b/src/libgit2/transports/smart_protocol.c index eb2bc5be4f8..6167a807409 100644 --- a/src/libgit2/transports/smart_protocol.c +++ b/src/libgit2/transports/smart_protocol.c @@ -408,26 +408,28 @@ int git_smart__negotiate_fetch(git_transport *transport, git_repository *repo, c goto on_error; while ((error = recv_pkt((git_pkt **)&pkt, NULL, t, buf)) == 0) { + bool complete = false; + if (pkt->type == GIT_PKT_SHALLOW) { git_shallowarray_add(wants->shallow_roots, &pkt->oid); } else if (pkt->type == GIT_PKT_UNSHALLOW) { git_shallowarray_remove(wants->shallow_roots, &pkt->oid); } else if (pkt->type == GIT_PKT_FLUSH) { /* Server is done, stop processing shallow oids */ - break; + complete = true; } else { - git_error_set(GIT_ERROR_NET, "Unexpected pkt type"); - goto on_error; + git_error_set(GIT_ERROR_NET, "unexpected packet type"); + error = -1; } git_pkt_free((git_pkt *) pkt); - } - git_pkt_free((git_pkt *) pkt); + if (complete || error < 0) + break; + } - if (error < 0) { + if (error < 0) goto on_error; - } } /* * Our support for ACK extensions is simply to parse them. On From 6a02b459ab1d9ca6eaeda96cce94ba5ce6f8eaea Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 24 Apr 2023 12:15:11 +0100 Subject: [PATCH 249/608] futils: use SHA256 for checksums always Use SHA256 for file checksums. SHA1 makes no sense as a default in 2023. Given that we're just looking at a file checksum to see if it's changed, this does not need to take repository's OID type into account or otherwise be configurable. --- src/libgit2/grafts.c | 5 +++-- src/util/futils.c | 13 ++++++++----- 2 files changed, 11 insertions(+), 7 deletions(-) diff --git a/src/libgit2/grafts.c b/src/libgit2/grafts.c index 1bfdc500e9f..ef314550d7d 100644 --- a/src/libgit2/grafts.c +++ b/src/libgit2/grafts.c @@ -18,7 +18,7 @@ struct git_grafts { /* File backing the graft. NULL if it's an in-memory graft */ char *path; - git_oid path_checksum; + unsigned char path_checksum[GIT_HASH_SHA256_SIZE]; }; int git_grafts_new(git_grafts **out) @@ -97,7 +97,8 @@ int git_grafts_refresh(git_grafts *grafts) return 0; if ((error = git_futils_readbuffer_updated(&contents, grafts->path, - (grafts->path_checksum).id, &updated)) < 0) { + grafts->path_checksum, &updated)) < 0) { + if (error == GIT_ENOTFOUND) { git_grafts_clear(grafts); error = 0; diff --git a/src/util/futils.c b/src/util/futils.c index 084f1cd2820..7b5a24b305f 100644 --- a/src/util/futils.c +++ b/src/util/futils.c @@ -221,14 +221,14 @@ int git_futils_readbuffer_fd_full(git_str *buf, git_file fd) int git_futils_readbuffer_updated( git_str *out, const char *path, - unsigned char checksum[GIT_HASH_SHA1_SIZE], + unsigned char checksum[GIT_HASH_SHA256_SIZE], int *updated) { int error; git_file fd; struct stat st; git_str buf = GIT_STR_INIT; - unsigned char checksum_new[GIT_HASH_SHA1_SIZE]; + unsigned char checksum_new[GIT_HASH_SHA256_SIZE]; GIT_ASSERT_ARG(out); GIT_ASSERT_ARG(path && *path); @@ -261,7 +261,10 @@ int git_futils_readbuffer_updated( p_close(fd); if (checksum) { - if ((error = git_hash_buf(checksum_new, buf.ptr, buf.size, GIT_HASH_ALGORITHM_SHA1)) < 0) { + error = git_hash_buf(checksum_new, buf.ptr, + buf.size, GIT_HASH_ALGORITHM_SHA256); + + if (error < 0) { git_str_dispose(&buf); return error; } @@ -269,7 +272,7 @@ int git_futils_readbuffer_updated( /* * If we were given a checksum, we only want to use it if it's different */ - if (!memcmp(checksum, checksum_new, GIT_HASH_SHA1_SIZE)) { + if (!memcmp(checksum, checksum_new, GIT_HASH_SHA256_SIZE)) { git_str_dispose(&buf); if (updated) *updated = 0; @@ -277,7 +280,7 @@ int git_futils_readbuffer_updated( return 0; } - memcpy(checksum, checksum_new, GIT_HASH_SHA1_SIZE); + memcpy(checksum, checksum_new, GIT_HASH_SHA256_SIZE); } /* From 69592bde1f2789162b215b612df7c8a13956b722 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 24 Apr 2023 13:09:15 +0100 Subject: [PATCH 250/608] grafts: use `git_parse` to parse object IDs Don't mix parsing by hand and using `git_parse` to parse. --- src/libgit2/grafts.c | 16 +++++++--------- 1 file changed, 7 insertions(+), 9 deletions(-) diff --git a/src/libgit2/grafts.c b/src/libgit2/grafts.c index ef314550d7d..d46fc12c1a5 100644 --- a/src/libgit2/grafts.c +++ b/src/libgit2/grafts.c @@ -119,7 +119,7 @@ int git_grafts_refresh(git_grafts *grafts) return error; } -int git_grafts_parse(git_grafts *grafts, const char *content, size_t contentlen) +int git_grafts_parse(git_grafts *grafts, const char *buf, size_t len) { git_array_oid_t parents = GIT_ARRAY_INIT; git_parse_ctx parser; @@ -127,29 +127,26 @@ int git_grafts_parse(git_grafts *grafts, const char *content, size_t contentlen) git_grafts_clear(grafts); - if ((error = git_parse_ctx_init(&parser, content, contentlen)) < 0) + if ((error = git_parse_ctx_init(&parser, buf, len)) < 0) goto error; for (; parser.remain_len; git_parse_advance_line(&parser)) { - const char *line_start = parser.line, *line_end = parser.line + parser.line_len; git_oid graft_oid; - if ((error = git_oid__fromstrn(&graft_oid, line_start, GIT_OID_SHA1_HEXSIZE, GIT_OID_SHA1)) < 0) { + if ((error = git_parse_advance_oid(&graft_oid, &parser, GIT_OID_SHA1)) < 0) { git_error_set(GIT_ERROR_GRAFTS, "invalid graft OID at line %" PRIuZ, parser.line_num); goto error; } - line_start += GIT_OID_SHA1_HEXSIZE; - while (line_start < line_end && *line_start == ' ') { + while (parser.line_len && git_parse_advance_expected(&parser, "\n", 1) != 0) { git_oid *id = git_array_alloc(parents); GIT_ERROR_CHECK_ALLOC(id); - if ((error = git_oid__fromstrn(id, ++line_start, GIT_OID_SHA1_HEXSIZE, GIT_OID_SHA1)) < 0) { + if ((error = git_parse_advance_expected(&parser, " ", 1)) < 0 || + (error = git_parse_advance_oid(id, &parser, GIT_OID_SHA1)) < 0) { git_error_set(GIT_ERROR_GRAFTS, "invalid parent OID at line %" PRIuZ, parser.line_num); goto error; } - - line_start += GIT_OID_SHA1_HEXSIZE; } if ((error = git_grafts_add(grafts, &graft_oid, parents)) < 0) @@ -186,6 +183,7 @@ int git_grafts_add(git_grafts *grafts, const git_oid *oid, git_array_oid_t paren if ((error = git_grafts_remove(grafts, &graft->oid)) < 0 && error != GIT_ENOTFOUND) goto cleanup; + if ((error = git_oidmap_set(grafts->commits, &graft->oid, graft)) < 0) goto cleanup; From 7d7f3059decbd6b4730bfd09da54726c1b3ed8ea Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 24 Apr 2023 13:32:43 +0100 Subject: [PATCH 251/608] grafts: handle SHA256 graft files --- src/libgit2/grafts.c | 22 +++++++++++++++++----- src/libgit2/grafts.h | 6 +++--- src/libgit2/repository.c | 4 ++-- tests/libgit2/grafts/basic.c | 2 +- tests/libgit2/grafts/parse.c | 2 +- 5 files changed, 24 insertions(+), 12 deletions(-) diff --git a/src/libgit2/grafts.c b/src/libgit2/grafts.c index d46fc12c1a5..00de03e8b21 100644 --- a/src/libgit2/grafts.c +++ b/src/libgit2/grafts.c @@ -16,15 +16,20 @@ struct git_grafts { /* Map of `git_commit_graft`s */ git_oidmap *commits; + /* Type of object IDs */ + git_oid_t oid_type; + /* File backing the graft. NULL if it's an in-memory graft */ char *path; unsigned char path_checksum[GIT_HASH_SHA256_SIZE]; }; -int git_grafts_new(git_grafts **out) +int git_grafts_new(git_grafts **out, git_oid_t oid_type) { git_grafts *grafts; + GIT_ASSERT_ARG(out && oid_type); + grafts = git__calloc(1, sizeof(*grafts)); GIT_ERROR_CHECK_ALLOC(grafts); @@ -33,19 +38,26 @@ int git_grafts_new(git_grafts **out) return -1; } + grafts->oid_type = oid_type; + *out = grafts; return 0; } -int git_grafts_from_file(git_grafts **out, const char *path) +int git_grafts_from_file( + git_grafts **out, + const char *path, + git_oid_t oid_type) { git_grafts *grafts = NULL; int error; + GIT_ASSERT_ARG(path && oid_type); + if (*out) return git_grafts_refresh(*out); - if ((error = git_grafts_new(&grafts)) < 0) + if ((error = git_grafts_new(&grafts, oid_type)) < 0) goto error; grafts->path = git__strdup(path); @@ -133,7 +145,7 @@ int git_grafts_parse(git_grafts *grafts, const char *buf, size_t len) for (; parser.remain_len; git_parse_advance_line(&parser)) { git_oid graft_oid; - if ((error = git_parse_advance_oid(&graft_oid, &parser, GIT_OID_SHA1)) < 0) { + if ((error = git_parse_advance_oid(&graft_oid, &parser, grafts->oid_type)) < 0) { git_error_set(GIT_ERROR_GRAFTS, "invalid graft OID at line %" PRIuZ, parser.line_num); goto error; } @@ -143,7 +155,7 @@ int git_grafts_parse(git_grafts *grafts, const char *buf, size_t len) GIT_ERROR_CHECK_ALLOC(id); if ((error = git_parse_advance_expected(&parser, " ", 1)) < 0 || - (error = git_parse_advance_oid(id, &parser, GIT_OID_SHA1)) < 0) { + (error = git_parse_advance_oid(id, &parser, grafts->oid_type)) < 0) { git_error_set(GIT_ERROR_GRAFTS, "invalid parent OID at line %" PRIuZ, parser.line_num); goto error; } diff --git a/src/libgit2/grafts.h b/src/libgit2/grafts.h index fc61468f576..0c0e9cecbd6 100644 --- a/src/libgit2/grafts.h +++ b/src/libgit2/grafts.h @@ -19,13 +19,13 @@ typedef struct { typedef struct git_grafts git_grafts; -int git_grafts_new(git_grafts **out); -int git_grafts_from_file(git_grafts **out, const char *path); +int git_grafts_new(git_grafts **out, git_oid_t oid_type); +int git_grafts_from_file(git_grafts **out, const char *path, git_oid_t oid_type); void git_grafts_free(git_grafts *grafts); void git_grafts_clear(git_grafts *grafts); int git_grafts_refresh(git_grafts *grafts); -int git_grafts_parse(git_grafts *grafts, const char *content, size_t contentlen); +int git_grafts_parse(git_grafts *grafts, const char *buf, size_t len); int git_grafts_add(git_grafts *grafts, const git_oid *oid, git_array_oid_t parents); int git_grafts_remove(git_grafts *grafts, const git_oid *oid); int git_grafts_get(git_commit_graft **out, git_grafts *grafts, const git_oid *oid); diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index a60fb23fa0a..5778a86f7e9 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -852,13 +852,13 @@ static int load_grafts(git_repository *repo) if ((error = git_repository__item_path(&path, repo, GIT_REPOSITORY_ITEM_INFO)) < 0 || (error = git_str_joinpath(&path, path.ptr, "grafts")) < 0 || - (error = git_grafts_from_file(&repo->grafts, path.ptr)) < 0) + (error = git_grafts_from_file(&repo->grafts, path.ptr, repo->oid_type)) < 0) goto error; git_str_clear(&path); if ((error = git_str_joinpath(&path, repo->gitdir, "shallow")) < 0 || - (error = git_grafts_from_file(&repo->shallow_grafts, path.ptr)) < 0) + (error = git_grafts_from_file(&repo->shallow_grafts, path.ptr, repo->oid_type)) < 0) goto error; error: diff --git a/tests/libgit2/grafts/basic.c b/tests/libgit2/grafts/basic.c index fe747709715..30c87f908af 100644 --- a/tests/libgit2/grafts/basic.c +++ b/tests/libgit2/grafts/basic.c @@ -22,7 +22,7 @@ void test_grafts_basic__graft_add(void) git_commit_graft *graft; git_grafts *grafts; - cl_git_pass(git_grafts_new(&grafts)); + cl_git_pass(git_grafts_new(&grafts, GIT_OID_SHA1)); cl_assert(oid1 = git_array_alloc(parents)); cl_git_pass(git_oid__fromstr(&oid_src, "2f3053cbff8a4ca2f0666de364ddb734a28a31a9", GIT_OID_SHA1)); diff --git a/tests/libgit2/grafts/parse.c b/tests/libgit2/grafts/parse.c index 149b01c8c7b..3b0618a1d99 100644 --- a/tests/libgit2/grafts/parse.c +++ b/tests/libgit2/grafts/parse.c @@ -19,7 +19,7 @@ static git_grafts *grafts; void test_grafts_parse__initialize(void) { - cl_git_pass(git_grafts_new(&grafts)); + cl_git_pass(git_grafts_new(&grafts, GIT_OID_SHA1)); } void test_grafts_parse__cleanup(void) From 3388f5ba1b821e9683d21ca41c34ed752d2db222 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Tue, 25 Apr 2023 09:31:34 +0100 Subject: [PATCH 252/608] shallow: don't default to -1 for depth Depth of `0` should indicate full depth. Disallow negative values (they may have a future meaning) and use `0` as the default. --- include/git2/remote.h | 6 +++--- src/libgit2/clone.c | 2 +- src/libgit2/fetch.c | 13 +++++-------- 3 files changed, 9 insertions(+), 12 deletions(-) diff --git a/include/git2/remote.h b/include/git2/remote.h index 9e4043f87bd..8d612701416 100644 --- a/include/git2/remote.h +++ b/include/git2/remote.h @@ -744,9 +744,9 @@ typedef struct { git_proxy_options proxy_opts; /** - * Depth of the fetch to perform. Depth <= 0 fetches the full history. + * Depth of the fetch to perform, or 0 for full history. * - * The default is -1. + * The default is 0. */ int depth; @@ -772,7 +772,7 @@ typedef struct { #define GIT_FETCH_OPTIONS_VERSION 1 #define GIT_FETCH_OPTIONS_INIT { GIT_FETCH_OPTIONS_VERSION, GIT_REMOTE_CALLBACKS_INIT, GIT_FETCH_PRUNE_UNSPECIFIED, 1, \ - GIT_REMOTE_DOWNLOAD_TAGS_UNSPECIFIED, GIT_PROXY_OPTIONS_INIT, -1, 0 } + GIT_REMOTE_DOWNLOAD_TAGS_UNSPECIFIED, GIT_PROXY_OPTIONS_INIT } /** * Initialize git_fetch_options structure diff --git a/src/libgit2/clone.c b/src/libgit2/clone.c index 43341a493f4..fca0ca0cc7c 100644 --- a/src/libgit2/clone.c +++ b/src/libgit2/clone.c @@ -421,7 +421,7 @@ static int clone_into( memcpy(&fetch_opts, opts, sizeof(git_fetch_options)); fetch_opts.update_fetchhead = 0; - if (opts->depth <= 0) + if (!opts->depth) fetch_opts.download_tags = GIT_REMOTE_DOWNLOAD_TAGS_ALL; if ((error = git_remote_connect_options__from_fetch_opts(&connect_opts, remote, &fetch_opts)) < 0) diff --git a/src/libgit2/fetch.c b/src/libgit2/fetch.c index d66892ca0b9..86b650a60c5 100644 --- a/src/libgit2/fetch.c +++ b/src/libgit2/fetch.c @@ -172,10 +172,12 @@ int git_fetch_negotiate(git_remote *remote, const git_fetch_options *opts) remote->need_pack = 0; - if (!opts) - remote->nego.depth = -1; - else + if (opts) { + GIT_ASSERT_ARG(opts->unshallow == 0 || opts->depth == 0); + GIT_ASSERT_ARG(opts->depth >= 0); + remote->nego.depth = opts->unshallow ? INT_MAX : opts->depth; + } if (filter_wants(remote, opts) < 0) return -1; @@ -184,11 +186,6 @@ int git_fetch_negotiate(git_remote *remote, const git_fetch_options *opts) if (!remote->need_pack) return 0; - if (opts && opts->unshallow && opts->depth > 0) { - git_error_set(GIT_ERROR_INVALID, "options '--depth' and '--unshallow' cannot be used together"); - return -1; - } - /* * Now we have everything set up so we can start tell the * server what we want and what we have. From 19ccab005ed2a65ddcd3f50a2a09214a5849871d Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Tue, 25 Apr 2023 09:33:24 +0100 Subject: [PATCH 253/608] shallow: cleanup whitespace in tests --- tests/libgit2/transports/smart/shallowarray.c | 32 +++++++++---------- 1 file changed, 16 insertions(+), 16 deletions(-) diff --git a/tests/libgit2/transports/smart/shallowarray.c b/tests/libgit2/transports/smart/shallowarray.c index ec4388e42d3..34511c5f641 100644 --- a/tests/libgit2/transports/smart/shallowarray.c +++ b/tests/libgit2/transports/smart/shallowarray.c @@ -15,37 +15,37 @@ void test_transports_smart_shallowarray__add_and_remove_oid_from_shallowarray(void) { - git_oid oid_0_obj, oid_1_obj, oid_2_obj; - git_shallowarray *shallow_roots = git__malloc(sizeof(git_shallowarray)); - git_array_init(shallow_roots->array); + git_oid oid_0_obj, oid_1_obj, oid_2_obj; + git_shallowarray *shallow_roots = git__malloc(sizeof(git_shallowarray)); + git_array_init(shallow_roots->array); - git_oid__fromstr(&oid_0_obj, oid_0, GIT_OID_SHA1); - git_oid__fromstr(&oid_1_obj, oid_1, GIT_OID_SHA1); - git_oid__fromstr(&oid_2_obj, oid_2, GIT_OID_SHA1); + git_oid__fromstr(&oid_0_obj, oid_0, GIT_OID_SHA1); + git_oid__fromstr(&oid_1_obj, oid_1, GIT_OID_SHA1); + git_oid__fromstr(&oid_2_obj, oid_2, GIT_OID_SHA1); - git_shallowarray_add(shallow_roots, &oid_0_obj); - git_shallowarray_add(shallow_roots, &oid_1_obj); - git_shallowarray_add(shallow_roots, &oid_2_obj); + git_shallowarray_add(shallow_roots, &oid_0_obj); + git_shallowarray_add(shallow_roots, &oid_1_obj); + git_shallowarray_add(shallow_roots, &oid_2_obj); - cl_assert_equal_i(3, shallow_roots->array.size); + cl_assert_equal_i(3, shallow_roots->array.size); cl_assert_equal_s("c070ad8c08840c8116da865b2d65593a6bb9cd2a", git_oid_tostr_s(&shallow_roots->array.ptr[0])); cl_assert_equal_s("0966a434eb1a025db6b71485ab63a3bfbea520b6", git_oid_tostr_s(&shallow_roots->array.ptr[1])); cl_assert_equal_s("83834a7afdaa1a1260568567f6ad90020389f664", git_oid_tostr_s(&shallow_roots->array.ptr[2])); - git_shallowarray_remove(shallow_roots, &oid_2_obj); + git_shallowarray_remove(shallow_roots, &oid_2_obj); - cl_assert_equal_i(2, shallow_roots->array.size); + cl_assert_equal_i(2, shallow_roots->array.size); cl_assert_equal_s("c070ad8c08840c8116da865b2d65593a6bb9cd2a", git_oid_tostr_s(&shallow_roots->array.ptr[0])); cl_assert_equal_s("0966a434eb1a025db6b71485ab63a3bfbea520b6", git_oid_tostr_s(&shallow_roots->array.ptr[1])); - git_shallowarray_remove(shallow_roots, &oid_1_obj); + git_shallowarray_remove(shallow_roots, &oid_1_obj); - cl_assert_equal_i(1, shallow_roots->array.size); + cl_assert_equal_i(1, shallow_roots->array.size); cl_assert_equal_s("c070ad8c08840c8116da865b2d65593a6bb9cd2a", git_oid_tostr_s(&shallow_roots->array.ptr[0])); - git_shallowarray_remove(shallow_roots, &oid_0_obj); + git_shallowarray_remove(shallow_roots, &oid_0_obj); - cl_assert_equal_i(0, shallow_roots->array.size); + cl_assert_equal_i(0, shallow_roots->array.size); git_array_clear(shallow_roots->array); git__free(shallow_roots); From 43db928895fa85e4ee104dc8757275400d5acc2a Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Tue, 25 Apr 2023 10:48:33 +0100 Subject: [PATCH 254/608] grafts: make `from_file` be `open_or_refresh` The semantics of `from_file` are weird - it looks like a function that just opens a file, but it actually inspects the pointer, which is unexpected and could make things very crashy. Make an `open` function that just does an open, and move the magic to `open_or_refresh` whose name better indicates that it may do weird stuff. --- src/libgit2/grafts.c | 19 ++++++++++++++----- src/libgit2/grafts.h | 3 ++- src/libgit2/repository.c | 4 ++-- 3 files changed, 18 insertions(+), 8 deletions(-) diff --git a/src/libgit2/grafts.c b/src/libgit2/grafts.c index 00de03e8b21..83f5b2ab418 100644 --- a/src/libgit2/grafts.c +++ b/src/libgit2/grafts.c @@ -44,7 +44,7 @@ int git_grafts_new(git_grafts **out, git_oid_t oid_type) return 0; } -int git_grafts_from_file( +int git_grafts_open( git_grafts **out, const char *path, git_oid_t oid_type) @@ -52,10 +52,7 @@ int git_grafts_from_file( git_grafts *grafts = NULL; int error; - GIT_ASSERT_ARG(path && oid_type); - - if (*out) - return git_grafts_refresh(*out); + GIT_ASSERT_ARG(out && path && oid_type); if ((error = git_grafts_new(&grafts, oid_type)) < 0) goto error; @@ -67,12 +64,24 @@ int git_grafts_from_file( goto error; *out = grafts; + error: if (error < 0) git_grafts_free(grafts); + return error; } +int git_grafts_open_or_refresh( + git_grafts **out, + const char *path, + git_oid_t oid_type) +{ + GIT_ASSERT_ARG(out && path && oid_type); + + return *out ? git_grafts_refresh(*out) : git_grafts_open(out, path, oid_type); +} + void git_grafts_free(git_grafts *grafts) { if (!grafts) diff --git a/src/libgit2/grafts.h b/src/libgit2/grafts.h index 0c0e9cecbd6..0d561fc2538 100644 --- a/src/libgit2/grafts.h +++ b/src/libgit2/grafts.h @@ -20,7 +20,8 @@ typedef struct { typedef struct git_grafts git_grafts; int git_grafts_new(git_grafts **out, git_oid_t oid_type); -int git_grafts_from_file(git_grafts **out, const char *path, git_oid_t oid_type); +int git_grafts_open(git_grafts **out, const char *path, git_oid_t oid_type); +int git_grafts_open_or_refresh(git_grafts **out, const char *path, git_oid_t oid_type); void git_grafts_free(git_grafts *grafts); void git_grafts_clear(git_grafts *grafts); diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index 5778a86f7e9..763b62375ab 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -852,13 +852,13 @@ static int load_grafts(git_repository *repo) if ((error = git_repository__item_path(&path, repo, GIT_REPOSITORY_ITEM_INFO)) < 0 || (error = git_str_joinpath(&path, path.ptr, "grafts")) < 0 || - (error = git_grafts_from_file(&repo->grafts, path.ptr, repo->oid_type)) < 0) + (error = git_grafts_open_or_refresh(&repo->grafts, path.ptr, repo->oid_type)) < 0) goto error; git_str_clear(&path); if ((error = git_str_joinpath(&path, repo->gitdir, "shallow")) < 0 || - (error = git_grafts_from_file(&repo->shallow_grafts, path.ptr, repo->oid_type)) < 0) + (error = git_grafts_open_or_refresh(&repo->shallow_grafts, path.ptr, repo->oid_type)) < 0) goto error; error: From 04cddffea9d00d5788b4f41a7dce3356089228ab Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Tue, 25 Apr 2023 13:29:35 +0100 Subject: [PATCH 255/608] cli: add --depth option to clone --- src/cli/cmd_clone.c | 28 ++++++++++++++++++++++------ 1 file changed, 22 insertions(+), 6 deletions(-) diff --git a/src/cli/cmd_clone.c b/src/cli/cmd_clone.c index a382b5875df..e4776256cb3 100644 --- a/src/cli/cmd_clone.c +++ b/src/cli/cmd_clone.c @@ -18,7 +18,7 @@ #define COMMAND_NAME "clone" -static char *branch, *remote_path, *local_path; +static char *branch, *remote_path, *local_path, *depth; static int show_help, quiet, checkout = 1, bare; static bool local_path_exists; static cli_progress progress = CLI_PROGRESS_INIT; @@ -36,6 +36,8 @@ static const cli_opt_spec opts[] = { CLI_OPT_USAGE_DEFAULT, NULL, "don't create a working directory" }, { CLI_OPT_TYPE_VALUE, "branch", 'b', &branch, 0, CLI_OPT_USAGE_DEFAULT, "name", "branch to check out" }, + { CLI_OPT_TYPE_VALUE, "depth", 0, &depth, 0, + CLI_OPT_USAGE_DEFAULT, "depth", "commit depth to check out " }, { CLI_OPT_TYPE_LITERAL }, { CLI_OPT_TYPE_ARG, "repository", 0, &remote_path, 0, CLI_OPT_USAGE_REQUIRED, "repository", "repository path" }, @@ -71,6 +73,22 @@ static char *compute_local_path(const char *orig_path) return local_path; } +static int compute_depth(const char *depth) +{ + int64_t i; + const char *endptr; + + if (!depth) + return 0; + + if (git__strntol64(&i, depth, strlen(depth), &endptr, 10) < 0 || i < 0 || i > INT_MAX || *endptr) { + fprintf(stderr, "fatal: depth '%s' is not valid.\n", depth); + exit(128); + } + + return (int)i; +} + static bool validate_local_path(const char *path) { if (!git_fs_path_exists(path)) @@ -127,11 +145,9 @@ int cmd_clone(int argc, char **argv) goto done; } - if (bare) - clone_opts.bare = 1; - - if (branch) - clone_opts.checkout_branch = branch; + clone_opts.bare = !!bare; + clone_opts.checkout_branch = branch; + clone_opts.fetch_opts.depth = compute_depth(depth); if (!checkout) clone_opts.checkout_opts.checkout_strategy = GIT_CHECKOUT_NONE; From d873966fdeae7f0ac974318ce21772af555f1660 Mon Sep 17 00:00:00 2001 From: Dimitry Andric Date: Wed, 3 May 2023 22:47:12 +0200 Subject: [PATCH 256/608] util: detect all possible qsort_r and qsort_s variants As reported in https://bugs.freebsd.org/271234, recent versions of FreeBSD have adjusted the prototype for qsort_r() to match the POSIX interface. This causes libgit2's CMake configuration check to fail to detect qsort_r(), making it fall back to qsort_s(), which in libgit2 also has an incompatible interface. With recent versions of clang this results in a "incompatible function pointer types" compile error. Summarizing, there are four variations of 'qsort-with-context': * old style BSD qsort_r(), used in FreeBSD 13 and earlier, where the comparison function has the context parameter first * GNU or POSIX qsort_r(), also used in FreeBSD 14 and later, where the comparison function has the context parameter last * C11 qsort_s(), where the comparison function has the context parameter last * Microsoft qsort_s(), where the comparison function has the context parameter first Add explicit detections for all these variants, so they get detected as (in the same order as above): * `GIT_QSORT_R_BSD` * `GIT_QSORT_R_GNU` * `GIT_QSORT_S_C11` * `GIT_QSORT_S_MSC` An additional complication is that on FreeBSD 14 and later, uses the C11 _Generic() macro mechanism to automatically select the correct qsort_r() prototype, depending on the caller's comparison function argument. This breaks CMake's check_prototype_definition() functionality, since it tries to redefine the function, and _Generic macro is expanded inline causing a compile error. Work around that problem by putting the function names in parentheses, to prevent the preprocessor from using a macro to replace the function name. Also, in `git__qsort_r()`, change the `#if` order so the variants that do not have to use glue are preferred. --- src/CMakeLists.txt | 20 +++++++++++++++++--- src/util/git2_features.h.in | 3 ++- src/util/util.c | 17 ++++++++++------- 3 files changed, 29 insertions(+), 11 deletions(-) diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index cc0a0d4dce6..de591e4e4eb 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -58,15 +58,29 @@ add_feature_info(futimens GIT_USE_FUTIMENS "futimens support") # qsort +# old-style FreeBSD qsort_r() has the 'context' parameter as the first argument +# of the comparison function: check_prototype_definition(qsort_r - "void qsort_r(void *base, size_t nmemb, size_t size, void *thunk, int (*compar)(void *, const void *, const void *))" + "void (qsort_r)(void *base, size_t nmemb, size_t size, void *context, int (*compar)(void *, const void *, const void *))" "" "stdlib.h" GIT_QSORT_R_BSD) +# GNU or POSIX qsort_r() has the 'context' parameter as the last argument of the +# comparison function: check_prototype_definition(qsort_r - "void qsort_r(void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *, void *), void *arg)" + "void (qsort_r)(void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *, void *), void *context)" "" "stdlib.h" GIT_QSORT_R_GNU) -check_function_exists(qsort_s GIT_QSORT_S) +# C11 qsort_s() has the 'context' parameter as the last argument of the +# comparison function, and returns an error status: +check_prototype_definition(qsort_s + "errno_t (qsort_s)(void *base, rsize_t nmemb, rsize_t size, int (*compar)(const void *, const void *, void *), void *context)" + "0" "stdlib.h" GIT_QSORT_S_C11) + +# MSC qsort_s() has the 'context' parameter as the first argument of the +# comparison function, and as the last argument of qsort_s(): +check_prototype_definition(qsort_s + "void (qsort_s)(void *base, size_t num, size_t width, int (*compare )(void *, const void *, const void *), void *context)" + "" "stdlib.h" GIT_QSORT_S_MSC) # random / entropy data diff --git a/src/util/git2_features.h.in b/src/util/git2_features.h.in index 1575be641e1..5f606df8494 100644 --- a/src/util/git2_features.h.in +++ b/src/util/git2_features.h.in @@ -26,7 +26,8 @@ #cmakedefine GIT_QSORT_R_BSD #cmakedefine GIT_QSORT_R_GNU -#cmakedefine GIT_QSORT_S +#cmakedefine GIT_QSORT_S_C11 +#cmakedefine GIT_QSORT_S_MSC #cmakedefine GIT_SSH 1 #cmakedefine GIT_SSH_MEMORY_CREDENTIALS 1 diff --git a/src/util/util.c b/src/util/util.c index 9c9f2c0403a..f4eaf5835ab 100644 --- a/src/util/util.c +++ b/src/util/util.c @@ -18,7 +18,7 @@ # endif # include -# ifdef GIT_QSORT_S +# ifdef GIT_QSORT_S_MSC # include # endif #endif @@ -673,7 +673,7 @@ size_t git__unescape(char *str) return (pos - str); } -#if defined(GIT_QSORT_S) || defined(GIT_QSORT_R_BSD) +#if defined(GIT_QSORT_S_MSC) || defined(GIT_QSORT_R_BSD) typedef struct { git__sort_r_cmp cmp; void *payload; @@ -690,7 +690,8 @@ static int GIT_LIBGIT2_CALL git__qsort_r_glue_cmp( #if !defined(GIT_QSORT_R_BSD) && \ !defined(GIT_QSORT_R_GNU) && \ - !defined(GIT_QSORT_S) + !defined(GIT_QSORT_S_C11) && \ + !defined(GIT_QSORT_S_MSC) static void swap(uint8_t *a, uint8_t *b, size_t elsize) { char tmp[256]; @@ -721,12 +722,14 @@ static void insertsort( void git__qsort_r( void *els, size_t nel, size_t elsize, git__sort_r_cmp cmp, void *payload) { -#if defined(GIT_QSORT_R_BSD) +#if defined(GIT_QSORT_R_GNU) + qsort_r(els, nel, elsize, cmp, payload); +#elif defined(GIT_QSORT_S_C11) + qsort_s(els, nel, elsize, cmp, payload); +#elif defined(GIT_QSORT_R_BSD) git__qsort_r_glue glue = { cmp, payload }; qsort_r(els, nel, elsize, &glue, git__qsort_r_glue_cmp); -#elif defined(GIT_QSORT_R_GNU) - qsort_r(els, nel, elsize, cmp, payload); -#elif defined(GIT_QSORT_S) +#elif defined(GIT_QSORT_S_MSC) git__qsort_r_glue glue = { cmp, payload }; qsort_s(els, nel, elsize, git__qsort_r_glue_cmp, &glue); #else From 3d9cb5e0c6b36bf7e226890515088259180de212 Mon Sep 17 00:00:00 2001 From: Dimitry Andric Date: Tue, 9 May 2023 16:59:45 +0200 Subject: [PATCH 257/608] Work around -Werror problems when detecting qsort variants If `ENABLE_WERROR` is on, the CMake configure tests for the `qsort_r` and `qsort_s` variants may fail due to warnings about unused functions or unused parameters. These warnings can be ignored, so disable them specifically for running those tests. --- src/CMakeLists.txt | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index de591e4e4eb..db0fd10c75d 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -58,6 +58,13 @@ add_feature_info(futimens GIT_USE_FUTIMENS "futimens support") # qsort +# for these tests, temporarily save CMAKE_C_FLAGS and disable warnings about +# unused functions and parameters, otherwise they will always fail if +# ENABLE_WERROR is on +set(SAVED_CMAKE_C_FLAGS "${CMAKE_C_FLAGS}") +disable_warnings(unused-function) +disable_warnings(unused-parameter) + # old-style FreeBSD qsort_r() has the 'context' parameter as the first argument # of the comparison function: check_prototype_definition(qsort_r @@ -82,6 +89,9 @@ check_prototype_definition(qsort_s "void (qsort_s)(void *base, size_t num, size_t width, int (*compare )(void *, const void *, const void *), void *context)" "" "stdlib.h" GIT_QSORT_S_MSC) +# restore CMAKE_C_FLAGS +set(CMAKE_C_FLAGS "${SAVED_CMAKE_C_FLAGS}") + # random / entropy data check_function_exists(getentropy GIT_RAND_GETENTROPY) From 0a7e32b2326c02a91f9560dfd209e56ea9fb9d49 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 8 May 2023 10:07:11 +0100 Subject: [PATCH 258/608] oid: use an oid array instead of shallowarray Users should provide us an array of object ids; we don't need a separate type. And especially, we should not be mutating user-providing values. Instead, use `git_oid *` in the shallow code. --- include/git2/sys/transport.h | 22 +++-- src/libgit2/fetch.c | 29 +++--- src/libgit2/grafts.c | 16 ++- src/libgit2/grafts.h | 2 +- src/libgit2/oidarray.c | 52 +++++++++- src/libgit2/oidarray.h | 6 +- src/libgit2/remote.c | 5 - src/libgit2/repository.c | 20 ++-- src/libgit2/repository.h | 4 +- src/libgit2/transports/local.c | 11 +++ src/libgit2/transports/smart.c | 49 +--------- src/libgit2/transports/smart.h | 7 +- src/libgit2/transports/smart_pkt.c | 13 ++- src/libgit2/transports/smart_protocol.c | 56 +++++++++-- src/util/array.h | 3 + tests/libgit2/core/oidarray.c | 98 +++++++++++++++++++ tests/libgit2/online/shallow.c | 35 ++++--- tests/libgit2/transports/smart/shallowarray.c | 52 ---------- 18 files changed, 304 insertions(+), 176 deletions(-) create mode 100644 tests/libgit2/core/oidarray.c delete mode 100644 tests/libgit2/transports/smart/shallowarray.c diff --git a/include/git2/sys/transport.h b/include/git2/sys/transport.h index 062bcd0edf1..96a35d08cb2 100644 --- a/include/git2/sys/transport.h +++ b/include/git2/sys/transport.h @@ -25,12 +25,11 @@ GIT_BEGIN_DECL -typedef struct git_shallowarray git_shallowarray; - typedef struct { const git_remote_head * const *refs; - size_t count; - git_shallowarray *shallow_roots; + size_t refs_len; + git_oid *shallow_roots; + size_t shallow_roots_len; int depth; } git_fetch_negotiation; @@ -107,6 +106,16 @@ struct git_transport { git_repository *repo, const git_fetch_negotiation *fetch_data); + /** + * Return the shallow roots of the remote. + * + * This function may be called after a successful call to + * `negotiate_fetch`. + */ + int GIT_CALLBACK(shallow_roots)( + git_oidarray *out, + git_transport *transport); + /** * Start downloading the packfile from the remote repository. * @@ -450,11 +459,6 @@ GIT_EXTERN(int) git_smart_subtransport_ssh( git_transport *owner, void *param); -GIT_EXTERN(size_t) git_shallowarray_count(git_shallowarray *array); -GIT_EXTERN(const git_oid *) git_shallowarray_get(git_shallowarray *array, size_t idx); -GIT_EXTERN(int) git_shallowarray_add(git_shallowarray *array, git_oid *oid); -GIT_EXTERN(int) git_shallowarray_remove(git_shallowarray *array, git_oid *oid); - /** @} */ GIT_END_DECL #endif diff --git a/src/libgit2/fetch.c b/src/libgit2/fetch.c index 86b650a60c5..b4342521591 100644 --- a/src/libgit2/fetch.c +++ b/src/libgit2/fetch.c @@ -61,7 +61,7 @@ static int mark_local(git_remote *remote) git_vector_foreach(&remote->refs, i, head) { /* If we have the object, mark it so we don't ask for it. - However if we are unshallowing, we need to ask for it + However if we are unshallowing, we need to ask for it even though the head exists locally. */ if (remote->nego.depth != INT_MAX && git_odb_exists(odb, &head->oid)) head->local = 1; @@ -169,6 +169,7 @@ static int filter_wants(git_remote *remote, const git_fetch_options *opts) int git_fetch_negotiate(git_remote *remote, const git_fetch_options *opts) { git_transport *t = remote->transport; + int error; remote->need_pack = 0; @@ -191,33 +192,39 @@ int git_fetch_negotiate(git_remote *remote, const git_fetch_options *opts) * server what we want and what we have. */ remote->nego.refs = (const git_remote_head * const *)remote->refs.contents; - remote->nego.count = remote->refs.length; - remote->nego.shallow_roots = git__malloc(sizeof(*remote->nego.shallow_roots)); - - git_array_init(remote->nego.shallow_roots->array); + remote->nego.refs_len = remote->refs.length; - git_repository__shallow_roots(&remote->nego.shallow_roots->array, remote->repo); + if (git_repository__shallow_roots(&remote->nego.shallow_roots, + &remote->nego.shallow_roots_len, + remote->repo) < 0) + return -1; - return t->negotiate_fetch(t, + error = t->negotiate_fetch(t, remote->repo, &remote->nego); + + git__free(remote->nego.shallow_roots); + + return error; } int git_fetch_download_pack(git_remote *remote) { + git_oidarray shallow_roots = { NULL }; git_transport *t = remote->transport; int error; if (!remote->need_pack) return 0; - if ((error = t->download_pack(t, remote->repo, &remote->stats)) != 0) + if ((error = t->download_pack(t, remote->repo, &remote->stats)) != 0 || + (error = t->shallow_roots(&shallow_roots, t)) != 0) return error; - if ((error = git_repository__shallow_roots_write(remote->repo, remote->nego.shallow_roots->array)) != 0) - return error; + error = git_repository__shallow_roots_write(remote->repo, &shallow_roots); - return 0; + git_oidarray_dispose(&shallow_roots); + return error; } int git_fetch_options_init(git_fetch_options *opts, unsigned int version) diff --git a/src/libgit2/grafts.c b/src/libgit2/grafts.c index 83f5b2ab418..1d9373a56f6 100644 --- a/src/libgit2/grafts.c +++ b/src/libgit2/grafts.c @@ -243,20 +243,26 @@ int git_grafts_get(git_commit_graft **out, git_grafts *grafts, const git_oid *oi return 0; } -int git_grafts_get_oids(git_array_oid_t *out, git_grafts *grafts) +int git_grafts_oids(git_oid **out, size_t *out_len, git_grafts *grafts) { + git_array_oid_t array = GIT_ARRAY_INIT; const git_oid *oid; - size_t i = 0; - int error; + size_t existing, i = 0; GIT_ASSERT_ARG(out && grafts); - while ((error = git_oidmap_iterate(NULL, grafts->commits, &i, &oid)) == 0) { - git_oid *cpy = git_array_alloc(*out); + if ((existing = git_oidmap_size(grafts->commits)) > 0) + git_array_init_to_size(array, existing); + + while (git_oidmap_iterate(NULL, grafts->commits, &i, &oid) == 0) { + git_oid *cpy = git_array_alloc(array); GIT_ERROR_CHECK_ALLOC(cpy); git_oid_cpy(cpy, oid); } + *out = array.ptr; + *out_len = array.size; + return 0; } diff --git a/src/libgit2/grafts.h b/src/libgit2/grafts.h index 0d561fc2538..394867fd6cc 100644 --- a/src/libgit2/grafts.h +++ b/src/libgit2/grafts.h @@ -30,7 +30,7 @@ int git_grafts_parse(git_grafts *grafts, const char *buf, size_t len); int git_grafts_add(git_grafts *grafts, const git_oid *oid, git_array_oid_t parents); int git_grafts_remove(git_grafts *grafts, const git_oid *oid); int git_grafts_get(git_commit_graft **out, git_grafts *grafts, const git_oid *oid); -int git_grafts_get_oids(git_array_oid_t *out, git_grafts *grafts); +int git_grafts_oids(git_oid **out, size_t *out_len, git_grafts *grafts); size_t git_grafts_size(git_grafts *grafts); #endif diff --git a/src/libgit2/oidarray.c b/src/libgit2/oidarray.c index 583017c4ee2..37f67756aa5 100644 --- a/src/libgit2/oidarray.c +++ b/src/libgit2/oidarray.c @@ -15,10 +15,17 @@ void git_oidarray_dispose(git_oidarray *arr) git__free(arr->ids); } -void git_oidarray__from_array(git_oidarray *arr, git_array_oid_t *array) +void git_oidarray__from_array(git_oidarray *out, const git_array_oid_t *array) { - arr->count = array->size; - arr->ids = array->ptr; + out->count = array->size; + out->ids = array->ptr; +} + +void git_oidarray__to_array(git_array_oid_t *out, const git_oidarray *array) +{ + out->ptr = array->ids; + out->size = array->count; + out->asize = array->count; } void git_oidarray__reverse(git_oidarray *arr) @@ -33,6 +40,45 @@ void git_oidarray__reverse(git_oidarray *arr) } } +int git_oidarray__add(git_array_oid_t *arr, git_oid *id) +{ + git_oid *add, *iter; + size_t i; + + git_array_foreach(*arr, i, iter) { + if (git_oid_cmp(iter, id) == 0) + return 0; + } + + if ((add = git_array_alloc(*arr)) == NULL) + return -1; + + git_oid_cpy(add, id); + return 0; +} + +bool git_oidarray__remove(git_array_oid_t *arr, git_oid *id) +{ + bool found = false; + size_t remain, i; + git_oid *iter; + + git_array_foreach(*arr, i, iter) { + if (git_oid_cmp(iter, id) == 0) { + arr->size--; + remain = arr->size - i; + + if (remain > 0) + memmove(&arr->ptr[i], &arr->ptr[i+1], remain * sizeof(git_oid)); + + found = true; + break; + } + } + + return found; +} + #ifndef GIT_DEPRECATE_HARD void git_oidarray_free(git_oidarray *arr) diff --git a/src/libgit2/oidarray.h b/src/libgit2/oidarray.h index eed3a109120..8f1543a32e0 100644 --- a/src/libgit2/oidarray.h +++ b/src/libgit2/oidarray.h @@ -15,6 +15,10 @@ typedef git_array_t(git_oid) git_array_oid_t; extern void git_oidarray__reverse(git_oidarray *arr); -extern void git_oidarray__from_array(git_oidarray *arr, git_array_oid_t *array); +extern void git_oidarray__from_array(git_oidarray *out, const git_array_oid_t *array); +extern void git_oidarray__to_array(git_array_oid_t *out, const git_oidarray *array); + +int git_oidarray__add(git_array_oid_t *arr, git_oid *id); +bool git_oidarray__remove(git_array_oid_t *arr, git_oid *id); #endif diff --git a/src/libgit2/remote.c b/src/libgit2/remote.c index ef414209f42..fee2a7f3968 100644 --- a/src/libgit2/remote.c +++ b/src/libgit2/remote.c @@ -2167,11 +2167,6 @@ void git_remote_free(git_remote *remote) remote->transport = NULL; } - if (remote->nego.shallow_roots) { - git_array_clear(remote->nego.shallow_roots->array); - git__free(remote->nego.shallow_roots); - } - git_vector_free(&remote->refs); free_refspecs(&remote->refspecs); diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index 763b62375ab..8fcc4e2ba60 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -3651,7 +3651,11 @@ int git_repository_state_cleanup(git_repository *repo) return git_repository__cleanup_files(repo, state_files, ARRAY_SIZE(state_files)); } -int git_repository__shallow_roots(git_array_oid_t *out, git_repository *repo) { +int git_repository__shallow_roots( + git_oid **out, + size_t *out_len, + git_repository *repo) +{ int error = 0; if (!repo->shallow_grafts && (error = load_grafts(repo)) < 0) @@ -3660,19 +3664,18 @@ int git_repository__shallow_roots(git_array_oid_t *out, git_repository *repo) { if ((error = git_grafts_refresh(repo->shallow_grafts)) < 0) return error; - if ((error = git_grafts_get_oids(out, repo->shallow_grafts)) < 0) + if ((error = git_grafts_oids(out, out_len, repo->shallow_grafts)) < 0) return error; return 0; } -int git_repository__shallow_roots_write(git_repository *repo, git_array_oid_t roots) +int git_repository__shallow_roots_write(git_repository *repo, git_oidarray *roots) { git_filebuf file = GIT_FILEBUF_INIT; git_str path = GIT_STR_INIT; char oid_str[GIT_OID_MAX_HEXSIZE + 1]; - size_t idx; - git_oid *oid; + size_t i; int filebuf_hash, error = 0; GIT_ASSERT_ARG(repo); @@ -3686,8 +3689,8 @@ int git_repository__shallow_roots_write(git_repository *repo, git_array_oid_t ro if ((error = git_filebuf_open(&file, git_str_cstr(&path), filebuf_hash, 0666)) < 0) goto on_error; - git_array_foreach(roots, idx, oid) { - git_oid_tostr(oid_str, sizeof(oid_str), oid); + for (i = 0; i < roots->count; i++) { + git_oid_tostr(oid_str, sizeof(oid_str), &roots->ids[i]); git_filebuf_write(&file, oid_str, git_oid_hexsize(repo->oid_type)); git_filebuf_write(&file, "\n", 1); } @@ -3699,7 +3702,7 @@ int git_repository__shallow_roots_write(git_repository *repo, git_array_oid_t ro goto on_error; } - if (git_array_size(roots) == 0) + if (!roots->count) remove(path.ptr); on_error: @@ -3727,6 +3730,7 @@ int git_repository_is_shallow(git_repository *repo) if (error < 0) return error; + return st.st_size == 0 ? 0 : 1; } diff --git a/src/libgit2/repository.h b/src/libgit2/repository.h index d86b3627142..8dc20324dcc 100644 --- a/src/libgit2/repository.h +++ b/src/libgit2/repository.h @@ -246,8 +246,8 @@ extern size_t git_repository__reserved_names_posix_len; bool git_repository__reserved_names( git_str **out, size_t *outlen, git_repository *repo, bool include_ntfs); -int git_repository__shallow_roots(git_array_oid_t *out, git_repository *repo); -int git_repository__shallow_roots_write(git_repository *repo, git_array_oid_t roots); +int git_repository__shallow_roots(git_oid **out, size_t *out_len, git_repository *repo); +int git_repository__shallow_roots_write(git_repository *repo, git_oidarray *roots); /* * The default branch for the repository; the `init.defaultBranch` diff --git a/src/libgit2/transports/local.c b/src/libgit2/transports/local.c index f576682a77f..64c21afbd0d 100644 --- a/src/libgit2/transports/local.c +++ b/src/libgit2/transports/local.c @@ -320,6 +320,16 @@ static int local_negotiate_fetch( return 0; } +static int local_shallow_roots( + git_oidarray *out, + git_transport *transport) +{ + GIT_UNUSED(out); + GIT_UNUSED(transport); + + return 0; +} + static int local_push_update_remote_ref( git_repository *remote_repo, const char *lref, @@ -745,6 +755,7 @@ int git_transport_local(git_transport **out, git_remote *owner, void *param) t->parent.oid_type = local_oid_type; #endif t->parent.negotiate_fetch = local_negotiate_fetch; + t->parent.shallow_roots = local_shallow_roots; t->parent.download_pack = local_download_pack; t->parent.push = local_push; t->parent.close = local_close; diff --git a/src/libgit2/transports/smart.c b/src/libgit2/transports/smart.c index da6dca0392a..a56524bff0a 100644 --- a/src/libgit2/transports/smart.c +++ b/src/libgit2/transports/smart.c @@ -416,6 +416,8 @@ static void git_smart__free(git_transport *transport) git_remote_connect_options_dispose(&t->connect_opts); + git_array_dispose(t->shallow_roots); + git__free(t->caps.object_format); git__free(t->caps.agent); git__free(t); @@ -490,6 +492,7 @@ int git_transport_smart(git_transport **out, git_remote *owner, void *param) t->parent.close = git_smart__close; t->parent.free = git_smart__free; t->parent.negotiate_fetch = git_smart__negotiate_fetch; + t->parent.shallow_roots = git_smart__shallow_roots; t->parent.download_pack = git_smart__download_pack; t->parent.push = git_smart__push; t->parent.ls = git_smart__ls; @@ -517,49 +520,3 @@ int git_transport_smart(git_transport **out, git_remote *owner, void *param) *out = (git_transport *) t; return 0; } - -size_t git_shallowarray_count(git_shallowarray *array) -{ - return git_array_size(array->array); -} - -const git_oid * git_shallowarray_get(git_shallowarray *array, size_t idx) -{ - return git_array_get(array->array, idx); -} - -int git_shallowarray_add(git_shallowarray *array, git_oid *oid) -{ - size_t oid_index; - - if (git_array_search(&oid_index, array->array, (git_array_compare_cb)git_oid_cmp, oid) < 0) { - git_oid *tmp = git_array_alloc(array->array); - GIT_ERROR_CHECK_ALLOC(tmp); - - git_oid_cpy(tmp, oid); - } - - return 0; -} - -int git_shallowarray_remove(git_shallowarray *array, git_oid *oid) -{ - git_array_oid_t new_array = GIT_ARRAY_INIT; - git_oid *element; - git_oid *tmp; - size_t i; - - git_array_foreach(array->array, i, element) { - if (git_oid_cmp(oid, element)) { - tmp = git_array_alloc(new_array); - GIT_ERROR_CHECK_ALLOC(tmp); - - git_oid_cpy(tmp, element); - } - } - - git_array_clear(array->array); - array->array = new_array; - - return 0; -} diff --git a/src/libgit2/transports/smart.h b/src/libgit2/transports/smart.h index 8e06d03ef6e..34e27ea8e05 100644 --- a/src/libgit2/transports/smart.h +++ b/src/libgit2/transports/smart.h @@ -163,6 +163,7 @@ typedef struct { git_vector refs; git_vector heads; git_vector common; + git_array_oid_t shallow_roots; git_atomic32 cancelled; packetsize_cb packetsize_cb; void *packetsize_payload; @@ -183,6 +184,8 @@ int git_smart__negotiate_fetch( git_repository *repo, const git_fetch_negotiation *wants); +int git_smart__shallow_roots(git_oidarray *out, git_transport *transport); + int git_smart__download_pack( git_transport *transport, git_repository *repo, @@ -208,8 +211,4 @@ int git_pkt_buffer_wants(const git_fetch_negotiation *wants, transport_smart_cap int git_pkt_buffer_have(git_oid *oid, git_str *buf); void git_pkt_free(git_pkt *pkt); -struct git_shallowarray { - git_array_oid_t array; -}; - #endif diff --git a/src/libgit2/transports/smart_pkt.c b/src/libgit2/transports/smart_pkt.c index f2c9eea8e5e..9127ad5fe43 100644 --- a/src/libgit2/transports/smart_pkt.c +++ b/src/libgit2/transports/smart_pkt.c @@ -770,7 +770,7 @@ int git_pkt_buffer_wants( size_t oid_hexsize, want_len, i = 0; #ifdef GIT_EXPERIMENTAL_SHA256 - oid_type = wants->count > 0 ? wants->refs[0]->oid.type : GIT_OID_SHA1; + oid_type = wants->refs_len > 0 ? wants->refs[0]->oid.type : GIT_OID_SHA1; #else oid_type = GIT_OID_SHA1; #endif @@ -781,7 +781,7 @@ int git_pkt_buffer_wants( oid_hexsize + 1 /* LF */; if (caps->common) { - for (; i < wants->count; ++i) { + for (; i < wants->refs_len; ++i) { head = wants->refs[i]; if (!head->local) break; @@ -793,7 +793,7 @@ int git_pkt_buffer_wants( i++; } - for (; i < wants->count; ++i) { + for (; i < wants->refs_len; ++i) { head = wants->refs[i]; if (head->local) @@ -810,12 +810,11 @@ int git_pkt_buffer_wants( } /* Tell the server about our shallow objects */ - for (i = 0; i < git_shallowarray_count(wants->shallow_roots); i++) { + for (i = 0; i < wants->shallow_roots_len; i++) { char oid[GIT_OID_MAX_HEXSIZE + 1]; git_str shallow_buf = GIT_STR_INIT; - git_oid_tostr(oid, GIT_OID_MAX_HEXSIZE + 1, - git_shallowarray_get(wants->shallow_roots, i)); + git_oid_tostr(oid, GIT_OID_MAX_HEXSIZE + 1, &wants->shallow_roots[i]); git_str_puts(&shallow_buf, "shallow "); git_str_puts(&shallow_buf, oid); git_str_putc(&shallow_buf, '\n'); @@ -835,7 +834,7 @@ int git_pkt_buffer_wants( git_str_printf(buf,"%04x%s", (unsigned int)git_str_len(&deepen_buf) + 4, git_str_cstr(&deepen_buf)); git_str_dispose(&deepen_buf); - + if (git_str_oom(buf)) return -1; } diff --git a/src/libgit2/transports/smart_protocol.c b/src/libgit2/transports/smart_protocol.c index 6167a807409..488ef07c089 100644 --- a/src/libgit2/transports/smart_protocol.c +++ b/src/libgit2/transports/smart_protocol.c @@ -364,7 +364,9 @@ static int cap_not_sup_err(const char *cap_name) } /* Disables server capabilities we're not interested in */ -static int setup_caps(transport_smart_caps *caps, const git_fetch_negotiation *wants) +static int setup_caps( + transport_smart_caps *caps, + const git_fetch_negotiation *wants) { if (wants->depth > 0) { if (!caps->shallow) @@ -376,7 +378,27 @@ static int setup_caps(transport_smart_caps *caps, const git_fetch_negotiation *w return 0; } -int git_smart__negotiate_fetch(git_transport *transport, git_repository *repo, const git_fetch_negotiation *wants) +static int setup_shallow_roots( + git_array_oid_t *out, + const git_fetch_negotiation *wants) +{ + git_array_clear(*out); + + if (wants->shallow_roots_len > 0) { + git_array_init_to_size(*out, wants->shallow_roots_len); + GIT_ERROR_CHECK_ALLOC(out->ptr); + + memcpy(out->ptr, wants->shallow_roots, + sizeof(git_oid) * wants->shallow_roots_len); + } + + return 0; +} + +int git_smart__negotiate_fetch( + git_transport *transport, + git_repository *repo, + const git_fetch_negotiation *wants) { transport_smart *t = (transport_smart *)transport; git_revwalk__push_options opts = GIT_REVWALK__PUSH_OPTIONS_INIT; @@ -388,7 +410,8 @@ int git_smart__negotiate_fetch(git_transport *transport, git_repository *repo, c unsigned int i; git_oid oid; - if ((error = setup_caps(&t->caps, wants)) < 0) + if ((error = setup_caps(&t->caps, wants)) < 0 || + (error = setup_shallow_roots(&t->shallow_roots, wants)) < 0) return error; if ((error = git_pkt_buffer_wants(wants, &t->caps, &data)) < 0) @@ -411,9 +434,9 @@ int git_smart__negotiate_fetch(git_transport *transport, git_repository *repo, c bool complete = false; if (pkt->type == GIT_PKT_SHALLOW) { - git_shallowarray_add(wants->shallow_roots, &pkt->oid); + error = git_oidarray__add(&t->shallow_roots, &pkt->oid); } else if (pkt->type == GIT_PKT_UNSHALLOW) { - git_shallowarray_remove(wants->shallow_roots, &pkt->oid); + git_oidarray__remove(&t->shallow_roots, &pkt->oid); } else if (pkt->type == GIT_PKT_FLUSH) { /* Server is done, stop processing shallow oids */ complete = true; @@ -431,6 +454,7 @@ int git_smart__negotiate_fetch(git_transport *transport, git_repository *repo, c if (error < 0) goto on_error; } + /* * Our support for ACK extensions is simply to parse them. On * the first ACK we will accept that as enough common @@ -531,10 +555,11 @@ int git_smart__negotiate_fetch(git_transport *transport, git_repository *repo, c goto on_error; if (t->cancelled.val) { - git_error_set(GIT_ERROR_NET, "The fetch was cancelled by the user"); + git_error_set(GIT_ERROR_NET, "the fetch was cancelled"); error = GIT_EUSER; goto on_error; } + if ((error = git_smart__negotiation_step(&t->parent, data.ptr, data.size)) < 0) goto on_error; @@ -562,6 +587,25 @@ int git_smart__negotiate_fetch(git_transport *transport, git_repository *repo, c return error; } +int git_smart__shallow_roots(git_oidarray *out, git_transport *transport) +{ + transport_smart *t = (transport_smart *)transport; + size_t len; + + GIT_ERROR_CHECK_ALLOC_MULTIPLY(&len, t->shallow_roots.size, sizeof(git_oid)); + + out->count = t->shallow_roots.size; + + if (len) { + out->ids = git__malloc(len); + memcpy(out->ids, t->shallow_roots.ptr, len); + } else { + out->ids = NULL; + } + + return 0; +} + static int no_sideband(transport_smart *t, struct git_odb_writepack *writepack, gitno_buffer *buf, git_indexer_progress *stats) { int recvd; diff --git a/src/util/array.h b/src/util/array.h index bf66e1c5a55..633d598ee26 100644 --- a/src/util/array.h +++ b/src/util/array.h @@ -33,6 +33,9 @@ #define git_array_init_to_size(a, desired) \ do { (a).size = 0; (a).asize = desired; (a).ptr = git__calloc(desired, sizeof(*(a).ptr)); } while (0) +#define git_array_dispose(a) \ + do { git__free((a).ptr); } while (0) + #define git_array_clear(a) \ do { git__free((a).ptr); git_array_init(a); } while (0) diff --git a/tests/libgit2/core/oidarray.c b/tests/libgit2/core/oidarray.c new file mode 100644 index 00000000000..4a9e47c701d --- /dev/null +++ b/tests/libgit2/core/oidarray.c @@ -0,0 +1,98 @@ +#include "clar_libgit2.h" + +#include "git2/oid.h" +#include "git2/transport.h" + +#include "common.h" +#include "transports/smart.h" +#include "oid.h" +#include "oidarray.h" + +#include + +#define oid_0 "c070ad8c08840c8116da865b2d65593a6bb9cd2a" +#define oid_1 "0966a434eb1a025db6b71485ab63a3bfbea520b6" +#define oid_2 "83834a7afdaa1a1260568567f6ad90020389f664" +#define oid_3 "746fb4c91a7b6190bc4761adf7410afc4b59812c" + +void test_core_oidarray__add_and_remove_oid_from_shallowarray(void) +{ + git_oid oid_0_obj, oid_1_obj, oid_2_obj, oid_3_obj; + git_array_oid_t array = GIT_ARRAY_INIT; + + git_oid__fromstr(&oid_0_obj, oid_0, GIT_OID_SHA1); + git_oid__fromstr(&oid_1_obj, oid_1, GIT_OID_SHA1); + git_oid__fromstr(&oid_2_obj, oid_2, GIT_OID_SHA1); + git_oid__fromstr(&oid_3_obj, oid_3, GIT_OID_SHA1); + + /* add some initial ids */ + git_oidarray__add(&array, &oid_0_obj); + git_oidarray__add(&array, &oid_1_obj); + git_oidarray__add(&array, &oid_2_obj); + + cl_assert_equal_i(3, array.size); + cl_assert_equal_s("c070ad8c08840c8116da865b2d65593a6bb9cd2a", git_oid_tostr_s(&array.ptr[0])); + cl_assert_equal_s("0966a434eb1a025db6b71485ab63a3bfbea520b6", git_oid_tostr_s(&array.ptr[1])); + cl_assert_equal_s("83834a7afdaa1a1260568567f6ad90020389f664", git_oid_tostr_s(&array.ptr[2])); + + /* don't duplicate existing ids */ + git_oidarray__add(&array, &oid_1_obj); + + cl_assert_equal_i(3, array.size); + cl_assert_equal_s("c070ad8c08840c8116da865b2d65593a6bb9cd2a", git_oid_tostr_s(&array.ptr[0])); + cl_assert_equal_s("0966a434eb1a025db6b71485ab63a3bfbea520b6", git_oid_tostr_s(&array.ptr[1])); + cl_assert_equal_s("83834a7afdaa1a1260568567f6ad90020389f664", git_oid_tostr_s(&array.ptr[2])); + + /* remove the last id */ + cl_assert_equal_i(1, git_oidarray__remove(&array, &oid_2_obj)); + + cl_assert_equal_i(2, array.size); + cl_assert_equal_s("c070ad8c08840c8116da865b2d65593a6bb9cd2a", git_oid_tostr_s(&array.ptr[0])); + cl_assert_equal_s("0966a434eb1a025db6b71485ab63a3bfbea520b6", git_oid_tostr_s(&array.ptr[1])); + + /* add another id */ + git_oidarray__add(&array, &oid_3_obj); + + cl_assert_equal_i(3, array.size); + cl_assert_equal_s("c070ad8c08840c8116da865b2d65593a6bb9cd2a", git_oid_tostr_s(&array.ptr[0])); + cl_assert_equal_s("0966a434eb1a025db6b71485ab63a3bfbea520b6", git_oid_tostr_s(&array.ptr[1])); + cl_assert_equal_s("746fb4c91a7b6190bc4761adf7410afc4b59812c", git_oid_tostr_s(&array.ptr[2])); + + /* remove the first id */ + cl_assert_equal_i(1, git_oidarray__remove(&array, &oid_0_obj)); + + cl_assert_equal_i(2, array.size); + cl_assert_equal_s("0966a434eb1a025db6b71485ab63a3bfbea520b6", git_oid_tostr_s(&array.ptr[0])); + cl_assert_equal_s("746fb4c91a7b6190bc4761adf7410afc4b59812c", git_oid_tostr_s(&array.ptr[1])); + + /* removing a nonexistent oid does nothing */ + cl_assert_equal_i(0, git_oidarray__remove(&array, &oid_2_obj)); + + /* add another id */ + git_oidarray__add(&array, &oid_0_obj); + + cl_assert_equal_i(3, array.size); + cl_assert_equal_s("0966a434eb1a025db6b71485ab63a3bfbea520b6", git_oid_tostr_s(&array.ptr[0])); + cl_assert_equal_s("746fb4c91a7b6190bc4761adf7410afc4b59812c", git_oid_tostr_s(&array.ptr[1])); + cl_assert_equal_s("c070ad8c08840c8116da865b2d65593a6bb9cd2a", git_oid_tostr_s(&array.ptr[2])); + + /* remove another id */ + cl_assert_equal_i(1, git_oidarray__remove(&array, &oid_3_obj)); + + cl_assert_equal_i(2, array.size); + cl_assert_equal_s("0966a434eb1a025db6b71485ab63a3bfbea520b6", git_oid_tostr_s(&array.ptr[0])); + cl_assert_equal_s("c070ad8c08840c8116da865b2d65593a6bb9cd2a", git_oid_tostr_s(&array.ptr[1])); + + /* remove another id */ + cl_assert_equal_i(1, git_oidarray__remove(&array, &oid_1_obj)); + + cl_assert_equal_i(1, array.size); + cl_assert_equal_s("c070ad8c08840c8116da865b2d65593a6bb9cd2a", git_oid_tostr_s(&array.ptr[0])); + + /* remove the final id */ + cl_assert_equal_i(1, git_oidarray__remove(&array, &oid_0_obj)); + + cl_assert_equal_i(0, array.size); + + git_array_clear(array); +} diff --git a/tests/libgit2/online/shallow.c b/tests/libgit2/online/shallow.c index a889a68cd6f..12ef7748b1a 100644 --- a/tests/libgit2/online/shallow.c +++ b/tests/libgit2/online/shallow.c @@ -16,7 +16,8 @@ void test_online_shallow__clone_depth_zero(void) git_str path = GIT_STR_INIT; git_repository *repo; git_clone_options clone_opts = GIT_CLONE_OPTIONS_INIT; - git_array_oid_t roots = GIT_ARRAY_INIT; + git_oid *roots; + size_t roots_len; clone_opts.fetch_opts.depth = 0; clone_opts.remote_cb = remote_single_branch; @@ -29,10 +30,10 @@ void test_online_shallow__clone_depth_zero(void) cl_assert_equal_b(false, git_repository_is_shallow(repo)); /* full clones do not have shallow roots. */ - cl_git_pass(git_repository__shallow_roots(&roots, repo)); - cl_assert_equal_i(0, roots.size); + cl_git_pass(git_repository__shallow_roots(&roots, &roots_len, repo)); + cl_assert_equal_i(0, roots_len); - git_array_clear(roots); + git__free(roots); git_str_dispose(&path); git_repository_free(repo); } @@ -44,7 +45,8 @@ void test_online_shallow__clone_depth_one(void) git_revwalk *walk; git_clone_options clone_opts = GIT_CLONE_OPTIONS_INIT; git_oid oid; - git_array_oid_t roots = GIT_ARRAY_INIT; + git_oid *roots; + size_t roots_len; size_t num_commits = 0; int error = 0; @@ -57,9 +59,9 @@ void test_online_shallow__clone_depth_one(void) cl_assert_equal_b(true, git_repository_is_shallow(repo)); - cl_git_pass(git_repository__shallow_roots(&roots, repo)); - cl_assert_equal_i(1, roots.size); - cl_assert_equal_s("49322bb17d3acc9146f98c97d078513228bbf3c0", git_oid_tostr_s(&roots.ptr[0])); + cl_git_pass(git_repository__shallow_roots(&roots, &roots_len, repo)); + cl_assert_equal_i(1, roots_len); + cl_assert_equal_s("49322bb17d3acc9146f98c97d078513228bbf3c0", git_oid_tostr_s(&roots[0])); git_revwalk_new(&walk, repo); @@ -72,7 +74,7 @@ void test_online_shallow__clone_depth_one(void) cl_assert_equal_i(num_commits, 1); cl_assert_equal_i(error, GIT_ITEROVER); - git_array_clear(roots); + git__free(roots); git_str_dispose(&path); git_revwalk_free(walk); git_repository_free(repo); @@ -85,7 +87,8 @@ void test_online_shallow__clone_depth_five(void) git_revwalk *walk; git_clone_options clone_opts = GIT_CLONE_OPTIONS_INIT; git_oid oid; - git_array_oid_t roots = GIT_ARRAY_INIT; + git_oid *roots; + size_t roots_len; size_t num_commits = 0; int error = 0; @@ -98,11 +101,11 @@ void test_online_shallow__clone_depth_five(void) cl_assert_equal_b(true, git_repository_is_shallow(repo)); - cl_git_pass(git_repository__shallow_roots(&roots, repo)); - cl_assert_equal_i(3, roots.size); - cl_assert_equal_s("c070ad8c08840c8116da865b2d65593a6bb9cd2a", git_oid_tostr_s(&roots.ptr[0])); - cl_assert_equal_s("0966a434eb1a025db6b71485ab63a3bfbea520b6", git_oid_tostr_s(&roots.ptr[1])); - cl_assert_equal_s("83834a7afdaa1a1260568567f6ad90020389f664", git_oid_tostr_s(&roots.ptr[2])); + cl_git_pass(git_repository__shallow_roots(&roots, &roots_len, repo)); + cl_assert_equal_i(3, roots_len); + cl_assert_equal_s("c070ad8c08840c8116da865b2d65593a6bb9cd2a", git_oid_tostr_s(&roots[0])); + cl_assert_equal_s("0966a434eb1a025db6b71485ab63a3bfbea520b6", git_oid_tostr_s(&roots[1])); + cl_assert_equal_s("83834a7afdaa1a1260568567f6ad90020389f664", git_oid_tostr_s(&roots[2])); git_revwalk_new(&walk, repo); @@ -115,7 +118,7 @@ void test_online_shallow__clone_depth_five(void) cl_assert_equal_i(num_commits, 13); cl_assert_equal_i(error, GIT_ITEROVER); - git_array_clear(roots); + git__free(roots); git_str_dispose(&path); git_revwalk_free(walk); git_repository_free(repo); diff --git a/tests/libgit2/transports/smart/shallowarray.c b/tests/libgit2/transports/smart/shallowarray.c deleted file mode 100644 index 34511c5f641..00000000000 --- a/tests/libgit2/transports/smart/shallowarray.c +++ /dev/null @@ -1,52 +0,0 @@ -#include "clar_libgit2.h" - -#include "git2/oid.h" -#include "git2/transport.h" - -#include "common.h" -#include "transports/smart.h" -#include "oid.h" - -#include - -#define oid_0 "c070ad8c08840c8116da865b2d65593a6bb9cd2a" -#define oid_1 "0966a434eb1a025db6b71485ab63a3bfbea520b6" -#define oid_2 "83834a7afdaa1a1260568567f6ad90020389f664" - -void test_transports_smart_shallowarray__add_and_remove_oid_from_shallowarray(void) -{ - git_oid oid_0_obj, oid_1_obj, oid_2_obj; - git_shallowarray *shallow_roots = git__malloc(sizeof(git_shallowarray)); - git_array_init(shallow_roots->array); - - git_oid__fromstr(&oid_0_obj, oid_0, GIT_OID_SHA1); - git_oid__fromstr(&oid_1_obj, oid_1, GIT_OID_SHA1); - git_oid__fromstr(&oid_2_obj, oid_2, GIT_OID_SHA1); - - git_shallowarray_add(shallow_roots, &oid_0_obj); - git_shallowarray_add(shallow_roots, &oid_1_obj); - git_shallowarray_add(shallow_roots, &oid_2_obj); - - cl_assert_equal_i(3, shallow_roots->array.size); - cl_assert_equal_s("c070ad8c08840c8116da865b2d65593a6bb9cd2a", git_oid_tostr_s(&shallow_roots->array.ptr[0])); - cl_assert_equal_s("0966a434eb1a025db6b71485ab63a3bfbea520b6", git_oid_tostr_s(&shallow_roots->array.ptr[1])); - cl_assert_equal_s("83834a7afdaa1a1260568567f6ad90020389f664", git_oid_tostr_s(&shallow_roots->array.ptr[2])); - - git_shallowarray_remove(shallow_roots, &oid_2_obj); - - cl_assert_equal_i(2, shallow_roots->array.size); - cl_assert_equal_s("c070ad8c08840c8116da865b2d65593a6bb9cd2a", git_oid_tostr_s(&shallow_roots->array.ptr[0])); - cl_assert_equal_s("0966a434eb1a025db6b71485ab63a3bfbea520b6", git_oid_tostr_s(&shallow_roots->array.ptr[1])); - - git_shallowarray_remove(shallow_roots, &oid_1_obj); - - cl_assert_equal_i(1, shallow_roots->array.size); - cl_assert_equal_s("c070ad8c08840c8116da865b2d65593a6bb9cd2a", git_oid_tostr_s(&shallow_roots->array.ptr[0])); - - git_shallowarray_remove(shallow_roots, &oid_0_obj); - - cl_assert_equal_i(0, shallow_roots->array.size); - - git_array_clear(shallow_roots->array); - git__free(shallow_roots); -} From 437c5f5a0b6ae6068168081ac6422dba44cff31d Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 8 May 2023 10:17:11 +0100 Subject: [PATCH 259/608] fetch: remove `unshallow` option The `depth` field is suitable to specify unshallowing; provide an enum to aide in specifying the `unshallow` value. --- include/git2/remote.h | 22 +++++++++++++--------- src/libgit2/fetch.c | 4 +--- tests/libgit2/online/shallow.c | 2 +- 3 files changed, 15 insertions(+), 13 deletions(-) diff --git a/include/git2/remote.h b/include/git2/remote.h index 8d612701416..e9065b250c1 100644 --- a/include/git2/remote.h +++ b/include/git2/remote.h @@ -702,6 +702,15 @@ typedef enum { GIT_REMOTE_DOWNLOAD_TAGS_ALL } git_remote_autotag_option_t; +/** Constants for fetch depth (shallowness of fetch). */ +typedef enum { + /** The fetch is "full" (not shallow). This is the default. */ + GIT_FETCH_DEPTH_FULL = 0, + + /** The fetch should "unshallow" and fetch missing data. */ + GIT_FETCH_DEPTH_UNSHALLOW = 2147483647 +} git_fetch_depth_t; + /** * Fetch options structure. * @@ -744,19 +753,14 @@ typedef struct { git_proxy_options proxy_opts; /** - * Depth of the fetch to perform, or 0 for full history. + * Depth of the fetch to perform, or `GIT_FETCH_DEPTH_FULL` + * (or `0`) for full history, or `GIT_FETCH_DEPTH_UNSHALLOW` + * to "unshallow" a shallow repository. * - * The default is 0. + * The default is full (`GIT_FETCH_DEPTH_FULL` or `0`). */ int depth; - /** - * Convert a shallow repository to a full repository. - * - * The default is 0, which means the flag is off. - */ - int unshallow; - /** * Whether to allow off-site redirects. If this is not * specified, the `http.followRedirects` configuration setting diff --git a/src/libgit2/fetch.c b/src/libgit2/fetch.c index b4342521591..5bbef87f4e0 100644 --- a/src/libgit2/fetch.c +++ b/src/libgit2/fetch.c @@ -174,10 +174,8 @@ int git_fetch_negotiate(git_remote *remote, const git_fetch_options *opts) remote->need_pack = 0; if (opts) { - GIT_ASSERT_ARG(opts->unshallow == 0 || opts->depth == 0); GIT_ASSERT_ARG(opts->depth >= 0); - - remote->nego.depth = opts->unshallow ? INT_MAX : opts->depth; + remote->nego.depth = opts->depth; } if (filter_wants(remote, opts) < 0) diff --git a/tests/libgit2/online/shallow.c b/tests/libgit2/online/shallow.c index 12ef7748b1a..5c0e6565b03 100644 --- a/tests/libgit2/online/shallow.c +++ b/tests/libgit2/online/shallow.c @@ -143,7 +143,7 @@ void test_online_shallow__unshallow(void) cl_git_pass(git_clone(&repo, "https://github.com/libgit2/TestGitRepository", git_str_cstr(&path), &clone_opts)); cl_assert_equal_b(true, git_repository_is_shallow(repo)); - fetch_opts.unshallow = 1; + fetch_opts.depth = GIT_FETCH_DEPTH_UNSHALLOW; cl_git_pass(git_remote_lookup(&origin, repo, "origin")); cl_git_pass(git_remote_fetch(origin, NULL, &fetch_opts, NULL)); From a821455ee430d28d0032b91ba89b414b4b724464 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 11 May 2023 21:43:38 +0100 Subject: [PATCH 260/608] util: add GIT_UNUSED_ARG Add `GIT_UNUSED_ARG` which is an attribute for arguments, for compatibility with dependencies. --- src/util/cc-compat.h | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/util/cc-compat.h b/src/util/cc-compat.h index a0971e86c98..ede6e9aa9a1 100644 --- a/src/util/cc-compat.h +++ b/src/util/cc-compat.h @@ -43,8 +43,10 @@ __typeof__(x) _unused __attribute__((unused)); \ _unused = (x); \ } while (0) +# define GIT_UNUSED_ARG __attribute__((unused)) #else # define GIT_UNUSED(x) ((void)(x)) +# define GIT_UNUSED_ARG #endif /* Define the printf format specifier to use for size_t output */ From 027630ddd42e5ab4f4f5a221f38a3fd5bda4e3d4 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 11 May 2023 21:44:17 +0100 Subject: [PATCH 261/608] xdiff: update to xdiff from git 2.40.1 --- deps/xdiff/git-xdiff.h | 5 +++- deps/xdiff/xdiffi.c | 37 +++++++++++++++--------------- deps/xdiff/xdiffi.h | 6 ++--- deps/xdiff/xemit.c | 6 ++--- deps/xdiff/xhistogram.c | 25 ++++++-------------- deps/xdiff/xmacros.h | 19 ++++++++++++++- deps/xdiff/xmerge.c | 46 +++++++++++++++++++------------------ deps/xdiff/xpatience.c | 51 +++++++++++++++++------------------------ deps/xdiff/xprepare.c | 43 +++++++++++----------------------- deps/xdiff/xutils.c | 19 ++++++++++++++- deps/xdiff/xutils.h | 3 ++- 11 files changed, 131 insertions(+), 129 deletions(-) diff --git a/deps/xdiff/git-xdiff.h b/deps/xdiff/git-xdiff.h index b75dba8195a..1450ab3dd21 100644 --- a/deps/xdiff/git-xdiff.h +++ b/deps/xdiff/git-xdiff.h @@ -27,11 +27,14 @@ # endif #endif +#define XDL_UNUSED GIT_UNUSED_ARG + #define xdl_malloc(x) git__malloc(x) +#define xdl_calloc(n, sz) git__calloc(n, sz) #define xdl_free(ptr) git__free(ptr) #define xdl_realloc(ptr, x) git__realloc(ptr, x) -#define XDL_BUG(msg) GIT_ASSERT(msg) +#define XDL_BUG(msg) GIT_ASSERT(!msg) #define xdl_regex_t git_regexp #define xdl_regmatch_t git_regmatch diff --git a/deps/xdiff/xdiffi.c b/deps/xdiff/xdiffi.c index af31b7f4b39..ea36143af2c 100644 --- a/deps/xdiff/xdiffi.c +++ b/deps/xdiff/xdiffi.c @@ -315,16 +315,19 @@ int xdl_do_diff(mmfile_t *mf1, mmfile_t *mf2, xpparam_t const *xpp, long *kvd, *kvdf, *kvdb; xdalgoenv_t xenv; diffdata_t dd1, dd2; + int res; - if (XDF_DIFF_ALG(xpp->flags) == XDF_PATIENCE_DIFF) - return xdl_do_patience_diff(mf1, mf2, xpp, xe); - - if (XDF_DIFF_ALG(xpp->flags) == XDF_HISTOGRAM_DIFF) - return xdl_do_histogram_diff(mf1, mf2, xpp, xe); + if (xdl_prepare_env(mf1, mf2, xpp, xe) < 0) + return -1; - if (xdl_prepare_env(mf1, mf2, xpp, xe) < 0) { + if (XDF_DIFF_ALG(xpp->flags) == XDF_PATIENCE_DIFF) { + res = xdl_do_patience_diff(xpp, xe); + goto out; + } - return -1; + if (XDF_DIFF_ALG(xpp->flags) == XDF_HISTOGRAM_DIFF) { + res = xdl_do_histogram_diff(xpp, xe); + goto out; } /* @@ -334,7 +337,7 @@ int xdl_do_diff(mmfile_t *mf1, mmfile_t *mf2, xpparam_t const *xpp, * One is to store the forward path and one to store the backward path. */ ndiags = xe->xdf1.nreff + xe->xdf2.nreff + 3; - if (!(kvd = (long *) xdl_malloc((2 * ndiags + 2) * sizeof(long)))) { + if (!XDL_ALLOC_ARRAY(kvd, 2 * ndiags + 2)) { xdl_free_env(xe); return -1; @@ -359,17 +362,15 @@ int xdl_do_diff(mmfile_t *mf1, mmfile_t *mf2, xpparam_t const *xpp, dd2.rchg = xe->xdf2.rchg; dd2.rindex = xe->xdf2.rindex; - if (xdl_recs_cmp(&dd1, 0, dd1.nrec, &dd2, 0, dd2.nrec, - kvdf, kvdb, (xpp->flags & XDF_NEED_MINIMAL) != 0, &xenv) < 0) { - - xdl_free(kvd); - xdl_free_env(xe); - return -1; - } - + res = xdl_recs_cmp(&dd1, 0, dd1.nrec, &dd2, 0, dd2.nrec, + kvdf, kvdb, (xpp->flags & XDF_NEED_MINIMAL) != 0, + &xenv); xdl_free(kvd); + out: + if (res < 0) + xdl_free_env(xe); - return 0; + return res; } @@ -972,7 +973,7 @@ void xdl_free_script(xdchange_t *xscr) { } } -static int xdl_call_hunk_func(xdfenv_t *xe, xdchange_t *xscr, xdemitcb_t *ecb, +static int xdl_call_hunk_func(xdfenv_t *xe XDL_UNUSED, xdchange_t *xscr, xdemitcb_t *ecb, xdemitconf_t const *xecfg) { xdchange_t *xch, *xche; diff --git a/deps/xdiff/xdiffi.h b/deps/xdiff/xdiffi.h index 8f1c7c8b044..126c9d8ff4e 100644 --- a/deps/xdiff/xdiffi.h +++ b/deps/xdiff/xdiffi.h @@ -56,9 +56,7 @@ int xdl_build_script(xdfenv_t *xe, xdchange_t **xscr); void xdl_free_script(xdchange_t *xscr); int xdl_emit_diff(xdfenv_t *xe, xdchange_t *xscr, xdemitcb_t *ecb, xdemitconf_t const *xecfg); -int xdl_do_patience_diff(mmfile_t *mf1, mmfile_t *mf2, xpparam_t const *xpp, - xdfenv_t *env); -int xdl_do_histogram_diff(mmfile_t *mf1, mmfile_t *mf2, xpparam_t const *xpp, - xdfenv_t *env); +int xdl_do_patience_diff(xpparam_t const *xpp, xdfenv_t *env); +int xdl_do_histogram_diff(xpparam_t const *xpp, xdfenv_t *env); #endif /* #if !defined(XDIFFI_H) */ diff --git a/deps/xdiff/xemit.c b/deps/xdiff/xemit.c index 1cbf2b9829e..75f0fe49866 100644 --- a/deps/xdiff/xemit.c +++ b/deps/xdiff/xemit.c @@ -65,7 +65,7 @@ xdchange_t *xdl_get_hunk(xdchange_t **xscr, xdemitconf_t const *xecfg) *xscr = xch; } - if (*xscr == NULL) + if (!*xscr) return NULL; lxch = *xscr; @@ -95,7 +95,7 @@ xdchange_t *xdl_get_hunk(xdchange_t **xscr, xdemitconf_t const *xecfg) } -static long def_ff(const char *rec, long len, char *buf, long sz, void *priv) +static long def_ff(const char *rec, long len, char *buf, long sz) { if (len > 0 && (isalpha((unsigned char)*rec) || /* identifier? */ @@ -117,7 +117,7 @@ static long match_func_rec(xdfile_t *xdf, xdemitconf_t const *xecfg, long ri, const char *rec; long len = xdl_get_rec(xdf, ri, &rec); if (!xecfg->find_func) - return def_ff(rec, len, buf, sz, xecfg->find_func_priv); + return def_ff(rec, len, buf, sz); return xecfg->find_func(rec, len, buf, sz, xecfg->find_func_priv); } diff --git a/deps/xdiff/xhistogram.c b/deps/xdiff/xhistogram.c index 80794748b0d..16a8fe2f3f3 100644 --- a/deps/xdiff/xhistogram.c +++ b/deps/xdiff/xhistogram.c @@ -251,7 +251,7 @@ static int find_lcs(xpparam_t const *xpp, xdfenv_t *env, int line1, int count1, int line2, int count2) { int b_ptr; - int sz, ret = -1; + int ret = -1; struct histindex index; memset(&index, 0, sizeof(index)); @@ -265,23 +265,16 @@ static int find_lcs(xpparam_t const *xpp, xdfenv_t *env, index.rcha.head = NULL; index.table_bits = xdl_hashbits(count1); - sz = index.records_size = 1 << index.table_bits; - sz *= sizeof(struct record *); - if (!(index.records = (struct record **) xdl_malloc(sz))) + index.records_size = 1 << index.table_bits; + if (!XDL_CALLOC_ARRAY(index.records, index.records_size)) goto cleanup; - memset(index.records, 0, sz); - sz = index.line_map_size = count1; - sz *= sizeof(struct record *); - if (!(index.line_map = (struct record **) xdl_malloc(sz))) + index.line_map_size = count1; + if (!XDL_CALLOC_ARRAY(index.line_map, index.line_map_size)) goto cleanup; - memset(index.line_map, 0, sz); - sz = index.line_map_size; - sz *= sizeof(unsigned int); - if (!(index.next_ptrs = (unsigned int *) xdl_malloc(sz))) + if (!XDL_CALLOC_ARRAY(index.next_ptrs, index.line_map_size)) goto cleanup; - memset(index.next_ptrs, 0, sz); /* lines / 4 + 1 comes from xprepare.c:xdl_prepare_ctx() */ if (xdl_cha_init(&index.rcha, sizeof(struct record), count1 / 4 + 1) < 0) @@ -369,12 +362,8 @@ static int histogram_diff(xpparam_t const *xpp, xdfenv_t *env, return result; } -int xdl_do_histogram_diff(mmfile_t *file1, mmfile_t *file2, - xpparam_t const *xpp, xdfenv_t *env) +int xdl_do_histogram_diff(xpparam_t const *xpp, xdfenv_t *env) { - if (xdl_prepare_env(file1, file2, xpp, env) < 0) - return -1; - return histogram_diff(xpp, env, env->xdf1.dstart + 1, env->xdf1.dend - env->xdf1.dstart + 1, env->xdf2.dstart + 1, env->xdf2.dend - env->xdf2.dstart + 1); diff --git a/deps/xdiff/xmacros.h b/deps/xdiff/xmacros.h index 2809a28ca96..8487bb396fa 100644 --- a/deps/xdiff/xmacros.h +++ b/deps/xdiff/xmacros.h @@ -34,7 +34,6 @@ #define XDL_ADDBITS(v,b) ((v) + ((v) >> (b))) #define XDL_MASKBITS(b) ((1UL << (b)) - 1) #define XDL_HASHLONG(v,b) (XDL_ADDBITS((unsigned long)(v), b) & XDL_MASKBITS(b)) -#define XDL_PTRFREE(p) do { if (p) { xdl_free(p); (p) = NULL; } } while (0) #define XDL_LE32_PUT(p, v) \ do { \ unsigned char *__p = (unsigned char *) (p); \ @@ -50,5 +49,23 @@ do { \ ((unsigned long) __p[2]) << 16 | ((unsigned long) __p[3]) << 24; \ } while (0) +/* Allocate an array of nr elements, returns NULL on failure */ +#define XDL_ALLOC_ARRAY(p, nr) \ + ((p) = SIZE_MAX / sizeof(*(p)) >= (size_t)(nr) \ + ? xdl_malloc((nr) * sizeof(*(p))) \ + : NULL) + +/* Allocate an array of nr zeroed out elements, returns NULL on failure */ +#define XDL_CALLOC_ARRAY(p, nr) ((p) = xdl_calloc(nr, sizeof(*(p)))) + +/* + * Ensure array p can accommodate at least nr elements, growing the + * array and updating alloc (which is the number of allocated + * elements) as necessary. Frees p and returns -1 on failure, returns + * 0 on success + */ +#define XDL_ALLOC_GROW(p, nr, alloc) \ + (-!((nr) <= (alloc) || \ + ((p) = xdl_alloc_grow_helper((p), (nr), &(alloc), sizeof(*(p)))))) #endif /* #if !defined(XMACROS_H) */ diff --git a/deps/xdiff/xmerge.c b/deps/xdiff/xmerge.c index 433e2d74157..af40c88a5b3 100644 --- a/deps/xdiff/xmerge.c +++ b/deps/xdiff/xmerge.c @@ -88,7 +88,7 @@ static int xdl_cleanup_merge(xdmerge_t *c) if (c->mode == 0) count++; next_c = c->next; - xdl_free(c); + free(c); } return count; } @@ -456,7 +456,7 @@ static void xdl_merge_two_conflicts(xdmerge_t *m) m->chg1 = next_m->i1 + next_m->chg1 - m->i1; m->chg2 = next_m->i2 + next_m->chg2 - m->i2; m->next = next_m->next; - xdl_free(next_m); + free(next_m); } /* @@ -684,42 +684,42 @@ static int xdl_do_merge(xdfenv_t *xe1, xdchange_t *xscr1, int xdl_merge(mmfile_t *orig, mmfile_t *mf1, mmfile_t *mf2, xmparam_t const *xmp, mmbuffer_t *result) { - xdchange_t *xscr1, *xscr2; + xdchange_t *xscr1 = NULL, *xscr2 = NULL; xdfenv_t xe1, xe2; - int status; + int status = -1; xpparam_t const *xpp = &xmp->xpp; result->ptr = NULL; result->size = 0; - if (xdl_do_diff(orig, mf1, xpp, &xe1) < 0) { + if (xdl_do_diff(orig, mf1, xpp, &xe1) < 0) return -1; - } - if (xdl_do_diff(orig, mf2, xpp, &xe2) < 0) { - xdl_free_env(&xe1); - return -1; - } + + if (xdl_do_diff(orig, mf2, xpp, &xe2) < 0) + goto free_xe1; /* avoid double free of xe2 */ + if (xdl_change_compact(&xe1.xdf1, &xe1.xdf2, xpp->flags) < 0 || xdl_change_compact(&xe1.xdf2, &xe1.xdf1, xpp->flags) < 0 || - xdl_build_script(&xe1, &xscr1) < 0) { - xdl_free_env(&xe1); - return -1; - } + xdl_build_script(&xe1, &xscr1) < 0) + goto out; + if (xdl_change_compact(&xe2.xdf1, &xe2.xdf2, xpp->flags) < 0 || xdl_change_compact(&xe2.xdf2, &xe2.xdf1, xpp->flags) < 0 || - xdl_build_script(&xe2, &xscr2) < 0) { - xdl_free_script(xscr1); - xdl_free_env(&xe1); - xdl_free_env(&xe2); - return -1; - } - status = 0; + xdl_build_script(&xe2, &xscr2) < 0) + goto out; + if (!xscr1) { result->ptr = xdl_malloc(mf2->size); + if (!result->ptr) + goto out; + status = 0; memcpy(result->ptr, mf2->ptr, mf2->size); result->size = mf2->size; } else if (!xscr2) { result->ptr = xdl_malloc(mf1->size); + if (!result->ptr) + goto out; + status = 0; memcpy(result->ptr, mf1->ptr, mf1->size); result->size = mf1->size; } else { @@ -727,11 +727,13 @@ int xdl_merge(mmfile_t *orig, mmfile_t *mf1, mmfile_t *mf2, &xe2, xscr2, xmp, result); } + out: xdl_free_script(xscr1); xdl_free_script(xscr2); - xdl_free_env(&xe1); xdl_free_env(&xe2); + free_xe1: + xdl_free_env(&xe1); return status; } diff --git a/deps/xdiff/xpatience.c b/deps/xdiff/xpatience.c index c5d48e80aef..a2d8955537f 100644 --- a/deps/xdiff/xpatience.c +++ b/deps/xdiff/xpatience.c @@ -69,7 +69,6 @@ struct hashmap { } *entries, *first, *last; /* were common records found? */ unsigned long has_matches; - mmfile_t *file1, *file2; xdfenv_t *env; xpparam_t const *xpp; }; @@ -139,23 +138,17 @@ static void insert_record(xpparam_t const *xpp, int line, struct hashmap *map, * * It is assumed that env has been prepared using xdl_prepare(). */ -static int fill_hashmap(mmfile_t *file1, mmfile_t *file2, - xpparam_t const *xpp, xdfenv_t *env, +static int fill_hashmap(xpparam_t const *xpp, xdfenv_t *env, struct hashmap *result, int line1, int count1, int line2, int count2) { - result->file1 = file1; - result->file2 = file2; result->xpp = xpp; result->env = env; /* We know exactly how large we want the hash map */ result->alloc = count1 * 2; - result->entries = (struct entry *) - xdl_malloc(result->alloc * sizeof(struct entry)); - if (!result->entries) + if (!XDL_CALLOC_ARRAY(result->entries, result->alloc)) return -1; - memset(result->entries, 0, result->alloc * sizeof(struct entry)); /* First, fill with entries from the first file */ while (count1--) @@ -198,9 +191,9 @@ static int binary_search(struct entry **sequence, int longest, * item per sequence length: the sequence with the smallest last * element (in terms of line2). */ -static struct entry *find_longest_common_sequence(struct hashmap *map) +static int find_longest_common_sequence(struct hashmap *map, struct entry **res) { - struct entry **sequence = xdl_malloc(map->nr * sizeof(struct entry *)); + struct entry **sequence; int longest = 0, i; struct entry *entry; @@ -211,6 +204,9 @@ static struct entry *find_longest_common_sequence(struct hashmap *map) */ int anchor_i = -1; + if (!XDL_ALLOC_ARRAY(sequence, map->nr)) + return -1; + for (entry = map->first; entry; entry = entry->next) { if (!entry->line2 || entry->line2 == NON_UNIQUE) continue; @@ -230,8 +226,9 @@ static struct entry *find_longest_common_sequence(struct hashmap *map) /* No common unique lines were found */ if (!longest) { + *res = NULL; xdl_free(sequence); - return NULL; + return 0; } /* Iterate starting at the last element, adjusting the "next" members */ @@ -241,8 +238,9 @@ static struct entry *find_longest_common_sequence(struct hashmap *map) entry->previous->next = entry; entry = entry->previous; } + *res = entry; xdl_free(sequence); - return entry; + return 0; } static int match(struct hashmap *map, int line1, int line2) @@ -252,8 +250,7 @@ static int match(struct hashmap *map, int line1, int line2) return record1->ha == record2->ha; } -static int patience_diff(mmfile_t *file1, mmfile_t *file2, - xpparam_t const *xpp, xdfenv_t *env, +static int patience_diff(xpparam_t const *xpp, xdfenv_t *env, int line1, int count1, int line2, int count2); static int walk_common_sequence(struct hashmap *map, struct entry *first, @@ -284,8 +281,7 @@ static int walk_common_sequence(struct hashmap *map, struct entry *first, /* Recurse */ if (next1 > line1 || next2 > line2) { - if (patience_diff(map->file1, map->file2, - map->xpp, map->env, + if (patience_diff(map->xpp, map->env, line1, next1 - line1, line2, next2 - line2)) return -1; @@ -324,8 +320,7 @@ static int fall_back_to_classic_diff(struct hashmap *map, * * This function assumes that env was prepared with xdl_prepare_env(). */ -static int patience_diff(mmfile_t *file1, mmfile_t *file2, - xpparam_t const *xpp, xdfenv_t *env, +static int patience_diff(xpparam_t const *xpp, xdfenv_t *env, int line1, int count1, int line2, int count2) { struct hashmap map; @@ -344,7 +339,7 @@ static int patience_diff(mmfile_t *file1, mmfile_t *file2, } memset(&map, 0, sizeof(map)); - if (fill_hashmap(file1, file2, xpp, env, &map, + if (fill_hashmap(xpp, env, &map, line1, count1, line2, count2)) return -1; @@ -358,25 +353,21 @@ static int patience_diff(mmfile_t *file1, mmfile_t *file2, return 0; } - first = find_longest_common_sequence(&map); + result = find_longest_common_sequence(&map, &first); + if (result) + goto out; if (first) result = walk_common_sequence(&map, first, line1, count1, line2, count2); else result = fall_back_to_classic_diff(&map, line1, count1, line2, count2); - + out: xdl_free(map.entries); return result; } -int xdl_do_patience_diff(mmfile_t *file1, mmfile_t *file2, - xpparam_t const *xpp, xdfenv_t *env) +int xdl_do_patience_diff(xpparam_t const *xpp, xdfenv_t *env) { - if (xdl_prepare_env(file1, file2, xpp, env) < 0) - return -1; - - /* environment is cleaned up in xdl_diff() */ - return patience_diff(file1, file2, xpp, env, - 1, env->xdf1.nrec, 1, env->xdf2.nrec); + return patience_diff(xpp, env, 1, env->xdf1.nrec, 1, env->xdf2.nrec); } diff --git a/deps/xdiff/xprepare.c b/deps/xdiff/xprepare.c index 4527a4a07c4..c84549f6c50 100644 --- a/deps/xdiff/xprepare.c +++ b/deps/xdiff/xprepare.c @@ -78,15 +78,14 @@ static int xdl_init_classifier(xdlclassifier_t *cf, long size, long flags) { return -1; } - if (!(cf->rchash = (xdlclass_t **) xdl_malloc(cf->hsize * sizeof(xdlclass_t *)))) { + if (!XDL_CALLOC_ARRAY(cf->rchash, cf->hsize)) { xdl_cha_free(&cf->ncha); return -1; } - memset(cf->rchash, 0, cf->hsize * sizeof(xdlclass_t *)); cf->alloc = size; - if (!(cf->rcrecs = (xdlclass_t **) xdl_malloc(cf->alloc * sizeof(xdlclass_t *)))) { + if (!XDL_ALLOC_ARRAY(cf->rcrecs, cf->alloc)) { xdl_free(cf->rchash); xdl_cha_free(&cf->ncha); @@ -112,7 +111,6 @@ static int xdl_classify_record(unsigned int pass, xdlclassifier_t *cf, xrecord_t long hi; char const *line; xdlclass_t *rcrec; - xdlclass_t **rcrecs; line = rec->ptr; hi = (long) XDL_HASHLONG(rec->ha, cf->hbits); @@ -128,14 +126,8 @@ static int xdl_classify_record(unsigned int pass, xdlclassifier_t *cf, xrecord_t return -1; } rcrec->idx = cf->count++; - if (cf->count > cf->alloc) { - cf->alloc *= 2; - if (!(rcrecs = (xdlclass_t **) xdl_realloc(cf->rcrecs, cf->alloc * sizeof(xdlclass_t *)))) { - + if (XDL_ALLOC_GROW(cf->rcrecs, cf->count, cf->alloc)) return -1; - } - cf->rcrecs = rcrecs; - } cf->rcrecs[rcrec->idx] = rcrec; rcrec->line = line; rcrec->size = rec->size; @@ -164,7 +156,7 @@ static int xdl_prepare_ctx(unsigned int pass, mmfile_t *mf, long narec, xpparam_ unsigned long hav; char const *blk, *cur, *top, *prev; xrecord_t *crec; - xrecord_t **recs, **rrecs; + xrecord_t **recs; xrecord_t **rhash; unsigned long *ha; char *rchg; @@ -178,26 +170,21 @@ static int xdl_prepare_ctx(unsigned int pass, mmfile_t *mf, long narec, xpparam_ if (xdl_cha_init(&xdf->rcha, sizeof(xrecord_t), narec / 4 + 1) < 0) goto abort; - if (!(recs = (xrecord_t **) xdl_malloc(narec * sizeof(xrecord_t *)))) + if (!XDL_ALLOC_ARRAY(recs, narec)) goto abort; hbits = xdl_hashbits((unsigned int) narec); hsize = 1 << hbits; - if (!(rhash = (xrecord_t **) xdl_malloc(hsize * sizeof(xrecord_t *)))) + if (!XDL_CALLOC_ARRAY(rhash, hsize)) goto abort; - memset(rhash, 0, hsize * sizeof(xrecord_t *)); nrec = 0; - if ((cur = blk = xdl_mmfile_first(mf, &bsize)) != NULL) { + if ((cur = blk = xdl_mmfile_first(mf, &bsize))) { for (top = blk + bsize; cur < top; ) { prev = cur; hav = xdl_hash_record(&cur, top, xpp->flags); - if (nrec >= narec) { - narec *= 2; - if (!(rrecs = (xrecord_t **) xdl_realloc(recs, narec * sizeof(xrecord_t *)))) - goto abort; - recs = rrecs; - } + if (XDL_ALLOC_GROW(recs, nrec + 1, narec)) + goto abort; if (!(crec = xdl_cha_alloc(&xdf->rcha))) goto abort; crec->ptr = prev; @@ -209,15 +196,14 @@ static int xdl_prepare_ctx(unsigned int pass, mmfile_t *mf, long narec, xpparam_ } } - if (!(rchg = (char *) xdl_malloc((nrec + 2) * sizeof(char)))) + if (!XDL_CALLOC_ARRAY(rchg, nrec + 2)) goto abort; - memset(rchg, 0, (nrec + 2) * sizeof(char)); if ((XDF_DIFF_ALG(xpp->flags) != XDF_PATIENCE_DIFF) && (XDF_DIFF_ALG(xpp->flags) != XDF_HISTOGRAM_DIFF)) { - if (!(rindex = xdl_malloc((nrec + 1) * sizeof(*rindex)))) + if (!XDL_ALLOC_ARRAY(rindex, nrec + 1)) goto abort; - if (!(ha = xdl_malloc((nrec + 1) * sizeof(*ha)))) + if (!XDL_ALLOC_ARRAY(ha, nrec + 1)) goto abort; } @@ -383,11 +369,8 @@ static int xdl_cleanup_records(xdlclassifier_t *cf, xdfile_t *xdf1, xdfile_t *xd xdlclass_t *rcrec; char *dis, *dis1, *dis2; - if (!(dis = (char *) xdl_malloc(xdf1->nrec + xdf2->nrec + 2))) { - + if (!XDL_CALLOC_ARRAY(dis, xdf1->nrec + xdf2->nrec + 2)) return -1; - } - memset(dis, 0, xdf1->nrec + xdf2->nrec + 2); dis1 = dis; dis2 = dis1 + xdf1->nrec + 1; diff --git a/deps/xdiff/xutils.c b/deps/xdiff/xutils.c index cfa6e2220ff..9e36f24875d 100644 --- a/deps/xdiff/xutils.c +++ b/deps/xdiff/xutils.c @@ -122,7 +122,7 @@ long xdl_guess_lines(mmfile_t *mf, long sample) { long nl = 0, size, tsize = 0; char const *data, *cur, *top; - if ((cur = data = xdl_mmfile_first(mf, &size)) != NULL) { + if ((cur = data = xdl_mmfile_first(mf, &size))) { for (top = data + size; nl < sample && cur < top; ) { nl++; if (!(cur = memchr(cur, '\n', top - cur))) @@ -432,3 +432,20 @@ int xdl_fall_back_diff(xdfenv_t *diff_env, xpparam_t const *xpp, return 0; } + +void* xdl_alloc_grow_helper(void *p, long nr, long *alloc, size_t size) +{ + void *tmp = NULL; + size_t n = ((LONG_MAX - 16) / 2 >= *alloc) ? 2 * *alloc + 16 : LONG_MAX; + if (nr > n) + n = nr; + if (SIZE_MAX / size >= n) + tmp = xdl_realloc(p, n * size); + if (tmp) { + *alloc = n; + } else { + xdl_free(p); + *alloc = 0; + } + return tmp; +} diff --git a/deps/xdiff/xutils.h b/deps/xdiff/xutils.h index fba7bae03c7..fd0bba94e8b 100644 --- a/deps/xdiff/xutils.h +++ b/deps/xdiff/xutils.h @@ -42,6 +42,7 @@ int xdl_emit_hunk_hdr(long s1, long c1, long s2, long c2, int xdl_fall_back_diff(xdfenv_t *diff_env, xpparam_t const *xpp, int line1, int count1, int line2, int count2); - +/* Do not call this function, use XDL_ALLOC_GROW instead */ +void* xdl_alloc_grow_helper(void* p, long nr, long* alloc, size_t size); #endif /* #if !defined(XUTILS_H) */ From 767a9a733ca64928d395318a9cda47822241b879 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 12 May 2023 21:33:45 +0100 Subject: [PATCH 262/608] cmake: simplify QSORT names `QSORT_R` and `QSORT_S` -> `QSORT` --- src/CMakeLists.txt | 8 ++++---- src/util/git2_features.h.in | 8 ++++---- src/util/util.c | 22 ++++++++++++---------- 3 files changed, 20 insertions(+), 18 deletions(-) diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index db0fd10c75d..bdf513842c8 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -69,25 +69,25 @@ disable_warnings(unused-parameter) # of the comparison function: check_prototype_definition(qsort_r "void (qsort_r)(void *base, size_t nmemb, size_t size, void *context, int (*compar)(void *, const void *, const void *))" - "" "stdlib.h" GIT_QSORT_R_BSD) + "" "stdlib.h" GIT_QSORT_BSD) # GNU or POSIX qsort_r() has the 'context' parameter as the last argument of the # comparison function: check_prototype_definition(qsort_r "void (qsort_r)(void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *, void *), void *context)" - "" "stdlib.h" GIT_QSORT_R_GNU) + "" "stdlib.h" GIT_QSORT_GNU) # C11 qsort_s() has the 'context' parameter as the last argument of the # comparison function, and returns an error status: check_prototype_definition(qsort_s "errno_t (qsort_s)(void *base, rsize_t nmemb, rsize_t size, int (*compar)(const void *, const void *, void *), void *context)" - "0" "stdlib.h" GIT_QSORT_S_C11) + "0" "stdlib.h" GIT_QSORT_C11) # MSC qsort_s() has the 'context' parameter as the first argument of the # comparison function, and as the last argument of qsort_s(): check_prototype_definition(qsort_s "void (qsort_s)(void *base, size_t num, size_t width, int (*compare )(void *, const void *, const void *), void *context)" - "" "stdlib.h" GIT_QSORT_S_MSC) + "" "stdlib.h" GIT_QSORT_MSC) # restore CMAKE_C_FLAGS set(CMAKE_C_FLAGS "${SAVED_CMAKE_C_FLAGS}") diff --git a/src/util/git2_features.h.in b/src/util/git2_features.h.in index 5f606df8494..18644c3ccfc 100644 --- a/src/util/git2_features.h.in +++ b/src/util/git2_features.h.in @@ -24,10 +24,10 @@ #cmakedefine GIT_REGEX_PCRE2 #cmakedefine GIT_REGEX_BUILTIN 1 -#cmakedefine GIT_QSORT_R_BSD -#cmakedefine GIT_QSORT_R_GNU -#cmakedefine GIT_QSORT_S_C11 -#cmakedefine GIT_QSORT_S_MSC +#cmakedefine GIT_QSORT_BSD +#cmakedefine GIT_QSORT_GNU +#cmakedefine GIT_QSORT_C11 +#cmakedefine GIT_QSORT_MSC #cmakedefine GIT_SSH 1 #cmakedefine GIT_SSH_MEMORY_CREDENTIALS 1 diff --git a/src/util/util.c b/src/util/util.c index f4eaf5835ab..c8e8303afe1 100644 --- a/src/util/util.c +++ b/src/util/util.c @@ -18,7 +18,7 @@ # endif # include -# ifdef GIT_QSORT_S_MSC +# ifdef GIT_QSORT_MSC # include # endif #endif @@ -673,7 +673,7 @@ size_t git__unescape(char *str) return (pos - str); } -#if defined(GIT_QSORT_S_MSC) || defined(GIT_QSORT_R_BSD) +#if defined(GIT_QSORT_MSC) || defined(GIT_QSORT_BSD) typedef struct { git__sort_r_cmp cmp; void *payload; @@ -688,10 +688,11 @@ static int GIT_LIBGIT2_CALL git__qsort_r_glue_cmp( #endif -#if !defined(GIT_QSORT_R_BSD) && \ - !defined(GIT_QSORT_R_GNU) && \ - !defined(GIT_QSORT_S_C11) && \ - !defined(GIT_QSORT_S_MSC) +#if !defined(GIT_QSORT_BSD) && \ + !defined(GIT_QSORT_GNU) && \ + !defined(GIT_QSORT_C11) && \ + !defined(GIT_QSORT_MSC) + static void swap(uint8_t *a, uint8_t *b, size_t elsize) { char tmp[256]; @@ -717,19 +718,20 @@ static void insertsort( for (j = i; j > base && cmp(j, j - elsize, payload) < 0; j -= elsize) swap(j, j - elsize, elsize); } + #endif void git__qsort_r( void *els, size_t nel, size_t elsize, git__sort_r_cmp cmp, void *payload) { -#if defined(GIT_QSORT_R_GNU) +#if defined(GIT_QSORT_GNU) qsort_r(els, nel, elsize, cmp, payload); -#elif defined(GIT_QSORT_S_C11) +#elif defined(GIT_QSORT_C11) qsort_s(els, nel, elsize, cmp, payload); -#elif defined(GIT_QSORT_R_BSD) +#elif defined(GIT_QSORT_BSD) git__qsort_r_glue glue = { cmp, payload }; qsort_r(els, nel, elsize, &glue, git__qsort_r_glue_cmp); -#elif defined(GIT_QSORT_S_MSC) +#elif defined(GIT_QSORT_MSC) git__qsort_r_glue glue = { cmp, payload }; qsort_s(els, nel, elsize, git__qsort_r_glue_cmp, &glue); #else From 333573857960fa7260f01f38a2003bafa2313a87 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 12 May 2023 21:49:29 +0100 Subject: [PATCH 263/608] cmake: refactor `check_prototype_definition` Introduce `check_prototype_definition_safe` that is safe for `Werror` usage. --- CMakeLists.txt | 2 +- cmake/CheckPrototypeDefinitionSafe.cmake | 16 ++++++++++++++++ src/CMakeLists.txt | 18 ++++-------------- 3 files changed, 21 insertions(+), 15 deletions(-) create mode 100644 cmake/CheckPrototypeDefinitionSafe.cmake diff --git a/CMakeLists.txt b/CMakeLists.txt index 30527b9280b..cfb5a7d6f4d 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -94,7 +94,7 @@ include(CheckLibraryExists) include(CheckFunctionExists) include(CheckSymbolExists) include(CheckStructHasMember) -include(CheckPrototypeDefinition) +include(CheckPrototypeDefinitionSafe) include(AddCFlagIfSupported) include(FindPkgLibraries) include(FindThreads) diff --git a/cmake/CheckPrototypeDefinitionSafe.cmake b/cmake/CheckPrototypeDefinitionSafe.cmake new file mode 100644 index 00000000000..f82603d3d72 --- /dev/null +++ b/cmake/CheckPrototypeDefinitionSafe.cmake @@ -0,0 +1,16 @@ +include(CheckPrototypeDefinition) + +function(check_prototype_definition_safe function prototype return header variable) + # temporarily save CMAKE_C_FLAGS and disable warnings about unused + # unused functions and parameters, otherwise they will always fail + # if ENABLE_WERROR is on + set(SAVED_CMAKE_C_FLAGS "${CMAKE_C_FLAGS}") + + disable_warnings(unused-function) + disable_warnings(unused-parameter) + + check_prototype_definition("${function}" "${prototype}" "${return}" "${header}" "${variable}") + + # restore CMAKE_C_FLAGS + set(CMAKE_C_FLAGS "${SAVED_CMAKE_C_FLAGS}") +endfunction() diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index bdf513842c8..88d616cec1f 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -58,40 +58,30 @@ add_feature_info(futimens GIT_USE_FUTIMENS "futimens support") # qsort -# for these tests, temporarily save CMAKE_C_FLAGS and disable warnings about -# unused functions and parameters, otherwise they will always fail if -# ENABLE_WERROR is on -set(SAVED_CMAKE_C_FLAGS "${CMAKE_C_FLAGS}") -disable_warnings(unused-function) -disable_warnings(unused-parameter) - # old-style FreeBSD qsort_r() has the 'context' parameter as the first argument # of the comparison function: -check_prototype_definition(qsort_r +check_prototype_definition_safe(qsort_r "void (qsort_r)(void *base, size_t nmemb, size_t size, void *context, int (*compar)(void *, const void *, const void *))" "" "stdlib.h" GIT_QSORT_BSD) # GNU or POSIX qsort_r() has the 'context' parameter as the last argument of the # comparison function: -check_prototype_definition(qsort_r +check_prototype_definition_safe(qsort_r "void (qsort_r)(void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *, void *), void *context)" "" "stdlib.h" GIT_QSORT_GNU) # C11 qsort_s() has the 'context' parameter as the last argument of the # comparison function, and returns an error status: -check_prototype_definition(qsort_s +check_prototype_definition_safe(qsort_s "errno_t (qsort_s)(void *base, rsize_t nmemb, rsize_t size, int (*compar)(const void *, const void *, void *), void *context)" "0" "stdlib.h" GIT_QSORT_C11) # MSC qsort_s() has the 'context' parameter as the first argument of the # comparison function, and as the last argument of qsort_s(): -check_prototype_definition(qsort_s +check_prototype_definition_safe(qsort_s "void (qsort_s)(void *base, size_t num, size_t width, int (*compare )(void *, const void *, const void *), void *context)" "" "stdlib.h" GIT_QSORT_MSC) -# restore CMAKE_C_FLAGS -set(CMAKE_C_FLAGS "${SAVED_CMAKE_C_FLAGS}") - # random / entropy data check_function_exists(getentropy GIT_RAND_GETENTROPY) From 4be63a68667d3c75a3da36b3bc8045459a360906 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Tue, 8 Dec 2020 18:01:03 +0000 Subject: [PATCH 264/608] errors: drop unneccessary g_git prefix --- src/libgit2/errors.c | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/libgit2/errors.c b/src/libgit2/errors.c index 3614b9ce5f5..1b94a5cf403 100644 --- a/src/libgit2/errors.c +++ b/src/libgit2/errors.c @@ -16,12 +16,12 @@ * New error handling ********************************************/ -static git_error g_git_oom_error = { +static git_error oom_error = { "Out of memory", GIT_ERROR_NOMEMORY }; -static git_error g_git_uninitialized_error = { +static git_error uninitialized_error = { "libgit2 has not been initialized; you must call git_libgit2_init", GIT_ERROR_INVALID }; @@ -52,7 +52,7 @@ static void set_error(int error_class, char *string) void git_error_set_oom(void) { - GIT_THREADSTATE->last_error = &g_git_oom_error; + GIT_THREADSTATE->last_error = &oom_error; } void git_error_set(int error_class, const char *fmt, ...) @@ -134,7 +134,7 @@ const git_error *git_error_last(void) { /* If the library is not initialized, return a static error. */ if (!git_libgit2_init_count()) - return &g_git_uninitialized_error; + return &uninitialized_error; return GIT_THREADSTATE->last_error; } @@ -150,13 +150,13 @@ int git_error_state_capture(git_error_state *state, int error_code) return 0; state->error_code = error_code; - state->oom = (error == &g_git_oom_error); + state->oom = (error == &oom_error); if (error) { state->error_msg.klass = error->klass; if (state->oom) - state->error_msg.message = g_git_oom_error.message; + state->error_msg.message = oom_error.message; else state->error_msg.message = git_str_detach(error_buf); } From ce488be46e4cd2aeeb69c39a062fae1ba9a302f6 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Tue, 8 Dec 2020 19:28:01 +0000 Subject: [PATCH 265/608] errors: don't rely on tls data working Thread-local storage data may fail to initialize; in this case, do not try to set the error message into it. When the thread state has not been initialized, return a hardcoded message to that affect. --- src/libgit2/errors.c | 81 +++++++++++++++++++++++++++++++++++++------- 1 file changed, 68 insertions(+), 13 deletions(-) diff --git a/src/libgit2/errors.c b/src/libgit2/errors.c index 1b94a5cf403..460dfa00f78 100644 --- a/src/libgit2/errors.c +++ b/src/libgit2/errors.c @@ -26,22 +26,41 @@ static git_error uninitialized_error = { GIT_ERROR_INVALID }; +static git_error tlsdata_error = { + "thread-local data initialization failure", + GIT_ERROR +}; + static void set_error_from_buffer(int error_class) { - git_error *error = &GIT_THREADSTATE->error_t; - git_str *buf = &GIT_THREADSTATE->error_buf; + git_threadstate *threadstate = GIT_THREADSTATE; + git_error *error; + git_str *buf; + + if (!threadstate) + return; + + error = &threadstate->error_t; + buf = &threadstate->error_buf; error->message = buf->ptr; error->klass = error_class; - GIT_THREADSTATE->last_error = error; + threadstate->last_error = error; } static void set_error(int error_class, char *string) { - git_str *buf = &GIT_THREADSTATE->error_buf; + git_threadstate *threadstate = GIT_THREADSTATE; + git_str *buf; + + if (!threadstate) + return; + + buf = &threadstate->error_buf; git_str_clear(buf); + if (string) { git_str_puts(buf, string); git__free(string); @@ -52,7 +71,12 @@ static void set_error(int error_class, char *string) void git_error_set_oom(void) { - GIT_THREADSTATE->last_error = &oom_error; + git_threadstate *threadstate = GIT_THREADSTATE; + + if (!threadstate) + return; + + threadstate->last_error = &oom_error; } void git_error_set(int error_class, const char *fmt, ...) @@ -69,10 +93,18 @@ void git_error_vset(int error_class, const char *fmt, va_list ap) #ifdef GIT_WIN32 DWORD win32_error_code = (error_class == GIT_ERROR_OS) ? GetLastError() : 0; #endif + + git_threadstate *threadstate = GIT_THREADSTATE; int error_code = (error_class == GIT_ERROR_OS) ? errno : 0; - git_str *buf = &GIT_THREADSTATE->error_buf; + git_str *buf; + + if (!threadstate) + return; + + buf = &threadstate->error_buf; git_str_clear(buf); + if (fmt) { git_str_vprintf(buf, fmt, ap); if (error_class == GIT_ERROR_OS) @@ -81,7 +113,7 @@ void git_error_vset(int error_class, const char *fmt, va_list ap) if (error_class == GIT_ERROR_OS) { #ifdef GIT_WIN32 - char * win32_error = git_win32_get_error_message(win32_error_code); + char *win32_error = git_win32_get_error_message(win32_error_code); if (win32_error) { git_str_puts(buf, win32_error); git__free(win32_error); @@ -103,10 +135,16 @@ void git_error_vset(int error_class, const char *fmt, va_list ap) int git_error_set_str(int error_class, const char *string) { - git_str *buf = &GIT_THREADSTATE->error_buf; + git_threadstate *threadstate = GIT_THREADSTATE; + git_str *buf; GIT_ASSERT_ARG(string); + if (!threadstate) + return -1; + + buf = &threadstate->error_buf; + git_str_clear(buf); git_str_puts(buf, string); @@ -119,9 +157,14 @@ int git_error_set_str(int error_class, const char *string) void git_error_clear(void) { - if (GIT_THREADSTATE->last_error != NULL) { + git_threadstate *threadstate = GIT_THREADSTATE; + + if (!threadstate) + return; + + if (threadstate->last_error != NULL) { set_error(0, NULL); - GIT_THREADSTATE->last_error = NULL; + threadstate->last_error = NULL; } errno = 0; @@ -132,17 +175,29 @@ void git_error_clear(void) const git_error *git_error_last(void) { + git_threadstate *threadstate; + /* If the library is not initialized, return a static error. */ if (!git_libgit2_init_count()) return &uninitialized_error; - return GIT_THREADSTATE->last_error; + if ((threadstate = GIT_THREADSTATE) == NULL) + return &tlsdata_error; + + return threadstate->last_error; } int git_error_state_capture(git_error_state *state, int error_code) { - git_error *error = GIT_THREADSTATE->last_error; - git_str *error_buf = &GIT_THREADSTATE->error_buf; + git_threadstate *threadstate = GIT_THREADSTATE; + git_error *error; + git_str *error_buf; + + if (!threadstate) + return -1; + + error = threadstate->last_error; + error_buf = &threadstate->error_buf; memset(state, 0, sizeof(git_error_state)); From 4f76ef568d74c63031eb42fc10bf08b5641e5f0b Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Tue, 8 Dec 2020 19:28:44 +0000 Subject: [PATCH 266/608] oid: don't assume thread local state was initialized git_oid_tostr_s could fail if thread-local state initialization fails. In that case, it will now return `NULL`. Callers should check for `NULL` and propagate the failure. --- include/git2/oid.h | 2 +- src/libgit2/indexer.c | 8 +++++++- src/libgit2/odb.c | 13 +++++++++---- src/libgit2/oid.c | 8 +++++++- src/libgit2/repository.c | 27 +++++++++++++++++++++------ 5 files changed, 45 insertions(+), 13 deletions(-) diff --git a/include/git2/oid.h b/include/git2/oid.h index 399b7b9071b..35b43ef183a 100644 --- a/include/git2/oid.h +++ b/include/git2/oid.h @@ -225,7 +225,7 @@ GIT_EXTERN(int) git_oid_pathfmt(char *out, const git_oid *id); * concurrent calls of the function. * * @param oid The oid structure to format - * @return the c-string + * @return the c-string or NULL on failure */ GIT_EXTERN(char *) git_oid_tostr_s(const git_oid *oid); diff --git a/src/libgit2/indexer.c b/src/libgit2/indexer.c index 7357a4aa56f..e559a194235 100644 --- a/src/libgit2/indexer.c +++ b/src/libgit2/indexer.c @@ -519,7 +519,13 @@ static int store_object(git_indexer *idx) pentry->offset = entry_start; if (git_oidmap_exists(idx->pack->idx_cache, &pentry->id)) { - git_error_set(GIT_ERROR_INDEXER, "duplicate object %s found in pack", git_oid_tostr_s(&pentry->id)); + const char *idstr = git_oid_tostr_s(&pentry->id); + + if (!idstr) + git_error_set(GIT_ERROR_INDEXER, "failed to parse object id"); + else + git_error_set(GIT_ERROR_INDEXER, "duplicate object %s found in pack", idstr); + git__free(pentry); goto on_error; } diff --git a/src/libgit2/odb.c b/src/libgit2/odb.c index 68872e1a197..fec1e45b9d4 100644 --- a/src/libgit2/odb.c +++ b/src/libgit2/odb.c @@ -1494,11 +1494,16 @@ static int read_prefix_1(git_odb_object **out, git_odb *db, if (found && git_oid__cmp(&full_oid, &found_full_oid)) { git_str buf = GIT_STR_INIT; + const char *idstr; - git_str_printf(&buf, "multiple matches for prefix: %s", - git_oid_tostr_s(&full_oid)); - git_str_printf(&buf, " %s", - git_oid_tostr_s(&found_full_oid)); + if ((idstr = git_oid_tostr_s(&full_oid)) == NULL) { + git_str_puts(&buf, "failed to parse object id"); + } else { + git_str_printf(&buf, "multiple matches for prefix: %s", idstr); + + if ((idstr = git_oid_tostr_s(&found_full_oid)) != NULL) + git_str_printf(&buf, " %s", idstr); + } error = git_odb__error_ambiguous(buf.ptr); git_str_dispose(&buf); diff --git a/src/libgit2/oid.c b/src/libgit2/oid.c index 6cc21641d70..ab758fff4cf 100644 --- a/src/libgit2/oid.c +++ b/src/libgit2/oid.c @@ -155,7 +155,13 @@ int git_oid_pathfmt(char *str, const git_oid *oid) char *git_oid_tostr_s(const git_oid *oid) { - char *str = GIT_THREADSTATE->oid_fmt; + git_threadstate *threadstate = GIT_THREADSTATE; + char *str; + + if (!threadstate) + return NULL; + + str = threadstate->oid_fmt; git_oid_nfmt(str, git_oid_hexsize(git_oid_type(oid)) + 1, oid); return str; } diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index d2fe1e6bbcc..97f776c4a34 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -3422,12 +3422,18 @@ int git_repository_hashfile( static int checkout_message(git_str *out, git_reference *old, const char *new) { + const char *idstr; + git_str_puts(out, "checkout: moving from "); - if (git_reference_type(old) == GIT_REFERENCE_SYMBOLIC) + if (git_reference_type(old) == GIT_REFERENCE_SYMBOLIC) { git_str_puts(out, git_reference__shorthand(git_reference_symbolic_target(old))); - else - git_str_puts(out, git_oid_tostr_s(git_reference_target(old))); + } else { + if ((idstr = git_oid_tostr_s(git_reference_target(old))) == NULL) + return -1; + + git_str_puts(out, idstr); + } git_str_puts(out, " to "); @@ -3463,8 +3469,11 @@ static int detach(git_repository *repo, const git_oid *id, const char *new) if ((error = git_object_peel(&peeled, object, GIT_OBJECT_COMMIT)) < 0) goto cleanup; - if (new == NULL) - new = git_oid_tostr_s(git_object_id(peeled)); + if (new == NULL && + (new = git_oid_tostr_s(git_object_id(peeled))) == NULL) { + error = -1; + goto cleanup; + } if ((error = checkout_message(&log_message, current, new)) < 0) goto cleanup; @@ -3552,6 +3561,7 @@ int git_repository_detach_head(git_repository *repo) git_reference *old_head = NULL, *new_head = NULL, *current = NULL; git_object *object = NULL; git_str log_message = GIT_STR_INIT; + const char *idstr; int error; GIT_ASSERT_ARG(repo); @@ -3565,7 +3575,12 @@ int git_repository_detach_head(git_repository *repo) if ((error = git_object_lookup(&object, repo, git_reference_target(old_head), GIT_OBJECT_COMMIT)) < 0) goto cleanup; - if ((error = checkout_message(&log_message, current, git_oid_tostr_s(git_object_id(object)))) < 0) + if ((idstr = git_oid_tostr_s(git_object_id(object))) == NULL) { + error = -1; + goto cleanup; + } + + if ((error = checkout_message(&log_message, current, idstr)) < 0) goto cleanup; error = git_reference_create(&new_head, repo, GIT_HEAD_FILE, git_reference_target(old_head), From ebf2991f06d8831ed23524a068210b8103b5f604 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Tue, 8 Dec 2020 19:46:25 +0000 Subject: [PATCH 267/608] threadstate: don't use an unnecessary macro Now that we've reduced the usage of GIT_THREADSTATE, remove it entirely in favor of git_threadstate_get(). --- src/libgit2/errors.c | 16 ++++++++-------- src/libgit2/oid.c | 2 +- src/libgit2/threadstate.h | 2 -- 3 files changed, 9 insertions(+), 11 deletions(-) diff --git a/src/libgit2/errors.c b/src/libgit2/errors.c index 460dfa00f78..2e58948d2e4 100644 --- a/src/libgit2/errors.c +++ b/src/libgit2/errors.c @@ -33,7 +33,7 @@ static git_error tlsdata_error = { static void set_error_from_buffer(int error_class) { - git_threadstate *threadstate = GIT_THREADSTATE; + git_threadstate *threadstate = git_threadstate_get(); git_error *error; git_str *buf; @@ -51,7 +51,7 @@ static void set_error_from_buffer(int error_class) static void set_error(int error_class, char *string) { - git_threadstate *threadstate = GIT_THREADSTATE; + git_threadstate *threadstate = git_threadstate_get(); git_str *buf; if (!threadstate) @@ -71,7 +71,7 @@ static void set_error(int error_class, char *string) void git_error_set_oom(void) { - git_threadstate *threadstate = GIT_THREADSTATE; + git_threadstate *threadstate = git_threadstate_get(); if (!threadstate) return; @@ -94,7 +94,7 @@ void git_error_vset(int error_class, const char *fmt, va_list ap) DWORD win32_error_code = (error_class == GIT_ERROR_OS) ? GetLastError() : 0; #endif - git_threadstate *threadstate = GIT_THREADSTATE; + git_threadstate *threadstate = git_threadstate_get(); int error_code = (error_class == GIT_ERROR_OS) ? errno : 0; git_str *buf; @@ -135,7 +135,7 @@ void git_error_vset(int error_class, const char *fmt, va_list ap) int git_error_set_str(int error_class, const char *string) { - git_threadstate *threadstate = GIT_THREADSTATE; + git_threadstate *threadstate = git_threadstate_get(); git_str *buf; GIT_ASSERT_ARG(string); @@ -157,7 +157,7 @@ int git_error_set_str(int error_class, const char *string) void git_error_clear(void) { - git_threadstate *threadstate = GIT_THREADSTATE; + git_threadstate *threadstate = git_threadstate_get(); if (!threadstate) return; @@ -181,7 +181,7 @@ const git_error *git_error_last(void) if (!git_libgit2_init_count()) return &uninitialized_error; - if ((threadstate = GIT_THREADSTATE) == NULL) + if ((threadstate = git_threadstate_get()) == NULL) return &tlsdata_error; return threadstate->last_error; @@ -189,7 +189,7 @@ const git_error *git_error_last(void) int git_error_state_capture(git_error_state *state, int error_code) { - git_threadstate *threadstate = GIT_THREADSTATE; + git_threadstate *threadstate = git_threadstate_get(); git_error *error; git_str *error_buf; diff --git a/src/libgit2/oid.c b/src/libgit2/oid.c index ab758fff4cf..631a566ebaa 100644 --- a/src/libgit2/oid.c +++ b/src/libgit2/oid.c @@ -155,7 +155,7 @@ int git_oid_pathfmt(char *str, const git_oid *oid) char *git_oid_tostr_s(const git_oid *oid) { - git_threadstate *threadstate = GIT_THREADSTATE; + git_threadstate *threadstate = git_threadstate_get(); char *str; if (!threadstate) diff --git a/src/libgit2/threadstate.h b/src/libgit2/threadstate.h index 65edec71723..6ef04192ca9 100644 --- a/src/libgit2/threadstate.h +++ b/src/libgit2/threadstate.h @@ -19,6 +19,4 @@ typedef struct { extern int git_threadstate_global_init(void); extern git_threadstate *git_threadstate_get(void); -#define GIT_THREADSTATE (git_threadstate_get()) - #endif From 6c0d5b11c05254d91a2d0025d556251404f8f05f Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 12 May 2023 20:48:19 +0100 Subject: [PATCH 268/608] util: make monotonic time fn return ms `git__timer` is now `git_time_monotonic`, and returns milliseconds since an arbitrary epoch. Using a floating point to store the number of seconds elapsed was clever, as it better supports the wide range of precision from the different monotonic clocks of different systems. But we're a version control system, not a real-time clock. Milliseconds is a good enough precision for our work _and_ it's the units that system calls like `poll` take and that our users interact with. Make `git_time_monotonic` return the monotonically increasing number of milliseconds "ticked" since some arbitrary epoch. --- src/cli/progress.c | 17 ++++++----- src/cli/progress.h | 8 ++--- src/libgit2/pack-objects.c | 12 ++++---- src/libgit2/pack-objects.h | 4 ++- src/libgit2/transports/smart_protocol.c | 8 ++--- src/util/rand.c | 10 ++++--- src/util/util.h | 40 +++++++++++++++---------- tests/clar/clar_libgit2_timer.c | 8 ++--- tests/clar/clar_libgit2_timer.h | 10 +++---- tests/clar/clar_libgit2_trace.c | 2 +- 10 files changed, 66 insertions(+), 53 deletions(-) diff --git a/src/cli/progress.c b/src/cli/progress.c index ba52655e75e..ddfbafb73a4 100644 --- a/src/cli/progress.c +++ b/src/cli/progress.c @@ -15,10 +15,10 @@ /* * Show updates to the percentage and number of objects received * separately from the throughput to give an accurate progress while - * avoiding too much noise on the screen. + * avoiding too much noise on the screen. (In milliseconds.) */ -#define PROGRESS_UPDATE_TIME 0.10 -#define THROUGHPUT_UPDATE_TIME 1.00 +#define PROGRESS_UPDATE_TIME 60 +#define THROUGHPUT_UPDATE_TIME 500 #define is_nl(c) ((c) == '\r' || (c) == '\n') @@ -54,7 +54,7 @@ static int progress_write(cli_progress *progress, bool force, git_str *line) bool has_nl; size_t no_nl = no_nl_len(line->ptr, line->size); size_t nl = nl_len(&has_nl, line->ptr + no_nl, line->size - no_nl); - double now = git__timer(); + uint64_t now = git_time_monotonic(); size_t i; /* Avoid spamming the console with progress updates */ @@ -191,20 +191,21 @@ static int fetch_receiving( { char *recv_units[] = { "B", "KiB", "MiB", "GiB", "TiB", NULL }; char *rate_units[] = { "B/s", "KiB/s", "MiB/s", "GiB/s", "TiB/s", NULL }; + uint64_t now, elapsed; - double now, recv_len, rate, elapsed; + double recv_len, rate; size_t recv_unit_idx = 0, rate_unit_idx = 0; bool done = (stats->received_objects == stats->total_objects); if (!progress->action_start) - progress->action_start = git__timer(); + progress->action_start = git_time_monotonic(); if (done && progress->action_finish) now = progress->action_finish; else if (done) - progress->action_finish = now = git__timer(); + progress->action_finish = now = git_time_monotonic(); else - now = git__timer(); + now = git_time_monotonic(); if (progress->throughput_update && now - progress->throughput_update < THROUGHPUT_UPDATE_TIME) { diff --git a/src/cli/progress.h b/src/cli/progress.h index 7a445ec2966..886fef89d03 100644 --- a/src/cli/progress.h +++ b/src/cli/progress.h @@ -30,11 +30,11 @@ typedef struct { cli_progress_t action; /* Actions may time themselves (eg fetch) but are not required to */ - double action_start; - double action_finish; + uint64_t action_start; + uint64_t action_finish; /* Last console update, avoid too frequent updates. */ - double last_update; + uint64_t last_update; /* Accumulators for partial output and deferred updates. */ git_str sideband; @@ -42,7 +42,7 @@ typedef struct { git_str deferred; /* Last update about throughput */ - double throughput_update; + uint64_t throughput_update; double throughput_bytes; } cli_progress; diff --git a/src/libgit2/pack-objects.c b/src/libgit2/pack-objects.c index d6fd603268e..fc8efc65f5e 100644 --- a/src/libgit2/pack-objects.c +++ b/src/libgit2/pack-objects.c @@ -255,10 +255,10 @@ int git_packbuilder_insert(git_packbuilder *pb, const git_oid *oid, pb->done = false; if (pb->progress_cb) { - double current_time = git__timer(); - double elapsed = current_time - pb->last_progress_report_time; + uint64_t current_time = git_time_monotonic(); + uint64_t elapsed = current_time - pb->last_progress_report_time; - if (elapsed < 0 || elapsed >= MIN_PROGRESS_UPDATE_INTERVAL) { + if (elapsed >= MIN_PROGRESS_UPDATE_INTERVAL) { pb->last_progress_report_time = current_time; ret = pb->progress_cb( @@ -934,10 +934,10 @@ static int report_delta_progress( int ret; if (pb->progress_cb) { - double current_time = git__timer(); - double elapsed = current_time - pb->last_progress_report_time; + uint64_t current_time = git_time_monotonic(); + uint64_t elapsed = current_time - pb->last_progress_report_time; - if (force || elapsed < 0 || elapsed >= MIN_PROGRESS_UPDATE_INTERVAL) { + if (force || elapsed >= MIN_PROGRESS_UPDATE_INTERVAL) { pb->last_progress_report_time = current_time; ret = pb->progress_cb( diff --git a/src/libgit2/pack-objects.h b/src/libgit2/pack-objects.h index c6bc52fdc5e..0ceebc23cab 100644 --- a/src/libgit2/pack-objects.h +++ b/src/libgit2/pack-objects.h @@ -96,7 +96,9 @@ struct git_packbuilder { git_packbuilder_progress progress_cb; void *progress_cb_payload; - double last_progress_report_time; /* the time progress was last reported */ + + /* the time progress was last reported, in millisecond ticks */ + uint64_t last_progress_report_time; bool done; }; diff --git a/src/libgit2/transports/smart_protocol.c b/src/libgit2/transports/smart_protocol.c index 488ef07c089..f7a56782930 100644 --- a/src/libgit2/transports/smart_protocol.c +++ b/src/libgit2/transports/smart_protocol.c @@ -1114,7 +1114,7 @@ struct push_packbuilder_payload git_push_transfer_progress_cb cb; void *cb_payload; size_t last_bytes; - double last_progress_report_time; + uint64_t last_progress_report_time; }; static int stream_thunk(void *buf, size_t size, void *data) @@ -1126,11 +1126,11 @@ static int stream_thunk(void *buf, size_t size, void *data) return error; if (payload->cb) { - double current_time = git__timer(); - double elapsed = current_time - payload->last_progress_report_time; + uint64_t current_time = git_time_monotonic(); + uint64_t elapsed = current_time - payload->last_progress_report_time; payload->last_bytes += size; - if (elapsed < 0 || elapsed >= MIN_PROGRESS_UPDATE_INTERVAL) { + if (elapsed >= MIN_PROGRESS_UPDATE_INTERVAL) { payload->last_progress_report_time = current_time; error = payload->cb(payload->pb->nr_written, payload->pb->nr_objects, payload->last_bytes, payload->cb_payload); } diff --git a/src/util/rand.c b/src/util/rand.c index 940faf94796..2ed0605738b 100644 --- a/src/util/rand.c +++ b/src/util/rand.c @@ -32,7 +32,6 @@ GIT_INLINE(int) getseed(uint64_t *seed) HCRYPTPROV provider; SYSTEMTIME systemtime; FILETIME filetime, idletime, kerneltime, usertime; - bits convert; if (CryptAcquireContext(&provider, 0, 0, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT|CRYPT_SILENT)) { @@ -67,7 +66,7 @@ GIT_INLINE(int) getseed(uint64_t *seed) *seed ^= ((uint64_t)GetCurrentProcessId() << 32); *seed ^= ((uint64_t)GetCurrentThreadId() << 48); - convert.f = git__timer(); *seed ^= (convert.d); + *seed ^= git_time_monotonic(); /* Mix in the addresses of some functions and variables */ *seed ^= (((uint64_t)((uintptr_t)seed) << 32)); @@ -82,9 +81,12 @@ GIT_INLINE(int) getseed(uint64_t *seed) { struct timeval tv; double loadavg[3]; - bits convert; int fd; +# if defined(GIT_RAND_GETLOADAVG) + bits convert; +# endif + # if defined(GIT_RAND_GETENTROPY) GIT_UNUSED((fd = 0)); @@ -131,7 +133,7 @@ GIT_INLINE(int) getseed(uint64_t *seed) GIT_UNUSED(loadavg[0]); # endif - convert.f = git__timer(); *seed ^= (convert.d); + *seed ^= git_time_monotonic(); /* Mix in the addresses of some variables */ *seed ^= ((uint64_t)((size_t)((void *)seed)) << 32); diff --git a/src/util/util.h b/src/util/util.h index 63d6080f730..7f178b169fe 100644 --- a/src/util/util.h +++ b/src/util/util.h @@ -319,59 +319,67 @@ GIT_INLINE(void) git__memzero(void *data, size_t size) #ifdef GIT_WIN32 -GIT_INLINE(double) git__timer(void) +GIT_INLINE(uint64_t) git_time_monotonic(void) { /* GetTickCount64 returns the number of milliseconds that have * elapsed since the system was started. */ - return (double) GetTickCount64() / (double) 1000; + return GetTickCount64(); } #elif __APPLE__ #include +#include -GIT_INLINE(double) git__timer(void) +GIT_INLINE(uint64_t) git_time_monotonic(void) { - uint64_t time = mach_absolute_time(); - static double scaling_factor = 0; + static double scaling_factor = 0; + + if (scaling_factor == 0) { + mach_timebase_info_data_t info; - if (scaling_factor == 0) { - mach_timebase_info_data_t info; - (void)mach_timebase_info(&info); - scaling_factor = (double)info.numer / (double)info.denom; - } + scaling_factor = mach_timebase_info(&info) == KERN_SUCCESS ? + ((double)info.numer / (double)info.denom) / 1.0E6 : + -1; + } else if (scaling_factor < 0) { + struct timeval tv; + + /* mach_timebase_info failed; fall back to gettimeofday */ + gettimeofday(&tv, NULL); + return (tv.tv_sec * 1000) + (tv.tv_usec / 1000); + } - return (double)time * scaling_factor / 1.0E9; + return (uint64_t)(mach_absolute_time() * scaling_factor); } #elif defined(__amigaos4__) #include -GIT_INLINE(double) git__timer(void) +GIT_INLINE(uint64_t) git_time_monotonic(void) { struct TimeVal tv; ITimer->GetUpTime(&tv); - return (double)tv.Seconds + (double)tv.Microseconds / 1.0E6; + return (tv.Seconds * 1000) + (tv.Microseconds / 1000); } #else #include -GIT_INLINE(double) git__timer(void) +GIT_INLINE(uint64_t) git_time_monotonic(void) { struct timeval tv; #ifdef CLOCK_MONOTONIC struct timespec tp; if (clock_gettime(CLOCK_MONOTONIC, &tp) == 0) - return (double) tp.tv_sec + (double) tp.tv_nsec / 1.0E9; + return (tp.tv_sec * 1000) + (tp.tv_nsec / 1.0E6); #endif /* Fall back to using gettimeofday */ gettimeofday(&tv, NULL); - return (double)tv.tv_sec + (double)tv.tv_usec / 1.0E6; + return (tv.tv_sec * 1000) + (tv.tv_usec / 1000); } #endif diff --git a/tests/clar/clar_libgit2_timer.c b/tests/clar/clar_libgit2_timer.c index 2330f9351d1..6c75413be7e 100644 --- a/tests/clar/clar_libgit2_timer.c +++ b/tests/clar/clar_libgit2_timer.c @@ -8,23 +8,23 @@ void cl_perf_timer__init(cl_perf_timer *t) void cl_perf_timer__start(cl_perf_timer *t) { - t->time_started = git__timer(); + t->time_started = git_time_monotonic(); } void cl_perf_timer__stop(cl_perf_timer *t) { - double time_now = git__timer(); + uint64_t time_now = git_time_monotonic(); t->last = time_now - t->time_started; t->sum += t->last; } -double cl_perf_timer__last(const cl_perf_timer *t) +uint64_t cl_perf_timer__last(const cl_perf_timer *t) { return t->last; } -double cl_perf_timer__sum(const cl_perf_timer *t) +uint64_t cl_perf_timer__sum(const cl_perf_timer *t) { return t->sum; } diff --git a/tests/clar/clar_libgit2_timer.h b/tests/clar/clar_libgit2_timer.h index 7571a52e997..88706727884 100644 --- a/tests/clar/clar_libgit2_timer.h +++ b/tests/clar/clar_libgit2_timer.h @@ -4,13 +4,13 @@ struct cl_perf_timer { /* cumulative running time across all start..stop intervals */ - double sum; + uint64_t sum; /* value of last start..stop interval */ - double last; + uint64_t last; /* clock value at start */ - double time_started; + uint64_t time_started; }; #define CL_PERF_TIMER_INIT {0} @@ -24,12 +24,12 @@ void cl_perf_timer__stop(cl_perf_timer *t); /** * return value of last start..stop interval in seconds. */ -double cl_perf_timer__last(const cl_perf_timer *t); +uint64_t cl_perf_timer__last(const cl_perf_timer *t); /** * return cumulative running time across all start..stop * intervals in seconds. */ -double cl_perf_timer__sum(const cl_perf_timer *t); +uint64_t cl_perf_timer__sum(const cl_perf_timer *t); #endif /* __CLAR_LIBGIT2_TIMER__ */ diff --git a/tests/clar/clar_libgit2_trace.c b/tests/clar/clar_libgit2_trace.c index ebb0f41dda7..814a5fa9ee7 100644 --- a/tests/clar/clar_libgit2_trace.c +++ b/tests/clar/clar_libgit2_trace.c @@ -197,7 +197,7 @@ static void _cl_trace_cb__event_handler( case CL_TRACE__TEST__END: cl_perf_timer__stop(&s_timer_test); - git_trace(GIT_TRACE_TRACE, "%s::%s: End Test (%.3f %.3f)", suite_name, test_name, + git_trace(GIT_TRACE_TRACE, "%s::%s: End Test (%" PRIuZ " %" PRIuZ ")", suite_name, test_name, cl_perf_timer__last(&s_timer_run), cl_perf_timer__last(&s_timer_test)); break; From dbe343b6e3e957b5cffbd04832c6e7364b496ae7 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 12 May 2023 20:48:28 +0100 Subject: [PATCH 269/608] stransport: store error information We lose some error information from the read / write callbacks to stransport. Store our own error value in the object so that we can ensure that we rely upon it. --- src/libgit2/streams/stransport.c | 39 +++++++++++++++++++++++--------- 1 file changed, 28 insertions(+), 11 deletions(-) diff --git a/src/libgit2/streams/stransport.c b/src/libgit2/streams/stransport.c index 3f31d2541c7..74ee0d1eeb0 100644 --- a/src/libgit2/streams/stransport.c +++ b/src/libgit2/streams/stransport.c @@ -44,6 +44,7 @@ typedef struct { git_stream parent; git_stream *io; int owned; + int error; SSLContextRef ctx; CFDataRef der_data; git_cert_x509 cert_info; @@ -61,7 +62,10 @@ static int stransport_connect(git_stream *stream) return error; ret = SSLHandshake(st->ctx); - if (ret != errSSLServerAuthCompleted) { + + if (ret != errSSLServerAuthCompleted && st->error != 0) + return -1; + else if (ret != errSSLServerAuthCompleted) { git_error_set(GIT_ERROR_SSL, "unexpected return value from ssl handshake %d", (int)ret); return -1; } @@ -147,10 +151,18 @@ static int stransport_set_proxy( */ static OSStatus write_cb(SSLConnectionRef conn, const void *data, size_t *len) { - git_stream *io = (git_stream *) conn; + stransport_stream *st = (stransport_stream *)conn; + git_stream *io = st->io; + OSStatus ret; + + st->error = 0; + + ret = git_stream__write_full(io, data, *len, 0); - if (git_stream__write_full(io, data, *len, 0) < 0) - return -36; /* "ioErr" from MacErrors.h which is not available on iOS */ + if (ret < 0) { + st->error = ret; + return -36; /* ioErr */ + } return noErr; } @@ -182,18 +194,22 @@ static ssize_t stransport_write(git_stream *stream, const char *data, size_t len */ static OSStatus read_cb(SSLConnectionRef conn, void *data, size_t *len) { - git_stream *io = (git_stream *) conn; + stransport_stream *st = (stransport_stream *)conn; + git_stream *io = st->io; OSStatus error = noErr; size_t off = 0; ssize_t ret; + st->error = 0; + do { ret = git_stream_read(io, data + off, *len - off); + if (ret < 0) { - error = -36; /* "ioErr" from MacErrors.h which is not available on iOS */ + st->error = ret; + error = -36; /* ioErr */ break; - } - if (ret == 0) { + } else if (ret == 0) { error = errSSLClosedGraceful; break; } @@ -207,12 +223,13 @@ static OSStatus read_cb(SSLConnectionRef conn, void *data, size_t *len) static ssize_t stransport_read(git_stream *stream, void *data, size_t len) { - stransport_stream *st = (stransport_stream *) stream; + stransport_stream *st = (stransport_stream *)stream; size_t processed; OSStatus ret; - if ((ret = SSLRead(st->ctx, data, len, &processed)) != noErr) + if ((ret = SSLRead(st->ctx, data, len, &processed)) != noErr) { return stransport_error(ret); + } return processed; } @@ -269,7 +286,7 @@ static int stransport_wrap( } if ((ret = SSLSetIOFuncs(st->ctx, read_cb, write_cb)) != noErr || - (ret = SSLSetConnection(st->ctx, st->io)) != noErr || + (ret = SSLSetConnection(st->ctx, st)) != noErr || (ret = SSLSetSessionOption(st->ctx, kSSLSessionOptionBreakOnServerAuth, true)) != noErr || (ret = SSLSetProtocolVersionMin(st->ctx, kTLSProtocol1)) != noErr || (ret = SSLSetProtocolVersionMax(st->ctx, kTLSProtocol12)) != noErr || From 6e4bbf222d8c4babaff90aef40615546c8bc9cde Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 12 May 2023 20:48:30 +0100 Subject: [PATCH 270/608] net: move rfc2818 hostname / wildcard matching to util --- src/libgit2/netops.c | 39 --------------------------- src/libgit2/netops.h | 13 --------- src/libgit2/streams/openssl.c | 19 +++++-------- src/util/net.c | 44 +++++++++++++++++++++++++++++++ src/util/net.h | 17 ++++++++++++ tests/libgit2/network/matchhost.c | 13 --------- tests/util/hostname.c | 13 +++++++++ 7 files changed, 80 insertions(+), 78 deletions(-) delete mode 100644 tests/libgit2/network/matchhost.c create mode 100644 tests/util/hostname.c diff --git a/src/libgit2/netops.c b/src/libgit2/netops.c index 00640c600ee..5cae374ad9a 100644 --- a/src/libgit2/netops.c +++ b/src/libgit2/netops.c @@ -83,42 +83,3 @@ void gitno_consume_n(gitno_buffer *buf, size_t cons) memset(buf->data + cons, 0x0, buf->len - buf->offset); buf->offset -= cons; } - -/* Match host names according to RFC 2818 rules */ -int gitno__match_host(const char *pattern, const char *host) -{ - for (;;) { - char c = git__tolower(*pattern++); - - if (c == '\0') - return *host ? -1 : 0; - - if (c == '*') { - c = *pattern; - /* '*' at the end matches everything left */ - if (c == '\0') - return 0; - - /* - * We've found a pattern, so move towards the next matching - * char. The '.' is handled specially because wildcards aren't - * allowed to cross subdomains. - */ - - while(*host) { - char h = git__tolower(*host); - if (c == h) - return gitno__match_host(pattern, host++); - if (h == '.') - return gitno__match_host(pattern, host); - host++; - } - return -1; - } - - if (c != git__tolower(*host++)) - return -1; - } - - return -1; -} diff --git a/src/libgit2/netops.h b/src/libgit2/netops.h index 56f96853459..a3f4a0f9523 100644 --- a/src/libgit2/netops.h +++ b/src/libgit2/netops.h @@ -45,19 +45,6 @@ enum { GITNO_CONNECT_SSL = 1 }; -/** - * Check if the name in a cert matches the wanted hostname - * - * Check if a pattern from a certificate matches the hostname we - * wanted to connect to according to RFC2818 rules (which specifies - * HTTP over TLS). Mainly, an asterisk matches anything, but is - * limited to a single url component. - * - * Note that this does not set an error message. It expects the user - * to provide the message for the user. - */ -int gitno__match_host(const char *pattern, const char *host); - void gitno_buffer_setup_fromstream(git_stream *st, gitno_buffer *buf, char *data, size_t len); void gitno_buffer_setup_callback(gitno_buffer *buf, char *data, size_t len, int (*recv)(gitno_buffer *buf), void *cb_data); int gitno_recv(gitno_buffer *buf); diff --git a/src/libgit2/streams/openssl.c b/src/libgit2/streams/openssl.c index 5e0e2c939db..58b2d1b2363 100644 --- a/src/libgit2/streams/openssl.c +++ b/src/libgit2/streams/openssl.c @@ -18,6 +18,7 @@ #include "settings.h" #include "posix.h" #include "stream.h" +#include "net.h" #include "streams/socket.h" #include "netops.h" #include "git2/transport.h" @@ -357,15 +358,10 @@ static int ssl_teardown(SSL *ssl) return ret; } -static int check_host_name(const char *name, const char *host) +static bool check_host_name(const char *host, const char *name) { - if (!strcasecmp(name, host)) - return 0; - - if (gitno__match_host(name, host) < 0) - return -1; - - return 0; + return !strcasecmp(host, name) || + git_net_hostname_matches_cert(host, name); } static int verify_server_cert(SSL *ssl, const char *host) @@ -425,10 +421,7 @@ static int verify_server_cert(SSL *ssl, const char *host) if (memchr(name, '\0', namelen)) continue; - if (check_host_name(name, host) < 0) - matched = 0; - else - matched = 1; + matched = !!check_host_name(host, name); } else if (type == GEN_IPADD) { /* Here name isn't so much a name but a binary representation of the IP */ matched = addr && !!memcmp(name, addr, namelen); @@ -481,7 +474,7 @@ static int verify_server_cert(SSL *ssl, const char *host) goto cert_fail_name; } - if (check_host_name((char *)peer_cn, host) < 0) + if (!check_host_name(host, (char *)peer_cn)) goto cert_fail_name; goto cleanup; diff --git a/src/util/net.c b/src/util/net.c index ac7befe0738..dd8a1ba4670 100644 --- a/src/util/net.c +++ b/src/util/net.c @@ -19,6 +19,50 @@ #define DEFAULT_PORT_GIT "9418" #define DEFAULT_PORT_SSH "22" +bool git_net_hostname_matches_cert( + const char *hostname, + const char *pattern) +{ + for (;;) { + char c = git__tolower(*pattern++); + + if (c == '\0') + return *hostname ? false : true; + + if (c == '*') { + c = *pattern; + + /* '*' at the end matches everything left */ + if (c == '\0') + return true; + + /* + * We've found a pattern, so move towards the + * next matching char. The '.' is handled + * specially because wildcards aren't allowed + * to cross subdomains. + */ + while(*hostname) { + char h = git__tolower(*hostname); + + if (h == c) + return git_net_hostname_matches_cert(hostname++, pattern); + else if (h == '.') + return git_net_hostname_matches_cert(hostname, pattern); + + hostname++; + } + + return false; + } + + if (c != git__tolower(*hostname++)) + return false; + } + + return false; +} + bool git_net_str_is_url(const char *str) { const char *c; diff --git a/src/util/net.h b/src/util/net.h index 17f0bc4f079..c9a84cb6cec 100644 --- a/src/util/net.h +++ b/src/util/net.h @@ -9,6 +9,23 @@ #include "git2_util.h" +/* + * Hostname handling + */ + +/* + * See if a given hostname matches a certificate name pattern, according + * to RFC2818 rules (which specifies HTTP over TLS). Mainly, an asterisk + * matches anything, but is limited to a single url component. + */ +extern bool git_net_hostname_matches_cert( + const char *hostname, + const char *pattern); + +/* + * URL handling + */ + typedef struct git_net_url { char *scheme; char *host; diff --git a/tests/libgit2/network/matchhost.c b/tests/libgit2/network/matchhost.c deleted file mode 100644 index 3100dc21d70..00000000000 --- a/tests/libgit2/network/matchhost.c +++ /dev/null @@ -1,13 +0,0 @@ -#include "clar_libgit2.h" -#include "netops.h" - -void test_network_matchhost__match(void) -{ - cl_git_pass(gitno__match_host("*.example.org", "www.example.org")); - cl_git_pass(gitno__match_host("*.foo.example.org", "www.foo.example.org")); - cl_git_fail(gitno__match_host("*.foo.example.org", "foo.example.org")); - cl_git_fail(gitno__match_host("*.foo.example.org", "www.example.org")); - cl_git_fail(gitno__match_host("*.example.org", "example.org")); - cl_git_fail(gitno__match_host("*.example.org", "www.foo.example.org")); - cl_git_fail(gitno__match_host("*.example.org", "blah.www.www.example.org")); -} diff --git a/tests/util/hostname.c b/tests/util/hostname.c new file mode 100644 index 00000000000..5d8bfe2ac99 --- /dev/null +++ b/tests/util/hostname.c @@ -0,0 +1,13 @@ +#include "clar_libgit2.h" +#include "net.h" + +void test_hostname__matches_cert(void) +{ + cl_assert_equal_b(true, git_net_hostname_matches_cert("www.example.org", "*.example.org")); + cl_assert_equal_b(true, git_net_hostname_matches_cert("www.foo.example.org", "*.foo.example.org")); + cl_assert_equal_b(false, git_net_hostname_matches_cert("foo.example.org", "*.foo.example.org")); + cl_assert_equal_b(false, git_net_hostname_matches_cert("www.example.org", "*.foo.example.org")); + cl_assert_equal_b(false, git_net_hostname_matches_cert("example.org", "*.example.org")); + cl_assert_equal_b(false, git_net_hostname_matches_cert("www.foo.example.org", "*.example.org")); + cl_assert_equal_b(false, git_net_hostname_matches_cert("blah.www.www.example.org", "*.example.org")); +} From 11c89c386c8862f834097cdc5d9ed79634cf00f3 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 12 May 2023 20:48:30 +0100 Subject: [PATCH 271/608] net: move `gitno` buffer to `staticstr` The `gitno` buffer interface is another layer on top of socket reads. Abstract it a bit into a "static string" that has `git_str` like semantics but without heap allocation which moves the actual reading logic into the socket / stream code, and allows for easier future usage of a static / stack-allocated `git_str`-like interface. --- src/libgit2/fetch.c | 1 - src/libgit2/fetch.h | 2 - src/libgit2/netops.c | 85 ------------------------- src/libgit2/netops.h | 55 ---------------- src/libgit2/pack-objects.c | 1 - src/libgit2/pack-objects.h | 1 - src/libgit2/streams/mbedtls.c | 1 - src/libgit2/streams/openssl.c | 5 +- src/libgit2/streams/socket.c | 1 - src/libgit2/streams/socket.h | 2 +- src/libgit2/transports/auth.h | 3 +- src/libgit2/transports/git.c | 15 ++--- src/libgit2/transports/http.c | 1 - src/libgit2/transports/smart.c | 57 +++++++++-------- src/libgit2/transports/smart.h | 9 ++- src/libgit2/transports/smart_pkt.c | 1 - src/libgit2/transports/smart_protocol.c | 78 +++++++++++------------ src/libgit2/transports/ssh.c | 1 - src/libgit2/transports/winhttp.c | 1 - src/util/staticstr.h | 66 +++++++++++++++++++ tests/util/url/joinpath.c | 1 - tests/util/url/redirect.c | 1 - 22 files changed, 151 insertions(+), 237 deletions(-) delete mode 100644 src/libgit2/netops.c delete mode 100644 src/libgit2/netops.h create mode 100644 src/util/staticstr.h diff --git a/src/libgit2/fetch.c b/src/libgit2/fetch.c index 5bbef87f4e0..d74abb4a847 100644 --- a/src/libgit2/fetch.c +++ b/src/libgit2/fetch.c @@ -17,7 +17,6 @@ #include "remote.h" #include "refspec.h" #include "pack.h" -#include "netops.h" #include "repository.h" #include "refs.h" #include "transports/smart.h" diff --git a/src/libgit2/fetch.h b/src/libgit2/fetch.h index 10b6731f0a2..493366dedf1 100644 --- a/src/libgit2/fetch.h +++ b/src/libgit2/fetch.h @@ -11,8 +11,6 @@ #include "git2/remote.h" -#include "netops.h" - int git_fetch_negotiate(git_remote *remote, const git_fetch_options *opts); int git_fetch_download_pack(git_remote *remote); diff --git a/src/libgit2/netops.c b/src/libgit2/netops.c deleted file mode 100644 index 5cae374ad9a..00000000000 --- a/src/libgit2/netops.c +++ /dev/null @@ -1,85 +0,0 @@ -/* - * Copyright (C) the libgit2 contributors. All rights reserved. - * - * This file is part of libgit2, distributed under the GNU GPL v2 with - * a Linking Exception. For full terms see the included COPYING file. - */ - -#include "netops.h" - -#include -#include "git2/errors.h" - -#include "posix.h" -#include "str.h" -#include "runtime.h" - -int gitno_recv(gitno_buffer *buf) -{ - return buf->recv(buf); -} - -void gitno_buffer_setup_callback( - gitno_buffer *buf, - char *data, - size_t len, - int (*recv)(gitno_buffer *buf), void *cb_data) -{ - memset(data, 0x0, len); - buf->data = data; - buf->len = len; - buf->offset = 0; - buf->recv = recv; - buf->cb_data = cb_data; -} - -static int recv_stream(gitno_buffer *buf) -{ - git_stream *io = (git_stream *) buf->cb_data; - size_t readlen = buf->len - buf->offset; - ssize_t ret; - - readlen = min(readlen, INT_MAX); - - ret = git_stream_read(io, buf->data + buf->offset, (int)readlen); - if (ret < 0) - return -1; - - buf->offset += ret; - return (int)ret; -} - -void gitno_buffer_setup_fromstream(git_stream *st, gitno_buffer *buf, char *data, size_t len) -{ - memset(data, 0x0, len); - buf->data = data; - buf->len = len; - buf->offset = 0; - buf->recv = recv_stream; - buf->cb_data = st; -} - -/* Consume up to ptr and move the rest of the buffer to the beginning */ -int gitno_consume(gitno_buffer *buf, const char *ptr) -{ - size_t consumed; - - GIT_ASSERT(ptr - buf->data >= 0); - GIT_ASSERT(ptr - buf->data <= (int) buf->len); - - consumed = ptr - buf->data; - - memmove(buf->data, ptr, buf->offset - consumed); - memset(buf->data + buf->offset, 0x0, buf->len - buf->offset); - buf->offset -= consumed; - - return 0; -} - -/* Consume const bytes and move the rest of the buffer to the beginning */ -void gitno_consume_n(gitno_buffer *buf, size_t cons) -{ - memmove(buf->data, buf->data + cons, buf->len - buf->offset); - memset(buf->data + cons, 0x0, buf->len - buf->offset); - buf->offset -= cons; -} diff --git a/src/libgit2/netops.h b/src/libgit2/netops.h deleted file mode 100644 index a3f4a0f9523..00000000000 --- a/src/libgit2/netops.h +++ /dev/null @@ -1,55 +0,0 @@ -/* - * Copyright (C) the libgit2 contributors. All rights reserved. - * - * This file is part of libgit2, distributed under the GNU GPL v2 with - * a Linking Exception. For full terms see the included COPYING file. - */ -#ifndef INCLUDE_netops_h__ -#define INCLUDE_netops_h__ - -#include "common.h" - -#include "posix.h" -#include "stream.h" -#include "net.h" - -#ifdef GIT_OPENSSL -# include "streams/openssl.h" -#endif - -typedef struct gitno_ssl { -#ifdef GIT_OPENSSL - SSL *ssl; -#else - size_t dummy; -#endif -} gitno_ssl; - -/* Represents a socket that may or may not be using SSL */ -typedef struct gitno_socket { - GIT_SOCKET socket; - gitno_ssl ssl; -} gitno_socket; - -typedef struct gitno_buffer { - char *data; - size_t len; - size_t offset; - int (*recv)(struct gitno_buffer *buffer); - void *cb_data; -} gitno_buffer; - -/* Flags to gitno_connect */ -enum { - /* Attempt to create an SSL connection. */ - GITNO_CONNECT_SSL = 1 -}; - -void gitno_buffer_setup_fromstream(git_stream *st, gitno_buffer *buf, char *data, size_t len); -void gitno_buffer_setup_callback(gitno_buffer *buf, char *data, size_t len, int (*recv)(gitno_buffer *buf), void *cb_data); -int gitno_recv(gitno_buffer *buf); - -int gitno_consume(gitno_buffer *buf, const char *ptr); -void gitno_consume_n(gitno_buffer *buf, size_t cons); - -#endif diff --git a/src/libgit2/pack-objects.c b/src/libgit2/pack-objects.c index fc8efc65f5e..b2d80cba954 100644 --- a/src/libgit2/pack-objects.c +++ b/src/libgit2/pack-objects.c @@ -11,7 +11,6 @@ #include "zstream.h" #include "delta.h" #include "iterator.h" -#include "netops.h" #include "pack.h" #include "thread.h" #include "tree.h" diff --git a/src/libgit2/pack-objects.h b/src/libgit2/pack-objects.h index 0ceebc23cab..bbc8b9430ee 100644 --- a/src/libgit2/pack-objects.h +++ b/src/libgit2/pack-objects.h @@ -13,7 +13,6 @@ #include "str.h" #include "hash.h" #include "oidmap.h" -#include "netops.h" #include "zstream.h" #include "pool.h" #include "indexer.h" diff --git a/src/libgit2/streams/mbedtls.c b/src/libgit2/streams/mbedtls.c index 0cf5c8af1fb..49aa76c3ed8 100644 --- a/src/libgit2/streams/mbedtls.c +++ b/src/libgit2/streams/mbedtls.c @@ -14,7 +14,6 @@ #include "runtime.h" #include "stream.h" #include "streams/socket.h" -#include "netops.h" #include "git2/transport.h" #include "util.h" diff --git a/src/libgit2/streams/openssl.c b/src/libgit2/streams/openssl.c index 58b2d1b2363..9db911e39b3 100644 --- a/src/libgit2/streams/openssl.c +++ b/src/libgit2/streams/openssl.c @@ -20,7 +20,6 @@ #include "stream.h" #include "net.h" #include "streams/socket.h" -#include "netops.h" #include "git2/transport.h" #include "git2/sys/openssl.h" @@ -71,14 +70,14 @@ static void *git_openssl_malloc(size_t bytes, const char *file, int line) GIT_UNUSED(line); return git__calloc(1, bytes); } - + static void *git_openssl_realloc(void *mem, size_t size, const char *file, int line) { GIT_UNUSED(file); GIT_UNUSED(line); return git__realloc(mem, size); } - + static void git_openssl_free(void *mem, const char *file, int line) { GIT_UNUSED(file); diff --git a/src/libgit2/streams/socket.c b/src/libgit2/streams/socket.c index 8f23e746e51..6994d58f268 100644 --- a/src/libgit2/streams/socket.c +++ b/src/libgit2/streams/socket.c @@ -8,7 +8,6 @@ #include "streams/socket.h" #include "posix.h" -#include "netops.h" #include "registry.h" #include "runtime.h" #include "stream.h" diff --git a/src/libgit2/streams/socket.h b/src/libgit2/streams/socket.h index 300e708937f..73e8de099a6 100644 --- a/src/libgit2/streams/socket.h +++ b/src/libgit2/streams/socket.h @@ -9,7 +9,7 @@ #include "common.h" -#include "netops.h" +#include "stream.h" typedef struct { git_stream parent; diff --git a/src/libgit2/transports/auth.h b/src/libgit2/transports/auth.h index 64680cc5358..9f6f8fd3b2d 100644 --- a/src/libgit2/transports/auth.h +++ b/src/libgit2/transports/auth.h @@ -9,8 +9,7 @@ #define INCLUDE_transports_auth_h__ #include "common.h" - -#include "netops.h" +#include "net.h" typedef enum { GIT_HTTP_AUTH_BASIC = 1, diff --git a/src/libgit2/transports/git.c b/src/libgit2/transports/git.c index 591e2ab0352..53611f2a7a6 100644 --- a/src/libgit2/transports/git.c +++ b/src/libgit2/transports/git.c @@ -7,7 +7,7 @@ #include "common.h" -#include "netops.h" +#include "net.h" #include "stream.h" #include "streams/socket.h" #include "git2/sys/transport.h" @@ -95,22 +95,21 @@ static int git_proto_stream_read( size_t buf_size, size_t *bytes_read) { - int error; git_proto_stream *s = (git_proto_stream *)stream; - gitno_buffer buf; + ssize_t ret; + int error; *bytes_read = 0; if (!s->sent_command && (error = send_command(s)) < 0) return error; - gitno_buffer_setup_fromstream(s->io, &buf, buffer, buf_size); + ret = git_stream_read(s->io, buffer, min(buf_size, INT_MAX)); - if ((error = gitno_recv(&buf)) < 0) - return error; - - *bytes_read = buf.offset; + if (ret < 0) + return -1; + *bytes_read = (size_t)ret; return 0; } diff --git a/src/libgit2/transports/http.c b/src/libgit2/transports/http.c index cda76ae6199..0534503bf25 100644 --- a/src/libgit2/transports/http.c +++ b/src/libgit2/transports/http.c @@ -11,7 +11,6 @@ #include "http_parser.h" #include "net.h" -#include "netops.h" #include "remote.h" #include "smart.h" #include "auth.h" diff --git a/src/libgit2/transports/smart.c b/src/libgit2/transports/smart.c index a56524bff0a..53727282850 100644 --- a/src/libgit2/transports/smart.c +++ b/src/libgit2/transports/smart.c @@ -13,30 +13,42 @@ #include "refspec.h" #include "proxy.h" -static int git_smart__recv_cb(gitno_buffer *buf) +int git_smart__recv(transport_smart *t) { - transport_smart *t = (transport_smart *) buf->cb_data; - size_t old_len, bytes_read; - int error; + size_t bytes_read; + int ret; + GIT_ASSERT_ARG(t); GIT_ASSERT(t->current_stream); - old_len = buf->offset; + if (git_staticstr_remain(&t->buffer) == 0) { + git_error_set(GIT_ERROR_NET, "out of buffer space"); + return -1; + } - if ((error = t->current_stream->read(t->current_stream, buf->data + buf->offset, buf->len - buf->offset, &bytes_read)) < 0) - return error; + ret = t->current_stream->read(t->current_stream, + git_staticstr_offset(&t->buffer), + git_staticstr_remain(&t->buffer), + &bytes_read); - buf->offset += bytes_read; + if (ret < 0) + return ret; + + GIT_ASSERT(bytes_read <= INT_MAX); + GIT_ASSERT(bytes_read <= git_staticstr_remain(&t->buffer)); + + git_staticstr_increase(&t->buffer, bytes_read); if (t->packetsize_cb && !t->cancelled.val) { - error = t->packetsize_cb(bytes_read, t->packetsize_payload); - if (error) { + ret = t->packetsize_cb(bytes_read, t->packetsize_payload); + + if (ret) { git_atomic32_set(&t->cancelled, 1); return GIT_EUSER; } } - return (int)(buf->offset - old_len); + return (int)bytes_read; } GIT_INLINE(int) git_smart__reset_stream(transport_smart *t, bool close_subtransport) @@ -155,8 +167,6 @@ static int git_smart__connect( /* Save off the current stream (i.e. socket) that we are working with */ t->current_stream = stream; - gitno_buffer_setup_callback(&t->buffer, t->buffer_data, sizeof(t->buffer_data), git_smart__recv_cb, t); - /* 2 flushes for RPC; 1 for stateful */ if ((error = git_smart__store_refs(t, t->rpc ? 2 : 1)) < 0) return error; @@ -313,8 +323,6 @@ int git_smart__negotiation_step(git_transport *transport, void *data, size_t len if ((error = stream->write(stream, (const char *)data, len)) < 0) return error; - gitno_buffer_setup_callback(&t->buffer, t->buffer_data, sizeof(t->buffer_data), git_smart__recv_cb, t); - return 0; } @@ -339,8 +347,6 @@ int git_smart__get_push_stream(transport_smart *t, git_smart_subtransport_stream /* Save off the current stream (i.e. socket) that we are working with */ t->current_stream = *stream; - gitno_buffer_setup_callback(&t->buffer, t->buffer_data, sizeof(t->buffer_data), git_smart__recv_cb, t); - return 0; } @@ -502,20 +508,17 @@ int git_transport_smart(git_transport **out, git_remote *owner, void *param) t->owner = owner; t->rpc = definition->rpc; - if (git_vector_init(&t->refs, 16, ref_name_cmp) < 0) { + if (git_vector_init(&t->refs, 16, ref_name_cmp) < 0 || + git_vector_init(&t->heads, 16, ref_name_cmp) < 0 || + definition->callback(&t->wrapped, &t->parent, definition->param) < 0) { + git_vector_free(&t->refs); + git_vector_free(&t->heads); + t->wrapped->free(t->wrapped); git__free(t); return -1; } - if (git_vector_init(&t->heads, 16, ref_name_cmp) < 0) { - git__free(t); - return -1; - } - - if (definition->callback(&t->wrapped, &t->parent, definition->param) < 0) { - git__free(t); - return -1; - } + git_staticstr_init(&t->buffer, GIT_SMART_BUFFER_SIZE); *out = (git_transport *) t; return 0; diff --git a/src/libgit2/transports/smart.h b/src/libgit2/transports/smart.h index 34e27ea8e05..52c7553a1d7 100644 --- a/src/libgit2/transports/smart.h +++ b/src/libgit2/transports/smart.h @@ -11,12 +11,14 @@ #include "git2.h" #include "vector.h" -#include "netops.h" #include "push.h" #include "str.h" #include "oidarray.h" +#include "staticstr.h" #include "git2/sys/transport.h" +#define GIT_SMART_BUFFER_SIZE 65536 + #define GIT_SIDE_BAND_DATA 1 #define GIT_SIDE_BAND_PROGRESS 2 #define GIT_SIDE_BAND_ERROR 3 @@ -170,8 +172,7 @@ typedef struct { unsigned rpc : 1, have_refs : 1, connected : 1; - gitno_buffer buffer; - char buffer_data[65536]; + git_staticstr_with_size(GIT_SMART_BUFFER_SIZE) buffer; } transport_smart; /* smart_protocol.c */ @@ -192,6 +193,8 @@ int git_smart__download_pack( git_indexer_progress *stats); /* smart.c */ +int git_smart__recv(transport_smart *t); + int git_smart__negotiation_step(git_transport *transport, void *data, size_t len); int git_smart__get_push_stream(transport_smart *t, git_smart_subtransport_stream **out); diff --git a/src/libgit2/transports/smart_pkt.c b/src/libgit2/transports/smart_pkt.c index 9127ad5fe43..7805f332377 100644 --- a/src/libgit2/transports/smart_pkt.c +++ b/src/libgit2/transports/smart_pkt.c @@ -9,7 +9,6 @@ #include "smart.h" #include "util.h" -#include "netops.h" #include "posix.h" #include "str.h" #include "oid.h" diff --git a/src/libgit2/transports/smart_protocol.c b/src/libgit2/transports/smart_protocol.c index f7a56782930..c9c422d4c85 100644 --- a/src/libgit2/transports/smart_protocol.c +++ b/src/libgit2/transports/smart_protocol.c @@ -27,7 +27,6 @@ bool git_smart__ofs_delta_enabled = true; int git_smart__store_refs(transport_smart *t, int flushes) { - gitno_buffer *buf = &t->buffer; git_vector *refs = &t->refs; int error, flush = 0, recvd; const char *line_end = NULL; @@ -45,8 +44,10 @@ int git_smart__store_refs(transport_smart *t, int flushes) pkt = NULL; do { - if (buf->offset > 0) - error = git_pkt_parse_line(&pkt, &line_end, buf->data, buf->offset, &pkt_parse_data); + if (t->buffer.len > 0) + error = git_pkt_parse_line(&pkt, &line_end, + t->buffer.data, t->buffer.len, + &pkt_parse_data); else error = GIT_EBUFS; @@ -54,7 +55,7 @@ int git_smart__store_refs(transport_smart *t, int flushes) return error; if (error == GIT_EBUFS) { - if ((recvd = gitno_recv(buf)) < 0) + if ((recvd = git_smart__recv(t)) < 0) return recvd; if (recvd == 0) { @@ -65,8 +66,7 @@ int git_smart__store_refs(transport_smart *t, int flushes) continue; } - if (gitno_consume(buf, line_end) < 0) - return -1; + git_staticstr_consume(&t->buffer, line_end); if (pkt->type == GIT_PKT_ERR) { git_error_set(GIT_ERROR_NET, "remote error: %s", ((git_pkt_err *)pkt)->error); @@ -259,10 +259,9 @@ int git_smart__detect_caps( static int recv_pkt( git_pkt **out_pkt, git_pkt_type *out_type, - transport_smart *t, - gitno_buffer *buf) + transport_smart *t) { - const char *ptr = buf->data, *line_end = ptr; + const char *ptr = t->buffer.data, *line_end = ptr; git_pkt *pkt = NULL; git_pkt_parse_data pkt_parse_data = { 0 }; int error = 0, ret; @@ -271,8 +270,9 @@ static int recv_pkt( pkt_parse_data.seen_capabilities = 1; do { - if (buf->offset > 0) - error = git_pkt_parse_line(&pkt, &line_end, ptr, buf->offset, &pkt_parse_data); + if (t->buffer.len > 0) + error = git_pkt_parse_line(&pkt, &line_end, ptr, + t->buffer.len, &pkt_parse_data); else error = GIT_EBUFS; @@ -282,7 +282,7 @@ static int recv_pkt( if (error < 0 && error != GIT_EBUFS) return error; - if ((ret = gitno_recv(buf)) < 0) { + if ((ret = git_smart__recv(t)) < 0) { return ret; } else if (ret == 0) { git_error_set(GIT_ERROR_NET, "early EOF"); @@ -290,8 +290,7 @@ static int recv_pkt( } } while (error); - if (gitno_consume(buf, line_end) < 0) - return -1; + git_staticstr_consume(&t->buffer, line_end); if (out_type != NULL) *out_type = pkt->type; @@ -306,11 +305,10 @@ static int recv_pkt( static int store_common(transport_smart *t) { git_pkt *pkt = NULL; - gitno_buffer *buf = &t->buffer; int error; do { - if ((error = recv_pkt(&pkt, NULL, t, buf)) < 0) + if ((error = recv_pkt(&pkt, NULL, t)) < 0) return error; if (pkt->type != GIT_PKT_ACK) { @@ -327,7 +325,7 @@ static int store_common(transport_smart *t) return 0; } -static int wait_while_ack(transport_smart *t, gitno_buffer *buf) +static int wait_while_ack(transport_smart *t) { int error; git_pkt *pkt = NULL; @@ -336,7 +334,7 @@ static int wait_while_ack(transport_smart *t, gitno_buffer *buf) while (1) { git_pkt_free(pkt); - if ((error = recv_pkt(&pkt, NULL, t, buf)) < 0) + if ((error = recv_pkt(&pkt, NULL, t)) < 0) return error; if (pkt->type == GIT_PKT_NAK) @@ -402,7 +400,6 @@ int git_smart__negotiate_fetch( { transport_smart *t = (transport_smart *)transport; git_revwalk__push_options opts = GIT_REVWALK__PUSH_OPTIONS_INIT; - gitno_buffer *buf = &t->buffer; git_str data = GIT_STR_INIT; git_revwalk *walk = NULL; int error = -1; @@ -430,7 +427,7 @@ int git_smart__negotiate_fetch( if ((error = git_smart__negotiation_step(&t->parent, data.ptr, data.size)) < 0) goto on_error; - while ((error = recv_pkt((git_pkt **)&pkt, NULL, t, buf)) == 0) { + while ((error = recv_pkt((git_pkt **)&pkt, NULL, t)) == 0) { bool complete = false; if (pkt->type == GIT_PKT_SHALLOW) { @@ -495,7 +492,7 @@ int git_smart__negotiate_fetch( if ((error = store_common(t)) < 0) goto on_error; } else { - if ((error = recv_pkt(NULL, &pkt_type, t, buf)) < 0) + if ((error = recv_pkt(NULL, &pkt_type, t)) < 0) goto on_error; if (pkt_type == GIT_PKT_ACK) { @@ -568,7 +565,7 @@ int git_smart__negotiate_fetch( /* Now let's eat up whatever the server gives us */ if (!t->caps.multi_ack && !t->caps.multi_ack_detailed) { - if ((error = recv_pkt(NULL, &pkt_type, t, buf)) < 0) + if ((error = recv_pkt(NULL, &pkt_type, t)) < 0) return error; if (pkt_type != GIT_PKT_ACK && pkt_type != GIT_PKT_NAK) { @@ -576,7 +573,7 @@ int git_smart__negotiate_fetch( return -1; } } else { - error = wait_while_ack(t, buf); + error = wait_while_ack(t); } return error; @@ -606,7 +603,10 @@ int git_smart__shallow_roots(git_oidarray *out, git_transport *transport) return 0; } -static int no_sideband(transport_smart *t, struct git_odb_writepack *writepack, gitno_buffer *buf, git_indexer_progress *stats) +static int no_sideband( + transport_smart *t, + struct git_odb_writepack *writepack, + git_indexer_progress *stats) { int recvd; @@ -616,12 +616,12 @@ static int no_sideband(transport_smart *t, struct git_odb_writepack *writepack, return GIT_EUSER; } - if (writepack->append(writepack, buf->data, buf->offset, stats) < 0) + if (writepack->append(writepack, t->buffer.data, t->buffer.len, stats) < 0) return -1; - gitno_consume_n(buf, buf->offset); + git_staticstr_clear(&t->buffer); - if ((recvd = gitno_recv(buf)) < 0) + if ((recvd = git_smart__recv(t)) < 0) return recvd; } while(recvd > 0); @@ -663,7 +663,6 @@ int git_smart__download_pack( git_indexer_progress *stats) { transport_smart *t = (transport_smart *)transport; - gitno_buffer *buf = &t->buffer; git_odb *odb; struct git_odb_writepack *writepack = NULL; int error = 0; @@ -682,9 +681,10 @@ int git_smart__download_pack( t->packetsize_payload = &npp; /* We might have something in the buffer already from negotiate_fetch */ - if (t->buffer.offset > 0 && !t->cancelled.val) - if (t->packetsize_cb(t->buffer.offset, t->packetsize_payload)) + if (t->buffer.len > 0 && !t->cancelled.val) { + if (t->packetsize_cb(t->buffer.len, t->packetsize_payload)) git_atomic32_set(&t->cancelled, 1); + } } if ((error = git_repository_odb__weakptr(&odb, repo)) < 0 || @@ -697,7 +697,7 @@ int git_smart__download_pack( * check which one belongs there. */ if (!t->caps.side_band && !t->caps.side_band_64k) { - error = no_sideband(t, writepack, buf, stats); + error = no_sideband(t, writepack, stats); goto done; } @@ -711,7 +711,7 @@ int git_smart__download_pack( goto done; } - if ((error = recv_pkt(&pkt, NULL, t, buf)) >= 0) { + if ((error = recv_pkt(&pkt, NULL, t)) >= 0) { /* Check cancellation after network call */ if (t->cancelled.val) { git_error_clear(); @@ -916,15 +916,15 @@ static int parse_report(transport_smart *transport, git_push *push) git_pkt *pkt = NULL; git_pkt_parse_data pkt_parse_data = { 0 }; const char *line_end = NULL; - gitno_buffer *buf = &transport->buffer; int error, recvd; git_str data_pkt_buf = GIT_STR_INIT; for (;;) { - if (buf->offset > 0) + if (transport->buffer.len > 0) error = git_pkt_parse_line(&pkt, &line_end, - buf->data, buf->offset, - &pkt_parse_data); + transport->buffer.data, + transport->buffer.len, + &pkt_parse_data); else error = GIT_EBUFS; @@ -934,7 +934,7 @@ static int parse_report(transport_smart *transport, git_push *push) } if (error == GIT_EBUFS) { - if ((recvd = gitno_recv(buf)) < 0) { + if ((recvd = git_smart__recv(transport)) < 0) { error = recvd; goto done; } @@ -947,9 +947,7 @@ static int parse_report(transport_smart *transport, git_push *push) continue; } - if (gitno_consume(buf, line_end) < 0) - return -1; - + git_staticstr_consume(&transport->buffer, line_end); error = 0; switch (pkt->type) { diff --git a/src/libgit2/transports/ssh.c b/src/libgit2/transports/ssh.c index 5500ea100bd..af618e1a6ed 100644 --- a/src/libgit2/transports/ssh.c +++ b/src/libgit2/transports/ssh.c @@ -13,7 +13,6 @@ #include "runtime.h" #include "net.h" -#include "netops.h" #include "smart.h" #include "streams/socket.h" #include "sysdir.h" diff --git a/src/libgit2/transports/winhttp.c b/src/libgit2/transports/winhttp.c index de24a2a41c1..27e0fb6f7e9 100644 --- a/src/libgit2/transports/winhttp.c +++ b/src/libgit2/transports/winhttp.c @@ -13,7 +13,6 @@ #include "git2/transport.h" #include "posix.h" #include "str.h" -#include "netops.h" #include "smart.h" #include "remote.h" #include "repository.h" diff --git a/src/util/staticstr.h b/src/util/staticstr.h new file mode 100644 index 00000000000..b7d0790c4fd --- /dev/null +++ b/src/util/staticstr.h @@ -0,0 +1,66 @@ +/* + * Copyright (C) the libgit2 contributors. All rights reserved. + * + * This file is part of libgit2, distributed under the GNU GPL v2 with + * a Linking Exception. For full terms see the included COPYING file. + */ +#ifndef INCLUDE_stackstr_h__ +#define INCLUDE_stackstr_h__ + +#include "git2_util.h" + +typedef struct { + /* Length of / number of bytes used by `data`. */ + size_t len; + + /* Size of the allocated `data` buffer. */ + size_t size; + + /* The actual string buffer data. */ + char data[GIT_FLEX_ARRAY]; +} git_staticstr; + +#define git_staticstr_with_size(__size) \ + struct { \ + size_t len; \ + size_t size; \ + char data[__size]; \ + } + +#define git_staticstr_init(__str, __size) \ + do { \ + (__str)->len = 0; \ + (__str)->size = __size; \ + (__str)->data[0] = '\0'; \ + } while(0) + +#define git_staticstr_offset(__str) \ + ((__str)->data + (__str)->len) + +#define git_staticstr_remain(__str) \ + ((__str)->len > (__str)->size ? 0 : ((__str)->size - (__str)->len)) + +#define git_staticstr_increase(__str, __len) \ + do { ((__str)->len += __len); } while(0) + +#define git_staticstr_consume_bytes(__str, __len) \ + do { git_staticstr_consume(__str, (__str)->data + __len); } while(0) + +#define git_staticstr_consume(__str, __end) \ + do { \ + if (__end > (__str)->data && \ + __end <= (__str)->data + (__str)->len) { \ + size_t __consumed = __end - (__str)->data; \ + memmove((__str)->data, __end, (__str)->len - __consumed); \ + (__str)->len -= __consumed; \ + (__str)->data[(__str)->len] = '\0'; \ + } \ + } while(0) + +#define git_staticstr_clear(__str) \ + do { \ + (__str)->len = 0; \ + (__str)->data[0] = 0; \ + } while(0) + +#endif diff --git a/tests/util/url/joinpath.c b/tests/util/url/joinpath.c index 9fc02cde4a9..6027093e492 100644 --- a/tests/util/url/joinpath.c +++ b/tests/util/url/joinpath.c @@ -1,6 +1,5 @@ #include "clar_libgit2.h" #include "net.h" -#include "netops.h" static git_net_url source, target; diff --git a/tests/util/url/redirect.c b/tests/util/url/redirect.c index 5401778618f..a6f99dcdf09 100644 --- a/tests/util/url/redirect.c +++ b/tests/util/url/redirect.c @@ -1,6 +1,5 @@ #include "clar_libgit2.h" #include "net.h" -#include "netops.h" static git_net_url conndata; From 933b04c219b49d0f9cd779d024bfa39d806839ac Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 12 May 2023 20:48:30 +0100 Subject: [PATCH 272/608] ci: update to poxygit v0.6.0 v0.6.0 of poxygit add support for throttling connections to test timeouts and low-bandwidth situations. --- ci/test.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ci/test.sh b/ci/test.sh index c46cf0dc437..a6735231f21 100755 --- a/ci/test.sh +++ b/ci/test.sh @@ -171,7 +171,7 @@ if [ -z "$SKIP_PROXY_TESTS" ]; then fi if [ -z "$SKIP_NTLM_TESTS" -o -z "$SKIP_ONLINE_TESTS" ]; then - curl --location --silent --show-error https://github.com/ethomson/poxygit/releases/download/v0.5.1/poxygit-0.5.1.jar >poxygit.jar + curl --location --silent --show-error https://github.com/ethomson/poxygit/releases/download/v0.6.0/poxygit-0.6.0.jar >poxygit.jar echo "Starting HTTP server..." HTTP_DIR=`mktemp -d ${TMPDIR}/http.XXXXXXXX` From fad90428970e332153027773b517a1606c0efa1f Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 12 May 2023 20:48:30 +0100 Subject: [PATCH 273/608] streams: sockets are non-blocking and can timeout Make socket I/O non-blocking and add optional timeouts. Users may now set `GIT_OPT_SET_SERVER_CONNECT_TIMEOUT` to set a shorter connection timeout. (The connect timeout cannot be longer than the operating system default.) Users may also now configure the socket read and write timeouts with `GIT_OPT_SET_SERVER_TIMEOUT`. By default, connects still timeout based on the operating system defaults (typically 75 seconds) and socket read and writes block. Add a test against our custom testing git server that ensures that we can timeout reads against a slow server. --- ci/test.sh | 4 + include/git2/common.h | 27 ++++- include/git2/errors.h | 3 +- include/git2/sys/stream.h | 18 ++- src/libgit2/libgit2.c | 36 ++++++ src/libgit2/streams/socket.c | 198 +++++++++++++++++++++++++++---- src/libgit2/streams/stransport.c | 17 ++- tests/libgit2/CMakeLists.txt | 2 +- tests/libgit2/online/clone.c | 60 ++++++++++ 9 files changed, 335 insertions(+), 30 deletions(-) diff --git a/ci/test.sh b/ci/test.sh index a6735231f21..ee6801a79a2 100755 --- a/ci/test.sh +++ b/ci/test.sh @@ -271,9 +271,13 @@ if [ -z "$SKIP_ONLINE_TESTS" ]; then export GITTEST_REMOTE_REDIRECT_INITIAL="http://localhost:9000/initial-redirect/libgit2/TestGitRepository" export GITTEST_REMOTE_REDIRECT_SUBSEQUENT="http://localhost:9000/subsequent-redirect/libgit2/TestGitRepository" + export GITTEST_REMOTE_SPEED_SLOW="http://localhost:9000/speed-9600/test.git" + export GITTEST_REMOTE_SPEED_TIMESOUT="http://localhost:9000/speed-0.5/test.git" run_test online unset GITTEST_REMOTE_REDIRECT_INITIAL unset GITTEST_REMOTE_REDIRECT_SUBSEQUENT + unset GITTEST_REMOTE_SPEED_SLOW + unset GITTEST_REMOTE_SPEED_TIMESOUT # Run the online tests that immutably change global state separately # to avoid polluting the test environment. diff --git a/include/git2/common.h b/include/git2/common.h index f968deb233a..ab6bc1333b3 100644 --- a/include/git2/common.h +++ b/include/git2/common.h @@ -224,7 +224,11 @@ typedef enum { GIT_OPT_GET_OWNER_VALIDATION, GIT_OPT_SET_OWNER_VALIDATION, GIT_OPT_GET_HOMEDIR, - GIT_OPT_SET_HOMEDIR + GIT_OPT_SET_HOMEDIR, + GIT_OPT_SET_SERVER_CONNECT_TIMEOUT, + GIT_OPT_GET_SERVER_CONNECT_TIMEOUT, + GIT_OPT_SET_SERVER_TIMEOUT, + GIT_OPT_GET_SERVER_TIMEOUT } git_libgit2_opt_t; /** @@ -480,6 +484,27 @@ typedef enum { * > * > - `path` directory of home directory. * + * opts(GIT_OPT_GET_SERVER_CONNECT_TIMEOUT, int *timeout) + * > Gets the timeout (in milliseconds) to attempt connections to + * > a remote server. + * + * opts(GIT_OPT_SET_SERVER_CONNECT_TIMEOUT, int timeout) + * > Sets the timeout (in milliseconds) to attempt connections to + * > a remote server. This is supported only for HTTP(S) connections + * > and is not supported by SSH. Set to 0 to use the system default. + * > Note that this may not be able to be configured longer than the + * > system default, typically 75 seconds. + * + * opts(GIT_OPT_GET_SERVER_TIMEOUT, int *timeout) + * > Gets the timeout (in milliseconds) for reading from and writing + * > to a remote server. + * + * opts(GIT_OPT_SET_SERVER_TIMEOUT, int timeout) + * > Sets the timeout (in milliseconds) for reading from and writing + * > to a remote server. This is supported only for HTTP(S) + * > connections and is not supported by SSH. Set to 0 to use the + * > system default. + * * @param option Option key * @param ... value to set the option * @return 0 on success, <0 on failure diff --git a/include/git2/errors.h b/include/git2/errors.h index e634a97c176..7180852f95c 100644 --- a/include/git2/errors.h +++ b/include/git2/errors.h @@ -58,7 +58,8 @@ typedef enum { GIT_EMISMATCH = -33, /**< Hashsum mismatch in object */ GIT_EINDEXDIRTY = -34, /**< Unsaved changes in the index would be overwritten */ GIT_EAPPLYFAIL = -35, /**< Patch application failed */ - GIT_EOWNER = -36 /**< The object is not owned by the current user */ + GIT_EOWNER = -36, /**< The object is not owned by the current user */ + GIT_TIMEOUT = -37 /**< The operation timed out */ } git_error_code; /** diff --git a/include/git2/sys/stream.h b/include/git2/sys/stream.h index e0e03a2d764..3d28d09b321 100644 --- a/include/git2/sys/stream.h +++ b/include/git2/sys/stream.h @@ -29,8 +29,22 @@ GIT_BEGIN_DECL typedef struct git_stream { int version; - int encrypted; - int proxy_support; + int encrypted : 1, + proxy_support : 1; + + /** + * Timeout for read and write operations; can be set to `0` to + * block indefinitely. + */ + int timeout; + + /** + * Timeout to connect to the remote server; can be set to `0` + * to use the system defaults. This can be shorter than the + * system default - often 75 seconds - but cannot be longer. + */ + int connect_timeout; + int GIT_CALLBACK(connect)(struct git_stream *); int GIT_CALLBACK(certificate)(git_cert **, struct git_stream *); int GIT_CALLBACK(set_proxy)(struct git_stream *, const git_proxy_options *proxy_opts); diff --git a/src/libgit2/libgit2.c b/src/libgit2/libgit2.c index 178880c9eb9..ce287147a70 100644 --- a/src/libgit2/libgit2.c +++ b/src/libgit2/libgit2.c @@ -48,6 +48,8 @@ extern size_t git_indexer__max_objects; extern bool git_disable_pack_keep_file_checks; extern int git_odb__packed_priority; extern int git_odb__loose_priority; +extern int git_socket_stream__connect_timeout; +extern int git_socket_stream__timeout; char *git__user_agent; char *git__ssl_ciphers; @@ -436,6 +438,40 @@ int git_libgit2_opts(int key, ...) error = git_sysdir_set(GIT_SYSDIR_HOME, va_arg(ap, const char *)); break; + case GIT_OPT_GET_SERVER_CONNECT_TIMEOUT: + *(va_arg(ap, int *)) = git_socket_stream__connect_timeout; + break; + + case GIT_OPT_SET_SERVER_CONNECT_TIMEOUT: + { + int timeout = va_arg(ap, int); + + if (timeout < 0) { + git_error_set(GIT_ERROR_INVALID, "invalid connect timeout"); + error = -1; + } else { + git_socket_stream__connect_timeout = timeout; + } + } + break; + + case GIT_OPT_GET_SERVER_TIMEOUT: + *(va_arg(ap, int *)) = git_socket_stream__timeout; + break; + + case GIT_OPT_SET_SERVER_TIMEOUT: + { + int timeout = va_arg(ap, int); + + if (timeout < 0) { + git_error_set(GIT_ERROR_INVALID, "invalid timeout"); + error = -1; + } else { + git_socket_stream__timeout = timeout; + } + } + break; + default: git_error_set(GIT_ERROR_INVALID, "invalid option key"); error = -1; diff --git a/src/libgit2/streams/socket.c b/src/libgit2/streams/socket.c index 6994d58f268..0e0aa69349b 100644 --- a/src/libgit2/streams/socket.c +++ b/src/libgit2/streams/socket.c @@ -20,6 +20,7 @@ # include # include # include +# include #else # include # include @@ -28,6 +29,9 @@ # endif #endif +int git_socket_stream__connect_timeout = 0; +int git_socket_stream__timeout = 0; + #ifdef GIT_WIN32 static void net_set_error(const char *str) { @@ -66,21 +70,105 @@ static int close_socket(GIT_SOCKET s) } +static int set_nonblocking(GIT_SOCKET s) +{ +#ifdef GIT_WIN32 + unsigned long nonblocking = 1; + + if (ioctlsocket(s, FIONBIO, &nonblocking) != 0) { + net_set_error("could not set socket non-blocking"); + return -1; + } +#else + int flags; + + if ((flags = fcntl(s, F_GETFL, 0)) == -1) { + net_set_error("could not query socket flags"); + return -1; + } + + flags |= O_NONBLOCK; + + if (fcntl(s, F_SETFL, flags) != 0) { + net_set_error("could not set socket non-blocking"); + return -1; + } +#endif + + return 0; +} + +/* Promote a sockerr to an errno for our error handling routines */ +static int handle_sockerr(GIT_SOCKET socket) +{ + int sockerr; + socklen_t errlen = sizeof(sockerr); + + if (getsockopt(socket, SOL_SOCKET, SO_ERROR, &sockerr, &errlen) < 0) + return -1; + + if (sockerr == ETIMEDOUT) + return GIT_TIMEOUT; + + errno = sockerr; + return -1; +} + +static int connect_with_timeout( + GIT_SOCKET socket, + const struct sockaddr *address, + socklen_t address_len, + int timeout) +{ + struct pollfd fd; + int error; + + if (timeout && (error = set_nonblocking(socket)) < 0) + return error; + + error = connect(socket, address, address_len); + + if (error == 0 || (error == -1 && errno != EINPROGRESS)) + return error; + + fd.fd = socket; + fd.events = POLLOUT; + fd.revents = 0; + + error = poll(&fd, 1, timeout); + + if (error == 0) { + return GIT_TIMEOUT; + } else if (error != 1) { + return -1; + } else if ((fd.revents & (POLLHUP | POLLERR))) { + return handle_sockerr(socket); + } else if ((fd.revents & POLLOUT) != POLLOUT) { + git_error_set(GIT_ERROR_NET, + "unknown error while polling for connect: %d", + fd.revents); + return -1; + } + + return 0; +} + static int socket_connect(git_stream *stream) { - struct addrinfo *info = NULL, *p; - struct addrinfo hints; git_socket_stream *st = (git_socket_stream *) stream; GIT_SOCKET s = INVALID_SOCKET; - int ret; + struct addrinfo *info = NULL, *p; + struct addrinfo hints; + int error; memset(&hints, 0x0, sizeof(struct addrinfo)); hints.ai_socktype = SOCK_STREAM; hints.ai_family = AF_UNSPEC; - if ((ret = p_getaddrinfo(st->host, st->port, &hints, &info)) != 0) { + if ((error = p_getaddrinfo(st->host, st->port, &hints, &info)) != 0) { git_error_set(GIT_ERROR_NET, - "failed to resolve address for %s: %s", st->host, p_gai_strerror(ret)); + "failed to resolve address for %s: %s", + st->host, p_gai_strerror(error)); return -1; } @@ -90,51 +178,115 @@ static int socket_connect(git_stream *stream) if (s == INVALID_SOCKET) continue; - if (connect(s, p->ai_addr, (socklen_t)p->ai_addrlen) == 0) + error = connect_with_timeout(s, p->ai_addr, + (socklen_t)p->ai_addrlen, + st->parent.connect_timeout); + + if (error == 0) break; /* If we can't connect, try the next one */ close_socket(s); s = INVALID_SOCKET; + + if (error == GIT_TIMEOUT) + break; } /* Oops, we couldn't connect to any address */ - if (s == INVALID_SOCKET && p == NULL) { - git_error_set(GIT_ERROR_OS, "failed to connect to %s", st->host); - p_freeaddrinfo(info); - return -1; + if (s == INVALID_SOCKET) { + if (error == GIT_TIMEOUT) + git_error_set(GIT_ERROR_NET, "failed to connect to %s: Operation timed out", st->host); + else + git_error_set(GIT_ERROR_OS, "failed to connect to %s", st->host); + error = -1; + goto done; } + if (st->parent.timeout && !st->parent.connect_timeout && + (error = set_nonblocking(s)) < 0) + return error; + st->s = s; + error = 0; + +done: p_freeaddrinfo(info); - return 0; + return error; } -static ssize_t socket_write(git_stream *stream, const char *data, size_t len, int flags) +static ssize_t socket_write( + git_stream *stream, + const char *data, + size_t len, + int flags) { git_socket_stream *st = (git_socket_stream *) stream; - ssize_t written; + struct pollfd fd; + ssize_t ret; GIT_ASSERT(flags == 0); GIT_UNUSED(flags); - errno = 0; + ret = p_send(st->s, data, len, 0); + + if (st->parent.timeout && ret < 0 && + (errno == EAGAIN || errno != EWOULDBLOCK)) { + fd.fd = st->s; + fd.events = POLLOUT; + fd.revents = 0; + + ret = poll(&fd, 1, st->parent.timeout); - if ((written = p_send(st->s, data, len, 0)) < 0) { - net_set_error("error sending data"); + if (ret == 1) { + ret = p_send(st->s, data, len, 0); + } else if (ret == 0) { + git_error_set(GIT_ERROR_NET, + "could not write to socket: timed out"); + return GIT_TIMEOUT; + } + } + + if (ret < 0) { + net_set_error("error receiving data from socket"); return -1; } - return written; + return ret; } -static ssize_t socket_read(git_stream *stream, void *data, size_t len) +static ssize_t socket_read( + git_stream *stream, + void *data, + size_t len) { - ssize_t ret; git_socket_stream *st = (git_socket_stream *) stream; + struct pollfd fd; + ssize_t ret; + + ret = p_recv(st->s, data, len, 0); + + if (st->parent.timeout && ret < 0 && + (errno == EAGAIN || errno != EWOULDBLOCK)) { + fd.fd = st->s; + fd.events = POLLIN; + fd.revents = 0; - if ((ret = p_recv(st->s, data, len, 0)) < 0) - net_set_error("error receiving socket data"); + ret = poll(&fd, 1, st->parent.timeout); + + if (ret == 1) { + ret = p_recv(st->s, data, len, 0); + } else if (ret == 0) { + git_error_set(GIT_ERROR_NET, + "could not read from socket: timed out"); + return GIT_TIMEOUT; + } + } + + if (ret < 0) { + net_set_error("error receiving data from socket"); + return -1; + } return ret; } @@ -182,6 +334,8 @@ static int default_socket_stream_new( } st->parent.version = GIT_STREAM_VERSION; + st->parent.timeout = git_socket_stream__timeout; + st->parent.connect_timeout = git_socket_stream__connect_timeout; st->parent.connect = socket_connect; st->parent.write = socket_write; st->parent.read = socket_read; @@ -248,7 +402,7 @@ int git_socket_stream_global_init(void) return git_runtime_shutdown_register(socket_stream_global_shutdown); } - + #else #include "stream.h" diff --git a/src/libgit2/streams/stransport.c b/src/libgit2/streams/stransport.c index 74ee0d1eeb0..d956df84d10 100644 --- a/src/libgit2/streams/stransport.c +++ b/src/libgit2/streams/stransport.c @@ -161,7 +161,9 @@ static OSStatus write_cb(SSLConnectionRef conn, const void *data, size_t *len) if (ret < 0) { st->error = ret; - return -36; /* ioErr */ + return (ret == GIT_TIMEOUT) ? + errSSLNetworkTimeout : + -36 /* ioErr */; } return noErr; @@ -176,8 +178,12 @@ static ssize_t stransport_write(git_stream *stream, const char *data, size_t len GIT_UNUSED(flags); data_len = min(len, SSIZE_MAX); - if ((ret = SSLWrite(st->ctx, data, data_len, &processed)) != noErr) + if ((ret = SSLWrite(st->ctx, data, data_len, &processed)) != noErr) { + if (st->error == GIT_TIMEOUT) + return GIT_TIMEOUT; + return stransport_error(ret); + } GIT_ASSERT(processed < SSIZE_MAX); return (ssize_t)processed; @@ -207,7 +213,9 @@ static OSStatus read_cb(SSLConnectionRef conn, void *data, size_t *len) if (ret < 0) { st->error = ret; - error = -36; /* ioErr */ + error = (ret == GIT_TIMEOUT) ? + errSSLNetworkTimeout : + -36 /* ioErr */; break; } else if (ret == 0) { error = errSSLClosedGraceful; @@ -228,6 +236,9 @@ static ssize_t stransport_read(git_stream *stream, void *data, size_t len) OSStatus ret; if ((ret = SSLRead(st->ctx, data, len, &processed)) != noErr) { + if (st->error == GIT_TIMEOUT) + return GIT_TIMEOUT; + return stransport_error(ret); } diff --git a/tests/libgit2/CMakeLists.txt b/tests/libgit2/CMakeLists.txt index 866122d1c8c..af70f55a78b 100644 --- a/tests/libgit2/CMakeLists.txt +++ b/tests/libgit2/CMakeLists.txt @@ -65,7 +65,7 @@ endif() include(AddClarTest) add_clar_test(libgit2_tests offline -v -xonline) -add_clar_test(libgit2_tests invasive -v -sfilter::stream::bigfile -sodb::largefiles -siterator::workdir::filesystem_gunk -srepo::init -srepo::init::at_filesystem_root) +add_clar_test(libgit2_tests invasive -v -sfilter::stream::bigfile -sodb::largefiles -siterator::workdir::filesystem_gunk -srepo::init -srepo::init::at_filesystem_root -sonline::clone::connect_timeout_default) add_clar_test(libgit2_tests online -v -sonline -xonline::customcert) add_clar_test(libgit2_tests online_customcert -v -sonline::customcert) add_clar_test(libgit2_tests gitdaemon -v -sonline::push) diff --git a/tests/libgit2/online/clone.c b/tests/libgit2/online/clone.c index b635739b676..92fa4d35133 100644 --- a/tests/libgit2/online/clone.c +++ b/tests/libgit2/online/clone.c @@ -35,6 +35,8 @@ static char *_remote_proxy_selfsigned = NULL; static char *_remote_expectcontinue = NULL; static char *_remote_redirect_initial = NULL; static char *_remote_redirect_subsequent = NULL; +static char *_remote_speed_timesout = NULL; +static char *_remote_speed_slow = NULL; static char *_github_ssh_pubkey = NULL; static char *_github_ssh_privkey = NULL; @@ -89,6 +91,8 @@ void test_online_clone__initialize(void) _remote_expectcontinue = cl_getenv("GITTEST_REMOTE_EXPECTCONTINUE"); _remote_redirect_initial = cl_getenv("GITTEST_REMOTE_REDIRECT_INITIAL"); _remote_redirect_subsequent = cl_getenv("GITTEST_REMOTE_REDIRECT_SUBSEQUENT"); + _remote_speed_timesout = cl_getenv("GITTEST_REMOTE_SPEED_TIMESOUT"); + _remote_speed_slow = cl_getenv("GITTEST_REMOTE_SPEED_SLOW"); _github_ssh_pubkey = cl_getenv("GITTEST_GITHUB_SSH_PUBKEY"); _github_ssh_privkey = cl_getenv("GITTEST_GITHUB_SSH_KEY"); @@ -128,6 +132,8 @@ void test_online_clone__cleanup(void) git__free(_remote_expectcontinue); git__free(_remote_redirect_initial); git__free(_remote_redirect_subsequent); + git__free(_remote_speed_timesout); + git__free(_remote_speed_slow); git__free(_github_ssh_pubkey); git__free(_github_ssh_privkey); @@ -145,6 +151,8 @@ void test_online_clone__cleanup(void) } git_libgit2_opts(GIT_OPT_SET_SSL_CERT_LOCATIONS, NULL, NULL); + git_libgit2_opts(GIT_OPT_SET_SERVER_TIMEOUT, 0); + git_libgit2_opts(GIT_OPT_SET_SERVER_CONNECT_TIMEOUT, 0); } void test_online_clone__network_full(void) @@ -1207,3 +1215,55 @@ void test_online_clone__sha256(void) git_reference_free(head); #endif } + +void test_online_clone__connect_timeout_configurable(void) +{ + uint64_t start, finish; + + start = git_time_monotonic(); + + cl_git_pass(git_libgit2_opts(GIT_OPT_SET_SERVER_CONNECT_TIMEOUT, 1)); + cl_git_fail(git_clone(&g_repo, "http://www.google.com:8000/", "./timedout", NULL)); + cl_assert(git_error_last() && strstr(git_error_last()->message, "timed out")); + + finish = git_time_monotonic(); + + cl_assert(finish - start < 1000); +} + +void test_online_clone__connect_timeout_default(void) +{ + /* This test takes ~ 75 seconds on Unix. */ + if (!cl_is_env_set("GITTEST_INVASIVE_SPEED")) + cl_skip(); + + /* + * Use a host/port pair that blackholes packets and does not + * send an RST. + */ + cl_git_fail_with(GIT_TIMEOUT, git_clone(&g_repo, "http://www.google.com:8000/", "./refused", NULL)); + cl_assert(git_error_last() && strstr(git_error_last()->message, "timed out")); +} + +void test_online_clone__timeout_configurable_times_out(void) +{ + git_repository *failed_repo; + + if (!_remote_speed_timesout) + cl_skip(); + + cl_git_pass(git_libgit2_opts(GIT_OPT_SET_SERVER_TIMEOUT, 1000)); + + cl_git_fail_with(GIT_TIMEOUT, git_clone(&failed_repo, _remote_speed_timesout, "./timedout", NULL)); + cl_assert(git_error_last() && strstr(git_error_last()->message, "timed out")); +} + +void test_online_clone__timeout_configurable_succeeds_slowly(void) +{ + if (!_remote_speed_slow) + cl_skip(); + + cl_git_pass(git_libgit2_opts(GIT_OPT_SET_SERVER_TIMEOUT, 1000)); + + cl_git_pass(git_clone(&g_repo, _remote_speed_slow, "./slow-but-successful", NULL)); +} From 94f98400bf950aa9835ff9b04c724f2aa3ebd0fc Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 12 May 2023 20:48:31 +0100 Subject: [PATCH 274/608] posix: introduce p_poll emulation with select Not all systems have poll(2); emulate it with select(2). --- src/CMakeLists.txt | 5 ++++ src/libgit2/streams/socket.c | 9 +++--- src/util/git2_features.h.in | 3 ++ src/util/posix.c | 54 ++++++++++++++++++++++++++++++++++++ src/util/posix.h | 19 +++++++++++++ 5 files changed, 85 insertions(+), 5 deletions(-) diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 88d616cec1f..a00ab600a2b 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -87,6 +87,11 @@ check_prototype_definition_safe(qsort_s check_function_exists(getentropy GIT_RAND_GETENTROPY) check_function_exists(getloadavg GIT_RAND_GETLOADAVG) +# poll + +check_symbol_exists(poll poll.h GIT_IO_POLL) +check_symbol_exists(select sys/select.h GIT_IO_SELECT) + # determine architecture of the machine if(CMAKE_SIZEOF_VOID_P EQUAL 8) diff --git a/src/libgit2/streams/socket.c b/src/libgit2/streams/socket.c index 0e0aa69349b..ecbdf7b7d6d 100644 --- a/src/libgit2/streams/socket.c +++ b/src/libgit2/streams/socket.c @@ -20,7 +20,6 @@ # include # include # include -# include #else # include # include @@ -135,13 +134,13 @@ static int connect_with_timeout( fd.events = POLLOUT; fd.revents = 0; - error = poll(&fd, 1, timeout); + error = p_poll(&fd, 1, timeout); if (error == 0) { return GIT_TIMEOUT; } else if (error != 1) { return -1; - } else if ((fd.revents & (POLLHUP | POLLERR))) { + } else if ((fd.revents & (POLLPRI | POLLHUP | POLLERR))) { return handle_sockerr(socket); } else if ((fd.revents & POLLOUT) != POLLOUT) { git_error_set(GIT_ERROR_NET, @@ -236,7 +235,7 @@ static ssize_t socket_write( fd.events = POLLOUT; fd.revents = 0; - ret = poll(&fd, 1, st->parent.timeout); + ret = p_poll(&fd, 1, st->parent.timeout); if (ret == 1) { ret = p_send(st->s, data, len, 0); @@ -272,7 +271,7 @@ static ssize_t socket_read( fd.events = POLLIN; fd.revents = 0; - ret = poll(&fd, 1, st->parent.timeout); + ret = p_poll(&fd, 1, st->parent.timeout); if (ret == 1) { ret = p_recv(st->s, data, len, 0); diff --git a/src/util/git2_features.h.in b/src/util/git2_features.h.in index 18644c3ccfc..cf955122c2b 100644 --- a/src/util/git2_features.h.in +++ b/src/util/git2_features.h.in @@ -61,4 +61,7 @@ #cmakedefine GIT_RAND_GETENTROPY 1 #cmakedefine GIT_RAND_GETLOADAVG 1 +#cmakedefine GIT_IO_POLL 1 +#cmakedefine GIT_IO_SELECT 1 + #endif diff --git a/src/util/posix.c b/src/util/posix.c index b1f85dc9412..cfc0e0751be 100644 --- a/src/util/posix.c +++ b/src/util/posix.c @@ -301,3 +301,57 @@ int p_munmap(git_map *map) } #endif + +#if defined(GIT_IO_POLL) || defined(GIT_IO_WSAPOLL) + +/* Handled by posix.h; this test simplifies the final else */ + +#elif defined(GIT_IO_SELECT) + +int p_poll(struct pollfd *fds, unsigned int nfds, int timeout_ms) +{ + fd_set read_fds, write_fds, except_fds; + struct timeval timeout = { 0, 0 }; + unsigned int i; + int max_fd = -1, ret; + + FD_ZERO(&read_fds); + FD_ZERO(&write_fds); + FD_ZERO(&except_fds); + + for (i = 0; i < nfds; i++) { + if ((fds[i].events & POLLIN)) + FD_SET(fds[i].fd, &read_fds); + + if ((fds[i].events & POLLOUT)) + FD_SET(fds[i].fd, &write_fds); + + if ((fds[i].events & POLLPRI)) + FD_SET(fds[i].fd, &except_fds); + + max_fd = MAX(max_fd, fds[i].fd); + } + + if (timeout_ms > 0) { + timeout.tv_sec = timeout_ms / 1000; + timeout.tv_usec = (timeout_ms % 1000) * 1000; + } + + if ((ret = select(max_fd + 1, &read_fds, &write_fds, &except_fds, + timeout_ms < 0 ? NULL : &timeout)) < 0) + goto done; + + for (i = 0; i < nfds; i++) { + fds[i].revents = 0 | + FD_ISSET(fds[i].fd, &read_fds) ? POLLIN : 0 | + FD_ISSET(fds[i].fd, &write_fds) ? POLLOUT : 0 | + FD_ISSET(fds[i].fd, &except_fds) ? POLLPRI : 0; + } + +done: + return ret; +} + +#else +# error no poll compatible implementation +#endif diff --git a/src/util/posix.h b/src/util/posix.h index 607aa9dceb3..f516bb3ccd1 100644 --- a/src/util/posix.h +++ b/src/util/posix.h @@ -195,4 +195,23 @@ extern const char *p_gai_strerror(int ret); # define p_gai_strerror(c) gai_strerror(c) #endif /* NO_ADDRINFO */ +#ifdef GIT_IO_POLL +# include +# define p_poll poll +#else +# define POLLIN 0x01 +# define POLLPRI 0x02 +# define POLLOUT 0x04 +# define POLLERR 0x08 +# define POLLHUP 0x10 + +struct pollfd { + int fd; + short events; + short revents; +}; + +extern int p_poll(struct pollfd *fds, unsigned int nfds, int timeout); +#endif + #endif From 9908c076ab3fafa18f00c866840819d52bc6b00f Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 12 May 2023 20:48:31 +0100 Subject: [PATCH 275/608] posix: use WSAPoll on win32 --- src/CMakeLists.txt | 8 ++++++-- src/util/git2_features.h.in | 1 + src/util/posix.h | 3 +++ 3 files changed, 10 insertions(+), 2 deletions(-) diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index a00ab600a2b..e9de94b52aa 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -89,8 +89,12 @@ check_function_exists(getloadavg GIT_RAND_GETLOADAVG) # poll -check_symbol_exists(poll poll.h GIT_IO_POLL) -check_symbol_exists(select sys/select.h GIT_IO_SELECT) +if(WIN32) + set(GIT_IO_WSAPOLL 1) +else() + check_symbol_exists(poll poll.h GIT_IO_POLL) + check_symbol_exists(select sys/select.h GIT_IO_SELECT) +endif() # determine architecture of the machine diff --git a/src/util/git2_features.h.in b/src/util/git2_features.h.in index cf955122c2b..a84ea895635 100644 --- a/src/util/git2_features.h.in +++ b/src/util/git2_features.h.in @@ -62,6 +62,7 @@ #cmakedefine GIT_RAND_GETLOADAVG 1 #cmakedefine GIT_IO_POLL 1 +#cmakedefine GIT_IO_WSAPOLL 1 #cmakedefine GIT_IO_SELECT 1 #endif diff --git a/src/util/posix.h b/src/util/posix.h index f516bb3ccd1..74707453a6d 100644 --- a/src/util/posix.h +++ b/src/util/posix.h @@ -198,6 +198,9 @@ extern const char *p_gai_strerror(int ret); #ifdef GIT_IO_POLL # include # define p_poll poll +#elif GIT_IO_WSAPOLL +# include +# define p_poll WSAPoll #else # define POLLIN 0x01 # define POLLPRI 0x02 From 02ab53ce051df9a6b70b8f075956ed3a41f9979e Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 12 May 2023 20:48:31 +0100 Subject: [PATCH 276/608] cmake: use `check_symbol_exists` for rand functions `check_symbol_exists` is superior to `check_function_exists`; use it consistently in our cmake configuration --- src/CMakeLists.txt | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index e9de94b52aa..8525acdd803 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -84,8 +84,8 @@ check_prototype_definition_safe(qsort_s # random / entropy data -check_function_exists(getentropy GIT_RAND_GETENTROPY) -check_function_exists(getloadavg GIT_RAND_GETLOADAVG) +check_symbol_exists(getentropy unistd.h GIT_RAND_GETENTROPY) +check_symbol_exists(getloadavg stdlib.h GIT_RAND_GETLOADAVG) # poll From 03eebab8a9fc353e96b2f6932d28defd5d868bca Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 12 May 2023 20:48:32 +0100 Subject: [PATCH 277/608] win32: getsockopt takes a `char *` instead of a `void *` Monsters. --- src/libgit2/streams/socket.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/libgit2/streams/socket.c b/src/libgit2/streams/socket.c index ecbdf7b7d6d..3bfc3fd0f95 100644 --- a/src/libgit2/streams/socket.c +++ b/src/libgit2/streams/socket.c @@ -103,7 +103,8 @@ static int handle_sockerr(GIT_SOCKET socket) int sockerr; socklen_t errlen = sizeof(sockerr); - if (getsockopt(socket, SOL_SOCKET, SO_ERROR, &sockerr, &errlen) < 0) + if (getsockopt(socket, SOL_SOCKET, SO_ERROR, + (void *)&sockerr, &errlen) < 0) return -1; if (sockerr == ETIMEDOUT) From 14c820b191a7083bf9a54792e09afcd83e0f0206 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Tue, 11 Apr 2023 20:55:22 +0100 Subject: [PATCH 278/608] win32: use WSAGetLastError to determine blocking --- src/libgit2/streams/socket.c | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-) diff --git a/src/libgit2/streams/socket.c b/src/libgit2/streams/socket.c index 3bfc3fd0f95..a463312fd85 100644 --- a/src/libgit2/streams/socket.c +++ b/src/libgit2/streams/socket.c @@ -114,6 +114,19 @@ static int handle_sockerr(GIT_SOCKET socket) return -1; } +GIT_INLINE(bool) connect_would_block(int error) +{ +#ifdef GIT_WIN32 + if (error == SOCKET_ERROR && WSAGetLastError() == WSAEWOULDBLOCK) + return true; +#endif + + if (error == -1 && errno == EINPROGRESS) + return true; + + return false; +} + static int connect_with_timeout( GIT_SOCKET socket, const struct sockaddr *address, @@ -128,7 +141,7 @@ static int connect_with_timeout( error = connect(socket, address, address_len); - if (error == 0 || (error == -1 && errno != EINPROGRESS)) + if (error == 0 || !connect_would_block(error)) return error; fd.fd = socket; From 8f695c806bac2b044f102c55b802e44f2d30ca01 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Tue, 11 Apr 2023 20:59:30 +0100 Subject: [PATCH 279/608] clone: skip timeout tests on WinHTTP --- tests/libgit2/online/clone.c | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/tests/libgit2/online/clone.c b/tests/libgit2/online/clone.c index 92fa4d35133..dbcac50ae6e 100644 --- a/tests/libgit2/online/clone.c +++ b/tests/libgit2/online/clone.c @@ -1218,6 +1218,9 @@ void test_online_clone__sha256(void) void test_online_clone__connect_timeout_configurable(void) { +#ifdef GIT_WINHTTP + cl_skip(); +#else uint64_t start, finish; start = git_time_monotonic(); @@ -1229,10 +1232,14 @@ void test_online_clone__connect_timeout_configurable(void) finish = git_time_monotonic(); cl_assert(finish - start < 1000); +#endif } void test_online_clone__connect_timeout_default(void) { +#ifdef GIT_WINHTTP + cl_skip(); +#else /* This test takes ~ 75 seconds on Unix. */ if (!cl_is_env_set("GITTEST_INVASIVE_SPEED")) cl_skip(); @@ -1243,10 +1250,14 @@ void test_online_clone__connect_timeout_default(void) */ cl_git_fail_with(GIT_TIMEOUT, git_clone(&g_repo, "http://www.google.com:8000/", "./refused", NULL)); cl_assert(git_error_last() && strstr(git_error_last()->message, "timed out")); +#endif } void test_online_clone__timeout_configurable_times_out(void) { +#ifdef GIT_WINHTTP + cl_skip(); +#else git_repository *failed_repo; if (!_remote_speed_timesout) @@ -1256,14 +1267,19 @@ void test_online_clone__timeout_configurable_times_out(void) cl_git_fail_with(GIT_TIMEOUT, git_clone(&failed_repo, _remote_speed_timesout, "./timedout", NULL)); cl_assert(git_error_last() && strstr(git_error_last()->message, "timed out")); +#endif } void test_online_clone__timeout_configurable_succeeds_slowly(void) { +#ifdef GIT_WINHTTP + cl_skip(); +#else if (!_remote_speed_slow) cl_skip(); cl_git_pass(git_libgit2_opts(GIT_OPT_SET_SERVER_TIMEOUT, 1000)); cl_git_pass(git_clone(&g_repo, _remote_speed_slow, "./slow-but-successful", NULL)); +#endif } From 9dd1bfe81c3aba6ce35ed85bf62fa75d9c61e1a6 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sun, 14 May 2023 14:07:59 +0100 Subject: [PATCH 280/608] alloc: simplify pluggable allocators Remove the number of functions that custom allocator users need to provide; nobody should need to implement `substrdup`. Keep it to the basics that are actually _needed_ for allocation (malloc, realloc, free) and reimplement the rest ourselves. In addition, move the failure check and error setting _out_ of the custom allocators and into a wrapper so that users don't need to deal with this. This also allows us to call our allocator (without the wrapper) early so that it does not try to set an error on failure, which may be important for bootstrapping. --- include/git2/sys/alloc.h | 34 -------- src/util/alloc.c | 71 +++++++++++++++-- src/util/alloc.h | 43 ++++++++--- src/util/allocators/failalloc.c | 60 --------------- src/util/allocators/failalloc.h | 6 -- src/util/allocators/stdalloc.c | 107 +------------------------- src/util/allocators/win32_leakcheck.c | 68 ---------------- 7 files changed, 101 insertions(+), 288 deletions(-) diff --git a/include/git2/sys/alloc.h b/include/git2/sys/alloc.h index c295807bcf2..e7f85b890c8 100644 --- a/include/git2/sys/alloc.h +++ b/include/git2/sys/alloc.h @@ -24,28 +24,6 @@ typedef struct { /** Allocate `n` bytes of memory */ void * GIT_CALLBACK(gmalloc)(size_t n, const char *file, int line); - /** - * Allocate memory for an array of `nelem` elements, where each element - * has a size of `elsize`. Returned memory shall be initialized to - * all-zeroes - */ - void * GIT_CALLBACK(gcalloc)(size_t nelem, size_t elsize, const char *file, int line); - - /** Allocate memory for the string `str` and duplicate its contents. */ - char * GIT_CALLBACK(gstrdup)(const char *str, const char *file, int line); - - /** - * Equivalent to the `gstrdup` function, but only duplicating at most - * `n + 1` bytes - */ - char * GIT_CALLBACK(gstrndup)(const char *str, size_t n, const char *file, int line); - - /** - * Equivalent to `gstrndup`, but will always duplicate exactly `n` bytes - * of `str`. Thus, out of bounds reads at `str` may happen. - */ - char * GIT_CALLBACK(gsubstrdup)(const char *str, size_t n, const char *file, int line); - /** * This function shall deallocate the old object `ptr` and return a * pointer to a new object that has the size specified by `size`. In @@ -53,18 +31,6 @@ typedef struct { */ void * GIT_CALLBACK(grealloc)(void *ptr, size_t size, const char *file, int line); - /** - * This function shall be equivalent to `grealloc`, but allocating - * `neleme * elsize` bytes. - */ - void * GIT_CALLBACK(greallocarray)(void *ptr, size_t nelem, size_t elsize, const char *file, int line); - - /** - * This function shall allocate a new array of `nelem` elements, where - * each element has a size of `elsize` bytes. - */ - void * GIT_CALLBACK(gmallocarray)(size_t nelem, size_t elsize, const char *file, int line); - /** * This function shall free the memory pointed to by `ptr`. In case * `ptr` is `NULL`, this shall be a no-op. diff --git a/src/util/alloc.c b/src/util/alloc.c index 2820d84a219..6ec173d04a4 100644 --- a/src/util/alloc.c +++ b/src/util/alloc.c @@ -15,16 +15,75 @@ /* Fail any allocation until git_libgit2_init is called. */ git_allocator git__allocator = { git_failalloc_malloc, - git_failalloc_calloc, - git_failalloc_strdup, - git_failalloc_strndup, - git_failalloc_substrdup, git_failalloc_realloc, - git_failalloc_reallocarray, - git_failalloc_mallocarray, git_failalloc_free }; +void *git__calloc(size_t nelem, size_t elsize) +{ + size_t newsize; + void *ptr; + + if (GIT_MULTIPLY_SIZET_OVERFLOW(&newsize, nelem, elsize)) + return NULL; + + if ((ptr = git__malloc(newsize))) + memset(ptr, 0, newsize); + + return ptr; +} + +void *git__reallocarray(void *ptr, size_t nelem, size_t elsize) +{ + size_t newsize; + + if (GIT_MULTIPLY_SIZET_OVERFLOW(&newsize, nelem, elsize)) + return NULL; + + return git__realloc(ptr, newsize); +} + +void *git__mallocarray(size_t nelem, size_t elsize) +{ + return git__reallocarray(NULL, nelem, elsize); +} + +char *git__strdup(const char *str) +{ + size_t len = strlen(str) + 1; + void *ptr = git__malloc(len); + + if (ptr) + memcpy(ptr, str, len); + + return ptr; +} + +char *git__strndup(const char *str, size_t n) +{ + size_t len = p_strnlen(str, n); + char *ptr = git__malloc(len + 1); + + if (ptr) { + memcpy(ptr, str, len); + ptr[len] = '\0'; + } + + return ptr; +} + +char *git__substrdup(const char *str, size_t n) +{ + char *ptr = git__malloc(n + 1); + + if (ptr) { + memcpy(ptr, str, n); + ptr[n] = '\0'; + } + + return ptr; +} + static int setup_default_allocator(void) { #if defined(GIT_WIN32_LEAKCHECK) diff --git a/src/util/alloc.h b/src/util/alloc.h index 04fb7e10175..32b614b25cc 100644 --- a/src/util/alloc.h +++ b/src/util/alloc.h @@ -10,17 +10,42 @@ #include "git2/sys/alloc.h" +#include "git2_util.h" + extern git_allocator git__allocator; -#define git__malloc(len) git__allocator.gmalloc(len, __FILE__, __LINE__) -#define git__calloc(nelem, elsize) git__allocator.gcalloc(nelem, elsize, __FILE__, __LINE__) -#define git__strdup(str) git__allocator.gstrdup(str, __FILE__, __LINE__) -#define git__strndup(str, n) git__allocator.gstrndup(str, n, __FILE__, __LINE__) -#define git__substrdup(str, n) git__allocator.gsubstrdup(str, n, __FILE__, __LINE__) -#define git__realloc(ptr, size) git__allocator.grealloc(ptr, size, __FILE__, __LINE__) -#define git__reallocarray(ptr, nelem, elsize) git__allocator.greallocarray(ptr, nelem, elsize, __FILE__, __LINE__) -#define git__mallocarray(nelem, elsize) git__allocator.gmallocarray(nelem, elsize, __FILE__, __LINE__) -#define git__free git__allocator.gfree +GIT_INLINE(void *) git__malloc(size_t len) +{ + void *p = git__allocator.gmalloc(len, __FILE__, __LINE__); + + if (!p) + git_error_set_oom(); + + return p; +} + +GIT_INLINE(void *) git__realloc(void *ptr, size_t size) +{ + void *p = git__allocator.grealloc(ptr, size, __FILE__, __LINE__); + + if (!p) + git_error_set_oom(); + + return p; +} + +GIT_INLINE(void) git__free(void *ptr) +{ + git__allocator.gfree(ptr); +} + +extern void *git__calloc(size_t nelem, size_t elsize); +extern void *git__mallocarray(size_t nelem, size_t elsize); +extern void *git__reallocarray(void *ptr, size_t nelem, size_t elsize); + +extern char *git__strdup(const char *str); +extern char *git__strndup(const char *str, size_t n); +extern char *git__substrdup(const char *str, size_t n); /** * This function is being called by our global setup routines to diff --git a/src/util/allocators/failalloc.c b/src/util/allocators/failalloc.c index 5257d1dece0..c1025e32fef 100644 --- a/src/util/allocators/failalloc.c +++ b/src/util/allocators/failalloc.c @@ -16,45 +16,6 @@ void *git_failalloc_malloc(size_t len, const char *file, int line) return NULL; } -void *git_failalloc_calloc(size_t nelem, size_t elsize, const char *file, int line) -{ - GIT_UNUSED(nelem); - GIT_UNUSED(elsize); - GIT_UNUSED(file); - GIT_UNUSED(line); - - return NULL; -} - -char *git_failalloc_strdup(const char *str, const char *file, int line) -{ - GIT_UNUSED(str); - GIT_UNUSED(file); - GIT_UNUSED(line); - - return NULL; -} - -char *git_failalloc_strndup(const char *str, size_t n, const char *file, int line) -{ - GIT_UNUSED(str); - GIT_UNUSED(n); - GIT_UNUSED(file); - GIT_UNUSED(line); - - return NULL; -} - -char *git_failalloc_substrdup(const char *start, size_t n, const char *file, int line) -{ - GIT_UNUSED(start); - GIT_UNUSED(n); - GIT_UNUSED(file); - GIT_UNUSED(line); - - return NULL; -} - void *git_failalloc_realloc(void *ptr, size_t size, const char *file, int line) { GIT_UNUSED(ptr); @@ -65,27 +26,6 @@ void *git_failalloc_realloc(void *ptr, size_t size, const char *file, int line) return NULL; } -void *git_failalloc_reallocarray(void *ptr, size_t nelem, size_t elsize, const char *file, int line) -{ - GIT_UNUSED(ptr); - GIT_UNUSED(nelem); - GIT_UNUSED(elsize); - GIT_UNUSED(file); - GIT_UNUSED(line); - - return NULL; -} - -void *git_failalloc_mallocarray(size_t nelem, size_t elsize, const char *file, int line) -{ - GIT_UNUSED(nelem); - GIT_UNUSED(elsize); - GIT_UNUSED(file); - GIT_UNUSED(line); - - return NULL; -} - void git_failalloc_free(void *ptr) { GIT_UNUSED(ptr); diff --git a/src/util/allocators/failalloc.h b/src/util/allocators/failalloc.h index 91264a0bb91..a3788e634ee 100644 --- a/src/util/allocators/failalloc.h +++ b/src/util/allocators/failalloc.h @@ -11,13 +11,7 @@ #include "git2_util.h" extern void *git_failalloc_malloc(size_t len, const char *file, int line); -extern void *git_failalloc_calloc(size_t nelem, size_t elsize, const char *file, int line); -extern char *git_failalloc_strdup(const char *str, const char *file, int line); -extern char *git_failalloc_strndup(const char *str, size_t n, const char *file, int line); -extern char *git_failalloc_substrdup(const char *start, size_t n, const char *file, int line); extern void *git_failalloc_realloc(void *ptr, size_t size, const char *file, int line); -extern void *git_failalloc_reallocarray(void *ptr, size_t nelem, size_t elsize, const char *file, int line); -extern void *git_failalloc_mallocarray(size_t nelem, size_t elsize, const char *file, int line); extern void git_failalloc_free(void *ptr); #endif diff --git a/src/util/allocators/stdalloc.c b/src/util/allocators/stdalloc.c index 2b36d9f3df3..f2d72a7e6c9 100644 --- a/src/util/allocators/stdalloc.c +++ b/src/util/allocators/stdalloc.c @@ -9,8 +9,6 @@ static void *stdalloc__malloc(size_t len, const char *file, int line) { - void *ptr; - GIT_UNUSED(file); GIT_UNUSED(line); @@ -19,86 +17,11 @@ static void *stdalloc__malloc(size_t len, const char *file, int line) return NULL; #endif - ptr = malloc(len); - - if (!ptr) - git_error_set_oom(); - - return ptr; -} - -static void *stdalloc__calloc(size_t nelem, size_t elsize, const char *file, int line) -{ - void *ptr; - - GIT_UNUSED(file); - GIT_UNUSED(line); - -#ifdef GIT_DEBUG_STRICT_ALLOC - if (!elsize || !nelem) - return NULL; -#endif - - ptr = calloc(nelem, elsize); - - if (!ptr) - git_error_set_oom(); - - return ptr; -} - -static char *stdalloc__strdup(const char *str, const char *file, int line) -{ - char *ptr; - - GIT_UNUSED(file); - GIT_UNUSED(line); - - ptr = strdup(str); - - if (!ptr) - git_error_set_oom(); - - return ptr; -} - -static char *stdalloc__strndup(const char *str, size_t n, const char *file, int line) -{ - size_t length = 0, alloclength; - char *ptr; - - length = p_strnlen(str, n); - - if (GIT_ADD_SIZET_OVERFLOW(&alloclength, length, 1) || - !(ptr = stdalloc__malloc(alloclength, file, line))) - return NULL; - - if (length) - memcpy(ptr, str, length); - - ptr[length] = '\0'; - - return ptr; -} - -static char *stdalloc__substrdup(const char *start, size_t n, const char *file, int line) -{ - char *ptr; - size_t alloclen; - - if (GIT_ADD_SIZET_OVERFLOW(&alloclen, n, 1) || - !(ptr = stdalloc__malloc(alloclen, file, line))) - return NULL; - - memcpy(ptr, start, n); - ptr[n] = '\0'; - return ptr; + return malloc(len); } static void *stdalloc__realloc(void *ptr, size_t size, const char *file, int line) { - void *new_ptr; - GIT_UNUSED(file); GIT_UNUSED(line); @@ -107,27 +30,7 @@ static void *stdalloc__realloc(void *ptr, size_t size, const char *file, int lin return NULL; #endif - new_ptr = realloc(ptr, size); - - if (!new_ptr) - git_error_set_oom(); - - return new_ptr; -} - -static void *stdalloc__reallocarray(void *ptr, size_t nelem, size_t elsize, const char *file, int line) -{ - size_t newsize; - - if (GIT_MULTIPLY_SIZET_OVERFLOW(&newsize, nelem, elsize)) - return NULL; - - return stdalloc__realloc(ptr, newsize, file, line); -} - -static void *stdalloc__mallocarray(size_t nelem, size_t elsize, const char *file, int line) -{ - return stdalloc__reallocarray(NULL, nelem, elsize, file, line); + return realloc(ptr, size); } static void stdalloc__free(void *ptr) @@ -138,13 +41,7 @@ static void stdalloc__free(void *ptr) int git_stdalloc_init_allocator(git_allocator *allocator) { allocator->gmalloc = stdalloc__malloc; - allocator->gcalloc = stdalloc__calloc; - allocator->gstrdup = stdalloc__strdup; - allocator->gstrndup = stdalloc__strndup; - allocator->gsubstrdup = stdalloc__substrdup; allocator->grealloc = stdalloc__realloc; - allocator->greallocarray = stdalloc__reallocarray; - allocator->gmallocarray = stdalloc__mallocarray; allocator->gfree = stdalloc__free; return 0; } diff --git a/src/util/allocators/win32_leakcheck.c b/src/util/allocators/win32_leakcheck.c index fe06a14af73..cdf16d34880 100644 --- a/src/util/allocators/win32_leakcheck.c +++ b/src/util/allocators/win32_leakcheck.c @@ -18,53 +18,6 @@ static void *leakcheck_malloc(size_t len, const char *file, int line) return ptr; } -static void *leakcheck_calloc(size_t nelem, size_t elsize, const char *file, int line) -{ - void *ptr = _calloc_dbg(nelem, elsize, _NORMAL_BLOCK, git_win32_leakcheck_stacktrace(1,file), line); - if (!ptr) git_error_set_oom(); - return ptr; -} - -static char *leakcheck_strdup(const char *str, const char *file, int line) -{ - char *ptr = _strdup_dbg(str, _NORMAL_BLOCK, git_win32_leakcheck_stacktrace(1,file), line); - if (!ptr) git_error_set_oom(); - return ptr; -} - -static char *leakcheck_strndup(const char *str, size_t n, const char *file, int line) -{ - size_t length = 0, alloclength; - char *ptr; - - length = p_strnlen(str, n); - - if (GIT_ADD_SIZET_OVERFLOW(&alloclength, length, 1) || - !(ptr = leakcheck_malloc(alloclength, file, line))) - return NULL; - - if (length) - memcpy(ptr, str, length); - - ptr[length] = '\0'; - - return ptr; -} - -static char *leakcheck_substrdup(const char *start, size_t n, const char *file, int line) -{ - char *ptr; - size_t alloclen; - - if (GIT_ADD_SIZET_OVERFLOW(&alloclen, n, 1) || - !(ptr = leakcheck_malloc(alloclen, file, line))) - return NULL; - - memcpy(ptr, start, n); - ptr[n] = '\0'; - return ptr; -} - static void *leakcheck_realloc(void *ptr, size_t size, const char *file, int line) { void *new_ptr = _realloc_dbg(ptr, size, _NORMAL_BLOCK, git_win32_leakcheck_stacktrace(1,file), line); @@ -72,21 +25,6 @@ static void *leakcheck_realloc(void *ptr, size_t size, const char *file, int lin return new_ptr; } -static void *leakcheck_reallocarray(void *ptr, size_t nelem, size_t elsize, const char *file, int line) -{ - size_t newsize; - - if (GIT_MULTIPLY_SIZET_OVERFLOW(&newsize, nelem, elsize)) - return NULL; - - return leakcheck_realloc(ptr, newsize, file, line); -} - -static void *leakcheck_mallocarray(size_t nelem, size_t elsize, const char *file, int line) -{ - return leakcheck_reallocarray(NULL, nelem, elsize, file, line); -} - static void leakcheck_free(void *ptr) { free(ptr); @@ -95,13 +33,7 @@ static void leakcheck_free(void *ptr) int git_win32_leakcheck_init_allocator(git_allocator *allocator) { allocator->gmalloc = leakcheck_malloc; - allocator->gcalloc = leakcheck_calloc; - allocator->gstrdup = leakcheck_strdup; - allocator->gstrndup = leakcheck_strndup; - allocator->gsubstrdup = leakcheck_substrdup; allocator->grealloc = leakcheck_realloc; - allocator->greallocarray = leakcheck_reallocarray; - allocator->gmallocarray = leakcheck_mallocarray; allocator->gfree = leakcheck_free; return 0; } From 90cc07711c43b12a4bb270583026cbc71db3823e Mon Sep 17 00:00:00 2001 From: Patrick Steinhardt Date: Fri, 11 Oct 2019 10:57:28 +0200 Subject: [PATCH 281/608] tests: add allocator with limited number of bytes In several circumstances, we get bug reports about things that happen in situations where the environment is quite limited with regards to available memory. While it's expected that functionality will fail if memory allocations fail, the assumption is that we should do so in a controlled way. Most importantly, we do not want to crash hard due to e.g. accessing NULL pointers. Naturally, it is quite hard to debug such situations. But since our addition of pluggable allocators, we are able to implement allocators that fail in deterministic ways, e.g. after a certain amount of bytes has been allocated. This commit does exactly that. To be able to properly keep track of the amount of bytes currently allocated, allocated pointers contain tracking information. This tracking information is currently limited to the number of bytes allocated, so that we can correctly replenish them on calling `free` on the pointer. In the future, it would be feasible to extend the tracked information even further, e.g. by adding information about file and line where the allocation has been performed. As this introduced some overhead to allocations though, only information essential to limited allocations is currently tracked. --- src/libgit2/threadstate.c | 17 ++++- tests/clar/clar_libgit2_alloc.c | 106 ++++++++++++++++++++++++++++++++ tests/clar/clar_libgit2_alloc.h | 11 ++++ tests/util/alloc.c | 68 ++++++++++++++++++++ 4 files changed, 200 insertions(+), 2 deletions(-) create mode 100644 tests/clar/clar_libgit2_alloc.c create mode 100644 tests/clar/clar_libgit2_alloc.h create mode 100644 tests/util/alloc.c diff --git a/src/libgit2/threadstate.c b/src/libgit2/threadstate.c index 9e3ef581849..ed9bb9b96ff 100644 --- a/src/libgit2/threadstate.c +++ b/src/libgit2/threadstate.c @@ -75,10 +75,23 @@ git_threadstate *git_threadstate_get(void) if ((threadstate = git_tlsdata_get(tls_key)) != NULL) return threadstate; - if ((threadstate = git__calloc(1, sizeof(git_threadstate))) == NULL || - git_str_init(&threadstate->error_buf, 0) < 0) + /* + * Avoid git__malloc here, since if it fails, it sets an error + * message, which requires thread state, which would allocate + * here, which would fail, which would set an error message... + */ + + if ((threadstate = git__allocator.gmalloc(sizeof(git_threadstate), + __FILE__, __LINE__)) == NULL) return NULL; + memset(threadstate, 0, sizeof(git_threadstate)); + + if (git_str_init(&threadstate->error_buf, 0) < 0) { + git__allocator.gfree(threadstate); + return NULL; + } + git_tlsdata_set(tls_key, threadstate); return threadstate; } diff --git a/tests/clar/clar_libgit2_alloc.c b/tests/clar/clar_libgit2_alloc.c new file mode 100644 index 00000000000..7abc998cea0 --- /dev/null +++ b/tests/clar/clar_libgit2_alloc.c @@ -0,0 +1,106 @@ +/* + * Copyright (C) the libgit2 contributors. All rights reserved. + * + * This file is part of libgit2, distributed under the GNU GPL v2 with + * a Linking Exception. For full terms see the included COPYING file. + */ + +#include "clar_libgit2_alloc.h" + +static size_t bytes_available; + +/* + * The clar allocator uses a tagging mechanism for pointers that + * prepends the actual pointer's number bytes as `size_t`. + * + * First, this is required in order to be able to implement + * proper bookkeeping of allocated bytes in both `free` and + * `realloc`. + * + * Second, it may also be able to spot bugs that are + * otherwise hard to grasp, as the returned pointer cannot be + * free'd directly via free(3P). Instead, one is forced to use + * the tandem of `cl__malloc` and `cl__free`, as otherwise the + * code is going to crash hard. This is considered to be a + * feature, as it helps e.g. in finding cases where by accident + * malloc(3P) and free(3P) were used instead of git__malloc and + * git__free, respectively. + * + * The downside is obviously that each allocation grows by + * sizeof(size_t) bytes. As the allocator is for testing purposes + * only, this tradeoff is considered to be perfectly fine, + * though. + */ + +static void *cl__malloc(size_t len, const char *file, int line) +{ + char *ptr = NULL; + size_t alloclen; + + GIT_UNUSED(file); + GIT_UNUSED(line); + + if (len > bytes_available) + goto out; + + if (GIT_ADD_SIZET_OVERFLOW(&alloclen, len, sizeof(size_t)) || + (ptr = malloc(alloclen)) == NULL) + goto out; + memcpy(ptr, &len, sizeof(size_t)); + + bytes_available -= len; + +out: + return ptr ? ptr + sizeof(size_t) : NULL; +} + +static void cl__free(void *ptr) +{ + if (ptr) { + char *p = ptr; + size_t len; + memcpy(&len, p - sizeof(size_t), sizeof(size_t)); + free(p - sizeof(size_t)); + bytes_available += len; + } +} + +static void *cl__realloc(void *ptr, size_t size, const char *file, int line) +{ + size_t copybytes = 0; + char *p = ptr; + void *new; + + if (p) + memcpy(©bytes, p - sizeof(size_t), sizeof(size_t)); + if (copybytes > size) + copybytes = size; + + if ((new = cl__malloc(size, file, line)) == NULL) + goto out; + memcpy(new, p, copybytes); + cl__free(p); + +out: + return new; +} + +void cl_alloc_limit(size_t bytes) +{ + git_allocator alloc; + + alloc.gmalloc = cl__malloc; + alloc.grealloc = cl__realloc; + alloc.gfree = cl__free; + + git_allocator_setup(&alloc); + + bytes_available = bytes; +} + +void cl_alloc_reset(void) +{ + git_allocator stdalloc; + git_stdalloc_init_allocator(&stdalloc); + git_allocator_setup(&stdalloc); +} diff --git a/tests/clar/clar_libgit2_alloc.h b/tests/clar/clar_libgit2_alloc.h new file mode 100644 index 00000000000..78a18b67d16 --- /dev/null +++ b/tests/clar/clar_libgit2_alloc.h @@ -0,0 +1,11 @@ +#ifndef __CLAR_LIBGIT2_ALLOC__ +#define __CLAR_LIBGIT2_ALLOC__ + +#include "clar.h" +#include "common.h" +#include "git2/sys/alloc.h" + +void cl_alloc_limit(size_t bytes); +void cl_alloc_reset(void); + +#endif diff --git a/tests/util/alloc.c b/tests/util/alloc.c new file mode 100644 index 00000000000..492394a52c0 --- /dev/null +++ b/tests/util/alloc.c @@ -0,0 +1,68 @@ +#include "clar_libgit2.h" +#include "clar_libgit2_alloc.h" +#include "alloc.h" + +void test_alloc__cleanup(void) +{ + cl_alloc_reset(); +} + +void test_alloc__oom(void) +{ + void *ptr = NULL; + + cl_alloc_limit(0); + + cl_assert(git__malloc(1) == NULL); + cl_assert(git__calloc(1, 1) == NULL); + cl_assert(git__realloc(ptr, 1) == NULL); + cl_assert(git__strdup("test") == NULL); + cl_assert(git__strndup("test", 4) == NULL); +} + +void test_alloc__single_byte_is_exhausted(void) +{ + void *ptr; + + cl_alloc_limit(1); + + cl_assert(ptr = git__malloc(1)); + cl_assert(git__malloc(1) == NULL); + git__free(ptr); +} + +void test_alloc__free_replenishes_byte(void) +{ + void *ptr; + + cl_alloc_limit(1); + + cl_assert(ptr = git__malloc(1)); + cl_assert(git__malloc(1) == NULL); + git__free(ptr); + cl_assert(ptr = git__malloc(1)); + git__free(ptr); +} + +void test_alloc__realloc(void) +{ + char *ptr = NULL; + + cl_alloc_limit(3); + + cl_assert(ptr = git__realloc(ptr, 1)); + *ptr = 'x'; + + cl_assert(ptr = git__realloc(ptr, 1)); + cl_assert_equal_i(*ptr, 'x'); + + cl_assert(ptr = git__realloc(ptr, 2)); + cl_assert_equal_i(*ptr, 'x'); + + cl_assert(git__realloc(ptr, 2) == NULL); + + cl_assert(ptr = git__realloc(ptr, 1)); + cl_assert_equal_i(*ptr, 'x'); + + git__free(ptr); +} From 8e5281c88b860cce7a6a2f4a00c28b6fb00720b0 Mon Sep 17 00:00:00 2001 From: Patrick Steinhardt Date: Fri, 11 Oct 2019 11:38:14 +0200 Subject: [PATCH 282/608] tests: add allocation failure test for buffers Test that `git_buf` correctly fails if no more bytes can be allocated. This is mostly for demonstration purposes. --- tests/util/str/oom.c | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/tests/util/str/oom.c b/tests/util/str/oom.c index dd3796674f6..810c1f25a7a 100644 --- a/tests/util/str/oom.c +++ b/tests/util/str/oom.c @@ -1,4 +1,5 @@ #include "clar_libgit2.h" +#include "clar_libgit2_alloc.h" /* Override default allocators with ones that will fail predictably. */ @@ -56,3 +57,15 @@ void test_str_oom__grow_by(void) cl_assert(git_str_grow_by(&buf, 101) == -1); cl_assert(git_str_oom(&buf)); } + +void test_str_oom__allocation_failure(void) +{ + git_str buf = GIT_STR_INIT; + + cl_alloc_limit(10); + + cl_git_pass(git_str_puts(&buf, "foobar")); + cl_git_fail(git_str_puts(&buf, "foobar")); + + cl_alloc_reset(); +} From 27576416206f696edb16cf2e22271953903e731f Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 15 May 2023 11:04:37 +0100 Subject: [PATCH 283/608] tests: only copy when `ptr` is non-NULL Avoid passing a `NULL` ptr to `memcpy` -- that's UB (even if size is 0) --- tests/clar/clar_libgit2_alloc.c | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/tests/clar/clar_libgit2_alloc.c b/tests/clar/clar_libgit2_alloc.c index 7abc998cea0..e9303792382 100644 --- a/tests/clar/clar_libgit2_alloc.c +++ b/tests/clar/clar_libgit2_alloc.c @@ -73,13 +73,17 @@ static void *cl__realloc(void *ptr, size_t size, const char *file, int line) if (p) memcpy(©bytes, p - sizeof(size_t), sizeof(size_t)); + if (copybytes > size) copybytes = size; if ((new = cl__malloc(size, file, line)) == NULL) goto out; - memcpy(new, p, copybytes); - cl__free(p); + + if (p) { + memcpy(new, p, copybytes); + cl__free(p); + } out: return new; From 0fd80681f90ae23d5a74b469fefd3409d924ddae Mon Sep 17 00:00:00 2001 From: Reginald McLean Date: Tue, 24 Nov 2020 18:32:50 -0500 Subject: [PATCH 284/608] Added missing is_prunable test --- tests/libgit2/worktree/worktree.c | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/tests/libgit2/worktree/worktree.c b/tests/libgit2/worktree/worktree.c index 9fd27f49c5f..fed5c9259ca 100644 --- a/tests/libgit2/worktree/worktree.c +++ b/tests/libgit2/worktree/worktree.c @@ -645,3 +645,16 @@ void test_worktree_worktree__validate_invalid_worktreedir(void) git_worktree_free(wt); } + +void test_worktree_worktree__is_prunable_missing_repo(void) +{ + git_worktree *wt; + + cl_git_pass(git_worktree_lookup(&wt, fixture.repo, "testrepo-worktree")); + p_rename("testrepo", "testrepo-tmp"); + /* Should not be prunable since the repository moved */ + cl_assert(!git_worktree_is_prunable(wt, NULL)); + p_rename("testrepo-tmp", "testrepo"); + + git_worktree_free(wt); +} From 86db1ad5dc9d878f463ac6c9d5ee412b62b74340 Mon Sep 17 00:00:00 2001 From: Reginald McLean Date: Tue, 24 Nov 2020 18:45:55 -0500 Subject: [PATCH 285/608] Added check if gitdir exists in is_prunable() Fixes #5598 --- src/libgit2/worktree.c | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/src/libgit2/worktree.c b/src/libgit2/worktree.c index 82e1d2d7e18..a8460380ff9 100644 --- a/src/libgit2/worktree.c +++ b/src/libgit2/worktree.c @@ -565,6 +565,7 @@ int git_worktree_is_prunable(git_worktree *wt, git_worktree_prune_options *opts) { git_worktree_prune_options popts = GIT_WORKTREE_PRUNE_OPTIONS_INIT; + git_buf path = GIT_BUF_INIT; GIT_ERROR_CHECK_VERSION( opts, GIT_WORKTREE_PRUNE_OPTIONS_VERSION, @@ -595,6 +596,14 @@ int git_worktree_is_prunable(git_worktree *wt, return 0; } + if (git_buf_printf(&path, "%s/worktrees/%s", wt->commondir_path, wt->name) < 0) + return 0; + if (!git_path_exists(path.ptr)) + { + git_error_set(GIT_ERROR_WORKTREE, "worktree gitdir '%s' does not exist", path.ptr); + return 0; + } + return 1; } From 05719c55ff6a8780d7d3b5ae5c55d81f981fe7b3 Mon Sep 17 00:00:00 2001 From: Reginald McLean Date: Tue, 24 Nov 2020 19:42:54 -0500 Subject: [PATCH 286/608] Refactor git_worktree_is_prunable slightly to fix memory leak --- src/libgit2/worktree.c | 26 ++++++++++++++++---------- 1 file changed, 16 insertions(+), 10 deletions(-) diff --git a/src/libgit2/worktree.c b/src/libgit2/worktree.c index a8460380ff9..702b7b774f8 100644 --- a/src/libgit2/worktree.c +++ b/src/libgit2/worktree.c @@ -566,6 +566,7 @@ int git_worktree_is_prunable(git_worktree *wt, { git_worktree_prune_options popts = GIT_WORKTREE_PRUNE_OPTIONS_INIT; git_buf path = GIT_BUF_INIT; + int ret = 0; GIT_ERROR_CHECK_VERSION( opts, GIT_WORKTREE_PRUNE_OPTIONS_VERSION, @@ -576,35 +577,40 @@ int git_worktree_is_prunable(git_worktree *wt, if ((popts.flags & GIT_WORKTREE_PRUNE_LOCKED) == 0) { git_str reason = GIT_STR_INIT; - int error; - if ((error = git_worktree__is_locked(&reason, wt)) < 0) - return error; + if ((ret = git_worktree_is_locked(&reason, wt)) < 0) + goto out; - if (error) { + if (ret) { if (!reason.size) git_str_attach_notowned(&reason, "no reason given", 15); git_error_set(GIT_ERROR_WORKTREE, "not pruning locked working tree: '%s'", reason.ptr); git_str_dispose(&reason); - return 0; + ret = 0; + goto out; } } if ((popts.flags & GIT_WORKTREE_PRUNE_VALID) == 0 && git_worktree_validate(wt) == 0) { git_error_set(GIT_ERROR_WORKTREE, "not pruning valid working tree"); - return 0; + goto out; } - if (git_buf_printf(&path, "%s/worktrees/%s", wt->commondir_path, wt->name) < 0) - return 0; + if ((ret = git_buf_printf(&path, "%s/worktrees/%s", wt->commondir_path, wt->name) < 0)) + goto out; if (!git_path_exists(path.ptr)) { git_error_set(GIT_ERROR_WORKTREE, "worktree gitdir '%s' does not exist", path.ptr); - return 0; + goto out; } - return 1; + ret = 1; + +out: + + git_buf_dispose(&path); + return ret; } int git_worktree_prune(git_worktree *wt, From 372143244dc82551eccb0503ef58d9850d530346 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Tue, 16 May 2023 12:38:24 +0100 Subject: [PATCH 287/608] worktree: update prunable to reflect refactorings PR #5712 predates several refactorings to move the utility code into a more general purpose codebase. Update to reflect the refactorings. --- src/libgit2/worktree.c | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/src/libgit2/worktree.c b/src/libgit2/worktree.c index 702b7b774f8..a878634ca84 100644 --- a/src/libgit2/worktree.c +++ b/src/libgit2/worktree.c @@ -565,7 +565,7 @@ int git_worktree_is_prunable(git_worktree *wt, git_worktree_prune_options *opts) { git_worktree_prune_options popts = GIT_WORKTREE_PRUNE_OPTIONS_INIT; - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; int ret = 0; GIT_ERROR_CHECK_VERSION( @@ -578,13 +578,14 @@ int git_worktree_is_prunable(git_worktree *wt, if ((popts.flags & GIT_WORKTREE_PRUNE_LOCKED) == 0) { git_str reason = GIT_STR_INIT; - if ((ret = git_worktree_is_locked(&reason, wt)) < 0) + if ((ret = git_worktree__is_locked(&reason, wt)) < 0) goto out; if (ret) { - if (!reason.size) - git_str_attach_notowned(&reason, "no reason given", 15); - git_error_set(GIT_ERROR_WORKTREE, "not pruning locked working tree: '%s'", reason.ptr); + git_error_set(GIT_ERROR_WORKTREE, + "not pruning locked working tree: '%s'", + reason.size ? reason.ptr : "is locked"); + git_str_dispose(&reason); ret = 0; goto out; @@ -597,19 +598,18 @@ int git_worktree_is_prunable(git_worktree *wt, goto out; } - if ((ret = git_buf_printf(&path, "%s/worktrees/%s", wt->commondir_path, wt->name) < 0)) + if ((ret = git_str_printf(&path, "%s/worktrees/%s", wt->commondir_path, wt->name) < 0)) goto out; - if (!git_path_exists(path.ptr)) - { - git_error_set(GIT_ERROR_WORKTREE, "worktree gitdir '%s' does not exist", path.ptr); + + if (!git_fs_path_exists(path.ptr)) { + git_error_set(GIT_ERROR_WORKTREE, "worktree gitdir ('%s') does not exist", path.ptr); goto out; } ret = 1; out: - - git_buf_dispose(&path); + git_str_dispose(&path); return ret; } From 12b54ae00948a7a8422af53a8e98a5aa4d51f1f7 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Tue, 16 May 2023 12:40:16 +0100 Subject: [PATCH 288/608] worktree: document that is_prunable sets error messages When a worktree is not prunable, an error message will be set with information about why. Document that. --- include/git2/worktree.h | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/include/git2/worktree.h b/include/git2/worktree.h index bb024dc940e..9193eaf347b 100644 --- a/include/git2/worktree.h +++ b/include/git2/worktree.h @@ -237,7 +237,9 @@ GIT_EXTERN(int) git_worktree_prune_options_init( * * If the worktree is not valid and not locked or if the above * flags have been passed in, this function will return a - * positive value. + * positive value. If the worktree is not prunable, an error + * message will be set (visible in `giterr_last`) with details about + * why. * * @param wt Worktree to check. * @param opts The prunable options. From 3b750a887b8ee32dee82adc7c1877c4f5baf59bc Mon Sep 17 00:00:00 2001 From: Tim Date: Wed, 31 May 2023 14:20:20 +0100 Subject: [PATCH 289/608] Git blame buffer gives the wrong result in many cases where there are multiple local edits. I added multiple failing tests cases to tests/libgit2/blame/buffer.c to cover the test cases. blame.c has been updated to get these tests to pass. Fixes include: shift_hunks_by now no longer shifts hunks before the start line. Adjusting the wedge line in the case where a new hunk deletes and adds lines. In buffer_line_cb for addions humks are now shifted after the current diff line. Fixing the logic for removing a line in buffer_line_cb to work with multi-line deletions. --- src/libgit2/blame.c | 22 ++-- tests/libgit2/blame/buffer.c | 236 ++++++++++++++++++++++++++++++++++- 2 files changed, 244 insertions(+), 14 deletions(-) diff --git a/src/libgit2/blame.c b/src/libgit2/blame.c index d93dd5e76b1..2cb09355e42 100644 --- a/src/libgit2/blame.c +++ b/src/libgit2/blame.c @@ -119,8 +119,11 @@ static void shift_hunks_by(git_vector *v, size_t start_line, int shift_by) size_t i; if (!git_vector_bsearch2(&i, v, hunk_byfinalline_search_cmp, &start_line)) { - for (; i < v->length; i++) { + for (i = 0; i < v->length; i++) { git_blame_hunk *hunk = (git_blame_hunk*)v->contents[i]; + if(hunk->final_start_line_number < start_line){ + continue; + } hunk->final_start_line_number += shift_by; } } @@ -444,21 +447,20 @@ static int buffer_hunk_cb( GIT_UNUSED(delta); - wedge_line = (hunk->old_lines == 0) ? hunk->new_start : hunk->old_start; + wedge_line = (hunk->new_start >= hunk->old_start || hunk->old_lines==0) ? hunk->new_start : hunk->old_start; blame->current_diff_line = wedge_line; - blame->current_hunk = (git_blame_hunk*)git_blame_get_hunk_byline(blame, wedge_line); if (!blame->current_hunk) { /* Line added at the end of the file */ blame->current_hunk = new_hunk(wedge_line, 0, wedge_line, blame->path, blame); + blame->current_diff_line++; GIT_ERROR_CHECK_ALLOC(blame->current_hunk); - git_vector_insert(&blame->hunks, blame->current_hunk); } else if (!hunk_starts_at_or_after_line(blame->current_hunk, wedge_line)){ /* If this hunk doesn't start between existing hunks, split a hunk up so it does */ blame->current_hunk = split_hunk_in_vector(&blame->hunks, blame->current_hunk, - wedge_line - blame->current_hunk->orig_start_line_number, true, + wedge_line - blame->current_hunk->final_start_line_number, true, blame); GIT_ERROR_CHECK_ALLOC(blame->current_hunk); } @@ -484,13 +486,12 @@ static int buffer_line_cb( hunk_ends_at_or_before_line(blame->current_hunk, blame->current_diff_line)) { /* Append to the current buffer-blame hunk */ blame->current_hunk->lines_in_hunk++; - shift_hunks_by(&blame->hunks, blame->current_diff_line+1, 1); + shift_hunks_by(&blame->hunks, blame->current_diff_line, 1); } else { /* Create a new buffer-blame hunk with this line */ shift_hunks_by(&blame->hunks, blame->current_diff_line, 1); blame->current_hunk = new_hunk(blame->current_diff_line, 1, 0, blame->path, blame); GIT_ERROR_CHECK_ALLOC(blame->current_hunk); - git_vector_insert_sorted(&blame->hunks, blame->current_hunk, NULL); } blame->current_diff_line++; @@ -498,15 +499,16 @@ static int buffer_line_cb( if (line->origin == GIT_DIFF_LINE_DELETION) { /* Trim the line from the current hunk; remove it if it's now empty */ - size_t shift_base = blame->current_diff_line + blame->current_hunk->lines_in_hunk+1; + size_t shift_base = blame->current_diff_line + blame->current_hunk->lines_in_hunk; if (--(blame->current_hunk->lines_in_hunk) == 0) { size_t i; - shift_base--; + size_t i_next; if (!git_vector_search2(&i, &blame->hunks, ptrs_equal_cmp, blame->current_hunk)) { git_vector_remove(&blame->hunks, i); free_hunk(blame->current_hunk); - blame->current_hunk = (git_blame_hunk*)git_blame_get_hunk_byindex(blame, (uint32_t)i); + i_next = min( i , blame->hunks.length -1); + blame->current_hunk = (git_blame_hunk*)git_blame_get_hunk_byindex(blame, (uint32_t)i_next); } } shift_hunks_by(&blame->hunks, shift_base, -1); diff --git a/tests/libgit2/blame/buffer.c b/tests/libgit2/blame/buffer.c index 06d5042dd05..456402c4e8b 100644 --- a/tests/libgit2/blame/buffer.c +++ b/tests/libgit2/blame/buffer.c @@ -17,15 +17,204 @@ void test_blame_buffer__cleanup(void) git_repository_free(g_repo); } + +void test_blame_buffer__4_edits(void) +{ + + const char *buffer = "\ +EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n\ +EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n\ +xEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n\ +EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n\ +x\n\ +BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n\ +xBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n\ +BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n\ +xBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n\ +\n\ +CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\ +CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\ +CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\ +CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\n"; + + cl_git_pass(git_blame_buffer(&g_bufferblame, g_fileblame, buffer, strlen(buffer))); + check_blame_hunk_index(g_repo, g_bufferblame, 0, 1, 2, 0, "da237394", "b.txt"); + check_blame_hunk_index(g_repo, g_bufferblame, 1, 3, 1, 0, "000000", "b.txt"); + check_blame_hunk_index(g_repo, g_bufferblame, 2, 4, 1, 0, "da237394", "b.txt"); + check_blame_hunk_index(g_repo, g_bufferblame, 3, 5, 1, 0, "000000", "b.txt"); + check_blame_hunk_index(g_repo, g_bufferblame, 4, 6, 1, 0, "63d671eb", "b.txt"); + check_blame_hunk_index(g_repo, g_bufferblame, 5, 7, 1, 0, "000000", "b.txt"); + check_blame_hunk_index(g_repo, g_bufferblame, 6, 8, 1, 0, "63d671eb", "b.txt"); + check_blame_hunk_index(g_repo, g_bufferblame, 7, 9, 1, 0, "000000", "b.txt"); + check_blame_hunk_index(g_repo, g_bufferblame, 8, 10, 1, 0, "63d671eb", "b.txt"); + check_blame_hunk_index(g_repo, g_bufferblame, 9, 11, 5, 0, "aa06ecca", "b.txt"); +} + +void test_blame_buffer__two_added_lines_and_one_modified(void) +{ + + const char *buffer = "\ +EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n\ +EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n\ +EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n\ +x\n\ +EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n\ +x\n\ +BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n\ +xBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n\ +BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n\ +BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n\ +\n\ +CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\ +CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\ +CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\ +CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\n"; + + cl_git_pass(git_blame_buffer(&g_bufferblame, g_fileblame, buffer, strlen(buffer))); + check_blame_hunk_index(g_repo, g_bufferblame, 0, 1, 3, 0, "da237394", "b.txt"); + check_blame_hunk_index(g_repo, g_bufferblame, 1, 4, 1, 0, "000000", "b.txt"); + check_blame_hunk_index(g_repo, g_bufferblame, 2, 5, 1, 0, "da237394", "b.txt"); + check_blame_hunk_index(g_repo, g_bufferblame, 3, 6, 1, 0, "000000", "b.txt"); + check_blame_hunk_index(g_repo, g_bufferblame, 4, 7, 1, 0, "63d671eb", "b.txt"); + check_blame_hunk_index(g_repo, g_bufferblame, 5, 8, 1, 0, "000000", "b.txt"); + check_blame_hunk_index(g_repo, g_bufferblame, 6, 9, 3, 0, "63d671eb", "b.txt"); + check_blame_hunk_index(g_repo, g_bufferblame, 7, 12, 5, 0, "aa06ecca", "b.txt"); +} + +void test_blame_buffer__two_added_lines(void) +{ + + const char *buffer = "\ +EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n\ +EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n\ +EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n\ +abc\n\ +EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n\ +def\n\ +BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n\ +BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n\ +BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n\ +BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n\ +\n\ +CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\ +CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\ +CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\ +CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\n"; + + cl_git_pass(git_blame_buffer(&g_bufferblame, g_fileblame, buffer, strlen(buffer))); + check_blame_hunk_index(g_repo, g_bufferblame, 0, 1, 3, 0, "da237394", "b.txt"); + check_blame_hunk_index(g_repo, g_bufferblame, 1, 4, 1, 0, "000000", "b.txt"); + check_blame_hunk_index(g_repo, g_bufferblame, 2, 5, 1, 0, "da237394", "b.txt"); + check_blame_hunk_index(g_repo, g_bufferblame, 3, 6, 1, 0, "000000", "b.txt"); + check_blame_hunk_index(g_repo, g_bufferblame, 4, 7, 5, 0, "63d671eb", "b.txt"); + check_blame_hunk_index(g_repo, g_bufferblame, 5, 12, 5, 0, "aa06ecca", "b.txt"); +} + +void test_blame_buffer__added_blocks(void) +{ + + const char *buffer = "\ +EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n\ +EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n\ +EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n\ +EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n\ +\n\ +abcdefg\n\ +hijlmno\n\ +pqrstuv\n\ +BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n\ +BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n\ +BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n\ +BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n\ +abcdefg\n\ +hijlmno\n\ +pqrstuv\n\ +CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\ +CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\ +CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\ +CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\ +\n\ +abcdefg\n\ +hijlmno\n\ +pqrstuv\n"; + + cl_git_pass(git_blame_buffer(&g_bufferblame, g_fileblame, buffer, strlen(buffer))); + check_blame_hunk_index(g_repo, g_bufferblame, 0, 1, 4, 0, "da237394", "b.txt"); + check_blame_hunk_index(g_repo, g_bufferblame, 1, 5, 1, 1, "b99f7ac0", "b.txt"); + check_blame_hunk_index(g_repo, g_bufferblame, 2, 6, 3, 0, "000000", "b.txt"); + check_blame_hunk_index(g_repo, g_bufferblame, 3, 9, 4, 0, "63d671eb", "b.txt"); + check_blame_hunk_index(g_repo, g_bufferblame, 4, 13, 3, 0, "000000", "b.txt"); + check_blame_hunk_index(g_repo, g_bufferblame, 5, 16, 5, 0, "aa06ecca", "b.txt"); + check_blame_hunk_index(g_repo, g_bufferblame, 6, 21, 3, 0, "000000", "b.txt"); + + +} + +void test_blame_buffer__overlapping_blocks(void) +{ + const char *buffer = "\ +EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n\ +EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n\ +EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n\ +abcdefg\n\ +hijlmno\n\ +pqrstuv\n\ +BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n\ +BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n\ +BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n\ +\n\ +CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\ +CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\ +CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\ +CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\ +\n\ +"; + + cl_git_pass(git_blame_buffer(&g_bufferblame, g_fileblame, buffer, strlen(buffer))); + + check_blame_hunk_index(g_repo, g_bufferblame, 0, 1, 3, 0, "da237394", "b.txt"); + check_blame_hunk_index(g_repo, g_bufferblame, 1, 4, 3, 0, "000000", "b.txt"); + check_blame_hunk_index(g_repo, g_bufferblame, 2, 7, 4, 0, "63d671eb", "b.txt"); + check_blame_hunk_index(g_repo, g_bufferblame, 3, 11, 5, 0, "aa06ecca", "b.txt"); + +} + +void test_blame_buffer__2_add_splits_hunk(void) +{ + const char *buffer = "\ +EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n\ +EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n\ +abc\n\ +EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n\ +EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n\ +\n\ +BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n\ +BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n\ +abc\n\ +BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n\ +BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n\ +\n\ +CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\ +CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\ +CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\ +CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\n"; + + cl_git_pass(git_blame_buffer(&g_bufferblame, g_fileblame, buffer, strlen(buffer))); + check_blame_hunk_index(g_repo, g_bufferblame, 0, 1, 2, 0, "da237394", "b.txt"); + check_blame_hunk_index(g_repo, g_bufferblame, 1, 3, 1, 0, "00000000", "b.txt"); + check_blame_hunk_index(g_repo, g_bufferblame, 2, 4, 2, 0, "da237394", "b.txt"); + check_blame_hunk_index(g_repo, g_bufferblame, 3, 6, 1, 1, "b99f7ac0", "b.txt"); + check_blame_hunk_index(g_repo, g_bufferblame, 4, 7, 2, 0, "63d671eb", "b.txt"); + check_blame_hunk_index(g_repo, g_bufferblame, 5, 9, 1, 0, "00000000", "b.txt"); + check_blame_hunk_index(g_repo, g_bufferblame, 6, 10, 3, 0, "63d671eb", "b.txt"); + check_blame_hunk_index(g_repo, g_bufferblame, 7, 13, 5, 0, "aa06ecca", "b.txt"); +} + void test_blame_buffer__index(void) { const git_blame_hunk *hunk; const char *buffer = "Hello\nWorld!"; - /* - * We need to open a different file from the ones used in other tests. Close - * the one opened in test_blame_buffer__initialize() to avoid a leak. - */ git_blame_free(g_fileblame); g_fileblame = NULL; cl_git_pass(git_blame_file(&g_fileblame, g_repo, "file.txt", NULL)); @@ -43,6 +232,8 @@ void test_blame_buffer__index(void) cl_assert(hunk->final_signature == NULL); } + + void test_blame_buffer__added_line(void) { const git_blame_hunk *hunk; @@ -73,6 +264,43 @@ CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC cl_assert_equal_s("Ben Straub", hunk->final_signature->name); } +void test_blame_buffer__added_lines(void) +{ + + const char *buffer = "\ +EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n\ +EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n\ +EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n\ +EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n\ +\n\ +\n\ +\n\ +\n\ +BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n\ +BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n\ +BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n\ +BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n\ +\n\ +\n\ +\n\ +\n\ +CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\ +CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\ +CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\ +CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\ +\n\ +\n\ +\n\ +\n"; + + cl_git_pass(git_blame_buffer(&g_bufferblame, g_fileblame, buffer, strlen(buffer))); + cl_assert_equal_i(7, git_blame_get_hunk_count(g_bufferblame)); + check_blame_hunk_index(g_repo, g_bufferblame, 2, 6, 3, 0, "000000", "b.txt"); + check_blame_hunk_index(g_repo, g_bufferblame, 4, 14, 3, 0, "000000", "b.txt"); + check_blame_hunk_index(g_repo, g_bufferblame, 6, 22, 3, 0, "000000", "b.txt"); + +} + void test_blame_buffer__deleted_line(void) { const char *buffer = "\ From 3b6288af7ecf6ce7df499025bffec053009f2342 Mon Sep 17 00:00:00 2001 From: Tim Date: Wed, 31 May 2023 15:29:01 +0100 Subject: [PATCH 290/608] Removing redundant call to find start line. --- src/libgit2/blame.c | 13 +++++-------- 1 file changed, 5 insertions(+), 8 deletions(-) diff --git a/src/libgit2/blame.c b/src/libgit2/blame.c index 2cb09355e42..2ed7d2011f7 100644 --- a/src/libgit2/blame.c +++ b/src/libgit2/blame.c @@ -117,15 +117,12 @@ static git_blame_hunk *dup_hunk(git_blame_hunk *hunk, git_blame *blame) static void shift_hunks_by(git_vector *v, size_t start_line, int shift_by) { size_t i; - - if (!git_vector_bsearch2(&i, v, hunk_byfinalline_search_cmp, &start_line)) { - for (i = 0; i < v->length; i++) { - git_blame_hunk *hunk = (git_blame_hunk*)v->contents[i]; - if(hunk->final_start_line_number < start_line){ - continue; - } - hunk->final_start_line_number += shift_by; + for (i = 0; i < v->length; i++) { + git_blame_hunk *hunk = (git_blame_hunk*)v->contents[i]; + if(hunk->final_start_line_number < start_line){ + continue; } + hunk->final_start_line_number += shift_by; } } From 4a2c4cc93f86e832696a3067a6f24d42727bc6f5 Mon Sep 17 00:00:00 2001 From: Miguel Arroz <750683+arroz@users.noreply.github.com> Date: Fri, 9 Jun 2023 18:21:13 -0700 Subject: [PATCH 291/608] #6576 git_diff_index_to_workdir reverse now loads untracked content --- src/libgit2/diff_file.c | 2 +- tests/libgit2/diff/workdir.c | 47 ++++++++++++++++++++++++++++++++++++ 2 files changed, 48 insertions(+), 1 deletion(-) diff --git a/src/libgit2/diff_file.c b/src/libgit2/diff_file.c index c2d08675ab0..85296ca5be3 100644 --- a/src/libgit2/diff_file.c +++ b/src/libgit2/diff_file.c @@ -112,7 +112,7 @@ int git_diff_file_content__init_from_diff( case GIT_DELTA_DELETED: has_data = use_old; break; case GIT_DELTA_UNTRACKED: - has_data = !use_old && + has_data = (use_old == (diff->opts.flags & GIT_DIFF_REVERSE)) && (diff->opts.flags & GIT_DIFF_SHOW_UNTRACKED_CONTENT) != 0; break; case GIT_DELTA_UNREADABLE: diff --git a/tests/libgit2/diff/workdir.c b/tests/libgit2/diff/workdir.c index 21c5b0de9a2..c433b75cedc 100644 --- a/tests/libgit2/diff/workdir.c +++ b/tests/libgit2/diff/workdir.c @@ -2278,3 +2278,50 @@ void test_diff_workdir__ignore_blank_lines(void) git_patch_free(patch); git_diff_free(diff); } + +void test_diff_workdir__to_index_reversed_content_loads(void) +{ + git_diff_options opts = GIT_DIFF_OPTIONS_INIT; + git_diff *diff = NULL; + diff_expects exp; + int use_iterator; + char *pathspec = "new_file"; + + g_repo = cl_git_sandbox_init("status"); + + opts.context_lines = 3; + opts.interhunk_lines = 1; + opts.flags |= GIT_DIFF_INCLUDE_IGNORED | GIT_DIFF_INCLUDE_UNTRACKED | + GIT_DIFF_SHOW_UNTRACKED_CONTENT | GIT_DIFF_REVERSE; + opts.pathspec.strings = &pathspec; + opts.pathspec.count = 1; + + cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts)); + + for (use_iterator = 0; use_iterator <= 1; use_iterator++) { + memset(&exp, 0, sizeof(exp)); + + if (use_iterator) + cl_git_pass(diff_foreach_via_iterator( + diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp)); + else + cl_git_pass(git_diff_foreach( + diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp)); + + cl_assert_equal_i(1, exp.files); + cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]); + cl_assert_equal_i(0, exp.file_status[GIT_DELTA_DELETED]); + cl_assert_equal_i(0, exp.file_status[GIT_DELTA_MODIFIED]); + cl_assert_equal_i(0, exp.file_status[GIT_DELTA_IGNORED]); + cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNTRACKED]); + + cl_assert_equal_i(1, exp.hunks); + + cl_assert_equal_i(1, exp.lines); + cl_assert_equal_i(0, exp.line_ctxt); + cl_assert_equal_i(0, exp.line_adds); + cl_assert_equal_i(1, exp.line_dels); + } + + git_diff_free(diff); +} From 1e2ea79e78be135f47dfc3fcf65d7572c0ad1e3a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Timo=20R=C3=B6hling?= Date: Mon, 19 Jun 2023 20:44:09 +0200 Subject: [PATCH 292/608] Use #!/bin/bash for script with bash-specific commands The test/Resources/push.sh calls pushd/popd, which is not a POSIX shell feature but a Bash extension. --- tests/resources/push.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/resources/push.sh b/tests/resources/push.sh index 3e77fb5307f..54ef3ddf27c 100644 --- a/tests/resources/push.sh +++ b/tests/resources/push.sh @@ -1,4 +1,4 @@ -#!/bin/sh +#!/bin/bash #creates push_src repo for libgit2 push tests. set -eu From f576b7dd0228a8e3b203d66bf77cf3b71c780f87 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= Date: Thu, 22 Jun 2023 09:54:11 +0200 Subject: [PATCH 293/608] midx: allow unknown chunk ids in multi-pack index files These chunks work like extensions where it's fine not to know what one means. We can skip over it and keep processing the file instead of erroring out. --- src/libgit2/midx.c | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/src/libgit2/midx.c b/src/libgit2/midx.c index f6071f0bbbd..2072a8c8099 100644 --- a/src/libgit2/midx.c +++ b/src/libgit2/midx.c @@ -185,7 +185,8 @@ int git_midx_parse( chunk_oid_fanout = {0}, chunk_oid_lookup = {0}, chunk_object_offsets = {0}, - chunk_object_large_offsets = {0}; + chunk_object_large_offsets = {0}, + chunk_unknown = {0}; GIT_ASSERT_ARG(idx); @@ -264,7 +265,9 @@ int git_midx_parse( break; default: - return midx_error("unrecognized chunk ID"); + chunk_unknown.offset = last_chunk_offset; + last_chunk = &chunk_unknown; + break; } } last_chunk->length = (size_t)(trailer_offset - last_chunk_offset); From 1bbe0dd89dd1a63c4cf5f1cb1f925336408f0f7e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= Date: Thu, 22 Jun 2023 11:03:36 +0200 Subject: [PATCH 294/608] pack: cast the number of objects to size_t Similar to a previous change where we had to change the casting when loading the index file, we also need to make sure we don't restrict the numbers to 32-bit when looking up objects in packfiles. This was done about three years ago in git itself, but we never got he update in this library. --- src/libgit2/pack.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/libgit2/pack.c b/src/libgit2/pack.c index d59973aa937..eff73988278 100644 --- a/src/libgit2/pack.c +++ b/src/libgit2/pack.c @@ -1268,13 +1268,13 @@ static off64_t nth_packed_object_offset_locked(struct git_pack_file *p, uint32_t end = index + p->index_map.len; index += 4 * 256; if (p->index_version == 1) - return ntohl(*((uint32_t *)(index + (p->oid_size + 4) * n))); + return ntohl(*((uint32_t *)(index + (p->oid_size + 4) * (size_t) n))); - index += 8 + p->num_objects * (p->oid_size + 4); + index += 8 + (size_t) p->num_objects * (p->oid_size + 4); off32 = ntohl(*((uint32_t *)(index + 4 * n))); if (!(off32 & 0x80000000)) return off32; - index += p->num_objects * 4 + (off32 & 0x7fffffff) * 8; + index += (size_t) p->num_objects * 4 + (off32 & 0x7fffffff) * 8; /* Make sure we're not being sent out of bounds */ if (index >= end - 8) From c1aa0213e11c4cc5c5ba72eb5daf9b0664a1045c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= Date: Thu, 22 Jun 2023 12:08:31 +0200 Subject: [PATCH 295/608] midx: do not try to look at every object in the index Similar to previous issues around doing way too much verification at loading time, checking whether the object index chunk is monotonic is better left for git-fsck instead of every single time we want to look at something in the repository. As midx files grow, this starts taking more and more times. As an example, I went looking for this because it's taking about 1.5s to do a single object lookup in a repository that's ended up with a 7G multi-pack-index file. --- src/libgit2/midx.c | 10 +--------- 1 file changed, 1 insertion(+), 9 deletions(-) diff --git a/src/libgit2/midx.c b/src/libgit2/midx.c index f6071f0bbbd..a70725d6c52 100644 --- a/src/libgit2/midx.c +++ b/src/libgit2/midx.c @@ -114,8 +114,6 @@ static int midx_parse_oid_lookup( const unsigned char *data, struct git_midx_chunk *chunk_oid_lookup) { - uint32_t i; - unsigned char *oid, *prev_oid, zero_oid[GIT_OID_MAX_SIZE] = {0}; size_t oid_size = git_oid_size(idx->oid_type); if (chunk_oid_lookup->offset == 0) @@ -125,13 +123,7 @@ static int midx_parse_oid_lookup( if (chunk_oid_lookup->length != idx->num_objects * oid_size) return midx_error("OID Lookup chunk has wrong length"); - idx->oid_lookup = oid = (unsigned char *)(data + chunk_oid_lookup->offset); - prev_oid = zero_oid; - for (i = 0; i < idx->num_objects; ++i, oid += oid_size) { - if (git_oid_raw_cmp(prev_oid, oid, oid_size) >= 0) - return midx_error("OID Lookup index is non-monotonic"); - prev_oid = oid; - } + idx->oid_lookup = (unsigned char *)(data + chunk_oid_lookup->offset); return 0; } From 933c09dbec8bece0a33d9b1792fcc9adeba28045 Mon Sep 17 00:00:00 2001 From: Fabio Alessandrelli Date: Sun, 25 Jun 2023 05:12:57 +0200 Subject: [PATCH 296/608] CMake: Search for ssh2 instead of libssh2. Fixes "CMake Error: could not resolve ssh2" on Windows-MSVC. --- cmake/SelectSSH.cmake | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cmake/SelectSSH.cmake b/cmake/SelectSSH.cmake index 23dfc978521..968a63114f3 100644 --- a/cmake/SelectSSH.cmake +++ b/cmake/SelectSSH.cmake @@ -1,6 +1,6 @@ # Optional external dependency: libssh2 if(USE_SSH) - find_pkglibraries(LIBSSH2 libssh2) + find_pkglibraries(LIBSSH2 ssh2) if(NOT LIBSSH2_FOUND) find_package(LibSSH2) set(LIBSSH2_INCLUDE_DIRS ${LIBSSH2_INCLUDE_DIR}) From 27b40287a077a1c650ff4c761ae11e3c5bbdbe99 Mon Sep 17 00:00:00 2001 From: Vincenzo Palazzo Date: Sun, 9 Jul 2023 16:49:32 +0200 Subject: [PATCH 297/608] docs: fix IRC server from freenode to libera This commit update the contributing documents with the new IRC server and remove the old freenode. Signed-off-by: Vincenzo Palazzo --- docs/contributing.md | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/docs/contributing.md b/docs/contributing.md index 03e0017093b..382d9555ef5 100644 --- a/docs/contributing.md +++ b/docs/contributing.md @@ -24,9 +24,8 @@ by the following licenses: ## Discussion & Chat -We hang out in the -[`#libgit2`](http://webchat.freenode.net/?channels=#libgit2)) channel on -irc.freenode.net. +We hang out in the [#libgit2](https://web.libera.chat/#libgit2) channel on +[libera](https://libera.chat). Also, feel free to open an [Issue](https://github.com/libgit2/libgit2/issues/new) to start a discussion From 9b3d9c65a590fe2dfa803f89a7ae810001ca8107 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 15 Jul 2023 15:43:51 +0100 Subject: [PATCH 298/608] meta: update GitHub release labels --- .github/release.yml | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/.github/release.yml b/.github/release.yml index 79158f492d9..c7850749119 100644 --- a/.github/release.yml +++ b/.github/release.yml @@ -3,6 +3,9 @@ changelog: - title: New features labels: - feature + - title: Performance improvements + labels: + - performance issues - title: Bug fixes labels: - bug @@ -18,6 +21,9 @@ changelog: - title: Documentation improvements labels: - documentation + - title: Git compatibility fixes + labels: + - git compatibility - title: Other changes labels: - '*' From 2b55e59f60b807e6bc9e8663446d01ea88183dab Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 15 Jul 2023 15:46:02 +0100 Subject: [PATCH 299/608] meta: update GitHub release labels --- .github/release.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/release.yml b/.github/release.yml index c7850749119..7a0032113db 100644 --- a/.github/release.yml +++ b/.github/release.yml @@ -5,7 +5,7 @@ changelog: - feature - title: Performance improvements labels: - - performance issues + - performance - title: Bug fixes labels: - bug From c02fe8d2799a2c58ce8632870be263e99e884908 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 15 Jul 2023 16:16:48 +0100 Subject: [PATCH 300/608] deps: update pcre to 8.45 --- deps/pcre/LICENCE | 10 +++++----- deps/pcre/pcre.h | 4 ++-- deps/pcre/pcre_compile.c | 9 ++++++--- deps/pcre/pcre_exec.c | 4 ++-- 4 files changed, 15 insertions(+), 12 deletions(-) diff --git a/deps/pcre/LICENCE b/deps/pcre/LICENCE index 57a544814c8..803b4119e50 100644 --- a/deps/pcre/LICENCE +++ b/deps/pcre/LICENCE @@ -19,13 +19,13 @@ THE BASIC LIBRARY FUNCTIONS --------------------------- Written by: Philip Hazel -Email local part: ph10 -Email domain: cam.ac.uk +Email local part: Philip.Hazel +Email domain: gmail.com University of Cambridge Computing Service, Cambridge, England. -Copyright (c) 1997-2020 University of Cambridge +Copyright (c) 1997-2021 University of Cambridge All rights reserved. @@ -36,7 +36,7 @@ Written by: Zoltan Herczeg Email local part: hzmester Email domain: freemail.hu -Copyright(c) 2010-2020 Zoltan Herczeg +Copyright(c) 2010-2021 Zoltan Herczeg All rights reserved. @@ -47,7 +47,7 @@ Written by: Zoltan Herczeg Email local part: hzmester Email domain: freemail.hu -Copyright(c) 2009-2020 Zoltan Herczeg +Copyright(c) 2009-2021 Zoltan Herczeg All rights reserved. diff --git a/deps/pcre/pcre.h b/deps/pcre/pcre.h index 5b147b9f8b5..821b50e88a9 100644 --- a/deps/pcre/pcre.h +++ b/deps/pcre/pcre.h @@ -42,9 +42,9 @@ POSSIBILITY OF SUCH DAMAGE. /* The current PCRE version information. */ #define PCRE_MAJOR 8 -#define PCRE_MINOR 44 +#define PCRE_MINOR 45 #define PCRE_PRERELEASE -#define PCRE_DATE 2020-02-12 +#define PCRE_DATE 2021-06-15 #define PCRE_EXP_DECL extern diff --git a/deps/pcre/pcre_compile.c b/deps/pcre/pcre_compile.c index a3f20fd35d0..43f852f4627 100644 --- a/deps/pcre/pcre_compile.c +++ b/deps/pcre/pcre_compile.c @@ -6,7 +6,7 @@ and semantics are as close as possible to those of the Perl 5 language. Written by Philip Hazel - Copyright (c) 1997-2020 University of Cambridge + Copyright (c) 1997-2021 University of Cambridge ----------------------------------------------------------------------------- Redistribution and use in source and binary forms, with or without @@ -9104,6 +9104,8 @@ pcre_uchar cworkspace[COMPILE_WORK_SIZE]; similar way to cworkspace, it can be expanded using malloc() if necessary. */ named_group named_groups[NAMED_GROUP_LIST_SIZE]; +cd->named_groups = named_groups; +cd->named_group_list_size = NAMED_GROUP_LIST_SIZE; /* Set this early so that early errors get offset 0. */ @@ -9377,8 +9379,6 @@ cd->hwm = cworkspace; cd->iscondassert = FALSE; cd->start_workspace = cworkspace; cd->workspace_size = COMPILE_WORK_SIZE; -cd->named_groups = named_groups; -cd->named_group_list_size = NAMED_GROUP_LIST_SIZE; cd->start_pattern = (const pcre_uchar *)pattern; cd->end_pattern = (const pcre_uchar *)(pattern + STRLEN_UC((const pcre_uchar *)pattern)); cd->req_varyopt = 0; @@ -9489,6 +9489,7 @@ if (cd->names_found > 0) add_name(cd, ng->name, ng->length, ng->number); if (cd->named_group_list_size > NAMED_GROUP_LIST_SIZE) (PUBL(free))((void *)cd->named_groups); + cd->named_group_list_size = 0; /* So we don't free it twice */ } /* Set up a starting, non-extracting bracket, then compile the expression. On @@ -9639,6 +9640,8 @@ if (errorcode != 0) { (PUBL(free))(re); PCRE_EARLY_ERROR_RETURN: + if (cd->named_group_list_size > NAMED_GROUP_LIST_SIZE) + (PUBL(free))((void *)cd->named_groups); *erroroffset = (int)(ptr - (const pcre_uchar *)pattern); PCRE_EARLY_ERROR_RETURN2: *errorptr = find_error_text(errorcode); diff --git a/deps/pcre/pcre_exec.c b/deps/pcre/pcre_exec.c index 3fd58cbe31c..5b96954fcd9 100644 --- a/deps/pcre/pcre_exec.c +++ b/deps/pcre/pcre_exec.c @@ -6,7 +6,7 @@ and semantics are as close as possible to those of the Perl 5 language. Written by Philip Hazel - Copyright (c) 1997-2018 University of Cambridge + Copyright (c) 1997-2021 University of Cambridge ----------------------------------------------------------------------------- Redistribution and use in source and binary forms, with or without @@ -758,7 +758,7 @@ for (;;) md->mark = NULL; /* In case previously set by assertion */ RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode] + ecode[1], offset_top, md, eptrb, RM55); - if ((rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) && + if ((rrc == MATCH_MATCH || rrc == MATCH_ACCEPT || rrc == MATCH_KETRPOS) && md->mark == NULL) md->mark = ecode + 2; /* A return of MATCH_SKIP_ARG means that matching failed at SKIP with an From bdd031576b0ef3f3333270bead63e91a735d94d9 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 17 Jul 2023 10:33:15 +0100 Subject: [PATCH 301/608] v1.7: update version numbers --- README.md | 2 +- include/git2/version.h | 4 ++-- package.json | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index 93476f9c0cd..711e848e0a5 100644 --- a/README.md +++ b/README.md @@ -4,8 +4,8 @@ libgit2 - the Git linkable library | Build Status | | | ------------ | - | | **main** branch CI builds | [![CI Build](https://github.com/libgit2/libgit2/workflows/CI%20Build/badge.svg?event=push)](https://github.com/libgit2/libgit2/actions?query=workflow%3A%22CI+Build%22+event%3Apush) | +| **v1.7 branch** CI builds | [![CI Build](https://github.com/libgit2/libgit2/workflows/CI%20Build/badge.svg?branch=maint%2Fv1.7&event=push)](https://github.com/libgit2/libgit2/actions?query=workflow%3A%22CI+Build%22+event%3Apush+branch%3Amaint%2Fv1.7) | | **v1.6 branch** CI builds | [![CI Build](https://github.com/libgit2/libgit2/workflows/CI%20Build/badge.svg?branch=maint%2Fv1.6&event=push)](https://github.com/libgit2/libgit2/actions?query=workflow%3A%22CI+Build%22+event%3Apush+branch%3Amaint%2Fv1.6) | -| **v1.5 branch** CI builds | [![CI Build](https://github.com/libgit2/libgit2/workflows/CI%20Build/badge.svg?branch=maint%2Fv1.5&event=push)](https://github.com/libgit2/libgit2/actions?query=workflow%3A%22CI+Build%22+event%3Apush+branch%3Amaint%2Fv1.5) | | **Nightly** builds | [![Nightly Build](https://github.com/libgit2/libgit2/workflows/Nightly%20Build/badge.svg)](https://github.com/libgit2/libgit2/actions?query=workflow%3A%22Nightly+Build%22) [![Coverity Scan Status](https://scan.coverity.com/projects/639/badge.svg)](https://scan.coverity.com/projects/639) | `libgit2` is a portable, pure C implementation of the Git core methods diff --git a/include/git2/version.h b/include/git2/version.h index bed47f51e49..088ba6b07b1 100644 --- a/include/git2/version.h +++ b/include/git2/version.h @@ -11,7 +11,7 @@ * The version string for libgit2. This string follows semantic * versioning (v2) guidelines. */ -#define LIBGIT2_VERSION "1.7.0-alpha" +#define LIBGIT2_VERSION "1.7.0" /** The major version number for this version of libgit2. */ #define LIBGIT2_VER_MAJOR 1 @@ -31,7 +31,7 @@ * a prerelease name like "beta" or "rc1". For final releases, this will * be `NULL`. */ -#define LIBGIT2_VER_PRERELEASE "alpha" +#define LIBGIT2_VER_PRERELEASE NULL /** The library ABI soversion for this version of libgit2. */ #define LIBGIT2_SOVERSION "1.7" diff --git a/package.json b/package.json index 398446ea5f4..8c6f4ef6e80 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "libgit2", - "version": "1.7.0-alpha", + "version": "1.7.0", "repo": "https://github.com/libgit2/libgit2", "description": " A cross-platform, linkable library implementation of Git that you can use in your application.", "install": "mkdir build && cd build && cmake .. && cmake --build ." From c375d0b7c84243fe1cc1a3903b048d8a05c40d1b Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 17 Jul 2023 10:33:28 +0100 Subject: [PATCH 302/608] v1.7: update changelog --- docs/changelog.md | 128 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 128 insertions(+) diff --git a/docs/changelog.md b/docs/changelog.md index 20e48a084de..f733102356a 100644 --- a/docs/changelog.md +++ b/docs/changelog.md @@ -1,3 +1,131 @@ +v1.7 +---- + +This is release v1.7.0, "Kleine Raupe Nimmersatt". This release adds +shallow clone support, completes the experimental SHA256 support, +adds Schannel support for Windows, and includes many other new +features and bugfixes. + +## Major changes + +* **Shallow clone support** + libgit2 now supports shallow clone and shallow repositories, thanks + to a significant investment from many community members -- hundreds + of commits by many contributors. + + * Shallow (#6396) with some fixes from review by @ethomson in + https://github.com/libgit2/libgit2/pull/6557 + * Shallow Clone Support by @lya001 in + https://github.com/libgit2/libgit2/pull/6396 + * Shallow support v2 by @pks-t in + https://github.com/libgit2/libgit2/pull/5254 + +* **SHA256 support** + libgit2 should now support SHA256 repositories using the + `extensions.objectFormat` configuration option when the library is + built with `EXPERIMENTAL_SHA256=ON`. Users are encouraged to begin + testing their applications with this option and provide bug reports + and feedback. This _is_ a breaking API change; SHA256 support will + be enabled by default in libgit2 v2.0. + + * sha256: less hardcoded SHA1 types and lengths by @ethomson in + https://github.com/libgit2/libgit2/pull/6549 + * Support SHA256 in git_repository_wrap_odb by @ethomson in + https://github.com/libgit2/libgit2/pull/6556 + +* **Schannel and SSPI for Windows** + libgit2 now supports the Windows Schannel and SSPI APIs for HTTPS + support on Windows, when configured with `USE_HTTPS=Schannel`. + Setting this option will not use the existing WinHTTP support, but + will use libgit2's standard HTTP client stack with Windows TLS + primitives. Windows users are encouraged to begin testing their + applications with this option and provide bug reports and feedback. + This will be enabled by default in a future version of libgit2. + + * Introduce Schannel and SSPI for Windows by @ethomson in + https://github.com/libgit2/libgit2/pull/6533 + +## Breaking changes + +* **Simplify custom pluggable allocator** (System API / ABI breaking change) + The `git_allocator` structure (configurable by the + `GIT_OPT_SET_ALLOCATOR` option) now only contains `gmalloc`, + `grealloc` and `gfree` members. This simplifies both the work needed + by an implementer _and_ allows more flexibility and correctness in + libgit2 itself, especially during out-of-memory situations and + errors during bootstrapping. + + * tests: add allocator with limited number of bytes by @ethomson in + https://github.com/libgit2/libgit2/pull/6563 + +## Other changes + +### New features +* repo: honor environment variables for more scenarios by @ethomson in + https://github.com/libgit2/libgit2/pull/6544 +* Introduce timeouts on sockets by @ethomson in + https://github.com/libgit2/libgit2/pull/6535 + +### Performance improvements +* midx: do not try to look at every object in the index by @carlosmn in + https://github.com/libgit2/libgit2/pull/6585 +* Partial fix for #6532: insert-by-date order. by @arroz in + https://github.com/libgit2/libgit2/pull/6539 + +### Bug fixes +* repo: don't allow repeated extensions by @ethomson in + https://github.com/libgit2/libgit2/pull/6505 +* config: return `GIT_ENOTFOUND` for missing programdata by @ethomson in + https://github.com/libgit2/libgit2/pull/6547 +* Fix missing oid type for "fake" repositories by @oreiche in + https://github.com/libgit2/libgit2/pull/6554 +* Thread-local storage: handle failure cases by @ethomson in + https://github.com/libgit2/libgit2/pull/5722 +* midx: allow unknown chunk ids in multi-pack index files by @carlosmn in + https://github.com/libgit2/libgit2/pull/6583 +* pack: cast the number of objects to size_t by @carlosmn in + https://github.com/libgit2/libgit2/pull/6584 +* Fixes #6344: git_branch_move now renames the reflog instead of deleting + by @arroz in https://github.com/libgit2/libgit2/pull/6345 +* #6576 git_diff_index_to_workdir reverse now loads untracked content by + @arroz in https://github.com/libgit2/libgit2/pull/6577 + +### Build and CI improvements +* meta: the main branch is now v1.7.0 by @ethomson in + https://github.com/libgit2/libgit2/pull/6516 +* xdiff: move xdiff to 'deps' by @ethomson in + https://github.com/libgit2/libgit2/pull/6482 +* util: detect all possible qsort_r and qsort_s variants by + @DimitryAndric in https://github.com/libgit2/libgit2/pull/6555 +* Work around -Werror problems when detecting qsort variants by + @DimitryAndric in https://github.com/libgit2/libgit2/pull/6558 +* actions: simplify execution with composite action by @ethomson in + https://github.com/libgit2/libgit2/pull/6488 +* CMake: Search for ssh2 instead of libssh2. by @Faless in + https://github.com/libgit2/libgit2/pull/6586 + +### Documentation improvements +* docs: fix IRC server from freenode to libera by @vincenzopalazzo in + https://github.com/libgit2/libgit2/pull/6590 + +### Dependency upgrades +* Update xdiff to git 2.40.1's version by @ethomson in + https://github.com/libgit2/libgit2/pull/6561 +* deps: update pcre to 8.45 by @ethomson in + https://github.com/libgit2/libgit2/pull/6593 + +## New Contributors +* @oreiche made their first contribution in + https://github.com/libgit2/libgit2/pull/6554 +* @DimitryAndric made their first contribution in + https://github.com/libgit2/libgit2/pull/6555 +* @vincenzopalazzo made their first contribution in + https://github.com/libgit2/libgit2/pull/6590 +* @Faless made their first contribution in + https://github.com/libgit2/libgit2/pull/6586 + +**Full Changelog**: https://github.com/libgit2/libgit2/compare/v1.6.3...v1.7.0 + v1.6.3 ------ From 62498558ffbd16449850d33c5048673fce78999e Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 17 Jul 2023 11:05:48 +0100 Subject: [PATCH 303/608] meta: update version numbers to v1.8 --- CMakeLists.txt | 2 +- include/git2/version.h | 12 ++++++++---- package.json | 2 +- 3 files changed, 10 insertions(+), 6 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index cfb5a7d6f4d..81e2bc8aca1 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -6,7 +6,7 @@ cmake_minimum_required(VERSION 3.5.1) -project(libgit2 VERSION "1.7.0" LANGUAGES C) +project(libgit2 VERSION "1.8.0" LANGUAGES C) # Add find modules to the path set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${PROJECT_SOURCE_DIR}/cmake") diff --git a/include/git2/version.h b/include/git2/version.h index 088ba6b07b1..76cb0026fc2 100644 --- a/include/git2/version.h +++ b/include/git2/version.h @@ -11,13 +11,13 @@ * The version string for libgit2. This string follows semantic * versioning (v2) guidelines. */ -#define LIBGIT2_VERSION "1.7.0" +#define LIBGIT2_VERSION "1.8.0-alpha" /** The major version number for this version of libgit2. */ #define LIBGIT2_VER_MAJOR 1 /** The minor version number for this version of libgit2. */ -#define LIBGIT2_VER_MINOR 7 +#define LIBGIT2_VER_MINOR 8 /** The revision ("teeny") version number for this version of libgit2. */ #define LIBGIT2_VER_REVISION 0 @@ -31,9 +31,13 @@ * a prerelease name like "beta" or "rc1". For final releases, this will * be `NULL`. */ -#define LIBGIT2_VER_PRERELEASE NULL +#define LIBGIT2_VER_PRERELEASE "alpha" -/** The library ABI soversion for this version of libgit2. */ +/** + * The library ABI soversion for this version of libgit2. This should + * only be changed when the library has a breaking ABI change, and so + * may trail the library's version number. + */ #define LIBGIT2_SOVERSION "1.7" #endif diff --git a/package.json b/package.json index 8c6f4ef6e80..203e99b9bc6 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "libgit2", - "version": "1.7.0", + "version": "1.8.0-alpha", "repo": "https://github.com/libgit2/libgit2", "description": " A cross-platform, linkable library implementation of Git that you can use in your application.", "install": "mkdir build && cd build && cmake .. && cmake --build ." From 89bc8ff9825efd4dcb343ed788a74a58ed8e61d5 Mon Sep 17 00:00:00 2001 From: lmcglash Date: Mon, 17 Jul 2023 21:41:04 +0100 Subject: [PATCH 304/608] Return an error for invalid proxy URLs instead of crashing. --- src/libgit2/transports/http.c | 13 +++++++++++-- tests/libgit2/online/clone.c | 13 +++++++++++++ 2 files changed, 24 insertions(+), 2 deletions(-) diff --git a/src/libgit2/transports/http.c b/src/libgit2/transports/http.c index 0534503bf25..a7aea6b377e 100644 --- a/src/libgit2/transports/http.c +++ b/src/libgit2/transports/http.c @@ -334,10 +334,19 @@ static int lookup_proxy( return 0; } - if (!proxy || - (error = git_net_url_parse(&transport->proxy.url, proxy)) < 0) + if (!proxy) goto done; + + if ((error = git_net_url_parse(&transport->proxy.url, proxy) < 0)) + goto done; + + if (!git_net_url_valid(&transport->proxy.url)) { + git_error_set(GIT_ERROR_HTTP, "invalid proxy url: %s", proxy); + error = GIT_EINVALIDSPEC; + goto done; + } + *out_use = true; done: diff --git a/tests/libgit2/online/clone.c b/tests/libgit2/online/clone.c index dbcac50ae6e..5c714d1aa9d 100644 --- a/tests/libgit2/online/clone.c +++ b/tests/libgit2/online/clone.c @@ -968,6 +968,19 @@ static int proxy_cert_cb(git_cert *cert, int valid, const char *host, void *payl return valid ? 0 : GIT_ECERTIFICATE; } +void test_online_clone__proxy_invalid_url(void) +{ + g_options.fetch_opts.proxy_opts.type = GIT_PROXY_SPECIFIED; + g_options.fetch_opts.proxy_opts.credentials = proxy_cred_cb; + g_options.fetch_opts.proxy_opts.certificate_check = proxy_cert_cb; + + g_options.fetch_opts.proxy_opts.url = "noschemeorport"; + cl_git_fail_with(GIT_EINVALIDSPEC, git_clone(&g_repo, "http://github.com/libgit2/TestGitRepository", "./foo", &g_options)); + + g_options.fetch_opts.proxy_opts.url = "noscheme:8080"; + cl_git_fail_with(GIT_EINVALIDSPEC, git_clone(&g_repo, "http://github.com/libgit2/TestGitRepository", "./foo", &g_options)); +} + void test_online_clone__proxy_credentials_request(void) { git_str url = GIT_STR_INIT; From 9d4c550564ee254dda9e2620c4c1e32ebb529728 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= Date: Tue, 18 Jul 2023 12:31:46 +0200 Subject: [PATCH 305/608] repository: make cleanup safe for re-use with grafts We are allowed to call `git_repository__cleanup` multiple times, and this happens e.g. in rugged if we want to free up resources before GC gets around to them. This means that we cannot leave dangling pointers in it, which we were doing with the grafts. Fix this by setting the pointers to NULL after freeing the resources. --- src/libgit2/repository.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index 97f776c4a34..05ece6efc41 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -153,7 +153,9 @@ int git_repository__cleanup(git_repository *repo) git_cache_clear(&repo->objects); git_attr_cache_flush(repo); git_grafts_free(repo->grafts); + repo->grafts = NULL; git_grafts_free(repo->shallow_grafts); + repo->shallow_grafts = NULL; set_config(repo, NULL); set_index(repo, NULL); From 1a1464176b76d98cd71b7542baf56267fcb4c1ad Mon Sep 17 00:00:00 2001 From: steven9724 <116153756+steven9724@users.noreply.github.com> Date: Tue, 20 Jun 2023 10:36:24 +0100 Subject: [PATCH 306/608] ssh: fix known_hosts leak in _git_ssh_setup_conn --- src/libgit2/transports/ssh.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/libgit2/transports/ssh.c b/src/libgit2/transports/ssh.c index af618e1a6ed..de63d454ee6 100644 --- a/src/libgit2/transports/ssh.c +++ b/src/libgit2/transports/ssh.c @@ -877,11 +877,12 @@ static int _git_ssh_setup_conn( t->current_stream = s; done: + if (known_hosts) + libssh2_knownhost_free(known_hosts); + if (error < 0) { ssh_stream_free(*stream); - if (known_hosts) - libssh2_knownhost_free(known_hosts); if (session) libssh2_session_free(session); } From f85e0af2b68c97b97de8c2388674b0868b5c5979 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Wed, 19 Jul 2023 11:17:03 +0100 Subject: [PATCH 307/608] config: complete entry during creation Don't set entry data when we "get" an entry from the collection, add the data to the entry before it's put into the collection. This keeps the entry creation logic in a single place. --- src/libgit2/config_file.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/libgit2/config_file.c b/src/libgit2/config_file.c index 716924de600..6fc4c6fc21d 100644 --- a/src/libgit2/config_file.c +++ b/src/libgit2/config_file.c @@ -359,8 +359,6 @@ static int config_file_get(git_config_backend *cfg, const char *key, git_config_ return error; } - entry->free = config_file_entry_free; - entry->payload = entries; *out = entry; return 0; @@ -805,6 +803,8 @@ static int read_on_variable( entry->value = var_value ? git__strdup(var_value) : NULL; entry->level = parse_data->level; entry->include_depth = parse_data->depth; + entry->free = config_file_entry_free; + entry->payload = parse_data->entries; if ((result = git_config_entries_append(parse_data->entries, entry)) < 0) return result; From 650a9dffb48640f9e9b04f82489e74d34eaa9938 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Wed, 19 Jul 2023 12:23:07 +0100 Subject: [PATCH 308/608] config: rename config_entries to config_list --- src/libgit2/config_entries.h | 24 ---- src/libgit2/config_file.c | 124 ++++++++--------- .../{config_entries.c => config_list.c} | 127 +++++++++--------- src/libgit2/config_list.h | 24 ++++ src/libgit2/config_mem.c | 28 ++-- src/libgit2/config_snapshot.c | 42 +++--- 6 files changed, 185 insertions(+), 184 deletions(-) delete mode 100644 src/libgit2/config_entries.h rename src/libgit2/{config_entries.c => config_list.c} (50%) create mode 100644 src/libgit2/config_list.h diff --git a/src/libgit2/config_entries.h b/src/libgit2/config_entries.h deleted file mode 100644 index 832379e7466..00000000000 --- a/src/libgit2/config_entries.h +++ /dev/null @@ -1,24 +0,0 @@ -/* - * Copyright (C) the libgit2 contributors. All rights reserved. - * - * This file is part of libgit2, distributed under the GNU GPL v2 with - * a Linking Exception. For full terms see the included COPYING file. - */ - -#include "common.h" - -#include "git2/sys/config.h" -#include "config.h" - -typedef struct git_config_entries git_config_entries; - -int git_config_entries_new(git_config_entries **out); -int git_config_entries_dup(git_config_entries **out, git_config_entries *entries); -int git_config_entries_dup_entry(git_config_entries *entries, const git_config_entry *entry); -void git_config_entries_incref(git_config_entries *entries); -void git_config_entries_free(git_config_entries *entries); -/* Add or append the new config option */ -int git_config_entries_append(git_config_entries *entries, git_config_entry *entry); -int git_config_entries_get(git_config_entry **out, git_config_entries *entries, const char *key); -int git_config_entries_get_unique(git_config_entry **out, git_config_entries *entries, const char *key); -int git_config_entries_iterator_new(git_config_iterator **out, git_config_entries *entries); diff --git a/src/libgit2/config_file.c b/src/libgit2/config_file.c index 6fc4c6fc21d..41241f1b0f5 100644 --- a/src/libgit2/config_file.c +++ b/src/libgit2/config_file.c @@ -13,7 +13,7 @@ #include "array.h" #include "str.h" #include "config_backend.h" -#include "config_entries.h" +#include "config_list.h" #include "config_parse.h" #include "filebuf.h" #include "regexp.h" @@ -34,7 +34,7 @@ typedef struct config_file { typedef struct { git_config_backend parent; git_mutex values_mutex; - git_config_entries *entries; + git_config_list *config_list; const git_repository *repo; git_config_level_t level; @@ -50,13 +50,13 @@ typedef struct { typedef struct { const git_repository *repo; config_file *file; - git_config_entries *entries; + git_config_list *config_list; git_config_level_t level; unsigned int depth; } config_file_parse_data; -static int config_file_read(git_config_entries *entries, const git_repository *repo, config_file *file, git_config_level_t level, int depth); -static int config_file_read_buffer(git_config_entries *entries, const git_repository *repo, config_file *file, git_config_level_t level, int depth, const char *buf, size_t buflen); +static int config_file_read(git_config_list *config_list, const git_repository *repo, config_file *file, git_config_level_t level, int depth); +static int config_file_read_buffer(git_config_list *config_list, const git_repository *repo, config_file *file, git_config_level_t level, int depth, const char *buf, size_t buflen); static int config_file_write(config_file_backend *cfg, const char *orig_key, const char *key, const git_regexp *preg, const char *value); static char *escape_value(const char *ptr); @@ -65,7 +65,7 @@ static char *escape_value(const char *ptr); * refcount. This is its own function to make sure we use the mutex to * avoid the map pointer from changing under us. */ -static int config_file_entries_take(git_config_entries **out, config_file_backend *b) +static int config_file_take_list(git_config_list **out, config_file_backend *b) { int error; @@ -74,8 +74,8 @@ static int config_file_entries_take(git_config_entries **out, config_file_backen return error; } - git_config_entries_incref(b->entries); - *out = b->entries; + git_config_list_incref(b->config_list); + *out = b->config_list; git_mutex_unlock(&b->values_mutex); @@ -106,7 +106,7 @@ static int config_file_open(git_config_backend *cfg, git_config_level_t level, c b->level = level; b->repo = repo; - if ((res = git_config_entries_new(&b->entries)) < 0) + if ((res = git_config_list_new(&b->config_list)) < 0) return res; if (!git_fs_path_exists(b->file.path)) @@ -121,9 +121,9 @@ static int config_file_open(git_config_backend *cfg, git_config_level_t level, c if (p_access(b->file.path, R_OK) < 0) return GIT_ENOTFOUND; - if (res < 0 || (res = config_file_read(b->entries, repo, &b->file, level, 0)) < 0) { - git_config_entries_free(b->entries); - b->entries = NULL; + if (res < 0 || (res = config_file_read(b->config_list, repo, &b->file, level, 0)) < 0) { + git_config_list_free(b->config_list); + b->config_list = NULL; } return res; @@ -175,10 +175,10 @@ static void config_file_clear_includes(config_file_backend *cfg) git_array_clear(cfg->file.includes); } -static int config_file_set_entries(git_config_backend *cfg, git_config_entries *entries) +static int config_file_set_entries(git_config_backend *cfg, git_config_list *config_list) { config_file_backend *b = GIT_CONTAINER_OF(cfg, config_file_backend, parent); - git_config_entries *old = NULL; + git_config_list *old = NULL; int error; if (b->parent.readonly) { @@ -191,40 +191,40 @@ static int config_file_set_entries(git_config_backend *cfg, git_config_entries * goto out; } - old = b->entries; - b->entries = entries; + old = b->config_list; + b->config_list = config_list; git_mutex_unlock(&b->values_mutex); out: - git_config_entries_free(old); + git_config_list_free(old); return error; } static int config_file_refresh_from_buffer(git_config_backend *cfg, const char *buf, size_t buflen) { config_file_backend *b = GIT_CONTAINER_OF(cfg, config_file_backend, parent); - git_config_entries *entries = NULL; + git_config_list *config_list = NULL; int error; config_file_clear_includes(b); - if ((error = git_config_entries_new(&entries)) < 0 || - (error = config_file_read_buffer(entries, b->repo, &b->file, + if ((error = git_config_list_new(&config_list)) < 0 || + (error = config_file_read_buffer(config_list, b->repo, &b->file, b->level, 0, buf, buflen)) < 0 || - (error = config_file_set_entries(cfg, entries)) < 0) + (error = config_file_set_entries(cfg, config_list)) < 0) goto out; - entries = NULL; + config_list = NULL; out: - git_config_entries_free(entries); + git_config_list_free(config_list); return error; } static int config_file_refresh(git_config_backend *cfg) { config_file_backend *b = GIT_CONTAINER_OF(cfg, config_file_backend, parent); - git_config_entries *entries = NULL; + git_config_list *config_list = NULL; int error, modified; if (cfg->readonly) @@ -238,14 +238,14 @@ static int config_file_refresh(git_config_backend *cfg) config_file_clear_includes(b); - if ((error = git_config_entries_new(&entries)) < 0 || - (error = config_file_read(entries, b->repo, &b->file, b->level, 0)) < 0 || - (error = config_file_set_entries(cfg, entries)) < 0) + if ((error = git_config_list_new(&config_list)) < 0 || + (error = config_file_read(config_list, b->repo, &b->file, b->level, 0)) < 0 || + (error = config_file_set_entries(cfg, config_list)) < 0) goto out; - entries = NULL; + config_list = NULL; out: - git_config_entries_free(entries); + git_config_list_free(config_list); return (error == GIT_ENOTFOUND) ? 0 : error; } @@ -258,7 +258,7 @@ static void config_file_free(git_config_backend *_backend) return; config_file_clear(&backend->file); - git_config_entries_free(backend->entries); + git_config_list_free(backend->config_list); git_mutex_free(&backend->values_mutex); git__free(backend); } @@ -268,19 +268,19 @@ static int config_file_iterator( struct git_config_backend *backend) { config_file_backend *b = GIT_CONTAINER_OF(backend, config_file_backend, parent); - git_config_entries *dupped = NULL, *entries = NULL; + git_config_list *dupped = NULL, *config_list = NULL; int error; if ((error = config_file_refresh(backend)) < 0 || - (error = config_file_entries_take(&entries, b)) < 0 || - (error = git_config_entries_dup(&dupped, entries)) < 0 || - (error = git_config_entries_iterator_new(iter, dupped)) < 0) + (error = config_file_take_list(&config_list, b)) < 0 || + (error = git_config_list_dup(&dupped, config_list)) < 0 || + (error = git_config_list_iterator_new(iter, dupped)) < 0) goto out; out: - /* Let iterator delete duplicated entries when it's done */ - git_config_entries_free(entries); - git_config_entries_free(dupped); + /* Let iterator delete duplicated config_list when it's done */ + git_config_list_free(config_list); + git_config_list_free(dupped); return error; } @@ -292,7 +292,7 @@ static int config_file_snapshot(git_config_backend **out, git_config_backend *ba static int config_file_set(git_config_backend *cfg, const char *name, const char *value) { config_file_backend *b = GIT_CONTAINER_OF(cfg, config_file_backend, parent); - git_config_entries *entries; + git_config_list *config_list; git_config_entry *existing; char *key, *esc_value = NULL; int error; @@ -300,11 +300,11 @@ static int config_file_set(git_config_backend *cfg, const char *name, const char if ((error = git_config__normalize_name(name, &key)) < 0) return error; - if ((error = config_file_entries_take(&entries, b)) < 0) + if ((error = config_file_take_list(&config_list, b)) < 0) return error; /* Check whether we'd be modifying an included or multivar key */ - if ((error = git_config_entries_get_unique(&existing, entries, key)) < 0) { + if ((error = git_config_list_get_unique(&existing, config_list, key)) < 0) { if (error != GIT_ENOTFOUND) goto out; error = 0; @@ -325,7 +325,7 @@ static int config_file_set(git_config_backend *cfg, const char *name, const char goto out; out: - git_config_entries_free(entries); + git_config_list_free(config_list); git__free(esc_value); git__free(key); return error; @@ -334,8 +334,8 @@ static int config_file_set(git_config_backend *cfg, const char *name, const char /* release the map containing the entry as an equivalent to freeing it */ static void config_file_entry_free(git_config_entry *entry) { - git_config_entries *entries = (git_config_entries *) entry->payload; - git_config_entries_free(entries); + git_config_list *config_list = (git_config_list *) entry->payload; + git_config_list_free(config_list); } /* @@ -344,18 +344,18 @@ static void config_file_entry_free(git_config_entry *entry) static int config_file_get(git_config_backend *cfg, const char *key, git_config_entry **out) { config_file_backend *h = GIT_CONTAINER_OF(cfg, config_file_backend, parent); - git_config_entries *entries = NULL; + git_config_list *config_list = NULL; git_config_entry *entry; int error = 0; if (!h->parent.readonly && ((error = config_file_refresh(cfg)) < 0)) return error; - if ((error = config_file_entries_take(&entries, h)) < 0) + if ((error = config_file_take_list(&config_list, h)) < 0) return error; - if ((error = (git_config_entries_get(&entry, entries, key))) < 0) { - git_config_entries_free(entries); + if ((error = (git_config_list_get(&entry, config_list, key))) < 0) { + git_config_list_free(config_list); return error; } @@ -394,7 +394,7 @@ static int config_file_set_multivar( static int config_file_delete(git_config_backend *cfg, const char *name) { config_file_backend *b = GIT_CONTAINER_OF(cfg, config_file_backend, parent); - git_config_entries *entries = NULL; + git_config_list *config_list = NULL; git_config_entry *entry; char *key = NULL; int error; @@ -402,11 +402,11 @@ static int config_file_delete(git_config_backend *cfg, const char *name) if ((error = git_config__normalize_name(name, &key)) < 0) goto out; - if ((error = config_file_entries_take(&entries, b)) < 0) + if ((error = config_file_take_list(&config_list, b)) < 0) goto out; /* Check whether we'd be modifying an included or multivar key */ - if ((error = git_config_entries_get_unique(&entry, entries, key)) < 0) { + if ((error = git_config_list_get_unique(&entry, config_list, key)) < 0) { if (error == GIT_ENOTFOUND) git_error_set(GIT_ERROR_CONFIG, "could not find key '%s' to delete", name); goto out; @@ -416,7 +416,7 @@ static int config_file_delete(git_config_backend *cfg, const char *name) goto out; out: - git_config_entries_free(entries); + git_config_list_free(config_list); git__free(key); return error; } @@ -424,7 +424,7 @@ static int config_file_delete(git_config_backend *cfg, const char *name) static int config_file_delete_multivar(git_config_backend *cfg, const char *name, const char *regexp) { config_file_backend *b = GIT_CONTAINER_OF(cfg, config_file_backend, parent); - git_config_entries *entries = NULL; + git_config_list *config_list = NULL; git_config_entry *entry = NULL; git_regexp preg = GIT_REGEX_INIT; char *key = NULL; @@ -433,10 +433,10 @@ static int config_file_delete_multivar(git_config_backend *cfg, const char *name if ((result = git_config__normalize_name(name, &key)) < 0) goto out; - if ((result = config_file_entries_take(&entries, b)) < 0) + if ((result = config_file_take_list(&config_list, b)) < 0) goto out; - if ((result = git_config_entries_get(&entry, entries, key)) < 0) { + if ((result = git_config_list_get(&entry, config_list, key)) < 0) { if (result == GIT_ENOTFOUND) git_error_set(GIT_ERROR_CONFIG, "could not find key '%s' to delete", name); goto out; @@ -449,7 +449,7 @@ static int config_file_delete_multivar(git_config_backend *cfg, const char *name goto out; out: - git_config_entries_free(entries); + git_config_list_free(config_list); git__free(key); git_regexp_dispose(&preg); return result; @@ -589,7 +589,7 @@ static int parse_include(config_file_parse_data *parse_data, const char *file) git_array_init(include->includes); include->path = git_str_detach(&path); - result = config_file_read(parse_data->entries, parse_data->repo, include, + result = config_file_read(parse_data->config_list, parse_data->repo, include, parse_data->level, parse_data->depth+1); if (result == GIT_ENOTFOUND) { @@ -804,9 +804,9 @@ static int read_on_variable( entry->level = parse_data->level; entry->include_depth = parse_data->depth; entry->free = config_file_entry_free; - entry->payload = parse_data->entries; + entry->payload = parse_data->config_list; - if ((result = git_config_entries_append(parse_data->entries, entry)) < 0) + if ((result = git_config_list_append(parse_data->config_list, entry)) < 0) return result; result = 0; @@ -822,7 +822,7 @@ static int read_on_variable( } static int config_file_read_buffer( - git_config_entries *entries, + git_config_list *config_list, const git_repository *repo, config_file *file, git_config_level_t level, @@ -851,7 +851,7 @@ static int config_file_read_buffer( parse_data.repo = repo; parse_data.file = file; - parse_data.entries = entries; + parse_data.config_list = config_list; parse_data.level = level; parse_data.depth = depth; @@ -862,7 +862,7 @@ static int config_file_read_buffer( } static int config_file_read( - git_config_entries *entries, + git_config_list *config_list, const git_repository *repo, config_file *file, git_config_level_t level, @@ -884,7 +884,7 @@ static int config_file_read( if ((error = git_hash_buf(file->checksum, contents.ptr, contents.size, GIT_HASH_ALGORITHM_SHA256)) < 0) goto out; - if ((error = config_file_read_buffer(entries, repo, file, level, depth, + if ((error = config_file_read_buffer(config_list, repo, file, level, depth, contents.ptr, contents.size)) < 0) goto out; diff --git a/src/libgit2/config_entries.c b/src/libgit2/config_list.c similarity index 50% rename from src/libgit2/config_entries.c rename to src/libgit2/config_list.c index 66aae096d2d..01d41526e98 100644 --- a/src/libgit2/config_entries.c +++ b/src/libgit2/config_list.c @@ -5,7 +5,7 @@ * a Linking Exception. For full terms see the included COPYING file. */ -#include "config_entries.h" +#include "config_list.h" typedef struct config_entry_list { struct config_entry_list *next; @@ -18,36 +18,36 @@ typedef struct { bool multivar; } config_entry_map_head; -typedef struct config_entries_iterator { +typedef struct config_list_iterator { git_config_iterator parent; - git_config_entries *entries; + git_config_list *list; config_entry_list *head; -} config_entries_iterator; +} config_list_iterator; -struct git_config_entries { +struct git_config_list { git_refcount rc; git_strmap *map; - config_entry_list *list; + config_entry_list *entries; }; -int git_config_entries_new(git_config_entries **out) +int git_config_list_new(git_config_list **out) { - git_config_entries *entries; + git_config_list *config_list; int error; - entries = git__calloc(1, sizeof(git_config_entries)); - GIT_ERROR_CHECK_ALLOC(entries); - GIT_REFCOUNT_INC(entries); + config_list = git__calloc(1, sizeof(git_config_list)); + GIT_ERROR_CHECK_ALLOC(config_list); + GIT_REFCOUNT_INC(config_list); - if ((error = git_strmap_new(&entries->map)) < 0) - git__free(entries); + if ((error = git_strmap_new(&config_list->map)) < 0) + git__free(config_list); else - *out = entries; + *out = config_list; return error; } -int git_config_entries_dup_entry(git_config_entries *entries, const git_config_entry *entry) +int git_config_list_dup_entry(git_config_list *config_list, const git_config_entry *entry) { git_config_entry *duplicated; int error; @@ -65,7 +65,7 @@ int git_config_entries_dup_entry(git_config_entries *entries, const git_config_e duplicated->level = entry->level; duplicated->include_depth = entry->include_depth; - if ((error = git_config_entries_append(entries, duplicated)) < 0) + if ((error = git_config_list_append(config_list, duplicated)) < 0) goto out; out: @@ -77,78 +77,79 @@ int git_config_entries_dup_entry(git_config_entries *entries, const git_config_e return error; } -int git_config_entries_dup(git_config_entries **out, git_config_entries *entries) +int git_config_list_dup(git_config_list **out, git_config_list *config_list) { - git_config_entries *result = NULL; + git_config_list *result = NULL; config_entry_list *head; int error; - if ((error = git_config_entries_new(&result)) < 0) + if ((error = git_config_list_new(&result)) < 0) goto out; - for (head = entries->list; head; head = head->next) - if ((git_config_entries_dup_entry(result, head->entry)) < 0) + for (head = config_list->entries; head; head = head->next) + if ((git_config_list_dup_entry(result, head->entry)) < 0) goto out; *out = result; result = NULL; out: - git_config_entries_free(result); + git_config_list_free(result); return error; } -void git_config_entries_incref(git_config_entries *entries) +void git_config_list_incref(git_config_list *config_list) { - GIT_REFCOUNT_INC(entries); + GIT_REFCOUNT_INC(config_list); } -static void config_entries_free(git_config_entries *entries) +static void config_list_free(git_config_list *config_list) { - config_entry_list *list = NULL, *next; + config_entry_list *entry_list = NULL, *next; config_entry_map_head *head; - git_strmap_foreach_value(entries->map, head, - git__free((char *) head->entry->name); git__free(head) - ); - git_strmap_free(entries->map); - - list = entries->list; - while (list != NULL) { - next = list->next; - git__free((char *) list->entry->value); - git__free(list->entry); - git__free(list); - list = next; + git_strmap_foreach_value(config_list->map, head, { + git__free((char *) head->entry->name); + git__free(head); + }); + git_strmap_free(config_list->map); + + entry_list = config_list->entries; + while (entry_list != NULL) { + next = entry_list->next; + git__free((char *) entry_list->entry->value); + git__free(entry_list->entry); + git__free(entry_list); + entry_list = next; } - git__free(entries); + git__free(config_list); } -void git_config_entries_free(git_config_entries *entries) +void git_config_list_free(git_config_list *config_list) { - if (entries) - GIT_REFCOUNT_DEC(entries, config_entries_free); + if (config_list) + GIT_REFCOUNT_DEC(config_list, config_list_free); } -int git_config_entries_append(git_config_entries *entries, git_config_entry *entry) +int git_config_list_append(git_config_list *config_list, git_config_entry *entry) { config_entry_list *list_head; config_entry_map_head *map_head; - if ((map_head = git_strmap_get(entries->map, entry->name)) != NULL) { + if ((map_head = git_strmap_get(config_list->map, entry->name)) != NULL) { map_head->multivar = true; /* * This is a micro-optimization for configuration files * with a lot of same keys. As for multivars the entry's - * key will be the same for all entries, we can just free + * key will be the same for all list, we can just free * all except the first entry's name and just re-use it. */ git__free((char *) entry->name); entry->name = map_head->entry->name; } else { map_head = git__calloc(1, sizeof(*map_head)); - if ((git_strmap_set(entries->map, entry->name, map_head)) < 0) + if ((git_strmap_set(config_list->map, entry->name, map_head)) < 0) return -1; } map_head->entry = entry; @@ -157,29 +158,29 @@ int git_config_entries_append(git_config_entries *entries, git_config_entry *ent GIT_ERROR_CHECK_ALLOC(list_head); list_head->entry = entry; - if (entries->list) - entries->list->last->next = list_head; + if (config_list->entries) + config_list->entries->last->next = list_head; else - entries->list = list_head; - entries->list->last = list_head; + config_list->entries = list_head; + config_list->entries->last = list_head; return 0; } -int git_config_entries_get(git_config_entry **out, git_config_entries *entries, const char *key) +int git_config_list_get(git_config_entry **out, git_config_list *config_list, const char *key) { config_entry_map_head *entry; - if ((entry = git_strmap_get(entries->map, key)) == NULL) + if ((entry = git_strmap_get(config_list->map, key)) == NULL) return GIT_ENOTFOUND; *out = entry->entry; return 0; } -int git_config_entries_get_unique(git_config_entry **out, git_config_entries *entries, const char *key) +int git_config_list_get_unique(git_config_entry **out, git_config_list *config_list, const char *key) { config_entry_map_head *entry; - if ((entry = git_strmap_get(entries->map, key)) == NULL) + if ((entry = git_strmap_get(config_list->map, key)) == NULL) return GIT_ENOTFOUND; if (entry->multivar) { @@ -199,8 +200,8 @@ int git_config_entries_get_unique(git_config_entry **out, git_config_entries *en static void config_iterator_free(git_config_iterator *iter) { - config_entries_iterator *it = (config_entries_iterator *) iter; - git_config_entries_free(it->entries); + config_list_iterator *it = (config_list_iterator *) iter; + git_config_list_free(it->list); git__free(it); } @@ -208,7 +209,7 @@ static int config_iterator_next( git_config_entry **entry, git_config_iterator *iter) { - config_entries_iterator *it = (config_entries_iterator *) iter; + config_list_iterator *it = (config_list_iterator *) iter; if (!it->head) return GIT_ITEROVER; @@ -219,18 +220,18 @@ static int config_iterator_next( return 0; } -int git_config_entries_iterator_new(git_config_iterator **out, git_config_entries *entries) +int git_config_list_iterator_new(git_config_iterator **out, git_config_list *config_list) { - config_entries_iterator *it; + config_list_iterator *it; - it = git__calloc(1, sizeof(config_entries_iterator)); + it = git__calloc(1, sizeof(config_list_iterator)); GIT_ERROR_CHECK_ALLOC(it); it->parent.next = config_iterator_next; it->parent.free = config_iterator_free; - it->head = entries->list; - it->entries = entries; + it->head = config_list->entries; + it->list = config_list; - git_config_entries_incref(entries); + git_config_list_incref(config_list); *out = &it->parent; return 0; diff --git a/src/libgit2/config_list.h b/src/libgit2/config_list.h new file mode 100644 index 00000000000..e14e4aed023 --- /dev/null +++ b/src/libgit2/config_list.h @@ -0,0 +1,24 @@ +/* + * Copyright (C) the libgit2 contributors. All rights reserved. + * + * This file is part of libgit2, distributed under the GNU GPL v2 with + * a Linking Exception. For full terms see the included COPYING file. + */ + +#include "common.h" + +#include "git2/sys/config.h" +#include "config.h" + +typedef struct git_config_list git_config_list; + +int git_config_list_new(git_config_list **out); +int git_config_list_dup(git_config_list **out, git_config_list *list); +int git_config_list_dup_entry(git_config_list *list, const git_config_entry *entry); +void git_config_list_incref(git_config_list *list); +void git_config_list_free(git_config_list *list); +/* Add or append the new config option */ +int git_config_list_append(git_config_list *list, git_config_entry *entry); +int git_config_list_get(git_config_entry **out, git_config_list *list, const char *key); +int git_config_list_get_unique(git_config_entry **out, git_config_list *list, const char *key); +int git_config_list_iterator_new(git_config_iterator **out, git_config_list *list); diff --git a/src/libgit2/config_mem.c b/src/libgit2/config_mem.c index 560229cf534..902bf99e6a3 100644 --- a/src/libgit2/config_mem.c +++ b/src/libgit2/config_mem.c @@ -9,16 +9,16 @@ #include "config_backend.h" #include "config_parse.h" -#include "config_entries.h" +#include "config_list.h" typedef struct { git_config_backend parent; - git_config_entries *entries; + git_config_list *config_list; git_str cfg; } config_memory_backend; typedef struct { - git_config_entries *entries; + git_config_list *config_list; git_config_level_t level; } config_memory_parse_data; @@ -69,7 +69,7 @@ static int read_variable_cb( entry->level = parse_data->level; entry->include_depth = 0; - if ((result = git_config_entries_append(parse_data->entries, entry)) < 0) + if ((result = git_config_list_append(parse_data->config_list, entry)) < 0) return result; return result; @@ -87,7 +87,7 @@ static int config_memory_open(git_config_backend *backend, git_config_level_t le if ((error = git_config_parser_init(&parser, "in-memory", memory_backend->cfg.ptr, memory_backend->cfg.size)) < 0) goto out; - parse_data.entries = memory_backend->entries; + parse_data.config_list = memory_backend->config_list; parse_data.level = level; if ((error = git_config_parse(&parser, NULL, read_variable_cb, NULL, NULL, &parse_data)) < 0) @@ -101,7 +101,7 @@ static int config_memory_open(git_config_backend *backend, git_config_level_t le static int config_memory_get(git_config_backend *backend, const char *key, git_config_entry **out) { config_memory_backend *memory_backend = (config_memory_backend *) backend; - return git_config_entries_get(out, memory_backend->entries, key); + return git_config_list_get(out, memory_backend->config_list, key); } static int config_memory_iterator( @@ -109,18 +109,18 @@ static int config_memory_iterator( git_config_backend *backend) { config_memory_backend *memory_backend = (config_memory_backend *) backend; - git_config_entries *entries; + git_config_list *config_list; int error; - if ((error = git_config_entries_dup(&entries, memory_backend->entries)) < 0) + if ((error = git_config_list_dup(&config_list, memory_backend->config_list)) < 0) goto out; - if ((error = git_config_entries_iterator_new(iter, entries)) < 0) + if ((error = git_config_list_iterator_new(iter, config_list)) < 0) goto out; out: - /* Let iterator delete duplicated entries when it's done */ - git_config_entries_free(entries); + /* Let iterator delete duplicated config_list when it's done */ + git_config_list_free(config_list); return error; } @@ -177,7 +177,7 @@ static void config_memory_free(git_config_backend *_backend) if (backend == NULL) return; - git_config_entries_free(backend->entries); + git_config_list_free(backend->config_list); git_str_dispose(&backend->cfg); git__free(backend); } @@ -189,13 +189,13 @@ int git_config_backend_from_string(git_config_backend **out, const char *cfg, si backend = git__calloc(1, sizeof(config_memory_backend)); GIT_ERROR_CHECK_ALLOC(backend); - if (git_config_entries_new(&backend->entries) < 0) { + if (git_config_list_new(&backend->config_list) < 0) { git__free(backend); return -1; } if (git_str_set(&backend->cfg, cfg, len) < 0) { - git_config_entries_free(backend->entries); + git_config_list_free(backend->config_list); git__free(backend); return -1; } diff --git a/src/libgit2/config_snapshot.c b/src/libgit2/config_snapshot.c index e295d2f7f28..dbd05ffdce7 100644 --- a/src/libgit2/config_snapshot.c +++ b/src/libgit2/config_snapshot.c @@ -8,12 +8,12 @@ #include "config_backend.h" #include "config.h" -#include "config_entries.h" +#include "config_list.h" typedef struct { git_config_backend parent; git_mutex values_mutex; - git_config_entries *entries; + git_config_list *config_list; git_config_backend *source; } config_snapshot_backend; @@ -28,30 +28,30 @@ static int config_snapshot_iterator( struct git_config_backend *backend) { config_snapshot_backend *b = GIT_CONTAINER_OF(backend, config_snapshot_backend, parent); - git_config_entries *entries = NULL; + git_config_list *config_list = NULL; int error; - if ((error = git_config_entries_dup(&entries, b->entries)) < 0 || - (error = git_config_entries_iterator_new(iter, entries)) < 0) + if ((error = git_config_list_dup(&config_list, b->config_list)) < 0 || + (error = git_config_list_iterator_new(iter, config_list)) < 0) goto out; out: - /* Let iterator delete duplicated entries when it's done */ - git_config_entries_free(entries); + /* Let iterator delete duplicated config_list when it's done */ + git_config_list_free(config_list); return error; } /* release the map containing the entry as an equivalent to freeing it */ static void config_snapshot_entry_free(git_config_entry *entry) { - git_config_entries *entries = (git_config_entries *) entry->payload; - git_config_entries_free(entries); + git_config_list *config_list = (git_config_list *) entry->payload; + git_config_list_free(config_list); } static int config_snapshot_get(git_config_backend *cfg, const char *key, git_config_entry **out) { config_snapshot_backend *b = GIT_CONTAINER_OF(cfg, config_snapshot_backend, parent); - git_config_entries *entries = NULL; + git_config_list *config_list = NULL; git_config_entry *entry; int error = 0; @@ -60,17 +60,17 @@ static int config_snapshot_get(git_config_backend *cfg, const char *key, git_con return -1; } - entries = b->entries; - git_config_entries_incref(entries); + config_list = b->config_list; + git_config_list_incref(config_list); git_mutex_unlock(&b->values_mutex); - if ((error = (git_config_entries_get(&entry, entries, key))) < 0) { - git_config_entries_free(entries); + if ((error = (git_config_list_get(&entry, config_list, key))) < 0) { + git_config_list_free(config_list); return error; } entry->free = config_snapshot_entry_free; - entry->payload = entries; + entry->payload = config_list; *out = entry; return 0; @@ -135,7 +135,7 @@ static void config_snapshot_free(git_config_backend *_backend) if (backend == NULL) return; - git_config_entries_free(backend->entries); + git_config_list_free(backend->config_list); git_mutex_free(&backend->values_mutex); git__free(backend); } @@ -143,7 +143,7 @@ static void config_snapshot_free(git_config_backend *_backend) static int config_snapshot_open(git_config_backend *cfg, git_config_level_t level, const git_repository *repo) { config_snapshot_backend *b = GIT_CONTAINER_OF(cfg, config_snapshot_backend, parent); - git_config_entries *entries = NULL; + git_config_list *config_list = NULL; git_config_iterator *it = NULL; git_config_entry *entry; int error; @@ -152,12 +152,12 @@ static int config_snapshot_open(git_config_backend *cfg, git_config_level_t leve GIT_UNUSED(level); GIT_UNUSED(repo); - if ((error = git_config_entries_new(&entries)) < 0 || + if ((error = git_config_list_new(&config_list)) < 0 || (error = b->source->iterator(&it, b->source)) < 0) goto out; while ((error = git_config_next(&entry, it)) == 0) - if ((error = git_config_entries_dup_entry(entries, entry)) < 0) + if ((error = git_config_list_dup_entry(config_list, entry)) < 0) goto out; if (error < 0) { @@ -166,12 +166,12 @@ static int config_snapshot_open(git_config_backend *cfg, git_config_level_t leve error = 0; } - b->entries = entries; + b->config_list = config_list; out: git_config_iterator_free(it); if (error) - git_config_entries_free(entries); + git_config_list_free(config_list); return error; } From 5f7c18d7331c2326cbaecf5ce1487998e89c7489 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Wed, 19 Jul 2023 12:50:16 +0100 Subject: [PATCH 309/608] config: drop entry payload; teach config_list about entries The opaque `payload` on an entry is unnecessary and distracting; config entries should follow the patterns of other objects and use space elsewhere in the structure with a "base" config entry struct embedded. --- include/git2/config.h | 8 +++-- src/libgit2/config_file.c | 56 ++++++++++++++++---------------- src/libgit2/config_list.c | 61 +++++++++++++++++++++-------------- src/libgit2/config_list.h | 13 ++++++-- src/libgit2/config_mem.c | 23 +++++++++---- src/libgit2/config_snapshot.c | 14 ++------ 6 files changed, 98 insertions(+), 77 deletions(-) diff --git a/include/git2/config.h b/include/git2/config.h index cfab0c75739..155a2996205 100644 --- a/include/git2/config.h +++ b/include/git2/config.h @@ -66,8 +66,12 @@ typedef struct git_config_entry { const char *value; /**< String value of the entry */ unsigned int include_depth; /**< Depth of includes where this variable was found */ git_config_level_t level; /**< Which config file this was found in */ - void GIT_CALLBACK(free)(struct git_config_entry *entry); /**< Free function for this entry */ - void *payload; /**< Opaque value for the free function. Do not read or write */ + + /** + * Free function for this entry; for internal purposes. Callers + * should call `git_config_entry_free` to free data. + */ + void GIT_CALLBACK(free)(struct git_config_entry *entry); } git_config_entry; /** diff --git a/src/libgit2/config_file.c b/src/libgit2/config_file.c index 41241f1b0f5..46ef07533b6 100644 --- a/src/libgit2/config_file.c +++ b/src/libgit2/config_file.c @@ -293,7 +293,7 @@ static int config_file_set(git_config_backend *cfg, const char *name, const char { config_file_backend *b = GIT_CONTAINER_OF(cfg, config_file_backend, parent); git_config_list *config_list; - git_config_entry *existing; + git_config_list_entry *existing; char *key, *esc_value = NULL; int error; @@ -308,8 +308,8 @@ static int config_file_set(git_config_backend *cfg, const char *name, const char if (error != GIT_ENOTFOUND) goto out; error = 0; - } else if ((!existing->value && !value) || - (existing->value && value && !strcmp(existing->value, value))) { + } else if ((!existing->base.value && !value) || + (existing->base.value && value && !strcmp(existing->base.value, value))) { /* don't update if old and new values already match */ error = 0; goto out; @@ -331,13 +331,6 @@ static int config_file_set(git_config_backend *cfg, const char *name, const char return error; } -/* release the map containing the entry as an equivalent to freeing it */ -static void config_file_entry_free(git_config_entry *entry) -{ - git_config_list *config_list = (git_config_list *) entry->payload; - git_config_list_free(config_list); -} - /* * Internal function that actually gets the value in string form */ @@ -345,7 +338,7 @@ static int config_file_get(git_config_backend *cfg, const char *key, git_config_ { config_file_backend *h = GIT_CONTAINER_OF(cfg, config_file_backend, parent); git_config_list *config_list = NULL; - git_config_entry *entry; + git_config_list_entry *entry; int error = 0; if (!h->parent.readonly && ((error = config_file_refresh(cfg)) < 0)) @@ -359,7 +352,7 @@ static int config_file_get(git_config_backend *cfg, const char *key, git_config_ return error; } - *out = entry; + *out = &entry->base; return 0; } @@ -395,7 +388,7 @@ static int config_file_delete(git_config_backend *cfg, const char *name) { config_file_backend *b = GIT_CONTAINER_OF(cfg, config_file_backend, parent); git_config_list *config_list = NULL; - git_config_entry *entry; + git_config_list_entry *entry; char *key = NULL; int error; @@ -412,7 +405,7 @@ static int config_file_delete(git_config_backend *cfg, const char *name) goto out; } - if ((error = config_file_write(b, name, entry->name, NULL, NULL)) < 0) + if ((error = config_file_write(b, name, entry->base.name, NULL, NULL)) < 0) goto out; out: @@ -425,7 +418,7 @@ static int config_file_delete_multivar(git_config_backend *cfg, const char *name { config_file_backend *b = GIT_CONTAINER_OF(cfg, config_file_backend, parent); git_config_list *config_list = NULL; - git_config_entry *entry = NULL; + git_config_list_entry *entry = NULL; git_regexp preg = GIT_REGEX_INIT; char *key = NULL; int result; @@ -774,7 +767,7 @@ static int read_on_variable( { config_file_parse_data *parse_data = (config_file_parse_data *)data; git_str buf = GIT_STR_INIT; - git_config_entry *entry; + git_config_list_entry *entry; const char *c; int result = 0; @@ -797,14 +790,21 @@ static int read_on_variable( if (git_str_oom(&buf)) return -1; - entry = git__calloc(1, sizeof(git_config_entry)); + entry = git__calloc(1, sizeof(git_config_list_entry)); GIT_ERROR_CHECK_ALLOC(entry); - entry->name = git_str_detach(&buf); - entry->value = var_value ? git__strdup(var_value) : NULL; - entry->level = parse_data->level; - entry->include_depth = parse_data->depth; - entry->free = config_file_entry_free; - entry->payload = parse_data->config_list; + + entry->base.name = git_str_detach(&buf); + GIT_ERROR_CHECK_ALLOC(entry->base.name); + + if (var_value) { + entry->base.value = git__strdup(var_value); + GIT_ERROR_CHECK_ALLOC(entry->base.value); + } + + entry->base.level = parse_data->level; + entry->base.include_depth = parse_data->depth; + entry->base.free = git_config_list_entry_free; + entry->config_list = parse_data->config_list; if ((result = git_config_list_append(parse_data->config_list, entry)) < 0) return result; @@ -812,11 +812,11 @@ static int read_on_variable( result = 0; /* Add or append the new config option */ - if (!git__strcmp(entry->name, "include.path")) - result = parse_include(parse_data, entry->value); - else if (!git__prefixcmp(entry->name, "includeif.") && - !git__suffixcmp(entry->name, ".path")) - result = parse_conditional_include(parse_data, entry->name, entry->value); + if (!git__strcmp(entry->base.name, "include.path")) + result = parse_include(parse_data, entry->base.value); + else if (!git__prefixcmp(entry->base.name, "includeif.") && + !git__suffixcmp(entry->base.name, ".path")) + result = parse_conditional_include(parse_data, entry->base.name, entry->base.value); return result; } diff --git a/src/libgit2/config_list.c b/src/libgit2/config_list.c index 01d41526e98..979c6ccff99 100644 --- a/src/libgit2/config_list.c +++ b/src/libgit2/config_list.c @@ -10,11 +10,11 @@ typedef struct config_entry_list { struct config_entry_list *next; struct config_entry_list *last; - git_config_entry *entry; + git_config_list_entry *entry; } config_entry_list; typedef struct { - git_config_entry *entry; + git_config_list_entry *entry; bool multivar; } config_entry_map_head; @@ -49,29 +49,32 @@ int git_config_list_new(git_config_list **out) int git_config_list_dup_entry(git_config_list *config_list, const git_config_entry *entry) { - git_config_entry *duplicated; + git_config_list_entry *duplicated; int error; - duplicated = git__calloc(1, sizeof(git_config_entry)); + duplicated = git__calloc(1, sizeof(git_config_list_entry)); GIT_ERROR_CHECK_ALLOC(duplicated); - duplicated->name = git__strdup(entry->name); - GIT_ERROR_CHECK_ALLOC(duplicated->name); + duplicated->base.name = git__strdup(entry->name); + GIT_ERROR_CHECK_ALLOC(duplicated->base.name); if (entry->value) { - duplicated->value = git__strdup(entry->value); - GIT_ERROR_CHECK_ALLOC(duplicated->value); + duplicated->base.value = git__strdup(entry->value); + GIT_ERROR_CHECK_ALLOC(duplicated->base.value); } - duplicated->level = entry->level; - duplicated->include_depth = entry->include_depth; + + duplicated->base.level = entry->level; + duplicated->base.include_depth = entry->include_depth; + duplicated->base.free = git_config_list_entry_free; + duplicated->config_list = config_list; if ((error = git_config_list_append(config_list, duplicated)) < 0) goto out; out: if (error && duplicated) { - git__free((char *) duplicated->name); - git__free((char *) duplicated->value); + git__free((char *) duplicated->base.name); + git__free((char *) duplicated->base.value); git__free(duplicated); } return error; @@ -87,7 +90,7 @@ int git_config_list_dup(git_config_list **out, git_config_list *config_list) goto out; for (head = config_list->entries; head; head = head->next) - if ((git_config_list_dup_entry(result, head->entry)) < 0) + if ((git_config_list_dup_entry(result, &head->entry->base)) < 0) goto out; *out = result; @@ -109,7 +112,7 @@ static void config_list_free(git_config_list *config_list) config_entry_map_head *head; git_strmap_foreach_value(config_list->map, head, { - git__free((char *) head->entry->name); + git__free((char *) head->entry->base.name); git__free(head); }); git_strmap_free(config_list->map); @@ -117,7 +120,7 @@ static void config_list_free(git_config_list *config_list) entry_list = config_list->entries; while (entry_list != NULL) { next = entry_list->next; - git__free((char *) entry_list->entry->value); + git__free((char *) entry_list->entry->base.value); git__free(entry_list->entry); git__free(entry_list); entry_list = next; @@ -132,12 +135,12 @@ void git_config_list_free(git_config_list *config_list) GIT_REFCOUNT_DEC(config_list, config_list_free); } -int git_config_list_append(git_config_list *config_list, git_config_entry *entry) +int git_config_list_append(git_config_list *config_list, git_config_list_entry *entry) { config_entry_list *list_head; config_entry_map_head *map_head; - if ((map_head = git_strmap_get(config_list->map, entry->name)) != NULL) { + if ((map_head = git_strmap_get(config_list->map, entry->base.name)) != NULL) { map_head->multivar = true; /* * This is a micro-optimization for configuration files @@ -145,11 +148,11 @@ int git_config_list_append(git_config_list *config_list, git_config_entry *entry * key will be the same for all list, we can just free * all except the first entry's name and just re-use it. */ - git__free((char *) entry->name); - entry->name = map_head->entry->name; + git__free((char *) entry->base.name); + entry->base.name = map_head->entry->base.name; } else { map_head = git__calloc(1, sizeof(*map_head)); - if ((git_strmap_set(config_list->map, entry->name, map_head)) < 0) + if ((git_strmap_set(config_list->map, entry->base.name, map_head)) < 0) return -1; } map_head->entry = entry; @@ -167,16 +170,18 @@ int git_config_list_append(git_config_list *config_list, git_config_entry *entry return 0; } -int git_config_list_get(git_config_entry **out, git_config_list *config_list, const char *key) +int git_config_list_get(git_config_list_entry **out, git_config_list *config_list, const char *key) { config_entry_map_head *entry; + if ((entry = git_strmap_get(config_list->map, key)) == NULL) return GIT_ENOTFOUND; + *out = entry->entry; return 0; } -int git_config_list_get_unique(git_config_entry **out, git_config_list *config_list, const char *key) +int git_config_list_get_unique(git_config_list_entry **out, git_config_list *config_list, const char *key) { config_entry_map_head *entry; @@ -188,13 +193,12 @@ int git_config_list_get_unique(git_config_entry **out, git_config_list *config_l return -1; } - if (entry->entry->include_depth) { + if (entry->entry->base.include_depth) { git_error_set(GIT_ERROR_CONFIG, "entry is not unique due to being included"); return -1; } *out = entry->entry; - return 0; } @@ -214,7 +218,7 @@ static int config_iterator_next( if (!it->head) return GIT_ITEROVER; - *entry = it->head->entry; + *entry = &it->head->entry->base; it->head = it->head->next; return 0; @@ -236,3 +240,10 @@ int git_config_list_iterator_new(git_config_iterator **out, git_config_list *con return 0; } + +/* release the map containing the entry as an equivalent to freeing it */ +void git_config_list_entry_free(git_config_entry *e) +{ + git_config_list_entry *entry = (git_config_list_entry *)e; + git_config_list_free(entry->config_list); +} diff --git a/src/libgit2/config_list.h b/src/libgit2/config_list.h index e14e4aed023..0cacabb110d 100644 --- a/src/libgit2/config_list.h +++ b/src/libgit2/config_list.h @@ -12,13 +12,20 @@ typedef struct git_config_list git_config_list; +typedef struct { + git_config_entry base; + git_config_list *config_list; +} git_config_list_entry; + int git_config_list_new(git_config_list **out); int git_config_list_dup(git_config_list **out, git_config_list *list); int git_config_list_dup_entry(git_config_list *list, const git_config_entry *entry); void git_config_list_incref(git_config_list *list); void git_config_list_free(git_config_list *list); /* Add or append the new config option */ -int git_config_list_append(git_config_list *list, git_config_entry *entry); -int git_config_list_get(git_config_entry **out, git_config_list *list, const char *key); -int git_config_list_get_unique(git_config_entry **out, git_config_list *list, const char *key); +int git_config_list_append(git_config_list *list, git_config_list_entry *entry); +int git_config_list_get(git_config_list_entry **out, git_config_list *list, const char *key); +int git_config_list_get_unique(git_config_list_entry **out, git_config_list *list, const char *key); int git_config_list_iterator_new(git_config_iterator **out, git_config_list *list); + +void git_config_list_entry_free(git_config_entry *entry); diff --git a/src/libgit2/config_mem.c b/src/libgit2/config_mem.c index 902bf99e6a3..37f5b01f983 100644 --- a/src/libgit2/config_mem.c +++ b/src/libgit2/config_mem.c @@ -39,7 +39,7 @@ static int read_variable_cb( { config_memory_parse_data *parse_data = (config_memory_parse_data *) payload; git_str buf = GIT_STR_INIT; - git_config_entry *entry; + git_config_list_entry *entry; const char *c; int result; @@ -62,12 +62,14 @@ static int read_variable_cb( if (git_str_oom(&buf)) return -1; - entry = git__calloc(1, sizeof(git_config_entry)); + entry = git__calloc(1, sizeof(git_config_list_entry)); GIT_ERROR_CHECK_ALLOC(entry); - entry->name = git_str_detach(&buf); - entry->value = var_value ? git__strdup(var_value) : NULL; - entry->level = parse_data->level; - entry->include_depth = 0; + entry->base.name = git_str_detach(&buf); + entry->base.value = var_value ? git__strdup(var_value) : NULL; + entry->base.level = parse_data->level; + entry->base.include_depth = 0; + entry->base.free = git_config_list_entry_free; + entry->config_list = parse_data->config_list; if ((result = git_config_list_append(parse_data->config_list, entry)) < 0) return result; @@ -101,7 +103,14 @@ static int config_memory_open(git_config_backend *backend, git_config_level_t le static int config_memory_get(git_config_backend *backend, const char *key, git_config_entry **out) { config_memory_backend *memory_backend = (config_memory_backend *) backend; - return git_config_list_get(out, memory_backend->config_list, key); + git_config_list_entry *entry; + int error; + + if ((error = git_config_list_get(&entry, memory_backend->config_list, key)) != 0) + return error; + + *out = &entry->base; + return 0; } static int config_memory_iterator( diff --git a/src/libgit2/config_snapshot.c b/src/libgit2/config_snapshot.c index dbd05ffdce7..d8b8733a9fb 100644 --- a/src/libgit2/config_snapshot.c +++ b/src/libgit2/config_snapshot.c @@ -41,18 +41,11 @@ static int config_snapshot_iterator( return error; } -/* release the map containing the entry as an equivalent to freeing it */ -static void config_snapshot_entry_free(git_config_entry *entry) -{ - git_config_list *config_list = (git_config_list *) entry->payload; - git_config_list_free(config_list); -} - static int config_snapshot_get(git_config_backend *cfg, const char *key, git_config_entry **out) { config_snapshot_backend *b = GIT_CONTAINER_OF(cfg, config_snapshot_backend, parent); git_config_list *config_list = NULL; - git_config_entry *entry; + git_config_list_entry *entry; int error = 0; if (git_mutex_lock(&b->values_mutex) < 0) { @@ -69,10 +62,7 @@ static int config_snapshot_get(git_config_backend *cfg, const char *key, git_con return error; } - entry->free = config_snapshot_entry_free; - entry->payload = config_list; - *out = entry; - + *out = &entry->base; return 0; } From d48a5d5104114b56c5084fd56d2581e5d5ed09eb Mon Sep 17 00:00:00 2001 From: lmcglash Date: Wed, 19 Jul 2023 14:33:39 +0100 Subject: [PATCH 310/608] Validate proxy URL on Windows. --- src/libgit2/transports/http.c | 11 ++++------- src/libgit2/transports/winhttp.c | 2 +- tests/libgit2/online/clone.c | 4 ++-- 3 files changed, 7 insertions(+), 10 deletions(-) diff --git a/src/libgit2/transports/http.c b/src/libgit2/transports/http.c index a7aea6b377e..eed51914549 100644 --- a/src/libgit2/transports/http.c +++ b/src/libgit2/transports/http.c @@ -334,16 +334,13 @@ static int lookup_proxy( return 0; } - if (!proxy) - goto done; - - - if ((error = git_net_url_parse(&transport->proxy.url, proxy) < 0)) + if (!proxy || + (error = git_net_url_parse(&transport->proxy.url, proxy)) < 0) goto done; if (!git_net_url_valid(&transport->proxy.url)) { - git_error_set(GIT_ERROR_HTTP, "invalid proxy url: %s", proxy); - error = GIT_EINVALIDSPEC; + git_error_set(GIT_ERROR_HTTP, "invalid URL: '%s'", proxy); + error = -1; goto done; } diff --git a/src/libgit2/transports/winhttp.c b/src/libgit2/transports/winhttp.c index 27e0fb6f7e9..b7ffb9512ae 100644 --- a/src/libgit2/transports/winhttp.c +++ b/src/libgit2/transports/winhttp.c @@ -446,7 +446,7 @@ static int winhttp_stream_connect(winhttp_stream *s) if ((error = git_net_url_parse(&t->proxy.url, proxy_url)) < 0) goto on_error; - if (strcmp(t->proxy.url.scheme, "http") != 0 && strcmp(t->proxy.url.scheme, "https") != 0) { + if (!git_net_url_valid(&t->proxy.url)) { git_error_set(GIT_ERROR_HTTP, "invalid URL: '%s'", proxy_url); error = -1; goto on_error; diff --git a/tests/libgit2/online/clone.c b/tests/libgit2/online/clone.c index 5c714d1aa9d..0c53514a425 100644 --- a/tests/libgit2/online/clone.c +++ b/tests/libgit2/online/clone.c @@ -975,10 +975,10 @@ void test_online_clone__proxy_invalid_url(void) g_options.fetch_opts.proxy_opts.certificate_check = proxy_cert_cb; g_options.fetch_opts.proxy_opts.url = "noschemeorport"; - cl_git_fail_with(GIT_EINVALIDSPEC, git_clone(&g_repo, "http://github.com/libgit2/TestGitRepository", "./foo", &g_options)); + cl_git_fail(git_clone(&g_repo, "http://github.com/libgit2/TestGitRepository", "./foo", &g_options)); g_options.fetch_opts.proxy_opts.url = "noscheme:8080"; - cl_git_fail_with(GIT_EINVALIDSPEC, git_clone(&g_repo, "http://github.com/libgit2/TestGitRepository", "./foo", &g_options)); + cl_git_fail(git_clone(&g_repo, "http://github.com/libgit2/TestGitRepository", "./foo", &g_options)); } void test_online_clone__proxy_credentials_request(void) From 0e0781f6f3d51b6eda93010db3c56530cb3953af Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 20 Jul 2023 10:29:41 +0100 Subject: [PATCH 311/608] config: provide origin in git_config_entry A git_config_entry now knows the type of the origin for the entry ("file", "memory", etc) and the path details (for files, the path on disk). This is propagated through snapshots. --- include/git2/config.h | 24 ++++++++++++++--- src/libgit2/config_file.c | 6 +++++ src/libgit2/config_list.c | 47 +++++++++++++++++++++++++++++---- src/libgit2/config_list.h | 1 + src/libgit2/config_mem.c | 1 + tests/libgit2/config/read.c | 2 ++ tests/libgit2/config/snapshot.c | 35 +++++++++++++++++++++++- 7 files changed, 106 insertions(+), 10 deletions(-) diff --git a/include/git2/config.h b/include/git2/config.h index 155a2996205..332e62036d0 100644 --- a/include/git2/config.h +++ b/include/git2/config.h @@ -62,10 +62,26 @@ typedef enum { * An entry in a configuration file */ typedef struct git_config_entry { - const char *name; /**< Name of the entry (normalised) */ - const char *value; /**< String value of the entry */ - unsigned int include_depth; /**< Depth of includes where this variable was found */ - git_config_level_t level; /**< Which config file this was found in */ + /** Name of the configuration entry (normalized) */ + const char *name; + + /** Literal (string) value of the entry */ + const char *value; + + /** The type of backend that this entry exists in (eg, "file") */ + const char *backend_type; + + /** + * The path to the origin of this entry. For config files, this is + * the path to the file. + */ + const char *origin_path; + + /** Depth of includes where this variable was found */ + unsigned int include_depth; + + /** Configuration level for the file this was found in */ + git_config_level_t level; /** * Free function for this entry; for internal purposes. Callers diff --git a/src/libgit2/config_file.c b/src/libgit2/config_file.c index 46ef07533b6..c86e98bf2bf 100644 --- a/src/libgit2/config_file.c +++ b/src/libgit2/config_file.c @@ -24,6 +24,8 @@ /* Max depth for [include] directives */ #define MAX_INCLUDE_DEPTH 10 +#define CONFIG_FILE_TYPE "file" + typedef struct config_file { git_futils_filestamp stamp; unsigned char checksum[GIT_HASH_SHA256_SIZE]; @@ -801,7 +803,11 @@ static int read_on_variable( GIT_ERROR_CHECK_ALLOC(entry->base.value); } + entry->base.origin_path = git_config_list_add_path(parse_data->config_list, parse_data->file->path); + GIT_ERROR_CHECK_ALLOC(entry->base.origin_path); + entry->base.level = parse_data->level; + entry->base.backend_type = CONFIG_FILE_TYPE; entry->base.include_depth = parse_data->depth; entry->base.free = git_config_list_entry_free; entry->config_list = parse_data->config_list; diff --git a/src/libgit2/config_list.c b/src/libgit2/config_list.c index 979c6ccff99..f642c87a4a7 100644 --- a/src/libgit2/config_list.c +++ b/src/libgit2/config_list.c @@ -26,6 +26,11 @@ typedef struct config_list_iterator { struct git_config_list { git_refcount rc; + + /* Paths to config files that contribute to these entries */ + git_strmap *paths; + + /* Config entries */ git_strmap *map; config_entry_list *entries; }; @@ -33,18 +38,22 @@ struct git_config_list { int git_config_list_new(git_config_list **out) { git_config_list *config_list; - int error; config_list = git__calloc(1, sizeof(git_config_list)); GIT_ERROR_CHECK_ALLOC(config_list); GIT_REFCOUNT_INC(config_list); - if ((error = git_strmap_new(&config_list->map)) < 0) + if (git_strmap_new(&config_list->paths) < 0 || + git_strmap_new(&config_list->map) < 0) { + git_strmap_free(config_list->paths); + git_strmap_free(config_list->map); git__free(config_list); - else - *out = config_list; - return error; + return -1; + } + + *out = config_list; + return 0; } int git_config_list_dup_entry(git_config_list *config_list, const git_config_entry *entry) @@ -63,6 +72,12 @@ int git_config_list_dup_entry(git_config_list *config_list, const git_config_ent GIT_ERROR_CHECK_ALLOC(duplicated->base.value); } + if (entry->origin_path) { + duplicated->base.origin_path = git_config_list_add_path(config_list, entry->origin_path); + GIT_ERROR_CHECK_ALLOC(duplicated->base.origin_path); + } + + duplicated->base.backend_type = entry->backend_type; duplicated->base.level = entry->level; duplicated->base.include_depth = entry->include_depth; duplicated->base.free = git_config_list_entry_free; @@ -110,6 +125,12 @@ static void config_list_free(git_config_list *config_list) { config_entry_list *entry_list = NULL, *next; config_entry_map_head *head; + char *path; + + git_strmap_foreach_value(config_list->paths, path, { + git__free(path); + }); + git_strmap_free(config_list->paths); git_strmap_foreach_value(config_list->map, head, { git__free((char *) head->entry->base.name); @@ -247,3 +268,19 @@ void git_config_list_entry_free(git_config_entry *e) git_config_list_entry *entry = (git_config_list_entry *)e; git_config_list_free(entry->config_list); } + +const char *git_config_list_add_path( + git_config_list *config_list, + const char *path) +{ + const char *p; + + if ((p = git_strmap_get(config_list->paths, path)) != NULL) + return p; + + if ((p = git__strdup(path)) == NULL || + git_strmap_set(config_list->paths, p, (void *)p) < 0) + return NULL; + + return p; +} diff --git a/src/libgit2/config_list.h b/src/libgit2/config_list.h index 0cacabb110d..83c43b9a0ff 100644 --- a/src/libgit2/config_list.h +++ b/src/libgit2/config_list.h @@ -27,5 +27,6 @@ int git_config_list_append(git_config_list *list, git_config_list_entry *entry); int git_config_list_get(git_config_list_entry **out, git_config_list *list, const char *key); int git_config_list_get_unique(git_config_list_entry **out, git_config_list *list, const char *key); int git_config_list_iterator_new(git_config_iterator **out, git_config_list *list); +const char *git_config_list_add_path(git_config_list *list, const char *path); void git_config_list_entry_free(git_config_entry *entry); diff --git a/src/libgit2/config_mem.c b/src/libgit2/config_mem.c index 37f5b01f983..748a1471673 100644 --- a/src/libgit2/config_mem.c +++ b/src/libgit2/config_mem.c @@ -68,6 +68,7 @@ static int read_variable_cb( entry->base.value = var_value ? git__strdup(var_value) : NULL; entry->base.level = parse_data->level; entry->base.include_depth = 0; + entry->base.backend_type = "memory"; entry->base.free = git_config_list_entry_free; entry->config_list = parse_data->config_list; diff --git a/tests/libgit2/config/read.c b/tests/libgit2/config/read.c index ac6459b9ea6..25e7b963c4d 100644 --- a/tests/libgit2/config/read.c +++ b/tests/libgit2/config/read.c @@ -495,6 +495,8 @@ void test_config_read__read_git_config_entry(void) cl_assert_equal_s("core.dummy2", entry->name); cl_assert_equal_s("42", entry->value); cl_assert_equal_i(GIT_CONFIG_LEVEL_SYSTEM, entry->level); + cl_assert_equal_s("file", entry->backend_type); + cl_assert_equal_s(cl_fixture("config/config9"), entry->origin_path); git_config_entry_free(entry); git_config_free(cfg); diff --git a/tests/libgit2/config/snapshot.c b/tests/libgit2/config/snapshot.c index 5cc08a721ac..bfb68e21e23 100644 --- a/tests/libgit2/config/snapshot.c +++ b/tests/libgit2/config/snapshot.c @@ -79,6 +79,7 @@ void test_config_snapshot__multivar(void) void test_config_snapshot__includes(void) { + git_config_entry *entry; int i; cl_git_mkfile("including", "[include]\npath = included"); @@ -99,6 +100,16 @@ void test_config_snapshot__includes(void) cl_git_pass(git_config_get_int32(&i, snapshot, "section.key")); cl_assert_equal_i(i, 1); + /* Ensure that the config entry is populated with origin */ + cl_git_pass(git_config_get_entry(&entry, snapshot, "section.key")); + + cl_assert_equal_s("section.key", entry->name); + cl_assert_equal_s("1", entry->value); + cl_assert_equal_s("file", entry->backend_type); + cl_assert_equal_s("./included", entry->origin_path); + + git_config_entry_free(entry); + cl_git_pass(p_unlink("including")); cl_git_pass(p_unlink("included")); } @@ -106,6 +117,7 @@ void test_config_snapshot__includes(void) void test_config_snapshot__snapshot(void) { git_config *snapshot_snapshot; + git_config_entry *entry; int i; cl_git_mkfile("configfile", "[section]\nkey = 1\n"); @@ -118,15 +130,26 @@ void test_config_snapshot__snapshot(void) cl_git_pass(git_config_get_int32(&i, snapshot_snapshot, "section.key")); cl_assert_equal_i(i, 1); + /* Ensure that the config entry is populated with origin */ + cl_git_pass(git_config_get_entry(&entry, snapshot_snapshot, "section.key")); + + cl_assert_equal_s("section.key", entry->name); + cl_assert_equal_s("1", entry->value); + cl_assert_equal_s("file", entry->backend_type); + cl_assert_equal_s("configfile", entry->origin_path); + + git_config_entry_free(entry); + git_config_free(snapshot_snapshot); cl_git_pass(p_unlink("configfile")); } -void test_config_snapshot__snapshot_from_in_memony(void) +void test_config_snapshot__snapshot_from_in_memory(void) { const char *configuration = "[section]\nkey = 1\n"; git_config_backend *backend; + git_config_entry *entry; int i; cl_git_pass(git_config_new(&cfg)); @@ -136,4 +159,14 @@ void test_config_snapshot__snapshot_from_in_memony(void) cl_git_pass(git_config_snapshot(&snapshot, cfg)); cl_git_pass(git_config_get_int32(&i, snapshot, "section.key")); cl_assert_equal_i(i, 1); + + /* Ensure that the config entry is populated with origin */ + cl_git_pass(git_config_get_entry(&entry, snapshot, "section.key")); + + cl_assert_equal_s("section.key", entry->name); + cl_assert_equal_s("1", entry->value); + cl_assert_equal_s("memory", entry->backend_type); + cl_assert_equal_p(NULL, entry->origin_path); + + git_config_entry_free(entry); } From 248ac08cb89b9a8d962b6752bced8809c757e412 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 20 Jul 2023 10:54:14 +0100 Subject: [PATCH 312/608] config: memory backends have an optional type --- src/libgit2/config_backend.h | 10 +++++++-- src/libgit2/config_file.c | 6 ++++-- src/libgit2/config_list.c | 38 +++++++++++++++++---------------- src/libgit2/config_list.h | 2 +- src/libgit2/config_mem.c | 17 +++++++++++++-- tests/libgit2/config/memory.c | 4 ++-- tests/libgit2/config/snapshot.c | 4 ++-- 7 files changed, 52 insertions(+), 29 deletions(-) diff --git a/src/libgit2/config_backend.h b/src/libgit2/config_backend.h index dbb19051484..677b2236f98 100644 --- a/src/libgit2/config_backend.h +++ b/src/libgit2/config_backend.h @@ -38,13 +38,19 @@ extern int git_config_backend_from_file(git_config_backend **out, const char *pa extern int git_config_backend_snapshot(git_config_backend **out, git_config_backend *source); /** - * Create an in-memory configuration file backend + * Create an in-memory configuration file backend from a string in standard + * git configuration file format. * * @param out the new backend + * @param origin the name of the origin to use (or NULL for "memory") * @param cfg the configuration that is to be parsed * @param len the length of the string pointed to by `cfg` */ -extern int git_config_backend_from_string(git_config_backend **out, const char *cfg, size_t len); +extern int git_config_backend_from_string( + git_config_backend **out, + const char *origin, + const char *cfg, + size_t len); GIT_INLINE(int) git_config_backend_open(git_config_backend *cfg, unsigned int level, const git_repository *repo) { diff --git a/src/libgit2/config_file.c b/src/libgit2/config_file.c index c86e98bf2bf..340e85691ed 100644 --- a/src/libgit2/config_file.c +++ b/src/libgit2/config_file.c @@ -803,11 +803,13 @@ static int read_on_variable( GIT_ERROR_CHECK_ALLOC(entry->base.value); } - entry->base.origin_path = git_config_list_add_path(parse_data->config_list, parse_data->file->path); + entry->base.backend_type = git_config_list_add_string(parse_data->config_list, CONFIG_FILE_TYPE); + GIT_ERROR_CHECK_ALLOC(entry->base.backend_type); + + entry->base.origin_path = git_config_list_add_string(parse_data->config_list, parse_data->file->path); GIT_ERROR_CHECK_ALLOC(entry->base.origin_path); entry->base.level = parse_data->level; - entry->base.backend_type = CONFIG_FILE_TYPE; entry->base.include_depth = parse_data->depth; entry->base.free = git_config_list_entry_free; entry->config_list = parse_data->config_list; diff --git a/src/libgit2/config_list.c b/src/libgit2/config_list.c index f642c87a4a7..0b7a4f3600a 100644 --- a/src/libgit2/config_list.c +++ b/src/libgit2/config_list.c @@ -27,8 +27,8 @@ typedef struct config_list_iterator { struct git_config_list { git_refcount rc; - /* Paths to config files that contribute to these entries */ - git_strmap *paths; + /* Interned strings - paths to config files or backend types */ + git_strmap *strings; /* Config entries */ git_strmap *map; @@ -43,9 +43,9 @@ int git_config_list_new(git_config_list **out) GIT_ERROR_CHECK_ALLOC(config_list); GIT_REFCOUNT_INC(config_list); - if (git_strmap_new(&config_list->paths) < 0 || + if (git_strmap_new(&config_list->strings) < 0 || git_strmap_new(&config_list->map) < 0) { - git_strmap_free(config_list->paths); + git_strmap_free(config_list->strings); git_strmap_free(config_list->map); git__free(config_list); @@ -72,12 +72,14 @@ int git_config_list_dup_entry(git_config_list *config_list, const git_config_ent GIT_ERROR_CHECK_ALLOC(duplicated->base.value); } + duplicated->base.backend_type = git_config_list_add_string(config_list, entry->backend_type); + GIT_ERROR_CHECK_ALLOC(duplicated->base.backend_type); + if (entry->origin_path) { - duplicated->base.origin_path = git_config_list_add_path(config_list, entry->origin_path); + duplicated->base.origin_path = git_config_list_add_string(config_list, entry->origin_path); GIT_ERROR_CHECK_ALLOC(duplicated->base.origin_path); } - duplicated->base.backend_type = entry->backend_type; duplicated->base.level = entry->level; duplicated->base.include_depth = entry->include_depth; duplicated->base.free = git_config_list_entry_free; @@ -125,12 +127,12 @@ static void config_list_free(git_config_list *config_list) { config_entry_list *entry_list = NULL, *next; config_entry_map_head *head; - char *path; + char *str; - git_strmap_foreach_value(config_list->paths, path, { - git__free(path); + git_strmap_foreach_value(config_list->strings, str, { + git__free(str); }); - git_strmap_free(config_list->paths); + git_strmap_free(config_list->strings); git_strmap_foreach_value(config_list->map, head, { git__free((char *) head->entry->base.name); @@ -269,18 +271,18 @@ void git_config_list_entry_free(git_config_entry *e) git_config_list_free(entry->config_list); } -const char *git_config_list_add_path( +const char *git_config_list_add_string( git_config_list *config_list, - const char *path) + const char *str) { - const char *p; + const char *s; - if ((p = git_strmap_get(config_list->paths, path)) != NULL) - return p; + if ((s = git_strmap_get(config_list->strings, str)) != NULL) + return s; - if ((p = git__strdup(path)) == NULL || - git_strmap_set(config_list->paths, p, (void *)p) < 0) + if ((s = git__strdup(str)) == NULL || + git_strmap_set(config_list->strings, s, (void *)s) < 0) return NULL; - return p; + return s; } diff --git a/src/libgit2/config_list.h b/src/libgit2/config_list.h index 83c43b9a0ff..023bca1e5ca 100644 --- a/src/libgit2/config_list.h +++ b/src/libgit2/config_list.h @@ -27,6 +27,6 @@ int git_config_list_append(git_config_list *list, git_config_list_entry *entry); int git_config_list_get(git_config_list_entry **out, git_config_list *list, const char *key); int git_config_list_get_unique(git_config_list_entry **out, git_config_list *list, const char *key); int git_config_list_iterator_new(git_config_iterator **out, git_config_list *list); -const char *git_config_list_add_path(git_config_list *list, const char *path); +const char *git_config_list_add_string(git_config_list *list, const char *str); void git_config_list_entry_free(git_config_entry *entry); diff --git a/src/libgit2/config_mem.c b/src/libgit2/config_mem.c index 748a1471673..8faa53dcba5 100644 --- a/src/libgit2/config_mem.c +++ b/src/libgit2/config_mem.c @@ -13,11 +13,13 @@ typedef struct { git_config_backend parent; + char *type; git_config_list *config_list; git_str cfg; } config_memory_backend; typedef struct { + const char *backend_type; git_config_list *config_list; git_config_level_t level; } config_memory_parse_data; @@ -68,7 +70,7 @@ static int read_variable_cb( entry->base.value = var_value ? git__strdup(var_value) : NULL; entry->base.level = parse_data->level; entry->base.include_depth = 0; - entry->base.backend_type = "memory"; + entry->base.backend_type = parse_data->backend_type; entry->base.free = git_config_list_entry_free; entry->config_list = parse_data->config_list; @@ -90,6 +92,9 @@ static int config_memory_open(git_config_backend *backend, git_config_level_t le if ((error = git_config_parser_init(&parser, "in-memory", memory_backend->cfg.ptr, memory_backend->cfg.size)) < 0) goto out; + + parse_data.backend_type = git_config_list_add_string( + memory_backend->config_list, memory_backend->type); parse_data.config_list = memory_backend->config_list; parse_data.level = level; @@ -187,12 +192,17 @@ static void config_memory_free(git_config_backend *_backend) if (backend == NULL) return; + git__free(backend->type); git_config_list_free(backend->config_list); git_str_dispose(&backend->cfg); git__free(backend); } -int git_config_backend_from_string(git_config_backend **out, const char *cfg, size_t len) +int git_config_backend_from_string( + git_config_backend **out, + const char *backend_type, + const char *cfg, + size_t len) { config_memory_backend *backend; @@ -210,6 +220,9 @@ int git_config_backend_from_string(git_config_backend **out, const char *cfg, si return -1; } + backend->type = git__strdup(backend_type ? backend_type : "in-memory"); + GIT_ERROR_CHECK_ALLOC(backend->type); + backend->parent.version = GIT_CONFIG_BACKEND_VERSION; backend->parent.readonly = 1; backend->parent.open = config_memory_open; diff --git a/tests/libgit2/config/memory.c b/tests/libgit2/config/memory.c index ae661899da7..67a61a1c573 100644 --- a/tests/libgit2/config/memory.c +++ b/tests/libgit2/config/memory.c @@ -61,7 +61,7 @@ static void assert_config_contains_all(git_config_backend *backend, static void setup_backend(const char *cfg) { - cl_git_pass(git_config_backend_from_string(&backend, cfg, strlen(cfg))); + cl_git_pass(git_config_backend_from_string(&backend, "test", cfg, strlen(cfg))); cl_git_pass(git_config_backend_open(backend, 0, NULL)); } @@ -88,7 +88,7 @@ void test_config_memory__malformed_fails_to_open(void) const char *cfg = "[general\n" "foo=bar\n"; - cl_git_pass(git_config_backend_from_string(&backend, cfg, strlen(cfg))); + cl_git_pass(git_config_backend_from_string(&backend, "test", cfg, strlen(cfg))); cl_git_fail(git_config_backend_open(backend, 0, NULL)); } diff --git a/tests/libgit2/config/snapshot.c b/tests/libgit2/config/snapshot.c index bfb68e21e23..87a68600ee4 100644 --- a/tests/libgit2/config/snapshot.c +++ b/tests/libgit2/config/snapshot.c @@ -153,7 +153,7 @@ void test_config_snapshot__snapshot_from_in_memory(void) int i; cl_git_pass(git_config_new(&cfg)); - cl_git_pass(git_config_backend_from_string(&backend, configuration, strlen(configuration))); + cl_git_pass(git_config_backend_from_string(&backend, "test", configuration, strlen(configuration))); cl_git_pass(git_config_add_backend(cfg, backend, 0, NULL, 0)); cl_git_pass(git_config_snapshot(&snapshot, cfg)); @@ -165,7 +165,7 @@ void test_config_snapshot__snapshot_from_in_memory(void) cl_assert_equal_s("section.key", entry->name); cl_assert_equal_s("1", entry->value); - cl_assert_equal_s("memory", entry->backend_type); + cl_assert_equal_s("test", entry->backend_type); cl_assert_equal_p(NULL, entry->origin_path); git_config_entry_free(entry); From 40ce52e51fa766f05be8bf942cfcd0b082eb2224 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 20 Jul 2023 22:27:25 +0100 Subject: [PATCH 313/608] config: provide two memory-backed config backends Provide two memory-backed configuration backends -- one that takes a string in config file format `[section] key=value` and one that takes a list of strings in `section.key=value` format. --- fuzzers/config_file_fuzzer.c | 2 +- include/git2/sys/config.h | 51 +++++++++ src/libgit2/config_backend.h | 15 --- src/libgit2/config_mem.c | 191 +++++++++++++++++++++++++++----- src/util/strlist.c | 42 +++++++ src/util/strlist.h | 16 +++ tests/libgit2/config/memory.c | 75 ++++++++++++- tests/libgit2/config/snapshot.c | 10 +- 8 files changed, 350 insertions(+), 52 deletions(-) create mode 100644 src/util/strlist.c create mode 100644 src/util/strlist.h diff --git a/fuzzers/config_file_fuzzer.c b/fuzzers/config_file_fuzzer.c index 890adbfc528..763036960b4 100644 --- a/fuzzers/config_file_fuzzer.c +++ b/fuzzers/config_file_fuzzer.c @@ -43,7 +43,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) goto out; } - if ((err = git_config_backend_from_string(&backend, (const char*)data, size)) != 0) { + if ((err = git_config_backend_from_string(&backend, (const char*)data, size, NULL)) != 0) { goto out; } if ((err = git_config_add_backend(cfg, backend, 0, NULL, 0)) != 0) { diff --git a/include/git2/sys/config.h b/include/git2/sys/config.h index 0a9005e35d4..75d20758b84 100644 --- a/include/git2/sys/config.h +++ b/include/git2/sys/config.h @@ -125,6 +125,57 @@ GIT_EXTERN(int) git_config_add_backend( const git_repository *repo, int force); +/** Options for in-memory configuration backends. */ +typedef struct { + unsigned int version; + + /** + * The type of this backend (eg, "command line"). If this is + * NULL, then this will be "in-memory". + */ + const char *backend_type; + + /** + * The path to the origin; if this is NULL then it will be + * left unset in the resulting configuration entries. + */ + const char *origin_path; +} git_config_backend_memory_options; + +#define GIT_CONFIG_BACKEND_MEMORY_OPTIONS_VERSION 1 +#define GIT_CONFIG_BACKEND_MEMORY_OPTIONS_INIT { GIT_CONFIG_BACKEND_MEMORY_OPTIONS_VERSION } + + +/** + * Create an in-memory configuration backend from a string in standard + * git configuration file format. + * + * @param out the new backend + * @param cfg the configuration that is to be parsed + * @param len the length of the string pointed to by `cfg` + * @param opts the options to initialize this backend with, or NULL + */ +extern int git_config_backend_from_string( + git_config_backend **out, + const char *cfg, + size_t len, + git_config_backend_memory_options *opts); + +/** + * Create an in-memory configuration backend from a list of name/value + * pairs. + * + * @param out the new backend + * @param values the configuration values to set (in "key=value" format) + * @param len the length of the values array + * @param opts the options to initialize this backend with, or NULL + */ +extern int git_config_backend_from_values( + git_config_backend **out, + const char **values, + size_t len, + git_config_backend_memory_options *opts); + /** @} */ GIT_END_DECL #endif diff --git a/src/libgit2/config_backend.h b/src/libgit2/config_backend.h index 677b2236f98..37d25abe146 100644 --- a/src/libgit2/config_backend.h +++ b/src/libgit2/config_backend.h @@ -37,21 +37,6 @@ extern int git_config_backend_from_file(git_config_backend **out, const char *pa */ extern int git_config_backend_snapshot(git_config_backend **out, git_config_backend *source); -/** - * Create an in-memory configuration file backend from a string in standard - * git configuration file format. - * - * @param out the new backend - * @param origin the name of the origin to use (or NULL for "memory") - * @param cfg the configuration that is to be parsed - * @param len the length of the string pointed to by `cfg` - */ -extern int git_config_backend_from_string( - git_config_backend **out, - const char *origin, - const char *cfg, - size_t len); - GIT_INLINE(int) git_config_backend_open(git_config_backend *cfg, unsigned int level, const git_repository *repo) { return cfg->open(cfg, level, repo); diff --git a/src/libgit2/config_mem.c b/src/libgit2/config_mem.c index 8faa53dcba5..406aa83e6e1 100644 --- a/src/libgit2/config_mem.c +++ b/src/libgit2/config_mem.c @@ -10,16 +10,27 @@ #include "config_backend.h" #include "config_parse.h" #include "config_list.h" +#include "strlist.h" typedef struct { git_config_backend parent; - char *type; + + char *backend_type; + char *origin_path; + git_config_list *config_list; + + /* Configuration data in the config file format */ git_str cfg; + + /* Array of key=value pairs */ + char **values; + size_t values_len; } config_memory_backend; typedef struct { const char *backend_type; + const char *origin_path; git_config_list *config_list; git_config_level_t level; } config_memory_parse_data; @@ -71,6 +82,7 @@ static int read_variable_cb( entry->base.level = parse_data->level; entry->base.include_depth = 0; entry->base.backend_type = parse_data->backend_type; + entry->base.origin_path = parse_data->origin_path; entry->base.free = git_config_list_entry_free; entry->config_list = parse_data->config_list; @@ -80,25 +92,29 @@ static int read_variable_cb( return result; } -static int config_memory_open(git_config_backend *backend, git_config_level_t level, const git_repository *repo) +static int parse_config( + config_memory_backend *memory_backend, + git_config_level_t level) { - config_memory_backend *memory_backend = (config_memory_backend *) backend; git_config_parser parser = GIT_PARSE_CTX_INIT; config_memory_parse_data parse_data; int error; - GIT_UNUSED(repo); - - if ((error = git_config_parser_init(&parser, "in-memory", memory_backend->cfg.ptr, - memory_backend->cfg.size)) < 0) + if ((error = git_config_parser_init(&parser, "in-memory", + memory_backend->cfg.ptr, memory_backend->cfg.size)) < 0) goto out; parse_data.backend_type = git_config_list_add_string( - memory_backend->config_list, memory_backend->type); + memory_backend->config_list, memory_backend->backend_type); + parse_data.origin_path = memory_backend->origin_path ? + git_config_list_add_string(memory_backend->config_list, + memory_backend->origin_path) : + NULL; parse_data.config_list = memory_backend->config_list; parse_data.level = level; - if ((error = git_config_parse(&parser, NULL, read_variable_cb, NULL, NULL, &parse_data)) < 0) + if ((error = git_config_parse(&parser, NULL, read_variable_cb, + NULL, NULL, &parse_data)) < 0) goto out; out: @@ -106,6 +122,74 @@ static int config_memory_open(git_config_backend *backend, git_config_level_t le return error; } +static int parse_values( + config_memory_backend *memory_backend, + git_config_level_t level) +{ + git_config_list_entry *entry; + const char *eql, *backend_type, *origin_path; + size_t name_len, i; + + backend_type = git_config_list_add_string( + memory_backend->config_list, memory_backend->backend_type); + GIT_ERROR_CHECK_ALLOC(backend_type); + + origin_path = memory_backend->origin_path ? + git_config_list_add_string(memory_backend->config_list, + memory_backend->origin_path) : + NULL; + + for (i = 0; i < memory_backend->values_len; i++) { + eql = strchr(memory_backend->values[i], '='); + name_len = eql - memory_backend->values[i]; + + if (name_len == 0) { + git_error_set(GIT_ERROR_CONFIG, "empty config key"); + return -1; + } + + entry = git__calloc(1, sizeof(git_config_list_entry)); + GIT_ERROR_CHECK_ALLOC(entry); + + entry->base.name = git__strndup(memory_backend->values[i], name_len); + GIT_ERROR_CHECK_ALLOC(entry->base.name); + + if (eql) { + entry->base.value = git__strdup(eql + 1); + GIT_ERROR_CHECK_ALLOC(entry->base.value); + } + + entry->base.level = level; + entry->base.include_depth = 0; + entry->base.backend_type = backend_type; + entry->base.origin_path = origin_path; + entry->base.free = git_config_list_entry_free; + entry->config_list = memory_backend->config_list; + + if (git_config_list_append(memory_backend->config_list, entry) < 0) + return -1; + } + + return 0; +} + +static int config_memory_open(git_config_backend *backend, git_config_level_t level, const git_repository *repo) +{ + config_memory_backend *memory_backend = (config_memory_backend *) backend; + + GIT_UNUSED(repo); + + if (memory_backend->cfg.size > 0 && + parse_config(memory_backend, level) < 0) + return -1; + + if (memory_backend->values_len > 0 && + parse_values(memory_backend, level) < 0) + return -1; + + return 0; +} + static int config_memory_get(git_config_backend *backend, const char *key, git_config_entry **out) { config_memory_backend *memory_backend = (config_memory_backend *) backend; @@ -192,36 +276,24 @@ static void config_memory_free(git_config_backend *_backend) if (backend == NULL) return; - git__free(backend->type); + git__free(backend->origin_path); + git__free(backend->backend_type); git_config_list_free(backend->config_list); + git_strlist_free(backend->values, backend->values_len); git_str_dispose(&backend->cfg); git__free(backend); } -int git_config_backend_from_string( - git_config_backend **out, - const char *backend_type, - const char *cfg, - size_t len) +static config_memory_backend *config_backend_new( + git_config_backend_memory_options *opts) { config_memory_backend *backend; - backend = git__calloc(1, sizeof(config_memory_backend)); - GIT_ERROR_CHECK_ALLOC(backend); - - if (git_config_list_new(&backend->config_list) < 0) { - git__free(backend); - return -1; - } - - if (git_str_set(&backend->cfg, cfg, len) < 0) { - git_config_list_free(backend->config_list); - git__free(backend); - return -1; - } + if ((backend = git__calloc(1, sizeof(config_memory_backend))) == NULL) + return NULL; - backend->type = git__strdup(backend_type ? backend_type : "in-memory"); - GIT_ERROR_CHECK_ALLOC(backend->type); + if (git_config_list_new(&backend->config_list) < 0) + goto on_error; backend->parent.version = GIT_CONFIG_BACKEND_VERSION; backend->parent.readonly = 1; @@ -237,7 +309,66 @@ int git_config_backend_from_string( backend->parent.snapshot = git_config_backend_snapshot; backend->parent.free = config_memory_free; + backend->backend_type = git__strdup(opts && opts->backend_type ? + opts->backend_type : "in-memory"); + + if (backend->backend_type == NULL) + goto on_error; + + if (opts && opts->origin_path && + (backend->origin_path = git__strdup(opts->origin_path)) == NULL) + goto on_error; + + return backend; + +on_error: + git_config_list_free(backend->config_list); + git__free(backend->origin_path); + git__free(backend->backend_type); + git__free(backend); + return NULL; +} + +int git_config_backend_from_string( + git_config_backend **out, + const char *cfg, + size_t len, + git_config_backend_memory_options *opts) +{ + config_memory_backend *backend; + + if ((backend = config_backend_new(opts)) == NULL) + return -1; + + if (git_str_set(&backend->cfg, cfg, len) < 0) { + git_config_list_free(backend->config_list); + git__free(backend); + return -1; + } + *out = (git_config_backend *)backend; + return 0; +} + +int git_config_backend_from_values( + git_config_backend **out, + const char **values, + size_t len, + git_config_backend_memory_options *opts) +{ + config_memory_backend *backend; + if ((backend = config_backend_new(opts)) == NULL) + return -1; + + if (git_strlist_copy(&backend->values, values, len) < 0) { + git_config_list_free(backend->config_list); + git__free(backend); + return -1; + } + + backend->values_len = len; + + *out = (git_config_backend *)backend; return 0; } diff --git a/src/util/strlist.c b/src/util/strlist.c new file mode 100644 index 00000000000..af9b4bbd34d --- /dev/null +++ b/src/util/strlist.c @@ -0,0 +1,42 @@ +/* + * Copyright (C) the libgit2 contributors. All rights reserved. + * + * This file is part of libgit2, distributed under the GNU GPL v2 with + * a Linking Exception. For full terms see the included COPYING file. + */ + +#include + +#include "git2_util.h" +#include "vector.h" +#include "strlist.h" + +int git_strlist_copy(char ***out, const char **in, size_t len) +{ + char **dup; + size_t i; + + dup = git__calloc(len, sizeof(char *)); + GIT_ERROR_CHECK_ALLOC(dup); + + for (i = 0; i < len; i++) { + dup[i] = git__strdup(in[i]); + GIT_ERROR_CHECK_ALLOC(dup[i]); + } + + *out = dup; + return 0; +} + +void git_strlist_free(char **strings, size_t len) +{ + size_t i; + + if (!strings) + return; + + for (i = 0; i < len; i++) + git__free(strings[i]); + + git__free(strings); +} diff --git a/src/util/strlist.h b/src/util/strlist.h new file mode 100644 index 00000000000..089a8bb57b3 --- /dev/null +++ b/src/util/strlist.h @@ -0,0 +1,16 @@ +/* + * Copyright (C) the libgit2 contributors. All rights reserved. + * + * This file is part of libgit2, distributed under the GNU GPL v2 with + * a Linking Exception. For full terms see the included COPYING file. + */ + +#ifndef INCLUDE_runtime_h__ +#define INCLUDE_runtime_h__ + +#include "git2_util.h" + +extern int git_strlist_copy(char ***out, const char **in, size_t len); +extern void git_strlist_free(char **strings, size_t len); + +#endif diff --git a/tests/libgit2/config/memory.c b/tests/libgit2/config/memory.c index 67a61a1c573..9f533e282fd 100644 --- a/tests/libgit2/config/memory.c +++ b/tests/libgit2/config/memory.c @@ -34,8 +34,13 @@ static int contains_all_cb(const git_config_entry *entry, void *payload) int i; for (i = 0; entries[i].name; i++) { - if (strcmp(entries[i].name, entry->name) || - strcmp(entries[i].value , entry->value)) + if (strcmp(entries[i].name, entry->name)) + continue; + + if ((entries[i].value == NULL) ^ (entry->value == NULL)) + continue; + + if (entry->value && strcmp(entries[i].value , entry->value)) continue; if (entries[i].seen) @@ -61,7 +66,23 @@ static void assert_config_contains_all(git_config_backend *backend, static void setup_backend(const char *cfg) { - cl_git_pass(git_config_backend_from_string(&backend, "test", cfg, strlen(cfg))); + git_config_backend_memory_options opts = + GIT_CONFIG_BACKEND_MEMORY_OPTIONS_INIT; + + opts.backend_type = "test"; + + cl_git_pass(git_config_backend_from_string(&backend, cfg, strlen(cfg), &opts)); + cl_git_pass(git_config_backend_open(backend, 0, NULL)); +} + +static void setup_values_backend(const char **values, size_t len) +{ + git_config_backend_memory_options opts = + GIT_CONFIG_BACKEND_MEMORY_OPTIONS_INIT; + + opts.backend_type = "test"; + + cl_git_pass(git_config_backend_from_values(&backend, values, len, &opts)); cl_git_pass(git_config_backend_open(backend, 0, NULL)); } @@ -88,7 +109,13 @@ void test_config_memory__malformed_fails_to_open(void) const char *cfg = "[general\n" "foo=bar\n"; - cl_git_pass(git_config_backend_from_string(&backend, "test", cfg, strlen(cfg))); + + git_config_backend_memory_options opts = + GIT_CONFIG_BACKEND_MEMORY_OPTIONS_INIT; + + opts.backend_type = "test"; + + cl_git_pass(git_config_backend_from_string(&backend, cfg, strlen(cfg), &opts)); cl_git_fail(git_config_backend_open(backend, 0, NULL)); } @@ -137,3 +164,43 @@ void test_config_memory__foreach_sees_multivar(void) "foo=bar2\n"); assert_config_contains_all(backend, entries); } + +void test_config_memory__values(void) +{ + const char *values[] = { + "general.foo=bar1", + "general.foo=bar2", + "other.key=value", + "empty.value=", + "no.value", + }; + + struct expected_entry entries[] = { + { "general.foo", "bar1", 0 }, + { "general.foo", "bar2", 0 }, + { "other.key", "value", 0 }, + { "empty.value", "", 0 }, + { "no.value", NULL, 0 }, + { NULL, NULL, 0 } + }; + + setup_values_backend(values, 5); + assert_config_contains_all(backend, entries); +} + +void test_config_memory__valid_values(void) +{ + const char *values[] = { + "general.foo=bar1", + "=bar2", + "other.key=value" + }; + + git_config_backend_memory_options opts = + GIT_CONFIG_BACKEND_MEMORY_OPTIONS_INIT; + + opts.backend_type = "test"; + + cl_git_pass(git_config_backend_from_values(&backend, values, 3, &opts)); + cl_git_fail(git_config_backend_open(backend, 0, NULL)); +} diff --git a/tests/libgit2/config/snapshot.c b/tests/libgit2/config/snapshot.c index 87a68600ee4..cc877063c08 100644 --- a/tests/libgit2/config/snapshot.c +++ b/tests/libgit2/config/snapshot.c @@ -152,8 +152,14 @@ void test_config_snapshot__snapshot_from_in_memory(void) git_config_entry *entry; int i; + git_config_backend_memory_options opts = + GIT_CONFIG_BACKEND_MEMORY_OPTIONS_INIT; + + opts.backend_type = "test"; + opts.origin_path = "hello"; + cl_git_pass(git_config_new(&cfg)); - cl_git_pass(git_config_backend_from_string(&backend, "test", configuration, strlen(configuration))); + cl_git_pass(git_config_backend_from_string(&backend, configuration, strlen(configuration), &opts)); cl_git_pass(git_config_add_backend(cfg, backend, 0, NULL, 0)); cl_git_pass(git_config_snapshot(&snapshot, cfg)); @@ -166,7 +172,7 @@ void test_config_snapshot__snapshot_from_in_memory(void) cl_assert_equal_s("section.key", entry->name); cl_assert_equal_s("1", entry->value); cl_assert_equal_s("test", entry->backend_type); - cl_assert_equal_p(NULL, entry->origin_path); + cl_assert_equal_s("hello", entry->origin_path); git_config_entry_free(entry); } From f7c746a2ef3e7e0e7e90bda17178eb5a87cc130b Mon Sep 17 00:00:00 2001 From: David Runge Date: Fri, 21 Jul 2023 16:18:39 +0200 Subject: [PATCH 314/608] fix: Add missing include for oidarray. Add a missing include for `git2/oidarray.h` so build doesn't fail on using `git_oidarray` when using custom transports. Fixes #6607 --- include/git2/sys/transport.h | 1 + 1 file changed, 1 insertion(+) diff --git a/include/git2/sys/transport.h b/include/git2/sys/transport.h index 96a35d08cb2..370ca45d570 100644 --- a/include/git2/sys/transport.h +++ b/include/git2/sys/transport.h @@ -9,6 +9,7 @@ #define INCLUDE_sys_git_transport_h #include "git2/net.h" +#include "git2/oidarray.h" #include "git2/proxy.h" #include "git2/remote.h" #include "git2/strarray.h" From 3e15292d8863da316a57be23fede04f443460686 Mon Sep 17 00:00:00 2001 From: Christopher Nielsen Date: Mon, 24 Jul 2023 20:37:34 -0400 Subject: [PATCH 315/608] stransport: macos: replace errSSLNetworkTimeout, with hard-coded value - Constant only available in 10.13+, causing build failures for older macOS releases Fixes: https://github.com/libgit2/libgit2/issues/6606 --- src/libgit2/streams/stransport.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/libgit2/streams/stransport.c b/src/libgit2/streams/stransport.c index d956df84d10..7a3585e246b 100644 --- a/src/libgit2/streams/stransport.c +++ b/src/libgit2/streams/stransport.c @@ -162,7 +162,7 @@ static OSStatus write_cb(SSLConnectionRef conn, const void *data, size_t *len) if (ret < 0) { st->error = ret; return (ret == GIT_TIMEOUT) ? - errSSLNetworkTimeout : + -9853 /* errSSLNetworkTimeout */: -36 /* ioErr */; } @@ -214,7 +214,7 @@ static OSStatus read_cb(SSLConnectionRef conn, void *data, size_t *len) if (ret < 0) { st->error = ret; error = (ret == GIT_TIMEOUT) ? - errSSLNetworkTimeout : + -9853 /* errSSLNetworkTimeout */: -36 /* ioErr */; break; } else if (ret == 0) { From 23ba7aedff74043ac178e8dca24109b5aa1dffe0 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Wed, 19 Jul 2023 11:17:03 +0100 Subject: [PATCH 316/608] config: complete entry during creation Don't set entry data when we "get" an entry from the collection, add the data to the entry before it's put into the collection. This keeps the entry creation logic in a single place. --- src/libgit2/config_file.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/libgit2/config_file.c b/src/libgit2/config_file.c index 716924de600..6fc4c6fc21d 100644 --- a/src/libgit2/config_file.c +++ b/src/libgit2/config_file.c @@ -359,8 +359,6 @@ static int config_file_get(git_config_backend *cfg, const char *key, git_config_ return error; } - entry->free = config_file_entry_free; - entry->payload = entries; *out = entry; return 0; @@ -805,6 +803,8 @@ static int read_on_variable( entry->value = var_value ? git__strdup(var_value) : NULL; entry->level = parse_data->level; entry->include_depth = parse_data->depth; + entry->free = config_file_entry_free; + entry->payload = parse_data->entries; if ((result = git_config_entries_append(parse_data->entries, entry)) < 0) return result; From 1951864f7da3dc720dc56ce170a17a2a8b80130c Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Wed, 19 Jul 2023 12:23:07 +0100 Subject: [PATCH 317/608] config: rename config_entries to config_list --- src/libgit2/config_entries.h | 24 ---- src/libgit2/config_file.c | 124 ++++++++--------- .../{config_entries.c => config_list.c} | 127 +++++++++--------- src/libgit2/config_list.h | 24 ++++ src/libgit2/config_mem.c | 28 ++-- src/libgit2/config_snapshot.c | 42 +++--- 6 files changed, 185 insertions(+), 184 deletions(-) delete mode 100644 src/libgit2/config_entries.h rename src/libgit2/{config_entries.c => config_list.c} (50%) create mode 100644 src/libgit2/config_list.h diff --git a/src/libgit2/config_entries.h b/src/libgit2/config_entries.h deleted file mode 100644 index 832379e7466..00000000000 --- a/src/libgit2/config_entries.h +++ /dev/null @@ -1,24 +0,0 @@ -/* - * Copyright (C) the libgit2 contributors. All rights reserved. - * - * This file is part of libgit2, distributed under the GNU GPL v2 with - * a Linking Exception. For full terms see the included COPYING file. - */ - -#include "common.h" - -#include "git2/sys/config.h" -#include "config.h" - -typedef struct git_config_entries git_config_entries; - -int git_config_entries_new(git_config_entries **out); -int git_config_entries_dup(git_config_entries **out, git_config_entries *entries); -int git_config_entries_dup_entry(git_config_entries *entries, const git_config_entry *entry); -void git_config_entries_incref(git_config_entries *entries); -void git_config_entries_free(git_config_entries *entries); -/* Add or append the new config option */ -int git_config_entries_append(git_config_entries *entries, git_config_entry *entry); -int git_config_entries_get(git_config_entry **out, git_config_entries *entries, const char *key); -int git_config_entries_get_unique(git_config_entry **out, git_config_entries *entries, const char *key); -int git_config_entries_iterator_new(git_config_iterator **out, git_config_entries *entries); diff --git a/src/libgit2/config_file.c b/src/libgit2/config_file.c index 6fc4c6fc21d..41241f1b0f5 100644 --- a/src/libgit2/config_file.c +++ b/src/libgit2/config_file.c @@ -13,7 +13,7 @@ #include "array.h" #include "str.h" #include "config_backend.h" -#include "config_entries.h" +#include "config_list.h" #include "config_parse.h" #include "filebuf.h" #include "regexp.h" @@ -34,7 +34,7 @@ typedef struct config_file { typedef struct { git_config_backend parent; git_mutex values_mutex; - git_config_entries *entries; + git_config_list *config_list; const git_repository *repo; git_config_level_t level; @@ -50,13 +50,13 @@ typedef struct { typedef struct { const git_repository *repo; config_file *file; - git_config_entries *entries; + git_config_list *config_list; git_config_level_t level; unsigned int depth; } config_file_parse_data; -static int config_file_read(git_config_entries *entries, const git_repository *repo, config_file *file, git_config_level_t level, int depth); -static int config_file_read_buffer(git_config_entries *entries, const git_repository *repo, config_file *file, git_config_level_t level, int depth, const char *buf, size_t buflen); +static int config_file_read(git_config_list *config_list, const git_repository *repo, config_file *file, git_config_level_t level, int depth); +static int config_file_read_buffer(git_config_list *config_list, const git_repository *repo, config_file *file, git_config_level_t level, int depth, const char *buf, size_t buflen); static int config_file_write(config_file_backend *cfg, const char *orig_key, const char *key, const git_regexp *preg, const char *value); static char *escape_value(const char *ptr); @@ -65,7 +65,7 @@ static char *escape_value(const char *ptr); * refcount. This is its own function to make sure we use the mutex to * avoid the map pointer from changing under us. */ -static int config_file_entries_take(git_config_entries **out, config_file_backend *b) +static int config_file_take_list(git_config_list **out, config_file_backend *b) { int error; @@ -74,8 +74,8 @@ static int config_file_entries_take(git_config_entries **out, config_file_backen return error; } - git_config_entries_incref(b->entries); - *out = b->entries; + git_config_list_incref(b->config_list); + *out = b->config_list; git_mutex_unlock(&b->values_mutex); @@ -106,7 +106,7 @@ static int config_file_open(git_config_backend *cfg, git_config_level_t level, c b->level = level; b->repo = repo; - if ((res = git_config_entries_new(&b->entries)) < 0) + if ((res = git_config_list_new(&b->config_list)) < 0) return res; if (!git_fs_path_exists(b->file.path)) @@ -121,9 +121,9 @@ static int config_file_open(git_config_backend *cfg, git_config_level_t level, c if (p_access(b->file.path, R_OK) < 0) return GIT_ENOTFOUND; - if (res < 0 || (res = config_file_read(b->entries, repo, &b->file, level, 0)) < 0) { - git_config_entries_free(b->entries); - b->entries = NULL; + if (res < 0 || (res = config_file_read(b->config_list, repo, &b->file, level, 0)) < 0) { + git_config_list_free(b->config_list); + b->config_list = NULL; } return res; @@ -175,10 +175,10 @@ static void config_file_clear_includes(config_file_backend *cfg) git_array_clear(cfg->file.includes); } -static int config_file_set_entries(git_config_backend *cfg, git_config_entries *entries) +static int config_file_set_entries(git_config_backend *cfg, git_config_list *config_list) { config_file_backend *b = GIT_CONTAINER_OF(cfg, config_file_backend, parent); - git_config_entries *old = NULL; + git_config_list *old = NULL; int error; if (b->parent.readonly) { @@ -191,40 +191,40 @@ static int config_file_set_entries(git_config_backend *cfg, git_config_entries * goto out; } - old = b->entries; - b->entries = entries; + old = b->config_list; + b->config_list = config_list; git_mutex_unlock(&b->values_mutex); out: - git_config_entries_free(old); + git_config_list_free(old); return error; } static int config_file_refresh_from_buffer(git_config_backend *cfg, const char *buf, size_t buflen) { config_file_backend *b = GIT_CONTAINER_OF(cfg, config_file_backend, parent); - git_config_entries *entries = NULL; + git_config_list *config_list = NULL; int error; config_file_clear_includes(b); - if ((error = git_config_entries_new(&entries)) < 0 || - (error = config_file_read_buffer(entries, b->repo, &b->file, + if ((error = git_config_list_new(&config_list)) < 0 || + (error = config_file_read_buffer(config_list, b->repo, &b->file, b->level, 0, buf, buflen)) < 0 || - (error = config_file_set_entries(cfg, entries)) < 0) + (error = config_file_set_entries(cfg, config_list)) < 0) goto out; - entries = NULL; + config_list = NULL; out: - git_config_entries_free(entries); + git_config_list_free(config_list); return error; } static int config_file_refresh(git_config_backend *cfg) { config_file_backend *b = GIT_CONTAINER_OF(cfg, config_file_backend, parent); - git_config_entries *entries = NULL; + git_config_list *config_list = NULL; int error, modified; if (cfg->readonly) @@ -238,14 +238,14 @@ static int config_file_refresh(git_config_backend *cfg) config_file_clear_includes(b); - if ((error = git_config_entries_new(&entries)) < 0 || - (error = config_file_read(entries, b->repo, &b->file, b->level, 0)) < 0 || - (error = config_file_set_entries(cfg, entries)) < 0) + if ((error = git_config_list_new(&config_list)) < 0 || + (error = config_file_read(config_list, b->repo, &b->file, b->level, 0)) < 0 || + (error = config_file_set_entries(cfg, config_list)) < 0) goto out; - entries = NULL; + config_list = NULL; out: - git_config_entries_free(entries); + git_config_list_free(config_list); return (error == GIT_ENOTFOUND) ? 0 : error; } @@ -258,7 +258,7 @@ static void config_file_free(git_config_backend *_backend) return; config_file_clear(&backend->file); - git_config_entries_free(backend->entries); + git_config_list_free(backend->config_list); git_mutex_free(&backend->values_mutex); git__free(backend); } @@ -268,19 +268,19 @@ static int config_file_iterator( struct git_config_backend *backend) { config_file_backend *b = GIT_CONTAINER_OF(backend, config_file_backend, parent); - git_config_entries *dupped = NULL, *entries = NULL; + git_config_list *dupped = NULL, *config_list = NULL; int error; if ((error = config_file_refresh(backend)) < 0 || - (error = config_file_entries_take(&entries, b)) < 0 || - (error = git_config_entries_dup(&dupped, entries)) < 0 || - (error = git_config_entries_iterator_new(iter, dupped)) < 0) + (error = config_file_take_list(&config_list, b)) < 0 || + (error = git_config_list_dup(&dupped, config_list)) < 0 || + (error = git_config_list_iterator_new(iter, dupped)) < 0) goto out; out: - /* Let iterator delete duplicated entries when it's done */ - git_config_entries_free(entries); - git_config_entries_free(dupped); + /* Let iterator delete duplicated config_list when it's done */ + git_config_list_free(config_list); + git_config_list_free(dupped); return error; } @@ -292,7 +292,7 @@ static int config_file_snapshot(git_config_backend **out, git_config_backend *ba static int config_file_set(git_config_backend *cfg, const char *name, const char *value) { config_file_backend *b = GIT_CONTAINER_OF(cfg, config_file_backend, parent); - git_config_entries *entries; + git_config_list *config_list; git_config_entry *existing; char *key, *esc_value = NULL; int error; @@ -300,11 +300,11 @@ static int config_file_set(git_config_backend *cfg, const char *name, const char if ((error = git_config__normalize_name(name, &key)) < 0) return error; - if ((error = config_file_entries_take(&entries, b)) < 0) + if ((error = config_file_take_list(&config_list, b)) < 0) return error; /* Check whether we'd be modifying an included or multivar key */ - if ((error = git_config_entries_get_unique(&existing, entries, key)) < 0) { + if ((error = git_config_list_get_unique(&existing, config_list, key)) < 0) { if (error != GIT_ENOTFOUND) goto out; error = 0; @@ -325,7 +325,7 @@ static int config_file_set(git_config_backend *cfg, const char *name, const char goto out; out: - git_config_entries_free(entries); + git_config_list_free(config_list); git__free(esc_value); git__free(key); return error; @@ -334,8 +334,8 @@ static int config_file_set(git_config_backend *cfg, const char *name, const char /* release the map containing the entry as an equivalent to freeing it */ static void config_file_entry_free(git_config_entry *entry) { - git_config_entries *entries = (git_config_entries *) entry->payload; - git_config_entries_free(entries); + git_config_list *config_list = (git_config_list *) entry->payload; + git_config_list_free(config_list); } /* @@ -344,18 +344,18 @@ static void config_file_entry_free(git_config_entry *entry) static int config_file_get(git_config_backend *cfg, const char *key, git_config_entry **out) { config_file_backend *h = GIT_CONTAINER_OF(cfg, config_file_backend, parent); - git_config_entries *entries = NULL; + git_config_list *config_list = NULL; git_config_entry *entry; int error = 0; if (!h->parent.readonly && ((error = config_file_refresh(cfg)) < 0)) return error; - if ((error = config_file_entries_take(&entries, h)) < 0) + if ((error = config_file_take_list(&config_list, h)) < 0) return error; - if ((error = (git_config_entries_get(&entry, entries, key))) < 0) { - git_config_entries_free(entries); + if ((error = (git_config_list_get(&entry, config_list, key))) < 0) { + git_config_list_free(config_list); return error; } @@ -394,7 +394,7 @@ static int config_file_set_multivar( static int config_file_delete(git_config_backend *cfg, const char *name) { config_file_backend *b = GIT_CONTAINER_OF(cfg, config_file_backend, parent); - git_config_entries *entries = NULL; + git_config_list *config_list = NULL; git_config_entry *entry; char *key = NULL; int error; @@ -402,11 +402,11 @@ static int config_file_delete(git_config_backend *cfg, const char *name) if ((error = git_config__normalize_name(name, &key)) < 0) goto out; - if ((error = config_file_entries_take(&entries, b)) < 0) + if ((error = config_file_take_list(&config_list, b)) < 0) goto out; /* Check whether we'd be modifying an included or multivar key */ - if ((error = git_config_entries_get_unique(&entry, entries, key)) < 0) { + if ((error = git_config_list_get_unique(&entry, config_list, key)) < 0) { if (error == GIT_ENOTFOUND) git_error_set(GIT_ERROR_CONFIG, "could not find key '%s' to delete", name); goto out; @@ -416,7 +416,7 @@ static int config_file_delete(git_config_backend *cfg, const char *name) goto out; out: - git_config_entries_free(entries); + git_config_list_free(config_list); git__free(key); return error; } @@ -424,7 +424,7 @@ static int config_file_delete(git_config_backend *cfg, const char *name) static int config_file_delete_multivar(git_config_backend *cfg, const char *name, const char *regexp) { config_file_backend *b = GIT_CONTAINER_OF(cfg, config_file_backend, parent); - git_config_entries *entries = NULL; + git_config_list *config_list = NULL; git_config_entry *entry = NULL; git_regexp preg = GIT_REGEX_INIT; char *key = NULL; @@ -433,10 +433,10 @@ static int config_file_delete_multivar(git_config_backend *cfg, const char *name if ((result = git_config__normalize_name(name, &key)) < 0) goto out; - if ((result = config_file_entries_take(&entries, b)) < 0) + if ((result = config_file_take_list(&config_list, b)) < 0) goto out; - if ((result = git_config_entries_get(&entry, entries, key)) < 0) { + if ((result = git_config_list_get(&entry, config_list, key)) < 0) { if (result == GIT_ENOTFOUND) git_error_set(GIT_ERROR_CONFIG, "could not find key '%s' to delete", name); goto out; @@ -449,7 +449,7 @@ static int config_file_delete_multivar(git_config_backend *cfg, const char *name goto out; out: - git_config_entries_free(entries); + git_config_list_free(config_list); git__free(key); git_regexp_dispose(&preg); return result; @@ -589,7 +589,7 @@ static int parse_include(config_file_parse_data *parse_data, const char *file) git_array_init(include->includes); include->path = git_str_detach(&path); - result = config_file_read(parse_data->entries, parse_data->repo, include, + result = config_file_read(parse_data->config_list, parse_data->repo, include, parse_data->level, parse_data->depth+1); if (result == GIT_ENOTFOUND) { @@ -804,9 +804,9 @@ static int read_on_variable( entry->level = parse_data->level; entry->include_depth = parse_data->depth; entry->free = config_file_entry_free; - entry->payload = parse_data->entries; + entry->payload = parse_data->config_list; - if ((result = git_config_entries_append(parse_data->entries, entry)) < 0) + if ((result = git_config_list_append(parse_data->config_list, entry)) < 0) return result; result = 0; @@ -822,7 +822,7 @@ static int read_on_variable( } static int config_file_read_buffer( - git_config_entries *entries, + git_config_list *config_list, const git_repository *repo, config_file *file, git_config_level_t level, @@ -851,7 +851,7 @@ static int config_file_read_buffer( parse_data.repo = repo; parse_data.file = file; - parse_data.entries = entries; + parse_data.config_list = config_list; parse_data.level = level; parse_data.depth = depth; @@ -862,7 +862,7 @@ static int config_file_read_buffer( } static int config_file_read( - git_config_entries *entries, + git_config_list *config_list, const git_repository *repo, config_file *file, git_config_level_t level, @@ -884,7 +884,7 @@ static int config_file_read( if ((error = git_hash_buf(file->checksum, contents.ptr, contents.size, GIT_HASH_ALGORITHM_SHA256)) < 0) goto out; - if ((error = config_file_read_buffer(entries, repo, file, level, depth, + if ((error = config_file_read_buffer(config_list, repo, file, level, depth, contents.ptr, contents.size)) < 0) goto out; diff --git a/src/libgit2/config_entries.c b/src/libgit2/config_list.c similarity index 50% rename from src/libgit2/config_entries.c rename to src/libgit2/config_list.c index 66aae096d2d..01d41526e98 100644 --- a/src/libgit2/config_entries.c +++ b/src/libgit2/config_list.c @@ -5,7 +5,7 @@ * a Linking Exception. For full terms see the included COPYING file. */ -#include "config_entries.h" +#include "config_list.h" typedef struct config_entry_list { struct config_entry_list *next; @@ -18,36 +18,36 @@ typedef struct { bool multivar; } config_entry_map_head; -typedef struct config_entries_iterator { +typedef struct config_list_iterator { git_config_iterator parent; - git_config_entries *entries; + git_config_list *list; config_entry_list *head; -} config_entries_iterator; +} config_list_iterator; -struct git_config_entries { +struct git_config_list { git_refcount rc; git_strmap *map; - config_entry_list *list; + config_entry_list *entries; }; -int git_config_entries_new(git_config_entries **out) +int git_config_list_new(git_config_list **out) { - git_config_entries *entries; + git_config_list *config_list; int error; - entries = git__calloc(1, sizeof(git_config_entries)); - GIT_ERROR_CHECK_ALLOC(entries); - GIT_REFCOUNT_INC(entries); + config_list = git__calloc(1, sizeof(git_config_list)); + GIT_ERROR_CHECK_ALLOC(config_list); + GIT_REFCOUNT_INC(config_list); - if ((error = git_strmap_new(&entries->map)) < 0) - git__free(entries); + if ((error = git_strmap_new(&config_list->map)) < 0) + git__free(config_list); else - *out = entries; + *out = config_list; return error; } -int git_config_entries_dup_entry(git_config_entries *entries, const git_config_entry *entry) +int git_config_list_dup_entry(git_config_list *config_list, const git_config_entry *entry) { git_config_entry *duplicated; int error; @@ -65,7 +65,7 @@ int git_config_entries_dup_entry(git_config_entries *entries, const git_config_e duplicated->level = entry->level; duplicated->include_depth = entry->include_depth; - if ((error = git_config_entries_append(entries, duplicated)) < 0) + if ((error = git_config_list_append(config_list, duplicated)) < 0) goto out; out: @@ -77,78 +77,79 @@ int git_config_entries_dup_entry(git_config_entries *entries, const git_config_e return error; } -int git_config_entries_dup(git_config_entries **out, git_config_entries *entries) +int git_config_list_dup(git_config_list **out, git_config_list *config_list) { - git_config_entries *result = NULL; + git_config_list *result = NULL; config_entry_list *head; int error; - if ((error = git_config_entries_new(&result)) < 0) + if ((error = git_config_list_new(&result)) < 0) goto out; - for (head = entries->list; head; head = head->next) - if ((git_config_entries_dup_entry(result, head->entry)) < 0) + for (head = config_list->entries; head; head = head->next) + if ((git_config_list_dup_entry(result, head->entry)) < 0) goto out; *out = result; result = NULL; out: - git_config_entries_free(result); + git_config_list_free(result); return error; } -void git_config_entries_incref(git_config_entries *entries) +void git_config_list_incref(git_config_list *config_list) { - GIT_REFCOUNT_INC(entries); + GIT_REFCOUNT_INC(config_list); } -static void config_entries_free(git_config_entries *entries) +static void config_list_free(git_config_list *config_list) { - config_entry_list *list = NULL, *next; + config_entry_list *entry_list = NULL, *next; config_entry_map_head *head; - git_strmap_foreach_value(entries->map, head, - git__free((char *) head->entry->name); git__free(head) - ); - git_strmap_free(entries->map); - - list = entries->list; - while (list != NULL) { - next = list->next; - git__free((char *) list->entry->value); - git__free(list->entry); - git__free(list); - list = next; + git_strmap_foreach_value(config_list->map, head, { + git__free((char *) head->entry->name); + git__free(head); + }); + git_strmap_free(config_list->map); + + entry_list = config_list->entries; + while (entry_list != NULL) { + next = entry_list->next; + git__free((char *) entry_list->entry->value); + git__free(entry_list->entry); + git__free(entry_list); + entry_list = next; } - git__free(entries); + git__free(config_list); } -void git_config_entries_free(git_config_entries *entries) +void git_config_list_free(git_config_list *config_list) { - if (entries) - GIT_REFCOUNT_DEC(entries, config_entries_free); + if (config_list) + GIT_REFCOUNT_DEC(config_list, config_list_free); } -int git_config_entries_append(git_config_entries *entries, git_config_entry *entry) +int git_config_list_append(git_config_list *config_list, git_config_entry *entry) { config_entry_list *list_head; config_entry_map_head *map_head; - if ((map_head = git_strmap_get(entries->map, entry->name)) != NULL) { + if ((map_head = git_strmap_get(config_list->map, entry->name)) != NULL) { map_head->multivar = true; /* * This is a micro-optimization for configuration files * with a lot of same keys. As for multivars the entry's - * key will be the same for all entries, we can just free + * key will be the same for all list, we can just free * all except the first entry's name and just re-use it. */ git__free((char *) entry->name); entry->name = map_head->entry->name; } else { map_head = git__calloc(1, sizeof(*map_head)); - if ((git_strmap_set(entries->map, entry->name, map_head)) < 0) + if ((git_strmap_set(config_list->map, entry->name, map_head)) < 0) return -1; } map_head->entry = entry; @@ -157,29 +158,29 @@ int git_config_entries_append(git_config_entries *entries, git_config_entry *ent GIT_ERROR_CHECK_ALLOC(list_head); list_head->entry = entry; - if (entries->list) - entries->list->last->next = list_head; + if (config_list->entries) + config_list->entries->last->next = list_head; else - entries->list = list_head; - entries->list->last = list_head; + config_list->entries = list_head; + config_list->entries->last = list_head; return 0; } -int git_config_entries_get(git_config_entry **out, git_config_entries *entries, const char *key) +int git_config_list_get(git_config_entry **out, git_config_list *config_list, const char *key) { config_entry_map_head *entry; - if ((entry = git_strmap_get(entries->map, key)) == NULL) + if ((entry = git_strmap_get(config_list->map, key)) == NULL) return GIT_ENOTFOUND; *out = entry->entry; return 0; } -int git_config_entries_get_unique(git_config_entry **out, git_config_entries *entries, const char *key) +int git_config_list_get_unique(git_config_entry **out, git_config_list *config_list, const char *key) { config_entry_map_head *entry; - if ((entry = git_strmap_get(entries->map, key)) == NULL) + if ((entry = git_strmap_get(config_list->map, key)) == NULL) return GIT_ENOTFOUND; if (entry->multivar) { @@ -199,8 +200,8 @@ int git_config_entries_get_unique(git_config_entry **out, git_config_entries *en static void config_iterator_free(git_config_iterator *iter) { - config_entries_iterator *it = (config_entries_iterator *) iter; - git_config_entries_free(it->entries); + config_list_iterator *it = (config_list_iterator *) iter; + git_config_list_free(it->list); git__free(it); } @@ -208,7 +209,7 @@ static int config_iterator_next( git_config_entry **entry, git_config_iterator *iter) { - config_entries_iterator *it = (config_entries_iterator *) iter; + config_list_iterator *it = (config_list_iterator *) iter; if (!it->head) return GIT_ITEROVER; @@ -219,18 +220,18 @@ static int config_iterator_next( return 0; } -int git_config_entries_iterator_new(git_config_iterator **out, git_config_entries *entries) +int git_config_list_iterator_new(git_config_iterator **out, git_config_list *config_list) { - config_entries_iterator *it; + config_list_iterator *it; - it = git__calloc(1, sizeof(config_entries_iterator)); + it = git__calloc(1, sizeof(config_list_iterator)); GIT_ERROR_CHECK_ALLOC(it); it->parent.next = config_iterator_next; it->parent.free = config_iterator_free; - it->head = entries->list; - it->entries = entries; + it->head = config_list->entries; + it->list = config_list; - git_config_entries_incref(entries); + git_config_list_incref(config_list); *out = &it->parent; return 0; diff --git a/src/libgit2/config_list.h b/src/libgit2/config_list.h new file mode 100644 index 00000000000..e14e4aed023 --- /dev/null +++ b/src/libgit2/config_list.h @@ -0,0 +1,24 @@ +/* + * Copyright (C) the libgit2 contributors. All rights reserved. + * + * This file is part of libgit2, distributed under the GNU GPL v2 with + * a Linking Exception. For full terms see the included COPYING file. + */ + +#include "common.h" + +#include "git2/sys/config.h" +#include "config.h" + +typedef struct git_config_list git_config_list; + +int git_config_list_new(git_config_list **out); +int git_config_list_dup(git_config_list **out, git_config_list *list); +int git_config_list_dup_entry(git_config_list *list, const git_config_entry *entry); +void git_config_list_incref(git_config_list *list); +void git_config_list_free(git_config_list *list); +/* Add or append the new config option */ +int git_config_list_append(git_config_list *list, git_config_entry *entry); +int git_config_list_get(git_config_entry **out, git_config_list *list, const char *key); +int git_config_list_get_unique(git_config_entry **out, git_config_list *list, const char *key); +int git_config_list_iterator_new(git_config_iterator **out, git_config_list *list); diff --git a/src/libgit2/config_mem.c b/src/libgit2/config_mem.c index 560229cf534..902bf99e6a3 100644 --- a/src/libgit2/config_mem.c +++ b/src/libgit2/config_mem.c @@ -9,16 +9,16 @@ #include "config_backend.h" #include "config_parse.h" -#include "config_entries.h" +#include "config_list.h" typedef struct { git_config_backend parent; - git_config_entries *entries; + git_config_list *config_list; git_str cfg; } config_memory_backend; typedef struct { - git_config_entries *entries; + git_config_list *config_list; git_config_level_t level; } config_memory_parse_data; @@ -69,7 +69,7 @@ static int read_variable_cb( entry->level = parse_data->level; entry->include_depth = 0; - if ((result = git_config_entries_append(parse_data->entries, entry)) < 0) + if ((result = git_config_list_append(parse_data->config_list, entry)) < 0) return result; return result; @@ -87,7 +87,7 @@ static int config_memory_open(git_config_backend *backend, git_config_level_t le if ((error = git_config_parser_init(&parser, "in-memory", memory_backend->cfg.ptr, memory_backend->cfg.size)) < 0) goto out; - parse_data.entries = memory_backend->entries; + parse_data.config_list = memory_backend->config_list; parse_data.level = level; if ((error = git_config_parse(&parser, NULL, read_variable_cb, NULL, NULL, &parse_data)) < 0) @@ -101,7 +101,7 @@ static int config_memory_open(git_config_backend *backend, git_config_level_t le static int config_memory_get(git_config_backend *backend, const char *key, git_config_entry **out) { config_memory_backend *memory_backend = (config_memory_backend *) backend; - return git_config_entries_get(out, memory_backend->entries, key); + return git_config_list_get(out, memory_backend->config_list, key); } static int config_memory_iterator( @@ -109,18 +109,18 @@ static int config_memory_iterator( git_config_backend *backend) { config_memory_backend *memory_backend = (config_memory_backend *) backend; - git_config_entries *entries; + git_config_list *config_list; int error; - if ((error = git_config_entries_dup(&entries, memory_backend->entries)) < 0) + if ((error = git_config_list_dup(&config_list, memory_backend->config_list)) < 0) goto out; - if ((error = git_config_entries_iterator_new(iter, entries)) < 0) + if ((error = git_config_list_iterator_new(iter, config_list)) < 0) goto out; out: - /* Let iterator delete duplicated entries when it's done */ - git_config_entries_free(entries); + /* Let iterator delete duplicated config_list when it's done */ + git_config_list_free(config_list); return error; } @@ -177,7 +177,7 @@ static void config_memory_free(git_config_backend *_backend) if (backend == NULL) return; - git_config_entries_free(backend->entries); + git_config_list_free(backend->config_list); git_str_dispose(&backend->cfg); git__free(backend); } @@ -189,13 +189,13 @@ int git_config_backend_from_string(git_config_backend **out, const char *cfg, si backend = git__calloc(1, sizeof(config_memory_backend)); GIT_ERROR_CHECK_ALLOC(backend); - if (git_config_entries_new(&backend->entries) < 0) { + if (git_config_list_new(&backend->config_list) < 0) { git__free(backend); return -1; } if (git_str_set(&backend->cfg, cfg, len) < 0) { - git_config_entries_free(backend->entries); + git_config_list_free(backend->config_list); git__free(backend); return -1; } diff --git a/src/libgit2/config_snapshot.c b/src/libgit2/config_snapshot.c index e295d2f7f28..dbd05ffdce7 100644 --- a/src/libgit2/config_snapshot.c +++ b/src/libgit2/config_snapshot.c @@ -8,12 +8,12 @@ #include "config_backend.h" #include "config.h" -#include "config_entries.h" +#include "config_list.h" typedef struct { git_config_backend parent; git_mutex values_mutex; - git_config_entries *entries; + git_config_list *config_list; git_config_backend *source; } config_snapshot_backend; @@ -28,30 +28,30 @@ static int config_snapshot_iterator( struct git_config_backend *backend) { config_snapshot_backend *b = GIT_CONTAINER_OF(backend, config_snapshot_backend, parent); - git_config_entries *entries = NULL; + git_config_list *config_list = NULL; int error; - if ((error = git_config_entries_dup(&entries, b->entries)) < 0 || - (error = git_config_entries_iterator_new(iter, entries)) < 0) + if ((error = git_config_list_dup(&config_list, b->config_list)) < 0 || + (error = git_config_list_iterator_new(iter, config_list)) < 0) goto out; out: - /* Let iterator delete duplicated entries when it's done */ - git_config_entries_free(entries); + /* Let iterator delete duplicated config_list when it's done */ + git_config_list_free(config_list); return error; } /* release the map containing the entry as an equivalent to freeing it */ static void config_snapshot_entry_free(git_config_entry *entry) { - git_config_entries *entries = (git_config_entries *) entry->payload; - git_config_entries_free(entries); + git_config_list *config_list = (git_config_list *) entry->payload; + git_config_list_free(config_list); } static int config_snapshot_get(git_config_backend *cfg, const char *key, git_config_entry **out) { config_snapshot_backend *b = GIT_CONTAINER_OF(cfg, config_snapshot_backend, parent); - git_config_entries *entries = NULL; + git_config_list *config_list = NULL; git_config_entry *entry; int error = 0; @@ -60,17 +60,17 @@ static int config_snapshot_get(git_config_backend *cfg, const char *key, git_con return -1; } - entries = b->entries; - git_config_entries_incref(entries); + config_list = b->config_list; + git_config_list_incref(config_list); git_mutex_unlock(&b->values_mutex); - if ((error = (git_config_entries_get(&entry, entries, key))) < 0) { - git_config_entries_free(entries); + if ((error = (git_config_list_get(&entry, config_list, key))) < 0) { + git_config_list_free(config_list); return error; } entry->free = config_snapshot_entry_free; - entry->payload = entries; + entry->payload = config_list; *out = entry; return 0; @@ -135,7 +135,7 @@ static void config_snapshot_free(git_config_backend *_backend) if (backend == NULL) return; - git_config_entries_free(backend->entries); + git_config_list_free(backend->config_list); git_mutex_free(&backend->values_mutex); git__free(backend); } @@ -143,7 +143,7 @@ static void config_snapshot_free(git_config_backend *_backend) static int config_snapshot_open(git_config_backend *cfg, git_config_level_t level, const git_repository *repo) { config_snapshot_backend *b = GIT_CONTAINER_OF(cfg, config_snapshot_backend, parent); - git_config_entries *entries = NULL; + git_config_list *config_list = NULL; git_config_iterator *it = NULL; git_config_entry *entry; int error; @@ -152,12 +152,12 @@ static int config_snapshot_open(git_config_backend *cfg, git_config_level_t leve GIT_UNUSED(level); GIT_UNUSED(repo); - if ((error = git_config_entries_new(&entries)) < 0 || + if ((error = git_config_list_new(&config_list)) < 0 || (error = b->source->iterator(&it, b->source)) < 0) goto out; while ((error = git_config_next(&entry, it)) == 0) - if ((error = git_config_entries_dup_entry(entries, entry)) < 0) + if ((error = git_config_list_dup_entry(config_list, entry)) < 0) goto out; if (error < 0) { @@ -166,12 +166,12 @@ static int config_snapshot_open(git_config_backend *cfg, git_config_level_t leve error = 0; } - b->entries = entries; + b->config_list = config_list; out: git_config_iterator_free(it); if (error) - git_config_entries_free(entries); + git_config_list_free(config_list); return error; } From a8cac7ff7d5b760fe7c5114a1e7e580b37e764a4 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Wed, 19 Jul 2023 12:50:16 +0100 Subject: [PATCH 318/608] config: drop entry payload; teach config_list about entries The opaque `payload` on an entry is unnecessary and distracting; config entries should follow the patterns of other objects and use space elsewhere in the structure with a "base" config entry struct embedded. --- include/git2/config.h | 8 +++-- src/libgit2/config_file.c | 56 ++++++++++++++++---------------- src/libgit2/config_list.c | 61 +++++++++++++++++++++-------------- src/libgit2/config_list.h | 13 ++++++-- src/libgit2/config_mem.c | 23 +++++++++---- src/libgit2/config_snapshot.c | 14 ++------ 6 files changed, 98 insertions(+), 77 deletions(-) diff --git a/include/git2/config.h b/include/git2/config.h index cfab0c75739..155a2996205 100644 --- a/include/git2/config.h +++ b/include/git2/config.h @@ -66,8 +66,12 @@ typedef struct git_config_entry { const char *value; /**< String value of the entry */ unsigned int include_depth; /**< Depth of includes where this variable was found */ git_config_level_t level; /**< Which config file this was found in */ - void GIT_CALLBACK(free)(struct git_config_entry *entry); /**< Free function for this entry */ - void *payload; /**< Opaque value for the free function. Do not read or write */ + + /** + * Free function for this entry; for internal purposes. Callers + * should call `git_config_entry_free` to free data. + */ + void GIT_CALLBACK(free)(struct git_config_entry *entry); } git_config_entry; /** diff --git a/src/libgit2/config_file.c b/src/libgit2/config_file.c index 41241f1b0f5..46ef07533b6 100644 --- a/src/libgit2/config_file.c +++ b/src/libgit2/config_file.c @@ -293,7 +293,7 @@ static int config_file_set(git_config_backend *cfg, const char *name, const char { config_file_backend *b = GIT_CONTAINER_OF(cfg, config_file_backend, parent); git_config_list *config_list; - git_config_entry *existing; + git_config_list_entry *existing; char *key, *esc_value = NULL; int error; @@ -308,8 +308,8 @@ static int config_file_set(git_config_backend *cfg, const char *name, const char if (error != GIT_ENOTFOUND) goto out; error = 0; - } else if ((!existing->value && !value) || - (existing->value && value && !strcmp(existing->value, value))) { + } else if ((!existing->base.value && !value) || + (existing->base.value && value && !strcmp(existing->base.value, value))) { /* don't update if old and new values already match */ error = 0; goto out; @@ -331,13 +331,6 @@ static int config_file_set(git_config_backend *cfg, const char *name, const char return error; } -/* release the map containing the entry as an equivalent to freeing it */ -static void config_file_entry_free(git_config_entry *entry) -{ - git_config_list *config_list = (git_config_list *) entry->payload; - git_config_list_free(config_list); -} - /* * Internal function that actually gets the value in string form */ @@ -345,7 +338,7 @@ static int config_file_get(git_config_backend *cfg, const char *key, git_config_ { config_file_backend *h = GIT_CONTAINER_OF(cfg, config_file_backend, parent); git_config_list *config_list = NULL; - git_config_entry *entry; + git_config_list_entry *entry; int error = 0; if (!h->parent.readonly && ((error = config_file_refresh(cfg)) < 0)) @@ -359,7 +352,7 @@ static int config_file_get(git_config_backend *cfg, const char *key, git_config_ return error; } - *out = entry; + *out = &entry->base; return 0; } @@ -395,7 +388,7 @@ static int config_file_delete(git_config_backend *cfg, const char *name) { config_file_backend *b = GIT_CONTAINER_OF(cfg, config_file_backend, parent); git_config_list *config_list = NULL; - git_config_entry *entry; + git_config_list_entry *entry; char *key = NULL; int error; @@ -412,7 +405,7 @@ static int config_file_delete(git_config_backend *cfg, const char *name) goto out; } - if ((error = config_file_write(b, name, entry->name, NULL, NULL)) < 0) + if ((error = config_file_write(b, name, entry->base.name, NULL, NULL)) < 0) goto out; out: @@ -425,7 +418,7 @@ static int config_file_delete_multivar(git_config_backend *cfg, const char *name { config_file_backend *b = GIT_CONTAINER_OF(cfg, config_file_backend, parent); git_config_list *config_list = NULL; - git_config_entry *entry = NULL; + git_config_list_entry *entry = NULL; git_regexp preg = GIT_REGEX_INIT; char *key = NULL; int result; @@ -774,7 +767,7 @@ static int read_on_variable( { config_file_parse_data *parse_data = (config_file_parse_data *)data; git_str buf = GIT_STR_INIT; - git_config_entry *entry; + git_config_list_entry *entry; const char *c; int result = 0; @@ -797,14 +790,21 @@ static int read_on_variable( if (git_str_oom(&buf)) return -1; - entry = git__calloc(1, sizeof(git_config_entry)); + entry = git__calloc(1, sizeof(git_config_list_entry)); GIT_ERROR_CHECK_ALLOC(entry); - entry->name = git_str_detach(&buf); - entry->value = var_value ? git__strdup(var_value) : NULL; - entry->level = parse_data->level; - entry->include_depth = parse_data->depth; - entry->free = config_file_entry_free; - entry->payload = parse_data->config_list; + + entry->base.name = git_str_detach(&buf); + GIT_ERROR_CHECK_ALLOC(entry->base.name); + + if (var_value) { + entry->base.value = git__strdup(var_value); + GIT_ERROR_CHECK_ALLOC(entry->base.value); + } + + entry->base.level = parse_data->level; + entry->base.include_depth = parse_data->depth; + entry->base.free = git_config_list_entry_free; + entry->config_list = parse_data->config_list; if ((result = git_config_list_append(parse_data->config_list, entry)) < 0) return result; @@ -812,11 +812,11 @@ static int read_on_variable( result = 0; /* Add or append the new config option */ - if (!git__strcmp(entry->name, "include.path")) - result = parse_include(parse_data, entry->value); - else if (!git__prefixcmp(entry->name, "includeif.") && - !git__suffixcmp(entry->name, ".path")) - result = parse_conditional_include(parse_data, entry->name, entry->value); + if (!git__strcmp(entry->base.name, "include.path")) + result = parse_include(parse_data, entry->base.value); + else if (!git__prefixcmp(entry->base.name, "includeif.") && + !git__suffixcmp(entry->base.name, ".path")) + result = parse_conditional_include(parse_data, entry->base.name, entry->base.value); return result; } diff --git a/src/libgit2/config_list.c b/src/libgit2/config_list.c index 01d41526e98..979c6ccff99 100644 --- a/src/libgit2/config_list.c +++ b/src/libgit2/config_list.c @@ -10,11 +10,11 @@ typedef struct config_entry_list { struct config_entry_list *next; struct config_entry_list *last; - git_config_entry *entry; + git_config_list_entry *entry; } config_entry_list; typedef struct { - git_config_entry *entry; + git_config_list_entry *entry; bool multivar; } config_entry_map_head; @@ -49,29 +49,32 @@ int git_config_list_new(git_config_list **out) int git_config_list_dup_entry(git_config_list *config_list, const git_config_entry *entry) { - git_config_entry *duplicated; + git_config_list_entry *duplicated; int error; - duplicated = git__calloc(1, sizeof(git_config_entry)); + duplicated = git__calloc(1, sizeof(git_config_list_entry)); GIT_ERROR_CHECK_ALLOC(duplicated); - duplicated->name = git__strdup(entry->name); - GIT_ERROR_CHECK_ALLOC(duplicated->name); + duplicated->base.name = git__strdup(entry->name); + GIT_ERROR_CHECK_ALLOC(duplicated->base.name); if (entry->value) { - duplicated->value = git__strdup(entry->value); - GIT_ERROR_CHECK_ALLOC(duplicated->value); + duplicated->base.value = git__strdup(entry->value); + GIT_ERROR_CHECK_ALLOC(duplicated->base.value); } - duplicated->level = entry->level; - duplicated->include_depth = entry->include_depth; + + duplicated->base.level = entry->level; + duplicated->base.include_depth = entry->include_depth; + duplicated->base.free = git_config_list_entry_free; + duplicated->config_list = config_list; if ((error = git_config_list_append(config_list, duplicated)) < 0) goto out; out: if (error && duplicated) { - git__free((char *) duplicated->name); - git__free((char *) duplicated->value); + git__free((char *) duplicated->base.name); + git__free((char *) duplicated->base.value); git__free(duplicated); } return error; @@ -87,7 +90,7 @@ int git_config_list_dup(git_config_list **out, git_config_list *config_list) goto out; for (head = config_list->entries; head; head = head->next) - if ((git_config_list_dup_entry(result, head->entry)) < 0) + if ((git_config_list_dup_entry(result, &head->entry->base)) < 0) goto out; *out = result; @@ -109,7 +112,7 @@ static void config_list_free(git_config_list *config_list) config_entry_map_head *head; git_strmap_foreach_value(config_list->map, head, { - git__free((char *) head->entry->name); + git__free((char *) head->entry->base.name); git__free(head); }); git_strmap_free(config_list->map); @@ -117,7 +120,7 @@ static void config_list_free(git_config_list *config_list) entry_list = config_list->entries; while (entry_list != NULL) { next = entry_list->next; - git__free((char *) entry_list->entry->value); + git__free((char *) entry_list->entry->base.value); git__free(entry_list->entry); git__free(entry_list); entry_list = next; @@ -132,12 +135,12 @@ void git_config_list_free(git_config_list *config_list) GIT_REFCOUNT_DEC(config_list, config_list_free); } -int git_config_list_append(git_config_list *config_list, git_config_entry *entry) +int git_config_list_append(git_config_list *config_list, git_config_list_entry *entry) { config_entry_list *list_head; config_entry_map_head *map_head; - if ((map_head = git_strmap_get(config_list->map, entry->name)) != NULL) { + if ((map_head = git_strmap_get(config_list->map, entry->base.name)) != NULL) { map_head->multivar = true; /* * This is a micro-optimization for configuration files @@ -145,11 +148,11 @@ int git_config_list_append(git_config_list *config_list, git_config_entry *entry * key will be the same for all list, we can just free * all except the first entry's name and just re-use it. */ - git__free((char *) entry->name); - entry->name = map_head->entry->name; + git__free((char *) entry->base.name); + entry->base.name = map_head->entry->base.name; } else { map_head = git__calloc(1, sizeof(*map_head)); - if ((git_strmap_set(config_list->map, entry->name, map_head)) < 0) + if ((git_strmap_set(config_list->map, entry->base.name, map_head)) < 0) return -1; } map_head->entry = entry; @@ -167,16 +170,18 @@ int git_config_list_append(git_config_list *config_list, git_config_entry *entry return 0; } -int git_config_list_get(git_config_entry **out, git_config_list *config_list, const char *key) +int git_config_list_get(git_config_list_entry **out, git_config_list *config_list, const char *key) { config_entry_map_head *entry; + if ((entry = git_strmap_get(config_list->map, key)) == NULL) return GIT_ENOTFOUND; + *out = entry->entry; return 0; } -int git_config_list_get_unique(git_config_entry **out, git_config_list *config_list, const char *key) +int git_config_list_get_unique(git_config_list_entry **out, git_config_list *config_list, const char *key) { config_entry_map_head *entry; @@ -188,13 +193,12 @@ int git_config_list_get_unique(git_config_entry **out, git_config_list *config_l return -1; } - if (entry->entry->include_depth) { + if (entry->entry->base.include_depth) { git_error_set(GIT_ERROR_CONFIG, "entry is not unique due to being included"); return -1; } *out = entry->entry; - return 0; } @@ -214,7 +218,7 @@ static int config_iterator_next( if (!it->head) return GIT_ITEROVER; - *entry = it->head->entry; + *entry = &it->head->entry->base; it->head = it->head->next; return 0; @@ -236,3 +240,10 @@ int git_config_list_iterator_new(git_config_iterator **out, git_config_list *con return 0; } + +/* release the map containing the entry as an equivalent to freeing it */ +void git_config_list_entry_free(git_config_entry *e) +{ + git_config_list_entry *entry = (git_config_list_entry *)e; + git_config_list_free(entry->config_list); +} diff --git a/src/libgit2/config_list.h b/src/libgit2/config_list.h index e14e4aed023..0cacabb110d 100644 --- a/src/libgit2/config_list.h +++ b/src/libgit2/config_list.h @@ -12,13 +12,20 @@ typedef struct git_config_list git_config_list; +typedef struct { + git_config_entry base; + git_config_list *config_list; +} git_config_list_entry; + int git_config_list_new(git_config_list **out); int git_config_list_dup(git_config_list **out, git_config_list *list); int git_config_list_dup_entry(git_config_list *list, const git_config_entry *entry); void git_config_list_incref(git_config_list *list); void git_config_list_free(git_config_list *list); /* Add or append the new config option */ -int git_config_list_append(git_config_list *list, git_config_entry *entry); -int git_config_list_get(git_config_entry **out, git_config_list *list, const char *key); -int git_config_list_get_unique(git_config_entry **out, git_config_list *list, const char *key); +int git_config_list_append(git_config_list *list, git_config_list_entry *entry); +int git_config_list_get(git_config_list_entry **out, git_config_list *list, const char *key); +int git_config_list_get_unique(git_config_list_entry **out, git_config_list *list, const char *key); int git_config_list_iterator_new(git_config_iterator **out, git_config_list *list); + +void git_config_list_entry_free(git_config_entry *entry); diff --git a/src/libgit2/config_mem.c b/src/libgit2/config_mem.c index 902bf99e6a3..37f5b01f983 100644 --- a/src/libgit2/config_mem.c +++ b/src/libgit2/config_mem.c @@ -39,7 +39,7 @@ static int read_variable_cb( { config_memory_parse_data *parse_data = (config_memory_parse_data *) payload; git_str buf = GIT_STR_INIT; - git_config_entry *entry; + git_config_list_entry *entry; const char *c; int result; @@ -62,12 +62,14 @@ static int read_variable_cb( if (git_str_oom(&buf)) return -1; - entry = git__calloc(1, sizeof(git_config_entry)); + entry = git__calloc(1, sizeof(git_config_list_entry)); GIT_ERROR_CHECK_ALLOC(entry); - entry->name = git_str_detach(&buf); - entry->value = var_value ? git__strdup(var_value) : NULL; - entry->level = parse_data->level; - entry->include_depth = 0; + entry->base.name = git_str_detach(&buf); + entry->base.value = var_value ? git__strdup(var_value) : NULL; + entry->base.level = parse_data->level; + entry->base.include_depth = 0; + entry->base.free = git_config_list_entry_free; + entry->config_list = parse_data->config_list; if ((result = git_config_list_append(parse_data->config_list, entry)) < 0) return result; @@ -101,7 +103,14 @@ static int config_memory_open(git_config_backend *backend, git_config_level_t le static int config_memory_get(git_config_backend *backend, const char *key, git_config_entry **out) { config_memory_backend *memory_backend = (config_memory_backend *) backend; - return git_config_list_get(out, memory_backend->config_list, key); + git_config_list_entry *entry; + int error; + + if ((error = git_config_list_get(&entry, memory_backend->config_list, key)) != 0) + return error; + + *out = &entry->base; + return 0; } static int config_memory_iterator( diff --git a/src/libgit2/config_snapshot.c b/src/libgit2/config_snapshot.c index dbd05ffdce7..d8b8733a9fb 100644 --- a/src/libgit2/config_snapshot.c +++ b/src/libgit2/config_snapshot.c @@ -41,18 +41,11 @@ static int config_snapshot_iterator( return error; } -/* release the map containing the entry as an equivalent to freeing it */ -static void config_snapshot_entry_free(git_config_entry *entry) -{ - git_config_list *config_list = (git_config_list *) entry->payload; - git_config_list_free(config_list); -} - static int config_snapshot_get(git_config_backend *cfg, const char *key, git_config_entry **out) { config_snapshot_backend *b = GIT_CONTAINER_OF(cfg, config_snapshot_backend, parent); git_config_list *config_list = NULL; - git_config_entry *entry; + git_config_list_entry *entry; int error = 0; if (git_mutex_lock(&b->values_mutex) < 0) { @@ -69,10 +62,7 @@ static int config_snapshot_get(git_config_backend *cfg, const char *key, git_con return error; } - entry->free = config_snapshot_entry_free; - entry->payload = config_list; - *out = entry; - + *out = &entry->base; return 0; } From d9012202763d42ab192af736ed490ed8929fd295 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 20 Jul 2023 10:29:41 +0100 Subject: [PATCH 319/608] config: provide origin in git_config_entry A git_config_entry now knows the type of the origin for the entry ("file", "memory", etc) and the path details (for files, the path on disk). This is propagated through snapshots. --- include/git2/config.h | 24 ++++++++++++++--- src/libgit2/config_file.c | 6 +++++ src/libgit2/config_list.c | 47 +++++++++++++++++++++++++++++---- src/libgit2/config_list.h | 1 + src/libgit2/config_mem.c | 1 + tests/libgit2/config/read.c | 2 ++ tests/libgit2/config/snapshot.c | 35 +++++++++++++++++++++++- 7 files changed, 106 insertions(+), 10 deletions(-) diff --git a/include/git2/config.h b/include/git2/config.h index 155a2996205..332e62036d0 100644 --- a/include/git2/config.h +++ b/include/git2/config.h @@ -62,10 +62,26 @@ typedef enum { * An entry in a configuration file */ typedef struct git_config_entry { - const char *name; /**< Name of the entry (normalised) */ - const char *value; /**< String value of the entry */ - unsigned int include_depth; /**< Depth of includes where this variable was found */ - git_config_level_t level; /**< Which config file this was found in */ + /** Name of the configuration entry (normalized) */ + const char *name; + + /** Literal (string) value of the entry */ + const char *value; + + /** The type of backend that this entry exists in (eg, "file") */ + const char *backend_type; + + /** + * The path to the origin of this entry. For config files, this is + * the path to the file. + */ + const char *origin_path; + + /** Depth of includes where this variable was found */ + unsigned int include_depth; + + /** Configuration level for the file this was found in */ + git_config_level_t level; /** * Free function for this entry; for internal purposes. Callers diff --git a/src/libgit2/config_file.c b/src/libgit2/config_file.c index 46ef07533b6..c86e98bf2bf 100644 --- a/src/libgit2/config_file.c +++ b/src/libgit2/config_file.c @@ -24,6 +24,8 @@ /* Max depth for [include] directives */ #define MAX_INCLUDE_DEPTH 10 +#define CONFIG_FILE_TYPE "file" + typedef struct config_file { git_futils_filestamp stamp; unsigned char checksum[GIT_HASH_SHA256_SIZE]; @@ -801,7 +803,11 @@ static int read_on_variable( GIT_ERROR_CHECK_ALLOC(entry->base.value); } + entry->base.origin_path = git_config_list_add_path(parse_data->config_list, parse_data->file->path); + GIT_ERROR_CHECK_ALLOC(entry->base.origin_path); + entry->base.level = parse_data->level; + entry->base.backend_type = CONFIG_FILE_TYPE; entry->base.include_depth = parse_data->depth; entry->base.free = git_config_list_entry_free; entry->config_list = parse_data->config_list; diff --git a/src/libgit2/config_list.c b/src/libgit2/config_list.c index 979c6ccff99..f642c87a4a7 100644 --- a/src/libgit2/config_list.c +++ b/src/libgit2/config_list.c @@ -26,6 +26,11 @@ typedef struct config_list_iterator { struct git_config_list { git_refcount rc; + + /* Paths to config files that contribute to these entries */ + git_strmap *paths; + + /* Config entries */ git_strmap *map; config_entry_list *entries; }; @@ -33,18 +38,22 @@ struct git_config_list { int git_config_list_new(git_config_list **out) { git_config_list *config_list; - int error; config_list = git__calloc(1, sizeof(git_config_list)); GIT_ERROR_CHECK_ALLOC(config_list); GIT_REFCOUNT_INC(config_list); - if ((error = git_strmap_new(&config_list->map)) < 0) + if (git_strmap_new(&config_list->paths) < 0 || + git_strmap_new(&config_list->map) < 0) { + git_strmap_free(config_list->paths); + git_strmap_free(config_list->map); git__free(config_list); - else - *out = config_list; - return error; + return -1; + } + + *out = config_list; + return 0; } int git_config_list_dup_entry(git_config_list *config_list, const git_config_entry *entry) @@ -63,6 +72,12 @@ int git_config_list_dup_entry(git_config_list *config_list, const git_config_ent GIT_ERROR_CHECK_ALLOC(duplicated->base.value); } + if (entry->origin_path) { + duplicated->base.origin_path = git_config_list_add_path(config_list, entry->origin_path); + GIT_ERROR_CHECK_ALLOC(duplicated->base.origin_path); + } + + duplicated->base.backend_type = entry->backend_type; duplicated->base.level = entry->level; duplicated->base.include_depth = entry->include_depth; duplicated->base.free = git_config_list_entry_free; @@ -110,6 +125,12 @@ static void config_list_free(git_config_list *config_list) { config_entry_list *entry_list = NULL, *next; config_entry_map_head *head; + char *path; + + git_strmap_foreach_value(config_list->paths, path, { + git__free(path); + }); + git_strmap_free(config_list->paths); git_strmap_foreach_value(config_list->map, head, { git__free((char *) head->entry->base.name); @@ -247,3 +268,19 @@ void git_config_list_entry_free(git_config_entry *e) git_config_list_entry *entry = (git_config_list_entry *)e; git_config_list_free(entry->config_list); } + +const char *git_config_list_add_path( + git_config_list *config_list, + const char *path) +{ + const char *p; + + if ((p = git_strmap_get(config_list->paths, path)) != NULL) + return p; + + if ((p = git__strdup(path)) == NULL || + git_strmap_set(config_list->paths, p, (void *)p) < 0) + return NULL; + + return p; +} diff --git a/src/libgit2/config_list.h b/src/libgit2/config_list.h index 0cacabb110d..83c43b9a0ff 100644 --- a/src/libgit2/config_list.h +++ b/src/libgit2/config_list.h @@ -27,5 +27,6 @@ int git_config_list_append(git_config_list *list, git_config_list_entry *entry); int git_config_list_get(git_config_list_entry **out, git_config_list *list, const char *key); int git_config_list_get_unique(git_config_list_entry **out, git_config_list *list, const char *key); int git_config_list_iterator_new(git_config_iterator **out, git_config_list *list); +const char *git_config_list_add_path(git_config_list *list, const char *path); void git_config_list_entry_free(git_config_entry *entry); diff --git a/src/libgit2/config_mem.c b/src/libgit2/config_mem.c index 37f5b01f983..748a1471673 100644 --- a/src/libgit2/config_mem.c +++ b/src/libgit2/config_mem.c @@ -68,6 +68,7 @@ static int read_variable_cb( entry->base.value = var_value ? git__strdup(var_value) : NULL; entry->base.level = parse_data->level; entry->base.include_depth = 0; + entry->base.backend_type = "memory"; entry->base.free = git_config_list_entry_free; entry->config_list = parse_data->config_list; diff --git a/tests/libgit2/config/read.c b/tests/libgit2/config/read.c index ac6459b9ea6..25e7b963c4d 100644 --- a/tests/libgit2/config/read.c +++ b/tests/libgit2/config/read.c @@ -495,6 +495,8 @@ void test_config_read__read_git_config_entry(void) cl_assert_equal_s("core.dummy2", entry->name); cl_assert_equal_s("42", entry->value); cl_assert_equal_i(GIT_CONFIG_LEVEL_SYSTEM, entry->level); + cl_assert_equal_s("file", entry->backend_type); + cl_assert_equal_s(cl_fixture("config/config9"), entry->origin_path); git_config_entry_free(entry); git_config_free(cfg); diff --git a/tests/libgit2/config/snapshot.c b/tests/libgit2/config/snapshot.c index 5cc08a721ac..bfb68e21e23 100644 --- a/tests/libgit2/config/snapshot.c +++ b/tests/libgit2/config/snapshot.c @@ -79,6 +79,7 @@ void test_config_snapshot__multivar(void) void test_config_snapshot__includes(void) { + git_config_entry *entry; int i; cl_git_mkfile("including", "[include]\npath = included"); @@ -99,6 +100,16 @@ void test_config_snapshot__includes(void) cl_git_pass(git_config_get_int32(&i, snapshot, "section.key")); cl_assert_equal_i(i, 1); + /* Ensure that the config entry is populated with origin */ + cl_git_pass(git_config_get_entry(&entry, snapshot, "section.key")); + + cl_assert_equal_s("section.key", entry->name); + cl_assert_equal_s("1", entry->value); + cl_assert_equal_s("file", entry->backend_type); + cl_assert_equal_s("./included", entry->origin_path); + + git_config_entry_free(entry); + cl_git_pass(p_unlink("including")); cl_git_pass(p_unlink("included")); } @@ -106,6 +117,7 @@ void test_config_snapshot__includes(void) void test_config_snapshot__snapshot(void) { git_config *snapshot_snapshot; + git_config_entry *entry; int i; cl_git_mkfile("configfile", "[section]\nkey = 1\n"); @@ -118,15 +130,26 @@ void test_config_snapshot__snapshot(void) cl_git_pass(git_config_get_int32(&i, snapshot_snapshot, "section.key")); cl_assert_equal_i(i, 1); + /* Ensure that the config entry is populated with origin */ + cl_git_pass(git_config_get_entry(&entry, snapshot_snapshot, "section.key")); + + cl_assert_equal_s("section.key", entry->name); + cl_assert_equal_s("1", entry->value); + cl_assert_equal_s("file", entry->backend_type); + cl_assert_equal_s("configfile", entry->origin_path); + + git_config_entry_free(entry); + git_config_free(snapshot_snapshot); cl_git_pass(p_unlink("configfile")); } -void test_config_snapshot__snapshot_from_in_memony(void) +void test_config_snapshot__snapshot_from_in_memory(void) { const char *configuration = "[section]\nkey = 1\n"; git_config_backend *backend; + git_config_entry *entry; int i; cl_git_pass(git_config_new(&cfg)); @@ -136,4 +159,14 @@ void test_config_snapshot__snapshot_from_in_memony(void) cl_git_pass(git_config_snapshot(&snapshot, cfg)); cl_git_pass(git_config_get_int32(&i, snapshot, "section.key")); cl_assert_equal_i(i, 1); + + /* Ensure that the config entry is populated with origin */ + cl_git_pass(git_config_get_entry(&entry, snapshot, "section.key")); + + cl_assert_equal_s("section.key", entry->name); + cl_assert_equal_s("1", entry->value); + cl_assert_equal_s("memory", entry->backend_type); + cl_assert_equal_p(NULL, entry->origin_path); + + git_config_entry_free(entry); } From 1977a9a450ed92fcfda4cc33d1e670d24ac8b568 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 20 Jul 2023 10:54:14 +0100 Subject: [PATCH 320/608] config: memory backends have an optional type --- src/libgit2/config_backend.h | 10 +++++++-- src/libgit2/config_file.c | 6 ++++-- src/libgit2/config_list.c | 38 +++++++++++++++++---------------- src/libgit2/config_list.h | 2 +- src/libgit2/config_mem.c | 17 +++++++++++++-- tests/libgit2/config/memory.c | 4 ++-- tests/libgit2/config/snapshot.c | 4 ++-- 7 files changed, 52 insertions(+), 29 deletions(-) diff --git a/src/libgit2/config_backend.h b/src/libgit2/config_backend.h index dbb19051484..677b2236f98 100644 --- a/src/libgit2/config_backend.h +++ b/src/libgit2/config_backend.h @@ -38,13 +38,19 @@ extern int git_config_backend_from_file(git_config_backend **out, const char *pa extern int git_config_backend_snapshot(git_config_backend **out, git_config_backend *source); /** - * Create an in-memory configuration file backend + * Create an in-memory configuration file backend from a string in standard + * git configuration file format. * * @param out the new backend + * @param origin the name of the origin to use (or NULL for "memory") * @param cfg the configuration that is to be parsed * @param len the length of the string pointed to by `cfg` */ -extern int git_config_backend_from_string(git_config_backend **out, const char *cfg, size_t len); +extern int git_config_backend_from_string( + git_config_backend **out, + const char *origin, + const char *cfg, + size_t len); GIT_INLINE(int) git_config_backend_open(git_config_backend *cfg, unsigned int level, const git_repository *repo) { diff --git a/src/libgit2/config_file.c b/src/libgit2/config_file.c index c86e98bf2bf..340e85691ed 100644 --- a/src/libgit2/config_file.c +++ b/src/libgit2/config_file.c @@ -803,11 +803,13 @@ static int read_on_variable( GIT_ERROR_CHECK_ALLOC(entry->base.value); } - entry->base.origin_path = git_config_list_add_path(parse_data->config_list, parse_data->file->path); + entry->base.backend_type = git_config_list_add_string(parse_data->config_list, CONFIG_FILE_TYPE); + GIT_ERROR_CHECK_ALLOC(entry->base.backend_type); + + entry->base.origin_path = git_config_list_add_string(parse_data->config_list, parse_data->file->path); GIT_ERROR_CHECK_ALLOC(entry->base.origin_path); entry->base.level = parse_data->level; - entry->base.backend_type = CONFIG_FILE_TYPE; entry->base.include_depth = parse_data->depth; entry->base.free = git_config_list_entry_free; entry->config_list = parse_data->config_list; diff --git a/src/libgit2/config_list.c b/src/libgit2/config_list.c index f642c87a4a7..0b7a4f3600a 100644 --- a/src/libgit2/config_list.c +++ b/src/libgit2/config_list.c @@ -27,8 +27,8 @@ typedef struct config_list_iterator { struct git_config_list { git_refcount rc; - /* Paths to config files that contribute to these entries */ - git_strmap *paths; + /* Interned strings - paths to config files or backend types */ + git_strmap *strings; /* Config entries */ git_strmap *map; @@ -43,9 +43,9 @@ int git_config_list_new(git_config_list **out) GIT_ERROR_CHECK_ALLOC(config_list); GIT_REFCOUNT_INC(config_list); - if (git_strmap_new(&config_list->paths) < 0 || + if (git_strmap_new(&config_list->strings) < 0 || git_strmap_new(&config_list->map) < 0) { - git_strmap_free(config_list->paths); + git_strmap_free(config_list->strings); git_strmap_free(config_list->map); git__free(config_list); @@ -72,12 +72,14 @@ int git_config_list_dup_entry(git_config_list *config_list, const git_config_ent GIT_ERROR_CHECK_ALLOC(duplicated->base.value); } + duplicated->base.backend_type = git_config_list_add_string(config_list, entry->backend_type); + GIT_ERROR_CHECK_ALLOC(duplicated->base.backend_type); + if (entry->origin_path) { - duplicated->base.origin_path = git_config_list_add_path(config_list, entry->origin_path); + duplicated->base.origin_path = git_config_list_add_string(config_list, entry->origin_path); GIT_ERROR_CHECK_ALLOC(duplicated->base.origin_path); } - duplicated->base.backend_type = entry->backend_type; duplicated->base.level = entry->level; duplicated->base.include_depth = entry->include_depth; duplicated->base.free = git_config_list_entry_free; @@ -125,12 +127,12 @@ static void config_list_free(git_config_list *config_list) { config_entry_list *entry_list = NULL, *next; config_entry_map_head *head; - char *path; + char *str; - git_strmap_foreach_value(config_list->paths, path, { - git__free(path); + git_strmap_foreach_value(config_list->strings, str, { + git__free(str); }); - git_strmap_free(config_list->paths); + git_strmap_free(config_list->strings); git_strmap_foreach_value(config_list->map, head, { git__free((char *) head->entry->base.name); @@ -269,18 +271,18 @@ void git_config_list_entry_free(git_config_entry *e) git_config_list_free(entry->config_list); } -const char *git_config_list_add_path( +const char *git_config_list_add_string( git_config_list *config_list, - const char *path) + const char *str) { - const char *p; + const char *s; - if ((p = git_strmap_get(config_list->paths, path)) != NULL) - return p; + if ((s = git_strmap_get(config_list->strings, str)) != NULL) + return s; - if ((p = git__strdup(path)) == NULL || - git_strmap_set(config_list->paths, p, (void *)p) < 0) + if ((s = git__strdup(str)) == NULL || + git_strmap_set(config_list->strings, s, (void *)s) < 0) return NULL; - return p; + return s; } diff --git a/src/libgit2/config_list.h b/src/libgit2/config_list.h index 83c43b9a0ff..023bca1e5ca 100644 --- a/src/libgit2/config_list.h +++ b/src/libgit2/config_list.h @@ -27,6 +27,6 @@ int git_config_list_append(git_config_list *list, git_config_list_entry *entry); int git_config_list_get(git_config_list_entry **out, git_config_list *list, const char *key); int git_config_list_get_unique(git_config_list_entry **out, git_config_list *list, const char *key); int git_config_list_iterator_new(git_config_iterator **out, git_config_list *list); -const char *git_config_list_add_path(git_config_list *list, const char *path); +const char *git_config_list_add_string(git_config_list *list, const char *str); void git_config_list_entry_free(git_config_entry *entry); diff --git a/src/libgit2/config_mem.c b/src/libgit2/config_mem.c index 748a1471673..8faa53dcba5 100644 --- a/src/libgit2/config_mem.c +++ b/src/libgit2/config_mem.c @@ -13,11 +13,13 @@ typedef struct { git_config_backend parent; + char *type; git_config_list *config_list; git_str cfg; } config_memory_backend; typedef struct { + const char *backend_type; git_config_list *config_list; git_config_level_t level; } config_memory_parse_data; @@ -68,7 +70,7 @@ static int read_variable_cb( entry->base.value = var_value ? git__strdup(var_value) : NULL; entry->base.level = parse_data->level; entry->base.include_depth = 0; - entry->base.backend_type = "memory"; + entry->base.backend_type = parse_data->backend_type; entry->base.free = git_config_list_entry_free; entry->config_list = parse_data->config_list; @@ -90,6 +92,9 @@ static int config_memory_open(git_config_backend *backend, git_config_level_t le if ((error = git_config_parser_init(&parser, "in-memory", memory_backend->cfg.ptr, memory_backend->cfg.size)) < 0) goto out; + + parse_data.backend_type = git_config_list_add_string( + memory_backend->config_list, memory_backend->type); parse_data.config_list = memory_backend->config_list; parse_data.level = level; @@ -187,12 +192,17 @@ static void config_memory_free(git_config_backend *_backend) if (backend == NULL) return; + git__free(backend->type); git_config_list_free(backend->config_list); git_str_dispose(&backend->cfg); git__free(backend); } -int git_config_backend_from_string(git_config_backend **out, const char *cfg, size_t len) +int git_config_backend_from_string( + git_config_backend **out, + const char *backend_type, + const char *cfg, + size_t len) { config_memory_backend *backend; @@ -210,6 +220,9 @@ int git_config_backend_from_string(git_config_backend **out, const char *cfg, si return -1; } + backend->type = git__strdup(backend_type ? backend_type : "in-memory"); + GIT_ERROR_CHECK_ALLOC(backend->type); + backend->parent.version = GIT_CONFIG_BACKEND_VERSION; backend->parent.readonly = 1; backend->parent.open = config_memory_open; diff --git a/tests/libgit2/config/memory.c b/tests/libgit2/config/memory.c index ae661899da7..67a61a1c573 100644 --- a/tests/libgit2/config/memory.c +++ b/tests/libgit2/config/memory.c @@ -61,7 +61,7 @@ static void assert_config_contains_all(git_config_backend *backend, static void setup_backend(const char *cfg) { - cl_git_pass(git_config_backend_from_string(&backend, cfg, strlen(cfg))); + cl_git_pass(git_config_backend_from_string(&backend, "test", cfg, strlen(cfg))); cl_git_pass(git_config_backend_open(backend, 0, NULL)); } @@ -88,7 +88,7 @@ void test_config_memory__malformed_fails_to_open(void) const char *cfg = "[general\n" "foo=bar\n"; - cl_git_pass(git_config_backend_from_string(&backend, cfg, strlen(cfg))); + cl_git_pass(git_config_backend_from_string(&backend, "test", cfg, strlen(cfg))); cl_git_fail(git_config_backend_open(backend, 0, NULL)); } diff --git a/tests/libgit2/config/snapshot.c b/tests/libgit2/config/snapshot.c index bfb68e21e23..87a68600ee4 100644 --- a/tests/libgit2/config/snapshot.c +++ b/tests/libgit2/config/snapshot.c @@ -153,7 +153,7 @@ void test_config_snapshot__snapshot_from_in_memory(void) int i; cl_git_pass(git_config_new(&cfg)); - cl_git_pass(git_config_backend_from_string(&backend, configuration, strlen(configuration))); + cl_git_pass(git_config_backend_from_string(&backend, "test", configuration, strlen(configuration))); cl_git_pass(git_config_add_backend(cfg, backend, 0, NULL, 0)); cl_git_pass(git_config_snapshot(&snapshot, cfg)); @@ -165,7 +165,7 @@ void test_config_snapshot__snapshot_from_in_memory(void) cl_assert_equal_s("section.key", entry->name); cl_assert_equal_s("1", entry->value); - cl_assert_equal_s("memory", entry->backend_type); + cl_assert_equal_s("test", entry->backend_type); cl_assert_equal_p(NULL, entry->origin_path); git_config_entry_free(entry); From 21d3301135338ac27b4e8b8804d935bcfca633e6 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 20 Jul 2023 22:27:25 +0100 Subject: [PATCH 321/608] config: provide two memory-backed config backends Provide two memory-backed configuration backends -- one that takes a string in config file format `[section] key=value` and one that takes a list of strings in `section.key=value` format. --- fuzzers/config_file_fuzzer.c | 2 +- include/git2/sys/config.h | 51 +++++++++ src/libgit2/config_backend.h | 15 --- src/libgit2/config_mem.c | 191 +++++++++++++++++++++++++++----- src/util/strlist.c | 42 +++++++ src/util/strlist.h | 16 +++ tests/libgit2/config/memory.c | 75 ++++++++++++- tests/libgit2/config/snapshot.c | 10 +- 8 files changed, 350 insertions(+), 52 deletions(-) create mode 100644 src/util/strlist.c create mode 100644 src/util/strlist.h diff --git a/fuzzers/config_file_fuzzer.c b/fuzzers/config_file_fuzzer.c index 890adbfc528..763036960b4 100644 --- a/fuzzers/config_file_fuzzer.c +++ b/fuzzers/config_file_fuzzer.c @@ -43,7 +43,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) goto out; } - if ((err = git_config_backend_from_string(&backend, (const char*)data, size)) != 0) { + if ((err = git_config_backend_from_string(&backend, (const char*)data, size, NULL)) != 0) { goto out; } if ((err = git_config_add_backend(cfg, backend, 0, NULL, 0)) != 0) { diff --git a/include/git2/sys/config.h b/include/git2/sys/config.h index 0a9005e35d4..75d20758b84 100644 --- a/include/git2/sys/config.h +++ b/include/git2/sys/config.h @@ -125,6 +125,57 @@ GIT_EXTERN(int) git_config_add_backend( const git_repository *repo, int force); +/** Options for in-memory configuration backends. */ +typedef struct { + unsigned int version; + + /** + * The type of this backend (eg, "command line"). If this is + * NULL, then this will be "in-memory". + */ + const char *backend_type; + + /** + * The path to the origin; if this is NULL then it will be + * left unset in the resulting configuration entries. + */ + const char *origin_path; +} git_config_backend_memory_options; + +#define GIT_CONFIG_BACKEND_MEMORY_OPTIONS_VERSION 1 +#define GIT_CONFIG_BACKEND_MEMORY_OPTIONS_INIT { GIT_CONFIG_BACKEND_MEMORY_OPTIONS_VERSION } + + +/** + * Create an in-memory configuration backend from a string in standard + * git configuration file format. + * + * @param out the new backend + * @param cfg the configuration that is to be parsed + * @param len the length of the string pointed to by `cfg` + * @param opts the options to initialize this backend with, or NULL + */ +extern int git_config_backend_from_string( + git_config_backend **out, + const char *cfg, + size_t len, + git_config_backend_memory_options *opts); + +/** + * Create an in-memory configuration backend from a list of name/value + * pairs. + * + * @param out the new backend + * @param values the configuration values to set (in "key=value" format) + * @param len the length of the values array + * @param opts the options to initialize this backend with, or NULL + */ +extern int git_config_backend_from_values( + git_config_backend **out, + const char **values, + size_t len, + git_config_backend_memory_options *opts); + /** @} */ GIT_END_DECL #endif diff --git a/src/libgit2/config_backend.h b/src/libgit2/config_backend.h index 677b2236f98..37d25abe146 100644 --- a/src/libgit2/config_backend.h +++ b/src/libgit2/config_backend.h @@ -37,21 +37,6 @@ extern int git_config_backend_from_file(git_config_backend **out, const char *pa */ extern int git_config_backend_snapshot(git_config_backend **out, git_config_backend *source); -/** - * Create an in-memory configuration file backend from a string in standard - * git configuration file format. - * - * @param out the new backend - * @param origin the name of the origin to use (or NULL for "memory") - * @param cfg the configuration that is to be parsed - * @param len the length of the string pointed to by `cfg` - */ -extern int git_config_backend_from_string( - git_config_backend **out, - const char *origin, - const char *cfg, - size_t len); - GIT_INLINE(int) git_config_backend_open(git_config_backend *cfg, unsigned int level, const git_repository *repo) { return cfg->open(cfg, level, repo); diff --git a/src/libgit2/config_mem.c b/src/libgit2/config_mem.c index 8faa53dcba5..406aa83e6e1 100644 --- a/src/libgit2/config_mem.c +++ b/src/libgit2/config_mem.c @@ -10,16 +10,27 @@ #include "config_backend.h" #include "config_parse.h" #include "config_list.h" +#include "strlist.h" typedef struct { git_config_backend parent; - char *type; + + char *backend_type; + char *origin_path; + git_config_list *config_list; + + /* Configuration data in the config file format */ git_str cfg; + + /* Array of key=value pairs */ + char **values; + size_t values_len; } config_memory_backend; typedef struct { const char *backend_type; + const char *origin_path; git_config_list *config_list; git_config_level_t level; } config_memory_parse_data; @@ -71,6 +82,7 @@ static int read_variable_cb( entry->base.level = parse_data->level; entry->base.include_depth = 0; entry->base.backend_type = parse_data->backend_type; + entry->base.origin_path = parse_data->origin_path; entry->base.free = git_config_list_entry_free; entry->config_list = parse_data->config_list; @@ -80,25 +92,29 @@ static int read_variable_cb( return result; } -static int config_memory_open(git_config_backend *backend, git_config_level_t level, const git_repository *repo) +static int parse_config( + config_memory_backend *memory_backend, + git_config_level_t level) { - config_memory_backend *memory_backend = (config_memory_backend *) backend; git_config_parser parser = GIT_PARSE_CTX_INIT; config_memory_parse_data parse_data; int error; - GIT_UNUSED(repo); - - if ((error = git_config_parser_init(&parser, "in-memory", memory_backend->cfg.ptr, - memory_backend->cfg.size)) < 0) + if ((error = git_config_parser_init(&parser, "in-memory", + memory_backend->cfg.ptr, memory_backend->cfg.size)) < 0) goto out; parse_data.backend_type = git_config_list_add_string( - memory_backend->config_list, memory_backend->type); + memory_backend->config_list, memory_backend->backend_type); + parse_data.origin_path = memory_backend->origin_path ? + git_config_list_add_string(memory_backend->config_list, + memory_backend->origin_path) : + NULL; parse_data.config_list = memory_backend->config_list; parse_data.level = level; - if ((error = git_config_parse(&parser, NULL, read_variable_cb, NULL, NULL, &parse_data)) < 0) + if ((error = git_config_parse(&parser, NULL, read_variable_cb, + NULL, NULL, &parse_data)) < 0) goto out; out: @@ -106,6 +122,74 @@ static int config_memory_open(git_config_backend *backend, git_config_level_t le return error; } +static int parse_values( + config_memory_backend *memory_backend, + git_config_level_t level) +{ + git_config_list_entry *entry; + const char *eql, *backend_type, *origin_path; + size_t name_len, i; + + backend_type = git_config_list_add_string( + memory_backend->config_list, memory_backend->backend_type); + GIT_ERROR_CHECK_ALLOC(backend_type); + + origin_path = memory_backend->origin_path ? + git_config_list_add_string(memory_backend->config_list, + memory_backend->origin_path) : + NULL; + + for (i = 0; i < memory_backend->values_len; i++) { + eql = strchr(memory_backend->values[i], '='); + name_len = eql - memory_backend->values[i]; + + if (name_len == 0) { + git_error_set(GIT_ERROR_CONFIG, "empty config key"); + return -1; + } + + entry = git__calloc(1, sizeof(git_config_list_entry)); + GIT_ERROR_CHECK_ALLOC(entry); + + entry->base.name = git__strndup(memory_backend->values[i], name_len); + GIT_ERROR_CHECK_ALLOC(entry->base.name); + + if (eql) { + entry->base.value = git__strdup(eql + 1); + GIT_ERROR_CHECK_ALLOC(entry->base.value); + } + + entry->base.level = level; + entry->base.include_depth = 0; + entry->base.backend_type = backend_type; + entry->base.origin_path = origin_path; + entry->base.free = git_config_list_entry_free; + entry->config_list = memory_backend->config_list; + + if (git_config_list_append(memory_backend->config_list, entry) < 0) + return -1; + } + + return 0; +} + +static int config_memory_open(git_config_backend *backend, git_config_level_t level, const git_repository *repo) +{ + config_memory_backend *memory_backend = (config_memory_backend *) backend; + + GIT_UNUSED(repo); + + if (memory_backend->cfg.size > 0 && + parse_config(memory_backend, level) < 0) + return -1; + + if (memory_backend->values_len > 0 && + parse_values(memory_backend, level) < 0) + return -1; + + return 0; +} + static int config_memory_get(git_config_backend *backend, const char *key, git_config_entry **out) { config_memory_backend *memory_backend = (config_memory_backend *) backend; @@ -192,36 +276,24 @@ static void config_memory_free(git_config_backend *_backend) if (backend == NULL) return; - git__free(backend->type); + git__free(backend->origin_path); + git__free(backend->backend_type); git_config_list_free(backend->config_list); + git_strlist_free(backend->values, backend->values_len); git_str_dispose(&backend->cfg); git__free(backend); } -int git_config_backend_from_string( - git_config_backend **out, - const char *backend_type, - const char *cfg, - size_t len) +static config_memory_backend *config_backend_new( + git_config_backend_memory_options *opts) { config_memory_backend *backend; - backend = git__calloc(1, sizeof(config_memory_backend)); - GIT_ERROR_CHECK_ALLOC(backend); - - if (git_config_list_new(&backend->config_list) < 0) { - git__free(backend); - return -1; - } - - if (git_str_set(&backend->cfg, cfg, len) < 0) { - git_config_list_free(backend->config_list); - git__free(backend); - return -1; - } + if ((backend = git__calloc(1, sizeof(config_memory_backend))) == NULL) + return NULL; - backend->type = git__strdup(backend_type ? backend_type : "in-memory"); - GIT_ERROR_CHECK_ALLOC(backend->type); + if (git_config_list_new(&backend->config_list) < 0) + goto on_error; backend->parent.version = GIT_CONFIG_BACKEND_VERSION; backend->parent.readonly = 1; @@ -237,7 +309,66 @@ int git_config_backend_from_string( backend->parent.snapshot = git_config_backend_snapshot; backend->parent.free = config_memory_free; + backend->backend_type = git__strdup(opts && opts->backend_type ? + opts->backend_type : "in-memory"); + + if (backend->backend_type == NULL) + goto on_error; + + if (opts && opts->origin_path && + (backend->origin_path = git__strdup(opts->origin_path)) == NULL) + goto on_error; + + return backend; + +on_error: + git_config_list_free(backend->config_list); + git__free(backend->origin_path); + git__free(backend->backend_type); + git__free(backend); + return NULL; +} + +int git_config_backend_from_string( + git_config_backend **out, + const char *cfg, + size_t len, + git_config_backend_memory_options *opts) +{ + config_memory_backend *backend; + + if ((backend = config_backend_new(opts)) == NULL) + return -1; + + if (git_str_set(&backend->cfg, cfg, len) < 0) { + git_config_list_free(backend->config_list); + git__free(backend); + return -1; + } + *out = (git_config_backend *)backend; + return 0; +} + +int git_config_backend_from_values( + git_config_backend **out, + const char **values, + size_t len, + git_config_backend_memory_options *opts) +{ + config_memory_backend *backend; + if ((backend = config_backend_new(opts)) == NULL) + return -1; + + if (git_strlist_copy(&backend->values, values, len) < 0) { + git_config_list_free(backend->config_list); + git__free(backend); + return -1; + } + + backend->values_len = len; + + *out = (git_config_backend *)backend; return 0; } diff --git a/src/util/strlist.c b/src/util/strlist.c new file mode 100644 index 00000000000..af9b4bbd34d --- /dev/null +++ b/src/util/strlist.c @@ -0,0 +1,42 @@ +/* + * Copyright (C) the libgit2 contributors. All rights reserved. + * + * This file is part of libgit2, distributed under the GNU GPL v2 with + * a Linking Exception. For full terms see the included COPYING file. + */ + +#include + +#include "git2_util.h" +#include "vector.h" +#include "strlist.h" + +int git_strlist_copy(char ***out, const char **in, size_t len) +{ + char **dup; + size_t i; + + dup = git__calloc(len, sizeof(char *)); + GIT_ERROR_CHECK_ALLOC(dup); + + for (i = 0; i < len; i++) { + dup[i] = git__strdup(in[i]); + GIT_ERROR_CHECK_ALLOC(dup[i]); + } + + *out = dup; + return 0; +} + +void git_strlist_free(char **strings, size_t len) +{ + size_t i; + + if (!strings) + return; + + for (i = 0; i < len; i++) + git__free(strings[i]); + + git__free(strings); +} diff --git a/src/util/strlist.h b/src/util/strlist.h new file mode 100644 index 00000000000..089a8bb57b3 --- /dev/null +++ b/src/util/strlist.h @@ -0,0 +1,16 @@ +/* + * Copyright (C) the libgit2 contributors. All rights reserved. + * + * This file is part of libgit2, distributed under the GNU GPL v2 with + * a Linking Exception. For full terms see the included COPYING file. + */ + +#ifndef INCLUDE_runtime_h__ +#define INCLUDE_runtime_h__ + +#include "git2_util.h" + +extern int git_strlist_copy(char ***out, const char **in, size_t len); +extern void git_strlist_free(char **strings, size_t len); + +#endif diff --git a/tests/libgit2/config/memory.c b/tests/libgit2/config/memory.c index 67a61a1c573..9f533e282fd 100644 --- a/tests/libgit2/config/memory.c +++ b/tests/libgit2/config/memory.c @@ -34,8 +34,13 @@ static int contains_all_cb(const git_config_entry *entry, void *payload) int i; for (i = 0; entries[i].name; i++) { - if (strcmp(entries[i].name, entry->name) || - strcmp(entries[i].value , entry->value)) + if (strcmp(entries[i].name, entry->name)) + continue; + + if ((entries[i].value == NULL) ^ (entry->value == NULL)) + continue; + + if (entry->value && strcmp(entries[i].value , entry->value)) continue; if (entries[i].seen) @@ -61,7 +66,23 @@ static void assert_config_contains_all(git_config_backend *backend, static void setup_backend(const char *cfg) { - cl_git_pass(git_config_backend_from_string(&backend, "test", cfg, strlen(cfg))); + git_config_backend_memory_options opts = + GIT_CONFIG_BACKEND_MEMORY_OPTIONS_INIT; + + opts.backend_type = "test"; + + cl_git_pass(git_config_backend_from_string(&backend, cfg, strlen(cfg), &opts)); + cl_git_pass(git_config_backend_open(backend, 0, NULL)); +} + +static void setup_values_backend(const char **values, size_t len) +{ + git_config_backend_memory_options opts = + GIT_CONFIG_BACKEND_MEMORY_OPTIONS_INIT; + + opts.backend_type = "test"; + + cl_git_pass(git_config_backend_from_values(&backend, values, len, &opts)); cl_git_pass(git_config_backend_open(backend, 0, NULL)); } @@ -88,7 +109,13 @@ void test_config_memory__malformed_fails_to_open(void) const char *cfg = "[general\n" "foo=bar\n"; - cl_git_pass(git_config_backend_from_string(&backend, "test", cfg, strlen(cfg))); + + git_config_backend_memory_options opts = + GIT_CONFIG_BACKEND_MEMORY_OPTIONS_INIT; + + opts.backend_type = "test"; + + cl_git_pass(git_config_backend_from_string(&backend, cfg, strlen(cfg), &opts)); cl_git_fail(git_config_backend_open(backend, 0, NULL)); } @@ -137,3 +164,43 @@ void test_config_memory__foreach_sees_multivar(void) "foo=bar2\n"); assert_config_contains_all(backend, entries); } + +void test_config_memory__values(void) +{ + const char *values[] = { + "general.foo=bar1", + "general.foo=bar2", + "other.key=value", + "empty.value=", + "no.value", + }; + + struct expected_entry entries[] = { + { "general.foo", "bar1", 0 }, + { "general.foo", "bar2", 0 }, + { "other.key", "value", 0 }, + { "empty.value", "", 0 }, + { "no.value", NULL, 0 }, + { NULL, NULL, 0 } + }; + + setup_values_backend(values, 5); + assert_config_contains_all(backend, entries); +} + +void test_config_memory__valid_values(void) +{ + const char *values[] = { + "general.foo=bar1", + "=bar2", + "other.key=value" + }; + + git_config_backend_memory_options opts = + GIT_CONFIG_BACKEND_MEMORY_OPTIONS_INIT; + + opts.backend_type = "test"; + + cl_git_pass(git_config_backend_from_values(&backend, values, 3, &opts)); + cl_git_fail(git_config_backend_open(backend, 0, NULL)); +} diff --git a/tests/libgit2/config/snapshot.c b/tests/libgit2/config/snapshot.c index 87a68600ee4..cc877063c08 100644 --- a/tests/libgit2/config/snapshot.c +++ b/tests/libgit2/config/snapshot.c @@ -152,8 +152,14 @@ void test_config_snapshot__snapshot_from_in_memory(void) git_config_entry *entry; int i; + git_config_backend_memory_options opts = + GIT_CONFIG_BACKEND_MEMORY_OPTIONS_INIT; + + opts.backend_type = "test"; + opts.origin_path = "hello"; + cl_git_pass(git_config_new(&cfg)); - cl_git_pass(git_config_backend_from_string(&backend, "test", configuration, strlen(configuration))); + cl_git_pass(git_config_backend_from_string(&backend, configuration, strlen(configuration), &opts)); cl_git_pass(git_config_add_backend(cfg, backend, 0, NULL, 0)); cl_git_pass(git_config_snapshot(&snapshot, cfg)); @@ -166,7 +172,7 @@ void test_config_snapshot__snapshot_from_in_memory(void) cl_assert_equal_s("section.key", entry->name); cl_assert_equal_s("1", entry->value); cl_assert_equal_s("test", entry->backend_type); - cl_assert_equal_p(NULL, entry->origin_path); + cl_assert_equal_s("hello", entry->origin_path); git_config_entry_free(entry); } From 877968418ac645e79bb4cc8c0f39a05f5f7bbc98 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 21 Jul 2023 10:35:31 +0100 Subject: [PATCH 322/608] cli: add `config` command Add a `config` command with `--list` and `--get`. --- src/cli/cmd.h | 1 + src/cli/cmd_config.c | 178 +++++++++++++++++++++++++++++++++++++++++++ src/cli/main.c | 1 + 3 files changed, 180 insertions(+) create mode 100644 src/cli/cmd_config.c diff --git a/src/cli/cmd.h b/src/cli/cmd.h index 8b1a1b38fd7..12977cbc7bb 100644 --- a/src/cli/cmd.h +++ b/src/cli/cmd.h @@ -27,6 +27,7 @@ extern const cli_cmd_spec *cli_cmd_spec_byname(const char *name); /* Commands */ extern int cmd_cat_file(int argc, char **argv); extern int cmd_clone(int argc, char **argv); +extern int cmd_config(int argc, char **argv); extern int cmd_hash_object(int argc, char **argv); extern int cmd_help(int argc, char **argv); diff --git a/src/cli/cmd_config.c b/src/cli/cmd_config.c new file mode 100644 index 00000000000..9c966faef9b --- /dev/null +++ b/src/cli/cmd_config.c @@ -0,0 +1,178 @@ +/* + * Copyright (C) the libgit2 contributors. All rights reserved. + * + * This file is part of libgit2, distributed under the GNU GPL v2 with + * a Linking Exception. For full terms see the included COPYING file. + */ + +#include +#include "cli.h" +#include "cmd.h" + +#define COMMAND_NAME "config" + +typedef enum { + ACTION_NONE = 0, + ACTION_GET, + ACTION_LIST +} action_t; + +static action_t action = ACTION_NONE; +static int show_origin; +static int show_scope; +static int show_help; +static int null_separator; +static char *name; + +static const cli_opt_spec opts[] = { + { CLI_OPT_TYPE_SWITCH, "help", 0, &show_help, 1, + CLI_OPT_USAGE_HIDDEN | CLI_OPT_USAGE_STOP_PARSING, NULL, + "display help about the " COMMAND_NAME " command" }, + + { CLI_OPT_TYPE_SWITCH, "null", 'z', &null_separator, 1, + 0, NULL, "use NUL as a separator" }, + + { CLI_OPT_TYPE_SWITCH, "get", 0, &action, ACTION_GET, + CLI_OPT_USAGE_REQUIRED, NULL, "get a configuration value" }, + { CLI_OPT_TYPE_SWITCH, "list", 'l', &action, ACTION_LIST, + CLI_OPT_USAGE_CHOICE | CLI_OPT_USAGE_SHOW_LONG, + NULL, "list all configuration entries" }, + { CLI_OPT_TYPE_SWITCH, "show-origin", 0, &show_origin, 1, + 0, NULL, "show origin of configuration" }, + { CLI_OPT_TYPE_SWITCH, "show-scope", 0, &show_scope, 1, + 0, NULL, "show scope of configuration" }, + { CLI_OPT_TYPE_ARG, "name", 0, &name, 0, + 0, "name", "name of configuration entry" }, + { 0 }, +}; + +static void print_help(void) +{ + cli_opt_usage_fprint(stdout, PROGRAM_NAME, COMMAND_NAME, opts); + printf("\n"); + + printf("Query and set configuration options.\n"); + printf("\n"); + + printf("Options:\n"); + + cli_opt_help_fprint(stdout, opts); +} + +static int get_config(git_config *config) +{ + git_buf value = GIT_BUF_INIT; + char sep = null_separator ? '\0' : '\n'; + int error; + + error = git_config_get_string_buf(&value, config, name); + + if (error && error != GIT_ENOTFOUND) + return cli_error_git(); + + else if (error == GIT_ENOTFOUND) + return 1; + + printf("%s%c", value.ptr, sep); + return 0; +} + +static const char *level_name(git_config_level_t level) +{ + switch (level) { + case GIT_CONFIG_LEVEL_PROGRAMDATA: + return "programdata"; + case GIT_CONFIG_LEVEL_SYSTEM: + return "system"; + case GIT_CONFIG_LEVEL_XDG: + return "global"; + case GIT_CONFIG_LEVEL_GLOBAL: + return "global"; + case GIT_CONFIG_LEVEL_LOCAL: + return "local"; + case GIT_CONFIG_LEVEL_APP: + return "command"; + default: + return "unknown"; + } +} + +static int list_config(git_config *config) +{ + git_config_iterator *iterator; + git_config_entry *entry; + char data_separator = null_separator ? '\0' : '\t'; + char kv_separator = null_separator ? '\n' : '='; + char entry_separator = null_separator ? '\0' : '\n'; + int error; + + if (git_config_iterator_new(&iterator, config) < 0) + return cli_error_git(); + + while ((error = git_config_next(&entry, iterator)) == 0) { + if (show_scope) + printf("%s%c", + level_name(entry->level), + data_separator); + + if (show_origin) + printf("%s%s%s%c", + entry->backend_type ? entry->backend_type : "", + entry->backend_type && entry->origin_path ? ":" : "", + entry->origin_path ? entry->origin_path : "", + data_separator); + + printf("%s%c%s%c", entry->name, kv_separator, entry->value, + entry_separator); + } + + if (error != GIT_ITEROVER) + return cli_error_git(); + + git_config_iterator_free(iterator); + return 0; +} + +int cmd_config(int argc, char **argv) +{ + git_repository *repo = NULL; + git_config *config = NULL; + cli_opt invalid_opt; + int ret = 0; + + if (cli_opt_parse(&invalid_opt, opts, argv + 1, argc - 1, CLI_OPT_PARSE_GNU)) + return cli_opt_usage_error(COMMAND_NAME, opts, &invalid_opt); + + if (show_help) { + print_help(); + return 0; + } + + if (git_repository_open_ext(&repo, ".", GIT_REPOSITORY_OPEN_FROM_ENV, NULL) < 0 || + git_repository_config(&config, repo) < 0) { + ret = cli_error_git(); + goto done; + } + + switch (action) { + case ACTION_LIST: + if (name) + ret = cli_error_usage("%s --list does not take an argument", COMMAND_NAME); + else + ret = list_config(config); + break; + case ACTION_GET: + if (!name) + ret = cli_error_usage("%s --get requires an argument", COMMAND_NAME); + else + ret = get_config(config); + break; + default: + ret = cli_error_usage("unknown action"); + } + +done: + git_config_free(config); + git_repository_free(repo); + return ret; +} diff --git a/src/cli/main.c b/src/cli/main.c index cbfc50eec35..96a70127546 100644 --- a/src/cli/main.c +++ b/src/cli/main.c @@ -30,6 +30,7 @@ const cli_opt_spec cli_common_opts[] = { const cli_cmd_spec cli_cmds[] = { { "cat-file", cmd_cat_file, "Display an object in the repository" }, { "clone", cmd_clone, "Clone a repository into a new directory" }, + { "config", cmd_config, "View or set configuration values " }, { "hash-object", cmd_hash_object, "Hash a raw object and product its object ID" }, { "help", cmd_help, "Display help information" }, { NULL } From 1c381acf9d530a539c2cbf7c2cbbd05010c102cc Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 24 Jul 2023 20:30:59 +0100 Subject: [PATCH 323/608] cli: accept configuration on the command line Introduce `cli_repository_open` which will reparse command-line options looking for `-c` or `--config-env`. Add those values to an in-memory configuration database and configure the opened repository with that. --- src/cli/cli.h | 20 ------ src/cli/cmd.c | 2 +- src/cli/cmd_cat_file.c | 2 +- src/cli/cmd_clone.c | 2 +- src/cli/cmd_config.c | 46 ++++++++----- src/cli/cmd_hash_object.c | 2 +- src/cli/cmd_help.c | 2 +- src/cli/common.c | 126 ++++++++++++++++++++++++++++++++++++ src/cli/common.h | 47 ++++++++++++++ src/cli/error.h | 2 +- src/cli/main.c | 2 +- src/cli/opt.c | 26 +++++++- src/cli/opt.h | 8 +++ src/cli/opt_usage.c | 2 +- src/cli/unix/sighandler.c | 3 +- src/cli/win32/precompiled.h | 2 +- src/cli/win32/sighandler.c | 2 +- 17 files changed, 246 insertions(+), 50 deletions(-) delete mode 100644 src/cli/cli.h create mode 100644 src/cli/common.c create mode 100644 src/cli/common.h diff --git a/src/cli/cli.h b/src/cli/cli.h deleted file mode 100644 index 7dede678519..00000000000 --- a/src/cli/cli.h +++ /dev/null @@ -1,20 +0,0 @@ -/* - * Copyright (C) the libgit2 contributors. All rights reserved. - * - * This file is part of libgit2, distributed under the GNU GPL v2 with - * a Linking Exception. For full terms see the included COPYING file. - */ - -#ifndef CLI_cli_h__ -#define CLI_cli_h__ - -#define PROGRAM_NAME "git2" - -#include "git2_util.h" - -#include "error.h" -#include "opt.h" -#include "opt_usage.h" -#include "sighandler.h" - -#endif /* CLI_cli_h__ */ diff --git a/src/cli/cmd.c b/src/cli/cmd.c index 2a7e71cdbcb..0b1fafb4423 100644 --- a/src/cli/cmd.c +++ b/src/cli/cmd.c @@ -5,7 +5,7 @@ * a Linking Exception. For full terms see the included COPYING file. */ -#include "cli.h" +#include "common.h" #include "cmd.h" const cli_cmd_spec *cli_cmd_spec_byname(const char *name) diff --git a/src/cli/cmd_cat_file.c b/src/cli/cmd_cat_file.c index fb53a722ba2..96cab4a67ac 100644 --- a/src/cli/cmd_cat_file.c +++ b/src/cli/cmd_cat_file.c @@ -6,7 +6,7 @@ */ #include -#include "cli.h" +#include "common.h" #include "cmd.h" #define COMMAND_NAME "cat-file" diff --git a/src/cli/cmd_clone.c b/src/cli/cmd_clone.c index e4776256cb3..90d3e3db3b8 100644 --- a/src/cli/cmd_clone.c +++ b/src/cli/cmd_clone.c @@ -7,7 +7,7 @@ #include #include -#include "cli.h" +#include "common.h" #include "cmd.h" #include "error.h" #include "sighandler.h" diff --git a/src/cli/cmd_config.c b/src/cli/cmd_config.c index 9c966faef9b..75044af7a25 100644 --- a/src/cli/cmd_config.c +++ b/src/cli/cmd_config.c @@ -6,7 +6,8 @@ */ #include -#include "cli.h" + +#include "common.h" #include "cmd.h" #define COMMAND_NAME "config" @@ -24,25 +25,35 @@ static int show_help; static int null_separator; static char *name; +#define CLI_COMMON_OPT_HELP \ + CLI_OPT_TYPE_SWITCH, "help", 0, &show_help, 1, \ + CLI_OPT_USAGE_HIDDEN | CLI_OPT_USAGE_STOP_PARSING +#define CLI_COMMON_OPT_CONFIG \ + CLI_OPT_TYPE_VALUE, NULL, 'c', NULL, 0, \ + CLI_OPT_USAGE_HIDDEN +#define CLI_COMMON_OPT_CONFIG_ENV \ + CLI_OPT_TYPE_VALUE, "config-env", 0, NULL, 0, \ + CLI_OPT_USAGE_HIDDEN + static const cli_opt_spec opts[] = { - { CLI_OPT_TYPE_SWITCH, "help", 0, &show_help, 1, - CLI_OPT_USAGE_HIDDEN | CLI_OPT_USAGE_STOP_PARSING, NULL, - "display help about the " COMMAND_NAME " command" }, + { CLI_COMMON_OPT_HELP }, + { CLI_COMMON_OPT_CONFIG }, + { CLI_COMMON_OPT_CONFIG_ENV }, - { CLI_OPT_TYPE_SWITCH, "null", 'z', &null_separator, 1, - 0, NULL, "use NUL as a separator" }, + { CLI_OPT_TYPE_SWITCH, "null", 'z', &null_separator, 1, + 0, NULL, "use NUL as a separator" }, - { CLI_OPT_TYPE_SWITCH, "get", 0, &action, ACTION_GET, - CLI_OPT_USAGE_REQUIRED, NULL, "get a configuration value" }, - { CLI_OPT_TYPE_SWITCH, "list", 'l', &action, ACTION_LIST, + { CLI_OPT_TYPE_SWITCH, "get", 0, &action, ACTION_GET, + CLI_OPT_USAGE_REQUIRED, NULL, "get a configuration value" }, + { CLI_OPT_TYPE_SWITCH, "list", 'l', &action, ACTION_LIST, CLI_OPT_USAGE_CHOICE | CLI_OPT_USAGE_SHOW_LONG, - NULL, "list all configuration entries" }, - { CLI_OPT_TYPE_SWITCH, "show-origin", 0, &show_origin, 1, - 0, NULL, "show origin of configuration" }, - { CLI_OPT_TYPE_SWITCH, "show-scope", 0, &show_scope, 1, - 0, NULL, "show scope of configuration" }, - { CLI_OPT_TYPE_ARG, "name", 0, &name, 0, - 0, "name", "name of configuration entry" }, + NULL, "list all configuration entries" }, + { CLI_OPT_TYPE_SWITCH, "show-origin", 0, &show_origin, 1, + 0, NULL, "show origin of configuration" }, + { CLI_OPT_TYPE_SWITCH, "show-scope", 0, &show_scope, 1, + 0, NULL, "show scope of configuration" }, + { CLI_OPT_TYPE_ARG, "name", 0, &name, 0, + 0, "name", "name of configuration entry" }, { 0 }, }; @@ -137,6 +148,7 @@ int cmd_config(int argc, char **argv) { git_repository *repo = NULL; git_config *config = NULL; + cli_repository_open_options open_opts = { argv + 1, argc - 1}; cli_opt invalid_opt; int ret = 0; @@ -148,7 +160,7 @@ int cmd_config(int argc, char **argv) return 0; } - if (git_repository_open_ext(&repo, ".", GIT_REPOSITORY_OPEN_FROM_ENV, NULL) < 0 || + if (cli_repository_open(&repo, &open_opts) < 0 || git_repository_config(&config, repo) < 0) { ret = cli_error_git(); goto done; diff --git a/src/cli/cmd_hash_object.c b/src/cli/cmd_hash_object.c index 93b980d6676..529a1ec44e5 100644 --- a/src/cli/cmd_hash_object.c +++ b/src/cli/cmd_hash_object.c @@ -6,7 +6,7 @@ */ #include -#include "cli.h" +#include "common.h" #include "cmd.h" #include "futils.h" diff --git a/src/cli/cmd_help.c b/src/cli/cmd_help.c index 7ee9822427c..c9ac48aa96e 100644 --- a/src/cli/cmd_help.c +++ b/src/cli/cmd_help.c @@ -7,7 +7,7 @@ #include #include -#include "cli.h" +#include "common.h" #include "cmd.h" #define COMMAND_NAME "help" diff --git a/src/cli/common.c b/src/cli/common.c new file mode 100644 index 00000000000..60b0358662b --- /dev/null +++ b/src/cli/common.c @@ -0,0 +1,126 @@ +/* + * Copyright (C) the libgit2 contributors. All rights reserved. + * + * This file is part of libgit2, distributed under the GNU GPL v2 with + * a Linking Exception. For full terms see the included COPYING file. + */ + +#include +#include + +#include "git2_util.h" +#include "vector.h" + +#include "common.h" +#include "error.h" + +static int parse_option(cli_opt *opt, void *data) +{ + git_str kv = GIT_STR_INIT, env = GIT_STR_INIT; + git_vector *cmdline_config = data; + int error = 0; + + if (opt->spec && opt->spec->alias == 'c') { + if (git_str_puts(&kv, opt->value) < 0) { + error = cli_error_git(); + goto done; + } + } + + else if (opt->spec && !strcmp(opt->spec->name, "config-env")) { + char *val = strchr(opt->value, '='); + + if (val == NULL || *(val + 1) == '\0') { + error = cli_error("invalid config format: '%s'", opt->value); + goto done; + } + + if (git_str_put(&kv, opt->value, (val - opt->value)) < 0) { + error = cli_error_git(); + goto done; + } + + val++; + + if ((error = git__getenv(&env, val)) == GIT_ENOTFOUND) { + error = cli_error("missing environment variable '%s' for configuration '%s'", val, kv.ptr); + goto done; + } else if (error) { + error = cli_error_git(); + goto done; + } + + if (git_str_putc(&kv, '=') < 0 || + git_str_puts(&kv, env.ptr) < 0) { + error = cli_error_git(); + goto done; + } + } + + if (kv.size > 0 && + git_vector_insert(cmdline_config, git_str_detach(&kv)) < 0) + error = cli_error_git(); + +done: + git_str_dispose(&env); + git_str_dispose(&kv); + return error; +} + +static int parse_common_options( + git_repository *repo, + cli_repository_open_options *opts) +{ + cli_opt_spec common_opts[] = { + { CLI_COMMON_OPT_CONFIG }, + { CLI_COMMON_OPT_CONFIG_ENV }, + { 0 } + }; + git_config_backend_memory_options config_opts = + GIT_CONFIG_BACKEND_MEMORY_OPTIONS_INIT; + git_vector cmdline = GIT_VECTOR_INIT; + git_config *config = NULL; + git_config_backend *backend = NULL; + int error = 0; + + config_opts.backend_type = "command line"; + + if ((error = cli_opt_foreach(common_opts, opts->args, + opts->args_len, CLI_OPT_PARSE_GNU, parse_option, + &cmdline)) < 0) + goto done; + + if (git_vector_length(&cmdline) == 0) + goto done; + + if (git_repository_config(&config, repo) < 0 || + git_config_backend_from_values(&backend, + (const char **)cmdline.contents, cmdline.length, + &config_opts) < 0 || + git_config_add_backend(config, backend, GIT_CONFIG_LEVEL_APP, + repo, 0) < 0) + error = cli_error_git(); + +done: + if (error && backend) + backend->free(backend); + git_config_free(config); + git_vector_free_deep(&cmdline); + return error; +} + +int cli_repository_open( + git_repository **out, + cli_repository_open_options *opts) +{ + git_repository *repo; + + if (git_repository_open_ext(&repo, ".", GIT_REPOSITORY_OPEN_FROM_ENV, NULL) < 0) + return -1; + + if (opts && parse_common_options(repo, opts) < 0) + return -1; + + *out = repo; + return 0; +} diff --git a/src/cli/common.h b/src/cli/common.h new file mode 100644 index 00000000000..0d98c56cb12 --- /dev/null +++ b/src/cli/common.h @@ -0,0 +1,47 @@ +/* + * Copyright (C) the libgit2 contributors. All rights reserved. + * + * This file is part of libgit2, distributed under the GNU GPL v2 with + * a Linking Exception. For full terms see the included COPYING file. + */ + +#ifndef CLI_common_h__ +#define CLI_common_h__ + +#define PROGRAM_NAME "git2" + +#include "git2_util.h" + +#include "error.h" +#include "opt.h" +#include "opt_usage.h" + +/* + * Common command arguments. + */ + +#define CLI_COMMON_OPT_HELP \ + CLI_OPT_TYPE_SWITCH, "help", 0, &show_help, 1, \ + CLI_OPT_USAGE_HIDDEN | CLI_OPT_USAGE_STOP_PARSING +#define CLI_COMMON_OPT_CONFIG \ + CLI_OPT_TYPE_VALUE, NULL, 'c', NULL, 0, \ + CLI_OPT_USAGE_HIDDEN +#define CLI_COMMON_OPT_CONFIG_ENV \ + CLI_OPT_TYPE_VALUE, "config-env", 0, NULL, 0, \ + CLI_OPT_USAGE_HIDDEN + +#define CLI_COMMON_OPT \ + { CLI_COMMON_OPT_HELP }, \ + { CLI_COMMON_OPT_CONFIG }, \ + { CLI_COMMON_OPT_CONFIG_ENV } + +typedef struct { + char **args; + int args_len; +} cli_repository_open_options; + +extern int cli_repository_open( + git_repository **out, + cli_repository_open_options *opts); + +#endif /* CLI_common_h__ */ diff --git a/src/cli/error.h b/src/cli/error.h index cce7a54c093..abf8a5160d1 100644 --- a/src/cli/error.h +++ b/src/cli/error.h @@ -8,7 +8,7 @@ #ifndef CLI_error_h__ #define CLI_error_h__ -#include "cli.h" +#include "common.h" #include #define CLI_EXIT_OK 0 diff --git a/src/cli/main.c b/src/cli/main.c index 96a70127546..d1639e62ee3 100644 --- a/src/cli/main.c +++ b/src/cli/main.c @@ -7,7 +7,7 @@ #include #include -#include "cli.h" +#include "common.h" #include "cmd.h" static int show_help = 0; diff --git a/src/cli/opt.c b/src/cli/opt.c index 62a3430d16e..25c97746f1d 100644 --- a/src/cli/opt.c +++ b/src/cli/opt.c @@ -19,7 +19,7 @@ #include #include -#include "cli.h" +#include "common.h" #include "opt.h" #ifdef _WIN32 @@ -73,7 +73,7 @@ GIT_INLINE(const cli_opt_spec *) spec_for_long( /* Handle --option=value arguments */ if (spec->type == CLI_OPT_TYPE_VALUE && - eql && + spec->name && eql && strncmp(arg, spec->name, eql_pos) == 0 && spec->name[eql_pos] == '\0') { *has_value = 1; @@ -575,6 +575,28 @@ cli_opt_status_t cli_opt_parse( return validate_required(opt, specs, given_specs); } +int cli_opt_foreach( + const cli_opt_spec specs[], + char **args, + size_t args_len, + unsigned int flags, + int (*callback)(cli_opt *, void *), + void *callback_data) +{ + cli_opt_parser parser; + cli_opt opt; + int ret; + + cli_opt_parser_init(&parser, specs, args, args_len, flags); + + while (cli_opt_parser_next(&opt, &parser)) { + if ((ret = callback(&opt, callback_data)) != 0) + return ret; + } + + return 0; +} + static int spec_name_fprint(FILE *file, const cli_opt_spec *spec) { int error; diff --git a/src/cli/opt.h b/src/cli/opt.h index 6c1d4603ecd..7133307b4f7 100644 --- a/src/cli/opt.h +++ b/src/cli/opt.h @@ -300,6 +300,14 @@ cli_opt_status_t cli_opt_parse( size_t args_len, unsigned int flags); +int cli_opt_foreach( + const cli_opt_spec specs[], + char **args, + size_t args_len, + unsigned int flags, + int (*callback)(cli_opt *, void *), + void *callback_data); + /** * Initializes a parser that parses the given arguments according to the * given specifications. diff --git a/src/cli/opt_usage.c b/src/cli/opt_usage.c index 478b416316d..8374f5151a7 100644 --- a/src/cli/opt_usage.c +++ b/src/cli/opt_usage.c @@ -5,7 +5,7 @@ * a Linking Exception. For full terms see the included COPYING file. */ -#include "cli.h" +#include "common.h" #include "str.h" static int print_spec_name(git_str *out, const cli_opt_spec *spec) diff --git a/src/cli/unix/sighandler.c b/src/cli/unix/sighandler.c index 6b4982d48f2..05ac8672cad 100644 --- a/src/cli/unix/sighandler.c +++ b/src/cli/unix/sighandler.c @@ -8,7 +8,8 @@ #include #include #include "git2_util.h" -#include "cli.h" +#include "common.h" +#include "sighandler.h" static void (*interrupt_handler)(void) = NULL; diff --git a/src/cli/win32/precompiled.h b/src/cli/win32/precompiled.h index b0309b864ad..031370e87e7 100644 --- a/src/cli/win32/precompiled.h +++ b/src/cli/win32/precompiled.h @@ -1,3 +1,3 @@ #include -#include "cli.h" +#include "common.h" diff --git a/src/cli/win32/sighandler.c b/src/cli/win32/sighandler.c index cc0b6464033..05a67fb14fe 100644 --- a/src/cli/win32/sighandler.c +++ b/src/cli/win32/sighandler.c @@ -8,7 +8,7 @@ #include "git2_util.h" #include -#include "cli.h" +#include "sighandler.h" static void (*interrupt_handler)(void) = NULL; From 005bccea58e1e529e2af821f0d8f8c6423c0bb3e Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 24 Jul 2023 20:38:17 +0100 Subject: [PATCH 324/608] cli: reorder arguments for subcommands Instead of special casing `--help`, reorder the arguments for subcommands so that it can handle "global" arguments like `--help`, `-c key=value`, etc. --- src/cli/main.c | 53 ++++++++++++++++++++++++++++---------------------- 1 file changed, 30 insertions(+), 23 deletions(-) diff --git a/src/cli/main.c b/src/cli/main.c index d1639e62ee3..6854b82289a 100644 --- a/src/cli/main.c +++ b/src/cli/main.c @@ -16,8 +16,12 @@ static char *command = NULL; static char **args = NULL; const cli_opt_spec cli_common_opts[] = { - { CLI_OPT_TYPE_SWITCH, "help", 0, &show_help, 1, - CLI_OPT_USAGE_DEFAULT, NULL, "display help information" }, + { CLI_OPT_TYPE_SWITCH, "help", 0, &show_help, 1, + CLI_OPT_USAGE_DEFAULT, NULL, "display help information" }, + { CLI_OPT_TYPE_VALUE, NULL, 'c', NULL, 0, + CLI_OPT_USAGE_DEFAULT, "key=value", "add configuration value" }, + { CLI_OPT_TYPE_VALUE, "config-env", 0, NULL, 0, + CLI_OPT_USAGE_DEFAULT, "key=value", "set configuration value to environment variable" }, { CLI_OPT_TYPE_SWITCH, "version", 0, &show_version, 1, CLI_OPT_USAGE_DEFAULT, NULL, "display the version" }, { CLI_OPT_TYPE_ARG, "command", 0, &command, 0, @@ -36,14 +40,33 @@ const cli_cmd_spec cli_cmds[] = { { NULL } }; +/* + * Reorder the argv as it was given, since git has the notion of global + * options (like `--help` or `-c key=val`) that we want to pass to the + * subcommand, and that can appear early in the arguments, before the + * command name. Put the command-name in argv[1] to allow easier parsing. + */ +static void reorder_args(char **argv, size_t first) +{ + char *tmp; + size_t i; + + if (first == 1) + return; + + tmp = argv[first]; + + for (i = first; i > 1; i--) + argv[i] = argv[i - 1]; + + argv[1] = tmp; +} + int main(int argc, char **argv) { const cli_cmd_spec *cmd; cli_opt_parser optparser; cli_opt opt; - char *help_args[3] = { NULL }; - int help_args_len; - int args_len = 0; int ret = 0; if (git_libgit2_init() < 0) { @@ -67,8 +90,7 @@ int main(int argc, char **argv) * remaining arguments as args for the command itself. */ if (command) { - args = &argv[optparser.idx]; - args_len = (int)(argc - optparser.idx); + reorder_args(argv, optparser.idx); break; } } @@ -78,28 +100,13 @@ int main(int argc, char **argv) goto done; } - /* - * If `--help ` is specified, delegate to that command's - * `--help` option. If no command is specified, run the `help` - * command. Do this by updating the args to emulate that behavior. - */ - if (!command || show_help) { - help_args[0] = command ? (char *)command : "help"; - help_args[1] = command ? "--help" : NULL; - help_args_len = command ? 2 : 1; - - command = help_args[0]; - args = help_args; - args_len = help_args_len; - } - if ((cmd = cli_cmd_spec_byname(command)) == NULL) { ret = cli_error("'%s' is not a %s command. See '%s help'.", command, PROGRAM_NAME, PROGRAM_NAME); goto done; } - ret = cmd->fn(args_len, args); + ret = cmd->fn(argc - 1, &argv[1]); done: git_libgit2_shutdown(); From 90d3cc6cd4e4562023134202aae9294a86d99347 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 24 Jul 2023 21:27:10 +0100 Subject: [PATCH 325/608] cli: common options --- src/cli/cmd_cat_file.c | 4 +--- src/cli/cmd_clone.c | 4 +--- src/cli/cmd_config.c | 14 +------------- src/cli/cmd_hash_object.c | 4 +--- src/cli/cmd_help.c | 4 ++-- src/cli/common.h | 19 +++++++++++++++++++ 6 files changed, 25 insertions(+), 24 deletions(-) diff --git a/src/cli/cmd_cat_file.c b/src/cli/cmd_cat_file.c index 96cab4a67ac..f05449e7d9b 100644 --- a/src/cli/cmd_cat_file.c +++ b/src/cli/cmd_cat_file.c @@ -24,9 +24,7 @@ static int display = DISPLAY_CONTENT; static char *type_name, *object_spec; static const cli_opt_spec opts[] = { - { CLI_OPT_TYPE_SWITCH, "help", 0, &show_help, 1, - CLI_OPT_USAGE_HIDDEN | CLI_OPT_USAGE_STOP_PARSING, NULL, - "display help about the " COMMAND_NAME " command" }, + CLI_COMMON_OPT, { CLI_OPT_TYPE_SWITCH, NULL, 't', &display, DISPLAY_TYPE, CLI_OPT_USAGE_REQUIRED, NULL, "display the type of the object" }, diff --git a/src/cli/cmd_clone.c b/src/cli/cmd_clone.c index 90d3e3db3b8..7d9736fc72a 100644 --- a/src/cli/cmd_clone.c +++ b/src/cli/cmd_clone.c @@ -24,9 +24,7 @@ static bool local_path_exists; static cli_progress progress = CLI_PROGRESS_INIT; static const cli_opt_spec opts[] = { - { CLI_OPT_TYPE_SWITCH, "help", 0, &show_help, 1, - CLI_OPT_USAGE_HIDDEN | CLI_OPT_USAGE_STOP_PARSING, NULL, - "display help about the " COMMAND_NAME " command" }, + CLI_COMMON_OPT, { CLI_OPT_TYPE_SWITCH, "quiet", 'q', &quiet, 1, CLI_OPT_USAGE_DEFAULT, NULL, "display the type of the object" }, diff --git a/src/cli/cmd_config.c b/src/cli/cmd_config.c index 75044af7a25..c393fe8efce 100644 --- a/src/cli/cmd_config.c +++ b/src/cli/cmd_config.c @@ -25,20 +25,8 @@ static int show_help; static int null_separator; static char *name; -#define CLI_COMMON_OPT_HELP \ - CLI_OPT_TYPE_SWITCH, "help", 0, &show_help, 1, \ - CLI_OPT_USAGE_HIDDEN | CLI_OPT_USAGE_STOP_PARSING -#define CLI_COMMON_OPT_CONFIG \ - CLI_OPT_TYPE_VALUE, NULL, 'c', NULL, 0, \ - CLI_OPT_USAGE_HIDDEN -#define CLI_COMMON_OPT_CONFIG_ENV \ - CLI_OPT_TYPE_VALUE, "config-env", 0, NULL, 0, \ - CLI_OPT_USAGE_HIDDEN - static const cli_opt_spec opts[] = { - { CLI_COMMON_OPT_HELP }, - { CLI_COMMON_OPT_CONFIG }, - { CLI_COMMON_OPT_CONFIG_ENV }, + CLI_COMMON_OPT, \ { CLI_OPT_TYPE_SWITCH, "null", 'z', &null_separator, 1, 0, NULL, "use NUL as a separator" }, diff --git a/src/cli/cmd_hash_object.c b/src/cli/cmd_hash_object.c index 529a1ec44e5..a35f0666277 100644 --- a/src/cli/cmd_hash_object.c +++ b/src/cli/cmd_hash_object.c @@ -19,9 +19,7 @@ static int write_object, read_stdin, literally; static char **filenames; static const cli_opt_spec opts[] = { - { CLI_OPT_TYPE_SWITCH, "help", 0, &show_help, 1, - CLI_OPT_USAGE_HIDDEN | CLI_OPT_USAGE_STOP_PARSING, NULL, - "display help about the " COMMAND_NAME " command" }, + CLI_COMMON_OPT, { CLI_OPT_TYPE_VALUE, NULL, 't', &type_name, 0, CLI_OPT_USAGE_DEFAULT, "type", "the type of object to hash (default: \"blob\")" }, diff --git a/src/cli/cmd_help.c b/src/cli/cmd_help.c index c9ac48aa96e..5e877e06dbf 100644 --- a/src/cli/cmd_help.c +++ b/src/cli/cmd_help.c @@ -16,8 +16,8 @@ static char *command; static int show_help; static const cli_opt_spec opts[] = { - { CLI_OPT_TYPE_SWITCH, "help", 0, &show_help, 1, - CLI_OPT_USAGE_HIDDEN, NULL, "display help about the help command" }, + CLI_COMMON_OPT, + { CLI_OPT_TYPE_ARG, "command", 0, &command, 0, CLI_OPT_USAGE_DEFAULT, "command", "the command to show help for" }, { 0 }, diff --git a/src/cli/common.h b/src/cli/common.h index 0d98c56cb12..3aed8ad8a42 100644 --- a/src/cli/common.h +++ b/src/cli/common.h @@ -44,4 +44,23 @@ extern int cli_repository_open( git_repository **out, cli_repository_open_options *opts); +/* + * Common command arguments. + */ + +#define CLI_COMMON_OPT_HELP \ + CLI_OPT_TYPE_SWITCH, "help", 0, &show_help, 1, \ + CLI_OPT_USAGE_HIDDEN | CLI_OPT_USAGE_STOP_PARSING +#define CLI_COMMON_OPT_CONFIG \ + CLI_OPT_TYPE_VALUE, NULL, 'c', NULL, 0, \ + CLI_OPT_USAGE_HIDDEN +#define CLI_COMMON_OPT_CONFIG_ENV \ + CLI_OPT_TYPE_VALUE, "config-env", 0, NULL, 0, \ + CLI_OPT_USAGE_HIDDEN + +#define CLI_COMMON_OPT \ + { CLI_COMMON_OPT_HELP }, \ + { CLI_COMMON_OPT_CONFIG }, \ + { CLI_COMMON_OPT_CONFIG_ENV } + #endif /* CLI_common_h__ */ From 4470ea3920e969bf7c9236bccccb8414a537f566 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Tue, 25 Jul 2023 11:03:36 +0200 Subject: [PATCH 326/608] cli: use cli_repository_open --- src/cli/cmd_cat_file.c | 3 ++- src/cli/cmd_hash_object.c | 3 ++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/src/cli/cmd_cat_file.c b/src/cli/cmd_cat_file.c index f05449e7d9b..90ee6033e8c 100644 --- a/src/cli/cmd_cat_file.c +++ b/src/cli/cmd_cat_file.c @@ -137,6 +137,7 @@ static int print_pretty(git_object *object) int cmd_cat_file(int argc, char **argv) { + cli_repository_open_options open_opts = { argv + 1, argc - 1}; git_repository *repo = NULL; git_object *object = NULL; git_object_t type; @@ -151,7 +152,7 @@ int cmd_cat_file(int argc, char **argv) return 0; } - if (git_repository_open_ext(&repo, ".", GIT_REPOSITORY_OPEN_FROM_ENV, NULL) < 0) + if (cli_repository_open(&repo, &open_opts) < 0) return cli_error_git(); if ((giterr = git_revparse_single(&object, repo, object_spec)) < 0) { diff --git a/src/cli/cmd_hash_object.c b/src/cli/cmd_hash_object.c index a35f0666277..741debbeb2f 100644 --- a/src/cli/cmd_hash_object.c +++ b/src/cli/cmd_hash_object.c @@ -90,6 +90,7 @@ static int hash_buf( int cmd_hash_object(int argc, char **argv) { + cli_repository_open_options open_opts = { argv + 1, argc - 1}; git_repository *repo = NULL; git_odb *odb = NULL; git_oid_t oid_type; @@ -111,7 +112,7 @@ int cmd_hash_object(int argc, char **argv) return cli_error_usage("invalid object type '%s'", type_name); if (write_object && - (git_repository_open_ext(&repo, ".", GIT_REPOSITORY_OPEN_FROM_ENV, NULL) < 0 || + (cli_repository_open(&repo, &open_opts) < 0 || git_repository_odb(&odb, repo) < 0)) { ret = cli_error_git(); goto done; From a7512e68039c512c08208cd45136507c181607f9 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Tue, 25 Jul 2023 17:30:47 +0200 Subject: [PATCH 327/608] cli: add file levels to config command --- src/cli/cmd_config.c | 44 +++++++++++++++++++++++++++++++++++--------- 1 file changed, 35 insertions(+), 9 deletions(-) diff --git a/src/cli/cmd_config.c b/src/cli/cmd_config.c index c393fe8efce..31c4c09bb02 100644 --- a/src/cli/cmd_config.c +++ b/src/cli/cmd_config.c @@ -23,6 +23,8 @@ static int show_origin; static int show_scope; static int show_help; static int null_separator; +static int config_level; +static char *config_filename; static char *name; static const cli_opt_spec opts[] = { @@ -31,16 +33,25 @@ static const cli_opt_spec opts[] = { { CLI_OPT_TYPE_SWITCH, "null", 'z', &null_separator, 1, 0, NULL, "use NUL as a separator" }, - { CLI_OPT_TYPE_SWITCH, "get", 0, &action, ACTION_GET, + { CLI_OPT_TYPE_SWITCH, "system", 0, &config_level, GIT_CONFIG_LEVEL_SYSTEM, + 0, NULL, "read/write to system configuration" }, + { CLI_OPT_TYPE_SWITCH, "global", 0, &config_level, GIT_CONFIG_LEVEL_GLOBAL, + CLI_OPT_USAGE_CHOICE, NULL, "read/write to global configuration" }, + { CLI_OPT_TYPE_SWITCH, "local", 0, &config_level, GIT_CONFIG_LEVEL_LOCAL, + CLI_OPT_USAGE_CHOICE, NULL, "read/write to local configuration" }, + { CLI_OPT_TYPE_VALUE, "file", 0, &config_filename, 0, + CLI_OPT_USAGE_CHOICE, "filename", "read/write to specified configuration file" }, + + { CLI_OPT_TYPE_SWITCH, "get", 0, &action, ACTION_GET, CLI_OPT_USAGE_REQUIRED, NULL, "get a configuration value" }, - { CLI_OPT_TYPE_SWITCH, "list", 'l', &action, ACTION_LIST, + { CLI_OPT_TYPE_SWITCH, "list", 'l', &action, ACTION_LIST, CLI_OPT_USAGE_CHOICE | CLI_OPT_USAGE_SHOW_LONG, NULL, "list all configuration entries" }, - { CLI_OPT_TYPE_SWITCH, "show-origin", 0, &show_origin, 1, + { CLI_OPT_TYPE_SWITCH, "show-origin", 0, &show_origin, 1, 0, NULL, "show origin of configuration" }, - { CLI_OPT_TYPE_SWITCH, "show-scope", 0, &show_scope, 1, + { CLI_OPT_TYPE_SWITCH, "show-scope", 0, &show_scope, 1, 0, NULL, "show scope of configuration" }, - { CLI_OPT_TYPE_ARG, "name", 0, &name, 0, + { CLI_OPT_TYPE_ARG, "name", 0, &name, 0, 0, "name", "name of configuration entry" }, { 0 }, }; @@ -148,10 +159,25 @@ int cmd_config(int argc, char **argv) return 0; } - if (cli_repository_open(&repo, &open_opts) < 0 || - git_repository_config(&config, repo) < 0) { - ret = cli_error_git(); - goto done; + if (config_filename) { + if (git_config_new(&config) < 0 || + git_config_add_file_ondisk(config, config_filename, + GIT_CONFIG_LEVEL_APP, NULL, 0) < 0) { + ret = cli_error_git(); + goto done; + } + } else { + if (cli_repository_open(&repo, &open_opts) < 0 || + git_repository_config(&config, repo) < 0) { + ret = cli_error_git(); + goto done; + } + + if (config_level && + git_config_open_level(&config, config, config_level) < 0) { + ret = cli_error_git(); + goto done; + } } switch (action) { From 929ec75451943085821f38f069ec667c902f6bf8 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Tue, 25 Jul 2023 18:15:00 +0200 Subject: [PATCH 328/608] cli: add `--add` and `--replace-all` to config --- src/cli/cmd_config.c | 48 +++++++++++++++++++++++++++++++++++++++----- 1 file changed, 43 insertions(+), 5 deletions(-) diff --git a/src/cli/cmd_config.c b/src/cli/cmd_config.c index 31c4c09bb02..6b9d373cee6 100644 --- a/src/cli/cmd_config.c +++ b/src/cli/cmd_config.c @@ -15,6 +15,8 @@ typedef enum { ACTION_NONE = 0, ACTION_GET, + ACTION_ADD, + ACTION_REPLACE_ALL, ACTION_LIST } action_t; @@ -25,7 +27,7 @@ static int show_help; static int null_separator; static int config_level; static char *config_filename; -static char *name; +static char *name, *value, *value_pattern; static const cli_opt_spec opts[] = { CLI_COMMON_OPT, \ @@ -44,6 +46,10 @@ static const cli_opt_spec opts[] = { { CLI_OPT_TYPE_SWITCH, "get", 0, &action, ACTION_GET, CLI_OPT_USAGE_REQUIRED, NULL, "get a configuration value" }, + { CLI_OPT_TYPE_SWITCH, "add", 0, &action, ACTION_ADD, + CLI_OPT_USAGE_CHOICE, NULL, "add a configuration value" }, + { CLI_OPT_TYPE_SWITCH, "replace-all", 0, &action, ACTION_REPLACE_ALL, + CLI_OPT_USAGE_CHOICE, NULL, "add a configuration value, replacing any old values" }, { CLI_OPT_TYPE_SWITCH, "list", 'l', &action, ACTION_LIST, CLI_OPT_USAGE_CHOICE | CLI_OPT_USAGE_SHOW_LONG, NULL, "list all configuration entries" }, @@ -53,6 +59,10 @@ static const cli_opt_spec opts[] = { 0, NULL, "show scope of configuration" }, { CLI_OPT_TYPE_ARG, "name", 0, &name, 0, 0, "name", "name of configuration entry" }, + { CLI_OPT_TYPE_ARG, "value", 0, &value, 0, + 0, "value", "value of configuration entry" }, + { CLI_OPT_TYPE_ARG, "regexp", 0, &value_pattern, 0, + 0, "regexp", "regular expression of values to replace" }, { 0 }, }; @@ -87,6 +97,22 @@ static int get_config(git_config *config) return 0; } +static int add_config(git_config *config) +{ + if (git_config_set_multivar(config, name, "$^", value) < 0) + return cli_error_git(); + + return 0; +} + +static int replace_all_config(git_config *config) +{ + if (git_config_set_multivar(config, name, value_pattern ? value_pattern : ".*", value) < 0) + return cli_error_git(); + + return 0; +} + static const char *level_name(git_config_level_t level) { switch (level) { @@ -181,11 +207,17 @@ int cmd_config(int argc, char **argv) } switch (action) { - case ACTION_LIST: - if (name) - ret = cli_error_usage("%s --list does not take an argument", COMMAND_NAME); + case ACTION_ADD: + if (!name || !value || value_pattern) + ret = cli_error_usage("%s --add requires two arguments", COMMAND_NAME); else - ret = list_config(config); + ret = add_config(config); + break; + case ACTION_REPLACE_ALL: + if (!name || !value) + ret = cli_error_usage("%s --replace-all requires two or three arguments", COMMAND_NAME); + else + ret = replace_all_config(config); break; case ACTION_GET: if (!name) @@ -193,6 +225,12 @@ int cmd_config(int argc, char **argv) else ret = get_config(config); break; + case ACTION_LIST: + if (name) + ret = cli_error_usage("%s --list does not take an argument", COMMAND_NAME); + else + ret = list_config(config); + break; default: ret = cli_error_usage("unknown action"); } From a79aa14206ca07c07ead829914d47090541d5376 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 31 Jul 2023 17:14:29 +0100 Subject: [PATCH 329/608] httpclient: safety --- src/libgit2/transports/httpclient.c | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/libgit2/transports/httpclient.c b/src/libgit2/transports/httpclient.c index 0ad6cd4dcb9..a20b594930d 100644 --- a/src/libgit2/transports/httpclient.c +++ b/src/libgit2/transports/httpclient.c @@ -837,6 +837,11 @@ GIT_INLINE(int) server_setup_from_url( git_http_server *server, git_net_url *url) { + GIT_ASSERT_ARG(url); + GIT_ASSERT_ARG(url->scheme); + GIT_ASSERT_ARG(url->host); + GIT_ASSERT_ARG(url->port); + if (!server->url.scheme || strcmp(server->url.scheme, url->scheme) || !server->url.host || strcmp(server->url.host, url->host) || !server->url.port || strcmp(server->url.port, url->port)) { From 8c2c0fa80a14d2e1769e5b1836aa121e287f2498 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Tue, 1 Aug 2023 11:58:53 +0100 Subject: [PATCH 330/608] net: refactor url parsing Refactor url parsing to simplify the state-passing (introducing a struct) and add a path parser for future reusability. --- src/util/net.c | 378 ++++++++++++++++++++++++----------------- tests/util/url/parse.c | 14 ++ 2 files changed, 235 insertions(+), 157 deletions(-) diff --git a/src/util/net.c b/src/util/net.c index dd8a1ba4670..15fff859213 100644 --- a/src/util/net.c +++ b/src/util/net.c @@ -19,6 +19,30 @@ #define DEFAULT_PORT_GIT "9418" #define DEFAULT_PORT_SSH "22" +#define GIT_NET_URL_PARSER_INIT { 0 } + +typedef struct { + int hierarchical : 1; + + const char *scheme; + const char *user; + const char *password; + const char *host; + const char *port; + const char *path; + const char *query; + const char *fragment; + + size_t scheme_len; + size_t user_len; + size_t password_len; + size_t host_len; + size_t port_len; + size_t path_len; + size_t query_len; + size_t fragment_len; +} git_net_url_parser; + bool git_net_hostname_matches_cert( const char *hostname, const char *pattern) @@ -63,6 +87,12 @@ bool git_net_hostname_matches_cert( return false; } +#define is_valid_scheme_char(c) \ + (((c) >= 'a' && (c) <= 'z') || \ + ((c) >= 'A' && (c) <= 'Z') || \ + ((c) >= '0' && (c) <= '9') || \ + (c) == '+' || (c) == '-' || (c) == '.') + bool git_net_str_is_url(const char *str) { const char *c; @@ -71,10 +101,7 @@ bool git_net_str_is_url(const char *str) if (*c == ':' && *(c+1) == '/' && *(c+2) == '/') return true; - if ((*c < 'a' || *c > 'z') && - (*c < 'A' || *c > 'Z') && - (*c < '0' || *c > '9') && - (*c != '+' && *c != '-' && *c != '.')) + if (!is_valid_scheme_char(*c)) break; } @@ -97,6 +124,16 @@ static const char *default_port_for_scheme(const char *scheme) return NULL; } +static bool is_ssh_scheme(const char *scheme, size_t scheme_len) +{ + if (!scheme_len) + return false; + + return strncasecmp(scheme, "ssh", scheme_len) == 0 || + strncasecmp(scheme, "ssh+git", scheme_len) == 0 || + strncasecmp(scheme, "git+ssh", scheme_len) == 0; +} + int git_net_url_dup(git_net_url *out, git_net_url *in) { if (in->scheme) { @@ -144,12 +181,9 @@ static int url_invalid(const char *message) } static int url_parse_authority( - const char **user_start, size_t *user_len, - const char **password_start, size_t *password_len, - const char **host_start, size_t *host_len, - const char **port_start, size_t *port_len, - const char *authority_start, size_t len, - const char *scheme_start, size_t scheme_len) + git_net_url_parser *parser, + const char *authority, + size_t len) { const char *c, *hostport_end, *host_end = NULL, *userpass_end, *user_end = NULL; @@ -165,14 +199,14 @@ static int url_parse_authority( * walk the authority backwards so that we can parse google code's * ssh urls that are not rfc compliant and allow @ in the username */ - for (hostport_end = authority_start + len, c = hostport_end - 1; - c >= authority_start && !user_end; + for (hostport_end = authority + len, c = hostport_end - 1; + c >= authority && !user_end; c--) { switch (state) { case HOSTPORT: if (*c == ':') { - *port_start = c + 1; - *port_len = hostport_end - *port_start; + parser->port = c + 1; + parser->port_len = hostport_end - parser->port; host_end = c; state = HOST; break; @@ -200,9 +234,10 @@ static int url_parse_authority( } else if (*c == '@') { - *host_start = c + 1; - *host_len = host_end ? host_end - *host_start : - hostport_end - *host_start; + parser->host = c + 1; + parser->host_len = host_end ? + host_end - parser->host : + hostport_end - parser->host; userpass_end = c; state = USERPASS; } @@ -215,8 +250,8 @@ static int url_parse_authority( case IPV6: if (*c == '[') { - *host_start = c + 1; - *host_len = host_end - *host_start; + parser->host = c + 1; + parser->host_len = host_end - parser->host; state = HOST_END; } @@ -240,12 +275,12 @@ static int url_parse_authority( case USERPASS: if (*c == '@' && - strncasecmp(scheme_start, "ssh", scheme_len)) + !is_ssh_scheme(parser->scheme, parser->scheme_len)) return url_invalid("malformed hostname"); if (*c == ':') { - *password_start = c + 1; - *password_len = userpass_end - *password_start; + parser->password = c + 1; + parser->password_len = userpass_end - parser->password; user_end = c; state = USER; break; @@ -260,24 +295,24 @@ static int url_parse_authority( switch (state) { case HOSTPORT: - *host_start = authority_start; - *host_len = (hostport_end - *host_start); + parser->host = authority; + parser->host_len = (hostport_end - parser->host); break; case HOST: - *host_start = authority_start; - *host_len = (host_end - *host_start); + parser->host = authority; + parser->host_len = (host_end - parser->host); break; case IPV6: return url_invalid("malformed hostname"); case HOST_END: break; case USERPASS: - *user_start = authority_start; - *user_len = (userpass_end - *user_start); + parser->user = authority; + parser->user_len = (userpass_end - parser->user); break; case USER: - *user_start = authority_start; - *user_len = (user_end - *user_start); + parser->user = authority; + parser->user_len = (user_end - parser->user); break; default: GIT_ASSERT(!"unhandled state"); @@ -286,97 +321,30 @@ static int url_parse_authority( return 0; } -int git_net_url_parse(git_net_url *url, const char *given) +static int url_parse_path( + git_net_url_parser *parser, + const char *path, + size_t len) { - const char *c, *scheme_start, *authority_start, *user_start, - *password_start, *host_start, *port_start, *path_start, - *query_start, *fragment_start, *default_port; - git_str scheme = GIT_STR_INIT, user = GIT_STR_INIT, - password = GIT_STR_INIT, host = GIT_STR_INIT, - port = GIT_STR_INIT, path = GIT_STR_INIT, - query = GIT_STR_INIT, fragment = GIT_STR_INIT; - size_t scheme_len = 0, user_len = 0, password_len = 0, host_len = 0, - port_len = 0, path_len = 0, query_len = 0, fragment_len = 0; - bool hierarchical = false; - int error = 0; + const char *c, *end; - enum { - SCHEME, - AUTHORITY_START, AUTHORITY, - PATH_START, PATH, - QUERY, - FRAGMENT - } state = SCHEME; + enum { PATH, QUERY, FRAGMENT } state = PATH; - memset(url, 0, sizeof(git_net_url)); + parser->path = path; + end = path + len; - for (c = scheme_start = given; *c; c++) { + for (c = path; c < end; c++) { switch (state) { - case SCHEME: - if (*c == ':') { - scheme_len = (c - scheme_start); - - if (*(c+1) == '/' && *(c+2) == '/') { - c += 2; - hierarchical = true; - state = AUTHORITY_START; - } else { - state = PATH_START; - } - } else if ((*c < 'A' || *c > 'Z') && - (*c < 'a' || *c > 'z') && - (*c < '0' || *c > '9') && - (*c != '+' && *c != '-' && *c != '.')) { - /* - * an illegal scheme character means that we - * were just given a relative path - */ - path_start = given; - state = PATH; - break; - } - break; - - case AUTHORITY_START: - authority_start = c; - state = AUTHORITY; - - /* fall through */ - - case AUTHORITY: - if (*c != '/') - break; - - /* - * authority is sufficiently complex that we parse - * it separately - */ - if ((error = url_parse_authority( - &user_start, &user_len, - &password_start,&password_len, - &host_start, &host_len, - &port_start, &port_len, - authority_start, (c - authority_start), - scheme_start, scheme_len)) < 0) - goto done; - - /* fall through */ - - case PATH_START: - path_start = c; - state = PATH; - /* fall through */ - case PATH: switch (*c) { case '?': - path_len = (c - path_start); - query_start = c + 1; + parser->path_len = (c - parser->path); + parser->query = c + 1; state = QUERY; break; case '#': - path_len = (c - path_start); - fragment_start = c + 1; + parser->path_len = (c - parser->path); + parser->fragment = c + 1; state = FRAGMENT; break; } @@ -384,8 +352,8 @@ int git_net_url_parse(git_net_url *url, const char *given) case QUERY: if (*c == '#') { - query_len = (c - query_start); - fragment_start = c + 1; + parser->query_len = (c - parser->query); + parser->fragment = c + 1; state = FRAGMENT; } break; @@ -399,82 +367,70 @@ int git_net_url_parse(git_net_url *url, const char *given) } switch (state) { - case SCHEME: - /* - * if we never saw a ':' then we were given a relative - * path, not a bare scheme - */ - path_start = given; - path_len = (c - scheme_start); - break; - case AUTHORITY_START: - break; - case AUTHORITY: - if ((error = url_parse_authority( - &user_start, &user_len, - &password_start,&password_len, - &host_start, &host_len, - &port_start, &port_len, - authority_start, (c - authority_start), - scheme_start, scheme_len)) < 0) - goto done; - break; - case PATH_START: - break; case PATH: - path_len = (c - path_start); + parser->path_len = (c - parser->path); break; case QUERY: - query_len = (c - query_start); + parser->query_len = (c - parser->query); break; case FRAGMENT: - fragment_len = (c - fragment_start); + parser->fragment_len = (c - parser->fragment); break; - default: - GIT_ASSERT(!"unhandled state"); } - if (scheme_len) { - if ((error = git_str_put(&scheme, scheme_start, scheme_len)) < 0) + return 0; +} + +static int url_parse_finalize(git_net_url *url, git_net_url_parser *parser) +{ + git_str scheme = GIT_STR_INIT, user = GIT_STR_INIT, + password = GIT_STR_INIT, host = GIT_STR_INIT, + port = GIT_STR_INIT, path = GIT_STR_INIT, + query = GIT_STR_INIT, fragment = GIT_STR_INIT; + const char *default_port; + int error = 0; + + if (parser->scheme_len) { + if ((error = git_str_put(&scheme, parser->scheme, parser->scheme_len)) < 0) goto done; git__strntolower(scheme.ptr, scheme.size); } - if (user_len && - (error = git_str_decode_percent(&user, user_start, user_len)) < 0) + if (parser->user_len && + (error = git_str_decode_percent(&user, parser->user, parser->user_len)) < 0) goto done; - if (password_len && - (error = git_str_decode_percent(&password, password_start, password_len)) < 0) + if (parser->password_len && + (error = git_str_decode_percent(&password, parser->password, parser->password_len)) < 0) goto done; - if (host_len && - (error = git_str_decode_percent(&host, host_start, host_len)) < 0) + if (parser->host_len && + (error = git_str_decode_percent(&host, parser->host, parser->host_len)) < 0) goto done; - if (port_len) - error = git_str_put(&port, port_start, port_len); - else if (scheme_len && (default_port = default_port_for_scheme(scheme.ptr)) != NULL) + if (parser->port_len) + error = git_str_put(&port, parser->port, parser->port_len); + else if (parser->scheme_len && (default_port = default_port_for_scheme(scheme.ptr)) != NULL) error = git_str_puts(&port, default_port); if (error < 0) goto done; - if (path_len) - error = git_str_put(&path, path_start, path_len); - else if (hierarchical) + if (parser->path_len) + error = git_str_put(&path, parser->path, parser->path_len); + else if (parser->hierarchical) error = git_str_puts(&path, "/"); if (error < 0) goto done; - if (query_len && - (error = git_str_decode_percent(&query, query_start, query_len)) < 0) + if (parser->query_len && + (error = git_str_decode_percent(&query, parser->query, parser->query_len)) < 0) goto done; - if (fragment_len && - (error = git_str_decode_percent(&fragment, fragment_start, fragment_len)) < 0) + if (parser->fragment_len && + (error = git_str_decode_percent(&fragment, parser->fragment, parser->fragment_len)) < 0) goto done; url->scheme = git_str_detach(&scheme); @@ -501,6 +457,114 @@ int git_net_url_parse(git_net_url *url, const char *given) return error; } +int git_net_url_parse(git_net_url *url, const char *given) +{ + git_net_url_parser parser = GIT_NET_URL_PARSER_INIT; + const char *c, *authority, *path; + size_t authority_len = 0, path_len = 0; + int error = 0; + + enum { + SCHEME_START, SCHEME, + AUTHORITY_START, AUTHORITY, + PATH_START, PATH + } state = SCHEME_START; + + memset(url, 0, sizeof(git_net_url)); + + for (c = given; *c; c++) { + switch (state) { + case SCHEME_START: + parser.scheme = c; + state = SCHEME; + + /* fall through */ + + case SCHEME: + if (*c == ':') { + parser.scheme_len = (c - parser.scheme); + + if (parser.scheme_len && + *(c+1) == '/' && *(c+2) == '/') { + c += 2; + parser.hierarchical = 1; + state = AUTHORITY_START; + } else { + state = PATH_START; + } + } else if (!is_valid_scheme_char(*c)) { + /* + * an illegal scheme character means that we + * were just given a relative path + */ + path = given; + state = PATH; + break; + } + break; + + case AUTHORITY_START: + authority = c; + state = AUTHORITY; + + /* fall through */ + case AUTHORITY: + if (*c != '/') + break; + + authority_len = (c - authority); + + /* fall through */ + case PATH_START: + path = c; + state = PATH; + break; + + case PATH: + break; + + default: + GIT_ASSERT(!"unhandled state"); + } + } + + switch (state) { + case SCHEME: + /* + * if we never saw a ':' then we were given a relative + * path, not a bare scheme + */ + path = given; + path_len = (c - path); + break; + case AUTHORITY_START: + break; + case AUTHORITY: + authority_len = (c - authority); + break; + case PATH_START: + break; + case PATH: + path_len = (c - path); + break; + default: + GIT_ASSERT(!"unhandled state"); + } + + if (authority_len && + (error = url_parse_authority(&parser, authority, authority_len)) < 0) + goto done; + + if (path_len && + (error = url_parse_path(&parser, path, path_len)) < 0) + goto done; + + error = url_parse_finalize(url, &parser); + +done: + return error; +} + static int scp_invalid(const char *message) { git_error_set(GIT_ERROR_NET, "invalid scp-style path: %s", message); diff --git a/tests/util/url/parse.c b/tests/util/url/parse.c index 631d9b456d9..35486f7b7a7 100644 --- a/tests/util/url/parse.c +++ b/tests/util/url/parse.c @@ -669,6 +669,20 @@ void test_url_parse__ipv6_invalid_addresses(void) /* Oddities */ +void test_url_parse__empty_scheme(void) +{ + cl_git_pass(git_net_url_parse(&conndata, "://example.com/resource")); + cl_assert_equal_s(conndata.scheme, NULL); + cl_assert_equal_s(conndata.host, NULL); + cl_assert_equal_s(conndata.port, NULL); + cl_assert_equal_s(conndata.path, "//example.com/resource"); + cl_assert_equal_p(conndata.username, NULL); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_p(conndata.query, NULL); + cl_assert_equal_p(conndata.fragment, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0); +} + void test_url_parse__invalid_scheme_is_relative(void) { cl_git_pass(git_net_url_parse(&conndata, "foo!bar://host:42/path/to/project?query_string=yes")); From 8749655745d06b3be01222d512218dc16a359731 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Tue, 1 Aug 2023 11:59:55 +0100 Subject: [PATCH 331/608] net: introduce http-biased url parsing Introduce a url parser that defaults to treating poorly specified URLs as http URLs. For example: `localhost:8080` is treated as `http://localhost:8080/` by the http-biased url parsing, instead of a URL with a scheme `localhost` and a path of `8080`.. --- src/util/net.c | 43 +++ src/util/net.h | 8 + tests/util/url/http.c | 752 ++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 803 insertions(+) create mode 100644 tests/util/url/http.c diff --git a/src/util/net.c b/src/util/net.c index 15fff859213..afd52ce0830 100644 --- a/src/util/net.c +++ b/src/util/net.c @@ -565,6 +565,49 @@ int git_net_url_parse(git_net_url *url, const char *given) return error; } +int git_net_url_parse_http( + git_net_url *url, + const char *given) +{ + git_net_url_parser parser = GIT_NET_URL_PARSER_INIT; + const char *c, *authority, *path = NULL; + size_t authority_len = 0, path_len = 0; + int error; + + /* Hopefully this is a proper URL with a scheme. */ + if (git_net_str_is_url(given)) + return git_net_url_parse(url, given); + + memset(url, 0, sizeof(git_net_url)); + + /* Without a scheme, we are in the host (authority) section. */ + for (c = authority = given; *c; c++) { + if (!path && *c == '/') { + authority_len = (c - authority); + path = c; + } + } + + if (path) + path_len = (c - path); + else + authority_len = (c - authority); + + parser.scheme = "http"; + parser.scheme_len = 4; + parser.hierarchical = 1; + + if (authority_len && + (error = url_parse_authority(&parser, authority, authority_len)) < 0) + return error; + + if (path_len && + (error = url_parse_path(&parser, path, path_len)) < 0) + return error; + + return url_parse_finalize(url, &parser); +} + static int scp_invalid(const char *message) { git_error_set(GIT_ERROR_NET, "invalid scp-style path: %s", message); diff --git a/src/util/net.h b/src/util/net.h index c9a84cb6cec..8024956ad0c 100644 --- a/src/util/net.h +++ b/src/util/net.h @@ -57,6 +57,14 @@ extern int git_net_url_parse_scp(git_net_url *url, const char *str); */ extern int git_net_url_parse_standard_or_scp(git_net_url *url, const char *str); +/** + * Parses a string containing an HTTP endpoint that may not be a + * well-formed URL. For example, "localhost" or "localhost:port". + */ +extern int git_net_url_parse_http( + git_net_url *url, + const char *str); + /** Appends a path and/or query string to the given URL */ extern int git_net_url_joinpath( git_net_url *out, diff --git a/tests/util/url/http.c b/tests/util/url/http.c new file mode 100644 index 00000000000..88238896257 --- /dev/null +++ b/tests/util/url/http.c @@ -0,0 +1,752 @@ +#include "clar_libgit2.h" +#include "net.h" + +static git_net_url conndata; + +void test_url_http__initialize(void) +{ + memset(&conndata, 0, sizeof(conndata)); +} + +void test_url_http__cleanup(void) +{ + git_net_url_dispose(&conndata); +} + +/* Hostname */ + +void test_url_http__has_scheme(void) +{ + cl_git_pass(git_net_url_parse_http(&conndata, "http://example.com/resource")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "example.com"); + cl_assert_equal_s(conndata.port, "80"); + cl_assert_equal_s(conndata.path, "/resource"); + cl_assert_equal_p(conndata.username, NULL); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_p(conndata.query, NULL); + cl_assert_equal_p(conndata.fragment, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); +} + +void test_url_http__no_scheme(void) +{ + cl_git_pass(git_net_url_parse_http(&conndata, "example.com/resource")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "example.com"); + cl_assert_equal_s(conndata.port, "80"); + cl_assert_equal_s(conndata.path, "/resource"); + cl_assert_equal_p(conndata.username, NULL); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_p(conndata.query, NULL); + cl_assert_equal_p(conndata.fragment, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); +} + +void test_url_http__hostname_root(void) +{ + cl_git_pass(git_net_url_parse_http(&conndata, "example.com/")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "example.com"); + cl_assert_equal_s(conndata.port, "80"); + cl_assert_equal_s(conndata.path, "/"); + cl_assert_equal_p(conndata.username, NULL); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_p(conndata.query, NULL); + cl_assert_equal_p(conndata.fragment, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); +} + +void test_url_http__hostname_implied_root(void) +{ + cl_git_pass(git_net_url_parse_http(&conndata, "example.com")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "example.com"); + cl_assert_equal_s(conndata.port, "80"); + cl_assert_equal_s(conndata.path, "/"); + cl_assert_equal_p(conndata.username, NULL); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_p(conndata.query, NULL); + cl_assert_equal_p(conndata.fragment, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); +} + +void test_url_http__hostname_numeric(void) +{ + cl_git_pass(git_net_url_parse_http(&conndata, "8888888/")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "8888888"); + cl_assert_equal_s(conndata.port, "80"); + cl_assert_equal_s(conndata.path, "/"); + cl_assert_equal_p(conndata.username, NULL); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_p(conndata.query, NULL); + cl_assert_equal_p(conndata.fragment, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); +} + +void test_url_http__hostname_implied_root_custom_port(void) +{ + cl_git_pass(git_net_url_parse_http(&conndata, "example.com:42")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "example.com"); + cl_assert_equal_s(conndata.port, "42"); + cl_assert_equal_s(conndata.path, "/"); + cl_assert_equal_p(conndata.username, NULL); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_p(conndata.query, NULL); + cl_assert_equal_p(conndata.fragment, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0); +} + +void test_url_http__hostname_implied_root_empty_port(void) +{ + cl_git_pass(git_net_url_parse_http(&conndata, "example.com:")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "example.com"); + cl_assert_equal_s(conndata.port, "80"); + cl_assert_equal_s(conndata.path, "/"); + cl_assert_equal_p(conndata.username, NULL); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_p(conndata.query, NULL); + cl_assert_equal_p(conndata.fragment, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); +} + +void test_url_http__hostname_encoded_password(void) +{ + cl_git_pass(git_net_url_parse_http(&conndata, + "user:pass%2fis%40bad@hostname.com:1234/")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "hostname.com"); + cl_assert_equal_s(conndata.port, "1234"); + cl_assert_equal_s(conndata.path, "/"); + cl_assert_equal_s(conndata.username, "user"); + cl_assert_equal_s(conndata.password, "pass/is@bad"); + cl_assert_equal_p(conndata.query, NULL); + cl_assert_equal_p(conndata.fragment, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0); +} + +void test_url_http__hostname_user(void) +{ + cl_git_pass(git_net_url_parse_http(&conndata, + "user@example.com/resource")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "example.com"); + cl_assert_equal_s(conndata.port, "80"); + cl_assert_equal_s(conndata.path, "/resource"); + cl_assert_equal_s(conndata.username, "user"); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_p(conndata.query, NULL); + cl_assert_equal_p(conndata.fragment, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); +} + +void test_url_http__hostname_user_pass(void) +{ + /* user:pass@hostname.tld/resource */ + cl_git_pass(git_net_url_parse_http(&conndata, + "user:pass@example.com/resource")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "example.com"); + cl_assert_equal_s(conndata.port, "80"); + cl_assert_equal_s(conndata.path, "/resource"); + cl_assert_equal_s(conndata.username, "user"); + cl_assert_equal_s(conndata.password, "pass"); + cl_assert_equal_p(conndata.query, NULL); + cl_assert_equal_p(conndata.fragment, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); +} + +void test_url_http__hostname_port(void) +{ + /* hostname.tld:port/resource */ + cl_git_pass(git_net_url_parse_http(&conndata, + "example.com:9191/resource")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "example.com"); + cl_assert_equal_s(conndata.port, "9191"); + cl_assert_equal_s(conndata.path, "/resource"); + cl_assert_equal_p(conndata.username, NULL); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_p(conndata.query, NULL); + cl_assert_equal_p(conndata.fragment, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0); +} + +void test_url_http__hostname_empty_port(void) +{ + cl_git_pass(git_net_url_parse_http(&conndata, "example.com:/resource")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "example.com"); + cl_assert_equal_s(conndata.port, "80"); + cl_assert_equal_s(conndata.path, "/resource"); + cl_assert_equal_p(conndata.username, NULL); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_p(conndata.query, NULL); + cl_assert_equal_p(conndata.fragment, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); +} + +void test_url_http__hostname_user_port(void) +{ + /* user@hostname.tld:port/resource */ + cl_git_pass(git_net_url_parse_http(&conndata, + "user@example.com:9191/resource")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "example.com"); + cl_assert_equal_s(conndata.port, "9191"); + cl_assert_equal_s(conndata.path, "/resource"); + cl_assert_equal_s(conndata.username, "user"); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_p(conndata.query, NULL); + cl_assert_equal_p(conndata.fragment, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0); +} + +void test_url_http__hostname_user_pass_port(void) +{ + /* user:pass@hostname.tld:port/resource */ + cl_git_pass(git_net_url_parse_http(&conndata, + "user:pass@example.com:9191/resource")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "example.com"); + cl_assert_equal_s(conndata.port, "9191"); + cl_assert_equal_s(conndata.path, "/resource"); + cl_assert_equal_s(conndata.username, "user"); + cl_assert_equal_s(conndata.password, "pass"); + cl_assert_equal_p(conndata.query, NULL); + cl_assert_equal_p(conndata.fragment, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0); +} + +void test_url_http__hostname_user_pass_port_query(void) +{ + /* user:pass@hostname.tld:port/resource */ + cl_git_pass(git_net_url_parse_http(&conndata, + "user:pass@example.com:9191/resource?query=q&foo=bar&z=asdf")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "example.com"); + cl_assert_equal_s(conndata.port, "9191"); + cl_assert_equal_s(conndata.path, "/resource"); + cl_assert_equal_s(conndata.username, "user"); + cl_assert_equal_s(conndata.password, "pass"); + cl_assert_equal_s(conndata.query, "query=q&foo=bar&z=asdf"); + cl_assert_equal_p(conndata.fragment, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0); +} + +void test_url_http__hostname_user_pass_port_fragment(void) +{ + /* user:pass@hostname.tld:port/resource */ + cl_git_pass(git_net_url_parse_http(&conndata, + "user:pass@example.com:9191/resource#fragment")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "example.com"); + cl_assert_equal_s(conndata.port, "9191"); + cl_assert_equal_s(conndata.path, "/resource"); + cl_assert_equal_s(conndata.username, "user"); + cl_assert_equal_s(conndata.password, "pass"); + cl_assert_equal_p(conndata.query, NULL); + cl_assert_equal_s(conndata.fragment, "fragment"); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0); +} + +void test_url_http__hostname_user_pass_port_query_fragment(void) +{ + /* user:pass@hostname.tld:port/resource */ + cl_git_pass(git_net_url_parse_http(&conndata, + "user:pass@example.com:9191/resource?query=q&foo=bar&z=asdf#fragment")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "example.com"); + cl_assert_equal_s(conndata.port, "9191"); + cl_assert_equal_s(conndata.path, "/resource"); + cl_assert_equal_s(conndata.username, "user"); + cl_assert_equal_s(conndata.password, "pass"); + cl_assert_equal_s(conndata.query, "query=q&foo=bar&z=asdf"); + cl_assert_equal_s(conndata.fragment, "fragment"); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0); +} + +void test_url_http__fragment_with_question_mark(void) +{ + /* user:pass@hostname.tld:port/resource */ + cl_git_pass(git_net_url_parse_http(&conndata, + "user:pass@example.com:9191/resource#fragment_with?question_mark")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "example.com"); + cl_assert_equal_s(conndata.port, "9191"); + cl_assert_equal_s(conndata.path, "/resource"); + cl_assert_equal_s(conndata.username, "user"); + cl_assert_equal_s(conndata.password, "pass"); + cl_assert_equal_p(conndata.query, NULL); + cl_assert_equal_s(conndata.fragment, "fragment_with?question_mark"); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0); +} + +/* IPv4 addresses */ + +void test_url_http__ipv4_trivial(void) +{ + cl_git_pass(git_net_url_parse_http(&conndata, "192.168.1.1/resource")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "192.168.1.1"); + cl_assert_equal_s(conndata.port, "80"); + cl_assert_equal_s(conndata.path, "/resource"); + cl_assert_equal_p(conndata.username, NULL); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); +} + +void test_url_http__ipv4_root(void) +{ + cl_git_pass(git_net_url_parse_http(&conndata, "192.168.1.1/")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "192.168.1.1"); + cl_assert_equal_s(conndata.port, "80"); + cl_assert_equal_s(conndata.path, "/"); + cl_assert_equal_p(conndata.username, NULL); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); +} + +void test_url_http__ipv4_implied_root(void) +{ + cl_git_pass(git_net_url_parse_http(&conndata, "192.168.1.1")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "192.168.1.1"); + cl_assert_equal_s(conndata.port, "80"); + cl_assert_equal_s(conndata.path, "/"); + cl_assert_equal_p(conndata.username, NULL); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); +} + +void test_url_http__ipv4_implied_root_custom_port(void) +{ + cl_git_pass(git_net_url_parse_http(&conndata, "192.168.1.1:42")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "192.168.1.1"); + cl_assert_equal_s(conndata.port, "42"); + cl_assert_equal_s(conndata.path, "/"); + cl_assert_equal_p(conndata.username, NULL); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0); +} + +void test_url_http__ipv4_implied_root_empty_port(void) +{ + cl_git_pass(git_net_url_parse_http(&conndata, "192.168.1.1:")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "192.168.1.1"); + cl_assert_equal_s(conndata.port, "80"); + cl_assert_equal_s(conndata.path, "/"); + cl_assert_equal_p(conndata.username, NULL); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); +} + +void test_url_http__ipv4_encoded_password(void) +{ + cl_git_pass(git_net_url_parse_http(&conndata, + "user:pass%2fis%40bad@192.168.1.1:1234/")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "192.168.1.1"); + cl_assert_equal_s(conndata.port, "1234"); + cl_assert_equal_s(conndata.path, "/"); + cl_assert_equal_s(conndata.username, "user"); + cl_assert_equal_s(conndata.password, "pass/is@bad"); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0); +} + +void test_url_http__ipv4_user(void) +{ + cl_git_pass(git_net_url_parse_http(&conndata, + "user@192.168.1.1/resource")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "192.168.1.1"); + cl_assert_equal_s(conndata.port, "80"); + cl_assert_equal_s(conndata.path, "/resource"); + cl_assert_equal_s(conndata.username, "user"); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); +} + +void test_url_http__ipv4_user_pass(void) +{ + cl_git_pass(git_net_url_parse_http(&conndata, + "user:pass@192.168.1.1/resource")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "192.168.1.1"); + cl_assert_equal_s(conndata.port, "80"); + cl_assert_equal_s(conndata.path, "/resource"); + cl_assert_equal_s(conndata.username, "user"); + cl_assert_equal_s(conndata.password, "pass"); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); +} + +void test_url_http__ipv4_port(void) +{ + cl_git_pass(git_net_url_parse_http(&conndata, + "192.168.1.1:9191/resource")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "192.168.1.1"); + cl_assert_equal_s(conndata.port, "9191"); + cl_assert_equal_s(conndata.path, "/resource"); + cl_assert_equal_p(conndata.username, NULL); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0); +} + +void test_url_http__ipv4_empty_port(void) +{ + cl_git_pass(git_net_url_parse_http(&conndata, "192.168.1.1:/resource")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "192.168.1.1"); + cl_assert_equal_s(conndata.port, "80"); + cl_assert_equal_s(conndata.path, "/resource"); + cl_assert_equal_p(conndata.username, NULL); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); +} + +void test_url_http__ipv4_user_port(void) +{ + cl_git_pass(git_net_url_parse_http(&conndata, + "user@192.168.1.1:9191/resource")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "192.168.1.1"); + cl_assert_equal_s(conndata.port, "9191"); + cl_assert_equal_s(conndata.path, "/resource"); + cl_assert_equal_s(conndata.username, "user"); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0); +} + +void test_url_http__ipv4_user_pass_port(void) +{ + cl_git_pass(git_net_url_parse_http(&conndata, + "user:pass@192.168.1.1:9191/resource")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "192.168.1.1"); + cl_assert_equal_s(conndata.port, "9191"); + cl_assert_equal_s(conndata.path, "/resource"); + cl_assert_equal_s(conndata.username, "user"); + cl_assert_equal_s(conndata.password, "pass"); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0); +} + +/* IPv6 addresses */ + +void test_url_http__ipv6_trivial(void) +{ + cl_git_pass(git_net_url_parse_http(&conndata, "[fe80::dcad:beff:fe00:0001]/resource")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "fe80::dcad:beff:fe00:0001"); + cl_assert_equal_s(conndata.port, "80"); + cl_assert_equal_s(conndata.path, "/resource"); + cl_assert_equal_p(conndata.username, NULL); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); +} + +void test_url_http__ipv6_root(void) +{ + cl_git_pass(git_net_url_parse_http(&conndata, "[fe80::dcad:beff:fe00:0001]/")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "fe80::dcad:beff:fe00:0001"); + cl_assert_equal_s(conndata.port, "80"); + cl_assert_equal_s(conndata.path, "/"); + cl_assert_equal_p(conndata.username, NULL); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); +} + +void test_url_http__ipv6_implied_root(void) +{ + cl_git_pass(git_net_url_parse_http(&conndata, "[fe80::dcad:beff:fe00:0001]")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "fe80::dcad:beff:fe00:0001"); + cl_assert_equal_s(conndata.port, "80"); + cl_assert_equal_s(conndata.path, "/"); + cl_assert_equal_p(conndata.username, NULL); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); +} + +void test_url_http__ipv6_implied_root_custom_port(void) +{ + cl_git_pass(git_net_url_parse_http(&conndata, "[fe80::dcad:beff:fe00:0001]:42")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "fe80::dcad:beff:fe00:0001"); + cl_assert_equal_s(conndata.port, "42"); + cl_assert_equal_s(conndata.path, "/"); + cl_assert_equal_p(conndata.username, NULL); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0); +} + +void test_url_http__ipv6_implied_root_empty_port(void) +{ + cl_git_pass(git_net_url_parse_http(&conndata, "[fe80::dcad:beff:fe00:0001]:")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "fe80::dcad:beff:fe00:0001"); + cl_assert_equal_s(conndata.port, "80"); + cl_assert_equal_s(conndata.path, "/"); + cl_assert_equal_p(conndata.username, NULL); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); +} + +void test_url_http__ipv6_encoded_password(void) +{ + cl_git_pass(git_net_url_parse_http(&conndata, + "user:pass%2fis%40bad@[fe80::dcad:beff:fe00:0001]:1234/")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "fe80::dcad:beff:fe00:0001"); + cl_assert_equal_s(conndata.port, "1234"); + cl_assert_equal_s(conndata.path, "/"); + cl_assert_equal_s(conndata.username, "user"); + cl_assert_equal_s(conndata.password, "pass/is@bad"); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0); +} + +void test_url_http__ipv6_user(void) +{ + cl_git_pass(git_net_url_parse_http(&conndata, + "user@[fe80::dcad:beff:fe00:0001]/resource")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "fe80::dcad:beff:fe00:0001"); + cl_assert_equal_s(conndata.port, "80"); + cl_assert_equal_s(conndata.path, "/resource"); + cl_assert_equal_s(conndata.username, "user"); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); +} + +void test_url_http__ipv6_user_pass(void) +{ + cl_git_pass(git_net_url_parse_http(&conndata, + "user:pass@[fe80::dcad:beff:fe00:0001]/resource")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "fe80::dcad:beff:fe00:0001"); + cl_assert_equal_s(conndata.port, "80"); + cl_assert_equal_s(conndata.path, "/resource"); + cl_assert_equal_s(conndata.username, "user"); + cl_assert_equal_s(conndata.password, "pass"); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); +} + +void test_url_http__ipv6_port(void) +{ + cl_git_pass(git_net_url_parse_http(&conndata, + "[fe80::dcad:beff:fe00:0001]:9191/resource")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "fe80::dcad:beff:fe00:0001"); + cl_assert_equal_s(conndata.port, "9191"); + cl_assert_equal_s(conndata.path, "/resource"); + cl_assert_equal_p(conndata.username, NULL); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0); +} + +void test_url_http__ipv6_empty_port(void) +{ + cl_git_pass(git_net_url_parse_http(&conndata, "[fe80::dcad:beff:fe00:0001]:/resource")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "fe80::dcad:beff:fe00:0001"); + cl_assert_equal_s(conndata.port, "80"); + cl_assert_equal_s(conndata.path, "/resource"); + cl_assert_equal_p(conndata.username, NULL); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); +} + +void test_url_http__ipv6_user_port(void) +{ + cl_git_pass(git_net_url_parse_http(&conndata, + "user@[fe80::dcad:beff:fe00:0001]:9191/resource")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "fe80::dcad:beff:fe00:0001"); + cl_assert_equal_s(conndata.port, "9191"); + cl_assert_equal_s(conndata.path, "/resource"); + cl_assert_equal_s(conndata.username, "user"); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0); +} + +void test_url_http__ipv6_user_pass_port(void) +{ + cl_git_pass(git_net_url_parse_http(&conndata, + "user:pass@[fe80::dcad:beff:fe00:0001]:9191/resource")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "fe80::dcad:beff:fe00:0001"); + cl_assert_equal_s(conndata.port, "9191"); + cl_assert_equal_s(conndata.path, "/resource"); + cl_assert_equal_s(conndata.username, "user"); + cl_assert_equal_s(conndata.password, "pass"); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0); +} + +void test_url_http__ipv6_invalid_addresses(void) +{ + /* Opening bracket missing */ + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata, + "fe80::dcad:beff:fe00:0001]/resource")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata, + "fe80::dcad:beff:fe00:0001]/")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata, + "fe80::dcad:beff:fe00:0001]")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata, + "fe80::dcad:beff:fe00:0001]:42")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata, + "fe80::dcad:beff:fe00:0001]:")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata, + "user:pass%2fis%40bad@fe80::dcad:beff:fe00:0001]:1234/")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata, + "user@fe80::dcad:beff:fe00:0001]/resource")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata, + "user:pass@fe80::dcad:beff:fe00:0001]/resource")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata, + "fe80::dcad:beff:fe00:0001]:9191/resource")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata, + "fe80::dcad:beff:fe00:0001]:/resource")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata, + "user@fe80::dcad:beff:fe00:0001]:9191/resource")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata, + "user:pass@fe80::dcad:beff:fe00:0001]:9191/resource")); + + /* Closing bracket missing */ + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata, + "[fe80::dcad:beff:fe00:0001/resource")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata, + "[fe80::dcad:beff:fe00:0001/")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata, + "[fe80::dcad:beff:fe00:0001")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata, + "[fe80::dcad:beff:fe00:0001:42")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata, + "[fe80::dcad:beff:fe00:0001:")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata, + "user:pass%2fis%40bad@[fe80::dcad:beff:fe00:0001:1234/")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata, + "user@[fe80::dcad:beff:fe00:0001/resource")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata, + "user:pass@[fe80::dcad:beff:fe00:0001/resource")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata, + "[fe80::dcad:beff:fe00:0001:9191/resource")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata, + "[fe80::dcad:beff:fe00:0001:/resource")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata, + "user@[fe80::dcad:beff:fe00:0001:9191/resource")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata, + "user:pass@[fe80::dcad:beff:fe00:0001:9191/resource")); + + /* Both brackets missing */ + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata, + "fe80::dcad:beff:fe00:0001/resource")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata, + "fe80::dcad:beff:fe00:0001/")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata, + "fe80::dcad:beff:fe00:0001")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata, + "fe80::dcad:beff:fe00:0001:42")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata, + "fe80::dcad:beff:fe00:0001:")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata, + "user:pass%2fis%40bad@fe80::dcad:beff:fe00:0001:1234/")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata, + "user@fe80::dcad:beff:fe00:0001/resource")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata, + "user:pass@fe80::dcad:beff:fe00:0001/resource")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata, + "fe80::dcad:beff:fe00:0001:9191/resource")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata, + "fe80::dcad:beff:fe00:0001:/resource")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata, + "user@fe80::dcad:beff:fe00:0001:9191/resource")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata, + "user:pass@fe80::dcad:beff:fe00:0001:9191/resource")); + + /* Invalid character inside address */ + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata, "[fe8o::dcad:beff:fe00:0001]/resource")); + + /* Characters before/after braces */ + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata, + "fe80::[dcad:beff:fe00:0001]/resource")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata, + "cafe[fe80::dcad:beff:fe00:0001]/resource")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata, + "[fe80::dcad:beff:fe00:0001]cafe/resource")); +} + +/* Oddities */ + +void test_url_http__invalid_scheme_is_relative(void) +{ + cl_git_pass(git_net_url_parse_http(&conndata, "foo!bar://host:42/path/to/project?query_string=yes")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "foo!bar"); + cl_assert_equal_s(conndata.port, "80"); + cl_assert_equal_s(conndata.path, "//host:42/path/to/project"); + cl_assert_equal_p(conndata.username, NULL); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_s(conndata.query, "query_string=yes"); + cl_assert_equal_p(conndata.fragment, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); +} + +void test_url_http__scheme_case_is_normalized(void) +{ + cl_git_pass(git_net_url_parse_http(&conndata, "GIT+SSH://host:42/path/to/project")); + cl_assert_equal_s(conndata.scheme, "git+ssh"); +} + +void test_url_http__no_scheme_relative_path(void) +{ + cl_git_pass(git_net_url_parse_http(&conndata, "path")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "path"); + cl_assert_equal_s(conndata.port, "80"); + cl_assert_equal_s(conndata.path, "/"); + cl_assert_equal_p(conndata.username, NULL); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); +} + +void test_url_http__no_scheme_absolute_path(void) +{ + cl_git_pass(git_net_url_parse_http(&conndata, "/path")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_p(conndata.host, NULL); + cl_assert_equal_s(conndata.port, "80"); + cl_assert_equal_s(conndata.path, "/path"); + cl_assert_equal_p(conndata.username, NULL); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); +} + +void test_url_http__empty_path_with_empty_authority(void) +{ + cl_git_pass(git_net_url_parse_http(&conndata, "")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_p(conndata.host, NULL); + cl_assert_equal_s(conndata.port, "80"); + cl_assert_equal_s(conndata.path, "/"); + cl_assert_equal_p(conndata.username, NULL); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); +} + +void test_url_http__spaces_in_the_name(void) +{ + cl_git_pass(git_net_url_parse_http(&conndata, "libgit2@dev.azure.com/libgit2/test/_git/spaces%20in%20the%20name")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "dev.azure.com"); + cl_assert_equal_s(conndata.port, "80"); + cl_assert_equal_s(conndata.path, "/libgit2/test/_git/spaces%20in%20the%20name"); + cl_assert_equal_s(conndata.username, "libgit2"); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); +} From b6fdb3cbdf9ec0c663d4d34b0121c739a2d314fd Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Tue, 1 Aug 2023 12:16:32 +0100 Subject: [PATCH 332/608] http: allow proxies to be specified in common format The common format for specifying proxy URLs is just 'host:port'. Handle the common case. --- src/libgit2/transports/http.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/libgit2/transports/http.c b/src/libgit2/transports/http.c index eed51914549..8437674fcc9 100644 --- a/src/libgit2/transports/http.c +++ b/src/libgit2/transports/http.c @@ -335,7 +335,7 @@ static int lookup_proxy( } if (!proxy || - (error = git_net_url_parse(&transport->proxy.url, proxy)) < 0) + (error = git_net_url_parse_http(&transport->proxy.url, proxy)) < 0) goto done; if (!git_net_url_valid(&transport->proxy.url)) { From 5a64922408a5198c5ae00771b942fea1c76d2746 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Tue, 1 Aug 2023 14:07:53 +0100 Subject: [PATCH 333/608] http: test proxies in url and host:port format Test proxies specified by both host:port format in configuration options, environment variables, and `http.proxy` configuration. --- tests/libgit2/online/clone.c | 124 ++++++++++++++++++++++++++++++----- 1 file changed, 107 insertions(+), 17 deletions(-) diff --git a/tests/libgit2/online/clone.c b/tests/libgit2/online/clone.c index 0c53514a425..5789e9654c3 100644 --- a/tests/libgit2/online/clone.c +++ b/tests/libgit2/online/clone.c @@ -43,7 +43,6 @@ static char *_github_ssh_privkey = NULL; static char *_github_ssh_passphrase = NULL; static char *_github_ssh_remotehostkey = NULL; -static int _orig_proxies_need_reset = 0; static char *_orig_http_proxy = NULL; static char *_orig_https_proxy = NULL; static char *_orig_no_proxy = NULL; @@ -99,10 +98,12 @@ void test_online_clone__initialize(void) _github_ssh_passphrase = cl_getenv("GITTEST_GITHUB_SSH_PASSPHRASE"); _github_ssh_remotehostkey = cl_getenv("GITTEST_GITHUB_SSH_REMOTE_HOSTKEY"); + _orig_http_proxy = cl_getenv("HTTP_PROXY"); + _orig_https_proxy = cl_getenv("HTTPS_PROXY"); + _orig_no_proxy = cl_getenv("NO_PROXY"); + if (_remote_expectcontinue) git_libgit2_opts(GIT_OPT_ENABLE_HTTP_EXPECT_CONTINUE, 1); - - _orig_proxies_need_reset = 0; } void test_online_clone__cleanup(void) @@ -140,15 +141,13 @@ void test_online_clone__cleanup(void) git__free(_github_ssh_passphrase); git__free(_github_ssh_remotehostkey); - if (_orig_proxies_need_reset) { - cl_setenv("HTTP_PROXY", _orig_http_proxy); - cl_setenv("HTTPS_PROXY", _orig_https_proxy); - cl_setenv("NO_PROXY", _orig_no_proxy); + cl_setenv("HTTP_PROXY", _orig_http_proxy); + cl_setenv("HTTPS_PROXY", _orig_https_proxy); + cl_setenv("NO_PROXY", _orig_no_proxy); - git__free(_orig_http_proxy); - git__free(_orig_https_proxy); - git__free(_orig_no_proxy); - } + git__free(_orig_http_proxy); + git__free(_orig_https_proxy); + git__free(_orig_no_proxy); git_libgit2_opts(GIT_OPT_SET_SSL_CERT_LOCATIONS, NULL, NULL); git_libgit2_opts(GIT_OPT_SET_SERVER_TIMEOUT, 0); @@ -968,6 +967,79 @@ static int proxy_cert_cb(git_cert *cert, int valid, const char *host, void *payl return valid ? 0 : GIT_ECERTIFICATE; } +void test_online_clone__proxy_http_host_port_in_opts(void) +{ + if (!_remote_proxy_host || !_remote_proxy_user || !_remote_proxy_pass) + cl_skip(); + + if (_remote_proxy_scheme && strcmp(_remote_proxy_scheme, "http") != 0) + cl_skip(); + + g_options.fetch_opts.proxy_opts.type = GIT_PROXY_SPECIFIED; + g_options.fetch_opts.proxy_opts.url = _remote_proxy_host; + g_options.fetch_opts.proxy_opts.credentials = proxy_cred_cb; + + called_proxy_creds = 0; + cl_git_pass(git_clone(&g_repo, "https://github.com/libgit2/TestGitRepository", "./foo", &g_options)); + cl_assert(called_proxy_creds == 1); +} + +void test_online_clone__proxy_http_host_port_in_env(void) +{ + if (!_remote_proxy_host || !_remote_proxy_user || !_remote_proxy_pass) + cl_skip(); + + if (_remote_proxy_scheme && strcmp(_remote_proxy_scheme, "http") != 0) + cl_skip(); + + cl_setenv("HTTP_PROXY", _remote_proxy_host); + cl_setenv("HTTPS_PROXY", _remote_proxy_host); + cl_setenv("NO_PROXY", NULL); + + g_options.fetch_opts.proxy_opts.type = GIT_PROXY_AUTO; + g_options.fetch_opts.proxy_opts.credentials = proxy_cred_cb; + + called_proxy_creds = 0; + cl_git_pass(git_clone(&g_repo, "https://github.com/libgit2/TestGitRepository", "./foo", &g_options)); + cl_assert(called_proxy_creds == 1); +} + +static int repository_create_with_proxy( + git_repository **out, + const char *path, + int bare, + void *payload) +{ + git_repository *repo; + git_config *config; + char *value = (char *)payload; + + cl_git_pass(git_repository_init(&repo, path, bare)); + cl_git_pass(git_repository_config(&config, repo)); + + cl_git_pass(git_config_set_string(config, "http.proxy", value)); + + git_config_free(config); + + *out = repo; + return 0; +} + +void test_online_clone__proxy_http_host_port_in_config(void) +{ + if (!_remote_proxy_host || !_remote_proxy_user || !_remote_proxy_pass) + cl_skip(); + + g_options.fetch_opts.proxy_opts.type = GIT_PROXY_AUTO; + g_options.fetch_opts.proxy_opts.credentials = proxy_cred_cb; + g_options.repository_cb = repository_create_with_proxy; + g_options.repository_cb_payload = _remote_proxy_host; + + called_proxy_creds = 0; + cl_git_pass(git_clone(&g_repo, "https://github.com/libgit2/TestGitRepository", "./foo", &g_options)); + cl_assert(called_proxy_creds == 1); +} + void test_online_clone__proxy_invalid_url(void) { g_options.fetch_opts.proxy_opts.type = GIT_PROXY_SPECIFIED; @@ -1003,7 +1075,7 @@ void test_online_clone__proxy_credentials_request(void) git_str_dispose(&url); } -void test_online_clone__proxy_credentials_in_url(void) +void test_online_clone__proxy_credentials_in_well_formed_url(void) { git_str url = GIT_STR_INIT; @@ -1024,17 +1096,35 @@ void test_online_clone__proxy_credentials_in_url(void) git_str_dispose(&url); } -void test_online_clone__proxy_credentials_in_environment(void) +void test_online_clone__proxy_credentials_in_host_port_format(void) { git_str url = GIT_STR_INIT; if (!_remote_proxy_host || !_remote_proxy_user || !_remote_proxy_pass) cl_skip(); - _orig_http_proxy = cl_getenv("HTTP_PROXY"); - _orig_https_proxy = cl_getenv("HTTPS_PROXY"); - _orig_no_proxy = cl_getenv("NO_PROXY"); - _orig_proxies_need_reset = 1; + if (_remote_proxy_scheme && strcmp(_remote_proxy_scheme, "http") != 0) + cl_skip(); + + cl_git_pass(git_str_printf(&url, "%s:%s@%s", + _remote_proxy_user, _remote_proxy_pass, _remote_proxy_host)); + + g_options.fetch_opts.proxy_opts.type = GIT_PROXY_SPECIFIED; + g_options.fetch_opts.proxy_opts.url = url.ptr; + g_options.fetch_opts.proxy_opts.certificate_check = proxy_cert_cb; + called_proxy_creds = 0; + cl_git_pass(git_clone(&g_repo, "http://github.com/libgit2/TestGitRepository", "./foo", &g_options)); + cl_assert(called_proxy_creds == 0); + + git_str_dispose(&url); +} + +void test_online_clone__proxy_credentials_in_environment(void) +{ + git_str url = GIT_STR_INIT; + + if (!_remote_proxy_host || !_remote_proxy_user || !_remote_proxy_pass) + cl_skip(); g_options.fetch_opts.proxy_opts.type = GIT_PROXY_AUTO; g_options.fetch_opts.proxy_opts.certificate_check = proxy_cert_cb; From 38b60fd062c245b2efbb5079f1a2c868c915207d Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Wed, 2 Aug 2023 11:02:44 +0100 Subject: [PATCH 334/608] winhttp: use new http-style url parser for proxies --- src/libgit2/transports/winhttp.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/libgit2/transports/winhttp.c b/src/libgit2/transports/winhttp.c index b7ffb9512ae..ae572c56d8e 100644 --- a/src/libgit2/transports/winhttp.c +++ b/src/libgit2/transports/winhttp.c @@ -443,7 +443,7 @@ static int winhttp_stream_connect(winhttp_stream *s) git_net_url_dispose(&t->proxy.url); - if ((error = git_net_url_parse(&t->proxy.url, proxy_url)) < 0) + if ((error = git_net_url_parse_http(&t->proxy.url, proxy_url)) < 0) goto on_error; if (!git_net_url_valid(&t->proxy.url)) { From 52db5d11c5f22e6109e0b7cb9ffba1e79f34382b Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 10 Aug 2023 09:52:04 +0100 Subject: [PATCH 335/608] Revert "CMake: Search for ssh2 instead of libssh2." --- cmake/SelectSSH.cmake | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cmake/SelectSSH.cmake b/cmake/SelectSSH.cmake index 968a63114f3..23dfc978521 100644 --- a/cmake/SelectSSH.cmake +++ b/cmake/SelectSSH.cmake @@ -1,6 +1,6 @@ # Optional external dependency: libssh2 if(USE_SSH) - find_pkglibraries(LIBSSH2 ssh2) + find_pkglibraries(LIBSSH2 libssh2) if(NOT LIBSSH2_FOUND) find_package(LibSSH2) set(LIBSSH2_INCLUDE_DIRS ${LIBSSH2_INCLUDE_DIR}) From 7f098da4597a95c5754637388bb57da67f794a4e Mon Sep 17 00:00:00 2001 From: Laurence McGlashan Date: Mon, 14 Aug 2023 16:11:32 +0100 Subject: [PATCH 336/608] README.md: Fix link to conan packages --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 711e848e0a5..3ed33df55f2 100644 --- a/README.md +++ b/README.md @@ -68,7 +68,7 @@ But if you _do_ want to use libgit2 directly - because you're building an application in C - then you may be able use an existing binary. There are packages for the [vcpkg](https://github.com/Microsoft/vcpkg) and -[conan](https://conan.io/center/libgit2) +[conan](https://conan.io/center/recipes/libgit2) package managers. And libgit2 is available in [Homebrew](https://formulae.brew.sh/formula/libgit2) and most Linux distributions. From 86872834c5fc40b78e4881255fad5b11bc866fd4 Mon Sep 17 00:00:00 2001 From: Christoph Reiter Date: Sat, 19 Aug 2023 10:44:25 +0200 Subject: [PATCH 337/608] cmake: fix openssl build on win32 since f15c8ac71a916b libgit unconditionally depends on secur32 on Windows but only added it in cmake for the winhttp and schannel variants. In case libgit is built against openssl it would fail to link. This moves secur32 out of the https backend selection code into the global win32 condition (and while at it also adds ws2_32 to the .pc file) --- cmake/SelectHTTPSBackend.cmake | 8 ++++---- src/CMakeLists.txt | 3 ++- 2 files changed, 6 insertions(+), 5 deletions(-) diff --git a/cmake/SelectHTTPSBackend.cmake b/cmake/SelectHTTPSBackend.cmake index d14941643dc..0b3d63a790c 100644 --- a/cmake/SelectHTTPSBackend.cmake +++ b/cmake/SelectHTTPSBackend.cmake @@ -109,8 +109,8 @@ if(USE_HTTPS) elseif(USE_HTTPS STREQUAL "Schannel") set(GIT_SCHANNEL 1) - list(APPEND LIBGIT2_SYSTEM_LIBS "rpcrt4" "crypt32" "ole32" "secur32") - list(APPEND LIBGIT2_PC_LIBS "-lrpcrt4" "-lcrypt32" "-lole32" "-lsecur32") + list(APPEND LIBGIT2_SYSTEM_LIBS "rpcrt4" "crypt32" "ole32") + list(APPEND LIBGIT2_PC_LIBS "-lrpcrt4" "-lcrypt32" "-lole32") elseif(USE_HTTPS STREQUAL "WinHTTP") set(GIT_WINHTTP 1) @@ -125,8 +125,8 @@ if(USE_HTTPS) list(APPEND LIBGIT2_PC_LIBS "-lwinhttp") endif() - list(APPEND LIBGIT2_SYSTEM_LIBS "rpcrt4" "crypt32" "ole32" "secur32") - list(APPEND LIBGIT2_PC_LIBS "-lrpcrt4" "-lcrypt32" "-lole32" "-lsecur32") + list(APPEND LIBGIT2_SYSTEM_LIBS "rpcrt4" "crypt32" "ole32") + list(APPEND LIBGIT2_PC_LIBS "-lrpcrt4" "-lcrypt32" "-lole32") elseif(USE_HTTPS STREQUAL "OpenSSL-Dynamic") set(GIT_OPENSSL 1) set(GIT_OPENSSL_DYNAMIC 1) diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 8525acdd803..b412452c916 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -135,7 +135,8 @@ endif() # platform libraries if(WIN32) - list(APPEND LIBGIT2_SYSTEM_LIBS ws2_32) + list(APPEND LIBGIT2_SYSTEM_LIBS "ws2_32" "secur32") + list(APPEND LIBGIT2_PC_LIBS "-lws2_32" "-lsecur32") endif() if(CMAKE_SYSTEM_NAME MATCHES "(Solaris|SunOS)") From 2a99bc7b07544c289cb47028bbec24167bf1a17e Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Wed, 23 Aug 2023 11:00:25 +0100 Subject: [PATCH 338/608] ci: retry flaky online tests --- ci/test.sh | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/ci/test.sh b/ci/test.sh index ee6801a79a2..30cd162dd95 100755 --- a/ci/test.sh +++ b/ci/test.sh @@ -78,6 +78,8 @@ run_test() { echo "" echo "Re-running flaky ${1} tests..." echo "" + + sleep 2 fi RETURN_CODE=0 @@ -269,11 +271,16 @@ if [ -z "$SKIP_ONLINE_TESTS" ]; then echo "## Running networking (online) tests" echo "##############################################################################" + # the online tests can fail due to network connectivity problems; + # allow them to retry up to 5 times + export GITTEST_FLAKY_RETRY=5 + export GITTEST_REMOTE_REDIRECT_INITIAL="http://localhost:9000/initial-redirect/libgit2/TestGitRepository" export GITTEST_REMOTE_REDIRECT_SUBSEQUENT="http://localhost:9000/subsequent-redirect/libgit2/TestGitRepository" export GITTEST_REMOTE_SPEED_SLOW="http://localhost:9000/speed-9600/test.git" export GITTEST_REMOTE_SPEED_TIMESOUT="http://localhost:9000/speed-0.5/test.git" run_test online + unset GITTEST_FLAKY_RETRY unset GITTEST_REMOTE_REDIRECT_INITIAL unset GITTEST_REMOTE_REDIRECT_SUBSEQUENT unset GITTEST_REMOTE_SPEED_SLOW From 1fc9cd52923c531252dca0fc1b5da4bcff3b512f Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Wed, 23 Aug 2023 13:50:16 +0100 Subject: [PATCH 339/608] ci: retry (more) flaky online tests --- ci/test.sh | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/ci/test.sh b/ci/test.sh index 30cd162dd95..e5331362436 100755 --- a/ci/test.sh +++ b/ci/test.sh @@ -261,6 +261,10 @@ if [ -n "$RUN_INVASIVE_TESTS" ]; then unset GITTEST_INVASIVE_SPEED fi +# the various network tests can fail due to network connectivity problems; +# allow them to retry up to 5 times +export GITTEST_FLAKY_RETRY=5 + if [ -z "$SKIP_ONLINE_TESTS" ]; then # Run the online tests. The "online" test suite only includes the # default online tests that do not require additional configuration. @@ -271,16 +275,11 @@ if [ -z "$SKIP_ONLINE_TESTS" ]; then echo "## Running networking (online) tests" echo "##############################################################################" - # the online tests can fail due to network connectivity problems; - # allow them to retry up to 5 times - export GITTEST_FLAKY_RETRY=5 - export GITTEST_REMOTE_REDIRECT_INITIAL="http://localhost:9000/initial-redirect/libgit2/TestGitRepository" export GITTEST_REMOTE_REDIRECT_SUBSEQUENT="http://localhost:9000/subsequent-redirect/libgit2/TestGitRepository" export GITTEST_REMOTE_SPEED_SLOW="http://localhost:9000/speed-9600/test.git" export GITTEST_REMOTE_SPEED_TIMESOUT="http://localhost:9000/speed-0.5/test.git" run_test online - unset GITTEST_FLAKY_RETRY unset GITTEST_REMOTE_REDIRECT_INITIAL unset GITTEST_REMOTE_REDIRECT_SUBSEQUENT unset GITTEST_REMOTE_SPEED_SLOW @@ -438,6 +437,8 @@ if [ -z "$SKIP_SSH_TESTS" ]; then unset GITTEST_REMOTE_SSH_FINGERPRINT fi +unset GITTEST_FLAKY_RETRY + if [ -z "$SKIP_FUZZERS" ]; then echo "" echo "##############################################################################" From 14fa2ad70326e63729949260a4055b8ca4215477 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 25 Aug 2023 13:12:07 +0100 Subject: [PATCH 340/608] Update macOS build image to macos-12 --- .github/workflows/benchmark.yml | 2 +- .github/workflows/main.yml | 4 ++-- .github/workflows/nightly.yml | 4 ++-- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/.github/workflows/benchmark.yml b/.github/workflows/benchmark.yml index bf2167464ec..f6d3a616afa 100644 --- a/.github/workflows/benchmark.yml +++ b/.github/workflows/benchmark.yml @@ -27,7 +27,7 @@ jobs: os: ubuntu-latest setup-script: ubuntu - name: "macOS" - os: macos-11 + os: macos-12 env: CC: clang CMAKE_OPTIONS: -DREGEX_BACKEND=regcomp_l -DDEPRECATE_HARD=ON -DUSE_GSSAPI=ON -DBUILD_TESTS=OFF -DBUILD_EXAMPLES=OFF -DBUILD_CLI=ON -DCMAKE_BUILD_TYPE=Release diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index d84ded05ffd..84d476f78dc 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -63,7 +63,7 @@ jobs: os: ubuntu-latest - name: "macOS" id: macos - os: macos-11 + os: macos-12 env: CC: clang CMAKE_OPTIONS: -DREGEX_BACKEND=regcomp_l -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=leaks -DUSE_GSSAPI=ON @@ -177,7 +177,7 @@ jobs: os: ubuntu-latest - name: "macOS (SHA256)" id: macos - os: macos-11 + os: macos-12 env: CC: clang CMAKE_OPTIONS: -DREGEX_BACKEND=regcomp_l -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=leaks -DUSE_GSSAPI=ON -DEXPERIMENTAL_SHA256=ON diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml index 18328a7841d..fa7ef715fca 100644 --- a/.github/workflows/nightly.yml +++ b/.github/workflows/nightly.yml @@ -154,7 +154,7 @@ jobs: SKIP_SSH_TESTS: true os: ubuntu-latest - name: "macOS" - os: macos-11 + os: macos-12 env: CC: clang CMAKE_OPTIONS: -DREGEX_BACKEND=regcomp_l -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=leaks -DUSE_GSSAPI=ON @@ -294,7 +294,7 @@ jobs: os: ubuntu-latest - name: "macOS (SHA256)" id: macos - os: macos-10.15 + os: macos-12 env: CC: clang CMAKE_OPTIONS: -DREGEX_BACKEND=regcomp_l -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=leaks -DUSE_GSSAPI=ON -DEXPERIMENTAL_SHA256=ON From 0181b4cb82016d4f29d130205382cd35f13fedad Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 22 Apr 2023 14:04:09 +0100 Subject: [PATCH 341/608] Introduce `git_strlist` to manage string lists --- src/util/strlist.c | 66 ++++++++++++++++++++++++++++++++++++++++++++++ src/util/strlist.h | 20 ++++++++++++++ 2 files changed, 86 insertions(+) diff --git a/src/util/strlist.c b/src/util/strlist.c index af9b4bbd34d..df5640c2a1f 100644 --- a/src/util/strlist.c +++ b/src/util/strlist.c @@ -28,6 +28,59 @@ int git_strlist_copy(char ***out, const char **in, size_t len) return 0; } +int git_strlist_copy_with_null(char ***out, const char **in, size_t len) +{ + char **dup; + size_t new_len, i; + + GIT_ERROR_CHECK_ALLOC_ADD(&new_len, len, 1); + + dup = git__calloc(new_len, sizeof(char *)); + GIT_ERROR_CHECK_ALLOC(dup); + + for (i = 0; i < len; i++) { + dup[i] = git__strdup(in[i]); + GIT_ERROR_CHECK_ALLOC(dup[i]); + } + + *out = dup; + return 0; +} + +bool git_strlist_contains_prefix( + const char **strings, + size_t len, + const char *str, + size_t n) +{ + size_t i; + + for (i = 0; i < len; i++) { + if (strncmp(strings[i], str, n) == 0) + return true; + } + + return false; +} + +bool git_strlist_contains_key( + const char **strings, + size_t len, + const char *key, + char delimiter) +{ + const char *c; + + for (c = key; *c; c++) { + if (*c == delimiter) + break; + } + + return *c ? + git_strlist_contains_prefix(strings, len, key, (c - key)) : + false; +} + void git_strlist_free(char **strings, size_t len) { size_t i; @@ -40,3 +93,16 @@ void git_strlist_free(char **strings, size_t len) git__free(strings); } + +void git_strlist_free_with_null(char **strings) +{ + char **s; + + if (!strings) + return; + + for (s = strings; *s; s++) + git__free(*s); + + git__free(strings); +} diff --git a/src/util/strlist.h b/src/util/strlist.h index 089a8bb57b3..68fbf8fb263 100644 --- a/src/util/strlist.h +++ b/src/util/strlist.h @@ -11,6 +11,26 @@ #include "git2_util.h" extern int git_strlist_copy(char ***out, const char **in, size_t len); + +extern int git_strlist_copy_with_null( + char ***out, + const char **in, + size_t len); + +extern bool git_strlist_contains_prefix( + const char **strings, + size_t len, + const char *str, + size_t n); + +extern bool git_strlist_contains_key( + const char **strings, + size_t len, + const char *key, + char delimiter); + extern void git_strlist_free(char **strings, size_t len); +extern void git_strlist_free_with_null(char **strings); + #endif From bc97d01c039f004a05a5457bace11f3c3e26beb5 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Wed, 15 Feb 2023 21:25:19 +0000 Subject: [PATCH 342/608] Introduce git_process class that invokes processes --- src/util/process.h | 156 ++++++++ src/util/unix/process.c | 499 ++++++++++++++++++++++++++ src/util/win32/process.c | 460 ++++++++++++++++++++++++ tests/resources/process/cat.bat | 2 + tests/resources/process/env.cmd | 2 + tests/resources/process/helloworld.sh | 3 + tests/resources/process/pwd.bat | 2 + tests/util/process/env.c | 111 ++++++ tests/util/process/start.c | 212 +++++++++++ tests/util/process/win32.c | 61 ++++ 10 files changed, 1508 insertions(+) create mode 100644 src/util/process.h create mode 100644 src/util/unix/process.c create mode 100644 src/util/win32/process.c create mode 100644 tests/resources/process/cat.bat create mode 100644 tests/resources/process/env.cmd create mode 100755 tests/resources/process/helloworld.sh create mode 100644 tests/resources/process/pwd.bat create mode 100644 tests/util/process/env.c create mode 100644 tests/util/process/start.c create mode 100644 tests/util/process/win32.c diff --git a/src/util/process.h b/src/util/process.h new file mode 100644 index 00000000000..55b2a104934 --- /dev/null +++ b/src/util/process.h @@ -0,0 +1,156 @@ +/* + * Copyright (C) the libgit2 contributors. All rights reserved. + * + * This file is part of libgit2, distributed under the GNU GPL v2 with + * a Linking Exception. For full terms see the included COPYING file. + */ + +#ifndef INCLUDE_process_h__ +#define INCLUDE_process_h__ + +typedef struct git_process git_process; + +typedef struct { + int capture_in : 1, + capture_out : 1, + capture_err : 1, + exclude_env : 1; + + char *cwd; +} git_process_options; + +typedef enum { + GIT_PROCESS_STATUS_NONE, + GIT_PROCESS_STATUS_NORMAL, + GIT_PROCESS_STATUS_ERROR +} git_process_result_status; + +#define GIT_PROCESS_RESULT_INIT { GIT_PROCESS_STATUS_NONE } + +typedef struct { + git_process_result_status status; + int exitcode; + int signal; +} git_process_result; + +#define GIT_PROCESS_OPTIONS_INIT { 0 } + +/** + * Create a new process. The command to run should be specified as the + * element of the `arg` array. + * + * This function will add the given environment variables (in `env`) + * to the current environment. Operations on environment variables + * are not thread safe, so you may not modify the environment during + * this call. You can avoid this by setting `exclude_env` in the + * options and providing the entire environment yourself. + * + * @param out location to store the process + * @param args the command (with arguments) to run + * @param args_len the length of the args array + * @param env environment variables to add (or NULL) + * @param env_len the length of the env len + * @param opts the options for creating the process + * @return 0 or an error code + */ +extern int git_process_new( + git_process **out, + const char **args, + size_t args_len, + const char **env, + size_t env_len, + git_process_options *opts); + +#ifdef GIT_WIN32 + +/* Windows path parsing is tricky; this helper function is for testing. */ +extern int git_process__cmdline( + git_str *out, + const char **in, + size_t in_len); + +#endif + +/** + * Start the process. + * + * @param process the process to start + * @return 0 or an error code + */ +extern int git_process_start(git_process *process); + +/** + * Read from the process's stdout. The process must have been created with + * `capture_out` set to true. + * + * @param process the process to read from + * @param buf the buf to read into + * @param count maximum number of bytes to read + * @return number of bytes read or an error code + */ +extern ssize_t git_process_read(git_process *process, void *buf, size_t count); + +/** + * Write to the process's stdin. The process must have been created with + * `capture_in` set to true. + * + * @param process the process to write to + * @param buf the buf to write + * @param count maximum number of bytes to write + * @return number of bytes written or an error code + */ +extern ssize_t git_process_write(git_process *process, const void *buf, size_t count); + +/** + * Wait for the process to finish. + * + * @param result the result of the process or NULL + * @param process the process to wait on + */ +extern int git_process_wait(git_process_result *result, git_process *process); + +/** + * Close the input pipe from the child. + * + * @param process the process to close the pipe on + */ +extern int git_process_close_in(git_process *process); + +/** + * Close the output pipe from the child. + * + * @param process the process to close the pipe on + */ +extern int git_process_close_out(git_process *process); + +/** + * Close the error pipe from the child. + * + * @param process the process to close the pipe on + */ +extern int git_process_close_err(git_process *process); + +/** + * Close all resources that are used by the process. This does not + * wait for the process to complete. + * + * @parma process the process to close + */ +extern int git_process_close(git_process *process); + +/** + * Place a human-readable error message in the given git buffer. + * + * @param msg the buffer to store the message + * @param result the process result that produced an error + */ +extern int git_process_result_msg(git_str *msg, git_process_result *result); + +/** + * Free a process structure + * + * @param process the process to free + */ +extern void git_process_free(git_process *process); + +#endif diff --git a/src/util/unix/process.c b/src/util/unix/process.c new file mode 100644 index 00000000000..16171aec94c --- /dev/null +++ b/src/util/unix/process.c @@ -0,0 +1,499 @@ +/* + * Copyright (C) the libgit2 contributors. All rights reserved. + * + * This file is part of libgit2, distributed under the GNU GPL v2 with + * a Linking Exception. For full terms see the included COPYING file. + */ + +#include +#include +#include + +#include "git2_util.h" +#include "vector.h" +#include "process.h" +#include "strlist.h" + +extern char **environ; + +struct git_process { + char **args; + char **env; + + char *cwd; + + unsigned int capture_in : 1, + capture_out : 1, + capture_err : 1; + + pid_t pid; + + int child_in; + int child_out; + int child_err; + git_process_result_status status; +}; + +GIT_INLINE(bool) is_delete_env(const char *env) +{ + char *c = index(env, '='); + + if (c == NULL) + return false; + + return *(c+1) == '\0'; +} + +static int merge_env( + char ***out, + const char **env, + size_t env_len, + bool exclude_env) +{ + git_vector merged = GIT_VECTOR_INIT; + char **kv, *dup; + size_t max, cnt; + int error = 0; + + for (max = env_len, kv = environ; !exclude_env && *kv; kv++) + max++; + + if ((error = git_vector_init(&merged, max, NULL)) < 0) + goto on_error; + + for (cnt = 0; env && cnt < env_len; cnt++) { + if (is_delete_env(env[cnt])) + continue; + + dup = git__strdup(env[cnt]); + GIT_ERROR_CHECK_ALLOC(dup); + + if ((error = git_vector_insert(&merged, dup)) < 0) + goto on_error; + } + + if (!exclude_env) { + for (kv = environ; *kv; kv++) { + if (env && git_strlist_contains_key(env, env_len, *kv, '=')) + continue; + + dup = git__strdup(*kv); + GIT_ERROR_CHECK_ALLOC(dup); + + if ((error = git_vector_insert(&merged, dup)) < 0) + goto on_error; + } + } + + if (merged.length == 0) { + *out = NULL; + error = 0; + goto on_error; + } + + git_vector_insert(&merged, NULL); + + *out = (char **)merged.contents; + + return 0; + +on_error: + git_vector_free_deep(&merged); + return error; +} + +int git_process_new( + git_process **out, + const char **args, + size_t args_len, + const char **env, + size_t env_len, + git_process_options *opts) +{ + git_process *process; + + GIT_ASSERT_ARG(out && args && args_len > 0); + + *out = NULL; + + process = git__calloc(sizeof(git_process), 1); + GIT_ERROR_CHECK_ALLOC(process); + + if (git_strlist_copy_with_null(&process->args, args, args_len) < 0 || + merge_env(&process->env, env, env_len, opts->exclude_env) < 0) { + git_process_free(process); + return -1; + } + + if (opts) { + process->capture_in = opts->capture_in; + process->capture_out = opts->capture_out; + process->capture_err = opts->capture_err; + + if (opts->cwd) { + process->cwd = git__strdup(opts->cwd); + GIT_ERROR_CHECK_ALLOC(process->cwd); + } + } + + process->child_in = -1; + process->child_out = -1; + process->child_err = -1; + process->status = -1; + + *out = process; + return 0; +} + +#define CLOSE_FD(fd) \ + if (fd >= 0) { \ + close(fd); \ + fd = -1; \ + } + +static int try_read(size_t *out, int fd, void *buf, size_t len) +{ + size_t read_len = 0; + int ret = -1; + + while (ret && read_len < len) { + ret = read(fd, buf + read_len, len - read_len); + + if (ret < 0 && errno != EAGAIN && errno != EINTR) { + git_error_set(GIT_ERROR_OS, "could not read child status"); + return -1; + } + + read_len += ret; + } + + *out = read_len; + return 0; +} + + +static int read_status(int fd) +{ + size_t status_len = sizeof(int) * 3, read_len = 0; + char buffer[status_len], fn[128]; + int error, fn_error, os_error, fn_len = 0; + + if ((error = try_read(&read_len, fd, buffer, status_len)) < 0) + return error; + + /* Immediate EOF indicates the exec succeeded. */ + if (read_len == 0) + return 0; + + if (read_len < status_len) { + git_error_set(GIT_ERROR_INVALID, "child status truncated"); + return -1; + } + + memcpy(&fn_error, &buffer[0], sizeof(int)); + memcpy(&os_error, &buffer[sizeof(int)], sizeof(int)); + memcpy(&fn_len, &buffer[sizeof(int) * 2], sizeof(int)); + + if (fn_len > 0) { + fn_len = min(fn_len, (int)(ARRAY_SIZE(fn) - 1)); + + if ((error = try_read(&read_len, fd, fn, fn_len)) < 0) + return error; + + fn[fn_len] = '\0'; + } else { + fn[0] = '\0'; + } + + if (fn_error) { + errno = os_error; + git_error_set(GIT_ERROR_OS, "could not %s", fn[0] ? fn : "(unknown)"); + } + + return fn_error; +} + +static bool try_write(int fd, const void *buf, size_t len) +{ + size_t write_len; + int ret; + + for (write_len = 0; write_len < len; ) { + ret = write(fd, buf + write_len, len - write_len); + + if (ret <= 0) + break; + + write_len += ret; + } + + return (len == write_len); +} + +static void write_status(int fd, const char *fn, int error, int os_error) +{ + size_t status_len = sizeof(int) * 3, fn_len; + char buffer[status_len]; + + fn_len = strlen(fn); + + if (fn_len > INT_MAX) + fn_len = INT_MAX; + + memcpy(&buffer[0], &error, sizeof(int)); + memcpy(&buffer[sizeof(int)], &os_error, sizeof(int)); + memcpy(&buffer[sizeof(int) * 2], &fn_len, sizeof(int)); + + /* Do our best effort to write all the status. */ + if (!try_write(fd, buffer, status_len)) + return; + + if (fn_len) + try_write(fd, fn, fn_len); +} + +int git_process_start(git_process *process) +{ + int in[2] = { -1, -1 }, out[2] = { -1, -1 }, + err[2] = { -1, -1 }, status[2] = { -1, -1 }; + int fdflags, state, error; + pid_t pid; + + /* Set up the pipes to read from/write to the process */ + if ((process->capture_in && pipe(in) < 0) || + (process->capture_out && pipe(out) < 0) || + (process->capture_err && pipe(err) < 0)) { + git_error_set(GIT_ERROR_OS, "could not create pipe"); + goto on_error; + } + + /* Set up a self-pipe for status from the forked process. */ + if (pipe(status) < 0 || + (fdflags = fcntl(status[1], F_GETFD)) < 0 || + fcntl(status[1], F_SETFD, fdflags | FD_CLOEXEC) < 0) { + git_error_set(GIT_ERROR_OS, "could not create pipe"); + goto on_error; + } + + switch (pid = fork()) { + case -1: + git_error_set(GIT_ERROR_OS, "could not fork"); + goto on_error; + + /* Child: start the process. */ + case 0: + /* Close the opposing side of the pipes */ + CLOSE_FD(status[0]); + + if (process->capture_in) { + CLOSE_FD(in[1]); + dup2(in[0], STDIN_FILENO); + } + + if (process->capture_out) { + CLOSE_FD(out[0]); + dup2(out[1], STDOUT_FILENO); + } + + if (process->capture_err) { + CLOSE_FD(err[0]); + dup2(err[1], STDERR_FILENO); + } + + if (process->cwd && (error = chdir(process->cwd)) < 0) { + write_status(status[1], "chdir", error, errno); + exit(0); + } + + /* + * Exec the process and write the results back if the + * call fails. If it succeeds, we'll close the status + * pipe (via CLOEXEC) and the parent will know. + */ + error = execve(process->args[0], + process->args, + process->env); + + write_status(status[1], "execve", error, errno); + exit(0); + + /* Parent: make sure the child process exec'd correctly. */ + default: + /* Close the opposing side of the pipes */ + CLOSE_FD(status[1]); + + if (process->capture_in) { + CLOSE_FD(in[0]); + process->child_in = in[1]; + } + + if (process->capture_out) { + CLOSE_FD(out[1]); + process->child_out = out[0]; + } + + if (process->capture_err) { + CLOSE_FD(err[1]); + process->child_err = err[0]; + } + + /* Try to read the status */ + process->status = status[0]; + if ((error = read_status(status[0])) < 0) { + waitpid(process->pid, &state, 0); + goto on_error; + } + + process->pid = pid; + return 0; + } + +on_error: + CLOSE_FD(in[0]); CLOSE_FD(in[1]); + CLOSE_FD(out[0]); CLOSE_FD(out[1]); + CLOSE_FD(err[0]); CLOSE_FD(err[1]); + CLOSE_FD(status[0]); CLOSE_FD(status[1]); + return -1; +} + +ssize_t git_process_read(git_process *process, void *buf, size_t count) +{ + ssize_t ret; + + GIT_ASSERT_ARG(process); + GIT_ASSERT(process->capture_out); + + if (count > SSIZE_MAX) + count = SSIZE_MAX; + + if ((ret = read(process->child_out, buf, count)) < 0) { + git_error_set(GIT_ERROR_OS, "could not read from child process"); + return -1; + } + + return ret; +} + +ssize_t git_process_write(git_process *process, const void *buf, size_t count) +{ + ssize_t ret; + + GIT_ASSERT_ARG(process); + GIT_ASSERT(process->capture_in); + + if (count > SSIZE_MAX) + count = SSIZE_MAX; + + if ((ret = write(process->child_in, buf, count)) < 0) { + git_error_set(GIT_ERROR_OS, "could not write to child process"); + return -1; + } + + return ret; +} + +int git_process_close_in(git_process *process) +{ + if (!process->capture_in) { + git_error_set(GIT_ERROR_INVALID, "input is not open"); + return -1; + } + + CLOSE_FD(process->child_in); + return 0; +} + +int git_process_close_out(git_process *process) +{ + if (!process->capture_out) { + git_error_set(GIT_ERROR_INVALID, "output is not open"); + return -1; + } + + CLOSE_FD(process->child_out); + return 0; +} + +int git_process_close_err(git_process *process) +{ + if (!process->capture_err) { + git_error_set(GIT_ERROR_INVALID, "error is not open"); + return -1; + } + + CLOSE_FD(process->child_err); + return 0; +} + +int git_process_close(git_process *process) +{ + CLOSE_FD(process->child_in); + CLOSE_FD(process->child_out); + CLOSE_FD(process->child_err); + CLOSE_FD(process->status); + + return 0; +} + +int git_process_wait(git_process_result *result, git_process *process) +{ + int state; + + if (result) + memset(result, 0, sizeof(git_process_result)); + + if (!process->pid) { + git_error_set(GIT_ERROR_INVALID, "process is stopped"); + return -1; + } + + if (waitpid(process->pid, &state, 0) < 0) { + git_error_set(GIT_ERROR_OS, "could not wait for child"); + return -1; + } + + process->pid = 0; + + if (result) { + if (WIFEXITED(state)) { + result->status = GIT_PROCESS_STATUS_NORMAL; + result->exitcode = WEXITSTATUS(state); + } else if (WIFSIGNALED(state)) { + result->status = GIT_PROCESS_STATUS_ERROR; + result->signal = WTERMSIG(state); + } else { + result->status = GIT_PROCESS_STATUS_ERROR; + } + } + + return 0; +} + +int git_process_result_msg(git_str *out, git_process_result *result) +{ + if (result->status == GIT_PROCESS_STATUS_NONE) { + return git_str_puts(out, "process not started"); + } else if (result->status == GIT_PROCESS_STATUS_NORMAL) { + return git_str_printf(out, "process exited with code %d", + result->exitcode); + } else if (result->signal) { + return git_str_printf(out, "process exited on signal %d", + result->signal); + } + + return git_str_puts(out, "unknown error"); +} + +void git_process_free(git_process *process) +{ + if (!process) + return; + + if (process->pid) + git_process_close(process); + + git__free(process->cwd); + git_strlist_free_with_null(process->args); + git_strlist_free_with_null(process->env); + git__free(process); +} diff --git a/src/util/win32/process.c b/src/util/win32/process.c new file mode 100644 index 00000000000..6b8dd084015 --- /dev/null +++ b/src/util/win32/process.c @@ -0,0 +1,460 @@ +/* + * Copyright (C) the libgit2 contributors. All rights reserved. + * + * This file is part of libgit2, distributed under the GNU GPL v2 with + * a Linking Exception. For full terms see the included COPYING file. + */ + +#include +#include + +#include "git2_util.h" +#include "process.h" +#include "strlist.h" + +#ifndef DWORD_MAX +# define DWORD_MAX INT32_MAX +#endif + +#define ENV_MAX 32767 + +struct git_process { + wchar_t *appname; + wchar_t *cmdline; + wchar_t *env; + + wchar_t *cwd; + + unsigned int capture_in : 1, + capture_out : 1, + capture_err : 1; + + PROCESS_INFORMATION process_info; + + HANDLE child_in; + HANDLE child_out; + HANDLE child_err; + + git_process_result_status status; +}; + +/* + * Windows processes have a single command-line that is split by the + * invoked application into arguments (instead of an array of + * command-line arguments). This command-line is split by space or + * tab delimiters, unless that whitespace is within a double quote. + * Literal double-quotes themselves can be escaped by a backslash, + * but only when not within double quotes. Literal backslashes can + * be escaped by a backslash. + * + * Effectively, this means that instead of thinking about quoting + * individual strings, think about double quotes as an escaping + * mechanism for whitespace. + * + * In other words (using ` as a string boundary): + * [ `foo`, `bar` ] => `foo bar` + * [ `foo bar` ] => `foo" "bar` + * [ `foo bar`, `foo bar` ] => `foo" "bar foo" "bar` + * [ `foo "bar" foo` ] => `foo" "\"bar\"" "foo` + */ +int git_process__cmdline( + git_str *out, + const char **in, + size_t in_len) +{ + bool quoted = false; + const char *c; + size_t i; + + for (i = 0; i < in_len; i++) { + /* Arguments are delimited by an unquoted space */ + if (i) + git_str_putc(out, ' '); + + for (c = in[i]; *c; c++) { + /* Start or stop quoting spaces within an argument */ + if ((*c == ' ' || *c == '\t') && !quoted) { + git_str_putc(out, '"'); + quoted = true; + } else if (*c != ' ' && *c != '\t' && quoted) { + git_str_putc(out, '"'); + quoted = false; + } + + /* Escape double-quotes and backslashes */ + if (*c == '"' || *c == '\\') + git_str_putc(out, '\\'); + + git_str_putc(out, *c); + } + } + + return git_str_oom(out) ? -1 : 0; +} + +GIT_INLINE(bool) is_delete_env(const char *env) +{ + char *c = strchr(env, '='); + + if (c == NULL) + return false; + + return *(c+1) == '\0'; +} + +static int merge_env(wchar_t **out, const char **in, size_t in_len, bool exclude_env) +{ + git_str merged = GIT_STR_INIT; + wchar_t *in16 = NULL, *env = NULL, *e; + char *e8 = NULL; + size_t e_len; + int ret = 0; + size_t i; + + *out = NULL; + + in16 = git__malloc(ENV_MAX * sizeof(wchar_t)); + GIT_ERROR_CHECK_ALLOC(in16); + + e8 = git__malloc(ENV_MAX); + GIT_ERROR_CHECK_ALLOC(e8); + + for (i = 0; in && i < in_len; i++) { + if (is_delete_env(in[i])) + continue; + + if ((ret = git_utf8_to_16(in16, ENV_MAX, in[i])) < 0) + goto done; + + git_str_put(&merged, (const char *)in16, ret * 2); + git_str_put(&merged, "\0\0", 2); + } + + if (!exclude_env) { + env = GetEnvironmentStringsW(); + + for (e = env; *e; e += (e_len + 1)) { + e_len = wcslen(e); + + if ((ret = git_utf8_from_16(e8, ENV_MAX, e)) < 0) + goto done; + + if (git_strlist_contains_key(in, in_len, e8, '=')) + continue; + + git_str_put(&merged, (const char *)e, e_len * 2); + git_str_put(&merged, "\0\0", 2); + } + } + + git_str_put(&merged, "\0\0", 2); + + *out = (wchar_t *)git_str_detach(&merged); + +done: + if (env) + FreeEnvironmentStringsW(env); + + git_str_dispose(&merged); + git__free(e8); + git__free(in16); + + return ret < 0 ? -1 : 0; +} + +int git_process_new( + git_process **out, + const char **args, + size_t args_len, + const char **env, + size_t env_len, + git_process_options *opts) +{ + git_process *process; + git_str cmdline = GIT_STR_INIT; + int error; + + GIT_ASSERT_ARG(out && args && args_len > 0); + + *out = NULL; + + process = git__calloc(1, sizeof(git_process)); + GIT_ERROR_CHECK_ALLOC(process); + + if ((error = git_process__cmdline(&cmdline, args, args_len)) < 0) + goto done; + + if (git_utf8_to_16_alloc(&process->appname, args[0]) < 0 || + git_utf8_to_16_alloc(&process->cmdline, cmdline.ptr) < 0) { + error = -1; + goto done; + } + + if (opts && opts->cwd && + git_utf8_to_16_alloc(&process->cwd, opts->cwd) < 0) { + error = -1; + goto done; + } + + if (env && (error = merge_env(&process->env, env, env_len, opts && opts->exclude_env) < 0)) + goto done; + + if (opts) { + process->capture_in = opts->capture_in; + process->capture_out = opts->capture_out; + process->capture_err = opts->capture_err; + } + +done: + if (error) + git_process_free(process); + else + *out = process; + + git_str_dispose(&cmdline); + return error; +} + +#define CLOSE_HANDLE(h) do { if ((h) != NULL) CloseHandle(h); } while(0) + +int git_process_start(git_process *process) +{ + STARTUPINFOW startup_info; + SECURITY_ATTRIBUTES security_attrs; + DWORD flags = CREATE_UNICODE_ENVIRONMENT; + HANDLE in[2] = { NULL, NULL }, + out[2] = { NULL, NULL }, + err[2] = { NULL, NULL }; + + memset(&security_attrs, 0, sizeof(SECURITY_ATTRIBUTES)); + security_attrs.bInheritHandle = TRUE; + + memset(&startup_info, 0, sizeof(STARTUPINFOW)); + startup_info.cb = sizeof(STARTUPINFOW); + startup_info.hStdInput = GetStdHandle(STD_INPUT_HANDLE); + startup_info.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE); + startup_info.hStdError = GetStdHandle(STD_ERROR_HANDLE); + + if (process->capture_in) { + if (!CreatePipe(&in[0], &in[1], &security_attrs, 0) || + !SetHandleInformation(in[1], HANDLE_FLAG_INHERIT, 0)) { + git_error_set(GIT_ERROR_OS, "could not create pipe"); + goto on_error; + } + + startup_info.hStdInput = in[0]; + startup_info.dwFlags |= STARTF_USESTDHANDLES; + } + + if (process->capture_out) { + if (!CreatePipe(&out[0], &out[1], &security_attrs, 0) || + !SetHandleInformation(out[0], HANDLE_FLAG_INHERIT, 0)) { + git_error_set(GIT_ERROR_OS, "could not create pipe"); + goto on_error; + } + + startup_info.hStdOutput = out[1]; + startup_info.dwFlags |= STARTF_USESTDHANDLES; + } + + if (process->capture_err) { + if (!CreatePipe(&err[0], &err[1], &security_attrs, 0) || + !SetHandleInformation(err[0], HANDLE_FLAG_INHERIT, 0)) { + git_error_set(GIT_ERROR_OS, "could not create pipe"); + goto on_error; + } + + startup_info.hStdError = err[1]; + startup_info.dwFlags |= STARTF_USESTDHANDLES; + } + + memset(&process->process_info, 0, sizeof(PROCESS_INFORMATION)); + + if (!CreateProcessW(process->appname, process->cmdline, + NULL, NULL, TRUE, flags, process->env, + process->cwd, + &startup_info, + &process->process_info)) { + git_error_set(GIT_ERROR_OS, "could not create process"); + goto on_error; + } + + CLOSE_HANDLE(in[0]); process->child_in = in[1]; + CLOSE_HANDLE(out[1]); process->child_out = out[0]; + CLOSE_HANDLE(err[1]); process->child_err = err[0]; + + return 0; + +on_error: + CLOSE_HANDLE(in[0]); CLOSE_HANDLE(in[1]); + CLOSE_HANDLE(out[0]); CLOSE_HANDLE(out[1]); + CLOSE_HANDLE(err[0]); CLOSE_HANDLE(err[1]); + return -1; +} + +ssize_t git_process_read(git_process *process, void *buf, size_t count) +{ + DWORD ret; + + if (count > DWORD_MAX) + count = DWORD_MAX; + if (count > SSIZE_MAX) + count = SSIZE_MAX; + + if (!ReadFile(process->child_out, buf, (DWORD)count, &ret, NULL)) { + if (GetLastError() == ERROR_BROKEN_PIPE) + return 0; + + git_error_set(GIT_ERROR_OS, "could not read"); + return -1; + } + + return ret; +} + +ssize_t git_process_write(git_process *process, const void *buf, size_t count) +{ + DWORD ret; + + if (count > DWORD_MAX) + count = DWORD_MAX; + if (count > SSIZE_MAX) + count = SSIZE_MAX; + + if (!WriteFile(process->child_in, buf, (DWORD)count, &ret, NULL)) { + git_error_set(GIT_ERROR_OS, "could not write"); + return -1; + } + + return ret; +} + +int git_process_close_in(git_process *process) +{ + if (!process->capture_in) { + git_error_set(GIT_ERROR_INVALID, "input is not open"); + return -1; + } + + if (process->child_in) { + CloseHandle(process->child_in); + process->child_in = NULL; + } + + return 0; +} + +int git_process_close_out(git_process *process) +{ + if (!process->capture_out) { + git_error_set(GIT_ERROR_INVALID, "output is not open"); + return -1; + } + + if (process->child_out) { + CloseHandle(process->child_out); + process->child_out = NULL; + } + + return 0; +} + +int git_process_close_err(git_process *process) +{ + if (!process->capture_err) { + git_error_set(GIT_ERROR_INVALID, "error is not open"); + return -1; + } + + if (process->child_err) { + CloseHandle(process->child_err); + process->child_err = NULL; + } + + return 0; +} + +int git_process_close(git_process *process) +{ + if (process->child_in) { + CloseHandle(process->child_in); + process->child_in = NULL; + } + + if (process->child_out) { + CloseHandle(process->child_out); + process->child_out = NULL; + } + + if (process->child_err) { + CloseHandle(process->child_err); + process->child_err = NULL; + } + + CloseHandle(process->process_info.hProcess); + process->process_info.hProcess = NULL; + + CloseHandle(process->process_info.hThread); + process->process_info.hThread = NULL; + + return 0; +} + +int git_process_wait(git_process_result *result, git_process *process) +{ + DWORD exitcode; + + if (result) + memset(result, 0, sizeof(git_process_result)); + + if (!process->process_info.dwProcessId) { + git_error_set(GIT_ERROR_INVALID, "process is stopped"); + return -1; + } + + if (WaitForSingleObject(process->process_info.hProcess, INFINITE) == WAIT_FAILED) { + git_error_set(GIT_ERROR_OS, "could not wait for process"); + return -1; + } + + if (!GetExitCodeProcess(process->process_info.hProcess, &exitcode)) { + git_error_set(GIT_ERROR_OS, "could not get process exit code"); + return -1; + } + + result->status = GIT_PROCESS_STATUS_NORMAL; + result->exitcode = exitcode; + + memset(&process->process_info, 0, sizeof(PROCESS_INFORMATION)); + return 0; +} + +int git_process_result_msg(git_str *out, git_process_result *result) +{ + if (result->status == GIT_PROCESS_STATUS_NONE) { + return git_str_puts(out, "process not started"); + } else if (result->status == GIT_PROCESS_STATUS_NORMAL) { + return git_str_printf(out, "process exited with code %d", + result->exitcode); + } else if (result->signal) { + return git_str_printf(out, "process exited on signal %d", + result->signal); + } + + return git_str_puts(out, "unknown error"); +} + +void git_process_free(git_process *process) +{ + if (!process) + return; + + if (process->process_info.hProcess) + git_process_close(process); + + git__free(process->env); + git__free(process->cwd); + git__free(process->cmdline); + git__free(process->appname); + git__free(process); +} diff --git a/tests/resources/process/cat.bat b/tests/resources/process/cat.bat new file mode 100644 index 00000000000..af9b573c793 --- /dev/null +++ b/tests/resources/process/cat.bat @@ -0,0 +1,2 @@ +@ECHO OFF +FOR /F "tokens=*" %%a IN ('more') DO ECHO %%a diff --git a/tests/resources/process/env.cmd b/tests/resources/process/env.cmd new file mode 100644 index 00000000000..62675cf9edd --- /dev/null +++ b/tests/resources/process/env.cmd @@ -0,0 +1,2 @@ +@ECHO OFF +SET diff --git a/tests/resources/process/helloworld.sh b/tests/resources/process/helloworld.sh new file mode 100755 index 00000000000..0c4aefc384d --- /dev/null +++ b/tests/resources/process/helloworld.sh @@ -0,0 +1,3 @@ +#!/bin/sh + +echo "Hello, world." diff --git a/tests/resources/process/pwd.bat b/tests/resources/process/pwd.bat new file mode 100644 index 00000000000..82e4fb60f17 --- /dev/null +++ b/tests/resources/process/pwd.bat @@ -0,0 +1,2 @@ +@ECHO OFF +ECHO %CD% diff --git a/tests/util/process/env.c b/tests/util/process/env.c new file mode 100644 index 00000000000..bb7dbcdcdfd --- /dev/null +++ b/tests/util/process/env.c @@ -0,0 +1,111 @@ +#include "clar_libgit2.h" +#include "process.h" +#include "vector.h" + +static git_str env_cmd = GIT_STR_INIT; +static git_str accumulator = GIT_STR_INIT; +static git_vector env_result = GIT_VECTOR_INIT; + +void test_process_env__initialize(void) +{ +#ifdef GIT_WIN32 + git_str_printf(&env_cmd, "%s/env.cmd", cl_fixture("process")); +#else + git_str_puts(&env_cmd, "/usr/bin/env"); +#endif + + cl_git_pass(git_vector_init(&env_result, 32, git__strcmp_cb)); +} + +void test_process_env__cleanup(void) +{ + git_vector_free(&env_result); + git_str_dispose(&accumulator); + git_str_dispose(&env_cmd); +} + +static void run_env(const char **env_array, size_t env_len, bool exclude_env) +{ + const char *args_array[] = { env_cmd.ptr }; + + git_process *process; + git_process_options opts = GIT_PROCESS_OPTIONS_INIT; + git_process_result result = GIT_PROCESS_RESULT_INIT; + + char buf[1024], *tok; + ssize_t ret; + + opts.capture_out = 1; + opts.exclude_env = exclude_env; + + cl_git_pass(git_process_new(&process, args_array, ARRAY_SIZE(args_array), env_array, env_len, &opts)); + cl_git_pass(git_process_start(process)); + + while ((ret = git_process_read(process, buf, 1024)) > 0) + cl_git_pass(git_str_put(&accumulator, buf, (size_t)ret)); + + cl_assert_equal_i(0, ret); + + cl_git_pass(git_process_wait(&result, process)); + + cl_assert_equal_i(GIT_PROCESS_STATUS_NORMAL, result.status); + cl_assert_equal_i(0, result.exitcode); + cl_assert_equal_i(0, result.signal); + + for (tok = strtok(accumulator.ptr, "\n"); tok; tok = strtok(NULL, "\n")) { +#ifdef GIT_WIN32 + if (strlen(tok) && tok[strlen(tok) - 1] == '\r') + tok[strlen(tok) - 1] = '\0'; +#endif + + cl_git_pass(git_vector_insert(&env_result, tok)); + } + + git_process_close(process); + git_process_free(process); +} + +void test_process_env__can_add_env(void) +{ + const char *env_array[] = { "TEST_NEW_ENV=added", "TEST_OTHER_ENV=also_added" }; + run_env(env_array, 2, false); + + cl_git_pass(git_vector_search(NULL, &env_result, "TEST_NEW_ENV=added")); + cl_git_pass(git_vector_search(NULL, &env_result, "TEST_OTHER_ENV=also_added")); +} + +void test_process_env__can_propagate_env(void) +{ + cl_setenv("TEST_NEW_ENV", "propagated"); + run_env(NULL, 0, false); + + cl_git_pass(git_vector_search(NULL, &env_result, "TEST_NEW_ENV=propagated")); +} + +void test_process_env__can_remove_env(void) +{ + const char *env_array[] = { "TEST_NEW_ENV=" }; + char *str; + size_t i; + + cl_setenv("TEST_NEW_ENV", "propagated"); + run_env(env_array, 1, false); + + git_vector_foreach(&env_result, i, str) + cl_assert(git__prefixcmp(str, "TEST_NEW_ENV=") != 0); +} + +void test_process_env__can_clear_env(void) +{ + const char *env_array[] = { "TEST_NEW_ENV=added", "TEST_OTHER_ENV=also_added" }; + + cl_setenv("SOME_EXISTING_ENV", "propagated"); + run_env(env_array, 2, true); + + /* + * We can't simply test that the environment is precisely what we + * provided. Some systems (eg win32) will add environment variables + * to all processes. + */ + cl_assert_equal_i(GIT_ENOTFOUND, git_vector_search(NULL, &env_result, "SOME_EXISTING_ENV=propagated")); +} diff --git a/tests/util/process/start.c b/tests/util/process/start.c new file mode 100644 index 00000000000..0e4944b6567 --- /dev/null +++ b/tests/util/process/start.c @@ -0,0 +1,212 @@ +#include "clar_libgit2.h" +#include "process.h" +#include "vector.h" + +#ifndef SIGPIPE +# define SIGPIPE 42 +#endif + +static git_str helloworld_cmd = GIT_STR_INIT; +static git_str cat_cmd = GIT_STR_INIT; +static git_str pwd_cmd = GIT_STR_INIT; + +void test_process_start__initialize(void) +{ +#ifdef GIT_WIN32 + git_str_printf(&helloworld_cmd, "%s/helloworld.bat", cl_fixture("process")); + git_str_printf(&cat_cmd, "%s/cat.bat", cl_fixture("process")); + git_str_printf(&pwd_cmd, "%s/pwd.bat", cl_fixture("process")); +#else + git_str_printf(&helloworld_cmd, "%s/helloworld.sh", cl_fixture("process")); +#endif +} + +void test_process_start__cleanup(void) +{ + git_str_dispose(&pwd_cmd); + git_str_dispose(&cat_cmd); + git_str_dispose(&helloworld_cmd); +} + +void test_process_start__returncode(void) +{ +#ifdef GIT_WIN32 + const char *args_array[] = { "C:\\Windows\\System32\\cmd.exe", "/c", "exit", "1" }; +#elif __APPLE__ + const char *args_array[] = { "/usr/bin/false" }; +#else + const char *args_array[] = { "/bin/false" }; +#endif + + git_process *process; + git_process_options opts = GIT_PROCESS_OPTIONS_INIT; + git_process_result result = GIT_PROCESS_RESULT_INIT; + + cl_git_pass(git_process_new(&process, args_array, ARRAY_SIZE(args_array), NULL, 0, &opts)); + cl_git_pass(git_process_start(process)); + cl_git_pass(git_process_wait(&result, process)); + + cl_assert_equal_i(GIT_PROCESS_STATUS_NORMAL, result.status); + cl_assert_equal_i(1, result.exitcode); + cl_assert_equal_i(0, result.signal); + + git_process_free(process); +} + +void test_process_start__not_found(void) +{ +#ifdef GIT_WIN32 + const char *args_array[] = { "C:\\a\\b\\z\\y\\not_found" }; +#else + const char *args_array[] = { "/a/b/z/y/not_found" }; +#endif + + git_process *process; + git_process_options opts = GIT_PROCESS_OPTIONS_INIT; + + cl_git_pass(git_process_new(&process, args_array, ARRAY_SIZE(args_array), NULL, 0, &opts)); + cl_git_fail(git_process_start(process)); + git_process_free(process); +} + +static void write_all(git_process *process, char *buf) +{ + size_t buf_len = strlen(buf); + ssize_t ret; + + while (buf_len) { + ret = git_process_write(process, buf, buf_len); + cl_git_pass(ret < 0 ? (int)ret : 0); + + buf += ret; + buf_len -= ret; + } +} + +static void read_all(git_str *out, git_process *process) +{ + char buf[32]; + size_t buf_len = 32; + ssize_t ret; + + while ((ret = git_process_read(process, buf, buf_len)) > 0) + cl_git_pass(git_str_put(out, buf, ret)); + + cl_git_pass(ret < 0 ? (int)ret : 0); +} + +void test_process_start__redirect_stdio(void) +{ +#ifdef GIT_WIN32 + const char *args_array[] = { "C:\\Windows\\System32\\cmd.exe", "/c", cat_cmd.ptr }; +#else + const char *args_array[] = { "/bin/cat" }; +#endif + + git_process *process; + git_process_options opts = GIT_PROCESS_OPTIONS_INIT; + git_process_result result = GIT_PROCESS_RESULT_INIT; + git_str buf = GIT_STR_INIT; + + opts.capture_in = 1; + opts.capture_out = 1; + + cl_git_pass(git_process_new(&process, args_array, ARRAY_SIZE(args_array), NULL, 0, &opts)); + cl_git_pass(git_process_start(process)); + + write_all(process, "Hello, world.\r\nHello!\r\n"); + cl_git_pass(git_process_close_in(process)); + + read_all(&buf, process); + cl_assert_equal_s("Hello, world.\r\nHello!\r\n", buf.ptr); + + cl_git_pass(git_process_wait(&result, process)); + + cl_assert_equal_i(GIT_PROCESS_STATUS_NORMAL, result.status); + cl_assert_equal_i(0, result.exitcode); + cl_assert_equal_i(0, result.signal); + + git_str_dispose(&buf); + git_process_free(process); +} + +void test_process_start__catch_signal(void) +{ +#ifndef GIT_WIN32 + const char *args_array[] = { helloworld_cmd.ptr }; + + git_process *process; + git_process_options opts = GIT_PROCESS_OPTIONS_INIT; + git_process_result result = GIT_PROCESS_RESULT_INIT; + + opts.capture_out = 1; + + cl_git_pass(git_process_new(&process, args_array, ARRAY_SIZE(args_array), NULL, 0, &opts)); + cl_git_pass(git_process_start(process)); + cl_git_pass(git_process_close(process)); + cl_git_pass(git_process_wait(&result, process)); + + cl_assert_equal_i(GIT_PROCESS_STATUS_ERROR, result.status); + cl_assert_equal_i(0, result.exitcode); + cl_assert_equal_i(SIGPIPE, result.signal); + + git_process_free(process); +#endif +} + +void test_process_start__can_chdir(void) +{ +#ifdef GIT_WIN32 + const char *args_array[] = { "C:\\Windows\\System32\\cmd.exe", "/c", pwd_cmd.ptr }; + char *startwd = "C:\\"; +#else + const char *args_array[] = { "/bin/pwd" }; + char *startwd = "/"; +#endif + + git_process *process; + git_process_options opts = GIT_PROCESS_OPTIONS_INIT; + git_process_result result = GIT_PROCESS_RESULT_INIT; + git_str buf = GIT_STR_INIT; + + opts.cwd = startwd; + opts.capture_out = 1; + + cl_git_pass(git_process_new(&process, args_array, ARRAY_SIZE(args_array), NULL, 0, &opts)); + cl_git_pass(git_process_start(process)); + + read_all(&buf, process); + git_str_rtrim(&buf); + + cl_assert_equal_s(startwd, buf.ptr); + + cl_git_pass(git_process_wait(&result, process)); + + cl_assert_equal_i(GIT_PROCESS_STATUS_NORMAL, result.status); + cl_assert_equal_i(0, result.exitcode); + cl_assert_equal_i(0, result.signal); + + git_str_dispose(&buf); + git_process_free(process); +} + +void test_process_start__cannot_chdir_to_nonexistent_dir(void) +{ +#ifdef GIT_WIN32 + const char *args_array[] = { "C:\\Windows\\System32\\cmd.exe", "/c", pwd_cmd.ptr }; + char *startwd = "C:\\a\\b\\z\\y\\not_found"; +#else + const char *args_array[] = { "/bin/pwd" }; + char *startwd = "/a/b/z/y/not_found"; +#endif + + git_process *process; + git_process_options opts = GIT_PROCESS_OPTIONS_INIT; + + opts.cwd = startwd; + opts.capture_out = 1; + + cl_git_pass(git_process_new(&process, args_array, ARRAY_SIZE(args_array), NULL, 0, &opts)); + cl_git_fail(git_process_start(process)); + git_process_free(process); +} diff --git a/tests/util/process/win32.c b/tests/util/process/win32.c new file mode 100644 index 00000000000..914504d6263 --- /dev/null +++ b/tests/util/process/win32.c @@ -0,0 +1,61 @@ +#include "clar_libgit2.h" +#include "process.h" +#include "vector.h" + +#ifdef GIT_WIN32 +static git_str result; + +# define assert_cmdline(expected, given) do { \ + cl_git_pass(git_process__cmdline(&result, given, ARRAY_SIZE(given))); \ + cl_assert_equal_s(expected, result.ptr); \ + git_str_dispose(&result); \ + } while(0) +#endif + +void test_process_win32__cmdline_is_whitespace_delimited(void) +{ +#ifdef GIT_WIN32 + const char *one[] = { "one" }; + const char *two[] = { "one", "two" }; + const char *three[] = { "one", "two", "three" }; + const char *four[] = { "one", "two", "three", "four" }; + + assert_cmdline("one", one); + assert_cmdline("one two", two); + assert_cmdline("one two three", three); + assert_cmdline("one two three four", four); +#endif +} + +void test_process_win32__cmdline_escapes_whitespace(void) +{ +#ifdef GIT_WIN32 + const char *spaces[] = { "one with spaces" }; + const char *tabs[] = { "one\twith\ttabs" }; + const char *multiple[] = { "one with many spaces" }; + + assert_cmdline("one\" \"with\" \"spaces", spaces); + assert_cmdline("one\"\t\"with\"\t\"tabs", tabs); + assert_cmdline("one\" \"with\" \"many\" \"spaces", multiple); +#endif +} + +void test_process_win32__cmdline_escapes_quotes(void) +{ +#ifdef GIT_WIN32 + const char *one[] = { "echo", "\"hello world\"" }; + + assert_cmdline("echo \\\"hello\" \"world\\\"", one); +#endif +} + +void test_process_win32__cmdline_escapes_backslash(void) +{ +#ifdef GIT_WIN32 + const char *one[] = { "foo\\bar", "foo\\baz" }; + const char *two[] = { "c:\\program files\\foo bar\\foo bar.exe", "c:\\path\\to\\other\\", "/a", "/b" }; + + assert_cmdline("foo\\\\bar foo\\\\baz", one); + assert_cmdline("c:\\\\program\" \"files\\\\foo\" \"bar\\\\foo\" \"bar.exe c:\\\\path\\\\to\\\\other\\\\ /a /b", two); +#endif +} From 67ab8f07c987b9bb2c23471219945e44db9a91d7 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 23 Feb 2023 22:50:35 +0000 Subject: [PATCH 343/608] ssh: refactor libssh2-specific bits into their own file --- src/libgit2/libgit2.c | 4 +- src/libgit2/transports/ssh.c | 1110 +------------------------ src/libgit2/transports/ssh.h | 14 - src/libgit2/transports/ssh_libssh2.c | 1113 ++++++++++++++++++++++++++ src/libgit2/transports/ssh_libssh2.h | 28 + 5 files changed, 1161 insertions(+), 1108 deletions(-) delete mode 100644 src/libgit2/transports/ssh.h create mode 100644 src/libgit2/transports/ssh_libssh2.c create mode 100644 src/libgit2/transports/ssh_libssh2.h diff --git a/src/libgit2/libgit2.c b/src/libgit2/libgit2.c index ce287147a70..56b90321f4a 100644 --- a/src/libgit2/libgit2.c +++ b/src/libgit2/libgit2.c @@ -34,7 +34,7 @@ #include "streams/socket.h" #include "transports/smart.h" #include "transports/http.h" -#include "transports/ssh.h" +#include "transports/ssh_libssh2.h" #ifdef GIT_WIN32 # include "win32/w32_leakcheck.h" @@ -80,7 +80,7 @@ int git_libgit2_init(void) git_sysdir_global_init, git_filter_global_init, git_merge_driver_global_init, - git_transport_ssh_global_init, + git_transport_ssh_libssh2_global_init, git_stream_registry_global_init, git_socket_stream_global_init, git_openssl_stream_global_init, diff --git a/src/libgit2/transports/ssh.c b/src/libgit2/transports/ssh.c index de63d454ee6..bef0b14409f 100644 --- a/src/libgit2/transports/ssh.c +++ b/src/libgit2/transports/ssh.c @@ -5,1086 +5,38 @@ * a Linking Exception. For full terms see the included COPYING file. */ -#include "ssh.h" +#include "ssh_libssh2.h" -#ifdef GIT_SSH -#include -#endif - -#include "runtime.h" -#include "net.h" -#include "smart.h" -#include "streams/socket.h" -#include "sysdir.h" - -#include "git2/credential.h" -#include "git2/sys/credential.h" - -#ifdef GIT_SSH - -#define OWNING_SUBTRANSPORT(s) ((ssh_subtransport *)(s)->parent.subtransport) - -static const char cmd_uploadpack[] = "git-upload-pack"; -static const char cmd_receivepack[] = "git-receive-pack"; - -typedef struct { - git_smart_subtransport_stream parent; - git_stream *io; - LIBSSH2_SESSION *session; - LIBSSH2_CHANNEL *channel; - const char *cmd; - git_net_url url; - unsigned sent_command : 1; -} ssh_stream; - -typedef struct { - git_smart_subtransport parent; - transport_smart *owner; - ssh_stream *current_stream; - git_credential *cred; - char *cmd_uploadpack; - char *cmd_receivepack; -} ssh_subtransport; - -static int list_auth_methods(int *out, LIBSSH2_SESSION *session, const char *username); - -static void ssh_error(LIBSSH2_SESSION *session, const char *errmsg) -{ - char *ssherr; - libssh2_session_last_error(session, &ssherr, NULL, 0); - - git_error_set(GIT_ERROR_SSH, "%s: %s", errmsg, ssherr); -} - -/* - * Create a git protocol request. - * - * For example: git-upload-pack '/libgit2/libgit2' - */ -static int gen_proto(git_str *request, const char *cmd, git_net_url *url) -{ - const char *repo; - - repo = url->path; - - if (repo && repo[0] == '/' && repo[1] == '~') - repo++; - - if (!repo || !repo[0]) { - git_error_set(GIT_ERROR_NET, "malformed git protocol URL"); - return -1; - } - - git_str_puts(request, cmd); - git_str_puts(request, " '"); - git_str_puts(request, repo); - git_str_puts(request, "'"); - - if (git_str_oom(request)) - return -1; - - return 0; -} - -static int send_command(ssh_stream *s) -{ - int error; - git_str request = GIT_STR_INIT; - - error = gen_proto(&request, s->cmd, &s->url); - if (error < 0) - goto cleanup; - - error = libssh2_channel_exec(s->channel, request.ptr); - if (error < LIBSSH2_ERROR_NONE) { - ssh_error(s->session, "SSH could not execute request"); - goto cleanup; - } - - s->sent_command = 1; - -cleanup: - git_str_dispose(&request); - return error; -} - -static int ssh_stream_read( - git_smart_subtransport_stream *stream, - char *buffer, - size_t buf_size, - size_t *bytes_read) -{ - int rc; - ssh_stream *s = GIT_CONTAINER_OF(stream, ssh_stream, parent); - - *bytes_read = 0; - - if (!s->sent_command && send_command(s) < 0) - return -1; - - if ((rc = libssh2_channel_read(s->channel, buffer, buf_size)) < LIBSSH2_ERROR_NONE) { - ssh_error(s->session, "SSH could not read data"); - return -1; - } - - /* - * If we can't get anything out of stdout, it's typically a - * not-found error, so read from stderr and signal EOF on - * stderr. - */ - if (rc == 0) { - if ((rc = libssh2_channel_read_stderr(s->channel, buffer, buf_size)) > 0) { - git_error_set(GIT_ERROR_SSH, "%*s", rc, buffer); - return GIT_EEOF; - } else if (rc < LIBSSH2_ERROR_NONE) { - ssh_error(s->session, "SSH could not read stderr"); - return -1; - } - } - - - *bytes_read = rc; - - return 0; -} - -static int ssh_stream_write( - git_smart_subtransport_stream *stream, - const char *buffer, - size_t len) -{ - ssh_stream *s = GIT_CONTAINER_OF(stream, ssh_stream, parent); - size_t off = 0; - ssize_t ret = 0; - - if (!s->sent_command && send_command(s) < 0) - return -1; - - do { - ret = libssh2_channel_write(s->channel, buffer + off, len - off); - if (ret < 0) - break; - - off += ret; - - } while (off < len); - - if (ret < 0) { - ssh_error(s->session, "SSH could not write data"); - return -1; - } - - return 0; -} - -static void ssh_stream_free(git_smart_subtransport_stream *stream) -{ - ssh_stream *s = GIT_CONTAINER_OF(stream, ssh_stream, parent); - ssh_subtransport *t; - - if (!stream) - return; - - t = OWNING_SUBTRANSPORT(s); - t->current_stream = NULL; - - if (s->channel) { - libssh2_channel_close(s->channel); - libssh2_channel_free(s->channel); - s->channel = NULL; - } - - if (s->session) { - libssh2_session_disconnect(s->session, "closing transport"); - libssh2_session_free(s->session); - s->session = NULL; - } - - if (s->io) { - git_stream_close(s->io); - git_stream_free(s->io); - s->io = NULL; - } - - git_net_url_dispose(&s->url); - git__free(s); -} - -static int ssh_stream_alloc( - ssh_subtransport *t, - const char *cmd, - git_smart_subtransport_stream **stream) -{ - ssh_stream *s; - - GIT_ASSERT_ARG(stream); - - s = git__calloc(sizeof(ssh_stream), 1); - GIT_ERROR_CHECK_ALLOC(s); - - s->parent.subtransport = &t->parent; - s->parent.read = ssh_stream_read; - s->parent.write = ssh_stream_write; - s->parent.free = ssh_stream_free; - - s->cmd = cmd; - - *stream = &s->parent; - return 0; -} - -static int ssh_agent_auth(LIBSSH2_SESSION *session, git_credential_ssh_key *c) { - int rc = LIBSSH2_ERROR_NONE; - - struct libssh2_agent_publickey *curr, *prev = NULL; - - LIBSSH2_AGENT *agent = libssh2_agent_init(session); - - if (agent == NULL) - return -1; - - rc = libssh2_agent_connect(agent); - - if (rc != LIBSSH2_ERROR_NONE) { - rc = LIBSSH2_ERROR_AUTHENTICATION_FAILED; - goto shutdown; - } - - rc = libssh2_agent_list_identities(agent); - - if (rc != LIBSSH2_ERROR_NONE) - goto shutdown; - - while (1) { - rc = libssh2_agent_get_identity(agent, &curr, prev); - - if (rc < 0) - goto shutdown; - - /* rc is set to 1 whenever the ssh agent ran out of keys to check. - * Set the error code to authentication failure rather than erroring - * out with an untranslatable error code. - */ - if (rc == 1) { - rc = LIBSSH2_ERROR_AUTHENTICATION_FAILED; - goto shutdown; - } - - rc = libssh2_agent_userauth(agent, c->username, curr); - - if (rc == 0) - break; - - prev = curr; - } - -shutdown: - - if (rc != LIBSSH2_ERROR_NONE) - ssh_error(session, "error authenticating"); - - libssh2_agent_disconnect(agent); - libssh2_agent_free(agent); - - return rc; -} - -static int _git_ssh_authenticate_session( - LIBSSH2_SESSION *session, - git_credential *cred) -{ - int rc; - - do { - git_error_clear(); - switch (cred->credtype) { - case GIT_CREDENTIAL_USERPASS_PLAINTEXT: { - git_credential_userpass_plaintext *c = (git_credential_userpass_plaintext *)cred; - rc = libssh2_userauth_password(session, c->username, c->password); - break; - } - case GIT_CREDENTIAL_SSH_KEY: { - git_credential_ssh_key *c = (git_credential_ssh_key *)cred; - - if (c->privatekey) - rc = libssh2_userauth_publickey_fromfile( - session, c->username, c->publickey, - c->privatekey, c->passphrase); - else - rc = ssh_agent_auth(session, c); - - break; - } - case GIT_CREDENTIAL_SSH_CUSTOM: { - git_credential_ssh_custom *c = (git_credential_ssh_custom *)cred; - - rc = libssh2_userauth_publickey( - session, c->username, (const unsigned char *)c->publickey, - c->publickey_len, c->sign_callback, &c->payload); - break; - } - case GIT_CREDENTIAL_SSH_INTERACTIVE: { - void **abstract = libssh2_session_abstract(session); - git_credential_ssh_interactive *c = (git_credential_ssh_interactive *)cred; - - /* ideally, we should be able to set this by calling - * libssh2_session_init_ex() instead of libssh2_session_init(). - * libssh2's API is inconsistent here i.e. libssh2_userauth_publickey() - * allows you to pass the `abstract` as part of the call, whereas - * libssh2_userauth_keyboard_interactive() does not! - * - * The only way to set the `abstract` pointer is by calling - * libssh2_session_abstract(), which will replace the existing - * pointer as is done below. This is safe for now (at time of writing), - * but may not be valid in future. - */ - *abstract = c->payload; - - rc = libssh2_userauth_keyboard_interactive( - session, c->username, c->prompt_callback); - break; - } -#ifdef GIT_SSH_MEMORY_CREDENTIALS - case GIT_CREDENTIAL_SSH_MEMORY: { - git_credential_ssh_key *c = (git_credential_ssh_key *)cred; - - GIT_ASSERT(c->username); - GIT_ASSERT(c->privatekey); - - rc = libssh2_userauth_publickey_frommemory( - session, - c->username, - strlen(c->username), - c->publickey, - c->publickey ? strlen(c->publickey) : 0, - c->privatekey, - strlen(c->privatekey), - c->passphrase); - break; - } -#endif - default: - rc = LIBSSH2_ERROR_AUTHENTICATION_FAILED; - } - } while (LIBSSH2_ERROR_EAGAIN == rc || LIBSSH2_ERROR_TIMEOUT == rc); - - if (rc == LIBSSH2_ERROR_PASSWORD_EXPIRED || - rc == LIBSSH2_ERROR_AUTHENTICATION_FAILED || - rc == LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED) - return GIT_EAUTH; - - if (rc != LIBSSH2_ERROR_NONE) { - if (!git_error_last()) - ssh_error(session, "Failed to authenticate SSH session"); - return -1; - } - - return 0; -} - -static int request_creds(git_credential **out, ssh_subtransport *t, const char *user, int auth_methods) -{ - int error, no_callback = 0; - git_credential *cred = NULL; - - if (!t->owner->connect_opts.callbacks.credentials) { - no_callback = 1; - } else { - error = t->owner->connect_opts.callbacks.credentials( - &cred, - t->owner->url, - user, - auth_methods, - t->owner->connect_opts.callbacks.payload); - - if (error == GIT_PASSTHROUGH) { - no_callback = 1; - } else if (error < 0) { - return error; - } else if (!cred) { - git_error_set(GIT_ERROR_SSH, "callback failed to initialize SSH credentials"); - return -1; - } - } - - if (no_callback) { - git_error_set(GIT_ERROR_SSH, "authentication required but no callback set"); - return GIT_EAUTH; - } - - if (!(cred->credtype & auth_methods)) { - cred->free(cred); - git_error_set(GIT_ERROR_SSH, "authentication callback returned unsupported credentials type"); - return GIT_EAUTH; - } - - *out = cred; - - return 0; -} - -#define SSH_DIR ".ssh" -#define KNOWN_HOSTS_FILE "known_hosts" - -/* - * Load the known_hosts file. - * - * Returns success but leaves the output NULL if we couldn't find the file. - */ -static int load_known_hosts(LIBSSH2_KNOWNHOSTS **hosts, LIBSSH2_SESSION *session) -{ - git_str path = GIT_STR_INIT, sshdir = GIT_STR_INIT; - LIBSSH2_KNOWNHOSTS *known_hosts = NULL; - int error; - - GIT_ASSERT_ARG(hosts); - - if ((error = git_sysdir_expand_homedir_file(&sshdir, SSH_DIR)) < 0 || - (error = git_str_joinpath(&path, git_str_cstr(&sshdir), KNOWN_HOSTS_FILE)) < 0) - goto out; - - if ((known_hosts = libssh2_knownhost_init(session)) == NULL) { - ssh_error(session, "error initializing known hosts"); - error = -1; - goto out; - } - - /* - * Try to read the file and consider not finding it as not trusting the - * host rather than an error. - */ - error = libssh2_knownhost_readfile(known_hosts, git_str_cstr(&path), LIBSSH2_KNOWNHOST_FILE_OPENSSH); - if (error == LIBSSH2_ERROR_FILE) - error = 0; - if (error < 0) - ssh_error(session, "error reading known_hosts"); - -out: - *hosts = known_hosts; - - git_str_dispose(&sshdir); - git_str_dispose(&path); - - return error; -} - -static void add_hostkey_pref_if_avail( - LIBSSH2_KNOWNHOSTS *known_hosts, - const char *hostname, - int port, - git_str *prefs, - int type, - const char *type_name) -{ - struct libssh2_knownhost *host = NULL; - const char key = '\0'; - int mask = LIBSSH2_KNOWNHOST_TYPE_PLAIN | LIBSSH2_KNOWNHOST_KEYENC_RAW | type; - int error; - - error = libssh2_knownhost_checkp(known_hosts, hostname, port, &key, 1, mask, &host); - if (error == LIBSSH2_KNOWNHOST_CHECK_MISMATCH) { - if (git_str_len(prefs) > 0) { - git_str_putc(prefs, ','); - } - git_str_puts(prefs, type_name); - } -} - -/* - * We figure out what kind of key we want to ask the remote for by trying to - * look it up with a nonsense key and using that mismatch to figure out what key - * we do have stored for the host. - * - * Populates prefs with the string to pass to libssh2_session_method_pref. - */ -static void find_hostkey_preference( - LIBSSH2_KNOWNHOSTS *known_hosts, - const char *hostname, - int port, - git_str *prefs) -{ - /* - * The order here is important as it indicates the priority of what will - * be preferred. - */ -#ifdef LIBSSH2_KNOWNHOST_KEY_ED25519 - add_hostkey_pref_if_avail(known_hosts, hostname, port, prefs, LIBSSH2_KNOWNHOST_KEY_ED25519, "ssh-ed25519"); -#endif -#ifdef LIBSSH2_KNOWNHOST_KEY_ECDSA_256 - add_hostkey_pref_if_avail(known_hosts, hostname, port, prefs, LIBSSH2_KNOWNHOST_KEY_ECDSA_256, "ecdsa-sha2-nistp256"); - add_hostkey_pref_if_avail(known_hosts, hostname, port, prefs, LIBSSH2_KNOWNHOST_KEY_ECDSA_384, "ecdsa-sha2-nistp384"); - add_hostkey_pref_if_avail(known_hosts, hostname, port, prefs, LIBSSH2_KNOWNHOST_KEY_ECDSA_521, "ecdsa-sha2-nistp521"); -#endif - add_hostkey_pref_if_avail(known_hosts, hostname, port, prefs, LIBSSH2_KNOWNHOST_KEY_SSHRSA, "ssh-rsa"); -} - -static int _git_ssh_session_create( - LIBSSH2_SESSION **session, - LIBSSH2_KNOWNHOSTS **hosts, - const char *hostname, - int port, - git_stream *io) -{ - git_socket_stream *socket = GIT_CONTAINER_OF(io, git_socket_stream, parent); - LIBSSH2_SESSION *s; - LIBSSH2_KNOWNHOSTS *known_hosts; - git_str prefs = GIT_STR_INIT; - int rc = 0; - - GIT_ASSERT_ARG(session); - GIT_ASSERT_ARG(hosts); - - s = libssh2_session_init(); - if (!s) { - git_error_set(GIT_ERROR_NET, "failed to initialize SSH session"); - return -1; - } - - if ((rc = load_known_hosts(&known_hosts, s)) < 0) { - ssh_error(s, "error loading known_hosts"); - libssh2_session_free(s); - return -1; - } - - find_hostkey_preference(known_hosts, hostname, port, &prefs); - if (git_str_len(&prefs) > 0) { - do { - rc = libssh2_session_method_pref(s, LIBSSH2_METHOD_HOSTKEY, git_str_cstr(&prefs)); - } while (LIBSSH2_ERROR_EAGAIN == rc || LIBSSH2_ERROR_TIMEOUT == rc); - if (rc != LIBSSH2_ERROR_NONE) { - ssh_error(s, "failed to set hostkey preference"); - goto on_error; - } - } - git_str_dispose(&prefs); - - do { - rc = libssh2_session_handshake(s, socket->s); - } while (LIBSSH2_ERROR_EAGAIN == rc || LIBSSH2_ERROR_TIMEOUT == rc); - - if (rc != LIBSSH2_ERROR_NONE) { - ssh_error(s, "failed to start SSH session"); - goto on_error; - } - - libssh2_session_set_blocking(s, 1); - - *session = s; - *hosts = known_hosts; - - return 0; - -on_error: - libssh2_knownhost_free(known_hosts); - libssh2_session_free(s); - return -1; -} - - -/* - * Returns the typemask argument to pass to libssh2_knownhost_check{,p} based on - * the type of key that libssh2_session_hostkey returns. - */ -static int fingerprint_type_mask(int keytype) -{ - int mask = LIBSSH2_KNOWNHOST_TYPE_PLAIN | LIBSSH2_KNOWNHOST_KEYENC_RAW; - return mask; - - switch (keytype) { - case LIBSSH2_HOSTKEY_TYPE_RSA: - mask |= LIBSSH2_KNOWNHOST_KEY_SSHRSA; - break; - case LIBSSH2_HOSTKEY_TYPE_DSS: - mask |= LIBSSH2_KNOWNHOST_KEY_SSHDSS; - break; -#ifdef LIBSSH2_HOSTKEY_TYPE_ECDSA_256 - case LIBSSH2_HOSTKEY_TYPE_ECDSA_256: - mask |= LIBSSH2_KNOWNHOST_KEY_ECDSA_256; - break; - case LIBSSH2_HOSTKEY_TYPE_ECDSA_384: - mask |= LIBSSH2_KNOWNHOST_KEY_ECDSA_384; - break; - case LIBSSH2_HOSTKEY_TYPE_ECDSA_521: - mask |= LIBSSH2_KNOWNHOST_KEY_ECDSA_521; - break; -#endif -#ifdef LIBSSH2_HOSTKEY_TYPE_ED25519 - case LIBSSH2_HOSTKEY_TYPE_ED25519: - mask |= LIBSSH2_KNOWNHOST_KEY_ED25519; - break; -#endif - } - - return mask; -} - -/* - * Check the host against the user's known_hosts file. - * - * Returns 1/0 for valid/''not-valid or <0 for an error - */ -static int check_against_known_hosts( - LIBSSH2_SESSION *session, - LIBSSH2_KNOWNHOSTS *known_hosts, - const char *hostname, - int port, - const char *key, - size_t key_len, - int key_type) -{ - int check, typemask, ret = 0; - struct libssh2_knownhost *host = NULL; - - if (known_hosts == NULL) - return 0; - - typemask = fingerprint_type_mask(key_type); - check = libssh2_knownhost_checkp(known_hosts, hostname, port, key, key_len, typemask, &host); - if (check == LIBSSH2_KNOWNHOST_CHECK_FAILURE) { - ssh_error(session, "error checking for known host"); - return -1; - } - - ret = check == LIBSSH2_KNOWNHOST_CHECK_MATCH ? 1 : 0; - - return ret; -} - -/* - * Perform the check for the session's certificate against known hosts if - * possible and then ask the user if they have a callback. - * - * Returns 1/0 for valid/not-valid or <0 for an error - */ -static int check_certificate( - LIBSSH2_SESSION *session, - LIBSSH2_KNOWNHOSTS *known_hosts, - git_transport_certificate_check_cb check_cb, - void *check_cb_payload, - const char *host, - int port) -{ - git_cert_hostkey cert = {{ 0 }}; - const char *key; - size_t cert_len; - int cert_type, cert_valid = 0, error = 0; - - if ((key = libssh2_session_hostkey(session, &cert_len, &cert_type)) == NULL) { - ssh_error(session, "failed to retrieve hostkey"); - return -1; - } - - if ((cert_valid = check_against_known_hosts(session, known_hosts, host, port, key, cert_len, cert_type)) < 0) - return -1; - - cert.parent.cert_type = GIT_CERT_HOSTKEY_LIBSSH2; - if (key != NULL) { - cert.type |= GIT_CERT_SSH_RAW; - cert.hostkey = key; - cert.hostkey_len = cert_len; - switch (cert_type) { - case LIBSSH2_HOSTKEY_TYPE_RSA: - cert.raw_type = GIT_CERT_SSH_RAW_TYPE_RSA; - break; - case LIBSSH2_HOSTKEY_TYPE_DSS: - cert.raw_type = GIT_CERT_SSH_RAW_TYPE_DSS; - break; - -#ifdef LIBSSH2_HOSTKEY_TYPE_ECDSA_256 - case LIBSSH2_HOSTKEY_TYPE_ECDSA_256: - cert.raw_type = GIT_CERT_SSH_RAW_TYPE_KEY_ECDSA_256; - break; - case LIBSSH2_HOSTKEY_TYPE_ECDSA_384: - cert.raw_type = GIT_CERT_SSH_RAW_TYPE_KEY_ECDSA_384; - break; - case LIBSSH2_KNOWNHOST_KEY_ECDSA_521: - cert.raw_type = GIT_CERT_SSH_RAW_TYPE_KEY_ECDSA_521; - break; -#endif - -#ifdef LIBSSH2_HOSTKEY_TYPE_ED25519 - case LIBSSH2_HOSTKEY_TYPE_ED25519: - cert.raw_type = GIT_CERT_SSH_RAW_TYPE_KEY_ED25519; - break; -#endif - default: - cert.raw_type = GIT_CERT_SSH_RAW_TYPE_UNKNOWN; - } - } - -#ifdef LIBSSH2_HOSTKEY_HASH_SHA256 - key = libssh2_hostkey_hash(session, LIBSSH2_HOSTKEY_HASH_SHA256); - if (key != NULL) { - cert.type |= GIT_CERT_SSH_SHA256; - memcpy(&cert.hash_sha256, key, 32); - } -#endif - - key = libssh2_hostkey_hash(session, LIBSSH2_HOSTKEY_HASH_SHA1); - if (key != NULL) { - cert.type |= GIT_CERT_SSH_SHA1; - memcpy(&cert.hash_sha1, key, 20); - } - - key = libssh2_hostkey_hash(session, LIBSSH2_HOSTKEY_HASH_MD5); - if (key != NULL) { - cert.type |= GIT_CERT_SSH_MD5; - memcpy(&cert.hash_md5, key, 16); - } - - if (cert.type == 0) { - git_error_set(GIT_ERROR_SSH, "unable to get the host key"); - return -1; - } - - git_error_clear(); - error = 0; - if (!cert_valid) { - git_error_set(GIT_ERROR_SSH, "invalid or unknown remote ssh hostkey"); - error = GIT_ECERTIFICATE; - } - - if (check_cb != NULL) { - git_cert_hostkey *cert_ptr = &cert; - git_error_state previous_error = {0}; - - git_error_state_capture(&previous_error, error); - error = check_cb((git_cert *) cert_ptr, cert_valid, host, check_cb_payload); - if (error == GIT_PASSTHROUGH) { - error = git_error_state_restore(&previous_error); - } else if (error < 0 && !git_error_last()) { - git_error_set(GIT_ERROR_NET, "unknown remote host key"); - } - - git_error_state_free(&previous_error); - } - - return error; -} - -#define SSH_DEFAULT_PORT "22" - -static int _git_ssh_setup_conn( - ssh_subtransport *t, - const char *url, - const char *cmd, - git_smart_subtransport_stream **stream) -{ - int auth_methods, error = 0, port; - ssh_stream *s; - git_credential *cred = NULL; - LIBSSH2_SESSION *session=NULL; - LIBSSH2_CHANNEL *channel=NULL; - LIBSSH2_KNOWNHOSTS *known_hosts = NULL; - - t->current_stream = NULL; - - *stream = NULL; - if (ssh_stream_alloc(t, cmd, stream) < 0) - return -1; - - s = (ssh_stream *)*stream; - s->session = NULL; - s->channel = NULL; - - if ((error = git_net_url_parse_standard_or_scp(&s->url, url)) < 0 || - (error = git_socket_stream_new(&s->io, s->url.host, s->url.port)) < 0 || - (error = git_stream_connect(s->io)) < 0) - goto done; - - /* - * Try to parse the port as a number, if we can't then fall back to - * default. It would be nice if we could get the port that was resolved - * as part of the stream connection, but that's not something that's - * exposed. - */ - if (git__strntol32(&port, s->url.port, strlen(s->url.port), NULL, 10) < 0) { - git_error_set(GIT_ERROR_NET, "invalid port to ssh: %s", s->url.port); - error = -1; - goto done; - } - - if ((error = _git_ssh_session_create(&session, &known_hosts, s->url.host, port, s->io)) < 0) - goto done; - - if ((error = check_certificate(session, known_hosts, t->owner->connect_opts.callbacks.certificate_check, t->owner->connect_opts.callbacks.payload, s->url.host, port)) < 0) - goto done; - - /* we need the username to ask for auth methods */ - if (!s->url.username) { - if ((error = request_creds(&cred, t, NULL, GIT_CREDENTIAL_USERNAME)) < 0) - goto done; - - s->url.username = git__strdup(((git_credential_username *) cred)->username); - cred->free(cred); - cred = NULL; - if (!s->url.username) - goto done; - } else if (s->url.username && s->url.password) { - if ((error = git_credential_userpass_plaintext_new(&cred, s->url.username, s->url.password)) < 0) - goto done; - } - - if ((error = list_auth_methods(&auth_methods, session, s->url.username)) < 0) - goto done; - - error = GIT_EAUTH; - /* if we already have something to try */ - if (cred && auth_methods & cred->credtype) - error = _git_ssh_authenticate_session(session, cred); - - while (error == GIT_EAUTH) { - if (cred) { - cred->free(cred); - cred = NULL; - } - - if ((error = request_creds(&cred, t, s->url.username, auth_methods)) < 0) - goto done; - - if (strcmp(s->url.username, git_credential_get_username(cred))) { - git_error_set(GIT_ERROR_SSH, "username does not match previous request"); - error = -1; - goto done; - } - - error = _git_ssh_authenticate_session(session, cred); - - if (error == GIT_EAUTH) { - /* refresh auth methods */ - if ((error = list_auth_methods(&auth_methods, session, s->url.username)) < 0) - goto done; - else - error = GIT_EAUTH; - } - } - - if (error < 0) - goto done; - - channel = libssh2_channel_open_session(session); - if (!channel) { - error = -1; - ssh_error(session, "Failed to open SSH channel"); - goto done; - } - - libssh2_channel_set_blocking(channel, 1); - - s->session = session; - s->channel = channel; - - t->current_stream = s; - -done: - if (known_hosts) - libssh2_knownhost_free(known_hosts); - - if (error < 0) { - ssh_stream_free(*stream); - - if (session) - libssh2_session_free(session); - } - - if (cred) - cred->free(cred); - - return error; -} - -static int ssh_uploadpack_ls( - ssh_subtransport *t, - const char *url, - git_smart_subtransport_stream **stream) -{ - const char *cmd = t->cmd_uploadpack ? t->cmd_uploadpack : cmd_uploadpack; - - return _git_ssh_setup_conn(t, url, cmd, stream); -} - -static int ssh_uploadpack( - ssh_subtransport *t, - const char *url, - git_smart_subtransport_stream **stream) -{ - GIT_UNUSED(url); - - if (t->current_stream) { - *stream = &t->current_stream->parent; - return 0; - } - - git_error_set(GIT_ERROR_NET, "must call UPLOADPACK_LS before UPLOADPACK"); - return -1; -} - -static int ssh_receivepack_ls( - ssh_subtransport *t, - const char *url, - git_smart_subtransport_stream **stream) -{ - const char *cmd = t->cmd_receivepack ? t->cmd_receivepack : cmd_receivepack; - - - return _git_ssh_setup_conn(t, url, cmd, stream); -} - -static int ssh_receivepack( - ssh_subtransport *t, - const char *url, - git_smart_subtransport_stream **stream) -{ - GIT_UNUSED(url); - - if (t->current_stream) { - *stream = &t->current_stream->parent; - return 0; - } - - git_error_set(GIT_ERROR_NET, "must call RECEIVEPACK_LS before RECEIVEPACK"); - return -1; -} - -static int _ssh_action( - git_smart_subtransport_stream **stream, - git_smart_subtransport *subtransport, - const char *url, - git_smart_service_t action) -{ - ssh_subtransport *t = GIT_CONTAINER_OF(subtransport, ssh_subtransport, parent); - - switch (action) { - case GIT_SERVICE_UPLOADPACK_LS: - return ssh_uploadpack_ls(t, url, stream); - - case GIT_SERVICE_UPLOADPACK: - return ssh_uploadpack(t, url, stream); - - case GIT_SERVICE_RECEIVEPACK_LS: - return ssh_receivepack_ls(t, url, stream); - - case GIT_SERVICE_RECEIVEPACK: - return ssh_receivepack(t, url, stream); - } - - *stream = NULL; - return -1; -} - -static int _ssh_close(git_smart_subtransport *subtransport) -{ - ssh_subtransport *t = GIT_CONTAINER_OF(subtransport, ssh_subtransport, parent); - - GIT_ASSERT(!t->current_stream); - - GIT_UNUSED(t); - - return 0; -} - -static void _ssh_free(git_smart_subtransport *subtransport) -{ - ssh_subtransport *t = GIT_CONTAINER_OF(subtransport, ssh_subtransport, parent); - - git__free(t->cmd_uploadpack); - git__free(t->cmd_receivepack); - git__free(t); -} - -#define SSH_AUTH_PUBLICKEY "publickey" -#define SSH_AUTH_PASSWORD "password" -#define SSH_AUTH_KEYBOARD_INTERACTIVE "keyboard-interactive" - -static int list_auth_methods(int *out, LIBSSH2_SESSION *session, const char *username) -{ - const char *list, *ptr; - - *out = 0; - - list = libssh2_userauth_list(session, username, strlen(username)); - - /* either error, or the remote accepts NONE auth, which is bizarre, let's punt */ - if (list == NULL && !libssh2_userauth_authenticated(session)) { - ssh_error(session, "remote rejected authentication"); - return GIT_EAUTH; - } - - ptr = list; - while (ptr) { - if (*ptr == ',') - ptr++; - - if (!git__prefixcmp(ptr, SSH_AUTH_PUBLICKEY)) { - *out |= GIT_CREDENTIAL_SSH_KEY; - *out |= GIT_CREDENTIAL_SSH_CUSTOM; -#ifdef GIT_SSH_MEMORY_CREDENTIALS - *out |= GIT_CREDENTIAL_SSH_MEMORY; -#endif - ptr += strlen(SSH_AUTH_PUBLICKEY); - continue; - } - - if (!git__prefixcmp(ptr, SSH_AUTH_PASSWORD)) { - *out |= GIT_CREDENTIAL_USERPASS_PLAINTEXT; - ptr += strlen(SSH_AUTH_PASSWORD); - continue; - } - - if (!git__prefixcmp(ptr, SSH_AUTH_KEYBOARD_INTERACTIVE)) { - *out |= GIT_CREDENTIAL_SSH_INTERACTIVE; - ptr += strlen(SSH_AUTH_KEYBOARD_INTERACTIVE); - continue; - } - - /* Skip it if we don't know it */ - ptr = strchr(ptr, ','); - } - - return 0; -} -#endif +#include "transports/smart.h" int git_smart_subtransport_ssh( - git_smart_subtransport **out, git_transport *owner, void *param) + git_smart_subtransport **out, + git_transport *owner, + void *param) { #ifdef GIT_SSH - ssh_subtransport *t; - - GIT_ASSERT_ARG(out); - - GIT_UNUSED(param); - - t = git__calloc(sizeof(ssh_subtransport), 1); - GIT_ERROR_CHECK_ALLOC(t); - - t->owner = (transport_smart *)owner; - t->parent.action = _ssh_action; - t->parent.close = _ssh_close; - t->parent.free = _ssh_free; - - *out = (git_smart_subtransport *) t; - return 0; + return git_smart_subtransport_ssh_libssh2(out, owner, param); #else + GIT_UNUSED(out); GIT_UNUSED(owner); GIT_UNUSED(param); - GIT_ASSERT_ARG(out); - *out = NULL; - git_error_set(GIT_ERROR_INVALID, "cannot create SSH transport. Library was built without SSH support"); return -1; #endif } -int git_transport_ssh_with_paths(git_transport **out, git_remote *owner, void *payload) +int git_transport_ssh_with_paths( + git_transport **out, + git_remote *owner, + void *payload) { #ifdef GIT_SSH git_strarray *paths = (git_strarray *) payload; git_transport *transport; transport_smart *smart; - ssh_subtransport *t; int error; + git_smart_subtransport_definition ssh_definition = { git_smart_subtransport_ssh, 0, /* no RPC */ @@ -1100,48 +52,22 @@ int git_transport_ssh_with_paths(git_transport **out, git_remote *owner, void *p return error; smart = (transport_smart *) transport; - t = (ssh_subtransport *) smart->wrapped; - t->cmd_uploadpack = git__strdup(paths->strings[0]); - GIT_ERROR_CHECK_ALLOC(t->cmd_uploadpack); - t->cmd_receivepack = git__strdup(paths->strings[1]); - GIT_ERROR_CHECK_ALLOC(t->cmd_receivepack); + if ((error = git_smart_subtransport_ssh_libssh2_set_paths( + (git_smart_subtransport *)smart->wrapped, + paths->strings[0], + paths->strings[1])) < 0) + return error; *out = transport; return 0; #else + GIT_UNUSED(out); GIT_UNUSED(owner); GIT_UNUSED(payload); - GIT_ASSERT_ARG(out); - *out = NULL; - git_error_set(GIT_ERROR_INVALID, "cannot create SSH transport. Library was built without SSH support"); return -1; #endif } -#ifdef GIT_SSH -static void shutdown_ssh(void) -{ - libssh2_exit(); -} -#endif - -int git_transport_ssh_global_init(void) -{ -#ifdef GIT_SSH - if (libssh2_init(0) < 0) { - git_error_set(GIT_ERROR_SSH, "unable to initialize libssh2"); - return -1; - } - - return git_runtime_shutdown_register(shutdown_ssh); - -#else - - /* Nothing to initialize */ - return 0; - -#endif -} diff --git a/src/libgit2/transports/ssh.h b/src/libgit2/transports/ssh.h deleted file mode 100644 index d3e741f1d9e..00000000000 --- a/src/libgit2/transports/ssh.h +++ /dev/null @@ -1,14 +0,0 @@ -/* - * Copyright (C) the libgit2 contributors. All rights reserved. - * - * This file is part of libgit2, distributed under the GNU GPL v2 with - * a Linking Exception. For full terms see the included COPYING file. - */ -#ifndef INCLUDE_transports_ssh_h__ -#define INCLUDE_transports_ssh_h__ - -#include "common.h" - -int git_transport_ssh_global_init(void); - -#endif diff --git a/src/libgit2/transports/ssh_libssh2.c b/src/libgit2/transports/ssh_libssh2.c new file mode 100644 index 00000000000..154d022944b --- /dev/null +++ b/src/libgit2/transports/ssh_libssh2.c @@ -0,0 +1,1113 @@ +/* + * Copyright (C) the libgit2 contributors. All rights reserved. + * + * This file is part of libgit2, distributed under the GNU GPL v2 with + * a Linking Exception. For full terms see the included COPYING file. + */ + +#include "ssh_libssh2.h" + +#ifdef GIT_SSH + +#include + +#include "runtime.h" +#include "net.h" +#include "smart.h" +#include "streams/socket.h" +#include "sysdir.h" + +#include "git2/credential.h" +#include "git2/sys/credential.h" + +#define OWNING_SUBTRANSPORT(s) ((ssh_subtransport *)(s)->parent.subtransport) + +static const char cmd_uploadpack[] = "git-upload-pack"; +static const char cmd_receivepack[] = "git-receive-pack"; + +typedef struct { + git_smart_subtransport_stream parent; + git_stream *io; + LIBSSH2_SESSION *session; + LIBSSH2_CHANNEL *channel; + const char *cmd; + git_net_url url; + unsigned sent_command : 1; +} ssh_stream; + +typedef struct { + git_smart_subtransport parent; + transport_smart *owner; + ssh_stream *current_stream; + git_credential *cred; + char *cmd_uploadpack; + char *cmd_receivepack; +} ssh_subtransport; + +static int list_auth_methods(int *out, LIBSSH2_SESSION *session, const char *username); + +static void ssh_error(LIBSSH2_SESSION *session, const char *errmsg) +{ + char *ssherr; + libssh2_session_last_error(session, &ssherr, NULL, 0); + + git_error_set(GIT_ERROR_SSH, "%s: %s", errmsg, ssherr); +} + +/* + * Create a git protocol request. + * + * For example: git-upload-pack '/libgit2/libgit2' + */ +static int gen_proto(git_str *request, const char *cmd, git_net_url *url) +{ + const char *repo; + + repo = url->path; + + if (repo && repo[0] == '/' && repo[1] == '~') + repo++; + + if (!repo || !repo[0]) { + git_error_set(GIT_ERROR_NET, "malformed git protocol URL"); + return -1; + } + + git_str_puts(request, cmd); + git_str_puts(request, " '"); + git_str_puts(request, repo); + git_str_puts(request, "'"); + + if (git_str_oom(request)) + return -1; + + return 0; +} + +static int send_command(ssh_stream *s) +{ + int error; + git_str request = GIT_STR_INIT; + + error = gen_proto(&request, s->cmd, &s->url); + if (error < 0) + goto cleanup; + + error = libssh2_channel_exec(s->channel, request.ptr); + if (error < LIBSSH2_ERROR_NONE) { + ssh_error(s->session, "SSH could not execute request"); + goto cleanup; + } + + s->sent_command = 1; + +cleanup: + git_str_dispose(&request); + return error; +} + +static int ssh_stream_read( + git_smart_subtransport_stream *stream, + char *buffer, + size_t buf_size, + size_t *bytes_read) +{ + int rc; + ssh_stream *s = GIT_CONTAINER_OF(stream, ssh_stream, parent); + + *bytes_read = 0; + + if (!s->sent_command && send_command(s) < 0) + return -1; + + if ((rc = libssh2_channel_read(s->channel, buffer, buf_size)) < LIBSSH2_ERROR_NONE) { + ssh_error(s->session, "SSH could not read data"); + return -1; + } + + /* + * If we can't get anything out of stdout, it's typically a + * not-found error, so read from stderr and signal EOF on + * stderr. + */ + if (rc == 0) { + if ((rc = libssh2_channel_read_stderr(s->channel, buffer, buf_size)) > 0) { + git_error_set(GIT_ERROR_SSH, "%*s", rc, buffer); + return GIT_EEOF; + } else if (rc < LIBSSH2_ERROR_NONE) { + ssh_error(s->session, "SSH could not read stderr"); + return -1; + } + } + + + *bytes_read = rc; + + return 0; +} + +static int ssh_stream_write( + git_smart_subtransport_stream *stream, + const char *buffer, + size_t len) +{ + ssh_stream *s = GIT_CONTAINER_OF(stream, ssh_stream, parent); + size_t off = 0; + ssize_t ret = 0; + + if (!s->sent_command && send_command(s) < 0) + return -1; + + do { + ret = libssh2_channel_write(s->channel, buffer + off, len - off); + if (ret < 0) + break; + + off += ret; + + } while (off < len); + + if (ret < 0) { + ssh_error(s->session, "SSH could not write data"); + return -1; + } + + return 0; +} + +static void ssh_stream_free(git_smart_subtransport_stream *stream) +{ + ssh_stream *s = GIT_CONTAINER_OF(stream, ssh_stream, parent); + ssh_subtransport *t; + + if (!stream) + return; + + t = OWNING_SUBTRANSPORT(s); + t->current_stream = NULL; + + if (s->channel) { + libssh2_channel_close(s->channel); + libssh2_channel_free(s->channel); + s->channel = NULL; + } + + if (s->session) { + libssh2_session_disconnect(s->session, "closing transport"); + libssh2_session_free(s->session); + s->session = NULL; + } + + if (s->io) { + git_stream_close(s->io); + git_stream_free(s->io); + s->io = NULL; + } + + git_net_url_dispose(&s->url); + git__free(s); +} + +static int ssh_stream_alloc( + ssh_subtransport *t, + const char *cmd, + git_smart_subtransport_stream **stream) +{ + ssh_stream *s; + + GIT_ASSERT_ARG(stream); + + s = git__calloc(sizeof(ssh_stream), 1); + GIT_ERROR_CHECK_ALLOC(s); + + s->parent.subtransport = &t->parent; + s->parent.read = ssh_stream_read; + s->parent.write = ssh_stream_write; + s->parent.free = ssh_stream_free; + + s->cmd = cmd; + + *stream = &s->parent; + return 0; +} + +static int ssh_agent_auth(LIBSSH2_SESSION *session, git_credential_ssh_key *c) { + int rc = LIBSSH2_ERROR_NONE; + + struct libssh2_agent_publickey *curr, *prev = NULL; + + LIBSSH2_AGENT *agent = libssh2_agent_init(session); + + if (agent == NULL) + return -1; + + rc = libssh2_agent_connect(agent); + + if (rc != LIBSSH2_ERROR_NONE) { + rc = LIBSSH2_ERROR_AUTHENTICATION_FAILED; + goto shutdown; + } + + rc = libssh2_agent_list_identities(agent); + + if (rc != LIBSSH2_ERROR_NONE) + goto shutdown; + + while (1) { + rc = libssh2_agent_get_identity(agent, &curr, prev); + + if (rc < 0) + goto shutdown; + + /* rc is set to 1 whenever the ssh agent ran out of keys to check. + * Set the error code to authentication failure rather than erroring + * out with an untranslatable error code. + */ + if (rc == 1) { + rc = LIBSSH2_ERROR_AUTHENTICATION_FAILED; + goto shutdown; + } + + rc = libssh2_agent_userauth(agent, c->username, curr); + + if (rc == 0) + break; + + prev = curr; + } + +shutdown: + + if (rc != LIBSSH2_ERROR_NONE) + ssh_error(session, "error authenticating"); + + libssh2_agent_disconnect(agent); + libssh2_agent_free(agent); + + return rc; +} + +static int _git_ssh_authenticate_session( + LIBSSH2_SESSION *session, + git_credential *cred) +{ + int rc; + + do { + git_error_clear(); + switch (cred->credtype) { + case GIT_CREDENTIAL_USERPASS_PLAINTEXT: { + git_credential_userpass_plaintext *c = (git_credential_userpass_plaintext *)cred; + rc = libssh2_userauth_password(session, c->username, c->password); + break; + } + case GIT_CREDENTIAL_SSH_KEY: { + git_credential_ssh_key *c = (git_credential_ssh_key *)cred; + + if (c->privatekey) + rc = libssh2_userauth_publickey_fromfile( + session, c->username, c->publickey, + c->privatekey, c->passphrase); + else + rc = ssh_agent_auth(session, c); + + break; + } + case GIT_CREDENTIAL_SSH_CUSTOM: { + git_credential_ssh_custom *c = (git_credential_ssh_custom *)cred; + + rc = libssh2_userauth_publickey( + session, c->username, (const unsigned char *)c->publickey, + c->publickey_len, c->sign_callback, &c->payload); + break; + } + case GIT_CREDENTIAL_SSH_INTERACTIVE: { + void **abstract = libssh2_session_abstract(session); + git_credential_ssh_interactive *c = (git_credential_ssh_interactive *)cred; + + /* ideally, we should be able to set this by calling + * libssh2_session_init_ex() instead of libssh2_session_init(). + * libssh2's API is inconsistent here i.e. libssh2_userauth_publickey() + * allows you to pass the `abstract` as part of the call, whereas + * libssh2_userauth_keyboard_interactive() does not! + * + * The only way to set the `abstract` pointer is by calling + * libssh2_session_abstract(), which will replace the existing + * pointer as is done below. This is safe for now (at time of writing), + * but may not be valid in future. + */ + *abstract = c->payload; + + rc = libssh2_userauth_keyboard_interactive( + session, c->username, c->prompt_callback); + break; + } +#ifdef GIT_SSH_MEMORY_CREDENTIALS + case GIT_CREDENTIAL_SSH_MEMORY: { + git_credential_ssh_key *c = (git_credential_ssh_key *)cred; + + GIT_ASSERT(c->username); + GIT_ASSERT(c->privatekey); + + rc = libssh2_userauth_publickey_frommemory( + session, + c->username, + strlen(c->username), + c->publickey, + c->publickey ? strlen(c->publickey) : 0, + c->privatekey, + strlen(c->privatekey), + c->passphrase); + break; + } +#endif + default: + rc = LIBSSH2_ERROR_AUTHENTICATION_FAILED; + } + } while (LIBSSH2_ERROR_EAGAIN == rc || LIBSSH2_ERROR_TIMEOUT == rc); + + if (rc == LIBSSH2_ERROR_PASSWORD_EXPIRED || + rc == LIBSSH2_ERROR_AUTHENTICATION_FAILED || + rc == LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED) + return GIT_EAUTH; + + if (rc != LIBSSH2_ERROR_NONE) { + if (!git_error_last()) + ssh_error(session, "Failed to authenticate SSH session"); + return -1; + } + + return 0; +} + +static int request_creds(git_credential **out, ssh_subtransport *t, const char *user, int auth_methods) +{ + int error, no_callback = 0; + git_credential *cred = NULL; + + if (!t->owner->connect_opts.callbacks.credentials) { + no_callback = 1; + } else { + error = t->owner->connect_opts.callbacks.credentials( + &cred, + t->owner->url, + user, + auth_methods, + t->owner->connect_opts.callbacks.payload); + + if (error == GIT_PASSTHROUGH) { + no_callback = 1; + } else if (error < 0) { + return error; + } else if (!cred) { + git_error_set(GIT_ERROR_SSH, "callback failed to initialize SSH credentials"); + return -1; + } + } + + if (no_callback) { + git_error_set(GIT_ERROR_SSH, "authentication required but no callback set"); + return GIT_EAUTH; + } + + if (!(cred->credtype & auth_methods)) { + cred->free(cred); + git_error_set(GIT_ERROR_SSH, "authentication callback returned unsupported credentials type"); + return GIT_EAUTH; + } + + *out = cred; + + return 0; +} + +#define SSH_DIR ".ssh" +#define KNOWN_HOSTS_FILE "known_hosts" + +/* + * Load the known_hosts file. + * + * Returns success but leaves the output NULL if we couldn't find the file. + */ +static int load_known_hosts(LIBSSH2_KNOWNHOSTS **hosts, LIBSSH2_SESSION *session) +{ + git_str path = GIT_STR_INIT, sshdir = GIT_STR_INIT; + LIBSSH2_KNOWNHOSTS *known_hosts = NULL; + int error; + + GIT_ASSERT_ARG(hosts); + + if ((error = git_sysdir_expand_homedir_file(&sshdir, SSH_DIR)) < 0 || + (error = git_str_joinpath(&path, git_str_cstr(&sshdir), KNOWN_HOSTS_FILE)) < 0) + goto out; + + if ((known_hosts = libssh2_knownhost_init(session)) == NULL) { + ssh_error(session, "error initializing known hosts"); + error = -1; + goto out; + } + + /* + * Try to read the file and consider not finding it as not trusting the + * host rather than an error. + */ + error = libssh2_knownhost_readfile(known_hosts, git_str_cstr(&path), LIBSSH2_KNOWNHOST_FILE_OPENSSH); + if (error == LIBSSH2_ERROR_FILE) + error = 0; + if (error < 0) + ssh_error(session, "error reading known_hosts"); + +out: + *hosts = known_hosts; + + git_str_dispose(&sshdir); + git_str_dispose(&path); + + return error; +} + +static void add_hostkey_pref_if_avail( + LIBSSH2_KNOWNHOSTS *known_hosts, + const char *hostname, + int port, + git_str *prefs, + int type, + const char *type_name) +{ + struct libssh2_knownhost *host = NULL; + const char key = '\0'; + int mask = LIBSSH2_KNOWNHOST_TYPE_PLAIN | LIBSSH2_KNOWNHOST_KEYENC_RAW | type; + int error; + + error = libssh2_knownhost_checkp(known_hosts, hostname, port, &key, 1, mask, &host); + if (error == LIBSSH2_KNOWNHOST_CHECK_MISMATCH) { + if (git_str_len(prefs) > 0) { + git_str_putc(prefs, ','); + } + git_str_puts(prefs, type_name); + } +} + +/* + * We figure out what kind of key we want to ask the remote for by trying to + * look it up with a nonsense key and using that mismatch to figure out what key + * we do have stored for the host. + * + * Populates prefs with the string to pass to libssh2_session_method_pref. + */ +static void find_hostkey_preference( + LIBSSH2_KNOWNHOSTS *known_hosts, + const char *hostname, + int port, + git_str *prefs) +{ + /* + * The order here is important as it indicates the priority of what will + * be preferred. + */ +#ifdef LIBSSH2_KNOWNHOST_KEY_ED25519 + add_hostkey_pref_if_avail(known_hosts, hostname, port, prefs, LIBSSH2_KNOWNHOST_KEY_ED25519, "ssh-ed25519"); +#endif +#ifdef LIBSSH2_KNOWNHOST_KEY_ECDSA_256 + add_hostkey_pref_if_avail(known_hosts, hostname, port, prefs, LIBSSH2_KNOWNHOST_KEY_ECDSA_256, "ecdsa-sha2-nistp256"); + add_hostkey_pref_if_avail(known_hosts, hostname, port, prefs, LIBSSH2_KNOWNHOST_KEY_ECDSA_384, "ecdsa-sha2-nistp384"); + add_hostkey_pref_if_avail(known_hosts, hostname, port, prefs, LIBSSH2_KNOWNHOST_KEY_ECDSA_521, "ecdsa-sha2-nistp521"); +#endif + add_hostkey_pref_if_avail(known_hosts, hostname, port, prefs, LIBSSH2_KNOWNHOST_KEY_SSHRSA, "ssh-rsa"); +} + +static int _git_ssh_session_create( + LIBSSH2_SESSION **session, + LIBSSH2_KNOWNHOSTS **hosts, + const char *hostname, + int port, + git_stream *io) +{ + git_socket_stream *socket = GIT_CONTAINER_OF(io, git_socket_stream, parent); + LIBSSH2_SESSION *s; + LIBSSH2_KNOWNHOSTS *known_hosts; + git_str prefs = GIT_STR_INIT; + int rc = 0; + + GIT_ASSERT_ARG(session); + GIT_ASSERT_ARG(hosts); + + s = libssh2_session_init(); + if (!s) { + git_error_set(GIT_ERROR_NET, "failed to initialize SSH session"); + return -1; + } + + if ((rc = load_known_hosts(&known_hosts, s)) < 0) { + ssh_error(s, "error loading known_hosts"); + libssh2_session_free(s); + return -1; + } + + find_hostkey_preference(known_hosts, hostname, port, &prefs); + if (git_str_len(&prefs) > 0) { + do { + rc = libssh2_session_method_pref(s, LIBSSH2_METHOD_HOSTKEY, git_str_cstr(&prefs)); + } while (LIBSSH2_ERROR_EAGAIN == rc || LIBSSH2_ERROR_TIMEOUT == rc); + if (rc != LIBSSH2_ERROR_NONE) { + ssh_error(s, "failed to set hostkey preference"); + goto on_error; + } + } + git_str_dispose(&prefs); + + do { + rc = libssh2_session_handshake(s, socket->s); + } while (LIBSSH2_ERROR_EAGAIN == rc || LIBSSH2_ERROR_TIMEOUT == rc); + + if (rc != LIBSSH2_ERROR_NONE) { + ssh_error(s, "failed to start SSH session"); + goto on_error; + } + + libssh2_session_set_blocking(s, 1); + + *session = s; + *hosts = known_hosts; + + return 0; + +on_error: + libssh2_knownhost_free(known_hosts); + libssh2_session_free(s); + return -1; +} + + +/* + * Returns the typemask argument to pass to libssh2_knownhost_check{,p} based on + * the type of key that libssh2_session_hostkey returns. + */ +static int fingerprint_type_mask(int keytype) +{ + int mask = LIBSSH2_KNOWNHOST_TYPE_PLAIN | LIBSSH2_KNOWNHOST_KEYENC_RAW; + return mask; + + switch (keytype) { + case LIBSSH2_HOSTKEY_TYPE_RSA: + mask |= LIBSSH2_KNOWNHOST_KEY_SSHRSA; + break; + case LIBSSH2_HOSTKEY_TYPE_DSS: + mask |= LIBSSH2_KNOWNHOST_KEY_SSHDSS; + break; +#ifdef LIBSSH2_HOSTKEY_TYPE_ECDSA_256 + case LIBSSH2_HOSTKEY_TYPE_ECDSA_256: + mask |= LIBSSH2_KNOWNHOST_KEY_ECDSA_256; + break; + case LIBSSH2_HOSTKEY_TYPE_ECDSA_384: + mask |= LIBSSH2_KNOWNHOST_KEY_ECDSA_384; + break; + case LIBSSH2_HOSTKEY_TYPE_ECDSA_521: + mask |= LIBSSH2_KNOWNHOST_KEY_ECDSA_521; + break; +#endif +#ifdef LIBSSH2_HOSTKEY_TYPE_ED25519 + case LIBSSH2_HOSTKEY_TYPE_ED25519: + mask |= LIBSSH2_KNOWNHOST_KEY_ED25519; + break; +#endif + } + + return mask; +} + +/* + * Check the host against the user's known_hosts file. + * + * Returns 1/0 for valid/''not-valid or <0 for an error + */ +static int check_against_known_hosts( + LIBSSH2_SESSION *session, + LIBSSH2_KNOWNHOSTS *known_hosts, + const char *hostname, + int port, + const char *key, + size_t key_len, + int key_type) +{ + int check, typemask, ret = 0; + struct libssh2_knownhost *host = NULL; + + if (known_hosts == NULL) + return 0; + + typemask = fingerprint_type_mask(key_type); + check = libssh2_knownhost_checkp(known_hosts, hostname, port, key, key_len, typemask, &host); + if (check == LIBSSH2_KNOWNHOST_CHECK_FAILURE) { + ssh_error(session, "error checking for known host"); + return -1; + } + + ret = check == LIBSSH2_KNOWNHOST_CHECK_MATCH ? 1 : 0; + + return ret; +} + +/* + * Perform the check for the session's certificate against known hosts if + * possible and then ask the user if they have a callback. + * + * Returns 1/0 for valid/not-valid or <0 for an error + */ +static int check_certificate( + LIBSSH2_SESSION *session, + LIBSSH2_KNOWNHOSTS *known_hosts, + git_transport_certificate_check_cb check_cb, + void *check_cb_payload, + const char *host, + int port) +{ + git_cert_hostkey cert = {{ 0 }}; + const char *key; + size_t cert_len; + int cert_type, cert_valid = 0, error = 0; + + if ((key = libssh2_session_hostkey(session, &cert_len, &cert_type)) == NULL) { + ssh_error(session, "failed to retrieve hostkey"); + return -1; + } + + if ((cert_valid = check_against_known_hosts(session, known_hosts, host, port, key, cert_len, cert_type)) < 0) + return -1; + + cert.parent.cert_type = GIT_CERT_HOSTKEY_LIBSSH2; + if (key != NULL) { + cert.type |= GIT_CERT_SSH_RAW; + cert.hostkey = key; + cert.hostkey_len = cert_len; + switch (cert_type) { + case LIBSSH2_HOSTKEY_TYPE_RSA: + cert.raw_type = GIT_CERT_SSH_RAW_TYPE_RSA; + break; + case LIBSSH2_HOSTKEY_TYPE_DSS: + cert.raw_type = GIT_CERT_SSH_RAW_TYPE_DSS; + break; + +#ifdef LIBSSH2_HOSTKEY_TYPE_ECDSA_256 + case LIBSSH2_HOSTKEY_TYPE_ECDSA_256: + cert.raw_type = GIT_CERT_SSH_RAW_TYPE_KEY_ECDSA_256; + break; + case LIBSSH2_HOSTKEY_TYPE_ECDSA_384: + cert.raw_type = GIT_CERT_SSH_RAW_TYPE_KEY_ECDSA_384; + break; + case LIBSSH2_KNOWNHOST_KEY_ECDSA_521: + cert.raw_type = GIT_CERT_SSH_RAW_TYPE_KEY_ECDSA_521; + break; +#endif + +#ifdef LIBSSH2_HOSTKEY_TYPE_ED25519 + case LIBSSH2_HOSTKEY_TYPE_ED25519: + cert.raw_type = GIT_CERT_SSH_RAW_TYPE_KEY_ED25519; + break; +#endif + default: + cert.raw_type = GIT_CERT_SSH_RAW_TYPE_UNKNOWN; + } + } + +#ifdef LIBSSH2_HOSTKEY_HASH_SHA256 + key = libssh2_hostkey_hash(session, LIBSSH2_HOSTKEY_HASH_SHA256); + if (key != NULL) { + cert.type |= GIT_CERT_SSH_SHA256; + memcpy(&cert.hash_sha256, key, 32); + } +#endif + + key = libssh2_hostkey_hash(session, LIBSSH2_HOSTKEY_HASH_SHA1); + if (key != NULL) { + cert.type |= GIT_CERT_SSH_SHA1; + memcpy(&cert.hash_sha1, key, 20); + } + + key = libssh2_hostkey_hash(session, LIBSSH2_HOSTKEY_HASH_MD5); + if (key != NULL) { + cert.type |= GIT_CERT_SSH_MD5; + memcpy(&cert.hash_md5, key, 16); + } + + if (cert.type == 0) { + git_error_set(GIT_ERROR_SSH, "unable to get the host key"); + return -1; + } + + git_error_clear(); + error = 0; + if (!cert_valid) { + git_error_set(GIT_ERROR_SSH, "invalid or unknown remote ssh hostkey"); + error = GIT_ECERTIFICATE; + } + + if (check_cb != NULL) { + git_cert_hostkey *cert_ptr = &cert; + git_error_state previous_error = {0}; + + git_error_state_capture(&previous_error, error); + error = check_cb((git_cert *) cert_ptr, cert_valid, host, check_cb_payload); + if (error == GIT_PASSTHROUGH) { + error = git_error_state_restore(&previous_error); + } else if (error < 0 && !git_error_last()) { + git_error_set(GIT_ERROR_NET, "unknown remote host key"); + } + + git_error_state_free(&previous_error); + } + + return error; +} + +#define SSH_DEFAULT_PORT "22" + +static int _git_ssh_setup_conn( + ssh_subtransport *t, + const char *url, + const char *cmd, + git_smart_subtransport_stream **stream) +{ + int auth_methods, error = 0, port; + ssh_stream *s; + git_credential *cred = NULL; + LIBSSH2_SESSION *session=NULL; + LIBSSH2_CHANNEL *channel=NULL; + LIBSSH2_KNOWNHOSTS *known_hosts = NULL; + + t->current_stream = NULL; + + *stream = NULL; + if (ssh_stream_alloc(t, cmd, stream) < 0) + return -1; + + s = (ssh_stream *)*stream; + s->session = NULL; + s->channel = NULL; + + if (git_net_str_is_url(url)) + error = git_net_url_parse(&s->url, url); + else + error = git_net_url_parse_scp(&s->url, url); + + if (error < 0) + goto done; + + if ((error = git_socket_stream_new(&s->io, s->url.host, s->url.port)) < 0 || + (error = git_stream_connect(s->io)) < 0) + goto done; + + /* + * Try to parse the port as a number, if we can't then fall back to + * default. It would be nice if we could get the port that was resolved + * as part of the stream connection, but that's not something that's + * exposed. + */ + if (git__strntol32(&port, s->url.port, strlen(s->url.port), NULL, 10) < 0) + port = -1; + + if ((error = _git_ssh_session_create(&session, &known_hosts, s->url.host, port, s->io)) < 0) + goto done; + + if ((error = check_certificate(session, known_hosts, t->owner->connect_opts.callbacks.certificate_check, t->owner->connect_opts.callbacks.payload, s->url.host, port)) < 0) + goto done; + + /* we need the username to ask for auth methods */ + if (!s->url.username) { + if ((error = request_creds(&cred, t, NULL, GIT_CREDENTIAL_USERNAME)) < 0) + goto done; + + s->url.username = git__strdup(((git_credential_username *) cred)->username); + cred->free(cred); + cred = NULL; + if (!s->url.username) + goto done; + } else if (s->url.username && s->url.password) { + if ((error = git_credential_userpass_plaintext_new(&cred, s->url.username, s->url.password)) < 0) + goto done; + } + + if ((error = list_auth_methods(&auth_methods, session, s->url.username)) < 0) + goto done; + + error = GIT_EAUTH; + /* if we already have something to try */ + if (cred && auth_methods & cred->credtype) + error = _git_ssh_authenticate_session(session, cred); + + while (error == GIT_EAUTH) { + if (cred) { + cred->free(cred); + cred = NULL; + } + + if ((error = request_creds(&cred, t, s->url.username, auth_methods)) < 0) + goto done; + + if (strcmp(s->url.username, git_credential_get_username(cred))) { + git_error_set(GIT_ERROR_SSH, "username does not match previous request"); + error = -1; + goto done; + } + + error = _git_ssh_authenticate_session(session, cred); + + if (error == GIT_EAUTH) { + /* refresh auth methods */ + if ((error = list_auth_methods(&auth_methods, session, s->url.username)) < 0) + goto done; + else + error = GIT_EAUTH; + } + } + + if (error < 0) + goto done; + + channel = libssh2_channel_open_session(session); + if (!channel) { + error = -1; + ssh_error(session, "Failed to open SSH channel"); + goto done; + } + + libssh2_channel_set_blocking(channel, 1); + + s->session = session; + s->channel = channel; + + t->current_stream = s; + +done: + if (known_hosts) + libssh2_knownhost_free(known_hosts); + + if (error < 0) { + ssh_stream_free(*stream); + + if (session) + libssh2_session_free(session); + } + + if (cred) + cred->free(cred); + + return error; +} + +static int ssh_uploadpack_ls( + ssh_subtransport *t, + const char *url, + git_smart_subtransport_stream **stream) +{ + const char *cmd = t->cmd_uploadpack ? t->cmd_uploadpack : cmd_uploadpack; + + return _git_ssh_setup_conn(t, url, cmd, stream); +} + +static int ssh_uploadpack( + ssh_subtransport *t, + const char *url, + git_smart_subtransport_stream **stream) +{ + GIT_UNUSED(url); + + if (t->current_stream) { + *stream = &t->current_stream->parent; + return 0; + } + + git_error_set(GIT_ERROR_NET, "must call UPLOADPACK_LS before UPLOADPACK"); + return -1; +} + +static int ssh_receivepack_ls( + ssh_subtransport *t, + const char *url, + git_smart_subtransport_stream **stream) +{ + const char *cmd = t->cmd_receivepack ? t->cmd_receivepack : cmd_receivepack; + + + return _git_ssh_setup_conn(t, url, cmd, stream); +} + +static int ssh_receivepack( + ssh_subtransport *t, + const char *url, + git_smart_subtransport_stream **stream) +{ + GIT_UNUSED(url); + + if (t->current_stream) { + *stream = &t->current_stream->parent; + return 0; + } + + git_error_set(GIT_ERROR_NET, "must call RECEIVEPACK_LS before RECEIVEPACK"); + return -1; +} + +static int _ssh_action( + git_smart_subtransport_stream **stream, + git_smart_subtransport *subtransport, + const char *url, + git_smart_service_t action) +{ + ssh_subtransport *t = GIT_CONTAINER_OF(subtransport, ssh_subtransport, parent); + + switch (action) { + case GIT_SERVICE_UPLOADPACK_LS: + return ssh_uploadpack_ls(t, url, stream); + + case GIT_SERVICE_UPLOADPACK: + return ssh_uploadpack(t, url, stream); + + case GIT_SERVICE_RECEIVEPACK_LS: + return ssh_receivepack_ls(t, url, stream); + + case GIT_SERVICE_RECEIVEPACK: + return ssh_receivepack(t, url, stream); + } + + *stream = NULL; + return -1; +} + +static int _ssh_close(git_smart_subtransport *subtransport) +{ + ssh_subtransport *t = GIT_CONTAINER_OF(subtransport, ssh_subtransport, parent); + + GIT_ASSERT(!t->current_stream); + + GIT_UNUSED(t); + + return 0; +} + +static void _ssh_free(git_smart_subtransport *subtransport) +{ + ssh_subtransport *t = GIT_CONTAINER_OF(subtransport, ssh_subtransport, parent); + + git__free(t->cmd_uploadpack); + git__free(t->cmd_receivepack); + git__free(t); +} + +#define SSH_AUTH_PUBLICKEY "publickey" +#define SSH_AUTH_PASSWORD "password" +#define SSH_AUTH_KEYBOARD_INTERACTIVE "keyboard-interactive" + +static int list_auth_methods(int *out, LIBSSH2_SESSION *session, const char *username) +{ + const char *list, *ptr; + + *out = 0; + + list = libssh2_userauth_list(session, username, strlen(username)); + + /* either error, or the remote accepts NONE auth, which is bizarre, let's punt */ + if (list == NULL && !libssh2_userauth_authenticated(session)) { + ssh_error(session, "remote rejected authentication"); + return GIT_EAUTH; + } + + ptr = list; + while (ptr) { + if (*ptr == ',') + ptr++; + + if (!git__prefixcmp(ptr, SSH_AUTH_PUBLICKEY)) { + *out |= GIT_CREDENTIAL_SSH_KEY; + *out |= GIT_CREDENTIAL_SSH_CUSTOM; +#ifdef GIT_SSH_MEMORY_CREDENTIALS + *out |= GIT_CREDENTIAL_SSH_MEMORY; +#endif + ptr += strlen(SSH_AUTH_PUBLICKEY); + continue; + } + + if (!git__prefixcmp(ptr, SSH_AUTH_PASSWORD)) { + *out |= GIT_CREDENTIAL_USERPASS_PLAINTEXT; + ptr += strlen(SSH_AUTH_PASSWORD); + continue; + } + + if (!git__prefixcmp(ptr, SSH_AUTH_KEYBOARD_INTERACTIVE)) { + *out |= GIT_CREDENTIAL_SSH_INTERACTIVE; + ptr += strlen(SSH_AUTH_KEYBOARD_INTERACTIVE); + continue; + } + + /* Skip it if we don't know it */ + ptr = strchr(ptr, ','); + } + + return 0; +} + +int git_smart_subtransport_ssh_libssh2( + git_smart_subtransport **out, + git_transport *owner, + void *param) +{ + ssh_subtransport *t; + + GIT_ASSERT_ARG(out); + + GIT_UNUSED(param); + + t = git__calloc(sizeof(ssh_subtransport), 1); + GIT_ERROR_CHECK_ALLOC(t); + + t->owner = (transport_smart *)owner; + t->parent.action = _ssh_action; + t->parent.close = _ssh_close; + t->parent.free = _ssh_free; + + *out = (git_smart_subtransport *) t; + return 0; +} + +int git_smart_subtransport_ssh_libssh2_set_paths( + git_smart_subtransport *subtransport, + const char *cmd_uploadpack, + const char *cmd_receivepack) +{ + ssh_subtransport *t = (ssh_subtransport *)subtransport; + + git__free(t->cmd_uploadpack); + git__free(t->cmd_receivepack); + + t->cmd_uploadpack = git__strdup(cmd_uploadpack); + GIT_ERROR_CHECK_ALLOC(t->cmd_uploadpack); + + t->cmd_receivepack = git__strdup(cmd_receivepack); + GIT_ERROR_CHECK_ALLOC(t->cmd_receivepack); + + return 0; +} + +static void shutdown_libssh2(void) +{ + libssh2_exit(); +} + +int git_transport_ssh_libssh2_global_init(void) +{ + if (libssh2_init(0) < 0) { + git_error_set(GIT_ERROR_SSH, "unable to initialize libssh2"); + return -1; + } + + return git_runtime_shutdown_register(shutdown_libssh2); +} + +#else /* GIT_SSH */ + +int git_transport_ssh_libssh2_global_init(void) +{ + return 0; +} + +#endif diff --git a/src/libgit2/transports/ssh_libssh2.h b/src/libgit2/transports/ssh_libssh2.h new file mode 100644 index 00000000000..3f8cc2a8ad9 --- /dev/null +++ b/src/libgit2/transports/ssh_libssh2.h @@ -0,0 +1,28 @@ +/* + * Copyright (C) the libgit2 contributors. All rights reserved. + * + * This file is part of libgit2, distributed under the GNU GPL v2 with + * a Linking Exception. For full terms see the included COPYING file. + */ +#ifndef INCLUDE_transports_libssh2_h__ +#define INCLUDE_transports_libssh2_h__ + +#include "common.h" + +#include "git2.h" +#include "git2/transport.h" +#include "git2/sys/transport.h" + +int git_transport_ssh_libssh2_global_init(void); + +int git_smart_subtransport_ssh_libssh2( + git_smart_subtransport **out, + git_transport *owner, + void *param); + +int git_smart_subtransport_ssh_libssh2_set_paths( + git_smart_subtransport *subtransport, + const char *cmd_uploadpack, + const char *cmd_receivepack); + +#endif From 3fccf7468ba7a9a9f764984435db83f4588ec905 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 24 Feb 2023 00:30:50 +0000 Subject: [PATCH 344/608] ssh: GIT_SSH_LIBSSH2 is now distinct from GIT_SSH We may want to support SSH but with a different provider that is not libssh2. Add GIT_SSH to indicate that we have some inbuilt SSH support and GIT_SSH_LIBSSH2 to indicate that support is via libssh2. This is similar to how we support GIT_HTTPS and GIT_OPENSSL, for example. --- CMakeLists.txt | 2 +- cmake/SelectSSH.cmake | 33 ++++++++++++++-------------- src/libgit2/libgit2.c | 4 ++-- src/libgit2/transport.c | 3 +++ src/libgit2/transports/credential.c | 2 +- src/libgit2/transports/ssh.c | 4 ++-- src/libgit2/transports/ssh_libssh2.c | 6 ++--- src/util/git2_features.h.in | 3 ++- tests/libgit2/online/clone.c | 4 ++-- 9 files changed, 32 insertions(+), 29 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 81e2bc8aca1..17ca7576834 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -30,7 +30,7 @@ option(USE_THREADS "Use threads for parallel processing when possibl option(USE_NSEC "Support nanosecond precision file mtimes and ctimes" ON) # Backend selection -option(USE_SSH "Link with libssh2 to enable SSH support" OFF) +option(USE_SSH "Enable SSH support. Can be set to a specific backend" OFF) option(USE_HTTPS "Enable HTTPS support. Can be set to a specific backend" ON) option(USE_SHA1 "Enable SHA1. Can be set to CollisionDetection(ON)/HTTPS" ON) option(USE_SHA256 "Enable SHA256. Can be set to HTTPS/Builtin" ON) diff --git a/cmake/SelectSSH.cmake b/cmake/SelectSSH.cmake index 23dfc978521..ae9619900b6 100644 --- a/cmake/SelectSSH.cmake +++ b/cmake/SelectSSH.cmake @@ -1,6 +1,7 @@ -# Optional external dependency: libssh2 -if(USE_SSH) +# find libssh2 +if(USE_SSH STREQUAL ON OR USE_SSH STREQUAL "libssh2") find_pkglibraries(LIBSSH2 libssh2) + if(NOT LIBSSH2_FOUND) find_package(LibSSH2) set(LIBSSH2_INCLUDE_DIRS ${LIBSSH2_INCLUDE_DIR}) @@ -12,30 +13,28 @@ if(USE_SSH) if(NOT LIBSSH2_FOUND) message(FATAL_ERROR "LIBSSH2 not found. Set CMAKE_PREFIX_PATH if it is installed outside of the default search path.") endif() -endif() -if(LIBSSH2_FOUND) - set(GIT_SSH 1) list(APPEND LIBGIT2_SYSTEM_INCLUDES ${LIBSSH2_INCLUDE_DIRS}) list(APPEND LIBGIT2_SYSTEM_LIBS ${LIBSSH2_LIBRARIES}) list(APPEND LIBGIT2_PC_LIBS ${LIBSSH2_LDFLAGS}) check_library_exists("${LIBSSH2_LIBRARIES}" libssh2_userauth_publickey_frommemory "${LIBSSH2_LIBRARY_DIRS}" HAVE_LIBSSH2_MEMORY_CREDENTIALS) if(HAVE_LIBSSH2_MEMORY_CREDENTIALS) - set(GIT_SSH_MEMORY_CREDENTIALS 1) + set(GIT_SSH_LIBSSH2_MEMORY_CREDENTIALS 1) endif() -else() - message(STATUS "LIBSSH2 not found. Set CMAKE_PREFIX_PATH if it is installed outside of the default search path.") -endif() -if(WIN32 AND EMBED_SSH_PATH) - file(GLOB SSH_SRC "${EMBED_SSH_PATH}/src/*.c") - list(SORT SSH_SRC) - list(APPEND LIBGIT2_DEPENDENCY_OBJECTS ${SSH_SRC}) + if(WIN32 AND EMBED_SSH_PATH) + file(GLOB SSH_SRC "${EMBED_SSH_PATH}/src/*.c") + list(SORT SSH_SRC) + list(APPEND LIBGIT2_DEPENDENCY_OBJECTS ${SSH_SRC}) + + list(APPEND LIBGIT2_DEPENDENCY_INCLUDES "${EMBED_SSH_PATH}/include") + file(WRITE "${EMBED_SSH_PATH}/src/libssh2_config.h" "#define HAVE_WINCNG\n#define LIBSSH2_WINCNG\n#include \"../win32/libssh2_config.h\"") + endif() - list(APPEND LIBGIT2_DEPENDENCY_INCLUDES "${EMBED_SSH_PATH}/include") - file(WRITE "${EMBED_SSH_PATH}/src/libssh2_config.h" "#define HAVE_WINCNG\n#define LIBSSH2_WINCNG\n#include \"../win32/libssh2_config.h\"") set(GIT_SSH 1) + set(GIT_SSH_LIBSSH2 1) + add_feature_info(SSH ON "using libssh2") +else() + add_feature_info(SSH OFF "SSH transport support") endif() - -add_feature_info(SSH GIT_SSH "SSH transport support") diff --git a/src/libgit2/libgit2.c b/src/libgit2/libgit2.c index 56b90321f4a..ec4a699a2ee 100644 --- a/src/libgit2/libgit2.c +++ b/src/libgit2/libgit2.c @@ -126,10 +126,10 @@ int git_libgit2_features(void) #ifdef GIT_HTTPS | GIT_FEATURE_HTTPS #endif -#if defined(GIT_SSH) +#ifdef GIT_SSH | GIT_FEATURE_SSH #endif -#if defined(GIT_USE_NSEC) +#ifdef GIT_USE_NSEC | GIT_FEATURE_NSEC #endif ; diff --git a/src/libgit2/transport.c b/src/libgit2/transport.c index 640ccacaee3..c61d0a68b7e 100644 --- a/src/libgit2/transport.c +++ b/src/libgit2/transport.c @@ -22,6 +22,7 @@ typedef struct transport_definition { static git_smart_subtransport_definition http_subtransport_definition = { git_smart_subtransport_http, 1, NULL }; static git_smart_subtransport_definition git_subtransport_definition = { git_smart_subtransport_git, 0, NULL }; + #ifdef GIT_SSH static git_smart_subtransport_definition ssh_subtransport_definition = { git_smart_subtransport_ssh, 0, NULL }; #endif @@ -33,11 +34,13 @@ static transport_definition transports[] = { { "http://", git_transport_smart, &http_subtransport_definition }, { "https://", git_transport_smart, &http_subtransport_definition }, { "file://", git_transport_local, NULL }, + #ifdef GIT_SSH { "ssh://", git_transport_smart, &ssh_subtransport_definition }, { "ssh+git://", git_transport_smart, &ssh_subtransport_definition }, { "git+ssh://", git_transport_smart, &ssh_subtransport_definition }, #endif + { NULL, 0, 0 } }; diff --git a/src/libgit2/transports/credential.c b/src/libgit2/transports/credential.c index 6e00b028243..b47bd63a198 100644 --- a/src/libgit2/transports/credential.c +++ b/src/libgit2/transports/credential.c @@ -204,7 +204,7 @@ int git_credential_ssh_key_memory_new( const char *privatekey, const char *passphrase) { -#ifdef GIT_SSH_MEMORY_CREDENTIALS +#ifdef GIT_SSH_LIBSSH2_MEMORY_CREDENTIALS return git_credential_ssh_key_type_new( cred, username, diff --git a/src/libgit2/transports/ssh.c b/src/libgit2/transports/ssh.c index bef0b14409f..7171e9cb3a8 100644 --- a/src/libgit2/transports/ssh.c +++ b/src/libgit2/transports/ssh.c @@ -14,7 +14,7 @@ int git_smart_subtransport_ssh( git_transport *owner, void *param) { -#ifdef GIT_SSH +#ifdef GIT_SSH_LIBSSH2 return git_smart_subtransport_ssh_libssh2(out, owner, param); #else GIT_UNUSED(out); @@ -31,7 +31,7 @@ int git_transport_ssh_with_paths( git_remote *owner, void *payload) { -#ifdef GIT_SSH +#ifdef GIT_SSH_LIBSSH2 git_strarray *paths = (git_strarray *) payload; git_transport *transport; transport_smart *smart; diff --git a/src/libgit2/transports/ssh_libssh2.c b/src/libgit2/transports/ssh_libssh2.c index 154d022944b..76c08c2e1a5 100644 --- a/src/libgit2/transports/ssh_libssh2.c +++ b/src/libgit2/transports/ssh_libssh2.c @@ -7,7 +7,7 @@ #include "ssh_libssh2.h" -#ifdef GIT_SSH +#ifdef GIT_SSH_LIBSSH2 #include @@ -342,7 +342,7 @@ static int _git_ssh_authenticate_session( session, c->username, c->prompt_callback); break; } -#ifdef GIT_SSH_MEMORY_CREDENTIALS +#ifdef GIT_SSH_LIBSSH2_MEMORY_CREDENTIALS case GIT_CREDENTIAL_SSH_MEMORY: { git_credential_ssh_key *c = (git_credential_ssh_key *)cred; @@ -1020,7 +1020,7 @@ static int list_auth_methods(int *out, LIBSSH2_SESSION *session, const char *use if (!git__prefixcmp(ptr, SSH_AUTH_PUBLICKEY)) { *out |= GIT_CREDENTIAL_SSH_KEY; *out |= GIT_CREDENTIAL_SSH_CUSTOM; -#ifdef GIT_SSH_MEMORY_CREDENTIALS +#ifdef GIT_SSH_LIBSSH2_MEMORY_CREDENTIALS *out |= GIT_CREDENTIAL_SSH_MEMORY; #endif ptr += strlen(SSH_AUTH_PUBLICKEY); diff --git a/src/util/git2_features.h.in b/src/util/git2_features.h.in index a84ea895635..21399116df0 100644 --- a/src/util/git2_features.h.in +++ b/src/util/git2_features.h.in @@ -30,7 +30,8 @@ #cmakedefine GIT_QSORT_MSC #cmakedefine GIT_SSH 1 -#cmakedefine GIT_SSH_MEMORY_CREDENTIALS 1 +#cmakedefine GIT_SSH_LIBSSH2 1 +#cmakedefine GIT_SSH_LIBSSH2_MEMORY_CREDENTIALS 1 #cmakedefine GIT_NTLM 1 #cmakedefine GIT_GSSAPI 1 diff --git a/tests/libgit2/online/clone.c b/tests/libgit2/online/clone.c index 5789e9654c3..ea47b89985a 100644 --- a/tests/libgit2/online/clone.c +++ b/tests/libgit2/online/clone.c @@ -675,7 +675,7 @@ void test_online_clone__ssh_auth_methods(void) */ void test_online_clone__ssh_certcheck_accepts_unknown(void) { -#if !defined(GIT_SSH) || !defined(GIT_SSH_MEMORY_CREDENTIALS) +#if !defined(GIT_SSH_LIBSSH2) || !defined(GIT_SSH_MEMORY_CREDENTIALS) clar__skip(); #endif @@ -793,7 +793,7 @@ static int cred_foo_bar(git_credential **cred, const char *url, const char *user void test_online_clone__ssh_cannot_change_username(void) { -#ifndef GIT_SSH +#ifndef GIT_SSH_LIBSSH2 clar__skip(); #endif g_options.fetch_opts.callbacks.credentials = cred_foo_bar; From a8b052faab34db9d8b8a4ea620545a8155e06bed Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 24 Feb 2023 00:34:06 +0000 Subject: [PATCH 345/608] ssh: introduce GIT_SSH_EXEC for external OpenSSH We can now use the `git_process` class to invoke OpenSSH and use it as an SSH transport. This may be preferred over libssh2 for a variety of callers. --- cmake/SelectSSH.cmake | 8 +- src/libgit2/transports/ssh.c | 3 + src/libgit2/transports/ssh_exec.c | 273 ++++++++++++++++++++++++++++++ src/libgit2/transports/ssh_exec.h | 26 +++ src/util/git2_features.h.in | 1 + 5 files changed, 309 insertions(+), 2 deletions(-) create mode 100644 src/libgit2/transports/ssh_exec.c create mode 100644 src/libgit2/transports/ssh_exec.h diff --git a/cmake/SelectSSH.cmake b/cmake/SelectSSH.cmake index ae9619900b6..079857f502b 100644 --- a/cmake/SelectSSH.cmake +++ b/cmake/SelectSSH.cmake @@ -1,5 +1,9 @@ -# find libssh2 -if(USE_SSH STREQUAL ON OR USE_SSH STREQUAL "libssh2") +if(USE_SSH STREQUAL "exec") + set(GIT_SSH 1) + set(GIT_SSH_EXEC 1) + + add_feature_info(SSH ON "using OpenSSH exec support") +elseif(USE_SSH STREQUAL ON OR USE_SSH STREQUAL "libssh2") find_pkglibraries(LIBSSH2 libssh2) if(NOT LIBSSH2_FOUND) diff --git a/src/libgit2/transports/ssh.c b/src/libgit2/transports/ssh.c index 7171e9cb3a8..98e1be2d131 100644 --- a/src/libgit2/transports/ssh.c +++ b/src/libgit2/transports/ssh.c @@ -5,6 +5,7 @@ * a Linking Exception. For full terms see the included COPYING file. */ +#include "ssh_exec.h" #include "ssh_libssh2.h" #include "transports/smart.h" @@ -16,6 +17,8 @@ int git_smart_subtransport_ssh( { #ifdef GIT_SSH_LIBSSH2 return git_smart_subtransport_ssh_libssh2(out, owner, param); +#elif GIT_SSH_EXEC + return git_smart_subtransport_ssh_exec(out, owner, param); #else GIT_UNUSED(out); GIT_UNUSED(owner); diff --git a/src/libgit2/transports/ssh_exec.c b/src/libgit2/transports/ssh_exec.c new file mode 100644 index 00000000000..2b2c8a08eb2 --- /dev/null +++ b/src/libgit2/transports/ssh_exec.c @@ -0,0 +1,273 @@ +/* + * Copyright (C) the libgit2 contributors. All rights reserved. + * + * This file is part of libgit2, distributed under the GNU GPL v2 with + * a Linking Exception. For full terms see the included COPYING file. + */ + +#include "ssh_exec.h" + +#ifdef GIT_SSH_EXEC + +#include "common.h" + +#include "net.h" +#include "path.h" +#include "futils.h" +#include "process.h" + +typedef struct { + git_smart_subtransport_stream parent; +} ssh_exec_subtransport_stream; + +typedef struct { + git_smart_subtransport parent; + git_transport *owner; + + ssh_exec_subtransport_stream *current_stream; + + git_smart_service_t action; + git_process *process; +} ssh_exec_subtransport; + +static int ssh_exec_subtransport_stream_read( + git_smart_subtransport_stream *s, + char *buffer, + size_t buf_size, + size_t *bytes_read) +{ + ssh_exec_subtransport *transport; + ssh_exec_subtransport_stream *stream = (ssh_exec_subtransport_stream *)s; + ssize_t ret; + + GIT_ASSERT_ARG(stream); + GIT_ASSERT(stream->parent.subtransport); + + transport = (ssh_exec_subtransport *)stream->parent.subtransport; + + if ((ret = git_process_read(transport->process, buffer, buf_size)) < 0) + return (int)ret; + + *bytes_read = (size_t)ret; + return 0; +} + +static int ssh_exec_subtransport_stream_write( + git_smart_subtransport_stream *s, + const char *buffer, + size_t len) +{ + ssh_exec_subtransport *transport; + ssh_exec_subtransport_stream *stream = (ssh_exec_subtransport_stream *)s; + ssize_t ret; + + GIT_ASSERT(stream && stream->parent.subtransport); + + transport = (ssh_exec_subtransport *)stream->parent.subtransport; + + while (len > 0) { + if ((ret = git_process_write(transport->process, buffer, len)) < 0) + return (int)ret; + + len -= ret; + } + + return 0; +} + +static void ssh_exec_subtransport_stream_free(git_smart_subtransport_stream *s) +{ + ssh_exec_subtransport_stream *stream = (ssh_exec_subtransport_stream *)s; + + git__free(stream); +} + +static int ssh_exec_subtransport_stream_init( + ssh_exec_subtransport_stream **out, + ssh_exec_subtransport *transport) +{ + GIT_ASSERT_ARG(out); + + *out = git__calloc(sizeof(ssh_exec_subtransport_stream), 1); + GIT_ERROR_CHECK_ALLOC(*out); + + (*out)->parent.subtransport = &transport->parent; + (*out)->parent.read = ssh_exec_subtransport_stream_read; + (*out)->parent.write = ssh_exec_subtransport_stream_write; + (*out)->parent.free = ssh_exec_subtransport_stream_free; + + return 0; +} + +GIT_INLINE(int) ensure_transport_state( + ssh_exec_subtransport *transport, + git_smart_service_t expected, + git_smart_service_t next) +{ + if (transport->action != expected && transport->action != next) { + git_error_set(GIT_ERROR_NET, "invalid transport state"); + + return -1; + } + + return 0; +} + +static int start_ssh( + ssh_exec_subtransport *transport, + git_smart_service_t action, + const char *sshpath) +{ + const char *args[6]; + const char *env[] = { "GIT_DIR=" }; + + git_process_options process_opts = GIT_PROCESS_OPTIONS_INIT; + git_net_url url = GIT_NET_URL_INIT; + git_str userhost = GIT_STR_INIT; + const char *command; + int error; + + process_opts.capture_in = 1; + process_opts.capture_out = 1; + process_opts.capture_err = 1; + + switch (action) { + case GIT_SERVICE_UPLOADPACK_LS: + command = "git-upload-pack"; + break; + case GIT_SERVICE_RECEIVEPACK_LS: + command = "git-receive-pack"; + break; + default: + git_error_set(GIT_ERROR_NET, "invalid action"); + error = -1; + goto done; + } + + if (git_net_str_is_url(sshpath)) + error = git_net_url_parse(&url, sshpath); + else + error = git_net_url_parse_scp(&url, sshpath); + + if (error < 0) + goto done; + + if (url.username) { + git_str_puts(&userhost, url.username); + git_str_putc(&userhost, '@'); + } + git_str_puts(&userhost, url.host); + + args[0] = "/usr/bin/ssh"; + args[1] = "-p"; + args[2] = url.port; + args[3] = userhost.ptr; + args[4] = command; + args[5] = url.path; + + if ((error = git_process_new(&transport->process, args, ARRAY_SIZE(args), env, ARRAY_SIZE(env), &process_opts)) < 0 || + (error = git_process_start(transport->process)) < 0) { + git_process_free(transport->process); + transport->process = NULL; + goto done; + } + +done: + git_str_dispose(&userhost); + git_net_url_dispose(&url); + return error; +} + +static int ssh_exec_subtransport_action( + git_smart_subtransport_stream **out, + git_smart_subtransport *t, + const char *sshpath, + git_smart_service_t action) +{ + ssh_exec_subtransport *transport = (ssh_exec_subtransport *)t; + ssh_exec_subtransport_stream *stream = NULL; + git_smart_service_t expected; + int error; + + switch (action) { + case GIT_SERVICE_UPLOADPACK_LS: + case GIT_SERVICE_RECEIVEPACK_LS: + if ((error = ensure_transport_state(transport, 0, 0)) < 0 || + (error = ssh_exec_subtransport_stream_init(&stream, transport)) < 0 || + (error = start_ssh(transport, action, sshpath)) < 0) + goto on_error; + + transport->current_stream = stream; + break; + + case GIT_SERVICE_UPLOADPACK: + case GIT_SERVICE_RECEIVEPACK: + expected = (action == GIT_SERVICE_UPLOADPACK) ? + GIT_SERVICE_UPLOADPACK_LS : GIT_SERVICE_RECEIVEPACK_LS; + + if ((error = ensure_transport_state(transport, expected, action)) < 0) + goto on_error; + + break; + + default: + git_error_set(GIT_ERROR_INVALID, "invalid service request"); + goto on_error; + } + + transport->action = action; + *out = &transport->current_stream->parent; + + return 0; + +on_error: + if (stream != NULL) + ssh_exec_subtransport_stream_free(&stream->parent); + + return -1; +} + +static int ssh_exec_subtransport_close(git_smart_subtransport *t) +{ + ssh_exec_subtransport *transport = (ssh_exec_subtransport *)t; + + if (transport->process) { + git_process_close(transport->process); + git_process_free(transport->process); + transport->process = NULL; + } + + transport->action = 0; + + return 0; +} + +static void ssh_exec_subtransport_free(git_smart_subtransport *t) +{ + ssh_exec_subtransport *transport = (ssh_exec_subtransport *)t; + + git__free(transport); +} + +int git_smart_subtransport_ssh_exec( + git_smart_subtransport **out, + git_transport *owner, + void *payload) +{ + ssh_exec_subtransport *transport; + + GIT_UNUSED(payload); + + transport = git__calloc(sizeof(ssh_exec_subtransport), 1); + GIT_ERROR_CHECK_ALLOC(transport); + + transport->owner = owner; + transport->parent.action = ssh_exec_subtransport_action; + transport->parent.close = ssh_exec_subtransport_close; + transport->parent.free = ssh_exec_subtransport_free; + + *out = (git_smart_subtransport *) transport; + return 0; +} + +#endif diff --git a/src/libgit2/transports/ssh_exec.h b/src/libgit2/transports/ssh_exec.h new file mode 100644 index 00000000000..4bcba06b16b --- /dev/null +++ b/src/libgit2/transports/ssh_exec.h @@ -0,0 +1,26 @@ +/* + * Copyright (C) the libgit2 contributors. All rights reserved. + * + * This file is part of libgit2, distributed under the GNU GPL v2 with + * a Linking Exception. For full terms see the included COPYING file. + */ +#ifndef INCLUDE_transports_ssh_exec_h__ +#define INCLUDE_transports_ssh_exec_h__ + +#include "common.h" + +#include "git2.h" +#include "git2/transport.h" +#include "git2/sys/transport.h" + +int git_smart_subtransport_ssh_exec( + git_smart_subtransport **out, + git_transport *owner, + void *param); + +int git_smart_subtransport_ssh_exec_set_paths( + git_smart_subtransport *subtransport, + const char *cmd_uploadpack, + const char *cmd_receivepack); + +#endif diff --git a/src/util/git2_features.h.in b/src/util/git2_features.h.in index 21399116df0..a328f77cb00 100644 --- a/src/util/git2_features.h.in +++ b/src/util/git2_features.h.in @@ -30,6 +30,7 @@ #cmakedefine GIT_QSORT_MSC #cmakedefine GIT_SSH 1 +#cmakedefine GIT_SSH_EXEC 1 #cmakedefine GIT_SSH_LIBSSH2 1 #cmakedefine GIT_SSH_LIBSSH2_MEMORY_CREDENTIALS 1 From 38b16b01e36936c697a0a3a6d8076936f4a443a0 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 27 Mar 2023 12:08:19 +0100 Subject: [PATCH 346/608] ci: split ssh into exec and libssh2 --- .github/workflows/main.yml | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 84d476f78dc..eba3b055a6d 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -25,40 +25,40 @@ jobs: strategy: matrix: platform: - - name: "Linux (Xenial, GCC, OpenSSL)" + - name: "Linux (Xenial, GCC, OpenSSL, libssh2)" id: xenial-gcc-openssl container: name: xenial env: CC: gcc CMAKE_GENERATOR: Ninja - CMAKE_OPTIONS: -DUSE_HTTPS=OpenSSL -DREGEX_BACKEND=builtin -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=ON -DDEBUG_STRICT_ALLOC=ON -DDEBUG_STRICT_OPEN=ON + CMAKE_OPTIONS: -DUSE_HTTPS=OpenSSL -DREGEX_BACKEND=builtin -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=libssh2 -DDEBUG_STRICT_ALLOC=ON -DDEBUG_STRICT_OPEN=ON os: ubuntu-latest - - name: Linux (Xenial, GCC, mbedTLS) + - name: Linux (Xenial, GCC, mbedTLS, OpenSSH) id: xenial-gcc-mbedtls container: name: xenial env: CC: gcc CMAKE_GENERATOR: Ninja - CMAKE_OPTIONS: -DUSE_HTTPS=mbedTLS -DUSE_SHA1=HTTPS -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=ON + CMAKE_OPTIONS: -DUSE_HTTPS=mbedTLS -DUSE_SHA1=HTTPS -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=exec os: ubuntu-latest - - name: "Linux (Xenial, Clang, OpenSSL)" + - name: "Linux (Xenial, Clang, OpenSSL, OpenSSH)" id: xenial-clang-openssl container: name: xenial env: CC: clang CMAKE_GENERATOR: Ninja - CMAKE_OPTIONS: -DUSE_HTTPS=OpenSSL -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=ON + CMAKE_OPTIONS: -DUSE_HTTPS=OpenSSL -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=exec os: ubuntu-latest - - name: "Linux (Xenial, Clang, mbedTLS)" + - name: "Linux (Xenial, Clang, mbedTLS, libssh2)" id: xenial-clang-mbedtls container: name: xenial env: CC: clang - CMAKE_OPTIONS: -DUSE_HTTPS=mbedTLS -DUSE_SHA1=HTTPS -DREGEX_BACKEND=pcre -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=ON + CMAKE_OPTIONS: -DUSE_HTTPS=mbedTLS -DUSE_SHA1=HTTPS -DREGEX_BACKEND=pcre -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=libssh2 CMAKE_GENERATOR: Ninja os: ubuntu-latest - name: "macOS" From 7a8c4d8bd2b619061e432b021d9bfb1a6858637d Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 27 Mar 2023 17:31:51 +0100 Subject: [PATCH 347/608] process: test SIGTERM detection We can't reliably detect SIGPIPE on close because of platform differences. Track `pid` and send `SIGTERM` to a function and ensure that we can detect it. --- src/util/process.h | 15 ++++++++++++++ src/util/unix/process.c | 13 +++++++++++++ src/util/win32/process.c | 13 +++++++++++++ tests/util/process/start.c | 40 +++++++++++++++++++++++++++++++++++--- 4 files changed, 78 insertions(+), 3 deletions(-) diff --git a/src/util/process.h b/src/util/process.h index 55b2a104934..81081d10356 100644 --- a/src/util/process.h +++ b/src/util/process.h @@ -35,6 +35,12 @@ typedef struct { #define GIT_PROCESS_OPTIONS_INIT { 0 } +#ifdef GIT_WIN32 +# define p_pid_t DWORD +#else +# define p_pid_t pid_t +#endif + /** * Create a new process. The command to run should be specified as the * element of the `arg` array. @@ -79,6 +85,15 @@ extern int git_process__cmdline( */ extern int git_process_start(git_process *process); +/** + * Returns the process id of the process. + * + * @param out pointer to a pid_t to store the process id + * @param process the process to query + * @return 0 or an error code + */ +extern int git_process_id(p_pid_t *out, git_process *process); + /** * Read from the process's stdout. The process must have been created with * `capture_out` set to true. diff --git a/src/util/unix/process.c b/src/util/unix/process.c index 16171aec94c..3d734ffb53a 100644 --- a/src/util/unix/process.c +++ b/src/util/unix/process.c @@ -356,6 +356,19 @@ int git_process_start(git_process *process) return -1; } +int git_process_id(p_pid_t *out, git_process *process) +{ + GIT_ASSERT(out && process); + + if (!process->pid) { + git_error_set(GIT_ERROR_INVALID, "process not running"); + return -1; + } + + *out = process->pid; + return 0; +} + ssize_t git_process_read(git_process *process, void *buf, size_t count) { ssize_t ret; diff --git a/src/util/win32/process.c b/src/util/win32/process.c index 6b8dd084015..932119ab95e 100644 --- a/src/util/win32/process.c +++ b/src/util/win32/process.c @@ -292,6 +292,19 @@ int git_process_start(git_process *process) return -1; } +int git_process_id(p_pid_t *out, git_process *process) +{ + GIT_ASSERT(out && process); + + if (!process->process_info.dwProcessId) { + git_error_set(GIT_ERROR_INVALID, "process not running"); + return -1; + } + + *out = process->process_info.dwProcessId; + return 0; +} + ssize_t git_process_read(git_process *process, void *buf, size_t count) { DWORD ret; diff --git a/tests/util/process/start.c b/tests/util/process/start.c index 0e4944b6567..d130c7efbbb 100644 --- a/tests/util/process/start.c +++ b/tests/util/process/start.c @@ -2,6 +2,14 @@ #include "process.h" #include "vector.h" +#ifndef GIT_WIN32 +# include +#endif + +#ifndef SIGTERM +# define SIGTERM 42 +#endif + #ifndef SIGPIPE # define SIGPIPE 42 #endif @@ -130,9 +138,35 @@ void test_process_start__redirect_stdio(void) git_process_free(process); } -void test_process_start__catch_signal(void) +/* +void test_process_start__catch_sigterm(void) +{ + const char *args_array[] = { "/bin/cat" }; + + git_process *process; + git_process_options opts = GIT_PROCESS_OPTIONS_INIT; + git_process_result result = GIT_PROCESS_RESULT_INIT; + p_pid_t pid; + + opts.capture_out = 1; + + cl_git_pass(git_process_new(&process, args_array, ARRAY_SIZE(args_array), NULL, 0, &opts)); + cl_git_pass(git_process_start(process)); + cl_git_pass(git_process_id(&pid, process)); + + cl_must_pass(kill(pid, SIGTERM)); + + cl_git_pass(git_process_wait(&result, process)); + + cl_assert_equal_i(GIT_PROCESS_STATUS_ERROR, result.status); + cl_assert_equal_i(0, result.exitcode); + cl_assert_equal_i(SIGTERM, result.signal); + + git_process_free(process); +} + +void test_process_start__catch_sigpipe(void) { -#ifndef GIT_WIN32 const char *args_array[] = { helloworld_cmd.ptr }; git_process *process; @@ -151,8 +185,8 @@ void test_process_start__catch_signal(void) cl_assert_equal_i(SIGPIPE, result.signal); git_process_free(process); -#endif } +*/ void test_process_start__can_chdir(void) { From cf133a82217a2f22349a6b8bc7cc0227420025d5 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 18 May 2023 10:44:02 +0100 Subject: [PATCH 348/608] tests: use cl_fail_with correctly --- tests/libgit2/online/clone.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/tests/libgit2/online/clone.c b/tests/libgit2/online/clone.c index ea47b89985a..e2ddd6428e6 100644 --- a/tests/libgit2/online/clone.c +++ b/tests/libgit2/online/clone.c @@ -908,12 +908,12 @@ void test_online_clone__certificate_invalid(void) { g_options.fetch_opts.callbacks.certificate_check = fail_certificate_check; - cl_git_fail_with(git_clone(&g_repo, "https://github.com/libgit2/TestGitRepository", "./foo", &g_options), - GIT_ECERTIFICATE); + cl_git_fail_with(GIT_ECERTIFICATE, + git_clone(&g_repo, "https://github.com/libgit2/TestGitRepository", "./foo", &g_options)); #ifdef GIT_SSH - cl_git_fail_with(git_clone(&g_repo, "ssh://github.com/libgit2/TestGitRepository", "./foo", &g_options), - GIT_ECERTIFICATE); + cl_git_fail_with(GIT_ECERTIFICATE, + git_clone(&g_repo, "ssh://github.com/libgit2/TestGitRepository", "./foo", &g_options)); #endif } From 10fbb5c940d7712c8e81e0099823808424e0c41c Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 18 May 2023 10:47:13 +0100 Subject: [PATCH 349/608] ssh: only test callbacks for libssh2 There are no custom callbacks for OpenSSH; don't test them. --- tests/libgit2/online/clone.c | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/tests/libgit2/online/clone.c b/tests/libgit2/online/clone.c index e2ddd6428e6..1dc76d507a4 100644 --- a/tests/libgit2/online/clone.c +++ b/tests/libgit2/online/clone.c @@ -653,7 +653,7 @@ void test_online_clone__ssh_auth_methods(void) { int with_user; -#ifndef GIT_SSH +#ifndef GIT_SSH_LIBSSH2 clar__skip(); #endif g_options.fetch_opts.callbacks.credentials = check_ssh_auth_methods; @@ -796,6 +796,7 @@ void test_online_clone__ssh_cannot_change_username(void) #ifndef GIT_SSH_LIBSSH2 clar__skip(); #endif + g_options.fetch_opts.callbacks.credentials = cred_foo_bar; cl_git_fail(git_clone(&g_repo, "ssh://git@github.com/libgit2/TestGitRepository", "./foo", &g_options)); @@ -837,6 +838,10 @@ static int ssh_certificate_check(git_cert *cert, int valid, const char *host, vo void test_online_clone__ssh_cert(void) { +#ifndef GIT_SSH_LIBSSH2 + cl_skip(); +#endif + g_options.fetch_opts.callbacks.certificate_check = ssh_certificate_check; if (!_remote_ssh_fingerprint) @@ -911,7 +916,7 @@ void test_online_clone__certificate_invalid(void) cl_git_fail_with(GIT_ECERTIFICATE, git_clone(&g_repo, "https://github.com/libgit2/TestGitRepository", "./foo", &g_options)); -#ifdef GIT_SSH +#ifdef GIT_SSH_LIBSSH2 cl_git_fail_with(GIT_ECERTIFICATE, git_clone(&g_repo, "ssh://github.com/libgit2/TestGitRepository", "./foo", &g_options)); #endif From a283c1bd1b0b66b9bc0c5b3c66bcfe8ea221701d Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 18 May 2023 11:17:46 +0100 Subject: [PATCH 350/608] ci: valgrind shouldn't report on exited children Now that we (may) exec a child process to do ssh, we don't want valgrind reporting on that. Suppress children in valgrind runs. --- script/valgrind.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/script/valgrind.sh b/script/valgrind.sh index b5deed2b06e..aacd767a7c8 100755 --- a/script/valgrind.sh +++ b/script/valgrind.sh @@ -1,2 +1,2 @@ #!/bin/bash -exec valgrind --leak-check=full --show-reachable=yes --error-exitcode=125 --num-callers=50 --suppressions="$(dirname "${BASH_SOURCE[0]}")/valgrind.supp" "$@" +exec valgrind --leak-check=full --show-reachable=yes --child-silent-after-fork=yes --error-exitcode=125 --num-callers=50 --suppressions="$(dirname "${BASH_SOURCE[0]}")/valgrind.supp" "$@" From 1c72c59aa5e6af4e051025b06afde4bb558a7aa6 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 19 May 2023 10:35:59 +0100 Subject: [PATCH 351/608] smart: don't assume directionality A transport may want to validate that it's in a sane state; when flushing on close, don't assume that we're doing an upload-pack; send the correct direction. --- src/libgit2/transports/smart.c | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/src/libgit2/transports/smart.c b/src/libgit2/transports/smart.c index 53727282850..fe3fe970ae1 100644 --- a/src/libgit2/transports/smart.c +++ b/src/libgit2/transports/smart.c @@ -370,17 +370,27 @@ static int git_smart__close(git_transport *transport) git_vector *common = &t->common; unsigned int i; git_pkt *p; + git_smart_service_t service; int ret; git_smart_subtransport_stream *stream; const char flush[] = "0000"; + if (t->direction == GIT_DIRECTION_FETCH) { + service = GIT_SERVICE_UPLOADPACK; + } else if (t->direction == GIT_DIRECTION_PUSH) { + service = GIT_SERVICE_RECEIVEPACK; + } else { + git_error_set(GIT_ERROR_NET, "invalid direction"); + return -1; + } + /* * If we're still connected at this point and not using RPC, * we should say goodbye by sending a flush, or git-daemon * will complain that we disconnected unexpectedly. */ if (t->connected && !t->rpc && - !t->wrapped->action(&stream, t->wrapped, t->url, GIT_SERVICE_UPLOADPACK)) { + !t->wrapped->action(&stream, t->wrapped, t->url, service)) { t->current_stream->write(t->current_stream, flush, 4); } From 0e6261551516b28680e0632beee081552a0e2fc2 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 19 May 2023 10:36:33 +0100 Subject: [PATCH 352/608] smart: unique error messages Instead of "early EOF", provide information on _when_ we're seeing the EOF for debugging. --- src/libgit2/transports/smart_protocol.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/libgit2/transports/smart_protocol.c b/src/libgit2/transports/smart_protocol.c index c9c422d4c85..9646abb705b 100644 --- a/src/libgit2/transports/smart_protocol.c +++ b/src/libgit2/transports/smart_protocol.c @@ -59,7 +59,7 @@ int git_smart__store_refs(transport_smart *t, int flushes) return recvd; if (recvd == 0) { - git_error_set(GIT_ERROR_NET, "early EOF"); + git_error_set(GIT_ERROR_NET, "early EOF receiving refs"); return GIT_EEOF; } @@ -285,7 +285,7 @@ static int recv_pkt( if ((ret = git_smart__recv(t)) < 0) { return ret; } else if (ret == 0) { - git_error_set(GIT_ERROR_NET, "early EOF"); + git_error_set(GIT_ERROR_NET, "early EOF receiving packet"); return GIT_EEOF; } } while (error); @@ -940,7 +940,7 @@ static int parse_report(transport_smart *transport, git_push *push) } if (recvd == 0) { - git_error_set(GIT_ERROR_NET, "early EOF"); + git_error_set(GIT_ERROR_NET, "early EOF receiving report"); error = GIT_EEOF; goto done; } From ac07db3fb706f891880ae2666e89e57a2ee59c4e Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 19 May 2023 11:57:46 +0100 Subject: [PATCH 353/608] process: sigpipe suppression Suppress SIGPIPEs during writes to our piped process. On single-threaded applications, this is as simple as ignoring the signal. But since this is process-wide, on multi-threaded applications, we need to use some cumbersome `pthread_sigmask` manipulation. Thanks to https://www.doof.me.uk/2020/09/23/sigpipe-and-how-to-ignore-it/ and http://www.microhowto.info:80/howto/ignore_sigpipe_without_affecting_other_threads_in_a_process.html --- src/util/unix/process.c | 93 +++++++++++++++++++++++++++++++++++++++-- 1 file changed, 90 insertions(+), 3 deletions(-) diff --git a/src/util/unix/process.c b/src/util/unix/process.c index 3d734ffb53a..08499e24cc8 100644 --- a/src/util/unix/process.c +++ b/src/util/unix/process.c @@ -7,6 +7,7 @@ #include #include +#include #include #include "git2_util.h" @@ -387,8 +388,90 @@ ssize_t git_process_read(git_process *process, void *buf, size_t count) return ret; } +#ifdef GIT_THREADS + +# define signal_state sigset_t + +/* + * Since signal-handling is process-wide, we cannot simply use + * SIG_IGN to avoid SIGPIPE. Instead: http://www.microhowto.info:80/howto/ignore_sigpipe_without_affecting_other_threads_in_a_process.html + */ + +GIT_INLINE(int) disable_signals(sigset_t *saved_mask) +{ + sigset_t sigpipe_mask; + + sigemptyset(&sigpipe_mask); + sigaddset(&sigpipe_mask, SIGPIPE); + + if (pthread_sigmask(SIG_BLOCK, &sigpipe_mask, saved_mask) < 0) { + git_error_set(GIT_ERROR_OS, "could not configure signal mask"); + return -1; + } + + return 0; +} + +GIT_INLINE(int) restore_signals(sigset_t *saved_mask) +{ + sigset_t sigpipe_mask, pending; + int signal; + + sigemptyset(&sigpipe_mask); + sigaddset(&sigpipe_mask, SIGPIPE); + + if (sigpending(&pending) < 0) { + git_error_set(GIT_ERROR_OS, "could not examine pending signals"); + return -1; + } + + if (sigismember(&pending, SIGPIPE) == 1 && + sigwait(&sigpipe_mask, &signal) < 0) { + git_error_set(GIT_ERROR_OS, "could not wait for (blocking) signal delivery"); + return -1; + } + + if (pthread_sigmask(SIG_SETMASK, saved_mask, 0) < 0) { + git_error_set(GIT_ERROR_OS, "could not configure signal mask"); + return -1; + } + + return 0; +} + +#else + +# define signal_state struct sigaction + +GIT_INLINE(int) disable_signals(struct sigaction *saved_handler) +{ + struct sigaction ign_handler = { 0 }; + + ign_handler.sa_handler = SIG_IGN; + + if (sigaction(SIGPIPE, &ign_handler, saved_handler) < 0) { + git_error_set(GIT_ERROR_OS, "could not configure signal handler"); + return -1; + } + + return 0; +} + +GIT_INLINE(int) restore_signals(struct sigaction *saved_handler) +{ + if (sigaction(SIGPIPE, saved_handler, NULL) < 0) { + git_error_set(GIT_ERROR_OS, "could not configure signal handler"); + return -1; + } + + return 0; +} + +#endif + ssize_t git_process_write(git_process *process, const void *buf, size_t count) { + signal_state saved_signal; ssize_t ret; GIT_ASSERT_ARG(process); @@ -397,12 +480,16 @@ ssize_t git_process_write(git_process *process, const void *buf, size_t count) if (count > SSIZE_MAX) count = SSIZE_MAX; - if ((ret = write(process->child_in, buf, count)) < 0) { + if (disable_signals(&saved_signal) < 0) + return -1; + + if ((ret = write(process->child_in, buf, count)) < 0) git_error_set(GIT_ERROR_OS, "could not write to child process"); + + if (restore_signals(&saved_signal) < 0) return -1; - } - return ret; + return (ret < 0) ? -1 : ret; } int git_process_close_in(git_process *process) From 18474f7d699fc2d22ec217d620bb6a9fc5cac130 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 20 May 2023 15:59:28 +0100 Subject: [PATCH 354/608] process: reader for stderr Provide a mechanism for callers to read from stderr. --- src/util/process.h | 11 +++++++++++ src/util/unix/process.c | 35 ++++++++++++++++++++++++----------- 2 files changed, 35 insertions(+), 11 deletions(-) diff --git a/src/util/process.h b/src/util/process.h index 81081d10356..816be67fd98 100644 --- a/src/util/process.h +++ b/src/util/process.h @@ -105,6 +105,17 @@ extern int git_process_id(p_pid_t *out, git_process *process); */ extern ssize_t git_process_read(git_process *process, void *buf, size_t count); +/** + * Read from the process's stderr. The process must have been created with + * `capture_err` set to true. + * + * @param process the process to read from + * @param buf the buf to read into + * @param count maximum number of bytes to read + * @return number of bytes read or an error code + */ +extern ssize_t git_process_read_err(git_process *process, void *buf, size_t count); + /** * Write to the process's stdin. The process must have been created with * `capture_in` set to true. diff --git a/src/util/unix/process.c b/src/util/unix/process.c index 08499e24cc8..523e52f3156 100644 --- a/src/util/unix/process.c +++ b/src/util/unix/process.c @@ -152,7 +152,7 @@ int git_process_new( fd = -1; \ } -static int try_read(size_t *out, int fd, void *buf, size_t len) +static int try_read_status(size_t *out, int fd, void *buf, size_t len) { size_t read_len = 0; int ret = -1; @@ -179,7 +179,7 @@ static int read_status(int fd) char buffer[status_len], fn[128]; int error, fn_error, os_error, fn_len = 0; - if ((error = try_read(&read_len, fd, buffer, status_len)) < 0) + if ((error = try_read_status(&read_len, fd, buffer, status_len)) < 0) return error; /* Immediate EOF indicates the exec succeeded. */ @@ -198,7 +198,7 @@ static int read_status(int fd) if (fn_len > 0) { fn_len = min(fn_len, (int)(ARRAY_SIZE(fn) - 1)); - if ((error = try_read(&read_len, fd, fn, fn_len)) < 0) + if ((error = try_read_status(&read_len, fd, fn, fn_len)) < 0) return error; fn[fn_len] = '\0'; @@ -214,7 +214,7 @@ static int read_status(int fd) return fn_error; } -static bool try_write(int fd, const void *buf, size_t len) +static bool try_write_status(int fd, const void *buf, size_t len) { size_t write_len; int ret; @@ -246,11 +246,11 @@ static void write_status(int fd, const char *fn, int error, int os_error) memcpy(&buffer[sizeof(int) * 2], &fn_len, sizeof(int)); /* Do our best effort to write all the status. */ - if (!try_write(fd, buffer, status_len)) + if (!try_write_status(fd, buffer, status_len)) return; if (fn_len) - try_write(fd, fn, fn_len); + try_write_status(fd, fn, fn_len); } int git_process_start(git_process *process) @@ -370,17 +370,14 @@ int git_process_id(p_pid_t *out, git_process *process) return 0; } -ssize_t git_process_read(git_process *process, void *buf, size_t count) +static ssize_t process_read(int fd, void *buf, size_t count) { ssize_t ret; - GIT_ASSERT_ARG(process); - GIT_ASSERT(process->capture_out); - if (count > SSIZE_MAX) count = SSIZE_MAX; - if ((ret = read(process->child_out, buf, count)) < 0) { + if ((ret = read(fd, buf, count)) < 0) { git_error_set(GIT_ERROR_OS, "could not read from child process"); return -1; } @@ -388,6 +385,22 @@ ssize_t git_process_read(git_process *process, void *buf, size_t count) return ret; } +ssize_t git_process_read(git_process *process, void *buf, size_t count) +{ + GIT_ASSERT_ARG(process); + GIT_ASSERT(process->capture_out); + + return process_read(process->child_out, buf, count); +} + +ssize_t git_process_read_err(git_process *process, void *buf, size_t count) +{ + GIT_ASSERT_ARG(process); + GIT_ASSERT(process->capture_err); + + return process_read(process->child_err, buf, count); +} + #ifdef GIT_THREADS # define signal_state sigset_t From bc124bb4357538b1c5ee990fe0f90dca8aa8bf56 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 19 May 2023 17:34:09 +0100 Subject: [PATCH 355/608] transport: provide clearer / unique error messages Provide more user-friendly error messages in smart protocol negotiation failures. --- src/libgit2/transports/smart_protocol.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/libgit2/transports/smart_protocol.c b/src/libgit2/transports/smart_protocol.c index 9646abb705b..7c86a8fb96a 100644 --- a/src/libgit2/transports/smart_protocol.c +++ b/src/libgit2/transports/smart_protocol.c @@ -59,7 +59,7 @@ int git_smart__store_refs(transport_smart *t, int flushes) return recvd; if (recvd == 0) { - git_error_set(GIT_ERROR_NET, "early EOF receiving refs"); + git_error_set(GIT_ERROR_NET, "could not read refs from remote repository"); return GIT_EEOF; } @@ -285,7 +285,7 @@ static int recv_pkt( if ((ret = git_smart__recv(t)) < 0) { return ret; } else if (ret == 0) { - git_error_set(GIT_ERROR_NET, "early EOF receiving packet"); + git_error_set(GIT_ERROR_NET, "could not read from remote repository"); return GIT_EEOF; } } while (error); @@ -940,7 +940,7 @@ static int parse_report(transport_smart *transport, git_push *push) } if (recvd == 0) { - git_error_set(GIT_ERROR_NET, "early EOF receiving report"); + git_error_set(GIT_ERROR_NET, "could not read report from remote repository"); error = GIT_EEOF; goto done; } From 23424f43e1deee99f4830501669bf32d05234dca Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 20 May 2023 15:58:49 +0100 Subject: [PATCH 356/608] ssh: don't capture stderr Don't capture stderr, optimize for the CLI case. --- src/libgit2/transports/ssh_exec.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/libgit2/transports/ssh_exec.c b/src/libgit2/transports/ssh_exec.c index 2b2c8a08eb2..61b30ee52a4 100644 --- a/src/libgit2/transports/ssh_exec.c +++ b/src/libgit2/transports/ssh_exec.c @@ -45,8 +45,9 @@ static int ssh_exec_subtransport_stream_read( transport = (ssh_exec_subtransport *)stream->parent.subtransport; - if ((ret = git_process_read(transport->process, buffer, buf_size)) < 0) + if ((ret = git_process_read(transport->process, buffer, buf_size)) < 0) { return (int)ret; + } *bytes_read = (size_t)ret; return 0; @@ -129,7 +130,7 @@ static int start_ssh( process_opts.capture_in = 1; process_opts.capture_out = 1; - process_opts.capture_err = 1; + process_opts.capture_err = 0; switch (action) { case GIT_SERVICE_UPLOADPACK_LS: From d7060aff36fd5a4e37689ae79e6dd86c08b64cac Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 29 Jul 2023 14:31:29 +0100 Subject: [PATCH 357/608] process: provide cmdline-handling and execv style Provide both cmdline-style handling (passing it to the shell on POSIX, or directly to CreateProcess on win32) and execv style (passing it directly to execv on POSIX, and mangling it into a single command-line on win32). --- src/util/process.h | 31 +++++++++++++++++++++- src/util/unix/process.c | 13 ++++++++++ src/util/win32/process.c | 53 +++++++++++++++++++++++++++++++------- tests/util/process/win32.c | 2 ++ 4 files changed, 88 insertions(+), 11 deletions(-) diff --git a/src/util/process.h b/src/util/process.h index 816be67fd98..87cf7acbd0c 100644 --- a/src/util/process.h +++ b/src/util/process.h @@ -43,7 +43,8 @@ typedef struct { /** * Create a new process. The command to run should be specified as the - * element of the `arg` array. + * element of the `arg` array, execv-style. This should be the full path + * to the command to run, the PATH is not obeyed. * * This function will add the given environment variables (in `env`) * to the current environment. Operations on environment variables @@ -67,8 +68,36 @@ extern int git_process_new( size_t env_len, git_process_options *opts); +/** + * Create a new process. The command to run should be specified as the + * `cmdline` option - which is the full text of the command line as it + * would be specified or run by a user. The command to run will be + * looked up in the PATH. + * + * On Unix, this will be executed by the system's shell (`/bin/sh`) + * and may contain _Bourne-style_ shell quoting rules. On Windows, + * this will be passed to `CreateProcess`, and similarly, may + * contain _Windows-style_ shell quoting rules. + * + * This function will add the given environment variables (in `env`) + * to the current environment. Operations on environment variables + * are not thread safe, so you may not modify the environment during + * this call. You can avoid this by setting `exclude_env` in the + * options and providing the entire environment yourself. + */ +extern int git_process_new_from_cmdline( + git_process **out, + const char *cmdline, + const char **env, + size_t env_len, + git_process_options *opts); + #ifdef GIT_WIN32 +extern int git_process__appname( + git_str *out, + const char *cmdline); + /* Windows path parsing is tricky; this helper function is for testing. */ extern int git_process__cmdline( git_str *out, diff --git a/src/util/unix/process.c b/src/util/unix/process.c index 523e52f3156..7f88ccff067 100644 --- a/src/util/unix/process.c +++ b/src/util/unix/process.c @@ -146,6 +146,19 @@ int git_process_new( return 0; } +extern int git_process_new_from_cmdline( + git_process **out, + const char *cmdline, + const char **env, + size_t env_len, + git_process_options *opts) +{ + const char *args[] = { "/bin/sh", "-c", cmdline }; + + return git_process_new(out, + args, ARRAY_SIZE(args), env, env_len, opts); +} + #define CLOSE_FD(fd) \ if (fd >= 0) { \ close(fd); \ diff --git a/src/util/win32/process.c b/src/util/win32/process.c index 932119ab95e..bb522459711 100644 --- a/src/util/win32/process.c +++ b/src/util/win32/process.c @@ -162,30 +162,29 @@ static int merge_env(wchar_t **out, const char **in, size_t in_len, bool exclude return ret < 0 ? -1 : 0; } -int git_process_new( +static int process_new( git_process **out, - const char **args, - size_t args_len, + const char *appname, + const char *cmdline, const char **env, size_t env_len, git_process_options *opts) { git_process *process; - git_str cmdline = GIT_STR_INIT; - int error; - - GIT_ASSERT_ARG(out && args && args_len > 0); + int error = 0; *out = NULL; process = git__calloc(1, sizeof(git_process)); GIT_ERROR_CHECK_ALLOC(process); - if ((error = git_process__cmdline(&cmdline, args, args_len)) < 0) + if (appname && + git_utf8_to_16_alloc(&process->appname, appname) < 0) { + error = -1; goto done; + } - if (git_utf8_to_16_alloc(&process->appname, args[0]) < 0 || - git_utf8_to_16_alloc(&process->cmdline, cmdline.ptr) < 0) { + if (git_utf8_to_16_alloc(&process->cmdline, cmdline) < 0) { error = -1; goto done; } @@ -211,6 +210,40 @@ int git_process_new( else *out = process; + return error; +} + +int git_process_new_from_cmdline( + git_process **out, + const char *cmdline, + const char **env, + size_t env_len, + git_process_options *opts) +{ + GIT_ASSERT_ARG(out && cmdline); + + return process_new(out, NULL, cmdline, env, env_len, opts); +} + +int git_process_new( + git_process **out, + const char **args, + size_t args_len, + const char **env, + size_t env_len, + git_process_options *opts) +{ + git_str cmdline = GIT_STR_INIT; + int error; + + GIT_ASSERT_ARG(out && args && args_len > 0); + + if ((error = git_process__cmdline(&cmdline, args, args_len)) < 0) + goto done; + + error = process_new(out, args[0], cmdline.ptr, env, env_len, opts); + +done: git_str_dispose(&cmdline); return error; } diff --git a/tests/util/process/win32.c b/tests/util/process/win32.c index 914504d6263..c04a56ec54b 100644 --- a/tests/util/process/win32.c +++ b/tests/util/process/win32.c @@ -10,8 +10,10 @@ static git_str result; cl_assert_equal_s(expected, result.ptr); \ git_str_dispose(&result); \ } while(0) + #endif + void test_process_win32__cmdline_is_whitespace_delimited(void) { #ifdef GIT_WIN32 From 019cf6c24f6d150a11b7b4f150b3b6843b47e3c0 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 27 Jul 2023 09:48:34 +0100 Subject: [PATCH 358/608] ssh: honor core.sshcommand Callers can specify the ssh command to invoke using `core.sshcommand` or the `GIT_SSH` environment variable. This is useful for specifying alternate configuration, and is particularly useful for our testing environment. --- ci/test.sh | 4 ++ src/libgit2/transports/ssh.c | 2 + src/libgit2/transports/ssh_exec.c | 62 +++++++++++++++++++++++-------- tests/libgit2/online/clone.c | 16 ++++++++ tests/libgit2/online/push.c | 14 +++++++ 5 files changed, 82 insertions(+), 16 deletions(-) diff --git a/ci/test.sh b/ci/test.sh index e5331362436..9a24398ca1d 100755 --- a/ci/test.sh +++ b/ci/test.sh @@ -414,6 +414,8 @@ if [ -z "$SKIP_SSH_TESTS" ]; then export GITTEST_REMOTE_SSH_PASSPHRASE="" export GITTEST_REMOTE_SSH_FINGERPRINT="${SSH_FINGERPRINT}" + export GITTEST_SSH_CMD="ssh -i ${HOME}/.ssh/id_rsa -o UserKnownHostsFile=${HOME}/.ssh/known_hosts" + echo "" echo "Running ssh tests" echo "" @@ -430,6 +432,8 @@ if [ -z "$SKIP_SSH_TESTS" ]; then run_test ssh unset GITTEST_REMOTE_URL + unset GITTEST_SSH_CMD + unset GITTEST_REMOTE_USER unset GITTEST_REMOTE_SSH_KEY unset GITTEST_REMOTE_SSH_PUBKEY diff --git a/src/libgit2/transports/ssh.c b/src/libgit2/transports/ssh.c index 98e1be2d131..1155e18a1d7 100644 --- a/src/libgit2/transports/ssh.c +++ b/src/libgit2/transports/ssh.c @@ -64,6 +64,8 @@ int git_transport_ssh_with_paths( *out = transport; return 0; +#elif GIT_SSH_EXEC + abort(); #else GIT_UNUSED(out); GIT_UNUSED(owner); diff --git a/src/libgit2/transports/ssh_exec.c b/src/libgit2/transports/ssh_exec.c index 61b30ee52a4..661cd49779a 100644 --- a/src/libgit2/transports/ssh_exec.c +++ b/src/libgit2/transports/ssh_exec.c @@ -11,10 +11,12 @@ #include "common.h" +#include "config.h" #include "net.h" #include "path.h" #include "futils.h" #include "process.h" +#include "transports/smart.h" typedef struct { git_smart_subtransport_stream parent; @@ -114,17 +116,54 @@ GIT_INLINE(int) ensure_transport_state( return 0; } +static int get_ssh_cmdline( + git_str *out, + ssh_exec_subtransport *transport, + git_net_url *url, + const char *command) +{ + git_remote *remote = ((transport_smart *)transport->owner)->owner; + git_repository *repo = remote->repo; + git_config *cfg; + git_str ssh_cmd = GIT_STR_INIT; + const char *default_ssh_cmd = "ssh"; + int error; + + if ((error = git_repository_config_snapshot(&cfg, repo)) < 0) + return error; + + if ((error = git__getenv(&ssh_cmd, "GIT_SSH")) == 0) + ; + else if (error != GIT_ENOTFOUND) + goto done; + else if ((error = git_config__get_string_buf(&ssh_cmd, cfg, "core.sshcommand")) < 0 && error != GIT_ENOTFOUND) + goto done; + + error = git_str_printf(out, "%s -p %s \"%s%s%s\" \"%s\" \"%s\"", + ssh_cmd.size > 0 ? ssh_cmd.ptr : default_ssh_cmd, + url->port, + url->username ? url->username : "", + url->username ? "@" : "", + url->host, + command, + url->path); + +done: + git_str_dispose(&ssh_cmd); + git_config_free(cfg); + return error; +} + static int start_ssh( ssh_exec_subtransport *transport, git_smart_service_t action, const char *sshpath) { - const char *args[6]; const char *env[] = { "GIT_DIR=" }; git_process_options process_opts = GIT_PROCESS_OPTIONS_INIT; git_net_url url = GIT_NET_URL_INIT; - git_str userhost = GIT_STR_INIT; + git_str ssh_cmdline = GIT_STR_INIT; const char *command; int error; @@ -153,20 +192,11 @@ static int start_ssh( if (error < 0) goto done; - if (url.username) { - git_str_puts(&userhost, url.username); - git_str_putc(&userhost, '@'); - } - git_str_puts(&userhost, url.host); - - args[0] = "/usr/bin/ssh"; - args[1] = "-p"; - args[2] = url.port; - args[3] = userhost.ptr; - args[4] = command; - args[5] = url.path; + if ((error = get_ssh_cmdline(&ssh_cmdline, transport, &url, command)) < 0) + goto done; - if ((error = git_process_new(&transport->process, args, ARRAY_SIZE(args), env, ARRAY_SIZE(env), &process_opts)) < 0 || + if ((error = git_process_new_from_cmdline(&transport->process, + ssh_cmdline.ptr, env, ARRAY_SIZE(env), &process_opts)) < 0 || (error = git_process_start(transport->process)) < 0) { git_process_free(transport->process); transport->process = NULL; @@ -174,7 +204,7 @@ static int start_ssh( } done: - git_str_dispose(&userhost); + git_str_dispose(&ssh_cmdline); git_net_url_dispose(&url); return error; } diff --git a/tests/libgit2/online/clone.c b/tests/libgit2/online/clone.c index 1dc76d507a4..7a8f5ead780 100644 --- a/tests/libgit2/online/clone.c +++ b/tests/libgit2/online/clone.c @@ -47,6 +47,9 @@ static char *_orig_http_proxy = NULL; static char *_orig_https_proxy = NULL; static char *_orig_no_proxy = NULL; +static char *_ssh_cmd = NULL; +static char *_orig_ssh_cmd = NULL; + static int ssl_cert(git_cert *cert, int valid, const char *host, void *payload) { GIT_UNUSED(cert); @@ -102,6 +105,14 @@ void test_online_clone__initialize(void) _orig_https_proxy = cl_getenv("HTTPS_PROXY"); _orig_no_proxy = cl_getenv("NO_PROXY"); + _orig_ssh_cmd = cl_getenv("GIT_SSH"); + _ssh_cmd = cl_getenv("GITTEST_SSH_CMD"); + + if (_ssh_cmd) + cl_setenv("GIT_SSH", _ssh_cmd); + else + cl_setenv("GIT_SSH", NULL); + if (_remote_expectcontinue) git_libgit2_opts(GIT_OPT_ENABLE_HTTP_EXPECT_CONTINUE, 1); } @@ -149,6 +160,11 @@ void test_online_clone__cleanup(void) git__free(_orig_https_proxy); git__free(_orig_no_proxy); + cl_setenv("GIT_SSH", _orig_ssh_cmd); + git__free(_orig_ssh_cmd); + + git__free(_ssh_cmd); + git_libgit2_opts(GIT_OPT_SET_SSL_CERT_LOCATIONS, NULL, NULL); git_libgit2_opts(GIT_OPT_SET_SERVER_TIMEOUT, 0); git_libgit2_opts(GIT_OPT_SET_SERVER_CONNECT_TIMEOUT, 0); diff --git a/tests/libgit2/online/push.c b/tests/libgit2/online/push.c index 204572cf57b..b18402bf1a0 100644 --- a/tests/libgit2/online/push.c +++ b/tests/libgit2/online/push.c @@ -20,6 +20,9 @@ static char *_remote_ssh_passphrase = NULL; static char *_remote_default = NULL; static char *_remote_expectcontinue = NULL; +static char *_orig_ssh_cmd = NULL; +static char *_ssh_cmd = NULL; + static int cred_acquire_cb(git_credential **, const char *, const char *, unsigned int, void *); static git_remote *_remote; @@ -369,6 +372,14 @@ void test_online_push__initialize(void) _remote_expectcontinue = cl_getenv("GITTEST_REMOTE_EXPECTCONTINUE"); _remote = NULL; + _orig_ssh_cmd = cl_getenv("GIT_SSH"); + _ssh_cmd = cl_getenv("GITTEST_SSH_CMD"); + + if (_ssh_cmd) + cl_setenv("GIT_SSH", _ssh_cmd); + else + cl_setenv("GIT_SSH", NULL); + /* Skip the test if we're missing the remote URL */ if (!_remote_url) cl_skip(); @@ -423,6 +434,9 @@ void test_online_push__cleanup(void) git__free(_remote_default); git__free(_remote_expectcontinue); + git__free(_orig_ssh_cmd); + git__free(_ssh_cmd); + /* Freed by cl_git_sandbox_cleanup */ _repo = NULL; From 3eb7ff2bf91d1d5f524b57685354a043dc46a2b7 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 27 Jul 2023 20:52:52 +0100 Subject: [PATCH 359/608] ci: specify full path to certificate/key This helped when troubleshooting issues running the `ci/test.sh` script locally. --- ci/test.sh | 2 ++ 1 file changed, 2 insertions(+) diff --git a/ci/test.sh b/ci/test.sh index 9a24398ca1d..8c411b65fb8 100755 --- a/ci/test.sh +++ b/ci/test.sh @@ -199,6 +199,8 @@ if [ -z "$SKIP_SSH_TESTS" ]; then PubkeyAuthentication yes ChallengeResponseAuthentication no StrictModes no + HostCertificate ${SSHD_DIR}/id_rsa.pub + HostKey ${SSHD_DIR}/id_rsa # Required here as sshd will simply close connection otherwise UsePAM no EOF From f26d92a4e2f6adcd632707d6ef4c6e922627545b Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 27 Jul 2023 21:49:32 +0100 Subject: [PATCH 360/608] ssh: exec with paths for OpenSSH Handle custom paths for OpenSSH. --- src/libgit2/transports/ssh.c | 47 ++++++++++++++++++------------- src/libgit2/transports/ssh_exec.c | 30 ++++++++++++++++++-- 2 files changed, 55 insertions(+), 22 deletions(-) diff --git a/src/libgit2/transports/ssh.c b/src/libgit2/transports/ssh.c index 1155e18a1d7..3f3a127f256 100644 --- a/src/libgit2/transports/ssh.c +++ b/src/libgit2/transports/ssh.c @@ -24,7 +24,31 @@ int git_smart_subtransport_ssh( GIT_UNUSED(owner); GIT_UNUSED(param); - git_error_set(GIT_ERROR_INVALID, "cannot create SSH transport. Library was built without SSH support"); + git_error_set(GIT_ERROR_INVALID, "cannot create SSH transport; library was built without SSH support"); + return -1; +#endif +} + +static int transport_set_paths(git_transport *t, git_strarray *paths) +{ + transport_smart *smart = (transport_smart *)t; + +#ifdef GIT_SSH_LIBSSH2 + return git_smart_subtransport_ssh_libssh2_set_paths( + (git_smart_subtransport *)smart->wrapped, + paths->strings[0], + paths->strings[1]); +#elif GIT_SSH_EXEC + return git_smart_subtransport_ssh_exec_set_paths( + (git_smart_subtransport *)smart->wrapped, + paths->strings[0], + paths->strings[1]); +#else + GIT_UNUSED(t); + GIT_UNUSED(smart); + GIT_UNUSED(paths); + + GIT_ASSERT(!"cannot create SSH library; library was built without SSH support"); return -1; #endif } @@ -34,16 +58,14 @@ int git_transport_ssh_with_paths( git_remote *owner, void *payload) { -#ifdef GIT_SSH_LIBSSH2 git_strarray *paths = (git_strarray *) payload; git_transport *transport; - transport_smart *smart; int error; git_smart_subtransport_definition ssh_definition = { git_smart_subtransport_ssh, 0, /* no RPC */ - NULL, + NULL }; if (paths->count != 2) { @@ -54,25 +76,10 @@ int git_transport_ssh_with_paths( if ((error = git_transport_smart(&transport, owner, &ssh_definition)) < 0) return error; - smart = (transport_smart *) transport; - - if ((error = git_smart_subtransport_ssh_libssh2_set_paths( - (git_smart_subtransport *)smart->wrapped, - paths->strings[0], - paths->strings[1])) < 0) + if ((error = transport_set_paths(transport, paths)) < 0) return error; *out = transport; return 0; -#elif GIT_SSH_EXEC - abort(); -#else - GIT_UNUSED(out); - GIT_UNUSED(owner); - GIT_UNUSED(payload); - - git_error_set(GIT_ERROR_INVALID, "cannot create SSH transport. Library was built without SSH support"); - return -1; -#endif } diff --git a/src/libgit2/transports/ssh_exec.c b/src/libgit2/transports/ssh_exec.c index 661cd49779a..786e7ee8bdb 100644 --- a/src/libgit2/transports/ssh_exec.c +++ b/src/libgit2/transports/ssh_exec.c @@ -28,6 +28,9 @@ typedef struct { ssh_exec_subtransport_stream *current_stream; + char *cmd_uploadpack; + char *cmd_receivepack; + git_smart_service_t action; git_process *process; } ssh_exec_subtransport; @@ -173,10 +176,12 @@ static int start_ssh( switch (action) { case GIT_SERVICE_UPLOADPACK_LS: - command = "git-upload-pack"; + command = transport->cmd_uploadpack ? + transport->cmd_uploadpack : "git-upload-pack"; break; case GIT_SERVICE_RECEIVEPACK_LS: - command = "git-receive-pack"; + command = transport->cmd_receivepack ? + transport->cmd_receivepack : "git-receive-pack"; break; default: git_error_set(GIT_ERROR_NET, "invalid action"); @@ -277,6 +282,8 @@ static void ssh_exec_subtransport_free(git_smart_subtransport *t) { ssh_exec_subtransport *transport = (ssh_exec_subtransport *)t; + git__free(transport->cmd_uploadpack); + git__free(transport->cmd_receivepack); git__free(transport); } @@ -301,4 +308,23 @@ int git_smart_subtransport_ssh_exec( return 0; } +int git_smart_subtransport_ssh_exec_set_paths( + git_smart_subtransport *subtransport, + const char *cmd_uploadpack, + const char *cmd_receivepack) +{ + ssh_exec_subtransport *t = (ssh_exec_subtransport *)subtransport; + + git__free(t->cmd_uploadpack); + git__free(t->cmd_receivepack); + + t->cmd_uploadpack = git__strdup(cmd_uploadpack); + GIT_ERROR_CHECK_ALLOC(t->cmd_uploadpack); + + t->cmd_receivepack = git__strdup(cmd_receivepack); + GIT_ERROR_CHECK_ALLOC(t->cmd_receivepack); + + return 0; +} + #endif From ac399148d24e7cb6a6fc81a5b8c76454ac165b64 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 4 Aug 2023 09:19:02 +0100 Subject: [PATCH 361/608] net: don't free wrapped transport on failure --- src/libgit2/transports/smart.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/libgit2/transports/smart.c b/src/libgit2/transports/smart.c index fe3fe970ae1..67dc33e78fa 100644 --- a/src/libgit2/transports/smart.c +++ b/src/libgit2/transports/smart.c @@ -523,7 +523,6 @@ int git_transport_smart(git_transport **out, git_remote *owner, void *param) definition->callback(&t->wrapped, &t->parent, definition->param) < 0) { git_vector_free(&t->refs); git_vector_free(&t->heads); - t->wrapped->free(t->wrapped); git__free(t); return -1; } From 9a9f220119d9647a352867b24b0556195cb26548 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 19 Aug 2023 15:09:59 +0100 Subject: [PATCH 362/608] ssh: refactor to avoid using error state The error handling in the ssh certificate callback is straightforward. There's no error messages from an external library that need to be saved, we populate the error message ourselves. Since there's nothing custom here, it does not need to use the error saving mechanism. --- src/libgit2/transports/ssh_libssh2.c | 31 ++++++++++++---------------- 1 file changed, 13 insertions(+), 18 deletions(-) diff --git a/src/libgit2/transports/ssh_libssh2.c b/src/libgit2/transports/ssh_libssh2.c index 76c08c2e1a5..e32587683de 100644 --- a/src/libgit2/transports/ssh_libssh2.c +++ b/src/libgit2/transports/ssh_libssh2.c @@ -665,7 +665,7 @@ static int check_certificate( git_cert_hostkey cert = {{ 0 }}; const char *key; size_t cert_len; - int cert_type, cert_valid = 0, error = 0; + int cert_type, cert_valid = 0, error = GIT_ECERTIFICATE; if ((key = libssh2_session_hostkey(session, &cert_len, &cert_type)) == NULL) { ssh_error(session, "failed to retrieve hostkey"); @@ -735,29 +735,24 @@ static int check_certificate( return -1; } - git_error_clear(); - error = 0; - if (!cert_valid) { - git_error_set(GIT_ERROR_SSH, "invalid or unknown remote ssh hostkey"); - error = GIT_ECERTIFICATE; - } - if (check_cb != NULL) { git_cert_hostkey *cert_ptr = &cert; - git_error_state previous_error = {0}; - git_error_state_capture(&previous_error, error); - error = check_cb((git_cert *) cert_ptr, cert_valid, host, check_cb_payload); - if (error == GIT_PASSTHROUGH) { - error = git_error_state_restore(&previous_error); - } else if (error < 0 && !git_error_last()) { - git_error_set(GIT_ERROR_NET, "unknown remote host key"); - } + error = check_cb((git_cert *)cert_ptr, cert_valid, host, + check_cb_payload); - git_error_state_free(&previous_error); + if (error == 0) + cert_valid = 1; + else if (error != GIT_PASSTHROUGH) + cert_valid = 0; } - return error; + if (!cert_valid) { + git_error_set(GIT_ERROR_SSH, "invalid or unknown remote ssh hostkey"); + return (error == GIT_PASSTHROUGH) ? GIT_ECERTIFICATE : error; + } + + return 0; } #define SSH_DEFAULT_PORT "22" From 3618a2aa45893a88fbb2d1e0eb97d530c7dc4f4d Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 17 Aug 2023 10:49:52 +0100 Subject: [PATCH 363/608] errors: never return a NULL error Callers want to be able to simply call `git_error_last()->message`, not have to worry about whether `git_error_last()` returns NULL or not. --- include/git2/errors.h | 13 +++++++---- src/libgit2/errors.c | 10 ++++++++- tests/libgit2/config/include.c | 4 ++-- tests/libgit2/grafts/shallow.c | 2 +- tests/libgit2/repo/shallow.c | 2 +- tests/util/assert.c | 3 ++- tests/util/errors.c | 41 +++++++++++++++++++++++++--------- 7 files changed, 55 insertions(+), 20 deletions(-) diff --git a/include/git2/errors.h b/include/git2/errors.h index 7180852f95c..f9f14c72cda 100644 --- a/include/git2/errors.h +++ b/include/git2/errors.h @@ -118,10 +118,15 @@ typedef enum { * Return the last `git_error` object that was generated for the * current thread. * - * The default behaviour of this function is to return NULL if no previous error has occurred. - * However, libgit2's error strings are not cleared aggressively, so a prior - * (unrelated) error may be returned. This can be avoided by only calling - * this function if the prior call to a libgit2 API returned an error. + * This function will never return NULL. + * + * Callers should not rely on this to determine whether an error has + * occurred. For error checking, callers should examine the return + * codes of libgit2 functions. + * + * This call can only reliably report error messages when an error + * has occurred. (It may contain stale information if it is called + * after a different function that succeeds.) * * @return A git_error object. */ diff --git a/src/libgit2/errors.c b/src/libgit2/errors.c index 2e58948d2e4..1c4ff7de8a4 100644 --- a/src/libgit2/errors.c +++ b/src/libgit2/errors.c @@ -28,7 +28,12 @@ static git_error uninitialized_error = { static git_error tlsdata_error = { "thread-local data initialization failure", - GIT_ERROR + GIT_ERROR_THREAD +}; + +static git_error no_error = { + "no error", + GIT_ERROR_NONE }; static void set_error_from_buffer(int error_class) @@ -184,6 +189,9 @@ const git_error *git_error_last(void) if ((threadstate = git_threadstate_get()) == NULL) return &tlsdata_error; + if (!threadstate->last_error) + return &no_error; + return threadstate->last_error; } diff --git a/tests/libgit2/config/include.c b/tests/libgit2/config/include.c index 1b55fdc86fd..ba8bcad4387 100644 --- a/tests/libgit2/config/include.c +++ b/tests/libgit2/config/include.c @@ -111,7 +111,7 @@ void test_config_include__missing(void) git_error_clear(); cl_git_pass(git_config_open_ondisk(&cfg, "including")); - cl_assert(git_error_last() == NULL); + cl_assert_equal_i(GIT_ERROR_NONE, git_error_last()->klass); cl_git_pass(git_config_get_string_buf(&buf, cfg, "foo.bar")); cl_assert_equal_s("baz", buf.ptr); @@ -126,7 +126,7 @@ void test_config_include__missing_homedir(void) git_error_clear(); cl_git_pass(git_config_open_ondisk(&cfg, "including")); - cl_assert(git_error_last() == NULL); + cl_assert_equal_i(GIT_ERROR_NONE, git_error_last()->klass); cl_git_pass(git_config_get_string_buf(&buf, cfg, "foo.bar")); cl_assert_equal_s("baz", buf.ptr); diff --git a/tests/libgit2/grafts/shallow.c b/tests/libgit2/grafts/shallow.c index 5911a26aabc..289d1b19105 100644 --- a/tests/libgit2/grafts/shallow.c +++ b/tests/libgit2/grafts/shallow.c @@ -40,7 +40,7 @@ void test_grafts_shallow__clears_errors(void) { g_repo = cl_git_sandbox_init("testrepo.git"); cl_assert_equal_i(0, git_repository_is_shallow(g_repo)); - cl_assert_equal_p(NULL, git_error_last()); + cl_assert_equal_i(GIT_ERROR_NONE, git_error_last()->klass); } void test_grafts_shallow__shallow_oids(void) diff --git a/tests/libgit2/repo/shallow.c b/tests/libgit2/repo/shallow.c index adb7a9e44b5..a3e3036c533 100644 --- a/tests/libgit2/repo/shallow.c +++ b/tests/libgit2/repo/shallow.c @@ -35,5 +35,5 @@ void test_repo_shallow__clears_errors(void) { g_repo = cl_git_sandbox_init("testrepo.git"); cl_assert_equal_i(0, git_repository_is_shallow(g_repo)); - cl_assert_equal_p(NULL, git_error_last()); + cl_assert_equal_i(GIT_ERROR_NONE, git_error_last()->klass); } diff --git a/tests/util/assert.c b/tests/util/assert.c index 3babc475ae3..4644f3533e9 100644 --- a/tests/util/assert.c +++ b/tests/util/assert.c @@ -92,7 +92,8 @@ void test_assert__argument_with_void_return_type(void) git_error_clear(); cl_assert_equal_p(foo, fn_returns_string(foo)); - cl_assert_equal_p(NULL, git_error_last()); + cl_assert_equal_i(GIT_ERROR_NONE, git_error_last()->klass); + cl_assert_equal_s("no error", git_error_last()->message); } void test_assert__internal(void) diff --git a/tests/util/errors.c b/tests/util/errors.c index 78654a753ae..f3597fce28b 100644 --- a/tests/util/errors.c +++ b/tests/util/errors.c @@ -5,7 +5,10 @@ void test_errors__public_api(void) char *str_in_error; git_error_clear(); - cl_assert(git_error_last() == NULL); + + cl_assert(git_error_last() != NULL); + cl_assert(git_error_last()->klass == GIT_ERROR_NONE); + cl_assert(strcmp(git_error_last()->message, "no error") == 0); git_error_set_oom(); @@ -23,7 +26,9 @@ void test_errors__public_api(void) cl_assert(str_in_error != NULL); git_error_clear(); - cl_assert(git_error_last() == NULL); + cl_assert(git_error_last() != NULL); + cl_assert(git_error_last()->klass == GIT_ERROR_NONE); + cl_assert(strcmp(git_error_last()->message, "no error") == 0); } #include "common.h" @@ -35,7 +40,9 @@ void test_errors__new_school(void) char *str_in_error; git_error_clear(); - cl_assert(git_error_last() == NULL); + cl_assert(git_error_last() != NULL); + cl_assert(git_error_last()->klass == GIT_ERROR_NONE); + cl_assert(strcmp(git_error_last()->message, "no error") == 0); git_error_set_oom(); /* internal fn */ @@ -53,7 +60,9 @@ void test_errors__new_school(void) cl_assert(str_in_error != NULL); git_error_clear(); - cl_assert(git_error_last() == NULL); + cl_assert(git_error_last() != NULL); + cl_assert(git_error_last()->klass == GIT_ERROR_NONE); + cl_assert(strcmp(git_error_last()->message, "no error") == 0); do { struct stat st; @@ -91,7 +100,9 @@ void test_errors__restore(void) git_error_state err_state = {0}; git_error_clear(); - cl_assert(git_error_last() == NULL); + cl_assert(git_error_last() != NULL); + cl_assert(git_error_last()->klass == GIT_ERROR_NONE); + cl_assert(strcmp(git_error_last()->message, "no error") == 0); cl_assert_equal_i(0, git_error_state_capture(&err_state, 0)); @@ -100,7 +111,9 @@ void test_errors__restore(void) git_error_set(42, "Foo: %s", "bar"); cl_assert_equal_i(-1, git_error_state_capture(&err_state, -1)); - cl_assert(git_error_last() == NULL); + cl_assert(git_error_last() != NULL); + cl_assert(git_error_last()->klass == GIT_ERROR_NONE); + cl_assert(strcmp(git_error_last()->message, "no error") == 0); git_error_set(99, "Bar: %s", "foo"); @@ -128,7 +141,9 @@ void test_errors__free_state(void) git_error_state_restore(&err_state); - cl_assert(git_error_last() == NULL); + cl_assert(git_error_last() != NULL); + cl_assert(git_error_last()->klass == GIT_ERROR_NONE); + cl_assert(strcmp(git_error_last()->message, "no error") == 0); } void test_errors__restore_oom(void) @@ -144,7 +159,9 @@ void test_errors__restore_oom(void) cl_assert_equal_i(-1, git_error_state_capture(&err_state, -1)); - cl_assert(git_error_last() == NULL); + cl_assert(git_error_last() != NULL); + cl_assert(git_error_last()->klass == GIT_ERROR_NONE); + cl_assert(strcmp(git_error_last()->message, "no error") == 0); cl_assert_equal_i(GIT_ERROR_NOMEMORY, err_state.error_msg.klass); cl_assert_equal_s("Out of memory", err_state.error_msg.message); @@ -204,11 +221,15 @@ void test_errors__integer_overflow_sets_oom(void) git_error_clear(); cl_assert(!GIT_ADD_SIZET_OVERFLOW(&out, SIZE_MAX-1, 1)); - cl_assert_equal_p(NULL, git_error_last()); + cl_assert(git_error_last() != NULL); + cl_assert(git_error_last()->klass == GIT_ERROR_NONE); + cl_assert(strcmp(git_error_last()->message, "no error") == 0); git_error_clear(); cl_assert(!GIT_ADD_SIZET_OVERFLOW(&out, 42, 69)); - cl_assert_equal_p(NULL, git_error_last()); + cl_assert(git_error_last() != NULL); + cl_assert(git_error_last()->klass == GIT_ERROR_NONE); + cl_assert(strcmp(git_error_last()->message, "no error") == 0); git_error_clear(); cl_assert(GIT_ADD_SIZET_OVERFLOW(&out, SIZE_MAX, SIZE_MAX)); From f78ae89bf1800444257160ad6ca48a0cd95384ba Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 17 Aug 2023 10:57:44 +0100 Subject: [PATCH 364/608] errors: move systems things into the sys includes Most callers only need to _get_ error messages. Only callers implemented more complicated functions (like a custom ODB for example) need to set them. (Callback users should likely ferry their own error information in their callback payload.) --- include/git2/errors.h | 52 ++---------------------------- include/git2/sys/errors.h | 66 +++++++++++++++++++++++++++++++++++++++ src/libgit2/errors.h | 1 + src/util/git2_util.h | 1 + 4 files changed, 71 insertions(+), 49 deletions(-) create mode 100644 include/git2/sys/errors.h diff --git a/include/git2/errors.h b/include/git2/errors.h index f9f14c72cda..face0898a12 100644 --- a/include/git2/errors.h +++ b/include/git2/errors.h @@ -128,59 +128,13 @@ typedef enum { * has occurred. (It may contain stale information if it is called * after a different function that succeeds.) * + * The memory for this object is managed by libgit2. It should not + * be freed. + * * @return A git_error object. */ GIT_EXTERN(const git_error *) git_error_last(void); -/** - * Clear the last library error that occurred for this thread. - */ -GIT_EXTERN(void) git_error_clear(void); - -/** - * Set the error message string for this thread, using `printf`-style - * formatting. - * - * This function is public so that custom ODB backends and the like can - * relay an error message through libgit2. Most regular users of libgit2 - * will never need to call this function -- actually, calling it in most - * circumstances (for example, calling from within a callback function) - * will just end up having the value overwritten by libgit2 internals. - * - * This error message is stored in thread-local storage and only applies - * to the particular thread that this libgit2 call is made from. - * - * @param error_class One of the `git_error_t` enum above describing the - * general subsystem that is responsible for the error. - * @param fmt The `printf`-style format string; subsequent arguments must - * be the arguments for the format string. - */ -GIT_EXTERN(void) git_error_set(int error_class, const char *fmt, ...) - GIT_FORMAT_PRINTF(2, 3); - -/** - * Set the error message string for this thread. This function is like - * `git_error_set` but takes a static string instead of a `printf`-style - * format. - * - * @param error_class One of the `git_error_t` enum above describing the - * general subsystem that is responsible for the error. - * @param string The error message to keep - * @return 0 on success or -1 on failure - */ -GIT_EXTERN(int) git_error_set_str(int error_class, const char *string); - -/** - * Set the error message to a special value for memory allocation failure. - * - * The normal `git_error_set_str()` function attempts to `strdup()` the - * string that is passed in. This is not a good idea when the error in - * question is a memory allocation failure. That circumstance has a - * special setter function that sets the error string to a known and - * statically allocated internal value. - */ -GIT_EXTERN(void) git_error_set_oom(void); - /** @} */ GIT_END_DECL #endif diff --git a/include/git2/sys/errors.h b/include/git2/sys/errors.h new file mode 100644 index 00000000000..3ae121524d5 --- /dev/null +++ b/include/git2/sys/errors.h @@ -0,0 +1,66 @@ +/* + * Copyright (C) the libgit2 contributors. All rights reserved. + * + * This file is part of libgit2, distributed under the GNU GPL v2 with + * a Linking Exception. For full terms see the included COPYING file. + */ + +#ifndef INCLUDE_sys_git_errors_h__ +#define INCLUDE_sys_git_errors_h__ + +#include "git2/common.h" + +GIT_BEGIN_DECL + +/** + * Clear the last library error that occurred for this thread. + */ +GIT_EXTERN(void) git_error_clear(void); + +/** + * Set the error message string for this thread, using `printf`-style + * formatting. + * + * This function is public so that custom ODB backends and the like can + * relay an error message through libgit2. Most regular users of libgit2 + * will never need to call this function -- actually, calling it in most + * circumstances (for example, calling from within a callback function) + * will just end up having the value overwritten by libgit2 internals. + * + * This error message is stored in thread-local storage and only applies + * to the particular thread that this libgit2 call is made from. + * + * @param error_class One of the `git_error_t` enum above describing the + * general subsystem that is responsible for the error. + * @param fmt The `printf`-style format string; subsequent arguments must + * be the arguments for the format string. + */ +GIT_EXTERN(void) git_error_set(int error_class, const char *fmt, ...) + GIT_FORMAT_PRINTF(2, 3); + +/** + * Set the error message string for this thread. This function is like + * `git_error_set` but takes a static string instead of a `printf`-style + * format. + * + * @param error_class One of the `git_error_t` enum above describing the + * general subsystem that is responsible for the error. + * @param string The error message to keep + * @return 0 on success or -1 on failure + */ +GIT_EXTERN(int) git_error_set_str(int error_class, const char *string); + +/** + * Set the error message to a special value for memory allocation failure. + * + * The normal `git_error_set_str()` function attempts to `strdup()` the + * string that is passed in. This is not a good idea when the error in + * question is a memory allocation failure. That circumstance has a + * special setter function that sets the error string to a known and + * statically allocated internal value. + */ +GIT_EXTERN(void) git_error_set_oom(void); + +GIT_END_DECL + +#endif diff --git a/src/libgit2/errors.h b/src/libgit2/errors.h index 772c7bad18b..bb207a0f5e6 100644 --- a/src/libgit2/errors.h +++ b/src/libgit2/errors.h @@ -9,6 +9,7 @@ #define INCLUDE_errors_h__ #include "common.h" +#include "git2/sys/errors.h" /* * `vprintf`-style formatting for the error message for this thread. diff --git a/src/util/git2_util.h b/src/util/git2_util.h index c62dc24199d..5ec9429344a 100644 --- a/src/util/git2_util.h +++ b/src/util/git2_util.h @@ -12,6 +12,7 @@ #endif #include "git2/common.h" +#include "git2/sys/errors.h" #include "cc-compat.h" typedef struct git_str git_str; From f451cb18df97c5f9400cf31e6e271f4df74bfcd9 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 18 Aug 2023 10:32:34 +0100 Subject: [PATCH 365/608] errors: simplify the saved-state handling Instead of having a separate type for saving state, we can re-use the `git_error` structure. In practice, saving the error code along with the `git_error` information has not proven necessary or useful, so it can be removed to simplify down to re-using a single structure. --- src/libgit2/clone.c | 6 +- src/libgit2/errors.c | 94 +++++++++++++++++------------ src/libgit2/errors.h | 32 +++++----- src/libgit2/filter.c | 6 +- src/libgit2/index.c | 12 ++-- src/libgit2/transports/httpclient.c | 32 +++++++--- tests/util/errors.c | 57 +++++------------ 7 files changed, 121 insertions(+), 118 deletions(-) diff --git a/src/libgit2/clone.c b/src/libgit2/clone.c index fca0ca0cc7c..ab48191cc6a 100644 --- a/src/libgit2/clone.c +++ b/src/libgit2/clone.c @@ -542,15 +542,15 @@ static int git__clone( } if (error != 0) { - git_error_state last_error = {0}; - git_error_state_capture(&last_error, error); + git_error *last_error; + git_error_save(&last_error); git_repository_free(repo); repo = NULL; (void)git_futils_rmdir_r(local_path, NULL, rmdir_flags); - git_error_state_restore(&last_error); + git_error_restore(last_error); } *out = repo; diff --git a/src/libgit2/errors.c b/src/libgit2/errors.c index 1c4ff7de8a4..232980e0f40 100644 --- a/src/libgit2/errors.c +++ b/src/libgit2/errors.c @@ -36,6 +36,10 @@ static git_error no_error = { GIT_ERROR_NONE }; +#define IS_STATIC_ERROR(err) \ + ((err) == &oom_error || (err) == &uninitialized_error || \ + (err) == &tlsdata_error || (err) == &no_error) + static void set_error_from_buffer(int error_class) { git_threadstate *threadstate = git_threadstate_get(); @@ -66,12 +70,11 @@ static void set_error(int error_class, char *string) git_str_clear(buf); - if (string) { + if (string) git_str_puts(buf, string); - git__free(string); - } - set_error_from_buffer(error_class); + if (!git_str_oom(buf)) + set_error_from_buffer(error_class); } void git_error_set_oom(void) @@ -178,6 +181,16 @@ void git_error_clear(void) #endif } +bool git_error_exists(void) +{ + git_threadstate *threadstate; + + if ((threadstate = git_threadstate_get()) == NULL) + return true; + + return threadstate->last_error != NULL; +} + const git_error *git_error_last(void) { git_threadstate *threadstate; @@ -195,67 +208,68 @@ const git_error *git_error_last(void) return threadstate->last_error; } -int git_error_state_capture(git_error_state *state, int error_code) +int git_error_save(git_error **out) { git_threadstate *threadstate = git_threadstate_get(); - git_error *error; - git_str *error_buf; + git_error *error, *dup; - if (!threadstate) + if (!threadstate) { + *out = &tlsdata_error; return -1; + } error = threadstate->last_error; - error_buf = &threadstate->error_buf; - - memset(state, 0, sizeof(git_error_state)); - if (!error_code) + if (!error || error == &no_error) { + *out = &no_error; return 0; + } else if (IS_STATIC_ERROR(error)) { + *out = error; + return 0; + } - state->error_code = error_code; - state->oom = (error == &oom_error); + if ((dup = git__malloc(sizeof(git_error))) == NULL) { + *out = &oom_error; + return -1; + } - if (error) { - state->error_msg.klass = error->klass; + dup->klass = error->klass; + dup->message = git__strdup(error->message); - if (state->oom) - state->error_msg.message = oom_error.message; - else - state->error_msg.message = git_str_detach(error_buf); + if (!dup->message) { + *out = &oom_error; + return -1; } - git_error_clear(); - return error_code; + *out = dup; + return 0; } -int git_error_state_restore(git_error_state *state) +int git_error_restore(git_error *error) { - int ret = 0; + git_threadstate *threadstate = git_threadstate_get(); - git_error_clear(); + GIT_ASSERT_ARG(error); - if (state && state->error_msg.message) { - if (state->oom) - git_error_set_oom(); - else - set_error(state->error_msg.klass, state->error_msg.message); + if (IS_STATIC_ERROR(error) && threadstate) + threadstate->last_error = error; + else + set_error(error->klass, error->message); - ret = state->error_code; - memset(state, 0, sizeof(git_error_state)); - } - - return ret; + git_error_free(error); + return 0; } -void git_error_state_free(git_error_state *state) +void git_error_free(git_error *error) { - if (!state) + if (!error) return; - if (!state->oom) - git__free(state->error_msg.message); + if (IS_STATIC_ERROR(error)) + return; - memset(state, 0, sizeof(git_error_state)); + git__free(error->message); + git__free(error); } int git_error_system_last(void) diff --git a/src/libgit2/errors.h b/src/libgit2/errors.h index bb207a0f5e6..f929219560d 100644 --- a/src/libgit2/errors.h +++ b/src/libgit2/errors.h @@ -16,6 +16,11 @@ */ void git_error_vset(int error_class, const char *fmt, va_list ap); +/** + * Determines whether an error exists. + */ +bool git_error_exists(void); + /** * Set error message for user callback if needed. * @@ -28,9 +33,8 @@ GIT_INLINE(int) git_error_set_after_callback_function( int error_code, const char *action) { if (error_code) { - const git_error *e = git_error_last(); - if (!e || !e->message) - git_error_set(e ? e->klass : GIT_ERROR_CALLBACK, + if (!git_error_exists()) + git_error_set(GIT_ERROR_CALLBACK, "%s callback returned %d", action, error_code); } return error_code; @@ -54,28 +58,24 @@ int git_error_system_last(void); */ void git_error_system_set(int code); -/** - * Structure to preserve libgit2 error state - */ -typedef struct { - int error_code; - unsigned int oom : 1; - git_error error_msg; -} git_error_state; - /** * Capture current error state to restore later, returning error code. * If `error_code` is zero, this does not clear the current error state. * You must either restore this error state, or free it. + * + * This function returns 0 on success, or -1 on failure. If the function + * fails, the `out` structure is set to the failure error message and + * the normal system error message is not updated. */ -extern int git_error_state_capture(git_error_state *state, int error_code); +extern int git_error_save(git_error **out); /** - * Restore error state to a previous value, returning saved error code. + * Restore thread error state to the given value. The given value is + * freed and `git_error_free` need not be called on it. */ -extern int git_error_state_restore(git_error_state *state); +extern int git_error_restore(git_error *error); /** Free an error state. */ -extern void git_error_state_free(git_error_state *state); +extern void git_error_free(git_error *error); #endif diff --git a/src/libgit2/filter.c b/src/libgit2/filter.c index 80a3cae67bc..fdfc409a287 100644 --- a/src/libgit2/filter.c +++ b/src/libgit2/filter.c @@ -908,7 +908,7 @@ static int buffered_stream_close(git_writestream *s) { struct buffered_stream *buffered_stream = (struct buffered_stream *)s; git_str *writebuf; - git_error_state error_state = {0}; + git_error *last_error; int error; GIT_ASSERT_ARG(buffered_stream); @@ -946,9 +946,9 @@ static int buffered_stream_close(git_writestream *s) } else { /* close stream before erroring out taking care * to preserve the original error */ - git_error_state_capture(&error_state, error); + git_error_save(&last_error); buffered_stream->target->close(buffered_stream->target); - git_error_state_restore(&error_state); + git_error_restore(last_error); return error; } diff --git a/src/libgit2/index.c b/src/libgit2/index.c index 9d919093be0..90580731830 100644 --- a/src/libgit2/index.c +++ b/src/libgit2/index.c @@ -1609,15 +1609,17 @@ int git_index_add_bypath(git_index *index, const char *path) if (ret == GIT_EDIRECTORY) { git_submodule *sm; - git_error_state err; + git_error *last_error; - git_error_state_capture(&err, ret); + git_error_save(&last_error); ret = git_submodule_lookup(&sm, INDEX_OWNER(index), path); - if (ret == GIT_ENOTFOUND) - return git_error_state_restore(&err); + if (ret == GIT_ENOTFOUND) { + git_error_restore(last_error); + return GIT_EDIRECTORY; + } - git_error_state_free(&err); + git_error_free(last_error); /* * EEXISTS means that there is a repository at that path, but it's not known diff --git a/src/libgit2/transports/httpclient.c b/src/libgit2/transports/httpclient.c index a20b594930d..278d7c8e0ab 100644 --- a/src/libgit2/transports/httpclient.c +++ b/src/libgit2/transports/httpclient.c @@ -768,25 +768,37 @@ static int check_certificate( void *cert_cb_payload) { git_cert *cert; - git_error_state last_error = {0}; + git_error *last_error; int error; if ((error = git_stream_certificate(&cert, stream)) < 0) return error; - git_error_state_capture(&last_error, GIT_ECERTIFICATE); + /* + * Allow callers to set an error - but save ours and clear + * it, so that we can detect if they set one and restore it + * if we need to. + */ + git_error_save(&last_error); + git_error_clear(); error = cert_cb(cert, is_valid, url->host, cert_cb_payload); - if (error == GIT_PASSTHROUGH && !is_valid) - return git_error_state_restore(&last_error); - else if (error == GIT_PASSTHROUGH) - error = 0; - else if (error && !git_error_last()) - git_error_set(GIT_ERROR_HTTP, - "user rejected certificate for %s", url->host); + if (error == GIT_PASSTHROUGH) { + error = is_valid ? 0 : -1; + + if (error) { + git_error_restore(last_error); + last_error = NULL; + } + } else if (error) { + if (!git_error_exists()) + git_error_set(GIT_ERROR_HTTP, + "user rejected certificate for %s", + url->host); + } - git_error_state_free(&last_error); + git_error_free(last_error); return error; } diff --git a/tests/util/errors.c b/tests/util/errors.c index f3597fce28b..f9b85a65fde 100644 --- a/tests/util/errors.c +++ b/tests/util/errors.c @@ -97,58 +97,32 @@ void test_errors__new_school(void) void test_errors__restore(void) { - git_error_state err_state = {0}; + git_error *last_error; git_error_clear(); cl_assert(git_error_last() != NULL); cl_assert(git_error_last()->klass == GIT_ERROR_NONE); - cl_assert(strcmp(git_error_last()->message, "no error") == 0); - - cl_assert_equal_i(0, git_error_state_capture(&err_state, 0)); - - memset(&err_state, 0x0, sizeof(git_error_state)); + cl_assert(strcmp("no error", git_error_last()->message) == 0); git_error_set(42, "Foo: %s", "bar"); - cl_assert_equal_i(-1, git_error_state_capture(&err_state, -1)); + cl_assert(git_error_save(&last_error) == 0); + git_error_clear(); cl_assert(git_error_last() != NULL); cl_assert(git_error_last()->klass == GIT_ERROR_NONE); - cl_assert(strcmp(git_error_last()->message, "no error") == 0); - - git_error_set(99, "Bar: %s", "foo"); - - git_error_state_restore(&err_state); - - cl_assert_equal_i(42, git_error_last()->klass); - cl_assert_equal_s("Foo: bar", git_error_last()->message); -} - -void test_errors__free_state(void) -{ - git_error_state err_state = {0}; - - git_error_clear(); - - git_error_set(42, "Foo: %s", "bar"); - cl_assert_equal_i(-1, git_error_state_capture(&err_state, -1)); + cl_assert(strcmp("no error", git_error_last()->message) == 0); git_error_set(99, "Bar: %s", "foo"); - git_error_state_free(&err_state); - - cl_assert_equal_i(99, git_error_last()->klass); - cl_assert_equal_s("Bar: foo", git_error_last()->message); - - git_error_state_restore(&err_state); + git_error_restore(last_error); - cl_assert(git_error_last() != NULL); - cl_assert(git_error_last()->klass == GIT_ERROR_NONE); - cl_assert(strcmp(git_error_last()->message, "no error") == 0); + cl_assert(git_error_last()->klass == 42); + cl_assert(strcmp("Foo: bar", git_error_last()->message) == 0); } void test_errors__restore_oom(void) { - git_error_state err_state = {0}; + git_error *last_error; const git_error *oom_error = NULL; git_error_clear(); @@ -156,17 +130,18 @@ void test_errors__restore_oom(void) git_error_set_oom(); /* internal fn */ oom_error = git_error_last(); cl_assert(oom_error); + cl_assert(oom_error->klass == GIT_ERROR_NOMEMORY); - cl_assert_equal_i(-1, git_error_state_capture(&err_state, -1)); + cl_assert(git_error_save(&last_error) == 0); + cl_assert(last_error->klass == GIT_ERROR_NOMEMORY); + cl_assert(strcmp("Out of memory", last_error->message) == 0); + git_error_clear(); cl_assert(git_error_last() != NULL); cl_assert(git_error_last()->klass == GIT_ERROR_NONE); - cl_assert(strcmp(git_error_last()->message, "no error") == 0); - cl_assert_equal_i(GIT_ERROR_NOMEMORY, err_state.error_msg.klass); - cl_assert_equal_s("Out of memory", err_state.error_msg.message); - - git_error_state_restore(&err_state); + cl_assert(strcmp("no error", git_error_last()->message) == 0); + git_error_restore(last_error); cl_assert(git_error_last()->klass == GIT_ERROR_NOMEMORY); cl_assert_(git_error_last() == oom_error, "static oom error not restored"); From 7572d539f9acb9f46505c885c3bea5ff9c26ba8b Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 18 Aug 2023 12:33:00 +0100 Subject: [PATCH 366/608] errors: keep thread-local state internal --- src/libgit2/errors.c | 143 ++++++++++++++++++++++++++++++-------- src/libgit2/errors.h | 3 + src/libgit2/libgit2.c | 1 + src/libgit2/threadstate.c | 9 --- src/libgit2/threadstate.h | 3 - 5 files changed, 117 insertions(+), 42 deletions(-) diff --git a/src/libgit2/errors.c b/src/libgit2/errors.c index 232980e0f40..cfaa367d925 100644 --- a/src/libgit2/errors.c +++ b/src/libgit2/errors.c @@ -7,14 +7,15 @@ #include "common.h" -#include "threadstate.h" #include "posix.h" #include "str.h" #include "libgit2.h" +#include "runtime.h" -/******************************************** - * New error handling - ********************************************/ +/* + * Some static error data that is used when we're out of memory, TLS + * has not been setup, or TLS has failed. + */ static git_error oom_error = { "Out of memory", @@ -40,33 +41,115 @@ static git_error no_error = { ((err) == &oom_error || (err) == &uninitialized_error || \ (err) == &tlsdata_error || (err) == &no_error) +/* Per-thread error state (TLS) */ + +static git_tlsdata_key tls_key; + +struct error_threadstate { + /* The error message buffer. */ + git_str message; + + /* Error information, set by `git_error_set` and friends. */ + git_error error; + + /* + * The last error to occur; points to the error member of this + * struct _or_ a static error. + */ + git_error *last; +}; + +static void threadstate_dispose(struct error_threadstate *threadstate) +{ + if (!threadstate) + return; + + git_str_dispose(&threadstate->message); +} + +static struct error_threadstate *threadstate_get(void) +{ + struct error_threadstate *threadstate; + + if ((threadstate = git_tlsdata_get(tls_key)) != NULL) + return threadstate; + + /* + * Avoid git__malloc here, since if it fails, it sets an error + * message, which requires thread state, which would allocate + * here, which would fail, which would set an error message... + */ + + if ((threadstate = git__allocator.gmalloc( + sizeof(struct error_threadstate), + __FILE__, __LINE__)) == NULL) + return NULL; + + memset(threadstate, 0, sizeof(struct error_threadstate)); + + if (git_str_init(&threadstate->message, 0) < 0) { + git__allocator.gfree(threadstate); + return NULL; + } + + git_tlsdata_set(tls_key, threadstate); + return threadstate; +} + +static void GIT_SYSTEM_CALL threadstate_free(void *threadstate) +{ + threadstate_dispose(threadstate); + git__free(threadstate); +} + +static void git_error_global_shutdown(void) +{ + struct error_threadstate *threadstate; + + threadstate = git_tlsdata_get(tls_key); + git_tlsdata_set(tls_key, NULL); + + threadstate_dispose(threadstate); + git__free(threadstate); + + git_tlsdata_dispose(tls_key); +} + +int git_error_global_init(void) +{ + if (git_tlsdata_init(&tls_key, &threadstate_free) != 0) + return -1; + + return git_runtime_shutdown_register(git_error_global_shutdown); +} + static void set_error_from_buffer(int error_class) { - git_threadstate *threadstate = git_threadstate_get(); + struct error_threadstate *threadstate = threadstate_get(); git_error *error; git_str *buf; if (!threadstate) return; - error = &threadstate->error_t; - buf = &threadstate->error_buf; + error = &threadstate->error; + buf = &threadstate->message; error->message = buf->ptr; error->klass = error_class; - threadstate->last_error = error; + threadstate->last = error; } static void set_error(int error_class, char *string) { - git_threadstate *threadstate = git_threadstate_get(); + struct error_threadstate *threadstate = threadstate_get(); git_str *buf; if (!threadstate) return; - buf = &threadstate->error_buf; + buf = &threadstate->message; git_str_clear(buf); @@ -79,12 +162,12 @@ static void set_error(int error_class, char *string) void git_error_set_oom(void) { - git_threadstate *threadstate = git_threadstate_get(); + struct error_threadstate *threadstate = threadstate_get(); if (!threadstate) return; - threadstate->last_error = &oom_error; + threadstate->last = &oom_error; } void git_error_set(int error_class, const char *fmt, ...) @@ -102,14 +185,14 @@ void git_error_vset(int error_class, const char *fmt, va_list ap) DWORD win32_error_code = (error_class == GIT_ERROR_OS) ? GetLastError() : 0; #endif - git_threadstate *threadstate = git_threadstate_get(); + struct error_threadstate *threadstate = threadstate_get(); int error_code = (error_class == GIT_ERROR_OS) ? errno : 0; git_str *buf; if (!threadstate) return; - buf = &threadstate->error_buf; + buf = &threadstate->message; git_str_clear(buf); @@ -143,7 +226,7 @@ void git_error_vset(int error_class, const char *fmt, va_list ap) int git_error_set_str(int error_class, const char *string) { - git_threadstate *threadstate = git_threadstate_get(); + struct error_threadstate *threadstate = threadstate_get(); git_str *buf; GIT_ASSERT_ARG(string); @@ -151,7 +234,7 @@ int git_error_set_str(int error_class, const char *string) if (!threadstate) return -1; - buf = &threadstate->error_buf; + buf = &threadstate->message; git_str_clear(buf); git_str_puts(buf, string); @@ -165,14 +248,14 @@ int git_error_set_str(int error_class, const char *string) void git_error_clear(void) { - git_threadstate *threadstate = git_threadstate_get(); + struct error_threadstate *threadstate = threadstate_get(); if (!threadstate) return; - if (threadstate->last_error != NULL) { + if (threadstate->last != NULL) { set_error(0, NULL); - threadstate->last_error = NULL; + threadstate->last = NULL; } errno = 0; @@ -183,34 +266,34 @@ void git_error_clear(void) bool git_error_exists(void) { - git_threadstate *threadstate; + struct error_threadstate *threadstate; - if ((threadstate = git_threadstate_get()) == NULL) + if ((threadstate = threadstate_get()) == NULL) return true; - return threadstate->last_error != NULL; + return threadstate->last != NULL; } const git_error *git_error_last(void) { - git_threadstate *threadstate; + struct error_threadstate *threadstate; /* If the library is not initialized, return a static error. */ if (!git_libgit2_init_count()) return &uninitialized_error; - if ((threadstate = git_threadstate_get()) == NULL) + if ((threadstate = threadstate_get()) == NULL) return &tlsdata_error; - if (!threadstate->last_error) + if (!threadstate->last) return &no_error; - return threadstate->last_error; + return threadstate->last; } int git_error_save(git_error **out) { - git_threadstate *threadstate = git_threadstate_get(); + struct error_threadstate *threadstate = threadstate_get(); git_error *error, *dup; if (!threadstate) { @@ -218,7 +301,7 @@ int git_error_save(git_error **out) return -1; } - error = threadstate->last_error; + error = threadstate->last; if (!error || error == &no_error) { *out = &no_error; @@ -247,12 +330,12 @@ int git_error_save(git_error **out) int git_error_restore(git_error *error) { - git_threadstate *threadstate = git_threadstate_get(); + struct error_threadstate *threadstate = threadstate_get(); GIT_ASSERT_ARG(error); if (IS_STATIC_ERROR(error) && threadstate) - threadstate->last_error = error; + threadstate->last = error; else set_error(error->klass, error->message); diff --git a/src/libgit2/errors.h b/src/libgit2/errors.h index f929219560d..755fd4db460 100644 --- a/src/libgit2/errors.h +++ b/src/libgit2/errors.h @@ -11,6 +11,9 @@ #include "common.h" #include "git2/sys/errors.h" +/* Initialize the error thread-state. */ +int git_error_global_init(void); + /* * `vprintf`-style formatting for the error message for this thread. */ diff --git a/src/libgit2/libgit2.c b/src/libgit2/libgit2.c index ec4a699a2ee..715fbec1d79 100644 --- a/src/libgit2/libgit2.c +++ b/src/libgit2/libgit2.c @@ -73,6 +73,7 @@ int git_libgit2_init(void) git_win32_leakcheck_global_init, #endif git_allocator_global_init, + git_error_global_init, git_threadstate_global_init, git_threads_global_init, git_rand_global_init, diff --git a/src/libgit2/threadstate.c b/src/libgit2/threadstate.c index ed9bb9b96ff..e521450921d 100644 --- a/src/libgit2/threadstate.c +++ b/src/libgit2/threadstate.c @@ -35,10 +35,6 @@ static void threadstate_dispose(git_threadstate *threadstate) { if (!threadstate) return; - - if (threadstate->error_t.message != git_str__initstr) - git__free(threadstate->error_t.message); - threadstate->error_t.message = NULL; } static void GIT_SYSTEM_CALL threadstate_free(void *threadstate) @@ -87,11 +83,6 @@ git_threadstate *git_threadstate_get(void) memset(threadstate, 0, sizeof(git_threadstate)); - if (git_str_init(&threadstate->error_buf, 0) < 0) { - git__allocator.gfree(threadstate); - return NULL; - } - git_tlsdata_set(tls_key, threadstate); return threadstate; } diff --git a/src/libgit2/threadstate.h b/src/libgit2/threadstate.h index 6ef04192ca9..7a3bbd9a1aa 100644 --- a/src/libgit2/threadstate.h +++ b/src/libgit2/threadstate.h @@ -10,9 +10,6 @@ #include "common.h" typedef struct { - git_error *last_error; - git_error error_t; - git_str error_buf; char oid_fmt[GIT_OID_MAX_HEXSIZE+1]; } git_threadstate; From 36b52506fff2b4c06d1885c648ea22debf7c813c Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 18 Aug 2023 12:36:44 +0100 Subject: [PATCH 367/608] errors: move into util --- src/{libgit2 => util}/errors.c | 8 ++++---- src/{libgit2 => util}/errors.h | 2 +- 2 files changed, 5 insertions(+), 5 deletions(-) rename src/{libgit2 => util}/errors.c (98%) rename src/{libgit2 => util}/errors.h (98%) diff --git a/src/libgit2/errors.c b/src/util/errors.c similarity index 98% rename from src/libgit2/errors.c rename to src/util/errors.c index cfaa367d925..68e7a415625 100644 --- a/src/libgit2/errors.c +++ b/src/util/errors.c @@ -5,11 +5,11 @@ * a Linking Exception. For full terms see the included COPYING file. */ -#include "common.h" +#include "git2_util.h" +#include "errors.h" #include "posix.h" #include "str.h" -#include "libgit2.h" #include "runtime.h" /* @@ -23,7 +23,7 @@ static git_error oom_error = { }; static git_error uninitialized_error = { - "libgit2 has not been initialized; you must call git_libgit2_init", + "library has not been initialized", GIT_ERROR_INVALID }; @@ -279,7 +279,7 @@ const git_error *git_error_last(void) struct error_threadstate *threadstate; /* If the library is not initialized, return a static error. */ - if (!git_libgit2_init_count()) + if (!git_runtime_init_count()) return &uninitialized_error; if ((threadstate = threadstate_get()) == NULL) diff --git a/src/libgit2/errors.h b/src/util/errors.h similarity index 98% rename from src/libgit2/errors.h rename to src/util/errors.h index 755fd4db460..8d5877550b1 100644 --- a/src/libgit2/errors.h +++ b/src/util/errors.h @@ -8,7 +8,7 @@ #ifndef INCLUDE_errors_h__ #define INCLUDE_errors_h__ -#include "common.h" +#include "git2_util.h" #include "git2/sys/errors.h" /* Initialize the error thread-state. */ From 1265986b69866f84b01fb7694ac6832c9b249977 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 18 Aug 2023 14:54:47 +0100 Subject: [PATCH 368/608] oid: move thread local storage into oid.c Now that thread-local error data is handled in error, move the thread local data out of the `threadstate` object, since it has now become useless indirection. --- src/libgit2/libgit2.c | 1 + src/libgit2/oid.c | 37 ++++++++++++++++++++++++++++++++----- src/libgit2/oid.h | 2 ++ 3 files changed, 35 insertions(+), 5 deletions(-) diff --git a/src/libgit2/libgit2.c b/src/libgit2/libgit2.c index 715fbec1d79..2bbbccbae03 100644 --- a/src/libgit2/libgit2.c +++ b/src/libgit2/libgit2.c @@ -76,6 +76,7 @@ int git_libgit2_init(void) git_error_global_init, git_threadstate_global_init, git_threads_global_init, + git_oid_global_init, git_rand_global_init, git_hash_global_init, git_sysdir_global_init, diff --git a/src/libgit2/oid.c b/src/libgit2/oid.c index 631a566ebaa..2bb7a6f6bc4 100644 --- a/src/libgit2/oid.c +++ b/src/libgit2/oid.c @@ -9,7 +9,7 @@ #include "git2/oid.h" #include "repository.h" -#include "threadstate.h" +#include "runtime.h" #include #include @@ -153,15 +153,42 @@ int git_oid_pathfmt(char *str, const git_oid *oid) return 0; } +static git_tlsdata_key thread_str_key; + +static void GIT_SYSTEM_CALL thread_str_free(void *s) +{ + char *str = (char *)s; + git__free(str); +} + +static void thread_str_global_shutdown(void) +{ + char *str = git_tlsdata_get(thread_str_key); + git_tlsdata_set(thread_str_key, NULL); + + git__free(str); + git_tlsdata_dispose(thread_str_key); +} + +int git_oid_global_init(void) +{ + if (git_tlsdata_init(&thread_str_key, thread_str_free) != 0) + return -1; + + return git_runtime_shutdown_register(thread_str_global_shutdown); +} + char *git_oid_tostr_s(const git_oid *oid) { - git_threadstate *threadstate = git_threadstate_get(); char *str; - if (!threadstate) - return NULL; + if ((str = git_tlsdata_get(thread_str_key)) == NULL) { + if ((str = git__malloc(GIT_OID_MAX_HEXSIZE + 1)) == NULL) + return NULL; + + git_tlsdata_set(thread_str_key, str); + } - str = threadstate->oid_fmt; git_oid_nfmt(str, git_oid_hexsize(git_oid_type(oid)) + 1, oid); return str; } diff --git a/src/libgit2/oid.h b/src/libgit2/oid.h index 7b6b09d8bb6..f25a899a681 100644 --- a/src/libgit2/oid.h +++ b/src/libgit2/oid.h @@ -270,4 +270,6 @@ int git_oid__fromstrn( int git_oid__fromraw(git_oid *out, const unsigned char *raw, git_oid_t type); +int git_oid_global_init(void); + #endif From 5a63b43d970637158aa02a11bf23b23949bfe32b Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 18 Aug 2023 14:56:26 +0100 Subject: [PATCH 369/608] threadstate: remove the thread state object We now have no "big single object" that contains thread state. --- src/libgit2/libgit2.c | 2 - src/libgit2/threadstate.c | 88 --------------------------------------- src/libgit2/threadstate.h | 19 --------- 3 files changed, 109 deletions(-) delete mode 100644 src/libgit2/threadstate.c delete mode 100644 src/libgit2/threadstate.h diff --git a/src/libgit2/libgit2.c b/src/libgit2/libgit2.c index 2bbbccbae03..777dcbbb558 100644 --- a/src/libgit2/libgit2.c +++ b/src/libgit2/libgit2.c @@ -26,7 +26,6 @@ #include "runtime.h" #include "sysdir.h" #include "thread.h" -#include "threadstate.h" #include "git2/global.h" #include "streams/registry.h" #include "streams/mbedtls.h" @@ -74,7 +73,6 @@ int git_libgit2_init(void) #endif git_allocator_global_init, git_error_global_init, - git_threadstate_global_init, git_threads_global_init, git_oid_global_init, git_rand_global_init, diff --git a/src/libgit2/threadstate.c b/src/libgit2/threadstate.c deleted file mode 100644 index e521450921d..00000000000 --- a/src/libgit2/threadstate.c +++ /dev/null @@ -1,88 +0,0 @@ -/* - * Copyright (C) the libgit2 contributors. All rights reserved. - * - * This file is part of libgit2, distributed under the GNU GPL v2 with - * a Linking Exception. For full terms see the included COPYING file. - */ - -#include "threadstate.h" -#include "runtime.h" - -/** - * Handle the thread-local state - * - * `git_threadstate_global_init` will be called as part - * of `git_libgit2_init` (which itself must be called - * before calling any other function in the library). - * - * This function allocates a TLS index to store the per- - * thread state. - * - * Any internal method that requires thread-local state - * will then call `git_threadstate_get()` which returns a - * pointer to the thread-local state structure; this - * structure is lazily allocated on each thread. - * - * This mechanism will register a shutdown handler - * (`git_threadstate_global_shutdown`) which will free the - * TLS index. This shutdown handler will be called by - * `git_libgit2_shutdown`. - */ - -static git_tlsdata_key tls_key; - -static void threadstate_dispose(git_threadstate *threadstate) -{ - if (!threadstate) - return; -} - -static void GIT_SYSTEM_CALL threadstate_free(void *threadstate) -{ - threadstate_dispose(threadstate); - git__free(threadstate); -} - -static void git_threadstate_global_shutdown(void) -{ - git_threadstate *threadstate; - - threadstate = git_tlsdata_get(tls_key); - git_tlsdata_set(tls_key, NULL); - - threadstate_dispose(threadstate); - git__free(threadstate); - - git_tlsdata_dispose(tls_key); -} - -int git_threadstate_global_init(void) -{ - if (git_tlsdata_init(&tls_key, &threadstate_free) != 0) - return -1; - - return git_runtime_shutdown_register(git_threadstate_global_shutdown); -} - -git_threadstate *git_threadstate_get(void) -{ - git_threadstate *threadstate; - - if ((threadstate = git_tlsdata_get(tls_key)) != NULL) - return threadstate; - - /* - * Avoid git__malloc here, since if it fails, it sets an error - * message, which requires thread state, which would allocate - * here, which would fail, which would set an error message... - */ - - if ((threadstate = git__allocator.gmalloc(sizeof(git_threadstate), - __FILE__, __LINE__)) == NULL) - return NULL; - - memset(threadstate, 0, sizeof(git_threadstate)); - - git_tlsdata_set(tls_key, threadstate); - return threadstate; -} diff --git a/src/libgit2/threadstate.h b/src/libgit2/threadstate.h deleted file mode 100644 index 7a3bbd9a1aa..00000000000 --- a/src/libgit2/threadstate.h +++ /dev/null @@ -1,19 +0,0 @@ -/* - * Copyright (C) the libgit2 contributors. All rights reserved. - * - * This file is part of libgit2, distributed under the GNU GPL v2 with - * a Linking Exception. For full terms see the included COPYING file. - */ -#ifndef INCLUDE_threadstate_h__ -#define INCLUDE_threadstate_h__ - -#include "common.h" - -typedef struct { - char oid_fmt[GIT_OID_MAX_HEXSIZE+1]; -} git_threadstate; - -extern int git_threadstate_global_init(void); -extern git_threadstate *git_threadstate_get(void); - -#endif From 40556c798aa23e13e4e6f859c3e43b7e118a7ab0 Mon Sep 17 00:00:00 2001 From: Christopher Fujino Date: Sat, 9 Sep 2023 20:06:03 -0700 Subject: [PATCH 370/608] add dl to LIBGIT2_SYSTEM_LIBS --- cmake/SelectHTTPSBackend.cmake | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cmake/SelectHTTPSBackend.cmake b/cmake/SelectHTTPSBackend.cmake index 0b3d63a790c..94a0953f891 100644 --- a/cmake/SelectHTTPSBackend.cmake +++ b/cmake/SelectHTTPSBackend.cmake @@ -54,7 +54,7 @@ if(USE_HTTPS) set(GIT_OPENSSL 1) list(APPEND LIBGIT2_SYSTEM_INCLUDES ${OPENSSL_INCLUDE_DIR}) - list(APPEND LIBGIT2_SYSTEM_LIBS ${OPENSSL_LIBRARIES}) + list(APPEND LIBGIT2_SYSTEM_LIBS ${OPENSSL_LIBRARIES} ${CMAKE_DL_LIBS}) list(APPEND LIBGIT2_PC_LIBS ${OPENSSL_LDFLAGS}) list(APPEND LIBGIT2_PC_REQUIRES "openssl") elseif(USE_HTTPS STREQUAL "mbedTLS") From 8dd5d60e807fc49f136921c7537688de77d6190e Mon Sep 17 00:00:00 2001 From: Christopher Fujino Date: Sat, 9 Sep 2023 20:50:42 -0700 Subject: [PATCH 371/608] guard --- cmake/SelectHTTPSBackend.cmake | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/cmake/SelectHTTPSBackend.cmake b/cmake/SelectHTTPSBackend.cmake index 94a0953f891..fbc2adc147f 100644 --- a/cmake/SelectHTTPSBackend.cmake +++ b/cmake/SelectHTTPSBackend.cmake @@ -54,7 +54,10 @@ if(USE_HTTPS) set(GIT_OPENSSL 1) list(APPEND LIBGIT2_SYSTEM_INCLUDES ${OPENSSL_INCLUDE_DIR}) - list(APPEND LIBGIT2_SYSTEM_LIBS ${OPENSSL_LIBRARIES} ${CMAKE_DL_LIBS}) + list(APPEND LIBGIT2_SYSTEM_LIBS ${OPENSSL_LIBRARIES}) + if(LINK_WITH_STATIC_LIBRARIES STREQUAL ON) + list(APPEND LIBGIT2_SYSTEM_LIBS ${CMAKE_DL_LIBS}) + endif() list(APPEND LIBGIT2_PC_LIBS ${OPENSSL_LDFLAGS}) list(APPEND LIBGIT2_PC_REQUIRES "openssl") elseif(USE_HTTPS STREQUAL "mbedTLS") From 863ff79ff01988b634f7ae4caa5890d5ad83fc68 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= Date: Tue, 19 Sep 2023 21:49:49 +0300 Subject: [PATCH 372/608] net: copy the option-injection detection from git This function returns true if the string starts with a `-` as that could be used to inject options into commands we execute. --- src/util/net.c | 5 +++++ src/util/net.h | 9 +++++++++ 2 files changed, 14 insertions(+) diff --git a/src/util/net.c b/src/util/net.c index afd52ce0830..9c5ff1df44a 100644 --- a/src/util/net.c +++ b/src/util/net.c @@ -1152,3 +1152,8 @@ void git_net_url_dispose(git_net_url *url) git__free(url->username); url->username = NULL; git__free(url->password); url->password = NULL; } + +int git_net_looks_like_command_line_option(const char *str) +{ + return str && str[0] == '-'; +} diff --git a/src/util/net.h b/src/util/net.h index 8024956ad0c..1b82bd1dce3 100644 --- a/src/util/net.h +++ b/src/util/net.h @@ -107,4 +107,13 @@ extern bool git_net_url_matches_pattern_list( /** Disposes the contents of the structure. */ extern void git_net_url_dispose(git_net_url *url); + +/** + * Returns true if the string starts with a dash + * + * These could be used to try to trick an executed subcommand like ssh to do + * something other than what we intend. + */ +int git_net_looks_like_command_line_option(const char *str); + #endif From cf7477a82be9e6e59bb509d236d8a1ae2fc8d21f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= Date: Tue, 19 Sep 2023 19:13:46 +0300 Subject: [PATCH 373/608] ssh_exec: detect a potentially malicious ssh url string If you pass along something like `-oProxyCommand=...` as the hostname, we would pass that along to ssh unbeknownst to us and potentially also the user, if they were asking a tool to recursively clone submodules. This is the same fix as mainline git although they don't separate the username and host for ssh so ours looks like it's checking more. --- src/libgit2/transports/ssh_exec.c | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/src/libgit2/transports/ssh_exec.c b/src/libgit2/transports/ssh_exec.c index 786e7ee8bdb..1aa7a65d9fc 100644 --- a/src/libgit2/transports/ssh_exec.c +++ b/src/libgit2/transports/ssh_exec.c @@ -132,6 +132,26 @@ static int get_ssh_cmdline( const char *default_ssh_cmd = "ssh"; int error; + /* Safety check: like git, we forbid paths that look like an option as + * that could lead to injection to ssh that can make us do unexpected + * things */ + if (git_net_looks_like_command_line_option(url->username)) { + git_error_set(GIT_ERROR_NET, "strange username '%s' blocked", url->username); + return -1; + } + if (git_net_looks_like_command_line_option(url->host)) { + git_error_set(GIT_ERROR_NET, "strange host '%s' blocked", url->host); + return -1; + } + + /* Safety check: like git, we forbid paths that look like an option as + * that could lead to injection on the remote side */ + if (git_net_looks_like_command_line_option(url->path)) { + git_error_set(GIT_ERROR_NET, "strange path '%s' blocked", url->path); + return -1; + } + + if ((error = git_repository_config_snapshot(&cfg, repo)) < 0) return error; From 517bd0d30c02914e733e7d59742ce791801ece75 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= Date: Wed, 20 Sep 2023 00:39:41 +0300 Subject: [PATCH 374/608] ssh: reject suspicious path Like in the previous commit and in git, we reject a path that looks like an option to avoid injection into the command we ask the remote to execute. --- src/libgit2/transports/ssh_libssh2.c | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/src/libgit2/transports/ssh_libssh2.c b/src/libgit2/transports/ssh_libssh2.c index e32587683de..e74205bff00 100644 --- a/src/libgit2/transports/ssh_libssh2.c +++ b/src/libgit2/transports/ssh_libssh2.c @@ -788,6 +788,15 @@ static int _git_ssh_setup_conn( if (error < 0) goto done; + /* Safety check: like git, we forbid paths that look like an option as + * that could lead to injection on the remote side */ + if (git_net_looks_like_command_line_option(s->url.path)) { + git_error_set(GIT_ERROR_NET, "strange path '%s' blocked", s->url.path); + error = -1; + goto done; + } + + if ((error = git_socket_stream_new(&s->io, s->url.host, s->url.port)) < 0 || (error = git_stream_connect(s->io)) < 0) goto done; From 687da95ec8d778c475dc17a9b292d5c25647421e Mon Sep 17 00:00:00 2001 From: Antonin Delpeuch Date: Sat, 23 Sep 2023 12:00:19 +0200 Subject: [PATCH 375/608] blame example: Fix support for line range in CLI The -L option announced by the CLI was ignored so far. --- examples/blame.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/examples/blame.c b/examples/blame.c index 77087a5771a..0996e7a1fdb 100644 --- a/examples/blame.c +++ b/examples/blame.c @@ -47,6 +47,10 @@ int lg2_blame(git_repository *repo, int argc, char *argv[]) if (o.M) blameopts.flags |= GIT_BLAME_TRACK_COPIES_SAME_COMMIT_MOVES; if (o.C) blameopts.flags |= GIT_BLAME_TRACK_COPIES_SAME_COMMIT_COPIES; if (o.F) blameopts.flags |= GIT_BLAME_FIRST_PARENT; + if (o.start_line && o.end_line) { + blameopts.min_line = o.start_line; + blameopts.max_line = o.end_line; + } /** * The commit range comes in "committish" form. Use the rev-parse API to From ad3799e8120de26b418a28b1d04c33523809e0ca Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= Date: Wed, 20 Sep 2023 17:13:28 +0300 Subject: [PATCH 376/608] tests: add tests for injection rejection in ssh exec --- tests/libgit2/transport/ssh_exec.c | 79 ++++++++++++++++++++++++++++++ 1 file changed, 79 insertions(+) create mode 100644 tests/libgit2/transport/ssh_exec.c diff --git a/tests/libgit2/transport/ssh_exec.c b/tests/libgit2/transport/ssh_exec.c new file mode 100644 index 00000000000..886c10ad7c3 --- /dev/null +++ b/tests/libgit2/transport/ssh_exec.c @@ -0,0 +1,79 @@ +#include "clar_libgit2.h" +#include "git2/sys/remote.h" +#include "git2/sys/transport.h" + + +void test_transport_ssh_exec__reject_injection_username(void) +{ +#ifndef GIT_SSH_EXEC + cl_skip(); +#else + git_remote *remote; + git_repository *repo; + git_transport *transport; + const char *url = "-oProxyCommand=git@somehost:somepath"; + git_remote_connect_options opts = GIT_REMOTE_CONNECT_OPTIONS_INIT; + + + cl_git_pass(git_repository_init(&repo, "./transport-username", 0)); + cl_git_pass(git_remote_create(&remote, repo, "test", + cl_fixture("testrepo.git"))); + cl_git_pass(git_transport_new(&transport, remote, url)); + cl_git_fail_with(-1, transport->connect(transport, url, + GIT_SERVICE_UPLOADPACK_LS, &opts)); + + transport->free(transport); + git_remote_free(remote); + git_repository_free(repo); +#endif +} + +void test_transport_ssh_exec__reject_injection_hostname(void) +{ +#ifndef GIT_SSH_EXEC + cl_skip(); +#else + git_remote *remote; + git_repository *repo; + git_transport *transport; + const char *url = "-oProxyCommand=somehost:somepath-hostname"; + git_remote_connect_options opts = GIT_REMOTE_CONNECT_OPTIONS_INIT; + + + cl_git_pass(git_repository_init(&repo, "./transport-hostname", 0)); + cl_git_pass(git_remote_create(&remote, repo, "test", + cl_fixture("testrepo.git"))); + cl_git_pass(git_transport_new(&transport, remote, url)); + cl_git_fail_with(-1, transport->connect(transport, url, + GIT_SERVICE_UPLOADPACK_LS, &opts)); + + transport->free(transport); + git_remote_free(remote); + git_repository_free(repo); +#endif +} + +void test_transport_ssh_exec__reject_injection_path(void) +{ +#ifndef GIT_SSH_EXEC + cl_skip(); +#else + git_remote *remote; + git_repository *repo; + git_transport *transport; + const char *url = "git@somehost:-somepath"; + git_remote_connect_options opts = GIT_REMOTE_CONNECT_OPTIONS_INIT; + + + cl_git_pass(git_repository_init(&repo, "./transport-path", 0)); + cl_git_pass(git_remote_create(&remote, repo, "test", + cl_fixture("testrepo.git"))); + cl_git_pass(git_transport_new(&transport, remote, url)); + cl_git_fail_with(-1, transport->connect(transport, url, + GIT_SERVICE_UPLOADPACK_LS, &opts)); + + transport->free(transport); + git_remote_free(remote); + git_repository_free(repo); +#endif +} From aa5994b0174b8042d3d5a3887c162b6be2cab74f Mon Sep 17 00:00:00 2001 From: Yori Date: Fri, 6 Oct 2023 17:26:55 +1100 Subject: [PATCH 377/608] diff: fix removal of unmodified deltas When finding similar deltas, count the targets that are tagged to be deleted. Apply deletions even in the absense of rewrites or updates. --- src/libgit2/diff_tform.c | 14 ++++++++----- tests/libgit2/diff/rename.c | 41 +++++++++++++++++++++++++++++++++++++ 2 files changed, 50 insertions(+), 5 deletions(-) diff --git a/src/libgit2/diff_tform.c b/src/libgit2/diff_tform.c index 4a156c7a341..7b31905c0f6 100644 --- a/src/libgit2/diff_tform.c +++ b/src/libgit2/diff_tform.c @@ -810,7 +810,7 @@ int git_diff_find_similar( git_diff_find_options opts = GIT_DIFF_FIND_OPTIONS_INIT; size_t num_deltas, num_srcs = 0, num_tgts = 0; size_t tried_srcs = 0, tried_tgts = 0; - size_t num_rewrites = 0, num_updates = 0, num_bumped = 0; + size_t num_rewrites = 0, num_updates = 0, num_bumped = 0, num_to_delete = 0; size_t sigcache_size; void **sigcache = NULL; /* cache of similarity metric file signatures */ diff_find_match *tgt2src = NULL; @@ -852,11 +852,14 @@ int git_diff_find_similar( if ((tgt->flags & GIT_DIFF_FLAG__TO_SPLIT) != 0) num_rewrites++; + + if ((tgt->flags & GIT_DIFF_FLAG__TO_DELETE) != 0) + num_to_delete++; } - /* if there are no candidate srcs or tgts, we're done */ + /* If there are no candidate srcs or tgts, no need to find matches */ if (!num_srcs || !num_tgts) - goto cleanup; + goto split_and_delete; src2tgt = git__calloc(num_deltas, sizeof(diff_find_match)); GIT_ERROR_CHECK_ALLOC(src2tgt); @@ -1093,13 +1096,14 @@ int git_diff_find_similar( } } +split_and_delete: /* * Actually split and delete entries as needed */ - if (num_rewrites > 0 || num_updates > 0) + if (num_rewrites > 0 || num_updates > 0 || num_to_delete > 0) error = apply_splits_and_deletes( - diff, diff->deltas.length - num_rewrites, + diff, diff->deltas.length - num_rewrites - num_to_delete, FLAG_SET(&opts, GIT_DIFF_BREAK_REWRITES) && !FLAG_SET(&opts, GIT_DIFF_BREAK_REWRITES_FOR_RENAMES_ONLY)); diff --git a/tests/libgit2/diff/rename.c b/tests/libgit2/diff/rename.c index 9d44394624d..2fbcb2f7087 100644 --- a/tests/libgit2/diff/rename.c +++ b/tests/libgit2/diff/rename.c @@ -1441,6 +1441,47 @@ void test_diff_rename__can_delete_unmodified_deltas(void) git_str_dispose(&c1); } +void test_diff_rename__can_delete_unmodified_deltas_without_changes(void) +{ + git_str c1 = GIT_STR_INIT; + git_index *index; + git_tree *tree; + git_diff *diff; + git_diff_options diffopts = GIT_DIFF_OPTIONS_INIT; + git_diff_find_options opts = GIT_DIFF_FIND_OPTIONS_INIT; + diff_expects exp; + + cl_git_pass( + git_revparse_single((git_object **)&tree, g_repo, "HEAD^{tree}")); + + cl_git_pass(git_repository_index(&index, g_repo)); + cl_git_pass(git_index_read_tree(index, tree)); + + diffopts.flags = GIT_DIFF_INCLUDE_UNMODIFIED; + + cl_git_pass(git_diff_tree_to_index(&diff, g_repo, tree, index, &diffopts)); + + memset(&exp, 0, sizeof(exp)); + cl_git_pass(git_diff_foreach( + diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp)); + cl_assert_equal_i(4, exp.files); + cl_assert_equal_i(4, exp.file_status[GIT_DELTA_UNMODIFIED]); + + opts.flags = GIT_DIFF_FIND_ALL | GIT_DIFF_FIND_REMOVE_UNMODIFIED; + cl_git_pass(git_diff_find_similar(diff, &opts)); + + memset(&exp, 0, sizeof(exp)); + cl_git_pass(git_diff_foreach( + diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp)); + cl_assert_equal_i(0, exp.files); + + git_diff_free(diff); + git_tree_free(tree); + git_index_free(index); + + git_str_dispose(&c1); +} + void test_diff_rename__matches_config_behavior(void) { const char *sha0 = INITIAL_COMMIT; From e69ca3212ce4482863d89a341a27c57bf0256f2f Mon Sep 17 00:00:00 2001 From: Yori Date: Sat, 7 Oct 2023 13:28:37 +1100 Subject: [PATCH 378/608] diff: fix removal of unmodified non-blob deltas MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit When excluding non-blob deltas as potential rename sources, honour the “remove unmodified” option (if the delta is unmodified). --- src/libgit2/diff_tform.c | 9 ++++++++- tests/libgit2/diff/rename.c | 21 +++++++++++++-------- 2 files changed, 21 insertions(+), 9 deletions(-) diff --git a/src/libgit2/diff_tform.c b/src/libgit2/diff_tform.c index 7b31905c0f6..a90ab07c9b9 100644 --- a/src/libgit2/diff_tform.c +++ b/src/libgit2/diff_tform.c @@ -718,8 +718,15 @@ static bool is_rename_source( git_diff_delta *delta = GIT_VECTOR_GET(&diff->deltas, delta_idx); /* skip things that aren't blobs */ - if (!GIT_MODE_ISBLOB(delta->old_file.mode)) + if (!GIT_MODE_ISBLOB(delta->old_file.mode)) { + + /* but still honor "remove unmodified" flag */ + if (delta->status == GIT_DELTA_UNMODIFIED && + FLAG_SET(opts, GIT_DIFF_FIND_REMOVE_UNMODIFIED)) + delta->flags |= GIT_DIFF_FLAG__TO_DELETE; + return false; + } switch (delta->status) { case GIT_DELTA_ADDED: diff --git a/tests/libgit2/diff/rename.c b/tests/libgit2/diff/rename.c index 2fbcb2f7087..61a2f839cb3 100644 --- a/tests/libgit2/diff/rename.c +++ b/tests/libgit2/diff/rename.c @@ -1441,9 +1441,9 @@ void test_diff_rename__can_delete_unmodified_deltas(void) git_str_dispose(&c1); } -void test_diff_rename__can_delete_unmodified_deltas_without_changes(void) +void test_diff_rename__can_delete_unmodified_deltas_including_submodule(void) { - git_str c1 = GIT_STR_INIT; + git_repository *repo; /* "submodules" */ git_index *index; git_tree *tree; git_diff *diff; @@ -1451,21 +1451,26 @@ void test_diff_rename__can_delete_unmodified_deltas_without_changes(void) git_diff_find_options opts = GIT_DIFF_FIND_OPTIONS_INIT; diff_expects exp; + cl_git_sandbox_cleanup(); /* Don't use "renames" for this test */ + repo = cl_git_sandbox_init("submodules"); + + cl_repo_set_bool(repo, "core.autocrlf", false); + cl_git_pass( - git_revparse_single((git_object **)&tree, g_repo, "HEAD^{tree}")); + git_revparse_single((git_object **)&tree, repo, "HEAD^{tree}")); - cl_git_pass(git_repository_index(&index, g_repo)); + cl_git_pass(git_repository_index(&index, repo)); cl_git_pass(git_index_read_tree(index, tree)); diffopts.flags = GIT_DIFF_INCLUDE_UNMODIFIED; - cl_git_pass(git_diff_tree_to_index(&diff, g_repo, tree, index, &diffopts)); + cl_git_pass(git_diff_tree_to_index(&diff, repo, tree, index, &diffopts)); memset(&exp, 0, sizeof(exp)); cl_git_pass(git_diff_foreach( diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp)); - cl_assert_equal_i(4, exp.files); - cl_assert_equal_i(4, exp.file_status[GIT_DELTA_UNMODIFIED]); + cl_assert_equal_i(5, exp.files); + cl_assert_equal_i(5, exp.file_status[GIT_DELTA_UNMODIFIED]); opts.flags = GIT_DIFF_FIND_ALL | GIT_DIFF_FIND_REMOVE_UNMODIFIED; cl_git_pass(git_diff_find_similar(diff, &opts)); @@ -1479,7 +1484,7 @@ void test_diff_rename__can_delete_unmodified_deltas_without_changes(void) git_tree_free(tree); git_index_free(index); - git_str_dispose(&c1); + cl_git_sandbox_cleanup(); } void test_diff_rename__matches_config_behavior(void) From 95e517bee5ad4ddb1c2344cbfe6c7ad15ca78cd3 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sun, 15 Oct 2023 13:53:21 +0100 Subject: [PATCH 379/608] remote: optionally report unchanged tips --- include/git2/remote.h | 30 +++++++++++++----- src/libgit2/clone.c | 2 +- src/libgit2/remote.c | 59 +++++++++++++++++++++--------------- tests/libgit2/online/fetch.c | 45 ++++++++++++++++++++++++++- 4 files changed, 103 insertions(+), 33 deletions(-) diff --git a/include/git2/remote.h b/include/git2/remote.h index e9065b250c1..87577123c8d 100644 --- a/include/git2/remote.h +++ b/include/git2/remote.h @@ -76,6 +76,17 @@ typedef enum { GIT_REMOTE_CREATE_SKIP_DEFAULT_FETCHSPEC = (1 << 1) } git_remote_create_flags; +/** + * How to handle reference updates. + */ +typedef enum { + /* Write the fetch results to FETCH_HEAD. */ + GIT_REMOTE_UPDATE_FETCHHEAD = (1 << 0), + + /* Report unchanged tips in the update_tips callback. */ + GIT_REMOTE_UPDATE_REPORT_UNCHANGED = (1 << 1) +} git_remote_update_flags; + /** * Remote creation options structure * @@ -733,10 +744,10 @@ typedef struct { git_fetch_prune_t prune; /** - * Whether to write the results to FETCH_HEAD. Defaults to - * on. Leave this default in order to behave like git. + * How to handle reference updates; a combination of + * `git_remote_update_flags`. */ - int update_fetchhead; + unsigned int update_flags; /** * Determines how to behave regarding tags on the remote, such @@ -775,8 +786,13 @@ typedef struct { } git_fetch_options; #define GIT_FETCH_OPTIONS_VERSION 1 -#define GIT_FETCH_OPTIONS_INIT { GIT_FETCH_OPTIONS_VERSION, GIT_REMOTE_CALLBACKS_INIT, GIT_FETCH_PRUNE_UNSPECIFIED, 1, \ - GIT_REMOTE_DOWNLOAD_TAGS_UNSPECIFIED, GIT_PROXY_OPTIONS_INIT } +#define GIT_FETCH_OPTIONS_INIT { \ + GIT_FETCH_OPTIONS_VERSION, \ + GIT_REMOTE_CALLBACKS_INIT, \ + GIT_FETCH_PRUNE_UNSPECIFIED, \ + GIT_REMOTE_UPDATE_FETCHHEAD, \ + GIT_REMOTE_DOWNLOAD_TAGS_UNSPECIFIED, \ + GIT_PROXY_OPTIONS_INIT } /** * Initialize git_fetch_options structure @@ -1001,7 +1017,7 @@ GIT_EXTERN(int) git_remote_upload( * the name of the remote (or its url, for in-memory remotes). This * parameter is ignored when pushing. * @param callbacks pointer to the callback structure to use or NULL - * @param update_fetchhead whether to write to FETCH_HEAD. Pass 1 to behave like git. + * @param update_flags the git_remote_update_flags for these tips. * @param download_tags what the behaviour for downloading tags is for this fetch. This is * ignored for push. This must be the same value passed to `git_remote_download()`. * @return 0 or an error code @@ -1009,7 +1025,7 @@ GIT_EXTERN(int) git_remote_upload( GIT_EXTERN(int) git_remote_update_tips( git_remote *remote, const git_remote_callbacks *callbacks, - int update_fetchhead, + unsigned int update_flags, git_remote_autotag_option_t download_tags, const char *reflog_message); diff --git a/src/libgit2/clone.c b/src/libgit2/clone.c index ab48191cc6a..27bae1ac499 100644 --- a/src/libgit2/clone.c +++ b/src/libgit2/clone.c @@ -419,7 +419,7 @@ static int clone_into( return error; memcpy(&fetch_opts, opts, sizeof(git_fetch_options)); - fetch_opts.update_fetchhead = 0; + fetch_opts.update_flags = ~GIT_REMOTE_UPDATE_FETCHHEAD; if (!opts->depth) fetch_opts.download_tags = GIT_REMOTE_DOWNLOAD_TAGS_ALL; diff --git a/src/libgit2/remote.c b/src/libgit2/remote.c index fee2a7f3968..97d32200c66 100644 --- a/src/libgit2/remote.c +++ b/src/libgit2/remote.c @@ -1348,13 +1348,14 @@ int git_remote_fetch( const git_fetch_options *opts, const char *reflog_message) { - int error, update_fetchhead = 1; git_remote_autotag_option_t tagopt = remote->download_tags; bool prune = false; git_str reflog_msg_buf = GIT_STR_INIT; git_remote_connect_options connect_opts = GIT_REMOTE_CONNECT_OPTIONS_INIT; unsigned int capabilities; git_oid_t oid_type; + unsigned int update_flags = GIT_REMOTE_UPDATE_FETCHHEAD; + int error; GIT_ASSERT_ARG(remote); @@ -1371,7 +1372,7 @@ int git_remote_fetch( return error; if (opts) { - update_fetchhead = opts->update_fetchhead; + update_flags = opts->update_flags; tagopt = opts->download_tags; } @@ -1398,8 +1399,14 @@ int git_remote_fetch( } /* Create "remote/foo" branches for all remote branches */ - error = git_remote_update_tips(remote, &connect_opts.callbacks, update_fetchhead, tagopt, git_str_cstr(&reflog_msg_buf)); + error = git_remote_update_tips(remote, + &connect_opts.callbacks, + update_flags, + tagopt, + git_str_cstr(&reflog_msg_buf)); + git_str_dispose(&reflog_msg_buf); + if (error < 0) goto done; @@ -1774,6 +1781,7 @@ static int update_one_tip( git_refspec *spec, git_remote_head *head, git_refspec *tagspec, + unsigned int update_flags, git_remote_autotag_option_t tagopt, const char *log_message, const git_remote_callbacks *callbacks) @@ -1781,7 +1789,7 @@ static int update_one_tip( git_odb *odb; git_str refname = GIT_STR_INIT; git_reference *ref = NULL; - bool autotag = false; + bool autotag = false, updated = false; git_oid old; int valid; int error; @@ -1855,21 +1863,21 @@ static int update_one_tip( goto done; } - if (!git_oid__cmp(&old, &head->oid)) - goto done; + if ((updated = !git_oid_equal(&old, &head->oid))) { + /* In autotag mode, don't overwrite any locally-existing tags */ + error = git_reference_create(&ref, remote->repo, refname.ptr, &head->oid, !autotag, + log_message); - /* In autotag mode, don't overwrite any locally-existing tags */ - error = git_reference_create(&ref, remote->repo, refname.ptr, &head->oid, !autotag, - log_message); - - if (error < 0) { - if (error == GIT_EEXISTS) - error = 0; + if (error < 0) { + if (error == GIT_EEXISTS) + error = 0; - goto done; + goto done; + } } if (callbacks && callbacks->update_tips != NULL && + (updated || (update_flags & GIT_REMOTE_UPDATE_REPORT_UNCHANGED)) && (error = callbacks->update_tips(refname.ptr, &old, &head->oid, callbacks->payload)) < 0) git_error_set_after_callback_function(error, "git_remote_fetch"); @@ -1882,7 +1890,7 @@ static int update_one_tip( static int update_tips_for_spec( git_remote *remote, const git_remote_callbacks *callbacks, - int update_fetchhead, + unsigned int update_flags, git_remote_autotag_option_t tagopt, git_refspec *spec, git_vector *refs, @@ -1905,7 +1913,10 @@ static int update_tips_for_spec( /* Update tips based on the remote heads */ git_vector_foreach(refs, i, head) { - if (update_one_tip(&update_heads, remote, spec, head, &tagspec, tagopt, log_message, callbacks) < 0) + if (update_one_tip(&update_heads, + remote, spec, head, &tagspec, + update_flags, tagopt, log_message, + callbacks) < 0) goto on_error; } @@ -1927,7 +1938,7 @@ static int update_tips_for_spec( goto on_error; } - if (update_fetchhead && + if ((update_flags & GIT_REMOTE_UPDATE_FETCHHEAD) && (error = git_remote_write_fetchhead(remote, spec, &update_heads)) < 0) goto on_error; @@ -2058,11 +2069,11 @@ static int truncate_fetch_head(const char *gitdir) } int git_remote_update_tips( - git_remote *remote, - const git_remote_callbacks *callbacks, - int update_fetchhead, - git_remote_autotag_option_t download_tags, - const char *reflog_message) + git_remote *remote, + const git_remote_callbacks *callbacks, + unsigned int update_flags, + git_remote_autotag_option_t download_tags, + const char *reflog_message) { git_refspec *spec, tagspec; git_vector refs = GIT_VECTOR_INIT; @@ -2091,7 +2102,7 @@ int git_remote_update_tips( goto out; if (tagopt == GIT_REMOTE_DOWNLOAD_TAGS_ALL) { - if ((error = update_tips_for_spec(remote, callbacks, update_fetchhead, tagopt, &tagspec, &refs, reflog_message)) < 0) + if ((error = update_tips_for_spec(remote, callbacks, update_flags, tagopt, &tagspec, &refs, reflog_message)) < 0) goto out; } @@ -2099,7 +2110,7 @@ int git_remote_update_tips( if (spec->push) continue; - if ((error = update_tips_for_spec(remote, callbacks, update_fetchhead, tagopt, spec, &refs, reflog_message)) < 0) + if ((error = update_tips_for_spec(remote, callbacks, update_flags, tagopt, spec, &refs, reflog_message)) < 0) goto out; } diff --git a/tests/libgit2/online/fetch.c b/tests/libgit2/online/fetch.c index a557bbf7506..d640eac1b6c 100644 --- a/tests/libgit2/online/fetch.c +++ b/tests/libgit2/online/fetch.c @@ -128,6 +128,8 @@ void test_online_fetch__doesnt_retrieve_a_pack_when_the_repository_is_up_to_date git_clone_options opts = GIT_CLONE_OPTIONS_INIT; opts.bare = true; + counter = 0; + cl_git_pass(git_clone(&_repository, "https://github.com/libgit2/TestGitRepository.git", "./fetch/lg2", &opts)); git_repository_free(_repository); @@ -141,11 +143,52 @@ void test_online_fetch__doesnt_retrieve_a_pack_when_the_repository_is_up_to_date options.callbacks.transfer_progress = &transferProgressCallback; options.callbacks.payload = &invoked; + options.callbacks.update_tips = update_tips; cl_git_pass(git_remote_download(remote, NULL, &options)); cl_assert_equal_i(false, invoked); - cl_git_pass(git_remote_update_tips(remote, &options.callbacks, 1, options.download_tags, NULL)); + cl_git_pass(git_remote_update_tips(remote, &options.callbacks, GIT_REMOTE_UPDATE_FETCHHEAD, options.download_tags, NULL)); + cl_assert_equal_i(0, counter); + + git_remote_disconnect(remote); + + git_remote_free(remote); + git_repository_free(_repository); +} + +void test_online_fetch__report_unchanged_tips(void) +{ + git_repository *_repository; + bool invoked = false; + git_remote *remote; + git_fetch_options options = GIT_FETCH_OPTIONS_INIT; + git_clone_options opts = GIT_CLONE_OPTIONS_INIT; + opts.bare = true; + + counter = 0; + + cl_git_pass(git_clone(&_repository, "https://github.com/libgit2/TestGitRepository.git", + "./fetch/lg2", &opts)); + git_repository_free(_repository); + + cl_git_pass(git_repository_open(&_repository, "./fetch/lg2")); + + cl_git_pass(git_remote_lookup(&remote, _repository, "origin")); + cl_git_pass(git_remote_connect(remote, GIT_DIRECTION_FETCH, NULL, NULL, NULL)); + + cl_assert_equal_i(false, invoked); + + options.callbacks.transfer_progress = &transferProgressCallback; + options.callbacks.payload = &invoked; + options.callbacks.update_tips = update_tips; + cl_git_pass(git_remote_download(remote, NULL, &options)); + + cl_assert_equal_i(false, invoked); + + cl_git_pass(git_remote_update_tips(remote, &options.callbacks, GIT_REMOTE_UPDATE_REPORT_UNCHANGED, options.download_tags, NULL)); + cl_assert(counter > 0); + git_remote_disconnect(remote); git_remote_free(remote); From 7a060cc5bc9ca79e1d1e3e456d92b1985456d5b9 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sun, 15 Oct 2023 21:53:43 +0100 Subject: [PATCH 380/608] ssh: option injection code review --- src/libgit2/transports/ssh_exec.c | 26 +++++++++++--------------- src/libgit2/transports/ssh_libssh2.c | 5 +++-- src/util/net.c | 5 ----- src/util/net.h | 9 --------- src/util/process.h | 11 +++++++++++ 5 files changed, 25 insertions(+), 31 deletions(-) diff --git a/src/libgit2/transports/ssh_exec.c b/src/libgit2/transports/ssh_exec.c index 1aa7a65d9fc..a09c1db9441 100644 --- a/src/libgit2/transports/ssh_exec.c +++ b/src/libgit2/transports/ssh_exec.c @@ -132,26 +132,22 @@ static int get_ssh_cmdline( const char *default_ssh_cmd = "ssh"; int error; - /* Safety check: like git, we forbid paths that look like an option as - * that could lead to injection to ssh that can make us do unexpected - * things */ - if (git_net_looks_like_command_line_option(url->username)) { - git_error_set(GIT_ERROR_NET, "strange username '%s' blocked", url->username); + /* + * Safety check: like git, we forbid paths that look like an + * option as that could lead to injection to ssh that can make + * us do unexpected things + */ + if (git_process__is_cmdline_option(url->username)) { + git_error_set(GIT_ERROR_NET, "cannot ssh: username '%s' is ambiguous with command-line option", url->username); return -1; - } - if (git_net_looks_like_command_line_option(url->host)) { - git_error_set(GIT_ERROR_NET, "strange host '%s' blocked", url->host); + } else if (git_process__is_cmdline_option(url->host)) { + git_error_set(GIT_ERROR_NET, "cannot ssh: host '%s' is ambiguous with command-line option", url->host); return -1; - } - - /* Safety check: like git, we forbid paths that look like an option as - * that could lead to injection on the remote side */ - if (git_net_looks_like_command_line_option(url->path)) { - git_error_set(GIT_ERROR_NET, "strange path '%s' blocked", url->path); + } else if (git_process__is_cmdline_option(url->path)) { + git_error_set(GIT_ERROR_NET, "cannot ssh: path '%s' is ambiguous with command-line option", url->path); return -1; } - if ((error = git_repository_config_snapshot(&cfg, repo)) < 0) return error; diff --git a/src/libgit2/transports/ssh_libssh2.c b/src/libgit2/transports/ssh_libssh2.c index e74205bff00..d2be2ba3387 100644 --- a/src/libgit2/transports/ssh_libssh2.c +++ b/src/libgit2/transports/ssh_libssh2.c @@ -14,6 +14,7 @@ #include "runtime.h" #include "net.h" #include "smart.h" +#include "process.h" #include "streams/socket.h" #include "sysdir.h" @@ -790,8 +791,8 @@ static int _git_ssh_setup_conn( /* Safety check: like git, we forbid paths that look like an option as * that could lead to injection on the remote side */ - if (git_net_looks_like_command_line_option(s->url.path)) { - git_error_set(GIT_ERROR_NET, "strange path '%s' blocked", s->url.path); + if (git_process__is_cmdline_option(s->url.path)) { + git_error_set(GIT_ERROR_NET, "cannot ssh: path '%s' is ambiguous with command-line option", s->url.path); error = -1; goto done; } diff --git a/src/util/net.c b/src/util/net.c index 9c5ff1df44a..afd52ce0830 100644 --- a/src/util/net.c +++ b/src/util/net.c @@ -1152,8 +1152,3 @@ void git_net_url_dispose(git_net_url *url) git__free(url->username); url->username = NULL; git__free(url->password); url->password = NULL; } - -int git_net_looks_like_command_line_option(const char *str) -{ - return str && str[0] == '-'; -} diff --git a/src/util/net.h b/src/util/net.h index 1b82bd1dce3..8024956ad0c 100644 --- a/src/util/net.h +++ b/src/util/net.h @@ -107,13 +107,4 @@ extern bool git_net_url_matches_pattern_list( /** Disposes the contents of the structure. */ extern void git_net_url_dispose(git_net_url *url); - -/** - * Returns true if the string starts with a dash - * - * These could be used to try to trick an executed subcommand like ssh to do - * something other than what we intend. - */ -int git_net_looks_like_command_line_option(const char *str); - #endif diff --git a/src/util/process.h b/src/util/process.h index 87cf7acbd0c..9310652c325 100644 --- a/src/util/process.h +++ b/src/util/process.h @@ -106,6 +106,17 @@ extern int git_process__cmdline( #endif +/* + * Whether the given string looks like a command line option (starts + * with a dash). This is useful for examining strings that will become + * cmdline arguments to ensure that they are not erroneously treated + * as an option. For example, arguments to `ssh`. + */ +GIT_INLINE(bool) git_process__is_cmdline_option(const char *str) +{ + return (str && str[0] == '-'); +} + /** * Start the process. * From ffc12e66731ee002b35d498744fd2d767a95766a Mon Sep 17 00:00:00 2001 From: 7Ji Date: Tue, 31 Oct 2023 16:31:39 +0800 Subject: [PATCH 381/608] remote: fix memory leak in git_remote_download() connect_opts is created with its custom_headers and proxy_opts->url possibly allocated on heap, just like in git_remote_fetch(). But unlike in _fetch(), it is not disposed at the end of the function, thus causing memory leak. --- src/libgit2/remote.c | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/src/libgit2/remote.c b/src/libgit2/remote.c index 97d32200c66..fc37cf2a5ae 100644 --- a/src/libgit2/remote.c +++ b/src/libgit2/remote.c @@ -1339,7 +1339,11 @@ int git_remote_download( if ((error = connect_or_reset_options(remote, GIT_DIRECTION_FETCH, &connect_opts)) < 0) return error; - return git_remote__download(remote, refspecs, opts); + error = git_remote__download(remote, refspecs, opts); + + git_remote_connect_options_dispose(&connect_opts); + + return error; } int git_remote_fetch( From cf320cc125e589a4de109de9098d54098f03b31b Mon Sep 17 00:00:00 2001 From: Yuriy Chernyshov Date: Wed, 15 Nov 2023 16:03:07 +0300 Subject: [PATCH 382/608] Do not trim dots from usernames --- src/libgit2/signature.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/libgit2/signature.c b/src/libgit2/signature.c index 5d6ab572cbf..12d2b5f8d50 100644 --- a/src/libgit2/signature.c +++ b/src/libgit2/signature.c @@ -43,7 +43,6 @@ static bool contains_angle_brackets(const char *input) static bool is_crud(unsigned char c) { return c <= 32 || - c == '.' || c == ',' || c == ':' || c == ';' || From 51f0b0211bf8bb919ce5d3e600b7a7e281baba1f Mon Sep 17 00:00:00 2001 From: Peter Pettersson Date: Fri, 17 Nov 2023 18:25:09 +0100 Subject: [PATCH 383/608] util: make git_futils_readbuffer_updated header match source --- src/util/futils.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/util/futils.h b/src/util/futils.h index 3f207afb2f2..53bcc551890 100644 --- a/src/util/futils.h +++ b/src/util/futils.h @@ -25,7 +25,7 @@ extern int git_futils_readbuffer(git_str *obj, const char *path); extern int git_futils_readbuffer_updated( git_str *obj, const char *path, - unsigned char checksum[GIT_HASH_SHA1_SIZE], + unsigned char checksum[GIT_HASH_SHA256_SIZE], int *updated); extern int git_futils_readbuffer_fd_full(git_str *obj, git_file fd); extern int git_futils_readbuffer_fd(git_str *obj, git_file fd, size_t len); From b1b2f063c305c00253fa6204cf4c3c24f5e087be Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 20 Nov 2023 12:39:44 +0000 Subject: [PATCH 384/608] Update tests/resources/push.sh --- tests/resources/push.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/resources/push.sh b/tests/resources/push.sh index 54ef3ddf27c..648c2ad26f5 100644 --- a/tests/resources/push.sh +++ b/tests/resources/push.sh @@ -1,4 +1,4 @@ -#!/bin/bash +#!/usr/bin/env bash #creates push_src repo for libgit2 push tests. set -eu From a8cca4d5373f94cb5838715e0d3381a0f1dd79fb Mon Sep 17 00:00:00 2001 From: Yuriy Chernyshov Date: Tue, 21 Nov 2023 15:25:45 +0300 Subject: [PATCH 385/608] Update tests --- tests/libgit2/commit/signature.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/libgit2/commit/signature.c b/tests/libgit2/commit/signature.c index a91551415d6..32058f6c344 100644 --- a/tests/libgit2/commit/signature.c +++ b/tests/libgit2/commit/signature.c @@ -39,7 +39,7 @@ void test_commit_signature__leading_and_trailing_spaces_are_trimmed(void) void test_commit_signature__leading_and_trailing_crud_is_trimmed(void) { assert_name_and_email("nulltoken", "emeric.fermas@gmail.com", "\"nulltoken\"", "\"emeric.fermas@gmail.com\""); - assert_name_and_email("nulltoken w", "emeric.fermas@gmail.com", "nulltoken w.", "emeric.fermas@gmail.com"); + assert_name_and_email("nulltoken w", "emeric.fermas@gmail.com", "nulltoken w;", "emeric.fermas@gmail.com"); assert_name_and_email("nulltoken \xe2\x98\xba", "emeric.fermas@gmail.com", "nulltoken \xe2\x98\xba", "emeric.fermas@gmail.com"); } From 1f54d5bb5aae79b4f0ebd7767bac671903e54ed5 Mon Sep 17 00:00:00 2001 From: Peter Pettersson Date: Fri, 17 Nov 2023 19:19:12 +0100 Subject: [PATCH 386/608] util: suppress some uninitialized variable warnings --- src/util/net.c | 2 +- src/util/regexp.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/util/net.c b/src/util/net.c index afd52ce0830..24782d2af09 100644 --- a/src/util/net.c +++ b/src/util/net.c @@ -657,7 +657,7 @@ static bool has_at(const char *str) int git_net_url_parse_scp(git_net_url *url, const char *given) { const char *default_port = default_port_for_scheme("ssh"); - const char *c, *user, *host, *port, *path = NULL; + const char *c, *user, *host, *port = NULL, *path = NULL; size_t user_len = 0, host_len = 0, port_len = 0; unsigned short bracket = 0; diff --git a/src/util/regexp.c b/src/util/regexp.c index 08700882bc3..eb45822474d 100644 --- a/src/util/regexp.c +++ b/src/util/regexp.c @@ -125,7 +125,7 @@ int git_regexp_search(const git_regexp *r, const char *string, size_t nmatches, if ((data = pcre2_match_data_create(nmatches, NULL)) == NULL) { git_error_set_oom(); - goto out; + return -1; } if ((error = pcre2_match(*r, (const unsigned char *) string, strlen(string), From db013b5333e8f0808ea7cdf91ab7398b1e835181 Mon Sep 17 00:00:00 2001 From: Peter Pettersson Date: Mon, 20 Nov 2023 10:18:22 +0100 Subject: [PATCH 387/608] util: replace index (deprecated) with strchr --- src/util/unix/process.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/util/unix/process.c b/src/util/unix/process.c index 7f88ccff067..0c2029acb95 100644 --- a/src/util/unix/process.c +++ b/src/util/unix/process.c @@ -37,7 +37,7 @@ struct git_process { GIT_INLINE(bool) is_delete_env(const char *env) { - char *c = index(env, '='); + char *c = strchr(env, '='); if (c == NULL) return false; From 3889ea5eb173b2bd9366e9547da62b3b932c5683 Mon Sep 17 00:00:00 2001 From: Peter Pettersson Date: Mon, 20 Nov 2023 10:42:12 +0100 Subject: [PATCH 388/608] util: include git2/deprecated.h in errors.c In C99 functions need to be declared before they are defined. We could just add the declarations before them, but including the header allows the compiler to warn if they differ. --- src/util/errors.c | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/util/errors.c b/src/util/errors.c index 68e7a415625..feed6a835f5 100644 --- a/src/util/errors.c +++ b/src/util/errors.c @@ -376,6 +376,9 @@ void git_error_system_set(int code) /* Deprecated error values and functions */ #ifndef GIT_DEPRECATE_HARD + +#include "git2/deprecated.h" + const git_error *giterr_last(void) { return git_error_last(); From bde119e71a3364d3abd8201fc91da15baff99224 Mon Sep 17 00:00:00 2001 From: Peter Pettersson Date: Sun, 26 Nov 2023 01:02:47 +0100 Subject: [PATCH 389/608] util: sudo_uid_lookup should always return error if out isn't set --- src/util/fs_path.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/util/fs_path.c b/src/util/fs_path.c index e03fcf7c760..ab64778c23e 100644 --- a/src/util/fs_path.c +++ b/src/util/fs_path.c @@ -1938,12 +1938,13 @@ static int sudo_uid_lookup(uid_t *out) { git_str uid_str = GIT_STR_INIT; int64_t uid; - int error; + int error = -1; - if ((error = git__getenv(&uid_str, "SUDO_UID")) == 0 && - (error = git__strntol64(&uid, uid_str.ptr, uid_str.size, NULL, 10)) == 0 && - uid == (int64_t)((uid_t)uid)) { + if (git__getenv(&uid_str, "SUDO_UID") == 0 && + git__strntol64(&uid, uid_str.ptr, uid_str.size, NULL, 10) == 0 && + uid == (int64_t)((uid_t)uid)) { *out = (uid_t)uid; + error = 0; } git_str_dispose(&uid_str); From 4ed1bd1578f7b4d30138cc11dab212d0cfb3c1c0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Micha=C5=82=20K=C4=99pie=C5=84?= Date: Wed, 6 Dec 2023 11:50:29 +0100 Subject: [PATCH 390/608] fetch: enable deepening/shortening shallow clones A shallow repository can currently only be completely unshallowed, which is caused by mark_local() only marking locally-existing objects as wanted if the fetch depth is set to INT_MAX (GIT_FETCH_DEPTH_UNSHALLOW). This prevents deepening the history of a shallow clone to an arbitrary number of commits, which may be preferable over full unshallowing for large repositories. Enable deepening and shortening shallow clones by marking locally-existing objects as wanted whenever the fetch depth is set to any non-default value (either GIT_FETCH_DEPTH_UNSHALLOW or an arbitrary positive integer). --- src/libgit2/fetch.c | 8 +-- tests/libgit2/online/shallow.c | 99 ++++++++++++++++++++++++++++++++++ 2 files changed, 104 insertions(+), 3 deletions(-) diff --git a/src/libgit2/fetch.c b/src/libgit2/fetch.c index d74abb4a847..8e2660f2172 100644 --- a/src/libgit2/fetch.c +++ b/src/libgit2/fetch.c @@ -60,9 +60,11 @@ static int mark_local(git_remote *remote) git_vector_foreach(&remote->refs, i, head) { /* If we have the object, mark it so we don't ask for it. - However if we are unshallowing, we need to ask for it - even though the head exists locally. */ - if (remote->nego.depth != INT_MAX && git_odb_exists(odb, &head->oid)) + However if we are unshallowing or changing history + depth, we need to ask for it even though the head + exists locally. */ + if (remote->nego.depth == GIT_FETCH_DEPTH_FULL && + git_odb_exists(odb, &head->oid)) head->local = 1; else remote->need_pack = 1; diff --git a/tests/libgit2/online/shallow.c b/tests/libgit2/online/shallow.c index 5c0e6565b03..ee4aaf37ed4 100644 --- a/tests/libgit2/online/shallow.c +++ b/tests/libgit2/online/shallow.c @@ -164,3 +164,102 @@ void test_online_shallow__unshallow(void) git_revwalk_free(walk); git_repository_free(repo); } + +void test_online_shallow__deepen_six(void) +{ + git_str path = GIT_STR_INIT; + git_repository *repo; + git_revwalk *walk; + git_clone_options clone_opts = GIT_CLONE_OPTIONS_INIT; + git_fetch_options fetch_opts = GIT_FETCH_OPTIONS_INIT; + git_remote *origin = NULL; + git_oid oid; + git_oid *roots; + size_t roots_len; + size_t num_commits = 0; + int error = 0; + + clone_opts.fetch_opts.depth = 5; + clone_opts.remote_cb = remote_single_branch; + + git_str_joinpath(&path, clar_sandbox_path(), "deepen_6"); + cl_git_pass(git_clone(&repo, "https://github.com/libgit2/TestGitRepository", git_str_cstr(&path), &clone_opts)); + cl_assert_equal_b(true, git_repository_is_shallow(repo)); + + fetch_opts.depth = 6; + cl_git_pass(git_remote_lookup(&origin, repo, "origin")); + cl_git_pass(git_remote_fetch(origin, NULL, &fetch_opts, NULL)); + cl_assert_equal_b(true, git_repository_is_shallow(repo)); + + cl_git_pass(git_repository__shallow_roots(&roots, &roots_len, repo)); + cl_assert_equal_i(4, roots_len); + cl_assert_equal_s("58be4659bb571194ed4562d04b359d26216f526e", git_oid_tostr_s(&roots[0])); + cl_assert_equal_s("d31f5a60d406e831d056b8ac2538d515100c2df2", git_oid_tostr_s(&roots[1])); + cl_assert_equal_s("6462e7d8024396b14d7651e2ec11e2bbf07a05c4", git_oid_tostr_s(&roots[2])); + cl_assert_equal_s("2c349335b7f797072cf729c4f3bb0914ecb6dec9", git_oid_tostr_s(&roots[3])); + + git_revwalk_new(&walk, repo); + git_revwalk_push_head(walk); + + while ((error = git_revwalk_next(&oid, walk)) == GIT_OK) { + num_commits++; + } + + cl_assert_equal_i(num_commits, 17); + cl_assert_equal_i(error, GIT_ITEROVER); + + git__free(roots); + git_remote_free(origin); + git_str_dispose(&path); + git_revwalk_free(walk); + git_repository_free(repo); +} + +void test_online_shallow__shorten_four(void) +{ + git_str path = GIT_STR_INIT; + git_repository *repo; + git_revwalk *walk; + git_clone_options clone_opts = GIT_CLONE_OPTIONS_INIT; + git_fetch_options fetch_opts = GIT_FETCH_OPTIONS_INIT; + git_remote *origin = NULL; + git_oid oid; + git_oid *roots; + size_t roots_len; + size_t num_commits = 0; + int error = 0; + + clone_opts.fetch_opts.depth = 5; + clone_opts.remote_cb = remote_single_branch; + + git_str_joinpath(&path, clar_sandbox_path(), "shorten_4"); + cl_git_pass(git_clone(&repo, "https://github.com/libgit2/TestGitRepository", git_str_cstr(&path), &clone_opts)); + cl_assert_equal_b(true, git_repository_is_shallow(repo)); + + fetch_opts.depth = 4; + cl_git_pass(git_remote_lookup(&origin, repo, "origin")); + cl_git_pass(git_remote_fetch(origin, NULL, &fetch_opts, NULL)); + cl_assert_equal_b(true, git_repository_is_shallow(repo)); + + cl_git_pass(git_repository__shallow_roots(&roots, &roots_len, repo)); + cl_assert_equal_i(3, roots_len); + cl_assert_equal_s("d86a2aada2f5e7ccf6f11880bfb9ab404e8a8864", git_oid_tostr_s(&roots[0])); + cl_assert_equal_s("59706a11bde2b9899a278838ef20a97e8f8795d2", git_oid_tostr_s(&roots[1])); + cl_assert_equal_s("bab66b48f836ed950c99134ef666436fb07a09a0", git_oid_tostr_s(&roots[2])); + + git_revwalk_new(&walk, repo); + git_revwalk_push_head(walk); + + while ((error = git_revwalk_next(&oid, walk)) == GIT_OK) { + num_commits++; + } + + cl_assert_equal_i(num_commits, 10); + cl_assert_equal_i(error, GIT_ITEROVER); + + git__free(roots); + git_remote_free(origin); + git_str_dispose(&path); + git_revwalk_free(walk); + git_repository_free(repo); +} From e8ed8dae62e6073c143675e078e612dbcb0d0aa0 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 8 Dec 2023 10:52:05 +0000 Subject: [PATCH 391/608] ci: install fewer brew dependencies on macOS GitHub Actions has borked their homebrew setup by first `brew installing` things into `/usr/local` _and then_ putting their own things in their place (eg `python`). This breaks Homebrew, since it thinks it has `python` installed, but it's actually something else. Try to avoid using things that are in this bad state. https://github.com/orgs/community/discussions/78266 --- ci/setup-osx-build.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ci/setup-osx-build.sh b/ci/setup-osx-build.sh index 0b95e7629e4..426aa1c7414 100755 --- a/ci/setup-osx-build.sh +++ b/ci/setup-osx-build.sh @@ -3,6 +3,6 @@ set -ex brew update -brew install pkgconfig zlib curl openssl libssh2 ninja +brew install pkgconfig libssh2 ln -s /Applications/Xcode.app/Contents/Developer/usr/lib/libLeaksAtExit.dylib /usr/local/lib From e002004686109945cbf6089e18bc65d1a85bce12 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 8 Dec 2023 16:22:44 +0000 Subject: [PATCH 392/608] ci: use Ninja on macOS --- .github/workflows/main.yml | 2 ++ ci/setup-osx-build.sh | 2 +- 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index eba3b055a6d..5e456a81698 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -67,6 +67,7 @@ jobs: env: CC: clang CMAKE_OPTIONS: -DREGEX_BACKEND=regcomp_l -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=leaks -DUSE_GSSAPI=ON + CMAKE_GENERATOR: Ninja PKG_CONFIG_PATH: /usr/local/opt/openssl/lib/pkgconfig SKIP_SSH_TESTS: true SKIP_NEGOTIATE_TESTS: true @@ -181,6 +182,7 @@ jobs: env: CC: clang CMAKE_OPTIONS: -DREGEX_BACKEND=regcomp_l -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=leaks -DUSE_GSSAPI=ON -DEXPERIMENTAL_SHA256=ON + CMAKE_GENERATOR: Ninja PKG_CONFIG_PATH: /usr/local/opt/openssl/lib/pkgconfig SKIP_SSH_TESTS: true SKIP_NEGOTIATE_TESTS: true diff --git a/ci/setup-osx-build.sh b/ci/setup-osx-build.sh index 426aa1c7414..511d886cb17 100755 --- a/ci/setup-osx-build.sh +++ b/ci/setup-osx-build.sh @@ -3,6 +3,6 @@ set -ex brew update -brew install pkgconfig libssh2 +brew install pkgconfig libssh2 ninja ln -s /Applications/Xcode.app/Contents/Developer/usr/lib/libLeaksAtExit.dylib /usr/local/lib From a6164cb4f1720d2204f477fa781414146e4db5d6 Mon Sep 17 00:00:00 2001 From: Sven Strickroth Date: Sat, 9 Dec 2023 16:32:55 +0100 Subject: [PATCH 393/608] Avoid macro redefinition of ENABLE_INTSAFE_SIGNED_FUNCTIONS Signed-off-by: Sven Strickroth --- src/util/integer.h | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/util/integer.h b/src/util/integer.h index 63277177bf3..a9e416cc342 100644 --- a/src/util/integer.h +++ b/src/util/integer.h @@ -89,7 +89,9 @@ GIT_INLINE(int) git__is_int(int64_t p) /* Use Microsoft's safe integer handling functions where available */ #elif defined(_MSC_VER) -# define ENABLE_INTSAFE_SIGNED_FUNCTIONS +# if !defined(ENABLE_INTSAFE_SIGNED_FUNCTIONS) +# define ENABLE_INTSAFE_SIGNED_FUNCTIONS +# endif # include # define git__add_sizet_overflow(out, one, two) \ From cc965243d67c8fe524bbf47315e481b9a55328a1 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Wed, 13 Dec 2023 16:38:32 +0000 Subject: [PATCH 394/608] process: test /usr/bin/false on BSDs Our process tests were previously testing that false is `/bin/false` everywhere except macOS, where it exists as `/usr/bin/false`. . Extend this to all BSDs. --- tests/util/process/start.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/tests/util/process/start.c b/tests/util/process/start.c index d130c7efbbb..19ae5e312a4 100644 --- a/tests/util/process/start.c +++ b/tests/util/process/start.c @@ -38,9 +38,10 @@ void test_process_start__cleanup(void) void test_process_start__returncode(void) { -#ifdef GIT_WIN32 +#if defined(GIT_WIN32) const char *args_array[] = { "C:\\Windows\\System32\\cmd.exe", "/c", "exit", "1" }; -#elif __APPLE__ +#elif defined(__APPLE__) || defined(__NetBSD__) || defined(__FreeBSD__) || \ + defined(__MidnightBSD__) || defined(__DragonFly__) const char *args_array[] = { "/usr/bin/false" }; #else const char *args_array[] = { "/bin/false" }; From 779263be0d8601d866ed62619e96ddfa77c9b78f Mon Sep 17 00:00:00 2001 From: Sven Strickroth Date: Sun, 10 Dec 2023 10:17:44 +0100 Subject: [PATCH 395/608] Do not normalize safe.directory paths Vanilla Git does not do it either (cf. https://github.com/gitster/git/blob/master/setup.c#L1150) and calling git_fs_path_prettify_dir can cause performance issues (cf. issue #6649). Signed-off-by: Sven Strickroth --- src/libgit2/repository.c | 18 +++++++++++------- tests/libgit2/repo/open.c | 19 +++++++++++++++++++ 2 files changed, 30 insertions(+), 7 deletions(-) diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index 05ece6efc41..26741bbbc67 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -537,8 +537,7 @@ static int read_gitfile(git_str *path_out, const char *file_path) } typedef struct { - const char *repo_path; - git_str tmp; + git_str repo_path; bool *is_safe; } validate_ownership_data; @@ -582,9 +581,7 @@ static int validate_ownership_cb(const git_config_entry *entry, void *payload) strncmp(test_path, "//wsl.localhost/", strlen("//wsl.localhost/")) != 0) test_path++; #endif - - if (git_fs_path_prettify_dir(&data->tmp, test_path, NULL) == 0 && - strcmp(data->tmp.ptr, data->repo_path) == 0) + if (strcmp(test_path, data->repo_path.ptr) == 0) *data->is_safe = true; } @@ -597,7 +594,7 @@ static int validate_ownership_config( bool use_env) { validate_ownership_data ownership_data = { - path, GIT_STR_INIT, is_safe + GIT_STR_INIT, is_safe }; git_config *config; int error; @@ -605,6 +602,13 @@ static int validate_ownership_config( if (load_global_config(&config, use_env) != 0) return 0; + git_str_sets(&ownership_data.repo_path, path); + if (git_str_oom(&ownership_data.repo_path)) + return -1; + if (git_str_len(&ownership_data.repo_path) > 1 && + ownership_data.repo_path.ptr[git_str_len(&ownership_data.repo_path) - 1] == '/') + git_str_shorten(&ownership_data.repo_path, 1); + error = git_config_get_multivar_foreach(config, "safe.directory", NULL, validate_ownership_cb, @@ -614,7 +618,7 @@ static int validate_ownership_config( error = 0; git_config_free(config); - git_str_dispose(&ownership_data.tmp); + git_str_dispose(&ownership_data.repo_path); return error; } diff --git a/tests/libgit2/repo/open.c b/tests/libgit2/repo/open.c index 3d1a0620b12..547e300a170 100644 --- a/tests/libgit2/repo/open.c +++ b/tests/libgit2/repo/open.c @@ -555,6 +555,25 @@ void test_repo_open__can_allowlist_dirs_with_problematic_ownership(void) git_str_joinpath(&config_filename, config_path.ptr, ".gitconfig"); + // Test with incorrect exception (slash at the end) + git_str_printf(&config_data, + "[foo]\n" \ + "\tbar = Foobar\n" \ + "\tbaz = Baz!\n" \ + "[safe]\n" \ + "\tdirectory = /non/existent/path\n" \ + "\tdirectory = /\n" \ + "\tdirectory = c:\\\\temp\n" \ + "\tdirectory = %s/%s/\n" \ + "\tdirectory = /tmp\n" \ + "[bar]\n" \ + "\tfoo = barfoo\n", + clar_sandbox_path(), "empty_standard_repo"); + cl_git_rewritefile(config_filename.ptr, config_data.ptr); + cl_git_fail_with(GIT_EOWNER, git_repository_open(&repo, "empty_standard_repo")); + + // Test with correct exception + git_str_clear(&config_data); git_str_printf(&config_data, "[foo]\n" \ "\tbar = Foobar\n" \ From 73f034c7b99d3682d34408de567c9aeead185c34 Mon Sep 17 00:00:00 2001 From: Sven Strickroth Date: Sun, 10 Dec 2023 10:25:24 +0100 Subject: [PATCH 396/608] Improve error message Signed-off-by: Sven Strickroth --- src/libgit2/repository.c | 23 ++++++++++++++++++++--- 1 file changed, 20 insertions(+), 3 deletions(-) diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index 26741bbbc67..f9d639b6144 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -685,9 +685,26 @@ static int validate_ownership(git_repository *repo) goto done; if (!is_safe) { - git_error_set(GIT_ERROR_CONFIG, - "repository path '%s' is not owned by current user", - path); + git_str nice_path = GIT_STR_INIT; +#ifdef GIT_WIN32 + /* see comment above in validate_ownership_cb */ + if (!strncasecmp(path, "//", strlen("//"))) + git_str_puts(&nice_path, "%(prefix)/"); +#endif + git_str_puts(&nice_path, path); + if (!git_str_oom(&nice_path)) { + if (git_str_len(&nice_path) > 1 && nice_path.ptr[git_str_len(&nice_path) - 1] == '/') + git_str_shorten(&nice_path, 1); + git_error_set( + GIT_ERROR_CONFIG, + "repository path '%s' is not owned by current user.\n\nTo add an exception use the path '%s'.", + path, nice_path.ptr); + } else + git_error_set( + GIT_ERROR_CONFIG, + "repository path '%s' is not owned by current user.", + path); + git_str_dispose(&nice_path); error = GIT_EOWNER; } From 731af14be3a16839ead66751ea0d6c97226799d8 Mon Sep 17 00:00:00 2001 From: Kevin Saul Date: Thu, 14 Dec 2023 15:36:05 +1300 Subject: [PATCH 397/608] repo: add oid type support to git_repository_new --- include/git2/sys/repository.h | 5 ++++ src/libgit2/repository.c | 15 +++++++++++- src/libgit2/repository.h | 3 +++ tests/libgit2/network/remote/local.c | 4 +++ tests/libgit2/odb/backend/nobackend.c | 4 +++ tests/libgit2/repo/new.c | 35 +++++++++++++++++++++++++++ 6 files changed, 65 insertions(+), 1 deletion(-) diff --git a/include/git2/sys/repository.h b/include/git2/sys/repository.h index 892be669266..080a404c413 100644 --- a/include/git2/sys/repository.h +++ b/include/git2/sys/repository.h @@ -9,6 +9,7 @@ #include "git2/common.h" #include "git2/types.h" +#include "git2/oid.h" /** * @file git2/sys/repository.h @@ -32,7 +33,11 @@ GIT_BEGIN_DECL * @param out The blank repository * @return 0 on success, or an error code */ +#ifdef GIT_EXPERIMENTAL_SHA256 +GIT_EXTERN(int) git_repository_new(git_repository **out, git_oid_t oid_type); +#else GIT_EXTERN(int) git_repository_new(git_repository **out); +#endif /** * Reset all the internal state in a repository. diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index 05ece6efc41..c73ef1303da 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -328,7 +328,7 @@ static git_repository *repository_alloc(void) return NULL; } -int git_repository_new(git_repository **out) +int git_repository__new(git_repository **out, git_oid_t oid_type) { git_repository *repo; @@ -337,10 +337,23 @@ int git_repository_new(git_repository **out) repo->is_bare = 1; repo->is_worktree = 0; + repo->oid_type = oid_type; return 0; } +#ifdef GIT_EXPERIMENTAL_SHA256 +int git_repository_new(git_repository **out, git_oid_t oid_type) +{ + return git_repository__new(out, oid_type); +} +#else +int git_repository_new(git_repository** out) +{ + return git_repository__new(out, GIT_OID_SHA1); +} +#endif + static int load_config_data(git_repository *repo, const git_config *config) { int is_bare; diff --git a/src/libgit2/repository.h b/src/libgit2/repository.h index 6d2b64c0368..be4bc8860d6 100644 --- a/src/libgit2/repository.h +++ b/src/libgit2/repository.h @@ -280,4 +280,7 @@ int git_repository__set_objectformat( git_repository *repo, git_oid_t oid_type); +/* SHA256-aware internal functions */ +int git_repository__new(git_repository **out, git_oid_t oid_type); + #endif diff --git a/tests/libgit2/network/remote/local.c b/tests/libgit2/network/remote/local.c index 2007f3776a1..d70d0ebf7a6 100644 --- a/tests/libgit2/network/remote/local.c +++ b/tests/libgit2/network/remote/local.c @@ -473,7 +473,11 @@ void test_network_remote_local__anonymous_remote_inmemory_repo(void) git_str_sets(&file_path_buf, cl_git_path_url(cl_fixture("testrepo.git"))); +#ifdef GIT_EXPERIMENTAL_SHA256 + cl_git_pass(git_repository_new(&inmemory, GIT_OID_SHA1)); +#else cl_git_pass(git_repository_new(&inmemory)); +#endif cl_git_pass(git_remote_create_anonymous(&remote, inmemory, git_str_cstr(&file_path_buf))); cl_git_pass(git_remote_connect(remote, GIT_DIRECTION_FETCH, NULL, NULL, NULL)); cl_assert(git_remote_connected(remote)); diff --git a/tests/libgit2/odb/backend/nobackend.c b/tests/libgit2/odb/backend/nobackend.c index 7d9394c6f33..a81e5857715 100644 --- a/tests/libgit2/odb/backend/nobackend.c +++ b/tests/libgit2/odb/backend/nobackend.c @@ -11,7 +11,11 @@ void test_odb_backend_nobackend__initialize(void) git_odb *odb; git_refdb *refdb; +#ifdef GIT_EXPERIMENTAL_SHA256 + cl_git_pass(git_repository_new(&_repo, GIT_OID_SHA1)); +#else cl_git_pass(git_repository_new(&_repo)); +#endif cl_git_pass(git_config_new(&config)); cl_git_pass(git_odb__new(&odb, NULL)); cl_git_pass(git_refdb_new(&refdb, _repo)); diff --git a/tests/libgit2/repo/new.c b/tests/libgit2/repo/new.c index d77e903f670..aaa917a4aba 100644 --- a/tests/libgit2/repo/new.c +++ b/tests/libgit2/repo/new.c @@ -5,7 +5,11 @@ void test_repo_new__has_nothing(void) { git_repository *repo; +#ifdef GIT_EXPERIMENTAL_SHA256 + cl_git_pass(git_repository_new(&repo, GIT_OID_SHA1)); +#else cl_git_pass(git_repository_new(&repo)); +#endif cl_assert_equal_b(true, git_repository_is_bare(repo)); cl_assert_equal_p(NULL, git_repository_path(repo)); cl_assert_equal_p(NULL, git_repository_workdir(repo)); @@ -16,7 +20,11 @@ void test_repo_new__is_bare_until_workdir_set(void) { git_repository *repo; +#ifdef GIT_EXPERIMENTAL_SHA256 + cl_git_pass(git_repository_new(&repo, GIT_OID_SHA1)); +#else cl_git_pass(git_repository_new(&repo)); +#endif cl_assert_equal_b(true, git_repository_is_bare(repo)); cl_git_pass(git_repository_set_workdir(repo, clar_sandbox_path(), 0)); @@ -25,3 +33,30 @@ void test_repo_new__is_bare_until_workdir_set(void) git_repository_free(repo); } +void test_repo_new__sha1(void) +{ + git_repository *repo; + +#ifdef GIT_EXPERIMENTAL_SHA256 + cl_git_pass(git_repository_new(&repo, GIT_OID_SHA1)); +#else + cl_git_pass(git_repository_new(&repo)); +#endif + cl_assert_equal_i(GIT_OID_SHA1, git_repository_oid_type(repo)); + + git_repository_free(repo); +} + +void test_repo_new__sha256(void) +{ +#ifndef GIT_EXPERIMENTAL_SHA256 + cl_skip(); +#else + git_repository *repo; + + cl_git_pass(git_repository_new(&repo, GIT_OID_SHA256)); + cl_assert_equal_i(GIT_OID_SHA256, git_repository_oid_type(repo)); + + git_repository_free(repo); +#endif +} From f247a3f59fc1d50a1bfd8f94051cfee1571103fb Mon Sep 17 00:00:00 2001 From: Sven Strickroth Date: Thu, 14 Dec 2023 09:38:18 +0100 Subject: [PATCH 398/608] git2: Fix crash when called w/o parameters Signed-off-by: Sven Strickroth --- src/cli/main.c | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/cli/main.c b/src/cli/main.c index 6854b82289a..190b6756d95 100644 --- a/src/cli/main.c +++ b/src/cli/main.c @@ -100,6 +100,11 @@ int main(int argc, char **argv) goto done; } + if (!command) { + ret = cmd_help(argc, argv); + goto done; + } + if ((cmd = cli_cmd_spec_byname(command)) == NULL) { ret = cli_error("'%s' is not a %s command. See '%s help'.", command, PROGRAM_NAME, PROGRAM_NAME); From 8b7495fc8250e187a091bd5f00c8d5323799edb4 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 14 Dec 2023 10:51:34 +0000 Subject: [PATCH 399/608] push: set generic error in push_negotiation cb When a user returns `-1` in a `push_negotiation` callback, we set the error to whatever's hanging out in the buffer, probably something about a missing configuration entry. Clear the error buffer before invoking the callback, so that if a user does not set an error message in their callback that we can detect. If there is no error but `-1` is returned, set a generic error message. --- src/libgit2/push.c | 19 +++++++++++++++---- 1 file changed, 15 insertions(+), 4 deletions(-) diff --git a/src/libgit2/push.c b/src/libgit2/push.c index 8b47abc2463..d3ec4a1d818 100644 --- a/src/libgit2/push.c +++ b/src/libgit2/push.c @@ -444,10 +444,21 @@ static int do_push(git_push *push) if ((error = calculate_work(push)) < 0) goto on_error; - if (callbacks && callbacks->push_negotiation && - (error = callbacks->push_negotiation((const git_push_update **) push->updates.contents, - push->updates.length, callbacks->payload)) < 0) - goto on_error; + if (callbacks && callbacks->push_negotiation) { + git_error_clear(); + + error = callbacks->push_negotiation( + (const git_push_update **) push->updates.contents, + push->updates.length, callbacks->payload); + + if (error < 0) { + git_error_set_after_callback_function(error, + "push_negotiation"); + goto on_error; + } + + error = 0; + } if ((error = queue_objects(push)) < 0 || (error = transport->push(transport, push)) < 0) From 31fd5e36570bd338cea229952f043943c6b5ba72 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 14 Dec 2023 12:16:12 +0000 Subject: [PATCH 400/608] release: add a compatibility label Add a compatibility label to the release.yml to describe things that are for improved cross-platform compatibility. --- .github/release.yml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.github/release.yml b/.github/release.yml index 7a0032113db..099e3803fa6 100644 --- a/.github/release.yml +++ b/.github/release.yml @@ -21,6 +21,9 @@ changelog: - title: Documentation improvements labels: - documentation + - title: Platform compatibility fixes + labels: + - compatibility - title: Git compatibility fixes labels: - git compatibility From 4681b3aee447ba85c63043355699042253599d88 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 14 Dec 2023 13:40:20 +0000 Subject: [PATCH 401/608] ntlmclient: update to latest version Ensure that we declare variables at the top of the block for broad compatibility with old compilers. --- deps/ntlmclient/crypt_commoncrypto.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/deps/ntlmclient/crypt_commoncrypto.c b/deps/ntlmclient/crypt_commoncrypto.c index 4ff57edd29a..3c20469f58d 100644 --- a/deps/ntlmclient/crypt_commoncrypto.c +++ b/deps/ntlmclient/crypt_commoncrypto.c @@ -59,11 +59,12 @@ bool ntlm_des_encrypt( ntlm_des_block *plaintext, ntlm_des_block *key) { + CCCryptorStatus result; size_t written; NTLM_UNUSED(ntlm); - CCCryptorStatus result = CCCrypt(kCCEncrypt, + result = CCCrypt(kCCEncrypt, kCCAlgorithmDES, kCCOptionECBMode, key, sizeof(ntlm_des_block), NULL, plaintext, sizeof(ntlm_des_block), From b882e9e7a6e142ce4cf26ea15905f0ff06c11eb8 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 14 Dec 2023 13:40:57 +0000 Subject: [PATCH 402/608] stream: use an unsigned int for a bitmask --- include/git2/sys/stream.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/include/git2/sys/stream.h b/include/git2/sys/stream.h index 3d28d09b321..3277088c99c 100644 --- a/include/git2/sys/stream.h +++ b/include/git2/sys/stream.h @@ -29,8 +29,8 @@ GIT_BEGIN_DECL typedef struct git_stream { int version; - int encrypted : 1, - proxy_support : 1; + unsigned int encrypted : 1, + proxy_support : 1; /** * Timeout for read and write operations; can be set to `0` to From de9a76b92c5805033ce3b477a8a65957465c8625 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 14 Dec 2023 13:41:17 +0000 Subject: [PATCH 403/608] config: properly handle multiline quotes Pass a pointer to the quote counts so that we can increment it. --- src/libgit2/config_parse.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/libgit2/config_parse.c b/src/libgit2/config_parse.c index 06931368e7b..1431bed36db 100644 --- a/src/libgit2/config_parse.c +++ b/src/libgit2/config_parse.c @@ -279,8 +279,7 @@ static int skip_bom(git_parse_ctx *parser) */ /* '\"' -> '"' etc */ -static int unescape_line( - char **out, bool *is_multi, const char *ptr, int quote_count) +static int unescape_line(char **out, bool *is_multi, const char *ptr, int *quote_count) { char *str, *fixed, *esc; size_t ptr_len = strlen(ptr), alloc_len; @@ -296,7 +295,8 @@ static int unescape_line( while (*ptr != '\0') { if (*ptr == '"') { - quote_count++; + if (quote_count) + (*quote_count)++; } else if (*ptr != '\\') { *fixed++ = *ptr; } else { @@ -358,7 +358,7 @@ static int parse_multiline_variable(git_config_parser *reader, git_str *value, i goto next; if ((error = unescape_line(&proc_line, &multiline, - line, in_quotes)) < 0) + line, &in_quotes)) < 0) goto out; /* Add this line to the multiline var */ @@ -445,7 +445,7 @@ static int parse_variable(git_config_parser *reader, char **var_name, char **var while (git__isspace(value_start[0])) value_start++; - if ((error = unescape_line(&value, &multiline, value_start, 0)) < 0) + if ((error = unescape_line(&value, &multiline, value_start, NULL)) < 0) goto out; if (multiline) { From 9ed52434b718d3f06637e1b953dda98d93711c34 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 14 Dec 2023 13:41:49 +0000 Subject: [PATCH 404/608] refdb: use an unsigned int for a bitfield --- src/libgit2/refdb_fs.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/libgit2/refdb_fs.c b/src/libgit2/refdb_fs.c index e34a71455cb..6952548046c 100644 --- a/src/libgit2/refdb_fs.c +++ b/src/libgit2/refdb_fs.c @@ -62,8 +62,8 @@ typedef struct refdb_fs_backend { git_oid_t oid_type; - int fsync : 1, - sorted : 1; + unsigned int fsync : 1, + sorted : 1; int peeling_mode; git_iterator_flag_t iterator_flags; uint32_t direach_flags; From 18aa18bee17fcc45f87b556b5bde2aebb3a3a40a Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 14 Dec 2023 13:42:01 +0000 Subject: [PATCH 405/608] smart: use an unsigned int for a bitfield --- src/libgit2/transports/smart.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/libgit2/transports/smart.h b/src/libgit2/transports/smart.h index 52c7553a1d7..f49827eb698 100644 --- a/src/libgit2/transports/smart.h +++ b/src/libgit2/transports/smart.h @@ -203,7 +203,7 @@ int git_smart__update_heads(transport_smart *t, git_vector *symrefs); /* smart_pkt.c */ typedef struct { git_oid_t oid_type; - int seen_capabilities: 1; + unsigned int seen_capabilities: 1; } git_pkt_parse_data; int git_pkt_parse_line(git_pkt **head, const char **endptr, const char *line, size_t linelen, git_pkt_parse_data *data); From 60c68e7e03aa7c5b827ceb8cd9e0d506a87e743f Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 14 Dec 2023 14:06:51 +0000 Subject: [PATCH 406/608] cli: use the latest version of adopt --- src/cli/opt.c | 2 +- src/cli/opt.h | 16 +++++++++++++--- 2 files changed, 14 insertions(+), 4 deletions(-) diff --git a/src/cli/opt.c b/src/cli/opt.c index 25c97746f1d..2b08dc219a3 100644 --- a/src/cli/opt.c +++ b/src/cli/opt.c @@ -10,7 +10,7 @@ * This file was produced by using the `rename.pl` script included with * adopt. The command-line specified was: * - * ./rename.pl cli_opt --filename=opt --include=cli.h --inline=GIT_INLINE --header-guard=CLI_opt_h__ --lowercase-status --without-usage + * ./rename.pl cli_opt --filename=opt --include=common.h --inline=GIT_INLINE --header-guard=CLI_opt_h__ --lowercase-status --without-usage */ #include diff --git a/src/cli/opt.h b/src/cli/opt.h index 7133307b4f7..226f74db8bc 100644 --- a/src/cli/opt.h +++ b/src/cli/opt.h @@ -10,7 +10,7 @@ * This file was produced by using the `rename.pl` script included with * adopt. The command-line specified was: * - * ./rename.pl cli_opt --filename=opt --include=cli.h --inline=GIT_INLINE --header-guard=CLI_opt_h__ --lowercase-status --without-usage + * ./rename.pl cli_opt --filename=opt --include=common.h --inline=GIT_INLINE --header-guard=CLI_opt_h__ --lowercase-status --without-usage */ #ifndef CLI_opt_h__ @@ -275,8 +275,8 @@ typedef struct cli_opt_parser { size_t arg_idx; size_t in_args; size_t in_short; - int needs_sort : 1, - in_literal : 1; + unsigned int needs_sort : 1, + in_literal : 1; } cli_opt_parser; /** @@ -300,6 +300,16 @@ cli_opt_status_t cli_opt_parse( size_t args_len, unsigned int flags); +/** + * Quickly executes the given callback for each argument. + * + * @param specs A NULL-terminated array of `cli_opt_spec`s that can be parsed + * @param args The arguments that will be parsed + * @param args_len The length of arguments to be parsed + * @param flags The `cli_opt_flag_t flags for parsing + * @param callback The callback to invoke for each specified option + * @param callback_data Data to be provided to the callback + */ int cli_opt_foreach( const cli_opt_spec specs[], char **args, From 2098c490c8b8bfb88adab30575ff82fa157e52a3 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 14 Dec 2023 14:07:03 +0000 Subject: [PATCH 407/608] net: use an unsigned int for a bitfield --- src/util/net.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/util/net.c b/src/util/net.c index 24782d2af09..4474564511b 100644 --- a/src/util/net.c +++ b/src/util/net.c @@ -22,7 +22,7 @@ #define GIT_NET_URL_PARSER_INIT { 0 } typedef struct { - int hierarchical : 1; + unsigned int hierarchical : 1; const char *scheme; const char *user; From 6fb234b5fbd1e999685bf545013d64c42550d110 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 14 Dec 2023 14:17:24 +0000 Subject: [PATCH 408/608] process: use unsigned int for bitfields --- src/util/process.h | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/util/process.h b/src/util/process.h index 9310652c325..3ada6696d22 100644 --- a/src/util/process.h +++ b/src/util/process.h @@ -11,10 +11,10 @@ typedef struct git_process git_process; typedef struct { - int capture_in : 1, - capture_out : 1, - capture_err : 1, - exclude_env : 1; + unsigned int capture_in : 1, + capture_out : 1, + capture_err : 1, + exclude_env : 1; char *cwd; } git_process_options; From 839b249525b46f2894b8cd574d02b06ef9933f8e Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 14 Dec 2023 14:26:09 +0000 Subject: [PATCH 409/608] tests: update to latest clar --- tests/clar/clar.c | 2 ++ tests/clar/clar/fixtures.h | 2 +- tests/clar/clar/fs.h | 2 ++ 3 files changed, 5 insertions(+), 1 deletion(-) diff --git a/tests/clar/clar.c b/tests/clar/clar.c index c9c3fde3827..3fc2c768158 100644 --- a/tests/clar/clar.c +++ b/tests/clar/clar.c @@ -94,8 +94,10 @@ static void fs_rm(const char *_source); static void fs_copy(const char *_source, const char *dest); +#ifdef CLAR_FIXTURE_PATH static const char * fixture_path(const char *base, const char *fixture_name); +#endif struct clar_error { const char *file; diff --git a/tests/clar/clar/fixtures.h b/tests/clar/clar/fixtures.h index 77033d36507..6ec6423484d 100644 --- a/tests/clar/clar/fixtures.h +++ b/tests/clar/clar/fixtures.h @@ -1,3 +1,4 @@ +#ifdef CLAR_FIXTURE_PATH static const char * fixture_path(const char *base, const char *fixture_name) { @@ -20,7 +21,6 @@ fixture_path(const char *base, const char *fixture_name) return _path; } -#ifdef CLAR_FIXTURE_PATH const char *cl_fixture(const char *fixture_name) { return fixture_path(CLAR_FIXTURE_PATH, fixture_name); diff --git a/tests/clar/clar/fs.h b/tests/clar/clar/fs.h index 44ede457258..a6eda5e5dc2 100644 --- a/tests/clar/clar/fs.h +++ b/tests/clar/clar/fs.h @@ -295,7 +295,9 @@ fs_copy(const char *_source, const char *_dest) void cl_fs_cleanup(void) { +#ifdef CLAR_FIXTURE_PATH fs_rm(fixture_path(_clar_path, "*")); +#endif } #else From d728cb610bfa36c81a38a50fd32ae66d29b6c271 Mon Sep 17 00:00:00 2001 From: Peter Pettersson Date: Sat, 1 Jan 2022 14:50:15 +0100 Subject: [PATCH 410/608] ci: add url-like path to online clone tests --- tests/libgit2/online/clone.c | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/tests/libgit2/online/clone.c b/tests/libgit2/online/clone.c index 7a8f5ead780..207dd839172 100644 --- a/tests/libgit2/online/clone.c +++ b/tests/libgit2/online/clone.c @@ -7,6 +7,7 @@ #include "refs.h" #define LIVE_REPO_URL "http://github.com/libgit2/TestGitRepository" +#define LIVE_REPO_AS_DIR "http:/github.com/libgit2/TestGitRepository" #define LIVE_EMPTYREPO_URL "http://github.com/libgit2/TestEmptyRepository" #define BB_REPO_URL "https://libgit2-test@bitbucket.org/libgit2-test/testgitrepository.git" #define BB_REPO_URL_WITH_PASS "https://libgit2-test:YT77Ppm2nq8w4TYjGS8U@bitbucket.org/libgit2-test/testgitrepository.git" @@ -115,6 +116,16 @@ void test_online_clone__initialize(void) if (_remote_expectcontinue) git_libgit2_opts(GIT_OPT_ENABLE_HTTP_EXPECT_CONTINUE, 1); + +#if !defined(GIT_WIN32) + /* + * On system that allows ':' in filenames "http://path" can be misinterpreted + * as the local path "http:/path". + * Create a local non-repository path that looks like LIVE_REPO_URL to make + * sure we can handle cloning despite this directory being around. + */ + git_futils_mkdir_r(LIVE_REPO_AS_DIR, 0777); +#endif } void test_online_clone__cleanup(void) @@ -127,6 +138,10 @@ void test_online_clone__cleanup(void) cl_fixture_cleanup("./initial"); cl_fixture_cleanup("./subsequent"); +#if !defined(GIT_WIN32) + cl_fixture_cleanup("http:"); +#endif + git__free(_remote_url); git__free(_remote_user); git__free(_remote_pass); From 26b08d4c6d524d21ba95b0d08650c7b4c2aeb576 Mon Sep 17 00:00:00 2001 From: Peter Pettersson Date: Thu, 12 Aug 2021 13:46:03 +0200 Subject: [PATCH 411/608] clone: don't test remote url against filesystem --- src/libgit2/clone.c | 33 +++++++++++++++++---------------- 1 file changed, 17 insertions(+), 16 deletions(-) diff --git a/src/libgit2/clone.c b/src/libgit2/clone.c index 27bae1ac499..3df28f80aed 100644 --- a/src/libgit2/clone.c +++ b/src/libgit2/clone.c @@ -22,6 +22,7 @@ #include "fs_path.h" #include "repository.h" #include "odb.h" +#include "net.h" static int clone_local_into(git_repository *repo, git_remote *remote, const git_fetch_options *fetch_opts, const git_checkout_options *co_opts, const char *branch, int link); @@ -336,8 +337,9 @@ static int create_and_configure_origin( git_remote_create_cb remote_create = options->remote_cb; void *payload = options->remote_cb_payload; - /* If the path exists and is a dir, the url should be the absolute path */ - if (git_fs_path_root(url) < 0 && git_fs_path_exists(url) && git_fs_path_isdir(url)) { + /* If the path is local and exists it should be the absolute path. */ + if (!git_net_str_is_url(url) && git_fs_path_root(url) < 0 && + git_fs_path_exists(url)) { if (p_realpath(url, buf) == NULL) return -1; @@ -458,26 +460,25 @@ static int clone_into( int git_clone__should_clone_local(const char *url_or_path, git_clone_local_t local) { git_str fromurl = GIT_STR_INIT; - const char *path = url_or_path; - bool is_url, is_local; + bool is_local; if (local == GIT_CLONE_NO_LOCAL) return 0; - if ((is_url = git_fs_path_is_local_file_url(url_or_path)) != 0) { - if (git_fs_path_fromurl(&fromurl, url_or_path) < 0) { - is_local = -1; - goto done; - } + if (git_net_str_is_url(url_or_path)) { + /* If GIT_CLONE_LOCAL_AUTO is specified, any url should be treated as remote */ + if (local == GIT_CLONE_LOCAL_AUTO || + !git_fs_path_is_local_file_url(url_or_path)) + return 0; - path = fromurl.ptr; + if (git_fs_path_fromurl(&fromurl, url_or_path) == 0) + is_local = git_fs_path_isdir(git_str_cstr(&fromurl)); + else + is_local = -1; + git_str_dispose(&fromurl); + } else { + is_local = git_fs_path_isdir(url_or_path); } - - is_local = (!is_url || local != GIT_CLONE_LOCAL_AUTO) && - git_fs_path_isdir(path); - -done: - git_str_dispose(&fromurl); return is_local; } From 85c4edfae35f52e116c19d54a69c5bf683ae3e14 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 14 Dec 2023 20:50:51 +0000 Subject: [PATCH 412/608] signature: test new leading/trailing dot parsing We now allow leading and trailing dots in username and email addresses. Test that we do so. --- tests/libgit2/commit/signature.c | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/tests/libgit2/commit/signature.c b/tests/libgit2/commit/signature.c index 32058f6c344..fddd5076eb7 100644 --- a/tests/libgit2/commit/signature.c +++ b/tests/libgit2/commit/signature.c @@ -36,6 +36,13 @@ void test_commit_signature__leading_and_trailing_spaces_are_trimmed(void) assert_name_and_email("nulltoken", "emeric.fermas@gmail.com", " \t nulltoken \n", " \n emeric.fermas@gmail.com \n"); } +void test_commit_signature__leading_and_trailing_dots_are_supported(void) +{ + assert_name_and_email(".nulltoken", ".emeric.fermas@gmail.com", ".nulltoken", ".emeric.fermas@gmail.com"); + assert_name_and_email("nulltoken.", "emeric.fermas@gmail.com.", "nulltoken.", "emeric.fermas@gmail.com."); + assert_name_and_email(".nulltoken.", ".emeric.fermas@gmail.com.", ".nulltoken.", ".emeric.fermas@gmail.com."); +} + void test_commit_signature__leading_and_trailing_crud_is_trimmed(void) { assert_name_and_email("nulltoken", "emeric.fermas@gmail.com", "\"nulltoken\"", "\"emeric.fermas@gmail.com\""); From cba3469cdba08cef67d71ab53a8cc2abb3132598 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 24 Jun 2023 20:47:09 +0100 Subject: [PATCH 413/608] cli: add `index-pack` command --- src/cli/cmd.h | 1 + src/cli/cmd_index_pack.c | 114 +++++++++++++++++++++++++++++++++++++++ src/cli/main.c | 1 + src/cli/progress.c | 53 +++++++++++++++++- src/cli/progress.h | 12 +++++ 5 files changed, 179 insertions(+), 2 deletions(-) create mode 100644 src/cli/cmd_index_pack.c diff --git a/src/cli/cmd.h b/src/cli/cmd.h index 12977cbc7bb..bd881223db9 100644 --- a/src/cli/cmd.h +++ b/src/cli/cmd.h @@ -30,5 +30,6 @@ extern int cmd_clone(int argc, char **argv); extern int cmd_config(int argc, char **argv); extern int cmd_hash_object(int argc, char **argv); extern int cmd_help(int argc, char **argv); +extern int cmd_index_pack(int argc, char **argv); #endif /* CLI_cmd_h__ */ diff --git a/src/cli/cmd_index_pack.c b/src/cli/cmd_index_pack.c new file mode 100644 index 00000000000..17698033ae7 --- /dev/null +++ b/src/cli/cmd_index_pack.c @@ -0,0 +1,114 @@ +/* + * Copyright (C) the libgit2 contributors. All rights reserved. + * + * This file is part of libgit2, distributed under the GNU GPL v2 with + * a Linking Exception. For full terms see the included COPYING file. + */ + +#include +#include "common.h" +#include "cmd.h" +#include "progress.h" + +#define COMMAND_NAME "index-pack" + +#define BUFFER_SIZE (1024 * 1024) + +static int show_help, verbose, read_stdin; +static char *filename; +static cli_progress progress = CLI_PROGRESS_INIT; + +static const cli_opt_spec opts[] = { + { CLI_OPT_TYPE_SWITCH, "help", 0, &show_help, 1, + CLI_OPT_USAGE_HIDDEN | CLI_OPT_USAGE_STOP_PARSING, NULL, + "display help about the " COMMAND_NAME " command" }, + + { CLI_OPT_TYPE_SWITCH, "verbose", 'v', &verbose, 1, + CLI_OPT_USAGE_DEFAULT, NULL, "display progress output" }, + + { CLI_OPT_TYPE_LITERAL }, + + { CLI_OPT_TYPE_SWITCH, "stdin", 0, &read_stdin, 1, + CLI_OPT_USAGE_REQUIRED, NULL, "read from stdin" }, + { CLI_OPT_TYPE_ARG, "pack-file", 0, &filename, 0, + CLI_OPT_USAGE_CHOICE, "pack-file", "packfile path" }, + + { 0 }, +}; + +static void print_help(void) +{ + cli_opt_usage_fprint(stdout, PROGRAM_NAME, COMMAND_NAME, opts); + printf("\n"); + + printf("Indexes a packfile and writes the index to disk.\n"); + printf("\n"); + + printf("Options:\n"); + + cli_opt_help_fprint(stdout, opts); +} + +int cmd_index_pack(int argc, char **argv) +{ + cli_opt invalid_opt; + git_indexer *idx = NULL; + git_indexer_options idx_opts = GIT_INDEXER_OPTIONS_INIT; + git_indexer_progress stats = {0}; + char buf[BUFFER_SIZE]; + ssize_t read_len; + int fd, ret; + + if (cli_opt_parse(&invalid_opt, opts, argv + 1, argc - 1, CLI_OPT_PARSE_GNU)) + return cli_opt_usage_error(COMMAND_NAME, opts, &invalid_opt); + + if (show_help) { + print_help(); + return 0; + } + + if (verbose) { + idx_opts.progress_cb = cli_progress_indexer; + idx_opts.progress_cb_payload = &progress; + } + + if (read_stdin) { + fd = fileno(stdin); + } else if ((fd = p_open(filename, O_RDONLY)) < 0) { + ret = cli_error_git(); + goto done; + } + +#ifdef GIT_EXPERIMENTAL_SHA256 + ret = git_indexer_new(&idx, ".", GIT_OID_SHA1, &idx_opts); +#else + ret = git_indexer_new(&idx, ".", 0, NULL, &idx_opts); +#endif + + if (ret < 0) { + ret = cli_error_git(); + goto done; + } + + while ((read_len = p_read(fd, buf, sizeof(buf))) > 0) { + if (git_indexer_append(idx, buf, (size_t)read_len, &stats) < 0) { + ret = cli_error_git(); + goto done; + } + } + + if (!read_stdin) + p_close(fd); + + if (git_indexer_commit(idx, &stats) < 0) { + ret = cli_error_git(); + goto done; + } + + cli_progress_finish(&progress); + +done: + cli_progress_dispose(&progress); + git_indexer_free(idx); + return ret; +} diff --git a/src/cli/main.c b/src/cli/main.c index 190b6756d95..c7a6fcfce26 100644 --- a/src/cli/main.c +++ b/src/cli/main.c @@ -37,6 +37,7 @@ const cli_cmd_spec cli_cmds[] = { { "config", cmd_config, "View or set configuration values " }, { "hash-object", cmd_hash_object, "Hash a raw object and product its object ID" }, { "help", cmd_help, "Display help information" }, + { "index-pack", cmd_index_pack, "Create an index for a packfile" }, { NULL } }; diff --git a/src/cli/progress.c b/src/cli/progress.c index ddfbafb73a4..d975b0954ac 100644 --- a/src/cli/progress.c +++ b/src/cli/progress.c @@ -242,7 +242,21 @@ static int fetch_receiving( done ? ", done." : ""); } -static int fetch_resolving( +static int indexer_indexing( + cli_progress *progress, + const git_indexer_progress *stats) +{ + bool done = (stats->received_objects == stats->total_objects); + + return progress_printf(progress, false, + "Indexing objects: %3d%% (%d/%d)%s\r", + percent(stats->received_objects, stats->total_objects), + stats->received_objects, + stats->total_objects, + done ? ", done." : ""); +} + +static int indexer_resolving( cli_progress *progress, const git_indexer_progress *stats) { @@ -283,7 +297,42 @@ int cli_progress_fetch_transfer(const git_indexer_progress *stats, void *payload /* fall through */ case CLI_PROGRESS_RESOLVING: - error = fetch_resolving(progress, stats); + error = indexer_resolving(progress, stats); + break; + + default: + /* should not be reached */ + GIT_ASSERT(!"unexpected progress state"); + } + + return error; +} + +int cli_progress_indexer( + const git_indexer_progress *stats, + void *payload) +{ + cli_progress *progress = (cli_progress *)payload; + int error = 0; + + switch (progress->action) { + case CLI_PROGRESS_NONE: + progress->action = CLI_PROGRESS_INDEXING; + /* fall through */ + + case CLI_PROGRESS_INDEXING: + if ((error = indexer_indexing(progress, stats)) < 0) + break; + + if (stats->indexed_deltas == stats->total_deltas) + break; + + progress_complete(progress); + progress->action = CLI_PROGRESS_RESOLVING; + /* fall through */ + + case CLI_PROGRESS_RESOLVING: + error = indexer_resolving(progress, stats); break; default: diff --git a/src/cli/progress.h b/src/cli/progress.h index 886fef89d03..f08d68f19e4 100644 --- a/src/cli/progress.h +++ b/src/cli/progress.h @@ -22,6 +22,7 @@ typedef enum { CLI_PROGRESS_NONE, CLI_PROGRESS_RECEIVING, + CLI_PROGRESS_INDEXING, CLI_PROGRESS_RESOLVING, CLI_PROGRESS_CHECKING_OUT } cli_progress_t; @@ -74,6 +75,17 @@ extern int cli_progress_fetch_transfer( const git_indexer_progress *stats, void *payload); +/** + * Prints indexer progress to the console. Suitable for a + * `progress_cb` callback for `git_indexer_options`. + * + * @param stats The indexer stats + * @param payload A pointer to the cli_progress + */ +extern int cli_progress_indexer( + const git_indexer_progress *stats, + void *payload); + /** * Prints checkout progress to the console. Suitable for a * `progress_cb` callback for `git_checkout_options`. From 9d767b9d5ea05821c0213ec49a593f31241f5ef3 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 14 Dec 2023 22:26:05 +0000 Subject: [PATCH 414/608] cmake: rename FindIconv to avoid collision with cmake cmake now includes `FindIconv`. Rename ours to avoid any confusion. --- cmake/{FindIconv.cmake => FindIntlIconv.cmake} | 0 src/CMakeLists.txt | 2 +- 2 files changed, 1 insertion(+), 1 deletion(-) rename cmake/{FindIconv.cmake => FindIntlIconv.cmake} (100%) diff --git a/cmake/FindIconv.cmake b/cmake/FindIntlIconv.cmake similarity index 100% rename from cmake/FindIconv.cmake rename to cmake/FindIntlIconv.cmake diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index b412452c916..ed3f4a51427 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -184,7 +184,7 @@ add_feature_info(ntlmclient GIT_NTLM "NTLM authentication support for Unix") # iconv if(USE_ICONV) - find_package(Iconv) + find_package(IntlIconv) endif() if(ICONV_FOUND) set(GIT_USE_ICONV 1) From f5793057fa759b513f2cd48784be67511dfe7178 Mon Sep 17 00:00:00 2001 From: Kevin Saul Date: Fri, 15 Dec 2023 11:41:46 +1300 Subject: [PATCH 415/608] attr: ignore missing index --- src/libgit2/attr.c | 6 +++++- tests/libgit2/attr/repo.c | 25 +++++++++++++++++++++++++ 2 files changed, 30 insertions(+), 1 deletion(-) diff --git a/src/libgit2/attr.c b/src/libgit2/attr.c index 1623b1d4570..1db90b59c7e 100644 --- a/src/libgit2/attr.c +++ b/src/libgit2/attr.c @@ -424,9 +424,13 @@ static int attr_setup( goto out; if ((error = git_repository_index__weakptr(&idx, repo)) < 0 || - (error = preload_attr_source(repo, attr_session, &index_source)) < 0) + (error = preload_attr_source(repo, attr_session, &index_source)) < 0) { + if (error != GIT_ENOTFOUND) goto out; + error = 0; + } + if ((opts && (opts->flags & GIT_ATTR_CHECK_INCLUDE_HEAD) != 0) && (error = preload_attr_source(repo, attr_session, &head_source)) < 0) goto out; diff --git a/tests/libgit2/attr/repo.c b/tests/libgit2/attr/repo.c index abd2381541d..747715b51fa 100644 --- a/tests/libgit2/attr/repo.c +++ b/tests/libgit2/attr/repo.c @@ -309,6 +309,31 @@ void test_attr_repo__bare_repo_with_index(void) cl_assert(GIT_ATTR_IS_UNSPECIFIED(values[3])); } +void test_attr_repo__inmemory_repo_without_index(void) +{ + const char *names[1] = { "fake" }; + const char *values[1]; + git_repository *inmemory; + git_index *index = NULL; + + /* setup bare in-memory repo without index */ +#ifdef GIT_EXPERIMENTAL_SHA256 + cl_git_pass(git_repository_new(&inmemory, GIT_OID_SHA1)); +#else + cl_git_pass(git_repository_new(&inmemory)); +#endif + cl_assert(git_repository_is_bare(inmemory)); + + /* verify repo isn't given an index upfront in future */ + git_repository_index(&index, inmemory); + cl_assert(!index); + + /* check attributes can be queried without error due to missing index */ + cl_git_pass(git_attr_get_many(values, inmemory, 0, "fake.txt", 1, names)); + + git_repository_free(inmemory); +} + void test_attr_repo__sysdir(void) { git_str sysdir = GIT_STR_INIT; From 6855502c94c567dbac1f6b952c555625acdb73ec Mon Sep 17 00:00:00 2001 From: Kevin Saul Date: Fri, 15 Dec 2023 17:46:13 +1300 Subject: [PATCH 416/608] repo: use empty grafts when directory not found for in-memory repo --- src/libgit2/repository.c | 26 ++++++++++++++++++++++++-- 1 file changed, 24 insertions(+), 2 deletions(-) diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index c73ef1303da..0b76e0464a6 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -865,8 +865,30 @@ static int load_grafts(git_repository *repo) git_str path = GIT_STR_INIT; int error; - if ((error = git_repository__item_path(&path, repo, GIT_REPOSITORY_ITEM_INFO)) < 0 || - (error = git_str_joinpath(&path, path.ptr, "grafts")) < 0 || + /* refresh if they've both been opened previously */ + if (repo->grafts && repo->shallow_grafts) { + if ((error = git_grafts_refresh(repo->grafts)) < 0 || + (error = git_grafts_refresh(repo->shallow_grafts)) < 0) + return error; + } + + /* resolve info path, which may not be found for inmemory repository */ + if ((error = git_repository__item_path(&path, repo, GIT_REPOSITORY_ITEM_INFO)) < 0) { + if (error != GIT_ENOTFOUND) + return error; + + /* create empty/inmemory grafts for inmemory repository */ + if (!repo->grafts && (error = git_grafts_new(&repo->grafts, repo->oid_type)) < 0) + return error; + + if (!repo->shallow_grafts && (error = git_grafts_new(&repo->shallow_grafts, repo->oid_type)) < 0) + return error; + + return 0; + } + + /* load grafts from disk */ + if ((error = git_str_joinpath(&path, path.ptr, "grafts")) < 0 || (error = git_grafts_open_or_refresh(&repo->grafts, path.ptr, repo->oid_type)) < 0) goto error; From 8f3e2d26d3754921460ce583b6becb4dd1f3d92a Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 16 Dec 2023 13:57:43 +0000 Subject: [PATCH 417/608] ci: allow workflows to read and write packages Our CI workflows consume and will automatically generate their build containers. Ensure that they can do so. --- .github/workflows/benchmark.yml | 7 ++++--- .github/workflows/main.yml | 1 + .github/workflows/nightly.yml | 1 + 3 files changed, 6 insertions(+), 3 deletions(-) diff --git a/.github/workflows/benchmark.yml b/.github/workflows/benchmark.yml index cc231b462ec..7705d89e97a 100644 --- a/.github/workflows/benchmark.yml +++ b/.github/workflows/benchmark.yml @@ -10,9 +10,10 @@ permissions: contents: read jobs: - # Run our nightly builds. We build a matrix with the various build - # targets and their details. Then we build either in a docker container - # (Linux) or on the actual hosts (macOS, Windows). + # Run our benchmarks. We build a matrix with the various build + # targets and their details. Unlike our CI builds, we run these + # directly on the VM instead of in containers since we do not + # need the breadth of platform diversity. build: # Only run scheduled workflows on the main repository; prevents people # from using build minutes on their forks. diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 3de084b8d41..f341a9cd274 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -15,6 +15,7 @@ env: permissions: contents: read + packages: write jobs: containers: diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml index ae55b36c071..b48cbf51260 100644 --- a/.github/workflows/nightly.yml +++ b/.github/workflows/nightly.yml @@ -12,6 +12,7 @@ env: permissions: contents: read + packages: write jobs: # Run our nightly builds. We build a matrix with the various build From 0b10c3fb433c3ade7bfd3c89b17f1cf959a16c0b Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 16 Dec 2023 14:39:29 +0000 Subject: [PATCH 418/608] ci: allow workflows to push changes Our workflows push documentation changes; ensure that they are allowed to do so. --- .github/workflows/main.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index f341a9cd274..bafffdc1fc8 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -14,7 +14,7 @@ env: docker-config-path: source/ci/docker permissions: - contents: read + contents: write packages: write jobs: From e619b884d5f121d7e584f77e2187b720d4d23f01 Mon Sep 17 00:00:00 2001 From: Peter Pettersson Date: Thu, 14 Dec 2023 19:22:05 +0100 Subject: [PATCH 419/608] ctype: cast characters to unsigned when classifying characters ctype classification takes an integer in as returned from getc() if we just sign extend characters to integers 128-255 will be misclassified. (255 will become EOF) Newlib in particular doesn't like this since they uses the value as an index in a lookup table. --- src/libgit2/config.c | 2 +- src/libgit2/config_parse.c | 9 +++++---- src/libgit2/path.c | 2 +- src/libgit2/trailer.c | 10 +++++----- src/libgit2/transports/smart_pkt.c | 4 ++-- src/util/date.c | 18 +++++++++--------- src/util/str.c | 4 ++-- src/util/util.h | 2 +- tests/libgit2/repo/open.c | 2 +- 9 files changed, 27 insertions(+), 26 deletions(-) diff --git a/src/libgit2/config.c b/src/libgit2/config.c index 23a8f9ffad1..5c1c00f6cb7 100644 --- a/src/libgit2/config.c +++ b/src/libgit2/config.c @@ -1447,7 +1447,7 @@ static int normalize_section(char *start, char *end) for (scan = start; *scan; ++scan) { if (end && scan >= end) break; - if (isalnum(*scan)) + if (isalnum((unsigned char)*scan)) *scan = (char)git__tolower(*scan); else if (*scan != '-' || scan == start) return GIT_EINVALIDSPEC; diff --git a/src/libgit2/config_parse.c b/src/libgit2/config_parse.c index 1431bed36db..9ab78cc7f60 100644 --- a/src/libgit2/config_parse.c +++ b/src/libgit2/config_parse.c @@ -25,9 +25,9 @@ static void set_parse_error(git_config_parser *reader, int col, const char *erro } -GIT_INLINE(int) config_keychar(int c) +GIT_INLINE(int) config_keychar(char c) { - return isalnum(c) || c == '-'; + return isalnum((unsigned char)c) || c == '-'; } static int strip_comments(char *line, int in_quotes) @@ -158,9 +158,10 @@ static int parse_subsection_header(git_config_parser *reader, const char *line, static int parse_section_header(git_config_parser *reader, char **section_out) { char *name, *name_end; - int name_length, c, pos; + int name_length, pos; int result; char *line; + char c; size_t line_len; git_parse_advance_ws(&reader->ctx); @@ -382,7 +383,7 @@ static int parse_multiline_variable(git_config_parser *reader, git_str *value, i GIT_INLINE(bool) is_namechar(char c) { - return isalnum(c) || c == '-'; + return isalnum((unsigned char)c) || c == '-'; } static int parse_name( diff --git a/src/libgit2/path.c b/src/libgit2/path.c index a19340efe6f..50181fdbff0 100644 --- a/src/libgit2/path.c +++ b/src/libgit2/path.c @@ -202,7 +202,7 @@ GIT_INLINE(size_t) common_prefix_icase(const char *str, size_t len, const char * { size_t count = 0; - while (len > 0 && tolower(*str) == tolower(*prefix)) { + while (len > 0 && tolower((unsigned char)*str) == tolower((unsigned char)*prefix)) { count++; str++; prefix++; diff --git a/src/libgit2/trailer.c b/src/libgit2/trailer.c index 4761c9922f2..9fb16418413 100644 --- a/src/libgit2/trailer.c +++ b/src/libgit2/trailer.c @@ -24,7 +24,7 @@ static const char *const git_generated_prefixes[] = { static int is_blank_line(const char *str) { const char *s = str; - while (*s && *s != '\n' && isspace(*s)) + while (*s && *s != '\n' && isspace((unsigned char)*s)) s++; return !*s || *s == '\n'; } @@ -93,7 +93,7 @@ static bool find_separator(size_t *out, const char *line, const char *separators return true; } - if (!whitespace_found && (isalnum(*c) || *c == '-')) + if (!whitespace_found && (isalnum((unsigned char)*c) || *c == '-')) continue; if (c != line && (*c == ' ' || *c == '\t')) { whitespace_found = 1; @@ -233,12 +233,12 @@ static size_t find_trailer_start(const char *buf, size_t len) } find_separator(&separator_pos, bol, TRAILER_SEPARATORS); - if (separator_pos >= 1 && !isspace(bol[0])) { + if (separator_pos >= 1 && !isspace((unsigned char)bol[0])) { trailer_lines++; possible_continuation_lines = 0; if (recognized_prefix) continue; - } else if (isspace(bol[0])) + } else if (isspace((unsigned char)bol[0])) possible_continuation_lines++; else { non_trailer_lines++; @@ -323,7 +323,7 @@ int git_message_trailers(git_message_trailer_array *trailer_arr, const char *mes goto ret; } - if (isalnum(*ptr) || *ptr == '-') { + if (isalnum((unsigned char)*ptr) || *ptr == '-') { /* legal key character */ NEXT(S_KEY); } diff --git a/src/libgit2/transports/smart_pkt.c b/src/libgit2/transports/smart_pkt.c index 7805f332377..08cb7fbe5c2 100644 --- a/src/libgit2/transports/smart_pkt.c +++ b/src/libgit2/transports/smart_pkt.c @@ -535,10 +535,10 @@ static int parse_len(size_t *out, const char *line, size_t linelen) num[PKT_LEN_SIZE] = '\0'; for (i = 0; i < PKT_LEN_SIZE; ++i) { - if (!isxdigit(num[i])) { + if (!isxdigit((unsigned char)num[i])) { /* Make sure there are no special characters before passing to error message */ for (k = 0; k < PKT_LEN_SIZE; ++k) { - if(!isprint(num[k])) { + if(!isprint((unsigned char)num[k])) { num[k] = '.'; } } diff --git a/src/util/date.c b/src/util/date.c index 4d757e21a00..d54056842dd 100644 --- a/src/util/date.c +++ b/src/util/date.c @@ -129,9 +129,9 @@ static size_t match_string(const char *date, const char *str) for (i = 0; *date; date++, str++, i++) { if (*date == *str) continue; - if (toupper(*date) == toupper(*str)) + if (toupper((unsigned char)*date) == toupper((unsigned char)*str)) continue; - if (!isalnum(*date)) + if (!isalnum((unsigned char)*date)) break; return 0; } @@ -143,7 +143,7 @@ static int skip_alpha(const char *date) int i = 0; do { i++; - } while (isalpha(date[i])); + } while (isalpha((unsigned char)date[i])); return i; } @@ -251,7 +251,7 @@ static size_t match_multi_number(unsigned long num, char c, const char *date, ch num2 = strtol(end+1, &end, 10); num3 = -1; - if (*end == c && isdigit(end[1])) + if (*end == c && isdigit((unsigned char)end[1])) num3 = strtol(end+1, &end, 10); /* Time? Date? */ @@ -349,7 +349,7 @@ static size_t match_digit(const char *date, struct tm *tm, int *offset, int *tm_ case '.': case '/': case '-': - if (isdigit(end[1])) { + if (isdigit((unsigned char)end[1])) { size_t match = match_multi_number(num, *end, date, end, tm); if (match) return match; @@ -364,7 +364,7 @@ static size_t match_digit(const char *date, struct tm *tm, int *offset, int *tm_ n = 0; do { n++; - } while (isdigit(date[n])); + } while (isdigit((unsigned char)date[n])); /* Four-digit year or a timezone? */ if (n == 4) { @@ -518,7 +518,7 @@ static int parse_date_basic(const char *date, git_time_t *timestamp, int *offset match = match_alpha(date, &tm, offset); else if (isdigit(c)) match = match_digit(date, &tm, offset, &tm_gmt); - else if ((c == '-' || c == '+') && isdigit(date[1])) + else if ((c == '-' || c == '+') && isdigit((unsigned char)date[1])) match = match_tz(date, offset); if (!match) { @@ -682,7 +682,7 @@ static const char *approxidate_alpha(const char *date, struct tm *tm, struct tm const char *end = date; int i; - while (isalpha(*++end)) + while (isalpha((unsigned char)*++end)) /* scan to non-alpha */; for (i = 0; i < 12; i++) { @@ -783,7 +783,7 @@ static const char *approxidate_digit(const char *date, struct tm *tm, int *num) case '.': case '/': case '-': - if (isdigit(end[1])) { + if (isdigit((unsigned char)end[1])) { size_t match = match_multi_number(number, *end, date, end, tm); if (match) return date + match; diff --git a/src/util/str.c b/src/util/str.c index 0d405bfda50..625faba06db 100644 --- a/src/util/str.c +++ b/src/util/str.c @@ -485,8 +485,8 @@ int git_str_decode_percent( for (str_pos = 0; str_pos < str_len; buf->size++, str_pos++) { if (str[str_pos] == '%' && str_len > str_pos + 2 && - isxdigit(str[str_pos + 1]) && - isxdigit(str[str_pos + 2])) { + isxdigit((unsigned char)str[str_pos + 1]) && + isxdigit((unsigned char)str[str_pos + 2])) { buf->ptr[buf->size] = (HEX_DECODE(str[str_pos + 1]) << 4) + HEX_DECODE(str[str_pos + 2]); str_pos += 2; diff --git a/src/util/util.h b/src/util/util.h index 7f178b169fe..933644fd2b9 100644 --- a/src/util/util.h +++ b/src/util/util.h @@ -89,7 +89,7 @@ GIT_INLINE(int) git__tolower(int c) return (c >= 'A' && c <= 'Z') ? (c + 32) : c; } #else -# define git__tolower(a) tolower(a) +# define git__tolower(a) tolower((unsigned char)(a)) #endif extern size_t git__linenlen(const char *buffer, size_t buffer_len); diff --git a/tests/libgit2/repo/open.c b/tests/libgit2/repo/open.c index 3d1a0620b12..219612016b9 100644 --- a/tests/libgit2/repo/open.c +++ b/tests/libgit2/repo/open.c @@ -316,7 +316,7 @@ static void unposix_path(git_str *path) src = tgt = path->ptr; /* convert "/d/..." to "d:\..." */ - if (src[0] == '/' && isalpha(src[1]) && src[2] == '/') { + if (src[0] == '/' && isalpha((unsigned char)src[1]) && src[2] == '/') { *tgt++ = src[1]; *tgt++ = ':'; *tgt++ = '\\'; From 6847eed97a44170768fb89830ca894b454be0f17 Mon Sep 17 00:00:00 2001 From: Peter Pettersson Date: Sun, 17 Dec 2023 13:35:17 +0100 Subject: [PATCH 420/608] tests: remove test for strcasecmp strcasecmp is a posix function, testing it doesn't make sense. Functions that needs unsigned compare should use git__strcasecmp() --- tests/clar/clar.c | 3 --- tests/util/string.c | 6 ------ 2 files changed, 9 deletions(-) diff --git a/tests/clar/clar.c b/tests/clar/clar.c index 3fc2c768158..9695dc946e4 100644 --- a/tests/clar/clar.c +++ b/tests/clar/clar.c @@ -41,9 +41,6 @@ # ifndef strdup # define strdup(str) _strdup(str) # endif -# ifndef strcasecmp -# define strcasecmp(a,b) _stricmp(a,b) -# endif # ifndef __MINGW32__ # pragma comment(lib, "shell32") diff --git a/tests/util/string.c b/tests/util/string.c index de04dea6983..051f8c3298c 100644 --- a/tests/util/string.c +++ b/tests/util/string.c @@ -111,12 +111,6 @@ void test_string__strcasecmp(void) cl_assert(git__strcasecmp("foo", "FOO") == 0); cl_assert(git__strcasecmp("foo", "fOO") == 0); - cl_assert(strcasecmp("rt\303\202of", "rt dev\302\266h") > 0); - cl_assert(strcasecmp("e\342\202\254ghi=", "et") > 0); - cl_assert(strcasecmp("rt dev\302\266h", "rt\303\202of") < 0); - cl_assert(strcasecmp("et", "e\342\202\254ghi=") < 0); - cl_assert(strcasecmp("\303\215", "\303\255") < 0); - cl_assert(git__strcasecmp("rt\303\202of", "rt dev\302\266h") > 0); cl_assert(git__strcasecmp("e\342\202\254ghi=", "et") > 0); cl_assert(git__strcasecmp("rt dev\302\266h", "rt\303\202of") < 0); From 0023bf7263a6f484f2eb4c50286dca8584d443b9 Mon Sep 17 00:00:00 2001 From: Peter Pettersson Date: Sun, 17 Dec 2023 13:44:48 +0100 Subject: [PATCH 421/608] util: remove unused p_strcasecmp define It was unused and only defined in posix.h It did not exist in its Windows equivalent. --- src/util/unix/posix.h | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/util/unix/posix.h b/src/util/unix/posix.h index 778477e8e2f..60f27d3d333 100644 --- a/src/util/unix/posix.h +++ b/src/util/unix/posix.h @@ -54,8 +54,6 @@ GIT_INLINE(int) p_fsync(int fd) #define p_send(s,b,l,f) send(s,b,l,f) #define p_inet_pton(a, b, c) inet_pton(a, b, c) -#define p_strcasecmp(s1, s2) strcasecmp(s1, s2) -#define p_strncasecmp(s1, s2, c) strncasecmp(s1, s2, c) #define p_vsnprintf(b, c, f, a) vsnprintf(b, c, f, a) #define p_snprintf snprintf #define p_chdir(p) chdir(p) From 9f52a4b2029596cf30cf899d64ee823e82b69aac Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sun, 17 Dec 2023 14:21:47 +0000 Subject: [PATCH 422/608] README: replace gmaster with GitButler master is no more; GitButler is a new client using libgit2. Fixes #6689 --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 3ed33df55f2..19fe7196976 100644 --- a/README.md +++ b/README.md @@ -18,7 +18,7 @@ functionality into your application. Language bindings like in your favorite language. `libgit2` is used to power Git GUI clients like -[GitKraken](https://gitkraken.com/) and [gmaster](https://gmaster.io/) +[GitKraken](https://gitkraken.com/) and [GitButler](https://gitbutler.com/) and on Git hosting providers like [GitHub](https://github.com/), [GitLab](https://gitlab.com/) and [Azure DevOps](https://azure.com/devops). From d963f63816fe3fcce76176abb1fbb0687d889c81 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sun, 17 Dec 2023 20:34:08 +0000 Subject: [PATCH 423/608] process: don't try to close the status `process->status` is a status value; we were mistakenly trying to close it as a file descriptor, as if it were the `status` self-pipe that we open during process creation. Instead, don't try to close it, as it's not a file descriptor. --- src/util/unix/process.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/util/unix/process.c b/src/util/unix/process.c index 0c2029acb95..332f1fcdb3c 100644 --- a/src/util/unix/process.c +++ b/src/util/unix/process.c @@ -556,7 +556,6 @@ int git_process_close(git_process *process) CLOSE_FD(process->child_in); CLOSE_FD(process->child_out); CLOSE_FD(process->child_err); - CLOSE_FD(process->status); return 0; } From c529b2c753c0136a9246125d550d5ae15f9a0ecf Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sun, 17 Dec 2023 20:37:23 +0000 Subject: [PATCH 424/608] ci: allow users to opt-in only to certain tests Previously, users could skip certain tests when running the CI script (`SKIP_ONLINE_TESTS=1`). Provide a mechanism for users to opt-in to only certain tests (`SKIP_TESTS=1 SKIP_ONLINE_TESTS=0`). --- ci/test.sh | 43 ++++++++++++++++++++++++++++++------------- 1 file changed, 30 insertions(+), 13 deletions(-) diff --git a/ci/test.sh b/ci/test.sh index 8c411b65fb8..56cb78ce7d5 100755 --- a/ci/test.sh +++ b/ci/test.sh @@ -3,7 +3,14 @@ set -e if [ -n "$SKIP_TESTS" ]; then - exit 0 + if [ -z "$SKIP_OFFLINE_TESTS" ]; then SKIP_OFFLINE_TESTS=1; fi + if [ -z "$SKIP_ONLINE_TESTS" ]; then SKIP_ONLINE_TESTS=1; fi + if [ -z "$SKIP_GITDAEMON_TESTS" ]; then SKIP_GITDAEMON_TESTS=1; fi + if [ -z "$SKIP_PROXY_TESTS" ]; then SKIP_PROXY_TESTS=1; fi + if [ -z "$SKIP_NTLM_TESTS" ]; then SKIP_NTLM_TESTS=1; fi + if [ -z "$SKIP_NEGOTIATE_TESTS" ]; then SKIP_NEGOTIATE_TESTS=1; fi + if [ -z "$SKIP_SSH_TESTS" ]; then SKIP_SSH_TESTS=1; fi + if [ -z "$SKIP_FUZZERS" ]; then SKIP_FUZZERS=1; fi fi # Windows doesn't run the NTLM tests properly (yet) @@ -24,6 +31,16 @@ export CLAR_HOMEDIR=${HOME} SUCCESS=1 CONTINUE_ON_FAILURE=0 +should_run() { + eval "skip=\${SKIP_${1}}" + [ -z "$skip" \ + -o "$skip" == "no" -o "$skip" == "NO" \ + -o "$skip" == "n" -o "$skip" == "N" \ + -o "$skip" == "false" -o "$skip" == "FALSE" \ + -o "$skip" == "f" -o "$skip" == "F" \ + -o "$skip" == "0" ] +} + cleanup() { echo "Cleaning up..." @@ -140,7 +157,7 @@ echo "########################################################################## echo "" -if [ -z "$SKIP_GITDAEMON_TESTS" ]; then +if should_run "GITDAEMON_TESTS"; then echo "Starting git daemon (standard)..." GIT_STANDARD_DIR=`mktemp -d ${TMPDIR}/git_standard.XXXXXXXX` git init --bare "${GIT_STANDARD_DIR}/test.git" >/dev/null @@ -160,7 +177,7 @@ if [ -z "$SKIP_GITDAEMON_TESTS" ]; then GIT_SHA256_PID=$! fi -if [ -z "$SKIP_PROXY_TESTS" ]; then +if should_run "PROXY_TESTS"; then curl --location --silent --show-error https://github.com/ethomson/poxyproxy/releases/download/v0.7.0/poxyproxy-0.7.0.jar >poxyproxy.jar echo "Starting HTTP proxy (Basic)..." @@ -172,7 +189,7 @@ if [ -z "$SKIP_PROXY_TESTS" ]; then PROXY_NTLM_PID=$! fi -if [ -z "$SKIP_NTLM_TESTS" -o -z "$SKIP_ONLINE_TESTS" ]; then +if should_run "NTLM_TESTS" || should_run "ONLINE_TESTS"; then curl --location --silent --show-error https://github.com/ethomson/poxygit/releases/download/v0.6.0/poxygit-0.6.0.jar >poxygit.jar echo "Starting HTTP server..." @@ -182,7 +199,7 @@ if [ -z "$SKIP_NTLM_TESTS" -o -z "$SKIP_ONLINE_TESTS" ]; then HTTP_PID=$! fi -if [ -z "$SKIP_SSH_TESTS" ]; then +if should_run "SSH_TESTS"; then echo "Starting SSH server..." SSHD_DIR=`mktemp -d ${TMPDIR}/sshd.XXXXXXXX` git init --bare "${SSHD_DIR}/test.git" >/dev/null @@ -232,7 +249,7 @@ fi # Run the tests that do not require network connectivity. -if [ -z "$SKIP_OFFLINE_TESTS" ]; then +if should_run "OFFLINE_TESTS"; then echo "" echo "##############################################################################" echo "## Running core tests" @@ -267,7 +284,7 @@ fi # allow them to retry up to 5 times export GITTEST_FLAKY_RETRY=5 -if [ -z "$SKIP_ONLINE_TESTS" ]; then +if should_run "ONLINE_TESTS"; then # Run the online tests. The "online" test suite only includes the # default online tests that do not require additional configuration. # The "proxy" and "ssh" test suites require further setup. @@ -296,7 +313,7 @@ if [ -z "$SKIP_ONLINE_TESTS" ]; then run_test online_customcert fi -if [ -z "$SKIP_GITDAEMON_TESTS" ]; then +if should_run "GITDAEMON_TESTS"; then echo "" echo "Running gitdaemon (standard) tests" echo "" @@ -324,7 +341,7 @@ if [ -z "$SKIP_GITDAEMON_TESTS" ]; then unset GITTEST_REMOTE_URL fi -if [ -z "$SKIP_PROXY_TESTS" ]; then +if should_run "PROXY_TESTS"; then echo "" echo "Running proxy tests (Basic authentication)" echo "" @@ -350,7 +367,7 @@ if [ -z "$SKIP_PROXY_TESTS" ]; then unset GITTEST_REMOTE_PROXY_PASS fi -if [ -z "$SKIP_NTLM_TESTS" ]; then +if should_run "NTLM_TESTS"; then echo "" echo "Running NTLM tests (IIS emulation)" echo "" @@ -376,7 +393,7 @@ if [ -z "$SKIP_NTLM_TESTS" ]; then unset GITTEST_REMOTE_PASS fi -if [ -z "$SKIP_NEGOTIATE_TESTS" -a -n "$GITTEST_NEGOTIATE_PASSWORD" ]; then +if should_run "NEGOTIATE_TESTS" && -n "$GITTEST_NEGOTIATE_PASSWORD" ; then echo "" echo "Running SPNEGO tests" echo "" @@ -409,7 +426,7 @@ if [ -z "$SKIP_NEGOTIATE_TESTS" -a -n "$GITTEST_NEGOTIATE_PASSWORD" ]; then kdestroy -A fi -if [ -z "$SKIP_SSH_TESTS" ]; then +if should_run "SSH_TESTS"; then export GITTEST_REMOTE_USER=$USER export GITTEST_REMOTE_SSH_KEY="${HOME}/.ssh/id_rsa" export GITTEST_REMOTE_SSH_PUBKEY="${HOME}/.ssh/id_rsa.pub" @@ -445,7 +462,7 @@ fi unset GITTEST_FLAKY_RETRY -if [ -z "$SKIP_FUZZERS" ]; then +if should_run "FUZZERS"; then echo "" echo "##############################################################################" echo "## Running fuzzers" From bc04087577828578d688d2cfeaaa1376397c7547 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 18 Dec 2023 12:08:05 +0000 Subject: [PATCH 425/608] index_pack: close fd on error If we're reading an on-disk packfile, ensure that we close the file descriptor on error. --- src/cli/cmd_index_pack.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/cli/cmd_index_pack.c b/src/cli/cmd_index_pack.c index 17698033ae7..09685c5d4db 100644 --- a/src/cli/cmd_index_pack.c +++ b/src/cli/cmd_index_pack.c @@ -97,9 +97,6 @@ int cmd_index_pack(int argc, char **argv) } } - if (!read_stdin) - p_close(fd); - if (git_indexer_commit(idx, &stats) < 0) { ret = cli_error_git(); goto done; @@ -108,6 +105,9 @@ int cmd_index_pack(int argc, char **argv) cli_progress_finish(&progress); done: + if (!read_stdin && fd >= 0) + p_close(fd); + cli_progress_dispose(&progress); git_indexer_free(idx); return ret; From ecc2ffdabb6d2d495fa3930c78b290549f7c5cd0 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 18 Dec 2023 12:31:46 +0000 Subject: [PATCH 426/608] midx: avoid assignment in assert `GIT_ASSERT` may be a macro for `assert` (when `GIT_ASSERT_HARD` is defined), which may differ in debug builds. Pull the assignment out of the assertion. --- src/libgit2/midx.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/libgit2/midx.c b/src/libgit2/midx.c index d73a1da45d4..71bbb1d0eaf 100644 --- a/src/libgit2/midx.c +++ b/src/libgit2/midx.c @@ -703,9 +703,9 @@ static int midx_write( hash_cb_data.ctx = &ctx; oid_size = git_oid_size(w->oid_type); - - GIT_ASSERT((checksum_type = git_oid_algorithm(w->oid_type))); + checksum_type = git_oid_algorithm(w->oid_type); checksum_size = git_hash_size(checksum_type); + GIT_ASSERT(oid_size && checksum_type && checksum_size); if ((error = git_hash_ctx_init(&ctx, checksum_type)) < 0) return error; From 113b995f484a6be230c7118d2fd7663aec384227 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 18 Dec 2023 12:40:55 +0000 Subject: [PATCH 427/608] process: don't deref a NULL opts `opts` may be null; check before dereferencing. --- src/util/unix/process.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/util/unix/process.c b/src/util/unix/process.c index 332f1fcdb3c..15092cb217f 100644 --- a/src/util/unix/process.c +++ b/src/util/unix/process.c @@ -121,7 +121,7 @@ int git_process_new( GIT_ERROR_CHECK_ALLOC(process); if (git_strlist_copy_with_null(&process->args, args, args_len) < 0 || - merge_env(&process->env, env, env_len, opts->exclude_env) < 0) { + merge_env(&process->env, env, env_len, opts ? opts->exclude_env : false) < 0) { git_process_free(process); return -1; } From a46c426598c89b38aaeab38b6e15a27eaf27ca12 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 18 Dec 2023 12:56:24 +0000 Subject: [PATCH 428/608] gitattributes: .sh files are always Unixy Always checkout out shell scripts with Unix-style line endings. mingw doesn't mind, but cygwin struggles without CRLF. --- .gitattributes | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.gitattributes b/.gitattributes index 3d90b7d61f8..3788dc98358 100644 --- a/.gitattributes +++ b/.gitattributes @@ -1,2 +1,4 @@ * text=auto +ci/**/*.sh text eol=lf +script/**/*.sh text eol=lf tests/resources/** linguist-vendored From d0bb7eb7ea2537183169c1dfff3c3b068eb6b8cc Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 15 Dec 2023 10:48:14 +0000 Subject: [PATCH 429/608] ci: take an optional shell parameter Allow the build matrix to specify its shell, in case we provide one in the setup (eg, Cygwin). --- .github/actions/run-build/action.yml | 9 +++++++-- .github/workflows/main.yml | 2 ++ 2 files changed, 9 insertions(+), 2 deletions(-) diff --git a/.github/actions/run-build/action.yml b/.github/actions/run-build/action.yml index 41145d3b4f0..bd0f59c9a88 100644 --- a/.github/actions/run-build/action.yml +++ b/.github/actions/run-build/action.yml @@ -5,14 +5,19 @@ description: Run a build step in a container or directly on the Actions runner inputs: command: description: Command to run - required: true type: string + required: true container: description: Optional container to run in type: string container-version: description: Version of the container to run type: string + shell: + description: Shell to use + type: string + required: true + default: 'bash' runs: using: 'composite' @@ -42,4 +47,4 @@ runs: else ${{ inputs.command }} fi - shell: bash + shell: ${{ inputs.shell != '' && inputs.shell || 'bash' }} diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index bafffdc1fc8..4865cd1b6c0 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -241,12 +241,14 @@ jobs: command: cd build && ../source/ci/build.sh container: ${{ matrix.platform.container.name }} container-version: ${{ env.docker-registry-container-sha }} + shell: ${{ matrix.platform.shell }} - name: Test uses: ./source/.github/actions/run-build with: command: cd build && ../source/ci/test.sh container: ${{ matrix.platform.container.name }} container-version: ${{ env.docker-registry-container-sha }} + shell: ${{ matrix.platform.shell }} - name: Upload test results uses: actions/upload-artifact@v3 if: success() || failure() From a79ef29e6ac934d262619c0dba21a0c13cc76dee Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Tue, 19 Dec 2023 11:23:12 +0000 Subject: [PATCH 430/608] ci: reorder some parameters for cleanliness --- .github/workflows/main.yml | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 4865cd1b6c0..2f1ff039418 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -31,40 +31,40 @@ jobs: platform: - name: "Linux (Xenial, GCC, OpenSSL, libssh2)" id: xenial-gcc-openssl + os: ubuntu-latest container: name: xenial env: CC: gcc CMAKE_GENERATOR: Ninja CMAKE_OPTIONS: -DUSE_HTTPS=OpenSSL -DREGEX_BACKEND=builtin -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=libssh2 -DDEBUG_STRICT_ALLOC=ON -DDEBUG_STRICT_OPEN=ON - os: ubuntu-latest - name: Linux (Xenial, GCC, mbedTLS, OpenSSH) id: xenial-gcc-mbedtls + os: ubuntu-latest container: name: xenial env: CC: gcc CMAKE_GENERATOR: Ninja CMAKE_OPTIONS: -DUSE_HTTPS=mbedTLS -DUSE_SHA1=HTTPS -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=exec - os: ubuntu-latest - name: "Linux (Xenial, Clang, OpenSSL, OpenSSH)" id: xenial-clang-openssl + os: ubuntu-latest container: name: xenial env: CC: clang CMAKE_GENERATOR: Ninja CMAKE_OPTIONS: -DUSE_HTTPS=OpenSSL -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=exec - os: ubuntu-latest - name: "Linux (Xenial, Clang, mbedTLS, libssh2)" id: xenial-clang-mbedtls + os: ubuntu-latest container: name: xenial env: CC: clang CMAKE_OPTIONS: -DUSE_HTTPS=mbedTLS -DUSE_SHA1=HTTPS -DREGEX_BACKEND=pcre -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=libssh2 CMAKE_GENERATOR: Ninja - os: ubuntu-latest - name: "macOS" id: macos os: macos-12 @@ -142,6 +142,7 @@ jobs: os: ubuntu-latest - name: "Sanitizer (UndefinedBehavior)" id: ubsanitizer + os: ubuntu-latest container: name: focal env: @@ -153,9 +154,9 @@ jobs: SKIP_NEGOTIATE_TESTS: true ASAN_SYMBOLIZER_PATH: /usr/bin/llvm-symbolizer-10 UBSAN_OPTIONS: print_stacktrace=1 - os: ubuntu-latest - name: "Sanitizer (Thread)" id: threadsanitizer + os: ubuntu-latest container: name: focal env: @@ -168,21 +169,21 @@ jobs: ASAN_SYMBOLIZER_PATH: /usr/bin/llvm-symbolizer-10 UBSAN_OPTIONS: print_stacktrace=1 TSAN_OPTIONS: suppressions=/home/libgit2/source/script/thread-sanitizer.supp second_deadlock_stack=1 - os: ubuntu-latest # Experimental: SHA256 support - name: "Linux (SHA256, Xenial, Clang, OpenSSL)" id: xenial-clang-openssl + os: ubuntu-latest container: name: xenial env: CC: clang CMAKE_GENERATOR: Ninja CMAKE_OPTIONS: -DUSE_HTTPS=OpenSSL -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=ON -DEXPERIMENTAL_SHA256=ON - os: ubuntu-latest - name: "macOS (SHA256)" id: macos os: macos-12 + setup-script: osx env: CC: clang CMAKE_OPTIONS: -DREGEX_BACKEND=regcomp_l -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=leaks -DUSE_GSSAPI=ON -DEXPERIMENTAL_SHA256=ON @@ -190,7 +191,6 @@ jobs: PKG_CONFIG_PATH: /usr/local/opt/openssl/lib/pkgconfig SKIP_SSH_TESTS: true SKIP_NEGOTIATE_TESTS: true - setup-script: osx - name: "Windows (SHA256, amd64, Visual Studio)" id: windows-amd64-vs os: windows-2019 From 9d8fa925f285c292c9d879a0fe255145d9f5bef5 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Tue, 19 Dec 2023 11:24:17 +0000 Subject: [PATCH 431/608] ci: optional BUILD_WORKSPACE Setup scripts can change BUILD_WORKSPACE, for instance, if they use a different format for paths, they can replace with `cygpath` variants. --- .github/workflows/main.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 2f1ff039418..2207345194c 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -238,14 +238,14 @@ jobs: - name: Build uses: ./source/.github/actions/run-build with: - command: cd build && ../source/ci/build.sh + command: cd ${BUILD_WORKSPACE:-.}/build && ../source/ci/build.sh container: ${{ matrix.platform.container.name }} container-version: ${{ env.docker-registry-container-sha }} shell: ${{ matrix.platform.shell }} - name: Test uses: ./source/.github/actions/run-build with: - command: cd build && ../source/ci/test.sh + command: cd ${BUILD_WORKSPACE:-.}/build && ../source/ci/test.sh container: ${{ matrix.platform.container.name }} container-version: ${{ env.docker-registry-container-sha }} shell: ${{ matrix.platform.shell }} From 05a8d8d7becd35fc0d923e92b048a9a3ae9cc2cc Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Tue, 19 Dec 2023 11:25:24 +0000 Subject: [PATCH 432/608] ci: show PATH in build script --- ci/build.sh | 2 ++ 1 file changed, 2 insertions(+) diff --git a/ci/build.sh b/ci/build.sh index 80e7a61aecb..a9b66f6613f 100755 --- a/ci/build.sh +++ b/ci/build.sh @@ -61,6 +61,8 @@ if test -n "${CC}"; then "${CC}" --version 2>&1 | indent fi echo "Environment:" +echo "PATH=${BUILD_PATH}" | indent + if test -n "${CC}"; then echo "CC=${CC}" | indent fi From 90136cd4273da9d0fe7873105c877099ef449c33 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Tue, 19 Dec 2023 11:56:06 +0000 Subject: [PATCH 433/608] ci: align nightly with main Ensure that the main builds are all identical in nightly. Nightly should only add new, specialized builds. --- .github/workflows/main.yml | 11 +- .github/workflows/nightly.yml | 253 ++++++++++++++++++---------------- 2 files changed, 144 insertions(+), 120 deletions(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 2207345194c..3aa214cd397 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -29,6 +29,7 @@ jobs: strategy: matrix: platform: + # All builds: core platforms - name: "Linux (Xenial, GCC, OpenSSL, libssh2)" id: xenial-gcc-openssl os: ubuntu-latest @@ -125,9 +126,9 @@ jobs: SKIP_SSH_TESTS: true SKIP_NEGOTIATE_TESTS: true - # Sanitizers + # All builds: sanitizers - name: "Sanitizer (Memory)" - id: memorysanitizer + id: sanitizer-memory container: name: focal env: @@ -141,7 +142,7 @@ jobs: UBSAN_OPTIONS: print_stacktrace=1 os: ubuntu-latest - name: "Sanitizer (UndefinedBehavior)" - id: ubsanitizer + id: sanitizer-ub os: ubuntu-latest container: name: focal @@ -155,7 +156,7 @@ jobs: ASAN_SYMBOLIZER_PATH: /usr/bin/llvm-symbolizer-10 UBSAN_OPTIONS: print_stacktrace=1 - name: "Sanitizer (Thread)" - id: threadsanitizer + id: sanitizer-thread os: ubuntu-latest container: name: focal @@ -170,7 +171,7 @@ jobs: UBSAN_OPTIONS: print_stacktrace=1 TSAN_OPTIONS: suppressions=/home/libgit2/source/script/thread-sanitizer.supp second_deadlock_stack=1 - # Experimental: SHA256 support + # All builds: experimental SHA256 support - name: "Linux (SHA256, Xenial, Clang, OpenSSL)" id: xenial-clang-openssl os: ubuntu-latest diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml index b48cbf51260..aca4506b26b 100644 --- a/.github/workflows/nightly.yml +++ b/.github/workflows/nightly.yml @@ -26,55 +26,106 @@ jobs: strategy: matrix: platform: - - name: Linux (Xenial, GCC, OpenSSL) + # All builds: core platforms + - name: "Linux (Xenial, GCC, OpenSSL, libssh2)" + id: xenial-gcc-openssl + os: ubuntu-latest container: name: xenial env: CC: gcc CMAKE_GENERATOR: Ninja - CMAKE_OPTIONS: -DUSE_HTTPS=OpenSSL -DREGEX_BACKEND=builtin -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=ON + CMAKE_OPTIONS: -DUSE_HTTPS=OpenSSL -DREGEX_BACKEND=builtin -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=libssh2 -DDEBUG_STRICT_ALLOC=ON -DDEBUG_STRICT_OPEN=ON + - name: Linux (Xenial, GCC, mbedTLS, OpenSSH) + id: xenial-gcc-mbedtls os: ubuntu-latest - - name: "Linux (Xenial, GCC, mbedTLS)" container: name: xenial env: CC: gcc CMAKE_GENERATOR: Ninja - CMAKE_OPTIONS: -DUSE_HTTPS=mbedTLS -DUSE_SHA1=HTTPS -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=ON + CMAKE_OPTIONS: -DUSE_HTTPS=mbedTLS -DUSE_SHA1=HTTPS -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=exec + - name: "Linux (Xenial, Clang, OpenSSL, OpenSSH)" + id: xenial-clang-openssl os: ubuntu-latest - - name: "Linux (Xenial, Clang, OpenSSL)" container: name: xenial env: CC: clang CMAKE_GENERATOR: Ninja - CMAKE_OPTIONS: -DUSE_HTTPS=OpenSSL -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=ON + CMAKE_OPTIONS: -DUSE_HTTPS=OpenSSL -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=exec + - name: "Linux (Xenial, Clang, mbedTLS, libssh2)" + id: xenial-clang-mbedtls os: ubuntu-latest - - name: "Linux (Xenial, Clang, mbedTLS)" container: name: xenial env: CC: clang - CMAKE_OPTIONS: -DUSE_HTTPS=mbedTLS -DUSE_SHA1=HTTPS -DREGEX_BACKEND=pcre -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=ON - CMAKE_GENERATOR: Ninja - os: ubuntu-latest - - name: "Linux (no threads)" - container: - name: xenial - env: - CC: gcc - CMAKE_OPTIONS: -DTHREADSAFE=OFF -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=ON + CMAKE_OPTIONS: -DUSE_HTTPS=mbedTLS -DUSE_SHA1=HTTPS -DREGEX_BACKEND=pcre -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=libssh2 CMAKE_GENERATOR: Ninja - os: ubuntu-latest - - name: "Linux (dynamically-loaded OpenSSL)" - container: - name: xenial + - name: "macOS" + id: macos + os: macos-12 env: CC: clang - CMAKE_OPTIONS: -DUSE_HTTPS=OpenSSL-Dynamic -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=ON + CMAKE_OPTIONS: -DREGEX_BACKEND=regcomp_l -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=leaks -DUSE_GSSAPI=ON CMAKE_GENERATOR: Ninja - os: ubuntu-latest - - name: "Linux (MemorySanitizer)" + PKG_CONFIG_PATH: /usr/local/opt/openssl/lib/pkgconfig + SKIP_SSH_TESTS: true + SKIP_NEGOTIATE_TESTS: true + setup-script: osx + - name: "Windows (amd64, Visual Studio, Schannel)" + id: windows-amd64-vs + os: windows-2019 + setup-script: win32 + env: + ARCH: amd64 + CMAKE_GENERATOR: Visual Studio 16 2019 + CMAKE_OPTIONS: -A x64 -DWIN32_LEAKCHECK=ON -DDEPRECATE_HARD=ON -DUSE_HTTPS=Schannel -DUSE_SSH=ON -DCMAKE_PREFIX_PATH=D:\Temp\libssh2 + BUILD_PATH: C:\Windows\system32;C:\Windows;C:\Windows\System32\Wbem;C:\Program Files (x86)\CMake\bin;D:\Temp\libssh2\bin + BUILD_TEMP: D:\Temp + SKIP_SSH_TESTS: true + SKIP_NEGOTIATE_TESTS: true + - name: "Windows (x86, Visual Studio, WinHTTP)" + id: windows-x86-vs + os: windows-2019 + setup-script: win32 + env: + ARCH: x86 + CMAKE_GENERATOR: Visual Studio 16 2019 + CMAKE_OPTIONS: -A Win32 -DWIN32_LEAKCHECK=ON -DDEPRECATE_HARD=ON -DUSE_SHA1=HTTPS -DUSE_BUNDLED_ZLIB=ON -DUSE_SSH=ON -DCMAKE_PREFIX_PATH=D:\Temp\libssh2 + BUILD_PATH: C:\Windows\system32;C:\Windows;C:\Windows\System32\Wbem;C:\Program Files (x86)\CMake\bin;D:\Temp\libssh2\bin + BUILD_TEMP: D:\Temp + SKIP_SSH_TESTS: true + SKIP_NEGOTIATE_TESTS: true + - name: "Windows (amd64, mingw, WinHTTP)" + id: windows-amd64-mingw + os: windows-2019 + setup-script: mingw + env: + ARCH: amd64 + CMAKE_GENERATOR: MinGW Makefiles + CMAKE_OPTIONS: -DDEPRECATE_HARD=ON + BUILD_TEMP: D:\Temp + BUILD_PATH: D:\Temp\mingw64\bin;C:\Windows\system32;C:\Windows;C:\Windows\System32\Wbem;C:\Program Files (x86)\CMake\bin + SKIP_SSH_TESTS: true + SKIP_NEGOTIATE_TESTS: true + - name: "Windows (x86, mingw, Schannel)" + id: windows-x86-mingw + os: windows-2019 + setup-script: mingw + env: + ARCH: x86 + CMAKE_GENERATOR: MinGW Makefiles + CMAKE_OPTIONS: -DDEPRECATE_HARD=ON -DUSE_HTTPS=Schannel + BUILD_TEMP: D:\Temp + BUILD_PATH: D:\Temp\mingw32\bin;C:\Windows\system32;C:\Windows;C:\Windows\System32\Wbem;C:\Program Files (x86)\CMake\bin + SKIP_SSH_TESTS: true + SKIP_NEGOTIATE_TESTS: true + + # All builds: sanitizers + - name: "Sanitizer (Memory)" + id: memorysanitizer container: name: focal env: @@ -87,59 +138,58 @@ jobs: ASAN_SYMBOLIZER_PATH: /usr/bin/llvm-symbolizer-10 UBSAN_OPTIONS: print_stacktrace=1 os: ubuntu-latest - - name: "Linux (UndefinedBehaviorSanitizer)" + - name: "Sanitizer (UndefinedBehavior)" + id: ubsanitizer + os: ubuntu-latest container: name: focal env: CC: clang-10 CFLAGS: -fsanitize=undefined,nullability -fno-sanitize-recover=undefined,nullability -fsanitize-blacklist=/home/libgit2/source/script/sanitizers.supp -fno-optimize-sibling-calls -fno-omit-frame-pointer - CMAKE_OPTIONS: -DCMAKE_PREFIX_PATH=/usr/local -DUSE_HTTPS=OpenSSL -DUSE_SHA1=HTTPS -DREGEX_BACKEND=pcre -DDEPRECATE_HARD=ON -DUSE_BUNDLED_ZLIB=ON + CMAKE_OPTIONS: -DCMAKE_PREFIX_PATH=/usr/local -DUSE_HTTPS=OpenSSL -DUSE_SHA1=HTTPS -DREGEX_BACKEND=pcre -DDEPRECATE_HARD=ON -DUSE_BUNDLED_ZLIB=ON -DUSE_SSH=ON CMAKE_GENERATOR: Ninja SKIP_SSH_TESTS: true SKIP_NEGOTIATE_TESTS: true ASAN_SYMBOLIZER_PATH: /usr/bin/llvm-symbolizer-10 + UBSAN_OPTIONS: print_stacktrace=1 + - name: "Sanitizer (Thread)" + id: threadsanitizer os: ubuntu-latest - - name: "Linux (ThreadSanitizer)" container: name: focal env: CC: clang-10 CFLAGS: -fsanitize=thread -fno-optimize-sibling-calls -fno-omit-frame-pointer - CMAKE_OPTIONS: -DCMAKE_PREFIX_PATH=/usr/local -DUSE_HTTPS=OpenSSL -DUSE_SHA1=HTTPS -DREGEX_BACKEND=pcre -DDEPRECATE_HARD=ON -DUSE_BUNDLED_ZLIB=ON + CMAKE_OPTIONS: -DCMAKE_PREFIX_PATH=/usr/local -DUSE_HTTPS=OpenSSL -DUSE_SHA1=HTTPS -DREGEX_BACKEND=pcre -DDEPRECATE_HARD=ON -DUSE_BUNDLED_ZLIB=ON -DUSE_SSH=ON CMAKE_GENERATOR: Ninja SKIP_SSH_TESTS: true SKIP_NEGOTIATE_TESTS: true ASAN_SYMBOLIZER_PATH: /usr/bin/llvm-symbolizer-10 + UBSAN_OPTIONS: print_stacktrace=1 TSAN_OPTIONS: suppressions=/home/libgit2/source/script/thread-sanitizer.supp second_deadlock_stack=1 + + # Nightly builds: extended platforms + - name: "Linux (CentOS 7, OpenSSL)" + id: centos7-openssl os: ubuntu-latest - - name: "Linux (no mmap)" - container: - name: focal - env: - CC: clang-10 - CFLAGS: -DNO_MMAP - CMAKE_OPTIONS: -DCMAKE_PREFIX_PATH=/usr/local - CMAKE_GENERATOR: Ninja - SKIP_SSH_TESTS: true - SKIP_NEGOTIATE_TESTS: true - os: ubuntu-latest - - name: "Linux (CentOS 7)" container: name: centos7 env: CMAKE_OPTIONS: -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=ON PKG_CONFIG_PATH: /usr/local/lib/pkgconfig SKIP_NEGOTIATE_TESTS: true - os: ubuntu-latest - name: "Linux (CentOS 7, dynamically-loaded OpenSSL)" + id: centos7-dynamicopenssl + os: ubuntu-latest container: name: centos7 env: CMAKE_OPTIONS: -DUSE_HTTPS=OpenSSL-Dynamic -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=ON PKG_CONFIG_PATH: /usr/local/lib/pkgconfig SKIP_NEGOTIATE_TESTS: true + - name: "Linux (CentOS 8, OpenSSL)" + id: centos8-openssl os: ubuntu-latest - - name: "Linux (CentOS 8)" container: name: centos8 env: @@ -147,8 +197,9 @@ jobs: PKG_CONFIG_PATH: /usr/local/lib/pkgconfig SKIP_NEGOTIATE_TESTS: true SKIP_SSH_TESTS: true - os: ubuntu-latest - name: "Linux (CentOS 8, dynamically-loaded OpenSSL)" + id: centos8-dynamicopenssl + os: ubuntu-latest container: name: centos8 env: @@ -156,79 +207,8 @@ jobs: PKG_CONFIG_PATH: /usr/local/lib/pkgconfig SKIP_NEGOTIATE_TESTS: true SKIP_SSH_TESTS: true - os: ubuntu-latest - - name: "macOS" - os: macos-12 - env: - CC: clang - CMAKE_OPTIONS: -DREGEX_BACKEND=regcomp_l -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=leaks -DUSE_GSSAPI=ON - PKG_CONFIG_PATH: /usr/local/opt/openssl/lib/pkgconfig - SKIP_SSH_TESTS: true - SKIP_NEGOTIATE_TESTS: true - setup-script: osx - - name: "Windows (amd64, Visual Studio, WinHTTP)" - os: windows-2019 - env: - ARCH: amd64 - CMAKE_GENERATOR: Visual Studio 16 2019 - CMAKE_OPTIONS: -A x64 -DWIN32_LEAKCHECK=ON -DDEPRECATE_HARD=ON -DUSE_HTTPS=WinHTTP - SKIP_SSH_TESTS: true - SKIP_NEGOTIATE_TESTS: true - - name: "Windows (x86, Visual Studio, WinHTTP)" - os: windows-2019 - env: - ARCH: x86 - CMAKE_GENERATOR: Visual Studio 16 2019 - CMAKE_OPTIONS: -A Win32 -DWIN32_LEAKCHECK=ON -DDEPRECATE_HARD=ON -DUSE_HTTPS=WinHTTP -DUSE_SHA1=HTTPS -DUSE_BUNDLED_ZLIB=ON - SKIP_SSH_TESTS: true - SKIP_NEGOTIATE_TESTS: true - - name: "Windows (amd64, Visual Studio, Schannel)" - os: windows-2019 - env: - ARCH: amd64 - CMAKE_GENERATOR: Visual Studio 16 2019 - CMAKE_OPTIONS: -A x64 -DWIN32_LEAKCHECK=ON -DDEPRECATE_HARD=ON -DUSE_HTTPS=Schannel - SKIP_SSH_TESTS: true - SKIP_NEGOTIATE_TESTS: true - - name: "Windows (x86, Visual Studio, Schannel)" - os: windows-2019 - env: ARCH: x86 - CMAKE_GENERATOR: Visual Studio 16 2019 - CMAKE_OPTIONS: -A Win32 -DWIN32_LEAKCHECK=ON -DDEPRECATE_HARD=ON -DUSE_HTTPS=Schannel -DUSE_BUNDLED_ZLIB=ON - SKIP_SSH_TESTS: true - SKIP_NEGOTIATE_TESTS: true - - name: "Windows (amd64, mingw, WinHTTP)" - os: windows-2019 - setup-script: mingw - env: - ARCH: amd64 - CMAKE_GENERATOR: MinGW Makefiles - CMAKE_OPTIONS: -DDEPRECATE_HARD=ON - BUILD_TEMP: D:\Temp - BUILD_PATH: D:\Temp\mingw64\bin;C:\Windows\system32;C:\Windows;C:\Windows\System32\Wbem;C:\Program Files (x86)\CMake\bin - SKIP_SSH_TESTS: true - SKIP_NEGOTIATE_TESTS: true - - name: "Windows (x86, mingw, Schannel)" - os: windows-2019 - setup-script: mingw - env: - ARCH: x86 - CMAKE_GENERATOR: MinGW Makefiles - CMAKE_OPTIONS: -DDEPRECATE_HARD=ON -DUSE_HTTPS=Schannel - BUILD_TEMP: D:\Temp - BUILD_PATH: D:\Temp\mingw32\bin;C:\Windows\system32;C:\Windows;C:\Windows\System32\Wbem;C:\Program Files (x86)\CMake\bin - SKIP_SSH_TESTS: true - SKIP_NEGOTIATE_TESTS: true - - name: "Windows (no mmap)" - os: windows-2019 - env: - ARCH: amd64 - CMAKE_GENERATOR: Visual Studio 16 2019 - CFLAGS: -DNO_MMAP - CMAKE_OPTIONS: -A x64 -DDEPRECATE_HARD=ON - SKIP_SSH_TESTS: true - SKIP_NEGOTIATE_TESTS: true + - name: "Linux (Bionic, GCC, dynamically-loaded OpenSSL)" container: name: bionic @@ -286,7 +266,50 @@ jobs: SKIP_PROXY_TESTS: true os: ubuntu-latest - # Experimental: SHA256 support + # Nightly builds: ensure we fallback when missing core functionality + - name: "Linux (no threads)" + id: xenial-nothreads + os: ubuntu-latest + container: + name: xenial + env: + CC: gcc + CMAKE_OPTIONS: -DTHREADSAFE=OFF -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=ON + CMAKE_GENERATOR: Ninja + - name: "Linux (no mmap)" + id: focal-nommap + os: ubuntu-latest + container: + name: focal + env: + CC: clang-10 + CFLAGS: -DNO_MMAP + CMAKE_OPTIONS: -DCMAKE_PREFIX_PATH=/usr/local + CMAKE_GENERATOR: Ninja + SKIP_SSH_TESTS: true + SKIP_NEGOTIATE_TESTS: true + - name: "Windows (no mmap)" + os: windows-2019 + env: + ARCH: amd64 + CMAKE_GENERATOR: Visual Studio 16 2019 + CFLAGS: -DNO_MMAP + CMAKE_OPTIONS: -A x64 -DDEPRECATE_HARD=ON + SKIP_SSH_TESTS: true + SKIP_NEGOTIATE_TESTS: true + + # Nightly builds: extended SSL support + - name: "Linux (dynamically-loaded OpenSSL)" + id: xenial-dynamicopenssl + os: ubuntu-latest + container: + name: xenial + env: + CC: clang + CMAKE_OPTIONS: -DUSE_HTTPS=OpenSSL-Dynamic -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=ON + CMAKE_GENERATOR: Ninja + + # All builds: experimental SHA256 support - name: "Linux (SHA256, Xenial, Clang, OpenSSL)" id: xenial-clang-openssl container: From d83fccc97a8025563dc4d4c6268259a50529ac68 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Wed, 20 Dec 2023 11:10:53 +0000 Subject: [PATCH 434/608] zlib: upgrade bundled zlib to v1.3 --- COPYING | 2 +- deps/zlib/CMakeLists.txt | 7 +- deps/zlib/COPYING | 27 -- deps/zlib/LICENSE | 22 ++ deps/zlib/adler32.c | 32 +- deps/zlib/crc32.c | 261 +++++--------- deps/zlib/deflate.c | 750 +++++++++++++++++---------------------- deps/zlib/deflate.h | 16 +- deps/zlib/gzguts.h | 23 +- deps/zlib/infback.c | 47 +-- deps/zlib/inffast.c | 5 +- deps/zlib/inffast.h | 2 +- deps/zlib/inflate.c | 136 ++----- deps/zlib/inftrees.c | 17 +- deps/zlib/inftrees.h | 8 +- deps/zlib/trees.c | 623 ++++++++++++++------------------ deps/zlib/zconf.h | 27 +- deps/zlib/zlib.h | 392 ++++++++++---------- deps/zlib/zutil.c | 62 +--- deps/zlib/zutil.h | 19 +- 20 files changed, 1053 insertions(+), 1425 deletions(-) delete mode 100644 deps/zlib/COPYING create mode 100644 deps/zlib/LICENSE diff --git a/COPYING b/COPYING index 25c8d8c6b78..ff5e76857e3 100644 --- a/COPYING +++ b/COPYING @@ -365,7 +365,7 @@ Public License instead of this License. The bundled ZLib code is licensed under the ZLib license: -Copyright (C) 1995-2010 Jean-loup Gailly and Mark Adler + (C) 1995-2022 Jean-loup Gailly and Mark Adler This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages diff --git a/deps/zlib/CMakeLists.txt b/deps/zlib/CMakeLists.txt index 435877d869d..078ce69b32e 100644 --- a/deps/zlib/CMakeLists.txt +++ b/deps/zlib/CMakeLists.txt @@ -1,5 +1,10 @@ disable_warnings(implicit-fallthrough) -add_definitions(-DNO_VIZ -DSTDC -DNO_GZIP) +add_definitions(-DNO_VIZ -DSTDC -DNO_GZIP -DHAVE_SYS_TYPES_H -DHAVE_STDINT_H -DHAVE_STDDEF_H) + +if(MINGW OR MSYS) + add_definitions(-DZ_HAVE_UNISTD_H -D_LFS64_LARGEFILE -D_LARGEFILE64_SOURCE=1) +endif() + file(GLOB SRC_ZLIB "*.c" "*.h") list(SORT SRC_ZLIB) include_directories(".") diff --git a/deps/zlib/COPYING b/deps/zlib/COPYING deleted file mode 100644 index e2e86d76968..00000000000 --- a/deps/zlib/COPYING +++ /dev/null @@ -1,27 +0,0 @@ -Copyright (C) 1995-2017 Jean-loup Gailly and Mark Adler - -This software is provided 'as-is', without any express or implied -warranty. In no event will the authors be held liable for any -damages arising from the use of this software. - -Permission is granted to anyone to use this software for any -purpose, including commercial applications, and to alter it and -redistribute it freely, subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you - must not claim that you wrote the original software. If you - use this software in a product, an acknowledgment in the - product documentation would be appreciated but is not - required. - -2. Altered source versions must be plainly marked as such, and - must not be misrepresented as being the original software. - -3. This notice may not be removed or altered from any source - distribution. - -Jean-loup Gailly Mark Adler - -The data format used by the zlib library is described by RFCs -(Request for Comments) 1950 to 1952 in the files rfc1950 (zlib -format), rfc1951 (deflate format) and rfc1952 (gzip format). diff --git a/deps/zlib/LICENSE b/deps/zlib/LICENSE new file mode 100644 index 00000000000..ab8ee6f7142 --- /dev/null +++ b/deps/zlib/LICENSE @@ -0,0 +1,22 @@ +Copyright notice: + + (C) 1995-2022 Jean-loup Gailly and Mark Adler + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + + Jean-loup Gailly Mark Adler + jloup@gzip.org madler@alumni.caltech.edu diff --git a/deps/zlib/adler32.c b/deps/zlib/adler32.c index d0be4380a39..04b81d29bad 100644 --- a/deps/zlib/adler32.c +++ b/deps/zlib/adler32.c @@ -7,8 +7,6 @@ #include "zutil.h" -local uLong adler32_combine_ OF((uLong adler1, uLong adler2, z_off64_t len2)); - #define BASE 65521U /* largest prime smaller than 65536 */ #define NMAX 5552 /* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */ @@ -60,11 +58,7 @@ local uLong adler32_combine_ OF((uLong adler1, uLong adler2, z_off64_t len2)); #endif /* ========================================================================= */ -uLong ZEXPORT adler32_z(adler, buf, len) - uLong adler; - const Bytef *buf; - z_size_t len; -{ +uLong ZEXPORT adler32_z(uLong adler, const Bytef *buf, z_size_t len) { unsigned long sum2; unsigned n; @@ -131,20 +125,12 @@ uLong ZEXPORT adler32_z(adler, buf, len) } /* ========================================================================= */ -uLong ZEXPORT adler32(adler, buf, len) - uLong adler; - const Bytef *buf; - uInt len; -{ +uLong ZEXPORT adler32(uLong adler, const Bytef *buf, uInt len) { return adler32_z(adler, buf, len); } /* ========================================================================= */ -local uLong adler32_combine_(adler1, adler2, len2) - uLong adler1; - uLong adler2; - z_off64_t len2; -{ +local uLong adler32_combine_(uLong adler1, uLong adler2, z_off64_t len2) { unsigned long sum1; unsigned long sum2; unsigned rem; @@ -169,18 +155,10 @@ local uLong adler32_combine_(adler1, adler2, len2) } /* ========================================================================= */ -uLong ZEXPORT adler32_combine(adler1, adler2, len2) - uLong adler1; - uLong adler2; - z_off_t len2; -{ +uLong ZEXPORT adler32_combine(uLong adler1, uLong adler2, z_off_t len2) { return adler32_combine_(adler1, adler2, len2); } -uLong ZEXPORT adler32_combine64(adler1, adler2, len2) - uLong adler1; - uLong adler2; - z_off64_t len2; -{ +uLong ZEXPORT adler32_combine64(uLong adler1, uLong adler2, z_off64_t len2) { return adler32_combine_(adler1, adler2, len2); } diff --git a/deps/zlib/crc32.c b/deps/zlib/crc32.c index 25cb7a009e1..6c38f5c04c6 100644 --- a/deps/zlib/crc32.c +++ b/deps/zlib/crc32.c @@ -98,10 +98,6 @@ # endif #endif -/* Local functions. */ -local z_crc_t multmodp OF((z_crc_t a, z_crc_t b)); -local z_crc_t x2nmodp OF((z_off64_t n, unsigned k)); - /* If available, use the ARM processor CRC32 instruction. */ #if defined(__aarch64__) && defined(__ARM_FEATURE_CRC32) && W == 8 # define ARMCRC32 @@ -114,12 +110,7 @@ local z_crc_t x2nmodp OF((z_off64_t n, unsigned k)); instruction, if one is available. This assumes that word_t is either 32 bits or 64 bits. */ - -local z_word_t byte_swap(z_word_t word); - -local z_word_t byte_swap(word) - z_word_t word; -{ +local z_word_t byte_swap(z_word_t word) { # if W == 8 return (word & 0xff00000000000000) >> 56 | @@ -140,24 +131,77 @@ local z_word_t byte_swap(word) } #endif +#ifdef DYNAMIC_CRC_TABLE +/* ========================================================================= + * Table of powers of x for combining CRC-32s, filled in by make_crc_table() + * below. + */ + local z_crc_t FAR x2n_table[32]; +#else +/* ========================================================================= + * Tables for byte-wise and braided CRC-32 calculations, and a table of powers + * of x for combining CRC-32s, all made by make_crc_table(). + */ +# include "crc32.h" +#endif + /* CRC polynomial. */ #define POLY 0xedb88320 /* p(x) reflected, with x^32 implied */ -#ifdef DYNAMIC_CRC_TABLE +/* + Return a(x) multiplied by b(x) modulo p(x), where p(x) is the CRC polynomial, + reflected. For speed, this requires that a not be zero. + */ +local z_crc_t multmodp(z_crc_t a, z_crc_t b) { + z_crc_t m, p; + + m = (z_crc_t)1 << 31; + p = 0; + for (;;) { + if (a & m) { + p ^= b; + if ((a & (m - 1)) == 0) + break; + } + m >>= 1; + b = b & 1 ? (b >> 1) ^ POLY : b >> 1; + } + return p; +} + +/* + Return x^(n * 2^k) modulo p(x). Requires that x2n_table[] has been + initialized. + */ +local z_crc_t x2nmodp(z_off64_t n, unsigned k) { + z_crc_t p; + + p = (z_crc_t)1 << 31; /* x^0 == 1 */ + while (n) { + if (n & 1) + p = multmodp(x2n_table[k & 31], p); + n >>= 1; + k++; + } + return p; +} +#ifdef DYNAMIC_CRC_TABLE +/* ========================================================================= + * Build the tables for byte-wise and braided CRC-32 calculations, and a table + * of powers of x for combining CRC-32s. + */ local z_crc_t FAR crc_table[256]; -local z_crc_t FAR x2n_table[32]; -local void make_crc_table OF((void)); #ifdef W local z_word_t FAR crc_big_table[256]; local z_crc_t FAR crc_braid_table[W][256]; local z_word_t FAR crc_braid_big_table[W][256]; - local void braid OF((z_crc_t [][256], z_word_t [][256], int, int)); + local void braid(z_crc_t [][256], z_word_t [][256], int, int); #endif #ifdef MAKECRCH - local void write_table OF((FILE *, const z_crc_t FAR *, int)); - local void write_table32hi OF((FILE *, const z_word_t FAR *, int)); - local void write_table64 OF((FILE *, const z_word_t FAR *, int)); + local void write_table(FILE *, const z_crc_t FAR *, int); + local void write_table32hi(FILE *, const z_word_t FAR *, int); + local void write_table64(FILE *, const z_word_t FAR *, int); #endif /* MAKECRCH */ /* @@ -170,7 +214,6 @@ local void make_crc_table OF((void)); /* Definition of once functionality. */ typedef struct once_s once_t; -local void once OF((once_t *, void (*)(void))); /* Check for the availability of atomics. */ #if defined(__STDC__) && __STDC_VERSION__ >= 201112L && \ @@ -190,10 +233,7 @@ struct once_s { invoke once() at the same time. The state must be a once_t initialized with ONCE_INIT. */ -local void once(state, init) - once_t *state; - void (*init)(void); -{ +local void once(once_t *state, void (*init)(void)) { if (!atomic_load(&state->done)) { if (atomic_flag_test_and_set(&state->begun)) while (!atomic_load(&state->done)) @@ -216,10 +256,7 @@ struct once_s { /* Test and set. Alas, not atomic, but tries to minimize the period of vulnerability. */ -local int test_and_set OF((int volatile *)); -local int test_and_set(flag) - int volatile *flag; -{ +local int test_and_set(int volatile *flag) { int was; was = *flag; @@ -228,10 +265,7 @@ local int test_and_set(flag) } /* Run the provided init() function once. This is not thread-safe. */ -local void once(state, init) - once_t *state; - void (*init)(void); -{ +local void once(once_t *state, void (*init)(void)) { if (!state->done) { if (test_and_set(&state->begun)) while (!state->done) @@ -273,8 +307,7 @@ local once_t made = ONCE_INIT; combinations of CRC register values and incoming bytes. */ -local void make_crc_table() -{ +local void make_crc_table(void) { unsigned i, j, n; z_crc_t p; @@ -441,11 +474,7 @@ local void make_crc_table() Write the 32-bit values in table[0..k-1] to out, five per line in hexadecimal separated by commas. */ -local void write_table(out, table, k) - FILE *out; - const z_crc_t FAR *table; - int k; -{ +local void write_table(FILE *out, const z_crc_t FAR *table, int k) { int n; for (n = 0; n < k; n++) @@ -458,11 +487,7 @@ local void write_table(out, table, k) Write the high 32-bits of each value in table[0..k-1] to out, five per line in hexadecimal separated by commas. */ -local void write_table32hi(out, table, k) -FILE *out; -const z_word_t FAR *table; -int k; -{ +local void write_table32hi(FILE *out, const z_word_t FAR *table, int k) { int n; for (n = 0; n < k; n++) @@ -478,11 +503,7 @@ int k; bits. If not, then the type cast and format string can be adjusted accordingly. */ -local void write_table64(out, table, k) - FILE *out; - const z_word_t FAR *table; - int k; -{ +local void write_table64(FILE *out, const z_word_t FAR *table, int k) { int n; for (n = 0; n < k; n++) @@ -492,8 +513,7 @@ local void write_table64(out, table, k) } /* Actually do the deed. */ -int main() -{ +int main(void) { make_crc_table(); return 0; } @@ -505,12 +525,7 @@ int main() Generate the little and big-endian braid tables for the given n and z_word_t size w. Each array must have room for w blocks of 256 elements. */ -local void braid(ltl, big, n, w) - z_crc_t ltl[][256]; - z_word_t big[][256]; - int n; - int w; -{ +local void braid(z_crc_t ltl[][256], z_word_t big[][256], int n, int w) { int k; z_crc_t i, p, q; for (k = 0; k < w; k++) { @@ -525,69 +540,13 @@ local void braid(ltl, big, n, w) } #endif -#else /* !DYNAMIC_CRC_TABLE */ -/* ======================================================================== - * Tables for byte-wise and braided CRC-32 calculations, and a table of powers - * of x for combining CRC-32s, all made by make_crc_table(). - */ -#include "crc32.h" #endif /* DYNAMIC_CRC_TABLE */ -/* ======================================================================== - * Routines used for CRC calculation. Some are also required for the table - * generation above. - */ - -/* - Return a(x) multiplied by b(x) modulo p(x), where p(x) is the CRC polynomial, - reflected. For speed, this requires that a not be zero. - */ -local z_crc_t multmodp(a, b) - z_crc_t a; - z_crc_t b; -{ - z_crc_t m, p; - - m = (z_crc_t)1 << 31; - p = 0; - for (;;) { - if (a & m) { - p ^= b; - if ((a & (m - 1)) == 0) - break; - } - m >>= 1; - b = b & 1 ? (b >> 1) ^ POLY : b >> 1; - } - return p; -} - -/* - Return x^(n * 2^k) modulo p(x). Requires that x2n_table[] has been - initialized. - */ -local z_crc_t x2nmodp(n, k) - z_off64_t n; - unsigned k; -{ - z_crc_t p; - - p = (z_crc_t)1 << 31; /* x^0 == 1 */ - while (n) { - if (n & 1) - p = multmodp(x2n_table[k & 31], p); - n >>= 1; - k++; - } - return p; -} - /* ========================================================================= * This function can be used by asm versions of crc32(), and to force the * generation of the CRC tables in a threaded application. */ -const z_crc_t FAR * ZEXPORT get_crc_table() -{ +const z_crc_t FAR * ZEXPORT get_crc_table(void) { #ifdef DYNAMIC_CRC_TABLE once(&made, make_crc_table); #endif /* DYNAMIC_CRC_TABLE */ @@ -613,11 +572,8 @@ const z_crc_t FAR * ZEXPORT get_crc_table() #define Z_BATCH_ZEROS 0xa10d3d0c /* computed from Z_BATCH = 3990 */ #define Z_BATCH_MIN 800 /* fewest words in a final batch */ -unsigned long ZEXPORT crc32_z(crc, buf, len) - unsigned long crc; - const unsigned char FAR *buf; - z_size_t len; -{ +unsigned long ZEXPORT crc32_z(unsigned long crc, const unsigned char FAR *buf, + z_size_t len) { z_crc_t val; z_word_t crc1, crc2; const z_word_t *word; @@ -633,7 +589,7 @@ unsigned long ZEXPORT crc32_z(crc, buf, len) #endif /* DYNAMIC_CRC_TABLE */ /* Pre-condition the CRC */ - crc ^= 0xffffffff; + crc = (~crc) & 0xffffffff; /* Compute the CRC up to a word boundary. */ while (len && ((z_size_t)buf & 7) != 0) { @@ -648,8 +604,8 @@ unsigned long ZEXPORT crc32_z(crc, buf, len) len &= 7; /* Do three interleaved CRCs to realize the throughput of one crc32x - instruction per cycle. Each CRC is calcuated on Z_BATCH words. The three - CRCs are combined into a single CRC after each set of batches. */ + instruction per cycle. Each CRC is calculated on Z_BATCH words. The + three CRCs are combined into a single CRC after each set of batches. */ while (num >= 3 * Z_BATCH) { crc1 = 0; crc2 = 0; @@ -712,26 +668,19 @@ unsigned long ZEXPORT crc32_z(crc, buf, len) #ifdef W -local z_crc_t crc_word(z_word_t data); -local z_word_t crc_word_big(z_word_t data); - /* Return the CRC of the W bytes in the word_t data, taking the least-significant byte of the word as the first byte of data, without any pre or post conditioning. This is used to combine the CRCs of each braid. */ -local z_crc_t crc_word(data) - z_word_t data; -{ +local z_crc_t crc_word(z_word_t data) { int k; for (k = 0; k < W; k++) data = (data >> 8) ^ crc_table[data & 0xff]; return (z_crc_t)data; } -local z_word_t crc_word_big(data) - z_word_t data; -{ +local z_word_t crc_word_big(z_word_t data) { int k; for (k = 0; k < W; k++) data = (data << 8) ^ @@ -742,11 +691,8 @@ local z_word_t crc_word_big(data) #endif /* ========================================================================= */ -unsigned long ZEXPORT crc32_z(crc, buf, len) - unsigned long crc; - const unsigned char FAR *buf; - z_size_t len; -{ +unsigned long ZEXPORT crc32_z(unsigned long crc, const unsigned char FAR *buf, + z_size_t len) { /* Return initial CRC, if requested. */ if (buf == Z_NULL) return 0; @@ -755,7 +701,7 @@ unsigned long ZEXPORT crc32_z(crc, buf, len) #endif /* DYNAMIC_CRC_TABLE */ /* Pre-condition the CRC */ - crc ^= 0xffffffff; + crc = (~crc) & 0xffffffff; #ifdef W @@ -778,8 +724,8 @@ unsigned long ZEXPORT crc32_z(crc, buf, len) words = (z_word_t const *)buf; /* Do endian check at execution time instead of compile time, since ARM - processors can change the endianess at execution time. If the - compiler knows what the endianess will be, it can optimize out the + processors can change the endianness at execution time. If the + compiler knows what the endianness will be, it can optimize out the check and the unused branch. */ endian = 1; if (*(unsigned char *)&endian) { @@ -1066,39 +1012,26 @@ unsigned long ZEXPORT crc32_z(crc, buf, len) #endif /* ========================================================================= */ -unsigned long ZEXPORT crc32(crc, buf, len) - unsigned long crc; - const unsigned char FAR *buf; - uInt len; -{ +unsigned long ZEXPORT crc32(unsigned long crc, const unsigned char FAR *buf, + uInt len) { return crc32_z(crc, buf, len); } /* ========================================================================= */ -uLong ZEXPORT crc32_combine64(crc1, crc2, len2) - uLong crc1; - uLong crc2; - z_off64_t len2; -{ +uLong ZEXPORT crc32_combine64(uLong crc1, uLong crc2, z_off64_t len2) { #ifdef DYNAMIC_CRC_TABLE once(&made, make_crc_table); #endif /* DYNAMIC_CRC_TABLE */ - return multmodp(x2nmodp(len2, 3), crc1) ^ crc2; + return multmodp(x2nmodp(len2, 3), crc1) ^ (crc2 & 0xffffffff); } /* ========================================================================= */ -uLong ZEXPORT crc32_combine(crc1, crc2, len2) - uLong crc1; - uLong crc2; - z_off_t len2; -{ - return crc32_combine64(crc1, crc2, len2); +uLong ZEXPORT crc32_combine(uLong crc1, uLong crc2, z_off_t len2) { + return crc32_combine64(crc1, crc2, (z_off64_t)len2); } /* ========================================================================= */ -uLong ZEXPORT crc32_combine_gen64(len2) - z_off64_t len2; -{ +uLong ZEXPORT crc32_combine_gen64(z_off64_t len2) { #ifdef DYNAMIC_CRC_TABLE once(&made, make_crc_table); #endif /* DYNAMIC_CRC_TABLE */ @@ -1106,17 +1039,11 @@ uLong ZEXPORT crc32_combine_gen64(len2) } /* ========================================================================= */ -uLong ZEXPORT crc32_combine_gen(len2) - z_off_t len2; -{ - return crc32_combine_gen64(len2); +uLong ZEXPORT crc32_combine_gen(z_off_t len2) { + return crc32_combine_gen64((z_off64_t)len2); } /* ========================================================================= */ -uLong ZEXPORT crc32_combine_op(crc1, crc2, op) - uLong crc1; - uLong crc2; - uLong op; -{ - return multmodp(op, crc1) ^ crc2; +uLong ZEXPORT crc32_combine_op(uLong crc1, uLong crc2, uLong op) { + return multmodp(op, crc1) ^ (crc2 & 0xffffffff); } diff --git a/deps/zlib/deflate.c b/deps/zlib/deflate.c index feacd78327d..bd011751920 100644 --- a/deps/zlib/deflate.c +++ b/deps/zlib/deflate.c @@ -1,5 +1,5 @@ /* deflate.c -- compress data using the deflation algorithm - * Copyright (C) 1995-2022 Jean-loup Gailly and Mark Adler + * Copyright (C) 1995-2023 Jean-loup Gailly and Mark Adler * For conditions of distribution and use, see copyright notice in zlib.h */ @@ -52,7 +52,7 @@ #include "deflate.h" const char deflate_copyright[] = - " deflate 1.2.12 Copyright 1995-2022 Jean-loup Gailly and Mark Adler "; + " deflate 1.3 Copyright 1995-2023 Jean-loup Gailly and Mark Adler "; /* If you use the zlib library in a product, an acknowledgment is welcome in the documentation of your product. If for some reason you cannot @@ -60,9 +60,6 @@ const char deflate_copyright[] = copyright string in the executable of your product. */ -/* =========================================================================== - * Function prototypes. - */ typedef enum { need_more, /* block not completed, need more input or more output */ block_done, /* block flush performed */ @@ -70,35 +67,16 @@ typedef enum { finish_done /* finish done, accept no more input or output */ } block_state; -typedef block_state (*compress_func) OF((deflate_state *s, int flush)); +typedef block_state (*compress_func)(deflate_state *s, int flush); /* Compression function. Returns the block state after the call. */ -local int deflateStateCheck OF((z_streamp strm)); -local void slide_hash OF((deflate_state *s)); -local void fill_window OF((deflate_state *s)); -local block_state deflate_stored OF((deflate_state *s, int flush)); -local block_state deflate_fast OF((deflate_state *s, int flush)); +local block_state deflate_stored(deflate_state *s, int flush); +local block_state deflate_fast(deflate_state *s, int flush); #ifndef FASTEST -local block_state deflate_slow OF((deflate_state *s, int flush)); -#endif -local block_state deflate_rle OF((deflate_state *s, int flush)); -local block_state deflate_huff OF((deflate_state *s, int flush)); -local void lm_init OF((deflate_state *s)); -local void putShortMSB OF((deflate_state *s, uInt b)); -local void flush_pending OF((z_streamp strm)); -local unsigned read_buf OF((z_streamp strm, Bytef *buf, unsigned size)); -#ifdef ASMV -# pragma message("Assembler code may have bugs -- use at your own risk") - void match_init OF((void)); /* asm code initialization */ - uInt longest_match OF((deflate_state *s, IPos cur_match)); -#else -local uInt longest_match OF((deflate_state *s, IPos cur_match)); -#endif - -#ifdef ZLIB_DEBUG -local void check_match OF((deflate_state *s, IPos start, IPos match, - int length)); +local block_state deflate_slow(deflate_state *s, int flush); #endif +local block_state deflate_rle(deflate_state *s, int flush); +local block_state deflate_huff(deflate_state *s, int flush); /* =========================================================================== * Local data @@ -160,7 +138,7 @@ local const config configuration_table[10] = { * characters, so that a running hash key can be computed from the previous * key instead of complete recalculation each time. */ -#define UPDATE_HASH(s,h,c) (h = (((h)<hash_shift) ^ (c)) & s->hash_mask) +#define UPDATE_HASH(s,h,c) (h = (((h) << s->hash_shift) ^ (c)) & s->hash_mask) /* =========================================================================== @@ -191,9 +169,9 @@ local const config configuration_table[10] = { */ #define CLEAR_HASH(s) \ do { \ - s->head[s->hash_size-1] = NIL; \ + s->head[s->hash_size - 1] = NIL; \ zmemzero((Bytef *)s->head, \ - (unsigned)(s->hash_size-1)*sizeof(*s->head)); \ + (unsigned)(s->hash_size - 1)*sizeof(*s->head)); \ } while (0) /* =========================================================================== @@ -203,12 +181,10 @@ local const config configuration_table[10] = { */ #if defined(__has_feature) # if __has_feature(memory_sanitizer) -__attribute__((no_sanitize("memory"))) + __attribute__((no_sanitize("memory"))) # endif #endif -local void slide_hash(s) - deflate_state *s; -{ +local void slide_hash(deflate_state *s) { unsigned n, m; Posf *p; uInt wsize = s->w_size; @@ -232,30 +208,177 @@ local void slide_hash(s) #endif } +/* =========================================================================== + * Read a new buffer from the current input stream, update the adler32 + * and total number of bytes read. All deflate() input goes through + * this function so some applications may wish to modify it to avoid + * allocating a large strm->next_in buffer and copying from it. + * (See also flush_pending()). + */ +local unsigned read_buf(z_streamp strm, Bytef *buf, unsigned size) { + unsigned len = strm->avail_in; + + if (len > size) len = size; + if (len == 0) return 0; + + strm->avail_in -= len; + + zmemcpy(buf, strm->next_in, len); + if (strm->state->wrap == 1) { + strm->adler = adler32(strm->adler, buf, len); + } +#ifdef GZIP + else if (strm->state->wrap == 2) { + strm->adler = crc32(strm->adler, buf, len); + } +#endif + strm->next_in += len; + strm->total_in += len; + + return len; +} + +/* =========================================================================== + * Fill the window when the lookahead becomes insufficient. + * Updates strstart and lookahead. + * + * IN assertion: lookahead < MIN_LOOKAHEAD + * OUT assertions: strstart <= window_size-MIN_LOOKAHEAD + * At least one byte has been read, or avail_in == 0; reads are + * performed for at least two bytes (required for the zip translate_eol + * option -- not supported here). + */ +local void fill_window(deflate_state *s) { + unsigned n; + unsigned more; /* Amount of free space at the end of the window. */ + uInt wsize = s->w_size; + + Assert(s->lookahead < MIN_LOOKAHEAD, "already enough lookahead"); + + do { + more = (unsigned)(s->window_size -(ulg)s->lookahead -(ulg)s->strstart); + + /* Deal with !@#$% 64K limit: */ + if (sizeof(int) <= 2) { + if (more == 0 && s->strstart == 0 && s->lookahead == 0) { + more = wsize; + + } else if (more == (unsigned)(-1)) { + /* Very unlikely, but possible on 16 bit machine if + * strstart == 0 && lookahead == 1 (input done a byte at time) + */ + more--; + } + } + + /* If the window is almost full and there is insufficient lookahead, + * move the upper half to the lower one to make room in the upper half. + */ + if (s->strstart >= wsize + MAX_DIST(s)) { + + zmemcpy(s->window, s->window + wsize, (unsigned)wsize - more); + s->match_start -= wsize; + s->strstart -= wsize; /* we now have strstart >= MAX_DIST */ + s->block_start -= (long) wsize; + if (s->insert > s->strstart) + s->insert = s->strstart; + slide_hash(s); + more += wsize; + } + if (s->strm->avail_in == 0) break; + + /* If there was no sliding: + * strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 && + * more == window_size - lookahead - strstart + * => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1) + * => more >= window_size - 2*WSIZE + 2 + * In the BIG_MEM or MMAP case (not yet supported), + * window_size == input_size + MIN_LOOKAHEAD && + * strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD. + * Otherwise, window_size == 2*WSIZE so more >= 2. + * If there was sliding, more >= WSIZE. So in all cases, more >= 2. + */ + Assert(more >= 2, "more < 2"); + + n = read_buf(s->strm, s->window + s->strstart + s->lookahead, more); + s->lookahead += n; + + /* Initialize the hash value now that we have some input: */ + if (s->lookahead + s->insert >= MIN_MATCH) { + uInt str = s->strstart - s->insert; + s->ins_h = s->window[str]; + UPDATE_HASH(s, s->ins_h, s->window[str + 1]); +#if MIN_MATCH != 3 + Call UPDATE_HASH() MIN_MATCH-3 more times +#endif + while (s->insert) { + UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); +#ifndef FASTEST + s->prev[str & s->w_mask] = s->head[s->ins_h]; +#endif + s->head[s->ins_h] = (Pos)str; + str++; + s->insert--; + if (s->lookahead + s->insert < MIN_MATCH) + break; + } + } + /* If the whole input has less than MIN_MATCH bytes, ins_h is garbage, + * but this is not important since only literal bytes will be emitted. + */ + + } while (s->lookahead < MIN_LOOKAHEAD && s->strm->avail_in != 0); + + /* If the WIN_INIT bytes after the end of the current data have never been + * written, then zero those bytes in order to avoid memory check reports of + * the use of uninitialized (or uninitialised as Julian writes) bytes by + * the longest match routines. Update the high water mark for the next + * time through here. WIN_INIT is set to MAX_MATCH since the longest match + * routines allow scanning to strstart + MAX_MATCH, ignoring lookahead. + */ + if (s->high_water < s->window_size) { + ulg curr = s->strstart + (ulg)(s->lookahead); + ulg init; + + if (s->high_water < curr) { + /* Previous high water mark below current data -- zero WIN_INIT + * bytes or up to end of window, whichever is less. + */ + init = s->window_size - curr; + if (init > WIN_INIT) + init = WIN_INIT; + zmemzero(s->window + curr, (unsigned)init); + s->high_water = curr + init; + } + else if (s->high_water < (ulg)curr + WIN_INIT) { + /* High water mark at or above current data, but below current data + * plus WIN_INIT -- zero out to current data plus WIN_INIT, or up + * to end of window, whichever is less. + */ + init = (ulg)curr + WIN_INIT - s->high_water; + if (init > s->window_size - s->high_water) + init = s->window_size - s->high_water; + zmemzero(s->window + s->high_water, (unsigned)init); + s->high_water += init; + } + } + + Assert((ulg)s->strstart <= s->window_size - MIN_LOOKAHEAD, + "not enough room for search"); +} + /* ========================================================================= */ -int ZEXPORT deflateInit_(strm, level, version, stream_size) - z_streamp strm; - int level; - const char *version; - int stream_size; -{ +int ZEXPORT deflateInit_(z_streamp strm, int level, const char *version, + int stream_size) { return deflateInit2_(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, version, stream_size); /* To do: ignore strm->next_in if we use it as window */ } /* ========================================================================= */ -int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy, - version, stream_size) - z_streamp strm; - int level; - int method; - int windowBits; - int memLevel; - int strategy; - const char *version; - int stream_size; -{ +int ZEXPORT deflateInit2_(z_streamp strm, int level, int method, + int windowBits, int memLevel, int strategy, + const char *version, int stream_size) { deflate_state *s; int wrap = 1; static const char my_version[] = ZLIB_VERSION; @@ -290,6 +413,8 @@ int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy, if (windowBits < 0) { /* suppress zlib wrapper */ wrap = 0; + if (windowBits < -15) + return Z_STREAM_ERROR; windowBits = -windowBits; } #ifdef GZIP @@ -319,7 +444,7 @@ int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy, s->hash_bits = (uInt)memLevel + 7; s->hash_size = 1 << s->hash_bits; s->hash_mask = s->hash_size - 1; - s->hash_shift = ((s->hash_bits+MIN_MATCH-1)/MIN_MATCH); + s->hash_shift = ((s->hash_bits + MIN_MATCH-1) / MIN_MATCH); s->window = (Bytef *) ZALLOC(strm, s->w_size, 2*sizeof(Byte)); s->prev = (Posf *) ZALLOC(strm, s->w_size, sizeof(Pos)); @@ -345,11 +470,11 @@ int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy, * sym_buf value to read moves forward three bytes. From that symbol, up to * 31 bits are written to pending_buf. The closest the written pending_buf * bits gets to the next sym_buf symbol to read is just before the last - * code is written. At that time, 31*(n-2) bits have been written, just - * after 24*(n-2) bits have been consumed from sym_buf. sym_buf starts at - * 8*n bits into pending_buf. (Note that the symbol buffer fills when n-1 + * code is written. At that time, 31*(n - 2) bits have been written, just + * after 24*(n - 2) bits have been consumed from sym_buf. sym_buf starts at + * 8*n bits into pending_buf. (Note that the symbol buffer fills when n - 1 * symbols are written.) The closest the writing gets to what is unread is - * then n+14 bits. Here n is lit_bufsize, which is 16384 by default, and + * then n + 14 bits. Here n is lit_bufsize, which is 16384 by default, and * can range from 128 to 32768. * * Therefore, at a minimum, there are 142 bits of space between what is @@ -395,9 +520,7 @@ int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy, /* ========================================================================= * Check for a valid deflate stream state. Return 0 if ok, 1 if not. */ -local int deflateStateCheck (strm) - z_streamp strm; -{ +local int deflateStateCheck(z_streamp strm) { deflate_state *s; if (strm == Z_NULL || strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0) @@ -418,11 +541,8 @@ local int deflateStateCheck (strm) } /* ========================================================================= */ -int ZEXPORT deflateSetDictionary (strm, dictionary, dictLength) - z_streamp strm; - const Bytef *dictionary; - uInt dictLength; -{ +int ZEXPORT deflateSetDictionary(z_streamp strm, const Bytef *dictionary, + uInt dictLength) { deflate_state *s; uInt str, n; int wrap; @@ -487,11 +607,8 @@ int ZEXPORT deflateSetDictionary (strm, dictionary, dictLength) } /* ========================================================================= */ -int ZEXPORT deflateGetDictionary (strm, dictionary, dictLength) - z_streamp strm; - Bytef *dictionary; - uInt *dictLength; -{ +int ZEXPORT deflateGetDictionary(z_streamp strm, Bytef *dictionary, + uInt *dictLength) { deflate_state *s; uInt len; @@ -509,9 +626,7 @@ int ZEXPORT deflateGetDictionary (strm, dictionary, dictLength) } /* ========================================================================= */ -int ZEXPORT deflateResetKeep (strm) - z_streamp strm; -{ +int ZEXPORT deflateResetKeep(z_streamp strm) { deflate_state *s; if (deflateStateCheck(strm)) { @@ -546,10 +661,32 @@ int ZEXPORT deflateResetKeep (strm) return Z_OK; } +/* =========================================================================== + * Initialize the "longest match" routines for a new zlib stream + */ +local void lm_init(deflate_state *s) { + s->window_size = (ulg)2L*s->w_size; + + CLEAR_HASH(s); + + /* Set the default configuration parameters: + */ + s->max_lazy_match = configuration_table[s->level].max_lazy; + s->good_match = configuration_table[s->level].good_length; + s->nice_match = configuration_table[s->level].nice_length; + s->max_chain_length = configuration_table[s->level].max_chain; + + s->strstart = 0; + s->block_start = 0L; + s->lookahead = 0; + s->insert = 0; + s->match_length = s->prev_length = MIN_MATCH-1; + s->match_available = 0; + s->ins_h = 0; +} + /* ========================================================================= */ -int ZEXPORT deflateReset (strm) - z_streamp strm; -{ +int ZEXPORT deflateReset(z_streamp strm) { int ret; ret = deflateResetKeep(strm); @@ -559,10 +696,7 @@ int ZEXPORT deflateReset (strm) } /* ========================================================================= */ -int ZEXPORT deflateSetHeader (strm, head) - z_streamp strm; - gz_headerp head; -{ +int ZEXPORT deflateSetHeader(z_streamp strm, gz_headerp head) { if (deflateStateCheck(strm) || strm->state->wrap != 2) return Z_STREAM_ERROR; strm->state->gzhead = head; @@ -570,11 +704,7 @@ int ZEXPORT deflateSetHeader (strm, head) } /* ========================================================================= */ -int ZEXPORT deflatePending (strm, pending, bits) - unsigned *pending; - int *bits; - z_streamp strm; -{ +int ZEXPORT deflatePending(z_streamp strm, unsigned *pending, int *bits) { if (deflateStateCheck(strm)) return Z_STREAM_ERROR; if (pending != Z_NULL) *pending = strm->state->pending; @@ -584,11 +714,7 @@ int ZEXPORT deflatePending (strm, pending, bits) } /* ========================================================================= */ -int ZEXPORT deflatePrime (strm, bits, value) - z_streamp strm; - int bits; - int value; -{ +int ZEXPORT deflatePrime(z_streamp strm, int bits, int value) { deflate_state *s; int put; @@ -611,11 +737,7 @@ int ZEXPORT deflatePrime (strm, bits, value) } /* ========================================================================= */ -int ZEXPORT deflateParams(strm, level, strategy) - z_streamp strm; - int level; - int strategy; -{ +int ZEXPORT deflateParams(z_streamp strm, int level, int strategy) { deflate_state *s; compress_func func; @@ -660,13 +782,8 @@ int ZEXPORT deflateParams(strm, level, strategy) } /* ========================================================================= */ -int ZEXPORT deflateTune(strm, good_length, max_lazy, nice_length, max_chain) - z_streamp strm; - int good_length; - int max_lazy; - int nice_length; - int max_chain; -{ +int ZEXPORT deflateTune(z_streamp strm, int good_length, int max_lazy, + int nice_length, int max_chain) { deflate_state *s; if (deflateStateCheck(strm)) return Z_STREAM_ERROR; @@ -679,36 +796,47 @@ int ZEXPORT deflateTune(strm, good_length, max_lazy, nice_length, max_chain) } /* ========================================================================= - * For the default windowBits of 15 and memLevel of 8, this function returns - * a close to exact, as well as small, upper bound on the compressed size. - * They are coded as constants here for a reason--if the #define's are - * changed, then this function needs to be changed as well. The return - * value for 15 and 8 only works for those exact settings. + * For the default windowBits of 15 and memLevel of 8, this function returns a + * close to exact, as well as small, upper bound on the compressed size. This + * is an expansion of ~0.03%, plus a small constant. * - * For any setting other than those defaults for windowBits and memLevel, - * the value returned is a conservative worst case for the maximum expansion - * resulting from using fixed blocks instead of stored blocks, which deflate - * can emit on compressed data for some combinations of the parameters. + * For any setting other than those defaults for windowBits and memLevel, one + * of two worst case bounds is returned. This is at most an expansion of ~4% or + * ~13%, plus a small constant. * - * This function could be more sophisticated to provide closer upper bounds for - * every combination of windowBits and memLevel. But even the conservative - * upper bound of about 14% expansion does not seem onerous for output buffer - * allocation. + * Both the 0.03% and 4% derive from the overhead of stored blocks. The first + * one is for stored blocks of 16383 bytes (memLevel == 8), whereas the second + * is for stored blocks of 127 bytes (the worst case memLevel == 1). The + * expansion results from five bytes of header for each stored block. + * + * The larger expansion of 13% results from a window size less than or equal to + * the symbols buffer size (windowBits <= memLevel + 7). In that case some of + * the data being compressed may have slid out of the sliding window, impeding + * a stored block from being emitted. Then the only choice is a fixed or + * dynamic block, where a fixed block limits the maximum expansion to 9 bits + * per 8-bit byte, plus 10 bits for every block. The smallest block size for + * which this can occur is 255 (memLevel == 2). + * + * Shifts are used to approximate divisions, for speed. */ -uLong ZEXPORT deflateBound(strm, sourceLen) - z_streamp strm; - uLong sourceLen; -{ +uLong ZEXPORT deflateBound(z_streamp strm, uLong sourceLen) { deflate_state *s; - uLong complen, wraplen; + uLong fixedlen, storelen, wraplen; + + /* upper bound for fixed blocks with 9-bit literals and length 255 + (memLevel == 2, which is the lowest that may not use stored blocks) -- + ~13% overhead plus a small constant */ + fixedlen = sourceLen + (sourceLen >> 3) + (sourceLen >> 8) + + (sourceLen >> 9) + 4; - /* conservative upper bound for compressed data */ - complen = sourceLen + - ((sourceLen + 7) >> 3) + ((sourceLen + 63) >> 6) + 5; + /* upper bound for stored blocks with length 127 (memLevel == 1) -- + ~4% overhead plus a small constant */ + storelen = sourceLen + (sourceLen >> 5) + (sourceLen >> 7) + + (sourceLen >> 11) + 7; - /* if can't get parameters, return conservative bound plus zlib wrapper */ + /* if can't get parameters, return larger bound plus a zlib wrapper */ if (deflateStateCheck(strm)) - return complen + 6; + return (fixedlen > storelen ? fixedlen : storelen) + 6; /* compute wrapper length */ s = strm->state; @@ -745,11 +873,13 @@ uLong ZEXPORT deflateBound(strm, sourceLen) wraplen = 6; } - /* if not default parameters, return conservative bound */ + /* if not default parameters, return one of the conservative bounds */ if (s->w_bits != 15 || s->hash_bits != 8 + 7) - return complen + wraplen; + return (s->w_bits <= s->hash_bits && s->level ? fixedlen : storelen) + + wraplen; - /* default settings: return tight bound for that case */ + /* default settings: return tight bound for that case -- ~0.03% overhead + plus a small constant */ return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) + (sourceLen >> 25) + 13 - 6 + wraplen; } @@ -759,10 +889,7 @@ uLong ZEXPORT deflateBound(strm, sourceLen) * IN assertion: the stream state is correct and there is enough room in * pending_buf. */ -local void putShortMSB (s, b) - deflate_state *s; - uInt b; -{ +local void putShortMSB(deflate_state *s, uInt b) { put_byte(s, (Byte)(b >> 8)); put_byte(s, (Byte)(b & 0xff)); } @@ -773,9 +900,7 @@ local void putShortMSB (s, b) * applications may wish to modify it to avoid allocating a large * strm->next_out buffer and copying into it. (See also read_buf()). */ -local void flush_pending(strm) - z_streamp strm; -{ +local void flush_pending(z_streamp strm) { unsigned len; deflate_state *s = strm->state; @@ -806,10 +931,7 @@ local void flush_pending(strm) } while (0) /* ========================================================================= */ -int ZEXPORT deflate (strm, flush) - z_streamp strm; - int flush; -{ +int ZEXPORT deflate(z_streamp strm, int flush) { int old_flush; /* value of flush param for previous deflate call */ deflate_state *s; @@ -861,7 +983,7 @@ int ZEXPORT deflate (strm, flush) s->status = BUSY_STATE; if (s->status == INIT_STATE) { /* zlib header */ - uInt header = (Z_DEFLATED + ((s->w_bits-8)<<4)) << 8; + uInt header = (Z_DEFLATED + ((s->w_bits - 8) << 4)) << 8; uInt level_flags; if (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2) @@ -1121,9 +1243,7 @@ int ZEXPORT deflate (strm, flush) } /* ========================================================================= */ -int ZEXPORT deflateEnd (strm) - z_streamp strm; -{ +int ZEXPORT deflateEnd(z_streamp strm) { int status; if (deflateStateCheck(strm)) return Z_STREAM_ERROR; @@ -1147,11 +1267,10 @@ int ZEXPORT deflateEnd (strm) * To simplify the source, this is not supported for 16-bit MSDOS (which * doesn't have enough memory anyway to duplicate compression states). */ -int ZEXPORT deflateCopy (dest, source) - z_streamp dest; - z_streamp source; -{ +int ZEXPORT deflateCopy(z_streamp dest, z_streamp source) { #ifdef MAXSEG_64K + (void)dest; + (void)source; return Z_STREAM_ERROR; #else deflate_state *ds; @@ -1199,71 +1318,6 @@ int ZEXPORT deflateCopy (dest, source) #endif /* MAXSEG_64K */ } -/* =========================================================================== - * Read a new buffer from the current input stream, update the adler32 - * and total number of bytes read. All deflate() input goes through - * this function so some applications may wish to modify it to avoid - * allocating a large strm->next_in buffer and copying from it. - * (See also flush_pending()). - */ -local unsigned read_buf(strm, buf, size) - z_streamp strm; - Bytef *buf; - unsigned size; -{ - unsigned len = strm->avail_in; - - if (len > size) len = size; - if (len == 0) return 0; - - strm->avail_in -= len; - - zmemcpy(buf, strm->next_in, len); - if (strm->state->wrap == 1) { - strm->adler = adler32(strm->adler, buf, len); - } -#ifdef GZIP - else if (strm->state->wrap == 2) { - strm->adler = crc32(strm->adler, buf, len); - } -#endif - strm->next_in += len; - strm->total_in += len; - - return len; -} - -/* =========================================================================== - * Initialize the "longest match" routines for a new zlib stream - */ -local void lm_init (s) - deflate_state *s; -{ - s->window_size = (ulg)2L*s->w_size; - - CLEAR_HASH(s); - - /* Set the default configuration parameters: - */ - s->max_lazy_match = configuration_table[s->level].max_lazy; - s->good_match = configuration_table[s->level].good_length; - s->nice_match = configuration_table[s->level].nice_length; - s->max_chain_length = configuration_table[s->level].max_chain; - - s->strstart = 0; - s->block_start = 0L; - s->lookahead = 0; - s->insert = 0; - s->match_length = s->prev_length = MIN_MATCH-1; - s->match_available = 0; - s->ins_h = 0; -#ifndef FASTEST -#ifdef ASMV - match_init(); /* initialize the asm code */ -#endif -#endif -} - #ifndef FASTEST /* =========================================================================== * Set match_start to the longest match starting at the given string and @@ -1274,14 +1328,7 @@ local void lm_init (s) * string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1 * OUT assertion: the match length is not greater than s->lookahead. */ -#ifndef ASMV -/* For 80x86 and 680x0, an optimized version will be provided in match.asm or - * match.S. The code will be functionally equivalent. - */ -local uInt longest_match(s, cur_match) - deflate_state *s; - IPos cur_match; /* current match */ -{ +local uInt longest_match(deflate_state *s, IPos cur_match) { unsigned chain_length = s->max_chain_length;/* max hash chain length */ register Bytef *scan = s->window + s->strstart; /* current string */ register Bytef *match; /* matched string */ @@ -1302,10 +1349,10 @@ local uInt longest_match(s, cur_match) */ register Bytef *strend = s->window + s->strstart + MAX_MATCH - 1; register ush scan_start = *(ushf*)scan; - register ush scan_end = *(ushf*)(scan+best_len-1); + register ush scan_end = *(ushf*)(scan + best_len - 1); #else register Bytef *strend = s->window + s->strstart + MAX_MATCH; - register Byte scan_end1 = scan[best_len-1]; + register Byte scan_end1 = scan[best_len - 1]; register Byte scan_end = scan[best_len]; #endif @@ -1323,7 +1370,8 @@ local uInt longest_match(s, cur_match) */ if ((uInt)nice_match > s->lookahead) nice_match = (int)s->lookahead; - Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead"); + Assert((ulg)s->strstart <= s->window_size - MIN_LOOKAHEAD, + "need lookahead"); do { Assert(cur_match < s->strstart, "no future"); @@ -1341,43 +1389,44 @@ local uInt longest_match(s, cur_match) /* This code assumes sizeof(unsigned short) == 2. Do not use * UNALIGNED_OK if your compiler uses a different size. */ - if (*(ushf*)(match+best_len-1) != scan_end || + if (*(ushf*)(match + best_len - 1) != scan_end || *(ushf*)match != scan_start) continue; /* It is not necessary to compare scan[2] and match[2] since they are * always equal when the other bytes match, given that the hash keys * are equal and that HASH_BITS >= 8. Compare 2 bytes at a time at - * strstart+3, +5, ... up to strstart+257. We check for insufficient + * strstart + 3, + 5, up to strstart + 257. We check for insufficient * lookahead only every 4th comparison; the 128th check will be made - * at strstart+257. If MAX_MATCH-2 is not a multiple of 8, it is + * at strstart + 257. If MAX_MATCH-2 is not a multiple of 8, it is * necessary to put more guard bytes at the end of the window, or * to check more often for insufficient lookahead. */ Assert(scan[2] == match[2], "scan[2]?"); scan++, match++; do { - } while (*(ushf*)(scan+=2) == *(ushf*)(match+=2) && - *(ushf*)(scan+=2) == *(ushf*)(match+=2) && - *(ushf*)(scan+=2) == *(ushf*)(match+=2) && - *(ushf*)(scan+=2) == *(ushf*)(match+=2) && + } while (*(ushf*)(scan += 2) == *(ushf*)(match += 2) && + *(ushf*)(scan += 2) == *(ushf*)(match += 2) && + *(ushf*)(scan += 2) == *(ushf*)(match += 2) && + *(ushf*)(scan += 2) == *(ushf*)(match += 2) && scan < strend); /* The funny "do {}" generates better code on most compilers */ - /* Here, scan <= window+strstart+257 */ - Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); + /* Here, scan <= window + strstart + 257 */ + Assert(scan <= s->window + (unsigned)(s->window_size - 1), + "wild scan"); if (*scan == *match) scan++; - len = (MAX_MATCH - 1) - (int)(strend-scan); + len = (MAX_MATCH - 1) - (int)(strend - scan); scan = strend - (MAX_MATCH-1); #else /* UNALIGNED_OK */ - if (match[best_len] != scan_end || - match[best_len-1] != scan_end1 || - *match != *scan || - *++match != scan[1]) continue; + if (match[best_len] != scan_end || + match[best_len - 1] != scan_end1 || + *match != *scan || + *++match != scan[1]) continue; - /* The check at best_len-1 can be removed because it will be made + /* The check at best_len - 1 can be removed because it will be made * again later. (This heuristic is not always a win.) * It is not necessary to compare scan[2] and match[2] since they * are always equal when the other bytes match, given that @@ -1387,7 +1436,7 @@ local uInt longest_match(s, cur_match) Assert(*scan == *match, "match[2]?"); /* We check for insufficient lookahead only every 8th comparison; - * the 256th check will be made at strstart+258. + * the 256th check will be made at strstart + 258. */ do { } while (*++scan == *++match && *++scan == *++match && @@ -1396,7 +1445,8 @@ local uInt longest_match(s, cur_match) *++scan == *++match && *++scan == *++match && scan < strend); - Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); + Assert(scan <= s->window + (unsigned)(s->window_size - 1), + "wild scan"); len = MAX_MATCH - (int)(strend - scan); scan = strend - MAX_MATCH; @@ -1408,9 +1458,9 @@ local uInt longest_match(s, cur_match) best_len = len; if (len >= nice_match) break; #ifdef UNALIGNED_OK - scan_end = *(ushf*)(scan+best_len-1); + scan_end = *(ushf*)(scan + best_len - 1); #else - scan_end1 = scan[best_len-1]; + scan_end1 = scan[best_len - 1]; scan_end = scan[best_len]; #endif } @@ -1420,17 +1470,13 @@ local uInt longest_match(s, cur_match) if ((uInt)best_len <= s->lookahead) return (uInt)best_len; return s->lookahead; } -#endif /* ASMV */ #else /* FASTEST */ /* --------------------------------------------------------------------------- * Optimized version for FASTEST only */ -local uInt longest_match(s, cur_match) - deflate_state *s; - IPos cur_match; /* current match */ -{ +local uInt longest_match(deflate_state *s, IPos cur_match) { register Bytef *scan = s->window + s->strstart; /* current string */ register Bytef *match; /* matched string */ register int len; /* length of current match */ @@ -1441,7 +1487,8 @@ local uInt longest_match(s, cur_match) */ Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever"); - Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead"); + Assert((ulg)s->strstart <= s->window_size - MIN_LOOKAHEAD, + "need lookahead"); Assert(cur_match < s->strstart, "no future"); @@ -1451,7 +1498,7 @@ local uInt longest_match(s, cur_match) */ if (match[0] != scan[0] || match[1] != scan[1]) return MIN_MATCH-1; - /* The check at best_len-1 can be removed because it will be made + /* The check at best_len - 1 can be removed because it will be made * again later. (This heuristic is not always a win.) * It is not necessary to compare scan[2] and match[2] since they * are always equal when the other bytes match, given that @@ -1461,7 +1508,7 @@ local uInt longest_match(s, cur_match) Assert(*scan == *match, "match[2]?"); /* We check for insufficient lookahead only every 8th comparison; - * the 256th check will be made at strstart+258. + * the 256th check will be made at strstart + 258. */ do { } while (*++scan == *++match && *++scan == *++match && @@ -1470,7 +1517,7 @@ local uInt longest_match(s, cur_match) *++scan == *++match && *++scan == *++match && scan < strend); - Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); + Assert(scan <= s->window + (unsigned)(s->window_size - 1), "wild scan"); len = MAX_MATCH - (int)(strend - scan); @@ -1490,11 +1537,7 @@ local uInt longest_match(s, cur_match) /* =========================================================================== * Check that the match at match_start is indeed a match. */ -local void check_match(s, start, match, length) - deflate_state *s; - IPos start, match; - int length; -{ +local void check_match(deflate_state *s, IPos start, IPos match, int length) { /* check that the match is indeed a match */ if (zmemcmp(s->window + match, s->window + start, length) != EQUAL) { @@ -1506,7 +1549,7 @@ local void check_match(s, start, match, length) z_error("invalid match"); } if (z_verbose > 1) { - fprintf(stderr,"\\[%d,%d]", start-match, length); + fprintf(stderr,"\\[%d,%d]", start - match, length); do { putc(s->window[start++], stderr); } while (--length != 0); } } @@ -1514,137 +1557,6 @@ local void check_match(s, start, match, length) # define check_match(s, start, match, length) #endif /* ZLIB_DEBUG */ -/* =========================================================================== - * Fill the window when the lookahead becomes insufficient. - * Updates strstart and lookahead. - * - * IN assertion: lookahead < MIN_LOOKAHEAD - * OUT assertions: strstart <= window_size-MIN_LOOKAHEAD - * At least one byte has been read, or avail_in == 0; reads are - * performed for at least two bytes (required for the zip translate_eol - * option -- not supported here). - */ -local void fill_window(s) - deflate_state *s; -{ - unsigned n; - unsigned more; /* Amount of free space at the end of the window. */ - uInt wsize = s->w_size; - - Assert(s->lookahead < MIN_LOOKAHEAD, "already enough lookahead"); - - do { - more = (unsigned)(s->window_size -(ulg)s->lookahead -(ulg)s->strstart); - - /* Deal with !@#$% 64K limit: */ - if (sizeof(int) <= 2) { - if (more == 0 && s->strstart == 0 && s->lookahead == 0) { - more = wsize; - - } else if (more == (unsigned)(-1)) { - /* Very unlikely, but possible on 16 bit machine if - * strstart == 0 && lookahead == 1 (input done a byte at time) - */ - more--; - } - } - - /* If the window is almost full and there is insufficient lookahead, - * move the upper half to the lower one to make room in the upper half. - */ - if (s->strstart >= wsize+MAX_DIST(s)) { - - zmemcpy(s->window, s->window+wsize, (unsigned)wsize - more); - s->match_start -= wsize; - s->strstart -= wsize; /* we now have strstart >= MAX_DIST */ - s->block_start -= (long) wsize; - if (s->insert > s->strstart) - s->insert = s->strstart; - slide_hash(s); - more += wsize; - } - if (s->strm->avail_in == 0) break; - - /* If there was no sliding: - * strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 && - * more == window_size - lookahead - strstart - * => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1) - * => more >= window_size - 2*WSIZE + 2 - * In the BIG_MEM or MMAP case (not yet supported), - * window_size == input_size + MIN_LOOKAHEAD && - * strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD. - * Otherwise, window_size == 2*WSIZE so more >= 2. - * If there was sliding, more >= WSIZE. So in all cases, more >= 2. - */ - Assert(more >= 2, "more < 2"); - - n = read_buf(s->strm, s->window + s->strstart + s->lookahead, more); - s->lookahead += n; - - /* Initialize the hash value now that we have some input: */ - if (s->lookahead + s->insert >= MIN_MATCH) { - uInt str = s->strstart - s->insert; - s->ins_h = s->window[str]; - UPDATE_HASH(s, s->ins_h, s->window[str + 1]); -#if MIN_MATCH != 3 - Call UPDATE_HASH() MIN_MATCH-3 more times -#endif - while (s->insert) { - UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); -#ifndef FASTEST - s->prev[str & s->w_mask] = s->head[s->ins_h]; -#endif - s->head[s->ins_h] = (Pos)str; - str++; - s->insert--; - if (s->lookahead + s->insert < MIN_MATCH) - break; - } - } - /* If the whole input has less than MIN_MATCH bytes, ins_h is garbage, - * but this is not important since only literal bytes will be emitted. - */ - - } while (s->lookahead < MIN_LOOKAHEAD && s->strm->avail_in != 0); - - /* If the WIN_INIT bytes after the end of the current data have never been - * written, then zero those bytes in order to avoid memory check reports of - * the use of uninitialized (or uninitialised as Julian writes) bytes by - * the longest match routines. Update the high water mark for the next - * time through here. WIN_INIT is set to MAX_MATCH since the longest match - * routines allow scanning to strstart + MAX_MATCH, ignoring lookahead. - */ - if (s->high_water < s->window_size) { - ulg curr = s->strstart + (ulg)(s->lookahead); - ulg init; - - if (s->high_water < curr) { - /* Previous high water mark below current data -- zero WIN_INIT - * bytes or up to end of window, whichever is less. - */ - init = s->window_size - curr; - if (init > WIN_INIT) - init = WIN_INIT; - zmemzero(s->window + curr, (unsigned)init); - s->high_water = curr + init; - } - else if (s->high_water < (ulg)curr + WIN_INIT) { - /* High water mark at or above current data, but below current data - * plus WIN_INIT -- zero out to current data plus WIN_INIT, or up - * to end of window, whichever is less. - */ - init = (ulg)curr + WIN_INIT - s->high_water; - if (init > s->window_size - s->high_water) - init = s->window_size - s->high_water; - zmemzero(s->window + s->high_water, (unsigned)init); - s->high_water += init; - } - } - - Assert((ulg)s->strstart <= s->window_size - MIN_LOOKAHEAD, - "not enough room for search"); -} - /* =========================================================================== * Flush the current block, with given end-of-file flag. * IN assertion: strstart is set to the end of the current match. @@ -1685,12 +1597,9 @@ local void fill_window(s) * * deflate_stored() is written to minimize the number of times an input byte is * copied. It is most efficient with large input and output buffers, which - * maximizes the opportunites to have a single copy from next_in to next_out. + * maximizes the opportunities to have a single copy from next_in to next_out. */ -local block_state deflate_stored(s, flush) - deflate_state *s; - int flush; -{ +local block_state deflate_stored(deflate_state *s, int flush) { /* Smallest worthy block size when not flushing or finishing. By default * this is 32K. This can be as small as 507 bytes for memLevel == 1. For * large input and output buffers, the stored block size will be larger. @@ -1874,10 +1783,7 @@ local block_state deflate_stored(s, flush) * new strings in the dictionary only for unmatched strings or for short * matches. It is used only for the fast compression options. */ -local block_state deflate_fast(s, flush) - deflate_state *s; - int flush; -{ +local block_state deflate_fast(deflate_state *s, int flush) { IPos hash_head; /* head of the hash chain */ int bflush; /* set if current block must be flushed */ @@ -1895,7 +1801,7 @@ local block_state deflate_fast(s, flush) if (s->lookahead == 0) break; /* flush the current block */ } - /* Insert the string window[strstart .. strstart+2] in the + /* Insert the string window[strstart .. strstart + 2] in the * dictionary, and set hash_head to the head of the hash chain: */ hash_head = NIL; @@ -1943,7 +1849,7 @@ local block_state deflate_fast(s, flush) s->strstart += s->match_length; s->match_length = 0; s->ins_h = s->window[s->strstart]; - UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]); + UPDATE_HASH(s, s->ins_h, s->window[s->strstart + 1]); #if MIN_MATCH != 3 Call UPDATE_HASH() MIN_MATCH-3 more times #endif @@ -1954,7 +1860,7 @@ local block_state deflate_fast(s, flush) } else { /* No match, output a literal byte */ Tracevv((stderr,"%c", s->window[s->strstart])); - _tr_tally_lit (s, s->window[s->strstart], bflush); + _tr_tally_lit(s, s->window[s->strstart], bflush); s->lookahead--; s->strstart++; } @@ -1976,10 +1882,7 @@ local block_state deflate_fast(s, flush) * evaluation for matches: a match is finally adopted only if there is * no better match at the next window position. */ -local block_state deflate_slow(s, flush) - deflate_state *s; - int flush; -{ +local block_state deflate_slow(deflate_state *s, int flush) { IPos hash_head; /* head of hash chain */ int bflush; /* set if current block must be flushed */ @@ -1998,7 +1901,7 @@ local block_state deflate_slow(s, flush) if (s->lookahead == 0) break; /* flush the current block */ } - /* Insert the string window[strstart .. strstart+2] in the + /* Insert the string window[strstart .. strstart + 2] in the * dictionary, and set hash_head to the head of the hash chain: */ hash_head = NIL; @@ -2040,17 +1943,17 @@ local block_state deflate_slow(s, flush) uInt max_insert = s->strstart + s->lookahead - MIN_MATCH; /* Do not insert strings in hash table beyond this. */ - check_match(s, s->strstart-1, s->prev_match, s->prev_length); + check_match(s, s->strstart - 1, s->prev_match, s->prev_length); - _tr_tally_dist(s, s->strstart -1 - s->prev_match, + _tr_tally_dist(s, s->strstart - 1 - s->prev_match, s->prev_length - MIN_MATCH, bflush); /* Insert in hash table all strings up to the end of the match. - * strstart-1 and strstart are already inserted. If there is not + * strstart - 1 and strstart are already inserted. If there is not * enough lookahead, the last two strings are not inserted in * the hash table. */ - s->lookahead -= s->prev_length-1; + s->lookahead -= s->prev_length - 1; s->prev_length -= 2; do { if (++s->strstart <= max_insert) { @@ -2068,8 +1971,8 @@ local block_state deflate_slow(s, flush) * single literal. If there was a match but the current match * is longer, truncate the previous match to a single literal. */ - Tracevv((stderr,"%c", s->window[s->strstart-1])); - _tr_tally_lit(s, s->window[s->strstart-1], bflush); + Tracevv((stderr,"%c", s->window[s->strstart - 1])); + _tr_tally_lit(s, s->window[s->strstart - 1], bflush); if (bflush) { FLUSH_BLOCK_ONLY(s, 0); } @@ -2087,8 +1990,8 @@ local block_state deflate_slow(s, flush) } Assert (flush != Z_NO_FLUSH, "no flush?"); if (s->match_available) { - Tracevv((stderr,"%c", s->window[s->strstart-1])); - _tr_tally_lit(s, s->window[s->strstart-1], bflush); + Tracevv((stderr,"%c", s->window[s->strstart - 1])); + _tr_tally_lit(s, s->window[s->strstart - 1], bflush); s->match_available = 0; } s->insert = s->strstart < MIN_MATCH-1 ? s->strstart : MIN_MATCH-1; @@ -2107,10 +2010,7 @@ local block_state deflate_slow(s, flush) * one. Do not maintain a hash table. (It will be regenerated if this run of * deflate switches away from Z_RLE.) */ -local block_state deflate_rle(s, flush) - deflate_state *s; - int flush; -{ +local block_state deflate_rle(deflate_state *s, int flush) { int bflush; /* set if current block must be flushed */ uInt prev; /* byte at distance one to match */ Bytef *scan, *strend; /* scan goes up to strend for length of run */ @@ -2145,7 +2045,8 @@ local block_state deflate_rle(s, flush) if (s->match_length > s->lookahead) s->match_length = s->lookahead; } - Assert(scan <= s->window+(uInt)(s->window_size-1), "wild scan"); + Assert(scan <= s->window + (uInt)(s->window_size - 1), + "wild scan"); } /* Emit match if have run of MIN_MATCH or longer, else emit literal */ @@ -2160,7 +2061,7 @@ local block_state deflate_rle(s, flush) } else { /* No match, output a literal byte */ Tracevv((stderr,"%c", s->window[s->strstart])); - _tr_tally_lit (s, s->window[s->strstart], bflush); + _tr_tally_lit(s, s->window[s->strstart], bflush); s->lookahead--; s->strstart++; } @@ -2180,10 +2081,7 @@ local block_state deflate_rle(s, flush) * For Z_HUFFMAN_ONLY, do not look for matches. Do not maintain a hash table. * (It will be regenerated if this run of deflate switches away from Huffman.) */ -local block_state deflate_huff(s, flush) - deflate_state *s; - int flush; -{ +local block_state deflate_huff(deflate_state *s, int flush) { int bflush; /* set if current block must be flushed */ for (;;) { @@ -2200,7 +2098,7 @@ local block_state deflate_huff(s, flush) /* Output a literal byte */ s->match_length = 0; Tracevv((stderr,"%c", s->window[s->strstart])); - _tr_tally_lit (s, s->window[s->strstart], bflush); + _tr_tally_lit(s, s->window[s->strstart], bflush); s->lookahead--; s->strstart++; if (bflush) FLUSH_BLOCK(s, 0); diff --git a/deps/zlib/deflate.h b/deps/zlib/deflate.h index 1a06cd5f25d..8696791429f 100644 --- a/deps/zlib/deflate.h +++ b/deps/zlib/deflate.h @@ -291,14 +291,14 @@ typedef struct internal_state { memory checker errors from longest match routines */ /* in trees.c */ -void ZLIB_INTERNAL _tr_init OF((deflate_state *s)); -int ZLIB_INTERNAL _tr_tally OF((deflate_state *s, unsigned dist, unsigned lc)); -void ZLIB_INTERNAL _tr_flush_block OF((deflate_state *s, charf *buf, - ulg stored_len, int last)); -void ZLIB_INTERNAL _tr_flush_bits OF((deflate_state *s)); -void ZLIB_INTERNAL _tr_align OF((deflate_state *s)); -void ZLIB_INTERNAL _tr_stored_block OF((deflate_state *s, charf *buf, - ulg stored_len, int last)); +void ZLIB_INTERNAL _tr_init(deflate_state *s); +int ZLIB_INTERNAL _tr_tally(deflate_state *s, unsigned dist, unsigned lc); +void ZLIB_INTERNAL _tr_flush_block(deflate_state *s, charf *buf, + ulg stored_len, int last); +void ZLIB_INTERNAL _tr_flush_bits(deflate_state *s); +void ZLIB_INTERNAL _tr_align(deflate_state *s); +void ZLIB_INTERNAL _tr_stored_block(deflate_state *s, charf *buf, + ulg stored_len, int last); #define d_code(dist) \ ((dist) < 256 ? _dist_code[dist] : _dist_code[256+((dist)>>7)]) diff --git a/deps/zlib/gzguts.h b/deps/zlib/gzguts.h index 57faf37165a..f9375047e8c 100644 --- a/deps/zlib/gzguts.h +++ b/deps/zlib/gzguts.h @@ -7,9 +7,8 @@ # ifndef _LARGEFILE_SOURCE # define _LARGEFILE_SOURCE 1 # endif -# ifdef _FILE_OFFSET_BITS -# undef _FILE_OFFSET_BITS -# endif +# undef _FILE_OFFSET_BITS +# undef _TIME_BITS #endif #ifdef HAVE_HIDDEN @@ -119,8 +118,8 @@ /* gz* functions always use library allocation functions */ #ifndef STDC - extern voidp malloc OF((uInt size)); - extern void free OF((voidpf ptr)); + extern voidp malloc(uInt size); + extern void free(voidpf ptr); #endif /* get errno and strerror definition */ @@ -138,10 +137,10 @@ /* provide prototypes for these when building zlib without LFS */ #if !defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0 - ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *)); - ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int)); - ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile)); - ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile)); + ZEXTERN gzFile ZEXPORT gzopen64(const char *, const char *); + ZEXTERN z_off64_t ZEXPORT gzseek64(gzFile, z_off64_t, int); + ZEXTERN z_off64_t ZEXPORT gztell64(gzFile); + ZEXTERN z_off64_t ZEXPORT gzoffset64(gzFile); #endif /* default memLevel */ @@ -203,9 +202,9 @@ typedef struct { typedef gz_state FAR *gz_statep; /* shared functions */ -void ZLIB_INTERNAL gz_error OF((gz_statep, int, const char *)); +void ZLIB_INTERNAL gz_error(gz_statep, int, const char *); #if defined UNDER_CE -char ZLIB_INTERNAL *gz_strwinerror OF((DWORD error)); +char ZLIB_INTERNAL *gz_strwinerror(DWORD error); #endif /* GT_OFF(x), where x is an unsigned value, is true if x > maximum z_off64_t @@ -214,6 +213,6 @@ char ZLIB_INTERNAL *gz_strwinerror OF((DWORD error)); #ifdef INT_MAX # define GT_OFF(x) (sizeof(int) == sizeof(z_off64_t) && (x) > INT_MAX) #else -unsigned ZLIB_INTERNAL gz_intmax OF((void)); +unsigned ZLIB_INTERNAL gz_intmax(void); # define GT_OFF(x) (sizeof(int) == sizeof(z_off64_t) && (x) > gz_intmax()) #endif diff --git a/deps/zlib/infback.c b/deps/zlib/infback.c index a390c58e816..e7b25b307a3 100644 --- a/deps/zlib/infback.c +++ b/deps/zlib/infback.c @@ -15,9 +15,6 @@ #include "inflate.h" #include "inffast.h" -/* function prototypes */ -local void fixedtables OF((struct inflate_state FAR *state)); - /* strm provides memory allocation functions in zalloc and zfree, or Z_NULL to use the library memory allocation functions. @@ -25,13 +22,9 @@ local void fixedtables OF((struct inflate_state FAR *state)); windowBits is in the range 8..15, and window is a user-supplied window and output buffer that is 2**windowBits bytes. */ -int ZEXPORT inflateBackInit_(strm, windowBits, window, version, stream_size) -z_streamp strm; -int windowBits; -unsigned char FAR *window; -const char *version; -int stream_size; -{ +int ZEXPORT inflateBackInit_(z_streamp strm, int windowBits, + unsigned char FAR *window, const char *version, + int stream_size) { struct inflate_state FAR *state; if (version == Z_NULL || version[0] != ZLIB_VERSION[0] || @@ -66,6 +59,7 @@ int stream_size; state->window = window; state->wnext = 0; state->whave = 0; + state->sane = 1; return Z_OK; } @@ -79,9 +73,7 @@ int stream_size; used for threaded applications, since the rewriting of the tables and virgin may not be thread-safe. */ -local void fixedtables(state) -struct inflate_state FAR *state; -{ +local void fixedtables(struct inflate_state FAR *state) { #ifdef BUILDFIXED static int virgin = 1; static code *lenfix, *distfix; @@ -247,13 +239,8 @@ struct inflate_state FAR *state; inflateBack() can also return Z_STREAM_ERROR if the input parameters are not correct, i.e. strm is Z_NULL or the state was not initialized. */ -int ZEXPORT inflateBack(strm, in, in_desc, out, out_desc) -z_streamp strm; -in_func in; -void FAR *in_desc; -out_func out; -void FAR *out_desc; -{ +int ZEXPORT inflateBack(z_streamp strm, in_func in, void FAR *in_desc, + out_func out, void FAR *out_desc) { struct inflate_state FAR *state; z_const unsigned char FAR *next; /* next input */ unsigned char FAR *put; /* next output */ @@ -605,33 +592,33 @@ void FAR *out_desc; break; case DONE: - /* inflate stream terminated properly -- write leftover output */ + /* inflate stream terminated properly */ ret = Z_STREAM_END; - if (left < state->wsize) { - if (out(out_desc, state->window, state->wsize - left)) - ret = Z_BUF_ERROR; - } goto inf_leave; case BAD: ret = Z_DATA_ERROR; goto inf_leave; - default: /* can't happen, but makes compilers happy */ + default: + /* can't happen, but makes compilers happy */ ret = Z_STREAM_ERROR; goto inf_leave; } - /* Return unused input */ + /* Write leftover output and return unused input */ inf_leave: + if (left < state->wsize) { + if (out(out_desc, state->window, state->wsize - left) && + ret == Z_STREAM_END) + ret = Z_BUF_ERROR; + } strm->next_in = next; strm->avail_in = have; return ret; } -int ZEXPORT inflateBackEnd(strm) -z_streamp strm; -{ +int ZEXPORT inflateBackEnd(z_streamp strm) { if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0) return Z_STREAM_ERROR; ZFREE(strm, strm->state); diff --git a/deps/zlib/inffast.c b/deps/zlib/inffast.c index 1fec7f363fa..9354676e786 100644 --- a/deps/zlib/inffast.c +++ b/deps/zlib/inffast.c @@ -47,10 +47,7 @@ requires strm->avail_out >= 258 for each loop to avoid checking for output space. */ -void ZLIB_INTERNAL inflate_fast(strm, start) -z_streamp strm; -unsigned start; /* inflate()'s starting value for strm->avail_out */ -{ +void ZLIB_INTERNAL inflate_fast(z_streamp strm, unsigned start) { struct inflate_state FAR *state; z_const unsigned char FAR *in; /* local strm->next_in */ z_const unsigned char FAR *last; /* have enough input while in < last */ diff --git a/deps/zlib/inffast.h b/deps/zlib/inffast.h index e5c1aa4ca8c..49c6d156c5c 100644 --- a/deps/zlib/inffast.h +++ b/deps/zlib/inffast.h @@ -8,4 +8,4 @@ subject to change. Applications should only use zlib.h. */ -void ZLIB_INTERNAL inflate_fast OF((z_streamp strm, unsigned start)); +void ZLIB_INTERNAL inflate_fast(z_streamp strm, unsigned start); diff --git a/deps/zlib/inflate.c b/deps/zlib/inflate.c index 7be8c63662a..b0757a9b249 100644 --- a/deps/zlib/inflate.c +++ b/deps/zlib/inflate.c @@ -91,20 +91,7 @@ # endif #endif -/* function prototypes */ -local int inflateStateCheck OF((z_streamp strm)); -local void fixedtables OF((struct inflate_state FAR *state)); -local int updatewindow OF((z_streamp strm, const unsigned char FAR *end, - unsigned copy)); -#ifdef BUILDFIXED - void makefixed OF((void)); -#endif -local unsigned syncsearch OF((unsigned FAR *have, const unsigned char FAR *buf, - unsigned len)); - -local int inflateStateCheck(strm) -z_streamp strm; -{ +local int inflateStateCheck(z_streamp strm) { struct inflate_state FAR *state; if (strm == Z_NULL || strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0) @@ -116,9 +103,7 @@ z_streamp strm; return 0; } -int ZEXPORT inflateResetKeep(strm) -z_streamp strm; -{ +int ZEXPORT inflateResetKeep(z_streamp strm) { struct inflate_state FAR *state; if (inflateStateCheck(strm)) return Z_STREAM_ERROR; @@ -142,9 +127,7 @@ z_streamp strm; return Z_OK; } -int ZEXPORT inflateReset(strm) -z_streamp strm; -{ +int ZEXPORT inflateReset(z_streamp strm) { struct inflate_state FAR *state; if (inflateStateCheck(strm)) return Z_STREAM_ERROR; @@ -155,10 +138,7 @@ z_streamp strm; return inflateResetKeep(strm); } -int ZEXPORT inflateReset2(strm, windowBits) -z_streamp strm; -int windowBits; -{ +int ZEXPORT inflateReset2(z_streamp strm, int windowBits) { int wrap; struct inflate_state FAR *state; @@ -168,6 +148,8 @@ int windowBits; /* extract wrap request from windowBits parameter */ if (windowBits < 0) { + if (windowBits < -15) + return Z_STREAM_ERROR; wrap = 0; windowBits = -windowBits; } @@ -193,12 +175,8 @@ int windowBits; return inflateReset(strm); } -int ZEXPORT inflateInit2_(strm, windowBits, version, stream_size) -z_streamp strm; -int windowBits; -const char *version; -int stream_size; -{ +int ZEXPORT inflateInit2_(z_streamp strm, int windowBits, + const char *version, int stream_size) { int ret; struct inflate_state FAR *state; @@ -237,22 +215,17 @@ int stream_size; return ret; } -int ZEXPORT inflateInit_(strm, version, stream_size) -z_streamp strm; -const char *version; -int stream_size; -{ +int ZEXPORT inflateInit_(z_streamp strm, const char *version, + int stream_size) { return inflateInit2_(strm, DEF_WBITS, version, stream_size); } -int ZEXPORT inflatePrime(strm, bits, value) -z_streamp strm; -int bits; -int value; -{ +int ZEXPORT inflatePrime(z_streamp strm, int bits, int value) { struct inflate_state FAR *state; if (inflateStateCheck(strm)) return Z_STREAM_ERROR; + if (bits == 0) + return Z_OK; state = (struct inflate_state FAR *)strm->state; if (bits < 0) { state->hold = 0; @@ -276,9 +249,7 @@ int value; used for threaded applications, since the rewriting of the tables and virgin may not be thread-safe. */ -local void fixedtables(state) -struct inflate_state FAR *state; -{ +local void fixedtables(struct inflate_state FAR *state) { #ifdef BUILDFIXED static int virgin = 1; static code *lenfix, *distfix; @@ -340,7 +311,7 @@ struct inflate_state FAR *state; a.out > inffixed.h */ -void makefixed() +void makefixed(void) { unsigned low, size; struct inflate_state state; @@ -394,11 +365,7 @@ void makefixed() output will fall in the output data, making match copies simpler and faster. The advantage may be dependent on the size of the processor's data caches. */ -local int updatewindow(strm, end, copy) -z_streamp strm; -const Bytef *end; -unsigned copy; -{ +local int updatewindow(z_streamp strm, const Bytef *end, unsigned copy) { struct inflate_state FAR *state; unsigned dist; @@ -620,10 +587,7 @@ unsigned copy; will return Z_BUF_ERROR if it has not reached the end of the stream. */ -int ZEXPORT inflate(strm, flush) -z_streamp strm; -int flush; -{ +int ZEXPORT inflate(z_streamp strm, int flush) { struct inflate_state FAR *state; z_const unsigned char FAR *next; /* next input */ unsigned char FAR *put; /* next output */ @@ -764,8 +728,9 @@ int flush; if (copy > have) copy = have; if (copy) { if (state->head != Z_NULL && - state->head->extra != Z_NULL) { - len = state->head->extra_len - state->length; + state->head->extra != Z_NULL && + (len = state->head->extra_len - state->length) < + state->head->extra_max) { zmemcpy(state->head->extra + len, next, len + copy > state->head->extra_max ? state->head->extra_max - len : copy); @@ -1298,9 +1263,7 @@ int flush; return ret; } -int ZEXPORT inflateEnd(strm) -z_streamp strm; -{ +int ZEXPORT inflateEnd(z_streamp strm) { struct inflate_state FAR *state; if (inflateStateCheck(strm)) return Z_STREAM_ERROR; @@ -1312,11 +1275,8 @@ z_streamp strm; return Z_OK; } -int ZEXPORT inflateGetDictionary(strm, dictionary, dictLength) -z_streamp strm; -Bytef *dictionary; -uInt *dictLength; -{ +int ZEXPORT inflateGetDictionary(z_streamp strm, Bytef *dictionary, + uInt *dictLength) { struct inflate_state FAR *state; /* check state */ @@ -1335,11 +1295,8 @@ uInt *dictLength; return Z_OK; } -int ZEXPORT inflateSetDictionary(strm, dictionary, dictLength) -z_streamp strm; -const Bytef *dictionary; -uInt dictLength; -{ +int ZEXPORT inflateSetDictionary(z_streamp strm, const Bytef *dictionary, + uInt dictLength) { struct inflate_state FAR *state; unsigned long dictid; int ret; @@ -1370,10 +1327,7 @@ uInt dictLength; return Z_OK; } -int ZEXPORT inflateGetHeader(strm, head) -z_streamp strm; -gz_headerp head; -{ +int ZEXPORT inflateGetHeader(z_streamp strm, gz_headerp head) { struct inflate_state FAR *state; /* check state */ @@ -1398,11 +1352,8 @@ gz_headerp head; called again with more data and the *have state. *have is initialized to zero for the first call. */ -local unsigned syncsearch(have, buf, len) -unsigned FAR *have; -const unsigned char FAR *buf; -unsigned len; -{ +local unsigned syncsearch(unsigned FAR *have, const unsigned char FAR *buf, + unsigned len) { unsigned got; unsigned next; @@ -1421,9 +1372,7 @@ unsigned len; return next; } -int ZEXPORT inflateSync(strm) -z_streamp strm; -{ +int ZEXPORT inflateSync(z_streamp strm) { unsigned len; /* number of bytes to look at or looked at */ int flags; /* temporary to save header status */ unsigned long in, out; /* temporary to save total_in and total_out */ @@ -1479,9 +1428,7 @@ z_streamp strm; block. When decompressing, PPP checks that at the end of input packet, inflate is waiting for these length bytes. */ -int ZEXPORT inflateSyncPoint(strm) -z_streamp strm; -{ +int ZEXPORT inflateSyncPoint(z_streamp strm) { struct inflate_state FAR *state; if (inflateStateCheck(strm)) return Z_STREAM_ERROR; @@ -1489,10 +1436,7 @@ z_streamp strm; return state->mode == STORED && state->bits == 0; } -int ZEXPORT inflateCopy(dest, source) -z_streamp dest; -z_streamp source; -{ +int ZEXPORT inflateCopy(z_streamp dest, z_streamp source) { struct inflate_state FAR *state; struct inflate_state FAR *copy; unsigned char FAR *window; @@ -1536,10 +1480,7 @@ z_streamp source; return Z_OK; } -int ZEXPORT inflateUndermine(strm, subvert) -z_streamp strm; -int subvert; -{ +int ZEXPORT inflateUndermine(z_streamp strm, int subvert) { struct inflate_state FAR *state; if (inflateStateCheck(strm)) return Z_STREAM_ERROR; @@ -1554,10 +1495,7 @@ int subvert; #endif } -int ZEXPORT inflateValidate(strm, check) -z_streamp strm; -int check; -{ +int ZEXPORT inflateValidate(z_streamp strm, int check) { struct inflate_state FAR *state; if (inflateStateCheck(strm)) return Z_STREAM_ERROR; @@ -1569,9 +1507,7 @@ int check; return Z_OK; } -long ZEXPORT inflateMark(strm) -z_streamp strm; -{ +long ZEXPORT inflateMark(z_streamp strm) { struct inflate_state FAR *state; if (inflateStateCheck(strm)) @@ -1582,9 +1518,7 @@ z_streamp strm; (state->mode == MATCH ? state->was - state->length : 0)); } -unsigned long ZEXPORT inflateCodesUsed(strm) -z_streamp strm; -{ +unsigned long ZEXPORT inflateCodesUsed(z_streamp strm) { struct inflate_state FAR *state; if (inflateStateCheck(strm)) return (unsigned long)-1; state = (struct inflate_state FAR *)strm->state; diff --git a/deps/zlib/inftrees.c b/deps/zlib/inftrees.c index 09462a740b1..8a208c2daa8 100644 --- a/deps/zlib/inftrees.c +++ b/deps/zlib/inftrees.c @@ -1,5 +1,5 @@ /* inftrees.c -- generate Huffman trees for efficient decoding - * Copyright (C) 1995-2022 Mark Adler + * Copyright (C) 1995-2023 Mark Adler * For conditions of distribution and use, see copyright notice in zlib.h */ @@ -9,7 +9,7 @@ #define MAXBITS 15 const char inflate_copyright[] = - " inflate 1.2.12 Copyright 1995-2022 Mark Adler "; + " inflate 1.3 Copyright 1995-2023 Mark Adler "; /* If you use the zlib library in a product, an acknowledgment is welcome in the documentation of your product. If for some reason you cannot @@ -29,14 +29,9 @@ const char inflate_copyright[] = table index bits. It will differ if the request is greater than the longest code or if it is less than the shortest code. */ -int ZLIB_INTERNAL inflate_table(type, lens, codes, table, bits, work) -codetype type; -unsigned short FAR *lens; -unsigned codes; -code FAR * FAR *table; -unsigned FAR *bits; -unsigned short FAR *work; -{ +int ZLIB_INTERNAL inflate_table(codetype type, unsigned short FAR *lens, + unsigned codes, code FAR * FAR *table, + unsigned FAR *bits, unsigned short FAR *work) { unsigned len; /* a code's length in bits */ unsigned sym; /* index of code symbols */ unsigned min, max; /* minimum and maximum code lengths */ @@ -62,7 +57,7 @@ unsigned short FAR *work; 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0}; static const unsigned short lext[31] = { /* Length codes 257..285 extra */ 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18, - 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 199, 202}; + 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 198, 203}; static const unsigned short dbase[32] = { /* Distance codes 0..29 base */ 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, diff --git a/deps/zlib/inftrees.h b/deps/zlib/inftrees.h index baa53a0b1a1..a10712d8cb5 100644 --- a/deps/zlib/inftrees.h +++ b/deps/zlib/inftrees.h @@ -38,7 +38,7 @@ typedef struct { /* Maximum size of the dynamic table. The maximum number of code structures is 1444, which is the sum of 852 for literal/length codes and 592 for distance codes. These values were found by exhaustive searches using the program - examples/enough.c found in the zlib distribtution. The arguments to that + examples/enough.c found in the zlib distribution. The arguments to that program are the number of symbols, the initial root table size, and the maximum bit length of a code. "enough 286 9 15" for literal/length codes returns returns 852, and "enough 30 6 15" for distance codes returns 592. @@ -57,6 +57,6 @@ typedef enum { DISTS } codetype; -int ZLIB_INTERNAL inflate_table OF((codetype type, unsigned short FAR *lens, - unsigned codes, code FAR * FAR *table, - unsigned FAR *bits, unsigned short FAR *work)); +int ZLIB_INTERNAL inflate_table(codetype type, unsigned short FAR *lens, + unsigned codes, code FAR * FAR *table, + unsigned FAR *bits, unsigned short FAR *work); diff --git a/deps/zlib/trees.c b/deps/zlib/trees.c index 8b438cce4f3..8dbdc40bacc 100644 --- a/deps/zlib/trees.c +++ b/deps/zlib/trees.c @@ -122,39 +122,116 @@ struct static_tree_desc_s { int max_length; /* max bit length for the codes */ }; -local const static_tree_desc static_l_desc = +#ifdef NO_INIT_GLOBAL_POINTERS +# define TCONST +#else +# define TCONST const +#endif + +local TCONST static_tree_desc static_l_desc = {static_ltree, extra_lbits, LITERALS+1, L_CODES, MAX_BITS}; -local const static_tree_desc static_d_desc = +local TCONST static_tree_desc static_d_desc = {static_dtree, extra_dbits, 0, D_CODES, MAX_BITS}; -local const static_tree_desc static_bl_desc = +local TCONST static_tree_desc static_bl_desc = {(const ct_data *)0, extra_blbits, 0, BL_CODES, MAX_BL_BITS}; /* =========================================================================== - * Local (static) routines in this file. + * Output a short LSB first on the stream. + * IN assertion: there is enough room in pendingBuf. */ +#define put_short(s, w) { \ + put_byte(s, (uch)((w) & 0xff)); \ + put_byte(s, (uch)((ush)(w) >> 8)); \ +} -local void tr_static_init OF((void)); -local void init_block OF((deflate_state *s)); -local void pqdownheap OF((deflate_state *s, ct_data *tree, int k)); -local void gen_bitlen OF((deflate_state *s, tree_desc *desc)); -local void gen_codes OF((ct_data *tree, int max_code, ushf *bl_count)); -local void build_tree OF((deflate_state *s, tree_desc *desc)); -local void scan_tree OF((deflate_state *s, ct_data *tree, int max_code)); -local void send_tree OF((deflate_state *s, ct_data *tree, int max_code)); -local int build_bl_tree OF((deflate_state *s)); -local void send_all_trees OF((deflate_state *s, int lcodes, int dcodes, - int blcodes)); -local void compress_block OF((deflate_state *s, const ct_data *ltree, - const ct_data *dtree)); -local int detect_data_type OF((deflate_state *s)); -local unsigned bi_reverse OF((unsigned code, int len)); -local void bi_windup OF((deflate_state *s)); -local void bi_flush OF((deflate_state *s)); +/* =========================================================================== + * Reverse the first len bits of a code, using straightforward code (a faster + * method would use a table) + * IN assertion: 1 <= len <= 15 + */ +local unsigned bi_reverse(unsigned code, int len) { + register unsigned res = 0; + do { + res |= code & 1; + code >>= 1, res <<= 1; + } while (--len > 0); + return res >> 1; +} + +/* =========================================================================== + * Flush the bit buffer, keeping at most 7 bits in it. + */ +local void bi_flush(deflate_state *s) { + if (s->bi_valid == 16) { + put_short(s, s->bi_buf); + s->bi_buf = 0; + s->bi_valid = 0; + } else if (s->bi_valid >= 8) { + put_byte(s, (Byte)s->bi_buf); + s->bi_buf >>= 8; + s->bi_valid -= 8; + } +} + +/* =========================================================================== + * Flush the bit buffer and align the output on a byte boundary + */ +local void bi_windup(deflate_state *s) { + if (s->bi_valid > 8) { + put_short(s, s->bi_buf); + } else if (s->bi_valid > 0) { + put_byte(s, (Byte)s->bi_buf); + } + s->bi_buf = 0; + s->bi_valid = 0; +#ifdef ZLIB_DEBUG + s->bits_sent = (s->bits_sent + 7) & ~7; +#endif +} + +/* =========================================================================== + * Generate the codes for a given tree and bit counts (which need not be + * optimal). + * IN assertion: the array bl_count contains the bit length statistics for + * the given tree and the field len is set for all tree elements. + * OUT assertion: the field code is set for all tree elements of non + * zero code length. + */ +local void gen_codes(ct_data *tree, int max_code, ushf *bl_count) { + ush next_code[MAX_BITS+1]; /* next code value for each bit length */ + unsigned code = 0; /* running code value */ + int bits; /* bit index */ + int n; /* code index */ + + /* The distribution counts are first used to generate the code values + * without bit reversal. + */ + for (bits = 1; bits <= MAX_BITS; bits++) { + code = (code + bl_count[bits - 1]) << 1; + next_code[bits] = (ush)code; + } + /* Check that the bit counts in bl_count are consistent. The last code + * must be all ones. + */ + Assert (code + bl_count[MAX_BITS] - 1 == (1 << MAX_BITS) - 1, + "inconsistent bit counts"); + Tracev((stderr,"\ngen_codes: max_code %d ", max_code)); + + for (n = 0; n <= max_code; n++) { + int len = tree[n].Len; + if (len == 0) continue; + /* Now reverse the bits */ + tree[n].Code = (ush)bi_reverse(next_code[len]++, len); + + Tracecv(tree != static_ltree, (stderr,"\nn %3d %c l %2d c %4x (%x) ", + n, (isgraph(n) ? n : ' '), len, tree[n].Code, next_code[len] - 1)); + } +} #ifdef GEN_TREES_H -local void gen_trees_header OF((void)); +local void gen_trees_header(void); #endif #ifndef ZLIB_DEBUG @@ -167,33 +244,18 @@ local void gen_trees_header OF((void)); send_bits(s, tree[c].Code, tree[c].Len); } #endif -/* =========================================================================== - * Output a short LSB first on the stream. - * IN assertion: there is enough room in pendingBuf. - */ -#define put_short(s, w) { \ - put_byte(s, (uch)((w) & 0xff)); \ - put_byte(s, (uch)((ush)(w) >> 8)); \ -} - /* =========================================================================== * Send a value on a given number of bits. * IN assertion: length <= 16 and value fits in length bits. */ #ifdef ZLIB_DEBUG -local void send_bits OF((deflate_state *s, int value, int length)); - -local void send_bits(s, value, length) - deflate_state *s; - int value; /* value to send */ - int length; /* number of bits */ -{ +local void send_bits(deflate_state *s, int value, int length) { Tracevv((stderr," l %2d v %4x ", length, value)); Assert(length > 0 && length <= 15, "invalid length"); s->bits_sent += (ulg)length; /* If not enough room in bi_buf, use (valid) bits from bi_buf and - * (16 - bi_valid) bits from value, leaving (width - (16-bi_valid)) + * (16 - bi_valid) bits from value, leaving (width - (16 - bi_valid)) * unused bits in value. */ if (s->bi_valid > (int)Buf_size - length) { @@ -229,8 +291,7 @@ local void send_bits(s, value, length) /* =========================================================================== * Initialize the various 'constant' tables. */ -local void tr_static_init() -{ +local void tr_static_init(void) { #if defined(GEN_TREES_H) || !defined(STDC) static int static_init_done = 0; int n; /* iterates over tree elements */ @@ -256,7 +317,7 @@ local void tr_static_init() length = 0; for (code = 0; code < LENGTH_CODES-1; code++) { base_length[code] = length; - for (n = 0; n < (1< dist code (0..29) */ dist = 0; for (code = 0 ; code < 16; code++) { base_dist[code] = dist; - for (n = 0; n < (1<>= 7; /* from now on, all distances are divided by 128 */ for ( ; code < D_CODES; code++) { base_dist[code] = dist << 7; - for (n = 0; n < (1<<(extra_dbits[code]-7)); n++) { + for (n = 0; n < (1 << (extra_dbits[code] - 7)); n++) { _dist_code[256 + dist++] = (uch)code; } } - Assert (dist == 256, "tr_static_init: 256+dist != 512"); + Assert (dist == 256, "tr_static_init: 256 + dist != 512"); /* Construct the codes of the static literal tree */ for (bits = 0; bits <= MAX_BITS; bits++) bl_count[bits] = 0; @@ -312,7 +373,7 @@ local void tr_static_init() } /* =========================================================================== - * Genererate the file trees.h describing the static trees. + * Generate the file trees.h describing the static trees. */ #ifdef GEN_TREES_H # ifndef ZLIB_DEBUG @@ -321,10 +382,9 @@ local void tr_static_init() # define SEPARATOR(i, last, width) \ ((i) == (last)? "\n};\n\n" : \ - ((i) % (width) == (width)-1 ? ",\n" : ", ")) + ((i) % (width) == (width) - 1 ? ",\n" : ", ")) -void gen_trees_header() -{ +void gen_trees_header(void) { FILE *header = fopen("trees.h", "w"); int i; @@ -373,12 +433,26 @@ void gen_trees_header() } #endif /* GEN_TREES_H */ +/* =========================================================================== + * Initialize a new block. + */ +local void init_block(deflate_state *s) { + int n; /* iterates over tree elements */ + + /* Initialize the trees. */ + for (n = 0; n < L_CODES; n++) s->dyn_ltree[n].Freq = 0; + for (n = 0; n < D_CODES; n++) s->dyn_dtree[n].Freq = 0; + for (n = 0; n < BL_CODES; n++) s->bl_tree[n].Freq = 0; + + s->dyn_ltree[END_BLOCK].Freq = 1; + s->opt_len = s->static_len = 0L; + s->sym_next = s->matches = 0; +} + /* =========================================================================== * Initialize the tree data structures for a new zlib stream. */ -void ZLIB_INTERNAL _tr_init(s) - deflate_state *s; -{ +void ZLIB_INTERNAL _tr_init(deflate_state *s) { tr_static_init(); s->l_desc.dyn_tree = s->dyn_ltree; @@ -401,24 +475,6 @@ void ZLIB_INTERNAL _tr_init(s) init_block(s); } -/* =========================================================================== - * Initialize a new block. - */ -local void init_block(s) - deflate_state *s; -{ - int n; /* iterates over tree elements */ - - /* Initialize the trees. */ - for (n = 0; n < L_CODES; n++) s->dyn_ltree[n].Freq = 0; - for (n = 0; n < D_CODES; n++) s->dyn_dtree[n].Freq = 0; - for (n = 0; n < BL_CODES; n++) s->bl_tree[n].Freq = 0; - - s->dyn_ltree[END_BLOCK].Freq = 1; - s->opt_len = s->static_len = 0L; - s->sym_next = s->matches = 0; -} - #define SMALLEST 1 /* Index within the heap array of least frequent node in the Huffman tree */ @@ -448,17 +504,13 @@ local void init_block(s) * when the heap property is re-established (each father smaller than its * two sons). */ -local void pqdownheap(s, tree, k) - deflate_state *s; - ct_data *tree; /* the tree to restore */ - int k; /* node to move down */ -{ +local void pqdownheap(deflate_state *s, ct_data *tree, int k) { int v = s->heap[k]; int j = k << 1; /* left son of k */ while (j <= s->heap_len) { /* Set j to the smallest of the two sons: */ if (j < s->heap_len && - smaller(tree, s->heap[j+1], s->heap[j], s->depth)) { + smaller(tree, s->heap[j + 1], s->heap[j], s->depth)) { j++; } /* Exit if v is smaller than both sons */ @@ -483,10 +535,7 @@ local void pqdownheap(s, tree, k) * The length opt_len is updated; static_len is also updated if stree is * not null. */ -local void gen_bitlen(s, desc) - deflate_state *s; - tree_desc *desc; /* the tree descriptor */ -{ +local void gen_bitlen(deflate_state *s, tree_desc *desc) { ct_data *tree = desc->dyn_tree; int max_code = desc->max_code; const ct_data *stree = desc->stat_desc->static_tree; @@ -507,7 +556,7 @@ local void gen_bitlen(s, desc) */ tree[s->heap[s->heap_max]].Len = 0; /* root of the heap */ - for (h = s->heap_max+1; h < HEAP_SIZE; h++) { + for (h = s->heap_max + 1; h < HEAP_SIZE; h++) { n = s->heap[h]; bits = tree[tree[n].Dad].Len + 1; if (bits > max_length) bits = max_length, overflow++; @@ -518,7 +567,7 @@ local void gen_bitlen(s, desc) s->bl_count[bits]++; xbits = 0; - if (n >= base) xbits = extra[n-base]; + if (n >= base) xbits = extra[n - base]; f = tree[n].Freq; s->opt_len += (ulg)f * (unsigned)(bits + xbits); if (stree) s->static_len += (ulg)f * (unsigned)(stree[n].Len + xbits); @@ -530,10 +579,10 @@ local void gen_bitlen(s, desc) /* Find the first bit length which could increase: */ do { - bits = max_length-1; + bits = max_length - 1; while (s->bl_count[bits] == 0) bits--; - s->bl_count[bits]--; /* move one leaf down the tree */ - s->bl_count[bits+1] += 2; /* move one overflow item as its brother */ + s->bl_count[bits]--; /* move one leaf down the tree */ + s->bl_count[bits + 1] += 2; /* move one overflow item as its brother */ s->bl_count[max_length]--; /* The brother of the overflow item also moves one step up, * but this does not affect bl_count[max_length] @@ -561,48 +610,9 @@ local void gen_bitlen(s, desc) } } -/* =========================================================================== - * Generate the codes for a given tree and bit counts (which need not be - * optimal). - * IN assertion: the array bl_count contains the bit length statistics for - * the given tree and the field len is set for all tree elements. - * OUT assertion: the field code is set for all tree elements of non - * zero code length. - */ -local void gen_codes (tree, max_code, bl_count) - ct_data *tree; /* the tree to decorate */ - int max_code; /* largest code with non zero frequency */ - ushf *bl_count; /* number of codes at each bit length */ -{ - ush next_code[MAX_BITS+1]; /* next code value for each bit length */ - unsigned code = 0; /* running code value */ - int bits; /* bit index */ - int n; /* code index */ - - /* The distribution counts are first used to generate the code values - * without bit reversal. - */ - for (bits = 1; bits <= MAX_BITS; bits++) { - code = (code + bl_count[bits-1]) << 1; - next_code[bits] = (ush)code; - } - /* Check that the bit counts in bl_count are consistent. The last code - * must be all ones. - */ - Assert (code + bl_count[MAX_BITS]-1 == (1< +#endif /* =========================================================================== * Construct one Huffman tree and assigns the code bit strings and lengths. @@ -612,10 +622,7 @@ local void gen_codes (tree, max_code, bl_count) * and corresponding code. The length opt_len is updated; static_len is * also updated if stree is not null. The field max_code is set. */ -local void build_tree(s, desc) - deflate_state *s; - tree_desc *desc; /* the tree descriptor */ -{ +local void build_tree(deflate_state *s, tree_desc *desc) { ct_data *tree = desc->dyn_tree; const ct_data *stree = desc->stat_desc->static_tree; int elems = desc->stat_desc->elems; @@ -624,7 +631,7 @@ local void build_tree(s, desc) int node; /* new node being created */ /* Construct the initial heap, with least frequent element in - * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1]. + * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n + 1]. * heap[0] is not used. */ s->heap_len = 0, s->heap_max = HEAP_SIZE; @@ -652,7 +659,7 @@ local void build_tree(s, desc) } desc->max_code = max_code; - /* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree, + /* The elements heap[heap_len/2 + 1 .. heap_len] are leaves of the tree, * establish sub-heaps of increasing lengths: */ for (n = s->heap_len/2; n >= 1; n--) pqdownheap(s, tree, n); @@ -700,11 +707,7 @@ local void build_tree(s, desc) * Scan a literal or distance tree to determine the frequencies of the codes * in the bit length tree. */ -local void scan_tree (s, tree, max_code) - deflate_state *s; - ct_data *tree; /* the tree to be scanned */ - int max_code; /* and its largest code of non zero frequency */ -{ +local void scan_tree(deflate_state *s, ct_data *tree, int max_code) { int n; /* iterates over all tree elements */ int prevlen = -1; /* last emitted length */ int curlen; /* length of current code */ @@ -714,10 +717,10 @@ local void scan_tree (s, tree, max_code) int min_count = 4; /* min repeat count */ if (nextlen == 0) max_count = 138, min_count = 3; - tree[max_code+1].Len = (ush)0xffff; /* guard */ + tree[max_code + 1].Len = (ush)0xffff; /* guard */ for (n = 0; n <= max_code; n++) { - curlen = nextlen; nextlen = tree[n+1].Len; + curlen = nextlen; nextlen = tree[n + 1].Len; if (++count < max_count && curlen == nextlen) { continue; } else if (count < min_count) { @@ -745,11 +748,7 @@ local void scan_tree (s, tree, max_code) * Send a literal or distance tree in compressed form, using the codes in * bl_tree. */ -local void send_tree (s, tree, max_code) - deflate_state *s; - ct_data *tree; /* the tree to be scanned */ - int max_code; /* and its largest code of non zero frequency */ -{ +local void send_tree(deflate_state *s, ct_data *tree, int max_code) { int n; /* iterates over all tree elements */ int prevlen = -1; /* last emitted length */ int curlen; /* length of current code */ @@ -758,11 +757,11 @@ local void send_tree (s, tree, max_code) int max_count = 7; /* max repeat count */ int min_count = 4; /* min repeat count */ - /* tree[max_code+1].Len = -1; */ /* guard already set */ + /* tree[max_code + 1].Len = -1; */ /* guard already set */ if (nextlen == 0) max_count = 138, min_count = 3; for (n = 0; n <= max_code; n++) { - curlen = nextlen; nextlen = tree[n+1].Len; + curlen = nextlen; nextlen = tree[n + 1].Len; if (++count < max_count && curlen == nextlen) { continue; } else if (count < min_count) { @@ -773,13 +772,13 @@ local void send_tree (s, tree, max_code) send_code(s, curlen, s->bl_tree); count--; } Assert(count >= 3 && count <= 6, " 3_6?"); - send_code(s, REP_3_6, s->bl_tree); send_bits(s, count-3, 2); + send_code(s, REP_3_6, s->bl_tree); send_bits(s, count - 3, 2); } else if (count <= 10) { - send_code(s, REPZ_3_10, s->bl_tree); send_bits(s, count-3, 3); + send_code(s, REPZ_3_10, s->bl_tree); send_bits(s, count - 3, 3); } else { - send_code(s, REPZ_11_138, s->bl_tree); send_bits(s, count-11, 7); + send_code(s, REPZ_11_138, s->bl_tree); send_bits(s, count - 11, 7); } count = 0; prevlen = curlen; if (nextlen == 0) { @@ -796,9 +795,7 @@ local void send_tree (s, tree, max_code) * Construct the Huffman tree for the bit lengths and return the index in * bl_order of the last bit length code to send. */ -local int build_bl_tree(s) - deflate_state *s; -{ +local int build_bl_tree(deflate_state *s) { int max_blindex; /* index of last bit length code of non zero freq */ /* Determine the bit length frequencies for literal and distance trees */ @@ -807,8 +804,8 @@ local int build_bl_tree(s) /* Build the bit length tree: */ build_tree(s, (tree_desc *)(&(s->bl_desc))); - /* opt_len now includes the length of the tree representations, except - * the lengths of the bit lengths codes and the 5+5+4 bits for the counts. + /* opt_len now includes the length of the tree representations, except the + * lengths of the bit lengths codes and the 5 + 5 + 4 bits for the counts. */ /* Determine the number of bit length codes to send. The pkzip format @@ -819,7 +816,7 @@ local int build_bl_tree(s) if (s->bl_tree[bl_order[max_blindex]].Len != 0) break; } /* Update opt_len to include the bit length tree and counts */ - s->opt_len += 3*((ulg)max_blindex+1) + 5+5+4; + s->opt_len += 3*((ulg)max_blindex + 1) + 5 + 5 + 4; Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld", s->opt_len, s->static_len)); @@ -831,42 +828,36 @@ local int build_bl_tree(s) * lengths of the bit length codes, the literal tree and the distance tree. * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4. */ -local void send_all_trees(s, lcodes, dcodes, blcodes) - deflate_state *s; - int lcodes, dcodes, blcodes; /* number of codes for each tree */ -{ +local void send_all_trees(deflate_state *s, int lcodes, int dcodes, + int blcodes) { int rank; /* index in bl_order */ Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes"); Assert (lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES, "too many codes"); Tracev((stderr, "\nbl counts: ")); - send_bits(s, lcodes-257, 5); /* not +255 as stated in appnote.txt */ - send_bits(s, dcodes-1, 5); - send_bits(s, blcodes-4, 4); /* not -3 as stated in appnote.txt */ + send_bits(s, lcodes - 257, 5); /* not +255 as stated in appnote.txt */ + send_bits(s, dcodes - 1, 5); + send_bits(s, blcodes - 4, 4); /* not -3 as stated in appnote.txt */ for (rank = 0; rank < blcodes; rank++) { Tracev((stderr, "\nbl code %2d ", bl_order[rank])); send_bits(s, s->bl_tree[bl_order[rank]].Len, 3); } Tracev((stderr, "\nbl tree: sent %ld", s->bits_sent)); - send_tree(s, (ct_data *)s->dyn_ltree, lcodes-1); /* literal tree */ + send_tree(s, (ct_data *)s->dyn_ltree, lcodes - 1); /* literal tree */ Tracev((stderr, "\nlit tree: sent %ld", s->bits_sent)); - send_tree(s, (ct_data *)s->dyn_dtree, dcodes-1); /* distance tree */ + send_tree(s, (ct_data *)s->dyn_dtree, dcodes - 1); /* distance tree */ Tracev((stderr, "\ndist tree: sent %ld", s->bits_sent)); } /* =========================================================================== * Send a stored block */ -void ZLIB_INTERNAL _tr_stored_block(s, buf, stored_len, last) - deflate_state *s; - charf *buf; /* input block */ - ulg stored_len; /* length of input block */ - int last; /* one if this is the last block for a file */ -{ - send_bits(s, (STORED_BLOCK<<1)+last, 3); /* send block type */ +void ZLIB_INTERNAL _tr_stored_block(deflate_state *s, charf *buf, + ulg stored_len, int last) { + send_bits(s, (STORED_BLOCK<<1) + last, 3); /* send block type */ bi_windup(s); /* align on byte boundary */ put_short(s, (ush)stored_len); put_short(s, (ush)~stored_len); @@ -877,16 +868,14 @@ void ZLIB_INTERNAL _tr_stored_block(s, buf, stored_len, last) s->compressed_len = (s->compressed_len + 3 + 7) & (ulg)~7L; s->compressed_len += (stored_len + 4) << 3; s->bits_sent += 2*16; - s->bits_sent += stored_len<<3; + s->bits_sent += stored_len << 3; #endif } /* =========================================================================== * Flush the bits in the bit buffer to pending output (leaves at most 7 bits) */ -void ZLIB_INTERNAL _tr_flush_bits(s) - deflate_state *s; -{ +void ZLIB_INTERNAL _tr_flush_bits(deflate_state *s) { bi_flush(s); } @@ -894,9 +883,7 @@ void ZLIB_INTERNAL _tr_flush_bits(s) * Send one empty static block to give enough lookahead for inflate. * This takes 10 bits, of which 7 may remain in the bit buffer. */ -void ZLIB_INTERNAL _tr_align(s) - deflate_state *s; -{ +void ZLIB_INTERNAL _tr_align(deflate_state *s) { send_bits(s, STATIC_TREES<<1, 3); send_code(s, END_BLOCK, static_ltree); #ifdef ZLIB_DEBUG @@ -905,16 +892,99 @@ void ZLIB_INTERNAL _tr_align(s) bi_flush(s); } +/* =========================================================================== + * Send the block data compressed using the given Huffman trees + */ +local void compress_block(deflate_state *s, const ct_data *ltree, + const ct_data *dtree) { + unsigned dist; /* distance of matched string */ + int lc; /* match length or unmatched char (if dist == 0) */ + unsigned sx = 0; /* running index in sym_buf */ + unsigned code; /* the code to send */ + int extra; /* number of extra bits to send */ + + if (s->sym_next != 0) do { + dist = s->sym_buf[sx++] & 0xff; + dist += (unsigned)(s->sym_buf[sx++] & 0xff) << 8; + lc = s->sym_buf[sx++]; + if (dist == 0) { + send_code(s, lc, ltree); /* send a literal byte */ + Tracecv(isgraph(lc), (stderr," '%c' ", lc)); + } else { + /* Here, lc is the match length - MIN_MATCH */ + code = _length_code[lc]; + send_code(s, code + LITERALS + 1, ltree); /* send length code */ + extra = extra_lbits[code]; + if (extra != 0) { + lc -= base_length[code]; + send_bits(s, lc, extra); /* send the extra length bits */ + } + dist--; /* dist is now the match distance - 1 */ + code = d_code(dist); + Assert (code < D_CODES, "bad d_code"); + + send_code(s, code, dtree); /* send the distance code */ + extra = extra_dbits[code]; + if (extra != 0) { + dist -= (unsigned)base_dist[code]; + send_bits(s, dist, extra); /* send the extra distance bits */ + } + } /* literal or match pair ? */ + + /* Check that the overlay between pending_buf and sym_buf is ok: */ + Assert(s->pending < s->lit_bufsize + sx, "pendingBuf overflow"); + + } while (sx < s->sym_next); + + send_code(s, END_BLOCK, ltree); +} + +/* =========================================================================== + * Check if the data type is TEXT or BINARY, using the following algorithm: + * - TEXT if the two conditions below are satisfied: + * a) There are no non-portable control characters belonging to the + * "block list" (0..6, 14..25, 28..31). + * b) There is at least one printable character belonging to the + * "allow list" (9 {TAB}, 10 {LF}, 13 {CR}, 32..255). + * - BINARY otherwise. + * - The following partially-portable control characters form a + * "gray list" that is ignored in this detection algorithm: + * (7 {BEL}, 8 {BS}, 11 {VT}, 12 {FF}, 26 {SUB}, 27 {ESC}). + * IN assertion: the fields Freq of dyn_ltree are set. + */ +local int detect_data_type(deflate_state *s) { + /* block_mask is the bit mask of block-listed bytes + * set bits 0..6, 14..25, and 28..31 + * 0xf3ffc07f = binary 11110011111111111100000001111111 + */ + unsigned long block_mask = 0xf3ffc07fUL; + int n; + + /* Check for non-textual ("block-listed") bytes. */ + for (n = 0; n <= 31; n++, block_mask >>= 1) + if ((block_mask & 1) && (s->dyn_ltree[n].Freq != 0)) + return Z_BINARY; + + /* Check for textual ("allow-listed") bytes. */ + if (s->dyn_ltree[9].Freq != 0 || s->dyn_ltree[10].Freq != 0 + || s->dyn_ltree[13].Freq != 0) + return Z_TEXT; + for (n = 32; n < LITERALS; n++) + if (s->dyn_ltree[n].Freq != 0) + return Z_TEXT; + + /* There are no "block-listed" or "allow-listed" bytes: + * this stream either is empty or has tolerated ("gray-listed") bytes only. + */ + return Z_BINARY; +} + /* =========================================================================== * Determine the best encoding for the current block: dynamic trees, static * trees or store, and write out the encoded block. */ -void ZLIB_INTERNAL _tr_flush_block(s, buf, stored_len, last) - deflate_state *s; - charf *buf; /* input block, or NULL if too old */ - ulg stored_len; /* length of input block */ - int last; /* one if this is the last block for a file */ -{ +void ZLIB_INTERNAL _tr_flush_block(deflate_state *s, charf *buf, + ulg stored_len, int last) { ulg opt_lenb, static_lenb; /* opt_len and static_len in bytes */ int max_blindex = 0; /* index of last bit length code of non zero freq */ @@ -943,14 +1013,17 @@ void ZLIB_INTERNAL _tr_flush_block(s, buf, stored_len, last) max_blindex = build_bl_tree(s); /* Determine the best encoding. Compute the block lengths in bytes. */ - opt_lenb = (s->opt_len+3+7)>>3; - static_lenb = (s->static_len+3+7)>>3; + opt_lenb = (s->opt_len + 3 + 7) >> 3; + static_lenb = (s->static_len + 3 + 7) >> 3; Tracev((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u ", opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len, s->sym_next / 3)); - if (static_lenb <= opt_lenb) opt_lenb = static_lenb; +#ifndef FORCE_STATIC + if (static_lenb <= opt_lenb || s->strategy == Z_FIXED) +#endif + opt_lenb = static_lenb; } else { Assert(buf != (char*)0, "lost buf"); @@ -960,7 +1033,7 @@ void ZLIB_INTERNAL _tr_flush_block(s, buf, stored_len, last) #ifdef FORCE_STORED if (buf != (char*)0) { /* force stored block */ #else - if (stored_len+4 <= opt_lenb && buf != (char*)0) { + if (stored_len + 4 <= opt_lenb && buf != (char*)0) { /* 4: two words for the lengths */ #endif /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE. @@ -971,21 +1044,17 @@ void ZLIB_INTERNAL _tr_flush_block(s, buf, stored_len, last) */ _tr_stored_block(s, buf, stored_len, last); -#ifdef FORCE_STATIC - } else if (static_lenb >= 0) { /* force static trees */ -#else - } else if (s->strategy == Z_FIXED || static_lenb == opt_lenb) { -#endif - send_bits(s, (STATIC_TREES<<1)+last, 3); + } else if (static_lenb == opt_lenb) { + send_bits(s, (STATIC_TREES<<1) + last, 3); compress_block(s, (const ct_data *)static_ltree, (const ct_data *)static_dtree); #ifdef ZLIB_DEBUG s->compressed_len += 3 + s->static_len; #endif } else { - send_bits(s, (DYN_TREES<<1)+last, 3); - send_all_trees(s, s->l_desc.max_code+1, s->d_desc.max_code+1, - max_blindex+1); + send_bits(s, (DYN_TREES<<1) + last, 3); + send_all_trees(s, s->l_desc.max_code + 1, s->d_desc.max_code + 1, + max_blindex + 1); compress_block(s, (const ct_data *)s->dyn_ltree, (const ct_data *)s->dyn_dtree); #ifdef ZLIB_DEBUG @@ -1004,19 +1073,15 @@ void ZLIB_INTERNAL _tr_flush_block(s, buf, stored_len, last) s->compressed_len += 7; /* align on byte boundary */ #endif } - Tracev((stderr,"\ncomprlen %lu(%lu) ", s->compressed_len>>3, - s->compressed_len-7*last)); + Tracev((stderr,"\ncomprlen %lu(%lu) ", s->compressed_len >> 3, + s->compressed_len - 7*last)); } /* =========================================================================== * Save the match info and tally the frequency counts. Return true if * the current block must be flushed. */ -int ZLIB_INTERNAL _tr_tally (s, dist, lc) - deflate_state *s; - unsigned dist; /* distance of matched string */ - unsigned lc; /* match length-MIN_MATCH or unmatched char (if dist==0) */ -{ +int ZLIB_INTERNAL _tr_tally(deflate_state *s, unsigned dist, unsigned lc) { s->sym_buf[s->sym_next++] = (uch)dist; s->sym_buf[s->sym_next++] = (uch)(dist >> 8); s->sym_buf[s->sym_next++] = (uch)lc; @@ -1031,152 +1096,8 @@ int ZLIB_INTERNAL _tr_tally (s, dist, lc) (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) && (ush)d_code(dist) < (ush)D_CODES, "_tr_tally: bad match"); - s->dyn_ltree[_length_code[lc]+LITERALS+1].Freq++; + s->dyn_ltree[_length_code[lc] + LITERALS + 1].Freq++; s->dyn_dtree[d_code(dist)].Freq++; } return (s->sym_next == s->sym_end); } - -/* =========================================================================== - * Send the block data compressed using the given Huffman trees - */ -local void compress_block(s, ltree, dtree) - deflate_state *s; - const ct_data *ltree; /* literal tree */ - const ct_data *dtree; /* distance tree */ -{ - unsigned dist; /* distance of matched string */ - int lc; /* match length or unmatched char (if dist == 0) */ - unsigned sx = 0; /* running index in sym_buf */ - unsigned code; /* the code to send */ - int extra; /* number of extra bits to send */ - - if (s->sym_next != 0) do { - dist = s->sym_buf[sx++] & 0xff; - dist += (unsigned)(s->sym_buf[sx++] & 0xff) << 8; - lc = s->sym_buf[sx++]; - if (dist == 0) { - send_code(s, lc, ltree); /* send a literal byte */ - Tracecv(isgraph(lc), (stderr," '%c' ", lc)); - } else { - /* Here, lc is the match length - MIN_MATCH */ - code = _length_code[lc]; - send_code(s, code+LITERALS+1, ltree); /* send the length code */ - extra = extra_lbits[code]; - if (extra != 0) { - lc -= base_length[code]; - send_bits(s, lc, extra); /* send the extra length bits */ - } - dist--; /* dist is now the match distance - 1 */ - code = d_code(dist); - Assert (code < D_CODES, "bad d_code"); - - send_code(s, code, dtree); /* send the distance code */ - extra = extra_dbits[code]; - if (extra != 0) { - dist -= (unsigned)base_dist[code]; - send_bits(s, dist, extra); /* send the extra distance bits */ - } - } /* literal or match pair ? */ - - /* Check that the overlay between pending_buf and sym_buf is ok: */ - Assert(s->pending < s->lit_bufsize + sx, "pendingBuf overflow"); - - } while (sx < s->sym_next); - - send_code(s, END_BLOCK, ltree); -} - -/* =========================================================================== - * Check if the data type is TEXT or BINARY, using the following algorithm: - * - TEXT if the two conditions below are satisfied: - * a) There are no non-portable control characters belonging to the - * "block list" (0..6, 14..25, 28..31). - * b) There is at least one printable character belonging to the - * "allow list" (9 {TAB}, 10 {LF}, 13 {CR}, 32..255). - * - BINARY otherwise. - * - The following partially-portable control characters form a - * "gray list" that is ignored in this detection algorithm: - * (7 {BEL}, 8 {BS}, 11 {VT}, 12 {FF}, 26 {SUB}, 27 {ESC}). - * IN assertion: the fields Freq of dyn_ltree are set. - */ -local int detect_data_type(s) - deflate_state *s; -{ - /* block_mask is the bit mask of block-listed bytes - * set bits 0..6, 14..25, and 28..31 - * 0xf3ffc07f = binary 11110011111111111100000001111111 - */ - unsigned long block_mask = 0xf3ffc07fUL; - int n; - - /* Check for non-textual ("block-listed") bytes. */ - for (n = 0; n <= 31; n++, block_mask >>= 1) - if ((block_mask & 1) && (s->dyn_ltree[n].Freq != 0)) - return Z_BINARY; - - /* Check for textual ("allow-listed") bytes. */ - if (s->dyn_ltree[9].Freq != 0 || s->dyn_ltree[10].Freq != 0 - || s->dyn_ltree[13].Freq != 0) - return Z_TEXT; - for (n = 32; n < LITERALS; n++) - if (s->dyn_ltree[n].Freq != 0) - return Z_TEXT; - - /* There are no "block-listed" or "allow-listed" bytes: - * this stream either is empty or has tolerated ("gray-listed") bytes only. - */ - return Z_BINARY; -} - -/* =========================================================================== - * Reverse the first len bits of a code, using straightforward code (a faster - * method would use a table) - * IN assertion: 1 <= len <= 15 - */ -local unsigned bi_reverse(code, len) - unsigned code; /* the value to invert */ - int len; /* its bit length */ -{ - register unsigned res = 0; - do { - res |= code & 1; - code >>= 1, res <<= 1; - } while (--len > 0); - return res >> 1; -} - -/* =========================================================================== - * Flush the bit buffer, keeping at most 7 bits in it. - */ -local void bi_flush(s) - deflate_state *s; -{ - if (s->bi_valid == 16) { - put_short(s, s->bi_buf); - s->bi_buf = 0; - s->bi_valid = 0; - } else if (s->bi_valid >= 8) { - put_byte(s, (Byte)s->bi_buf); - s->bi_buf >>= 8; - s->bi_valid -= 8; - } -} - -/* =========================================================================== - * Flush the bit buffer and align the output on a byte boundary - */ -local void bi_windup(s) - deflate_state *s; -{ - if (s->bi_valid > 8) { - put_short(s, s->bi_buf); - } else if (s->bi_valid > 0) { - put_byte(s, (Byte)s->bi_buf); - } - s->bi_buf = 0; - s->bi_valid = 0; -#ifdef ZLIB_DEBUG - s->bits_sent = (s->bits_sent+7) & ~7; -#endif -} diff --git a/deps/zlib/zconf.h b/deps/zlib/zconf.h index 5e1d68a004e..fb76ffe312a 100644 --- a/deps/zlib/zconf.h +++ b/deps/zlib/zconf.h @@ -38,6 +38,9 @@ # define crc32 z_crc32 # define crc32_combine z_crc32_combine # define crc32_combine64 z_crc32_combine64 +# define crc32_combine_gen z_crc32_combine_gen +# define crc32_combine_gen64 z_crc32_combine_gen64 +# define crc32_combine_op z_crc32_combine_op # define crc32_z z_crc32_z # define deflate z_deflate # define deflateBound z_deflateBound @@ -238,7 +241,11 @@ #endif #ifdef Z_SOLO - typedef unsigned long z_size_t; +# ifdef _WIN64 + typedef unsigned long long z_size_t; +# else + typedef unsigned long z_size_t; +# endif #else # define z_longlong long long # if defined(NO_SIZE_T) @@ -349,6 +356,9 @@ # ifdef FAR # undef FAR # endif +# ifndef WIN32_LEAN_AND_MEAN +# define WIN32_LEAN_AND_MEAN +# endif # include /* No need for _export, use ZLIB.DEF instead. */ /* For complete Windows compatibility, use WINAPI, not __stdcall. */ @@ -467,11 +477,18 @@ typedef uLong FAR uLongf; # undef _LARGEFILE64_SOURCE #endif -#if defined(__WATCOMC__) && !defined(Z_HAVE_UNISTD_H) -# define Z_HAVE_UNISTD_H +#ifndef Z_HAVE_UNISTD_H +# ifdef __WATCOMC__ +# define Z_HAVE_UNISTD_H +# endif +#endif +#ifndef Z_HAVE_UNISTD_H +# if defined(_LARGEFILE64_SOURCE) && !defined(_WIN32) +# define Z_HAVE_UNISTD_H +# endif #endif #ifndef Z_SOLO -# if defined(Z_HAVE_UNISTD_H) || defined(_LARGEFILE64_SOURCE) +# if defined(Z_HAVE_UNISTD_H) # include /* for SEEK_*, off_t, and _LFS64_LARGEFILE */ # ifdef VMS # include /* for off_t */ @@ -507,7 +524,7 @@ typedef uLong FAR uLongf; #if !defined(_WIN32) && defined(Z_LARGE64) # define z_off64_t off64_t #else -# if defined(_WIN32) && !defined(__GNUC__) && !defined(Z_SOLO) +# if defined(_WIN32) && !defined(__GNUC__) # define z_off64_t __int64 # else # define z_off64_t z_off_t diff --git a/deps/zlib/zlib.h b/deps/zlib/zlib.h index d074d8398a6..6b7244f9943 100644 --- a/deps/zlib/zlib.h +++ b/deps/zlib/zlib.h @@ -1,7 +1,7 @@ /* zlib.h -- interface of the 'zlib' general purpose compression library - version 1.2.12, March 11th, 2022 + version 1.3, August 18th, 2023 - Copyright (C) 1995-2022 Jean-loup Gailly and Mark Adler + Copyright (C) 1995-2023 Jean-loup Gailly and Mark Adler This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages @@ -37,11 +37,11 @@ extern "C" { #endif -#define ZLIB_VERSION "1.2.12" -#define ZLIB_VERNUM 0x12c0 +#define ZLIB_VERSION "1.3" +#define ZLIB_VERNUM 0x1300 #define ZLIB_VER_MAJOR 1 -#define ZLIB_VER_MINOR 2 -#define ZLIB_VER_REVISION 12 +#define ZLIB_VER_MINOR 3 +#define ZLIB_VER_REVISION 0 #define ZLIB_VER_SUBREVISION 0 /* @@ -78,8 +78,8 @@ extern "C" { even in the case of corrupted input. */ -typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size)); -typedef void (*free_func) OF((voidpf opaque, voidpf address)); +typedef voidpf (*alloc_func)(voidpf opaque, uInt items, uInt size); +typedef void (*free_func)(voidpf opaque, voidpf address); struct internal_state; @@ -217,7 +217,7 @@ typedef gz_header FAR *gz_headerp; /* basic functions */ -ZEXTERN const char * ZEXPORT zlibVersion OF((void)); +ZEXTERN const char * ZEXPORT zlibVersion(void); /* The application can compare zlibVersion and ZLIB_VERSION for consistency. If the first character differs, the library code actually used is not compatible with the zlib.h header file used by the application. This check @@ -225,12 +225,12 @@ ZEXTERN const char * ZEXPORT zlibVersion OF((void)); */ /* -ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level)); +ZEXTERN int ZEXPORT deflateInit(z_streamp strm, int level); Initializes the internal stream state for compression. The fields zalloc, zfree and opaque must be initialized before by the caller. If zalloc and zfree are set to Z_NULL, deflateInit updates them to use default - allocation functions. + allocation functions. total_in, total_out, adler, and msg are initialized. The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9: 1 gives best speed, 9 gives best compression, 0 gives no compression at all @@ -247,7 +247,7 @@ ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level)); */ -ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush)); +ZEXTERN int ZEXPORT deflate(z_streamp strm, int flush); /* deflate compresses as much data as possible, and stops when the input buffer becomes empty or the output buffer becomes full. It may introduce @@ -276,7 +276,7 @@ ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush)); == 0), or after each call of deflate(). If deflate returns Z_OK and with zero avail_out, it must be called again after making room in the output buffer because there might be more output pending. See deflatePending(), - which can be used if desired to determine whether or not there is more ouput + which can be used if desired to determine whether or not there is more output in that case. Normally the parameter flush is set to Z_NO_FLUSH, which allows deflate to @@ -320,8 +320,8 @@ ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush)); with the same value of the flush parameter and more output space (updated avail_out), until the flush is complete (deflate returns with non-zero avail_out). In the case of a Z_FULL_FLUSH or Z_SYNC_FLUSH, make sure that - avail_out is greater than six to avoid repeated flush markers due to - avail_out == 0 on return. + avail_out is greater than six when the flush marker begins, in order to avoid + repeated flush markers upon calling deflate() again when avail_out == 0. If the parameter flush is set to Z_FINISH, pending input is processed, pending output is flushed and deflate returns with Z_STREAM_END if there was @@ -360,7 +360,7 @@ ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush)); */ -ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm)); +ZEXTERN int ZEXPORT deflateEnd(z_streamp strm); /* All dynamically allocated data structures for this stream are freed. This function discards any unprocessed input and does not flush any pending @@ -375,7 +375,7 @@ ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm)); /* -ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm)); +ZEXTERN int ZEXPORT inflateInit(z_streamp strm); Initializes the internal stream state for decompression. The fields next_in, avail_in, zalloc, zfree and opaque must be initialized before by @@ -383,7 +383,8 @@ ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm)); read or consumed. The allocation of a sliding window will be deferred to the first call of inflate (if the decompression does not complete on the first call). If zalloc and zfree are set to Z_NULL, inflateInit updates - them to use default allocation functions. + them to use default allocation functions. total_in, total_out, adler, and + msg are initialized. inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough memory, Z_VERSION_ERROR if the zlib library version is incompatible with the @@ -397,7 +398,7 @@ ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm)); */ -ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush)); +ZEXTERN int ZEXPORT inflate(z_streamp strm, int flush); /* inflate decompresses as much data as possible, and stops when the input buffer becomes empty or the output buffer becomes full. It may introduce @@ -517,7 +518,7 @@ ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush)); */ -ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm)); +ZEXTERN int ZEXPORT inflateEnd(z_streamp strm); /* All dynamically allocated data structures for this stream are freed. This function discards any unprocessed input and does not flush any pending @@ -535,12 +536,12 @@ ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm)); */ /* -ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm, - int level, - int method, - int windowBits, - int memLevel, - int strategy)); +ZEXTERN int ZEXPORT deflateInit2(z_streamp strm, + int level, + int method, + int windowBits, + int memLevel, + int strategy); This is another version of deflateInit with more compression options. The fields zalloc, zfree and opaque must be initialized before by the caller. @@ -607,9 +608,9 @@ ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm, compression: this will be done by deflate(). */ -ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm, - const Bytef *dictionary, - uInt dictLength)); +ZEXTERN int ZEXPORT deflateSetDictionary(z_streamp strm, + const Bytef *dictionary, + uInt dictLength); /* Initializes the compression dictionary from the given byte sequence without producing any compressed output. When using the zlib format, this @@ -651,16 +652,16 @@ ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm, not perform any compression: this will be done by deflate(). */ -ZEXTERN int ZEXPORT deflateGetDictionary OF((z_streamp strm, - Bytef *dictionary, - uInt *dictLength)); +ZEXTERN int ZEXPORT deflateGetDictionary(z_streamp strm, + Bytef *dictionary, + uInt *dictLength); /* Returns the sliding dictionary being maintained by deflate. dictLength is set to the number of bytes in the dictionary, and that many bytes are copied to dictionary. dictionary must have enough space, where 32768 bytes is always enough. If deflateGetDictionary() is called with dictionary equal to Z_NULL, then only the dictionary length is returned, and nothing is copied. - Similary, if dictLength is Z_NULL, then it is not set. + Similarly, if dictLength is Z_NULL, then it is not set. deflateGetDictionary() may return a length less than the window size, even when more than the window size in input has been provided. It may return up @@ -673,8 +674,8 @@ ZEXTERN int ZEXPORT deflateGetDictionary OF((z_streamp strm, stream state is inconsistent. */ -ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest, - z_streamp source)); +ZEXTERN int ZEXPORT deflateCopy(z_streamp dest, + z_streamp source); /* Sets the destination stream as a complete copy of the source stream. @@ -691,20 +692,20 @@ ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest, destination. */ -ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm)); +ZEXTERN int ZEXPORT deflateReset(z_streamp strm); /* This function is equivalent to deflateEnd followed by deflateInit, but does not free and reallocate the internal compression state. The stream will leave the compression level and any other attributes that may have been - set unchanged. + set unchanged. total_in, total_out, adler, and msg are initialized. deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source stream state was inconsistent (such as zalloc or state being Z_NULL). */ -ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm, - int level, - int strategy)); +ZEXTERN int ZEXPORT deflateParams(z_streamp strm, + int level, + int strategy); /* Dynamically update the compression level and compression strategy. The interpretation of level and strategy is as in deflateInit2(). This can be @@ -729,7 +730,7 @@ ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm, Then no more input data should be provided before the deflateParams() call. If this is done, the old level and strategy will be applied to the data compressed before deflateParams(), and the new level and strategy will be - applied to the the data compressed after deflateParams(). + applied to the data compressed after deflateParams(). deflateParams returns Z_OK on success, Z_STREAM_ERROR if the source stream state was inconsistent or if a parameter was invalid, or Z_BUF_ERROR if @@ -740,11 +741,11 @@ ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm, retried with more output space. */ -ZEXTERN int ZEXPORT deflateTune OF((z_streamp strm, - int good_length, - int max_lazy, - int nice_length, - int max_chain)); +ZEXTERN int ZEXPORT deflateTune(z_streamp strm, + int good_length, + int max_lazy, + int nice_length, + int max_chain); /* Fine tune deflate's internal compression parameters. This should only be used by someone who understands the algorithm used by zlib's deflate for @@ -757,8 +758,8 @@ ZEXTERN int ZEXPORT deflateTune OF((z_streamp strm, returns Z_OK on success, or Z_STREAM_ERROR for an invalid deflate stream. */ -ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm, - uLong sourceLen)); +ZEXTERN uLong ZEXPORT deflateBound(z_streamp strm, + uLong sourceLen); /* deflateBound() returns an upper bound on the compressed size after deflation of sourceLen bytes. It must be called after deflateInit() or @@ -772,9 +773,9 @@ ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm, than Z_FINISH or Z_NO_FLUSH are used. */ -ZEXTERN int ZEXPORT deflatePending OF((z_streamp strm, - unsigned *pending, - int *bits)); +ZEXTERN int ZEXPORT deflatePending(z_streamp strm, + unsigned *pending, + int *bits); /* deflatePending() returns the number of bytes and bits of output that have been generated, but not yet provided in the available output. The bytes not @@ -787,9 +788,9 @@ ZEXTERN int ZEXPORT deflatePending OF((z_streamp strm, stream state was inconsistent. */ -ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm, - int bits, - int value)); +ZEXTERN int ZEXPORT deflatePrime(z_streamp strm, + int bits, + int value); /* deflatePrime() inserts bits in the deflate output stream. The intent is that this function is used to start off the deflate output with the bits @@ -804,8 +805,8 @@ ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm, source stream state was inconsistent. */ -ZEXTERN int ZEXPORT deflateSetHeader OF((z_streamp strm, - gz_headerp head)); +ZEXTERN int ZEXPORT deflateSetHeader(z_streamp strm, + gz_headerp head); /* deflateSetHeader() provides gzip header information for when a gzip stream is requested by deflateInit2(). deflateSetHeader() may be called @@ -821,16 +822,17 @@ ZEXTERN int ZEXPORT deflateSetHeader OF((z_streamp strm, gzip file" and give up. If deflateSetHeader is not used, the default gzip header has text false, - the time set to zero, and os set to 255, with no extra, name, or comment - fields. The gzip header is returned to the default state by deflateReset(). + the time set to zero, and os set to the current operating system, with no + extra, name, or comment fields. The gzip header is returned to the default + state by deflateReset(). deflateSetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source stream state was inconsistent. */ /* -ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm, - int windowBits)); +ZEXTERN int ZEXPORT inflateInit2(z_streamp strm, + int windowBits); This is another version of inflateInit with an extra parameter. The fields next_in, avail_in, zalloc, zfree and opaque must be initialized @@ -883,9 +885,9 @@ ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm, deferred until inflate() is called. */ -ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm, - const Bytef *dictionary, - uInt dictLength)); +ZEXTERN int ZEXPORT inflateSetDictionary(z_streamp strm, + const Bytef *dictionary, + uInt dictLength); /* Initializes the decompression dictionary from the given uncompressed byte sequence. This function must be called immediately after a call of inflate, @@ -906,22 +908,22 @@ ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm, inflate(). */ -ZEXTERN int ZEXPORT inflateGetDictionary OF((z_streamp strm, - Bytef *dictionary, - uInt *dictLength)); +ZEXTERN int ZEXPORT inflateGetDictionary(z_streamp strm, + Bytef *dictionary, + uInt *dictLength); /* Returns the sliding dictionary being maintained by inflate. dictLength is set to the number of bytes in the dictionary, and that many bytes are copied to dictionary. dictionary must have enough space, where 32768 bytes is always enough. If inflateGetDictionary() is called with dictionary equal to Z_NULL, then only the dictionary length is returned, and nothing is copied. - Similary, if dictLength is Z_NULL, then it is not set. + Similarly, if dictLength is Z_NULL, then it is not set. inflateGetDictionary returns Z_OK on success, or Z_STREAM_ERROR if the stream state is inconsistent. */ -ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm)); +ZEXTERN int ZEXPORT inflateSync(z_streamp strm); /* Skips invalid compressed data until a possible full flush point (see above for the description of deflate with Z_FULL_FLUSH) can be found, or until all @@ -940,8 +942,8 @@ ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm)); input each time, until success or end of the input data. */ -ZEXTERN int ZEXPORT inflateCopy OF((z_streamp dest, - z_streamp source)); +ZEXTERN int ZEXPORT inflateCopy(z_streamp dest, + z_streamp source); /* Sets the destination stream as a complete copy of the source stream. @@ -956,18 +958,19 @@ ZEXTERN int ZEXPORT inflateCopy OF((z_streamp dest, destination. */ -ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm)); +ZEXTERN int ZEXPORT inflateReset(z_streamp strm); /* This function is equivalent to inflateEnd followed by inflateInit, but does not free and reallocate the internal decompression state. The stream will keep attributes that may have been set by inflateInit2. + total_in, total_out, adler, and msg are initialized. inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source stream state was inconsistent (such as zalloc or state being Z_NULL). */ -ZEXTERN int ZEXPORT inflateReset2 OF((z_streamp strm, - int windowBits)); +ZEXTERN int ZEXPORT inflateReset2(z_streamp strm, + int windowBits); /* This function is the same as inflateReset, but it also permits changing the wrap and window size requests. The windowBits parameter is interpreted @@ -980,9 +983,9 @@ ZEXTERN int ZEXPORT inflateReset2 OF((z_streamp strm, the windowBits parameter is invalid. */ -ZEXTERN int ZEXPORT inflatePrime OF((z_streamp strm, - int bits, - int value)); +ZEXTERN int ZEXPORT inflatePrime(z_streamp strm, + int bits, + int value); /* This function inserts bits in the inflate input stream. The intent is that this function is used to start inflating at a bit position in the @@ -1001,7 +1004,7 @@ ZEXTERN int ZEXPORT inflatePrime OF((z_streamp strm, stream state was inconsistent. */ -ZEXTERN long ZEXPORT inflateMark OF((z_streamp strm)); +ZEXTERN long ZEXPORT inflateMark(z_streamp strm); /* This function returns two values, one in the lower 16 bits of the return value, and the other in the remaining upper bits, obtained by shifting the @@ -1029,8 +1032,8 @@ ZEXTERN long ZEXPORT inflateMark OF((z_streamp strm)); source stream state was inconsistent. */ -ZEXTERN int ZEXPORT inflateGetHeader OF((z_streamp strm, - gz_headerp head)); +ZEXTERN int ZEXPORT inflateGetHeader(z_streamp strm, + gz_headerp head); /* inflateGetHeader() requests that gzip header information be stored in the provided gz_header structure. inflateGetHeader() may be called after @@ -1070,8 +1073,8 @@ ZEXTERN int ZEXPORT inflateGetHeader OF((z_streamp strm, */ /* -ZEXTERN int ZEXPORT inflateBackInit OF((z_streamp strm, int windowBits, - unsigned char FAR *window)); +ZEXTERN int ZEXPORT inflateBackInit(z_streamp strm, int windowBits, + unsigned char FAR *window); Initialize the internal stream state for decompression using inflateBack() calls. The fields zalloc, zfree and opaque in strm must be initialized @@ -1091,13 +1094,13 @@ ZEXTERN int ZEXPORT inflateBackInit OF((z_streamp strm, int windowBits, the version of the header file. */ -typedef unsigned (*in_func) OF((void FAR *, - z_const unsigned char FAR * FAR *)); -typedef int (*out_func) OF((void FAR *, unsigned char FAR *, unsigned)); +typedef unsigned (*in_func)(void FAR *, + z_const unsigned char FAR * FAR *); +typedef int (*out_func)(void FAR *, unsigned char FAR *, unsigned); -ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm, - in_func in, void FAR *in_desc, - out_func out, void FAR *out_desc)); +ZEXTERN int ZEXPORT inflateBack(z_streamp strm, + in_func in, void FAR *in_desc, + out_func out, void FAR *out_desc); /* inflateBack() does a raw inflate with a single call using a call-back interface for input and output. This is potentially more efficient than @@ -1165,7 +1168,7 @@ ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm, cannot return Z_OK. */ -ZEXTERN int ZEXPORT inflateBackEnd OF((z_streamp strm)); +ZEXTERN int ZEXPORT inflateBackEnd(z_streamp strm); /* All memory allocated by inflateBackInit() is freed. @@ -1173,7 +1176,7 @@ ZEXTERN int ZEXPORT inflateBackEnd OF((z_streamp strm)); state was inconsistent. */ -ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void)); +ZEXTERN uLong ZEXPORT zlibCompileFlags(void); /* Return flags indicating compile-time options. Type sizes, two bits each, 00 = 16 bits, 01 = 32, 10 = 64, 11 = other: @@ -1226,8 +1229,8 @@ ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void)); you need special options. */ -ZEXTERN int ZEXPORT compress OF((Bytef *dest, uLongf *destLen, - const Bytef *source, uLong sourceLen)); +ZEXTERN int ZEXPORT compress(Bytef *dest, uLongf *destLen, + const Bytef *source, uLong sourceLen); /* Compresses the source buffer into the destination buffer. sourceLen is the byte length of the source buffer. Upon entry, destLen is the total size @@ -1241,9 +1244,9 @@ ZEXTERN int ZEXPORT compress OF((Bytef *dest, uLongf *destLen, buffer. */ -ZEXTERN int ZEXPORT compress2 OF((Bytef *dest, uLongf *destLen, - const Bytef *source, uLong sourceLen, - int level)); +ZEXTERN int ZEXPORT compress2(Bytef *dest, uLongf *destLen, + const Bytef *source, uLong sourceLen, + int level); /* Compresses the source buffer into the destination buffer. The level parameter has the same meaning as in deflateInit. sourceLen is the byte @@ -1257,15 +1260,15 @@ ZEXTERN int ZEXPORT compress2 OF((Bytef *dest, uLongf *destLen, Z_STREAM_ERROR if the level parameter is invalid. */ -ZEXTERN uLong ZEXPORT compressBound OF((uLong sourceLen)); +ZEXTERN uLong ZEXPORT compressBound(uLong sourceLen); /* compressBound() returns an upper bound on the compressed size after compress() or compress2() on sourceLen bytes. It would be used before a compress() or compress2() call to allocate the destination buffer. */ -ZEXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen, - const Bytef *source, uLong sourceLen)); +ZEXTERN int ZEXPORT uncompress(Bytef *dest, uLongf *destLen, + const Bytef *source, uLong sourceLen); /* Decompresses the source buffer into the destination buffer. sourceLen is the byte length of the source buffer. Upon entry, destLen is the total size @@ -1282,8 +1285,8 @@ ZEXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen, buffer with the uncompressed data up to that point. */ -ZEXTERN int ZEXPORT uncompress2 OF((Bytef *dest, uLongf *destLen, - const Bytef *source, uLong *sourceLen)); +ZEXTERN int ZEXPORT uncompress2(Bytef *dest, uLongf *destLen, + const Bytef *source, uLong *sourceLen); /* Same as uncompress, except that sourceLen is a pointer, where the length of the source is *sourceLen. On return, *sourceLen is the number of @@ -1302,7 +1305,7 @@ ZEXTERN int ZEXPORT uncompress2 OF((Bytef *dest, uLongf *destLen, typedef struct gzFile_s *gzFile; /* semi-opaque gzip file descriptor */ /* -ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode)); +ZEXTERN gzFile ZEXPORT gzopen(const char *path, const char *mode); Open the gzip (.gz) file at path for reading and decompressing, or compressing and writing. The mode parameter is as in fopen ("rb" or "wb") @@ -1339,7 +1342,7 @@ ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode)); file could not be opened. */ -ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode)); +ZEXTERN gzFile ZEXPORT gzdopen(int fd, const char *mode); /* Associate a gzFile with the file descriptor fd. File descriptors are obtained from calls like open, dup, creat, pipe or fileno (if the file has @@ -1362,7 +1365,7 @@ ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode)); will not detect if fd is invalid (unless fd is -1). */ -ZEXTERN int ZEXPORT gzbuffer OF((gzFile file, unsigned size)); +ZEXTERN int ZEXPORT gzbuffer(gzFile file, unsigned size); /* Set the internal buffer size used by this library's functions for file to size. The default buffer size is 8192 bytes. This function must be called @@ -1378,7 +1381,7 @@ ZEXTERN int ZEXPORT gzbuffer OF((gzFile file, unsigned size)); too late. */ -ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy)); +ZEXTERN int ZEXPORT gzsetparams(gzFile file, int level, int strategy); /* Dynamically update the compression level and strategy for file. See the description of deflateInit2 for the meaning of these parameters. Previously @@ -1389,7 +1392,7 @@ ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy)); or Z_MEM_ERROR if there is a memory allocation error. */ -ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len)); +ZEXTERN int ZEXPORT gzread(gzFile file, voidp buf, unsigned len); /* Read and decompress up to len uncompressed bytes from file into buf. If the input file is not in gzip format, gzread copies the given number of @@ -1419,8 +1422,8 @@ ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len)); Z_STREAM_ERROR. */ -ZEXTERN z_size_t ZEXPORT gzfread OF((voidp buf, z_size_t size, z_size_t nitems, - gzFile file)); +ZEXTERN z_size_t ZEXPORT gzfread(voidp buf, z_size_t size, z_size_t nitems, + gzFile file); /* Read and decompress up to nitems items of size size from file into buf, otherwise operating as gzread() does. This duplicates the interface of @@ -1437,22 +1440,22 @@ ZEXTERN z_size_t ZEXPORT gzfread OF((voidp buf, z_size_t size, z_size_t nitems, In the event that the end of file is reached and only a partial item is available at the end, i.e. the remaining uncompressed data length is not a - multiple of size, then the final partial item is nevetheless read into buf + multiple of size, then the final partial item is nevertheless read into buf and the end-of-file flag is set. The length of the partial item read is not provided, but could be inferred from the result of gztell(). This behavior is the same as the behavior of fread() implementations in common libraries, but it prevents the direct use of gzfread() to read a concurrently written - file, reseting and retrying on end-of-file, when size is not 1. + file, resetting and retrying on end-of-file, when size is not 1. */ -ZEXTERN int ZEXPORT gzwrite OF((gzFile file, voidpc buf, unsigned len)); +ZEXTERN int ZEXPORT gzwrite(gzFile file, voidpc buf, unsigned len); /* Compress and write the len uncompressed bytes at buf to file. gzwrite returns the number of uncompressed bytes written or 0 in case of error. */ -ZEXTERN z_size_t ZEXPORT gzfwrite OF((voidpc buf, z_size_t size, - z_size_t nitems, gzFile file)); +ZEXTERN z_size_t ZEXPORT gzfwrite(voidpc buf, z_size_t size, + z_size_t nitems, gzFile file); /* Compress and write nitems items of size size from buf to file, duplicating the interface of stdio's fwrite(), with size_t request and return types. If @@ -1465,7 +1468,7 @@ ZEXTERN z_size_t ZEXPORT gzfwrite OF((voidpc buf, z_size_t size, is returned, and the error state is set to Z_STREAM_ERROR. */ -ZEXTERN int ZEXPORTVA gzprintf Z_ARG((gzFile file, const char *format, ...)); +ZEXTERN int ZEXPORTVA gzprintf(gzFile file, const char *format, ...); /* Convert, format, compress, and write the arguments (...) to file under control of the string format, as in fprintf. gzprintf returns the number of @@ -1480,7 +1483,7 @@ ZEXTERN int ZEXPORTVA gzprintf Z_ARG((gzFile file, const char *format, ...)); This can be determined using zlibCompileFlags(). */ -ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s)); +ZEXTERN int ZEXPORT gzputs(gzFile file, const char *s); /* Compress and write the given null-terminated string s to file, excluding the terminating null character. @@ -1488,7 +1491,7 @@ ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s)); gzputs returns the number of characters written, or -1 in case of error. */ -ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len)); +ZEXTERN char * ZEXPORT gzgets(gzFile file, char *buf, int len); /* Read and decompress bytes from file into buf, until len-1 characters are read, or until a newline character is read and transferred to buf, or an @@ -1502,13 +1505,13 @@ ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len)); buf are indeterminate. */ -ZEXTERN int ZEXPORT gzputc OF((gzFile file, int c)); +ZEXTERN int ZEXPORT gzputc(gzFile file, int c); /* Compress and write c, converted to an unsigned char, into file. gzputc returns the value that was written, or -1 in case of error. */ -ZEXTERN int ZEXPORT gzgetc OF((gzFile file)); +ZEXTERN int ZEXPORT gzgetc(gzFile file); /* Read and decompress one byte from file. gzgetc returns this byte or -1 in case of end of file or error. This is implemented as a macro for speed. @@ -1517,7 +1520,7 @@ ZEXTERN int ZEXPORT gzgetc OF((gzFile file)); points to has been clobbered or not. */ -ZEXTERN int ZEXPORT gzungetc OF((int c, gzFile file)); +ZEXTERN int ZEXPORT gzungetc(int c, gzFile file); /* Push c back onto the stream for file to be read as the first character on the next read. At least one character of push-back is always allowed. @@ -1529,7 +1532,7 @@ ZEXTERN int ZEXPORT gzungetc OF((int c, gzFile file)); gzseek() or gzrewind(). */ -ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush)); +ZEXTERN int ZEXPORT gzflush(gzFile file, int flush); /* Flush all pending output to file. The parameter flush is as in the deflate() function. The return value is the zlib error number (see function @@ -1545,8 +1548,8 @@ ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush)); */ /* -ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file, - z_off_t offset, int whence)); +ZEXTERN z_off_t ZEXPORT gzseek(gzFile file, + z_off_t offset, int whence); Set the starting position to offset relative to whence for the next gzread or gzwrite on file. The offset represents a number of bytes in the @@ -1564,7 +1567,7 @@ ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file, would be before the current position. */ -ZEXTERN int ZEXPORT gzrewind OF((gzFile file)); +ZEXTERN int ZEXPORT gzrewind(gzFile file); /* Rewind file. This function is supported only for reading. @@ -1572,7 +1575,7 @@ ZEXTERN int ZEXPORT gzrewind OF((gzFile file)); */ /* -ZEXTERN z_off_t ZEXPORT gztell OF((gzFile file)); +ZEXTERN z_off_t ZEXPORT gztell(gzFile file); Return the starting position for the next gzread or gzwrite on file. This position represents a number of bytes in the uncompressed data stream, @@ -1583,7 +1586,7 @@ ZEXTERN z_off_t ZEXPORT gztell OF((gzFile file)); */ /* -ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile file)); +ZEXTERN z_off_t ZEXPORT gzoffset(gzFile file); Return the current compressed (actual) read or write offset of file. This offset includes the count of bytes that precede the gzip stream, for example @@ -1592,7 +1595,7 @@ ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile file)); be used for a progress indicator. On error, gzoffset() returns -1. */ -ZEXTERN int ZEXPORT gzeof OF((gzFile file)); +ZEXTERN int ZEXPORT gzeof(gzFile file); /* Return true (1) if the end-of-file indicator for file has been set while reading, false (0) otherwise. Note that the end-of-file indicator is set @@ -1607,7 +1610,7 @@ ZEXTERN int ZEXPORT gzeof OF((gzFile file)); has grown since the previous end of file was detected. */ -ZEXTERN int ZEXPORT gzdirect OF((gzFile file)); +ZEXTERN int ZEXPORT gzdirect(gzFile file); /* Return true (1) if file is being copied directly while reading, or false (0) if file is a gzip stream being decompressed. @@ -1628,7 +1631,7 @@ ZEXTERN int ZEXPORT gzdirect OF((gzFile file)); gzip file reading and decompression, which may not be desired.) */ -ZEXTERN int ZEXPORT gzclose OF((gzFile file)); +ZEXTERN int ZEXPORT gzclose(gzFile file); /* Flush all pending output for file, if necessary, close file and deallocate the (de)compression state. Note that once file is closed, you @@ -1641,8 +1644,8 @@ ZEXTERN int ZEXPORT gzclose OF((gzFile file)); last read ended in the middle of a gzip stream, or Z_OK on success. */ -ZEXTERN int ZEXPORT gzclose_r OF((gzFile file)); -ZEXTERN int ZEXPORT gzclose_w OF((gzFile file)); +ZEXTERN int ZEXPORT gzclose_r(gzFile file); +ZEXTERN int ZEXPORT gzclose_w(gzFile file); /* Same as gzclose(), but gzclose_r() is only for use when reading, and gzclose_w() is only for use when writing or appending. The advantage to @@ -1653,7 +1656,7 @@ ZEXTERN int ZEXPORT gzclose_w OF((gzFile file)); zlib library. */ -ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum)); +ZEXTERN const char * ZEXPORT gzerror(gzFile file, int *errnum); /* Return the error message for the last error which occurred on file. errnum is set to zlib error number. If an error occurred in the file system @@ -1669,7 +1672,7 @@ ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum)); functions above that do not distinguish those cases in their return values. */ -ZEXTERN void ZEXPORT gzclearerr OF((gzFile file)); +ZEXTERN void ZEXPORT gzclearerr(gzFile file); /* Clear the error and end-of-file flags for file. This is analogous to the clearerr() function in stdio. This is useful for continuing to read a gzip @@ -1686,7 +1689,7 @@ ZEXTERN void ZEXPORT gzclearerr OF((gzFile file)); library. */ -ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len)); +ZEXTERN uLong ZEXPORT adler32(uLong adler, const Bytef *buf, uInt len); /* Update a running Adler-32 checksum with the bytes buf[0..len-1] and return the updated checksum. An Adler-32 value is in the range of a 32-bit @@ -1706,15 +1709,15 @@ ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len)); if (adler != original_adler) error(); */ -ZEXTERN uLong ZEXPORT adler32_z OF((uLong adler, const Bytef *buf, - z_size_t len)); +ZEXTERN uLong ZEXPORT adler32_z(uLong adler, const Bytef *buf, + z_size_t len); /* Same as adler32(), but with a size_t length. */ /* -ZEXTERN uLong ZEXPORT adler32_combine OF((uLong adler1, uLong adler2, - z_off_t len2)); +ZEXTERN uLong ZEXPORT adler32_combine(uLong adler1, uLong adler2, + z_off_t len2); Combine two Adler-32 checksums into one. For two sequences of bytes, seq1 and seq2 with lengths len1 and len2, Adler-32 checksums were calculated for @@ -1724,7 +1727,7 @@ ZEXTERN uLong ZEXPORT adler32_combine OF((uLong adler1, uLong adler2, negative, the result has no meaning or utility. */ -ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len)); +ZEXTERN uLong ZEXPORT crc32(uLong crc, const Bytef *buf, uInt len); /* Update a running CRC-32 with the bytes buf[0..len-1] and return the updated CRC-32. A CRC-32 value is in the range of a 32-bit unsigned integer. @@ -1742,14 +1745,14 @@ ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len)); if (crc != original_crc) error(); */ -ZEXTERN uLong ZEXPORT crc32_z OF((uLong crc, const Bytef *buf, - z_size_t len)); +ZEXTERN uLong ZEXPORT crc32_z(uLong crc, const Bytef *buf, + z_size_t len); /* Same as crc32(), but with a size_t length. */ /* -ZEXTERN uLong ZEXPORT crc32_combine OF((uLong crc1, uLong crc2, z_off_t len2)); +ZEXTERN uLong ZEXPORT crc32_combine(uLong crc1, uLong crc2, z_off_t len2); Combine two CRC-32 check values into one. For two sequences of bytes, seq1 and seq2 with lengths len1 and len2, CRC-32 check values were @@ -1759,13 +1762,13 @@ ZEXTERN uLong ZEXPORT crc32_combine OF((uLong crc1, uLong crc2, z_off_t len2)); */ /* -ZEXTERN uLong ZEXPORT crc32_combine_gen OF((z_off_t len2)); +ZEXTERN uLong ZEXPORT crc32_combine_gen(z_off_t len2); Return the operator corresponding to length len2, to be used with crc32_combine_op(). */ -ZEXTERN uLong ZEXPORT crc32_combine_op OF((uLong crc1, uLong crc2, uLong op)); +ZEXTERN uLong ZEXPORT crc32_combine_op(uLong crc1, uLong crc2, uLong op); /* Give the same result as crc32_combine(), using op in place of len2. op is is generated from len2 by crc32_combine_gen(). This will be faster than @@ -1778,20 +1781,20 @@ ZEXTERN uLong ZEXPORT crc32_combine_op OF((uLong crc1, uLong crc2, uLong op)); /* deflateInit and inflateInit are macros to allow checking the zlib version * and the compiler's view of z_stream: */ -ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level, - const char *version, int stream_size)); -ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm, - const char *version, int stream_size)); -ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int level, int method, - int windowBits, int memLevel, - int strategy, const char *version, - int stream_size)); -ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int windowBits, - const char *version, int stream_size)); -ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits, - unsigned char FAR *window, - const char *version, - int stream_size)); +ZEXTERN int ZEXPORT deflateInit_(z_streamp strm, int level, + const char *version, int stream_size); +ZEXTERN int ZEXPORT inflateInit_(z_streamp strm, + const char *version, int stream_size); +ZEXTERN int ZEXPORT deflateInit2_(z_streamp strm, int level, int method, + int windowBits, int memLevel, + int strategy, const char *version, + int stream_size); +ZEXTERN int ZEXPORT inflateInit2_(z_streamp strm, int windowBits, + const char *version, int stream_size); +ZEXTERN int ZEXPORT inflateBackInit_(z_streamp strm, int windowBits, + unsigned char FAR *window, + const char *version, + int stream_size); #ifdef Z_PREFIX_SET # define z_deflateInit(strm, level) \ deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream)) @@ -1836,7 +1839,7 @@ struct gzFile_s { unsigned char *next; z_off64_t pos; }; -ZEXTERN int ZEXPORT gzgetc_ OF((gzFile file)); /* backward compatibility */ +ZEXTERN int ZEXPORT gzgetc_(gzFile file); /* backward compatibility */ #ifdef Z_PREFIX_SET # undef z_gzgetc # define z_gzgetc(g) \ @@ -1853,13 +1856,13 @@ ZEXTERN int ZEXPORT gzgetc_ OF((gzFile file)); /* backward compatibility */ * without large file support, _LFS64_LARGEFILE must also be true */ #ifdef Z_LARGE64 - ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *)); - ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int)); - ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile)); - ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile)); - ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off64_t)); - ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off64_t)); - ZEXTERN uLong ZEXPORT crc32_combine_gen64 OF((z_off64_t)); + ZEXTERN gzFile ZEXPORT gzopen64(const char *, const char *); + ZEXTERN z_off64_t ZEXPORT gzseek64(gzFile, z_off64_t, int); + ZEXTERN z_off64_t ZEXPORT gztell64(gzFile); + ZEXTERN z_off64_t ZEXPORT gzoffset64(gzFile); + ZEXTERN uLong ZEXPORT adler32_combine64(uLong, uLong, z_off64_t); + ZEXTERN uLong ZEXPORT crc32_combine64(uLong, uLong, z_off64_t); + ZEXTERN uLong ZEXPORT crc32_combine_gen64(z_off64_t); #endif #if !defined(ZLIB_INTERNAL) && defined(Z_WANT64) @@ -1881,53 +1884,50 @@ ZEXTERN int ZEXPORT gzgetc_ OF((gzFile file)); /* backward compatibility */ # define crc32_combine_gen crc32_combine_gen64 # endif # ifndef Z_LARGE64 - ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *)); - ZEXTERN z_off_t ZEXPORT gzseek64 OF((gzFile, z_off_t, int)); - ZEXTERN z_off_t ZEXPORT gztell64 OF((gzFile)); - ZEXTERN z_off_t ZEXPORT gzoffset64 OF((gzFile)); - ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t)); - ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t)); - ZEXTERN uLong ZEXPORT crc32_combine_gen64 OF((z_off_t)); + ZEXTERN gzFile ZEXPORT gzopen64(const char *, const char *); + ZEXTERN z_off_t ZEXPORT gzseek64(gzFile, z_off_t, int); + ZEXTERN z_off_t ZEXPORT gztell64(gzFile); + ZEXTERN z_off_t ZEXPORT gzoffset64(gzFile); + ZEXTERN uLong ZEXPORT adler32_combine64(uLong, uLong, z_off_t); + ZEXTERN uLong ZEXPORT crc32_combine64(uLong, uLong, z_off_t); + ZEXTERN uLong ZEXPORT crc32_combine_gen64(z_off_t); # endif #else - ZEXTERN gzFile ZEXPORT gzopen OF((const char *, const char *)); - ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile, z_off_t, int)); - ZEXTERN z_off_t ZEXPORT gztell OF((gzFile)); - ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile)); - ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t)); - ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off64_t)); - ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t)); - ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off64_t)); - ZEXTERN uLong ZEXPORT crc32_combine_gen OF((z_off_t)); - ZEXTERN uLong ZEXPORT crc32_combine_gen64 OF((z_off64_t)); + ZEXTERN gzFile ZEXPORT gzopen(const char *, const char *); + ZEXTERN z_off_t ZEXPORT gzseek(gzFile, z_off_t, int); + ZEXTERN z_off_t ZEXPORT gztell(gzFile); + ZEXTERN z_off_t ZEXPORT gzoffset(gzFile); + ZEXTERN uLong ZEXPORT adler32_combine(uLong, uLong, z_off_t); + ZEXTERN uLong ZEXPORT crc32_combine(uLong, uLong, z_off_t); + ZEXTERN uLong ZEXPORT crc32_combine_gen(z_off_t); #endif #else /* Z_SOLO */ - ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t)); - ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t)); - ZEXTERN uLong ZEXPORT crc32_combine_gen OF((z_off_t)); + ZEXTERN uLong ZEXPORT adler32_combine(uLong, uLong, z_off_t); + ZEXTERN uLong ZEXPORT crc32_combine(uLong, uLong, z_off_t); + ZEXTERN uLong ZEXPORT crc32_combine_gen(z_off_t); #endif /* !Z_SOLO */ /* undocumented functions */ -ZEXTERN const char * ZEXPORT zError OF((int)); -ZEXTERN int ZEXPORT inflateSyncPoint OF((z_streamp)); -ZEXTERN const z_crc_t FAR * ZEXPORT get_crc_table OF((void)); -ZEXTERN int ZEXPORT inflateUndermine OF((z_streamp, int)); -ZEXTERN int ZEXPORT inflateValidate OF((z_streamp, int)); -ZEXTERN unsigned long ZEXPORT inflateCodesUsed OF ((z_streamp)); -ZEXTERN int ZEXPORT inflateResetKeep OF((z_streamp)); -ZEXTERN int ZEXPORT deflateResetKeep OF((z_streamp)); +ZEXTERN const char * ZEXPORT zError(int); +ZEXTERN int ZEXPORT inflateSyncPoint(z_streamp); +ZEXTERN const z_crc_t FAR * ZEXPORT get_crc_table(void); +ZEXTERN int ZEXPORT inflateUndermine(z_streamp, int); +ZEXTERN int ZEXPORT inflateValidate(z_streamp, int); +ZEXTERN unsigned long ZEXPORT inflateCodesUsed(z_streamp); +ZEXTERN int ZEXPORT inflateResetKeep(z_streamp); +ZEXTERN int ZEXPORT deflateResetKeep(z_streamp); #if defined(_WIN32) && !defined(Z_SOLO) -ZEXTERN gzFile ZEXPORT gzopen_w OF((const wchar_t *path, - const char *mode)); +ZEXTERN gzFile ZEXPORT gzopen_w(const wchar_t *path, + const char *mode); #endif #if defined(STDC) || defined(Z_HAVE_STDARG_H) # ifndef Z_SOLO -ZEXTERN int ZEXPORTVA gzvprintf Z_ARG((gzFile file, - const char *format, - va_list va)); +ZEXTERN int ZEXPORTVA gzvprintf(gzFile file, + const char *format, + va_list va); # endif #endif diff --git a/deps/zlib/zutil.c b/deps/zlib/zutil.c index dcab28a0d51..b1c5d2d3c6d 100644 --- a/deps/zlib/zutil.c +++ b/deps/zlib/zutil.c @@ -24,13 +24,11 @@ z_const char * const z_errmsg[10] = { }; -const char * ZEXPORT zlibVersion() -{ +const char * ZEXPORT zlibVersion(void) { return ZLIB_VERSION; } -uLong ZEXPORT zlibCompileFlags() -{ +uLong ZEXPORT zlibCompileFlags(void) { uLong flags; flags = 0; @@ -61,9 +59,11 @@ uLong ZEXPORT zlibCompileFlags() #ifdef ZLIB_DEBUG flags += 1 << 8; #endif + /* #if defined(ASMV) || defined(ASMINF) flags += 1 << 9; #endif + */ #ifdef ZLIB_WINAPI flags += 1 << 10; #endif @@ -119,9 +119,7 @@ uLong ZEXPORT zlibCompileFlags() # endif int ZLIB_INTERNAL z_verbose = verbose; -void ZLIB_INTERNAL z_error (m) - char *m; -{ +void ZLIB_INTERNAL z_error(char *m) { fprintf(stderr, "%s\n", m); exit(1); } @@ -130,9 +128,7 @@ void ZLIB_INTERNAL z_error (m) /* exported to allow conversion of error code to string for compress() and * uncompress() */ -const char * ZEXPORT zError(err) - int err; -{ +const char * ZEXPORT zError(int err) { return ERR_MSG(err); } @@ -146,22 +142,14 @@ const char * ZEXPORT zError(err) #ifndef HAVE_MEMCPY -void ZLIB_INTERNAL zmemcpy(dest, source, len) - Bytef* dest; - const Bytef* source; - uInt len; -{ +void ZLIB_INTERNAL zmemcpy(Bytef* dest, const Bytef* source, uInt len) { if (len == 0) return; do { *dest++ = *source++; /* ??? to be unrolled */ } while (--len != 0); } -int ZLIB_INTERNAL zmemcmp(s1, s2, len) - const Bytef* s1; - const Bytef* s2; - uInt len; -{ +int ZLIB_INTERNAL zmemcmp(const Bytef* s1, const Bytef* s2, uInt len) { uInt j; for (j = 0; j < len; j++) { @@ -170,10 +158,7 @@ int ZLIB_INTERNAL zmemcmp(s1, s2, len) return 0; } -void ZLIB_INTERNAL zmemzero(dest, len) - Bytef* dest; - uInt len; -{ +void ZLIB_INTERNAL zmemzero(Bytef* dest, uInt len) { if (len == 0) return; do { *dest++ = 0; /* ??? to be unrolled */ @@ -214,8 +199,7 @@ local ptr_table table[MAX_PTR]; * a protected system like OS/2. Use Microsoft C instead. */ -voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, unsigned items, unsigned size) -{ +voidpf ZLIB_INTERNAL zcalloc(voidpf opaque, unsigned items, unsigned size) { voidpf buf; ulg bsize = (ulg)items*size; @@ -240,8 +224,7 @@ voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, unsigned items, unsigned size) return buf; } -void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr) -{ +void ZLIB_INTERNAL zcfree(voidpf opaque, voidpf ptr) { int n; (void)opaque; @@ -277,14 +260,12 @@ void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr) # define _hfree hfree #endif -voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, uInt items, uInt size) -{ +voidpf ZLIB_INTERNAL zcalloc(voidpf opaque, uInt items, uInt size) { (void)opaque; return _halloc((long)items, size); } -void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr) -{ +void ZLIB_INTERNAL zcfree(voidpf opaque, voidpf ptr) { (void)opaque; _hfree(ptr); } @@ -297,25 +278,18 @@ void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr) #ifndef MY_ZCALLOC /* Any system without a special alloc function */ #ifndef STDC -extern voidp malloc OF((uInt size)); -extern voidp calloc OF((uInt items, uInt size)); -extern void free OF((voidpf ptr)); +extern voidp malloc(uInt size); +extern voidp calloc(uInt items, uInt size); +extern void free(voidpf ptr); #endif -voidpf ZLIB_INTERNAL zcalloc (opaque, items, size) - voidpf opaque; - unsigned items; - unsigned size; -{ +voidpf ZLIB_INTERNAL zcalloc(voidpf opaque, unsigned items, unsigned size) { (void)opaque; return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) : (voidpf)calloc(items, size); } -void ZLIB_INTERNAL zcfree (opaque, ptr) - voidpf opaque; - voidpf ptr; -{ +void ZLIB_INTERNAL zcfree(voidpf opaque, voidpf ptr) { (void)opaque; free(ptr); } diff --git a/deps/zlib/zutil.h b/deps/zlib/zutil.h index d9a20ae1bf4..902a304cc2d 100644 --- a/deps/zlib/zutil.h +++ b/deps/zlib/zutil.h @@ -191,8 +191,9 @@ extern z_const char * const z_errmsg[10]; /* indexed by 2-zlib_error */ /* provide prototypes for these when building zlib without LFS */ #if !defined(_WIN32) && \ (!defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0) - ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t)); - ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t)); + ZEXTERN uLong ZEXPORT adler32_combine64(uLong, uLong, z_off_t); + ZEXTERN uLong ZEXPORT crc32_combine64(uLong, uLong, z_off_t); + ZEXTERN uLong ZEXPORT crc32_combine_gen64(z_off_t); #endif /* common defaults */ @@ -231,16 +232,16 @@ extern z_const char * const z_errmsg[10]; /* indexed by 2-zlib_error */ # define zmemzero(dest, len) memset(dest, 0, len) # endif #else - void ZLIB_INTERNAL zmemcpy OF((Bytef* dest, const Bytef* source, uInt len)); - int ZLIB_INTERNAL zmemcmp OF((const Bytef* s1, const Bytef* s2, uInt len)); - void ZLIB_INTERNAL zmemzero OF((Bytef* dest, uInt len)); + void ZLIB_INTERNAL zmemcpy(Bytef* dest, const Bytef* source, uInt len); + int ZLIB_INTERNAL zmemcmp(const Bytef* s1, const Bytef* s2, uInt len); + void ZLIB_INTERNAL zmemzero(Bytef* dest, uInt len); #endif /* Diagnostic functions */ #ifdef ZLIB_DEBUG # include extern int ZLIB_INTERNAL z_verbose; - extern void ZLIB_INTERNAL z_error OF((char *m)); + extern void ZLIB_INTERNAL z_error(char *m); # define Assert(cond,msg) {if(!(cond)) z_error(msg);} # define Trace(x) {if (z_verbose>=0) fprintf x ;} # define Tracev(x) {if (z_verbose>0) fprintf x ;} @@ -257,9 +258,9 @@ extern z_const char * const z_errmsg[10]; /* indexed by 2-zlib_error */ #endif #ifndef Z_SOLO - voidpf ZLIB_INTERNAL zcalloc OF((voidpf opaque, unsigned items, - unsigned size)); - void ZLIB_INTERNAL zcfree OF((voidpf opaque, voidpf ptr)); + voidpf ZLIB_INTERNAL zcalloc(voidpf opaque, unsigned items, + unsigned size); + void ZLIB_INTERNAL zcfree(voidpf opaque, voidpf ptr); #endif #define ZALLOC(strm, items, size) \ From f004096fff7c00f7ff17f8232f4d2d65ba4c546f Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Wed, 20 Dec 2023 11:20:45 +0000 Subject: [PATCH 435/608] examples: use unsigned int for bitfields --- examples/args.h | 2 +- examples/checkout.c | 6 +++--- examples/merge.c | 2 +- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/examples/args.h b/examples/args.h index d626f98c8a7..4db0493bb2d 100644 --- a/examples/args.h +++ b/examples/args.h @@ -8,7 +8,7 @@ struct args_info { int argc; char **argv; int pos; - int opts_done : 1; /**< Did we see a -- separator */ + unsigned int opts_done : 1; /**< Did we see a -- separator */ }; #define ARGS_INFO_INIT { argc, argv, 0, 0 } #define ARGS_CURRENT(args) args->argv[args->pos] diff --git a/examples/checkout.c b/examples/checkout.c index ac7b7422d7b..82567cdc432 100644 --- a/examples/checkout.c +++ b/examples/checkout.c @@ -35,9 +35,9 @@ */ typedef struct { - int force : 1; - int progress : 1; - int perf : 1; + unsigned int force : 1; + unsigned int progress : 1; + unsigned int perf : 1; } checkout_options; static void print_usage(void) diff --git a/examples/merge.c b/examples/merge.c index 460c06a2567..7a76912cd24 100644 --- a/examples/merge.c +++ b/examples/merge.c @@ -30,7 +30,7 @@ struct merge_options { git_annotated_commit **annotated; size_t annotated_count; - int no_commit : 1; + unsigned int no_commit : 1; }; static void print_usage(void) From 032a8c2d5c75a3c23888a7e809e536636dfd54d5 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Wed, 20 Dec 2023 16:36:30 +0000 Subject: [PATCH 436/608] util: our strcmp cb should use git__strcmp --- src/util/util.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/util/util.c b/src/util/util.c index c8e8303afe1..e86bceeb5a8 100644 --- a/src/util/util.c +++ b/src/util/util.c @@ -623,12 +623,12 @@ int git__bsearch_r( */ int git__strcmp_cb(const void *a, const void *b) { - return strcmp((const char *)a, (const char *)b); + return git__strcmp((const char *)a, (const char *)b); } int git__strcasecmp_cb(const void *a, const void *b) { - return strcasecmp((const char *)a, (const char *)b); + return git__strcasecmp((const char *)a, (const char *)b); } int git__parse_bool(int *out, const char *value) From 6816f30cbecab8224e716db5d449767feb20a8b7 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Wed, 20 Dec 2023 13:34:25 +0000 Subject: [PATCH 437/608] Use the correct function definition for function pointers Passing a function pointer with different parameters is UB, even if those params are (void *). Use our separate `_cb` functions that will do the correct casting. --- src/libgit2/iterator.c | 14 ++++++++++---- src/libgit2/refs.c | 6 ++++++ src/libgit2/refs.h | 6 ++++++ tests/libgit2/iterator/workdir.c | 6 +++--- tests/libgit2/network/remote/rename.c | 2 +- tests/libgit2/odb/sorting.c | 7 ++++++- 6 files changed, 32 insertions(+), 9 deletions(-) diff --git a/src/libgit2/iterator.c b/src/libgit2/iterator.c index 95ded1046dc..bef9c609079 100644 --- a/src/libgit2/iterator.c +++ b/src/libgit2/iterator.c @@ -26,9 +26,10 @@ #define iterator__ignore_dot_git(I) iterator__flag(I,IGNORE_DOT_GIT) #define iterator__descend_symlinks(I) iterator__flag(I,DESCEND_SYMLINKS) - static void iterator_set_ignore_case(git_iterator *iter, bool ignore_case) { + int (*vector_cmp)(const void *a, const void *b); + if (ignore_case) iter->flags |= GIT_ITERATOR_IGNORE_CASE; else @@ -39,7 +40,9 @@ static void iterator_set_ignore_case(git_iterator *iter, bool ignore_case) iter->prefixcomp = ignore_case ? git__prefixcmp_icase : git__prefixcmp; iter->entry_srch = ignore_case ? git_index_entry_isrch : git_index_entry_srch; - git_vector_set_cmp(&iter->pathlist, (git_vector_cmp)iter->strcomp); + vector_cmp = ignore_case ? git__strcasecmp_cb : git__strcmp_cb; + + git_vector_set_cmp(&iter->pathlist, vector_cmp); } static int iterator_range_init( @@ -299,6 +302,7 @@ typedef enum { static iterator_pathlist_search_t iterator_pathlist_search( git_iterator *iter, const char *path, size_t path_len) { + int (*vector_cmp)(const void *a, const void *b); const char *p; size_t idx; int error; @@ -308,8 +312,10 @@ static iterator_pathlist_search_t iterator_pathlist_search( git_vector_sort(&iter->pathlist); - error = git_vector_bsearch2(&idx, &iter->pathlist, - (git_vector_cmp)iter->strcomp, path); + vector_cmp = (iter->flags & GIT_ITERATOR_IGNORE_CASE) != 0 ? + git__strcasecmp_cb : git__strcmp_cb; + + error = git_vector_bsearch2(&idx, &iter->pathlist, vector_cmp, path); /* the given path was found in the pathlist. since the pathlist only * matches directories when they're suffixed with a '/', analyze the diff --git a/src/libgit2/refs.c b/src/libgit2/refs.c index 5e2fe97e76f..c1ed04d233a 100644 --- a/src/libgit2/refs.c +++ b/src/libgit2/refs.c @@ -1080,6 +1080,12 @@ int git_reference_cmp( return git_oid__cmp(&ref1->target.oid, &ref2->target.oid); } +int git_reference__cmp_cb(const void *a, const void *b) +{ + return git_reference_cmp( + (const git_reference *)a, (const git_reference *)b); +} + /* * Starting with the reference given by `ref_name`, follows symbolic * references until a direct reference is found and updated the OID diff --git a/src/libgit2/refs.h b/src/libgit2/refs.h index cb888bf8f49..588af82fe40 100644 --- a/src/libgit2/refs.h +++ b/src/libgit2/refs.h @@ -92,6 +92,12 @@ int git_reference__is_tag(const char *ref_name); int git_reference__is_note(const char *ref_name); const char *git_reference__shorthand(const char *name); +/* + * A `git_reference_cmp` wrapper suitable for passing to generic + * comparators, like `vector_cmp` / `tsort` / etc. + */ +int git_reference__cmp_cb(const void *a, const void *b); + /** * Lookup a reference by name and try to resolve to an OID. * diff --git a/tests/libgit2/iterator/workdir.c b/tests/libgit2/iterator/workdir.c index 7634997e1e5..af47d8b3601 100644 --- a/tests/libgit2/iterator/workdir.c +++ b/tests/libgit2/iterator/workdir.c @@ -585,9 +585,9 @@ void test_iterator_workdir__filesystem(void) expect_iterator_items(i, 5, expect_noauto, 18, expect_trees); git_iterator_free(i); - git__tsort((void **)expect_base, 8, (git__tsort_cmp)git__strcasecmp); - git__tsort((void **)expect_trees, 18, (git__tsort_cmp)git__strcasecmp); - git__tsort((void **)expect_noauto, 5, (git__tsort_cmp)git__strcasecmp); + git__tsort((void **)expect_base, 8, git__strcasecmp_cb); + git__tsort((void **)expect_trees, 18, git__strcasecmp_cb); + git__tsort((void **)expect_noauto, 5, git__strcasecmp_cb); i_opts.flags = GIT_ITERATOR_IGNORE_CASE; cl_git_pass(git_iterator_for_filesystem(&i, "status/subdir", &i_opts)); diff --git a/tests/libgit2/network/remote/rename.c b/tests/libgit2/network/remote/rename.c index b071f9ceffe..21ea216545c 100644 --- a/tests/libgit2/network/remote/rename.c +++ b/tests/libgit2/network/remote/rename.c @@ -216,7 +216,7 @@ void test_network_remote_rename__symref_head(void) cl_assert_equal_i(0, problems.count); git_strarray_dispose(&problems); - cl_git_pass(git_vector_init(&refs, 2, (git_vector_cmp) git_reference_cmp)); + cl_git_pass(git_vector_init(&refs, 2, git_reference__cmp_cb)); cl_git_pass(git_branch_iterator_new(&iter, _repo, GIT_BRANCH_REMOTE)); while ((error = git_branch_next(&ref, &btype, iter)) == 0) { diff --git a/tests/libgit2/odb/sorting.c b/tests/libgit2/odb/sorting.c index ec4e3696ba1..3fe52e852cd 100644 --- a/tests/libgit2/odb/sorting.c +++ b/tests/libgit2/odb/sorting.c @@ -7,6 +7,11 @@ typedef struct { size_t position; } fake_backend; +static void odb_backend_free(git_odb_backend *odb) +{ + git__free(odb); +} + static git_odb_backend *new_backend(size_t position) { fake_backend *b; @@ -15,7 +20,7 @@ static git_odb_backend *new_backend(size_t position) if (b == NULL) return NULL; - b->base.free = (void (*)(git_odb_backend *)) git__free; + b->base.free = odb_backend_free; b->base.version = GIT_ODB_BACKEND_VERSION; b->position = position; return (git_odb_backend *)b; From 01d2adcb605e10e9fdc803a4c683c315f67566f1 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Wed, 20 Dec 2023 16:12:35 +0000 Subject: [PATCH 438/608] remote: pass the commit not its id in tests `git_commit_create_v` takes _commits_ not _commit ids_. Fix the test to call the API correctly. --- tests/libgit2/remote/fetch.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/tests/libgit2/remote/fetch.c b/tests/libgit2/remote/fetch.c index 85e99206fdc..a5d3272c56b 100644 --- a/tests/libgit2/remote/fetch.c +++ b/tests/libgit2/remote/fetch.c @@ -75,6 +75,7 @@ static void do_time_travelling_fetch(git_oid *commit1id, git_oid *commit2id, /* create two commits in repo 1 and a reference to them */ { git_oid empty_tree_id; + git_commit *commit1; git_tree *empty_tree; git_signature *sig; git_treebuilder *tb; @@ -84,10 +85,12 @@ static void do_time_travelling_fetch(git_oid *commit1id, git_oid *commit2id, cl_git_pass(git_signature_default(&sig, repo1)); cl_git_pass(git_commit_create(commit1id, repo1, REPO1_REFNAME, sig, sig, NULL, "one", empty_tree, 0, NULL)); + cl_git_pass(git_commit_lookup(&commit1, repo1, commit1id)); cl_git_pass(git_commit_create_v(commit2id, repo1, REPO1_REFNAME, sig, - sig, NULL, "two", empty_tree, 1, commit1id)); + sig, NULL, "two", empty_tree, 1, commit1)); git_tree_free(empty_tree); + git_commit_free(commit1); git_signature_free(sig); git_treebuilder_free(tb); } From a80c52693545f7bcf6d4ad3ef189e08aa76ce27d Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 21 Dec 2023 13:27:27 +0000 Subject: [PATCH 439/608] diff: move non-blob handling out of is_target --- src/libgit2/diff_tform.c | 41 ++++++++++++++++++++++++++++------------ 1 file changed, 29 insertions(+), 12 deletions(-) diff --git a/src/libgit2/diff_tform.c b/src/libgit2/diff_tform.c index a90ab07c9b9..9fa3cef8358 100644 --- a/src/libgit2/diff_tform.c +++ b/src/libgit2/diff_tform.c @@ -653,6 +653,23 @@ static int calc_self_similarity( return 0; } +static void handle_non_blob( + git_diff *diff, + const git_diff_find_options *opts, + size_t delta_idx) +{ + git_diff_delta *delta = GIT_VECTOR_GET(&diff->deltas, delta_idx); + + /* skip things that are blobs */ + if (GIT_MODE_ISBLOB(delta->old_file.mode)) + return; + + /* honor "remove unmodified" flag for non-blobs (eg submodules) */ + if (delta->status == GIT_DELTA_UNMODIFIED && + FLAG_SET(opts, GIT_DIFF_FIND_REMOVE_UNMODIFIED)) + delta->flags |= GIT_DIFF_FLAG__TO_DELETE; +} + static bool is_rename_target( git_diff *diff, const git_diff_find_options *opts, @@ -718,15 +735,8 @@ static bool is_rename_source( git_diff_delta *delta = GIT_VECTOR_GET(&diff->deltas, delta_idx); /* skip things that aren't blobs */ - if (!GIT_MODE_ISBLOB(delta->old_file.mode)) { - - /* but still honor "remove unmodified" flag */ - if (delta->status == GIT_DELTA_UNMODIFIED && - FLAG_SET(opts, GIT_DIFF_FIND_REMOVE_UNMODIFIED)) - delta->flags |= GIT_DIFF_FLAG__TO_DELETE; - + if (!GIT_MODE_ISBLOB(delta->old_file.mode)) return false; - } switch (delta->status) { case GIT_DELTA_ADDED: @@ -817,7 +827,8 @@ int git_diff_find_similar( git_diff_find_options opts = GIT_DIFF_FIND_OPTIONS_INIT; size_t num_deltas, num_srcs = 0, num_tgts = 0; size_t tried_srcs = 0, tried_tgts = 0; - size_t num_rewrites = 0, num_updates = 0, num_bumped = 0, num_to_delete = 0; + size_t num_rewrites = 0, num_updates = 0, num_bumped = 0, + num_to_delete = 0; size_t sigcache_size; void **sigcache = NULL; /* cache of similarity metric file signatures */ diff_find_match *tgt2src = NULL; @@ -851,6 +862,8 @@ int git_diff_find_similar( * mark them for splitting if break-rewrites is enabled */ git_vector_foreach(&diff->deltas, t, tgt) { + handle_non_blob(diff, &opts, t); + if (is_rename_source(diff, &opts, t, sigcache)) ++num_srcs; @@ -861,7 +874,7 @@ int git_diff_find_similar( num_rewrites++; if ((tgt->flags & GIT_DIFF_FLAG__TO_DELETE) != 0) - num_to_delete++; + num_to_delete++; } /* If there are no candidate srcs or tgts, no need to find matches */ @@ -1108,11 +1121,15 @@ int git_diff_find_similar( * Actually split and delete entries as needed */ - if (num_rewrites > 0 || num_updates > 0 || num_to_delete > 0) + if (num_rewrites > 0 || num_updates > 0 || num_to_delete > 0) { + size_t apply_len = diff->deltas.length - + num_rewrites - num_to_delete; + error = apply_splits_and_deletes( - diff, diff->deltas.length - num_rewrites - num_to_delete, + diff, apply_len, FLAG_SET(&opts, GIT_DIFF_BREAK_REWRITES) && !FLAG_SET(&opts, GIT_DIFF_BREAK_REWRITES_FOR_RENAMES_ONLY)); + } cleanup: git__free(tgt2src); From 52daefc6f34b52820df2191e79c1dfb43e826b2f Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Wed, 20 Dec 2023 22:19:54 +0000 Subject: [PATCH 440/608] httpclient: clear client->parser.data after use Some static code analysis complains that we're putting a stack variable into client->parser.data (which persists past the function calls). Clear that on function exit to avoid confusion. --- src/libgit2/transports/httpclient.c | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/libgit2/transports/httpclient.c b/src/libgit2/transports/httpclient.c index 278d7c8e0ab..e22a07ba1a0 100644 --- a/src/libgit2/transports/httpclient.c +++ b/src/libgit2/transports/httpclient.c @@ -1252,6 +1252,7 @@ static void complete_response_body(git_http_client *client) } done: + client->parser.data = NULL; git_str_clear(&client->read_buf); } @@ -1441,6 +1442,7 @@ int git_http_client_read_response( done: git_str_dispose(&parser_context.parse_header_name); git_str_dispose(&parser_context.parse_header_value); + client->parser.data = NULL; return error; } @@ -1496,6 +1498,8 @@ int git_http_client_read_body( if (error < 0) client->connected = 0; + client->parser.data = NULL; + return error; } @@ -1530,6 +1534,8 @@ int git_http_client_skip_body(git_http_client *client) if (error < 0) client->connected = 0; + client->parser.data = NULL; + return error; } From 66f587b5260a9e28a36d40696171e16afd15d652 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Wed, 20 Dec 2023 21:50:13 +0000 Subject: [PATCH 441/608] ntlmclient: update to latest upstream ntlmclient --- deps/ntlmclient/unicode_builtin.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/deps/ntlmclient/unicode_builtin.c b/deps/ntlmclient/unicode_builtin.c index e2ee0abf71e..6d398b7c9f8 100644 --- a/deps/ntlmclient/unicode_builtin.c +++ b/deps/ntlmclient/unicode_builtin.c @@ -372,13 +372,13 @@ static inline bool unicode_builtin_encoding_convert( goto done; } + out_len = out_start - out; + if ((new_out = realloc(out, out_size)) == NULL) { ntlm_client_set_errmsg(ntlm, "out of memory"); goto done; } - out_len = out_start - out; - out = new_out; out_start = new_out + out_len; out_end = out + out_size; From edeec76a29912b3fdcd566ebc422fd47b32386c7 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 21 Dec 2023 17:00:52 +0000 Subject: [PATCH 442/608] ci: update all images to use libssh2 v1.11.0 --- ci/docker/centos7 | 6 +++--- ci/docker/centos8 | 6 +++--- ci/docker/focal | 2 +- ci/docker/xenial | 8 ++++---- 4 files changed, 11 insertions(+), 11 deletions(-) diff --git a/ci/docker/centos7 b/ci/docker/centos7 index 28ed650811c..45c299d10bb 100644 --- a/ci/docker/centos7 +++ b/ci/docker/centos7 @@ -18,13 +18,13 @@ RUN yum install -y \ FROM yum AS libssh2 RUN cd /tmp && \ - curl --location --silent --show-error https://www.libssh2.org/download/libssh2-1.8.0.tar.gz | tar -xz && \ - cd libssh2-1.8.0 && \ + curl --location --silent --show-error https://www.libssh2.org/download/libssh2-1.11.0.tar.gz | tar -xz && \ + cd libssh2-1.11.0 && \ ./configure && \ make && \ make install && \ cd .. && \ - rm -rf libssh-1.8.0 + rm -rf libssh-1.11.0 FROM libssh2 AS valgrind RUN cd /tmp && \ diff --git a/ci/docker/centos8 b/ci/docker/centos8 index 81f0c3c7698..c2ac5f07af3 100644 --- a/ci/docker/centos8 +++ b/ci/docker/centos8 @@ -24,13 +24,13 @@ RUN yum install -y \ FROM yum AS libssh2 RUN cd /tmp && \ - curl --location --silent --show-error https://www.libssh2.org/download/libssh2-1.8.0.tar.gz | tar -xz && \ - cd libssh2-1.8.0 && \ + curl --location --silent --show-error https://www.libssh2.org/download/libssh2-1.11.0.tar.gz | tar -xz && \ + cd libssh2-1.11.0 && \ ./configure && \ make && \ make install && \ cd .. && \ - rm -rf libssh2-1.8.0 + rm -rf libssh2-1.11.0 FROM libssh2 AS valgrind RUN cd /tmp && \ diff --git a/ci/docker/focal b/ci/docker/focal index b3a402cb011..62f5b6301ae 100644 --- a/ci/docker/focal +++ b/ci/docker/focal @@ -53,7 +53,7 @@ RUN cd /tmp && \ cd libssh2-1.9.0 && \ mkdir build build-msan && \ cd build && \ - CC=clang-10 CFLAGS="-fPIC" cmake -G Ninja -DBUILD_SHARED_LIBS=ON -DCRYPTO_BACKEND=Libgcrypt -DCMAKE_PREFIX_PATH=/usr/local -DCMAKE_INSTALL_PREFIX=/usr/local .. && \ + CC=clang-10 CFLAGS="-fPIC" cmake -G Ninja -DBUILD_SHARED_LIBS=ON -DCMAKE_PREFIX_PATH=/usr/local -DCMAKE_INSTALL_PREFIX=/usr/local .. && \ ninja install && \ cd ../build-msan && \ CC=clang-10 CFLAGS="-fPIC -fsanitize=memory -fno-optimize-sibling-calls -fsanitize-memory-track-origins=2 -fno-omit-frame-pointer" LDFLAGS="-fsanitize=memory" cmake -G Ninja -DBUILD_SHARED_LIBS=ON -DCRYPTO_BACKEND=mbedTLS -DCMAKE_PREFIX_PATH=/usr/local/msan -DCMAKE_INSTALL_PREFIX=/usr/local/msan .. && \ diff --git a/ci/docker/xenial b/ci/docker/xenial index 578f0a962a9..793df4bda50 100644 --- a/ci/docker/xenial +++ b/ci/docker/xenial @@ -53,12 +53,12 @@ RUN cd /tmp && \ FROM mbedtls AS libssh2 RUN cd /tmp && \ - curl --location --silent --show-error https://www.libssh2.org/download/libssh2-1.8.2.tar.gz | tar -xz && \ - cd libssh2-1.8.2 && \ - CFLAGS=-fPIC cmake -G Ninja -DBUILD_SHARED_LIBS=ON -DCRYPTO_BACKEND=Libgcrypt . && \ + curl --location --silent --show-error https://www.libssh2.org/download/libssh2-1.11.0.tar.gz | tar -xz && \ + cd libssh2-1.11.0 && \ + CFLAGS=-fPIC cmake -G Ninja -DBUILD_SHARED_LIBS=ON . && \ ninja install && \ cd .. && \ - rm -rf libssh2-1.8.2 + rm -rf libssh2-1.11.0 FROM libssh2 AS valgrind RUN cd /tmp && \ From 4da4bea79f5a0bb1c77b6670af8400b9bf9708a9 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Wed, 20 Dec 2023 10:21:27 +0000 Subject: [PATCH 443/608] ci: add an Ubuntu Noble dockerfile --- ci/docker/noble | 88 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 88 insertions(+) create mode 100644 ci/docker/noble diff --git a/ci/docker/noble b/ci/docker/noble new file mode 100644 index 00000000000..05cd2768fe4 --- /dev/null +++ b/ci/docker/noble @@ -0,0 +1,88 @@ +ARG BASE=ubuntu:noble + +FROM ${BASE} AS apt +RUN apt-get update && \ + DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends \ + bzip2 \ + clang \ + cmake \ + curl \ + gcc \ + git \ + krb5-user \ + libclang-rt-17-dev \ + libcurl4-gnutls-dev \ + libgcrypt20-dev \ + libkrb5-dev \ + libpcre3-dev \ + libssl-dev \ + libz-dev \ + llvm-17 \ + make \ + ninja-build \ + openjdk-8-jre-headless \ + openssh-server \ + openssl \ + pkgconf \ + python3 \ + sudo \ + valgrind \ + && \ + rm -rf /var/lib/apt/lists/* && \ + mkdir /usr/local/msan + +FROM apt AS mbedtls +RUN cd /tmp && \ + curl --location --silent --show-error https://github.com/Mbed-TLS/mbedtls/archive/refs/tags/mbedtls-2.28.6.tar.gz | \ + tar -xz && \ + cd mbedtls-mbedtls-2.28.6 && \ + scripts/config.pl unset MBEDTLS_AESNI_C && \ + scripts/config.pl set MBEDTLS_MD4_C 1 && \ + mkdir build build-msan && \ + cd build && \ + CC=clang-17 CFLAGS="-fPIC" cmake -G Ninja -DENABLE_PROGRAMS=OFF -DENABLE_TESTING=OFF -DUSE_SHARED_MBEDTLS_LIBRARY=ON -DUSE_STATIC_MBEDTLS_LIBRARY=OFF -DCMAKE_BUILD_TYPE=Debug -DCMAKE_PREFIX_PATH=/usr/local -DCMAKE_INSTALL_PREFIX=/usr/local .. && \ + ninja install && \ + cd ../build-msan && \ + CC=clang-17 CFLAGS="-fPIC" cmake -G Ninja -DENABLE_PROGRAMS=OFF -DENABLE_TESTING=OFF -DUSE_SHARED_MBEDTLS_LIBRARY=ON -DUSE_STATIC_MBEDTLS_LIBRARY=OFF -DCMAKE_BUILD_TYPE=MemSanDbg -DCMAKE_INSTALL_PREFIX=/usr/local/msan .. && \ + ninja install && \ + cd .. && \ + rm -rf mbedtls-mbedtls-2.28.6 + +FROM mbedtls AS libssh2 +RUN cd /tmp && \ + curl --location --silent --show-error https://www.libssh2.org/download/libssh2-1.11.0.tar.gz | tar -xz && \ + cd libssh2-1.11.0 && \ + mkdir build build-msan && \ + cd build && \ + CC=clang-17 CFLAGS="-fPIC" cmake -G Ninja -DBUILD_SHARED_LIBS=ON -DCMAKE_PREFIX_PATH=/usr/local -DCMAKE_INSTALL_PREFIX=/usr/local .. && \ + ninja install && \ + cd ../build-msan && \ + CC=clang-17 CFLAGS="-fPIC -fsanitize=memory -fno-optimize-sibling-calls -fsanitize-memory-track-origins=2 -fno-omit-frame-pointer" LDFLAGS="-fsanitize=memory" cmake -G Ninja -DBUILD_SHARED_LIBS=ON -DCRYPTO_BACKEND=mbedTLS -DCMAKE_PREFIX_PATH=/usr/local/msan -DCMAKE_INSTALL_PREFIX=/usr/local/msan .. && \ + ninja install && \ + cd .. && \ + rm -rf libssh2-1.11.0 + +FROM libssh2 AS valgrind +RUN cd /tmp && \ + curl --insecure --location --silent --show-error https://sourceware.org/pub/valgrind/valgrind-3.22.0.tar.bz2 | \ + tar -xj && \ + cd valgrind-3.22.0 && \ + CC=clang-17 ./configure && \ + make MAKEFLAGS="-j -l$(grep -c ^processor /proc/cpuinfo)" && \ + make install && \ + cd .. && \ + rm -rf valgrind-3.22.0 + +FROM valgrind AS adduser +ARG UID="" +ARG GID="" +RUN if [ "${UID}" != "" ]; then USER_ARG="--uid ${UID}"; fi && \ + if [ "${GID}" != "" ]; then GROUP_ARG="--gid ${GID}"; fi && \ + groupadd ${GROUP_ARG} libgit2 && \ + useradd ${USER_ARG} --gid libgit2 --shell /bin/bash --create-home libgit2 + +FROM adduser AS ldconfig +RUN ldconfig + +FROM ldconfig AS configure +RUN mkdir /var/run/sshd From 8329f7ace3523df1eb070a3d2690ef1f6e031f41 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Wed, 20 Dec 2023 10:23:35 +0000 Subject: [PATCH 444/608] ci: upgrade focal builds to noble Let's use the latest & greatest for building our sanitizer / fuzzing builds. --- .github/workflows/main.yml | 40 +++++++++++++++--------------- .github/workflows/nightly.yml | 46 +++++++++++++++++------------------ 2 files changed, 43 insertions(+), 43 deletions(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 3aa214cd397..e045bb436f2 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -30,42 +30,42 @@ jobs: matrix: platform: # All builds: core platforms - - name: "Linux (Xenial, GCC, OpenSSL, libssh2)" - id: xenial-gcc-openssl + - name: "Linux (Noble, GCC, OpenSSL, libssh2)" + id: noble-gcc-openssl os: ubuntu-latest container: - name: xenial + name: noble env: CC: gcc CMAKE_GENERATOR: Ninja CMAKE_OPTIONS: -DUSE_HTTPS=OpenSSL -DREGEX_BACKEND=builtin -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=libssh2 -DDEBUG_STRICT_ALLOC=ON -DDEBUG_STRICT_OPEN=ON - - name: Linux (Xenial, GCC, mbedTLS, OpenSSH) - id: xenial-gcc-mbedtls + - name: "Linux (Noble, Clang, mbedTLS, OpenSSH)" + id: noble-clang-mbedtls os: ubuntu-latest container: - name: xenial + name: noble env: - CC: gcc + CC: clang + CMAKE_OPTIONS: -DUSE_HTTPS=mbedTLS -DUSE_SHA1=HTTPS -DREGEX_BACKEND=pcre -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=exec CMAKE_GENERATOR: Ninja - CMAKE_OPTIONS: -DUSE_HTTPS=mbedTLS -DUSE_SHA1=HTTPS -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=exec - - name: "Linux (Xenial, Clang, OpenSSL, OpenSSH)" - id: xenial-clang-openssl + - name: "Linux (Xenial, GCC, OpenSSL, OpenSSH)" + id: xenial-gcc-openssl os: ubuntu-latest container: name: xenial env: - CC: clang + CC: gcc CMAKE_GENERATOR: Ninja - CMAKE_OPTIONS: -DUSE_HTTPS=OpenSSL -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=exec + CMAKE_OPTIONS: -DUSE_HTTPS=OpenSSL -DREGEX_BACKEND=builtin -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=exec -DDEBUG_STRICT_ALLOC=ON -DDEBUG_STRICT_OPEN=ON - name: "Linux (Xenial, Clang, mbedTLS, libssh2)" - id: xenial-clang-mbedtls + id: xenial-gcc-mbedtls os: ubuntu-latest container: name: xenial env: CC: clang - CMAKE_OPTIONS: -DUSE_HTTPS=mbedTLS -DUSE_SHA1=HTTPS -DREGEX_BACKEND=pcre -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=libssh2 CMAKE_GENERATOR: Ninja + CMAKE_OPTIONS: -DUSE_HTTPS=mbedTLS -DUSE_SHA1=HTTPS -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=libssh2 - name: "macOS" id: macos os: macos-12 @@ -130,9 +130,9 @@ jobs: - name: "Sanitizer (Memory)" id: sanitizer-memory container: - name: focal + name: noble env: - CC: clang-10 + CC: clang CFLAGS: -fsanitize=memory -fsanitize-memory-track-origins=2 -fsanitize-blacklist=/home/libgit2/source/script/sanitizers.supp -fno-optimize-sibling-calls -fno-omit-frame-pointer CMAKE_OPTIONS: -DCMAKE_PREFIX_PATH=/usr/local/msan -DUSE_HTTPS=mbedTLS -DUSE_SHA1=HTTPS -DREGEX_BACKEND=pcre -DDEPRECATE_HARD=ON -DUSE_BUNDLED_ZLIB=ON -DUSE_SSH=ON CMAKE_GENERATOR: Ninja @@ -145,9 +145,9 @@ jobs: id: sanitizer-ub os: ubuntu-latest container: - name: focal + name: noble env: - CC: clang-10 + CC: clang CFLAGS: -fsanitize=undefined,nullability -fno-sanitize-recover=undefined,nullability -fsanitize-blacklist=/home/libgit2/source/script/sanitizers.supp -fno-optimize-sibling-calls -fno-omit-frame-pointer CMAKE_OPTIONS: -DCMAKE_PREFIX_PATH=/usr/local -DUSE_HTTPS=OpenSSL -DUSE_SHA1=HTTPS -DREGEX_BACKEND=pcre -DDEPRECATE_HARD=ON -DUSE_BUNDLED_ZLIB=ON -DUSE_SSH=ON CMAKE_GENERATOR: Ninja @@ -159,9 +159,9 @@ jobs: id: sanitizer-thread os: ubuntu-latest container: - name: focal + name: noble env: - CC: clang-10 + CC: clang CFLAGS: -fsanitize=thread -fno-optimize-sibling-calls -fno-omit-frame-pointer CMAKE_OPTIONS: -DCMAKE_PREFIX_PATH=/usr/local -DUSE_HTTPS=OpenSSL -DUSE_SHA1=HTTPS -DREGEX_BACKEND=pcre -DDEPRECATE_HARD=ON -DUSE_BUNDLED_ZLIB=ON -DUSE_SSH=ON CMAKE_GENERATOR: Ninja diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml index aca4506b26b..776b58b12db 100644 --- a/.github/workflows/nightly.yml +++ b/.github/workflows/nightly.yml @@ -27,42 +27,42 @@ jobs: matrix: platform: # All builds: core platforms - - name: "Linux (Xenial, GCC, OpenSSL, libssh2)" - id: xenial-gcc-openssl + - name: "Linux (Noble, GCC, OpenSSL, libssh2)" + id: noble-gcc-openssl os: ubuntu-latest container: - name: xenial + name: noble env: CC: gcc CMAKE_GENERATOR: Ninja CMAKE_OPTIONS: -DUSE_HTTPS=OpenSSL -DREGEX_BACKEND=builtin -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=libssh2 -DDEBUG_STRICT_ALLOC=ON -DDEBUG_STRICT_OPEN=ON - - name: Linux (Xenial, GCC, mbedTLS, OpenSSH) - id: xenial-gcc-mbedtls + - name: "Linux (Noble, Clang, mbedTLS, OpenSSH)" + id: noble-clang-mbedtls os: ubuntu-latest container: - name: xenial + name: noble env: - CC: gcc + CC: clang + CMAKE_OPTIONS: -DUSE_HTTPS=mbedTLS -DUSE_SHA1=HTTPS -DREGEX_BACKEND=pcre -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=exec CMAKE_GENERATOR: Ninja - CMAKE_OPTIONS: -DUSE_HTTPS=mbedTLS -DUSE_SHA1=HTTPS -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=exec - - name: "Linux (Xenial, Clang, OpenSSL, OpenSSH)" - id: xenial-clang-openssl + - name: "Linux (Xenial, GCC, OpenSSL, OpenSSH)" + id: xenial-gcc-openssl os: ubuntu-latest container: name: xenial env: - CC: clang + CC: gcc CMAKE_GENERATOR: Ninja - CMAKE_OPTIONS: -DUSE_HTTPS=OpenSSL -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=exec + CMAKE_OPTIONS: -DUSE_HTTPS=OpenSSL -DREGEX_BACKEND=builtin -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=exec -DDEBUG_STRICT_ALLOC=ON -DDEBUG_STRICT_OPEN=ON - name: "Linux (Xenial, Clang, mbedTLS, libssh2)" - id: xenial-clang-mbedtls + id: xenial-gcc-mbedtls os: ubuntu-latest container: name: xenial env: CC: clang - CMAKE_OPTIONS: -DUSE_HTTPS=mbedTLS -DUSE_SHA1=HTTPS -DREGEX_BACKEND=pcre -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=libssh2 CMAKE_GENERATOR: Ninja + CMAKE_OPTIONS: -DUSE_HTTPS=mbedTLS -DUSE_SHA1=HTTPS -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=libssh2 - name: "macOS" id: macos os: macos-12 @@ -127,9 +127,9 @@ jobs: - name: "Sanitizer (Memory)" id: memorysanitizer container: - name: focal + name: noble env: - CC: clang-10 + CC: clang-17 CFLAGS: -fsanitize=memory -fsanitize-memory-track-origins=2 -fsanitize-blacklist=/home/libgit2/source/script/sanitizers.supp -fno-optimize-sibling-calls -fno-omit-frame-pointer CMAKE_OPTIONS: -DCMAKE_PREFIX_PATH=/usr/local/msan -DUSE_HTTPS=mbedTLS -DUSE_SHA1=HTTPS -DREGEX_BACKEND=pcre -DDEPRECATE_HARD=ON -DUSE_BUNDLED_ZLIB=ON -DUSE_SSH=ON CMAKE_GENERATOR: Ninja @@ -142,9 +142,9 @@ jobs: id: ubsanitizer os: ubuntu-latest container: - name: focal + name: noble env: - CC: clang-10 + CC: clang-17 CFLAGS: -fsanitize=undefined,nullability -fno-sanitize-recover=undefined,nullability -fsanitize-blacklist=/home/libgit2/source/script/sanitizers.supp -fno-optimize-sibling-calls -fno-omit-frame-pointer CMAKE_OPTIONS: -DCMAKE_PREFIX_PATH=/usr/local -DUSE_HTTPS=OpenSSL -DUSE_SHA1=HTTPS -DREGEX_BACKEND=pcre -DDEPRECATE_HARD=ON -DUSE_BUNDLED_ZLIB=ON -DUSE_SSH=ON CMAKE_GENERATOR: Ninja @@ -156,9 +156,9 @@ jobs: id: threadsanitizer os: ubuntu-latest container: - name: focal + name: noble env: - CC: clang-10 + CC: clang-17 CFLAGS: -fsanitize=thread -fno-optimize-sibling-calls -fno-omit-frame-pointer CMAKE_OPTIONS: -DCMAKE_PREFIX_PATH=/usr/local -DUSE_HTTPS=OpenSSL -DUSE_SHA1=HTTPS -DREGEX_BACKEND=pcre -DDEPRECATE_HARD=ON -DUSE_BUNDLED_ZLIB=ON -DUSE_SSH=ON CMAKE_GENERATOR: Ninja @@ -277,12 +277,12 @@ jobs: CMAKE_OPTIONS: -DTHREADSAFE=OFF -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=ON CMAKE_GENERATOR: Ninja - name: "Linux (no mmap)" - id: focal-nommap + id: noble-nommap os: ubuntu-latest container: - name: focal + name: noble env: - CC: clang-10 + CC: gcc CFLAGS: -DNO_MMAP CMAKE_OPTIONS: -DCMAKE_PREFIX_PATH=/usr/local CMAKE_GENERATOR: Ninja From 383e5ed5812ed5f0069fa0ca92b429f675560e55 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 21 Dec 2023 16:30:10 +0000 Subject: [PATCH 445/608] ci: use ecdsa keys for ssh Using modern rsa (sha2-256 or sha2-512) with libssh2 is complicated and depends on numerous factors for support. Just use ecdsa, which is supported by both libssh2 v1.11.0 and modern OpenSSH (which we use for our server in CI). --- ci/test.sh | 22 ++++++++++++---------- 1 file changed, 12 insertions(+), 10 deletions(-) diff --git a/ci/test.sh b/ci/test.sh index 56cb78ce7d5..e55c6261f27 100755 --- a/ci/test.sh +++ b/ci/test.sh @@ -25,6 +25,8 @@ CTEST=$(which ctest) TMPDIR=${TMPDIR:-/tmp} USER=${USER:-$(whoami)} +GITTEST_SSH_KEYTYPE=${GITTEST_SSH_KEYTYPE:="ecdsa"} + HOME=`mktemp -d ${TMPDIR}/home.XXXXXXXX` export CLAR_HOMEDIR=${HOME} @@ -207,7 +209,7 @@ if should_run "SSH_TESTS"; then Port 2222 ListenAddress 0.0.0.0 Protocol 2 - HostKey ${SSHD_DIR}/id_rsa + HostKey ${SSHD_DIR}/id_${GITTEST_SSH_KEYTYPE} PidFile ${SSHD_DIR}/pid AuthorizedKeysFile ${HOME}/.ssh/authorized_keys LogLevel DEBUG @@ -216,21 +218,21 @@ if should_run "SSH_TESTS"; then PubkeyAuthentication yes ChallengeResponseAuthentication no StrictModes no - HostCertificate ${SSHD_DIR}/id_rsa.pub - HostKey ${SSHD_DIR}/id_rsa + HostCertificate ${SSHD_DIR}/id_${GITTEST_SSH_KEYTYPE}.pub + HostKey ${SSHD_DIR}/id_${GITTEST_SSH_KEYTYPE} # Required here as sshd will simply close connection otherwise UsePAM no EOF - ssh-keygen -t rsa -f "${SSHD_DIR}/id_rsa" -N "" -q + ssh-keygen -t "${GITTEST_SSH_KEYTYPE}" -f "${SSHD_DIR}/id_${GITTEST_SSH_KEYTYPE}" -N "" -q /usr/sbin/sshd -f "${SSHD_DIR}/sshd_config" -E "${SSHD_DIR}/log" # Set up keys mkdir "${HOME}/.ssh" - ssh-keygen -t rsa -f "${HOME}/.ssh/id_rsa" -N "" -q - cat "${HOME}/.ssh/id_rsa.pub" >>"${HOME}/.ssh/authorized_keys" + ssh-keygen -t "${GITTEST_SSH_KEYTYPE}" -f "${HOME}/.ssh/id_${GITTEST_SSH_KEYTYPE}" -N "" -q + cat "${HOME}/.ssh/id_${GITTEST_SSH_KEYTYPE}.pub" >>"${HOME}/.ssh/authorized_keys" while read algorithm key comment; do echo "[localhost]:2222 $algorithm $key" >>"${HOME}/.ssh/known_hosts" - done <"${SSHD_DIR}/id_rsa.pub" + done <"${SSHD_DIR}/id_${GITTEST_SSH_KEYTYPE}.pub" # Append the github.com keys for the tests that don't override checks. # We ask for ssh-rsa to test that the selection based off of known_hosts @@ -428,12 +430,12 @@ fi if should_run "SSH_TESTS"; then export GITTEST_REMOTE_USER=$USER - export GITTEST_REMOTE_SSH_KEY="${HOME}/.ssh/id_rsa" - export GITTEST_REMOTE_SSH_PUBKEY="${HOME}/.ssh/id_rsa.pub" + export GITTEST_REMOTE_SSH_KEY="${HOME}/.ssh/id_${GITTEST_SSH_KEYTYPE}" + export GITTEST_REMOTE_SSH_PUBKEY="${HOME}/.ssh/id_${GITTEST_SSH_KEYTYPE}.pub" export GITTEST_REMOTE_SSH_PASSPHRASE="" export GITTEST_REMOTE_SSH_FINGERPRINT="${SSH_FINGERPRINT}" - export GITTEST_SSH_CMD="ssh -i ${HOME}/.ssh/id_rsa -o UserKnownHostsFile=${HOME}/.ssh/known_hosts" + export GITTEST_SSH_CMD="ssh -i ${HOME}/.ssh/id_${GITTEST_SSH_KEYTYPE} -o UserKnownHostsFile=${HOME}/.ssh/known_hosts" echo "" echo "Running ssh tests" From e2027c006b44c9c4bcbf885b57189aacdf582608 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 23 Dec 2023 13:43:48 +0000 Subject: [PATCH 446/608] ci: add noble to build-container matrix --- .github/workflows/build-containers.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/build-containers.yml b/.github/workflows/build-containers.yml index 767798bf6d0..56ac66a9016 100644 --- a/.github/workflows/build-containers.yml +++ b/.github/workflows/build-containers.yml @@ -24,6 +24,7 @@ jobs: - name: xenial - name: bionic - name: focal + - name: noble - name: docurium - name: bionic-x86 dockerfile: bionic From 0572884693c00ea73c6e79057b3ca8ae8bd55531 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 22 Dec 2023 23:17:29 +0000 Subject: [PATCH 447/608] commit: introduce `git_repository_commit_parents` Emulating `git commit` is clunky - identifying your commit's parents is part of the problem. Provide a helper to give you the parents given the current repository state. --- include/git2/commit.h | 18 +++++++++++ include/git2/repository.h | 12 +++++++ src/libgit2/commit.c | 15 +++++++++ src/libgit2/repository.c | 62 ++++++++++++++++++++++++++++++++++++ tests/libgit2/repo/getters.c | 60 ++++++++++++++++++++++++++++++++++ 5 files changed, 167 insertions(+) diff --git a/include/git2/commit.h b/include/git2/commit.h index 67170cb9c83..e3e5d723624 100644 --- a/include/git2/commit.h +++ b/include/git2/commit.h @@ -541,6 +541,24 @@ typedef int (*git_commit_create_cb)( const git_commit *parents[], void *payload); +/** An array of commits returned from the library */ +typedef struct git_commitarray { + git_commit **commits; + size_t count; +} git_commitarray; + +/** + * Free the commits contained in a commit array. This method should + * be called on `git_commitarray` objects that were provided by the + * library. Not doing so will result in a memory leak. + * + * This does not free the `git_commitarray` itself, since the library + * will never allocate that object directly itself. + * + * @param array The git_commitarray that contains commits to free + */ +GIT_EXTERN(void) git_commitarray_dispose(git_commitarray *array); + /** @} */ GIT_END_DECL #endif diff --git a/include/git2/repository.h b/include/git2/repository.h index 6ec2ac8220c..0ff0856510f 100644 --- a/include/git2/repository.h +++ b/include/git2/repository.h @@ -11,6 +11,7 @@ #include "types.h" #include "oid.h" #include "buffer.h" +#include "commit.h" /** * @file git2/repository.h @@ -978,6 +979,17 @@ GIT_EXTERN(int) git_repository_set_ident(git_repository *repo, const char *name, */ GIT_EXTERN(git_oid_t) git_repository_oid_type(git_repository *repo); +/** + * Gets the parents of the next commit, given the current repository state. + * Generally, this is the HEAD commit, except when performing a merge, in + * which case it is two or more commits. + * + * @param commits a `git_commitarray` that will contain the commit parents + * @param repo the repository + * @return 0 or an error code + */ +GIT_EXTERN(int) git_repository_commit_parents(git_commitarray *commits, git_repository *repo); + /** @} */ GIT_END_DECL #endif diff --git a/src/libgit2/commit.c b/src/libgit2/commit.c index f7be73acf3f..b2c335e81b6 100644 --- a/src/libgit2/commit.c +++ b/src/libgit2/commit.c @@ -1097,3 +1097,18 @@ int git_commit_author_with_mailmap( { return git_mailmap_resolve_signature(out, mailmap, commit->author); } + +void git_commitarray_dispose(git_commitarray *array) +{ + size_t i; + + if (array == NULL) + return; + + for (i = 0; i < array->count; i++) + git_commit_free(array->commits[i]); + + git__free(array->commits); + + memset(array, 0, sizeof(*array)); +} diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index 0b76e0464a6..c11fef403fc 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -3874,3 +3874,65 @@ git_oid_t git_repository_oid_type(git_repository *repo) { return repo ? repo->oid_type : 0; } + +struct mergehead_data { + git_repository *repo; + git_vector *parents; +}; + +static int insert_mergehead(const git_oid *oid, void *payload) +{ + git_commit *commit; + struct mergehead_data *data = (struct mergehead_data *)payload; + + if (git_commit_lookup(&commit, data->repo, oid) < 0) + return -1; + + return git_vector_insert(data->parents, commit); +} + +int git_repository_commit_parents(git_commitarray *out, git_repository *repo) +{ + git_commit *first_parent = NULL, *commit; + git_reference *head_ref = NULL; + git_vector parents = GIT_VECTOR_INIT; + struct mergehead_data data; + size_t i; + int error; + + GIT_ASSERT_ARG(out && repo); + + out->count = 0; + out->commits = NULL; + + error = git_revparse_ext((git_object **)&first_parent, &head_ref, repo, "HEAD"); + + if (error != 0) { + if (error == GIT_ENOTFOUND) + error = 0; + + goto done; + } + + if ((error = git_vector_insert(&parents, first_parent)) < 0) + goto done; + + data.repo = repo; + data.parents = &parents; + + error = git_repository_mergehead_foreach(repo, insert_mergehead, &data); + + if (error == GIT_ENOTFOUND) + error = 0; + else if (error != 0) + goto done; + + out->commits = (git_commit **)git_vector_detach(&out->count, NULL, &parents); + +done: + git_vector_foreach(&parents, i, commit) + git__free(commit); + + git_reference_free(head_ref); + return error; +} diff --git a/tests/libgit2/repo/getters.c b/tests/libgit2/repo/getters.c index d401bb8327f..8e21d35b512 100644 --- a/tests/libgit2/repo/getters.c +++ b/tests/libgit2/repo/getters.c @@ -51,3 +51,63 @@ void test_repo_getters__retrieving_the_odb_honors_the_refcount(void) git_odb_free(odb); } + +void test_repo_getters__commit_parents(void) +{ + git_repository *repo; + git_commitarray parents; + git_oid first_parent; + git_oid merge_parents[4]; + + git_oid__fromstr(&first_parent, "099fabac3a9ea935598528c27f866e34089c2eff", GIT_OID_SHA1); + + /* A commit on a new repository has no parents */ + + cl_git_pass(git_repository_init(&repo, "new_repo", false)); + cl_git_pass(git_repository_commit_parents(&parents, repo)); + + cl_assert_equal_sz(0, parents.count); + cl_assert_equal_p(NULL, parents.commits); + + git_commitarray_dispose(&parents); + git_repository_free(repo); + + /* A standard commit has one parent */ + + repo = cl_git_sandbox_init("testrepo"); + cl_git_pass(git_repository_commit_parents(&parents, repo)); + + cl_assert_equal_sz(1, parents.count); + cl_assert_equal_oid(&first_parent, git_commit_id(parents.commits[0])); + + git_commitarray_dispose(&parents); + + /* A merge commit has multiple parents */ + + cl_git_rewritefile("testrepo/.git/MERGE_HEAD", + "8496071c1b46c854b31185ea97743be6a8774479\n" + "5b5b025afb0b4c913b4c338a42934a3863bf3644\n" + "4a202b346bb0fb0db7eff3cffeb3c70babbd2045\n" + "9fd738e8f7967c078dceed8190330fc8648ee56a\n"); + + cl_git_pass(git_repository_commit_parents(&parents, repo)); + + cl_assert_equal_sz(5, parents.count); + + cl_assert_equal_oid(&first_parent, git_commit_id(parents.commits[0])); + + git_oid__fromstr(&merge_parents[0], "8496071c1b46c854b31185ea97743be6a8774479", GIT_OID_SHA1); + cl_assert_equal_oid(&merge_parents[0], git_commit_id(parents.commits[1])); + git_oid__fromstr(&merge_parents[1], "5b5b025afb0b4c913b4c338a42934a3863bf3644", GIT_OID_SHA1); + cl_assert_equal_oid(&merge_parents[1], git_commit_id(parents.commits[2])); + git_oid__fromstr(&merge_parents[2], "4a202b346bb0fb0db7eff3cffeb3c70babbd2045", GIT_OID_SHA1); + cl_assert_equal_oid(&merge_parents[2], git_commit_id(parents.commits[3])); + git_oid__fromstr(&merge_parents[3], "9fd738e8f7967c078dceed8190330fc8648ee56a", GIT_OID_SHA1); + cl_assert_equal_oid(&merge_parents[3], git_commit_id(parents.commits[4])); + + git_commitarray_dispose(&parents); + + git_repository_free(repo); + + cl_fixture_cleanup("testrepo"); +} From 98075baed20d7688147bf49d7a6ecfc565e3eb69 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 23 Dec 2023 15:30:31 +0000 Subject: [PATCH 448/608] fixup! commit: introduce `git_repository_commit_parents` --- include/git2/commit.h | 2 +- src/libgit2/commit.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/include/git2/commit.h b/include/git2/commit.h index e3e5d723624..8841aa033f3 100644 --- a/include/git2/commit.h +++ b/include/git2/commit.h @@ -543,7 +543,7 @@ typedef int (*git_commit_create_cb)( /** An array of commits returned from the library */ typedef struct git_commitarray { - git_commit **commits; + git_commit *const *commits; size_t count; } git_commitarray; diff --git a/src/libgit2/commit.c b/src/libgit2/commit.c index b2c335e81b6..2e30c1be9b0 100644 --- a/src/libgit2/commit.c +++ b/src/libgit2/commit.c @@ -1108,7 +1108,7 @@ void git_commitarray_dispose(git_commitarray *array) for (i = 0; i < array->count; i++) git_commit_free(array->commits[i]); - git__free(array->commits); + git__free((git_commit **)array->commits); memset(array, 0, sizeof(*array)); } From 0589ba6cccbf05aeaa3d7ce8253ca939799d0da0 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Wed, 10 Jan 2024 01:29:04 +0000 Subject: [PATCH 449/608] ci: use newest libssh2 in bionic builds --- ci/docker/bionic | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/ci/docker/bionic b/ci/docker/bionic index f1b69edefeb..f42c6d2aa0b 100644 --- a/ci/docker/bionic +++ b/ci/docker/bionic @@ -12,7 +12,6 @@ RUN apt-get update && \ libcurl4-openssl-dev \ libkrb5-dev \ libpcre3-dev \ - libssh2-1-dev \ libssl-dev \ libz-dev \ ninja-build \ @@ -37,7 +36,16 @@ RUN cd /tmp && \ cd .. && \ rm -rf mbedtls-mbedtls-2.16.2 -FROM mbedtls AS adduser +FROM mbedtls AS libssh2 +RUN cd /tmp && \ + curl --location --silent --show-error https://www.libssh2.org/download/libssh2-1.11.0.tar.gz | tar -xz && \ + cd libssh2-1.11.0 && \ + CFLAGS=-fPIC cmake -G Ninja -DBUILD_SHARED_LIBS=ON . && \ + ninja install && \ + cd .. && \ + rm -rf libssh2-1.11.0 + +FROM libssh2 AS adduser ARG UID="" ARG GID="" RUN if [ "${UID}" != "" ]; then USER_ARG="--uid ${UID}"; fi && \ From 235f8e222d1d71f32b804dc56f3956337d846dda Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 23 Dec 2023 14:27:59 +0000 Subject: [PATCH 450/608] ci: update nightlies There's been drift in our nightly builds vs our main builds. Unfortunately, sharing steps remains clunky with our matrix-heavy setup. So this remains copy-pasta. --- .github/workflows/nightly.yml | 31 ++++++++++++++++++++++++++++--- 1 file changed, 28 insertions(+), 3 deletions(-) diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml index 776b58b12db..0474df7bbad 100644 --- a/.github/workflows/nightly.yml +++ b/.github/workflows/nightly.yml @@ -364,7 +364,11 @@ jobs: working-directory: ${{ env.docker-config-path }} if: matrix.platform.container.name != '' - name: Create container - run: docker build -t ${{ env.docker-registry-container-sha }} -f ${{ env.dockerfile }} . + run: | + if [ "${{ matrix.container.base }}" != "" ]; then + BASE_ARG="--build-arg BASE=${{ matrix.container.base }}" + fi + docker build -t ${{ env.docker-registry-container-sha }} --build-arg UID=$(id -u) --build-arg GID=$(id -g) ${BASE_ARG} -f ${{ env.dockerfile }} . working-directory: ${{ env.docker-config-path }} if: matrix.platform.container.name != '' && env.docker-container-exists != 'true' - name: Prepare build @@ -372,15 +376,36 @@ jobs: - name: Build uses: ./source/.github/actions/run-build with: - command: cd build && ../source/ci/build.sh + command: cd ${BUILD_WORKSPACE:-.}/build && ../source/ci/build.sh container: ${{ matrix.platform.container.name }} container-version: ${{ env.docker-registry-container-sha }} + shell: ${{ matrix.platform.shell }} - name: Test uses: ./source/.github/actions/run-build with: - command: cd build && ../source/ci/test.sh + command: cd ${BUILD_WORKSPACE:-.}/build && ../source/ci/test.sh container: ${{ matrix.platform.container.name }} container-version: ${{ env.docker-registry-container-sha }} + shell: ${{ matrix.platform.shell }} + - name: Upload test results + uses: actions/upload-artifact@v3 + if: success() || failure() + with: + name: test-results-${{ matrix.platform.id }} + path: build/results_*.xml + + test_results: + name: Test results + needs: [ build ] + if: always() + runs-on: ubuntu-latest + steps: + - name: Download test results + uses: actions/download-artifact@v3 + - name: Generate test summary + uses: test-summary/action@v2 + with: + paths: 'test-results-*/*.xml' coverity: # Only run scheduled workflows on the main repository; prevents people From ee1d9a065a15981ec68d5b10a4fb7d7a22d1635b Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 23 Dec 2023 14:55:35 +0000 Subject: [PATCH 451/608] ci: actually push new build containers When we update the build container, actually do a push. Remove the broken build-containers.yml step and just do it in the workflow. --- .github/workflows/main.yml | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index e045bb436f2..a5d10b708eb 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -18,14 +18,10 @@ permissions: packages: write jobs: - containers: - uses: ./.github/workflows/build-containers.yml - # Run our CI/CD builds. We build a matrix with the various build targets # and their details. Then we build either in a docker container (Linux) # or on the actual hosts (macOS, Windows). build: - needs: [ containers ] strategy: matrix: platform: @@ -232,6 +228,11 @@ jobs: BASE_ARG="--build-arg BASE=${{ matrix.container.base }}" fi docker build -t ${{ env.docker-registry-container-sha }} --build-arg UID=$(id -u) --build-arg GID=$(id -g) ${BASE_ARG} -f ${{ env.dockerfile }} . + docker tag ${{ env.docker-registry-container-sha }} ${{ env.docker-registry-container-latest }} + if [ "${{ github.event_name }}" != "pull_request" ]; then + docker push ${{ env.docker-registry-container-sha }} + docker push ${{ env.docker-registry-container-latest }} + fi working-directory: ${{ env.docker-config-path }} if: matrix.platform.container.name != '' && env.docker-container-exists != 'true' - name: Prepare build @@ -278,7 +279,6 @@ jobs: # published to our documentation site. documentation: name: Generate documentation - needs: [ containers ] if: success() || failure() runs-on: ubuntu-latest steps: From d15be592db7bb9a52d5b287bd3af99b49a1ac258 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 23 Dec 2023 15:20:47 +0000 Subject: [PATCH 452/608] ci: move docker container creation to an action --- .../download-or-build-container/action.yml | 109 ++++++++++++++++++ .github/workflows/main.yml | 38 +++--- .github/workflows/nightly.yml | 40 +++---- ci/getcontainer.sh | 55 --------- 4 files changed, 143 insertions(+), 99 deletions(-) create mode 100644 .github/actions/download-or-build-container/action.yml delete mode 100755 ci/getcontainer.sh diff --git a/.github/actions/download-or-build-container/action.yml b/.github/actions/download-or-build-container/action.yml new file mode 100644 index 00000000000..9c83a9836c3 --- /dev/null +++ b/.github/actions/download-or-build-container/action.yml @@ -0,0 +1,109 @@ +# Run a build step in a container or directly on the Actions runner +name: Download or Build Container +description: Download a container from the package registry, or build it if it's not found + +inputs: + container: + description: Container name + type: string + required: true + dockerfile: + description: Dockerfile + type: string + base: + description: Container base + type: string + registry: + description: Docker registry to read and publish to + type: string + default: ghcr.io + config-path: + description: Path to Dockerfiles + type: string + github_token: + description: GitHub Token + type: string + +runs: + using: 'composite' + steps: + - name: Download container + run: | + IMAGE_NAME="${{ inputs.container }}" + DOCKERFILE_PATH="${{ inputs.dockerfile }}" + DOCKER_REGISTRY="${{ inputs.registry }}" + DOCKERFILE_ROOT="${{ inputs.config-path }}" + + if [ "${DOCKERFILE_PATH}" = "" ]; then + DOCKERFILE_PATH="${DOCKERFILE_ROOT}/${IMAGE_NAME}" + else + DOCKERFILE_PATH="${DOCKERFILE_ROOT}/${DOCKERFILE_PATH}" + fi + + GIT_WORKTREE=$(cd "${GITHUB_ACTION_PATH}" && git rev-parse --show-toplevel) + echo "::: git worktree is ${GIT_WORKTREE}" + cd "${GIT_WORKTREE}" + + DOCKER_CONTAINER="${GITHUB_REPOSITORY}/${IMAGE_NAME}" + DOCKER_REGISTRY_CONTAINER="${DOCKER_REGISTRY}/${DOCKER_CONTAINER}" + + echo "dockerfile=${DOCKERFILE_PATH}" >> $GITHUB_ENV + echo "docker-container=${DOCKER_CONTAINER}" >> $GITHUB_ENV + echo "docker-registry-container=${DOCKER_REGISTRY_CONTAINER}" >> $GITHUB_ENV + + # Identify the last git commit that touched the Dockerfiles + # Use this as a hash to identify the resulting docker containers + echo "::: dockerfile path is ${DOCKERFILE_PATH}" + + DOCKER_SHA=$(git log -1 --pretty=format:"%h" -- "${DOCKERFILE_PATH}") + echo "docker-sha=${DOCKER_SHA}" >> $GITHUB_ENV + + echo "::: docker sha is ${DOCKER_SHA}" + + DOCKER_REGISTRY_CONTAINER_SHA="${DOCKER_REGISTRY_CONTAINER}:${DOCKER_SHA}" + + echo "docker-registry-container-sha=${DOCKER_REGISTRY_CONTAINER_SHA}" >> $GITHUB_ENV + echo "docker-registry-container-latest=${DOCKER_REGISTRY_CONTAINER}:latest" >> $GITHUB_ENV + + echo "::: logging in to ${DOCKER_REGISTRY} as ${GITHUB_ACTOR}" + + exists="true" + docker login https://${DOCKER_REGISTRY} -u ${GITHUB_ACTOR} -p ${GITHUB_TOKEN} || exists="false" + + echo "::: pulling ${DOCKER_REGISTRY_CONTAINER_SHA}" + + if [ "${exists}" != "false" ]; then + docker pull ${DOCKER_REGISTRY_CONTAINER_SHA} || exists="false" + fi + + if [ "${exists}" = "true" ]; then + echo "::: docker container exists in registry" + echo "docker-container-exists=true" >> $GITHUB_ENV + else + echo "::: docker container does not exist in registry" + echo "docker-container-exists=false" >> $GITHUB_ENV + fi + shell: bash + env: + GITHUB_TOKEN: ${{ inputs.github_token }} + - name: Create container + run: | + if [ "${{ inputs.base }}" != "" ]; then + BASE_ARG="--build-arg BASE=${{ inputs.base }}" + fi + + GIT_WORKTREE=$(cd "${GITHUB_ACTION_PATH}" && git rev-parse --show-toplevel) + echo "::: git worktree is ${GIT_WORKTREE}" + cd "${GIT_WORKTREE}" + + docker build -t ${{ env.docker-registry-container-sha }} --build-arg UID=$(id -u) --build-arg GID=$(id -g) ${BASE_ARG} -f ${{ env.dockerfile }} . + docker tag ${{ env.docker-registry-container-sha }} ${{ env.docker-registry-container-latest }} + shell: bash + working-directory: source/${{ inputs.config-path }} + if: env.docker-container-exists != 'true' + - name: Publish container + run: | + docker push ${{ env.docker-registry-container-sha }} + docker push ${{ env.docker-registry-container-latest }} + shell: bash + if: env.docker-container-exists != 'true' && github.event_name != 'pull_request' diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index a5d10b708eb..f6a087b89b2 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -11,7 +11,7 @@ on: env: docker-registry: ghcr.io - docker-config-path: source/ci/docker + docker-config-path: ci/docker permissions: contents: write @@ -214,27 +214,15 @@ jobs: - name: Setup QEMU run: docker run --rm --privileged multiarch/qemu-user-static:register --reset if: matrix.platform.container.qemu == true - - name: Download container - run: | - "${{ github.workspace }}/source/ci/getcontainer.sh" "${{ matrix.platform.container.name }}" "${{ matrix.platform.container.dockerfile }}" - env: - DOCKER_REGISTRY: ${{ env.docker-registry }} - GITHUB_TOKEN: ${{ secrets.github_token }} - working-directory: ${{ env.docker-config-path }} + - name: Set up container + uses: ./source/.github/actions/download-or-build-container + with: + registry: ${{ env.docker-registry }} + config-path: ${{ env.docker-config-path }} + container: ${{ matrix.platform.container.name }} + github_token: ${{ secrets.github_token }} + dockerfile: ${{ matrix.platform.container.dockerfile }} if: matrix.platform.container.name != '' - - name: Create container - run: | - if [ "${{ matrix.container.base }}" != "" ]; then - BASE_ARG="--build-arg BASE=${{ matrix.container.base }}" - fi - docker build -t ${{ env.docker-registry-container-sha }} --build-arg UID=$(id -u) --build-arg GID=$(id -g) ${BASE_ARG} -f ${{ env.dockerfile }} . - docker tag ${{ env.docker-registry-container-sha }} ${{ env.docker-registry-container-latest }} - if [ "${{ github.event_name }}" != "pull_request" ]; then - docker push ${{ env.docker-registry-container-sha }} - docker push ${{ env.docker-registry-container-latest }} - fi - working-directory: ${{ env.docker-config-path }} - if: matrix.platform.container.name != '' && env.docker-container-exists != 'true' - name: Prepare build run: mkdir build - name: Build @@ -287,6 +275,14 @@ jobs: with: path: source fetch-depth: 0 + - name: Set up container + uses: ./source/.github/actions/download-or-build-container + with: + registry: ${{ env.docker-registry }} + config-path: ${{ env.docker-config-path }} + container: docurium + github_token: ${{ secrets.github_token }} + dockerfile: ${{ matrix.platform.container.dockerfile }} - name: Generate documentation working-directory: source run: | diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml index 0474df7bbad..43796859762 100644 --- a/.github/workflows/nightly.yml +++ b/.github/workflows/nightly.yml @@ -8,7 +8,7 @@ on: env: docker-registry: ghcr.io - docker-config-path: source/ci/docker + docker-config-path: ci/docker permissions: contents: read @@ -355,22 +355,15 @@ jobs: - name: Setup QEMU run: docker run --rm --privileged multiarch/qemu-user-static:register --reset if: matrix.platform.container.qemu == true - - name: Download container - run: | - "${{ github.workspace }}/source/ci/getcontainer.sh" "${{ matrix.platform.container.name }}" "${{ matrix.platform.container.dockerfile }}" - env: - DOCKER_REGISTRY: ${{ env.docker-registry }} - GITHUB_TOKEN: ${{ secrets.github_token }} - working-directory: ${{ env.docker-config-path }} + - name: Set up container + uses: ./source/.github/actions/download-or-build-container + with: + registry: ${{ env.docker-registry }} + config-path: ${{ env.docker-config-path }} + container: ${{ matrix.platform.container.name }} + github_token: ${{ secrets.github_token }} + dockerfile: ${{ matrix.platform.container.dockerfile }} if: matrix.platform.container.name != '' - - name: Create container - run: | - if [ "${{ matrix.container.base }}" != "" ]; then - BASE_ARG="--build-arg BASE=${{ matrix.container.base }}" - fi - docker build -t ${{ env.docker-registry-container-sha }} --build-arg UID=$(id -u) --build-arg GID=$(id -g) ${BASE_ARG} -f ${{ env.dockerfile }} . - working-directory: ${{ env.docker-config-path }} - if: matrix.platform.container.name != '' && env.docker-container-exists != 'true' - name: Prepare build run: mkdir build - name: Build @@ -420,13 +413,14 @@ jobs: with: path: source fetch-depth: 0 - - name: Download container - run: | - "${{ github.workspace }}/source/ci/getcontainer.sh" xenial - env: - DOCKER_REGISTRY: ${{ env.docker-registry }} - GITHUB_TOKEN: ${{ secrets.github_token }} - working-directory: ${{ env.docker-config-path }} + - name: Set up container + uses: ./source/.github/actions/download-or-build-container + with: + registry: ${{ env.docker-registry }} + config-path: ${{ env.docker-config-path }} + container: xenial + github_token: ${{ secrets.github_token }} + if: matrix.platform.container.name != '' - name: Run Coverity run: source/ci/coverity.sh env: diff --git a/ci/getcontainer.sh b/ci/getcontainer.sh deleted file mode 100755 index 81d0c1d9266..00000000000 --- a/ci/getcontainer.sh +++ /dev/null @@ -1,55 +0,0 @@ -#!/bin/bash - -set -e - -IMAGE_NAME=$1 -DOCKERFILE_PATH=$2 - -if [ "${IMAGE_NAME}" = "" ]; then - echo "usage: $0 image_name [dockerfile]" - exit 1 -fi - -if [ "${DOCKERFILE_PATH}" = "" ]; then - DOCKERFILE_PATH="${IMAGE_NAME}" -fi - -if [ "${DOCKER_REGISTRY}" = "" ]; then - echo "DOCKER_REGISTRY environment variable is unset." - echo "Not running inside GitHub Actions or misconfigured?" - exit 1 -fi - -DOCKER_CONTAINER="${GITHUB_REPOSITORY}/${IMAGE_NAME}" -DOCKER_REGISTRY_CONTAINER="${DOCKER_REGISTRY}/${DOCKER_CONTAINER}" - -echo "dockerfile=${DOCKERFILE_PATH}" >> $GITHUB_ENV -echo "docker-container=${DOCKER_CONTAINER}" >> $GITHUB_ENV -echo "docker-registry-container=${DOCKER_REGISTRY_CONTAINER}" >> $GITHUB_ENV - -# Identify the last git commit that touched the Dockerfiles -# Use this as a hash to identify the resulting docker containers -DOCKER_SHA=$(git log -1 --pretty=format:"%h" -- "${DOCKERFILE_PATH}") -echo "docker-sha=${DOCKER_SHA}" >> $GITHUB_ENV - -DOCKER_REGISTRY_CONTAINER_SHA="${DOCKER_REGISTRY_CONTAINER}:${DOCKER_SHA}" - -echo "docker-registry-container-sha=${DOCKER_REGISTRY_CONTAINER_SHA}" >> $GITHUB_ENV -echo "docker-registry-container-latest=${DOCKER_REGISTRY_CONTAINER}:latest" >> $GITHUB_ENV - -echo "::: logging in to ${DOCKER_REGISTRY} as ${GITHUB_ACTOR}" - -exists="true" -docker login https://${DOCKER_REGISTRY} -u ${GITHUB_ACTOR} -p ${GITHUB_TOKEN} || exists="false" - -echo "::: pulling ${DOCKER_REGISTRY_CONTAINER_SHA}" - -if [ "${exists}" != "false" ]; then - docker pull ${DOCKER_REGISTRY_CONTAINER_SHA} || exists="false" -fi - -if [ "${exists}" = "true" ]; then - echo "docker-container-exists=true" >> $GITHUB_ENV -else - echo "docker-container-exists=false" >> $GITHUB_ENV -fi From d6454dd467750c0e1d3eb5bc69742d8825534ca1 Mon Sep 17 00:00:00 2001 From: DavHau Date: Thu, 11 Jan 2024 16:34:36 +0700 Subject: [PATCH 453/608] docs: fix mistake in attr.h Also fix indentation --- include/git2/attr.h | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/include/git2/attr.h b/include/git2/attr.h index 0c838727d14..69929b3dfc6 100644 --- a/include/git2/attr.h +++ b/include/git2/attr.h @@ -116,14 +116,12 @@ GIT_EXTERN(git_attr_value_t) git_attr_value(const char *attr); */ #define GIT_ATTR_CHECK_FILE_THEN_INDEX 0 #define GIT_ATTR_CHECK_INDEX_THEN_FILE 1 -#define GIT_ATTR_CHECK_INDEX_ONLY 2 +#define GIT_ATTR_CHECK_INDEX_ONLY 2 /** * Check attribute flags: controlling extended attribute behavior. * * Normally, attribute checks include looking in the /etc (or system - * equivalent) directory for a `gitattributes` file. Passing this - * flag will cause attribute checks to ignore that file. * equivalent) directory for a `gitattributes` file. Passing the * `GIT_ATTR_CHECK_NO_SYSTEM` flag will cause attribute checks to * ignore that file. From 45c8caad1cd10434e4c77df619da6f021558fede Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sun, 7 Jan 2024 04:04:39 +0000 Subject: [PATCH 454/608] benchmarks: update name to be "libgit2" --- .github/workflows/benchmark.yml | 2 +- tests/benchmarks/benchmark.sh | 10 +++++++++- 2 files changed, 10 insertions(+), 2 deletions(-) diff --git a/.github/workflows/benchmark.yml b/.github/workflows/benchmark.yml index 7705d89e97a..67a00298783 100644 --- a/.github/workflows/benchmark.yml +++ b/.github/workflows/benchmark.yml @@ -76,7 +76,7 @@ jobs: fi mkdir benchmark && cd benchmark - ../source/tests/benchmarks/benchmark.sh --baseline-cli "git" --cli "${GIT2_CLI}" --json benchmarks.json --zip benchmarks.zip + ../source/tests/benchmarks/benchmark.sh --baseline-cli "git" --cli "${GIT2_CLI}" --name libgit2 --json benchmarks.json --zip benchmarks.zip shell: bash - name: Upload results uses: actions/upload-artifact@v2 diff --git a/tests/benchmarks/benchmark.sh b/tests/benchmarks/benchmark.sh index 4a89807b789..4cb2b2fbfd3 100755 --- a/tests/benchmarks/benchmark.sh +++ b/tests/benchmarks/benchmark.sh @@ -6,9 +6,10 @@ set -eo pipefail # parse the command line # -usage() { echo "usage: $(basename "$0") [--cli ] [--baseline-cli ] [--suite ] [--json ] [--zip ] [--verbose] [--debug]"; } +usage() { echo "usage: $(basename "$0") [--cli ] [--name ] [--baseline-cli ] [--suite ] [--json ] [--zip ] [--verbose] [--debug]"; } TEST_CLI="git" +TEST_CLI_NAME= BASELINE_CLI= SUITE= JSON_RESULT= @@ -22,6 +23,9 @@ for a in "$@"; do if [ "${NEXT}" = "cli" ]; then TEST_CLI="${a}" NEXT= + elif [ "${NEXT}" = "name" ]; then + TEST_CLI_NAME="${a}" + NEXT= elif [ "${NEXT}" = "baseline-cli" ]; then BASELINE_CLI="${a}" NEXT= @@ -41,6 +45,10 @@ for a in "$@"; do NEXT="cli" elif [[ "${a}" == "-c"* ]]; then TEST_CLI="${a/-c/}" + elif [ "${a}" = "n" ] || [ "${a}" = "--name" ]; then + NEXT="name" + elif [[ "${a}" == "-n"* ]]; then + TEST_CLI_NAME="${a/-n/}" elif [ "${a}" = "b" ] || [ "${a}" = "--baseline-cli" ]; then NEXT="baseline-cli" elif [[ "${a}" == "-b"* ]]; then From 155eb67f2893091cab39585f5d509a5166dcd344 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sun, 7 Jan 2024 04:06:50 +0000 Subject: [PATCH 455/608] benchmarks: use upload-artifact v3 --- .github/workflows/benchmark.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/benchmark.yml b/.github/workflows/benchmark.yml index 67a00298783..d47f2cc2900 100644 --- a/.github/workflows/benchmark.yml +++ b/.github/workflows/benchmark.yml @@ -79,7 +79,7 @@ jobs: ../source/tests/benchmarks/benchmark.sh --baseline-cli "git" --cli "${GIT2_CLI}" --name libgit2 --json benchmarks.json --zip benchmarks.zip shell: bash - name: Upload results - uses: actions/upload-artifact@v2 + uses: actions/upload-artifact@v3 with: name: benchmark-${{ matrix.platform.id }} path: benchmark From a79e48addb34a2736943d6bd6bf7676214ec7ece Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 11 Jan 2024 17:04:06 +0000 Subject: [PATCH 456/608] benchmarks: publish benchmarks as a static api --- .github/workflows/benchmark.yml | 56 ++++++++++++++++++++++++++++++++- 1 file changed, 55 insertions(+), 1 deletion(-) diff --git a/.github/workflows/benchmark.yml b/.github/workflows/benchmark.yml index d47f2cc2900..831ffbb8235 100644 --- a/.github/workflows/benchmark.yml +++ b/.github/workflows/benchmark.yml @@ -49,7 +49,7 @@ jobs: id: windows setup-script: win32 fail-fast: false - name: "Build ${{ matrix.platform.name }}" + name: "Benchmark ${{ matrix.platform.name }}" env: ${{ matrix.platform.env }} runs-on: ${{ matrix.platform.os }} steps: @@ -84,3 +84,57 @@ jobs: name: benchmark-${{ matrix.platform.id }} path: benchmark if: always() + + # Publish the results + publish: + name: Publish results + needs: [ build ] + if: always() + runs-on: ubuntu-latest + steps: + - name: Check out benchmark repository + uses: actions/checkout@v3 + with: + repository: libgit2/benchmarks + path: site + fetch-depth: 0 + ssh-key: ${{ secrets.BENCHMARKS_PUBLISH_KEY }} + - name: Download test results + uses: actions/download-artifact@v3 + - name: Publish API + run: | + # Move today's benchmark run into the right place + for platform in linux macos windows; do + TIMESTAMP=$(jq .time.start < "benchmark-${platform}/benchmarks.json") + TIMESTAMP_LEN=$(echo -n ${TIMESTAMP} | wc -c | xargs) + DENOMINATOR=1 + if [ "${TIMESTAMP_LEN}" = "19" ]; then + DENOMINATOR="1000000000" + elif [ "${TIMESTAMP_LEN}" = "13" ]; then + DENOMINATOR="1000" + else + echo "unknown timestamp" + exit 1 + fi + + if [[ "$(uname -s)" == "Darwin" ]]; then + DATE=$(date -R -r $(("${TIMESTAMP}/${DENOMINATOR}")) +"%Y-%m-%d") + else + DATE=$(date -d @$(("${TIMESTAMP}/${DENOMINATOR}")) +"%Y-%m-%d") + fi + + mkdir -p "site/public/api/runs/${DATE}" + cp "benchmark-${platform}/benchmarks.json" "site/public/api/runs/${DATE}/${platform}.json" + done + + (cd site && node scripts/aggregate.js) + + ( + cd site && + git config user.name 'Benchmark Site Generation' && + git config user.email 'libgit2@users.noreply.github.com' && + git add . && + git commit --allow-empty -m"benchmark update ${DATE}" && + git push origin main + ) + shell: bash From 516749fe7dc60ebad7b18aae610e626d11ba1f94 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sun, 14 Jan 2024 01:03:29 +0000 Subject: [PATCH 457/608] repo: simplify safe.directory comparison Keep the `git_str` buf that prevents unnecessary small allocations, and simplify the comparisons compared to what was there previously. --- src/libgit2/repository.c | 52 ++++++++++++++++----------------------- tests/libgit2/repo/open.c | 4 +-- 2 files changed, 23 insertions(+), 33 deletions(-) diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index f9d639b6144..2db106ce6eb 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -537,7 +537,8 @@ static int read_gitfile(git_str *path_out, const char *file_path) } typedef struct { - git_str repo_path; + const char *repo_path; + git_str tmp; bool *is_safe; } validate_ownership_data; @@ -552,6 +553,18 @@ static int validate_ownership_cb(const git_config_entry *entry, void *payload) } else { const char *test_path = entry->value; + if (git_str_sets(&data->tmp, test_path) < 0 || + git_fs_path_to_dir(&data->tmp) < 0) + return -1; + + /* + * Ensure that `git_fs_path_to_dir` mutated the + * input path by adding a trailing backslash. + * A trailing backslash on the input is not allowed. + */ + if (strcmp(data->tmp.ptr, test_path) == 0) + return 0; + #ifdef GIT_WIN32 /* * Git for Windows does some truly bizarre things with @@ -581,7 +594,8 @@ static int validate_ownership_cb(const git_config_entry *entry, void *payload) strncmp(test_path, "//wsl.localhost/", strlen("//wsl.localhost/")) != 0) test_path++; #endif - if (strcmp(test_path, data->repo_path.ptr) == 0) + + if (strcmp(data->tmp.ptr, data->repo_path) == 0) *data->is_safe = true; } @@ -594,7 +608,7 @@ static int validate_ownership_config( bool use_env) { validate_ownership_data ownership_data = { - GIT_STR_INIT, is_safe + path, GIT_STR_INIT, is_safe }; git_config *config; int error; @@ -602,13 +616,6 @@ static int validate_ownership_config( if (load_global_config(&config, use_env) != 0) return 0; - git_str_sets(&ownership_data.repo_path, path); - if (git_str_oom(&ownership_data.repo_path)) - return -1; - if (git_str_len(&ownership_data.repo_path) > 1 && - ownership_data.repo_path.ptr[git_str_len(&ownership_data.repo_path) - 1] == '/') - git_str_shorten(&ownership_data.repo_path, 1); - error = git_config_get_multivar_foreach(config, "safe.directory", NULL, validate_ownership_cb, @@ -618,7 +625,7 @@ static int validate_ownership_config( error = 0; git_config_free(config); - git_str_dispose(&ownership_data.repo_path); + git_str_dispose(&ownership_data.tmp); return error; } @@ -685,26 +692,9 @@ static int validate_ownership(git_repository *repo) goto done; if (!is_safe) { - git_str nice_path = GIT_STR_INIT; -#ifdef GIT_WIN32 - /* see comment above in validate_ownership_cb */ - if (!strncasecmp(path, "//", strlen("//"))) - git_str_puts(&nice_path, "%(prefix)/"); -#endif - git_str_puts(&nice_path, path); - if (!git_str_oom(&nice_path)) { - if (git_str_len(&nice_path) > 1 && nice_path.ptr[git_str_len(&nice_path) - 1] == '/') - git_str_shorten(&nice_path, 1); - git_error_set( - GIT_ERROR_CONFIG, - "repository path '%s' is not owned by current user.\n\nTo add an exception use the path '%s'.", - path, nice_path.ptr); - } else - git_error_set( - GIT_ERROR_CONFIG, - "repository path '%s' is not owned by current user.", - path); - git_str_dispose(&nice_path); + git_error_set(GIT_ERROR_CONFIG, + "repository path '%s' is not owned by current user", + path); error = GIT_EOWNER; } diff --git a/tests/libgit2/repo/open.c b/tests/libgit2/repo/open.c index 547e300a170..9c0bfde7b57 100644 --- a/tests/libgit2/repo/open.c +++ b/tests/libgit2/repo/open.c @@ -555,7 +555,7 @@ void test_repo_open__can_allowlist_dirs_with_problematic_ownership(void) git_str_joinpath(&config_filename, config_path.ptr, ".gitconfig"); - // Test with incorrect exception (slash at the end) + /* Test with incorrect exception (slash at the end) */ git_str_printf(&config_data, "[foo]\n" \ "\tbar = Foobar\n" \ @@ -572,7 +572,7 @@ void test_repo_open__can_allowlist_dirs_with_problematic_ownership(void) cl_git_rewritefile(config_filename.ptr, config_data.ptr); cl_git_fail_with(GIT_EOWNER, git_repository_open(&repo, "empty_standard_repo")); - // Test with correct exception + /* Test with correct exception */ git_str_clear(&config_data); git_str_printf(&config_data, "[foo]\n" \ From 048421a404d3c4e4ba524496e551e61077b11a2b Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sun, 14 Jan 2024 14:39:17 +0000 Subject: [PATCH 458/608] repo: add `head_commit` helper Provide a helper method to provide the HEAD's commit, much like our existing `head_tree` helper. --- src/libgit2/repository.c | 19 +++++++++++++++++++ src/libgit2/repository.h | 1 + 2 files changed, 20 insertions(+) diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index cb6658cfc75..b2afc4f59d2 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -3314,6 +3314,25 @@ int git_repository_set_bare(git_repository *repo) return 0; } +int git_repository_head_commit(git_commit **commit, git_repository *repo) +{ + git_reference *head; + git_object *obj; + int error; + + if ((error = git_repository_head(&head, repo)) < 0) + return error; + + if ((error = git_reference_peel(&obj, head, GIT_OBJECT_COMMIT)) < 0) + goto cleanup; + + *commit = (git_commit *)obj; + +cleanup: + git_reference_free(head); + return error; +} + int git_repository_head_tree(git_tree **tree, git_repository *repo) { git_reference *head; diff --git a/src/libgit2/repository.h b/src/libgit2/repository.h index be4bc8860d6..f45a3591981 100644 --- a/src/libgit2/repository.h +++ b/src/libgit2/repository.h @@ -173,6 +173,7 @@ GIT_INLINE(git_attr_cache *) git_repository_attr_cache(git_repository *repo) return repo->attrcache; } +int git_repository_head_commit(git_commit **commit, git_repository *repo); int git_repository_head_tree(git_tree **tree, git_repository *repo); int git_repository_create_head(const char *git_dir, const char *ref_name); From cf19ddc52227f4ec2efd4c0a84aa5d2362f0ffc7 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sun, 14 Jan 2024 15:37:20 +0000 Subject: [PATCH 459/608] commit: fix const declaration commit functions should take an array of const pointers, not a const array. --- examples/merge.c | 2 +- include/git2/commit.h | 6 +++--- src/libgit2/commit.c | 8 ++++---- src/libgit2/commit.h | 2 +- src/libgit2/notes.c | 4 ++-- src/libgit2/rebase.c | 9 ++++----- src/libgit2/stash.c | 4 ++-- tests/libgit2/checkout/tree.c | 2 +- tests/libgit2/cherrypick/workdir.c | 2 +- tests/libgit2/commit/commit.c | 4 ++-- tests/libgit2/commit/write.c | 2 +- tests/libgit2/diff/rename.c | 2 +- tests/libgit2/odb/freshen.c | 2 +- tests/libgit2/rebase/sign.c | 6 +++--- tests/libgit2/refs/reflog/messages.c | 2 +- tests/libgit2/revert/workdir.c | 6 +++--- tests/libgit2/revwalk/basic.c | 3 +-- 17 files changed, 32 insertions(+), 34 deletions(-) diff --git a/examples/merge.c b/examples/merge.c index 7a76912cd24..718c767d038 100644 --- a/examples/merge.c +++ b/examples/merge.c @@ -263,7 +263,7 @@ static int create_merge_commit(git_repository *repo, git_index *index, struct me sign, sign, NULL, msg, tree, - opts->annotated_count + 1, (const git_commit **)parents); + opts->annotated_count + 1, parents); check_lg2(err, "failed to create commit", NULL); /* We're done merging, cleanup the repository state */ diff --git a/include/git2/commit.h b/include/git2/commit.h index 8841aa033f3..ea0e94969a8 100644 --- a/include/git2/commit.h +++ b/include/git2/commit.h @@ -366,7 +366,7 @@ GIT_EXTERN(int) git_commit_create( const char *message, const git_tree *tree, size_t parent_count, - const git_commit *parents[]); + git_commit * const parents[]); /** * Create new commit in the repository using a variable argument list. @@ -469,7 +469,7 @@ GIT_EXTERN(int) git_commit_create_buffer( const char *message, const git_tree *tree, size_t parent_count, - const git_commit *parents[]); + git_commit * const parents[]); /** * Create a commit object from the given buffer and signature @@ -538,7 +538,7 @@ typedef int (*git_commit_create_cb)( const char *message, const git_tree *tree, size_t parent_count, - const git_commit *parents[], + git_commit * const parents[], void *payload); /** An array of commits returned from the library */ diff --git a/src/libgit2/commit.c b/src/libgit2/commit.c index 2e30c1be9b0..9e3b29a00b8 100644 --- a/src/libgit2/commit.c +++ b/src/libgit2/commit.c @@ -281,7 +281,7 @@ int git_commit_create_from_ids( typedef struct { size_t total; - const git_commit **parents; + git_commit * const *parents; git_repository *repo; } commit_parent_data; @@ -307,7 +307,7 @@ int git_commit_create( const char *message, const git_tree *tree, size_t parent_count, - const git_commit *parents[]) + git_commit * const parents[]) { commit_parent_data data = { parent_count, parents, repo }; @@ -945,7 +945,7 @@ int git_commit_create_buffer( const char *message, const git_tree *tree, size_t parent_count, - const git_commit *parents[]) + git_commit * const parents[]) { GIT_BUF_WRAP_PRIVATE(out, git_commit__create_buffer, repo, author, committer, message_encoding, message, @@ -961,7 +961,7 @@ int git_commit__create_buffer( const char *message, const git_tree *tree, size_t parent_count, - const git_commit *parents[]) + git_commit * const parents[]) { int error; commit_parent_data data = { parent_count, parents, repo }; diff --git a/src/libgit2/commit.h b/src/libgit2/commit.h index c25fee327b8..53128ba5d83 100644 --- a/src/libgit2/commit.h +++ b/src/libgit2/commit.h @@ -64,7 +64,7 @@ int git_commit__create_buffer( const char *message, const git_tree *tree, size_t parent_count, - const git_commit *parents[]); + git_commit * const parents[]); int git_commit__parse( void *commit, diff --git a/src/libgit2/notes.c b/src/libgit2/notes.c index 13ca3824bf1..2dd194581fd 100644 --- a/src/libgit2/notes.c +++ b/src/libgit2/notes.c @@ -303,7 +303,7 @@ static int note_write( error = git_commit_create(&oid, repo, notes_ref, author, committer, NULL, GIT_NOTES_DEFAULT_MSG_ADD, - tree, *parents == NULL ? 0 : 1, (const git_commit **) parents); + tree, *parents == NULL ? 0 : 1, parents); if (notes_commit_out) git_oid_cpy(notes_commit_out, &oid); @@ -394,7 +394,7 @@ static int note_remove( NULL, GIT_NOTES_DEFAULT_MSG_RM, tree_after_removal, *parents == NULL ? 0 : 1, - (const git_commit **) parents); + parents); if (error < 0) goto cleanup; diff --git a/src/libgit2/rebase.c b/src/libgit2/rebase.c index 77e442e981d..2fce3e7bc06 100644 --- a/src/libgit2/rebase.c +++ b/src/libgit2/rebase.c @@ -952,7 +952,7 @@ static int create_signed( const char *message, git_tree *tree, size_t parent_count, - const git_commit **parents) + git_commit * const *parents) { git_str commit_content = GIT_STR_INIT; git_buf commit_signature = { NULL, 0, 0 }, @@ -1040,8 +1040,7 @@ static int rebase_commit__create( if (rebase->options.commit_create_cb) { error = rebase->options.commit_create_cb(&commit_id, author, committer, message_encoding, message, - tree, 1, (const git_commit **)&parent_commit, - rebase->options.payload); + tree, 1, &parent_commit, rebase->options.payload); git_error_set_after_callback_function(error, "commit_create_cb"); @@ -1050,14 +1049,14 @@ static int rebase_commit__create( else if (rebase->options.signing_cb) { error = create_signed(&commit_id, rebase, author, committer, message_encoding, message, tree, - 1, (const git_commit **)&parent_commit); + 1, &parent_commit); } #endif if (error == GIT_PASSTHROUGH) error = git_commit_create(&commit_id, rebase->repo, NULL, author, committer, message_encoding, message, - tree, 1, (const git_commit **)&parent_commit); + tree, 1, &parent_commit); if (error) goto done; diff --git a/src/libgit2/stash.c b/src/libgit2/stash.c index b49e95cdb21..a0a72deacc6 100644 --- a/src/libgit2/stash.c +++ b/src/libgit2/stash.c @@ -124,7 +124,7 @@ static int commit_index( git_index *index, const git_signature *stasher, const char *message, - const git_commit *parent) + git_commit *parent) { git_tree *i_tree = NULL; git_oid i_commit_oid; @@ -423,7 +423,7 @@ static int build_stash_commit_from_tree( git_commit *u_commit, const git_tree *tree) { - const git_commit *parents[] = { NULL, NULL, NULL }; + git_commit *parents[] = { NULL, NULL, NULL }; parents[0] = b_commit; parents[1] = i_commit; diff --git a/tests/libgit2/checkout/tree.c b/tests/libgit2/checkout/tree.c index 65df00cd87b..97935aaeaa1 100644 --- a/tests/libgit2/checkout/tree.c +++ b/tests/libgit2/checkout/tree.c @@ -1235,7 +1235,7 @@ void test_checkout_tree__case_changing_rename(void) cl_git_pass(git_signature_new(&signature, "Renamer", "rename@contoso.com", time(NULL), 0)); - cl_git_pass(git_commit_create(&commit_id, g_repo, "refs/heads/dir", signature, signature, NULL, "case-changing rename", tree, 1, (const git_commit **)&dir_commit)); + cl_git_pass(git_commit_create(&commit_id, g_repo, "refs/heads/dir", signature, signature, NULL, "case-changing rename", tree, 1, &dir_commit)); cl_assert(git_fs_path_isfile("testrepo/readme")); if (case_sensitive) diff --git a/tests/libgit2/cherrypick/workdir.c b/tests/libgit2/cherrypick/workdir.c index c16b7814ac0..9d9a3f49795 100644 --- a/tests/libgit2/cherrypick/workdir.c +++ b/tests/libgit2/cherrypick/workdir.c @@ -77,7 +77,7 @@ void test_cherrypick_workdir__automerge(void) cl_git_pass(git_index_write_tree(&cherrypicked_tree_oid, repo_index)); cl_git_pass(git_tree_lookup(&cherrypicked_tree, repo, &cherrypicked_tree_oid)); cl_git_pass(git_commit_create(&cherrypicked_oid, repo, "HEAD", signature, signature, NULL, - "Cherry picked!", cherrypicked_tree, 1, (const git_commit **)&head)); + "Cherry picked!", cherrypicked_tree, 1, &head)); cl_assert(merge_test_index(repo_index, merge_index_entries + i * 3, 3)); diff --git a/tests/libgit2/commit/commit.c b/tests/libgit2/commit/commit.c index 140f87d0c72..923740f23af 100644 --- a/tests/libgit2/commit/commit.c +++ b/tests/libgit2/commit/commit.c @@ -36,11 +36,11 @@ void test_commit_commit__create_unexisting_update_ref(void) cl_git_fail(git_reference_lookup(&ref, _repo, "refs/heads/foo/bar")); cl_git_pass(git_commit_create(&oid, _repo, "refs/heads/foo/bar", s, s, - NULL, "some msg", tree, 1, (const git_commit **) &commit)); + NULL, "some msg", tree, 1, &commit)); /* fail because the parent isn't the tip of the branch anymore */ cl_git_fail(git_commit_create(&oid, _repo, "refs/heads/foo/bar", s, s, - NULL, "some msg", tree, 1, (const git_commit **) &commit)); + NULL, "some msg", tree, 1, &commit)); cl_git_pass(git_reference_lookup(&ref, _repo, "refs/heads/foo/bar")); cl_assert_equal_oid(&oid, git_reference_target(ref)); diff --git a/tests/libgit2/commit/write.c b/tests/libgit2/commit/write.c index 890f7384b1a..d38b54d2077 100644 --- a/tests/libgit2/commit/write.c +++ b/tests/libgit2/commit/write.c @@ -118,7 +118,7 @@ void test_commit_write__into_buf(void) cl_git_pass(git_commit_lookup(&parent, g_repo, &parent_id)); cl_git_pass(git_commit_create_buffer(&commit, g_repo, author, committer, - NULL, root_commit_message, tree, 1, (const git_commit **) &parent)); + NULL, root_commit_message, tree, 1, &parent)); cl_assert_equal_s(commit.ptr, "tree 1810dff58d8a660512d4832e740f692884338ccd\n\ diff --git a/tests/libgit2/diff/rename.c b/tests/libgit2/diff/rename.c index 61a2f839cb3..15dee5c97d5 100644 --- a/tests/libgit2/diff/rename.c +++ b/tests/libgit2/diff/rename.c @@ -424,7 +424,7 @@ void test_diff_rename__test_small_files(void) cl_git_pass(git_index_write_tree(&oid, index)); cl_git_pass(git_tree_lookup(&commit_tree, g_repo, &oid)); cl_git_pass(git_signature_new(&signature, "Rename", "rename@example.com", 1404157834, 0)); - cl_git_pass(git_commit_create(&oid, g_repo, "HEAD", signature, signature, NULL, "Test commit", commit_tree, 1, (const git_commit**)&head_commit)); + cl_git_pass(git_commit_create(&oid, g_repo, "HEAD", signature, signature, NULL, "Test commit", commit_tree, 1, &head_commit)); cl_git_mkfile("renames/copy.txt", "Hello World!\n"); cl_git_rmfile("renames/small.txt"); diff --git a/tests/libgit2/odb/freshen.c b/tests/libgit2/odb/freshen.c index e337c82b773..d0e0e3c3c04 100644 --- a/tests/libgit2/odb/freshen.c +++ b/tests/libgit2/odb/freshen.c @@ -125,7 +125,7 @@ void test_odb_freshen__tree_during_commit(void) cl_git_pass(git_commit_create(&commit_id, repo, NULL, signature, signature, NULL, "New commit pointing to old tree", - tree, 1, (const git_commit **)&parent)); + tree, 1, &parent)); /* make sure we freshen the tree the commit points to */ cl_must_pass(p_lstat("testrepo.git/objects/" LOOSE_TREE_FN, &after)); diff --git a/tests/libgit2/rebase/sign.c b/tests/libgit2/rebase/sign.c index 69bb1c6f998..45bac29d095 100644 --- a/tests/libgit2/rebase/sign.c +++ b/tests/libgit2/rebase/sign.c @@ -26,7 +26,7 @@ static int create_cb_passthrough( const char *message, const git_tree *tree, size_t parent_count, - const git_commit *parents[], + git_commit * const parents[], void *payload) { GIT_UNUSED(out); @@ -94,7 +94,7 @@ static int create_cb_signed_gpg( const char *message, const git_tree *tree, size_t parent_count, - const git_commit *parents[], + git_commit * const parents[], void *payload) { git_buf commit_content = GIT_BUF_INIT; @@ -202,7 +202,7 @@ static int create_cb_error( const char *message, const git_tree *tree, size_t parent_count, - const git_commit *parents[], + git_commit * const parents[], void *payload) { GIT_UNUSED(out); diff --git a/tests/libgit2/refs/reflog/messages.c b/tests/libgit2/refs/reflog/messages.c index 647c00d0dfd..4a2ecb02aed 100644 --- a/tests/libgit2/refs/reflog/messages.c +++ b/tests/libgit2/refs/reflog/messages.c @@ -233,7 +233,7 @@ void test_refs_reflog_messages__show_merge_for_merge_commits(void) cl_git_pass(git_commit_create(&merge_commit_oid, g_repo, "HEAD", s, s, NULL, "Merge commit", tree, - 2, (const struct git_commit **) parent_commits)); + 2, parent_commits)); cl_reflog_check_entry(g_repo, GIT_HEAD_FILE, 0, NULL, diff --git a/tests/libgit2/revert/workdir.c b/tests/libgit2/revert/workdir.c index 3e790b77f78..6d74254e533 100644 --- a/tests/libgit2/revert/workdir.c +++ b/tests/libgit2/revert/workdir.c @@ -188,7 +188,7 @@ void test_revert_workdir__again(void) cl_git_pass(git_tree_lookup(&reverted_tree, repo, &reverted_tree_oid)); cl_git_pass(git_signature_new(&signature, "Reverter", "reverter@example.org", time(NULL), 0)); - cl_git_pass(git_commit_create(&reverted_commit_oid, repo, "HEAD", signature, signature, NULL, "Reverted!", reverted_tree, 1, (const git_commit **)&orig_head)); + cl_git_pass(git_commit_create(&reverted_commit_oid, repo, "HEAD", signature, signature, NULL, "Reverted!", reverted_tree, 1, &orig_head)); cl_git_pass(git_revert(repo, orig_head, NULL)); cl_assert(merge_test_index(repo_index, merge_index_entries, 4)); @@ -238,7 +238,7 @@ void test_revert_workdir__again_after_automerge(void) cl_git_pass(git_tree_lookup(&reverted_tree, repo, &reverted_tree_oid)); cl_git_pass(git_signature_new(&signature, "Reverter", "reverter@example.org", time(NULL), 0)); - cl_git_pass(git_commit_create(&reverted_commit_oid, repo, "HEAD", signature, signature, NULL, "Reverted!", reverted_tree, 1, (const git_commit **)&head)); + cl_git_pass(git_commit_create(&reverted_commit_oid, repo, "HEAD", signature, signature, NULL, "Reverted!", reverted_tree, 1, &head)); cl_git_pass(git_revert(repo, commit, NULL)); cl_assert(merge_test_index(repo_index, second_revert_entries, 6)); @@ -287,7 +287,7 @@ void test_revert_workdir__again_after_edit(void) cl_git_pass(git_tree_lookup(&reverted_tree, repo, &reverted_tree_oid)); cl_git_pass(git_signature_new(&signature, "Reverter", "reverter@example.org", time(NULL), 0)); - cl_git_pass(git_commit_create(&reverted_commit_oid, repo, "HEAD", signature, signature, NULL, "Reverted!", reverted_tree, 1, (const git_commit **)&orig_head)); + cl_git_pass(git_commit_create(&reverted_commit_oid, repo, "HEAD", signature, signature, NULL, "Reverted!", reverted_tree, 1, &orig_head)); cl_git_pass(git_revert(repo, commit, NULL)); cl_assert(merge_test_index(repo_index, merge_index_entries, 4)); diff --git a/tests/libgit2/revwalk/basic.c b/tests/libgit2/revwalk/basic.c index 41090a1dac8..5c53405051b 100644 --- a/tests/libgit2/revwalk/basic.c +++ b/tests/libgit2/revwalk/basic.c @@ -550,8 +550,7 @@ void test_revwalk_basic__big_timestamp(void) cl_git_pass(git_signature_new(&sig, "Joe", "joe@example.com", INT64_C(2399662595), 0)); cl_git_pass(git_commit_tree(&tree, tip)); - cl_git_pass(git_commit_create(&id, _repo, "HEAD", sig, sig, NULL, "some message", tree, 1, - (const git_commit **)&tip)); + cl_git_pass(git_commit_create(&id, _repo, "HEAD", sig, sig, NULL, "some message", tree, 1, &tip)); cl_git_pass(git_revwalk_push_head(_walk)); From fddfca35267765feb23be26e8b402781e778225e Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 15 Jan 2024 00:06:26 +0000 Subject: [PATCH 460/608] tests: add `cl_assert_equal_oidstr` helper method --- tests/clar/clar_libgit2.h | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/tests/clar/clar_libgit2.h b/tests/clar/clar_libgit2.h index c33b5d28bed..d8105c841b4 100644 --- a/tests/clar/clar_libgit2.h +++ b/tests/clar/clar_libgit2.h @@ -166,10 +166,27 @@ GIT_INLINE(void) clar__assert_equal_oid( } } +GIT_INLINE(void) clar__assert_equal_oidstr( + const char *file, const char *func, int line, const char *desc, + const char *one_str, const git_oid *two) +{ + git_oid one; + + if (git_oid__fromstr(&one, one_str, git_oid_type(two)) < 0) { + clar__fail(file, func, line, desc, "could not parse oid string", 1); + } else { + clar__assert_equal_oid(file, func, line, desc, &one, two); + } +} + #define cl_assert_equal_oid(one, two) \ clar__assert_equal_oid(__FILE__, __func__, __LINE__, \ "OID mismatch: " #one " != " #two, (one), (two)) +#define cl_assert_equal_oidstr(one_str, two) \ + clar__assert_equal_oidstr(__FILE__, __func__, __LINE__, \ + "OID mismatch: " #one_str " != " #two, (one_str), (two)) + /* * Some utility macros for building long strings */ From 67a4d04b5984c3dab681b59f67f4255be8c38eef Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 15 Jan 2024 00:08:16 +0000 Subject: [PATCH 461/608] commit: introduce `git_commit_create_from_stage` Provide a simple helper method that allows users to create a commit from the current index with minimal information. --- include/git2/commit.h | 30 +++++++++ include/git2/errors.h | 3 +- src/libgit2/commit.c | 73 ++++++++++++++++++++++ tests/libgit2/commit/create.c | 112 ++++++++++++++++++++++++++++++++++ 4 files changed, 217 insertions(+), 1 deletion(-) create mode 100644 tests/libgit2/commit/create.c diff --git a/include/git2/commit.h b/include/git2/commit.h index ea0e94969a8..7d2740dc1dd 100644 --- a/include/git2/commit.h +++ b/include/git2/commit.h @@ -394,6 +394,36 @@ GIT_EXTERN(int) git_commit_create_v( size_t parent_count, ...); +typedef struct { + unsigned int version; + + unsigned int allow_empty_commit : 1; + + const git_signature *author; + const git_signature *committer; +} git_commit_create_options; + +#define GIT_COMMIT_CREATE_OPTIONS_VERSION 1 +#define GIT_COMMIT_CREATE_OPTIONS_INIT { GIT_COMMIT_CREATE_OPTIONS_VERSION } + +/** + * Commits the staged changes in the repository; this is a near analog to + * `git commit -m message`. + * + * By default, empty commits are not allowed. + * + * @param id pointer to store the new commit's object id + * @param repo repository to commit changes in + * @param message the commit message + * @param opts options for creating the commit + * @return 0 on success, GIT_EUNCHANGED if there were no changes to commit, or an error code + */ +GIT_EXTERN(int) git_commit_create_from_stage( + git_oid *id, + git_repository *repo, + const char *message, + const git_commit_create_options *opts); + /** * Amend an existing commit by replacing only non-NULL values. * diff --git a/include/git2/errors.h b/include/git2/errors.h index face0898a12..bdace8c43dd 100644 --- a/include/git2/errors.h +++ b/include/git2/errors.h @@ -59,7 +59,8 @@ typedef enum { GIT_EINDEXDIRTY = -34, /**< Unsaved changes in the index would be overwritten */ GIT_EAPPLYFAIL = -35, /**< Patch application failed */ GIT_EOWNER = -36, /**< The object is not owned by the current user */ - GIT_TIMEOUT = -37 /**< The operation timed out */ + GIT_TIMEOUT = -37, /**< The operation timed out */ + GIT_EUNCHANGED = -38 /**< There were no changes */ } git_error_code; /** diff --git a/src/libgit2/commit.c b/src/libgit2/commit.c index 9e3b29a00b8..10257601579 100644 --- a/src/libgit2/commit.c +++ b/src/libgit2/commit.c @@ -1086,6 +1086,79 @@ int git_commit_create_with_signature( return error; } +int git_commit_create_from_stage( + git_oid *out, + git_repository *repo, + const char *message, + const git_commit_create_options *given_opts) +{ + git_commit_create_options opts = GIT_COMMIT_CREATE_OPTIONS_INIT; + git_signature *default_signature = NULL; + const git_signature *author, *committer; + git_index *index = NULL; + git_diff *diff = NULL; + git_oid tree_id; + git_tree *head_tree = NULL, *tree = NULL; + git_commitarray parents = { 0 }; + int error = -1; + + GIT_ASSERT_ARG(out && repo); + + if (given_opts) + memcpy(&opts, given_opts, sizeof(git_commit_create_options)); + + if ((author = opts.author) == NULL || + (committer = opts.committer) == NULL) { + if (git_signature_default(&default_signature, repo) < 0) + goto done; + + if (!author) + author = default_signature; + + if (!committer) + committer = default_signature; + } + + if (git_repository_index(&index, repo) < 0) + goto done; + + if (!opts.allow_empty_commit) { + error = git_repository_head_tree(&head_tree, repo); + + if (error && error != GIT_EUNBORNBRANCH) + goto done; + + error = -1; + + if (git_diff_tree_to_index(&diff, repo, head_tree, index, NULL) < 0) + goto done; + + if (git_diff_num_deltas(diff) == 0) { + git_error_set(GIT_ERROR_REPOSITORY, + "no changes are staged for commit"); + error = GIT_EUNCHANGED; + goto done; + } + } + + if (git_index_write_tree(&tree_id, index) < 0 || + git_tree_lookup(&tree, repo, &tree_id) < 0 || + git_repository_commit_parents(&parents, repo) < 0) + goto done; + + error = git_commit_create(out, repo, "HEAD", author, committer, + NULL, message, tree, parents.count, parents.commits); + +done: + git_commitarray_dispose(&parents); + git_signature_free(default_signature); + git_tree_free(tree); + git_tree_free(head_tree); + git_diff_free(diff); + git_index_free(index); + return error; +} + int git_commit_committer_with_mailmap( git_signature **out, const git_commit *commit, const git_mailmap *mailmap) { diff --git a/tests/libgit2/commit/create.c b/tests/libgit2/commit/create.c new file mode 100644 index 00000000000..9f627dc87b5 --- /dev/null +++ b/tests/libgit2/commit/create.c @@ -0,0 +1,112 @@ +#include "clar_libgit2.h" +#include "repository.h" + +/* Fixture setup */ +static git_repository *g_repo; +static git_signature *g_author, *g_committer; + +void test_commit_create__initialize(void) +{ + g_repo = cl_git_sandbox_init("testrepo2"); + cl_git_pass(git_signature_new(&g_author, "Edward Thomson", "ethomson@edwardthomson.com", 123456789, 60)); + cl_git_pass(git_signature_new(&g_committer, "libgit2 user", "nobody@noreply.libgit2.org", 987654321, 90)); +} + +void test_commit_create__cleanup(void) +{ + git_signature_free(g_committer); + git_signature_free(g_author); + cl_git_sandbox_cleanup(); +} + + +void test_commit_create__from_stage_simple(void) +{ + git_commit_create_options opts = GIT_COMMIT_CREATE_OPTIONS_INIT; + git_index *index; + git_oid commit_id; + git_tree *tree; + + opts.author = g_author; + opts.committer = g_committer; + + cl_git_rewritefile("testrepo2/newfile.txt", "This is a new file.\n"); + cl_git_rewritefile("testrepo2/newfile2.txt", "This is a new file.\n"); + cl_git_rewritefile("testrepo2/README", "hello, world.\n"); + cl_git_rewritefile("testrepo2/new.txt", "hi there.\n"); + + cl_git_pass(git_repository_index(&index, g_repo)); + cl_git_pass(git_index_add_bypath(index, "newfile2.txt")); + cl_git_pass(git_index_add_bypath(index, "README")); + cl_git_pass(git_index_write(index)); + + cl_git_pass(git_commit_create_from_stage(&commit_id, g_repo, "This is the message.", &opts)); + + cl_git_pass(git_repository_head_tree(&tree, g_repo)); + + cl_assert_equal_oidstr("241b5b04e847bc38dd7b4b9f49f21e55da40f3a6", &commit_id); + cl_assert_equal_oidstr("b27210772d0633870b4f486d04ed3eb5ebbef5e7", git_tree_id(tree)); + + git_index_free(index); + git_tree_free(tree); +} + +void test_commit_create__from_stage_nochanges(void) +{ + git_commit_create_options opts = GIT_COMMIT_CREATE_OPTIONS_INIT; + git_oid commit_id; + git_tree *tree; + + opts.author = g_author; + opts.committer = g_committer; + + cl_git_fail_with(GIT_EUNCHANGED, git_commit_create_from_stage(&commit_id, g_repo, "Message goes here.", &opts)); + + opts.allow_empty_commit = 1; + + cl_git_pass(git_commit_create_from_stage(&commit_id, g_repo, "Message goes here.", &opts)); + + cl_git_pass(git_repository_head_tree(&tree, g_repo)); + + cl_assert_equal_oidstr("f776dc4c7fd8164b7127dc8e4f9b44421cb01b56", &commit_id); + cl_assert_equal_oidstr("c4dc1555e4d4fa0e0c9c3fc46734c7c35b3ce90b", git_tree_id(tree)); + + git_tree_free(tree); +} + +void test_commit_create__from_stage_newrepo(void) +{ + git_commit_create_options opts = GIT_COMMIT_CREATE_OPTIONS_INIT; + git_repository *newrepo; + git_index *index; + git_commit *commit; + git_tree *tree; + git_oid commit_id; + + opts.author = g_author; + opts.committer = g_committer; + + git_repository_init(&newrepo, "newrepo", false); + cl_git_pass(git_repository_index(&index, newrepo)); + + cl_git_rewritefile("newrepo/hello.txt", "hello, world.\n"); + cl_git_rewritefile("newrepo/hi.txt", "hi there.\n"); + cl_git_rewritefile("newrepo/foo.txt", "bar.\n"); + + cl_git_pass(git_index_add_bypath(index, "hello.txt")); + cl_git_pass(git_index_add_bypath(index, "foo.txt")); + cl_git_pass(git_index_write(index)); + + cl_git_pass(git_commit_create_from_stage(&commit_id, newrepo, "Initial commit.", &opts)); + cl_git_pass(git_repository_head_commit(&commit, newrepo)); + cl_git_pass(git_repository_head_tree(&tree, newrepo)); + + cl_assert_equal_oid(&commit_id, git_commit_id(commit)); + cl_assert_equal_oidstr("b2fa96a4f191c76eb172437281c66aa29609dcaa", git_commit_tree_id(commit)); + + git_tree_free(tree); + git_commit_free(commit); + git_index_free(index); + git_repository_free(newrepo); + cl_fixture_cleanup("newrepo"); +} From 55381816e83c268651e5adfd4314c724be75ef27 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 15 Jan 2024 15:52:35 +0000 Subject: [PATCH 462/608] commit: support specifying encoding for message --- include/git2/commit.h | 13 +++++++++++++ src/libgit2/commit.c | 3 ++- 2 files changed, 15 insertions(+), 1 deletion(-) diff --git a/include/git2/commit.h b/include/git2/commit.h index 7d2740dc1dd..ef38c66e6cc 100644 --- a/include/git2/commit.h +++ b/include/git2/commit.h @@ -397,10 +397,23 @@ GIT_EXTERN(int) git_commit_create_v( typedef struct { unsigned int version; + /** + * Flags for creating the commit. + * + * If `allow_empty_commit` is specified, a commit with no changes + * from the prior commit (and "empty" commit) is allowed. Otherwise, + * commit creation will be stopped. + */ unsigned int allow_empty_commit : 1; + /** The commit author, or NULL for the default. */ const git_signature *author; + + /** The committer, or NULL for the default. */ const git_signature *committer; + + /** Encoding for the commit message; leave NULL for default. */ + const char *message_encoding; } git_commit_create_options; #define GIT_COMMIT_CREATE_OPTIONS_VERSION 1 diff --git a/src/libgit2/commit.c b/src/libgit2/commit.c index 10257601579..5582a65aadf 100644 --- a/src/libgit2/commit.c +++ b/src/libgit2/commit.c @@ -1147,7 +1147,8 @@ int git_commit_create_from_stage( goto done; error = git_commit_create(out, repo, "HEAD", author, committer, - NULL, message, tree, parents.count, parents.commits); + opts.message_encoding, message, + tree, parents.count, parents.commits); done: git_commitarray_dispose(&parents); From 216f698eb2e22ca5d6fbd58f60f6481a4e994934 Mon Sep 17 00:00:00 2001 From: Gregory Herrero Date: Mon, 15 Jan 2024 14:14:39 +0100 Subject: [PATCH 463/608] merge: fix incorrect rename detection for empty files. When merging trees containing multiple empty files, make sure a rename is not detected between each empty files. For example Ancestor has files: * foo.c with content * bar.c empty Ours has: * foo.c with content * boo.c empty Theirs has: * foo.c with other content * bar.c with content merge_trees() will incorrectly apply the content of theirs's 'bar.c' in ours's boo.c' thinking 'bar.c' has been renamed to 'boo.c'. This happens because both are empty and their sha1 are the same. Thus merge_diff_mark_similarity_exact() incorrectly mark it as renamed. Signed-off-by: Gregory Herrero --- src/libgit2/merge.c | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/src/libgit2/merge.c b/src/libgit2/merge.c index 0114e4b75a0..21e5ef6a8f9 100644 --- a/src/libgit2/merge.c +++ b/src/libgit2/merge.c @@ -1225,6 +1225,13 @@ static int merge_diff_mark_similarity_exact( if (!GIT_MERGE_INDEX_ENTRY_EXISTS(conflict_src->ancestor_entry)) continue; + /* + * Ignore empty files because it has always the same blob sha1 + * and will lead to incorrect matches between all entries. + */ + if (git_oid_equal(&conflict_src->ancestor_entry.id, &git_oid__empty_blob_sha1)) + continue; + if (!GIT_MERGE_INDEX_ENTRY_EXISTS(conflict_src->our_entry)) { error = deletes_by_oid_enqueue(ours_deletes_by_oid, &diff_list->pool, &conflict_src->ancestor_entry.id, i); if (error < 0) From 334dd8da93cb80c353fb3b363bfb730383f09fb8 Mon Sep 17 00:00:00 2001 From: Gregory Herrero Date: Mon, 15 Jan 2024 15:52:44 +0100 Subject: [PATCH 464/608] tests: merge: tree: add support for different ancestor. Add a boolean option to merge_trivial() so that it can use theirs parent instead of merge base as ancestor. This will be needed in the following commit. Signed-off-by: Gregory Herrero --- tests/libgit2/merge/trees/trivial.c | 36 ++++++++++++++++------------- 1 file changed, 20 insertions(+), 16 deletions(-) diff --git a/tests/libgit2/merge/trees/trivial.c b/tests/libgit2/merge/trees/trivial.c index 287a53cfe7a..becd618d358 100644 --- a/tests/libgit2/merge/trees/trivial.c +++ b/tests/libgit2/merge/trees/trivial.c @@ -25,7 +25,7 @@ void test_merge_trees_trivial__cleanup(void) } -static int merge_trivial(git_index **index, const char *ours, const char *theirs) +static int merge_trivial(git_index **index, const char *ours, const char *theirs, bool ancestor_use_parent) { git_commit *our_commit, *their_commit, *ancestor_commit; git_tree *our_tree, *their_tree, *ancestor_tree; @@ -42,8 +42,12 @@ static int merge_trivial(git_index **index, const char *ours, const char *theirs cl_git_pass(git_reference_name_to_id(&their_oid, repo, branch_buf.ptr)); cl_git_pass(git_commit_lookup(&their_commit, repo, &their_oid)); - cl_git_pass(git_merge_base(&ancestor_oid, repo, git_commit_id(our_commit), git_commit_id(their_commit))); - cl_git_pass(git_commit_lookup(&ancestor_commit, repo, &ancestor_oid)); + if (!ancestor_use_parent) { + cl_git_pass(git_merge_base(&ancestor_oid, repo, git_commit_id(our_commit), git_commit_id(their_commit))); + cl_git_pass(git_commit_lookup(&ancestor_commit, repo, &ancestor_oid)); + } else { + cl_git_pass(git_commit_parent(&ancestor_commit, their_commit, 0)); + } cl_git_pass(git_commit_tree(&ancestor_tree, ancestor_commit)); cl_git_pass(git_commit_tree(&our_tree, our_commit)); @@ -84,7 +88,7 @@ void test_merge_trees_trivial__2alt(void) git_index *result; const git_index_entry *entry; - cl_git_pass(merge_trivial(&result, "trivial-2alt", "trivial-2alt-branch")); + cl_git_pass(merge_trivial(&result, "trivial-2alt", "trivial-2alt-branch", false)); cl_assert(entry = git_index_get_bypath(result, "new-in-branch.txt", 0)); cl_assert(git_index_reuc_entrycount(result) == 0); @@ -99,7 +103,7 @@ void test_merge_trees_trivial__3alt(void) git_index *result; const git_index_entry *entry; - cl_git_pass(merge_trivial(&result, "trivial-3alt", "trivial-3alt-branch")); + cl_git_pass(merge_trivial(&result, "trivial-3alt", "trivial-3alt-branch", false)); cl_assert(entry = git_index_get_bypath(result, "new-in-3alt.txt", 0)); cl_assert(git_index_reuc_entrycount(result) == 0); @@ -114,7 +118,7 @@ void test_merge_trees_trivial__4(void) git_index *result; const git_index_entry *entry; - cl_git_pass(merge_trivial(&result, "trivial-4", "trivial-4-branch")); + cl_git_pass(merge_trivial(&result, "trivial-4", "trivial-4-branch", false)); cl_assert((entry = git_index_get_bypath(result, "new-and-different.txt", 0)) == NULL); cl_assert(git_index_reuc_entrycount(result) == 0); @@ -132,7 +136,7 @@ void test_merge_trees_trivial__5alt_1(void) git_index *result; const git_index_entry *entry; - cl_git_pass(merge_trivial(&result, "trivial-5alt-1", "trivial-5alt-1-branch")); + cl_git_pass(merge_trivial(&result, "trivial-5alt-1", "trivial-5alt-1-branch", false)); cl_assert(entry = git_index_get_bypath(result, "new-and-same.txt", 0)); cl_assert(git_index_reuc_entrycount(result) == 0); @@ -147,7 +151,7 @@ void test_merge_trees_trivial__5alt_2(void) git_index *result; const git_index_entry *entry; - cl_git_pass(merge_trivial(&result, "trivial-5alt-2", "trivial-5alt-2-branch")); + cl_git_pass(merge_trivial(&result, "trivial-5alt-2", "trivial-5alt-2-branch", false)); cl_assert(entry = git_index_get_bypath(result, "modified-to-same.txt", 0)); cl_assert(git_index_reuc_entrycount(result) == 0); @@ -163,7 +167,7 @@ void test_merge_trees_trivial__6(void) const git_index_entry *entry; const git_index_reuc_entry *reuc; - cl_git_pass(merge_trivial(&result, "trivial-6", "trivial-6-branch")); + cl_git_pass(merge_trivial(&result, "trivial-6", "trivial-6-branch", false)); cl_assert((entry = git_index_get_bypath(result, "removed-in-both.txt", 0)) == NULL); cl_assert(git_index_reuc_entrycount(result) == 1); @@ -181,7 +185,7 @@ void test_merge_trees_trivial__8(void) const git_index_entry *entry; const git_index_reuc_entry *reuc; - cl_git_pass(merge_trivial(&result, "trivial-8", "trivial-8-branch")); + cl_git_pass(merge_trivial(&result, "trivial-8", "trivial-8-branch", false)); cl_assert((entry = git_index_get_bypath(result, "removed-in-8.txt", 0)) == NULL); @@ -199,7 +203,7 @@ void test_merge_trees_trivial__7(void) git_index *result; const git_index_entry *entry; - cl_git_pass(merge_trivial(&result, "trivial-7", "trivial-7-branch")); + cl_git_pass(merge_trivial(&result, "trivial-7", "trivial-7-branch", false)); cl_assert((entry = git_index_get_bypath(result, "removed-in-7.txt", 0)) == NULL); cl_assert(git_index_reuc_entrycount(result) == 0); @@ -218,7 +222,7 @@ void test_merge_trees_trivial__10(void) const git_index_entry *entry; const git_index_reuc_entry *reuc; - cl_git_pass(merge_trivial(&result, "trivial-10", "trivial-10-branch")); + cl_git_pass(merge_trivial(&result, "trivial-10", "trivial-10-branch", false)); cl_assert((entry = git_index_get_bypath(result, "removed-in-10-branch.txt", 0)) == NULL); @@ -236,7 +240,7 @@ void test_merge_trees_trivial__9(void) git_index *result; const git_index_entry *entry; - cl_git_pass(merge_trivial(&result, "trivial-9", "trivial-9-branch")); + cl_git_pass(merge_trivial(&result, "trivial-9", "trivial-9-branch", false)); cl_assert((entry = git_index_get_bypath(result, "removed-in-9-branch.txt", 0)) == NULL); cl_assert(git_index_reuc_entrycount(result) == 0); @@ -255,7 +259,7 @@ void test_merge_trees_trivial__13(void) const git_index_entry *entry; git_oid expected_oid; - cl_git_pass(merge_trivial(&result, "trivial-13", "trivial-13-branch")); + cl_git_pass(merge_trivial(&result, "trivial-13", "trivial-13-branch", false)); cl_assert(entry = git_index_get_bypath(result, "modified-in-13.txt", 0)); cl_git_pass(git_oid__fromstr(&expected_oid, "1cff9ec6a47a537380dedfdd17c9e76d74259a2b", GIT_OID_SHA1)); @@ -274,7 +278,7 @@ void test_merge_trees_trivial__14(void) const git_index_entry *entry; git_oid expected_oid; - cl_git_pass(merge_trivial(&result, "trivial-14", "trivial-14-branch")); + cl_git_pass(merge_trivial(&result, "trivial-14", "trivial-14-branch", false)); cl_assert(entry = git_index_get_bypath(result, "modified-in-14-branch.txt", 0)); cl_git_pass(git_oid__fromstr(&expected_oid, "26153a3ff3649b6c2bb652d3f06878c6e0a172f9", GIT_OID_SHA1)); @@ -292,7 +296,7 @@ void test_merge_trees_trivial__11(void) git_index *result; const git_index_entry *entry; - cl_git_pass(merge_trivial(&result, "trivial-11", "trivial-11-branch")); + cl_git_pass(merge_trivial(&result, "trivial-11", "trivial-11-branch", false)); cl_assert((entry = git_index_get_bypath(result, "modified-in-both.txt", 0)) == NULL); cl_assert(git_index_reuc_entrycount(result) == 0); From 16688efa412208d0ed6d90d24ae632abda9c8a4d Mon Sep 17 00:00:00 2001 From: Gregory Herrero Date: Mon, 15 Jan 2024 15:46:00 +0100 Subject: [PATCH 465/608] tests: merge: tree: detect incorrect renames. This test follow "merge: fix incorrect rename detection for empty files." commit. Signed-off-by: Gregory Herrero --- tests/libgit2/merge/trees/trivial.c | 19 ++++++++++++++++++ .../.gitted/logs/refs/heads/trivial-15 | 1 + .../.gitted/logs/refs/heads/trivial-15-branch | 2 ++ .../1d/6a96dd04ac7354ae6bb4ba24c514500fd0ec89 | Bin 0 -> 279 bytes .../48/320305de02310b9c4fd744243b9b0d1d5f11af | Bin 0 -> 46 bytes .../67/06996f054c6af4fec7c77939d00e2f486dab4c | Bin 0 -> 172 bytes .../c0/d1f321977d1c18e23a28c581fed6d17d0cc013 | Bin 0 -> 273 bytes .../c4/52c5eb5aacf204fc95a55d1eb9668736fecfb6 | Bin 0 -> 163 bytes .../c5/be2acabac675af81df8bb70400235af2a9c225 | 4 ++++ .../cd/d1cd02dbd164e9d18a644515bc2ca6551f13b4 | Bin 0 -> 280 bytes .../.gitted/refs/heads/trivial-15 | 1 + .../.gitted/refs/heads/trivial-15-branch | 1 + 12 files changed, 28 insertions(+) create mode 100644 tests/resources/merge-resolve/.gitted/logs/refs/heads/trivial-15 create mode 100644 tests/resources/merge-resolve/.gitted/logs/refs/heads/trivial-15-branch create mode 100644 tests/resources/merge-resolve/.gitted/objects/1d/6a96dd04ac7354ae6bb4ba24c514500fd0ec89 create mode 100644 tests/resources/merge-resolve/.gitted/objects/48/320305de02310b9c4fd744243b9b0d1d5f11af create mode 100644 tests/resources/merge-resolve/.gitted/objects/67/06996f054c6af4fec7c77939d00e2f486dab4c create mode 100644 tests/resources/merge-resolve/.gitted/objects/c0/d1f321977d1c18e23a28c581fed6d17d0cc013 create mode 100644 tests/resources/merge-resolve/.gitted/objects/c4/52c5eb5aacf204fc95a55d1eb9668736fecfb6 create mode 100644 tests/resources/merge-resolve/.gitted/objects/c5/be2acabac675af81df8bb70400235af2a9c225 create mode 100644 tests/resources/merge-resolve/.gitted/objects/cd/d1cd02dbd164e9d18a644515bc2ca6551f13b4 create mode 100644 tests/resources/merge-resolve/.gitted/refs/heads/trivial-15 create mode 100644 tests/resources/merge-resolve/.gitted/refs/heads/trivial-15-branch diff --git a/tests/libgit2/merge/trees/trivial.c b/tests/libgit2/merge/trees/trivial.c index becd618d358..7f9d918e806 100644 --- a/tests/libgit2/merge/trees/trivial.c +++ b/tests/libgit2/merge/trees/trivial.c @@ -308,3 +308,22 @@ void test_merge_trees_trivial__11(void) git_index_free(result); } + +/* 15: ancest:remote^, head:head, remote:remote = result:no merge */ +void test_merge_trees_trivial__15(void) +{ + git_index *result; + const git_index_entry *entry; + + /* Can't use merge_trivialfalsehere because a different ancestor is used. */ + cl_git_pass(merge_trivial(&result, "trivial-15", "trivial-15-branch", true)); + + cl_assert((entry = git_index_get_bypath(result, "another-new-empty-15.txt", GIT_INDEX_STAGE_NORMAL)) == NULL); + cl_assert((entry = git_index_get_bypath(result, "another-new-empty-15.txt", GIT_INDEX_STAGE_ANCESTOR))); + cl_assert((entry = git_index_get_bypath(result, "another-new-empty-15.txt", GIT_INDEX_STAGE_OURS)) == NULL); + cl_assert((entry = git_index_get_bypath(result, "another-new-empty-15.txt", GIT_INDEX_STAGE_THEIRS))); + cl_assert(merge_trivial_conflict_entrycount(result) == 2); + + git_index_free(result); +} + diff --git a/tests/resources/merge-resolve/.gitted/logs/refs/heads/trivial-15 b/tests/resources/merge-resolve/.gitted/logs/refs/heads/trivial-15 new file mode 100644 index 00000000000..c71411b5f11 --- /dev/null +++ b/tests/resources/merge-resolve/.gitted/logs/refs/heads/trivial-15 @@ -0,0 +1 @@ +0000000000000000000000000000000000000000 c452c5eb5aacf204fc95a55d1eb9668736fecfb6 Gregory Herrero 1705326305 +0100 push diff --git a/tests/resources/merge-resolve/.gitted/logs/refs/heads/trivial-15-branch b/tests/resources/merge-resolve/.gitted/logs/refs/heads/trivial-15-branch new file mode 100644 index 00000000000..f85a1e96dd9 --- /dev/null +++ b/tests/resources/merge-resolve/.gitted/logs/refs/heads/trivial-15-branch @@ -0,0 +1,2 @@ +0000000000000000000000000000000000000000 6706996f054c6af4fec7c77939d00e2f486dab4c Gregory Herrero 1705326302 +0100 push +6706996f054c6af4fec7c77939d00e2f486dab4c c5be2acabac675af81df8bb70400235af2a9c225 Gregory Herrero 1705326412 +0100 push diff --git a/tests/resources/merge-resolve/.gitted/objects/1d/6a96dd04ac7354ae6bb4ba24c514500fd0ec89 b/tests/resources/merge-resolve/.gitted/objects/1d/6a96dd04ac7354ae6bb4ba24c514500fd0ec89 new file mode 100644 index 0000000000000000000000000000000000000000..ec618090bdf04fd36e456a413c316a3e8ab4dca1 GIT binary patch literal 279 zcmV+y0qFjC0V^p=O;s>9H)k+3FfcPQQAo_oFUd$P(#=aP*G|#Ju#>6y3}`-K3(#yyOh9hSfPPi(a@)TI=n&J9|yLsoh+rHQksRaubV7 zQi}*`$j?j5$xJTE%u5F=y`uhL(?g2@DO=Gq<_YDCljTJBx*O7ai1V#(6;Mw#=Y#jm>Q5A6JwpRT>i+fSTp_0?Qy}vHCa*HmqIm^0(}VfFxV+4 dKIH3JZ<^*#A Cyb`|v literal 0 HcmV?d00001 diff --git a/tests/resources/merge-resolve/.gitted/objects/67/06996f054c6af4fec7c77939d00e2f486dab4c b/tests/resources/merge-resolve/.gitted/objects/67/06996f054c6af4fec7c77939d00e2f486dab4c new file mode 100644 index 0000000000000000000000000000000000000000..92ddbf0be101a048e8e819dac29dfdc5a4305659 GIT binary patch literal 172 zcmV;d08{^X0j17OY6CG0hT*P#3h&Ddl08yf2%)?78n&$YflOS46Ugl|kRx>a@bd9V z+xM;eK=jc~)l01?6+$f)dD5?nDf2WDQjs8;iEzePCij<3Z`}*SX_g2nMU9cF&LK(V z#N`NC<_w_#tGImcYcv02x-@(GUo}%}{=B?lT;K5BEX!3#Y5T?F2`B~*0sSW+fIIYf a+x5RYuG{w5@^wHOishTEqk91!2~$WI3Rb58 literal 0 HcmV?d00001 diff --git a/tests/resources/merge-resolve/.gitted/objects/c0/d1f321977d1c18e23a28c581fed6d17d0cc013 b/tests/resources/merge-resolve/.gitted/objects/c0/d1f321977d1c18e23a28c581fed6d17d0cc013 new file mode 100644 index 0000000000000000000000000000000000000000..4c20a212ade60c6f8046f0f5384bb06e145ce014 GIT binary patch literal 273 zcmV+s0q*{I0V^p=O;s>9vt%$dFfcPQQAjK;$5Ep%1PBLsVHGc5;`oqI?hAM z{rdDef8NUpvTr_GLlq}yB<7{3rs!to=_VB=<|Su>F;6I8oGd50*9~fRUTV2+ zYHmSErLLhVSnad9k7jSWc+J_nTXS7`)Qv+=dV(iH)fT1Z=9ghO{Ql!l+N8 zkTGc6^*G~R_FYU3NDhy&&R8ygh_N7J5=Yr3_6e($P%su?1|;*!D$i~?K&(uV5($wnQkS}f6h@CV zaLwRG2*M`6`@N~XsN9-NRjNr)yB(hsT0JG@ww#&ae Rrt9>X@?(d7Fh7HwP+9wjOc4M8 literal 0 HcmV?d00001 diff --git a/tests/resources/merge-resolve/.gitted/objects/c5/be2acabac675af81df8bb70400235af2a9c225 b/tests/resources/merge-resolve/.gitted/objects/c5/be2acabac675af81df8bb70400235af2a9c225 new file mode 100644 index 00000000000..848f341c929 --- /dev/null +++ b/tests/resources/merge-resolve/.gitted/objects/c5/be2acabac675af81df8bb70400235af2a9c225 @@ -0,0 +1,4 @@ +xAj1 @Ѭ} +CyFc(%,g2qno G->_o1P3 +ȒT +Qb*{}xJ@9SBܰ$I)/L 㟱v_n[Ժ`Z_prIC̄@=y;ݎn|;x*wY'IS \ No newline at end of file diff --git a/tests/resources/merge-resolve/.gitted/objects/cd/d1cd02dbd164e9d18a644515bc2ca6551f13b4 b/tests/resources/merge-resolve/.gitted/objects/cd/d1cd02dbd164e9d18a644515bc2ca6551f13b4 new file mode 100644 index 0000000000000000000000000000000000000000..d2385b8f2353863209a288ba2cd3edc4ef04cfad GIT binary patch literal 280 zcmV+z0q6dB0V^p=O;s>9H)k+3FfcPQQAo_oFUd$P(#=aP*GO{^L*D ztK{>~g}6_UF=*TMIOAUST}%x~j)}3(ST29$SFD--<@UH>;hLAL e6Cd*RtT#<_EJ?4M_+j;{3r}q3#R3319++g`S&~%% literal 0 HcmV?d00001 diff --git a/tests/resources/merge-resolve/.gitted/refs/heads/trivial-15 b/tests/resources/merge-resolve/.gitted/refs/heads/trivial-15 new file mode 100644 index 00000000000..d6149eb8131 --- /dev/null +++ b/tests/resources/merge-resolve/.gitted/refs/heads/trivial-15 @@ -0,0 +1 @@ +c452c5eb5aacf204fc95a55d1eb9668736fecfb6 diff --git a/tests/resources/merge-resolve/.gitted/refs/heads/trivial-15-branch b/tests/resources/merge-resolve/.gitted/refs/heads/trivial-15-branch new file mode 100644 index 00000000000..a255d1a3a95 --- /dev/null +++ b/tests/resources/merge-resolve/.gitted/refs/heads/trivial-15-branch @@ -0,0 +1 @@ +c5be2acabac675af81df8bb70400235af2a9c225 From 392e380463f23981f52fbc0cae53721234984fbf Mon Sep 17 00:00:00 2001 From: Mark Date: Thu, 18 Jan 2024 23:13:14 -0500 Subject: [PATCH 466/608] set SSH timeout --- include/git2/common.h | 3 +-- src/libgit2/transports/ssh_libssh2.c | 6 ++++++ 2 files changed, 7 insertions(+), 2 deletions(-) diff --git a/include/git2/common.h b/include/git2/common.h index ab6bc1333b3..7736a0af9fc 100644 --- a/include/git2/common.h +++ b/include/git2/common.h @@ -490,8 +490,7 @@ typedef enum { * * opts(GIT_OPT_SET_SERVER_CONNECT_TIMEOUT, int timeout) * > Sets the timeout (in milliseconds) to attempt connections to - * > a remote server. This is supported only for HTTP(S) connections - * > and is not supported by SSH. Set to 0 to use the system default. + * > a remote server. Set to 0 to use the system default. * > Note that this may not be able to be configured longer than the * > system default, typically 75 seconds. * diff --git a/src/libgit2/transports/ssh_libssh2.c b/src/libgit2/transports/ssh_libssh2.c index d2be2ba3387..89f341f2108 100644 --- a/src/libgit2/transports/ssh_libssh2.c +++ b/src/libgit2/transports/ssh_libssh2.c @@ -23,6 +23,8 @@ #define OWNING_SUBTRANSPORT(s) ((ssh_subtransport *)(s)->parent.subtransport) +extern int git_socket_stream__connect_timeout; + static const char cmd_uploadpack[] = "git-upload-pack"; static const char cmd_receivepack[] = "git-receive-pack"; @@ -539,6 +541,10 @@ static int _git_ssh_session_create( return -1; } + if (git_socket_stream__connect_timeout > 0) { + libssh2_session_set_timeout(s, git_socket_stream__connect_timeout); + } + if ((rc = load_known_hosts(&known_hosts, s)) < 0) { ssh_error(s, "error loading known_hosts"); libssh2_session_free(s); From 7f1d52067a4ecb5cacdff07f3563c400f497235a Mon Sep 17 00:00:00 2001 From: Samuel Tardieu Date: Mon, 22 Jan 2024 20:09:26 +0100 Subject: [PATCH 467/608] config: properly rename section containing multivars Renaming a section or deleting its content removes each entry after copying it in its new place if needed. However, since each entry may be part of a multivar, deletion must only remove the exact entry that has just been copied. --- src/libgit2/config.c | 29 ++++++++++++++++++++------ tests/libgit2/config/multivar.c | 31 ++++++++++++++++++++++++++++ tests/libgit2/refs/branches/delete.c | 15 ++++++++++++++ 3 files changed, 69 insertions(+), 6 deletions(-) diff --git a/src/libgit2/config.c b/src/libgit2/config.c index 23a8f9ffad1..d11e76d9577 100644 --- a/src/libgit2/config.c +++ b/src/libgit2/config.c @@ -1509,19 +1509,36 @@ static int rename_config_entries_cb( int error = 0; struct rename_data *data = (struct rename_data *)payload; size_t base_len = git_str_len(data->name); + git_str raw_value = GIT_STR_INIT, value = GIT_STR_INIT; if (base_len > 0 && !(error = git_str_puts(data->name, entry->name + data->old_len))) { - error = git_config_set_string( - data->config, git_str_cstr(data->name), entry->value); - - git_str_truncate(data->name, base_len); + error = git_config_set_multivar( + data->config, git_str_cstr(data->name), "^$", + entry->value); } - if (!error) - error = git_config_delete_entry(data->config, entry->name); + if (!error) { + if ((error = git_str_puts_escape_regex( + &raw_value, entry->value))) + goto cleanup; + git_str_grow(&value, git_str_len(&raw_value) + 2); + git_str_putc(&value, '^'); + git_str_puts(&value, git_str_cstr(&raw_value)); + git_str_putc(&value, '$'); + if (git_str_oom(&value)) { + error = -1; + goto cleanup; + } + error = git_config_delete_multivar( + data->config, entry->name, git_str_cstr(&value)); + } + cleanup: + git_str_truncate(data->name, base_len); + git_str_dispose(&raw_value); + git_str_dispose(&value); return error; } diff --git a/tests/libgit2/config/multivar.c b/tests/libgit2/config/multivar.c index 244e3755965..3ed846012fa 100644 --- a/tests/libgit2/config/multivar.c +++ b/tests/libgit2/config/multivar.c @@ -1,4 +1,6 @@ #include "clar_libgit2.h" +#include "config.h" +#include "config/config_helpers.h" static const char *_name = "remote.ab.url"; @@ -286,3 +288,32 @@ void test_config_multivar__delete_notfound(void) git_config_free(cfg); } + +void test_config_multivar__rename_section(void) +{ + git_repository *repo; + git_config *cfg; + int n; + + repo = cl_git_sandbox_init("testrepo"); + cl_git_pass(git_repository_config(&cfg, repo)); + + cl_git_pass(git_config_set_multivar(cfg, "branch.foo.name", "^$", "bar")); + cl_git_pass(git_config_set_multivar(cfg, "branch.foo.name", "^$", "xyzzy")); + n = 0; + cl_git_pass(git_config_get_multivar_foreach( + cfg, "branch.foo.name", NULL, cb, &n)); + cl_assert(n == 2); + + cl_git_pass( + git_config_rename_section(repo, "branch.foo", "branch.foobar")); + + assert_config_entry_existence(repo, "branch.foo.name", false); + n = 0; + cl_git_pass(git_config_get_multivar_foreach( + cfg, "branch.foobar.name", NULL, cb, &n)); + cl_assert(n == 2); + + git_config_free(cfg); + cl_git_sandbox_cleanup(); +} diff --git a/tests/libgit2/refs/branches/delete.c b/tests/libgit2/refs/branches/delete.c index 6b3d507a869..63f8c5d95c7 100644 --- a/tests/libgit2/refs/branches/delete.c +++ b/tests/libgit2/refs/branches/delete.c @@ -92,6 +92,21 @@ void test_refs_branches_delete__can_delete_a_local_branch(void) git_reference_free(branch); } +void test_refs_branches_delete__can_delete_a_local_branch_with_multivar(void) +{ + git_reference *branch; + git_config *cfg; + + cl_git_pass(git_repository_config(&cfg, repo)); + cl_git_pass(git_config_set_multivar( + cfg, "branch.br2.gitpublishto", "^$", "example1@example.com")); + cl_git_pass(git_config_set_multivar( + cfg, "branch.br2.gitpublishto", "^$", "example2@example.com")); + cl_git_pass(git_branch_lookup(&branch, repo, "br2", GIT_BRANCH_LOCAL)); + cl_git_pass(git_branch_delete(branch)); + git_reference_free(branch); +} + void test_refs_branches_delete__can_delete_a_remote_branch(void) { git_reference *branch; From 7be7c0c0e01aae938f2aaf78f22f20fc1b7a7763 Mon Sep 17 00:00:00 2001 From: Mark Date: Fri, 26 Jan 2024 13:37:23 -0500 Subject: [PATCH 468/608] use git_socket_stream__timeout --- include/git2/common.h | 7 +++---- src/libgit2/transports/ssh_libssh2.c | 6 +++--- 2 files changed, 6 insertions(+), 7 deletions(-) diff --git a/include/git2/common.h b/include/git2/common.h index 7736a0af9fc..140dd95610b 100644 --- a/include/git2/common.h +++ b/include/git2/common.h @@ -490,7 +490,8 @@ typedef enum { * * opts(GIT_OPT_SET_SERVER_CONNECT_TIMEOUT, int timeout) * > Sets the timeout (in milliseconds) to attempt connections to - * > a remote server. Set to 0 to use the system default. + * > a remote server. This is supported only for HTTP(S) connections + * > and is not supported by SSH. Set to 0 to use the system default. * > Note that this may not be able to be configured longer than the * > system default, typically 75 seconds. * @@ -500,9 +501,7 @@ typedef enum { * * opts(GIT_OPT_SET_SERVER_TIMEOUT, int timeout) * > Sets the timeout (in milliseconds) for reading from and writing - * > to a remote server. This is supported only for HTTP(S) - * > connections and is not supported by SSH. Set to 0 to use the - * > system default. + * > to a remote server. Set to 0 to use the system default. * * @param option Option key * @param ... value to set the option diff --git a/src/libgit2/transports/ssh_libssh2.c b/src/libgit2/transports/ssh_libssh2.c index 89f341f2108..d1b5d40d51f 100644 --- a/src/libgit2/transports/ssh_libssh2.c +++ b/src/libgit2/transports/ssh_libssh2.c @@ -23,7 +23,7 @@ #define OWNING_SUBTRANSPORT(s) ((ssh_subtransport *)(s)->parent.subtransport) -extern int git_socket_stream__connect_timeout; +extern int git_socket_stream__timeout; static const char cmd_uploadpack[] = "git-upload-pack"; static const char cmd_receivepack[] = "git-receive-pack"; @@ -541,8 +541,8 @@ static int _git_ssh_session_create( return -1; } - if (git_socket_stream__connect_timeout > 0) { - libssh2_session_set_timeout(s, git_socket_stream__connect_timeout); + if (git_socket_stream__timeout > 0) { + libssh2_session_set_timeout(s, git_socket_stream__timeout); } if ((rc = load_known_hosts(&known_hosts, s)) < 0) { From ca864c59141fef29781fcd1a0eb0eed2b5d7fa68 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sun, 4 Feb 2024 14:40:47 +0000 Subject: [PATCH 469/608] clone: don't swallow error in should_checkout When determining whether to check out a branch, we did not actually look at `should_checkout`'s possible error condition. Disconnect the boolean "should checkout" value from the potential error code so that it no longer looks like a function that can be treated as if it returns a boolean. --- src/libgit2/clone.c | 28 +++++++++++++++++++--------- 1 file changed, 19 insertions(+), 9 deletions(-) diff --git a/src/libgit2/clone.c b/src/libgit2/clone.c index 3df28f80aed..db9a898e34e 100644 --- a/src/libgit2/clone.c +++ b/src/libgit2/clone.c @@ -362,25 +362,29 @@ static int create_and_configure_origin( return error; } -static bool should_checkout( +static int should_checkout( + bool *out, git_repository *repo, bool is_bare, const git_checkout_options *opts) { - if (is_bare) - return false; + int error; - if (!opts) - return false; + if (!opts || is_bare || opts->checkout_strategy == GIT_CHECKOUT_NONE) { + *out = 0; + return 0; + } - if (opts->checkout_strategy == GIT_CHECKOUT_NONE) - return false; + if ((error = git_repository_head_unborn(repo)) < 0) + return error; - return !git_repository_head_unborn(repo); + *out = !error; + return 0; } static int checkout_branch(git_repository *repo, git_remote *remote, const git_checkout_options *co_opts, const char *branch, const char *reflog_message) { + bool checkout; int error; if (branch) @@ -389,7 +393,13 @@ static int checkout_branch(git_repository *repo, git_remote *remote, const git_c else error = update_head_to_remote(repo, remote, reflog_message); - if (!error && should_checkout(repo, git_repository_is_bare(repo), co_opts)) + if (error < 0) + return error; + + if ((error = should_checkout(&checkout, repo, git_repository_is_bare(repo), co_opts)) < 0) + return error; + + if (checkout) error = git_checkout_head(repo, co_opts); return error; From c3dc87b0c80eb4f885ba1781eed7a029c0e1e53a Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 5 Feb 2024 10:16:17 +0000 Subject: [PATCH 470/608] docs: update documentation for timeout The connect timeout *does* apply to SSH connections (at least libssh2), so update the documentation appropriately. --- include/git2/common.h | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/include/git2/common.h b/include/git2/common.h index 140dd95610b..0f42c34f683 100644 --- a/include/git2/common.h +++ b/include/git2/common.h @@ -490,10 +490,9 @@ typedef enum { * * opts(GIT_OPT_SET_SERVER_CONNECT_TIMEOUT, int timeout) * > Sets the timeout (in milliseconds) to attempt connections to - * > a remote server. This is supported only for HTTP(S) connections - * > and is not supported by SSH. Set to 0 to use the system default. - * > Note that this may not be able to be configured longer than the - * > system default, typically 75 seconds. + * > a remote server. Set to 0 to use the system default. Note that + * > this may not be able to be configured longer than the system + * > default, typically 75 seconds. * * opts(GIT_OPT_GET_SERVER_TIMEOUT, int *timeout) * > Gets the timeout (in milliseconds) for reading from and writing From 8bd69574bdfba221a365c3d40713e6d13463ae79 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 17 Nov 2023 10:29:08 +0000 Subject: [PATCH 471/608] fuzzers: provide util functions like repo init Many fuzzers will need to operate with a repository; extract the repository initialization from downloads_refs_fuzzer.c into its own utility area. --- fuzzers/CMakeLists.txt | 5 +++- fuzzers/download_refs_fuzzer.c | 35 +++-------------------- fuzzers/fuzzer_utils.c | 51 ++++++++++++++++++++++++++++++++++ fuzzers/fuzzer_utils.h | 14 ++++++++++ 4 files changed, 73 insertions(+), 32 deletions(-) create mode 100644 fuzzers/fuzzer_utils.c create mode 100644 fuzzers/fuzzer_utils.h diff --git a/fuzzers/CMakeLists.txt b/fuzzers/CMakeLists.txt index a2c19ed408a..01f0f51997f 100644 --- a/fuzzers/CMakeLists.txt +++ b/fuzzers/CMakeLists.txt @@ -12,10 +12,13 @@ foreach(fuzz_target_src ${SRC_FUZZERS}) string(REPLACE ".c" "" fuzz_target_name ${fuzz_target_src}) string(REPLACE "_fuzzer" "" fuzz_name ${fuzz_target_name}) - set(${fuzz_target_name}_SOURCES ${fuzz_target_src} ${LIBGIT2_OBJECTS}) + set(${fuzz_target_name}_SOURCES + ${fuzz_target_src} "fuzzer_utils.c" ${LIBGIT2_OBJECTS}) + if(USE_STANDALONE_FUZZERS) list(APPEND ${fuzz_target_name}_SOURCES "standalone_driver.c") endif() + add_executable(${fuzz_target_name} ${${fuzz_target_name}_SOURCES}) set_target_properties(${fuzz_target_name} PROPERTIES C_STANDARD 90) diff --git a/fuzzers/download_refs_fuzzer.c b/fuzzers/download_refs_fuzzer.c index ff95cd107ef..c2b80ccb1f2 100644 --- a/fuzzers/download_refs_fuzzer.c +++ b/fuzzers/download_refs_fuzzer.c @@ -16,6 +16,7 @@ #include "futils.h" #include "standalone_driver.h" +#include "fuzzer_utils.h" #define UNUSED(x) (void)(x) @@ -157,33 +158,10 @@ static int fuzzer_transport_cb(git_transport **out, git_remote *owner, void *par return git_transport_smart(out, owner, &def); } -static void fuzzer_git_abort(const char *op) -{ - const git_error *err = git_error_last(); - fprintf(stderr, "unexpected libgit error: %s: %s\n", - op, err ? err->message : ""); - abort(); -} - int LLVMFuzzerInitialize(int *argc, char ***argv) { -#if defined(_WIN32) - char tmpdir[MAX_PATH], path[MAX_PATH]; - - if (GetTempPath((DWORD)sizeof(tmpdir), tmpdir) == 0) - abort(); - - if (GetTempFileName(tmpdir, "lg2", 1, path) == 0) - abort(); - - if (git_futils_mkdir(path, 0700, 0) < 0) - abort(); -#else - char path[] = "/tmp/git2.XXXXXX"; - - if (mkdtemp(path) != path) - abort(); -#endif + UNUSED(argc); + UNUSED(argv); if (git_libgit2_init() < 0) abort(); @@ -191,12 +169,7 @@ int LLVMFuzzerInitialize(int *argc, char ***argv) if (git_libgit2_opts(GIT_OPT_SET_PACK_MAX_OBJECTS, 10000000) < 0) abort(); - UNUSED(argc); - UNUSED(argv); - - if (git_repository_init(&repo, path, 1) < 0) - fuzzer_git_abort("git_repository_init"); - + repo = fuzzer_repo_init(); return 0; } diff --git a/fuzzers/fuzzer_utils.c b/fuzzers/fuzzer_utils.c new file mode 100644 index 00000000000..cde5065da03 --- /dev/null +++ b/fuzzers/fuzzer_utils.c @@ -0,0 +1,51 @@ +/* + * Copyright (C) the libgit2 contributors. All rights reserved. + * + * This file is part of libgit2, distributed under the GNU GPL v2 with + * a Linking Exception. For full terms see the included COPYING file. + */ + +#include +#include +#include + +#include "git2.h" +#include "futils.h" + +#include "fuzzer_utils.h" + +void fuzzer_git_abort(const char *op) +{ + const git_error *err = git_error_last(); + fprintf(stderr, "unexpected libgit error: %s: %s\n", + op, err ? err->message : ""); + abort(); +} + +git_repository *fuzzer_repo_init(void) +{ + git_repository *repo; + +#if defined(_WIN32) + char tmpdir[MAX_PATH], path[MAX_PATH]; + + if (GetTempPath((DWORD)sizeof(tmpdir), tmpdir) == 0) + abort(); + + if (GetTempFileName(tmpdir, "lg2", 1, path) == 0) + abort(); + + if (git_futils_mkdir(path, 0700, 0) < 0) + abort(); +#else + char path[] = "/tmp/git2.XXXXXX"; + + if (mkdtemp(path) != path) + abort(); +#endif + + if (git_repository_init(&repo, path, 1) < 0) + fuzzer_git_abort("git_repository_init"); + + return repo; +} diff --git a/fuzzers/fuzzer_utils.h b/fuzzers/fuzzer_utils.h new file mode 100644 index 00000000000..6b67c9a611d --- /dev/null +++ b/fuzzers/fuzzer_utils.h @@ -0,0 +1,14 @@ +/* + * Copyright (C) the libgit2 contributors. All rights reserved. + * + * This file is part of libgit2, distributed under the GNU GPL v2 with + * a Linking Exception. For full terms see the included COPYING file. + */ + +#ifndef INCLUDE_fuzzer_utils_h__ +#define INCLUDE_fuzzer_utils_h__ + +extern void fuzzer_git_abort(const char *op); +extern git_repository *fuzzer_repo_init(void); + +#endif From f015996fe3bd61819f3f3ddd85effbeb451ebfac Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 17 Nov 2023 10:29:56 +0000 Subject: [PATCH 472/608] fuzzer: add a revparse fuzzer --- fuzzers/corpora/revparse/head | 1 + fuzzers/corpora/revparse/revat | 1 + fuzzers/revparse_fuzzer.c | 52 ++++++++++++++++++++++++++++++++++ 3 files changed, 54 insertions(+) create mode 100644 fuzzers/corpora/revparse/head create mode 100644 fuzzers/corpora/revparse/revat create mode 100644 fuzzers/revparse_fuzzer.c diff --git a/fuzzers/corpora/revparse/head b/fuzzers/corpora/revparse/head new file mode 100644 index 00000000000..e5517e4c5b4 --- /dev/null +++ b/fuzzers/corpora/revparse/head @@ -0,0 +1 @@ +HEAD \ No newline at end of file diff --git a/fuzzers/corpora/revparse/revat b/fuzzers/corpora/revparse/revat new file mode 100644 index 00000000000..382ffc0ba32 --- /dev/null +++ b/fuzzers/corpora/revparse/revat @@ -0,0 +1 @@ +xxxxxxxxxxxxxxxx@ \ No newline at end of file diff --git a/fuzzers/revparse_fuzzer.c b/fuzzers/revparse_fuzzer.c new file mode 100644 index 00000000000..37c22e2221c --- /dev/null +++ b/fuzzers/revparse_fuzzer.c @@ -0,0 +1,52 @@ +/* + * libgit2 revparse fuzzer target. + * + * Copyright (C) the libgit2 contributors. All rights reserved. + * + * This file is part of libgit2, distributed under the GNU GPL v2 with + * a Linking Exception. For full terms see the included COPYING file. + */ + +#include +#include + +#include "git2.h" + +#include "standalone_driver.h" +#include "fuzzer_utils.h" + +#define UNUSED(x) (void)(x) + +static git_repository *repo; + +int LLVMFuzzerInitialize(int *argc, char ***argv) +{ + UNUSED(argc); + UNUSED(argv); + + if (git_libgit2_init() < 0) + abort(); + + if (git_libgit2_opts(GIT_OPT_SET_PACK_MAX_OBJECTS, 10000000) < 0) + abort(); + + repo = fuzzer_repo_init(); + return 0; +} + +int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) +{ + git_object *obj = NULL; + char *c; + + if ((c = calloc(1, size + 1)) == NULL) + abort(); + + memcpy(c, data, size); + + git_revparse_single(&obj, repo, c); + git_object_free(obj); + free(c); + + return 0; +} From cef060a4f2626362f66d1b1b9d30d82bc3f30d92 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 17 Nov 2023 10:52:19 +0000 Subject: [PATCH 473/608] fuzzer: run address sanitization during fuzzing --- .github/workflows/main.yml | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index f6a087b89b2..accb042e463 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -137,6 +137,20 @@ jobs: ASAN_SYMBOLIZER_PATH: /usr/bin/llvm-symbolizer-10 UBSAN_OPTIONS: print_stacktrace=1 os: ubuntu-latest + - name: "Sanitizer (Address)" + id: sanitizer-address + container: + name: noble + env: + CC: clang + CFLAGS: -fsanitize=address -ggdb -fsanitize-blacklist=/home/libgit2/source/script/sanitizers.supp -fno-optimize-sibling-calls -fno-omit-frame-pointer + CMAKE_OPTIONS: -DCMAKE_PREFIX_PATH=/usr/local -DUSE_HTTPS=mbedTLS -DUSE_SHA1=HTTPS -DREGEX_BACKEND=pcre -DDEPRECATE_HARD=ON -DUSE_BUNDLED_ZLIB=ON -DUSE_SSH=ON + CMAKE_GENERATOR: Ninja + SKIP_SSH_TESTS: true + SKIP_NEGOTIATE_TESTS: true + ASAN_SYMBOLIZER_PATH: /usr/bin/llvm-symbolizer-10 + UBSAN_OPTIONS: print_stacktrace=1 + os: ubuntu-latest - name: "Sanitizer (UndefinedBehavior)" id: sanitizer-ub os: ubuntu-latest From d41d32188106a60beeec87be6d398804bcae9785 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 17 Nov 2023 16:25:06 +0000 Subject: [PATCH 474/608] transport: safely handle messages with no caps If there are no caps, don't try to advance past the first NULL to look for object-format. This prevents a possible out-of-bounds read. --- src/libgit2/transports/smart_pkt.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/libgit2/transports/smart_pkt.c b/src/libgit2/transports/smart_pkt.c index 7805f332377..3307acfa08e 100644 --- a/src/libgit2/transports/smart_pkt.c +++ b/src/libgit2/transports/smart_pkt.c @@ -232,7 +232,8 @@ static int set_data( GIT_ASSERT_ARG(data); - if ((caps = memchr(line, '\0', len)) != NULL) { + if ((caps = memchr(line, '\0', len)) != NULL && + len > (size_t)((caps - line) + 1)) { caps++; if (strncmp(caps, "object-format=", CONST_STRLEN("object-format=")) == 0) From d353cf4897c719a6e4bd7183747cb8e88ee0481d Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 17 Nov 2023 16:54:47 +0000 Subject: [PATCH 475/608] revparse: fix parsing bug for trailing `@` When parsing a revspec that ends with a trailing `@`, explicitly stop parsing. Introduce a sentinel variable to explicitly stop parsing. Prior to this, we would set `spec` to `HEAD`, but were looping on the value of `spec[pos]`, so we would continue walking the (new) `spec` at offset `pos`, looking for a NUL. This is obviously an out-of-bounds read. Credit to Michael Rodler (@f0rki) and Amazon AWS Security. --- src/libgit2/revparse.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/libgit2/revparse.c b/src/libgit2/revparse.c index 964afe378da..06d92f82bf2 100644 --- a/src/libgit2/revparse.c +++ b/src/libgit2/revparse.c @@ -701,6 +701,7 @@ static int revparse( git_object *base_rev = NULL; bool should_return_reference = true; + bool parsed = false; GIT_ASSERT_ARG(object_out); GIT_ASSERT_ARG(reference_out); @@ -710,7 +711,7 @@ static int revparse( *object_out = NULL; *reference_out = NULL; - while (spec[pos]) { + while (!parsed && spec[pos]) { switch (spec[pos]) { case '^': should_return_reference = false; @@ -817,6 +818,8 @@ static int revparse( break; } else if (spec[pos+1] == '\0') { spec = "HEAD"; + identifier_len = 4; + parsed = true; break; } /* fall through */ From 56c98a07ed391c73b2ecc4fe86770eb39dd248e2 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 16 Dec 2023 11:14:58 +0000 Subject: [PATCH 476/608] index: test adding two identical slash-prefix paths Ensure that we can `git_index_add` a slash-prefixed path, followed by re-adding the same path. The original entry should be replaced by the new entry. --- tests/libgit2/index/add.c | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) diff --git a/tests/libgit2/index/add.c b/tests/libgit2/index/add.c index b0c3bd2b7ae..588a2ad148c 100644 --- a/tests/libgit2/index/add.c +++ b/tests/libgit2/index/add.c @@ -82,3 +82,27 @@ void test_index_add__invalid_entries_succeeds_by_default(void) test_add_entry(true, valid_commit_id, GIT_FILEMODE_LINK); } +void test_index_add__two_slash_prefixed(void) +{ + git_index_entry one = {{0}}, two = {{0}}; + const git_index_entry *result; + size_t orig_count; + + orig_count = git_index_entrycount(g_index); + + cl_git_pass(git_oid__fromstr(&one.id, "fa49b077972391ad58037050f2a75f74e3671e92", GIT_OID_SHA1)); + one.path = "/a"; + one.mode = GIT_FILEMODE_BLOB; + + cl_git_pass(git_oid__fromstr(&two.id, "3697d64be941a53d4ae8f6a271e4e3fa56b022cc", GIT_OID_SHA1)); + two.path = "/a"; + two.mode = GIT_FILEMODE_BLOB; + + cl_git_pass(git_index_add(g_index, &one)); + cl_git_pass(git_index_add(g_index, &two)); + + cl_assert_equal_i(orig_count + 1, git_index_entrycount(g_index)); + + cl_assert(result = git_index_get_bypath(g_index, "/a", 0)); + cl_assert_equal_oid(&two.id, &result->id); +} From 18ea0b0773ebe24459ee3a5beb790e37746fb2ca Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 16 Dec 2023 11:19:07 +0000 Subject: [PATCH 477/608] index: correct index has_dir_name check `has_dir_name` is used to check for directory/file collisions, and attempts to determine whether the index contains a file with a directory name that is a proper subset of the new index entry that we're trying to add. To determine directory name, the function would walk the path string backwards to identify a `/`, stopping at the end of the string. However, the function assumed that the strings did not start with a `/`. If the paths contain only a single `/` at the beginning of the string, then the function would continue the loop, erroneously, when they should have stopped at the first character. Correct the order of the tests to terminate properly. Credit to Michael Rodler (@f0rki) and Amazon AWS Security. --- src/libgit2/index.c | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/src/libgit2/index.c b/src/libgit2/index.c index 90580731830..5074e3e1fa4 100644 --- a/src/libgit2/index.c +++ b/src/libgit2/index.c @@ -1185,10 +1185,13 @@ static int has_dir_name(git_index *index, size_t len, pos; for (;;) { - if (*--slash == '/') - break; + slash--; + if (slash <= entry->path) return 0; + + if (*slash == '/') + break; } len = slash - name; From 39669956fb510fb7b13289f6ce959884969dbebd Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 5 Feb 2024 10:58:14 +0000 Subject: [PATCH 478/608] push: "push_options" are now "remote_push_options" Since we use `git_push_options` as the options structure to our `git_push` command, much like we do everywhere else, "push_options" becomes ambiguous. "remote_options" isn't much better for us. Call them "remote_push_options", which is still quite bad, and not particularly insightful for end users, but at least something that we can discuss unambiguously. --- include/git2/remote.h | 4 +- src/libgit2/push.c | 11 +- src/libgit2/push.h | 2 +- src/libgit2/remote.c | 10 +- src/libgit2/transports/smart_protocol.c | 8 +- tests/libgit2/online/push.c | 167 +++++++++++++++--------- 6 files changed, 123 insertions(+), 79 deletions(-) diff --git a/include/git2/remote.h b/include/git2/remote.h index 1f41f8c787f..7ad820ad3c3 100644 --- a/include/git2/remote.h +++ b/include/git2/remote.h @@ -848,9 +848,9 @@ typedef struct { git_strarray custom_headers; /** - * Push options + * "Push options" to deliver to the remote. */ - git_strarray push_options; + git_strarray remote_push_options; } git_push_options; #define GIT_PUSH_OPTIONS_VERSION 1 diff --git a/src/libgit2/push.c b/src/libgit2/push.c index d718170c82a..e065858826a 100644 --- a/src/libgit2/push.c +++ b/src/libgit2/push.c @@ -68,7 +68,7 @@ int git_push_new(git_push **out, git_remote *remote, const git_push_options *opt return -1; } - if (git_vector_init(&p->push_options, 0, git__strcmp_cb) < 0) { + if (git_vector_init(&p->remote_push_options, 0, git__strcmp_cb) < 0) { git_vector_free(&p->status); git_vector_free(&p->specs); git_vector_free(&p->updates); @@ -505,12 +505,13 @@ int git_push_finish(git_push *push) return -1; } - if ((error = git_remote_capabilities(&remote_caps, push->remote)) < 0){ + if ((error = git_remote_capabilities(&remote_caps, push->remote)) < 0) { git_error_set(GIT_ERROR_INVALID, "remote capabilities not available"); return -1; } - if (git_vector_length(&push->push_options) > 0 && !(remote_caps & GIT_REMOTE_CAPABILITY_PUSH_OPTIONS)) { + if (git_vector_length(&push->remote_push_options) > 0 && + !(remote_caps & GIT_REMOTE_CAPABILITY_PUSH_OPTIONS)) { git_error_set(GIT_ERROR_INVALID, "push-options not supported by remote"); return -1; } @@ -581,10 +582,10 @@ void git_push_free(git_push *push) } git_vector_free(&push->updates); - git_vector_foreach(&push->push_options, i, option) { + git_vector_foreach(&push->remote_push_options, i, option) { git__free(option); } - git_vector_free(&push->push_options); + git_vector_free(&push->remote_push_options); git__free(push); } diff --git a/src/libgit2/push.h b/src/libgit2/push.h index 17c3e2f6845..40a1823e45b 100644 --- a/src/libgit2/push.h +++ b/src/libgit2/push.h @@ -34,7 +34,7 @@ struct git_push { git_vector specs; git_vector updates; bool report_status; - git_vector push_options; + git_vector remote_push_options; /* report-status */ bool unpack_ok; diff --git a/src/libgit2/remote.c b/src/libgit2/remote.c index 4adc57c4d09..9eb4bac8b2f 100644 --- a/src/libgit2/remote.c +++ b/src/libgit2/remote.c @@ -2982,11 +2982,13 @@ int git_remote_upload( } } - if (opts && opts->push_options.count > 0) - for (i = 0; i < opts->push_options.count; ++i) { - if ((error = git_vector_insert(&push->push_options, git__strdup(opts->push_options.strings[i]))) < 0) { + if (opts && opts->remote_push_options.count > 0) + for (i = 0; i < opts->remote_push_options.count; ++i) { + char *optstr = git__strdup(opts->remote_push_options.strings[i]); + GIT_ERROR_CHECK_ALLOC(optstr); + + if ((error = git_vector_insert(&push->remote_push_options, optstr)) < 0) goto cleanup; - } } if ((error = git_push_finish(push)) < 0) diff --git a/src/libgit2/transports/smart_protocol.c b/src/libgit2/transports/smart_protocol.c index 85ad65c6227..13f97b7274f 100644 --- a/src/libgit2/transports/smart_protocol.c +++ b/src/libgit2/transports/smart_protocol.c @@ -797,7 +797,7 @@ static int gen_pktline(git_str *buf, git_push *push) ++len; /* '\0' */ if (push->report_status) len += strlen(GIT_CAP_REPORT_STATUS) + 1; - if (git_vector_length(&push->push_options) > 0) + if (git_vector_length(&push->remote_push_options) > 0) len += strlen(GIT_CAP_PUSH_OPTIONS) + 1; len += strlen(GIT_CAP_SIDE_BAND_64K) + 1; } @@ -814,7 +814,7 @@ static int gen_pktline(git_str *buf, git_push *push) git_str_putc(buf, ' '); git_str_printf(buf, GIT_CAP_REPORT_STATUS); } - if (git_vector_length(&push->push_options) > 0) { + if (git_vector_length(&push->remote_push_options) > 0) { git_str_putc(buf, ' '); git_str_printf(buf, GIT_CAP_PUSH_OPTIONS); } @@ -825,9 +825,9 @@ static int gen_pktline(git_str *buf, git_push *push) git_str_putc(buf, '\n'); } - if (git_vector_length(&push->push_options) > 0) { + if (git_vector_length(&push->remote_push_options) > 0) { git_str_printf(buf, "0000"); - git_vector_foreach(&push->push_options, i, option) { + git_vector_foreach(&push->remote_push_options, i, option) { git_str_printf(buf, "%04"PRIxZ"%s", strlen(option) + 4 , option); } } diff --git a/tests/libgit2/online/push.c b/tests/libgit2/online/push.c index 1f5f141f53b..cfd43209da4 100644 --- a/tests/libgit2/online/push.c +++ b/tests/libgit2/online/push.c @@ -26,7 +26,7 @@ static char *_ssh_cmd = NULL; static char *_remote_push_options_result = NULL; -static int cred_acquire_cb(git_credential **, const char *, const char *, unsigned int, void *); +static int cred_acquire_cb(git_credential **, const char *, const char *, unsigned int, void *); static git_remote *_remote; static record_callbacks_data _record_cbs_data = {{ 0 }}; @@ -492,7 +492,7 @@ static void do_push( push_status expected_statuses[], size_t expected_statuses_len, expected_ref expected_refs[], size_t expected_refs_len, int expected_ret, int check_progress_cb, int check_update_tips_cb, - git_strarray push_options) + git_strarray *remote_push_options) { git_push_options opts = GIT_PUSH_OPTIONS_INIT; size_t i; @@ -504,8 +504,8 @@ static void do_push( /* Auto-detect the number of threads to use */ opts.pb_parallelism = 0; - if(push_options.count != 0) - opts.push_options = push_options; + if (remote_push_options) + memcpy(&opts.remote_push_options, remote_push_options, sizeof(git_strarray)); memcpy(&opts.callbacks, &_record_cbs, sizeof(git_remote_callbacks)); data = opts.callbacks.payload; @@ -550,14 +550,12 @@ static void do_push( verify_update_tips_callback(_remote, expected_refs, expected_refs_len); } - } /* Call push_finish() without ever calling git_push_add_refspec() */ void test_online_push__noop(void) { - git_strarray push_options = { 0 }; - do_push(NULL, 0, NULL, 0, NULL, 0, 0, 0, 1, push_options); + do_push(NULL, 0, NULL, 0, NULL, 0, 0, 0, 1, NULL); } void test_online_push__b1(void) @@ -565,10 +563,11 @@ void test_online_push__b1(void) const char *specs[] = { "refs/heads/b1:refs/heads/b1" }; push_status exp_stats[] = { { "refs/heads/b1", 1 } }; expected_ref exp_refs[] = { { "refs/heads/b1", &_oid_b1 } }; - git_strarray push_options = { 0 }; do_push(specs, ARRAY_SIZE(specs), exp_stats, ARRAY_SIZE(exp_stats), - exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1, push_options); + exp_refs, ARRAY_SIZE(exp_refs), + 0, 1, 1, + NULL); } void test_online_push__b2(void) @@ -576,10 +575,11 @@ void test_online_push__b2(void) const char *specs[] = { "refs/heads/b2:refs/heads/b2" }; push_status exp_stats[] = { { "refs/heads/b2", 1 } }; expected_ref exp_refs[] = { { "refs/heads/b2", &_oid_b2 } }; - git_strarray push_options = { 0 }; do_push(specs, ARRAY_SIZE(specs), exp_stats, ARRAY_SIZE(exp_stats), - exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1, push_options); + exp_refs, ARRAY_SIZE(exp_refs), + 0, 1, 1, + NULL); } void test_online_push__b3(void) @@ -587,10 +587,11 @@ void test_online_push__b3(void) const char *specs[] = { "refs/heads/b3:refs/heads/b3" }; push_status exp_stats[] = { { "refs/heads/b3", 1 } }; expected_ref exp_refs[] = { { "refs/heads/b3", &_oid_b3 } }; - git_strarray push_options = { 0 }; do_push(specs, ARRAY_SIZE(specs), exp_stats, ARRAY_SIZE(exp_stats), - exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1, push_options); + exp_refs, ARRAY_SIZE(exp_refs), + 0, 1, 1, + NULL); } void test_online_push__b4(void) @@ -598,10 +599,11 @@ void test_online_push__b4(void) const char *specs[] = { "refs/heads/b4:refs/heads/b4" }; push_status exp_stats[] = { { "refs/heads/b4", 1 } }; expected_ref exp_refs[] = { { "refs/heads/b4", &_oid_b4 } }; - git_strarray push_options = { 0 }; do_push(specs, ARRAY_SIZE(specs), exp_stats, ARRAY_SIZE(exp_stats), - exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1, push_options); + exp_refs, ARRAY_SIZE(exp_refs), + 0, 1, 1, + NULL); } void test_online_push__b5(void) @@ -609,17 +611,17 @@ void test_online_push__b5(void) const char *specs[] = { "refs/heads/b5:refs/heads/b5" }; push_status exp_stats[] = { { "refs/heads/b5", 1 } }; expected_ref exp_refs[] = { { "refs/heads/b5", &_oid_b5 } }; - git_strarray push_options = { 0 }; do_push(specs, ARRAY_SIZE(specs), exp_stats, ARRAY_SIZE(exp_stats), - exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1, push_options); + exp_refs, ARRAY_SIZE(exp_refs), + 0, 1, 1, + NULL); } void test_online_push__b5_cancel(void) { const char *specs[] = { "refs/heads/b5:refs/heads/b5" }; - git_strarray push_options = { 0 }; - do_push(specs, ARRAY_SIZE(specs), NULL, 0, NULL, 0, GIT_EUSER, 1, 1, push_options); + do_push(specs, ARRAY_SIZE(specs), NULL, 0, NULL, 0, GIT_EUSER, 1, 1, NULL); } void test_online_push__multi(void) @@ -648,10 +650,11 @@ void test_online_push__multi(void) { "refs/heads/b4", &_oid_b4 }, { "refs/heads/b5", &_oid_b5 } }; - git_strarray push_options = { 0 }; do_push(specs, ARRAY_SIZE(specs), exp_stats, ARRAY_SIZE(exp_stats), - exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1, push_options); + exp_refs, ARRAY_SIZE(exp_refs), + 0, 1, 1, + NULL); cl_git_pass(git_reflog_read(&log, _repo, "refs/remotes/test/b1")); entry = git_reflog_entry_byindex(log, 0); @@ -672,18 +675,21 @@ void test_online_push__implicit_tgt(void) const char *specs2[] = { "refs/heads/b2" }; push_status exp_stats2[] = { { "refs/heads/b2", 1 } }; expected_ref exp_refs2[] = { - { "refs/heads/b1", &_oid_b1 }, - { "refs/heads/b2", &_oid_b2 } + { "refs/heads/b1", &_oid_b1 }, + { "refs/heads/b2", &_oid_b2 } }; - git_strarray push_options = { 0 }; do_push(specs1, ARRAY_SIZE(specs1), exp_stats1, ARRAY_SIZE(exp_stats1), - exp_refs1, ARRAY_SIZE(exp_refs1), 0, 1, 1, push_options); + exp_refs1, ARRAY_SIZE(exp_refs1), + 0, 1, 1, + NULL); do_push(specs2, ARRAY_SIZE(specs2), exp_stats2, ARRAY_SIZE(exp_stats2), - exp_refs2, ARRAY_SIZE(exp_refs2), 0, 0, 0, push_options); + exp_refs2, ARRAY_SIZE(exp_refs2), + 0, 0, 0, + NULL); } void test_online_push__fast_fwd(void) @@ -703,22 +709,29 @@ void test_online_push__fast_fwd(void) /* Force should have no effect on a fast forward push */ const char *specs_ff_force[] = { "+refs/heads/b6:refs/heads/b1" }; - git_strarray push_options = { 0 }; do_push(specs_init, ARRAY_SIZE(specs_init), exp_stats_init, ARRAY_SIZE(exp_stats_init), - exp_refs_init, ARRAY_SIZE(exp_refs_init), 0, 1, 1, push_options); + exp_refs_init, ARRAY_SIZE(exp_refs_init), + 0, 1, 1, + NULL); do_push(specs_ff, ARRAY_SIZE(specs_ff), exp_stats_ff, ARRAY_SIZE(exp_stats_ff), - exp_refs_ff, ARRAY_SIZE(exp_refs_ff), 0, 0, 0, push_options); + exp_refs_ff, ARRAY_SIZE(exp_refs_ff), + 0, 0, 0, + NULL); do_push(specs_reset, ARRAY_SIZE(specs_reset), exp_stats_init, ARRAY_SIZE(exp_stats_init), - exp_refs_init, ARRAY_SIZE(exp_refs_init), 0, 0, 0, push_options); + exp_refs_init, ARRAY_SIZE(exp_refs_init), + 0, 0, 0, + NULL); do_push(specs_ff_force, ARRAY_SIZE(specs_ff_force), exp_stats_ff, ARRAY_SIZE(exp_stats_ff), - exp_refs_ff, ARRAY_SIZE(exp_refs_ff), 0, 0, 0, push_options); + exp_refs_ff, ARRAY_SIZE(exp_refs_ff), + 0, 0, 0, + NULL); } void test_online_push__tag_commit(void) @@ -726,10 +739,11 @@ void test_online_push__tag_commit(void) const char *specs[] = { "refs/tags/tag-commit:refs/tags/tag-commit" }; push_status exp_stats[] = { { "refs/tags/tag-commit", 1 } }; expected_ref exp_refs[] = { { "refs/tags/tag-commit", &_tag_commit } }; - git_strarray push_options = { 0 }; do_push(specs, ARRAY_SIZE(specs), exp_stats, ARRAY_SIZE(exp_stats), - exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1, push_options); + exp_refs, ARRAY_SIZE(exp_refs), + 0, 1, 1, + NULL); } void test_online_push__tag_tree(void) @@ -737,10 +751,11 @@ void test_online_push__tag_tree(void) const char *specs[] = { "refs/tags/tag-tree:refs/tags/tag-tree" }; push_status exp_stats[] = { { "refs/tags/tag-tree", 1 } }; expected_ref exp_refs[] = { { "refs/tags/tag-tree", &_tag_tree } }; - git_strarray push_options = { 0 }; do_push(specs, ARRAY_SIZE(specs), exp_stats, ARRAY_SIZE(exp_stats), - exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1, push_options); + exp_refs, ARRAY_SIZE(exp_refs), + 0, 1, 1, + NULL); } void test_online_push__tag_blob(void) @@ -748,10 +763,11 @@ void test_online_push__tag_blob(void) const char *specs[] = { "refs/tags/tag-blob:refs/tags/tag-blob" }; push_status exp_stats[] = { { "refs/tags/tag-blob", 1 } }; expected_ref exp_refs[] = { { "refs/tags/tag-blob", &_tag_blob } }; - git_strarray push_options = { 0 }; do_push(specs, ARRAY_SIZE(specs), exp_stats, ARRAY_SIZE(exp_stats), - exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1, push_options); + exp_refs, ARRAY_SIZE(exp_refs), + 0, 1, 1, + NULL); } void test_online_push__tag_lightweight(void) @@ -759,10 +775,11 @@ void test_online_push__tag_lightweight(void) const char *specs[] = { "refs/tags/tag-lightweight:refs/tags/tag-lightweight" }; push_status exp_stats[] = { { "refs/tags/tag-lightweight", 1 } }; expected_ref exp_refs[] = { { "refs/tags/tag-lightweight", &_tag_lightweight } }; - git_strarray push_options = { 0 }; do_push(specs, ARRAY_SIZE(specs), exp_stats, ARRAY_SIZE(exp_stats), - exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1, push_options); + exp_refs, ARRAY_SIZE(exp_refs), + 0, 1, 1, + NULL); } void test_online_push__tag_to_tag(void) @@ -770,10 +787,11 @@ void test_online_push__tag_to_tag(void) const char *specs[] = { "refs/tags/tag-tag:refs/tags/tag-tag" }; push_status exp_stats[] = { { "refs/tags/tag-tag", 1 } }; expected_ref exp_refs[] = { { "refs/tags/tag-tag", &_tag_tag } }; - git_strarray push_options = { 0 }; do_push(specs, ARRAY_SIZE(specs), exp_stats, ARRAY_SIZE(exp_stats), - exp_refs, ARRAY_SIZE(exp_refs), 0, 0, 0, push_options); + exp_refs, ARRAY_SIZE(exp_refs), + 0, 0, 0, + NULL); } void test_online_push__force(void) @@ -788,20 +806,25 @@ void test_online_push__force(void) push_status exp_stats2_force[] = { { "refs/heads/tgt", 1 } }; expected_ref exp_refs2_force[] = { { "refs/heads/tgt", &_oid_b4 } }; - git_strarray push_options = { 0 }; do_push(specs1, ARRAY_SIZE(specs1), exp_stats1, ARRAY_SIZE(exp_stats1), - exp_refs1, ARRAY_SIZE(exp_refs1), 0, 1, 1, push_options); + exp_refs1, ARRAY_SIZE(exp_refs1), + 0, 1, 1, + NULL); do_push(specs2, ARRAY_SIZE(specs2), NULL, 0, - exp_refs1, ARRAY_SIZE(exp_refs1), GIT_ENONFASTFORWARD, 0, 0, push_options); + exp_refs1, ARRAY_SIZE(exp_refs1), + GIT_ENONFASTFORWARD, 0, 0, + NULL); /* Non-fast-forward update with force should pass. */ record_callbacks_data_clear(&_record_cbs_data); do_push(specs2_force, ARRAY_SIZE(specs2_force), exp_stats2_force, ARRAY_SIZE(exp_stats2_force), - exp_refs2_force, ARRAY_SIZE(exp_refs2_force), 0, 1, 1, push_options); + exp_refs2_force, ARRAY_SIZE(exp_refs2_force), + 0, 1, 1, + NULL); } static void push_option_test(git_strarray push_options, const char *expected_option) @@ -817,7 +840,9 @@ static void push_option_test(git_strarray push_options, const char *expected_opt do_push(specs, ARRAY_SIZE(specs), exp_stats, ARRAY_SIZE(exp_stats), - exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1, push_options); + exp_refs, ARRAY_SIZE(exp_refs), + 0, 1, 1, + &push_options); if (git_futils_readbuffer(&push_options_result, _remote_push_options_result) < 0) cl_fail("Failed to read push options result file"); @@ -874,10 +899,11 @@ void test_online_push__delete(void) /* Force has no effect for delete. */ const char *specs_delete_force[] = { "+:refs/heads/tgt1" }; - git_strarray push_options = { 0 }; do_push(specs1, ARRAY_SIZE(specs1), exp_stats1, ARRAY_SIZE(exp_stats1), - exp_refs1, ARRAY_SIZE(exp_refs1), 0, 1, 1, push_options); + exp_refs1, ARRAY_SIZE(exp_refs1), + 0, 1, 1, + NULL); /* When deleting a non-existent branch, the git client sends zero for both * the old and new commit id. This should succeed on the server with the @@ -887,25 +913,35 @@ void test_online_push__delete(void) */ do_push(specs_del_fake, ARRAY_SIZE(specs_del_fake), exp_stats_fake, 1, - exp_refs1, ARRAY_SIZE(exp_refs1), 0, 0, 0, push_options); + exp_refs1, ARRAY_SIZE(exp_refs1), + 0, 0, 0, + NULL); do_push(specs_del_fake_force, ARRAY_SIZE(specs_del_fake_force), exp_stats_fake, 1, - exp_refs1, ARRAY_SIZE(exp_refs1), 0, 0, 0, push_options); + exp_refs1, ARRAY_SIZE(exp_refs1), + 0, 0, 0, + NULL); /* Delete one of the pushed branches. */ do_push(specs_delete, ARRAY_SIZE(specs_delete), exp_stats_delete, ARRAY_SIZE(exp_stats_delete), - exp_refs_delete, ARRAY_SIZE(exp_refs_delete), 0, 0, 0, push_options); + exp_refs_delete, ARRAY_SIZE(exp_refs_delete), + 0, 0, 0, + NULL); /* Re-push branches and retry delete with force. */ do_push(specs1, ARRAY_SIZE(specs1), exp_stats1, ARRAY_SIZE(exp_stats1), - exp_refs1, ARRAY_SIZE(exp_refs1), 0, 0, 0, push_options); + exp_refs1, ARRAY_SIZE(exp_refs1), + 0, 0, 0, + NULL); do_push(specs_delete_force, ARRAY_SIZE(specs_delete_force), exp_stats_delete, ARRAY_SIZE(exp_stats_delete), - exp_refs_delete, ARRAY_SIZE(exp_refs_delete), 0, 0, 0, push_options); + exp_refs_delete, ARRAY_SIZE(exp_refs_delete), + 0, 0, 0, + NULL); } void test_online_push__bad_refspecs(void) @@ -947,19 +983,17 @@ void test_online_push__expressions(void) { "refs/heads/b6", &_oid_b6 } }; - git_strarray push_options = { 0 }; - do_push(specs_left_expr, ARRAY_SIZE(specs_left_expr), exp_stats, ARRAY_SIZE(exp_stats), - exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1, - push_options); + exp_refs, ARRAY_SIZE(exp_refs), + 0, 1, 1, + NULL); } void test_online_push__notes(void) { git_oid note_oid, *target_oid, expected_oid; git_signature *signature; - git_strarray push_options = { 0 }; const char *specs[] = { "refs/notes/commits:refs/notes/commits" }; push_status exp_stats[] = { { "refs/notes/commits", 1 } }; expected_ref exp_refs[] = { { "refs/notes/commits", &expected_oid } }; @@ -975,13 +1009,17 @@ void test_online_push__notes(void) do_push(specs, ARRAY_SIZE(specs), exp_stats, ARRAY_SIZE(exp_stats), - exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1, push_options); + exp_refs, ARRAY_SIZE(exp_refs), + 0, 1, 1, + NULL); /* And make sure to delete the note */ do_push(specs_del, ARRAY_SIZE(specs_del), exp_stats, 1, - NULL, 0, 0, 0, 0, push_options); + NULL, 0, + 0, 0, 0, + NULL); git_signature_free(signature); } @@ -991,7 +1029,6 @@ void test_online_push__configured(void) git_oid note_oid, *target_oid, expected_oid; git_signature *signature; git_remote *old_remote; - git_strarray push_options = { 0 }; const char *specs[] = { "refs/notes/commits:refs/notes/commits" }; push_status exp_stats[] = { { "refs/notes/commits", 1 } }; expected_ref exp_refs[] = { { "refs/notes/commits", &expected_oid } }; @@ -1012,13 +1049,17 @@ void test_online_push__configured(void) do_push(NULL, 0, exp_stats, ARRAY_SIZE(exp_stats), - exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1, push_options); + exp_refs, ARRAY_SIZE(exp_refs), + 0, 1, 1, + NULL); /* And make sure to delete the note */ do_push(specs_del, ARRAY_SIZE(specs_del), exp_stats, 1, - NULL, 0, 0, 0, 0, push_options); + NULL, 0, + 0, 0, 0, + NULL); git_signature_free(signature); } From 85279f06aae1796d1551609041c5e0cf691bb297 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 5 Feb 2024 11:48:19 +0000 Subject: [PATCH 479/608] ci: update push options tests Keep the push options tests more constrained to our CI environment; writing files within the test sandbox instead of outside of it. Provide the path to the output file in the test data. In addition, add the repository to the test resources instead of recreating the hooks every time. --- ci/hooks/pre-receive | 2 - ci/test.sh | 60 +++++-------------- tests/libgit2/online/push.c | 34 +++++++---- tests/resources/pushoptions.git/HEAD | 1 + .../pushoptions.git/branches/.gitignore | 0 tests/resources/pushoptions.git/config | 8 +++ tests/resources/pushoptions.git/description | 1 + .../pushoptions.git/hooks/pre-receive | 3 + tests/resources/pushoptions.git/info/exclude | 6 ++ .../pushoptions.git/objects/info/.gitignore | 0 .../pushoptions.git/objects/pack/.gitignore | 0 .../pushoptions.git/refs/heads/.gitignore | 0 .../pushoptions.git/refs/tags/.gitignore | 0 13 files changed, 57 insertions(+), 58 deletions(-) delete mode 100755 ci/hooks/pre-receive create mode 100644 tests/resources/pushoptions.git/HEAD create mode 100644 tests/resources/pushoptions.git/branches/.gitignore create mode 100644 tests/resources/pushoptions.git/config create mode 100644 tests/resources/pushoptions.git/description create mode 100755 tests/resources/pushoptions.git/hooks/pre-receive create mode 100644 tests/resources/pushoptions.git/info/exclude create mode 100644 tests/resources/pushoptions.git/objects/info/.gitignore create mode 100644 tests/resources/pushoptions.git/objects/pack/.gitignore create mode 100644 tests/resources/pushoptions.git/refs/heads/.gitignore create mode 100644 tests/resources/pushoptions.git/refs/tags/.gitignore diff --git a/ci/hooks/pre-receive b/ci/hooks/pre-receive deleted file mode 100755 index 92be65ce01f..00000000000 --- a/ci/hooks/pre-receive +++ /dev/null @@ -1,2 +0,0 @@ -#!/bin/sh -printf "$GIT_PUSH_OPTION_0$GIT_PUSH_OPTION_1$GIT_PUSH_OPTION_2" > %file% diff --git a/ci/test.sh b/ci/test.sh index 8543169ce5c..4217568226a 100755 --- a/ci/test.sh +++ b/ci/test.sh @@ -1,6 +1,6 @@ #!/usr/bin/env bash -set -ex +set -e if [ -n "$SKIP_TESTS" ]; then if [ -z "$SKIP_OFFLINE_TESTS" ]; then SKIP_OFFLINE_TESTS=1; fi @@ -162,14 +162,7 @@ echo "" if should_run "GITDAEMON_TESTS"; then echo "Starting git daemon (standard)..." GIT_STANDARD_DIR=`mktemp -d ${TMPDIR}/git_standard.XXXXXXXX` - git init --bare "${GIT_STANDARD_DIR}/test.git" >/dev/null - git config --file "${GIT_STANDARD_DIR}/test.git/config" receive.advertisePushOptions true - for f in $(ls ${SOURCE_DIR}/ci/hooks) - do - sed "s=%file%=${TMPDIR}/push-option-result-git-daemon=g" "${SOURCE_DIR}/ci/hooks/$f" > "${GIT_STANDARD_DIR}/test.git/hooks/${f}" - chmod +x "$GIT_STANDARD_DIR/test.git/hooks/${f}" - done - + cp -R "${SOURCE_DIR}/tests/resources/pushoptions.git" "${GIT_STANDARD_DIR}/test.git" git daemon --listen=localhost --export-all --enable=receive-pack --base-path="${GIT_STANDARD_DIR}" "${GIT_STANDARD_DIR}" 2>/dev/null & GIT_STANDARD_PID=$! @@ -204,14 +197,7 @@ if should_run "NTLM_TESTS" || should_run "ONLINE_TESTS"; then echo "Starting HTTP server..." HTTP_DIR=`mktemp -d ${TMPDIR}/http.XXXXXXXX` - git init --bare "${HTTP_DIR}/test.git" - git config --file "${HTTP_DIR}/test.git/config" receive.advertisePushOptions true - - for f in $(ls ${SOURCE_DIR}/ci/hooks) - do - sed "s=%file%=${TMPDIR}/push-option-result-git-ntlm=g" "${SOURCE_DIR}/ci/hooks/$f" > "${HTTP_DIR}/test.git/hooks/${f}" - chmod +x "$HTTP_DIR/test.git/hooks/${f}" - done + cp -R "${SOURCE_DIR}/tests/resources/pushoptions.git" "${HTTP_DIR}/test.git" java -jar poxygit.jar --address 127.0.0.1 --port 9000 --credentials foo:baz --quiet "${HTTP_DIR}" & HTTP_PID=$! @@ -220,14 +206,8 @@ fi if should_run "SSH_TESTS"; then echo "Starting SSH server..." SSHD_DIR=`mktemp -d ${TMPDIR}/sshd.XXXXXXXX` - git init --bare "${SSHD_DIR}/test.git" >/dev/null - git config --file "${SSHD_DIR}/test.git/config" receive.advertisePushOptions true - - for f in $(ls ${SOURCE_DIR}/ci/hooks) - do - sed "s=%file%=${TMPDIR}/push-option-result-git-ssh=g" "${SOURCE_DIR}/ci/hooks/$f" > "${SSHD_DIR}/test.git/hooks/${f}" - chmod +x "$SSHD_DIR/test.git/hooks/${f}" - done + cp -R "${SOURCE_DIR}/tests/resources/pushoptions.git" "${SSHD_DIR}/test.git" + ls -FlasR "${SSHD_DIR}" cat >"${SSHD_DIR}/sshd_config" <<-EOF Port 2222 @@ -344,13 +324,11 @@ if should_run "GITDAEMON_TESTS"; then echo "Running gitdaemon (standard) tests" echo "" - if [[ "$RUN_PUSH_OPTONS_TESTS" = "true " ]]; then - export GITTEST_PUSH_OPTION_RESULT="${TMPDIR}/push-option-result-git-daemon" - fi export GITTEST_REMOTE_URL="git://localhost/test.git" + export GITTEST_PUSH_OPTIONS=true run_test gitdaemon - unset GITTEST_PUSH_OPTION_RESULT unset GITTEST_REMOTE_URL + unset GITTEST_PUSH_OPTIONS echo "" echo "Running gitdaemon (namespace) tests" @@ -402,33 +380,29 @@ if should_run "NTLM_TESTS"; then echo "Running NTLM tests (IIS emulation)" echo "" - if [[ "$RUN_PUSH_OPTONS_TESTS" = "true " ]]; then - export GITTEST_PUSH_OPTION_RESULT="${TMPDIR}/push-option-result-git-ntlm" - fi export GITTEST_REMOTE_URL="http://localhost:9000/ntlm/test.git" export GITTEST_REMOTE_USER="foo" export GITTEST_REMOTE_PASS="baz" + export GITTEST_PUSH_OPTIONS=true run_test auth_clone_and_push - unset GITTEST_PUSH_OPTION_RESULT unset GITTEST_REMOTE_URL unset GITTEST_REMOTE_USER unset GITTEST_REMOTE_PASS + unset GITTEST_PUSH_OPTIONS echo "" echo "Running NTLM tests (Apache emulation)" echo "" - if [[ "$RUN_PUSH_OPTONS_TESTS" == "true " ]]; then - export GITTEST_PUSH_OPTION_RESULT="${TMPDIR}/push-option-result-git-ntlm" - fi export GITTEST_REMOTE_URL="http://localhost:9000/broken-ntlm/test.git" export GITTEST_REMOTE_USER="foo" export GITTEST_REMOTE_PASS="baz" + export GITTEST_PUSH_OPTIONS=true run_test auth_clone_and_push - unset GITTEST_PUSH_OPTION_RESULT unset GITTEST_REMOTE_URL unset GITTEST_REMOTE_USER unset GITTEST_REMOTE_PASS + unset GITTEST_PUSH_OPTIONS fi if should_run "NEGOTIATE_TESTS" && -n "$GITTEST_NEGOTIATE_PASSWORD" ; then @@ -477,25 +451,21 @@ if should_run "SSH_TESTS"; then echo "Running ssh tests" echo "" - if [[ "$RUN_PUSH_OPTONS_TESTS" == "true " ]]; then - export GITTEST_PUSH_OPTION_RESULT="${TMPDIR}/push-option-result-ssh" - fi export GITTEST_REMOTE_URL="ssh://localhost:2222/$SSHD_DIR/test.git" + export GITTEST_PUSH_OPTIONS=true run_test ssh - unset GITTEST_PUSH_OPTION_RESULT unset GITTEST_REMOTE_URL + unset GITTEST_PUSH_OPTIONS echo "" echo "Running ssh tests (scp-style paths)" echo "" - if [[ "$RUN_PUSH_OPTONS_TESTS" == "true " ]]; then - export GITTEST_PUSH_OPTION_RESULT="${TMPDIR}/push-option-result-ssh" - fi export GITTEST_REMOTE_URL="[localhost:2222]:$SSHD_DIR/test.git" + export GITTEST_PUSH_OPTIONS=true run_test ssh - unset GITTEST_PUSH_OPTION_RESULT unset GITTEST_REMOTE_URL + unset GITTEST_PUSH_OPTIONS unset GITTEST_SSH_CMD diff --git a/tests/libgit2/online/push.c b/tests/libgit2/online/push.c index cfd43209da4..e5693bf346c 100644 --- a/tests/libgit2/online/push.c +++ b/tests/libgit2/online/push.c @@ -21,11 +21,11 @@ static char *_remote_ssh_passphrase = NULL; static char *_remote_default = NULL; static char *_remote_expectcontinue = NULL; +static char *_remote_push_options = NULL; + static char *_orig_ssh_cmd = NULL; static char *_ssh_cmd = NULL; -static char *_remote_push_options_result = NULL; - static int cred_acquire_cb(git_credential **, const char *, const char *, unsigned int, void *); static git_remote *_remote; @@ -373,7 +373,7 @@ void test_online_push__initialize(void) _remote_ssh_passphrase = cl_getenv("GITTEST_REMOTE_SSH_PASSPHRASE"); _remote_default = cl_getenv("GITTEST_REMOTE_DEFAULT"); _remote_expectcontinue = cl_getenv("GITTEST_REMOTE_EXPECTCONTINUE"); - _remote_push_options_result = cl_getenv("GITTEST_PUSH_OPTION_RESULT"); + _remote_push_options = cl_getenv("GITTEST_PUSH_OPTIONS"); _remote = NULL; _orig_ssh_cmd = cl_getenv("GIT_SSH"); @@ -437,7 +437,7 @@ void test_online_push__cleanup(void) git__free(_remote_ssh_passphrase); git__free(_remote_default); git__free(_remote_expectcontinue); - git__free(_remote_push_options_result); + git__free(_remote_push_options); git__free(_orig_ssh_cmd); git__free(_ssh_cmd); @@ -449,6 +449,7 @@ void test_online_push__cleanup(void) record_callbacks_data_clear(&_record_cbs_data); + cl_fixture_cleanup("push-options-result"); cl_fixture_cleanup("testrepo.git"); cl_git_sandbox_cleanup(); } @@ -827,30 +828,41 @@ void test_online_push__force(void) NULL); } -static void push_option_test(git_strarray push_options, const char *expected_option) +static void push_option_test(git_strarray given_options, const char *expected_option) { const char *specs[] = { "refs/heads/b1:refs/heads/b1" }; push_status exp_stats[] = { { "refs/heads/b1", 1 } }; expected_ref exp_refs[] = { { "refs/heads/b1", &_oid_b1 } }; + git_str push_options_path = GIT_STR_INIT; git_str push_options_result = GIT_STR_INIT; + char *options[16]; + git_strarray push_options = { options, given_options.count + 1 }; + size_t i; /* Skip the test if we're missing the push options result file */ - if (!_remote_push_options_result) + if (!_remote_push_options) cl_skip(); + cl_assert(given_options.count < 16); + + cl_git_pass(git_str_joinpath(&push_options_path, clar_sandbox_path(), "push-options-result")); + + options[0] = push_options_path.ptr; + for (i = 0; i < given_options.count; i++) + options[i + 1] = given_options.strings[i]; + do_push(specs, ARRAY_SIZE(specs), exp_stats, ARRAY_SIZE(exp_stats), exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1, &push_options); - if (git_futils_readbuffer(&push_options_result, _remote_push_options_result) < 0) - cl_fail("Failed to read push options result file"); - - cl_assert_equal_strn(expected_option, git_str_cstr(&push_options_result), - strlen(expected_option)); + cl_assert(git_fs_path_exists(push_options_path.ptr)); + cl_git_pass(git_futils_readbuffer(&push_options_result, push_options_path.ptr)); + cl_assert_equal_s(expected_option, git_str_cstr(&push_options_result)); git_str_dispose(&push_options_result); + git_str_dispose(&push_options_path); } void test_online_push__options(void) diff --git a/tests/resources/pushoptions.git/HEAD b/tests/resources/pushoptions.git/HEAD new file mode 100644 index 00000000000..b870d82622c --- /dev/null +++ b/tests/resources/pushoptions.git/HEAD @@ -0,0 +1 @@ +ref: refs/heads/main diff --git a/tests/resources/pushoptions.git/branches/.gitignore b/tests/resources/pushoptions.git/branches/.gitignore new file mode 100644 index 00000000000..e69de29bb2d diff --git a/tests/resources/pushoptions.git/config b/tests/resources/pushoptions.git/config new file mode 100644 index 00000000000..23d39788fa7 --- /dev/null +++ b/tests/resources/pushoptions.git/config @@ -0,0 +1,8 @@ +[core] + repositoryformatversion = 0 + filemode = true + bare = true + ignorecase = true + precomposeunicode = true +[receive] + advertisePushOptions = true diff --git a/tests/resources/pushoptions.git/description b/tests/resources/pushoptions.git/description new file mode 100644 index 00000000000..498b267a8c7 --- /dev/null +++ b/tests/resources/pushoptions.git/description @@ -0,0 +1 @@ +Unnamed repository; edit this file 'description' to name the repository. diff --git a/tests/resources/pushoptions.git/hooks/pre-receive b/tests/resources/pushoptions.git/hooks/pre-receive new file mode 100755 index 00000000000..24f48d34c54 --- /dev/null +++ b/tests/resources/pushoptions.git/hooks/pre-receive @@ -0,0 +1,3 @@ +#!/bin/sh +printf "${GIT_PUSH_OPTION_1}${GIT_PUSH_OPTION_2}${GIT_PUSH_OPTION_3}" > "${GIT_PUSH_OPTION_0}" +exit 0 diff --git a/tests/resources/pushoptions.git/info/exclude b/tests/resources/pushoptions.git/info/exclude new file mode 100644 index 00000000000..a5196d1be8f --- /dev/null +++ b/tests/resources/pushoptions.git/info/exclude @@ -0,0 +1,6 @@ +# git ls-files --others --exclude-from=.git/info/exclude +# Lines that start with '#' are comments. +# For a project mostly in C, the following would be a good set of +# exclude patterns (uncomment them if you want to use them): +# *.[oa] +# *~ diff --git a/tests/resources/pushoptions.git/objects/info/.gitignore b/tests/resources/pushoptions.git/objects/info/.gitignore new file mode 100644 index 00000000000..e69de29bb2d diff --git a/tests/resources/pushoptions.git/objects/pack/.gitignore b/tests/resources/pushoptions.git/objects/pack/.gitignore new file mode 100644 index 00000000000..e69de29bb2d diff --git a/tests/resources/pushoptions.git/refs/heads/.gitignore b/tests/resources/pushoptions.git/refs/heads/.gitignore new file mode 100644 index 00000000000..e69de29bb2d diff --git a/tests/resources/pushoptions.git/refs/tags/.gitignore b/tests/resources/pushoptions.git/refs/tags/.gitignore new file mode 100644 index 00000000000..e69de29bb2d From 00eb3470682e25e9362e207790914c5e2688c71a Mon Sep 17 00:00:00 2001 From: Sergio Correia Date: Tue, 16 Jan 2024 09:46:01 +0000 Subject: [PATCH 480/608] ci: add fedora container and build So that we can test a build with llhttp instead of http-parser. Co-authored-by: Stephen Gallagher Signed-off-by: Sergio Correia Signed-off-by: Stephen Gallagher --- .github/workflows/build-containers.yml | 1 + .github/workflows/main.yml | 9 ++++ ci/docker/fedora | 61 ++++++++++++++++++++++++++ 3 files changed, 71 insertions(+) create mode 100644 ci/docker/fedora diff --git a/.github/workflows/build-containers.yml b/.github/workflows/build-containers.yml index 56ac66a9016..84bc4da0e64 100644 --- a/.github/workflows/build-containers.yml +++ b/.github/workflows/build-containers.yml @@ -40,6 +40,7 @@ jobs: qemu: true - name: centos7 - name: centos8 + - name: fedora runs-on: ubuntu-latest name: "Create container: ${{ matrix.container.name }}" steps: diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index accb042e463..aca6b0ee359 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -62,6 +62,15 @@ jobs: CC: clang CMAKE_GENERATOR: Ninja CMAKE_OPTIONS: -DUSE_HTTPS=mbedTLS -DUSE_SHA1=HTTPS -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=libssh2 + - name: "Linux (Fedora, GCC, llhttp, SHA-256, OpenSSL, libssh2" + id: fedora-gcc-openssl-llhttp + os: ubuntu-latest + container: + name: fedora + env: + CC: gcc + CMAKE_GENERATOR: Ninja + CMAKE_OPTIONS: -DUSE_HTTPS=OpenSSL -DREGEX_BACKEND=pcre2 -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_NTLMCLIENT=OFF -DUSE_SSH=libssh2 -DDEBUG_STRICT_ALLOC=ON -DDEBUG_STRICT_OPEN=ON -DEXPERIMENTAL_SHA256=ON - name: "macOS" id: macos os: macos-12 diff --git a/ci/docker/fedora b/ci/docker/fedora new file mode 100644 index 00000000000..d6339bc8512 --- /dev/null +++ b/ci/docker/fedora @@ -0,0 +1,61 @@ +ARG BASE=fedora:rawhide + +FROM ${BASE} AS stream +RUN dnf -y distro-sync + +FROM stream AS yum +RUN yum install -y \ + which \ + bzip2 \ + git \ + libarchive \ + cmake \ + gcc \ + make \ + openssl-devel \ + openssh-server \ + git-daemon \ + java-1.8.0-openjdk-headless \ + sudo \ + python3 \ + krb5-workstation \ + krb5-libs \ + krb5-devel \ + pcre2-devel \ + ninja-build \ + llhttp-devel + +FROM yum AS libssh2 +RUN cd /tmp && \ + curl --location --silent --show-error https://www.libssh2.org/download/libssh2-1.11.0.tar.gz | tar -xz && \ + cd libssh2-1.11.0 && \ + ./configure && \ + make && \ + make install && \ + cd .. && \ + rm -rf libssh2-1.11.0 + +FROM libssh2 AS valgrind +RUN cd /tmp && \ + curl --insecure --location --silent --show-error https://sourceware.org/pub/valgrind/valgrind-3.15.0.tar.bz2 | \ + tar -xj && \ + cd valgrind-3.15.0 && \ + ./configure && \ + make MAKEFLAGS="-j -l$(grep -c ^processor /proc/cpuinfo)" && \ + make install && \ + cd .. && \ + rm -rf valgrind-3.15.0 + +FROM valgrind AS adduser +ARG UID="" +ARG GID="" +RUN if [ "${UID}" != "" ]; then USER_ARG="--uid ${UID}"; fi && \ + if [ "${GID}" != "" ]; then GROUP_ARG="--gid ${GID}"; fi && \ + groupadd ${GROUP_ARG} libgit2 && \ + useradd ${USER_ARG} --gid libgit2 --shell /bin/bash --create-home libgit2 + +FROM adduser AS configure +ENV PKG_CONFIG_PATH /usr/local/lib/pkgconfig +RUN mkdir /var/run/sshd +RUN echo "/usr/local/lib" > /etc/ld.so.conf.d/local && \ + ldconfig From 06e384a0a44a7ab33e24b0e2123dc1edbf86becc Mon Sep 17 00:00:00 2001 From: Stephen Gallagher Date: Wed, 10 Jan 2024 17:07:45 -0500 Subject: [PATCH 481/608] Enable llhttp for HTTP parsing Fixes: https://github.com/libgit2/libgit2/issues/6074 We now try to use llhttp by default, falling back to http-parser if the former is not available. As a last resort, we use the bundled http-parser. Co-authored-by: Sergio Correia Signed-off-by: Stephen Gallagher Signed-off-by: Sergio Correia --- cmake/FindLLHTTP.cmake | 39 +++++++++ cmake/SelectHTTPParser.cmake | 44 +++++++--- src/libgit2/transports/http.c | 1 - src/libgit2/transports/httpclient.c | 122 ++++++++++++++++++++++------ src/util/net.c | 1 - 5 files changed, 169 insertions(+), 38 deletions(-) create mode 100644 cmake/FindLLHTTP.cmake diff --git a/cmake/FindLLHTTP.cmake b/cmake/FindLLHTTP.cmake new file mode 100644 index 00000000000..a87d335d048 --- /dev/null +++ b/cmake/FindLLHTTP.cmake @@ -0,0 +1,39 @@ +# - Try to find llhttp +# +# Defines the following variables: +# +# LLHTTP_FOUND - system has llhttp +# LLHTTP_INCLUDE_DIR - the llhttp include directory +# LLHTTP_LIBRARIES - Link these to use llhttp +# LLHTTP_VERSION_MAJOR - major version +# LLHTTP_VERSION_MINOR - minor version +# LLHTTP_VERSION_STRING - the version of llhttp found + +# Find the header and library +find_path(LLHTTP_INCLUDE_DIR NAMES llhttp.h) +find_library(LLHTTP_LIBRARY NAMES llhttp libllhttp) + +# Found the header, read version +if(LLHTTP_INCLUDE_DIR AND EXISTS "${LLHTTP_INCLUDE_DIR}/llhttp.h") + file(READ "${LLHTTP_INCLUDE_DIR}/llhttp.h" LLHTTP_H) + if(LLHTTP_H) + string(REGEX REPLACE ".*#define[\t ]+LLHTTP_VERSION_MAJOR[\t ]+([0-9]+).*" "\\1" LLHTTP_VERSION_MAJOR "${LLHTTP_H}") + string(REGEX REPLACE ".*#define[\t ]+LLHTTP_VERSION_MINOR[\t ]+([0-9]+).*" "\\1" LLHTTP_VERSION_MINOR "${LLHTTP_H}") + set(LLHTTP_VERSION_STRING "${LLHTTP_VERSION_MAJOR}.${LLHTTP_VERSION_MINOR}") + endif() + unset(LLHTTP_H) +endif() + +# Handle the QUIETLY and REQUIRED arguments and set LLHTTP_FOUND +# to TRUE if all listed variables are TRUE +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(LLHTTP REQUIRED_VARS LLHTTP_INCLUDE_DIR LLHTTP_LIBRARY) + +# Hide advanced variables +mark_as_advanced(LLHTTP_INCLUDE_DIR LLHTTP_LIBRARY) + +# Set standard variables +if(LLHTTP_FOUND) + set(LLHTTP_LIBRARIES ${LLHTTP_LIBRARY}) + set(LLHTTP_INCLUDE_DIRS ${LLHTTP_INCLUDE_DIR}) +endif() diff --git a/cmake/SelectHTTPParser.cmake b/cmake/SelectHTTPParser.cmake index 955aea3308c..aa6711d9607 100644 --- a/cmake/SelectHTTPParser.cmake +++ b/cmake/SelectHTTPParser.cmake @@ -1,19 +1,39 @@ # Optional external dependency: http-parser -if(USE_HTTP_PARSER STREQUAL "system") - find_package(HTTPParser) +if(USE_HTTP_PARSER STREQUAL "builtin") + message(STATUS "support for bundled (legacy) http-parser explicitly requested") - if(HTTP_PARSER_FOUND AND HTTP_PARSER_VERSION_MAJOR EQUAL 2) - list(APPEND LIBGIT2_SYSTEM_INCLUDES ${HTTP_PARSER_INCLUDE_DIRS}) - list(APPEND LIBGIT2_SYSTEM_LIBS ${HTTP_PARSER_LIBRARIES}) - list(APPEND LIBGIT2_PC_LIBS "-lhttp_parser") - add_feature_info(http-parser ON "http-parser support (system)") - else() - message(FATAL_ERROR "http-parser support was requested but not found") - endif() -else() - message(STATUS "http-parser version 2 was not found or disabled; using bundled 3rd-party sources.") add_subdirectory("${PROJECT_SOURCE_DIR}/deps/http-parser" "${PROJECT_BINARY_DIR}/deps/http-parser") list(APPEND LIBGIT2_DEPENDENCY_INCLUDES "${PROJECT_SOURCE_DIR}/deps/http-parser") list(APPEND LIBGIT2_DEPENDENCY_OBJECTS "$") add_feature_info(http-parser ON "http-parser support (bundled)") +else() + # By default, try to use system LLHTTP. Fall back to + # system http-parser, and even to bundled http-parser + # as a last resort. + find_package(LLHTTP) + + if(LLHTTP_FOUND AND LLHTTP_VERSION_MAJOR EQUAL 9) + add_compile_definitions(USE_LLHTTP) + list(APPEND LIBGIT2_SYSTEM_INCLUDES ${LLHTTP_INCLUDE_DIRS}) + list(APPEND LIBGIT2_SYSTEM_LIBS ${LLHTTP_LIBRARIES}) + list(APPEND LIBGIT2_PC_LIBS "-lllhttp") + add_feature_info(llhttp ON "llhttp support (system)") + else() + message(STATUS "llhttp support was requested but not found; checking (legacy) http-parser support") + find_package(HTTPParser) + + if(HTTP_PARSER_FOUND AND HTTP_PARSER_VERSION_MAJOR EQUAL 2) + list(APPEND LIBGIT2_SYSTEM_INCLUDES ${HTTP_PARSER_INCLUDE_DIRS}) + list(APPEND LIBGIT2_SYSTEM_LIBS ${HTTP_PARSER_LIBRARIES}) + list(APPEND LIBGIT2_PC_LIBS "-lhttp_parser") + add_feature_info(http-parser ON "http-parser support (system)") + else() + message(STATUS "neither llhttp nor http-parser support was found; proceeding with bundled (legacy) http-parser") + + add_subdirectory("${PROJECT_SOURCE_DIR}/deps/http-parser" "${PROJECT_BINARY_DIR}/deps/http-parser") + list(APPEND LIBGIT2_DEPENDENCY_INCLUDES "${PROJECT_SOURCE_DIR}/deps/http-parser") + list(APPEND LIBGIT2_DEPENDENCY_OBJECTS "$") + add_feature_info(http-parser ON "http-parser support (bundled)") + endif() + endif() endif() diff --git a/src/libgit2/transports/http.c b/src/libgit2/transports/http.c index 8437674fcc9..fc2161b6076 100644 --- a/src/libgit2/transports/http.c +++ b/src/libgit2/transports/http.c @@ -9,7 +9,6 @@ #ifndef GIT_WINHTTP -#include "http_parser.h" #include "net.h" #include "remote.h" #include "smart.h" diff --git a/src/libgit2/transports/httpclient.c b/src/libgit2/transports/httpclient.c index e22a07ba1a0..6e3491ed2b3 100644 --- a/src/libgit2/transports/httpclient.c +++ b/src/libgit2/transports/httpclient.c @@ -7,7 +7,32 @@ #include "common.h" #include "git2.h" -#include "http_parser.h" + +#ifdef USE_LLHTTP +#include +typedef llhttp_settings_t http_settings_t; +typedef llhttp_t http_parser_t; +GIT_INLINE(http_settings_t *) http_client_parser_settings(void); +#define git_http_parser_init(parser) llhttp_init(parser, HTTP_RESPONSE, http_client_parser_settings()) +#define git_http_parser_pause(parser) llhttp_pause(parser) +#define git_http_parser_resume(parser) llhttp_resume(parser) +#define git_http_parser_errno(parser) parser.error +#define git_http_should_keep_alive(parser) llhttp_should_keep_alive(parser) +#define git_http_errno_description(parser, errno) llhttp_get_error_reason(parser) +#else +#include +/* Legacy http-parser. */ +typedef http_parser_settings http_settings_t; +typedef struct http_parser http_parser_t; +GIT_INLINE(http_settings_t *) http_client_parser_settings(void); +#define git_http_parser_init(parser) http_parser_init(parser, HTTP_RESPONSE) +#define git_http_parser_pause(parser) http_parser_pause(parser, 1) +#define git_http_parser_resume(parser) http_parser_pause(parser, 0) +#define git_http_parser_errno(parser) parser.http_errno +#define git_http_should_keep_alive(parser) http_should_keep_alive(parser) +#define git_http_errno_description(parser, errno) http_errno_description(errno) +#endif /* USE_LLHTTP */ + #include "vector.h" #include "trace.h" #include "httpclient.h" @@ -108,7 +133,7 @@ struct git_http_client { git_http_server_t current_server; http_client_state state; - http_parser parser; + http_parser_t parser; git_http_server server; git_http_server proxy; @@ -154,7 +179,7 @@ void git_http_response_dispose(git_http_response *response) memset(response, 0, sizeof(git_http_response)); } -static int on_header_complete(http_parser *parser) +static int on_header_complete(http_parser_t *parser) { http_parser_context *ctx = (http_parser_context *) parser->data; git_http_client *client = ctx->client; @@ -219,7 +244,7 @@ static int on_header_complete(http_parser *parser) return 0; } -static int on_header_field(http_parser *parser, const char *str, size_t len) +static int on_header_field(http_parser_t *parser, const char *str, size_t len) { http_parser_context *ctx = (http_parser_context *) parser->data; @@ -254,7 +279,7 @@ static int on_header_field(http_parser *parser, const char *str, size_t len) return 0; } -static int on_header_value(http_parser *parser, const char *str, size_t len) +static int on_header_value(http_parser_t *parser, const char *str, size_t len) { http_parser_context *ctx = (http_parser_context *) parser->data; @@ -342,7 +367,7 @@ static int resend_needed(git_http_client *client, git_http_response *response) return 0; } -static int on_headers_complete(http_parser *parser) +static int on_headers_complete(http_parser_t *parser) { http_parser_context *ctx = (http_parser_context *) parser->data; @@ -365,7 +390,7 @@ static int on_headers_complete(http_parser *parser) } ctx->response->status = parser->status_code; - ctx->client->keepalive = http_should_keep_alive(parser); + ctx->client->keepalive = git_http_should_keep_alive(parser); /* Prepare for authentication */ collect_authinfo(&ctx->response->server_auth_schemetypes, @@ -378,18 +403,28 @@ static int on_headers_complete(http_parser *parser) ctx->response->resend_credentials = resend_needed(ctx->client, ctx->response); - /* Stop parsing. */ - http_parser_pause(parser, 1); +#ifndef USE_LLHTTP + /* Stop parsing. llhttp documentation says about llhttp_pause(): + * "Do not call this from user callbacks! User callbacks must + * return HPE_PAUSED if pausing is required", so that's what + * we will do, and call git_http_parser_pause() only for + * http-parser. */ + git_http_parser_pause(parser); +#endif if (ctx->response->content_type || ctx->response->chunked) ctx->client->state = READING_BODY; else ctx->client->state = DONE; +#ifdef USE_LLHTTP + return HPE_PAUSED; +#else return 0; +#endif } -static int on_body(http_parser *parser, const char *buf, size_t len) +static int on_body(http_parser_t *parser, const char *buf, size_t len) { http_parser_context *ctx = (http_parser_context *) parser->data; size_t max_len; @@ -411,7 +446,7 @@ static int on_body(http_parser *parser, const char *buf, size_t len) return 0; } -static int on_message_complete(http_parser *parser) +static int on_message_complete(http_parser_t *parser) { http_parser_context *ctx = (http_parser_context *) parser->data; @@ -878,7 +913,7 @@ GIT_INLINE(int) server_setup_from_url( static void reset_parser(git_http_client *client) { - http_parser_init(&client->parser, HTTP_RESPONSE); + git_http_parser_init(&client->parser); } static int setup_hosts( @@ -1122,9 +1157,46 @@ GIT_INLINE(int) client_read(git_http_client *client) } static bool parser_settings_initialized; -static http_parser_settings parser_settings; +static http_settings_t parser_settings; + +static size_t git_http_parser_execute(http_parser_t *parser, const char* data, size_t len) +{ +#ifdef USE_LLHTTP + llhttp_errno_t error; + size_t parsed_len; + + /* + * Unlike http_parser, which returns the number of parsed + * bytes in the _execute() call, llhttp returns an error + * code. + */ + + if (data == NULL || len == 0) { + error = llhttp_finish(parser); + } else { + error = llhttp_execute(parser, data, len); + } + + parsed_len = len; + /* + * Adjust number of parsed bytes in case of error. + */ + if (error != HPE_OK) { + parsed_len = llhttp_get_error_pos(parser) - data; + + /* This isn't a real pause, just a way to stop parsing early. */ + if (error == HPE_PAUSED_UPGRADE) { + llhttp_resume_after_upgrade(parser); + } + } + + return parsed_len; +#else + return http_parser_execute(parser, http_client_parser_settings(), data, len); +#endif +} -GIT_INLINE(http_parser_settings *) http_client_parser_settings(void) +GIT_INLINE(http_settings_t *) http_client_parser_settings(void) { if (!parser_settings_initialized) { parser_settings.on_header_field = on_header_field; @@ -1141,7 +1213,7 @@ GIT_INLINE(http_parser_settings *) http_client_parser_settings(void) GIT_INLINE(int) client_read_and_parse(git_http_client *client) { - http_parser *parser = &client->parser; + http_parser_t *parser = &client->parser; http_parser_context *ctx = (http_parser_context *) parser->data; unsigned char http_errno; int read_len; @@ -1155,11 +1227,10 @@ GIT_INLINE(int) client_read_and_parse(git_http_client *client) if (!client->read_buf.size && (read_len = client_read(client)) < 0) return read_len; - parsed_len = http_parser_execute(parser, - http_client_parser_settings(), + parsed_len = git_http_parser_execute(parser, client->read_buf.ptr, client->read_buf.size); - http_errno = client->parser.http_errno; + http_errno = git_http_parser_errno(client->parser); if (parsed_len > INT_MAX) { git_error_set(GIT_ERROR_HTTP, "unexpectedly large parse"); @@ -1179,6 +1250,7 @@ GIT_INLINE(int) client_read_and_parse(git_http_client *client) * where the server gives you a 100 and 200 simultaneously.) */ if (http_errno == HPE_PAUSED) { +#ifndef USE_LLHTTP /* * http-parser has a "feature" where it will not deliver the * final byte when paused in a callback. Consume that byte. @@ -1186,18 +1258,20 @@ GIT_INLINE(int) client_read_and_parse(git_http_client *client) */ GIT_ASSERT(client->read_buf.size > parsed_len); - http_parser_pause(parser, 0); +#endif + git_http_parser_resume(parser); - parsed_len += http_parser_execute(parser, - http_client_parser_settings(), +#ifndef USE_LLHTTP + parsed_len += git_http_parser_execute(parser, client->read_buf.ptr + parsed_len, 1); +#endif } /* Most failures will be reported in http_errno */ - else if (parser->http_errno != HPE_OK) { + else if (git_http_parser_errno(client->parser) != HPE_OK) { git_error_set(GIT_ERROR_HTTP, "http parser error: %s", - http_errno_description(http_errno)); + git_http_errno_description(parser, http_errno)); return -1; } @@ -1205,7 +1279,7 @@ GIT_INLINE(int) client_read_and_parse(git_http_client *client) else if (parsed_len != client->read_buf.size) { git_error_set(GIT_ERROR_HTTP, "http parser did not consume entire buffer: %s", - http_errno_description(http_errno)); + git_http_errno_description(parser, http_errno)); return -1; } diff --git a/src/util/net.c b/src/util/net.c index 4474564511b..dede784cc31 100644 --- a/src/util/net.c +++ b/src/util/net.c @@ -11,7 +11,6 @@ #include "posix.h" #include "str.h" -#include "http_parser.h" #include "runtime.h" #define DEFAULT_PORT_HTTP "80" From c95e91a280e58c4776b8f440c1bde5b9184827c5 Mon Sep 17 00:00:00 2001 From: Sebastien Marie Date: Mon, 12 Feb 2024 10:17:02 +0100 Subject: [PATCH 482/608] GIT_RAND_GETENTROPY: do not include sys/random.h CMakeLists.txt is looking for unistd.h (where the getentropy function is present for at least Linux and OpenBSD). It isn't necessary to include sys/random.h (which is Linux only). It unbreak the build on OpenBSD. --- src/util/rand.c | 4 ---- 1 file changed, 4 deletions(-) diff --git a/src/util/rand.c b/src/util/rand.c index 2ed0605738b..a02853519b2 100644 --- a/src/util/rand.c +++ b/src/util/rand.c @@ -10,10 +10,6 @@ See . */ #include "rand.h" #include "runtime.h" -#if defined(GIT_RAND_GETENTROPY) -# include -#endif - #if defined(GIT_WIN32) # include #endif From 38a062ddca5d95d8e308894886567d2c49a0fac2 Mon Sep 17 00:00:00 2001 From: Parnic Date: Fri, 16 Feb 2024 09:09:32 -0600 Subject: [PATCH 483/608] Support index.skipHash true config When this is set, the checksum at the end of the index is zero. Fixes #6531 --- src/libgit2/index.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/libgit2/index.c b/src/libgit2/index.c index 5074e3e1fa4..86f14fdfc41 100644 --- a/src/libgit2/index.c +++ b/src/libgit2/index.c @@ -2760,6 +2760,7 @@ static int parse_index(git_index *index, const char *buffer, size_t buffer_size) unsigned int i; struct index_header header = { 0 }; unsigned char checksum[GIT_HASH_MAX_SIZE]; + unsigned char zero_checksum[GIT_HASH_MAX_SIZE] = { 0 }; size_t checksum_size = git_hash_size(git_oid_algorithm(index->oid_type)); const char *last = NULL; const char *empty = ""; @@ -2849,8 +2850,9 @@ static int parse_index(git_index *index, const char *buffer, size_t buffer_size) /* * SHA-1 or SHA-256 (depending on the repository's object format) * over the content of the index file before this checksum. + * Note: checksum may be 0 if index.skipHash is set to true. */ - if (memcmp(checksum, buffer, checksum_size) != 0) { + if (memcmp(zero_checksum, buffer, checksum_size) != 0 && memcmp(checksum, buffer, checksum_size) != 0) { error = index_error_invalid( "calculated checksum does not match expected"); goto done; From 9ed014775ee47e0b59ce2fc3b12a79344596f05b Mon Sep 17 00:00:00 2001 From: Parnic Date: Fri, 16 Feb 2024 09:29:21 -0600 Subject: [PATCH 484/608] Add index.skipHash test --- tests/libgit2/status/worktree.c | 9 + .../status_skipHash/.gitted/COMMIT_EDITMSG | 1 + tests/resources/status_skipHash/.gitted/HEAD | 1 + .../status_skipHash/.gitted/MERGE_RR | 0 .../resources/status_skipHash/.gitted/config | 9 + .../status_skipHash/.gitted/description | 1 + .../.gitted/hooks/applypatch-msg.sample | 15 ++ .../.gitted/hooks/commit-msg.sample | 24 +++ .../.gitted/hooks/fsmonitor-watchman.sample | 174 ++++++++++++++++++ .../.gitted/hooks/post-update.sample | 8 + .../.gitted/hooks/pre-applypatch.sample | 14 ++ .../.gitted/hooks/pre-commit.sample | 49 +++++ .../.gitted/hooks/pre-merge-commit.sample | 13 ++ .../.gitted/hooks/pre-push.sample | 53 ++++++ .../.gitted/hooks/pre-rebase.sample | 169 +++++++++++++++++ .../.gitted/hooks/pre-receive.sample | 24 +++ .../.gitted/hooks/prepare-commit-msg.sample | 42 +++++ .../.gitted/hooks/push-to-checkout.sample | 78 ++++++++ .../.gitted/hooks/sendemail-validate.sample | 77 ++++++++ .../.gitted/hooks/update.sample | 128 +++++++++++++ tests/resources/status_skipHash/.gitted/index | Bin 0 -> 137 bytes .../status_skipHash/.gitted/info/exclude | 6 + .../status_skipHash/.gitted/logs/HEAD | 1 + .../.gitted/logs/refs/heads/main | 1 + .../34/f4c90b237fcb4c677772a6093f3cba239c41a5 | Bin 0 -> 510 bytes .../71/a21e67674e9717aa7380e5782ec5e070a8d7e0 | Bin 0 -> 53 bytes .../d7/c1f165e51adbbfd7760162b7a5802d4117740c | Bin 0 -> 26 bytes .../status_skipHash/.gitted/refs/heads/main | 1 + tests/resources/status_skipHash/new_file | 1 + 29 files changed, 899 insertions(+) create mode 100644 tests/resources/status_skipHash/.gitted/COMMIT_EDITMSG create mode 100644 tests/resources/status_skipHash/.gitted/HEAD create mode 100644 tests/resources/status_skipHash/.gitted/MERGE_RR create mode 100644 tests/resources/status_skipHash/.gitted/config create mode 100644 tests/resources/status_skipHash/.gitted/description create mode 100644 tests/resources/status_skipHash/.gitted/hooks/applypatch-msg.sample create mode 100644 tests/resources/status_skipHash/.gitted/hooks/commit-msg.sample create mode 100644 tests/resources/status_skipHash/.gitted/hooks/fsmonitor-watchman.sample create mode 100644 tests/resources/status_skipHash/.gitted/hooks/post-update.sample create mode 100644 tests/resources/status_skipHash/.gitted/hooks/pre-applypatch.sample create mode 100644 tests/resources/status_skipHash/.gitted/hooks/pre-commit.sample create mode 100644 tests/resources/status_skipHash/.gitted/hooks/pre-merge-commit.sample create mode 100644 tests/resources/status_skipHash/.gitted/hooks/pre-push.sample create mode 100644 tests/resources/status_skipHash/.gitted/hooks/pre-rebase.sample create mode 100644 tests/resources/status_skipHash/.gitted/hooks/pre-receive.sample create mode 100644 tests/resources/status_skipHash/.gitted/hooks/prepare-commit-msg.sample create mode 100644 tests/resources/status_skipHash/.gitted/hooks/push-to-checkout.sample create mode 100644 tests/resources/status_skipHash/.gitted/hooks/sendemail-validate.sample create mode 100644 tests/resources/status_skipHash/.gitted/hooks/update.sample create mode 100644 tests/resources/status_skipHash/.gitted/index create mode 100644 tests/resources/status_skipHash/.gitted/info/exclude create mode 100644 tests/resources/status_skipHash/.gitted/logs/HEAD create mode 100644 tests/resources/status_skipHash/.gitted/logs/refs/heads/main create mode 100644 tests/resources/status_skipHash/.gitted/objects/34/f4c90b237fcb4c677772a6093f3cba239c41a5 create mode 100644 tests/resources/status_skipHash/.gitted/objects/71/a21e67674e9717aa7380e5782ec5e070a8d7e0 create mode 100644 tests/resources/status_skipHash/.gitted/objects/d7/c1f165e51adbbfd7760162b7a5802d4117740c create mode 100644 tests/resources/status_skipHash/.gitted/refs/heads/main create mode 100644 tests/resources/status_skipHash/new_file diff --git a/tests/libgit2/status/worktree.c b/tests/libgit2/status/worktree.c index efbf597a723..bd3cdb9e7d3 100644 --- a/tests/libgit2/status/worktree.c +++ b/tests/libgit2/status/worktree.c @@ -1360,3 +1360,12 @@ void test_status_worktree__at_head_parent(void) git_tree_free(parent_tree); git_status_list_free(statuslist); } + +void test_status_worktree__skip_hash(void) +{ + git_repository *repo = cl_git_sandbox_init("status_skipHash"); + git_index *index; + + cl_git_pass(git_repository_index(&index, repo)); + cl_git_pass(git_index_read(index, true)); +} diff --git a/tests/resources/status_skipHash/.gitted/COMMIT_EDITMSG b/tests/resources/status_skipHash/.gitted/COMMIT_EDITMSG new file mode 100644 index 00000000000..ea450f959b9 --- /dev/null +++ b/tests/resources/status_skipHash/.gitted/COMMIT_EDITMSG @@ -0,0 +1 @@ +New file diff --git a/tests/resources/status_skipHash/.gitted/HEAD b/tests/resources/status_skipHash/.gitted/HEAD new file mode 100644 index 00000000000..b870d82622c --- /dev/null +++ b/tests/resources/status_skipHash/.gitted/HEAD @@ -0,0 +1 @@ +ref: refs/heads/main diff --git a/tests/resources/status_skipHash/.gitted/MERGE_RR b/tests/resources/status_skipHash/.gitted/MERGE_RR new file mode 100644 index 00000000000..e69de29bb2d diff --git a/tests/resources/status_skipHash/.gitted/config b/tests/resources/status_skipHash/.gitted/config new file mode 100644 index 00000000000..16aebb686c2 --- /dev/null +++ b/tests/resources/status_skipHash/.gitted/config @@ -0,0 +1,9 @@ +[core] + repositoryformatversion = 0 + filemode = false + bare = false + logallrefupdates = true + symlinks = false + ignorecase = true +[index] + skipHash = true diff --git a/tests/resources/status_skipHash/.gitted/description b/tests/resources/status_skipHash/.gitted/description new file mode 100644 index 00000000000..498b267a8c7 --- /dev/null +++ b/tests/resources/status_skipHash/.gitted/description @@ -0,0 +1 @@ +Unnamed repository; edit this file 'description' to name the repository. diff --git a/tests/resources/status_skipHash/.gitted/hooks/applypatch-msg.sample b/tests/resources/status_skipHash/.gitted/hooks/applypatch-msg.sample new file mode 100644 index 00000000000..a5d7b84a673 --- /dev/null +++ b/tests/resources/status_skipHash/.gitted/hooks/applypatch-msg.sample @@ -0,0 +1,15 @@ +#!/bin/sh +# +# An example hook script to check the commit log message taken by +# applypatch from an e-mail message. +# +# The hook should exit with non-zero status after issuing an +# appropriate message if it wants to stop the commit. The hook is +# allowed to edit the commit message file. +# +# To enable this hook, rename this file to "applypatch-msg". + +. git-sh-setup +commitmsg="$(git rev-parse --git-path hooks/commit-msg)" +test -x "$commitmsg" && exec "$commitmsg" ${1+"$@"} +: diff --git a/tests/resources/status_skipHash/.gitted/hooks/commit-msg.sample b/tests/resources/status_skipHash/.gitted/hooks/commit-msg.sample new file mode 100644 index 00000000000..b58d1184a9d --- /dev/null +++ b/tests/resources/status_skipHash/.gitted/hooks/commit-msg.sample @@ -0,0 +1,24 @@ +#!/bin/sh +# +# An example hook script to check the commit log message. +# Called by "git commit" with one argument, the name of the file +# that has the commit message. The hook should exit with non-zero +# status after issuing an appropriate message if it wants to stop the +# commit. The hook is allowed to edit the commit message file. +# +# To enable this hook, rename this file to "commit-msg". + +# Uncomment the below to add a Signed-off-by line to the message. +# Doing this in a hook is a bad idea in general, but the prepare-commit-msg +# hook is more suited to it. +# +# SOB=$(git var GIT_AUTHOR_IDENT | sed -n 's/^\(.*>\).*$/Signed-off-by: \1/p') +# grep -qs "^$SOB" "$1" || echo "$SOB" >> "$1" + +# This example catches duplicate Signed-off-by lines. + +test "" = "$(grep '^Signed-off-by: ' "$1" | + sort | uniq -c | sed -e '/^[ ]*1[ ]/d')" || { + echo >&2 Duplicate Signed-off-by lines. + exit 1 +} diff --git a/tests/resources/status_skipHash/.gitted/hooks/fsmonitor-watchman.sample b/tests/resources/status_skipHash/.gitted/hooks/fsmonitor-watchman.sample new file mode 100644 index 00000000000..23e856f5dee --- /dev/null +++ b/tests/resources/status_skipHash/.gitted/hooks/fsmonitor-watchman.sample @@ -0,0 +1,174 @@ +#!/usr/bin/perl + +use strict; +use warnings; +use IPC::Open2; + +# An example hook script to integrate Watchman +# (https://facebook.github.io/watchman/) with git to speed up detecting +# new and modified files. +# +# The hook is passed a version (currently 2) and last update token +# formatted as a string and outputs to stdout a new update token and +# all files that have been modified since the update token. Paths must +# be relative to the root of the working tree and separated by a single NUL. +# +# To enable this hook, rename this file to "query-watchman" and set +# 'git config core.fsmonitor .git/hooks/query-watchman' +# +my ($version, $last_update_token) = @ARGV; + +# Uncomment for debugging +# print STDERR "$0 $version $last_update_token\n"; + +# Check the hook interface version +if ($version ne 2) { + die "Unsupported query-fsmonitor hook version '$version'.\n" . + "Falling back to scanning...\n"; +} + +my $git_work_tree = get_working_dir(); + +my $retry = 1; + +my $json_pkg; +eval { + require JSON::XS; + $json_pkg = "JSON::XS"; + 1; +} or do { + require JSON::PP; + $json_pkg = "JSON::PP"; +}; + +launch_watchman(); + +sub launch_watchman { + my $o = watchman_query(); + if (is_work_tree_watched($o)) { + output_result($o->{clock}, @{$o->{files}}); + } +} + +sub output_result { + my ($clockid, @files) = @_; + + # Uncomment for debugging watchman output + # open (my $fh, ">", ".git/watchman-output.out"); + # binmode $fh, ":utf8"; + # print $fh "$clockid\n@files\n"; + # close $fh; + + binmode STDOUT, ":utf8"; + print $clockid; + print "\0"; + local $, = "\0"; + print @files; +} + +sub watchman_clock { + my $response = qx/watchman clock "$git_work_tree"/; + die "Failed to get clock id on '$git_work_tree'.\n" . + "Falling back to scanning...\n" if $? != 0; + + return $json_pkg->new->utf8->decode($response); +} + +sub watchman_query { + my $pid = open2(\*CHLD_OUT, \*CHLD_IN, 'watchman -j --no-pretty') + or die "open2() failed: $!\n" . + "Falling back to scanning...\n"; + + # In the query expression below we're asking for names of files that + # changed since $last_update_token but not from the .git folder. + # + # To accomplish this, we're using the "since" generator to use the + # recency index to select candidate nodes and "fields" to limit the + # output to file names only. Then we're using the "expression" term to + # further constrain the results. + my $last_update_line = ""; + if (substr($last_update_token, 0, 1) eq "c") { + $last_update_token = "\"$last_update_token\""; + $last_update_line = qq[\n"since": $last_update_token,]; + } + my $query = <<" END"; + ["query", "$git_work_tree", {$last_update_line + "fields": ["name"], + "expression": ["not", ["dirname", ".git"]] + }] + END + + # Uncomment for debugging the watchman query + # open (my $fh, ">", ".git/watchman-query.json"); + # print $fh $query; + # close $fh; + + print CHLD_IN $query; + close CHLD_IN; + my $response = do {local $/; }; + + # Uncomment for debugging the watch response + # open ($fh, ">", ".git/watchman-response.json"); + # print $fh $response; + # close $fh; + + die "Watchman: command returned no output.\n" . + "Falling back to scanning...\n" if $response eq ""; + die "Watchman: command returned invalid output: $response\n" . + "Falling back to scanning...\n" unless $response =~ /^\{/; + + return $json_pkg->new->utf8->decode($response); +} + +sub is_work_tree_watched { + my ($output) = @_; + my $error = $output->{error}; + if ($retry > 0 and $error and $error =~ m/unable to resolve root .* directory (.*) is not watched/) { + $retry--; + my $response = qx/watchman watch "$git_work_tree"/; + die "Failed to make watchman watch '$git_work_tree'.\n" . + "Falling back to scanning...\n" if $? != 0; + $output = $json_pkg->new->utf8->decode($response); + $error = $output->{error}; + die "Watchman: $error.\n" . + "Falling back to scanning...\n" if $error; + + # Uncomment for debugging watchman output + # open (my $fh, ">", ".git/watchman-output.out"); + # close $fh; + + # Watchman will always return all files on the first query so + # return the fast "everything is dirty" flag to git and do the + # Watchman query just to get it over with now so we won't pay + # the cost in git to look up each individual file. + my $o = watchman_clock(); + $error = $output->{error}; + + die "Watchman: $error.\n" . + "Falling back to scanning...\n" if $error; + + output_result($o->{clock}, ("/")); + $last_update_token = $o->{clock}; + + eval { launch_watchman() }; + return 0; + } + + die "Watchman: $error.\n" . + "Falling back to scanning...\n" if $error; + + return 1; +} + +sub get_working_dir { + my $working_dir; + if ($^O =~ 'msys' || $^O =~ 'cygwin') { + $working_dir = Win32::GetCwd(); + $working_dir =~ tr/\\/\//; + } else { + require Cwd; + $working_dir = Cwd::cwd(); + } + + return $working_dir; +} diff --git a/tests/resources/status_skipHash/.gitted/hooks/post-update.sample b/tests/resources/status_skipHash/.gitted/hooks/post-update.sample new file mode 100644 index 00000000000..ec17ec1939b --- /dev/null +++ b/tests/resources/status_skipHash/.gitted/hooks/post-update.sample @@ -0,0 +1,8 @@ +#!/bin/sh +# +# An example hook script to prepare a packed repository for use over +# dumb transports. +# +# To enable this hook, rename this file to "post-update". + +exec git update-server-info diff --git a/tests/resources/status_skipHash/.gitted/hooks/pre-applypatch.sample b/tests/resources/status_skipHash/.gitted/hooks/pre-applypatch.sample new file mode 100644 index 00000000000..4142082bcb9 --- /dev/null +++ b/tests/resources/status_skipHash/.gitted/hooks/pre-applypatch.sample @@ -0,0 +1,14 @@ +#!/bin/sh +# +# An example hook script to verify what is about to be committed +# by applypatch from an e-mail message. +# +# The hook should exit with non-zero status after issuing an +# appropriate message if it wants to stop the commit. +# +# To enable this hook, rename this file to "pre-applypatch". + +. git-sh-setup +precommit="$(git rev-parse --git-path hooks/pre-commit)" +test -x "$precommit" && exec "$precommit" ${1+"$@"} +: diff --git a/tests/resources/status_skipHash/.gitted/hooks/pre-commit.sample b/tests/resources/status_skipHash/.gitted/hooks/pre-commit.sample new file mode 100644 index 00000000000..e144712c85c --- /dev/null +++ b/tests/resources/status_skipHash/.gitted/hooks/pre-commit.sample @@ -0,0 +1,49 @@ +#!/bin/sh +# +# An example hook script to verify what is about to be committed. +# Called by "git commit" with no arguments. The hook should +# exit with non-zero status after issuing an appropriate message if +# it wants to stop the commit. +# +# To enable this hook, rename this file to "pre-commit". + +if git rev-parse --verify HEAD >/dev/null 2>&1 +then + against=HEAD +else + # Initial commit: diff against an empty tree object + against=$(git hash-object -t tree /dev/null) +fi + +# If you want to allow non-ASCII filenames set this variable to true. +allownonascii=$(git config --type=bool hooks.allownonascii) + +# Redirect output to stderr. +exec 1>&2 + +# Cross platform projects tend to avoid non-ASCII filenames; prevent +# them from being added to the repository. We exploit the fact that the +# printable range starts at the space character and ends with tilde. +if [ "$allownonascii" != "true" ] && + # Note that the use of brackets around a tr range is ok here, (it's + # even required, for portability to Solaris 10's /usr/bin/tr), since + # the square bracket bytes happen to fall in the designated range. + test $(git diff --cached --name-only --diff-filter=A -z $against | + LC_ALL=C tr -d '[ -~]\0' | wc -c) != 0 +then + cat <<\EOF +Error: Attempt to add a non-ASCII file name. + +This can cause problems if you want to work with people on other platforms. + +To be portable it is advisable to rename the file. + +If you know what you are doing you can disable this check using: + + git config hooks.allownonascii true +EOF + exit 1 +fi + +# If there are whitespace errors, print the offending file names and fail. +exec git diff-index --check --cached $against -- diff --git a/tests/resources/status_skipHash/.gitted/hooks/pre-merge-commit.sample b/tests/resources/status_skipHash/.gitted/hooks/pre-merge-commit.sample new file mode 100644 index 00000000000..399eab1924e --- /dev/null +++ b/tests/resources/status_skipHash/.gitted/hooks/pre-merge-commit.sample @@ -0,0 +1,13 @@ +#!/bin/sh +# +# An example hook script to verify what is about to be committed. +# Called by "git merge" with no arguments. The hook should +# exit with non-zero status after issuing an appropriate message to +# stderr if it wants to stop the merge commit. +# +# To enable this hook, rename this file to "pre-merge-commit". + +. git-sh-setup +test -x "$GIT_DIR/hooks/pre-commit" && + exec "$GIT_DIR/hooks/pre-commit" +: diff --git a/tests/resources/status_skipHash/.gitted/hooks/pre-push.sample b/tests/resources/status_skipHash/.gitted/hooks/pre-push.sample new file mode 100644 index 00000000000..4ce688d32b7 --- /dev/null +++ b/tests/resources/status_skipHash/.gitted/hooks/pre-push.sample @@ -0,0 +1,53 @@ +#!/bin/sh + +# An example hook script to verify what is about to be pushed. Called by "git +# push" after it has checked the remote status, but before anything has been +# pushed. If this script exits with a non-zero status nothing will be pushed. +# +# This hook is called with the following parameters: +# +# $1 -- Name of the remote to which the push is being done +# $2 -- URL to which the push is being done +# +# If pushing without using a named remote those arguments will be equal. +# +# Information about the commits which are being pushed is supplied as lines to +# the standard input in the form: +# +# +# +# This sample shows how to prevent push of commits where the log message starts +# with "WIP" (work in progress). + +remote="$1" +url="$2" + +zero=$(git hash-object --stdin &2 "Found WIP commit in $local_ref, not pushing" + exit 1 + fi + fi +done + +exit 0 diff --git a/tests/resources/status_skipHash/.gitted/hooks/pre-rebase.sample b/tests/resources/status_skipHash/.gitted/hooks/pre-rebase.sample new file mode 100644 index 00000000000..6cbef5c370d --- /dev/null +++ b/tests/resources/status_skipHash/.gitted/hooks/pre-rebase.sample @@ -0,0 +1,169 @@ +#!/bin/sh +# +# Copyright (c) 2006, 2008 Junio C Hamano +# +# The "pre-rebase" hook is run just before "git rebase" starts doing +# its job, and can prevent the command from running by exiting with +# non-zero status. +# +# The hook is called with the following parameters: +# +# $1 -- the upstream the series was forked from. +# $2 -- the branch being rebased (or empty when rebasing the current branch). +# +# This sample shows how to prevent topic branches that are already +# merged to 'next' branch from getting rebased, because allowing it +# would result in rebasing already published history. + +publish=next +basebranch="$1" +if test "$#" = 2 +then + topic="refs/heads/$2" +else + topic=`git symbolic-ref HEAD` || + exit 0 ;# we do not interrupt rebasing detached HEAD +fi + +case "$topic" in +refs/heads/??/*) + ;; +*) + exit 0 ;# we do not interrupt others. + ;; +esac + +# Now we are dealing with a topic branch being rebased +# on top of master. Is it OK to rebase it? + +# Does the topic really exist? +git show-ref -q "$topic" || { + echo >&2 "No such branch $topic" + exit 1 +} + +# Is topic fully merged to master? +not_in_master=`git rev-list --pretty=oneline ^master "$topic"` +if test -z "$not_in_master" +then + echo >&2 "$topic is fully merged to master; better remove it." + exit 1 ;# we could allow it, but there is no point. +fi + +# Is topic ever merged to next? If so you should not be rebasing it. +only_next_1=`git rev-list ^master "^$topic" ${publish} | sort` +only_next_2=`git rev-list ^master ${publish} | sort` +if test "$only_next_1" = "$only_next_2" +then + not_in_topic=`git rev-list "^$topic" master` + if test -z "$not_in_topic" + then + echo >&2 "$topic is already up to date with master" + exit 1 ;# we could allow it, but there is no point. + else + exit 0 + fi +else + not_in_next=`git rev-list --pretty=oneline ^${publish} "$topic"` + /usr/bin/perl -e ' + my $topic = $ARGV[0]; + my $msg = "* $topic has commits already merged to public branch:\n"; + my (%not_in_next) = map { + /^([0-9a-f]+) /; + ($1 => 1); + } split(/\n/, $ARGV[1]); + for my $elem (map { + /^([0-9a-f]+) (.*)$/; + [$1 => $2]; + } split(/\n/, $ARGV[2])) { + if (!exists $not_in_next{$elem->[0]}) { + if ($msg) { + print STDERR $msg; + undef $msg; + } + print STDERR " $elem->[1]\n"; + } + } + ' "$topic" "$not_in_next" "$not_in_master" + exit 1 +fi + +<<\DOC_END + +This sample hook safeguards topic branches that have been +published from being rewound. + +The workflow assumed here is: + + * Once a topic branch forks from "master", "master" is never + merged into it again (either directly or indirectly). + + * Once a topic branch is fully cooked and merged into "master", + it is deleted. If you need to build on top of it to correct + earlier mistakes, a new topic branch is created by forking at + the tip of the "master". This is not strictly necessary, but + it makes it easier to keep your history simple. + + * Whenever you need to test or publish your changes to topic + branches, merge them into "next" branch. + +The script, being an example, hardcodes the publish branch name +to be "next", but it is trivial to make it configurable via +$GIT_DIR/config mechanism. + +With this workflow, you would want to know: + +(1) ... if a topic branch has ever been merged to "next". Young + topic branches can have stupid mistakes you would rather + clean up before publishing, and things that have not been + merged into other branches can be easily rebased without + affecting other people. But once it is published, you would + not want to rewind it. + +(2) ... if a topic branch has been fully merged to "master". + Then you can delete it. More importantly, you should not + build on top of it -- other people may already want to + change things related to the topic as patches against your + "master", so if you need further changes, it is better to + fork the topic (perhaps with the same name) afresh from the + tip of "master". + +Let's look at this example: + + o---o---o---o---o---o---o---o---o---o "next" + / / / / + / a---a---b A / / + / / / / + / / c---c---c---c B / + / / / \ / + / / / b---b C \ / + / / / / \ / + ---o---o---o---o---o---o---o---o---o---o---o "master" + + +A, B and C are topic branches. + + * A has one fix since it was merged up to "next". + + * B has finished. It has been fully merged up to "master" and "next", + and is ready to be deleted. + + * C has not merged to "next" at all. + +We would want to allow C to be rebased, refuse A, and encourage +B to be deleted. + +To compute (1): + + git rev-list ^master ^topic next + git rev-list ^master next + + if these match, topic has not merged in next at all. + +To compute (2): + + git rev-list master..topic + + if this is empty, it is fully merged to "master". + +DOC_END diff --git a/tests/resources/status_skipHash/.gitted/hooks/pre-receive.sample b/tests/resources/status_skipHash/.gitted/hooks/pre-receive.sample new file mode 100644 index 00000000000..a1fd29ec148 --- /dev/null +++ b/tests/resources/status_skipHash/.gitted/hooks/pre-receive.sample @@ -0,0 +1,24 @@ +#!/bin/sh +# +# An example hook script to make use of push options. +# The example simply echoes all push options that start with 'echoback=' +# and rejects all pushes when the "reject" push option is used. +# +# To enable this hook, rename this file to "pre-receive". + +if test -n "$GIT_PUSH_OPTION_COUNT" +then + i=0 + while test "$i" -lt "$GIT_PUSH_OPTION_COUNT" + do + eval "value=\$GIT_PUSH_OPTION_$i" + case "$value" in + echoback=*) + echo "echo from the pre-receive-hook: ${value#*=}" >&2 + ;; + reject) + exit 1 + esac + i=$((i + 1)) + done +fi diff --git a/tests/resources/status_skipHash/.gitted/hooks/prepare-commit-msg.sample b/tests/resources/status_skipHash/.gitted/hooks/prepare-commit-msg.sample new file mode 100644 index 00000000000..10fa14c5ab0 --- /dev/null +++ b/tests/resources/status_skipHash/.gitted/hooks/prepare-commit-msg.sample @@ -0,0 +1,42 @@ +#!/bin/sh +# +# An example hook script to prepare the commit log message. +# Called by "git commit" with the name of the file that has the +# commit message, followed by the description of the commit +# message's source. The hook's purpose is to edit the commit +# message file. If the hook fails with a non-zero status, +# the commit is aborted. +# +# To enable this hook, rename this file to "prepare-commit-msg". + +# This hook includes three examples. The first one removes the +# "# Please enter the commit message..." help message. +# +# The second includes the output of "git diff --name-status -r" +# into the message, just before the "git status" output. It is +# commented because it doesn't cope with --amend or with squashed +# commits. +# +# The third example adds a Signed-off-by line to the message, that can +# still be edited. This is rarely a good idea. + +COMMIT_MSG_FILE=$1 +COMMIT_SOURCE=$2 +SHA1=$3 + +/usr/bin/perl -i.bak -ne 'print unless(m/^. Please enter the commit message/..m/^#$/)' "$COMMIT_MSG_FILE" + +# case "$COMMIT_SOURCE,$SHA1" in +# ,|template,) +# /usr/bin/perl -i.bak -pe ' +# print "\n" . `git diff --cached --name-status -r` +# if /^#/ && $first++ == 0' "$COMMIT_MSG_FILE" ;; +# *) ;; +# esac + +# SOB=$(git var GIT_COMMITTER_IDENT | sed -n 's/^\(.*>\).*$/Signed-off-by: \1/p') +# git interpret-trailers --in-place --trailer "$SOB" "$COMMIT_MSG_FILE" +# if test -z "$COMMIT_SOURCE" +# then +# /usr/bin/perl -i.bak -pe 'print "\n" if !$first_line++' "$COMMIT_MSG_FILE" +# fi diff --git a/tests/resources/status_skipHash/.gitted/hooks/push-to-checkout.sample b/tests/resources/status_skipHash/.gitted/hooks/push-to-checkout.sample new file mode 100644 index 00000000000..af5a0c0018b --- /dev/null +++ b/tests/resources/status_skipHash/.gitted/hooks/push-to-checkout.sample @@ -0,0 +1,78 @@ +#!/bin/sh + +# An example hook script to update a checked-out tree on a git push. +# +# This hook is invoked by git-receive-pack(1) when it reacts to git +# push and updates reference(s) in its repository, and when the push +# tries to update the branch that is currently checked out and the +# receive.denyCurrentBranch configuration variable is set to +# updateInstead. +# +# By default, such a push is refused if the working tree and the index +# of the remote repository has any difference from the currently +# checked out commit; when both the working tree and the index match +# the current commit, they are updated to match the newly pushed tip +# of the branch. This hook is to be used to override the default +# behaviour; however the code below reimplements the default behaviour +# as a starting point for convenient modification. +# +# The hook receives the commit with which the tip of the current +# branch is going to be updated: +commit=$1 + +# It can exit with a non-zero status to refuse the push (when it does +# so, it must not modify the index or the working tree). +die () { + echo >&2 "$*" + exit 1 +} + +# Or it can make any necessary changes to the working tree and to the +# index to bring them to the desired state when the tip of the current +# branch is updated to the new commit, and exit with a zero status. +# +# For example, the hook can simply run git read-tree -u -m HEAD "$1" +# in order to emulate git fetch that is run in the reverse direction +# with git push, as the two-tree form of git read-tree -u -m is +# essentially the same as git switch or git checkout that switches +# branches while keeping the local changes in the working tree that do +# not interfere with the difference between the branches. + +# The below is a more-or-less exact translation to shell of the C code +# for the default behaviour for git's push-to-checkout hook defined in +# the push_to_deploy() function in builtin/receive-pack.c. +# +# Note that the hook will be executed from the repository directory, +# not from the working tree, so if you want to perform operations on +# the working tree, you will have to adapt your code accordingly, e.g. +# by adding "cd .." or using relative paths. + +if ! git update-index -q --ignore-submodules --refresh +then + die "Up-to-date check failed" +fi + +if ! git diff-files --quiet --ignore-submodules -- +then + die "Working directory has unstaged changes" +fi + +# This is a rough translation of: +# +# head_has_history() ? "HEAD" : EMPTY_TREE_SHA1_HEX +if git cat-file -e HEAD 2>/dev/null +then + head=HEAD +else + head=$(git hash-object -t tree --stdin &2 + exit 1 +} + +unset GIT_DIR GIT_WORK_TREE +cd "$worktree" && + +if grep -q "^diff --git " "$1" +then + validate_patch "$1" +else + validate_cover_letter "$1" +fi && + +if test "$GIT_SENDEMAIL_FILE_COUNTER" = "$GIT_SENDEMAIL_FILE_TOTAL" +then + git config --unset-all sendemail.validateWorktree && + trap 'git worktree remove -ff "$worktree"' EXIT && + validate_series +fi diff --git a/tests/resources/status_skipHash/.gitted/hooks/update.sample b/tests/resources/status_skipHash/.gitted/hooks/update.sample new file mode 100644 index 00000000000..c4d426bc6ee --- /dev/null +++ b/tests/resources/status_skipHash/.gitted/hooks/update.sample @@ -0,0 +1,128 @@ +#!/bin/sh +# +# An example hook script to block unannotated tags from entering. +# Called by "git receive-pack" with arguments: refname sha1-old sha1-new +# +# To enable this hook, rename this file to "update". +# +# Config +# ------ +# hooks.allowunannotated +# This boolean sets whether unannotated tags will be allowed into the +# repository. By default they won't be. +# hooks.allowdeletetag +# This boolean sets whether deleting tags will be allowed in the +# repository. By default they won't be. +# hooks.allowmodifytag +# This boolean sets whether a tag may be modified after creation. By default +# it won't be. +# hooks.allowdeletebranch +# This boolean sets whether deleting branches will be allowed in the +# repository. By default they won't be. +# hooks.denycreatebranch +# This boolean sets whether remotely creating branches will be denied +# in the repository. By default this is allowed. +# + +# --- Command line +refname="$1" +oldrev="$2" +newrev="$3" + +# --- Safety check +if [ -z "$GIT_DIR" ]; then + echo "Don't run this script from the command line." >&2 + echo " (if you want, you could supply GIT_DIR then run" >&2 + echo " $0 )" >&2 + exit 1 +fi + +if [ -z "$refname" -o -z "$oldrev" -o -z "$newrev" ]; then + echo "usage: $0 " >&2 + exit 1 +fi + +# --- Config +allowunannotated=$(git config --type=bool hooks.allowunannotated) +allowdeletebranch=$(git config --type=bool hooks.allowdeletebranch) +denycreatebranch=$(git config --type=bool hooks.denycreatebranch) +allowdeletetag=$(git config --type=bool hooks.allowdeletetag) +allowmodifytag=$(git config --type=bool hooks.allowmodifytag) + +# check for no description +projectdesc=$(sed -e '1q' "$GIT_DIR/description") +case "$projectdesc" in +"Unnamed repository"* | "") + echo "*** Project description file hasn't been set" >&2 + exit 1 + ;; +esac + +# --- Check types +# if $newrev is 0000...0000, it's a commit to delete a ref. +zero=$(git hash-object --stdin &2 + echo "*** Use 'git tag [ -a | -s ]' for tags you want to propagate." >&2 + exit 1 + fi + ;; + refs/tags/*,delete) + # delete tag + if [ "$allowdeletetag" != "true" ]; then + echo "*** Deleting a tag is not allowed in this repository" >&2 + exit 1 + fi + ;; + refs/tags/*,tag) + # annotated tag + if [ "$allowmodifytag" != "true" ] && git rev-parse $refname > /dev/null 2>&1 + then + echo "*** Tag '$refname' already exists." >&2 + echo "*** Modifying a tag is not allowed in this repository." >&2 + exit 1 + fi + ;; + refs/heads/*,commit) + # branch + if [ "$oldrev" = "$zero" -a "$denycreatebranch" = "true" ]; then + echo "*** Creating a branch is not allowed in this repository" >&2 + exit 1 + fi + ;; + refs/heads/*,delete) + # delete branch + if [ "$allowdeletebranch" != "true" ]; then + echo "*** Deleting a branch is not allowed in this repository" >&2 + exit 1 + fi + ;; + refs/remotes/*,commit) + # tracking branch + ;; + refs/remotes/*,delete) + # delete tracking branch + if [ "$allowdeletebranch" != "true" ]; then + echo "*** Deleting a tracking branch is not allowed in this repository" >&2 + exit 1 + fi + ;; + *) + # Anything else (is there anything else?) + echo "*** Update hook: unknown type of update to ref $refname of type $newrev_type" >&2 + exit 1 + ;; +esac + +# --- Finished +exit 0 diff --git a/tests/resources/status_skipHash/.gitted/index b/tests/resources/status_skipHash/.gitted/index new file mode 100644 index 0000000000000000000000000000000000000000..1963fe0d3d48be4a53099966cbd14d342421a38a GIT binary patch literal 137 zcmZ?q402{*U|<4b#?Ef%38=h9^9eq%+;`#$5!{AH+ D>}4ak literal 0 HcmV?d00001 diff --git a/tests/resources/status_skipHash/.gitted/info/exclude b/tests/resources/status_skipHash/.gitted/info/exclude new file mode 100644 index 00000000000..a5196d1be8f --- /dev/null +++ b/tests/resources/status_skipHash/.gitted/info/exclude @@ -0,0 +1,6 @@ +# git ls-files --others --exclude-from=.git/info/exclude +# Lines that start with '#' are comments. +# For a project mostly in C, the following would be a good set of +# exclude patterns (uncomment them if you want to use them): +# *.[oa] +# *~ diff --git a/tests/resources/status_skipHash/.gitted/logs/HEAD b/tests/resources/status_skipHash/.gitted/logs/HEAD new file mode 100644 index 00000000000..35e1a747dbe --- /dev/null +++ b/tests/resources/status_skipHash/.gitted/logs/HEAD @@ -0,0 +1 @@ +0000000000000000000000000000000000000000 34f4c90b237fcb4c677772a6093f3cba239c41a5 Parnic 1708097798 -0600 commit (initial): New file diff --git a/tests/resources/status_skipHash/.gitted/logs/refs/heads/main b/tests/resources/status_skipHash/.gitted/logs/refs/heads/main new file mode 100644 index 00000000000..35e1a747dbe --- /dev/null +++ b/tests/resources/status_skipHash/.gitted/logs/refs/heads/main @@ -0,0 +1 @@ +0000000000000000000000000000000000000000 34f4c90b237fcb4c677772a6093f3cba239c41a5 Parnic 1708097798 -0600 commit (initial): New file diff --git a/tests/resources/status_skipHash/.gitted/objects/34/f4c90b237fcb4c677772a6093f3cba239c41a5 b/tests/resources/status_skipHash/.gitted/objects/34/f4c90b237fcb4c677772a6093f3cba239c41a5 new file mode 100644 index 0000000000000000000000000000000000000000..0513158cb21d4d3d77b30a4b5d80b8a70ec19815 GIT binary patch literal 510 zcmVF?TCrKxLpRo64Xg@&*}LnPe%?Rrx4dnBKoKJasTivY{EB3Rzz6-<8uosDLv3>U+IYv{No1t@=50=A(I9*4rMPHr0CYysM zBqAvR?045{MMp=l^}1vOV!>@84W3Zloph=PFU#%2^N9@_QUxS887mGu{rKo5TeSnj>BNUy684J0e*G-`Bg-LHWExDb$c2APdZYecO%TXM=DmWF&l$rj$z8I!|NtQK$ z+kUaG)XSopSp0lgbbWZ<38G_;#tZjHWn;(g95h8(yI8roj(1ljVIGZBTrKl+$Rq%* zhUPmbY*%sLAD^``KE}$-?}<0b^NZ!S+I~d*jSl@P>7v!jGxomMP7fxC`LsOlZvb-s zXlv)X@Io9LeI14AbqaZON2ag!!P66fPwBWlf|Fsj4~n1v@m*8e4Do Am;e9( literal 0 HcmV?d00001 diff --git a/tests/resources/status_skipHash/.gitted/objects/71/a21e67674e9717aa7380e5782ec5e070a8d7e0 b/tests/resources/status_skipHash/.gitted/objects/71/a21e67674e9717aa7380e5782ec5e070a8d7e0 new file mode 100644 index 0000000000000000000000000000000000000000..7c48fa4f43b779b3bbbc8a8c39fa596877c1e24f GIT binary patch literal 53 zcmV-50LuS(0V^p=O;s>9V=y!@Ff%bx$V)AcPs_|nWw?IuW9n0>+xxGVF(z$a+Mw$w LUcv(aTUZe49NQLZ literal 0 HcmV?d00001 diff --git a/tests/resources/status_skipHash/.gitted/objects/d7/c1f165e51adbbfd7760162b7a5802d4117740c b/tests/resources/status_skipHash/.gitted/objects/d7/c1f165e51adbbfd7760162b7a5802d4117740c new file mode 100644 index 0000000000000000000000000000000000000000..c685321ce69cedebf8744674d239c0e493b89cbb GIT binary patch literal 26 icmb Date: Fri, 16 Feb 2024 09:40:29 -0600 Subject: [PATCH 485/608] Remove unnecessary files --- .../.gitted/hooks/applypatch-msg.sample | 15 -- .../.gitted/hooks/commit-msg.sample | 24 --- .../.gitted/hooks/fsmonitor-watchman.sample | 174 ------------------ .../.gitted/hooks/post-update.sample | 8 - .../.gitted/hooks/pre-applypatch.sample | 14 -- .../.gitted/hooks/pre-commit.sample | 49 ----- .../.gitted/hooks/pre-merge-commit.sample | 13 -- .../.gitted/hooks/pre-push.sample | 53 ------ .../.gitted/hooks/pre-rebase.sample | 169 ----------------- .../.gitted/hooks/pre-receive.sample | 24 --- .../.gitted/hooks/prepare-commit-msg.sample | 42 ----- .../.gitted/hooks/push-to-checkout.sample | 78 -------- .../.gitted/hooks/sendemail-validate.sample | 77 -------- .../.gitted/hooks/update.sample | 128 ------------- 14 files changed, 868 deletions(-) delete mode 100644 tests/resources/status_skipHash/.gitted/hooks/applypatch-msg.sample delete mode 100644 tests/resources/status_skipHash/.gitted/hooks/commit-msg.sample delete mode 100644 tests/resources/status_skipHash/.gitted/hooks/fsmonitor-watchman.sample delete mode 100644 tests/resources/status_skipHash/.gitted/hooks/post-update.sample delete mode 100644 tests/resources/status_skipHash/.gitted/hooks/pre-applypatch.sample delete mode 100644 tests/resources/status_skipHash/.gitted/hooks/pre-commit.sample delete mode 100644 tests/resources/status_skipHash/.gitted/hooks/pre-merge-commit.sample delete mode 100644 tests/resources/status_skipHash/.gitted/hooks/pre-push.sample delete mode 100644 tests/resources/status_skipHash/.gitted/hooks/pre-rebase.sample delete mode 100644 tests/resources/status_skipHash/.gitted/hooks/pre-receive.sample delete mode 100644 tests/resources/status_skipHash/.gitted/hooks/prepare-commit-msg.sample delete mode 100644 tests/resources/status_skipHash/.gitted/hooks/push-to-checkout.sample delete mode 100644 tests/resources/status_skipHash/.gitted/hooks/sendemail-validate.sample delete mode 100644 tests/resources/status_skipHash/.gitted/hooks/update.sample diff --git a/tests/resources/status_skipHash/.gitted/hooks/applypatch-msg.sample b/tests/resources/status_skipHash/.gitted/hooks/applypatch-msg.sample deleted file mode 100644 index a5d7b84a673..00000000000 --- a/tests/resources/status_skipHash/.gitted/hooks/applypatch-msg.sample +++ /dev/null @@ -1,15 +0,0 @@ -#!/bin/sh -# -# An example hook script to check the commit log message taken by -# applypatch from an e-mail message. -# -# The hook should exit with non-zero status after issuing an -# appropriate message if it wants to stop the commit. The hook is -# allowed to edit the commit message file. -# -# To enable this hook, rename this file to "applypatch-msg". - -. git-sh-setup -commitmsg="$(git rev-parse --git-path hooks/commit-msg)" -test -x "$commitmsg" && exec "$commitmsg" ${1+"$@"} -: diff --git a/tests/resources/status_skipHash/.gitted/hooks/commit-msg.sample b/tests/resources/status_skipHash/.gitted/hooks/commit-msg.sample deleted file mode 100644 index b58d1184a9d..00000000000 --- a/tests/resources/status_skipHash/.gitted/hooks/commit-msg.sample +++ /dev/null @@ -1,24 +0,0 @@ -#!/bin/sh -# -# An example hook script to check the commit log message. -# Called by "git commit" with one argument, the name of the file -# that has the commit message. The hook should exit with non-zero -# status after issuing an appropriate message if it wants to stop the -# commit. The hook is allowed to edit the commit message file. -# -# To enable this hook, rename this file to "commit-msg". - -# Uncomment the below to add a Signed-off-by line to the message. -# Doing this in a hook is a bad idea in general, but the prepare-commit-msg -# hook is more suited to it. -# -# SOB=$(git var GIT_AUTHOR_IDENT | sed -n 's/^\(.*>\).*$/Signed-off-by: \1/p') -# grep -qs "^$SOB" "$1" || echo "$SOB" >> "$1" - -# This example catches duplicate Signed-off-by lines. - -test "" = "$(grep '^Signed-off-by: ' "$1" | - sort | uniq -c | sed -e '/^[ ]*1[ ]/d')" || { - echo >&2 Duplicate Signed-off-by lines. - exit 1 -} diff --git a/tests/resources/status_skipHash/.gitted/hooks/fsmonitor-watchman.sample b/tests/resources/status_skipHash/.gitted/hooks/fsmonitor-watchman.sample deleted file mode 100644 index 23e856f5dee..00000000000 --- a/tests/resources/status_skipHash/.gitted/hooks/fsmonitor-watchman.sample +++ /dev/null @@ -1,174 +0,0 @@ -#!/usr/bin/perl - -use strict; -use warnings; -use IPC::Open2; - -# An example hook script to integrate Watchman -# (https://facebook.github.io/watchman/) with git to speed up detecting -# new and modified files. -# -# The hook is passed a version (currently 2) and last update token -# formatted as a string and outputs to stdout a new update token and -# all files that have been modified since the update token. Paths must -# be relative to the root of the working tree and separated by a single NUL. -# -# To enable this hook, rename this file to "query-watchman" and set -# 'git config core.fsmonitor .git/hooks/query-watchman' -# -my ($version, $last_update_token) = @ARGV; - -# Uncomment for debugging -# print STDERR "$0 $version $last_update_token\n"; - -# Check the hook interface version -if ($version ne 2) { - die "Unsupported query-fsmonitor hook version '$version'.\n" . - "Falling back to scanning...\n"; -} - -my $git_work_tree = get_working_dir(); - -my $retry = 1; - -my $json_pkg; -eval { - require JSON::XS; - $json_pkg = "JSON::XS"; - 1; -} or do { - require JSON::PP; - $json_pkg = "JSON::PP"; -}; - -launch_watchman(); - -sub launch_watchman { - my $o = watchman_query(); - if (is_work_tree_watched($o)) { - output_result($o->{clock}, @{$o->{files}}); - } -} - -sub output_result { - my ($clockid, @files) = @_; - - # Uncomment for debugging watchman output - # open (my $fh, ">", ".git/watchman-output.out"); - # binmode $fh, ":utf8"; - # print $fh "$clockid\n@files\n"; - # close $fh; - - binmode STDOUT, ":utf8"; - print $clockid; - print "\0"; - local $, = "\0"; - print @files; -} - -sub watchman_clock { - my $response = qx/watchman clock "$git_work_tree"/; - die "Failed to get clock id on '$git_work_tree'.\n" . - "Falling back to scanning...\n" if $? != 0; - - return $json_pkg->new->utf8->decode($response); -} - -sub watchman_query { - my $pid = open2(\*CHLD_OUT, \*CHLD_IN, 'watchman -j --no-pretty') - or die "open2() failed: $!\n" . - "Falling back to scanning...\n"; - - # In the query expression below we're asking for names of files that - # changed since $last_update_token but not from the .git folder. - # - # To accomplish this, we're using the "since" generator to use the - # recency index to select candidate nodes and "fields" to limit the - # output to file names only. Then we're using the "expression" term to - # further constrain the results. - my $last_update_line = ""; - if (substr($last_update_token, 0, 1) eq "c") { - $last_update_token = "\"$last_update_token\""; - $last_update_line = qq[\n"since": $last_update_token,]; - } - my $query = <<" END"; - ["query", "$git_work_tree", {$last_update_line - "fields": ["name"], - "expression": ["not", ["dirname", ".git"]] - }] - END - - # Uncomment for debugging the watchman query - # open (my $fh, ">", ".git/watchman-query.json"); - # print $fh $query; - # close $fh; - - print CHLD_IN $query; - close CHLD_IN; - my $response = do {local $/; }; - - # Uncomment for debugging the watch response - # open ($fh, ">", ".git/watchman-response.json"); - # print $fh $response; - # close $fh; - - die "Watchman: command returned no output.\n" . - "Falling back to scanning...\n" if $response eq ""; - die "Watchman: command returned invalid output: $response\n" . - "Falling back to scanning...\n" unless $response =~ /^\{/; - - return $json_pkg->new->utf8->decode($response); -} - -sub is_work_tree_watched { - my ($output) = @_; - my $error = $output->{error}; - if ($retry > 0 and $error and $error =~ m/unable to resolve root .* directory (.*) is not watched/) { - $retry--; - my $response = qx/watchman watch "$git_work_tree"/; - die "Failed to make watchman watch '$git_work_tree'.\n" . - "Falling back to scanning...\n" if $? != 0; - $output = $json_pkg->new->utf8->decode($response); - $error = $output->{error}; - die "Watchman: $error.\n" . - "Falling back to scanning...\n" if $error; - - # Uncomment for debugging watchman output - # open (my $fh, ">", ".git/watchman-output.out"); - # close $fh; - - # Watchman will always return all files on the first query so - # return the fast "everything is dirty" flag to git and do the - # Watchman query just to get it over with now so we won't pay - # the cost in git to look up each individual file. - my $o = watchman_clock(); - $error = $output->{error}; - - die "Watchman: $error.\n" . - "Falling back to scanning...\n" if $error; - - output_result($o->{clock}, ("/")); - $last_update_token = $o->{clock}; - - eval { launch_watchman() }; - return 0; - } - - die "Watchman: $error.\n" . - "Falling back to scanning...\n" if $error; - - return 1; -} - -sub get_working_dir { - my $working_dir; - if ($^O =~ 'msys' || $^O =~ 'cygwin') { - $working_dir = Win32::GetCwd(); - $working_dir =~ tr/\\/\//; - } else { - require Cwd; - $working_dir = Cwd::cwd(); - } - - return $working_dir; -} diff --git a/tests/resources/status_skipHash/.gitted/hooks/post-update.sample b/tests/resources/status_skipHash/.gitted/hooks/post-update.sample deleted file mode 100644 index ec17ec1939b..00000000000 --- a/tests/resources/status_skipHash/.gitted/hooks/post-update.sample +++ /dev/null @@ -1,8 +0,0 @@ -#!/bin/sh -# -# An example hook script to prepare a packed repository for use over -# dumb transports. -# -# To enable this hook, rename this file to "post-update". - -exec git update-server-info diff --git a/tests/resources/status_skipHash/.gitted/hooks/pre-applypatch.sample b/tests/resources/status_skipHash/.gitted/hooks/pre-applypatch.sample deleted file mode 100644 index 4142082bcb9..00000000000 --- a/tests/resources/status_skipHash/.gitted/hooks/pre-applypatch.sample +++ /dev/null @@ -1,14 +0,0 @@ -#!/bin/sh -# -# An example hook script to verify what is about to be committed -# by applypatch from an e-mail message. -# -# The hook should exit with non-zero status after issuing an -# appropriate message if it wants to stop the commit. -# -# To enable this hook, rename this file to "pre-applypatch". - -. git-sh-setup -precommit="$(git rev-parse --git-path hooks/pre-commit)" -test -x "$precommit" && exec "$precommit" ${1+"$@"} -: diff --git a/tests/resources/status_skipHash/.gitted/hooks/pre-commit.sample b/tests/resources/status_skipHash/.gitted/hooks/pre-commit.sample deleted file mode 100644 index e144712c85c..00000000000 --- a/tests/resources/status_skipHash/.gitted/hooks/pre-commit.sample +++ /dev/null @@ -1,49 +0,0 @@ -#!/bin/sh -# -# An example hook script to verify what is about to be committed. -# Called by "git commit" with no arguments. The hook should -# exit with non-zero status after issuing an appropriate message if -# it wants to stop the commit. -# -# To enable this hook, rename this file to "pre-commit". - -if git rev-parse --verify HEAD >/dev/null 2>&1 -then - against=HEAD -else - # Initial commit: diff against an empty tree object - against=$(git hash-object -t tree /dev/null) -fi - -# If you want to allow non-ASCII filenames set this variable to true. -allownonascii=$(git config --type=bool hooks.allownonascii) - -# Redirect output to stderr. -exec 1>&2 - -# Cross platform projects tend to avoid non-ASCII filenames; prevent -# them from being added to the repository. We exploit the fact that the -# printable range starts at the space character and ends with tilde. -if [ "$allownonascii" != "true" ] && - # Note that the use of brackets around a tr range is ok here, (it's - # even required, for portability to Solaris 10's /usr/bin/tr), since - # the square bracket bytes happen to fall in the designated range. - test $(git diff --cached --name-only --diff-filter=A -z $against | - LC_ALL=C tr -d '[ -~]\0' | wc -c) != 0 -then - cat <<\EOF -Error: Attempt to add a non-ASCII file name. - -This can cause problems if you want to work with people on other platforms. - -To be portable it is advisable to rename the file. - -If you know what you are doing you can disable this check using: - - git config hooks.allownonascii true -EOF - exit 1 -fi - -# If there are whitespace errors, print the offending file names and fail. -exec git diff-index --check --cached $against -- diff --git a/tests/resources/status_skipHash/.gitted/hooks/pre-merge-commit.sample b/tests/resources/status_skipHash/.gitted/hooks/pre-merge-commit.sample deleted file mode 100644 index 399eab1924e..00000000000 --- a/tests/resources/status_skipHash/.gitted/hooks/pre-merge-commit.sample +++ /dev/null @@ -1,13 +0,0 @@ -#!/bin/sh -# -# An example hook script to verify what is about to be committed. -# Called by "git merge" with no arguments. The hook should -# exit with non-zero status after issuing an appropriate message to -# stderr if it wants to stop the merge commit. -# -# To enable this hook, rename this file to "pre-merge-commit". - -. git-sh-setup -test -x "$GIT_DIR/hooks/pre-commit" && - exec "$GIT_DIR/hooks/pre-commit" -: diff --git a/tests/resources/status_skipHash/.gitted/hooks/pre-push.sample b/tests/resources/status_skipHash/.gitted/hooks/pre-push.sample deleted file mode 100644 index 4ce688d32b7..00000000000 --- a/tests/resources/status_skipHash/.gitted/hooks/pre-push.sample +++ /dev/null @@ -1,53 +0,0 @@ -#!/bin/sh - -# An example hook script to verify what is about to be pushed. Called by "git -# push" after it has checked the remote status, but before anything has been -# pushed. If this script exits with a non-zero status nothing will be pushed. -# -# This hook is called with the following parameters: -# -# $1 -- Name of the remote to which the push is being done -# $2 -- URL to which the push is being done -# -# If pushing without using a named remote those arguments will be equal. -# -# Information about the commits which are being pushed is supplied as lines to -# the standard input in the form: -# -# -# -# This sample shows how to prevent push of commits where the log message starts -# with "WIP" (work in progress). - -remote="$1" -url="$2" - -zero=$(git hash-object --stdin &2 "Found WIP commit in $local_ref, not pushing" - exit 1 - fi - fi -done - -exit 0 diff --git a/tests/resources/status_skipHash/.gitted/hooks/pre-rebase.sample b/tests/resources/status_skipHash/.gitted/hooks/pre-rebase.sample deleted file mode 100644 index 6cbef5c370d..00000000000 --- a/tests/resources/status_skipHash/.gitted/hooks/pre-rebase.sample +++ /dev/null @@ -1,169 +0,0 @@ -#!/bin/sh -# -# Copyright (c) 2006, 2008 Junio C Hamano -# -# The "pre-rebase" hook is run just before "git rebase" starts doing -# its job, and can prevent the command from running by exiting with -# non-zero status. -# -# The hook is called with the following parameters: -# -# $1 -- the upstream the series was forked from. -# $2 -- the branch being rebased (or empty when rebasing the current branch). -# -# This sample shows how to prevent topic branches that are already -# merged to 'next' branch from getting rebased, because allowing it -# would result in rebasing already published history. - -publish=next -basebranch="$1" -if test "$#" = 2 -then - topic="refs/heads/$2" -else - topic=`git symbolic-ref HEAD` || - exit 0 ;# we do not interrupt rebasing detached HEAD -fi - -case "$topic" in -refs/heads/??/*) - ;; -*) - exit 0 ;# we do not interrupt others. - ;; -esac - -# Now we are dealing with a topic branch being rebased -# on top of master. Is it OK to rebase it? - -# Does the topic really exist? -git show-ref -q "$topic" || { - echo >&2 "No such branch $topic" - exit 1 -} - -# Is topic fully merged to master? -not_in_master=`git rev-list --pretty=oneline ^master "$topic"` -if test -z "$not_in_master" -then - echo >&2 "$topic is fully merged to master; better remove it." - exit 1 ;# we could allow it, but there is no point. -fi - -# Is topic ever merged to next? If so you should not be rebasing it. -only_next_1=`git rev-list ^master "^$topic" ${publish} | sort` -only_next_2=`git rev-list ^master ${publish} | sort` -if test "$only_next_1" = "$only_next_2" -then - not_in_topic=`git rev-list "^$topic" master` - if test -z "$not_in_topic" - then - echo >&2 "$topic is already up to date with master" - exit 1 ;# we could allow it, but there is no point. - else - exit 0 - fi -else - not_in_next=`git rev-list --pretty=oneline ^${publish} "$topic"` - /usr/bin/perl -e ' - my $topic = $ARGV[0]; - my $msg = "* $topic has commits already merged to public branch:\n"; - my (%not_in_next) = map { - /^([0-9a-f]+) /; - ($1 => 1); - } split(/\n/, $ARGV[1]); - for my $elem (map { - /^([0-9a-f]+) (.*)$/; - [$1 => $2]; - } split(/\n/, $ARGV[2])) { - if (!exists $not_in_next{$elem->[0]}) { - if ($msg) { - print STDERR $msg; - undef $msg; - } - print STDERR " $elem->[1]\n"; - } - } - ' "$topic" "$not_in_next" "$not_in_master" - exit 1 -fi - -<<\DOC_END - -This sample hook safeguards topic branches that have been -published from being rewound. - -The workflow assumed here is: - - * Once a topic branch forks from "master", "master" is never - merged into it again (either directly or indirectly). - - * Once a topic branch is fully cooked and merged into "master", - it is deleted. If you need to build on top of it to correct - earlier mistakes, a new topic branch is created by forking at - the tip of the "master". This is not strictly necessary, but - it makes it easier to keep your history simple. - - * Whenever you need to test or publish your changes to topic - branches, merge them into "next" branch. - -The script, being an example, hardcodes the publish branch name -to be "next", but it is trivial to make it configurable via -$GIT_DIR/config mechanism. - -With this workflow, you would want to know: - -(1) ... if a topic branch has ever been merged to "next". Young - topic branches can have stupid mistakes you would rather - clean up before publishing, and things that have not been - merged into other branches can be easily rebased without - affecting other people. But once it is published, you would - not want to rewind it. - -(2) ... if a topic branch has been fully merged to "master". - Then you can delete it. More importantly, you should not - build on top of it -- other people may already want to - change things related to the topic as patches against your - "master", so if you need further changes, it is better to - fork the topic (perhaps with the same name) afresh from the - tip of "master". - -Let's look at this example: - - o---o---o---o---o---o---o---o---o---o "next" - / / / / - / a---a---b A / / - / / / / - / / c---c---c---c B / - / / / \ / - / / / b---b C \ / - / / / / \ / - ---o---o---o---o---o---o---o---o---o---o---o "master" - - -A, B and C are topic branches. - - * A has one fix since it was merged up to "next". - - * B has finished. It has been fully merged up to "master" and "next", - and is ready to be deleted. - - * C has not merged to "next" at all. - -We would want to allow C to be rebased, refuse A, and encourage -B to be deleted. - -To compute (1): - - git rev-list ^master ^topic next - git rev-list ^master next - - if these match, topic has not merged in next at all. - -To compute (2): - - git rev-list master..topic - - if this is empty, it is fully merged to "master". - -DOC_END diff --git a/tests/resources/status_skipHash/.gitted/hooks/pre-receive.sample b/tests/resources/status_skipHash/.gitted/hooks/pre-receive.sample deleted file mode 100644 index a1fd29ec148..00000000000 --- a/tests/resources/status_skipHash/.gitted/hooks/pre-receive.sample +++ /dev/null @@ -1,24 +0,0 @@ -#!/bin/sh -# -# An example hook script to make use of push options. -# The example simply echoes all push options that start with 'echoback=' -# and rejects all pushes when the "reject" push option is used. -# -# To enable this hook, rename this file to "pre-receive". - -if test -n "$GIT_PUSH_OPTION_COUNT" -then - i=0 - while test "$i" -lt "$GIT_PUSH_OPTION_COUNT" - do - eval "value=\$GIT_PUSH_OPTION_$i" - case "$value" in - echoback=*) - echo "echo from the pre-receive-hook: ${value#*=}" >&2 - ;; - reject) - exit 1 - esac - i=$((i + 1)) - done -fi diff --git a/tests/resources/status_skipHash/.gitted/hooks/prepare-commit-msg.sample b/tests/resources/status_skipHash/.gitted/hooks/prepare-commit-msg.sample deleted file mode 100644 index 10fa14c5ab0..00000000000 --- a/tests/resources/status_skipHash/.gitted/hooks/prepare-commit-msg.sample +++ /dev/null @@ -1,42 +0,0 @@ -#!/bin/sh -# -# An example hook script to prepare the commit log message. -# Called by "git commit" with the name of the file that has the -# commit message, followed by the description of the commit -# message's source. The hook's purpose is to edit the commit -# message file. If the hook fails with a non-zero status, -# the commit is aborted. -# -# To enable this hook, rename this file to "prepare-commit-msg". - -# This hook includes three examples. The first one removes the -# "# Please enter the commit message..." help message. -# -# The second includes the output of "git diff --name-status -r" -# into the message, just before the "git status" output. It is -# commented because it doesn't cope with --amend or with squashed -# commits. -# -# The third example adds a Signed-off-by line to the message, that can -# still be edited. This is rarely a good idea. - -COMMIT_MSG_FILE=$1 -COMMIT_SOURCE=$2 -SHA1=$3 - -/usr/bin/perl -i.bak -ne 'print unless(m/^. Please enter the commit message/..m/^#$/)' "$COMMIT_MSG_FILE" - -# case "$COMMIT_SOURCE,$SHA1" in -# ,|template,) -# /usr/bin/perl -i.bak -pe ' -# print "\n" . `git diff --cached --name-status -r` -# if /^#/ && $first++ == 0' "$COMMIT_MSG_FILE" ;; -# *) ;; -# esac - -# SOB=$(git var GIT_COMMITTER_IDENT | sed -n 's/^\(.*>\).*$/Signed-off-by: \1/p') -# git interpret-trailers --in-place --trailer "$SOB" "$COMMIT_MSG_FILE" -# if test -z "$COMMIT_SOURCE" -# then -# /usr/bin/perl -i.bak -pe 'print "\n" if !$first_line++' "$COMMIT_MSG_FILE" -# fi diff --git a/tests/resources/status_skipHash/.gitted/hooks/push-to-checkout.sample b/tests/resources/status_skipHash/.gitted/hooks/push-to-checkout.sample deleted file mode 100644 index af5a0c0018b..00000000000 --- a/tests/resources/status_skipHash/.gitted/hooks/push-to-checkout.sample +++ /dev/null @@ -1,78 +0,0 @@ -#!/bin/sh - -# An example hook script to update a checked-out tree on a git push. -# -# This hook is invoked by git-receive-pack(1) when it reacts to git -# push and updates reference(s) in its repository, and when the push -# tries to update the branch that is currently checked out and the -# receive.denyCurrentBranch configuration variable is set to -# updateInstead. -# -# By default, such a push is refused if the working tree and the index -# of the remote repository has any difference from the currently -# checked out commit; when both the working tree and the index match -# the current commit, they are updated to match the newly pushed tip -# of the branch. This hook is to be used to override the default -# behaviour; however the code below reimplements the default behaviour -# as a starting point for convenient modification. -# -# The hook receives the commit with which the tip of the current -# branch is going to be updated: -commit=$1 - -# It can exit with a non-zero status to refuse the push (when it does -# so, it must not modify the index or the working tree). -die () { - echo >&2 "$*" - exit 1 -} - -# Or it can make any necessary changes to the working tree and to the -# index to bring them to the desired state when the tip of the current -# branch is updated to the new commit, and exit with a zero status. -# -# For example, the hook can simply run git read-tree -u -m HEAD "$1" -# in order to emulate git fetch that is run in the reverse direction -# with git push, as the two-tree form of git read-tree -u -m is -# essentially the same as git switch or git checkout that switches -# branches while keeping the local changes in the working tree that do -# not interfere with the difference between the branches. - -# The below is a more-or-less exact translation to shell of the C code -# for the default behaviour for git's push-to-checkout hook defined in -# the push_to_deploy() function in builtin/receive-pack.c. -# -# Note that the hook will be executed from the repository directory, -# not from the working tree, so if you want to perform operations on -# the working tree, you will have to adapt your code accordingly, e.g. -# by adding "cd .." or using relative paths. - -if ! git update-index -q --ignore-submodules --refresh -then - die "Up-to-date check failed" -fi - -if ! git diff-files --quiet --ignore-submodules -- -then - die "Working directory has unstaged changes" -fi - -# This is a rough translation of: -# -# head_has_history() ? "HEAD" : EMPTY_TREE_SHA1_HEX -if git cat-file -e HEAD 2>/dev/null -then - head=HEAD -else - head=$(git hash-object -t tree --stdin &2 - exit 1 -} - -unset GIT_DIR GIT_WORK_TREE -cd "$worktree" && - -if grep -q "^diff --git " "$1" -then - validate_patch "$1" -else - validate_cover_letter "$1" -fi && - -if test "$GIT_SENDEMAIL_FILE_COUNTER" = "$GIT_SENDEMAIL_FILE_TOTAL" -then - git config --unset-all sendemail.validateWorktree && - trap 'git worktree remove -ff "$worktree"' EXIT && - validate_series -fi diff --git a/tests/resources/status_skipHash/.gitted/hooks/update.sample b/tests/resources/status_skipHash/.gitted/hooks/update.sample deleted file mode 100644 index c4d426bc6ee..00000000000 --- a/tests/resources/status_skipHash/.gitted/hooks/update.sample +++ /dev/null @@ -1,128 +0,0 @@ -#!/bin/sh -# -# An example hook script to block unannotated tags from entering. -# Called by "git receive-pack" with arguments: refname sha1-old sha1-new -# -# To enable this hook, rename this file to "update". -# -# Config -# ------ -# hooks.allowunannotated -# This boolean sets whether unannotated tags will be allowed into the -# repository. By default they won't be. -# hooks.allowdeletetag -# This boolean sets whether deleting tags will be allowed in the -# repository. By default they won't be. -# hooks.allowmodifytag -# This boolean sets whether a tag may be modified after creation. By default -# it won't be. -# hooks.allowdeletebranch -# This boolean sets whether deleting branches will be allowed in the -# repository. By default they won't be. -# hooks.denycreatebranch -# This boolean sets whether remotely creating branches will be denied -# in the repository. By default this is allowed. -# - -# --- Command line -refname="$1" -oldrev="$2" -newrev="$3" - -# --- Safety check -if [ -z "$GIT_DIR" ]; then - echo "Don't run this script from the command line." >&2 - echo " (if you want, you could supply GIT_DIR then run" >&2 - echo " $0 )" >&2 - exit 1 -fi - -if [ -z "$refname" -o -z "$oldrev" -o -z "$newrev" ]; then - echo "usage: $0 " >&2 - exit 1 -fi - -# --- Config -allowunannotated=$(git config --type=bool hooks.allowunannotated) -allowdeletebranch=$(git config --type=bool hooks.allowdeletebranch) -denycreatebranch=$(git config --type=bool hooks.denycreatebranch) -allowdeletetag=$(git config --type=bool hooks.allowdeletetag) -allowmodifytag=$(git config --type=bool hooks.allowmodifytag) - -# check for no description -projectdesc=$(sed -e '1q' "$GIT_DIR/description") -case "$projectdesc" in -"Unnamed repository"* | "") - echo "*** Project description file hasn't been set" >&2 - exit 1 - ;; -esac - -# --- Check types -# if $newrev is 0000...0000, it's a commit to delete a ref. -zero=$(git hash-object --stdin &2 - echo "*** Use 'git tag [ -a | -s ]' for tags you want to propagate." >&2 - exit 1 - fi - ;; - refs/tags/*,delete) - # delete tag - if [ "$allowdeletetag" != "true" ]; then - echo "*** Deleting a tag is not allowed in this repository" >&2 - exit 1 - fi - ;; - refs/tags/*,tag) - # annotated tag - if [ "$allowmodifytag" != "true" ] && git rev-parse $refname > /dev/null 2>&1 - then - echo "*** Tag '$refname' already exists." >&2 - echo "*** Modifying a tag is not allowed in this repository." >&2 - exit 1 - fi - ;; - refs/heads/*,commit) - # branch - if [ "$oldrev" = "$zero" -a "$denycreatebranch" = "true" ]; then - echo "*** Creating a branch is not allowed in this repository" >&2 - exit 1 - fi - ;; - refs/heads/*,delete) - # delete branch - if [ "$allowdeletebranch" != "true" ]; then - echo "*** Deleting a branch is not allowed in this repository" >&2 - exit 1 - fi - ;; - refs/remotes/*,commit) - # tracking branch - ;; - refs/remotes/*,delete) - # delete tracking branch - if [ "$allowdeletebranch" != "true" ]; then - echo "*** Deleting a tracking branch is not allowed in this repository" >&2 - exit 1 - fi - ;; - *) - # Anything else (is there anything else?) - echo "*** Update hook: unknown type of update to ref $refname of type $newrev_type" >&2 - exit 1 - ;; -esac - -# --- Finished -exit 0 From d73078773e8f68dd7bceb70d0887846ef6a9e201 Mon Sep 17 00:00:00 2001 From: parnic Date: Sat, 17 Feb 2024 08:13:46 -0600 Subject: [PATCH 486/608] Update src/libgit2/index.c Co-authored-by: Edward Thomson --- src/libgit2/index.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/libgit2/index.c b/src/libgit2/index.c index 86f14fdfc41..f4df9f64392 100644 --- a/src/libgit2/index.c +++ b/src/libgit2/index.c @@ -2850,7 +2850,8 @@ static int parse_index(git_index *index, const char *buffer, size_t buffer_size) /* * SHA-1 or SHA-256 (depending on the repository's object format) * over the content of the index file before this checksum. - * Note: checksum may be 0 if index.skipHash is set to true. + * Note: checksum may be 0 if the index was written by a client + * where index.skipHash was set to true. */ if (memcmp(zero_checksum, buffer, checksum_size) != 0 && memcmp(checksum, buffer, checksum_size) != 0) { error = index_error_invalid( From b69d927243e0137342fb093ec3c9203df6d201d5 Mon Sep 17 00:00:00 2001 From: parnic Date: Sat, 17 Feb 2024 08:13:54 -0600 Subject: [PATCH 487/608] Update src/libgit2/index.c Co-authored-by: Edward Thomson --- src/libgit2/index.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/libgit2/index.c b/src/libgit2/index.c index f4df9f64392..670fbc5cf15 100644 --- a/src/libgit2/index.c +++ b/src/libgit2/index.c @@ -2853,7 +2853,8 @@ static int parse_index(git_index *index, const char *buffer, size_t buffer_size) * Note: checksum may be 0 if the index was written by a client * where index.skipHash was set to true. */ - if (memcmp(zero_checksum, buffer, checksum_size) != 0 && memcmp(checksum, buffer, checksum_size) != 0) { + if (memcmp(zero_checksum, buffer, checksum_size) != 0 && + memcmp(checksum, buffer, checksum_size) != 0) { error = index_error_invalid( "calculated checksum does not match expected"); goto done; From 6a218c2dc14f8989616b62e441ac161c820fa4f2 Mon Sep 17 00:00:00 2001 From: parnic Date: Sat, 17 Feb 2024 08:14:09 -0600 Subject: [PATCH 488/608] Update tests/libgit2/status/worktree.c Co-authored-by: Edward Thomson --- tests/libgit2/status/worktree.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/libgit2/status/worktree.c b/tests/libgit2/status/worktree.c index bd3cdb9e7d3..bf99461871c 100644 --- a/tests/libgit2/status/worktree.c +++ b/tests/libgit2/status/worktree.c @@ -1363,7 +1363,7 @@ void test_status_worktree__at_head_parent(void) void test_status_worktree__skip_hash(void) { - git_repository *repo = cl_git_sandbox_init("status_skipHash"); + git_repository *repo = cl_git_sandbox_init("status_skiphash"); git_index *index; cl_git_pass(git_repository_index(&index, repo)); From a0dbf6044785a914b0c2c1b4f6601b54a153374e Mon Sep 17 00:00:00 2001 From: Parnic Date: Sat, 17 Feb 2024 08:15:42 -0600 Subject: [PATCH 489/608] Change capitalization per PR feedback --- .../.gitted/COMMIT_EDITMSG | 0 .../.gitted/HEAD | 0 .../.gitted/MERGE_RR | 0 .../.gitted/config | 0 .../.gitted/description | 0 .../.gitted/index | Bin .../.gitted/info/exclude | 0 .../.gitted/logs/HEAD | 0 .../.gitted/logs/refs/heads/main | 0 .../34/f4c90b237fcb4c677772a6093f3cba239c41a5 | Bin .../71/a21e67674e9717aa7380e5782ec5e070a8d7e0 | Bin .../d7/c1f165e51adbbfd7760162b7a5802d4117740c | Bin .../.gitted/refs/heads/main | 0 .../{status_skipHash => status_skiphash}/new_file | 0 14 files changed, 0 insertions(+), 0 deletions(-) rename tests/resources/{status_skipHash => status_skiphash}/.gitted/COMMIT_EDITMSG (100%) rename tests/resources/{status_skipHash => status_skiphash}/.gitted/HEAD (100%) rename tests/resources/{status_skipHash => status_skiphash}/.gitted/MERGE_RR (100%) rename tests/resources/{status_skipHash => status_skiphash}/.gitted/config (100%) rename tests/resources/{status_skipHash => status_skiphash}/.gitted/description (100%) rename tests/resources/{status_skipHash => status_skiphash}/.gitted/index (100%) rename tests/resources/{status_skipHash => status_skiphash}/.gitted/info/exclude (100%) rename tests/resources/{status_skipHash => status_skiphash}/.gitted/logs/HEAD (100%) rename tests/resources/{status_skipHash => status_skiphash}/.gitted/logs/refs/heads/main (100%) rename tests/resources/{status_skipHash => status_skiphash}/.gitted/objects/34/f4c90b237fcb4c677772a6093f3cba239c41a5 (100%) rename tests/resources/{status_skipHash => status_skiphash}/.gitted/objects/71/a21e67674e9717aa7380e5782ec5e070a8d7e0 (100%) rename tests/resources/{status_skipHash => status_skiphash}/.gitted/objects/d7/c1f165e51adbbfd7760162b7a5802d4117740c (100%) rename tests/resources/{status_skipHash => status_skiphash}/.gitted/refs/heads/main (100%) rename tests/resources/{status_skipHash => status_skiphash}/new_file (100%) diff --git a/tests/resources/status_skipHash/.gitted/COMMIT_EDITMSG b/tests/resources/status_skiphash/.gitted/COMMIT_EDITMSG similarity index 100% rename from tests/resources/status_skipHash/.gitted/COMMIT_EDITMSG rename to tests/resources/status_skiphash/.gitted/COMMIT_EDITMSG diff --git a/tests/resources/status_skipHash/.gitted/HEAD b/tests/resources/status_skiphash/.gitted/HEAD similarity index 100% rename from tests/resources/status_skipHash/.gitted/HEAD rename to tests/resources/status_skiphash/.gitted/HEAD diff --git a/tests/resources/status_skipHash/.gitted/MERGE_RR b/tests/resources/status_skiphash/.gitted/MERGE_RR similarity index 100% rename from tests/resources/status_skipHash/.gitted/MERGE_RR rename to tests/resources/status_skiphash/.gitted/MERGE_RR diff --git a/tests/resources/status_skipHash/.gitted/config b/tests/resources/status_skiphash/.gitted/config similarity index 100% rename from tests/resources/status_skipHash/.gitted/config rename to tests/resources/status_skiphash/.gitted/config diff --git a/tests/resources/status_skipHash/.gitted/description b/tests/resources/status_skiphash/.gitted/description similarity index 100% rename from tests/resources/status_skipHash/.gitted/description rename to tests/resources/status_skiphash/.gitted/description diff --git a/tests/resources/status_skipHash/.gitted/index b/tests/resources/status_skiphash/.gitted/index similarity index 100% rename from tests/resources/status_skipHash/.gitted/index rename to tests/resources/status_skiphash/.gitted/index diff --git a/tests/resources/status_skipHash/.gitted/info/exclude b/tests/resources/status_skiphash/.gitted/info/exclude similarity index 100% rename from tests/resources/status_skipHash/.gitted/info/exclude rename to tests/resources/status_skiphash/.gitted/info/exclude diff --git a/tests/resources/status_skipHash/.gitted/logs/HEAD b/tests/resources/status_skiphash/.gitted/logs/HEAD similarity index 100% rename from tests/resources/status_skipHash/.gitted/logs/HEAD rename to tests/resources/status_skiphash/.gitted/logs/HEAD diff --git a/tests/resources/status_skipHash/.gitted/logs/refs/heads/main b/tests/resources/status_skiphash/.gitted/logs/refs/heads/main similarity index 100% rename from tests/resources/status_skipHash/.gitted/logs/refs/heads/main rename to tests/resources/status_skiphash/.gitted/logs/refs/heads/main diff --git a/tests/resources/status_skipHash/.gitted/objects/34/f4c90b237fcb4c677772a6093f3cba239c41a5 b/tests/resources/status_skiphash/.gitted/objects/34/f4c90b237fcb4c677772a6093f3cba239c41a5 similarity index 100% rename from tests/resources/status_skipHash/.gitted/objects/34/f4c90b237fcb4c677772a6093f3cba239c41a5 rename to tests/resources/status_skiphash/.gitted/objects/34/f4c90b237fcb4c677772a6093f3cba239c41a5 diff --git a/tests/resources/status_skipHash/.gitted/objects/71/a21e67674e9717aa7380e5782ec5e070a8d7e0 b/tests/resources/status_skiphash/.gitted/objects/71/a21e67674e9717aa7380e5782ec5e070a8d7e0 similarity index 100% rename from tests/resources/status_skipHash/.gitted/objects/71/a21e67674e9717aa7380e5782ec5e070a8d7e0 rename to tests/resources/status_skiphash/.gitted/objects/71/a21e67674e9717aa7380e5782ec5e070a8d7e0 diff --git a/tests/resources/status_skipHash/.gitted/objects/d7/c1f165e51adbbfd7760162b7a5802d4117740c b/tests/resources/status_skiphash/.gitted/objects/d7/c1f165e51adbbfd7760162b7a5802d4117740c similarity index 100% rename from tests/resources/status_skipHash/.gitted/objects/d7/c1f165e51adbbfd7760162b7a5802d4117740c rename to tests/resources/status_skiphash/.gitted/objects/d7/c1f165e51adbbfd7760162b7a5802d4117740c diff --git a/tests/resources/status_skipHash/.gitted/refs/heads/main b/tests/resources/status_skiphash/.gitted/refs/heads/main similarity index 100% rename from tests/resources/status_skipHash/.gitted/refs/heads/main rename to tests/resources/status_skiphash/.gitted/refs/heads/main diff --git a/tests/resources/status_skipHash/new_file b/tests/resources/status_skiphash/new_file similarity index 100% rename from tests/resources/status_skipHash/new_file rename to tests/resources/status_skiphash/new_file From e696528aa849a3911b756b0e5d32abaca5370358 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 17 Feb 2024 14:27:19 +0000 Subject: [PATCH 490/608] Update cmake/SelectHTTPSBackend.cmake --- cmake/SelectHTTPSBackend.cmake | 1 + 1 file changed, 1 insertion(+) diff --git a/cmake/SelectHTTPSBackend.cmake b/cmake/SelectHTTPSBackend.cmake index fbc2adc147f..d293001f567 100644 --- a/cmake/SelectHTTPSBackend.cmake +++ b/cmake/SelectHTTPSBackend.cmake @@ -55,6 +55,7 @@ if(USE_HTTPS) set(GIT_OPENSSL 1) list(APPEND LIBGIT2_SYSTEM_INCLUDES ${OPENSSL_INCLUDE_DIR}) list(APPEND LIBGIT2_SYSTEM_LIBS ${OPENSSL_LIBRARIES}) + # Static OpenSSL (lib crypto.a) requires libdl, include it explicitly if(LINK_WITH_STATIC_LIBRARIES STREQUAL ON) list(APPEND LIBGIT2_SYSTEM_LIBS ${CMAKE_DL_LIBS}) endif() From 8422a6386ea7458799a080ce073b530b663aa0cc Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 17 Feb 2024 15:07:53 +0000 Subject: [PATCH 491/608] config: avoid unnecessary copy in rename_section We can just append the escaped regex to the value buffer, we don't need create a new value buffer and then append _that_. --- src/libgit2/config.c | 42 +++++++++++++++++++----------------------- 1 file changed, 19 insertions(+), 23 deletions(-) diff --git a/src/libgit2/config.c b/src/libgit2/config.c index d11e76d9577..04f3ec2fee2 100644 --- a/src/libgit2/config.c +++ b/src/libgit2/config.c @@ -1509,35 +1509,31 @@ static int rename_config_entries_cb( int error = 0; struct rename_data *data = (struct rename_data *)payload; size_t base_len = git_str_len(data->name); - git_str raw_value = GIT_STR_INIT, value = GIT_STR_INIT; - - if (base_len > 0 && - !(error = git_str_puts(data->name, entry->name + data->old_len))) - { - error = git_config_set_multivar( - data->config, git_str_cstr(data->name), "^$", - entry->value); + git_str value = GIT_STR_INIT; + + if (base_len > 0) { + if ((error = git_str_puts(data->name, + entry->name + data->old_len)) < 0 || + (error = git_config_set_multivar( + data->config, git_str_cstr(data->name), "^$", + entry->value)) < 0) + goto cleanup; } - if (!error) { - if ((error = git_str_puts_escape_regex( - &raw_value, entry->value))) - goto cleanup; - git_str_grow(&value, git_str_len(&raw_value) + 2); - git_str_putc(&value, '^'); - git_str_puts(&value, git_str_cstr(&raw_value)); - git_str_putc(&value, '$'); - if (git_str_oom(&value)) { - error = -1; - goto cleanup; - } - error = git_config_delete_multivar( - data->config, entry->name, git_str_cstr(&value)); + git_str_putc(&value, '^'); + git_str_puts_escape_regex(&value, entry->value); + git_str_putc(&value, '$'); + + if (git_str_oom(&value)) { + error = -1; + goto cleanup; } + error = git_config_delete_multivar( + data->config, entry->name, git_str_cstr(&value)); + cleanup: git_str_truncate(data->name, base_len); - git_str_dispose(&raw_value); git_str_dispose(&value); return error; } From 913d4ea251366f006a5ced6ed1804acf973a6ce6 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 17 Feb 2024 15:20:12 +0000 Subject: [PATCH 492/608] skiphash: free the index --- tests/libgit2/status/worktree.c | 1 + 1 file changed, 1 insertion(+) diff --git a/tests/libgit2/status/worktree.c b/tests/libgit2/status/worktree.c index bf99461871c..8a2ea9cb674 100644 --- a/tests/libgit2/status/worktree.c +++ b/tests/libgit2/status/worktree.c @@ -1368,4 +1368,5 @@ void test_status_worktree__skip_hash(void) cl_git_pass(git_repository_index(&index, repo)); cl_git_pass(git_index_read(index, true)); + git_index_free(index); } From 928ac176f4949481b9eea4a172af5bc4a2be2779 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sun, 18 Feb 2024 00:55:46 +0000 Subject: [PATCH 493/608] meta: add dependency tag to release.yml --- .github/release.yml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.github/release.yml b/.github/release.yml index 099e3803fa6..4d4e31860c2 100644 --- a/.github/release.yml +++ b/.github/release.yml @@ -27,6 +27,9 @@ changelog: - title: Git compatibility fixes labels: - git compatibility + - title: Dependency updates + labels: + - dependency - title: Other changes labels: - '*' From 49487b5e39a4895085450897e9335f60c252b811 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 19 Feb 2024 08:38:34 -0800 Subject: [PATCH 494/608] clar: canonicalize temp sandbox directory everywhere We currently only canonicalize the temp sandbox directory on macOS, which is critical since `/tmp` is really `/private/tmp`. However, we should do it everywhere, so that tests can actually expect a consistent outcome by looking at `clar_sandbox_path()`. --- tests/clar/clar/sandbox.h | 45 ++++++++++++++++++++++++++++++--------- 1 file changed, 35 insertions(+), 10 deletions(-) diff --git a/tests/clar/clar/sandbox.h b/tests/clar/clar/sandbox.h index 0ba1479620a..0688374f8d6 100644 --- a/tests/clar/clar/sandbox.h +++ b/tests/clar/clar/sandbox.h @@ -2,7 +2,8 @@ #include #endif -static char _clar_path[4096 + 1]; +#define CLAR_PATH_MAX 4096 +static char _clar_path[CLAR_PATH_MAX]; static int is_valid_tmp_path(const char *path) @@ -35,10 +36,9 @@ find_tmp_path(char *buffer, size_t length) continue; if (is_valid_tmp_path(env)) { -#ifdef __APPLE__ - if (length >= PATH_MAX && realpath(env, buffer) != NULL) - return 0; -#endif + if (strlen(env) + 1 > CLAR_PATH_MAX) + return -1; + strncpy(buffer, env, length - 1); buffer[length - 1] = '\0'; return 0; @@ -47,10 +47,6 @@ find_tmp_path(char *buffer, size_t length) /* If the environment doesn't say anything, try to use /tmp */ if (is_valid_tmp_path("/tmp")) { -#ifdef __APPLE__ - if (length >= PATH_MAX && realpath("/tmp", buffer) != NULL) - return 0; -#endif strncpy(buffer, "/tmp", length - 1); buffer[length - 1] = '\0'; return 0; @@ -75,6 +71,34 @@ find_tmp_path(char *buffer, size_t length) return -1; } +static int canonicalize_tmp_path(char *buffer) +{ +#ifdef _WIN32 + char tmp[CLAR_PATH_MAX]; + DWORD ret; + + ret = GetFullPathName(buffer, CLAR_PATH_MAX, tmp, NULL); + + if (ret == 0 || ret > CLAR_PATH_MAX) + return -1; + + ret = GetLongPathName(tmp, buffer, CLAR_PATH_MAX); + + if (ret == 0 || ret > CLAR_PATH_MAX) + return -1; + + return 0; +#else + char tmp[CLAR_PATH_MAX]; + + if (realpath(buffer, tmp) == NULL) + return -1; + + strcpy(buffer, tmp); + return 0; +#endif +} + static void clar_unsandbox(void) { if (_clar_path[0] == '\0') @@ -95,7 +119,8 @@ static int build_sandbox_path(void) size_t len; - if (find_tmp_path(_clar_path, sizeof(_clar_path)) < 0) + if (find_tmp_path(_clar_path, sizeof(_clar_path)) < 0 || + canonicalize_tmp_path(_clar_path) < 0) return -1; len = strlen(_clar_path); From bec1d7b7b073758549d1d7484fab753b889acbfc Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sun, 18 Feb 2024 00:02:47 +0000 Subject: [PATCH 495/608] path: provide a helper to compute len with trailing slashes We may need to strip multiple slashes at the end of a path; provide a method to do so. --- src/util/fs_path.c | 10 ++++++++++ src/util/fs_path.h | 6 ++++++ tests/util/path.c | 12 ++++++++++++ 3 files changed, 28 insertions(+) diff --git a/src/util/fs_path.c b/src/util/fs_path.c index ab64778c23e..9d5c99eab81 100644 --- a/src/util/fs_path.c +++ b/src/util/fs_path.c @@ -419,6 +419,16 @@ int git_fs_path_to_dir(git_str *path) return git_str_oom(path) ? -1 : 0; } +size_t git_fs_path_dirlen(const char *path) +{ + size_t len = strlen(path); + + while (len > 1 && path[len - 1] == '/') + len--; + + return len; +} + void git_fs_path_string_to_dir(char *path, size_t size) { size_t end = strlen(path); diff --git a/src/util/fs_path.h b/src/util/fs_path.h index e5ca6737818..34e491eb919 100644 --- a/src/util/fs_path.h +++ b/src/util/fs_path.h @@ -86,6 +86,12 @@ extern int git_fs_path_to_dir(git_str *path); */ extern void git_fs_path_string_to_dir(char *path, size_t size); +/** + * Provides the length of the given path string with no trailing + * slashes. + */ +size_t git_fs_path_dirlen(const char *path); + /** * Taken from git.git; returns nonzero if the given path is "." or "..". */ diff --git a/tests/util/path.c b/tests/util/path.c index 02ec42fcea2..38a59392521 100644 --- a/tests/util/path.c +++ b/tests/util/path.c @@ -766,3 +766,15 @@ void test_path__validate_current_user_ownership(void) cl_git_fail(git_fs_path_owner_is_current_user(&is_cur, "/path/does/not/exist")); #endif } + +void test_path__dirlen(void) +{ + cl_assert_equal_sz(13, git_fs_path_dirlen("/foo/bar/asdf")); + cl_assert_equal_sz(13, git_fs_path_dirlen("/foo/bar/asdf/")); + cl_assert_equal_sz(13, git_fs_path_dirlen("/foo/bar/asdf//")); + cl_assert_equal_sz(3, git_fs_path_dirlen("foo////")); + cl_assert_equal_sz(3, git_fs_path_dirlen("foo")); + cl_assert_equal_sz(1, git_fs_path_dirlen("/")); + cl_assert_equal_sz(1, git_fs_path_dirlen("////")); + cl_assert_equal_sz(0, git_fs_path_dirlen("")); +} From beea99b08234a7e0de3a3c7f739260527d38a6f1 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sun, 18 Feb 2024 07:46:19 -0800 Subject: [PATCH 496/608] path: provide an is_root helper method We may quickly want to determine if the given path is the root path ('/') on POSIX, or the root of a drive letter (eg, 'A:/', 'C:\') on Windows. --- src/util/fs_path.h | 17 +++++++++++++++++ tests/util/path/core.c | 26 ++++++++++++++++++++++++++ 2 files changed, 43 insertions(+) diff --git a/src/util/fs_path.h b/src/util/fs_path.h index 34e491eb919..43f7951adde 100644 --- a/src/util/fs_path.h +++ b/src/util/fs_path.h @@ -92,6 +92,23 @@ extern void git_fs_path_string_to_dir(char *path, size_t size); */ size_t git_fs_path_dirlen(const char *path); +/** + * Returns nonzero if the given path is a filesystem root; on Windows, this + * means a drive letter (eg `A:/`, `C:\`). On POSIX this is `/`. + */ +GIT_INLINE(int) git_fs_path_is_root(const char *name) +{ +#ifdef GIT_WIN32 + if (((name[0] >= 'A' && name[0] <= 'Z') || (name[0] >= 'a' && name[0] <= 'z')) && + name[1] == ':' && + (name[2] == '/' || name[2] == '\\') && + name[3] == '\0') + return 1; +#endif + + return (name[0] == '/' && name[1] == '\0'); +} + /** * Taken from git.git; returns nonzero if the given path is "." or "..". */ diff --git a/tests/util/path/core.c b/tests/util/path/core.c index f30f6c01b0d..41d9b02040f 100644 --- a/tests/util/path/core.c +++ b/tests/util/path/core.c @@ -341,3 +341,29 @@ void test_path_core__join_unrooted_respects_funny_windows_roots(void) test_join_unrooted("💩:/foo/bar/foobar", 13, "💩:/foo/bar/foobar", "💩:/foo/bar"); test_join_unrooted("💩:/foo/bar/foobar", 9, "💩:/foo/bar/foobar", "💩:/foo/"); } + +void test_path_core__is_root(void) +{ + cl_assert_equal_b(true, git_fs_path_is_root("/")); + cl_assert_equal_b(false, git_fs_path_is_root("//")); + cl_assert_equal_b(false, git_fs_path_is_root("foo/")); + cl_assert_equal_b(false, git_fs_path_is_root("/foo/")); + cl_assert_equal_b(false, git_fs_path_is_root("/foo")); + cl_assert_equal_b(false, git_fs_path_is_root("\\")); + +#ifdef GIT_WIN32 + cl_assert_equal_b(true, git_fs_path_is_root("A:\\")); + cl_assert_equal_b(false, git_fs_path_is_root("B:\\foo")); + cl_assert_equal_b(false, git_fs_path_is_root("B:\\foo\\")); + cl_assert_equal_b(true, git_fs_path_is_root("C:\\")); + cl_assert_equal_b(true, git_fs_path_is_root("c:\\")); + cl_assert_equal_b(true, git_fs_path_is_root("z:\\")); + cl_assert_equal_b(false, git_fs_path_is_root("z:\\\\")); + cl_assert_equal_b(false, git_fs_path_is_root("\\\\localhost")); + cl_assert_equal_b(false, git_fs_path_is_root("\\\\localhost\\")); + cl_assert_equal_b(false, git_fs_path_is_root("\\\\localhost\\c$\\")); + cl_assert_equal_b(false, git_fs_path_is_root("\\\\localhost\\c$\\Foo")); + cl_assert_equal_b(false, git_fs_path_is_root("\\\\localhost\\c$\\Foo\\")); + cl_assert_equal_b(false, git_fs_path_is_root("\\\\Volume\\12345\\Foo\\Bar.txt")); +#endif +} From f43aa1adb50666e258d2412230cf93f6a493ae05 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 19 Feb 2024 07:05:41 -0800 Subject: [PATCH 497/608] util: move path tests to path::core Clar handles multiple levels of hierarchy in a test name _but_ it does so assuming that there are not tests at a parent folder level. In other words, if you have some tests at path/core.c and path/win32.c, then you cannot have tests in path.c. If you have tests in path.c, then the things in path/*.c will be ignored. Move the tests in path.c into path/core.c. --- tests/util/path.c | 780 ----------------------------------------- tests/util/path/core.c | 778 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 778 insertions(+), 780 deletions(-) delete mode 100644 tests/util/path.c diff --git a/tests/util/path.c b/tests/util/path.c deleted file mode 100644 index 38a59392521..00000000000 --- a/tests/util/path.c +++ /dev/null @@ -1,780 +0,0 @@ -#include "clar_libgit2.h" -#include "futils.h" -#include "fs_path.h" - -#ifndef GIT_WIN32 -# include -#endif - -static char *path_save; - -void test_path__initialize(void) -{ - path_save = cl_getenv("PATH"); -} - -void test_path__cleanup(void) -{ - cl_setenv("PATH", path_save); - git__free(path_save); - path_save = NULL; -} - -static void -check_dirname(const char *A, const char *B) -{ - git_str dir = GIT_STR_INIT; - char *dir2; - - cl_assert(git_fs_path_dirname_r(&dir, A) >= 0); - cl_assert_equal_s(B, dir.ptr); - git_str_dispose(&dir); - - cl_assert((dir2 = git_fs_path_dirname(A)) != NULL); - cl_assert_equal_s(B, dir2); - git__free(dir2); -} - -static void -check_basename(const char *A, const char *B) -{ - git_str base = GIT_STR_INIT; - char *base2; - - cl_assert(git_fs_path_basename_r(&base, A) >= 0); - cl_assert_equal_s(B, base.ptr); - git_str_dispose(&base); - - cl_assert((base2 = git_fs_path_basename(A)) != NULL); - cl_assert_equal_s(B, base2); - git__free(base2); -} - -static void -check_joinpath(const char *path_a, const char *path_b, const char *expected_path) -{ - git_str joined_path = GIT_STR_INIT; - - cl_git_pass(git_str_joinpath(&joined_path, path_a, path_b)); - cl_assert_equal_s(expected_path, joined_path.ptr); - - git_str_dispose(&joined_path); -} - -static void -check_joinpath_n( - const char *path_a, - const char *path_b, - const char *path_c, - const char *path_d, - const char *expected_path) -{ - git_str joined_path = GIT_STR_INIT; - - cl_git_pass(git_str_join_n(&joined_path, '/', 4, - path_a, path_b, path_c, path_d)); - cl_assert_equal_s(expected_path, joined_path.ptr); - - git_str_dispose(&joined_path); -} - -static void check_setenv(const char* name, const char* value) -{ - char* check; - - cl_git_pass(cl_setenv(name, value)); - check = cl_getenv(name); - - if (value) - cl_assert_equal_s(value, check); - else - cl_assert(check == NULL); - - git__free(check); -} - -/* get the dirname of a path */ -void test_path__00_dirname(void) -{ - check_dirname(NULL, "."); - check_dirname("", "."); - check_dirname("a", "."); - check_dirname("/", "/"); - check_dirname("/usr", "/"); - check_dirname("/usr/", "/"); - check_dirname("/usr/lib", "/usr"); - check_dirname("/usr/lib/", "/usr"); - check_dirname("/usr/lib//", "/usr"); - check_dirname("usr/lib", "usr"); - check_dirname("usr/lib/", "usr"); - check_dirname("usr/lib//", "usr"); - check_dirname(".git/", "."); - - check_dirname(REP16("/abc"), REP15("/abc")); - -#ifdef GIT_WIN32 - check_dirname("C:/", "C:/"); - check_dirname("C:", "C:/"); - check_dirname("C:/path/", "C:/"); - check_dirname("C:/path", "C:/"); - check_dirname("//computername/", "//computername/"); - check_dirname("//computername", "//computername/"); - check_dirname("//computername/path/", "//computername/"); - check_dirname("//computername/path", "//computername/"); - check_dirname("//computername/sub/path/", "//computername/sub"); - check_dirname("//computername/sub/path", "//computername/sub"); -#endif -} - -/* get the base name of a path */ -void test_path__01_basename(void) -{ - check_basename(NULL, "."); - check_basename("", "."); - check_basename("a", "a"); - check_basename("/", "/"); - check_basename("/usr", "usr"); - check_basename("/usr/", "usr"); - check_basename("/usr/lib", "lib"); - check_basename("/usr/lib//", "lib"); - check_basename("usr/lib", "lib"); - - check_basename(REP16("/abc"), "abc"); - check_basename(REP1024("/abc"), "abc"); -} - -/* properly join path components */ -void test_path__05_joins(void) -{ - check_joinpath("", "", ""); - check_joinpath("", "a", "a"); - check_joinpath("", "/a", "/a"); - check_joinpath("a", "", "a/"); - check_joinpath("a", "/", "a/"); - check_joinpath("a", "b", "a/b"); - check_joinpath("/", "a", "/a"); - check_joinpath("/", "", "/"); - check_joinpath("/a", "/b", "/a/b"); - check_joinpath("/a", "/b/", "/a/b/"); - check_joinpath("/a/", "b/", "/a/b/"); - check_joinpath("/a/", "/b/", "/a/b/"); - - check_joinpath("/abcd", "/defg", "/abcd/defg"); - check_joinpath("/abcd", "/defg/", "/abcd/defg/"); - check_joinpath("/abcd/", "defg/", "/abcd/defg/"); - check_joinpath("/abcd/", "/defg/", "/abcd/defg/"); - - check_joinpath("/abcdefgh", "/12345678", "/abcdefgh/12345678"); - check_joinpath("/abcdefgh", "/12345678/", "/abcdefgh/12345678/"); - check_joinpath("/abcdefgh/", "12345678/", "/abcdefgh/12345678/"); - - check_joinpath(REP1024("aaaa"), "", REP1024("aaaa") "/"); - check_joinpath(REP1024("aaaa/"), "", REP1024("aaaa/")); - check_joinpath(REP1024("/aaaa"), "", REP1024("/aaaa") "/"); - - check_joinpath(REP1024("aaaa"), REP1024("bbbb"), - REP1024("aaaa") "/" REP1024("bbbb")); - check_joinpath(REP1024("/aaaa"), REP1024("/bbbb"), - REP1024("/aaaa") REP1024("/bbbb")); -} - -/* properly join path components for more than one path */ -void test_path__06_long_joins(void) -{ - check_joinpath_n("", "", "", "", ""); - check_joinpath_n("", "a", "", "", "a/"); - check_joinpath_n("a", "", "", "", "a/"); - check_joinpath_n("", "", "", "a", "a"); - check_joinpath_n("a", "b", "", "/c/d/", "a/b/c/d/"); - check_joinpath_n("a", "b", "", "/c/d", "a/b/c/d"); - check_joinpath_n("abcd", "efgh", "ijkl", "mnop", "abcd/efgh/ijkl/mnop"); - check_joinpath_n("abcd/", "efgh/", "ijkl/", "mnop/", "abcd/efgh/ijkl/mnop/"); - check_joinpath_n("/abcd/", "/efgh/", "/ijkl/", "/mnop/", "/abcd/efgh/ijkl/mnop/"); - - check_joinpath_n(REP1024("a"), REP1024("b"), REP1024("c"), REP1024("d"), - REP1024("a") "/" REP1024("b") "/" - REP1024("c") "/" REP1024("d")); - check_joinpath_n(REP1024("/a"), REP1024("/b"), REP1024("/c"), REP1024("/d"), - REP1024("/a") REP1024("/b") - REP1024("/c") REP1024("/d")); -} - - -static void -check_path_to_dir( - const char* path, - const char* expected) -{ - git_str tgt = GIT_STR_INIT; - - git_str_sets(&tgt, path); - cl_git_pass(git_fs_path_to_dir(&tgt)); - cl_assert_equal_s(expected, tgt.ptr); - - git_str_dispose(&tgt); -} - -static void -check_string_to_dir( - const char* path, - size_t maxlen, - const char* expected) -{ - size_t len = strlen(path); - char *buf = git__malloc(len + 2); - cl_assert(buf); - - strncpy(buf, path, len + 2); - - git_fs_path_string_to_dir(buf, maxlen); - - cl_assert_equal_s(expected, buf); - - git__free(buf); -} - -/* convert paths to dirs */ -void test_path__07_path_to_dir(void) -{ - check_path_to_dir("", ""); - check_path_to_dir(".", "./"); - check_path_to_dir("./", "./"); - check_path_to_dir("a/", "a/"); - check_path_to_dir("ab", "ab/"); - /* make sure we try just under and just over an expansion that will - * require a realloc - */ - check_path_to_dir("abcdef", "abcdef/"); - check_path_to_dir("abcdefg", "abcdefg/"); - check_path_to_dir("abcdefgh", "abcdefgh/"); - check_path_to_dir("abcdefghi", "abcdefghi/"); - check_path_to_dir(REP1024("abcd") "/", REP1024("abcd") "/"); - check_path_to_dir(REP1024("abcd"), REP1024("abcd") "/"); - - check_string_to_dir("", 1, ""); - check_string_to_dir(".", 1, "."); - check_string_to_dir(".", 2, "./"); - check_string_to_dir(".", 3, "./"); - check_string_to_dir("abcd", 3, "abcd"); - check_string_to_dir("abcd", 4, "abcd"); - check_string_to_dir("abcd", 5, "abcd/"); - check_string_to_dir("abcd", 6, "abcd/"); -} - -/* join path to itself */ -void test_path__08_self_join(void) -{ - git_str path = GIT_STR_INIT; - size_t asize = 0; - - asize = path.asize; - cl_git_pass(git_str_sets(&path, "/foo")); - cl_assert_equal_s(path.ptr, "/foo"); - cl_assert(asize < path.asize); - - asize = path.asize; - cl_git_pass(git_str_joinpath(&path, path.ptr, "this is a new string")); - cl_assert_equal_s(path.ptr, "/foo/this is a new string"); - cl_assert(asize < path.asize); - - asize = path.asize; - cl_git_pass(git_str_joinpath(&path, path.ptr, "/grow the buffer, grow the buffer, grow the buffer")); - cl_assert_equal_s(path.ptr, "/foo/this is a new string/grow the buffer, grow the buffer, grow the buffer"); - cl_assert(asize < path.asize); - - git_str_dispose(&path); - cl_git_pass(git_str_sets(&path, "/foo/bar")); - - cl_git_pass(git_str_joinpath(&path, path.ptr + 4, "baz")); - cl_assert_equal_s(path.ptr, "/bar/baz"); - - asize = path.asize; - cl_git_pass(git_str_joinpath(&path, path.ptr + 4, "somethinglongenoughtorealloc")); - cl_assert_equal_s(path.ptr, "/baz/somethinglongenoughtorealloc"); - cl_assert(asize < path.asize); - - git_str_dispose(&path); -} - -static void check_percent_decoding(const char *expected_result, const char *input) -{ - git_str buf = GIT_STR_INIT; - - cl_git_pass(git__percent_decode(&buf, input)); - cl_assert_equal_s(expected_result, git_str_cstr(&buf)); - - git_str_dispose(&buf); -} - -void test_path__09_percent_decode(void) -{ - check_percent_decoding("abcd", "abcd"); - check_percent_decoding("a2%", "a2%"); - check_percent_decoding("a2%3", "a2%3"); - check_percent_decoding("a2%%3", "a2%%3"); - check_percent_decoding("a2%3z", "a2%3z"); - check_percent_decoding("a,", "a%2c"); - check_percent_decoding("a21", "a2%31"); - check_percent_decoding("a2%1", "a2%%31"); - check_percent_decoding("a bc ", "a%20bc%20"); - check_percent_decoding("Vicent Mart" "\355", "Vicent%20Mart%ED"); -} - -static void check_fromurl(const char *expected_result, const char *input, int should_fail) -{ - git_str buf = GIT_STR_INIT; - - assert(should_fail || expected_result); - - if (!should_fail) { - cl_git_pass(git_fs_path_fromurl(&buf, input)); - cl_assert_equal_s(expected_result, git_str_cstr(&buf)); - } else - cl_git_fail(git_fs_path_fromurl(&buf, input)); - - git_str_dispose(&buf); -} - -#ifdef GIT_WIN32 -#define ABS_PATH_MARKER "" -#else -#define ABS_PATH_MARKER "/" -#endif - -void test_path__10_fromurl(void) -{ - /* Failing cases */ - check_fromurl(NULL, "a", 1); - check_fromurl(NULL, "http:///c:/Temp%20folder/note.txt", 1); - check_fromurl(NULL, "file://c:/Temp%20folder/note.txt", 1); - check_fromurl(NULL, "file:////c:/Temp%20folder/note.txt", 1); - check_fromurl(NULL, "file:///", 1); - check_fromurl(NULL, "file:////", 1); - check_fromurl(NULL, "file://servername/c:/Temp%20folder/note.txt", 1); - - /* Passing cases */ - check_fromurl(ABS_PATH_MARKER "c:/Temp folder/note.txt", "file:///c:/Temp%20folder/note.txt", 0); - check_fromurl(ABS_PATH_MARKER "c:/Temp folder/note.txt", "file://localhost/c:/Temp%20folder/note.txt", 0); - check_fromurl(ABS_PATH_MARKER "c:/Temp+folder/note.txt", "file:///c:/Temp+folder/note.txt", 0); - check_fromurl(ABS_PATH_MARKER "a", "file:///a", 0); -} - -typedef struct { - int expect_idx; - int cancel_after; - char **expect; -} check_walkup_info; - -#define CANCEL_VALUE 1234 - -static int check_one_walkup_step(void *ref, const char *path) -{ - check_walkup_info *info = (check_walkup_info *)ref; - - if (!info->cancel_after) { - cl_assert_equal_s(info->expect[info->expect_idx], "[CANCEL]"); - return CANCEL_VALUE; - } - info->cancel_after--; - - cl_assert(info->expect[info->expect_idx] != NULL); - cl_assert_equal_s(info->expect[info->expect_idx], path); - info->expect_idx++; - - return 0; -} - -void test_path__11_walkup(void) -{ - git_str p = GIT_STR_INIT; - - char *expect[] = { - /* 1 */ "/a/b/c/d/e/", "/a/b/c/d/", "/a/b/c/", "/a/b/", "/a/", "/", NULL, - /* 2 */ "/a/b/c/d/e", "/a/b/c/d/", "/a/b/c/", "/a/b/", "/a/", "/", NULL, - /* 3 */ "/a/b/c/d/e", "/a/b/c/d/", "/a/b/c/", "/a/b/", "/a/", "/", NULL, - /* 4 */ "/a/b/c/d/e", "/a/b/c/d/", "/a/b/c/", "/a/b/", "/a/", "/", NULL, - /* 5 */ "/a/b/c/d/e", "/a/b/c/d/", "/a/b/c/", "/a/b/", NULL, - /* 6 */ "/a/b/c/d/e", "/a/b/c/d/", "/a/b/c/", "/a/b/", NULL, - /* 7 */ "this_is_a_path", "", NULL, - /* 8 */ "this_is_a_path/", "", NULL, - /* 9 */ "///a///b///c///d///e///", "///a///b///c///d///", "///a///b///c///", "///a///b///", "///a///", "///", NULL, - /* 10 */ "a/b/c/", "a/b/", "a/", "", NULL, - /* 11 */ "a/b/c", "a/b/", "a/", "", NULL, - /* 12 */ "a/b/c/", "a/b/", "a/", NULL, - /* 13 */ "", NULL, - /* 14 */ "/", NULL, - /* 15 */ NULL - }; - - char *root[] = { - /* 1 */ NULL, - /* 2 */ NULL, - /* 3 */ "/", - /* 4 */ "", - /* 5 */ "/a/b", - /* 6 */ "/a/b/", - /* 7 */ NULL, - /* 8 */ NULL, - /* 9 */ NULL, - /* 10 */ NULL, - /* 11 */ NULL, - /* 12 */ "a/", - /* 13 */ NULL, - /* 14 */ NULL, - }; - - int i, j; - check_walkup_info info; - - info.expect = expect; - info.cancel_after = -1; - - for (i = 0, j = 0; expect[i] != NULL; i++, j++) { - - git_str_sets(&p, expect[i]); - - info.expect_idx = i; - cl_git_pass( - git_fs_path_walk_up(&p, root[j], check_one_walkup_step, &info) - ); - - cl_assert_equal_s(p.ptr, expect[i]); - cl_assert(expect[info.expect_idx] == NULL); - i = info.expect_idx; - } - - git_str_dispose(&p); -} - -void test_path__11a_walkup_cancel(void) -{ - git_str p = GIT_STR_INIT; - int cancel[] = { 3, 2, 1, 0 }; - char *expect[] = { - "/a/b/c/d/e/", "/a/b/c/d/", "/a/b/c/", "[CANCEL]", NULL, - "/a/b/c/d/e", "/a/b/c/d/", "[CANCEL]", NULL, - "/a/b/c/d/e", "[CANCEL]", NULL, - "[CANCEL]", NULL, - NULL - }; - char *root[] = { NULL, NULL, "/", "", NULL }; - int i, j; - check_walkup_info info; - - info.expect = expect; - - for (i = 0, j = 0; expect[i] != NULL; i++, j++) { - - git_str_sets(&p, expect[i]); - - info.cancel_after = cancel[j]; - info.expect_idx = i; - - cl_assert_equal_i( - CANCEL_VALUE, - git_fs_path_walk_up(&p, root[j], check_one_walkup_step, &info) - ); - - /* skip to next run of expectations */ - while (expect[i] != NULL) i++; - } - - git_str_dispose(&p); -} - -void test_path__12_offset_to_path_root(void) -{ - cl_assert(git_fs_path_root("non/rooted/path") == -1); - cl_assert(git_fs_path_root("/rooted/path") == 0); - -#ifdef GIT_WIN32 - /* Windows specific tests */ - cl_assert(git_fs_path_root("C:non/rooted/path") == -1); - cl_assert(git_fs_path_root("C:/rooted/path") == 2); - cl_assert(git_fs_path_root("//computername/sharefolder/resource") == 14); - cl_assert(git_fs_path_root("//computername/sharefolder") == 14); - cl_assert(git_fs_path_root("//computername") == -1); -#endif -} - -#define NON_EXISTING_FILEPATH "i_hope_i_do_not_exist" - -void test_path__13_cannot_prettify_a_non_existing_file(void) -{ - git_str p = GIT_STR_INIT; - - cl_assert_equal_b(git_fs_path_exists(NON_EXISTING_FILEPATH), false); - cl_assert_equal_i(GIT_ENOTFOUND, git_fs_path_prettify(&p, NON_EXISTING_FILEPATH, NULL)); - cl_assert_equal_i(GIT_ENOTFOUND, git_fs_path_prettify(&p, NON_EXISTING_FILEPATH "/so-do-i", NULL)); - - git_str_dispose(&p); -} - -void test_path__14_apply_relative(void) -{ - git_str p = GIT_STR_INIT; - - cl_git_pass(git_str_sets(&p, "/this/is/a/base")); - - cl_git_pass(git_fs_path_apply_relative(&p, "../test")); - cl_assert_equal_s("/this/is/a/test", p.ptr); - - cl_git_pass(git_fs_path_apply_relative(&p, "../../the/./end")); - cl_assert_equal_s("/this/is/the/end", p.ptr); - - cl_git_pass(git_fs_path_apply_relative(&p, "./of/this/../the/string")); - cl_assert_equal_s("/this/is/the/end/of/the/string", p.ptr); - - cl_git_pass(git_fs_path_apply_relative(&p, "../../../../../..")); - cl_assert_equal_s("/this/", p.ptr); - - cl_git_pass(git_fs_path_apply_relative(&p, "../")); - cl_assert_equal_s("/", p.ptr); - - cl_git_fail(git_fs_path_apply_relative(&p, "../../..")); - - - cl_git_pass(git_str_sets(&p, "d:/another/test")); - - cl_git_pass(git_fs_path_apply_relative(&p, "../..")); - cl_assert_equal_s("d:/", p.ptr); - - cl_git_pass(git_fs_path_apply_relative(&p, "from/here/to/../and/./back/.")); - cl_assert_equal_s("d:/from/here/and/back/", p.ptr); - - - cl_git_pass(git_str_sets(&p, "https://my.url.com/test.git")); - - cl_git_pass(git_fs_path_apply_relative(&p, "../another.git")); - cl_assert_equal_s("https://my.url.com/another.git", p.ptr); - - cl_git_pass(git_fs_path_apply_relative(&p, "../full/path/url.patch")); - cl_assert_equal_s("https://my.url.com/full/path/url.patch", p.ptr); - - cl_git_pass(git_fs_path_apply_relative(&p, "..")); - cl_assert_equal_s("https://my.url.com/full/path/", p.ptr); - - cl_git_pass(git_fs_path_apply_relative(&p, "../../../")); - cl_assert_equal_s("https://", p.ptr); - - - cl_git_pass(git_str_sets(&p, "../../this/is/relative")); - - cl_git_pass(git_fs_path_apply_relative(&p, "../../preserves/the/prefix")); - cl_assert_equal_s("../../this/preserves/the/prefix", p.ptr); - - cl_git_pass(git_fs_path_apply_relative(&p, "../../../../that")); - cl_assert_equal_s("../../that", p.ptr); - - cl_git_pass(git_fs_path_apply_relative(&p, "../there")); - cl_assert_equal_s("../../there", p.ptr); - git_str_dispose(&p); -} - -static void assert_resolve_relative( - git_str *buf, const char *expected, const char *path) -{ - cl_git_pass(git_str_sets(buf, path)); - cl_git_pass(git_fs_path_resolve_relative(buf, 0)); - cl_assert_equal_s(expected, buf->ptr); -} - -void test_path__15_resolve_relative(void) -{ - git_str buf = GIT_STR_INIT; - - assert_resolve_relative(&buf, "", ""); - assert_resolve_relative(&buf, "", "."); - assert_resolve_relative(&buf, "", "./"); - assert_resolve_relative(&buf, "..", ".."); - assert_resolve_relative(&buf, "../", "../"); - assert_resolve_relative(&buf, "..", "./.."); - assert_resolve_relative(&buf, "../", "./../"); - assert_resolve_relative(&buf, "../", "../."); - assert_resolve_relative(&buf, "../", ".././"); - assert_resolve_relative(&buf, "../..", "../.."); - assert_resolve_relative(&buf, "../../", "../../"); - - assert_resolve_relative(&buf, "/", "/"); - assert_resolve_relative(&buf, "/", "/."); - - assert_resolve_relative(&buf, "", "a/.."); - assert_resolve_relative(&buf, "", "a/../"); - assert_resolve_relative(&buf, "", "a/../."); - - assert_resolve_relative(&buf, "/a", "/a"); - assert_resolve_relative(&buf, "/a/", "/a/."); - assert_resolve_relative(&buf, "/", "/a/../"); - assert_resolve_relative(&buf, "/", "/a/../."); - assert_resolve_relative(&buf, "/", "/a/.././"); - - assert_resolve_relative(&buf, "a", "a"); - assert_resolve_relative(&buf, "a/", "a/"); - assert_resolve_relative(&buf, "a/", "a/."); - assert_resolve_relative(&buf, "a/", "a/./"); - - assert_resolve_relative(&buf, "a/b", "a//b"); - assert_resolve_relative(&buf, "a/b/c", "a/b/c"); - assert_resolve_relative(&buf, "b/c", "./b/c"); - assert_resolve_relative(&buf, "a/c", "a/./c"); - assert_resolve_relative(&buf, "a/b/", "a/b/."); - - assert_resolve_relative(&buf, "/a/b/c", "///a/b/c"); - assert_resolve_relative(&buf, "/", "////"); - assert_resolve_relative(&buf, "/a", "///a"); - assert_resolve_relative(&buf, "/", "///."); - assert_resolve_relative(&buf, "/", "///a/.."); - - assert_resolve_relative(&buf, "../../path", "../../test//../././path"); - assert_resolve_relative(&buf, "../d", "a/b/../../../c/../d"); - - cl_git_pass(git_str_sets(&buf, "/..")); - cl_git_fail(git_fs_path_resolve_relative(&buf, 0)); - - cl_git_pass(git_str_sets(&buf, "/./..")); - cl_git_fail(git_fs_path_resolve_relative(&buf, 0)); - - cl_git_pass(git_str_sets(&buf, "/.//..")); - cl_git_fail(git_fs_path_resolve_relative(&buf, 0)); - - cl_git_pass(git_str_sets(&buf, "/../.")); - cl_git_fail(git_fs_path_resolve_relative(&buf, 0)); - - cl_git_pass(git_str_sets(&buf, "/../.././../a")); - cl_git_fail(git_fs_path_resolve_relative(&buf, 0)); - - cl_git_pass(git_str_sets(&buf, "////..")); - cl_git_fail(git_fs_path_resolve_relative(&buf, 0)); - - /* things that start with Windows network paths */ -#ifdef GIT_WIN32 - assert_resolve_relative(&buf, "//a/b/c", "//a/b/c"); - assert_resolve_relative(&buf, "//a/", "//a/b/.."); - assert_resolve_relative(&buf, "//a/b/c", "//a/Q/../b/x/y/../../c"); - - cl_git_pass(git_str_sets(&buf, "//a/b/../..")); - cl_git_fail(git_fs_path_resolve_relative(&buf, 0)); -#else - assert_resolve_relative(&buf, "/a/b/c", "//a/b/c"); - assert_resolve_relative(&buf, "/a/", "//a/b/.."); - assert_resolve_relative(&buf, "/a/b/c", "//a/Q/../b/x/y/../../c"); - assert_resolve_relative(&buf, "/", "//a/b/../.."); -#endif - - git_str_dispose(&buf); -} - -#define assert_common_dirlen(i, p, q) \ - cl_assert_equal_i((i), git_fs_path_common_dirlen((p), (q))); - -void test_path__16_resolve_relative(void) -{ - assert_common_dirlen(0, "", ""); - assert_common_dirlen(0, "", "bar.txt"); - assert_common_dirlen(0, "foo.txt", "bar.txt"); - assert_common_dirlen(0, "foo.txt", ""); - assert_common_dirlen(0, "foo/bar.txt", "bar/foo.txt"); - assert_common_dirlen(0, "foo/bar.txt", "../foo.txt"); - - assert_common_dirlen(1, "/one.txt", "/two.txt"); - assert_common_dirlen(4, "foo/one.txt", "foo/two.txt"); - assert_common_dirlen(5, "/foo/one.txt", "/foo/two.txt"); - - assert_common_dirlen(6, "a/b/c/foo.txt", "a/b/c/d/e/bar.txt"); - assert_common_dirlen(7, "/a/b/c/foo.txt", "/a/b/c/d/e/bar.txt"); -} - -static void fix_path(git_str *s) -{ -#ifndef GIT_WIN32 - GIT_UNUSED(s); -#else - char* c; - - for (c = s->ptr; *c; c++) { - if (*c == '/') - *c = '\\'; - } -#endif -} - -void test_path__find_exe_in_path(void) -{ - char *orig_path; - git_str sandbox_path = GIT_STR_INIT; - git_str new_path = GIT_STR_INIT, full_path = GIT_STR_INIT, - dummy_path = GIT_STR_INIT; - -#ifdef GIT_WIN32 - static const char *bogus_path_1 = "c:\\does\\not\\exist\\"; - static const char *bogus_path_2 = "e:\\non\\existent"; -#else - static const char *bogus_path_1 = "/this/path/does/not/exist/"; - static const char *bogus_path_2 = "/non/existent"; -#endif - - orig_path = cl_getenv("PATH"); - - git_str_puts(&sandbox_path, clar_sandbox_path()); - git_str_joinpath(&dummy_path, sandbox_path.ptr, "dummmmmmmy_libgit2_file"); - cl_git_rewritefile(dummy_path.ptr, "this is a dummy file"); - - fix_path(&sandbox_path); - fix_path(&dummy_path); - - cl_git_pass(git_str_printf(&new_path, "%s%c%s%c%s%c%s", - bogus_path_1, GIT_PATH_LIST_SEPARATOR, - orig_path, GIT_PATH_LIST_SEPARATOR, - sandbox_path.ptr, GIT_PATH_LIST_SEPARATOR, - bogus_path_2)); - - check_setenv("PATH", new_path.ptr); - - cl_git_fail_with(GIT_ENOTFOUND, git_fs_path_find_executable(&full_path, "this_file_does_not_exist")); - cl_git_pass(git_fs_path_find_executable(&full_path, "dummmmmmmy_libgit2_file")); - - cl_assert_equal_s(full_path.ptr, dummy_path.ptr); - - git_str_dispose(&full_path); - git_str_dispose(&new_path); - git_str_dispose(&dummy_path); - git_str_dispose(&sandbox_path); - git__free(orig_path); -} - -void test_path__validate_current_user_ownership(void) -{ - bool is_cur; - - cl_must_pass(p_mkdir("testdir", 0777)); - cl_git_pass(git_fs_path_owner_is_current_user(&is_cur, "testdir")); - cl_assert_equal_i(is_cur, 1); - - cl_git_rewritefile("testfile", "This is a test file."); - cl_git_pass(git_fs_path_owner_is_current_user(&is_cur, "testfile")); - cl_assert_equal_i(is_cur, 1); - -#ifdef GIT_WIN32 - cl_git_pass(git_fs_path_owner_is_current_user(&is_cur, "C:\\")); - cl_assert_equal_i(is_cur, 0); - - cl_git_fail(git_fs_path_owner_is_current_user(&is_cur, "c:\\path\\does\\not\\exist")); -#else - cl_git_pass(git_fs_path_owner_is_current_user(&is_cur, "/")); - cl_assert_equal_i(is_cur, (geteuid() == 0)); - - cl_git_fail(git_fs_path_owner_is_current_user(&is_cur, "/path/does/not/exist")); -#endif -} - -void test_path__dirlen(void) -{ - cl_assert_equal_sz(13, git_fs_path_dirlen("/foo/bar/asdf")); - cl_assert_equal_sz(13, git_fs_path_dirlen("/foo/bar/asdf/")); - cl_assert_equal_sz(13, git_fs_path_dirlen("/foo/bar/asdf//")); - cl_assert_equal_sz(3, git_fs_path_dirlen("foo////")); - cl_assert_equal_sz(3, git_fs_path_dirlen("foo")); - cl_assert_equal_sz(1, git_fs_path_dirlen("/")); - cl_assert_equal_sz(1, git_fs_path_dirlen("////")); - cl_assert_equal_sz(0, git_fs_path_dirlen("")); -} diff --git a/tests/util/path/core.c b/tests/util/path/core.c index 41d9b02040f..d1935a816a9 100644 --- a/tests/util/path/core.c +++ b/tests/util/path/core.c @@ -1,6 +1,784 @@ #include "clar_libgit2.h" +#include "futils.h" #include "fs_path.h" +#ifndef GIT_WIN32 +# include +#endif + +static char *path_save; + +void test_path_core__initialize(void) +{ + path_save = cl_getenv("PATH"); +} + +void test_path_core__cleanup(void) +{ + cl_setenv("PATH", path_save); + git__free(path_save); + path_save = NULL; +} + +static void +check_dirname(const char *A, const char *B) +{ + git_str dir = GIT_STR_INIT; + char *dir2; + + cl_assert(git_fs_path_dirname_r(&dir, A) >= 0); + cl_assert_equal_s(B, dir.ptr); + git_str_dispose(&dir); + + cl_assert((dir2 = git_fs_path_dirname(A)) != NULL); + cl_assert_equal_s(B, dir2); + git__free(dir2); +} + +static void +check_basename(const char *A, const char *B) +{ + git_str base = GIT_STR_INIT; + char *base2; + + cl_assert(git_fs_path_basename_r(&base, A) >= 0); + cl_assert_equal_s(B, base.ptr); + git_str_dispose(&base); + + cl_assert((base2 = git_fs_path_basename(A)) != NULL); + cl_assert_equal_s(B, base2); + git__free(base2); +} + +static void +check_joinpath(const char *path_a, const char *path_b, const char *expected_path) +{ + git_str joined_path = GIT_STR_INIT; + + cl_git_pass(git_str_joinpath(&joined_path, path_a, path_b)); + cl_assert_equal_s(expected_path, joined_path.ptr); + + git_str_dispose(&joined_path); +} + +static void +check_joinpath_n( + const char *path_a, + const char *path_b, + const char *path_c, + const char *path_d, + const char *expected_path) +{ + git_str joined_path = GIT_STR_INIT; + + cl_git_pass(git_str_join_n(&joined_path, '/', 4, + path_a, path_b, path_c, path_d)); + cl_assert_equal_s(expected_path, joined_path.ptr); + + git_str_dispose(&joined_path); +} + +static void check_setenv(const char* name, const char* value) +{ + char* check; + + cl_git_pass(cl_setenv(name, value)); + check = cl_getenv(name); + + if (value) + cl_assert_equal_s(value, check); + else + cl_assert(check == NULL); + + git__free(check); +} + +/* get the dirname of a path */ +void test_path_core__00_dirname(void) +{ + check_dirname(NULL, "."); + check_dirname("", "."); + check_dirname("a", "."); + check_dirname("/", "/"); + check_dirname("/usr", "/"); + check_dirname("/usr/", "/"); + check_dirname("/usr/lib", "/usr"); + check_dirname("/usr/lib/", "/usr"); + check_dirname("/usr/lib//", "/usr"); + check_dirname("usr/lib", "usr"); + check_dirname("usr/lib/", "usr"); + check_dirname("usr/lib//", "usr"); + check_dirname(".git/", "."); + + check_dirname(REP16("/abc"), REP15("/abc")); + +#ifdef GIT_WIN32 + check_dirname("C:/", "C:/"); + check_dirname("C:", "C:/"); + check_dirname("C:/path/", "C:/"); + check_dirname("C:/path", "C:/"); + check_dirname("//computername/", "//computername/"); + check_dirname("//computername", "//computername/"); + check_dirname("//computername/path/", "//computername/"); + check_dirname("//computername/path", "//computername/"); + check_dirname("//computername/sub/path/", "//computername/sub"); + check_dirname("//computername/sub/path", "//computername/sub"); +#endif +} + +/* get the base name of a path */ +void test_path_core__01_basename(void) +{ + check_basename(NULL, "."); + check_basename("", "."); + check_basename("a", "a"); + check_basename("/", "/"); + check_basename("/usr", "usr"); + check_basename("/usr/", "usr"); + check_basename("/usr/lib", "lib"); + check_basename("/usr/lib//", "lib"); + check_basename("usr/lib", "lib"); + + check_basename(REP16("/abc"), "abc"); + check_basename(REP1024("/abc"), "abc"); +} + +/* properly join path components */ +void test_path_core__05_joins(void) +{ + check_joinpath("", "", ""); + check_joinpath("", "a", "a"); + check_joinpath("", "/a", "/a"); + check_joinpath("a", "", "a/"); + check_joinpath("a", "/", "a/"); + check_joinpath("a", "b", "a/b"); + check_joinpath("/", "a", "/a"); + check_joinpath("/", "", "/"); + check_joinpath("/a", "/b", "/a/b"); + check_joinpath("/a", "/b/", "/a/b/"); + check_joinpath("/a/", "b/", "/a/b/"); + check_joinpath("/a/", "/b/", "/a/b/"); + + check_joinpath("/abcd", "/defg", "/abcd/defg"); + check_joinpath("/abcd", "/defg/", "/abcd/defg/"); + check_joinpath("/abcd/", "defg/", "/abcd/defg/"); + check_joinpath("/abcd/", "/defg/", "/abcd/defg/"); + + check_joinpath("/abcdefgh", "/12345678", "/abcdefgh/12345678"); + check_joinpath("/abcdefgh", "/12345678/", "/abcdefgh/12345678/"); + check_joinpath("/abcdefgh/", "12345678/", "/abcdefgh/12345678/"); + + check_joinpath(REP1024("aaaa"), "", REP1024("aaaa") "/"); + check_joinpath(REP1024("aaaa/"), "", REP1024("aaaa/")); + check_joinpath(REP1024("/aaaa"), "", REP1024("/aaaa") "/"); + + check_joinpath(REP1024("aaaa"), REP1024("bbbb"), + REP1024("aaaa") "/" REP1024("bbbb")); + check_joinpath(REP1024("/aaaa"), REP1024("/bbbb"), + REP1024("/aaaa") REP1024("/bbbb")); +} + +/* properly join path components for more than one path */ +void test_path_core__06_long_joins(void) +{ + check_joinpath_n("", "", "", "", ""); + check_joinpath_n("", "a", "", "", "a/"); + check_joinpath_n("a", "", "", "", "a/"); + check_joinpath_n("", "", "", "a", "a"); + check_joinpath_n("a", "b", "", "/c/d/", "a/b/c/d/"); + check_joinpath_n("a", "b", "", "/c/d", "a/b/c/d"); + check_joinpath_n("abcd", "efgh", "ijkl", "mnop", "abcd/efgh/ijkl/mnop"); + check_joinpath_n("abcd/", "efgh/", "ijkl/", "mnop/", "abcd/efgh/ijkl/mnop/"); + check_joinpath_n("/abcd/", "/efgh/", "/ijkl/", "/mnop/", "/abcd/efgh/ijkl/mnop/"); + + check_joinpath_n(REP1024("a"), REP1024("b"), REP1024("c"), REP1024("d"), + REP1024("a") "/" REP1024("b") "/" + REP1024("c") "/" REP1024("d")); + check_joinpath_n(REP1024("/a"), REP1024("/b"), REP1024("/c"), REP1024("/d"), + REP1024("/a") REP1024("/b") + REP1024("/c") REP1024("/d")); +} + + +static void +check_path_to_dir( + const char* path, + const char* expected) +{ + git_str tgt = GIT_STR_INIT; + + git_str_sets(&tgt, path); + cl_git_pass(git_fs_path_to_dir(&tgt)); + cl_assert_equal_s(expected, tgt.ptr); + + git_str_dispose(&tgt); +} + +static void +check_string_to_dir( + const char* path, + size_t maxlen, + const char* expected) +{ + size_t len = strlen(path); + char *buf = git__malloc(len + 2); + cl_assert(buf); + + strncpy(buf, path, len + 2); + + git_fs_path_string_to_dir(buf, maxlen); + + cl_assert_equal_s(expected, buf); + + git__free(buf); +} + +/* convert paths to dirs */ +void test_path_core__07_path_to_dir(void) +{ + check_path_to_dir("", ""); + check_path_to_dir(".", "./"); + check_path_to_dir("./", "./"); + check_path_to_dir("a/", "a/"); + check_path_to_dir("ab", "ab/"); + /* make sure we try just under and just over an expansion that will + * require a realloc + */ + check_path_to_dir("abcdef", "abcdef/"); + check_path_to_dir("abcdefg", "abcdefg/"); + check_path_to_dir("abcdefgh", "abcdefgh/"); + check_path_to_dir("abcdefghi", "abcdefghi/"); + check_path_to_dir(REP1024("abcd") "/", REP1024("abcd") "/"); + check_path_to_dir(REP1024("abcd"), REP1024("abcd") "/"); + + check_string_to_dir("", 1, ""); + check_string_to_dir(".", 1, "."); + check_string_to_dir(".", 2, "./"); + check_string_to_dir(".", 3, "./"); + check_string_to_dir("abcd", 3, "abcd"); + check_string_to_dir("abcd", 4, "abcd"); + check_string_to_dir("abcd", 5, "abcd/"); + check_string_to_dir("abcd", 6, "abcd/"); +} + +/* join path to itself */ +void test_path_core__08_self_join(void) +{ + git_str path = GIT_STR_INIT; + size_t asize = 0; + + asize = path.asize; + cl_git_pass(git_str_sets(&path, "/foo")); + cl_assert_equal_s(path.ptr, "/foo"); + cl_assert(asize < path.asize); + + asize = path.asize; + cl_git_pass(git_str_joinpath(&path, path.ptr, "this is a new string")); + cl_assert_equal_s(path.ptr, "/foo/this is a new string"); + cl_assert(asize < path.asize); + + asize = path.asize; + cl_git_pass(git_str_joinpath(&path, path.ptr, "/grow the buffer, grow the buffer, grow the buffer")); + cl_assert_equal_s(path.ptr, "/foo/this is a new string/grow the buffer, grow the buffer, grow the buffer"); + cl_assert(asize < path.asize); + + git_str_dispose(&path); + cl_git_pass(git_str_sets(&path, "/foo/bar")); + + cl_git_pass(git_str_joinpath(&path, path.ptr + 4, "baz")); + cl_assert_equal_s(path.ptr, "/bar/baz"); + + asize = path.asize; + cl_git_pass(git_str_joinpath(&path, path.ptr + 4, "somethinglongenoughtorealloc")); + cl_assert_equal_s(path.ptr, "/baz/somethinglongenoughtorealloc"); + cl_assert(asize < path.asize); + + git_str_dispose(&path); +} + +static void check_percent_decoding(const char *expected_result, const char *input) +{ + git_str buf = GIT_STR_INIT; + + cl_git_pass(git__percent_decode(&buf, input)); + cl_assert_equal_s(expected_result, git_str_cstr(&buf)); + + git_str_dispose(&buf); +} + +void test_path_core__09_percent_decode(void) +{ + check_percent_decoding("abcd", "abcd"); + check_percent_decoding("a2%", "a2%"); + check_percent_decoding("a2%3", "a2%3"); + check_percent_decoding("a2%%3", "a2%%3"); + check_percent_decoding("a2%3z", "a2%3z"); + check_percent_decoding("a,", "a%2c"); + check_percent_decoding("a21", "a2%31"); + check_percent_decoding("a2%1", "a2%%31"); + check_percent_decoding("a bc ", "a%20bc%20"); + check_percent_decoding("Vicent Mart" "\355", "Vicent%20Mart%ED"); +} + +static void check_fromurl(const char *expected_result, const char *input, int should_fail) +{ + git_str buf = GIT_STR_INIT; + + assert(should_fail || expected_result); + + if (!should_fail) { + cl_git_pass(git_fs_path_fromurl(&buf, input)); + cl_assert_equal_s(expected_result, git_str_cstr(&buf)); + } else + cl_git_fail(git_fs_path_fromurl(&buf, input)); + + git_str_dispose(&buf); +} + +#ifdef GIT_WIN32 +#define ABS_PATH_MARKER "" +#else +#define ABS_PATH_MARKER "/" +#endif + +void test_path_core__10_fromurl(void) +{ + /* Failing cases */ + check_fromurl(NULL, "a", 1); + check_fromurl(NULL, "http:///c:/Temp%20folder/note.txt", 1); + check_fromurl(NULL, "file://c:/Temp%20folder/note.txt", 1); + check_fromurl(NULL, "file:////c:/Temp%20folder/note.txt", 1); + check_fromurl(NULL, "file:///", 1); + check_fromurl(NULL, "file:////", 1); + check_fromurl(NULL, "file://servername/c:/Temp%20folder/note.txt", 1); + + /* Passing cases */ + check_fromurl(ABS_PATH_MARKER "c:/Temp folder/note.txt", "file:///c:/Temp%20folder/note.txt", 0); + check_fromurl(ABS_PATH_MARKER "c:/Temp folder/note.txt", "file://localhost/c:/Temp%20folder/note.txt", 0); + check_fromurl(ABS_PATH_MARKER "c:/Temp+folder/note.txt", "file:///c:/Temp+folder/note.txt", 0); + check_fromurl(ABS_PATH_MARKER "a", "file:///a", 0); +} + +typedef struct { + int expect_idx; + int cancel_after; + char **expect; +} check_walkup_info; + +#define CANCEL_VALUE 1234 + +static int check_one_walkup_step(void *ref, const char *path) +{ + check_walkup_info *info = (check_walkup_info *)ref; + + if (!info->cancel_after) { + cl_assert_equal_s(info->expect[info->expect_idx], "[CANCEL]"); + return CANCEL_VALUE; + } + info->cancel_after--; + + cl_assert(info->expect[info->expect_idx] != NULL); + cl_assert_equal_s(info->expect[info->expect_idx], path); + info->expect_idx++; + + return 0; +} + +void test_path_core__11_walkup(void) +{ + git_str p = GIT_STR_INIT; + + char *expect[] = { + /* 1 */ "/a/b/c/d/e/", "/a/b/c/d/", "/a/b/c/", "/a/b/", "/a/", "/", NULL, + /* 2 */ "/a/b/c/d/e", "/a/b/c/d/", "/a/b/c/", "/a/b/", "/a/", "/", NULL, + /* 3 */ "/a/b/c/d/e", "/a/b/c/d/", "/a/b/c/", "/a/b/", "/a/", "/", NULL, + /* 4 */ "/a/b/c/d/e", "/a/b/c/d/", "/a/b/c/", "/a/b/", "/a/", "/", NULL, + /* 5 */ "/a/b/c/d/e", "/a/b/c/d/", "/a/b/c/", "/a/b/", NULL, + /* 6 */ "/a/b/c/d/e", "/a/b/c/d/", "/a/b/c/", "/a/b/", NULL, + /* 7 */ "this_is_a_path", "", NULL, + /* 8 */ "this_is_a_path/", "", NULL, + /* 9 */ "///a///b///c///d///e///", "///a///b///c///d///", "///a///b///c///", "///a///b///", "///a///", "///", NULL, + /* 10 */ "a/b/c/", "a/b/", "a/", "", NULL, + /* 11 */ "a/b/c", "a/b/", "a/", "", NULL, + /* 12 */ "a/b/c/", "a/b/", "a/", NULL, + /* 13 */ "", NULL, + /* 14 */ "/", NULL, + /* 15 */ NULL + }; + + char *root[] = { + /* 1 */ NULL, + /* 2 */ NULL, + /* 3 */ "/", + /* 4 */ "", + /* 5 */ "/a/b", + /* 6 */ "/a/b/", + /* 7 */ NULL, + /* 8 */ NULL, + /* 9 */ NULL, + /* 10 */ NULL, + /* 11 */ NULL, + /* 12 */ "a/", + /* 13 */ NULL, + /* 14 */ NULL, + }; + + int i, j; + check_walkup_info info; + + info.expect = expect; + info.cancel_after = -1; + + for (i = 0, j = 0; expect[i] != NULL; i++, j++) { + + git_str_sets(&p, expect[i]); + + info.expect_idx = i; + cl_git_pass( + git_fs_path_walk_up(&p, root[j], check_one_walkup_step, &info) + ); + + cl_assert_equal_s(p.ptr, expect[i]); + cl_assert(expect[info.expect_idx] == NULL); + i = info.expect_idx; + } + + git_str_dispose(&p); +} + +void test_path_core__11a_walkup_cancel(void) +{ + git_str p = GIT_STR_INIT; + int cancel[] = { 3, 2, 1, 0 }; + char *expect[] = { + "/a/b/c/d/e/", "/a/b/c/d/", "/a/b/c/", "[CANCEL]", NULL, + "/a/b/c/d/e", "/a/b/c/d/", "[CANCEL]", NULL, + "/a/b/c/d/e", "[CANCEL]", NULL, + "[CANCEL]", NULL, + NULL + }; + char *root[] = { NULL, NULL, "/", "", NULL }; + int i, j; + check_walkup_info info; + + info.expect = expect; + + for (i = 0, j = 0; expect[i] != NULL; i++, j++) { + + git_str_sets(&p, expect[i]); + + info.cancel_after = cancel[j]; + info.expect_idx = i; + + cl_assert_equal_i( + CANCEL_VALUE, + git_fs_path_walk_up(&p, root[j], check_one_walkup_step, &info) + ); + + /* skip to next run of expectations */ + while (expect[i] != NULL) i++; + } + + git_str_dispose(&p); +} + +void test_path_core__12_offset_to_path_root(void) +{ + cl_assert(git_fs_path_root("non/rooted/path") == -1); + cl_assert(git_fs_path_root("/rooted/path") == 0); + +#ifdef GIT_WIN32 + /* Windows specific tests */ + cl_assert(git_fs_path_root("C:non/rooted/path") == -1); + cl_assert(git_fs_path_root("C:/rooted/path") == 2); + cl_assert(git_fs_path_root("//computername/sharefolder/resource") == 14); + cl_assert(git_fs_path_root("//computername/sharefolder") == 14); + cl_assert(git_fs_path_root("//computername") == -1); +#endif +} + +#define NON_EXISTING_FILEPATH "i_hope_i_do_not_exist" + +void test_path_core__13_cannot_prettify_a_non_existing_file(void) +{ + git_str p = GIT_STR_INIT; + + cl_assert_equal_b(git_fs_path_exists(NON_EXISTING_FILEPATH), false); + cl_assert_equal_i(GIT_ENOTFOUND, git_fs_path_prettify(&p, NON_EXISTING_FILEPATH, NULL)); + cl_assert_equal_i(GIT_ENOTFOUND, git_fs_path_prettify(&p, NON_EXISTING_FILEPATH "/so-do-i", NULL)); + + git_str_dispose(&p); +} + +void test_path_core__14_apply_relative(void) +{ + git_str p = GIT_STR_INIT; + + cl_git_pass(git_str_sets(&p, "/this/is/a/base")); + + cl_git_pass(git_fs_path_apply_relative(&p, "../test")); + cl_assert_equal_s("/this/is/a/test", p.ptr); + + cl_git_pass(git_fs_path_apply_relative(&p, "../../the/./end")); + cl_assert_equal_s("/this/is/the/end", p.ptr); + + cl_git_pass(git_fs_path_apply_relative(&p, "./of/this/../the/string")); + cl_assert_equal_s("/this/is/the/end/of/the/string", p.ptr); + + cl_git_pass(git_fs_path_apply_relative(&p, "../../../../../..")); + cl_assert_equal_s("/this/", p.ptr); + + cl_git_pass(git_fs_path_apply_relative(&p, "../")); + cl_assert_equal_s("/", p.ptr); + + cl_git_fail(git_fs_path_apply_relative(&p, "../../..")); + + + cl_git_pass(git_str_sets(&p, "d:/another/test")); + + cl_git_pass(git_fs_path_apply_relative(&p, "../..")); + cl_assert_equal_s("d:/", p.ptr); + + cl_git_pass(git_fs_path_apply_relative(&p, "from/here/to/../and/./back/.")); + cl_assert_equal_s("d:/from/here/and/back/", p.ptr); + + + cl_git_pass(git_str_sets(&p, "https://my.url.com/test.git")); + + cl_git_pass(git_fs_path_apply_relative(&p, "../another.git")); + cl_assert_equal_s("https://my.url.com/another.git", p.ptr); + + cl_git_pass(git_fs_path_apply_relative(&p, "../full/path/url.patch")); + cl_assert_equal_s("https://my.url.com/full/path/url.patch", p.ptr); + + cl_git_pass(git_fs_path_apply_relative(&p, "..")); + cl_assert_equal_s("https://my.url.com/full/path/", p.ptr); + + cl_git_pass(git_fs_path_apply_relative(&p, "../../../")); + cl_assert_equal_s("https://", p.ptr); + + + cl_git_pass(git_str_sets(&p, "../../this/is/relative")); + + cl_git_pass(git_fs_path_apply_relative(&p, "../../preserves/the/prefix")); + cl_assert_equal_s("../../this/preserves/the/prefix", p.ptr); + + cl_git_pass(git_fs_path_apply_relative(&p, "../../../../that")); + cl_assert_equal_s("../../that", p.ptr); + + cl_git_pass(git_fs_path_apply_relative(&p, "../there")); + cl_assert_equal_s("../../there", p.ptr); + git_str_dispose(&p); +} + +static void assert_resolve_relative( + git_str *buf, const char *expected, const char *path) +{ + cl_git_pass(git_str_sets(buf, path)); + cl_git_pass(git_fs_path_resolve_relative(buf, 0)); + cl_assert_equal_s(expected, buf->ptr); +} + +void test_path_core__15_resolve_relative(void) +{ + git_str buf = GIT_STR_INIT; + + assert_resolve_relative(&buf, "", ""); + assert_resolve_relative(&buf, "", "."); + assert_resolve_relative(&buf, "", "./"); + assert_resolve_relative(&buf, "..", ".."); + assert_resolve_relative(&buf, "../", "../"); + assert_resolve_relative(&buf, "..", "./.."); + assert_resolve_relative(&buf, "../", "./../"); + assert_resolve_relative(&buf, "../", "../."); + assert_resolve_relative(&buf, "../", ".././"); + assert_resolve_relative(&buf, "../..", "../.."); + assert_resolve_relative(&buf, "../../", "../../"); + + assert_resolve_relative(&buf, "/", "/"); + assert_resolve_relative(&buf, "/", "/."); + + assert_resolve_relative(&buf, "", "a/.."); + assert_resolve_relative(&buf, "", "a/../"); + assert_resolve_relative(&buf, "", "a/../."); + + assert_resolve_relative(&buf, "/a", "/a"); + assert_resolve_relative(&buf, "/a/", "/a/."); + assert_resolve_relative(&buf, "/", "/a/../"); + assert_resolve_relative(&buf, "/", "/a/../."); + assert_resolve_relative(&buf, "/", "/a/.././"); + + assert_resolve_relative(&buf, "a", "a"); + assert_resolve_relative(&buf, "a/", "a/"); + assert_resolve_relative(&buf, "a/", "a/."); + assert_resolve_relative(&buf, "a/", "a/./"); + + assert_resolve_relative(&buf, "a/b", "a//b"); + assert_resolve_relative(&buf, "a/b/c", "a/b/c"); + assert_resolve_relative(&buf, "b/c", "./b/c"); + assert_resolve_relative(&buf, "a/c", "a/./c"); + assert_resolve_relative(&buf, "a/b/", "a/b/."); + + assert_resolve_relative(&buf, "/a/b/c", "///a/b/c"); + assert_resolve_relative(&buf, "/", "////"); + assert_resolve_relative(&buf, "/a", "///a"); + assert_resolve_relative(&buf, "/", "///."); + assert_resolve_relative(&buf, "/", "///a/.."); + + assert_resolve_relative(&buf, "../../path", "../../test//../././path"); + assert_resolve_relative(&buf, "../d", "a/b/../../../c/../d"); + + cl_git_pass(git_str_sets(&buf, "/..")); + cl_git_fail(git_fs_path_resolve_relative(&buf, 0)); + + cl_git_pass(git_str_sets(&buf, "/./..")); + cl_git_fail(git_fs_path_resolve_relative(&buf, 0)); + + cl_git_pass(git_str_sets(&buf, "/.//..")); + cl_git_fail(git_fs_path_resolve_relative(&buf, 0)); + + cl_git_pass(git_str_sets(&buf, "/../.")); + cl_git_fail(git_fs_path_resolve_relative(&buf, 0)); + + cl_git_pass(git_str_sets(&buf, "/../.././../a")); + cl_git_fail(git_fs_path_resolve_relative(&buf, 0)); + + cl_git_pass(git_str_sets(&buf, "////..")); + cl_git_fail(git_fs_path_resolve_relative(&buf, 0)); + + /* things that start with Windows network paths */ +#ifdef GIT_WIN32 + assert_resolve_relative(&buf, "//a/b/c", "//a/b/c"); + assert_resolve_relative(&buf, "//a/", "//a/b/.."); + assert_resolve_relative(&buf, "//a/b/c", "//a/Q/../b/x/y/../../c"); + + cl_git_pass(git_str_sets(&buf, "//a/b/../..")); + cl_git_fail(git_fs_path_resolve_relative(&buf, 0)); +#else + assert_resolve_relative(&buf, "/a/b/c", "//a/b/c"); + assert_resolve_relative(&buf, "/a/", "//a/b/.."); + assert_resolve_relative(&buf, "/a/b/c", "//a/Q/../b/x/y/../../c"); + assert_resolve_relative(&buf, "/", "//a/b/../.."); +#endif + + git_str_dispose(&buf); +} + +#define assert_common_dirlen(i, p, q) \ + cl_assert_equal_i((i), git_fs_path_common_dirlen((p), (q))); + +void test_path_core__16_resolve_relative(void) +{ + assert_common_dirlen(0, "", ""); + assert_common_dirlen(0, "", "bar.txt"); + assert_common_dirlen(0, "foo.txt", "bar.txt"); + assert_common_dirlen(0, "foo.txt", ""); + assert_common_dirlen(0, "foo/bar.txt", "bar/foo.txt"); + assert_common_dirlen(0, "foo/bar.txt", "../foo.txt"); + + assert_common_dirlen(1, "/one.txt", "/two.txt"); + assert_common_dirlen(4, "foo/one.txt", "foo/two.txt"); + assert_common_dirlen(5, "/foo/one.txt", "/foo/two.txt"); + + assert_common_dirlen(6, "a/b/c/foo.txt", "a/b/c/d/e/bar.txt"); + assert_common_dirlen(7, "/a/b/c/foo.txt", "/a/b/c/d/e/bar.txt"); +} + +static void fix_path(git_str *s) +{ +#ifndef GIT_WIN32 + GIT_UNUSED(s); +#else + char* c; + + for (c = s->ptr; *c; c++) { + if (*c == '/') + *c = '\\'; + } +#endif +} + +void test_path_core__find_exe_in_path(void) +{ + char *orig_path; + git_str sandbox_path = GIT_STR_INIT; + git_str new_path = GIT_STR_INIT, full_path = GIT_STR_INIT, + dummy_path = GIT_STR_INIT; + +#ifdef GIT_WIN32 + static const char *bogus_path_1 = "c:\\does\\not\\exist\\"; + static const char *bogus_path_2 = "e:\\non\\existent"; +#else + static const char *bogus_path_1 = "/this/path/does/not/exist/"; + static const char *bogus_path_2 = "/non/existent"; +#endif + + orig_path = cl_getenv("PATH"); + + git_str_puts(&sandbox_path, clar_sandbox_path()); + git_str_joinpath(&dummy_path, sandbox_path.ptr, "dummmmmmmy_libgit2_file"); + cl_git_rewritefile(dummy_path.ptr, "this is a dummy file"); + + fix_path(&sandbox_path); + fix_path(&dummy_path); + + cl_git_pass(git_str_printf(&new_path, "%s%c%s%c%s%c%s", + bogus_path_1, GIT_PATH_LIST_SEPARATOR, + orig_path, GIT_PATH_LIST_SEPARATOR, + sandbox_path.ptr, GIT_PATH_LIST_SEPARATOR, + bogus_path_2)); + + check_setenv("PATH", new_path.ptr); + + cl_git_fail_with(GIT_ENOTFOUND, git_fs_path_find_executable(&full_path, "this_file_does_not_exist")); + cl_git_pass(git_fs_path_find_executable(&full_path, "dummmmmmmy_libgit2_file")); + + cl_assert_equal_s(full_path.ptr, dummy_path.ptr); + + git_str_dispose(&full_path); + git_str_dispose(&new_path); + git_str_dispose(&dummy_path); + git_str_dispose(&sandbox_path); + git__free(orig_path); +} + +void test_path_core__validate_current_user_ownership(void) +{ + bool is_cur; + + cl_must_pass(p_mkdir("testdir", 0777)); + cl_git_pass(git_fs_path_owner_is_current_user(&is_cur, "testdir")); + cl_assert_equal_i(is_cur, 1); + + cl_git_rewritefile("testfile", "This is a test file."); + cl_git_pass(git_fs_path_owner_is_current_user(&is_cur, "testfile")); + cl_assert_equal_i(is_cur, 1); + +#ifdef GIT_WIN32 + cl_git_pass(git_fs_path_owner_is_current_user(&is_cur, "C:\\")); + cl_assert_equal_i(is_cur, 0); + + cl_git_fail(git_fs_path_owner_is_current_user(&is_cur, "c:\\path\\does\\not\\exist")); +#else + cl_git_pass(git_fs_path_owner_is_current_user(&is_cur, "/")); + cl_assert_equal_i(is_cur, (geteuid() == 0)); + + cl_git_fail(git_fs_path_owner_is_current_user(&is_cur, "/path/does/not/exist")); +#endif +} + +void test_path_core__dirlen(void) +{ + cl_assert_equal_sz(13, git_fs_path_dirlen("/foo/bar/asdf")); + cl_assert_equal_sz(13, git_fs_path_dirlen("/foo/bar/asdf/")); + cl_assert_equal_sz(13, git_fs_path_dirlen("/foo/bar/asdf//")); + cl_assert_equal_sz(3, git_fs_path_dirlen("foo////")); + cl_assert_equal_sz(3, git_fs_path_dirlen("foo")); + cl_assert_equal_sz(1, git_fs_path_dirlen("/")); + cl_assert_equal_sz(1, git_fs_path_dirlen("////")); + cl_assert_equal_sz(0, git_fs_path_dirlen("")); +} + static void test_make_relative( const char *expected_path, const char *path, From bdf4d70a1333bed0de1728e4725b7620f8bf74f8 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 19 Feb 2024 07:08:39 -0800 Subject: [PATCH 498/608] util: update win32 p_realpath to canonicalize case The POSIX `realpath` function canonicalizes relative paths, symbolic links, and case (on case-insensitive filesystems). For example, on macOS, if you create some file `/private/tmp/FOO`, and you call `realpath("/tmp/foo")`, you get _the real path_ returned of `/private/tmp/FOO`. To emulate this behavior on win32, we call `GetFullPathName` to handle the relative to absolute path conversion, then call `GetLongPathName` to handle the case canonicalization. --- src/util/win32/posix_w32.c | 34 ++++++++++++++++++++++++++++------ tests/util/path/win32.c | 29 +++++++++++++++++++++++++++++ 2 files changed, 57 insertions(+), 6 deletions(-) diff --git a/src/util/win32/posix_w32.c b/src/util/win32/posix_w32.c index 3fec469a648..ace23200f59 100644 --- a/src/util/win32/posix_w32.c +++ b/src/util/win32/posix_w32.c @@ -787,13 +787,19 @@ int p_rmdir(const char *path) char *p_realpath(const char *orig_path, char *buffer) { git_win32_path orig_path_w, buffer_w; + DWORD long_len; if (git_win32_path_from_utf8(orig_path_w, orig_path) < 0) return NULL; - /* Note that if the path provided is a relative path, then the current directory + /* + * POSIX realpath performs two functions: first, it turns relative + * paths into absolute paths. For this, we need GetFullPathName. + * + * Note that if the path provided is a relative path, then the current directory * is used to resolve the path -- which is a concurrency issue because the current - * directory is a process-wide variable. */ + * directory is a process-wide variable. + */ if (!GetFullPathNameW(orig_path_w, GIT_WIN_PATH_UTF16, buffer_w, NULL)) { if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) errno = ENAMETOOLONG; @@ -803,9 +809,26 @@ char *p_realpath(const char *orig_path, char *buffer) return NULL; } - /* The path must exist. */ - if (GetFileAttributesW(buffer_w) == INVALID_FILE_ATTRIBUTES) { - errno = ENOENT; + /* + * Then, the path is canonicalized. eg, on macOS, + * "/TMP" -> "/private/tmp". For this, we need GetLongPathName. + */ + if ((long_len = GetLongPathNameW(buffer_w, buffer_w, GIT_WIN_PATH_UTF16)) == 0) { + DWORD error = GetLastError(); + + if (error == ERROR_FILE_NOT_FOUND || + error == ERROR_PATH_NOT_FOUND) + errno = ENOENT; + else if (error == ERROR_ACCESS_DENIED) + errno = EPERM; + else + errno = EINVAL; + + return NULL; + } + + if (long_len > GIT_WIN_PATH_UTF16) { + errno = ENAMETOOLONG; return NULL; } @@ -821,7 +844,6 @@ char *p_realpath(const char *orig_path, char *buffer) return NULL; git_fs_path_mkposix(buffer); - return buffer; } diff --git a/tests/util/path/win32.c b/tests/util/path/win32.c index 1aaf6867a26..09a5a8ba881 100644 --- a/tests/util/path/win32.c +++ b/tests/util/path/win32.c @@ -280,3 +280,32 @@ void test_path_win32__8dot3_name(void) git__free(shortname); #endif } + +void test_path_win32__realpath(void) +{ +#ifdef GIT_WIN32 + git_str expected = GIT_STR_INIT; + char result[GIT_PATH_MAX]; + + /* Ensure relative paths become absolute */ + cl_must_pass(git_str_joinpath(&expected, clar_sandbox_path(), "abcdef")); + cl_must_pass(p_mkdir("abcdef", 0777)); + cl_assert(p_realpath("./abcdef", result) != NULL); + cl_assert_equal_s(expected.ptr, result); + + /* Ensure case is canonicalized */ + git_str_clear(&expected); + cl_must_pass(git_str_joinpath(&expected, clar_sandbox_path(), "FOO")); + cl_must_pass(p_mkdir("FOO", 0777)); + cl_assert(p_realpath("foo", result) != NULL); + cl_assert_equal_s(expected.ptr, result); + + cl_assert(p_realpath("nonexistent", result) == NULL); + cl_assert_equal_i(ENOENT, errno); + + git_str_dispose(&expected); + + p_rmdir("abcdef"); + p_rmdir("FOO"); +#endif +} From 57870e9f4d21791d3b62166f5b9b0a67641de942 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 19 Feb 2024 09:04:39 -0800 Subject: [PATCH 499/608] util: clean up test resources in the sandbox Ensure that we clean up cruft that we create for testing, so that future tests don't have troubles. --- tests/util/path/win32.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/tests/util/path/win32.c b/tests/util/path/win32.c index 09a5a8ba881..6f90b447dda 100644 --- a/tests/util/path/win32.c +++ b/tests/util/path/win32.c @@ -278,6 +278,10 @@ void test_path_win32__8dot3_name(void) cl_must_pass(p_mkdir(".bar", 0777)); cl_assert_equal_s("BAR~2", (shortname = git_win32_path_8dot3_name(".bar"))); git__free(shortname); + + p_rmdir(".foo"); + p_rmdir(".bar"); + p_unlink("bar~1"); #endif } From 19d52837e4b879f8cfd903dcfa8e1459f0f92cc6 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sun, 18 Feb 2024 00:06:35 +0000 Subject: [PATCH 500/608] repo: trim trailing slashes from safedir error message Our error messages should provide the literal path that users should add to their safe directory allowlist, which means it should not have a trailing slash. --- src/libgit2/repository.c | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index b2afc4f59d2..0a39e07c084 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -705,9 +705,12 @@ static int validate_ownership(git_repository *repo) goto done; if (!is_safe) { + size_t path_len = git_fs_path_is_root(path) ? + strlen(path) : git_fs_path_dirlen(path); + git_error_set(GIT_ERROR_CONFIG, - "repository path '%s' is not owned by current user", - path); + "repository path '%.*s' is not owned by current user", + (int)min(path_len, INT_MAX), path); error = GIT_EOWNER; } From d970934b29ebad813de9b378f246015df6801da8 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sun, 18 Feb 2024 00:39:26 +0000 Subject: [PATCH 501/608] repo: test that '%(prefix)/' safe.directory succeeds Ensure that we can support safe.directory entries that are prefixed with '%(prefix)/'. --- tests/libgit2/repo/open.c | 66 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 66 insertions(+) diff --git a/tests/libgit2/repo/open.c b/tests/libgit2/repo/open.c index 9c0bfde7b57..595440a68dd 100644 --- a/tests/libgit2/repo/open.c +++ b/tests/libgit2/repo/open.c @@ -779,3 +779,69 @@ void test_repo_open__can_reset_safe_directory_list(void) git_str_dispose(&config_filename); git_str_dispose(&config_data); } + +void test_repo_open__can_handle_prefixed_safe_paths(void) +{ + git_repository *repo; + git_str config_path = GIT_STR_INIT, + config_filename = GIT_STR_INIT, + config_data = GIT_STR_INIT; + + cl_git_pass(git_libgit2_opts(GIT_OPT_SET_OWNER_VALIDATION, 1)); + + cl_fixture_sandbox("empty_standard_repo"); + cl_git_pass(cl_rename("empty_standard_repo/.gitted", "empty_standard_repo/.git")); + + git_fs_path__set_owner(GIT_FS_PATH_OWNER_OTHER); + cl_git_fail_with(GIT_EOWNER, git_repository_open(&repo, "empty_standard_repo")); + + /* Add safe.directory options to the global configuration */ + git_str_joinpath(&config_path, clar_sandbox_path(), "__global_config"); + cl_must_pass(p_mkdir(config_path.ptr, 0777)); + git_libgit2_opts(GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, config_path.ptr); + + git_str_joinpath(&config_filename, config_path.ptr, ".gitconfig"); + + /* + * Using "%(prefix)/" becomes "%(prefix)//tmp/foo" - so + * "%(prefix)/" is stripped and means the literal path + * follows. + */ + git_str_clear(&config_data); + git_str_printf(&config_data, + "[foo]\n" \ + "\tbar = Foobar\n" \ + "\tbaz = Baz!\n" \ + "[safe]\n" \ + "\tdirectory = %%(prefix)/%s/%s\n" \ + "[bar]\n" \ + "\tfoo = barfoo\n", + clar_sandbox_path(), "empty_standard_repo"); + cl_git_rewritefile(config_filename.ptr, config_data.ptr); + + cl_git_pass(git_repository_open(&repo, "empty_standard_repo")); + git_repository_free(repo); + + /* + * Using "%(prefix)" becomes "%(prefix)/tmp/foo" - so it's + * actually trying to look in the git prefix, for example, + * "/usr/local/tmp/foo", which we don't actually support. + */ + git_str_clear(&config_data); + git_str_printf(&config_data, + "[foo]\n" \ + "\tbar = Foobar\n" \ + "\tbaz = Baz!\n" \ + "[safe]\n" \ + "\tdirectory = %%(prefix)%s/%s\n" \ + "[bar]\n" \ + "\tfoo = barfoo\n", + clar_sandbox_path(), "empty_standard_repo"); + cl_git_rewritefile(config_filename.ptr, config_data.ptr); + + cl_git_fail_with(GIT_EOWNER, git_repository_open(&repo, "empty_standard_repo")); + + git_str_dispose(&config_path); + git_str_dispose(&config_filename); + git_str_dispose(&config_data); +} From 71309547ec602a9bd1a2c36d0bfc2b24f3a43cd8 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sun, 18 Feb 2024 00:40:44 +0000 Subject: [PATCH 502/608] repo: trim '%(prefix)/' from safedir on all platforms '%(prefix)/' as a leading path name is safe to strip on all platforms. It doesn't make sense to use on non-Windows, but supporting it there does allow us to easily dev/test. --- src/libgit2/repository.c | 32 +++++++++++++++++--------------- 1 file changed, 17 insertions(+), 15 deletions(-) diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index 0a39e07c084..372c43f5ea6 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -558,15 +558,14 @@ typedef struct { static int validate_ownership_cb(const git_config_entry *entry, void *payload) { validate_ownership_data *data = payload; + const char *test_path; if (strcmp(entry->value, "") == 0) { *data->is_safe = false; } else if (strcmp(entry->value, "*") == 0) { *data->is_safe = true; } else { - const char *test_path = entry->value; - - if (git_str_sets(&data->tmp, test_path) < 0 || + if (git_str_sets(&data->tmp, entry->value) < 0 || git_fs_path_to_dir(&data->tmp) < 0) return -1; @@ -575,20 +574,22 @@ static int validate_ownership_cb(const git_config_entry *entry, void *payload) * input path by adding a trailing backslash. * A trailing backslash on the input is not allowed. */ - if (strcmp(data->tmp.ptr, test_path) == 0) + if (strcmp(data->tmp.ptr, entry->value) == 0) return 0; -#ifdef GIT_WIN32 + test_path = data->tmp.ptr; + /* - * Git for Windows does some truly bizarre things with - * paths that start with a forward slash; and expects you - * to escape that with `%(prefix)`. This syntax generally - * means to add the prefix that Git was installed to -- eg - * `/usr/local` -- unless it's an absolute path, in which - * case the leading `%(prefix)/` is just removed. And Git - * for Windows expects you to use this syntax for absolute - * Unix-style paths (in "Git Bash" or Windows Subsystem for - * Linux). + * Git - and especially, Git for Windows - does some + * truly bizarre things with paths that start with a + * forward slash; and expects you to escape that with + * `%(prefix)`. This syntax generally means to add the + * prefix that Git was installed to (eg `/usr/local`) + * unless it's an absolute path, in which case the + * leading `%(prefix)/` is just removed. And Git for + * Windows expects you to use this syntax for absolute + * Unix-style paths (in "Git Bash" or Windows Subsystem + * for Linux). * * Worse, the behavior used to be that a leading `/` was * not absolute. It would indicate that Git for Windows @@ -603,12 +604,13 @@ static int validate_ownership_cb(const git_config_entry *entry, void *payload) */ if (strncmp(test_path, "%(prefix)//", strlen("%(prefix)//")) == 0) test_path += strlen("%(prefix)/"); +#ifdef GIT_WIN32 else if (strncmp(test_path, "//", 2) == 0 && strncmp(test_path, "//wsl.localhost/", strlen("//wsl.localhost/")) != 0) test_path++; #endif - if (strcmp(data->tmp.ptr, data->repo_path) == 0) + if (strcmp(test_path, data->repo_path) == 0) *data->is_safe = true; } From b19a6a1582c626a2253ad232b087542f10c3cb62 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sun, 18 Feb 2024 14:40:26 +0000 Subject: [PATCH 503/608] repo: refactor safe directory tests Provide a helper method in the tests to set up the safe.directory configuration for a normal and bare repository to avoid some copy/pasta. (Some copypasta will remain, since there's customizations to the file that are not trivially abstractable.) --- tests/libgit2/repo/open.c | 260 +++++++++++++++----------------------- 1 file changed, 100 insertions(+), 160 deletions(-) diff --git a/tests/libgit2/repo/open.c b/tests/libgit2/repo/open.c index 595440a68dd..7719bbd1b82 100644 --- a/tests/libgit2/repo/open.c +++ b/tests/libgit2/repo/open.c @@ -533,15 +533,21 @@ void test_repo_open__validates_bare_repo_ownership(void) cl_git_fail_with(GIT_EOWNER, git_repository_open(&repo, "testrepo.git")); } -void test_repo_open__can_allowlist_dirs_with_problematic_ownership(void) +static int test_safe_path(const char *path) { git_repository *repo; git_str config_path = GIT_STR_INIT, config_filename = GIT_STR_INIT, config_data = GIT_STR_INIT; + int error; cl_git_pass(git_libgit2_opts(GIT_OPT_SET_OWNER_VALIDATION, 1)); + /* + * Sandbox the fixture, and ensure that when we fake an owner + * of "other" that the repository cannot be opened (and fails + * with `GIT_EOWNER`). + */ cl_fixture_sandbox("empty_standard_repo"); cl_git_pass(cl_rename("empty_standard_repo/.gitted", "empty_standard_repo/.git")); @@ -555,93 +561,35 @@ void test_repo_open__can_allowlist_dirs_with_problematic_ownership(void) git_str_joinpath(&config_filename, config_path.ptr, ".gitconfig"); - /* Test with incorrect exception (slash at the end) */ - git_str_printf(&config_data, - "[foo]\n" \ - "\tbar = Foobar\n" \ - "\tbaz = Baz!\n" \ - "[safe]\n" \ - "\tdirectory = /non/existent/path\n" \ - "\tdirectory = /\n" \ - "\tdirectory = c:\\\\temp\n" \ - "\tdirectory = %s/%s/\n" \ - "\tdirectory = /tmp\n" \ - "[bar]\n" \ - "\tfoo = barfoo\n", - clar_sandbox_path(), "empty_standard_repo"); - cl_git_rewritefile(config_filename.ptr, config_data.ptr); - cl_git_fail_with(GIT_EOWNER, git_repository_open(&repo, "empty_standard_repo")); - - /* Test with correct exception */ git_str_clear(&config_data); git_str_printf(&config_data, "[foo]\n" \ "\tbar = Foobar\n" \ "\tbaz = Baz!\n" \ "[safe]\n" \ - "\tdirectory = /non/existent/path\n" \ - "\tdirectory = /\n" \ - "\tdirectory = c:\\\\temp\n" \ - "\tdirectory = %s/%s\n" \ - "\tdirectory = /tmp\n" \ + "\tdirectory = %s\n" \ "[bar]\n" \ "\tfoo = barfoo\n", - clar_sandbox_path(), "empty_standard_repo"); + path); cl_git_rewritefile(config_filename.ptr, config_data.ptr); - cl_git_pass(git_repository_open(&repo, "empty_standard_repo")); + error = git_repository_open(&repo, "empty_standard_repo"); git_repository_free(repo); git_str_dispose(&config_path); git_str_dispose(&config_filename); git_str_dispose(&config_data); -} - -void test_repo_open__can_wildcard_allowlist_with_problematic_ownership(void) -{ - git_repository *repo; - git_str config_path = GIT_STR_INIT, config_filename = GIT_STR_INIT; - - cl_git_pass(git_libgit2_opts(GIT_OPT_SET_OWNER_VALIDATION, 1)); - - cl_fixture_sandbox("empty_standard_repo"); - cl_git_pass(cl_rename( - "empty_standard_repo/.gitted", "empty_standard_repo/.git")); - - git_fs_path__set_owner(GIT_FS_PATH_OWNER_OTHER); - cl_git_fail_with( - GIT_EOWNER, git_repository_open(&repo, "empty_standard_repo")); - - /* Add safe.directory options to the global configuration */ - git_str_joinpath(&config_path, clar_sandbox_path(), "__global_config"); - cl_must_pass(p_mkdir(config_path.ptr, 0777)); - git_libgit2_opts( - GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, - config_path.ptr); - - git_str_joinpath(&config_filename, config_path.ptr, ".gitconfig"); - - cl_git_rewritefile(config_filename.ptr, "[foo]\n" - "\tbar = Foobar\n" - "\tbaz = Baz!\n" - "[safe]\n" - "\tdirectory = *\n" - "[bar]\n" - "\tfoo = barfoo\n"); - - cl_git_pass(git_repository_open(&repo, "empty_standard_repo")); - git_repository_free(repo); - git_str_dispose(&config_path); - git_str_dispose(&config_filename); + return error; } -void test_repo_open__can_allowlist_bare_gitdir(void) +static int test_bare_safe_path(const char *path) { git_repository *repo; git_str config_path = GIT_STR_INIT, config_filename = GIT_STR_INIT, config_data = GIT_STR_INIT; + int error; cl_git_pass(git_libgit2_opts(GIT_OPT_SET_OWNER_VALIDATION, 1)); @@ -665,56 +613,114 @@ void test_repo_open__can_allowlist_bare_gitdir(void) "\tdirectory = /non/existent/path\n" \ "\tdirectory = /\n" \ "\tdirectory = c:\\\\temp\n" \ - "\tdirectory = %s/%s\n" \ + "\tdirectory = %s\n" \ "\tdirectory = /tmp\n" \ "[bar]\n" \ "\tfoo = barfoo\n", - clar_sandbox_path(), "testrepo.git"); + path); cl_git_rewritefile(config_filename.ptr, config_data.ptr); - cl_git_pass(git_repository_open(&repo, "testrepo.git")); + error = git_repository_open(&repo, "testrepo.git"); git_repository_free(repo); git_str_dispose(&config_path); git_str_dispose(&config_filename); git_str_dispose(&config_data); + + return error; } -void test_repo_open__can_wildcard_allowlist_bare_gitdir(void) +void test_repo_open__can_allowlist_dirs_with_problematic_ownership(void) { - git_repository *repo; - git_str config_path = GIT_STR_INIT, config_filename = GIT_STR_INIT; + git_str path = GIT_STR_INIT; - cl_git_pass(git_libgit2_opts(GIT_OPT_SET_OWNER_VALIDATION, 1)); + cl_git_pass(git_str_printf(&path, "%s/%s", + clar_sandbox_path(), "empty_standard_repo")); + cl_git_pass(test_safe_path(path.ptr)); + git_str_dispose(&path); +} - cl_fixture_sandbox("testrepo.git"); +void test_repo_open__safe_directory_fails_with_trailing_slash(void) +{ + git_str path = GIT_STR_INIT; - git_fs_path__set_owner(GIT_FS_PATH_OWNER_OTHER); - cl_git_fail_with( - GIT_EOWNER, git_repository_open(&repo, "testrepo.git")); + /* + * "/tmp/foo/" is not permitted; safe path must be specified + * as "/tmp/foo" + */ + cl_git_pass(git_str_printf(&path, "%s/%s/", + clar_sandbox_path(), "empty_standard_repo")); + cl_git_fail_with(GIT_EOWNER, test_safe_path(path.ptr)); + git_str_dispose(&path); +} - /* Add safe.directory options to the global configuration */ - git_str_joinpath(&config_path, clar_sandbox_path(), "__global_config"); - cl_must_pass(p_mkdir(config_path.ptr, 0777)); - git_libgit2_opts( - GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, - config_path.ptr); +void test_repo_open__can_wildcard_allowlist_with_problematic_ownership(void) +{ + cl_git_pass(test_safe_path("*")); +} - git_str_joinpath(&config_filename, config_path.ptr, ".gitconfig"); +void test_repo_open__can_allowlist_bare_gitdir(void) +{ + git_str path = GIT_STR_INIT; - cl_git_rewritefile(config_filename.ptr, "[foo]\n" - "\tbar = Foobar\n" - "\tbaz = Baz!\n" - "[safe]\n" - "\tdirectory = *\n" - "[bar]\n" - "\tfoo = barfoo\n"); + cl_git_pass(git_str_printf(&path, "%s/%s", + clar_sandbox_path(), "testrepo.git")); + cl_git_pass(test_bare_safe_path(path.ptr)); + git_str_dispose(&path); +} - cl_git_pass(git_repository_open(&repo, "testrepo.git")); - git_repository_free(repo); +void test_repo_open__can_wildcard_allowlist_bare_gitdir(void) +{ + cl_git_pass(test_bare_safe_path("*")); +} - git_str_dispose(&config_path); - git_str_dispose(&config_filename); +void test_repo_open__can_handle_prefixed_safe_paths(void) +{ +#ifndef GIT_WIN32 + git_str path = GIT_STR_INIT; + + /* + * Using "%(prefix)/" becomes "%(prefix)//tmp/foo" - so + * "%(prefix)/" is stripped and means the literal path + * follows. + */ + cl_git_pass(git_str_printf(&path, "%%(prefix)/%s/%s", + clar_sandbox_path(), "empty_standard_repo")); + cl_git_pass(test_safe_path(path.ptr)); + git_str_dispose(&path); +#endif +} + +void test_repo_open__prefixed_safe_paths_must_have_two_slashes(void) +{ + git_str path = GIT_STR_INIT; + + /* + * Using "%(prefix)" becomes "%(prefix)/tmp/foo" - so it's + * actually trying to look in the git prefix, for example, + * "/usr/local/tmp/foo", which we don't actually support. + */ + cl_git_pass(git_str_printf(&path, "%%(prefix)%s/%s", + clar_sandbox_path(), "empty_standard_repo")); + cl_git_fail_with(GIT_EOWNER, test_safe_path(path.ptr)); + git_str_dispose(&path); +} + +void test_repo_open__can_handle_win32_prefixed_safe_paths(void) +{ +#ifdef GIT_WIN32 + git_str path = GIT_STR_INIT; + + /* + * On Windows, we need %(prefix)///wsl.localhost/C:/foo/bar/... + * because we can't have nice things. + */ + cl_git_pass(git_str_printf(&path, + "%%(prefix)///localhost/%s/%s", + clar_sandbox_path(), "empty_standard_repo")); + cl_git_pass(test_safe_path(path.ptr)); + git_str_dispose(&path); +#endif } void test_repo_open__can_reset_safe_directory_list(void) @@ -779,69 +785,3 @@ void test_repo_open__can_reset_safe_directory_list(void) git_str_dispose(&config_filename); git_str_dispose(&config_data); } - -void test_repo_open__can_handle_prefixed_safe_paths(void) -{ - git_repository *repo; - git_str config_path = GIT_STR_INIT, - config_filename = GIT_STR_INIT, - config_data = GIT_STR_INIT; - - cl_git_pass(git_libgit2_opts(GIT_OPT_SET_OWNER_VALIDATION, 1)); - - cl_fixture_sandbox("empty_standard_repo"); - cl_git_pass(cl_rename("empty_standard_repo/.gitted", "empty_standard_repo/.git")); - - git_fs_path__set_owner(GIT_FS_PATH_OWNER_OTHER); - cl_git_fail_with(GIT_EOWNER, git_repository_open(&repo, "empty_standard_repo")); - - /* Add safe.directory options to the global configuration */ - git_str_joinpath(&config_path, clar_sandbox_path(), "__global_config"); - cl_must_pass(p_mkdir(config_path.ptr, 0777)); - git_libgit2_opts(GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, config_path.ptr); - - git_str_joinpath(&config_filename, config_path.ptr, ".gitconfig"); - - /* - * Using "%(prefix)/" becomes "%(prefix)//tmp/foo" - so - * "%(prefix)/" is stripped and means the literal path - * follows. - */ - git_str_clear(&config_data); - git_str_printf(&config_data, - "[foo]\n" \ - "\tbar = Foobar\n" \ - "\tbaz = Baz!\n" \ - "[safe]\n" \ - "\tdirectory = %%(prefix)/%s/%s\n" \ - "[bar]\n" \ - "\tfoo = barfoo\n", - clar_sandbox_path(), "empty_standard_repo"); - cl_git_rewritefile(config_filename.ptr, config_data.ptr); - - cl_git_pass(git_repository_open(&repo, "empty_standard_repo")); - git_repository_free(repo); - - /* - * Using "%(prefix)" becomes "%(prefix)/tmp/foo" - so it's - * actually trying to look in the git prefix, for example, - * "/usr/local/tmp/foo", which we don't actually support. - */ - git_str_clear(&config_data); - git_str_printf(&config_data, - "[foo]\n" \ - "\tbar = Foobar\n" \ - "\tbaz = Baz!\n" \ - "[safe]\n" \ - "\tdirectory = %%(prefix)%s/%s\n" \ - "[bar]\n" \ - "\tfoo = barfoo\n", - clar_sandbox_path(), "empty_standard_repo"); - cl_git_rewritefile(config_filename.ptr, config_data.ptr); - - cl_git_fail_with(GIT_EOWNER, git_repository_open(&repo, "empty_standard_repo")); - - git_str_dispose(&config_path); - git_str_dispose(&config_filename); - git_str_dispose(&config_data); -} From c1734b5ae42809a322977f9fe0dd26ccebd19a94 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sun, 18 Feb 2024 07:04:00 -0800 Subject: [PATCH 504/608] repo: test for safe.directory with unc paths On Windows, you may open a repo with UNC path format -- for example \\share\foo\bar, or as a git-style path, //share/foo/bar. In this world, Git for Windows expects you to translate this to $(prefix)//share/foo/bar. We can test for that by using the fact that local drives are exposed as hidden shares. For example, C:\Foo is //localhost/C$/Foo/. --- tests/libgit2/repo/open.c | 50 +++++++++++++++++++++++++++++++++------ 1 file changed, 43 insertions(+), 7 deletions(-) diff --git a/tests/libgit2/repo/open.c b/tests/libgit2/repo/open.c index 7719bbd1b82..f859838aeb3 100644 --- a/tests/libgit2/repo/open.c +++ b/tests/libgit2/repo/open.c @@ -709,17 +709,53 @@ void test_repo_open__prefixed_safe_paths_must_have_two_slashes(void) void test_repo_open__can_handle_win32_prefixed_safe_paths(void) { #ifdef GIT_WIN32 - git_str path = GIT_STR_INIT; + git_repository *repo; + git_str unc_path = GIT_STR_INIT, + config_path = GIT_STR_INIT, + config_filename = GIT_STR_INIT, + config_data = GIT_STR_INIT; + + cl_git_pass(git_libgit2_opts(GIT_OPT_SET_OWNER_VALIDATION, 1)); + + cl_fixture_sandbox("empty_standard_repo"); + cl_git_pass(cl_rename("empty_standard_repo/.gitted", "empty_standard_repo/.git")); /* - * On Windows, we need %(prefix)///wsl.localhost/C:/foo/bar/... - * because we can't have nice things. + * On Windows, we can generally map a local drive to a UNC path; + * for example C:\Foo\Bar becomes //localhost/C$/Foo/bar */ - cl_git_pass(git_str_printf(&path, - "%%(prefix)///localhost/%s/%s", + cl_git_pass(git_str_printf(&unc_path, "//localhost/%s/%s", clar_sandbox_path(), "empty_standard_repo")); - cl_git_pass(test_safe_path(path.ptr)); - git_str_dispose(&path); + + if (unc_path.ptr[13] != ':' || unc_path.ptr[14] != '/') + cl_skip(); + + unc_path.ptr[13] = '$'; + + git_fs_path__set_owner(GIT_FS_PATH_OWNER_OTHER); + cl_git_fail_with(GIT_EOWNER, git_repository_open(&repo, unc_path.ptr)); + + /* Add safe.directory options to the global configuration */ + git_str_joinpath(&config_path, clar_sandbox_path(), "__global_config"); + cl_must_pass(p_mkdir(config_path.ptr, 0777)); + git_libgit2_opts(GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, config_path.ptr); + + git_str_joinpath(&config_filename, config_path.ptr, ".gitconfig"); + + /* The blank resets our sandbox directory and opening fails */ + + git_str_printf(&config_data, + "[safe]\n\tdirectory = %%(prefix)/%s\n", + unc_path.ptr); + cl_git_rewritefile(config_filename.ptr, config_data.ptr); + + cl_git_pass(git_repository_open(&repo, unc_path.ptr)); + git_repository_free(repo); + + git_str_dispose(&config_path); + git_str_dispose(&config_filename); + git_str_dispose(&config_data); + git_str_dispose(&unc_path); #endif } From e9d55212890ed0cb695485aadac0a2cc4e89ecb3 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sun, 18 Feb 2024 07:47:26 -0800 Subject: [PATCH 505/608] repo: handle root paths properly for safe directories When doing directory name munging to remove trailing slashes, ensure that we do not remove the trailing slash from the path root, whether that's '/' or 'C:\'. --- src/libgit2/repository.c | 19 ++++++++++--------- 1 file changed, 10 insertions(+), 9 deletions(-) diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index 372c43f5ea6..6df9e63f2bb 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -565,17 +565,18 @@ static int validate_ownership_cb(const git_config_entry *entry, void *payload) } else if (strcmp(entry->value, "*") == 0) { *data->is_safe = true; } else { - if (git_str_sets(&data->tmp, entry->value) < 0 || - git_fs_path_to_dir(&data->tmp) < 0) + if (git_str_sets(&data->tmp, entry->value) < 0) return -1; - /* - * Ensure that `git_fs_path_to_dir` mutated the - * input path by adding a trailing backslash. - * A trailing backslash on the input is not allowed. - */ - if (strcmp(data->tmp.ptr, entry->value) == 0) - return 0; + if (!git_fs_path_is_root(data->tmp.ptr)) { + /* Input must not have trailing backslash. */ + if (!data->tmp.size || + data->tmp.ptr[data->tmp.size - 1] == '/') + return 0; + + if (git_fs_path_to_dir(&data->tmp) < 0) + return -1; + } test_path = data->tmp.ptr; From 9c31bd0358acfcafe45bb6a2fe5da6ce5d0d1f01 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 19 Feb 2024 07:23:33 -0800 Subject: [PATCH 506/608] repo: allow safe.directory to be a UNC path Recent versions of Git for Windows allow a sane UNC style path to be used directly in `safe.directory` (without needing the `%(prefix)` silliness). Match that behavior. --- src/libgit2/repository.c | 5 ---- tests/libgit2/repo/open.c | 53 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 53 insertions(+), 5 deletions(-) diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index 6df9e63f2bb..2c16808c7fc 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -605,11 +605,6 @@ static int validate_ownership_cb(const git_config_entry *entry, void *payload) */ if (strncmp(test_path, "%(prefix)//", strlen("%(prefix)//")) == 0) test_path += strlen("%(prefix)/"); -#ifdef GIT_WIN32 - else if (strncmp(test_path, "//", 2) == 0 && - strncmp(test_path, "//wsl.localhost/", strlen("//wsl.localhost/")) != 0) - test_path++; -#endif if (strcmp(test_path, data->repo_path) == 0) *data->is_safe = true; diff --git a/tests/libgit2/repo/open.c b/tests/libgit2/repo/open.c index f859838aeb3..a1acfae9022 100644 --- a/tests/libgit2/repo/open.c +++ b/tests/libgit2/repo/open.c @@ -759,6 +759,59 @@ void test_repo_open__can_handle_win32_prefixed_safe_paths(void) #endif } +void test_repo_open__can_handle_win32_unc_safe_paths(void) +{ +#ifdef GIT_WIN32 + git_repository *repo; + git_str unc_path = GIT_STR_INIT, + config_path = GIT_STR_INIT, + config_filename = GIT_STR_INIT, + config_data = GIT_STR_INIT; + + cl_git_pass(git_libgit2_opts(GIT_OPT_SET_OWNER_VALIDATION, 1)); + + cl_fixture_sandbox("empty_standard_repo"); + cl_git_pass(cl_rename("empty_standard_repo/.gitted", "empty_standard_repo/.git")); + + /* + * On Windows, we can generally map a local drive to a UNC path; + * for example C:\Foo\Bar becomes //localhost/C$/Foo/bar + */ + cl_git_pass(git_str_printf(&unc_path, "//localhost/%s/%s", + clar_sandbox_path(), "empty_standard_repo")); + + if (unc_path.ptr[13] != ':' || unc_path.ptr[14] != '/') + cl_skip(); + + unc_path.ptr[13] = '$'; + + git_fs_path__set_owner(GIT_FS_PATH_OWNER_OTHER); + cl_git_fail_with(GIT_EOWNER, git_repository_open(&repo, unc_path.ptr)); + + /* Add safe.directory options to the global configuration */ + git_str_joinpath(&config_path, clar_sandbox_path(), "__global_config"); + cl_must_pass(p_mkdir(config_path.ptr, 0777)); + git_libgit2_opts(GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, config_path.ptr); + + git_str_joinpath(&config_filename, config_path.ptr, ".gitconfig"); + + /* The blank resets our sandbox directory and opening fails */ + + git_str_printf(&config_data, + "[safe]\n\tdirectory = %s\n", + unc_path.ptr); + cl_git_rewritefile(config_filename.ptr, config_data.ptr); + + cl_git_pass(git_repository_open(&repo, unc_path.ptr)); + git_repository_free(repo); + + git_str_dispose(&config_path); + git_str_dispose(&config_filename); + git_str_dispose(&config_data); + git_str_dispose(&unc_path); +#endif +} + void test_repo_open__can_reset_safe_directory_list(void) { git_repository *repo; From c63eccc3e5d2fe4481270431c9fb3377f2949595 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Tue, 20 Feb 2024 09:56:26 +0000 Subject: [PATCH 507/608] revparse: ensure bare '@' is truly bare Support a revspec of '@' to mean 'HEAD', but ensure that it's at the start of the revspec. Previously we were erroneously allowing 'foo@' to mean 'HEAD' as well. Instead, 'foo@' should be rejected. --- src/libgit2/revparse.c | 6 ++++++ tests/libgit2/refs/revparse.c | 12 ++++++++++++ 2 files changed, 18 insertions(+) diff --git a/src/libgit2/revparse.c b/src/libgit2/revparse.c index 06d92f82bf2..bf8131aab79 100644 --- a/src/libgit2/revparse.c +++ b/src/libgit2/revparse.c @@ -817,6 +817,12 @@ static int revparse( base_rev = temp_object; break; } else if (spec[pos+1] == '\0') { + if (pos) { + git_error_set(GIT_ERROR_REFERENCE, "invalid revspec"); + error = GIT_EINVALIDSPEC; + goto cleanup; + } + spec = "HEAD"; identifier_len = 4; parsed = true; diff --git a/tests/libgit2/refs/revparse.c b/tests/libgit2/refs/revparse.c index d2f464840a0..3fe07811796 100644 --- a/tests/libgit2/refs/revparse.c +++ b/tests/libgit2/refs/revparse.c @@ -889,3 +889,15 @@ void test_refs_revparse__parses_at_head(void) test_id("@{0}", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", NULL, GIT_REVSPEC_SINGLE); test_id("@", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", NULL, GIT_REVSPEC_SINGLE); } + +void test_refs_revparse__rejects_bogus_at(void) +{ + git_repository *repo; + git_object *target; + + repo = cl_git_sandbox_init("testrepo.git"); + + cl_git_fail_with(GIT_EINVALIDSPEC, git_revparse_single(&target, repo, "foo@")); + + cl_git_sandbox_cleanup(); +} From af68b86baad93fa529e6fe412c2b129c80ddb0d8 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Tue, 20 Feb 2024 09:57:18 +0000 Subject: [PATCH 508/608] revspec: correct capitalization for error message --- src/libgit2/revparse.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/libgit2/revparse.c b/src/libgit2/revparse.c index bf8131aab79..08237628793 100644 --- a/src/libgit2/revparse.c +++ b/src/libgit2/revparse.c @@ -941,7 +941,7 @@ int git_revparse( * allowed. */ if (!git__strcmp(spec, "..")) { - git_error_set(GIT_ERROR_INVALID, "Invalid pattern '..'"); + git_error_set(GIT_ERROR_INVALID, "invalid pattern '..'"); return GIT_EINVALIDSPEC; } From 6e8c09a46f4136ada0601a75546f5b6bfb6298d0 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Tue, 20 Feb 2024 03:16:04 -0800 Subject: [PATCH 509/608] repo: ensure we can initialize win32 paths Given a win32 path, ensure that we can initialize it. This involves a posix-style path conversion at the beginning of our initialization. --- src/libgit2/repository.c | 2 ++ tests/libgit2/repo/init.c | 25 +++++++++++++++++++++++++ 2 files changed, 27 insertions(+) diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index b2afc4f59d2..737b96445a4 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -2676,6 +2676,8 @@ static int repo_init_directories( if (git_str_joinpath(repo_path, given_repo, add_dotgit ? GIT_DIR : "") < 0) return -1; + git_fs_path_mkposix(repo_path->ptr); + has_dotgit = (git__suffixcmp(repo_path->ptr, "/" GIT_DIR) == 0); if (has_dotgit) opts->flags |= GIT_REPOSITORY_INIT__HAS_DOTGIT; diff --git a/tests/libgit2/repo/init.c b/tests/libgit2/repo/init.c index d78ec063cd2..446ab735e4e 100644 --- a/tests/libgit2/repo/init.c +++ b/tests/libgit2/repo/init.c @@ -755,3 +755,28 @@ void test_repo_init__longpath(void) git_str_dispose(&path); #endif } + +void test_repo_init__absolute_path_with_backslashes(void) +{ +#ifdef GIT_WIN32 + git_repository_init_options initopts = GIT_REPOSITORY_INIT_OPTIONS_INIT; + git_str path = GIT_STR_INIT; + char *c; + + cl_set_cleanup(&cleanup_repository, "path"); + + cl_git_pass(git_str_joinpath(&path, clar_sandbox_path(), "path/to/newrepo")); + + for (c = path.ptr; *c; c++) { + if (*c == '/') + *c = '\\'; + } + + initopts.flags |= GIT_REPOSITORY_INIT_MKDIR | GIT_REPOSITORY_INIT_MKPATH; + + cl_git_pass(git_repository_init_ext(&g_repo, path.ptr, &initopts)); + git_str_dispose(&path); +#else + clar__skip(); +#endif +} From 267479dad5bfc8b028965e54a2625f3960f9d319 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Tue, 20 Feb 2024 11:31:22 +0000 Subject: [PATCH 510/608] http: support empty http.proxy config setting An empty `http.proxy` config setting should be treated like a missing `http.proxy` config setting. --- src/libgit2/transports/http.c | 2 +- src/libgit2/transports/winhttp.c | 2 +- tests/libgit2/online/fetch.c | 20 ++++++++++++++++++++ 3 files changed, 22 insertions(+), 2 deletions(-) diff --git a/src/libgit2/transports/http.c b/src/libgit2/transports/http.c index 8437674fcc9..00bfcb0b39b 100644 --- a/src/libgit2/transports/http.c +++ b/src/libgit2/transports/http.c @@ -334,7 +334,7 @@ static int lookup_proxy( return 0; } - if (!proxy || + if (!proxy || !*proxy || (error = git_net_url_parse_http(&transport->proxy.url, proxy)) < 0) goto done; diff --git a/src/libgit2/transports/winhttp.c b/src/libgit2/transports/winhttp.c index ae572c56d8e..031ff3f70b0 100644 --- a/src/libgit2/transports/winhttp.c +++ b/src/libgit2/transports/winhttp.c @@ -436,7 +436,7 @@ static int winhttp_stream_connect(winhttp_stream *s) GIT_ERROR_CHECK_ALLOC(proxy_url); } - if (proxy_url) { + if (proxy_url && *proxy_url) { git_str processed_url = GIT_STR_INIT; WINHTTP_PROXY_INFO proxy_info; wchar_t *proxy_wide; diff --git a/tests/libgit2/online/fetch.c b/tests/libgit2/online/fetch.c index d640eac1b6c..08a14c6317d 100644 --- a/tests/libgit2/online/fetch.c +++ b/tests/libgit2/online/fetch.c @@ -110,6 +110,26 @@ void test_online_fetch__fetch_twice(void) git_remote_free(remote); } +void test_online_fetch__fetch_with_empty_http_proxy(void) +{ + git_remote *remote; + git_config *config; + git_fetch_options opts = GIT_FETCH_OPTIONS_INIT; + + opts.proxy_opts.type = GIT_PROXY_AUTO; + + cl_git_pass(git_repository_config(&config, _repo)); + cl_git_pass(git_config_set_string(config, "http.proxy", "")); + + cl_git_pass(git_remote_create(&remote, _repo, "test", + "https://github.com/libgit2/TestGitRepository")); + cl_git_pass(git_remote_fetch(remote, NULL, &opts, NULL)); + + git_remote_disconnect(remote); + git_remote_free(remote); + git_config_free(config); +} + static int transferProgressCallback(const git_indexer_progress *stats, void *payload) { bool *invoked = (bool *)payload; From 4a1c2bd8ced01f4b95b924a7c0348b5684a726f7 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Tue, 20 Feb 2024 12:37:58 +0000 Subject: [PATCH 511/608] diff: fix test for SHA256 support in diff_from_buffer --- tests/libgit2/diff/parse.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/libgit2/diff/parse.c b/tests/libgit2/diff/parse.c index 0e5eb2809c8..59fc0280ed6 100644 --- a/tests/libgit2/diff/parse.c +++ b/tests/libgit2/diff/parse.c @@ -294,7 +294,7 @@ void test_diff_parse__eof_nl_missing(void) git_patch *ret_patch; git_diff_line *line; - cl_git_pass(git_diff_from_buffer(&diff, patch, strlen(patch))); + cl_git_pass(diff_from_buffer(&diff, patch, strlen(patch))); cl_git_pass(git_patch_from_diff(&ret_patch, diff, 0)); cl_assert((line = git_array_get(ret_patch->lines, 2)) != NULL); From 6b542105950b0d99b1d49d25d0db8f397e7e46e9 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Tue, 20 Feb 2024 13:42:38 +0000 Subject: [PATCH 512/608] merge: refactor merge tests for empty files treated as renames Don't munge the "trivial" tests, those are specifically about the "trivial" resolutions for git's tree merge. (For example, adding a file in a new branch and making no changes in the HEAD branch is something that can be handled _trivially_.) For tests of rename functionality, put them in the trees::rename tests. --- tests/libgit2/merge/trees/renames.c | 19 ++++++ tests/libgit2/merge/trees/trivial.c | 55 +++++------------- .../.gitted/logs/refs/heads/trivial-15 | 1 - .../.gitted/logs/refs/heads/trivial-15-branch | 2 - .../1d/6a96dd04ac7354ae6bb4ba24c514500fd0ec89 | Bin 279 -> 0 bytes .../merge-resolve/.gitted/objects/29 | Bin 0 -> 75 bytes .../48/320305de02310b9c4fd744243b9b0d1d5f11af | Bin 46 -> 0 bytes .../54/c9d15687fb4f56e08252662962d6d1dbc09d9d | 3 + .../57/16ca5987cbf97d6bb54920bea6adde242d87e6 | Bin 0 -> 19 bytes .../60/b12be2d2f57977ce83d8dfd32e2394ac1ba1a2 | Bin 0 -> 38 bytes .../67/06996f054c6af4fec7c77939d00e2f486dab4c | Bin 172 -> 0 bytes .../a6/5140d5ec9f47064f614ecf8e43776baa5c0c11 | Bin 0 -> 75 bytes .../ab/347abd8cda4a0e3b8bb42bb620c0c72c7df779 | Bin 0 -> 165 bytes .../bc/114411903fd2afaa4bb9b85ed13f27e37ac375 | Bin 0 -> 74 bytes .../c0/d1f321977d1c18e23a28c581fed6d17d0cc013 | Bin 273 -> 0 bytes .../c4/52c5eb5aacf204fc95a55d1eb9668736fecfb6 | Bin 163 -> 0 bytes .../c5/be2acabac675af81df8bb70400235af2a9c225 | 4 -- .../cd/d1cd02dbd164e9d18a644515bc2ca6551f13b4 | Bin 280 -> 0 bytes .../cd/edf9760406dc79e0c6a8899ce9f180ec2a23a0 | 2 + .../de/06afe070b65f94d7d791c39a6d389c58dda60d | Bin 0 -> 75 bytes .../e5/0a49f9558d09d4d3bfc108363bb24c127ed263 | Bin 0 -> 20 bytes .../ea/789495e0a72efadcd0f86a48f4c9ed435bb8a3 | 3 + .../.gitted/refs/heads/emptyfile_renames | 1 + .../refs/heads/emptyfile_renames-branch | 1 + .../.gitted/refs/heads/trivial-15 | 1 - .../.gitted/refs/heads/trivial-15-branch | 1 - 26 files changed, 45 insertions(+), 48 deletions(-) delete mode 100644 tests/resources/merge-resolve/.gitted/logs/refs/heads/trivial-15 delete mode 100644 tests/resources/merge-resolve/.gitted/logs/refs/heads/trivial-15-branch delete mode 100644 tests/resources/merge-resolve/.gitted/objects/1d/6a96dd04ac7354ae6bb4ba24c514500fd0ec89 create mode 100644 tests/resources/merge-resolve/.gitted/objects/29 delete mode 100644 tests/resources/merge-resolve/.gitted/objects/48/320305de02310b9c4fd744243b9b0d1d5f11af create mode 100644 tests/resources/merge-resolve/.gitted/objects/54/c9d15687fb4f56e08252662962d6d1dbc09d9d create mode 100644 tests/resources/merge-resolve/.gitted/objects/57/16ca5987cbf97d6bb54920bea6adde242d87e6 create mode 100644 tests/resources/merge-resolve/.gitted/objects/60/b12be2d2f57977ce83d8dfd32e2394ac1ba1a2 delete mode 100644 tests/resources/merge-resolve/.gitted/objects/67/06996f054c6af4fec7c77939d00e2f486dab4c create mode 100644 tests/resources/merge-resolve/.gitted/objects/a6/5140d5ec9f47064f614ecf8e43776baa5c0c11 create mode 100644 tests/resources/merge-resolve/.gitted/objects/ab/347abd8cda4a0e3b8bb42bb620c0c72c7df779 create mode 100644 tests/resources/merge-resolve/.gitted/objects/bc/114411903fd2afaa4bb9b85ed13f27e37ac375 delete mode 100644 tests/resources/merge-resolve/.gitted/objects/c0/d1f321977d1c18e23a28c581fed6d17d0cc013 delete mode 100644 tests/resources/merge-resolve/.gitted/objects/c4/52c5eb5aacf204fc95a55d1eb9668736fecfb6 delete mode 100644 tests/resources/merge-resolve/.gitted/objects/c5/be2acabac675af81df8bb70400235af2a9c225 delete mode 100644 tests/resources/merge-resolve/.gitted/objects/cd/d1cd02dbd164e9d18a644515bc2ca6551f13b4 create mode 100644 tests/resources/merge-resolve/.gitted/objects/cd/edf9760406dc79e0c6a8899ce9f180ec2a23a0 create mode 100644 tests/resources/merge-resolve/.gitted/objects/de/06afe070b65f94d7d791c39a6d389c58dda60d create mode 100644 tests/resources/merge-resolve/.gitted/objects/e5/0a49f9558d09d4d3bfc108363bb24c127ed263 create mode 100644 tests/resources/merge-resolve/.gitted/objects/ea/789495e0a72efadcd0f86a48f4c9ed435bb8a3 create mode 100644 tests/resources/merge-resolve/.gitted/refs/heads/emptyfile_renames create mode 100644 tests/resources/merge-resolve/.gitted/refs/heads/emptyfile_renames-branch delete mode 100644 tests/resources/merge-resolve/.gitted/refs/heads/trivial-15 delete mode 100644 tests/resources/merge-resolve/.gitted/refs/heads/trivial-15-branch diff --git a/tests/libgit2/merge/trees/renames.c b/tests/libgit2/merge/trees/renames.c index a27945ee071..9507b51bc9e 100644 --- a/tests/libgit2/merge/trees/renames.c +++ b/tests/libgit2/merge/trees/renames.c @@ -350,3 +350,22 @@ void test_merge_trees_renames__cache_recomputation(void) git_tree_free(our_tree); git__free(data); } + +void test_merge_trees_renames__emptyfile_renames(void) +{ + git_index *index; + git_merge_options *opts = NULL; + + struct merge_index_entry merge_index_entries[] = { + { 0100644, "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", 1, "bar" }, + { 0100644, "60b12be2d2f57977ce83d8dfd32e2394ac1ba1a2", 3, "bar" }, + { 0100644, "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", 0, "boo" }, + { 0100644, "e50a49f9558d09d4d3bfc108363bb24c127ed263", 0, "foo" }, + }; + + cl_git_pass(merge_trees_from_branches(&index, repo, + "emptyfile_renames", "emptyfile_renames-branch", + opts)); + cl_assert(merge_test_index(index, merge_index_entries, 4)); + git_index_free(index); +} diff --git a/tests/libgit2/merge/trees/trivial.c b/tests/libgit2/merge/trees/trivial.c index 7f9d918e806..287a53cfe7a 100644 --- a/tests/libgit2/merge/trees/trivial.c +++ b/tests/libgit2/merge/trees/trivial.c @@ -25,7 +25,7 @@ void test_merge_trees_trivial__cleanup(void) } -static int merge_trivial(git_index **index, const char *ours, const char *theirs, bool ancestor_use_parent) +static int merge_trivial(git_index **index, const char *ours, const char *theirs) { git_commit *our_commit, *their_commit, *ancestor_commit; git_tree *our_tree, *their_tree, *ancestor_tree; @@ -42,12 +42,8 @@ static int merge_trivial(git_index **index, const char *ours, const char *theirs cl_git_pass(git_reference_name_to_id(&their_oid, repo, branch_buf.ptr)); cl_git_pass(git_commit_lookup(&their_commit, repo, &their_oid)); - if (!ancestor_use_parent) { - cl_git_pass(git_merge_base(&ancestor_oid, repo, git_commit_id(our_commit), git_commit_id(their_commit))); - cl_git_pass(git_commit_lookup(&ancestor_commit, repo, &ancestor_oid)); - } else { - cl_git_pass(git_commit_parent(&ancestor_commit, their_commit, 0)); - } + cl_git_pass(git_merge_base(&ancestor_oid, repo, git_commit_id(our_commit), git_commit_id(their_commit))); + cl_git_pass(git_commit_lookup(&ancestor_commit, repo, &ancestor_oid)); cl_git_pass(git_commit_tree(&ancestor_tree, ancestor_commit)); cl_git_pass(git_commit_tree(&our_tree, our_commit)); @@ -88,7 +84,7 @@ void test_merge_trees_trivial__2alt(void) git_index *result; const git_index_entry *entry; - cl_git_pass(merge_trivial(&result, "trivial-2alt", "trivial-2alt-branch", false)); + cl_git_pass(merge_trivial(&result, "trivial-2alt", "trivial-2alt-branch")); cl_assert(entry = git_index_get_bypath(result, "new-in-branch.txt", 0)); cl_assert(git_index_reuc_entrycount(result) == 0); @@ -103,7 +99,7 @@ void test_merge_trees_trivial__3alt(void) git_index *result; const git_index_entry *entry; - cl_git_pass(merge_trivial(&result, "trivial-3alt", "trivial-3alt-branch", false)); + cl_git_pass(merge_trivial(&result, "trivial-3alt", "trivial-3alt-branch")); cl_assert(entry = git_index_get_bypath(result, "new-in-3alt.txt", 0)); cl_assert(git_index_reuc_entrycount(result) == 0); @@ -118,7 +114,7 @@ void test_merge_trees_trivial__4(void) git_index *result; const git_index_entry *entry; - cl_git_pass(merge_trivial(&result, "trivial-4", "trivial-4-branch", false)); + cl_git_pass(merge_trivial(&result, "trivial-4", "trivial-4-branch")); cl_assert((entry = git_index_get_bypath(result, "new-and-different.txt", 0)) == NULL); cl_assert(git_index_reuc_entrycount(result) == 0); @@ -136,7 +132,7 @@ void test_merge_trees_trivial__5alt_1(void) git_index *result; const git_index_entry *entry; - cl_git_pass(merge_trivial(&result, "trivial-5alt-1", "trivial-5alt-1-branch", false)); + cl_git_pass(merge_trivial(&result, "trivial-5alt-1", "trivial-5alt-1-branch")); cl_assert(entry = git_index_get_bypath(result, "new-and-same.txt", 0)); cl_assert(git_index_reuc_entrycount(result) == 0); @@ -151,7 +147,7 @@ void test_merge_trees_trivial__5alt_2(void) git_index *result; const git_index_entry *entry; - cl_git_pass(merge_trivial(&result, "trivial-5alt-2", "trivial-5alt-2-branch", false)); + cl_git_pass(merge_trivial(&result, "trivial-5alt-2", "trivial-5alt-2-branch")); cl_assert(entry = git_index_get_bypath(result, "modified-to-same.txt", 0)); cl_assert(git_index_reuc_entrycount(result) == 0); @@ -167,7 +163,7 @@ void test_merge_trees_trivial__6(void) const git_index_entry *entry; const git_index_reuc_entry *reuc; - cl_git_pass(merge_trivial(&result, "trivial-6", "trivial-6-branch", false)); + cl_git_pass(merge_trivial(&result, "trivial-6", "trivial-6-branch")); cl_assert((entry = git_index_get_bypath(result, "removed-in-both.txt", 0)) == NULL); cl_assert(git_index_reuc_entrycount(result) == 1); @@ -185,7 +181,7 @@ void test_merge_trees_trivial__8(void) const git_index_entry *entry; const git_index_reuc_entry *reuc; - cl_git_pass(merge_trivial(&result, "trivial-8", "trivial-8-branch", false)); + cl_git_pass(merge_trivial(&result, "trivial-8", "trivial-8-branch")); cl_assert((entry = git_index_get_bypath(result, "removed-in-8.txt", 0)) == NULL); @@ -203,7 +199,7 @@ void test_merge_trees_trivial__7(void) git_index *result; const git_index_entry *entry; - cl_git_pass(merge_trivial(&result, "trivial-7", "trivial-7-branch", false)); + cl_git_pass(merge_trivial(&result, "trivial-7", "trivial-7-branch")); cl_assert((entry = git_index_get_bypath(result, "removed-in-7.txt", 0)) == NULL); cl_assert(git_index_reuc_entrycount(result) == 0); @@ -222,7 +218,7 @@ void test_merge_trees_trivial__10(void) const git_index_entry *entry; const git_index_reuc_entry *reuc; - cl_git_pass(merge_trivial(&result, "trivial-10", "trivial-10-branch", false)); + cl_git_pass(merge_trivial(&result, "trivial-10", "trivial-10-branch")); cl_assert((entry = git_index_get_bypath(result, "removed-in-10-branch.txt", 0)) == NULL); @@ -240,7 +236,7 @@ void test_merge_trees_trivial__9(void) git_index *result; const git_index_entry *entry; - cl_git_pass(merge_trivial(&result, "trivial-9", "trivial-9-branch", false)); + cl_git_pass(merge_trivial(&result, "trivial-9", "trivial-9-branch")); cl_assert((entry = git_index_get_bypath(result, "removed-in-9-branch.txt", 0)) == NULL); cl_assert(git_index_reuc_entrycount(result) == 0); @@ -259,7 +255,7 @@ void test_merge_trees_trivial__13(void) const git_index_entry *entry; git_oid expected_oid; - cl_git_pass(merge_trivial(&result, "trivial-13", "trivial-13-branch", false)); + cl_git_pass(merge_trivial(&result, "trivial-13", "trivial-13-branch")); cl_assert(entry = git_index_get_bypath(result, "modified-in-13.txt", 0)); cl_git_pass(git_oid__fromstr(&expected_oid, "1cff9ec6a47a537380dedfdd17c9e76d74259a2b", GIT_OID_SHA1)); @@ -278,7 +274,7 @@ void test_merge_trees_trivial__14(void) const git_index_entry *entry; git_oid expected_oid; - cl_git_pass(merge_trivial(&result, "trivial-14", "trivial-14-branch", false)); + cl_git_pass(merge_trivial(&result, "trivial-14", "trivial-14-branch")); cl_assert(entry = git_index_get_bypath(result, "modified-in-14-branch.txt", 0)); cl_git_pass(git_oid__fromstr(&expected_oid, "26153a3ff3649b6c2bb652d3f06878c6e0a172f9", GIT_OID_SHA1)); @@ -296,7 +292,7 @@ void test_merge_trees_trivial__11(void) git_index *result; const git_index_entry *entry; - cl_git_pass(merge_trivial(&result, "trivial-11", "trivial-11-branch", false)); + cl_git_pass(merge_trivial(&result, "trivial-11", "trivial-11-branch")); cl_assert((entry = git_index_get_bypath(result, "modified-in-both.txt", 0)) == NULL); cl_assert(git_index_reuc_entrycount(result) == 0); @@ -308,22 +304,3 @@ void test_merge_trees_trivial__11(void) git_index_free(result); } - -/* 15: ancest:remote^, head:head, remote:remote = result:no merge */ -void test_merge_trees_trivial__15(void) -{ - git_index *result; - const git_index_entry *entry; - - /* Can't use merge_trivialfalsehere because a different ancestor is used. */ - cl_git_pass(merge_trivial(&result, "trivial-15", "trivial-15-branch", true)); - - cl_assert((entry = git_index_get_bypath(result, "another-new-empty-15.txt", GIT_INDEX_STAGE_NORMAL)) == NULL); - cl_assert((entry = git_index_get_bypath(result, "another-new-empty-15.txt", GIT_INDEX_STAGE_ANCESTOR))); - cl_assert((entry = git_index_get_bypath(result, "another-new-empty-15.txt", GIT_INDEX_STAGE_OURS)) == NULL); - cl_assert((entry = git_index_get_bypath(result, "another-new-empty-15.txt", GIT_INDEX_STAGE_THEIRS))); - cl_assert(merge_trivial_conflict_entrycount(result) == 2); - - git_index_free(result); -} - diff --git a/tests/resources/merge-resolve/.gitted/logs/refs/heads/trivial-15 b/tests/resources/merge-resolve/.gitted/logs/refs/heads/trivial-15 deleted file mode 100644 index c71411b5f11..00000000000 --- a/tests/resources/merge-resolve/.gitted/logs/refs/heads/trivial-15 +++ /dev/null @@ -1 +0,0 @@ -0000000000000000000000000000000000000000 c452c5eb5aacf204fc95a55d1eb9668736fecfb6 Gregory Herrero 1705326305 +0100 push diff --git a/tests/resources/merge-resolve/.gitted/logs/refs/heads/trivial-15-branch b/tests/resources/merge-resolve/.gitted/logs/refs/heads/trivial-15-branch deleted file mode 100644 index f85a1e96dd9..00000000000 --- a/tests/resources/merge-resolve/.gitted/logs/refs/heads/trivial-15-branch +++ /dev/null @@ -1,2 +0,0 @@ -0000000000000000000000000000000000000000 6706996f054c6af4fec7c77939d00e2f486dab4c Gregory Herrero 1705326302 +0100 push -6706996f054c6af4fec7c77939d00e2f486dab4c c5be2acabac675af81df8bb70400235af2a9c225 Gregory Herrero 1705326412 +0100 push diff --git a/tests/resources/merge-resolve/.gitted/objects/1d/6a96dd04ac7354ae6bb4ba24c514500fd0ec89 b/tests/resources/merge-resolve/.gitted/objects/1d/6a96dd04ac7354ae6bb4ba24c514500fd0ec89 deleted file mode 100644 index ec618090bdf04fd36e456a413c316a3e8ab4dca1..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 279 zcmV+y0qFjC0V^p=O;s>9H)k+3FfcPQQAo_oFUd$P(#=aP*G|#Ju#>6y3}`-K3(#yyOh9hSfPPi(a@)TI=n&J9|yLsoh+rHQksRaubV7 zQi}*`$j?j5$xJTE%u5F=y`uhL(?g2@DO=Gq<_YDCljTJBx*O7ai1V#(6;Mw#=Y#jm>Q5A6JwpRT>i+fSTp_0?Qy}vHCa*HmqIm^0(}VfFxV+4 dKIH3JZ<^*6VlXr?Ff%bxNJ=bXNZ6?T=+f89@^j5M?qAkZp0Y-I;UcJX hT7Eu5xY()4_R~LWv$uLG>|3_>o{Db!GXS}e9ew4xB)b3r literal 0 HcmV?d00001 diff --git a/tests/resources/merge-resolve/.gitted/objects/48/320305de02310b9c4fd744243b9b0d1d5f11af b/tests/resources/merge-resolve/.gitted/objects/48/320305de02310b9c4fd744243b9b0d1d5f11af deleted file mode 100644 index 25236a804aca5db4fbe9f17b32e88afeb1156a22..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 46 zcmb#A Cyb`|v diff --git a/tests/resources/merge-resolve/.gitted/objects/54/c9d15687fb4f56e08252662962d6d1dbc09d9d b/tests/resources/merge-resolve/.gitted/objects/54/c9d15687fb4f56e08252662962d6d1dbc09d9d new file mode 100644 index 00000000000..7e0555b3ff6 --- /dev/null +++ b/tests/resources/merge-resolve/.gitted/objects/54/c9d15687fb4f56e08252662962d6d1dbc09d9d @@ -0,0 +1,3 @@ +xNI +1W]/a&#~(:FQ\A۸Mtr8K0YK&Xkwə"$pPwjv\RhgI=ŘK*SDaM*z68 .^aG?` +q6Y83W^BMiQ \ No newline at end of file diff --git a/tests/resources/merge-resolve/.gitted/objects/57/16ca5987cbf97d6bb54920bea6adde242d87e6 b/tests/resources/merge-resolve/.gitted/objects/57/16ca5987cbf97d6bb54920bea6adde242d87e6 new file mode 100644 index 0000000000000000000000000000000000000000..cfc3920fb3f273219368fbff8644d599281d31f4 GIT binary patch literal 19 acmba@bd9V z+xM;eK=jc~)l01?6+$f)dD5?nDf2WDQjs8;iEzePCij<3Z`}*SX_g2nMU9cF&LK(V z#N`NC<_w_#tGImcYcv02x-@(GUo}%}{=B?lT;K5BEX!3#Y5T?F2`B~*0sSW+fIIYf a+x5RYuG{w5@^wHOishTEqk91!2~$WI3Rb58 diff --git a/tests/resources/merge-resolve/.gitted/objects/a6/5140d5ec9f47064f614ecf8e43776baa5c0c11 b/tests/resources/merge-resolve/.gitted/objects/a6/5140d5ec9f47064f614ecf8e43776baa5c0c11 new file mode 100644 index 0000000000000000000000000000000000000000..dc6cf6493cbe7b9ca4bccd8a6e212b4f7c385fa4 GIT binary patch literal 75 zcmV-R0JQ&j0V^p=O;s>6VlXr?Ff%bxNJ=bXcsBRZ>`fQ1IeT|&t}Bnaap*};@I|3_>o{Db!GXTtE9p+*ZB1!-N literal 0 HcmV?d00001 diff --git a/tests/resources/merge-resolve/.gitted/objects/ab/347abd8cda4a0e3b8bb42bb620c0c72c7df779 b/tests/resources/merge-resolve/.gitted/objects/ab/347abd8cda4a0e3b8bb42bb620c0c72c7df779 new file mode 100644 index 0000000000000000000000000000000000000000..d743a385c215b9e2a6b0073fb81115ba027e1ccd GIT binary patch literal 165 zcmV;W09yZe0i}*jssb?(gx@-+=)EBM?Ia-L#v6EnOuFN|MJ5s>Uf(F*z*<#(1x4jn z>;C|4!{6x4KrAs8mR>ICO0?w3N0m)XNG8PW0#QOq;+8sZ1Dwr~l*8c5Vv9qTK|778 zBWglYv}746l1PuSwhm`{rcQ8KTfMgp4m|1Go%mCH(>}L)1m$J0#yR6*C#S@u^X%Xs TXGC7pc4Zh1N^9Z;oFY*Th`UZ( literal 0 HcmV?d00001 diff --git a/tests/resources/merge-resolve/.gitted/objects/bc/114411903fd2afaa4bb9b85ed13f27e37ac375 b/tests/resources/merge-resolve/.gitted/objects/bc/114411903fd2afaa4bb9b85ed13f27e37ac375 new file mode 100644 index 0000000000000000000000000000000000000000..08941ff9538a4fea381f49ebd80332d417954c84 GIT binary patch literal 74 zcmV-Q0JZ;k0V^p=O;s>6VlXr?Ff%bxNXpM=csBRZ>`fQ1IeT|&t}Bnaap*};@I{Mj?>7TXPTRj!_En9m}MYsJK0M57_@mw7s{r~^~ literal 0 HcmV?d00001 diff --git a/tests/resources/merge-resolve/.gitted/objects/c0/d1f321977d1c18e23a28c581fed6d17d0cc013 b/tests/resources/merge-resolve/.gitted/objects/c0/d1f321977d1c18e23a28c581fed6d17d0cc013 deleted file mode 100644 index 4c20a212ade60c6f8046f0f5384bb06e145ce014..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 273 zcmV+s0q*{I0V^p=O;s>9vt%$dFfcPQQAjK;$5Ep%1PBLsVHGc5;`oqI?hAM z{rdDef8NUpvTr_GLlq}yB<7{3rs!to=_VB=<|Su>F;6I8oGd50*9~fRUTV2+ zYHmSErLLhVSnad9k7jSWc+J_nTXS7`)Qv+=dV(iH)fT1Z=9ghO{Ql!l+N8 zkTGc6^*G~R_FYU3NDhy&&R8ygh_N7J5=Yr3_6e($P%su?1|;*!D$i~?K&(uV5($wnQkS}f6h@CV zaLwRG2*M`6`@N~XsN9-NRjNr)yB(hsT0JG@ww#&ae Rrt9>X@?(d7Fh7HwP+9wjOc4M8 diff --git a/tests/resources/merge-resolve/.gitted/objects/c5/be2acabac675af81df8bb70400235af2a9c225 b/tests/resources/merge-resolve/.gitted/objects/c5/be2acabac675af81df8bb70400235af2a9c225 deleted file mode 100644 index 848f341c929..00000000000 --- a/tests/resources/merge-resolve/.gitted/objects/c5/be2acabac675af81df8bb70400235af2a9c225 +++ /dev/null @@ -1,4 +0,0 @@ -xAj1 @Ѭ} -CyFc(%,g2qno G->_o1P3 -ȒT -Qb*{}xJ@9SBܰ$I)/L 㟱v_n[Ժ`Z_prIC̄@=y;ݎn|;x*wY'IS \ No newline at end of file diff --git a/tests/resources/merge-resolve/.gitted/objects/cd/d1cd02dbd164e9d18a644515bc2ca6551f13b4 b/tests/resources/merge-resolve/.gitted/objects/cd/d1cd02dbd164e9d18a644515bc2ca6551f13b4 deleted file mode 100644 index d2385b8f2353863209a288ba2cd3edc4ef04cfad..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 280 zcmV+z0q6dB0V^p=O;s>9H)k+3FfcPQQAo_oFUd$P(#=aP*GO{^L*D ztK{>~g}6_UF=*TMIOAUST}%x~j)}3(ST29$SFD--<@UH>;hLAL e6Cd*RtT#<_EJ?4M_+j;{3r}q3#R3319++g`S&~%% diff --git a/tests/resources/merge-resolve/.gitted/objects/cd/edf9760406dc79e0c6a8899ce9f180ec2a23a0 b/tests/resources/merge-resolve/.gitted/objects/cd/edf9760406dc79e0c6a8899ce9f180ec2a23a0 new file mode 100644 index 00000000000..011b5b3e58c --- /dev/null +++ b/tests/resources/merge-resolve/.gitted/objects/cd/edf9760406dc79e0c6a8899ce9f180ec2a23a0 @@ -0,0 +1,2 @@ +xA +B1C] "n)B[U R^Mo3c:d chCi2FGkKzŖ:ײ<ǝ[Ҏj9 zB0X!58猒E;4~*uQo$D \ No newline at end of file diff --git a/tests/resources/merge-resolve/.gitted/objects/de/06afe070b65f94d7d791c39a6d389c58dda60d b/tests/resources/merge-resolve/.gitted/objects/de/06afe070b65f94d7d791c39a6d389c58dda60d new file mode 100644 index 0000000000000000000000000000000000000000..28567b624d1d3579d581e99f2fb49ea86add007c GIT binary patch literal 75 zcmV-R0JQ&j0V^p=O;s>6VlXr?Ff%bxNJ=bXNZ6?T=+f89@^j5M?qAkZp0Y-I;UcJX hT7EvmQ!dY+p}m|}F7H3cVP?I_N2u;nG61#K9B#?!BSruK literal 0 HcmV?d00001 diff --git a/tests/resources/merge-resolve/.gitted/objects/e5/0a49f9558d09d4d3bfc108363bb24c127ed263 b/tests/resources/merge-resolve/.gitted/objects/e5/0a49f9558d09d4d3bfc108363bb24c127ed263 new file mode 100644 index 0000000000000000000000000000000000000000..251c5dfb20c2b73cf789ff29345c8faa2ee433cc GIT binary patch literal 20 bcmbZ;uB[JrN9z)Vb!.Rj +: +$ŘK:!c \˃Fｷ[?Kby{; pA-wS[_i{WOGR \ No newline at end of file diff --git a/tests/resources/merge-resolve/.gitted/refs/heads/emptyfile_renames b/tests/resources/merge-resolve/.gitted/refs/heads/emptyfile_renames new file mode 100644 index 00000000000..89b4eea8ff5 --- /dev/null +++ b/tests/resources/merge-resolve/.gitted/refs/heads/emptyfile_renames @@ -0,0 +1 @@ +ea789495e0a72efadcd0f86a48f4c9ed435bb8a3 diff --git a/tests/resources/merge-resolve/.gitted/refs/heads/emptyfile_renames-branch b/tests/resources/merge-resolve/.gitted/refs/heads/emptyfile_renames-branch new file mode 100644 index 00000000000..1c6a9f4db55 --- /dev/null +++ b/tests/resources/merge-resolve/.gitted/refs/heads/emptyfile_renames-branch @@ -0,0 +1 @@ +ab347abd8cda4a0e3b8bb42bb620c0c72c7df779 diff --git a/tests/resources/merge-resolve/.gitted/refs/heads/trivial-15 b/tests/resources/merge-resolve/.gitted/refs/heads/trivial-15 deleted file mode 100644 index d6149eb8131..00000000000 --- a/tests/resources/merge-resolve/.gitted/refs/heads/trivial-15 +++ /dev/null @@ -1 +0,0 @@ -c452c5eb5aacf204fc95a55d1eb9668736fecfb6 diff --git a/tests/resources/merge-resolve/.gitted/refs/heads/trivial-15-branch b/tests/resources/merge-resolve/.gitted/refs/heads/trivial-15-branch deleted file mode 100644 index a255d1a3a95..00000000000 --- a/tests/resources/merge-resolve/.gitted/refs/heads/trivial-15-branch +++ /dev/null @@ -1 +0,0 @@ -c5be2acabac675af81df8bb70400235af2a9c225 From a204533ded1e30f79b50d1e681b9884043091c12 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Tue, 20 Feb 2024 14:30:17 +0000 Subject: [PATCH 513/608] test: completely ignored diff is empty --- tests/libgit2/diff/workdir.c | 57 ++++++++++++++++++++++++++++++------ 1 file changed, 48 insertions(+), 9 deletions(-) diff --git a/tests/libgit2/diff/workdir.c b/tests/libgit2/diff/workdir.c index c433b75cedc..504ece6fc91 100644 --- a/tests/libgit2/diff/workdir.c +++ b/tests/libgit2/diff/workdir.c @@ -2286,42 +2286,81 @@ void test_diff_workdir__to_index_reversed_content_loads(void) diff_expects exp; int use_iterator; char *pathspec = "new_file"; - + g_repo = cl_git_sandbox_init("status"); - + opts.context_lines = 3; opts.interhunk_lines = 1; opts.flags |= GIT_DIFF_INCLUDE_IGNORED | GIT_DIFF_INCLUDE_UNTRACKED | GIT_DIFF_SHOW_UNTRACKED_CONTENT | GIT_DIFF_REVERSE; opts.pathspec.strings = &pathspec; opts.pathspec.count = 1; - + cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts)); - + for (use_iterator = 0; use_iterator <= 1; use_iterator++) { memset(&exp, 0, sizeof(exp)); - + if (use_iterator) cl_git_pass(diff_foreach_via_iterator( diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp)); else cl_git_pass(git_diff_foreach( diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp)); - + cl_assert_equal_i(1, exp.files); cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]); cl_assert_equal_i(0, exp.file_status[GIT_DELTA_DELETED]); cl_assert_equal_i(0, exp.file_status[GIT_DELTA_MODIFIED]); cl_assert_equal_i(0, exp.file_status[GIT_DELTA_IGNORED]); cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNTRACKED]); - + cl_assert_equal_i(1, exp.hunks); - + cl_assert_equal_i(1, exp.lines); cl_assert_equal_i(0, exp.line_ctxt); cl_assert_equal_i(0, exp.line_adds); cl_assert_equal_i(1, exp.line_dels); } - + + git_diff_free(diff); +} + +void test_diff_workdir__completely_ignored_shows_empty_diff(void) +{ + git_diff_options opts = GIT_DIFF_OPTIONS_INIT; + git_diff *diff; + git_patch *patch; + git_buf buf = GIT_BUF_INIT; + char *pathspec = "subdir.txt"; + + opts.pathspec.strings = &pathspec; + opts.pathspec.count = 1; + + g_repo = cl_git_sandbox_init("status"); + cl_git_rewritefile("status/subdir.txt", "Is it a bird?\n\nIs it a plane?\n"); + + /* Perform the diff normally */ + cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts)); + cl_git_pass(git_patch_from_diff(&patch, diff, 0)); + cl_git_pass(git_patch_to_buf(&buf, patch)); + + cl_assert_equal_s("diff --git a/subdir.txt b/subdir.txt\nindex e8ee89e..53c8db5 100644\n--- a/subdir.txt\n+++ b/subdir.txt\n@@ -1,2 +1,3 @@\n Is it a bird?\n+\n Is it a plane?\n", buf.ptr); + + git_buf_dispose(&buf); + git_patch_free(patch); + git_diff_free(diff); + + /* Perform the diff ignoring blank lines */ + opts.flags |= GIT_DIFF_IGNORE_BLANK_LINES; + + cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts)); + cl_git_pass(git_patch_from_diff(&patch, diff, 0)); + cl_git_pass(git_patch_to_buf(&buf, patch)); + + cl_assert_equal_s("", buf.ptr); + + git_buf_dispose(&buf); + git_patch_free(patch); git_diff_free(diff); } From d704046712a762a79689c00767ef7602e86d630f Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Tue, 20 Feb 2024 14:30:26 +0000 Subject: [PATCH 514/608] diff: don't print header for empty (fully ignored) diff When a diff has no content -- for example, when there are only whitespace changes, and they're being ignored -- we need to avoid printing the file header. Queue the file header update until the first hunk is printed, and display it then. --- src/libgit2/diff_print.c | 51 ++++++++++++++++++++++++++++++++++++---- 1 file changed, 47 insertions(+), 4 deletions(-) diff --git a/src/libgit2/diff_print.c b/src/libgit2/diff_print.c index 32c93682679..daeefca50ca 100644 --- a/src/libgit2/diff_print.c +++ b/src/libgit2/diff_print.c @@ -29,6 +29,7 @@ typedef struct { const char *new_prefix; uint32_t flags; int id_strlen; + unsigned int sent_file_header; git_oid_t oid_type; int (*strcomp)(const char *, const char *); @@ -579,6 +580,30 @@ static int diff_print_patch_file_binary( return error; } +GIT_INLINE(int) should_force_header(const git_diff_delta *delta) +{ + if (delta->old_file.mode != delta->new_file.mode) + return 1; + + if (delta->status == GIT_DELTA_RENAMED || delta->status == GIT_DELTA_COPIED) + return 1; + + return 0; +} + +GIT_INLINE(int) flush_file_header(const git_diff_delta *delta, diff_print_info *pi) +{ + if (pi->sent_file_header) + return 0; + + pi->line.origin = GIT_DIFF_LINE_FILE_HDR; + pi->line.content = git_str_cstr(pi->buf); + pi->line.content_len = git_str_len(pi->buf); + pi->sent_file_header = 1; + + return pi->print_cb(delta, NULL, &pi->line, pi->payload); +} + static int diff_print_patch_file( const git_diff_delta *delta, float progress, void *data) { @@ -609,15 +634,22 @@ static int diff_print_patch_file( (pi->flags & GIT_DIFF_SHOW_UNTRACKED_CONTENT) == 0)) return 0; + pi->sent_file_header = 0; + if ((error = git_diff_delta__format_file_header(pi->buf, delta, oldpfx, newpfx, id_strlen, print_index)) < 0) return error; - pi->line.origin = GIT_DIFF_LINE_FILE_HDR; - pi->line.content = git_str_cstr(pi->buf); - pi->line.content_len = git_str_len(pi->buf); + /* + * pi->buf now contains the file header data. Go ahead and send it + * if there's useful data in there, like similarity. Otherwise, we + * should queue it to send when we see the first hunk. This prevents + * us from sending a header when all hunks were ignored. + */ + if (should_force_header(delta) && (error = flush_file_header(delta, pi)) < 0) + return error; - return pi->print_cb(delta, NULL, &pi->line, pi->payload); + return 0; } static int diff_print_patch_binary( @@ -632,6 +664,9 @@ static int diff_print_patch_binary( pi->new_prefix ? pi->new_prefix : DIFF_NEW_PREFIX_DEFAULT; int error; + if ((error = flush_file_header(delta, pi)) < 0) + return error; + git_str_clear(pi->buf); if ((error = diff_print_patch_file_binary( @@ -651,10 +686,14 @@ static int diff_print_patch_hunk( void *data) { diff_print_info *pi = data; + int error; if (S_ISDIR(d->new_file.mode)) return 0; + if ((error = flush_file_header(d, pi)) < 0) + return error; + pi->line.origin = GIT_DIFF_LINE_HUNK_HDR; pi->line.content = h->header; pi->line.content_len = h->header_len; @@ -669,10 +708,14 @@ static int diff_print_patch_line( void *data) { diff_print_info *pi = data; + int error; if (S_ISDIR(delta->new_file.mode)) return 0; + if ((error = flush_file_header(delta, pi)) < 0) + return error; + return pi->print_cb(delta, hunk, line, pi->payload); } From aa31120f7c131cbe79f0f95b9bd5e745792ae47d Mon Sep 17 00:00:00 2001 From: Sean Allred Date: Sun, 6 Feb 2022 07:22:59 -0600 Subject: [PATCH 515/608] config: introduce GIT_CONFIG_LEVEL_WORKTREE Introduce the logical concept of a worktree-level config. The new value sits between _LOCAL and _APP to allow `git_config_get_*` to 'just work'. The assumption of how `git_config_get_*` works was tested experimentally by setting _WORKTREE to some nonsense value (like -3) and watching the new test fail. --- include/git2/config.h | 6 +++++- tests/libgit2/config/configlevel.c | 18 ++++++++++++++++++ 2 files changed, 23 insertions(+), 1 deletion(-) diff --git a/include/git2/config.h b/include/git2/config.h index 332e62036d0..63293dbdaec 100644 --- a/include/git2/config.h +++ b/include/git2/config.h @@ -48,9 +48,13 @@ typedef enum { */ GIT_CONFIG_LEVEL_LOCAL = 5, + /** Worktree specific configuration file; $GIT_DIR/config.worktree + */ + GIT_CONFIG_LEVEL_WORKTREE = 6, + /** Application specific configuration file; freely defined by applications */ - GIT_CONFIG_LEVEL_APP = 6, + GIT_CONFIG_LEVEL_APP = 7, /** Represents the highest level available config file (i.e. the most * specific config file available that actually is loaded) diff --git a/tests/libgit2/config/configlevel.c b/tests/libgit2/config/configlevel.c index 8422d32c944..3534fbc2c84 100644 --- a/tests/libgit2/config/configlevel.c +++ b/tests/libgit2/config/configlevel.c @@ -71,3 +71,21 @@ void test_config_configlevel__fetching_a_level_from_an_empty_compound_config_ret git_config_free(cfg); } + +void test_config_configlevel__can_override_local_with_worktree(void) +{ + git_config *cfg; + git_buf buf = GIT_BUF_INIT; + + cl_git_pass(git_config_new(&cfg)); + cl_git_pass(git_config_add_file_ondisk(cfg, cl_fixture("config/config19"), + GIT_CONFIG_LEVEL_WORKTREE, NULL, 1)); + cl_git_pass(git_config_add_file_ondisk(cfg, cl_fixture("config/config18"), + GIT_CONFIG_LEVEL_LOCAL, NULL, 1)); + + cl_git_pass(git_config_get_string_buf(&buf, cfg, "core.stringglobal")); + cl_assert_equal_s("don't find me!", buf.ptr); + + git_buf_dispose(&buf); + git_config_free(cfg); +} From c4df10285edc3bab45cd779293800e7ec19d9bb0 Mon Sep 17 00:00:00 2001 From: Sean Allred Date: Sun, 6 Feb 2022 09:26:41 -0600 Subject: [PATCH 516/608] config: load worktree config from disk Now that GIT_CONFIG_LEVEL_WORKTREE exists logically, define and load $GIT_DIR/config.worktree into that level. --- include/git2/repository.h | 1 + src/libgit2/repository.c | 7 +++++++ 2 files changed, 8 insertions(+) diff --git a/include/git2/repository.h b/include/git2/repository.h index 0ff0856510f..9ad6176f940 100644 --- a/include/git2/repository.h +++ b/include/git2/repository.h @@ -499,6 +499,7 @@ typedef enum { GIT_REPOSITORY_ITEM_PACKED_REFS, GIT_REPOSITORY_ITEM_REMOTES, GIT_REPOSITORY_ITEM_CONFIG, + GIT_REPOSITORY_ITEM_WORKTREE_CONFIG, GIT_REPOSITORY_ITEM_INFO, GIT_REPOSITORY_ITEM_HOOKS, GIT_REPOSITORY_ITEM_LOGS, diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index 4eb3449133b..2859bd4800b 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -58,6 +58,7 @@ static const struct { { GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM_GITDIR, "packed-refs", false }, { GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM_GITDIR, "remotes", true }, { GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM_GITDIR, "config", false }, + { GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM_GITDIR, "config.worktree", false }, { GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM_GITDIR, "info", true }, { GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM_GITDIR, "hooks", true }, { GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM_GITDIR, "logs", true }, @@ -1291,6 +1292,12 @@ static int load_config( return error; if (repo) { + if ((error = git_repository__item_path(&config_path, repo, GIT_REPOSITORY_ITEM_WORKTREE_CONFIG)) == 0) + error = git_config_add_file_ondisk(cfg, config_path.ptr, GIT_CONFIG_LEVEL_WORKTREE, repo, 0); + + if (error && error != GIT_ENOTFOUND) + goto on_error; + if ((error = git_repository__item_path(&config_path, repo, GIT_REPOSITORY_ITEM_CONFIG)) == 0) error = git_config_add_file_ondisk(cfg, config_path.ptr, GIT_CONFIG_LEVEL_LOCAL, repo, 0); From 5a86dfc17298bb80ff0dabe95f8e9fbdd6ad6e7c Mon Sep 17 00:00:00 2001 From: Sean Allred Date: Sun, 6 Feb 2022 10:00:40 -0600 Subject: [PATCH 517/608] repository: support the 'worktreeConfig' extension Now that worktree-level configuration can be read from disk and manipulated in memory, we should be able to say we support 'extensions.worktreeConfig'. --- src/libgit2/repository.c | 3 ++- tests/libgit2/core/opts.c | 12 ++++++++---- 2 files changed, 10 insertions(+), 5 deletions(-) diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index 2859bd4800b..be938b5b9d0 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -1852,7 +1852,8 @@ static int check_repositoryformatversion(int *version, git_config *config) static const char *builtin_extensions[] = { "noop", - "objectformat" + "objectformat", + "worktreeconfig", }; static git_vector user_extensions = { 0, git__strcmp_cb }; diff --git a/tests/libgit2/core/opts.c b/tests/libgit2/core/opts.c index 1aa095adf4c..cbef29f991d 100644 --- a/tests/libgit2/core/opts.c +++ b/tests/libgit2/core/opts.c @@ -34,9 +34,10 @@ void test_core_opts__extensions_query(void) cl_git_pass(git_libgit2_opts(GIT_OPT_GET_EXTENSIONS, &out)); - cl_assert_equal_sz(out.count, 2); + cl_assert_equal_sz(out.count, 3); cl_assert_equal_s("noop", out.strings[0]); cl_assert_equal_s("objectformat", out.strings[1]); + cl_assert_equal_s("worktreeconfig", out.strings[2]); git_strarray_dispose(&out); } @@ -49,10 +50,11 @@ void test_core_opts__extensions_add(void) cl_git_pass(git_libgit2_opts(GIT_OPT_SET_EXTENSIONS, in, ARRAY_SIZE(in))); cl_git_pass(git_libgit2_opts(GIT_OPT_GET_EXTENSIONS, &out)); - cl_assert_equal_sz(out.count, 3); + cl_assert_equal_sz(out.count, 4); cl_assert_equal_s("foo", out.strings[0]); cl_assert_equal_s("noop", out.strings[1]); cl_assert_equal_s("objectformat", out.strings[2]); + cl_assert_equal_s("worktreeconfig", out.strings[3]); git_strarray_dispose(&out); } @@ -65,10 +67,11 @@ void test_core_opts__extensions_remove(void) cl_git_pass(git_libgit2_opts(GIT_OPT_SET_EXTENSIONS, in, ARRAY_SIZE(in))); cl_git_pass(git_libgit2_opts(GIT_OPT_GET_EXTENSIONS, &out)); - cl_assert_equal_sz(out.count, 3); + cl_assert_equal_sz(out.count, 4); cl_assert_equal_s("bar", out.strings[0]); cl_assert_equal_s("baz", out.strings[1]); cl_assert_equal_s("objectformat", out.strings[2]); + cl_assert_equal_s("worktreeconfig", out.strings[3]); git_strarray_dispose(&out); } @@ -81,11 +84,12 @@ void test_core_opts__extensions_uniq(void) cl_git_pass(git_libgit2_opts(GIT_OPT_SET_EXTENSIONS, in, ARRAY_SIZE(in))); cl_git_pass(git_libgit2_opts(GIT_OPT_GET_EXTENSIONS, &out)); - cl_assert_equal_sz(out.count, 4); + cl_assert_equal_sz(out.count, 5); cl_assert_equal_s("bar", out.strings[0]); cl_assert_equal_s("foo", out.strings[1]); cl_assert_equal_s("noop", out.strings[2]); cl_assert_equal_s("objectformat", out.strings[3]); + cl_assert_equal_s("worktreeconfig", out.strings[4]); git_strarray_dispose(&out); } From 42e7e681de2dbd37b0b1018fc78a0e3a7ff1cf68 Mon Sep 17 00:00:00 2001 From: Sean Allred Date: Tue, 20 Feb 2024 21:38:52 -0600 Subject: [PATCH 518/608] config: refactor get_backend_for_use This structure provides for cleaner diffs in upcoming commits. --- src/libgit2/config.c | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) diff --git a/src/libgit2/config.c b/src/libgit2/config.c index 04f3ec2fee2..e67839c3622 100644 --- a/src/libgit2/config.c +++ b/src/libgit2/config.c @@ -594,6 +594,7 @@ static int get_backend_for_use(git_config_backend **out, { size_t i; backend_internal *backend; + int error = 0; *out = NULL; @@ -605,16 +606,20 @@ static int get_backend_for_use(git_config_backend **out, } git_vector_foreach(&cfg->backends, i, backend) { - if (!backend->backend->readonly) { - *out = backend->backend; - return 0; - } + if (backend->backend->readonly) + continue; + + *out = backend->backend; + goto cleanup; } + error = GIT_ENOTFOUND; git_error_set(GIT_ERROR_CONFIG, "cannot %s value for '%s' when all config backends are readonly", uses[use], name); - return GIT_ENOTFOUND; + + cleanup: + return error; } int git_config_delete_entry(git_config *cfg, const char *name) From ea66ab07738642a3d7dae6d249a92f5fd1ff3e89 Mon Sep 17 00:00:00 2001 From: Sean Allred Date: Tue, 20 Feb 2024 21:39:11 -0600 Subject: [PATCH 519/608] config: skip worktree config in get_backend_for_use It would seem that `get_backend_for_use` is primarily used when writing config data -- either to set keys or delete them (based on the possible values of `backend_use`). When git-config(1) is used for side-effects, it will modify only the local (repository-level) configuration unless explicitly overridden. From git-config(1): --local For writing options: write to the repository .git/config file. This is the default behavior. `get_backend_for_use` does not have the ability to specify a config level and typically is expected (it seems) to 'do the right thing'. Taking its cue from git-config(1), don't update worktree-specific config unless it's the only option. If that functionality is needed by consumers, I assume they would find the appropriate backend with `git_config_open_level` and feed that `git_config` object through to the `git_config_set_*` functions (as demonstrated in the provided test). --- src/libgit2/config.c | 13 ++++++++++++- tests/libgit2/worktree/config.c | 30 +++++++++++++++++++++++++++++- 2 files changed, 41 insertions(+), 2 deletions(-) diff --git a/src/libgit2/config.c b/src/libgit2/config.c index e67839c3622..732d10830ec 100644 --- a/src/libgit2/config.c +++ b/src/libgit2/config.c @@ -593,12 +593,14 @@ static int get_backend_for_use(git_config_backend **out, git_config *cfg, const char *name, backend_use use) { size_t i; + size_t len; backend_internal *backend; int error = 0; *out = NULL; - if (git_vector_length(&cfg->backends) == 0) { + len = git_vector_length(&cfg->backends); + if (len == 0) { git_error_set(GIT_ERROR_CONFIG, "cannot %s value for '%s' when no config backends exist", uses[use], name); @@ -609,6 +611,15 @@ static int get_backend_for_use(git_config_backend **out, if (backend->backend->readonly) continue; + /* git-config doesn't update worktree-level config + unless specifically requested; follow suit. If you + specifically want to update that level, open the + single config level with git_config_open_level and + provide that as the config. In this case, there + will only be one backend in the config. */ + if (len > 1 && backend->level == GIT_CONFIG_LEVEL_WORKTREE) + continue; + *out = backend->backend; goto cleanup; } diff --git a/tests/libgit2/worktree/config.c b/tests/libgit2/worktree/config.c index 81dcfe1fa51..c23cd044fba 100644 --- a/tests/libgit2/worktree/config.c +++ b/tests/libgit2/worktree/config.c @@ -27,7 +27,7 @@ void test_worktree_config__open(void) git_config_free(cfg); } -void test_worktree_config__set(void) +void test_worktree_config__set_level_local(void) { git_config *cfg; int32_t val; @@ -45,3 +45,31 @@ void test_worktree_config__set(void) cl_assert_equal_i(val, 5); git_config_free(cfg); } + +void test_worktree_config__set_level_worktree(void) +{ + git_config *cfg; + git_config *wtcfg; + int32_t val; + + cl_git_pass(git_repository_config(&cfg, fixture.repo)); + cl_git_pass(git_config_open_level(&wtcfg, cfg, GIT_CONFIG_LEVEL_WORKTREE)); + cl_git_pass(git_config_set_int32(wtcfg, "worktree.specific", 42)); + + cl_git_pass(git_config_get_int32(&val, cfg, "worktree.specific")); + cl_assert_equal_i(val, 42); + + /* reopen to verify config has been set */ + git_config_free(cfg); + cl_git_pass(git_repository_config(&cfg, fixture.repo)); + cl_git_pass(git_config_get_int32(&val, cfg, "worktree.specific")); + cl_assert_equal_i(val, 42); + + cl_assert(git_config_delete_entry(cfg, "worktree.specific") == GIT_ENOTFOUND); + + cl_git_pass(git_config_delete_entry(wtcfg, "worktree.specific")); + cl_assert(git_config_get_int32(&val, cfg, "worktree.specific") == GIT_ENOTFOUND); + + git_config_free(cfg); + git_config_free(wtcfg); +} From 9b21c428cfebdb5cd047d7fd6505d8c32e47f101 Mon Sep 17 00:00:00 2001 From: Sean Allred Date: Tue, 20 Feb 2024 21:46:07 -0600 Subject: [PATCH 520/608] config: return only backends that contain the key When deleting a key from a repository with multiple config backends (like a --local config and a --worktree config), it's important to return the correct backend to modify. This patch ensures that we don't return a backend that is incapable of deleting a given piece of configuration when that is the required use. --- src/libgit2/config.c | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/src/libgit2/config.c b/src/libgit2/config.c index 732d10830ec..6d3cd9836d3 100644 --- a/src/libgit2/config.c +++ b/src/libgit2/config.c @@ -596,6 +596,7 @@ static int get_backend_for_use(git_config_backend **out, size_t len; backend_internal *backend; int error = 0; + git_config_entry *entry = NULL; *out = NULL; @@ -620,6 +621,15 @@ static int get_backend_for_use(git_config_backend **out, if (len > 1 && backend->level == GIT_CONFIG_LEVEL_WORKTREE) continue; + /* If we're trying to delete a piece of config, make + sure the backend we return actually defines it in + the first place. */ + if (use == BACKEND_USE_DELETE) { + if (backend->backend->get(backend->backend, name, &entry) < 0) + continue; + git_config_entry_free(entry); + } + *out = backend->backend; goto cleanup; } From 498f443379f3fb248bb20c9ae6dce0f956dea327 Mon Sep 17 00:00:00 2001 From: Sean Allred Date: Tue, 20 Feb 2024 21:46:16 -0600 Subject: [PATCH 521/608] config: normalize key name in get_backend_for_use Before passing the config key name to backend->get(), it needs to be normalized first. Not all current callers are performing this normalization, so perform it centrally instead. Co-authored-by: Brian Lyles --- src/libgit2/config.c | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/src/libgit2/config.c b/src/libgit2/config.c index 6d3cd9836d3..6994a8e2736 100644 --- a/src/libgit2/config.c +++ b/src/libgit2/config.c @@ -597,6 +597,7 @@ static int get_backend_for_use(git_config_backend **out, backend_internal *backend; int error = 0; git_config_entry *entry = NULL; + char *key = NULL; *out = NULL; @@ -625,7 +626,9 @@ static int get_backend_for_use(git_config_backend **out, sure the backend we return actually defines it in the first place. */ if (use == BACKEND_USE_DELETE) { - if (backend->backend->get(backend->backend, name, &entry) < 0) + if (key == NULL && (error = git_config__normalize_name(name, &key)) < 0) + goto cleanup; + if (backend->backend->get(backend->backend, key, &entry) < 0) continue; git_config_entry_free(entry); } @@ -640,6 +643,7 @@ static int get_backend_for_use(git_config_backend **out, uses[use], name); cleanup: + git__free(key); return error; } From 47f3953111a94bcd11b9798989bc702eda2cdb44 Mon Sep 17 00:00:00 2001 From: Sean Allred Date: Wed, 21 Feb 2024 13:51:36 -0600 Subject: [PATCH 522/608] config: use appropriate backend_use value This looks like a simple copy/paste error. --- src/libgit2/config.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/libgit2/config.c b/src/libgit2/config.c index 6994a8e2736..908bf8d390a 100644 --- a/src/libgit2/config.c +++ b/src/libgit2/config.c @@ -1126,7 +1126,7 @@ int git_config_set_multivar(git_config *cfg, const char *name, const char *regex { git_config_backend *backend; - if (get_backend_for_use(&backend, cfg, name, BACKEND_USE_DELETE) < 0) + if (get_backend_for_use(&backend, cfg, name, BACKEND_USE_SET) < 0) return GIT_ENOTFOUND; return backend->set_multivar(backend, name, regexp, value); From 4cd2d1798ce2af4bff7ce8a76b6e97d702183567 Mon Sep 17 00:00:00 2001 From: Sean Allred Date: Tue, 20 Feb 2024 21:34:29 -0600 Subject: [PATCH 523/608] config: propagate errors from get_backend_for_use Now that get_backend_for_use can return other error codes (by virtue of key-name normalization), make sure to propagate the appropriate error code when used. --- src/libgit2/config.c | 19 +++++++++++-------- 1 file changed, 11 insertions(+), 8 deletions(-) diff --git a/src/libgit2/config.c b/src/libgit2/config.c index 908bf8d390a..d3193c95e26 100644 --- a/src/libgit2/config.c +++ b/src/libgit2/config.c @@ -650,9 +650,10 @@ static int get_backend_for_use(git_config_backend **out, int git_config_delete_entry(git_config *cfg, const char *name) { git_config_backend *backend; + int error = 0; - if (get_backend_for_use(&backend, cfg, name, BACKEND_USE_DELETE) < 0) - return GIT_ENOTFOUND; + if ((error = get_backend_for_use(&backend, cfg, name, BACKEND_USE_DELETE)) < 0) + return error; return backend->del(backend, name); } @@ -684,8 +685,8 @@ int git_config_set_string(git_config *cfg, const char *name, const char *value) return -1; } - if (get_backend_for_use(&backend, cfg, name, BACKEND_USE_SET) < 0) - return GIT_ENOTFOUND; + if ((error = get_backend_for_use(&backend, cfg, name, BACKEND_USE_SET)) < 0) + return error; error = backend->set(backend, name, value); @@ -1125,9 +1126,10 @@ int git_config_multivar_iterator_new(git_config_iterator **out, const git_config int git_config_set_multivar(git_config *cfg, const char *name, const char *regexp, const char *value) { git_config_backend *backend; + int error = 0; - if (get_backend_for_use(&backend, cfg, name, BACKEND_USE_SET) < 0) - return GIT_ENOTFOUND; + if ((error = get_backend_for_use(&backend, cfg, name, BACKEND_USE_SET)) < 0) + return error; return backend->set_multivar(backend, name, regexp, value); } @@ -1135,9 +1137,10 @@ int git_config_set_multivar(git_config *cfg, const char *name, const char *regex int git_config_delete_multivar(git_config *cfg, const char *name, const char *regexp) { git_config_backend *backend; + int error = 0; - if (get_backend_for_use(&backend, cfg, name, BACKEND_USE_DELETE) < 0) - return GIT_ENOTFOUND; + if ((error = get_backend_for_use(&backend, cfg, name, BACKEND_USE_DELETE)) < 0) + return error; return backend->del_multivar(backend, name, regexp); } From 88608a5e9e4c0a617bac158e762b058e16b9b600 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 22 Feb 2024 14:06:06 +0000 Subject: [PATCH 524/608] worktree: update worktree refs test Ensure that we test for the expected error code (GIT_ENOTFOUND) on not found refs. In addition, we don't need to handle the error case with an explicit free; it's okay to leak memory on test failures. --- tests/libgit2/worktree/refs.c | 20 ++++++-------------- 1 file changed, 6 insertions(+), 14 deletions(-) diff --git a/tests/libgit2/worktree/refs.c b/tests/libgit2/worktree/refs.c index 6bcf7aa9dac..51e7b2b9463 100644 --- a/tests/libgit2/worktree/refs.c +++ b/tests/libgit2/worktree/refs.c @@ -69,23 +69,19 @@ void test_worktree_refs__list_worktree_specific(void) git_oid oid; cl_git_pass(git_reference_name_to_id(&oid, fixture.repo, "refs/heads/dir")); - cl_git_fail(git_reference_lookup(&ref, fixture.repo, "refs/bisect/a-bisect-ref")); + cl_git_fail_with(GIT_ENOTFOUND, git_reference_lookup(&ref, fixture.repo, "refs/bisect/a-bisect-ref")); cl_git_pass(git_reference_create( &new_branch, fixture.worktree, "refs/bisect/a-bisect-ref", &oid, 0, "test")); - cl_git_fail(git_reference_lookup(&ref, fixture.repo, "refs/bisect/a-bisect-ref")); + cl_git_fail_with(GIT_ENOTFOUND, git_reference_lookup(&ref, fixture.repo, "refs/bisect/a-bisect-ref")); cl_git_pass(git_reference_lookup(&ref, fixture.worktree, "refs/bisect/a-bisect-ref")); cl_git_pass(git_reference_list(&refs, fixture.repo)); cl_git_pass(git_reference_list(&wtrefs, fixture.worktree)); - if (refs.count + 1 != wtrefs.count) { - error = GIT_ERROR; - goto exit; - } + cl_assert_equal_sz(wtrefs.count, refs.count + 1); -exit: git_reference_free(ref); git_reference_free(new_branch); git_strarray_dispose(&refs); @@ -102,13 +98,13 @@ void test_worktree_refs__list_worktree_specific_hidden_in_main_repo(void) cl_git_pass( git_reference_name_to_id(&oid, fixture.repo, "refs/heads/dir")); - cl_git_fail(git_reference_lookup( + cl_git_fail_with(GIT_ENOTFOUND, git_reference_lookup( &ref, fixture.worktree, "refs/bisect/a-bisect-ref")); cl_git_pass(git_reference_create( &new_branch, fixture.repo, "refs/bisect/a-bisect-ref", &oid, 0, "test")); - cl_git_fail(git_reference_lookup( + cl_git_fail_with(GIT_ENOTFOUND, git_reference_lookup( &ref, fixture.worktree, "refs/bisect/a-bisect-ref")); cl_git_pass(git_reference_lookup( &ref, fixture.repo, "refs/bisect/a-bisect-ref")); @@ -116,12 +112,8 @@ void test_worktree_refs__list_worktree_specific_hidden_in_main_repo(void) cl_git_pass(git_reference_list(&refs, fixture.repo)); cl_git_pass(git_reference_list(&wtrefs, fixture.worktree)); - if (refs.count != wtrefs.count + 1) { - error = GIT_ERROR; - goto exit; - } + cl_assert_equal_sz(refs.count, wtrefs.count + 1); -exit: git_reference_free(ref); git_reference_free(new_branch); git_strarray_dispose(&refs); From bd242a05e29d74e44e5a5d98ff6023c0f0a4750e Mon Sep 17 00:00:00 2001 From: Sven Strickroth Date: Sat, 24 Feb 2024 14:33:26 +0100 Subject: [PATCH 525/608] Fix broken links Signed-off-by: Sven Strickroth --- README.md | 2 +- examples/general.c | 24 ++++++++++++------------ 2 files changed, 13 insertions(+), 13 deletions(-) diff --git a/README.md b/README.md index 19fe7196976..f646feb197c 100644 --- a/README.md +++ b/README.md @@ -113,7 +113,7 @@ Getting Help **Getting Help** If you have questions about the library, please be sure to check out the -[API documentation](http://libgit2.github.com/libgit2/). If you still have +[API documentation](http://libgit2.github.io/libgit2/). If you still have questions, reach out to us on Slack or post a question on [StackOverflow](http://stackoverflow.com/questions/tagged/libgit2) (with the `libgit2` tag). diff --git a/examples/general.c b/examples/general.c index 7f44cd78680..a3767809230 100644 --- a/examples/general.c +++ b/examples/general.c @@ -32,7 +32,7 @@ * check out [Chapter 10][pg] of the Pro Git book. * * [lg]: http://libgit2.github.com - * [ap]: http://libgit2.github.com/libgit2 + * [ap]: http://libgit2.github.io/libgit2 * [pg]: https://git-scm.com/book/en/v2/Git-Internals-Plumbing-and-Porcelain */ @@ -97,7 +97,7 @@ int lg2_general(git_repository *repo, int argc, char** argv) * * (Try running this program against tests/resources/testrepo.git.) * - * [me]: http://libgit2.github.com/libgit2/#HEAD/group/repository + * [me]: http://libgit2.github.io/libgit2/#HEAD/group/repository */ repo_path = (argc > 1) ? argv[1] : "/opt/libgit2-test/.git"; @@ -173,7 +173,7 @@ static void oid_parsing(git_oid *oid) * working with raw objects, we'll need to get this structure from the * repository. * - * [odb]: http://libgit2.github.com/libgit2/#HEAD/group/odb + * [odb]: http://libgit2.github.io/libgit2/#HEAD/group/odb */ static void object_database(git_repository *repo, git_oid *oid) { @@ -262,7 +262,7 @@ static void object_database(git_repository *repo, git_oid *oid) * of them here. You can read about the other ones in the [commit API * docs][cd]. * - * [cd]: http://libgit2.github.com/libgit2/#HEAD/group/commit + * [cd]: http://libgit2.github.io/libgit2/#HEAD/group/commit */ static void commit_writing(git_repository *repo) { @@ -347,7 +347,7 @@ static void commit_writing(git_repository *repo) * data in the commit - the author (name, email, datetime), committer * (same), tree, message, encoding and parent(s). * - * [pco]: http://libgit2.github.com/libgit2/#HEAD/group/commit + * [pco]: http://libgit2.github.io/libgit2/#HEAD/group/commit */ static void commit_parsing(git_repository *repo) { @@ -418,7 +418,7 @@ static void commit_parsing(git_repository *repo) * functions very similarly to the commit lookup, parsing and creation * methods, since the objects themselves are very similar. * - * [tm]: http://libgit2.github.com/libgit2/#HEAD/group/tag + * [tm]: http://libgit2.github.io/libgit2/#HEAD/group/tag */ static void tag_parsing(git_repository *repo) { @@ -472,7 +472,7 @@ static void tag_parsing(git_repository *repo) * object type in Git, but a useful structure for parsing and traversing * tree entries. * - * [tp]: http://libgit2.github.com/libgit2/#HEAD/group/tree + * [tp]: http://libgit2.github.io/libgit2/#HEAD/group/tree */ static void tree_parsing(git_repository *repo) { @@ -536,7 +536,7 @@ static void tree_parsing(git_repository *repo) * from disk and writing it to the db and getting the oid back so you * don't have to do all those steps yourself. * - * [ba]: http://libgit2.github.com/libgit2/#HEAD/group/blob + * [ba]: http://libgit2.github.io/libgit2/#HEAD/group/blob */ static void blob_parsing(git_repository *repo) { @@ -578,7 +578,7 @@ static void blob_parsing(git_repository *repo) * that were ancestors of (reachable from) a given starting point. This * can allow you to create `git log` type functionality. * - * [rw]: http://libgit2.github.com/libgit2/#HEAD/group/revwalk + * [rw]: http://libgit2.github.io/libgit2/#HEAD/group/revwalk */ static void revwalking(git_repository *repo) { @@ -643,7 +643,7 @@ static void revwalking(git_repository *repo) * The [index file API][gi] allows you to read, traverse, update and write * the Git index file (sometimes thought of as the staging area). * - * [gi]: http://libgit2.github.com/libgit2/#HEAD/group/index + * [gi]: http://libgit2.github.io/libgit2/#HEAD/group/index */ static void index_walking(git_repository *repo) { @@ -687,7 +687,7 @@ static void index_walking(git_repository *repo) * references such as branches, tags and remote references (everything in * the .git/refs directory). * - * [ref]: http://libgit2.github.com/libgit2/#HEAD/group/reference + * [ref]: http://libgit2.github.io/libgit2/#HEAD/group/reference */ static void reference_listing(git_repository *repo) { @@ -740,7 +740,7 @@ static void reference_listing(git_repository *repo) * The [config API][config] allows you to list and update config values * in any of the accessible config file locations (system, global, local). * - * [config]: http://libgit2.github.com/libgit2/#HEAD/group/config + * [config]: http://libgit2.github.io/libgit2/#HEAD/group/config */ static void config_files(const char *repo_path, git_repository* repo) { From f9e055468d167cb4d6bde1ecd9e293d8a7d40db5 Mon Sep 17 00:00:00 2001 From: Sven Strickroth Date: Sat, 24 Feb 2024 14:47:40 +0100 Subject: [PATCH 526/608] Fix memory leaks Signed-off-by: Sven Strickroth --- src/libgit2/repository.c | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index 4eb3449133b..ba182eea4bb 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -3246,14 +3246,18 @@ int git_repository_set_workdir( if (git_fs_path_prettify_dir(&path, workdir, NULL) < 0) return -1; - if (repo->workdir && strcmp(repo->workdir, path.ptr) == 0) + if (repo->workdir && strcmp(repo->workdir, path.ptr) == 0) { + git_str_dispose(&path); return 0; + } if (update_gitlink) { git_config *config; - if (git_repository_config__weakptr(&config, repo) < 0) + if (git_repository_config__weakptr(&config, repo) < 0) { + git_str_dispose(&path); return -1; + } error = repo_write_gitlink(path.ptr, git_repository_path(repo), false); @@ -3275,6 +3279,7 @@ int git_repository_set_workdir( git__free(old_workdir); } + git_str_dispose(&path); return error; } From 2f6c4f75e374e08e5e1e2de294b77cc5cd7de232 Mon Sep 17 00:00:00 2001 From: Sven Strickroth Date: Sat, 24 Feb 2024 15:18:42 +0100 Subject: [PATCH 527/608] Fix broken regexp that matches submodule names containing ".path" Signed-off-by: Sven Strickroth --- src/libgit2/submodule.c | 4 ++-- tests/libgit2/submodule/lookup.c | 18 ++++++++++++++++++ 2 files changed, 20 insertions(+), 2 deletions(-) diff --git a/src/libgit2/submodule.c b/src/libgit2/submodule.c index 95ea84fc233..830d41c7d22 100644 --- a/src/libgit2/submodule.c +++ b/src/libgit2/submodule.c @@ -196,7 +196,7 @@ static void free_submodule_names(git_strmap *names) */ static int load_submodule_names(git_strmap **out, git_repository *repo, git_config *cfg) { - const char *key = "submodule\\..*\\.path"; + const char *key = "^submodule\\..*\\.path$"; git_config_iterator *iter = NULL; git_config_entry *entry; git_str buf = GIT_STR_INIT; @@ -332,7 +332,7 @@ int git_submodule__lookup_with_cache( /* If it's not configured or we're looking by path */ if (location == 0 || location == GIT_SUBMODULE_STATUS_IN_WD) { git_config_backend *mods; - const char *pattern = "submodule\\..*\\.path"; + const char *pattern = "^submodule\\..*\\.path$"; git_str path = GIT_STR_INIT; fbp_data data = { NULL, NULL }; diff --git a/tests/libgit2/submodule/lookup.c b/tests/libgit2/submodule/lookup.c index febb7dfad7d..14a624badef 100644 --- a/tests/libgit2/submodule/lookup.c +++ b/tests/libgit2/submodule/lookup.c @@ -401,6 +401,24 @@ void test_submodule_lookup__prefix_name(void) git_submodule_free(sm); } +/* ".path" in name of submodule */ +void test_submodule_lookup__dotpath_in_name(void) +{ + sm_lookup_data data; + + cl_git_rewritefile( + "submod2/.gitmodules", "[submodule \"kwb.pathdict\"]\n" + " path = kwb.pathdict\n" + " url = ../Test_App\n" + "[submodule \"fakin.path.app\"]\n" + " path = fakin.path.app\n" + " url = ../Test_App\n"); + + memset(&data, 0, sizeof(data)); + cl_git_pass(git_submodule_foreach(g_repo, sm_lookup_cb, &data)); + cl_assert_equal_i(9, data.count); +} + void test_submodule_lookup__renamed(void) { const char *newpath = "sm_actually_changed"; From cc35d987b412878b6f944243658fce88e845ec94 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 29 Feb 2024 18:25:24 +0000 Subject: [PATCH 528/608] ci: drop debugging ls --- ci/test.sh | 1 - 1 file changed, 1 deletion(-) diff --git a/ci/test.sh b/ci/test.sh index 4217568226a..5f6b3c31d23 100755 --- a/ci/test.sh +++ b/ci/test.sh @@ -207,7 +207,6 @@ if should_run "SSH_TESTS"; then echo "Starting SSH server..." SSHD_DIR=`mktemp -d ${TMPDIR}/sshd.XXXXXXXX` cp -R "${SOURCE_DIR}/tests/resources/pushoptions.git" "${SSHD_DIR}/test.git" - ls -FlasR "${SSHD_DIR}" cat >"${SSHD_DIR}/sshd_config" <<-EOF Port 2222 From 1a3d6a889323f26acd2c572466356f9591f3147c Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 29 Feb 2024 18:24:38 +0000 Subject: [PATCH 529/608] ci: allow opting out of push-options tests The push-options online tests require push options support in the git itself that's on the system. Allow callers with old git to opt out. --- .github/actions/run-build/action.yml | 1 + ci/test.sh | 15 +++++---------- 2 files changed, 6 insertions(+), 10 deletions(-) diff --git a/.github/actions/run-build/action.yml b/.github/actions/run-build/action.yml index bd0f59c9a88..9afcfb11e72 100644 --- a/.github/actions/run-build/action.yml +++ b/.github/actions/run-build/action.yml @@ -40,6 +40,7 @@ runs: -e PKG_CONFIG_PATH \ -e SKIP_NEGOTIATE_TESTS \ -e SKIP_SSH_TESTS \ + -e SKIP_PUSHOPTIONS_TESTS \ -e TSAN_OPTIONS \ -e UBSAN_OPTIONS \ ${{ inputs.container-version }} \ diff --git a/ci/test.sh b/ci/test.sh index 5f6b3c31d23..98093c6ec5c 100755 --- a/ci/test.sh +++ b/ci/test.sh @@ -18,6 +18,11 @@ if [[ "$(uname -s)" == MINGW* ]]; then SKIP_NTLM_TESTS=1 fi +# older versions of git don't support push options +if [ -z "$SKIP_PUSHOPTIONS_TESTS" ]; then + export GITTEST_PUSH_OPTIONS=true +fi + SOURCE_DIR=${SOURCE_DIR:-$( cd "$( dirname "${BASH_SOURCE[0]}" )" && dirname $( pwd ) )} BUILD_DIR=$(pwd) BUILD_PATH=${BUILD_PATH:=$PATH} @@ -324,10 +329,8 @@ if should_run "GITDAEMON_TESTS"; then echo "" export GITTEST_REMOTE_URL="git://localhost/test.git" - export GITTEST_PUSH_OPTIONS=true run_test gitdaemon unset GITTEST_REMOTE_URL - unset GITTEST_PUSH_OPTIONS echo "" echo "Running gitdaemon (namespace) tests" @@ -382,12 +385,10 @@ if should_run "NTLM_TESTS"; then export GITTEST_REMOTE_URL="http://localhost:9000/ntlm/test.git" export GITTEST_REMOTE_USER="foo" export GITTEST_REMOTE_PASS="baz" - export GITTEST_PUSH_OPTIONS=true run_test auth_clone_and_push unset GITTEST_REMOTE_URL unset GITTEST_REMOTE_USER unset GITTEST_REMOTE_PASS - unset GITTEST_PUSH_OPTIONS echo "" echo "Running NTLM tests (Apache emulation)" @@ -396,12 +397,10 @@ if should_run "NTLM_TESTS"; then export GITTEST_REMOTE_URL="http://localhost:9000/broken-ntlm/test.git" export GITTEST_REMOTE_USER="foo" export GITTEST_REMOTE_PASS="baz" - export GITTEST_PUSH_OPTIONS=true run_test auth_clone_and_push unset GITTEST_REMOTE_URL unset GITTEST_REMOTE_USER unset GITTEST_REMOTE_PASS - unset GITTEST_PUSH_OPTIONS fi if should_run "NEGOTIATE_TESTS" && -n "$GITTEST_NEGOTIATE_PASSWORD" ; then @@ -451,20 +450,16 @@ if should_run "SSH_TESTS"; then echo "" export GITTEST_REMOTE_URL="ssh://localhost:2222/$SSHD_DIR/test.git" - export GITTEST_PUSH_OPTIONS=true run_test ssh unset GITTEST_REMOTE_URL - unset GITTEST_PUSH_OPTIONS echo "" echo "Running ssh tests (scp-style paths)" echo "" export GITTEST_REMOTE_URL="[localhost:2222]:$SSHD_DIR/test.git" - export GITTEST_PUSH_OPTIONS=true run_test ssh unset GITTEST_REMOTE_URL - unset GITTEST_PUSH_OPTIONS unset GITTEST_SSH_CMD From 038f078d44e00df040cd2e24e038bce89253aa79 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 29 Feb 2024 21:16:56 +0000 Subject: [PATCH 530/608] ci: disable push options tests on older systems --- .github/workflows/nightly.yml | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml index 43796859762..25249e7440d 100644 --- a/.github/workflows/nightly.yml +++ b/.github/workflows/nightly.yml @@ -178,6 +178,7 @@ jobs: CMAKE_OPTIONS: -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=ON PKG_CONFIG_PATH: /usr/local/lib/pkgconfig SKIP_NEGOTIATE_TESTS: true + SKIP_PUSHOPTIONS_TESTS: true - name: "Linux (CentOS 7, dynamically-loaded OpenSSL)" id: centos7-dynamicopenssl os: ubuntu-latest @@ -187,6 +188,7 @@ jobs: CMAKE_OPTIONS: -DUSE_HTTPS=OpenSSL-Dynamic -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=ON PKG_CONFIG_PATH: /usr/local/lib/pkgconfig SKIP_NEGOTIATE_TESTS: true + SKIP_PUSHOPTIONS_TESTS: true - name: "Linux (CentOS 8, OpenSSL)" id: centos8-openssl os: ubuntu-latest @@ -218,6 +220,7 @@ jobs: CMAKE_GENERATOR: Ninja CMAKE_OPTIONS: -DUSE_HTTPS=OpenSSL-Dynamic -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=ON RUN_INVASIVE_TESTS: true + SKIP_PUSHOPTIONS_TESTS: true os: ubuntu-latest - name: "Linux (x86, Bionic, Clang, OpenSSL)" container: @@ -229,6 +232,7 @@ jobs: CMAKE_GENERATOR: Ninja CMAKE_OPTIONS: -DUSE_HTTPS=OpenSSL -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=ON RUN_INVASIVE_TESTS: true + SKIP_PUSHOPTIONS_TESTS: true os: ubuntu-latest - name: "Linux (x86, Bionic, GCC, OpenSSL)" container: @@ -239,6 +243,7 @@ jobs: CMAKE_GENERATOR: Ninja CMAKE_OPTIONS: -DUSE_HTTPS=OpenSSL -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=ON RUN_INVASIVE_TESTS: true + SKIP_PUSHOPTIONS_TESTS: true os: ubuntu-latest - name: "Linux (arm32, Bionic, GCC, OpenSSL)" container: @@ -251,6 +256,7 @@ jobs: CMAKE_OPTIONS: -DUSE_HTTPS=OpenSSL -DDEPRECATE_HARD=ON -DUSE_GSSAPI=ON -DUSE_SSH=ON RUN_INVASIVE_TESTS: true SKIP_PROXY_TESTS: true + SKIP_PUSHOPTIONS_TESTS: true GITTEST_FLAKY_STAT: true os: ubuntu-latest - name: "Linux (arm64, Bionic, GCC, OpenSSL)" @@ -264,6 +270,7 @@ jobs: CMAKE_OPTIONS: -DUSE_HTTPS=OpenSSL -DDEPRECATE_HARD=ON -DUSE_GSSAPI=ON -DUSE_SSH=ON RUN_INVASIVE_TESTS: true SKIP_PROXY_TESTS: true + SKIP_PUSHOPTIONS_TESTS: true os: ubuntu-latest # Nightly builds: ensure we fallback when missing core functionality @@ -276,6 +283,7 @@ jobs: CC: gcc CMAKE_OPTIONS: -DTHREADSAFE=OFF -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=ON CMAKE_GENERATOR: Ninja + SKIP_PUSHOPTIONS_TESTS: true - name: "Linux (no mmap)" id: noble-nommap os: ubuntu-latest From 6c7df67071d779208c3e5ca3155d01640c8e477b Mon Sep 17 00:00:00 2001 From: Sven Strickroth Date: Fri, 1 Mar 2024 14:45:08 +0100 Subject: [PATCH 531/608] Consistently use libgit2.org Signed-off-by: Sven Strickroth --- README.md | 2 +- examples/README.md | 4 ++-- examples/general.c | 26 +++++++++++++------------- src/libgit2/git2.rc | 2 +- 4 files changed, 17 insertions(+), 17 deletions(-) diff --git a/README.md b/README.md index f646feb197c..f4dbc789154 100644 --- a/README.md +++ b/README.md @@ -113,7 +113,7 @@ Getting Help **Getting Help** If you have questions about the library, please be sure to check out the -[API documentation](http://libgit2.github.io/libgit2/). If you still have +[API documentation](https://libgit2.org/libgit2/). If you still have questions, reach out to us on Slack or post a question on [StackOverflow](http://stackoverflow.com/questions/tagged/libgit2) (with the `libgit2` tag). diff --git a/examples/README.md b/examples/README.md index 769c4b2678a..0f1f253877a 100644 --- a/examples/README.md +++ b/examples/README.md @@ -15,8 +15,8 @@ so there are no restrictions on their use. For annotated HTML versions, see the "Examples" section of: - http://libgit2.github.com/libgit2 + https://libgit2.org/libgit2 such as: - http://libgit2.github.com/libgit2/ex/HEAD/general.html + https://libgit2.org/libgit2/ex/HEAD/general.html diff --git a/examples/general.c b/examples/general.c index a3767809230..0275f84a24e 100644 --- a/examples/general.c +++ b/examples/general.c @@ -31,8 +31,8 @@ * Git Internals that you will need to know to work with Git at this level, * check out [Chapter 10][pg] of the Pro Git book. * - * [lg]: http://libgit2.github.com - * [ap]: http://libgit2.github.io/libgit2 + * [lg]: https://libgit2.org + * [ap]: https://libgit2.org/libgit2 * [pg]: https://git-scm.com/book/en/v2/Git-Internals-Plumbing-and-Porcelain */ @@ -97,7 +97,7 @@ int lg2_general(git_repository *repo, int argc, char** argv) * * (Try running this program against tests/resources/testrepo.git.) * - * [me]: http://libgit2.github.io/libgit2/#HEAD/group/repository + * [me]: https://libgit2.org/libgit2/#HEAD/group/repository */ repo_path = (argc > 1) ? argv[1] : "/opt/libgit2-test/.git"; @@ -173,7 +173,7 @@ static void oid_parsing(git_oid *oid) * working with raw objects, we'll need to get this structure from the * repository. * - * [odb]: http://libgit2.github.io/libgit2/#HEAD/group/odb + * [odb]: https://libgit2.org/libgit2/#HEAD/group/odb */ static void object_database(git_repository *repo, git_oid *oid) { @@ -262,7 +262,7 @@ static void object_database(git_repository *repo, git_oid *oid) * of them here. You can read about the other ones in the [commit API * docs][cd]. * - * [cd]: http://libgit2.github.io/libgit2/#HEAD/group/commit + * [cd]: https://libgit2.org/libgit2/#HEAD/group/commit */ static void commit_writing(git_repository *repo) { @@ -347,7 +347,7 @@ static void commit_writing(git_repository *repo) * data in the commit - the author (name, email, datetime), committer * (same), tree, message, encoding and parent(s). * - * [pco]: http://libgit2.github.io/libgit2/#HEAD/group/commit + * [pco]: https://libgit2.org/libgit2/#HEAD/group/commit */ static void commit_parsing(git_repository *repo) { @@ -418,7 +418,7 @@ static void commit_parsing(git_repository *repo) * functions very similarly to the commit lookup, parsing and creation * methods, since the objects themselves are very similar. * - * [tm]: http://libgit2.github.io/libgit2/#HEAD/group/tag + * [tm]: https://libgit2.org/libgit2/#HEAD/group/tag */ static void tag_parsing(git_repository *repo) { @@ -472,7 +472,7 @@ static void tag_parsing(git_repository *repo) * object type in Git, but a useful structure for parsing and traversing * tree entries. * - * [tp]: http://libgit2.github.io/libgit2/#HEAD/group/tree + * [tp]: https://libgit2.org/libgit2/#HEAD/group/tree */ static void tree_parsing(git_repository *repo) { @@ -536,7 +536,7 @@ static void tree_parsing(git_repository *repo) * from disk and writing it to the db and getting the oid back so you * don't have to do all those steps yourself. * - * [ba]: http://libgit2.github.io/libgit2/#HEAD/group/blob + * [ba]: https://libgit2.org/libgit2/#HEAD/group/blob */ static void blob_parsing(git_repository *repo) { @@ -578,7 +578,7 @@ static void blob_parsing(git_repository *repo) * that were ancestors of (reachable from) a given starting point. This * can allow you to create `git log` type functionality. * - * [rw]: http://libgit2.github.io/libgit2/#HEAD/group/revwalk + * [rw]: https://libgit2.org/libgit2/#HEAD/group/revwalk */ static void revwalking(git_repository *repo) { @@ -643,7 +643,7 @@ static void revwalking(git_repository *repo) * The [index file API][gi] allows you to read, traverse, update and write * the Git index file (sometimes thought of as the staging area). * - * [gi]: http://libgit2.github.io/libgit2/#HEAD/group/index + * [gi]: https://libgit2.org/libgit2/#HEAD/group/index */ static void index_walking(git_repository *repo) { @@ -687,7 +687,7 @@ static void index_walking(git_repository *repo) * references such as branches, tags and remote references (everything in * the .git/refs directory). * - * [ref]: http://libgit2.github.io/libgit2/#HEAD/group/reference + * [ref]: https://libgit2.org/libgit2/#HEAD/group/reference */ static void reference_listing(git_repository *repo) { @@ -740,7 +740,7 @@ static void reference_listing(git_repository *repo) * The [config API][config] allows you to list and update config values * in any of the accessible config file locations (system, global, local). * - * [config]: http://libgit2.github.io/libgit2/#HEAD/group/config + * [config]: https://libgit2.org/libgit2/#HEAD/group/config */ static void config_files(const char *repo_path, git_repository* repo) { diff --git a/src/libgit2/git2.rc b/src/libgit2/git2.rc index d273afd7066..b94ecafd774 100644 --- a/src/libgit2/git2.rc +++ b/src/libgit2/git2.rc @@ -10,7 +10,7 @@ #endif #ifndef LIBGIT2_COMMENTS -# define LIBGIT2_COMMENTS "For more information visit http://libgit2.github.com/" +# define LIBGIT2_COMMENTS "For more information visit https://libgit2.org/" #endif #ifdef __GNUC__ From 70ab8216079469cc7a20443953dfa37b94e16671 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 2 Mar 2024 09:06:46 +0000 Subject: [PATCH 532/608] config: improve documentation for config levels --- include/git2/config.h | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/include/git2/config.h b/include/git2/config.h index 63293dbdaec..a711e1561dc 100644 --- a/include/git2/config.h +++ b/include/git2/config.h @@ -22,8 +22,15 @@ GIT_BEGIN_DECL /** * Priority level of a config file. + * * These priority levels correspond to the natural escalation logic - * (from higher to lower) when searching for config entries in git.git. + * (from higher to lower) when reading or searching for config entries + * in git.git. Meaning that for the same key, the configuration in + * the local configuration is preferred over the configuration in + * the system configuration file. + * + * Callers can add their own custom configuration, beginning at the + * `GIT_CONFIG_LEVEL_APP` level. * * git_config_open_default() and git_repository_config() honor those * priority levels as well. From 78f145366e3865ff6d20d9aecbbff57decaf773f Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 2 Mar 2024 09:07:12 +0000 Subject: [PATCH 533/608] config: update tests to use `fail_with` `cl_git_fail_with` is preferred over asserting a return value; the former gives more detailed information about the mismatch. --- tests/libgit2/worktree/config.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/libgit2/worktree/config.c b/tests/libgit2/worktree/config.c index c23cd044fba..2ddec25e264 100644 --- a/tests/libgit2/worktree/config.c +++ b/tests/libgit2/worktree/config.c @@ -65,10 +65,10 @@ void test_worktree_config__set_level_worktree(void) cl_git_pass(git_config_get_int32(&val, cfg, "worktree.specific")); cl_assert_equal_i(val, 42); - cl_assert(git_config_delete_entry(cfg, "worktree.specific") == GIT_ENOTFOUND); + cl_git_fail_with(GIT_ENOTFOUND, git_config_delete_entry(cfg, "worktree.specific")); cl_git_pass(git_config_delete_entry(wtcfg, "worktree.specific")); - cl_assert(git_config_get_int32(&val, cfg, "worktree.specific") == GIT_ENOTFOUND); + cl_git_fail_with(GIT_ENOTFOUND, git_config_get_int32(&val, cfg, "worktree.specific")); git_config_free(cfg); git_config_free(wtcfg); From 88b516713d7606c115d5253c535a4d556b899dde Mon Sep 17 00:00:00 2001 From: Laurence McGlashan Date: Mon, 4 Mar 2024 10:46:45 +0000 Subject: [PATCH 534/608] trace: Re-enable tests as tracing is now enabled by default --- tests/libgit2/trace/trace.c | 24 ------------------------ 1 file changed, 24 deletions(-) diff --git a/tests/libgit2/trace/trace.c b/tests/libgit2/trace/trace.c index 097208bffd6..9fea57668a2 100644 --- a/tests/libgit2/trace/trace.c +++ b/tests/libgit2/trace/trace.c @@ -32,16 +32,11 @@ void test_trace_trace__cleanup(void) void test_trace_trace__sets(void) { -#ifdef GIT_TRACE cl_assert(git_trace_level() == GIT_TRACE_INFO); -#else - cl_skip(); -#endif } void test_trace_trace__can_reset(void) { -#ifdef GIT_TRACE cl_assert(git_trace_level() == GIT_TRACE_INFO); cl_git_pass(git_trace_set(GIT_TRACE_ERROR, trace_callback)); @@ -51,14 +46,10 @@ void test_trace_trace__can_reset(void) git_trace(GIT_TRACE_ERROR, "Hello %s!", "world"); cl_assert(written == 1); -#else - cl_skip(); -#endif } void test_trace_trace__can_unset(void) { -#ifdef GIT_TRACE cl_assert(git_trace_level() == GIT_TRACE_INFO); cl_git_pass(git_trace_set(GIT_TRACE_NONE, NULL)); @@ -67,40 +58,25 @@ void test_trace_trace__can_unset(void) cl_assert(written == 0); git_trace(GIT_TRACE_FATAL, "Hello %s!", "world"); cl_assert(written == 0); -#else - cl_skip(); -#endif } void test_trace_trace__skips_higher_level(void) { -#ifdef GIT_TRACE cl_assert(written == 0); git_trace(GIT_TRACE_DEBUG, "Hello %s!", "world"); cl_assert(written == 0); -#else - cl_skip(); -#endif } void test_trace_trace__writes(void) { -#ifdef GIT_TRACE cl_assert(written == 0); git_trace(GIT_TRACE_INFO, "Hello %s!", "world"); cl_assert(written == 1); -#else - cl_skip(); -#endif } void test_trace_trace__writes_lower_level(void) { -#ifdef GIT_TRACE cl_assert(written == 0); git_trace(GIT_TRACE_ERROR, "Hello %s!", "world"); cl_assert(written == 1); -#else - cl_skip(); -#endif } From 885744a77e8a727dd725f6a5fa8d80c199668fb7 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Tue, 5 Mar 2024 09:23:03 +0000 Subject: [PATCH 535/608] worktree: keep version number at 1 We aren't upgrading options struct version numbers when we make ABI changes. This is a future (v2.0+) plan for libgit2. In the meantime, keep the version numbers at 1. --- include/git2/worktree.h | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/include/git2/worktree.h b/include/git2/worktree.h index 3f1acbdb0ff..c41bc8e7bc1 100644 --- a/include/git2/worktree.h +++ b/include/git2/worktree.h @@ -86,11 +86,12 @@ typedef struct git_worktree_add_options { int lock; /**< lock newly created worktree */ int checkout_existing; /**< allow checkout of existing branch matching worktree name */ + git_reference *ref; /**< reference to use for the new worktree HEAD */ } git_worktree_add_options; -#define GIT_WORKTREE_ADD_OPTIONS_VERSION 2 -#define GIT_WORKTREE_ADD_OPTIONS_INIT {GIT_WORKTREE_ADD_OPTIONS_VERSION,0,0,NULL} +#define GIT_WORKTREE_ADD_OPTIONS_VERSION 1 +#define GIT_WORKTREE_ADD_OPTIONS_INIT { GIT_WORKTREE_ADD_OPTIONS_VERSION } /** * Initialize git_worktree_add_options structure From 7bbb07f83f36dbdad6b2fa0b45eb7a87a1a818f9 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 8 Mar 2024 16:51:11 +0000 Subject: [PATCH 536/608] worktree: dry up the refdb_fs iterator The refdb iterator has grown a bit and has a few concerns intermixed. Refactor a bit to improve readability while trying to avoid unnecessary git_str allocations. --- src/libgit2/refdb_fs.c | 201 +++++++++++++++++++++++------------------ 1 file changed, 111 insertions(+), 90 deletions(-) diff --git a/src/libgit2/refdb_fs.c b/src/libgit2/refdb_fs.c index 4628e01dc99..14368e34775 100644 --- a/src/libgit2/refdb_fs.c +++ b/src/libgit2/refdb_fs.c @@ -794,125 +794,146 @@ static void refdb_fs_backend__iterator_free(git_reference_iterator *_iter) git__free(iter); } -static int iter_load_loose_paths(refdb_fs_backend *backend, refdb_fs_iter *iter) +struct iter_load_context { + refdb_fs_backend *backend; + refdb_fs_iter *iter; + + /* + * If we have a glob with a prefix (eg `refs/heads/ *`) then we can + * optimize our prefix to avoid walking refs that we know won't + * match. This is that prefix. + */ + const char *ref_prefix; + size_t ref_prefix_len; + + /* Temporary variables to avoid unnecessary allocations */ + git_str ref_name; + git_str path; +}; + +static void iter_load_optimize_prefix(struct iter_load_context *ctx) { - int error = 0; - git_str path = GIT_STR_INIT; - git_iterator *fsit = NULL; - git_iterator_options fsit_opts = GIT_ITERATOR_OPTIONS_INIT; - const git_index_entry *entry = NULL; - const char *ref_prefix = GIT_REFS_DIR; - size_t ref_prefix_len = strlen(ref_prefix); + const char *pos, *last_sep = NULL; - if (!backend->commonpath) /* do nothing if no commonpath for loose refs */ - return 0; + if (!ctx->iter->glob) + return; - fsit_opts.flags = backend->iterator_flags; - - if (iter->glob) { - const char *last_sep = NULL; - const char *pos; - for (pos = iter->glob; *pos; ++pos) { - switch (*pos) { - case '?': - case '*': - case '[': - case '\\': - break; - case '/': - last_sep = pos; - /* FALLTHROUGH */ - default: - continue; - } + for (pos = ctx->iter->glob; *pos; pos++) { + switch (*pos) { + case '?': + case '*': + case '[': + case '\\': break; + case '/': + last_sep = pos; + /* FALLTHROUGH */ + default: + continue; } - if (last_sep) { - ref_prefix = iter->glob; - ref_prefix_len = (last_sep - ref_prefix) + 1; - } + break; } - if ((error = git_str_puts(&path, backend->commonpath)) < 0 || - (error = git_str_put(&path, ref_prefix, ref_prefix_len)) < 0) { - git_str_dispose(&path); - return error; + if (last_sep) { + ctx->ref_prefix = ctx->iter->glob; + ctx->ref_prefix_len = (last_sep - ctx->ref_prefix) + 1; } +} + +static int iter_load_paths( + struct iter_load_context *ctx, + const char *root_path, + bool worktree) +{ + git_iterator *fsit = NULL; + git_iterator_options fsit_opts = GIT_ITERATOR_OPTIONS_INIT; + const git_index_entry *entry; + int error = 0; + + fsit_opts.flags = ctx->backend->iterator_flags; + + git_str_clear(&ctx->path); + git_str_puts(&ctx->path, root_path); + git_str_put(&ctx->path, ctx->ref_prefix, ctx->ref_prefix_len); + + if ((error = git_iterator_for_filesystem(&fsit, ctx->path.ptr, &fsit_opts)) < 0) { + /* + * Subdirectories - either glob provided or per-worktree refs - need + * not exist. + */ + if ((worktree || ctx->iter->glob) && error == GIT_ENOTFOUND) + error = 0; - if ((error = git_iterator_for_filesystem(&fsit, path.ptr, &fsit_opts)) < 0) { - git_str_dispose(&path); - return (iter->glob && error == GIT_ENOTFOUND)? 0 : error; + goto done; } - error = git_str_sets(&path, ref_prefix); + git_str_clear(&ctx->ref_name); + git_str_put(&ctx->ref_name, ctx->ref_prefix, ctx->ref_prefix_len); - while (!error && !git_iterator_advance(&entry, fsit)) { - const char *ref_name; + while (git_iterator_advance(&entry, fsit) == 0) { char *ref_dup; - git_str_truncate(&path, ref_prefix_len); - git_str_puts(&path, entry->path); - ref_name = git_str_cstr(&path); - if (git_repository_is_worktree(backend->repo) == 1 && is_per_worktree_ref(ref_name)) + git_str_truncate(&ctx->ref_name, ctx->ref_prefix_len); + git_str_puts(&ctx->ref_name, entry->path); + + if (worktree) { + if (!is_per_worktree_ref(ctx->ref_name.ptr)) + continue; + } else { + if (git_repository_is_worktree(ctx->backend->repo) && + is_per_worktree_ref(ctx->ref_name.ptr)) + continue; + } + + if (git__suffixcmp(ctx->ref_name.ptr, ".lock") == 0) continue; - if (git__suffixcmp(ref_name, ".lock") == 0 || - (iter->glob && wildmatch(iter->glob, ref_name, 0) != 0)) + if (ctx->iter->glob && wildmatch(ctx->iter->glob, ctx->ref_name.ptr, 0)) continue; - ref_dup = git_pool_strdup(&iter->pool, ref_name); - if (!ref_dup) - error = -1; - else - error = git_vector_insert(&iter->loose, ref_dup); + ref_dup = git_pool_strdup(&ctx->iter->pool, ctx->ref_name.ptr); + GIT_ERROR_CHECK_ALLOC(ref_dup); + + if ((error = git_vector_insert(&ctx->iter->loose, ref_dup)) < 0) + goto done; } - if (!error && git_repository_is_worktree(backend->repo) == 1) { - git_iterator_free(fsit); - git_str_clear(&path); - if ((error = git_str_puts(&path, backend->gitpath)) < 0 || - (error = git_str_put(&path, ref_prefix, ref_prefix_len)) < 0 || - !git_fs_path_exists(git_str_cstr(&path))) { - git_str_dispose(&path); - return error; - } +done: + git_iterator_free(fsit); + return error; +} - if ((error = git_iterator_for_filesystem( - &fsit, path.ptr, &fsit_opts)) < 0) { - git_str_dispose(&path); - return (iter->glob && error == GIT_ENOTFOUND) ? 0 : error; - } +#define iter_load_context_init(b, i) { b, i, GIT_REFS_DIR, CONST_STRLEN(GIT_REFS_DIR) } +#define iter_load_context_dispose(ctx) do { \ + git_str_dispose(&((ctx)->path)); \ + git_str_dispose(&((ctx)->ref_name)); \ +} while(0) - error = git_str_sets(&path, ref_prefix); +static int iter_load_loose_paths( + refdb_fs_backend *backend, + refdb_fs_iter *iter) +{ + struct iter_load_context ctx = iter_load_context_init(backend, iter); - while (!error && !git_iterator_advance(&entry, fsit)) { - const char *ref_name; - char *ref_dup; + int error = 0; - git_str_truncate(&path, ref_prefix_len); - git_str_puts(&path, entry->path); - ref_name = git_str_cstr(&path); + if (!backend->commonpath) + return 0; - if (!is_per_worktree_ref(ref_name)) - continue; + iter_load_optimize_prefix(&ctx); - if (git__suffixcmp(ref_name, ".lock") == 0 || - (iter->glob && - wildmatch(iter->glob, ref_name, 0) != 0)) - continue; + if ((error = iter_load_paths(&ctx, + backend->commonpath, false)) < 0) + goto done; - ref_dup = git_pool_strdup(&iter->pool, ref_name); - if (!ref_dup) - error = -1; - else - error = git_vector_insert( - &iter->loose, ref_dup); - } + if (git_repository_is_worktree(backend->repo)) { + if ((error = iter_load_paths(&ctx, + backend->gitpath, true)) < 0) + goto done; } - git_iterator_free(fsit); - git_str_dispose(&path); - +done: + iter_load_context_dispose(&ctx); return error; } From b499a3465c121c9f942648adadd56495727b38d9 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sun, 3 Mar 2024 21:48:06 +0000 Subject: [PATCH 537/608] config: introduce a writers list Configuration read order and write order should be separated. For example: configuration readers have a worktree level that is higher priority than the local configuration _for reads_. Despite that, the worktree configuration is not written to by default. Use a new list, `writers`, to identify the write target. To do this, we need another level of indirection between backend instances (which are refcounted and shared amongst different git_config instances) and the config reader/writer list (since each of those different git_config instances can have different read/write priorities). --- include/git2/config.h | 9 + src/libgit2/config.c | 597 ++++++++++++++++++++------------------- src/libgit2/config.h | 3 +- src/libgit2/repository.c | 8 +- 4 files changed, 327 insertions(+), 290 deletions(-) diff --git a/include/git2/config.h b/include/git2/config.h index a711e1561dc..32361431326 100644 --- a/include/git2/config.h +++ b/include/git2/config.h @@ -32,6 +32,10 @@ GIT_BEGIN_DECL * Callers can add their own custom configuration, beginning at the * `GIT_CONFIG_LEVEL_APP` level. * + * Writes, by default, occur in the highest priority level backend + * that is writable. This ordering can be overridden with + * `git_config_set_writeorder`. + * * git_config_open_default() and git_repository_config() honor those * priority levels as well. */ @@ -307,6 +311,11 @@ GIT_EXTERN(int) git_config_open_level( */ GIT_EXTERN(int) git_config_open_global(git_config **out, git_config *config); +GIT_EXTERN(int) git_config_set_writeorder( + git_config *cfg, + git_config_level_t *levels, + size_t len); + /** * Create a snapshot of the configuration * diff --git a/src/libgit2/config.c b/src/libgit2/config.c index d3193c95e26..fdf32e9669a 100644 --- a/src/libgit2/config.c +++ b/src/libgit2/config.c @@ -22,6 +22,32 @@ #include +/* + * A refcounted instance of a config_backend that can be shared across + * a configuration instance, any snapshots, and individual configuration + * levels (from `git_config_open_level`). + */ +typedef struct { + git_refcount rc; + git_config_backend *backend; +} backend_instance; + +/* + * An entry in the readers or writers vector in the configuration. + * This is kept separate from the refcounted instance so that different + * views of the configuration can have different notions of levels or + * write orders. + * + * (eg, a standard configuration has a priority ordering of writers, a + * snapshot has *no* writers, and an individual level has a single + * writer.) + */ +typedef struct { + backend_instance *instance; + git_config_level_t level; + int write_order; +} backend_entry; + void git_config_entry_free(git_config_entry *entry) { if (!entry) @@ -30,75 +56,75 @@ void git_config_entry_free(git_config_entry *entry) entry->free(entry); } -typedef struct { - git_refcount rc; - - git_config_backend *backend; - git_config_level_t level; -} backend_internal; - -static void backend_internal_free(backend_internal *internal) +static void backend_instance_free(backend_instance *instance) { git_config_backend *backend; - backend = internal->backend; + backend = instance->backend; backend->free(backend); - git__free(internal); + git__free(instance); } -static void config_free(git_config *cfg) +static void config_free(git_config *config) { size_t i; - backend_internal *internal; + backend_entry *entry; - for (i = 0; i < cfg->backends.length; ++i) { - internal = git_vector_get(&cfg->backends, i); - GIT_REFCOUNT_DEC(internal, backend_internal_free); + git_vector_foreach(&config->readers, i, entry) { + GIT_REFCOUNT_DEC(entry->instance, backend_instance_free); + git__free(entry); } - git_vector_free(&cfg->backends); - - git__memzero(cfg, sizeof(*cfg)); - git__free(cfg); + git_vector_free(&config->readers); + git_vector_free(&config->writers); + git__free(config); } -void git_config_free(git_config *cfg) +void git_config_free(git_config *config) { - if (cfg == NULL) + if (config == NULL) return; - GIT_REFCOUNT_DEC(cfg, config_free); + GIT_REFCOUNT_DEC(config, config_free); } -static int config_backend_cmp(const void *a, const void *b) +static int reader_cmp(const void *_a, const void *_b) { - const backend_internal *bk_a = (const backend_internal *)(a); - const backend_internal *bk_b = (const backend_internal *)(b); + const backend_entry *a = _a; + const backend_entry *b = _b; - return bk_b->level - bk_a->level; + return b->level - a->level; } -int git_config_new(git_config **out) +static int writer_cmp(const void *_a, const void *_b) { - git_config *cfg; + const backend_entry *a = _a; + const backend_entry *b = _b; - cfg = git__malloc(sizeof(git_config)); - GIT_ERROR_CHECK_ALLOC(cfg); + return b->write_order - a->write_order; +} - memset(cfg, 0x0, sizeof(git_config)); +int git_config_new(git_config **out) +{ + git_config *config; - if (git_vector_init(&cfg->backends, 3, config_backend_cmp) < 0) { - git__free(cfg); + config = git__calloc(1, sizeof(git_config)); + GIT_ERROR_CHECK_ALLOC(config); + + if (git_vector_init(&config->readers, 8, reader_cmp) < 0 || + git_vector_init(&config->writers, 8, writer_cmp) < 0) { + config_free(config); return -1; } - *out = cfg; - GIT_REFCOUNT_INC(cfg); + GIT_REFCOUNT_INC(config); + + *out = config; return 0; } int git_config_add_file_ondisk( - git_config *cfg, + git_config *config, const char *path, git_config_level_t level, const git_repository *repo, @@ -108,7 +134,7 @@ int git_config_add_file_ondisk( struct stat st; int res; - GIT_ASSERT_ARG(cfg); + GIT_ASSERT_ARG(config); GIT_ASSERT_ARG(path); res = p_stat(path, &st); @@ -120,7 +146,7 @@ int git_config_add_file_ondisk( if (git_config_backend_from_file(&file, path) < 0) return -1; - if ((res = git_config_add_backend(cfg, file, level, repo, force)) < 0) { + if ((res = git_config_add_backend(config, file, level, repo, force)) < 0) { /* * free manually; the file is not owned by the config * instance yet and will not be freed on cleanup @@ -154,7 +180,7 @@ int git_config_snapshot(git_config **out, git_config *in) { int error = 0; size_t i; - backend_internal *internal; + backend_entry *entry; git_config *config; *out = NULL; @@ -162,18 +188,20 @@ int git_config_snapshot(git_config **out, git_config *in) if (git_config_new(&config) < 0) return -1; - git_vector_foreach(&in->backends, i, internal) { + git_vector_foreach(&in->readers, i, entry) { git_config_backend *b; - if ((error = internal->backend->snapshot(&b, internal->backend)) < 0) + if ((error = entry->instance->backend->snapshot(&b, entry->instance->backend)) < 0) break; - if ((error = git_config_add_backend(config, b, internal->level, NULL, 0)) < 0) { + if ((error = git_config_add_backend(config, b, entry->level, NULL, 0)) < 0) { b->free(b); break; } } + git_config_set_writeorder(config, NULL, 0); + if (error < 0) git_config_free(config); else @@ -183,141 +211,162 @@ int git_config_snapshot(git_config **out, git_config *in) } static int find_backend_by_level( - backend_internal **out, - const git_config *cfg, + backend_instance **out, + const git_config *config, git_config_level_t level) { - int pos = -1; - backend_internal *internal; + backend_entry *entry, *found = NULL; size_t i; - /* when passing GIT_CONFIG_HIGHEST_LEVEL, the idea is to get the config backend - * which has the highest level. As config backends are stored in a vector - * sorted by decreasing order of level, getting the backend at position 0 - * will do the job. + /* + * when passing GIT_CONFIG_HIGHEST_LEVEL, the idea is to get the + * config backend which has the highest level. As config backends + * are stored in a vector sorted by decreasing order of level, + * getting the backend at position 0 will do the job. */ if (level == GIT_CONFIG_HIGHEST_LEVEL) { - pos = 0; + found = git_vector_get(&config->readers, 0); } else { - git_vector_foreach(&cfg->backends, i, internal) { - if (internal->level == level) - pos = (int)i; + git_vector_foreach(&config->readers, i, entry) { + if (entry->level == level) { + found = entry; + break; + } } } - if (pos == -1) { + if (!found) { git_error_set(GIT_ERROR_CONFIG, - "no configuration exists for the given level '%i'", (int)level); + "no configuration exists for the given level '%d'", level); return GIT_ENOTFOUND; } - *out = git_vector_get(&cfg->backends, pos); - + *out = entry->instance; return 0; } -static int duplicate_level(void **old_raw, void *new_raw) +static int duplicate_level(void **_old, void *_new) { - backend_internal **old = (backend_internal **)old_raw; + backend_entry **old = (backend_entry **)_old; - GIT_UNUSED(new_raw); + GIT_UNUSED(_new); - git_error_set(GIT_ERROR_CONFIG, "there already exists a configuration for the given level (%i)", (int)(*old)->level); + git_error_set(GIT_ERROR_CONFIG, "configuration at level %d already exists", (*old)->level); return GIT_EEXISTS; } static void try_remove_existing_backend( - git_config *cfg, + git_config *config, git_config_level_t level) { - int pos = -1; - backend_internal *internal; + backend_entry *entry, *found = NULL; size_t i; - git_vector_foreach(&cfg->backends, i, internal) { - if (internal->level == level) - pos = (int)i; + git_vector_foreach(&config->readers, i, entry) { + if (entry->level == level) { + git_vector_remove(&config->readers, i); + found = entry; + break; + } } - if (pos == -1) + if (!found) return; - internal = git_vector_get(&cfg->backends, pos); - - if (git_vector_remove(&cfg->backends, pos) < 0) - return; + git_vector_foreach(&config->writers, i, entry) { + if (entry->level == level) { + git_vector_remove(&config->writers, i); + break; + } + } - GIT_REFCOUNT_DEC(internal, backend_internal_free); + GIT_REFCOUNT_DEC(found->instance, backend_instance_free); + git__free(found); } -static int git_config__add_internal( - git_config *cfg, - backend_internal *internal, +static int git_config__add_instance( + git_config *config, + backend_instance *instance, git_config_level_t level, int force) { + backend_entry *entry; int result; /* delete existing config backend for level if it exists */ if (force) - try_remove_existing_backend(cfg, level); + try_remove_existing_backend(config, level); - if ((result = git_vector_insert_sorted(&cfg->backends, - internal, &duplicate_level)) < 0) - return result; + entry = git__malloc(sizeof(backend_entry)); + GIT_ERROR_CHECK_ALLOC(entry); - git_vector_sort(&cfg->backends); - internal->backend->cfg = cfg; + entry->instance = instance; + entry->level = level; + entry->write_order = level; - GIT_REFCOUNT_INC(internal); + if ((result = git_vector_insert_sorted(&config->readers, + entry, &duplicate_level)) < 0 || + (result = git_vector_insert_sorted(&config->writers, + entry, NULL)) < 0) { + git__free(entry); + return result; + } + + GIT_REFCOUNT_INC(entry->instance); return 0; } -int git_config_open_global(git_config **cfg_out, git_config *cfg) +int git_config_open_global(git_config **out, git_config *config) { - if (!git_config_open_level(cfg_out, cfg, GIT_CONFIG_LEVEL_XDG)) + int error; + + error = git_config_open_level(out, config, GIT_CONFIG_LEVEL_XDG); + + if (error == 0) return 0; + else if (error != GIT_ENOTFOUND) + return error; - return git_config_open_level(cfg_out, cfg, GIT_CONFIG_LEVEL_GLOBAL); + return git_config_open_level(out, config, GIT_CONFIG_LEVEL_GLOBAL); } int git_config_open_level( - git_config **cfg_out, - const git_config *cfg_parent, + git_config **out, + const git_config *parent, git_config_level_t level) { - git_config *cfg; - backend_internal *internal; + git_config *config; + backend_instance *instance; int res; - if ((res = find_backend_by_level(&internal, cfg_parent, level)) < 0) + if ((res = find_backend_by_level(&instance, parent, level)) < 0) return res; - if ((res = git_config_new(&cfg)) < 0) + if ((res = git_config_new(&config)) < 0) return res; - if ((res = git_config__add_internal(cfg, internal, level, true)) < 0) { - git_config_free(cfg); + if ((res = git_config__add_instance(config, instance, level, true)) < 0) { + git_config_free(config); return res; } - *cfg_out = cfg; + *out = config; return 0; } int git_config_add_backend( - git_config *cfg, + git_config *config, git_config_backend *backend, git_config_level_t level, const git_repository *repo, int force) { - backend_internal *internal; + backend_instance *instance; int result; - GIT_ASSERT_ARG(cfg); + GIT_ASSERT_ARG(config); GIT_ASSERT_ARG(backend); GIT_ERROR_CHECK_VERSION(backend, GIT_CONFIG_BACKEND_VERSION, "git_config_backend"); @@ -325,22 +374,50 @@ int git_config_add_backend( if ((result = backend->open(backend, level, repo)) < 0) return result; - internal = git__malloc(sizeof(backend_internal)); - GIT_ERROR_CHECK_ALLOC(internal); + instance = git__calloc(1, sizeof(backend_instance)); + GIT_ERROR_CHECK_ALLOC(instance); - memset(internal, 0x0, sizeof(backend_internal)); + instance->backend = backend; + instance->backend->cfg = config; - internal->backend = backend; - internal->level = level; - - if ((result = git_config__add_internal(cfg, internal, level, force)) < 0) { - git__free(internal); + if ((result = git_config__add_instance(config, instance, level, force)) < 0) { + git__free(instance); return result; } return 0; } +int git_config_set_writeorder( + git_config *config, + git_config_level_t *levels, + size_t len) +{ + backend_entry *entry; + size_t i, j; + + GIT_ASSERT(len < INT_MAX); + + git_vector_foreach(&config->readers, i, entry) { + bool found = false; + + for (j = 0; j < len; j++) { + if (levels[j] == entry->level) { + entry->write_order = (int)j; + found = true; + break; + } + } + + if (!found) + entry->write_order = -1; + } + + git_vector_sort(&config->writers); + + return 0; +} + /* * Loop over all the variables */ @@ -348,19 +425,18 @@ int git_config_add_backend( typedef struct { git_config_iterator parent; git_config_iterator *current; - const git_config *cfg; + const git_config *config; git_regexp regex; size_t i; } all_iter; -static int find_next_backend(size_t *out, const git_config *cfg, size_t i) +static int find_next_backend(size_t *out, const git_config *config, size_t i) { - backend_internal *internal; + backend_entry *entry; for (; i > 0; --i) { - internal = git_vector_get(&cfg->backends, i - 1); - if (!internal || !internal->backend) - continue; + entry = git_vector_get(&config->readers, i - 1); + GIT_ASSERT(entry && entry->instance && entry->instance->backend); *out = i; return 0; @@ -369,16 +445,16 @@ static int find_next_backend(size_t *out, const git_config *cfg, size_t i) return -1; } -static int all_iter_next(git_config_entry **entry, git_config_iterator *_iter) +static int all_iter_next(git_config_entry **out, git_config_iterator *_iter) { all_iter *iter = (all_iter *) _iter; - backend_internal *internal; + backend_entry *entry; git_config_backend *backend; size_t i; int error = 0; if (iter->current != NULL && - (error = iter->current->next(entry, iter->current)) == 0) { + (error = iter->current->next(out, iter->current)) == 0) { return 0; } @@ -386,11 +462,11 @@ static int all_iter_next(git_config_entry **entry, git_config_iterator *_iter) return error; do { - if (find_next_backend(&i, iter->cfg, iter->i) < 0) + if (find_next_backend(&i, iter->config, iter->i) < 0) return GIT_ITEROVER; - internal = git_vector_get(&iter->cfg->backends, i - 1); - backend = internal->backend; + entry = git_vector_get(&iter->config->readers, i - 1); + backend = entry->instance->backend; iter->i = i - 1; if (iter->current) @@ -404,7 +480,7 @@ static int all_iter_next(git_config_entry **entry, git_config_iterator *_iter) if (error < 0) return error; - error = iter->current->next(entry, iter->current); + error = iter->current->next(out, iter->current); /* If this backend is empty, then keep going */ if (error == GIT_ITEROVER) continue; @@ -423,7 +499,7 @@ static int all_iter_glob_next(git_config_entry **entry, git_config_iterator *_it /* * We use the "normal" function to grab the next one across - * backends and then apply the regex + * readers and then apply the regex */ while ((error = all_iter_next(entry, _iter)) == 0) { /* skip non-matching keys if regexp was provided */ @@ -455,7 +531,7 @@ static void all_iter_glob_free(git_config_iterator *_iter) all_iter_free(_iter); } -int git_config_iterator_new(git_config_iterator **out, const git_config *cfg) +int git_config_iterator_new(git_config_iterator **out, const git_config *config) { all_iter *iter; @@ -465,21 +541,21 @@ int git_config_iterator_new(git_config_iterator **out, const git_config *cfg) iter->parent.free = all_iter_free; iter->parent.next = all_iter_next; - iter->i = cfg->backends.length; - iter->cfg = cfg; + iter->i = config->readers.length; + iter->config = config; *out = (git_config_iterator *) iter; return 0; } -int git_config_iterator_glob_new(git_config_iterator **out, const git_config *cfg, const char *regexp) +int git_config_iterator_glob_new(git_config_iterator **out, const git_config *config, const char *regexp) { all_iter *iter; int result; if (regexp == NULL) - return git_config_iterator_new(out, cfg); + return git_config_iterator_new(out, config); iter = git__calloc(1, sizeof(all_iter)); GIT_ERROR_CHECK_ALLOC(iter); @@ -491,8 +567,8 @@ int git_config_iterator_glob_new(git_config_iterator **out, const git_config *cf iter->parent.next = all_iter_glob_next; iter->parent.free = all_iter_glob_free; - iter->i = cfg->backends.length; - iter->cfg = cfg; + iter->i = config->readers.length; + iter->config = config; *out = (git_config_iterator *) iter; @@ -500,9 +576,9 @@ int git_config_iterator_glob_new(git_config_iterator **out, const git_config *cf } int git_config_foreach( - const git_config *cfg, git_config_foreach_cb cb, void *payload) + const git_config *config, git_config_foreach_cb cb, void *payload) { - return git_config_foreach_match(cfg, NULL, cb, payload); + return git_config_foreach_match(config, NULL, cb, payload); } int git_config_backend_foreach_match( @@ -548,7 +624,7 @@ int git_config_backend_foreach_match( } int git_config_foreach_match( - const git_config *cfg, + const git_config *config, const char *regexp, git_config_foreach_cb cb, void *payload) @@ -557,7 +633,7 @@ int git_config_foreach_match( git_config_iterator *iter; git_config_entry *entry; - if ((error = git_config_iterator_glob_new(&iter, cfg, regexp)) < 0) + if ((error = git_config_iterator_glob_new(&iter, config, regexp)) < 0) return error; while (!(error = git_config_next(&entry, iter))) { @@ -579,103 +655,52 @@ int git_config_foreach_match( * Setters **************/ -typedef enum { - BACKEND_USE_SET, - BACKEND_USE_DELETE -} backend_use; - -static const char *uses[] = { - "set", - "delete" -}; - -static int get_backend_for_use(git_config_backend **out, - git_config *cfg, const char *name, backend_use use) +static git_config_backend *get_writer(git_config *config) { + backend_entry *entry; size_t i; - size_t len; - backend_internal *backend; - int error = 0; - git_config_entry *entry = NULL; - char *key = NULL; - *out = NULL; - - len = git_vector_length(&cfg->backends); - if (len == 0) { - git_error_set(GIT_ERROR_CONFIG, - "cannot %s value for '%s' when no config backends exist", - uses[use], name); - return GIT_ENOTFOUND; - } - - git_vector_foreach(&cfg->backends, i, backend) { - if (backend->backend->readonly) + git_vector_foreach(&config->writers, i, entry) { + if (entry->instance->backend->readonly) continue; - /* git-config doesn't update worktree-level config - unless specifically requested; follow suit. If you - specifically want to update that level, open the - single config level with git_config_open_level and - provide that as the config. In this case, there - will only be one backend in the config. */ - if (len > 1 && backend->level == GIT_CONFIG_LEVEL_WORKTREE) + if (entry->write_order < 0) continue; - /* If we're trying to delete a piece of config, make - sure the backend we return actually defines it in - the first place. */ - if (use == BACKEND_USE_DELETE) { - if (key == NULL && (error = git_config__normalize_name(name, &key)) < 0) - goto cleanup; - if (backend->backend->get(backend->backend, key, &entry) < 0) - continue; - git_config_entry_free(entry); - } - - *out = backend->backend; - goto cleanup; + return entry->instance->backend; } - error = GIT_ENOTFOUND; - git_error_set(GIT_ERROR_CONFIG, - "cannot %s value for '%s' when all config backends are readonly", - uses[use], name); - - cleanup: - git__free(key); - return error; + return NULL; } -int git_config_delete_entry(git_config *cfg, const char *name) +int git_config_delete_entry(git_config *config, const char *name) { git_config_backend *backend; - int error = 0; - if ((error = get_backend_for_use(&backend, cfg, name, BACKEND_USE_DELETE)) < 0) - return error; + if ((backend = get_writer(config)) == NULL) + return GIT_ENOTFOUND; return backend->del(backend, name); } -int git_config_set_int64(git_config *cfg, const char *name, int64_t value) +int git_config_set_int64(git_config *config, const char *name, int64_t value) { char str_value[32]; /* All numbers should fit in here */ p_snprintf(str_value, sizeof(str_value), "%" PRId64, value); - return git_config_set_string(cfg, name, str_value); + return git_config_set_string(config, name, str_value); } -int git_config_set_int32(git_config *cfg, const char *name, int32_t value) +int git_config_set_int32(git_config *config, const char *name, int32_t value) { - return git_config_set_int64(cfg, name, (int64_t)value); + return git_config_set_int64(config, name, (int64_t)value); } -int git_config_set_bool(git_config *cfg, const char *name, int value) +int git_config_set_bool(git_config *config, const char *name, int value) { - return git_config_set_string(cfg, name, value ? "true" : "false"); + return git_config_set_string(config, name, value ? "true" : "false"); } -int git_config_set_string(git_config *cfg, const char *name, const char *value) +int git_config_set_string(git_config *config, const char *name, const char *value) { int error; git_config_backend *backend; @@ -685,13 +710,15 @@ int git_config_set_string(git_config *cfg, const char *name, const char *value) return -1; } - if ((error = get_backend_for_use(&backend, cfg, name, BACKEND_USE_SET)) < 0) - return error; + if ((backend = get_writer(config)) == NULL) { + git_error_set(GIT_ERROR_CONFIG, "cannot set '%s': the configuration is read-only", name); + return GIT_ENOTFOUND; + } error = backend->set(backend, name, value); - if (!error && GIT_REFCOUNT_OWNER(cfg) != NULL) - git_repository__configmap_lookup_cache_clear(GIT_REFCOUNT_OWNER(cfg)); + if (!error && GIT_REFCOUNT_OWNER(config) != NULL) + git_repository__configmap_lookup_cache_clear(GIT_REFCOUNT_OWNER(config)); return error; } @@ -745,16 +772,17 @@ enum { static int get_entry( git_config_entry **out, - const git_config *cfg, + const git_config *config, const char *name, bool normalize_name, int want_errors) { + backend_entry *entry; + git_config_backend *backend; int res = GIT_ENOTFOUND; const char *key = name; char *normalized = NULL; size_t i; - backend_internal *internal; *out = NULL; @@ -765,11 +793,12 @@ static int get_entry( } res = GIT_ENOTFOUND; - git_vector_foreach(&cfg->backends, i, internal) { - if (!internal || !internal->backend) - continue; + git_vector_foreach(&config->readers, i, entry) { + GIT_ASSERT(entry->instance && entry->instance->backend); + + backend = entry->instance->backend; + res = backend->get(backend, key, out); - res = internal->backend->get(internal->backend, key, out); if (res != GIT_ENOTFOUND) break; } @@ -777,9 +806,9 @@ static int get_entry( git__free(normalized); cleanup: - if (res == GIT_ENOTFOUND) + if (res == GIT_ENOTFOUND) { res = (want_errors > GET_ALL_ERRORS) ? 0 : config_error_notfound(name); - else if (res && (want_errors == GET_NO_ERRORS)) { + } else if (res && (want_errors == GET_NO_ERRORS)) { git_error_clear(); res = 0; } @@ -788,24 +817,24 @@ static int get_entry( } int git_config_get_entry( - git_config_entry **out, const git_config *cfg, const char *name) + git_config_entry **out, const git_config *config, const char *name) { - return get_entry(out, cfg, name, true, GET_ALL_ERRORS); + return get_entry(out, config, name, true, GET_ALL_ERRORS); } int git_config__lookup_entry( git_config_entry **out, - const git_config *cfg, + const git_config *config, const char *key, bool no_errors) { return get_entry( - out, cfg, key, false, no_errors ? GET_NO_ERRORS : GET_NO_MISSING); + out, config, key, false, no_errors ? GET_NO_ERRORS : GET_NO_MISSING); } int git_config_get_mapped( int *out, - const git_config *cfg, + const git_config *config, const char *name, const git_configmap *maps, size_t map_n) @@ -813,7 +842,7 @@ int git_config_get_mapped( git_config_entry *entry; int ret; - if ((ret = get_entry(&entry, cfg, name, true, GET_ALL_ERRORS)) < 0) + if ((ret = get_entry(&entry, config, name, true, GET_ALL_ERRORS)) < 0) return ret; ret = git_config_lookup_map_value(out, maps, map_n, entry->value); @@ -822,12 +851,12 @@ int git_config_get_mapped( return ret; } -int git_config_get_int64(int64_t *out, const git_config *cfg, const char *name) +int git_config_get_int64(int64_t *out, const git_config *config, const char *name) { git_config_entry *entry; int ret; - if ((ret = get_entry(&entry, cfg, name, true, GET_ALL_ERRORS)) < 0) + if ((ret = get_entry(&entry, config, name, true, GET_ALL_ERRORS)) < 0) return ret; ret = git_config_parse_int64(out, entry->value); @@ -836,12 +865,12 @@ int git_config_get_int64(int64_t *out, const git_config *cfg, const char *name) return ret; } -int git_config_get_int32(int32_t *out, const git_config *cfg, const char *name) +int git_config_get_int32(int32_t *out, const git_config *config, const char *name) { git_config_entry *entry; int ret; - if ((ret = get_entry(&entry, cfg, name, true, GET_ALL_ERRORS)) < 0) + if ((ret = get_entry(&entry, config, name, true, GET_ALL_ERRORS)) < 0) return ret; ret = git_config_parse_int32(out, entry->value); @@ -850,12 +879,12 @@ int git_config_get_int32(int32_t *out, const git_config *cfg, const char *name) return ret; } -int git_config_get_bool(int *out, const git_config *cfg, const char *name) +int git_config_get_bool(int *out, const git_config *config, const char *name) { git_config_entry *entry; int ret; - if ((ret = get_entry(&entry, cfg, name, true, GET_ALL_ERRORS)) < 0) + if ((ret = get_entry(&entry, config, name, true, GET_ALL_ERRORS)) < 0) return ret; ret = git_config_parse_bool(out, entry->value); @@ -864,16 +893,15 @@ int git_config_get_bool(int *out, const git_config *cfg, const char *name) return ret; } -static int is_readonly(const git_config *cfg) +static int is_readonly(const git_config *config) { + backend_entry *entry; size_t i; - backend_internal *internal; - git_vector_foreach(&cfg->backends, i, internal) { - if (!internal || !internal->backend) - continue; + git_vector_foreach(&config->writers, i, entry) { + GIT_ASSERT(entry->instance && entry->instance->backend); - if (!internal->backend->readonly) + if (!entry->instance->backend->readonly) return 0; } @@ -904,21 +932,21 @@ int git_config_parse_path(git_buf *out, const char *value) int git_config_get_path( git_buf *out, - const git_config *cfg, + const git_config *config, const char *name) { - GIT_BUF_WRAP_PRIVATE(out, git_config__get_path, cfg, name); + GIT_BUF_WRAP_PRIVATE(out, git_config__get_path, config, name); } int git_config__get_path( git_str *out, - const git_config *cfg, + const git_config *config, const char *name) { git_config_entry *entry; int error; - if ((error = get_entry(&entry, cfg, name, true, GET_ALL_ERRORS)) < 0) + if ((error = get_entry(&entry, config, name, true, GET_ALL_ERRORS)) < 0) return error; error = git_config__parse_path(out, entry->value); @@ -928,17 +956,17 @@ int git_config__get_path( } int git_config_get_string( - const char **out, const git_config *cfg, const char *name) + const char **out, const git_config *config, const char *name) { git_config_entry *entry; int ret; - if (!is_readonly(cfg)) { + if (!is_readonly(config)) { git_error_set(GIT_ERROR_CONFIG, "get_string called on a live config object"); return -1; } - ret = get_entry(&entry, cfg, name, true, GET_ALL_ERRORS); + ret = get_entry(&entry, config, name, true, GET_ALL_ERRORS); *out = !ret ? (entry->value ? entry->value : "") : NULL; git_config_entry_free(entry); @@ -947,22 +975,22 @@ int git_config_get_string( } int git_config_get_string_buf( - git_buf *out, const git_config *cfg, const char *name) + git_buf *out, const git_config *config, const char *name) { - GIT_BUF_WRAP_PRIVATE(out, git_config__get_string_buf, cfg, name); + GIT_BUF_WRAP_PRIVATE(out, git_config__get_string_buf, config, name); } int git_config__get_string_buf( - git_str *out, const git_config *cfg, const char *name) + git_str *out, const git_config *config, const char *name) { git_config_entry *entry; int ret; const char *str; GIT_ASSERT_ARG(out); - GIT_ASSERT_ARG(cfg); + GIT_ASSERT_ARG(config); - ret = get_entry(&entry, cfg, name, true, GET_ALL_ERRORS); + ret = get_entry(&entry, config, name, true, GET_ALL_ERRORS); str = !ret ? (entry->value ? entry->value : "") : NULL; if (str) @@ -974,12 +1002,12 @@ int git_config__get_string_buf( } char *git_config__get_string_force( - const git_config *cfg, const char *key, const char *fallback_value) + const git_config *config, const char *key, const char *fallback_value) { git_config_entry *entry; char *ret; - get_entry(&entry, cfg, key, false, GET_NO_ERRORS); + get_entry(&entry, config, key, false, GET_NO_ERRORS); ret = (entry && entry->value) ? git__strdup(entry->value) : fallback_value ? git__strdup(fallback_value) : NULL; git_config_entry_free(entry); @@ -987,12 +1015,12 @@ char *git_config__get_string_force( } int git_config__get_bool_force( - const git_config *cfg, const char *key, int fallback_value) + const git_config *config, const char *key, int fallback_value) { int val = fallback_value; git_config_entry *entry; - get_entry(&entry, cfg, key, false, GET_NO_ERRORS); + get_entry(&entry, config, key, false, GET_NO_ERRORS); if (entry && git_config_parse_bool(&val, entry->value) < 0) git_error_clear(); @@ -1002,12 +1030,12 @@ int git_config__get_bool_force( } int git_config__get_int_force( - const git_config *cfg, const char *key, int fallback_value) + const git_config *config, const char *key, int fallback_value) { int32_t val = (int32_t)fallback_value; git_config_entry *entry; - get_entry(&entry, cfg, key, false, GET_NO_ERRORS); + get_entry(&entry, config, key, false, GET_NO_ERRORS); if (entry && git_config_parse_int32(&val, entry->value) < 0) git_error_clear(); @@ -1017,14 +1045,14 @@ int git_config__get_int_force( } int git_config_get_multivar_foreach( - const git_config *cfg, const char *name, const char *regexp, + const git_config *config, const char *name, const char *regexp, git_config_foreach_cb cb, void *payload) { int err, found; git_config_iterator *iter; git_config_entry *entry; - if ((err = git_config_multivar_iterator_new(&iter, cfg, name, regexp)) < 0) + if ((err = git_config_multivar_iterator_new(&iter, config, name, regexp)) < 0) return err; found = 0; @@ -1086,13 +1114,13 @@ static void multivar_iter_free(git_config_iterator *_iter) git__free(iter); } -int git_config_multivar_iterator_new(git_config_iterator **out, const git_config *cfg, const char *name, const char *regexp) +int git_config_multivar_iterator_new(git_config_iterator **out, const git_config *config, const char *name, const char *regexp) { multivar_iter *iter = NULL; git_config_iterator *inner = NULL; int error; - if ((error = git_config_iterator_new(&inner, cfg)) < 0) + if ((error = git_config_iterator_new(&inner, config)) < 0) return error; iter = git__calloc(1, sizeof(multivar_iter)); @@ -1123,24 +1151,24 @@ int git_config_multivar_iterator_new(git_config_iterator **out, const git_config return error; } -int git_config_set_multivar(git_config *cfg, const char *name, const char *regexp, const char *value) +int git_config_set_multivar(git_config *config, const char *name, const char *regexp, const char *value) { git_config_backend *backend; - int error = 0; - if ((error = get_backend_for_use(&backend, cfg, name, BACKEND_USE_SET)) < 0) - return error; + if ((backend = get_writer(config)) == NULL) { + git_error_set(GIT_ERROR_CONFIG, "cannot set '%s': the configuration is read-only", name); + return GIT_ENOTFOUND; + } return backend->set_multivar(backend, name, regexp, value); } -int git_config_delete_multivar(git_config *cfg, const char *name, const char *regexp) +int git_config_delete_multivar(git_config *config, const char *name, const char *regexp) { git_config_backend *backend; - int error = 0; - if ((error = get_backend_for_use(&backend, cfg, name, BACKEND_USE_DELETE)) < 0) - return error; + if ((backend = get_writer(config)) == NULL) + return GIT_ENOTFOUND; return backend->del_multivar(backend, name, regexp); } @@ -1251,78 +1279,71 @@ int git_config__global_location(git_str *buf) int git_config_open_default(git_config **out) { int error; - git_config *cfg = NULL; + git_config *config = NULL; git_str buf = GIT_STR_INIT; - if ((error = git_config_new(&cfg)) < 0) + if ((error = git_config_new(&config)) < 0) return error; if (!git_config__find_global(&buf) || !git_config__global_location(&buf)) { - error = git_config_add_file_ondisk(cfg, buf.ptr, + error = git_config_add_file_ondisk(config, buf.ptr, GIT_CONFIG_LEVEL_GLOBAL, NULL, 0); } if (!error && !git_config__find_xdg(&buf)) - error = git_config_add_file_ondisk(cfg, buf.ptr, + error = git_config_add_file_ondisk(config, buf.ptr, GIT_CONFIG_LEVEL_XDG, NULL, 0); if (!error && !git_config__find_system(&buf)) - error = git_config_add_file_ondisk(cfg, buf.ptr, + error = git_config_add_file_ondisk(config, buf.ptr, GIT_CONFIG_LEVEL_SYSTEM, NULL, 0); if (!error && !git_config__find_programdata(&buf)) - error = git_config_add_file_ondisk(cfg, buf.ptr, + error = git_config_add_file_ondisk(config, buf.ptr, GIT_CONFIG_LEVEL_PROGRAMDATA, NULL, 0); git_str_dispose(&buf); if (error) { - git_config_free(cfg); - cfg = NULL; + git_config_free(config); + config = NULL; } - *out = cfg; + *out = config; return error; } -int git_config_lock(git_transaction **out, git_config *cfg) +int git_config_lock(git_transaction **out, git_config *config) { - int error; git_config_backend *backend; - backend_internal *internal; + int error; - GIT_ASSERT_ARG(cfg); + GIT_ASSERT_ARG(config); - internal = git_vector_get(&cfg->backends, 0); - if (!internal || !internal->backend) { - git_error_set(GIT_ERROR_CONFIG, "cannot lock; the config has no backends"); - return -1; + if ((backend = get_writer(config)) == NULL) { + git_error_set(GIT_ERROR_CONFIG, "cannot lock: the configuration is read-only"); + return GIT_ENOTFOUND; } - backend = internal->backend; if ((error = backend->lock(backend)) < 0) return error; - return git_transaction_config_new(out, cfg); + return git_transaction_config_new(out, config); } -int git_config_unlock(git_config *cfg, int commit) +int git_config_unlock(git_config *config, int commit) { git_config_backend *backend; - backend_internal *internal; - GIT_ASSERT_ARG(cfg); + GIT_ASSERT_ARG(config); - internal = git_vector_get(&cfg->backends, 0); - if (!internal || !internal->backend) { - git_error_set(GIT_ERROR_CONFIG, "cannot lock; the config has no backends"); - return -1; + if ((backend = get_writer(config)) == NULL) { + git_error_set(GIT_ERROR_CONFIG, "cannot unlock: the configuration is read-only"); + return GIT_ENOTFOUND; } - backend = internal->backend; - return backend->unlock(backend, commit); } diff --git a/src/libgit2/config.h b/src/libgit2/config.h index 01b84b157f7..3119f7d748b 100644 --- a/src/libgit2/config.h +++ b/src/libgit2/config.h @@ -24,7 +24,8 @@ struct git_config { git_refcount rc; - git_vector backends; + git_vector readers; + git_vector writers; }; extern int git_config__global_location(git_str *buf); diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index be938b5b9d0..97671fe40b1 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -1282,9 +1282,10 @@ static int load_config( const char *system_config_path, const char *programdata_path) { - int error; git_str config_path = GIT_STR_INIT; git_config *cfg = NULL; + git_config_level_t write_order; + int error; GIT_ASSERT_ARG(out); @@ -1333,6 +1334,11 @@ static int load_config( git_error_clear(); /* clear any lingering ENOTFOUND errors */ + write_order = GIT_CONFIG_LEVEL_LOCAL; + + if ((error = git_config_set_writeorder(cfg, &write_order, 1)) < 0) + goto on_error; + *out = cfg; return 0; From fb187bd00367463587ea88f351b71822d3f6057c Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 4 Mar 2024 13:28:21 +0000 Subject: [PATCH 538/608] config: return GIT_EREADONLY on read-only configs Introduce `GIT_EREADONLY` and return it when a read-only configuration is attempted to be mutated. This is preferred over the prior `GIT_ENOTFOUND` which is not accurate. --- include/git2/errors.h | 3 ++- src/libgit2/config.c | 12 ++++++------ tests/libgit2/config/readonly.c | 2 +- 3 files changed, 9 insertions(+), 8 deletions(-) diff --git a/include/git2/errors.h b/include/git2/errors.h index bdace8c43dd..5dda9fa0362 100644 --- a/include/git2/errors.h +++ b/include/git2/errors.h @@ -60,7 +60,8 @@ typedef enum { GIT_EAPPLYFAIL = -35, /**< Patch application failed */ GIT_EOWNER = -36, /**< The object is not owned by the current user */ GIT_TIMEOUT = -37, /**< The operation timed out */ - GIT_EUNCHANGED = -38 /**< There were no changes */ + GIT_EUNCHANGED = -38, /**< There were no changes */ + GIT_EREADONLY = -39 /**< The subject is read-only */ } git_error_code; /** diff --git a/src/libgit2/config.c b/src/libgit2/config.c index fdf32e9669a..7e38d86936f 100644 --- a/src/libgit2/config.c +++ b/src/libgit2/config.c @@ -678,7 +678,7 @@ int git_config_delete_entry(git_config *config, const char *name) git_config_backend *backend; if ((backend = get_writer(config)) == NULL) - return GIT_ENOTFOUND; + return GIT_EREADONLY; return backend->del(backend, name); } @@ -712,7 +712,7 @@ int git_config_set_string(git_config *config, const char *name, const char *valu if ((backend = get_writer(config)) == NULL) { git_error_set(GIT_ERROR_CONFIG, "cannot set '%s': the configuration is read-only", name); - return GIT_ENOTFOUND; + return GIT_EREADONLY; } error = backend->set(backend, name, value); @@ -1157,7 +1157,7 @@ int git_config_set_multivar(git_config *config, const char *name, const char *re if ((backend = get_writer(config)) == NULL) { git_error_set(GIT_ERROR_CONFIG, "cannot set '%s': the configuration is read-only", name); - return GIT_ENOTFOUND; + return GIT_EREADONLY; } return backend->set_multivar(backend, name, regexp, value); @@ -1168,7 +1168,7 @@ int git_config_delete_multivar(git_config *config, const char *name, const char git_config_backend *backend; if ((backend = get_writer(config)) == NULL) - return GIT_ENOTFOUND; + return GIT_EREADONLY; return backend->del_multivar(backend, name, regexp); } @@ -1324,7 +1324,7 @@ int git_config_lock(git_transaction **out, git_config *config) if ((backend = get_writer(config)) == NULL) { git_error_set(GIT_ERROR_CONFIG, "cannot lock: the configuration is read-only"); - return GIT_ENOTFOUND; + return GIT_EREADONLY; } if ((error = backend->lock(backend)) < 0) @@ -1341,7 +1341,7 @@ int git_config_unlock(git_config *config, int commit) if ((backend = get_writer(config)) == NULL) { git_error_set(GIT_ERROR_CONFIG, "cannot unlock: the configuration is read-only"); - return GIT_ENOTFOUND; + return GIT_EREADONLY; } return backend->unlock(backend, commit); diff --git a/tests/libgit2/config/readonly.c b/tests/libgit2/config/readonly.c index a8901e394c0..483f83a85fd 100644 --- a/tests/libgit2/config/readonly.c +++ b/tests/libgit2/config/readonly.c @@ -24,7 +24,7 @@ void test_config_readonly__writing_to_readonly_fails(void) backend->readonly = 1; cl_git_pass(git_config_add_backend(cfg, backend, GIT_CONFIG_LEVEL_GLOBAL, NULL, 0)); - cl_git_fail_with(GIT_ENOTFOUND, git_config_set_string(cfg, "foo.bar", "baz")); + cl_git_fail_with(GIT_EREADONLY, git_config_set_string(cfg, "foo.bar", "baz")); cl_assert(!git_fs_path_exists("global")); } From 5f85714e1f80a16f95c646fbb2124d8f963c0a2c Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 4 Mar 2024 14:55:40 +0000 Subject: [PATCH 539/608] config: don't git_config_free an aborted transaction When a configuration transaction is freed with `git_transaction_free` - without first committing it - we should not `git_config_free`. We never increased the refcount, so we certainly shouldn't decrease it. Also, add a test around aborting a transaction without committing it. --- tests/libgit2/config/write.c | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+) diff --git a/tests/libgit2/config/write.c b/tests/libgit2/config/write.c index 9d8c3fe9495..c71d4f6dc86 100644 --- a/tests/libgit2/config/write.c +++ b/tests/libgit2/config/write.c @@ -696,6 +696,36 @@ void test_config_write__locking(void) git_config_free(cfg); } +void test_config_write__abort_lock(void) +{ + git_config *cfg; + git_config_entry *entry; + git_transaction *tx; + const char *filename = "locked-file"; + + /* Open the config and lock it */ + cl_git_mkfile(filename, "[section]\n\tname = value\n"); + cl_git_pass(git_config_open_ondisk(&cfg, filename)); + cl_git_pass(git_config_get_entry(&entry, cfg, "section.name")); + cl_assert_equal_s("value", entry->value); + git_config_entry_free(entry); + cl_git_pass(git_config_lock(&tx, cfg)); + + /* Change entries in the locked backend */ + cl_git_pass(git_config_set_string(cfg, "section.name", "other value")); + cl_git_pass(git_config_set_string(cfg, "section2.name3", "more value")); + + git_transaction_free(tx); + + /* Now that we've unlocked it, we should see no changes */ + cl_git_pass(git_config_get_entry(&entry, cfg, "section.name")); + cl_assert_equal_s("value", entry->value); + git_config_entry_free(entry); + cl_git_fail_with(GIT_ENOTFOUND, git_config_get_entry(&entry, cfg, "section2.name3")); + + git_config_free(cfg); +} + void test_config_write__repeated(void) { const char *filename = "config-repeated"; From d287e1a4fe020253f2b194e2f81e199145f3646d Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 4 Mar 2024 15:11:54 +0000 Subject: [PATCH 540/608] config: store the backend in a transaction When we `git_config_unlock`, we shouldn't _unlock the thing that we locked_ instead of assuming that the highest-priority target _remains_ the highest-priority target. --- src/libgit2/config.c | 17 +++++++---------- src/libgit2/config.h | 10 +++++++--- src/libgit2/transaction.c | 17 +++++++++++------ src/libgit2/transaction.h | 5 ++++- 4 files changed, 29 insertions(+), 20 deletions(-) diff --git a/src/libgit2/config.c b/src/libgit2/config.c index 7e38d86936f..26b6fd677cd 100644 --- a/src/libgit2/config.c +++ b/src/libgit2/config.c @@ -1330,19 +1330,16 @@ int git_config_lock(git_transaction **out, git_config *config) if ((error = backend->lock(backend)) < 0) return error; - return git_transaction_config_new(out, config); + return git_transaction_config_new(out, config, backend); } -int git_config_unlock(git_config *config, int commit) +int git_config_unlock( + git_config *config, + git_config_backend *backend, + int commit) { - git_config_backend *backend; - - GIT_ASSERT_ARG(config); - - if ((backend = get_writer(config)) == NULL) { - git_error_set(GIT_ERROR_CONFIG, "cannot unlock: the configuration is read-only"); - return GIT_EREADONLY; - } + GIT_ASSERT_ARG(config && backend); + GIT_UNUSED(config); return backend->unlock(backend, commit); } diff --git a/src/libgit2/config.h b/src/libgit2/config.h index 3119f7d748b..d3428e7da4e 100644 --- a/src/libgit2/config.h +++ b/src/libgit2/config.h @@ -95,17 +95,21 @@ int git_config_lookup_map_enum(git_configmap_t *type_out, size_t map_n, int enum_val); /** - * Unlock the backend with the highest priority + * Unlock the given backend that was previously locked. * * Unlocking will allow other writers to update the configuration * file. Optionally, any changes performed since the lock will be * applied to the configuration. * - * @param cfg the configuration + * @param config the config instance + * @param backend the config backend * @param commit boolean which indicates whether to commit any changes * done since locking * @return 0 or an error code */ -GIT_EXTERN(int) git_config_unlock(git_config *cfg, int commit); +GIT_EXTERN(int) git_config_unlock( + git_config *config, + git_config_backend *backend, + int commit); #endif diff --git a/src/libgit2/transaction.c b/src/libgit2/transaction.c index ccffa9984cc..47bdb03a2f9 100644 --- a/src/libgit2/transaction.c +++ b/src/libgit2/transaction.c @@ -49,12 +49,16 @@ struct git_transaction { git_repository *repo; git_refdb *db; git_config *cfg; + git_config_backend *backend; git_strmap *locks; git_pool pool; }; -int git_transaction_config_new(git_transaction **out, git_config *cfg) +int git_transaction_config_new( + git_transaction **out, + git_config *cfg, + git_config_backend *backend) { git_transaction *tx; @@ -66,6 +70,8 @@ int git_transaction_config_new(git_transaction **out, git_config *cfg) tx->type = TRANSACTION_CONFIG; tx->cfg = cfg; + tx->backend = backend; + *out = tx; return 0; } @@ -333,8 +339,9 @@ int git_transaction_commit(git_transaction *tx) GIT_ASSERT_ARG(tx); if (tx->type == TRANSACTION_CONFIG) { - error = git_config_unlock(tx->cfg, true); + error = git_config_unlock(tx->cfg, tx->backend, true); tx->cfg = NULL; + tx->backend = NULL; return error; } @@ -369,10 +376,8 @@ void git_transaction_free(git_transaction *tx) return; if (tx->type == TRANSACTION_CONFIG) { - if (tx->cfg) { - git_config_unlock(tx->cfg, false); - git_config_free(tx->cfg); - } + if (tx->cfg) + git_config_unlock(tx->cfg, tx->backend, false); git__free(tx); return; diff --git a/src/libgit2/transaction.h b/src/libgit2/transaction.h index 780c068303e..961c8c3c844 100644 --- a/src/libgit2/transaction.h +++ b/src/libgit2/transaction.h @@ -9,6 +9,9 @@ #include "common.h" -int git_transaction_config_new(git_transaction **out, git_config *cfg); +int git_transaction_config_new( + git_transaction **out, + git_config *cfg, + git_config_backend *backend); #endif From e8910c175dd4418505962687050193cb08e3c3e4 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 4 Mar 2024 16:42:59 +0000 Subject: [PATCH 541/608] config: refcount the backend when we start a transaction When we start a transaction, we should refcount the backend so that we don't lose it. This prevents the case where we have a transaction open and a configuration entry locked and somebody forces a new backend at the same level and the backend is freed. Now a user can gently wind down their transaction even when the backend has been removed from the live configuration object. --- src/libgit2/config.c | 35 +++++++++++++++++++++++++---------- src/libgit2/config.h | 4 ++-- src/libgit2/transaction.c | 12 ++++++------ src/libgit2/transaction.h | 2 +- 4 files changed, 34 insertions(+), 19 deletions(-) diff --git a/src/libgit2/config.c b/src/libgit2/config.c index 26b6fd677cd..21b9666db33 100644 --- a/src/libgit2/config.c +++ b/src/libgit2/config.c @@ -655,8 +655,8 @@ int git_config_foreach_match( * Setters **************/ -static git_config_backend *get_writer(git_config *config) -{ + static backend_instance *get_writer_instance(git_config *config) + { backend_entry *entry; size_t i; @@ -667,10 +667,17 @@ static git_config_backend *get_writer(git_config *config) if (entry->write_order < 0) continue; - return entry->instance->backend; + return entry->instance; } return NULL; + } + +static git_config_backend *get_writer(git_config *config) +{ + backend_instance *instance = get_writer_instance(config); + + return instance ? instance->backend : NULL; } int git_config_delete_entry(git_config *config, const char *name) @@ -1317,31 +1324,39 @@ int git_config_open_default(git_config **out) int git_config_lock(git_transaction **out, git_config *config) { - git_config_backend *backend; + backend_instance *instance; int error; GIT_ASSERT_ARG(config); - if ((backend = get_writer(config)) == NULL) { + if ((instance = get_writer_instance(config)) == NULL) { git_error_set(GIT_ERROR_CONFIG, "cannot lock: the configuration is read-only"); return GIT_EREADONLY; } - if ((error = backend->lock(backend)) < 0) + if ((error = instance->backend->lock(instance->backend)) < 0 || + (error = git_transaction_config_new(out, config, instance)) < 0) return error; - return git_transaction_config_new(out, config, backend); + GIT_REFCOUNT_INC(instance); + return 0; } int git_config_unlock( git_config *config, - git_config_backend *backend, + void *data, int commit) { - GIT_ASSERT_ARG(config && backend); + backend_instance *instance = data; + int error; + + GIT_ASSERT_ARG(config && data); GIT_UNUSED(config); - return backend->unlock(backend, commit); + error = instance->backend->unlock(instance->backend, commit); + GIT_REFCOUNT_DEC(instance, backend_instance_free); + + return error; } /*********** diff --git a/src/libgit2/config.h b/src/libgit2/config.h index d3428e7da4e..5003cbf9c1f 100644 --- a/src/libgit2/config.h +++ b/src/libgit2/config.h @@ -102,14 +102,14 @@ int git_config_lookup_map_enum(git_configmap_t *type_out, * applied to the configuration. * * @param config the config instance - * @param backend the config backend + * @param data the config data passed to git_transaction_new * @param commit boolean which indicates whether to commit any changes * done since locking * @return 0 or an error code */ GIT_EXTERN(int) git_config_unlock( git_config *config, - git_config_backend *backend, + void *data, int commit); #endif diff --git a/src/libgit2/transaction.c b/src/libgit2/transaction.c index 47bdb03a2f9..963416196b4 100644 --- a/src/libgit2/transaction.c +++ b/src/libgit2/transaction.c @@ -49,7 +49,7 @@ struct git_transaction { git_repository *repo; git_refdb *db; git_config *cfg; - git_config_backend *backend; + void *cfg_data; git_strmap *locks; git_pool pool; @@ -58,7 +58,7 @@ struct git_transaction { int git_transaction_config_new( git_transaction **out, git_config *cfg, - git_config_backend *backend) + void *data) { git_transaction *tx; @@ -70,7 +70,7 @@ int git_transaction_config_new( tx->type = TRANSACTION_CONFIG; tx->cfg = cfg; - tx->backend = backend; + tx->cfg_data = data; *out = tx; return 0; @@ -339,9 +339,9 @@ int git_transaction_commit(git_transaction *tx) GIT_ASSERT_ARG(tx); if (tx->type == TRANSACTION_CONFIG) { - error = git_config_unlock(tx->cfg, tx->backend, true); + error = git_config_unlock(tx->cfg, tx->cfg_data, true); tx->cfg = NULL; - tx->backend = NULL; + tx->cfg_data = NULL; return error; } @@ -377,7 +377,7 @@ void git_transaction_free(git_transaction *tx) if (tx->type == TRANSACTION_CONFIG) { if (tx->cfg) - git_config_unlock(tx->cfg, tx->backend, false); + git_config_unlock(tx->cfg, tx->cfg_data, false); git__free(tx); return; diff --git a/src/libgit2/transaction.h b/src/libgit2/transaction.h index 961c8c3c844..cb26017ae9f 100644 --- a/src/libgit2/transaction.h +++ b/src/libgit2/transaction.h @@ -12,6 +12,6 @@ int git_transaction_config_new( git_transaction **out, git_config *cfg, - git_config_backend *backend); + void *data); #endif From e890ca35aa321cf128078e628ea05e79bd2c9607 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 11 Mar 2024 15:20:02 +0000 Subject: [PATCH 542/608] config: only read worktree config if extension is set Only read the worktree configuration when `extensions.worktreeconfig` is set to true. --- src/libgit2/repository.c | 29 +++++++++++++++++++++++++---- tests/libgit2/worktree/config.c | 29 +++++++++++++++++++++++++++++ 2 files changed, 54 insertions(+), 4 deletions(-) diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index 97671fe40b1..124ec3672ab 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -1274,6 +1274,24 @@ int git_repository_discover( return error; } +static int has_config_worktree(bool *out, git_config *cfg) +{ + int worktreeconfig = 0, error; + + *out = false; + + error = git_config_get_bool(&worktreeconfig, cfg, "extensions.worktreeconfig"); + + if (error == 0) + *out = worktreeconfig; + else if (error == GIT_ENOTFOUND) + *out = false; + else + return error; + + return 0; +} + static int load_config( git_config **out, git_repository *repo, @@ -1285,6 +1303,7 @@ static int load_config( git_str config_path = GIT_STR_INIT; git_config *cfg = NULL; git_config_level_t write_order; + bool has_worktree; int error; GIT_ASSERT_ARG(out); @@ -1293,14 +1312,16 @@ static int load_config( return error; if (repo) { - if ((error = git_repository__item_path(&config_path, repo, GIT_REPOSITORY_ITEM_WORKTREE_CONFIG)) == 0) - error = git_config_add_file_ondisk(cfg, config_path.ptr, GIT_CONFIG_LEVEL_WORKTREE, repo, 0); + if ((error = git_repository__item_path(&config_path, repo, GIT_REPOSITORY_ITEM_CONFIG)) == 0) + error = git_config_add_file_ondisk(cfg, config_path.ptr, GIT_CONFIG_LEVEL_LOCAL, repo, 0); if (error && error != GIT_ENOTFOUND) goto on_error; - if ((error = git_repository__item_path(&config_path, repo, GIT_REPOSITORY_ITEM_CONFIG)) == 0) - error = git_config_add_file_ondisk(cfg, config_path.ptr, GIT_CONFIG_LEVEL_LOCAL, repo, 0); + if ((error = has_config_worktree(&has_worktree, cfg)) == 0 && + has_worktree && + (error = git_repository__item_path(&config_path, repo, GIT_REPOSITORY_ITEM_WORKTREE_CONFIG)) == 0) + error = git_config_add_file_ondisk(cfg, config_path.ptr, GIT_CONFIG_LEVEL_WORKTREE, repo, 0); if (error && error != GIT_ENOTFOUND) goto on_error; diff --git a/tests/libgit2/worktree/config.c b/tests/libgit2/worktree/config.c index 2ddec25e264..dee8e0c06d6 100644 --- a/tests/libgit2/worktree/config.c +++ b/tests/libgit2/worktree/config.c @@ -6,15 +6,19 @@ static worktree_fixture fixture = WORKTREE_FIXTURE_INIT(COMMON_REPO, WORKTREE_REPO); +static worktree_fixture submodule = + WORKTREE_FIXTURE_INIT("submodules", "submodules-worktree-parent"); void test_worktree_config__initialize(void) { setup_fixture_worktree(&fixture); + setup_fixture_worktree(&submodule); } void test_worktree_config__cleanup(void) { cleanup_fixture_worktree(&fixture); + cleanup_fixture_worktree(&submodule); } void test_worktree_config__open(void) @@ -46,6 +50,31 @@ void test_worktree_config__set_level_local(void) git_config_free(cfg); } +void test_worktree_config__requires_extension(void) +{ + git_config *cfg; + git_config *wtcfg; + int extension = 0; + + /* + * the "submodules" repo does not have extensions.worktreeconfig + * set, the worktree configuration should not be available. + */ + cl_git_pass(git_repository_config(&cfg, submodule.repo)); + cl_git_fail_with(GIT_ENOTFOUND, git_config_get_bool(&extension, cfg, "extensions.worktreeconfig")); + cl_assert_equal_i(0, extension); + cl_git_fail_with(GIT_ENOTFOUND, git_config_open_level(&wtcfg, cfg, GIT_CONFIG_LEVEL_WORKTREE)); + git_config_free(cfg); + + /* the "testrepo" repo does have the configuration set. */ + cl_git_pass(git_repository_config(&cfg, fixture.repo)); + cl_git_pass(git_config_get_bool(&extension, cfg, "extensions.worktreeconfig")); + cl_assert_equal_i(1, extension); + cl_git_pass(git_config_open_level(&wtcfg, cfg, GIT_CONFIG_LEVEL_WORKTREE)); + git_config_free(wtcfg); + git_config_free(cfg); +} + void test_worktree_config__set_level_worktree(void) { git_config *cfg; From 3baa6372fd5957ebc8601ee7223118fa19f00ce4 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 11 Mar 2024 15:21:12 +0000 Subject: [PATCH 543/608] config: read the individual worktree config Instead of reading the worktree configuration from the commondir, read it from the gitdir. This ensures that each worktree gets its own configuration. --- src/libgit2/repository.c | 2 +- tests/libgit2/worktree/config.c | 22 +++++++++++++++++++ tests/resources/testrepo/.gitted/config | 2 ++ .../testrepo/.gitted/config.worktree | 2 ++ .../testrepo-worktree/config.worktree | 2 ++ 5 files changed, 29 insertions(+), 1 deletion(-) create mode 100644 tests/resources/testrepo/.gitted/config.worktree create mode 100644 tests/resources/testrepo/.gitted/worktrees/testrepo-worktree/config.worktree diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index 124ec3672ab..09b74df4a6e 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -58,7 +58,7 @@ static const struct { { GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM_GITDIR, "packed-refs", false }, { GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM_GITDIR, "remotes", true }, { GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM_GITDIR, "config", false }, - { GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM_GITDIR, "config.worktree", false }, + { GIT_REPOSITORY_ITEM_GITDIR, GIT_REPOSITORY_ITEM_GITDIR, "config.worktree", false }, { GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM_GITDIR, "info", true }, { GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM_GITDIR, "hooks", true }, { GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM_GITDIR, "logs", true }, diff --git a/tests/libgit2/worktree/config.c b/tests/libgit2/worktree/config.c index dee8e0c06d6..1fd1f75b47b 100644 --- a/tests/libgit2/worktree/config.c +++ b/tests/libgit2/worktree/config.c @@ -75,6 +75,28 @@ void test_worktree_config__requires_extension(void) git_config_free(cfg); } +void test_worktree_config__exists(void) +{ + git_config *cfg, *wtcfg, *snap; + const char *str; + + cl_git_pass(git_repository_config(&cfg, fixture.repo)); + cl_git_pass(git_repository_config(&wtcfg, fixture.worktree)); + + cl_git_pass(git_config_snapshot(&snap, cfg)); + cl_git_pass(git_config_get_string(&str, snap, "worktreetest.config")); + cl_assert_equal_s("mainrepo", str); + git_config_free(snap); + + cl_git_pass(git_config_snapshot(&snap, wtcfg)); + cl_git_pass(git_config_get_string(&str, snap, "worktreetest.config")); + cl_assert_equal_s("worktreerepo", str); + git_config_free(snap); + + git_config_free(cfg); + git_config_free(wtcfg); +} + void test_worktree_config__set_level_worktree(void) { git_config *cfg; diff --git a/tests/resources/testrepo/.gitted/config b/tests/resources/testrepo/.gitted/config index d0114012f98..04d750a93bc 100644 --- a/tests/resources/testrepo/.gitted/config +++ b/tests/resources/testrepo/.gitted/config @@ -3,6 +3,8 @@ filemode = true bare = false logallrefupdates = true +[extensions] + worktreeconfig = true [remote "test"] url = git://github.com/libgit2/libgit2 fetch = +refs/heads/*:refs/remotes/test/* diff --git a/tests/resources/testrepo/.gitted/config.worktree b/tests/resources/testrepo/.gitted/config.worktree new file mode 100644 index 00000000000..df9f0caf650 --- /dev/null +++ b/tests/resources/testrepo/.gitted/config.worktree @@ -0,0 +1,2 @@ +[worktreetest] + config = mainrepo diff --git a/tests/resources/testrepo/.gitted/worktrees/testrepo-worktree/config.worktree b/tests/resources/testrepo/.gitted/worktrees/testrepo-worktree/config.worktree new file mode 100644 index 00000000000..7a130a7aed7 --- /dev/null +++ b/tests/resources/testrepo/.gitted/worktrees/testrepo-worktree/config.worktree @@ -0,0 +1,2 @@ +[worktreetest] + config = worktreerepo From b454eba9a717919bb5b43d3b2b70bcd54ca5f3e6 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 11 Mar 2024 21:07:21 +0000 Subject: [PATCH 544/608] errors: introduce GIT_ENOTSUPPORTED libgit2 lacks many of the things that git supports. Give a reasonable error code for these cases. --- include/git2/errors.h | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/include/git2/errors.h b/include/git2/errors.h index bdace8c43dd..2e007ecb55e 100644 --- a/include/git2/errors.h +++ b/include/git2/errors.h @@ -60,7 +60,8 @@ typedef enum { GIT_EAPPLYFAIL = -35, /**< Patch application failed */ GIT_EOWNER = -36, /**< The object is not owned by the current user */ GIT_TIMEOUT = -37, /**< The operation timed out */ - GIT_EUNCHANGED = -38 /**< There were no changes */ + GIT_EUNCHANGED = -38, /**< There were no changes */ + GIT_ENOTSUPPORTED = -39 /**< An option is not supported */ } git_error_code; /** From b8f3dae325fb257f14404979b837aef374a8a497 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 11 Mar 2024 21:07:46 +0000 Subject: [PATCH 545/608] fetch: fail on depth for local transport We don't support shallow clones for the local transport, currently. Fail, instead of silently ignoring the depth option. --- src/libgit2/transports/local.c | 5 +++++ tests/libgit2/clone/local.c | 11 +++++++++++ 2 files changed, 16 insertions(+) diff --git a/src/libgit2/transports/local.c b/src/libgit2/transports/local.c index 64c21afbd0d..fe59bcab0c1 100644 --- a/src/libgit2/transports/local.c +++ b/src/libgit2/transports/local.c @@ -303,6 +303,11 @@ static int local_negotiate_fetch( GIT_UNUSED(wants); + if (wants->depth) { + git_error_set(GIT_ERROR_NET, "shallow fetch is not supported by the local transport"); + return GIT_ENOTSUPPORTED; + } + /* Fill in the loids */ git_vector_foreach(&t->refs, i, rhead) { git_object *obj; diff --git a/tests/libgit2/clone/local.c b/tests/libgit2/clone/local.c index e0bd74df78a..a89b2343759 100644 --- a/tests/libgit2/clone/local.c +++ b/tests/libgit2/clone/local.c @@ -210,3 +210,14 @@ void test_clone_local__git_style_unc_paths(void) cl_git_pass(git_futils_rmdir_r("./clone.git", NULL, GIT_RMDIR_REMOVE_FILES)); #endif } + +void test_clone_local__shallow_fails(void) +{ + git_repository *repo; + git_clone_options opts = GIT_CLONE_OPTIONS_INIT; + + opts.fetch_opts.depth = 4; + + cl_git_fail_with(GIT_ENOTSUPPORTED, git_clone(&repo, cl_fixture("testrepo.git"), "./clone.git", &opts)); + git_repository_free(repo); +} From 2625ed24b9a4b0cd0dedbb3327fddf773893a486 Mon Sep 17 00:00:00 2001 From: Adam Harrison Date: Wed, 13 Mar 2024 17:20:11 -0400 Subject: [PATCH 546/608] Initial implementation. --- src/libgit2/streams/mbedtls.c | 36 ++++++++++++++++++++++++++--------- 1 file changed, 27 insertions(+), 9 deletions(-) diff --git a/src/libgit2/streams/mbedtls.c b/src/libgit2/streams/mbedtls.c index 49aa76c3ed8..c875a2f50e8 100644 --- a/src/libgit2/streams/mbedtls.c +++ b/src/libgit2/streams/mbedtls.c @@ -32,7 +32,6 @@ # endif #endif -#include #include #include #include @@ -54,10 +53,17 @@ static mbedtls_entropy_context *mbedtls_entropy; static void shutdown_ssl(void) { if (git__ssl_conf) { - mbedtls_x509_crt_free(git__ssl_conf->ca_chain); - git__free(git__ssl_conf->ca_chain); - mbedtls_ctr_drbg_free(git__ssl_conf->p_rng); - git__free(git__ssl_conf->p_rng); + #if MBEDTLS_VERSION_MAJOR >= 3 + mbedtls_x509_crt_free(git__ssl_conf->private_ca_chain); + git__free(git__ssl_conf->private_ca_chain); + mbedtls_ctr_drbg_free(git__ssl_conf->private_p_rng); + git__free(git__ssl_conf->private_p_rng); + #else + mbedtls_x509_crt_free(git__ssl_conf->ca_chain); + git__free(git__ssl_conf->ca_chain); + mbedtls_ctr_drbg_free(git__ssl_conf->p_rng); + git__free(git__ssl_conf->p_rng); + #endif mbedtls_ssl_config_free(git__ssl_conf); git__free(git__ssl_conf); git__ssl_conf = NULL; @@ -94,7 +100,10 @@ int git_mbedtls_stream_global_init(void) } /* configure TLSv1 */ - mbedtls_ssl_conf_min_version(git__ssl_conf, MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0); + #if MBEDTLS_VERSION_MAJOR < 3 + /* SSLv3 is not included in mbedtls3 */ + mbedtls_ssl_conf_min_version(git__ssl_conf, MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0); + #endif /* verify_server_cert is responsible for making the check. * OPTIONAL because REQUIRED drops the certificate as soon as the check @@ -192,7 +201,11 @@ static int ssl_set_error(mbedtls_ssl_context *ssl, int error) break; case MBEDTLS_ERR_X509_CERT_VERIFY_FAILED: - git_error_set(GIT_ERROR_SSL, "SSL error: %#04x [%x] - %s", error, ssl->session_negotiate->verify_result, errbuf); + #ifdef MBEDTLS_VERSION_MAJOR >= 3 + git_error_set(GIT_ERROR_SSL, "SSL error: %#04x - %s", error, errbuf); + #else + git_error_set(GIT_ERROR_SSL, "SSL error: %#04x [%x] - %s", error, ssl->session_negotiate->verify_result, errbuf); + #endif ret = GIT_ECERTIFICATE; break; @@ -462,8 +475,13 @@ int git_mbedtls__set_cert_location(const char *file, const char *path) return -1; } - mbedtls_x509_crt_free(git__ssl_conf->ca_chain); - git__free(git__ssl_conf->ca_chain); + #if MBEDTLS_VERSION_MAJOR >= 3 + mbedtls_x509_crt_free(git__ssl_conf->private_ca_chain); + git__free(git__ssl_conf->private_ca_chain); + #else + mbedtls_x509_crt_free(git__ssl_conf->ca_chain); + git__free(git__ssl_conf->ca_chain); + #endif mbedtls_ssl_conf_ca_chain(git__ssl_conf, cacert, NULL); return 0; From 5934779ae0aa1c66def5153c8a4628c65e5b0fc0 Mon Sep 17 00:00:00 2001 From: Adam Harrison Date: Wed, 13 Mar 2024 17:35:39 -0400 Subject: [PATCH 547/608] Restored verify result report. --- src/libgit2/streams/mbedtls.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/libgit2/streams/mbedtls.c b/src/libgit2/streams/mbedtls.c index c875a2f50e8..f2ce411abd7 100644 --- a/src/libgit2/streams/mbedtls.c +++ b/src/libgit2/streams/mbedtls.c @@ -201,8 +201,8 @@ static int ssl_set_error(mbedtls_ssl_context *ssl, int error) break; case MBEDTLS_ERR_X509_CERT_VERIFY_FAILED: - #ifdef MBEDTLS_VERSION_MAJOR >= 3 - git_error_set(GIT_ERROR_SSL, "SSL error: %#04x - %s", error, errbuf); + #if MBEDTLS_VERSION_MAJOR >= 3 + git_error_set(GIT_ERROR_SSL, "SSL error: %#04x [%x] - %s", error, mbedtls_ssl_get_verify_result(ssl), errbuf); #else git_error_set(GIT_ERROR_SSL, "SSL error: %#04x [%x] - %s", error, ssl->session_negotiate->verify_result, errbuf); #endif From fdaf373c0e50555c16e97f5ae41db8571fcc3ba6 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 14 Mar 2024 11:27:36 +0000 Subject: [PATCH 548/608] trailer: test actual array equivalence We never test the lengths of the two arrays, so a short return from `git_message_trailers` will match erroneously. --- tests/libgit2/message/trailer.c | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/tests/libgit2/message/trailer.c b/tests/libgit2/message/trailer.c index 919e10a499c..3705794fbdb 100644 --- a/tests/libgit2/message/trailer.c +++ b/tests/libgit2/message/trailer.c @@ -3,19 +3,22 @@ static void assert_trailers(const char *message, git_message_trailer *trailers) { git_message_trailer_array arr; - size_t i; + size_t i, count; int rc = git_message_trailers(&arr, message); cl_assert_equal_i(0, rc); - for(i=0; i Date: Thu, 14 Mar 2024 11:28:20 +0000 Subject: [PATCH 549/608] trailer: ensure we identify patch lines like git Git looks explicitly for `---` followed by whitespace (`isspace()`) to determine when a patch line begins in a commit message. Match that behavior. This ensures that we don't treat (say) `----` as a patch line incorrectly. --- src/libgit2/trailer.c | 2 +- tests/libgit2/message/trailer.c | 20 ++++++++++++++++++++ 2 files changed, 21 insertions(+), 1 deletion(-) diff --git a/src/libgit2/trailer.c b/src/libgit2/trailer.c index 4761c9922f2..52e655914b0 100644 --- a/src/libgit2/trailer.c +++ b/src/libgit2/trailer.c @@ -158,7 +158,7 @@ static size_t find_patch_start(const char *str) const char *s; for (s = str; *s; s = next_line(s)) { - if (git__prefixcmp(s, "---") == 0) + if (git__prefixcmp(s, "---") == 0 && git__isspace(s[3])) return s - str; } diff --git a/tests/libgit2/message/trailer.c b/tests/libgit2/message/trailer.c index 3705794fbdb..09e8f6115a7 100644 --- a/tests/libgit2/message/trailer.c +++ b/tests/libgit2/message/trailer.c @@ -165,3 +165,23 @@ void test_message_trailer__invalid(void) "Another: trailer\n" , trailers); } + +void test_message_trailer__ignores_dashes(void) +{ + git_message_trailer trailers[] = { + { "Signed-off-by", "some@one.com" }, + { "Another", "trailer" }, + { NULL, NULL }, + }; + + assert_trailers( + "Message\n" + "\n" + "Markdown header\n" + "---------------\n" + "Lorem ipsum\n" + "\n" + "Signed-off-by: some@one.com\n" + "Another: trailer\n" + , trailers); +} From 4c9353227b039bc4e7532df60031bbd5900b8352 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 14 Mar 2024 19:20:18 +0000 Subject: [PATCH 550/608] tests: don't free an unininitialized repo --- tests/libgit2/clone/local.c | 1 - 1 file changed, 1 deletion(-) diff --git a/tests/libgit2/clone/local.c b/tests/libgit2/clone/local.c index a89b2343759..d35fe86b27e 100644 --- a/tests/libgit2/clone/local.c +++ b/tests/libgit2/clone/local.c @@ -219,5 +219,4 @@ void test_clone_local__shallow_fails(void) opts.fetch_opts.depth = 4; cl_git_fail_with(GIT_ENOTSUPPORTED, git_clone(&repo, cl_fixture("testrepo.git"), "./clone.git", &opts)); - git_repository_free(repo); } From 53978e678455e0cdcd7f77b242b34450d2169706 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 16 Mar 2024 11:04:36 +0000 Subject: [PATCH 551/608] ci: reduce ASLR randomization for TSAN Linux updated its ASLR randomization in a way that is incompatible with TSAN. See https://github.com/google/sanitizers/issues/1716 Reducing the randomness for ASLR allows the sanitizers to cope. --- .github/workflows/main.yml | 10 +++++++--- .github/workflows/nightly.yml | 9 ++++++--- ci/setup-sanitizer-build.sh | 7 +++++++ 3 files changed, 20 insertions(+), 6 deletions(-) create mode 100755 ci/setup-sanitizer-build.sh diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index accb042e463..284b40358f1 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -65,6 +65,7 @@ jobs: - name: "macOS" id: macos os: macos-12 + setup-script: osx env: CC: clang CMAKE_OPTIONS: -DREGEX_BACKEND=regcomp_l -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=leaks -DUSE_GSSAPI=ON @@ -72,7 +73,6 @@ jobs: PKG_CONFIG_PATH: /usr/local/opt/openssl/lib/pkgconfig SKIP_SSH_TESTS: true SKIP_NEGOTIATE_TESTS: true - setup-script: osx - name: "Windows (amd64, Visual Studio, Schannel)" id: windows-amd64-vs os: windows-2019 @@ -125,6 +125,8 @@ jobs: # All builds: sanitizers - name: "Sanitizer (Memory)" id: sanitizer-memory + os: ubuntu-latest + setup-script: sanitizer container: name: noble env: @@ -136,9 +138,10 @@ jobs: SKIP_NEGOTIATE_TESTS: true ASAN_SYMBOLIZER_PATH: /usr/bin/llvm-symbolizer-10 UBSAN_OPTIONS: print_stacktrace=1 - os: ubuntu-latest - name: "Sanitizer (Address)" id: sanitizer-address + os: ubuntu-latest + setup-script: sanitizer container: name: noble env: @@ -150,10 +153,10 @@ jobs: SKIP_NEGOTIATE_TESTS: true ASAN_SYMBOLIZER_PATH: /usr/bin/llvm-symbolizer-10 UBSAN_OPTIONS: print_stacktrace=1 - os: ubuntu-latest - name: "Sanitizer (UndefinedBehavior)" id: sanitizer-ub os: ubuntu-latest + setup-script: sanitizer container: name: noble env: @@ -168,6 +171,7 @@ jobs: - name: "Sanitizer (Thread)" id: sanitizer-thread os: ubuntu-latest + setup-script: sanitizer container: name: noble env: diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml index 25249e7440d..779f66f586e 100644 --- a/.github/workflows/nightly.yml +++ b/.github/workflows/nightly.yml @@ -66,6 +66,7 @@ jobs: - name: "macOS" id: macos os: macos-12 + setup-script: osx env: CC: clang CMAKE_OPTIONS: -DREGEX_BACKEND=regcomp_l -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=leaks -DUSE_GSSAPI=ON @@ -73,7 +74,6 @@ jobs: PKG_CONFIG_PATH: /usr/local/opt/openssl/lib/pkgconfig SKIP_SSH_TESTS: true SKIP_NEGOTIATE_TESTS: true - setup-script: osx - name: "Windows (amd64, Visual Studio, Schannel)" id: windows-amd64-vs os: windows-2019 @@ -126,6 +126,8 @@ jobs: # All builds: sanitizers - name: "Sanitizer (Memory)" id: memorysanitizer + os: ubuntu-latest + setup-script: sanitizer container: name: noble env: @@ -137,10 +139,10 @@ jobs: SKIP_NEGOTIATE_TESTS: true ASAN_SYMBOLIZER_PATH: /usr/bin/llvm-symbolizer-10 UBSAN_OPTIONS: print_stacktrace=1 - os: ubuntu-latest - name: "Sanitizer (UndefinedBehavior)" id: ubsanitizer os: ubuntu-latest + setup-script: sanitizer container: name: noble env: @@ -155,6 +157,7 @@ jobs: - name: "Sanitizer (Thread)" id: threadsanitizer os: ubuntu-latest + setup-script: sanitizer container: name: noble env: @@ -330,13 +333,13 @@ jobs: - name: "macOS (SHA256)" id: macos os: macos-12 + setup-script: osx env: CC: clang CMAKE_OPTIONS: -DREGEX_BACKEND=regcomp_l -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=leaks -DUSE_GSSAPI=ON -DEXPERIMENTAL_SHA256=ON PKG_CONFIG_PATH: /usr/local/opt/openssl/lib/pkgconfig SKIP_SSH_TESTS: true SKIP_NEGOTIATE_TESTS: true - setup-script: osx - name: "Windows (SHA256, amd64, Visual Studio)" id: windows-amd64-vs os: windows-2019 diff --git a/ci/setup-sanitizer-build.sh b/ci/setup-sanitizer-build.sh new file mode 100755 index 00000000000..e4591f85bec --- /dev/null +++ b/ci/setup-sanitizer-build.sh @@ -0,0 +1,7 @@ +#!/bin/sh + +set -ex + +# Linux updated its ASLR randomization in a way that is incompatible with +# TSAN. See https://github.com/google/sanitizers/issues/1716 +sudo sysctl vm.mmap_rnd_bits=28 From b70dd1270614fef64b11bda4e55d71c96a687a88 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 14 Mar 2024 11:07:31 +0000 Subject: [PATCH 552/608] packbuilder: adjust nondeterministic tests The packbuilder tests should be deterministic. This comment suggests that they are: ``` /* * By default, packfiles are created with only one thread. * Therefore we can predict the object ordering and make sure * we create exactly the same pack as git.git does when *not* * reusing existing deltas (as libgit2). * * $ cd tests/resources/testrepo.git * $ git rev-list --objects HEAD | \ * git pack-objects -q --no-reuse-delta --threads=1 pack * $ sha1sum pack-7f5fa362c664d68ba7221259be1cbd187434b2f0.pack * 5d410bdf97cf896f9007681b92868471d636954b * */ ``` but it is disappointingly incorrect. As is evidenced by the fact that -- at least on _my_ machine -- that command does not actually produce that output any longer. Variations in things like the which compression library is actually used, and its defaults, mean that we cannot accurately predict or enforce the bytes in the packfile from one system to another. Adjust the tests so that they do not believe that they should enforce the bytes in the packfile. This allows broader compatibility with zlib-compatible compression libraries, or other compression levels. --- tests/libgit2/pack/packbuilder.c | 70 ++++++++++++++++++-------------- 1 file changed, 40 insertions(+), 30 deletions(-) diff --git a/tests/libgit2/pack/packbuilder.c b/tests/libgit2/pack/packbuilder.c index ff3dc1f68aa..7da3877e451 100644 --- a/tests/libgit2/pack/packbuilder.c +++ b/tests/libgit2/pack/packbuilder.c @@ -98,9 +98,6 @@ void test_pack_packbuilder__create_pack(void) { git_indexer_progress stats; git_str buf = GIT_STR_INIT, path = GIT_STR_INIT; - git_hash_ctx ctx; - unsigned char hash[GIT_HASH_SHA1_SIZE]; - char hex[(GIT_HASH_SHA1_SIZE * 2) + 1]; seed_packbuilder(); @@ -114,33 +111,13 @@ void test_pack_packbuilder__create_pack(void) cl_git_pass(git_indexer_commit(_indexer, &stats)); git_str_printf(&path, "pack-%s.pack", git_indexer_name(_indexer)); - - /* - * By default, packfiles are created with only one thread. - * Therefore we can predict the object ordering and make sure - * we create exactly the same pack as git.git does when *not* - * reusing existing deltas (as libgit2). - * - * $ cd tests/resources/testrepo.git - * $ git rev-list --objects HEAD | \ - * git pack-objects -q --no-reuse-delta --threads=1 pack - * $ sha1sum pack-7f5fa362c664d68ba7221259be1cbd187434b2f0.pack - * 5d410bdf97cf896f9007681b92868471d636954b - * - */ + cl_assert(git_fs_path_exists(path.ptr)); cl_git_pass(git_futils_readbuffer(&buf, git_str_cstr(&path))); - - cl_git_pass(git_hash_ctx_init(&ctx, GIT_HASH_ALGORITHM_SHA1)); - cl_git_pass(git_hash_update(&ctx, buf.ptr, buf.size)); - cl_git_pass(git_hash_final(hash, &ctx)); - git_hash_ctx_cleanup(&ctx); + cl_assert(buf.size > 256); git_str_dispose(&path); git_str_dispose(&buf); - - git_hash_fmt(hex, hash, GIT_HASH_SHA1_SIZE); - cl_assert_equal_s(hex, "5d410bdf97cf896f9007681b92868471d636954b"); } void test_pack_packbuilder__get_name(void) @@ -148,22 +125,49 @@ void test_pack_packbuilder__get_name(void) seed_packbuilder(); cl_git_pass(git_packbuilder_write(_packbuilder, ".", 0, NULL, NULL)); - cl_assert_equal_s("7f5fa362c664d68ba7221259be1cbd187434b2f0", git_packbuilder_name(_packbuilder)); + cl_assert(git_packbuilder_name(_packbuilder) != NULL); +} + +static void get_packfile_path(git_str *out, git_packbuilder *pb) +{ + git_str_puts(out, "pack-"); + git_str_puts(out, git_packbuilder_name(pb)); + git_str_puts(out, ".pack"); +} + +static void get_index_path(git_str *out, git_packbuilder *pb) +{ + git_str_puts(out, "pack-"); + git_str_puts(out, git_packbuilder_name(pb)); + git_str_puts(out, ".idx"); } void test_pack_packbuilder__write_default_path(void) { + git_str idx = GIT_STR_INIT, pack = GIT_STR_INIT; + seed_packbuilder(); cl_git_pass(git_packbuilder_write(_packbuilder, NULL, 0, NULL, NULL)); - cl_assert(git_fs_path_exists("objects/pack/pack-7f5fa362c664d68ba7221259be1cbd187434b2f0.idx")); - cl_assert(git_fs_path_exists("objects/pack/pack-7f5fa362c664d68ba7221259be1cbd187434b2f0.pack")); + + git_str_puts(&idx, "objects/pack/"); + get_index_path(&idx, _packbuilder); + + git_str_puts(&pack, "objects/pack/"); + get_packfile_path(&pack, _packbuilder); + + cl_assert(git_fs_path_exists(idx.ptr)); + cl_assert(git_fs_path_exists(pack.ptr)); + + git_str_dispose(&idx); + git_str_dispose(&pack); } static void test_write_pack_permission(mode_t given, mode_t expected) { struct stat statbuf; mode_t mask, os_mask; + git_str idx = GIT_STR_INIT, pack = GIT_STR_INIT; seed_packbuilder(); @@ -181,11 +185,17 @@ static void test_write_pack_permission(mode_t given, mode_t expected) mask = p_umask(0); p_umask(mask); - cl_git_pass(p_stat("pack-7f5fa362c664d68ba7221259be1cbd187434b2f0.idx", &statbuf)); + get_index_path(&idx, _packbuilder); + get_packfile_path(&pack, _packbuilder); + + cl_git_pass(p_stat(idx.ptr, &statbuf)); cl_assert_equal_i(statbuf.st_mode & os_mask, (expected & ~mask) & os_mask); - cl_git_pass(p_stat("pack-7f5fa362c664d68ba7221259be1cbd187434b2f0.pack", &statbuf)); + cl_git_pass(p_stat(pack.ptr, &statbuf)); cl_assert_equal_i(statbuf.st_mode & os_mask, (expected & ~mask) & os_mask); + + git_str_dispose(&idx); + git_str_dispose(&pack); } void test_pack_packbuilder__permissions_standard(void) From 594063935b3bd3a419b66ae24c99d041eb95f3a6 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 16 Mar 2024 14:31:55 +0000 Subject: [PATCH 553/608] cli: use libgit2 system includes libgit2 may adjust the system includes - for example, to locate a dependency installed in a funny location. Ensure that the cli understands those include paths as well. --- src/cli/CMakeLists.txt | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/cli/CMakeLists.txt b/src/cli/CMakeLists.txt index 84b6c190151..97797e33bd9 100644 --- a/src/cli/CMakeLists.txt +++ b/src/cli/CMakeLists.txt @@ -4,7 +4,8 @@ set(CLI_INCLUDES "${libgit2_SOURCE_DIR}/src/util" "${libgit2_SOURCE_DIR}/src/cli" "${libgit2_SOURCE_DIR}/include" - "${LIBGIT2_DEPENDENCY_INCLUDES}") + "${LIBGIT2_DEPENDENCY_INCLUDES}" + "${LIBGIT2_SYSTEM_INCLUDES}") if(WIN32 AND NOT CYGWIN) file(GLOB CLI_SRC_OS win32/*.c) From 079861729b55a43366a59cb6922bee6f6975d982 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 16 Mar 2024 14:32:54 +0000 Subject: [PATCH 554/608] build: update ntlmclient dependency The ntlmclient dependency now bundles an MD4 implementation for compatibility with newer mbedTLS. Include that so that we can support mbedTLS 3. --- deps/ntlmclient/CMakeLists.txt | 2 +- deps/ntlmclient/crypt_builtin_md4.c | 311 ++++++++++++++++++++++++++++ deps/ntlmclient/crypt_mbedtls.c | 20 -- 3 files changed, 312 insertions(+), 21 deletions(-) create mode 100644 deps/ntlmclient/crypt_builtin_md4.c diff --git a/deps/ntlmclient/CMakeLists.txt b/deps/ntlmclient/CMakeLists.txt index 8356d472367..f1f5de162a0 100644 --- a/deps/ntlmclient/CMakeLists.txt +++ b/deps/ntlmclient/CMakeLists.txt @@ -31,7 +31,7 @@ elseif(USE_HTTPS STREQUAL "OpenSSL-Dynamic") elseif(USE_HTTPS STREQUAL "mbedTLS") add_definitions(-DCRYPT_MBEDTLS) include_directories(${MBEDTLS_INCLUDE_DIR}) - set(SRC_NTLMCLIENT_CRYPTO "crypt_mbedtls.c" "crypt_mbedtls.h") + set(SRC_NTLMCLIENT_CRYPTO "crypt_mbedtls.c" "crypt_mbedtls.h" "crypt_builtin_md4.c") else() message(FATAL_ERROR "Unable to use libgit2's HTTPS backend (${USE_HTTPS}) for NTLM crypto") endif() diff --git a/deps/ntlmclient/crypt_builtin_md4.c b/deps/ntlmclient/crypt_builtin_md4.c new file mode 100644 index 00000000000..de9a85cafaa --- /dev/null +++ b/deps/ntlmclient/crypt_builtin_md4.c @@ -0,0 +1,311 @@ +/* + * Copyright (c) Edward Thomson. All rights reserved. + * + * This file is part of ntlmclient, distributed under the MIT license. + * For full terms and copyright information, and for third-party + * copyright information, see the included LICENSE.txt file. + */ + +#include +#include + +#include "ntlm.h" +#include "crypt.h" + +/* + * Below is the MD4 code from RFC 1320, with minor modifications + * to make it compile on a modern compiler. It is included since + * many system crypto libraries lack MD4, sensibly. + */ + +/* MD4C.C - RSA Data Security, Inc., MD4 message-digest algorithm + */ + +/* Copyright (C) 1990-2, RSA Data Security, Inc. All rights reserved. + + License to copy and use this software is granted provided that it + is identified as the "RSA Data Security, Inc. MD4 Message-Digest + Algorithm" in all material mentioning or referencing this software + or this function. + + License is also granted to make and use derivative works provided + that such works are identified as "derived from the RSA Data + Security, Inc. MD4 Message-Digest Algorithm" in all material + mentioning or referencing the derived work. + + RSA Data Security, Inc. makes no representations concerning either + the merchantability of this software or the suitability of this + software for any particular purpose. It is provided "as is" + without express or implied warranty of any kind. + + These notices must be retained in any copies of any part of this + documentation and/or software. + */ + +/* POINTER defines a generic pointer type */ +typedef unsigned char *POINTER; + +/* UINT2 defines a two byte word */ +typedef uint16_t UINT2; + +/* UINT4 defines a four byte word */ +typedef uint32_t UINT4; + +#define MD4_memcpy memcpy +#define MD4_memset memset + +/* MD4 context. */ +typedef struct { + UINT4 state[4]; /* state (ABCD) */ + UINT4 count[2]; /* number of bits, modulo 2^64 (lsb first) */ + unsigned char buffer[64]; /* input buffer */ +} MD4_CTX; + +/* Constants for MD4Transform routine. + */ +#define S11 3 +#define S12 7 +#define S13 11 +#define S14 19 +#define S21 3 +#define S22 5 +#define S23 9 +#define S24 13 +#define S31 3 +#define S32 9 +#define S33 11 +#define S34 15 + +static void MD4Transform(UINT4 [4], const unsigned char [64]); +static void Encode (unsigned char *, UINT4 *, unsigned int); +static void Decode (UINT4 *, const unsigned char *, unsigned int); + +static unsigned char PADDING[64] = { + 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 +}; + +/* F, G and H are basic MD4 functions. + */ +#define F(x, y, z) (((x) & (y)) | ((~x) & (z))) +#define G(x, y, z) (((x) & (y)) | ((x) & (z)) | ((y) & (z))) +#define H(x, y, z) ((x) ^ (y) ^ (z)) + +/* ROTATE_LEFT rotates x left n bits. + */ +#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n)))) + +/* FF, GG and HH are transformations for rounds 1, 2 and 3 */ +/* Rotation is separate from addition to prevent recomputation */ +#define FF(a, b, c, d, x, s) { \ + (a) += F ((b), (c), (d)) + (x); \ + (a) = ROTATE_LEFT ((a), (s)); \ + } +#define GG(a, b, c, d, x, s) { \ + (a) += G ((b), (c), (d)) + (x) + (UINT4)0x5a827999; \ + (a) = ROTATE_LEFT ((a), (s)); \ + } +#define HH(a, b, c, d, x, s) { \ + (a) += H ((b), (c), (d)) + (x) + (UINT4)0x6ed9eba1; \ + (a) = ROTATE_LEFT ((a), (s)); \ + } + +/* MD4 initialization. Begins an MD4 operation, writing a new context. + */ +static void MD4Init (MD4_CTX *context) +{ + context->count[0] = context->count[1] = 0; + + /* Load magic initialization constants. + */ + context->state[0] = 0x67452301; + context->state[1] = 0xefcdab89; + context->state[2] = 0x98badcfe; + context->state[3] = 0x10325476; +} + +/* MD4 block update operation. Continues an MD4 message-digest + operation, processing another message block, and updating the + context. + */ +static void MD4Update (MD4_CTX *context, const unsigned char *input, unsigned int inputLen) +{ + unsigned int i, index, partLen; + + /* Compute number of bytes mod 64 */ + index = (unsigned int)((context->count[0] >> 3) & 0x3F); + /* Update number of bits */ + if ((context->count[0] += ((UINT4)inputLen << 3)) + < ((UINT4)inputLen << 3)) + context->count[1]++; + context->count[1] += ((UINT4)inputLen >> 29); + + partLen = 64 - index; + + /* Transform as many times as possible. + */ + if (inputLen >= partLen) { + MD4_memcpy + ((POINTER)&context->buffer[index], (POINTER)input, partLen); + MD4Transform (context->state, context->buffer); + + for (i = partLen; i + 63 < inputLen; i += 64) + MD4Transform (context->state, &input[i]); + + index = 0; + } + else + i = 0; + + /* Buffer remaining input */ + MD4_memcpy + ((POINTER)&context->buffer[index], (POINTER)&input[i], + inputLen-i); +} + +/* MD4 finalization. Ends an MD4 message-digest operation, writing the + the message digest and zeroizing the context. + */ +static void MD4Final (unsigned char digest[16], MD4_CTX *context) +{ + unsigned char bits[8]; + unsigned int index, padLen; + + /* Save number of bits */ + Encode (bits, context->count, 8); + + /* Pad out to 56 mod 64. + */ + index = (unsigned int)((context->count[0] >> 3) & 0x3f); + padLen = (index < 56) ? (56 - index) : (120 - index); + MD4Update (context, PADDING, padLen); + + /* Append length (before padding) */ + MD4Update (context, bits, 8); + /* Store state in digest */ + Encode (digest, context->state, 16); + + /* Zeroize sensitive information. + */ + MD4_memset ((POINTER)context, 0, sizeof (*context)); +} + +/* MD4 basic transformation. Transforms state based on block. + */ +static void MD4Transform (UINT4 state[4], const unsigned char block[64]) +{ + UINT4 a = state[0], b = state[1], c = state[2], d = state[3], x[16]; + + Decode (x, block, 64); + + /* Round 1 */ + FF (a, b, c, d, x[ 0], S11); /* 1 */ + FF (d, a, b, c, x[ 1], S12); /* 2 */ + FF (c, d, a, b, x[ 2], S13); /* 3 */ + FF (b, c, d, a, x[ 3], S14); /* 4 */ + FF (a, b, c, d, x[ 4], S11); /* 5 */ + FF (d, a, b, c, x[ 5], S12); /* 6 */ + FF (c, d, a, b, x[ 6], S13); /* 7 */ + FF (b, c, d, a, x[ 7], S14); /* 8 */ + FF (a, b, c, d, x[ 8], S11); /* 9 */ + FF (d, a, b, c, x[ 9], S12); /* 10 */ + FF (c, d, a, b, x[10], S13); /* 11 */ + FF (b, c, d, a, x[11], S14); /* 12 */ + FF (a, b, c, d, x[12], S11); /* 13 */ + FF (d, a, b, c, x[13], S12); /* 14 */ + FF (c, d, a, b, x[14], S13); /* 15 */ + FF (b, c, d, a, x[15], S14); /* 16 */ + + /* Round 2 */ + GG (a, b, c, d, x[ 0], S21); /* 17 */ + GG (d, a, b, c, x[ 4], S22); /* 18 */ + GG (c, d, a, b, x[ 8], S23); /* 19 */ + GG (b, c, d, a, x[12], S24); /* 20 */ + GG (a, b, c, d, x[ 1], S21); /* 21 */ + GG (d, a, b, c, x[ 5], S22); /* 22 */ + GG (c, d, a, b, x[ 9], S23); /* 23 */ + GG (b, c, d, a, x[13], S24); /* 24 */ + GG (a, b, c, d, x[ 2], S21); /* 25 */ + GG (d, a, b, c, x[ 6], S22); /* 26 */ + GG (c, d, a, b, x[10], S23); /* 27 */ + GG (b, c, d, a, x[14], S24); /* 28 */ + GG (a, b, c, d, x[ 3], S21); /* 29 */ + GG (d, a, b, c, x[ 7], S22); /* 30 */ + GG (c, d, a, b, x[11], S23); /* 31 */ + GG (b, c, d, a, x[15], S24); /* 32 */ + + /* Round 3 */ + HH (a, b, c, d, x[ 0], S31); /* 33 */ + HH (d, a, b, c, x[ 8], S32); /* 34 */ + HH (c, d, a, b, x[ 4], S33); /* 35 */ + HH (b, c, d, a, x[12], S34); /* 36 */ + HH (a, b, c, d, x[ 2], S31); /* 37 */ + HH (d, a, b, c, x[10], S32); /* 38 */ + HH (c, d, a, b, x[ 6], S33); /* 39 */ + HH (b, c, d, a, x[14], S34); /* 40 */ + HH (a, b, c, d, x[ 1], S31); /* 41 */ + HH (d, a, b, c, x[ 9], S32); /* 42 */ + HH (c, d, a, b, x[ 5], S33); /* 43 */ + HH (b, c, d, a, x[13], S34); /* 44 */ + HH (a, b, c, d, x[ 3], S31); /* 45 */ + HH (d, a, b, c, x[11], S32); /* 46 */ + HH (c, d, a, b, x[ 7], S33); /* 47 */ + HH (b, c, d, a, x[15], S34); /* 48 */ + + state[0] += a; + state[1] += b; + state[2] += c; + state[3] += d; + + /* Zeroize sensitive information. + */ + MD4_memset ((POINTER)x, 0, sizeof (x)); +} + +/* Encodes input (UINT4) into output (unsigned char). Assumes len is + a multiple of 4. + */ +static void Encode (unsigned char *output, UINT4 *input, unsigned int len) +{ + unsigned int i, j; + + for (i = 0, j = 0; j < len; i++, j += 4) { + output[j] = (unsigned char)(input[i] & 0xff); + output[j+1] = (unsigned char)((input[i] >> 8) & 0xff); + output[j+2] = (unsigned char)((input[i] >> 16) & 0xff); + output[j+3] = (unsigned char)((input[i] >> 24) & 0xff); + } +} + +/* Decodes input (unsigned char) into output (UINT4). Assumes len is + a multiple of 4. + */ +static void Decode (UINT4 *output, const unsigned char *input, unsigned int len) +{ + unsigned int i, j; + + for (i = 0, j = 0; j < len; i++, j += 4) + output[i] = ((UINT4)input[j]) | (((UINT4)input[j+1]) << 8) | + (((UINT4)input[j+2]) << 16) | (((UINT4)input[j+3]) << 24); +} + +bool ntlm_md4_digest( + unsigned char out[CRYPT_MD4_DIGESTSIZE], + ntlm_client *ntlm, + const unsigned char *in, + size_t in_len) +{ + MD4_CTX ctx; + + NTLM_UNUSED(ntlm); + + if (in_len > UINT_MAX) + return false; + + MD4Init(&ctx); + MD4Update(&ctx, in, (unsigned int)in_len); + MD4Final (out, &ctx); + + return true; +} diff --git a/deps/ntlmclient/crypt_mbedtls.c b/deps/ntlmclient/crypt_mbedtls.c index 6283c3eec08..4bbb878015d 100644 --- a/deps/ntlmclient/crypt_mbedtls.c +++ b/deps/ntlmclient/crypt_mbedtls.c @@ -12,7 +12,6 @@ #include "mbedtls/ctr_drbg.h" #include "mbedtls/des.h" #include "mbedtls/entropy.h" -#include "mbedtls/md4.h" #include "ntlm.h" #include "crypt.h" @@ -88,25 +87,6 @@ bool ntlm_des_encrypt( return success; } -bool ntlm_md4_digest( - unsigned char out[CRYPT_MD4_DIGESTSIZE], - ntlm_client *ntlm, - const unsigned char *in, - size_t in_len) -{ - mbedtls_md4_context ctx; - - NTLM_UNUSED(ntlm); - - mbedtls_md4_init(&ctx); - mbedtls_md4_starts(&ctx); - mbedtls_md4_update(&ctx, in, in_len); - mbedtls_md4_finish(&ctx, out); - mbedtls_md4_free(&ctx); - - return true; -} - bool ntlm_hmac_md5_init( ntlm_client *ntlm, const unsigned char *key, From 3266fc4938cce5f4251b7a055cbb4ff099d090a3 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 16 Mar 2024 14:57:06 +0000 Subject: [PATCH 555/608] mbedtls: keep track of what we allocate, then free it Instead of trying to allocate something, hand it to mbedTLS, and then peer into its private data structures to try to free that thing... we could just keep track of it ourselves. Once we've done that, we needn't do an allocation _anyway_, we can just keep it on the stack. --- src/libgit2/streams/mbedtls.c | 128 ++++++++++++++-------------------- 1 file changed, 52 insertions(+), 76 deletions(-) diff --git a/src/libgit2/streams/mbedtls.c b/src/libgit2/streams/mbedtls.c index f2ce411abd7..1b2780706c6 100644 --- a/src/libgit2/streams/mbedtls.c +++ b/src/libgit2/streams/mbedtls.c @@ -42,9 +42,15 @@ #define GIT_SSL_DEFAULT_CIPHERS "TLS-ECDHE-ECDSA-WITH-AES-128-GCM-SHA256:TLS-ECDHE-RSA-WITH-AES-128-GCM-SHA256:TLS-ECDHE-ECDSA-WITH-AES-256-GCM-SHA384:TLS-ECDHE-RSA-WITH-AES-256-GCM-SHA384:TLS-DHE-RSA-WITH-AES-128-GCM-SHA256:TLS-DHE-DSS-WITH-AES-128-GCM-SHA256:TLS-DHE-RSA-WITH-AES-256-GCM-SHA384:TLS-DHE-DSS-WITH-AES-256-GCM-SHA384:TLS-ECDHE-ECDSA-WITH-AES-128-CBC-SHA256:TLS-ECDHE-RSA-WITH-AES-128-CBC-SHA256:TLS-ECDHE-ECDSA-WITH-AES-128-CBC-SHA:TLS-ECDHE-RSA-WITH-AES-128-CBC-SHA:TLS-ECDHE-ECDSA-WITH-AES-256-CBC-SHA384:TLS-ECDHE-RSA-WITH-AES-256-CBC-SHA384:TLS-ECDHE-ECDSA-WITH-AES-256-CBC-SHA:TLS-ECDHE-RSA-WITH-AES-256-CBC-SHA:TLS-DHE-RSA-WITH-AES-128-CBC-SHA256:TLS-DHE-RSA-WITH-AES-256-CBC-SHA256:TLS-DHE-RSA-WITH-AES-128-CBC-SHA:TLS-DHE-RSA-WITH-AES-256-CBC-SHA:TLS-DHE-DSS-WITH-AES-128-CBC-SHA256:TLS-DHE-DSS-WITH-AES-256-CBC-SHA256:TLS-DHE-DSS-WITH-AES-128-CBC-SHA:TLS-DHE-DSS-WITH-AES-256-CBC-SHA:TLS-RSA-WITH-AES-128-GCM-SHA256:TLS-RSA-WITH-AES-256-GCM-SHA384:TLS-RSA-WITH-AES-128-CBC-SHA256:TLS-RSA-WITH-AES-256-CBC-SHA256:TLS-RSA-WITH-AES-128-CBC-SHA:TLS-RSA-WITH-AES-256-CBC-SHA" #define GIT_SSL_DEFAULT_CIPHERS_COUNT 30 -static mbedtls_ssl_config *git__ssl_conf; static int ciphers_list[GIT_SSL_DEFAULT_CIPHERS_COUNT]; -static mbedtls_entropy_context *mbedtls_entropy; + +static bool initialized = false; +static mbedtls_ssl_config mbedtls_config; +static mbedtls_ctr_drbg_context mbedtls_rng; +static mbedtls_entropy_context mbedtls_entropy; + +static bool has_ca_chain = false; +static mbedtls_x509_crt mbedtls_ca_chain; /** * This function aims to clean-up the SSL context which @@ -52,26 +58,16 @@ static mbedtls_entropy_context *mbedtls_entropy; */ static void shutdown_ssl(void) { - if (git__ssl_conf) { - #if MBEDTLS_VERSION_MAJOR >= 3 - mbedtls_x509_crt_free(git__ssl_conf->private_ca_chain); - git__free(git__ssl_conf->private_ca_chain); - mbedtls_ctr_drbg_free(git__ssl_conf->private_p_rng); - git__free(git__ssl_conf->private_p_rng); - #else - mbedtls_x509_crt_free(git__ssl_conf->ca_chain); - git__free(git__ssl_conf->ca_chain); - mbedtls_ctr_drbg_free(git__ssl_conf->p_rng); - git__free(git__ssl_conf->p_rng); - #endif - mbedtls_ssl_config_free(git__ssl_conf); - git__free(git__ssl_conf); - git__ssl_conf = NULL; + if (has_ca_chain) { + mbedtls_x509_crt_free(&mbedtls_ca_chain); + has_ca_chain = false; } - if (mbedtls_entropy) { - mbedtls_entropy_free(mbedtls_entropy); - git__free(mbedtls_entropy); - mbedtls_entropy = NULL; + + if (initialized) { + mbedtls_ctr_drbg_free(&mbedtls_rng); + mbedtls_ssl_config_free(&mbedtls_config); + mbedtls_entropy_free(&mbedtls_entropy); + initialized = false; } } @@ -80,35 +76,33 @@ int git_mbedtls_stream_global_init(void) int loaded = 0; char *crtpath = GIT_DEFAULT_CERT_LOCATION; struct stat statbuf; - mbedtls_ctr_drbg_context *ctr_drbg = NULL; size_t ciphers_known = 0; char *cipher_name = NULL; char *cipher_string = NULL; char *cipher_string_tmp = NULL; - git__ssl_conf = git__malloc(sizeof(mbedtls_ssl_config)); - GIT_ERROR_CHECK_ALLOC(git__ssl_conf); + mbedtls_ssl_config_init(&mbedtls_config); + mbedtls_entropy_init(&mbedtls_entropy); + mbedtls_ctr_drbg_init(&mbedtls_rng); - mbedtls_ssl_config_init(git__ssl_conf); - if (mbedtls_ssl_config_defaults(git__ssl_conf, - MBEDTLS_SSL_IS_CLIENT, - MBEDTLS_SSL_TRANSPORT_STREAM, - MBEDTLS_SSL_PRESET_DEFAULT) != 0) { + if (mbedtls_ssl_config_defaults(&mbedtls_config, + MBEDTLS_SSL_IS_CLIENT, + MBEDTLS_SSL_TRANSPORT_STREAM, + MBEDTLS_SSL_PRESET_DEFAULT) != 0) { git_error_set(GIT_ERROR_SSL, "failed to initialize mbedTLS"); goto cleanup; } - /* configure TLSv1 */ - #if MBEDTLS_VERSION_MAJOR < 3 - /* SSLv3 is not included in mbedtls3 */ - mbedtls_ssl_conf_min_version(git__ssl_conf, MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0); - #endif + /* configure TLSv1.1 */ +#ifdef MBEDTLS_SSL_MINOR_VERSION_2 + mbedtls_ssl_conf_min_version(&mbedtls_config, MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_2); +#endif /* verify_server_cert is responsible for making the check. * OPTIONAL because REQUIRED drops the certificate as soon as the check * is made, so we can never see the certificate and override it. */ - mbedtls_ssl_conf_authmode(git__ssl_conf, MBEDTLS_SSL_VERIFY_OPTIONAL); + mbedtls_ssl_conf_authmode(&mbedtls_config, MBEDTLS_SSL_VERIFY_OPTIONAL); /* set the list of allowed ciphersuites */ ciphers_known = 0; @@ -132,42 +126,33 @@ int git_mbedtls_stream_global_init(void) git_error_set(GIT_ERROR_SSL, "no cipher could be enabled"); goto cleanup; } - mbedtls_ssl_conf_ciphersuites(git__ssl_conf, ciphers_list); + mbedtls_ssl_conf_ciphersuites(&mbedtls_config, ciphers_list); /* Seeding the random number generator */ - mbedtls_entropy = git__malloc(sizeof(mbedtls_entropy_context)); - GIT_ERROR_CHECK_ALLOC(mbedtls_entropy); - - mbedtls_entropy_init(mbedtls_entropy); - - ctr_drbg = git__malloc(sizeof(mbedtls_ctr_drbg_context)); - GIT_ERROR_CHECK_ALLOC(ctr_drbg); - mbedtls_ctr_drbg_init(ctr_drbg); - - if (mbedtls_ctr_drbg_seed(ctr_drbg, - mbedtls_entropy_func, - mbedtls_entropy, NULL, 0) != 0) { + if (mbedtls_ctr_drbg_seed(&mbedtls_rng, mbedtls_entropy_func, + &mbedtls_entropy, NULL, 0) != 0) { git_error_set(GIT_ERROR_SSL, "failed to initialize mbedTLS entropy pool"); goto cleanup; } - mbedtls_ssl_conf_rng(git__ssl_conf, mbedtls_ctr_drbg_random, ctr_drbg); + mbedtls_ssl_conf_rng(&mbedtls_config, mbedtls_ctr_drbg_random, &mbedtls_rng); /* load default certificates */ if (crtpath != NULL && stat(crtpath, &statbuf) == 0 && S_ISREG(statbuf.st_mode)) loaded = (git_mbedtls__set_cert_location(crtpath, NULL) == 0); + if (!loaded && crtpath != NULL && stat(crtpath, &statbuf) == 0 && S_ISDIR(statbuf.st_mode)) loaded = (git_mbedtls__set_cert_location(NULL, crtpath) == 0); + initialized = true; + return git_runtime_shutdown_register(shutdown_ssl); cleanup: - mbedtls_ctr_drbg_free(ctr_drbg); - git__free(ctr_drbg); - mbedtls_ssl_config_free(git__ssl_conf); - git__free(git__ssl_conf); - git__ssl_conf = NULL; + mbedtls_ctr_drbg_free(&mbedtls_rng); + mbedtls_ssl_config_free(&mbedtls_config); + mbedtls_entropy_free(&mbedtls_entropy); return -1; } @@ -201,11 +186,7 @@ static int ssl_set_error(mbedtls_ssl_context *ssl, int error) break; case MBEDTLS_ERR_X509_CERT_VERIFY_FAILED: - #if MBEDTLS_VERSION_MAJOR >= 3 - git_error_set(GIT_ERROR_SSL, "SSL error: %#04x [%x] - %s", error, mbedtls_ssl_get_verify_result(ssl), errbuf); - #else - git_error_set(GIT_ERROR_SSL, "SSL error: %#04x [%x] - %s", error, ssl->session_negotiate->verify_result, errbuf); - #endif + git_error_set(GIT_ERROR_SSL, "SSL error: %#04x [%x] - %s", error, mbedtls_ssl_get_verify_result(ssl), errbuf); ret = GIT_ECERTIFICATE; break; @@ -387,7 +368,7 @@ static int mbedtls_stream_wrap( st->ssl = git__malloc(sizeof(mbedtls_ssl_context)); GIT_ERROR_CHECK_ALLOC(st->ssl); mbedtls_ssl_init(st->ssl); - if (mbedtls_ssl_setup(st->ssl, git__ssl_conf)) { + if (mbedtls_ssl_setup(st->ssl, &mbedtls_config)) { git_error_set(GIT_ERROR_SSL, "failed to create ssl object"); error = -1; goto out_err; @@ -454,35 +435,30 @@ int git_mbedtls__set_cert_location(const char *file, const char *path) { int ret = 0; char errbuf[512]; - mbedtls_x509_crt *cacert; GIT_ASSERT_ARG(file || path); - cacert = git__malloc(sizeof(mbedtls_x509_crt)); - GIT_ERROR_CHECK_ALLOC(cacert); + if (has_ca_chain) + mbedtls_x509_crt_free(&mbedtls_ca_chain); + + mbedtls_x509_crt_init(&mbedtls_ca_chain); - mbedtls_x509_crt_init(cacert); if (file) - ret = mbedtls_x509_crt_parse_file(cacert, file); + ret = mbedtls_x509_crt_parse_file(&mbedtls_ca_chain, file); + if (ret >= 0 && path) - ret = mbedtls_x509_crt_parse_path(cacert, path); + ret = mbedtls_x509_crt_parse_path(&mbedtls_ca_chain, path); + /* mbedtls_x509_crt_parse_path returns the number of invalid certs on success */ if (ret < 0) { - mbedtls_x509_crt_free(cacert); - git__free(cacert); + mbedtls_x509_crt_free(&mbedtls_ca_chain); mbedtls_strerror( ret, errbuf, 512 ); git_error_set(GIT_ERROR_SSL, "failed to load CA certificates: %#04x - %s", ret, errbuf); return -1; } - #if MBEDTLS_VERSION_MAJOR >= 3 - mbedtls_x509_crt_free(git__ssl_conf->private_ca_chain); - git__free(git__ssl_conf->private_ca_chain); - #else - mbedtls_x509_crt_free(git__ssl_conf->ca_chain); - git__free(git__ssl_conf->ca_chain); - #endif - mbedtls_ssl_conf_ca_chain(git__ssl_conf, cacert, NULL); + mbedtls_ssl_conf_ca_chain(&mbedtls_config, &mbedtls_ca_chain, NULL); + has_ca_chain = true; return 0; } From 58dfe647b7cb474661f5f5a6f072efc929cecf03 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 16 Mar 2024 16:38:44 +0000 Subject: [PATCH 556/608] build: update to latest actions versions --- .github/workflows/benchmark.yml | 6 +++--- .github/workflows/build-containers.yml | 2 +- .github/workflows/main.yml | 14 +++++++------- .github/workflows/nightly.yml | 14 +++++++------- 4 files changed, 18 insertions(+), 18 deletions(-) diff --git a/.github/workflows/benchmark.yml b/.github/workflows/benchmark.yml index 831ffbb8235..51a5fc1c083 100644 --- a/.github/workflows/benchmark.yml +++ b/.github/workflows/benchmark.yml @@ -54,7 +54,7 @@ jobs: runs-on: ${{ matrix.platform.os }} steps: - name: Check out repository - uses: actions/checkout@v3 + uses: actions/checkout@v4 with: path: source fetch-depth: 0 @@ -79,7 +79,7 @@ jobs: ../source/tests/benchmarks/benchmark.sh --baseline-cli "git" --cli "${GIT2_CLI}" --name libgit2 --json benchmarks.json --zip benchmarks.zip shell: bash - name: Upload results - uses: actions/upload-artifact@v3 + uses: actions/upload-artifact@v4 with: name: benchmark-${{ matrix.platform.id }} path: benchmark @@ -93,7 +93,7 @@ jobs: runs-on: ubuntu-latest steps: - name: Check out benchmark repository - uses: actions/checkout@v3 + uses: actions/checkout@v4 with: repository: libgit2/benchmarks path: site diff --git a/.github/workflows/build-containers.yml b/.github/workflows/build-containers.yml index 56ac66a9016..5518548c6c3 100644 --- a/.github/workflows/build-containers.yml +++ b/.github/workflows/build-containers.yml @@ -44,7 +44,7 @@ jobs: name: "Create container: ${{ matrix.container.name }}" steps: - name: Check out repository - uses: actions/checkout@v3 + uses: actions/checkout@v4 with: path: source fetch-depth: 0 diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 284b40358f1..236a7d13bb6 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -187,7 +187,7 @@ jobs: # All builds: experimental SHA256 support - name: "Linux (SHA256, Xenial, Clang, OpenSSL)" - id: xenial-clang-openssl + id: linux-sha256 os: ubuntu-latest container: name: xenial @@ -196,7 +196,7 @@ jobs: CMAKE_GENERATOR: Ninja CMAKE_OPTIONS: -DUSE_HTTPS=OpenSSL -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=ON -DEXPERIMENTAL_SHA256=ON - name: "macOS (SHA256)" - id: macos + id: macos-sha256 os: macos-12 setup-script: osx env: @@ -207,7 +207,7 @@ jobs: SKIP_SSH_TESTS: true SKIP_NEGOTIATE_TESTS: true - name: "Windows (SHA256, amd64, Visual Studio)" - id: windows-amd64-vs + id: windows-sha256 os: windows-2019 env: ARCH: amd64 @@ -221,7 +221,7 @@ jobs: name: "Build: ${{ matrix.platform.name }}" steps: - name: Check out repository - uses: actions/checkout@v3 + uses: actions/checkout@v4 with: path: source fetch-depth: 0 @@ -258,7 +258,7 @@ jobs: container-version: ${{ env.docker-registry-container-sha }} shell: ${{ matrix.platform.shell }} - name: Upload test results - uses: actions/upload-artifact@v3 + uses: actions/upload-artifact@v4 if: success() || failure() with: name: test-results-${{ matrix.platform.id }} @@ -289,7 +289,7 @@ jobs: runs-on: ubuntu-latest steps: - name: Check out repository - uses: actions/checkout@v3 + uses: actions/checkout@v4 with: path: source fetch-depth: 0 @@ -316,7 +316,7 @@ jobs: cm doc api.docurium git checkout gh-pages zip --exclude .git/\* --exclude .gitignore --exclude .gitattributes -r api-documentation.zip . - - uses: actions/upload-artifact@v3 + - uses: actions/upload-artifact@v4 name: Upload artifact with: name: api-documentation diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml index 779f66f586e..570b9aa6ab6 100644 --- a/.github/workflows/nightly.yml +++ b/.github/workflows/nightly.yml @@ -322,7 +322,7 @@ jobs: # All builds: experimental SHA256 support - name: "Linux (SHA256, Xenial, Clang, OpenSSL)" - id: xenial-clang-openssl + id: linux-sha256 container: name: xenial env: @@ -331,7 +331,7 @@ jobs: CMAKE_OPTIONS: -DUSE_HTTPS=OpenSSL -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=ON os: ubuntu-latest - name: "macOS (SHA256)" - id: macos + id: macos-sha256 os: macos-12 setup-script: osx env: @@ -341,7 +341,7 @@ jobs: SKIP_SSH_TESTS: true SKIP_NEGOTIATE_TESTS: true - name: "Windows (SHA256, amd64, Visual Studio)" - id: windows-amd64-vs + id: windows-sha256 os: windows-2019 env: ARCH: amd64 @@ -355,7 +355,7 @@ jobs: name: "Build ${{ matrix.platform.name }}" steps: - name: Check out repository - uses: actions/checkout@v3 + uses: actions/checkout@v4 with: path: source fetch-depth: 0 @@ -392,7 +392,7 @@ jobs: container-version: ${{ env.docker-registry-container-sha }} shell: ${{ matrix.platform.shell }} - name: Upload test results - uses: actions/upload-artifact@v3 + uses: actions/upload-artifact@v4 if: success() || failure() with: name: test-results-${{ matrix.platform.id }} @@ -420,7 +420,7 @@ jobs: runs-on: ubuntu-latest steps: - name: Check out repository - uses: actions/checkout@v3 + uses: actions/checkout@v4 with: path: source fetch-depth: 0 @@ -451,7 +451,7 @@ jobs: runs-on: ubuntu-latest steps: - name: Check out repository - uses: actions/checkout@v3 + uses: actions/checkout@v4 with: fetch-depth: 0 From cc7764f6a69c4b01c6e5e0b19e4177afb93d0620 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sun, 17 Mar 2024 14:11:40 +0000 Subject: [PATCH 557/608] config: correct fetching the HIGHEST_LEVEL config Also, add a test for fetching the `GIT_CONFIG_HIGHEST_LEVEL`. --- src/libgit2/config.c | 26 ++++++-------------------- tests/libgit2/config/configlevel.c | 23 +++++++++++++++++++++++ 2 files changed, 29 insertions(+), 20 deletions(-) diff --git a/src/libgit2/config.c b/src/libgit2/config.c index 21b9666db33..67ce6573801 100644 --- a/src/libgit2/config.c +++ b/src/libgit2/config.c @@ -241,7 +241,7 @@ static int find_backend_by_level( return GIT_ENOTFOUND; } - *out = entry->instance; + *out = found->instance; return 0; } @@ -430,27 +430,11 @@ typedef struct { size_t i; } all_iter; -static int find_next_backend(size_t *out, const git_config *config, size_t i) -{ - backend_entry *entry; - - for (; i > 0; --i) { - entry = git_vector_get(&config->readers, i - 1); - GIT_ASSERT(entry && entry->instance && entry->instance->backend); - - *out = i; - return 0; - } - - return -1; -} - static int all_iter_next(git_config_entry **out, git_config_iterator *_iter) { all_iter *iter = (all_iter *) _iter; backend_entry *entry; git_config_backend *backend; - size_t i; int error = 0; if (iter->current != NULL && @@ -462,12 +446,14 @@ static int all_iter_next(git_config_entry **out, git_config_iterator *_iter) return error; do { - if (find_next_backend(&i, iter->config, iter->i) < 0) + if (iter->i == 0) return GIT_ITEROVER; - entry = git_vector_get(&iter->config->readers, i - 1); + entry = git_vector_get(&iter->config->readers, iter->i - 1); + GIT_ASSERT(entry && entry->instance && entry->instance->backend); + backend = entry->instance->backend; - iter->i = i - 1; + iter->i--; if (iter->current) iter->current->free(iter->current); diff --git a/tests/libgit2/config/configlevel.c b/tests/libgit2/config/configlevel.c index 3534fbc2c84..0e31268b0c6 100644 --- a/tests/libgit2/config/configlevel.c +++ b/tests/libgit2/config/configlevel.c @@ -72,6 +72,29 @@ void test_config_configlevel__fetching_a_level_from_an_empty_compound_config_ret git_config_free(cfg); } +void test_config_configlevel__can_fetch_highest_level(void) +{ + git_config *cfg; + git_config *single_level_cfg; + git_buf buf = {0}; + + cl_git_pass(git_config_new(&cfg)); + cl_git_pass(git_config_add_file_ondisk(cfg, cl_fixture("config/config18"), + GIT_CONFIG_LEVEL_GLOBAL, NULL, 0)); + cl_git_pass(git_config_add_file_ondisk(cfg, cl_fixture("config/config19"), + GIT_CONFIG_LEVEL_LOCAL, NULL, 0)); + + cl_git_pass(git_config_open_level(&single_level_cfg, cfg, GIT_CONFIG_HIGHEST_LEVEL)); + + git_config_free(cfg); + + cl_git_pass(git_config_get_string_buf(&buf, single_level_cfg, "core.stringglobal")); + cl_assert_equal_s("don't find me!", buf.ptr); + + git_buf_dispose(&buf); + git_config_free(single_level_cfg); +} + void test_config_configlevel__can_override_local_with_worktree(void) { git_config *cfg; From 2eb3fecd03376be3f72a2c41716ee89b2fccdcaa Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sun, 17 Mar 2024 21:18:06 +0000 Subject: [PATCH 558/608] fetch: avoid API breaking-changes from v1.7 Update `git_fetch_options` to break out the fetch options into individual options. This prevents creating an API breaking change from v1.7.0. `git_remote_update_tips` retains the `update_flags` to also avoid an API breaking change. --- include/git2/remote.h | 9 +++++---- src/libgit2/clone.c | 2 +- src/libgit2/remote.c | 7 ++++++- 3 files changed, 12 insertions(+), 6 deletions(-) diff --git a/include/git2/remote.h b/include/git2/remote.h index 7ad820ad3c3..7067c88b0b1 100644 --- a/include/git2/remote.h +++ b/include/git2/remote.h @@ -744,10 +744,10 @@ typedef struct { git_fetch_prune_t prune; /** - * How to handle reference updates; a combination of - * `git_remote_update_flags`. + * How to handle reference updates; see `git_remote_update_flags`. */ - unsigned int update_flags; + unsigned int update_fetchhead : 1, + report_unchanged : 1; /** * Determines how to behave regarding tags on the remote, such @@ -790,7 +790,8 @@ typedef struct { GIT_FETCH_OPTIONS_VERSION, \ GIT_REMOTE_CALLBACKS_INIT, \ GIT_FETCH_PRUNE_UNSPECIFIED, \ - GIT_REMOTE_UPDATE_FETCHHEAD, \ + 1, \ + 0, \ GIT_REMOTE_DOWNLOAD_TAGS_UNSPECIFIED, \ GIT_PROXY_OPTIONS_INIT } diff --git a/src/libgit2/clone.c b/src/libgit2/clone.c index db9a898e34e..d62c77ac554 100644 --- a/src/libgit2/clone.c +++ b/src/libgit2/clone.c @@ -431,7 +431,7 @@ static int clone_into( return error; memcpy(&fetch_opts, opts, sizeof(git_fetch_options)); - fetch_opts.update_flags = ~GIT_REMOTE_UPDATE_FETCHHEAD; + fetch_opts.update_fetchhead = 0; if (!opts->depth) fetch_opts.download_tags = GIT_REMOTE_DOWNLOAD_TAGS_ALL; diff --git a/src/libgit2/remote.c b/src/libgit2/remote.c index 9eb4bac8b2f..8b07c83184a 100644 --- a/src/libgit2/remote.c +++ b/src/libgit2/remote.c @@ -1376,7 +1376,12 @@ int git_remote_fetch( return error; if (opts) { - update_flags = opts->update_flags; + if (opts->update_fetchhead) + update_flags |= GIT_REMOTE_UPDATE_FETCHHEAD; + + if (opts->report_unchanged) + update_flags |= GIT_REMOTE_UPDATE_REPORT_UNCHANGED; + tagopt = opts->download_tags; } From dd35af37d8ef1fbed24511ba8258ef77e6b8a0cc Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sun, 17 Mar 2024 21:28:17 +0000 Subject: [PATCH 559/608] repository: rearrange `git_repository_item_t` values Update the ordering of `GIT_REPOSITORY_ITEM_WORKTREE_CONFIG` to avoid breaking the ABI unnecessarily. --- include/git2/repository.h | 2 +- src/libgit2/repository.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/include/git2/repository.h b/include/git2/repository.h index 9ad6176f940..0afda72d402 100644 --- a/include/git2/repository.h +++ b/include/git2/repository.h @@ -499,12 +499,12 @@ typedef enum { GIT_REPOSITORY_ITEM_PACKED_REFS, GIT_REPOSITORY_ITEM_REMOTES, GIT_REPOSITORY_ITEM_CONFIG, - GIT_REPOSITORY_ITEM_WORKTREE_CONFIG, GIT_REPOSITORY_ITEM_INFO, GIT_REPOSITORY_ITEM_HOOKS, GIT_REPOSITORY_ITEM_LOGS, GIT_REPOSITORY_ITEM_MODULES, GIT_REPOSITORY_ITEM_WORKTREES, + GIT_REPOSITORY_ITEM_WORKTREE_CONFIG, GIT_REPOSITORY_ITEM__LAST } git_repository_item_t; diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index 06c653ea921..8e449a6df09 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -58,12 +58,12 @@ static const struct { { GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM_GITDIR, "packed-refs", false }, { GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM_GITDIR, "remotes", true }, { GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM_GITDIR, "config", false }, - { GIT_REPOSITORY_ITEM_GITDIR, GIT_REPOSITORY_ITEM_GITDIR, "config.worktree", false }, { GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM_GITDIR, "info", true }, { GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM_GITDIR, "hooks", true }, { GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM_GITDIR, "logs", true }, { GIT_REPOSITORY_ITEM_GITDIR, GIT_REPOSITORY_ITEM__LAST, "modules", true }, - { GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM_GITDIR, "worktrees", true } + { GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM_GITDIR, "worktrees", true }, + { GIT_REPOSITORY_ITEM_GITDIR, GIT_REPOSITORY_ITEM_GITDIR, "config.worktree", false } }; static int check_repositoryformatversion(int *version, git_config *config); From 4504f2c5cf7ca6ca8b7af3b748b0ba09df7801dd Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 18 Mar 2024 10:33:27 +0000 Subject: [PATCH 560/608] valgrind: suppress OpenSSL warnings --- script/valgrind.supp | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/script/valgrind.supp b/script/valgrind.supp index 8c4549f62be..12b6634d5fe 100644 --- a/script/valgrind.supp +++ b/script/valgrind.supp @@ -191,6 +191,16 @@ ... } +{ + ignore-openssl-undefined-in-connect + Memcheck:Cond + ... + obj:*libcrypto.so* + ... + fun:openssl_connect + ... +} + { ignore-libssh2-rsa-sha1-sign Memcheck:Leak From 647f8eb9879eb4fe0459658756fcf2d23982f40a Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Tue, 19 Dec 2023 16:56:30 +0000 Subject: [PATCH 561/608] ctype: only use custom functions on Windows The Microsoft C runtime (MSVCRT) may take a heavy lock on the locale in order to figure out how the `ctype` functions work. This is deeply slow. Provide our own to avoid that. On POSIX, provide emulation for that functionality using the ctype functions, but compress the return value into a `bool`, and cast the value to an `unsigned char`. --- src/util/ctype_compat.h | 52 +++++++++++++++++++++++++++++++++++++++++ src/util/git2_util.h | 1 + src/util/util.h | 34 --------------------------- 3 files changed, 53 insertions(+), 34 deletions(-) create mode 100644 src/util/ctype_compat.h diff --git a/src/util/ctype_compat.h b/src/util/ctype_compat.h new file mode 100644 index 00000000000..5b04a8dd42c --- /dev/null +++ b/src/util/ctype_compat.h @@ -0,0 +1,52 @@ +/* + * Copyright (C) the libgit2 contributors. All rights reserved. + * + * This file is part of libgit2, distributed under the GNU GPL v2 with + * a Linking Exception. For full terms see the included COPYING file. + */ +#ifndef INCLUDE_ctype_compat_h__ +#define INCLUDE_ctype_compat_h__ + +/* + * The Microsoft C runtime (MSVCRT) may take a heavy lock on the + * locale in order to figure out how the `ctype` functions work. + * This is deeply slow. Provide our own to avoid that. + */ + +#ifdef GIT_WIN32 + +GIT_INLINE(int) git__tolower(int c) +{ + return (c >= 'A' && c <= 'Z') ? (c + 32) : c; +} + +GIT_INLINE(bool) git__isalpha(int c) +{ + return ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')); +} + +GIT_INLINE(bool) git__isdigit(int c) +{ + return (c >= '0' && c <= '9'); +} +- +GIT_INLINE(bool) git__isspace(int c) +{ + return (c == ' ' || c == '\t' || c == '\n' || c == '\f' || c == '\r' || c == '\v'); +} + +GIT_INLINE(bool) git__isxdigit(int c) +{ + return ((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F')); +} + +#else +# define git__tolower(a) tolower((unsigned char)(a)) + +# define git__isalpha(a) (!!isalpha((unsigned char)(a))) +# define git__isdigit(a) (!!isdigit((unsigned char)(a))) +# define git__isspace(a) (!!isspace((unsigned char)(a))) +# define git__isxdigit(a) (!!isxdigit((unsigned char)(a))) +#endif + +#endif diff --git a/src/util/git2_util.h b/src/util/git2_util.h index 5ec9429344a..5bf09819956 100644 --- a/src/util/git2_util.h +++ b/src/util/git2_util.h @@ -165,5 +165,6 @@ typedef struct git_str git_str; if (GIT_MULTIPLY_SIZET_OVERFLOW(out, nelem, elsize)) { return -1; } #include "util.h" +#include "ctype_compat.h" #endif diff --git a/src/util/util.h b/src/util/util.h index 933644fd2b9..2ed005110ef 100644 --- a/src/util/util.h +++ b/src/util/util.h @@ -83,15 +83,6 @@ extern char *git__strsep(char **end, const char *sep); extern void git__strntolower(char *str, size_t len); extern void git__strtolower(char *str); -#ifdef GIT_WIN32 -GIT_INLINE(int) git__tolower(int c) -{ - return (c >= 'A' && c <= 'Z') ? (c + 32) : c; -} -#else -# define git__tolower(a) tolower((unsigned char)(a)) -#endif - extern size_t git__linenlen(const char *buffer, size_t buffer_len); GIT_INLINE(const char *) git__next_line(const char *s) @@ -249,26 +240,6 @@ GIT_INLINE(size_t) git__size_t_powerof2(size_t v) return git__size_t_bitmask(v) + 1; } -GIT_INLINE(bool) git__isupper(int c) -{ - return (c >= 'A' && c <= 'Z'); -} - -GIT_INLINE(bool) git__isalpha(int c) -{ - return ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')); -} - -GIT_INLINE(bool) git__isdigit(int c) -{ - return (c >= '0' && c <= '9'); -} - -GIT_INLINE(bool) git__isspace(int c) -{ - return (c == ' ' || c == '\t' || c == '\n' || c == '\f' || c == '\r' || c == '\v'); -} - GIT_INLINE(bool) git__isspace_nonlf(int c) { return (c == ' ' || c == '\t' || c == '\f' || c == '\r' || c == '\v'); @@ -279,11 +250,6 @@ GIT_INLINE(bool) git__iswildcard(int c) return (c == '*' || c == '?' || c == '['); } -GIT_INLINE(bool) git__isxdigit(int c) -{ - return ((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F')); -} - /* * Parse a string value as a boolean, just like Core Git does. * From 8e6beb3d16286f9647880ab6488ca7c2485d46cd Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Tue, 19 Dec 2023 17:09:16 +0000 Subject: [PATCH 562/608] ctype: switch to `git__` ctype functions Use the `git__` ctype functions (`git__isdigit` and friends) instead of explicitly casting. --- src/libgit2/config.c | 2 +- src/libgit2/config_parse.c | 4 ++-- src/libgit2/path.c | 2 +- src/libgit2/trailer.c | 10 +++++----- src/libgit2/transports/smart_pkt.c | 4 ++-- src/util/ctype_compat.h | 20 +++++++++++++++++++- src/util/date.c | 26 +++++++++++++------------- src/util/str.c | 4 ++-- tests/libgit2/repo/open.c | 2 +- 9 files changed, 46 insertions(+), 28 deletions(-) diff --git a/src/libgit2/config.c b/src/libgit2/config.c index 5c1c00f6cb7..cfc3a4b2e26 100644 --- a/src/libgit2/config.c +++ b/src/libgit2/config.c @@ -1447,7 +1447,7 @@ static int normalize_section(char *start, char *end) for (scan = start; *scan; ++scan) { if (end && scan >= end) break; - if (isalnum((unsigned char)*scan)) + if (git__isalnum(*scan)) *scan = (char)git__tolower(*scan); else if (*scan != '-' || scan == start) return GIT_EINVALIDSPEC; diff --git a/src/libgit2/config_parse.c b/src/libgit2/config_parse.c index 9ab78cc7f60..7f933db4885 100644 --- a/src/libgit2/config_parse.c +++ b/src/libgit2/config_parse.c @@ -27,7 +27,7 @@ static void set_parse_error(git_config_parser *reader, int col, const char *erro GIT_INLINE(int) config_keychar(char c) { - return isalnum((unsigned char)c) || c == '-'; + return git__isalnum(c) || c == '-'; } static int strip_comments(char *line, int in_quotes) @@ -383,7 +383,7 @@ static int parse_multiline_variable(git_config_parser *reader, git_str *value, i GIT_INLINE(bool) is_namechar(char c) { - return isalnum((unsigned char)c) || c == '-'; + return git__isalnum(c) || c == '-'; } static int parse_name( diff --git a/src/libgit2/path.c b/src/libgit2/path.c index 50181fdbff0..4b584fb8056 100644 --- a/src/libgit2/path.c +++ b/src/libgit2/path.c @@ -202,7 +202,7 @@ GIT_INLINE(size_t) common_prefix_icase(const char *str, size_t len, const char * { size_t count = 0; - while (len > 0 && tolower((unsigned char)*str) == tolower((unsigned char)*prefix)) { + while (len > 0 && git__tolower(*str) == git__tolower(*prefix)) { count++; str++; prefix++; diff --git a/src/libgit2/trailer.c b/src/libgit2/trailer.c index 9fb16418413..6e37cfdcf2d 100644 --- a/src/libgit2/trailer.c +++ b/src/libgit2/trailer.c @@ -24,7 +24,7 @@ static const char *const git_generated_prefixes[] = { static int is_blank_line(const char *str) { const char *s = str; - while (*s && *s != '\n' && isspace((unsigned char)*s)) + while (*s && *s != '\n' && git__isspace(*s)) s++; return !*s || *s == '\n'; } @@ -93,7 +93,7 @@ static bool find_separator(size_t *out, const char *line, const char *separators return true; } - if (!whitespace_found && (isalnum((unsigned char)*c) || *c == '-')) + if (!whitespace_found && (git__isalnum(*c) || *c == '-')) continue; if (c != line && (*c == ' ' || *c == '\t')) { whitespace_found = 1; @@ -233,12 +233,12 @@ static size_t find_trailer_start(const char *buf, size_t len) } find_separator(&separator_pos, bol, TRAILER_SEPARATORS); - if (separator_pos >= 1 && !isspace((unsigned char)bol[0])) { + if (separator_pos >= 1 && !git__isspace(bol[0])) { trailer_lines++; possible_continuation_lines = 0; if (recognized_prefix) continue; - } else if (isspace((unsigned char)bol[0])) + } else if (git__isspace(bol[0])) possible_continuation_lines++; else { non_trailer_lines++; @@ -323,7 +323,7 @@ int git_message_trailers(git_message_trailer_array *trailer_arr, const char *mes goto ret; } - if (isalnum((unsigned char)*ptr) || *ptr == '-') { + if (git__isalnum(*ptr) || *ptr == '-') { /* legal key character */ NEXT(S_KEY); } diff --git a/src/libgit2/transports/smart_pkt.c b/src/libgit2/transports/smart_pkt.c index 08cb7fbe5c2..6a3f903df15 100644 --- a/src/libgit2/transports/smart_pkt.c +++ b/src/libgit2/transports/smart_pkt.c @@ -535,10 +535,10 @@ static int parse_len(size_t *out, const char *line, size_t linelen) num[PKT_LEN_SIZE] = '\0'; for (i = 0; i < PKT_LEN_SIZE; ++i) { - if (!isxdigit((unsigned char)num[i])) { + if (!git__isxdigit(num[i])) { /* Make sure there are no special characters before passing to error message */ for (k = 0; k < PKT_LEN_SIZE; ++k) { - if(!isprint((unsigned char)num[k])) { + if(!git__isprint(num[k])) { num[k] = '.'; } } diff --git a/src/util/ctype_compat.h b/src/util/ctype_compat.h index 5b04a8dd42c..462c8a17f17 100644 --- a/src/util/ctype_compat.h +++ b/src/util/ctype_compat.h @@ -20,6 +20,11 @@ GIT_INLINE(int) git__tolower(int c) return (c >= 'A' && c <= 'Z') ? (c + 32) : c; } +GIT_INLINE(int) git__toupper(int c) +{ + return (c >= 'a' && c <= 'z') ? (c - 32) : c; +} + GIT_INLINE(bool) git__isalpha(int c) { return ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')); @@ -29,7 +34,12 @@ GIT_INLINE(bool) git__isdigit(int c) { return (c >= '0' && c <= '9'); } -- + +GIT_INLINE(bool) git__isalnum(int c) +{ + return git__isalpha(c) || git__isdigit(c); +} + GIT_INLINE(bool) git__isspace(int c) { return (c == ' ' || c == '\t' || c == '\n' || c == '\f' || c == '\r' || c == '\v'); @@ -40,13 +50,21 @@ GIT_INLINE(bool) git__isxdigit(int c) return ((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F')); } +GIT_INLINE(bool) git__isprint(int c) +{ + return (c >= ' ' && c <= '~'); +} + #else # define git__tolower(a) tolower((unsigned char)(a)) +# define git__toupper(a) toupper((unsigned char)(a)) # define git__isalpha(a) (!!isalpha((unsigned char)(a))) # define git__isdigit(a) (!!isdigit((unsigned char)(a))) +# define git__isalnum(a) (!!isalnum((unsigned char)(a))) # define git__isspace(a) (!!isspace((unsigned char)(a))) # define git__isxdigit(a) (!!isxdigit((unsigned char)(a))) +# define git__isprint(a) (!!isprint((unsigned char)(a))) #endif #endif diff --git a/src/util/date.c b/src/util/date.c index d54056842dd..872cb81f33c 100644 --- a/src/util/date.c +++ b/src/util/date.c @@ -129,9 +129,9 @@ static size_t match_string(const char *date, const char *str) for (i = 0; *date; date++, str++, i++) { if (*date == *str) continue; - if (toupper((unsigned char)*date) == toupper((unsigned char)*str)) + if (git__toupper(*date) == git__toupper(*str)) continue; - if (!isalnum((unsigned char)*date)) + if (!git__isalnum(*date)) break; return 0; } @@ -143,7 +143,7 @@ static int skip_alpha(const char *date) int i = 0; do { i++; - } while (isalpha((unsigned char)date[i])); + } while (git__isalpha(date[i])); return i; } @@ -251,7 +251,7 @@ static size_t match_multi_number(unsigned long num, char c, const char *date, ch num2 = strtol(end+1, &end, 10); num3 = -1; - if (*end == c && isdigit((unsigned char)end[1])) + if (*end == c && git__isdigit(end[1])) num3 = strtol(end+1, &end, 10); /* Time? Date? */ @@ -349,7 +349,7 @@ static size_t match_digit(const char *date, struct tm *tm, int *offset, int *tm_ case '.': case '/': case '-': - if (isdigit((unsigned char)end[1])) { + if (git__isdigit(end[1])) { size_t match = match_multi_number(num, *end, date, end, tm); if (match) return match; @@ -364,7 +364,7 @@ static size_t match_digit(const char *date, struct tm *tm, int *offset, int *tm_ n = 0; do { n++; - } while (isdigit((unsigned char)date[n])); + } while (git__isdigit(date[n])); /* Four-digit year or a timezone? */ if (n == 4) { @@ -514,11 +514,11 @@ static int parse_date_basic(const char *date, git_time_t *timestamp, int *offset if (!c || c == '\n') break; - if (isalpha(c)) + if (git__isalpha(c)) match = match_alpha(date, &tm, offset); - else if (isdigit(c)) + else if (git__isdigit(c)) match = match_digit(date, &tm, offset, &tm_gmt); - else if ((c == '-' || c == '+') && isdigit((unsigned char)date[1])) + else if ((c == '-' || c == '+') && git__isdigit(date[1])) match = match_tz(date, offset); if (!match) { @@ -682,7 +682,7 @@ static const char *approxidate_alpha(const char *date, struct tm *tm, struct tm const char *end = date; int i; - while (isalpha((unsigned char)*++end)) + while (git__isalpha(*++end)) /* scan to non-alpha */; for (i = 0; i < 12; i++) { @@ -783,7 +783,7 @@ static const char *approxidate_digit(const char *date, struct tm *tm, int *num) case '.': case '/': case '-': - if (isdigit((unsigned char)end[1])) { + if (git__isdigit(end[1])) { size_t match = match_multi_number(number, *end, date, end, tm); if (match) return date + match; @@ -843,13 +843,13 @@ static git_time_t approxidate_str(const char *date, if (!c) break; date++; - if (isdigit(c)) { + if (git__isdigit(c)) { pending_number(&tm, &number); date = approxidate_digit(date-1, &tm, &number); touched = 1; continue; } - if (isalpha(c)) + if (git__isalpha(c)) date = approxidate_alpha(date-1, &tm, &now, &number, &touched); } pending_number(&tm, &number); diff --git a/src/util/str.c b/src/util/str.c index 625faba06db..0b07c814702 100644 --- a/src/util/str.c +++ b/src/util/str.c @@ -485,8 +485,8 @@ int git_str_decode_percent( for (str_pos = 0; str_pos < str_len; buf->size++, str_pos++) { if (str[str_pos] == '%' && str_len > str_pos + 2 && - isxdigit((unsigned char)str[str_pos + 1]) && - isxdigit((unsigned char)str[str_pos + 2])) { + git__isxdigit(str[str_pos + 1]) && + git__isxdigit(str[str_pos + 2])) { buf->ptr[buf->size] = (HEX_DECODE(str[str_pos + 1]) << 4) + HEX_DECODE(str[str_pos + 2]); str_pos += 2; diff --git a/tests/libgit2/repo/open.c b/tests/libgit2/repo/open.c index 219612016b9..9eef7f5a7e8 100644 --- a/tests/libgit2/repo/open.c +++ b/tests/libgit2/repo/open.c @@ -316,7 +316,7 @@ static void unposix_path(git_str *path) src = tgt = path->ptr; /* convert "/d/..." to "d:\..." */ - if (src[0] == '/' && isalpha((unsigned char)src[1]) && src[2] == '/') { + if (src[0] == '/' && git__isalpha(src[1]) && src[2] == '/') { *tgt++ = src[1]; *tgt++ = ':'; *tgt++ = '\\'; From 467556993fa9d249294858c967f0b4a6359b9a3b Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 18 Mar 2024 10:14:35 +0000 Subject: [PATCH 563/608] ntlmclient: use unsigned char for ctype functions --- deps/ntlmclient/ntlm.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/deps/ntlmclient/ntlm.c b/deps/ntlmclient/ntlm.c index ad4de5de56e..6094a4a3484 100644 --- a/deps/ntlmclient/ntlm.c +++ b/deps/ntlmclient/ntlm.c @@ -988,9 +988,9 @@ static inline bool generate_lm_hash( keystr2_len = (password_len > 7) ? MIN(14, password_len) - 7 : 0; for (i = 0; i < keystr1_len; i++) - keystr1[i] = (unsigned char)toupper(password[i]); + keystr1[i] = (unsigned char)toupper((unsigned char)password[i]); for (i = 0; i < keystr2_len; i++) - keystr2[i] = (unsigned char)toupper(password[i+7]); + keystr2[i] = (unsigned char)toupper((unsigned char)password[i+7]); /* DES encrypt the LM constant using the password as the key */ des_key_from_password(&key1, keystr1, keystr1_len); From 9288436e38b64ec86795f90710b79ccf8ceba1a6 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Tue, 19 Mar 2024 07:01:01 +0000 Subject: [PATCH 564/608] ci: split SHA256 builds out into their own workflow Split the SHA256 builds into their own workflow; since they're experimental (and have proven to be flaky) they shouldn't be used as signal that there's a problem with a PR. --- .github/workflows/experimental.yml | 118 +++++++++++++++++++++++++++++ .github/workflows/main.yml | 31 -------- 2 files changed, 118 insertions(+), 31 deletions(-) create mode 100644 .github/workflows/experimental.yml diff --git a/.github/workflows/experimental.yml b/.github/workflows/experimental.yml new file mode 100644 index 00000000000..5bfea2c0028 --- /dev/null +++ b/.github/workflows/experimental.yml @@ -0,0 +1,118 @@ +# Validation builds for experimental features; these shouldn't be +# required for pull request approval. +name: Experimental Features + +on: + push: + branches: [ main, maint/* ] + pull_request: + branches: [ main, maint/* ] + workflow_dispatch: + +env: + docker-registry: ghcr.io + docker-config-path: ci/docker + +permissions: + contents: write + packages: write + +jobs: + # Run our CI/CD builds. We build a matrix with the various build targets + # and their details. Then we build either in a docker container (Linux) + # or on the actual hosts (macOS, Windows). + build: + strategy: + matrix: + platform: + # All builds: experimental SHA256 support + - name: "Linux (SHA256, Xenial, Clang, OpenSSL)" + id: linux-sha256 + os: ubuntu-latest + container: + name: xenial + env: + CC: clang + CMAKE_GENERATOR: Ninja + CMAKE_OPTIONS: -DUSE_HTTPS=OpenSSL -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=ON -DEXPERIMENTAL_SHA256=ON + - name: "macOS (SHA256)" + id: macos-sha256 + os: macos-12 + setup-script: osx + env: + CC: clang + CMAKE_OPTIONS: -DREGEX_BACKEND=regcomp_l -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=leaks -DUSE_GSSAPI=ON -DEXPERIMENTAL_SHA256=ON + CMAKE_GENERATOR: Ninja + PKG_CONFIG_PATH: /usr/local/opt/openssl/lib/pkgconfig + SKIP_SSH_TESTS: true + SKIP_NEGOTIATE_TESTS: true + - name: "Windows (SHA256, amd64, Visual Studio)" + id: windows-sha256 + os: windows-2019 + env: + ARCH: amd64 + CMAKE_GENERATOR: Visual Studio 16 2019 + CMAKE_OPTIONS: -A x64 -DWIN32_LEAKCHECK=ON -DDEPRECATE_HARD=ON -DEXPERIMENTAL_SHA256=ON + SKIP_SSH_TESTS: true + SKIP_NEGOTIATE_TESTS: true + fail-fast: false + env: ${{ matrix.platform.env }} + runs-on: ${{ matrix.platform.os }} + name: "Build: ${{ matrix.platform.name }}" + steps: + - name: Check out repository + uses: actions/checkout@v4 + with: + path: source + fetch-depth: 0 + - name: Set up build environment + run: source/ci/setup-${{ matrix.platform.setup-script }}-build.sh + shell: bash + if: matrix.platform.setup-script != '' + - name: Setup QEMU + run: docker run --rm --privileged multiarch/qemu-user-static:register --reset + if: matrix.platform.container.qemu == true + - name: Set up container + uses: ./source/.github/actions/download-or-build-container + with: + registry: ${{ env.docker-registry }} + config-path: ${{ env.docker-config-path }} + container: ${{ matrix.platform.container.name }} + github_token: ${{ secrets.github_token }} + dockerfile: ${{ matrix.platform.container.dockerfile }} + if: matrix.platform.container.name != '' + - name: Prepare build + run: mkdir build + - name: Build + uses: ./source/.github/actions/run-build + with: + command: cd ${BUILD_WORKSPACE:-.}/build && ../source/ci/build.sh + container: ${{ matrix.platform.container.name }} + container-version: ${{ env.docker-registry-container-sha }} + shell: ${{ matrix.platform.shell }} + - name: Test + uses: ./source/.github/actions/run-build + with: + command: cd ${BUILD_WORKSPACE:-.}/build && ../source/ci/test.sh + container: ${{ matrix.platform.container.name }} + container-version: ${{ env.docker-registry-container-sha }} + shell: ${{ matrix.platform.shell }} + - name: Upload test results + uses: actions/upload-artifact@v4 + if: success() || failure() + with: + name: test-results-${{ matrix.platform.id }} + path: build/results_*.xml + + test_results: + name: Test results + needs: [ build ] + if: always() + runs-on: ubuntu-latest + steps: + - name: Download test results + uses: actions/download-artifact@v3 + - name: Generate test summary + uses: test-summary/action@v2 + with: + paths: 'test-results-*/*.xml' diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 236a7d13bb6..87e834f10db 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -184,37 +184,6 @@ jobs: ASAN_SYMBOLIZER_PATH: /usr/bin/llvm-symbolizer-10 UBSAN_OPTIONS: print_stacktrace=1 TSAN_OPTIONS: suppressions=/home/libgit2/source/script/thread-sanitizer.supp second_deadlock_stack=1 - - # All builds: experimental SHA256 support - - name: "Linux (SHA256, Xenial, Clang, OpenSSL)" - id: linux-sha256 - os: ubuntu-latest - container: - name: xenial - env: - CC: clang - CMAKE_GENERATOR: Ninja - CMAKE_OPTIONS: -DUSE_HTTPS=OpenSSL -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=ON -DEXPERIMENTAL_SHA256=ON - - name: "macOS (SHA256)" - id: macos-sha256 - os: macos-12 - setup-script: osx - env: - CC: clang - CMAKE_OPTIONS: -DREGEX_BACKEND=regcomp_l -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=leaks -DUSE_GSSAPI=ON -DEXPERIMENTAL_SHA256=ON - CMAKE_GENERATOR: Ninja - PKG_CONFIG_PATH: /usr/local/opt/openssl/lib/pkgconfig - SKIP_SSH_TESTS: true - SKIP_NEGOTIATE_TESTS: true - - name: "Windows (SHA256, amd64, Visual Studio)" - id: windows-sha256 - os: windows-2019 - env: - ARCH: amd64 - CMAKE_GENERATOR: Visual Studio 16 2019 - CMAKE_OPTIONS: -A x64 -DWIN32_LEAKCHECK=ON -DDEPRECATE_HARD=ON -DEXPERIMENTAL_SHA256=ON - SKIP_SSH_TESTS: true - SKIP_NEGOTIATE_TESTS: true fail-fast: false env: ${{ matrix.platform.env }} runs-on: ${{ matrix.platform.os }} From 7940f094a54765f277d5ce9bcb9d6ce6ea9d24e5 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 16 Mar 2024 21:41:59 +0000 Subject: [PATCH 565/608] v1.8: update COPYING file Include the ntlmclient dependency's license file. --- COPYING | 169 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 169 insertions(+) diff --git a/COPYING b/COPYING index ff5e76857e3..bc94b9df9fa 100644 --- a/COPYING +++ b/COPYING @@ -1214,3 +1214,172 @@ AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +---------------------------------------------------------------------- + +The bundled ntlmclient code is licensed under the MIT license: + +Copyright (c) Edward Thomson. All rights reserved. + +Permission is hereby granted, free of charge, to any person obtaining a +copy of this software and associated documentation files (the "Software"), +to deal in the Software without restriction, including without limitation +the rights to use, copy, modify, merge, publish, distribute, sublicense, +and/or sell copies of the Software, and to permit persons to whom the +Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included +in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +DEALINGS IN THE SOFTWARE. + +---------------------------------------------------------------------- + +Portions of this software derived from Team Explorer Everywhere: + +Copyright (c) Microsoft Corporation + +All rights reserved. + +Permission is hereby granted, free of charge, to any person obtaining a +copy of this software and associated documentation files (the "Software"), +to deal in the Software without restriction, including without limitation +the rights to use, copy, modify, merge, publish, distribute, sublicense, +and/or sell copies of the Software, and to permit persons to whom the +Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included +in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS +OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR +OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. + +--------------------------------------------------------------------------- + +Portions of this software derived from the LLVM Compiler Infrastructure: + +Copyright (c) 2003-2016 University of Illinois at Urbana-Champaign. +All rights reserved. + +Developed by: + + LLVM Team + + University of Illinois at Urbana-Champaign + + http://llvm.org + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal with +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: + + * Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimers. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimers in the + documentation and/or other materials provided with the distribution. + + * Neither the names of the LLVM Team, University of Illinois at + Urbana-Champaign, nor the names of its contributors may be used to + endorse or promote products derived from this Software without specific + prior written permission. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE +SOFTWARE. + +--------------------------------------------------------------------------- + +Portions of this software derived from Unicode, Inc: + +Copyright 2001-2004 Unicode, Inc. + +Disclaimer + +This source code is provided as is by Unicode, Inc. No claims are +made as to fitness for any particular purpose. No warranties of any +kind are expressed or implied. The recipient agrees to determine +applicability of information provided. If this file has been +purchased on magnetic or optical media from Unicode, Inc., the +sole remedy for any claim will be exchange of defective media +within 90 days of receipt. + +Limitations on Rights to Redistribute This Code + +Unicode, Inc. hereby grants the right to freely use the information +supplied in this file in the creation of products supporting the +Unicode Standard, and to make copies of this file in any form +for internal or external distribution as long as this notice +remains attached. + +--------------------------------------------------------------------------- + +Portions of this software derived from sheredom/utf8.h: + +This is free and unencumbered software released into the public domain. + +Anyone is free to copy, modify, publish, use, compile, sell, or +distribute this software, either in source code form or as a compiled +binary, for any purpose, commercial or non-commercial, and by any +means. + +In jurisdictions that recognize copyright laws, the author or authors +of this software dedicate any and all copyright interest in the +software to the public domain. We make this dedication for the benefit +of the public at large and to the detriment of our heirs and +successors. We intend this dedication to be an overt act of +relinquishment in perpetuity of all present and future rights to this +software under copyright law. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR +OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. + +For more information, please refer to + +--------------------------------------------------------------------------- + +Portions of this software derived from RFC 1320: + +Copyright (C) 1990-2, RSA Data Security, Inc. All rights reserved. + +License to copy and use this software is granted provided that it +is identified as the "RSA Data Security, Inc. MD4 Message-Digest +Algorithm" in all material mentioning or referencing this software +or this function. + +License is also granted to make and use derivative works provided +that such works are identified as "derived from the RSA Data +Security, Inc. MD4 Message-Digest Algorithm" in all material +mentioning or referencing the derived work. + +RSA Data Security, Inc. makes no representations concerning either +the merchantability of this software or the suitability of this +software for any particular purpose. It is provided "as is" +without express or implied warranty of any kind. + +These notices must be retained in any copies of any part of this +documentation and/or software. From 5aa3ce722538bc898af09be332e8ccaa5d04232c Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 16 Mar 2024 20:07:30 +0000 Subject: [PATCH 566/608] v1.8: update version numbers --- README.md | 2 +- include/git2/version.h | 6 +++--- package.json | 2 +- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/README.md b/README.md index f4dbc789154..77efdd4a688 100644 --- a/README.md +++ b/README.md @@ -4,8 +4,8 @@ libgit2 - the Git linkable library | Build Status | | | ------------ | - | | **main** branch CI builds | [![CI Build](https://github.com/libgit2/libgit2/workflows/CI%20Build/badge.svg?event=push)](https://github.com/libgit2/libgit2/actions?query=workflow%3A%22CI+Build%22+event%3Apush) | +| **v1.8 branch** CI builds | [![CI Build](https://github.com/libgit2/libgit2/workflows/CI%20Build/badge.svg?branch=maint%2Fv1.8&event=push)](https://github.com/libgit2/libgit2/actions?query=workflow%3A%22CI+Build%22+event%3Apush+branch%3Amaint%2Fv1.8) | | **v1.7 branch** CI builds | [![CI Build](https://github.com/libgit2/libgit2/workflows/CI%20Build/badge.svg?branch=maint%2Fv1.7&event=push)](https://github.com/libgit2/libgit2/actions?query=workflow%3A%22CI+Build%22+event%3Apush+branch%3Amaint%2Fv1.7) | -| **v1.6 branch** CI builds | [![CI Build](https://github.com/libgit2/libgit2/workflows/CI%20Build/badge.svg?branch=maint%2Fv1.6&event=push)](https://github.com/libgit2/libgit2/actions?query=workflow%3A%22CI+Build%22+event%3Apush+branch%3Amaint%2Fv1.6) | | **Nightly** builds | [![Nightly Build](https://github.com/libgit2/libgit2/workflows/Nightly%20Build/badge.svg)](https://github.com/libgit2/libgit2/actions?query=workflow%3A%22Nightly+Build%22) [![Coverity Scan Status](https://scan.coverity.com/projects/639/badge.svg)](https://scan.coverity.com/projects/639) | `libgit2` is a portable, pure C implementation of the Git core methods diff --git a/include/git2/version.h b/include/git2/version.h index 76cb0026fc2..010d4a224d9 100644 --- a/include/git2/version.h +++ b/include/git2/version.h @@ -11,7 +11,7 @@ * The version string for libgit2. This string follows semantic * versioning (v2) guidelines. */ -#define LIBGIT2_VERSION "1.8.0-alpha" +#define LIBGIT2_VERSION "1.8.0" /** The major version number for this version of libgit2. */ #define LIBGIT2_VER_MAJOR 1 @@ -31,13 +31,13 @@ * a prerelease name like "beta" or "rc1". For final releases, this will * be `NULL`. */ -#define LIBGIT2_VER_PRERELEASE "alpha" +#define LIBGIT2_VER_PRERELEASE NULL /** * The library ABI soversion for this version of libgit2. This should * only be changed when the library has a breaking ABI change, and so * may trail the library's version number. */ -#define LIBGIT2_SOVERSION "1.7" +#define LIBGIT2_SOVERSION "1.8" #endif diff --git a/package.json b/package.json index 203e99b9bc6..2306e721853 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "libgit2", - "version": "1.8.0-alpha", + "version": "1.8.0", "repo": "https://github.com/libgit2/libgit2", "description": " A cross-platform, linkable library implementation of Git that you can use in your application.", "install": "mkdir build && cd build && cmake .. && cmake --build ." From 69f257711014e738819feb13280d9428d0539339 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sun, 17 Mar 2024 13:55:52 +0000 Subject: [PATCH 567/608] v1.8: update changelog --- docs/changelog.md | 317 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 317 insertions(+) diff --git a/docs/changelog.md b/docs/changelog.md index f733102356a..7b118c798be 100644 --- a/docs/changelog.md +++ b/docs/changelog.md @@ -1,3 +1,320 @@ +v1.8 +---- + +This is release v1.8.0, "Das Fliegende Klassenzimmer". This release +includes optional, experimental support for invoking OpenSSH to fetch +and push, an easier mechanism to perform the default behavior of +`git commit`, and has many improvements for worktrees. This release +also includes many other new features and bugfixes. + +## Major changes + +* **Executable SSH (OpenSSH) support** + libgit2 can now invoke the command-line OpenSSH to fetch from and push + to remotes over SSH. This support takes the place of libssh2 support. + To use it, configure libgit2 with `cmake -DUSE_SSH=exec`, and please + report any problems that you discover. By @ethomson in + https://github.com/libgit2/libgit2/pull/6617 + +* **Simplified commit creation** + The `git_commit_create_from_stage` API was introduced to allow users to + better emulate the behavior of `git commit` without needing to provide + unnecessary information. The current state of the index is committed to + the current branch. By @ethomson in + https://github.com/libgit2/libgit2/pull/6716 + +* **Worktree improvements** + A number of worktree improvements have been made for better + compatibility with core git. First, libgit2 now understands per-worktree + references, thanks to @csware in + https://github.com/libgit2/libgit2/pull/6387. Worktree-specific + configuration is now supported, thanks to @vermiculus in + https://github.com/libgit2/libgit2/pull/6202. And improved compatibility + with `git worktree add` is now supported, thanks to @herrerog in + https://github.com/libgit2/libgit2/pull/5319. + +## Breaking changes + +* **Adding `WORKTREE` configuration level** (ABI breaking change) + To support worktree configurations at the appropriate level (higher + priority than local configuration, but lower priority than app-specific + configuration), the `GIT_CONFIG_LEVEL_WORKTREE` level was introduced at + priority 6. `GIT_CONFIG_LEVEL_APP` now begins at priority 7. + +* **Changes to `git_config_entry`** (ABI breaking change) + The `git_config_entry` structure now contains information about the + `backend_type` and `origin_path`. The unused `payload` value has been + removed. + +* **`git_push_options` includes remote push options** (ABI breaking change) + The `git_push_options` structure now contains a value for remote push + options. + +## Other changes + +### New features + +* config: provide an "origin" for config entries by @ethomson in + https://github.com/libgit2/libgit2/pull/6615 +* cli: add a `git config` command by @ethomson in + https://github.com/libgit2/libgit2/pull/6616 +* Add OpenSSH support by @ethomson in + https://github.com/libgit2/libgit2/pull/6617 +* remote: optionally report unchanged tips by @ethomson in + https://github.com/libgit2/libgit2/pull/6645 +* Support setting oid type for in-memory repositories by @kcsaul in + https://github.com/libgit2/libgit2/pull/6671 +* cli: add `index-pack` command by @ethomson in + https://github.com/libgit2/libgit2/pull/6681 +* Add `git_repository_commit_parents` to identify the parents of the next + commit given the repository state by @ethomson in + https://github.com/libgit2/libgit2/pull/6707 +* commit: introduce `git_commit_create_from_stage` by @ethomson in + https://github.com/libgit2/libgit2/pull/6716 +* set SSH timeout by @vafada in + https://github.com/libgit2/libgit2/pull/6721 +* Implement push options on push by @russell in + https://github.com/libgit2/libgit2/pull/6439 +* Support index.skipHash true config by @parnic in + https://github.com/libgit2/libgit2/pull/6738 +* worktree: mimic 'git worktree add' behavior. by @herrerog in + https://github.com/libgit2/libgit2/pull/5319 +* Support the extension for worktree-specific config by @vermiculus in + https://github.com/libgit2/libgit2/pull/6202 +* Separate config reader and writer backend priorities (for worktree + configs) by @ethomson in https://github.com/libgit2/libgit2/pull/6756 +* fetch: enable deepening/shortening shallow clones by @kempniu in + https://github.com/libgit2/libgit2/pull/6662 + +### Bug fixes + +* repository: make cleanup safe for re-use with grafts by @carlosmn in + https://github.com/libgit2/libgit2/pull/6600 +* fix: Add missing include for `oidarray`. by @dvzrv in + https://github.com/libgit2/libgit2/pull/6608 +* ssh: fix `known_hosts` leak in `_git_ssh_setup_conn` by @steven9724 in + https://github.com/libgit2/libgit2/pull/6599 +* proxy: Return an error for invalid proxy URLs instead of crashing by + @lrm29 in https://github.com/libgit2/libgit2/pull/6597 +* errors: refactoring - never return `NULL` in `git_error_last()` by + @ethomson in https://github.com/libgit2/libgit2/pull/6625 +* Reject potential option injections over ssh by @carlosmn in + https://github.com/libgit2/libgit2/pull/6636 +* remote: fix memory leak in `git_remote_download()` by @7Ji in + https://github.com/libgit2/libgit2/pull/6651 +* git2: Fix crash when called w/o parameters by @csware in + https://github.com/libgit2/libgit2/pull/6673 +* Avoid macro redefinition of `ENABLE_INTSAFE_SIGNED_FUNCTIONS` by @csware + in https://github.com/libgit2/libgit2/pull/6666 +* util: suppress some uninitialized variable warnings by @boretrk in + https://github.com/libgit2/libgit2/pull/6659 +* push: set generic error in `push_negotiation` cb by @ethomson in + https://github.com/libgit2/libgit2/pull/6675 +* process: test `/usr/bin/false` on BSDs by @ethomson in + https://github.com/libgit2/libgit2/pull/6677 +* clone: don't mix up "http://url" with "http:/url" when figuring out if we + should do a local clone by @boretrk in + https://github.com/libgit2/libgit2/pull/6361 +* Several compatibility fixes by @ethomson in + https://github.com/libgit2/libgit2/pull/6678 +* Git blame buffer gives the wrong result in many cases where there are + by @thosey in https://github.com/libgit2/libgit2/pull/6572 +* Fix 'path cannot exist in repository' during diff for in-memory repository + by @kcsaul in https://github.com/libgit2/libgit2/pull/6683 +* process: don't try to close the status by @ethomson in + https://github.com/libgit2/libgit2/pull/6693 +* Minor bug fixes by @ethomson in + https://github.com/libgit2/libgit2/pull/6695 +* Bypass shallow clone support for in-memory repositories by @kcsaul in + https://github.com/libgit2/libgit2/pull/6684 +* examples: use `unsigned` int for bitfields by @ethomson in + https://github.com/libgit2/libgit2/pull/6699 +* Fix some bugs caught by UBscan by @ethomson in + https://github.com/libgit2/libgit2/pull/6700 +* `git_diff_find_similar` doesn't always remove unmodified deltas by @yori + in https://github.com/libgit2/libgit2/pull/6642 +* httpclient: clear `client->parser.data` after use by @ethomson in + https://github.com/libgit2/libgit2/pull/6705 +* Do not normalize `safe.directory` paths by @csware in + https://github.com/libgit2/libgit2/pull/6668 +* clone: don't swallow error in `should_checkout` by @ethomson in + https://github.com/libgit2/libgit2/pull/6727 +* Correct index add directory/file conflict detection by @ethomson in + https://github.com/libgit2/libgit2/pull/6729 +* Correct `git_revparse_single` and add revparse fuzzing by @ethomson in + https://github.com/libgit2/libgit2/pull/6730 +* config: properly delete or rename section containing multivars by + @samueltardieu in https://github.com/libgit2/libgit2/pull/6723 +* revparse: ensure bare '@' is truly bare by @ethomson in + https://github.com/libgit2/libgit2/pull/6742 +* repo: ensure we can initialize win32 paths by @ethomson in + https://github.com/libgit2/libgit2/pull/6743 +* Swap `GIT_DIFF_LINE_(ADD|DEL)_EOFNL` to match other Diffs by @xphoniex in + https://github.com/libgit2/libgit2/pull/6240 +* diff: fix test for SHA256 support in `diff_from_buffer` by @ethomson in + https://github.com/libgit2/libgit2/pull/6745 +* http: support empty http.proxy config setting by @ethomson in + https://github.com/libgit2/libgit2/pull/6744 +* More `safe.directory` improvements by @ethomson in + https://github.com/libgit2/libgit2/pull/6739 +* Ensure that completely ignored diff is empty by @ethomson in + https://github.com/libgit2/libgit2/pull/5893 +* Fix broken regexp that matches submodule names containing ".path" by + @csware in https://github.com/libgit2/libgit2/pull/6749 +* Fix memory leaks by @csware in + https://github.com/libgit2/libgit2/pull/6748 +* Make `refdb_fs` (hopefully) fully aware of per worktree refs by @csware in + https://github.com/libgit2/libgit2/pull/6387 +* fix log example by @albfan in https://github.com/libgit2/libgit2/pull/6359 +* fetch: fail on depth for local transport by @ethomson in + https://github.com/libgit2/libgit2/pull/6757 +* Fix message trailer parsing by @ethomson in + https://github.com/libgit2/libgit2/pull/6761 +* config: correct fetching the `HIGHEST_LEVEL` config by @ethomson in + https://github.com/libgit2/libgit2/pull/6766 +* Avoid some API breaking changes in v1.8 by @ethomson in + https://github.com/libgit2/libgit2/pull/6768 + +### Build and CI improvements + +* meta: update version numbers to v1.8 by @ethomson in + https://github.com/libgit2/libgit2/pull/6596 +* Revert "CMake: Search for ssh2 instead of libssh2." by @ethomson in + https://github.com/libgit2/libgit2/pull/6619 +* cmake: fix openssl build on win32 by @lazka in + https://github.com/libgit2/libgit2/pull/6626 +* ci: retry flaky online tests by @ethomson in + https://github.com/libgit2/libgit2/pull/6628 +* ci: update to macOS 12 by @ethomson in + https://github.com/libgit2/libgit2/pull/6629 +* Use `#!/bin/bash` for script with bash-specific commands by @roehling in + https://github.com/libgit2/libgit2/pull/6581 +* ci: overwrite nonsense in `/usr/local` during macOS setup by @ethomson in + https://github.com/libgit2/libgit2/pull/6664 +* release: add a compatibility label by @ethomson in + https://github.com/libgit2/libgit2/pull/6676 +* actions: set permissions by @ethomson in + https://github.com/libgit2/libgit2/pull/6680 +* cmake: rename FindIconv to avoid collision with cmake by @ethomson in + https://github.com/libgit2/libgit2/pull/6682 +* ci: allow workflows to read and write packages by @ethomson in + https://github.com/libgit2/libgit2/pull/6687 +* ci: allow workflows to push changes by @ethomson in + https://github.com/libgit2/libgit2/pull/6688 +* tests: remove test for strcasecmp by @boretrk in + https://github.com/libgit2/libgit2/pull/6691 +* CI fixes by @ethomson in + https://github.com/libgit2/libgit2/pull/6694 +* ci: improvements to prepare for Cygwin support by @ethomson in + https://github.com/libgit2/libgit2/pull/6696 +* Yet more CI improvements by @ethomson in + https://github.com/libgit2/libgit2/pull/6697 +* Fix nightly builds by @ethomson in + https://github.com/libgit2/libgit2/pull/6709 +* Benchmarks: add a site to view results by @ethomson in + https://github.com/libgit2/libgit2/pull/6715 +* `GIT_RAND_GETENTROPY`: do not include `sys/random.h` by @semarie in + https://github.com/libgit2/libgit2/pull/6736 +* add dl to `LIBGIT2_SYSTEM_LIBS` by @christopherfujino in + https://github.com/libgit2/libgit2/pull/6631 +* meta: add dependency tag to release.yml by @ethomson in + https://github.com/libgit2/libgit2/pull/6740 +* CI: fix our nightlies by @ethomson in + https://github.com/libgit2/libgit2/pull/6751 +* trace: Re-enable tests as tracing is now enabled by default by @lrm29 in + https://github.com/libgit2/libgit2/pull/6752 +* tests: don't free an unininitialized repo by @ethomson in + https://github.com/libgit2/libgit2/pull/6763 +* ci: reduce ASLR randomization for TSAN by @ethomson in + https://github.com/libgit2/libgit2/pull/6764 +* packbuilder: adjust nondeterministic tests by @ethomson in + https://github.com/libgit2/libgit2/pull/6762 +* Allow libgit2 to be compiled with mbedtls3. by @adamharrison in + https://github.com/libgit2/libgit2/pull/6759 +* build: update to latest actions versions by @ethomson in + https://github.com/libgit2/libgit2/pull/6765 +* ctype: cast characters to unsigned when classifying characters by + @boretrk in https://github.com/libgit2/libgit2/pull/6679 and + @ethomson in https://github.com/libgit2/libgit2/pull/6770 +* valgrind: suppress OpenSSL warnings by @ethomson in https://github.com/libgit2/libgit2/pull/6769 + +### Documentation improvements + +* README.md: Fix link to conan packages by @lrm29 in + https://github.com/libgit2/libgit2/pull/6621 +* README: replace gmaster with GitButler by @ethomson in + https://github.com/libgit2/libgit2/pull/6692 +* blame example: Fix support for line range in CLI by @wetneb in + https://github.com/libgit2/libgit2/pull/6638 +* Support authentication in push example by @pluehne in + https://github.com/libgit2/libgit2/pull/5904 +* docs: fix mistake in attr.h by @DavHau in + https://github.com/libgit2/libgit2/pull/6714 +* Fix broken links by @csware in + https://github.com/libgit2/libgit2/pull/6747 + +### Platform compatibility fixes + +* stransport: macOS: replace `errSSLNetworkTimeout`, with hard-coded + value by @mascguy in https://github.com/libgit2/libgit2/pull/6610 + +### Git compatibility fixes + +* Do not trim dots from usernames by @georgthegreat in + https://github.com/libgit2/libgit2/pull/6657 +* merge: fix incorrect rename detection for empty files by @herrerog in + https://github.com/libgit2/libgit2/pull/6717 + +### Dependency updates + +* zlib: upgrade bundled zlib to v1.3 by @ethomson in + https://github.com/libgit2/libgit2/pull/6698 +* ntlmclient: update to latest upstream ntlmclient by @ethomson in + https://github.com/libgit2/libgit2/pull/6704 + +## New Contributors + +* @dvzrv made their first contribution in + https://github.com/libgit2/libgit2/pull/6608 +* @mascguy made their first contribution in + https://github.com/libgit2/libgit2/pull/6610 +* @steven9724 made their first contribution in + https://github.com/libgit2/libgit2/pull/6599 +* @lazka made their first contribution in + https://github.com/libgit2/libgit2/pull/6626 +* @roehling made their first contribution in + https://github.com/libgit2/libgit2/pull/6581 +* @7Ji made their first contribution in + https://github.com/libgit2/libgit2/pull/6651 +* @kempniu made their first contribution in + https://github.com/libgit2/libgit2/pull/6662 +* @thosey made their first contribution in + https://github.com/libgit2/libgit2/pull/6572 +* @wetneb made their first contribution in + https://github.com/libgit2/libgit2/pull/6638 +* @yori made their first contribution in + https://github.com/libgit2/libgit2/pull/6642 +* @pluehne made their first contribution in + https://github.com/libgit2/libgit2/pull/5904 +* @DavHau made their first contribution in + https://github.com/libgit2/libgit2/pull/6714 +* @vafada made their first contribution in + https://github.com/libgit2/libgit2/pull/6721 +* @semarie made their first contribution in + https://github.com/libgit2/libgit2/pull/6736 +* @christopherfujino made their first contribution in + https://github.com/libgit2/libgit2/pull/6631 +* @parnic made their first contribution in + https://github.com/libgit2/libgit2/pull/6738 +* @samueltardieu made their first contribution in + https://github.com/libgit2/libgit2/pull/6723 +* @xphoniex made their first contribution in + https://github.com/libgit2/libgit2/pull/6240 +* @adamharrison made their first contribution in + https://github.com/libgit2/libgit2/pull/6759 + +**Full Changelog**: https://github.com/libgit2/libgit2/compare/v1.7.0...v1.8.0 + v1.7 ---- From 9b29a5d30d1ea993498b9f9c91855ed0d56eea6a Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Wed, 20 Mar 2024 09:25:14 +0000 Subject: [PATCH 568/608] ci: update nightly workflows Update the nightly and benchmark workflows to only run steps in libgit2/libgit2 by default. Also update the benchmark workflow to use the latest download-artifact version. --- .github/workflows/benchmark.yml | 4 ++-- .github/workflows/nightly.yml | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/benchmark.yml b/.github/workflows/benchmark.yml index 51a5fc1c083..6ee492ac443 100644 --- a/.github/workflows/benchmark.yml +++ b/.github/workflows/benchmark.yml @@ -89,7 +89,7 @@ jobs: publish: name: Publish results needs: [ build ] - if: always() + if: ${{ always() && github.repository == 'libgit2/libgit2' }} runs-on: ubuntu-latest steps: - name: Check out benchmark repository @@ -100,7 +100,7 @@ jobs: fetch-depth: 0 ssh-key: ${{ secrets.BENCHMARKS_PUBLISH_KEY }} - name: Download test results - uses: actions/download-artifact@v3 + uses: actions/download-artifact@v4 - name: Publish API run: | # Move today's benchmark run into the right place diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml index 570b9aa6ab6..33155c9e447 100644 --- a/.github/workflows/nightly.yml +++ b/.github/workflows/nightly.yml @@ -401,7 +401,7 @@ jobs: test_results: name: Test results needs: [ build ] - if: always() + if: ${{ always() && github.repository == 'libgit2/libgit2' }} runs-on: ubuntu-latest steps: - name: Download test results From 34073bf2e53eedc83f301ded79361ec0e506ca20 Mon Sep 17 00:00:00 2001 From: Florian Pircher Date: Sun, 24 Mar 2024 23:11:41 +0100 Subject: [PATCH 569/608] commit: Fix git_commit_create_from_stage without author and committer --- src/libgit2/commit.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/libgit2/commit.c b/src/libgit2/commit.c index 5582a65aadf..47f6fed892f 100644 --- a/src/libgit2/commit.c +++ b/src/libgit2/commit.c @@ -1107,8 +1107,10 @@ int git_commit_create_from_stage( if (given_opts) memcpy(&opts, given_opts, sizeof(git_commit_create_options)); - if ((author = opts.author) == NULL || - (committer = opts.committer) == NULL) { + author = opts.author; + committer = opts.committer; + + if (!author || !committer) { if (git_signature_default(&default_signature, repo) < 0) goto done; From dd79fbb5abee81fc232e92cc4bbd1b11647ec092 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Tue, 26 Mar 2024 20:56:07 +0000 Subject: [PATCH 570/608] ci: give all nightly builds a unique id The new upload-artifact action fails on conflicting names; ensure that we give each artifact a unique name (keyed off the id). --- .github/workflows/nightly.yml | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml index 33155c9e447..1888e5e174e 100644 --- a/.github/workflows/nightly.yml +++ b/.github/workflows/nightly.yml @@ -215,6 +215,7 @@ jobs: ARCH: x86 - name: "Linux (Bionic, GCC, dynamically-loaded OpenSSL)" + id: bionic-gcc-dynamicopenssl container: name: bionic dockerfile: bionic @@ -226,6 +227,7 @@ jobs: SKIP_PUSHOPTIONS_TESTS: true os: ubuntu-latest - name: "Linux (x86, Bionic, Clang, OpenSSL)" + id: bionic-x86-clang-openssl container: name: bionic-x86 dockerfile: bionic @@ -238,6 +240,7 @@ jobs: SKIP_PUSHOPTIONS_TESTS: true os: ubuntu-latest - name: "Linux (x86, Bionic, GCC, OpenSSL)" + id: bionic-x86-gcc-openssl container: name: bionic-x86 dockerfile: bionic @@ -249,6 +252,7 @@ jobs: SKIP_PUSHOPTIONS_TESTS: true os: ubuntu-latest - name: "Linux (arm32, Bionic, GCC, OpenSSL)" + id: bionic-arm32-gcc-openssl container: name: bionic-arm32 dockerfile: bionic @@ -263,6 +267,7 @@ jobs: GITTEST_FLAKY_STAT: true os: ubuntu-latest - name: "Linux (arm64, Bionic, GCC, OpenSSL)" + id: bionic-arm64-gcc-openssl container: name: bionic-arm64 dockerfile: bionic @@ -300,6 +305,7 @@ jobs: SKIP_SSH_TESTS: true SKIP_NEGOTIATE_TESTS: true - name: "Windows (no mmap)" + id: windows-nommap os: windows-2019 env: ARCH: amd64 From 4d19e8c9c5113fc68dde130af3f6e66c2bd00f65 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Wed, 27 Mar 2024 09:59:48 +0000 Subject: [PATCH 571/608] settings: pull settings out into its own file --- src/libgit2/libgit2.c | 392 +------------------------------ src/libgit2/libgit2.h | 15 -- src/libgit2/settings.c | 408 +++++++++++++++++++++++++++++++++ src/libgit2/settings.h | 7 +- src/libgit2/streams/openssl.c | 4 +- src/libgit2/transports/http.h | 2 +- tests/libgit2/core/useragent.c | 4 +- 7 files changed, 422 insertions(+), 410 deletions(-) delete mode 100644 src/libgit2/libgit2.h create mode 100644 src/libgit2/settings.c diff --git a/src/libgit2/libgit2.c b/src/libgit2/libgit2.c index 777dcbbb558..1b6f1a1f846 100644 --- a/src/libgit2/libgit2.c +++ b/src/libgit2/libgit2.c @@ -5,25 +5,19 @@ * a Linking Exception. For full terms see the included COPYING file. */ -#include "libgit2.h" - #include #include "alloc.h" #include "buf.h" -#include "cache.h" #include "common.h" #include "filter.h" -#include "grafts.h" #include "hash.h" -#include "index.h" #include "merge_driver.h" #include "pool.h" #include "mwindow.h" -#include "object.h" -#include "odb.h" +#include "oid.h" #include "rand.h" -#include "refs.h" #include "runtime.h" +#include "settings.h" #include "sysdir.h" #include "thread.h" #include "git2/global.h" @@ -31,40 +25,12 @@ #include "streams/mbedtls.h" #include "streams/openssl.h" #include "streams/socket.h" -#include "transports/smart.h" -#include "transports/http.h" #include "transports/ssh_libssh2.h" #ifdef GIT_WIN32 # include "win32/w32_leakcheck.h" #endif -/* Declarations for tuneable settings */ -extern size_t git_mwindow__window_size; -extern size_t git_mwindow__mapped_limit; -extern size_t git_mwindow__file_limit; -extern size_t git_indexer__max_objects; -extern bool git_disable_pack_keep_file_checks; -extern int git_odb__packed_priority; -extern int git_odb__loose_priority; -extern int git_socket_stream__connect_timeout; -extern int git_socket_stream__timeout; - -char *git__user_agent; -char *git__ssl_ciphers; - -static void libgit2_settings_global_shutdown(void) -{ - git__free(git__user_agent); - git__free(git__ssl_ciphers); - git_repository__free_extensions(); -} - -static int git_libgit2_settings_global_init(void) -{ - return git_runtime_shutdown_register(libgit2_settings_global_shutdown); -} - int git_libgit2_init(void) { static git_runtime_init_fn init_fns[] = { @@ -87,17 +53,12 @@ int git_libgit2_init(void) git_mbedtls_stream_global_init, git_mwindow_global_init, git_pool_global_init, - git_libgit2_settings_global_init + git_settings_global_init }; return git_runtime_init(init_fns, ARRAY_SIZE(init_fns)); } -int git_libgit2_init_count(void) -{ - return git_runtime_init_count(); -} - int git_libgit2_shutdown(void) { return git_runtime_shutdown(); @@ -134,350 +95,3 @@ int git_libgit2_features(void) #endif ; } - -static int config_level_to_sysdir(int *out, int config_level) -{ - switch (config_level) { - case GIT_CONFIG_LEVEL_SYSTEM: - *out = GIT_SYSDIR_SYSTEM; - return 0; - case GIT_CONFIG_LEVEL_XDG: - *out = GIT_SYSDIR_XDG; - return 0; - case GIT_CONFIG_LEVEL_GLOBAL: - *out = GIT_SYSDIR_GLOBAL; - return 0; - case GIT_CONFIG_LEVEL_PROGRAMDATA: - *out = GIT_SYSDIR_PROGRAMDATA; - return 0; - default: - break; - } - - git_error_set( - GIT_ERROR_INVALID, "invalid config path selector %d", config_level); - return -1; -} - -const char *git_libgit2__user_agent(void) -{ - return git__user_agent; -} - -const char *git_libgit2__ssl_ciphers(void) -{ - return git__ssl_ciphers; -} - -int git_libgit2_opts(int key, ...) -{ - int error = 0; - va_list ap; - - va_start(ap, key); - - switch (key) { - case GIT_OPT_SET_MWINDOW_SIZE: - git_mwindow__window_size = va_arg(ap, size_t); - break; - - case GIT_OPT_GET_MWINDOW_SIZE: - *(va_arg(ap, size_t *)) = git_mwindow__window_size; - break; - - case GIT_OPT_SET_MWINDOW_MAPPED_LIMIT: - git_mwindow__mapped_limit = va_arg(ap, size_t); - break; - - case GIT_OPT_GET_MWINDOW_MAPPED_LIMIT: - *(va_arg(ap, size_t *)) = git_mwindow__mapped_limit; - break; - - case GIT_OPT_SET_MWINDOW_FILE_LIMIT: - git_mwindow__file_limit = va_arg(ap, size_t); - break; - - case GIT_OPT_GET_MWINDOW_FILE_LIMIT: - *(va_arg(ap, size_t *)) = git_mwindow__file_limit; - break; - - case GIT_OPT_GET_SEARCH_PATH: - { - int sysdir = va_arg(ap, int); - git_buf *out = va_arg(ap, git_buf *); - git_str str = GIT_STR_INIT; - const git_str *tmp; - int level; - - if ((error = git_buf_tostr(&str, out)) < 0 || - (error = config_level_to_sysdir(&level, sysdir)) < 0 || - (error = git_sysdir_get(&tmp, level)) < 0 || - (error = git_str_put(&str, tmp->ptr, tmp->size)) < 0) - break; - - error = git_buf_fromstr(out, &str); - } - break; - - case GIT_OPT_SET_SEARCH_PATH: - { - int level; - - if ((error = config_level_to_sysdir(&level, va_arg(ap, int))) >= 0) - error = git_sysdir_set(level, va_arg(ap, const char *)); - } - break; - - case GIT_OPT_SET_CACHE_OBJECT_LIMIT: - { - git_object_t type = (git_object_t)va_arg(ap, int); - size_t size = va_arg(ap, size_t); - error = git_cache_set_max_object_size(type, size); - break; - } - - case GIT_OPT_SET_CACHE_MAX_SIZE: - git_cache__max_storage = va_arg(ap, ssize_t); - break; - - case GIT_OPT_ENABLE_CACHING: - git_cache__enabled = (va_arg(ap, int) != 0); - break; - - case GIT_OPT_GET_CACHED_MEMORY: - *(va_arg(ap, ssize_t *)) = git_cache__current_storage.val; - *(va_arg(ap, ssize_t *)) = git_cache__max_storage; - break; - - case GIT_OPT_GET_TEMPLATE_PATH: - { - git_buf *out = va_arg(ap, git_buf *); - git_str str = GIT_STR_INIT; - const git_str *tmp; - - if ((error = git_buf_tostr(&str, out)) < 0 || - (error = git_sysdir_get(&tmp, GIT_SYSDIR_TEMPLATE)) < 0 || - (error = git_str_put(&str, tmp->ptr, tmp->size)) < 0) - break; - - error = git_buf_fromstr(out, &str); - } - break; - - case GIT_OPT_SET_TEMPLATE_PATH: - error = git_sysdir_set(GIT_SYSDIR_TEMPLATE, va_arg(ap, const char *)); - break; - - case GIT_OPT_SET_SSL_CERT_LOCATIONS: -#ifdef GIT_OPENSSL - { - const char *file = va_arg(ap, const char *); - const char *path = va_arg(ap, const char *); - error = git_openssl__set_cert_location(file, path); - } -#elif defined(GIT_MBEDTLS) - { - const char *file = va_arg(ap, const char *); - const char *path = va_arg(ap, const char *); - error = git_mbedtls__set_cert_location(file, path); - } -#else - git_error_set(GIT_ERROR_SSL, "TLS backend doesn't support certificate locations"); - error = -1; -#endif - break; - case GIT_OPT_SET_USER_AGENT: - git__free(git__user_agent); - git__user_agent = git__strdup(va_arg(ap, const char *)); - if (!git__user_agent) { - git_error_set_oom(); - error = -1; - } - - break; - - case GIT_OPT_ENABLE_STRICT_OBJECT_CREATION: - git_object__strict_input_validation = (va_arg(ap, int) != 0); - break; - - case GIT_OPT_ENABLE_STRICT_SYMBOLIC_REF_CREATION: - git_reference__enable_symbolic_ref_target_validation = (va_arg(ap, int) != 0); - break; - - case GIT_OPT_SET_SSL_CIPHERS: -#if (GIT_OPENSSL || GIT_MBEDTLS) - { - git__free(git__ssl_ciphers); - git__ssl_ciphers = git__strdup(va_arg(ap, const char *)); - if (!git__ssl_ciphers) { - git_error_set_oom(); - error = -1; - } - } -#else - git_error_set(GIT_ERROR_SSL, "TLS backend doesn't support custom ciphers"); - error = -1; -#endif - break; - - case GIT_OPT_GET_USER_AGENT: - { - git_buf *out = va_arg(ap, git_buf *); - git_str str = GIT_STR_INIT; - - if ((error = git_buf_tostr(&str, out)) < 0 || - (error = git_str_puts(&str, git__user_agent)) < 0) - break; - - error = git_buf_fromstr(out, &str); - } - break; - - case GIT_OPT_ENABLE_OFS_DELTA: - git_smart__ofs_delta_enabled = (va_arg(ap, int) != 0); - break; - - case GIT_OPT_ENABLE_FSYNC_GITDIR: - git_repository__fsync_gitdir = (va_arg(ap, int) != 0); - break; - - case GIT_OPT_GET_WINDOWS_SHAREMODE: -#ifdef GIT_WIN32 - *(va_arg(ap, unsigned long *)) = git_win32__createfile_sharemode; -#endif - break; - - case GIT_OPT_SET_WINDOWS_SHAREMODE: -#ifdef GIT_WIN32 - git_win32__createfile_sharemode = va_arg(ap, unsigned long); -#endif - break; - - case GIT_OPT_ENABLE_STRICT_HASH_VERIFICATION: - git_odb__strict_hash_verification = (va_arg(ap, int) != 0); - break; - - case GIT_OPT_SET_ALLOCATOR: - error = git_allocator_setup(va_arg(ap, git_allocator *)); - break; - - case GIT_OPT_ENABLE_UNSAVED_INDEX_SAFETY: - git_index__enforce_unsaved_safety = (va_arg(ap, int) != 0); - break; - - case GIT_OPT_SET_PACK_MAX_OBJECTS: - git_indexer__max_objects = va_arg(ap, size_t); - break; - - case GIT_OPT_GET_PACK_MAX_OBJECTS: - *(va_arg(ap, size_t *)) = git_indexer__max_objects; - break; - - case GIT_OPT_DISABLE_PACK_KEEP_FILE_CHECKS: - git_disable_pack_keep_file_checks = (va_arg(ap, int) != 0); - break; - - case GIT_OPT_ENABLE_HTTP_EXPECT_CONTINUE: - git_http__expect_continue = (va_arg(ap, int) != 0); - break; - - case GIT_OPT_SET_ODB_PACKED_PRIORITY: - git_odb__packed_priority = va_arg(ap, int); - break; - - case GIT_OPT_SET_ODB_LOOSE_PRIORITY: - git_odb__loose_priority = va_arg(ap, int); - break; - - case GIT_OPT_SET_EXTENSIONS: - { - const char **extensions = va_arg(ap, const char **); - size_t len = va_arg(ap, size_t); - error = git_repository__set_extensions(extensions, len); - } - break; - - case GIT_OPT_GET_EXTENSIONS: - { - git_strarray *out = va_arg(ap, git_strarray *); - char **extensions; - size_t len; - - if ((error = git_repository__extensions(&extensions, &len)) < 0) - break; - - out->strings = extensions; - out->count = len; - } - break; - - case GIT_OPT_GET_OWNER_VALIDATION: - *(va_arg(ap, int *)) = git_repository__validate_ownership; - break; - - case GIT_OPT_SET_OWNER_VALIDATION: - git_repository__validate_ownership = (va_arg(ap, int) != 0); - break; - - case GIT_OPT_GET_HOMEDIR: - { - git_buf *out = va_arg(ap, git_buf *); - git_str str = GIT_STR_INIT; - const git_str *tmp; - - if ((error = git_buf_tostr(&str, out)) < 0 || - (error = git_sysdir_get(&tmp, GIT_SYSDIR_HOME)) < 0 || - (error = git_str_put(&str, tmp->ptr, tmp->size)) < 0) - break; - - error = git_buf_fromstr(out, &str); - } - break; - - case GIT_OPT_SET_HOMEDIR: - error = git_sysdir_set(GIT_SYSDIR_HOME, va_arg(ap, const char *)); - break; - - case GIT_OPT_GET_SERVER_CONNECT_TIMEOUT: - *(va_arg(ap, int *)) = git_socket_stream__connect_timeout; - break; - - case GIT_OPT_SET_SERVER_CONNECT_TIMEOUT: - { - int timeout = va_arg(ap, int); - - if (timeout < 0) { - git_error_set(GIT_ERROR_INVALID, "invalid connect timeout"); - error = -1; - } else { - git_socket_stream__connect_timeout = timeout; - } - } - break; - - case GIT_OPT_GET_SERVER_TIMEOUT: - *(va_arg(ap, int *)) = git_socket_stream__timeout; - break; - - case GIT_OPT_SET_SERVER_TIMEOUT: - { - int timeout = va_arg(ap, int); - - if (timeout < 0) { - git_error_set(GIT_ERROR_INVALID, "invalid timeout"); - error = -1; - } else { - git_socket_stream__timeout = timeout; - } - } - break; - - default: - git_error_set(GIT_ERROR_INVALID, "invalid option key"); - error = -1; - } - - va_end(ap); - - return error; -} diff --git a/src/libgit2/libgit2.h b/src/libgit2/libgit2.h deleted file mode 100644 index a898367ae37..00000000000 --- a/src/libgit2/libgit2.h +++ /dev/null @@ -1,15 +0,0 @@ -/* - * Copyright (C) the libgit2 contributors. All rights reserved. - * - * This file is part of libgit2, distributed under the GNU GPL v2 with - * a Linking Exception. For full terms see the included COPYING file. - */ -#ifndef INCLUDE_libgit2_h__ -#define INCLUDE_libgit2_h__ - -extern int git_libgit2_init_count(void); - -extern const char *git_libgit2__user_agent(void); -extern const char *git_libgit2__ssl_ciphers(void); - -#endif diff --git a/src/libgit2/settings.c b/src/libgit2/settings.c new file mode 100644 index 00000000000..96a910d70cd --- /dev/null +++ b/src/libgit2/settings.c @@ -0,0 +1,408 @@ +/* + * Copyright (C) the libgit2 contributors. All rights reserved. + * + * This file is part of libgit2, distributed under the GNU GPL v2 with + * a Linking Exception. For full terms see the included COPYING file. + */ + +#include "settings.h" + +#include +#include "alloc.h" +#include "buf.h" +#include "cache.h" +#include "common.h" +#include "filter.h" +#include "grafts.h" +#include "hash.h" +#include "index.h" +#include "merge_driver.h" +#include "pool.h" +#include "mwindow.h" +#include "object.h" +#include "odb.h" +#include "rand.h" +#include "refs.h" +#include "runtime.h" +#include "sysdir.h" +#include "thread.h" +#include "git2/global.h" +#include "streams/registry.h" +#include "streams/mbedtls.h" +#include "streams/openssl.h" +#include "streams/socket.h" +#include "transports/smart.h" +#include "transports/http.h" +#include "transports/ssh_libssh2.h" + +#ifdef GIT_WIN32 +# include "win32/w32_leakcheck.h" +#endif + +/* Declarations for tuneable settings */ +extern size_t git_mwindow__window_size; +extern size_t git_mwindow__mapped_limit; +extern size_t git_mwindow__file_limit; +extern size_t git_indexer__max_objects; +extern bool git_disable_pack_keep_file_checks; +extern int git_odb__packed_priority; +extern int git_odb__loose_priority; +extern int git_socket_stream__connect_timeout; +extern int git_socket_stream__timeout; + +char *git__user_agent; +char *git__ssl_ciphers; + +static void settings_global_shutdown(void) +{ + git__free(git__user_agent); + git__free(git__ssl_ciphers); + git_repository__free_extensions(); +} + +int git_settings_global_init(void) +{ + return git_runtime_shutdown_register(settings_global_shutdown); +} + +static int config_level_to_sysdir(int *out, int config_level) +{ + switch (config_level) { + case GIT_CONFIG_LEVEL_SYSTEM: + *out = GIT_SYSDIR_SYSTEM; + return 0; + case GIT_CONFIG_LEVEL_XDG: + *out = GIT_SYSDIR_XDG; + return 0; + case GIT_CONFIG_LEVEL_GLOBAL: + *out = GIT_SYSDIR_GLOBAL; + return 0; + case GIT_CONFIG_LEVEL_PROGRAMDATA: + *out = GIT_SYSDIR_PROGRAMDATA; + return 0; + default: + break; + } + + git_error_set( + GIT_ERROR_INVALID, "invalid config path selector %d", config_level); + return -1; +} + +const char *git_settings__user_agent(void) +{ + return git__user_agent; +} + +int git_libgit2_opts(int key, ...) +{ + int error = 0; + va_list ap; + + va_start(ap, key); + + switch (key) { + case GIT_OPT_SET_MWINDOW_SIZE: + git_mwindow__window_size = va_arg(ap, size_t); + break; + + case GIT_OPT_GET_MWINDOW_SIZE: + *(va_arg(ap, size_t *)) = git_mwindow__window_size; + break; + + case GIT_OPT_SET_MWINDOW_MAPPED_LIMIT: + git_mwindow__mapped_limit = va_arg(ap, size_t); + break; + + case GIT_OPT_GET_MWINDOW_MAPPED_LIMIT: + *(va_arg(ap, size_t *)) = git_mwindow__mapped_limit; + break; + + case GIT_OPT_SET_MWINDOW_FILE_LIMIT: + git_mwindow__file_limit = va_arg(ap, size_t); + break; + + case GIT_OPT_GET_MWINDOW_FILE_LIMIT: + *(va_arg(ap, size_t *)) = git_mwindow__file_limit; + break; + + case GIT_OPT_GET_SEARCH_PATH: + { + int sysdir = va_arg(ap, int); + git_buf *out = va_arg(ap, git_buf *); + git_str str = GIT_STR_INIT; + const git_str *tmp; + int level; + + if ((error = git_buf_tostr(&str, out)) < 0 || + (error = config_level_to_sysdir(&level, sysdir)) < 0 || + (error = git_sysdir_get(&tmp, level)) < 0 || + (error = git_str_put(&str, tmp->ptr, tmp->size)) < 0) + break; + + error = git_buf_fromstr(out, &str); + } + break; + + case GIT_OPT_SET_SEARCH_PATH: + { + int level; + + if ((error = config_level_to_sysdir(&level, va_arg(ap, int))) >= 0) + error = git_sysdir_set(level, va_arg(ap, const char *)); + } + break; + + case GIT_OPT_SET_CACHE_OBJECT_LIMIT: + { + git_object_t type = (git_object_t)va_arg(ap, int); + size_t size = va_arg(ap, size_t); + error = git_cache_set_max_object_size(type, size); + break; + } + + case GIT_OPT_SET_CACHE_MAX_SIZE: + git_cache__max_storage = va_arg(ap, ssize_t); + break; + + case GIT_OPT_ENABLE_CACHING: + git_cache__enabled = (va_arg(ap, int) != 0); + break; + + case GIT_OPT_GET_CACHED_MEMORY: + *(va_arg(ap, ssize_t *)) = git_cache__current_storage.val; + *(va_arg(ap, ssize_t *)) = git_cache__max_storage; + break; + + case GIT_OPT_GET_TEMPLATE_PATH: + { + git_buf *out = va_arg(ap, git_buf *); + git_str str = GIT_STR_INIT; + const git_str *tmp; + + if ((error = git_buf_tostr(&str, out)) < 0 || + (error = git_sysdir_get(&tmp, GIT_SYSDIR_TEMPLATE)) < 0 || + (error = git_str_put(&str, tmp->ptr, tmp->size)) < 0) + break; + + error = git_buf_fromstr(out, &str); + } + break; + + case GIT_OPT_SET_TEMPLATE_PATH: + error = git_sysdir_set(GIT_SYSDIR_TEMPLATE, va_arg(ap, const char *)); + break; + + case GIT_OPT_SET_SSL_CERT_LOCATIONS: +#ifdef GIT_OPENSSL + { + const char *file = va_arg(ap, const char *); + const char *path = va_arg(ap, const char *); + error = git_openssl__set_cert_location(file, path); + } +#elif defined(GIT_MBEDTLS) + { + const char *file = va_arg(ap, const char *); + const char *path = va_arg(ap, const char *); + error = git_mbedtls__set_cert_location(file, path); + } +#else + git_error_set(GIT_ERROR_SSL, "TLS backend doesn't support certificate locations"); + error = -1; +#endif + break; + case GIT_OPT_SET_USER_AGENT: + git__free(git__user_agent); + git__user_agent = git__strdup(va_arg(ap, const char *)); + if (!git__user_agent) { + git_error_set_oom(); + error = -1; + } + + break; + + case GIT_OPT_ENABLE_STRICT_OBJECT_CREATION: + git_object__strict_input_validation = (va_arg(ap, int) != 0); + break; + + case GIT_OPT_ENABLE_STRICT_SYMBOLIC_REF_CREATION: + git_reference__enable_symbolic_ref_target_validation = (va_arg(ap, int) != 0); + break; + + case GIT_OPT_SET_SSL_CIPHERS: +#if (GIT_OPENSSL || GIT_MBEDTLS) + { + git__free(git__ssl_ciphers); + git__ssl_ciphers = git__strdup(va_arg(ap, const char *)); + if (!git__ssl_ciphers) { + git_error_set_oom(); + error = -1; + } + } +#else + git_error_set(GIT_ERROR_SSL, "TLS backend doesn't support custom ciphers"); + error = -1; +#endif + break; + + case GIT_OPT_GET_USER_AGENT: + { + git_buf *out = va_arg(ap, git_buf *); + git_str str = GIT_STR_INIT; + + if ((error = git_buf_tostr(&str, out)) < 0 || + (error = git_str_puts(&str, git__user_agent)) < 0) + break; + + error = git_buf_fromstr(out, &str); + } + break; + + case GIT_OPT_ENABLE_OFS_DELTA: + git_smart__ofs_delta_enabled = (va_arg(ap, int) != 0); + break; + + case GIT_OPT_ENABLE_FSYNC_GITDIR: + git_repository__fsync_gitdir = (va_arg(ap, int) != 0); + break; + + case GIT_OPT_GET_WINDOWS_SHAREMODE: +#ifdef GIT_WIN32 + *(va_arg(ap, unsigned long *)) = git_win32__createfile_sharemode; +#endif + break; + + case GIT_OPT_SET_WINDOWS_SHAREMODE: +#ifdef GIT_WIN32 + git_win32__createfile_sharemode = va_arg(ap, unsigned long); +#endif + break; + + case GIT_OPT_ENABLE_STRICT_HASH_VERIFICATION: + git_odb__strict_hash_verification = (va_arg(ap, int) != 0); + break; + + case GIT_OPT_SET_ALLOCATOR: + error = git_allocator_setup(va_arg(ap, git_allocator *)); + break; + + case GIT_OPT_ENABLE_UNSAVED_INDEX_SAFETY: + git_index__enforce_unsaved_safety = (va_arg(ap, int) != 0); + break; + + case GIT_OPT_SET_PACK_MAX_OBJECTS: + git_indexer__max_objects = va_arg(ap, size_t); + break; + + case GIT_OPT_GET_PACK_MAX_OBJECTS: + *(va_arg(ap, size_t *)) = git_indexer__max_objects; + break; + + case GIT_OPT_DISABLE_PACK_KEEP_FILE_CHECKS: + git_disable_pack_keep_file_checks = (va_arg(ap, int) != 0); + break; + + case GIT_OPT_ENABLE_HTTP_EXPECT_CONTINUE: + git_http__expect_continue = (va_arg(ap, int) != 0); + break; + + case GIT_OPT_SET_ODB_PACKED_PRIORITY: + git_odb__packed_priority = va_arg(ap, int); + break; + + case GIT_OPT_SET_ODB_LOOSE_PRIORITY: + git_odb__loose_priority = va_arg(ap, int); + break; + + case GIT_OPT_SET_EXTENSIONS: + { + const char **extensions = va_arg(ap, const char **); + size_t len = va_arg(ap, size_t); + error = git_repository__set_extensions(extensions, len); + } + break; + + case GIT_OPT_GET_EXTENSIONS: + { + git_strarray *out = va_arg(ap, git_strarray *); + char **extensions; + size_t len; + + if ((error = git_repository__extensions(&extensions, &len)) < 0) + break; + + out->strings = extensions; + out->count = len; + } + break; + + case GIT_OPT_GET_OWNER_VALIDATION: + *(va_arg(ap, int *)) = git_repository__validate_ownership; + break; + + case GIT_OPT_SET_OWNER_VALIDATION: + git_repository__validate_ownership = (va_arg(ap, int) != 0); + break; + + case GIT_OPT_GET_HOMEDIR: + { + git_buf *out = va_arg(ap, git_buf *); + git_str str = GIT_STR_INIT; + const git_str *tmp; + + if ((error = git_buf_tostr(&str, out)) < 0 || + (error = git_sysdir_get(&tmp, GIT_SYSDIR_HOME)) < 0 || + (error = git_str_put(&str, tmp->ptr, tmp->size)) < 0) + break; + + error = git_buf_fromstr(out, &str); + } + break; + + case GIT_OPT_SET_HOMEDIR: + error = git_sysdir_set(GIT_SYSDIR_HOME, va_arg(ap, const char *)); + break; + + case GIT_OPT_GET_SERVER_CONNECT_TIMEOUT: + *(va_arg(ap, int *)) = git_socket_stream__connect_timeout; + break; + + case GIT_OPT_SET_SERVER_CONNECT_TIMEOUT: + { + int timeout = va_arg(ap, int); + + if (timeout < 0) { + git_error_set(GIT_ERROR_INVALID, "invalid connect timeout"); + error = -1; + } else { + git_socket_stream__connect_timeout = timeout; + } + } + break; + + case GIT_OPT_GET_SERVER_TIMEOUT: + *(va_arg(ap, int *)) = git_socket_stream__timeout; + break; + + case GIT_OPT_SET_SERVER_TIMEOUT: + { + int timeout = va_arg(ap, int); + + if (timeout < 0) { + git_error_set(GIT_ERROR_INVALID, "invalid timeout"); + error = -1; + } else { + git_socket_stream__timeout = timeout; + } + } + break; + + default: + git_error_set(GIT_ERROR_INVALID, "invalid option key"); + error = -1; + } + + va_end(ap); + + return error; +} diff --git a/src/libgit2/settings.h b/src/libgit2/settings.h index dc42ce93952..18ee5280ac7 100644 --- a/src/libgit2/settings.h +++ b/src/libgit2/settings.h @@ -4,8 +4,11 @@ * This file is part of libgit2, distributed under the GNU GPL v2 with * a Linking Exception. For full terms see the included COPYING file. */ +#ifndef INCLUDE_settings_h__ +#define INCLUDE_settings_h__ extern int git_settings_global_init(void); -extern const char *git_libgit2__user_agent(void); -extern const char *git_libgit2__ssl_ciphers(void); +extern const char *git_settings__user_agent(void); + +#endif diff --git a/src/libgit2/streams/openssl.c b/src/libgit2/streams/openssl.c index 9db911e39b3..7cb8f7f927c 100644 --- a/src/libgit2/streams/openssl.c +++ b/src/libgit2/streams/openssl.c @@ -36,6 +36,8 @@ # include #endif +extern char *git__ssl_ciphers; + SSL_CTX *git__ssl_ctx; #define GIT_SSL_DEFAULT_CIPHERS "ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-DSS-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:DHE-DSS-AES256-GCM-SHA384:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA:ECDHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA256:DHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA:DHE-DSS-AES128-SHA256:DHE-DSS-AES256-SHA256:DHE-DSS-AES128-SHA:DHE-DSS-AES256-SHA:AES128-GCM-SHA256:AES256-GCM-SHA384:AES128-SHA256:AES256-SHA256:AES128-SHA:AES256-SHA" @@ -105,7 +107,7 @@ static void git_openssl_free(void *mem) static int openssl_init(void) { long ssl_opts = SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3; - const char *ciphers = git_libgit2__ssl_ciphers(); + const char *ciphers = git__ssl_ciphers; #ifdef VALGRIND static bool allocators_initialized = false; #endif diff --git a/src/libgit2/transports/http.h b/src/libgit2/transports/http.h index 8e8e7226ed2..3d73237dd0f 100644 --- a/src/libgit2/transports/http.h +++ b/src/libgit2/transports/http.h @@ -17,7 +17,7 @@ extern bool git_http__expect_continue; GIT_INLINE(int) git_http__user_agent(git_str *buf) { - const char *ua = git_libgit2__user_agent(); + const char *ua = git_settings__user_agent(); if (!ua) ua = "libgit2 " LIBGIT2_VERSION; diff --git a/tests/libgit2/core/useragent.c b/tests/libgit2/core/useragent.c index a4ece902fd9..697f7440db6 100644 --- a/tests/libgit2/core/useragent.c +++ b/tests/libgit2/core/useragent.c @@ -6,9 +6,9 @@ void test_core_useragent__get(void) const char *custom_name = "super duper git"; git_str buf = GIT_STR_INIT; - cl_assert_equal_p(NULL, git_libgit2__user_agent()); + cl_assert_equal_p(NULL, git_settings__user_agent()); cl_git_pass(git_libgit2_opts(GIT_OPT_SET_USER_AGENT, custom_name)); - cl_assert_equal_s(custom_name, git_libgit2__user_agent()); + cl_assert_equal_s(custom_name, git_settings__user_agent()); cl_git_pass(git_libgit2_opts(GIT_OPT_GET_USER_AGENT, &buf)); cl_assert_equal_s(custom_name, buf.ptr); From 4839f4fbfc3bfd9e19ac140ed9b5654861b97596 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Wed, 27 Mar 2024 11:56:45 +0000 Subject: [PATCH 572/608] http: allow users more control over user-agent Users can now override the "product" portion of the user-agent (via GIT_OPT_SET_USER_AGENT_PRODUCT). This continues to default to "git/2.0", but users may define their own string, or may opt out of sending a user-agent entirely (by passing an empty string). Similarly, users may now also opt-out of sending any additional "comment" information by setting the GIT_OPT_SET_USER_AGENT value to an empty string. --- include/git2/common.h | 41 ++++++++++---- src/libgit2/settings.c | 86 ++++++++++++++++++++++------- src/libgit2/settings.h | 1 + src/libgit2/transports/http.h | 10 ---- src/libgit2/transports/httpclient.c | 32 +++++++++-- src/libgit2/transports/winhttp.c | 34 +++++++++++- tests/libgit2/core/useragent.c | 53 +++++++++++++++--- 7 files changed, 200 insertions(+), 57 deletions(-) diff --git a/include/git2/common.h b/include/git2/common.h index 0f42c34f683..b7cf20b31c9 100644 --- a/include/git2/common.h +++ b/include/git2/common.h @@ -228,7 +228,9 @@ typedef enum { GIT_OPT_SET_SERVER_CONNECT_TIMEOUT, GIT_OPT_GET_SERVER_CONNECT_TIMEOUT, GIT_OPT_SET_SERVER_TIMEOUT, - GIT_OPT_GET_SERVER_TIMEOUT + GIT_OPT_GET_SERVER_TIMEOUT, + GIT_OPT_SET_USER_AGENT_PRODUCT, + GIT_OPT_GET_USER_AGENT_PRODUCT } git_libgit2_opt_t; /** @@ -337,11 +339,35 @@ typedef enum { * * * opts(GIT_OPT_SET_USER_AGENT, const char *user_agent) * - * > Set the value of the User-Agent header. This value will be - * > appended to "git/1.0", for compatibility with other git clients. + * > Set the value of the comment section of the User-Agent header. + * > This can be information about your product and its version. + * > By default this is "libgit2" followed by the libgit2 version. * > - * > - `user_agent` is the value that will be delivered as the - * > User-Agent header on HTTP requests. + * > This value will be appended to User-Agent _product_, which + * > is typically set to "git/2.0". + * > + * > Set to the empty string ("") to not send any information in the + * > comment section, or set to NULL to restore the default. + * + * * opts(GIT_OPT_GET_USER_AGENT, git_buf *out) + * + * > Get the value of the User-Agent header. + * > The User-Agent is written to the `out` buffer. + * + * * opts(GIT_OPT_SET_USER_AGENT_PRODUCT, const char *user_agent_product) + * + * > Set the value of the product portion of the User-Agent header. + * > This defaults to "git/2.0", for compatibility with other git + * > clients. It is recommended to keep this as git/ for + * > compatibility with servers that do user-agent detection. + * > + * > Set to the empty string ("") to not send any user-agent string, + * > or set to NULL to restore the default. + * + * * opts(GIT_OPT_GET_USER_AGENT_PRODUCT, git_buf *out) + * + * > Get the value of the User-Agent product header. + * > The User-Agent product is written to the `out` buffer. * * * opts(GIT_OPT_SET_WINDOWS_SHAREMODE, unsigned long value) * @@ -377,11 +403,6 @@ typedef enum { * > * > - `ciphers` is the list of ciphers that are eanbled. * - * * opts(GIT_OPT_GET_USER_AGENT, git_buf *out) - * - * > Get the value of the User-Agent header. - * > The User-Agent is written to the `out` buffer. - * * * opts(GIT_OPT_ENABLE_OFS_DELTA, int enabled) * * > Enable or disable the use of "offset deltas" when creating packfiles, diff --git a/src/libgit2/settings.c b/src/libgit2/settings.c index 96a910d70cd..4a41830b8fd 100644 --- a/src/libgit2/settings.c +++ b/src/libgit2/settings.c @@ -51,11 +51,14 @@ extern int git_socket_stream__connect_timeout; extern int git_socket_stream__timeout; char *git__user_agent; +char *git__user_agent_product; char *git__ssl_ciphers; static void settings_global_shutdown(void) { git__free(git__user_agent); + git__free(git__user_agent_product); + git__free(git__ssl_ciphers); git_repository__free_extensions(); } @@ -89,9 +92,16 @@ static int config_level_to_sysdir(int *out, int config_level) return -1; } +const char *git_settings__user_agent_product(void) +{ + return git__user_agent_product ? git__user_agent_product : + "git/2.0"; +} + const char *git_settings__user_agent(void) { - return git__user_agent; + return git__user_agent ? git__user_agent : + "libgit2 " LIBGIT2_VERSION; } int git_libgit2_opts(int key, ...) @@ -211,14 +221,65 @@ int git_libgit2_opts(int key, ...) error = -1; #endif break; + case GIT_OPT_SET_USER_AGENT: - git__free(git__user_agent); - git__user_agent = git__strdup(va_arg(ap, const char *)); - if (!git__user_agent) { - git_error_set_oom(); - error = -1; + { + const char *new_agent = va_arg(ap, const char *); + + git__free(git__user_agent); + + if (new_agent) { + git__user_agent= git__strdup(new_agent); + + if (!git__user_agent) + error = -1; + } else { + git__user_agent = NULL; + } + } + break; + + case GIT_OPT_GET_USER_AGENT: + { + git_buf *out = va_arg(ap, git_buf *); + git_str str = GIT_STR_INIT; + + if ((error = git_buf_tostr(&str, out)) < 0 || + (error = git_str_puts(&str, git_settings__user_agent())) < 0) + break; + + error = git_buf_fromstr(out, &str); + } + break; + + case GIT_OPT_SET_USER_AGENT_PRODUCT: + { + const char *new_agent = va_arg(ap, const char *); + + git__free(git__user_agent_product); + + if (new_agent) { + git__user_agent_product = git__strdup(new_agent); + + if (!git__user_agent_product) + error = -1; + } else { + git__user_agent_product = NULL; + } } + break; + + case GIT_OPT_GET_USER_AGENT_PRODUCT: + { + git_buf *out = va_arg(ap, git_buf *); + git_str str = GIT_STR_INIT; + if ((error = git_buf_tostr(&str, out)) < 0 || + (error = git_str_puts(&str, git_settings__user_agent_product())) < 0) + break; + + error = git_buf_fromstr(out, &str); + } break; case GIT_OPT_ENABLE_STRICT_OBJECT_CREATION: @@ -245,19 +306,6 @@ int git_libgit2_opts(int key, ...) #endif break; - case GIT_OPT_GET_USER_AGENT: - { - git_buf *out = va_arg(ap, git_buf *); - git_str str = GIT_STR_INIT; - - if ((error = git_buf_tostr(&str, out)) < 0 || - (error = git_str_puts(&str, git__user_agent)) < 0) - break; - - error = git_buf_fromstr(out, &str); - } - break; - case GIT_OPT_ENABLE_OFS_DELTA: git_smart__ofs_delta_enabled = (va_arg(ap, int) != 0); break; diff --git a/src/libgit2/settings.h b/src/libgit2/settings.h index 18ee5280ac7..292936676aa 100644 --- a/src/libgit2/settings.h +++ b/src/libgit2/settings.h @@ -10,5 +10,6 @@ extern int git_settings_global_init(void); extern const char *git_settings__user_agent(void); +extern const char *git_settings__user_agent_product(void); #endif diff --git a/src/libgit2/transports/http.h b/src/libgit2/transports/http.h index 3d73237dd0f..7410202a820 100644 --- a/src/libgit2/transports/http.h +++ b/src/libgit2/transports/http.h @@ -15,14 +15,4 @@ extern bool git_http__expect_continue; -GIT_INLINE(int) git_http__user_agent(git_str *buf) -{ - const char *ua = git_settings__user_agent(); - - if (!ua) - ua = "libgit2 " LIBGIT2_VERSION; - - return git_str_printf(buf, "git/2.0 (%s)", ua); -} - #endif diff --git a/src/libgit2/transports/httpclient.c b/src/libgit2/transports/httpclient.c index e22a07ba1a0..2c2e36859a7 100644 --- a/src/libgit2/transports/httpclient.c +++ b/src/libgit2/transports/httpclient.c @@ -651,6 +651,30 @@ static int puts_host_and_port(git_str *buf, git_net_url *url, bool force_port) return git_str_oom(buf) ? -1 : 0; } +static int append_user_agent(git_str *buf) +{ + const char *product = git_settings__user_agent_product(); + const char *comment = git_settings__user_agent(); + + GIT_ASSERT(product && comment); + + if (!*product) + return 0; + + git_str_puts(buf, "User-Agent: "); + git_str_puts(buf, product); + + if (*comment) { + git_str_puts(buf, " ("); + git_str_puts(buf, comment); + git_str_puts(buf, ")"); + } + + git_str_puts(buf, "\r\n"); + + return git_str_oom(buf) ? -1 : 0; +} + static int generate_connect_request( git_http_client *client, git_http_request *request) @@ -665,9 +689,7 @@ static int generate_connect_request( puts_host_and_port(buf, &client->server.url, true); git_str_puts(buf, " HTTP/1.1\r\n"); - git_str_puts(buf, "User-Agent: "); - git_http__user_agent(buf); - git_str_puts(buf, "\r\n"); + append_user_agent(buf); git_str_puts(buf, "Host: "); puts_host_and_port(buf, &client->server.url, true); @@ -711,9 +733,7 @@ static int generate_request( git_str_puts(buf, " HTTP/1.1\r\n"); - git_str_puts(buf, "User-Agent: "); - git_http__user_agent(buf); - git_str_puts(buf, "\r\n"); + append_user_agent(buf); git_str_puts(buf, "Host: "); puts_host_and_port(buf, request->url, false); diff --git a/src/libgit2/transports/winhttp.c b/src/libgit2/transports/winhttp.c index 031ff3f70b0..7eca4b7443b 100644 --- a/src/libgit2/transports/winhttp.c +++ b/src/libgit2/transports/winhttp.c @@ -746,6 +746,33 @@ static void CALLBACK winhttp_status( } } +static int user_agent(bool *exists, git_str *out) +{ + const char *product = git_settings__user_agent_product(); + const char *comment = git_settings__user_agent(); + + GIT_ASSERT(product && comment); + + if (!*product) { + *exists = false; + return 0; + } + + git_str_puts(out, product); + + if (*comment) { + git_str_puts(out, " ("); + git_str_puts(out, comment); + git_str_puts(out, ")"); + } + + if (git_str_oom(out)) + return -1; + + *exists = true; + return 0; +} + static int winhttp_connect( winhttp_subtransport *t) { @@ -757,6 +784,7 @@ static int winhttp_connect( int error = -1; int default_timeout = TIMEOUT_INFINITE; int default_connect_timeout = DEFAULT_CONNECT_TIMEOUT; + bool has_ua = true; DWORD protocols = WINHTTP_FLAG_SECURE_PROTOCOL_TLS1 | WINHTTP_FLAG_SECURE_PROTOCOL_TLS1_1 | @@ -787,11 +815,11 @@ static int winhttp_connect( goto on_error; } - - if (git_http__user_agent(&ua) < 0) + if (user_agent(&has_ua, &ua) < 0) goto on_error; - if (git_utf8_to_16_alloc(&wide_ua, git_str_cstr(&ua)) < 0) { + if (has_ua && + git_utf8_to_16_alloc(&wide_ua, git_str_cstr(&ua)) < 0) { git_error_set(GIT_ERROR_OS, "unable to convert host to wide characters"); goto on_error; } diff --git a/tests/libgit2/core/useragent.c b/tests/libgit2/core/useragent.c index 697f7440db6..2e119de4490 100644 --- a/tests/libgit2/core/useragent.c +++ b/tests/libgit2/core/useragent.c @@ -1,17 +1,52 @@ #include "clar_libgit2.h" #include "settings.h" -void test_core_useragent__get(void) +static git_buf default_ua = GIT_BUF_INIT; +static git_buf default_product = GIT_BUF_INIT; + +void test_core_useragent__initialize(void) +{ + cl_git_pass(git_libgit2_opts(GIT_OPT_GET_USER_AGENT, &default_ua)); + cl_git_pass(git_libgit2_opts(GIT_OPT_GET_USER_AGENT_PRODUCT, &default_product)); +} + +void test_core_useragent__cleanup(void) +{ + git_libgit2_opts(GIT_OPT_SET_USER_AGENT, NULL); + git_libgit2_opts(GIT_OPT_SET_USER_AGENT_PRODUCT, NULL); + + git_buf_dispose(&default_ua); + git_buf_dispose(&default_product); +} + +void test_core_useragent__get_default(void) +{ + cl_assert(default_ua.size); + cl_assert(default_ua.ptr); + cl_assert(git__prefixcmp(default_ua.ptr, "libgit2 ") == 0); + + cl_assert(default_product.size); + cl_assert(default_product.ptr); + cl_assert(git__prefixcmp(default_product.ptr, "git/") == 0); +} + +void test_core_useragent__set(void) { - const char *custom_name = "super duper git"; - git_str buf = GIT_STR_INIT; + cl_git_pass(git_libgit2_opts(GIT_OPT_SET_USER_AGENT, "foo bar 4.24")); + cl_assert_equal_s("foo bar 4.24", git_settings__user_agent()); + cl_assert_equal_s(default_product.ptr, git_settings__user_agent_product()); - cl_assert_equal_p(NULL, git_settings__user_agent()); - cl_git_pass(git_libgit2_opts(GIT_OPT_SET_USER_AGENT, custom_name)); - cl_assert_equal_s(custom_name, git_settings__user_agent()); + cl_git_pass(git_libgit2_opts(GIT_OPT_SET_USER_AGENT_PRODUCT, "baz/2.2.3")); + cl_assert_equal_s("foo bar 4.24", git_settings__user_agent()); + cl_assert_equal_s("baz/2.2.3", git_settings__user_agent_product()); - cl_git_pass(git_libgit2_opts(GIT_OPT_GET_USER_AGENT, &buf)); - cl_assert_equal_s(custom_name, buf.ptr); + cl_git_pass(git_libgit2_opts(GIT_OPT_SET_USER_AGENT, "")); + cl_git_pass(git_libgit2_opts(GIT_OPT_SET_USER_AGENT_PRODUCT, "")); + cl_assert_equal_s("", git_settings__user_agent()); + cl_assert_equal_s("", git_settings__user_agent_product()); - git_str_dispose(&buf); + cl_git_pass(git_libgit2_opts(GIT_OPT_SET_USER_AGENT, NULL)); + cl_git_pass(git_libgit2_opts(GIT_OPT_SET_USER_AGENT_PRODUCT, NULL)); + cl_assert_equal_s(default_ua.ptr, git_settings__user_agent()); + cl_assert_equal_s(default_product.ptr, git_settings__user_agent_product()); } From 6bed71e05d77566423756060032e4cdd467085f8 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Tue, 2 Apr 2024 22:08:50 +0100 Subject: [PATCH 573/608] docs: update includes Update our headers so that they can include the necessary definitions. Docs generators (in particular, `clang -Xclang -ast-dump`) were unable to see the necessary definitions. --- include/git2/email.h | 1 + include/git2/sys/email.h | 5 +++++ include/git2/worktree.h | 1 + 3 files changed, 7 insertions(+) diff --git a/include/git2/email.h b/include/git2/email.h index 20393653e9f..3389353e796 100644 --- a/include/git2/email.h +++ b/include/git2/email.h @@ -8,6 +8,7 @@ #define INCLUDE_git_email_h__ #include "common.h" +#include "diff.h" /** * @file git2/email.h diff --git a/include/git2/sys/email.h b/include/git2/sys/email.h index 6f4a2866209..5029f9a532c 100644 --- a/include/git2/sys/email.h +++ b/include/git2/sys/email.h @@ -7,6 +7,11 @@ #ifndef INCLUDE_sys_git_email_h__ #define INCLUDE_sys_git_email_h__ +#include "git2/common.h" +#include "git2/diff.h" +#include "git2/email.h" +#include "git2/types.h" + /** * @file git2/sys/email.h * @brief Advanced git email creation routines diff --git a/include/git2/worktree.h b/include/git2/worktree.h index 1af4c038573..a6e5d17c4b1 100644 --- a/include/git2/worktree.h +++ b/include/git2/worktree.h @@ -11,6 +11,7 @@ #include "buffer.h" #include "types.h" #include "strarray.h" +#include "checkout.h" /** * @file git2/worktrees.h From 6122f008c6f247a4729d246d9c469c2f1d3bf685 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Tue, 2 Apr 2024 22:13:24 +0100 Subject: [PATCH 574/608] docs: it's _return_ not _returns_ --- include/git2/refspec.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/git2/refspec.h b/include/git2/refspec.h index eaf7747465c..e7087132b04 100644 --- a/include/git2/refspec.h +++ b/include/git2/refspec.h @@ -58,7 +58,7 @@ GIT_EXTERN(const char *) git_refspec_dst(const git_refspec *refspec); * Get the refspec's string * * @param refspec the refspec - * @returns the refspec's original string + * @return the refspec's original string */ GIT_EXTERN(const char *) git_refspec_string(const git_refspec *refspec); From cc2a01524d7ff0cbab60b4c68908a364ea960360 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Tue, 2 Apr 2024 22:13:53 +0100 Subject: [PATCH 575/608] docs: document `git_remote_capability_t` --- include/git2/sys/remote.h | 3 +++ 1 file changed, 3 insertions(+) diff --git a/include/git2/sys/remote.h b/include/git2/sys/remote.h index 07309ab09b6..58950e1ec77 100644 --- a/include/git2/sys/remote.h +++ b/include/git2/sys/remote.h @@ -20,6 +20,9 @@ GIT_BEGIN_DECL +/** + * A remote's capabilities. + */ typedef enum { /** Remote supports fetching an advertised object by ID. */ GIT_REMOTE_CAPABILITY_TIP_OID = (1 << 0), From 4b043541ab480aaa083707c134c23d17be5baafc Mon Sep 17 00:00:00 2001 From: Sergey Fedorov Date: Mon, 8 Apr 2024 03:46:17 +0800 Subject: [PATCH 576/608] process.c: fix environ for macOS --- src/util/unix/process.c | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/src/util/unix/process.c b/src/util/unix/process.c index 15092cb217f..68c0384a4c4 100644 --- a/src/util/unix/process.c +++ b/src/util/unix/process.c @@ -15,7 +15,12 @@ #include "process.h" #include "strlist.h" -extern char **environ; +#ifdef __APPLE__ + #include + #define environ (*_NSGetEnviron()) +#else + extern char **environ; +#endif struct git_process { char **args; From 387d01c18633175adb05aaad1f0428dcf6a5c254 Mon Sep 17 00:00:00 2001 From: Jason Haslam Date: Wed, 10 Apr 2024 21:29:54 -0600 Subject: [PATCH 577/608] cmake: remove workaround that isn't compatible with Windows on ARM --- src/libgit2/CMakeLists.txt | 6 ------ 1 file changed, 6 deletions(-) diff --git a/src/libgit2/CMakeLists.txt b/src/libgit2/CMakeLists.txt index 876a703e857..bc7cb5b3597 100644 --- a/src/libgit2/CMakeLists.txt +++ b/src/libgit2/CMakeLists.txt @@ -65,12 +65,6 @@ set_target_properties(libgit2package PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${PROJE set_target_properties(libgit2package PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}) set_target_properties(libgit2package PROPERTIES ARCHIVE_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}) -# Workaround for Cmake bug #0011240 (see http://public.kitware.com/Bug/view.php?id=11240) -# Win64+MSVC+static libs = linker error -if(MSVC AND GIT_ARCH_64 AND NOT BUILD_SHARED_LIBS) - set_target_properties(libgit2package PROPERTIES STATIC_LIBRARY_FLAGS "/MACHINE:x64") -endif() - ide_split_sources(libgit2package) if(SONAME) From 6e8227ab38952cf3575eb76f64f80dc536d36ec9 Mon Sep 17 00:00:00 2001 From: Conrad Irwin Date: Mon, 15 Apr 2024 09:36:12 -0600 Subject: [PATCH 578/608] Bounds check for pack index read Fixes: https://github.com/libgit2/libgit2/issues/6795 Co-Authored-By: Bennet --- src/libgit2/pack.c | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/src/libgit2/pack.c b/src/libgit2/pack.c index eff73988278..566f8c51ae5 100644 --- a/src/libgit2/pack.c +++ b/src/libgit2/pack.c @@ -1525,6 +1525,14 @@ static int pack_entry_find_offset( if (p->index_version > 1) { level1_ofs += 2; index += 8; + + if ((int)short_oid->id[0] + 2 >= p->index_map.len) { + git_error_set(GIT_ERROR_INTERNAL, "internal error: p->short_oid->[0] out of bounds"); + goto cleanup; + } + } else if ((int)short_oid->id[0] >= p->index_map.len) { + git_error_set(GIT_ERROR_INTERNAL, "internal error: p->short_oid->[0] out of bounds"); + goto cleanup; } index += 4 * 256; From 06cafdf9d8ff70d78a82223fe87d1ad3b83fde29 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 19 Apr 2024 09:58:47 +0100 Subject: [PATCH 579/608] pack: upcast to `size_t` for bounds checking --- src/libgit2/pack.c | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/src/libgit2/pack.c b/src/libgit2/pack.c index 566f8c51ae5..1ff0eb0c9d9 100644 --- a/src/libgit2/pack.c +++ b/src/libgit2/pack.c @@ -1499,6 +1499,7 @@ static int pack_entry_find_offset( size_t len) { const uint32_t *level1_ofs; + size_t ofs_delta = 0; const unsigned char *index; unsigned hi, lo, stride; int pos, found = 0; @@ -1524,13 +1525,11 @@ static int pack_entry_find_offset( if (p->index_version > 1) { level1_ofs += 2; + ofs_delta = 2; index += 8; + } - if ((int)short_oid->id[0] + 2 >= p->index_map.len) { - git_error_set(GIT_ERROR_INTERNAL, "internal error: p->short_oid->[0] out of bounds"); - goto cleanup; - } - } else if ((int)short_oid->id[0] >= p->index_map.len) { + if ((size_t)short_oid->id[0] + ofs_delta >= p->index_map.len) { git_error_set(GIT_ERROR_INTERNAL, "internal error: p->short_oid->[0] out of bounds"); goto cleanup; } From 3599de9073ed46ed6da5e8b56aa32d1092bfc8e7 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 19 Apr 2024 13:16:37 +0100 Subject: [PATCH 580/608] http: add llhttp as a bundled dependency Include llhttp as a bundled dependency with the aim to use it as our default http parser, removing the now-unmaintained Node.js http-parser. --- COPYING | 25 + deps/llhttp/CMakeLists.txt | 8 + deps/llhttp/LICENSE-MIT | 22 + deps/llhttp/api.c | 510 ++ deps/llhttp/http.c | 170 + deps/llhttp/llhttp.c | 10168 +++++++++++++++++++++++++++++++++++ deps/llhttp/llhttp.h | 897 +++ 7 files changed, 11800 insertions(+) create mode 100644 deps/llhttp/CMakeLists.txt create mode 100644 deps/llhttp/LICENSE-MIT create mode 100644 deps/llhttp/api.c create mode 100644 deps/llhttp/http.c create mode 100644 deps/llhttp/llhttp.c create mode 100644 deps/llhttp/llhttp.h diff --git a/COPYING b/COPYING index ff5e76857e3..32c851f68da 100644 --- a/COPYING +++ b/COPYING @@ -1214,3 +1214,28 @@ AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +---------------------------------------------------------------------- + +The bundled llhttp dependency is licensed under the MIT license: + +Copyright Fedor Indutny, 2018. + +Permission is hereby granted, free of charge, to any person obtaining a +copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to permit +persons to whom the Software is furnished to do so, subject to the +following conditions: + +The above copyright notice and this permission notice shall be included +in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/deps/llhttp/CMakeLists.txt b/deps/llhttp/CMakeLists.txt new file mode 100644 index 00000000000..89daa87c8de --- /dev/null +++ b/deps/llhttp/CMakeLists.txt @@ -0,0 +1,8 @@ +file(GLOB SRC_HTTP "*.c" "*.h") +list(SORT SRC_HTTP) + +add_library(llhttp OBJECT ${SRC_HTTP}) + +if(NOT MSVC) + set_source_files_properties(api.c http.c llhttp.c PROPERTIES COMPILE_FLAGS "-Wno-unused-parameter -Wno-missing-declarations") +endif() diff --git a/deps/llhttp/LICENSE-MIT b/deps/llhttp/LICENSE-MIT new file mode 100644 index 00000000000..6c1512dd6bc --- /dev/null +++ b/deps/llhttp/LICENSE-MIT @@ -0,0 +1,22 @@ +This software is licensed under the MIT License. + +Copyright Fedor Indutny, 2018. + +Permission is hereby granted, free of charge, to any person obtaining a +copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to permit +persons to whom the Software is furnished to do so, subject to the +following conditions: + +The above copyright notice and this permission notice shall be included +in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/deps/llhttp/api.c b/deps/llhttp/api.c new file mode 100644 index 00000000000..8c2ce3dc5c4 --- /dev/null +++ b/deps/llhttp/api.c @@ -0,0 +1,510 @@ +#include +#include +#include + +#include "llhttp.h" + +#define CALLBACK_MAYBE(PARSER, NAME) \ + do { \ + const llhttp_settings_t* settings; \ + settings = (const llhttp_settings_t*) (PARSER)->settings; \ + if (settings == NULL || settings->NAME == NULL) { \ + err = 0; \ + break; \ + } \ + err = settings->NAME((PARSER)); \ + } while (0) + +#define SPAN_CALLBACK_MAYBE(PARSER, NAME, START, LEN) \ + do { \ + const llhttp_settings_t* settings; \ + settings = (const llhttp_settings_t*) (PARSER)->settings; \ + if (settings == NULL || settings->NAME == NULL) { \ + err = 0; \ + break; \ + } \ + err = settings->NAME((PARSER), (START), (LEN)); \ + if (err == -1) { \ + err = HPE_USER; \ + llhttp_set_error_reason((PARSER), "Span callback error in " #NAME); \ + } \ + } while (0) + +void llhttp_init(llhttp_t* parser, llhttp_type_t type, + const llhttp_settings_t* settings) { + llhttp__internal_init(parser); + + parser->type = type; + parser->settings = (void*) settings; +} + + +#if defined(__wasm__) + +extern int wasm_on_message_begin(llhttp_t * p); +extern int wasm_on_url(llhttp_t* p, const char* at, size_t length); +extern int wasm_on_status(llhttp_t* p, const char* at, size_t length); +extern int wasm_on_header_field(llhttp_t* p, const char* at, size_t length); +extern int wasm_on_header_value(llhttp_t* p, const char* at, size_t length); +extern int wasm_on_headers_complete(llhttp_t * p, int status_code, + uint8_t upgrade, int should_keep_alive); +extern int wasm_on_body(llhttp_t* p, const char* at, size_t length); +extern int wasm_on_message_complete(llhttp_t * p); + +static int wasm_on_headers_complete_wrap(llhttp_t* p) { + return wasm_on_headers_complete(p, p->status_code, p->upgrade, + llhttp_should_keep_alive(p)); +} + +const llhttp_settings_t wasm_settings = { + wasm_on_message_begin, + wasm_on_url, + wasm_on_status, + NULL, + NULL, + wasm_on_header_field, + wasm_on_header_value, + NULL, + NULL, + wasm_on_headers_complete_wrap, + wasm_on_body, + wasm_on_message_complete, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, +}; + + +llhttp_t* llhttp_alloc(llhttp_type_t type) { + llhttp_t* parser = malloc(sizeof(llhttp_t)); + llhttp_init(parser, type, &wasm_settings); + return parser; +} + +void llhttp_free(llhttp_t* parser) { + free(parser); +} + +#endif // defined(__wasm__) + +/* Some getters required to get stuff from the parser */ + +uint8_t llhttp_get_type(llhttp_t* parser) { + return parser->type; +} + +uint8_t llhttp_get_http_major(llhttp_t* parser) { + return parser->http_major; +} + +uint8_t llhttp_get_http_minor(llhttp_t* parser) { + return parser->http_minor; +} + +uint8_t llhttp_get_method(llhttp_t* parser) { + return parser->method; +} + +int llhttp_get_status_code(llhttp_t* parser) { + return parser->status_code; +} + +uint8_t llhttp_get_upgrade(llhttp_t* parser) { + return parser->upgrade; +} + + +void llhttp_reset(llhttp_t* parser) { + llhttp_type_t type = parser->type; + const llhttp_settings_t* settings = parser->settings; + void* data = parser->data; + uint16_t lenient_flags = parser->lenient_flags; + + llhttp__internal_init(parser); + + parser->type = type; + parser->settings = (void*) settings; + parser->data = data; + parser->lenient_flags = lenient_flags; +} + + +llhttp_errno_t llhttp_execute(llhttp_t* parser, const char* data, size_t len) { + return llhttp__internal_execute(parser, data, data + len); +} + + +void llhttp_settings_init(llhttp_settings_t* settings) { + memset(settings, 0, sizeof(*settings)); +} + + +llhttp_errno_t llhttp_finish(llhttp_t* parser) { + int err; + + /* We're in an error state. Don't bother doing anything. */ + if (parser->error != 0) { + return 0; + } + + switch (parser->finish) { + case HTTP_FINISH_SAFE_WITH_CB: + CALLBACK_MAYBE(parser, on_message_complete); + if (err != HPE_OK) return err; + + /* FALLTHROUGH */ + case HTTP_FINISH_SAFE: + return HPE_OK; + case HTTP_FINISH_UNSAFE: + parser->reason = "Invalid EOF state"; + return HPE_INVALID_EOF_STATE; + default: + abort(); + } +} + + +void llhttp_pause(llhttp_t* parser) { + if (parser->error != HPE_OK) { + return; + } + + parser->error = HPE_PAUSED; + parser->reason = "Paused"; +} + + +void llhttp_resume(llhttp_t* parser) { + if (parser->error != HPE_PAUSED) { + return; + } + + parser->error = 0; +} + + +void llhttp_resume_after_upgrade(llhttp_t* parser) { + if (parser->error != HPE_PAUSED_UPGRADE) { + return; + } + + parser->error = 0; +} + + +llhttp_errno_t llhttp_get_errno(const llhttp_t* parser) { + return parser->error; +} + + +const char* llhttp_get_error_reason(const llhttp_t* parser) { + return parser->reason; +} + + +void llhttp_set_error_reason(llhttp_t* parser, const char* reason) { + parser->reason = reason; +} + + +const char* llhttp_get_error_pos(const llhttp_t* parser) { + return parser->error_pos; +} + + +const char* llhttp_errno_name(llhttp_errno_t err) { +#define HTTP_ERRNO_GEN(CODE, NAME, _) case HPE_##NAME: return "HPE_" #NAME; + switch (err) { + HTTP_ERRNO_MAP(HTTP_ERRNO_GEN) + default: abort(); + } +#undef HTTP_ERRNO_GEN +} + + +const char* llhttp_method_name(llhttp_method_t method) { +#define HTTP_METHOD_GEN(NUM, NAME, STRING) case HTTP_##NAME: return #STRING; + switch (method) { + HTTP_ALL_METHOD_MAP(HTTP_METHOD_GEN) + default: abort(); + } +#undef HTTP_METHOD_GEN +} + +const char* llhttp_status_name(llhttp_status_t status) { +#define HTTP_STATUS_GEN(NUM, NAME, STRING) case HTTP_STATUS_##NAME: return #STRING; + switch (status) { + HTTP_STATUS_MAP(HTTP_STATUS_GEN) + default: abort(); + } +#undef HTTP_STATUS_GEN +} + + +void llhttp_set_lenient_headers(llhttp_t* parser, int enabled) { + if (enabled) { + parser->lenient_flags |= LENIENT_HEADERS; + } else { + parser->lenient_flags &= ~LENIENT_HEADERS; + } +} + + +void llhttp_set_lenient_chunked_length(llhttp_t* parser, int enabled) { + if (enabled) { + parser->lenient_flags |= LENIENT_CHUNKED_LENGTH; + } else { + parser->lenient_flags &= ~LENIENT_CHUNKED_LENGTH; + } +} + + +void llhttp_set_lenient_keep_alive(llhttp_t* parser, int enabled) { + if (enabled) { + parser->lenient_flags |= LENIENT_KEEP_ALIVE; + } else { + parser->lenient_flags &= ~LENIENT_KEEP_ALIVE; + } +} + +void llhttp_set_lenient_transfer_encoding(llhttp_t* parser, int enabled) { + if (enabled) { + parser->lenient_flags |= LENIENT_TRANSFER_ENCODING; + } else { + parser->lenient_flags &= ~LENIENT_TRANSFER_ENCODING; + } +} + +void llhttp_set_lenient_version(llhttp_t* parser, int enabled) { + if (enabled) { + parser->lenient_flags |= LENIENT_VERSION; + } else { + parser->lenient_flags &= ~LENIENT_VERSION; + } +} + +void llhttp_set_lenient_data_after_close(llhttp_t* parser, int enabled) { + if (enabled) { + parser->lenient_flags |= LENIENT_DATA_AFTER_CLOSE; + } else { + parser->lenient_flags &= ~LENIENT_DATA_AFTER_CLOSE; + } +} + +void llhttp_set_lenient_optional_lf_after_cr(llhttp_t* parser, int enabled) { + if (enabled) { + parser->lenient_flags |= LENIENT_OPTIONAL_LF_AFTER_CR; + } else { + parser->lenient_flags &= ~LENIENT_OPTIONAL_LF_AFTER_CR; + } +} + +void llhttp_set_lenient_optional_crlf_after_chunk(llhttp_t* parser, int enabled) { + if (enabled) { + parser->lenient_flags |= LENIENT_OPTIONAL_CRLF_AFTER_CHUNK; + } else { + parser->lenient_flags &= ~LENIENT_OPTIONAL_CRLF_AFTER_CHUNK; + } +} + +void llhttp_set_lenient_optional_cr_before_lf(llhttp_t* parser, int enabled) { + if (enabled) { + parser->lenient_flags |= LENIENT_OPTIONAL_CR_BEFORE_LF; + } else { + parser->lenient_flags &= ~LENIENT_OPTIONAL_CR_BEFORE_LF; + } +} + +void llhttp_set_lenient_spaces_after_chunk_size(llhttp_t* parser, int enabled) { + if (enabled) { + parser->lenient_flags |= LENIENT_SPACES_AFTER_CHUNK_SIZE; + } else { + parser->lenient_flags &= ~LENIENT_SPACES_AFTER_CHUNK_SIZE; + } +} + +/* Callbacks */ + + +int llhttp__on_message_begin(llhttp_t* s, const char* p, const char* endp) { + int err; + CALLBACK_MAYBE(s, on_message_begin); + return err; +} + + +int llhttp__on_url(llhttp_t* s, const char* p, const char* endp) { + int err; + SPAN_CALLBACK_MAYBE(s, on_url, p, endp - p); + return err; +} + + +int llhttp__on_url_complete(llhttp_t* s, const char* p, const char* endp) { + int err; + CALLBACK_MAYBE(s, on_url_complete); + return err; +} + + +int llhttp__on_status(llhttp_t* s, const char* p, const char* endp) { + int err; + SPAN_CALLBACK_MAYBE(s, on_status, p, endp - p); + return err; +} + + +int llhttp__on_status_complete(llhttp_t* s, const char* p, const char* endp) { + int err; + CALLBACK_MAYBE(s, on_status_complete); + return err; +} + + +int llhttp__on_method(llhttp_t* s, const char* p, const char* endp) { + int err; + SPAN_CALLBACK_MAYBE(s, on_method, p, endp - p); + return err; +} + + +int llhttp__on_method_complete(llhttp_t* s, const char* p, const char* endp) { + int err; + CALLBACK_MAYBE(s, on_method_complete); + return err; +} + + +int llhttp__on_version(llhttp_t* s, const char* p, const char* endp) { + int err; + SPAN_CALLBACK_MAYBE(s, on_version, p, endp - p); + return err; +} + + +int llhttp__on_version_complete(llhttp_t* s, const char* p, const char* endp) { + int err; + CALLBACK_MAYBE(s, on_version_complete); + return err; +} + + +int llhttp__on_header_field(llhttp_t* s, const char* p, const char* endp) { + int err; + SPAN_CALLBACK_MAYBE(s, on_header_field, p, endp - p); + return err; +} + + +int llhttp__on_header_field_complete(llhttp_t* s, const char* p, const char* endp) { + int err; + CALLBACK_MAYBE(s, on_header_field_complete); + return err; +} + + +int llhttp__on_header_value(llhttp_t* s, const char* p, const char* endp) { + int err; + SPAN_CALLBACK_MAYBE(s, on_header_value, p, endp - p); + return err; +} + + +int llhttp__on_header_value_complete(llhttp_t* s, const char* p, const char* endp) { + int err; + CALLBACK_MAYBE(s, on_header_value_complete); + return err; +} + + +int llhttp__on_headers_complete(llhttp_t* s, const char* p, const char* endp) { + int err; + CALLBACK_MAYBE(s, on_headers_complete); + return err; +} + + +int llhttp__on_message_complete(llhttp_t* s, const char* p, const char* endp) { + int err; + CALLBACK_MAYBE(s, on_message_complete); + return err; +} + + +int llhttp__on_body(llhttp_t* s, const char* p, const char* endp) { + int err; + SPAN_CALLBACK_MAYBE(s, on_body, p, endp - p); + return err; +} + + +int llhttp__on_chunk_header(llhttp_t* s, const char* p, const char* endp) { + int err; + CALLBACK_MAYBE(s, on_chunk_header); + return err; +} + + +int llhttp__on_chunk_extension_name(llhttp_t* s, const char* p, const char* endp) { + int err; + SPAN_CALLBACK_MAYBE(s, on_chunk_extension_name, p, endp - p); + return err; +} + + +int llhttp__on_chunk_extension_name_complete(llhttp_t* s, const char* p, const char* endp) { + int err; + CALLBACK_MAYBE(s, on_chunk_extension_name_complete); + return err; +} + + +int llhttp__on_chunk_extension_value(llhttp_t* s, const char* p, const char* endp) { + int err; + SPAN_CALLBACK_MAYBE(s, on_chunk_extension_value, p, endp - p); + return err; +} + + +int llhttp__on_chunk_extension_value_complete(llhttp_t* s, const char* p, const char* endp) { + int err; + CALLBACK_MAYBE(s, on_chunk_extension_value_complete); + return err; +} + + +int llhttp__on_chunk_complete(llhttp_t* s, const char* p, const char* endp) { + int err; + CALLBACK_MAYBE(s, on_chunk_complete); + return err; +} + + +int llhttp__on_reset(llhttp_t* s, const char* p, const char* endp) { + int err; + CALLBACK_MAYBE(s, on_reset); + return err; +} + + +/* Private */ + + +void llhttp__debug(llhttp_t* s, const char* p, const char* endp, + const char* msg) { + if (p == endp) { + fprintf(stderr, "p=%p type=%d flags=%02x next=null debug=%s\n", s, s->type, + s->flags, msg); + } else { + fprintf(stderr, "p=%p type=%d flags=%02x next=%02x debug=%s\n", s, + s->type, s->flags, *p, msg); + } +} diff --git a/deps/llhttp/http.c b/deps/llhttp/http.c new file mode 100644 index 00000000000..1ab91a55796 --- /dev/null +++ b/deps/llhttp/http.c @@ -0,0 +1,170 @@ +#include +#ifndef LLHTTP__TEST +# include "llhttp.h" +#else +# define llhttp_t llparse_t +#endif /* */ + +int llhttp_message_needs_eof(const llhttp_t* parser); +int llhttp_should_keep_alive(const llhttp_t* parser); + +int llhttp__before_headers_complete(llhttp_t* parser, const char* p, + const char* endp) { + /* Set this here so that on_headers_complete() callbacks can see it */ + if ((parser->flags & F_UPGRADE) && + (parser->flags & F_CONNECTION_UPGRADE)) { + /* For responses, "Upgrade: foo" and "Connection: upgrade" are + * mandatory only when it is a 101 Switching Protocols response, + * otherwise it is purely informational, to announce support. + */ + parser->upgrade = + (parser->type == HTTP_REQUEST || parser->status_code == 101); + } else { + parser->upgrade = (parser->method == HTTP_CONNECT); + } + return 0; +} + + +/* Return values: + * 0 - No body, `restart`, message_complete + * 1 - CONNECT request, `restart`, message_complete, and pause + * 2 - chunk_size_start + * 3 - body_identity + * 4 - body_identity_eof + * 5 - invalid transfer-encoding for request + */ +int llhttp__after_headers_complete(llhttp_t* parser, const char* p, + const char* endp) { + int hasBody; + + hasBody = parser->flags & F_CHUNKED || parser->content_length > 0; + if ( + (parser->upgrade && (parser->method == HTTP_CONNECT || + (parser->flags & F_SKIPBODY) || !hasBody)) || + /* See RFC 2616 section 4.4 - 1xx e.g. Continue */ + (parser->type == HTTP_RESPONSE && parser->status_code == 101) + ) { + /* Exit, the rest of the message is in a different protocol. */ + return 1; + } + + if (parser->type == HTTP_RESPONSE && parser->status_code == 100) { + /* No body, restart as the message is complete */ + return 0; + } + + /* See RFC 2616 section 4.4 */ + if ( + parser->flags & F_SKIPBODY || /* response to a HEAD request */ + ( + parser->type == HTTP_RESPONSE && ( + parser->status_code == 102 || /* Processing */ + parser->status_code == 103 || /* Early Hints */ + parser->status_code == 204 || /* No Content */ + parser->status_code == 304 /* Not Modified */ + ) + ) + ) { + return 0; + } else if (parser->flags & F_CHUNKED) { + /* chunked encoding - ignore Content-Length header, prepare for a chunk */ + return 2; + } else if (parser->flags & F_TRANSFER_ENCODING) { + if (parser->type == HTTP_REQUEST && + (parser->lenient_flags & LENIENT_CHUNKED_LENGTH) == 0 && + (parser->lenient_flags & LENIENT_TRANSFER_ENCODING) == 0) { + /* RFC 7230 3.3.3 */ + + /* If a Transfer-Encoding header field + * is present in a request and the chunked transfer coding is not + * the final encoding, the message body length cannot be determined + * reliably; the server MUST respond with the 400 (Bad Request) + * status code and then close the connection. + */ + return 5; + } else { + /* RFC 7230 3.3.3 */ + + /* If a Transfer-Encoding header field is present in a response and + * the chunked transfer coding is not the final encoding, the + * message body length is determined by reading the connection until + * it is closed by the server. + */ + return 4; + } + } else { + if (!(parser->flags & F_CONTENT_LENGTH)) { + if (!llhttp_message_needs_eof(parser)) { + /* Assume content-length 0 - read the next */ + return 0; + } else { + /* Read body until EOF */ + return 4; + } + } else if (parser->content_length == 0) { + /* Content-Length header given but zero: Content-Length: 0\r\n */ + return 0; + } else { + /* Content-Length header given and non-zero */ + return 3; + } + } +} + + +int llhttp__after_message_complete(llhttp_t* parser, const char* p, + const char* endp) { + int should_keep_alive; + + should_keep_alive = llhttp_should_keep_alive(parser); + parser->finish = HTTP_FINISH_SAFE; + parser->flags = 0; + + /* NOTE: this is ignored in loose parsing mode */ + return should_keep_alive; +} + + +int llhttp_message_needs_eof(const llhttp_t* parser) { + if (parser->type == HTTP_REQUEST) { + return 0; + } + + /* See RFC 2616 section 4.4 */ + if (parser->status_code / 100 == 1 || /* 1xx e.g. Continue */ + parser->status_code == 204 || /* No Content */ + parser->status_code == 304 || /* Not Modified */ + (parser->flags & F_SKIPBODY)) { /* response to a HEAD request */ + return 0; + } + + /* RFC 7230 3.3.3, see `llhttp__after_headers_complete` */ + if ((parser->flags & F_TRANSFER_ENCODING) && + (parser->flags & F_CHUNKED) == 0) { + return 1; + } + + if (parser->flags & (F_CHUNKED | F_CONTENT_LENGTH)) { + return 0; + } + + return 1; +} + + +int llhttp_should_keep_alive(const llhttp_t* parser) { + if (parser->http_major > 0 && parser->http_minor > 0) { + /* HTTP/1.1 */ + if (parser->flags & F_CONNECTION_CLOSE) { + return 0; + } + } else { + /* HTTP/1.0 or earlier */ + if (!(parser->flags & F_CONNECTION_KEEP_ALIVE)) { + return 0; + } + } + + return !llhttp_message_needs_eof(parser); +} diff --git a/deps/llhttp/llhttp.c b/deps/llhttp/llhttp.c new file mode 100644 index 00000000000..3ef3b817f3d --- /dev/null +++ b/deps/llhttp/llhttp.c @@ -0,0 +1,10168 @@ +#include +#include +#include + +#ifdef __SSE4_2__ + #ifdef _MSC_VER + #include + #else /* !_MSC_VER */ + #include + #endif /* _MSC_VER */ +#endif /* __SSE4_2__ */ + +#ifdef _MSC_VER + #define ALIGN(n) _declspec(align(n)) +#else /* !_MSC_VER */ + #define ALIGN(n) __attribute__((aligned(n))) +#endif /* _MSC_VER */ + +#include "llhttp.h" + +typedef int (*llhttp__internal__span_cb)( + llhttp__internal_t*, const char*, const char*); + +static const unsigned char llparse_blob0[] = { + 'o', 'n' +}; +static const unsigned char llparse_blob1[] = { + 'e', 'c', 't', 'i', 'o', 'n' +}; +static const unsigned char llparse_blob2[] = { + 'l', 'o', 's', 'e' +}; +static const unsigned char llparse_blob3[] = { + 'e', 'e', 'p', '-', 'a', 'l', 'i', 'v', 'e' +}; +static const unsigned char llparse_blob4[] = { + 'p', 'g', 'r', 'a', 'd', 'e' +}; +static const unsigned char llparse_blob5[] = { + 'c', 'h', 'u', 'n', 'k', 'e', 'd' +}; +#ifdef __SSE4_2__ +static const unsigned char ALIGN(16) llparse_blob6[] = { + 0x9, 0x9, ' ', '~', 0x80, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0 +}; +#endif /* __SSE4_2__ */ +#ifdef __SSE4_2__ +static const unsigned char ALIGN(16) llparse_blob7[] = { + '!', '!', '#', '\'', '*', '+', '-', '.', '0', '9', 'A', + 'Z', '^', 'z', '|', '|' +}; +#endif /* __SSE4_2__ */ +#ifdef __SSE4_2__ +static const unsigned char ALIGN(16) llparse_blob8[] = { + '~', '~', 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0 +}; +#endif /* __SSE4_2__ */ +static const unsigned char llparse_blob9[] = { + 'e', 'n', 't', '-', 'l', 'e', 'n', 'g', 't', 'h' +}; +static const unsigned char llparse_blob10[] = { + 'r', 'o', 'x', 'y', '-', 'c', 'o', 'n', 'n', 'e', 'c', + 't', 'i', 'o', 'n' +}; +static const unsigned char llparse_blob11[] = { + 'r', 'a', 'n', 's', 'f', 'e', 'r', '-', 'e', 'n', 'c', + 'o', 'd', 'i', 'n', 'g' +}; +static const unsigned char llparse_blob12[] = { + 'p', 'g', 'r', 'a', 'd', 'e' +}; +static const unsigned char llparse_blob13[] = { + 'T', 'T', 'P', '/' +}; +static const unsigned char llparse_blob14[] = { + 0xd, 0xa, 0xd, 0xa, 'S', 'M', 0xd, 0xa, 0xd, 0xa +}; +static const unsigned char llparse_blob15[] = { + 'C', 'E', '/' +}; +static const unsigned char llparse_blob16[] = { + 'T', 'S', 'P', '/' +}; +static const unsigned char llparse_blob17[] = { + 'N', 'O', 'U', 'N', 'C', 'E' +}; +static const unsigned char llparse_blob18[] = { + 'I', 'N', 'D' +}; +static const unsigned char llparse_blob19[] = { + 'E', 'C', 'K', 'O', 'U', 'T' +}; +static const unsigned char llparse_blob20[] = { + 'N', 'E', 'C', 'T' +}; +static const unsigned char llparse_blob21[] = { + 'E', 'T', 'E' +}; +static const unsigned char llparse_blob22[] = { + 'C', 'R', 'I', 'B', 'E' +}; +static const unsigned char llparse_blob23[] = { + 'L', 'U', 'S', 'H' +}; +static const unsigned char llparse_blob24[] = { + 'E', 'T' +}; +static const unsigned char llparse_blob25[] = { + 'P', 'A', 'R', 'A', 'M', 'E', 'T', 'E', 'R' +}; +static const unsigned char llparse_blob26[] = { + 'E', 'A', 'D' +}; +static const unsigned char llparse_blob27[] = { + 'N', 'K' +}; +static const unsigned char llparse_blob28[] = { + 'C', 'K' +}; +static const unsigned char llparse_blob29[] = { + 'S', 'E', 'A', 'R', 'C', 'H' +}; +static const unsigned char llparse_blob30[] = { + 'R', 'G', 'E' +}; +static const unsigned char llparse_blob31[] = { + 'C', 'T', 'I', 'V', 'I', 'T', 'Y' +}; +static const unsigned char llparse_blob32[] = { + 'L', 'E', 'N', 'D', 'A', 'R' +}; +static const unsigned char llparse_blob33[] = { + 'V', 'E' +}; +static const unsigned char llparse_blob34[] = { + 'O', 'T', 'I', 'F', 'Y' +}; +static const unsigned char llparse_blob35[] = { + 'P', 'T', 'I', 'O', 'N', 'S' +}; +static const unsigned char llparse_blob36[] = { + 'C', 'H' +}; +static const unsigned char llparse_blob37[] = { + 'S', 'E' +}; +static const unsigned char llparse_blob38[] = { + 'A', 'Y' +}; +static const unsigned char llparse_blob39[] = { + 'S', 'T' +}; +static const unsigned char llparse_blob40[] = { + 'I', 'N', 'D' +}; +static const unsigned char llparse_blob41[] = { + 'A', 'T', 'C', 'H' +}; +static const unsigned char llparse_blob42[] = { + 'G', 'E' +}; +static const unsigned char llparse_blob43[] = { + 'U', 'E', 'R', 'Y' +}; +static const unsigned char llparse_blob44[] = { + 'I', 'N', 'D' +}; +static const unsigned char llparse_blob45[] = { + 'O', 'R', 'D' +}; +static const unsigned char llparse_blob46[] = { + 'I', 'R', 'E', 'C', 'T' +}; +static const unsigned char llparse_blob47[] = { + 'O', 'R', 'T' +}; +static const unsigned char llparse_blob48[] = { + 'R', 'C', 'H' +}; +static const unsigned char llparse_blob49[] = { + 'P', 'A', 'R', 'A', 'M', 'E', 'T', 'E', 'R' +}; +static const unsigned char llparse_blob50[] = { + 'U', 'R', 'C', 'E' +}; +static const unsigned char llparse_blob51[] = { + 'B', 'S', 'C', 'R', 'I', 'B', 'E' +}; +static const unsigned char llparse_blob52[] = { + 'A', 'R', 'D', 'O', 'W', 'N' +}; +static const unsigned char llparse_blob53[] = { + 'A', 'C', 'E' +}; +static const unsigned char llparse_blob54[] = { + 'I', 'N', 'D' +}; +static const unsigned char llparse_blob55[] = { + 'N', 'K' +}; +static const unsigned char llparse_blob56[] = { + 'C', 'K' +}; +static const unsigned char llparse_blob57[] = { + 'U', 'B', 'S', 'C', 'R', 'I', 'B', 'E' +}; +static const unsigned char llparse_blob58[] = { + 'H', 'T', 'T', 'P', '/' +}; +static const unsigned char llparse_blob59[] = { + 'A', 'D' +}; +static const unsigned char llparse_blob60[] = { + 'T', 'P', '/' +}; + +enum llparse_match_status_e { + kMatchComplete, + kMatchPause, + kMatchMismatch +}; +typedef enum llparse_match_status_e llparse_match_status_t; + +struct llparse_match_s { + llparse_match_status_t status; + const unsigned char* current; +}; +typedef struct llparse_match_s llparse_match_t; + +static llparse_match_t llparse__match_sequence_to_lower( + llhttp__internal_t* s, const unsigned char* p, + const unsigned char* endp, + const unsigned char* seq, uint32_t seq_len) { + uint32_t index; + llparse_match_t res; + + index = s->_index; + for (; p != endp; p++) { + unsigned char current; + + current = ((*p) >= 'A' && (*p) <= 'Z' ? (*p | 0x20) : (*p)); + if (current == seq[index]) { + if (++index == seq_len) { + res.status = kMatchComplete; + goto reset; + } + } else { + res.status = kMatchMismatch; + goto reset; + } + } + s->_index = index; + res.status = kMatchPause; + res.current = p; + return res; +reset: + s->_index = 0; + res.current = p; + return res; +} + +static llparse_match_t llparse__match_sequence_to_lower_unsafe( + llhttp__internal_t* s, const unsigned char* p, + const unsigned char* endp, + const unsigned char* seq, uint32_t seq_len) { + uint32_t index; + llparse_match_t res; + + index = s->_index; + for (; p != endp; p++) { + unsigned char current; + + current = ((*p) | 0x20); + if (current == seq[index]) { + if (++index == seq_len) { + res.status = kMatchComplete; + goto reset; + } + } else { + res.status = kMatchMismatch; + goto reset; + } + } + s->_index = index; + res.status = kMatchPause; + res.current = p; + return res; +reset: + s->_index = 0; + res.current = p; + return res; +} + +static llparse_match_t llparse__match_sequence_id( + llhttp__internal_t* s, const unsigned char* p, + const unsigned char* endp, + const unsigned char* seq, uint32_t seq_len) { + uint32_t index; + llparse_match_t res; + + index = s->_index; + for (; p != endp; p++) { + unsigned char current; + + current = *p; + if (current == seq[index]) { + if (++index == seq_len) { + res.status = kMatchComplete; + goto reset; + } + } else { + res.status = kMatchMismatch; + goto reset; + } + } + s->_index = index; + res.status = kMatchPause; + res.current = p; + return res; +reset: + s->_index = 0; + res.current = p; + return res; +} + +enum llparse_state_e { + s_error, + s_n_llhttp__internal__n_closed, + s_n_llhttp__internal__n_invoke_llhttp__after_message_complete, + s_n_llhttp__internal__n_pause_1, + s_n_llhttp__internal__n_invoke_is_equal_upgrade, + s_n_llhttp__internal__n_invoke_llhttp__on_message_complete_2, + s_n_llhttp__internal__n_chunk_data_almost_done_1, + s_n_llhttp__internal__n_chunk_data_almost_done, + s_n_llhttp__internal__n_consume_content_length, + s_n_llhttp__internal__n_span_start_llhttp__on_body, + s_n_llhttp__internal__n_invoke_is_equal_content_length, + s_n_llhttp__internal__n_chunk_size_almost_done, + s_n_llhttp__internal__n_invoke_test_lenient_flags_9, + s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_name_complete, + s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_name_complete_1, + s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_name_complete_2, + s_n_llhttp__internal__n_invoke_test_lenient_flags_10, + s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete, + s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete_1, + s_n_llhttp__internal__n_chunk_extension_quoted_value_done, + s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete_2, + s_n_llhttp__internal__n_error_30, + s_n_llhttp__internal__n_chunk_extension_quoted_value_quoted_pair, + s_n_llhttp__internal__n_error_31, + s_n_llhttp__internal__n_chunk_extension_quoted_value, + s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete_3, + s_n_llhttp__internal__n_error_33, + s_n_llhttp__internal__n_chunk_extension_value, + s_n_llhttp__internal__n_span_start_llhttp__on_chunk_extension_value, + s_n_llhttp__internal__n_error_34, + s_n_llhttp__internal__n_chunk_extension_name, + s_n_llhttp__internal__n_span_start_llhttp__on_chunk_extension_name, + s_n_llhttp__internal__n_chunk_extensions, + s_n_llhttp__internal__n_chunk_size_otherwise, + s_n_llhttp__internal__n_chunk_size, + s_n_llhttp__internal__n_chunk_size_digit, + s_n_llhttp__internal__n_invoke_update_content_length_1, + s_n_llhttp__internal__n_consume_content_length_1, + s_n_llhttp__internal__n_span_start_llhttp__on_body_1, + s_n_llhttp__internal__n_eof, + s_n_llhttp__internal__n_span_start_llhttp__on_body_2, + s_n_llhttp__internal__n_invoke_llhttp__after_headers_complete, + s_n_llhttp__internal__n_error_5, + s_n_llhttp__internal__n_headers_almost_done, + s_n_llhttp__internal__n_header_field_colon_discard_ws, + s_n_llhttp__internal__n_invoke_llhttp__on_header_value_complete, + s_n_llhttp__internal__n_span_start_llhttp__on_header_value, + s_n_llhttp__internal__n_header_value_discard_lws, + s_n_llhttp__internal__n_header_value_discard_ws_almost_done, + s_n_llhttp__internal__n_header_value_lws, + s_n_llhttp__internal__n_header_value_almost_done, + s_n_llhttp__internal__n_invoke_test_lenient_flags_17, + s_n_llhttp__internal__n_header_value_lenient, + s_n_llhttp__internal__n_error_54, + s_n_llhttp__internal__n_header_value_otherwise, + s_n_llhttp__internal__n_header_value_connection_token, + s_n_llhttp__internal__n_header_value_connection_ws, + s_n_llhttp__internal__n_header_value_connection_1, + s_n_llhttp__internal__n_header_value_connection_2, + s_n_llhttp__internal__n_header_value_connection_3, + s_n_llhttp__internal__n_header_value_connection, + s_n_llhttp__internal__n_error_56, + s_n_llhttp__internal__n_error_57, + s_n_llhttp__internal__n_header_value_content_length_ws, + s_n_llhttp__internal__n_header_value_content_length, + s_n_llhttp__internal__n_error_59, + s_n_llhttp__internal__n_error_58, + s_n_llhttp__internal__n_header_value_te_token_ows, + s_n_llhttp__internal__n_header_value, + s_n_llhttp__internal__n_header_value_te_token, + s_n_llhttp__internal__n_header_value_te_chunked_last, + s_n_llhttp__internal__n_header_value_te_chunked, + s_n_llhttp__internal__n_span_start_llhttp__on_header_value_1, + s_n_llhttp__internal__n_header_value_discard_ws, + s_n_llhttp__internal__n_invoke_load_header_state, + s_n_llhttp__internal__n_invoke_llhttp__on_header_field_complete, + s_n_llhttp__internal__n_header_field_general_otherwise, + s_n_llhttp__internal__n_header_field_general, + s_n_llhttp__internal__n_header_field_colon, + s_n_llhttp__internal__n_header_field_3, + s_n_llhttp__internal__n_header_field_4, + s_n_llhttp__internal__n_header_field_2, + s_n_llhttp__internal__n_header_field_1, + s_n_llhttp__internal__n_header_field_5, + s_n_llhttp__internal__n_header_field_6, + s_n_llhttp__internal__n_header_field_7, + s_n_llhttp__internal__n_header_field, + s_n_llhttp__internal__n_span_start_llhttp__on_header_field, + s_n_llhttp__internal__n_header_field_start, + s_n_llhttp__internal__n_headers_start, + s_n_llhttp__internal__n_url_to_http_09, + s_n_llhttp__internal__n_url_skip_to_http09, + s_n_llhttp__internal__n_url_skip_lf_to_http09_1, + s_n_llhttp__internal__n_url_skip_lf_to_http09, + s_n_llhttp__internal__n_req_pri_upgrade, + s_n_llhttp__internal__n_req_http_complete_crlf, + s_n_llhttp__internal__n_req_http_complete, + s_n_llhttp__internal__n_invoke_load_method_1, + s_n_llhttp__internal__n_invoke_llhttp__on_version_complete, + s_n_llhttp__internal__n_error_66, + s_n_llhttp__internal__n_error_73, + s_n_llhttp__internal__n_req_http_minor, + s_n_llhttp__internal__n_error_74, + s_n_llhttp__internal__n_req_http_dot, + s_n_llhttp__internal__n_error_75, + s_n_llhttp__internal__n_req_http_major, + s_n_llhttp__internal__n_span_start_llhttp__on_version, + s_n_llhttp__internal__n_req_http_start_1, + s_n_llhttp__internal__n_req_http_start_2, + s_n_llhttp__internal__n_req_http_start_3, + s_n_llhttp__internal__n_req_http_start, + s_n_llhttp__internal__n_url_to_http, + s_n_llhttp__internal__n_url_skip_to_http, + s_n_llhttp__internal__n_url_fragment, + s_n_llhttp__internal__n_span_end_stub_query_3, + s_n_llhttp__internal__n_url_query, + s_n_llhttp__internal__n_url_query_or_fragment, + s_n_llhttp__internal__n_url_path, + s_n_llhttp__internal__n_span_start_stub_path_2, + s_n_llhttp__internal__n_span_start_stub_path, + s_n_llhttp__internal__n_span_start_stub_path_1, + s_n_llhttp__internal__n_url_server_with_at, + s_n_llhttp__internal__n_url_server, + s_n_llhttp__internal__n_url_schema_delim_1, + s_n_llhttp__internal__n_url_schema_delim, + s_n_llhttp__internal__n_span_end_stub_schema, + s_n_llhttp__internal__n_url_schema, + s_n_llhttp__internal__n_url_start, + s_n_llhttp__internal__n_span_start_llhttp__on_url_1, + s_n_llhttp__internal__n_url_entry_normal, + s_n_llhttp__internal__n_span_start_llhttp__on_url, + s_n_llhttp__internal__n_url_entry_connect, + s_n_llhttp__internal__n_req_spaces_before_url, + s_n_llhttp__internal__n_req_first_space_before_url, + s_n_llhttp__internal__n_invoke_llhttp__on_method_complete_1, + s_n_llhttp__internal__n_after_start_req_2, + s_n_llhttp__internal__n_after_start_req_3, + s_n_llhttp__internal__n_after_start_req_1, + s_n_llhttp__internal__n_after_start_req_4, + s_n_llhttp__internal__n_after_start_req_6, + s_n_llhttp__internal__n_after_start_req_8, + s_n_llhttp__internal__n_after_start_req_9, + s_n_llhttp__internal__n_after_start_req_7, + s_n_llhttp__internal__n_after_start_req_5, + s_n_llhttp__internal__n_after_start_req_12, + s_n_llhttp__internal__n_after_start_req_13, + s_n_llhttp__internal__n_after_start_req_11, + s_n_llhttp__internal__n_after_start_req_10, + s_n_llhttp__internal__n_after_start_req_14, + s_n_llhttp__internal__n_after_start_req_17, + s_n_llhttp__internal__n_after_start_req_16, + s_n_llhttp__internal__n_after_start_req_15, + s_n_llhttp__internal__n_after_start_req_18, + s_n_llhttp__internal__n_after_start_req_20, + s_n_llhttp__internal__n_after_start_req_21, + s_n_llhttp__internal__n_after_start_req_19, + s_n_llhttp__internal__n_after_start_req_23, + s_n_llhttp__internal__n_after_start_req_24, + s_n_llhttp__internal__n_after_start_req_26, + s_n_llhttp__internal__n_after_start_req_28, + s_n_llhttp__internal__n_after_start_req_29, + s_n_llhttp__internal__n_after_start_req_27, + s_n_llhttp__internal__n_after_start_req_25, + s_n_llhttp__internal__n_after_start_req_30, + s_n_llhttp__internal__n_after_start_req_22, + s_n_llhttp__internal__n_after_start_req_31, + s_n_llhttp__internal__n_after_start_req_32, + s_n_llhttp__internal__n_after_start_req_35, + s_n_llhttp__internal__n_after_start_req_36, + s_n_llhttp__internal__n_after_start_req_34, + s_n_llhttp__internal__n_after_start_req_37, + s_n_llhttp__internal__n_after_start_req_38, + s_n_llhttp__internal__n_after_start_req_42, + s_n_llhttp__internal__n_after_start_req_43, + s_n_llhttp__internal__n_after_start_req_41, + s_n_llhttp__internal__n_after_start_req_40, + s_n_llhttp__internal__n_after_start_req_39, + s_n_llhttp__internal__n_after_start_req_45, + s_n_llhttp__internal__n_after_start_req_44, + s_n_llhttp__internal__n_after_start_req_33, + s_n_llhttp__internal__n_after_start_req_46, + s_n_llhttp__internal__n_after_start_req_49, + s_n_llhttp__internal__n_after_start_req_50, + s_n_llhttp__internal__n_after_start_req_51, + s_n_llhttp__internal__n_after_start_req_52, + s_n_llhttp__internal__n_after_start_req_48, + s_n_llhttp__internal__n_after_start_req_47, + s_n_llhttp__internal__n_after_start_req_55, + s_n_llhttp__internal__n_after_start_req_57, + s_n_llhttp__internal__n_after_start_req_58, + s_n_llhttp__internal__n_after_start_req_56, + s_n_llhttp__internal__n_after_start_req_54, + s_n_llhttp__internal__n_after_start_req_59, + s_n_llhttp__internal__n_after_start_req_60, + s_n_llhttp__internal__n_after_start_req_53, + s_n_llhttp__internal__n_after_start_req_62, + s_n_llhttp__internal__n_after_start_req_63, + s_n_llhttp__internal__n_after_start_req_61, + s_n_llhttp__internal__n_after_start_req_66, + s_n_llhttp__internal__n_after_start_req_68, + s_n_llhttp__internal__n_after_start_req_69, + s_n_llhttp__internal__n_after_start_req_67, + s_n_llhttp__internal__n_after_start_req_70, + s_n_llhttp__internal__n_after_start_req_65, + s_n_llhttp__internal__n_after_start_req_64, + s_n_llhttp__internal__n_after_start_req, + s_n_llhttp__internal__n_span_start_llhttp__on_method_1, + s_n_llhttp__internal__n_res_line_almost_done, + s_n_llhttp__internal__n_invoke_test_lenient_flags_30, + s_n_llhttp__internal__n_res_status, + s_n_llhttp__internal__n_span_start_llhttp__on_status, + s_n_llhttp__internal__n_res_status_code_otherwise, + s_n_llhttp__internal__n_res_status_code_digit_3, + s_n_llhttp__internal__n_res_status_code_digit_2, + s_n_llhttp__internal__n_res_status_code_digit_1, + s_n_llhttp__internal__n_res_after_version, + s_n_llhttp__internal__n_invoke_llhttp__on_version_complete_1, + s_n_llhttp__internal__n_error_89, + s_n_llhttp__internal__n_error_103, + s_n_llhttp__internal__n_res_http_minor, + s_n_llhttp__internal__n_error_104, + s_n_llhttp__internal__n_res_http_dot, + s_n_llhttp__internal__n_error_105, + s_n_llhttp__internal__n_res_http_major, + s_n_llhttp__internal__n_span_start_llhttp__on_version_1, + s_n_llhttp__internal__n_start_res, + s_n_llhttp__internal__n_invoke_llhttp__on_method_complete, + s_n_llhttp__internal__n_req_or_res_method_2, + s_n_llhttp__internal__n_invoke_update_type_1, + s_n_llhttp__internal__n_req_or_res_method_3, + s_n_llhttp__internal__n_req_or_res_method_1, + s_n_llhttp__internal__n_req_or_res_method, + s_n_llhttp__internal__n_span_start_llhttp__on_method, + s_n_llhttp__internal__n_start_req_or_res, + s_n_llhttp__internal__n_invoke_load_type, + s_n_llhttp__internal__n_invoke_update_finish, + s_n_llhttp__internal__n_start, +}; +typedef enum llparse_state_e llparse_state_t; + +int llhttp__on_method( + llhttp__internal_t* s, const unsigned char* p, + const unsigned char* endp); + +int llhttp__on_url( + llhttp__internal_t* s, const unsigned char* p, + const unsigned char* endp); + +int llhttp__on_version( + llhttp__internal_t* s, const unsigned char* p, + const unsigned char* endp); + +int llhttp__on_header_field( + llhttp__internal_t* s, const unsigned char* p, + const unsigned char* endp); + +int llhttp__on_header_value( + llhttp__internal_t* s, const unsigned char* p, + const unsigned char* endp); + +int llhttp__on_body( + llhttp__internal_t* s, const unsigned char* p, + const unsigned char* endp); + +int llhttp__on_chunk_extension_name( + llhttp__internal_t* s, const unsigned char* p, + const unsigned char* endp); + +int llhttp__on_chunk_extension_value( + llhttp__internal_t* s, const unsigned char* p, + const unsigned char* endp); + +int llhttp__on_status( + llhttp__internal_t* s, const unsigned char* p, + const unsigned char* endp); + +int llhttp__internal__c_load_initial_message_completed( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp) { + return state->initial_message_completed; +} + +int llhttp__on_reset( + llhttp__internal_t* s, const unsigned char* p, + const unsigned char* endp); + +int llhttp__internal__c_update_finish( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp) { + state->finish = 2; + return 0; +} + +int llhttp__on_message_begin( + llhttp__internal_t* s, const unsigned char* p, + const unsigned char* endp); + +int llhttp__internal__c_load_type( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp) { + return state->type; +} + +int llhttp__internal__c_store_method( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp, + int match) { + state->method = match; + return 0; +} + +int llhttp__on_method_complete( + llhttp__internal_t* s, const unsigned char* p, + const unsigned char* endp); + +int llhttp__internal__c_is_equal_method( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp) { + return state->method == 5; +} + +int llhttp__internal__c_update_http_major( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp) { + state->http_major = 0; + return 0; +} + +int llhttp__internal__c_update_http_minor( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp) { + state->http_minor = 9; + return 0; +} + +int llhttp__on_url_complete( + llhttp__internal_t* s, const unsigned char* p, + const unsigned char* endp); + +int llhttp__internal__c_test_lenient_flags( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp) { + return (state->lenient_flags & 1) == 1; +} + +int llhttp__internal__c_test_lenient_flags_1( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp) { + return (state->lenient_flags & 256) == 256; +} + +int llhttp__internal__c_test_flags( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp) { + return (state->flags & 128) == 128; +} + +int llhttp__on_chunk_complete( + llhttp__internal_t* s, const unsigned char* p, + const unsigned char* endp); + +int llhttp__on_message_complete( + llhttp__internal_t* s, const unsigned char* p, + const unsigned char* endp); + +int llhttp__internal__c_is_equal_upgrade( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp) { + return state->upgrade == 1; +} + +int llhttp__after_message_complete( + llhttp__internal_t* s, const unsigned char* p, + const unsigned char* endp); + +int llhttp__internal__c_update_content_length( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp) { + state->content_length = 0; + return 0; +} + +int llhttp__internal__c_update_initial_message_completed( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp) { + state->initial_message_completed = 1; + return 0; +} + +int llhttp__internal__c_update_finish_1( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp) { + state->finish = 0; + return 0; +} + +int llhttp__internal__c_test_lenient_flags_2( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp) { + return (state->lenient_flags & 4) == 4; +} + +int llhttp__internal__c_test_lenient_flags_3( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp) { + return (state->lenient_flags & 32) == 32; +} + +int llhttp__before_headers_complete( + llhttp__internal_t* s, const unsigned char* p, + const unsigned char* endp); + +int llhttp__on_headers_complete( + llhttp__internal_t* s, const unsigned char* p, + const unsigned char* endp); + +int llhttp__after_headers_complete( + llhttp__internal_t* s, const unsigned char* p, + const unsigned char* endp); + +int llhttp__internal__c_mul_add_content_length( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp, + int match) { + /* Multiplication overflow */ + if (state->content_length > 0xffffffffffffffffULL / 16) { + return 1; + } + + state->content_length *= 16; + + /* Addition overflow */ + if (match >= 0) { + if (state->content_length > 0xffffffffffffffffULL - match) { + return 1; + } + } else { + if (state->content_length < 0ULL - match) { + return 1; + } + } + state->content_length += match; + return 0; +} + +int llhttp__internal__c_test_lenient_flags_4( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp) { + return (state->lenient_flags & 512) == 512; +} + +int llhttp__on_chunk_header( + llhttp__internal_t* s, const unsigned char* p, + const unsigned char* endp); + +int llhttp__internal__c_is_equal_content_length( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp) { + return state->content_length == 0; +} + +int llhttp__internal__c_test_lenient_flags_7( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp) { + return (state->lenient_flags & 128) == 128; +} + +int llhttp__internal__c_or_flags( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp) { + state->flags |= 128; + return 0; +} + +int llhttp__internal__c_test_lenient_flags_8( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp) { + return (state->lenient_flags & 64) == 64; +} + +int llhttp__on_chunk_extension_name_complete( + llhttp__internal_t* s, const unsigned char* p, + const unsigned char* endp); + +int llhttp__on_chunk_extension_value_complete( + llhttp__internal_t* s, const unsigned char* p, + const unsigned char* endp); + +int llhttp__internal__c_update_finish_3( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp) { + state->finish = 1; + return 0; +} + +int llhttp__internal__c_or_flags_1( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp) { + state->flags |= 64; + return 0; +} + +int llhttp__internal__c_update_upgrade( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp) { + state->upgrade = 1; + return 0; +} + +int llhttp__internal__c_store_header_state( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp, + int match) { + state->header_state = match; + return 0; +} + +int llhttp__on_header_field_complete( + llhttp__internal_t* s, const unsigned char* p, + const unsigned char* endp); + +int llhttp__internal__c_load_header_state( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp) { + return state->header_state; +} + +int llhttp__internal__c_test_flags_4( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp) { + return (state->flags & 512) == 512; +} + +int llhttp__internal__c_test_lenient_flags_22( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp) { + return (state->lenient_flags & 2) == 2; +} + +int llhttp__internal__c_or_flags_5( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp) { + state->flags |= 1; + return 0; +} + +int llhttp__internal__c_update_header_state( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp) { + state->header_state = 1; + return 0; +} + +int llhttp__on_header_value_complete( + llhttp__internal_t* s, const unsigned char* p, + const unsigned char* endp); + +int llhttp__internal__c_or_flags_6( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp) { + state->flags |= 2; + return 0; +} + +int llhttp__internal__c_or_flags_7( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp) { + state->flags |= 4; + return 0; +} + +int llhttp__internal__c_or_flags_8( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp) { + state->flags |= 8; + return 0; +} + +int llhttp__internal__c_update_header_state_3( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp) { + state->header_state = 6; + return 0; +} + +int llhttp__internal__c_update_header_state_1( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp) { + state->header_state = 0; + return 0; +} + +int llhttp__internal__c_update_header_state_6( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp) { + state->header_state = 5; + return 0; +} + +int llhttp__internal__c_update_header_state_7( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp) { + state->header_state = 7; + return 0; +} + +int llhttp__internal__c_test_flags_2( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp) { + return (state->flags & 32) == 32; +} + +int llhttp__internal__c_mul_add_content_length_1( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp, + int match) { + /* Multiplication overflow */ + if (state->content_length > 0xffffffffffffffffULL / 10) { + return 1; + } + + state->content_length *= 10; + + /* Addition overflow */ + if (match >= 0) { + if (state->content_length > 0xffffffffffffffffULL - match) { + return 1; + } + } else { + if (state->content_length < 0ULL - match) { + return 1; + } + } + state->content_length += match; + return 0; +} + +int llhttp__internal__c_or_flags_17( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp) { + state->flags |= 32; + return 0; +} + +int llhttp__internal__c_test_flags_3( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp) { + return (state->flags & 8) == 8; +} + +int llhttp__internal__c_test_lenient_flags_20( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp) { + return (state->lenient_flags & 8) == 8; +} + +int llhttp__internal__c_or_flags_18( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp) { + state->flags |= 512; + return 0; +} + +int llhttp__internal__c_and_flags( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp) { + state->flags &= -9; + return 0; +} + +int llhttp__internal__c_update_header_state_8( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp) { + state->header_state = 8; + return 0; +} + +int llhttp__internal__c_or_flags_20( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp) { + state->flags |= 16; + return 0; +} + +int llhttp__internal__c_load_method( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp) { + return state->method; +} + +int llhttp__internal__c_store_http_major( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp, + int match) { + state->http_major = match; + return 0; +} + +int llhttp__internal__c_store_http_minor( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp, + int match) { + state->http_minor = match; + return 0; +} + +int llhttp__internal__c_test_lenient_flags_24( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp) { + return (state->lenient_flags & 16) == 16; +} + +int llhttp__on_version_complete( + llhttp__internal_t* s, const unsigned char* p, + const unsigned char* endp); + +int llhttp__internal__c_load_http_major( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp) { + return state->http_major; +} + +int llhttp__internal__c_load_http_minor( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp) { + return state->http_minor; +} + +int llhttp__internal__c_update_status_code( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp) { + state->status_code = 0; + return 0; +} + +int llhttp__internal__c_mul_add_status_code( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp, + int match) { + /* Multiplication overflow */ + if (state->status_code > 0xffff / 10) { + return 1; + } + + state->status_code *= 10; + + /* Addition overflow */ + if (match >= 0) { + if (state->status_code > 0xffff - match) { + return 1; + } + } else { + if (state->status_code < 0 - match) { + return 1; + } + } + state->status_code += match; + return 0; +} + +int llhttp__on_status_complete( + llhttp__internal_t* s, const unsigned char* p, + const unsigned char* endp); + +int llhttp__internal__c_update_type( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp) { + state->type = 1; + return 0; +} + +int llhttp__internal__c_update_type_1( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp) { + state->type = 2; + return 0; +} + +int llhttp__internal_init(llhttp__internal_t* state) { + memset(state, 0, sizeof(*state)); + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_start; + return 0; +} + +static llparse_state_t llhttp__internal__run( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp) { + int match; + switch ((llparse_state_t) (intptr_t) state->_current) { + case s_n_llhttp__internal__n_closed: + s_n_llhttp__internal__n_closed: { + if (p == endp) { + return s_n_llhttp__internal__n_closed; + } + switch (*p) { + case 10: { + p++; + goto s_n_llhttp__internal__n_closed; + } + case 13: { + p++; + goto s_n_llhttp__internal__n_closed; + } + default: { + p++; + goto s_n_llhttp__internal__n_invoke_test_lenient_flags_3; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_invoke_llhttp__after_message_complete: + s_n_llhttp__internal__n_invoke_llhttp__after_message_complete: { + switch (llhttp__after_message_complete(state, p, endp)) { + case 1: + goto s_n_llhttp__internal__n_invoke_update_content_length; + default: + goto s_n_llhttp__internal__n_invoke_update_finish_1; + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_pause_1: + s_n_llhttp__internal__n_pause_1: { + state->error = 0x16; + state->reason = "Pause on CONNECT/Upgrade"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__after_message_complete; + return s_error; + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_invoke_is_equal_upgrade: + s_n_llhttp__internal__n_invoke_is_equal_upgrade: { + switch (llhttp__internal__c_is_equal_upgrade(state, p, endp)) { + case 0: + goto s_n_llhttp__internal__n_invoke_llhttp__after_message_complete; + default: + goto s_n_llhttp__internal__n_pause_1; + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_invoke_llhttp__on_message_complete_2: + s_n_llhttp__internal__n_invoke_llhttp__on_message_complete_2: { + switch (llhttp__on_message_complete(state, p, endp)) { + case 0: + goto s_n_llhttp__internal__n_invoke_is_equal_upgrade; + case 21: + goto s_n_llhttp__internal__n_pause_13; + default: + goto s_n_llhttp__internal__n_error_38; + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_chunk_data_almost_done_1: + s_n_llhttp__internal__n_chunk_data_almost_done_1: { + if (p == endp) { + return s_n_llhttp__internal__n_chunk_data_almost_done_1; + } + switch (*p) { + case 10: { + p++; + goto s_n_llhttp__internal__n_invoke_llhttp__on_chunk_complete; + } + default: { + goto s_n_llhttp__internal__n_invoke_test_lenient_flags_7; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_chunk_data_almost_done: + s_n_llhttp__internal__n_chunk_data_almost_done: { + if (p == endp) { + return s_n_llhttp__internal__n_chunk_data_almost_done; + } + switch (*p) { + case 10: { + p++; + goto s_n_llhttp__internal__n_invoke_test_lenient_flags_6; + } + case 13: { + p++; + goto s_n_llhttp__internal__n_chunk_data_almost_done_1; + } + default: { + goto s_n_llhttp__internal__n_invoke_test_lenient_flags_7; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_consume_content_length: + s_n_llhttp__internal__n_consume_content_length: { + size_t avail; + uint64_t need; + + avail = endp - p; + need = state->content_length; + if (avail >= need) { + p += need; + state->content_length = 0; + goto s_n_llhttp__internal__n_span_end_llhttp__on_body; + } + + state->content_length -= avail; + return s_n_llhttp__internal__n_consume_content_length; + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_span_start_llhttp__on_body: + s_n_llhttp__internal__n_span_start_llhttp__on_body: { + if (p == endp) { + return s_n_llhttp__internal__n_span_start_llhttp__on_body; + } + state->_span_pos0 = (void*) p; + state->_span_cb0 = llhttp__on_body; + goto s_n_llhttp__internal__n_consume_content_length; + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_invoke_is_equal_content_length: + s_n_llhttp__internal__n_invoke_is_equal_content_length: { + switch (llhttp__internal__c_is_equal_content_length(state, p, endp)) { + case 0: + goto s_n_llhttp__internal__n_span_start_llhttp__on_body; + default: + goto s_n_llhttp__internal__n_invoke_or_flags; + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_chunk_size_almost_done: + s_n_llhttp__internal__n_chunk_size_almost_done: { + if (p == endp) { + return s_n_llhttp__internal__n_chunk_size_almost_done; + } + switch (*p) { + case 10: { + p++; + goto s_n_llhttp__internal__n_invoke_llhttp__on_chunk_header; + } + default: { + goto s_n_llhttp__internal__n_invoke_test_lenient_flags_8; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_invoke_test_lenient_flags_9: + s_n_llhttp__internal__n_invoke_test_lenient_flags_9: { + switch (llhttp__internal__c_test_lenient_flags_1(state, p, endp)) { + case 1: + goto s_n_llhttp__internal__n_chunk_size_almost_done; + default: + goto s_n_llhttp__internal__n_error_20; + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_name_complete: + s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_name_complete: { + switch (llhttp__on_chunk_extension_name_complete(state, p, endp)) { + case 0: + goto s_n_llhttp__internal__n_invoke_test_lenient_flags_9; + case 21: + goto s_n_llhttp__internal__n_pause_5; + default: + goto s_n_llhttp__internal__n_error_19; + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_name_complete_1: + s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_name_complete_1: { + switch (llhttp__on_chunk_extension_name_complete(state, p, endp)) { + case 0: + goto s_n_llhttp__internal__n_chunk_size_almost_done; + case 21: + goto s_n_llhttp__internal__n_pause_6; + default: + goto s_n_llhttp__internal__n_error_21; + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_name_complete_2: + s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_name_complete_2: { + switch (llhttp__on_chunk_extension_name_complete(state, p, endp)) { + case 0: + goto s_n_llhttp__internal__n_chunk_extensions; + case 21: + goto s_n_llhttp__internal__n_pause_7; + default: + goto s_n_llhttp__internal__n_error_22; + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_invoke_test_lenient_flags_10: + s_n_llhttp__internal__n_invoke_test_lenient_flags_10: { + switch (llhttp__internal__c_test_lenient_flags_1(state, p, endp)) { + case 1: + goto s_n_llhttp__internal__n_chunk_size_almost_done; + default: + goto s_n_llhttp__internal__n_error_25; + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete: + s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete: { + switch (llhttp__on_chunk_extension_value_complete(state, p, endp)) { + case 0: + goto s_n_llhttp__internal__n_invoke_test_lenient_flags_10; + case 21: + goto s_n_llhttp__internal__n_pause_8; + default: + goto s_n_llhttp__internal__n_error_24; + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete_1: + s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete_1: { + switch (llhttp__on_chunk_extension_value_complete(state, p, endp)) { + case 0: + goto s_n_llhttp__internal__n_chunk_size_almost_done; + case 21: + goto s_n_llhttp__internal__n_pause_9; + default: + goto s_n_llhttp__internal__n_error_26; + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_chunk_extension_quoted_value_done: + s_n_llhttp__internal__n_chunk_extension_quoted_value_done: { + if (p == endp) { + return s_n_llhttp__internal__n_chunk_extension_quoted_value_done; + } + switch (*p) { + case 10: { + goto s_n_llhttp__internal__n_invoke_test_lenient_flags_11; + } + case 13: { + p++; + goto s_n_llhttp__internal__n_chunk_size_almost_done; + } + case ';': { + p++; + goto s_n_llhttp__internal__n_chunk_extensions; + } + default: { + goto s_n_llhttp__internal__n_error_29; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete_2: + s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete_2: { + switch (llhttp__on_chunk_extension_value_complete(state, p, endp)) { + case 0: + goto s_n_llhttp__internal__n_chunk_extension_quoted_value_done; + case 21: + goto s_n_llhttp__internal__n_pause_10; + default: + goto s_n_llhttp__internal__n_error_27; + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_error_30: + s_n_llhttp__internal__n_error_30: { + state->error = 0x2; + state->reason = "Invalid quoted-pair in chunk extensions quoted value"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_chunk_extension_quoted_value_quoted_pair: + s_n_llhttp__internal__n_chunk_extension_quoted_value_quoted_pair: { + static uint8_t lookup_table[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 + }; + if (p == endp) { + return s_n_llhttp__internal__n_chunk_extension_quoted_value_quoted_pair; + } + switch (lookup_table[(uint8_t) *p]) { + case 1: { + p++; + goto s_n_llhttp__internal__n_chunk_extension_quoted_value; + } + default: { + goto s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_value_3; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_error_31: + s_n_llhttp__internal__n_error_31: { + state->error = 0x2; + state->reason = "Invalid character in chunk extensions quoted value"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_chunk_extension_quoted_value: + s_n_llhttp__internal__n_chunk_extension_quoted_value: { + static uint8_t lookup_table[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 + }; + if (p == endp) { + return s_n_llhttp__internal__n_chunk_extension_quoted_value; + } + switch (lookup_table[(uint8_t) *p]) { + case 1: { + p++; + goto s_n_llhttp__internal__n_chunk_extension_quoted_value; + } + case 2: { + p++; + goto s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_value_2; + } + case 3: { + p++; + goto s_n_llhttp__internal__n_chunk_extension_quoted_value_quoted_pair; + } + default: { + goto s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_value_4; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete_3: + s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete_3: { + switch (llhttp__on_chunk_extension_value_complete(state, p, endp)) { + case 0: + goto s_n_llhttp__internal__n_chunk_extensions; + case 21: + goto s_n_llhttp__internal__n_pause_11; + default: + goto s_n_llhttp__internal__n_error_32; + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_error_33: + s_n_llhttp__internal__n_error_33: { + state->error = 0x2; + state->reason = "Invalid character in chunk extensions value"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_chunk_extension_value: + s_n_llhttp__internal__n_chunk_extension_value: { + static uint8_t lookup_table[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 2, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3, 4, 3, 3, 3, 3, 3, 0, 0, 3, 3, 0, 3, 3, 0, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 5, 0, 0, 0, 0, + 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 3, 0, 3, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 + }; + if (p == endp) { + return s_n_llhttp__internal__n_chunk_extension_value; + } + switch (lookup_table[(uint8_t) *p]) { + case 1: { + goto s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_value; + } + case 2: { + goto s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_value_1; + } + case 3: { + p++; + goto s_n_llhttp__internal__n_chunk_extension_value; + } + case 4: { + p++; + goto s_n_llhttp__internal__n_chunk_extension_quoted_value; + } + case 5: { + goto s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_value_5; + } + default: { + goto s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_value_6; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_span_start_llhttp__on_chunk_extension_value: + s_n_llhttp__internal__n_span_start_llhttp__on_chunk_extension_value: { + if (p == endp) { + return s_n_llhttp__internal__n_span_start_llhttp__on_chunk_extension_value; + } + state->_span_pos0 = (void*) p; + state->_span_cb0 = llhttp__on_chunk_extension_value; + goto s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_name_complete_3; + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_error_34: + s_n_llhttp__internal__n_error_34: { + state->error = 0x2; + state->reason = "Invalid character in chunk extensions name"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_chunk_extension_name: + s_n_llhttp__internal__n_chunk_extension_name: { + static uint8_t lookup_table[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 2, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3, 0, 3, 3, 3, 3, 3, 0, 0, 3, 3, 0, 3, 3, 0, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 4, 0, 5, 0, 0, + 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 3, 0, 3, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 + }; + if (p == endp) { + return s_n_llhttp__internal__n_chunk_extension_name; + } + switch (lookup_table[(uint8_t) *p]) { + case 1: { + goto s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_name; + } + case 2: { + goto s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_name_1; + } + case 3: { + p++; + goto s_n_llhttp__internal__n_chunk_extension_name; + } + case 4: { + goto s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_name_2; + } + case 5: { + goto s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_name_3; + } + default: { + goto s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_name_4; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_span_start_llhttp__on_chunk_extension_name: + s_n_llhttp__internal__n_span_start_llhttp__on_chunk_extension_name: { + if (p == endp) { + return s_n_llhttp__internal__n_span_start_llhttp__on_chunk_extension_name; + } + state->_span_pos0 = (void*) p; + state->_span_cb0 = llhttp__on_chunk_extension_name; + goto s_n_llhttp__internal__n_chunk_extension_name; + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_chunk_extensions: + s_n_llhttp__internal__n_chunk_extensions: { + if (p == endp) { + return s_n_llhttp__internal__n_chunk_extensions; + } + switch (*p) { + case 13: { + p++; + goto s_n_llhttp__internal__n_error_17; + } + case ' ': { + p++; + goto s_n_llhttp__internal__n_error_18; + } + default: { + goto s_n_llhttp__internal__n_span_start_llhttp__on_chunk_extension_name; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_chunk_size_otherwise: + s_n_llhttp__internal__n_chunk_size_otherwise: { + if (p == endp) { + return s_n_llhttp__internal__n_chunk_size_otherwise; + } + switch (*p) { + case 9: { + p++; + goto s_n_llhttp__internal__n_invoke_test_lenient_flags_4; + } + case 10: { + p++; + goto s_n_llhttp__internal__n_invoke_test_lenient_flags_5; + } + case 13: { + p++; + goto s_n_llhttp__internal__n_chunk_size_almost_done; + } + case ' ': { + p++; + goto s_n_llhttp__internal__n_invoke_test_lenient_flags_4; + } + case ';': { + p++; + goto s_n_llhttp__internal__n_chunk_extensions; + } + default: { + goto s_n_llhttp__internal__n_error_35; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_chunk_size: + s_n_llhttp__internal__n_chunk_size: { + if (p == endp) { + return s_n_llhttp__internal__n_chunk_size; + } + switch (*p) { + case '0': { + p++; + match = 0; + goto s_n_llhttp__internal__n_invoke_mul_add_content_length; + } + case '1': { + p++; + match = 1; + goto s_n_llhttp__internal__n_invoke_mul_add_content_length; + } + case '2': { + p++; + match = 2; + goto s_n_llhttp__internal__n_invoke_mul_add_content_length; + } + case '3': { + p++; + match = 3; + goto s_n_llhttp__internal__n_invoke_mul_add_content_length; + } + case '4': { + p++; + match = 4; + goto s_n_llhttp__internal__n_invoke_mul_add_content_length; + } + case '5': { + p++; + match = 5; + goto s_n_llhttp__internal__n_invoke_mul_add_content_length; + } + case '6': { + p++; + match = 6; + goto s_n_llhttp__internal__n_invoke_mul_add_content_length; + } + case '7': { + p++; + match = 7; + goto s_n_llhttp__internal__n_invoke_mul_add_content_length; + } + case '8': { + p++; + match = 8; + goto s_n_llhttp__internal__n_invoke_mul_add_content_length; + } + case '9': { + p++; + match = 9; + goto s_n_llhttp__internal__n_invoke_mul_add_content_length; + } + case 'A': { + p++; + match = 10; + goto s_n_llhttp__internal__n_invoke_mul_add_content_length; + } + case 'B': { + p++; + match = 11; + goto s_n_llhttp__internal__n_invoke_mul_add_content_length; + } + case 'C': { + p++; + match = 12; + goto s_n_llhttp__internal__n_invoke_mul_add_content_length; + } + case 'D': { + p++; + match = 13; + goto s_n_llhttp__internal__n_invoke_mul_add_content_length; + } + case 'E': { + p++; + match = 14; + goto s_n_llhttp__internal__n_invoke_mul_add_content_length; + } + case 'F': { + p++; + match = 15; + goto s_n_llhttp__internal__n_invoke_mul_add_content_length; + } + case 'a': { + p++; + match = 10; + goto s_n_llhttp__internal__n_invoke_mul_add_content_length; + } + case 'b': { + p++; + match = 11; + goto s_n_llhttp__internal__n_invoke_mul_add_content_length; + } + case 'c': { + p++; + match = 12; + goto s_n_llhttp__internal__n_invoke_mul_add_content_length; + } + case 'd': { + p++; + match = 13; + goto s_n_llhttp__internal__n_invoke_mul_add_content_length; + } + case 'e': { + p++; + match = 14; + goto s_n_llhttp__internal__n_invoke_mul_add_content_length; + } + case 'f': { + p++; + match = 15; + goto s_n_llhttp__internal__n_invoke_mul_add_content_length; + } + default: { + goto s_n_llhttp__internal__n_chunk_size_otherwise; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_chunk_size_digit: + s_n_llhttp__internal__n_chunk_size_digit: { + if (p == endp) { + return s_n_llhttp__internal__n_chunk_size_digit; + } + switch (*p) { + case '0': { + p++; + match = 0; + goto s_n_llhttp__internal__n_invoke_mul_add_content_length; + } + case '1': { + p++; + match = 1; + goto s_n_llhttp__internal__n_invoke_mul_add_content_length; + } + case '2': { + p++; + match = 2; + goto s_n_llhttp__internal__n_invoke_mul_add_content_length; + } + case '3': { + p++; + match = 3; + goto s_n_llhttp__internal__n_invoke_mul_add_content_length; + } + case '4': { + p++; + match = 4; + goto s_n_llhttp__internal__n_invoke_mul_add_content_length; + } + case '5': { + p++; + match = 5; + goto s_n_llhttp__internal__n_invoke_mul_add_content_length; + } + case '6': { + p++; + match = 6; + goto s_n_llhttp__internal__n_invoke_mul_add_content_length; + } + case '7': { + p++; + match = 7; + goto s_n_llhttp__internal__n_invoke_mul_add_content_length; + } + case '8': { + p++; + match = 8; + goto s_n_llhttp__internal__n_invoke_mul_add_content_length; + } + case '9': { + p++; + match = 9; + goto s_n_llhttp__internal__n_invoke_mul_add_content_length; + } + case 'A': { + p++; + match = 10; + goto s_n_llhttp__internal__n_invoke_mul_add_content_length; + } + case 'B': { + p++; + match = 11; + goto s_n_llhttp__internal__n_invoke_mul_add_content_length; + } + case 'C': { + p++; + match = 12; + goto s_n_llhttp__internal__n_invoke_mul_add_content_length; + } + case 'D': { + p++; + match = 13; + goto s_n_llhttp__internal__n_invoke_mul_add_content_length; + } + case 'E': { + p++; + match = 14; + goto s_n_llhttp__internal__n_invoke_mul_add_content_length; + } + case 'F': { + p++; + match = 15; + goto s_n_llhttp__internal__n_invoke_mul_add_content_length; + } + case 'a': { + p++; + match = 10; + goto s_n_llhttp__internal__n_invoke_mul_add_content_length; + } + case 'b': { + p++; + match = 11; + goto s_n_llhttp__internal__n_invoke_mul_add_content_length; + } + case 'c': { + p++; + match = 12; + goto s_n_llhttp__internal__n_invoke_mul_add_content_length; + } + case 'd': { + p++; + match = 13; + goto s_n_llhttp__internal__n_invoke_mul_add_content_length; + } + case 'e': { + p++; + match = 14; + goto s_n_llhttp__internal__n_invoke_mul_add_content_length; + } + case 'f': { + p++; + match = 15; + goto s_n_llhttp__internal__n_invoke_mul_add_content_length; + } + default: { + goto s_n_llhttp__internal__n_error_37; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_invoke_update_content_length_1: + s_n_llhttp__internal__n_invoke_update_content_length_1: { + switch (llhttp__internal__c_update_content_length(state, p, endp)) { + default: + goto s_n_llhttp__internal__n_chunk_size_digit; + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_consume_content_length_1: + s_n_llhttp__internal__n_consume_content_length_1: { + size_t avail; + uint64_t need; + + avail = endp - p; + need = state->content_length; + if (avail >= need) { + p += need; + state->content_length = 0; + goto s_n_llhttp__internal__n_span_end_llhttp__on_body_1; + } + + state->content_length -= avail; + return s_n_llhttp__internal__n_consume_content_length_1; + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_span_start_llhttp__on_body_1: + s_n_llhttp__internal__n_span_start_llhttp__on_body_1: { + if (p == endp) { + return s_n_llhttp__internal__n_span_start_llhttp__on_body_1; + } + state->_span_pos0 = (void*) p; + state->_span_cb0 = llhttp__on_body; + goto s_n_llhttp__internal__n_consume_content_length_1; + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_eof: + s_n_llhttp__internal__n_eof: { + if (p == endp) { + return s_n_llhttp__internal__n_eof; + } + p++; + goto s_n_llhttp__internal__n_eof; + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_span_start_llhttp__on_body_2: + s_n_llhttp__internal__n_span_start_llhttp__on_body_2: { + if (p == endp) { + return s_n_llhttp__internal__n_span_start_llhttp__on_body_2; + } + state->_span_pos0 = (void*) p; + state->_span_cb0 = llhttp__on_body; + goto s_n_llhttp__internal__n_eof; + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_invoke_llhttp__after_headers_complete: + s_n_llhttp__internal__n_invoke_llhttp__after_headers_complete: { + switch (llhttp__after_headers_complete(state, p, endp)) { + case 1: + goto s_n_llhttp__internal__n_invoke_llhttp__on_message_complete_1; + case 2: + goto s_n_llhttp__internal__n_invoke_update_content_length_1; + case 3: + goto s_n_llhttp__internal__n_span_start_llhttp__on_body_1; + case 4: + goto s_n_llhttp__internal__n_invoke_update_finish_3; + case 5: + goto s_n_llhttp__internal__n_error_39; + default: + goto s_n_llhttp__internal__n_invoke_llhttp__on_message_complete; + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_error_5: + s_n_llhttp__internal__n_error_5: { + state->error = 0xa; + state->reason = "Invalid header field char"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_headers_almost_done: + s_n_llhttp__internal__n_headers_almost_done: { + if (p == endp) { + return s_n_llhttp__internal__n_headers_almost_done; + } + switch (*p) { + case 10: { + p++; + goto s_n_llhttp__internal__n_invoke_test_flags_1; + } + default: { + goto s_n_llhttp__internal__n_invoke_test_lenient_flags_12; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_header_field_colon_discard_ws: + s_n_llhttp__internal__n_header_field_colon_discard_ws: { + if (p == endp) { + return s_n_llhttp__internal__n_header_field_colon_discard_ws; + } + switch (*p) { + case ' ': { + p++; + goto s_n_llhttp__internal__n_header_field_colon_discard_ws; + } + default: { + goto s_n_llhttp__internal__n_header_field_colon; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_invoke_llhttp__on_header_value_complete: + s_n_llhttp__internal__n_invoke_llhttp__on_header_value_complete: { + switch (llhttp__on_header_value_complete(state, p, endp)) { + case 0: + goto s_n_llhttp__internal__n_header_field_start; + case 21: + goto s_n_llhttp__internal__n_pause_18; + default: + goto s_n_llhttp__internal__n_error_48; + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_span_start_llhttp__on_header_value: + s_n_llhttp__internal__n_span_start_llhttp__on_header_value: { + if (p == endp) { + return s_n_llhttp__internal__n_span_start_llhttp__on_header_value; + } + state->_span_pos0 = (void*) p; + state->_span_cb0 = llhttp__on_header_value; + goto s_n_llhttp__internal__n_span_end_llhttp__on_header_value; + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_header_value_discard_lws: + s_n_llhttp__internal__n_header_value_discard_lws: { + if (p == endp) { + return s_n_llhttp__internal__n_header_value_discard_lws; + } + switch (*p) { + case 9: { + p++; + goto s_n_llhttp__internal__n_invoke_test_lenient_flags_15; + } + case ' ': { + p++; + goto s_n_llhttp__internal__n_invoke_test_lenient_flags_15; + } + default: { + goto s_n_llhttp__internal__n_invoke_load_header_state_1; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_header_value_discard_ws_almost_done: + s_n_llhttp__internal__n_header_value_discard_ws_almost_done: { + if (p == endp) { + return s_n_llhttp__internal__n_header_value_discard_ws_almost_done; + } + switch (*p) { + case 10: { + p++; + goto s_n_llhttp__internal__n_header_value_discard_lws; + } + default: { + goto s_n_llhttp__internal__n_invoke_test_lenient_flags_16; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_header_value_lws: + s_n_llhttp__internal__n_header_value_lws: { + if (p == endp) { + return s_n_llhttp__internal__n_header_value_lws; + } + switch (*p) { + case 9: { + goto s_n_llhttp__internal__n_invoke_test_lenient_flags_18; + } + case ' ': { + goto s_n_llhttp__internal__n_invoke_test_lenient_flags_18; + } + default: { + goto s_n_llhttp__internal__n_invoke_load_header_state_5; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_header_value_almost_done: + s_n_llhttp__internal__n_header_value_almost_done: { + if (p == endp) { + return s_n_llhttp__internal__n_header_value_almost_done; + } + switch (*p) { + case 10: { + p++; + goto s_n_llhttp__internal__n_header_value_lws; + } + default: { + goto s_n_llhttp__internal__n_error_53; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_invoke_test_lenient_flags_17: + s_n_llhttp__internal__n_invoke_test_lenient_flags_17: { + switch (llhttp__internal__c_test_lenient_flags_1(state, p, endp)) { + case 1: + goto s_n_llhttp__internal__n_header_value_almost_done; + default: + goto s_n_llhttp__internal__n_error_51; + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_header_value_lenient: + s_n_llhttp__internal__n_header_value_lenient: { + if (p == endp) { + return s_n_llhttp__internal__n_header_value_lenient; + } + switch (*p) { + case 10: { + goto s_n_llhttp__internal__n_span_end_llhttp__on_header_value_4; + } + case 13: { + goto s_n_llhttp__internal__n_span_end_llhttp__on_header_value_5; + } + default: { + p++; + goto s_n_llhttp__internal__n_header_value_lenient; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_error_54: + s_n_llhttp__internal__n_error_54: { + state->error = 0xa; + state->reason = "Invalid header value char"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_header_value_otherwise: + s_n_llhttp__internal__n_header_value_otherwise: { + if (p == endp) { + return s_n_llhttp__internal__n_header_value_otherwise; + } + switch (*p) { + case 10: { + goto s_n_llhttp__internal__n_span_end_llhttp__on_header_value_1; + } + case 13: { + goto s_n_llhttp__internal__n_span_end_llhttp__on_header_value_2; + } + default: { + goto s_n_llhttp__internal__n_invoke_test_lenient_flags_19; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_header_value_connection_token: + s_n_llhttp__internal__n_header_value_connection_token: { + static uint8_t lookup_table[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 + }; + if (p == endp) { + return s_n_llhttp__internal__n_header_value_connection_token; + } + switch (lookup_table[(uint8_t) *p]) { + case 1: { + p++; + goto s_n_llhttp__internal__n_header_value_connection_token; + } + case 2: { + p++; + goto s_n_llhttp__internal__n_header_value_connection; + } + default: { + goto s_n_llhttp__internal__n_header_value_otherwise; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_header_value_connection_ws: + s_n_llhttp__internal__n_header_value_connection_ws: { + if (p == endp) { + return s_n_llhttp__internal__n_header_value_connection_ws; + } + switch (*p) { + case 10: { + goto s_n_llhttp__internal__n_header_value_otherwise; + } + case 13: { + goto s_n_llhttp__internal__n_header_value_otherwise; + } + case ' ': { + p++; + goto s_n_llhttp__internal__n_header_value_connection_ws; + } + case ',': { + p++; + goto s_n_llhttp__internal__n_invoke_load_header_state_6; + } + default: { + goto s_n_llhttp__internal__n_invoke_update_header_state_5; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_header_value_connection_1: + s_n_llhttp__internal__n_header_value_connection_1: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_header_value_connection_1; + } + match_seq = llparse__match_sequence_to_lower(state, p, endp, llparse_blob2, 4); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + goto s_n_llhttp__internal__n_invoke_update_header_state_3; + } + case kMatchPause: { + return s_n_llhttp__internal__n_header_value_connection_1; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_header_value_connection_token; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_header_value_connection_2: + s_n_llhttp__internal__n_header_value_connection_2: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_header_value_connection_2; + } + match_seq = llparse__match_sequence_to_lower(state, p, endp, llparse_blob3, 9); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + goto s_n_llhttp__internal__n_invoke_update_header_state_6; + } + case kMatchPause: { + return s_n_llhttp__internal__n_header_value_connection_2; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_header_value_connection_token; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_header_value_connection_3: + s_n_llhttp__internal__n_header_value_connection_3: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_header_value_connection_3; + } + match_seq = llparse__match_sequence_to_lower(state, p, endp, llparse_blob4, 6); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + goto s_n_llhttp__internal__n_invoke_update_header_state_7; + } + case kMatchPause: { + return s_n_llhttp__internal__n_header_value_connection_3; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_header_value_connection_token; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_header_value_connection: + s_n_llhttp__internal__n_header_value_connection: { + if (p == endp) { + return s_n_llhttp__internal__n_header_value_connection; + } + switch (((*p) >= 'A' && (*p) <= 'Z' ? (*p | 0x20) : (*p))) { + case 9: { + p++; + goto s_n_llhttp__internal__n_header_value_connection; + } + case ' ': { + p++; + goto s_n_llhttp__internal__n_header_value_connection; + } + case 'c': { + p++; + goto s_n_llhttp__internal__n_header_value_connection_1; + } + case 'k': { + p++; + goto s_n_llhttp__internal__n_header_value_connection_2; + } + case 'u': { + p++; + goto s_n_llhttp__internal__n_header_value_connection_3; + } + default: { + goto s_n_llhttp__internal__n_header_value_connection_token; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_error_56: + s_n_llhttp__internal__n_error_56: { + state->error = 0xb; + state->reason = "Content-Length overflow"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_error_57: + s_n_llhttp__internal__n_error_57: { + state->error = 0xb; + state->reason = "Invalid character in Content-Length"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_header_value_content_length_ws: + s_n_llhttp__internal__n_header_value_content_length_ws: { + if (p == endp) { + return s_n_llhttp__internal__n_header_value_content_length_ws; + } + switch (*p) { + case 10: { + goto s_n_llhttp__internal__n_invoke_or_flags_17; + } + case 13: { + goto s_n_llhttp__internal__n_invoke_or_flags_17; + } + case ' ': { + p++; + goto s_n_llhttp__internal__n_header_value_content_length_ws; + } + default: { + goto s_n_llhttp__internal__n_span_end_llhttp__on_header_value_7; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_header_value_content_length: + s_n_llhttp__internal__n_header_value_content_length: { + if (p == endp) { + return s_n_llhttp__internal__n_header_value_content_length; + } + switch (*p) { + case '0': { + p++; + match = 0; + goto s_n_llhttp__internal__n_invoke_mul_add_content_length_1; + } + case '1': { + p++; + match = 1; + goto s_n_llhttp__internal__n_invoke_mul_add_content_length_1; + } + case '2': { + p++; + match = 2; + goto s_n_llhttp__internal__n_invoke_mul_add_content_length_1; + } + case '3': { + p++; + match = 3; + goto s_n_llhttp__internal__n_invoke_mul_add_content_length_1; + } + case '4': { + p++; + match = 4; + goto s_n_llhttp__internal__n_invoke_mul_add_content_length_1; + } + case '5': { + p++; + match = 5; + goto s_n_llhttp__internal__n_invoke_mul_add_content_length_1; + } + case '6': { + p++; + match = 6; + goto s_n_llhttp__internal__n_invoke_mul_add_content_length_1; + } + case '7': { + p++; + match = 7; + goto s_n_llhttp__internal__n_invoke_mul_add_content_length_1; + } + case '8': { + p++; + match = 8; + goto s_n_llhttp__internal__n_invoke_mul_add_content_length_1; + } + case '9': { + p++; + match = 9; + goto s_n_llhttp__internal__n_invoke_mul_add_content_length_1; + } + default: { + goto s_n_llhttp__internal__n_header_value_content_length_ws; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_error_59: + s_n_llhttp__internal__n_error_59: { + state->error = 0xf; + state->reason = "Invalid `Transfer-Encoding` header value"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_error_58: + s_n_llhttp__internal__n_error_58: { + state->error = 0xf; + state->reason = "Invalid `Transfer-Encoding` header value"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_header_value_te_token_ows: + s_n_llhttp__internal__n_header_value_te_token_ows: { + if (p == endp) { + return s_n_llhttp__internal__n_header_value_te_token_ows; + } + switch (*p) { + case 9: { + p++; + goto s_n_llhttp__internal__n_header_value_te_token_ows; + } + case ' ': { + p++; + goto s_n_llhttp__internal__n_header_value_te_token_ows; + } + default: { + goto s_n_llhttp__internal__n_header_value_te_chunked; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_header_value: + s_n_llhttp__internal__n_header_value: { + static uint8_t lookup_table[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 + }; + if (p == endp) { + return s_n_llhttp__internal__n_header_value; + } + #ifdef __SSE4_2__ + if (endp - p >= 16) { + __m128i ranges; + __m128i input; + int avail; + int match_len; + + /* Load input */ + input = _mm_loadu_si128((__m128i const*) p); + ranges = _mm_loadu_si128((__m128i const*) llparse_blob6); + + /* Find first character that does not match `ranges` */ + match_len = _mm_cmpestri(ranges, 6, + input, 16, + _SIDD_UBYTE_OPS | _SIDD_CMP_RANGES | + _SIDD_NEGATIVE_POLARITY); + + if (match_len != 0) { + p += match_len; + goto s_n_llhttp__internal__n_header_value; + } + goto s_n_llhttp__internal__n_header_value_otherwise; + } + #endif /* __SSE4_2__ */ + switch (lookup_table[(uint8_t) *p]) { + case 1: { + p++; + goto s_n_llhttp__internal__n_header_value; + } + default: { + goto s_n_llhttp__internal__n_header_value_otherwise; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_header_value_te_token: + s_n_llhttp__internal__n_header_value_te_token: { + static uint8_t lookup_table[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 + }; + if (p == endp) { + return s_n_llhttp__internal__n_header_value_te_token; + } + switch (lookup_table[(uint8_t) *p]) { + case 1: { + p++; + goto s_n_llhttp__internal__n_header_value_te_token; + } + case 2: { + p++; + goto s_n_llhttp__internal__n_header_value_te_token_ows; + } + default: { + goto s_n_llhttp__internal__n_invoke_update_header_state_9; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_header_value_te_chunked_last: + s_n_llhttp__internal__n_header_value_te_chunked_last: { + if (p == endp) { + return s_n_llhttp__internal__n_header_value_te_chunked_last; + } + switch (*p) { + case 10: { + goto s_n_llhttp__internal__n_invoke_update_header_state_8; + } + case 13: { + goto s_n_llhttp__internal__n_invoke_update_header_state_8; + } + case ' ': { + p++; + goto s_n_llhttp__internal__n_header_value_te_chunked_last; + } + case ',': { + goto s_n_llhttp__internal__n_invoke_load_type_1; + } + default: { + goto s_n_llhttp__internal__n_header_value_te_token; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_header_value_te_chunked: + s_n_llhttp__internal__n_header_value_te_chunked: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_header_value_te_chunked; + } + match_seq = llparse__match_sequence_to_lower_unsafe(state, p, endp, llparse_blob5, 7); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + goto s_n_llhttp__internal__n_header_value_te_chunked_last; + } + case kMatchPause: { + return s_n_llhttp__internal__n_header_value_te_chunked; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_header_value_te_token; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_span_start_llhttp__on_header_value_1: + s_n_llhttp__internal__n_span_start_llhttp__on_header_value_1: { + if (p == endp) { + return s_n_llhttp__internal__n_span_start_llhttp__on_header_value_1; + } + state->_span_pos0 = (void*) p; + state->_span_cb0 = llhttp__on_header_value; + goto s_n_llhttp__internal__n_invoke_load_header_state_3; + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_header_value_discard_ws: + s_n_llhttp__internal__n_header_value_discard_ws: { + if (p == endp) { + return s_n_llhttp__internal__n_header_value_discard_ws; + } + switch (*p) { + case 9: { + p++; + goto s_n_llhttp__internal__n_header_value_discard_ws; + } + case 10: { + p++; + goto s_n_llhttp__internal__n_invoke_test_lenient_flags_14; + } + case 13: { + p++; + goto s_n_llhttp__internal__n_header_value_discard_ws_almost_done; + } + case ' ': { + p++; + goto s_n_llhttp__internal__n_header_value_discard_ws; + } + default: { + goto s_n_llhttp__internal__n_span_start_llhttp__on_header_value_1; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_invoke_load_header_state: + s_n_llhttp__internal__n_invoke_load_header_state: { + switch (llhttp__internal__c_load_header_state(state, p, endp)) { + case 2: + goto s_n_llhttp__internal__n_invoke_test_flags_4; + case 3: + goto s_n_llhttp__internal__n_invoke_test_flags_5; + default: + goto s_n_llhttp__internal__n_header_value_discard_ws; + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_invoke_llhttp__on_header_field_complete: + s_n_llhttp__internal__n_invoke_llhttp__on_header_field_complete: { + switch (llhttp__on_header_field_complete(state, p, endp)) { + case 0: + goto s_n_llhttp__internal__n_invoke_load_header_state; + case 21: + goto s_n_llhttp__internal__n_pause_19; + default: + goto s_n_llhttp__internal__n_error_45; + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_header_field_general_otherwise: + s_n_llhttp__internal__n_header_field_general_otherwise: { + if (p == endp) { + return s_n_llhttp__internal__n_header_field_general_otherwise; + } + switch (*p) { + case ':': { + goto s_n_llhttp__internal__n_span_end_llhttp__on_header_field_2; + } + default: { + goto s_n_llhttp__internal__n_error_62; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_header_field_general: + s_n_llhttp__internal__n_header_field_general: { + static uint8_t lookup_table[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 + }; + if (p == endp) { + return s_n_llhttp__internal__n_header_field_general; + } + #ifdef __SSE4_2__ + if (endp - p >= 16) { + __m128i ranges; + __m128i input; + int avail; + int match_len; + + /* Load input */ + input = _mm_loadu_si128((__m128i const*) p); + ranges = _mm_loadu_si128((__m128i const*) llparse_blob7); + + /* Find first character that does not match `ranges` */ + match_len = _mm_cmpestri(ranges, 16, + input, 16, + _SIDD_UBYTE_OPS | _SIDD_CMP_RANGES | + _SIDD_NEGATIVE_POLARITY); + + if (match_len != 0) { + p += match_len; + goto s_n_llhttp__internal__n_header_field_general; + } + ranges = _mm_loadu_si128((__m128i const*) llparse_blob8); + + /* Find first character that does not match `ranges` */ + match_len = _mm_cmpestri(ranges, 2, + input, 16, + _SIDD_UBYTE_OPS | _SIDD_CMP_RANGES | + _SIDD_NEGATIVE_POLARITY); + + if (match_len != 0) { + p += match_len; + goto s_n_llhttp__internal__n_header_field_general; + } + goto s_n_llhttp__internal__n_header_field_general_otherwise; + } + #endif /* __SSE4_2__ */ + switch (lookup_table[(uint8_t) *p]) { + case 1: { + p++; + goto s_n_llhttp__internal__n_header_field_general; + } + default: { + goto s_n_llhttp__internal__n_header_field_general_otherwise; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_header_field_colon: + s_n_llhttp__internal__n_header_field_colon: { + if (p == endp) { + return s_n_llhttp__internal__n_header_field_colon; + } + switch (*p) { + case ' ': { + goto s_n_llhttp__internal__n_invoke_test_lenient_flags_13; + } + case ':': { + goto s_n_llhttp__internal__n_span_end_llhttp__on_header_field_1; + } + default: { + goto s_n_llhttp__internal__n_invoke_update_header_state_10; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_header_field_3: + s_n_llhttp__internal__n_header_field_3: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_header_field_3; + } + match_seq = llparse__match_sequence_to_lower(state, p, endp, llparse_blob1, 6); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + match = 1; + goto s_n_llhttp__internal__n_invoke_store_header_state; + } + case kMatchPause: { + return s_n_llhttp__internal__n_header_field_3; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_invoke_update_header_state_11; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_header_field_4: + s_n_llhttp__internal__n_header_field_4: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_header_field_4; + } + match_seq = llparse__match_sequence_to_lower(state, p, endp, llparse_blob9, 10); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + match = 2; + goto s_n_llhttp__internal__n_invoke_store_header_state; + } + case kMatchPause: { + return s_n_llhttp__internal__n_header_field_4; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_invoke_update_header_state_11; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_header_field_2: + s_n_llhttp__internal__n_header_field_2: { + if (p == endp) { + return s_n_llhttp__internal__n_header_field_2; + } + switch (((*p) >= 'A' && (*p) <= 'Z' ? (*p | 0x20) : (*p))) { + case 'n': { + p++; + goto s_n_llhttp__internal__n_header_field_3; + } + case 't': { + p++; + goto s_n_llhttp__internal__n_header_field_4; + } + default: { + goto s_n_llhttp__internal__n_invoke_update_header_state_11; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_header_field_1: + s_n_llhttp__internal__n_header_field_1: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_header_field_1; + } + match_seq = llparse__match_sequence_to_lower(state, p, endp, llparse_blob0, 2); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + goto s_n_llhttp__internal__n_header_field_2; + } + case kMatchPause: { + return s_n_llhttp__internal__n_header_field_1; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_invoke_update_header_state_11; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_header_field_5: + s_n_llhttp__internal__n_header_field_5: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_header_field_5; + } + match_seq = llparse__match_sequence_to_lower(state, p, endp, llparse_blob10, 15); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + match = 1; + goto s_n_llhttp__internal__n_invoke_store_header_state; + } + case kMatchPause: { + return s_n_llhttp__internal__n_header_field_5; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_invoke_update_header_state_11; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_header_field_6: + s_n_llhttp__internal__n_header_field_6: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_header_field_6; + } + match_seq = llparse__match_sequence_to_lower(state, p, endp, llparse_blob11, 16); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + match = 3; + goto s_n_llhttp__internal__n_invoke_store_header_state; + } + case kMatchPause: { + return s_n_llhttp__internal__n_header_field_6; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_invoke_update_header_state_11; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_header_field_7: + s_n_llhttp__internal__n_header_field_7: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_header_field_7; + } + match_seq = llparse__match_sequence_to_lower(state, p, endp, llparse_blob12, 6); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + match = 4; + goto s_n_llhttp__internal__n_invoke_store_header_state; + } + case kMatchPause: { + return s_n_llhttp__internal__n_header_field_7; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_invoke_update_header_state_11; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_header_field: + s_n_llhttp__internal__n_header_field: { + if (p == endp) { + return s_n_llhttp__internal__n_header_field; + } + switch (((*p) >= 'A' && (*p) <= 'Z' ? (*p | 0x20) : (*p))) { + case 'c': { + p++; + goto s_n_llhttp__internal__n_header_field_1; + } + case 'p': { + p++; + goto s_n_llhttp__internal__n_header_field_5; + } + case 't': { + p++; + goto s_n_llhttp__internal__n_header_field_6; + } + case 'u': { + p++; + goto s_n_llhttp__internal__n_header_field_7; + } + default: { + goto s_n_llhttp__internal__n_invoke_update_header_state_11; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_span_start_llhttp__on_header_field: + s_n_llhttp__internal__n_span_start_llhttp__on_header_field: { + if (p == endp) { + return s_n_llhttp__internal__n_span_start_llhttp__on_header_field; + } + state->_span_pos0 = (void*) p; + state->_span_cb0 = llhttp__on_header_field; + goto s_n_llhttp__internal__n_header_field; + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_header_field_start: + s_n_llhttp__internal__n_header_field_start: { + if (p == endp) { + return s_n_llhttp__internal__n_header_field_start; + } + switch (*p) { + case 10: { + p++; + goto s_n_llhttp__internal__n_invoke_test_lenient_flags_1; + } + case 13: { + p++; + goto s_n_llhttp__internal__n_headers_almost_done; + } + case ':': { + goto s_n_llhttp__internal__n_error_44; + } + default: { + goto s_n_llhttp__internal__n_span_start_llhttp__on_header_field; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_headers_start: + s_n_llhttp__internal__n_headers_start: { + if (p == endp) { + return s_n_llhttp__internal__n_headers_start; + } + switch (*p) { + case ' ': { + p++; + goto s_n_llhttp__internal__n_invoke_test_lenient_flags; + } + default: { + goto s_n_llhttp__internal__n_header_field_start; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_url_to_http_09: + s_n_llhttp__internal__n_url_to_http_09: { + if (p == endp) { + return s_n_llhttp__internal__n_url_to_http_09; + } + switch (*p) { + case 9: { + p++; + goto s_n_llhttp__internal__n_error_2; + } + case 12: { + p++; + goto s_n_llhttp__internal__n_error_2; + } + default: { + goto s_n_llhttp__internal__n_invoke_update_http_major; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_url_skip_to_http09: + s_n_llhttp__internal__n_url_skip_to_http09: { + if (p == endp) { + return s_n_llhttp__internal__n_url_skip_to_http09; + } + switch (*p) { + case 9: { + p++; + goto s_n_llhttp__internal__n_error_2; + } + case 12: { + p++; + goto s_n_llhttp__internal__n_error_2; + } + default: { + p++; + goto s_n_llhttp__internal__n_url_to_http_09; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_url_skip_lf_to_http09_1: + s_n_llhttp__internal__n_url_skip_lf_to_http09_1: { + if (p == endp) { + return s_n_llhttp__internal__n_url_skip_lf_to_http09_1; + } + switch (*p) { + case 10: { + p++; + goto s_n_llhttp__internal__n_url_to_http_09; + } + default: { + goto s_n_llhttp__internal__n_error_63; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_url_skip_lf_to_http09: + s_n_llhttp__internal__n_url_skip_lf_to_http09: { + if (p == endp) { + return s_n_llhttp__internal__n_url_skip_lf_to_http09; + } + switch (*p) { + case 9: { + p++; + goto s_n_llhttp__internal__n_error_2; + } + case 12: { + p++; + goto s_n_llhttp__internal__n_error_2; + } + case 13: { + p++; + goto s_n_llhttp__internal__n_url_skip_lf_to_http09_1; + } + default: { + goto s_n_llhttp__internal__n_error_63; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_req_pri_upgrade: + s_n_llhttp__internal__n_req_pri_upgrade: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_req_pri_upgrade; + } + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob14, 10); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + goto s_n_llhttp__internal__n_error_71; + } + case kMatchPause: { + return s_n_llhttp__internal__n_req_pri_upgrade; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_error_72; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_req_http_complete_crlf: + s_n_llhttp__internal__n_req_http_complete_crlf: { + if (p == endp) { + return s_n_llhttp__internal__n_req_http_complete_crlf; + } + switch (*p) { + case 10: { + p++; + goto s_n_llhttp__internal__n_headers_start; + } + default: { + goto s_n_llhttp__internal__n_invoke_test_lenient_flags_26; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_req_http_complete: + s_n_llhttp__internal__n_req_http_complete: { + if (p == endp) { + return s_n_llhttp__internal__n_req_http_complete; + } + switch (*p) { + case 10: { + p++; + goto s_n_llhttp__internal__n_invoke_test_lenient_flags_25; + } + case 13: { + p++; + goto s_n_llhttp__internal__n_req_http_complete_crlf; + } + default: { + goto s_n_llhttp__internal__n_error_70; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_invoke_load_method_1: + s_n_llhttp__internal__n_invoke_load_method_1: { + switch (llhttp__internal__c_load_method(state, p, endp)) { + case 34: + goto s_n_llhttp__internal__n_req_pri_upgrade; + default: + goto s_n_llhttp__internal__n_req_http_complete; + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_invoke_llhttp__on_version_complete: + s_n_llhttp__internal__n_invoke_llhttp__on_version_complete: { + switch (llhttp__on_version_complete(state, p, endp)) { + case 0: + goto s_n_llhttp__internal__n_invoke_load_method_1; + case 21: + goto s_n_llhttp__internal__n_pause_21; + default: + goto s_n_llhttp__internal__n_error_67; + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_error_66: + s_n_llhttp__internal__n_error_66: { + state->error = 0x9; + state->reason = "Invalid HTTP version"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_error_73: + s_n_llhttp__internal__n_error_73: { + state->error = 0x9; + state->reason = "Invalid minor version"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_req_http_minor: + s_n_llhttp__internal__n_req_http_minor: { + if (p == endp) { + return s_n_llhttp__internal__n_req_http_minor; + } + switch (*p) { + case '0': { + p++; + match = 0; + goto s_n_llhttp__internal__n_invoke_store_http_minor; + } + case '1': { + p++; + match = 1; + goto s_n_llhttp__internal__n_invoke_store_http_minor; + } + case '2': { + p++; + match = 2; + goto s_n_llhttp__internal__n_invoke_store_http_minor; + } + case '3': { + p++; + match = 3; + goto s_n_llhttp__internal__n_invoke_store_http_minor; + } + case '4': { + p++; + match = 4; + goto s_n_llhttp__internal__n_invoke_store_http_minor; + } + case '5': { + p++; + match = 5; + goto s_n_llhttp__internal__n_invoke_store_http_minor; + } + case '6': { + p++; + match = 6; + goto s_n_llhttp__internal__n_invoke_store_http_minor; + } + case '7': { + p++; + match = 7; + goto s_n_llhttp__internal__n_invoke_store_http_minor; + } + case '8': { + p++; + match = 8; + goto s_n_llhttp__internal__n_invoke_store_http_minor; + } + case '9': { + p++; + match = 9; + goto s_n_llhttp__internal__n_invoke_store_http_minor; + } + default: { + goto s_n_llhttp__internal__n_span_end_llhttp__on_version_2; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_error_74: + s_n_llhttp__internal__n_error_74: { + state->error = 0x9; + state->reason = "Expected dot"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_req_http_dot: + s_n_llhttp__internal__n_req_http_dot: { + if (p == endp) { + return s_n_llhttp__internal__n_req_http_dot; + } + switch (*p) { + case '.': { + p++; + goto s_n_llhttp__internal__n_req_http_minor; + } + default: { + goto s_n_llhttp__internal__n_span_end_llhttp__on_version_3; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_error_75: + s_n_llhttp__internal__n_error_75: { + state->error = 0x9; + state->reason = "Invalid major version"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_req_http_major: + s_n_llhttp__internal__n_req_http_major: { + if (p == endp) { + return s_n_llhttp__internal__n_req_http_major; + } + switch (*p) { + case '0': { + p++; + match = 0; + goto s_n_llhttp__internal__n_invoke_store_http_major; + } + case '1': { + p++; + match = 1; + goto s_n_llhttp__internal__n_invoke_store_http_major; + } + case '2': { + p++; + match = 2; + goto s_n_llhttp__internal__n_invoke_store_http_major; + } + case '3': { + p++; + match = 3; + goto s_n_llhttp__internal__n_invoke_store_http_major; + } + case '4': { + p++; + match = 4; + goto s_n_llhttp__internal__n_invoke_store_http_major; + } + case '5': { + p++; + match = 5; + goto s_n_llhttp__internal__n_invoke_store_http_major; + } + case '6': { + p++; + match = 6; + goto s_n_llhttp__internal__n_invoke_store_http_major; + } + case '7': { + p++; + match = 7; + goto s_n_llhttp__internal__n_invoke_store_http_major; + } + case '8': { + p++; + match = 8; + goto s_n_llhttp__internal__n_invoke_store_http_major; + } + case '9': { + p++; + match = 9; + goto s_n_llhttp__internal__n_invoke_store_http_major; + } + default: { + goto s_n_llhttp__internal__n_span_end_llhttp__on_version_4; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_span_start_llhttp__on_version: + s_n_llhttp__internal__n_span_start_llhttp__on_version: { + if (p == endp) { + return s_n_llhttp__internal__n_span_start_llhttp__on_version; + } + state->_span_pos0 = (void*) p; + state->_span_cb0 = llhttp__on_version; + goto s_n_llhttp__internal__n_req_http_major; + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_req_http_start_1: + s_n_llhttp__internal__n_req_http_start_1: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_req_http_start_1; + } + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob13, 4); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + goto s_n_llhttp__internal__n_invoke_load_method; + } + case kMatchPause: { + return s_n_llhttp__internal__n_req_http_start_1; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_error_78; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_req_http_start_2: + s_n_llhttp__internal__n_req_http_start_2: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_req_http_start_2; + } + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob15, 3); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + goto s_n_llhttp__internal__n_invoke_load_method_2; + } + case kMatchPause: { + return s_n_llhttp__internal__n_req_http_start_2; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_error_78; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_req_http_start_3: + s_n_llhttp__internal__n_req_http_start_3: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_req_http_start_3; + } + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob16, 4); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + goto s_n_llhttp__internal__n_invoke_load_method_3; + } + case kMatchPause: { + return s_n_llhttp__internal__n_req_http_start_3; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_error_78; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_req_http_start: + s_n_llhttp__internal__n_req_http_start: { + if (p == endp) { + return s_n_llhttp__internal__n_req_http_start; + } + switch (*p) { + case ' ': { + p++; + goto s_n_llhttp__internal__n_req_http_start; + } + case 'H': { + p++; + goto s_n_llhttp__internal__n_req_http_start_1; + } + case 'I': { + p++; + goto s_n_llhttp__internal__n_req_http_start_2; + } + case 'R': { + p++; + goto s_n_llhttp__internal__n_req_http_start_3; + } + default: { + goto s_n_llhttp__internal__n_error_78; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_url_to_http: + s_n_llhttp__internal__n_url_to_http: { + if (p == endp) { + return s_n_llhttp__internal__n_url_to_http; + } + switch (*p) { + case 9: { + p++; + goto s_n_llhttp__internal__n_error_2; + } + case 12: { + p++; + goto s_n_llhttp__internal__n_error_2; + } + default: { + goto s_n_llhttp__internal__n_invoke_llhttp__on_url_complete_1; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_url_skip_to_http: + s_n_llhttp__internal__n_url_skip_to_http: { + if (p == endp) { + return s_n_llhttp__internal__n_url_skip_to_http; + } + switch (*p) { + case 9: { + p++; + goto s_n_llhttp__internal__n_error_2; + } + case 12: { + p++; + goto s_n_llhttp__internal__n_error_2; + } + default: { + p++; + goto s_n_llhttp__internal__n_url_to_http; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_url_fragment: + s_n_llhttp__internal__n_url_fragment: { + static uint8_t lookup_table[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 1, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 + }; + if (p == endp) { + return s_n_llhttp__internal__n_url_fragment; + } + switch (lookup_table[(uint8_t) *p]) { + case 1: { + p++; + goto s_n_llhttp__internal__n_error_2; + } + case 2: { + goto s_n_llhttp__internal__n_span_end_llhttp__on_url_6; + } + case 3: { + goto s_n_llhttp__internal__n_span_end_llhttp__on_url_7; + } + case 4: { + goto s_n_llhttp__internal__n_span_end_llhttp__on_url_8; + } + case 5: { + p++; + goto s_n_llhttp__internal__n_url_fragment; + } + default: { + goto s_n_llhttp__internal__n_error_79; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_span_end_stub_query_3: + s_n_llhttp__internal__n_span_end_stub_query_3: { + if (p == endp) { + return s_n_llhttp__internal__n_span_end_stub_query_3; + } + p++; + goto s_n_llhttp__internal__n_url_fragment; + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_url_query: + s_n_llhttp__internal__n_url_query: { + static uint8_t lookup_table[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 1, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 4, 5, 5, 6, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 + }; + if (p == endp) { + return s_n_llhttp__internal__n_url_query; + } + switch (lookup_table[(uint8_t) *p]) { + case 1: { + p++; + goto s_n_llhttp__internal__n_error_2; + } + case 2: { + goto s_n_llhttp__internal__n_span_end_llhttp__on_url_9; + } + case 3: { + goto s_n_llhttp__internal__n_span_end_llhttp__on_url_10; + } + case 4: { + goto s_n_llhttp__internal__n_span_end_llhttp__on_url_11; + } + case 5: { + p++; + goto s_n_llhttp__internal__n_url_query; + } + case 6: { + goto s_n_llhttp__internal__n_span_end_stub_query_3; + } + default: { + goto s_n_llhttp__internal__n_error_80; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_url_query_or_fragment: + s_n_llhttp__internal__n_url_query_or_fragment: { + if (p == endp) { + return s_n_llhttp__internal__n_url_query_or_fragment; + } + switch (*p) { + case 9: { + p++; + goto s_n_llhttp__internal__n_error_2; + } + case 10: { + goto s_n_llhttp__internal__n_span_end_llhttp__on_url_3; + } + case 12: { + p++; + goto s_n_llhttp__internal__n_error_2; + } + case 13: { + goto s_n_llhttp__internal__n_span_end_llhttp__on_url_4; + } + case ' ': { + goto s_n_llhttp__internal__n_span_end_llhttp__on_url_5; + } + case '#': { + p++; + goto s_n_llhttp__internal__n_url_fragment; + } + case '?': { + p++; + goto s_n_llhttp__internal__n_url_query; + } + default: { + goto s_n_llhttp__internal__n_error_81; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_url_path: + s_n_llhttp__internal__n_url_path: { + static uint8_t lookup_table[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 + }; + if (p == endp) { + return s_n_llhttp__internal__n_url_path; + } + switch (lookup_table[(uint8_t) *p]) { + case 1: { + p++; + goto s_n_llhttp__internal__n_error_2; + } + case 2: { + p++; + goto s_n_llhttp__internal__n_url_path; + } + default: { + goto s_n_llhttp__internal__n_url_query_or_fragment; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_span_start_stub_path_2: + s_n_llhttp__internal__n_span_start_stub_path_2: { + if (p == endp) { + return s_n_llhttp__internal__n_span_start_stub_path_2; + } + p++; + goto s_n_llhttp__internal__n_url_path; + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_span_start_stub_path: + s_n_llhttp__internal__n_span_start_stub_path: { + if (p == endp) { + return s_n_llhttp__internal__n_span_start_stub_path; + } + p++; + goto s_n_llhttp__internal__n_url_path; + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_span_start_stub_path_1: + s_n_llhttp__internal__n_span_start_stub_path_1: { + if (p == endp) { + return s_n_llhttp__internal__n_span_start_stub_path_1; + } + p++; + goto s_n_llhttp__internal__n_url_path; + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_url_server_with_at: + s_n_llhttp__internal__n_url_server_with_at: { + static uint8_t lookup_table[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 1, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 4, 5, 0, 0, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0, 5, 0, 7, + 8, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0, 5, 0, 5, + 0, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0, 0, 0, 5, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 + }; + if (p == endp) { + return s_n_llhttp__internal__n_url_server_with_at; + } + switch (lookup_table[(uint8_t) *p]) { + case 1: { + p++; + goto s_n_llhttp__internal__n_error_2; + } + case 2: { + goto s_n_llhttp__internal__n_span_end_llhttp__on_url_12; + } + case 3: { + goto s_n_llhttp__internal__n_span_end_llhttp__on_url_13; + } + case 4: { + goto s_n_llhttp__internal__n_span_end_llhttp__on_url_14; + } + case 5: { + p++; + goto s_n_llhttp__internal__n_url_server; + } + case 6: { + goto s_n_llhttp__internal__n_span_start_stub_path_1; + } + case 7: { + p++; + goto s_n_llhttp__internal__n_url_query; + } + case 8: { + p++; + goto s_n_llhttp__internal__n_error_82; + } + default: { + goto s_n_llhttp__internal__n_error_83; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_url_server: + s_n_llhttp__internal__n_url_server: { + static uint8_t lookup_table[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 1, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 4, 5, 0, 0, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0, 5, 0, 7, + 8, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0, 5, 0, 5, + 0, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0, 0, 0, 5, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 + }; + if (p == endp) { + return s_n_llhttp__internal__n_url_server; + } + switch (lookup_table[(uint8_t) *p]) { + case 1: { + p++; + goto s_n_llhttp__internal__n_error_2; + } + case 2: { + goto s_n_llhttp__internal__n_span_end_llhttp__on_url; + } + case 3: { + goto s_n_llhttp__internal__n_span_end_llhttp__on_url_1; + } + case 4: { + goto s_n_llhttp__internal__n_span_end_llhttp__on_url_2; + } + case 5: { + p++; + goto s_n_llhttp__internal__n_url_server; + } + case 6: { + goto s_n_llhttp__internal__n_span_start_stub_path; + } + case 7: { + p++; + goto s_n_llhttp__internal__n_url_query; + } + case 8: { + p++; + goto s_n_llhttp__internal__n_url_server_with_at; + } + default: { + goto s_n_llhttp__internal__n_error_84; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_url_schema_delim_1: + s_n_llhttp__internal__n_url_schema_delim_1: { + if (p == endp) { + return s_n_llhttp__internal__n_url_schema_delim_1; + } + switch (*p) { + case '/': { + p++; + goto s_n_llhttp__internal__n_url_server; + } + default: { + goto s_n_llhttp__internal__n_error_85; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_url_schema_delim: + s_n_llhttp__internal__n_url_schema_delim: { + if (p == endp) { + return s_n_llhttp__internal__n_url_schema_delim; + } + switch (*p) { + case 9: { + p++; + goto s_n_llhttp__internal__n_error_2; + } + case 10: { + p++; + goto s_n_llhttp__internal__n_error_2; + } + case 12: { + p++; + goto s_n_llhttp__internal__n_error_2; + } + case 13: { + p++; + goto s_n_llhttp__internal__n_error_2; + } + case ' ': { + p++; + goto s_n_llhttp__internal__n_error_2; + } + case '/': { + p++; + goto s_n_llhttp__internal__n_url_schema_delim_1; + } + default: { + goto s_n_llhttp__internal__n_error_85; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_span_end_stub_schema: + s_n_llhttp__internal__n_span_end_stub_schema: { + if (p == endp) { + return s_n_llhttp__internal__n_span_end_stub_schema; + } + p++; + goto s_n_llhttp__internal__n_url_schema_delim; + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_url_schema: + s_n_llhttp__internal__n_url_schema: { + static uint8_t lookup_table[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, + 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, + 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 + }; + if (p == endp) { + return s_n_llhttp__internal__n_url_schema; + } + switch (lookup_table[(uint8_t) *p]) { + case 1: { + p++; + goto s_n_llhttp__internal__n_error_2; + } + case 2: { + goto s_n_llhttp__internal__n_span_end_stub_schema; + } + case 3: { + p++; + goto s_n_llhttp__internal__n_url_schema; + } + default: { + goto s_n_llhttp__internal__n_error_86; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_url_start: + s_n_llhttp__internal__n_url_start: { + static uint8_t lookup_table[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 2, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, + 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 + }; + if (p == endp) { + return s_n_llhttp__internal__n_url_start; + } + switch (lookup_table[(uint8_t) *p]) { + case 1: { + p++; + goto s_n_llhttp__internal__n_error_2; + } + case 2: { + goto s_n_llhttp__internal__n_span_start_stub_path_2; + } + case 3: { + goto s_n_llhttp__internal__n_url_schema; + } + default: { + goto s_n_llhttp__internal__n_error_87; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_span_start_llhttp__on_url_1: + s_n_llhttp__internal__n_span_start_llhttp__on_url_1: { + if (p == endp) { + return s_n_llhttp__internal__n_span_start_llhttp__on_url_1; + } + state->_span_pos0 = (void*) p; + state->_span_cb0 = llhttp__on_url; + goto s_n_llhttp__internal__n_url_start; + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_url_entry_normal: + s_n_llhttp__internal__n_url_entry_normal: { + if (p == endp) { + return s_n_llhttp__internal__n_url_entry_normal; + } + switch (*p) { + case 9: { + p++; + goto s_n_llhttp__internal__n_error_2; + } + case 12: { + p++; + goto s_n_llhttp__internal__n_error_2; + } + default: { + goto s_n_llhttp__internal__n_span_start_llhttp__on_url_1; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_span_start_llhttp__on_url: + s_n_llhttp__internal__n_span_start_llhttp__on_url: { + if (p == endp) { + return s_n_llhttp__internal__n_span_start_llhttp__on_url; + } + state->_span_pos0 = (void*) p; + state->_span_cb0 = llhttp__on_url; + goto s_n_llhttp__internal__n_url_server; + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_url_entry_connect: + s_n_llhttp__internal__n_url_entry_connect: { + if (p == endp) { + return s_n_llhttp__internal__n_url_entry_connect; + } + switch (*p) { + case 9: { + p++; + goto s_n_llhttp__internal__n_error_2; + } + case 12: { + p++; + goto s_n_llhttp__internal__n_error_2; + } + default: { + goto s_n_llhttp__internal__n_span_start_llhttp__on_url; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_req_spaces_before_url: + s_n_llhttp__internal__n_req_spaces_before_url: { + if (p == endp) { + return s_n_llhttp__internal__n_req_spaces_before_url; + } + switch (*p) { + case ' ': { + p++; + goto s_n_llhttp__internal__n_req_spaces_before_url; + } + default: { + goto s_n_llhttp__internal__n_invoke_is_equal_method; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_req_first_space_before_url: + s_n_llhttp__internal__n_req_first_space_before_url: { + if (p == endp) { + return s_n_llhttp__internal__n_req_first_space_before_url; + } + switch (*p) { + case ' ': { + p++; + goto s_n_llhttp__internal__n_req_spaces_before_url; + } + default: { + goto s_n_llhttp__internal__n_error_88; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_invoke_llhttp__on_method_complete_1: + s_n_llhttp__internal__n_invoke_llhttp__on_method_complete_1: { + switch (llhttp__on_method_complete(state, p, endp)) { + case 0: + goto s_n_llhttp__internal__n_req_first_space_before_url; + case 21: + goto s_n_llhttp__internal__n_pause_26; + default: + goto s_n_llhttp__internal__n_error_107; + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_2: + s_n_llhttp__internal__n_after_start_req_2: { + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_2; + } + switch (*p) { + case 'L': { + p++; + match = 19; + goto s_n_llhttp__internal__n_invoke_store_method_1; + } + default: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_3: + s_n_llhttp__internal__n_after_start_req_3: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_3; + } + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob17, 6); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + match = 36; + goto s_n_llhttp__internal__n_invoke_store_method_1; + } + case kMatchPause: { + return s_n_llhttp__internal__n_after_start_req_3; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_1: + s_n_llhttp__internal__n_after_start_req_1: { + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_1; + } + switch (*p) { + case 'C': { + p++; + goto s_n_llhttp__internal__n_after_start_req_2; + } + case 'N': { + p++; + goto s_n_llhttp__internal__n_after_start_req_3; + } + default: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_4: + s_n_llhttp__internal__n_after_start_req_4: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_4; + } + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob18, 3); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + match = 16; + goto s_n_llhttp__internal__n_invoke_store_method_1; + } + case kMatchPause: { + return s_n_llhttp__internal__n_after_start_req_4; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_6: + s_n_llhttp__internal__n_after_start_req_6: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_6; + } + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob19, 6); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + match = 22; + goto s_n_llhttp__internal__n_invoke_store_method_1; + } + case kMatchPause: { + return s_n_llhttp__internal__n_after_start_req_6; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_8: + s_n_llhttp__internal__n_after_start_req_8: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_8; + } + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob20, 4); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + match = 5; + goto s_n_llhttp__internal__n_invoke_store_method_1; + } + case kMatchPause: { + return s_n_llhttp__internal__n_after_start_req_8; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_9: + s_n_llhttp__internal__n_after_start_req_9: { + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_9; + } + switch (*p) { + case 'Y': { + p++; + match = 8; + goto s_n_llhttp__internal__n_invoke_store_method_1; + } + default: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_7: + s_n_llhttp__internal__n_after_start_req_7: { + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_7; + } + switch (*p) { + case 'N': { + p++; + goto s_n_llhttp__internal__n_after_start_req_8; + } + case 'P': { + p++; + goto s_n_llhttp__internal__n_after_start_req_9; + } + default: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_5: + s_n_llhttp__internal__n_after_start_req_5: { + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_5; + } + switch (*p) { + case 'H': { + p++; + goto s_n_llhttp__internal__n_after_start_req_6; + } + case 'O': { + p++; + goto s_n_llhttp__internal__n_after_start_req_7; + } + default: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_12: + s_n_llhttp__internal__n_after_start_req_12: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_12; + } + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob21, 3); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + match = 0; + goto s_n_llhttp__internal__n_invoke_store_method_1; + } + case kMatchPause: { + return s_n_llhttp__internal__n_after_start_req_12; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_13: + s_n_llhttp__internal__n_after_start_req_13: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_13; + } + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob22, 5); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + match = 35; + goto s_n_llhttp__internal__n_invoke_store_method_1; + } + case kMatchPause: { + return s_n_llhttp__internal__n_after_start_req_13; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_11: + s_n_llhttp__internal__n_after_start_req_11: { + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_11; + } + switch (*p) { + case 'L': { + p++; + goto s_n_llhttp__internal__n_after_start_req_12; + } + case 'S': { + p++; + goto s_n_llhttp__internal__n_after_start_req_13; + } + default: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_10: + s_n_llhttp__internal__n_after_start_req_10: { + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_10; + } + switch (*p) { + case 'E': { + p++; + goto s_n_llhttp__internal__n_after_start_req_11; + } + default: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_14: + s_n_llhttp__internal__n_after_start_req_14: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_14; + } + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob23, 4); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + match = 45; + goto s_n_llhttp__internal__n_invoke_store_method_1; + } + case kMatchPause: { + return s_n_llhttp__internal__n_after_start_req_14; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_17: + s_n_llhttp__internal__n_after_start_req_17: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_17; + } + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob25, 9); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + match = 41; + goto s_n_llhttp__internal__n_invoke_store_method_1; + } + case kMatchPause: { + return s_n_llhttp__internal__n_after_start_req_17; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_16: + s_n_llhttp__internal__n_after_start_req_16: { + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_16; + } + switch (*p) { + case '_': { + p++; + goto s_n_llhttp__internal__n_after_start_req_17; + } + default: { + match = 1; + goto s_n_llhttp__internal__n_invoke_store_method_1; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_15: + s_n_llhttp__internal__n_after_start_req_15: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_15; + } + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob24, 2); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + goto s_n_llhttp__internal__n_after_start_req_16; + } + case kMatchPause: { + return s_n_llhttp__internal__n_after_start_req_15; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_18: + s_n_llhttp__internal__n_after_start_req_18: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_18; + } + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob26, 3); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + match = 2; + goto s_n_llhttp__internal__n_invoke_store_method_1; + } + case kMatchPause: { + return s_n_llhttp__internal__n_after_start_req_18; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_20: + s_n_llhttp__internal__n_after_start_req_20: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_20; + } + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob27, 2); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + match = 31; + goto s_n_llhttp__internal__n_invoke_store_method_1; + } + case kMatchPause: { + return s_n_llhttp__internal__n_after_start_req_20; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_21: + s_n_llhttp__internal__n_after_start_req_21: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_21; + } + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob28, 2); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + match = 9; + goto s_n_llhttp__internal__n_invoke_store_method_1; + } + case kMatchPause: { + return s_n_llhttp__internal__n_after_start_req_21; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_19: + s_n_llhttp__internal__n_after_start_req_19: { + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_19; + } + switch (*p) { + case 'I': { + p++; + goto s_n_llhttp__internal__n_after_start_req_20; + } + case 'O': { + p++; + goto s_n_llhttp__internal__n_after_start_req_21; + } + default: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_23: + s_n_llhttp__internal__n_after_start_req_23: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_23; + } + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob29, 6); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + match = 24; + goto s_n_llhttp__internal__n_invoke_store_method_1; + } + case kMatchPause: { + return s_n_llhttp__internal__n_after_start_req_23; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_24: + s_n_llhttp__internal__n_after_start_req_24: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_24; + } + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob30, 3); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + match = 23; + goto s_n_llhttp__internal__n_invoke_store_method_1; + } + case kMatchPause: { + return s_n_llhttp__internal__n_after_start_req_24; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_26: + s_n_llhttp__internal__n_after_start_req_26: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_26; + } + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob31, 7); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + match = 21; + goto s_n_llhttp__internal__n_invoke_store_method_1; + } + case kMatchPause: { + return s_n_llhttp__internal__n_after_start_req_26; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_28: + s_n_llhttp__internal__n_after_start_req_28: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_28; + } + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob32, 6); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + match = 30; + goto s_n_llhttp__internal__n_invoke_store_method_1; + } + case kMatchPause: { + return s_n_llhttp__internal__n_after_start_req_28; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_29: + s_n_llhttp__internal__n_after_start_req_29: { + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_29; + } + switch (*p) { + case 'L': { + p++; + match = 10; + goto s_n_llhttp__internal__n_invoke_store_method_1; + } + default: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_27: + s_n_llhttp__internal__n_after_start_req_27: { + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_27; + } + switch (*p) { + case 'A': { + p++; + goto s_n_llhttp__internal__n_after_start_req_28; + } + case 'O': { + p++; + goto s_n_llhttp__internal__n_after_start_req_29; + } + default: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_25: + s_n_llhttp__internal__n_after_start_req_25: { + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_25; + } + switch (*p) { + case 'A': { + p++; + goto s_n_llhttp__internal__n_after_start_req_26; + } + case 'C': { + p++; + goto s_n_llhttp__internal__n_after_start_req_27; + } + default: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_30: + s_n_llhttp__internal__n_after_start_req_30: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_30; + } + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob33, 2); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + match = 11; + goto s_n_llhttp__internal__n_invoke_store_method_1; + } + case kMatchPause: { + return s_n_llhttp__internal__n_after_start_req_30; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_22: + s_n_llhttp__internal__n_after_start_req_22: { + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_22; + } + switch (*p) { + case '-': { + p++; + goto s_n_llhttp__internal__n_after_start_req_23; + } + case 'E': { + p++; + goto s_n_llhttp__internal__n_after_start_req_24; + } + case 'K': { + p++; + goto s_n_llhttp__internal__n_after_start_req_25; + } + case 'O': { + p++; + goto s_n_llhttp__internal__n_after_start_req_30; + } + default: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_31: + s_n_llhttp__internal__n_after_start_req_31: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_31; + } + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob34, 5); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + match = 25; + goto s_n_llhttp__internal__n_invoke_store_method_1; + } + case kMatchPause: { + return s_n_llhttp__internal__n_after_start_req_31; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_32: + s_n_llhttp__internal__n_after_start_req_32: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_32; + } + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob35, 6); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + match = 6; + goto s_n_llhttp__internal__n_invoke_store_method_1; + } + case kMatchPause: { + return s_n_llhttp__internal__n_after_start_req_32; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_35: + s_n_llhttp__internal__n_after_start_req_35: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_35; + } + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob36, 2); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + match = 28; + goto s_n_llhttp__internal__n_invoke_store_method_1; + } + case kMatchPause: { + return s_n_llhttp__internal__n_after_start_req_35; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_36: + s_n_llhttp__internal__n_after_start_req_36: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_36; + } + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob37, 2); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + match = 39; + goto s_n_llhttp__internal__n_invoke_store_method_1; + } + case kMatchPause: { + return s_n_llhttp__internal__n_after_start_req_36; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_34: + s_n_llhttp__internal__n_after_start_req_34: { + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_34; + } + switch (*p) { + case 'T': { + p++; + goto s_n_llhttp__internal__n_after_start_req_35; + } + case 'U': { + p++; + goto s_n_llhttp__internal__n_after_start_req_36; + } + default: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_37: + s_n_llhttp__internal__n_after_start_req_37: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_37; + } + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob38, 2); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + match = 38; + goto s_n_llhttp__internal__n_invoke_store_method_1; + } + case kMatchPause: { + return s_n_llhttp__internal__n_after_start_req_37; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_38: + s_n_llhttp__internal__n_after_start_req_38: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_38; + } + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob39, 2); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + match = 3; + goto s_n_llhttp__internal__n_invoke_store_method_1; + } + case kMatchPause: { + return s_n_llhttp__internal__n_after_start_req_38; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_42: + s_n_llhttp__internal__n_after_start_req_42: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_42; + } + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob40, 3); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + match = 12; + goto s_n_llhttp__internal__n_invoke_store_method_1; + } + case kMatchPause: { + return s_n_llhttp__internal__n_after_start_req_42; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_43: + s_n_llhttp__internal__n_after_start_req_43: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_43; + } + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob41, 4); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + match = 13; + goto s_n_llhttp__internal__n_invoke_store_method_1; + } + case kMatchPause: { + return s_n_llhttp__internal__n_after_start_req_43; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_41: + s_n_llhttp__internal__n_after_start_req_41: { + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_41; + } + switch (*p) { + case 'F': { + p++; + goto s_n_llhttp__internal__n_after_start_req_42; + } + case 'P': { + p++; + goto s_n_llhttp__internal__n_after_start_req_43; + } + default: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_40: + s_n_llhttp__internal__n_after_start_req_40: { + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_40; + } + switch (*p) { + case 'P': { + p++; + goto s_n_llhttp__internal__n_after_start_req_41; + } + default: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_39: + s_n_llhttp__internal__n_after_start_req_39: { + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_39; + } + switch (*p) { + case 'I': { + p++; + match = 34; + goto s_n_llhttp__internal__n_invoke_store_method_1; + } + case 'O': { + p++; + goto s_n_llhttp__internal__n_after_start_req_40; + } + default: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_45: + s_n_llhttp__internal__n_after_start_req_45: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_45; + } + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob42, 2); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + match = 29; + goto s_n_llhttp__internal__n_invoke_store_method_1; + } + case kMatchPause: { + return s_n_llhttp__internal__n_after_start_req_45; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_44: + s_n_llhttp__internal__n_after_start_req_44: { + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_44; + } + switch (*p) { + case 'R': { + p++; + goto s_n_llhttp__internal__n_after_start_req_45; + } + case 'T': { + p++; + match = 4; + goto s_n_llhttp__internal__n_invoke_store_method_1; + } + default: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_33: + s_n_llhttp__internal__n_after_start_req_33: { + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_33; + } + switch (*p) { + case 'A': { + p++; + goto s_n_llhttp__internal__n_after_start_req_34; + } + case 'L': { + p++; + goto s_n_llhttp__internal__n_after_start_req_37; + } + case 'O': { + p++; + goto s_n_llhttp__internal__n_after_start_req_38; + } + case 'R': { + p++; + goto s_n_llhttp__internal__n_after_start_req_39; + } + case 'U': { + p++; + goto s_n_llhttp__internal__n_after_start_req_44; + } + default: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_46: + s_n_llhttp__internal__n_after_start_req_46: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_46; + } + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob43, 4); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + match = 46; + goto s_n_llhttp__internal__n_invoke_store_method_1; + } + case kMatchPause: { + return s_n_llhttp__internal__n_after_start_req_46; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_49: + s_n_llhttp__internal__n_after_start_req_49: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_49; + } + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob44, 3); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + match = 17; + goto s_n_llhttp__internal__n_invoke_store_method_1; + } + case kMatchPause: { + return s_n_llhttp__internal__n_after_start_req_49; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_50: + s_n_llhttp__internal__n_after_start_req_50: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_50; + } + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob45, 3); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + match = 44; + goto s_n_llhttp__internal__n_invoke_store_method_1; + } + case kMatchPause: { + return s_n_llhttp__internal__n_after_start_req_50; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_51: + s_n_llhttp__internal__n_after_start_req_51: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_51; + } + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob46, 5); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + match = 43; + goto s_n_llhttp__internal__n_invoke_store_method_1; + } + case kMatchPause: { + return s_n_llhttp__internal__n_after_start_req_51; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_52: + s_n_llhttp__internal__n_after_start_req_52: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_52; + } + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob47, 3); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + match = 20; + goto s_n_llhttp__internal__n_invoke_store_method_1; + } + case kMatchPause: { + return s_n_llhttp__internal__n_after_start_req_52; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_48: + s_n_llhttp__internal__n_after_start_req_48: { + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_48; + } + switch (*p) { + case 'B': { + p++; + goto s_n_llhttp__internal__n_after_start_req_49; + } + case 'C': { + p++; + goto s_n_llhttp__internal__n_after_start_req_50; + } + case 'D': { + p++; + goto s_n_llhttp__internal__n_after_start_req_51; + } + case 'P': { + p++; + goto s_n_llhttp__internal__n_after_start_req_52; + } + default: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_47: + s_n_llhttp__internal__n_after_start_req_47: { + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_47; + } + switch (*p) { + case 'E': { + p++; + goto s_n_llhttp__internal__n_after_start_req_48; + } + default: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_55: + s_n_llhttp__internal__n_after_start_req_55: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_55; + } + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob48, 3); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + match = 14; + goto s_n_llhttp__internal__n_invoke_store_method_1; + } + case kMatchPause: { + return s_n_llhttp__internal__n_after_start_req_55; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_57: + s_n_llhttp__internal__n_after_start_req_57: { + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_57; + } + switch (*p) { + case 'P': { + p++; + match = 37; + goto s_n_llhttp__internal__n_invoke_store_method_1; + } + default: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_58: + s_n_llhttp__internal__n_after_start_req_58: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_58; + } + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob49, 9); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + match = 42; + goto s_n_llhttp__internal__n_invoke_store_method_1; + } + case kMatchPause: { + return s_n_llhttp__internal__n_after_start_req_58; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_56: + s_n_llhttp__internal__n_after_start_req_56: { + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_56; + } + switch (*p) { + case 'U': { + p++; + goto s_n_llhttp__internal__n_after_start_req_57; + } + case '_': { + p++; + goto s_n_llhttp__internal__n_after_start_req_58; + } + default: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_54: + s_n_llhttp__internal__n_after_start_req_54: { + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_54; + } + switch (*p) { + case 'A': { + p++; + goto s_n_llhttp__internal__n_after_start_req_55; + } + case 'T': { + p++; + goto s_n_llhttp__internal__n_after_start_req_56; + } + default: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_59: + s_n_llhttp__internal__n_after_start_req_59: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_59; + } + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob50, 4); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + match = 33; + goto s_n_llhttp__internal__n_invoke_store_method_1; + } + case kMatchPause: { + return s_n_llhttp__internal__n_after_start_req_59; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_60: + s_n_llhttp__internal__n_after_start_req_60: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_60; + } + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob51, 7); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + match = 26; + goto s_n_llhttp__internal__n_invoke_store_method_1; + } + case kMatchPause: { + return s_n_llhttp__internal__n_after_start_req_60; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_53: + s_n_llhttp__internal__n_after_start_req_53: { + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_53; + } + switch (*p) { + case 'E': { + p++; + goto s_n_llhttp__internal__n_after_start_req_54; + } + case 'O': { + p++; + goto s_n_llhttp__internal__n_after_start_req_59; + } + case 'U': { + p++; + goto s_n_llhttp__internal__n_after_start_req_60; + } + default: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_62: + s_n_llhttp__internal__n_after_start_req_62: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_62; + } + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob52, 6); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + match = 40; + goto s_n_llhttp__internal__n_invoke_store_method_1; + } + case kMatchPause: { + return s_n_llhttp__internal__n_after_start_req_62; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_63: + s_n_llhttp__internal__n_after_start_req_63: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_63; + } + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob53, 3); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + match = 7; + goto s_n_llhttp__internal__n_invoke_store_method_1; + } + case kMatchPause: { + return s_n_llhttp__internal__n_after_start_req_63; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_61: + s_n_llhttp__internal__n_after_start_req_61: { + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_61; + } + switch (*p) { + case 'E': { + p++; + goto s_n_llhttp__internal__n_after_start_req_62; + } + case 'R': { + p++; + goto s_n_llhttp__internal__n_after_start_req_63; + } + default: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_66: + s_n_llhttp__internal__n_after_start_req_66: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_66; + } + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob54, 3); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + match = 18; + goto s_n_llhttp__internal__n_invoke_store_method_1; + } + case kMatchPause: { + return s_n_llhttp__internal__n_after_start_req_66; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_68: + s_n_llhttp__internal__n_after_start_req_68: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_68; + } + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob55, 2); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + match = 32; + goto s_n_llhttp__internal__n_invoke_store_method_1; + } + case kMatchPause: { + return s_n_llhttp__internal__n_after_start_req_68; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_69: + s_n_llhttp__internal__n_after_start_req_69: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_69; + } + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob56, 2); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + match = 15; + goto s_n_llhttp__internal__n_invoke_store_method_1; + } + case kMatchPause: { + return s_n_llhttp__internal__n_after_start_req_69; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_67: + s_n_llhttp__internal__n_after_start_req_67: { + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_67; + } + switch (*p) { + case 'I': { + p++; + goto s_n_llhttp__internal__n_after_start_req_68; + } + case 'O': { + p++; + goto s_n_llhttp__internal__n_after_start_req_69; + } + default: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_70: + s_n_llhttp__internal__n_after_start_req_70: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_70; + } + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob57, 8); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + match = 27; + goto s_n_llhttp__internal__n_invoke_store_method_1; + } + case kMatchPause: { + return s_n_llhttp__internal__n_after_start_req_70; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_65: + s_n_llhttp__internal__n_after_start_req_65: { + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_65; + } + switch (*p) { + case 'B': { + p++; + goto s_n_llhttp__internal__n_after_start_req_66; + } + case 'L': { + p++; + goto s_n_llhttp__internal__n_after_start_req_67; + } + case 'S': { + p++; + goto s_n_llhttp__internal__n_after_start_req_70; + } + default: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req_64: + s_n_llhttp__internal__n_after_start_req_64: { + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req_64; + } + switch (*p) { + case 'N': { + p++; + goto s_n_llhttp__internal__n_after_start_req_65; + } + default: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_after_start_req: + s_n_llhttp__internal__n_after_start_req: { + if (p == endp) { + return s_n_llhttp__internal__n_after_start_req; + } + switch (*p) { + case 'A': { + p++; + goto s_n_llhttp__internal__n_after_start_req_1; + } + case 'B': { + p++; + goto s_n_llhttp__internal__n_after_start_req_4; + } + case 'C': { + p++; + goto s_n_llhttp__internal__n_after_start_req_5; + } + case 'D': { + p++; + goto s_n_llhttp__internal__n_after_start_req_10; + } + case 'F': { + p++; + goto s_n_llhttp__internal__n_after_start_req_14; + } + case 'G': { + p++; + goto s_n_llhttp__internal__n_after_start_req_15; + } + case 'H': { + p++; + goto s_n_llhttp__internal__n_after_start_req_18; + } + case 'L': { + p++; + goto s_n_llhttp__internal__n_after_start_req_19; + } + case 'M': { + p++; + goto s_n_llhttp__internal__n_after_start_req_22; + } + case 'N': { + p++; + goto s_n_llhttp__internal__n_after_start_req_31; + } + case 'O': { + p++; + goto s_n_llhttp__internal__n_after_start_req_32; + } + case 'P': { + p++; + goto s_n_llhttp__internal__n_after_start_req_33; + } + case 'Q': { + p++; + goto s_n_llhttp__internal__n_after_start_req_46; + } + case 'R': { + p++; + goto s_n_llhttp__internal__n_after_start_req_47; + } + case 'S': { + p++; + goto s_n_llhttp__internal__n_after_start_req_53; + } + case 'T': { + p++; + goto s_n_llhttp__internal__n_after_start_req_61; + } + case 'U': { + p++; + goto s_n_llhttp__internal__n_after_start_req_64; + } + default: { + goto s_n_llhttp__internal__n_error_108; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_span_start_llhttp__on_method_1: + s_n_llhttp__internal__n_span_start_llhttp__on_method_1: { + if (p == endp) { + return s_n_llhttp__internal__n_span_start_llhttp__on_method_1; + } + state->_span_pos0 = (void*) p; + state->_span_cb0 = llhttp__on_method; + goto s_n_llhttp__internal__n_after_start_req; + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_res_line_almost_done: + s_n_llhttp__internal__n_res_line_almost_done: { + if (p == endp) { + return s_n_llhttp__internal__n_res_line_almost_done; + } + switch (*p) { + case 10: { + p++; + goto s_n_llhttp__internal__n_invoke_llhttp__on_status_complete; + } + case 13: { + p++; + goto s_n_llhttp__internal__n_invoke_llhttp__on_status_complete; + } + default: { + goto s_n_llhttp__internal__n_invoke_test_lenient_flags_29; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_invoke_test_lenient_flags_30: + s_n_llhttp__internal__n_invoke_test_lenient_flags_30: { + switch (llhttp__internal__c_test_lenient_flags_1(state, p, endp)) { + case 1: + goto s_n_llhttp__internal__n_invoke_llhttp__on_status_complete; + default: + goto s_n_llhttp__internal__n_error_94; + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_res_status: + s_n_llhttp__internal__n_res_status: { + if (p == endp) { + return s_n_llhttp__internal__n_res_status; + } + switch (*p) { + case 10: { + goto s_n_llhttp__internal__n_span_end_llhttp__on_status; + } + case 13: { + goto s_n_llhttp__internal__n_span_end_llhttp__on_status_1; + } + default: { + p++; + goto s_n_llhttp__internal__n_res_status; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_span_start_llhttp__on_status: + s_n_llhttp__internal__n_span_start_llhttp__on_status: { + if (p == endp) { + return s_n_llhttp__internal__n_span_start_llhttp__on_status; + } + state->_span_pos0 = (void*) p; + state->_span_cb0 = llhttp__on_status; + goto s_n_llhttp__internal__n_res_status; + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_res_status_code_otherwise: + s_n_llhttp__internal__n_res_status_code_otherwise: { + if (p == endp) { + return s_n_llhttp__internal__n_res_status_code_otherwise; + } + switch (*p) { + case 10: { + p++; + goto s_n_llhttp__internal__n_invoke_test_lenient_flags_28; + } + case 13: { + p++; + goto s_n_llhttp__internal__n_res_line_almost_done; + } + case ' ': { + p++; + goto s_n_llhttp__internal__n_span_start_llhttp__on_status; + } + default: { + goto s_n_llhttp__internal__n_error_95; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_res_status_code_digit_3: + s_n_llhttp__internal__n_res_status_code_digit_3: { + if (p == endp) { + return s_n_llhttp__internal__n_res_status_code_digit_3; + } + switch (*p) { + case '0': { + p++; + match = 0; + goto s_n_llhttp__internal__n_invoke_mul_add_status_code_2; + } + case '1': { + p++; + match = 1; + goto s_n_llhttp__internal__n_invoke_mul_add_status_code_2; + } + case '2': { + p++; + match = 2; + goto s_n_llhttp__internal__n_invoke_mul_add_status_code_2; + } + case '3': { + p++; + match = 3; + goto s_n_llhttp__internal__n_invoke_mul_add_status_code_2; + } + case '4': { + p++; + match = 4; + goto s_n_llhttp__internal__n_invoke_mul_add_status_code_2; + } + case '5': { + p++; + match = 5; + goto s_n_llhttp__internal__n_invoke_mul_add_status_code_2; + } + case '6': { + p++; + match = 6; + goto s_n_llhttp__internal__n_invoke_mul_add_status_code_2; + } + case '7': { + p++; + match = 7; + goto s_n_llhttp__internal__n_invoke_mul_add_status_code_2; + } + case '8': { + p++; + match = 8; + goto s_n_llhttp__internal__n_invoke_mul_add_status_code_2; + } + case '9': { + p++; + match = 9; + goto s_n_llhttp__internal__n_invoke_mul_add_status_code_2; + } + default: { + goto s_n_llhttp__internal__n_error_97; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_res_status_code_digit_2: + s_n_llhttp__internal__n_res_status_code_digit_2: { + if (p == endp) { + return s_n_llhttp__internal__n_res_status_code_digit_2; + } + switch (*p) { + case '0': { + p++; + match = 0; + goto s_n_llhttp__internal__n_invoke_mul_add_status_code_1; + } + case '1': { + p++; + match = 1; + goto s_n_llhttp__internal__n_invoke_mul_add_status_code_1; + } + case '2': { + p++; + match = 2; + goto s_n_llhttp__internal__n_invoke_mul_add_status_code_1; + } + case '3': { + p++; + match = 3; + goto s_n_llhttp__internal__n_invoke_mul_add_status_code_1; + } + case '4': { + p++; + match = 4; + goto s_n_llhttp__internal__n_invoke_mul_add_status_code_1; + } + case '5': { + p++; + match = 5; + goto s_n_llhttp__internal__n_invoke_mul_add_status_code_1; + } + case '6': { + p++; + match = 6; + goto s_n_llhttp__internal__n_invoke_mul_add_status_code_1; + } + case '7': { + p++; + match = 7; + goto s_n_llhttp__internal__n_invoke_mul_add_status_code_1; + } + case '8': { + p++; + match = 8; + goto s_n_llhttp__internal__n_invoke_mul_add_status_code_1; + } + case '9': { + p++; + match = 9; + goto s_n_llhttp__internal__n_invoke_mul_add_status_code_1; + } + default: { + goto s_n_llhttp__internal__n_error_99; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_res_status_code_digit_1: + s_n_llhttp__internal__n_res_status_code_digit_1: { + if (p == endp) { + return s_n_llhttp__internal__n_res_status_code_digit_1; + } + switch (*p) { + case '0': { + p++; + match = 0; + goto s_n_llhttp__internal__n_invoke_mul_add_status_code; + } + case '1': { + p++; + match = 1; + goto s_n_llhttp__internal__n_invoke_mul_add_status_code; + } + case '2': { + p++; + match = 2; + goto s_n_llhttp__internal__n_invoke_mul_add_status_code; + } + case '3': { + p++; + match = 3; + goto s_n_llhttp__internal__n_invoke_mul_add_status_code; + } + case '4': { + p++; + match = 4; + goto s_n_llhttp__internal__n_invoke_mul_add_status_code; + } + case '5': { + p++; + match = 5; + goto s_n_llhttp__internal__n_invoke_mul_add_status_code; + } + case '6': { + p++; + match = 6; + goto s_n_llhttp__internal__n_invoke_mul_add_status_code; + } + case '7': { + p++; + match = 7; + goto s_n_llhttp__internal__n_invoke_mul_add_status_code; + } + case '8': { + p++; + match = 8; + goto s_n_llhttp__internal__n_invoke_mul_add_status_code; + } + case '9': { + p++; + match = 9; + goto s_n_llhttp__internal__n_invoke_mul_add_status_code; + } + default: { + goto s_n_llhttp__internal__n_error_101; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_res_after_version: + s_n_llhttp__internal__n_res_after_version: { + if (p == endp) { + return s_n_llhttp__internal__n_res_after_version; + } + switch (*p) { + case ' ': { + p++; + goto s_n_llhttp__internal__n_invoke_update_status_code; + } + default: { + goto s_n_llhttp__internal__n_error_102; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_invoke_llhttp__on_version_complete_1: + s_n_llhttp__internal__n_invoke_llhttp__on_version_complete_1: { + switch (llhttp__on_version_complete(state, p, endp)) { + case 0: + goto s_n_llhttp__internal__n_res_after_version; + case 21: + goto s_n_llhttp__internal__n_pause_25; + default: + goto s_n_llhttp__internal__n_error_90; + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_error_89: + s_n_llhttp__internal__n_error_89: { + state->error = 0x9; + state->reason = "Invalid HTTP version"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_error_103: + s_n_llhttp__internal__n_error_103: { + state->error = 0x9; + state->reason = "Invalid minor version"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_res_http_minor: + s_n_llhttp__internal__n_res_http_minor: { + if (p == endp) { + return s_n_llhttp__internal__n_res_http_minor; + } + switch (*p) { + case '0': { + p++; + match = 0; + goto s_n_llhttp__internal__n_invoke_store_http_minor_1; + } + case '1': { + p++; + match = 1; + goto s_n_llhttp__internal__n_invoke_store_http_minor_1; + } + case '2': { + p++; + match = 2; + goto s_n_llhttp__internal__n_invoke_store_http_minor_1; + } + case '3': { + p++; + match = 3; + goto s_n_llhttp__internal__n_invoke_store_http_minor_1; + } + case '4': { + p++; + match = 4; + goto s_n_llhttp__internal__n_invoke_store_http_minor_1; + } + case '5': { + p++; + match = 5; + goto s_n_llhttp__internal__n_invoke_store_http_minor_1; + } + case '6': { + p++; + match = 6; + goto s_n_llhttp__internal__n_invoke_store_http_minor_1; + } + case '7': { + p++; + match = 7; + goto s_n_llhttp__internal__n_invoke_store_http_minor_1; + } + case '8': { + p++; + match = 8; + goto s_n_llhttp__internal__n_invoke_store_http_minor_1; + } + case '9': { + p++; + match = 9; + goto s_n_llhttp__internal__n_invoke_store_http_minor_1; + } + default: { + goto s_n_llhttp__internal__n_span_end_llhttp__on_version_7; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_error_104: + s_n_llhttp__internal__n_error_104: { + state->error = 0x9; + state->reason = "Expected dot"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_res_http_dot: + s_n_llhttp__internal__n_res_http_dot: { + if (p == endp) { + return s_n_llhttp__internal__n_res_http_dot; + } + switch (*p) { + case '.': { + p++; + goto s_n_llhttp__internal__n_res_http_minor; + } + default: { + goto s_n_llhttp__internal__n_span_end_llhttp__on_version_8; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_error_105: + s_n_llhttp__internal__n_error_105: { + state->error = 0x9; + state->reason = "Invalid major version"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_res_http_major: + s_n_llhttp__internal__n_res_http_major: { + if (p == endp) { + return s_n_llhttp__internal__n_res_http_major; + } + switch (*p) { + case '0': { + p++; + match = 0; + goto s_n_llhttp__internal__n_invoke_store_http_major_1; + } + case '1': { + p++; + match = 1; + goto s_n_llhttp__internal__n_invoke_store_http_major_1; + } + case '2': { + p++; + match = 2; + goto s_n_llhttp__internal__n_invoke_store_http_major_1; + } + case '3': { + p++; + match = 3; + goto s_n_llhttp__internal__n_invoke_store_http_major_1; + } + case '4': { + p++; + match = 4; + goto s_n_llhttp__internal__n_invoke_store_http_major_1; + } + case '5': { + p++; + match = 5; + goto s_n_llhttp__internal__n_invoke_store_http_major_1; + } + case '6': { + p++; + match = 6; + goto s_n_llhttp__internal__n_invoke_store_http_major_1; + } + case '7': { + p++; + match = 7; + goto s_n_llhttp__internal__n_invoke_store_http_major_1; + } + case '8': { + p++; + match = 8; + goto s_n_llhttp__internal__n_invoke_store_http_major_1; + } + case '9': { + p++; + match = 9; + goto s_n_llhttp__internal__n_invoke_store_http_major_1; + } + default: { + goto s_n_llhttp__internal__n_span_end_llhttp__on_version_9; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_span_start_llhttp__on_version_1: + s_n_llhttp__internal__n_span_start_llhttp__on_version_1: { + if (p == endp) { + return s_n_llhttp__internal__n_span_start_llhttp__on_version_1; + } + state->_span_pos0 = (void*) p; + state->_span_cb0 = llhttp__on_version; + goto s_n_llhttp__internal__n_res_http_major; + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_start_res: + s_n_llhttp__internal__n_start_res: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_start_res; + } + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob58, 5); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + goto s_n_llhttp__internal__n_span_start_llhttp__on_version_1; + } + case kMatchPause: { + return s_n_llhttp__internal__n_start_res; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_error_109; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_invoke_llhttp__on_method_complete: + s_n_llhttp__internal__n_invoke_llhttp__on_method_complete: { + switch (llhttp__on_method_complete(state, p, endp)) { + case 0: + goto s_n_llhttp__internal__n_req_first_space_before_url; + case 21: + goto s_n_llhttp__internal__n_pause_23; + default: + goto s_n_llhttp__internal__n_error_1; + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_req_or_res_method_2: + s_n_llhttp__internal__n_req_or_res_method_2: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_req_or_res_method_2; + } + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob59, 2); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + match = 2; + goto s_n_llhttp__internal__n_invoke_store_method; + } + case kMatchPause: { + return s_n_llhttp__internal__n_req_or_res_method_2; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_error_106; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_invoke_update_type_1: + s_n_llhttp__internal__n_invoke_update_type_1: { + switch (llhttp__internal__c_update_type_1(state, p, endp)) { + default: + goto s_n_llhttp__internal__n_span_start_llhttp__on_version_1; + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_req_or_res_method_3: + s_n_llhttp__internal__n_req_or_res_method_3: { + llparse_match_t match_seq; + + if (p == endp) { + return s_n_llhttp__internal__n_req_or_res_method_3; + } + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob60, 3); + p = match_seq.current; + switch (match_seq.status) { + case kMatchComplete: { + p++; + goto s_n_llhttp__internal__n_span_end_llhttp__on_method_1; + } + case kMatchPause: { + return s_n_llhttp__internal__n_req_or_res_method_3; + } + case kMatchMismatch: { + goto s_n_llhttp__internal__n_error_106; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_req_or_res_method_1: + s_n_llhttp__internal__n_req_or_res_method_1: { + if (p == endp) { + return s_n_llhttp__internal__n_req_or_res_method_1; + } + switch (*p) { + case 'E': { + p++; + goto s_n_llhttp__internal__n_req_or_res_method_2; + } + case 'T': { + p++; + goto s_n_llhttp__internal__n_req_or_res_method_3; + } + default: { + goto s_n_llhttp__internal__n_error_106; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_req_or_res_method: + s_n_llhttp__internal__n_req_or_res_method: { + if (p == endp) { + return s_n_llhttp__internal__n_req_or_res_method; + } + switch (*p) { + case 'H': { + p++; + goto s_n_llhttp__internal__n_req_or_res_method_1; + } + default: { + goto s_n_llhttp__internal__n_error_106; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_span_start_llhttp__on_method: + s_n_llhttp__internal__n_span_start_llhttp__on_method: { + if (p == endp) { + return s_n_llhttp__internal__n_span_start_llhttp__on_method; + } + state->_span_pos0 = (void*) p; + state->_span_cb0 = llhttp__on_method; + goto s_n_llhttp__internal__n_req_or_res_method; + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_start_req_or_res: + s_n_llhttp__internal__n_start_req_or_res: { + if (p == endp) { + return s_n_llhttp__internal__n_start_req_or_res; + } + switch (*p) { + case 'H': { + goto s_n_llhttp__internal__n_span_start_llhttp__on_method; + } + default: { + goto s_n_llhttp__internal__n_invoke_update_type_2; + } + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_invoke_load_type: + s_n_llhttp__internal__n_invoke_load_type: { + switch (llhttp__internal__c_load_type(state, p, endp)) { + case 1: + goto s_n_llhttp__internal__n_span_start_llhttp__on_method_1; + case 2: + goto s_n_llhttp__internal__n_start_res; + default: + goto s_n_llhttp__internal__n_start_req_or_res; + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_invoke_update_finish: + s_n_llhttp__internal__n_invoke_update_finish: { + switch (llhttp__internal__c_update_finish(state, p, endp)) { + default: + goto s_n_llhttp__internal__n_invoke_llhttp__on_message_begin; + } + /* UNREACHABLE */; + abort(); + } + case s_n_llhttp__internal__n_start: + s_n_llhttp__internal__n_start: { + if (p == endp) { + return s_n_llhttp__internal__n_start; + } + switch (*p) { + case 10: { + p++; + goto s_n_llhttp__internal__n_start; + } + case 13: { + p++; + goto s_n_llhttp__internal__n_start; + } + default: { + goto s_n_llhttp__internal__n_invoke_load_initial_message_completed; + } + } + /* UNREACHABLE */; + abort(); + } + default: + /* UNREACHABLE */ + abort(); + } + s_n_llhttp__internal__n_error_2: { + state->error = 0x7; + state->reason = "Invalid characters in url"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_update_finish_2: { + switch (llhttp__internal__c_update_finish_1(state, p, endp)) { + default: + goto s_n_llhttp__internal__n_start; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_update_initial_message_completed: { + switch (llhttp__internal__c_update_initial_message_completed(state, p, endp)) { + default: + goto s_n_llhttp__internal__n_invoke_update_finish_2; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_update_content_length: { + switch (llhttp__internal__c_update_content_length(state, p, endp)) { + default: + goto s_n_llhttp__internal__n_invoke_update_initial_message_completed; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_8: { + state->error = 0x5; + state->reason = "Data after `Connection: close`"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_test_lenient_flags_3: { + switch (llhttp__internal__c_test_lenient_flags_3(state, p, endp)) { + case 1: + goto s_n_llhttp__internal__n_closed; + default: + goto s_n_llhttp__internal__n_error_8; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_test_lenient_flags_2: { + switch (llhttp__internal__c_test_lenient_flags_2(state, p, endp)) { + case 1: + goto s_n_llhttp__internal__n_invoke_update_initial_message_completed; + default: + goto s_n_llhttp__internal__n_closed; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_update_finish_1: { + switch (llhttp__internal__c_update_finish_1(state, p, endp)) { + default: + goto s_n_llhttp__internal__n_invoke_test_lenient_flags_2; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_pause_13: { + state->error = 0x15; + state->reason = "on_message_complete pause"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_is_equal_upgrade; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_38: { + state->error = 0x12; + state->reason = "`on_message_complete` callback error"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_pause_15: { + state->error = 0x15; + state->reason = "on_chunk_complete pause"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__on_message_complete_2; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_40: { + state->error = 0x14; + state->reason = "`on_chunk_complete` callback error"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_llhttp__on_chunk_complete_1: { + switch (llhttp__on_chunk_complete(state, p, endp)) { + case 0: + goto s_n_llhttp__internal__n_invoke_llhttp__on_message_complete_2; + case 21: + goto s_n_llhttp__internal__n_pause_15; + default: + goto s_n_llhttp__internal__n_error_40; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_pause_2: { + state->error = 0x15; + state->reason = "on_message_complete pause"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_pause_1; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_9: { + state->error = 0x12; + state->reason = "`on_message_complete` callback error"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_llhttp__on_message_complete_1: { + switch (llhttp__on_message_complete(state, p, endp)) { + case 0: + goto s_n_llhttp__internal__n_pause_1; + case 21: + goto s_n_llhttp__internal__n_pause_2; + default: + goto s_n_llhttp__internal__n_error_9; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_36: { + state->error = 0xc; + state->reason = "Chunk size overflow"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_10: { + state->error = 0xc; + state->reason = "Invalid character in chunk size"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_test_lenient_flags_4: { + switch (llhttp__internal__c_test_lenient_flags_4(state, p, endp)) { + case 1: + goto s_n_llhttp__internal__n_chunk_size_otherwise; + default: + goto s_n_llhttp__internal__n_error_10; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_pause_3: { + state->error = 0x15; + state->reason = "on_chunk_complete pause"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_update_content_length_1; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_14: { + state->error = 0x14; + state->reason = "`on_chunk_complete` callback error"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_llhttp__on_chunk_complete: { + switch (llhttp__on_chunk_complete(state, p, endp)) { + case 0: + goto s_n_llhttp__internal__n_invoke_update_content_length_1; + case 21: + goto s_n_llhttp__internal__n_pause_3; + default: + goto s_n_llhttp__internal__n_error_14; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_13: { + state->error = 0x19; + state->reason = "Missing expected CR after chunk data"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_test_lenient_flags_6: { + switch (llhttp__internal__c_test_lenient_flags_1(state, p, endp)) { + case 1: + goto s_n_llhttp__internal__n_invoke_llhttp__on_chunk_complete; + default: + goto s_n_llhttp__internal__n_error_13; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_15: { + state->error = 0x2; + state->reason = "Expected LF after chunk data"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_test_lenient_flags_7: { + switch (llhttp__internal__c_test_lenient_flags_7(state, p, endp)) { + case 1: + goto s_n_llhttp__internal__n_invoke_llhttp__on_chunk_complete; + default: + goto s_n_llhttp__internal__n_error_15; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_body: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_body(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_chunk_data_almost_done; + return s_error; + } + goto s_n_llhttp__internal__n_chunk_data_almost_done; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_or_flags: { + switch (llhttp__internal__c_or_flags(state, p, endp)) { + default: + goto s_n_llhttp__internal__n_header_field_start; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_pause_4: { + state->error = 0x15; + state->reason = "on_chunk_header pause"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_is_equal_content_length; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_12: { + state->error = 0x13; + state->reason = "`on_chunk_header` callback error"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_llhttp__on_chunk_header: { + switch (llhttp__on_chunk_header(state, p, endp)) { + case 0: + goto s_n_llhttp__internal__n_invoke_is_equal_content_length; + case 21: + goto s_n_llhttp__internal__n_pause_4; + default: + goto s_n_llhttp__internal__n_error_12; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_16: { + state->error = 0x2; + state->reason = "Expected LF after chunk size"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_test_lenient_flags_8: { + switch (llhttp__internal__c_test_lenient_flags_8(state, p, endp)) { + case 1: + goto s_n_llhttp__internal__n_invoke_llhttp__on_chunk_header; + default: + goto s_n_llhttp__internal__n_error_16; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_11: { + state->error = 0x19; + state->reason = "Missing expected CR after chunk size"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_test_lenient_flags_5: { + switch (llhttp__internal__c_test_lenient_flags_1(state, p, endp)) { + case 1: + goto s_n_llhttp__internal__n_chunk_size_almost_done; + default: + goto s_n_llhttp__internal__n_error_11; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_17: { + state->error = 0x2; + state->reason = "Invalid character in chunk extensions"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_18: { + state->error = 0x2; + state->reason = "Invalid character in chunk extensions"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_20: { + state->error = 0x19; + state->reason = "Missing expected CR after chunk extension name"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_pause_5: { + state->error = 0x15; + state->reason = "on_chunk_extension_name pause"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_test_lenient_flags_9; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_19: { + state->error = 0x22; + state->reason = "`on_chunk_extension_name` callback error"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_name: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_chunk_extension_name(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_name_complete; + return s_error; + } + goto s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_name_complete; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_pause_6: { + state->error = 0x15; + state->reason = "on_chunk_extension_name pause"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_chunk_size_almost_done; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_21: { + state->error = 0x22; + state->reason = "`on_chunk_extension_name` callback error"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_name_1: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_chunk_extension_name(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) (p + 1); + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_name_complete_1; + return s_error; + } + p++; + goto s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_name_complete_1; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_pause_7: { + state->error = 0x15; + state->reason = "on_chunk_extension_name pause"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_chunk_extensions; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_22: { + state->error = 0x22; + state->reason = "`on_chunk_extension_name` callback error"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_name_2: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_chunk_extension_name(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) (p + 1); + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_name_complete_2; + return s_error; + } + p++; + goto s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_name_complete_2; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_25: { + state->error = 0x19; + state->reason = "Missing expected CR after chunk extension value"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_pause_8: { + state->error = 0x15; + state->reason = "on_chunk_extension_value pause"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_test_lenient_flags_10; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_24: { + state->error = 0x23; + state->reason = "`on_chunk_extension_value` callback error"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_value: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_chunk_extension_value(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete; + return s_error; + } + goto s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_pause_9: { + state->error = 0x15; + state->reason = "on_chunk_extension_value pause"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_chunk_size_almost_done; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_26: { + state->error = 0x23; + state->reason = "`on_chunk_extension_value` callback error"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_value_1: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_chunk_extension_value(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) (p + 1); + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete_1; + return s_error; + } + p++; + goto s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete_1; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_28: { + state->error = 0x19; + state->reason = "Missing expected CR after chunk extension value"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_test_lenient_flags_11: { + switch (llhttp__internal__c_test_lenient_flags_1(state, p, endp)) { + case 1: + goto s_n_llhttp__internal__n_chunk_size_almost_done; + default: + goto s_n_llhttp__internal__n_error_28; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_29: { + state->error = 0x2; + state->reason = "Invalid character in chunk extensions quote value"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_pause_10: { + state->error = 0x15; + state->reason = "on_chunk_extension_value pause"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_chunk_extension_quoted_value_done; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_27: { + state->error = 0x23; + state->reason = "`on_chunk_extension_value` callback error"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_value_2: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_chunk_extension_value(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete_2; + return s_error; + } + goto s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete_2; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_value_3: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_chunk_extension_value(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) (p + 1); + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_error_30; + return s_error; + } + p++; + goto s_n_llhttp__internal__n_error_30; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_value_4: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_chunk_extension_value(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) (p + 1); + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_error_31; + return s_error; + } + p++; + goto s_n_llhttp__internal__n_error_31; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_pause_11: { + state->error = 0x15; + state->reason = "on_chunk_extension_value pause"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_chunk_extensions; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_32: { + state->error = 0x23; + state->reason = "`on_chunk_extension_value` callback error"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_value_5: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_chunk_extension_value(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) (p + 1); + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete_3; + return s_error; + } + p++; + goto s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete_3; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_value_6: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_chunk_extension_value(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) (p + 1); + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_error_33; + return s_error; + } + p++; + goto s_n_llhttp__internal__n_error_33; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_pause_12: { + state->error = 0x15; + state->reason = "on_chunk_extension_name pause"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_chunk_extension_value; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_23: { + state->error = 0x22; + state->reason = "`on_chunk_extension_name` callback error"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_name_complete_3: { + switch (llhttp__on_chunk_extension_name_complete(state, p, endp)) { + case 0: + goto s_n_llhttp__internal__n_chunk_extension_value; + case 21: + goto s_n_llhttp__internal__n_pause_12; + default: + goto s_n_llhttp__internal__n_error_23; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_name_3: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_chunk_extension_name(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) (p + 1); + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_span_start_llhttp__on_chunk_extension_value; + return s_error; + } + p++; + goto s_n_llhttp__internal__n_span_start_llhttp__on_chunk_extension_value; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_name_4: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_chunk_extension_name(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) (p + 1); + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_error_34; + return s_error; + } + p++; + goto s_n_llhttp__internal__n_error_34; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_35: { + state->error = 0xc; + state->reason = "Invalid character in chunk size"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_mul_add_content_length: { + switch (llhttp__internal__c_mul_add_content_length(state, p, endp, match)) { + case 1: + goto s_n_llhttp__internal__n_error_36; + default: + goto s_n_llhttp__internal__n_chunk_size; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_37: { + state->error = 0xc; + state->reason = "Invalid character in chunk size"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_body_1: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_body(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__on_message_complete_2; + return s_error; + } + goto s_n_llhttp__internal__n_invoke_llhttp__on_message_complete_2; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_update_finish_3: { + switch (llhttp__internal__c_update_finish_3(state, p, endp)) { + default: + goto s_n_llhttp__internal__n_span_start_llhttp__on_body_2; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_39: { + state->error = 0xf; + state->reason = "Request has invalid `Transfer-Encoding`"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_pause: { + state->error = 0x15; + state->reason = "on_message_complete pause"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__after_message_complete; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_7: { + state->error = 0x12; + state->reason = "`on_message_complete` callback error"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_llhttp__on_message_complete: { + switch (llhttp__on_message_complete(state, p, endp)) { + case 0: + goto s_n_llhttp__internal__n_invoke_llhttp__after_message_complete; + case 21: + goto s_n_llhttp__internal__n_pause; + default: + goto s_n_llhttp__internal__n_error_7; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_or_flags_1: { + switch (llhttp__internal__c_or_flags_1(state, p, endp)) { + default: + goto s_n_llhttp__internal__n_invoke_llhttp__after_headers_complete; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_or_flags_2: { + switch (llhttp__internal__c_or_flags_1(state, p, endp)) { + default: + goto s_n_llhttp__internal__n_invoke_llhttp__after_headers_complete; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_update_upgrade: { + switch (llhttp__internal__c_update_upgrade(state, p, endp)) { + default: + goto s_n_llhttp__internal__n_invoke_or_flags_2; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_pause_14: { + state->error = 0x15; + state->reason = "Paused by on_headers_complete"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__after_headers_complete; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_6: { + state->error = 0x11; + state->reason = "User callback error"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_llhttp__on_headers_complete: { + switch (llhttp__on_headers_complete(state, p, endp)) { + case 0: + goto s_n_llhttp__internal__n_invoke_llhttp__after_headers_complete; + case 1: + goto s_n_llhttp__internal__n_invoke_or_flags_1; + case 2: + goto s_n_llhttp__internal__n_invoke_update_upgrade; + case 21: + goto s_n_llhttp__internal__n_pause_14; + default: + goto s_n_llhttp__internal__n_error_6; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_llhttp__before_headers_complete: { + switch (llhttp__before_headers_complete(state, p, endp)) { + default: + goto s_n_llhttp__internal__n_invoke_llhttp__on_headers_complete; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_test_flags: { + switch (llhttp__internal__c_test_flags(state, p, endp)) { + case 1: + goto s_n_llhttp__internal__n_invoke_llhttp__on_chunk_complete_1; + default: + goto s_n_llhttp__internal__n_invoke_llhttp__before_headers_complete; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_test_lenient_flags_1: { + switch (llhttp__internal__c_test_lenient_flags_1(state, p, endp)) { + case 1: + goto s_n_llhttp__internal__n_invoke_test_flags; + default: + goto s_n_llhttp__internal__n_error_5; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_pause_17: { + state->error = 0x15; + state->reason = "on_chunk_complete pause"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__on_message_complete_2; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_42: { + state->error = 0x14; + state->reason = "`on_chunk_complete` callback error"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_llhttp__on_chunk_complete_2: { + switch (llhttp__on_chunk_complete(state, p, endp)) { + case 0: + goto s_n_llhttp__internal__n_invoke_llhttp__on_message_complete_2; + case 21: + goto s_n_llhttp__internal__n_pause_17; + default: + goto s_n_llhttp__internal__n_error_42; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_or_flags_3: { + switch (llhttp__internal__c_or_flags_1(state, p, endp)) { + default: + goto s_n_llhttp__internal__n_invoke_llhttp__after_headers_complete; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_or_flags_4: { + switch (llhttp__internal__c_or_flags_1(state, p, endp)) { + default: + goto s_n_llhttp__internal__n_invoke_llhttp__after_headers_complete; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_update_upgrade_1: { + switch (llhttp__internal__c_update_upgrade(state, p, endp)) { + default: + goto s_n_llhttp__internal__n_invoke_or_flags_4; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_pause_16: { + state->error = 0x15; + state->reason = "Paused by on_headers_complete"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__after_headers_complete; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_41: { + state->error = 0x11; + state->reason = "User callback error"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_llhttp__on_headers_complete_1: { + switch (llhttp__on_headers_complete(state, p, endp)) { + case 0: + goto s_n_llhttp__internal__n_invoke_llhttp__after_headers_complete; + case 1: + goto s_n_llhttp__internal__n_invoke_or_flags_3; + case 2: + goto s_n_llhttp__internal__n_invoke_update_upgrade_1; + case 21: + goto s_n_llhttp__internal__n_pause_16; + default: + goto s_n_llhttp__internal__n_error_41; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_llhttp__before_headers_complete_1: { + switch (llhttp__before_headers_complete(state, p, endp)) { + default: + goto s_n_llhttp__internal__n_invoke_llhttp__on_headers_complete_1; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_test_flags_1: { + switch (llhttp__internal__c_test_flags(state, p, endp)) { + case 1: + goto s_n_llhttp__internal__n_invoke_llhttp__on_chunk_complete_2; + default: + goto s_n_llhttp__internal__n_invoke_llhttp__before_headers_complete_1; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_43: { + state->error = 0x2; + state->reason = "Expected LF after headers"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_test_lenient_flags_12: { + switch (llhttp__internal__c_test_lenient_flags_8(state, p, endp)) { + case 1: + goto s_n_llhttp__internal__n_invoke_test_flags_1; + default: + goto s_n_llhttp__internal__n_error_43; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_44: { + state->error = 0xa; + state->reason = "Invalid header token"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_header_field: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_header_field(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) (p + 1); + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_error_5; + return s_error; + } + p++; + goto s_n_llhttp__internal__n_error_5; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_test_lenient_flags_13: { + switch (llhttp__internal__c_test_lenient_flags(state, p, endp)) { + case 1: + goto s_n_llhttp__internal__n_header_field_colon_discard_ws; + default: + goto s_n_llhttp__internal__n_span_end_llhttp__on_header_field; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_60: { + state->error = 0xb; + state->reason = "Content-Length can't be present with Transfer-Encoding"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_47: { + state->error = 0xa; + state->reason = "Invalid header value char"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_test_lenient_flags_15: { + switch (llhttp__internal__c_test_lenient_flags(state, p, endp)) { + case 1: + goto s_n_llhttp__internal__n_header_value_discard_ws; + default: + goto s_n_llhttp__internal__n_error_47; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_49: { + state->error = 0xb; + state->reason = "Empty Content-Length"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_pause_18: { + state->error = 0x15; + state->reason = "on_header_value_complete pause"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_header_field_start; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_48: { + state->error = 0x1d; + state->reason = "`on_header_value_complete` callback error"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_header_value: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_header_value(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__on_header_value_complete; + return s_error; + } + goto s_n_llhttp__internal__n_invoke_llhttp__on_header_value_complete; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_update_header_state: { + switch (llhttp__internal__c_update_header_state(state, p, endp)) { + default: + goto s_n_llhttp__internal__n_span_start_llhttp__on_header_value; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_or_flags_5: { + switch (llhttp__internal__c_or_flags_5(state, p, endp)) { + default: + goto s_n_llhttp__internal__n_invoke_update_header_state; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_or_flags_6: { + switch (llhttp__internal__c_or_flags_6(state, p, endp)) { + default: + goto s_n_llhttp__internal__n_invoke_update_header_state; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_or_flags_7: { + switch (llhttp__internal__c_or_flags_7(state, p, endp)) { + default: + goto s_n_llhttp__internal__n_invoke_update_header_state; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_or_flags_8: { + switch (llhttp__internal__c_or_flags_8(state, p, endp)) { + default: + goto s_n_llhttp__internal__n_span_start_llhttp__on_header_value; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_load_header_state_2: { + switch (llhttp__internal__c_load_header_state(state, p, endp)) { + case 5: + goto s_n_llhttp__internal__n_invoke_or_flags_5; + case 6: + goto s_n_llhttp__internal__n_invoke_or_flags_6; + case 7: + goto s_n_llhttp__internal__n_invoke_or_flags_7; + case 8: + goto s_n_llhttp__internal__n_invoke_or_flags_8; + default: + goto s_n_llhttp__internal__n_span_start_llhttp__on_header_value; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_load_header_state_1: { + switch (llhttp__internal__c_load_header_state(state, p, endp)) { + case 2: + goto s_n_llhttp__internal__n_error_49; + default: + goto s_n_llhttp__internal__n_invoke_load_header_state_2; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_46: { + state->error = 0xa; + state->reason = "Invalid header value char"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_test_lenient_flags_14: { + switch (llhttp__internal__c_test_lenient_flags_1(state, p, endp)) { + case 1: + goto s_n_llhttp__internal__n_header_value_discard_lws; + default: + goto s_n_llhttp__internal__n_error_46; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_50: { + state->error = 0x2; + state->reason = "Expected LF after CR"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_test_lenient_flags_16: { + switch (llhttp__internal__c_test_lenient_flags(state, p, endp)) { + case 1: + goto s_n_llhttp__internal__n_header_value_discard_lws; + default: + goto s_n_llhttp__internal__n_error_50; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_update_header_state_1: { + switch (llhttp__internal__c_update_header_state_1(state, p, endp)) { + default: + goto s_n_llhttp__internal__n_span_start_llhttp__on_header_value_1; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_load_header_state_4: { + switch (llhttp__internal__c_load_header_state(state, p, endp)) { + case 8: + goto s_n_llhttp__internal__n_invoke_update_header_state_1; + default: + goto s_n_llhttp__internal__n_span_start_llhttp__on_header_value_1; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_52: { + state->error = 0xa; + state->reason = "Unexpected whitespace after header value"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_test_lenient_flags_18: { + switch (llhttp__internal__c_test_lenient_flags(state, p, endp)) { + case 1: + goto s_n_llhttp__internal__n_invoke_load_header_state_4; + default: + goto s_n_llhttp__internal__n_error_52; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_update_header_state_2: { + switch (llhttp__internal__c_update_header_state(state, p, endp)) { + default: + goto s_n_llhttp__internal__n_invoke_llhttp__on_header_value_complete; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_or_flags_9: { + switch (llhttp__internal__c_or_flags_5(state, p, endp)) { + default: + goto s_n_llhttp__internal__n_invoke_update_header_state_2; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_or_flags_10: { + switch (llhttp__internal__c_or_flags_6(state, p, endp)) { + default: + goto s_n_llhttp__internal__n_invoke_update_header_state_2; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_or_flags_11: { + switch (llhttp__internal__c_or_flags_7(state, p, endp)) { + default: + goto s_n_llhttp__internal__n_invoke_update_header_state_2; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_or_flags_12: { + switch (llhttp__internal__c_or_flags_8(state, p, endp)) { + default: + goto s_n_llhttp__internal__n_invoke_llhttp__on_header_value_complete; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_load_header_state_5: { + switch (llhttp__internal__c_load_header_state(state, p, endp)) { + case 5: + goto s_n_llhttp__internal__n_invoke_or_flags_9; + case 6: + goto s_n_llhttp__internal__n_invoke_or_flags_10; + case 7: + goto s_n_llhttp__internal__n_invoke_or_flags_11; + case 8: + goto s_n_llhttp__internal__n_invoke_or_flags_12; + default: + goto s_n_llhttp__internal__n_invoke_llhttp__on_header_value_complete; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_53: { + state->error = 0x3; + state->reason = "Missing expected LF after header value"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_51: { + state->error = 0x19; + state->reason = "Missing expected CR after header value"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_header_value_1: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_header_value(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_test_lenient_flags_17; + return s_error; + } + goto s_n_llhttp__internal__n_invoke_test_lenient_flags_17; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_header_value_2: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_header_value(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) (p + 1); + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_header_value_almost_done; + return s_error; + } + p++; + goto s_n_llhttp__internal__n_header_value_almost_done; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_header_value_4: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_header_value(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_header_value_almost_done; + return s_error; + } + goto s_n_llhttp__internal__n_header_value_almost_done; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_header_value_5: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_header_value(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) (p + 1); + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_header_value_almost_done; + return s_error; + } + p++; + goto s_n_llhttp__internal__n_header_value_almost_done; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_header_value_3: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_header_value(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_error_54; + return s_error; + } + goto s_n_llhttp__internal__n_error_54; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_test_lenient_flags_19: { + switch (llhttp__internal__c_test_lenient_flags(state, p, endp)) { + case 1: + goto s_n_llhttp__internal__n_header_value_lenient; + default: + goto s_n_llhttp__internal__n_span_end_llhttp__on_header_value_3; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_update_header_state_4: { + switch (llhttp__internal__c_update_header_state(state, p, endp)) { + default: + goto s_n_llhttp__internal__n_header_value_connection; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_or_flags_13: { + switch (llhttp__internal__c_or_flags_5(state, p, endp)) { + default: + goto s_n_llhttp__internal__n_invoke_update_header_state_4; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_or_flags_14: { + switch (llhttp__internal__c_or_flags_6(state, p, endp)) { + default: + goto s_n_llhttp__internal__n_invoke_update_header_state_4; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_or_flags_15: { + switch (llhttp__internal__c_or_flags_7(state, p, endp)) { + default: + goto s_n_llhttp__internal__n_invoke_update_header_state_4; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_or_flags_16: { + switch (llhttp__internal__c_or_flags_8(state, p, endp)) { + default: + goto s_n_llhttp__internal__n_header_value_connection; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_load_header_state_6: { + switch (llhttp__internal__c_load_header_state(state, p, endp)) { + case 5: + goto s_n_llhttp__internal__n_invoke_or_flags_13; + case 6: + goto s_n_llhttp__internal__n_invoke_or_flags_14; + case 7: + goto s_n_llhttp__internal__n_invoke_or_flags_15; + case 8: + goto s_n_llhttp__internal__n_invoke_or_flags_16; + default: + goto s_n_llhttp__internal__n_header_value_connection; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_update_header_state_5: { + switch (llhttp__internal__c_update_header_state_1(state, p, endp)) { + default: + goto s_n_llhttp__internal__n_header_value_connection_token; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_update_header_state_3: { + switch (llhttp__internal__c_update_header_state_3(state, p, endp)) { + default: + goto s_n_llhttp__internal__n_header_value_connection_ws; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_update_header_state_6: { + switch (llhttp__internal__c_update_header_state_6(state, p, endp)) { + default: + goto s_n_llhttp__internal__n_header_value_connection_ws; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_update_header_state_7: { + switch (llhttp__internal__c_update_header_state_7(state, p, endp)) { + default: + goto s_n_llhttp__internal__n_header_value_connection_ws; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_header_value_6: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_header_value(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_error_56; + return s_error; + } + goto s_n_llhttp__internal__n_error_56; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_mul_add_content_length_1: { + switch (llhttp__internal__c_mul_add_content_length_1(state, p, endp, match)) { + case 1: + goto s_n_llhttp__internal__n_span_end_llhttp__on_header_value_6; + default: + goto s_n_llhttp__internal__n_header_value_content_length; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_or_flags_17: { + switch (llhttp__internal__c_or_flags_17(state, p, endp)) { + default: + goto s_n_llhttp__internal__n_header_value_otherwise; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_header_value_7: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_header_value(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_error_57; + return s_error; + } + goto s_n_llhttp__internal__n_error_57; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_55: { + state->error = 0x4; + state->reason = "Duplicate Content-Length"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_test_flags_2: { + switch (llhttp__internal__c_test_flags_2(state, p, endp)) { + case 0: + goto s_n_llhttp__internal__n_header_value_content_length; + default: + goto s_n_llhttp__internal__n_error_55; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_header_value_9: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_header_value(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) (p + 1); + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_error_59; + return s_error; + } + p++; + goto s_n_llhttp__internal__n_error_59; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_update_header_state_8: { + switch (llhttp__internal__c_update_header_state_8(state, p, endp)) { + default: + goto s_n_llhttp__internal__n_header_value_otherwise; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_header_value_8: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_header_value(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) (p + 1); + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_error_58; + return s_error; + } + p++; + goto s_n_llhttp__internal__n_error_58; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_test_lenient_flags_20: { + switch (llhttp__internal__c_test_lenient_flags_20(state, p, endp)) { + case 0: + goto s_n_llhttp__internal__n_span_end_llhttp__on_header_value_8; + default: + goto s_n_llhttp__internal__n_header_value_te_chunked; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_load_type_1: { + switch (llhttp__internal__c_load_type(state, p, endp)) { + case 1: + goto s_n_llhttp__internal__n_invoke_test_lenient_flags_20; + default: + goto s_n_llhttp__internal__n_header_value_te_chunked; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_update_header_state_9: { + switch (llhttp__internal__c_update_header_state_1(state, p, endp)) { + default: + goto s_n_llhttp__internal__n_header_value; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_and_flags: { + switch (llhttp__internal__c_and_flags(state, p, endp)) { + default: + goto s_n_llhttp__internal__n_header_value_te_chunked; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_or_flags_19: { + switch (llhttp__internal__c_or_flags_18(state, p, endp)) { + default: + goto s_n_llhttp__internal__n_invoke_and_flags; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_test_lenient_flags_21: { + switch (llhttp__internal__c_test_lenient_flags_20(state, p, endp)) { + case 0: + goto s_n_llhttp__internal__n_span_end_llhttp__on_header_value_9; + default: + goto s_n_llhttp__internal__n_invoke_or_flags_19; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_load_type_2: { + switch (llhttp__internal__c_load_type(state, p, endp)) { + case 1: + goto s_n_llhttp__internal__n_invoke_test_lenient_flags_21; + default: + goto s_n_llhttp__internal__n_invoke_or_flags_19; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_or_flags_18: { + switch (llhttp__internal__c_or_flags_18(state, p, endp)) { + default: + goto s_n_llhttp__internal__n_invoke_and_flags; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_test_flags_3: { + switch (llhttp__internal__c_test_flags_3(state, p, endp)) { + case 1: + goto s_n_llhttp__internal__n_invoke_load_type_2; + default: + goto s_n_llhttp__internal__n_invoke_or_flags_18; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_or_flags_20: { + switch (llhttp__internal__c_or_flags_20(state, p, endp)) { + default: + goto s_n_llhttp__internal__n_invoke_update_header_state_9; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_load_header_state_3: { + switch (llhttp__internal__c_load_header_state(state, p, endp)) { + case 1: + goto s_n_llhttp__internal__n_header_value_connection; + case 2: + goto s_n_llhttp__internal__n_invoke_test_flags_2; + case 3: + goto s_n_llhttp__internal__n_invoke_test_flags_3; + case 4: + goto s_n_llhttp__internal__n_invoke_or_flags_20; + default: + goto s_n_llhttp__internal__n_header_value; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_test_lenient_flags_22: { + switch (llhttp__internal__c_test_lenient_flags_22(state, p, endp)) { + case 0: + goto s_n_llhttp__internal__n_error_60; + default: + goto s_n_llhttp__internal__n_header_value_discard_ws; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_test_flags_4: { + switch (llhttp__internal__c_test_flags_4(state, p, endp)) { + case 1: + goto s_n_llhttp__internal__n_invoke_test_lenient_flags_22; + default: + goto s_n_llhttp__internal__n_header_value_discard_ws; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_61: { + state->error = 0xf; + state->reason = "Transfer-Encoding can't be present with Content-Length"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_test_lenient_flags_23: { + switch (llhttp__internal__c_test_lenient_flags_22(state, p, endp)) { + case 0: + goto s_n_llhttp__internal__n_error_61; + default: + goto s_n_llhttp__internal__n_header_value_discard_ws; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_test_flags_5: { + switch (llhttp__internal__c_test_flags_2(state, p, endp)) { + case 1: + goto s_n_llhttp__internal__n_invoke_test_lenient_flags_23; + default: + goto s_n_llhttp__internal__n_header_value_discard_ws; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_pause_19: { + state->error = 0x15; + state->reason = "on_header_field_complete pause"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_load_header_state; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_45: { + state->error = 0x1c; + state->reason = "`on_header_field_complete` callback error"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_header_field_1: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_header_field(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) (p + 1); + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__on_header_field_complete; + return s_error; + } + p++; + goto s_n_llhttp__internal__n_invoke_llhttp__on_header_field_complete; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_header_field_2: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_header_field(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) (p + 1); + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__on_header_field_complete; + return s_error; + } + p++; + goto s_n_llhttp__internal__n_invoke_llhttp__on_header_field_complete; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_62: { + state->error = 0xa; + state->reason = "Invalid header token"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_update_header_state_10: { + switch (llhttp__internal__c_update_header_state_1(state, p, endp)) { + default: + goto s_n_llhttp__internal__n_header_field_general; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_store_header_state: { + switch (llhttp__internal__c_store_header_state(state, p, endp, match)) { + default: + goto s_n_llhttp__internal__n_header_field_colon; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_update_header_state_11: { + switch (llhttp__internal__c_update_header_state_1(state, p, endp)) { + default: + goto s_n_llhttp__internal__n_header_field_general; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_4: { + state->error = 0x1e; + state->reason = "Unexpected space after start line"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_test_lenient_flags: { + switch (llhttp__internal__c_test_lenient_flags(state, p, endp)) { + case 1: + goto s_n_llhttp__internal__n_header_field_start; + default: + goto s_n_llhttp__internal__n_error_4; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_pause_20: { + state->error = 0x15; + state->reason = "on_url_complete pause"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_headers_start; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_3: { + state->error = 0x1a; + state->reason = "`on_url_complete` callback error"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_llhttp__on_url_complete: { + switch (llhttp__on_url_complete(state, p, endp)) { + case 0: + goto s_n_llhttp__internal__n_headers_start; + case 21: + goto s_n_llhttp__internal__n_pause_20; + default: + goto s_n_llhttp__internal__n_error_3; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_update_http_minor: { + switch (llhttp__internal__c_update_http_minor(state, p, endp)) { + default: + goto s_n_llhttp__internal__n_invoke_llhttp__on_url_complete; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_update_http_major: { + switch (llhttp__internal__c_update_http_major(state, p, endp)) { + default: + goto s_n_llhttp__internal__n_invoke_update_http_minor; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_url_3: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_url(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_url_skip_to_http09; + return s_error; + } + goto s_n_llhttp__internal__n_url_skip_to_http09; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_63: { + state->error = 0x7; + state->reason = "Expected CRLF"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_url_4: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_url(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_url_skip_lf_to_http09; + return s_error; + } + goto s_n_llhttp__internal__n_url_skip_lf_to_http09; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_71: { + state->error = 0x17; + state->reason = "Pause on PRI/Upgrade"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_72: { + state->error = 0x9; + state->reason = "Expected HTTP/2 Connection Preface"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_69: { + state->error = 0x2; + state->reason = "Expected CRLF after version"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_test_lenient_flags_26: { + switch (llhttp__internal__c_test_lenient_flags_8(state, p, endp)) { + case 1: + goto s_n_llhttp__internal__n_headers_start; + default: + goto s_n_llhttp__internal__n_error_69; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_68: { + state->error = 0x9; + state->reason = "Expected CRLF after version"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_test_lenient_flags_25: { + switch (llhttp__internal__c_test_lenient_flags_1(state, p, endp)) { + case 1: + goto s_n_llhttp__internal__n_req_http_complete_crlf; + default: + goto s_n_llhttp__internal__n_error_68; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_70: { + state->error = 0x9; + state->reason = "Expected CRLF after version"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_pause_21: { + state->error = 0x15; + state->reason = "on_version_complete pause"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_load_method_1; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_67: { + state->error = 0x21; + state->reason = "`on_version_complete` callback error"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_version_1: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_version(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__on_version_complete; + return s_error; + } + goto s_n_llhttp__internal__n_invoke_llhttp__on_version_complete; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_version: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_version(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_error_66; + return s_error; + } + goto s_n_llhttp__internal__n_error_66; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_load_http_minor: { + switch (llhttp__internal__c_load_http_minor(state, p, endp)) { + case 9: + goto s_n_llhttp__internal__n_span_end_llhttp__on_version_1; + default: + goto s_n_llhttp__internal__n_span_end_llhttp__on_version; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_load_http_minor_1: { + switch (llhttp__internal__c_load_http_minor(state, p, endp)) { + case 0: + goto s_n_llhttp__internal__n_span_end_llhttp__on_version_1; + case 1: + goto s_n_llhttp__internal__n_span_end_llhttp__on_version_1; + default: + goto s_n_llhttp__internal__n_span_end_llhttp__on_version; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_load_http_minor_2: { + switch (llhttp__internal__c_load_http_minor(state, p, endp)) { + case 0: + goto s_n_llhttp__internal__n_span_end_llhttp__on_version_1; + default: + goto s_n_llhttp__internal__n_span_end_llhttp__on_version; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_load_http_major: { + switch (llhttp__internal__c_load_http_major(state, p, endp)) { + case 0: + goto s_n_llhttp__internal__n_invoke_load_http_minor; + case 1: + goto s_n_llhttp__internal__n_invoke_load_http_minor_1; + case 2: + goto s_n_llhttp__internal__n_invoke_load_http_minor_2; + default: + goto s_n_llhttp__internal__n_span_end_llhttp__on_version; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_test_lenient_flags_24: { + switch (llhttp__internal__c_test_lenient_flags_24(state, p, endp)) { + case 1: + goto s_n_llhttp__internal__n_span_end_llhttp__on_version_1; + default: + goto s_n_llhttp__internal__n_invoke_load_http_major; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_store_http_minor: { + switch (llhttp__internal__c_store_http_minor(state, p, endp, match)) { + default: + goto s_n_llhttp__internal__n_invoke_test_lenient_flags_24; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_version_2: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_version(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_error_73; + return s_error; + } + goto s_n_llhttp__internal__n_error_73; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_version_3: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_version(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_error_74; + return s_error; + } + goto s_n_llhttp__internal__n_error_74; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_store_http_major: { + switch (llhttp__internal__c_store_http_major(state, p, endp, match)) { + default: + goto s_n_llhttp__internal__n_req_http_dot; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_version_4: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_version(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_error_75; + return s_error; + } + goto s_n_llhttp__internal__n_error_75; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_65: { + state->error = 0x8; + state->reason = "Invalid method for HTTP/x.x request"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_load_method: { + switch (llhttp__internal__c_load_method(state, p, endp)) { + case 0: + goto s_n_llhttp__internal__n_span_start_llhttp__on_version; + case 1: + goto s_n_llhttp__internal__n_span_start_llhttp__on_version; + case 2: + goto s_n_llhttp__internal__n_span_start_llhttp__on_version; + case 3: + goto s_n_llhttp__internal__n_span_start_llhttp__on_version; + case 4: + goto s_n_llhttp__internal__n_span_start_llhttp__on_version; + case 5: + goto s_n_llhttp__internal__n_span_start_llhttp__on_version; + case 6: + goto s_n_llhttp__internal__n_span_start_llhttp__on_version; + case 7: + goto s_n_llhttp__internal__n_span_start_llhttp__on_version; + case 8: + goto s_n_llhttp__internal__n_span_start_llhttp__on_version; + case 9: + goto s_n_llhttp__internal__n_span_start_llhttp__on_version; + case 10: + goto s_n_llhttp__internal__n_span_start_llhttp__on_version; + case 11: + goto s_n_llhttp__internal__n_span_start_llhttp__on_version; + case 12: + goto s_n_llhttp__internal__n_span_start_llhttp__on_version; + case 13: + goto s_n_llhttp__internal__n_span_start_llhttp__on_version; + case 14: + goto s_n_llhttp__internal__n_span_start_llhttp__on_version; + case 15: + goto s_n_llhttp__internal__n_span_start_llhttp__on_version; + case 16: + goto s_n_llhttp__internal__n_span_start_llhttp__on_version; + case 17: + goto s_n_llhttp__internal__n_span_start_llhttp__on_version; + case 18: + goto s_n_llhttp__internal__n_span_start_llhttp__on_version; + case 19: + goto s_n_llhttp__internal__n_span_start_llhttp__on_version; + case 20: + goto s_n_llhttp__internal__n_span_start_llhttp__on_version; + case 21: + goto s_n_llhttp__internal__n_span_start_llhttp__on_version; + case 22: + goto s_n_llhttp__internal__n_span_start_llhttp__on_version; + case 23: + goto s_n_llhttp__internal__n_span_start_llhttp__on_version; + case 24: + goto s_n_llhttp__internal__n_span_start_llhttp__on_version; + case 25: + goto s_n_llhttp__internal__n_span_start_llhttp__on_version; + case 26: + goto s_n_llhttp__internal__n_span_start_llhttp__on_version; + case 27: + goto s_n_llhttp__internal__n_span_start_llhttp__on_version; + case 28: + goto s_n_llhttp__internal__n_span_start_llhttp__on_version; + case 29: + goto s_n_llhttp__internal__n_span_start_llhttp__on_version; + case 30: + goto s_n_llhttp__internal__n_span_start_llhttp__on_version; + case 31: + goto s_n_llhttp__internal__n_span_start_llhttp__on_version; + case 32: + goto s_n_llhttp__internal__n_span_start_llhttp__on_version; + case 33: + goto s_n_llhttp__internal__n_span_start_llhttp__on_version; + case 34: + goto s_n_llhttp__internal__n_span_start_llhttp__on_version; + case 46: + goto s_n_llhttp__internal__n_span_start_llhttp__on_version; + default: + goto s_n_llhttp__internal__n_error_65; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_78: { + state->error = 0x8; + state->reason = "Expected HTTP/"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_76: { + state->error = 0x8; + state->reason = "Expected SOURCE method for ICE/x.x request"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_load_method_2: { + switch (llhttp__internal__c_load_method(state, p, endp)) { + case 33: + goto s_n_llhttp__internal__n_span_start_llhttp__on_version; + default: + goto s_n_llhttp__internal__n_error_76; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_77: { + state->error = 0x8; + state->reason = "Invalid method for RTSP/x.x request"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_load_method_3: { + switch (llhttp__internal__c_load_method(state, p, endp)) { + case 1: + goto s_n_llhttp__internal__n_span_start_llhttp__on_version; + case 3: + goto s_n_llhttp__internal__n_span_start_llhttp__on_version; + case 6: + goto s_n_llhttp__internal__n_span_start_llhttp__on_version; + case 35: + goto s_n_llhttp__internal__n_span_start_llhttp__on_version; + case 36: + goto s_n_llhttp__internal__n_span_start_llhttp__on_version; + case 37: + goto s_n_llhttp__internal__n_span_start_llhttp__on_version; + case 38: + goto s_n_llhttp__internal__n_span_start_llhttp__on_version; + case 39: + goto s_n_llhttp__internal__n_span_start_llhttp__on_version; + case 40: + goto s_n_llhttp__internal__n_span_start_llhttp__on_version; + case 41: + goto s_n_llhttp__internal__n_span_start_llhttp__on_version; + case 42: + goto s_n_llhttp__internal__n_span_start_llhttp__on_version; + case 43: + goto s_n_llhttp__internal__n_span_start_llhttp__on_version; + case 44: + goto s_n_llhttp__internal__n_span_start_llhttp__on_version; + case 45: + goto s_n_llhttp__internal__n_span_start_llhttp__on_version; + default: + goto s_n_llhttp__internal__n_error_77; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_pause_22: { + state->error = 0x15; + state->reason = "on_url_complete pause"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_req_http_start; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_64: { + state->error = 0x1a; + state->reason = "`on_url_complete` callback error"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_llhttp__on_url_complete_1: { + switch (llhttp__on_url_complete(state, p, endp)) { + case 0: + goto s_n_llhttp__internal__n_req_http_start; + case 21: + goto s_n_llhttp__internal__n_pause_22; + default: + goto s_n_llhttp__internal__n_error_64; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_url_5: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_url(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_url_skip_to_http; + return s_error; + } + goto s_n_llhttp__internal__n_url_skip_to_http; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_url_6: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_url(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_url_skip_to_http09; + return s_error; + } + goto s_n_llhttp__internal__n_url_skip_to_http09; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_url_7: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_url(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_url_skip_lf_to_http09; + return s_error; + } + goto s_n_llhttp__internal__n_url_skip_lf_to_http09; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_url_8: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_url(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_url_skip_to_http; + return s_error; + } + goto s_n_llhttp__internal__n_url_skip_to_http; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_79: { + state->error = 0x7; + state->reason = "Invalid char in url fragment start"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_url_9: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_url(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_url_skip_to_http09; + return s_error; + } + goto s_n_llhttp__internal__n_url_skip_to_http09; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_url_10: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_url(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_url_skip_lf_to_http09; + return s_error; + } + goto s_n_llhttp__internal__n_url_skip_lf_to_http09; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_url_11: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_url(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_url_skip_to_http; + return s_error; + } + goto s_n_llhttp__internal__n_url_skip_to_http; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_80: { + state->error = 0x7; + state->reason = "Invalid char in url query"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_81: { + state->error = 0x7; + state->reason = "Invalid char in url path"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_url: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_url(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_url_skip_to_http09; + return s_error; + } + goto s_n_llhttp__internal__n_url_skip_to_http09; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_url_1: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_url(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_url_skip_lf_to_http09; + return s_error; + } + goto s_n_llhttp__internal__n_url_skip_lf_to_http09; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_url_2: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_url(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_url_skip_to_http; + return s_error; + } + goto s_n_llhttp__internal__n_url_skip_to_http; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_url_12: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_url(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_url_skip_to_http09; + return s_error; + } + goto s_n_llhttp__internal__n_url_skip_to_http09; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_url_13: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_url(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_url_skip_lf_to_http09; + return s_error; + } + goto s_n_llhttp__internal__n_url_skip_lf_to_http09; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_url_14: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_url(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_url_skip_to_http; + return s_error; + } + goto s_n_llhttp__internal__n_url_skip_to_http; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_82: { + state->error = 0x7; + state->reason = "Double @ in url"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_83: { + state->error = 0x7; + state->reason = "Unexpected char in url server"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_84: { + state->error = 0x7; + state->reason = "Unexpected char in url server"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_85: { + state->error = 0x7; + state->reason = "Unexpected char in url schema"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_86: { + state->error = 0x7; + state->reason = "Unexpected char in url schema"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_87: { + state->error = 0x7; + state->reason = "Unexpected start char in url"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_is_equal_method: { + switch (llhttp__internal__c_is_equal_method(state, p, endp)) { + case 0: + goto s_n_llhttp__internal__n_url_entry_normal; + default: + goto s_n_llhttp__internal__n_url_entry_connect; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_88: { + state->error = 0x6; + state->reason = "Expected space after method"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_pause_26: { + state->error = 0x15; + state->reason = "on_method_complete pause"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_req_first_space_before_url; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_107: { + state->error = 0x20; + state->reason = "`on_method_complete` callback error"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_method_2: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_method(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__on_method_complete_1; + return s_error; + } + goto s_n_llhttp__internal__n_invoke_llhttp__on_method_complete_1; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_store_method_1: { + switch (llhttp__internal__c_store_method(state, p, endp, match)) { + default: + goto s_n_llhttp__internal__n_span_end_llhttp__on_method_2; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_108: { + state->error = 0x6; + state->reason = "Invalid method encountered"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_100: { + state->error = 0xd; + state->reason = "Invalid status code"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_98: { + state->error = 0xd; + state->reason = "Invalid status code"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_96: { + state->error = 0xd; + state->reason = "Invalid status code"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_pause_24: { + state->error = 0x15; + state->reason = "on_status_complete pause"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_headers_start; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_92: { + state->error = 0x1b; + state->reason = "`on_status_complete` callback error"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_llhttp__on_status_complete: { + switch (llhttp__on_status_complete(state, p, endp)) { + case 0: + goto s_n_llhttp__internal__n_headers_start; + case 21: + goto s_n_llhttp__internal__n_pause_24; + default: + goto s_n_llhttp__internal__n_error_92; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_91: { + state->error = 0xd; + state->reason = "Invalid response status"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_test_lenient_flags_28: { + switch (llhttp__internal__c_test_lenient_flags_1(state, p, endp)) { + case 1: + goto s_n_llhttp__internal__n_invoke_llhttp__on_status_complete; + default: + goto s_n_llhttp__internal__n_error_91; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_93: { + state->error = 0x2; + state->reason = "Expected LF after CR"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_test_lenient_flags_29: { + switch (llhttp__internal__c_test_lenient_flags_8(state, p, endp)) { + case 1: + goto s_n_llhttp__internal__n_invoke_llhttp__on_status_complete; + default: + goto s_n_llhttp__internal__n_error_93; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_94: { + state->error = 0x19; + state->reason = "Missing expected CR after response line"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_status: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_status(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) (p + 1); + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_test_lenient_flags_30; + return s_error; + } + p++; + goto s_n_llhttp__internal__n_invoke_test_lenient_flags_30; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_status_1: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_status(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) (p + 1); + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_res_line_almost_done; + return s_error; + } + p++; + goto s_n_llhttp__internal__n_res_line_almost_done; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_95: { + state->error = 0xd; + state->reason = "Invalid response status"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_mul_add_status_code_2: { + switch (llhttp__internal__c_mul_add_status_code(state, p, endp, match)) { + case 1: + goto s_n_llhttp__internal__n_error_96; + default: + goto s_n_llhttp__internal__n_res_status_code_otherwise; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_97: { + state->error = 0xd; + state->reason = "Invalid status code"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_mul_add_status_code_1: { + switch (llhttp__internal__c_mul_add_status_code(state, p, endp, match)) { + case 1: + goto s_n_llhttp__internal__n_error_98; + default: + goto s_n_llhttp__internal__n_res_status_code_digit_3; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_99: { + state->error = 0xd; + state->reason = "Invalid status code"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_mul_add_status_code: { + switch (llhttp__internal__c_mul_add_status_code(state, p, endp, match)) { + case 1: + goto s_n_llhttp__internal__n_error_100; + default: + goto s_n_llhttp__internal__n_res_status_code_digit_2; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_101: { + state->error = 0xd; + state->reason = "Invalid status code"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_update_status_code: { + switch (llhttp__internal__c_update_status_code(state, p, endp)) { + default: + goto s_n_llhttp__internal__n_res_status_code_digit_1; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_102: { + state->error = 0x9; + state->reason = "Expected space after version"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_pause_25: { + state->error = 0x15; + state->reason = "on_version_complete pause"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_res_after_version; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_90: { + state->error = 0x21; + state->reason = "`on_version_complete` callback error"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_version_6: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_version(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__on_version_complete_1; + return s_error; + } + goto s_n_llhttp__internal__n_invoke_llhttp__on_version_complete_1; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_version_5: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_version(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_error_89; + return s_error; + } + goto s_n_llhttp__internal__n_error_89; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_load_http_minor_3: { + switch (llhttp__internal__c_load_http_minor(state, p, endp)) { + case 9: + goto s_n_llhttp__internal__n_span_end_llhttp__on_version_6; + default: + goto s_n_llhttp__internal__n_span_end_llhttp__on_version_5; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_load_http_minor_4: { + switch (llhttp__internal__c_load_http_minor(state, p, endp)) { + case 0: + goto s_n_llhttp__internal__n_span_end_llhttp__on_version_6; + case 1: + goto s_n_llhttp__internal__n_span_end_llhttp__on_version_6; + default: + goto s_n_llhttp__internal__n_span_end_llhttp__on_version_5; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_load_http_minor_5: { + switch (llhttp__internal__c_load_http_minor(state, p, endp)) { + case 0: + goto s_n_llhttp__internal__n_span_end_llhttp__on_version_6; + default: + goto s_n_llhttp__internal__n_span_end_llhttp__on_version_5; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_load_http_major_1: { + switch (llhttp__internal__c_load_http_major(state, p, endp)) { + case 0: + goto s_n_llhttp__internal__n_invoke_load_http_minor_3; + case 1: + goto s_n_llhttp__internal__n_invoke_load_http_minor_4; + case 2: + goto s_n_llhttp__internal__n_invoke_load_http_minor_5; + default: + goto s_n_llhttp__internal__n_span_end_llhttp__on_version_5; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_test_lenient_flags_27: { + switch (llhttp__internal__c_test_lenient_flags_24(state, p, endp)) { + case 1: + goto s_n_llhttp__internal__n_span_end_llhttp__on_version_6; + default: + goto s_n_llhttp__internal__n_invoke_load_http_major_1; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_store_http_minor_1: { + switch (llhttp__internal__c_store_http_minor(state, p, endp, match)) { + default: + goto s_n_llhttp__internal__n_invoke_test_lenient_flags_27; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_version_7: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_version(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_error_103; + return s_error; + } + goto s_n_llhttp__internal__n_error_103; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_version_8: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_version(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_error_104; + return s_error; + } + goto s_n_llhttp__internal__n_error_104; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_store_http_major_1: { + switch (llhttp__internal__c_store_http_major(state, p, endp, match)) { + default: + goto s_n_llhttp__internal__n_res_http_dot; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_version_9: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_version(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_error_105; + return s_error; + } + goto s_n_llhttp__internal__n_error_105; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_109: { + state->error = 0x8; + state->reason = "Expected HTTP/"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_pause_23: { + state->error = 0x15; + state->reason = "on_method_complete pause"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_req_first_space_before_url; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_1: { + state->error = 0x20; + state->reason = "`on_method_complete` callback error"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_method: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_method(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__on_method_complete; + return s_error; + } + goto s_n_llhttp__internal__n_invoke_llhttp__on_method_complete; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_update_type: { + switch (llhttp__internal__c_update_type(state, p, endp)) { + default: + goto s_n_llhttp__internal__n_span_end_llhttp__on_method; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_store_method: { + switch (llhttp__internal__c_store_method(state, p, endp, match)) { + default: + goto s_n_llhttp__internal__n_invoke_update_type; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_106: { + state->error = 0x8; + state->reason = "Invalid word encountered"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_span_end_llhttp__on_method_1: { + const unsigned char* start; + int err; + + start = state->_span_pos0; + state->_span_pos0 = NULL; + err = llhttp__on_method(state, start, p); + if (err != 0) { + state->error = err; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_update_type_1; + return s_error; + } + goto s_n_llhttp__internal__n_invoke_update_type_1; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_update_type_2: { + switch (llhttp__internal__c_update_type(state, p, endp)) { + default: + goto s_n_llhttp__internal__n_span_start_llhttp__on_method_1; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_pause_27: { + state->error = 0x15; + state->reason = "on_message_begin pause"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_load_type; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error: { + state->error = 0x10; + state->reason = "`on_message_begin` callback error"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_llhttp__on_message_begin: { + switch (llhttp__on_message_begin(state, p, endp)) { + case 0: + goto s_n_llhttp__internal__n_invoke_load_type; + case 21: + goto s_n_llhttp__internal__n_pause_27; + default: + goto s_n_llhttp__internal__n_error; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_pause_28: { + state->error = 0x15; + state->reason = "on_reset pause"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_update_finish; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_error_110: { + state->error = 0x1f; + state->reason = "`on_reset` callback error"; + state->error_pos = (const char*) p; + state->_current = (void*) (intptr_t) s_error; + return s_error; + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_llhttp__on_reset: { + switch (llhttp__on_reset(state, p, endp)) { + case 0: + goto s_n_llhttp__internal__n_invoke_update_finish; + case 21: + goto s_n_llhttp__internal__n_pause_28; + default: + goto s_n_llhttp__internal__n_error_110; + } + /* UNREACHABLE */; + abort(); + } + s_n_llhttp__internal__n_invoke_load_initial_message_completed: { + switch (llhttp__internal__c_load_initial_message_completed(state, p, endp)) { + case 1: + goto s_n_llhttp__internal__n_invoke_llhttp__on_reset; + default: + goto s_n_llhttp__internal__n_invoke_update_finish; + } + /* UNREACHABLE */; + abort(); + } +} + +int llhttp__internal_execute(llhttp__internal_t* state, const char* p, const char* endp) { + llparse_state_t next; + + /* check lingering errors */ + if (state->error != 0) { + return state->error; + } + + /* restart spans */ + if (state->_span_pos0 != NULL) { + state->_span_pos0 = (void*) p; + } + + next = llhttp__internal__run(state, (const unsigned char*) p, (const unsigned char*) endp); + if (next == s_error) { + return state->error; + } + state->_current = (void*) (intptr_t) next; + + /* execute spans */ + if (state->_span_pos0 != NULL) { + int error; + + error = ((llhttp__internal__span_cb) state->_span_cb0)(state, state->_span_pos0, (const char*) endp); + if (error != 0) { + state->error = error; + state->error_pos = endp; + return error; + } + } + + return 0; +} \ No newline at end of file diff --git a/deps/llhttp/llhttp.h b/deps/llhttp/llhttp.h new file mode 100644 index 00000000000..26f01c32cc7 --- /dev/null +++ b/deps/llhttp/llhttp.h @@ -0,0 +1,897 @@ + +#ifndef INCLUDE_LLHTTP_H_ +#define INCLUDE_LLHTTP_H_ + +#define LLHTTP_VERSION_MAJOR 9 +#define LLHTTP_VERSION_MINOR 2 +#define LLHTTP_VERSION_PATCH 1 + +#ifndef INCLUDE_LLHTTP_ITSELF_H_ +#define INCLUDE_LLHTTP_ITSELF_H_ +#ifdef __cplusplus +extern "C" { +#endif + +#include + +typedef struct llhttp__internal_s llhttp__internal_t; +struct llhttp__internal_s { + int32_t _index; + void* _span_pos0; + void* _span_cb0; + int32_t error; + const char* reason; + const char* error_pos; + void* data; + void* _current; + uint64_t content_length; + uint8_t type; + uint8_t method; + uint8_t http_major; + uint8_t http_minor; + uint8_t header_state; + uint16_t lenient_flags; + uint8_t upgrade; + uint8_t finish; + uint16_t flags; + uint16_t status_code; + uint8_t initial_message_completed; + void* settings; +}; + +int llhttp__internal_init(llhttp__internal_t* s); +int llhttp__internal_execute(llhttp__internal_t* s, const char* p, const char* endp); + +#ifdef __cplusplus +} /* extern "C" */ +#endif +#endif /* INCLUDE_LLHTTP_ITSELF_H_ */ + + +#ifndef LLLLHTTP_C_HEADERS_ +#define LLLLHTTP_C_HEADERS_ +#ifdef __cplusplus +extern "C" { +#endif + +enum llhttp_errno { + HPE_OK = 0, + HPE_INTERNAL = 1, + HPE_STRICT = 2, + HPE_CR_EXPECTED = 25, + HPE_LF_EXPECTED = 3, + HPE_UNEXPECTED_CONTENT_LENGTH = 4, + HPE_UNEXPECTED_SPACE = 30, + HPE_CLOSED_CONNECTION = 5, + HPE_INVALID_METHOD = 6, + HPE_INVALID_URL = 7, + HPE_INVALID_CONSTANT = 8, + HPE_INVALID_VERSION = 9, + HPE_INVALID_HEADER_TOKEN = 10, + HPE_INVALID_CONTENT_LENGTH = 11, + HPE_INVALID_CHUNK_SIZE = 12, + HPE_INVALID_STATUS = 13, + HPE_INVALID_EOF_STATE = 14, + HPE_INVALID_TRANSFER_ENCODING = 15, + HPE_CB_MESSAGE_BEGIN = 16, + HPE_CB_HEADERS_COMPLETE = 17, + HPE_CB_MESSAGE_COMPLETE = 18, + HPE_CB_CHUNK_HEADER = 19, + HPE_CB_CHUNK_COMPLETE = 20, + HPE_PAUSED = 21, + HPE_PAUSED_UPGRADE = 22, + HPE_PAUSED_H2_UPGRADE = 23, + HPE_USER = 24, + HPE_CB_URL_COMPLETE = 26, + HPE_CB_STATUS_COMPLETE = 27, + HPE_CB_METHOD_COMPLETE = 32, + HPE_CB_VERSION_COMPLETE = 33, + HPE_CB_HEADER_FIELD_COMPLETE = 28, + HPE_CB_HEADER_VALUE_COMPLETE = 29, + HPE_CB_CHUNK_EXTENSION_NAME_COMPLETE = 34, + HPE_CB_CHUNK_EXTENSION_VALUE_COMPLETE = 35, + HPE_CB_RESET = 31 +}; +typedef enum llhttp_errno llhttp_errno_t; + +enum llhttp_flags { + F_CONNECTION_KEEP_ALIVE = 0x1, + F_CONNECTION_CLOSE = 0x2, + F_CONNECTION_UPGRADE = 0x4, + F_CHUNKED = 0x8, + F_UPGRADE = 0x10, + F_CONTENT_LENGTH = 0x20, + F_SKIPBODY = 0x40, + F_TRAILING = 0x80, + F_TRANSFER_ENCODING = 0x200 +}; +typedef enum llhttp_flags llhttp_flags_t; + +enum llhttp_lenient_flags { + LENIENT_HEADERS = 0x1, + LENIENT_CHUNKED_LENGTH = 0x2, + LENIENT_KEEP_ALIVE = 0x4, + LENIENT_TRANSFER_ENCODING = 0x8, + LENIENT_VERSION = 0x10, + LENIENT_DATA_AFTER_CLOSE = 0x20, + LENIENT_OPTIONAL_LF_AFTER_CR = 0x40, + LENIENT_OPTIONAL_CRLF_AFTER_CHUNK = 0x80, + LENIENT_OPTIONAL_CR_BEFORE_LF = 0x100, + LENIENT_SPACES_AFTER_CHUNK_SIZE = 0x200 +}; +typedef enum llhttp_lenient_flags llhttp_lenient_flags_t; + +enum llhttp_type { + HTTP_BOTH = 0, + HTTP_REQUEST = 1, + HTTP_RESPONSE = 2 +}; +typedef enum llhttp_type llhttp_type_t; + +enum llhttp_finish { + HTTP_FINISH_SAFE = 0, + HTTP_FINISH_SAFE_WITH_CB = 1, + HTTP_FINISH_UNSAFE = 2 +}; +typedef enum llhttp_finish llhttp_finish_t; + +enum llhttp_method { + HTTP_DELETE = 0, + HTTP_GET = 1, + HTTP_HEAD = 2, + HTTP_POST = 3, + HTTP_PUT = 4, + HTTP_CONNECT = 5, + HTTP_OPTIONS = 6, + HTTP_TRACE = 7, + HTTP_COPY = 8, + HTTP_LOCK = 9, + HTTP_MKCOL = 10, + HTTP_MOVE = 11, + HTTP_PROPFIND = 12, + HTTP_PROPPATCH = 13, + HTTP_SEARCH = 14, + HTTP_UNLOCK = 15, + HTTP_BIND = 16, + HTTP_REBIND = 17, + HTTP_UNBIND = 18, + HTTP_ACL = 19, + HTTP_REPORT = 20, + HTTP_MKACTIVITY = 21, + HTTP_CHECKOUT = 22, + HTTP_MERGE = 23, + HTTP_MSEARCH = 24, + HTTP_NOTIFY = 25, + HTTP_SUBSCRIBE = 26, + HTTP_UNSUBSCRIBE = 27, + HTTP_PATCH = 28, + HTTP_PURGE = 29, + HTTP_MKCALENDAR = 30, + HTTP_LINK = 31, + HTTP_UNLINK = 32, + HTTP_SOURCE = 33, + HTTP_PRI = 34, + HTTP_DESCRIBE = 35, + HTTP_ANNOUNCE = 36, + HTTP_SETUP = 37, + HTTP_PLAY = 38, + HTTP_PAUSE = 39, + HTTP_TEARDOWN = 40, + HTTP_GET_PARAMETER = 41, + HTTP_SET_PARAMETER = 42, + HTTP_REDIRECT = 43, + HTTP_RECORD = 44, + HTTP_FLUSH = 45, + HTTP_QUERY = 46 +}; +typedef enum llhttp_method llhttp_method_t; + +enum llhttp_status { + HTTP_STATUS_CONTINUE = 100, + HTTP_STATUS_SWITCHING_PROTOCOLS = 101, + HTTP_STATUS_PROCESSING = 102, + HTTP_STATUS_EARLY_HINTS = 103, + HTTP_STATUS_RESPONSE_IS_STALE = 110, + HTTP_STATUS_REVALIDATION_FAILED = 111, + HTTP_STATUS_DISCONNECTED_OPERATION = 112, + HTTP_STATUS_HEURISTIC_EXPIRATION = 113, + HTTP_STATUS_MISCELLANEOUS_WARNING = 199, + HTTP_STATUS_OK = 200, + HTTP_STATUS_CREATED = 201, + HTTP_STATUS_ACCEPTED = 202, + HTTP_STATUS_NON_AUTHORITATIVE_INFORMATION = 203, + HTTP_STATUS_NO_CONTENT = 204, + HTTP_STATUS_RESET_CONTENT = 205, + HTTP_STATUS_PARTIAL_CONTENT = 206, + HTTP_STATUS_MULTI_STATUS = 207, + HTTP_STATUS_ALREADY_REPORTED = 208, + HTTP_STATUS_TRANSFORMATION_APPLIED = 214, + HTTP_STATUS_IM_USED = 226, + HTTP_STATUS_MISCELLANEOUS_PERSISTENT_WARNING = 299, + HTTP_STATUS_MULTIPLE_CHOICES = 300, + HTTP_STATUS_MOVED_PERMANENTLY = 301, + HTTP_STATUS_FOUND = 302, + HTTP_STATUS_SEE_OTHER = 303, + HTTP_STATUS_NOT_MODIFIED = 304, + HTTP_STATUS_USE_PROXY = 305, + HTTP_STATUS_SWITCH_PROXY = 306, + HTTP_STATUS_TEMPORARY_REDIRECT = 307, + HTTP_STATUS_PERMANENT_REDIRECT = 308, + HTTP_STATUS_BAD_REQUEST = 400, + HTTP_STATUS_UNAUTHORIZED = 401, + HTTP_STATUS_PAYMENT_REQUIRED = 402, + HTTP_STATUS_FORBIDDEN = 403, + HTTP_STATUS_NOT_FOUND = 404, + HTTP_STATUS_METHOD_NOT_ALLOWED = 405, + HTTP_STATUS_NOT_ACCEPTABLE = 406, + HTTP_STATUS_PROXY_AUTHENTICATION_REQUIRED = 407, + HTTP_STATUS_REQUEST_TIMEOUT = 408, + HTTP_STATUS_CONFLICT = 409, + HTTP_STATUS_GONE = 410, + HTTP_STATUS_LENGTH_REQUIRED = 411, + HTTP_STATUS_PRECONDITION_FAILED = 412, + HTTP_STATUS_PAYLOAD_TOO_LARGE = 413, + HTTP_STATUS_URI_TOO_LONG = 414, + HTTP_STATUS_UNSUPPORTED_MEDIA_TYPE = 415, + HTTP_STATUS_RANGE_NOT_SATISFIABLE = 416, + HTTP_STATUS_EXPECTATION_FAILED = 417, + HTTP_STATUS_IM_A_TEAPOT = 418, + HTTP_STATUS_PAGE_EXPIRED = 419, + HTTP_STATUS_ENHANCE_YOUR_CALM = 420, + HTTP_STATUS_MISDIRECTED_REQUEST = 421, + HTTP_STATUS_UNPROCESSABLE_ENTITY = 422, + HTTP_STATUS_LOCKED = 423, + HTTP_STATUS_FAILED_DEPENDENCY = 424, + HTTP_STATUS_TOO_EARLY = 425, + HTTP_STATUS_UPGRADE_REQUIRED = 426, + HTTP_STATUS_PRECONDITION_REQUIRED = 428, + HTTP_STATUS_TOO_MANY_REQUESTS = 429, + HTTP_STATUS_REQUEST_HEADER_FIELDS_TOO_LARGE_UNOFFICIAL = 430, + HTTP_STATUS_REQUEST_HEADER_FIELDS_TOO_LARGE = 431, + HTTP_STATUS_LOGIN_TIMEOUT = 440, + HTTP_STATUS_NO_RESPONSE = 444, + HTTP_STATUS_RETRY_WITH = 449, + HTTP_STATUS_BLOCKED_BY_PARENTAL_CONTROL = 450, + HTTP_STATUS_UNAVAILABLE_FOR_LEGAL_REASONS = 451, + HTTP_STATUS_CLIENT_CLOSED_LOAD_BALANCED_REQUEST = 460, + HTTP_STATUS_INVALID_X_FORWARDED_FOR = 463, + HTTP_STATUS_REQUEST_HEADER_TOO_LARGE = 494, + HTTP_STATUS_SSL_CERTIFICATE_ERROR = 495, + HTTP_STATUS_SSL_CERTIFICATE_REQUIRED = 496, + HTTP_STATUS_HTTP_REQUEST_SENT_TO_HTTPS_PORT = 497, + HTTP_STATUS_INVALID_TOKEN = 498, + HTTP_STATUS_CLIENT_CLOSED_REQUEST = 499, + HTTP_STATUS_INTERNAL_SERVER_ERROR = 500, + HTTP_STATUS_NOT_IMPLEMENTED = 501, + HTTP_STATUS_BAD_GATEWAY = 502, + HTTP_STATUS_SERVICE_UNAVAILABLE = 503, + HTTP_STATUS_GATEWAY_TIMEOUT = 504, + HTTP_STATUS_HTTP_VERSION_NOT_SUPPORTED = 505, + HTTP_STATUS_VARIANT_ALSO_NEGOTIATES = 506, + HTTP_STATUS_INSUFFICIENT_STORAGE = 507, + HTTP_STATUS_LOOP_DETECTED = 508, + HTTP_STATUS_BANDWIDTH_LIMIT_EXCEEDED = 509, + HTTP_STATUS_NOT_EXTENDED = 510, + HTTP_STATUS_NETWORK_AUTHENTICATION_REQUIRED = 511, + HTTP_STATUS_WEB_SERVER_UNKNOWN_ERROR = 520, + HTTP_STATUS_WEB_SERVER_IS_DOWN = 521, + HTTP_STATUS_CONNECTION_TIMEOUT = 522, + HTTP_STATUS_ORIGIN_IS_UNREACHABLE = 523, + HTTP_STATUS_TIMEOUT_OCCURED = 524, + HTTP_STATUS_SSL_HANDSHAKE_FAILED = 525, + HTTP_STATUS_INVALID_SSL_CERTIFICATE = 526, + HTTP_STATUS_RAILGUN_ERROR = 527, + HTTP_STATUS_SITE_IS_OVERLOADED = 529, + HTTP_STATUS_SITE_IS_FROZEN = 530, + HTTP_STATUS_IDENTITY_PROVIDER_AUTHENTICATION_ERROR = 561, + HTTP_STATUS_NETWORK_READ_TIMEOUT = 598, + HTTP_STATUS_NETWORK_CONNECT_TIMEOUT = 599 +}; +typedef enum llhttp_status llhttp_status_t; + +#define HTTP_ERRNO_MAP(XX) \ + XX(0, OK, OK) \ + XX(1, INTERNAL, INTERNAL) \ + XX(2, STRICT, STRICT) \ + XX(25, CR_EXPECTED, CR_EXPECTED) \ + XX(3, LF_EXPECTED, LF_EXPECTED) \ + XX(4, UNEXPECTED_CONTENT_LENGTH, UNEXPECTED_CONTENT_LENGTH) \ + XX(30, UNEXPECTED_SPACE, UNEXPECTED_SPACE) \ + XX(5, CLOSED_CONNECTION, CLOSED_CONNECTION) \ + XX(6, INVALID_METHOD, INVALID_METHOD) \ + XX(7, INVALID_URL, INVALID_URL) \ + XX(8, INVALID_CONSTANT, INVALID_CONSTANT) \ + XX(9, INVALID_VERSION, INVALID_VERSION) \ + XX(10, INVALID_HEADER_TOKEN, INVALID_HEADER_TOKEN) \ + XX(11, INVALID_CONTENT_LENGTH, INVALID_CONTENT_LENGTH) \ + XX(12, INVALID_CHUNK_SIZE, INVALID_CHUNK_SIZE) \ + XX(13, INVALID_STATUS, INVALID_STATUS) \ + XX(14, INVALID_EOF_STATE, INVALID_EOF_STATE) \ + XX(15, INVALID_TRANSFER_ENCODING, INVALID_TRANSFER_ENCODING) \ + XX(16, CB_MESSAGE_BEGIN, CB_MESSAGE_BEGIN) \ + XX(17, CB_HEADERS_COMPLETE, CB_HEADERS_COMPLETE) \ + XX(18, CB_MESSAGE_COMPLETE, CB_MESSAGE_COMPLETE) \ + XX(19, CB_CHUNK_HEADER, CB_CHUNK_HEADER) \ + XX(20, CB_CHUNK_COMPLETE, CB_CHUNK_COMPLETE) \ + XX(21, PAUSED, PAUSED) \ + XX(22, PAUSED_UPGRADE, PAUSED_UPGRADE) \ + XX(23, PAUSED_H2_UPGRADE, PAUSED_H2_UPGRADE) \ + XX(24, USER, USER) \ + XX(26, CB_URL_COMPLETE, CB_URL_COMPLETE) \ + XX(27, CB_STATUS_COMPLETE, CB_STATUS_COMPLETE) \ + XX(32, CB_METHOD_COMPLETE, CB_METHOD_COMPLETE) \ + XX(33, CB_VERSION_COMPLETE, CB_VERSION_COMPLETE) \ + XX(28, CB_HEADER_FIELD_COMPLETE, CB_HEADER_FIELD_COMPLETE) \ + XX(29, CB_HEADER_VALUE_COMPLETE, CB_HEADER_VALUE_COMPLETE) \ + XX(34, CB_CHUNK_EXTENSION_NAME_COMPLETE, CB_CHUNK_EXTENSION_NAME_COMPLETE) \ + XX(35, CB_CHUNK_EXTENSION_VALUE_COMPLETE, CB_CHUNK_EXTENSION_VALUE_COMPLETE) \ + XX(31, CB_RESET, CB_RESET) \ + + +#define HTTP_METHOD_MAP(XX) \ + XX(0, DELETE, DELETE) \ + XX(1, GET, GET) \ + XX(2, HEAD, HEAD) \ + XX(3, POST, POST) \ + XX(4, PUT, PUT) \ + XX(5, CONNECT, CONNECT) \ + XX(6, OPTIONS, OPTIONS) \ + XX(7, TRACE, TRACE) \ + XX(8, COPY, COPY) \ + XX(9, LOCK, LOCK) \ + XX(10, MKCOL, MKCOL) \ + XX(11, MOVE, MOVE) \ + XX(12, PROPFIND, PROPFIND) \ + XX(13, PROPPATCH, PROPPATCH) \ + XX(14, SEARCH, SEARCH) \ + XX(15, UNLOCK, UNLOCK) \ + XX(16, BIND, BIND) \ + XX(17, REBIND, REBIND) \ + XX(18, UNBIND, UNBIND) \ + XX(19, ACL, ACL) \ + XX(20, REPORT, REPORT) \ + XX(21, MKACTIVITY, MKACTIVITY) \ + XX(22, CHECKOUT, CHECKOUT) \ + XX(23, MERGE, MERGE) \ + XX(24, MSEARCH, M-SEARCH) \ + XX(25, NOTIFY, NOTIFY) \ + XX(26, SUBSCRIBE, SUBSCRIBE) \ + XX(27, UNSUBSCRIBE, UNSUBSCRIBE) \ + XX(28, PATCH, PATCH) \ + XX(29, PURGE, PURGE) \ + XX(30, MKCALENDAR, MKCALENDAR) \ + XX(31, LINK, LINK) \ + XX(32, UNLINK, UNLINK) \ + XX(33, SOURCE, SOURCE) \ + XX(46, QUERY, QUERY) \ + + +#define RTSP_METHOD_MAP(XX) \ + XX(1, GET, GET) \ + XX(3, POST, POST) \ + XX(6, OPTIONS, OPTIONS) \ + XX(35, DESCRIBE, DESCRIBE) \ + XX(36, ANNOUNCE, ANNOUNCE) \ + XX(37, SETUP, SETUP) \ + XX(38, PLAY, PLAY) \ + XX(39, PAUSE, PAUSE) \ + XX(40, TEARDOWN, TEARDOWN) \ + XX(41, GET_PARAMETER, GET_PARAMETER) \ + XX(42, SET_PARAMETER, SET_PARAMETER) \ + XX(43, REDIRECT, REDIRECT) \ + XX(44, RECORD, RECORD) \ + XX(45, FLUSH, FLUSH) \ + + +#define HTTP_ALL_METHOD_MAP(XX) \ + XX(0, DELETE, DELETE) \ + XX(1, GET, GET) \ + XX(2, HEAD, HEAD) \ + XX(3, POST, POST) \ + XX(4, PUT, PUT) \ + XX(5, CONNECT, CONNECT) \ + XX(6, OPTIONS, OPTIONS) \ + XX(7, TRACE, TRACE) \ + XX(8, COPY, COPY) \ + XX(9, LOCK, LOCK) \ + XX(10, MKCOL, MKCOL) \ + XX(11, MOVE, MOVE) \ + XX(12, PROPFIND, PROPFIND) \ + XX(13, PROPPATCH, PROPPATCH) \ + XX(14, SEARCH, SEARCH) \ + XX(15, UNLOCK, UNLOCK) \ + XX(16, BIND, BIND) \ + XX(17, REBIND, REBIND) \ + XX(18, UNBIND, UNBIND) \ + XX(19, ACL, ACL) \ + XX(20, REPORT, REPORT) \ + XX(21, MKACTIVITY, MKACTIVITY) \ + XX(22, CHECKOUT, CHECKOUT) \ + XX(23, MERGE, MERGE) \ + XX(24, MSEARCH, M-SEARCH) \ + XX(25, NOTIFY, NOTIFY) \ + XX(26, SUBSCRIBE, SUBSCRIBE) \ + XX(27, UNSUBSCRIBE, UNSUBSCRIBE) \ + XX(28, PATCH, PATCH) \ + XX(29, PURGE, PURGE) \ + XX(30, MKCALENDAR, MKCALENDAR) \ + XX(31, LINK, LINK) \ + XX(32, UNLINK, UNLINK) \ + XX(33, SOURCE, SOURCE) \ + XX(34, PRI, PRI) \ + XX(35, DESCRIBE, DESCRIBE) \ + XX(36, ANNOUNCE, ANNOUNCE) \ + XX(37, SETUP, SETUP) \ + XX(38, PLAY, PLAY) \ + XX(39, PAUSE, PAUSE) \ + XX(40, TEARDOWN, TEARDOWN) \ + XX(41, GET_PARAMETER, GET_PARAMETER) \ + XX(42, SET_PARAMETER, SET_PARAMETER) \ + XX(43, REDIRECT, REDIRECT) \ + XX(44, RECORD, RECORD) \ + XX(45, FLUSH, FLUSH) \ + XX(46, QUERY, QUERY) \ + + +#define HTTP_STATUS_MAP(XX) \ + XX(100, CONTINUE, CONTINUE) \ + XX(101, SWITCHING_PROTOCOLS, SWITCHING_PROTOCOLS) \ + XX(102, PROCESSING, PROCESSING) \ + XX(103, EARLY_HINTS, EARLY_HINTS) \ + XX(110, RESPONSE_IS_STALE, RESPONSE_IS_STALE) \ + XX(111, REVALIDATION_FAILED, REVALIDATION_FAILED) \ + XX(112, DISCONNECTED_OPERATION, DISCONNECTED_OPERATION) \ + XX(113, HEURISTIC_EXPIRATION, HEURISTIC_EXPIRATION) \ + XX(199, MISCELLANEOUS_WARNING, MISCELLANEOUS_WARNING) \ + XX(200, OK, OK) \ + XX(201, CREATED, CREATED) \ + XX(202, ACCEPTED, ACCEPTED) \ + XX(203, NON_AUTHORITATIVE_INFORMATION, NON_AUTHORITATIVE_INFORMATION) \ + XX(204, NO_CONTENT, NO_CONTENT) \ + XX(205, RESET_CONTENT, RESET_CONTENT) \ + XX(206, PARTIAL_CONTENT, PARTIAL_CONTENT) \ + XX(207, MULTI_STATUS, MULTI_STATUS) \ + XX(208, ALREADY_REPORTED, ALREADY_REPORTED) \ + XX(214, TRANSFORMATION_APPLIED, TRANSFORMATION_APPLIED) \ + XX(226, IM_USED, IM_USED) \ + XX(299, MISCELLANEOUS_PERSISTENT_WARNING, MISCELLANEOUS_PERSISTENT_WARNING) \ + XX(300, MULTIPLE_CHOICES, MULTIPLE_CHOICES) \ + XX(301, MOVED_PERMANENTLY, MOVED_PERMANENTLY) \ + XX(302, FOUND, FOUND) \ + XX(303, SEE_OTHER, SEE_OTHER) \ + XX(304, NOT_MODIFIED, NOT_MODIFIED) \ + XX(305, USE_PROXY, USE_PROXY) \ + XX(306, SWITCH_PROXY, SWITCH_PROXY) \ + XX(307, TEMPORARY_REDIRECT, TEMPORARY_REDIRECT) \ + XX(308, PERMANENT_REDIRECT, PERMANENT_REDIRECT) \ + XX(400, BAD_REQUEST, BAD_REQUEST) \ + XX(401, UNAUTHORIZED, UNAUTHORIZED) \ + XX(402, PAYMENT_REQUIRED, PAYMENT_REQUIRED) \ + XX(403, FORBIDDEN, FORBIDDEN) \ + XX(404, NOT_FOUND, NOT_FOUND) \ + XX(405, METHOD_NOT_ALLOWED, METHOD_NOT_ALLOWED) \ + XX(406, NOT_ACCEPTABLE, NOT_ACCEPTABLE) \ + XX(407, PROXY_AUTHENTICATION_REQUIRED, PROXY_AUTHENTICATION_REQUIRED) \ + XX(408, REQUEST_TIMEOUT, REQUEST_TIMEOUT) \ + XX(409, CONFLICT, CONFLICT) \ + XX(410, GONE, GONE) \ + XX(411, LENGTH_REQUIRED, LENGTH_REQUIRED) \ + XX(412, PRECONDITION_FAILED, PRECONDITION_FAILED) \ + XX(413, PAYLOAD_TOO_LARGE, PAYLOAD_TOO_LARGE) \ + XX(414, URI_TOO_LONG, URI_TOO_LONG) \ + XX(415, UNSUPPORTED_MEDIA_TYPE, UNSUPPORTED_MEDIA_TYPE) \ + XX(416, RANGE_NOT_SATISFIABLE, RANGE_NOT_SATISFIABLE) \ + XX(417, EXPECTATION_FAILED, EXPECTATION_FAILED) \ + XX(418, IM_A_TEAPOT, IM_A_TEAPOT) \ + XX(419, PAGE_EXPIRED, PAGE_EXPIRED) \ + XX(420, ENHANCE_YOUR_CALM, ENHANCE_YOUR_CALM) \ + XX(421, MISDIRECTED_REQUEST, MISDIRECTED_REQUEST) \ + XX(422, UNPROCESSABLE_ENTITY, UNPROCESSABLE_ENTITY) \ + XX(423, LOCKED, LOCKED) \ + XX(424, FAILED_DEPENDENCY, FAILED_DEPENDENCY) \ + XX(425, TOO_EARLY, TOO_EARLY) \ + XX(426, UPGRADE_REQUIRED, UPGRADE_REQUIRED) \ + XX(428, PRECONDITION_REQUIRED, PRECONDITION_REQUIRED) \ + XX(429, TOO_MANY_REQUESTS, TOO_MANY_REQUESTS) \ + XX(430, REQUEST_HEADER_FIELDS_TOO_LARGE_UNOFFICIAL, REQUEST_HEADER_FIELDS_TOO_LARGE_UNOFFICIAL) \ + XX(431, REQUEST_HEADER_FIELDS_TOO_LARGE, REQUEST_HEADER_FIELDS_TOO_LARGE) \ + XX(440, LOGIN_TIMEOUT, LOGIN_TIMEOUT) \ + XX(444, NO_RESPONSE, NO_RESPONSE) \ + XX(449, RETRY_WITH, RETRY_WITH) \ + XX(450, BLOCKED_BY_PARENTAL_CONTROL, BLOCKED_BY_PARENTAL_CONTROL) \ + XX(451, UNAVAILABLE_FOR_LEGAL_REASONS, UNAVAILABLE_FOR_LEGAL_REASONS) \ + XX(460, CLIENT_CLOSED_LOAD_BALANCED_REQUEST, CLIENT_CLOSED_LOAD_BALANCED_REQUEST) \ + XX(463, INVALID_X_FORWARDED_FOR, INVALID_X_FORWARDED_FOR) \ + XX(494, REQUEST_HEADER_TOO_LARGE, REQUEST_HEADER_TOO_LARGE) \ + XX(495, SSL_CERTIFICATE_ERROR, SSL_CERTIFICATE_ERROR) \ + XX(496, SSL_CERTIFICATE_REQUIRED, SSL_CERTIFICATE_REQUIRED) \ + XX(497, HTTP_REQUEST_SENT_TO_HTTPS_PORT, HTTP_REQUEST_SENT_TO_HTTPS_PORT) \ + XX(498, INVALID_TOKEN, INVALID_TOKEN) \ + XX(499, CLIENT_CLOSED_REQUEST, CLIENT_CLOSED_REQUEST) \ + XX(500, INTERNAL_SERVER_ERROR, INTERNAL_SERVER_ERROR) \ + XX(501, NOT_IMPLEMENTED, NOT_IMPLEMENTED) \ + XX(502, BAD_GATEWAY, BAD_GATEWAY) \ + XX(503, SERVICE_UNAVAILABLE, SERVICE_UNAVAILABLE) \ + XX(504, GATEWAY_TIMEOUT, GATEWAY_TIMEOUT) \ + XX(505, HTTP_VERSION_NOT_SUPPORTED, HTTP_VERSION_NOT_SUPPORTED) \ + XX(506, VARIANT_ALSO_NEGOTIATES, VARIANT_ALSO_NEGOTIATES) \ + XX(507, INSUFFICIENT_STORAGE, INSUFFICIENT_STORAGE) \ + XX(508, LOOP_DETECTED, LOOP_DETECTED) \ + XX(509, BANDWIDTH_LIMIT_EXCEEDED, BANDWIDTH_LIMIT_EXCEEDED) \ + XX(510, NOT_EXTENDED, NOT_EXTENDED) \ + XX(511, NETWORK_AUTHENTICATION_REQUIRED, NETWORK_AUTHENTICATION_REQUIRED) \ + XX(520, WEB_SERVER_UNKNOWN_ERROR, WEB_SERVER_UNKNOWN_ERROR) \ + XX(521, WEB_SERVER_IS_DOWN, WEB_SERVER_IS_DOWN) \ + XX(522, CONNECTION_TIMEOUT, CONNECTION_TIMEOUT) \ + XX(523, ORIGIN_IS_UNREACHABLE, ORIGIN_IS_UNREACHABLE) \ + XX(524, TIMEOUT_OCCURED, TIMEOUT_OCCURED) \ + XX(525, SSL_HANDSHAKE_FAILED, SSL_HANDSHAKE_FAILED) \ + XX(526, INVALID_SSL_CERTIFICATE, INVALID_SSL_CERTIFICATE) \ + XX(527, RAILGUN_ERROR, RAILGUN_ERROR) \ + XX(529, SITE_IS_OVERLOADED, SITE_IS_OVERLOADED) \ + XX(530, SITE_IS_FROZEN, SITE_IS_FROZEN) \ + XX(561, IDENTITY_PROVIDER_AUTHENTICATION_ERROR, IDENTITY_PROVIDER_AUTHENTICATION_ERROR) \ + XX(598, NETWORK_READ_TIMEOUT, NETWORK_READ_TIMEOUT) \ + XX(599, NETWORK_CONNECT_TIMEOUT, NETWORK_CONNECT_TIMEOUT) \ + + +#ifdef __cplusplus +} /* extern "C" */ +#endif +#endif /* LLLLHTTP_C_HEADERS_ */ + + +#ifndef INCLUDE_LLHTTP_API_H_ +#define INCLUDE_LLHTTP_API_H_ +#ifdef __cplusplus +extern "C" { +#endif +#include + +#define LLHTTP_EXPORT + +typedef llhttp__internal_t llhttp_t; +typedef struct llhttp_settings_s llhttp_settings_t; + +typedef int (*llhttp_data_cb)(llhttp_t*, const char *at, size_t length); +typedef int (*llhttp_cb)(llhttp_t*); + +struct llhttp_settings_s { + /* Possible return values 0, -1, `HPE_PAUSED` */ + llhttp_cb on_message_begin; + + /* Possible return values 0, -1, HPE_USER */ + llhttp_data_cb on_url; + llhttp_data_cb on_status; + llhttp_data_cb on_method; + llhttp_data_cb on_version; + llhttp_data_cb on_header_field; + llhttp_data_cb on_header_value; + llhttp_data_cb on_chunk_extension_name; + llhttp_data_cb on_chunk_extension_value; + + /* Possible return values: + * 0 - Proceed normally + * 1 - Assume that request/response has no body, and proceed to parsing the + * next message + * 2 - Assume absence of body (as above) and make `llhttp_execute()` return + * `HPE_PAUSED_UPGRADE` + * -1 - Error + * `HPE_PAUSED` + */ + llhttp_cb on_headers_complete; + + /* Possible return values 0, -1, HPE_USER */ + llhttp_data_cb on_body; + + /* Possible return values 0, -1, `HPE_PAUSED` */ + llhttp_cb on_message_complete; + llhttp_cb on_url_complete; + llhttp_cb on_status_complete; + llhttp_cb on_method_complete; + llhttp_cb on_version_complete; + llhttp_cb on_header_field_complete; + llhttp_cb on_header_value_complete; + llhttp_cb on_chunk_extension_name_complete; + llhttp_cb on_chunk_extension_value_complete; + + /* When on_chunk_header is called, the current chunk length is stored + * in parser->content_length. + * Possible return values 0, -1, `HPE_PAUSED` + */ + llhttp_cb on_chunk_header; + llhttp_cb on_chunk_complete; + llhttp_cb on_reset; +}; + +/* Initialize the parser with specific type and user settings. + * + * NOTE: lifetime of `settings` has to be at least the same as the lifetime of + * the `parser` here. In practice, `settings` has to be either a static + * variable or be allocated with `malloc`, `new`, etc. + */ +LLHTTP_EXPORT +void llhttp_init(llhttp_t* parser, llhttp_type_t type, + const llhttp_settings_t* settings); + +LLHTTP_EXPORT +llhttp_t* llhttp_alloc(llhttp_type_t type); + +LLHTTP_EXPORT +void llhttp_free(llhttp_t* parser); + +LLHTTP_EXPORT +uint8_t llhttp_get_type(llhttp_t* parser); + +LLHTTP_EXPORT +uint8_t llhttp_get_http_major(llhttp_t* parser); + +LLHTTP_EXPORT +uint8_t llhttp_get_http_minor(llhttp_t* parser); + +LLHTTP_EXPORT +uint8_t llhttp_get_method(llhttp_t* parser); + +LLHTTP_EXPORT +int llhttp_get_status_code(llhttp_t* parser); + +LLHTTP_EXPORT +uint8_t llhttp_get_upgrade(llhttp_t* parser); + +/* Reset an already initialized parser back to the start state, preserving the + * existing parser type, callback settings, user data, and lenient flags. + */ +LLHTTP_EXPORT +void llhttp_reset(llhttp_t* parser); + +/* Initialize the settings object */ +LLHTTP_EXPORT +void llhttp_settings_init(llhttp_settings_t* settings); + +/* Parse full or partial request/response, invoking user callbacks along the + * way. + * + * If any of `llhttp_data_cb` returns errno not equal to `HPE_OK` - the parsing + * interrupts, and such errno is returned from `llhttp_execute()`. If + * `HPE_PAUSED` was used as a errno, the execution can be resumed with + * `llhttp_resume()` call. + * + * In a special case of CONNECT/Upgrade request/response `HPE_PAUSED_UPGRADE` + * is returned after fully parsing the request/response. If the user wishes to + * continue parsing, they need to invoke `llhttp_resume_after_upgrade()`. + * + * NOTE: if this function ever returns a non-pause type error, it will continue + * to return the same error upon each successive call up until `llhttp_init()` + * is called. + */ +LLHTTP_EXPORT +llhttp_errno_t llhttp_execute(llhttp_t* parser, const char* data, size_t len); + +/* This method should be called when the other side has no further bytes to + * send (e.g. shutdown of readable side of the TCP connection.) + * + * Requests without `Content-Length` and other messages might require treating + * all incoming bytes as the part of the body, up to the last byte of the + * connection. This method will invoke `on_message_complete()` callback if the + * request was terminated safely. Otherwise a error code would be returned. + */ +LLHTTP_EXPORT +llhttp_errno_t llhttp_finish(llhttp_t* parser); + +/* Returns `1` if the incoming message is parsed until the last byte, and has + * to be completed by calling `llhttp_finish()` on EOF + */ +LLHTTP_EXPORT +int llhttp_message_needs_eof(const llhttp_t* parser); + +/* Returns `1` if there might be any other messages following the last that was + * successfully parsed. + */ +LLHTTP_EXPORT +int llhttp_should_keep_alive(const llhttp_t* parser); + +/* Make further calls of `llhttp_execute()` return `HPE_PAUSED` and set + * appropriate error reason. + * + * Important: do not call this from user callbacks! User callbacks must return + * `HPE_PAUSED` if pausing is required. + */ +LLHTTP_EXPORT +void llhttp_pause(llhttp_t* parser); + +/* Might be called to resume the execution after the pause in user's callback. + * See `llhttp_execute()` above for details. + * + * Call this only if `llhttp_execute()` returns `HPE_PAUSED`. + */ +LLHTTP_EXPORT +void llhttp_resume(llhttp_t* parser); + +/* Might be called to resume the execution after the pause in user's callback. + * See `llhttp_execute()` above for details. + * + * Call this only if `llhttp_execute()` returns `HPE_PAUSED_UPGRADE` + */ +LLHTTP_EXPORT +void llhttp_resume_after_upgrade(llhttp_t* parser); + +/* Returns the latest return error */ +LLHTTP_EXPORT +llhttp_errno_t llhttp_get_errno(const llhttp_t* parser); + +/* Returns the verbal explanation of the latest returned error. + * + * Note: User callback should set error reason when returning the error. See + * `llhttp_set_error_reason()` for details. + */ +LLHTTP_EXPORT +const char* llhttp_get_error_reason(const llhttp_t* parser); + +/* Assign verbal description to the returned error. Must be called in user + * callbacks right before returning the errno. + * + * Note: `HPE_USER` error code might be useful in user callbacks. + */ +LLHTTP_EXPORT +void llhttp_set_error_reason(llhttp_t* parser, const char* reason); + +/* Returns the pointer to the last parsed byte before the returned error. The + * pointer is relative to the `data` argument of `llhttp_execute()`. + * + * Note: this method might be useful for counting the number of parsed bytes. + */ +LLHTTP_EXPORT +const char* llhttp_get_error_pos(const llhttp_t* parser); + +/* Returns textual name of error code */ +LLHTTP_EXPORT +const char* llhttp_errno_name(llhttp_errno_t err); + +/* Returns textual name of HTTP method */ +LLHTTP_EXPORT +const char* llhttp_method_name(llhttp_method_t method); + +/* Returns textual name of HTTP status */ +LLHTTP_EXPORT +const char* llhttp_status_name(llhttp_status_t status); + +/* Enables/disables lenient header value parsing (disabled by default). + * + * Lenient parsing disables header value token checks, extending llhttp's + * protocol support to highly non-compliant clients/server. No + * `HPE_INVALID_HEADER_TOKEN` will be raised for incorrect header values when + * lenient parsing is "on". + * + * **Enabling this flag can pose a security issue since you will be exposed to + * request smuggling attacks. USE WITH CAUTION!** + */ +LLHTTP_EXPORT +void llhttp_set_lenient_headers(llhttp_t* parser, int enabled); + + +/* Enables/disables lenient handling of conflicting `Transfer-Encoding` and + * `Content-Length` headers (disabled by default). + * + * Normally `llhttp` would error when `Transfer-Encoding` is present in + * conjunction with `Content-Length`. This error is important to prevent HTTP + * request smuggling, but may be less desirable for small number of cases + * involving legacy servers. + * + * **Enabling this flag can pose a security issue since you will be exposed to + * request smuggling attacks. USE WITH CAUTION!** + */ +LLHTTP_EXPORT +void llhttp_set_lenient_chunked_length(llhttp_t* parser, int enabled); + + +/* Enables/disables lenient handling of `Connection: close` and HTTP/1.0 + * requests responses. + * + * Normally `llhttp` would error on (in strict mode) or discard (in loose mode) + * the HTTP request/response after the request/response with `Connection: close` + * and `Content-Length`. This is important to prevent cache poisoning attacks, + * but might interact badly with outdated and insecure clients. With this flag + * the extra request/response will be parsed normally. + * + * **Enabling this flag can pose a security issue since you will be exposed to + * poisoning attacks. USE WITH CAUTION!** + */ +LLHTTP_EXPORT +void llhttp_set_lenient_keep_alive(llhttp_t* parser, int enabled); + +/* Enables/disables lenient handling of `Transfer-Encoding` header. + * + * Normally `llhttp` would error when a `Transfer-Encoding` has `chunked` value + * and another value after it (either in a single header or in multiple + * headers whose value are internally joined using `, `). + * This is mandated by the spec to reliably determine request body size and thus + * avoid request smuggling. + * With this flag the extra value will be parsed normally. + * + * **Enabling this flag can pose a security issue since you will be exposed to + * request smuggling attacks. USE WITH CAUTION!** + */ +LLHTTP_EXPORT +void llhttp_set_lenient_transfer_encoding(llhttp_t* parser, int enabled); + +/* Enables/disables lenient handling of HTTP version. + * + * Normally `llhttp` would error when the HTTP version in the request or status line + * is not `0.9`, `1.0`, `1.1` or `2.0`. + * With this flag the invalid value will be parsed normally. + * + * **Enabling this flag can pose a security issue since you will allow unsupported + * HTTP versions. USE WITH CAUTION!** + */ +LLHTTP_EXPORT +void llhttp_set_lenient_version(llhttp_t* parser, int enabled); + +/* Enables/disables lenient handling of additional data received after a message ends + * and keep-alive is disabled. + * + * Normally `llhttp` would error when additional unexpected data is received if the message + * contains the `Connection` header with `close` value. + * With this flag the extra data will discarded without throwing an error. + * + * **Enabling this flag can pose a security issue since you will be exposed to + * poisoning attacks. USE WITH CAUTION!** + */ +LLHTTP_EXPORT +void llhttp_set_lenient_data_after_close(llhttp_t* parser, int enabled); + +/* Enables/disables lenient handling of incomplete CRLF sequences. + * + * Normally `llhttp` would error when a CR is not followed by LF when terminating the + * request line, the status line, the headers or a chunk header. + * With this flag only a CR is required to terminate such sections. + * + * **Enabling this flag can pose a security issue since you will be exposed to + * request smuggling attacks. USE WITH CAUTION!** + */ +LLHTTP_EXPORT +void llhttp_set_lenient_optional_lf_after_cr(llhttp_t* parser, int enabled); + +/* + * Enables/disables lenient handling of line separators. + * + * Normally `llhttp` would error when a LF is not preceded by CR when terminating the + * request line, the status line, the headers, a chunk header or a chunk data. + * With this flag only a LF is required to terminate such sections. + * + * **Enabling this flag can pose a security issue since you will be exposed to + * request smuggling attacks. USE WITH CAUTION!** + */ +LLHTTP_EXPORT +void llhttp_set_lenient_optional_cr_before_lf(llhttp_t* parser, int enabled); + +/* Enables/disables lenient handling of chunks not separated via CRLF. + * + * Normally `llhttp` would error when after a chunk data a CRLF is missing before + * starting a new chunk. + * With this flag the new chunk can start immediately after the previous one. + * + * **Enabling this flag can pose a security issue since you will be exposed to + * request smuggling attacks. USE WITH CAUTION!** + */ +LLHTTP_EXPORT +void llhttp_set_lenient_optional_crlf_after_chunk(llhttp_t* parser, int enabled); + +/* Enables/disables lenient handling of spaces after chunk size. + * + * Normally `llhttp` would error when after a chunk size is followed by one or more + * spaces are present instead of a CRLF or `;`. + * With this flag this check is disabled. + * + * **Enabling this flag can pose a security issue since you will be exposed to + * request smuggling attacks. USE WITH CAUTION!** + */ +LLHTTP_EXPORT +void llhttp_set_lenient_spaces_after_chunk_size(llhttp_t* parser, int enabled); + +#ifdef __cplusplus +} /* extern "C" */ +#endif +#endif /* INCLUDE_LLHTTP_API_H_ */ + + +#endif /* INCLUDE_LLHTTP_H_ */ From d396819101a67c652af0fa0ae65cda19a2c0430a Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 19 Apr 2024 21:07:11 +0100 Subject: [PATCH 581/608] http: abstract http parsing out of httpclient Avoid #ifdef's in httpclient.c, and move http parsing into its own file. --- cmake/SelectHTTPParser.cmake | 53 ++++----- src/libgit2/transports/httpclient.c | 178 +++++++++------------------- src/libgit2/transports/httpparser.c | 126 ++++++++++++++++++++ src/libgit2/transports/httpparser.h | 99 ++++++++++++++++ src/util/git2_features.h.in | 4 + 5 files changed, 305 insertions(+), 155 deletions(-) create mode 100644 src/libgit2/transports/httpparser.c create mode 100644 src/libgit2/transports/httpparser.h diff --git a/cmake/SelectHTTPParser.cmake b/cmake/SelectHTTPParser.cmake index aa6711d9607..111170cb259 100644 --- a/cmake/SelectHTTPParser.cmake +++ b/cmake/SelectHTTPParser.cmake @@ -1,39 +1,32 @@ # Optional external dependency: http-parser -if(USE_HTTP_PARSER STREQUAL "builtin") - message(STATUS "support for bundled (legacy) http-parser explicitly requested") +if(USE_HTTP_PARSER STREQUAL "http-parser") + find_package(HTTPParser) - add_subdirectory("${PROJECT_SOURCE_DIR}/deps/http-parser" "${PROJECT_BINARY_DIR}/deps/http-parser") - list(APPEND LIBGIT2_DEPENDENCY_INCLUDES "${PROJECT_SOURCE_DIR}/deps/http-parser") - list(APPEND LIBGIT2_DEPENDENCY_OBJECTS "$") - add_feature_info(http-parser ON "http-parser support (bundled)") -else() - # By default, try to use system LLHTTP. Fall back to - # system http-parser, and even to bundled http-parser - # as a last resort. - find_package(LLHTTP) + if(HTTP_PARSER_FOUND AND HTTP_PARSER_VERSION_MAJOR EQUAL 2) + list(APPEND LIBGIT2_SYSTEM_INCLUDES ${HTTP_PARSER_INCLUDE_DIRS}) + list(APPEND LIBGIT2_SYSTEM_LIBS ${HTTP_PARSER_LIBRARIES}) + list(APPEND LIBGIT2_PC_LIBS "-lhttp_parser") + set(GIT_HTTPPARSER_HTTPPARSER 1) + add_feature_info(http-parser ON "using http-parser (system)") + else() + message(FATAL_ERROR "http-parser support was requested but not found") + endif() +elseif(USE_HTTP_PARSER STREQUAL "llhttp") + find_package(LLHTTP) if(LLHTTP_FOUND AND LLHTTP_VERSION_MAJOR EQUAL 9) - add_compile_definitions(USE_LLHTTP) list(APPEND LIBGIT2_SYSTEM_INCLUDES ${LLHTTP_INCLUDE_DIRS}) list(APPEND LIBGIT2_SYSTEM_LIBS ${LLHTTP_LIBRARIES}) list(APPEND LIBGIT2_PC_LIBS "-lllhttp") - add_feature_info(llhttp ON "llhttp support (system)") + set(GIT_HTTPPARSER_LLHTTP 1) + add_feature_info(http-parser ON "using llhttp (system)") else() - message(STATUS "llhttp support was requested but not found; checking (legacy) http-parser support") - find_package(HTTPParser) - - if(HTTP_PARSER_FOUND AND HTTP_PARSER_VERSION_MAJOR EQUAL 2) - list(APPEND LIBGIT2_SYSTEM_INCLUDES ${HTTP_PARSER_INCLUDE_DIRS}) - list(APPEND LIBGIT2_SYSTEM_LIBS ${HTTP_PARSER_LIBRARIES}) - list(APPEND LIBGIT2_PC_LIBS "-lhttp_parser") - add_feature_info(http-parser ON "http-parser support (system)") - else() - message(STATUS "neither llhttp nor http-parser support was found; proceeding with bundled (legacy) http-parser") - - add_subdirectory("${PROJECT_SOURCE_DIR}/deps/http-parser" "${PROJECT_BINARY_DIR}/deps/http-parser") - list(APPEND LIBGIT2_DEPENDENCY_INCLUDES "${PROJECT_SOURCE_DIR}/deps/http-parser") - list(APPEND LIBGIT2_DEPENDENCY_OBJECTS "$") - add_feature_info(http-parser ON "http-parser support (bundled)") - endif() - endif() + message(FATAL_ERROR "llhttp support was requested but not found") + endif() +else() + add_subdirectory("${PROJECT_SOURCE_DIR}/deps/http-parser" "${PROJECT_BINARY_DIR}/deps/http-parser") + list(APPEND LIBGIT2_DEPENDENCY_INCLUDES "${PROJECT_SOURCE_DIR}/deps/http-parser") + list(APPEND LIBGIT2_DEPENDENCY_OBJECTS "$") + set(GIT_HTTPPARSER_BUILTIN 1) + add_feature_info(http-parser ON "using bundled parser") endif() diff --git a/src/libgit2/transports/httpclient.c b/src/libgit2/transports/httpclient.c index 6e3491ed2b3..9937e9484b1 100644 --- a/src/libgit2/transports/httpclient.c +++ b/src/libgit2/transports/httpclient.c @@ -8,31 +8,6 @@ #include "common.h" #include "git2.h" -#ifdef USE_LLHTTP -#include -typedef llhttp_settings_t http_settings_t; -typedef llhttp_t http_parser_t; -GIT_INLINE(http_settings_t *) http_client_parser_settings(void); -#define git_http_parser_init(parser) llhttp_init(parser, HTTP_RESPONSE, http_client_parser_settings()) -#define git_http_parser_pause(parser) llhttp_pause(parser) -#define git_http_parser_resume(parser) llhttp_resume(parser) -#define git_http_parser_errno(parser) parser.error -#define git_http_should_keep_alive(parser) llhttp_should_keep_alive(parser) -#define git_http_errno_description(parser, errno) llhttp_get_error_reason(parser) -#else -#include -/* Legacy http-parser. */ -typedef http_parser_settings http_settings_t; -typedef struct http_parser http_parser_t; -GIT_INLINE(http_settings_t *) http_client_parser_settings(void); -#define git_http_parser_init(parser) http_parser_init(parser, HTTP_RESPONSE) -#define git_http_parser_pause(parser) http_parser_pause(parser, 1) -#define git_http_parser_resume(parser) http_parser_pause(parser, 0) -#define git_http_parser_errno(parser) parser.http_errno -#define git_http_should_keep_alive(parser) http_should_keep_alive(parser) -#define git_http_errno_description(parser, errno) http_errno_description(errno) -#endif /* USE_LLHTTP */ - #include "vector.h" #include "trace.h" #include "httpclient.h" @@ -46,6 +21,7 @@ GIT_INLINE(http_settings_t *) http_client_parser_settings(void); #include "streams/socket.h" #include "streams/tls.h" #include "auth.h" +#include "httpparser.h" static git_http_auth_scheme auth_schemes[] = { { GIT_HTTP_AUTH_NEGOTIATE, "Negotiate", GIT_CREDENTIAL_DEFAULT, git_http_auth_negotiate }, @@ -133,7 +109,7 @@ struct git_http_client { git_http_server_t current_server; http_client_state state; - http_parser_t parser; + git_http_parser parser; git_http_server server; git_http_server proxy; @@ -179,7 +155,7 @@ void git_http_response_dispose(git_http_response *response) memset(response, 0, sizeof(git_http_response)); } -static int on_header_complete(http_parser_t *parser) +static int on_header_complete(git_http_parser *parser) { http_parser_context *ctx = (http_parser_context *) parser->data; git_http_client *client = ctx->client; @@ -244,7 +220,7 @@ static int on_header_complete(http_parser_t *parser) return 0; } -static int on_header_field(http_parser_t *parser, const char *str, size_t len) +static int on_header_field(git_http_parser *parser, const char *str, size_t len) { http_parser_context *ctx = (http_parser_context *) parser->data; @@ -279,7 +255,7 @@ static int on_header_field(http_parser_t *parser, const char *str, size_t len) return 0; } -static int on_header_value(http_parser_t *parser, const char *str, size_t len) +static int on_header_value(git_http_parser *parser, const char *str, size_t len) { http_parser_context *ctx = (http_parser_context *) parser->data; @@ -367,7 +343,7 @@ static int resend_needed(git_http_client *client, git_http_response *response) return 0; } -static int on_headers_complete(http_parser_t *parser) +static int on_headers_complete(git_http_parser *parser) { http_parser_context *ctx = (http_parser_context *) parser->data; @@ -389,8 +365,8 @@ static int on_headers_complete(http_parser_t *parser) return ctx->parse_status = PARSE_STATUS_ERROR; } - ctx->response->status = parser->status_code; - ctx->client->keepalive = git_http_should_keep_alive(parser); + ctx->response->status = git_http_parser_status_code(parser); + ctx->client->keepalive = git_http_parser_keep_alive(parser); /* Prepare for authentication */ collect_authinfo(&ctx->response->server_auth_schemetypes, @@ -403,28 +379,15 @@ static int on_headers_complete(http_parser_t *parser) ctx->response->resend_credentials = resend_needed(ctx->client, ctx->response); -#ifndef USE_LLHTTP - /* Stop parsing. llhttp documentation says about llhttp_pause(): - * "Do not call this from user callbacks! User callbacks must - * return HPE_PAUSED if pausing is required", so that's what - * we will do, and call git_http_parser_pause() only for - * http-parser. */ - git_http_parser_pause(parser); -#endif - if (ctx->response->content_type || ctx->response->chunked) ctx->client->state = READING_BODY; else ctx->client->state = DONE; -#ifdef USE_LLHTTP - return HPE_PAUSED; -#else - return 0; -#endif + return git_http_parser_pause(parser); } -static int on_body(http_parser_t *parser, const char *buf, size_t len) +static int on_body(git_http_parser *parser, const char *buf, size_t len) { http_parser_context *ctx = (http_parser_context *) parser->data; size_t max_len; @@ -446,7 +409,7 @@ static int on_body(http_parser_t *parser, const char *buf, size_t len) return 0; } -static int on_message_complete(http_parser_t *parser) +static int on_message_complete(git_http_parser *parser) { http_parser_context *ctx = (http_parser_context *) parser->data; @@ -911,9 +874,29 @@ GIT_INLINE(int) server_setup_from_url( return 0; } +static bool parser_settings_initialized; +static git_http_parser_settings parser_settings; + +GIT_INLINE(git_http_parser_settings *) http_client_parser_settings(void) +{ + if (!parser_settings_initialized) { + parser_settings.on_header_field = on_header_field; + parser_settings.on_header_value = on_header_value; + parser_settings.on_headers_complete = on_headers_complete; + parser_settings.on_body = on_body; + parser_settings.on_message_complete = on_message_complete; + + parser_settings_initialized = true; + } + + return &parser_settings; +} + static void reset_parser(git_http_client *client) { - git_http_parser_init(&client->parser); + git_http_parser_init(&client->parser, + GIT_HTTP_PARSER_RESPONSE, + http_client_parser_settings()); } static int setup_hosts( @@ -1156,64 +1139,9 @@ GIT_INLINE(int) client_read(git_http_client *client) return (int)read_len; } -static bool parser_settings_initialized; -static http_settings_t parser_settings; - -static size_t git_http_parser_execute(http_parser_t *parser, const char* data, size_t len) -{ -#ifdef USE_LLHTTP - llhttp_errno_t error; - size_t parsed_len; - - /* - * Unlike http_parser, which returns the number of parsed - * bytes in the _execute() call, llhttp returns an error - * code. - */ - - if (data == NULL || len == 0) { - error = llhttp_finish(parser); - } else { - error = llhttp_execute(parser, data, len); - } - - parsed_len = len; - /* - * Adjust number of parsed bytes in case of error. - */ - if (error != HPE_OK) { - parsed_len = llhttp_get_error_pos(parser) - data; - - /* This isn't a real pause, just a way to stop parsing early. */ - if (error == HPE_PAUSED_UPGRADE) { - llhttp_resume_after_upgrade(parser); - } - } - - return parsed_len; -#else - return http_parser_execute(parser, http_client_parser_settings(), data, len); -#endif -} - -GIT_INLINE(http_settings_t *) http_client_parser_settings(void) -{ - if (!parser_settings_initialized) { - parser_settings.on_header_field = on_header_field; - parser_settings.on_header_value = on_header_value; - parser_settings.on_headers_complete = on_headers_complete; - parser_settings.on_body = on_body; - parser_settings.on_message_complete = on_message_complete; - - parser_settings_initialized = true; - } - - return &parser_settings; -} - GIT_INLINE(int) client_read_and_parse(git_http_client *client) { - http_parser_t *parser = &client->parser; + git_http_parser *parser = &client->parser; http_parser_context *ctx = (http_parser_context *) parser->data; unsigned char http_errno; int read_len; @@ -1230,7 +1158,7 @@ GIT_INLINE(int) client_read_and_parse(git_http_client *client) parsed_len = git_http_parser_execute(parser, client->read_buf.ptr, client->read_buf.size); - http_errno = git_http_parser_errno(client->parser); + http_errno = git_http_parser_errno(parser); if (parsed_len > INT_MAX) { git_error_set(GIT_ERROR_HTTP, "unexpectedly large parse"); @@ -1249,29 +1177,29 @@ GIT_INLINE(int) client_read_and_parse(git_http_client *client) * (This can happen in response to an expect/continue request, * where the server gives you a 100 and 200 simultaneously.) */ - if (http_errno == HPE_PAUSED) { -#ifndef USE_LLHTTP - /* - * http-parser has a "feature" where it will not deliver the - * final byte when paused in a callback. Consume that byte. - * https://github.com/nodejs/http-parser/issues/97 - */ - GIT_ASSERT(client->read_buf.size > parsed_len); + if (http_errno == GIT_HTTP_PARSER_PAUSED) { + size_t additional_size; -#endif git_http_parser_resume(parser); -#ifndef USE_LLHTTP - parsed_len += git_http_parser_execute(parser, - client->read_buf.ptr + parsed_len, - 1); -#endif + /* + * http-parser has a "feature" where it will not deliver + * the final byte when paused in a callback. Consume + * that byte. + */ + if ((additional_size = git_http_parser_remain_after_pause(parser)) > 0) { + GIT_ASSERT((client->read_buf.size - parsed_len) >= additional_size); + + parsed_len += git_http_parser_execute(parser, + client->read_buf.ptr + parsed_len, + additional_size); + } } /* Most failures will be reported in http_errno */ - else if (git_http_parser_errno(client->parser) != HPE_OK) { + else if (git_http_parser_errno(parser) != GIT_HTTP_PARSER_OK) { git_error_set(GIT_ERROR_HTTP, "http parser error: %s", - git_http_errno_description(parser, http_errno)); + git_http_parser_errmsg(parser, http_errno)); return -1; } @@ -1279,7 +1207,7 @@ GIT_INLINE(int) client_read_and_parse(git_http_client *client) else if (parsed_len != client->read_buf.size) { git_error_set(GIT_ERROR_HTTP, "http parser did not consume entire buffer: %s", - git_http_errno_description(parser, http_errno)); + git_http_parser_errmsg(parser, http_errno)); return -1; } @@ -1318,7 +1246,7 @@ static void complete_response_body(git_http_client *client) /* If there was an error, just close the connection. */ if (client_read_and_parse(client) < 0 || - parser_context.error != HPE_OK || + parser_context.error != GIT_HTTP_PARSER_OK || (parser_context.parse_status != PARSE_STATUS_OK && parser_context.parse_status != PARSE_STATUS_NO_OUTPUT)) { git_error_clear(); @@ -1596,7 +1524,7 @@ int git_http_client_skip_body(git_http_client *client) do { error = client_read_and_parse(client); - if (parser_context.error != HPE_OK || + if (parser_context.error != GIT_HTTP_PARSER_OK || (parser_context.parse_status != PARSE_STATUS_OK && parser_context.parse_status != PARSE_STATUS_NO_OUTPUT)) { git_error_set(GIT_ERROR_HTTP, diff --git a/src/libgit2/transports/httpparser.c b/src/libgit2/transports/httpparser.c new file mode 100644 index 00000000000..abd8f0244c7 --- /dev/null +++ b/src/libgit2/transports/httpparser.c @@ -0,0 +1,126 @@ +/* + * Copyright (C) the libgit2 contributors. All rights reserved. + * + * This file is part of libgit2, distributed under the GNU GPL v2 with + * a Linking Exception. For full terms see the included COPYING file. + */ + +#include "httpparser.h" + +#include + +#if defined(GIT_HTTPPARSER_HTTPPARSER) || defined(GIT_HTTPPARSER_BUILTIN) + +#include "http_parser.h" + +static int on_message_begin(http_parser *p) +{ + git_http_parser *parser = (git_http_parser *)p; + return parser->settings.on_message_begin(parser); +} + +static int on_url(http_parser *p, const char *str, size_t len) +{ + git_http_parser *parser = (git_http_parser *)p; + return parser->settings.on_url(parser, str, len); +} + +static int on_header_field(http_parser *p, const char *str, size_t len) +{ + git_http_parser *parser = (git_http_parser *)p; + return parser->settings.on_header_field(parser, str, len); +} + +static int on_header_value(http_parser *p, const char *str, size_t len) +{ + git_http_parser *parser = (git_http_parser *)p; + return parser->settings.on_header_value(parser, str, len); +} + +static int on_headers_complete(http_parser *p) +{ + git_http_parser *parser = (git_http_parser *)p; + return parser->settings.on_headers_complete(parser); +} + +static int on_body(http_parser *p, const char *buf, size_t len) +{ + git_http_parser *parser = (git_http_parser *)p; + return parser->settings.on_body(parser, buf, len); +} + +static int on_message_complete(http_parser *p) +{ + git_http_parser *parser = (git_http_parser *)p; + return parser->settings.on_message_complete(parser); +} + +void git_http_parser_init( + git_http_parser *parser, + git_http_parser_t type, + git_http_parser_settings *settings) +{ + http_parser_init(&parser->parser, (enum http_parser_type)type); + memcpy(&parser->settings, settings, sizeof(git_http_parser_settings)); +} + +size_t git_http_parser_execute( + git_http_parser *parser, + const char *data, + size_t len) +{ + struct http_parser_settings settings_proxy; + + settings_proxy.on_message_begin = parser->settings.on_message_begin ? on_message_begin : NULL; + settings_proxy.on_url = parser->settings.on_url ? on_url : NULL; + settings_proxy.on_header_field = parser->settings.on_header_field ? on_header_field : NULL; + settings_proxy.on_header_value = parser->settings.on_header_value ? on_header_value : NULL; + settings_proxy.on_headers_complete = parser->settings.on_headers_complete ? on_headers_complete : NULL; + settings_proxy.on_body = parser->settings.on_body ? on_body : NULL; + settings_proxy.on_message_complete = parser->settings.on_message_complete ? on_message_complete : NULL; + + return http_parser_execute(&parser->parser, &settings_proxy, data, len); +} + +#elif defined(GIT_HTTPPARSER_LLHTTP) + +# include + +size_t git_http_parser_execute( + git_http_parser *parser, + const char* data, + size_t len) +{ + llhttp_errno_t error; + size_t parsed_len; + + /* + * Unlike http_parser, which returns the number of parsed + * bytes in the _execute() call, llhttp returns an error + * code. + */ + + if (data == NULL || len == 0) + error = llhttp_finish(parser); + else + error = llhttp_execute(parser, data, len); + + parsed_len = len; + + /* + * Adjust number of parsed bytes in case of error. + */ + if (error != HPE_OK) { + parsed_len = llhttp_get_error_pos(parser) - data; + + /* This isn't a real pause, just a way to stop parsing early. */ + if (error == HPE_PAUSED_UPGRADE) + llhttp_resume_after_upgrade(parser); + } + + return parsed_len; +} + +#else +# error unknown http-parser +#endif diff --git a/src/libgit2/transports/httpparser.h b/src/libgit2/transports/httpparser.h new file mode 100644 index 00000000000..616be587edd --- /dev/null +++ b/src/libgit2/transports/httpparser.h @@ -0,0 +1,99 @@ +/* + * Copyright (C) the libgit2 contributors. All rights reserved. + * + * This file is part of libgit2, distributed under the GNU GPL v2 with + * a Linking Exception. For full terms see the included COPYING file. + */ + +#ifndef INCLUDE_transports_httpparser_h__ +#define INCLUDE_transports_httpparser_h__ + +#include "git2_util.h" + +#if defined(GIT_HTTPPARSER_HTTPPARSER) || defined(GIT_HTTPPARSER_BUILTIN) + +# include + +typedef enum { + GIT_HTTP_PARSER_OK = HPE_OK, + GIT_HTTP_PARSER_PAUSED = HPE_PAUSED, +} git_http_parser_error_t; + +typedef enum { + GIT_HTTP_PARSER_REQUEST = HTTP_REQUEST, + GIT_HTTP_PARSER_RESPONSE = HTTP_RESPONSE, +} git_http_parser_t; + +typedef struct git_http_parser git_http_parser; + +typedef struct { + int (*on_message_begin)(git_http_parser *); + int (*on_url)(git_http_parser *, const char *, size_t); + int (*on_header_field)(git_http_parser *, const char *, size_t); + int (*on_header_value)(git_http_parser *, const char *, size_t); + int (*on_headers_complete)(git_http_parser *); + int (*on_body)(git_http_parser *, const char *, size_t); + int (*on_message_complete)(git_http_parser *); +} git_http_parser_settings; + +struct git_http_parser { + http_parser parser; + git_http_parser_settings settings; + void *data; +}; + +void git_http_parser_init( + git_http_parser *parser, + git_http_parser_t type, + git_http_parser_settings *settings); + +size_t git_http_parser_execute( + git_http_parser *parser, + const char *data, + size_t len); + +# define git_http_parser_status_code(parser) parser->parser.status_code +# define git_http_parser_keep_alive(parser) http_should_keep_alive(&parser->parser) +# define git_http_parser_pause(parser) (http_parser_pause(&parser->parser, 1), 0) +# define git_http_parser_resume(parser) http_parser_pause(&parser->parser, 0) +# define git_http_parser_remain_after_pause(parser) 1 +# define git_http_parser_errno(parser) parser->parser.http_errno +# define git_http_parser_errmsg(parser, errno) http_errno_description(errno) + +#elif defined(GIT_HTTPPARSER_LLHTTP) + +# include + +typedef enum { + GIT_HTTP_PARSER_OK = HPE_OK, + GIT_HTTP_PARSER_PAUSED = HPE_PAUSED, +} git_http_parser_error_t; + +typedef enum { + GIT_HTTP_PARSER_REQUEST = HTTP_REQUEST, + GIT_HTTP_PARSER_RESPONSE = HTTP_RESPONSE, +} git_http_parser_t; + +typedef llhttp_t git_http_parser; +typedef llhttp_settings_t git_http_parser_settings; + +# define git_http_parser_init(parser, direction, settings) llhttp_init(parser, (llhttp_type_t)direction, settings) + +size_t git_http_parser_execute( + git_http_parser *parser, + const char *data, + size_t len); + +# define git_http_parser_status_code(parser) parser->status_code +# define git_http_parser_keep_alive(parser) llhttp_should_keep_alive(parser) +# define git_http_parser_pause(parser) (llhttp_pause(parser), GIT_HTTP_PARSER_PAUSED) +# define git_http_parser_resume(parser) llhttp_resume(parser) +# define git_http_parser_remain_after_pause(parser) 0 +# define git_http_parser_errno(parser) parser->error +# define git_http_parser_errmsg(parser, errno) llhttp_get_error_reason(parser) + +#else +# error unknown http-parser +#endif + +#endif diff --git a/src/util/git2_features.h.in b/src/util/git2_features.h.in index a328f77cb00..52b73284687 100644 --- a/src/util/git2_features.h.in +++ b/src/util/git2_features.h.in @@ -46,6 +46,10 @@ #cmakedefine GIT_MBEDTLS 1 #cmakedefine GIT_SCHANNEL 1 +#cmakedefine GIT_HTTPPARSER_HTTPPARSER 1 +#cmakedefine GIT_HTTPPARSER_LLHTTP 1 +#cmakedefine GIT_HTTPPARSER_BUILTIN 1 + #cmakedefine GIT_SHA1_COLLISIONDETECT 1 #cmakedefine GIT_SHA1_WIN32 1 #cmakedefine GIT_SHA1_COMMON_CRYPTO 1 From d02b549dab742a1666934e013160fc35985dc4d2 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 22 Apr 2024 13:44:55 +0100 Subject: [PATCH 582/608] http: make llhttp the default --- cmake/SelectHTTPParser.cmake | 6 +++--- deps/llhttp/CMakeLists.txt | 6 +++--- src/libgit2/transports/httpparser.c | 4 ++-- src/libgit2/transports/httpparser.h | 4 ++-- 4 files changed, 10 insertions(+), 10 deletions(-) diff --git a/cmake/SelectHTTPParser.cmake b/cmake/SelectHTTPParser.cmake index 111170cb259..4fc1f6968e6 100644 --- a/cmake/SelectHTTPParser.cmake +++ b/cmake/SelectHTTPParser.cmake @@ -24,9 +24,9 @@ elseif(USE_HTTP_PARSER STREQUAL "llhttp") message(FATAL_ERROR "llhttp support was requested but not found") endif() else() - add_subdirectory("${PROJECT_SOURCE_DIR}/deps/http-parser" "${PROJECT_BINARY_DIR}/deps/http-parser") - list(APPEND LIBGIT2_DEPENDENCY_INCLUDES "${PROJECT_SOURCE_DIR}/deps/http-parser") - list(APPEND LIBGIT2_DEPENDENCY_OBJECTS "$") + add_subdirectory("${PROJECT_SOURCE_DIR}/deps/llhttp" "${PROJECT_BINARY_DIR}/deps/llhttp") + list(APPEND LIBGIT2_DEPENDENCY_INCLUDES "${PROJECT_SOURCE_DIR}/deps/llhttp") + list(APPEND LIBGIT2_DEPENDENCY_OBJECTS "$") set(GIT_HTTPPARSER_BUILTIN 1) add_feature_info(http-parser ON "using bundled parser") endif() diff --git a/deps/llhttp/CMakeLists.txt b/deps/llhttp/CMakeLists.txt index 89daa87c8de..6965335ab27 100644 --- a/deps/llhttp/CMakeLists.txt +++ b/deps/llhttp/CMakeLists.txt @@ -1,7 +1,7 @@ -file(GLOB SRC_HTTP "*.c" "*.h") -list(SORT SRC_HTTP) +file(GLOB SRC_LLHTTP "*.c" "*.h") +list(SORT SRC_LLHTTP) -add_library(llhttp OBJECT ${SRC_HTTP}) +add_library(llhttp OBJECT ${SRC_LLHTTP}) if(NOT MSVC) set_source_files_properties(api.c http.c llhttp.c PROPERTIES COMPILE_FLAGS "-Wno-unused-parameter -Wno-missing-declarations") diff --git a/src/libgit2/transports/httpparser.c b/src/libgit2/transports/httpparser.c index abd8f0244c7..50ba6d2e0cd 100644 --- a/src/libgit2/transports/httpparser.c +++ b/src/libgit2/transports/httpparser.c @@ -9,7 +9,7 @@ #include -#if defined(GIT_HTTPPARSER_HTTPPARSER) || defined(GIT_HTTPPARSER_BUILTIN) +#if defined(GIT_HTTPPARSER_HTTPPARSER) #include "http_parser.h" @@ -82,7 +82,7 @@ size_t git_http_parser_execute( return http_parser_execute(&parser->parser, &settings_proxy, data, len); } -#elif defined(GIT_HTTPPARSER_LLHTTP) +#elif defined(GIT_HTTPPARSER_LLHTTP) || defined(GIT_HTTPPARSER_BUILTIN) # include diff --git a/src/libgit2/transports/httpparser.h b/src/libgit2/transports/httpparser.h index 616be587edd..1fe0dcf6406 100644 --- a/src/libgit2/transports/httpparser.h +++ b/src/libgit2/transports/httpparser.h @@ -10,7 +10,7 @@ #include "git2_util.h" -#if defined(GIT_HTTPPARSER_HTTPPARSER) || defined(GIT_HTTPPARSER_BUILTIN) +#if defined(GIT_HTTPPARSER_HTTPPARSER) # include @@ -60,7 +60,7 @@ size_t git_http_parser_execute( # define git_http_parser_errno(parser) parser->parser.http_errno # define git_http_parser_errmsg(parser, errno) http_errno_description(errno) -#elif defined(GIT_HTTPPARSER_LLHTTP) +#elif defined(GIT_HTTPPARSER_LLHTTP) || defined(GIT_HTTPPARSER_BUILTIN) # include From 98c495539053a2c43e5ac00affa5561870a7745e Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 19 Apr 2024 21:07:25 +0100 Subject: [PATCH 583/608] http: remove legacy bundled http-parser Users can still use the legacy Node.js http-parser library, but now we bundle llhttp and prefer it. --- deps/http-parser/CMakeLists.txt | 6 - deps/http-parser/COPYING | 23 - deps/http-parser/http_parser.c | 2182 ------------------------------- deps/http-parser/http_parser.h | 305 ----- 4 files changed, 2516 deletions(-) delete mode 100644 deps/http-parser/CMakeLists.txt delete mode 100644 deps/http-parser/COPYING delete mode 100644 deps/http-parser/http_parser.c delete mode 100644 deps/http-parser/http_parser.h diff --git a/deps/http-parser/CMakeLists.txt b/deps/http-parser/CMakeLists.txt deleted file mode 100644 index b9da2496f75..00000000000 --- a/deps/http-parser/CMakeLists.txt +++ /dev/null @@ -1,6 +0,0 @@ -file(GLOB SRC_HTTP "*.c" "*.h") -list(SORT SRC_HTTP) - -add_library(http-parser OBJECT ${SRC_HTTP}) - -enable_warnings(implicit-fallthrough=1) diff --git a/deps/http-parser/COPYING b/deps/http-parser/COPYING deleted file mode 100644 index 58010b38894..00000000000 --- a/deps/http-parser/COPYING +++ /dev/null @@ -1,23 +0,0 @@ -http_parser.c is based on src/http/ngx_http_parse.c from NGINX copyright -Igor Sysoev. - -Additional changes are licensed under the same terms as NGINX and -copyright Joyent, Inc. and other Node contributors. All rights reserved. - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to -deal in the Software without restriction, including without limitation the -rights to use, copy, modify, merge, publish, distribute, sublicense, and/or -sell copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in -all copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING -FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS -IN THE SOFTWARE. diff --git a/deps/http-parser/http_parser.c b/deps/http-parser/http_parser.c deleted file mode 100644 index 1bcd330e5b5..00000000000 --- a/deps/http-parser/http_parser.c +++ /dev/null @@ -1,2182 +0,0 @@ -/* Based on src/http/ngx_http_parse.c from NGINX copyright Igor Sysoev - * - * Additional changes are licensed under the same terms as NGINX and - * copyright Joyent, Inc. and other Node contributors. All rights reserved. - * - * Permission is hereby granted, free of charge, to any person obtaining a copy - * of this software and associated documentation files (the "Software"), to - * deal in the Software without restriction, including without limitation the - * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or - * sell copies of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in - * all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING - * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS - * IN THE SOFTWARE. - */ -#include "http_parser.h" -#include -#include -#include -#include -#include -#include - -#ifndef ULLONG_MAX -# define ULLONG_MAX ((uint64_t) -1) /* 2^64-1 */ -#endif - -#ifndef MIN -# define MIN(a,b) ((a) < (b) ? (a) : (b)) -#endif - -#ifndef ARRAY_SIZE -# define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0])) -#endif - -#ifndef BIT_AT -# define BIT_AT(a, i) \ - (!!((unsigned int) (a)[(unsigned int) (i) >> 3] & \ - (1 << ((unsigned int) (i) & 7)))) -#endif - -#ifndef ELEM_AT -# define ELEM_AT(a, i, v) ((unsigned int) (i) < ARRAY_SIZE(a) ? (a)[(i)] : (v)) -#endif - -#define SET_ERRNO(e) \ -do { \ - parser->http_errno = (e); \ -} while(0) - - -/* Run the notify callback FOR, returning ER if it fails */ -#define CALLBACK_NOTIFY_(FOR, ER) \ -do { \ - assert(HTTP_PARSER_ERRNO(parser) == HPE_OK); \ - \ - if (settings->on_##FOR) { \ - if (0 != settings->on_##FOR(parser)) { \ - SET_ERRNO(HPE_CB_##FOR); \ - } \ - \ - /* We either errored above or got paused; get out */ \ - if (HTTP_PARSER_ERRNO(parser) != HPE_OK) { \ - return (ER); \ - } \ - } \ -} while (0) - -/* Run the notify callback FOR and consume the current byte */ -#define CALLBACK_NOTIFY(FOR) CALLBACK_NOTIFY_(FOR, p - data + 1) - -/* Run the notify callback FOR and don't consume the current byte */ -#define CALLBACK_NOTIFY_NOADVANCE(FOR) CALLBACK_NOTIFY_(FOR, p - data) - -/* Run data callback FOR with LEN bytes, returning ER if it fails */ -#define CALLBACK_DATA_(FOR, LEN, ER) \ -do { \ - assert(HTTP_PARSER_ERRNO(parser) == HPE_OK); \ - \ - if (FOR##_mark) { \ - if (settings->on_##FOR) { \ - if (0 != settings->on_##FOR(parser, FOR##_mark, (LEN))) { \ - SET_ERRNO(HPE_CB_##FOR); \ - } \ - \ - /* We either errored above or got paused; get out */ \ - if (HTTP_PARSER_ERRNO(parser) != HPE_OK) { \ - return (ER); \ - } \ - } \ - FOR##_mark = NULL; \ - } \ -} while (0) - -/* Run the data callback FOR and consume the current byte */ -#define CALLBACK_DATA(FOR) \ - CALLBACK_DATA_(FOR, p - FOR##_mark, p - data + 1) - -/* Run the data callback FOR and don't consume the current byte */ -#define CALLBACK_DATA_NOADVANCE(FOR) \ - CALLBACK_DATA_(FOR, p - FOR##_mark, p - data) - -/* Set the mark FOR; non-destructive if mark is already set */ -#define MARK(FOR) \ -do { \ - if (!FOR##_mark) { \ - FOR##_mark = p; \ - } \ -} while (0) - - -#define PROXY_CONNECTION "proxy-connection" -#define CONNECTION "connection" -#define CONTENT_LENGTH "content-length" -#define TRANSFER_ENCODING "transfer-encoding" -#define UPGRADE "upgrade" -#define CHUNKED "chunked" -#define KEEP_ALIVE "keep-alive" -#define CLOSE "close" - - -static const char *method_strings[] = - { -#define XX(num, name, string) #string, - HTTP_METHOD_MAP(XX) -#undef XX - }; - - -/* Tokens as defined by rfc 2616. Also lowercases them. - * token = 1* - * separators = "(" | ")" | "<" | ">" | "@" - * | "," | ";" | ":" | "\" | <"> - * | "/" | "[" | "]" | "?" | "=" - * | "{" | "}" | SP | HT - */ -static const char tokens[256] = { -/* 0 nul 1 soh 2 stx 3 etx 4 eot 5 enq 6 ack 7 bel */ - 0, 0, 0, 0, 0, 0, 0, 0, -/* 8 bs 9 ht 10 nl 11 vt 12 np 13 cr 14 so 15 si */ - 0, 0, 0, 0, 0, 0, 0, 0, -/* 16 dle 17 dc1 18 dc2 19 dc3 20 dc4 21 nak 22 syn 23 etb */ - 0, 0, 0, 0, 0, 0, 0, 0, -/* 24 can 25 em 26 sub 27 esc 28 fs 29 gs 30 rs 31 us */ - 0, 0, 0, 0, 0, 0, 0, 0, -/* 32 sp 33 ! 34 " 35 # 36 $ 37 % 38 & 39 ' */ - 0, '!', 0, '#', '$', '%', '&', '\'', -/* 40 ( 41 ) 42 * 43 + 44 , 45 - 46 . 47 / */ - 0, 0, '*', '+', 0, '-', '.', 0, -/* 48 0 49 1 50 2 51 3 52 4 53 5 54 6 55 7 */ - '0', '1', '2', '3', '4', '5', '6', '7', -/* 56 8 57 9 58 : 59 ; 60 < 61 = 62 > 63 ? */ - '8', '9', 0, 0, 0, 0, 0, 0, -/* 64 @ 65 A 66 B 67 C 68 D 69 E 70 F 71 G */ - 0, 'a', 'b', 'c', 'd', 'e', 'f', 'g', -/* 72 H 73 I 74 J 75 K 76 L 77 M 78 N 79 O */ - 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', -/* 80 P 81 Q 82 R 83 S 84 T 85 U 86 V 87 W */ - 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', -/* 88 X 89 Y 90 Z 91 [ 92 \ 93 ] 94 ^ 95 _ */ - 'x', 'y', 'z', 0, 0, 0, '^', '_', -/* 96 ` 97 a 98 b 99 c 100 d 101 e 102 f 103 g */ - '`', 'a', 'b', 'c', 'd', 'e', 'f', 'g', -/* 104 h 105 i 106 j 107 k 108 l 109 m 110 n 111 o */ - 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', -/* 112 p 113 q 114 r 115 s 116 t 117 u 118 v 119 w */ - 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', -/* 120 x 121 y 122 z 123 { 124 | 125 } 126 ~ 127 del */ - 'x', 'y', 'z', 0, '|', 0, '~', 0 }; - - -static const int8_t unhex[256] = - {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 - ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 - ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 - , 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,-1,-1,-1,-1,-1,-1 - ,-1,10,11,12,13,14,15,-1,-1,-1,-1,-1,-1,-1,-1,-1 - ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 - ,-1,10,11,12,13,14,15,-1,-1,-1,-1,-1,-1,-1,-1,-1 - ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 - }; - - -#if HTTP_PARSER_STRICT -# define T(v) 0 -#else -# define T(v) v -#endif - - -static const uint8_t normal_url_char[32] = { -/* 0 nul 1 soh 2 stx 3 etx 4 eot 5 enq 6 ack 7 bel */ - 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0, -/* 8 bs 9 ht 10 nl 11 vt 12 np 13 cr 14 so 15 si */ - 0 | T(2) | 0 | 0 | T(16) | 0 | 0 | 0, -/* 16 dle 17 dc1 18 dc2 19 dc3 20 dc4 21 nak 22 syn 23 etb */ - 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0, -/* 24 can 25 em 26 sub 27 esc 28 fs 29 gs 30 rs 31 us */ - 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0, -/* 32 sp 33 ! 34 " 35 # 36 $ 37 % 38 & 39 ' */ - 0 | 2 | 4 | 0 | 16 | 32 | 64 | 128, -/* 40 ( 41 ) 42 * 43 + 44 , 45 - 46 . 47 / */ - 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128, -/* 48 0 49 1 50 2 51 3 52 4 53 5 54 6 55 7 */ - 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128, -/* 56 8 57 9 58 : 59 ; 60 < 61 = 62 > 63 ? */ - 1 | 2 | 4 | 8 | 16 | 32 | 64 | 0, -/* 64 @ 65 A 66 B 67 C 68 D 69 E 70 F 71 G */ - 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128, -/* 72 H 73 I 74 J 75 K 76 L 77 M 78 N 79 O */ - 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128, -/* 80 P 81 Q 82 R 83 S 84 T 85 U 86 V 87 W */ - 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128, -/* 88 X 89 Y 90 Z 91 [ 92 \ 93 ] 94 ^ 95 _ */ - 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128, -/* 96 ` 97 a 98 b 99 c 100 d 101 e 102 f 103 g */ - 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128, -/* 104 h 105 i 106 j 107 k 108 l 109 m 110 n 111 o */ - 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128, -/* 112 p 113 q 114 r 115 s 116 t 117 u 118 v 119 w */ - 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128, -/* 120 x 121 y 122 z 123 { 124 | 125 } 126 ~ 127 del */ - 1 | 2 | 4 | 8 | 16 | 32 | 64 | 0, }; - -#undef T - -enum state - { s_dead = 1 /* important that this is > 0 */ - - , s_start_req_or_res - , s_res_or_resp_H - , s_start_res - , s_res_H - , s_res_HT - , s_res_HTT - , s_res_HTTP - , s_res_first_http_major - , s_res_http_major - , s_res_first_http_minor - , s_res_http_minor - , s_res_first_status_code - , s_res_status_code - , s_res_status - , s_res_line_almost_done - - , s_start_req - - , s_req_method - , s_req_spaces_before_url - , s_req_schema - , s_req_schema_slash - , s_req_schema_slash_slash - , s_req_server_start - , s_req_server - , s_req_server_with_at - , s_req_path - , s_req_query_string_start - , s_req_query_string - , s_req_fragment_start - , s_req_fragment - , s_req_http_start - , s_req_http_H - , s_req_http_HT - , s_req_http_HTT - , s_req_http_HTTP - , s_req_first_http_major - , s_req_http_major - , s_req_first_http_minor - , s_req_http_minor - , s_req_line_almost_done - - , s_header_field_start - , s_header_field - , s_header_value_start - , s_header_value - , s_header_value_lws - - , s_header_almost_done - - , s_chunk_size_start - , s_chunk_size - , s_chunk_parameters - , s_chunk_size_almost_done - - , s_headers_almost_done - , s_headers_done - - /* Important: 's_headers_done' must be the last 'header' state. All - * states beyond this must be 'body' states. It is used for overflow - * checking. See the PARSING_HEADER() macro. - */ - - , s_chunk_data - , s_chunk_data_almost_done - , s_chunk_data_done - - , s_body_identity - , s_body_identity_eof - - , s_message_done - }; - - -#define PARSING_HEADER(state) (state <= s_headers_done) - - -enum header_states - { h_general = 0 - , h_C - , h_CO - , h_CON - - , h_matching_connection - , h_matching_proxy_connection - , h_matching_content_length - , h_matching_transfer_encoding - , h_matching_upgrade - - , h_connection - , h_content_length - , h_transfer_encoding - , h_upgrade - - , h_matching_transfer_encoding_chunked - , h_matching_connection_keep_alive - , h_matching_connection_close - - , h_transfer_encoding_chunked - , h_connection_keep_alive - , h_connection_close - }; - -enum http_host_state - { - s_http_host_dead = 1 - , s_http_userinfo_start - , s_http_userinfo - , s_http_host_start - , s_http_host_v6_start - , s_http_host - , s_http_host_v6 - , s_http_host_v6_end - , s_http_host_port_start - , s_http_host_port -}; - -/* Macros for character classes; depends on strict-mode */ -#define CR '\r' -#define LF '\n' -#define LOWER(c) (unsigned char)(c | 0x20) -#define IS_ALPHA(c) (LOWER(c) >= 'a' && LOWER(c) <= 'z') -#define IS_NUM(c) ((c) >= '0' && (c) <= '9') -#define IS_ALPHANUM(c) (IS_ALPHA(c) || IS_NUM(c)) -#define IS_HEX(c) (IS_NUM(c) || (LOWER(c) >= 'a' && LOWER(c) <= 'f')) -#define IS_MARK(c) ((c) == '-' || (c) == '_' || (c) == '.' || \ - (c) == '!' || (c) == '~' || (c) == '*' || (c) == '\'' || (c) == '(' || \ - (c) == ')') -#define IS_USERINFO_CHAR(c) (IS_ALPHANUM(c) || IS_MARK(c) || (c) == '%' || \ - (c) == ';' || (c) == ':' || (c) == '&' || (c) == '=' || (c) == '+' || \ - (c) == '$' || (c) == ',') - -#if HTTP_PARSER_STRICT -#define TOKEN(c) (tokens[(unsigned char)c]) -#define IS_URL_CHAR(c) (BIT_AT(normal_url_char, (unsigned char)c)) -#define IS_HOST_CHAR(c) (IS_ALPHANUM(c) || (c) == '.' || (c) == '-') -#else -#define TOKEN(c) ((c == ' ') ? ' ' : tokens[(unsigned char)c]) -#define IS_URL_CHAR(c) \ - (BIT_AT(normal_url_char, (unsigned char)c) || ((c) & 0x80)) -#define IS_HOST_CHAR(c) \ - (IS_ALPHANUM(c) || (c) == '.' || (c) == '-' || (c) == '_') -#endif - - -#define start_state (parser->type == HTTP_REQUEST ? s_start_req : s_start_res) - - -#if HTTP_PARSER_STRICT -# define STRICT_CHECK(cond) \ -do { \ - if (cond) { \ - SET_ERRNO(HPE_STRICT); \ - goto error; \ - } \ -} while (0) -# define NEW_MESSAGE() (http_should_keep_alive(parser) ? start_state : s_dead) -#else -# define STRICT_CHECK(cond) -# define NEW_MESSAGE() start_state -#endif - - -/* Map errno values to strings for human-readable output */ -#define HTTP_STRERROR_GEN(n, s) { "HPE_" #n, s }, -static struct { - const char *name; - const char *description; -} http_strerror_tab[] = { - HTTP_ERRNO_MAP(HTTP_STRERROR_GEN) -}; -#undef HTTP_STRERROR_GEN - -int http_message_needs_eof(const http_parser *parser); - -/* Our URL parser. - * - * This is designed to be shared by http_parser_execute() for URL validation, - * hence it has a state transition + byte-for-byte interface. In addition, it - * is meant to be embedded in http_parser_parse_url(), which does the dirty - * work of turning state transitions URL components for its API. - * - * This function should only be invoked with non-space characters. It is - * assumed that the caller cares about (and can detect) the transition between - * URL and non-URL states by looking for these. - */ -static enum state -parse_url_char(enum state s, const char ch) -{ - if (ch == ' ' || ch == '\r' || ch == '\n') { - return s_dead; - } - -#if HTTP_PARSER_STRICT - if (ch == '\t' || ch == '\f') { - return s_dead; - } -#endif - - switch (s) { - case s_req_spaces_before_url: - /* Proxied requests are followed by scheme of an absolute URI (alpha). - * All methods except CONNECT are followed by '/' or '*'. - */ - - if (ch == '/' || ch == '*') { - return s_req_path; - } - - /* The schema must start with an alpha character. After that, it may - * consist of digits, '+', '-' or '.', followed by a ':'. - */ - if (IS_ALPHA(ch)) { - return s_req_schema; - } - - break; - - case s_req_schema: - if (IS_ALPHANUM(ch) || ch == '+' || ch == '-' || ch == '.') { - return s; - } - - if (ch == ':') { - return s_req_schema_slash; - } - - break; - - case s_req_schema_slash: - if (ch == '/') { - return s_req_schema_slash_slash; - } - - break; - - case s_req_schema_slash_slash: - if (ch == '/') { - return s_req_server_start; - } - - break; - - case s_req_server_with_at: - if (ch == '@') { - return s_dead; - } - - /* FALLTHROUGH */ - case s_req_server_start: - case s_req_server: - if (ch == '/') { - return s_req_path; - } - - if (ch == '?') { - return s_req_query_string_start; - } - - if (ch == '@') { - return s_req_server_with_at; - } - - if (IS_USERINFO_CHAR(ch) || ch == '[' || ch == ']') { - return s_req_server; - } - - break; - - case s_req_path: - if (IS_URL_CHAR(ch)) { - return s; - } - - switch (ch) { - case '?': - return s_req_query_string_start; - - case '#': - return s_req_fragment_start; - } - - break; - - case s_req_query_string_start: - case s_req_query_string: - if (IS_URL_CHAR(ch)) { - return s_req_query_string; - } - - switch (ch) { - case '?': - /* allow extra '?' in query string */ - return s_req_query_string; - - case '#': - return s_req_fragment_start; - } - - break; - - case s_req_fragment_start: - if (IS_URL_CHAR(ch)) { - return s_req_fragment; - } - - switch (ch) { - case '?': - return s_req_fragment; - - case '#': - return s; - } - - break; - - case s_req_fragment: - if (IS_URL_CHAR(ch)) { - return s; - } - - switch (ch) { - case '?': - case '#': - return s; - } - - break; - - default: - break; - } - - /* We should never fall out of the switch above unless there's an error */ - return s_dead; -} - -size_t http_parser_execute (http_parser *parser, - const http_parser_settings *settings, - const char *data, - size_t len) -{ - char c, ch; - int8_t unhex_val; - const char *p = data; - const char *header_field_mark = 0; - const char *header_value_mark = 0; - const char *url_mark = 0; - const char *body_mark = 0; - - /* We're in an error state. Don't bother doing anything. */ - if (HTTP_PARSER_ERRNO(parser) != HPE_OK) { - return 0; - } - - if (len == 0) { - switch (parser->state) { - case s_body_identity_eof: - /* Use of CALLBACK_NOTIFY() here would erroneously return 1 byte read if - * we got paused. - */ - CALLBACK_NOTIFY_NOADVANCE(message_complete); - return 0; - - case s_dead: - case s_start_req_or_res: - case s_start_res: - case s_start_req: - return 0; - - default: - SET_ERRNO(HPE_INVALID_EOF_STATE); - return 1; - } - } - - - if (parser->state == s_header_field) - header_field_mark = data; - if (parser->state == s_header_value) - header_value_mark = data; - switch (parser->state) { - case s_req_path: - case s_req_schema: - case s_req_schema_slash: - case s_req_schema_slash_slash: - case s_req_server_start: - case s_req_server: - case s_req_server_with_at: - case s_req_query_string_start: - case s_req_query_string: - case s_req_fragment_start: - case s_req_fragment: - url_mark = data; - break; - } - - for (p=data; p != data + len; p++) { - ch = *p; - - if (PARSING_HEADER(parser->state)) { - ++parser->nread; - /* Buffer overflow attack */ - if (parser->nread > HTTP_MAX_HEADER_SIZE) { - SET_ERRNO(HPE_HEADER_OVERFLOW); - goto error; - } - } - - reexecute_byte: - switch (parser->state) { - - case s_dead: - /* this state is used after a 'Connection: close' message - * the parser will error out if it reads another message - */ - if (ch == CR || ch == LF) - break; - - SET_ERRNO(HPE_CLOSED_CONNECTION); - goto error; - - case s_start_req_or_res: - { - if (ch == CR || ch == LF) - break; - parser->flags = 0; - parser->content_length = ULLONG_MAX; - - if (ch == 'H') { - parser->state = s_res_or_resp_H; - - CALLBACK_NOTIFY(message_begin); - } else { - parser->type = HTTP_REQUEST; - parser->state = s_start_req; - goto reexecute_byte; - } - - break; - } - - case s_res_or_resp_H: - if (ch == 'T') { - parser->type = HTTP_RESPONSE; - parser->state = s_res_HT; - } else { - if (ch != 'E') { - SET_ERRNO(HPE_INVALID_CONSTANT); - goto error; - } - - parser->type = HTTP_REQUEST; - parser->method = HTTP_HEAD; - parser->index = 2; - parser->state = s_req_method; - } - break; - - case s_start_res: - { - parser->flags = 0; - parser->content_length = ULLONG_MAX; - - switch (ch) { - case 'H': - parser->state = s_res_H; - break; - - case CR: - case LF: - break; - - default: - SET_ERRNO(HPE_INVALID_CONSTANT); - goto error; - } - - CALLBACK_NOTIFY(message_begin); - break; - } - - case s_res_H: - STRICT_CHECK(ch != 'T'); - parser->state = s_res_HT; - break; - - case s_res_HT: - STRICT_CHECK(ch != 'T'); - parser->state = s_res_HTT; - break; - - case s_res_HTT: - STRICT_CHECK(ch != 'P'); - parser->state = s_res_HTTP; - break; - - case s_res_HTTP: - STRICT_CHECK(ch != '/'); - parser->state = s_res_first_http_major; - break; - - case s_res_first_http_major: - if (ch < '0' || ch > '9') { - SET_ERRNO(HPE_INVALID_VERSION); - goto error; - } - - parser->http_major = ch - '0'; - parser->state = s_res_http_major; - break; - - /* major HTTP version or dot */ - case s_res_http_major: - { - if (ch == '.') { - parser->state = s_res_first_http_minor; - break; - } - - if (!IS_NUM(ch)) { - SET_ERRNO(HPE_INVALID_VERSION); - goto error; - } - - parser->http_major *= 10; - parser->http_major += ch - '0'; - - if (parser->http_major > 999) { - SET_ERRNO(HPE_INVALID_VERSION); - goto error; - } - - break; - } - - /* first digit of minor HTTP version */ - case s_res_first_http_minor: - if (!IS_NUM(ch)) { - SET_ERRNO(HPE_INVALID_VERSION); - goto error; - } - - parser->http_minor = ch - '0'; - parser->state = s_res_http_minor; - break; - - /* minor HTTP version or end of request line */ - case s_res_http_minor: - { - if (ch == ' ') { - parser->state = s_res_first_status_code; - break; - } - - if (!IS_NUM(ch)) { - SET_ERRNO(HPE_INVALID_VERSION); - goto error; - } - - parser->http_minor *= 10; - parser->http_minor += ch - '0'; - - if (parser->http_minor > 999) { - SET_ERRNO(HPE_INVALID_VERSION); - goto error; - } - - break; - } - - case s_res_first_status_code: - { - if (!IS_NUM(ch)) { - if (ch == ' ') { - break; - } - - SET_ERRNO(HPE_INVALID_STATUS); - goto error; - } - parser->status_code = ch - '0'; - parser->state = s_res_status_code; - break; - } - - case s_res_status_code: - { - if (!IS_NUM(ch)) { - switch (ch) { - case ' ': - parser->state = s_res_status; - break; - case CR: - parser->state = s_res_line_almost_done; - break; - case LF: - parser->state = s_header_field_start; - break; - default: - SET_ERRNO(HPE_INVALID_STATUS); - goto error; - } - break; - } - - parser->status_code *= 10; - parser->status_code += ch - '0'; - - if (parser->status_code > 999) { - SET_ERRNO(HPE_INVALID_STATUS); - goto error; - } - - break; - } - - case s_res_status: - /* the human readable status. e.g. "NOT FOUND" - * we are not humans so just ignore this */ - if (ch == CR) { - parser->state = s_res_line_almost_done; - break; - } - - if (ch == LF) { - parser->state = s_header_field_start; - break; - } - break; - - case s_res_line_almost_done: - STRICT_CHECK(ch != LF); - parser->state = s_header_field_start; - break; - - case s_start_req: - { - if (ch == CR || ch == LF) - break; - parser->flags = 0; - parser->content_length = ULLONG_MAX; - - if (!IS_ALPHA(ch)) { - SET_ERRNO(HPE_INVALID_METHOD); - goto error; - } - - parser->method = (enum http_method) 0; - parser->index = 1; - switch (ch) { - case 'C': parser->method = HTTP_CONNECT; /* or COPY, CHECKOUT */ break; - case 'D': parser->method = HTTP_DELETE; break; - case 'G': parser->method = HTTP_GET; break; - case 'H': parser->method = HTTP_HEAD; break; - case 'L': parser->method = HTTP_LOCK; break; - case 'M': parser->method = HTTP_MKCOL; /* or MOVE, MKACTIVITY, MERGE, M-SEARCH */ break; - case 'N': parser->method = HTTP_NOTIFY; break; - case 'O': parser->method = HTTP_OPTIONS; break; - case 'P': parser->method = HTTP_POST; - /* or PROPFIND|PROPPATCH|PUT|PATCH|PURGE */ - break; - case 'R': parser->method = HTTP_REPORT; break; - case 'S': parser->method = HTTP_SUBSCRIBE; /* or SEARCH */ break; - case 'T': parser->method = HTTP_TRACE; break; - case 'U': parser->method = HTTP_UNLOCK; /* or UNSUBSCRIBE */ break; - default: - SET_ERRNO(HPE_INVALID_METHOD); - goto error; - } - parser->state = s_req_method; - - CALLBACK_NOTIFY(message_begin); - - break; - } - - case s_req_method: - { - const char *matcher; - if (ch == '\0') { - SET_ERRNO(HPE_INVALID_METHOD); - goto error; - } - - matcher = method_strings[parser->method]; - if (ch == ' ' && matcher[parser->index] == '\0') { - parser->state = s_req_spaces_before_url; - } else if (ch == matcher[parser->index]) { - ; /* nada */ - } else if (parser->method == HTTP_CONNECT) { - if (parser->index == 1 && ch == 'H') { - parser->method = HTTP_CHECKOUT; - } else if (parser->index == 2 && ch == 'P') { - parser->method = HTTP_COPY; - } else { - goto error; - } - } else if (parser->method == HTTP_MKCOL) { - if (parser->index == 1 && ch == 'O') { - parser->method = HTTP_MOVE; - } else if (parser->index == 1 && ch == 'E') { - parser->method = HTTP_MERGE; - } else if (parser->index == 1 && ch == '-') { - parser->method = HTTP_MSEARCH; - } else if (parser->index == 2 && ch == 'A') { - parser->method = HTTP_MKACTIVITY; - } else { - goto error; - } - } else if (parser->method == HTTP_SUBSCRIBE) { - if (parser->index == 1 && ch == 'E') { - parser->method = HTTP_SEARCH; - } else { - goto error; - } - } else if (parser->index == 1 && parser->method == HTTP_POST) { - if (ch == 'R') { - parser->method = HTTP_PROPFIND; /* or HTTP_PROPPATCH */ - } else if (ch == 'U') { - parser->method = HTTP_PUT; /* or HTTP_PURGE */ - } else if (ch == 'A') { - parser->method = HTTP_PATCH; - } else { - goto error; - } - } else if (parser->index == 2) { - if (parser->method == HTTP_PUT) { - if (ch == 'R') parser->method = HTTP_PURGE; - } else if (parser->method == HTTP_UNLOCK) { - if (ch == 'S') parser->method = HTTP_UNSUBSCRIBE; - } - } else if (parser->index == 4 && parser->method == HTTP_PROPFIND && ch == 'P') { - parser->method = HTTP_PROPPATCH; - } else { - SET_ERRNO(HPE_INVALID_METHOD); - goto error; - } - - ++parser->index; - break; - } - - case s_req_spaces_before_url: - { - if (ch == ' ') break; - - MARK(url); - if (parser->method == HTTP_CONNECT) { - parser->state = s_req_server_start; - } - - parser->state = parse_url_char((enum state)parser->state, ch); - if (parser->state == s_dead) { - SET_ERRNO(HPE_INVALID_URL); - goto error; - } - - break; - } - - case s_req_schema: - case s_req_schema_slash: - case s_req_schema_slash_slash: - case s_req_server_start: - { - switch (ch) { - /* No whitespace allowed here */ - case ' ': - case CR: - case LF: - SET_ERRNO(HPE_INVALID_URL); - goto error; - default: - parser->state = parse_url_char((enum state)parser->state, ch); - if (parser->state == s_dead) { - SET_ERRNO(HPE_INVALID_URL); - goto error; - } - } - - break; - } - - case s_req_server: - case s_req_server_with_at: - case s_req_path: - case s_req_query_string_start: - case s_req_query_string: - case s_req_fragment_start: - case s_req_fragment: - { - switch (ch) { - case ' ': - parser->state = s_req_http_start; - CALLBACK_DATA(url); - break; - case CR: - case LF: - parser->http_major = 0; - parser->http_minor = 9; - parser->state = (ch == CR) ? - s_req_line_almost_done : - s_header_field_start; - CALLBACK_DATA(url); - break; - default: - parser->state = parse_url_char((enum state)parser->state, ch); - if (parser->state == s_dead) { - SET_ERRNO(HPE_INVALID_URL); - goto error; - } - } - break; - } - - case s_req_http_start: - switch (ch) { - case 'H': - parser->state = s_req_http_H; - break; - case ' ': - break; - default: - SET_ERRNO(HPE_INVALID_CONSTANT); - goto error; - } - break; - - case s_req_http_H: - STRICT_CHECK(ch != 'T'); - parser->state = s_req_http_HT; - break; - - case s_req_http_HT: - STRICT_CHECK(ch != 'T'); - parser->state = s_req_http_HTT; - break; - - case s_req_http_HTT: - STRICT_CHECK(ch != 'P'); - parser->state = s_req_http_HTTP; - break; - - case s_req_http_HTTP: - STRICT_CHECK(ch != '/'); - parser->state = s_req_first_http_major; - break; - - /* first digit of major HTTP version */ - case s_req_first_http_major: - if (ch < '1' || ch > '9') { - SET_ERRNO(HPE_INVALID_VERSION); - goto error; - } - - parser->http_major = ch - '0'; - parser->state = s_req_http_major; - break; - - /* major HTTP version or dot */ - case s_req_http_major: - { - if (ch == '.') { - parser->state = s_req_first_http_minor; - break; - } - - if (!IS_NUM(ch)) { - SET_ERRNO(HPE_INVALID_VERSION); - goto error; - } - - parser->http_major *= 10; - parser->http_major += ch - '0'; - - if (parser->http_major > 999) { - SET_ERRNO(HPE_INVALID_VERSION); - goto error; - } - - break; - } - - /* first digit of minor HTTP version */ - case s_req_first_http_minor: - if (!IS_NUM(ch)) { - SET_ERRNO(HPE_INVALID_VERSION); - goto error; - } - - parser->http_minor = ch - '0'; - parser->state = s_req_http_minor; - break; - - /* minor HTTP version or end of request line */ - case s_req_http_minor: - { - if (ch == CR) { - parser->state = s_req_line_almost_done; - break; - } - - if (ch == LF) { - parser->state = s_header_field_start; - break; - } - - /* XXX allow spaces after digit? */ - - if (!IS_NUM(ch)) { - SET_ERRNO(HPE_INVALID_VERSION); - goto error; - } - - parser->http_minor *= 10; - parser->http_minor += ch - '0'; - - if (parser->http_minor > 999) { - SET_ERRNO(HPE_INVALID_VERSION); - goto error; - } - - break; - } - - /* end of request line */ - case s_req_line_almost_done: - { - if (ch != LF) { - SET_ERRNO(HPE_LF_EXPECTED); - goto error; - } - - parser->state = s_header_field_start; - break; - } - - case s_header_field_start: - { - if (ch == CR) { - parser->state = s_headers_almost_done; - break; - } - - if (ch == LF) { - /* they might be just sending \n instead of \r\n so this would be - * the second \n to denote the end of headers*/ - parser->state = s_headers_almost_done; - goto reexecute_byte; - } - - c = TOKEN(ch); - - if (!c) { - SET_ERRNO(HPE_INVALID_HEADER_TOKEN); - goto error; - } - - MARK(header_field); - - parser->index = 0; - parser->state = s_header_field; - - switch (c) { - case 'c': - parser->header_state = h_C; - break; - - case 'p': - parser->header_state = h_matching_proxy_connection; - break; - - case 't': - parser->header_state = h_matching_transfer_encoding; - break; - - case 'u': - parser->header_state = h_matching_upgrade; - break; - - default: - parser->header_state = h_general; - break; - } - break; - } - - case s_header_field: - { - c = TOKEN(ch); - - if (c) { - switch (parser->header_state) { - case h_general: - break; - - case h_C: - parser->index++; - parser->header_state = (c == 'o' ? h_CO : h_general); - break; - - case h_CO: - parser->index++; - parser->header_state = (c == 'n' ? h_CON : h_general); - break; - - case h_CON: - parser->index++; - switch (c) { - case 'n': - parser->header_state = h_matching_connection; - break; - case 't': - parser->header_state = h_matching_content_length; - break; - default: - parser->header_state = h_general; - break; - } - break; - - /* connection */ - - case h_matching_connection: - parser->index++; - if (parser->index > sizeof(CONNECTION)-1 - || c != CONNECTION[parser->index]) { - parser->header_state = h_general; - } else if (parser->index == sizeof(CONNECTION)-2) { - parser->header_state = h_connection; - } - break; - - /* proxy-connection */ - - case h_matching_proxy_connection: - parser->index++; - if (parser->index > sizeof(PROXY_CONNECTION)-1 - || c != PROXY_CONNECTION[parser->index]) { - parser->header_state = h_general; - } else if (parser->index == sizeof(PROXY_CONNECTION)-2) { - parser->header_state = h_connection; - } - break; - - /* content-length */ - - case h_matching_content_length: - parser->index++; - if (parser->index > sizeof(CONTENT_LENGTH)-1 - || c != CONTENT_LENGTH[parser->index]) { - parser->header_state = h_general; - } else if (parser->index == sizeof(CONTENT_LENGTH)-2) { - parser->header_state = h_content_length; - } - break; - - /* transfer-encoding */ - - case h_matching_transfer_encoding: - parser->index++; - if (parser->index > sizeof(TRANSFER_ENCODING)-1 - || c != TRANSFER_ENCODING[parser->index]) { - parser->header_state = h_general; - } else if (parser->index == sizeof(TRANSFER_ENCODING)-2) { - parser->header_state = h_transfer_encoding; - } - break; - - /* upgrade */ - - case h_matching_upgrade: - parser->index++; - if (parser->index > sizeof(UPGRADE)-1 - || c != UPGRADE[parser->index]) { - parser->header_state = h_general; - } else if (parser->index == sizeof(UPGRADE)-2) { - parser->header_state = h_upgrade; - } - break; - - case h_connection: - case h_content_length: - case h_transfer_encoding: - case h_upgrade: - if (ch != ' ') parser->header_state = h_general; - break; - - default: - assert(0 && "Unknown header_state"); - break; - } - break; - } - - if (ch == ':') { - parser->state = s_header_value_start; - CALLBACK_DATA(header_field); - break; - } - - if (ch == CR) { - parser->state = s_header_almost_done; - CALLBACK_DATA(header_field); - break; - } - - if (ch == LF) { - parser->state = s_header_field_start; - CALLBACK_DATA(header_field); - break; - } - - SET_ERRNO(HPE_INVALID_HEADER_TOKEN); - goto error; - } - - case s_header_value_start: - { - if (ch == ' ' || ch == '\t') break; - - MARK(header_value); - - parser->state = s_header_value; - parser->index = 0; - - if (ch == CR) { - parser->header_state = h_general; - parser->state = s_header_almost_done; - CALLBACK_DATA(header_value); - break; - } - - if (ch == LF) { - parser->state = s_header_field_start; - CALLBACK_DATA(header_value); - break; - } - - c = LOWER(ch); - - switch (parser->header_state) { - case h_upgrade: - parser->flags |= F_UPGRADE; - parser->header_state = h_general; - break; - - case h_transfer_encoding: - /* looking for 'Transfer-Encoding: chunked' */ - if ('c' == c) { - parser->header_state = h_matching_transfer_encoding_chunked; - } else { - parser->header_state = h_general; - } - break; - - case h_content_length: - if (!IS_NUM(ch)) { - SET_ERRNO(HPE_INVALID_CONTENT_LENGTH); - goto error; - } - - parser->content_length = ch - '0'; - break; - - case h_connection: - /* looking for 'Connection: keep-alive' */ - if (c == 'k') { - parser->header_state = h_matching_connection_keep_alive; - /* looking for 'Connection: close' */ - } else if (c == 'c') { - parser->header_state = h_matching_connection_close; - } else { - parser->header_state = h_general; - } - break; - - default: - parser->header_state = h_general; - break; - } - break; - } - - case s_header_value: - { - - if (ch == CR) { - parser->state = s_header_almost_done; - CALLBACK_DATA(header_value); - break; - } - - if (ch == LF) { - parser->state = s_header_almost_done; - CALLBACK_DATA_NOADVANCE(header_value); - goto reexecute_byte; - } - - c = LOWER(ch); - - switch (parser->header_state) { - case h_general: - break; - - case h_connection: - case h_transfer_encoding: - assert(0 && "Shouldn't get here."); - break; - - case h_content_length: - { - uint64_t t; - - if (ch == ' ') break; - - if (!IS_NUM(ch)) { - SET_ERRNO(HPE_INVALID_CONTENT_LENGTH); - goto error; - } - - t = parser->content_length; - t *= 10; - t += ch - '0'; - - /* Overflow? */ - if (t < parser->content_length || t == ULLONG_MAX) { - SET_ERRNO(HPE_INVALID_CONTENT_LENGTH); - goto error; - } - - parser->content_length = t; - break; - } - - /* Transfer-Encoding: chunked */ - case h_matching_transfer_encoding_chunked: - parser->index++; - if (parser->index > sizeof(CHUNKED)-1 - || c != CHUNKED[parser->index]) { - parser->header_state = h_general; - } else if (parser->index == sizeof(CHUNKED)-2) { - parser->header_state = h_transfer_encoding_chunked; - } - break; - - /* looking for 'Connection: keep-alive' */ - case h_matching_connection_keep_alive: - parser->index++; - if (parser->index > sizeof(KEEP_ALIVE)-1 - || c != KEEP_ALIVE[parser->index]) { - parser->header_state = h_general; - } else if (parser->index == sizeof(KEEP_ALIVE)-2) { - parser->header_state = h_connection_keep_alive; - } - break; - - /* looking for 'Connection: close' */ - case h_matching_connection_close: - parser->index++; - if (parser->index > sizeof(CLOSE)-1 || c != CLOSE[parser->index]) { - parser->header_state = h_general; - } else if (parser->index == sizeof(CLOSE)-2) { - parser->header_state = h_connection_close; - } - break; - - case h_transfer_encoding_chunked: - case h_connection_keep_alive: - case h_connection_close: - if (ch != ' ') parser->header_state = h_general; - break; - - default: - parser->state = s_header_value; - parser->header_state = h_general; - break; - } - break; - } - - case s_header_almost_done: - { - STRICT_CHECK(ch != LF); - - parser->state = s_header_value_lws; - - switch (parser->header_state) { - case h_connection_keep_alive: - parser->flags |= F_CONNECTION_KEEP_ALIVE; - break; - case h_connection_close: - parser->flags |= F_CONNECTION_CLOSE; - break; - case h_transfer_encoding_chunked: - parser->flags |= F_CHUNKED; - break; - default: - break; - } - - break; - } - - case s_header_value_lws: - { - if (ch == ' ' || ch == '\t') - parser->state = s_header_value_start; - else - { - parser->state = s_header_field_start; - goto reexecute_byte; - } - break; - } - - case s_headers_almost_done: - { - STRICT_CHECK(ch != LF); - - if (parser->flags & F_TRAILING) { - /* End of a chunked request */ - parser->state = NEW_MESSAGE(); - CALLBACK_NOTIFY(message_complete); - break; - } - - parser->state = s_headers_done; - - /* Set this here so that on_headers_complete() callbacks can see it */ - parser->upgrade = - (parser->flags & F_UPGRADE || parser->method == HTTP_CONNECT); - - /* Here we call the headers_complete callback. This is somewhat - * different than other callbacks because if the user returns 1, we - * will interpret that as saying that this message has no body. This - * is needed for the annoying case of recieving a response to a HEAD - * request. - * - * We'd like to use CALLBACK_NOTIFY_NOADVANCE() here but we cannot, so - * we have to simulate it by handling a change in errno below. - */ - if (settings->on_headers_complete) { - switch (settings->on_headers_complete(parser)) { - case 0: - break; - - case 1: - parser->flags |= F_SKIPBODY; - break; - - default: - SET_ERRNO(HPE_CB_headers_complete); - return p - data; /* Error */ - } - } - - if (HTTP_PARSER_ERRNO(parser) != HPE_OK) { - return p - data; - } - - goto reexecute_byte; - } - - case s_headers_done: - { - STRICT_CHECK(ch != LF); - - parser->nread = 0; - - /* Exit, the rest of the connect is in a different protocol. */ - if (parser->upgrade) { - parser->state = NEW_MESSAGE(); - CALLBACK_NOTIFY(message_complete); - return (p - data) + 1; - } - - if (parser->flags & F_SKIPBODY) { - parser->state = NEW_MESSAGE(); - CALLBACK_NOTIFY(message_complete); - } else if (parser->flags & F_CHUNKED) { - /* chunked encoding - ignore Content-Length header */ - parser->state = s_chunk_size_start; - } else { - if (parser->content_length == 0) { - /* Content-Length header given but zero: Content-Length: 0\r\n */ - parser->state = NEW_MESSAGE(); - CALLBACK_NOTIFY(message_complete); - } else if (parser->content_length != ULLONG_MAX) { - /* Content-Length header given and non-zero */ - parser->state = s_body_identity; - } else { - if (parser->type == HTTP_REQUEST || - !http_message_needs_eof(parser)) { - /* Assume content-length 0 - read the next */ - parser->state = NEW_MESSAGE(); - CALLBACK_NOTIFY(message_complete); - } else { - /* Read body until EOF */ - parser->state = s_body_identity_eof; - } - } - } - - break; - } - - case s_body_identity: - { - uint64_t to_read = MIN(parser->content_length, - (uint64_t) ((data + len) - p)); - - assert(parser->content_length != 0 - && parser->content_length != ULLONG_MAX); - - /* The difference between advancing content_length and p is because - * the latter will automaticaly advance on the next loop iteration. - * Further, if content_length ends up at 0, we want to see the last - * byte again for our message complete callback. - */ - MARK(body); - parser->content_length -= to_read; - p += to_read - 1; - - if (parser->content_length == 0) { - parser->state = s_message_done; - - /* Mimic CALLBACK_DATA_NOADVANCE() but with one extra byte. - * - * The alternative to doing this is to wait for the next byte to - * trigger the data callback, just as in every other case. The - * problem with this is that this makes it difficult for the test - * harness to distinguish between complete-on-EOF and - * complete-on-length. It's not clear that this distinction is - * important for applications, but let's keep it for now. - */ - CALLBACK_DATA_(body, p - body_mark + 1, p - data); - goto reexecute_byte; - } - - break; - } - - /* read until EOF */ - case s_body_identity_eof: - MARK(body); - p = data + len - 1; - - break; - - case s_message_done: - parser->state = NEW_MESSAGE(); - CALLBACK_NOTIFY(message_complete); - break; - - case s_chunk_size_start: - { - assert(parser->nread == 1); - assert(parser->flags & F_CHUNKED); - - unhex_val = unhex[(unsigned char)ch]; - if (unhex_val == -1) { - SET_ERRNO(HPE_INVALID_CHUNK_SIZE); - goto error; - } - - parser->content_length = unhex_val; - parser->state = s_chunk_size; - break; - } - - case s_chunk_size: - { - uint64_t t; - - assert(parser->flags & F_CHUNKED); - - if (ch == CR) { - parser->state = s_chunk_size_almost_done; - break; - } - - unhex_val = unhex[(unsigned char)ch]; - - if (unhex_val == -1) { - if (ch == ';' || ch == ' ') { - parser->state = s_chunk_parameters; - break; - } - - SET_ERRNO(HPE_INVALID_CHUNK_SIZE); - goto error; - } - - t = parser->content_length; - t *= 16; - t += unhex_val; - - /* Overflow? */ - if (t < parser->content_length || t == ULLONG_MAX) { - SET_ERRNO(HPE_INVALID_CONTENT_LENGTH); - goto error; - } - - parser->content_length = t; - break; - } - - case s_chunk_parameters: - { - assert(parser->flags & F_CHUNKED); - /* just ignore this. TODO check for overflow */ - if (ch == CR) { - parser->state = s_chunk_size_almost_done; - break; - } - break; - } - - case s_chunk_size_almost_done: - { - assert(parser->flags & F_CHUNKED); - STRICT_CHECK(ch != LF); - - parser->nread = 0; - - if (parser->content_length == 0) { - parser->flags |= F_TRAILING; - parser->state = s_header_field_start; - } else { - parser->state = s_chunk_data; - } - break; - } - - case s_chunk_data: - { - uint64_t to_read = MIN(parser->content_length, - (uint64_t) ((data + len) - p)); - - assert(parser->flags & F_CHUNKED); - assert(parser->content_length != 0 - && parser->content_length != ULLONG_MAX); - - /* See the explanation in s_body_identity for why the content - * length and data pointers are managed this way. - */ - MARK(body); - parser->content_length -= to_read; - p += to_read - 1; - - if (parser->content_length == 0) { - parser->state = s_chunk_data_almost_done; - } - - break; - } - - case s_chunk_data_almost_done: - assert(parser->flags & F_CHUNKED); - assert(parser->content_length == 0); - STRICT_CHECK(ch != CR); - parser->state = s_chunk_data_done; - CALLBACK_DATA(body); - break; - - case s_chunk_data_done: - assert(parser->flags & F_CHUNKED); - STRICT_CHECK(ch != LF); - parser->nread = 0; - parser->state = s_chunk_size_start; - break; - - default: - assert(0 && "unhandled state"); - SET_ERRNO(HPE_INVALID_INTERNAL_STATE); - goto error; - } - } - - /* Run callbacks for any marks that we have leftover after we ran our of - * bytes. There should be at most one of these set, so it's OK to invoke - * them in series (unset marks will not result in callbacks). - * - * We use the NOADVANCE() variety of callbacks here because 'p' has already - * overflowed 'data' and this allows us to correct for the off-by-one that - * we'd otherwise have (since CALLBACK_DATA() is meant to be run with a 'p' - * value that's in-bounds). - */ - - assert(((header_field_mark ? 1 : 0) + - (header_value_mark ? 1 : 0) + - (url_mark ? 1 : 0) + - (body_mark ? 1 : 0)) <= 1); - - CALLBACK_DATA_NOADVANCE(header_field); - CALLBACK_DATA_NOADVANCE(header_value); - CALLBACK_DATA_NOADVANCE(url); - CALLBACK_DATA_NOADVANCE(body); - - return len; - -error: - if (HTTP_PARSER_ERRNO(parser) == HPE_OK) { - SET_ERRNO(HPE_UNKNOWN); - } - - return (p - data); -} - - -/* Does the parser need to see an EOF to find the end of the message? */ -int -http_message_needs_eof (const http_parser *parser) -{ - if (parser->type == HTTP_REQUEST) { - return 0; - } - - /* See RFC 2616 section 4.4 */ - if (parser->status_code / 100 == 1 || /* 1xx e.g. Continue */ - parser->status_code == 204 || /* No Content */ - parser->status_code == 304 || /* Not Modified */ - parser->flags & F_SKIPBODY) { /* response to a HEAD request */ - return 0; - } - - if ((parser->flags & F_CHUNKED) || parser->content_length != ULLONG_MAX) { - return 0; - } - - return 1; -} - - -int -http_should_keep_alive (const http_parser *parser) -{ - if (parser->http_major > 0 && parser->http_minor > 0) { - /* HTTP/1.1 */ - if (parser->flags & F_CONNECTION_CLOSE) { - return 0; - } - } else { - /* HTTP/1.0 or earlier */ - if (!(parser->flags & F_CONNECTION_KEEP_ALIVE)) { - return 0; - } - } - - return !http_message_needs_eof(parser); -} - - -const char * -http_method_str (enum http_method m) -{ - return ELEM_AT(method_strings, m, ""); -} - - -void -http_parser_init (http_parser *parser, enum http_parser_type t) -{ - void *data = parser->data; /* preserve application data */ - memset(parser, 0, sizeof(*parser)); - parser->data = data; - parser->type = t; - parser->state = (t == HTTP_REQUEST ? s_start_req : (t == HTTP_RESPONSE ? s_start_res : s_start_req_or_res)); - parser->http_errno = HPE_OK; -} - -const char * -http_errno_name(enum http_errno err) { - assert(err < (sizeof(http_strerror_tab)/sizeof(http_strerror_tab[0]))); - return http_strerror_tab[err].name; -} - -const char * -http_errno_description(enum http_errno err) { - assert(err < (sizeof(http_strerror_tab)/sizeof(http_strerror_tab[0]))); - return http_strerror_tab[err].description; -} - -static enum http_host_state -http_parse_host_char(enum http_host_state s, const char ch) { - switch(s) { - case s_http_userinfo: - case s_http_userinfo_start: - if (ch == '@') { - return s_http_host_start; - } - - if (IS_USERINFO_CHAR(ch)) { - return s_http_userinfo; - } - break; - - case s_http_host_start: - if (ch == '[') { - return s_http_host_v6_start; - } - - if (IS_HOST_CHAR(ch)) { - return s_http_host; - } - - break; - - case s_http_host: - if (IS_HOST_CHAR(ch)) { - return s_http_host; - } - - /* FALLTHROUGH */ - case s_http_host_v6_end: - if (ch == ':') { - return s_http_host_port_start; - } - - break; - - case s_http_host_v6: - if (ch == ']') { - return s_http_host_v6_end; - } - - /* FALLTHROUGH */ - case s_http_host_v6_start: - if (IS_HEX(ch) || ch == ':') { - return s_http_host_v6; - } - - break; - - case s_http_host_port: - case s_http_host_port_start: - if (IS_NUM(ch)) { - return s_http_host_port; - } - - break; - - default: - break; - } - return s_http_host_dead; -} - -static int -http_parse_host(const char * buf, struct http_parser_url *u, int found_at) { - enum http_host_state s; - - const char *p; - size_t buflen = u->field_data[UF_HOST].off + u->field_data[UF_HOST].len; - - if (buflen > UINT16_MAX) - return 1; - - u->field_data[UF_HOST].len = 0; - - s = found_at ? s_http_userinfo_start : s_http_host_start; - - for (p = buf + u->field_data[UF_HOST].off; p < buf + buflen; p++) { - enum http_host_state new_s = http_parse_host_char(s, *p); - - if (new_s == s_http_host_dead) { - return 1; - } - - switch(new_s) { - case s_http_host: - if (s != s_http_host) { - u->field_data[UF_HOST].off = (uint16_t)(p - buf); - } - u->field_data[UF_HOST].len++; - break; - - case s_http_host_v6: - if (s != s_http_host_v6) { - u->field_data[UF_HOST].off = (uint16_t)(p - buf); - } - u->field_data[UF_HOST].len++; - break; - - case s_http_host_port: - if (s != s_http_host_port) { - u->field_data[UF_PORT].off = (uint16_t)(p - buf); - u->field_data[UF_PORT].len = 0; - u->field_set |= (1 << UF_PORT); - } - u->field_data[UF_PORT].len++; - break; - - case s_http_userinfo: - if (s != s_http_userinfo) { - u->field_data[UF_USERINFO].off = (uint16_t)(p - buf); - u->field_data[UF_USERINFO].len = 0; - u->field_set |= (1 << UF_USERINFO); - } - u->field_data[UF_USERINFO].len++; - break; - - default: - break; - } - s = new_s; - } - - /* Make sure we don't end somewhere unexpected */ - switch (s) { - case s_http_host_start: - case s_http_host_v6_start: - case s_http_host_v6: - case s_http_userinfo: - case s_http_userinfo_start: - return 1; - default: - break; - } - - return 0; -} - -int -http_parser_parse_url(const char *buf, size_t buflen, int is_connect, - struct http_parser_url *u) -{ - enum state s; - const char *p; - enum http_parser_url_fields uf, old_uf; - int found_at = 0; - - if (buflen > UINT16_MAX) - return 1; - - u->port = u->field_set = 0; - s = is_connect ? s_req_server_start : s_req_spaces_before_url; - uf = old_uf = UF_MAX; - - for (p = buf; p < buf + buflen; p++) { - s = parse_url_char(s, *p); - - /* Figure out the next field that we're operating on */ - switch (s) { - case s_dead: - return 1; - - /* Skip delimeters */ - case s_req_schema_slash: - case s_req_schema_slash_slash: - case s_req_server_start: - case s_req_query_string_start: - case s_req_fragment_start: - continue; - - case s_req_schema: - uf = UF_SCHEMA; - break; - - case s_req_server_with_at: - found_at = 1; - - /* FALLTROUGH */ - case s_req_server: - uf = UF_HOST; - break; - - case s_req_path: - uf = UF_PATH; - break; - - case s_req_query_string: - uf = UF_QUERY; - break; - - case s_req_fragment: - uf = UF_FRAGMENT; - break; - - default: - assert(!"Unexpected state"); - return 1; - } - - /* Nothing's changed; soldier on */ - if (uf == old_uf) { - u->field_data[uf].len++; - continue; - } - - u->field_data[uf].off = (uint16_t)(p - buf); - u->field_data[uf].len = 1; - - u->field_set |= (1 << uf); - old_uf = uf; - } - - /* host must be present if there is a schema */ - /* parsing http:///toto will fail */ - if ((u->field_set & ((1 << UF_SCHEMA) | (1 << UF_HOST))) != 0) { - if (http_parse_host(buf, u, found_at) != 0) { - return 1; - } - } - - /* CONNECT requests can only contain "hostname:port" */ - if (is_connect && u->field_set != ((1 << UF_HOST)|(1 << UF_PORT))) { - return 1; - } - - if (u->field_set & (1 << UF_PORT)) { - /* Don't bother with endp; we've already validated the string */ - unsigned long v = strtoul(buf + u->field_data[UF_PORT].off, NULL, 10); - - /* Ports have a max value of 2^16 */ - if (v > 0xffff) { - return 1; - } - - u->port = (uint16_t) v; - } - - return 0; -} - -void -http_parser_pause(http_parser *parser, int paused) { - /* Users should only be pausing/unpausing a parser that is not in an error - * state. In non-debug builds, there's not much that we can do about this - * other than ignore it. - */ - if (HTTP_PARSER_ERRNO(parser) == HPE_OK || - HTTP_PARSER_ERRNO(parser) == HPE_PAUSED) { - SET_ERRNO((paused) ? HPE_PAUSED : HPE_OK); - } else { - assert(0 && "Attempting to pause parser in error state"); - } -} - -int -http_body_is_final(const struct http_parser *parser) { - return parser->state == s_message_done; -} diff --git a/deps/http-parser/http_parser.h b/deps/http-parser/http_parser.h deleted file mode 100644 index 67e1d95dd6e..00000000000 --- a/deps/http-parser/http_parser.h +++ /dev/null @@ -1,305 +0,0 @@ -/* Copyright Joyent, Inc. and other Node contributors. All rights reserved. - * - * Permission is hereby granted, free of charge, to any person obtaining a copy - * of this software and associated documentation files (the "Software"), to - * deal in the Software without restriction, including without limitation the - * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or - * sell copies of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in - * all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING - * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS - * IN THE SOFTWARE. - */ -#ifndef http_parser_h -#define http_parser_h -#ifdef __cplusplus -extern "C" { -#endif - -#define HTTP_PARSER_VERSION_MAJOR 2 -#define HTTP_PARSER_VERSION_MINOR 0 - -#include -#if defined(_WIN32) && !defined(__MINGW32__) && (!defined(_MSC_VER) || _MSC_VER<1600) -#include -typedef __int8 int8_t; -typedef unsigned __int8 uint8_t; -typedef __int16 int16_t; -typedef unsigned __int16 uint16_t; -typedef __int32 int32_t; -typedef unsigned __int32 uint32_t; -typedef __int64 int64_t; -typedef unsigned __int64 uint64_t; -typedef SIZE_T size_t; -typedef SSIZE_T ssize_t; -#elif defined(__sun) || defined(__sun__) -#include -#else -#include -#endif - -/* Compile with -DHTTP_PARSER_STRICT=0 to make less checks, but run - * faster - */ -#ifndef HTTP_PARSER_STRICT -# define HTTP_PARSER_STRICT 1 -#endif - -/* Maximium header size allowed */ -#define HTTP_MAX_HEADER_SIZE (80*1024) - - -typedef struct http_parser http_parser; -typedef struct http_parser_settings http_parser_settings; - - -/* Callbacks should return non-zero to indicate an error. The parser will - * then halt execution. - * - * The one exception is on_headers_complete. In a HTTP_RESPONSE parser - * returning '1' from on_headers_complete will tell the parser that it - * should not expect a body. This is used when receiving a response to a - * HEAD request which may contain 'Content-Length' or 'Transfer-Encoding: - * chunked' headers that indicate the presence of a body. - * - * http_data_cb does not return data chunks. It will be call arbitrarally - * many times for each string. E.G. you might get 10 callbacks for "on_url" - * each providing just a few characters more data. - */ -typedef int (*http_data_cb) (http_parser*, const char *at, size_t length); -typedef int (*http_cb) (http_parser*); - - -/* Request Methods */ -#define HTTP_METHOD_MAP(XX) \ - XX(0, DELETE, DELETE) \ - XX(1, GET, GET) \ - XX(2, HEAD, HEAD) \ - XX(3, POST, POST) \ - XX(4, PUT, PUT) \ - /* pathological */ \ - XX(5, CONNECT, CONNECT) \ - XX(6, OPTIONS, OPTIONS) \ - XX(7, TRACE, TRACE) \ - /* webdav */ \ - XX(8, COPY, COPY) \ - XX(9, LOCK, LOCK) \ - XX(10, MKCOL, MKCOL) \ - XX(11, MOVE, MOVE) \ - XX(12, PROPFIND, PROPFIND) \ - XX(13, PROPPATCH, PROPPATCH) \ - XX(14, SEARCH, SEARCH) \ - XX(15, UNLOCK, UNLOCK) \ - /* subversion */ \ - XX(16, REPORT, REPORT) \ - XX(17, MKACTIVITY, MKACTIVITY) \ - XX(18, CHECKOUT, CHECKOUT) \ - XX(19, MERGE, MERGE) \ - /* upnp */ \ - XX(20, MSEARCH, M-SEARCH) \ - XX(21, NOTIFY, NOTIFY) \ - XX(22, SUBSCRIBE, SUBSCRIBE) \ - XX(23, UNSUBSCRIBE, UNSUBSCRIBE) \ - /* RFC-5789 */ \ - XX(24, PATCH, PATCH) \ - XX(25, PURGE, PURGE) \ - -enum http_method - { -#define XX(num, name, string) HTTP_##name = num, - HTTP_METHOD_MAP(XX) -#undef XX - }; - - -enum http_parser_type { HTTP_REQUEST, HTTP_RESPONSE, HTTP_BOTH }; - - -/* Flag values for http_parser.flags field */ -enum flags - { F_CHUNKED = 1 << 0 - , F_CONNECTION_KEEP_ALIVE = 1 << 1 - , F_CONNECTION_CLOSE = 1 << 2 - , F_TRAILING = 1 << 3 - , F_UPGRADE = 1 << 4 - , F_SKIPBODY = 1 << 5 - }; - - -/* Map for errno-related constants - * - * The provided argument should be a macro that takes 2 arguments. - */ -#define HTTP_ERRNO_MAP(XX) \ - /* No error */ \ - XX(OK, "success") \ - \ - /* Callback-related errors */ \ - XX(CB_message_begin, "the on_message_begin callback failed") \ - XX(CB_url, "the on_url callback failed") \ - XX(CB_header_field, "the on_header_field callback failed") \ - XX(CB_header_value, "the on_header_value callback failed") \ - XX(CB_headers_complete, "the on_headers_complete callback failed") \ - XX(CB_body, "the on_body callback failed") \ - XX(CB_message_complete, "the on_message_complete callback failed") \ - \ - /* Parsing-related errors */ \ - XX(INVALID_EOF_STATE, "stream ended at an unexpected time") \ - XX(HEADER_OVERFLOW, \ - "too many header bytes seen; overflow detected") \ - XX(CLOSED_CONNECTION, \ - "data received after completed connection: close message") \ - XX(INVALID_VERSION, "invalid HTTP version") \ - XX(INVALID_STATUS, "invalid HTTP status code") \ - XX(INVALID_METHOD, "invalid HTTP method") \ - XX(INVALID_URL, "invalid URL") \ - XX(INVALID_HOST, "invalid host") \ - XX(INVALID_PORT, "invalid port") \ - XX(INVALID_PATH, "invalid path") \ - XX(INVALID_QUERY_STRING, "invalid query string") \ - XX(INVALID_FRAGMENT, "invalid fragment") \ - XX(LF_EXPECTED, "LF character expected") \ - XX(INVALID_HEADER_TOKEN, "invalid character in header") \ - XX(INVALID_CONTENT_LENGTH, \ - "invalid character in content-length header") \ - XX(INVALID_CHUNK_SIZE, \ - "invalid character in chunk size header") \ - XX(INVALID_CONSTANT, "invalid constant string") \ - XX(INVALID_INTERNAL_STATE, "encountered unexpected internal state")\ - XX(STRICT, "strict mode assertion failed") \ - XX(PAUSED, "parser is paused") \ - XX(UNKNOWN, "an unknown error occurred") - - -/* Define HPE_* values for each errno value above */ -#define HTTP_ERRNO_GEN(n, s) HPE_##n, -enum http_errno { - HTTP_ERRNO_MAP(HTTP_ERRNO_GEN) -}; -#undef HTTP_ERRNO_GEN - - -/* Get an http_errno value from an http_parser */ -#define HTTP_PARSER_ERRNO(p) ((enum http_errno) (p)->http_errno) - - -struct http_parser { - /** PRIVATE **/ - unsigned char type : 2; /* enum http_parser_type */ - unsigned char flags : 6; /* F_* values from 'flags' enum; semi-public */ - unsigned char state; /* enum state from http_parser.c */ - unsigned char header_state; /* enum header_state from http_parser.c */ - unsigned char index; /* index into current matcher */ - - uint32_t nread; /* # bytes read in various scenarios */ - uint64_t content_length; /* # bytes in body (0 if no Content-Length header) */ - - /** READ-ONLY **/ - unsigned short http_major; - unsigned short http_minor; - unsigned short status_code; /* responses only */ - unsigned char method; /* requests only */ - unsigned char http_errno : 7; - - /* 1 = Upgrade header was present and the parser has exited because of that. - * 0 = No upgrade header present. - * Should be checked when http_parser_execute() returns in addition to - * error checking. - */ - unsigned char upgrade : 1; - - /** PUBLIC **/ - void *data; /* A pointer to get hook to the "connection" or "socket" object */ -}; - - -struct http_parser_settings { - http_cb on_message_begin; - http_data_cb on_url; - http_data_cb on_header_field; - http_data_cb on_header_value; - http_cb on_headers_complete; - http_data_cb on_body; - http_cb on_message_complete; -}; - - -enum http_parser_url_fields - { UF_SCHEMA = 0 - , UF_HOST = 1 - , UF_PORT = 2 - , UF_PATH = 3 - , UF_QUERY = 4 - , UF_FRAGMENT = 5 - , UF_USERINFO = 6 - , UF_MAX = 7 - }; - - -/* Result structure for http_parser_parse_url(). - * - * Callers should index into field_data[] with UF_* values iff field_set - * has the relevant (1 << UF_*) bit set. As a courtesy to clients (and - * because we probably have padding left over), we convert any port to - * a uint16_t. - */ -struct http_parser_url { - uint16_t field_set; /* Bitmask of (1 << UF_*) values */ - uint16_t port; /* Converted UF_PORT string */ - - struct { - uint16_t off; /* Offset into buffer in which field starts */ - uint16_t len; /* Length of run in buffer */ - } field_data[UF_MAX]; -}; - - -void http_parser_init(http_parser *parser, enum http_parser_type type); - - -size_t http_parser_execute(http_parser *parser, - const http_parser_settings *settings, - const char *data, - size_t len); - - -/* If http_should_keep_alive() in the on_headers_complete or - * on_message_complete callback returns 0, then this should be - * the last message on the connection. - * If you are the server, respond with the "Connection: close" header. - * If you are the client, close the connection. - */ -int http_should_keep_alive(const http_parser *parser); - -/* Returns a string version of the HTTP method. */ -const char *http_method_str(enum http_method m); - -/* Return a string name of the given error */ -const char *http_errno_name(enum http_errno err); - -/* Return a string description of the given error */ -const char *http_errno_description(enum http_errno err); - -/* Parse a URL; return nonzero on failure */ -int http_parser_parse_url(const char *buf, size_t buflen, - int is_connect, - struct http_parser_url *u); - -/* Pause or un-pause the parser; a nonzero value pauses */ -void http_parser_pause(http_parser *parser, int paused); - -/* Checks if this is the final chunk of the body. */ -int http_body_is_final(const http_parser *parser); - -#ifdef __cplusplus -} -#endif -#endif From 64808a9a8e9ba6796fd3bdd78db9a148b8586348 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 22 Apr 2024 22:23:32 +0100 Subject: [PATCH 584/608] ci: fixes for fedora Use fedora's valgrind instead of trying to build our own; omit false positive leaks in getaddrinfo; --- ci/docker/fedora | 19 +++++-------------- script/valgrind.supp | 7 +++++++ 2 files changed, 12 insertions(+), 14 deletions(-) diff --git a/ci/docker/fedora b/ci/docker/fedora index d6339bc8512..1db3ceb78a0 100644 --- a/ci/docker/fedora +++ b/ci/docker/fedora @@ -18,10 +18,12 @@ RUN yum install -y \ java-1.8.0-openjdk-headless \ sudo \ python3 \ + valgrind \ krb5-workstation \ krb5-libs \ - krb5-devel \ - pcre2-devel \ + krb5-devel \ + pcre2-devel \ + zlib-devel \ ninja-build \ llhttp-devel @@ -35,18 +37,7 @@ RUN cd /tmp && \ cd .. && \ rm -rf libssh2-1.11.0 -FROM libssh2 AS valgrind -RUN cd /tmp && \ - curl --insecure --location --silent --show-error https://sourceware.org/pub/valgrind/valgrind-3.15.0.tar.bz2 | \ - tar -xj && \ - cd valgrind-3.15.0 && \ - ./configure && \ - make MAKEFLAGS="-j -l$(grep -c ^processor /proc/cpuinfo)" && \ - make install && \ - cd .. && \ - rm -rf valgrind-3.15.0 - -FROM valgrind AS adduser +FROM libssh2 AS adduser ARG UID="" ARG GID="" RUN if [ "${UID}" != "" ]; then USER_ARG="--uid ${UID}"; fi && \ diff --git a/script/valgrind.supp b/script/valgrind.supp index 8c4549f62be..b641386636f 100644 --- a/script/valgrind.supp +++ b/script/valgrind.supp @@ -80,6 +80,13 @@ fun:__check_pf } +{ + ignore-glibc-getaddrinfo-fn + Memcheck:Leak + ... + fun:getaddrinfo +} + { ignore-curl-global-init Memcheck:Leak From 15a8d8763e3088e2fa5c7bd7ba75c02454a16af8 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 22 Apr 2024 23:44:32 +0100 Subject: [PATCH 585/608] ci: make fedora a nightly build --- .github/workflows/main.yml | 9 --------- .github/workflows/nightly.yml | 10 +++++++++- 2 files changed, 9 insertions(+), 10 deletions(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index aca6b0ee359..accb042e463 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -62,15 +62,6 @@ jobs: CC: clang CMAKE_GENERATOR: Ninja CMAKE_OPTIONS: -DUSE_HTTPS=mbedTLS -DUSE_SHA1=HTTPS -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=libssh2 - - name: "Linux (Fedora, GCC, llhttp, SHA-256, OpenSSL, libssh2" - id: fedora-gcc-openssl-llhttp - os: ubuntu-latest - container: - name: fedora - env: - CC: gcc - CMAKE_GENERATOR: Ninja - CMAKE_OPTIONS: -DUSE_HTTPS=OpenSSL -DREGEX_BACKEND=pcre2 -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_NTLMCLIENT=OFF -DUSE_SSH=libssh2 -DDEBUG_STRICT_ALLOC=ON -DDEBUG_STRICT_OPEN=ON -DEXPERIMENTAL_SHA256=ON - name: "macOS" id: macos os: macos-12 diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml index 43796859762..57bdd1f778e 100644 --- a/.github/workflows/nightly.yml +++ b/.github/workflows/nightly.yml @@ -208,7 +208,15 @@ jobs: SKIP_NEGOTIATE_TESTS: true SKIP_SSH_TESTS: true ARCH: x86 - + - name: "Linux (Fedora, llhttp)" + id: fedora + os: ubuntu-latest + container: + name: fedora + env: + CC: gcc + CMAKE_GENERATOR: Ninja + CMAKE_OPTIONS: -DUSE_HTTPS=OpenSSL -DREGEX_BACKEND=pcre2 -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=libssh2 -DUSE_HTTP_PARSER=llhttp - name: "Linux (Bionic, GCC, dynamically-loaded OpenSSL)" container: name: bionic From ffd881eb4a6f378e9bbefb40e72ff0098579be12 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 29 Apr 2024 09:44:30 +0100 Subject: [PATCH 586/608] transport: provide a useful error message during cancellation Since 3618a2a, `git_error_last` does not return NULL when there was no error. Adapt to this when testing for a user cancelling a callback but not setting an error message, testing for `klass` of `GIT_ERROR_NONE`. --- src/libgit2/transports/local.c | 2 +- src/libgit2/transports/ssh_libssh2.c | 4 ++-- src/libgit2/transports/winhttp.c | 6 +++--- 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/src/libgit2/transports/local.c b/src/libgit2/transports/local.c index fe59bcab0c1..68ff1c1c12c 100644 --- a/src/libgit2/transports/local.c +++ b/src/libgit2/transports/local.c @@ -458,7 +458,7 @@ static int local_push( default: last = git_error_last(); - if (last && last->message) + if (last->klass != GIT_ERROR_NONE) status->msg = git__strdup(last->message); else status->msg = git__strdup("Unspecified error encountered"); diff --git a/src/libgit2/transports/ssh_libssh2.c b/src/libgit2/transports/ssh_libssh2.c index d1b5d40d51f..1993ffe5c3a 100644 --- a/src/libgit2/transports/ssh_libssh2.c +++ b/src/libgit2/transports/ssh_libssh2.c @@ -375,8 +375,8 @@ static int _git_ssh_authenticate_session( return GIT_EAUTH; if (rc != LIBSSH2_ERROR_NONE) { - if (!git_error_last()) - ssh_error(session, "Failed to authenticate SSH session"); + if (git_error_last()->klass == GIT_ERROR_NONE) + ssh_error(session, "failed to authenticate SSH session"); return -1; } diff --git a/src/libgit2/transports/winhttp.c b/src/libgit2/transports/winhttp.c index 7eca4b7443b..b83ef990de6 100644 --- a/src/libgit2/transports/winhttp.c +++ b/src/libgit2/transports/winhttp.c @@ -293,7 +293,7 @@ static int certificate_check(winhttp_stream *s, int valid) /* If there is no override, we should fail if WinHTTP doesn't think it's fine */ if (t->owner->connect_opts.callbacks.certificate_check == NULL && !valid) { - if (!git_error_last()) + if (git_error_last()->klass == GIT_ERROR_NONE) git_error_set(GIT_ERROR_HTTP, "unknown certificate check failure"); return GIT_ECERTIFICATE; @@ -317,7 +317,7 @@ static int certificate_check(winhttp_stream *s, int valid) if (error == GIT_PASSTHROUGH) error = valid ? 0 : GIT_ECERTIFICATE; - if (error < 0 && !git_error_last()) + if (error < 0 && git_error_last()->klass == GIT_ERROR_NONE) git_error_set(GIT_ERROR_HTTP, "user cancelled certificate check"); return error; @@ -961,7 +961,7 @@ static int send_request(winhttp_stream *s, size_t len, bool chunked) (!request_failed && s->status_sending_request_reached)) { git_error_clear(); if ((error = certificate_check(s, cert_valid)) < 0) { - if (!git_error_last()) + if (git_error_last()->klass == GIT_ERROR_NONE) git_error_set(GIT_ERROR_OS, "user cancelled certificate check"); return error; From 2fd37e1bfedf8363d37f12eda726cdc34961e49a Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 18 Mar 2024 21:01:29 +0000 Subject: [PATCH 587/608] transport: support sha256 oids --- src/libgit2/transports/smart_protocol.c | 29 +++++++++++++++++++------ 1 file changed, 22 insertions(+), 7 deletions(-) diff --git a/src/libgit2/transports/smart_protocol.c b/src/libgit2/transports/smart_protocol.c index 13f97b7274f..df1c190c30e 100644 --- a/src/libgit2/transports/smart_protocol.c +++ b/src/libgit2/transports/smart_protocol.c @@ -786,29 +786,43 @@ static int gen_pktline(git_str *buf, git_push *push) push_spec *spec; char *option; size_t i, len; - char old_id[GIT_OID_SHA1_HEXSIZE+1], new_id[GIT_OID_SHA1_HEXSIZE+1]; - - old_id[GIT_OID_SHA1_HEXSIZE] = '\0'; new_id[GIT_OID_SHA1_HEXSIZE] = '\0'; + char old_id[GIT_OID_MAX_HEXSIZE + 1], new_id[GIT_OID_MAX_HEXSIZE + 1]; + size_t old_id_len, new_id_len; git_vector_foreach(&push->specs, i, spec) { - len = 2*GIT_OID_SHA1_HEXSIZE + 7 + strlen(spec->refspec.dst); + len = strlen(spec->refspec.dst) + 7; if (i == 0) { - ++len; /* '\0' */ + /* Need a leading \0 */ + ++len; + if (push->report_status) len += strlen(GIT_CAP_REPORT_STATUS) + 1; + if (git_vector_length(&push->remote_push_options) > 0) len += strlen(GIT_CAP_PUSH_OPTIONS) + 1; + len += strlen(GIT_CAP_SIDE_BAND_64K) + 1; } + old_id_len = git_oid_hexsize(git_oid_type(&spec->roid)); + new_id_len = git_oid_hexsize(git_oid_type(&spec->loid)); + + len += (old_id_len + new_id_len); + git_oid_fmt(old_id, &spec->roid); + old_id[old_id_len] = '\0'; + git_oid_fmt(new_id, &spec->loid); + new_id[new_id_len] = '\0'; - git_str_printf(buf, "%04"PRIxZ"%s %s %s", len, old_id, new_id, spec->refspec.dst); + git_str_printf(buf, "%04"PRIxZ"%.*s %.*s %s", len, + (int)old_id_len, old_id, (int)new_id_len, new_id, + spec->refspec.dst); if (i == 0) { git_str_putc(buf, '\0'); + /* Core git always starts their capabilities string with a space */ if (push->report_status) { git_str_putc(buf, ' '); @@ -831,6 +845,7 @@ static int gen_pktline(git_str *buf, git_push *push) git_str_printf(buf, "%04"PRIxZ"%s", strlen(option) + 4 , option); } } + git_str_puts(buf, "0000"); return git_str_oom(buf) ? -1 : 0; } @@ -1176,7 +1191,7 @@ int git_smart__push(git_transport *transport, git_push *push) #ifdef PUSH_DEBUG { git_remote_head *head; - char hex[GIT_OID_SHA1_HEXSIZE+1]; hex[GIT_OID_SHA1_HEXSIZE] = '\0'; + char hex[GIT_OID_MAX_HEXSIZE+1], hex[GIT_OID_MAX_HEXSIZE] = '\0'; git_vector_foreach(&push->remote->refs, i, head) { git_oid_fmt(hex, &head->oid); From 2d649ccd234914a7173142caed3434d6a73ddfe8 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 6 May 2024 15:46:21 +0100 Subject: [PATCH 588/608] remote: drop bitfields in git_remote_fetch_options In attempting to make a clever change that added fetch options as flags, while keeping ABI and API compatibility, we screwed up. Bitfields in structs are implementation-specific and are not necessarily ABI compatible across compilers. Make `update_fetchhead` a flags value which is weirdly named, but that's a future problem. This removes the `report_unchanged` option from API. --- include/git2/remote.h | 6 ++---- src/libgit2/remote.c | 7 +------ 2 files changed, 3 insertions(+), 10 deletions(-) diff --git a/include/git2/remote.h b/include/git2/remote.h index 7067c88b0b1..5505f6c358d 100644 --- a/include/git2/remote.h +++ b/include/git2/remote.h @@ -746,8 +746,7 @@ typedef struct { /** * How to handle reference updates; see `git_remote_update_flags`. */ - unsigned int update_fetchhead : 1, - report_unchanged : 1; + unsigned int update_fetchhead; /** * Determines how to behave regarding tags on the remote, such @@ -790,8 +789,7 @@ typedef struct { GIT_FETCH_OPTIONS_VERSION, \ GIT_REMOTE_CALLBACKS_INIT, \ GIT_FETCH_PRUNE_UNSPECIFIED, \ - 1, \ - 0, \ + GIT_REMOTE_UPDATE_FETCHHEAD, \ GIT_REMOTE_DOWNLOAD_TAGS_UNSPECIFIED, \ GIT_PROXY_OPTIONS_INIT } diff --git a/src/libgit2/remote.c b/src/libgit2/remote.c index 8b07c83184a..8b486ea3550 100644 --- a/src/libgit2/remote.c +++ b/src/libgit2/remote.c @@ -1376,12 +1376,7 @@ int git_remote_fetch( return error; if (opts) { - if (opts->update_fetchhead) - update_flags |= GIT_REMOTE_UPDATE_FETCHHEAD; - - if (opts->report_unchanged) - update_flags |= GIT_REMOTE_UPDATE_REPORT_UNCHANGED; - + update_flags = opts->update_fetchhead; tagopt = opts->download_tags; } From 322ea80231832fcb441ecfdcbbbf706e4acc3fc5 Mon Sep 17 00:00:00 2001 From: qaqland Date: Wed, 8 May 2024 11:08:26 +0800 Subject: [PATCH 589/608] examples: fix memory leak in for-each-ref.c --- examples/for-each-ref.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/examples/for-each-ref.c b/examples/for-each-ref.c index a0706741a3f..f745bc38cb9 100644 --- a/examples/for-each-ref.c +++ b/examples/for-each-ref.c @@ -25,6 +25,8 @@ static int show_ref(git_reference *ref, void *data) git_object_type2string(git_object_type(obj)), git_reference_name(ref)); + git_object_free(obj); + git_reference_free(ref); if (resolved) git_reference_free(resolved); return 0; From 60f219e80be22a733fb4321e5aed189fde984dbe Mon Sep 17 00:00:00 2001 From: Sven Strickroth Date: Wed, 8 May 2024 17:05:19 +0200 Subject: [PATCH 590/608] Revparse: Correctly accept ref with '@' at the end Signed-off-by: Sven Strickroth --- src/libgit2/revparse.c | 8 +------- tests/libgit2/refs/revparse.c | 31 +++++++++++++++++++------------ 2 files changed, 20 insertions(+), 19 deletions(-) diff --git a/src/libgit2/revparse.c b/src/libgit2/revparse.c index 08237628793..9083e7a3cdc 100644 --- a/src/libgit2/revparse.c +++ b/src/libgit2/revparse.c @@ -816,13 +816,7 @@ static int revparse( if (temp_object != NULL) base_rev = temp_object; break; - } else if (spec[pos+1] == '\0') { - if (pos) { - git_error_set(GIT_ERROR_REFERENCE, "invalid revspec"); - error = GIT_EINVALIDSPEC; - goto cleanup; - } - + } else if (spec[pos + 1] == '\0' && !pos) { spec = "HEAD"; identifier_len = 4; parsed = true; diff --git a/tests/libgit2/refs/revparse.c b/tests/libgit2/refs/revparse.c index 3fe07811796..9bc3bd10e4c 100644 --- a/tests/libgit2/refs/revparse.c +++ b/tests/libgit2/refs/revparse.c @@ -747,6 +747,25 @@ void test_refs_revparse__try_to_retrieve_branch_before_abbrev_sha(void) cl_git_sandbox_cleanup(); } +void test_refs_revparse__at_at_end_of_refname(void) +{ + git_repository *repo; + git_reference *branch; + git_object *target; + + repo = cl_git_sandbox_init("testrepo.git"); + + cl_git_pass(git_revparse_single(&target, repo, "HEAD")); + cl_git_pass(git_branch_create(&branch, repo, "master@", (git_commit *)target, 0)); + git_object_free(target); + + test_id_inrepo("master@", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", NULL, GIT_REVSPEC_SINGLE, repo); + + cl_git_fail_with(GIT_ENOTFOUND, git_revparse_single(&target, repo, "foo@")); + + git_reference_free(branch); + cl_git_sandbox_cleanup(); +} void test_refs_revparse__range(void) { @@ -889,15 +908,3 @@ void test_refs_revparse__parses_at_head(void) test_id("@{0}", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", NULL, GIT_REVSPEC_SINGLE); test_id("@", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", NULL, GIT_REVSPEC_SINGLE); } - -void test_refs_revparse__rejects_bogus_at(void) -{ - git_repository *repo; - git_object *target; - - repo = cl_git_sandbox_init("testrepo.git"); - - cl_git_fail_with(GIT_EINVALIDSPEC, git_revparse_single(&target, repo, "foo@")); - - cl_git_sandbox_cleanup(); -} From b1d6fd0858aad5db7bb33d56fb8f76fd3fb6722a Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 13 May 2024 10:21:24 +0100 Subject: [PATCH 591/608] cli: include alloca on illumos / solaris / sunos --- src/cli/opt.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/cli/opt.c b/src/cli/opt.c index 2b08dc219a3..9242e2203b4 100644 --- a/src/cli/opt.c +++ b/src/cli/opt.c @@ -19,6 +19,10 @@ #include #include +#if defined(__sun) || defined(__illumos__) +# include +#endif + #include "common.h" #include "opt.h" From 99ba44608f216d6c59eb9131907114883c7059a9 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 13 May 2024 10:21:58 +0100 Subject: [PATCH 592/608] tree: avoid mixed signedness comparison Promote mode to `uint32_t` before comparing it to an `uint16_t` to avoid mixed signed comparison warnings. --- src/libgit2/tree.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/libgit2/tree.c b/src/libgit2/tree.c index 236a87f7e3e..18278d34e77 100644 --- a/src/libgit2/tree.c +++ b/src/libgit2/tree.c @@ -381,7 +381,7 @@ static int parse_mode(uint16_t *mode_out, const char *buffer, size_t buffer_len, if ((error = git__strntol32(&mode, buffer, buffer_len, buffer_out, 8)) < 0) return error; - if (mode < 0 || mode > UINT16_MAX) + if (mode < 0 || (uint32_t)mode > UINT16_MAX) return -1; *mode_out = mode; From 2fb07fd0e18d8e589e8b9ca9c7f8140b173b5d27 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 13 May 2024 10:24:21 +0100 Subject: [PATCH 593/608] rand: avoid uninitialized loadavg warnings --- src/util/rand.c | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/src/util/rand.c b/src/util/rand.c index a02853519b2..2b137a57b56 100644 --- a/src/util/rand.c +++ b/src/util/rand.c @@ -76,10 +76,10 @@ GIT_INLINE(int) getseed(uint64_t *seed) GIT_INLINE(int) getseed(uint64_t *seed) { struct timeval tv; - double loadavg[3]; int fd; # if defined(GIT_RAND_GETLOADAVG) + double loadavg[3]; bits convert; # endif @@ -125,8 +125,6 @@ GIT_INLINE(int) getseed(uint64_t *seed) convert.f = loadavg[0]; *seed ^= (convert.d >> 36); convert.f = loadavg[1]; *seed ^= (convert.d); convert.f = loadavg[2]; *seed ^= (convert.d >> 16); -# else - GIT_UNUSED(loadavg[0]); # endif *seed ^= git_time_monotonic(); From bb3c31f3274f1ec046c6a798c3c10d1043dfe517 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 18 Apr 2024 20:47:11 +0100 Subject: [PATCH 594/608] xdiff: use proper free function --- deps/xdiff/xmerge.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/deps/xdiff/xmerge.c b/deps/xdiff/xmerge.c index af40c88a5b3..6ebf73a933a 100644 --- a/deps/xdiff/xmerge.c +++ b/deps/xdiff/xmerge.c @@ -88,7 +88,7 @@ static int xdl_cleanup_merge(xdmerge_t *c) if (c->mode == 0) count++; next_c = c->next; - free(c); + xdl_free(c); } return count; } @@ -456,7 +456,7 @@ static void xdl_merge_two_conflicts(xdmerge_t *m) m->chg1 = next_m->i1 + next_m->chg1 - m->i1; m->chg2 = next_m->i2 + next_m->chg2 - m->i2; m->next = next_m->next; - free(next_m); + xdl_free(next_m); } /* From 54218b5506a45217403f6cdfb85fce861b62606d Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 29 Apr 2024 19:16:29 +0100 Subject: [PATCH 595/608] array: treat `git_array` ptrs as `void *` Avoid sloppy aliasing in our (re-)allocation, which is undefined behavior. This has been problematic before and was helped by `volatile` (see b62a6a13b2f9a40e6ea4bf7bc2a9255429fb0bd6) but that is not technically correct, and some compilers / architectures do not understand that `ptr` is changing due to its aliasing. Just make `git_array_alloc` behave like `realloc`, taking a `void *` and returning a `void *`. --- src/util/array.h | 35 ++++++++++++++++++----------------- 1 file changed, 18 insertions(+), 17 deletions(-) diff --git a/src/util/array.h b/src/util/array.h index 633d598ee26..515e6e3ab46 100644 --- a/src/util/array.h +++ b/src/util/array.h @@ -41,39 +41,40 @@ #define GIT_ERROR_CHECK_ARRAY(a) GIT_ERROR_CHECK_ALLOC((a).ptr) - -typedef git_array_t(char) git_array_generic_t; - -/* use a generic array for growth, return 0 on success */ -GIT_INLINE(int) git_array_grow(void *_a, size_t item_size) +GIT_INLINE(void *) git_array__alloc(void *arr, size_t *size, size_t *asize, size_t item_size) { - volatile git_array_generic_t *a = _a; size_t new_size; - char *new_array; + void *new_array; + + if (*size < *asize) + return arr; - if (a->size < 8) { + if (*size < 8) { new_size = 8; } else { - if (GIT_MULTIPLY_SIZET_OVERFLOW(&new_size, a->size, 3)) + if (GIT_MULTIPLY_SIZET_OVERFLOW(&new_size, *asize, 3)) goto on_oom; + new_size /= 2; } - if ((new_array = git__reallocarray(a->ptr, new_size, item_size)) == NULL) + if ((new_array = git__reallocarray(arr, new_size, item_size)) == NULL) goto on_oom; - a->ptr = new_array; - a->asize = new_size; - return 0; + *asize = new_size; + + return new_array; on_oom: - git_array_clear(*a); - return -1; + git__free(arr); + *size = 0; + *asize = 0; + return NULL; } #define git_array_alloc(a) \ - (((a).size < (a).asize || git_array_grow(&(a), sizeof(*(a).ptr)) == 0) ? \ - &(a).ptr[(a).size++] : (void *)NULL) + (((a).size < (a).asize || \ + ((a).ptr = git_array__alloc((a).ptr, &(a).size, &(a).asize, sizeof(*(a).ptr))) != NULL) ? &(a).ptr[(a).size++] : (void *)NULL) #define git_array_last(a) ((a).size ? &(a).ptr[(a).size - 1] : (void *)NULL) From aaed67f78673d6fb213de5a58dd1ed08d2ab9db2 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 18 Apr 2024 20:47:45 +0100 Subject: [PATCH 596/608] alloc: introduce debug allocators Instead of tweaking the `stdalloc` allocator when `GIT_DEBUG_STRICT_ALLOC` is defined, actually create a debugging allocator. This allows us to ensure that we are strict about things like not expecting `malloc(0)` to do something useful, but we can also introduce an excessively pedantic `realloc` implementation that _always_ creates a new buffer, throws away its original `ptr`, and overwrites the data that's there with garbage. This may be helpful to identify places that make assumptions about realloc. --- src/util/alloc.c | 5 ++- src/util/allocators/debugalloc.c | 71 ++++++++++++++++++++++++++++++++ src/util/allocators/debugalloc.h | 17 ++++++++ src/util/allocators/stdalloc.c | 10 ----- 4 files changed, 92 insertions(+), 11 deletions(-) create mode 100644 src/util/allocators/debugalloc.c create mode 100644 src/util/allocators/debugalloc.h diff --git a/src/util/alloc.c b/src/util/alloc.c index 6ec173d04a4..998b0aea1d9 100644 --- a/src/util/alloc.c +++ b/src/util/alloc.c @@ -8,8 +8,9 @@ #include "alloc.h" #include "runtime.h" -#include "allocators/failalloc.h" #include "allocators/stdalloc.h" +#include "allocators/debugalloc.h" +#include "allocators/failalloc.h" #include "allocators/win32_leakcheck.h" /* Fail any allocation until git_libgit2_init is called. */ @@ -88,6 +89,8 @@ static int setup_default_allocator(void) { #if defined(GIT_WIN32_LEAKCHECK) return git_win32_leakcheck_init_allocator(&git__allocator); +#elif defined(GIT_DEBUG_STRICT_ALLOC) + return git_debugalloc_init_allocator(&git__allocator); #else return git_stdalloc_init_allocator(&git__allocator); #endif diff --git a/src/util/allocators/debugalloc.c b/src/util/allocators/debugalloc.c new file mode 100644 index 00000000000..acb002dbb32 --- /dev/null +++ b/src/util/allocators/debugalloc.c @@ -0,0 +1,71 @@ +/* + * Copyright (C) the libgit2 contributors. All rights reserved. + * + * This file is part of libgit2, distributed under the GNU GPL v2 with + * a Linking Exception. For full terms see the included COPYING file. + */ + +#include "debugalloc.h" + +static void *debugalloc__malloc(size_t len, const char *file, int line) +{ + void *ptr; + size_t total = len + sizeof(size_t); + + GIT_UNUSED(file); + GIT_UNUSED(line); + + if (!len || (ptr = malloc(total)) == NULL) + return NULL; + + memcpy(ptr, &len, sizeof(size_t)); + return ptr + sizeof(size_t); +} + +static void *debugalloc__realloc(void *ptr, size_t len, const char *file, int line) +{ + void *newptr; + size_t original_len; + size_t total = len + sizeof(size_t); + + GIT_UNUSED(file); + GIT_UNUSED(line); + + if (!len && !ptr) + return NULL; + + if (!len) { + free(ptr - sizeof(size_t)); + return NULL; + } + + if ((newptr = malloc(total)) == NULL) + return NULL; + + if (ptr) { + memcpy(&original_len, ptr - sizeof(size_t), sizeof(size_t)); + memcpy(newptr + sizeof(size_t), ptr, min(len, original_len)); + + memset(ptr - sizeof(size_t), 0xfd, original_len + sizeof(size_t)); + free(ptr - sizeof(size_t)); + } + + memcpy(newptr, &len, sizeof(size_t)); + return newptr + sizeof(size_t); +} + +static void debugalloc__free(void *ptr) +{ + if (!ptr) + return; + + free(ptr - sizeof(size_t)); +} + +int git_debugalloc_init_allocator(git_allocator *allocator) +{ + allocator->gmalloc = debugalloc__malloc; + allocator->grealloc = debugalloc__realloc; + allocator->gfree = debugalloc__free; + return 0; +} diff --git a/src/util/allocators/debugalloc.h b/src/util/allocators/debugalloc.h new file mode 100644 index 00000000000..dea0ca31cc1 --- /dev/null +++ b/src/util/allocators/debugalloc.h @@ -0,0 +1,17 @@ +/* + * Copyright (C) the libgit2 contributors. All rights reserved. + * + * This file is part of libgit2, distributed under the GNU GPL v2 with + * a Linking Exception. For full terms see the included COPYING file. + */ + +#ifndef INCLUDE_allocators_debugalloc_h__ +#define INCLUDE_allocators_debugalloc_h__ + +#include "git2_util.h" + +#include "alloc.h" + +int git_debugalloc_init_allocator(git_allocator *allocator); + +#endif diff --git a/src/util/allocators/stdalloc.c b/src/util/allocators/stdalloc.c index f2d72a7e6c9..65ec40fbe9d 100644 --- a/src/util/allocators/stdalloc.c +++ b/src/util/allocators/stdalloc.c @@ -12,11 +12,6 @@ static void *stdalloc__malloc(size_t len, const char *file, int line) GIT_UNUSED(file); GIT_UNUSED(line); -#ifdef GIT_DEBUG_STRICT_ALLOC - if (!len) - return NULL; -#endif - return malloc(len); } @@ -25,11 +20,6 @@ static void *stdalloc__realloc(void *ptr, size_t size, const char *file, int lin GIT_UNUSED(file); GIT_UNUSED(line); -#ifdef GIT_DEBUG_STRICT_ALLOC - if (!size) - return NULL; -#endif - return realloc(ptr, size); } From cfd6e0148b93e4823630c2839610f825b11d0294 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 18 Apr 2024 20:49:57 +0100 Subject: [PATCH 597/608] tests: use git__ allocator functions consistently --- tests/libgit2/checkout/conflict.c | 2 +- tests/libgit2/checkout/icase.c | 2 +- tests/libgit2/remote/fetch.c | 4 ++-- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/tests/libgit2/checkout/conflict.c b/tests/libgit2/checkout/conflict.c index b2eb939dcd7..3539c8b2dee 100644 --- a/tests/libgit2/checkout/conflict.c +++ b/tests/libgit2/checkout/conflict.c @@ -1095,7 +1095,7 @@ static void collect_progress( if (path == NULL) return; - git_vector_insert(paths, strdup(path)); + git_vector_insert(paths, git__strdup(path)); } void test_checkout_conflict__report_progress(void) diff --git a/tests/libgit2/checkout/icase.c b/tests/libgit2/checkout/icase.c index d77c7abd514..3769a9f9b7e 100644 --- a/tests/libgit2/checkout/icase.c +++ b/tests/libgit2/checkout/icase.c @@ -89,7 +89,7 @@ static void assert_name_is(const char *expected) if (start) cl_assert_equal_strn("/", actual + (start - 1), 1); - free(actual); + git__free(actual); } static int symlink_or_fake(git_repository *repo, const char *a, const char *b) diff --git a/tests/libgit2/remote/fetch.c b/tests/libgit2/remote/fetch.c index a5d3272c56b..7d2d11e2702 100644 --- a/tests/libgit2/remote/fetch.c +++ b/tests/libgit2/remote/fetch.c @@ -40,10 +40,10 @@ void test_remote_fetch__cleanup(void) { git_repository_free(repo2); cl_git_pass(git_futils_rmdir_r(repo1_path, NULL, GIT_RMDIR_REMOVE_FILES)); - free(repo1_path); + git__free(repo1_path); cl_git_pass(git_futils_rmdir_r(repo2_path, NULL, GIT_RMDIR_REMOVE_FILES)); - free(repo2_path); + git__free(repo2_path); } From afb2ef21bc46e116ec939164fdb5efb77cd88536 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 18 Apr 2024 14:54:29 +0100 Subject: [PATCH 598/608] util: don't return system allocated strings in realpath realpath(3) _may_ allocate strings (if the second param is NULL) using the system allocator. However, callers need an assurance that they can free memory using git__free. If we made realpath do an allocation, then make sure that we strdup it into our allocator's memory. More importantly, avoid this behavior by always providing a buffer to p_realpath invocations. --- src/util/unix/realpath.c | 28 +++++++++++++++++++++++----- 1 file changed, 23 insertions(+), 5 deletions(-) diff --git a/src/util/unix/realpath.c b/src/util/unix/realpath.c index 9e31a63b9f4..e1d2adb8dba 100644 --- a/src/util/unix/realpath.c +++ b/src/util/unix/realpath.c @@ -16,17 +16,35 @@ char *p_realpath(const char *pathname, char *resolved) { - char *ret; - if ((ret = realpath(pathname, resolved)) == NULL) + char *result; + + if ((result = realpath(pathname, resolved)) == NULL) return NULL; #ifdef __OpenBSD__ /* The OpenBSD realpath function behaves differently, * figure out if the file exists */ - if (access(ret, F_OK) < 0) - ret = NULL; + if (access(ret, F_OK) < 0) { + if (!resolved) + free(result); + + return NULL; + } #endif - return ret; + + /* + * If resolved == NULL, the system has allocated the result + * string. We need to strdup this into _our_ allocator pool + * so that callers can free it with git__free. + */ + if (!resolved) { + char *dup = git__strdup(result); + free(result); + + result = dup; + } + + return result; } #endif From abedcfe71ce8b8cf58b4ac4c276dbc45a31d90ea Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 18 Apr 2024 17:31:27 +0100 Subject: [PATCH 599/608] tests: reset the allocator to the default Instead of setting the allocator to stdalloc, just pass `NULL`, in case we're running with the debug allocator. --- tests/clar/clar_libgit2_alloc.c | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/tests/clar/clar_libgit2_alloc.c b/tests/clar/clar_libgit2_alloc.c index e9303792382..54eacd543e2 100644 --- a/tests/clar/clar_libgit2_alloc.c +++ b/tests/clar/clar_libgit2_alloc.c @@ -104,7 +104,5 @@ void cl_alloc_limit(size_t bytes) void cl_alloc_reset(void) { - git_allocator stdalloc; - git_stdalloc_init_allocator(&stdalloc); - git_allocator_setup(&stdalloc); + git_allocator_setup(NULL); } From eb00b48d915d0dd01e41364d31c6ab8470834aae Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Wed, 15 May 2024 22:38:33 +0100 Subject: [PATCH 600/608] fixup! alloc: introduce debug allocators --- src/util/allocators/debugalloc.c | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/src/util/allocators/debugalloc.c b/src/util/allocators/debugalloc.c index acb002dbb32..44022cd785a 100644 --- a/src/util/allocators/debugalloc.c +++ b/src/util/allocators/debugalloc.c @@ -9,7 +9,7 @@ static void *debugalloc__malloc(size_t len, const char *file, int line) { - void *ptr; + unsigned char *ptr; size_t total = len + sizeof(size_t); GIT_UNUSED(file); @@ -22,9 +22,9 @@ static void *debugalloc__malloc(size_t len, const char *file, int line) return ptr + sizeof(size_t); } -static void *debugalloc__realloc(void *ptr, size_t len, const char *file, int line) +static void *debugalloc__realloc(void *_ptr, size_t len, const char *file, int line) { - void *newptr; + unsigned char *ptr = _ptr, *newptr; size_t original_len; size_t total = len + sizeof(size_t); @@ -54,8 +54,10 @@ static void *debugalloc__realloc(void *ptr, size_t len, const char *file, int li return newptr + sizeof(size_t); } -static void debugalloc__free(void *ptr) +static void debugalloc__free(void *_ptr) { + unsigned char *ptr = _ptr; + if (!ptr) return; From 834ec0f52fcafd3af011dfd3f1b36ae2ee984ea5 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 16 May 2024 00:49:10 +0100 Subject: [PATCH 601/608] v1.8.1: update version numbers --- CMakeLists.txt | 2 +- include/git2/version.h | 4 ++-- package.json | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 17ca7576834..9ca8882a00e 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -6,7 +6,7 @@ cmake_minimum_required(VERSION 3.5.1) -project(libgit2 VERSION "1.8.0" LANGUAGES C) +project(libgit2 VERSION "1.8.1" LANGUAGES C) # Add find modules to the path set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${PROJECT_SOURCE_DIR}/cmake") diff --git a/include/git2/version.h b/include/git2/version.h index 010d4a224d9..33c96254cee 100644 --- a/include/git2/version.h +++ b/include/git2/version.h @@ -11,7 +11,7 @@ * The version string for libgit2. This string follows semantic * versioning (v2) guidelines. */ -#define LIBGIT2_VERSION "1.8.0" +#define LIBGIT2_VERSION "1.8.1" /** The major version number for this version of libgit2. */ #define LIBGIT2_VER_MAJOR 1 @@ -20,7 +20,7 @@ #define LIBGIT2_VER_MINOR 8 /** The revision ("teeny") version number for this version of libgit2. */ -#define LIBGIT2_VER_REVISION 0 +#define LIBGIT2_VER_REVISION 1 /** The Windows DLL patch number for this version of libgit2. */ #define LIBGIT2_VER_PATCH 0 diff --git a/package.json b/package.json index 2306e721853..6c1cb286ebd 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "libgit2", - "version": "1.8.0", + "version": "1.8.1", "repo": "https://github.com/libgit2/libgit2", "description": " A cross-platform, linkable library implementation of Git that you can use in your application.", "install": "mkdir build && cd build && cmake .. && cmake --build ." From ae65dac85ec4bfe795b35a8f1f4815489668713f Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 16 May 2024 00:46:42 +0100 Subject: [PATCH 602/608] v1.8.1: update changelog --- docs/changelog.md | 89 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 89 insertions(+) diff --git a/docs/changelog.md b/docs/changelog.md index 7b118c798be..a35a389a4c6 100644 --- a/docs/changelog.md +++ b/docs/changelog.md @@ -1,3 +1,92 @@ +v1.8.1 +------ + +This release primarily includes straightforward bugfixes, as well as +new functionality to have more control over the HTTP User-Agent header. +However, there is an API change from v1.8 that was required for +improved compatibility. + +In v1.8, libgit2 introduced the `report_unchanged ` member in the +`git_fetch_options` structure. We mistakenly introduced this as a +bitfield, which is not suitable for our public API. To correct this +mistake, we have _removed_ the `report_unchanged ` member. To support +the report unchanged tips option, users can set the `update_fetchhead` +member to include the `GIT_REMOTE_UPDATE_REPORT_UNCHANGED` value. + +The libgit2 projects regrets the API change, but this was required to +support cross-platform compatibility. + +## What's Changed + +### New features + +* Allow more control over the user-agent by @ethomson in + https://github.com/libgit2/libgit2/pull/6788 + +### Bug fixes + +* commit: Fix git_commit_create_from_stage without author and + committer by @florianpircher in + https://github.com/libgit2/libgit2/pull/6781 +* process.c: fix environ for macOS by @barracuda156 in + https://github.com/libgit2/libgit2/pull/6792 +* Bounds check for pack index read by @ConradIrwin in + https://github.com/libgit2/libgit2/pull/6796 +* transport: provide a useful error message during cancellation + by @ethomson in https://github.com/libgit2/libgit2/pull/6802 +* transport: support sha256 oids by @ethomson in + https://github.com/libgit2/libgit2/pull/6803 +* Revparse: Correctly accept ref with '@' at the end by @csware in + https://github.com/libgit2/libgit2/pull/6809 +* remote: drop bitfields in git_remote_fetch_options by @ethomson in + https://github.com/libgit2/libgit2/pull/6806 +* examples: fix memory leak in for-each-ref.c by @qaqland in + https://github.com/libgit2/libgit2/pull/6808 +* xdiff: use proper free function by @ethomson in + https://github.com/libgit2/libgit2/pull/6810 +* rand: avoid uninitialized loadavg warnings by @ethomson in + https://github.com/libgit2/libgit2/pull/6812 +* cli: include alloca on illumos / solaris / sunos by @ethomson in + https://github.com/libgit2/libgit2/pull/6813 +* Update git_array allocator to obey strict aliasing rules + by @ethomson in https://github.com/libgit2/libgit2/pull/6814 +* tree: avoid mixed signedness comparison by @ethomson in + https://github.com/libgit2/libgit2/pull/6815 + +### Build and CI improvements + +* ci: update nightly workflows by @ethomson in + https://github.com/libgit2/libgit2/pull/6773 +* ci: give all nightly builds a unique id by @ethomson in + https://github.com/libgit2/libgit2/pull/6782 +* cmake: remove workaround that isn't compatible with Windows on + ARM by @hackhaslam in https://github.com/libgit2/libgit2/pull/6794 + +### Documentation improvements + +* Docs meta-updates by @ethomson in + https://github.com/libgit2/libgit2/pull/6787 + +### Dependency updates + +* Enable llhttp for HTTP parsing by @sgallagher in + https://github.com/libgit2/libgit2/pull/6713 + +## New Contributors + +* @florianpircher made their first contribution in + https://github.com/libgit2/libgit2/pull/6781 +* @barracuda156 made their first contribution in + https://github.com/libgit2/libgit2/pull/6792 +* @sgallagher made their first contribution in + https://github.com/libgit2/libgit2/pull/6713 +* @ConradIrwin made their first contribution in + https://github.com/libgit2/libgit2/pull/6796 +* @qaqland made their first contribution in + https://github.com/libgit2/libgit2/pull/6808 + +**Full Changelog**: https://github.com/libgit2/libgit2/compare/v1.8.0...v1.8.1 + v1.8 ---- From cc2082aa9bafaf1ff541fca22cccc86ec1461f65 Mon Sep 17 00:00:00 2001 From: Martin Marmsoler Date: Tue, 11 Jun 2024 23:12:41 +0200 Subject: [PATCH 603/608] Add assert Description: In an older version of libgit2 in git_object_lookup_prefix was a check that repo is valid, but now there is repo->oid_type in the git_object_lookup and must be checked as well --- src/libgit2/object.c | 1 + 1 file changed, 1 insertion(+) diff --git a/src/libgit2/object.c b/src/libgit2/object.c index 5fab77e6ae3..70e28c2c034 100644 --- a/src/libgit2/object.c +++ b/src/libgit2/object.c @@ -281,6 +281,7 @@ int git_object_lookup_prefix( } int git_object_lookup(git_object **object_out, git_repository *repo, const git_oid *id, git_object_t type) { + GIT_ASSERT_ARG(repo); return git_object_lookup_prefix(object_out, repo, id, git_oid_hexsize(repo->oid_type), type); } From 65a7ff06440afbea2576db44122ee5a20aa30b0a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ludovic=20Court=C3=A8s?= Date: Wed, 28 Aug 2024 15:28:35 +0200 Subject: [PATCH 604/608] =?UTF-8?q?http:=20Initialize=20=E2=80=98on=5Fstat?= =?UTF-8?q?us=E2=80=99=20when=20using=20the=20http-parser=20backend.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Fixes a bug likely introduced in d396819101a67c652af0fa0ae65cda19a2c0430a (in 1.8.1) whereby ‘proxy_settings.on_status’ would be left uninitialized when using the ‘http-parser’ backend, eventually leading to a segfault in ‘http_parser_execute’. Valgrind would report use of the uninitialized value like so: Conditional jump or move depends on uninitialised value(s) at 0x50CD533: http_parser_execute (http_parser.c:910) by 0x4928504: git_http_parser_execute (httpparser.c:82) by 0x4925C42: client_read_and_parse (httpclient.c:1178) by 0x4926F27: git_http_client_read_response (httpclient.c:1458) by 0x49255FE: http_stream_read (http.c:427) by 0x4929B90: git_smart__recv (smart.c:29) by 0x492C147: git_smart__store_refs (smart_protocol.c:58) by 0x4929F6C: git_smart__connect (smart.c:171) by 0x4904DCE: git_remote_connect_ext (remote.c:963) by 0x48A15D2: clone_into (clone.c:449) by 0x48A15D2: git__clone (clone.c:546) by 0x4010E9: main (libgit2-proxy.c:20) --- src/libgit2/transports/httpparser.c | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/libgit2/transports/httpparser.c b/src/libgit2/transports/httpparser.c index 50ba6d2e0cd..c19499b84f4 100644 --- a/src/libgit2/transports/httpparser.c +++ b/src/libgit2/transports/httpparser.c @@ -71,6 +71,7 @@ size_t git_http_parser_execute( { struct http_parser_settings settings_proxy; + settings_proxy.on_status = NULL; settings_proxy.on_message_begin = parser->settings.on_message_begin ? on_message_begin : NULL; settings_proxy.on_url = parser->settings.on_url ? on_url : NULL; settings_proxy.on_header_field = parser->settings.on_header_field ? on_header_field : NULL; @@ -78,6 +79,8 @@ size_t git_http_parser_execute( settings_proxy.on_headers_complete = parser->settings.on_headers_complete ? on_headers_complete : NULL; settings_proxy.on_body = parser->settings.on_body ? on_body : NULL; settings_proxy.on_message_complete = parser->settings.on_message_complete ? on_message_complete : NULL; + settings_proxy.on_chunk_header = NULL; + settings_proxy.on_chunk_complete = NULL; return http_parser_execute(&parser->parser, &settings_proxy, data, len); } From a44f198f925db5acfdc9585e5c03ec373cd781c0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ludovic=20Court=C3=A8s?= Date: Thu, 29 Aug 2024 20:38:55 +0000 Subject: [PATCH 605/608] Apply suggestions from code review Co-authored-by: Edward Thomson --- src/libgit2/transports/httpparser.c | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/src/libgit2/transports/httpparser.c b/src/libgit2/transports/httpparser.c index c19499b84f4..84833e61737 100644 --- a/src/libgit2/transports/httpparser.c +++ b/src/libgit2/transports/httpparser.c @@ -71,7 +71,8 @@ size_t git_http_parser_execute( { struct http_parser_settings settings_proxy; - settings_proxy.on_status = NULL; + memset(&settings_proxy, 0, sizeof(struct http_parser_settings)); + settings_proxy.on_message_begin = parser->settings.on_message_begin ? on_message_begin : NULL; settings_proxy.on_url = parser->settings.on_url ? on_url : NULL; settings_proxy.on_header_field = parser->settings.on_header_field ? on_header_field : NULL; @@ -79,8 +80,6 @@ size_t git_http_parser_execute( settings_proxy.on_headers_complete = parser->settings.on_headers_complete ? on_headers_complete : NULL; settings_proxy.on_body = parser->settings.on_body ? on_body : NULL; settings_proxy.on_message_complete = parser->settings.on_message_complete ? on_message_complete : NULL; - settings_proxy.on_chunk_header = NULL; - settings_proxy.on_chunk_complete = NULL; return http_parser_execute(&parser->parser, &settings_proxy, data, len); } From da3db6368817d3bc45abb94df61ce8487b49dc7b Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 26 Oct 2024 19:36:15 +0100 Subject: [PATCH 606/608] v1.8.3: update changelog and version numbers --- CMakeLists.txt | 2 +- docs/changelog.md | 39 +++++++++++++++++++++++++++++++++++++++ include/git2/version.h | 4 ++-- package.json | 2 +- 4 files changed, 43 insertions(+), 4 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 9ca8882a00e..83b62185848 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -6,7 +6,7 @@ cmake_minimum_required(VERSION 3.5.1) -project(libgit2 VERSION "1.8.1" LANGUAGES C) +project(libgit2 VERSION "1.8.3" LANGUAGES C) # Add find modules to the path set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${PROJECT_SOURCE_DIR}/cmake") diff --git a/docs/changelog.md b/docs/changelog.md index a35a389a4c6..f4ac83fb406 100644 --- a/docs/changelog.md +++ b/docs/changelog.md @@ -1,3 +1,42 @@ +v1.8.3 +------ + +This release fixes a bug introduced in v1.8.1 for users of the legacy +[Node.js http-parser](https://github.com/nodejs/http-parser) +dependency. + +## What's Changed + +### Bug fixes + +* http: Backport on_status initialize fix for http-parser by @ethomson in https://github.com/libgit2/libgit2/pull/6931 + +v1.8.2 +------ + +This release reverts a const-correctness change introduced in +v1.8.0 for the `git_commit_create` functions. We now retain the +const-behavior for the `commits` arguments from prior to v1.8.0. + +This change was meant to resolve compatibility issues with bindings +and downstream users. + +## What's Changed + +### New features + +* Introduce a stricter debugging allocator for testing by @ethomson in https://github.com/libgit2/libgit2/pull/6811 + +### Bug fixes + +* Fix constness issue introduced in #6716 by @ethomson in https://github.com/libgit2/libgit2/pull/6829 + +### Build and CI improvements + +* README: add experimental builds to ci table by @ethomson in https://github.com/libgit2/libgit2/pull/6816 + +**Full Changelog**: https://github.com/libgit2/libgit2/compare/v1.8.1...v1.8.2 + v1.8.1 ------ diff --git a/include/git2/version.h b/include/git2/version.h index 33c96254cee..906fa61c642 100644 --- a/include/git2/version.h +++ b/include/git2/version.h @@ -11,7 +11,7 @@ * The version string for libgit2. This string follows semantic * versioning (v2) guidelines. */ -#define LIBGIT2_VERSION "1.8.1" +#define LIBGIT2_VERSION "1.8.3" /** The major version number for this version of libgit2. */ #define LIBGIT2_VER_MAJOR 1 @@ -20,7 +20,7 @@ #define LIBGIT2_VER_MINOR 8 /** The revision ("teeny") version number for this version of libgit2. */ -#define LIBGIT2_VER_REVISION 1 +#define LIBGIT2_VER_REVISION 3 /** The Windows DLL patch number for this version of libgit2. */ #define LIBGIT2_VER_PATCH 0 diff --git a/package.json b/package.json index 6c1cb286ebd..b67c559024e 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "libgit2", - "version": "1.8.1", + "version": "1.8.3", "repo": "https://github.com/libgit2/libgit2", "description": " A cross-platform, linkable library implementation of Git that you can use in your application.", "install": "mkdir build && cd build && cmake .. && cmake --build ." From 94ba816f66f71057b33c107e0c5aea6299a3d497 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 13 Jun 2024 15:20:40 +0200 Subject: [PATCH 607/608] Revert "commit: fix const declaration" This reverts commit cf19ddc52227f4ec2efd4c0a84aa5d2362f0ffc7, which was breaking for several projects. --- examples/merge.c | 2 +- include/git2/commit.h | 6 +++--- src/libgit2/commit.c | 11 ++++++----- src/libgit2/commit.h | 2 +- src/libgit2/notes.c | 4 ++-- src/libgit2/rebase.c | 9 +++++---- src/libgit2/stash.c | 4 ++-- tests/libgit2/checkout/tree.c | 2 +- tests/libgit2/cherrypick/workdir.c | 2 +- tests/libgit2/commit/commit.c | 4 ++-- tests/libgit2/commit/write.c | 2 +- tests/libgit2/diff/rename.c | 2 +- tests/libgit2/odb/freshen.c | 2 +- tests/libgit2/rebase/sign.c | 6 +++--- tests/libgit2/refs/reflog/messages.c | 2 +- tests/libgit2/revert/workdir.c | 6 +++--- tests/libgit2/revwalk/basic.c | 3 ++- 17 files changed, 36 insertions(+), 33 deletions(-) diff --git a/examples/merge.c b/examples/merge.c index 718c767d038..7a76912cd24 100644 --- a/examples/merge.c +++ b/examples/merge.c @@ -263,7 +263,7 @@ static int create_merge_commit(git_repository *repo, git_index *index, struct me sign, sign, NULL, msg, tree, - opts->annotated_count + 1, parents); + opts->annotated_count + 1, (const git_commit **)parents); check_lg2(err, "failed to create commit", NULL); /* We're done merging, cleanup the repository state */ diff --git a/include/git2/commit.h b/include/git2/commit.h index ef38c66e6cc..88c21e0c973 100644 --- a/include/git2/commit.h +++ b/include/git2/commit.h @@ -366,7 +366,7 @@ GIT_EXTERN(int) git_commit_create( const char *message, const git_tree *tree, size_t parent_count, - git_commit * const parents[]); + const git_commit *parents[]); /** * Create new commit in the repository using a variable argument list. @@ -512,7 +512,7 @@ GIT_EXTERN(int) git_commit_create_buffer( const char *message, const git_tree *tree, size_t parent_count, - git_commit * const parents[]); + const git_commit *parents[]); /** * Create a commit object from the given buffer and signature @@ -581,7 +581,7 @@ typedef int (*git_commit_create_cb)( const char *message, const git_tree *tree, size_t parent_count, - git_commit * const parents[], + const git_commit *parents[], void *payload); /** An array of commits returned from the library */ diff --git a/src/libgit2/commit.c b/src/libgit2/commit.c index 47f6fed892f..10df43623d2 100644 --- a/src/libgit2/commit.c +++ b/src/libgit2/commit.c @@ -281,7 +281,7 @@ int git_commit_create_from_ids( typedef struct { size_t total; - git_commit * const *parents; + const git_commit **parents; git_repository *repo; } commit_parent_data; @@ -307,7 +307,7 @@ int git_commit_create( const char *message, const git_tree *tree, size_t parent_count, - git_commit * const parents[]) + const git_commit *parents[]) { commit_parent_data data = { parent_count, parents, repo }; @@ -945,7 +945,7 @@ int git_commit_create_buffer( const char *message, const git_tree *tree, size_t parent_count, - git_commit * const parents[]) + const git_commit *parents[]) { GIT_BUF_WRAP_PRIVATE(out, git_commit__create_buffer, repo, author, committer, message_encoding, message, @@ -961,7 +961,7 @@ int git_commit__create_buffer( const char *message, const git_tree *tree, size_t parent_count, - git_commit * const parents[]) + const git_commit *parents[]) { int error; commit_parent_data data = { parent_count, parents, repo }; @@ -1150,7 +1150,8 @@ int git_commit_create_from_stage( error = git_commit_create(out, repo, "HEAD", author, committer, opts.message_encoding, message, - tree, parents.count, parents.commits); + tree, parents.count, + (const git_commit **)parents.commits); done: git_commitarray_dispose(&parents); diff --git a/src/libgit2/commit.h b/src/libgit2/commit.h index 53128ba5d83..c25fee327b8 100644 --- a/src/libgit2/commit.h +++ b/src/libgit2/commit.h @@ -64,7 +64,7 @@ int git_commit__create_buffer( const char *message, const git_tree *tree, size_t parent_count, - git_commit * const parents[]); + const git_commit *parents[]); int git_commit__parse( void *commit, diff --git a/src/libgit2/notes.c b/src/libgit2/notes.c index 2dd194581fd..13ca3824bf1 100644 --- a/src/libgit2/notes.c +++ b/src/libgit2/notes.c @@ -303,7 +303,7 @@ static int note_write( error = git_commit_create(&oid, repo, notes_ref, author, committer, NULL, GIT_NOTES_DEFAULT_MSG_ADD, - tree, *parents == NULL ? 0 : 1, parents); + tree, *parents == NULL ? 0 : 1, (const git_commit **) parents); if (notes_commit_out) git_oid_cpy(notes_commit_out, &oid); @@ -394,7 +394,7 @@ static int note_remove( NULL, GIT_NOTES_DEFAULT_MSG_RM, tree_after_removal, *parents == NULL ? 0 : 1, - parents); + (const git_commit **) parents); if (error < 0) goto cleanup; diff --git a/src/libgit2/rebase.c b/src/libgit2/rebase.c index 2fce3e7bc06..77e442e981d 100644 --- a/src/libgit2/rebase.c +++ b/src/libgit2/rebase.c @@ -952,7 +952,7 @@ static int create_signed( const char *message, git_tree *tree, size_t parent_count, - git_commit * const *parents) + const git_commit **parents) { git_str commit_content = GIT_STR_INIT; git_buf commit_signature = { NULL, 0, 0 }, @@ -1040,7 +1040,8 @@ static int rebase_commit__create( if (rebase->options.commit_create_cb) { error = rebase->options.commit_create_cb(&commit_id, author, committer, message_encoding, message, - tree, 1, &parent_commit, rebase->options.payload); + tree, 1, (const git_commit **)&parent_commit, + rebase->options.payload); git_error_set_after_callback_function(error, "commit_create_cb"); @@ -1049,14 +1050,14 @@ static int rebase_commit__create( else if (rebase->options.signing_cb) { error = create_signed(&commit_id, rebase, author, committer, message_encoding, message, tree, - 1, &parent_commit); + 1, (const git_commit **)&parent_commit); } #endif if (error == GIT_PASSTHROUGH) error = git_commit_create(&commit_id, rebase->repo, NULL, author, committer, message_encoding, message, - tree, 1, &parent_commit); + tree, 1, (const git_commit **)&parent_commit); if (error) goto done; diff --git a/src/libgit2/stash.c b/src/libgit2/stash.c index a0a72deacc6..b49e95cdb21 100644 --- a/src/libgit2/stash.c +++ b/src/libgit2/stash.c @@ -124,7 +124,7 @@ static int commit_index( git_index *index, const git_signature *stasher, const char *message, - git_commit *parent) + const git_commit *parent) { git_tree *i_tree = NULL; git_oid i_commit_oid; @@ -423,7 +423,7 @@ static int build_stash_commit_from_tree( git_commit *u_commit, const git_tree *tree) { - git_commit *parents[] = { NULL, NULL, NULL }; + const git_commit *parents[] = { NULL, NULL, NULL }; parents[0] = b_commit; parents[1] = i_commit; diff --git a/tests/libgit2/checkout/tree.c b/tests/libgit2/checkout/tree.c index 97935aaeaa1..65df00cd87b 100644 --- a/tests/libgit2/checkout/tree.c +++ b/tests/libgit2/checkout/tree.c @@ -1235,7 +1235,7 @@ void test_checkout_tree__case_changing_rename(void) cl_git_pass(git_signature_new(&signature, "Renamer", "rename@contoso.com", time(NULL), 0)); - cl_git_pass(git_commit_create(&commit_id, g_repo, "refs/heads/dir", signature, signature, NULL, "case-changing rename", tree, 1, &dir_commit)); + cl_git_pass(git_commit_create(&commit_id, g_repo, "refs/heads/dir", signature, signature, NULL, "case-changing rename", tree, 1, (const git_commit **)&dir_commit)); cl_assert(git_fs_path_isfile("testrepo/readme")); if (case_sensitive) diff --git a/tests/libgit2/cherrypick/workdir.c b/tests/libgit2/cherrypick/workdir.c index 9d9a3f49795..c16b7814ac0 100644 --- a/tests/libgit2/cherrypick/workdir.c +++ b/tests/libgit2/cherrypick/workdir.c @@ -77,7 +77,7 @@ void test_cherrypick_workdir__automerge(void) cl_git_pass(git_index_write_tree(&cherrypicked_tree_oid, repo_index)); cl_git_pass(git_tree_lookup(&cherrypicked_tree, repo, &cherrypicked_tree_oid)); cl_git_pass(git_commit_create(&cherrypicked_oid, repo, "HEAD", signature, signature, NULL, - "Cherry picked!", cherrypicked_tree, 1, &head)); + "Cherry picked!", cherrypicked_tree, 1, (const git_commit **)&head)); cl_assert(merge_test_index(repo_index, merge_index_entries + i * 3, 3)); diff --git a/tests/libgit2/commit/commit.c b/tests/libgit2/commit/commit.c index 923740f23af..140f87d0c72 100644 --- a/tests/libgit2/commit/commit.c +++ b/tests/libgit2/commit/commit.c @@ -36,11 +36,11 @@ void test_commit_commit__create_unexisting_update_ref(void) cl_git_fail(git_reference_lookup(&ref, _repo, "refs/heads/foo/bar")); cl_git_pass(git_commit_create(&oid, _repo, "refs/heads/foo/bar", s, s, - NULL, "some msg", tree, 1, &commit)); + NULL, "some msg", tree, 1, (const git_commit **) &commit)); /* fail because the parent isn't the tip of the branch anymore */ cl_git_fail(git_commit_create(&oid, _repo, "refs/heads/foo/bar", s, s, - NULL, "some msg", tree, 1, &commit)); + NULL, "some msg", tree, 1, (const git_commit **) &commit)); cl_git_pass(git_reference_lookup(&ref, _repo, "refs/heads/foo/bar")); cl_assert_equal_oid(&oid, git_reference_target(ref)); diff --git a/tests/libgit2/commit/write.c b/tests/libgit2/commit/write.c index d38b54d2077..890f7384b1a 100644 --- a/tests/libgit2/commit/write.c +++ b/tests/libgit2/commit/write.c @@ -118,7 +118,7 @@ void test_commit_write__into_buf(void) cl_git_pass(git_commit_lookup(&parent, g_repo, &parent_id)); cl_git_pass(git_commit_create_buffer(&commit, g_repo, author, committer, - NULL, root_commit_message, tree, 1, &parent)); + NULL, root_commit_message, tree, 1, (const git_commit **) &parent)); cl_assert_equal_s(commit.ptr, "tree 1810dff58d8a660512d4832e740f692884338ccd\n\ diff --git a/tests/libgit2/diff/rename.c b/tests/libgit2/diff/rename.c index 15dee5c97d5..61a2f839cb3 100644 --- a/tests/libgit2/diff/rename.c +++ b/tests/libgit2/diff/rename.c @@ -424,7 +424,7 @@ void test_diff_rename__test_small_files(void) cl_git_pass(git_index_write_tree(&oid, index)); cl_git_pass(git_tree_lookup(&commit_tree, g_repo, &oid)); cl_git_pass(git_signature_new(&signature, "Rename", "rename@example.com", 1404157834, 0)); - cl_git_pass(git_commit_create(&oid, g_repo, "HEAD", signature, signature, NULL, "Test commit", commit_tree, 1, &head_commit)); + cl_git_pass(git_commit_create(&oid, g_repo, "HEAD", signature, signature, NULL, "Test commit", commit_tree, 1, (const git_commit**)&head_commit)); cl_git_mkfile("renames/copy.txt", "Hello World!\n"); cl_git_rmfile("renames/small.txt"); diff --git a/tests/libgit2/odb/freshen.c b/tests/libgit2/odb/freshen.c index d0e0e3c3c04..e337c82b773 100644 --- a/tests/libgit2/odb/freshen.c +++ b/tests/libgit2/odb/freshen.c @@ -125,7 +125,7 @@ void test_odb_freshen__tree_during_commit(void) cl_git_pass(git_commit_create(&commit_id, repo, NULL, signature, signature, NULL, "New commit pointing to old tree", - tree, 1, &parent)); + tree, 1, (const git_commit **)&parent)); /* make sure we freshen the tree the commit points to */ cl_must_pass(p_lstat("testrepo.git/objects/" LOOSE_TREE_FN, &after)); diff --git a/tests/libgit2/rebase/sign.c b/tests/libgit2/rebase/sign.c index 45bac29d095..69bb1c6f998 100644 --- a/tests/libgit2/rebase/sign.c +++ b/tests/libgit2/rebase/sign.c @@ -26,7 +26,7 @@ static int create_cb_passthrough( const char *message, const git_tree *tree, size_t parent_count, - git_commit * const parents[], + const git_commit *parents[], void *payload) { GIT_UNUSED(out); @@ -94,7 +94,7 @@ static int create_cb_signed_gpg( const char *message, const git_tree *tree, size_t parent_count, - git_commit * const parents[], + const git_commit *parents[], void *payload) { git_buf commit_content = GIT_BUF_INIT; @@ -202,7 +202,7 @@ static int create_cb_error( const char *message, const git_tree *tree, size_t parent_count, - git_commit * const parents[], + const git_commit *parents[], void *payload) { GIT_UNUSED(out); diff --git a/tests/libgit2/refs/reflog/messages.c b/tests/libgit2/refs/reflog/messages.c index 4a2ecb02aed..647c00d0dfd 100644 --- a/tests/libgit2/refs/reflog/messages.c +++ b/tests/libgit2/refs/reflog/messages.c @@ -233,7 +233,7 @@ void test_refs_reflog_messages__show_merge_for_merge_commits(void) cl_git_pass(git_commit_create(&merge_commit_oid, g_repo, "HEAD", s, s, NULL, "Merge commit", tree, - 2, parent_commits)); + 2, (const struct git_commit **) parent_commits)); cl_reflog_check_entry(g_repo, GIT_HEAD_FILE, 0, NULL, diff --git a/tests/libgit2/revert/workdir.c b/tests/libgit2/revert/workdir.c index 6d74254e533..3e790b77f78 100644 --- a/tests/libgit2/revert/workdir.c +++ b/tests/libgit2/revert/workdir.c @@ -188,7 +188,7 @@ void test_revert_workdir__again(void) cl_git_pass(git_tree_lookup(&reverted_tree, repo, &reverted_tree_oid)); cl_git_pass(git_signature_new(&signature, "Reverter", "reverter@example.org", time(NULL), 0)); - cl_git_pass(git_commit_create(&reverted_commit_oid, repo, "HEAD", signature, signature, NULL, "Reverted!", reverted_tree, 1, &orig_head)); + cl_git_pass(git_commit_create(&reverted_commit_oid, repo, "HEAD", signature, signature, NULL, "Reverted!", reverted_tree, 1, (const git_commit **)&orig_head)); cl_git_pass(git_revert(repo, orig_head, NULL)); cl_assert(merge_test_index(repo_index, merge_index_entries, 4)); @@ -238,7 +238,7 @@ void test_revert_workdir__again_after_automerge(void) cl_git_pass(git_tree_lookup(&reverted_tree, repo, &reverted_tree_oid)); cl_git_pass(git_signature_new(&signature, "Reverter", "reverter@example.org", time(NULL), 0)); - cl_git_pass(git_commit_create(&reverted_commit_oid, repo, "HEAD", signature, signature, NULL, "Reverted!", reverted_tree, 1, &head)); + cl_git_pass(git_commit_create(&reverted_commit_oid, repo, "HEAD", signature, signature, NULL, "Reverted!", reverted_tree, 1, (const git_commit **)&head)); cl_git_pass(git_revert(repo, commit, NULL)); cl_assert(merge_test_index(repo_index, second_revert_entries, 6)); @@ -287,7 +287,7 @@ void test_revert_workdir__again_after_edit(void) cl_git_pass(git_tree_lookup(&reverted_tree, repo, &reverted_tree_oid)); cl_git_pass(git_signature_new(&signature, "Reverter", "reverter@example.org", time(NULL), 0)); - cl_git_pass(git_commit_create(&reverted_commit_oid, repo, "HEAD", signature, signature, NULL, "Reverted!", reverted_tree, 1, &orig_head)); + cl_git_pass(git_commit_create(&reverted_commit_oid, repo, "HEAD", signature, signature, NULL, "Reverted!", reverted_tree, 1, (const git_commit **)&orig_head)); cl_git_pass(git_revert(repo, commit, NULL)); cl_assert(merge_test_index(repo_index, merge_index_entries, 4)); diff --git a/tests/libgit2/revwalk/basic.c b/tests/libgit2/revwalk/basic.c index 5c53405051b..41090a1dac8 100644 --- a/tests/libgit2/revwalk/basic.c +++ b/tests/libgit2/revwalk/basic.c @@ -550,7 +550,8 @@ void test_revwalk_basic__big_timestamp(void) cl_git_pass(git_signature_new(&sig, "Joe", "joe@example.com", INT64_C(2399662595), 0)); cl_git_pass(git_commit_tree(&tree, tip)); - cl_git_pass(git_commit_create(&id, _repo, "HEAD", sig, sig, NULL, "some message", tree, 1, &tip)); + cl_git_pass(git_commit_create(&id, _repo, "HEAD", sig, sig, NULL, "some message", tree, 1, + (const git_commit **)&tip)); cl_git_pass(git_revwalk_push_head(_walk)); From 73644b33f4e15c45ddeca493216d7e7ee1a98393 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Wed, 30 Oct 2024 17:35:05 -0400 Subject: [PATCH 608/608] v1.8.4: update changelog and version numbers --- CMakeLists.txt | 2 +- docs/changelog.md | 15 +++++++++++++++ include/git2/version.h | 4 ++-- package.json | 2 +- 4 files changed, 19 insertions(+), 4 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 83b62185848..6e454816ef4 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -6,7 +6,7 @@ cmake_minimum_required(VERSION 3.5.1) -project(libgit2 VERSION "1.8.3" LANGUAGES C) +project(libgit2 VERSION "1.8.4" LANGUAGES C) # Add find modules to the path set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${PROJECT_SOURCE_DIR}/cmake") diff --git a/docs/changelog.md b/docs/changelog.md index f4ac83fb406..02bad65e17c 100644 --- a/docs/changelog.md +++ b/docs/changelog.md @@ -1,3 +1,18 @@ +v1.8.4 +------ + +We erroneously shipped v1.8.3 without actually including the change +in v1.8.2. This release re-re-introduces the pre-v1.8.0 `commit` +constness behavior. + +## What's Changed + +### Bug fixes + +* Fix constness issue introduced in #6716 by @ethomson in https://github.com/libgit2/libgit2/pull/6829 + +**Full Changelog**: https://github.com/libgit2/libgit2/compare/v1.8.3...v1.8.4 + v1.8.3 ------ diff --git a/include/git2/version.h b/include/git2/version.h index 906fa61c642..65fd199cf09 100644 --- a/include/git2/version.h +++ b/include/git2/version.h @@ -11,7 +11,7 @@ * The version string for libgit2. This string follows semantic * versioning (v2) guidelines. */ -#define LIBGIT2_VERSION "1.8.3" +#define LIBGIT2_VERSION "1.8.4" /** The major version number for this version of libgit2. */ #define LIBGIT2_VER_MAJOR 1 @@ -20,7 +20,7 @@ #define LIBGIT2_VER_MINOR 8 /** The revision ("teeny") version number for this version of libgit2. */ -#define LIBGIT2_VER_REVISION 3 +#define LIBGIT2_VER_REVISION 4 /** The Windows DLL patch number for this version of libgit2. */ #define LIBGIT2_VER_PATCH 0 diff --git a/package.json b/package.json index b67c559024e..6b8106c43a8 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "libgit2", - "version": "1.8.3", + "version": "1.8.4", "repo": "https://github.com/libgit2/libgit2", "description": " A cross-platform, linkable library implementation of Git that you can use in your application.", "install": "mkdir build && cd build && cmake .. && cmake --build ."

    =mM5&%b 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 VkO2&l#Yv$+QtYmHNi3Nj{}+t}`m6u| literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/pack/pack-f72bbfa35af982c2a60735152c80b24ee981cf102db76764c383f9b87935d0d3.idx b/tests/resources/testrepo_256.git/objects/pack/pack-f72bbfa35af982c2a60735152c80b24ee981cf102db76764c383f9b87935d0d3.idx new file mode 100644 index 0000000000000000000000000000000000000000..1d197e87085e32a838da41a976b0dbf13938628b GIT binary patch literal 1336 zcmexg;-AdGz`z8=qk!}fU<7KRB?iUIKx1a08>od@fM!t>vjWW|?pt)*BaNFAyuP`%y7il{<)*l^up!FyVBLILX1~6UNj$>y7hv+?ty1Foih&9c8$9gZVTN(b|vv=+n z%vY#cef;}9o3l0T7e94ekq+)qb=qWeh$CyJ*trPpZY`#4Uej*2!>e|k<5Vsvk1x8F z`%9#=a4pwHFQtQVS#mr{Q3uw%)UbRqOEe-N)H^;`N0UujbJgVEHTHi0cWu3Y$MxLK zpUXA3KYsl0)3(#!e%|Q&dsA7I#cSe0dj`fGuHSS0ez(6`_s#Zi{DH~88P9h5PoBX8 za<(VeAqN45_n*7=abMb;A|~*W`QDLge}8v&U#5+p>zV&KtO$0Tx=zVq?E{J0XHvmM z5#?NM6N)^_4mjvcoe{j&?$m`Dv!>6vyUucog_rS`m&K6}??tAyYOlTZaEXcj`nR8E ztk~bb$0vP*UUZ3}2tRvCN80w_@TvAe#gqFFUfn%$QOBLO{Y5s*lYAdr>(2I0yPnUfJA41>o9i!$GHl)_^lURw zGqx${veU9^^TXL&loJDdfzC2AGQx0KM)i`y;->57*SAgA zJ|i7bzI2!Azy7+KBWX(y{>!QC)t>f|L13~N&sIhpE@NT{O=oZWuDyS8)X%0v%h*jt abs9GLy=*)$pu0Ui<#6-Q9hIgRE&~9e7#2MM literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/packed-refs b/tests/resources/testrepo_256.git/packed-refs new file mode 100644 index 00000000000..995685f0805 --- /dev/null +++ b/tests/resources/testrepo_256.git/packed-refs @@ -0,0 +1,3 @@ +# pack-refs with: peeled sorted +66fe8385c6378bfa5ca5573bd0fdd773e4eadb0e86416b483f2c50c839859ecb refs/heads/packed +cb282e7c15fd8aeb2265cd621f5a228cb33dc84192980ca426cf9ab2a48cb9f0 refs/heads/packed-test diff --git a/tests/resources/testrepo_256.git/refs/blobs/annotated_tag_to_blob b/tests/resources/testrepo_256.git/refs/blobs/annotated_tag_to_blob new file mode 100644 index 00000000000..2723f8909fe --- /dev/null +++ b/tests/resources/testrepo_256.git/refs/blobs/annotated_tag_to_blob @@ -0,0 +1 @@ +d88b60d2641df3656381dc8e201abb820a414de03eb63c065b06a2ab37d3f5ca diff --git a/tests/resources/testrepo_256.git/refs/heads/br2 b/tests/resources/testrepo_256.git/refs/heads/br2 new file mode 100644 index 00000000000..2abd96e0992 --- /dev/null +++ b/tests/resources/testrepo_256.git/refs/heads/br2 @@ -0,0 +1 @@ +a4813ef6708e6011e8187224297e83e4a285f58bf5eabb1db270351388603c95 diff --git a/tests/resources/testrepo_256.git/refs/heads/cannot-fetch b/tests/resources/testrepo_256.git/refs/heads/cannot-fetch new file mode 100644 index 00000000000..2abd96e0992 --- /dev/null +++ b/tests/resources/testrepo_256.git/refs/heads/cannot-fetch @@ -0,0 +1 @@ +a4813ef6708e6011e8187224297e83e4a285f58bf5eabb1db270351388603c95 diff --git a/tests/resources/testrepo_256.git/refs/heads/chomped b/tests/resources/testrepo_256.git/refs/heads/chomped new file mode 100644 index 00000000000..de0d95305df --- /dev/null +++ b/tests/resources/testrepo_256.git/refs/heads/chomped @@ -0,0 +1 @@ +4d46d9719e425ef2dfb5bfba098d0b62e21b2b92d0731892eef70db0870e3744 diff --git a/tests/resources/testrepo_256.git/refs/heads/haacked b/tests/resources/testrepo_256.git/refs/heads/haacked new file mode 100644 index 00000000000..5feda4d4178 --- /dev/null +++ b/tests/resources/testrepo_256.git/refs/heads/haacked @@ -0,0 +1 @@ +7e9424c06052ca33bfc599bccadee60065d8664a9af7648a1455100c4f772e1c diff --git a/tests/resources/testrepo_256.git/refs/heads/master b/tests/resources/testrepo_256.git/refs/heads/master new file mode 100644 index 00000000000..106231c4cfa --- /dev/null +++ b/tests/resources/testrepo_256.git/refs/heads/master @@ -0,0 +1 @@ +decaff3051968d1f3a2defd3d4a80ced03101555e1fd8913b3544026c0717d4f diff --git a/tests/resources/testrepo_256.git/refs/heads/not-good b/tests/resources/testrepo_256.git/refs/heads/not-good new file mode 100644 index 00000000000..106231c4cfa --- /dev/null +++ b/tests/resources/testrepo_256.git/refs/heads/not-good @@ -0,0 +1 @@ +decaff3051968d1f3a2defd3d4a80ced03101555e1fd8913b3544026c0717d4f diff --git a/tests/resources/testrepo_256.git/refs/heads/packed-test b/tests/resources/testrepo_256.git/refs/heads/packed-test new file mode 100644 index 00000000000..7c2c5e4383f --- /dev/null +++ b/tests/resources/testrepo_256.git/refs/heads/packed-test @@ -0,0 +1 @@ +43e084a4599ca42c476919917e3db8fde0045ee66305fd5e634b0c793c536a1b diff --git a/tests/resources/testrepo_256.git/refs/heads/subtrees b/tests/resources/testrepo_256.git/refs/heads/subtrees new file mode 100644 index 00000000000..3b352e1adff --- /dev/null +++ b/tests/resources/testrepo_256.git/refs/heads/subtrees @@ -0,0 +1 @@ +0118010feb81fe41b9df646d13866742a9070b56fd0ba9ab8dff828fc36c1f78 diff --git a/tests/resources/testrepo_256.git/refs/heads/test b/tests/resources/testrepo_256.git/refs/heads/test new file mode 100644 index 00000000000..de0d95305df --- /dev/null +++ b/tests/resources/testrepo_256.git/refs/heads/test @@ -0,0 +1 @@ +4d46d9719e425ef2dfb5bfba098d0b62e21b2b92d0731892eef70db0870e3744 diff --git a/tests/resources/testrepo_256.git/refs/heads/track-local b/tests/resources/testrepo_256.git/refs/heads/track-local new file mode 100644 index 00000000000..8f6ecbe2b82 --- /dev/null +++ b/tests/resources/testrepo_256.git/refs/heads/track-local @@ -0,0 +1 @@ +b83624f6ac0995273c0034a7ab8c68929bdc91b69ad54ef94979b93eba3f6022 diff --git a/tests/resources/testrepo_256.git/refs/heads/trailing b/tests/resources/testrepo_256.git/refs/heads/trailing new file mode 100644 index 00000000000..de0d95305df --- /dev/null +++ b/tests/resources/testrepo_256.git/refs/heads/trailing @@ -0,0 +1 @@ +4d46d9719e425ef2dfb5bfba098d0b62e21b2b92d0731892eef70db0870e3744 diff --git a/tests/resources/testrepo_256.git/refs/heads/with-empty-log b/tests/resources/testrepo_256.git/refs/heads/with-empty-log new file mode 100644 index 00000000000..bd392a7d2ae --- /dev/null +++ b/tests/resources/testrepo_256.git/refs/heads/with-empty-log @@ -0,0 +1 @@ +7e4633ae1b0e83503dbea4417f9d5ccaf22b877c5a4522b6d1d2b16090ee2f6f diff --git a/tests/resources/testrepo_256.git/refs/notes/fanout b/tests/resources/testrepo_256.git/refs/notes/fanout new file mode 100644 index 00000000000..307abb49c2a --- /dev/null +++ b/tests/resources/testrepo_256.git/refs/notes/fanout @@ -0,0 +1 @@ +cf84e5be57f8d5d51f136d3d137b654c602721c469c1b0a58e7e95647a9cf1c0 diff --git a/tests/resources/testrepo_256.git/refs/remotes/test/master b/tests/resources/testrepo_256.git/refs/remotes/test/master new file mode 100644 index 00000000000..ee4aa140b33 --- /dev/null +++ b/tests/resources/testrepo_256.git/refs/remotes/test/master @@ -0,0 +1 @@ +1b4b74772bd83ff28bf44cda9be93f4afc2279623bb5b36c9194a660b7623c24 diff --git a/tests/resources/testrepo_256.git/refs/tags/annotated_tag_to_blob b/tests/resources/testrepo_256.git/refs/tags/annotated_tag_to_blob new file mode 100644 index 00000000000..2723f8909fe --- /dev/null +++ b/tests/resources/testrepo_256.git/refs/tags/annotated_tag_to_blob @@ -0,0 +1 @@ +d88b60d2641df3656381dc8e201abb820a414de03eb63c065b06a2ab37d3f5ca diff --git a/tests/resources/testrepo_256.git/refs/tags/e90810b b/tests/resources/testrepo_256.git/refs/tags/e90810b new file mode 100644 index 00000000000..eb8846a05a5 --- /dev/null +++ b/tests/resources/testrepo_256.git/refs/tags/e90810b @@ -0,0 +1 @@ +21e1e1ebe45b2c1ef79ab050334e36a8015a546f0740bea4505e10d81a946f61 diff --git a/tests/resources/testrepo_256.git/refs/tags/hard_tag b/tests/resources/testrepo_256.git/refs/tags/hard_tag new file mode 100644 index 00000000000..05dfe06158e --- /dev/null +++ b/tests/resources/testrepo_256.git/refs/tags/hard_tag @@ -0,0 +1 @@ +34f79ad1c813b93d2ee11c830c2134815a31d9629e6aa9773338fedaab90976b diff --git a/tests/resources/testrepo_256.git/refs/tags/point_to_blob b/tests/resources/testrepo_256.git/refs/tags/point_to_blob new file mode 100644 index 00000000000..5efdc777d2c --- /dev/null +++ b/tests/resources/testrepo_256.git/refs/tags/point_to_blob @@ -0,0 +1 @@ +33e415b835a670bb5c3c760efa0433ac0cbd2d44679f68f2df3a9ae7014cf2a8 diff --git a/tests/resources/testrepo_256.git/refs/tags/taggerless b/tests/resources/testrepo_256.git/refs/tags/taggerless new file mode 100644 index 00000000000..45547b7fa0c --- /dev/null +++ b/tests/resources/testrepo_256.git/refs/tags/taggerless @@ -0,0 +1 @@ +14bd335f9d7188c778d44eba8801fe9bda46b66593291f5b9f7cd5f8888af12f diff --git a/tests/resources/testrepo_256.git/refs/tags/test b/tests/resources/testrepo_256.git/refs/tags/test new file mode 100644 index 00000000000..a7d2fef64c4 --- /dev/null +++ b/tests/resources/testrepo_256.git/refs/tags/test @@ -0,0 +1 @@ +c258f010a08328a29cde33411d955520e0375fcbbcc14b7636a70f7536c32ef6 diff --git a/tests/resources/testrepo_256.git/refs/tags/wrapped_tag b/tests/resources/testrepo_256.git/refs/tags/wrapped_tag new file mode 100644 index 00000000000..05dfe06158e --- /dev/null +++ b/tests/resources/testrepo_256.git/refs/tags/wrapped_tag @@ -0,0 +1 @@ +34f79ad1c813b93d2ee11c830c2134815a31d9629e6aa9773338fedaab90976b From e89e2e0102300af1faf0ab892e598a700692718a Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sun, 24 Jul 2022 13:33:58 -0400 Subject: [PATCH 121/608] odb: rename test file to avoid underscore In clar, an underscore is meaningful; avoid using it incorrectly / unnecessarily. --- tests/libgit2/odb/{packed_one.c => packedone.c} | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) rename tests/libgit2/odb/{packed_one.c => packedone.c} (87%) diff --git a/tests/libgit2/odb/packed_one.c b/tests/libgit2/odb/packedone.c similarity index 87% rename from tests/libgit2/odb/packed_one.c rename to tests/libgit2/odb/packedone.c index 7a1d3d913d6..9af27e8c7fd 100644 --- a/tests/libgit2/odb/packed_one.c +++ b/tests/libgit2/odb/packedone.c @@ -6,7 +6,7 @@ static git_odb *_odb; -void test_odb_packed_one__initialize(void) +void test_odb_packedone__initialize(void) { git_odb_backend *backend = NULL; @@ -15,13 +15,13 @@ void test_odb_packed_one__initialize(void) cl_git_pass(git_odb_add_backend(_odb, backend, 1)); } -void test_odb_packed_one__cleanup(void) +void test_odb_packedone__cleanup(void) { git_odb_free(_odb); _odb = NULL; } -void test_odb_packed_one__mass_read(void) +void test_odb_packedone__mass_read(void) { unsigned int i; @@ -37,7 +37,7 @@ void test_odb_packed_one__mass_read(void) } } -void test_odb_packed_one__read_header_0(void) +void test_odb_packedone__read_header_0(void) { unsigned int i; From 479c8c8c14f83491f31fb9b23388ae17070c9549 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 8 Jul 2022 17:17:09 -0400 Subject: [PATCH 122/608] packfile: handle sha256 packfiles Teach the packfile machinery to cope with SHA256. --- include/git2/odb_backend.h | 66 ++++++-- src/libgit2/commit_graph.c | 5 +- src/libgit2/indexer.c | 19 ++- src/libgit2/midx.c | 5 +- src/libgit2/mwindow.c | 7 +- src/libgit2/mwindow.h | 5 +- src/libgit2/odb.c | 15 +- src/libgit2/odb_pack.c | 120 +++++++++----- src/libgit2/pack.c | 156 ++++++++++-------- src/libgit2/pack.h | 44 +++-- tests/libgit2/odb/foreach.c | 11 +- tests/libgit2/odb/pack_data_one256.h | 21 +++ tests/libgit2/odb/packedone.c | 9 +- tests/libgit2/odb/packedone256.c | 78 +++++++++ tests/libgit2/odb/sorting.c | 6 +- ...76d752efc71661592db317474a0cf292915f31.idx | Bin 0 -> 1376 bytes ...6d752efc71661592db317474a0cf292915f31.pack | Bin 0 -> 1406 bytes 17 files changed, 412 insertions(+), 155 deletions(-) create mode 100644 tests/libgit2/odb/pack_data_one256.h create mode 100644 tests/libgit2/odb/packedone256.c create mode 100644 tests/resources/packfile-sha256/pack-b4a043c0ec5e079e8ac67d823776d752efc71661592db317474a0cf292915f31.idx create mode 100644 tests/resources/packfile-sha256/pack-b4a043c0ec5e079e8ac67d823776d752efc71661592db317474a0cf292915f31.pack diff --git a/include/git2/odb_backend.h b/include/git2/odb_backend.h index a31d1b78291..4d0559ec0e6 100644 --- a/include/git2/odb_backend.h +++ b/include/git2/odb_backend.h @@ -24,6 +24,26 @@ GIT_BEGIN_DECL * Constructors for in-box ODB backends. */ +/** Options for configuring a packfile object backend. */ +typedef struct { + unsigned int version; /**< version for the struct */ + + /** + * Type of object IDs to use for this object database, or + * 0 for default (currently SHA1). + */ + git_oid_t oid_type; +} git_odb_backend_pack_options; + +/* The current version of the diff options structure */ +#define GIT_ODB_BACKEND_PACK_OPTIONS_VERSION 1 + +/* Stack initializer for odb pack backend options. Alternatively use + * `git_odb_backend_pack_options_init` programmatic initialization. + */ +#define GIT_ODB_BACKEND_PACK_OPTIONS_INIT \ + { GIT_ODB_BACKEND_PACK_OPTIONS_VERSION } + /** * Create a backend for the packfiles. * @@ -32,7 +52,38 @@ GIT_BEGIN_DECL * * @return 0 or an error code */ -GIT_EXTERN(int) git_odb_backend_pack(git_odb_backend **out, const char *objects_dir); +#ifdef GIT_EXPERIMENTAL_SHA256 +GIT_EXTERN(int) git_odb_backend_pack( + git_odb_backend **out, + const char *objects_dir, + const git_odb_backend_pack_options *opts); +#else +GIT_EXTERN(int) git_odb_backend_pack( + git_odb_backend **out, + const char *objects_dir); +#endif + +/** + * Create a backend out of a single packfile + * + * This can be useful for inspecting the contents of a single + * packfile. + * + * @param out location to store the odb backend pointer + * @param index_file path to the packfile's .idx file + * + * @return 0 or an error code + */ +#ifdef GIT_EXPERIMENTAL_SHA256 +GIT_EXTERN(int) git_odb_backend_one_pack( + git_odb_backend **out, + const char *index_file, + const git_odb_backend_pack_options *opts); +#else +GIT_EXTERN(int) git_odb_backend_one_pack( + git_odb_backend **out, + const char *index_file); +#endif typedef enum { GIT_ODB_BACKEND_LOOSE_FSYNC = (1 << 0) @@ -100,19 +151,6 @@ GIT_EXTERN(int) git_odb_backend_loose( unsigned int file_mode); #endif -/** - * Create a backend out of a single packfile - * - * This can be useful for inspecting the contents of a single - * packfile. - * - * @param out location to store the odb backend pointer - * @param index_file path to the packfile's .idx file - * - * @return 0 or an error code - */ -GIT_EXTERN(int) git_odb_backend_one_pack(git_odb_backend **out, const char *index_file); - /** Streaming mode */ typedef enum { GIT_STREAM_RDONLY = (1 << 1), diff --git a/src/libgit2/commit_graph.c b/src/libgit2/commit_graph.c index 9554fe85551..bf557f7ad66 100644 --- a/src/libgit2/commit_graph.c +++ b/src/libgit2/commit_graph.c @@ -538,7 +538,7 @@ int git_commit_graph_entry_find( hi = ntohl(file->oid_fanout[(int)short_oid->id[0]]); lo = ((short_oid->id[0] == 0x0) ? 0 : ntohl(file->oid_fanout[(int)short_oid->id[0] - 1])); - pos = git_pack__lookup_sha1(file->oid_lookup, GIT_OID_SHA1_SIZE, lo, hi, short_oid->id); + pos = git_pack__lookup_id(file->oid_lookup, GIT_OID_SHA1_SIZE, lo, hi, short_oid->id, GIT_OID_SHA1); if (pos >= 0) { /* An object matching exactly the oid was found */ @@ -726,7 +726,8 @@ int git_commit_graph_writer_add_index_file( if (error < 0) goto cleanup; - error = git_mwindow_get_pack(&p, idx_path); + /* TODO: SHA256 */ + error = git_mwindow_get_pack(&p, idx_path, 0); if (error < 0) goto cleanup; diff --git a/src/libgit2/indexer.c b/src/libgit2/indexer.c index 62bb70393b8..98408646ae7 100644 --- a/src/libgit2/indexer.c +++ b/src/libgit2/indexer.c @@ -179,7 +179,8 @@ int git_indexer_new( if (fd < 0) goto cleanup; - error = git_packfile_alloc(&idx->pack, git_str_cstr(&tmp_path)); + /* TODO: SHA256 */ + error = git_packfile_alloc(&idx->pack, git_str_cstr(&tmp_path), 0); git_str_dispose(&tmp_path); if (error < 0) @@ -468,16 +469,16 @@ static int store_object(git_indexer *idx) goto on_error; } - git_oid_cpy(&pentry->sha1, &oid); + git_oid_cpy(&pentry->id, &oid); pentry->offset = entry_start; - if (git_oidmap_exists(idx->pack->idx_cache, &pentry->sha1)) { - git_error_set(GIT_ERROR_INDEXER, "duplicate object %s found in pack", git_oid_tostr_s(&pentry->sha1)); + if (git_oidmap_exists(idx->pack->idx_cache, &pentry->id)) { + git_error_set(GIT_ERROR_INDEXER, "duplicate object %s found in pack", git_oid_tostr_s(&pentry->id)); git__free(pentry); goto on_error; } - if ((error = git_oidmap_set(idx->pack->idx_cache, &pentry->sha1, pentry)) < 0) { + if ((error = git_oidmap_set(idx->pack->idx_cache, &pentry->id, pentry)) < 0) { git__free(pentry); git_error_set_oom(); goto on_error; @@ -522,8 +523,8 @@ static int save_entry(git_indexer *idx, struct entry *entry, struct git_pack_ent pentry->offset = entry_start; - if (git_oidmap_exists(idx->pack->idx_cache, &pentry->sha1) || - git_oidmap_set(idx->pack->idx_cache, &pentry->sha1, pentry) < 0) { + if (git_oidmap_exists(idx->pack->idx_cache, &pentry->id) || + git_oidmap_set(idx->pack->idx_cache, &pentry->id, pentry) < 0) { git_error_set(GIT_ERROR_INDEXER, "cannot insert object into pack"); return -1; } @@ -557,7 +558,7 @@ static int hash_and_save(git_indexer *idx, git_rawobj *obj, off64_t entry_start) pentry = git__calloc(1, sizeof(struct git_pack_entry)); GIT_ERROR_CHECK_ALLOC(pentry); - git_oid_cpy(&pentry->sha1, &oid); + git_oid_cpy(&pentry->id, &oid); git_oid_cpy(&entry->oid, &oid); entry->crc = crc32(0L, Z_NULL, 0); @@ -987,7 +988,7 @@ static int inject_object(git_indexer *idx, git_oid *id) pentry = git__calloc(1, sizeof(struct git_pack_entry)); GIT_ERROR_CHECK_ALLOC(pentry); - git_oid_cpy(&pentry->sha1, id); + git_oid_cpy(&pentry->id, id); git_oid_cpy(&entry->oid, id); idx->off = entry_start + hdr_len + len; diff --git a/src/libgit2/midx.c b/src/libgit2/midx.c index 51b2d6cc7ae..b0905523713 100644 --- a/src/libgit2/midx.c +++ b/src/libgit2/midx.c @@ -392,7 +392,7 @@ int git_midx_entry_find( hi = ntohl(idx->oid_fanout[(int)short_oid->id[0]]); lo = ((short_oid->id[0] == 0x0) ? 0 : ntohl(idx->oid_fanout[(int)short_oid->id[0] - 1])); - pos = git_pack__lookup_sha1(idx->oid_lookup, GIT_OID_SHA1_SIZE, lo, hi, short_oid->id); + pos = git_pack__lookup_id(idx->oid_lookup, GIT_OID_SHA1_SIZE, lo, hi, short_oid->id, GIT_OID_SHA1); if (pos >= 0) { /* An object matching exactly the oid was found */ @@ -549,7 +549,8 @@ int git_midx_writer_add( if (error < 0) return error; - error = git_mwindow_get_pack(&p, git_str_cstr(&idx_path_buf)); + /* TODO: SHA256 */ + error = git_mwindow_get_pack(&p, git_str_cstr(&idx_path_buf), 0); git_str_dispose(&idx_path_buf); if (error < 0) return error; diff --git a/src/libgit2/mwindow.c b/src/libgit2/mwindow.c index ad649490ad4..b8295d9d119 100644 --- a/src/libgit2/mwindow.c +++ b/src/libgit2/mwindow.c @@ -61,7 +61,10 @@ int git_mwindow_global_init(void) return git_runtime_shutdown_register(git_mwindow_global_shutdown); } -int git_mwindow_get_pack(struct git_pack_file **out, const char *path) +int git_mwindow_get_pack( + struct git_pack_file **out, + const char *path, + git_oid_t oid_type) { struct git_pack_file *pack; char *packname; @@ -86,7 +89,7 @@ int git_mwindow_get_pack(struct git_pack_file **out, const char *path) } /* If we didn't find it, we need to create it */ - if ((error = git_packfile_alloc(&pack, path)) < 0) { + if ((error = git_packfile_alloc(&pack, path, oid_type)) < 0) { git_mutex_unlock(&git__mwindow_mutex); return error; } diff --git a/src/libgit2/mwindow.h b/src/libgit2/mwindow.h index e32ab99d4e9..8e6df2613b7 100644 --- a/src/libgit2/mwindow.h +++ b/src/libgit2/mwindow.h @@ -48,7 +48,10 @@ void git_mwindow_close(git_mwindow **w_cursor); extern int git_mwindow_global_init(void); struct git_pack_file; /* just declaration to avoid cyclical includes */ -int git_mwindow_get_pack(struct git_pack_file **out, const char *path); +int git_mwindow_get_pack( + struct git_pack_file **out, + const char *path, + git_oid_t oid_type); int git_mwindow_put_pack(struct git_pack_file *pack); #endif diff --git a/src/libgit2/odb.c b/src/libgit2/odb.c index aa2dd3cb27a..edf4f001f11 100644 --- a/src/libgit2/odb.c +++ b/src/libgit2/odb.c @@ -684,6 +684,7 @@ int git_odb__add_default_backends( ino_t inode; git_odb_backend *loose, *packed; git_odb_backend_loose_options loose_opts = GIT_ODB_BACKEND_LOOSE_OPTIONS_INIT; + git_odb_backend_pack_options pack_opts = GIT_ODB_BACKEND_PACK_OPTIONS_INIT; /* TODO: inodes are not really relevant on Win32, so we need to find * a cross-platform workaround for this */ @@ -722,6 +723,7 @@ int git_odb__add_default_backends( loose_opts.flags |= GIT_ODB_BACKEND_LOOSE_FSYNC; loose_opts.oid_type = db->options.oid_type; + pack_opts.oid_type = db->options.oid_type; /* add the loose object backend */ if (git_odb__backend_loose(&loose, objects_dir, &loose_opts) < 0 || @@ -729,8 +731,17 @@ int git_odb__add_default_backends( return -1; /* add the packed file backend */ - if (git_odb_backend_pack(&packed, objects_dir) < 0 || - add_backend_internal(db, packed, git_odb__packed_priority, as_alternates, inode) < 0) +#ifdef GIT_EXPERIMENTAL_SHA256 + if (git_odb_backend_pack(&packed, objects_dir, &pack_opts) < 0) + return -1; +#else + GIT_UNUSED(pack_opts); + + if (git_odb_backend_pack(&packed, objects_dir) < 0) + return -1; +#endif + + if (add_backend_internal(db, packed, git_odb__packed_priority, as_alternates, inode) < 0) return -1; if (git_mutex_lock(&db->lock) < 0) { diff --git a/src/libgit2/odb_pack.c b/src/libgit2/odb_pack.c index 49a655b4484..814c0bc7550 100644 --- a/src/libgit2/odb_pack.c +++ b/src/libgit2/odb_pack.c @@ -26,6 +26,7 @@ struct pack_backend { git_odb_backend parent; + git_odb_backend_pack_options opts; git_midx_file *midx; git_vector midx_packs; git_vector packs; @@ -95,24 +96,24 @@ struct pack_writepack { * -------------------------------------------------- * * # pack_backend__exists / pack_backend__exists_prefix - * | Check if the given SHA1 oid (or a SHA1 oid prefix) exists in any of the + * | Check if the given oid (or an oid prefix) exists in any of the * | packs that have been loaded for our ODB. * | * |-# pack_entry_find / pack_entry_find_prefix - * | If there is a multi-pack-index present, search the SHA1 oid in that + * | If there is a multi-pack-index present, search the oid in that * | index first. If it is not found there, iterate through all the unindexed * | packs that have been preloaded (starting by the pack where the latest * | object was found) to try to find the OID in one of them. * | * |-# git_midx_entry_find - * | Search for the SHA1 oid in the multi-pack-index. See + * | Search for the oid in the multi-pack-index. See * | * | for specifics on the multi-pack-index format and how do we find * | entries in it. * | * |-# git_pack_entry_find - * | Check the index of an individual unindexed pack to see if the SHA1 - * | OID can be found. If we can find the offset to that SHA1 inside of the + * | Check the index of an individual unindexed pack to see if the + * | OID can be found. If we can find the offset to that inside of the * | index, that means the object is contained inside of the packfile and * | we can stop searching. Before returning, we verify that the * | packfile behind the index we are searching still exists on disk. @@ -141,13 +142,13 @@ struct pack_writepack { * -------------------------------------------------- * * # pack_backend__read / pack_backend__read_prefix - * | Check if the given SHA1 oid (or a SHA1 oid prefix) exists in any of the + * | Check if the given oid (or an oid prefix) exists in any of the * | packs that have been loaded for our ODB. If it does, open the packfile and * | read from it. * | * |-# git_packfile_unpack * Armed with a packfile and the offset within it, we can finally unpack - * the object pointed at by the SHA1 oid. This involves mmapping part of + * the object pointed at by the oid. This involves mmapping part of * the `.pack` file, and uncompressing the object within it (if it is * stored in the undelfitied representation), or finding a base object and * applying some deltas to its uncompressed representation (if it is stored @@ -177,7 +178,7 @@ static int pack_entry_find(struct git_pack_entry *e, * a prefix of an identifier. * Sets GIT_EAMBIGUOUS if short oid is ambiguous. * This method assumes that len is between - * GIT_OID_MINPREFIXLEN and GIT_OID_SHA1_HEXSIZE. + * GIT_OID_MINPREFIXLEN and the hexsize for the hash type. */ static int pack_entry_find_prefix( struct git_pack_entry *e, @@ -251,7 +252,7 @@ static int packfile_load__cb(void *data, git_str *path) if (git_vector_search2(NULL, &backend->packs, packfile_byname_search_cmp, &index_prefix) == 0) return 0; - error = git_mwindow_get_pack(&pack, path->ptr); + error = git_mwindow_get_pack(&pack, path->ptr, backend->opts.oid_type); /* ignore missing .pack file as git does */ if (error == GIT_ENOTFOUND) { @@ -270,33 +271,34 @@ static int pack_entry_find(struct git_pack_entry *e, struct pack_backend *backen { struct git_pack_file *last_found = backend->last_found, *p; git_midx_entry midx_entry; + size_t oid_hexsize = git_oid_hexsize(backend->opts.oid_type); size_t i; if (backend->midx && - git_midx_entry_find(&midx_entry, backend->midx, oid, GIT_OID_SHA1_HEXSIZE) == 0 && + git_midx_entry_find(&midx_entry, backend->midx, oid, oid_hexsize) == 0 && midx_entry.pack_index < git_vector_length(&backend->midx_packs)) { e->offset = midx_entry.offset; - git_oid_cpy(&e->sha1, &midx_entry.sha1); + git_oid_cpy(&e->id, &midx_entry.sha1); e->p = git_vector_get(&backend->midx_packs, midx_entry.pack_index); return 0; } if (last_found && - git_pack_entry_find(e, last_found, oid, GIT_OID_SHA1_HEXSIZE) == 0) + git_pack_entry_find(e, last_found, oid, oid_hexsize) == 0) return 0; git_vector_foreach(&backend->packs, i, p) { if (p == last_found) continue; - if (git_pack_entry_find(e, p, oid, GIT_OID_SHA1_HEXSIZE) == 0) { + if (git_pack_entry_find(e, p, oid, oid_hexsize) == 0) { backend->last_found = p; return 0; } } return git_odb__error_notfound( - "failed to find pack entry", oid, GIT_OID_SHA1_HEXSIZE); + "failed to find pack entry", oid, oid_hexsize); } static int pack_entry_find_prefix( @@ -318,9 +320,9 @@ static int pack_entry_find_prefix( return error; if (!error && midx_entry.pack_index < git_vector_length(&backend->midx_packs)) { e->offset = midx_entry.offset; - git_oid_cpy(&e->sha1, &midx_entry.sha1); + git_oid_cpy(&e->id, &midx_entry.sha1); e->p = git_vector_get(&backend->midx_packs, midx_entry.pack_index); - git_oid_cpy(&found_full_oid, &e->sha1); + git_oid_cpy(&found_full_oid, &e->id); found = true; } } @@ -330,9 +332,9 @@ static int pack_entry_find_prefix( if (error == GIT_EAMBIGUOUS) return error; if (!error) { - if (found && git_oid_cmp(&e->sha1, &found_full_oid)) + if (found && git_oid_cmp(&e->id, &found_full_oid)) return git_odb__error_ambiguous("found multiple pack entries"); - git_oid_cpy(&found_full_oid, &e->sha1); + git_oid_cpy(&found_full_oid, &e->id); found = true; } } @@ -345,9 +347,9 @@ static int pack_entry_find_prefix( if (error == GIT_EAMBIGUOUS) return error; if (!error) { - if (found && git_oid_cmp(&e->sha1, &found_full_oid)) + if (found && git_oid_cmp(&e->id, &found_full_oid)) return git_odb__error_ambiguous("found multiple pack entries"); - git_oid_cpy(&found_full_oid, &e->sha1); + git_oid_cpy(&found_full_oid, &e->id); found = true; backend->last_found = p; } @@ -425,7 +427,10 @@ static int process_multi_pack_index_pack( } /* Pack was not found. Allocate a new one. */ - error = git_mwindow_get_pack(&pack, git_str_cstr(&pack_path)); + error = git_mwindow_get_pack( + &pack, + git_str_cstr(&pack_path), + backend->opts.oid_type); git_str_dispose(&pack_path); if (error < 0) return error; @@ -596,32 +601,33 @@ static int pack_backend__read_prefix( void **buffer_p, size_t *len_p, git_object_t *type_p, - git_odb_backend *backend, + git_odb_backend *_backend, const git_oid *short_oid, size_t len) { + struct pack_backend *backend = (struct pack_backend *)_backend; int error = 0; if (len < GIT_OID_MINPREFIXLEN) error = git_odb__error_ambiguous("prefix length too short"); - else if (len >= GIT_OID_SHA1_HEXSIZE) { + else if (len >= git_oid_hexsize(backend->opts.oid_type)) { /* We can fall back to regular read method */ - error = pack_backend__read(buffer_p, len_p, type_p, backend, short_oid); + error = pack_backend__read(buffer_p, len_p, type_p, _backend, short_oid); if (!error) git_oid_cpy(out_oid, short_oid); } else { struct git_pack_entry e; git_rawobj raw = {NULL}; - if ((error = pack_entry_find_prefix( - &e, (struct pack_backend *)backend, short_oid, len)) == 0 && - (error = git_packfile_unpack(&raw, e.p, &e.offset)) == 0) + if ((error = pack_entry_find_prefix(&e, + backend, short_oid, len)) == 0 && + (error = git_packfile_unpack(&raw, e.p, &e.offset)) == 0) { *buffer_p = raw.data; *len_p = raw.len; *type_p = raw.type; - git_oid_cpy(out_oid, &e.sha1); + git_oid_cpy(out_oid, &e.id); } } @@ -642,7 +648,7 @@ static int pack_backend__exists_prefix( struct git_pack_entry e = {0}; error = pack_entry_find_prefix(&e, pb, short_id, len); - git_oid_cpy(out, &e.sha1); + git_oid_cpy(out, &e.id); return error; } @@ -840,7 +846,10 @@ static void pack_backend__free(git_odb_backend *_backend) git__free(backend); } -static int pack_backend__alloc(struct pack_backend **out, size_t initial_size) +static int pack_backend__alloc( + struct pack_backend **out, + size_t initial_size, + const git_odb_backend_pack_options *opts) { struct pack_backend *backend = git__calloc(1, sizeof(struct pack_backend)); GIT_ERROR_CHECK_ALLOC(backend); @@ -849,12 +858,19 @@ static int pack_backend__alloc(struct pack_backend **out, size_t initial_size) git__free(backend); return -1; } + if (git_vector_init(&backend->packs, initial_size, packfile_sort__cb) < 0) { git_vector_free(&backend->midx_packs); git__free(backend); return -1; } + if (opts) + memcpy(&backend->opts, opts, sizeof(git_odb_backend_pack_options)); + + if (!backend->opts.oid_type) + backend->opts.oid_type = GIT_OID_DEFAULT; + backend->parent.version = GIT_ODB_BACKEND_VERSION; backend->parent.read = &pack_backend__read; @@ -873,17 +889,31 @@ static int pack_backend__alloc(struct pack_backend **out, size_t initial_size) return 0; } -int git_odb_backend_one_pack(git_odb_backend **backend_out, const char *idx) +#ifdef GIT_EXPERIMENTAL_SHA256 +int git_odb_backend_one_pack( + git_odb_backend **backend_out, + const char *idx, + const git_odb_backend_pack_options *opts) +#else +int git_odb_backend_one_pack( + git_odb_backend **backend_out, + const char *idx) +#endif { struct pack_backend *backend = NULL; struct git_pack_file *packfile = NULL; - if (pack_backend__alloc(&backend, 1) < 0) +#ifndef GIT_EXPERIMENTAL_SHA256 + git_odb_backend_pack_options *opts = NULL; +#endif + + git_oid_t oid_type = opts ? opts->oid_type : 0; + + if (pack_backend__alloc(&backend, 1, opts) < 0) return -1; - if (git_mwindow_get_pack(&packfile, idx) < 0 || - git_vector_insert(&backend->packs, packfile) < 0) - { + if (git_mwindow_get_pack(&packfile, idx, oid_type) < 0 || + git_vector_insert(&backend->packs, packfile) < 0) { pack_backend__free((git_odb_backend *)backend); return -1; } @@ -892,18 +922,30 @@ int git_odb_backend_one_pack(git_odb_backend **backend_out, const char *idx) return 0; } -int git_odb_backend_pack(git_odb_backend **backend_out, const char *objects_dir) +#ifdef GIT_EXPERIMENTAL_SHA256 +int git_odb_backend_pack( + git_odb_backend **backend_out, + const char *objects_dir, + const git_odb_backend_pack_options *opts) +#else +int git_odb_backend_pack( + git_odb_backend **backend_out, + const char *objects_dir) +#endif { int error = 0; struct pack_backend *backend = NULL; git_str path = GIT_STR_INIT; - if (pack_backend__alloc(&backend, 8) < 0) +#ifndef GIT_EXPERIMENTAL_SHA256 + git_odb_backend_pack_options *opts = NULL; +#endif + + if (pack_backend__alloc(&backend, 8, opts) < 0) return -1; if (!(error = git_str_joinpath(&path, objects_dir, "pack")) && - git_fs_path_isdir(git_str_cstr(&path))) - { + git_fs_path_isdir(git_str_cstr(&path))) { backend->pack_folder = git_str_detach(&path); error = pack_backend__refresh((git_odb_backend *)backend); } diff --git a/src/libgit2/pack.c b/src/libgit2/pack.c index d428729eae1..c3080184449 100644 --- a/src/libgit2/pack.c +++ b/src/libgit2/pack.c @@ -32,7 +32,7 @@ static int packfile_unpack_compressed( * Throws GIT_EAMBIGUOUSOIDPREFIX if short oid * is ambiguous within the pack. * This method assumes that len is between - * GIT_OID_MINPREFIXLEN and GIT_OID_SHA1_HEXSIZE. + * GIT_OID_MINPREFIXLEN and the oid type's hexsize. */ static int pack_entry_find_offset( off64_t *offset_out, @@ -186,9 +186,9 @@ static int cache_add( static void pack_index_free(struct git_pack_file *p) { - if (p->oids) { - git__free(p->oids); - p->oids = NULL; + if (p->ids) { + git__free(p->ids); + p->ids = NULL; } if (p->index_map.data) { git_futils_mmap_free(&p->index_map); @@ -205,6 +205,7 @@ static int pack_index_check_locked(const char *path, struct git_pack_file *p) size_t idx_size; struct stat st; int error; + /* TODO: properly open the file without access time using O_NOATIME */ git_file fd = git_futils_open_ro(path); if (fd < 0) @@ -218,8 +219,7 @@ static int pack_index_check_locked(const char *path, struct git_pack_file *p) if (!S_ISREG(st.st_mode) || !git__is_sizet(st.st_size) || - (idx_size = (size_t)st.st_size) < 4 * 256 + 20 + 20) - { + (idx_size = (size_t)st.st_size) < (size_t)((4 * 256) + (p->oid_size * 2))) { p_close(fd); git_error_set(GIT_ERROR_ODB, "invalid pack index '%s'", path); return -1; @@ -242,8 +242,9 @@ static int pack_index_check_locked(const char *path, struct git_pack_file *p) return packfile_error("unsupported index version"); } - } else + } else { version = 1; + } nr = 0; index = idx_map; @@ -264,11 +265,11 @@ static int pack_index_check_locked(const char *path, struct git_pack_file *p) /* * Total size: * - 256 index entries 4 bytes each - * - 24-byte entries * nr (20-byte sha1 + 4-byte offset) - * - 20-byte SHA1 of the packfile - * - 20-byte SHA1 file checksum + * - 24/36-byte entries * nr (20/32 byte SHA + 4-byte offset) + * - 20/32-byte SHA of the packfile + * - 20/32-byte SHA file checksum */ - if (idx_size != 4*256 + nr * 24 + 20 + 20) { + if (idx_size != (4 * 256 + (nr * (p->oid_size + 4)) + (p->oid_size * 2))) { git_futils_mmap_free(&p->index_map); return packfile_error("index is corrupted"); } @@ -277,16 +278,16 @@ static int pack_index_check_locked(const char *path, struct git_pack_file *p) * Minimum size: * - 8 bytes of header * - 256 index entries 4 bytes each - * - 20-byte sha1 entry * nr + * - 20/32-byte SHA entry * nr * - 4-byte crc entry * nr * - 4-byte offset entry * nr - * - 20-byte SHA1 of the packfile - * - 20-byte SHA1 file checksum + * - 20/32-byte SHA of the packfile + * - 20/32-byte SHA file checksum * And after the 4-byte offset table might be a * variable sized table containing 8-byte entries * for offsets larger than 2^31. */ - unsigned long min_size = 8 + 4*256 + nr*(20 + 4 + 4) + 20 + 20; + unsigned long min_size = 8 + (4 * 256) + (nr * (p->oid_size + 4 + 4)) + (p->oid_size * 2); unsigned long max_size = min_size; if (nr) @@ -365,12 +366,12 @@ static unsigned char *pack_window_open( * Don't allow a negative offset, as that means we've wrapped * around. */ - if (offset > (p->mwf.size - 20)) + if (offset > (p->mwf.size - p->oid_size)) goto cleanup; if (offset < 0) goto cleanup; - pack_data = git_mwindow_open(&p->mwf, w_cursor, offset, 20, left); + pack_data = git_mwindow_open(&p->mwf, w_cursor, offset, p->oid_size, left); cleanup: git_mutex_unlock(&p->mwf.lock); @@ -473,13 +474,13 @@ int git_packfile_unpack_header( return error; } - /* pack_window_open() assures us we have [base, base + 20) available - * as a range that we can look at at. (Its actually the hash - * size that is assured.) With our object header encoding - * the maximum deflated object size is 2^137, which is just - * insane, so we know won't exceed what we have been given. + /* pack_window_open() assures us we have [base, base + oid_size) + * available as a range that we can look at at. (It's actually + * the hash size that is assured.) With our object header + * encoding the maximum deflated object size is 2^137, which is + * just insane, so we know won't exceed what we have been given. */ - base = git_mwindow_open(&p->mwf, w_curs, *curpos, 20, &left); + base = git_mwindow_open(&p->mwf, w_curs, *curpos, p->oid_size, &left); git_mutex_unlock(&p->lock); git_mutex_unlock(&p->mwf.lock); if (base == NULL) @@ -977,11 +978,12 @@ int get_delta_base( /* Assumption: the only reason this would fail is because the file is too small */ if (base_info == NULL) return GIT_EBUFS; - /* pack_window_open() assured us we have [base_info, base_info + 20) - * as a range that we can look at without walking off the - * end of the mapped window. Its actually the hash size - * that is assured. An OFS_DELTA longer than the hash size - * is stupid, as then a REF_DELTA would be smaller to store. + /* pack_window_open() assured us we have + * [base_info, base_info + oid_size) as a range that we can look + * at without walking off the end of the mapped window. Its + * actually the hash size that is assured. An OFS_DELTA longer + * than the hash size is stupid, as then a REF_DELTA would be + * smaller to store. */ if (type == GIT_OBJECT_OFS_DELTA) { unsigned used = 0; @@ -1002,7 +1004,7 @@ int get_delta_base( *curpos += used; } else if (type == GIT_OBJECT_REF_DELTA) { git_oid base_oid; - git_oid__fromraw(&base_oid, base_info, GIT_OID_SHA1); + git_oid__fromraw(&base_oid, base_info, p->oid_type); /* If we have the cooperative cache, search in it first */ if (p->has_cache) { @@ -1012,7 +1014,7 @@ int get_delta_base( if (entry->offset == 0) return packfile_error("delta offset is zero"); - *curpos += 20; + *curpos += p->oid_size; *delta_base_out = entry->offset; return 0; } else { @@ -1025,9 +1027,9 @@ int get_delta_base( } /* The base entry _must_ be in the same pack */ - if (pack_entry_find_offset(&base_offset, &unused, p, &base_oid, GIT_OID_SHA1_HEXSIZE) < 0) + if (pack_entry_find_offset(&base_offset, &unused, p, &base_oid, p->oid_hexsize) < 0) return packfile_error("base entry delta is not in the same pack"); - *curpos += 20; + *curpos += p->oid_size; } else return packfile_error("unknown object type"); @@ -1070,7 +1072,7 @@ void git_packfile_free(struct git_pack_file *p, bool unlink_packfile) pack_index_free(p); - git__free(p->bad_object_sha1); + git__free(p->bad_object_ids); git_mutex_free(&p->bases.lock); git_mutex_free(&p->mwf.lock); @@ -1083,8 +1085,8 @@ static int packfile_open_locked(struct git_pack_file *p) { struct stat st; struct git_pack_header hdr; - unsigned char sha1[GIT_OID_SHA1_SIZE]; - unsigned char *idx_sha1; + unsigned char checksum[GIT_OID_MAX_SIZE]; + unsigned char *idx_checksum; if (pack_index_open_locked(p) < 0) return git_odb__error_notfound("failed to open packfile", NULL, 0); @@ -1131,12 +1133,13 @@ static int packfile_open_locked(struct git_pack_file *p) /* Verify the pack matches its index. */ if (p->num_objects != ntohl(hdr.hdr_entries) || - p_pread(p->mwf.fd, sha1, GIT_OID_SHA1_SIZE, p->mwf.size - GIT_OID_SHA1_SIZE) < 0) + p_pread(p->mwf.fd, checksum, p->oid_size, p->mwf.size - p->oid_size) < 0) goto cleanup; - idx_sha1 = ((unsigned char *)p->index_map.data) + p->index_map.len - 40; + idx_checksum = ((unsigned char *)p->index_map.data) + + p->index_map.len - (p->oid_size * 2); - if (git_oid_raw_cmp(sha1, idx_sha1, GIT_OID_SHA1_SIZE) != 0) + if (git_oid_raw_cmp(checksum, idx_checksum, p->oid_size) != 0) goto cleanup; if (git_mwindow_file_register(&p->mwf) < 0) @@ -1171,7 +1174,10 @@ int git_packfile__name(char **out, const char *path) return 0; } -int git_packfile_alloc(struct git_pack_file **pack_out, const char *path) +int git_packfile_alloc( + struct git_pack_file **pack_out, + const char *path, + git_oid_t oid_type) { struct stat st; struct git_pack_file *p; @@ -1219,6 +1225,9 @@ int git_packfile_alloc(struct git_pack_file **pack_out, const char *path) p->pack_local = 1; p->mtime = (git_time_t)st.st_mtime; p->index_version = -1; + p->oid_type = oid_type ? oid_type : GIT_OID_DEFAULT; + p->oid_size = (unsigned int)git_oid_size(p->oid_type); + p->oid_hexsize = (unsigned int)git_oid_hexsize(p->oid_type); if (git_mutex_init(&p->lock) < 0) { git_error_set(GIT_ERROR_OS, "failed to initialize packfile mutex"); @@ -1260,9 +1269,9 @@ static off64_t nth_packed_object_offset_locked(struct git_pack_file *p, uint32_t end = index + p->index_map.len; index += 4 * 256; if (p->index_version == 1) - return ntohl(*((uint32_t *)(index + 24 * n))); + return ntohl(*((uint32_t *)(index + (p->oid_size + 4) * n))); - index += 8 + p->num_objects * (20 + 4); + index += 8 + p->num_objects * (p->oid_size + 4); off32 = ntohl(*((uint32_t *)(index + 4 * n))); if (!(off32 & 0x80000000)) return off32; @@ -1273,7 +1282,7 @@ static off64_t nth_packed_object_offset_locked(struct git_pack_file *p, uint32_t return -1; return (((uint64_t)ntohl(*((uint32_t *)(index + 0)))) << 32) | - ntohl(*((uint32_t *)(index + 4))); + ntohl(*((uint32_t *)(index + 4))); } static int git__memcmp4(const void *a, const void *b) { @@ -1312,7 +1321,7 @@ int git_pack_foreach_entry( index += 4 * 256; - if (p->oids == NULL) { + if (p->ids == NULL) { git_vector offsets, oids; if ((error = git_vector_init(&oids, p->num_objects, NULL))) { @@ -1326,22 +1335,25 @@ int git_pack_foreach_entry( } if (p->index_version > 1) { - const unsigned char *off = index + 24 * p->num_objects; + const unsigned char *off = index + + (p->oid_size + 4) * p->num_objects; + for (i = 0; i < p->num_objects; i++) git_vector_insert(&offsets, (void*)&off[4 * i]); + git_vector_sort(&offsets); git_vector_foreach(&offsets, i, current) git_vector_insert(&oids, (void*)&index[5 * (current - off)]); } else { for (i = 0; i < p->num_objects; i++) - git_vector_insert(&offsets, (void*)&index[24 * i]); + git_vector_insert(&offsets, (void*)&index[(p->oid_size + 4) * i]); git_vector_sort(&offsets); git_vector_foreach(&offsets, i, current) git_vector_insert(&oids, (void*)¤t[4]); } git_vector_free(&offsets); - p->oids = (unsigned char **)git_vector_detach(NULL, NULL, &oids); + p->ids = (unsigned char **)git_vector_detach(NULL, NULL, &oids); } /* @@ -1362,7 +1374,7 @@ int git_pack_foreach_entry( git_array_clear(oids); GIT_ERROR_CHECK_ALLOC(oid); } - git_oid__fromraw(oid, p->oids[i], GIT_OID_SHA1); + git_oid__fromraw(oid, p->ids[i], p->oid_type); } git_mutex_unlock(&p->lock); @@ -1412,10 +1424,13 @@ int git_pack_foreach_entry_offset( /* all offsets should have been validated by pack_index_check_locked */ if (p->index_version > 1) { - const unsigned char *offsets = index + 24 * p->num_objects; + const unsigned char *offsets = index + + (p->oid_size + 4) * p->num_objects; const unsigned char *large_offset_ptr; - const unsigned char *large_offsets = index + 28 * p->num_objects; - const unsigned char *large_offsets_end = ((const unsigned char *)p->index_map.data) + p->index_map.len - 20; + const unsigned char *large_offsets = index + + (p->oid_size + 8) * p->num_objects; + const unsigned char *large_offsets_end = ((const unsigned char *)p->index_map.data) + p->index_map.len - p->oid_size; + for (i = 0; i < p->num_objects; i++) { current_offset = ntohl(*(const uint32_t *)(offsets + 4 * i)); if (current_offset & 0x80000000) { @@ -1428,7 +1443,7 @@ int git_pack_foreach_entry_offset( ntohl(*((uint32_t *)(large_offset_ptr + 4))); } - git_oid__fromraw(¤t_oid, (index + 20 * i), GIT_OID_SHA1); + git_oid__fromraw(¤t_oid, (index + p->oid_size * i), p->oid_type); if ((error = cb(¤t_oid, current_offset, data)) != 0) { error = git_error_set_after_callback(error); goto cleanup; @@ -1436,8 +1451,8 @@ int git_pack_foreach_entry_offset( } } else { for (i = 0; i < p->num_objects; i++) { - current_offset = ntohl(*(const uint32_t *)(index + 24 * i)); - git_oid__fromraw(¤t_oid, (index + 24 * i + 4), GIT_OID_SHA1); + current_offset = ntohl(*(const uint32_t *)(index + (p->oid_size + 4) * i)); + git_oid__fromraw(¤t_oid, (index + (p->oid_size + 4) * i + 4), p->oid_type); if ((error = cb(¤t_oid, current_offset, data)) != 0) { error = git_error_set_after_callback(error); goto cleanup; @@ -1450,14 +1465,20 @@ int git_pack_foreach_entry_offset( return error; } -int git_pack__lookup_sha1(const void *oid_lookup_table, size_t stride, unsigned lo, - unsigned hi, const unsigned char *oid_prefix) +int git_pack__lookup_id( + const void *oid_lookup_table, + size_t stride, + unsigned lo, + unsigned hi, + const unsigned char *oid_prefix, + const git_oid_t oid_type) { const unsigned char *base = oid_lookup_table; + size_t oid_size = git_oid_size(oid_type); while (lo < hi) { unsigned mi = (lo + hi) / 2; - int cmp = git_oid_raw_cmp(base + mi * stride, oid_prefix, GIT_OID_SHA1_SIZE); + int cmp = git_oid_raw_cmp(base + mi * stride, oid_prefix, oid_size); if (!cmp) return mi; @@ -1512,9 +1533,9 @@ static int pack_entry_find_offset( lo = ((short_oid->id[0] == 0x0) ? 0 : ntohl(level1_ofs[(int)short_oid->id[0] - 1])); if (p->index_version > 1) { - stride = 20; + stride = p->oid_size; } else { - stride = 24; + stride = p->oid_size + 4; index += 4; } @@ -1523,7 +1544,8 @@ static int pack_entry_find_offset( short_oid->id[0], short_oid->id[1], short_oid->id[2], lo, hi, p->num_objects); #endif - pos = git_pack__lookup_sha1(index, stride, lo, hi, short_oid->id); + pos = git_pack__lookup_id(index, stride, lo, hi, + short_oid->id, p->oid_type); if (pos >= 0) { /* An object matching exactly the oid was found */ @@ -1541,7 +1563,9 @@ static int pack_entry_find_offset( } } - if (found && len != GIT_OID_SHA1_HEXSIZE && pos + 1 < (int)p->num_objects) { + if (found && + len != p->oid_hexsize && + pos + 1 < (int)p->num_objects) { /* Check for ambiguousity */ const unsigned char *next = current + stride; @@ -1566,13 +1590,13 @@ static int pack_entry_find_offset( } *offset_out = offset; - git_oid__fromraw(found_oid, current, GIT_OID_SHA1); + git_oid__fromraw(found_oid, current, p->oid_type); #ifdef INDEX_DEBUG_LOOKUP { - unsigned char hex_sha1[GIT_OID_SHA1_HEXSIZE + 1]; + char hex_sha1[p->oid_hexsize + 1]; git_oid_fmt(hex_sha1, found_oid); - hex_sha1[GIT_OID_SHA1_HEXSIZE] = '\0'; + hex_sha1[p->oid_hexsize] = '\0'; printf("found lo=%d %s\n", lo, hex_sha1); } #endif @@ -1594,10 +1618,10 @@ int git_pack_entry_find( GIT_ASSERT_ARG(p); - if (len == GIT_OID_SHA1_HEXSIZE && p->num_bad_objects) { + if (len == p->oid_hexsize && p->num_bad_objects) { unsigned i; for (i = 0; i < p->num_bad_objects; i++) - if (git_oid__cmp(short_oid, &p->bad_object_sha1[i]) == 0) + if (git_oid__cmp(short_oid, &p->bad_object_ids[i]) == 0) return packfile_error("bad object found in packfile"); } @@ -1630,6 +1654,6 @@ int git_pack_entry_find( e->offset = offset; e->p = p; - git_oid_cpy(&e->sha1, &found_oid); + git_oid_cpy(&e->id, &found_oid); return 0; } diff --git a/src/libgit2/pack.h b/src/libgit2/pack.h index d90588f7951..1a9eb14b295 100644 --- a/src/libgit2/pack.h +++ b/src/libgit2/pack.h @@ -99,13 +99,19 @@ struct git_pack_file { uint32_t num_objects; uint32_t num_bad_objects; - git_oid *bad_object_sha1; /* array of git_oid */ + git_oid *bad_object_ids; /* array of git_oid */ + + git_oid_t oid_type; + unsigned oid_hexsize:7, + oid_size:6, + pack_local:1, + pack_keep:1, + has_cache:1; int index_version; git_time_t mtime; - unsigned pack_local:1, pack_keep:1, has_cache:1; git_oidmap *idx_cache; - unsigned char **oids; + unsigned char **ids; git_pack_cache bases; /* delta base cache */ @@ -116,21 +122,26 @@ struct git_pack_file { }; /** - * Return the position where an OID (or a prefix) would be inserted within the - * OID Lookup Table of an .idx file. This performs binary search between the lo - * and hi indices. + * Return the position where an OID (or a prefix) would be inserted within + * the OID Lookup Table of an .idx file. This performs binary search + * between the lo and hi indices. * - * The stride parameter is provided because .idx files version 1 store the OIDs - * interleaved with the 4-byte file offsets of the objects within the .pack - * file (stride = 24), whereas files with version 2 store them in a contiguous - * flat array (stride = 20). + * The stride parameter is provided because .idx files version 1 store the + * OIDs interleaved with the 4-byte file offsets of the objects within the + * .pack file (stride = oid_size + 4), whereas files with version 2 store + * them in a contiguous flat array (stride = oid_size). */ -int git_pack__lookup_sha1(const void *oid_lookup_table, size_t stride, unsigned lo, - unsigned hi, const unsigned char *oid_prefix); +int git_pack__lookup_id( + const void *id_lookup_table, + size_t stride, + unsigned lo, + unsigned hi, + const unsigned char *id_prefix, + const git_oid_t oid_type); struct git_pack_entry { off64_t offset; - git_oid sha1; + git_oid id; struct git_pack_file *p; }; @@ -174,12 +185,15 @@ int get_delta_base( off64_t delta_obj_offset); void git_packfile_free(struct git_pack_file *p, bool unlink_packfile); -int git_packfile_alloc(struct git_pack_file **pack_out, const char *path); +int git_packfile_alloc( + struct git_pack_file **pack_out, + const char *path, + git_oid_t oid_type); int git_pack_entry_find( struct git_pack_entry *e, struct git_pack_file *p, - const git_oid *short_oid, + const git_oid *short_id, size_t len); int git_pack_foreach_entry( struct git_pack_file *p, diff --git a/tests/libgit2/odb/foreach.c b/tests/libgit2/odb/foreach.c index 165a511a0ca..56b3e882ce0 100644 --- a/tests/libgit2/odb/foreach.c +++ b/tests/libgit2/odb/foreach.c @@ -52,7 +52,16 @@ void test_odb_foreach__one_pack(void) int nobj = 0; cl_git_pass(git_odb__new(&_odb, NULL)); - cl_git_pass(git_odb_backend_one_pack(&backend, cl_fixture("testrepo.git/objects/pack/pack-a81e489679b7d3418f9ab594bda8ceb37dd4c695.idx"))); + +#ifdef GIT_EXPERIMENTAL_SHA256 + cl_git_pass(git_odb_backend_one_pack(&backend, + cl_fixture("testrepo.git/objects/pack/pack-a81e489679b7d3418f9ab594bda8ceb37dd4c695.idx"), + NULL)); +#else + cl_git_pass(git_odb_backend_one_pack(&backend, + cl_fixture("testrepo.git/objects/pack/pack-a81e489679b7d3418f9ab594bda8ceb37dd4c695.idx"))); +#endif + cl_git_pass(git_odb_add_backend(_odb, backend, 1)); _repo = NULL; diff --git a/tests/libgit2/odb/pack_data_one256.h b/tests/libgit2/odb/pack_data_one256.h new file mode 100644 index 00000000000..98a874798c6 --- /dev/null +++ b/tests/libgit2/odb/pack_data_one256.h @@ -0,0 +1,21 @@ +/* Just a few to make sure it's working, the rest is tested already */ +#ifdef GIT_EXPERIMENTAL_SHA256 +static const char *packed_objects_one256[] = { + "ea926306b1bab6d3f25f45609907eb6dff91a1460b25e63bf4a0494c70e7a269", + "d048ba2ef4fafa502a44cbc1a50cd58359b9bc243b84a08f541a08ca5f621137", + "a66bda0109d2b3c9bc87970da81bd91076b5f871febbc860f09ae997668b6800", + "3609a41c0506fe19d01fb8b4729923362675f191fe5f63fab3111ef804c48fdf", + "22b6705b86e4aa9120eff203af24709d483698d9f78695e86e82de121784b570", + "6f11d93bfb269ee8c7a506178f60c430abfac5d424acfd9c0b0b27b98e6ab49b", + "0aefd477d9e5b3f8d708a3cf6d78be6b670dfa2e2ec41244634f3b8f115d8e04", + "580474d948cd2ebd2e5ce7a5b81b872d87ba4639c1ac4c0fa7a11a8eddf9827c", + "0636b4292bfdd7274a977cb6f8b2ded8f315ea1bcd8dbedfca37964c2ed3d085", + "19fb1c78b11f0f8bda658d6fa6cc63c0b573c0f6760ee5a9c2df6ce2cde00c5c", + "7f2f7afccb317bb3fdd28555f126846dc4eebe5d9ae7b8d8a1456e8ff85422ce", + "4066249c68b0d3c8b39ebe02c9188935900465acad02a49269710f56720fa58e", + "a560d1fa1edf114f57b402e16d662c17b1e3b7e8601ff7dcea6615ba7f1e48ef", + "58923faa87c7d559d308a114ec2b164e5d6046c889420ed1def6eef2d55106a2", + "753ddabab8ae9c1e733cda15e8e3c83dd43f5a2d939ae32cc3b30b0be1e91f96", + "46333d32b3801cf11d9f80b557245c9e32b0e05deca61dae968914fde159f0e5" +}; +#endif diff --git a/tests/libgit2/odb/packedone.c b/tests/libgit2/odb/packedone.c index 9af27e8c7fd..8637001ffa7 100644 --- a/tests/libgit2/odb/packedone.c +++ b/tests/libgit2/odb/packedone.c @@ -11,7 +11,14 @@ void test_odb_packedone__initialize(void) git_odb_backend *backend = NULL; cl_git_pass(git_odb__new(&_odb, NULL)); - cl_git_pass(git_odb_backend_one_pack(&backend, cl_fixture("testrepo.git/objects/pack/pack-a81e489679b7d3418f9ab594bda8ceb37dd4c695.idx"))); +#ifdef GIT_EXPERIMENTAL_SHA256 + cl_git_pass(git_odb_backend_one_pack(&backend, + cl_fixture("testrepo.git/objects/pack/pack-a81e489679b7d3418f9ab594bda8ceb37dd4c695.idx"), + NULL)); +#else + cl_git_pass(git_odb_backend_one_pack(&backend, + cl_fixture("testrepo.git/objects/pack/pack-a81e489679b7d3418f9ab594bda8ceb37dd4c695.idx"))); +#endif cl_git_pass(git_odb_add_backend(_odb, backend, 1)); } diff --git a/tests/libgit2/odb/packedone256.c b/tests/libgit2/odb/packedone256.c new file mode 100644 index 00000000000..fdeac42055f --- /dev/null +++ b/tests/libgit2/odb/packedone256.c @@ -0,0 +1,78 @@ +#include "clar_libgit2.h" +#include "git2/odb_backend.h" + +#include "pack_data_one256.h" +#include "pack.h" + +#ifdef GIT_EXPERIMENTAL_SHA256 +static git_odb *_odb; +#endif + +void test_odb_packedone256__initialize(void) +{ +#ifdef GIT_EXPERIMENTAL_SHA256 + git_odb_backend *backend = NULL; + git_odb_options odb_opts = GIT_ODB_OPTIONS_INIT; + git_odb_backend_pack_options backend_opts = GIT_ODB_BACKEND_PACK_OPTIONS_INIT; + + odb_opts.oid_type = GIT_OID_SHA256; + backend_opts.oid_type = GIT_OID_SHA256; + + cl_git_pass(git_odb__new(&_odb, &odb_opts)); + cl_git_pass(git_odb_backend_one_pack( + &backend, + cl_fixture("testrepo_256.git/objects/pack/pack-e2f07f30db7e480ea84a0e64ee791b9b270067124b2609019b74f33f256f33fa.idx"), + &backend_opts)); + cl_git_pass(git_odb_add_backend(_odb, backend, 1)); +#endif +} + +void test_odb_packedone256__cleanup(void) +{ +#ifdef GIT_EXPERIMENTAL_SHA256 + git_odb_free(_odb); + _odb = NULL; +#endif +} + +void test_odb_packedone256__mass_read(void) +{ +#ifdef GIT_EXPERIMENTAL_SHA256 + unsigned int i; + + for (i = 0; i < ARRAY_SIZE(packed_objects_one256); ++i) { + git_oid id; + git_odb_object *obj; + + cl_git_pass(git_oid__fromstr(&id, packed_objects_one256[i], GIT_OID_SHA256)); + cl_assert(git_odb_exists(_odb, &id) == 1); + cl_git_pass(git_odb_read(&obj, _odb, &id)); + + git_odb_object_free(obj); + } +#endif +} + +void test_odb_packedone256__read_header_0(void) +{ +#ifdef GIT_EXPERIMENTAL_SHA256 + unsigned int i; + + for (i = 0; i < ARRAY_SIZE(packed_objects_one256); ++i) { + git_oid id; + git_odb_object *obj; + size_t len; + git_object_t type; + + cl_git_pass(git_oid__fromstr(&id, packed_objects_one256[i], GIT_OID_SHA256)); + + cl_git_pass(git_odb_read(&obj, _odb, &id)); + cl_git_pass(git_odb_read_header(&len, &type, _odb, &id)); + + cl_assert(obj->cached.size == len); + cl_assert(obj->cached.type == type); + + git_odb_object_free(obj); + } +#endif +} diff --git a/tests/libgit2/odb/sorting.c b/tests/libgit2/odb/sorting.c index 1010872f466..ec4e3696ba1 100644 --- a/tests/libgit2/odb/sorting.c +++ b/tests/libgit2/odb/sorting.c @@ -82,7 +82,11 @@ void test_odb_sorting__override_default_backend_priority(void) cl_git_pass(git_libgit2_opts(GIT_OPT_SET_ODB_LOOSE_PRIORITY, 5)); cl_git_pass(git_libgit2_opts(GIT_OPT_SET_ODB_PACKED_PRIORITY, 3)); - git_odb_backend_pack(&packed, "./testrepo.git/objects"); + git_odb_backend_pack(&packed, "./testrepo.git/objects" +#ifdef GIT_EXPERIMENTAL_SHA256 + , NULL +#endif + ); git_odb__backend_loose(&loose, "./testrepo.git/objects", NULL); cl_git_pass(git_odb__open(&new_odb, cl_fixture("testrepo.git/objects"), NULL)); diff --git a/tests/resources/packfile-sha256/pack-b4a043c0ec5e079e8ac67d823776d752efc71661592db317474a0cf292915f31.idx b/tests/resources/packfile-sha256/pack-b4a043c0ec5e079e8ac67d823776d752efc71661592db317474a0cf292915f31.idx new file mode 100644 index 0000000000000000000000000000000000000000..7aa472ceaeabd319cd129414f9d72cdefa6b15a9 GIT binary patch literal 1376 zcmexg;-AdGz`z8=ga9K@!BD~=KT!)a1ILfD5l z=wib$S;lix6Ym{;7xCfrv-qo1jMuGTUOlNY)zkj^q9q2ulQ&KIk+I(I+nJMxU#RAp zb3~pC?^15AIuUICHR-GA^~l&*zPMoS*w-c@I@3JmUm0)-OE70A1ha+oY*PJ^6zBZ& zfxn8TeEHdZK82ePE#AOjpWry#?m`x8Z&^QqeU|I*td8~HV4`n2+26M97n|9+kDb2(r97Xp literal 0 HcmV?d00001 diff --git a/tests/resources/packfile-sha256/pack-b4a043c0ec5e079e8ac67d823776d752efc71661592db317474a0cf292915f31.pack b/tests/resources/packfile-sha256/pack-b4a043c0ec5e079e8ac67d823776d752efc71661592db317474a0cf292915f31.pack new file mode 100644 index 0000000000000000000000000000000000000000..adbe70ad35af897528d8ad69f89907a4479859b7 GIT binary patch literal 1406 zcmV-^1%didK|@Ob00062000NENqC%vQ^8K-Fc7`(SIlu2Wr4EVQ%?a=hy-nwq(VKq z@q~RYvW#doWtZsXp{wy znnLun8zYxRP*$Hg553dWPC~+Gqt)mkb_fxDAHcQg=VrNq8?@+^f%UjE)W97zXai>O zj6RUFaFGdz3NT1P=upFMO6Y~?sSbKz;kb#43^`?hUR{lKniVK@$wW`48NayeJ+$R^DJ_7ppC z4E8X1_vlq0UMII&s6TkjVgmjPcB6Pd@jj%okqg0d9oa`-p6ipek+C18oC18W#fMKl z5QYzg0ki`(3}zDhUe)sTfK3c@XnF1UqWZz`{`hX<<~+S{q%=^Ip!^nJuFW8Jx?O6Sf!?OQM>bqI`xaQ6c;+%>S$2}PXyW~YXnhdy7 zI39}ncD1P?UvA+cFUx#cZ|85`;xoQd5f4br%(3&z#);<<^!;^tb<2?avbZbiEwCAj zqF!EC6)aXICLG5`C5h$4f%Pg3_iR;7aNYrGMPeNUp7z(FN{jPz zQyDmHw7Xrx94;003Yd*??mr7E>V z5)~;^x3yH7l0Q(4DkpCCJnb3Z+ppT=EbTT;UUL-{P_xFLXygjdbdwe}*&X zb#s=yt>K~EhHb8QIa7jHc!#%LUJmyknq46VDn=Iwb_V9fdrT{1w}C)MvqH3xhvV*P zp0TILZ4Vh;aG?jgr0pXC-KP-)W)}ndp{6BGai$|=z|hkSF60!=(vbnZ{)#^__Tl(k$LurGKXdtS;Hc$`&F+fKwF5Pjz>=3TdGp%=Q@7>&=y2iFgn(t%=HXec$? zzn8kZiIPb;Gt9Z*yDw4^kYg!w-PNMwZK-7~QJ17^rBtf~NnX_?np{?`qN4Z#KpRPuHacpXq|rJW`e>Pf&2)$fD$J z0}pvRjGYI&K&m(p?2`T(Rr>&eM#6>eE;nOX)@j19?Nox!_ZxWqOTWEOv@B@oG4(E@ zb=DcsYe*Xb=rWJ!Fk0`}jWw@f_Q~ZgGN3b*BDolRzbfjX+y2OBjD1++s6Tjp=(Z!g zz$cuC6!(N{O!vPJvmeaAd%ZGvoJ-^a007PaY_y<5!0cWJo{GkOf;V>8Qt!tWVOcG+ M7e`7A@{*BXG4>I-djJ3c literal 0 HcmV?d00001 From 6204499242101d0f93cd7e56e259c900828e41e1 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 25 Jul 2022 13:04:08 -0400 Subject: [PATCH 123/608] odb: test sha256 pack backend --- tests/libgit2/odb/pack_data_256.h | 154 ++++++++++++++++++++++++++++++ tests/libgit2/odb/packed256.c | 98 +++++++++++++++++++ 2 files changed, 252 insertions(+) create mode 100644 tests/libgit2/odb/pack_data_256.h create mode 100644 tests/libgit2/odb/packed256.c diff --git a/tests/libgit2/odb/pack_data_256.h b/tests/libgit2/odb/pack_data_256.h new file mode 100644 index 00000000000..b631882273a --- /dev/null +++ b/tests/libgit2/odb/pack_data_256.h @@ -0,0 +1,154 @@ +#ifdef GIT_EXPERIMENTAL_SHA256 + +static const char *packed_objects_256[] = { + "99f3b405443221141eb0fd1e0cca5d355f893983749b7fb455769fba434e7945", + "d0fc7f52dc42358506e7f3f3be72f5271994abb104b9397ab3e19bb42361504d", + "86e228d9904af64586e9a8378005ba654681ff5be3c43ca930bf6b1f28d4395f", + "652412419a24ba62a1d897f40aeb80eecbf873797b04a1bbb8d71918653ef65b", + "ad90f638cb67720b20b904478471504acebacc7bb36e5dcad3e882acec496fed", + "4d46d9719e425ef2dfb5bfba098d0b62e21b2b92d0731892eef70db0870e3744", + "80ec1e36b983e68664e8357c538cd35b30638bb0cb99626f906d145e2d2e2558", + "e8bbf40ee280bc43b33c04df2250903b75e92f2497e91759cf1cad753c23be6c", + "8864b5746d7c5780083bb98449a3f5bf78d8281e8c5e3fd12a8ccd9103eb3a1f", + "083c2b8b445640d171e7aa667b0b32007006f786711032ebb82931cca69cc15b", + "5c8bea399f78d3d6a037a41cee2e763d00024180b66f2ec738d443b6a3dd7081", + "281c36286eab5e534f1c2121a4cf2cd48a32b3773a3e78df500bed3f3c9747f3", + "c9dc53358a0d83bee1caae40ee81d752abf4962a9f206702e24a447b766b5bd7", + "fafc05a1d0b7614ba32f428eb52f3439ffbfed9a817e5ae069364cfc3fa3e4d4", + "25a4efebb38c55b8f2309ce5e3116b2b9287239952cc2fa174074e05c6e5875a", + "c223f1b579bad18635efdeffa7a8ff40567d03fa427e08bb90d9878f958d8021", + "8a0042d434a2f8a2e8d47caa4eb454f388752fb3fe71150c1cea12e807cfdf1c", + "d79e913b4137117b7f8fc2a8d184373f657d6f71bbeaca0fe83b7757ce486108", + "375f69d3d41e36d6904bfa86221690ec49de2a030664a362abaf86c426f9f7e0", + "22b6705b86e4aa9120eff203af24709d483698d9f78695e86e82de121784b570", + "4516b0e63349c81abc6584cb11ce84ab8ba38b105f9de39d0d0a1455dba2478d", + "c2b535bfc3501f0b4e179d5d6f0e2cea613940fa3813be5923db7e71e190849f", + "aa793f0e9d9d746eba8a7a60cb4981f7e24ce9691910350d7df9b9e94c7567b9", + "890bb959ac8c20db603bf083bc82f55f9f42b6dca6581d941d0b361188abae3b", + "bfc0ee6fe04854c11011539f38cc6b9b73e0c445bac2008de2fb877123efc2e3", + "5ba7253f47d390ee2c7c7afe8fd9a963a7a2674bbdadeb9a927665c9246306c4", + "79bc735b91f8dfa9379d1d6c21e2d519ac1bf0d04d48534864c9ff571df5297d", + "f362826c827aa3bcbeb3ff8b71bba08d7440b89ab53fe95d61b8922d01f46e28", + "4a1b9c078e7bb20759a2d75e3a4b96827c851446c0261750b96aa5f286efe378", + "2e2aa456dbbb8889923eb6713672427854020298a764967c50235a9a76d7ce4b", + "97b0e3661fa0caa6200c50381233f8320b907540ceb9d17ac94fedc66fd093c2", + "ade7d297ede7bb58008da582de1253f0a55cb76e82d1cd376f82ccf97f70bced", + "3315093132a8f28bd202c0a9562d04eebea4943dcd1e1c754341b0389722042f", + "6fae137ba81d0d81c2a85759b99322e7ea8103bd7c8b85be3163b7e91e18c125", + "f8b45f792840019909fd35f9dcb98082b3bc39373268d467e1b00f1da5ac71e5", + "d2ab425d6092770366bc3dff5276e3a869221bc7b6d22e99c089d556e7eb8331", + "4dd37b9df07bcc7b45ce72a44e3f5fcaf5f0a9a5f3148963714eac4c99a60388", + "8c53c0f9f0972a1c77e40549170b9ae51d365c200ffc4cb220628c5bce3dd0b2", + "11d0463a82345c2512bd704dd00211aefb7d5b8590ca92809122fd09486a9f06", + "1ab4fa663d22416f45cb1a007d767a58d0abf5255bf86f888393dae637b37c3b", + "345d2fbf1d306c7ea46a05f497793308357e9e17ab0e866446d2b9894378ddce", + "304352ddad641770fcc94ee4d9f957cde7aaf4c107dbf8b5ba14d543640bf7dd", + "cfdd565f4cbc315760c287d57714852e1a4894eef9c715332fd556f2e114a9f1", + "d6d2e87e6de8690efd26b8c5b58de28dcb3c9bd2b7659eccf34468d71a7a4478", + "aa61d4adf622265ec814c1a97198d2bcd3f58fb08989cb9beda32a4d0aab6697", + "40799f33b8cd9ca41f36a2f89d8ac8550537ad01dfb21fbc76f01eeb62f512d4", + "faa7ca59426e17f6b34fa407d06cd634faaabeb4abe26df12296e05a17c98eef", + "1f6ea2cab887a2ff4bb1557a36dd6bac9931ef1f36794ddd22b4b7b7276051fb", + "b38a7a2ee69d55f021efa91caf59e23bccdaf6b8a9c3f83acd978aa177587537", + "f66691f32eb9b23a029b43251bfa994d16481fe97903057e121b76e4e78f6ff4", + "afe1fad6f6b22eea530ff7b373d6b9b787b39792f720e6fcd0692ba6ef99e02f", + "b71ee6c8837efa5b3ba3361f88c321d391ac05f41d5b2506cad39319e80716e4", + "e207a266e228414023223530eb77c64b10f2f5124f3354deb45aff04c1db98b9", + "696503760a18787240ba52ad1abec3be6517bb802238e9469b3a8999cbd6432c", + "c30d06fd49797e3135652d654db0de122dd83f8400df1c7a0e95ca3720defb0d", + "8a9b600a21987e6ffddbad745f38c115797eacef9117043bd9d2da4835ee3cc4", + "d509fa76ff5944e25f48c2476736b6239a53f0463cba6ebc488464d087951951", + "3e00d8cae2726dc33879adf876b30c306f50e7a85b15c8add4a27f84d88616d7", + "ce55f9f5ab1d799a9ffaa839539af196d13f35677b3d0761b0fe034e764f8d07", + "84005e38a65f4115d5c94790010dc57e1a3297f4aa89744f5927f208af758bd0", + "75b0ed5f4a2d5c810f34d867dbca51db6a596d4739abfaf24fcc0f05d99097a8", + "3eab74a6894d790767f3d92615a6887dcccaffa9e48fdd2ce482b5f17efcf9b9", + "8e61988c998c96a131cfe72225fce43e555bec4e590fa8c239373172a9d485ce", + "5f45a18f90f2934e7c7985d05b2b5b3584886fd057c9202f26f562d6c3080038", + "7609c608c1097270356a6fe336a8756ff124d4a9c2e941bba26a6e8c3becdeb1", + "81ba4e67aa59ccb078e3dc9ff3075f50084ec1696bd867e8e4284fcfc34fe3cf", + "3b1b991ae70d1f5388ad16b63d2285e99ada7a618c6f5d01e50a6d4b33c4767d", + "ac49410f64fad10760838866a40107573e42c86908c83ece433d64b7a8b57f7f", + "72c472319cf7d5d59bf9fea9e90b9785d7ab39340003fbc68619c11a9e583c2f", + "3a0cd33a47fcd0c7b8f8c1d407aaa53f648e25f2ffe2533a7e9c09c3d1b9da75", + "bf409f1aa76256282ebf1a7cc6c9f4220be9ffc47b2cc42248fcc5cbb67bce1f", + "13c8c9dae9fa63b1ec48b8abb12312fc8df61b9414678f504fa68164a48eef28", + "078baf54914fab56842798c90fec863f15f67a22041e8aa54a88c43f059da050", + "41c166c241a4e878f444932a193501e12ab38ba0634747291df70e619dccee1c", + "9db520a5a88c7d75b86a4faa1ce9010edf38af922f400c69a4a93aef69e25c4c", + "edf6e0dbfaf8a7ad89b05b5768981eeedd7a2bda4b1d0fae07aa2a9d49bb39df", + "ec1866b39026366e69ab8e167c15312c27f5eda4c0afdf9367ac3d76f56bf8e7", + "695bdb545f636d454b4825effd29db96c46d81772dda6c104f97dffe2ec509f1", + "07c31b4be5f3ec8f82c7ad6c91cbdf07ae876bb73041903d64fe8bac64bbcb6e", + "06665948a581e547ac1dc883b35bab54682fc311f7a87d5563a76501ecba55fc", + "fa6a2b7e588e57115d2772c0d5250d886757404fc510a5956be8de4926e94c01", + "28aec9a4450d9de98db98a021f97026bf12f1328f66e53319669eb5adce5ed3e", + "290d84a2cf108c074d3764ca8dc56e1215a5a7482837f098dff7a55e23d89d5f", + "ed10f9520d5f0d6bbd9c467ed83a239df0cba94ae9031602e02f6ad6256c459e", + "ad05c66a177f844f8239a1d186a1f803a4daa6286c959538838e222bc6337dc9", + "88fecc715077807bd7ee9e6a1dff65fde000379e0bf2a15cc2404469cef4c82b", + "bcc4fa242e55c5e08f64900407dca1cf2451806830905be616f339bf7a5580aa", + "4a4ebb837e3c9883f35d0ecdc26d4bc76a0f665568b08f3e967096f2fd3fa537", + "9abb7801e72353060a1490ffa3331674d6882558e7d6458de397b4b00d31ff8c", + "466cdfec4c74f3ed4fe53165e468a52df5dff9c6533ec433cdf235a73e099d32", + "8a1e1a6cc00519c4df8ce404c987751446fa299662308622cb63576fb52996d7", + "e5ea38108d603a6ed8dbb0b8455abe6d971f2d60920207e67ba646d267ece305", + "97e00ba4c8028ea91e7131c8c7596227cd03d3d2d14ed2d179fe0f305ebbca39", + "807faa3586b7f1aff2797a7c39c135b0196647c9ae7ee8843322accc960b2f22", + "b9134c331629e9cb29d1bbc03904d911a942b451e087543fc16deb0116391297", + "23cb97c200205dc84109c248be5bd719c23bdab52b52c51ec92fef9a48790833", + "b6e8427e3afe1cf0095d0f5aeca0642c4fb12d4e529f62e8264b6c4db72f04b4", + "92128dfb792caea934f5218807ec993867b0c8487a3de69ebac33e067f64d38a", + "a13ecbc514b571721a9a1c92af7f89d473a5fe13228904f8d17368e71f273ea1", + "3f5dca26a2f512d6681ce1957b8afba5e031bf63d52fd52d8f57093bf92391a4", + "1aa24b7ebd910f39a676f2ccab8e9a79f14842c20b55ed18e3dc297bdbaca279", + "1e0ce38d00e8f3e613febc0f8b275e0fd7fbef8af293fd62698be46dfbbc937d", + "dd9b1d5ca653752cef167e034324198971ab6f2f38f3db9db571cb2985759f00", + "efc4b8fd4b0b2586fce256b107ee2a052d11d26f99d85ce0478c3d49d1b2186b", + "da38f65b32fb03ce332e0c4238edae0a733e4cd793d849522bb4e0bdd0af608c", + "bf66badfda7b5d2157db65c5310cfdc4e904d7d5da57ac5abe17542de612f856", + "2c0f52f9ae1f34f280dfc1c755cbfaf2b9968fd3bab1f1eb16d3ac0fafd71940", + "165ec90aa4190bbe12ee415b294fd6d204c64afcf1ca64dd815782872b24ea26", + "cc3d272d457c7e26c5d611923841511a1766bcd58e5be66433698627e6fb3f9d", + "d970d1a6296d149bfb8283b8b4a9a6f7e9ee320c5d46a5ef216e10400df2d281", + "bdc530e0b98dd736cd812408eeed9aa0d393bbd0630b355eb7601e61f0dbc7c4", + "94db24aca3f8e07f481744f62633730feb4fc47605280381a08be510ae971ffe", + "151c7527acc5b731199a03a932ae374331e16e5ae29256e98cb652f37669889b", + "ac88849a26c126b03fc6fcb17cb23ec563e87a5f63b7afe800ad0f436128ce98", + "26a2dac21f8f0939566570e48f7f4fcf89239c2746ef8d3dbf31d179c691808f", + "619f24a7f37f8ca922c83b3a1b9a384eb6a444ff3a2a52c712f3c60dde6f24fb", + "5329dd2fd8557be5ad06b57882cf42e23d767cdc8a4b25e464fdb00890649e07", + "fff5cbc10ffea865d69aba64082ae17479c522e8e0305e678469749282bf0a18", + "d0c992aae9cde855b17ac826234a73255ecb09534cdcfa633d90640f6a4324d9", + "6129f1672465ee7b9e2edef53fbf3846ab5d06e8e6a1d7fb51e31666a8b411f8", + "0a8c0add81b065b97451f7b47a9935f0e240251c5f90a89ced885cb7d4efc2ba", + "471fa4fc2da467dd94e57babb1912bbdb5e40b96c8129d46fc709c0bfc009bca", + "23cea2b49eed4993c5b92a9d5f0b82efe4fae3837ea707d921de645d04479015", + "c85e35eec23dea4089aee7a2dc7f6d937ad7e13c66bdbd7eef37bd6336418609", + "a0f3dac8fa0e22dcf356aecbbdf79440715687c1053bc59b83354f276d688ceb", + "1cfb8ae71e9e576d1b16b7bd1a62156d0641c6e51f5d76877be6de4f26410623" +}; + +static const char *loose_objects_256[] = { + "96c18f0297e38d01f4b2dacddea4259aea6b2961eb0822bd2c0c3f6029030045", + "aea29dc305d40e362df25c3fdeed5502fd56b182af01b7740d297a24459333c5", + "73b4f3c4f3182e6c8dd2c98aeb2c7811556538e7673e4b325307c71685fbf5b6", + "901505c3355518bee35475c5d3f23bac1dded688b2bd314cc32b7f157e100724", + "4bc142808884e472ee6cc331b132e66ef18f564d41efb055804ec1dd28efb3f5", + "7e4633ae1b0e83503dbea4417f9d5ccaf22b877c5a4522b6d1d2b16090ee2f6f", + "473a0f4c3be8a93681a267e3b1e9a7dcda1185436fe141f7749120a303721813", + "7030f925768d9beb65654ab8f436e3ca0a82b25eddefd237bf5a26a0441c2aa7", + "cb282e7c15fd8aeb2265cd621f5a228cb33dc84192980ca426cf9ab2a48cb9f0", + "33e415b835a670bb5c3c760efa0433ac0cbd2d44679f68f2df3a9ae7014cf2a8", + "8155958bbda08eed88c8ac908dc44452ed38911cffa54ccc06076f30a1ffb1bf", + "1b4b74772bd83ff28bf44cda9be93f4afc2279623bb5b36c9194a660b7623c24", + "f31459efb9367c5a19c9dd24c75107423d5773066922ea5e55eaeb6490979562", + "6d5fd291bb0f67444e99ab492f1bf1fcdf5dca09dab24cf331e05111b4cfc1a3", + "b83624f6ac0995273c0034a7ab8c68929bdc91b69ad54ef94979b93eba3f6022", + "61489e9e831f1d9001084d39b79f964c293db8620d679ea3596673c8a326446e", + "abee32b3339d1566d75613ea61f40c14bdfc5b101b60fde4f44b58dd06667640", + "a4813ef6708e6011e8187224297e83e4a285f58bf5eabb1db270351388603c95", + "43e084a4599ca42c476919917e3db8fde0045ee66305fd5e634b0c793c536a1b" +}; + +#endif diff --git a/tests/libgit2/odb/packed256.c b/tests/libgit2/odb/packed256.c new file mode 100644 index 00000000000..65220fd4c8b --- /dev/null +++ b/tests/libgit2/odb/packed256.c @@ -0,0 +1,98 @@ +#include "clar_libgit2.h" +#include "odb.h" +#include "pack_data_256.h" + +#ifdef GIT_EXPERIMENTAL_SHA256 +static git_odb *_odb; +#endif + +void test_odb_packed256__initialize(void) +{ +#ifdef GIT_EXPERIMENTAL_SHA256 + git_odb_options opts = GIT_ODB_OPTIONS_INIT; + + opts.oid_type = GIT_OID_SHA256; + + cl_git_pass(git_odb__open( + &_odb, + cl_fixture("testrepo_256.git/objects"), + &opts)); +#endif +} + +void test_odb_packed256__cleanup(void) +{ +#ifdef GIT_EXPERIMENTAL_SHA256 + git_odb_free(_odb); + _odb = NULL; +#endif +} + +void test_odb_packed256__mass_read(void) +{ +#ifdef GIT_EXPERIMENTAL_SHA256 + unsigned int i; + + for (i = 0; i < ARRAY_SIZE(packed_objects_256); ++i) { + git_oid id; + git_odb_object *obj; + + cl_git_pass(git_oid__fromstr(&id, packed_objects_256[i], GIT_OID_SHA256)); + cl_assert(git_odb_exists(_odb, &id) == 1); + cl_git_pass(git_odb_read(&obj, _odb, &id)); + + git_odb_object_free(obj); + } +#endif +} + +void test_odb_packed256__read_header_0(void) +{ +#ifdef GIT_EXPERIMENTAL_SHA256 + unsigned int i; + + for (i = 0; i < ARRAY_SIZE(packed_objects_256); ++i) { + git_oid id; + git_odb_object *obj; + size_t len; + git_object_t type; + + cl_git_pass(git_oid__fromstr(&id, packed_objects_256[i], GIT_OID_SHA256)); + + cl_git_pass(git_odb_read(&obj, _odb, &id)); + cl_git_pass(git_odb_read_header(&len, &type, _odb, &id)); + + cl_assert(obj->cached.size == len); + cl_assert(obj->cached.type == type); + + git_odb_object_free(obj); + } +#endif +} + +void test_odb_packed256__read_header_1(void) +{ +#ifdef GIT_EXPERIMENTAL_SHA256 + unsigned int i; + + for (i = 0; i < ARRAY_SIZE(loose_objects_256); ++i) { + git_oid id; + git_odb_object *obj; + size_t len; + git_object_t type; + + cl_git_pass(git_oid__fromstr(&id, loose_objects_256[i], GIT_OID_SHA256)); + + cl_assert(git_odb_exists(_odb, &id) == 1); + + cl_git_pass(git_odb_read(&obj, _odb, &id)); + cl_git_pass(git_odb_read_header(&len, &type, _odb, &id)); + + cl_assert(obj->cached.size == len); + cl_assert(obj->cached.type == type); + + git_odb_object_free(obj); + } +#endif +} + From fe2ee3a018286b04cd0c64f84d437c7317c8f138 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Wed, 21 Sep 2022 05:09:46 -0400 Subject: [PATCH 124/608] object: lookup sha256 objects This is much of the plumbing for the object database to support SHA256, and for objects to be able to parse SHA256 versions of themselves. --- examples/index-pack.c | 9 +- fuzzers/objects_fuzzer.c | 2 +- fuzzers/packfile_fuzzer.c | 9 +- include/git2/indexer.h | 29 +++ include/git2/object.h | 30 ++- src/cli/cmd_hash_object.c | 32 ++- src/libgit2/blob.c | 6 +- src/libgit2/blob.h | 4 +- src/libgit2/commit.c | 57 ++++-- src/libgit2/commit.h | 32 ++- src/libgit2/commit_list.c | 6 +- src/libgit2/indexer.c | 79 +++++--- src/libgit2/object.c | 45 +++-- src/libgit2/object.h | 3 +- src/libgit2/odb_pack.c | 18 +- src/libgit2/pack-objects.c | 13 +- src/libgit2/repository.c | 5 +- src/libgit2/tag.c | 25 ++- src/libgit2/tag.h | 4 +- src/libgit2/tree.c | 38 ++-- src/libgit2/tree.h | 4 +- tests/libgit2/commit/parse.c | 2 +- tests/libgit2/object/commit/parse.c | 298 +++++++++++++++++++++++++--- tests/libgit2/object/lookup256.c | 153 ++++++++++++++ tests/libgit2/object/tag/parse.c | 4 +- tests/libgit2/object/tree/parse.c | 4 +- tests/libgit2/object/validate.c | 154 +++++++++++--- tests/libgit2/pack/indexer.c | 53 ++++- tests/libgit2/pack/packbuilder.c | 17 ++ 29 files changed, 961 insertions(+), 174 deletions(-) create mode 100644 tests/libgit2/object/lookup256.c diff --git a/examples/index-pack.c b/examples/index-pack.c index df37dd0c45e..0f8234c7591 100644 --- a/examples/index-pack.c +++ b/examples/index-pack.c @@ -28,11 +28,18 @@ int lg2_index_pack(git_repository *repo, int argc, char **argv) return EXIT_FAILURE; } - if (git_indexer_new(&idx, ".", 0, NULL, NULL) < 0) { +#ifdef GIT_EXPERIMENTAL_SHA256 + error = git_indexer_new(&idx, ".", git_repository_oid_type(repo), NULL); +#else + error = git_indexer_new(&idx, ".", 0, NULL, NULL); +#endif + + if (error < 0) { puts("bad idx"); return -1; } + if ((fd = open(argv[1], 0)) < 0) { perror("open"); return -1; diff --git a/fuzzers/objects_fuzzer.c b/fuzzers/objects_fuzzer.c index 51b4a1ed415..7294e9b35aa 100644 --- a/fuzzers/objects_fuzzer.c +++ b/fuzzers/objects_fuzzer.c @@ -39,7 +39,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) * to do. */ for (i = 0; i < ARRAY_SIZE(types); i++) { - if (git_object__from_raw(&object, (const char *) data, size, types[i]) < 0) + if (git_object__from_raw(&object, (const char *) data, size, types[i], GIT_OID_SHA1) < 0) continue; git_object_free(object); object = NULL; diff --git a/fuzzers/packfile_fuzzer.c b/fuzzers/packfile_fuzzer.c index 52a813760a4..aeba9575c3e 100644 --- a/fuzzers/packfile_fuzzer.c +++ b/fuzzers/packfile_fuzzer.c @@ -67,6 +67,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) git_str path = GIT_STR_INIT; git_oid oid; bool append_hash = false; + int error; if (size == 0) return 0; @@ -82,7 +83,13 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) abort(); } - if (git_indexer_new(&indexer, ".", 0, odb, NULL) < 0) { +#ifdef GIT_EXPERIMENTAL_SHA256 + error = git_indexer_new(&indexer, ".", GIT_OID_SHA1, NULL); +#else + error = git_indexer_new(&indexer, ".", 0, odb, NULL); +#endif + + if (error < 0) { fprintf(stderr, "Failed to create the indexer: %s\n", git_error_last()->message); abort(); diff --git a/include/git2/indexer.h b/include/git2/indexer.h index ffe9bf366d5..630eef93456 100644 --- a/include/git2/indexer.h +++ b/include/git2/indexer.h @@ -62,6 +62,19 @@ typedef int GIT_CALLBACK(git_indexer_progress_cb)(const git_indexer_progress *st typedef struct git_indexer_options { unsigned int version; +#ifdef GIT_EXPERIMENTAL_SHA256 + /** permissions to use creating packfile or 0 for defaults */ + unsigned int mode; + + /** + * object database from which to read base objects when + * fixing thin packs. This can be NULL if there are no thin + * packs; if a thin pack is encountered, an error will be + * returned if there are bases missing. + */ + git_odb *odb; +#endif + /** progress_cb function to call with progress information */ git_indexer_progress_cb progress_cb; @@ -87,6 +100,21 @@ GIT_EXTERN(int) git_indexer_options_init( git_indexer_options *opts, unsigned int version); +#ifdef GIT_EXPERIMENTAL_SHA256 +/** + * Create a new indexer instance + * + * @param out where to store the indexer instance + * @param path to the directory where the packfile should be stored + * @param oid_type the oid type to use for objects + * @return 0 or an error code. + */ +GIT_EXTERN(int) git_indexer_new( + git_indexer **out, + const char *path, + git_oid_t oid_type, + git_indexer_options *opts); +#else /** * Create a new indexer instance * @@ -106,6 +134,7 @@ GIT_EXTERN(int) git_indexer_new( unsigned int mode, git_odb *odb, git_indexer_options *opts); +#endif /** * Add data to the indexer diff --git a/include/git2/object.h b/include/git2/object.h index 5610a476f49..6384aaa6e94 100644 --- a/include/git2/object.h +++ b/include/git2/object.h @@ -225,6 +225,7 @@ GIT_EXTERN(int) git_object_peel( */ GIT_EXTERN(int) git_object_dup(git_object **dest, git_object *source); +#ifdef GIT_EXPERIMENTAL_SHA256 /** * Analyzes a buffer of raw object content and determines its validity. * Tree, commit, and tag objects will be parsed and ensured that they @@ -238,14 +239,39 @@ GIT_EXTERN(int) git_object_dup(git_object **dest, git_object *source); * @param valid Output pointer to set with validity of the object content * @param buf The contents to validate * @param len The length of the buffer - * @param type The type of the object in the buffer + * @param object_type The type of the object in the buffer + * @param oid_type The object ID type for the OIDs in the given buffer * @return 0 on success or an error code */ GIT_EXTERN(int) git_object_rawcontent_is_valid( int *valid, const char *buf, size_t len, - git_object_t type); + git_object_t object_type, + git_oid_t oid_type); +#else +/** + * Analyzes a buffer of raw object content and determines its validity. + * Tree, commit, and tag objects will be parsed and ensured that they + * are valid, parseable content. (Blobs are always valid by definition.) + * An error message will be set with an informative message if the object + * is not valid. + * + * @warning This function is experimental and its signature may change in + * the future. + * + * @param valid Output pointer to set with validity of the object content + * @param buf The contents to validate + * @param len The length of the buffer + * @param object_type The type of the object in the buffer + * @return 0 on success or an error code + */ +GIT_EXTERN(int) git_object_rawcontent_is_valid( + int *valid, + const char *buf, + size_t len, + git_object_t object_type); +#endif /** @} */ GIT_END_DECL diff --git a/src/cli/cmd_hash_object.c b/src/cli/cmd_hash_object.c index a64db8823a7..93b980d6676 100644 --- a/src/cli/cmd_hash_object.c +++ b/src/cli/cmd_hash_object.c @@ -49,26 +49,37 @@ static void print_help(void) cli_opt_help_fprint(stdout, opts); } -static int hash_buf(git_odb *odb, git_str *buf, git_object_t type) +static int hash_buf( + git_odb *odb, + git_str *buf, + git_object_t object_type, + git_oid_t oid_type) { git_oid oid; if (!literally) { int valid = 0; - if (git_object_rawcontent_is_valid(&valid, buf->ptr, buf->size, type) < 0 || !valid) +#ifdef GIT_EXPERIMENTAL_SHA256 + if (git_object_rawcontent_is_valid(&valid, buf->ptr, buf->size, object_type, oid_type) < 0 || !valid) + return cli_error_git(); +#else + GIT_UNUSED(oid_type); + + if (git_object_rawcontent_is_valid(&valid, buf->ptr, buf->size, object_type) < 0 || !valid) return cli_error_git(); +#endif } if (write_object) { - if (git_odb_write(&oid, odb, buf->ptr, buf->size, type) < 0) + if (git_odb_write(&oid, odb, buf->ptr, buf->size, object_type) < 0) return cli_error_git(); } else { #ifdef GIT_EXPERIMENTAL_SHA256 - if (git_odb_hash(&oid, buf->ptr, buf->size, type, GIT_OID_SHA1) < 0) + if (git_odb_hash(&oid, buf->ptr, buf->size, object_type, GIT_OID_SHA1) < 0) return cli_error_git(); #else - if (git_odb_hash(&oid, buf->ptr, buf->size, type) < 0) + if (git_odb_hash(&oid, buf->ptr, buf->size, object_type) < 0) return cli_error_git(); #endif } @@ -83,9 +94,10 @@ int cmd_hash_object(int argc, char **argv) { git_repository *repo = NULL; git_odb *odb = NULL; + git_oid_t oid_type; git_str buf = GIT_STR_INIT; cli_opt invalid_opt; - git_object_t type = GIT_OBJECT_BLOB; + git_object_t object_type = GIT_OBJECT_BLOB; char **filename; int ret = 0; @@ -97,7 +109,7 @@ int cmd_hash_object(int argc, char **argv) return 0; } - if (type_name && (type = git_object_string2type(type_name)) == GIT_OBJECT_INVALID) + if (type_name && (object_type = git_object_string2type(type_name)) == GIT_OBJECT_INVALID) return cli_error_usage("invalid object type '%s'", type_name); if (write_object && @@ -107,6 +119,8 @@ int cmd_hash_object(int argc, char **argv) goto done; } + oid_type = git_repository_oid_type(repo); + /* * TODO: we're reading blobs, we shouldn't pull them all into main * memory, we should just stream them into the odb instead. @@ -118,7 +132,7 @@ int cmd_hash_object(int argc, char **argv) goto done; } - if ((ret = hash_buf(odb, &buf, type)) != 0) + if ((ret = hash_buf(odb, &buf, object_type, oid_type)) != 0) goto done; } else { for (filename = filenames; *filename; filename++) { @@ -127,7 +141,7 @@ int cmd_hash_object(int argc, char **argv) goto done; } - if ((ret = hash_buf(odb, &buf, type)) != 0) + if ((ret = hash_buf(odb, &buf, object_type, oid_type)) != 0) goto done; } } diff --git a/src/libgit2/blob.c b/src/libgit2/blob.c index b1680d3a80c..5cfd7474b71 100644 --- a/src/libgit2/blob.c +++ b/src/libgit2/blob.c @@ -52,11 +52,12 @@ void git_blob__free(void *_blob) git__free(blob); } -int git_blob__parse_raw(void *_blob, const char *data, size_t size) +int git_blob__parse_raw(void *_blob, const char *data, size_t size, git_oid_t oid_type) { git_blob *blob = (git_blob *) _blob; GIT_ASSERT_ARG(blob); + GIT_UNUSED(oid_type); blob->raw = 1; blob->data.raw.data = data; @@ -64,11 +65,12 @@ int git_blob__parse_raw(void *_blob, const char *data, size_t size) return 0; } -int git_blob__parse(void *_blob, git_odb_object *odb_obj) +int git_blob__parse(void *_blob, git_odb_object *odb_obj, git_oid_t oid_type) { git_blob *blob = (git_blob *) _blob; GIT_ASSERT_ARG(blob); + GIT_UNUSED(oid_type); git_cached_obj_incref((git_cached_obj *)odb_obj); blob->raw = 0; diff --git a/src/libgit2/blob.h b/src/libgit2/blob.h index 9a5dda2254e..d6c9dd99b07 100644 --- a/src/libgit2/blob.h +++ b/src/libgit2/blob.h @@ -36,8 +36,8 @@ struct git_blob { } while(0) void git_blob__free(void *blob); -int git_blob__parse(void *blob, git_odb_object *obj); -int git_blob__parse_raw(void *blob, const char *data, size_t size); +int git_blob__parse(void *blob, git_odb_object *obj, git_oid_t oid_type); +int git_blob__parse_raw(void *blob, const char *data, size_t size, git_oid_t oid_type); int git_blob__getbuf(git_str *buffer, git_blob *blob); extern int git_blob__create_from_paths( diff --git a/src/libgit2/commit.c b/src/libgit2/commit.c index 114ae6fc92b..d85fefb3d48 100644 --- a/src/libgit2/commit.c +++ b/src/libgit2/commit.c @@ -390,7 +390,11 @@ int git_commit_amend( return error; } -static int commit_parse(git_commit *commit, const char *data, size_t size, unsigned int flags) +static int commit_parse( + git_commit *commit, + const char *data, + size_t size, + git_commit__parse_options *opts) { const char *buffer_start = data, *buffer; const char *buffer_end = buffer_start + size; @@ -401,6 +405,7 @@ static int commit_parse(git_commit *commit, const char *data, size_t size, unsig GIT_ASSERT_ARG(commit); GIT_ASSERT_ARG(data); + GIT_ASSERT_ARG(opts); buffer = buffer_start; @@ -409,13 +414,14 @@ static int commit_parse(git_commit *commit, const char *data, size_t size, unsig GIT_ERROR_CHECK_ARRAY(commit->parent_ids); /* The tree is always the first field */ - if (!(flags & GIT_COMMIT_PARSE_QUICK)) { + if (!(opts->flags & GIT_COMMIT_PARSE_QUICK)) { if (git_object__parse_oid_header(&commit->tree_id, &buffer, buffer_end, "tree ", - GIT_OID_SHA1) < 0) + opts->oid_type) < 0) goto bad_buffer; } else { - size_t tree_len = strlen("tree ") + GIT_OID_SHA1_HEXSIZE + 1; + size_t tree_len = strlen("tree ") + git_oid_hexsize(opts->oid_type) + 1; + if (buffer + tree_len > buffer_end) goto bad_buffer; buffer += tree_len; @@ -427,14 +433,14 @@ static int commit_parse(git_commit *commit, const char *data, size_t size, unsig while (git_object__parse_oid_header(&parent_id, &buffer, buffer_end, "parent ", - GIT_OID_SHA1) == 0) { + opts->oid_type) == 0) { git_oid *new_id = git_array_alloc(commit->parent_ids); GIT_ERROR_CHECK_ALLOC(new_id); git_oid_cpy(new_id, &parent_id); } - if (!(flags & GIT_COMMIT_PARSE_QUICK)) { + if (!opts || !(opts->flags & GIT_COMMIT_PARSE_QUICK)) { commit->author = git__malloc(sizeof(git_signature)); GIT_ERROR_CHECK_ALLOC(commit->author); @@ -458,7 +464,7 @@ static int commit_parse(git_commit *commit, const char *data, size_t size, unsig if ((error = git_signature__parse(commit->committer, &buffer, buffer_end, "committer ", '\n')) < 0) return error; - if (flags & GIT_COMMIT_PARSE_QUICK) + if (opts && opts->flags & GIT_COMMIT_PARSE_QUICK) return 0; /* Parse add'l header entries */ @@ -503,19 +509,39 @@ static int commit_parse(git_commit *commit, const char *data, size_t size, unsig return GIT_EINVALID; } -int git_commit__parse_raw(void *commit, const char *data, size_t size) +int git_commit__parse( + void *commit, + git_odb_object *odb_obj, + git_oid_t oid_type) { - return commit_parse(commit, data, size, 0); + git_commit__parse_options parse_options = {0}; + parse_options.oid_type = oid_type; + + return git_commit__parse_ext(commit, odb_obj, &parse_options); } -int git_commit__parse_ext(git_commit *commit, git_odb_object *odb_obj, unsigned int flags) +int git_commit__parse_raw( + void *commit, + const char *data, + size_t size, + git_oid_t oid_type) { - return commit_parse(commit, git_odb_object_data(odb_obj), git_odb_object_size(odb_obj), flags); + git_commit__parse_options parse_options = {0}; + parse_options.oid_type = oid_type; + + return commit_parse(commit, data, size, &parse_options); } -int git_commit__parse(void *_commit, git_odb_object *odb_obj) +int git_commit__parse_ext( + git_commit *commit, + git_odb_object *odb_obj, + git_commit__parse_options *parse_opts) { - return git_commit__parse_ext(_commit, odb_obj, 0); + return commit_parse( + commit, + git_odb_object_data(odb_obj), + git_odb_object_size(odb_obj), + parse_opts); } #define GIT_COMMIT_GETTER(_rvalue, _name, _return, _invalid) \ @@ -985,11 +1011,14 @@ int git_commit_create_with_signature( git_str commit = GIT_STR_INIT; git_commit *parsed; git_array_oid_t parents = GIT_ARRAY_INIT; + git_commit__parse_options parse_opts = {0}; + + parse_opts.oid_type = repo->oid_type; /* The first step is to verify that all the tree and parents exist */ parsed = git__calloc(1, sizeof(git_commit)); GIT_ERROR_CHECK_ALLOC(parsed); - if (commit_parse(parsed, commit_content, strlen(commit_content), 0) < 0) { + if (commit_parse(parsed, commit_content, strlen(commit_content), &parse_opts) < 0) { error = -1; goto cleanup; } diff --git a/src/libgit2/commit.h b/src/libgit2/commit.h index 7a2454e6192..c25fee327b8 100644 --- a/src/libgit2/commit.h +++ b/src/libgit2/commit.h @@ -33,6 +33,16 @@ struct git_commit { char *body; }; +typedef struct { + git_oid_t oid_type; + unsigned int flags; +} git_commit__parse_options; + +typedef enum { + /** Only parse parents and committer info */ + GIT_COMMIT_PARSE_QUICK = (1 << 0) +} git_commit__parse_flags; + int git_commit__header_field( git_str *out, const git_commit *commit, @@ -56,14 +66,22 @@ int git_commit__create_buffer( size_t parent_count, const git_commit *parents[]); -void git_commit__free(void *commit); -int git_commit__parse(void *commit, git_odb_object *obj); -int git_commit__parse_raw(void *commit, const char *data, size_t size); +int git_commit__parse( + void *commit, + git_odb_object *obj, + git_oid_t oid_type); -typedef enum { - GIT_COMMIT_PARSE_QUICK = (1 << 0) /**< Only parse parents and committer info */ -} git_commit__parse_flags; +int git_commit__parse_raw( + void *commit, + const char *data, + size_t size, + git_oid_t oid_type); -int git_commit__parse_ext(git_commit *commit, git_odb_object *odb_obj, unsigned int flags); +int git_commit__parse_ext( + git_commit *commit, + git_odb_object *odb_obj, + git_commit__parse_options *parse_opts); + +void git_commit__free(void *commit); #endif diff --git a/src/libgit2/commit_list.c b/src/libgit2/commit_list.c index 511d7291f00..12b329b251e 100644 --- a/src/libgit2/commit_list.c +++ b/src/libgit2/commit_list.c @@ -124,13 +124,17 @@ static int commit_quick_parse( { git_oid *parent_oid; git_commit *commit; + git_commit__parse_options parse_opts = { + GIT_OID_SHA1, + GIT_COMMIT_PARSE_QUICK + }; size_t i; commit = git__calloc(1, sizeof(*commit)); GIT_ERROR_CHECK_ALLOC(commit); commit->object.repo = walk->repo; - if (git_commit__parse_ext(commit, obj, GIT_COMMIT_PARSE_QUICK) < 0) { + if (git_commit__parse_ext(commit, obj, &parse_opts) < 0) { git__free(commit); return -1; } diff --git a/src/libgit2/indexer.c b/src/libgit2/indexer.c index 98408646ae7..dfc326e02d0 100644 --- a/src/libgit2/indexer.c +++ b/src/libgit2/indexer.c @@ -42,6 +42,7 @@ struct git_indexer { have_delta :1, do_fsync :1, do_verify :1; + git_oid_t oid_type; struct git_pack_header hdr; struct git_pack_file *pack; unsigned int mode; @@ -68,7 +69,7 @@ struct git_indexer { git_odb *odb; /* Fields for calculating the packfile trailer (hash of everything before it) */ - char inbuf[GIT_OID_SHA1_SIZE]; + char inbuf[GIT_OID_MAX_SIZE]; size_t inbuf_len; git_hash_ctx trailer; }; @@ -136,12 +137,13 @@ int git_indexer_init_options(git_indexer_options *opts, unsigned int version) } #endif -int git_indexer_new( - git_indexer **out, - const char *prefix, - unsigned int mode, - git_odb *odb, - git_indexer_options *in_opts) +static int indexer_new( + git_indexer **out, + const char *prefix, + git_oid_t oid_type, + unsigned int mode, + git_odb *odb, + git_indexer_options *in_opts) { git_indexer_options opts = GIT_INDEXER_OPTIONS_INIT; git_indexer *idx; @@ -154,6 +156,7 @@ int git_indexer_new( idx = git__calloc(1, sizeof(git_indexer)); GIT_ERROR_CHECK_ALLOC(idx); + idx->oid_type = oid_type; idx->odb = odb; idx->progress_cb = opts.progress_cb; idx->progress_payload = opts.progress_cb_payload; @@ -209,6 +212,33 @@ int git_indexer_new( return -1; } +#ifdef GIT_EXPERIMENTAL_SHA256 +int git_indexer_new( + git_indexer **out, + const char *prefix, + git_oid_t oid_type, + git_indexer_options *opts) +{ + return indexer_new( + out, + prefix, + oid_type, + opts ? opts->mode : 0, + opts ? opts->odb : NULL, + opts); +} +#else +int git_indexer_new( + git_indexer **out, + const char *prefix, + unsigned int mode, + git_odb *odb, + git_indexer_options *opts) +{ + return indexer_new(out, prefix, GIT_OID_SHA1, mode, odb, opts); +} +#endif + void git_indexer__set_fsync(git_indexer *idx, int do_fsync) { idx->do_fsync = !!do_fsync; @@ -273,7 +303,7 @@ static int advance_delta_offset(git_indexer *idx, git_object_t type) GIT_ASSERT_ARG(type == GIT_OBJECT_REF_DELTA || type == GIT_OBJECT_OFS_DELTA); if (type == GIT_OBJECT_REF_DELTA) { - idx->off += GIT_OID_SHA1_SIZE; + idx->off += git_oid_size(idx->oid_type); } else { off64_t base_off; int error = get_delta_base(&base_off, idx->pack, &w, &idx->off, type, idx->entry_start); @@ -357,7 +387,7 @@ static int check_object_connectivity(git_indexer *idx, const git_rawobj *obj) obj->type != GIT_OBJECT_TAG) return 0; - if (git_object__from_raw(&object, obj->data, obj->len, obj->type) < 0) { + if (git_object__from_raw(&object, obj->data, obj->len, obj->type, idx->oid_type) < 0) { /* * parse_raw returns EINVALID on invalid data; downgrade * that to a normal -1 error code. @@ -447,7 +477,7 @@ static int store_object(git_indexer *idx) } #ifdef GIT_EXPERIMENTAL_SHA256 - oid.type = GIT_OID_SHA1; + oid.type = idx->oid_type; #endif entry_size = idx->off - entry_start; @@ -550,7 +580,7 @@ static int hash_and_save(git_indexer *idx, git_rawobj *obj, off64_t entry_start) entry = git__calloc(1, sizeof(*entry)); GIT_ERROR_CHECK_ALLOC(entry); - if (git_odb__hashobj(&oid, obj, GIT_OID_SHA1) < 0) { + if (git_odb__hashobj(&oid, obj, idx->oid_type) < 0) { git_error_set(GIT_ERROR_INDEXER, "failed to hash object"); goto on_error; } @@ -588,30 +618,31 @@ static int do_progress_callback(git_indexer *idx, git_indexer_progress *stats) static void hash_partially(git_indexer *idx, const uint8_t *data, size_t size) { size_t to_expell, to_keep; + size_t oid_size = git_oid_size(idx->oid_type); if (size == 0) return; /* Easy case, dump the buffer and the data minus the last 20 bytes */ - if (size >= GIT_OID_SHA1_SIZE) { + if (size >= oid_size) { git_hash_update(&idx->trailer, idx->inbuf, idx->inbuf_len); - git_hash_update(&idx->trailer, data, size - GIT_OID_SHA1_SIZE); + git_hash_update(&idx->trailer, data, size - oid_size); - data += size - GIT_OID_SHA1_SIZE; - memcpy(idx->inbuf, data, GIT_OID_SHA1_SIZE); - idx->inbuf_len = GIT_OID_SHA1_SIZE; + data += size - oid_size; + memcpy(idx->inbuf, data, oid_size); + idx->inbuf_len = oid_size; return; } /* We can just append */ - if (idx->inbuf_len + size <= GIT_OID_SHA1_SIZE) { + if (idx->inbuf_len + size <= oid_size) { memcpy(idx->inbuf + idx->inbuf_len, data, size); idx->inbuf_len += size; return; } /* We need to partially drain the buffer and then append */ - to_keep = GIT_OID_SHA1_SIZE - size; + to_keep = oid_size - size; to_expell = idx->inbuf_len - to_keep; git_hash_update(&idx->trailer, idx->inbuf, to_expell); @@ -906,7 +937,7 @@ static int index_path(git_str *path, git_indexer *idx, const char *suffix) slash--; if (git_str_grow(path, slash + 1 + strlen(prefix) + - GIT_OID_SHA1_HEXSIZE + strlen(suffix) + 1) < 0) + git_oid_hexsize(idx->oid_type) + strlen(suffix) + 1) < 0) return -1; git_str_truncate(path, slash); @@ -923,7 +954,7 @@ static int index_path(git_str *path, git_indexer *idx, const char *suffix) */ static int seek_back_trailer(git_indexer *idx) { - idx->pack->mwf.size -= GIT_OID_SHA1_SIZE; + idx->pack->mwf.size -= git_oid_size(idx->oid_type); return git_mwindow_free_all(&idx->pack->mwf); } @@ -983,7 +1014,7 @@ static int inject_object(git_indexer *idx, git_oid *id) if ((error = append_to_pack(idx, empty_checksum, checksum_size)) < 0) goto cleanup; - idx->pack->mwf.size += GIT_OID_SHA1_SIZE; + idx->pack->mwf.size += git_oid_size(idx->oid_type); pentry = git__calloc(1, sizeof(struct git_pack_entry)); GIT_ERROR_CHECK_ALLOC(pentry); @@ -1046,13 +1077,13 @@ static int fix_thin_pack(git_indexer *idx, git_indexer_progress *stats) } /* curpos now points to the base information, which is an OID */ - base_info = git_mwindow_open(&idx->pack->mwf, &w, curpos, GIT_OID_SHA1_SIZE, &left); + base_info = git_mwindow_open(&idx->pack->mwf, &w, curpos, git_oid_size(idx->oid_type), &left); if (base_info == NULL) { git_error_set(GIT_ERROR_INDEXER, "failed to map delta information"); return -1; } - git_oid__fromraw(&base, base_info, GIT_OID_SHA1); + git_oid__fromraw(&base, base_info, idx->oid_type); git_mwindow_close(&w); if (has_entry(idx, &base)) @@ -1275,7 +1306,7 @@ int git_indexer_commit(git_indexer *idx, git_indexer_progress *stats) /* Write out the object names (SHA-1 hashes) */ git_vector_foreach(&idx->objects, i, entry) { - git_filebuf_write(&index_file, &entry->oid.id, GIT_OID_SHA1_SIZE); + git_filebuf_write(&index_file, &entry->oid.id, git_oid_size(idx->oid_type)); } /* Write out the CRC32 values */ diff --git a/src/libgit2/object.c b/src/libgit2/object.c index d45465678f1..d87d40cf16d 100644 --- a/src/libgit2/object.c +++ b/src/libgit2/object.c @@ -27,8 +27,8 @@ typedef struct { const char *str; /* type name string */ size_t size; /* size in bytes of the object structure */ - int (*parse)(void *self, git_odb_object *obj); - int (*parse_raw)(void *self, const char *data, size_t size); + int (*parse)(void *self, git_odb_object *obj, git_oid_t oid_type); + int (*parse_raw)(void *self, const char *data, size_t size, git_oid_t oid_type); void (*free)(void *self); } git_object_def; @@ -60,7 +60,8 @@ int git_object__from_raw( git_object **object_out, const char *data, size_t size, - git_object_t type) + git_object_t object_type, + git_oid_t oid_type) { git_object_def *def; git_object *object; @@ -71,12 +72,15 @@ int git_object__from_raw( *object_out = NULL; /* Validate type match */ - if (type != GIT_OBJECT_BLOB && type != GIT_OBJECT_TREE && type != GIT_OBJECT_COMMIT && type != GIT_OBJECT_TAG) { + if (object_type != GIT_OBJECT_BLOB && + object_type != GIT_OBJECT_TREE && + object_type != GIT_OBJECT_COMMIT && + object_type != GIT_OBJECT_TAG) { git_error_set(GIT_ERROR_INVALID, "the requested type is invalid"); return GIT_ENOTFOUND; } - if ((object_size = git_object__size(type)) == 0) { + if ((object_size = git_object__size(object_type)) == 0) { git_error_set(GIT_ERROR_INVALID, "the requested type is invalid"); return GIT_ENOTFOUND; } @@ -85,15 +89,15 @@ int git_object__from_raw( object = git__calloc(1, object_size); GIT_ERROR_CHECK_ALLOC(object); object->cached.flags = GIT_CACHE_STORE_PARSED; - object->cached.type = type; - if ((error = git_odb__hash(&object->cached.oid, data, size, type, GIT_OID_SHA1)) < 0) + object->cached.type = object_type; + if ((error = git_odb__hash(&object->cached.oid, data, size, object_type, oid_type)) < 0) return error; /* Parse raw object data */ - def = &git_objects_table[type]; + def = &git_objects_table[object_type]; GIT_ASSERT(def->free && def->parse_raw); - if ((error = def->parse_raw(object, data, size)) < 0) { + if ((error = def->parse_raw(object, data, size, oid_type)) < 0) { def->free(object); return error; } @@ -143,7 +147,7 @@ int git_object__from_odb_object( def = &git_objects_table[odb_obj->cached.type]; GIT_ASSERT(def->free && def->parse); - if ((error = def->parse(object, odb_obj)) < 0) { + if ((error = def->parse(object, odb_obj, repo->oid_type)) < 0) { /* * parse returns EINVALID on invalid data; downgrade * that to a normal -1 error code. @@ -357,12 +361,11 @@ static int dereference_object(git_object **dereferenced, git_object *obj) static int peel_error(int error, const git_oid *oid, git_object_t type) { const char *type_name; - char hex_oid[GIT_OID_SHA1_HEXSIZE + 1]; + char hex_oid[GIT_OID_MAX_HEXSIZE + 1]; type_name = git_object_type2string(type); - git_oid_fmt(hex_oid, oid); - hex_oid[GIT_OID_SHA1_HEXSIZE] = '\0'; + git_oid_nfmt(hex_oid, GIT_OID_MAX_HEXSIZE + 1, oid); git_error_set(GIT_ERROR_OBJECT, "the git_object of id '%s' can not be " "successfully peeled into a %s (git_object_t=%i).", hex_oid, type_name, type); @@ -576,21 +579,29 @@ int git_object_rawcontent_is_valid( int *valid, const char *buf, size_t len, - git_object_t type) + git_object_t object_type +#ifdef GIT_EXPERIMENTAL_SHA256 + , git_oid_t oid_type +#endif + ) { git_object *obj = NULL; int error; +#ifndef GIT_EXPERIMENTAL_SHA256 + git_oid_t oid_type = GIT_OID_SHA1; +#endif + GIT_ASSERT_ARG(valid); GIT_ASSERT_ARG(buf); /* Blobs are always valid; don't bother parsing. */ - if (type == GIT_OBJECT_BLOB) { + if (object_type == GIT_OBJECT_BLOB) { *valid = 1; return 0; } - error = git_object__from_raw(&obj, buf, len, type); + error = git_object__from_raw(&obj, buf, len, object_type, oid_type); git_object_free(obj); if (error == 0) { @@ -611,7 +622,7 @@ int git_object__parse_oid_header( const char *header, git_oid_t oid_type) { - const size_t sha_len = GIT_OID_SHA1_HEXSIZE; + const size_t sha_len = git_oid_hexsize(oid_type); const size_t header_len = strlen(header); const char *buffer = *buffer_out; diff --git a/src/libgit2/object.h b/src/libgit2/object.h index 980e8627e47..a29fdfbf3dd 100644 --- a/src/libgit2/object.h +++ b/src/libgit2/object.h @@ -33,7 +33,8 @@ int git_object__from_raw( git_object **object_out, const char *data, size_t size, - git_object_t type); + git_object_t object_type, + git_oid_t oid_type); int git_object__from_odb_object( git_object **object_out, diff --git a/src/libgit2/odb_pack.c b/src/libgit2/odb_pack.c index 814c0bc7550..1b1d122b06c 100644 --- a/src/libgit2/odb_pack.c +++ b/src/libgit2/odb_pack.c @@ -718,6 +718,7 @@ static int pack_backend__writepack(struct git_odb_writepack **out, git_indexer_options opts = GIT_INDEXER_OPTIONS_INIT; struct pack_backend *backend; struct pack_writepack *writepack; + int error; GIT_ASSERT_ARG(out); GIT_ASSERT_ARG(_backend); @@ -732,11 +733,20 @@ static int pack_backend__writepack(struct git_odb_writepack **out, writepack = git__calloc(1, sizeof(struct pack_writepack)); GIT_ERROR_CHECK_ALLOC(writepack); - if (git_indexer_new(&writepack->indexer, - backend->pack_folder, 0, odb, &opts) < 0) { - git__free(writepack); +#ifdef GIT_EXPERIMENTAL_SHA256 + opts.odb = odb; + + error = git_indexer_new(&writepack->indexer, + backend->pack_folder, + backend->opts.oid_type, + &opts); +#else + error = git_indexer_new(&writepack->indexer, + backend->pack_folder, 0, odb, &opts); +#endif + + if (error < 0) return -1; - } writepack->parent.backend = _backend; writepack->parent.append = pack_backend__writepack_append; diff --git a/src/libgit2/pack-objects.c b/src/libgit2/pack-objects.c index 068231649ad..20a5dfcbdd5 100644 --- a/src/libgit2/pack-objects.c +++ b/src/libgit2/pack-objects.c @@ -1407,7 +1407,18 @@ int git_packbuilder_write( opts.progress_cb = progress_cb; opts.progress_cb_payload = progress_cb_payload; - if ((error = git_indexer_new(&indexer, path, mode, pb->odb, &opts)) < 0) + /* TODO: SHA256 */ + +#ifdef GIT_EXPERIMENTAL_SHA256 + opts.mode = mode; + opts.odb = pb->odb; + + error = git_indexer_new(&indexer, path, GIT_OID_SHA1, &opts); +#else + error = git_indexer_new(&indexer, path, mode, pb->odb, &opts); +#endif + + if (error < 0) goto cleanup; if (!git_repository__configmap_lookup(&t, pb->repo, GIT_CONFIGMAP_FSYNCOBJECTFILES) && t) diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index 043cfd1fd6f..2da6caf3a32 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -1278,11 +1278,14 @@ int git_repository_odb__weakptr(git_odb **out, git_repository *repo) *out = git_atomic_load(repo->_odb); if (*out == NULL) { git_str odb_path = GIT_STR_INIT; + git_odb_options odb_opts = GIT_ODB_OPTIONS_INIT; git_odb *odb; + odb_opts.oid_type = repo->oid_type; + if ((error = git_repository__item_path(&odb_path, repo, GIT_REPOSITORY_ITEM_OBJECTS)) < 0 || - (error = git_odb__new(&odb, NULL)) < 0) + (error = git_odb__new(&odb, &odb_opts)) < 0) return error; GIT_REFCOUNT_OWN(odb, repo); diff --git a/src/libgit2/tag.c b/src/libgit2/tag.c index 0a90e393cc9..562ec13eaed 100644 --- a/src/libgit2/tag.c +++ b/src/libgit2/tag.c @@ -65,7 +65,11 @@ static int tag_error(const char *str) return GIT_EINVALID; } -static int tag_parse(git_tag *tag, const char *buffer, const char *buffer_end) +static int tag_parse( + git_tag *tag, + const char *buffer, + const char *buffer_end, + git_oid_t oid_type) { static const char *tag_types[] = { NULL, "commit\n", "tree\n", "blob\n", "tag\n" @@ -76,7 +80,7 @@ static int tag_parse(git_tag *tag, const char *buffer, const char *buffer_end) int error; if (git_object__parse_oid_header(&tag->target, - &buffer, buffer_end, "object ", GIT_OID_SHA1) < 0) + &buffer, buffer_end, "object ", oid_type) < 0) return tag_error("object field invalid"); if (buffer + 5 >= buffer_end) @@ -161,18 +165,25 @@ static int tag_parse(git_tag *tag, const char *buffer, const char *buffer_end) return 0; } -int git_tag__parse_raw(void *_tag, const char *data, size_t size) +int git_tag__parse_raw( + void *_tag, + const char *data, + size_t size, + git_oid_t oid_type) { - return tag_parse(_tag, data, data + size); + return tag_parse(_tag, data, data + size, oid_type); } -int git_tag__parse(void *_tag, git_odb_object *odb_obj) +int git_tag__parse( + void *_tag, + git_odb_object *odb_obj, + git_oid_t oid_type) { git_tag *tag = _tag; const char *buffer = git_odb_object_data(odb_obj); const char *buffer_end = buffer + git_odb_object_size(odb_obj); - return tag_parse(tag, buffer, buffer_end); + return tag_parse(tag, buffer, buffer_end, oid_type); } static int retrieve_tag_reference( @@ -374,7 +385,7 @@ int git_tag_create_from_buffer(git_oid *oid, git_repository *repo, const char *b return -1; /* validate the buffer */ - if (tag_parse(&tag, buffer, buffer + strlen(buffer)) < 0) + if (tag_parse(&tag, buffer, buffer + strlen(buffer), repo->oid_type) < 0) return -1; /* validate the target */ diff --git a/src/libgit2/tag.h b/src/libgit2/tag.h index 76ae1508eaa..fdaaa463ccf 100644 --- a/src/libgit2/tag.h +++ b/src/libgit2/tag.h @@ -25,7 +25,7 @@ struct git_tag { }; void git_tag__free(void *tag); -int git_tag__parse(void *tag, git_odb_object *obj); -int git_tag__parse_raw(void *tag, const char *data, size_t size); +int git_tag__parse(void *tag, git_odb_object *obj, git_oid_t oid_type); +int git_tag__parse_raw(void *tag, const char *data, size_t size, git_oid_t oid_type); #endif diff --git a/src/libgit2/tree.c b/src/libgit2/tree.c index 9a43d585c4f..9293d9422ba 100644 --- a/src/libgit2/tree.c +++ b/src/libgit2/tree.c @@ -85,11 +85,17 @@ static git_tree_entry *alloc_entry(const char *filename, size_t filename_len, co char *filename_ptr; size_t tree_len; +#ifdef GIT_EXPERIMENTAL_SHA256 + size_t oid_size = git_oid_size(id->type); +#else + size_t oid_size = GIT_OID_SHA1_SIZE; +#endif + TREE_ENTRY_CHECK_NAMELEN(filename_len); if (GIT_ADD_SIZET_OVERFLOW(&tree_len, sizeof(git_tree_entry), filename_len) || GIT_ADD_SIZET_OVERFLOW(&tree_len, tree_len, 1) || - GIT_ADD_SIZET_OVERFLOW(&tree_len, tree_len, GIT_OID_SHA1_SIZE)) + GIT_ADD_SIZET_OVERFLOW(&tree_len, tree_len, oid_size)) return NULL; entry = git__calloc(1, tree_len); @@ -383,11 +389,12 @@ static int parse_mode(uint16_t *mode_out, const char *buffer, size_t buffer_len, return 0; } -int git_tree__parse_raw(void *_tree, const char *data, size_t size) +int git_tree__parse_raw(void *_tree, const char *data, size_t size, git_oid_t oid_type) { git_tree *tree = _tree; const char *buffer; const char *buffer_end; + const long oid_size = (long)git_oid_size(oid_type); buffer = data; buffer_end = buffer + size; @@ -414,35 +421,33 @@ int git_tree__parse_raw(void *_tree, const char *data, size_t size) if ((filename_len = nul - buffer) == 0 || filename_len > UINT16_MAX) return tree_parse_error("failed to parse tree: can't parse filename", NULL); - if ((buffer_end - (nul + 1)) < GIT_OID_SHA1_SIZE) + if ((buffer_end - (nul + 1)) < (long)oid_size) return tree_parse_error("failed to parse tree: can't parse OID", NULL); /* Allocate the entry */ - { - entry = git_array_alloc(tree->entries); - GIT_ERROR_CHECK_ALLOC(entry); - - entry->attr = attr; - entry->filename_len = (uint16_t)filename_len; - entry->filename = buffer; - git_oid__fromraw(&entry->oid, ((unsigned char *) buffer + filename_len + 1), GIT_OID_SHA1); - } + entry = git_array_alloc(tree->entries); + GIT_ERROR_CHECK_ALLOC(entry); + entry->attr = attr; + entry->filename_len = (uint16_t)filename_len; + entry->filename = buffer; buffer += filename_len + 1; - buffer += GIT_OID_SHA1_SIZE; + + git_oid__fromraw(&entry->oid, (unsigned char *)buffer, oid_type); + buffer += oid_size; } return 0; } -int git_tree__parse(void *_tree, git_odb_object *odb_obj) +int git_tree__parse(void *_tree, git_odb_object *odb_obj, git_oid_t oid_type) { git_tree *tree = _tree; const char *data = git_odb_object_data(odb_obj); size_t size = git_odb_object_size(odb_obj); int error; - if ((error = git_tree__parse_raw(tree, data, size)) < 0 || + if ((error = git_tree__parse_raw(tree, data, size, oid_type)) < 0 || (error = git_odb_object_dup(&tree->odb_obj, odb_obj)) < 0) return error; @@ -506,6 +511,7 @@ static int git_treebuilder__write_with_buffer( git_odb *odb; git_tree_entry *entry; git_vector entries = GIT_VECTOR_INIT; + size_t oid_size = git_oid_size(bld->repo->oid_type); git_str_clear(buf); @@ -529,7 +535,7 @@ static int git_treebuilder__write_with_buffer( git_str_printf(buf, "%o ", entry->attr); git_str_put(buf, entry->filename, entry->filename_len + 1); - git_str_put(buf, (char *)entry->oid.id, GIT_OID_SHA1_SIZE); + git_str_put(buf, (char *)entry->oid.id, oid_size); if (git_str_oom(buf)) { error = -1; diff --git a/src/libgit2/tree.h b/src/libgit2/tree.h index 0dd963ff291..5088450ab9b 100644 --- a/src/libgit2/tree.h +++ b/src/libgit2/tree.h @@ -41,8 +41,8 @@ GIT_INLINE(bool) git_tree_entry__is_tree(const struct git_tree_entry *e) } void git_tree__free(void *tree); -int git_tree__parse(void *tree, git_odb_object *obj); -int git_tree__parse_raw(void *_tree, const char *data, size_t size); +int git_tree__parse(void *tree, git_odb_object *obj, git_oid_t oid_type); +int git_tree__parse_raw(void *_tree, const char *data, size_t size, git_oid_t oid_type); /** * Write a tree to the given repository diff --git a/tests/libgit2/commit/parse.c b/tests/libgit2/commit/parse.c index b313fc3088b..3a1fc3d26bd 100644 --- a/tests/libgit2/commit/parse.c +++ b/tests/libgit2/commit/parse.c @@ -287,7 +287,7 @@ static int parse_commit(git_commit **out, const char *buffer) fake_odb_object.buffer = (char *)buffer; fake_odb_object.cached.size = strlen(fake_odb_object.buffer); - error = git_commit__parse(commit, &fake_odb_object); + error = git_commit__parse(commit, &fake_odb_object, GIT_OID_SHA1); *out = commit; return error; diff --git a/tests/libgit2/object/commit/parse.c b/tests/libgit2/object/commit/parse.c index 28a3ccd8525..6f9a6550789 100644 --- a/tests/libgit2/object/commit/parse.c +++ b/tests/libgit2/object/commit/parse.c @@ -3,7 +3,10 @@ #include "object.h" #include "signature.h" -static void assert_commit_parses(const char *data, size_t datalen, +static void assert_commit_parses( + const char *data, + size_t datalen, + git_oid_t oid_type, const char *expected_treeid, const char *expected_author, const char *expected_committer, @@ -14,7 +17,7 @@ static void assert_commit_parses(const char *data, size_t datalen, git_commit *commit; if (!datalen) datalen = strlen(data); - cl_git_pass(git_object__from_raw((git_object **) &commit, data, datalen, GIT_OBJECT_COMMIT)); + cl_git_pass(git_object__from_raw((git_object **) &commit, data, datalen, GIT_OBJECT_COMMIT, oid_type)); if (expected_author) { git_signature *author; @@ -51,7 +54,7 @@ static void assert_commit_parses(const char *data, size_t datalen, if (expected_treeid) { git_oid tree_oid; - cl_git_pass(git_oid__fromstr(&tree_oid, expected_treeid, GIT_OID_SHA1)); + cl_git_pass(git_oid__fromstr(&tree_oid, expected_treeid, oid_type)); cl_assert_equal_oid(&tree_oid, &commit->tree_id); } @@ -60,15 +63,18 @@ static void assert_commit_parses(const char *data, size_t datalen, git_object__free(&commit->object); } -static void assert_commit_fails(const char *data, size_t datalen) +static void assert_commit_fails( + const char *data, + size_t datalen, + git_oid_t oid_type) { git_object *object; if (!datalen) datalen = strlen(data); - cl_git_fail(git_object__from_raw(&object, data, datalen, GIT_OBJECT_COMMIT)); + cl_git_fail(git_object__from_raw(&object, data, datalen, GIT_OBJECT_COMMIT, oid_type)); } -void test_object_commit_parse__parsing_commit_succeeds(void) +void test_object_commit_parse__sha1_parsing_commit_succeeds(void) { const char *commit = "tree 3e7ac388cadacccdf1c6c5f3445895b71d9cb0f8\n" @@ -77,7 +83,7 @@ void test_object_commit_parse__parsing_commit_succeeds(void) "encoding Encoding\n" "\n" "Message"; - assert_commit_parses(commit, 0, + assert_commit_parses(commit, 0, GIT_OID_SHA1, "3e7ac388cadacccdf1c6c5f3445895b71d9cb0f8", "Author ", "Committer ", @@ -85,7 +91,7 @@ void test_object_commit_parse__parsing_commit_succeeds(void) "Message", 0); } -void test_object_commit_parse__parsing_commit_without_encoding_succeeds(void) +void test_object_commit_parse__sha1_parsing_commit_without_encoding_succeeds(void) { const char *commit = "tree 3e7ac388cadacccdf1c6c5f3445895b71d9cb0f8\n" @@ -93,7 +99,7 @@ void test_object_commit_parse__parsing_commit_without_encoding_succeeds(void) "committer Committer \n" "\n" "Message"; - assert_commit_parses(commit, 0, + assert_commit_parses(commit, 0, GIT_OID_SHA1, "3e7ac388cadacccdf1c6c5f3445895b71d9cb0f8", "Author ", "Committer ", @@ -101,7 +107,7 @@ void test_object_commit_parse__parsing_commit_without_encoding_succeeds(void) "Message", 0); } -void test_object_commit_parse__parsing_commit_with_multiple_authors_succeeds(void) +void test_object_commit_parse__sha1_parsing_commit_with_multiple_authors_succeeds(void) { const char *commit = "tree 3e7ac388cadacccdf1c6c5f3445895b71d9cb0f8\n" @@ -112,7 +118,7 @@ void test_object_commit_parse__parsing_commit_with_multiple_authors_succeeds(voi "committer Committer \n" "\n" "Message"; - assert_commit_parses(commit, 0, + assert_commit_parses(commit, 0, GIT_OID_SHA1, "3e7ac388cadacccdf1c6c5f3445895b71d9cb0f8", "Author1 ", "Committer ", @@ -120,7 +126,7 @@ void test_object_commit_parse__parsing_commit_with_multiple_authors_succeeds(voi "Message", 0); } -void test_object_commit_parse__parsing_commit_with_multiple_committers_succeeds(void) +void test_object_commit_parse__sha1_parsing_commit_with_multiple_committers_succeeds(void) { const char *commit = "tree 3e7ac388cadacccdf1c6c5f3445895b71d9cb0f8\n" @@ -131,7 +137,7 @@ void test_object_commit_parse__parsing_commit_with_multiple_committers_succeeds( "committer Committer4 \n" "\n" "Message"; - assert_commit_parses(commit, 0, + assert_commit_parses(commit, 0, GIT_OID_SHA1, "3e7ac388cadacccdf1c6c5f3445895b71d9cb0f8", "Author ", "Committer1 ", @@ -139,13 +145,13 @@ void test_object_commit_parse__parsing_commit_with_multiple_committers_succeeds( "Message", 0); } -void test_object_commit_parse__parsing_commit_without_message_succeeds(void) +void test_object_commit_parse__sha1_parsing_commit_without_message_succeeds(void) { const char *commit = "tree 3e7ac388cadacccdf1c6c5f3445895b71d9cb0f8\n" "author Author \n" "committer Committer \n"; - assert_commit_parses(commit, 0, + assert_commit_parses(commit, 0, GIT_OID_SHA1, "3e7ac388cadacccdf1c6c5f3445895b71d9cb0f8", "Author ", "Committer ", @@ -153,7 +159,7 @@ void test_object_commit_parse__parsing_commit_without_message_succeeds(void) "", 0); } -void test_object_commit_parse__parsing_commit_with_unknown_fields_succeeds(void) +void test_object_commit_parse__sha1_parsing_commit_with_unknown_fields_succeeds(void) { const char *commit = "tree 3e7ac388cadacccdf1c6c5f3445895b71d9cb0f8\n" @@ -163,7 +169,7 @@ void test_object_commit_parse__parsing_commit_with_unknown_fields_succeeds(void) "more garbage\n" "\n" "Message"; - assert_commit_parses(commit, 0, + assert_commit_parses(commit, 0, GIT_OID_SHA1, "3e7ac388cadacccdf1c6c5f3445895b71d9cb0f8", "Author ", "Committer ", @@ -171,7 +177,7 @@ void test_object_commit_parse__parsing_commit_with_unknown_fields_succeeds(void) "Message", 0); } -void test_object_commit_parse__parsing_commit_with_invalid_tree_fails(void) +void test_object_commit_parse__sha1_parsing_commit_with_invalid_tree_fails(void) { const char *commit = "tree 3e7ac388cadacccdf1xxx5f3445895b71d9cb0f8\n" @@ -179,40 +185,51 @@ void test_object_commit_parse__parsing_commit_with_invalid_tree_fails(void) "committer Committer \n" "\n" "Message"; - assert_commit_fails(commit, 0); + assert_commit_fails(commit, 0, GIT_OID_SHA1); } -void test_object_commit_parse__parsing_commit_without_tree_fails(void) +void test_object_commit_parse__sha1_parsing_commit_with_sha256_tree_fails(void) { const char *commit = + "tree f2a108f86a3b4fd9ad75ed55e9cb3cb46e348fca3b9dba3db64f7c9f64b8a736\n" "author Author \n" "committer Committer \n" "\n" "Message"; - assert_commit_fails(commit, 0); + assert_commit_fails(commit, 0, GIT_OID_SHA1); } -void test_object_commit_parse__parsing_commit_without_author_fails(void) +void test_object_commit_parse__sha1_parsing_commit_without_tree_fails(void) +{ + const char *commit = + "author Author \n" + "committer Committer \n" + "\n" + "Message"; + assert_commit_fails(commit, 0, GIT_OID_SHA1); +} + +void test_object_commit_parse__sha1_parsing_commit_without_author_fails(void) { const char *commit = "tree 3e7ac388cadacccdf1c6c5f3445895b71d9cb0f8\n" "committer Committer \n" "\n" "Message"; - assert_commit_fails(commit, 0); + assert_commit_fails(commit, 0, GIT_OID_SHA1); } -void test_object_commit_parse__parsing_commit_without_committer_fails(void) +void test_object_commit_parse__sha1_parsing_commit_without_committer_fails(void) { const char *commit = "tree 3e7ac388cadacccdf1c6c5f3445895b71d9cb0f8\n" "author Author \n" "\n" "Message"; - assert_commit_fails(commit, 0); + assert_commit_fails(commit, 0, GIT_OID_SHA1); } -void test_object_commit_parse__parsing_encoding_will_not_cause_oob_read(void) +void test_object_commit_parse__sha1_parsing_encoding_will_not_cause_oob_read(void) { const char *commit = "tree 3e7ac388cadacccdf1c6c5f3445895b71d9cb0f8\n" @@ -223,10 +240,237 @@ void test_object_commit_parse__parsing_encoding_will_not_cause_oob_read(void) * As we ignore unknown fields, the cut-off encoding field will be * parsed just fine. */ - assert_commit_parses(commit, strlen(commit) - strlen("ncoding foo\n"), + assert_commit_parses( + commit, strlen(commit) - strlen("ncoding foo\n"), + GIT_OID_SHA1, "3e7ac388cadacccdf1c6c5f3445895b71d9cb0f8", "<>", "<>", NULL, "", 0); } + + +void test_object_commit_parse__sha256_parsing_commit_succeeds(void) +{ +#ifndef GIT_EXPERIMENTAL_SHA256 + cl_skip(); +#else + const char *commit = + "tree f2a108f86a3b4fd9ad75ed55e9cb3cb46e348fca3b9dba3db64f7c9f64b8a736\n" + "author Author \n" + "committer Committer \n" + "encoding Encoding\n" + "\n" + "Message"; + assert_commit_parses(commit, 0, GIT_OID_SHA256, + "f2a108f86a3b4fd9ad75ed55e9cb3cb46e348fca3b9dba3db64f7c9f64b8a736", + "Author ", + "Committer ", + "Encoding", + "Message", 0); +#endif +} + +void test_object_commit_parse__sha256_parsing_commit_without_encoding_succeeds(void) +{ +#ifndef GIT_EXPERIMENTAL_SHA256 + cl_skip(); +#else + const char *commit = + "tree f2a108f86a3b4fd9ad75ed55e9cb3cb46e348fca3b9dba3db64f7c9f64b8a736\n" + "author Author \n" + "committer Committer \n" + "\n" + "Message"; + assert_commit_parses(commit, 0, GIT_OID_SHA256, + "f2a108f86a3b4fd9ad75ed55e9cb3cb46e348fca3b9dba3db64f7c9f64b8a736", + "Author ", + "Committer ", + NULL, + "Message", 0); +#endif +} + +void test_object_commit_parse__sha256_parsing_commit_with_multiple_authors_succeeds(void) +{ +#ifndef GIT_EXPERIMENTAL_SHA256 + cl_skip(); +#else + const char *commit = + "tree f2a108f86a3b4fd9ad75ed55e9cb3cb46e348fca3b9dba3db64f7c9f64b8a736\n" + "author Author1 \n" + "author Author2 \n" + "author Author3 \n" + "author Author4 \n" + "committer Committer \n" + "\n" + "Message"; + assert_commit_parses(commit, 0, GIT_OID_SHA256, + "f2a108f86a3b4fd9ad75ed55e9cb3cb46e348fca3b9dba3db64f7c9f64b8a736", + "Author1 ", + "Committer ", + NULL, + "Message", 0); +#endif +} + +void test_object_commit_parse__sha256_parsing_commit_with_multiple_committers_succeeds(void) +{ +#ifndef GIT_EXPERIMENTAL_SHA256 + cl_skip(); +#else + const char *commit = + "tree f2a108f86a3b4fd9ad75ed55e9cb3cb46e348fca3b9dba3db64f7c9f64b8a736\n" + "author Author \n" + "committer Committer1 \n" + "committer Committer2 \n" + "committer Committer3 \n" + "committer Committer4 \n" + "\n" + "Message"; + assert_commit_parses(commit, 0, GIT_OID_SHA256, + "f2a108f86a3b4fd9ad75ed55e9cb3cb46e348fca3b9dba3db64f7c9f64b8a736", + "Author ", + "Committer1 ", + NULL, + "Message", 0); +#endif +} + +void test_object_commit_parse__sha256_parsing_commit_without_message_succeeds(void) +{ +#ifndef GIT_EXPERIMENTAL_SHA256 + cl_skip(); +#else + const char *commit = + "tree f2a108f86a3b4fd9ad75ed55e9cb3cb46e348fca3b9dba3db64f7c9f64b8a736\n" + "author Author \n" + "committer Committer \n"; + assert_commit_parses(commit, 0, GIT_OID_SHA256, + "f2a108f86a3b4fd9ad75ed55e9cb3cb46e348fca3b9dba3db64f7c9f64b8a736", + "Author ", + "Committer ", + NULL, + "", 0); +#endif +} + +void test_object_commit_parse__sha256_parsing_commit_with_unknown_fields_succeeds(void) +{ +#ifndef GIT_EXPERIMENTAL_SHA256 + cl_skip(); +#else + const char *commit = + "tree f2a108f86a3b4fd9ad75ed55e9cb3cb46e348fca3b9dba3db64f7c9f64b8a736\n" + "author Author \n" + "committer Committer \n" + "foo bar\n" + "more garbage\n" + "\n" + "Message"; + assert_commit_parses(commit, 0, GIT_OID_SHA256, + "f2a108f86a3b4fd9ad75ed55e9cb3cb46e348fca3b9dba3db64f7c9f64b8a736", + "Author ", + "Committer ", + NULL, + "Message", 0); +#endif +} + +void test_object_commit_parse__sha256_parsing_commit_with_invalid_tree_fails(void) +{ +#ifndef GIT_EXPERIMENTAL_SHA256 + cl_skip(); +#else + const char *commit = + "tree f2a108f86a3b4fd9adxxxd55e9cb3cb46e348fca3b9dba3db64f7c9f64b8a736\n" + "author Author \n" + "committer Committer \n" + "\n" + "Message"; + assert_commit_fails(commit, 0, GIT_OID_SHA256); +#endif +} + +void test_object_commit_parse__sha256_parsing_commit_with_sha1_tree_fails(void) +{ +#ifndef GIT_EXPERIMENTAL_SHA256 + cl_skip(); +#else + const char *commit = + "tree 3e7ac388cadacccdf1c6c5f3445895b71d9cb0f8\n" + "author Author \n" + "committer Committer \n" + "\n" + "Message"; + assert_commit_fails(commit, 0, GIT_OID_SHA256); +#endif +} + +void test_object_commit_parse__sha256_parsing_commit_without_tree_fails(void) +{ +#ifndef GIT_EXPERIMENTAL_SHA256 + cl_skip(); +#else + const char *commit = + "author Author \n" + "committer Committer \n" + "\n" + "Message"; + assert_commit_fails(commit, 0, GIT_OID_SHA256); +#endif +} + +void test_object_commit_parse__sha256_parsing_commit_without_author_fails(void) +{ +#ifndef GIT_EXPERIMENTAL_SHA256 + cl_skip(); +#else + const char *commit = + "tree f2a108f86a3b4fd9ad75ed55e9cb3cb46e348fca3b9dba3db64f7c9f64b8a736\n" + "committer Committer \n" + "\n" + "Message"; + assert_commit_fails(commit, 0, GIT_OID_SHA256); +#endif +} + +void test_object_commit_parse__sha256_parsing_commit_without_committer_fails(void) +{ +#ifndef GIT_EXPERIMENTAL_SHA256 + cl_skip(); +#else + const char *commit = + "tree f2a108f86a3b4fd9ad75ed55e9cb3cb46e348fca3b9dba3db64f7c9f64b8a736\n" + "author Author \n" + "\n" + "Message"; + assert_commit_fails(commit, 0, GIT_OID_SHA256); +#endif +} + +void test_object_commit_parse__sha256_parsing_encoding_will_not_cause_oob_read(void) +{ +#ifndef GIT_EXPERIMENTAL_SHA256 + cl_skip(); +#else + const char *commit = + "tree f2a108f86a3b4fd9ad75ed55e9cb3cb46e348fca3b9dba3db64f7c9f64b8a736\n" + "author <>\n" + "committer <>\n" + "encoding foo\n"; + /* + * As we ignore unknown fields, the cut-off encoding field will be + * parsed just fine. + */ + assert_commit_parses( + commit, strlen(commit) - strlen("ncoding foo\n"), + GIT_OID_SHA256, + "f2a108f86a3b4fd9ad75ed55e9cb3cb46e348fca3b9dba3db64f7c9f64b8a736", + "<>", + "<>", + NULL, + "", 0); +#endif +} diff --git a/tests/libgit2/object/lookup256.c b/tests/libgit2/object/lookup256.c new file mode 100644 index 00000000000..3e1dab6610a --- /dev/null +++ b/tests/libgit2/object/lookup256.c @@ -0,0 +1,153 @@ +#include "clar_libgit2.h" + +#include "repository.h" + +#ifdef GIT_EXPERIMENTAL_SHA256 +static git_repository *g_repo; +#endif + +void test_object_lookup256__initialize(void) +{ +#ifdef GIT_EXPERIMENTAL_SHA256 + g_repo = cl_git_sandbox_init("testrepo_256.git"); +#endif +} + +void test_object_lookup256__cleanup(void) +{ +#ifdef GIT_EXPERIMENTAL_SHA256 + cl_git_sandbox_cleanup(); +#endif +} + +void test_object_lookup256__lookup_wrong_type_returns_enotfound(void) +{ +#ifndef GIT_EXPERIMENTAL_SHA256 + cl_skip(); +#else + const char *commit = "4d46d9719e425ef2dfb5bfba098d0b62e21b2b92d0731892eef70db0870e3744"; + git_oid oid; + git_object *object; + + cl_git_pass(git_oid__fromstr(&oid, commit, GIT_OID_SHA256)); + cl_assert_equal_i( + GIT_ENOTFOUND, git_object_lookup(&object, g_repo, &oid, GIT_OBJECT_TAG)); +#endif +} + +void test_object_lookup256__lookup_nonexisting_returns_enotfound(void) +{ +#ifndef GIT_EXPERIMENTAL_SHA256 + cl_skip(); +#else + const char *unknown = "deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef"; + git_oid oid; + git_object *object; + + cl_git_pass(git_oid__fromstr(&oid, unknown, GIT_OID_SHA256)); + cl_assert_equal_i( + GIT_ENOTFOUND, git_object_lookup(&object, g_repo, &oid, GIT_OBJECT_ANY)); +#endif +} + +void test_object_lookup256__lookup_wrong_type_by_abbreviated_id_returns_enotfound(void) +{ +#ifndef GIT_EXPERIMENTAL_SHA256 + cl_skip(); +#else + const char *commit = "4d46d97"; + git_oid oid; + git_object *object; + + cl_git_pass(git_oid__fromstrn(&oid, commit, strlen(commit), GIT_OID_SHA256)); + cl_assert_equal_i( + GIT_ENOTFOUND, git_object_lookup_prefix(&object, g_repo, &oid, strlen(commit), GIT_OBJECT_TAG)); +#endif +} + +void test_object_lookup256__lookup_wrong_type_eventually_returns_enotfound(void) +{ +#ifndef GIT_EXPERIMENTAL_SHA256 + cl_skip(); +#else + const char *commit = "4d46d9719e425ef2dfb5bfba098d0b62e21b2b92d0731892eef70db0870e3744"; + git_oid oid; + git_object *object; + + cl_git_pass(git_oid__fromstr(&oid, commit, GIT_OID_SHA256)); + + cl_git_pass(git_object_lookup(&object, g_repo, &oid, GIT_OBJECT_COMMIT)); + git_object_free(object); + + cl_assert_equal_i( + GIT_ENOTFOUND, git_object_lookup(&object, g_repo, &oid, GIT_OBJECT_TAG)); +#endif +} + +void test_object_lookup256__lookup_corrupt_object_returns_error(void) +{ +#ifndef GIT_EXPERIMENTAL_SHA256 + cl_skip(); +#else + const char *commit = "5ca8959deb2b8327458e0344523eb1ddeeef4bce03e35864640b452f84d26848", + *file = "objects/5c/a8959deb2b8327458e0344523eb1ddeeef4bce03e35864640b452f84d26848"; + git_str path = GIT_STR_INIT, contents = GIT_STR_INIT; + git_oid oid; + git_object *object; + size_t i; + + cl_git_pass(git_oid__fromstr(&oid, commit, GIT_OID_SHA256)); + cl_git_pass(git_str_joinpath(&path, git_repository_path(g_repo), file)); + cl_git_pass(git_futils_readbuffer(&contents, path.ptr)); + + /* Corrupt and try to read the object */ + for (i = 0; i < contents.size; i++) { + contents.ptr[i] ^= 0x1; + cl_git_pass(git_futils_writebuffer(&contents, path.ptr, O_RDWR, 0644)); + cl_git_fail(git_object_lookup(&object, g_repo, &oid, GIT_OBJECT_COMMIT)); + contents.ptr[i] ^= 0x1; + } + + /* Restore original content and assert we can read the object */ + cl_git_pass(git_futils_writebuffer(&contents, path.ptr, O_RDWR, 0644)); + cl_git_pass(git_object_lookup(&object, g_repo, &oid, GIT_OBJECT_COMMIT)); + + git_object_free(object); + git_str_dispose(&path); + git_str_dispose(&contents); +#endif +} + +void test_object_lookup256__lookup_object_with_wrong_hash_returns_error(void) +{ +#ifndef GIT_EXPERIMENTAL_SHA256 + cl_skip(); +#else + const char *oldloose = "objects/5c/a8959deb2b8327458e0344523eb1ddeeef4bce03e35864640b452f84d26848", + *newloose = "objects/5c/a8959deb2b8327458e0344523eb1ddeeef4bce03e35864640b452f84d26840", + *commit = "5ca8959deb2b8327458e0344523eb1ddeeef4bce03e35864640b452f84d26840"; + + git_str oldpath = GIT_STR_INIT, newpath = GIT_STR_INIT; + git_object *object; + git_oid oid; + + cl_git_pass(git_oid__fromstr(&oid, commit, GIT_OID_SHA256)); + + /* Copy object to another location with wrong hash */ + cl_git_pass(git_str_joinpath(&oldpath, git_repository_path(g_repo), oldloose)); + cl_git_pass(git_str_joinpath(&newpath, git_repository_path(g_repo), newloose)); + cl_git_pass(git_futils_cp(oldpath.ptr, newpath.ptr, 0644)); + + /* Verify that lookup fails due to a hashsum mismatch */ + cl_git_fail_with(GIT_EMISMATCH, git_object_lookup(&object, g_repo, &oid, GIT_OBJECT_COMMIT)); + + /* Disable verification and try again */ + cl_git_pass(git_libgit2_opts(GIT_OPT_ENABLE_STRICT_HASH_VERIFICATION, 0)); + cl_git_pass(git_object_lookup(&object, g_repo, &oid, GIT_OBJECT_COMMIT)); + cl_git_pass(git_libgit2_opts(GIT_OPT_ENABLE_STRICT_HASH_VERIFICATION, 1)); + + git_object_free(object); + git_str_dispose(&oldpath); + git_str_dispose(&newpath); +#endif +} diff --git a/tests/libgit2/object/tag/parse.c b/tests/libgit2/object/tag/parse.c index 92298b5ce4a..d7a4d85bfda 100644 --- a/tests/libgit2/object/tag/parse.c +++ b/tests/libgit2/object/tag/parse.c @@ -14,7 +14,7 @@ static void assert_tag_parses(const char *data, size_t datalen, if (!datalen) datalen = strlen(data); - cl_git_pass(git_object__from_raw((git_object **) &tag, data, datalen, GIT_OBJECT_TAG)); + cl_git_pass(git_object__from_raw((git_object **) &tag, data, datalen, GIT_OBJECT_TAG, GIT_OID_SHA1)); cl_assert_equal_i(tag->type, GIT_OBJECT_TAG); if (expected_oid) { @@ -54,7 +54,7 @@ static void assert_tag_fails(const char *data, size_t datalen) git_object *object; if (!datalen) datalen = strlen(data); - cl_git_fail(git_object__from_raw(&object, data, datalen, GIT_OBJECT_TAG)); + cl_git_fail(git_object__from_raw(&object, data, datalen, GIT_OBJECT_TAG, GIT_OID_SHA1)); } void test_object_tag_parse__valid_tag_parses(void) diff --git a/tests/libgit2/object/tree/parse.c b/tests/libgit2/object/tree/parse.c index d6d6e53026a..fc985d672d8 100644 --- a/tests/libgit2/object/tree/parse.c +++ b/tests/libgit2/object/tree/parse.c @@ -26,7 +26,7 @@ static void assert_tree_parses(const char *data, size_t datalen, if (!datalen) datalen = strlen(data); - cl_git_pass(git_object__from_raw((git_object **) &tree, data, datalen, GIT_OBJECT_TREE)); + cl_git_pass(git_object__from_raw((git_object **) &tree, data, datalen, GIT_OBJECT_TREE, GIT_OID_SHA1)); cl_assert_equal_i(git_tree_entrycount(tree), expected_nentries); @@ -51,7 +51,7 @@ static void assert_tree_fails(const char *data, size_t datalen) git_object *object; if (!datalen) datalen = strlen(data); - cl_git_fail(git_object__from_raw(&object, data, datalen, GIT_OBJECT_TREE)); + cl_git_fail(git_object__from_raw(&object, data, datalen, GIT_OBJECT_TREE, GIT_OID_SHA1)); } void test_object_tree_parse__single_blob_parses(void) diff --git a/tests/libgit2/object/validate.c b/tests/libgit2/object/validate.c index 87193deb64c..e11038115da 100644 --- a/tests/libgit2/object/validate.c +++ b/tests/libgit2/object/validate.c @@ -1,50 +1,154 @@ #include "clar_libgit2.h" -#define VALID_COMMIT "tree bdd24e358576f1baa275df98cdcaf3ac9a3f4233\n" \ - "parent d6d956f1d66210bfcd0484166befab33b5987a39\n" \ - "author Edward Thomson 1638286404 -0500\n" \ - "committer Edward Thomson 1638324642 -0500\n" \ - "\n" \ - "commit go here.\n" -#define VALID_TREE "100644 HEADER\0\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42" - -#define INVALID_COMMIT "tree bdd24e358576f1baa275df98cdcaf3ac9a3f4233\n" \ - "parent d6d956f1d66210bfcd0484166befab33b5987a39\n" \ - "committer Edward Thomson 1638324642 -0500\n" \ - "\n" \ - "commit go here.\n" -#define INVALID_TREE "100644 HEADER \x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42" - -void test_object_validate__valid(void) +#define VALID_COMMIT_SHA1 \ + "tree bdd24e358576f1baa275df98cdcaf3ac9a3f4233\n" \ + "parent d6d956f1d66210bfcd0484166befab33b5987a39\n" \ + "author Edward Thomson 1638286404 -0500\n" \ + "committer Edward Thomson 1638324642 -0500\n" \ + "\n" \ + "commit go here.\n" + +#define VALID_TREE_SHA1 \ + "100644 HEADER\0\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42" + +#define INVALID_COMMIT_SHA1 \ + "tree bdd24e358576f1baa275df98cdcaf3ac9a3f4233\n" \ + "parent d6d956f1d66210bfcd0484166befab33b5987a39\n" \ + "committer Edward Thomson 1638324642 -0500\n" \ + "\n" \ + "commit go here.\n" + +#define INVALID_TREE_SHA1 \ + "100644 HEADER \x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42" + +#define VALID_COMMIT_SHA256 \ + "tree d0fc7f52dc42358506e7f3f3be72f5271994abb104b9397ab3e19bb42361504d\n" \ + "parent 652412419a24ba62a1d897f40aeb80eecbf873797b04a1bbb8d71918653ef65b\n" \ + "author Edward Thomson 1638286404 -0500\n" \ + "committer Edward Thomson 1638324642 -0500\n" \ + "\n" \ + "commit go here.\n" + +#define VALID_TREE_SHA256 \ + "100644 HEADER\0\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42" + +#define INVALID_COMMIT_SHA256 \ + "tree d0fc7f52dc42358506e7f3f3be72f5271994abb104b9397ab3e19bb42361504d\n" \ + "parent 652412419a24ba62a1d897f40aeb80eecbf873797b04a1bbb8d71918653ef65b\n" \ + "committer Edward Thomson 1638324642 -0500\n" \ + "\n" \ + "commit go here.\n" + +#define INVALID_TREE_SHA256 \ + "100644 HEADER \x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42" + +#ifdef GIT_EXPERIMENTAL_SHA256 +# define sha1_rawcontent_is_valid(v, c, l, t) \ + git_object_rawcontent_is_valid(v, c, l, t, GIT_OID_SHA1) +#else +# define sha1_rawcontent_is_valid(v, c, l, t) \ + git_object_rawcontent_is_valid(v, c, l, t) +#endif + +void test_object_validate__valid_sha1(void) +{ + int valid; + + cl_git_pass(sha1_rawcontent_is_valid(&valid, "", 0, GIT_OBJECT_BLOB)); + cl_assert_equal_i(1, valid); + + cl_git_pass(sha1_rawcontent_is_valid(&valid, "foobar", 0, GIT_OBJECT_BLOB)); + cl_assert_equal_i(1, valid); + + cl_git_pass(sha1_rawcontent_is_valid(&valid, VALID_COMMIT_SHA1, CONST_STRLEN(VALID_COMMIT_SHA1), GIT_OBJECT_COMMIT)); + cl_assert_equal_i(1, valid); + + cl_git_pass(sha1_rawcontent_is_valid(&valid, VALID_TREE_SHA1, CONST_STRLEN(VALID_TREE_SHA1), GIT_OBJECT_TREE)); + cl_assert_equal_i(1, valid); +} + +void test_object_validate__cannot_parse_sha256_as_sha1(void) +{ + int valid; + + cl_git_pass(sha1_rawcontent_is_valid(&valid, VALID_COMMIT_SHA256, CONST_STRLEN(INVALID_COMMIT_SHA256), GIT_OBJECT_COMMIT)); + cl_assert_equal_i(0, valid); + + cl_git_pass(sha1_rawcontent_is_valid(&valid, INVALID_TREE_SHA256, CONST_STRLEN(INVALID_TREE_SHA256), GIT_OBJECT_TREE)); + cl_assert_equal_i(0, valid); +} + +void test_object_validate__invalid_sha1(void) { int valid; - cl_git_pass(git_object_rawcontent_is_valid(&valid, "", 0, GIT_OBJECT_BLOB)); + cl_git_pass(sha1_rawcontent_is_valid(&valid, "", 0, GIT_OBJECT_COMMIT)); + cl_assert_equal_i(0, valid); + + cl_git_pass(sha1_rawcontent_is_valid(&valid, "foobar", 0, GIT_OBJECT_COMMIT)); + cl_assert_equal_i(0, valid); + + cl_git_pass(sha1_rawcontent_is_valid(&valid, INVALID_COMMIT_SHA1, CONST_STRLEN(INVALID_COMMIT_SHA1), GIT_OBJECT_COMMIT)); + cl_assert_equal_i(0, valid); + + cl_git_pass(sha1_rawcontent_is_valid(&valid, INVALID_TREE_SHA1, CONST_STRLEN(INVALID_TREE_SHA1), GIT_OBJECT_TREE)); + cl_assert_equal_i(0, valid); +} + + +void test_object_validate__valid_sha256(void) +{ +#ifndef GIT_EXPERIMENTAL_SHA256 + cl_skip(); +#else + int valid; + + cl_git_pass(git_object_rawcontent_is_valid(&valid, "", 0, GIT_OBJECT_BLOB, GIT_OID_SHA256)); cl_assert_equal_i(1, valid); - cl_git_pass(git_object_rawcontent_is_valid(&valid, "foobar", 0, GIT_OBJECT_BLOB)); + cl_git_pass(git_object_rawcontent_is_valid(&valid, "foobar", 0, GIT_OBJECT_BLOB, GIT_OID_SHA256)); cl_assert_equal_i(1, valid); - cl_git_pass(git_object_rawcontent_is_valid(&valid, VALID_COMMIT, CONST_STRLEN(VALID_COMMIT), GIT_OBJECT_COMMIT)); + cl_git_pass(git_object_rawcontent_is_valid(&valid, VALID_COMMIT_SHA256, CONST_STRLEN(VALID_COMMIT_SHA256), GIT_OBJECT_COMMIT, GIT_OID_SHA256)); cl_assert_equal_i(1, valid); - cl_git_pass(git_object_rawcontent_is_valid(&valid, VALID_TREE, CONST_STRLEN(VALID_TREE), GIT_OBJECT_TREE)); + cl_git_pass(git_object_rawcontent_is_valid(&valid, VALID_TREE_SHA256, CONST_STRLEN(VALID_TREE_SHA256), GIT_OBJECT_TREE, GIT_OID_SHA256)); cl_assert_equal_i(1, valid); +#endif } -void test_object_validate__invalid(void) +void test_object_validate__invalid_sha256(void) { +#ifndef GIT_EXPERIMENTAL_SHA256 + cl_skip(); +#else int valid; - cl_git_pass(git_object_rawcontent_is_valid(&valid, "", 0, GIT_OBJECT_COMMIT)); + cl_git_pass(git_object_rawcontent_is_valid(&valid, "", 0, GIT_OBJECT_COMMIT, GIT_OID_SHA256)); + cl_assert_equal_i(0, valid); + + cl_git_pass(git_object_rawcontent_is_valid(&valid, "foobar", 0, GIT_OBJECT_COMMIT, GIT_OID_SHA256)); cl_assert_equal_i(0, valid); - cl_git_pass(git_object_rawcontent_is_valid(&valid, "foobar", 0, GIT_OBJECT_COMMIT)); + cl_git_pass(git_object_rawcontent_is_valid(&valid, INVALID_COMMIT_SHA256, CONST_STRLEN(INVALID_COMMIT_SHA256), GIT_OBJECT_COMMIT, GIT_OID_SHA256)); cl_assert_equal_i(0, valid); - cl_git_pass(git_object_rawcontent_is_valid(&valid, INVALID_COMMIT, CONST_STRLEN(INVALID_COMMIT), GIT_OBJECT_COMMIT)); + cl_git_pass(git_object_rawcontent_is_valid(&valid, INVALID_TREE_SHA256, CONST_STRLEN(INVALID_TREE_SHA256), GIT_OBJECT_TREE, GIT_OID_SHA256)); + cl_assert_equal_i(0, valid); +#endif +} + +void test_object_validate__cannot_parse_sha1_as_sha256(void) +{ +#ifndef GIT_EXPERIMENTAL_SHA256 + cl_skip(); +#else + int valid; + + cl_git_pass(git_object_rawcontent_is_valid(&valid, VALID_COMMIT_SHA1, CONST_STRLEN(INVALID_COMMIT_SHA1), GIT_OBJECT_COMMIT, GIT_OID_SHA256)); cl_assert_equal_i(0, valid); - cl_git_pass(git_object_rawcontent_is_valid(&valid, INVALID_TREE, CONST_STRLEN(INVALID_TREE), GIT_OBJECT_TREE)); + cl_git_pass(git_object_rawcontent_is_valid(&valid, INVALID_TREE_SHA1, CONST_STRLEN(INVALID_TREE_SHA1), GIT_OBJECT_TREE, GIT_OID_SHA256)); cl_assert_equal_i(0, valid); +#endif } diff --git a/tests/libgit2/pack/indexer.c b/tests/libgit2/pack/indexer.c index 2ac2872554f..9722decafc0 100644 --- a/tests/libgit2/pack/indexer.c +++ b/tests/libgit2/pack/indexer.c @@ -100,7 +100,12 @@ void test_pack_indexer__out_of_order(void) git_indexer *idx = 0; git_indexer_progress stats = { 0 }; +#ifdef GIT_EXPERIMENTAL_SHA256 + cl_git_pass(git_indexer_new(&idx, ".", GIT_OID_SHA1, NULL)); +#else cl_git_pass(git_indexer_new(&idx, ".", 0, NULL, NULL)); +#endif + cl_git_pass(git_indexer_append( idx, out_of_order_pack, out_of_order_pack_len, &stats)); cl_git_pass(git_indexer_commit(idx, &stats)); @@ -117,7 +122,12 @@ void test_pack_indexer__missing_trailer(void) git_indexer *idx = 0; git_indexer_progress stats = { 0 }; +#ifdef GIT_EXPERIMENTAL_SHA256 + cl_git_pass(git_indexer_new(&idx, ".", GIT_OID_SHA1, NULL)); +#else cl_git_pass(git_indexer_new(&idx, ".", 0, NULL, NULL)); +#endif + cl_git_pass(git_indexer_append( idx, missing_trailer_pack, missing_trailer_pack_len, &stats)); cl_git_fail(git_indexer_commit(idx, &stats)); @@ -133,7 +143,12 @@ void test_pack_indexer__leaky(void) git_indexer *idx = 0; git_indexer_progress stats = { 0 }; +#ifdef GIT_EXPERIMENTAL_SHA256 + cl_git_pass(git_indexer_new(&idx, ".", GIT_OID_SHA1, NULL)); +#else cl_git_pass(git_indexer_new(&idx, ".", 0, NULL, NULL)); +#endif + cl_git_pass(git_indexer_append( idx, leaky_pack, leaky_pack_len, &stats)); cl_git_fail(git_indexer_commit(idx, &stats)); @@ -151,6 +166,7 @@ void test_pack_indexer__fix_thin(void) git_repository *repo; git_odb *odb; git_oid id, should_id; + git_indexer_options opts = GIT_INDEXER_OPTIONS_INIT; cl_git_pass(git_repository_init(&repo, "thin.git", true)); cl_git_pass(git_repository_odb(&odb, repo)); @@ -160,7 +176,13 @@ void test_pack_indexer__fix_thin(void) git_oid__fromstr(&should_id, "e68fe8129b546b101aee9510c5328e7f21ca1d18", GIT_OID_SHA1); cl_assert_equal_oid(&should_id, &id); - cl_git_pass(git_indexer_new(&idx, ".", 0, odb, NULL)); +#ifdef GIT_EXPERIMENTAL_SHA256 + opts.odb = odb; + cl_git_pass(git_indexer_new(&idx, ".", GIT_OID_SHA1, &opts)); +#else + cl_git_pass(git_indexer_new(&idx, ".", 0, odb, &opts)); +#endif + cl_git_pass(git_indexer_append(idx, thin_pack, thin_pack_len, &stats)); cl_git_pass(git_indexer_commit(idx, &stats)); @@ -192,7 +214,12 @@ void test_pack_indexer__fix_thin(void) cl_git_pass(p_stat(name, &st)); +#ifdef GIT_EXPERIMENTAL_SHA256 + cl_git_pass(git_indexer_new(&idx, ".", GIT_OID_SHA1, NULL)); +#else cl_git_pass(git_indexer_new(&idx, ".", 0, NULL, NULL)); +#endif + read = p_read(fd, buffer, sizeof(buffer)); cl_assert(read != -1); p_close(fd); @@ -216,6 +243,7 @@ void test_pack_indexer__corrupt_length(void) git_repository *repo; git_odb *odb; git_oid id, should_id; + git_indexer_options opts = GIT_INDEXER_OPTIONS_INIT; cl_git_pass(git_repository_init(&repo, "thin.git", true)); cl_git_pass(git_repository_odb(&odb, repo)); @@ -225,7 +253,13 @@ void test_pack_indexer__corrupt_length(void) git_oid__fromstr(&should_id, "e68fe8129b546b101aee9510c5328e7f21ca1d18", GIT_OID_SHA1); cl_assert_equal_oid(&should_id, &id); - cl_git_pass(git_indexer_new(&idx, ".", 0, odb, NULL)); +#ifdef GIT_EXPERIMENTAL_SHA256 + opts.odb = odb; + cl_git_pass(git_indexer_new(&idx, ".", GIT_OID_SHA1, &opts)); +#else + cl_git_pass(git_indexer_new(&idx, ".", 0, odb, &opts)); +#endif + cl_git_pass(git_indexer_append( idx, corrupt_thin_pack, corrupt_thin_pack_len, &stats)); cl_git_fail(git_indexer_commit(idx, &stats)); @@ -246,7 +280,12 @@ void test_pack_indexer__incomplete_pack_fails_with_strict(void) opts.verify = 1; +#ifdef GIT_EXPERIMENTAL_SHA256 + cl_git_pass(git_indexer_new(&idx, ".", GIT_OID_SHA1, &opts)); +#else cl_git_pass(git_indexer_new(&idx, ".", 0, NULL, &opts)); +#endif + cl_git_pass(git_indexer_append( idx, incomplete_pack, incomplete_pack_len, &stats)); cl_git_fail(git_indexer_commit(idx, &stats)); @@ -266,7 +305,12 @@ void test_pack_indexer__out_of_order_with_connectivity_checks(void) opts.verify = 1; +#ifdef GIT_EXPERIMENTAL_SHA256 + cl_git_pass(git_indexer_new(&idx, ".", GIT_OID_SHA1, &opts)); +#else cl_git_pass(git_indexer_new(&idx, ".", 0, NULL, &opts)); +#endif + cl_git_pass(git_indexer_append( idx, out_of_order_pack, out_of_order_pack_len, &stats)); cl_git_pass(git_indexer_commit(idx, &stats)); @@ -309,7 +353,12 @@ void test_pack_indexer__no_tmp_files(void) git_str_dispose(&path); cl_assert(git_str_len(&first_tmp_file) == 0); +#ifdef GIT_EXPERIMENTAL_SHA256 + cl_git_pass(git_indexer_new(&idx, ".", GIT_OID_SHA1, NULL)); +#else cl_git_pass(git_indexer_new(&idx, ".", 0, NULL, NULL)); +#endif + git_indexer_free(idx); cl_git_pass(git_str_sets(&path, clar_sandbox_path())); diff --git a/tests/libgit2/pack/packbuilder.c b/tests/libgit2/pack/packbuilder.c index 0889f46eddb..ff3dc1f68aa 100644 --- a/tests/libgit2/pack/packbuilder.c +++ b/tests/libgit2/pack/packbuilder.c @@ -104,7 +104,12 @@ void test_pack_packbuilder__create_pack(void) seed_packbuilder(); +#ifdef GIT_EXPERIMENTAL_SHA256 + cl_git_pass(git_indexer_new(&_indexer, ".", GIT_OID_SHA1, NULL)); +#else cl_git_pass(git_indexer_new(&_indexer, ".", 0, NULL, NULL)); +#endif + cl_git_pass(git_packbuilder_foreach(_packbuilder, feed_indexer, &stats)); cl_git_pass(git_indexer_commit(_indexer, &stats)); @@ -244,7 +249,13 @@ void test_pack_packbuilder__foreach(void) git_indexer *idx; seed_packbuilder(); + +#ifdef GIT_EXPERIMENTAL_SHA256 + cl_git_pass(git_indexer_new(&idx, ".", GIT_OID_SHA1, NULL)); +#else cl_git_pass(git_indexer_new(&idx, ".", 0, NULL, NULL)); +#endif + cl_git_pass(git_packbuilder_foreach(_packbuilder, foreach_cb, idx)); cl_git_pass(git_indexer_commit(idx, &_stats)); git_indexer_free(idx); @@ -262,7 +273,13 @@ void test_pack_packbuilder__foreach_with_cancel(void) git_indexer *idx; seed_packbuilder(); + +#ifdef GIT_EXPERIMENTAL_SHA256 + cl_git_pass(git_indexer_new(&idx, ".", GIT_OID_SHA1, NULL)); +#else cl_git_pass(git_indexer_new(&idx, ".", 0, NULL, NULL)); +#endif + cl_git_fail_with( git_packbuilder_foreach(_packbuilder, foreach_cancel_cb, idx), -1111); git_indexer_free(idx); From e56f35076e0b669d6b226eb3b8808d84899e425b Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Wed, 21 Sep 2022 08:17:34 -0400 Subject: [PATCH 125/608] refdb: teach filesystem refdb about sha256 --- src/libgit2/refdb_fs.c | 109 ++++++++++++++++++++++++++--------------- src/libgit2/reflog.c | 14 +++--- src/libgit2/reflog.h | 3 +- 3 files changed, 78 insertions(+), 48 deletions(-) diff --git a/src/libgit2/refdb_fs.c b/src/libgit2/refdb_fs.c index 43283b3e472..9ce1a960833 100644 --- a/src/libgit2/refdb_fs.c +++ b/src/libgit2/refdb_fs.c @@ -60,15 +60,17 @@ typedef struct refdb_fs_backend { /* path to common objects' directory */ char *commonpath; - git_sortedcache *refcache; + git_oid_t oid_type; + + int fsync : 1, + sorted : 1; int peeling_mode; git_iterator_flag_t iterator_flags; uint32_t direach_flags; - int fsync; + git_sortedcache *refcache; git_map packed_refs_map; git_mutex prlock; /* protect packed_refs_map */ git_futils_filestamp packed_refs_stamp; - bool sorted; } refdb_fs_backend; static int refdb_reflog_fs__delete(git_refdb_backend *_backend, const char *name); @@ -113,6 +115,7 @@ static int packed_reload(refdb_fs_backend *backend) { int error; git_str packedrefs = GIT_STR_INIT; + size_t oid_hexsize = git_oid_hexsize(backend->oid_type); char *scan, *eof, *eol; if (!backend->gitpath) @@ -158,9 +161,9 @@ static int packed_reload(refdb_fs_backend *backend) /* parse " \n" */ - if (git_oid__fromstr(&oid, scan, GIT_OID_SHA1) < 0) + if (git_oid__fromstr(&oid, scan, backend->oid_type) < 0) goto parse_failed; - scan += GIT_OID_SHA1_HEXSIZE; + scan += oid_hexsize; if (*scan++ != ' ') goto parse_failed; @@ -179,9 +182,9 @@ static int packed_reload(refdb_fs_backend *backend) /* look for optional "^\n" */ if (*scan == '^') { - if (git_oid__fromstr(&oid, scan + 1, GIT_OID_SHA1) < 0) + if (git_oid__fromstr(&oid, scan + 1, backend->oid_type) < 0) goto parse_failed; - scan += GIT_OID_SHA1_HEXSIZE + 1; + scan += oid_hexsize + 1; if (scan < eof) { if (!(eol = strchr(scan, '\n'))) @@ -214,19 +217,23 @@ static int packed_reload(refdb_fs_backend *backend) } static int loose_parse_oid( - git_oid *oid, const char *filename, git_str *file_content) + git_oid *oid, + const char *filename, + git_str *file_content, + git_oid_t oid_type) { const char *str = git_str_cstr(file_content); + size_t oid_hexsize = git_oid_hexsize(oid_type); - if (git_str_len(file_content) < GIT_OID_SHA1_HEXSIZE) + if (git_str_len(file_content) < oid_hexsize) goto corrupted; /* we need to get 40 OID characters from the file */ - if (git_oid__fromstr(oid, str, GIT_OID_SHA1) < 0) + if (git_oid__fromstr(oid, str, oid_type) < 0) goto corrupted; /* If the file is longer than 40 chars, the 41st must be a space */ - str += GIT_OID_SHA1_HEXSIZE; + str += oid_hexsize; if (*str == '\0' || git__isspace(*str)) return 0; @@ -266,7 +273,7 @@ static int loose_lookup_to_packfile(refdb_fs_backend *backend, const char *name) goto done; /* parse OID from file */ - if ((error = loose_parse_oid(&oid, name, &ref_file)) < 0) + if ((error = loose_parse_oid(&oid, name, &ref_file, backend->oid_type)) < 0) goto done; if ((error = git_sortedcache_wlock(backend->refcache)) < 0) @@ -437,7 +444,7 @@ static int loose_lookup( } else { git_oid oid; - if (!(error = loose_parse_oid(&oid, ref_name, &ref_file)) && + if (!(error = loose_parse_oid(&oid, ref_name, &ref_file, backend->oid_type)) && out != NULL) *out = git_reference__alloc(ref_name, &oid, NULL); } @@ -615,19 +622,24 @@ static const char *end_of_record(const char *p, const char *end) return p; } -static int -cmp_record_to_refname(const char *rec, size_t data_end, const char *ref_name) +static int cmp_record_to_refname( + const char *rec, + size_t data_end, + const char *ref_name, + git_oid_t oid_type) { const size_t ref_len = strlen(ref_name); int cmp_val; const char *end; + size_t oid_hexsize = git_oid_hexsize(oid_type); - rec += GIT_OID_SHA1_HEXSIZE + 1; /* + space */ - if (data_end < GIT_OID_SHA1_HEXSIZE + 3) { - /* an incomplete (corrupt) record is treated as less than ref_name */ + rec += oid_hexsize + 1; /* + space */ + + /* an incomplete (corrupt) record is treated as less than ref_name */ + if (data_end < oid_hexsize + 3) return -1; - } - data_end -= GIT_OID_SHA1_HEXSIZE + 1; + + data_end -= oid_hexsize + 1; end = memchr(rec, '\n', data_end); if (end) @@ -675,6 +687,7 @@ static int packed_lookup( { int error = 0; const char *left, *right, *data_end; + size_t oid_hexsize = git_oid_hexsize(backend->oid_type); if ((error = packed_map_check(backend)) < 0) return error; @@ -698,7 +711,7 @@ static int packed_lookup( mid = left + (right - left) / 2; rec = start_of_record(left, mid); - compare = cmp_record_to_refname(rec, data_end - rec, ref_name); + compare = cmp_record_to_refname(rec, data_end - rec, ref_name, backend->oid_type); if (compare < 0) { left = end_of_record(mid, right); @@ -708,11 +721,11 @@ static int packed_lookup( const char *eol; git_oid oid, peel, *peel_ptr = NULL; - if (data_end - rec < GIT_OID_SHA1_HEXSIZE || - git_oid__fromstr(&oid, rec, GIT_OID_SHA1) < 0) { + if (data_end - rec < (long)oid_hexsize || + git_oid__fromstr(&oid, rec, backend->oid_type) < 0) { goto parse_failed; } - rec += GIT_OID_SHA1_HEXSIZE + 1; + rec += oid_hexsize + 1; if (!(eol = memchr(rec, '\n', data_end - rec))) { goto parse_failed; } @@ -724,8 +737,8 @@ static int packed_lookup( if (*rec == '^') { rec++; - if (data_end - rec < GIT_OID_SHA1_HEXSIZE || - git_oid__fromstr(&peel, rec, GIT_OID_SHA1) < 0) { + if (data_end - rec < (long)oid_hexsize || + git_oid__fromstr(&peel, rec, backend->oid_type) < 0) { goto parse_failed; } peel_ptr = &peel; @@ -1108,7 +1121,7 @@ static int loose_commit(git_filebuf *file, const git_reference *ref) GIT_ASSERT_ARG(ref); if (ref->type == GIT_REFERENCE_DIRECT) { - char oid[GIT_OID_SHA1_HEXSIZE + 1]; + char oid[GIT_OID_MAX_HEXSIZE + 1]; git_oid_nfmt(oid, sizeof(oid), &ref->target.oid); git_filebuf_printf(file, "%s\n", oid); @@ -1224,7 +1237,7 @@ static int packed_find_peel(refdb_fs_backend *backend, struct packref *ref) */ static int packed_write_ref(struct packref *ref, git_filebuf *file) { - char oid[GIT_OID_SHA1_HEXSIZE + 1]; + char oid[GIT_OID_MAX_HEXSIZE + 1]; git_oid_nfmt(oid, sizeof(oid), &ref->oid); /* @@ -1238,7 +1251,7 @@ static int packed_write_ref(struct packref *ref, git_filebuf *file) * The required peels have already been loaded into `ref->peel_target`. */ if (ref->flags & PACKREF_HAS_PEEL) { - char peel[GIT_OID_SHA1_HEXSIZE + 1]; + char peel[GIT_OID_MAX_HEXSIZE + 1]; git_oid_nfmt(peel, sizeof(peel), &ref->peel); if (git_filebuf_printf(file, "%s %s\n^%s\n", oid, ref->name, peel) < 0) @@ -1302,7 +1315,7 @@ static int packed_remove_loose(refdb_fs_backend *backend) continue; /* Figure out the current id; if we find a bad ref file, skip it so we can do the rest */ - if (loose_parse_oid(¤t_id, lock.path_original, &ref_content) < 0) + if (loose_parse_oid(¤t_id, lock.path_original, &ref_content, backend->oid_type) < 0) continue; /* If the ref moved since we packed it, we must not delete it */ @@ -1891,7 +1904,10 @@ static char *setup_namespace(git_repository *repo, const char *in) return out; } -static int reflog_alloc(git_reflog **reflog, const char *name) +static int reflog_alloc( + git_reflog **reflog, + const char *name, + git_oid_t oid_type) { git_reflog *log; @@ -1903,6 +1919,8 @@ static int reflog_alloc(git_reflog **reflog, const char *name) log->ref_name = git__strdup(name); GIT_ERROR_CHECK_ALLOC(log->ref_name); + log->oid_type = oid_type; + if (git_vector_init(&log->entries, 0, NULL) < 0) { git__free(log->ref_name); git__free(log); @@ -2032,7 +2050,10 @@ static int refdb_reflog_fs__has_log(git_refdb_backend *_backend, const char *nam return has_reflog(backend->repo, name); } -static int refdb_reflog_fs__read(git_reflog **out, git_refdb_backend *_backend, const char *name) +static int refdb_reflog_fs__read( + git_reflog **out, + git_refdb_backend *_backend, + const char *name) { int error = -1; git_str log_path = GIT_STR_INIT; @@ -2048,7 +2069,7 @@ static int refdb_reflog_fs__read(git_reflog **out, git_refdb_backend *_backend, backend = GIT_CONTAINER_OF(_backend, refdb_fs_backend, parent); repo = backend->repo; - if (reflog_alloc(&log, name) < 0) + if (reflog_alloc(&log, name, backend->oid_type) < 0) return -1; if (reflog_path(&log_path, repo, name) < 0) @@ -2086,11 +2107,11 @@ static int serialize_reflog_entry( const git_signature *committer, const char *msg) { - char raw_old[GIT_OID_SHA1_HEXSIZE+1]; - char raw_new[GIT_OID_SHA1_HEXSIZE+1]; + char raw_old[GIT_OID_MAX_HEXSIZE + 1]; + char raw_new[GIT_OID_MAX_HEXSIZE + 1]; - git_oid_tostr(raw_old, GIT_OID_SHA1_HEXSIZE+1, oid_old); - git_oid_tostr(raw_new, GIT_OID_SHA1_HEXSIZE+1, oid_new); + git_oid_tostr(raw_old, GIT_OID_MAX_HEXSIZE + 1, oid_old); + git_oid_tostr(raw_new, GIT_OID_MAX_HEXSIZE + 1, oid_new); git_str_clear(buf); @@ -2189,10 +2210,16 @@ static int refdb_reflog_fs__write(git_refdb_backend *_backend, git_reflog *reflo } /* Append to the reflog, must be called under reference lock */ -static int reflog_append(refdb_fs_backend *backend, const git_reference *ref, const git_oid *old, const git_oid *new, const git_signature *who, const char *message) +static int reflog_append( + refdb_fs_backend *backend, + const git_reference *ref, + const git_oid *old, + const git_oid *new, + const git_signature *who, + const char *message) { int error, is_symbolic, open_flags; - git_oid old_id = GIT_OID_SHA1_ZERO, new_id = GIT_OID_SHA1_ZERO; + git_oid old_id, new_id; git_str buf = GIT_STR_INIT, path = GIT_STR_INIT; git_repository *repo = backend->repo; @@ -2206,6 +2233,9 @@ static int reflog_append(refdb_fs_backend *backend, const git_reference *ref, co /* From here on is_symbolic also means that it's HEAD */ + git_oid_clear(&old_id, backend->oid_type); + git_oid_clear(&new_id, backend->oid_type); + if (old) { git_oid_cpy(&old_id, old); } else { @@ -2402,6 +2432,7 @@ int git_refdb_backend_fs( goto fail; backend->repo = repository; + backend->oid_type = repository->oid_type; if (repository->gitdir) { backend->gitpath = setup_namespace(repository, repository->gitdir); diff --git a/src/libgit2/reflog.c b/src/libgit2/reflog.c index eb0b7e48c1f..86d4355e336 100644 --- a/src/libgit2/reflog.c +++ b/src/libgit2/reflog.c @@ -71,7 +71,11 @@ int git_reflog_write(git_reflog *reflog) return db->backend->reflog_write(db->backend, reflog); } -int git_reflog_append(git_reflog *reflog, const git_oid *new_oid, const git_signature *committer, const char *msg) +int git_reflog_append( + git_reflog *reflog, + const git_oid *new_oid, + const git_signature *committer, + const char *msg) { const git_reflog_entry *previous; git_reflog_entry *entry; @@ -104,7 +108,7 @@ int git_reflog_append(git_reflog *reflog, const git_oid *new_oid, const git_sign previous = git_reflog_entry_byindex(reflog, 0); if (previous == NULL) - git_oid__fromstr(&entry->oid_old, GIT_OID_SHA1_HEXZERO, GIT_OID_SHA1); + git_oid_clear(&entry->oid_old, reflog->oid_type); else git_oid_cpy(&entry->oid_old, &previous->oid_cur); @@ -218,12 +222,8 @@ int git_reflog_drop(git_reflog *reflog, size_t idx, int rewrite_previous_entry) /* If the oldest entry has just been removed... */ if (idx == entrycount - 1) { - git_oid zero = GIT_OID_SHA1_ZERO; - /* ...clear the oid_old member of the "new" oldest entry */ - if (git_oid_cpy(&entry->oid_old, &zero) < 0) - return -1; - + git_oid_clear(&entry->oid_old, reflog->oid_type); return 0; } diff --git a/src/libgit2/reflog.h b/src/libgit2/reflog.h index 50d1056ed7e..bc98785981a 100644 --- a/src/libgit2/reflog.h +++ b/src/libgit2/reflog.h @@ -16,8 +16,6 @@ #define GIT_REFLOG_DIR_MODE 0777 #define GIT_REFLOG_FILE_MODE 0666 -#define GIT_REFLOG_SIZE_MIN (2*GIT_OID_SHA1_HEXSIZE+2+17) - struct git_reflog_entry { git_oid oid_old; git_oid oid_cur; @@ -30,6 +28,7 @@ struct git_reflog_entry { struct git_reflog { git_refdb *db; char *ref_name; + git_oid_t oid_type; git_vector entries; }; From 7186d7baadfe3e5e129710e07bdd57b1c7c0e862 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Wed, 21 Sep 2022 08:25:58 -0400 Subject: [PATCH 126/608] revparse: don't assume SHA1 --- src/libgit2/revparse.c | 19 +++++++++++++------ 1 file changed, 13 insertions(+), 6 deletions(-) diff --git a/src/libgit2/revparse.c b/src/libgit2/revparse.c index 2ed28215957..bd13727ebc0 100644 --- a/src/libgit2/revparse.c +++ b/src/libgit2/revparse.c @@ -15,21 +15,28 @@ #include "git2.h" -static int maybe_sha_or_abbrev(git_object **out, git_repository *repo, const char *spec, size_t speclen) +static int maybe_sha_or_abbrev( + git_object **out, + git_repository *repo, + const char *spec, + size_t speclen) { git_oid oid; - if (git_oid__fromstrn(&oid, spec, speclen, GIT_OID_SHA1) < 0) + if (git_oid__fromstrn(&oid, spec, speclen, repo->oid_type) < 0) return GIT_ENOTFOUND; return git_object_lookup_prefix(out, repo, &oid, speclen, GIT_OBJECT_ANY); } -static int maybe_sha(git_object **out, git_repository *repo, const char *spec) +static int maybe_sha( + git_object **out, + git_repository *repo, + const char *spec) { size_t speclen = strlen(spec); - if (speclen != GIT_OID_SHA1_HEXSIZE) + if (speclen != git_oid_hexsize(repo->oid_type)) return GIT_ENOTFOUND; return maybe_sha_or_abbrev(out, repo, spec, speclen); @@ -110,8 +117,8 @@ static int revparse_lookup_object( if (error != GIT_ENOTFOUND) return error; - if ((strlen(spec) < GIT_OID_SHA1_HEXSIZE) && - ((error = maybe_abbrev(object_out, repo, spec)) != GIT_ENOTFOUND)) + if ((strlen(spec) < git_oid_hexsize(repo->oid_type)) && + ((error = maybe_abbrev(object_out, repo, spec)) != GIT_ENOTFOUND)) return error; if ((error = maybe_describe(object_out, repo, spec)) != GIT_ENOTFOUND) From 0006ff63359358bc5e65ea5a2b6ef7ba5eca2e8e Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Wed, 23 Nov 2022 22:05:29 +0000 Subject: [PATCH 127/608] clone: support sha256 --- ci/test.sh | 19 ++++ src/libgit2/transports/smart.h | 7 +- src/libgit2/transports/smart_pkt.c | 111 ++++++++++++++++++++---- src/libgit2/transports/smart_protocol.c | 13 ++- tests/libgit2/CMakeLists.txt | 1 + tests/libgit2/online/clone.c | 19 ++++ tests/libgit2/transports/smart/packet.c | 37 +++++--- 7 files changed, 173 insertions(+), 34 deletions(-) diff --git a/ci/test.sh b/ci/test.sh index 230daaaa0a4..95e6871e709 100755 --- a/ci/test.sh +++ b/ci/test.sh @@ -32,6 +32,11 @@ cleanup() { kill $GIT_NAMESPACE_PID fi + if [ ! -z "$GIT_SHA256_PID" ]; then + echo "Stopping git daemon (sha256)..." + kill $GIT_SHA256_PID + fi + if [ ! -z "$PROXY_BASIC_PID" ]; then echo "Stopping proxy (Basic)..." kill $PROXY_BASIC_PID @@ -114,6 +119,12 @@ if [ -z "$SKIP_GITDAEMON_TESTS" ]; then cp -R "${SOURCE_DIR}/tests/resources/namespace.git" "${GIT_NAMESPACE_DIR}/namespace.git" GIT_NAMESPACE="name1" git daemon --listen=localhost --port=9419 --export-all --enable=receive-pack --base-path="${GIT_NAMESPACE_DIR}" "${GIT_NAMESPACE_DIR}" & GIT_NAMESPACE_PID=$! + + echo "Starting git daemon (sha256)..." + GIT_SHA256_DIR=`mktemp -d ${TMPDIR}/git_sha256.XXXXXXXX` + cp -R "${SOURCE_DIR}/tests/resources/testrepo_256.git" "${GIT_SHA256_DIR}/testrepo_256.git" + git daemon --listen=localhost --port=9420 --export-all --enable=receive-pack --base-path="${GIT_SHA256_DIR}" "${GIT_SHA256_DIR}" & + GIT_SHA256_PID=$! fi if [ -z "$SKIP_PROXY_TESTS" ]; then @@ -261,6 +272,14 @@ if [ -z "$SKIP_GITDAEMON_TESTS" ]; then run_test gitdaemon_namespace unset GITTEST_REMOTE_URL unset GITTEST_REMOTE_BRANCH + + echo "" + echo "Running gitdaemon (sha256) tests" + echo "" + + export GITTEST_REMOTE_URL="git://localhost:9420/testrepo_256.git" + run_test gitdaemon_sha256 + unset GITTEST_REMOTE_URL fi if [ -z "$SKIP_PROXY_TESTS" ]; then diff --git a/src/libgit2/transports/smart.h b/src/libgit2/transports/smart.h index 9323d6c444e..ca649616317 100644 --- a/src/libgit2/transports/smart.h +++ b/src/libgit2/transports/smart.h @@ -182,7 +182,12 @@ int git_smart__get_push_stream(transport_smart *t, git_smart_subtransport_stream int git_smart__update_heads(transport_smart *t, git_vector *symrefs); /* smart_pkt.c */ -int git_pkt_parse_line(git_pkt **head, const char **endptr, const char *line, size_t linelen); +typedef struct { + git_oid_t oid_type; + int seen_capabilities: 1; +} git_pkt_parse_data; + +int git_pkt_parse_line(git_pkt **head, const char **endptr, const char *line, size_t linelen, git_pkt_parse_data *data); int git_pkt_buffer_flush(git_str *buf); int git_pkt_send_flush(GIT_SOCKET s); int git_pkt_buffer_done(git_str *buf); diff --git a/src/libgit2/transports/smart_pkt.c b/src/libgit2/transports/smart_pkt.c index e679819fa15..b6428d845e4 100644 --- a/src/libgit2/transports/smart_pkt.c +++ b/src/libgit2/transports/smart_pkt.c @@ -212,26 +212,87 @@ static int sideband_error_pkt(git_pkt **out, const char *line, size_t len) return 0; } +static int set_data( + git_pkt_parse_data *data, + const char *line, + size_t len) +{ + const char *caps, *format_str = NULL, *eos; + size_t format_len; + git_oid_t remote_oid_type; + + GIT_ASSERT_ARG(data); + + if ((caps = memchr(line, '\0', len)) != NULL) { + caps++; + + if (strncmp(caps, "object-format=", CONST_STRLEN("object-format=")) == 0) + format_str = caps + CONST_STRLEN("object-format="); + else if ((format_str = strstr(caps, " object-format=")) != NULL) + format_str += CONST_STRLEN(" object-format="); + } + + if (format_str) { + if ((eos = strchr(format_str, ' ')) == NULL) + eos = strchr(format_str, '\0'); + + GIT_ASSERT(eos); + + format_len = eos - format_str; + + if ((remote_oid_type = git_oid_type_fromstrn(format_str, format_len)) == 0) { + git_error_set(GIT_ERROR_INVALID, "unknown remote object format '%.*s'", (int)format_len, format_str); + return -1; + } + } else { + remote_oid_type = GIT_OID_SHA1; + } + + if (!data->oid_type) { + data->oid_type = remote_oid_type; + } else if (data->oid_type != remote_oid_type) { + git_error_set(GIT_ERROR_INVALID, + "the local object format '%s' does not match the remote object format '%s'", + git_oid_type_name(data->oid_type), + git_oid_type_name(remote_oid_type)); + return -1; + } + + return 0; +} + /* * Parse an other-ref line. */ -static int ref_pkt(git_pkt **out, const char *line, size_t len) +static int ref_pkt( + git_pkt **out, + const char *line, + size_t len, + git_pkt_parse_data *data) { git_pkt_ref *pkt; - size_t alloclen; + size_t alloclen, oid_hexsize; pkt = git__calloc(1, sizeof(git_pkt_ref)); GIT_ERROR_CHECK_ALLOC(pkt); pkt->type = GIT_PKT_REF; - if (len < GIT_OID_SHA1_HEXSIZE || - git_oid__fromstr(&pkt->head.oid, line, GIT_OID_SHA1) < 0) + /* Determine OID type from capabilities */ + if (!data->seen_capabilities && set_data(data, line, len) < 0) + return -1; + + GIT_ASSERT(data->oid_type); + oid_hexsize = git_oid_hexsize(data->oid_type); + + if (len < oid_hexsize || + git_oid__fromstr(&pkt->head.oid, line, data->oid_type) < 0) goto out_err; - line += GIT_OID_SHA1_HEXSIZE; - len -= GIT_OID_SHA1_HEXSIZE; + line += oid_hexsize; + len -= oid_hexsize; if (git__prefixncmp(line, len, " ")) goto out_err; + line++; len--; @@ -248,8 +309,14 @@ static int ref_pkt(git_pkt **out, const char *line, size_t len) memcpy(pkt->head.name, line, len); pkt->head.name[len] = '\0'; - if (strlen(pkt->head.name) < len) - pkt->capabilities = strchr(pkt->head.name, '\0') + 1; + if (strlen(pkt->head.name) < len) { + if (!data->seen_capabilities) + pkt->capabilities = strchr(pkt->head.name, '\0') + 1; + else + goto out_err; + } + + data->seen_capabilities = 1; *out = (git_pkt *)pkt; return 0; @@ -418,7 +485,11 @@ static int parse_len(size_t *out, const char *line, size_t linelen) */ int git_pkt_parse_line( - git_pkt **pkt, const char **endptr, const char *line, size_t linelen) + git_pkt **pkt, + const char **endptr, + const char *line, + size_t linelen, + git_pkt_parse_data *data) { int error; size_t len; @@ -493,7 +564,7 @@ int git_pkt_parse_line( else if (!git__prefixncmp(line, len, "unpack")) error = unpack_pkt(pkt, line, len); else - error = ref_pkt(pkt, line, len); + error = ref_pkt(pkt, line, len, data); *endptr = line + len; @@ -533,8 +604,11 @@ int git_pkt_buffer_flush(git_str *buf) static int buffer_want_with_caps(const git_remote_head *head, transport_smart_caps *caps, git_str *buf) { git_str str = GIT_STR_INIT; - char oid[GIT_OID_SHA1_HEXSIZE +1] = {0}; - size_t len; + char oid[GIT_OID_MAX_HEXSIZE + 1] = {0}; + size_t oid_hexsize, len; + + oid_hexsize = git_oid_hexsize(head->oid.type); + git_oid_fmt(oid, &head->oid); /* Prefer multi_ack_detailed */ if (caps->multi_ack_detailed) @@ -560,7 +634,7 @@ static int buffer_want_with_caps(const git_remote_head *head, transport_smart_ca if (git_str_oom(&str)) return -1; - len = strlen("XXXXwant ") + GIT_OID_SHA1_HEXSIZE + 1 /* NUL */ + + len = strlen("XXXXwant ") + oid_hexsize + 1 /* NUL */ + git_str_len(&str) + 1 /* LF */; if (len > 0xffff) { @@ -570,9 +644,9 @@ static int buffer_want_with_caps(const git_remote_head *head, transport_smart_ca } git_str_grow_by(buf, len); - git_oid_fmt(oid, &head->oid); git_str_printf(buf, - "%04xwant %s %s\n", (unsigned int)len, oid, git_str_cstr(&str)); + "%04xwant %.*s %s\n", (unsigned int)len, + (int)oid_hexsize, oid, git_str_cstr(&str)); git_str_dispose(&str); GIT_ERROR_CHECK_ALLOC_STR(buf); @@ -608,16 +682,19 @@ int git_pkt_buffer_wants( } for (; i < count; ++i) { - char oid[GIT_OID_SHA1_HEXSIZE]; + char oid[GIT_OID_MAX_HEXSIZE]; head = refs[i]; + if (head->local) continue; git_oid_fmt(oid, &head->oid); + git_str_put(buf, pkt_want_prefix, strlen(pkt_want_prefix)); - git_str_put(buf, oid, GIT_OID_SHA1_HEXSIZE); + git_str_put(buf, oid, git_oid_hexsize(head->oid.type)); git_str_putc(buf, '\n'); + if (git_str_oom(buf)) return -1; } diff --git a/src/libgit2/transports/smart_protocol.c b/src/libgit2/transports/smart_protocol.c index 88c208fb5d0..86d02df83bc 100644 --- a/src/libgit2/transports/smart_protocol.c +++ b/src/libgit2/transports/smart_protocol.c @@ -32,6 +32,7 @@ int git_smart__store_refs(transport_smart *t, int flushes) int error, flush = 0, recvd; const char *line_end = NULL; git_pkt *pkt = NULL; + git_pkt_parse_data pkt_parse_data = { 0 }; size_t i; /* Clear existing refs in case git_remote_connect() is called again @@ -45,7 +46,7 @@ int git_smart__store_refs(transport_smart *t, int flushes) do { if (buf->offset > 0) - error = git_pkt_parse_line(&pkt, &line_end, buf->data, buf->offset); + error = git_pkt_parse_line(&pkt, &line_end, buf->data, buf->offset, &pkt_parse_data); else error = GIT_EBUFS; @@ -228,11 +229,12 @@ static int recv_pkt(git_pkt **out_pkt, git_pkt_type *out_type, gitno_buffer *buf { const char *ptr = buf->data, *line_end = ptr; git_pkt *pkt = NULL; + git_pkt_parse_data pkt_parse_data = { 0 }; int error = 0, ret; do { if (buf->offset > 0) - error = git_pkt_parse_line(&pkt, &line_end, ptr, buf->offset); + error = git_pkt_parse_line(&pkt, &line_end, ptr, buf->offset, &pkt_parse_data); else error = GIT_EBUFS; @@ -723,6 +725,7 @@ static int add_push_report_pkt(git_push *push, git_pkt *pkt) static int add_push_report_sideband_pkt(git_push *push, git_pkt_data *data_pkt, git_str *data_pkt_buf) { git_pkt *pkt; + git_pkt_parse_data pkt_parse_data = { 0 }; const char *line, *line_end = NULL; size_t line_len; int error; @@ -741,7 +744,7 @@ static int add_push_report_sideband_pkt(git_push *push, git_pkt_data *data_pkt, } while (line_len > 0) { - error = git_pkt_parse_line(&pkt, &line_end, line, line_len); + error = git_pkt_parse_line(&pkt, &line_end, line, line_len, &pkt_parse_data); if (error == GIT_EBUFS) { /* Buffer the data when the inner packet is split @@ -777,6 +780,7 @@ static int add_push_report_sideband_pkt(git_push *push, git_pkt_data *data_pkt, static int parse_report(transport_smart *transport, git_push *push) { git_pkt *pkt = NULL; + git_pkt_parse_data pkt_parse_data = { 0 }; const char *line_end = NULL; gitno_buffer *buf = &transport->buffer; int error, recvd; @@ -785,7 +789,8 @@ static int parse_report(transport_smart *transport, git_push *push) for (;;) { if (buf->offset > 0) error = git_pkt_parse_line(&pkt, &line_end, - buf->data, buf->offset); + buf->data, buf->offset, + &pkt_parse_data); else error = GIT_EBUFS; diff --git a/tests/libgit2/CMakeLists.txt b/tests/libgit2/CMakeLists.txt index f581d3075b6..6cce150def4 100644 --- a/tests/libgit2/CMakeLists.txt +++ b/tests/libgit2/CMakeLists.txt @@ -70,6 +70,7 @@ add_clar_test(libgit2_tests online -v -sonline -xonline::customcert add_clar_test(libgit2_tests online_customcert -v -sonline::customcert) add_clar_test(libgit2_tests gitdaemon -v -sonline::push) add_clar_test(libgit2_tests gitdaemon_namespace -v -sonline::clone::namespace) +add_clar_test(libgit2_tests gitdaemon_sha256 -v -sonline::clone::sha256) add_clar_test(libgit2_tests ssh -v -sonline::push -sonline::clone::ssh_cert -sonline::clone::ssh_with_paths -sonline::clone::path_whitespace_ssh -sonline::clone::ssh_auth_methods) add_clar_test(libgit2_tests proxy -v -sonline::clone::proxy) add_clar_test(libgit2_tests auth_clone -v -sonline::clone::cred) diff --git a/tests/libgit2/online/clone.c b/tests/libgit2/online/clone.c index 96ff66ae06a..70ec4ef1a09 100644 --- a/tests/libgit2/online/clone.c +++ b/tests/libgit2/online/clone.c @@ -1058,3 +1058,22 @@ void test_online_clone__namespace_with_specified_branch(void) git_reference_free(head); } + +void test_online_clone__sha256(void) +{ +#ifndef GIT_EXPERIMENTAL_SHA256 + cl_skip(); +#else + git_clone_options options = GIT_CLONE_OPTIONS_INIT; + git_reference *head; + + if (!_remote_url) + cl_skip(); + + cl_git_pass(git_clone(&g_repo, _remote_url, "./sha256", &options)); + cl_git_pass(git_reference_lookup(&head, g_repo, GIT_HEAD_FILE)); + cl_assert_equal_i(GIT_REFERENCE_SYMBOLIC, git_reference_type(head)); + + git_reference_free(head); +#endif +} diff --git a/tests/libgit2/transports/smart/packet.c b/tests/libgit2/transports/smart/packet.c index 8801ef833f7..2035e3b65d0 100644 --- a/tests/libgit2/transports/smart/packet.c +++ b/tests/libgit2/transports/smart/packet.c @@ -11,8 +11,9 @@ static void assert_flush_parses(const char *line) size_t linelen = strlen(line) + 1; const char *endptr; git_pkt *pkt; + git_pkt_parse_data pkt_parse_data = { 0 }; - cl_git_pass(git_pkt_parse_line((git_pkt **) &pkt, &endptr, line, linelen)); + cl_git_pass(git_pkt_parse_line((git_pkt **) &pkt, &endptr, line, linelen, &pkt_parse_data)); cl_assert_equal_i(pkt->type, GIT_PKT_FLUSH); cl_assert_equal_strn(endptr, line + 4, linelen - 4); @@ -24,8 +25,9 @@ static void assert_data_pkt_parses(const char *line, const char *expected_data, size_t linelen = strlen(line) + 1; const char *endptr; git_pkt_data *pkt; + git_pkt_parse_data pkt_parse_data = { 0 }; - cl_git_pass(git_pkt_parse_line((git_pkt **) &pkt, &endptr, line, linelen)); + cl_git_pass(git_pkt_parse_line((git_pkt **) &pkt, &endptr, line, linelen, &pkt_parse_data)); cl_assert_equal_i(pkt->type, GIT_PKT_DATA); cl_assert_equal_i(pkt->len, expected_len); cl_assert_equal_strn(pkt->data, expected_data, expected_len); @@ -38,8 +40,9 @@ static void assert_sideband_progress_parses(const char *line, const char *expect size_t linelen = strlen(line) + 1; const char *endptr; git_pkt_progress *pkt; + git_pkt_parse_data pkt_parse_data = { 0 }; - cl_git_pass(git_pkt_parse_line((git_pkt **) &pkt, &endptr, line, linelen)); + cl_git_pass(git_pkt_parse_line((git_pkt **) &pkt, &endptr, line, linelen, &pkt_parse_data)); cl_assert_equal_i(pkt->type, GIT_PKT_PROGRESS); cl_assert_equal_i(pkt->len, expected_len); cl_assert_equal_strn(pkt->data, expected_data, expected_len); @@ -52,8 +55,9 @@ static void assert_error_parses(const char *line, const char *expected_error, si size_t linelen = strlen(line) + 1; const char *endptr; git_pkt_err *pkt; + git_pkt_parse_data pkt_parse_data = { 0 }; - cl_git_pass(git_pkt_parse_line((git_pkt **) &pkt, &endptr, line, linelen)); + cl_git_pass(git_pkt_parse_line((git_pkt **) &pkt, &endptr, line, linelen, &pkt_parse_data)); cl_assert_equal_i(pkt->type, GIT_PKT_ERR); cl_assert_equal_i(pkt->len, expected_len); cl_assert_equal_strn(pkt->error, expected_error, expected_len); @@ -67,10 +71,11 @@ static void assert_ack_parses(const char *line, const char *expected_oid, enum g const char *endptr; git_pkt_ack *pkt; git_oid oid; + git_pkt_parse_data pkt_parse_data = { 0 }; cl_git_pass(git_oid__fromstr(&oid, expected_oid, GIT_OID_SHA1)); - cl_git_pass(git_pkt_parse_line((git_pkt **) &pkt, &endptr, line, linelen)); + cl_git_pass(git_pkt_parse_line((git_pkt **) &pkt, &endptr, line, linelen, &pkt_parse_data)); cl_assert_equal_i(pkt->type, GIT_PKT_ACK); cl_assert_equal_oid(&pkt->oid, &oid); cl_assert_equal_i(pkt->status, expected_status); @@ -83,8 +88,9 @@ static void assert_nak_parses(const char *line) size_t linelen = strlen(line) + 1; const char *endptr; git_pkt *pkt; + git_pkt_parse_data pkt_parse_data = { 0 }; - cl_git_pass(git_pkt_parse_line((git_pkt **) &pkt, &endptr, line, linelen)); + cl_git_pass(git_pkt_parse_line((git_pkt **) &pkt, &endptr, line, linelen, &pkt_parse_data)); cl_assert_equal_i(pkt->type, GIT_PKT_NAK); cl_assert_equal_strn(endptr, line + 7, linelen - 7); @@ -96,8 +102,9 @@ static void assert_comment_parses(const char *line, const char *expected_comment size_t linelen = strlen(line) + 1; const char *endptr; git_pkt_comment *pkt; + git_pkt_parse_data pkt_parse_data = { 0 }; - cl_git_pass(git_pkt_parse_line((git_pkt **) &pkt, &endptr, line, linelen)); + cl_git_pass(git_pkt_parse_line((git_pkt **) &pkt, &endptr, line, linelen, &pkt_parse_data)); cl_assert_equal_i(pkt->type, GIT_PKT_COMMENT); cl_assert_equal_strn(pkt->comment, expected_comment, strlen(expected_comment)); @@ -109,8 +116,9 @@ static void assert_ok_parses(const char *line, const char *expected_ref) size_t linelen = strlen(line) + 1; const char *endptr; git_pkt_ok *pkt; + git_pkt_parse_data pkt_parse_data = { 0 }; - cl_git_pass(git_pkt_parse_line((git_pkt **) &pkt, &endptr, line, linelen)); + cl_git_pass(git_pkt_parse_line((git_pkt **) &pkt, &endptr, line, linelen, &pkt_parse_data)); cl_assert_equal_i(pkt->type, GIT_PKT_OK); cl_assert_equal_strn(pkt->ref, expected_ref, strlen(expected_ref)); @@ -122,8 +130,9 @@ static void assert_unpack_parses(const char *line, bool ok) size_t linelen = strlen(line) + 1; const char *endptr; git_pkt_unpack *pkt; + git_pkt_parse_data pkt_parse_data = { 0 }; - cl_git_pass(git_pkt_parse_line((git_pkt **) &pkt, &endptr, line, linelen)); + cl_git_pass(git_pkt_parse_line((git_pkt **) &pkt, &endptr, line, linelen, &pkt_parse_data)); cl_assert_equal_i(pkt->type, GIT_PKT_UNPACK); cl_assert_equal_i(pkt->unpack_ok, ok); @@ -135,8 +144,9 @@ static void assert_ng_parses(const char *line, const char *expected_ref, const c size_t linelen = strlen(line) + 1; const char *endptr; git_pkt_ng *pkt; + git_pkt_parse_data pkt_parse_data = { 0 }; - cl_git_pass(git_pkt_parse_line((git_pkt **) &pkt, &endptr, line, linelen)); + cl_git_pass(git_pkt_parse_line((git_pkt **) &pkt, &endptr, line, linelen, &pkt_parse_data)); cl_assert_equal_i(pkt->type, GIT_PKT_NG); cl_assert_equal_strn(pkt->ref, expected_ref, strlen(expected_ref)); cl_assert_equal_strn(pkt->msg, expected_msg, strlen(expected_msg)); @@ -153,10 +163,11 @@ static void assert_ref_parses_(const char *line, size_t linelen, const char *exp const char *endptr; git_pkt_ref *pkt; git_oid oid; + git_pkt_parse_data pkt_parse_data = { 0 }; cl_git_pass(git_oid__fromstr(&oid, expected_oid, GIT_OID_SHA1)); - cl_git_pass(git_pkt_parse_line((git_pkt **) &pkt, &endptr, line, linelen)); + cl_git_pass(git_pkt_parse_line((git_pkt **) &pkt, &endptr, line, linelen, &pkt_parse_data)); cl_assert_equal_i(pkt->type, GIT_PKT_REF); cl_assert_equal_oid(&pkt->head.oid, &oid); cl_assert_equal_strn(pkt->head.name, expected_ref, strlen(expected_ref)); @@ -171,8 +182,10 @@ static void assert_ref_parses_(const char *line, size_t linelen, const char *exp static void assert_pkt_fails(const char *line) { const char *endptr; + git_pkt_parse_data pkt_parse_data = { 0 }; + git_pkt *pkt; - cl_git_fail(git_pkt_parse_line(&pkt, &endptr, line, strlen(line) + 1)); + cl_git_fail(git_pkt_parse_line(&pkt, &endptr, line, strlen(line) + 1, &pkt_parse_data)); } void test_transports_smart_packet__parsing_garbage_fails(void) From 53fcd5b8f5f069ee9a2567280dca81b74192da74 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 2 Dec 2022 00:45:13 +0000 Subject: [PATCH 128/608] transport: teach transports about oid types and SHA256 --- include/git2/sys/transport.h | 12 ++++ src/libgit2/clone.c | 26 +++++++- src/libgit2/fetch.c | 4 -- src/libgit2/indexer.c | 56 +++++++++++----- src/libgit2/remote.c | 64 +++++++++--------- src/libgit2/remote.h | 32 +++++++++ src/libgit2/streams/socket.c | 4 +- src/libgit2/transports/local.c | 14 ++++ src/libgit2/transports/smart.c | 35 ++++++++++ src/libgit2/transports/smart.h | 4 ++ src/libgit2/transports/smart_pkt.c | 88 +++++++++++++++++-------- src/libgit2/transports/smart_protocol.c | 29 +++++++- src/util/hash.h | 13 ++++ 13 files changed, 298 insertions(+), 83 deletions(-) diff --git a/include/git2/sys/transport.h b/include/git2/sys/transport.h index 06ae7079ffd..b7058218803 100644 --- a/include/git2/sys/transport.h +++ b/include/git2/sys/transport.h @@ -57,6 +57,18 @@ struct git_transport { unsigned int *capabilities, git_transport *transport); +#ifdef GIT_EXPERIMENTAL_SHA256 + /** + * Gets the object type for the remote repository. + * + * This function may be called after a successful call to + * `connect()`. + */ + int GIT_CALLBACK(oid_type)( + git_oid_t *object_type, + git_transport *transport); +#endif + /** * Get the list of available references in the remote repository. * diff --git a/src/libgit2/clone.c b/src/libgit2/clone.c index 0d393eb858a..886159fbd5e 100644 --- a/src/libgit2/clone.c +++ b/src/libgit2/clone.c @@ -393,12 +393,19 @@ static int checkout_branch(git_repository *repo, git_remote *remote, const git_c return error; } -static int clone_into(git_repository *repo, git_remote *_remote, const git_fetch_options *opts, const git_checkout_options *co_opts, const char *branch) +static int clone_into( + git_repository *repo, + git_remote *_remote, + const git_fetch_options *opts, + const git_checkout_options *co_opts, + const char *branch) { int error; git_str reflog_message = GIT_STR_INIT; + git_remote_connect_options connect_opts = GIT_REMOTE_CONNECT_OPTIONS_INIT; git_fetch_options fetch_opts; git_remote *remote; + git_oid_t oid_type; GIT_ASSERT_ARG(repo); GIT_ASSERT_ARG(_remote); @@ -414,8 +421,25 @@ static int clone_into(git_repository *repo, git_remote *_remote, const git_fetch memcpy(&fetch_opts, opts, sizeof(git_fetch_options)); fetch_opts.update_fetchhead = 0; fetch_opts.download_tags = GIT_REMOTE_DOWNLOAD_TAGS_ALL; + + if ((error = git_remote_connect_options__from_fetch_opts(&connect_opts, remote, &fetch_opts)) < 0) + return error; + git_str_printf(&reflog_message, "clone: from %s", git_remote_url(remote)); + /* + * Connect to the server so that we can identify the remote + * object format. + */ + + if ((error = git_remote_connect_ext(remote, GIT_DIRECTION_FETCH, + &connect_opts)) < 0) + goto cleanup; + + if ((error = git_remote_oid_type(&oid_type, remote)) < 0 || + (error = git_repository__set_objectformat(repo, oid_type)) < 0) + goto cleanup; + if ((error = git_remote_fetch(remote, NULL, &fetch_opts, git_str_cstr(&reflog_message))) != 0) goto cleanup; diff --git a/src/libgit2/fetch.c b/src/libgit2/fetch.c index 5c2fee61737..003b5198ae8 100644 --- a/src/libgit2/fetch.c +++ b/src/libgit2/fetch.c @@ -95,7 +95,6 @@ static int filter_wants(git_remote *remote, const git_fetch_options *opts) git_remote_head **heads; git_refspec tagspec, head, *spec; int error = 0; - git_odb *odb; size_t i, heads_len; unsigned int remote_caps; unsigned int oid_mask = GIT_REMOTE_CAPABILITY_TIP_OID | @@ -126,9 +125,6 @@ static int filter_wants(git_remote *remote, const git_fetch_options *opts) goto cleanup; } - if ((error = git_repository_odb__weakptr(&odb, remote->repo)) < 0) - goto cleanup; - if ((error = git_remote_ls((const git_remote_head ***)&heads, &heads_len, remote)) < 0 || (error = git_remote_capabilities(&remote_caps, remote)) < 0) goto cleanup; diff --git a/src/libgit2/indexer.c b/src/libgit2/indexer.c index dfc326e02d0..fa55fb5eafe 100644 --- a/src/libgit2/indexer.c +++ b/src/libgit2/indexer.c @@ -56,8 +56,8 @@ struct git_indexer { git_vector deltas; unsigned int fanout[256]; git_hash_ctx hash_ctx; - unsigned char checksum[GIT_HASH_SHA1_SIZE]; - char name[(GIT_HASH_SHA1_SIZE * 2) + 1]; + unsigned char checksum[GIT_HASH_MAX_SIZE]; + char name[(GIT_HASH_MAX_SIZE * 2) + 1]; git_indexer_progress_cb progress_cb; void *progress_payload; char objbuf[8*1024]; @@ -69,7 +69,7 @@ struct git_indexer { git_odb *odb; /* Fields for calculating the packfile trailer (hash of everything before it) */ - char inbuf[GIT_OID_MAX_SIZE]; + char inbuf[GIT_HASH_MAX_SIZE]; size_t inbuf_len; git_hash_ctx trailer; }; @@ -137,6 +137,20 @@ int git_indexer_init_options(git_indexer_options *opts, unsigned int version) } #endif +GIT_INLINE(git_hash_algorithm_t) indexer_hash_algorithm(git_indexer *idx) +{ + switch (idx->oid_type) { + case GIT_OID_SHA1: + return GIT_HASH_ALGORITHM_SHA1; +#ifdef GIT_EXPERIMENTAL_SHA256 + case GIT_OID_SHA256: + return GIT_HASH_ALGORITHM_SHA256; +#endif + } + + return GIT_HASH_ALGORITHM_NONE; +} + static int indexer_new( git_indexer **out, const char *prefix, @@ -149,6 +163,7 @@ static int indexer_new( git_indexer *idx; git_str path = GIT_STR_INIT, tmp_path = GIT_STR_INIT; static const char suff[] = "/pack"; + git_hash_algorithm_t checksum_type; int error, fd = -1; if (in_opts) @@ -163,8 +178,10 @@ static int indexer_new( idx->mode = mode ? mode : GIT_PACK_FILE_MODE; git_str_init(&idx->entry_data, 0); - if ((error = git_hash_ctx_init(&idx->hash_ctx, GIT_HASH_ALGORITHM_SHA1)) < 0 || - (error = git_hash_ctx_init(&idx->trailer, GIT_HASH_ALGORITHM_SHA1)) < 0 || + checksum_type = indexer_hash_algorithm(idx); + + if ((error = git_hash_ctx_init(&idx->hash_ctx, checksum_type)) < 0 || + (error = git_hash_ctx_init(&idx->trailer, checksum_type)) < 0 || (error = git_oidmap_new(&idx->expected_oids)) < 0) goto cleanup; @@ -182,8 +199,7 @@ static int indexer_new( if (fd < 0) goto cleanup; - /* TODO: SHA256 */ - error = git_packfile_alloc(&idx->pack, git_str_cstr(&tmp_path), 0); + error = git_packfile_alloc(&idx->pack, git_str_cstr(&tmp_path), oid_type); git_str_dispose(&tmp_path); if (error < 0) @@ -614,7 +630,7 @@ static int do_progress_callback(git_indexer *idx, git_indexer_progress *stats) return 0; } -/* Hash everything but the last 20B of input */ +/* Hash everything but the checksum trailer */ static void hash_partially(git_indexer *idx, const uint8_t *data, size_t size) { size_t to_expell, to_keep; @@ -623,7 +639,10 @@ static void hash_partially(git_indexer *idx, const uint8_t *data, size_t size) if (size == 0) return; - /* Easy case, dump the buffer and the data minus the last 20 bytes */ + /* + * Easy case, dump the buffer and the data minus the trailing + * checksum (SHA1 or SHA256). + */ if (size >= oid_size) { git_hash_update(&idx->trailer, idx->inbuf, idx->inbuf_len); git_hash_update(&idx->trailer, data, size - oid_size); @@ -761,12 +780,14 @@ static int read_stream_object(git_indexer *idx, git_indexer_progress *stats) { git_packfile_stream *stream = &idx->stream; off64_t entry_start = idx->off; - size_t entry_size; + size_t oid_size, entry_size; git_object_t type; git_mwindow *w = NULL; int error; - if (idx->pack->mwf.size <= idx->off + 20) + oid_size = git_oid_size(idx->oid_type); + + if (idx->pack->mwf.size <= idx->off + (long long)oid_size) return GIT_EBUFS; if (!idx->have_stream) { @@ -963,15 +984,17 @@ static int inject_object(git_indexer *idx, git_oid *id) git_odb_object *obj = NULL; struct entry *entry = NULL; struct git_pack_entry *pentry = NULL; - unsigned char empty_checksum[GIT_HASH_SHA1_SIZE] = {0}; + unsigned char empty_checksum[GIT_HASH_MAX_SIZE] = {0}; unsigned char hdr[64]; git_str buf = GIT_STR_INIT; off64_t entry_start; const void *data; size_t len, hdr_len; - size_t checksum_size = GIT_HASH_SHA1_SIZE; + size_t checksum_size; int error; + checksum_size = git_hash_size(indexer_hash_algorithm(idx)); + if ((error = seek_back_trailer(idx)) < 0) goto cleanup; @@ -1205,10 +1228,10 @@ int git_indexer_commit(git_indexer *idx, git_indexer_progress *stats) struct git_pack_idx_header hdr; git_str filename = GIT_STR_INIT; struct entry *entry; - unsigned char checksum[GIT_HASH_SHA1_SIZE]; + unsigned char checksum[GIT_HASH_MAX_SIZE]; git_filebuf index_file = {0}; void *packfile_trailer; - size_t checksum_size = GIT_HASH_SHA1_SIZE; + size_t checksum_size; bool mismatch; if (!idx->parsed_header) { @@ -1216,6 +1239,9 @@ int git_indexer_commit(git_indexer *idx, git_indexer_progress *stats) return -1; } + checksum_size = git_hash_size(indexer_hash_algorithm(idx)); + GIT_ASSERT(checksum_size); + /* Test for this before resolve_deltas(), as it plays with idx->off */ if (idx->off + (ssize_t)checksum_size < idx->pack->mwf.size) { git_error_set(GIT_ERROR_INDEXER, "unexpected data at the end of the pack"); diff --git a/src/libgit2/remote.c b/src/libgit2/remote.c index 02d271d7d9d..3583ec031e2 100644 --- a/src/libgit2/remote.c +++ b/src/libgit2/remote.c @@ -1026,6 +1026,24 @@ int git_remote_capabilities(unsigned int *out, git_remote *remote) return remote->transport->capabilities(out, remote->transport); } +int git_remote_oid_type(git_oid_t *out, git_remote *remote) +{ + GIT_ASSERT_ARG(remote); + + if (!remote->transport) { + git_error_set(GIT_ERROR_NET, "this remote has never connected"); + *out = 0; + return -1; + } + +#ifdef GIT_EXPERIMENTAL_SHA256 + return remote->transport->oid_type(out, remote->transport); +#else + *out = GIT_OID_SHA1; + return 0; +#endif +} + static int lookup_config(char **out, git_config *cfg, const char *name) { git_config_entry *ce = NULL; @@ -1225,24 +1243,6 @@ static int ls_to_vector(git_vector *out, git_remote *remote) return 0; } -#define copy_opts(out, in) \ - if (in) { \ - (out)->callbacks = (in)->callbacks; \ - (out)->proxy_opts = (in)->proxy_opts; \ - (out)->custom_headers = (in)->custom_headers; \ - (out)->follow_redirects = (in)->follow_redirects; \ - } - -GIT_INLINE(int) connect_opts_from_fetch_opts( - git_remote_connect_options *out, - git_remote *remote, - const git_fetch_options *fetch_opts) -{ - git_remote_connect_options tmp = GIT_REMOTE_CONNECT_OPTIONS_INIT; - copy_opts(&tmp, fetch_opts); - return git_remote_connect_options_normalize(out, remote->repo, &tmp); -} - static int connect_or_reset_options( git_remote *remote, int direction, @@ -1330,7 +1330,8 @@ int git_remote_download( return -1; } - if (connect_opts_from_fetch_opts(&connect_opts, remote, opts) < 0) + if (git_remote_connect_options__from_fetch_opts(&connect_opts, + remote, opts) < 0) return -1; if ((error = connect_or_reset_options(remote, GIT_DIRECTION_FETCH, &connect_opts)) < 0) @@ -1350,6 +1351,8 @@ int git_remote_fetch( bool prune = false; git_str reflog_msg_buf = GIT_STR_INIT; git_remote_connect_options connect_opts = GIT_REMOTE_CONNECT_OPTIONS_INIT; + unsigned int capabilities; + git_oid_t oid_type; GIT_ASSERT_ARG(remote); @@ -1358,7 +1361,8 @@ int git_remote_fetch( return -1; } - if (connect_opts_from_fetch_opts(&connect_opts, remote, opts) < 0) + if (git_remote_connect_options__from_fetch_opts(&connect_opts, + remote, opts) < 0) return -1; if ((error = connect_or_reset_options(remote, GIT_DIRECTION_FETCH, &connect_opts)) < 0) @@ -1369,6 +1373,10 @@ int git_remote_fetch( tagopt = opts->download_tags; } + if ((error = git_remote_capabilities(&capabilities, remote)) < 0 || + (error = git_remote_oid_type(&oid_type, remote)) < 0) + return error; + /* Connect and download everything */ error = git_remote__download(remote, refspecs, opts); @@ -2896,16 +2904,6 @@ int git_remote__default_branch(git_str *out, git_remote *remote) return error; } -GIT_INLINE(int) connect_opts_from_push_opts( - git_remote_connect_options *out, - git_remote *remote, - const git_push_options *push_opts) -{ - git_remote_connect_options tmp = GIT_REMOTE_CONNECT_OPTIONS_INIT; - copy_opts(&tmp, push_opts); - return git_remote_connect_options_normalize(out, remote->repo, &tmp); -} - int git_remote_upload( git_remote *remote, const git_strarray *refspecs, @@ -2924,7 +2922,8 @@ int git_remote_upload( return -1; } - if ((error = connect_opts_from_push_opts(&connect_opts, remote, opts)) < 0) + if ((error = git_remote_connect_options__from_push_opts( + &connect_opts, remote, opts)) < 0) goto cleanup; if ((error = connect_or_reset_options(remote, GIT_DIRECTION_PUSH, &connect_opts)) < 0) @@ -2985,7 +2984,8 @@ int git_remote_push( return -1; } - if (connect_opts_from_push_opts(&connect_opts, remote, opts) < 0) + if (git_remote_connect_options__from_push_opts(&connect_opts, + remote, opts) < 0) return -1; if ((error = git_remote_upload(remote, refspecs, opts)) < 0) diff --git a/src/libgit2/remote.h b/src/libgit2/remote.h index 41ee58e0fd5..87dab4eba62 100644 --- a/src/libgit2/remote.h +++ b/src/libgit2/remote.h @@ -56,5 +56,37 @@ int git_remote_connect_options_normalize( const git_remote_connect_options *src); int git_remote_capabilities(unsigned int *out, git_remote *remote); +int git_remote_oid_type(git_oid_t *out, git_remote *remote); + + +#define git_remote_connect_options__copy_opts(out, in) \ + if (in) { \ + (out)->callbacks = (in)->callbacks; \ + (out)->proxy_opts = (in)->proxy_opts; \ + (out)->custom_headers = (in)->custom_headers; \ + (out)->follow_redirects = (in)->follow_redirects; \ + } + +GIT_INLINE(int) git_remote_connect_options__from_fetch_opts( + git_remote_connect_options *out, + git_remote *remote, + const git_fetch_options *fetch_opts) +{ + git_remote_connect_options tmp = GIT_REMOTE_CONNECT_OPTIONS_INIT; + git_remote_connect_options__copy_opts(&tmp, fetch_opts); + return git_remote_connect_options_normalize(out, remote->repo, &tmp); +} + +GIT_INLINE(int) git_remote_connect_options__from_push_opts( + git_remote_connect_options *out, + git_remote *remote, + const git_push_options *push_opts) +{ + git_remote_connect_options tmp = GIT_REMOTE_CONNECT_OPTIONS_INIT; + git_remote_connect_options__copy_opts(&tmp, push_opts); + return git_remote_connect_options_normalize(out, remote->repo, &tmp); +} + +#undef git_remote_connect_options__copy_opts #endif diff --git a/src/libgit2/streams/socket.c b/src/libgit2/streams/socket.c index 9415fe89237..cbf80587909 100644 --- a/src/libgit2/streams/socket.c +++ b/src/libgit2/streams/socket.c @@ -135,9 +135,11 @@ static ssize_t socket_write(git_stream *stream, const char *data, size_t len, in git_socket_stream *st = (git_socket_stream *) stream; ssize_t written; + assert(flags == 0); + errno = 0; - if ((written = p_send(st->s, data, len, flags)) < 0) { + if ((written = p_send(st->s, data, len, 0)) < 0) { net_set_error("error sending data"); return -1; } diff --git a/src/libgit2/transports/local.c b/src/libgit2/transports/local.c index 6c754a034a4..4d86f171310 100644 --- a/src/libgit2/transports/local.c +++ b/src/libgit2/transports/local.c @@ -266,6 +266,17 @@ static int local_capabilities(unsigned int *capabilities, git_transport *transpo return 0; } +#ifdef GIT_EXPERIMENTAL_SHA256 +static int local_oid_type(git_oid_t *out, git_transport *transport) +{ + transport_local *t = (transport_local *)transport; + + *out = t->repo->oid_type; + + return 0; +} +#endif + static int local_ls(const git_remote_head ***out, size_t *size, git_transport *transport) { transport_local *t = (transport_local *)transport; @@ -732,6 +743,9 @@ int git_transport_local(git_transport **out, git_remote *owner, void *param) t->parent.connect = local_connect; t->parent.set_connect_opts = local_set_connect_opts; t->parent.capabilities = local_capabilities; +#ifdef GIT_EXPERIMENTAL_SHA256 + t->parent.oid_type = local_oid_type; +#endif t->parent.negotiate_fetch = local_negotiate_fetch; t->parent.download_pack = local_download_pack; t->parent.push = local_push; diff --git a/src/libgit2/transports/smart.c b/src/libgit2/transports/smart.c index 7f57dba2a42..c3a764bd3d5 100644 --- a/src/libgit2/transports/smart.c +++ b/src/libgit2/transports/smart.c @@ -54,6 +54,12 @@ GIT_INLINE(int) git_smart__reset_stream(transport_smart *t, bool close_subtransp return -1; } + git__free(t->caps.object_format); + t->caps.object_format = NULL; + + git__free(t->caps.agent); + t->caps.agent = NULL; + return 0; } @@ -242,6 +248,30 @@ static int git_smart__capabilities(unsigned int *capabilities, git_transport *tr return 0; } +#ifdef GIT_EXPERIMENTAL_SHA256 +static int git_smart__oid_type(git_oid_t *out, git_transport *transport) +{ + transport_smart *t = GIT_CONTAINER_OF(transport, transport_smart, parent); + + *out = 0; + + if (t->caps.object_format == NULL) { + *out = GIT_OID_DEFAULT; + } else { + *out = git_oid_type_fromstr(t->caps.object_format); + + if (!*out) { + git_error_set(GIT_ERROR_INVALID, + "unknown object format '%s'", + t->caps.object_format); + return -1; + } + } + + return 0; +} +#endif + static int git_smart__ls(const git_remote_head ***out, size_t *size, git_transport *transport) { transport_smart *t = GIT_CONTAINER_OF(transport, transport_smart, parent); @@ -386,6 +416,8 @@ static void git_smart__free(git_transport *transport) git_remote_connect_options_dispose(&t->connect_opts); + git__free(t->caps.object_format); + git__free(t->caps.agent); git__free(t); } @@ -452,6 +484,9 @@ int git_transport_smart(git_transport **out, git_remote *owner, void *param) t->parent.connect = git_smart__connect; t->parent.set_connect_opts = git_smart__set_connect_opts; t->parent.capabilities = git_smart__capabilities; +#ifdef GIT_EXPERIMENTAL_SHA256 + t->parent.oid_type = git_smart__oid_type; +#endif t->parent.close = git_smart__close; t->parent.free = git_smart__free; t->parent.negotiate_fetch = git_smart__negotiate_fetch; diff --git a/src/libgit2/transports/smart.h b/src/libgit2/transports/smart.h index ca649616317..d71160d8e60 100644 --- a/src/libgit2/transports/smart.h +++ b/src/libgit2/transports/smart.h @@ -32,6 +32,8 @@ #define GIT_CAP_SYMREF "symref" #define GIT_CAP_WANT_TIP_SHA1 "allow-tip-sha1-in-want" #define GIT_CAP_WANT_REACHABLE_SHA1 "allow-reachable-sha1-in-want" +#define GIT_CAP_OBJECT_FORMAT "object-format=" +#define GIT_CAP_AGENT "agent=" extern bool git_smart__ofs_delta_enabled; @@ -133,6 +135,8 @@ typedef struct transport_smart_caps { thin_pack:1, want_tip_sha1:1, want_reachable_sha1:1; + char *object_format; + char *agent; } transport_smart_caps; typedef int (*packetsize_cb)(size_t received, void *payload); diff --git a/src/libgit2/transports/smart_pkt.c b/src/libgit2/transports/smart_pkt.c index b6428d845e4..5fce42175be 100644 --- a/src/libgit2/transports/smart_pkt.c +++ b/src/libgit2/transports/smart_pkt.c @@ -21,11 +21,14 @@ #include -#define PKT_LEN_SIZE 4 -static const char pkt_done_str[] = "0009done\n"; -static const char pkt_flush_str[] = "0000"; -static const char pkt_have_prefix[] = "0032have "; -static const char pkt_want_prefix[] = "0032want "; +#define PKT_DONE_STR "0009done\n" +#define PKT_FLUSH_STR "0000" +#define PKT_HAVE_PREFIX "have " +#define PKT_WANT_PREFIX "want " + +#define PKT_LEN_SIZE 4 +#define PKT_MAX_SIZE 0xffff +#define PKT_MAX_WANTLEN (PKT_LEN_SIZE + CONST_STRLEN(PKT_WANT_PREFIX) + GIT_OID_MAX_HEXSIZE + 1) static int flush_pkt(git_pkt **out) { @@ -598,16 +601,20 @@ void git_pkt_free(git_pkt *pkt) int git_pkt_buffer_flush(git_str *buf) { - return git_str_put(buf, pkt_flush_str, strlen(pkt_flush_str)); + return git_str_put(buf, PKT_FLUSH_STR, CONST_STRLEN(PKT_FLUSH_STR)); } -static int buffer_want_with_caps(const git_remote_head *head, transport_smart_caps *caps, git_str *buf) +static int buffer_want_with_caps( + const git_remote_head *head, + transport_smart_caps *caps, + git_oid_t oid_type, + git_str *buf) { git_str str = GIT_STR_INIT; - char oid[GIT_OID_MAX_HEXSIZE + 1] = {0}; + char oid[GIT_OID_MAX_HEXSIZE]; size_t oid_hexsize, len; - oid_hexsize = git_oid_hexsize(head->oid.type); + oid_hexsize = git_oid_hexsize(oid_type); git_oid_fmt(oid, &head->oid); /* Prefer multi_ack_detailed */ @@ -634,18 +641,19 @@ static int buffer_want_with_caps(const git_remote_head *head, transport_smart_ca if (git_str_oom(&str)) return -1; - len = strlen("XXXXwant ") + oid_hexsize + 1 /* NUL */ + - git_str_len(&str) + 1 /* LF */; - - if (len > 0xffff) { + if (str.size > (PKT_MAX_SIZE - (PKT_MAX_WANTLEN + 1))) { git_error_set(GIT_ERROR_NET, - "tried to produce packet with invalid length %" PRIuZ, len); + "tried to produce packet with invalid caps length %" PRIuZ, str.size); return -1; } + len = PKT_LEN_SIZE + CONST_STRLEN(PKT_WANT_PREFIX) + + oid_hexsize + 1 /* NUL */ + + git_str_len(&str) + 1 /* LF */; + git_str_grow_by(buf, len); git_str_printf(buf, - "%04xwant %.*s %s\n", (unsigned int)len, + "%04x%s%.*s %s\n", (unsigned int)len, PKT_WANT_PREFIX, (int)oid_hexsize, oid, git_str_cstr(&str)); git_str_dispose(&str); @@ -665,8 +673,21 @@ int git_pkt_buffer_wants( transport_smart_caps *caps, git_str *buf) { - size_t i = 0; const git_remote_head *head; + char oid[GIT_OID_MAX_HEXSIZE]; + git_oid_t oid_type; + size_t oid_hexsize, want_len, i = 0; + +#ifdef GIT_EXPERIMENTAL_SHA256 + oid_type = count > 0 ? refs[0]->oid.type : GIT_OID_SHA1; +#else + oid_type = GIT_OID_SHA1; +#endif + + oid_hexsize = git_oid_hexsize(oid_type); + + want_len = PKT_LEN_SIZE + CONST_STRLEN(PKT_WANT_PREFIX) + + oid_hexsize + 1 /* LF */; if (caps->common) { for (; i < count; ++i) { @@ -675,15 +696,13 @@ int git_pkt_buffer_wants( break; } - if (buffer_want_with_caps(refs[i], caps, buf) < 0) + if (buffer_want_with_caps(refs[i], caps, oid_type, buf) < 0) return -1; i++; } for (; i < count; ++i) { - char oid[GIT_OID_MAX_HEXSIZE]; - head = refs[i]; if (head->local) @@ -691,9 +710,9 @@ int git_pkt_buffer_wants( git_oid_fmt(oid, &head->oid); - git_str_put(buf, pkt_want_prefix, strlen(pkt_want_prefix)); - git_str_put(buf, oid, git_oid_hexsize(head->oid.type)); - git_str_putc(buf, '\n'); + git_str_printf(buf, "%04x%s%.*s\n", + (unsigned int)want_len, PKT_WANT_PREFIX, + (int)oid_hexsize, oid); if (git_str_oom(buf)) return -1; @@ -704,14 +723,27 @@ int git_pkt_buffer_wants( int git_pkt_buffer_have(git_oid *oid, git_str *buf) { - char oidhex[GIT_OID_SHA1_HEXSIZE + 1]; - - memset(oidhex, 0x0, sizeof(oidhex)); - git_oid_fmt(oidhex, oid); - return git_str_printf(buf, "%s%s\n", pkt_have_prefix, oidhex); + char oid_str[GIT_OID_MAX_HEXSIZE]; + git_oid_t oid_type; + size_t oid_hexsize, have_len; + +#ifdef GIT_EXPERIMENTAL_SHA256 + oid_type = oid->type; +#else + oid_type = GIT_OID_SHA1; +#endif + + oid_hexsize = git_oid_hexsize(oid_type); + have_len = PKT_LEN_SIZE + CONST_STRLEN(PKT_HAVE_PREFIX) + + oid_hexsize + 1 /* LF */; + + git_oid_fmt(oid_str, oid); + return git_str_printf(buf, "%04x%s%.*s\n", + (unsigned int)have_len, PKT_HAVE_PREFIX, + (int)oid_hexsize, oid_str); } int git_pkt_buffer_done(git_str *buf) { - return git_str_puts(buf, pkt_done_str); + return git_str_put(buf, PKT_DONE_STR, CONST_STRLEN(PKT_DONE_STR)); } diff --git a/src/libgit2/transports/smart_protocol.c b/src/libgit2/transports/smart_protocol.c index 86d02df83bc..0d47acafe0a 100644 --- a/src/libgit2/transports/smart_protocol.c +++ b/src/libgit2/transports/smart_protocol.c @@ -134,9 +134,12 @@ static int append_symref(const char **out, git_vector *symrefs, const char *ptr) return -1; } -int git_smart__detect_caps(git_pkt_ref *pkt, transport_smart_caps *caps, git_vector *symrefs) +int git_smart__detect_caps( + git_pkt_ref *pkt, + transport_smart_caps *caps, + git_vector *symrefs) { - const char *ptr; + const char *ptr, *start; /* No refs or capabilities, odd but not a problem */ if (pkt == NULL || pkt->capabilities == NULL) @@ -218,6 +221,28 @@ int git_smart__detect_caps(git_pkt_ref *pkt, transport_smart_caps *caps, git_vec continue; } + if (!git__prefixcmp(ptr, GIT_CAP_OBJECT_FORMAT)) { + ptr += strlen(GIT_CAP_OBJECT_FORMAT); + + start = ptr; + ptr = strchr(ptr, ' '); + + if ((caps->object_format = git__strndup(start, (ptr - start))) == NULL) + return -1; + continue; + } + + if (!git__prefixcmp(ptr, GIT_CAP_AGENT)) { + ptr += strlen(GIT_CAP_AGENT); + + start = ptr; + ptr = strchr(ptr, ' '); + + if ((caps->agent = git__strndup(start, (ptr - start))) == NULL) + return -1; + continue; + } + /* We don't know this capability, so skip it */ ptr = strchr(ptr, ' '); } diff --git a/src/util/hash.h b/src/util/hash.h index 387c5a66f96..21fcaf045e7 100644 --- a/src/util/hash.h +++ b/src/util/hash.h @@ -23,6 +23,8 @@ typedef enum { GIT_HASH_ALGORITHM_SHA256 } git_hash_algorithm_t; +#define GIT_HASH_MAX_SIZE GIT_HASH_SHA256_SIZE + typedef struct git_hash_ctx { union { git_hash_sha1_ctx sha1; @@ -45,4 +47,15 @@ int git_hash_vec(unsigned char *out, git_str_vec *vec, size_t n, git_hash_algori int git_hash_fmt(char *out, unsigned char *hash, size_t hash_len); +GIT_INLINE(size_t) git_hash_size(git_hash_algorithm_t algorithm) { + switch (algorithm) { + case GIT_HASH_ALGORITHM_SHA1: + return GIT_HASH_SHA1_SIZE; + case GIT_HASH_ALGORITHM_SHA256: + return GIT_HASH_SHA256_SIZE; + default: + return 0; + } +} + #endif From af20d13b18dbab4de9f244402c255bc85e907ac1 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sun, 4 Dec 2022 14:22:02 +0000 Subject: [PATCH 129/608] repo: dump backends on oid type change --- src/libgit2/repository.c | 19 ++++++++++++++++++- 1 file changed, 18 insertions(+), 1 deletion(-) diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index 2da6caf3a32..928f4635ced 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -1674,6 +1674,12 @@ int git_repository__set_objectformat( if (oid_type == GIT_OID_DEFAULT) return 0; + if (!git_repository_is_empty(repo) && repo->oid_type != oid_type) { + git_error_set(GIT_ERROR_REPOSITORY, + "cannot change object id type of existing repository"); + return -1; + } + if (git_repository_config__weakptr(&cfg, repo) < 0) return -1; @@ -1683,7 +1689,18 @@ int git_repository__set_objectformat( git_oid_type_name(oid_type)) < 0) return -1; - repo->oid_type = oid_type; + /* + * During repo init, we may create some backends with the + * default oid type. Clear them so that we create them with + * the proper oid type. + */ + if (repo->oid_type != oid_type) { + set_index(repo, NULL); + set_odb(repo, NULL); + set_refdb(repo, NULL); + + repo->oid_type = oid_type; + } return 0; } From 8eadeedee46e8cd4ac2364134b4696b1473d17dc Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 9 Feb 2023 17:14:01 +0000 Subject: [PATCH 130/608] repo: take an oid_type when initializing --- include/git2/repository.h | 9 +++++++++ src/libgit2/repository.c | 18 +++++++++++++++--- 2 files changed, 24 insertions(+), 3 deletions(-) diff --git a/include/git2/repository.h b/include/git2/repository.h index 9b56599d75d..04c240d2440 100644 --- a/include/git2/repository.h +++ b/include/git2/repository.h @@ -351,6 +351,15 @@ typedef struct { * pointing to this URL. */ const char *origin_url; + +#ifdef GIT_EXPERIMENTAL_SHA256 + /** + * + * Type of object IDs to use for this repository, or 0 for + * default (currently SHA1). + */ + git_oid_t oid_type; +#endif } git_repository_init_options; #define GIT_REPOSITORY_INIT_OPTIONS_VERSION 1 diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index 928f4635ced..489d627a0de 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -1983,7 +1983,8 @@ static int repo_init_config( const char *repo_dir, const char *work_dir, uint32_t flags, - uint32_t mode) + uint32_t mode, + git_oid_t oid_type) { int error = 0; git_str cfg_path = GIT_STR_INIT, worktree_path = GIT_STR_INIT; @@ -2040,6 +2041,11 @@ static int repo_init_config( SET_REPO_CONFIG(bool, "receive.denyNonFastforwards", true); } + if (oid_type != GIT_OID_SHA1) { + SET_REPO_CONFIG(int32, "core.repositoryformatversion", 1); + SET_REPO_CONFIG(string, "extensions.objectformat", git_oid_type_name(oid_type)); + } + cleanup: git_str_dispose(&cfg_path); git_str_dispose(&worktree_path); @@ -2520,6 +2526,7 @@ int git_repository_init_ext( common_path = GIT_STR_INIT; const char *wd; bool is_valid; + git_oid_t oid_type = GIT_OID_DEFAULT; int error; GIT_ASSERT_ARG(out); @@ -2528,6 +2535,11 @@ int git_repository_init_ext( GIT_ERROR_CHECK_VERSION(opts, GIT_REPOSITORY_INIT_OPTIONS_VERSION, "git_repository_init_options"); +#ifdef GIT_EXPERIMENTAL_SHA256 + if (opts->oid_type) + oid_type = opts->oid_type; +#endif + if ((error = repo_init_directories(&repo_path, &wd_path, given_repo, opts)) < 0) goto out; @@ -2546,13 +2558,13 @@ int git_repository_init_ext( opts->flags |= GIT_REPOSITORY_INIT__IS_REINIT; - if ((error = repo_init_config(repo_path.ptr, wd, opts->flags, opts->mode)) < 0) + if ((error = repo_init_config(repo_path.ptr, wd, opts->flags, opts->mode, oid_type)) < 0) goto out; /* TODO: reinitialize the templates */ } else { if ((error = repo_init_structure(repo_path.ptr, wd, opts)) < 0 || - (error = repo_init_config(repo_path.ptr, wd, opts->flags, opts->mode)) < 0 || + (error = repo_init_config(repo_path.ptr, wd, opts->flags, opts->mode, oid_type)) < 0 || (error = repo_init_head(repo_path.ptr, opts->initial_head)) < 0) goto out; } From 6cb7966d5a9b8d704e7a221c1fd8e8c0aba02b7b Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 10 Feb 2023 09:46:33 +0000 Subject: [PATCH 131/608] clone: free connect opts --- src/libgit2/clone.c | 1 + src/libgit2/remote.h | 8 ++++++++ 2 files changed, 9 insertions(+) diff --git a/src/libgit2/clone.c b/src/libgit2/clone.c index 886159fbd5e..e8885f22ac3 100644 --- a/src/libgit2/clone.c +++ b/src/libgit2/clone.c @@ -447,6 +447,7 @@ static int clone_into( cleanup: git_remote_free(remote); + git_remote_connect_options_dispose(&connect_opts); git_str_dispose(&reflog_message); return error; diff --git a/src/libgit2/remote.h b/src/libgit2/remote.h index 87dab4eba62..676b3c2ab65 100644 --- a/src/libgit2/remote.h +++ b/src/libgit2/remote.h @@ -17,6 +17,7 @@ #include "refspec.h" #include "vector.h" #include "net.h" +#include "proxy.h" #define GIT_REMOTE_ORIGIN "origin" @@ -89,4 +90,11 @@ GIT_INLINE(int) git_remote_connect_options__from_push_opts( #undef git_remote_connect_options__copy_opts +GIT_INLINE(void) git_remote_connect_options__dispose( + git_remote_connect_options *opts) +{ + git_proxy_options_dispose(&opts->proxy_opts); + git_strarray_dispose(&opts->custom_headers); +} + #endif From f72707872b036f1283537b248f0199ac193c6933 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 10 Feb 2023 10:56:18 +0000 Subject: [PATCH 132/608] ci: actually build sha256 support on linux --- .github/workflows/main.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 39cefdb192d..767eb121a61 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -226,7 +226,7 @@ jobs: env: CC: clang CMAKE_GENERATOR: Ninja - CMAKE_OPTIONS: -DUSE_HTTPS=OpenSSL -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=ON + CMAKE_OPTIONS: -DUSE_HTTPS=OpenSSL -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=ON -DEXPERIMENTAL_SHA256=ON os: ubuntu-latest - name: "macOS (SHA256)" id: macos From d63f1fe2457edbcdae7e20f1c1e4b75fbff8354e Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 10 Feb 2023 11:08:34 +0000 Subject: [PATCH 133/608] cmake: support older cmakes --- cmake/ExperimentalFeatures.cmake | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cmake/ExperimentalFeatures.cmake b/cmake/ExperimentalFeatures.cmake index 57a66e68daa..7eff40bdbc2 100644 --- a/cmake/ExperimentalFeatures.cmake +++ b/cmake/ExperimentalFeatures.cmake @@ -13,7 +13,7 @@ if(EXPERIMENTAL_SHA256) set(EXPERIMENTAL 1) set(GIT_EXPERIMENTAL_SHA256 1) - add_compile_definitions(GIT_EXPERIMENTAL_SHA256) + add_definitions(-DGIT_EXPERIMENTAL_SHA256=1) else() add_feature_info("SHA256 API" OFF "experimental SHA256 APIs") endif() From e7a7691146f3ce1b85e3f79be4fe40745973ffe9 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 10 Feb 2023 14:16:08 +0000 Subject: [PATCH 134/608] win32: adjust max path length for SHA256 The longest path within a git repository is now a SHA256 format packfile. Adjust our max length checking to match. --- tests/libgit2/repo/init.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/libgit2/repo/init.c b/tests/libgit2/repo/init.c index 637d4a90355..d78ec063cd2 100644 --- a/tests/libgit2/repo/init.c +++ b/tests/libgit2/repo/init.c @@ -727,7 +727,7 @@ void test_repo_init__defaultbranch_config_empty(void) void test_repo_init__longpath(void) { #ifdef GIT_WIN32 - size_t padding = CONST_STRLEN("objects/pack/pack-.pack.lock") + GIT_OID_SHA1_HEXSIZE; + size_t padding = CONST_STRLEN("objects/pack/pack-.pack.lock") + GIT_OID_MAX_HEXSIZE; size_t max, i; git_str path = GIT_STR_INIT; git_repository *one = NULL, *two = NULL; From e3cd859150f720914dfbbdd2d80d12b1482a397a Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 10 Feb 2023 15:14:36 +0000 Subject: [PATCH 135/608] ci: build our own git on xenial The git included with xenial is ancient, and lacks sha256 support. --- ci/docker/xenial | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-) diff --git a/ci/docker/xenial b/ci/docker/xenial index f5fa5a315b2..578f0a962a9 100644 --- a/ci/docker/xenial +++ b/ci/docker/xenial @@ -7,11 +7,13 @@ RUN apt-get update && \ clang \ cmake \ curl \ + gettext \ gcc \ - git \ krb5-user \ libcurl4-gnutls-dev \ + libexpat1-dev \ libgcrypt20-dev \ + libintl-perl \ libkrb5-dev \ libpcre3-dev \ libssl-dev \ @@ -28,7 +30,17 @@ RUN apt-get update && \ && \ rm -rf /var/lib/apt/lists/* -FROM apt AS mbedtls +FROM apt AS git +RUN cd /tmp && \ + curl --location --silent --show-error https://github.com/git/git/archive/refs/tags/v2.39.1.tar.gz | \ + tar -xz && \ + cd git-2.39.1 && \ + make && \ + make prefix=/usr install && \ + cd .. && \ + rm -rf git-2.39.1 + +FROM git AS mbedtls RUN cd /tmp && \ curl --location --silent --show-error https://github.com/Mbed-TLS/mbedtls/archive/refs/tags/mbedtls-2.16.2.tar.gz | \ tar -xz && \ From b755b7d294780bf7dc1c9b5c5fff892ac5f0ec38 Mon Sep 17 00:00:00 2001 From: Iliyas Jorio Date: Mon, 13 Feb 2023 19:49:33 +0100 Subject: [PATCH 136/608] diff_file: don't mmap/readbuffer empty files This prevents GIT_MMAP_VALIDATE from failing. This also prevents git_diff_file_content__unload from attempting to free git_str__initstr. --- src/libgit2/diff_file.c | 7 +++++++ tests/libgit2/diff/workdir.c | 36 ++++++++++++++++++++++++++++++++++++ 2 files changed, 43 insertions(+) diff --git a/src/libgit2/diff_file.c b/src/libgit2/diff_file.c index 5f433665852..c2d08675ab0 100644 --- a/src/libgit2/diff_file.c +++ b/src/libgit2/diff_file.c @@ -348,6 +348,13 @@ static int diff_file_content_load_workdir_file( goto cleanup; } + /* if file is empty, don't attempt to mmap or readbuffer */ + if (fc->file->size == 0) { + fc->map.len = 0; + fc->map.data = git_str__initstr; + goto cleanup; + } + if ((diff_opts->flags & GIT_DIFF_SHOW_BINARY) == 0 && diff_file_content_binary_by_size(fc)) goto cleanup; diff --git a/tests/libgit2/diff/workdir.c b/tests/libgit2/diff/workdir.c index 8ccde41ff2a..21c5b0de9a2 100644 --- a/tests/libgit2/diff/workdir.c +++ b/tests/libgit2/diff/workdir.c @@ -1232,6 +1232,42 @@ void test_diff_workdir__checks_options_version(void) cl_assert_equal_i(GIT_ERROR_INVALID, err->klass); } +void test_diff_workdir__can_diff_empty_untracked_file(void) +{ + git_diff_options opts = GIT_DIFF_OPTIONS_INIT; + git_diff *diff = NULL; + git_patch *patch = NULL; + + g_repo = cl_git_sandbox_init("empty_standard_repo"); + + cl_git_mkfile("empty_standard_repo/emptyfile.txt", ""); + + opts.context_lines = 3; + opts.interhunk_lines = 1; + opts.flags |= GIT_DIFF_INCLUDE_UNTRACKED | GIT_DIFF_SHOW_UNTRACKED_CONTENT; + + cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts)); + + /* without filters */ + git_patch_from_diff(&patch, diff, 0); + cl_assert(NULL != patch); + cl_assert(0 == git_patch_get_delta(patch)->new_file.size); + cl_assert(0 == strcmp("emptyfile.txt", git_patch_get_delta(patch)->new_file.path)); + git_patch_free(patch); + patch = NULL; + + /* with a filter */ + cl_repo_set_bool(g_repo, "core.autocrlf", true); /* install some filter */ + git_patch_from_diff(&patch, diff, 0); + cl_assert(NULL != patch); + cl_assert(0 == git_patch_get_delta(patch)->new_file.size); + cl_assert(0 == strcmp("emptyfile.txt", git_patch_get_delta(patch)->new_file.path)); + git_patch_free(patch); + patch = NULL; + + git_diff_free(diff); +} + void test_diff_workdir__can_diff_empty_file(void) { git_diff *diff; From 9e757f288aaadd55b8e10e9bf3c5e9811c649c64 Mon Sep 17 00:00:00 2001 From: Roger Gee Date: Mon, 13 Feb 2023 21:27:12 -0600 Subject: [PATCH 137/608] chore(docs): update php language binding project links Updates the README.md language binding section to reference a new project providing PHP bindings at https://github.com/RogerGee/php-git2. --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index c844ee4a1bb..166a202f296 100644 --- a/README.md +++ b/README.md @@ -395,7 +395,7 @@ Here are the bindings to libgit2 that are currently available: * Pharo Smalltalk * libgit2-pharo-bindings * PHP - * php-git + * php-git2 * Python * pygit2 * R From 0628e25d04bed2734091a8354aae7186f490037c Mon Sep 17 00:00:00 2001 From: Sven Strickroth Date: Fri, 19 Aug 2022 21:16:21 +0200 Subject: [PATCH 138/608] Fix parsing rev with reflog of HEAD (e.g., HEAD@{3}) Fixes issue #6156. Signed-off-by: Sven Strickroth --- src/libgit2/revparse.c | 6 +++++- tests/libgit2/refs/revparse.c | 3 +++ 2 files changed, 8 insertions(+), 1 deletion(-) diff --git a/src/libgit2/revparse.c b/src/libgit2/revparse.c index 2ed28215957..255c566caa4 100644 --- a/src/libgit2/revparse.c +++ b/src/libgit2/revparse.c @@ -268,7 +268,11 @@ static int retrieve_revobject_from_reflog(git_object **out, git_reference **base int error = -1; if (*base_ref == NULL) { - if ((error = git_reference_dwim(&ref, repo, identifier)) < 0) + if (position > 0 && + (!strcmp(identifier, "HEAD"))) { + if ((error = git_reference_lookup(&ref, repo, "HEAD")) < 0) + return error; + } else if ((error = git_reference_dwim(&ref, repo, identifier)) < 0) return error; } else { ref = *base_ref; diff --git a/tests/libgit2/refs/revparse.c b/tests/libgit2/refs/revparse.c index 02ffe005df6..d2f464840a0 100644 --- a/tests/libgit2/refs/revparse.c +++ b/tests/libgit2/refs/revparse.c @@ -304,6 +304,9 @@ void test_refs_revparse__ordinal(void) test_object("@{0}", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750"); test_object("@{1}", "be3563ae3f795b2b4353bcce3a527ad0a4f7f644"); + test_object("HEAD@{0}", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750"); + test_object("HEAD@{4}", "5b5b025afb0b4c913b4c338a42934a3863bf3644"); + test_object("master@{0}", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750"); test_object("master@{1}", "be3563ae3f795b2b4353bcce3a527ad0a4f7f644"); test_object("heads/master@{1}", "be3563ae3f795b2b4353bcce3a527ad0a4f7f644"); From c1634611dde3feee874c0be545cbc1107caa2f29 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Tue, 14 Feb 2023 11:59:42 +0000 Subject: [PATCH 139/608] revparse: comment reflog HEAD@{n} parsing --- src/libgit2/revparse.c | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) diff --git a/src/libgit2/revparse.c b/src/libgit2/revparse.c index 255c566caa4..780f1a0cbad 100644 --- a/src/libgit2/revparse.c +++ b/src/libgit2/revparse.c @@ -268,11 +268,16 @@ static int retrieve_revobject_from_reflog(git_object **out, git_reference **base int error = -1; if (*base_ref == NULL) { - if (position > 0 && - (!strcmp(identifier, "HEAD"))) { - if ((error = git_reference_lookup(&ref, repo, "HEAD")) < 0) - return error; - } else if ((error = git_reference_dwim(&ref, repo, identifier)) < 0) + /* + * When HEAD@{n} is specified, do not use dwim, which would resolve the + * reference (to the current branch that HEAD is pointing to). + */ + if (position > 0 && strcmp(identifier, GIT_HEAD_FILE) == 0) + error = git_reference_lookup(&ref, repo, GIT_HEAD_FILE); + else + error = git_reference_dwim(&ref, repo, identifier); + + if (error < 0) return error; } else { ref = *base_ref; From 527be0a202b2093cb5249cf6b534992869fa3bb5 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Tue, 14 Feb 2023 17:49:18 -0500 Subject: [PATCH 140/608] clone: clean up options on failure --- src/libgit2/clone.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/libgit2/clone.c b/src/libgit2/clone.c index e8885f22ac3..b73880e4486 100644 --- a/src/libgit2/clone.c +++ b/src/libgit2/clone.c @@ -423,7 +423,7 @@ static int clone_into( fetch_opts.download_tags = GIT_REMOTE_DOWNLOAD_TAGS_ALL; if ((error = git_remote_connect_options__from_fetch_opts(&connect_opts, remote, &fetch_opts)) < 0) - return error; + goto cleanup; git_str_printf(&reflog_message, "clone: from %s", git_remote_url(remote)); From f892ec2add4c180de4ab71fefe0f21d7cf9e09c1 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Wed, 15 Feb 2023 10:07:35 +0000 Subject: [PATCH 141/608] socket: mark flags as unused --- src/libgit2/streams/socket.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/libgit2/streams/socket.c b/src/libgit2/streams/socket.c index cbf80587909..908e8c02f9b 100644 --- a/src/libgit2/streams/socket.c +++ b/src/libgit2/streams/socket.c @@ -135,7 +135,8 @@ static ssize_t socket_write(git_stream *stream, const char *data, size_t len, in git_socket_stream *st = (git_socket_stream *) stream; ssize_t written; - assert(flags == 0); + GIT_ASSERT(flags == 0); + GIT_UNUSED(flags); errno = 0; From b8fff35ab32a384f7e224d1afd06ef4fe1863e1f Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Wed, 15 Feb 2023 10:08:42 +0000 Subject: [PATCH 142/608] tests: use static scope for test data --- tests/libgit2/repo/extensions.c | 2 +- tests/libgit2/repo/objectformat.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/tests/libgit2/repo/extensions.c b/tests/libgit2/repo/extensions.c index e7772acd512..105cdae12f4 100644 --- a/tests/libgit2/repo/extensions.c +++ b/tests/libgit2/repo/extensions.c @@ -3,7 +3,7 @@ #include "sysdir.h" #include -git_repository *repo; +static git_repository *repo; void test_repo_extensions__initialize(void) { diff --git a/tests/libgit2/repo/objectformat.c b/tests/libgit2/repo/objectformat.c index 3518115f4d9..d278e10c4b2 100644 --- a/tests/libgit2/repo/objectformat.c +++ b/tests/libgit2/repo/objectformat.c @@ -4,8 +4,8 @@ #include "repository.h" #include -git_repository *repo; -git_config *config; +static git_repository *repo; +static git_config *config; void test_repo_objectformat__initialize(void) { From 35580d88a834438275adea77785a5f356352ea21 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 16 Feb 2023 09:11:57 +0000 Subject: [PATCH 143/608] stash: fixes from code review --- include/git2/stash.h | 22 +++---------- src/libgit2/stash.c | 73 ++++++++++++++++++++------------------------ 2 files changed, 38 insertions(+), 57 deletions(-) diff --git a/include/git2/stash.h b/include/git2/stash.h index 3d70b36c310..dcfc013dc4e 100644 --- a/include/git2/stash.h +++ b/include/git2/stash.h @@ -57,15 +57,10 @@ typedef enum { * * @param out Object id of the commit containing the stashed state. * This commit is also the target of the direct reference refs/stash. - * * @param repo The owning repository. - * * @param stasher The identity of the person performing the stashing. - * * @param message Optional description along with the stashed state. - * * @param flags Flags to control the stashing process. (see GIT_STASH_* above) - * * @return 0 on success, GIT_ENOTFOUND where there's nothing to stash, * or error code. */ @@ -86,25 +81,21 @@ GIT_EXTERN(int) git_stash_save( typedef struct git_stash_save_options { unsigned int version; + /** Flags to control the stashing process. (see GIT_STASH_* above) */ + uint32_t flags; + /** The identity of the person performing the stashing. */ const git_signature *stasher; /** Optional description along with the stashed state. */ const char *message; - /** Flags to control the stashing process. (see GIT_STASH_* above) */ - uint32_t flags; - /** Optional paths that control which files are stashed. */ git_strarray paths; } git_stash_save_options; #define GIT_STASH_SAVE_OPTIONS_VERSION 1 -#define GIT_STASH_SAVE_OPTIONS_INIT { \ - GIT_STASH_SAVE_OPTIONS_VERSION, \ - NULL, \ - NULL, \ - GIT_STASH_DEFAULT } +#define GIT_STASH_SAVE_OPTIONS_INIT { GIT_STASH_SAVE_OPTIONS_VERSION } /** * Initialize git_stash_save_options structure @@ -121,14 +112,11 @@ GIT_EXTERN(int) git_stash_save_options_init( /** * Save the local modifications to a new stash, with options. - * + * * @param out Object id of the commit containing the stashed state. * This commit is also the target of the direct reference refs/stash. - * * @param repo The owning repository. - * * @param opts The stash options. - * * @return 0 on success, GIT_ENOTFOUND where there's nothing to stash, * or error code. */ diff --git a/src/libgit2/stash.c b/src/libgit2/stash.c index af65aae3c4d..80eaddecf77 100644 --- a/src/libgit2/stash.c +++ b/src/libgit2/stash.c @@ -199,16 +199,16 @@ static int stash_update_index_from_paths( const git_strarray *paths) { unsigned int status_flags; - size_t i, error = 0; + size_t i; + int error = 0; - for(i = 0; i < paths->count; i++) { + for (i = 0; i < paths->count; i++) { git_status_file(&status_flags, repo, paths->strings[i]); if (status_flags & (GIT_STATUS_WT_DELETED | GIT_STATUS_INDEX_DELETED)) { if ((error = git_index_remove(index, paths->strings[i], 0)) < 0) return error; - } - else { + } else { if ((error = stash_to_index(repo, index, paths->strings[i])) < 0) return error; } @@ -453,7 +453,7 @@ static int build_stash_commit_from_index( { git_tree *tree; int error; - + if ((error = build_tree_from_index(&tree, repo, index)) < 0) goto cleanup; @@ -465,8 +465,7 @@ static int build_stash_commit_from_index( i_commit, b_commit, u_commit, - tree - ); + tree); cleanup: git_tree_free(tree); @@ -599,7 +598,11 @@ static int ensure_there_are_changes_to_stash(git_repository *repo, uint32_t flag return error; } -static int has_changes_cb(const char *path, unsigned int status, void *payload) { +static int has_changes_cb( + const char *path, + unsigned int status, + void *payload) +{ GIT_UNUSED(path); GIT_UNUSED(status); GIT_UNUSED(payload); @@ -619,9 +622,9 @@ static int ensure_there_are_changes_to_stash_paths( git_status_options opts = GIT_STATUS_OPTIONS_INIT; opts.show = GIT_STATUS_SHOW_INDEX_AND_WORKDIR; - opts.flags = GIT_STATUS_OPT_EXCLUDE_SUBMODULES - | GIT_STATUS_OPT_INCLUDE_UNMODIFIED - | GIT_STATUS_OPT_DISABLE_PATHSPEC_MATCH; + opts.flags = GIT_STATUS_OPT_EXCLUDE_SUBMODULES | + GIT_STATUS_OPT_INCLUDE_UNMODIFIED | + GIT_STATUS_OPT_DISABLE_PATHSPEC_MATCH; if (flags & GIT_STASH_INCLUDE_UNTRACKED) opts.flags |= GIT_STATUS_OPT_INCLUDE_UNTRACKED | @@ -630,7 +633,7 @@ static int ensure_there_are_changes_to_stash_paths( if (flags & GIT_STASH_INCLUDE_IGNORED) opts.flags |= GIT_STATUS_OPT_INCLUDE_IGNORED | GIT_STATUS_OPT_RECURSE_IGNORED_DIRS; - + git_strarray_copy(&opts.pathspec, paths); error = git_status_foreach_ext(repo, &opts, has_changes_cb, NULL); @@ -664,17 +667,20 @@ int git_stash_save( uint32_t flags) { git_stash_save_options opts = GIT_STASH_SAVE_OPTIONS_INIT; - + GIT_ASSERT_ARG(stasher); - + opts.stasher = stasher; opts.message = message; opts.flags = flags; + return git_stash_save_with_opts(out, repo, &opts); } int git_stash_save_with_opts( - git_oid *out, git_repository *repo, const git_stash_save_options *opts) + git_oid *out, + git_repository *repo, + const git_stash_save_options *opts) { git_index *index = NULL, *paths_index = NULL; git_commit *b_commit = NULL, *i_commit = NULL, *u_commit = NULL; @@ -725,22 +731,12 @@ int git_stash_save_with_opts( i_commit, b_commit, u_commit)) < 0) goto cleanup; } else { - if ((error = git_index_new(&paths_index)) < 0) - goto cleanup; - - if ((error = retrieve_head(&head, repo)) < 0) - goto cleanup; - - if ((error = git_reference_peel((git_object**)&tree, head, GIT_OBJECT_TREE)) < 0) - goto cleanup; - - if ((error = git_index_read_tree(paths_index, tree)) < 0) - goto cleanup; - - if ((error = stash_update_index_from_paths(repo, paths_index, &opts->paths)) < 0) - goto cleanup; - - if ((error = build_stash_commit_from_index(out, repo, opts->stasher, git_str_cstr(&msg), + if ((error = git_index_new(&paths_index)) < 0 || + (error = retrieve_head(&head, repo)) < 0 || + (error = git_reference_peel((git_object**)&tree, head, GIT_OBJECT_TREE)) < 0 || + (error = git_index_read_tree(paths_index, tree)) < 0 || + (error = stash_update_index_from_paths(repo, paths_index, &opts->paths)) < 0 || + (error = build_stash_commit_from_index(out, repo, opts->stasher, git_str_cstr(&msg), i_commit, b_commit, u_commit, paths_index)) < 0) goto cleanup; } @@ -750,23 +746,20 @@ int git_stash_save_with_opts( if ((error = update_reflog(out, repo, git_str_cstr(&msg))) < 0) goto cleanup; - if (!(opts->flags & GIT_STASH_KEEP_ALL) && (error = reset_index_and_workdir(repo, - (opts->flags & GIT_STASH_KEEP_INDEX) ? i_commit : b_commit, opts->flags)) < 0) + if (!(opts->flags & GIT_STASH_KEEP_ALL) && + (error = reset_index_and_workdir(repo, + (opts->flags & GIT_STASH_KEEP_INDEX) ? i_commit : b_commit,opts->flags)) < 0) goto cleanup; cleanup: - git_str_dispose(&msg); git_commit_free(i_commit); git_commit_free(b_commit); git_commit_free(u_commit); git_tree_free(tree); - - if (has_paths) { - git_reference_free(head); - git_index_free(index); - git_index_free(paths_index); - } + git_reference_free(head); + git_index_free(index); + git_index_free(paths_index); return error; } From 7c6df9e12543577f5efd52383435336bb84279cc Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 16 Feb 2023 09:36:25 +0000 Subject: [PATCH 144/608] strarray: remove deprecated declaration `git_strarray_copy` is deprecated (and has been included in `deprecated.h` for some time). It should not have remained in the public `strarray.h`. Remove it. --- include/git2/strarray.h | 13 ------------- src/libgit2/describe.c | 2 +- src/libgit2/remote.c | 1 + src/libgit2/strarray.c | 1 + src/libgit2/strarray.h | 25 +++++++++++++++++++++++++ 5 files changed, 28 insertions(+), 14 deletions(-) create mode 100644 src/libgit2/strarray.h diff --git a/include/git2/strarray.h b/include/git2/strarray.h index 0f657e6c57d..03d93f8fbbc 100644 --- a/include/git2/strarray.h +++ b/include/git2/strarray.h @@ -36,19 +36,6 @@ typedef struct git_strarray { */ GIT_EXTERN(void) git_strarray_dispose(git_strarray *array); -/** - * Copy a string array object from source to target. - * - * Note: target is overwritten and hence should be empty, otherwise its - * contents are leaked. Call git_strarray_free() if necessary. - * - * @param tgt target - * @param src source - * @return 0 on success, < 0 on allocation failure - */ -GIT_EXTERN(int) git_strarray_copy(git_strarray *tgt, const git_strarray *src); - - /** @} */ GIT_END_DECL diff --git a/src/libgit2/describe.c b/src/libgit2/describe.c index 20a171aa58d..3f73d87d63f 100644 --- a/src/libgit2/describe.c +++ b/src/libgit2/describe.c @@ -8,7 +8,6 @@ #include "common.h" #include "git2/describe.h" -#include "git2/strarray.h" #include "git2/diff.h" #include "git2/status.h" @@ -19,6 +18,7 @@ #include "refs.h" #include "repository.h" #include "revwalk.h" +#include "strarray.h" #include "tag.h" #include "vector.h" #include "wildmatch.h" diff --git a/src/libgit2/remote.c b/src/libgit2/remote.c index 3583ec031e2..ab6b5edbcd5 100644 --- a/src/libgit2/remote.c +++ b/src/libgit2/remote.c @@ -17,6 +17,7 @@ #include "fetchhead.h" #include "push.h" #include "proxy.h" +#include "strarray.h" #include "git2/config.h" #include "git2/types.h" diff --git a/src/libgit2/strarray.c b/src/libgit2/strarray.c index 2f9b77cc280..25e75f02ad9 100644 --- a/src/libgit2/strarray.c +++ b/src/libgit2/strarray.c @@ -8,6 +8,7 @@ #include "util.h" #include "common.h" +#include "strarray.h" int git_strarray_copy(git_strarray *tgt, const git_strarray *src) { diff --git a/src/libgit2/strarray.h b/src/libgit2/strarray.h new file mode 100644 index 00000000000..1984805357a --- /dev/null +++ b/src/libgit2/strarray.h @@ -0,0 +1,25 @@ +/* + * Copyright (C) the libgit2 contributors. All rights reserved. + * + * This file is part of libgit2, distributed under the GNU GPL v2 with + * a Linking Exception. For full terms see the included COPYING file. + */ +#ifndef INCLUDE_strarray_h__ +#define INCLUDE_strarray_h__ + +#include "common.h" +#include "git2/strarray.h" + +/** + * Copy a string array object from source to target. + * + * Note: target is overwritten and hence should be empty, otherwise its + * contents are leaked. Call git_strarray_free() if necessary. + * + * @param tgt target + * @param src source + * @return 0 on success, < 0 on allocation failure + */ +extern int git_strarray_copy(git_strarray *tgt, const git_strarray *src); + +#endif From 797926633a37997f8c64e8dc18ebcd2f3f06ecfc Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 16 Feb 2023 12:38:59 +0000 Subject: [PATCH 145/608] stash: update strarray usage --- src/libgit2/stash.c | 1 + 1 file changed, 1 insertion(+) diff --git a/src/libgit2/stash.c b/src/libgit2/stash.c index 80eaddecf77..319ae3a3f0c 100644 --- a/src/libgit2/stash.c +++ b/src/libgit2/stash.c @@ -25,6 +25,7 @@ #include "merge.h" #include "diff.h" #include "diff_generate.h" +#include "strarray.h" static int create_error(int error, const char *msg) { From f487b8478af3e2eb737443b8d3bbd3dbcbef29b2 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 16 Feb 2023 12:59:52 +0000 Subject: [PATCH 146/608] actions: simplify execution with composite action --- .github/actions/run-build/action.yml | 45 ++++++++++++++++++++++++ .github/workflows/main.yml | 51 ++++++++-------------------- 2 files changed, 59 insertions(+), 37 deletions(-) create mode 100644 .github/actions/run-build/action.yml diff --git a/.github/actions/run-build/action.yml b/.github/actions/run-build/action.yml new file mode 100644 index 00000000000..41145d3b4f0 --- /dev/null +++ b/.github/actions/run-build/action.yml @@ -0,0 +1,45 @@ +# Run a build step in a container or directly on the Actions runner +name: Run Build Step +description: Run a build step in a container or directly on the Actions runner + +inputs: + command: + description: Command to run + required: true + type: string + container: + description: Optional container to run in + type: string + container-version: + description: Version of the container to run + type: string + +runs: + using: 'composite' + steps: + - run: | + if [ -n "${{ inputs.container }}" ]; then + docker run \ + --rm \ + --user "$(id -u):$(id -g)" \ + -v "$(pwd)/source:/home/libgit2/source" \ + -v "$(pwd)/build:/home/libgit2/build" \ + -w /home/libgit2 \ + -e ASAN_SYMBOLIZER_PATH \ + -e CC \ + -e CFLAGS \ + -e CMAKE_GENERATOR \ + -e CMAKE_OPTIONS \ + -e GITTEST_NEGOTIATE_PASSWORD \ + -e GITTEST_FLAKY_STAT \ + -e PKG_CONFIG_PATH \ + -e SKIP_NEGOTIATE_TESTS \ + -e SKIP_SSH_TESTS \ + -e TSAN_OPTIONS \ + -e UBSAN_OPTIONS \ + ${{ inputs.container-version }} \ + /bin/bash -c "${{ inputs.command }}" + else + ${{ inputs.command }} + fi + shell: bash diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 0eedab87a20..9df073915c8 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -286,43 +286,20 @@ jobs: docker build -t ${{ env.docker-registry-container-sha }} --build-arg UID=$(id -u) --build-arg GID=$(id -g) ${BASE_ARG} -f ${{ env.dockerfile }} . working-directory: ${{ env.docker-config-path }} if: matrix.platform.container.name != '' && env.docker-container-exists != 'true' - - name: Build and test - run: | - export GITTEST_NEGOTIATE_PASSWORD="${{ secrets.GITTEST_NEGOTIATE_PASSWORD }}" - export GITTEST_GITHUB_SSH_KEY="${{ secrets.GITTEST_GITHUB_SSH_KEY }}" - export GITTEST_GITHUB_SSH_PUBKEY="${{ secrets.GITTEST_GITHUB_SSH_PUBKEY }}" - export GITTEST_GITHUB_SSH_PASSPHRASE="${{ secrets.GITTEST_GITHUB_SSH_PASSPHRASE }}" - export GITTEST_GITHUB_SSH_REMOTE_HOSTKEY="${{ secrets.GITTEST_GITHUB_SSH_REMOTE_HOSTKEY }}" - - if [ -n "${{ matrix.platform.container.name }}" ]; then - mkdir build - docker run \ - --rm \ - --user "$(id -u):$(id -g)" \ - -v "$(pwd)/source:/home/libgit2/source" \ - -v "$(pwd)/build:/home/libgit2/build" \ - -w /home/libgit2 \ - -e ASAN_SYMBOLIZER_PATH \ - -e CC \ - -e CFLAGS \ - -e CMAKE_GENERATOR \ - -e CMAKE_OPTIONS \ - -e GITTEST_NEGOTIATE_PASSWORD \ - -e GITTEST_FLAKY_STAT \ - -e PKG_CONFIG_PATH \ - -e SKIP_NEGOTIATE_TESTS \ - -e SKIP_SSH_TESTS \ - -e TSAN_OPTIONS \ - -e UBSAN_OPTIONS \ - ${{ env.docker-registry-container-sha }} \ - /bin/bash -c "cd build && ../source/ci/build.sh && ../source/ci/test.sh" - else - mkdir build - cd build - ../source/ci/build.sh - ../source/ci/test.sh - fi - shell: bash + - name: Prepare build + run: mkdir build + - name: Build + uses: ./.github/actions/run-build + with: + command: cd build && ../source/ci/build.sh + container: ${{ matrix.platform.container.name }} + container-version: ${{ env.docker-registry-container-sha }} + - name: Test + uses: .github/workflows/run-build.yml@ethomson/workflow + with: + command: cd build && ../source/ci/test.sh + container: ${{ matrix.platform.container.name }} + container-version: ${{ env.docker-registry-container-sha }} - name: Upload test results uses: actions/upload-artifact@v3 if: success() || failure() From 14c86fc268398c7b87a5623696b342960a6e650d Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 16 Feb 2023 13:02:36 +0000 Subject: [PATCH 147/608] fixup! actions: simplify execution with composite action --- .github/workflows/main.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 9df073915c8..bcf8e4c17eb 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -295,7 +295,7 @@ jobs: container: ${{ matrix.platform.container.name }} container-version: ${{ env.docker-registry-container-sha }} - name: Test - uses: .github/workflows/run-build.yml@ethomson/workflow + uses: ./.github/actions/run-build with: command: cd build && ../source/ci/test.sh container: ${{ matrix.platform.container.name }} From 45e95144f399c6894ef8bfeca46c25511c8461a4 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 16 Feb 2023 13:04:48 +0000 Subject: [PATCH 148/608] fixup! fixup! actions: simplify execution with composite action --- .github/workflows/main.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index bcf8e4c17eb..d64c91587de 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -289,13 +289,13 @@ jobs: - name: Prepare build run: mkdir build - name: Build - uses: ./.github/actions/run-build + uses: ./source/.github/actions/run-build with: command: cd build && ../source/ci/build.sh container: ${{ matrix.platform.container.name }} container-version: ${{ env.docker-registry-container-sha }} - name: Test - uses: ./.github/actions/run-build + uses: ./source/.github/actions/run-build with: command: cd build && ../source/ci/test.sh container: ${{ matrix.platform.container.name }} From cf754031ce99f13ee8995d4a6e0d1cd6763da982 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 17 Feb 2023 13:10:39 +0000 Subject: [PATCH 149/608] nightly --- .github/workflows/nightly.yml | 43 ++++++++++++----------------------- 1 file changed, 14 insertions(+), 29 deletions(-) diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml index 5a0b7d12b0b..8e66e65a2ab 100644 --- a/.github/workflows/nightly.yml +++ b/.github/workflows/nightly.yml @@ -324,35 +324,20 @@ jobs: run: docker build -t ${{ env.docker-registry-container-sha }} -f ${{ env.dockerfile }} . working-directory: ${{ env.docker-config-path }} if: matrix.platform.container.name != '' && env.docker-container-exists != 'true' - - name: Build and test - run: | - export GITTEST_NEGOTIATE_PASSWORD="${{ secrets.GITTEST_NEGOTIATE_PASSWORD }}" - - if [ -n "${{ matrix.platform.container.name }}" ]; then - docker run \ - --rm \ - --user libgit2:libgit2 \ - -v "$(pwd)/source:/home/libgit2/source" \ - -w /home/libgit2 \ - -e ASAN_SYMBOLIZER_PATH \ - -e CC \ - -e CFLAGS \ - -e CMAKE_GENERATOR \ - -e CMAKE_OPTIONS \ - -e GITTEST_NEGOTIATE_PASSWORD \ - -e GITTEST_FLAKY_STAT \ - -e PKG_CONFIG_PATH \ - -e SKIP_NEGOTIATE_TESTS \ - -e SKIP_SSH_TESTS \ - -e TSAN_OPTIONS \ - ${{ env.docker-registry-container-sha }} \ - /bin/bash -c "mkdir build && cd build && ../source/ci/build.sh && ../source/ci/test.sh" - else - mkdir build && cd build - ../source/ci/build.sh - ../source/ci/test.sh - fi - shell: bash + - name: Prepare build + run: mkdir build + - name: Build + uses: ./source/.github/actions/run-build + with: + command: cd build && ../source/ci/build.sh + container: ${{ matrix.platform.container.name }} + container-version: ${{ env.docker-registry-container-sha }} + - name: Test + uses: ./source/.github/actions/run-build + with: + command: cd build && ../source/ci/test.sh + container: ${{ matrix.platform.container.name }} + container-version: ${{ env.docker-registry-container-sha }} coverity: # Only run scheduled workflows on the main repository; prevents people From 7eb63188e56bc8cc7d211c9482d8483a507c4a15 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 17 Feb 2023 14:33:59 +0000 Subject: [PATCH 150/608] reusable --- .github/workflows/build-containers.yml | 72 ++++++++++++++++++++++++++ .github/workflows/main.yml | 61 +--------------------- 2 files changed, 73 insertions(+), 60 deletions(-) create mode 100644 .github/workflows/build-containers.yml diff --git a/.github/workflows/build-containers.yml b/.github/workflows/build-containers.yml new file mode 100644 index 00000000000..767798bf6d0 --- /dev/null +++ b/.github/workflows/build-containers.yml @@ -0,0 +1,72 @@ +# Generate the containers that we use for builds. +name: Build Containers + +on: + workflow_call: + +env: + docker-registry: ghcr.io + docker-config-path: source/ci/docker + +jobs: + # Build the docker container images that we will use for our Linux + # builds. This will identify the last commit to the repository that + # updated the docker images, and try to download the image tagged with + # that sha. If it does not exist, we'll do a docker build and push + # the image up to GitHub Packages for the actual CI/CD runs. We tag + # with both the sha and "latest" so that the subsequent runs need not + # know the sha. Only do this on CI builds (when the event is a "push") + # because PR builds from forks lack permission to write packages. + containers: + strategy: + matrix: + container: + - name: xenial + - name: bionic + - name: focal + - name: docurium + - name: bionic-x86 + dockerfile: bionic + base: multiarch/ubuntu-core:x86-bionic + qemu: true + - name: bionic-arm32 + dockerfile: bionic + base: multiarch/ubuntu-core:armhf-bionic + qemu: true + - name: bionic-arm64 + dockerfile: bionic + base: multiarch/ubuntu-core:arm64-bionic + qemu: true + - name: centos7 + - name: centos8 + runs-on: ubuntu-latest + name: "Create container: ${{ matrix.container.name }}" + steps: + - name: Check out repository + uses: actions/checkout@v3 + with: + path: source + fetch-depth: 0 + if: github.event_name != 'pull_request' + - name: Setup QEMU + run: docker run --rm --privileged multiarch/qemu-user-static:register --reset + if: matrix.container.qemu == true + - name: Download existing container + run: | + "${{ github.workspace }}/source/ci/getcontainer.sh" "${{ matrix.container.name }}" "${{ matrix.container.dockerfile }}" + env: + DOCKER_REGISTRY: ${{ env.docker-registry }} + GITHUB_TOKEN: ${{ secrets.github_token }} + working-directory: ${{ env.docker-config-path }} + if: github.event_name != 'pull_request' + - name: Build and publish image + run: | + if [ "${{ matrix.container.base }}" != "" ]; then + BASE_ARG="--build-arg BASE=${{ matrix.container.base }}" + fi + docker build -t ${{ env.docker-registry-container-sha }} --build-arg UID=$(id -u) --build-arg GID=$(id -g) ${BASE_ARG} -f ${{ env.dockerfile }} . + docker tag ${{ env.docker-registry-container-sha }} ${{ env.docker-registry-container-latest }} + docker push ${{ env.docker-registry-container-sha }} + docker push ${{ env.docker-registry-container-latest }} + working-directory: ${{ env.docker-config-path }} + if: github.event_name != 'pull_request' && env.docker-container-exists != 'true' diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index d64c91587de..d4ea86d1802 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -14,67 +14,8 @@ env: docker-config-path: source/ci/docker jobs: - # Build the docker container images that we will use for our Linux - # builds. This will identify the last commit to the repository that - # updated the docker images, and try to download the image tagged with - # that sha. If it does not exist, we'll do a docker build and push - # the image up to GitHub Packages for the actual CI/CD runs. We tag - # with both the sha and "latest" so that the subsequent runs need not - # know the sha. Only do this on CI builds (when the event is a "push") - # because PR builds from forks lack permission to write packages. containers: - strategy: - matrix: - container: - - name: xenial - - name: bionic - - name: focal - - name: docurium - - name: bionic-x86 - dockerfile: bionic - base: multiarch/ubuntu-core:x86-bionic - qemu: true - - name: bionic-arm32 - dockerfile: bionic - base: multiarch/ubuntu-core:armhf-bionic - qemu: true - - name: bionic-arm64 - dockerfile: bionic - base: multiarch/ubuntu-core:arm64-bionic - qemu: true - - name: centos7 - - name: centos8 - runs-on: ubuntu-latest - name: "Create container: ${{ matrix.container.name }}" - steps: - - name: Check out repository - uses: actions/checkout@v3 - with: - path: source - fetch-depth: 0 - if: github.event_name != 'pull_request' - - name: Setup QEMU - run: docker run --rm --privileged multiarch/qemu-user-static:register --reset - if: matrix.container.qemu == true - - name: Download existing container - run: | - "${{ github.workspace }}/source/ci/getcontainer.sh" "${{ matrix.container.name }}" "${{ matrix.container.dockerfile }}" - env: - DOCKER_REGISTRY: ${{ env.docker-registry }} - GITHUB_TOKEN: ${{ secrets.github_token }} - working-directory: ${{ env.docker-config-path }} - if: github.event_name != 'pull_request' - - name: Build and publish image - run: | - if [ "${{ matrix.container.base }}" != "" ]; then - BASE_ARG="--build-arg BASE=${{ matrix.container.base }}" - fi - docker build -t ${{ env.docker-registry-container-sha }} --build-arg UID=$(id -u) --build-arg GID=$(id -g) ${BASE_ARG} -f ${{ env.dockerfile }} . - docker tag ${{ env.docker-registry-container-sha }} ${{ env.docker-registry-container-latest }} - docker push ${{ env.docker-registry-container-sha }} - docker push ${{ env.docker-registry-container-latest }} - working-directory: ${{ env.docker-config-path }} - if: github.event_name != 'pull_request' && env.docker-container-exists != 'true' + uses: ./.github/workflows/build-containers.yml # Run our CI/CD builds. We build a matrix with the various build targets # and their details. Then we build either in a docker container (Linux) From c1b024fb4d69f9a9eab3d1f20d9547d0e59ae642 Mon Sep 17 00:00:00 2001 From: Miguel Arroz <750683+arroz@users.noreply.github.com> Date: Fri, 17 Feb 2023 11:06:48 -0800 Subject: [PATCH 151/608] #6491: Sets oid_type on repos open with git_repository_open_bare --- src/libgit2/repository.c | 70 +++++++++++++++++++++++++++------------ tests/libgit2/repo/open.c | 3 ++ 2 files changed, 51 insertions(+), 22 deletions(-) diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index 489d627a0de..45387b531ac 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -733,6 +733,43 @@ static int find_repo( return error; } +static int obtain_config_and_set_oid_type( + git_config **config_ptr, + git_repository *repo) +{ + int error; + git_config *config = NULL; + int version = 0; + + /* + * We'd like to have the config, but git doesn't particularly + * care if it's not there, so we need to deal with that. + */ + + error = git_repository_config_snapshot(&config, repo); + if (error < 0 && error != GIT_ENOTFOUND) + goto out; + + if (config && + (error = check_repositoryformatversion(&version, config)) < 0) + goto out; + + if ((error = check_extensions(config, version)) < 0) + goto out; + + if (version > 0) { + if ((error = load_objectformat(repo, config)) < 0) + goto out; + } else { + repo->oid_type = GIT_OID_SHA1; + } + +out: + *config_ptr = config; + + return error; +} + int git_repository_open_bare( git_repository **repo_ptr, const char *bare_path) @@ -741,6 +778,7 @@ int git_repository_open_bare( git_repository *repo = NULL; bool is_valid; int error; + git_config *config; if ((error = git_fs_path_prettify_dir(&path, bare_path, NULL)) < 0 || (error = is_valid_repository_path(&is_valid, &path, &common_path)) < 0) @@ -766,8 +804,15 @@ int git_repository_open_bare( repo->is_worktree = 0; repo->workdir = NULL; + if ((error = obtain_config_and_set_oid_type(&config, repo)) < 0) + goto cleanup; + *repo_ptr = repo; - return 0; + +cleanup: + git_config_free(config); + + return error; } static int _git_repository_open_ext_from_env( @@ -1007,20 +1052,8 @@ int git_repository_open_ext( goto cleanup; repo->is_worktree = is_worktree; - /* - * We'd like to have the config, but git doesn't particularly - * care if it's not there, so we need to deal with that. - */ - - error = git_repository_config_snapshot(&config, repo); - if (error < 0 && error != GIT_ENOTFOUND) - goto cleanup; - - if (config && - (error = check_repositoryformatversion(&version, config)) < 0) - goto cleanup; - - if ((error = check_extensions(config, version)) < 0) + error = obtain_config_and_set_oid_type(&config, repo); + if (error < 0) goto cleanup; if ((flags & GIT_REPOSITORY_OPEN_BARE) != 0) { @@ -1032,13 +1065,6 @@ int git_repository_open_ext( goto cleanup; } - if (version > 0) { - if ((error = load_objectformat(repo, config)) < 0) - goto cleanup; - } else { - repo->oid_type = GIT_OID_SHA1; - } - /* * Ensure that the git directory and worktree are * owned by the current user. diff --git a/tests/libgit2/repo/open.c b/tests/libgit2/repo/open.c index d835240b779..3d1a0620b12 100644 --- a/tests/libgit2/repo/open.c +++ b/tests/libgit2/repo/open.c @@ -410,6 +410,7 @@ void test_repo_open__no_config(void) git_str_dispose(&path); cl_git_pass(git_repository_open(&repo, "empty_standard_repo")); + cl_assert(git_repository_oid_type(repo) == GIT_OID_SHA1); cl_git_pass(git_repository_config(&config, repo)); cl_git_pass(git_config_set_string(config, "test.set", "42")); @@ -433,11 +434,13 @@ void test_repo_open__force_bare(void) cl_git_pass(git_repository_open(&barerepo, "alternate")); cl_assert(!git_repository_is_bare(barerepo)); + cl_assert(git_repository_oid_type(barerepo) == GIT_OID_SHA1); git_repository_free(barerepo); cl_git_pass(git_repository_open_bare( &barerepo, "empty_standard_repo/.git")); cl_assert(git_repository_is_bare(barerepo)); + cl_assert(git_repository_oid_type(barerepo) == GIT_OID_SHA1); git_repository_free(barerepo); cl_git_fail(git_repository_open_bare(&barerepo, "alternate/.git")); From 2ae3bbf32b85a12a75f878aff2a9a95690821960 Mon Sep 17 00:00:00 2001 From: Miguel Arroz <750683+arroz@users.noreply.github.com> Date: Fri, 17 Feb 2023 11:14:24 -0800 Subject: [PATCH 152/608] Deleted unused variable. --- src/libgit2/repository.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index 45387b531ac..a3e7b9e139f 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -1019,7 +1019,6 @@ int git_repository_open_ext( gitlink = GIT_STR_INIT, commondir = GIT_STR_INIT; git_repository *repo = NULL; git_config *config = NULL; - int version = 0; if (flags & GIT_REPOSITORY_OPEN_FROM_ENV) return _git_repository_open_ext_from_env(repo_ptr, start_path); From 1be70649432afc0dbac4fdd7d3d50d4881f3c634 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 18 Feb 2023 12:54:31 -0800 Subject: [PATCH 153/608] repo: don't fail on strange win32 paths With some paths on Win32, we cannot identify the owner because it's on a file share (WSL2 or UNC). In that case, don't fail, but identify that the current user does not own the path. This matches Git for Windows behavior. --- src/libgit2/repository.c | 3 +++ src/util/fs_path.c | 2 +- 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index 489d627a0de..c02662bdae6 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -547,6 +547,9 @@ static int validate_ownership_path(bool *is_safe, const char *path) if (error == GIT_ENOTFOUND) { *is_safe = true; error = 0; + } else if (error == GIT_EINVALID) { + *is_safe = false; + error = 0; } return error; diff --git a/src/util/fs_path.c b/src/util/fs_path.c index 6c87bfd01b2..b52867e779f 100644 --- a/src/util/fs_path.c +++ b/src/util/fs_path.c @@ -1855,7 +1855,7 @@ static int file_owner_sid(PSID *out, const char *path) PSECURITY_DESCRIPTOR descriptor = NULL; PSID owner_sid; DWORD ret; - int error = -1; + int error = GIT_EINVALID; if (git_win32_path_from_utf8(path_w32, path) < 0) return -1; From be3a78cc933169bab12dccdfcbb173cb48261103 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 20 Feb 2023 08:08:13 -0800 Subject: [PATCH 154/608] repo: support safe.directory with %(prefix)/ Git for Windows does some truly bizarre things with paths that start with a forward slash; and expects you to escape that with `%(prefix)`. This syntax generally means to add the prefix that Git was installed to -- eg `/usr/local` -- unless it's an absolute path, in which case the leading `%(prefix)/` is just removed. And Git for Windows expects you to use this syntax for absolute Unix-style paths (in "Git Bash" or Windows Subsystem for Linux). Worse, the behavior used to be that a leading `/` was not absolute. It would indicate that Git for Windows should add the prefix. So `//` is required for absolute Unix-style paths. Yes, this is truly horrifying. Emulate that behavior, I guess, but only for absolute paths. We won't deal with the Git install prefix. Also, give WSL users an escape hatch where they don't have to think about this and can use the literal path that the filesystem APIs provide (`//wsl.localhost/...`). --- src/libgit2/repository.c | 45 ++++++++++++++++++++++++++++++++++------ 1 file changed, 39 insertions(+), 6 deletions(-) diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index c02662bdae6..186b3d4ece6 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -496,14 +496,47 @@ static int validate_ownership_cb(const git_config_entry *entry, void *payload) { validate_ownership_data *data = payload; - if (strcmp(entry->value, "") == 0) + if (strcmp(entry->value, "") == 0) { *data->is_safe = false; - - if (strcmp(entry->value, "*") == 0) - *data->is_safe = true; - else if (git_fs_path_prettify_dir(&data->tmp, entry->value, NULL) == 0 && - strcmp(data->tmp.ptr, data->repo_path) == 0) + } else if (strcmp(entry->value, "*") == 0) { *data->is_safe = true; + } else { + const char *test_path = entry->value; + +#ifdef GIT_WIN32 + /* + * Git for Windows does some truly bizarre things with + * paths that start with a forward slash; and expects you + * to escape that with `%(prefix)`. This syntax generally + * means to add the prefix that Git was installed to -- eg + * `/usr/local` -- unless it's an absolute path, in which + * case the leading `%(prefix)/` is just removed. And Git + * for Windows expects you to use this syntax for absolute + * Unix-style paths (in "Git Bash" or Windows Subsystem for + * Linux). + * + * Worse, the behavior used to be that a leading `/` was + * not absolute. It would indicate that Git for Windows + * should add the prefix. So `//` is required for absolute + * Unix-style paths. Yes, this is truly horrifying. + * + * Emulate that behavior, I guess, but only for absolute + * paths. We won't deal with the Git install prefix. Also, + * give WSL users an escape hatch where they don't have to + * think about this and can use the literal path that the + * filesystem APIs provide (`//wsl.localhost/...`). + */ + if (strncmp(test_path, "%(prefix)//", strlen("%(prefix)//")) == 0) + test_path += strlen("%(prefix)/"); + else if (strncmp(test_path, "//", 2) == 0 && + strncmp(test_path, "//wsl.localhost/", strlen("//wsl.localhost/")) != 0) + test_path++; +#endif + + if (git_fs_path_prettify_dir(&data->tmp, test_path, NULL) == 0 && + strcmp(data->tmp.ptr, data->repo_path) == 0) + *data->is_safe = true; + } return 0; } From 3b7137415b192da14a2203f25d66ef2b51f91463 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 20 Feb 2023 20:37:45 +0000 Subject: [PATCH 155/608] README: clarify the linking exception We say that you can link libgit2 "unmodified"... "without having to release its source code". Clarify that you can modify libgit2 - but you must release _its_ source code back - and you can link libgit2 without having to release _your software's_ source code. --- README.md | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index 166a202f296..5e6b9828ac4 100644 --- a/README.md +++ b/README.md @@ -25,10 +25,11 @@ and on Git hosting providers like [GitHub](https://github.com/), We perform the merge every time you click "merge pull request". `libgit2` is licensed under a **very permissive license** (GPLv2 with a special -Linking Exception). This basically means that you can link it (unmodified) -with any kind of software without having to release its source code. -Additionally, the example code has been released to the public domain (see the -[separate license](examples/COPYING) for more information). +Linking Exception). The GPLv2 requires you to make changes you make _to libgit2 +itself_ available publicly, but the linking exception means that you can link +libgit2 with your software without it becoming "infected" by the libgit2 +license. Additionally, the example code has been released to the public +domain (see the [separate license](examples/COPYING) for more information). Table of Contents ================= From d286952f9e8fce847404f2651e4e341dd33e96eb Mon Sep 17 00:00:00 2001 From: Francois-Xavier Coudert Date: Wed, 22 Feb 2023 10:52:06 +0100 Subject: [PATCH 156/608] Make failure to connect to ssh-agent non-fatal Fixes https://github.com/libgit2/libgit2/issues/3866 Has been applied in all Julia builds since 2017: https://github.com/JuliaLang/julia/pull/17459 Authored-by: Keno Fischer --- src/libgit2/transports/ssh.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/libgit2/transports/ssh.c b/src/libgit2/transports/ssh.c index e90ab07e8f8..60d26e8023e 100644 --- a/src/libgit2/transports/ssh.c +++ b/src/libgit2/transports/ssh.c @@ -246,8 +246,10 @@ static int ssh_agent_auth(LIBSSH2_SESSION *session, git_credential_ssh_key *c) { rc = libssh2_agent_connect(agent); - if (rc != LIBSSH2_ERROR_NONE) + if (rc != LIBSSH2_ERROR_NONE) { + rc = LIBSSH2_ERROR_AUTHENTICATION_FAILED; goto shutdown; + } rc = libssh2_agent_list_identities(agent); From 3ebe0741f7d41e4e9fcd64feca347f86ea8b70d7 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Wed, 22 Feb 2023 22:44:03 +0000 Subject: [PATCH 157/608] Update README.md Update based on carlosmn suggestions. --- README.md | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/README.md b/README.md index 5e6b9828ac4..3730d4e6cee 100644 --- a/README.md +++ b/README.md @@ -25,11 +25,11 @@ and on Git hosting providers like [GitHub](https://github.com/), We perform the merge every time you click "merge pull request". `libgit2` is licensed under a **very permissive license** (GPLv2 with a special -Linking Exception). The GPLv2 requires you to make changes you make _to libgit2 -itself_ available publicly, but the linking exception means that you can link -libgit2 with your software without it becoming "infected" by the libgit2 -license. Additionally, the example code has been released to the public -domain (see the [separate license](examples/COPYING) for more information). +Linking Exception). This means that you can link against the library with any +kind of software without making that software fall under the GPL. +Changes to libgit2 would still be covered under its GPL license. +Additionally, the example code has been released to the public domain (see the +[separate license](examples/COPYING) for more information). Table of Contents ================= From 80016e0e9658662e67f39a937c52de64fa642ea9 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 23 Feb 2023 10:19:19 +0000 Subject: [PATCH 158/608] tests: always unset HTTP_PROXY before starting tests The remote::httpproxy::env test (correctly) reset the environment before running; however the other tests are also impacted by the environment and need to have it isolated. --- tests/libgit2/remote/httpproxy.c | 36 +++++++++++++------------------- 1 file changed, 15 insertions(+), 21 deletions(-) diff --git a/tests/libgit2/remote/httpproxy.c b/tests/libgit2/remote/httpproxy.c index 6ba00b7c951..60fc67dec31 100644 --- a/tests/libgit2/remote/httpproxy.c +++ b/tests/libgit2/remote/httpproxy.c @@ -6,7 +6,6 @@ static git_repository *repo; static git_net_url url = GIT_NET_URL_INIT; -static int orig_proxies_need_reset = 0; static char *orig_http_proxy = NULL; static char *orig_https_proxy = NULL; static char *orig_no_proxy = NULL; @@ -21,20 +20,25 @@ void test_remote_httpproxy__initialize(void) git_remote_free(remote); - orig_proxies_need_reset = 0; + /* Clear everything for a fresh start */ + orig_http_proxy = cl_getenv("HTTP_PROXY"); + orig_https_proxy = cl_getenv("HTTPS_PROXY"); + orig_no_proxy = cl_getenv("NO_PROXY"); + + cl_setenv("HTTP_PROXY", NULL); + cl_setenv("HTTPS_PROXY", NULL); + cl_setenv("NO_PROXY", NULL); } void test_remote_httpproxy__cleanup(void) { - if (orig_proxies_need_reset) { - cl_setenv("HTTP_PROXY", orig_http_proxy); - cl_setenv("HTTPS_PROXY", orig_https_proxy); - cl_setenv("NO_PROXY", orig_no_proxy); - - git__free(orig_http_proxy); - git__free(orig_https_proxy); - git__free(orig_no_proxy); - } + cl_setenv("HTTP_PROXY", orig_http_proxy); + cl_setenv("HTTPS_PROXY", orig_https_proxy); + cl_setenv("NO_PROXY", orig_no_proxy); + + git__free(orig_http_proxy); + git__free(orig_https_proxy); + git__free(orig_no_proxy); git_net_url_dispose(&url); cl_git_sandbox_cleanup(); @@ -145,16 +149,6 @@ void test_remote_httpproxy__config_overrides_detached_remote(void) void test_remote_httpproxy__env(void) { - orig_http_proxy = cl_getenv("HTTP_PROXY"); - orig_https_proxy = cl_getenv("HTTPS_PROXY"); - orig_no_proxy = cl_getenv("NO_PROXY"); - orig_proxies_need_reset = 1; - - /* Clear everything for a fresh start */ - cl_setenv("HTTP_PROXY", NULL); - cl_setenv("HTTPS_PROXY", NULL); - cl_setenv("NO_PROXY", NULL); - /* HTTP proxy is ignored for HTTPS */ cl_setenv("HTTP_PROXY", "http://localhost:9/"); assert_proxy_is(NULL); From d16b59c91e524bfa385b3db511da727a66694820 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 23 Feb 2023 14:03:16 +0000 Subject: [PATCH 159/608] odb: don't unconditionally add oid_type to stream `git_odb_stream` should have an `oid_type` to disambiguate; that's not necessary on non-experimental SHA256 builds. Avoid unnecessary ABI breakage for consumers and hide it behind an ifdef for now. --- include/git2/odb_backend.h | 2 ++ src/libgit2/odb.c | 2 ++ 2 files changed, 4 insertions(+) diff --git a/include/git2/odb_backend.h b/include/git2/odb_backend.h index 4d0559ec0e6..12dd0fd38a3 100644 --- a/include/git2/odb_backend.h +++ b/include/git2/odb_backend.h @@ -171,7 +171,9 @@ struct git_odb_stream { unsigned int mode; void *hash_ctx; +#ifdef GIT_EXPERIMENTAL_SHA256 git_oid_t oid_type; +#endif git_object_size_t declared_size; git_object_size_t received_bytes; diff --git a/src/libgit2/odb.c b/src/libgit2/odb.c index edf4f001f11..1a02cbad974 100644 --- a/src/libgit2/odb.c +++ b/src/libgit2/odb.c @@ -1704,7 +1704,9 @@ int git_odb_open_wstream( (error = hash_header(ctx, size, type)) < 0) goto done; +#ifdef GIT_EXPERIMENTAL_SHA256 (*stream)->oid_type = db->options.oid_type; +#endif (*stream)->hash_ctx = ctx; (*stream)->declared_size = size; (*stream)->received_bytes = 0; From 86b532de1548669c8922b2bd3af57b21ab460e74 Mon Sep 17 00:00:00 2001 From: Tim Rogers Date: Thu, 23 Feb 2023 18:47:03 +0000 Subject: [PATCH 160/608] Correct the definition of "empty" in the docs for `git_repository_is_empty` This improves the documentation for `git_repository_is_empty` which currently does not accurately describe libgit2's definition of "empty". It says that HEAD must point to the "unborn master branch", when in fact, this is not the case if the repo's `init.defaultBranch` configuration is set. If it is set, it will check that HEAD points there. Only if it is not set does it fall back to `master`. --- include/git2/repository.h | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/include/git2/repository.h b/include/git2/repository.h index 04c240d2440..560e70ab6df 100644 --- a/include/git2/repository.h +++ b/include/git2/repository.h @@ -465,7 +465,9 @@ GIT_EXTERN(int) git_repository_head_unborn(git_repository *repo); * Check if a repository is empty * * An empty repository has just been initialized and contains no references - * apart from HEAD, which must be pointing to the unborn master branch. + * apart from HEAD, which must be pointing to the unborn master branch, + * or the branch specified for the repository in the `init.defaultBranch` + * configuration variable. * * @param repo Repo to test * @return 1 if the repository is empty, 0 if it isn't, error code From c2bdef6f3a16ca5c4ea32444b28772046da881a5 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 24 Feb 2023 17:29:47 +0000 Subject: [PATCH 161/608] net: parse urls or scp style paths in the same function --- src/libgit2/transports/ssh.c | 18 +++++++----------- src/util/net.c | 7 +++++++ src/util/net.h | 6 ++++++ 3 files changed, 20 insertions(+), 11 deletions(-) diff --git a/src/libgit2/transports/ssh.c b/src/libgit2/transports/ssh.c index 60d26e8023e..5500ea100bd 100644 --- a/src/libgit2/transports/ssh.c +++ b/src/libgit2/transports/ssh.c @@ -788,15 +788,8 @@ static int _git_ssh_setup_conn( s->session = NULL; s->channel = NULL; - if (git_net_str_is_url(url)) - error = git_net_url_parse(&s->url, url); - else - error = git_net_url_parse_scp(&s->url, url); - - if (error < 0) - goto done; - - if ((error = git_socket_stream_new(&s->io, s->url.host, s->url.port)) < 0 || + if ((error = git_net_url_parse_standard_or_scp(&s->url, url)) < 0 || + (error = git_socket_stream_new(&s->io, s->url.host, s->url.port)) < 0 || (error = git_stream_connect(s->io)) < 0) goto done; @@ -806,8 +799,11 @@ static int _git_ssh_setup_conn( * as part of the stream connection, but that's not something that's * exposed. */ - if (git__strntol32(&port, s->url.port, strlen(s->url.port), NULL, 10) < 0) - port = -1; + if (git__strntol32(&port, s->url.port, strlen(s->url.port), NULL, 10) < 0) { + git_error_set(GIT_ERROR_NET, "invalid port to ssh: %s", s->url.port); + error = -1; + goto done; + } if ((error = _git_ssh_session_create(&session, &known_hosts, s->url.host, port, s->io)) < 0) goto done; diff --git a/src/util/net.c b/src/util/net.c index 43c7dc952ac..ac7befe0738 100644 --- a/src/util/net.c +++ b/src/util/net.c @@ -646,6 +646,13 @@ int git_net_url_parse_scp(git_net_url *url, const char *given) return 0; } +int git_net_url_parse_standard_or_scp(git_net_url *url, const char *given) +{ + return git_net_str_is_url(given) ? + git_net_url_parse(url, given) : + git_net_url_parse_scp(url, given); +} + int git_net_url_joinpath( git_net_url *out, git_net_url *one, diff --git a/src/util/net.h b/src/util/net.h index 383592812bd..17f0bc4f079 100644 --- a/src/util/net.h +++ b/src/util/net.h @@ -34,6 +34,12 @@ extern int git_net_url_parse(git_net_url *url, const char *str); /** Parses a string containing an SCP style path into a URL structure. */ extern int git_net_url_parse_scp(git_net_url *url, const char *str); +/** + * Parses a string containing a standard URL or an SCP style path into + * a URL structure. + */ +extern int git_net_url_parse_standard_or_scp(git_net_url *url, const char *str); + /** Appends a path and/or query string to the given URL */ extern int git_net_url_joinpath( git_net_url *out, From f68b40c0af9c7c5c2c8740fe4a8fbcba367e0087 Mon Sep 17 00:00:00 2001 From: Francois-Xavier Coudert Date: Fri, 24 Feb 2023 11:05:31 +0100 Subject: [PATCH 162/608] Pass hostkey & port to host verify callback Co-authored-by: Stefan Karpinski --- src/libgit2/transports/ssh.c | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-) diff --git a/src/libgit2/transports/ssh.c b/src/libgit2/transports/ssh.c index 5500ea100bd..d7594aa124a 100644 --- a/src/libgit2/transports/ssh.c +++ b/src/libgit2/transports/ssh.c @@ -651,6 +651,8 @@ static int check_against_known_hosts( return ret; } +#define SSH_DEFAULT_PORT 22 + /* * Perform the check for the session's certificate against known hosts if * possible and then ask the user if they have a callback. @@ -748,9 +750,16 @@ static int check_certificate( if (check_cb != NULL) { git_cert_hostkey *cert_ptr = &cert; git_error_state previous_error = {0}; + const char *host_ptr = host; + git_str host_and_port = GIT_STR_INIT; + + if (port != SSH_DEFAULT_PORT) { + git_str_printf(&host_and_port, "%s:%d", host, port); + host_ptr = host_and_port.ptr; + } git_error_state_capture(&previous_error, error); - error = check_cb((git_cert *) cert_ptr, cert_valid, host, check_cb_payload); + error = check_cb((git_cert *) cert_ptr, cert_valid, host_ptr, check_cb_payload); if (error == GIT_PASSTHROUGH) { error = git_error_state_restore(&previous_error); } else if (error < 0 && !git_error_last()) { @@ -758,13 +767,12 @@ static int check_certificate( } git_error_state_free(&previous_error); + git_str_dispose(&host_and_port); } return error; } -#define SSH_DEFAULT_PORT "22" - static int _git_ssh_setup_conn( ssh_subtransport *t, const char *url, From 43e84e246cc716ac51a276945b5b112b21d802d1 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 24 Feb 2023 16:47:39 +0000 Subject: [PATCH 163/608] tests: validate host and port for ssh tests when non-standard --- tests/libgit2/online/clone.c | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/tests/libgit2/online/clone.c b/tests/libgit2/online/clone.c index 1a4cdb520ce..bb704c06675 100644 --- a/tests/libgit2/online/clone.c +++ b/tests/libgit2/online/clone.c @@ -787,10 +787,19 @@ static int ssh_certificate_check(git_cert *cert, int valid, const char *host, vo { git_cert_hostkey *key; git_oid expected = GIT_OID_SHA1_ZERO, actual = GIT_OID_SHA1_ZERO; + git_str expected_host = GIT_STR_INIT; + git_net_url parsed_url = GIT_NET_URL_INIT; GIT_UNUSED(valid); GIT_UNUSED(payload); + cl_git_pass(git_net_url_parse_standard_or_scp(&parsed_url, _remote_url)); + cl_git_pass(git_str_printf(&expected_host, "%s%s%s", + parsed_url.host, + git_net_url_is_default_port(&parsed_url) ? "" : ":", + git_net_url_is_default_port(&parsed_url) ? "" : parsed_url.port)); + cl_assert_equal_s(expected_host.ptr, host); + cl_assert(_remote_ssh_fingerprint); cl_git_pass(git_oid__fromstrp(&expected, _remote_ssh_fingerprint, GIT_OID_SHA1)); @@ -812,7 +821,8 @@ static int ssh_certificate_check(git_cert *cert, int valid, const char *host, vo cl_assert(!memcmp(&expected, &actual, 20)); - cl_assert_equal_s("localhost", host); + git_net_url_dispose(&parsed_url); + git_str_dispose(&expected_host); return GIT_EUSER; } From c5b306020d73397fecfc3f2f2f7a462b562818d9 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 23 Feb 2023 00:32:53 +0000 Subject: [PATCH 164/608] v1.6: update the changelog --- docs/changelog.md | 99 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 99 insertions(+) diff --git a/docs/changelog.md b/docs/changelog.md index 989800a11db..a51db0180a7 100644 --- a/docs/changelog.md +++ b/docs/changelog.md @@ -1,3 +1,102 @@ +v1.6 +---- + +This is release v1.6.0, "Hubbeliges Krokodil". This release adds experimental SHA256 support and includes many new features and bugfixes. + +## What's Changed + +### New features + +* **Support for bare repositories with SHA256 support (experimental)** by @ethomson in https://github.com/libgit2/libgit2/pull/6191 + You can configure experimental SHA256 support in libgit2 with `cmake -DEXPERIMENTAL_SHA256=ON` during project setup. This is useful for considering future integrations, work on clients, and work on language bindings. At present, working with bare repositories should largely work, including remote operations. But many pieces of functionality - including working with the index - are not yet supported. As a result, **libgit2 with SHA256 support should not be used in production or released with package distribution.** + +* **Support the notion of a home directory separately from global configuration directory** by @ethomson in https://github.com/libgit2/libgit2/pull/6455 and https://github.com/libgit2/libgit2/pull/6456 + Callers and language bindings can now configure the home directory that libgit2 uses for file lookups (eg, the `.ssh` directory). This configuration is separate from the git global configuration path. + +* **stash: partial stash specific files** by @gitkraken-jacobw in https://github.com/libgit2/libgit2/pull/6330 + A stash can be created with only specific files, using a pathspec. This is similar to the `git stash push` command. + +* **push: revparse refspec source, so you can push things that are not refs** by @sven-of-cord in https://github.com/libgit2/libgit2/pull/6362 + Pushes can be performed using refspecs instead of only references. + +* **Support OpenSSL3** by @ethomson in https://github.com/libgit2/libgit2/pull/6464 and https://github.com/libgit2/libgit2/pull/6471 + OpenSSL 3 is now supported, both when compiled directly and dynamically loaded. + +### Bug fixes +* winhttp: support long custom headers by @kcsaul in https://github.com/libgit2/libgit2/pull/6363 +* Fix memory leak by @csware in https://github.com/libgit2/libgit2/pull/6382 +* Don't fail the whole clone if you can't find a default branch by @torvalds in https://github.com/libgit2/libgit2/pull/6369 +* #6366: When a worktree is missing, return `GIT_ENOTFOUND`. by @arroz in https://github.com/libgit2/libgit2/pull/6395 +* commit-graph: only verify csum on `git_commit_graph_open()`. by @derrickstolee in https://github.com/libgit2/libgit2/pull/6420 +* Ignore missing 'safe.directory' config during ownership checks by @kcsaul in https://github.com/libgit2/libgit2/pull/6408 +* Fix leak in `git_tag_create_from_buffer` by @julianmesa-gitkraken in https://github.com/libgit2/libgit2/pull/6421 +* http: Update httpclient options when reusing an existing connection. by @slackner in https://github.com/libgit2/libgit2/pull/6416 +* Add support for `safe.directory *` by @csware in https://github.com/libgit2/libgit2/pull/6429 +* URL parsing for google-compatible URLs by @ethomson in https://github.com/libgit2/libgit2/pull/6326 +* Fixes #6433: `git_submodule_update` fails to update configured but missing submodule by @tagesuhu in https://github.com/libgit2/libgit2/pull/6434 +* transport: fix capabilities calculation by @russell in https://github.com/libgit2/libgit2/pull/6435 +* push: use resolved oid as the source by @ethomson in https://github.com/libgit2/libgit2/pull/6452 +* Use `git_clone__submodule` to avoid file checks in workdir by @abizjak in https://github.com/libgit2/libgit2/pull/6444 +* #6422: handle dangling symbolic refs gracefully by @arroz in https://github.com/libgit2/libgit2/pull/6423 +* `diff_file`: Fix crash when freeing a patch representing an empty untracked file by @jorio in https://github.com/libgit2/libgit2/pull/6475 +* clone: clean up options on failure by @ethomson in https://github.com/libgit2/libgit2/pull/6479 +* stash: update strarray usage by @ethomson in https://github.com/libgit2/libgit2/pull/6487 +* #6491: Sets `oid_type` on repos open with `git_repository_open_bare` by @arroz in https://github.com/libgit2/libgit2/pull/6492 +* Handle Win32 shares by @ethomson in https://github.com/libgit2/libgit2/pull/6493 +* Make failure to connect to ssh-agent non-fatal by @fxcoudert in https://github.com/libgit2/libgit2/pull/6497 +* odb: don't unconditionally add `oid_type` to stream by @ethomson in https://github.com/libgit2/libgit2/pull/6499 +* Pass hostkey & port to host verify callback by @fxcoudert in https://github.com/libgit2/libgit2/pull/6503 + +### Code cleanups +* meta: update version number to v1.6.0-alpha by @ethomson in https://github.com/libgit2/libgit2/pull/6352 +* sha256: indirection for experimental functions by @ethomson in https://github.com/libgit2/libgit2/pull/6354 +* Delete `create.c.bak` by @lrm29 in https://github.com/libgit2/libgit2/pull/6398 +* Support non-cmake builds with an in-tree `experimental.h` by @ethomson in https://github.com/libgit2/libgit2/pull/6405 + +### Build and CI improvements +* tests: skip flaky-ass googlesource tests by @ethomson in https://github.com/libgit2/libgit2/pull/6353 +* clar: remove ftrunacte from libgit2 tests by @boretrk in https://github.com/libgit2/libgit2/pull/6357 +* CI Improvements by @ethomson in https://github.com/libgit2/libgit2/pull/6403 +* fix compile on Windows with `-DWIN32_LEAN_AND_MEAN` by @christoph-cullmann in https://github.com/libgit2/libgit2/pull/6373 +* Fixes #6365 : Uppercase windows.h include fails build in case-sensitive OS by @Vinz2008 in https://github.com/libgit2/libgit2/pull/6377 +* ci: update version numbers of actions by @ethomson in https://github.com/libgit2/libgit2/pull/6448 +* thread: avoid warnings when building without threads by @ethomson in https://github.com/libgit2/libgit2/pull/6432 +* src: hide unused hmac() prototype by @0-wiz-0 in https://github.com/libgit2/libgit2/pull/6458 +* tests: update clar test runner by @ethomson in https://github.com/libgit2/libgit2/pull/6459 +* ci: always create test summaries, even on failure by @ethomson in https://github.com/libgit2/libgit2/pull/6460 +* Fix build failure with `-DEMBED_SSH_PATH` by @vicr123 in https://github.com/libgit2/libgit2/pull/6374 +* Define correct `off64_t` for AIX by @bzEq in https://github.com/libgit2/libgit2/pull/6376 +* Fix some warnings in main by @ethomson in https://github.com/libgit2/libgit2/pull/6480 +* strarray: remove deprecated declaration by @ethomson in https://github.com/libgit2/libgit2/pull/6486 +* tests: always unset `HTTP_PROXY` before starting tests by @ethomson in https://github.com/libgit2/libgit2/pull/6498 + +### Documentation improvements +* add 2-clause BSD license to COPYING by @martinvonz in https://github.com/libgit2/libgit2/pull/6413 +* Add new PHP bindings project to language bindings section of README.md by @RogerGee in https://github.com/libgit2/libgit2/pull/6473 +* README: clarify the linking exception by @ethomson in https://github.com/libgit2/libgit2/pull/6494 +* Correct the definition of "empty" in the docs for `git_repository_is_empty` by @timrogers in https://github.com/libgit2/libgit2/pull/6500 + +## New Contributors +* @christoph-cullmann made their first contribution in https://github.com/libgit2/libgit2/pull/6373 +* @Vinz2008 made their first contribution in https://github.com/libgit2/libgit2/pull/6377 +* @torvalds made their first contribution in https://github.com/libgit2/libgit2/pull/6369 +* @derrickstolee made their first contribution in https://github.com/libgit2/libgit2/pull/6420 +* @julianmesa-gitkraken made their first contribution in https://github.com/libgit2/libgit2/pull/6421 +* @slackner made their first contribution in https://github.com/libgit2/libgit2/pull/6416 +* @martinvonz made their first contribution in https://github.com/libgit2/libgit2/pull/6413 +* @tagesuhu made their first contribution in https://github.com/libgit2/libgit2/pull/6434 +* @russell made their first contribution in https://github.com/libgit2/libgit2/pull/6435 +* @sven-of-cord made their first contribution in https://github.com/libgit2/libgit2/pull/6362 +* @0-wiz-0 made their first contribution in https://github.com/libgit2/libgit2/pull/6458 +* @abizjak made their first contribution in https://github.com/libgit2/libgit2/pull/6444 +* @vicr123 made their first contribution in https://github.com/libgit2/libgit2/pull/6374 +* @bzEq made their first contribution in https://github.com/libgit2/libgit2/pull/6376 +* @gitkraken-jacobw made their first contribution in https://github.com/libgit2/libgit2/pull/6330 +* @fxcoudert made their first contribution in https://github.com/libgit2/libgit2/pull/6497 +* @timrogers made their first contribution in https://github.com/libgit2/libgit2/pull/6500 + +**Full Changelog**: https://github.com/libgit2/libgit2/compare/v1.5.0...v1.6.0 + v1.5 ---- From ef235a1662593a11260d0220b860aea70c2e47ec Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 23 Feb 2023 00:34:40 +0000 Subject: [PATCH 165/608] v1.6: update version numbers --- CMakeLists.txt | 2 +- README.md | 2 +- include/git2/version.h | 4 ++-- package.json | 2 +- 4 files changed, 5 insertions(+), 5 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index cf3b6224621..9d7bc6c6e91 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -6,7 +6,7 @@ cmake_minimum_required(VERSION 3.5.1) -project(libgit2 VERSION "1.5.0" LANGUAGES C) +project(libgit2 VERSION "1.6.0" LANGUAGES C) # Add find modules to the path set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${PROJECT_SOURCE_DIR}/cmake") diff --git a/README.md b/README.md index 3730d4e6cee..93476f9c0cd 100644 --- a/README.md +++ b/README.md @@ -4,8 +4,8 @@ libgit2 - the Git linkable library | Build Status | | | ------------ | - | | **main** branch CI builds | [![CI Build](https://github.com/libgit2/libgit2/workflows/CI%20Build/badge.svg?event=push)](https://github.com/libgit2/libgit2/actions?query=workflow%3A%22CI+Build%22+event%3Apush) | +| **v1.6 branch** CI builds | [![CI Build](https://github.com/libgit2/libgit2/workflows/CI%20Build/badge.svg?branch=maint%2Fv1.6&event=push)](https://github.com/libgit2/libgit2/actions?query=workflow%3A%22CI+Build%22+event%3Apush+branch%3Amaint%2Fv1.6) | | **v1.5 branch** CI builds | [![CI Build](https://github.com/libgit2/libgit2/workflows/CI%20Build/badge.svg?branch=maint%2Fv1.5&event=push)](https://github.com/libgit2/libgit2/actions?query=workflow%3A%22CI+Build%22+event%3Apush+branch%3Amaint%2Fv1.5) | -| **v1.4 branch** CI builds | [![CI Build](https://github.com/libgit2/libgit2/workflows/CI%20Build/badge.svg?branch=maint%2Fv1.4&event=push)](https://github.com/libgit2/libgit2/actions?query=workflow%3A%22CI+Build%22+event%3Apush+branch%3Amaint%2Fv1.4) | | **Nightly** builds | [![Nightly Build](https://github.com/libgit2/libgit2/workflows/Nightly%20Build/badge.svg)](https://github.com/libgit2/libgit2/actions?query=workflow%3A%22Nightly+Build%22) [![Coverity Scan Status](https://scan.coverity.com/projects/639/badge.svg)](https://scan.coverity.com/projects/639) | `libgit2` is a portable, pure C implementation of the Git core methods diff --git a/include/git2/version.h b/include/git2/version.h index 09f4ae3e4df..90f33e9395c 100644 --- a/include/git2/version.h +++ b/include/git2/version.h @@ -11,7 +11,7 @@ * The version string for libgit2. This string follows semantic * versioning (v2) guidelines. */ -#define LIBGIT2_VERSION "1.6.0-alpha" +#define LIBGIT2_VERSION "1.6.0" /** The major version number for this version of libgit2. */ #define LIBGIT2_VER_MAJOR 1 @@ -31,7 +31,7 @@ * a prerelease name like "beta" or "rc1". For final releases, this will * be `NULL`. */ -#define LIBGIT2_VER_PRERELEASE "alpha" +#define LIBGIT2_VER_PRERELEASE NULL /** The library ABI soversion for this version of libgit2. */ #define LIBGIT2_SOVERSION "1.6" diff --git a/package.json b/package.json index 8ef46d7610c..25d100bc5d8 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "libgit2", - "version": "1.6.0-alpha", + "version": "1.6.0", "repo": "https://github.com/libgit2/libgit2", "description": " A cross-platform, linkable library implementation of Git that you can use in your application.", "install": "mkdir build && cd build && cmake .. && cmake --build ." From 8a871d13b7f4e186b8ad943ae5a7fcf30be52e67 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 25 Feb 2023 13:52:34 +0000 Subject: [PATCH 166/608] v1.6.1: correct missing version number updates --- CMakeLists.txt | 2 +- docs/changelog.md | 2 +- include/git2/version.h | 4 ++-- package.json | 2 +- 4 files changed, 5 insertions(+), 5 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 9d7bc6c6e91..e49bee30217 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -6,7 +6,7 @@ cmake_minimum_required(VERSION 3.5.1) -project(libgit2 VERSION "1.6.0" LANGUAGES C) +project(libgit2 VERSION "1.6.1" LANGUAGES C) # Add find modules to the path set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${PROJECT_SOURCE_DIR}/cmake") diff --git a/docs/changelog.md b/docs/changelog.md index a51db0180a7..c27a07496ad 100644 --- a/docs/changelog.md +++ b/docs/changelog.md @@ -1,7 +1,7 @@ v1.6 ---- -This is release v1.6.0, "Hubbeliges Krokodil". This release adds experimental SHA256 support and includes many new features and bugfixes. +This is release v1.6.1, "Hubbeliges Krokodil". This release adds experimental SHA256 support and includes many new features and bugfixes. This release replaces libgit2 v1.6.0, which did not correctly update its version number(s). ## What's Changed diff --git a/include/git2/version.h b/include/git2/version.h index 90f33e9395c..33726a58ad9 100644 --- a/include/git2/version.h +++ b/include/git2/version.h @@ -11,7 +11,7 @@ * The version string for libgit2. This string follows semantic * versioning (v2) guidelines. */ -#define LIBGIT2_VERSION "1.6.0" +#define LIBGIT2_VERSION "1.6.1" /** The major version number for this version of libgit2. */ #define LIBGIT2_VER_MAJOR 1 @@ -20,7 +20,7 @@ #define LIBGIT2_VER_MINOR 6 /** The revision ("teeny") version number for this version of libgit2. */ -#define LIBGIT2_VER_REVISION 0 +#define LIBGIT2_VER_REVISION 1 /** The Windows DLL patch number for this version of libgit2. */ #define LIBGIT2_VER_PATCH 0 diff --git a/package.json b/package.json index 25d100bc5d8..0448346bad1 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "libgit2", - "version": "1.6.0", + "version": "1.6.1", "repo": "https://github.com/libgit2/libgit2", "description": " A cross-platform, linkable library implementation of Git that you can use in your application.", "install": "mkdir build && cd build && cmake .. && cmake --build ." From e25f9a9bb85e062aeff3d0713e35dd1ad31962d3 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 25 Feb 2023 22:24:10 +0000 Subject: [PATCH 167/608] repo: don't allow repeated extensions If a user attempts to add a custom extension that the system already supports, or that is already in their list of custom extensions, de-dup it. --- src/libgit2/repository.c | 38 +++++++++++++++++++++++++++++++++----- tests/libgit2/core/opts.c | 29 +++++++++++++++++++++++------ 2 files changed, 56 insertions(+), 11 deletions(-) diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index 8c41167a1c0..e16413f763f 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -1632,7 +1632,7 @@ static const char *builtin_extensions[] = { "objectformat" }; -static git_vector user_extensions = GIT_VECTOR_INIT; +static git_vector user_extensions = { 0, git__strcmp_cb }; static int check_valid_extension(const git_config_entry *entry, void *payload) { @@ -1773,7 +1773,7 @@ int git_repository__extensions(char ***out, size_t *out_len) char *extension; size_t i, j; - if (git_vector_init(&extensions, 8, NULL) < 0) + if (git_vector_init(&extensions, 8, git__strcmp_cb) < 0) return -1; for (i = 0; i < ARRAY_SIZE(builtin_extensions); i++) { @@ -1805,21 +1805,49 @@ int git_repository__extensions(char ***out, size_t *out_len) return -1; } + git_vector_sort(&extensions); + *out = (char **)git_vector_detach(out_len, NULL, &extensions); return 0; } +static int dup_ext_err(void **old, void *extension) +{ + GIT_UNUSED(old); + GIT_UNUSED(extension); + return GIT_EEXISTS; +} + int git_repository__set_extensions(const char **extensions, size_t len) { char *extension; - size_t i; + size_t i, j; + int error; git_repository__free_extensions(); for (i = 0; i < len; i++) { - if ((extension = git__strdup(extensions[i])) == NULL || - git_vector_insert(&user_extensions, extension) < 0) + bool is_builtin = false; + + for (j = 0; j < ARRAY_SIZE(builtin_extensions); j++) { + if (strcmp(builtin_extensions[j], extensions[i]) == 0) { + is_builtin = true; + break; + } + } + + if (is_builtin) + continue; + + if ((extension = git__strdup(extensions[i])) == NULL) return -1; + + if ((error = git_vector_insert_sorted(&user_extensions, extension, dup_ext_err)) < 0) { + git__free(extension); + + if (error != GIT_EEXISTS) + return -1; + } } return 0; diff --git a/tests/libgit2/core/opts.c b/tests/libgit2/core/opts.c index 486ff58c6e7..1aa095adf4c 100644 --- a/tests/libgit2/core/opts.c +++ b/tests/libgit2/core/opts.c @@ -50,9 +50,9 @@ void test_core_opts__extensions_add(void) cl_git_pass(git_libgit2_opts(GIT_OPT_GET_EXTENSIONS, &out)); cl_assert_equal_sz(out.count, 3); - cl_assert_equal_s("noop", out.strings[0]); - cl_assert_equal_s("objectformat", out.strings[1]); - cl_assert_equal_s("foo", out.strings[2]); + cl_assert_equal_s("foo", out.strings[0]); + cl_assert_equal_s("noop", out.strings[1]); + cl_assert_equal_s("objectformat", out.strings[2]); git_strarray_dispose(&out); } @@ -66,9 +66,26 @@ void test_core_opts__extensions_remove(void) cl_git_pass(git_libgit2_opts(GIT_OPT_GET_EXTENSIONS, &out)); cl_assert_equal_sz(out.count, 3); - cl_assert_equal_s("objectformat", out.strings[0]); - cl_assert_equal_s("bar", out.strings[1]); - cl_assert_equal_s("baz", out.strings[2]); + cl_assert_equal_s("bar", out.strings[0]); + cl_assert_equal_s("baz", out.strings[1]); + cl_assert_equal_s("objectformat", out.strings[2]); + + git_strarray_dispose(&out); +} + +void test_core_opts__extensions_uniq(void) +{ + const char *in[] = { "foo", "noop", "bar", "bar", "foo", "objectformat" }; + git_strarray out = { 0 }; + + cl_git_pass(git_libgit2_opts(GIT_OPT_SET_EXTENSIONS, in, ARRAY_SIZE(in))); + cl_git_pass(git_libgit2_opts(GIT_OPT_GET_EXTENSIONS, &out)); + + cl_assert_equal_sz(out.count, 4); + cl_assert_equal_s("bar", out.strings[0]); + cl_assert_equal_s("foo", out.strings[1]); + cl_assert_equal_s("noop", out.strings[2]); + cl_assert_equal_s("objectformat", out.strings[3]); git_strarray_dispose(&out); } From cd40b9186311516ab69c778c5f676f20c28435ed Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 25 Feb 2023 23:15:43 +0000 Subject: [PATCH 168/608] remote: always populate old id in update tips In b1e83cca1bbc255627950b4e8d4fdb1174bf7a12 we erroneously stopped setting the old ID to zero; correct that. --- src/libgit2/remote.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/libgit2/remote.c b/src/libgit2/remote.c index ab6b5edbcd5..c3e2a324d23 100644 --- a/src/libgit2/remote.c +++ b/src/libgit2/remote.c @@ -1733,7 +1733,7 @@ static int update_ref( const git_remote_callbacks *callbacks) { git_reference *ref; - git_oid old_id; + git_oid old_id = GIT_OID_SHA1_ZERO; int error; error = git_reference_name_to_id(&old_id, remote->repo, ref_name); From 5adde383153af033d22bf25c443e6e7f6f08d0bd Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 27 Feb 2023 20:37:50 +0000 Subject: [PATCH 169/608] Revert "Pass hostkey & port to host verify callback" This reverts commit f68b40c0af9c7c5c2c8740fe4a8fbcba367e0087. --- src/libgit2/transports/ssh.c | 14 +++----------- 1 file changed, 3 insertions(+), 11 deletions(-) diff --git a/src/libgit2/transports/ssh.c b/src/libgit2/transports/ssh.c index d7594aa124a..5500ea100bd 100644 --- a/src/libgit2/transports/ssh.c +++ b/src/libgit2/transports/ssh.c @@ -651,8 +651,6 @@ static int check_against_known_hosts( return ret; } -#define SSH_DEFAULT_PORT 22 - /* * Perform the check for the session's certificate against known hosts if * possible and then ask the user if they have a callback. @@ -750,16 +748,9 @@ static int check_certificate( if (check_cb != NULL) { git_cert_hostkey *cert_ptr = &cert; git_error_state previous_error = {0}; - const char *host_ptr = host; - git_str host_and_port = GIT_STR_INIT; - - if (port != SSH_DEFAULT_PORT) { - git_str_printf(&host_and_port, "%s:%d", host, port); - host_ptr = host_and_port.ptr; - } git_error_state_capture(&previous_error, error); - error = check_cb((git_cert *) cert_ptr, cert_valid, host_ptr, check_cb_payload); + error = check_cb((git_cert *) cert_ptr, cert_valid, host, check_cb_payload); if (error == GIT_PASSTHROUGH) { error = git_error_state_restore(&previous_error); } else if (error < 0 && !git_error_last()) { @@ -767,12 +758,13 @@ static int check_certificate( } git_error_state_free(&previous_error); - git_str_dispose(&host_and_port); } return error; } +#define SSH_DEFAULT_PORT "22" + static int _git_ssh_setup_conn( ssh_subtransport *t, const char *url, From c28ebdf25649aeffdcb40bbb57ebc0ec42d07cc9 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 27 Feb 2023 20:38:02 +0000 Subject: [PATCH 170/608] Revert "tests: validate host and port for ssh tests when non-standard" This reverts commit 43e84e246cc716ac51a276945b5b112b21d802d1. --- tests/libgit2/online/clone.c | 12 +----------- 1 file changed, 1 insertion(+), 11 deletions(-) diff --git a/tests/libgit2/online/clone.c b/tests/libgit2/online/clone.c index bb704c06675..1a4cdb520ce 100644 --- a/tests/libgit2/online/clone.c +++ b/tests/libgit2/online/clone.c @@ -787,19 +787,10 @@ static int ssh_certificate_check(git_cert *cert, int valid, const char *host, vo { git_cert_hostkey *key; git_oid expected = GIT_OID_SHA1_ZERO, actual = GIT_OID_SHA1_ZERO; - git_str expected_host = GIT_STR_INIT; - git_net_url parsed_url = GIT_NET_URL_INIT; GIT_UNUSED(valid); GIT_UNUSED(payload); - cl_git_pass(git_net_url_parse_standard_or_scp(&parsed_url, _remote_url)); - cl_git_pass(git_str_printf(&expected_host, "%s%s%s", - parsed_url.host, - git_net_url_is_default_port(&parsed_url) ? "" : ":", - git_net_url_is_default_port(&parsed_url) ? "" : parsed_url.port)); - cl_assert_equal_s(expected_host.ptr, host); - cl_assert(_remote_ssh_fingerprint); cl_git_pass(git_oid__fromstrp(&expected, _remote_ssh_fingerprint, GIT_OID_SHA1)); @@ -821,8 +812,7 @@ static int ssh_certificate_check(git_cert *cert, int valid, const char *host, vo cl_assert(!memcmp(&expected, &actual, 20)); - git_net_url_dispose(&parsed_url); - git_str_dispose(&expected_host); + cl_assert_equal_s("localhost", host); return GIT_EUSER; } From 5c1d7649100175fef2c74ec66e7cb1e57440d89d Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 27 Feb 2023 21:49:13 +0000 Subject: [PATCH 171/608] fs_path: let root run the ownership tests The `git_fs_path_owner_is_current_user` expects the root dir on unix (`/`) to be owned by a non-current user. This makes sense unless root (or euid == 0) is running the tests, which often happens during distro build / packaging scripts. Allow them to run the tests. --- tests/util/path.c | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/tests/util/path.c b/tests/util/path.c index 2c39e088700..02ec42fcea2 100644 --- a/tests/util/path.c +++ b/tests/util/path.c @@ -2,6 +2,10 @@ #include "futils.h" #include "fs_path.h" +#ifndef GIT_WIN32 +# include +#endif + static char *path_save; void test_path__initialize(void) @@ -757,7 +761,7 @@ void test_path__validate_current_user_ownership(void) cl_git_fail(git_fs_path_owner_is_current_user(&is_cur, "c:\\path\\does\\not\\exist")); #else cl_git_pass(git_fs_path_owner_is_current_user(&is_cur, "/")); - cl_assert_equal_i(is_cur, 0); + cl_assert_equal_i(is_cur, (geteuid() == 0)); cl_git_fail(git_fs_path_owner_is_current_user(&is_cur, "/path/does/not/exist")); #endif From c4523c6c66ee0ff731be374e153c96bc635cf25b Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 27 Feb 2023 21:39:01 +0000 Subject: [PATCH 172/608] odb: add back git_odb_backend_loose `git_odb_backend_loose` was erroneously removed during a refactoring; add it back. --- src/libgit2/odb_loose.c | 34 ++++++++++++++++++++++++++++++++++ 1 file changed, 34 insertions(+) diff --git a/src/libgit2/odb_loose.c b/src/libgit2/odb_loose.c index d1abbe2333e..51195d35778 100644 --- a/src/libgit2/odb_loose.c +++ b/src/libgit2/odb_loose.c @@ -1204,3 +1204,37 @@ int git_odb__backend_loose( *backend_out = (git_odb_backend *)backend; return 0; } + + +#ifdef GIT_EXPERIMENTAL_SHA256 +int git_odb_backend_loose( + git_odb_backend **backend_out, + const char *objects_dir, + git_odb_backend_loose_options *opts) +{ + return git_odb__backend_loose(backend_out, objects_dir, opts); +} +#else +int git_odb_backend_loose( + git_odb_backend **backend_out, + const char *objects_dir, + int compression_level, + int do_fsync, + unsigned int dir_mode, + unsigned int file_mode) +{ + git_odb_backend_loose_flag_t flags = 0; + git_odb_backend_loose_options opts = GIT_ODB_BACKEND_LOOSE_OPTIONS_INIT; + + if (do_fsync) + flags |= GIT_ODB_BACKEND_LOOSE_FSYNC; + + opts.flags = flags; + opts.compression_level = compression_level; + opts.dir_mode = dir_mode; + opts.file_mode = file_mode; + opts.oid_type = GIT_OID_DEFAULT; + + return git_odb__backend_loose(backend_out, objects_dir, &opts); +} +#endif From 59bb933c17b74f25f5f0756c15f3afe461d2b73a Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 27 Feb 2023 21:39:27 +0000 Subject: [PATCH 173/608] odb: test git_odb_backend_loose --- tests/libgit2/odb/backend/loose.c | 43 +++++++++++++++++++++++++++++++ 1 file changed, 43 insertions(+) create mode 100644 tests/libgit2/odb/backend/loose.c diff --git a/tests/libgit2/odb/backend/loose.c b/tests/libgit2/odb/backend/loose.c new file mode 100644 index 00000000000..781b61d9ff9 --- /dev/null +++ b/tests/libgit2/odb/backend/loose.c @@ -0,0 +1,43 @@ +#include "clar_libgit2.h" +#include "repository.h" +#include "odb.h" +#include "backend_helpers.h" +#include "git2/sys/mempack.h" + +static git_repository *_repo; +static git_odb *_odb; + +void test_odb_backend_loose__initialize(void) +{ + git_odb_backend *backend; + + cl_fixture_sandbox("testrepo.git"); + +#ifdef GIT_EXPERIMENTAL_SHA256 + cl_git_pass(git_odb_backend_loose(&backend, "testrepo.git/objects", NULL)); +#else + cl_git_pass(git_odb_backend_loose(&backend, "testrepo.git/objects", 0, 0, 0, 0)); +#endif + + cl_git_pass(git_odb__new(&_odb, NULL)); + cl_git_pass(git_odb_add_backend(_odb, backend, 10)); + cl_git_pass(git_repository_wrap_odb(&_repo, _odb)); +} + +void test_odb_backend_loose__cleanup(void) +{ + git_odb_free(_odb); + git_repository_free(_repo); + + cl_fixture_cleanup("testrepo.git"); +} + +void test_odb_backend_loose__read(void) +{ + git_oid oid; + git_odb_object *obj; + + cl_git_pass(git_oid__fromstr(&oid, "1385f264afb75a56a5bec74243be9b367ba4ca08", GIT_OID_SHA1)); + cl_git_pass(git_odb_read(&obj, _odb, &oid)); + git_odb_object_free(obj); +} From 3142fdba3258cce583e6590ca135e3b665c81c64 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 27 Feb 2023 22:08:47 +0000 Subject: [PATCH 174/608] meta: configure pkg-config .pc correctly The library name is correctly libgit2 (not git2) or libgit2-experimental depending on configuration. --- src/libgit2/CMakeLists.txt | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/libgit2/CMakeLists.txt b/src/libgit2/CMakeLists.txt index 3d1fb90ea77..03b57121291 100644 --- a/src/libgit2/CMakeLists.txt +++ b/src/libgit2/CMakeLists.txt @@ -103,10 +103,10 @@ if(SONAME) endif() endif() -pkg_build_config(NAME "${LIBGIT2_FILENAME}" +pkg_build_config(NAME "lib${LIBGIT2_FILENAME}" VERSION ${libgit2_VERSION} DESCRIPTION "The git library, take 2" - LIBS_SELF git2 + LIBS_SELF ${LIBGIT2_FILENAME} PRIVATE_LIBS ${LIBGIT2_PC_LIBS} REQUIRES ${LIBGIT2_PC_REQUIRES}) From 9d1a3ef7c722d38c8d007627b3ae830c2e658929 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Tue, 28 Feb 2023 10:18:00 +0000 Subject: [PATCH 175/608] v1.6.2: update version numbers --- CMakeLists.txt | 2 +- include/git2/version.h | 4 ++-- package.json | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index e49bee30217..710915da1bd 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -6,7 +6,7 @@ cmake_minimum_required(VERSION 3.5.1) -project(libgit2 VERSION "1.6.1" LANGUAGES C) +project(libgit2 VERSION "1.6.2" LANGUAGES C) # Add find modules to the path set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${PROJECT_SOURCE_DIR}/cmake") diff --git a/include/git2/version.h b/include/git2/version.h index 33726a58ad9..8b5eb31386f 100644 --- a/include/git2/version.h +++ b/include/git2/version.h @@ -11,7 +11,7 @@ * The version string for libgit2. This string follows semantic * versioning (v2) guidelines. */ -#define LIBGIT2_VERSION "1.6.1" +#define LIBGIT2_VERSION "1.6.2" /** The major version number for this version of libgit2. */ #define LIBGIT2_VER_MAJOR 1 @@ -20,7 +20,7 @@ #define LIBGIT2_VER_MINOR 6 /** The revision ("teeny") version number for this version of libgit2. */ -#define LIBGIT2_VER_REVISION 1 +#define LIBGIT2_VER_REVISION 2 /** The Windows DLL patch number for this version of libgit2. */ #define LIBGIT2_VER_PATCH 0 diff --git a/package.json b/package.json index 0448346bad1..e29459efddd 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "libgit2", - "version": "1.6.1", + "version": "1.6.2", "repo": "https://github.com/libgit2/libgit2", "description": " A cross-platform, linkable library implementation of Git that you can use in your application.", "install": "mkdir build && cd build && cmake .. && cmake --build ." From 25ec37379ed07b10c4ecc6143cf6018cabc8f857 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Tue, 28 Feb 2023 10:22:07 +0000 Subject: [PATCH 176/608] v1.6.2: update changelog --- docs/changelog.md | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/docs/changelog.md b/docs/changelog.md index c27a07496ad..f685234aaee 100644 --- a/docs/changelog.md +++ b/docs/changelog.md @@ -1,3 +1,23 @@ +v1.6.2 +------ + +## What's Changed +### Bug fixes + +* remote: always populate old id in update tips by @ethomson in https://github.com/libgit2/libgit2/pull/6506 + The update tips callback would not always be properly provided with an empty (`0000000...`) OID for new refs. + +* Revert #6503 by @ethomson in https://github.com/libgit2/libgit2/pull/6511 + The certificate callback added port information for callbacks in #6503, but the format was ambiguous with IPv6 addresses. Revert this change temporarily. + +* Add `git_odb_backend_loose` back by @ethomson in https://github.com/libgit2/libgit2/pull/6512 + During SHA256 refactoring, the `git_odb_backend_loose` API was accidentally removed. Add it back. + +* meta: configure pkg-config .pc correctly by @ethomson in https://github.com/libgit2/libgit2/pull/6514 + During SHA256 refactoring, the pkg-config `.pc` file was erroneously renamed to `git2` instead of `libgit2`. Repair this. + +**Full Changelog**: https://github.com/libgit2/libgit2/compare/v1.6.1...v1.6.2 + v1.6 ---- From 3770bf6766ade2eae8a7771dde8248322e68f879 Mon Sep 17 00:00:00 2001 From: Yuriy Chernyshov Date: Tue, 28 Feb 2023 19:03:51 +0300 Subject: [PATCH 177/608] Remove unused wditer variable Found this randomly while debugging #6517 --- src/libgit2/index.c | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/libgit2/index.c b/src/libgit2/index.c index 1821f6027f7..195ec1d5a2f 100644 --- a/src/libgit2/index.c +++ b/src/libgit2/index.c @@ -3397,7 +3397,6 @@ int git_index_add_all( { int error; git_repository *repo; - git_iterator *wditer = NULL; git_pathspec ps; bool no_fnmatch = (flags & GIT_INDEX_ADD_DISABLE_PATHSPEC_MATCH) != 0; @@ -3423,7 +3422,6 @@ int git_index_add_all( git_error_set_after_callback(error); cleanup: - git_iterator_free(wditer); git_pathspec__clear(&ps); return error; From e1e0d77c6f1573ab1e332af3f4c7490059d78e3c Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Wed, 1 Mar 2023 22:16:31 +0000 Subject: [PATCH 178/608] odb: restore `git_odb_open` `git_odb_open` was erroneously removed during a refactoring; add it back. --- src/libgit2/odb.c | 19 +++++++++++++++++++ tests/libgit2/odb/open.c | 34 ++++++++++++++++++++++++++++++++++ 2 files changed, 53 insertions(+) create mode 100644 tests/libgit2/odb/open.c diff --git a/src/libgit2/odb.c b/src/libgit2/odb.c index 1a02cbad974..0fc48035af2 100644 --- a/src/libgit2/odb.c +++ b/src/libgit2/odb.c @@ -856,6 +856,25 @@ int git_odb__open( return 0; } +#ifdef GIT_EXPERIMENTAL_SHA256 + +int git_odb_open( + git_odb **out, + const char *objects_dir, + const git_odb_options *opts) +{ + return git_odb__open(out, objects_dir, opts); +} + +#else + +int git_odb_open(git_odb **out, const char *objects_dir) +{ + return git_odb__open(out, objects_dir, NULL); +} + +#endif + int git_odb__set_caps(git_odb *odb, int caps) { if (caps == GIT_ODB_CAP_FROM_OWNER) { diff --git a/tests/libgit2/odb/open.c b/tests/libgit2/odb/open.c new file mode 100644 index 00000000000..395406d0f3c --- /dev/null +++ b/tests/libgit2/odb/open.c @@ -0,0 +1,34 @@ +#include "clar_libgit2.h" + +void test_odb_open__initialize(void) +{ + cl_fixture_sandbox("testrepo.git"); +} + +void test_odb_open__cleanup(void) +{ + cl_fixture_cleanup("testrepo.git"); +} + +void test_odb_open__exists(void) +{ + git_odb *odb; + git_oid one, two; + +#ifdef GIT_EXPERIMENTAL_SHA256 + git_odb_options opts = GIT_ODB_OPTIONS_INIT; + + cl_git_pass(git_odb_open(&odb, "testrepo.git/objects", &opts)); + cl_git_pass(git_oid_fromstr(&one, "1385f264afb75a56a5bec74243be9b367ba4ca08", GIT_OID_SHA1)); + cl_git_pass(git_oid_fromstr(&two, "00112233445566778899aabbccddeeff00112233", GIT_OID_SHA1)); +#else + cl_git_pass(git_odb_open(&odb, "testrepo.git/objects")); + cl_git_pass(git_oid_fromstr(&one, "1385f264afb75a56a5bec74243be9b367ba4ca08")); + cl_git_pass(git_oid_fromstr(&two, "00112233445566778899aabbccddeeff00112233")); +#endif + + cl_assert(git_odb_exists(odb, &one)); + cl_assert(!git_odb_exists(odb, &two)); + + git_odb_free(odb); +} From 6fb5ab372366a92ae36aac36e1427158c22f3278 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 2 Mar 2023 00:15:08 +0000 Subject: [PATCH 179/608] index: test `git_index_add_all` with ignored folder Ensure that when all files beneath a directory are ignored that we actually ignore the files. --- tests/libgit2/index/addall.c | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/tests/libgit2/index/addall.c b/tests/libgit2/index/addall.c index 6f95f6386f4..0d3407d48cb 100644 --- a/tests/libgit2/index/addall.c +++ b/tests/libgit2/index/addall.c @@ -441,6 +441,29 @@ void test_index_addall__callback_filtering(void) git_index_free(index); } +void test_index_addall__handles_ignored_files_in_directory(void) +{ + git_index *index; + + g_repo = cl_git_sandbox_init_new(TEST_DIR); + + cl_git_mkfile(TEST_DIR "/file.foo", "a file"); + cl_git_mkfile(TEST_DIR "/file.bar", "another file"); + cl_must_pass(p_mkdir(TEST_DIR "/folder", 0777)); + cl_git_mkfile(TEST_DIR "/folder/asdf", "yet another file"); + + cl_git_mkfile(TEST_DIR "/.gitignore", "folder/\n"); + + check_status(g_repo, 0, 0, 0, 3, 0, 0, 1, 0); + + cl_git_pass(git_repository_index(&index, g_repo)); + cl_git_pass(git_index_add_all(index, NULL, 0, NULL, NULL)); + + check_status(g_repo, 3, 0, 0, 0, 0, 0, 1, 0); + + git_index_free(index); +} + void test_index_addall__adds_conflicts(void) { git_index *index; From 309befe413d7ab68e8e410d8121af98467620792 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 2 Mar 2023 23:21:23 +0000 Subject: [PATCH 180/608] index: test `git_index_add_all` with force Ensure that when all files beneath a directory are ignored that we add the files when FORCE is specified. --- tests/libgit2/index/addall.c | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/tests/libgit2/index/addall.c b/tests/libgit2/index/addall.c index 0d3407d48cb..e76b6e81d89 100644 --- a/tests/libgit2/index/addall.c +++ b/tests/libgit2/index/addall.c @@ -464,6 +464,29 @@ void test_index_addall__handles_ignored_files_in_directory(void) git_index_free(index); } +void test_index_addall__force_adds_ignored_directories(void) +{ + git_index *index; + + g_repo = cl_git_sandbox_init_new(TEST_DIR); + + cl_git_mkfile(TEST_DIR "/file.foo", "a file"); + cl_git_mkfile(TEST_DIR "/file.bar", "another file"); + cl_must_pass(p_mkdir(TEST_DIR "/folder", 0777)); + cl_git_mkfile(TEST_DIR "/folder/asdf", "yet another file"); + + cl_git_mkfile(TEST_DIR "/.gitignore", "folder/\n"); + + check_status(g_repo, 0, 0, 0, 3, 0, 0, 1, 0); + + cl_git_pass(git_repository_index(&index, g_repo)); + cl_git_pass(git_index_add_all(index, NULL, GIT_INDEX_ADD_FORCE, NULL, NULL)); + + check_status(g_repo, 4, 0, 0, 0, 0, 0, 0, 0); + + git_index_free(index); +} + void test_index_addall__adds_conflicts(void) { git_index *index; From 129cadf9bf9ef1b43dd844d54f2b57a52b69ed2a Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 2 Mar 2023 23:20:45 +0000 Subject: [PATCH 181/608] index: support `git_index_add_all` directories with force When the contents of an entire new directory is ignored, and `FORCE` is specified to `git_index_add_all`, ensure that we expand the entire file list. By default, diff will coalesce a fully ignored folder into a single diff entry; expand it. --- src/libgit2/index.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/libgit2/index.c b/src/libgit2/index.c index 195ec1d5a2f..d4532c005d0 100644 --- a/src/libgit2/index.c +++ b/src/libgit2/index.c @@ -3509,7 +3509,8 @@ static int index_apply_to_wd_diff(git_index *index, int action, const git_strarr GIT_DIFF_RECURSE_UNTRACKED_DIRS; if (flags == GIT_INDEX_ADD_FORCE) - opts.flags |= GIT_DIFF_INCLUDE_IGNORED; + opts.flags |= GIT_DIFF_INCLUDE_IGNORED | + GIT_DIFF_RECURSE_IGNORED_DIRS; } if ((error = git_diff_index_to_workdir(&diff, repo, index, &opts)) < 0) From 462dbe21d0edc3817d53900702e68d666c303600 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Wed, 15 Feb 2023 10:26:50 +0000 Subject: [PATCH 182/608] xdiff: move xdiff to 'deps' xdiff is a dependency (from git core) and more properly belongs in the 'deps' directory. Move it there, and add a stub for cmake to resolve xdiff from the system location in the future. (At present, bundled xdiff remains hardcoded.) --- CMakeLists.txt | 1 + cmake/SelectXdiff.cmake | 9 ++++++++ deps/xdiff/CMakeLists.txt | 28 ++++++++++++++++++++++++ {src/libgit2 => deps}/xdiff/git-xdiff.h | 0 {src/libgit2 => deps}/xdiff/xdiff.h | 0 {src/libgit2 => deps}/xdiff/xdiffi.c | 0 {src/libgit2 => deps}/xdiff/xdiffi.h | 0 {src/libgit2 => deps}/xdiff/xemit.c | 0 {src/libgit2 => deps}/xdiff/xemit.h | 0 {src/libgit2 => deps}/xdiff/xhistogram.c | 0 {src/libgit2 => deps}/xdiff/xinclude.h | 0 {src/libgit2 => deps}/xdiff/xmacros.h | 0 {src/libgit2 => deps}/xdiff/xmerge.c | 0 {src/libgit2 => deps}/xdiff/xpatience.c | 0 {src/libgit2 => deps}/xdiff/xprepare.c | 0 {src/libgit2 => deps}/xdiff/xprepare.h | 0 {src/libgit2 => deps}/xdiff/xtypes.h | 0 {src/libgit2 => deps}/xdiff/xutils.c | 0 {src/libgit2 => deps}/xdiff/xutils.h | 0 src/CMakeLists.txt | 1 + src/libgit2/CMakeLists.txt | 20 +---------------- src/libgit2/blame_git.c | 1 - src/libgit2/diff_xdiff.h | 2 +- src/libgit2/merge_file.c | 2 -- 24 files changed, 41 insertions(+), 23 deletions(-) create mode 100644 cmake/SelectXdiff.cmake create mode 100644 deps/xdiff/CMakeLists.txt rename {src/libgit2 => deps}/xdiff/git-xdiff.h (100%) rename {src/libgit2 => deps}/xdiff/xdiff.h (100%) rename {src/libgit2 => deps}/xdiff/xdiffi.c (100%) rename {src/libgit2 => deps}/xdiff/xdiffi.h (100%) rename {src/libgit2 => deps}/xdiff/xemit.c (100%) rename {src/libgit2 => deps}/xdiff/xemit.h (100%) rename {src/libgit2 => deps}/xdiff/xhistogram.c (100%) rename {src/libgit2 => deps}/xdiff/xinclude.h (100%) rename {src/libgit2 => deps}/xdiff/xmacros.h (100%) rename {src/libgit2 => deps}/xdiff/xmerge.c (100%) rename {src/libgit2 => deps}/xdiff/xpatience.c (100%) rename {src/libgit2 => deps}/xdiff/xprepare.c (100%) rename {src/libgit2 => deps}/xdiff/xprepare.h (100%) rename {src/libgit2 => deps}/xdiff/xtypes.h (100%) rename {src/libgit2 => deps}/xdiff/xutils.c (100%) rename {src/libgit2 => deps}/xdiff/xutils.h (100%) diff --git a/CMakeLists.txt b/CMakeLists.txt index 710915da1bd..fc31faecaf5 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -36,6 +36,7 @@ option(USE_SHA1 "Enable SHA1. Can be set to CollisionDetection(ON option(USE_SHA256 "Enable SHA256. Can be set to HTTPS/Builtin" ON) option(USE_GSSAPI "Link with libgssapi for SPNEGO auth" OFF) set(USE_HTTP_PARSER "" CACHE STRING "Specifies the HTTP Parser implementation; either system or builtin.") +# set(USE_XDIFF "" CACHE STRING "Specifies the xdiff implementation; either system or builtin.") set(REGEX_BACKEND "" CACHE STRING "Regular expression implementation. One of regcomp_l, pcre2, pcre, regcomp, or builtin.") option(USE_BUNDLED_ZLIB "Use the bundled version of zlib. Can be set to one of Bundled(ON)/Chromium. The Chromium option requires a x86_64 processor with SSE4.2 and CLMUL" OFF) diff --git a/cmake/SelectXdiff.cmake b/cmake/SelectXdiff.cmake new file mode 100644 index 00000000000..9ab9f3f4f29 --- /dev/null +++ b/cmake/SelectXdiff.cmake @@ -0,0 +1,9 @@ +# Optional external dependency: xdiff +if(USE_XDIFF STREQUAL "system") + message(FATAL_ERROR "external/system xdiff is not yet supported") +else() + add_subdirectory("${PROJECT_SOURCE_DIR}/deps/xdiff" "${PROJECT_BINARY_DIR}/deps/xdiff") + list(APPEND LIBGIT2_DEPENDENCY_INCLUDES "${PROJECT_SOURCE_DIR}/deps/xdiff") + list(APPEND LIBGIT2_DEPENDENCY_OBJECTS "$") + add_feature_info(xdiff ON "xdiff support (bundled)") +endif() diff --git a/deps/xdiff/CMakeLists.txt b/deps/xdiff/CMakeLists.txt new file mode 100644 index 00000000000..743ac636f0a --- /dev/null +++ b/deps/xdiff/CMakeLists.txt @@ -0,0 +1,28 @@ + +file(GLOB SRC_XDIFF "*.c" "*.h") +list(SORT SRC_XDIFF) + +add_library(xdiff OBJECT ${SRC_XDIFF}) +target_include_directories(xdiff SYSTEM PRIVATE + "${PROJECT_SOURCE_DIR}/include" + "${PROJECT_SOURCE_DIR}/src/util" + "${PROJECT_BINARY_DIR}/src/util" + ${LIBGIT2_SYSTEM_INCLUDES} + ${LIBGIT2_DEPENDENCY_INCLUDES}) + +# the xdiff dependency is not (yet) warning-free, disable warnings +# as errors for the xdiff sources until we've sorted them out +if(MSVC) + set_source_files_properties(xdiffi.c PROPERTIES COMPILE_FLAGS -WX-) + set_source_files_properties(xemit.c PROPERTIES COMPILE_FLAGS -WX-) + set_source_files_properties(xhistogram.c PROPERTIES COMPILE_FLAGS -WX-) + set_source_files_properties(xmerge.c PROPERTIES COMPILE_FLAGS -WX-) + set_source_files_properties(xutils.c PROPERTIES COMPILE_FLAGS -WX-) + set_source_files_properties(xpatience.c PROPERTIES COMPILE_FLAGS -WX-) +else() + set_source_files_properties(xdiffi.c PROPERTIES COMPILE_FLAGS "-Wno-sign-compare -Wno-unused-parameter") + set_source_files_properties(xemit.c PROPERTIES COMPILE_FLAGS "-Wno-sign-compare -Wno-unused-parameter") + set_source_files_properties(xhistogram.c PROPERTIES COMPILE_FLAGS "-Wno-sign-compare") + set_source_files_properties(xutils.c PROPERTIES COMPILE_FLAGS "-Wno-sign-compare") + set_source_files_properties(xpatience.c PROPERTIES COMPILE_FLAGS "-Wno-sign-compare") +endif() diff --git a/src/libgit2/xdiff/git-xdiff.h b/deps/xdiff/git-xdiff.h similarity index 100% rename from src/libgit2/xdiff/git-xdiff.h rename to deps/xdiff/git-xdiff.h diff --git a/src/libgit2/xdiff/xdiff.h b/deps/xdiff/xdiff.h similarity index 100% rename from src/libgit2/xdiff/xdiff.h rename to deps/xdiff/xdiff.h diff --git a/src/libgit2/xdiff/xdiffi.c b/deps/xdiff/xdiffi.c similarity index 100% rename from src/libgit2/xdiff/xdiffi.c rename to deps/xdiff/xdiffi.c diff --git a/src/libgit2/xdiff/xdiffi.h b/deps/xdiff/xdiffi.h similarity index 100% rename from src/libgit2/xdiff/xdiffi.h rename to deps/xdiff/xdiffi.h diff --git a/src/libgit2/xdiff/xemit.c b/deps/xdiff/xemit.c similarity index 100% rename from src/libgit2/xdiff/xemit.c rename to deps/xdiff/xemit.c diff --git a/src/libgit2/xdiff/xemit.h b/deps/xdiff/xemit.h similarity index 100% rename from src/libgit2/xdiff/xemit.h rename to deps/xdiff/xemit.h diff --git a/src/libgit2/xdiff/xhistogram.c b/deps/xdiff/xhistogram.c similarity index 100% rename from src/libgit2/xdiff/xhistogram.c rename to deps/xdiff/xhistogram.c diff --git a/src/libgit2/xdiff/xinclude.h b/deps/xdiff/xinclude.h similarity index 100% rename from src/libgit2/xdiff/xinclude.h rename to deps/xdiff/xinclude.h diff --git a/src/libgit2/xdiff/xmacros.h b/deps/xdiff/xmacros.h similarity index 100% rename from src/libgit2/xdiff/xmacros.h rename to deps/xdiff/xmacros.h diff --git a/src/libgit2/xdiff/xmerge.c b/deps/xdiff/xmerge.c similarity index 100% rename from src/libgit2/xdiff/xmerge.c rename to deps/xdiff/xmerge.c diff --git a/src/libgit2/xdiff/xpatience.c b/deps/xdiff/xpatience.c similarity index 100% rename from src/libgit2/xdiff/xpatience.c rename to deps/xdiff/xpatience.c diff --git a/src/libgit2/xdiff/xprepare.c b/deps/xdiff/xprepare.c similarity index 100% rename from src/libgit2/xdiff/xprepare.c rename to deps/xdiff/xprepare.c diff --git a/src/libgit2/xdiff/xprepare.h b/deps/xdiff/xprepare.h similarity index 100% rename from src/libgit2/xdiff/xprepare.h rename to deps/xdiff/xprepare.h diff --git a/src/libgit2/xdiff/xtypes.h b/deps/xdiff/xtypes.h similarity index 100% rename from src/libgit2/xdiff/xtypes.h rename to deps/xdiff/xtypes.h diff --git a/src/libgit2/xdiff/xutils.c b/deps/xdiff/xutils.c similarity index 100% rename from src/libgit2/xdiff/xutils.c rename to deps/xdiff/xutils.c diff --git a/src/libgit2/xdiff/xutils.h b/deps/xdiff/xutils.h similarity index 100% rename from src/libgit2/xdiff/xutils.h rename to deps/xdiff/xutils.h diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index e108b2e79ce..e14bd36c2a3 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -41,6 +41,7 @@ include(SelectHTTPSBackend) include(SelectHashes) include(SelectHTTPParser) include(SelectRegex) +include(SelectXdiff) include(SelectSSH) include(SelectWinHTTP) include(SelectZlib) diff --git a/src/libgit2/CMakeLists.txt b/src/libgit2/CMakeLists.txt index 03b57121291..5c453aab9b0 100644 --- a/src/libgit2/CMakeLists.txt +++ b/src/libgit2/CMakeLists.txt @@ -25,8 +25,7 @@ target_sources(libgit2 PRIVATE ${SRC_H}) file(GLOB SRC_GIT2 *.c *.h streams/*.c streams/*.h - transports/*.c transports/*.h - xdiff/*.c xdiff/*.h) + transports/*.c transports/*.h) list(SORT SRC_GIT2) target_sources(libgit2 PRIVATE ${SRC_GIT2}) @@ -40,23 +39,6 @@ if(APPLE) set_source_files_properties(streams/stransport.c PROPERTIES COMPILE_FLAGS -Wno-deprecated) endif() -# the xdiff dependency is not (yet) warning-free, disable warnings -# as errors for the xdiff sources until we've sorted them out -if(MSVC) - set_source_files_properties(xdiff/xdiffi.c PROPERTIES COMPILE_FLAGS -WX-) - set_source_files_properties(xdiff/xemit.c PROPERTIES COMPILE_FLAGS -WX-) - set_source_files_properties(xdiff/xhistogram.c PROPERTIES COMPILE_FLAGS -WX-) - set_source_files_properties(xdiff/xmerge.c PROPERTIES COMPILE_FLAGS -WX-) - set_source_files_properties(xdiff/xutils.c PROPERTIES COMPILE_FLAGS -WX-) - set_source_files_properties(xdiff/xpatience.c PROPERTIES COMPILE_FLAGS -WX-) -else() - set_source_files_properties(xdiff/xdiffi.c PROPERTIES COMPILE_FLAGS "-Wno-sign-compare -Wno-unused-parameter") - set_source_files_properties(xdiff/xemit.c PROPERTIES COMPILE_FLAGS "-Wno-sign-compare -Wno-unused-parameter") - set_source_files_properties(xdiff/xhistogram.c PROPERTIES COMPILE_FLAGS "-Wno-sign-compare") - set_source_files_properties(xdiff/xutils.c PROPERTIES COMPILE_FLAGS "-Wno-sign-compare") - set_source_files_properties(xdiff/xpatience.c PROPERTIES COMPILE_FLAGS "-Wno-sign-compare") -endif() - ide_split_sources(libgit2) list(APPEND LIBGIT2_OBJECTS $ $ ${LIBGIT2_DEPENDENCY_OBJECTS}) list(APPEND LIBGIT2_INCLUDES ${LIBGIT2_DEPENDENCY_INCLUDES}) diff --git a/src/libgit2/blame_git.c b/src/libgit2/blame_git.c index 2504b338ac5..69897b3860c 100644 --- a/src/libgit2/blame_git.c +++ b/src/libgit2/blame_git.c @@ -9,7 +9,6 @@ #include "commit.h" #include "blob.h" -#include "xdiff/xinclude.h" #include "diff_xdiff.h" /* diff --git a/src/libgit2/diff_xdiff.h b/src/libgit2/diff_xdiff.h index 9b303e9dc45..327dc7c4ab3 100644 --- a/src/libgit2/diff_xdiff.h +++ b/src/libgit2/diff_xdiff.h @@ -10,7 +10,7 @@ #include "common.h" #include "diff.h" -#include "xdiff/xdiff.h" +#include "xdiff.h" #include "patch_generate.h" /* xdiff cannot cope with large files. these files should not be passed to diff --git a/src/libgit2/merge_file.c b/src/libgit2/merge_file.c index 732a047b1c9..ffe83cf2a3b 100644 --- a/src/libgit2/merge_file.c +++ b/src/libgit2/merge_file.c @@ -19,8 +19,6 @@ #include "git2/index.h" #include "git2/merge.h" -#include "xdiff/xdiff.h" - /* only examine the first 8000 bytes for binaryness. * https://github.com/git/git/blob/77bd3ea9f54f1584147b594abc04c26ca516d987/xdiff-interface.c#L197 */ From 20811c5aa9c528405eaa3f88ff22a9adebafa9e6 Mon Sep 17 00:00:00 2001 From: Nicolas Cavallari Date: Wed, 8 Mar 2023 14:00:52 +0100 Subject: [PATCH 183/608] sysdir: Do not declare win32 functions on non-win32 platforms These declaration poses problems on some embedded or retro Linux systems that deliberately disable support for wchar_t from their libc. --- src/libgit2/sysdir.h | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/libgit2/sysdir.h b/src/libgit2/sysdir.h index 1d15bbf43dd..03f59e1de81 100644 --- a/src/libgit2/sysdir.h +++ b/src/libgit2/sysdir.h @@ -134,10 +134,12 @@ extern int git_sysdir_set(git_sysdir_t which, const char *paths); */ extern int git_sysdir_reset(void); +#ifdef GIT_WIN32 /** Sets the registry system dir to a mock; for testing. */ extern int git_win32__set_registry_system_dir(const wchar_t *mock_sysdir); /** Find the given system dir; for testing. */ extern int git_win32__find_system_dirs(git_str *out, const char *subdir); +#endif #endif From 1cc2979a71ba042c20ea3e18484d4a50c4fdf10d Mon Sep 17 00:00:00 2001 From: lmcglash Date: Fri, 10 Mar 2023 08:56:49 +0000 Subject: [PATCH 184/608] Fix merge error --- src/libgit2/commit.c | 43 +++++++++++++++++-------------------------- 1 file changed, 17 insertions(+), 26 deletions(-) diff --git a/src/libgit2/commit.c b/src/libgit2/commit.c index 017c603037e..a7d83111509 100644 --- a/src/libgit2/commit.c +++ b/src/libgit2/commit.c @@ -517,6 +517,18 @@ int git_commit__parse( return git_commit__parse_ext(commit, odb_obj, &parse_options); } +int git_commit__parse_raw( + void *commit, + const char *data, + size_t size, + git_oid_t oid_type) +{ + git_commit__parse_options parse_options = {0}; + parse_options.oid_type = oid_type; + + return commit_parse(commit, data, size, &parse_options); +} + static int assign_commit_parents_from_graft(git_commit *commit, git_commit_graft *graft) { size_t idx; git_oid *oid; @@ -533,14 +545,17 @@ static int assign_commit_parents_from_graft(git_commit *commit, git_commit_graft return 0; } -int git_commit__parse_ext(git_commit *commit, git_odb_object *odb_obj, unsigned int flags) +int git_commit__parse_ext( + git_commit *commit, + git_odb_object *odb_obj, + git_commit__parse_options *parse_opts) { git_repository *repo = git_object_owner((git_object *)commit); git_commit_graft *graft; int error; if ((error = commit_parse(commit, git_odb_object_data(odb_obj), - git_odb_object_size(odb_obj), flags)) < 0) + git_odb_object_size(odb_obj), parse_opts)) < 0) return error; if (!git_shallow__enabled) @@ -554,30 +569,6 @@ int git_commit__parse_ext(git_commit *commit, git_odb_object *odb_obj, unsigned return assign_commit_parents_from_graft(commit, graft); } -int git_commit__parse_raw( - void *commit, - const char *data, - size_t size, - git_oid_t oid_type) -{ - git_commit__parse_options parse_options = {0}; - parse_options.oid_type = oid_type; - - return commit_parse(commit, data, size, &parse_options); -} - -int git_commit__parse_ext( - git_commit *commit, - git_odb_object *odb_obj, - git_commit__parse_options *parse_opts) -{ - return commit_parse( - commit, - git_odb_object_data(odb_obj), - git_odb_object_size(odb_obj), - parse_opts); -} - #define GIT_COMMIT_GETTER(_rvalue, _name, _return, _invalid) \ _rvalue git_commit_##_name(const git_commit *commit) \ {\ From 2da3e8c16629cee9736965556a50dc7502e1dec7 Mon Sep 17 00:00:00 2001 From: lmcglash Date: Fri, 10 Mar 2023 09:06:26 +0000 Subject: [PATCH 185/608] Remove stray comma --- src/libgit2/transports/smart.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/libgit2/transports/smart.h b/src/libgit2/transports/smart.h index 15b6c9a0aba..8e06d03ef6e 100644 --- a/src/libgit2/transports/smart.h +++ b/src/libgit2/transports/smart.h @@ -54,7 +54,7 @@ typedef enum { GIT_PKT_NG, GIT_PKT_UNPACK, GIT_PKT_SHALLOW, - GIT_PKT_UNSHALLOW, + GIT_PKT_UNSHALLOW } git_pkt_type; /* Used for multi_ack and multi_ack_detailed */ @@ -144,7 +144,7 @@ typedef struct transport_smart_caps { thin_pack:1, want_tip_sha1:1, want_reachable_sha1:1, - shallow:1; + shallow:1; char *object_format; char *agent; } transport_smart_caps; From d935773743f8f0ed50027bfe3b66133174610cc9 Mon Sep 17 00:00:00 2001 From: lmcglash Date: Fri, 10 Mar 2023 09:30:02 +0000 Subject: [PATCH 186/608] Remove unused git_transport_flags_t --- include/git2/sys/transport.h | 9 --------- 1 file changed, 9 deletions(-) diff --git a/include/git2/sys/transport.h b/include/git2/sys/transport.h index 8a84515928b..062bcd0edf1 100644 --- a/include/git2/sys/transport.h +++ b/include/git2/sys/transport.h @@ -25,15 +25,6 @@ GIT_BEGIN_DECL -/** - * Flags to pass to transport - * - * Currently unused. - */ -typedef enum { - GIT_TRANSPORTFLAGS_NONE = 0, -} git_transport_flags_t; - typedef struct git_shallowarray git_shallowarray; typedef struct { From 79ed94e0f86daae2d839f89789952f0e99eef32a Mon Sep 17 00:00:00 2001 From: Laurence McGlashan Date: Fri, 10 Mar 2023 09:30:29 +0000 Subject: [PATCH 187/608] Apply suggestions from code review Co-authored-by: Qix --- include/git2/remote.h | 4 ++-- src/libgit2/transports/smart_protocol.c | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/include/git2/remote.h b/include/git2/remote.h index f1cee17aa97..9e4043f87bd 100644 --- a/include/git2/remote.h +++ b/include/git2/remote.h @@ -744,9 +744,9 @@ typedef struct { git_proxy_options proxy_opts; /** - * Depth of the fetch to perform, has to be a positive integer. + * Depth of the fetch to perform. Depth <= 0 fetches the full history. * - * The default is -1, which will fetch the full history. + * The default is -1. */ int depth; diff --git a/src/libgit2/transports/smart_protocol.c b/src/libgit2/transports/smart_protocol.c index 2ec3901019e..c37c3cc8dcb 100644 --- a/src/libgit2/transports/smart_protocol.c +++ b/src/libgit2/transports/smart_protocol.c @@ -359,7 +359,7 @@ static int cap_not_sup_err(const char *cap_name) /* Disables server capabilities we're not interested in */ static int setup_caps(transport_smart_caps *caps, const git_fetch_negotiation *wants) { - if (wants->depth) { + if (wants->depth > 0) { if (!caps->shallow) return cap_not_sup_err(GIT_CAP_SHALLOW); } else { From 5b711335603b6d6abe6ae9bf09f570ada66232ef Mon Sep 17 00:00:00 2001 From: Laurence McGlashan Date: Fri, 10 Mar 2023 09:32:33 +0000 Subject: [PATCH 188/608] Update src/libgit2/fetch.c Co-authored-by: Qix --- src/libgit2/fetch.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/libgit2/fetch.c b/src/libgit2/fetch.c index 3a574e857d7..6bf16bc0f12 100644 --- a/src/libgit2/fetch.c +++ b/src/libgit2/fetch.c @@ -195,7 +195,7 @@ int git_fetch_negotiate(git_remote *remote, const git_fetch_options *opts) */ remote->nego.refs = (const git_remote_head * const *)remote->refs.contents; remote->nego.count = remote->refs.length; - remote->nego.shallow_roots = git__malloc(sizeof(git_shallowarray)); + remote->nego.shallow_roots = git__malloc(sizeof(*remote->nego.shallow_roots)); git_array_init(remote->nego.shallow_roots->array); From cbc5c6adfa8e0988b323d226c0439fe74e94bed6 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 10 Mar 2023 22:45:24 +0000 Subject: [PATCH 189/608] cmake: don't include `include/git2` Including the `include/git2` build path is a seemingly unnecessary oversight to include the generated `experimental.h` file. --- src/cli/CMakeLists.txt | 1 - src/libgit2/CMakeLists.txt | 1 - src/util/CMakeLists.txt | 1 - 3 files changed, 3 deletions(-) diff --git a/src/cli/CMakeLists.txt b/src/cli/CMakeLists.txt index ac1659c17fe..84b6c190151 100644 --- a/src/cli/CMakeLists.txt +++ b/src/cli/CMakeLists.txt @@ -1,7 +1,6 @@ set(CLI_INCLUDES "${libgit2_BINARY_DIR}/src/util" "${libgit2_BINARY_DIR}/include" - "${libgit2_BINARY_DIR}/include/git2" "${libgit2_SOURCE_DIR}/src/util" "${libgit2_SOURCE_DIR}/src/cli" "${libgit2_SOURCE_DIR}/include" diff --git a/src/libgit2/CMakeLists.txt b/src/libgit2/CMakeLists.txt index 03b57121291..dcb4279c1ef 100644 --- a/src/libgit2/CMakeLists.txt +++ b/src/libgit2/CMakeLists.txt @@ -10,7 +10,6 @@ include(PkgBuildConfig) set(LIBGIT2_INCLUDES "${PROJECT_BINARY_DIR}/src/util" "${PROJECT_BINARY_DIR}/include" - "${PROJECT_BINARY_DIR}/include/git2" "${PROJECT_SOURCE_DIR}/src/libgit2" "${PROJECT_SOURCE_DIR}/src/util" "${PROJECT_SOURCE_DIR}/include") diff --git a/src/util/CMakeLists.txt b/src/util/CMakeLists.txt index 2207041ef1a..ee35eb9610e 100644 --- a/src/util/CMakeLists.txt +++ b/src/util/CMakeLists.txt @@ -9,7 +9,6 @@ configure_file(git2_features.h.in git2_features.h) set(UTIL_INCLUDES "${PROJECT_BINARY_DIR}/src/util" "${PROJECT_BINARY_DIR}/include" - "${PROJECT_BINARY_DIR}/include/git2" "${PROJECT_SOURCE_DIR}/src/util" "${PROJECT_SOURCE_DIR}/include") From e288f874a3a73ef31f88bb524f6d25d5ff3c5a3a Mon Sep 17 00:00:00 2001 From: lmcglash Date: Mon, 13 Mar 2023 08:46:59 +0000 Subject: [PATCH 190/608] Remove unnecessary include. --- include/git2/repository.h | 1 - 1 file changed, 1 deletion(-) diff --git a/include/git2/repository.h b/include/git2/repository.h index 0de4d755729..560e70ab6df 100644 --- a/include/git2/repository.h +++ b/include/git2/repository.h @@ -11,7 +11,6 @@ #include "types.h" #include "oid.h" #include "buffer.h" -#include "oidarray.h" /** * @file git2/repository.h From 62b9f803575d261348508c449f8e1698beebb115 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= Date: Tue, 14 Mar 2023 15:51:50 +0100 Subject: [PATCH 191/608] pack: use 64 bits for the number of objects Keeping it as a 32-bit value means the min size calculation overflows or gets truncated which can lead to issues with large packfiles. --- src/libgit2/pack.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/libgit2/pack.c b/src/libgit2/pack.c index c3080184449..6e99d4b71f9 100644 --- a/src/libgit2/pack.c +++ b/src/libgit2/pack.c @@ -200,7 +200,8 @@ static void pack_index_free(struct git_pack_file *p) static int pack_index_check_locked(const char *path, struct git_pack_file *p) { struct git_pack_idx_header *hdr; - uint32_t version, nr, i, *index; + uint32_t version, i, *index; + uint64_t nr = 0; void *idx_map; size_t idx_size; struct stat st; @@ -246,7 +247,6 @@ static int pack_index_check_locked(const char *path, struct git_pack_file *p) version = 1; } - nr = 0; index = idx_map; if (version > 1) @@ -287,8 +287,8 @@ static int pack_index_check_locked(const char *path, struct git_pack_file *p) * variable sized table containing 8-byte entries * for offsets larger than 2^31. */ - unsigned long min_size = 8 + (4 * 256) + (nr * (p->oid_size + 4 + 4)) + (p->oid_size * 2); - unsigned long max_size = min_size; + uint64_t min_size = 8 + (4 * 256) + (nr * (p->oid_size + 4 + 4)) + (p->oid_size * 2); + uint64_t max_size = min_size; if (nr) max_size += (nr - 1)*8; From 1d57344cdf51fe4e610615d9a25eb591a4dacaeb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= Date: Thu, 16 Mar 2023 09:21:37 +0100 Subject: [PATCH 192/608] pack: cast to uint64_t when calculating index size instead It is a bit too hidden why we want 64 bits when we're assigning to a 32-bit integer later on to store the number of objects, so go back to uint32_t and cast to uint64_t during the size calculation. --- src/libgit2/pack.c | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/src/libgit2/pack.c b/src/libgit2/pack.c index 6e99d4b71f9..d59973aa937 100644 --- a/src/libgit2/pack.c +++ b/src/libgit2/pack.c @@ -200,8 +200,7 @@ static void pack_index_free(struct git_pack_file *p) static int pack_index_check_locked(const char *path, struct git_pack_file *p) { struct git_pack_idx_header *hdr; - uint32_t version, i, *index; - uint64_t nr = 0; + uint32_t version, nr = 0, i, *index; void *idx_map; size_t idx_size; struct stat st; @@ -269,7 +268,7 @@ static int pack_index_check_locked(const char *path, struct git_pack_file *p) * - 20/32-byte SHA of the packfile * - 20/32-byte SHA file checksum */ - if (idx_size != (4 * 256 + (nr * (p->oid_size + 4)) + (p->oid_size * 2))) { + if (idx_size != (4 * 256 + ((uint64_t) nr * (p->oid_size + 4)) + (p->oid_size * 2))) { git_futils_mmap_free(&p->index_map); return packfile_error("index is corrupted"); } @@ -287,7 +286,7 @@ static int pack_index_check_locked(const char *path, struct git_pack_file *p) * variable sized table containing 8-byte entries * for offsets larger than 2^31. */ - uint64_t min_size = 8 + (4 * 256) + (nr * (p->oid_size + 4 + 4)) + (p->oid_size * 2); + uint64_t min_size = 8 + (4 * 256) + ((uint64_t)nr * (p->oid_size + 4 + 4)) + (p->oid_size * 2); uint64_t max_size = min_size; if (nr) From f68f542eb63efb0f50e00d2376196f5bd48ed41e Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 6 Mar 2023 15:19:29 -0800 Subject: [PATCH 193/608] http: introduce schannel streams for windows Provide a stream interface for Schannel - the native crypto APIs - on Windows. This allows Windows to use the same HTTP transport that all the other platforms use, with its own native crypto. Ultimately this allows us to deprecate WinHTTP and we need not add support for our socket changes in two places (our HTTP stack and the WinHTTP stack). --- .github/workflows/main.yml | 12 +- .github/workflows/nightly.yml | 36 +- CMakeLists.txt | 6 - cmake/SelectHTTPSBackend.cmake | 23 +- cmake/SelectHashes.cmake | 4 + cmake/SelectWinHTTP.cmake | 17 - src/CMakeLists.txt | 1 - src/libgit2/libgit2.c | 2 + src/libgit2/streams/schannel.c | 715 ++++++++++++++++++++++++++++ src/libgit2/streams/schannel.h | 28 ++ src/libgit2/streams/socket.c | 88 ++-- src/libgit2/streams/socket.h | 2 + src/libgit2/streams/tls.c | 5 + src/util/git2_features.h.in | 1 + tests/libgit2/online/clone.c | 13 +- tests/libgit2/stream/registration.c | 6 +- 16 files changed, 879 insertions(+), 80 deletions(-) delete mode 100644 cmake/SelectWinHTTP.cmake create mode 100644 src/libgit2/streams/schannel.c create mode 100644 src/libgit2/streams/schannel.h diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 0eedab87a20..cdcea1644a5 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -130,19 +130,19 @@ jobs: SKIP_SSH_TESTS: true SKIP_NEGOTIATE_TESTS: true setup-script: osx - - name: "Windows (amd64, Visual Studio)" + - name: "Windows (amd64, Visual Studio, Schannel)" id: windows-amd64-vs os: windows-2019 setup-script: win32 env: ARCH: amd64 CMAKE_GENERATOR: Visual Studio 16 2019 - CMAKE_OPTIONS: -A x64 -DWIN32_LEAKCHECK=ON -DDEPRECATE_HARD=ON -DUSE_SSH=ON -DCMAKE_PREFIX_PATH=D:\Temp\libssh2 + CMAKE_OPTIONS: -A x64 -DWIN32_LEAKCHECK=ON -DDEPRECATE_HARD=ON -DUSE_HTTPS=Schannel -DUSE_SSH=ON -DCMAKE_PREFIX_PATH=D:\Temp\libssh2 BUILD_PATH: C:\Windows\system32;C:\Windows;C:\Windows\System32\Wbem;C:\Program Files (x86)\CMake\bin;D:\Temp\libssh2\bin BUILD_TEMP: D:\Temp SKIP_SSH_TESTS: true SKIP_NEGOTIATE_TESTS: true - - name: "Windows (x86, Visual Studio)" + - name: "Windows (x86, Visual Studio, WinHTTP)" id: windows-x86-vs os: windows-2019 setup-script: win32 @@ -154,7 +154,7 @@ jobs: BUILD_TEMP: D:\Temp SKIP_SSH_TESTS: true SKIP_NEGOTIATE_TESTS: true - - name: "Windows (amd64, mingw)" + - name: "Windows (amd64, mingw, WinHTTP)" id: windows-amd64-mingw os: windows-2019 setup-script: mingw @@ -166,14 +166,14 @@ jobs: BUILD_PATH: D:\Temp\mingw64\bin;C:\Windows\system32;C:\Windows;C:\Windows\System32\Wbem;C:\Program Files (x86)\CMake\bin SKIP_SSH_TESTS: true SKIP_NEGOTIATE_TESTS: true - - name: "Windows (x86, mingw)" + - name: "Windows (x86, mingw, Schannel)" id: windows-x86-mingw os: windows-2019 setup-script: mingw env: ARCH: x86 CMAKE_GENERATOR: MinGW Makefiles - CMAKE_OPTIONS: -DDEPRECATE_HARD=ON + CMAKE_OPTIONS: -DDEPRECATE_HARD=ON -DUSE_HTTPS=Schannel BUILD_TEMP: D:\Temp BUILD_PATH: D:\Temp\mingw32\bin;C:\Windows\system32;C:\Windows;C:\Windows\System32\Wbem;C:\Program Files (x86)\CMake\bin SKIP_SSH_TESTS: true diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml index 5a0b7d12b0b..f461530ae71 100644 --- a/.github/workflows/nightly.yml +++ b/.github/workflows/nightly.yml @@ -162,32 +162,39 @@ jobs: SKIP_SSH_TESTS: true SKIP_NEGOTIATE_TESTS: true setup-script: osx - - name: "Windows (amd64, Visual Studio)" + - name: "Windows (amd64, Visual Studio, WinHTTP)" os: windows-2019 env: ARCH: amd64 CMAKE_GENERATOR: Visual Studio 16 2019 - CMAKE_OPTIONS: -A x64 -DWIN32_LEAKCHECK=ON -DDEPRECATE_HARD=ON + CMAKE_OPTIONS: -A x64 -DWIN32_LEAKCHECK=ON -DDEPRECATE_HARD=ON -DUSE_HTTPS=WinHTTP SKIP_SSH_TESTS: true SKIP_NEGOTIATE_TESTS: true - - name: "Windows (no mmap)" + - name: "Windows (x86, Visual Studio, WinHTTP)" + os: windows-2019 + env: + ARCH: x86 + CMAKE_GENERATOR: Visual Studio 16 2019 + CMAKE_OPTIONS: -A Win32 -DWIN32_LEAKCHECK=ON -DDEPRECATE_HARD=ON -DUSE_HTTPS=WinHTTP -DUSE_SHA1=HTTPS -DUSE_BUNDLED_ZLIB=ON + SKIP_SSH_TESTS: true + SKIP_NEGOTIATE_TESTS: true + - name: "Windows (amd64, Visual Studio, Schannel)" os: windows-2019 env: ARCH: amd64 CMAKE_GENERATOR: Visual Studio 16 2019 - CFLAGS: -DNO_MMAP - CMAKE_OPTIONS: -A x64 -DDEPRECATE_HARD=ON + CMAKE_OPTIONS: -A x64 -DWIN32_LEAKCHECK=ON -DDEPRECATE_HARD=ON -DUSE_HTTPS=Schannel SKIP_SSH_TESTS: true SKIP_NEGOTIATE_TESTS: true - - name: "Windows (x86, Visual Studio)" + - name: "Windows (x86, Visual Studio, Schannel)" os: windows-2019 env: ARCH: x86 CMAKE_GENERATOR: Visual Studio 16 2019 - CMAKE_OPTIONS: -A Win32 -DWIN32_LEAKCHECK=ON -DDEPRECATE_HARD=ON -DUSE_SHA1=HTTPS -DUSE_BUNDLED_ZLIB=ON + CMAKE_OPTIONS: -A Win32 -DWIN32_LEAKCHECK=ON -DDEPRECATE_HARD=ON -DUSE_HTTPS=Schannel -DUSE_BUNDLED_ZLIB=ON SKIP_SSH_TESTS: true SKIP_NEGOTIATE_TESTS: true - - name: "Windows (amd64, mingw)" + - name: "Windows (amd64, mingw, WinHTTP)" os: windows-2019 setup-script: mingw env: @@ -198,17 +205,26 @@ jobs: BUILD_PATH: D:\Temp\mingw64\bin;C:\Windows\system32;C:\Windows;C:\Windows\System32\Wbem;C:\Program Files (x86)\CMake\bin SKIP_SSH_TESTS: true SKIP_NEGOTIATE_TESTS: true - - name: "Windows (x86, mingw)" + - name: "Windows (x86, mingw, Schannel)" os: windows-2019 setup-script: mingw env: ARCH: x86 CMAKE_GENERATOR: MinGW Makefiles - CMAKE_OPTIONS: -DDEPRECATE_HARD=ON + CMAKE_OPTIONS: -DDEPRECATE_HARD=ON -DUSE_HTTPS=Schannel BUILD_TEMP: D:\Temp BUILD_PATH: D:\Temp\mingw32\bin;C:\Windows\system32;C:\Windows;C:\Windows\System32\Wbem;C:\Program Files (x86)\CMake\bin SKIP_SSH_TESTS: true SKIP_NEGOTIATE_TESTS: true + - name: "Windows (no mmap)" + os: windows-2019 + env: + ARCH: amd64 + CMAKE_GENERATOR: Visual Studio 16 2019 + CFLAGS: -DNO_MMAP + CMAKE_OPTIONS: -A x64 -DDEPRECATE_HARD=ON + SKIP_SSH_TESTS: true + SKIP_NEGOTIATE_TESTS: true - name: "Linux (Bionic, GCC, dynamically-loaded OpenSSL)" container: name: bionic diff --git a/CMakeLists.txt b/CMakeLists.txt index 710915da1bd..7aed74df67e 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -82,12 +82,6 @@ if(MSVC) option(WIN32_LEAKCHECK "Enable leak reporting via crtdbg" OFF) endif() -if(WIN32) - # By default, libgit2 is built with WinHTTP. To use the built-in - # HTTP transport, invoke CMake with the "-DUSE_WINHTTP=OFF" argument. - option(USE_WINHTTP "Use Win32 WinHTTP routines" ON) -endif() - if(NOT CMAKE_CONFIGURATION_TYPES AND NOT CMAKE_BUILD_TYPE) set(CMAKE_BUILD_TYPE "Debug" CACHE STRING "Choose the type of build, options are: Debug Release RelWithDebInfo MinSizeRel." FORCE) endif() diff --git a/cmake/SelectHTTPSBackend.cmake b/cmake/SelectHTTPSBackend.cmake index 20221bf9f64..64c7a1097ce 100644 --- a/cmake/SelectHTTPSBackend.cmake +++ b/cmake/SelectHTTPSBackend.cmake @@ -19,7 +19,7 @@ if(USE_HTTPS) message(STATUS "Security framework is too old, falling back to OpenSSL") set(USE_HTTPS "OpenSSL") endif() - elseif(USE_WINHTTP) + elseif(WIN32) set(USE_HTTPS "WinHTTP") elseif(OPENSSL_FOUND) set(USE_HTTPS "OpenSSL") @@ -106,8 +106,27 @@ if(USE_HTTPS) # https://github.com/ARMmbed/mbedtls/issues/228 # For now, pass its link flags as our own list(APPEND LIBGIT2_PC_LIBS ${MBEDTLS_LIBRARIES}) + elseif(USE_HTTPS STREQUAL "Schannel") + set(GIT_SCHANNEL 1) + + list(APPEND LIBGIT2_SYSTEM_LIBS "rpcrt4" "crypt32" "ole32" "secur32") + list(APPEND LIBGIT2_PC_LIBS "-lrpcrt4" "-lcrypt32" "-lole32" "-lsecur32") elseif(USE_HTTPS STREQUAL "WinHTTP") - # WinHTTP setup was handled in the WinHTTP-specific block above + set(GIT_WINHTTP 1) + + # Since MinGW does not come with headers or an import library for winhttp, + # we have to include a private header and generate our own import library + if(MINGW) + add_subdirectory("${PROJECT_SOURCE_DIR}/deps/winhttp" "${PROJECT_BINARY_DIR}/deps/winhttp") + list(APPEND LIBGIT2_SYSTEM_LIBS winhttp) + list(APPEND LIBGIT2_DEPENDENCY_INCLUDES "${PROJECT_SOURCE_DIR}/deps/winhttp") + else() + list(APPEND LIBGIT2_SYSTEM_LIBS "winhttp") + list(APPEND LIBGIT2_PC_LIBS "-lwinhttp") + endif() + + list(APPEND LIBGIT2_SYSTEM_LIBS "rpcrt4" "crypt32" "ole32") + list(APPEND LIBGIT2_PC_LIBS "-lrpcrt4" "-lcrypt32" "-lole32") elseif(USE_HTTPS STREQUAL "OpenSSL-Dynamic") set(GIT_OPENSSL 1) set(GIT_OPENSSL_DYNAMIC 1) diff --git a/cmake/SelectHashes.cmake b/cmake/SelectHashes.cmake index faf9e2ea31d..5c007e58749 100644 --- a/cmake/SelectHashes.cmake +++ b/cmake/SelectHashes.cmake @@ -13,6 +13,8 @@ if(USE_SHA1 STREQUAL ON) elseif(USE_SHA1 STREQUAL "HTTPS") if(USE_HTTPS STREQUAL "SecureTransport") set(USE_SHA1 "CommonCrypto") + elseif(USE_HTTPS STREQUAL "Schannel") + set(USE_SHA1 "Win32") elseif(USE_HTTPS STREQUAL "WinHTTP") set(USE_SHA1 "Win32") elseif(USE_HTTPS) @@ -51,6 +53,8 @@ endif() if(USE_SHA256 STREQUAL "HTTPS") if(USE_HTTPS STREQUAL "SecureTransport") set(USE_SHA256 "CommonCrypto") + elseif(USE_HTTPS STREQUAL "Schannel") + set(USE_SHA256 "Win32") elseif(USE_HTTPS STREQUAL "WinHTTP") set(USE_SHA256 "Win32") elseif(USE_HTTPS) diff --git a/cmake/SelectWinHTTP.cmake b/cmake/SelectWinHTTP.cmake deleted file mode 100644 index 96e0bdbae54..00000000000 --- a/cmake/SelectWinHTTP.cmake +++ /dev/null @@ -1,17 +0,0 @@ -if(WIN32 AND USE_WINHTTP) - set(GIT_WINHTTP 1) - - # Since MinGW does not come with headers or an import library for winhttp, - # we have to include a private header and generate our own import library - if(MINGW) - add_subdirectory("${PROJECT_SOURCE_DIR}/deps/winhttp" "${PROJECT_BINARY_DIR}/deps/winhttp") - list(APPEND LIBGIT2_SYSTEM_LIBS winhttp) - list(APPEND LIBGIT2_DEPENDENCY_INCLUDES "${PROJECT_SOURCE_DIR}/deps/winhttp") - else() - list(APPEND LIBGIT2_SYSTEM_LIBS "winhttp") - list(APPEND LIBGIT2_PC_LIBS "-lwinhttp") - endif() - - list(APPEND LIBGIT2_SYSTEM_LIBS "rpcrt4" "crypt32" "ole32") - list(APPEND LIBGIT2_PC_LIBS "-lrpcrt4" "-lcrypt32" "-lole32") -endif() diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index e108b2e79ce..8fd22bc115c 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -42,7 +42,6 @@ include(SelectHashes) include(SelectHTTPParser) include(SelectRegex) include(SelectSSH) -include(SelectWinHTTP) include(SelectZlib) # diff --git a/src/libgit2/libgit2.c b/src/libgit2/libgit2.c index f225122e548..5d796b1f79b 100644 --- a/src/libgit2/libgit2.c +++ b/src/libgit2/libgit2.c @@ -30,6 +30,7 @@ #include "streams/registry.h" #include "streams/mbedtls.h" #include "streams/openssl.h" +#include "streams/socket.h" #include "transports/smart.h" #include "transports/http.h" #include "transports/ssh.h" @@ -78,6 +79,7 @@ int git_libgit2_init(void) git_merge_driver_global_init, git_transport_ssh_global_init, git_stream_registry_global_init, + git_socket_stream_global_init, git_openssl_stream_global_init, git_mbedtls_stream_global_init, git_mwindow_global_init, diff --git a/src/libgit2/streams/schannel.c b/src/libgit2/streams/schannel.c new file mode 100644 index 00000000000..2c1066adb7d --- /dev/null +++ b/src/libgit2/streams/schannel.c @@ -0,0 +1,715 @@ +/* + * Copyright (C) the libgit2 contributors. All rights reserved. + * + * This file is part of libgit2, distributed under the GNU GPL v2 with + * a Linking Exception. For full terms see the included COPYING file. + */ + +#include "streams/schannel.h" + +#ifdef GIT_SCHANNEL + +#define SECURITY_WIN32 + +#include +#include +#include + +#include "stream.h" +#include "streams/socket.h" + +#ifndef SP_PROT_TLS1_2_CLIENT +# define SP_PROT_TLS1_2_CLIENT 2048 +#endif + +#ifndef SP_PROT_TLS1_3_CLIENT +# define SP_PROT_TLS1_3_CLIENT 8192 +#endif + +#ifndef SECBUFFER_ALERT +# define SECBUFFER_ALERT 17 +#endif + +#define READ_BLOCKSIZE (16 * 1024) + +typedef enum { + STATE_NONE = 0, + STATE_CRED = 1, + STATE_CONTEXT = 2, + STATE_CERTIFICATE = 3 +} schannel_state; + +typedef struct { + git_stream parent; + git_stream *io; + int owned; + bool connected; + wchar_t *host_w; + + schannel_state state; + + CredHandle cred; + CtxtHandle context; + SecPkgContext_StreamSizes stream_sizes; + + CERT_CONTEXT *certificate; + const CERT_CHAIN_CONTEXT *cert_chain; + git_cert_x509 x509; + + git_str plaintext_in; + git_str ciphertext_in; +} schannel_stream; + +static int connect_context(schannel_stream *st) +{ + SCHANNEL_CRED cred = { 0 }; + SECURITY_STATUS status = SEC_E_INTERNAL_ERROR; + DWORD context_flags; + static size_t MAX_RETRIES = 1024; + size_t retries; + ssize_t read_len; + int error = 0; + + if (st->owned && (error = git_stream_connect(st->io)) < 0) + return error; + + cred.dwVersion = SCHANNEL_CRED_VERSION; + cred.dwFlags = SCH_CRED_IGNORE_NO_REVOCATION_CHECK | + SCH_CRED_IGNORE_REVOCATION_OFFLINE | + SCH_CRED_MANUAL_CRED_VALIDATION | + SCH_CRED_NO_DEFAULT_CREDS | + SCH_CRED_NO_SERVERNAME_CHECK; + cred.grbitEnabledProtocols = SP_PROT_TLS1_2_CLIENT | + SP_PROT_TLS1_3_CLIENT; + + if (AcquireCredentialsHandleW(NULL, SCHANNEL_NAME_W, + SECPKG_CRED_OUTBOUND, NULL, &cred, NULL, + NULL, &st->cred, NULL) != SEC_E_OK) { + git_error_set(GIT_ERROR_OS, "could not acquire credentials handle"); + return -1; + } + + st->state = STATE_CRED; + + context_flags = ISC_REQ_ALLOCATE_MEMORY | + ISC_REQ_CONFIDENTIALITY | + ISC_REQ_REPLAY_DETECT | + ISC_REQ_SEQUENCE_DETECT | + ISC_REQ_STREAM; + + for (retries = 0; retries < MAX_RETRIES; retries++) { + SecBuffer input_buf[] = { + { (unsigned long)st->ciphertext_in.size, + SECBUFFER_TOKEN, + st->ciphertext_in.size ? st->ciphertext_in.ptr : NULL }, + { 0, SECBUFFER_EMPTY, NULL } + }; + SecBuffer output_buf[] = { { 0, SECBUFFER_TOKEN, NULL }, + { 0, SECBUFFER_ALERT, NULL } }; + + SecBufferDesc input_buf_desc = { SECBUFFER_VERSION, 2, input_buf }; + SecBufferDesc output_buf_desc = { SECBUFFER_VERSION, 2, output_buf }; + + status = InitializeSecurityContextW(&st->cred, + retries ? &st->context : NULL, st->host_w, + context_flags, 0, 0, retries ? &input_buf_desc : NULL, 0, + retries ? NULL : &st->context, &output_buf_desc, + &context_flags, NULL); + + if (status == SEC_E_OK || status == SEC_I_CONTINUE_NEEDED) { + st->state = STATE_CONTEXT; + + if (output_buf[0].cbBuffer > 0) { + error = git_stream__write_full(st->io, + output_buf[0].pvBuffer, + output_buf[0].cbBuffer, 0); + + FreeContextBuffer(output_buf[0].pvBuffer); + } + + /* handle any leftover, unprocessed data */ + if (input_buf[1].BufferType == SECBUFFER_EXTRA) { + GIT_ASSERT(st->ciphertext_in.size > input_buf[1].cbBuffer); + + git_str_consume_bytes(&st->ciphertext_in, + st->ciphertext_in.size - input_buf[1].cbBuffer); + } else { + git_str_clear(&st->ciphertext_in); + } + + if (error < 0 || status == SEC_E_OK) + break; + } else if (status == SEC_E_INCOMPLETE_MESSAGE) { + /* we need additional data from the client; */ + if (git_str_grow_by(&st->ciphertext_in, READ_BLOCKSIZE) < 0) { + error = -1; + break; + } + + if ((read_len = git_stream_read(st->io, + st->ciphertext_in.ptr + st->ciphertext_in.size, + (st->ciphertext_in.asize - st->ciphertext_in.size))) < 0) { + error = -1; + break; + } + + GIT_ASSERT((size_t)read_len <= + st->ciphertext_in.asize - st->ciphertext_in.size); + st->ciphertext_in.size += read_len; + } else { + git_error_set(GIT_ERROR_OS, + "could not initialize security context"); + error = -1; + break; + } + + GIT_ASSERT(st->ciphertext_in.size < ULONG_MAX); + } + + if (retries == MAX_RETRIES) { + git_error_set(GIT_ERROR_SSL, + "could not initialize security context: too many retries"); + error = -1; + } + + if (!error) { + if (QueryContextAttributesW(&st->context, + SECPKG_ATTR_STREAM_SIZES, + &st->stream_sizes) != SEC_E_OK) { + git_error_set(GIT_ERROR_SSL, + "could not query stream sizes"); + error = -1; + } + } + + return error; +} + +static int set_certificate_lookup_error(DWORD status) +{ + switch (status) { + case CERT_TRUST_IS_NOT_TIME_VALID: + git_error_set(GIT_ERROR_SSL, + "certificate is expired or not yet valid"); + break; + case CERT_TRUST_IS_REVOKED: + git_error_set(GIT_ERROR_SSL, "certificate is revoked"); + break; + case CERT_TRUST_IS_NOT_SIGNATURE_VALID: + case CERT_TRUST_IS_NOT_VALID_FOR_USAGE: + case CERT_TRUST_INVALID_EXTENSION: + case CERT_TRUST_INVALID_POLICY_CONSTRAINTS: + case CERT_TRUST_INVALID_BASIC_CONSTRAINTS: + case CERT_TRUST_INVALID_NAME_CONSTRAINTS: + case CERT_TRUST_HAS_NOT_SUPPORTED_NAME_CONSTRAINT: + case CERT_TRUST_HAS_NOT_DEFINED_NAME_CONSTRAINT: + case CERT_TRUST_HAS_NOT_PERMITTED_NAME_CONSTRAINT: + case CERT_TRUST_HAS_EXCLUDED_NAME_CONSTRAINT: + case CERT_TRUST_NO_ISSUANCE_CHAIN_POLICY: + case CERT_TRUST_HAS_NOT_SUPPORTED_CRITICAL_EXT: + git_error_set(GIT_ERROR_SSL, "certificate is not valid"); + break; + case CERT_TRUST_IS_UNTRUSTED_ROOT: + case CERT_TRUST_IS_CYCLIC: + case CERT_TRUST_IS_EXPLICIT_DISTRUST: + git_error_set(GIT_ERROR_SSL, "certificate is not trusted"); + break; + case CERT_TRUST_REVOCATION_STATUS_UNKNOWN: + git_error_set(GIT_ERROR_SSL, + "certificate revocation status could not be verified"); + break; + case CERT_TRUST_IS_OFFLINE_REVOCATION: + git_error_set(GIT_ERROR_SSL, + "certificate revocation is offline or stale"); + break; + case CERT_TRUST_HAS_WEAK_SIGNATURE: + git_error_set(GIT_ERROR_SSL, "certificate has a weak signature"); + break; + default: + git_error_set(GIT_ERROR_SSL, + "unknown certificate lookup failure: %d", status); + return -1; + } + + return GIT_ECERTIFICATE; +} + +static int set_certificate_validation_error(DWORD status) +{ + switch (status) { + case TRUST_E_CERT_SIGNATURE: + git_error_set(GIT_ERROR_SSL, + "the certificate cannot be verified"); + break; + case CRYPT_E_REVOKED: + git_error_set(GIT_ERROR_SSL, + "the certificate or signature has been revoked"); + break; + case CERT_E_UNTRUSTEDROOT: + git_error_set(GIT_ERROR_SSL, + "the certificate root is not trusted"); + break; + case CERT_E_UNTRUSTEDTESTROOT: + git_error_set(GIT_ERROR_SSL, + "the certificate root is a test certificate"); + break; + case CERT_E_CHAINING: + git_error_set(GIT_ERROR_SSL, + "the certificate chain is invalid"); + break; + case CERT_E_WRONG_USAGE: + case CERT_E_PURPOSE: + git_error_set(GIT_ERROR_SSL, + "the certificate is not valid for this usage"); + break; + case CERT_E_EXPIRED: + git_error_set(GIT_ERROR_SSL, + "certificate is expired or not yet valid"); + break; + case CERT_E_INVALID_NAME: + case CERT_E_CN_NO_MATCH: + git_error_set(GIT_ERROR_SSL, + "certificate is not valid for this hostname"); + break; + case CERT_E_INVALID_POLICY: + case TRUST_E_BASIC_CONSTRAINTS: + case CERT_E_CRITICAL: + case CERT_E_VALIDITYPERIODNESTING: + git_error_set(GIT_ERROR_SSL, "certificate is not valid"); + break; + case CRYPT_E_NO_REVOCATION_CHECK: + git_error_set(GIT_ERROR_SSL, + "certificate revocation status could not be verified"); + break; + case CRYPT_E_REVOCATION_OFFLINE: + git_error_set(GIT_ERROR_SSL, + "certificate revocation is offline or stale"); + break; + case CERT_E_ROLE: + git_error_set(GIT_ERROR_SSL, "certificate authority is not valid"); + break; + default: + git_error_set(GIT_ERROR_SSL, + "unknown certificate policy checking failure: %d", + status); + return -1; + } + + return GIT_ECERTIFICATE; +} + +static int check_certificate(schannel_stream* st) +{ + CERT_CHAIN_PARA cert_chain_parameters; + SSL_EXTRA_CERT_CHAIN_POLICY_PARA ssl_policy_parameters; + CERT_CHAIN_POLICY_PARA cert_policy_parameters = + { sizeof(CERT_CHAIN_POLICY_PARA), 0, &ssl_policy_parameters }; + CERT_CHAIN_POLICY_STATUS cert_policy_status; + + memset(&cert_chain_parameters, 0, sizeof(CERT_CHAIN_PARA)); + cert_chain_parameters.cbSize = sizeof(CERT_CHAIN_PARA); + + if (QueryContextAttributesW(&st->context, + SECPKG_ATTR_REMOTE_CERT_CONTEXT, + &st->certificate) != SEC_E_OK) { + git_error_set(GIT_ERROR_OS, + "could not query remote certificate context"); + return -1; + } + + /* TODO: do we really want to do revokcation checking ? */ + if (!CertGetCertificateChain(NULL, st->certificate, NULL, + st->certificate->hCertStore, &cert_chain_parameters, + CERT_CHAIN_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOT, + NULL, &st->cert_chain)) { + git_error_set(GIT_ERROR_OS, "could not query remote certificate chain"); + CertFreeCertificateContext(st->certificate); + return -1; + } + + st->state = STATE_CERTIFICATE; + + /* Set up the x509 certificate data for future callbacks */ + + st->x509.parent.cert_type = GIT_CERT_X509; + st->x509.data = st->certificate->pbCertEncoded; + st->x509.len = st->certificate->cbCertEncoded; + + /* Handle initial certificate validation */ + + if (st->cert_chain->TrustStatus.dwErrorStatus != CERT_TRUST_NO_ERROR) + return set_certificate_lookup_error(st->cert_chain->TrustStatus.dwErrorStatus); + + ssl_policy_parameters.cbSize = sizeof(SSL_EXTRA_CERT_CHAIN_POLICY_PARA); + ssl_policy_parameters.dwAuthType = AUTHTYPE_SERVER; + ssl_policy_parameters.pwszServerName = st->host_w; + + if (!CertVerifyCertificateChainPolicy(CERT_CHAIN_POLICY_SSL, + st->cert_chain, &cert_policy_parameters, + &cert_policy_status)) { + git_error_set(GIT_ERROR_OS, "could not verify certificate chain policy"); + return -1; + } + + if (cert_policy_status.dwError != SEC_E_OK) + return set_certificate_validation_error(cert_policy_status.dwError); + + return 0; +} + +static int schannel_connect(git_stream *stream) +{ + schannel_stream *st = (schannel_stream *)stream; + int error; + + GIT_ASSERT(st->state == STATE_NONE); + + if ((error = connect_context(st)) < 0 || + (error = check_certificate(st)) < 0) + return error; + + st->connected = 1; + return 0; +} + +static int schannel_certificate(git_cert **out, git_stream *stream) +{ + schannel_stream *st = (schannel_stream *)stream; + + *out = &st->x509.parent; + return 0; +} + +static int schannel_set_proxy( + git_stream *stream, + const git_proxy_options *proxy_options) +{ + schannel_stream *st = (schannel_stream *)stream; + return git_stream_set_proxy(st->io, proxy_options); +} + +static ssize_t schannel_write( + git_stream *stream, + const char *data, + size_t data_len, + int flags) +{ + schannel_stream *st = (schannel_stream *)stream; + SecBuffer encrypt_buf[3]; + SecBufferDesc encrypt_buf_desc = { SECBUFFER_VERSION, 3, encrypt_buf }; + git_str ciphertext_out = GIT_STR_INIT; + ssize_t total_len = 0; + + GIT_UNUSED(flags); + + if (data_len > SSIZE_MAX) + data_len = SSIZE_MAX; + + git_str_init(&ciphertext_out, + st->stream_sizes.cbHeader + + st->stream_sizes.cbMaximumMessage + + st->stream_sizes.cbTrailer); + + while (data_len > 0) { + size_t message_len = min(data_len, st->stream_sizes.cbMaximumMessage); + size_t ciphertext_len, ciphertext_written = 0; + + encrypt_buf[0].BufferType = SECBUFFER_STREAM_HEADER; + encrypt_buf[0].cbBuffer = st->stream_sizes.cbHeader; + encrypt_buf[0].pvBuffer = ciphertext_out.ptr; + + encrypt_buf[1].BufferType = SECBUFFER_DATA; + encrypt_buf[1].cbBuffer = (unsigned long)message_len; + encrypt_buf[1].pvBuffer = + ciphertext_out.ptr + st->stream_sizes.cbHeader; + + encrypt_buf[2].BufferType = SECBUFFER_STREAM_TRAILER; + encrypt_buf[2].cbBuffer = st->stream_sizes.cbTrailer; + encrypt_buf[2].pvBuffer = + ciphertext_out.ptr + st->stream_sizes.cbHeader + + message_len; + + memcpy(ciphertext_out.ptr + st->stream_sizes.cbHeader, data, message_len); + + if (EncryptMessage(&st->context, 0, &encrypt_buf_desc, 0) != SEC_E_OK) { + git_error_set(GIT_ERROR_OS, "could not encrypt tls message"); + total_len = -1; + goto done; + } + + ciphertext_len = encrypt_buf[0].cbBuffer + + encrypt_buf[1].cbBuffer + + encrypt_buf[2].cbBuffer; + + while (ciphertext_written < ciphertext_len) { + ssize_t chunk_len = git_stream_write(st->io, + ciphertext_out.ptr + ciphertext_written, + ciphertext_len - ciphertext_written, 0); + + if (chunk_len < 0) { + total_len = -1; + goto done; + } + + ciphertext_len -= chunk_len; + ciphertext_written += chunk_len; + } + + total_len += message_len; + + data += message_len; + data_len -= message_len; + } + +done: + git_str_dispose(&ciphertext_out); + return total_len; +} + +static ssize_t schannel_read(git_stream *stream, void *_data, size_t data_len) +{ + schannel_stream *st = (schannel_stream *)stream; + char *data = (char *)_data; + SecBuffer decrypt_buf[4]; + SecBufferDesc decrypt_buf_desc = { SECBUFFER_VERSION, 4, decrypt_buf }; + SECURITY_STATUS status; + ssize_t chunk_len, total_len = 0; + + if (data_len > SSIZE_MAX) + data_len = SSIZE_MAX; + + /* + * Loop until we have some bytes to return - we may have decrypted + * bytes queued or ciphertext from the wire that we can decrypt and + * return. Return any queued bytes if they're available to avoid a + * network read, which may block. We may return less than the + * caller requested, and they can retry for an actual network + */ + while ((size_t)total_len < data_len) { + if (st->plaintext_in.size > 0) { + size_t copy_len = min(st->plaintext_in.size, data_len); + + memcpy(data, st->plaintext_in.ptr, copy_len); + git_str_consume_bytes(&st->plaintext_in, copy_len); + + data += copy_len; + data_len -= copy_len; + + total_len += copy_len; + + continue; + } + + if (st->ciphertext_in.size > 0) { + decrypt_buf[0].BufferType = SECBUFFER_DATA; + decrypt_buf[0].cbBuffer = (unsigned long)min(st->ciphertext_in.size, ULONG_MAX); + decrypt_buf[0].pvBuffer = st->ciphertext_in.ptr; + + decrypt_buf[1].BufferType = SECBUFFER_EMPTY; + decrypt_buf[1].cbBuffer = 0; + decrypt_buf[1].pvBuffer = NULL; + + decrypt_buf[2].BufferType = SECBUFFER_EMPTY; + decrypt_buf[2].cbBuffer = 0; + decrypt_buf[2].pvBuffer = NULL; + + decrypt_buf[3].BufferType = SECBUFFER_EMPTY; + decrypt_buf[3].cbBuffer = 0; + decrypt_buf[3].pvBuffer = NULL; + + status = DecryptMessage(&st->context, &decrypt_buf_desc, 0, NULL); + + if (status == SEC_E_OK) { + GIT_ASSERT(decrypt_buf[0].BufferType == SECBUFFER_STREAM_HEADER); + GIT_ASSERT(decrypt_buf[1].BufferType == SECBUFFER_DATA); + GIT_ASSERT(decrypt_buf[2].BufferType == SECBUFFER_STREAM_TRAILER); + + if (git_str_put(&st->plaintext_in, decrypt_buf[1].pvBuffer, decrypt_buf[1].cbBuffer) < 0) { + total_len = -1; + goto done; + } + + if (decrypt_buf[3].BufferType == SECBUFFER_EXTRA) { + git_str_consume_bytes(&st->ciphertext_in, (st->ciphertext_in.size - decrypt_buf[3].cbBuffer)); + } else { + git_str_clear(&st->ciphertext_in); + } + + continue; + } else if (status == SEC_E_CONTEXT_EXPIRED) { + break; + } else if (status != SEC_E_INCOMPLETE_MESSAGE) { + git_error_set(GIT_ERROR_SSL, "could not decrypt tls message"); + total_len = -1; + goto done; + } + } + + if (total_len != 0) + break; + + if (git_str_grow_by(&st->ciphertext_in, READ_BLOCKSIZE) < 0) { + total_len = -1; + goto done; + } + + if ((chunk_len = git_stream_read(st->io, st->ciphertext_in.ptr + st->ciphertext_in.size, st->ciphertext_in.asize - st->ciphertext_in.size)) < 0) { + total_len = -1; + goto done; + } + + st->ciphertext_in.size += chunk_len; + } + +done: + return total_len; +} + +static int schannel_close(git_stream *stream) +{ + schannel_stream *st = (schannel_stream *)stream; + int error = 0; + + if (st->connected) { + SecBuffer shutdown_buf; + SecBufferDesc shutdown_buf_desc = + { SECBUFFER_VERSION, 1, &shutdown_buf }; + DWORD shutdown_message = SCHANNEL_SHUTDOWN, shutdown_flags; + + shutdown_buf.BufferType = SECBUFFER_TOKEN; + shutdown_buf.cbBuffer = sizeof(DWORD); + shutdown_buf.pvBuffer = &shutdown_message; + + if (ApplyControlToken(&st->context, &shutdown_buf_desc) != SEC_E_OK) { + git_error_set(GIT_ERROR_SSL, "could not shutdown stream"); + error = -1; + } + + shutdown_buf.BufferType = SECBUFFER_TOKEN; + shutdown_buf.cbBuffer = 0; + shutdown_buf.pvBuffer = NULL; + + shutdown_flags = ISC_REQ_ALLOCATE_MEMORY | + ISC_REQ_CONFIDENTIALITY | + ISC_REQ_REPLAY_DETECT | + ISC_REQ_SEQUENCE_DETECT | + ISC_REQ_STREAM; + + if (InitializeSecurityContext(&st->cred, &st->context, + NULL, shutdown_flags, 0, 0, + &shutdown_buf_desc, 0, NULL, + &shutdown_buf_desc, &shutdown_flags, + NULL) == SEC_E_OK) { + if (shutdown_buf.cbBuffer > 0) { + if (git_stream__write_full(st->io, + shutdown_buf.pvBuffer, + shutdown_buf.cbBuffer, 0) < 0) + error = -1; + + FreeContextBuffer(shutdown_buf.pvBuffer); + } + } + } + + st->connected = false; + + if (st->owned && git_stream_close(st->io) < 0) + error = -1; + + return error; +} + +static void schannel_free(git_stream *stream) +{ + schannel_stream *st = (schannel_stream *)stream; + + if (st->state >= STATE_CERTIFICATE) { + CertFreeCertificateContext(st->certificate); + CertFreeCertificateChain(st->cert_chain); + } + + if (st->state >= STATE_CONTEXT) + DeleteSecurityContext(&st->context); + + if (st->state >= STATE_CRED) + FreeCredentialsHandle(&st->cred); + + st->state = STATE_NONE; + + git_str_dispose(&st->ciphertext_in); + git_str_dispose(&st->plaintext_in); + + git__free(st->host_w); + + if (st->owned) + git_stream_free(st->io); + + git__free(st); +} + +static int schannel_stream_wrap( + git_stream **out, + git_stream *in, + const char *host, + int owned) +{ + schannel_stream *st; + + st = git__calloc(1, sizeof(schannel_stream)); + GIT_ERROR_CHECK_ALLOC(st); + + st->io = in; + st->owned = owned; + + if (git__utf8_to_16_alloc(&st->host_w, host) < 0) { + git__free(st); + return -1; + } + + st->parent.version = GIT_STREAM_VERSION; + st->parent.encrypted = 1; + st->parent.proxy_support = git_stream_supports_proxy(st->io); + st->parent.connect = schannel_connect; + st->parent.certificate = schannel_certificate; + st->parent.set_proxy = schannel_set_proxy; + st->parent.read = schannel_read; + st->parent.write = schannel_write; + st->parent.close = schannel_close; + st->parent.free = schannel_free; + + *out = (git_stream *)st; + return 0; +} + +extern int git_schannel_stream_new( + git_stream **out, + const char *host, + const char *port) +{ + git_stream *stream; + int error; + + GIT_ASSERT_ARG(out); + GIT_ASSERT_ARG(host); + GIT_ASSERT_ARG(port); + + if ((error = git_socket_stream_new(&stream, host, port)) < 0) + return error; + + if ((error = schannel_stream_wrap(out, stream, host, 1)) < 0) { + git_stream_close(stream); + git_stream_free(stream); + } + + return error; +} + +extern int git_schannel_stream_wrap( + git_stream **out, + git_stream *in, + const char *host) +{ + return schannel_stream_wrap(out, in, host, 0); +} + +#endif diff --git a/src/libgit2/streams/schannel.h b/src/libgit2/streams/schannel.h new file mode 100644 index 00000000000..3584970d1f8 --- /dev/null +++ b/src/libgit2/streams/schannel.h @@ -0,0 +1,28 @@ +/* + * Copyright (C) the libgit2 contributors. All rights reserved. + * + * This file is part of libgit2, distributed under the GNU GPL v2 with + * a Linking Exception. For full terms see the included COPYING file. + */ +#ifndef INCLUDE_steams_schannel_h__ +#define INCLUDE_steams_schannel_h__ + +#include "common.h" + +#include "git2/sys/stream.h" + +#ifdef GIT_SCHANNEL + +extern int git_schannel_stream_new( + git_stream **out, + const char *host, + const char *port); + +extern int git_schannel_stream_wrap( + git_stream **out, + git_stream *in, + const char *host); + +#endif + +#endif diff --git a/src/libgit2/streams/socket.c b/src/libgit2/streams/socket.c index 908e8c02f9b..8f23e746e51 100644 --- a/src/libgit2/streams/socket.c +++ b/src/libgit2/streams/socket.c @@ -10,22 +10,23 @@ #include "posix.h" #include "netops.h" #include "registry.h" +#include "runtime.h" #include "stream.h" #ifndef _WIN32 -# include -# include -# include -# include -# include -# include -# include +# include +# include +# include +# include +# include +# include +# include #else -# include -# include -# ifdef _MSC_VER -# pragma comment(lib, "ws2_32") -# endif +# include +# include +# ifdef _MSC_VER +# pragma comment(lib, "ws2_32") +# endif #endif #ifdef GIT_WIN32 @@ -54,11 +55,8 @@ static int close_socket(GIT_SOCKET s) return 0; #ifdef GIT_WIN32 - if (SOCKET_ERROR == closesocket(s)) - return -1; - - if (0 != WSACleanup()) { - git_error_set(GIT_ERROR_OS, "winsock cleanup failed"); + if (closesocket(s) != 0) { + net_set_error("could not close socket"); return -1; } @@ -77,23 +75,6 @@ static int socket_connect(git_stream *stream) GIT_SOCKET s = INVALID_SOCKET; int ret; -#ifdef GIT_WIN32 - /* on win32, the WSA context needs to be initialized - * before any socket calls can be performed */ - WSADATA wsd; - - if (WSAStartup(MAKEWORD(2,2), &wsd) != 0) { - git_error_set(GIT_ERROR_OS, "winsock init failed"); - return -1; - } - - if (LOBYTE(wsd.wVersion) != 2 || HIBYTE(wsd.wVersion) != 2) { - WSACleanup(); - git_error_set(GIT_ERROR_OS, "winsock init failed"); - return -1; - } -#endif - memset(&hints, 0x0, sizeof(struct addrinfo)); hints.ai_socktype = SOCK_STREAM; hints.ai_family = AF_UNSPEC; @@ -240,3 +221,42 @@ int git_socket_stream_new( return init(out, host, port); } + +#ifdef GIT_WIN32 + +static void socket_stream_global_shutdown(void) +{ + WSACleanup(); +} + +int git_socket_stream_global_init(void) +{ + WORD winsock_version; + WSADATA wsa_data; + + winsock_version = MAKEWORD(2, 2); + + if (WSAStartup(winsock_version, &wsa_data) != 0) { + git_error_set(GIT_ERROR_OS, "could not initialize Windows Socket Library"); + return -1; + } + + if (LOBYTE(wsa_data.wVersion) != 2 || + HIBYTE(wsa_data.wVersion) != 2) { + git_error_set(GIT_ERROR_SSL, "Windows Socket Library does not support Winsock 2.2"); + return -1; + } + + return git_runtime_shutdown_register(socket_stream_global_shutdown); +} + +#else + +#include "stream.h" + +int git_socket_stream_global_init(void) +{ + return 0; +} + + #endif diff --git a/src/libgit2/streams/socket.h b/src/libgit2/streams/socket.h index 3235f31679c..300e708937f 100644 --- a/src/libgit2/streams/socket.h +++ b/src/libgit2/streams/socket.h @@ -20,4 +20,6 @@ typedef struct { extern int git_socket_stream_new(git_stream **out, const char *host, const char *port); +extern int git_socket_stream_global_init(void); + #endif diff --git a/src/libgit2/streams/tls.c b/src/libgit2/streams/tls.c index e063a33f99a..246ac9ca793 100644 --- a/src/libgit2/streams/tls.c +++ b/src/libgit2/streams/tls.c @@ -13,6 +13,7 @@ #include "streams/mbedtls.h" #include "streams/openssl.h" #include "streams/stransport.h" +#include "streams/schannel.h" int git_tls_stream_new(git_stream **out, const char *host, const char *port) { @@ -33,6 +34,8 @@ int git_tls_stream_new(git_stream **out, const char *host, const char *port) init = git_openssl_stream_new; #elif defined(GIT_MBEDTLS) init = git_mbedtls_stream_new; +#elif defined(GIT_SCHANNEL) + init = git_schannel_stream_new; #endif } else { return error; @@ -63,6 +66,8 @@ int git_tls_stream_wrap(git_stream **out, git_stream *in, const char *host) wrap = git_openssl_stream_wrap; #elif defined(GIT_MBEDTLS) wrap = git_mbedtls_stream_wrap; +#elif defined(GIT_SCHANNEL) + wrap = git_schannel_stream_wrap; #endif } diff --git a/src/util/git2_features.h.in b/src/util/git2_features.h.in index fbf0cab60ea..1575be641e1 100644 --- a/src/util/git2_features.h.in +++ b/src/util/git2_features.h.in @@ -41,6 +41,7 @@ #cmakedefine GIT_OPENSSL_DYNAMIC 1 #cmakedefine GIT_SECURE_TRANSPORT 1 #cmakedefine GIT_MBEDTLS 1 +#cmakedefine GIT_SCHANNEL 1 #cmakedefine GIT_SHA1_COLLISIONDETECT 1 #cmakedefine GIT_SHA1_WIN32 1 diff --git a/tests/libgit2/online/clone.c b/tests/libgit2/online/clone.c index 1a4cdb520ce..b635739b676 100644 --- a/tests/libgit2/online/clone.c +++ b/tests/libgit2/online/clone.c @@ -580,6 +580,17 @@ static int succeed_certificate_check(git_cert *cert, int valid, const char *host return 0; } +static int x509_succeed_certificate_check(git_cert *cert, int valid, const char *host, void *payload) +{ + GIT_UNUSED(valid); + GIT_UNUSED(payload); + + cl_assert_equal_s("github.com", host); + cl_assert_equal_i(GIT_CERT_X509, cert->cert_type); + + return 0; +} + static int fail_certificate_check(git_cert *cert, int valid, const char *host, void *payload) { GIT_UNUSED(cert); @@ -901,7 +912,7 @@ void test_online_clone__certificate_invalid(void) void test_online_clone__certificate_valid(void) { - g_options.fetch_opts.callbacks.certificate_check = succeed_certificate_check; + g_options.fetch_opts.callbacks.certificate_check = x509_succeed_certificate_check; cl_git_pass(git_clone(&g_repo, "https://github.com/libgit2/TestGitRepository", "./foo", &g_options)); } diff --git a/tests/libgit2/stream/registration.c b/tests/libgit2/stream/registration.c index bf3c20502a0..ccaecee8c1e 100644 --- a/tests/libgit2/stream/registration.c +++ b/tests/libgit2/stream/registration.c @@ -81,10 +81,10 @@ void test_stream_registration__tls(void) cl_git_pass(git_stream_register(GIT_STREAM_TLS, NULL)); error = git_tls_stream_new(&stream, "localhost", "443"); - /* We don't have TLS support enabled, or we're on Windows, - * which has no arbitrary TLS stream support. + /* We don't have TLS support enabled, or we're on Windows + * with WinHTTP, which is not actually TLS stream support. */ -#if defined(GIT_WIN32) || !defined(GIT_HTTPS) +#if defined(GIT_WINHTTP) || !defined(GIT_HTTPS) cl_git_fail_with(-1, error); #else cl_git_pass(error); From cff0d9b1cc2432ab6a6eab777cdfe230ee07fca1 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 11 Mar 2023 00:03:34 -0800 Subject: [PATCH 194/608] http: refactor GSSAPI / negotiate / NTLM auth Name the GSSAPI and ntlmclient authentication providers as such. Today they're named after the authentication mechanism ("Negotiate", "NTLM") instead of their implementation. If we have competing implementations for the same mechanism (eg, a future Windows SSPI-based provider for Negotiate and NTLM) then this will get confusing. --- .../{auth_negotiate.c => auth_gssapi.c} | 64 +++++++++---------- src/libgit2/transports/auth_ntlm.h | 4 +- .../{auth_ntlm.c => auth_ntlmclient.c} | 24 +++---- 3 files changed, 46 insertions(+), 46 deletions(-) rename src/libgit2/transports/{auth_negotiate.c => auth_gssapi.c} (79%) rename src/libgit2/transports/{auth_ntlm.c => auth_ntlmclient.c} (88%) diff --git a/src/libgit2/transports/auth_negotiate.c b/src/libgit2/transports/auth_gssapi.c similarity index 79% rename from src/libgit2/transports/auth_negotiate.c rename to src/libgit2/transports/auth_gssapi.c index 6380504be7e..5005538411b 100644 --- a/src/libgit2/transports/auth_negotiate.c +++ b/src/libgit2/transports/auth_gssapi.c @@ -20,13 +20,13 @@ #include #endif -static gss_OID_desc negotiate_oid_spnego = +static gss_OID_desc gssapi_oid_spnego = { 6, (void *) "\x2b\x06\x01\x05\x05\x02" }; -static gss_OID_desc negotiate_oid_krb5 = +static gss_OID_desc gssapi_oid_krb5 = { 9, (void *) "\x2a\x86\x48\x86\xf7\x12\x01\x02\x02" }; -static gss_OID negotiate_oids[] = - { &negotiate_oid_spnego, &negotiate_oid_krb5, NULL }; +static gss_OID gssapi_oids[] = + { &gssapi_oid_spnego, &gssapi_oid_krb5, NULL }; typedef struct { git_http_auth_context parent; @@ -36,9 +36,9 @@ typedef struct { char *challenge; gss_ctx_id_t gss_context; gss_OID oid; -} http_auth_negotiate_context; +} http_auth_gssapi_context; -static void negotiate_err_set( +static void gssapi_err_set( OM_uint32 status_major, OM_uint32 status_minor, const char *message) @@ -58,11 +58,11 @@ static void negotiate_err_set( } } -static int negotiate_set_challenge( +static int gssapi_set_challenge( git_http_auth_context *c, const char *challenge) { - http_auth_negotiate_context *ctx = (http_auth_negotiate_context *)c; + http_auth_gssapi_context *ctx = (http_auth_gssapi_context *)c; GIT_ASSERT_ARG(ctx); GIT_ASSERT_ARG(challenge); @@ -76,7 +76,7 @@ static int negotiate_set_challenge( return 0; } -static void negotiate_context_dispose(http_auth_negotiate_context *ctx) +static void gssapi_context_dispose(http_auth_gssapi_context *ctx) { OM_uint32 status_minor; @@ -92,12 +92,12 @@ static void negotiate_context_dispose(http_auth_negotiate_context *ctx) ctx->challenge = NULL; } -static int negotiate_next_token( +static int gssapi_next_token( git_str *buf, git_http_auth_context *c, git_credential *cred) { - http_auth_negotiate_context *ctx = (http_auth_negotiate_context *)c; + http_auth_gssapi_context *ctx = (http_auth_gssapi_context *)c; OM_uint32 status_major, status_minor; gss_buffer_desc target_buffer = GSS_C_EMPTY_BUFFER, input_token = GSS_C_EMPTY_BUFFER, @@ -126,7 +126,7 @@ static int negotiate_next_token( GSS_C_NT_HOSTBASED_SERVICE, &server); if (GSS_ERROR(status_major)) { - negotiate_err_set(status_major, status_minor, + gssapi_err_set(status_major, status_minor, "could not parse principal"); error = -1; goto done; @@ -152,10 +152,10 @@ static int negotiate_next_token( input_token.length = input_buf.size; input_token_ptr = &input_token; } else if (ctx->gss_context != GSS_C_NO_CONTEXT) { - negotiate_context_dispose(ctx); + gssapi_context_dispose(ctx); } - mech = &negotiate_oid_spnego; + mech = &gssapi_oid_spnego; status_major = gss_init_sec_context( &status_minor, @@ -173,14 +173,14 @@ static int negotiate_next_token( NULL); if (GSS_ERROR(status_major)) { - negotiate_err_set(status_major, status_minor, "negotiate failure"); + gssapi_err_set(status_major, status_minor, "negotiate failure"); error = -1; goto done; } /* This message merely told us auth was complete; we do not respond. */ if (status_major == GSS_S_COMPLETE) { - negotiate_context_dispose(ctx); + gssapi_context_dispose(ctx); ctx->complete = 1; goto done; } @@ -204,20 +204,20 @@ static int negotiate_next_token( return error; } -static int negotiate_is_complete(git_http_auth_context *c) +static int gssapi_is_complete(git_http_auth_context *c) { - http_auth_negotiate_context *ctx = (http_auth_negotiate_context *)c; + http_auth_gssapi_context *ctx = (http_auth_gssapi_context *)c; GIT_ASSERT_ARG(ctx); return (ctx->complete == 1); } -static void negotiate_context_free(git_http_auth_context *c) +static void gssapi_context_free(git_http_auth_context *c) { - http_auth_negotiate_context *ctx = (http_auth_negotiate_context *)c; + http_auth_gssapi_context *ctx = (http_auth_gssapi_context *)c; - negotiate_context_dispose(ctx); + gssapi_context_dispose(ctx); ctx->configured = 0; ctx->complete = 0; @@ -226,8 +226,8 @@ static void negotiate_context_free(git_http_auth_context *c) git__free(ctx); } -static int negotiate_init_context( - http_auth_negotiate_context *ctx, +static int gssapi_init_context( + http_auth_gssapi_context *ctx, const git_net_url *url) { OM_uint32 status_major, status_minor; @@ -239,13 +239,13 @@ static int negotiate_init_context( status_major = gss_indicate_mechs(&status_minor, &mechanism_list); if (GSS_ERROR(status_major)) { - negotiate_err_set(status_major, status_minor, + gssapi_err_set(status_major, status_minor, "could not query mechanisms"); return -1; } if (mechanism_list) { - for (oid = negotiate_oids; *oid; oid++) { + for (oid = gssapi_oids; *oid; oid++) { for (i = 0; i < mechanism_list->count; i++) { item = &mechanism_list->elements[i]; @@ -285,14 +285,14 @@ int git_http_auth_negotiate( git_http_auth_context **out, const git_net_url *url) { - http_auth_negotiate_context *ctx; + http_auth_gssapi_context *ctx; *out = NULL; - ctx = git__calloc(1, sizeof(http_auth_negotiate_context)); + ctx = git__calloc(1, sizeof(http_auth_gssapi_context)); GIT_ERROR_CHECK_ALLOC(ctx); - if (negotiate_init_context(ctx, url) < 0) { + if (gssapi_init_context(ctx, url) < 0) { git__free(ctx); return -1; } @@ -300,10 +300,10 @@ int git_http_auth_negotiate( ctx->parent.type = GIT_HTTP_AUTH_NEGOTIATE; ctx->parent.credtypes = GIT_CREDENTIAL_DEFAULT; ctx->parent.connection_affinity = 1; - ctx->parent.set_challenge = negotiate_set_challenge; - ctx->parent.next_token = negotiate_next_token; - ctx->parent.is_complete = negotiate_is_complete; - ctx->parent.free = negotiate_context_free; + ctx->parent.set_challenge = gssapi_set_challenge; + ctx->parent.next_token = gssapi_next_token; + ctx->parent.is_complete = gssapi_is_complete; + ctx->parent.free = gssapi_context_free; *out = (git_http_auth_context *)ctx; diff --git a/src/libgit2/transports/auth_ntlm.h b/src/libgit2/transports/auth_ntlm.h index 40689498cae..2bf8f41f619 100644 --- a/src/libgit2/transports/auth_ntlm.h +++ b/src/libgit2/transports/auth_ntlm.h @@ -5,8 +5,8 @@ * a Linking Exception. For full terms see the included COPYING file. */ -#ifndef INCLUDE_transports_auth_ntlm_h__ -#define INCLUDE_transports_auth_ntlm_h__ +#ifndef INCLUDE_transports_auth_ntlmclient_h__ +#define INCLUDE_transports_auth_ntlmclient_h__ #include "auth.h" diff --git a/src/libgit2/transports/auth_ntlm.c b/src/libgit2/transports/auth_ntlmclient.c similarity index 88% rename from src/libgit2/transports/auth_ntlm.c rename to src/libgit2/transports/auth_ntlmclient.c index f49ce101a56..6f26a6179c6 100644 --- a/src/libgit2/transports/auth_ntlm.c +++ b/src/libgit2/transports/auth_ntlmclient.c @@ -23,7 +23,7 @@ typedef struct { bool complete; } http_auth_ntlm_context; -static int ntlm_set_challenge( +static int ntlmclient_set_challenge( git_http_auth_context *c, const char *challenge) { @@ -40,7 +40,7 @@ static int ntlm_set_challenge( return 0; } -static int ntlm_set_credentials(http_auth_ntlm_context *ctx, git_credential *_cred) +static int ntlmclient_set_credentials(http_auth_ntlm_context *ctx, git_credential *_cred) { git_credential_userpass_plaintext *cred; const char *sep, *username; @@ -76,7 +76,7 @@ static int ntlm_set_credentials(http_auth_ntlm_context *ctx, git_credential *_cr return error; } -static int ntlm_next_token( +static int ntlmclient_next_token( git_str *buf, git_http_auth_context *c, git_credential *cred) @@ -104,7 +104,7 @@ static int ntlm_next_token( */ ctx->complete = true; - if (cred && ntlm_set_credentials(ctx, cred) != 0) + if (cred && ntlmclient_set_credentials(ctx, cred) != 0) goto done; if (challenge_len < 4) { @@ -162,7 +162,7 @@ static int ntlm_next_token( return error; } -static int ntlm_is_complete(git_http_auth_context *c) +static int ntlmclient_is_complete(git_http_auth_context *c) { http_auth_ntlm_context *ctx = (http_auth_ntlm_context *)c; @@ -170,7 +170,7 @@ static int ntlm_is_complete(git_http_auth_context *c) return (ctx->complete == true); } -static void ntlm_context_free(git_http_auth_context *c) +static void ntlmclient_context_free(git_http_auth_context *c) { http_auth_ntlm_context *ctx = (http_auth_ntlm_context *)c; @@ -179,7 +179,7 @@ static void ntlm_context_free(git_http_auth_context *c) git__free(ctx); } -static int ntlm_init_context( +static int ntlmclient_init_context( http_auth_ntlm_context *ctx, const git_net_url *url) { @@ -206,7 +206,7 @@ int git_http_auth_ntlm( ctx = git__calloc(1, sizeof(http_auth_ntlm_context)); GIT_ERROR_CHECK_ALLOC(ctx); - if (ntlm_init_context(ctx, url) < 0) { + if (ntlmclient_init_context(ctx, url) < 0) { git__free(ctx); return -1; } @@ -214,10 +214,10 @@ int git_http_auth_ntlm( ctx->parent.type = GIT_HTTP_AUTH_NTLM; ctx->parent.credtypes = GIT_CREDENTIAL_USERPASS_PLAINTEXT; ctx->parent.connection_affinity = 1; - ctx->parent.set_challenge = ntlm_set_challenge; - ctx->parent.next_token = ntlm_next_token; - ctx->parent.is_complete = ntlm_is_complete; - ctx->parent.free = ntlm_context_free; + ctx->parent.set_challenge = ntlmclient_set_challenge; + ctx->parent.next_token = ntlmclient_next_token; + ctx->parent.is_complete = ntlmclient_is_complete; + ctx->parent.free = ntlmclient_context_free; *out = (git_http_auth_context *)ctx; From 0d7f3f52918a00a2a07ba965eb65c6ac5d122867 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 11 Mar 2023 04:45:19 -0800 Subject: [PATCH 195/608] utf8: add conversion with size and refactor names Add functions to use convert a string with length, instead of assuming NUL termination. In addition, move the utf8 to 16 conversion routines into the `git_utf8` namespace instead of using namespaceless `git__` prefixed names. --- src/libgit2/streams/schannel.c | 2 +- src/libgit2/transports/winhttp.c | 24 ++--- src/util/fs_path.c | 2 +- src/util/util.c | 2 +- src/util/win32/error.c | 2 +- src/util/win32/path_w32.c | 16 ++-- src/util/win32/posix_w32.c | 2 +- src/util/win32/utf-conv.c | 148 +++++++++++++++---------------- src/util/win32/utf-conv.h | 95 +++++++++++++++++--- src/util/win32/w32_util.c | 2 +- tests/clar/clar_libgit2.c | 4 +- tests/util/link.c | 6 +- 12 files changed, 185 insertions(+), 120 deletions(-) diff --git a/src/libgit2/streams/schannel.c b/src/libgit2/streams/schannel.c index 2c1066adb7d..f096158193c 100644 --- a/src/libgit2/streams/schannel.c +++ b/src/libgit2/streams/schannel.c @@ -661,7 +661,7 @@ static int schannel_stream_wrap( st->io = in; st->owned = owned; - if (git__utf8_to_16_alloc(&st->host_w, host) < 0) { + if (git_utf8_to_16_alloc(&st->host_w, host) < 0) { git__free(st); return -1; } diff --git a/src/libgit2/transports/winhttp.c b/src/libgit2/transports/winhttp.c index 09822760799..de24a2a41c1 100644 --- a/src/libgit2/transports/winhttp.c +++ b/src/libgit2/transports/winhttp.c @@ -158,10 +158,10 @@ static int apply_userpass_credentials(HINTERNET request, DWORD target, int mecha goto done; } - if ((error = user_len = git__utf8_to_16_alloc(&user, c->username)) < 0) + if ((error = user_len = git_utf8_to_16_alloc(&user, c->username)) < 0) goto done; - if ((error = pass_len = git__utf8_to_16_alloc(&pass, c->password)) < 0) + if ((error = pass_len = git_utf8_to_16_alloc(&pass, c->password)) < 0) goto done; if (!WinHttpSetCredentials(request, target, native_scheme, user, pass, NULL)) { @@ -242,7 +242,7 @@ static int acquire_fallback_cred( HRESULT hCoInitResult; /* Convert URL to wide characters */ - if (git__utf8_to_16_alloc(&wide_url, url) < 0) { + if (git_utf8_to_16_alloc(&wide_url, url) < 0) { git_error_set(GIT_ERROR_OS, "failed to convert string to wide form"); return -1; } @@ -397,7 +397,7 @@ static int winhttp_stream_connect(winhttp_stream *s) return -1; /* Convert URL to wide characters */ - if (git__utf8_to_16_alloc(&s->request_uri, git_str_cstr(&buf)) < 0) { + if (git_utf8_to_16_alloc(&s->request_uri, git_str_cstr(&buf)) < 0) { git_error_set(GIT_ERROR_OS, "failed to convert string to wide form"); goto on_error; } @@ -473,7 +473,7 @@ static int winhttp_stream_connect(winhttp_stream *s) } /* Convert URL to wide characters */ - error = git__utf8_to_16_alloc(&proxy_wide, processed_url.ptr); + error = git_utf8_to_16_alloc(&proxy_wide, processed_url.ptr); git_str_dispose(&processed_url); if (error < 0) goto on_error; @@ -531,7 +531,7 @@ static int winhttp_stream_connect(winhttp_stream *s) s->service) < 0) goto on_error; - if (git__utf8_to_16(ct, MAX_CONTENT_TYPE_LEN, git_str_cstr(&buf)) < 0) { + if (git_utf8_to_16(ct, MAX_CONTENT_TYPE_LEN, git_str_cstr(&buf)) < 0) { git_error_set(GIT_ERROR_OS, "failed to convert content-type to wide characters"); goto on_error; } @@ -548,7 +548,7 @@ static int winhttp_stream_connect(winhttp_stream *s) s->service) < 0) goto on_error; - if (git__utf8_to_16(ct, MAX_CONTENT_TYPE_LEN, git_str_cstr(&buf)) < 0) { + if (git_utf8_to_16(ct, MAX_CONTENT_TYPE_LEN, git_str_cstr(&buf)) < 0) { git_error_set(GIT_ERROR_OS, "failed to convert accept header to wide characters"); goto on_error; } @@ -568,7 +568,7 @@ static int winhttp_stream_connect(winhttp_stream *s) git_str_puts(&buf, t->owner->connect_opts.custom_headers.strings[i]); /* Convert header to wide characters */ - if ((error = git__utf8_to_16_alloc(&custom_header_wide, git_str_cstr(&buf))) < 0) + if ((error = git_utf8_to_16_alloc(&custom_header_wide, git_str_cstr(&buf))) < 0) goto on_error; if (!WinHttpAddRequestHeaders(s->request, custom_header_wide, (ULONG)-1L, @@ -783,7 +783,7 @@ static int winhttp_connect( } /* Prepare host */ - if (git__utf8_to_16_alloc(&wide_host, host) < 0) { + if (git_utf8_to_16_alloc(&wide_host, host) < 0) { git_error_set(GIT_ERROR_OS, "unable to convert host to wide characters"); goto on_error; } @@ -792,7 +792,7 @@ static int winhttp_connect( if (git_http__user_agent(&ua) < 0) goto on_error; - if (git__utf8_to_16_alloc(&wide_ua, git_str_cstr(&ua)) < 0) { + if (git_utf8_to_16_alloc(&wide_ua, git_str_cstr(&ua)) < 0) { git_error_set(GIT_ERROR_OS, "unable to convert host to wide characters"); goto on_error; } @@ -1182,7 +1182,7 @@ static int winhttp_stream_read( } /* Convert the Location header to UTF-8 */ - if (git__utf16_to_8_alloc(&location8, location) < 0) { + if (git_utf8_from_16_alloc(&location8, location) < 0) { git_error_set(GIT_ERROR_OS, "failed to convert Location header to UTF-8"); git__free(location); return -1; @@ -1254,7 +1254,7 @@ static int winhttp_stream_read( else p_snprintf(expected_content_type_8, MAX_CONTENT_TYPE_LEN, "application/x-git-%s-advertisement", s->service); - if (git__utf8_to_16(expected_content_type, MAX_CONTENT_TYPE_LEN, expected_content_type_8) < 0) { + if (git_utf8_to_16(expected_content_type, MAX_CONTENT_TYPE_LEN, expected_content_type_8) < 0) { git_error_set(GIT_ERROR_OS, "failed to convert expected content-type to wide characters"); return -1; } diff --git a/src/util/fs_path.c b/src/util/fs_path.c index b52867e779f..e03fcf7c760 100644 --- a/src/util/fs_path.c +++ b/src/util/fs_path.c @@ -2015,7 +2015,7 @@ int git_fs_path_find_executable(git_str *fullpath, const char *executable) git_win32_path fullpath_w, executable_w; int error; - if (git__utf8_to_16(executable_w, GIT_WIN_PATH_MAX, executable) < 0) + if (git_utf8_to_16(executable_w, GIT_WIN_PATH_MAX, executable) < 0) return -1; error = git_win32_path_find_executable(fullpath_w, executable_w); diff --git a/src/util/util.c b/src/util/util.c index aee95fddfb5..9c9f2c0403a 100644 --- a/src/util/util.c +++ b/src/util/util.c @@ -743,7 +743,7 @@ int git__getenv(git_str *out, const char *name) git_str_clear(out); - if (git__utf8_to_16_alloc(&wide_name, name) < 0) + if (git_utf8_to_16_alloc(&wide_name, name) < 0) return -1; if ((value_len = GetEnvironmentVariableW(wide_name, NULL, 0)) > 0) { diff --git a/src/util/win32/error.c b/src/util/win32/error.c index 3a52fb5a90a..dfd6fa1e8a1 100644 --- a/src/util/win32/error.c +++ b/src/util/win32/error.c @@ -43,7 +43,7 @@ char *git_win32_get_error_message(DWORD error_code) (LPWSTR)&lpMsgBuf, 0, NULL)) { /* Convert the message to UTF-8. If this fails, we will * return NULL, which is a condition expected by the caller */ - if (git__utf16_to_8_alloc(&utf8_msg, lpMsgBuf) < 0) + if (git_utf8_from_16_alloc(&utf8_msg, lpMsgBuf) < 0) utf8_msg = NULL; LocalFree(lpMsgBuf); diff --git a/src/util/win32/path_w32.c b/src/util/win32/path_w32.c index d9fc8292b0c..7a559e45c58 100644 --- a/src/util/win32/path_w32.c +++ b/src/util/win32/path_w32.c @@ -336,13 +336,13 @@ int git_win32_path_from_utf8(git_win32_path out, const char *src) /* See if this is an absolute path (beginning with a drive letter) */ if (git_fs_path_is_absolute(src)) { - if (git__utf8_to_16(dest, GIT_WIN_PATH_MAX, src) < 0) + if (git_utf8_to_16(dest, GIT_WIN_PATH_MAX, src) < 0) goto on_error; } /* File-prefixed NT-style paths beginning with \\?\ */ else if (path__is_nt_namespace(src)) { /* Skip the NT prefix, the destination already contains it */ - if (git__utf8_to_16(dest, GIT_WIN_PATH_MAX, src + PATH__NT_NAMESPACE_LEN) < 0) + if (git_utf8_to_16(dest, GIT_WIN_PATH_MAX, src + PATH__NT_NAMESPACE_LEN) < 0) goto on_error; } /* UNC paths */ @@ -351,7 +351,7 @@ int git_win32_path_from_utf8(git_win32_path out, const char *src) dest += 4; /* Skip the leading "\\" */ - if (git__utf8_to_16(dest, GIT_WIN_PATH_MAX - 2, src + 2) < 0) + if (git_utf8_to_16(dest, GIT_WIN_PATH_MAX - 2, src + 2) < 0) goto on_error; } /* Absolute paths omitting the drive letter */ @@ -365,7 +365,7 @@ int git_win32_path_from_utf8(git_win32_path out, const char *src) } /* Skip the drive letter specification ("C:") */ - if (git__utf8_to_16(dest + 2, GIT_WIN_PATH_MAX - 2, src) < 0) + if (git_utf8_to_16(dest + 2, GIT_WIN_PATH_MAX - 2, src) < 0) goto on_error; } /* Relative paths */ @@ -377,7 +377,7 @@ int git_win32_path_from_utf8(git_win32_path out, const char *src) dest[cwd_len++] = L'\\'; - if (git__utf8_to_16(dest + cwd_len, GIT_WIN_PATH_MAX - cwd_len, src) < 0) + if (git_utf8_to_16(dest + cwd_len, GIT_WIN_PATH_MAX - cwd_len, src) < 0) goto on_error; } @@ -404,7 +404,7 @@ int git_win32_path_relative_from_utf8(git_win32_path out, const char *src) return git_win32_path_from_utf8(out, src); } - if ((len = git__utf8_to_16(dest, GIT_WIN_PATH_MAX, src)) < 0) + if ((len = git_utf8_to_16(dest, GIT_WIN_PATH_MAX, src)) < 0) return -1; for (p = dest; p < (dest + len); p++) { @@ -433,7 +433,7 @@ int git_win32_path_to_utf8(git_win32_utf8_path dest, const wchar_t *src) } } - if ((len = git__utf16_to_8(out, GIT_WIN_PATH_UTF8, src)) < 0) + if ((len = git_utf8_from_16(out, GIT_WIN_PATH_UTF8, src)) < 0) return len; git_fs_path_mkposix(dest); @@ -471,7 +471,7 @@ char *git_win32_path_8dot3_name(const char *path) if (namelen > 12 || (shortname = git__malloc(namelen + 1)) == NULL) return NULL; - if ((len = git__utf16_to_8(shortname, namelen + 1, start)) < 0) + if ((len = git_utf8_from_16(shortname, namelen + 1, start)) < 0) return NULL; return shortname; diff --git a/src/util/win32/posix_w32.c b/src/util/win32/posix_w32.c index 5862e5c9ad6..3fec469a648 100644 --- a/src/util/win32/posix_w32.c +++ b/src/util/win32/posix_w32.c @@ -649,7 +649,7 @@ int p_getcwd(char *buffer_out, size_t size) git_win32_path_remove_namespace(cwd, wcslen(cwd)); /* Convert the working directory back to UTF-8 */ - if (git__utf16_to_8(buffer_out, size, cwd) < 0) { + if (git_utf8_from_16(buffer_out, size, cwd) < 0) { DWORD code = GetLastError(); if (code == ERROR_INSUFFICIENT_BUFFER) diff --git a/src/util/win32/utf-conv.c b/src/util/win32/utf-conv.c index 4bde3023ab6..ad35c0c35ff 100644 --- a/src/util/win32/utf-conv.c +++ b/src/util/win32/utf-conv.c @@ -15,108 +15,114 @@ GIT_INLINE(void) git__set_errno(void) errno = EINVAL; } -/** - * Converts a UTF-8 string to wide characters. - * - * @param dest The buffer to receive the wide string. - * @param dest_size The size of the buffer, in characters. - * @param src The UTF-8 string to convert. - * @return The length of the wide string, in characters (not counting the NULL terminator), or < 0 for failure - */ -int git__utf8_to_16(wchar_t *dest, size_t dest_size, const char *src) +int git_utf8_to_16(wchar_t *dest, size_t dest_size, const char *src) +{ + /* Length of -1 indicates NULL termination of the input string. */ + return git_utf8_to_16_with_len(dest, dest_size, src, -1); +} + +int git_utf8_to_16_with_len( + wchar_t *dest, + size_t _dest_size, + const char *src, + int src_len) { + int dest_size = (int)min(_dest_size, INT_MAX); int len; - /* Length of -1 indicates NULL termination of the input string. Subtract 1 from the result to - * turn 0 into -1 (an error code) and to not count the NULL terminator as part of the string's - * length. MultiByteToWideChar never returns int's minvalue, so underflow is not possible */ - if ((len = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, src, -1, dest, (int)dest_size) - 1) < 0) + /* + * Subtract 1 from the result to turn 0 into -1 (an error code) and + * to not count the NULL terminator as part of the string's length. + * MultiByteToWideChar never returns int's minvalue, so underflow + * is not possible. + */ + len = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, + src, src_len, dest, dest_size) - 1; + + if (len < 0) git__set_errno(); return len; } -/** - * Converts a wide string to UTF-8. - * - * @param dest The buffer to receive the UTF-8 string. - * @param dest_size The size of the buffer, in bytes. - * @param src The wide string to convert. - * @return The length of the UTF-8 string, in bytes (not counting the NULL terminator), or < 0 for failure - */ -int git__utf16_to_8(char *dest, size_t dest_size, const wchar_t *src) +int git_utf8_from_16(char *dest, size_t dest_size, const wchar_t *src) { + /* Length of -1 indicates NULL termination of the input string. */ + return git_utf8_from_16_with_len(dest, dest_size, src, -1); +} + +int git_utf8_from_16_with_len( + char *dest, + size_t _dest_size, + const wchar_t *src, + int src_len) +{ + int dest_size = (int)min(_dest_size, INT_MAX); int len; - /* Length of -1 indicates NULL termination of the input string. Subtract 1 from the result to - * turn 0 into -1 (an error code) and to not count the NULL terminator as part of the string's - * length. WideCharToMultiByte never returns int's minvalue, so underflow is not possible */ - if ((len = WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, src, -1, dest, (int)dest_size, NULL, NULL) - 1) < 0) + /* + * Subtract 1 from the result to turn 0 into -1 (an error code) and + * to not count the NULL terminator as part of the string's length. + * WideCharToMultiByte never returns int's minvalue, so underflow + * is not possible. + */ + len = WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, + src, src_len, dest, dest_size, NULL, NULL) - 1; + + if (len < 0) git__set_errno(); return len; } -/** - * Converts a UTF-8 string to wide characters. - * Memory is allocated to hold the converted string. - * The caller is responsible for freeing the string with git__free. - * - * @param dest Receives a pointer to the wide string. - * @param src The UTF-8 string to convert. - * @return The length of the wide string, in characters (not counting the NULL terminator), or < 0 for failure - */ -int git__utf8_to_16_alloc(wchar_t **dest, const char *src) +int git_utf8_to_16_alloc(wchar_t **dest, const char *src) +{ + /* Length of -1 indicates NULL termination of the input string. */ + return git_utf8_to_16_alloc_with_len(dest, src, -1); +} + +int git_utf8_to_16_alloc_with_len(wchar_t **dest, const char *src, int src_len) { int utf16_size; *dest = NULL; - /* Length of -1 indicates NULL termination of the input string */ - utf16_size = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, src, -1, NULL, 0); + utf16_size = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, + src, src_len, NULL, 0); if (!utf16_size) { git__set_errno(); return -1; } - if (!(*dest = git__mallocarray(utf16_size, sizeof(wchar_t)))) { - errno = ENOMEM; - return -1; - } + *dest = git__mallocarray(utf16_size, sizeof(wchar_t)); + GIT_ERROR_CHECK_ALLOC(*dest); - utf16_size = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, src, -1, *dest, utf16_size); - - if (!utf16_size) { - git__set_errno(); + utf16_size = git_utf8_to_16_with_len(*dest, (size_t)utf16_size, + src, src_len); + if (utf16_size < 0) { git__free(*dest); *dest = NULL; } - /* Subtract 1 from the result to turn 0 into -1 (an error code) and to not count the NULL - * terminator as part of the string's length. MultiByteToWideChar never returns int's minvalue, - * so underflow is not possible */ - return utf16_size - 1; + return utf16_size; } -/** - * Converts a wide string to UTF-8. - * Memory is allocated to hold the converted string. - * The caller is responsible for freeing the string with git__free. - * - * @param dest Receives a pointer to the UTF-8 string. - * @param src The wide string to convert. - * @return The length of the UTF-8 string, in bytes (not counting the NULL terminator), or < 0 for failure - */ -int git__utf16_to_8_alloc(char **dest, const wchar_t *src) +int git_utf8_from_16_alloc(char **dest, const wchar_t *src) +{ + /* Length of -1 indicates NULL termination of the input string. */ + return git_utf8_from_16_alloc_with_len(dest, src, -1); +} + +int git_utf8_from_16_alloc_with_len(char **dest, const wchar_t *src, int src_len) { int utf8_size; *dest = NULL; - /* Length of -1 indicates NULL termination of the input string */ - utf8_size = WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, src, -1, NULL, 0, NULL, NULL); + utf8_size = WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, + src, src_len, NULL, 0, NULL, NULL); if (!utf8_size) { git__set_errno(); @@ -124,23 +130,15 @@ int git__utf16_to_8_alloc(char **dest, const wchar_t *src) } *dest = git__malloc(utf8_size); + GIT_ERROR_CHECK_ALLOC(*dest); - if (!*dest) { - errno = ENOMEM; - return -1; - } - - utf8_size = WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, src, -1, *dest, utf8_size, NULL, NULL); - - if (!utf8_size) { - git__set_errno(); + utf8_size = WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, + src, src_len, *dest, utf8_size, NULL, NULL); + if (utf8_size < 0) { git__free(*dest); *dest = NULL; } - /* Subtract 1 from the result to turn 0 into -1 (an error code) and to not count the NULL - * terminator as part of the string's length. MultiByteToWideChar never returns int's minvalue, - * so underflow is not possible */ - return utf8_size - 1; + return utf8_size; } diff --git a/src/util/win32/utf-conv.h b/src/util/win32/utf-conv.h index 120d647efdf..301f5a6d36c 100644 --- a/src/util/win32/utf-conv.h +++ b/src/util/win32/utf-conv.h @@ -15,15 +15,46 @@ # define WC_ERR_INVALID_CHARS 0x80 #endif +/** + * Converts a NUL-terminated UTF-8 string to wide characters. This is a + * convenience function for `git_utf8_to_16_with_len`. + * + * @param dest The buffer to receive the wide string. + * @param dest_size The size of the buffer, in characters. + * @param src The UTF-8 string to convert. + * @return The length of the wide string, in characters + * (not counting the NULL terminator), or < 0 for failure + */ +int git_utf8_to_16(wchar_t *dest, size_t dest_size, const char *src); + /** * Converts a UTF-8 string to wide characters. * * @param dest The buffer to receive the wide string. * @param dest_size The size of the buffer, in characters. * @param src The UTF-8 string to convert. - * @return The length of the wide string, in characters (not counting the NULL terminator), or < 0 for failure + * @param src_len The length of the string to convert. + * @return The length of the wide string, in characters + * (not counting the NULL terminator), or < 0 for failure + */ +int git_utf8_to_16_with_len( + wchar_t *dest, + size_t dest_size, + const char *src, + int src_len); + +/** + * Converts a NUL-terminated wide string to UTF-8. This is a convenience + * function for `git_utf8_from_16_with_len`. + * + * @param dest The buffer to receive the UTF-8 string. + * @param dest_size The size of the buffer, in bytes. + * @param src The wide string to convert. + * @param src_len The length of the string to convert. + * @return The length of the UTF-8 string, in bytes + * (not counting the NULL terminator), or < 0 for failure */ -int git__utf8_to_16(wchar_t *dest, size_t dest_size, const char *src); +int git_utf8_from_16(char *dest, size_t dest_size, const wchar_t *src); /** * Converts a wide string to UTF-8. @@ -31,30 +62,66 @@ int git__utf8_to_16(wchar_t *dest, size_t dest_size, const char *src); * @param dest The buffer to receive the UTF-8 string. * @param dest_size The size of the buffer, in bytes. * @param src The wide string to convert. - * @return The length of the UTF-8 string, in bytes (not counting the NULL terminator), or < 0 for failure + * @param src_len The length of the string to convert. + * @return The length of the UTF-8 string, in bytes + * (not counting the NULL terminator), or < 0 for failure */ -int git__utf16_to_8(char *dest, size_t dest_size, const wchar_t *src); +int git_utf8_from_16_with_len(char *dest, size_t dest_size, const wchar_t *src, int src_len); /** - * Converts a UTF-8 string to wide characters. - * Memory is allocated to hold the converted string. - * The caller is responsible for freeing the string with git__free. + * Converts a UTF-8 string to wide characters. Memory is allocated to hold + * the converted string. The caller is responsible for freeing the string + * with git__free. * * @param dest Receives a pointer to the wide string. * @param src The UTF-8 string to convert. - * @return The length of the wide string, in characters (not counting the NULL terminator), or < 0 for failure + * @return The length of the wide string, in characters + * (not counting the NULL terminator), or < 0 for failure */ -int git__utf8_to_16_alloc(wchar_t **dest, const char *src); +int git_utf8_to_16_alloc(wchar_t **dest, const char *src); /** - * Converts a wide string to UTF-8. - * Memory is allocated to hold the converted string. - * The caller is responsible for freeing the string with git__free. + * Converts a UTF-8 string to wide characters. Memory is allocated to hold + * the converted string. The caller is responsible for freeing the string + * with git__free. + * + * @param dest Receives a pointer to the wide string. + * @param src The UTF-8 string to convert. + * @param src_len The length of the string. + * @return The length of the wide string, in characters + * (not counting the NULL terminator), or < 0 for failure + */ +int git_utf8_to_16_alloc_with_len( + wchar_t **dest, + const char *src, + int src_len); + +/** + * Converts a wide string to UTF-8. Memory is allocated to hold the + * converted string. The caller is responsible for freeing the string + * with git__free. + * + * @param dest Receives a pointer to the UTF-8 string. + * @param src The wide string to convert. + * @return The length of the UTF-8 string, in bytes + * (not counting the NULL terminator), or < 0 for failure + */ +int git_utf8_from_16_alloc(char **dest, const wchar_t *src); + +/** + * Converts a wide string to UTF-8. Memory is allocated to hold the + * converted string. The caller is responsible for freeing the string + * with git__free. * * @param dest Receives a pointer to the UTF-8 string. * @param src The wide string to convert. - * @return The length of the UTF-8 string, in bytes (not counting the NULL terminator), or < 0 for failure + * @param src_len The length of the wide string. + * @return The length of the UTF-8 string, in bytes + * (not counting the NULL terminator), or < 0 for failure */ -int git__utf16_to_8_alloc(char **dest, const wchar_t *src); +int git_utf8_from_16_alloc_with_len( + char **dest, + const wchar_t *src, + int src_len); #endif diff --git a/src/util/win32/w32_util.c b/src/util/win32/w32_util.c index fe4b75baefd..f5b006a1974 100644 --- a/src/util/win32/w32_util.c +++ b/src/util/win32/w32_util.c @@ -115,7 +115,7 @@ int git_win32__file_attribute_to_stat( /* st_size gets the UTF-8 length of the target name, in bytes, * not counting the NULL terminator */ - if ((st->st_size = git__utf16_to_8(NULL, 0, target)) < 0) { + if ((st->st_size = git_utf8_from_16(NULL, 0, target)) < 0) { git_error_set(GIT_ERROR_OS, "could not convert reparse point name for '%ls'", path); return -1; } diff --git a/tests/clar/clar_libgit2.c b/tests/clar/clar_libgit2.c index 54122997df7..a1b92fc336e 100644 --- a/tests/clar/clar_libgit2.c +++ b/tests/clar/clar_libgit2.c @@ -103,10 +103,10 @@ int cl_setenv(const char *name, const char *value) { wchar_t *wide_name, *wide_value = NULL; - cl_assert(git__utf8_to_16_alloc(&wide_name, name) >= 0); + cl_assert(git_utf8_to_16_alloc(&wide_name, name) >= 0); if (value) { - cl_assert(git__utf8_to_16_alloc(&wide_value, value) >= 0); + cl_assert(git_utf8_to_16_alloc(&wide_value, value) >= 0); cl_assert(SetEnvironmentVariableW(wide_name, wide_value)); } else { /* Windows XP returns 0 (failed) when passing NULL for lpValue when diff --git a/tests/util/link.c b/tests/util/link.c index 46cafada7e9..5909e26e391 100644 --- a/tests/util/link.c +++ b/tests/util/link.c @@ -98,7 +98,7 @@ static void do_junction(const char *old, const char *new) git_str_putc(&unparsed_buf, '\\'); - subst_utf16_len = git__utf8_to_16(NULL, 0, git_str_cstr(&unparsed_buf)); + subst_utf16_len = git_utf8_to_16(NULL, 0, git_str_cstr(&unparsed_buf)); subst_byte_len = subst_utf16_len * sizeof(WCHAR); print_utf16_len = subst_utf16_len - 4; @@ -124,11 +124,11 @@ static void do_junction(const char *old, const char *new) subst_utf16 = reparse_buf->ReparseBuffer.MountPoint.PathBuffer; print_utf16 = subst_utf16 + subst_utf16_len + 1; - ret = git__utf8_to_16(subst_utf16, subst_utf16_len + 1, + ret = git_utf8_to_16(subst_utf16, subst_utf16_len + 1, git_str_cstr(&unparsed_buf)); cl_assert_equal_i(subst_utf16_len, ret); - ret = git__utf8_to_16(print_utf16, + ret = git_utf8_to_16(print_utf16, print_utf16_len + 1, git_str_cstr(&unparsed_buf) + 4); cl_assert_equal_i(print_utf16_len, ret); From f15c8ac71a916bf186cd5ff81f07ca85eef82afb Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 13 Mar 2023 07:08:46 -0700 Subject: [PATCH 196/608] http: add SSPI authentication on Windows Add support for SSPI on Windows, which offers NTLM and Negotiate authentication. --- cmake/SelectGSSAPI.cmake | 6 +- cmake/SelectHTTPSBackend.cmake | 4 +- src/libgit2/transports/auth_negotiate.h | 2 +- src/libgit2/transports/auth_ntlm.h | 6 +- src/libgit2/transports/auth_sspi.c | 341 ++++++++++++++++++++++++ 5 files changed, 350 insertions(+), 9 deletions(-) create mode 100644 src/libgit2/transports/auth_sspi.c diff --git a/cmake/SelectGSSAPI.cmake b/cmake/SelectGSSAPI.cmake index 24e2d68b9a7..5bde11697df 100644 --- a/cmake/SelectGSSAPI.cmake +++ b/cmake/SelectGSSAPI.cmake @@ -29,7 +29,7 @@ if(USE_GSSAPI) list(APPEND LIBGIT2_SYSTEM_LIBS ${GSSFRAMEWORK_LIBRARIES}) set(GIT_GSSFRAMEWORK 1) - add_feature_info(SPNEGO GIT_GSSFRAMEWORK "SPNEGO authentication support (${USE_GSSAPI})") + add_feature_info(GSSAPI GIT_GSSFRAMEWORK "GSSAPI support for SPNEGO authentication (${USE_GSSAPI})") elseif(USE_GSSAPI STREQUAL "gssapi") if(NOT GSSAPI_FOUND) message(FATAL_ERROR "Asked for gssapi GSS backend, but it wasn't found") @@ -38,11 +38,11 @@ if(USE_GSSAPI) list(APPEND LIBGIT2_SYSTEM_LIBS ${GSSAPI_LIBRARIES}) set(GIT_GSSAPI 1) - add_feature_info(SPNEGO GIT_GSSAPI "SPNEGO authentication support (${USE_GSSAPI})") + add_feature_info(GSSAPI GIT_GSSAPI "GSSAPI support for SPNEGO authentication (${USE_GSSAPI})") else() message(FATAL_ERROR "Asked for backend ${USE_GSSAPI} but it wasn't found") endif() else() set(GIT_GSSAPI 0) - add_feature_info(SPNEGO NO "SPNEGO authentication support") + add_feature_info(GSSAPI NO "GSSAPI support for SPNEGO authentication") endif() diff --git a/cmake/SelectHTTPSBackend.cmake b/cmake/SelectHTTPSBackend.cmake index 64c7a1097ce..d14941643dc 100644 --- a/cmake/SelectHTTPSBackend.cmake +++ b/cmake/SelectHTTPSBackend.cmake @@ -125,8 +125,8 @@ if(USE_HTTPS) list(APPEND LIBGIT2_PC_LIBS "-lwinhttp") endif() - list(APPEND LIBGIT2_SYSTEM_LIBS "rpcrt4" "crypt32" "ole32") - list(APPEND LIBGIT2_PC_LIBS "-lrpcrt4" "-lcrypt32" "-lole32") + list(APPEND LIBGIT2_SYSTEM_LIBS "rpcrt4" "crypt32" "ole32" "secur32") + list(APPEND LIBGIT2_PC_LIBS "-lrpcrt4" "-lcrypt32" "-lole32" "-lsecur32") elseif(USE_HTTPS STREQUAL "OpenSSL-Dynamic") set(GIT_OPENSSL 1) set(GIT_OPENSSL_DYNAMIC 1) diff --git a/src/libgit2/transports/auth_negotiate.h b/src/libgit2/transports/auth_negotiate.h index 34aff295b13..4360785c555 100644 --- a/src/libgit2/transports/auth_negotiate.h +++ b/src/libgit2/transports/auth_negotiate.h @@ -12,7 +12,7 @@ #include "git2.h" #include "auth.h" -#if defined(GIT_GSSAPI) || defined(GIT_GSSFRAMEWORK) +#if defined(GIT_GSSAPI) || defined(GIT_GSSFRAMEWORK) || defined(GIT_WIN32) extern int git_http_auth_negotiate( git_http_auth_context **out, diff --git a/src/libgit2/transports/auth_ntlm.h b/src/libgit2/transports/auth_ntlm.h index 2bf8f41f619..33406ae94c3 100644 --- a/src/libgit2/transports/auth_ntlm.h +++ b/src/libgit2/transports/auth_ntlm.h @@ -5,15 +5,15 @@ * a Linking Exception. For full terms see the included COPYING file. */ -#ifndef INCLUDE_transports_auth_ntlmclient_h__ -#define INCLUDE_transports_auth_ntlmclient_h__ +#ifndef INCLUDE_transports_auth_ntlm_h__ +#define INCLUDE_transports_auth_ntlm_h__ #include "auth.h" /* NTLM requires a full request/challenge/response */ #define GIT_AUTH_STEPS_NTLM 2 -#ifdef GIT_NTLM +#if defined(GIT_NTLM) || defined(GIT_WIN32) #if defined(GIT_OPENSSL) # define CRYPT_OPENSSL diff --git a/src/libgit2/transports/auth_sspi.c b/src/libgit2/transports/auth_sspi.c new file mode 100644 index 00000000000..f8269365d7f --- /dev/null +++ b/src/libgit2/transports/auth_sspi.c @@ -0,0 +1,341 @@ +/* + * Copyright (C) the libgit2 contributors. All rights reserved. + * + * This file is part of libgit2, distributed under the GNU GPL v2 with + * a Linking Exception. For full terms see the included COPYING file. + */ + +#include "auth_ntlm.h" +#include "auth_negotiate.h" + +#ifdef GIT_WIN32 + +#define SECURITY_WIN32 + +#include "git2.h" +#include "auth.h" +#include "git2/sys/credential.h" + +#include +#include + +typedef struct { + git_http_auth_context parent; + wchar_t *target; + + const char *package_name; + size_t package_name_len; + wchar_t *package_name_w; + SecPkgInfoW *package_info; + SEC_WINNT_AUTH_IDENTITY_W identity; + CredHandle cred; + CtxtHandle context; + + int has_identity : 1, + has_credentials : 1, + has_context : 1, + complete : 1; + git_str challenge; +} http_auth_sspi_context; + +static void sspi_reset_context(http_auth_sspi_context *ctx) +{ + if (ctx->has_identity) { + git__free(ctx->identity.User); + git__free(ctx->identity.Domain); + git__free(ctx->identity.Password); + + memset(&ctx->identity, 0, sizeof(SEC_WINNT_AUTH_IDENTITY_W)); + + ctx->has_identity = 0; + } + + if (ctx->has_credentials) { + FreeCredentialsHandle(&ctx->cred); + memset(&ctx->cred, 0, sizeof(CredHandle)); + + ctx->has_credentials = 0; + } + + if (ctx->has_context) { + DeleteSecurityContext(&ctx->context); + memset(&ctx->context, 0, sizeof(CtxtHandle)); + + ctx->has_context = 0; + } + + ctx->complete = 0; + + git_str_dispose(&ctx->challenge); +} + +static int sspi_set_challenge( + git_http_auth_context *c, + const char *challenge) +{ + http_auth_sspi_context *ctx = (http_auth_sspi_context *)c; + size_t challenge_len = strlen(challenge); + + git_str_clear(&ctx->challenge); + + if (strncmp(challenge, ctx->package_name, ctx->package_name_len) != 0) { + git_error_set(GIT_ERROR_NET, "invalid %s challenge from server", ctx->package_name); + return -1; + } + + /* + * A package type indicator without a base64 payload indicates the + * mechanism; it's not an actual challenge. Ignore it. + */ + if (challenge[ctx->package_name_len] == 0) { + return 0; + } else if (challenge[ctx->package_name_len] != ' ') { + git_error_set(GIT_ERROR_NET, "invalid %s challenge from server", ctx->package_name); + return -1; + } + + if (git_str_decode_base64(&ctx->challenge, + challenge + (ctx->package_name_len + 1), + challenge_len - (ctx->package_name_len + 1)) < 0) { + git_error_set(GIT_ERROR_NET, "invalid %s challenge from server", ctx->package_name); + return -1; + } + + GIT_ASSERT(ctx->challenge.size <= ULONG_MAX); + return 0; +} + +static int create_identity( + SEC_WINNT_AUTH_IDENTITY_W **out, + http_auth_sspi_context *ctx, + git_credential *cred) +{ + git_credential_userpass_plaintext *userpass; + wchar_t *username = NULL, *domain = NULL, *password = NULL; + int username_len = 0, domain_len = 0, password_len = 0; + const char *sep; + + if (cred->credtype == GIT_CREDENTIAL_DEFAULT) { + *out = NULL; + return 0; + } + + if (cred->credtype != GIT_CREDENTIAL_USERPASS_PLAINTEXT) { + git_error_set(GIT_ERROR_NET, "unknown credential type: %d", cred->credtype); + return -1; + } + + userpass = (git_credential_userpass_plaintext *)cred; + + if ((sep = strchr(userpass->username, '\\')) != NULL) { + GIT_ASSERT(sep - userpass->username < INT_MAX); + + username_len = git_utf8_to_16_alloc(&username, sep + 1); + domain_len = git_utf8_to_16_alloc_with_len(&domain, + userpass->username, (int)(sep - userpass->username)); + } else { + username_len = git_utf8_to_16_alloc(&username, + userpass->username); + } + + password_len = git_utf8_to_16_alloc(&password, userpass->password); + + if (username_len < 0 || domain_len < 0 || password_len < 0) { + git__free(username); + git__free(domain); + git__free(password); + return -1; + } + + ctx->identity.Flags = SEC_WINNT_AUTH_IDENTITY_UNICODE; + ctx->identity.User = username; + ctx->identity.UserLength = (unsigned long)username_len; + ctx->identity.Password = password; + ctx->identity.PasswordLength = (unsigned long)password_len; + ctx->identity.Domain = domain; + ctx->identity.DomainLength = (unsigned long)domain_len; + + ctx->has_identity = 1; + + *out = &ctx->identity; + + return 0; +} + +static int sspi_next_token( + git_str *buf, + git_http_auth_context *c, + git_credential *cred) +{ + http_auth_sspi_context *ctx = (http_auth_sspi_context *)c; + SEC_WINNT_AUTH_IDENTITY_W *identity = NULL; + TimeStamp timestamp; + DWORD context_flags; + SecBuffer input_buf = { 0, SECBUFFER_TOKEN, NULL }; + SecBuffer output_buf = { 0, SECBUFFER_TOKEN, NULL }; + SecBufferDesc input_buf_desc = { SECBUFFER_VERSION, 1, &input_buf }; + SecBufferDesc output_buf_desc = { SECBUFFER_VERSION, 1, &output_buf }; + SECURITY_STATUS status; + + if (ctx->complete) + sspi_reset_context(ctx); + + if (!ctx->has_context) { + if (create_identity(&identity, ctx, cred) < 0) + return -1; + + status = AcquireCredentialsHandleW(NULL, ctx->package_name_w, + SECPKG_CRED_BOTH, NULL, identity, NULL, + NULL, &ctx->cred, ×tamp); + + if (status != SEC_E_OK) { + git_error_set(GIT_ERROR_OS, "could not acquire credentials"); + return -1; + } + + ctx->has_credentials = 1; + } + + context_flags = ISC_REQ_ALLOCATE_MEMORY | + ISC_REQ_CONFIDENTIALITY | + ISC_REQ_MUTUAL_AUTH; + + if (ctx->challenge.size > 0) { + input_buf.BufferType = SECBUFFER_TOKEN; + input_buf.cbBuffer = (unsigned long)ctx->challenge.size; + input_buf.pvBuffer = ctx->challenge.ptr; + } + + status = InitializeSecurityContextW(&ctx->cred, + ctx->has_context ? &ctx->context : NULL, + ctx->target, + context_flags, + 0, + SECURITY_NETWORK_DREP, + ctx->has_context ? &input_buf_desc : NULL, + 0, + ctx->has_context ? NULL : &ctx->context, + &output_buf_desc, + &context_flags, + NULL); + + if (status == SEC_I_COMPLETE_AND_CONTINUE || + status == SEC_I_COMPLETE_NEEDED) + status = CompleteAuthToken(&ctx->context, &output_buf_desc); + + if (status == SEC_E_OK) { + ctx->complete = 1; + } else if (status != SEC_I_CONTINUE_NEEDED) { + git_error_set(GIT_ERROR_OS, "could not initialize security context"); + return -1; + } + + ctx->has_context = 1; + git_str_clear(&ctx->challenge); + + if (output_buf.cbBuffer > 0) { + git_str_put(buf, ctx->package_name, ctx->package_name_len); + git_str_putc(buf, ' '); + git_str_encode_base64(buf, output_buf.pvBuffer, output_buf.cbBuffer); + + FreeContextBuffer(output_buf.pvBuffer); + + if (git_str_oom(buf)) + return -1; + } + + return 0; +} + +static int sspi_is_complete(git_http_auth_context *c) +{ + http_auth_sspi_context *ctx = (http_auth_sspi_context *)c; + + return ctx->complete; +} + +static void sspi_context_free(git_http_auth_context *c) +{ + http_auth_sspi_context *ctx = (http_auth_sspi_context *)c; + + sspi_reset_context(ctx); + + FreeContextBuffer(ctx->package_info); + git__free(ctx->target); + git__free(ctx); +} + +static int sspi_init_context( + git_http_auth_context **out, + git_http_auth_t type, + const git_net_url *url) +{ + http_auth_sspi_context *ctx; + git_str target = GIT_STR_INIT; + + *out = NULL; + + ctx = git__calloc(1, sizeof(http_auth_sspi_context)); + GIT_ERROR_CHECK_ALLOC(ctx); + + switch (type) { + case GIT_HTTP_AUTH_NTLM: + ctx->package_name = "NTLM"; + ctx->package_name_len = CONST_STRLEN("NTLM"); + ctx->package_name_w = L"NTLM"; + ctx->parent.credtypes = GIT_CREDENTIAL_USERPASS_PLAINTEXT | + GIT_CREDENTIAL_DEFAULT; + break; + case GIT_HTTP_AUTH_NEGOTIATE: + ctx->package_name = "Negotiate"; + ctx->package_name_len = CONST_STRLEN("Negotiate"); + ctx->package_name_w = L"Negotiate"; + ctx->parent.credtypes = GIT_CREDENTIAL_DEFAULT; + break; + default: + git_error_set(GIT_ERROR_NET, "unknown SSPI auth type: %d", ctx->parent.type); + git__free(ctx); + return -1; + } + + if (QuerySecurityPackageInfoW(ctx->package_name_w, &ctx->package_info) != SEC_E_OK) { + git_error_set(GIT_ERROR_OS, "could not query security package"); + git__free(ctx); + return -1; + } + + if (git_str_printf(&target, "http/%s", url->host) < 0 || + git_utf8_to_16_alloc(&ctx->target, target.ptr) < 0) { + FreeContextBuffer(ctx->package_info); + git__free(ctx); + return -1; + } + + ctx->parent.type = type; + ctx->parent.connection_affinity = 1; + ctx->parent.set_challenge = sspi_set_challenge; + ctx->parent.next_token = sspi_next_token; + ctx->parent.is_complete = sspi_is_complete; + ctx->parent.free = sspi_context_free; + + *out = (git_http_auth_context *)ctx; + + git_str_dispose(&target); + return 0; +} + +int git_http_auth_negotiate( + git_http_auth_context **out, + const git_net_url *url) +{ + return sspi_init_context(out, GIT_HTTP_AUTH_NEGOTIATE, url); +} + +int git_http_auth_ntlm( + git_http_auth_context **out, + const git_net_url *url) +{ + return sspi_init_context(out, GIT_HTTP_AUTH_NTLM, url); +} + +#endif /* GIT_WIN32 */ From 2173ca8a4196c762fa34474b583ba6e9f25e67ff Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Tue, 21 Mar 2023 10:13:23 +0000 Subject: [PATCH 197/608] v1.6.3: update version numbers --- CMakeLists.txt | 2 +- include/git2/version.h | 4 ++-- package.json | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 710915da1bd..94627f54dd5 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -6,7 +6,7 @@ cmake_minimum_required(VERSION 3.5.1) -project(libgit2 VERSION "1.6.2" LANGUAGES C) +project(libgit2 VERSION "1.6.3" LANGUAGES C) # Add find modules to the path set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${PROJECT_SOURCE_DIR}/cmake") diff --git a/include/git2/version.h b/include/git2/version.h index 8b5eb31386f..78750740aca 100644 --- a/include/git2/version.h +++ b/include/git2/version.h @@ -11,7 +11,7 @@ * The version string for libgit2. This string follows semantic * versioning (v2) guidelines. */ -#define LIBGIT2_VERSION "1.6.2" +#define LIBGIT2_VERSION "1.6.3" /** The major version number for this version of libgit2. */ #define LIBGIT2_VER_MAJOR 1 @@ -20,7 +20,7 @@ #define LIBGIT2_VER_MINOR 6 /** The revision ("teeny") version number for this version of libgit2. */ -#define LIBGIT2_VER_REVISION 2 +#define LIBGIT2_VER_REVISION 3 /** The Windows DLL patch number for this version of libgit2. */ #define LIBGIT2_VER_PATCH 0 diff --git a/package.json b/package.json index e29459efddd..5665b4edd02 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "libgit2", - "version": "1.6.2", + "version": "1.6.3", "repo": "https://github.com/libgit2/libgit2", "description": " A cross-platform, linkable library implementation of Git that you can use in your application.", "install": "mkdir build && cd build && cmake .. && cmake --build ." From a1826a8b1ba36027caaa03eb4d29474bd4420fef Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Tue, 21 Mar 2023 10:15:25 +0000 Subject: [PATCH 198/608] v1.6.3: update changelog --- docs/changelog.md | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/docs/changelog.md b/docs/changelog.md index f685234aaee..20e48a084de 100644 --- a/docs/changelog.md +++ b/docs/changelog.md @@ -1,3 +1,26 @@ +v1.6.3 +------ + +## What's Changed + +### Bug fixes + +* odb: restore `git_odb_open` by @ethomson in https://github.com/libgit2/libgit2/pull/6520 +* Ensure that `git_index_add_all` handles ignored directories by @ethomson in https://github.com/libgit2/libgit2/pull/6521 +* pack: use 64 bits for the number of objects by @carlosmn in https://github.com/libgit2/libgit2/pull/6530 + +### Build and CI improvements + +* Remove unused wditer variable by @georgthegreat in https://github.com/libgit2/libgit2/pull/6518 +* fs_path: let root run the ownership tests by @ethomson in https://github.com/libgit2/libgit2/pull/6513 +* sysdir: Do not declare win32 functions on non-win32 platforms by @Batchyx in https://github.com/libgit2/libgit2/pull/6527 +* cmake: don't include `include/git2` by @ethomson in https://github.com/libgit2/libgit2/pull/6529 + +## New Contributors +* @georgthegreat made their first contribution in https://github.com/libgit2/libgit2/pull/6518 + +**Full Changelog**: https://github.com/libgit2/libgit2/compare/v1.6.2...v1.6.3 + v1.6.2 ------ From 4edf6c114118232da86d4de1543222b12ca960ae Mon Sep 17 00:00:00 2001 From: Miguel Arroz <750683+arroz@users.noreply.github.com> Date: Mon, 27 Mar 2023 11:07:57 -0700 Subject: [PATCH 199/608] Partial fix for #6532: insert-by-date order. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This commit fixes the following issues: 1. In `git_revwalk__push_commit`, if `opts->insert_by_date` is true, `git_commit_list_insert_by_date` is called. However, by this point the commit wasn’t parsed yet, so the `time` field still has 0 as value. Solved by parsing the commit immediately if `opts->insert_by_date` is true. 2. In the same function, there was an error in the boolean logic. When `opts->insert_by_date` was true, the commit would be inserted twice, first “by date” (not really, due to the issue described above) and then in the first position again. Logic was corrected. 3. In `prepare_walk`, when processing `user_input` and building the `commits` list, the order was being inverted. Assuming both fixes above, this would mean we would start negotiation by the oldest reference, not the newest one. This was fixed by producing a `commits` list in the same order as `user_input`. The output list for the list of “have” statements during the negotiation is still not the same as core git’s because there is an optimization missing (excluding ancestors of commits known to be common between the client and the server) but this commit brings it much closer to core git’s. Specifically, the example on the #6532 issue description now fetches exactly the same objects than core git, and other examples I tested as well. --- src/libgit2/commit_list.c | 11 ++++++++--- src/libgit2/commit_list.h | 1 + src/libgit2/revwalk.c | 30 ++++++++++++++++++++++++++---- 3 files changed, 35 insertions(+), 7 deletions(-) diff --git a/src/libgit2/commit_list.c b/src/libgit2/commit_list.c index 12b329b251e..2e28d5caf8a 100644 --- a/src/libgit2/commit_list.c +++ b/src/libgit2/commit_list.c @@ -43,13 +43,18 @@ int git_commit_list_time_cmp(const void *a, const void *b) return 0; } -git_commit_list *git_commit_list_insert(git_commit_list_node *item, git_commit_list **list_p) -{ +git_commit_list *git_commit_list_create(git_commit_list_node *item, git_commit_list *next) { git_commit_list *new_list = git__malloc(sizeof(git_commit_list)); if (new_list != NULL) { new_list->item = item; - new_list->next = *list_p; + new_list->next = next; } + return new_list; +} + +git_commit_list *git_commit_list_insert(git_commit_list_node *item, git_commit_list **list_p) +{ + git_commit_list *new_list = git_commit_list_create(item, *list_p); *list_p = new_list; return new_list; } diff --git a/src/libgit2/commit_list.h b/src/libgit2/commit_list.h index aad39f3513b..e2dbd2aaed3 100644 --- a/src/libgit2/commit_list.h +++ b/src/libgit2/commit_list.h @@ -49,6 +49,7 @@ git_commit_list_node *git_commit_list_alloc_node(git_revwalk *walk); int git_commit_list_generation_cmp(const void *a, const void *b); int git_commit_list_time_cmp(const void *a, const void *b); void git_commit_list_free(git_commit_list **list_p); +git_commit_list *git_commit_list_create(git_commit_list_node *item, git_commit_list *next); git_commit_list *git_commit_list_insert(git_commit_list_node *item, git_commit_list **list_p); git_commit_list *git_commit_list_insert_by_date(git_commit_list_node *item, git_commit_list **list_p); int git_commit_list_parse(git_revwalk *walk, git_commit_list_node *commit); diff --git a/src/libgit2/revwalk.c b/src/libgit2/revwalk.c index 3269d9279b6..4ea6fae8ffb 100644 --- a/src/libgit2/revwalk.c +++ b/src/libgit2/revwalk.c @@ -83,8 +83,13 @@ int git_revwalk__push_commit(git_revwalk *walk, const git_oid *oid, const git_re commit->uninteresting = opts->uninteresting; list = walk->user_input; - if ((opts->insert_by_date && - git_commit_list_insert_by_date(commit, &list) == NULL) || + + /* To insert by date, we need to parse so we know the date. */ + if (opts->insert_by_date && ((error = git_commit_list_parse(walk, commit)) < 0)) + return error; + + if ((opts->insert_by_date == 0 || + git_commit_list_insert_by_date(commit, &list) == NULL) && git_commit_list_insert(commit, &list) == NULL) { git_error_set_oom(); return -1; @@ -609,7 +614,7 @@ static int sort_in_topological_order(git_commit_list **out, git_revwalk *walk, g static int prepare_walk(git_revwalk *walk) { int error = 0; - git_commit_list *list, *commits = NULL; + git_commit_list *list, *commits = NULL, *commits_last = NULL; git_commit_list_node *next; /* If there were no pushes, we know that the walk is already over */ @@ -618,6 +623,12 @@ static int prepare_walk(git_revwalk *walk) return GIT_ITEROVER; } + /* + * This is a bit convoluted, but necessary to maintain the order of + * the commits. This is especially important in situations where + * git_revwalk__push_glob is called with a git_revwalk__push_options + * setting insert_by_date = 1, which is critical for fetch negotiation. + */ for (list = walk->user_input; list; list = list->next) { git_commit_list_node *commit = list->item; if ((error = git_commit_list_parse(walk, commit)) < 0) @@ -627,8 +638,19 @@ static int prepare_walk(git_revwalk *walk) mark_parents_uninteresting(commit); if (!commit->seen) { + git_commit_list *new_list = NULL; + if ((new_list = git_commit_list_create(commit, NULL)) == NULL) { + git_error_set_oom(); + return -1; + } + commit->seen = 1; - git_commit_list_insert(commit, &commits); + if (commits_last == NULL) + commits = new_list; + else + commits_last->next = new_list; + + commits_last = new_list; } } From dc7bca58eef9c9d2d0589e6363793b9425ff0be0 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Tue, 4 Apr 2023 09:04:24 +0100 Subject: [PATCH 200/608] repo: free data in the discovery tests Shocked that our leak checkers didn't find this earlier. --- tests/libgit2/repo/discover.c | 3 +++ 1 file changed, 3 insertions(+) diff --git a/tests/libgit2/repo/discover.c b/tests/libgit2/repo/discover.c index 523fdf8e395..983d75e3ae5 100644 --- a/tests/libgit2/repo/discover.c +++ b/tests/libgit2/repo/discover.c @@ -122,7 +122,10 @@ void test_repo_discover__cleanup(void) void test_repo_discover__discovering_repo_with_exact_path_succeeds(void) { cl_git_pass(git_repository_discover(&discovered, DISCOVER_FOLDER, 0, ceiling_dirs.ptr)); + git_buf_dispose(&discovered); + cl_git_pass(git_repository_discover(&discovered, SUB_REPOSITORY_FOLDER, 0, ceiling_dirs.ptr)); + git_buf_dispose(&discovered); } void test_repo_discover__discovering_nonexistent_dir_fails(void) From 19065e59601e6fd6f3041d4f9a6de8b105b27cc3 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 3 Apr 2023 11:27:03 +0100 Subject: [PATCH 201/608] repo: change error message "Could not find repository from ..." doesn't make sense. "Could not find repository _at_ ..." does not indicate that we walked down the path hierarchy, but at least it's more correct. --- src/libgit2/repository.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index e16413f763f..00c139a6469 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -757,7 +757,7 @@ static int find_repo( /* If we didn't find the repository, and we don't have any other error * to report, report that. */ if (!git_str_len(gitdir_path)) { - git_error_set(GIT_ERROR_REPOSITORY, "could not find repository from '%s'", start_path); + git_error_set(GIT_ERROR_REPOSITORY, "could not find repository at '%s'", start_path); error = GIT_ENOTFOUND; goto out; } From 54a22f536557b9a25752c6b59829dff4cbee99e0 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 3 Apr 2023 09:52:30 +0100 Subject: [PATCH 202/608] env: remove the _from_env function Remove the `_git_repository_open_ext_from_env` and make it part of the general repository opening code path. This removes the re-entrancy, and standardizes things like index and config opening to a single place again so that we have predictable ordering of the opening procedure. --- src/libgit2/repository.c | 455 ++++++++++++++++++++------------------- src/libgit2/repository.h | 5 +- 2 files changed, 233 insertions(+), 227 deletions(-) diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index 00c139a6469..fe0f1a4efae 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -637,14 +637,28 @@ static int validate_ownership(git_repository *repo) return error; } -static int find_repo( - git_str *gitdir_path, - git_str *workdir_path, - git_str *gitlink_path, - git_str *commondir_path, +struct repo_paths { + git_str gitdir; + git_str workdir; + git_str gitlink; + git_str commondir; +}; + +#define REPO_PATHS_INIT { GIT_STR_INIT } + +GIT_INLINE(void) repo_paths_dispose(struct repo_paths *paths) +{ + git_str_dispose(&paths->gitdir); + git_str_dispose(&paths->workdir); + git_str_dispose(&paths->gitlink); + git_str_dispose(&paths->commondir); +} + +static int find_repo_traverse( + struct repo_paths *out, const char *start_path, - uint32_t flags, - const char *ceiling_dirs) + const char *ceiling_dirs, + uint32_t flags) { git_str path = GIT_STR_INIT; git_str repo_link = GIT_STR_INIT; @@ -656,19 +670,23 @@ static int find_repo( size_t ceiling_offset = 0; int error; - git_str_clear(gitdir_path); + git_str_clear(&out->gitdir); - error = git_fs_path_prettify(&path, start_path, NULL); - if (error < 0) + if ((error = git_fs_path_prettify(&path, start_path, NULL)) < 0) return error; - /* in_dot_git toggles each loop: + /* + * In each loop we look first for a `.git` dir within the + * directory, then to see if the directory itself is a repo. + * + * In other words: if we start in /a/b/c, then we look at: * /a/b/c/.git, /a/b/c, /a/b/.git, /a/b, /a/.git, /a - * With GIT_REPOSITORY_OPEN_BARE or GIT_REPOSITORY_OPEN_NO_DOTGIT, we - * assume we started with /a/b/c.git and don't append .git the first - * time through. - * min_iterations indicates the number of iterations left before going - * further counts as a search. */ + * + * With GIT_REPOSITORY_OPEN_BARE or GIT_REPOSITORY_OPEN_NO_DOTGIT, + * we assume we started with /a/b/c.git and don't append .git the + * first time through. min_iterations indicates the number of + * iterations left before going further counts as a search. + */ if (flags & (GIT_REPOSITORY_OPEN_BARE | GIT_REPOSITORY_OPEN_NO_DOTGIT)) { in_dot_git = true; min_iterations = 1; @@ -700,14 +718,13 @@ static int find_repo( if (is_valid) { if ((error = git_fs_path_to_dir(&path)) < 0 || - (error = git_str_set(gitdir_path, path.ptr, path.size)) < 0) + (error = git_str_set(&out->gitdir, path.ptr, path.size)) < 0) goto out; - if (gitlink_path) - if ((error = git_str_attach(gitlink_path, git_worktree__read_link(path.ptr, GIT_GITDIR_FILE), 0)) < 0) - goto out; - if (commondir_path) - git_str_swap(&common_link, commondir_path); + if ((error = git_str_attach(&out->gitlink, git_worktree__read_link(path.ptr, GIT_GITDIR_FILE), 0)) < 0) + goto out; + + git_str_swap(&common_link, &out->commondir); break; } @@ -717,26 +734,30 @@ static int find_repo( goto out; if (is_valid) { - git_str_swap(gitdir_path, &repo_link); + git_str_swap(&out->gitdir, &repo_link); - if (gitlink_path) - if ((error = git_str_put(gitlink_path, path.ptr, path.size)) < 0) - goto out; - if (commondir_path) - git_str_swap(&common_link, commondir_path); + if ((error = git_str_put(&out->gitlink, path.ptr, path.size)) < 0) + goto out; + + git_str_swap(&common_link, &out->commondir); } break; } } - /* Move up one directory. If we're in_dot_git, we'll search the - * parent itself next. If we're !in_dot_git, we'll search .git - * in the parent directory next (added at the top of the loop). */ + /* + * Move up one directory. If we're in_dot_git, we'll + * search the parent itself next. If we're !in_dot_git, + * we'll search .git in the parent directory next (added + * at the top of the loop). + */ if ((error = git_fs_path_dirname_r(&path, path.ptr)) < 0) goto out; - /* Once we've checked the directory (and .git if applicable), - * find the ceiling for a search. */ + /* + * Once we've checked the directory (and .git if + * applicable), find the ceiling for a search. + */ if (min_iterations && (--min_iterations == 0)) ceiling_offset = find_ceiling_dir_offset(path.ptr, ceiling_dirs); @@ -746,29 +767,96 @@ static int find_repo( break; } - if (workdir_path && !(flags & GIT_REPOSITORY_OPEN_BARE)) { - if (!git_str_len(gitdir_path)) - git_str_clear(workdir_path); - else if ((error = git_fs_path_dirname_r(workdir_path, path.ptr)) < 0 || - (error = git_fs_path_to_dir(workdir_path)) < 0) + if (!(flags & GIT_REPOSITORY_OPEN_BARE)) { + if (!git_str_len(&out->gitdir)) + git_str_clear(&out->workdir); + else if ((error = git_fs_path_dirname_r(&out->workdir, path.ptr)) < 0 || + (error = git_fs_path_to_dir(&out->workdir)) < 0) goto out; } - /* If we didn't find the repository, and we don't have any other error - * to report, report that. */ - if (!git_str_len(gitdir_path)) { + /* If we didn't find the repository, and we don't have any other + * error to report, report that. */ + if (!git_str_len(&out->gitdir)) { git_error_set(GIT_ERROR_REPOSITORY, "could not find repository at '%s'", start_path); error = GIT_ENOTFOUND; goto out; } out: + if (error) + repo_paths_dispose(out); + git_str_dispose(&path); git_str_dispose(&repo_link); git_str_dispose(&common_link); return error; } +static int find_repo( + struct repo_paths *out, + const char *start_path, + const char *ceiling_dirs, + uint32_t flags) +{ + bool use_env = !!(flags & GIT_REPOSITORY_OPEN_FROM_ENV); + git_str gitdir_buf = GIT_STR_INIT, + ceiling_dirs_buf = GIT_STR_INIT, + across_fs_buf = GIT_STR_INIT; + int error; + + if (use_env && !start_path) { + error = git__getenv(&gitdir_buf, "GIT_DIR"); + + if (!error) { + start_path = gitdir_buf.ptr; + flags |= GIT_REPOSITORY_OPEN_NO_SEARCH; + flags |= GIT_REPOSITORY_OPEN_NO_DOTGIT; + } else if (error == GIT_ENOTFOUND) { + start_path = "."; + } else { + goto done; + } + } + + if (use_env && !ceiling_dirs) { + error = git__getenv(&ceiling_dirs_buf, + "GIT_CEILING_DIRECTORIES"); + + if (!error) + ceiling_dirs = ceiling_dirs_buf.ptr; + else if (error != GIT_ENOTFOUND) + goto done; + } + + if (use_env) { + error = git__getenv(&across_fs_buf, + "GIT_DISCOVERY_ACROSS_FILESYSTEM"); + + if (!error) { + int across_fs = 0; + + if ((error = git_config_parse_bool(&across_fs, + git_str_cstr(&across_fs_buf))) < 0) + goto done; + + if (across_fs) + flags |= GIT_REPOSITORY_OPEN_CROSS_FS; + } else if (error != GIT_ENOTFOUND) { + goto done; + } + } + + error = find_repo_traverse(out, start_path, ceiling_dirs, flags); + +done: + git_str_dispose(&gitdir_buf); + git_str_dispose(&ceiling_dirs_buf); + git_str_dispose(&across_fs_buf); + + return error; +} + static int obtain_config_and_set_oid_type( git_config **config_ptr, git_repository *repo) @@ -787,7 +875,7 @@ static int obtain_config_and_set_oid_type( goto out; if (config && - (error = check_repositoryformatversion(&version, config)) < 0) + (error = check_repositoryformatversion(&version, config)) < 0) goto out; if ((error = check_extensions(config, version)) < 0) @@ -851,173 +939,22 @@ int git_repository_open_bare( return error; } -static int _git_repository_open_ext_from_env( - git_repository **out, - const char *start_path) +static int repo_load_namespace(git_repository *repo) { - git_repository *repo = NULL; - git_index *index = NULL; - git_odb *odb = NULL; - git_str dir_buf = GIT_STR_INIT; - git_str ceiling_dirs_buf = GIT_STR_INIT; - git_str across_fs_buf = GIT_STR_INIT; - git_str index_file_buf = GIT_STR_INIT; git_str namespace_buf = GIT_STR_INIT; - git_str object_dir_buf = GIT_STR_INIT; - git_str alts_buf = GIT_STR_INIT; - git_str work_tree_buf = GIT_STR_INIT; - git_str common_dir_buf = GIT_STR_INIT; - const char *ceiling_dirs = NULL; - unsigned flags = 0; int error; - if (!start_path) { - error = git__getenv(&dir_buf, "GIT_DIR"); - if (error == GIT_ENOTFOUND) { - git_error_clear(); - start_path = "."; - } else if (error < 0) - goto error; - else { - start_path = git_str_cstr(&dir_buf); - flags |= GIT_REPOSITORY_OPEN_NO_SEARCH; - flags |= GIT_REPOSITORY_OPEN_NO_DOTGIT; - } - } - - error = git__getenv(&ceiling_dirs_buf, "GIT_CEILING_DIRECTORIES"); - if (error == GIT_ENOTFOUND) - git_error_clear(); - else if (error < 0) - goto error; - else - ceiling_dirs = git_str_cstr(&ceiling_dirs_buf); - - error = git__getenv(&across_fs_buf, "GIT_DISCOVERY_ACROSS_FILESYSTEM"); - if (error == GIT_ENOTFOUND) - git_error_clear(); - else if (error < 0) - goto error; - else { - int across_fs = 0; - error = git_config_parse_bool(&across_fs, git_str_cstr(&across_fs_buf)); - if (error < 0) - goto error; - if (across_fs) - flags |= GIT_REPOSITORY_OPEN_CROSS_FS; - } - - error = git__getenv(&index_file_buf, "GIT_INDEX_FILE"); - if (error == GIT_ENOTFOUND) - git_error_clear(); - else if (error < 0) - goto error; - else { - error = git_index_open(&index, git_str_cstr(&index_file_buf)); - if (error < 0) - goto error; - } + if (!repo->use_env) + return 0; error = git__getenv(&namespace_buf, "GIT_NAMESPACE"); - if (error == GIT_ENOTFOUND) - git_error_clear(); - else if (error < 0) - goto error; - - error = git__getenv(&object_dir_buf, "GIT_OBJECT_DIRECTORY"); - if (error == GIT_ENOTFOUND) - git_error_clear(); - else if (error < 0) - goto error; - else { - error = git_odb__open(&odb, git_str_cstr(&object_dir_buf), NULL); - if (error < 0) - goto error; - } - - error = git__getenv(&work_tree_buf, "GIT_WORK_TREE"); - if (error == GIT_ENOTFOUND) - git_error_clear(); - else if (error < 0) - goto error; - else { - git_error_set(GIT_ERROR_INVALID, "GIT_WORK_TREE unimplemented"); - error = GIT_ERROR; - goto error; - } - - error = git__getenv(&work_tree_buf, "GIT_COMMON_DIR"); - if (error == GIT_ENOTFOUND) - git_error_clear(); - else if (error < 0) - goto error; - else { - git_error_set(GIT_ERROR_INVALID, "GIT_COMMON_DIR unimplemented"); - error = GIT_ERROR; - goto error; - } - error = git_repository_open_ext(&repo, start_path, flags, ceiling_dirs); - if (error < 0) - goto error; - - if (odb) - git_repository_set_odb(repo, odb); - - error = git__getenv(&alts_buf, "GIT_ALTERNATE_OBJECT_DIRECTORIES"); - if (error == GIT_ENOTFOUND) { - git_error_clear(); - error = 0; - } else if (error < 0) - goto error; - else { - const char *end; - char *alt, *sep; - if (!odb) { - error = git_repository_odb(&odb, repo); - if (error < 0) - goto error; - } - - end = git_str_cstr(&alts_buf) + git_str_len(&alts_buf); - for (sep = alt = alts_buf.ptr; sep != end; alt = sep+1) { - for (sep = alt; *sep && *sep != GIT_PATH_LIST_SEPARATOR; sep++) - ; - if (*sep) - *sep = '\0'; - error = git_odb_add_disk_alternate(odb, alt); - if (error < 0) - goto error; - } - } + if (error == 0) + repo->namespace = git_str_detach(&namespace_buf); + else if (error != GIT_ENOTFOUND) + return error; - if (git_str_len(&namespace_buf)) { - error = git_repository_set_namespace(repo, git_str_cstr(&namespace_buf)); - if (error < 0) - goto error; - } - - git_repository_set_index(repo, index); - - if (out) { - *out = repo; - goto success; - } -error: - git_repository_free(repo); -success: - git_odb_free(odb); - git_index_free(index); - git_str_dispose(&common_dir_buf); - git_str_dispose(&work_tree_buf); - git_str_dispose(&alts_buf); - git_str_dispose(&object_dir_buf); - git_str_dispose(&namespace_buf); - git_str_dispose(&index_file_buf); - git_str_dispose(&across_fs_buf); - git_str_dispose(&ceiling_dirs_buf); - git_str_dispose(&dir_buf); - return error; + return 0; } static int repo_is_worktree(unsigned *out, const git_repository *repo) @@ -1049,21 +986,16 @@ int git_repository_open_ext( unsigned int flags, const char *ceiling_dirs) { - int error; - unsigned is_worktree; - git_str gitdir = GIT_STR_INIT, workdir = GIT_STR_INIT, - gitlink = GIT_STR_INIT, commondir = GIT_STR_INIT; + struct repo_paths paths = { GIT_STR_INIT }; git_repository *repo = NULL; git_config *config = NULL; - - if (flags & GIT_REPOSITORY_OPEN_FROM_ENV) - return _git_repository_open_ext_from_env(repo_ptr, start_path); + unsigned is_worktree; + int error; if (repo_ptr) *repo_ptr = NULL; - error = find_repo( - &gitdir, &workdir, &gitlink, &commondir, start_path, flags, ceiling_dirs); + error = find_repo(&paths, start_path, ceiling_dirs, flags); if (error < 0 || !repo_ptr) goto cleanup; @@ -1071,20 +1003,23 @@ int git_repository_open_ext( repo = repository_alloc(); GIT_ERROR_CHECK_ALLOC(repo); - repo->gitdir = git_str_detach(&gitdir); + repo->use_env = !!(flags & GIT_REPOSITORY_OPEN_FROM_ENV); + + repo->gitdir = git_str_detach(&paths.gitdir); GIT_ERROR_CHECK_ALLOC(repo->gitdir); - if (gitlink.size) { - repo->gitlink = git_str_detach(&gitlink); + if (paths.gitlink.size) { + repo->gitlink = git_str_detach(&paths.gitlink); GIT_ERROR_CHECK_ALLOC(repo->gitlink); } - if (commondir.size) { - repo->commondir = git_str_detach(&commondir); + if (paths.commondir.size) { + repo->commondir = git_str_detach(&paths.commondir); GIT_ERROR_CHECK_ALLOC(repo->commondir); } if ((error = repo_is_worktree(&is_worktree, repo)) < 0) goto cleanup; + repo->is_worktree = is_worktree; error = obtain_config_and_set_oid_type(&config, repo); @@ -1096,10 +1031,13 @@ int git_repository_open_ext( } else { if (config && ((error = load_config_data(repo, config)) < 0 || - (error = load_workdir(repo, config, &workdir)) < 0)) + (error = load_workdir(repo, config, &paths.workdir)) < 0)) goto cleanup; } + if ((error = repo_load_namespace(repo)) < 0) + goto cleanup; + /* * Ensure that the git directory and worktree are * owned by the current user. @@ -1109,10 +1047,7 @@ int git_repository_open_ext( goto cleanup; cleanup: - git_str_dispose(&gitdir); - git_str_dispose(&workdir); - git_str_dispose(&gitlink); - git_str_dispose(&commondir); + repo_paths_dispose(&paths); git_config_free(config); if (error < 0) @@ -1180,11 +1115,17 @@ int git_repository_discover( int across_fs, const char *ceiling_dirs) { + struct repo_paths paths = { GIT_STR_INIT }; uint32_t flags = across_fs ? GIT_REPOSITORY_OPEN_CROSS_FS : 0; + int error; GIT_ASSERT_ARG(start_path); - GIT_BUF_WRAP_PRIVATE(out, find_repo, NULL, NULL, NULL, start_path, flags, ceiling_dirs); + if ((error = find_repo(&paths, start_path, ceiling_dirs, flags)) == 0) + error = git_buf_fromstr(out, &paths.gitdir); + + repo_paths_dispose(&paths); + return error; } static int load_config( @@ -1329,6 +1270,56 @@ int git_repository_set_config(git_repository *repo, git_config *config) return 0; } +static int repository_odb_path(git_str *out, git_repository *repo) +{ + int error = GIT_ENOTFOUND; + + if (repo->use_env) + error = git__getenv(out, "GIT_OBJECT_DIRECTORY"); + + if (error == GIT_ENOTFOUND) + error = git_repository__item_path(out, repo, + GIT_REPOSITORY_ITEM_OBJECTS); + + return error; +} + +static int repository_odb_alternates( + git_odb *odb, + git_repository *repo) +{ + git_str alternates = GIT_STR_INIT; + char *sep, *alt; + int error; + + if (!repo->use_env) + return 0; + + error = git__getenv(&alternates, "GIT_ALTERNATE_OBJECT_DIRECTORIES"); + + if (error != 0) + return (error == GIT_ENOTFOUND) ? 0 : error; + + alt = alternates.ptr; + + while (*alt) { + sep = strchr(alt, GIT_PATH_LIST_SEPARATOR); + + if (sep) + *sep = '\0'; + + error = git_odb_add_disk_alternate(odb, alt); + + if (sep) + alt = sep + 1; + else + break; + } + + git_str_dispose(&alternates); + return 0; +} + int git_repository_odb__weakptr(git_odb **out, git_repository *repo) { int error = 0; @@ -1344,9 +1335,9 @@ int git_repository_odb__weakptr(git_odb **out, git_repository *repo) odb_opts.oid_type = repo->oid_type; - if ((error = git_repository__item_path(&odb_path, repo, - GIT_REPOSITORY_ITEM_OBJECTS)) < 0 || - (error = git_odb__new(&odb, &odb_opts)) < 0) + if ((error = repository_odb_path(&odb_path, repo)) < 0 || + (error = git_odb__new(&odb, &odb_opts)) < 0 || + (error = repository_odb_alternates(odb, repo)) < 0) return error; GIT_REFCOUNT_OWN(odb, repo); @@ -1430,6 +1421,20 @@ int git_repository_set_refdb(git_repository *repo, git_refdb *refdb) return 0; } +static int repository_index_path(git_str *out, git_repository *repo) +{ + int error = GIT_ENOTFOUND; + + if (repo->use_env) + error = git__getenv(out, "GIT_INDEX_FILE"); + + if (error == GIT_ENOTFOUND) + error = git_repository__item_path(out, repo, + GIT_REPOSITORY_ITEM_INDEX); + + return error; +} + int git_repository_index__weakptr(git_index **out, git_repository *repo) { int error = 0; @@ -1441,7 +1446,7 @@ int git_repository_index__weakptr(git_index **out, git_repository *repo) git_str index_path = GIT_STR_INIT; git_index *index; - if ((error = git_str_joinpath(&index_path, repo->gitdir, GIT_INDEX_FILE)) < 0) + if ((error = repository_index_path(&index_path, repo)) < 0) return error; error = git_index_open(&index, index_path.ptr); diff --git a/src/libgit2/repository.h b/src/libgit2/repository.h index 75380ae5347..9a36ef97210 100644 --- a/src/libgit2/repository.h +++ b/src/libgit2/repository.h @@ -151,8 +151,9 @@ struct git_repository { git_array_t(git_str) reserved_names; - unsigned is_bare:1; - unsigned is_worktree:1; + unsigned use_env:1, + is_bare:1, + is_worktree:1; git_oid_t oid_type; unsigned int lru_counter; From b41c3dfce65fec1f6f5f009f050e61c54acf617c Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 3 Apr 2023 10:38:57 +0100 Subject: [PATCH 203/608] repo: honor GIT_WORK_TREE environment variable When the repository is opened with `GIT_REPOSITORY_OPEN_FROM_ENV`, honor the `GIT_WORK_TREE` environment variable. --- src/libgit2/repository.c | 55 ++++++++++++++++++++++++++++++---------- tests/libgit2/repo/env.c | 20 +++++++++++++++ 2 files changed, 62 insertions(+), 13 deletions(-) diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index fe0f1a4efae..32ffb009e5a 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -337,19 +337,42 @@ static int load_config_data(git_repository *repo, const git_config *config) return 0; } -static int load_workdir(git_repository *repo, git_config *config, git_str *parent_path) +static int load_workdir( + git_repository *repo, + git_config *config, + git_str *parent_path) { - int error; - git_config_entry *ce; + git_config_entry *ce = NULL; git_str worktree = GIT_STR_INIT; git_str path = GIT_STR_INIT; + git_str workdir_env = GIT_STR_INIT; + const char *value = NULL; + int error; if (repo->is_bare) return 0; - if ((error = git_config__lookup_entry( - &ce, config, "core.worktree", false)) < 0) - return error; + /* Environment variables are preferred */ + if (repo->use_env) { + error = git__getenv(&workdir_env, "GIT_WORK_TREE"); + + if (error == 0) + value = workdir_env.ptr; + else if (error == GIT_ENOTFOUND) + error = 0; + else + goto cleanup; + } + + /* Examine configuration values if necessary */ + if (!value) { + if ((error = git_config__lookup_entry(&ce, config, + "core.worktree", false)) < 0) + return error; + + if (ce && ce->value) + value = ce->value; + } if (repo->is_worktree) { char *gitlink = git_worktree__read_link(repo->gitdir, GIT_GITDIR_FILE); @@ -367,17 +390,21 @@ static int load_workdir(git_repository *repo, git_config *config, git_str *paren } repo->workdir = git_str_detach(&worktree); - } - else if (ce && ce->value) { - if ((error = git_fs_path_prettify_dir( - &worktree, ce->value, repo->gitdir)) < 0) + } else if (value) { + if (!*value) { + git_error_set(GIT_ERROR_NET, "working directory cannot be set to empty path"); + error = -1; + goto cleanup; + } + + if ((error = git_fs_path_prettify_dir(&worktree, + value, repo->gitdir)) < 0) goto cleanup; repo->workdir = git_str_detach(&worktree); - } - else if (parent_path && git_fs_path_isdir(parent_path->ptr)) + } else if (parent_path && git_fs_path_isdir(parent_path->ptr)) { repo->workdir = git_str_detach(parent_path); - else { + } else { if (git_fs_path_dirname_r(&worktree, repo->gitdir) < 0 || git_fs_path_to_dir(&worktree) < 0) { error = -1; @@ -388,8 +415,10 @@ static int load_workdir(git_repository *repo, git_config *config, git_str *paren } GIT_ERROR_CHECK_ALLOC(repo->workdir); + cleanup: git_str_dispose(&path); + git_str_dispose(&workdir_env); git_config_entry_free(ce); return error; } diff --git a/tests/libgit2/repo/env.c b/tests/libgit2/repo/env.c index 790ffd40f0f..5f084ac0078 100644 --- a/tests/libgit2/repo/env.c +++ b/tests/libgit2/repo/env.c @@ -31,6 +31,8 @@ void test_repo_env__cleanup(void) if (git_fs_path_isdir("peeled.git")) git_futils_rmdir_r("peeled.git", NULL, GIT_RMDIR_REMOVE_FILES); + cl_fixture_cleanup("test_workdir"); + clear_git_env(); } @@ -275,3 +277,21 @@ void test_repo_env__open(void) clear_git_env(); } + +void test_repo_env__work_tree(void) +{ + git_repository *repo; + const char *test_path; + + cl_fixture_sandbox("attr"); + cl_git_pass(p_rename("attr/.gitted", "attr/.git")); + + cl_must_pass(p_mkdir("test_workdir", 0777)); + test_path = cl_git_sandbox_path(1, "test_workdir", NULL); + + cl_setenv("GIT_WORK_TREE", test_path); + cl_git_pass(git_repository_open_ext(&repo, "attr", GIT_REPOSITORY_OPEN_FROM_ENV, NULL)); + cl_assert_equal_s(test_path, git_repository_workdir(repo)); + git_repository_free(repo); + cl_setenv("GIT_WORK_TREE", NULL); +} From 24b9c4b63374e850d165ae5f7055db6e47ff3051 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 3 Apr 2023 11:43:47 +0100 Subject: [PATCH 204/608] repo: honor GIT_COMMON_DIR when respecting env When the repository is opened with `GIT_REPOSITORY_OPEN_FROM_ENV`, honor the `GIT_COMMON_DIR` environment variable. --- src/libgit2/repository.c | 36 ++++++++++++++++++++++++++---------- tests/libgit2/repo/env.c | 20 ++++++++++++++++++++ 2 files changed, 46 insertions(+), 10 deletions(-) diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index 32ffb009e5a..cd0f4ad74da 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -191,11 +191,23 @@ void git_repository_free(git_repository *repo) } /* Check if we have a separate commondir (e.g. we have a worktree) */ -static int lookup_commondir(bool *separate, git_str *commondir, git_str *repository_path) +static int lookup_commondir( + bool *separate, + git_str *commondir, + git_str *repository_path, + uint32_t flags) { - git_str common_link = GIT_STR_INIT; + git_str common_link = GIT_STR_INIT; int error; + /* Environment variable overrides configuration */ + if ((flags & GIT_REPOSITORY_OPEN_FROM_ENV)) { + error = git__getenv(commondir, "GIT_COMMON_DIR"); + + if (!error || error != GIT_ENOTFOUND) + goto done; + } + /* * If there's no commondir file, the repository path is the * common path, but it needs a trailing slash. @@ -222,12 +234,11 @@ static int lookup_commondir(bool *separate, git_str *commondir, git_str *reposit git_str_swap(commondir, &common_link); } - git_str_dispose(&common_link); - /* Make sure the commondir path always has a trailing slash */ error = git_fs_path_prettify_dir(commondir, commondir->ptr, NULL); done: + git_str_dispose(&common_link); return error; } @@ -252,14 +263,19 @@ GIT_INLINE(int) validate_repo_path(git_str *path) * * Open a repository object from its path */ -static int is_valid_repository_path(bool *out, git_str *repository_path, git_str *common_path) +static int is_valid_repository_path( + bool *out, + git_str *repository_path, + git_str *common_path, + uint32_t flags) { bool separate_commondir = false; int error; *out = false; - if ((error = lookup_commondir(&separate_commondir, common_path, repository_path)) < 0) + if ((error = lookup_commondir(&separate_commondir, + common_path, repository_path, flags)) < 0) return error; /* Ensure HEAD file exists */ @@ -742,7 +758,7 @@ static int find_repo_traverse( break; if (S_ISDIR(st.st_mode)) { - if ((error = is_valid_repository_path(&is_valid, &path, &common_link)) < 0) + if ((error = is_valid_repository_path(&is_valid, &path, &common_link, flags)) < 0) goto out; if (is_valid) { @@ -759,7 +775,7 @@ static int find_repo_traverse( } } else if (S_ISREG(st.st_mode) && git__suffixcmp(path.ptr, "/" DOT_GIT) == 0) { if ((error = read_gitfile(&repo_link, path.ptr)) < 0 || - (error = is_valid_repository_path(&is_valid, &repo_link, &common_link)) < 0) + (error = is_valid_repository_path(&is_valid, &repo_link, &common_link, flags)) < 0) goto out; if (is_valid) { @@ -934,7 +950,7 @@ int git_repository_open_bare( git_config *config; if ((error = git_fs_path_prettify_dir(&path, bare_path, NULL)) < 0 || - (error = is_valid_repository_path(&is_valid, &path, &common_path)) < 0) + (error = is_valid_repository_path(&is_valid, &path, &common_path, 0)) < 0) return error; if (!is_valid) { @@ -2668,7 +2684,7 @@ int git_repository_init_ext( wd = (opts->flags & GIT_REPOSITORY_INIT_BARE) ? NULL : git_str_cstr(&wd_path); - if ((error = is_valid_repository_path(&is_valid, &repo_path, &common_path)) < 0) + if ((error = is_valid_repository_path(&is_valid, &repo_path, &common_path, opts->flags)) < 0) goto out; if (is_valid) { diff --git a/tests/libgit2/repo/env.c b/tests/libgit2/repo/env.c index 5f084ac0078..4a61581bd6b 100644 --- a/tests/libgit2/repo/env.c +++ b/tests/libgit2/repo/env.c @@ -295,3 +295,23 @@ void test_repo_env__work_tree(void) git_repository_free(repo); cl_setenv("GIT_WORK_TREE", NULL); } + +void test_repo_env__commondir(void) +{ + git_repository *repo; + const char *test_path; + + cl_fixture_sandbox("attr"); + cl_git_pass(p_rename("attr/.gitted", "attr/.git")); + + cl_fixture_sandbox("testrepo.git"); + cl_git_pass(p_rename("testrepo.git", "test_commondir")); + + test_path = cl_git_sandbox_path(1, "test_commondir", NULL); + + cl_setenv("GIT_COMMON_DIR", test_path); + cl_git_pass(git_repository_open_ext(&repo, "attr", GIT_REPOSITORY_OPEN_FROM_ENV, NULL)); + cl_assert_equal_s(test_path, git_repository_commondir(repo)); + git_repository_free(repo); + cl_setenv("GIT_COMMON_DIR", NULL); +} From 389f9b10e6e71339fe28145098a37975c49a472d Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 3 Apr 2023 12:58:23 +0100 Subject: [PATCH 205/608] repo: honor GIT_CONFIG_* environment variables When the repository is opened with `GIT_REPOSITORY_OPEN_FROM_ENV`, honor the `GIT_CONFIG_GLOBAL`, `GIT_CONFIG_SYSTEM` and `GIT_CONFIG_NOSYSTEM` environment variables. --- src/libgit2/repository.c | 129 ++++++++++++++++++++++++++++----------- tests/libgit2/repo/env.c | 52 ++++++++++++++++ 2 files changed, 146 insertions(+), 35 deletions(-) diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index cd0f4ad74da..3f57fb23cca 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -66,7 +66,7 @@ static const struct { static int check_repositoryformatversion(int *version, git_config *config); static int check_extensions(git_config *config, int version); -static int load_global_config(git_config **config); +static int load_global_config(git_config **config, bool use_env); static int load_objectformat(git_repository *repo, git_config *config); #define GIT_COMMONDIR_FILE "commondir" @@ -586,7 +586,10 @@ static int validate_ownership_cb(const git_config_entry *entry, void *payload) return 0; } -static int validate_ownership_config(bool *is_safe, const char *path) +static int validate_ownership_config( + bool *is_safe, + const char *path, + bool use_env) { validate_ownership_data ownership_data = { path, GIT_STR_INIT, is_safe @@ -594,7 +597,7 @@ static int validate_ownership_config(bool *is_safe, const char *path) git_config *config; int error; - if (load_global_config(&config) != 0) + if (load_global_config(&config, use_env) != 0) return 0; error = git_config_get_multivar_foreach(config, @@ -668,7 +671,8 @@ static int validate_ownership(git_repository *repo) } if (is_safe || - (error = validate_ownership_config(&is_safe, validation_paths[0])) < 0) + (error = validate_ownership_config( + &is_safe, validation_paths[0], repo->use_env)) < 0) goto done; if (!is_safe) { @@ -1241,32 +1245,81 @@ static const char *path_unless_empty(git_str *buf) return git_str_len(buf) > 0 ? git_str_cstr(buf) : NULL; } +GIT_INLINE(int) config_path_system(git_str *out, bool use_env) +{ + if (use_env) { + git_str no_system_buf = GIT_STR_INIT; + int no_system = 0; + int error; + + error = git__getenv(&no_system_buf, "GIT_CONFIG_NOSYSTEM"); + + if (error && error != GIT_ENOTFOUND) + return error; + + error = git_config_parse_bool(&no_system, no_system_buf.ptr); + git_str_dispose(&no_system_buf); + + if (no_system) + return 0; + + error = git__getenv(out, "GIT_CONFIG_SYSTEM"); + + if (error == 0 || error != GIT_ENOTFOUND) + return 0; + } + + git_config__find_system(out); + return 0; +} + +GIT_INLINE(int) config_path_global(git_str *out, bool use_env) +{ + if (use_env) { + int error = git__getenv(out, "GIT_CONFIG_GLOBAL"); + + if (error == 0 || error != GIT_ENOTFOUND) + return 0; + } + + git_config__find_global(out); + return 0; +} + int git_repository_config__weakptr(git_config **out, git_repository *repo) { int error = 0; if (repo->_config == NULL) { + git_str system_buf = GIT_STR_INIT; git_str global_buf = GIT_STR_INIT; git_str xdg_buf = GIT_STR_INIT; - git_str system_buf = GIT_STR_INIT; git_str programdata_buf = GIT_STR_INIT; + bool use_env = repo->use_env; git_config *config; - git_config__find_global(&global_buf); - git_config__find_xdg(&xdg_buf); - git_config__find_system(&system_buf); - git_config__find_programdata(&programdata_buf); + if (!(error = config_path_system(&system_buf, use_env)) && + !(error = config_path_global(&global_buf, use_env))) { + git_config__find_xdg(&xdg_buf); + git_config__find_programdata(&programdata_buf); + } - /* If there is no global file, open a backend for it anyway */ - if (git_str_len(&global_buf) == 0) - git_config__global_location(&global_buf); + if (!error) { + /* + * If there is no global file, open a backend + * for it anyway. + */ + if (git_str_len(&global_buf) == 0) + git_config__global_location(&global_buf); + + error = load_config( + &config, repo, + path_unless_empty(&global_buf), + path_unless_empty(&xdg_buf), + path_unless_empty(&system_buf), + path_unless_empty(&programdata_buf)); + } - error = load_config( - &config, repo, - path_unless_empty(&global_buf), - path_unless_empty(&xdg_buf), - path_unless_empty(&system_buf), - path_unless_empty(&programdata_buf)); if (!error) { GIT_REFCOUNT_OWN(config, repo); @@ -1966,7 +2019,7 @@ static bool is_filesystem_case_insensitive(const char *gitdir_path) * Return a configuration object with only the global and system * configurations; no repository-level configuration. */ -static int load_global_config(git_config **config) +static int load_global_config(git_config **config, bool use_env) { git_str global_buf = GIT_STR_INIT; git_str xdg_buf = GIT_STR_INIT; @@ -1974,16 +2027,17 @@ static int load_global_config(git_config **config) git_str programdata_buf = GIT_STR_INIT; int error; - git_config__find_global(&global_buf); - git_config__find_xdg(&xdg_buf); - git_config__find_system(&system_buf); - git_config__find_programdata(&programdata_buf); + if (!(error = config_path_system(&system_buf, use_env)) && + !(error = config_path_global(&global_buf, use_env))) { + git_config__find_xdg(&xdg_buf); + git_config__find_programdata(&programdata_buf); - error = load_config(config, NULL, - path_unless_empty(&global_buf), - path_unless_empty(&xdg_buf), - path_unless_empty(&system_buf), - path_unless_empty(&programdata_buf)); + error = load_config(config, NULL, + path_unless_empty(&global_buf), + path_unless_empty(&xdg_buf), + path_unless_empty(&system_buf), + path_unless_empty(&programdata_buf)); + } git_str_dispose(&global_buf); git_str_dispose(&xdg_buf); @@ -1993,7 +2047,7 @@ static int load_global_config(git_config **config) return error; } -static bool are_symlinks_supported(const char *wd_path) +static bool are_symlinks_supported(const char *wd_path, bool use_env) { git_config *config = NULL; int symlinks = 0; @@ -2006,10 +2060,12 @@ static bool are_symlinks_supported(const char *wd_path) * _not_ set, then we do not test or enable symlink support. */ #ifdef GIT_WIN32 - if (load_global_config(&config) < 0 || + if (load_global_config(&config, use_env) < 0 || git_config_get_bool(&symlinks, config, "core.symlinks") < 0 || !symlinks) goto done; +#else + GIT_UNUSED(use_env); #endif if (!(symlinks = git_fs_path_supports_symlinks(wd_path))) @@ -2082,7 +2138,8 @@ static int repo_init_fs_configs( const char *cfg_path, const char *repo_dir, const char *work_dir, - bool update_ignorecase) + bool update_ignorecase, + bool use_env) { int error = 0; @@ -2093,7 +2150,7 @@ static int repo_init_fs_configs( cfg, "core.filemode", is_chmod_supported(cfg_path))) < 0) return error; - if (!are_symlinks_supported(work_dir)) { + if (!are_symlinks_supported(work_dir, use_env)) { if ((error = git_config_set_bool(cfg, "core.symlinks", false)) < 0) return error; } else if (git_config_delete_entry(cfg, "core.symlinks") < 0) @@ -2130,6 +2187,7 @@ static int repo_init_config( git_config *config = NULL; bool is_bare = ((flags & GIT_REPOSITORY_INIT_BARE) != 0); bool is_reinit = ((flags & GIT_REPOSITORY_INIT__IS_REINIT) != 0); + bool use_env = ((flags & GIT_REPOSITORY_OPEN_FROM_ENV) != 0); int version = GIT_REPO_VERSION_DEFAULT; if ((error = repo_local_config(&config, &cfg_path, NULL, repo_dir)) < 0) @@ -2150,7 +2208,8 @@ static int repo_init_config( SET_REPO_CONFIG(int32, "core.repositoryformatversion", version); if ((error = repo_init_fs_configs( - config, cfg_path.ptr, repo_dir, work_dir, !is_reinit)) < 0) + config, cfg_path.ptr, repo_dir, work_dir, + !is_reinit, use_env)) < 0) goto cleanup; if (!is_bare) { @@ -2214,8 +2273,8 @@ int git_repository_reinit_filesystem(git_repository *repo, int recurse) const char *repo_dir = git_repository_path(repo); if (!(error = repo_local_config(&config, &path, repo, repo_dir))) - error = repo_init_fs_configs( - config, path.ptr, repo_dir, git_repository_workdir(repo), true); + error = repo_init_fs_configs(config, path.ptr, repo_dir, + git_repository_workdir(repo), true, repo->use_env); git_config_free(config); git_str_dispose(&path); diff --git a/tests/libgit2/repo/env.c b/tests/libgit2/repo/env.c index 4a61581bd6b..0e6cc59d5e2 100644 --- a/tests/libgit2/repo/env.c +++ b/tests/libgit2/repo/env.c @@ -32,6 +32,8 @@ void test_repo_env__cleanup(void) git_futils_rmdir_r("peeled.git", NULL, GIT_RMDIR_REMOVE_FILES); cl_fixture_cleanup("test_workdir"); + cl_fixture_cleanup("test_global_conf"); + cl_fixture_cleanup("test_system_conf"); clear_git_env(); } @@ -315,3 +317,53 @@ void test_repo_env__commondir(void) git_repository_free(repo); cl_setenv("GIT_COMMON_DIR", NULL); } + +void test_repo_env__config(void) +{ + git_repository *repo; + git_config *config; + const char *system_path, *global_path; + int s, g; + + cl_fixture_sandbox("attr"); + cl_git_pass(p_rename("attr/.gitted", "attr/.git")); + + cl_git_rewritefile("test_system_conf", "[tttest]\n\tsys = true\n"); + cl_git_rewritefile("test_global_conf", "[tttest]\n\tglb = true\n"); + + system_path = cl_git_sandbox_path(0, "test_system_conf", NULL); + cl_setenv("GIT_CONFIG_SYSTEM", system_path); + + global_path = cl_git_sandbox_path(0, "test_global_conf", NULL); + cl_setenv("GIT_CONFIG_GLOBAL", global_path); + + /* Ensure we can override the system and global files */ + + cl_git_pass(git_repository_open_ext(&repo, "attr", GIT_REPOSITORY_OPEN_FROM_ENV, NULL)); + cl_git_pass(git_repository_config(&config, repo)); + + cl_git_pass(git_config_get_bool(&s, config, "tttest.sys")); + cl_assert_equal_i(1, s); + cl_git_pass(git_config_get_bool(&g, config, "tttest.glb")); + cl_assert_equal_i(1, g); + + git_config_free(config); + git_repository_free(repo); + + /* Further ensure we can ignore the system file. */ + cl_setenv("GIT_CONFIG_NOSYSTEM", "TrUe"); + + cl_git_pass(git_repository_open_ext(&repo, "attr", GIT_REPOSITORY_OPEN_FROM_ENV, NULL)); + cl_git_pass(git_repository_config(&config, repo)); + + cl_git_fail_with(GIT_ENOTFOUND, git_config_get_bool(&s, config, "tttest.sys")); + cl_git_pass(git_config_get_bool(&g, config, "tttest.glb")); + cl_assert_equal_i(1, g); + + git_config_free(config); + git_repository_free(repo); + + cl_setenv("GIT_CONFIG_NOSYSTEM", NULL); + cl_setenv("GIT_CONFIG_SYSTEM", NULL); + cl_setenv("GIT_CONFIG_GLOBAL", NULL); +} From c616ba2d1ebab52af0315235932659d81d238876 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Wed, 5 Apr 2023 10:33:11 +0100 Subject: [PATCH 206/608] filebuf: configurable hash type `git_filebuf` hashes contents as its written; allow for SHA1 or SHA256 as that hash. Currently, most callers simply use SHA1 as they do not yet know about SHA256 themselves. --- src/libgit2/config_file.c | 16 ++++++++++++---- src/libgit2/index.c | 12 ++++++++---- src/libgit2/indexer.c | 5 +++-- src/util/filebuf.c | 7 ++++++- src/util/filebuf.h | 25 +++++++++++++++++++------ 5 files changed, 48 insertions(+), 17 deletions(-) diff --git a/src/libgit2/config_file.c b/src/libgit2/config_file.c index 932ca76014e..f3b87578d9c 100644 --- a/src/libgit2/config_file.c +++ b/src/libgit2/config_file.c @@ -1116,7 +1116,12 @@ static int write_on_eof( /* * This is pretty much the parsing, except we write out anything we don't have */ -static int config_file_write(config_file_backend *cfg, const char *orig_key, const char *key, const git_regexp *preg, const char *value) +static int config_file_write( + config_file_backend *cfg, + const char *orig_key, + const char *key, + const git_regexp *preg, + const char *value) { char *orig_section = NULL, *section = NULL, *orig_name, *name, *ldot; @@ -1124,15 +1129,18 @@ static int config_file_write(config_file_backend *cfg, const char *orig_key, con git_config_parser parser = GIT_CONFIG_PARSER_INIT; git_filebuf file = GIT_FILEBUF_INIT; struct write_data write_data; - int error; + int filebuf_hash, error; + + filebuf_hash = git_filebuf_hash_flags(git_oid_algorithm(GIT_OID_SHA1)); + GIT_ASSERT(filebuf_hash); memset(&write_data, 0, sizeof(write_data)); if (cfg->locked) { error = git_str_puts(&contents, git_str_cstr(&cfg->locked_content) == NULL ? "" : git_str_cstr(&cfg->locked_content)); } else { - if ((error = git_filebuf_open(&file, cfg->file.path, GIT_FILEBUF_HASH_CONTENTS, - GIT_CONFIG_FILE_MODE)) < 0) + if ((error = git_filebuf_open(&file, cfg->file.path, + filebuf_hash, GIT_CONFIG_FILE_MODE)) < 0) goto done; /* We need to read in our own config file */ diff --git a/src/libgit2/index.c b/src/libgit2/index.c index d4532c005d0..6777f035812 100644 --- a/src/libgit2/index.c +++ b/src/libgit2/index.c @@ -3668,19 +3668,23 @@ int git_indexwriter_init( git_indexwriter *writer, git_index *index) { - int error; + int filebuf_hash, error; GIT_REFCOUNT_INC(index); writer->index = index; + filebuf_hash = git_filebuf_hash_flags(git_oid_algorithm(GIT_OID_SHA1)); + GIT_ASSERT(filebuf_hash); + if (!index->index_file_path) return create_index_error(-1, "failed to write index: The index is in-memory only"); - if ((error = git_filebuf_open( - &writer->file, index->index_file_path, GIT_FILEBUF_HASH_CONTENTS, GIT_INDEX_FILE_MODE)) < 0) { - + if ((error = git_filebuf_open(&writer->file, + index->index_file_path, + git_filebuf_hash_flags(filebuf_hash), + GIT_INDEX_FILE_MODE)) < 0) { if (error == GIT_ELOCKED) git_error_set(GIT_ERROR_INDEX, "the index is locked; this might be due to a concurrent or crashed process"); diff --git a/src/libgit2/indexer.c b/src/libgit2/indexer.c index fa55fb5eafe..7357a4aa56f 100644 --- a/src/libgit2/indexer.c +++ b/src/libgit2/indexer.c @@ -1232,6 +1232,7 @@ int git_indexer_commit(git_indexer *idx, git_indexer_progress *stats) git_filebuf index_file = {0}; void *packfile_trailer; size_t checksum_size; + int filebuf_hash; bool mismatch; if (!idx->parsed_header) { @@ -1240,6 +1241,7 @@ int git_indexer_commit(git_indexer *idx, git_indexer_progress *stats) } checksum_size = git_hash_size(indexer_hash_algorithm(idx)); + filebuf_hash = git_filebuf_hash_flags(indexer_hash_algorithm(idx)); GIT_ASSERT(checksum_size); /* Test for this before resolve_deltas(), as it plays with idx->off */ @@ -1314,8 +1316,7 @@ int git_indexer_commit(git_indexer *idx, git_indexer_progress *stats) return -1; if (git_filebuf_open(&index_file, filename.ptr, - GIT_FILEBUF_HASH_CONTENTS | - (idx->do_fsync ? GIT_FILEBUF_FSYNC : 0), + filebuf_hash | (idx->do_fsync ? GIT_FILEBUF_FSYNC : 0), idx->mode) < 0) goto on_error; diff --git a/src/util/filebuf.c b/src/util/filebuf.c index e014d43b25f..7afb76b88ec 100644 --- a/src/util/filebuf.c +++ b/src/util/filebuf.c @@ -302,11 +302,16 @@ int git_filebuf_open_withsize(git_filebuf *file, const char *path, int flags, mo } /* If we are hashing on-write, allocate a new hash context */ - if (flags & GIT_FILEBUF_HASH_CONTENTS) { + if (flags & GIT_FILEBUF_HASH_SHA1) { file->compute_digest = 1; if (git_hash_ctx_init(&file->digest, GIT_HASH_ALGORITHM_SHA1) < 0) goto cleanup; + } else if (flags & GIT_FILEBUF_HASH_SHA256) { + file->compute_digest = 1; + + if (git_hash_ctx_init(&file->digest, GIT_HASH_ALGORITHM_SHA256) < 0) + goto cleanup; } compression = flags >> GIT_FILEBUF_DEFLATE_SHIFT; diff --git a/src/util/filebuf.h b/src/util/filebuf.h index 4a61ae4e3bf..e23b9ed2adc 100644 --- a/src/util/filebuf.h +++ b/src/util/filebuf.h @@ -17,13 +17,14 @@ # define GIT_FILEBUF_THREADS #endif -#define GIT_FILEBUF_HASH_CONTENTS (1 << 0) -#define GIT_FILEBUF_APPEND (1 << 2) +#define GIT_FILEBUF_HASH_SHA1 (1 << 0) +#define GIT_FILEBUF_HASH_SHA256 (1 << 1) +#define GIT_FILEBUF_APPEND (1 << 2) #define GIT_FILEBUF_CREATE_LEADING_DIRS (1 << 3) -#define GIT_FILEBUF_TEMPORARY (1 << 4) -#define GIT_FILEBUF_DO_NOT_BUFFER (1 << 5) -#define GIT_FILEBUF_FSYNC (1 << 6) -#define GIT_FILEBUF_DEFLATE_SHIFT (7) +#define GIT_FILEBUF_TEMPORARY (1 << 4) +#define GIT_FILEBUF_DO_NOT_BUFFER (1 << 5) +#define GIT_FILEBUF_FSYNC (1 << 6) +#define GIT_FILEBUF_DEFLATE_SHIFT (7) #define GIT_FILELOCK_EXTENSION ".lock\0" #define GIT_FILELOCK_EXTLENGTH 6 @@ -91,4 +92,16 @@ int git_filebuf_hash(unsigned char *out, git_filebuf *file); int git_filebuf_flush(git_filebuf *file); int git_filebuf_stats(time_t *mtime, size_t *size, git_filebuf *file); +GIT_INLINE(int) git_filebuf_hash_flags(git_hash_algorithm_t algorithm) +{ + switch (algorithm) { + case GIT_HASH_ALGORITHM_SHA1: + return GIT_FILEBUF_HASH_SHA1; + case GIT_HASH_ALGORITHM_SHA256: + return GIT_FILEBUF_HASH_SHA256; + default: + return 0; + } +} + #endif From 523f893f6fac92e301b090b141b449183947e3b3 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Wed, 5 Apr 2023 10:39:01 +0100 Subject: [PATCH 207/608] index: add sha256 support --- examples/show-index.c | 4 + include/git2/index.h | 9 + src/libgit2/apply.c | 7 +- src/libgit2/index.c | 433 ++++-- src/libgit2/index.h | 15 +- src/libgit2/merge.c | 15 +- src/libgit2/repository.c | 3 +- src/libgit2/stash.c | 17 +- src/libgit2/tree-cache.c | 42 +- src/libgit2/tree-cache.h | 8 +- src/libgit2/tree.c | 2 +- tests/libgit2/checkout/index.c | 3 +- tests/libgit2/clone/nonetwork.c | 3 +- tests/libgit2/diff/index.c | 3 +- tests/libgit2/index/cache.c | 10 +- tests/libgit2/index/inmemory.c | 5 +- tests/libgit2/index/racy.c | 4 +- tests/libgit2/index/read_index.c | 12 +- tests/libgit2/index/tests.c | 30 +- tests/libgit2/index/tests256.c | 1169 +++++++++++++++++ tests/libgit2/object/tree/update.c | 13 +- tests/libgit2/repo/setters.c | 3 +- tests/libgit2/reset/hard.c | 3 +- tests/libgit2/status/worktree_init.c | 13 +- tests/libgit2/submodule/lookup.c | 3 +- tests/resources/git-sha256.index | Bin 0 -> 458900 bytes tests/resources/testrepo_256/.gitted/HEAD | 1 + tests/resources/testrepo_256/.gitted/config | 15 + .../testrepo_256/.gitted/description | 1 + tests/resources/testrepo_256/.gitted/index | Bin 0 -> 361 bytes .../testrepo_256/.gitted/info/exclude | 6 + .../resources/testrepo_256/.gitted/logs/HEAD | 1 + .../.gitted/logs/refs/heads/master | 1 + .../.gitted/logs/refs/remotes/origin/HEAD | 1 + ...925bdc34ccdab778bd1d824f5562aaa319c6c8f045 | Bin 0 -> 267 bytes ...6d13866742a9070b56fd0ba9ab8dff828fc36c1f78 | 1 + ...16acdd727ea9364f7d48c55afed2f7dd889804065b | Bin 0 -> 103 bytes ...fcd19f12cc38faf337d10ec03ef4363d1a86f63750 | Bin 0 -> 21 bytes ...ba8801fe9bda46b66593291f5b9f7cd5f8888af12f | 1 + ...7e8ddfc9c8c47820fab5615cc04d904989ce800498 | Bin 0 -> 64 bytes ...4acca4ce4e1ea8508dfd77c24cefd461b65cead09e | Bin 0 -> 92 bytes ...da9be93f4afc2279623bb5b36c9194a660b7623c24 | Bin 0 -> 236 bytes ...50334e36a8015a546f0740bea4505e10d81a946f61 | Bin 0 -> 162 bytes ...08d88e14af624bb07fced6390997a0fa6abdad950a | Bin 0 -> 143 bytes ...e50a12b15f26aace3718749624f008bde68670352a | Bin 0 -> 202 bytes ...8644c307e17d0afe29b55f6488398cb59f13feb2f2 | Bin 0 -> 238 bytes ...0efa0433ac0cbd2d44679f68f2df3a9ae7014cf2a8 | Bin 0 -> 19 bytes ...830c2134815a31d9629e6aa9773338fedaab90976b | 1 + ...f2f30d79af178374166daeceefbf11e2f058d30d60 | Bin 0 -> 21 bytes ...eeca6bfffd9a0fe641784db85de2eb0f57b7553869 | Bin 0 -> 106 bytes ...89aa396d10f71c69e168d5c48ea23de59734ec3ab1 | Bin 0 -> 38 bytes ...917e3db8fde0045ee66305fd5e634b0c793c536a1b | 1 + ...e3b1e9a7dcda1185436fe141f7749120a303721813 | Bin 0 -> 15 bytes ...31b132e66ef18f564d41efb055804ec1dd28efb3f5 | Bin 0 -> 28 bytes ...2170996ce459d39e3a441e9759b635b0bc4ecc43fd | Bin 0 -> 57 bytes ...8c22b7898baaa0eda205a21cafdcb7e0f94b07bb9b | Bin 0 -> 64 bytes ...44523eb1ddeeef4bce03e35864640b452f84d26848 | 1 + ...635ab9fbee66d65fe5dda47dd0ac5f01dd69a84c6f | 3 + ...39b79f964c293db8620d679ea3596673c8a326446e | Bin 0 -> 157 bytes ...492f1bf1fcdf5dca09dab24cf331e05111b4cfc1a3 | Bin 0 -> 24 bytes ...b8f436e3ca0a82b25eddefd237bf5a26a0441c2aa7 | Bin 0 -> 107 bytes ...e660a4d510603c3f36e782a1a32ebd0388db6411ed | Bin 0 -> 181 bytes ...8aeb2c7811556538e7673e4b325307c71685fbf5b6 | Bin 0 -> 108 bytes ...417f9d5ccaf22b877c5a4522b6d1d2b16090ee2f6f | Bin 0 -> 141 bytes ...bccadee60065d8664a9af7648a1455100c4f772e1c | 2 + ...da9b3179f2419717275e3bfd2055b303489dbbfa47 | 1 + ...908dc44452ed38911cffa54ccc06076f30a1ffb1bf | Bin 0 -> 108 bytes ...c5d3f23bac1dded688b2bd314cc32b7f157e100724 | 1 + ...0b96786ebaa9ee6535fb698ec01b5f7a800fa27cbe | Bin 0 -> 137 bytes ...c294c441d08b89b455903c0c14e9b16587fec081f5 | Bin 0 -> 188 bytes ...cddea4259aea6b2961eb0822bd2c0c3f6029030045 | Bin 0 -> 18 bytes ...db7fc3a850e94f8c5ac1d71b9afa365a89005aff54 | Bin 0 -> 221 bytes ...8cc3cf4602c270a369beebc7d0b67238897bbc426b | 1 + ...24297e83e4a285f58bf5eabb1db270351388603c95 | Bin 0 -> 244 bytes ...ea61f40c14bdfc5b101b60fde4f44b58dd06667640 | Bin 0 -> 63 bytes ...3fdeed5502fd56b182af01b7740d297a24459333c5 | Bin 0 -> 26 bytes ...a3497ade7f62d2cd818bf388775cfa721de4068ebd | Bin 0 -> 54 bytes ...4ebf05e11d9c591b04cfdaff7cc860310356d71827 | 1 + ...82c5c09c22053675e2db24ea6b4b28cc75e9c10890 | Bin 0 -> 37 bytes ...a7ab8c68929bdc91b69ad54ef94979b93eba3f6022 | Bin 0 -> 190 bytes ...157ee4aad97814279fe500340eb3465797cbd3be23 | Bin 0 -> 23 bytes ...444b12c412210e9689c17e51bfc318ce4bb4360f19 | Bin 0 -> 57 bytes ...aaa96359f304c3dc97e95f336269ed474ea846ada5 | Bin 0 -> 198 bytes ...411d955520e0375fcbbcc14b7636a70f7536c32ef6 | 2 + ...787c5e94ba024ac9a4f763cb1d9bfd8e63aa7f7269 | Bin 0 -> 182 bytes ...621f5a228cb33dc84192980ca426cf9ab2a48cb9f0 | Bin 0 -> 187 bytes ...abfa899655d1b00e6529101a40d42f6acb059dff9f | Bin 0 -> 21 bytes ...3d137b654c602721c469c1b0a58e7e95647a9cf1c0 | 3 + ...8e201abb820a414de03eb63c065b06a2ab37d3f5ca | 1 + ...d3d4a80ced03101555e1fd8913b3544026c0717d4f | Bin 0 -> 181 bytes ...a5d92b78e54493fdaa78f72268d4cc69b61d5feee1 | Bin 0 -> 21 bytes ...55e9cb3cb46e348fca3b9dba3db64f7c9f64b8a736 | Bin 0 -> 157 bytes ...441f0b3f387faeddde1b37d0ad2f3f6a63f5327978 | Bin 0 -> 192 bytes ...24c75107423d5773066922ea5e55eaeb6490979562 | Bin 0 -> 157 bytes ...6e7643653c03e7f91faa27b767e3eb8225f0f6.idx | Bin 0 -> 1336 bytes ...e7643653c03e7f91faa27b767e3eb8225f0f6.pack | Bin 0 -> 569 bytes ...791b9b270067124b2609019b74f33f256f33fa.idx | Bin 0 -> 66216 bytes ...91b9b270067124b2609019b74f33f256f33fa.pack | Bin 0 -> 562646 bytes ...80b24ee981cf102db76764c383f9b87935d0d3.idx | Bin 0 -> 1336 bytes ...0b24ee981cf102db76764c383f9b87935d0d3.pack | Bin 0 -> 612 bytes .../testrepo_256/.gitted/packed-refs | 27 + .../testrepo_256/.gitted/refs/heads/master | 1 + .../.gitted/refs/remotes/origin/HEAD | 1 + tests/resources/testrepo_256/README | 1 + tests/resources/testrepo_256/branch_file.txt | 2 + tests/resources/testrepo_256/new.txt | 1 + 106 files changed, 1704 insertions(+), 204 deletions(-) create mode 100644 tests/libgit2/index/tests256.c create mode 100644 tests/resources/git-sha256.index create mode 100644 tests/resources/testrepo_256/.gitted/HEAD create mode 100644 tests/resources/testrepo_256/.gitted/config create mode 100644 tests/resources/testrepo_256/.gitted/description create mode 100644 tests/resources/testrepo_256/.gitted/index create mode 100644 tests/resources/testrepo_256/.gitted/info/exclude create mode 100644 tests/resources/testrepo_256/.gitted/logs/HEAD create mode 100644 tests/resources/testrepo_256/.gitted/logs/refs/heads/master create mode 100644 tests/resources/testrepo_256/.gitted/logs/refs/remotes/origin/HEAD create mode 100644 tests/resources/testrepo_256/.gitted/objects/00/404e6179d86039bbc01a925bdc34ccdab778bd1d824f5562aaa319c6c8f045 create mode 100644 tests/resources/testrepo_256/.gitted/objects/01/18010feb81fe41b9df646d13866742a9070b56fd0ba9ab8dff828fc36c1f78 create mode 100644 tests/resources/testrepo_256/.gitted/objects/02/df938cfb169b0b6ba0dd16acdd727ea9364f7d48c55afed2f7dd889804065b create mode 100644 tests/resources/testrepo_256/.gitted/objects/05/f7b70a01b0ade8afa5a5fcd19f12cc38faf337d10ec03ef4363d1a86f63750 create mode 100644 tests/resources/testrepo_256/.gitted/objects/14/bd335f9d7188c778d44eba8801fe9bda46b66593291f5b9f7cd5f8888af12f create mode 100644 tests/resources/testrepo_256/.gitted/objects/17/9496410f66032c03bd2b7e8ddfc9c8c47820fab5615cc04d904989ce800498 create mode 100644 tests/resources/testrepo_256/.gitted/objects/19/0a1349522cc11f8682e34acca4ce4e1ea8508dfd77c24cefd461b65cead09e create mode 100644 tests/resources/testrepo_256/.gitted/objects/1b/4b74772bd83ff28bf44cda9be93f4afc2279623bb5b36c9194a660b7623c24 create mode 100644 tests/resources/testrepo_256/.gitted/objects/21/e1e1ebe45b2c1ef79ab050334e36a8015a546f0740bea4505e10d81a946f61 create mode 100644 tests/resources/testrepo_256/.gitted/objects/23/8a501cf11a036f2f248008d88e14af624bb07fced6390997a0fa6abdad950a create mode 100644 tests/resources/testrepo_256/.gitted/objects/26/149bf1ac4612f24b532ae50a12b15f26aace3718749624f008bde68670352a create mode 100644 tests/resources/testrepo_256/.gitted/objects/2d/b6069c27ca4c08b784048644c307e17d0afe29b55f6488398cb59f13feb2f2 create mode 100644 tests/resources/testrepo_256/.gitted/objects/33/e415b835a670bb5c3c760efa0433ac0cbd2d44679f68f2df3a9ae7014cf2a8 create mode 100644 tests/resources/testrepo_256/.gitted/objects/34/f79ad1c813b93d2ee11c830c2134815a31d9629e6aa9773338fedaab90976b create mode 100644 tests/resources/testrepo_256/.gitted/objects/36/eac24505d4c4405864ccf2f30d79af178374166daeceefbf11e2f058d30d60 create mode 100644 tests/resources/testrepo_256/.gitted/objects/39/bf1ac28cc3f8432ba7cfeeca6bfffd9a0fe641784db85de2eb0f57b7553869 create mode 100644 tests/resources/testrepo_256/.gitted/objects/3b/58565ee067f13349cd4f89aa396d10f71c69e168d5c48ea23de59734ec3ab1 create mode 100644 tests/resources/testrepo_256/.gitted/objects/43/e084a4599ca42c476919917e3db8fde0045ee66305fd5e634b0c793c536a1b create mode 100644 tests/resources/testrepo_256/.gitted/objects/47/3a0f4c3be8a93681a267e3b1e9a7dcda1185436fe141f7749120a303721813 create mode 100644 tests/resources/testrepo_256/.gitted/objects/4b/c142808884e472ee6cc331b132e66ef18f564d41efb055804ec1dd28efb3f5 create mode 100644 tests/resources/testrepo_256/.gitted/objects/4d/f8ed86acaac5dc82b5652170996ce459d39e3a441e9759b635b0bc4ecc43fd create mode 100644 tests/resources/testrepo_256/.gitted/objects/5a/2d5699fea33657b42ba98c22b7898baaa0eda205a21cafdcb7e0f94b07bb9b create mode 100644 tests/resources/testrepo_256/.gitted/objects/5c/a8959deb2b8327458e0344523eb1ddeeef4bce03e35864640b452f84d26848 create mode 100644 tests/resources/testrepo_256/.gitted/objects/5d/bb1fff5c0094b31b25b4635ab9fbee66d65fe5dda47dd0ac5f01dd69a84c6f create mode 100644 tests/resources/testrepo_256/.gitted/objects/61/489e9e831f1d9001084d39b79f964c293db8620d679ea3596673c8a326446e create mode 100644 tests/resources/testrepo_256/.gitted/objects/6d/5fd291bb0f67444e99ab492f1bf1fcdf5dca09dab24cf331e05111b4cfc1a3 create mode 100644 tests/resources/testrepo_256/.gitted/objects/70/30f925768d9beb65654ab8f436e3ca0a82b25eddefd237bf5a26a0441c2aa7 create mode 100644 tests/resources/testrepo_256/.gitted/objects/73/8ff86401dbc5af692c83e660a4d510603c3f36e782a1a32ebd0388db6411ed create mode 100644 tests/resources/testrepo_256/.gitted/objects/73/b4f3c4f3182e6c8dd2c98aeb2c7811556538e7673e4b325307c71685fbf5b6 create mode 100644 tests/resources/testrepo_256/.gitted/objects/7e/4633ae1b0e83503dbea4417f9d5ccaf22b877c5a4522b6d1d2b16090ee2f6f create mode 100644 tests/resources/testrepo_256/.gitted/objects/7e/9424c06052ca33bfc599bccadee60065d8664a9af7648a1455100c4f772e1c create mode 100644 tests/resources/testrepo_256/.gitted/objects/80/91b686de8bf697ef632dda9b3179f2419717275e3bfd2055b303489dbbfa47 create mode 100644 tests/resources/testrepo_256/.gitted/objects/81/55958bbda08eed88c8ac908dc44452ed38911cffa54ccc06076f30a1ffb1bf create mode 100644 tests/resources/testrepo_256/.gitted/objects/90/1505c3355518bee35475c5d3f23bac1dded688b2bd314cc32b7f157e100724 create mode 100644 tests/resources/testrepo_256/.gitted/objects/93/1093620e5f050e2127fb0b96786ebaa9ee6535fb698ec01b5f7a800fa27cbe create mode 100644 tests/resources/testrepo_256/.gitted/objects/94/ed253efa9e86fc636805c294c441d08b89b455903c0c14e9b16587fec081f5 create mode 100644 tests/resources/testrepo_256/.gitted/objects/96/c18f0297e38d01f4b2dacddea4259aea6b2961eb0822bd2c0c3f6029030045 create mode 100644 tests/resources/testrepo_256/.gitted/objects/9c/cfa556cd7f73b426a7bedb7fc3a850e94f8c5ac1d71b9afa365a89005aff54 create mode 100644 tests/resources/testrepo_256/.gitted/objects/9d/aab17c25f647d652c72c8cc3cf4602c270a369beebc7d0b67238897bbc426b create mode 100644 tests/resources/testrepo_256/.gitted/objects/a4/813ef6708e6011e8187224297e83e4a285f58bf5eabb1db270351388603c95 create mode 100644 tests/resources/testrepo_256/.gitted/objects/ab/ee32b3339d1566d75613ea61f40c14bdfc5b101b60fde4f44b58dd06667640 create mode 100644 tests/resources/testrepo_256/.gitted/objects/ae/a29dc305d40e362df25c3fdeed5502fd56b182af01b7740d297a24459333c5 create mode 100644 tests/resources/testrepo_256/.gitted/objects/b1/95873b48c824d995c974a3497ade7f62d2cd818bf388775cfa721de4068ebd create mode 100644 tests/resources/testrepo_256/.gitted/objects/b2/1c8c27a05a3f0bf9f0f44ebf05e11d9c591b04cfdaff7cc860310356d71827 create mode 100644 tests/resources/testrepo_256/.gitted/objects/b6/1b940a8cd979a32e005682c5c09c22053675e2db24ea6b4b28cc75e9c10890 create mode 100644 tests/resources/testrepo_256/.gitted/objects/b8/3624f6ac0995273c0034a7ab8c68929bdc91b69ad54ef94979b93eba3f6022 create mode 100644 tests/resources/testrepo_256/.gitted/objects/bd/f2066a28e11603a1af04157ee4aad97814279fe500340eb3465797cbd3be23 create mode 100644 tests/resources/testrepo_256/.gitted/objects/bf/a3b3b9a161d354e2254a444b12c412210e9689c17e51bfc318ce4bb4360f19 create mode 100644 tests/resources/testrepo_256/.gitted/objects/bf/cc4074ac517ed24d61b0aaa96359f304c3dc97e95f336269ed474ea846ada5 create mode 100644 tests/resources/testrepo_256/.gitted/objects/c2/58f010a08328a29cde33411d955520e0375fcbbcc14b7636a70f7536c32ef6 create mode 100644 tests/resources/testrepo_256/.gitted/objects/ca/31f7336e882a233a2943787c5e94ba024ac9a4f763cb1d9bfd8e63aa7f7269 create mode 100644 tests/resources/testrepo_256/.gitted/objects/cb/282e7c15fd8aeb2265cd621f5a228cb33dc84192980ca426cf9ab2a48cb9f0 create mode 100644 tests/resources/testrepo_256/.gitted/objects/cc/b5a03da85607c230d111abfa899655d1b00e6529101a40d42f6acb059dff9f create mode 100644 tests/resources/testrepo_256/.gitted/objects/cf/84e5be57f8d5d51f136d3d137b654c602721c469c1b0a58e7e95647a9cf1c0 create mode 100644 tests/resources/testrepo_256/.gitted/objects/d8/8b60d2641df3656381dc8e201abb820a414de03eb63c065b06a2ab37d3f5ca create mode 100644 tests/resources/testrepo_256/.gitted/objects/de/caff3051968d1f3a2defd3d4a80ced03101555e1fd8913b3544026c0717d4f create mode 100644 tests/resources/testrepo_256/.gitted/objects/eb/ead5965196dfaeab52b1a5d92b78e54493fdaa78f72268d4cc69b61d5feee1 create mode 100644 tests/resources/testrepo_256/.gitted/objects/f2/a108f86a3b4fd9ad75ed55e9cb3cb46e348fca3b9dba3db64f7c9f64b8a736 create mode 100644 tests/resources/testrepo_256/.gitted/objects/f2/c8da1a7c2eb49ff25c47441f0b3f387faeddde1b37d0ad2f3f6a63f5327978 create mode 100644 tests/resources/testrepo_256/.gitted/objects/f3/1459efb9367c5a19c9dd24c75107423d5773066922ea5e55eaeb6490979562 create mode 100644 tests/resources/testrepo_256/.gitted/objects/pack/pack-b87f1f214098b19ce092afb9ef6e7643653c03e7f91faa27b767e3eb8225f0f6.idx create mode 100644 tests/resources/testrepo_256/.gitted/objects/pack/pack-b87f1f214098b19ce092afb9ef6e7643653c03e7f91faa27b767e3eb8225f0f6.pack create mode 100644 tests/resources/testrepo_256/.gitted/objects/pack/pack-e2f07f30db7e480ea84a0e64ee791b9b270067124b2609019b74f33f256f33fa.idx create mode 100644 tests/resources/testrepo_256/.gitted/objects/pack/pack-e2f07f30db7e480ea84a0e64ee791b9b270067124b2609019b74f33f256f33fa.pack create mode 100644 tests/resources/testrepo_256/.gitted/objects/pack/pack-f72bbfa35af982c2a60735152c80b24ee981cf102db76764c383f9b87935d0d3.idx create mode 100644 tests/resources/testrepo_256/.gitted/objects/pack/pack-f72bbfa35af982c2a60735152c80b24ee981cf102db76764c383f9b87935d0d3.pack create mode 100644 tests/resources/testrepo_256/.gitted/packed-refs create mode 100644 tests/resources/testrepo_256/.gitted/refs/heads/master create mode 100644 tests/resources/testrepo_256/.gitted/refs/remotes/origin/HEAD create mode 100644 tests/resources/testrepo_256/README create mode 100644 tests/resources/testrepo_256/branch_file.txt create mode 100644 tests/resources/testrepo_256/new.txt diff --git a/examples/show-index.c b/examples/show-index.c index fb797e04beb..0a5e7d1a2e4 100644 --- a/examples/show-index.c +++ b/examples/show-index.c @@ -30,7 +30,11 @@ int lg2_show_index(git_repository *repo, int argc, char **argv) dirlen = strlen(dir); if (dirlen > 5 && strcmp(dir + dirlen - 5, "index") == 0) { +#ifdef GIT_EXPERIMENTAL_SHA256 + check_lg2(git_index_open(&index, dir, GIT_OID_SHA1), "could not open index", dir); +#else check_lg2(git_index_open(&index, dir), "could not open index", dir); +#endif } else { check_lg2(git_repository_open_ext(&repo, dir, 0, NULL), "could not open repository", dir); check_lg2(git_repository_index(&index, repo), "could not open repository index", NULL); diff --git a/include/git2/index.h b/include/git2/index.h index 981535dadad..6e806371bf4 100644 --- a/include/git2/index.h +++ b/include/git2/index.h @@ -184,7 +184,12 @@ typedef enum { * @param index_path the path to the index file in disk * @return 0 or an error code */ + +#ifdef GIT_EXPERIMENTAL_SHA256 +GIT_EXTERN(int) git_index_open(git_index **out, const char *index_path, git_oid_t oid_type); +#else GIT_EXTERN(int) git_index_open(git_index **out, const char *index_path); +#endif /** * Create an in-memory index object. @@ -197,7 +202,11 @@ GIT_EXTERN(int) git_index_open(git_index **out, const char *index_path); * @param out the pointer for the new index * @return 0 or an error code */ +#ifdef GIT_EXPERIMENTAL_SHA256 +GIT_EXTERN(int) git_index_new(git_index **out, git_oid_t oid_type); +#else GIT_EXTERN(int) git_index_new(git_index **out); +#endif /** * Free an existing index object. diff --git a/src/libgit2/apply.c b/src/libgit2/apply.c index 18304da4df7..6b55b812fa4 100644 --- a/src/libgit2/apply.c +++ b/src/libgit2/apply.c @@ -19,6 +19,7 @@ #include "zstream.h" #include "reader.h" #include "index.h" +#include "repository.h" #include "apply.h" typedef struct { @@ -644,7 +645,7 @@ int git_apply_to_tree( * put the current tree into the postimage as-is - the diff will * replace any entries contained therein */ - if ((error = git_index_new(&postimage)) < 0 || + if ((error = git_index__new(&postimage, repo->oid_type)) < 0 || (error = git_index_read_tree(postimage, preimage)) < 0 || (error = git_reader_for_index(&post_reader, repo, postimage)) < 0) goto done; @@ -851,8 +852,8 @@ int git_apply( * having the full repo index, so we will limit our checkout * to only write these files that were affected by the diff. */ - if ((error = git_index_new(&preimage)) < 0 || - (error = git_index_new(&postimage)) < 0 || + if ((error = git_index__new(&preimage, repo->oid_type)) < 0 || + (error = git_index__new(&postimage, repo->oid_type)) < 0 || (error = git_reader_for_index(&post_reader, repo, postimage)) < 0) goto done; diff --git a/src/libgit2/index.c b/src/libgit2/index.c index 6777f035812..9d919093be0 100644 --- a/src/libgit2/index.c +++ b/src/libgit2/index.c @@ -32,8 +32,6 @@ static int index_apply_to_wd_diff(git_index *index, int action, const git_strarr unsigned int flags, git_index_matched_path_cb cb, void *payload); -#define minimal_entry_size (offsetof(struct entry_short, path)) - static const size_t INDEX_HEADER_SIZE = 12; static const unsigned int INDEX_VERSION_NUMBER_DEFAULT = 2; @@ -65,7 +63,7 @@ struct entry_time { uint32_t nanoseconds; }; -struct entry_short { +struct entry_common { struct entry_time ctime; struct entry_time mtime; uint32_t dev; @@ -74,25 +72,35 @@ struct entry_short { uint32_t uid; uint32_t gid; uint32_t file_size; - unsigned char oid[GIT_OID_SHA1_SIZE]; - uint16_t flags; - char path[1]; /* arbitrary length */ }; -struct entry_long { - struct entry_time ctime; - struct entry_time mtime; - uint32_t dev; - uint32_t ino; - uint32_t mode; - uint32_t uid; - uint32_t gid; - uint32_t file_size; - unsigned char oid[GIT_OID_SHA1_SIZE]; - uint16_t flags; - uint16_t flags_extended; - char path[1]; /* arbitrary length */ -}; +#define entry_short(oid_size) \ + struct { \ + struct entry_common common; \ + unsigned char oid[oid_size]; \ + uint16_t flags; \ + char path[1]; /* arbitrary length */ \ + } + +#define entry_long(oid_size) \ + struct { \ + struct entry_common common; \ + unsigned char oid[oid_size]; \ + uint16_t flags; \ + uint16_t flags_extended; \ + char path[1]; /* arbitrary length */ \ + } + +typedef entry_short(GIT_OID_SHA1_SIZE) index_entry_short_sha1; +typedef entry_long(GIT_OID_SHA1_SIZE) index_entry_long_sha1; + +#ifdef GIT_EXPERIMENTAL_SHA256 +typedef entry_short(GIT_OID_SHA256_SIZE) index_entry_short_sha256; +typedef entry_long(GIT_OID_SHA256_SIZE) index_entry_long_sha256; +#endif + +#undef entry_short +#undef entry_long struct entry_srch_key { const char *path; @@ -115,12 +123,12 @@ struct reuc_entry_internal { bool git_index__enforce_unsaved_safety = false; /* local declarations */ -static int read_extension(size_t *read_len, git_index *index, const char *buffer, size_t buffer_size); +static int read_extension(size_t *read_len, git_index *index, size_t checksum_size, const char *buffer, size_t buffer_size); static int read_header(struct index_header *dest, const void *buffer); static int parse_index(git_index *index, const char *buffer, size_t buffer_size); static bool is_index_extended(git_index *index); -static int write_index(unsigned char checksum[GIT_HASH_SHA1_SIZE], size_t *checksum_size, git_index *index, git_filebuf *file); +static int write_index(unsigned char checksum[GIT_HASH_MAX_SIZE], size_t *checksum_size, git_index *index, git_filebuf *file); static void index_entry_free(git_index_entry *entry); static void index_entry_reuc_free(git_index_reuc_entry *reuc); @@ -401,7 +409,10 @@ void git_index__set_ignore_case(git_index *index, bool ignore_case) git_vector_sort(&index->reuc); } -int git_index_open(git_index **index_out, const char *index_path) +int git_index__open( + git_index **index_out, + const char *index_path, + git_oid_t oid_type) { git_index *index; int error = -1; @@ -411,6 +422,8 @@ int git_index_open(git_index **index_out, const char *index_path) index = git__calloc(1, sizeof(git_index)); GIT_ERROR_CHECK_ALLOC(index); + index->oid_type = oid_type; + if (git_pool_init(&index->tree_pool, 1) < 0) goto fail; @@ -451,10 +464,34 @@ int git_index_open(git_index **index_out, const char *index_path) return error; } +#ifdef GIT_EXPERIMENTAL_SHA256 +int git_index_open(git_index **index_out, const char *index_path, git_oid_t oid_type) +{ + return git_index__open(index_out, index_path, oid_type); +} +#else +int git_index_open(git_index **index_out, const char *index_path) +{ + return git_index__open(index_out, index_path, GIT_OID_SHA1); +} +#endif + +int git_index__new(git_index **out, git_oid_t oid_type) +{ + return git_index__open(out, NULL, oid_type); +} + +#ifdef GIT_EXPERIMENTAL_SHA256 +int git_index_new(git_index **out, git_oid_t oid_type) +{ + return git_index__new(out, oid_type); +} +#else int git_index_new(git_index **out) { - return git_index_open(out, NULL); + return git_index__new(out, GIT_OID_SHA1); } +#endif static void index_free(git_index *index) { @@ -620,8 +657,8 @@ static int compare_checksum(git_index *index) { int fd; ssize_t bytes_read; - unsigned char checksum[GIT_HASH_SHA1_SIZE]; - size_t checksum_size = GIT_HASH_SHA1_SIZE; + unsigned char checksum[GIT_HASH_MAX_SIZE]; + size_t checksum_size = git_oid_size(index->oid_type); if ((fd = p_open(index->index_file_path, O_RDONLY)) < 0) return fd; @@ -2306,6 +2343,7 @@ static int index_error_invalid(const char *message) static int read_reuc(git_index *index, const char *buffer, size_t size) { const char *endptr; + size_t oid_size = git_oid_size(index->oid_type); size_t len; int i; @@ -2354,16 +2392,16 @@ static int read_reuc(git_index *index, const char *buffer, size_t size) for (i = 0; i < 3; i++) { if (!lost->mode[i]) continue; - if (size < GIT_OID_SHA1_SIZE) { + if (size < oid_size) { index_entry_reuc_free(lost); return index_error_invalid("reading reuc entry oid"); } - if (git_oid__fromraw(&lost->oid[i], (const unsigned char *) buffer, GIT_OID_SHA1) < 0) + if (git_oid__fromraw(&lost->oid[i], (const unsigned char *) buffer, index->oid_type) < 0) return -1; - size -= GIT_OID_SHA1_SIZE; - buffer += GIT_OID_SHA1_SIZE; + size -= oid_size; + buffer += oid_size; } /* entry was read successfully - insert into reuc vector */ @@ -2433,73 +2471,157 @@ static int read_conflict_names(git_index *index, const char *buffer, size_t size return 0; } -static size_t index_entry_size(size_t path_len, size_t varint_len, uint32_t flags) +GIT_INLINE(size_t) index_entry_path_offset( + git_oid_t oid_type, + uint32_t flags) { + if (oid_type == GIT_OID_SHA1) + return (flags & GIT_INDEX_ENTRY_EXTENDED) ? + offsetof(index_entry_long_sha1, path) : + offsetof(index_entry_short_sha1, path); + +#ifdef GIT_EXPERIMENTAL_SHA256 + else if (oid_type == GIT_OID_SHA256) + return (flags & GIT_INDEX_ENTRY_EXTENDED) ? + offsetof(index_entry_long_sha256, path) : + offsetof(index_entry_short_sha256, path); +#endif + + git_error_set(GIT_ERROR_INTERNAL, "invalid oid type"); + return 0; +} + +GIT_INLINE(size_t) index_entry_flags_offset(git_oid_t oid_type) +{ + if (oid_type == GIT_OID_SHA1) + return offsetof(index_entry_long_sha1, flags_extended); + +#ifdef GIT_EXPERIMENTAL_SHA256 + else if (oid_type == GIT_OID_SHA256) + return offsetof(index_entry_long_sha256, flags_extended); +#endif + + git_error_set(GIT_ERROR_INTERNAL, "invalid oid type"); + return 0; +} + +static size_t index_entry_size( + size_t path_len, + size_t varint_len, + git_oid_t oid_type, + uint32_t flags) +{ + size_t offset, size; + + if (!(offset = index_entry_path_offset(oid_type, flags))) + return 0; + if (varint_len) { - if (flags & GIT_INDEX_ENTRY_EXTENDED) - return offsetof(struct entry_long, path) + path_len + 1 + varint_len; - else - return offsetof(struct entry_short, path) + path_len + 1 + varint_len; + if (GIT_ADD_SIZET_OVERFLOW(&size, offset, path_len) || + GIT_ADD_SIZET_OVERFLOW(&size, size, 1) || + GIT_ADD_SIZET_OVERFLOW(&size, size, varint_len)) + return 0; } else { -#define entry_size(type,len) ((offsetof(type, path) + (len) + 8) & ~7) - if (flags & GIT_INDEX_ENTRY_EXTENDED) - return entry_size(struct entry_long, path_len); - else - return entry_size(struct entry_short, path_len); -#undef entry_size + if (GIT_ADD_SIZET_OVERFLOW(&size, offset, path_len) || + GIT_ADD_SIZET_OVERFLOW(&size, size, 8)) + return 0; + + size &= ~7; } + + return size; } static int read_entry( git_index_entry **out, size_t *out_size, git_index *index, + size_t checksum_size, const void *buffer, size_t buffer_size, const char *last) { - size_t path_length, entry_size; + size_t path_length, path_offset, entry_size; const char *path_ptr; - struct entry_short source; + struct entry_common *source_common; + index_entry_short_sha1 source_sha1; +#ifdef GIT_EXPERIMENTAL_SHA256 + index_entry_short_sha256 source_sha256; +#endif git_index_entry entry = {{0}}; bool compressed = index->version >= INDEX_VERSION_NUMBER_COMP; char *tmp_path = NULL; - size_t checksum_size = GIT_HASH_SHA1_SIZE; + + size_t minimal_entry_size = index_entry_path_offset(index->oid_type, 0); if (checksum_size + minimal_entry_size > buffer_size) return -1; /* buffer is not guaranteed to be aligned */ - memcpy(&source, buffer, sizeof(struct entry_short)); - - entry.ctime.seconds = (git_time_t)ntohl(source.ctime.seconds); - entry.ctime.nanoseconds = ntohl(source.ctime.nanoseconds); - entry.mtime.seconds = (git_time_t)ntohl(source.mtime.seconds); - entry.mtime.nanoseconds = ntohl(source.mtime.nanoseconds); - entry.dev = ntohl(source.dev); - entry.ino = ntohl(source.ino); - entry.mode = ntohl(source.mode); - entry.uid = ntohl(source.uid); - entry.gid = ntohl(source.gid); - entry.file_size = ntohl(source.file_size); - entry.flags = ntohs(source.flags); - - if (git_oid__fromraw(&entry.id, source.oid, GIT_OID_SHA1) < 0) + switch (index->oid_type) { + case GIT_OID_SHA1: + source_common = &source_sha1.common; + memcpy(&source_sha1, buffer, sizeof(source_sha1)); + break; +#ifdef GIT_EXPERIMENTAL_SHA256 + case GIT_OID_SHA256: + source_common = &source_sha256.common; + memcpy(&source_sha256, buffer, sizeof(source_sha256)); + break; +#endif + default: + GIT_ASSERT(!"invalid oid type"); + } + + entry.ctime.seconds = (git_time_t)ntohl(source_common->ctime.seconds); + entry.ctime.nanoseconds = ntohl(source_common->ctime.nanoseconds); + entry.mtime.seconds = (git_time_t)ntohl(source_common->mtime.seconds); + entry.mtime.nanoseconds = ntohl(source_common->mtime.nanoseconds); + entry.dev = ntohl(source_common->dev); + entry.ino = ntohl(source_common->ino); + entry.mode = ntohl(source_common->mode); + entry.uid = ntohl(source_common->uid); + entry.gid = ntohl(source_common->gid); + entry.file_size = ntohl(source_common->file_size); + + switch (index->oid_type) { + case GIT_OID_SHA1: + if (git_oid__fromraw(&entry.id, source_sha1.oid, + GIT_OID_SHA1) < 0) + return -1; + entry.flags = ntohs(source_sha1.flags); + break; +#ifdef GIT_EXPERIMENTAL_SHA256 + case GIT_OID_SHA256: + if (git_oid__fromraw(&entry.id, source_sha256.oid, + GIT_OID_SHA256) < 0) + return -1; + entry.flags = ntohs(source_sha256.flags); + break; +#endif + default: + GIT_ASSERT(!"invalid oid type"); + } + + if (!(path_offset = index_entry_path_offset(index->oid_type, entry.flags))) return -1; + if (entry.flags & GIT_INDEX_ENTRY_EXTENDED) { uint16_t flags_raw; size_t flags_offset; - flags_offset = offsetof(struct entry_long, flags_extended); - memcpy(&flags_raw, (const char *) buffer + flags_offset, - sizeof(flags_raw)); + if (!(flags_offset = index_entry_flags_offset(index->oid_type))) + return -1; + + memcpy(&flags_raw, (const char *)buffer + flags_offset, sizeof(flags_raw)); flags_raw = ntohs(flags_raw); memcpy(&entry.flags_extended, &flags_raw, sizeof(flags_raw)); - path_ptr = (const char *) buffer + offsetof(struct entry_long, path); - } else - path_ptr = (const char *) buffer + offsetof(struct entry_short, path); + path_ptr = (const char *)buffer + path_offset; + } else { + path_ptr = (const char *)buffer + path_offset; + } if (!compressed) { path_length = entry.flags & GIT_INDEX_ENTRY_NAMEMASK; @@ -2511,12 +2633,12 @@ static int read_entry( path_end = memchr(path_ptr, '\0', buffer_size); if (path_end == NULL) - return -1; + return index_error_invalid("invalid path name"); path_length = path_end - path_ptr; } - entry_size = index_entry_size(path_length, 0, entry.flags); + entry_size = index_entry_size(path_length, 0, index->oid_type, entry.flags); entry.path = (char *)path_ptr; } else { size_t varint_len, last_len, prefix_len, suffix_len, path_len; @@ -2542,15 +2664,18 @@ static int read_entry( memcpy(tmp_path, last, prefix_len); memcpy(tmp_path + prefix_len, path_ptr + varint_len, suffix_len + 1); - entry_size = index_entry_size(suffix_len, varint_len, entry.flags); + + entry_size = index_entry_size(suffix_len, varint_len, index->oid_type, entry.flags); entry.path = tmp_path; } if (entry_size == 0) return -1; - if (checksum_size + entry_size > buffer_size) + if (checksum_size + entry_size > buffer_size) { + git_error_set(GIT_ERROR_INTERNAL, "invalid index checksum"); return -1; + } if (index_entry_dup(out, index, &entry) < 0) { git__free(tmp_path); @@ -2579,11 +2704,10 @@ static int read_header(struct index_header *dest, const void *buffer) return 0; } -static int read_extension(size_t *read_len, git_index *index, const char *buffer, size_t buffer_size) +static int read_extension(size_t *read_len, git_index *index, size_t checksum_size, const char *buffer, size_t buffer_size) { struct index_extension dest; size_t total_size; - size_t checksum_size = GIT_HASH_SHA1_SIZE; /* buffer is not guaranteed to be aligned */ memcpy(&dest, buffer, sizeof(struct index_extension)); @@ -2602,7 +2726,7 @@ static int read_extension(size_t *read_len, git_index *index, const char *buffer if (dest.signature[0] >= 'A' && dest.signature[0] <= 'Z') { /* tree cache */ if (memcmp(dest.signature, INDEX_EXT_TREECACHE_SIG, 4) == 0) { - if (git_tree_cache_read(&index->tree, buffer + 8, dest.extension_size, &index->tree_pool) < 0) + if (git_tree_cache_read(&index->tree, buffer + 8, dest.extension_size, index->oid_type, &index->tree_pool) < 0) return -1; } else if (memcmp(dest.signature, INDEX_EXT_UNMERGED_SIG, 4) == 0) { if (read_reuc(index, buffer + 8, dest.extension_size) < 0) @@ -2630,8 +2754,8 @@ static int parse_index(git_index *index, const char *buffer, size_t buffer_size) int error = 0; unsigned int i; struct index_header header = { 0 }; - unsigned char checksum[GIT_HASH_SHA1_SIZE]; - size_t checksum_size = GIT_HASH_SHA1_SIZE; + unsigned char checksum[GIT_HASH_MAX_SIZE]; + size_t checksum_size = git_hash_size(git_oid_algorithm(index->oid_type)); const char *last = NULL; const char *empty = ""; @@ -2646,9 +2770,12 @@ static int parse_index(git_index *index, const char *buffer, size_t buffer_size) if (buffer_size < INDEX_HEADER_SIZE + checksum_size) return index_error_invalid("insufficient buffer space"); - /* Precalculate the SHA1 of the files's contents -- we'll match it to - * the provided SHA1 in the footer */ - git_hash_buf(checksum, buffer, buffer_size - checksum_size, GIT_HASH_ALGORITHM_SHA1); + /* + * Precalculate the hash of the files's contents -- we'll match + * it to the provided checksum in the footer. + */ + git_hash_buf(checksum, buffer, buffer_size - checksum_size, + git_oid_algorithm(index->oid_type)); /* Parse header */ if ((error = read_header(&header, buffer)) < 0) @@ -2670,7 +2797,7 @@ static int parse_index(git_index *index, const char *buffer, size_t buffer_size) git_index_entry *entry = NULL; size_t entry_size; - if ((error = read_entry(&entry, &entry_size, index, buffer, buffer_size, last)) < 0) { + if ((error = read_entry(&entry, &entry_size, index, checksum_size, buffer, buffer_size, last)) < 0) { error = index_error_invalid("invalid entry"); goto done; } @@ -2701,7 +2828,7 @@ static int parse_index(git_index *index, const char *buffer, size_t buffer_size) while (buffer_size > checksum_size) { size_t extension_size; - if ((error = read_extension(&extension_size, index, buffer, buffer_size)) < 0) { + if ((error = read_extension(&extension_size, index, checksum_size, buffer, buffer_size)) < 0) { goto done; } @@ -2714,7 +2841,10 @@ static int parse_index(git_index *index, const char *buffer, size_t buffer_size) goto done; } - /* 160-bit SHA-1 over the content of the index file before this checksum. */ + /* + * SHA-1 or SHA-256 (depending on the repository's object format) + * over the content of the index file before this checksum. + */ if (memcmp(checksum, buffer, checksum_size) != 0) { error = index_error_invalid( "calculated checksum does not match expected"); @@ -2754,16 +2884,40 @@ static bool is_index_extended(git_index *index) return (extended > 0); } -static int write_disk_entry(git_filebuf *file, git_index_entry *entry, const char *last) +static int write_disk_entry( + git_index *index, + git_filebuf *file, + git_index_entry *entry, + const char *last) { void *mem = NULL; - struct entry_short ondisk; - size_t path_len, disk_size; + struct entry_common *ondisk_common; + size_t path_len, path_offset, disk_size; int varint_len = 0; char *path; const char *path_start = entry->path; size_t same_len = 0; + index_entry_short_sha1 ondisk_sha1; + index_entry_long_sha1 ondisk_ext_sha1; +#ifdef GIT_EXPERIMENTAL_SHA256 + index_entry_short_sha256 ondisk_sha256; + index_entry_long_sha256 ondisk_ext_sha256; +#endif + + switch (index->oid_type) { + case GIT_OID_SHA1: + ondisk_common = &ondisk_sha1.common; + break; +#ifdef GIT_EXPERIMENTAL_SHA256 + case GIT_OID_SHA256: + ondisk_common = &ondisk_sha256.common; + break; +#endif + default: + GIT_ASSERT(!"invalid oid type"); + } + path_len = ((struct entry_internal *)entry)->pathlen; if (last) { @@ -2780,9 +2934,9 @@ static int write_disk_entry(git_filebuf *file, git_index_entry *entry, const cha varint_len = git_encode_varint(NULL, 0, strlen(last) - same_len); } - disk_size = index_entry_size(path_len, varint_len, entry->flags); + disk_size = index_entry_size(path_len, varint_len, index->oid_type, entry->flags); - if (git_filebuf_reserve(file, &mem, disk_size) < 0) + if (!disk_size || git_filebuf_reserve(file, &mem, disk_size) < 0) return -1; memset(mem, 0x0, disk_size); @@ -2797,35 +2951,77 @@ static int write_disk_entry(git_filebuf *file, git_index_entry *entry, const cha * * In 2038 I will be either too dead or too rich to care about this */ - ondisk.ctime.seconds = htonl((uint32_t)entry->ctime.seconds); - ondisk.mtime.seconds = htonl((uint32_t)entry->mtime.seconds); - ondisk.ctime.nanoseconds = htonl(entry->ctime.nanoseconds); - ondisk.mtime.nanoseconds = htonl(entry->mtime.nanoseconds); - ondisk.dev = htonl(entry->dev); - ondisk.ino = htonl(entry->ino); - ondisk.mode = htonl(entry->mode); - ondisk.uid = htonl(entry->uid); - ondisk.gid = htonl(entry->gid); - ondisk.file_size = htonl((uint32_t)entry->file_size); - git_oid_raw_cpy(ondisk.oid, entry->id.id, GIT_OID_SHA1_SIZE); - ondisk.flags = htons(entry->flags); + ondisk_common->ctime.seconds = htonl((uint32_t)entry->ctime.seconds); + ondisk_common->mtime.seconds = htonl((uint32_t)entry->mtime.seconds); + ondisk_common->ctime.nanoseconds = htonl(entry->ctime.nanoseconds); + ondisk_common->mtime.nanoseconds = htonl(entry->mtime.nanoseconds); + ondisk_common->dev = htonl(entry->dev); + ondisk_common->ino = htonl(entry->ino); + ondisk_common->mode = htonl(entry->mode); + ondisk_common->uid = htonl(entry->uid); + ondisk_common->gid = htonl(entry->gid); + ondisk_common->file_size = htonl((uint32_t)entry->file_size); + + switch (index->oid_type) { + case GIT_OID_SHA1: + git_oid_raw_cpy(ondisk_sha1.oid, entry->id.id, GIT_OID_SHA1_SIZE); + ondisk_sha1.flags = htons(entry->flags); + break; +#ifdef GIT_EXPERIMENTAL_SHA256 + case GIT_OID_SHA256: + git_oid_raw_cpy(ondisk_sha256.oid, entry->id.id, GIT_OID_SHA256_SIZE); + ondisk_sha256.flags = htons(entry->flags); + break; +#endif + default: + GIT_ASSERT(!"invalid oid type"); + } + + path_offset = index_entry_path_offset(index->oid_type, entry->flags); if (entry->flags & GIT_INDEX_ENTRY_EXTENDED) { - const size_t path_offset = offsetof(struct entry_long, path); - struct entry_long ondisk_ext; - memcpy(&ondisk_ext, &ondisk, sizeof(struct entry_short)); - ondisk_ext.flags_extended = htons(entry->flags_extended & + struct entry_common *ondisk_ext; + uint16_t flags_extended = htons(entry->flags_extended & GIT_INDEX_ENTRY_EXTENDED_FLAGS); - memcpy(mem, &ondisk_ext, path_offset); - path = (char *)mem + path_offset; - disk_size -= path_offset; + + switch (index->oid_type) { + case GIT_OID_SHA1: + memcpy(&ondisk_ext_sha1, &ondisk_sha1, + sizeof(index_entry_short_sha1)); + ondisk_ext_sha1.flags_extended = flags_extended; + ondisk_ext = &ondisk_ext_sha1.common; + break; +#ifdef GIT_EXPERIMENTAL_SHA256 + case GIT_OID_SHA256: + memcpy(&ondisk_ext_sha256, &ondisk_sha256, + sizeof(index_entry_short_sha256)); + ondisk_ext_sha256.flags_extended = flags_extended; + ondisk_ext = &ondisk_ext_sha256.common; + break; +#endif + default: + GIT_ASSERT(!"invalid oid type"); + } + + memcpy(mem, ondisk_ext, path_offset); } else { - const size_t path_offset = offsetof(struct entry_short, path); - memcpy(mem, &ondisk, path_offset); - path = (char *)mem + path_offset; - disk_size -= path_offset; + switch (index->oid_type) { + case GIT_OID_SHA1: + memcpy(mem, &ondisk_sha1, path_offset); + break; +#ifdef GIT_EXPERIMENTAL_SHA256 + case GIT_OID_SHA256: + memcpy(mem, &ondisk_sha256, path_offset); + break; +#endif + default: + GIT_ASSERT(!"invalid oid type"); + } } + path = (char *)mem + path_offset; + disk_size -= path_offset; + if (last) { varint_len = git_encode_varint((unsigned char *) path, disk_size, strlen(last) - same_len); @@ -2877,7 +3073,7 @@ static int write_entries(git_index *index, git_filebuf *file) last = ""; git_vector_foreach(entries, i, entry) { - if ((error = write_disk_entry(file, entry, last)) < 0) + if ((error = write_disk_entry(index, file, entry, last)) < 0) break; if (index->version >= INDEX_VERSION_NUMBER_COMP) last = entry->path; @@ -2955,8 +3151,9 @@ static int write_name_extension(git_index *index, git_filebuf *file) return error; } -static int create_reuc_extension_data(git_str *reuc_buf, git_index_reuc_entry *reuc) +static int create_reuc_extension_data(git_str *reuc_buf, git_index *index, git_index_reuc_entry *reuc) { + size_t oid_size = git_oid_size(index->oid_type); int i; int error = 0; @@ -2970,7 +3167,7 @@ static int create_reuc_extension_data(git_str *reuc_buf, git_index_reuc_entry *r } for (i = 0; i < 3; i++) { - if (reuc->mode[i] && (error = git_str_put(reuc_buf, (char *)&reuc->oid[i].id, GIT_OID_SHA1_SIZE)) < 0) + if (reuc->mode[i] && (error = git_str_put(reuc_buf, (char *)&reuc->oid[i].id, oid_size)) < 0) return error; } @@ -2987,7 +3184,7 @@ static int write_reuc_extension(git_index *index, git_filebuf *file) int error = 0; git_vector_foreach(out, i, reuc) { - if ((error = create_reuc_extension_data(&reuc_buf, reuc)) < 0) + if ((error = create_reuc_extension_data(&reuc_buf, index, reuc)) < 0) goto done; } @@ -3036,7 +3233,7 @@ static void clear_uptodate(git_index *index) } static int write_index( - unsigned char checksum[GIT_HASH_SHA1_SIZE], + unsigned char checksum[GIT_HASH_MAX_SIZE], size_t *checksum_size, git_index *index, git_filebuf *file) @@ -3048,7 +3245,9 @@ static int write_index( GIT_ASSERT_ARG(index); GIT_ASSERT_ARG(file); - *checksum_size = GIT_HASH_SHA1_SIZE; + GIT_ASSERT(index->oid_type); + + *checksum_size = git_hash_size(git_oid_algorithm(index->oid_type)); if (index->version <= INDEX_VERSION_NUMBER_EXT) { is_extended = is_index_extended(index); @@ -3209,7 +3408,7 @@ int git_index_read_tree(git_index *index, const git_tree *tree) if (error < 0) return error; - error = git_tree_cache_read_tree(&index->tree, tree, &index->tree_pool); + error = git_tree_cache_read_tree(&index->tree, tree, index->oid_type, &index->tree_pool); return error; } @@ -3674,7 +3873,7 @@ int git_indexwriter_init( writer->index = index; - filebuf_hash = git_filebuf_hash_flags(git_oid_algorithm(GIT_OID_SHA1)); + filebuf_hash = git_filebuf_hash_flags(git_oid_algorithm(index->oid_type)); GIT_ASSERT(filebuf_hash); if (!index->index_file_path) @@ -3716,7 +3915,7 @@ int git_indexwriter_init_for_operation( int git_indexwriter_commit(git_indexwriter *writer) { - unsigned char checksum[GIT_HASH_SHA1_SIZE]; + unsigned char checksum[GIT_HASH_MAX_SIZE]; size_t checksum_size; int error; diff --git a/src/libgit2/index.h b/src/libgit2/index.h index 71bb096f738..53c29977df7 100644 --- a/src/libgit2/index.h +++ b/src/libgit2/index.h @@ -27,7 +27,7 @@ struct git_index { char *index_file_path; git_futils_filestamp stamp; - unsigned char checksum[GIT_HASH_SHA1_SIZE]; + unsigned char checksum[GIT_HASH_MAX_SIZE]; git_vector entries; git_idxmap *entries_map; @@ -35,6 +35,8 @@ struct git_index { git_vector deleted; /* deleted entries if readers > 0 */ git_atomic32 readers; /* number of active iterators */ + git_oid_t oid_type; + unsigned int on_disk:1; unsigned int ignore_case:1; unsigned int distrust_filemode:1; @@ -141,6 +143,17 @@ GIT_INLINE(unsigned char *) git_index__checksum(git_index *index) return index->checksum; } +/* SHA256-aware internal functions */ + +extern int git_index__new( + git_index **index_out, + git_oid_t oid_type); + +extern int git_index__open( + git_index **index_out, + const char *index_path, + git_oid_t oid_type); + /* Copy the current entries vector *and* increment the index refcount. * Call `git_index__release_snapshot` when done. */ diff --git a/src/libgit2/merge.c b/src/libgit2/merge.c index df2cefb2930..9a52b9f786b 100644 --- a/src/libgit2/merge.c +++ b/src/libgit2/merge.c @@ -1997,8 +1997,11 @@ static int index_update_reuc(git_index *index, git_merge_diff_list *diff_list) return 0; } -static int index_from_diff_list(git_index **out, - git_merge_diff_list *diff_list, bool skip_reuc) +static int index_from_diff_list( + git_index **out, + git_merge_diff_list *diff_list, + git_oid_t oid_type, + bool skip_reuc) { git_index *index; size_t i; @@ -2007,7 +2010,7 @@ static int index_from_diff_list(git_index **out, *out = NULL; - if ((error = git_index_new(&index)) < 0) + if ((error = git_index__new(&index, oid_type)) < 0) return error; if ((error = git_index__fill(index, &diff_list->staged)) < 0) @@ -2157,7 +2160,7 @@ int git_merge__iterators( } } - error = index_from_diff_list(out, diff_list, + error = index_from_diff_list(out, diff_list, repo->oid_type, (opts.flags & GIT_MERGE_SKIP_REUC)); done: @@ -2200,8 +2203,8 @@ int git_merge_trees( result = our_tree; if (result) { - if ((error = git_index_new(out)) == 0) - error = git_index_read_tree(*out, result); + if ((error = git_index__new(out, repo->oid_type)) == 0) + error = git_index_read_tree(*out, result); return error; } diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index 3f57fb23cca..4bf92dcdca3 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -1547,7 +1547,8 @@ int git_repository_index__weakptr(git_index **out, git_repository *repo) if ((error = repository_index_path(&index_path, repo)) < 0) return error; - error = git_index_open(&index, index_path.ptr); + error = git_index__open(&index, index_path.ptr, repo->oid_type); + if (!error) { GIT_REFCOUNT_OWN(index, repo); diff --git a/src/libgit2/stash.c b/src/libgit2/stash.c index 319ae3a3f0c..b49e95cdb21 100644 --- a/src/libgit2/stash.c +++ b/src/libgit2/stash.c @@ -284,7 +284,7 @@ static int build_untracked_tree( struct stash_update_rules data = {0}; int error; - if ((error = git_index_new(&i_index)) < 0) + if ((error = git_index__new(&i_index, repo->oid_type)) < 0) goto cleanup; if (flags & GIT_STASH_INCLUDE_UNTRACKED) { @@ -487,7 +487,7 @@ static int commit_worktree( int error = 0, ignorecase; if ((error = git_repository_index(&r_index, repo) < 0) || - (error = git_index_new(&i_index)) < 0 || + (error = git_index__new(&i_index, repo->oid_type)) < 0 || (error = git_index__fill(i_index, &r_index->entries) < 0) || (error = git_repository__configmap_lookup(&ignorecase, repo, GIT_CONFIGMAP_IGNORECASE)) < 0) goto cleanup; @@ -732,7 +732,7 @@ int git_stash_save_with_opts( i_commit, b_commit, u_commit)) < 0) goto cleanup; } else { - if ((error = git_index_new(&paths_index)) < 0 || + if ((error = git_index__new(&paths_index, repo->oid_type)) < 0 || (error = retrieve_head(&head, repo)) < 0 || (error = git_reference_peel((git_object**)&tree, head, GIT_OBJECT_TREE)) < 0 || (error = git_index_read_tree(paths_index, tree)) < 0 || @@ -1003,6 +1003,7 @@ static int stage_new_file(const git_index_entry **entries, void *data) static int stage_new_files( git_index **out, + git_repository *repo, git_tree *parent_tree, git_tree *tree) { @@ -1011,7 +1012,7 @@ static int stage_new_files( git_index *index = NULL; int error; - if ((error = git_index_new(&index)) < 0 || + if ((error = git_index__new(&index, repo->oid_type)) < 0 || (error = git_iterator_for_tree( &iterators[0], parent_tree, &iterator_options)) < 0 || (error = git_iterator_for_tree( @@ -1095,10 +1096,10 @@ int git_stash_apply( * previously unstaged contents are staged, not the previously staged.) */ } else if ((opts.flags & GIT_STASH_APPLY_REINSTATE_INDEX) == 0) { - if ((error = stage_new_files( - &stash_adds, stash_parent_tree, stash_tree)) < 0 || - (error = merge_indexes( - &unstashed_index, repo, stash_parent_tree, repo_index, stash_adds)) < 0) + if ((error = stage_new_files(&stash_adds, repo, + stash_parent_tree, stash_tree)) < 0 || + (error = merge_indexes(&unstashed_index, repo, + stash_parent_tree, repo_index, stash_adds)) < 0) goto cleanup; } diff --git a/src/libgit2/tree-cache.c b/src/libgit2/tree-cache.c index 19fad85aea3..95d879860f1 100644 --- a/src/libgit2/tree-cache.c +++ b/src/libgit2/tree-cache.c @@ -71,12 +71,16 @@ const git_tree_cache *git_tree_cache_get(const git_tree_cache *tree, const char } } -static int read_tree_internal(git_tree_cache **out, - const char **buffer_in, const char *buffer_end, - git_pool *pool) +static int read_tree_internal( + git_tree_cache **out, + const char **buffer_in, + const char *buffer_end, + git_oid_t oid_type, + git_pool *pool) { git_tree_cache *tree = NULL; const char *name_start, *buffer; + size_t oid_size = git_oid_size(oid_type); int count; buffer = name_start = *buffer_in; @@ -87,7 +91,7 @@ static int read_tree_internal(git_tree_cache **out, if (++buffer >= buffer_end) goto corrupted; - if (git_tree_cache_new(&tree, name_start, pool) < 0) + if (git_tree_cache_new(&tree, name_start, oid_type, pool) < 0) return -1; /* Blank-terminated ASCII decimal number of entries in this tree */ @@ -108,14 +112,14 @@ static int read_tree_internal(git_tree_cache **out, if (*buffer != '\n' || ++buffer > buffer_end) goto corrupted; - /* The SHA1 is only there if it's not invalidated */ + /* The OID is only there if it's not invalidated */ if (tree->entry_count >= 0) { /* 160-bit SHA-1 for this tree and it's children */ - if (buffer + GIT_OID_SHA1_SIZE > buffer_end) + if (buffer + oid_size > buffer_end) goto corrupted; - git_oid__fromraw(&tree->oid, (const unsigned char *)buffer, GIT_OID_SHA1); - buffer += GIT_OID_SHA1_SIZE; + git_oid__fromraw(&tree->oid, (const unsigned char *)buffer, oid_type); + buffer += oid_size; } /* Parse children: */ @@ -130,7 +134,7 @@ static int read_tree_internal(git_tree_cache **out, memset(tree->children, 0x0, bufsize); for (i = 0; i < tree->children_count; ++i) { - if (read_tree_internal(&tree->children[i], &buffer, buffer_end, pool) < 0) + if (read_tree_internal(&tree->children[i], &buffer, buffer_end, oid_type, pool) < 0) goto corrupted; } } @@ -144,11 +148,16 @@ static int read_tree_internal(git_tree_cache **out, return -1; } -int git_tree_cache_read(git_tree_cache **tree, const char *buffer, size_t buffer_size, git_pool *pool) +int git_tree_cache_read( + git_tree_cache **tree, + const char *buffer, + size_t buffer_size, + git_oid_t oid_type, + git_pool *pool) { const char *buffer_end = buffer + buffer_size; - if (read_tree_internal(tree, &buffer, buffer_end, pool) < 0) + if (read_tree_internal(tree, &buffer, buffer_end, oid_type, pool) < 0) return -1; if (buffer < buffer_end) { @@ -201,7 +210,7 @@ static int read_tree_recursive(git_tree_cache *cache, const git_tree *tree, git_ continue; } - if ((error = git_tree_cache_new(&cache->children[j], git_tree_entry_name(entry), pool)) < 0) + if ((error = git_tree_cache_new(&cache->children[j], git_tree_entry_name(entry), cache->oid_type, pool)) < 0) return error; if ((error = git_tree_lookup(&subtree, repo, git_tree_entry_id(entry))) < 0) @@ -219,12 +228,12 @@ static int read_tree_recursive(git_tree_cache *cache, const git_tree *tree, git_ return 0; } -int git_tree_cache_read_tree(git_tree_cache **out, const git_tree *tree, git_pool *pool) +int git_tree_cache_read_tree(git_tree_cache **out, const git_tree *tree, git_oid_t oid_type, git_pool *pool) { int error; git_tree_cache *cache; - if ((error = git_tree_cache_new(&cache, "", pool)) < 0) + if ((error = git_tree_cache_new(&cache, "", oid_type, pool)) < 0) return error; if ((error = read_tree_recursive(cache, tree, pool)) < 0) @@ -234,7 +243,7 @@ int git_tree_cache_read_tree(git_tree_cache **out, const git_tree *tree, git_poo return 0; } -int git_tree_cache_new(git_tree_cache **out, const char *name, git_pool *pool) +int git_tree_cache_new(git_tree_cache **out, const char *name, git_oid_t oid_type, git_pool *pool) { size_t name_len, alloc_size; git_tree_cache *tree; @@ -248,6 +257,7 @@ int git_tree_cache_new(git_tree_cache **out, const char *name, git_pool *pool) memset(tree, 0x0, sizeof(git_tree_cache)); /* NUL-terminated tree name */ + tree->oid_type = oid_type; tree->namelen = name_len; memcpy(tree->name, name, name_len); tree->name[name_len] = '\0'; @@ -263,7 +273,7 @@ static void write_tree(git_str *out, git_tree_cache *tree) git_str_printf(out, "%s%c%"PRIdZ" %"PRIuZ"\n", tree->name, 0, tree->entry_count, tree->children_count); if (tree->entry_count != -1) - git_str_put(out, (char *)&tree->oid.id, GIT_OID_SHA1_SIZE); + git_str_put(out, (char *)&tree->oid.id, git_oid_size(tree->oid_type)); for (i = 0; i < tree->children_count; i++) write_tree(out, tree->children[i]); diff --git a/src/libgit2/tree-cache.h b/src/libgit2/tree-cache.h index a27e3046614..e4a73f277e0 100644 --- a/src/libgit2/tree-cache.h +++ b/src/libgit2/tree-cache.h @@ -18,6 +18,8 @@ typedef struct git_tree_cache { struct git_tree_cache **children; size_t children_count; + git_oid_t oid_type; + ssize_t entry_count; git_oid oid; size_t namelen; @@ -25,14 +27,14 @@ typedef struct git_tree_cache { } git_tree_cache; int git_tree_cache_write(git_str *out, git_tree_cache *tree); -int git_tree_cache_read(git_tree_cache **tree, const char *buffer, size_t buffer_size, git_pool *pool); +int git_tree_cache_read(git_tree_cache **tree, const char *buffer, size_t buffer_size, git_oid_t oid_type, git_pool *pool); void git_tree_cache_invalidate_path(git_tree_cache *tree, const char *path); const git_tree_cache *git_tree_cache_get(const git_tree_cache *tree, const char *path); -int git_tree_cache_new(git_tree_cache **out, const char *name, git_pool *pool); +int git_tree_cache_new(git_tree_cache **out, const char *name, git_oid_t oid_type, git_pool *pool); /** * Read a tree as the root of the tree cache (like for `git read-tree`) */ -int git_tree_cache_read_tree(git_tree_cache **out, const git_tree *tree, git_pool *pool); +int git_tree_cache_read_tree(git_tree_cache **out, const git_tree *tree, git_oid_t oid_type, git_pool *pool); void git_tree_cache_free(git_tree_cache *tree); #endif diff --git a/src/libgit2/tree.c b/src/libgit2/tree.c index 9293d9422ba..236a87f7e3e 100644 --- a/src/libgit2/tree.c +++ b/src/libgit2/tree.c @@ -731,7 +731,7 @@ int git_tree__write_index( return ret; /* Read the tree cache into the index */ - ret = git_tree_cache_read_tree(&index->tree, tree, &index->tree_pool); + ret = git_tree_cache_read_tree(&index->tree, tree, index->oid_type, &index->tree_pool); git_tree_free(tree); return ret; diff --git a/tests/libgit2/checkout/index.c b/tests/libgit2/checkout/index.c index 6432cba841d..3dfdaa630ae 100644 --- a/tests/libgit2/checkout/index.c +++ b/tests/libgit2/checkout/index.c @@ -4,6 +4,7 @@ #include "git2/checkout.h" #include "futils.h" #include "repository.h" +#include "index.h" #include "remote.h" #include "repo/repo_helpers.h" @@ -834,7 +835,7 @@ void test_checkout_index__adding_conflict_removes_stage_0(void) git_index *new_index, *index; git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT; - cl_git_pass(git_index_new(&new_index)); + cl_git_pass(git_index__new(&new_index, GIT_OID_SHA1)); add_conflict(new_index, "new.txt"); cl_git_pass(git_checkout_index(g_repo, new_index, &opts)); diff --git a/tests/libgit2/clone/nonetwork.c b/tests/libgit2/clone/nonetwork.c index eab63363516..5316003f82a 100644 --- a/tests/libgit2/clone/nonetwork.c +++ b/tests/libgit2/clone/nonetwork.c @@ -5,6 +5,7 @@ #include "remote.h" #include "futils.h" #include "repository.h" +#include "index.h" #define LIVE_REPO_URL "git://github.com/libgit2/TestGitRepository" @@ -271,7 +272,7 @@ void test_clone_nonetwork__clone_tag_to_tree(void) stage = cl_git_sandbox_init("testrepo.git"); cl_git_pass(git_repository_odb(&odb, stage)); - cl_git_pass(git_index_new(&index)); + cl_git_pass(git_index__new(&index, GIT_OID_SHA1)); memset(&entry, 0, sizeof(git_index_entry)); entry.path = file_path; diff --git a/tests/libgit2/diff/index.c b/tests/libgit2/diff/index.c index 5773b748e10..b7866750bb3 100644 --- a/tests/libgit2/diff/index.c +++ b/tests/libgit2/diff/index.c @@ -1,5 +1,6 @@ #include "clar_libgit2.h" #include "diff_helpers.h" +#include "index.h" static git_repository *g_repo = NULL; @@ -278,7 +279,7 @@ void test_diff_index__to_index(void) git_diff *diff; diff_expects exp; - cl_git_pass(git_index_new(&old_index)); + cl_git_pass(git_index__new(&old_index, GIT_OID_SHA1)); old_tree = resolve_commit_oid_to_tree(g_repo, a_commit); cl_git_pass(git_index_read_tree(old_index, old_tree)); diff --git a/tests/libgit2/index/cache.c b/tests/libgit2/index/cache.c index 7576331b014..77f19a50b29 100644 --- a/tests/libgit2/index/cache.c +++ b/tests/libgit2/index/cache.c @@ -24,7 +24,7 @@ void test_index_cache__write_extension_at_root(void) const char *tree_id_str = "45dd856fdd4d89b884c340ba0e047752d9b085d6"; const char *index_file = "index-tree"; - cl_git_pass(git_index_open(&index, index_file)); + cl_git_pass(git_index__open(&index, index_file, GIT_OID_SHA1)); cl_assert(index->tree == NULL); cl_git_pass(git_oid__fromstr(&id, tree_id_str, GIT_OID_SHA1)); cl_git_pass(git_tree_lookup(&tree, g_repo, &id)); @@ -35,7 +35,7 @@ void test_index_cache__write_extension_at_root(void) cl_git_pass(git_index_write(index)); git_index_free(index); - cl_git_pass(git_index_open(&index, index_file)); + cl_git_pass(git_index__open(&index, index_file, GIT_OID_SHA1)); cl_assert(index->tree); cl_assert_equal_i(git_index_entrycount(index), index->tree->entry_count); @@ -56,7 +56,7 @@ void test_index_cache__write_extension_invalidated_root(void) const char *index_file = "index-tree-invalidated"; git_index_entry entry; - cl_git_pass(git_index_open(&index, index_file)); + cl_git_pass(git_index__open(&index, index_file, GIT_OID_SHA1)); cl_assert(index->tree == NULL); cl_git_pass(git_oid__fromstr(&id, tree_id_str, GIT_OID_SHA1)); cl_git_pass(git_tree_lookup(&tree, g_repo, &id)); @@ -77,7 +77,7 @@ void test_index_cache__write_extension_invalidated_root(void) cl_git_pass(git_index_write(index)); git_index_free(index); - cl_git_pass(git_index_open(&index, index_file)); + cl_git_pass(git_index__open(&index, index_file, GIT_OID_SHA1)); cl_assert(index->tree); cl_assert_equal_i(-1, index->tree->entry_count); @@ -96,7 +96,7 @@ void test_index_cache__read_tree_no_children(void) git_tree *tree; git_oid id; - cl_git_pass(git_index_new(&index)); + cl_git_pass(git_index__new(&index, GIT_OID_SHA1)); cl_assert(index->tree == NULL); cl_git_pass(git_oid__fromstr(&id, "45dd856fdd4d89b884c340ba0e047752d9b085d6", GIT_OID_SHA1)); cl_git_pass(git_tree_lookup(&tree, g_repo, &id)); diff --git a/tests/libgit2/index/inmemory.c b/tests/libgit2/index/inmemory.c index 38e91e0fd94..39374af67bc 100644 --- a/tests/libgit2/index/inmemory.c +++ b/tests/libgit2/index/inmemory.c @@ -1,10 +1,11 @@ #include "clar_libgit2.h" +#include "index.h" void test_index_inmemory__can_create_an_inmemory_index(void) { git_index *index; - cl_git_pass(git_index_new(&index)); + cl_git_pass(git_index__new(&index, GIT_OID_SHA1)); cl_assert_equal_i(0, (int)git_index_entrycount(index)); git_index_free(index); @@ -14,7 +15,7 @@ void test_index_inmemory__cannot_add_bypath_to_an_inmemory_index(void) { git_index *index; - cl_git_pass(git_index_new(&index)); + cl_git_pass(git_index__new(&index, GIT_OID_SHA1)); cl_assert_equal_i(GIT_ERROR, git_index_add_bypath(index, "test.txt")); diff --git a/tests/libgit2/index/racy.c b/tests/libgit2/index/racy.c index 07b3b73d429..a1d6f9c6ec0 100644 --- a/tests/libgit2/index/racy.c +++ b/tests/libgit2/index/racy.c @@ -287,7 +287,7 @@ void test_index_racy__read_index_smudges(void) setup_race(); cl_git_pass(git_repository_index(&index, g_repo)); - cl_git_pass(git_index_new(&newindex)); + cl_git_pass(git_index__new(&newindex, GIT_OID_SHA1)); cl_git_pass(git_index_read_index(newindex, index)); cl_assert(entry = git_index_get_bypath(newindex, "A", 0)); @@ -305,7 +305,7 @@ void test_index_racy__read_index_clears_uptodate_bit(void) setup_uptodate_files(); cl_git_pass(git_repository_index(&index, g_repo)); - cl_git_pass(git_index_new(&newindex)); + cl_git_pass(git_index__new(&newindex, GIT_OID_SHA1)); cl_git_pass(git_index_read_index(newindex, index)); /* ensure that files brought in from the other index are not uptodate */ diff --git a/tests/libgit2/index/read_index.c b/tests/libgit2/index/read_index.c index ac03cf1773e..9c80be299f1 100644 --- a/tests/libgit2/index/read_index.c +++ b/tests/libgit2/index/read_index.c @@ -42,7 +42,7 @@ void test_index_read_index__maintains_stat_cache(void) /* read-tree, then read index */ git_tree_lookup(&tree, _repo, &index_id); - cl_git_pass(git_index_new(&new_index)); + cl_git_pass(git_index__new(&new_index, GIT_OID_SHA1)); cl_git_pass(git_index_read_tree(new_index, tree)); git_tree_free(tree); @@ -81,7 +81,7 @@ static bool roundtrip_with_read_index(const char *tree_idstr) cl_git_pass(git_oid__fromstr(&tree_id, tree_idstr, GIT_OID_SHA1)); cl_git_pass(git_tree_lookup(&tree, _repo, &tree_id)); - cl_git_pass(git_index_new(&tree_index)); + cl_git_pass(git_index__new(&tree_index, GIT_OID_SHA1)); cl_git_pass(git_index_read_tree(tree_index, tree)); cl_git_pass(git_index_read_index(_index, tree_index)); cl_git_pass(git_index_write_tree(&new_tree_id, _index)); @@ -113,12 +113,12 @@ void test_index_read_index__read_and_writes(void) cl_git_pass(git_oid__fromstr(&tree_id, "ae90f12eea699729ed24555e40b9fd669da12a12", GIT_OID_SHA1)); cl_git_pass(git_tree_lookup(&tree, _repo, &tree_id)); - cl_git_pass(git_index_new(&tree_index)); + cl_git_pass(git_index__new(&tree_index, GIT_OID_SHA1)); cl_git_pass(git_index_read_tree(tree_index, tree)); cl_git_pass(git_index_read_index(_index, tree_index)); cl_git_pass(git_index_write(_index)); - cl_git_pass(git_index_open(&new_index, git_index_path(_index))); + cl_git_pass(git_index__open(&new_index, git_index_path(_index), GIT_OID_SHA1)); cl_git_pass(git_index_write_tree_to(&new_tree_id, new_index, _repo)); cl_assert_equal_oid(&tree_id, &new_tree_id); @@ -174,8 +174,8 @@ void test_index_read_index__handles_conflicts(void) cl_git_pass(git_oid__fromstr(&tree_id, "ae90f12eea699729ed24555e40b9fd669da12a12", GIT_OID_SHA1)); cl_git_pass(git_tree_lookup(&tree, _repo, &tree_id)); - cl_git_pass(git_index_new(&index)); - cl_git_pass(git_index_new(&new_index)); + cl_git_pass(git_index__new(&index, GIT_OID_SHA1)); + cl_git_pass(git_index__new(&new_index, GIT_OID_SHA1)); cl_git_pass(git_index_read_tree(index, tree)); cl_git_pass(git_index_read_tree(new_index, tree)); diff --git a/tests/libgit2/index/tests.c b/tests/libgit2/index/tests.c index da3ff6dd7b5..b48eb0fc170 100644 --- a/tests/libgit2/index/tests.c +++ b/tests/libgit2/index/tests.c @@ -81,7 +81,7 @@ void test_index_tests__empty_index(void) { git_index *index; - cl_git_pass(git_index_open(&index, "in-memory-index")); + cl_git_pass(git_index__open(&index, "in-memory-index", GIT_OID_SHA1)); cl_assert(index->on_disk == 0); cl_assert(git_index_entrycount(index) == 0); @@ -96,7 +96,7 @@ void test_index_tests__default_test_index(void) unsigned int i; git_index_entry **entries; - cl_git_pass(git_index_open(&index, TEST_INDEX_PATH)); + cl_git_pass(git_index__open(&index, TEST_INDEX_PATH, GIT_OID_SHA1)); cl_assert(index->on_disk); cl_assert(git_index_entrycount(index) == index_entry_count); @@ -119,7 +119,7 @@ void test_index_tests__gitgit_index(void) { git_index *index; - cl_git_pass(git_index_open(&index, TEST_INDEX2_PATH)); + cl_git_pass(git_index__open(&index, TEST_INDEX2_PATH, GIT_OID_SHA1)); cl_assert(index->on_disk); cl_assert(git_index_entrycount(index) == index_entry_count_2); @@ -134,7 +134,7 @@ void test_index_tests__find_in_existing(void) git_index *index; unsigned int i; - cl_git_pass(git_index_open(&index, TEST_INDEX_PATH)); + cl_git_pass(git_index__open(&index, TEST_INDEX_PATH, GIT_OID_SHA1)); for (i = 0; i < ARRAY_SIZE(test_entries); ++i) { size_t idx; @@ -151,7 +151,7 @@ void test_index_tests__find_in_empty(void) git_index *index; unsigned int i; - cl_git_pass(git_index_open(&index, "fake-index")); + cl_git_pass(git_index__open(&index, "fake-index", GIT_OID_SHA1)); for (i = 0; i < ARRAY_SIZE(test_entries); ++i) { cl_assert(GIT_ENOTFOUND == git_index_find(NULL, index, test_entries[i].path)); @@ -166,7 +166,7 @@ void test_index_tests__find_prefix(void) const git_index_entry *entry; size_t pos; - cl_git_pass(git_index_open(&index, TEST_INDEX_PATH)); + cl_git_pass(git_index__open(&index, TEST_INDEX_PATH, GIT_OID_SHA1)); cl_git_pass(git_index_find_prefix(&pos, index, "src")); entry = git_index_get_byindex(index, pos); @@ -187,7 +187,7 @@ void test_index_tests__write(void) copy_file(TEST_INDEXBIG_PATH, "index_rewrite"); - cl_git_pass(git_index_open(&index, "index_rewrite")); + cl_git_pass(git_index__open(&index, "index_rewrite", GIT_OID_SHA1)); cl_assert(index->on_disk); cl_git_pass(git_index_write(index)); @@ -218,7 +218,7 @@ void test_index_tests__sort1(void) /* sort the entries in an empty index */ git_index *index; - cl_git_pass(git_index_open(&index, "fake-index")); + cl_git_pass(git_index__open(&index, "fake-index", GIT_OID_SHA1)); /* FIXME: this test is slightly dumb */ cl_assert(git_vector_is_sorted(&index->entries)); @@ -703,7 +703,7 @@ void test_index_tests__write_tree_invalid_unowned_index(void) git_index_entry entry = {{0}}; git_oid tree_id; - cl_git_pass(git_index_new(&idx)); + cl_git_pass(git_index__new(&idx, GIT_OID_SHA1)); cl_git_pass(git_oid__fromstr(&entry.id, "8312e0a89a9cbab77c732b6bc39b51a783e3a318", GIT_OID_SHA1)); entry.path = "foo"; @@ -966,7 +966,7 @@ void test_index_tests__reload_from_disk(void) cl_git_pass(git_repository_index(&write_index, repo)); cl_assert_equal_i(false, write_index->on_disk); - cl_git_pass(git_index_open(&read_index, write_index->index_file_path)); + cl_git_pass(git_index__open(&read_index, write_index->index_file_path, GIT_OID_SHA1)); cl_assert_equal_i(false, read_index->on_disk); /* Stage two new files against the write_index */ @@ -1004,7 +1004,7 @@ void test_index_tests__corrupted_extension(void) { git_index *index; - cl_git_fail_with(git_index_open(&index, TEST_INDEXBAD_PATH), GIT_ERROR); + cl_git_fail_with(git_index__open(&index, TEST_INDEXBAD_PATH, GIT_OID_SHA1), GIT_ERROR); } void test_index_tests__reload_while_ignoring_case(void) @@ -1012,7 +1012,7 @@ void test_index_tests__reload_while_ignoring_case(void) git_index *index; unsigned int caps; - cl_git_pass(git_index_open(&index, TEST_INDEX_PATH)); + cl_git_pass(git_index__open(&index, TEST_INDEX_PATH, GIT_OID_SHA1)); cl_git_pass(git_vector_verify_sorted(&index->entries)); caps = git_index_caps(index); @@ -1037,7 +1037,7 @@ void test_index_tests__change_icase_on_instance(void) unsigned int caps; const git_index_entry *e; - cl_git_pass(git_index_open(&index, TEST_INDEX_PATH)); + cl_git_pass(git_index__open(&index, TEST_INDEX_PATH, GIT_OID_SHA1)); cl_git_pass(git_vector_verify_sorted(&index->entries)); caps = git_index_caps(index); @@ -1093,7 +1093,7 @@ void test_index_tests__can_iterate(void) size_t i, iterator_idx = 0, found = 0; int ret; - cl_git_pass(git_index_open(&index, TEST_INDEX_PATH)); + cl_git_pass(git_index__open(&index, TEST_INDEX_PATH, GIT_OID_SHA1)); cl_git_pass(git_index_iterator_new(&iterator, index)); cl_assert(git_vector_is_sorted(&iterator->snap)); @@ -1136,7 +1136,7 @@ void test_index_tests__can_modify_while_iterating(void) size_t expected = 0, seen = 0; int ret; - cl_git_pass(git_index_open(&index, TEST_INDEX_PATH)); + cl_git_pass(git_index__open(&index, TEST_INDEX_PATH, GIT_OID_SHA1)); cl_git_pass(git_index_iterator_new(&iterator, index)); expected = git_index_entrycount(index); diff --git a/tests/libgit2/index/tests256.c b/tests/libgit2/index/tests256.c new file mode 100644 index 00000000000..fed8bfb9358 --- /dev/null +++ b/tests/libgit2/index/tests256.c @@ -0,0 +1,1169 @@ +#include "clar_libgit2.h" +#include "index.h" + +#ifdef GIT_EXPERIMENTAL_SHA256 + +static const size_t index_entry_count = 4344; +#define TEST_INDEX_PATH cl_fixture("git-sha256.index") + +static git_repository_init_options repo_init_opts = + GIT_REPOSITORY_INIT_OPTIONS_INIT; + +/* Suite data */ +struct test_entry { + size_t index; + char path[128]; + off64_t file_size; + git_time_t mtime; +}; + +static struct test_entry test_entries[] = { + { 892, "Makefile", 120084, 0x642c3a6e }, + { 1542, "git.c", 27432, 0x642c3a6e }, + { 1737, "perl/Git.pm", 48084, 0x642c3a6e }, + { 1961, "t/Makefile", 4711, 0x642c3a6e }, + { 4343, "zlib.c", 6271, 0x642c3a6f } +}; + +/* Helpers */ +static void copy_file(const char *src, const char *dst) +{ + git_str source_buf = GIT_STR_INIT; + git_file dst_fd; + + cl_git_pass(git_futils_readbuffer(&source_buf, src)); + + dst_fd = git_futils_creat_withpath(dst, 0777, 0666); /* -V536 */ + if (dst_fd < 0) + goto cleanup; + + cl_git_pass(p_write(dst_fd, source_buf.ptr, source_buf.size)); + +cleanup: + git_str_dispose(&source_buf); + p_close(dst_fd); +} + +static void files_are_equal(const char *a, const char *b) +{ + git_str buf_a = GIT_STR_INIT; + git_str buf_b = GIT_STR_INIT; + + if (git_futils_readbuffer(&buf_a, a) < 0) + cl_assert(0); + + if (git_futils_readbuffer(&buf_b, b) < 0) { + git_str_dispose(&buf_a); + cl_assert(0); + } + + cl_assert_equal_sz(buf_a.size, buf_b.size); + cl_assert(!memcmp(buf_a.ptr, buf_b.ptr, buf_a.size)); + + git_str_dispose(&buf_a); + git_str_dispose(&buf_b); +} + +#endif + +/* Fixture setup and teardown */ +void test_index_tests256__initialize(void) +{ +#ifdef GIT_EXPERIMENTAL_SHA256 + repo_init_opts.flags |= GIT_REPOSITORY_INIT_MKPATH; + repo_init_opts.oid_type = GIT_OID_SHA256; +#endif +} + +void test_index_tests256__cleanup(void) +{ +#ifdef GIT_EXPERIMENTAL_SHA256 + cl_git_pass(git_libgit2_opts(GIT_OPT_ENABLE_UNSAVED_INDEX_SAFETY, 0)); +#endif +} + +void test_index_tests256__empty_index(void) +{ +#ifdef GIT_EXPERIMENTAL_SHA256 + git_index *index; + + cl_git_pass(git_index__open(&index, "in-memory-index", GIT_OID_SHA256)); + cl_assert(index->on_disk == 0); + + cl_assert(git_index_entrycount(index) == 0); + cl_assert(git_vector_is_sorted(&index->entries)); + + git_index_free(index); +#endif +} + +void test_index_tests256__default_test_index(void) +{ +#ifdef GIT_EXPERIMENTAL_SHA256 + git_index *index; + unsigned int i; + git_index_entry **entries; + + cl_git_pass(git_index__open(&index, TEST_INDEX_PATH, GIT_OID_SHA256)); + cl_assert(index->on_disk); + + cl_assert_equal_sz(git_index_entrycount(index), index_entry_count); + cl_assert(git_vector_is_sorted(&index->entries)); + + entries = (git_index_entry **)index->entries.contents; + + for (i = 0; i < ARRAY_SIZE(test_entries); ++i) { + git_index_entry *e = entries[test_entries[i].index]; + + cl_assert_equal_s(e->path, test_entries[i].path); + cl_assert_equal_i(e->mtime.seconds, test_entries[i].mtime); + cl_assert_equal_i(e->file_size, test_entries[i].file_size); + } + + git_index_free(index); +#endif +} + +void test_index_tests256__find_in_existing(void) +{ +#ifdef GIT_EXPERIMENTAL_SHA256 + git_index *index; + unsigned int i; + + cl_git_pass(git_index__open(&index, TEST_INDEX_PATH, GIT_OID_SHA256)); + + for (i = 0; i < ARRAY_SIZE(test_entries); ++i) { + size_t idx; + + cl_assert(!git_index_find(&idx, index, test_entries[i].path)); + cl_assert(idx == test_entries[i].index); + } + + git_index_free(index); +#endif +} + +void test_index_tests256__find_in_empty(void) +{ +#ifdef GIT_EXPERIMENTAL_SHA256 + git_index *index; + unsigned int i; + + cl_git_pass(git_index__open(&index, "fake-index", GIT_OID_SHA256)); + + for (i = 0; i < ARRAY_SIZE(test_entries); ++i) { + cl_assert(GIT_ENOTFOUND == git_index_find(NULL, index, test_entries[i].path)); + } + + git_index_free(index); +#endif +} + +void test_index_tests256__find_prefix(void) +{ +#ifdef GIT_EXPERIMENTAL_SHA256 + git_index *index; + const git_index_entry *entry; + size_t pos; + + cl_git_pass(git_index__open(&index, TEST_INDEX_PATH, GIT_OID_SHA256)); + + cl_git_pass(git_index_find_prefix(&pos, index, "Documentation")); + entry = git_index_get_byindex(index, pos); + cl_assert(git__strcmp(entry->path, "Documentation/.gitattributes") == 0); + + cl_git_pass(git_index_find_prefix(&pos, index, "contrib/RE")); + entry = git_index_get_byindex(index, pos); + cl_assert(git__strcmp(entry->path, "contrib/README") == 0); + + cl_assert(GIT_ENOTFOUND == git_index_find_prefix(NULL, index, "blah")); + + git_index_free(index); +#endif +} + +void test_index_tests256__write(void) +{ +#ifdef GIT_EXPERIMENTAL_SHA256 + git_index *index; + + copy_file(TEST_INDEX_PATH, "index_rewrite"); + + cl_git_pass(git_index__open(&index, "index_rewrite", GIT_OID_SHA256)); + cl_assert(index->on_disk); + + cl_git_pass(git_index_write(index)); + files_are_equal(TEST_INDEX_PATH, "index_rewrite"); + + git_index_free(index); + + p_unlink("index_rewrite"); +#endif +} + +void test_index_tests256__sort1(void) +{ +#ifdef GIT_EXPERIMENTAL_SHA256 + /* sort the entries in an empty index */ + git_index *index; + + cl_git_pass(git_index__open(&index, "fake-index", GIT_OID_SHA256)); + + /* FIXME: this test is slightly dumb */ + cl_assert(git_vector_is_sorted(&index->entries)); + + git_index_free(index); +#endif +} + +#ifdef GIT_EXPERIMENTAL_SHA256 +static void cleanup_myrepo(void *opaque) +{ + GIT_UNUSED(opaque); + cl_fixture_cleanup("myrepo"); +} +#endif + +void test_index_tests256__add(void) +{ +#ifdef GIT_EXPERIMENTAL_SHA256 + git_index *index; + git_filebuf file = GIT_FILEBUF_INIT; + git_repository *repo; + const git_index_entry *entry; + git_oid id1; + + cl_set_cleanup(&cleanup_myrepo, NULL); + + /* Initialize a new repository */ + cl_git_pass(git_repository_init_ext(&repo, "./myrepo", &repo_init_opts)); + + /* Ensure we're the only guy in the room */ + cl_git_pass(git_repository_index(&index, repo)); + cl_assert(git_index_entrycount(index) == 0); + + /* Create a new file in the working directory */ + cl_git_pass(git_futils_mkpath2file("myrepo/test.txt", 0777)); + cl_git_pass(git_filebuf_open(&file, "myrepo/test.txt", 0, 0666)); + cl_git_pass(git_filebuf_write(&file, "hey there\n", 10)); + cl_git_pass(git_filebuf_commit(&file)); + + /* Store the expected hash of the file/blob + * This has been generated by executing the following + * $ echo "hey there" | git hash-object --stdin + */ + cl_git_pass(git_oid__fromstr(&id1, "aea29dc305d40e362df25c3fdeed5502fd56b182af01b7740d297a24459333c5", GIT_OID_SHA256)); + + /* Add the new file to the index */ + cl_git_pass(git_index_add_bypath(index, "test.txt")); + + /* Wow... it worked! */ + cl_assert(git_index_entrycount(index) == 1); + entry = git_index_get_byindex(index, 0); + + /* And the built-in hashing mechanism worked as expected */ + cl_assert_equal_oid(&id1, &entry->id); + + /* Test access by path instead of index */ + cl_assert((entry = git_index_get_bypath(index, "test.txt", 0)) != NULL); + cl_assert_equal_oid(&id1, &entry->id); + + git_index_free(index); + git_repository_free(repo); +#endif +} + +void test_index_tests256__add_frombuffer(void) +{ +#ifdef GIT_EXPERIMENTAL_SHA256 + git_index *index; + git_repository *repo; + git_index_entry entry; + const git_index_entry *returned_entry; + + git_oid id1; + git_blob *blob; + + const char *content = "hey there\n"; + + cl_set_cleanup(&cleanup_myrepo, NULL); + + /* Initialize a new repository */ + cl_git_pass(git_repository_init_ext(&repo, "./myrepo", &repo_init_opts)); + + /* Ensure we're the only guy in the room */ + cl_git_pass(git_repository_index(&index, repo)); + cl_assert(git_index_entrycount(index) == 0); + + /* Store the expected hash of the file/blob + * This has been generated by executing the following + * $ echo "hey there" | git hash-object --stdin + */ + cl_git_pass(git_oid__fromstr(&id1, "aea29dc305d40e362df25c3fdeed5502fd56b182af01b7740d297a24459333c5", GIT_OID_SHA256)); + + /* Add the new file to the index */ + memset(&entry, 0x0, sizeof(git_index_entry)); + entry.mode = GIT_FILEMODE_BLOB; + entry.path = "test.txt"; + cl_git_pass(git_index_add_from_buffer(index, &entry, + content, strlen(content))); + + /* Wow... it worked! */ + cl_assert(git_index_entrycount(index) == 1); + returned_entry = git_index_get_byindex(index, 0); + + /* And the built-in hashing mechanism worked as expected */ + cl_assert_equal_oid(&id1, &returned_entry->id); + /* And mode is the one asked */ + cl_assert_equal_i(GIT_FILEMODE_BLOB, returned_entry->mode); + + /* Test access by path instead of index */ + cl_assert((returned_entry = git_index_get_bypath(index, "test.txt", 0)) != NULL); + cl_assert_equal_oid(&id1, &returned_entry->id); + + /* Test the blob is in the repository */ + cl_git_pass(git_blob_lookup(&blob, repo, &id1)); + cl_assert_equal_s( + content, git_blob_rawcontent(blob)); + git_blob_free(blob); + + git_index_free(index); + git_repository_free(repo); +#endif +} + +void test_index_tests256__dirty_and_clean(void) +{ +#ifdef GIT_EXPERIMENTAL_SHA256 + git_repository *repo; + git_index *index; + git_index_entry entry = {{0}}; + + /* Index is not dirty after opening */ + cl_git_pass(git_repository_init_ext(&repo, "./myrepo", &repo_init_opts)); + cl_git_pass(git_repository_index(&index, repo)); + + cl_assert(git_index_entrycount(index) == 0); + cl_assert(!git_index_is_dirty(index)); + + /* Index is dirty after adding an entry */ + entry.mode = GIT_FILEMODE_BLOB; + entry.path = "test.txt"; + cl_git_pass(git_index_add_from_buffer(index, &entry, "Hi.\n", 4)); + cl_assert(git_index_entrycount(index) == 1); + cl_assert(git_index_is_dirty(index)); + + /* Index is not dirty after write */ + cl_git_pass(git_index_write(index)); + cl_assert(!git_index_is_dirty(index)); + + /* Index is dirty after removing an entry */ + cl_git_pass(git_index_remove_bypath(index, "test.txt")); + cl_assert(git_index_entrycount(index) == 0); + cl_assert(git_index_is_dirty(index)); + + /* Index is not dirty after write */ + cl_git_pass(git_index_write(index)); + cl_assert(!git_index_is_dirty(index)); + + /* Index remains not dirty after read */ + cl_git_pass(git_index_read(index, 0)); + cl_assert(!git_index_is_dirty(index)); + + /* Index is dirty when we do an unforced read with dirty content */ + cl_git_pass(git_index_add_from_buffer(index, &entry, "Hi.\n", 4)); + cl_assert(git_index_entrycount(index) == 1); + cl_assert(git_index_is_dirty(index)); + + cl_git_pass(git_index_read(index, 0)); + cl_assert(git_index_is_dirty(index)); + + /* Index is clean when we force a read with dirty content */ + cl_git_pass(git_index_read(index, 1)); + cl_assert(!git_index_is_dirty(index)); + + git_index_free(index); + git_repository_free(repo); +#endif +} + +void test_index_tests256__dirty_fails_optionally(void) +{ +#ifdef GIT_EXPERIMENTAL_SHA256 + git_repository *repo; + git_index *index; + git_index_entry entry = {{0}}; + + /* Index is not dirty after opening */ + repo = cl_git_sandbox_init("testrepo"); + cl_git_pass(git_repository_index(&index, repo)); + + /* Index is dirty after adding an entry */ + entry.mode = GIT_FILEMODE_BLOB; + entry.path = "test.txt"; + cl_git_pass(git_index_add_from_buffer(index, &entry, "Hi.\n", 4)); + cl_assert(git_index_is_dirty(index)); + + cl_git_pass(git_checkout_head(repo, NULL)); + + /* Index is dirty (again) after adding an entry */ + entry.mode = GIT_FILEMODE_BLOB; + entry.path = "test.txt"; + cl_git_pass(git_index_add_from_buffer(index, &entry, "Hi.\n", 4)); + cl_assert(git_index_is_dirty(index)); + + cl_git_pass(git_libgit2_opts(GIT_OPT_ENABLE_UNSAVED_INDEX_SAFETY, 1)); + cl_git_fail_with(GIT_EINDEXDIRTY, git_checkout_head(repo, NULL)); + + git_index_free(index); + cl_git_sandbox_cleanup(); +#endif +} + +void test_index_tests256__add_frombuffer_reset_entry(void) +{ +#ifdef GIT_EXPERIMENTAL_SHA256 + git_index *index; + git_repository *repo; + git_index_entry entry; + const git_index_entry *returned_entry; + git_filebuf file = GIT_FILEBUF_INIT; + + git_oid id1; + git_blob *blob; + const char *old_content = "here\n"; + const char *content = "hey there\n"; + + cl_set_cleanup(&cleanup_myrepo, NULL); + + /* Initialize a new repository */ + cl_git_pass(git_repository_init_ext(&repo, "./myrepo", &repo_init_opts)); + cl_git_pass(git_repository_index(&index, repo)); + cl_git_pass(git_futils_mkpath2file("myrepo/test.txt", 0777)); + cl_git_pass(git_filebuf_open(&file, "myrepo/test.txt", 0, 0666)); + cl_git_pass(git_filebuf_write(&file, old_content, strlen(old_content))); + cl_git_pass(git_filebuf_commit(&file)); + + /* Store the expected hash of the file/blob + * This has been generated by executing the following + * $ echo "hey there" | git hash-object --stdin + */ + cl_git_pass(git_oid__fromstr(&id1, "aea29dc305d40e362df25c3fdeed5502fd56b182af01b7740d297a24459333c5", GIT_OID_SHA256)); + + cl_git_pass(git_index_add_bypath(index, "test.txt")); + + /* Add the new file to the index */ + memset(&entry, 0x0, sizeof(git_index_entry)); + entry.mode = GIT_FILEMODE_BLOB; + entry.path = "test.txt"; + cl_git_pass(git_index_add_from_buffer(index, &entry, + content, strlen(content))); + + /* Wow... it worked! */ + cl_assert(git_index_entrycount(index) == 1); + returned_entry = git_index_get_byindex(index, 0); + + /* And the built-in hashing mechanism worked as expected */ + cl_assert_equal_oid(&id1, &returned_entry->id); + /* And mode is the one asked */ + cl_assert_equal_i(GIT_FILEMODE_BLOB, returned_entry->mode); + + /* Test access by path instead of index */ + cl_assert((returned_entry = git_index_get_bypath(index, "test.txt", 0)) != NULL); + cl_assert_equal_oid(&id1, &returned_entry->id); + cl_assert_equal_i(0, returned_entry->dev); + cl_assert_equal_i(0, returned_entry->ino); + cl_assert_equal_i(0, returned_entry->uid); + cl_assert_equal_i(0, returned_entry->uid); + cl_assert_equal_i(10, returned_entry->file_size); + + /* Test the blob is in the repository */ + cl_git_pass(git_blob_lookup(&blob, repo, &id1)); + cl_assert_equal_s(content, git_blob_rawcontent(blob)); + git_blob_free(blob); + + git_index_free(index); + git_repository_free(repo); +#endif +} + +void test_index_tests256__add_bypath_to_a_bare_repository_returns_EBAREPO(void) +{ +#ifdef GIT_EXPERIMENTAL_SHA256 + git_repository *bare_repo; + git_index *index; + + cl_git_pass(git_repository_open(&bare_repo, cl_fixture("testrepo.git"))); + cl_git_pass(git_repository_index(&index, bare_repo)); + + cl_assert_equal_i(GIT_EBAREREPO, git_index_add_bypath(index, "test.txt")); + + git_index_free(index); + git_repository_free(bare_repo); +#endif +} + +#ifdef GIT_EXPERIMENTAL_SHA256 +static void assert_add_bypath_fails(git_repository *repo, const char *fn) +{ + git_index *index; + git_str path = GIT_STR_INIT; + + cl_git_pass(git_repository_index(&index, repo)); + cl_assert(git_index_entrycount(index) == 0); + + git_str_joinpath(&path, "./invalid", fn); + + cl_git_mkfile(path.ptr, NULL); + cl_git_fail(git_index_add_bypath(index, fn)); + cl_must_pass(p_unlink(path.ptr)); + + cl_assert(git_index_entrycount(index) == 0); + + git_str_dispose(&path); + git_index_free(index); +} +#endif + +/* Test that writing an invalid filename fails */ +void test_index_tests256__cannot_add_invalid_filename(void) +{ +#ifdef GIT_EXPERIMENTAL_SHA256 + git_repository *repo; + + cl_must_pass(p_mkdir("invalid", 0700)); + cl_git_pass(git_repository_init_ext(&repo, "./invalid", &repo_init_opts)); + cl_must_pass(p_mkdir("./invalid/subdir", 0777)); + + /* cl_git_mkfile() needs the dir to exist */ + if (!git_fs_path_exists("./invalid/.GIT")) + cl_must_pass(p_mkdir("./invalid/.GIT", 0777)); + if (!git_fs_path_exists("./invalid/.GiT")) + cl_must_pass(p_mkdir("./invalid/.GiT", 0777)); + + assert_add_bypath_fails(repo, ".git/hello"); + assert_add_bypath_fails(repo, ".GIT/hello"); + assert_add_bypath_fails(repo, ".GiT/hello"); + assert_add_bypath_fails(repo, "./.git/hello"); + assert_add_bypath_fails(repo, "./foo"); + assert_add_bypath_fails(repo, "./bar"); + assert_add_bypath_fails(repo, "subdir/../bar"); + + git_repository_free(repo); + + cl_fixture_cleanup("invalid"); +#endif +} + +#ifdef GIT_EXPERIMENTAL_SHA256 +static void assert_add_fails(git_repository *repo, const char *fn) +{ + git_index *index; + git_str path = GIT_STR_INIT; + git_index_entry entry = {{0}}; + + cl_git_pass(git_repository_index(&index, repo)); + cl_assert(git_index_entrycount(index) == 0); + + entry.path = fn; + entry.mode = GIT_FILEMODE_BLOB; + cl_git_pass(git_oid__fromstr(&entry.id, "aea29dc305d40e362df25c3fdeed5502fd56b182af01b7740d297a24459333c5", GIT_OID_SHA256)); + + cl_git_fail(git_index_add(index, &entry)); + + cl_assert(git_index_entrycount(index) == 0); + + git_str_dispose(&path); + git_index_free(index); +} +#endif + +/* + * Test that writing an invalid filename fails on filesystem + * specific protected names + */ +void test_index_tests256__cannot_add_protected_invalid_filename(void) +{ +#ifdef GIT_EXPERIMENTAL_SHA256 + git_repository *repo; + git_index *index; + + cl_must_pass(p_mkdir("invalid", 0700)); + + cl_git_pass(git_repository_init(&repo, "./invalid", 0)); + + /* add a file to the repository so we can reference it later */ + cl_git_pass(git_repository_index(&index, repo)); + cl_git_mkfile("invalid/dummy.txt", ""); + cl_git_pass(git_index_add_bypath(index, "dummy.txt")); + cl_must_pass(p_unlink("invalid/dummy.txt")); + cl_git_pass(git_index_remove_bypath(index, "dummy.txt")); + git_index_free(index); + + cl_repo_set_bool(repo, "core.protectHFS", true); + cl_repo_set_bool(repo, "core.protectNTFS", true); + + assert_add_fails(repo, ".git./hello"); + assert_add_fails(repo, ".git\xe2\x80\xad/hello"); + assert_add_fails(repo, "git~1/hello"); + assert_add_fails(repo, ".git\xe2\x81\xaf/hello"); + assert_add_fails(repo, ".git::$INDEX_ALLOCATION/dummy-file"); + + git_repository_free(repo); + + cl_fixture_cleanup("invalid"); +#endif +} + +#ifdef GIT_EXPERIMENTAL_SHA256 +static void replace_char(char *str, char in, char out) +{ + char *c = str; + + while (*c++) + if (*c == in) + *c = out; +} + +static void assert_write_fails(git_repository *repo, const char *fn_orig) +{ + git_index *index; + git_oid expected; + const git_index_entry *entry; + git_str path = GIT_STR_INIT; + char *fn; + + cl_git_pass(git_repository_index(&index, repo)); + cl_assert(git_index_entrycount(index) == 0); + + /* + * Sneak a valid path into the index, we'll update it + * to an invalid path when we try to write the index. + */ + fn = git__strdup(fn_orig); + replace_char(fn, '/', '_'); + replace_char(fn, ':', '!'); + + git_str_joinpath(&path, "./invalid", fn); + + cl_git_mkfile(path.ptr, NULL); + + cl_git_pass(git_index_add_bypath(index, fn)); + + cl_assert(entry = git_index_get_bypath(index, fn, 0)); + + /* kids, don't try this at home */ + replace_char((char *)entry->path, '_', '/'); + replace_char((char *)entry->path, '!', ':'); + + /* write-tree */ + cl_git_fail(git_index_write_tree(&expected, index)); + + p_unlink(path.ptr); + + cl_git_pass(git_index_remove_all(index, NULL, NULL, NULL)); + git_str_dispose(&path); + git_index_free(index); + git__free(fn); +} +#endif + +void test_index_tests256__write_tree_invalid_unowned_index(void) +{ +#ifdef GIT_EXPERIMENTAL_SHA256 + git_index *idx; + git_repository *repo; + git_index_entry entry = {{0}}; + git_oid tree_id; + + cl_git_pass(git_index__new(&idx, GIT_OID_SHA256)); + + // TODO: this one is failing + cl_git_pass(git_oid__fromstr(&entry.id, "a8c2e0a89a9cbab77c732b6bc39b51a783e3a318a847f46cba7614cac9814291", GIT_OID_SHA256)); + entry.path = "foo"; + entry.mode = GIT_FILEMODE_BLOB; + cl_git_pass(git_index_add(idx, &entry)); + + cl_git_pass(git_repository_init_ext(&repo, "./invalid-id", &repo_init_opts)); + + cl_git_fail(git_index_write_tree_to(&tree_id, idx, repo)); + + git_index_free(idx); + git_repository_free(repo); + + cl_fixture_cleanup("invalid-id"); +#endif +} + +/* Test that writing an invalid filename fails */ +void test_index_tests256__write_invalid_filename(void) +{ +#ifdef GIT_EXPERIMENTAL_SHA256 + git_repository *repo; + + p_mkdir("invalid", 0700); + + cl_git_pass(git_repository_init(&repo, "./invalid", 0)); + + assert_write_fails(repo, ".git/hello"); + assert_write_fails(repo, ".GIT/hello"); + assert_write_fails(repo, ".GiT/hello"); + assert_write_fails(repo, "./.git/hello"); + assert_write_fails(repo, "./foo"); + assert_write_fails(repo, "./bar"); + assert_write_fails(repo, "foo/../bar"); + + git_repository_free(repo); + + cl_fixture_cleanup("invalid"); +#endif +} + +void test_index_tests256__honors_protect_filesystems(void) +{ +#ifdef GIT_EXPERIMENTAL_SHA256 + git_repository *repo; + + p_mkdir("invalid", 0700); + + cl_git_pass(git_repository_init(&repo, "./invalid", 0)); + + cl_repo_set_bool(repo, "core.protectHFS", true); + cl_repo_set_bool(repo, "core.protectNTFS", true); + + assert_write_fails(repo, ".git./hello"); + assert_write_fails(repo, ".git\xe2\x80\xad/hello"); + assert_write_fails(repo, "git~1/hello"); + assert_write_fails(repo, ".git\xe2\x81\xaf/hello"); + assert_write_fails(repo, ".git::$INDEX_ALLOCATION/dummy-file"); + + git_repository_free(repo); + + cl_fixture_cleanup("invalid"); +#endif +} + +void test_index_tests256__protectntfs_on_by_default(void) +{ +#ifdef GIT_EXPERIMENTAL_SHA256 + git_repository *repo; + + p_mkdir("invalid", 0700); + + cl_git_pass(git_repository_init(&repo, "./invalid", 0)); + assert_write_fails(repo, ".git./hello"); + assert_write_fails(repo, "git~1/hello"); + + git_repository_free(repo); + + cl_fixture_cleanup("invalid"); +#endif +} + +void test_index_tests256__can_disable_protectntfs(void) +{ +#ifdef GIT_EXPERIMENTAL_SHA256 + git_repository *repo; + git_index *index; + + cl_must_pass(p_mkdir("valid", 0700)); + cl_git_rewritefile("valid/git~1", "steal the shortname"); + + cl_git_pass(git_repository_init(&repo, "./valid", 0)); + cl_git_pass(git_repository_index(&index, repo)); + cl_repo_set_bool(repo, "core.protectNTFS", false); + + cl_git_pass(git_index_add_bypath(index, "git~1")); + + git_index_free(index); + git_repository_free(repo); + + cl_fixture_cleanup("valid"); +#endif +} + +void test_index_tests256__remove_entry(void) +{ +#ifdef GIT_EXPERIMENTAL_SHA256 + git_repository *repo; + git_index *index; + + p_mkdir("index_test", 0770); + + cl_git_pass(git_repository_init(&repo, "index_test", 0)); + cl_git_pass(git_repository_index(&index, repo)); + cl_assert(git_index_entrycount(index) == 0); + + cl_git_mkfile("index_test/hello", NULL); + cl_git_pass(git_index_add_bypath(index, "hello")); + cl_git_pass(git_index_write(index)); + + cl_git_pass(git_index_read(index, true)); /* reload */ + cl_assert(git_index_entrycount(index) == 1); + cl_assert(git_index_get_bypath(index, "hello", 0) != NULL); + + cl_git_pass(git_index_remove(index, "hello", 0)); + cl_git_pass(git_index_write(index)); + + cl_git_pass(git_index_read(index, true)); /* reload */ + cl_assert(git_index_entrycount(index) == 0); + cl_assert(git_index_get_bypath(index, "hello", 0) == NULL); + + git_index_free(index); + git_repository_free(repo); + cl_fixture_cleanup("index_test"); +#endif +} + +void test_index_tests256__remove_directory(void) +{ +#ifdef GIT_EXPERIMENTAL_SHA256 + git_repository *repo; + git_index *index; + + p_mkdir("index_test", 0770); + + cl_git_pass(git_repository_init(&repo, "index_test", 0)); + cl_git_pass(git_repository_index(&index, repo)); + cl_assert_equal_i(0, (int)git_index_entrycount(index)); + + p_mkdir("index_test/a", 0770); + cl_git_mkfile("index_test/a/1.txt", NULL); + cl_git_mkfile("index_test/a/2.txt", NULL); + cl_git_mkfile("index_test/a/3.txt", NULL); + cl_git_mkfile("index_test/b.txt", NULL); + + cl_git_pass(git_index_add_bypath(index, "a/1.txt")); + cl_git_pass(git_index_add_bypath(index, "a/2.txt")); + cl_git_pass(git_index_add_bypath(index, "a/3.txt")); + cl_git_pass(git_index_add_bypath(index, "b.txt")); + cl_git_pass(git_index_write(index)); + + cl_git_pass(git_index_read(index, true)); /* reload */ + cl_assert_equal_i(4, (int)git_index_entrycount(index)); + cl_assert(git_index_get_bypath(index, "a/1.txt", 0) != NULL); + cl_assert(git_index_get_bypath(index, "a/2.txt", 0) != NULL); + cl_assert(git_index_get_bypath(index, "b.txt", 0) != NULL); + + cl_git_pass(git_index_remove(index, "a/1.txt", 0)); + cl_git_pass(git_index_write(index)); + + cl_git_pass(git_index_read(index, true)); /* reload */ + cl_assert_equal_i(3, (int)git_index_entrycount(index)); + cl_assert(git_index_get_bypath(index, "a/1.txt", 0) == NULL); + cl_assert(git_index_get_bypath(index, "a/2.txt", 0) != NULL); + cl_assert(git_index_get_bypath(index, "b.txt", 0) != NULL); + + cl_git_pass(git_index_remove_directory(index, "a", 0)); + cl_git_pass(git_index_write(index)); + + cl_git_pass(git_index_read(index, true)); /* reload */ + cl_assert_equal_i(1, (int)git_index_entrycount(index)); + cl_assert(git_index_get_bypath(index, "a/1.txt", 0) == NULL); + cl_assert(git_index_get_bypath(index, "a/2.txt", 0) == NULL); + cl_assert(git_index_get_bypath(index, "b.txt", 0) != NULL); + + git_index_free(index); + git_repository_free(repo); + cl_fixture_cleanup("index_test"); +#endif +} + +void test_index_tests256__preserves_case(void) +{ +#ifdef GIT_EXPERIMENTAL_SHA256 + git_repository *repo; + git_index *index; + const git_index_entry *entry; + int index_caps; + + cl_set_cleanup(&cleanup_myrepo, NULL); + + cl_git_pass(git_repository_init_ext(&repo, "./myrepo", &repo_init_opts)); + cl_git_pass(git_repository_index(&index, repo)); + + index_caps = git_index_caps(index); + + cl_git_rewritefile("myrepo/test.txt", "hey there\n"); + cl_git_pass(git_index_add_bypath(index, "test.txt")); + + cl_git_pass(p_rename("myrepo/test.txt", "myrepo/TEST.txt")); + cl_git_rewritefile("myrepo/TEST.txt", "hello again\n"); + cl_git_pass(git_index_add_bypath(index, "TEST.txt")); + + if (index_caps & GIT_INDEX_CAPABILITY_IGNORE_CASE) + cl_assert_equal_i(1, (int)git_index_entrycount(index)); + else + cl_assert_equal_i(2, (int)git_index_entrycount(index)); + + /* Test access by path instead of index */ + cl_assert((entry = git_index_get_bypath(index, "test.txt", 0)) != NULL); + /* The path should *not* have changed without an explicit remove */ + cl_assert(git__strcmp(entry->path, "test.txt") == 0); + + cl_assert((entry = git_index_get_bypath(index, "TEST.txt", 0)) != NULL); + if (index_caps & GIT_INDEX_CAPABILITY_IGNORE_CASE) + /* The path should *not* have changed without an explicit remove */ + cl_assert(git__strcmp(entry->path, "test.txt") == 0); + else + cl_assert(git__strcmp(entry->path, "TEST.txt") == 0); + + git_index_free(index); + git_repository_free(repo); +#endif +} + +void test_index_tests256__elocked(void) +{ +#ifdef GIT_EXPERIMENTAL_SHA256 + git_repository *repo; + git_index *index; + git_filebuf file = GIT_FILEBUF_INIT; + const git_error *err; + int error; + + cl_set_cleanup(&cleanup_myrepo, NULL); + + cl_git_pass(git_repository_init_ext(&repo, "./myrepo", &repo_init_opts)); + cl_git_pass(git_repository_index(&index, repo)); + + /* Lock the index file so we fail to lock it */ + cl_git_pass(git_filebuf_open(&file, index->index_file_path, 0, 0666)); + error = git_index_write(index); + cl_assert_equal_i(GIT_ELOCKED, error); + + err = git_error_last(); + cl_assert_equal_i(err->klass, GIT_ERROR_INDEX); + + git_filebuf_cleanup(&file); + git_index_free(index); + git_repository_free(repo); +#endif +} + +void test_index_tests256__reload_from_disk(void) +{ +#ifdef GIT_EXPERIMENTAL_SHA256 + git_repository *repo; + git_index *read_index; + git_index *write_index; + + cl_set_cleanup(&cleanup_myrepo, NULL); + + cl_git_pass(git_futils_mkdir("./myrepo", 0777, GIT_MKDIR_PATH)); + cl_git_mkfile("./myrepo/a.txt", "a\n"); + cl_git_mkfile("./myrepo/b.txt", "b\n"); + + cl_git_pass(git_repository_init_ext(&repo, "./myrepo", &repo_init_opts)); + cl_git_pass(git_repository_index(&write_index, repo)); + cl_assert_equal_i(false, write_index->on_disk); + + cl_git_pass(git_index__open(&read_index, write_index->index_file_path, GIT_OID_SHA256)); + cl_assert_equal_i(false, read_index->on_disk); + + /* Stage two new files against the write_index */ + cl_git_pass(git_index_add_bypath(write_index, "a.txt")); + cl_git_pass(git_index_add_bypath(write_index, "b.txt")); + + cl_assert_equal_sz(2, git_index_entrycount(write_index)); + + /* Persist the index changes to disk */ + cl_git_pass(git_index_write(write_index)); + cl_assert_equal_i(true, write_index->on_disk); + + /* Sync the changes back into the read_index */ + cl_assert_equal_sz(0, git_index_entrycount(read_index)); + + cl_git_pass(git_index_read(read_index, true)); + cl_assert_equal_i(true, read_index->on_disk); + + cl_assert_equal_sz(2, git_index_entrycount(read_index)); + + /* Remove the index file from the filesystem */ + cl_git_pass(p_unlink(write_index->index_file_path)); + + /* Sync the changes back into the read_index */ + cl_git_pass(git_index_read(read_index, true)); + cl_assert_equal_i(false, read_index->on_disk); + cl_assert_equal_sz(0, git_index_entrycount(read_index)); + + git_index_free(read_index); + git_index_free(write_index); + git_repository_free(repo); +#endif +} + +void test_index_tests256__reload_while_ignoring_case(void) +{ +#ifdef GIT_EXPERIMENTAL_SHA256 + git_index *index; + unsigned int caps; + + cl_git_pass(git_index__open(&index, TEST_INDEX_PATH, GIT_OID_SHA256)); + cl_git_pass(git_vector_verify_sorted(&index->entries)); + + caps = git_index_caps(index); + cl_git_pass(git_index_set_caps(index, caps &= ~GIT_INDEX_CAPABILITY_IGNORE_CASE)); + cl_git_pass(git_index_read(index, true)); + cl_git_pass(git_vector_verify_sorted(&index->entries)); + cl_assert(git_index_get_bypath(index, "contrib/README", 0)); + cl_assert_equal_p(NULL, git_index_get_bypath(index, "CONTRIB/readme", 0)); + + cl_git_pass(git_index_set_caps(index, caps | GIT_INDEX_CAPABILITY_IGNORE_CASE)); + cl_git_pass(git_index_read(index, true)); + cl_git_pass(git_vector_verify_sorted(&index->entries)); + cl_assert(git_index_get_bypath(index, "contrib/README", 0)); + cl_assert(git_index_get_bypath(index, "CONTRIB/readme", 0)); + + git_index_free(index); +#endif +} + +void test_index_tests256__change_icase_on_instance(void) +{ +#ifdef GIT_EXPERIMENTAL_SHA256 + git_index *index; + unsigned int caps; + const git_index_entry *e; + + cl_git_pass(git_index__open(&index, TEST_INDEX_PATH, GIT_OID_SHA256)); + cl_git_pass(git_vector_verify_sorted(&index->entries)); + + caps = git_index_caps(index); + cl_git_pass(git_index_set_caps(index, caps &= ~GIT_INDEX_CAPABILITY_IGNORE_CASE)); + cl_assert_equal_i(false, index->ignore_case); + cl_git_pass(git_vector_verify_sorted(&index->entries)); + cl_assert(e = git_index_get_bypath(index, "contrib/README", 0)); + cl_assert_equal_p(NULL, e = git_index_get_bypath(index, "CONTRIB/readme", 0)); + cl_assert(e = git_index_get_bypath(index, "config.h", 0)); + cl_assert_equal_p(NULL, e = git_index_get_bypath(index, "CONFIG.H", 0)); + + cl_git_pass(git_index_set_caps(index, caps | GIT_INDEX_CAPABILITY_IGNORE_CASE)); + cl_assert_equal_i(true, index->ignore_case); + cl_git_pass(git_vector_verify_sorted(&index->entries)); + cl_assert(e = git_index_get_bypath(index, "config.h", 0)); + cl_assert_equal_s("config.h", e->path); + cl_assert(e = git_index_get_bypath(index, "CONFIG.H", 0)); + cl_assert_equal_s("config.h", e->path); + + git_index_free(index); +#endif +} + +void test_index_tests256__can_lock_index(void) +{ +#ifdef GIT_EXPERIMENTAL_SHA256 + git_repository *repo; + git_index *index; + git_indexwriter one = GIT_INDEXWRITER_INIT, + two = GIT_INDEXWRITER_INIT; + + repo = cl_git_sandbox_init("testrepo.git"); + + cl_git_pass(git_repository_index(&index, repo)); + cl_git_pass(git_indexwriter_init(&one, index)); + + cl_git_fail_with(GIT_ELOCKED, git_indexwriter_init(&two, index)); + cl_git_fail_with(GIT_ELOCKED, git_index_write(index)); + + cl_git_pass(git_indexwriter_commit(&one)); + + cl_git_pass(git_index_write(index)); + + git_indexwriter_cleanup(&one); + git_indexwriter_cleanup(&two); + git_index_free(index); + cl_git_sandbox_cleanup(); +#endif +} + +void test_index_tests256__can_iterate(void) +{ +#ifdef GIT_EXPERIMENTAL_SHA256 + git_index *index; + git_index_iterator *iterator; + const git_index_entry *entry; + size_t i, iterator_idx = 0, found = 0; + int ret; + + cl_git_pass(git_index__open(&index, TEST_INDEX_PATH, GIT_OID_SHA256)); + cl_git_pass(git_index_iterator_new(&iterator, index)); + + cl_assert(git_vector_is_sorted(&iterator->snap)); + + for (i = 0; i < ARRAY_SIZE(test_entries); i++) { + /* Advance iterator to next test entry index */ + do { + ret = git_index_iterator_next(&entry, iterator); + + if (ret == GIT_ITEROVER) + cl_fail("iterator did not contain all test entries"); + + cl_git_pass(ret); + } while (iterator_idx++ < test_entries[i].index); + + cl_assert_equal_s(entry->path, test_entries[i].path); + cl_assert_equal_i(entry->mtime.seconds, test_entries[i].mtime); + cl_assert_equal_i(entry->file_size, test_entries[i].file_size); + found++; + } + + while ((ret = git_index_iterator_next(&entry, iterator)) == 0) + ; + + if (ret != GIT_ITEROVER) + cl_git_fail(ret); + + cl_assert_equal_i(found, ARRAY_SIZE(test_entries)); + + git_index_iterator_free(iterator); + git_index_free(index); +#endif +} + +void test_index_tests256__can_modify_while_iterating(void) +{ +#ifdef GIT_EXPERIMENTAL_SHA256 + git_index *index; + git_index_iterator *iterator; + const git_index_entry *entry; + git_index_entry new_entry = {{0}}; + size_t expected = 0, seen = 0; + int ret; + + cl_git_pass(git_index__open(&index, TEST_INDEX_PATH, GIT_OID_SHA256)); + cl_git_pass(git_index_iterator_new(&iterator, index)); + + expected = git_index_entrycount(index); + cl_assert(git_vector_is_sorted(&iterator->snap)); + + /* + * After we've counted the entries, add a new one and change another; + * ensure that our iterator is backed by a snapshot and thus returns + * the number of entries from when the iterator was created. + */ + cl_git_pass(git_oid__fromstr(&new_entry.id, "8312e0a89a9cbab77c732b6bc39b51a783e3a318a847f46cba7614cac9814291", GIT_OID_SHA256)); + new_entry.path = "newfile"; + new_entry.mode = GIT_FILEMODE_BLOB; + cl_git_pass(git_index_add(index, &new_entry)); + + cl_git_pass(git_oid__fromstr(&new_entry.id, "4141414141414141414141414141414141414141414141414141414141414141", GIT_OID_SHA256)); + new_entry.path = "Makefile"; + new_entry.mode = GIT_FILEMODE_BLOB; + cl_git_pass(git_index_add(index, &new_entry)); + + while (true) { + ret = git_index_iterator_next(&entry, iterator); + + if (ret == GIT_ITEROVER) + break; + + seen++; + } + + cl_assert_equal_i(expected, seen); + + git_index_iterator_free(iterator); + git_index_free(index); +#endif +} diff --git a/tests/libgit2/object/tree/update.c b/tests/libgit2/object/tree/update.c index 1861ac838af..1e82bdcd621 100644 --- a/tests/libgit2/object/tree/update.c +++ b/tests/libgit2/object/tree/update.c @@ -1,5 +1,6 @@ #include "clar_libgit2.h" #include "tree.h" +#include "index.h" static git_repository *g_repo; @@ -28,7 +29,7 @@ void test_object_tree_update__remove_blob(void) cl_git_pass(git_tree_lookup(&base_tree, g_repo, &base_id)); /* Create it with an index */ - cl_git_pass(git_index_new(&idx)); + cl_git_pass(git_index__new(&idx, GIT_OID_SHA1)); cl_git_pass(git_index_read_tree(idx, base_tree)); cl_git_pass(git_index_remove(idx, path, 0)); cl_git_pass(git_index_write_tree_to(&tree_index_id, idx, g_repo)); @@ -57,7 +58,7 @@ void test_object_tree_update__remove_blob_deeper(void) cl_git_pass(git_tree_lookup(&base_tree, g_repo, &base_id)); /* Create it with an index */ - cl_git_pass(git_index_new(&idx)); + cl_git_pass(git_index__new(&idx, GIT_OID_SHA1)); cl_git_pass(git_index_read_tree(idx, base_tree)); cl_git_pass(git_index_remove(idx, path, 0)); cl_git_pass(git_index_write_tree_to(&tree_index_id, idx, g_repo)); @@ -88,7 +89,7 @@ void test_object_tree_update__remove_all_entries(void) cl_git_pass(git_tree_lookup(&base_tree, g_repo, &base_id)); /* Create it with an index */ - cl_git_pass(git_index_new(&idx)); + cl_git_pass(git_index__new(&idx, GIT_OID_SHA1)); cl_git_pass(git_index_read_tree(idx, base_tree)); cl_git_pass(git_index_remove(idx, path1, 0)); cl_git_pass(git_index_remove(idx, path2, 0)); @@ -119,7 +120,7 @@ void test_object_tree_update__replace_blob(void) cl_git_pass(git_tree_lookup(&base_tree, g_repo, &base_id)); /* Create it with an index */ - cl_git_pass(git_index_new(&idx)); + cl_git_pass(git_index__new(&idx, GIT_OID_SHA1)); cl_git_pass(git_index_read_tree(idx, base_tree)); entry.path = path; @@ -171,7 +172,7 @@ void test_object_tree_update__add_blobs(void) int j; /* Create it with an index */ - cl_git_pass(git_index_new(&idx)); + cl_git_pass(git_index__new(&idx, GIT_OID_SHA1)); base_tree = NULL; if (i == 1) { @@ -228,7 +229,7 @@ void test_object_tree_update__add_blobs_unsorted(void) int j; /* Create it with an index */ - cl_git_pass(git_index_new(&idx)); + cl_git_pass(git_index__new(&idx, GIT_OID_SHA1)); base_tree = NULL; if (i == 1) { diff --git a/tests/libgit2/repo/setters.c b/tests/libgit2/repo/setters.c index 66ec7706c2b..5c91ed39005 100644 --- a/tests/libgit2/repo/setters.c +++ b/tests/libgit2/repo/setters.c @@ -1,6 +1,7 @@ #include "clar_libgit2.h" #include "git2/sys/repository.h" +#include "index.h" #include "odb.h" #include "posix.h" #include "util.h" @@ -70,7 +71,7 @@ void test_repo_setters__setting_a_new_index_on_a_repo_which_has_already_loaded_o { git_index *new_index; - cl_git_pass(git_index_open(&new_index, "./my-index")); + cl_git_pass(git_index__open(&new_index, "./my-index", GIT_OID_SHA1)); cl_assert(((git_refcount *)new_index)->refcount.val == 1); git_repository_set_index(repo, new_index); diff --git a/tests/libgit2/reset/hard.c b/tests/libgit2/reset/hard.c index 0b6342cb2f8..06a8a049afc 100644 --- a/tests/libgit2/reset/hard.c +++ b/tests/libgit2/reset/hard.c @@ -3,6 +3,7 @@ #include "reset_helpers.h" #include "path.h" #include "futils.h" +#include "index.h" static git_repository *repo; static git_object *target; @@ -252,7 +253,7 @@ void test_reset_hard__switch_file_to_dir(void) git_odb_free(odb); entry.mode = GIT_FILEMODE_BLOB; - cl_git_pass(git_index_new(&idx)); + cl_git_pass(git_index__new(&idx, GIT_OID_SHA1)); cl_git_pass(git_signature_now(&sig, "foo", "bar")); /* Create the old tree */ diff --git a/tests/libgit2/status/worktree_init.c b/tests/libgit2/status/worktree_init.c index 40f1b2a3140..db6e71f1234 100644 --- a/tests/libgit2/status/worktree_init.c +++ b/tests/libgit2/status/worktree_init.c @@ -7,6 +7,7 @@ #include "posix.h" #include "util.h" #include "path.h" +#include "index.h" static void cleanup_new_repo(void *path) { @@ -65,7 +66,7 @@ void test_status_worktree_init__status_file_without_index_or_workdir(void) cl_git_pass(git_repository_open(&repo, cl_fixture("testrepo.git"))); cl_git_pass(git_repository_set_workdir(repo, "wd", false)); - cl_git_pass(git_index_open(&index, "empty-index")); + cl_git_pass(git_index__open(&index, "empty-index", GIT_OID_SHA1)); cl_assert_equal_i(0, (int)git_index_entrycount(index)); git_repository_set_index(repo, index); @@ -106,7 +107,7 @@ void test_status_worktree_init__status_file_with_clean_index_and_empty_workdir(v cl_git_pass(git_repository_open(&repo, cl_fixture("testrepo.git"))); cl_git_pass(git_repository_set_workdir(repo, "wd", false)); - cl_git_pass(git_index_open(&index, "my-index")); + cl_git_pass(git_index__open(&index, "my-index", GIT_OID_SHA1)); fill_index_wth_head_entries(repo, index); git_repository_set_index(repo, index); @@ -283,7 +284,7 @@ void test_status_worktree_init__disable_pathspec_match(void) { git_repository *repo; git_status_options opts = GIT_STATUS_OPTIONS_INIT; - char *file_with_bracket = "LICENSE[1].md", + char *file_with_bracket = "LICENSE[1].md", *imaginary_file_with_bracket = "LICENSE[1-2].md"; cl_set_cleanup(&cleanup_new_repo, "pathspec"); @@ -291,18 +292,18 @@ void test_status_worktree_init__disable_pathspec_match(void) cl_git_mkfile("pathspec/LICENSE[1].md", "screaming bracket\n"); cl_git_mkfile("pathspec/LICENSE1.md", "no bracket\n"); - opts.flags = GIT_STATUS_OPT_INCLUDE_UNTRACKED | + opts.flags = GIT_STATUS_OPT_INCLUDE_UNTRACKED | GIT_STATUS_OPT_DISABLE_PATHSPEC_MATCH; opts.pathspec.count = 1; opts.pathspec.strings = &file_with_bracket; cl_git_pass( - git_status_foreach_ext(repo, &opts, cb_status__expected_path, + git_status_foreach_ext(repo, &opts, cb_status__expected_path, file_with_bracket) ); /* Test passing a pathspec matching files in the workdir. */ - /* Must not match because pathspecs are disabled. */ + /* Must not match because pathspecs are disabled. */ opts.pathspec.strings = &imaginary_file_with_bracket; cl_git_pass( git_status_foreach_ext(repo, &opts, cb_status__expected_path, NULL) diff --git a/tests/libgit2/submodule/lookup.c b/tests/libgit2/submodule/lookup.c index acfdc838c26..febb7dfad7d 100644 --- a/tests/libgit2/submodule/lookup.c +++ b/tests/libgit2/submodule/lookup.c @@ -3,6 +3,7 @@ #include "git2/sys/repository.h" #include "repository.h" #include "futils.h" +#include "index.h" static git_repository *g_repo = NULL; @@ -210,7 +211,7 @@ void test_submodule_lookup__lookup_even_with_missing_index(void) git_index *idx; /* give the repo an empty index */ - cl_git_pass(git_index_new(&idx)); + cl_git_pass(git_index__new(&idx, GIT_OID_SHA1)); git_repository_set_index(g_repo, idx); git_index_free(idx); diff --git a/tests/resources/git-sha256.index b/tests/resources/git-sha256.index new file mode 100644 index 0000000000000000000000000000000000000000..84b5cabd998bea56e0902dce6eee57d8d4107e7f GIT binary patch literal 458900 zcmagnc{~;G`#D0>7!o8E?sFLVKcU-Ww=7*tuw5#6yKF-Yim{OHHg~^3AE#jab~hB?LAQ$}*e*4^T@r!!EiRY+I~tPB zy!0&!4>MmJJK}xk0@L0T%XWV#9*y&6BHMLy^$PY2bn)|b_wvARm*d$>bh}7`?b5*8 zB@Hd#(s}(4H^+5TL*LWjgx(Z{uk4OY;P|Rr_zA{(P;RTeZ;brIHbj z^Y8XOL!6~`%uFpUjI^yRjZ6)sd|dx^xD!WE2T9=2!w$*g8$W6&e56{mLe1x%TM6yn zH?d{M!RSXnjo!ub7l;gVZN&+!Ip$Wob~#$;?Xl9^Yw2jIx7&P|mZjc0h&mfR#?}&e zjIc+i6>HX*F;qs^^L1yh*6^3tR}`z9FGO%B9hSEaY(AEMQW7V+=7sqMdb=O?3k#BV z@pNa`(5cBabzd2H?f^j_m>mHWb?z?88+u!6cu$I7Kh8@K{TgLZTXdEzXpqEgUpclBW zZK9ND9P!(<^@5)lPx%$by8oZ!H_xv zb2dTf2#!_9Ojpm*Oy3ciLtQH!OE3}WcEwE2tR>h!2fTfw-9N)_L~ftD*C?>d(YND+ zPyQ(H==Sd1>vwz$C0$Rlm<8adbj-~6BcqMqE%@UoA;FGr7fG;PE_k~*7A@WolQXL} zIW~qPCvq8ZOVxcYfy>V<2X%LMDDI(m8OQPJ`niPoxcMUIC}f{V|2?Yzo~_XBOFG1^ zC2+V2oMAR8PbYz7ks`%<)|BmGmtzd?jW#s%>I{=#Jb&rgT-#Y3*Z(^IbtULaDR+0& zK@vDTu;bBqBy?0UpW)EOch!nHULvd7uYzI)1KRz8(f4 zUaoG3y?hDIzuRAVq8^gK+X#C*9VdONixiTk9lm~iM6zFNz@;_%to_#&dgrZegSCey z8lK=dU~jjRx0}1yVRY8k=S@MA0(FoC4lnF-hQNuPn&1lL|fpu7}DyPN5!>z~h5G|3}GbHhXKS zcf2qe*~mQ2`l>wI((VfFE&bzTk~eluG9kAE!v9~-%=wU;OYlCY!``R{j+^S37V04h zJbu_C|Df48T^~^E@ZG5Vg6FTxe)_~?Vva~+5J#~~-;^C_(@=nj(Dlw^vMyx!AcOvKv( zd79Q9sD~u*gkg`=DXuxsG*I|^SSlGMZ)c3hWTOPhLM15+w|bB^i&FZ#QX-x_N|*d3XrEA$%cAJ z0#Ag%8`D`-aJjLwaoe^P`<1$7hWIm9RN0${pQJq=)SeIP_PkBRQ-nO-YadY$N#KdX zo?(aACaJyAxrv23X4R&5+2_M^>^inRwVrJ?Gv4K+LqC#_6TqB@zoU-+hdTPg0c#1o zEwD!&9GQ6U{fKL*o8#`!CWozRXeNZG7g!u-aB379nIVnyn=$K?A(%e{l}D(DB=E#w zk1{Bi^~XVR%ex%B{Ye*Uqy4>aezB$Fn!GM>D_wm1^T$8Nh-s(+Wi8Y4_TrKYFs_c-v>;bE}M1jKw|S zqht+;90|Dbr!Jdg^@`Z{`?}>rkGtIOyA$!?`P(IR9rcg|-c|x{j&m;sQ$*zjHwOpN zqVimG{o~4MPIRR_NBia3YMk9aZY1Kt^S9eJ7xjpCo=ZKHd_mz&lwg z*EoNZ)AX{>QpB0>){?ae#|(*h@I08$y+G?j5_sETkBryDIbyM|N3v4zJXmmyq8^gKlOgbggfwk08CRRQF?y8oYh~03COw&% zp05)3C$)9fQ51asnn-={JnU8LMLi^eCrjYvzmgSrqZ9U~KIw~eL#pwTN!bfZue$89 zH>@wyxI3;}&Jpq8d9bYbhI&W>PY(8YA3WYZExCK=o|1c9+A1cQ!6jD?wcIylo?-l^ zAeil%#q$r|)6KmMc9A6!=)7|La?Nvb_V~v| zx+iD8oO8my9?22(=RPWYe$7QgV_PBzo_@$IL{r)|fIM(^h}{^~MpeBvAQ zQ-iuIe;?-ll#^Po5UtB*BllVYPXYGGVkF<*VCmpebnFjWo%Q&)P@G zq}#V?{jMkC!Tq`aav@jRl3EVo7nKtv-Gh1h9&SvXE^|^hQ6_fm|pMSCU(zaVN zBI3dQX-8d%dPo9K8TKg7Pt9+StPyZmp=Yx1`$?VnqrrmV`iUo1Gf8)*r5_p8W8V+T zNx|o9dp!lzLlSr@ut&LFbg%UOGl{G&zPu0Vr@2IuR}RFVKJ~FfHm~FOZR$LOw?yiL z@0T3*eMdbcfu{<4WK5=E(Qj%aFW)@1WzzEM`6FE3L3&agwjOWaqWr|_lC&H>DMU++#Z z?@qe->n)PN+X;K5^gRQg*qBC`n+~%`$?Pa3r?_-e^x@F~*`m%P_GZ~b{zI7c?I4(U z=hhyyJ|uys4to?!7PSI5oKvQ6J~ZR1=nKpo(jEA+l+*m6lR;ZKdNS$<6%h}fcbB*L z-$zISPXqSICS$&N|Hx!Lbn4{Y4w+VUJ=bDwH4nzOEj6Z0i|r2*d@RvU#d$+cGlHRILM|fy`L+zj!1p*ynCAZp&pXJ z(}F$fhSB2d0%;MI?P`9rPEM}&#u4{lU5|MA^75B7=B;#h9t9Ke;Cc6I@<%-+fu{|7 z6#0G(y!|^gn(dN*XQm`ACS;E@=ospU?)9URV6$oBe@#xrgXi7*Wh&|+2|VNhz`xJe zNUUSeFjBux-_E@C`Z8{k;X8Fl!ECj>NIn^B)xm;*xeLNXJb2!HesiE6lEBl2JtdoM zYNw4${QF%TTZ47-_q{G5RiM@?^QO=VPxrdCdgSm~%=ueCdSL$iH1XF5B!Q;~dlau3 z3u_a0lk0Xp+Xk|^?`wc|JiXN#G%m38CXBll{Tw zQ>^X&UYjp$KN2rcOY@cT?DR7ZFJu;+E_*XLW=+IfKck^e5Dx#m2T9-=!X7R~JkgWS z;g-kzv{LGjepqJ2d%e}M4Wc)mH@3a-@)w`_L&RG@f~Xg4fPYShB=C%2kECJmCGuqUQ>#OhzHMKNZ>f?A_+WW0?*oBQG`ZmWt>-B zh~%aqRff!RVCb8|G2NykA>8`vkF;8ec<}s%&OSpuB!OoFdwgXzDcZjuRZFtXKS(0| z^OT&0eDat>r(sp9;C{wh>Z!vAG3Q~uIxr7MSgxQRlEB*qdt}`6MT4Hxv4anL@Avg9 zi_b3GQcEkfzcgLWJKpTIP55IOW_=0-^AH}5e@=}g@OHx<#jTsRS{vWAZ?@gYc1*MP zvSYS+B`O*UOvi{r+-=bh zUQ`$RD0Vg+q^mNv-27gofQSdrLliCk`5BVHGlM-!5q}fO@T>ZznT+bP)}9#@y^%2i z7O!SKtGq|sHl!xeVBZfaNWt?EtzV4Rha~XKVUL`J(WYAIK@2x{GwY_3RRdWCkLtFV zy<#kbAGK37+1fWG6RB^#V^HU)DSjOkN#N~)JrZl&yP^$b?%j{{Uc54W86+0p)bQT* z-u9_ac0Nr4yhqbjh5PF=p{9W`p zPU&McH<_dhN-^hQT?6wFGf0nmNCIy!?2#AVwqB0&dBu?VfQKegBw$t-_e7>SY<~yI z_?dtsuRjKuVbrJaKhLjEP~)%fNCM9i_UO3y9)D1{rPrVls7x99>IU25WC^#u^vRp? zyd-K%N3);D67k@9h`WPd|3wmbRNKEYUm4??Yv{`@60vVA3SZc_12%5!_}TL zyru7mc!_b*P6V@N8g@{5l0K&-aI7FLuwp)*6$jn^2{qN|Y}2J#|!rG`GiLN7^b8 zZ@oiNC#44ed>2XJ?T5WBT3?4J6r(A2v6?+B;LmkT>k97nRb+@1dr>Z_@yR*qbv4F3 z{OwQpd2%W{e!Ue*;2nTHs{1eWY4Rv2Pu^E8r%t z^$|W#KI4tQ|3ngawy;O(DL5xo7rp%$w|6)7?Ytsoty_+=m6Zt+z8=Ef{a^F;krDCW zc}Tw+jP6$?foBJMWM;3%ac6$y9xT=IsP2wDAo%lYzWo*BktFM&V;^X(Moq2~@!)yL z*wTV}NCM9u_9&Gt_VT_Bc~5Dk{z>|q&!YE`cd^vtuXBw(v0nMN8Ipc{B;vvIkonaR z^^gRf1MG=esHo)yiCwr@vy9tr|N;@tSIy@)7A(^(-PD+%Gw_C8&oa@SI_f!a$~8 zwYw$5P4t@X#zUmHE_WIVoI9CN#Ua5Tr9p0U^${}>5AK&-dwbMF5_m4KM|xA3rS|;W zg0$$Sbg5q?d6VJ0ELX$tU73qj-S)v_X<0gehzFlPFH#kt9+JRAURV0}_X;O2O~tX| z%d;<;GHD}yv4cq_zqdPowtpdheNZ~tykOLGNb>FjJToIWEc9qyLo(W};wO$JGwRHBB!K{z)dFy4T9cX<>0?!@xsNV@J zWzGpGDJ{Rwk@jv?hzPe3j2rc+9II4R?9uBxzrUY|w_YLYWs97|>Vy09%F+kaLlStNut$E6&oYN|p6~?(Tlpz+b1ylWxYDkFU8vU=dDNr?-1-!1+L^-Gz^+>{frJ< zNMft?%Z=yOK0wMXTUcWG;%MH6#eychrFWs?>vx4>`OMoiEr*SkT?{e ze$)1z0v87f=_bzES5uaOB>C4g^oV%tdlYp_QxC5t@O%h7+C7_2?LIcbqT?mVdU{{E z0k_@E<{urJSM^&K-o3i>Rj`|g2lq=^KYslWN#Oay9;yBDsf1WD=0m4a*p7`Hp%1n* zV(hcvk$QZ4=M~SLn;C|&o`?MXH3py0D%=Ip`j7;kAMCMDag=@UW#3w^repHS{$;w( z`^E0F1FcV=hYf{Qy$;P{RKx7g_3A)>R;CM}9+JRA-j@6K_>qd7F#NvyG1_i1@}s@h zp$`%Dxlt#D8jjB0e;0aCU?4YO59aY6g#` zoQZ9SpV8_Q)s*v{Ec}bChx3SdaDU$Vgg<{G3A{kqqq*B}$M?R!-JRdU@QF{~+;BaA zW6)GWjO~Yy3}(Wn0#+PEJh(rr_Tc*yN#G&x2L8K0$(Md*vNReze7MWA&@1j)2yH-) z`o|p~H=I^VykT%slXlNGBHsEDMEB!e>eFipykOX)a`|21(^Rmkip>w1yE{Hgx z6+O9K=0|03j%gzi5B|MU{mKmWkOW>Rfk(D&h-Ihrt|n&=sg0FWV9KUQ7f!fi`c1Lx(3tq06@M;n1K$mWS@WV=W>!3+>!SwQx~deoAd$P4`Tuboix_)nlO+ z7T=}cW38|J_2BD6>pm-VeV?2-7KmDV~)mMi7XvRXCN6tv^cD5Gv^FLzx579y^gc^_fe1p-bn(l=bMdjf&9Er=uq2@Qw?4Dl<5~MU%sW+;plA+*u%ts z5$k#RUk|=MbXMZ;UyuY|9D&!ER+zrSRNT3}D>ZH}yIR*iMOVexOx)#Ct9{oF$h}>} zdf(=+2VWmvHoZaXL=t%Mu!nnnzh25%np^$%nQH>?m|rhGQtJ2JoDtGFvWt6Kw3U(Z zH<9B9Umv>FmrxH$;3dGG&`vY`H)140m8m8+7iyU(E1xjz*!@{?LuF93gI}VC1oAr9 z|NXw{-}>O^gFPkTsD~u*5@C<=%SDdMy9%uGbaFf-1T52eoHlxRDQaw#z1+3GbjQJ$ zR9Nr3DI%*!>ra?ar?(UT{REQ0OM*S}Z5O4pO0QaZ%TG5a<;Vq&H%_qi=Z@{lKfYyZ z#5=wI4c7hcUk^UN^iAzXT_k~b3ie1EBVH>G^lNN=Oigh~$u zZBn!Rj*MrY5uh@l94@ux9!yfK+O_`C*DKYxb_il@iTN`8^cJS@&W~NRVb=GmV zCC!b}!R!|qg7u?;y$h&^B=AyTk1m>VN2J3h28(O^sQFq?@9&;LFUK%Ljrv1Pj+nRBFsL(p5C8iCN#Lcy9=RZiGNahaz$V4lCkr0tvyA4ar)C~~DE^_{ znuR7HgQ1g^n74L8LcO=Wv}*~xbl4*~t@u7}R_KvmuSwr-(!kHbwvpNr1!@j-UEJp= zzs)&{RuJ>nE=Z^|67IW}z&i_j!di)K+NW%5uL`_xRhFdUsJoM~7+N!Y)#KxboUXG5 zEAd@8!TD+96KlYLh)vZ z4?DdEG4J306cQ5kMm;2fmj!#|8BBuNwwCvNCvTqRYP_PKwn|-|FexnIa8!foy;tvx zuU5pofBRENxMCIckOW>f>`~Ak8RP5vws^r)j%%i=qINTG6Su78=TEyW(>SE(d}RJ` z5cB@+PazR$bbaM-0`ENRF&u9Hbhj{rCG(nOV;Z&Ir4u|V*5{6GbIjuEd!K$_qW8Tc zF>mdL39U;s|M6M^?*i;m6@NY+YM1+*YnYL}A)du=*?dFO)eEDfL*x5oXtvDvg|ra! z)^3ezFjfz{`QX4JSNHsN)(g4Q;HObWGexb8y?hjylq0L9MIzuP~fw&4{nT zp1=Pt5U3~N$hDTh%Y{9Tk_NXDDS?MS21fj)bKLJO?6>#D6@?#s{G=mGYo>E^?gQ-l z{#!so9m)11YYDtO*rWVF!$hVZTBNGwZ@DaY;LInFAEnZ~H^Z}d3bSR7Zk?8zA?88z zw@pG9^^gSKMcAW|8E6en;pDh^D*VGUiOskB&u~Qa#vZ${osL49L{7xM{U9+9nm?&S z=<_TgB!PDc_DEam0@U>4rRc*y(Q=xnU6h-}J#(xMRQBQObD4V|5LVAk%!B4{J5?E4 zACkbk414SYG^ZpDq*e`j@_fk)4UW7hy6T&7IN;t*r3-)B)Z*hL4YB)WZExc5Cxm1) zhENYl;N`;}nW$O0VWKyayN;bx<=FX78FRTebQ?a^u#faOU5$U@x|0d>e(Aq(TsOJ+%twh9IYZttyV2-XI z2_Xr*LfFH-&eYi=cH8FEQTkuMCf>QZpWr+4KB8i-Dp^JQ3|nqlzcI^0wCAfr5DRq%W6qLx$nF`tSn_q+xkq(>PZ@Wi~|T|auDKb6(- z=QAXMcMbMPuE$=u5o9MnSjJlag~?)n1FOSR!|mxuoyZ%%UogHtv>*HTAHjN~kcxi> zS|5_YD~3JXxtufd5C2RDziw+)89Vi{u=iB^D;3EtYN^&&HJ2R&%vdq^C&Bj}LaL?c z^Mbz#yb{=>-WWX^s9JKEwK>^kHy!=GcXWKgX{n*?mp_+T@Jy-5-x46=!TqV$kKWG< zAql+eut(_;5@s~e)WLDDKG#6g{A;n9O1BoxXa0{bLLW}{oz-|eO~ixyQ=Pd8-JeJT z?*{BqRJ^TyoJh<3uE3*W_erU+;5V}ue{nI2sYf>aIFb0iboe_F5AIKmz-ZJ%5_qMs zM{6ZMQvzF4tTNGOnsmBMQyW_<+fn?l-}==<}36L{sY zNBuSFXq&W97OnI(zX!YzgDMBPi_>5-?ucklji+hWYOs^PO;(4N$b@kHu_`&0M(R@6fhc$Kh6 zL0wfUcwLX~;8*X@j0fh;t{qf2o9UL<3wolvW5JXEK|&i55AIKWM|8bW2ua}GggxA` z=!C@zFIGyDvqK4W8(0Hvb%!*)w>&6YIsSl8Gkn?gG!YN(PeXxMXnjZm?-uNFyC-{^ zB*=d6dk`R}n!m6|LFCAZrE9q?OO7=YdQzle=W+Mw5&T^8`M9s)nDoIrCxO`|uLMfk(hzIwlDJQxfE`%iT?!q4FSE|KAXKwMh z*u?C`(eB2UH`xg*G5tk0C;54Lb9DW0MiTMXk04r?IVHtf0`DH|v3HTX$re`N^me;M zdLOlG7%$a#k0pPtMIU?0JHOTS?AHp+ep&BM&@X%5OQIfXyK}mRA^epKVe1 z7}xJFn9Pfo6*gL(qu3;nu;1;=4uxBo^%1OB3GKB-|IX0g1m1nv!z~y|lC*q&x-8T2 zZulop6Wj4Ay$c&R`oBpl@0U@Kf4M@;gZstu2LAUglEABhJuZ@j7ILM`*y&#wvAtAwm=FQNMrN#NDO9{K$FNH1EEjAVl)wTc~V zUs}DQ?H3aQbT38iZZW8OveT@c$o_=;WnU`#y{Hh9zp2KCE{PT9-}x)3pTNL)arVd3$V?o20*jA~c1~ z#>CLptwP{+`Vf0np8X~j5u?2WVMOX%`}vN)|2*K0exDnGQx@- zZd;lA&(3;YJ~}T_qE_MH`o*@KUzP;3zQ0ef!2>kZvA5X1mcXlrJxT`}iJtVQUEyKd zoVuuN_r2>CU2-Fjq8ydJN8 zm0ZqBQx@a$_)g=WqEq}q^4Itm)o1G{iPQ(5KMy7fqxB&Pyaw1Kc~~fSNy5VWsZpus zjI;vRyCWGq?Qw0Ct3^h-1&->w+_n($;CXOrZbv;Nf%k;K8*OO6Raan39`4VU(i^lj zmd3RK7seCBuf|@rLqb3{_#6=ro(GqH{PRI1f%g>l$T&r(l3W75xgFwSnmKPfd;37j zpLbm8a~E~9mc7{2>Q}LUKm47*fBVJlHYZvilE7<(JrdJ1g-5>zU05zR=V5Hx!s5t( z`NzwA!3_2U`v`sJp1Rvu@4x)*m$k=P`1$kvh<{#yB=DMGZ-c|zM+~hGN#M1>9!Vwpu4ZEq?FB7Q_ZqJm zRuBFnG36I!v#aAp3+FmY_E6dosSln%zkvIwha~V?VUO&>TWYC&@1AG(6j5s}32<-; z3>*>;34f$i)o~%<9u9eQNW_EZ&p+1-^^gSKbJ!zw@K=8)x=O$6N>=;)jY#h3fUc}M z(bt7W*$u^BrT)J&u&;kg1lOa$?Ke>mN#MO8@O<8nsk2JkOKf`e?AiE8h?-f@quIs1 zKea!Yu8z;HWc~ zMVe>yr#1H1_4J2b7VW{DhxOHPFb|;$7O00L@Y-RI=AwDvv}I(8aMssvoRNl3SCWRA z&nh{jWYj%RZ>Qi-7{u-uWrBGKYmG!bB!Slfd$ebJPDRydCJ8S@5?~ zrz2ayGXudk5oUMn_d}Ek<{_LH|N96@;B~?t)ivEuH5Zqv^#_%zM?xexWosI>bkz#2 zMZY`CaqlY_-JODY{FMLu1&`JhaVTajf%g*j$ilAB9OAz4?(V$gqkVVPQy;tzGJ1Pw zGqdVD$5D})U+QWbh8dmBM2c0ye`-yeSJ2u{GF`M_comecc;%5Ii4K};deVa z{ODTFuFJOPOvOrwc<}WonoJq34@uy4!yd^^S^m=>SW>4A&W*_Mm*h?!sC?nmMpY_N zL*m})cGKy4C=m~yhog@2sD~u*dI-Fr=g)L>!-HC4;`D~84;*XgH>IbnIvmisi(2Ve zX5v1vaU$OO6#{jRyM?VK@Ooj7WdnH|CH3zjmso{QK1xlaUGuV7jVE$so(D&JekOW>I?9pUhpRC*}^{e^7ir49{{o%)423NKTGSdi!MmcwS z=+s@I!>CUQc|QccA3T|rh}MTB@cLnod~ElbHRUDu556A74acD#lE8Zfdn6?cak*DF{&4to<#zPu8=WNEza-_bq8^gK8-zWEUk1D1oD7;B3TO`Fy!G|q9Qi=z&B6#C8`<<* zCYpQS;^;B!`)_#~?W~KZpC-Zk7 zUH!A^{dn!eTDf9lL2s(Z)3c#wFS;H2 zTY9nXKmXn>!N>2c!#L_83A{J3N3y5=j#Zmb$oY)b%%66BKX?UGhB4MNEJa=}*p^L@d4Vd$= zes%%pv%G8CsD~u*MqrPn>%<$oxl)&hQ@or!qh%M3Z1mpgyyE;6yO;OL5!vJS^h_}8 zBV7NxB#3{$ge34rVUH$WVrA!XvD0zQJ6rBW3D9KgFgCj~J*?SsSii^q z-d)4>!@G+J@>9t@ZTBQP<>u9n$B3l_PqmzWcE+{#$D|yHqTFD9>4YK z!0{`H!_PaCz?*m%cK??1iNf|;cie-w47w2U;Nw^F z0ev4@2ua|5fIZTOPK-}|j?kRglOC~kyV_$zXUq8xwk(yVu}<8fx5XsQ*z+IAD(vy@5XGG@Q5R|oo~ zoOB-bkObZo?9nx<1(R(!#P)SV^6#1b`CSe{Qq`N11|G_*+!L@H>62W>`g?LpNOf?( zRHS*J9+JTO1bg&vYqoyzc-FK#XW}8PsCf_qi9{X z+)k_|@IJ#HiFK3x?FY(+x|vVUjvKplEZby`X-v`;6^-w7lKEzR!nmA>2Vehg*AJr} zlE9lG@QU8Zt?c%x7ww)jNMPAXr|;|BMIRINu|V0ixp5CgI`b$I55E50y@0;2D1;>N zW?^qHtwrqMCF^saJp$*|_a&X~xNhFf^oWC_`*rMv6_rG#juV*uxn3RU&--fl=VwR) zZw~fwE5#Af2VQUV`glB?q;^<4rLQ+7Ii7v>$_SsK*6{Y*HrV&OgzHr`Z|uR0NCNK* z?2*}KIDc%^A`d^hfnG5UX$f2%^s89r*ieB!Tx0_9$vQ zjcBD;>ZhkFP6SW~73m0A1?;gn6-Ax*w06qLA>H5?-kmfGd26FE_Y3(-+v!F+eyTO@6Q@3pP+Rj3A_c^GmFx3{ybT^ z_-WG_yF8LZc3B_(>?r%?zWM0ss4a8*KIVtq#+--s>cBiav%ufKAPKx5u%~LDQe!LF zS9kfcPGnz>ufl`-f11267M2EE-ZIk&xo2PY8N*ZlpWjE#7x2#`kp$i%?9q6|9Q|za z%2YC{n=a`jzrw?&7}D*yik1hDrB$vu9NBIjkLj&n9YB4pE$H|5LP!GdC+yKK@^#l| z$x7~48b3Zh{@J~{kw#jm3vFJg z^?J1O@bKfPy9%oE{BQ5-Qs-~1mAGH7%tdXC>8(#6sIP4SfBi!ecuNGHjU!D8%YT9PRc_i}x^kk9lB>er}tF4B5NCNK{y9{UzF(ymPtKEKw5wcYS|7!v5^5y@Ps40&fNODD+MqDh{HFY&6AlpaQxO2^Bv?R*;UkuSs!74zM|(vJtTp*3VWpHr+a#5v!7pF4OqCY zm7%faV?sf%h1_MuJo55jt8-rl{_p2mf9oUc&jADc^A{xXo-_{ja2MnqhIbkri&I~& z`}+AL+np8(Wj5>6R_3>#$kEa@iXV82Ss!744xXb!>q8QFNc{VKIAy9;K$_|=RsT;8 zN6eBLU-uR?^S?Mi`+;O6>4N&xxT}hXF+IZmeEqo_^^gP}DeURoS1+i&;msd)M>|4m z^ZjJ*3~SlqB!dmI_nr)W^OSpWff~b;`JetAK1PCiNCJ-x_NW+-ur@aiP%l0|AXafJ zGi|?lw}k)k5re5yI1QV#XIrLCd{a@ZroZ5Otecf9>o;W#bE`-|u63g#G#M=MGN#Ie!9%X9eaE=Kp_l)K(nZTjsUF=@VOBTCl znstpmmLjwzCdX_rJ;MH+mI^^VB!Nc-dm(oc5`L$>Hmf>qdZ9d}HZ@$ek&Nk5Plnlq z+RM}YdnbgO|IhcYk!K zUA*Vrl%cVoZ1e)Q_g}-H&iu-!wFDjw?6Kdz(RqKKgZX&AF*8q9vW2AZ8%EC1*}Gfo zL!T_GzJ1NuitYW^FsSqGz2;g1j~4c5WRlOR-ubb|Ks{$b8XW<+E{sl?k(ZL=r>NLGg0Q#h(P;?4Z&; zan@bWh%H!D=D(u(u3M~t*ZmB z+0SKQdHm8F!k{rsD~u*m|+hWr8;Bjb9J|xxXuo@{pUF@_Esoe;T>8q{KFI(&C_}347qAaMo{Tb!_5dRtPiXN%jX{CEY6@#q$&7V~2-r53Tgzqb@? z3oNL^!g_8kfyV}WlqOZ7&%TZ6+B@FutN9Y4-d{TVK|ZzPSZ4SeuP+b%7y_)ZJ%WB= z{enJk6-E+x?6AkUN#K&|2AVUCpN^W3wQuH(ccV%j6?QTHb-trN?7^0Mj}x&yf_`By z?LzBA5_lV6k7oLr;+9oq&Ol?U3OXy==N}kNNtXJ?WW8yJ*=S0?RDJuuzvn`(5C8mg zA?W&%Foy~HJ<#6-9tZ5-&!>D(7zN24-O*HgUhhaK&cUmxeousk`! z{^TP=|Ggz)B!R~bdu&%TESlbRwI2{`OHke*|7Ki&F=oU&m~}c1pO(n zr4{v%1l~s2qp{46Y2o4B?)%|az|J3~oOeA1%x>$==?wj}8VO;NtUYlH+aoxi2}T*A z9+JT0g*|eGMXkWbY;RGKLDps)YmcU_V%Q!*e+oUppU;p4 z9v|%CqR!s4Gvd*DrfD%-?mm4yUNNngXZ4CHg~91dA~I6^$6ByGg8tl0iGH6Wj3n?j z!5*oMzTM^93wGn}Z`jRGo-Xz8QWWbyo8^35rr{yeq9*xfhP!i zxTwP0n?HYx**o?%EyV2eAib$%l4!4Uwfl+Cstko=)byj+9>M%=4dO#RB!MRcdo1yu zGfdY9D=dQdRh}Mk*flW}Ql|UXE7;Z|a_fc9R_ZC@*dD?BZJX^!JtToA40}vBc;8g_ zsY>wRR=b&UerDJ4SMDD?H4q8QFqOeDOP+4*I%mH=r7sr#$ zbx$o&eDlLKyJX4n}^wvcZP` zoQt5{zKpOFKc@F}KlQKlzNw>)<^BB!IHCI`g-0x?ha~XCV2|ODxp6qp-aDL+W>U;+ z>b|gPkFcpIrN5ud+s56J^Cv2?7~3P52PJX*{U?&Z6Nf!2cVBx(Pqy(Hwf*YHo6k{F zNlK2Yq}kVKq=~dGMtYO72w-~z^Pp^wpFbplCjoo7ZjP+_kP|m*KF2SRGt9|4Thy8) zFUtN3juz#ubWq6u(ueI4%!A5){Pi74;7P(B$(V02^;Z3Bg=V*|uvAP2w7B=NRkZ!_ zi)r2eAex#&eo_J3BbW!ZIefn$3B0Yaw}(2y?1Jc`SJU9}2c-;e!o6>N@d#jRQm z2HBw^bXS!3V|xVsqHz*k-xNj?cv7%OuDa3i(v**C|GD2%txg#ZZaSG8m&u&DPw4M9 z)l*Dui><@<2>L~{23=nfMiO|)14-!l;BXhI-N4UZLCd{83M0+f{iWWxDEYGl-BZ1-R3L7c@3O3dt4=)PIeDp61tXU ziR}@bKXv)h^*CW9fhP-lB)cDeb=CgZXiEsKw)G@q zdj#iC{S0(HP8dnx$-$o9n`0w|q6bUlc~3M(_y=}td=FO+bq(RUUR~Jz!GDWEB4&O6 z{sAp?KN@b5SxeyUfIU(#;myG^l(9~8Y3%#r+V|-n5=vyK708v{6vrzl%DZp*9#(z- ze4c~9UozUOk9tS~PagJ2W-|RMao=T~2kSqIE%Zu7OLV7u}&iu1XXyy%Nr>%E6tgiD)LhqEtlv5Wpza2fOYnc{z+2jGvN z>5B@qJ|uys40|N2_e4xsRddKbI;F1gpP<^2%`D%(!&k)nBD^i6(Hl#pq8SmFJ0t%dev{f0%BuVwL0N6+89=+atI>SbASY zT_l00274s?;-^2hx_v79ak5s-{jNko5p_cei++3lR6@UBRK}AJ8?iltd9dm*K|Lga zw-feo#ThC&LvdRU8QoGH{doNx-9bvN-_Kb#vB=JvxA{F*Lw<(;Uw_XEdH(YEg*WK_ zY~Nn|^#MuXsS|qN7w7!%Ot$XY5?!}&YiH|#u1@rM<_~sbFK$YfU+Wpbd_Mp8g(=9h zaYw(e5=Ihu8U$YFW=5`+tS3&AxWw4|-or8JCwzW}l=ZouR`6`p+}J6P`TOCY&t>rQ zU@Pzp-JeJTPZRchK4m0#UspVGH1)jK@}&R|P4lzP$&Ej*)Eua@>X%$_iC@OrpZ~sK zfI4>m==+MoNCHm__Hg6F1#Nu7E*(4S7Edr=Qb z;OP;1kEf2eIR2P9;LXz7CSLPd{Oa%PyQ-bv>^u^3@yDSfmNM8L!TpP~DEjw9gpmZE zK7luUIkH=t6HSf!oSeF)oieEz^IJZ%8ZU^=%s}hX$#(y7||SKof$@mBPgSozJJ4bjS2jc0LUbbCK|2(!Nb#sOcSr^i{; zLlSt#ut&m66ZT9o*oNuJBKIjiNrB8*{i@RMOXinX_{@I?I_iqGVtW6L1K#s4#9!Z$ z1fB`(9pfsEH5{p!89z58PSc&>n4e=jH>r&?eWYS`5Bc|!?}&NTQ61l6|D0M;{A63QODn@el3A# zM(Ayqtb4&~E6-v!Br%zF)^eQl7k^M$dBUSOVbbttyp&k$D~LyMJ_~44L_H*dXHMX~ z-_{;u6WMm|cVuG|9j$b!{L7tFeswBScCsR8-Oog3+G8I-g7aDMLG*naVI+aK2lh;_ zo?K}T+4cO^9--NZ0aCv=<&P%@ou)>64;{&+&^q^aH4Dr8pY_|24*dEUlEAZoJyKS= zgZK4h0|c7PUyJbs3@I^teK`yVgKJo$EBk0c~FVXiygpmZE6@fP=SlesA=XStn zgN&(eOM}e}=D|VLD_X}4{@h=2JwFhJwf-*q&z~2@pU)yC@#~F90?!)uyj&_O1j3HH z)}C{=A9|_A=lgd!$8<-XneG#`WQ5%fz;0Q!EGFp|JKKFWJ%aPu@hWF@zaj}dTLSNA#!sg2`sJ5- zL`OGtpV@!E^d6_j8=KmrmQ^>N2J8OpAHenq&Sxk2PNN=@z_Wurg|N3&w0qv?-4S)l z8>xNyv(#AASflbj!j~eoRc4Q8H`d+L(L5 zpV+*561^evCeO>~|8zG-1Y*6fA^XqgPWb*z0lznq1fCB*KIf_J_lf|x&pg&V<(C;^ekp$jB*drl{pmRtFjWm3?I@4kC@FU3~ z$`gI>y+V5ogJd>tt$7{)4cjB=&-Bgsj~o?Ib4*Np|gZjIHP4$+7+ z7P8l01@;T1rsT!MdtrJ1v)-7YjQ%|jVI+a)40|Nu(h|z2f3%xz@V#2QO{9G)fgsd_*&4f_F^O-9oe5V$F z-f*1}`e-D_r#0cPnUB3c3Hl}bJNiDfFp|J?gFO=3Ck>BYryRXwacG!cpyIZB>Bitd z_rYXIvN+b`S;s84(P4W8{gR{6itbM&f#(i;nmnN!vvgjWUy$9X#`dPYUm#KK#lr_8 z@v~VyUnf>)J)_TIdH=H>m-|=+^^gRf2kcSXm$nr#O&%*6n11G5bi22Ry5Q!$oV3Z% zwoj*BdC7}9o??3h=a;-i^m{d7B!TA%do+(OyotbRX`2K)-)Ff)_R0T@&h9U*_Bo?{ zANcr;g|@^V!uAO6moBa}qxB&PJTKV86<;n+i7ioa?c4UnA&nw})amEpe)$c()k|bG zJBPOq*|K1J1pRWERu=V;1l}P+FR?5ksqMqyf7btsX7KAdNCM9X_Hf1Xo24wL4_1GdDBKx&t?mo*_bw=ys?|5$U8v;xZuWMt zAKN47&*DDx??DJ72|Qmy&)#&raq;U!wkIF|)=$P3&egwCMffg`Qju(TJ?(rmj~v@0 z=+En4Poc*TN#Oax9tkfcW59vEw`%X~RX;qi;5oNMb%yt0ykE(kuAs*B8{75hu|0zR zEU(AEe}*LR{9(`b9i@v-S1(^D$#0K6y_0O@U(D!B>;BYQlhr&5nV6!d+=k`-&w5p5 zA^!I}lE4dqJra@Z7|$ekl5c_Ks;+tmcC74|dNn9KzkJ&D@->;t+q7HMu|0z0cdODC z-JeJTFA(-bW*%#@T1gFN-nnr@e?-1s$|{mh^wP^K?3ts&48pb+PmwFt|MBlXAUD_l zv;J^<7{A_+B=CY@k3`C^qUlzXT4?6t?GmPfYTm`6)6XNeP*(UKpsqOYYWoZ8{RzY) zsPAq+{&^3Qzzc>wTUM*N3H>_hLS>_%i*!kM70p`v5A91m|D*k|DdYa5>K!++>ieJP z*VWGW^+qIt7Xo`EAD-P7mN*&cBrEW2wTt4mG_4PpSo&B!Z9>M(8oH9T? zB!L%3;3-PQ)(P=H`9dWz`2PsI^Khz~2M*x&H9Mh%xR!)OR6-K6WG~reCu{Z;A&I24 zP-G`kvhSs2OG%c(OG!zTB}*bp`i*nvmUH9&-haOD^YlFT^UR!?Idf*_9N~deQQLpN z%gGFW;$ftz`N`<%k^MG-ggw0e_t0Pt@jyb)AMHu*8+%pNEWAB2Z1&NH=nwUuwQU0) zeD-i__(*!1Ogw?(k}`qy!PSos*!j|<0OaqJ@PmZjDYQrV>WWd8{zA*AR*f(HF{d2I z2eqgJ-y68n$=APj5PzrdCP>ixd-<^5<5S4{EBqj#7l8Iio^iNX7AJn(o2#cL+%(Cy zS!|r=h&9)%`~ZbtCwgxWwe}IHPw;gHyz@jgp4jvAAfa~}?a@9}WS^lc4BELQ)gBVU zxaH_Ii`q*xsdl^Eg&n+uiy6NW6D;4~=7KHX(@yO9WRTE1gZ9Y3r@d4fNTAE5s(ZRk zBlGfmr+sC|x?aRC5iM5b9sBr2NQ0pFx4B@w7um~5djSc(K(t2|Wd2Cdrses&?w=R+Sl*gFU*!6}5|bjP zI(^p1U+FF%YGBLWIGt5pW4mMM^B#iU-^XdJ*YfHoQa+H-JB#*+V|cYPsH>LvRgC%D z&c&*4XrsO2Yo#bodhxRExyrq{*R2S8f44iZ-m4kp?`iOZgkCV(BU!lTs>AO<#J2gj zk#2}Zhhe~LlQ)WNmXdXx@ua#LO$i?fdVi0bV!bvN?EM`i^g_@csrXo3vIfgV1{T?z z3;%JXt6s#Y9cFWs{5qx{9~N2SD^0k4;(afVzn!-RsZWs53q^axTzj89O-l)C(ykx! zD>3fOt^K{{lY!Z5e~tE@(e{m=;F!*Of6r~@us+`R!T4Xhv?3lz=$%7*2M70MkB*EV zQF6b}lh~tpU3SF5-a)ZBaK|;ZflKcu`_u`&?CcO7l zz3LdB3X6_tfJ_)&iLs@;yU?83_q>z2s)W720}SHySYXc=fP`K++9S0RQ>ms1-m~XE zcc^XmsBT=GM{A9vbw!x~dsT?juP#nP@2`OR{5!xPUhg{{Tte>x+9S!;mF&7_)$zlU zFL3^J>qyg4(%{lhkAMIC;ze;~7X-Fo^S^0DC_I3B4$^N73*;hh4nI+$QPm ziz5-SQs1@qM1ObmONw%@(BHgkyZcT;=M{nXcYr~>PxOMggx)2zC&zs-RbqR7WBIi$ znwDv|3fn#o74A{d0x-rorf;tV~(_CJu&yNvdTT9=n>w>U-kn^|o7 ze0%4$;w(3>PQz2?3awk5gE}O%=n0*7lUnuXBC+>};a&>F1qr`-l+oJx+d*(7TG~WwUX6r62cw|C+OPFq$!_ zR6!tQJzAAfa~+->ab~4i=H_8XJ77tZp)W%S}-_ zMKRZ}@3!7v(dJs^9d8JGc>R5>O9AmfLhm}B_sQYb7lrc~{MTYPv%R5KW3m2Zp2Tz_ z@Jp``W$})~^xTBrzXk0DufI=d4(p5(Sv|D!9))=T^? zg;B%%8q3nER&J@3;UrY||q$lpkr z&`M@`jH1%mk+6q%zx{q4yIuzpdN=XBzEkx)>7~M)D(!DRYlK8RcW;l{xlJhOX?*TG zhLarv4PJyjy#6;+K#7zOB=m0KdD-HNM@P$T-+6d3pBOfF4yzE$pHIH6QW&XovO#}` zK^UR)k>L8_^}kt;Qp5uZy?C@o%+$@ae5Srw(ut|^P~O>`j}ph@(pvJTpZiBM+&XF@ z_wWqi^5ONrIXGVe3B3fgM>MtIlo$0d@KuiRN&DWtWghh5pZ`m(?XbyXi>NK5Bc>82 z?BVsl`ODb-X^_ynjrMl59HFiWqgwJ;@_2QbwO~Bq7=3eV5@$*tm%z<9&;K0Tnh1HT zAE=RfTo{?aCG--}9;>MR%lxuQ{}Q&k2K5Suxv7fh`&m>zG@f|>pL5#o#h15^5%%!z zM~ibJhzAmSNobFFM)7S-idxhuS9=Ffr?XqcgVV?@lS&PGB|aQ2&OB_~KYUVLS7ZH*WYc@{yd=p+zJ6~wcTQYIB|Cv;fN=Tn`opqN zIZ{55&`ZJdhC(WyN&m{wu*BR^_;HIuEAq)RH6nA*=KnUvUtcCGDyJsw;q`~#TNV%x zB=l18ylfS-wj%*G4{m3PN}JOvDU=miQXPuF8CJHhU-`AwL5mu~9=bnZh-4I3yp@Dr z8ooF6fK;xpUUI{ZDuKeXZFcw7BKR7%-K=Yyy+ZMQ=#}Cx!XCOmV2ID$L_CntOULsT zie4YuM>!DZnqXZ-8~jO3Ft_U)zmi(e<(@ezG7b{V|0y5(euN?YZyfPJLN5dD9im9H z;5Q>FIyf^~Z#se-lG)^bzquLN62Tk#2fQ z&U)~|iM9_3T&oLsekX~XCgnEeu_h(V+RPemtAlFey=**h;>@mb zgWr6-uLBr|vW#14i|BTB>^L{U`2F;5`$OAnR7weZ=>CVH!65UAm4x11JTH5EM*8*ivbu9SSXgzo#av}D_sBI4eNiP(*u(38v|^u;@_~e24!(C&`*V%74QKw@ z+O~GivoRXK3*5p_%m*ch)dk%4I^y`6u!qG(s}!VJxw0^!8QN*r)B+UzHQ~(Dy$KV|6v+frQ=zJn!e6OkB3>MMu?G(_|52 zox7ctxp(J7!U`*NM&92a{U$xk}`|hhZAbK|GMq%fs^`=zrSYe!@7dlaT(O z{DBvO*XpN#b0=!~Ff%Y;B-*vhlb3M$(Dy$K3zrGvfrMT@p7-hA(ur3yrIG zyxY@Rt46Q>?NM1#60O!-G43Z^ggw0e$Lh#{cp#xyfahgLtBjG|H7C8xeVp@IXJN># zf%+@56u;kPy&AO$);XdQL)gRXe{6Zk{w)S1^a}C4-+h6+J_iJD?VZ?`{%NUS{(|d^ zig!!oOK#RTiu#YJ656i<*AK7%Z5%P&?`lIR2G>miMAJ+6sl6rEX_0#YedO3jpjHF zGcwTBk|cYM9wT(VM@k0&{A5WWkzH30 z687-!55h_qq&`7HuNv)9Puz=7dj0XJTo&sTU#xi1w?^5~R7KZ*0iaDOm`6 zchn_@sh?+Mx?=I-K`{-n&uN9vf6d|k1zxY9gHJK;fFq0pV&%wz@QSs}t6-u*$` z1=&BsfP`KR+Eb{!d`+gKs^(6=iQ(DTiOse;0tefJ@*f?W(XtLURGK-iN65oJAA;HO zU?WnWAffjZ?Ga@+hF&^Wa4tCzQ?^hqBsYF7>sjD!lCU!33lq|c4Ne0C?{`o!xG(im*{ zKtitp?MXSuvMN32QhRwPcd9Wg99I)miAUmHD-N6>YWR;Mm9@f|k>LDu)t@`VdVBTW zAs$HRHK9E!Zq{!8LK@Y4@?$=QQLm%9YO|%ke82xi+tRZ8f#$asn>oVuiPv7_?jZa9 z7?99=j`j>K!oNfv`ZTXv*mur2T$lQ^({;LQG)%ly6lyYFKZol+WD?j9U%fnmEuX?J zGo*YVq4xsqQTUdSh%4;0@^0Q?@Kk6o#iM6tEbM-J8?Me|NBa98wbCdj=>6^PSZ}|L z65@e`UNhPwdFJl(MmOa5VAUd*@>BLFxuNclh-gU+5jEw~-b=2Wi5_K&{(6tIjuE(i!24T3 zq+AEer*R3r7Cf(C!OZ=oT;@G1hr0j#FkU2If{G%3Cmhgo{1o9#mqnEsLD<8)zbg%Q zARb8Qy+V7G>D2aTGoG9ozZ^>5CRBgv;=K(%E*y$=ttxLa$wOEyA4d|ret$Xa^;7m3 zL_CntYejps3ti?JE>TSkwR!)s5ANBud#@Jje!Ar19&O8uJ48bT?FR{Zf4c+LQ@JON zcp#zIhW5x_sp|?2@|&@23+=h~`a{E>TSCcp!zWU`4zZ1rPpWwLaS`<}G7Zm+|CUFIOBoJ5k{}-av-rYYNq!+g<&~9%T9YOE!bOP%gTAD)2 z2NHT6XpiJevfu|^j_#2W-QrhK7Y2;gGlKobM)?`{eg5xKigI(XH9_z1bOP(CyCd)S zV?aXhHQJ-PQz0}*l5p;XS`xje%y1a7Wi!)sK-q~V&XBlUm)`N#H4*gwK5k+?jW|K1 zd?2Cs2JMm5G(D$INqGEwjAM*>a>h58{$bkC@VWFHsiXilp3dxLO@iLv?S8DMnS2WI zKtit*?GbauiS4fjFEC>Qxb-sZ>dR#g*@O~wWYMyLA(d)veH!pG4H?juN+?`$^)Zg*X6Jc~(tB~@6 zgkCq=;~;-9U>K$&SI4(A<)xgCk}Yf1mw>aHnBhCumUd{>4u^{n^6<|yVDt-n5f3Ev z{zH5A;tEGNwsGzk$_)OFDh4gtdVgaqQi^ix))*didj~F||BWK9JCR zhvzlC=k2uXcoWBQxmNK4oAC139u>LQKO%e>DNno|(rQTxA?V?cpC)c%hzAmSeQ1w3 zGvM>Fw4%(O$;gSsR%#BzmkaF%Cd=j@8gy^}7;H4(+fC5JA3sfBBIltoAffjj&wHD{ zbpo@cP4L)t!G%7voiAthy`B5Cy)(`tUw^4_TScuQK@WfYw3yRJ$_Em9{b)~7(oOR2 z?f0$iT~h82G_hl49q+tGhfD>dKgN7$=+{iJ3nSpIUOvONPuu&*`&Af_(EEV)NS?aB znLcgLa3XF@G4w*yb36& zHKSwqAufxy=E`I!xLfgz_ZjzZ+JpHI*^>)pHWBpj`-77Z2U4FPp*Mi`ScHwVTV|Hq zdVUT*7wCP_d?&d2P9(V$*Qp*g8pWdnYDCNgJ^cRQoYReXAffjO?NNEXYG^VOt182g z>&q?>Nj%7D{7hWYSHSaC`sghEvK`%bf*yWmG$GfO+PNf7k#`-59%6ykw|-e;;nl3XXmSeS8^yU zTy?u6JvLsb{biFPLOrco=aNFu!|xC79chRM5_&^;-rG{r z!TWgCW_uChZ)K`;?`tv$die7R&#p$q0|~uhw5M#silN_rP z|LNlA<-5iVgs$K2Rm<1d^7-YmBjp1Ly%DrWBfv$MzVuk*;lYymOFv_>Mw!h7%ZK0p{QpDF*I__HZxrnjXU={*>SY*OubMMr(jIe)y+&BaU3B*q zeu?^;jzir)$zKul@cUnY4su=t0}^^;Xpe+_%-3_T*%sa%vM=d0@GP*Q9aDB-Yb708 zj`H~$R8P>u?|(tkJjnF}3B7My~+D4RL4#|D@*EoyaEE!E}In>11Nt(e?EfdX|K_>-k33~Yb z;rwRo{xnGFeMfu5Z{?j8iq1(r?y#&Ot9zQGcRAzX?d1(KxgneG9o?+GTY#OQhufu8xJu&5c}J33~YbA=2s| z;(>(T543mm@T)hOO5X9ZCaHBL*E$ZITpV)Vkz*RXNx`KZ{}#K@Yz_T+(7f z$_Em9b7+tFe!9{1gi@ENL84>!rQ4RiZKr%?n>?w1LQR3p`|HF4`26xz5L1ku zzkr0^JlbR8J%Xt%)^iM;>$h+vRp$7w&@>^CV^27XyIE=94t~cS+yp)R{&3?Aw*P^I z-U8Yq3OK%O^G-zVWa{A;dxYJY^*oO#XXYmE?%YC~Edied}raSUJECwX> z7SSG0n&j8YmvU6HS0s~cP8KmPlX&_B7AzQ6|D-n;ZJZach$Rxhf8W>F$6K^0slb^CH6jhj@u^qj3qnUuci~KX;6ZfYQjDH>tnMpGnG71C?i;uJFLxh(KqR!bm5FudhLJY<;B32?I z(yt%KN!xZcg|bc(>8Ab6Izf6^ZP_#3_+UnR!a|JW zQgzg4i22-iQ#~RMbURsThTu`=&xJzDQy_)i&j$$|3baFVa1U$K2Z0|_t(}5Gj3oOH z%d+MfD_$5IJS@^OrDH2nmb1gk))s3aPT_mxJuM7K=uo1ajn4&bh+m(Y8zZth zv2O!ecny2hxhlEdBgUWRzn|Tq`;2V}zdc~f0~}u`8@s>7!uGRbtw_WL2|X&bMyhV1)8&M#1tTYw%(WlJXhygG=-G0Xh%7 zHQFO7zD|Fgnd6b^b{5h_hMS^S8W?#x4-rQ?Gw(WOJ}Vo)$NHakfn2X0R<5vY$nTfN zV9$GigboebA-;Qr_3dZf{hK4}NpC!gos=z;kh3K^fYYxSU#5 zjo5lDd+dm~AfZQ#_Q*?LzAwv;DH6R^9huTtWWG4df53B7wNTMi-?JCt^NtfE>v+iU z@sC%bC5m_;p|=6;vG_jH>z*j2iDuz7y;{FHh%Vx+TvA5CL#B+2Id8NQ^&*4UX(!g6 zR&F+qt3br5bVuG##(;z#9oi$l+Qv=dKV|3n!Zf`545{jms<~Lb^OL_7tHgKcDAbF( z{Ij0`+oiRqyPubx=U))<9!B@!5_whTyaeiBGUSnR7{4XR^V?%v1s04 zHBozXLHYE^dgb$Rvvv8WA3W;CJ|BaG9s}B=lF=6RFf<}QyExIS*%)+4=Nk9p;*R2n zzLA@fxJ!fr=7#Xs_hI?Ko!Z9P-3NOQUFix)xvD?);1YU_XphL%VR_0%PKNY%{HCW@ zn8$0ixhbe#kdY`puPuFdPEW!*eVz7V<6>v!_O~{n_vGXp;(>%76WSx$b>OV|<@^&V z)Y2&;_s*1^9ejRp_aj;gg|syxGk)=hxecfEGT)&40#ah+>U#HohSd$;Qn{6V&!@>(Z{WR(n*)YLChqRKo-3HG>*ct`oe}yt!6}?Vvg~E?f6LT2 zz6{!JnS7%mv0k}6?QHGbyq&CER+p=Fq5$zgLXQ*eVKxh2+FfkdHc4b= zgn0jbNHAphq~F{*|4l_iug-UCUdcM+rM(?^ zSp0MGaQC0y6zup65_&vnk61gtI+te?aWA(`+NFES(mJN(TnbGxdrB`DMveEW>lJTZ zXZ*5va`9e$JICG+-eIuoCm^B6i}px8KR+a?%Hg%3ns zy-30wnMEYH=6GW7>MiDK=jmW4=IXU-)(-Cr?>|W*^$HTYThT82!`Yj(CsLZ9pE{^!U&oUH;L)%%3Gc zqF@SlHqL+h`{%<)5C>h9*W@{lZMYh?%iAJ=ve z?~5Yx-8&3O=wi?=`>xN-g*|WH{j8Q;3VicZq1?nyvVwVD!z$rNYTK@C@z$hu=I;(R z5JH@92A6ON9RajM>!4CF~HK%)J)xG?%(9;=g0&lSJKC3J+*4jJS4v(ip>Y2}2vM9YM>0ExbE*BWUH9cJgHtmw`? zok?6Fky-f)G3~s3>ZR^qr~Vx6TvpZJueMRd0SO&Zw6ljY=k)tiywvTvDsG%6wJCOW z3gzwmuYyKNFW>(me}?F*|9Xx$_!HoNuG8`e_C5*{I$~&txQE|I{7Ldv?)Xsyw&1Mk zzM8?h^sPxJ+7_2@I22@WkUzPOhXB!Du;ek(wxj`Z7=gdSKR zTs`ln%VFGD? z0_2aGk@^G)y`5-}XrUF;FrB>gO=jRa_hNJ0-HdiEV8(Kft=1JZ@-TUf%|N{^9<5%t@Hfr z91mj;g(L&vpagmxq<12m5sNPFMKLR99kA+JyHN9^md^=>R&^Ynujflk7jP`IC0d;Gr8&4+aTL> zl{4?;+FHCgN|ny8Gd{VvuNrR!Hs~Vjt1Af|X|zKk|19a+V&PExK9$=s1(ftI0~4($ zB~=8tKB!1MFE$pN{j$z|#Kp_g&L021B|vu`IoGz5(33%X#IoDTFtR&szK60Y9>1A* zf!L@peEEs~4-rib+CvA%ejVAq&UJIOasqoA_U?b0BvOy`y-B!)-fpx<@~C~9!{Ap` z3%5&Mj-IE-1KPnu#pyL(JDv>eYrh*q)4$&MyW-)x_R4e$+x{6n?;;*Z=H0m8#Zt+6nMLOK}5>U8~y(Q*s*OfrQ>( zv`1Warq=KU>8`~+Ds7T4pLaAAonUCr8)XX{Iet_9-mQwN_I28cD{fT=`F$2+WPeWp zBy?oa&c-Nx5i+?COcII0E+>ACsohOdR9$!zU^@S3LBwYEP4dOgb;c27F8t@B;p&lf zni_FILT?}1V|aEt&sA#ZTuPW50_IrZZ*4&I=}Ad4gpF`leqmfB2|&Z=LeFxqHKn zHl&rncEah8?5_)egq}Rwx`2gR;%XS0-J`g{S72^6wnTF$*cH-j&3@f?ok8-=-E}V8#C5kFei8aXKK+g9v3RlM z-CfUh!dliDPdq&ByuDX1WFyyWiv==Y6aWc5MYKmH`H(Efv8*xYKT=A={ZH+GlzZOL zRI)tFN%C}(Rq~cIo!mO(iHE1Vw>wx&`_nWLkNdPAE}?e-?U5gPVb0v`#Lrt)8Kd3) zqi#NHuX)_6k_$Lo z+j$&(63kq0?ilHfOsg5}WPRJn#k1ZzjE9dG_VF5VwjN`{C3Fs=9qPsga1ef&ovS)a z@yFY;3~EOH6ACnmMW=II2EylF7m;PJbG< z5;K3!K*X~C0Y9hsptaZ)qHLSxOXbDwH8rQ#nGbu~+1UNLhpu!r#KDB<;1YT&XpfHX zbBswQ^-#GY6%*O}?7WYD6X(zEoAP8cxm=>p0smLOs)om}K3=zcE8eObDpD??z)W01 z?-1IfcyU0Ft^KOqkjWvz06yQPTt9xJ&O0n#brFr8t>530UDRE-e1Ap~?7)RM!kNf> zJpv%1r-t@OC`_2r-i`_ET-bc(D%Ef*lT5!e{bGOL&iBGXmtS5FCsJP5^R!#N%!Ivu zqPE3|3le(jXphJ@kcM1AzSBg_Kb$SLe6(0^Y20`Bu@NQ3Qm+Re)n{X^*Y$ku{;Z+> zX)h8TIfw@mdKzet_FJJYkCS`K;R_$ewtjIWXD_K?6A9678{BZOc8k8w^ADHS>EB*f z_Sn{f{JxYu@?0YT5;~e_hpxv%=3C(WUZ%*={u`f4uI8u{zX_NI&ye>VNd(Cpe%o$mTs!a$}6El zEBZ6T&br~7nT_^PTD@7Pop^azdHy?&?IjODJdn`SL3?B|5e=0ho9G8e0*%yed;o<}i&HR11LL6CJWIa*iJ1ulROjIg%j7oB3t4w3x>%H;*I`akaRE3jPjVJQL*O2mogq}Xy+fbM$ z^I^K{ip|#6bo(&{y_@IH$H;XjxXv(58z{xbYw|~|cip_fy7j8z5?elnCoPBv5_$$` zk97|Rznvf_$@ff}oqAi|{@mZk!{EBpq)syP^YnuP<7Ksz>-7V0+{xY6=kHc6;_P2S z&MOFjgx(RfN6PWBSk(FxIZsE&qf&|dy|NYg0S^moIT{@>^*TZY`~rjPTsLp4)z5K? zOLm9{5;{lG4l!TjMQ099Ek;G@A10A1!@2a^wbVpUw+kNH(mi#cGHv_zbsgBVk>6K3 zf^GL8p<{@4XcNQOKkdrT&mD-{NSYWb&e=N8Fx$flTzm%tlAYSS?wpMmbU+& z_hjL|2Jqax?Eem1*!H19@f9g2Naz`%Jz}Q5chc;>?fD^^L#nr_om_>URT1qZ(Ky|1 zk=Xb{fHhiUoppa74;ObUTPsf+N7O6@&Kp!qA0sYE=o+J422XxAl_Rf`8x!(FV(UI8 zelxf}mG=Efm?6FFUSHj;cjN8rj3-!k)x8{X4$UF&a|?iko(bBcu^iWw*SDHl5Y>YeG=UcXRh;n+!+2HGdKmOZVdE1HEBfC$lhhuDi z)8FQVcp#y79PM#FFget6{p8_oMaw-c%6Xv%+q*sUn_`OGBjmDY+@FzM{ea&-RyKg4 zhm0o3?;jb(J_mq=juqPBQj$|jc+C3!LF#Dd?}y?|4&})l)cw{XGnVB_848IpOQrbd zX%WZ4&JC>IfdYE0oN@i@8E<@#xFDeij%}`9cMUB4{_Lce*Vd0Q9!6AcnmsWXJBFr5 zr_-{-ZN#-XZEK!g`==gP%JuKDOl&=xHpn3!Na)!BZ~X7MOlB^(7Naw{Zf~7TtBkJa z{_^zCU-lrTDK=4F?2Pse9y)JBv=P0oZ0l|#wo*py-5QQl=9bub2uSGIqRYk9@?nRr zyyVF~V#9~d>4_ft`!iK3P48Y9E2f!onJgo!{%3y%IM(j&&SL&vF5)&`UfA+j6xAT* z0SO&Dv_pI%!jgA*&YiUFi^Ht2#^Y}Ge%ejR;?A|?PY(;&Ej?3CA>#a}JS&bkaF8M) zzki$$*~bt72^~=0)z^t=w)ipaq{Qy>kQ+Db_VW;3tZAL1_;$31s!BC%WAojjnlAkP zK|3&FoU*k-mMYwF_c3cP>~joA=s2Jq@lXA#vaXy?i(O>~H~$;{>?kgOo+*8XC$*M0 zRcdL2q)R&feG}OzU!y@F<+8~`_MHSkLeCL+tJ(vxv|_c{rL$YZKexzjV?Gp7^(l4tX2o5n6ANO90}?vUXa{2^WKSz$ z>qK{F+oQo#`qY=1YuMZ3!qrS<4rI{&a*d6v!9SmiIJm=}IL9TY193n?2Q z553^((Mt{c91RkBpv$eU$E`%33foH^ZF?5Lt>fDRpF~HQjoWUI$u{R)C_fYu;NAHi zzy1C3;D!uRF2AlGTtdeK?bLFM3p6RqynQ-d@Y#+;AggGnDOHo(bQR0N{}MEdCNx+v z`17+B$J)uu&c<8J#aU890{6)X#0i+*j7#X9M0*G4r`iuD@HOi{*IZ_OFzXoO$B-JK z5u_}jsFEU7Vx^tS05^80~W*ynVR(D6h&e9Q{8irT~>E%UQaDPvN4H)M6p zx}LaqqWQ-SiDq%>6LijNwTsn@i$I2fPll`Z~$8VH(4I!fVnv2wES!A6{F)&X+(!&j;;^m0#Q$SR9!6 zS%X0k>9_1m-0r((xmF$eMamUtb`_V<@k2Yi9@fu2d^FJ{ z#kKH4+$$kJRLL`h%;PA@VsJrTv}2>@?xnTHic`08VlgXk??0wO;VNZ$6N?;W#-z49yk=kk^7hV`5r+;E2~ zao6p3_kP3!3B3TcM|LFo>i5imr&AGg7I~*$8ukhC=X?w&nNxnhw|T3^3*%y!wfZyG zLvIZtPEyl6E}?fC?XldUct-R3;E9WmxB2_)+B0y_bOfLOP3!FRUZ;Gk!th;FF8t@p zzvTlPt*a-zNb7|4nv#uOZwCq8GiZ0?mi!-sdIqK}vAPCtee;&2H(syR5HxBC=nr#p z-Ef@EtsVcl=#L8yiHogTs6xt@9*ezyf`ncm+A~bJbNE9@#VyYlwzrR09m%|?cj=gg z%EkAWet%8c);ckFePPXZihn2_cO5fZvE>5^y&$y5C)adLmW^q)xTWDX!=EDpmcprXcm-^4&DS_ql^gJcz;RN^6R;m;!UzYd~E}?f8?a}jWowRJzD);0S z(SP>9haNLhZ9Od~(q=vp5OO)ugh`8it^N+$4e(Zt%h_g2hyxNj!DxqshcP(nv&L7a z1-A*8(YzllLYjs@Z)K^3f7g!P(&6e`puVQF>dX-G`*+9ba0#6dw8NC%uzYg*WL$&r zxkH9KLbHBvFxDkfJxJ$ycvOd*!cc1Kz*^(~>O=j=@88FK!zFY=(axUtD(;O@uB_9P zF6UpKDSv5t#QhGDh0so2ccsyHediiY9M^XK9_B}WKlciD-wY&l&Y>NucuitqJ7;Q& z<3B5m5=%zxGmbTc7++{Pv^AfMSJh95wq?zFTXm=&aq>8Ma0#6-w8Jic{zRW_(n0zY zB%(t)y5+)}Url7&Avr#E=Kk9C`1fT2qN4 zXbDqBT+=FUyu7PAT_aygLgm?0>hq!5K2(Q(2&FXpG?ZYHQgl@YebBcbevgACNr*u|Vk5ll$&+&^>+Nbi@9PizI+`Prytxtei9By#~ z@tQs#$0hV4(H`k(E5>T`*py8jZ$}2c@PGFau<&C)c{U{0Tki9&9gE>_rijGR&#%b! z`g3Ss%*F}~8u({k|BO@3)B}hQ68aa>K6PG_#K8?mg8Zm@+uY?+)D5ppP0JUH$S96K zl6yv7^@Ejo&HD|W|Ic&A%U`BK`d$XoE zuj&6fGlMCr<;KMJ?GVRbPeQJ*ua}+w$~+VMmJ5O+UPlFX{QxBNE~7ne4dWCQ=?^!5 zT>sdAy^5n(rlfP~%^v?tGXZX)>h zFEj6r`wPF{=kw!}__c|~^YsBUuQO+hx9Qu;&8#(#1}B-pvMpF3`CFY>uP1N@DJMwi z#h|^N+Y_&NSPmqqvtrz}suqfp7hmR{w!C~{C3M*Ke4s*vhj4X{vI*YupMz?>Gf zEs3qikM9@}4AWZLPXovv`ToM$}*V>{|T* zyQT^r6mWwaZay?-NrHGFp?3rAF}JiW=MQJzFcN)98#&qTZ!s;~MMf_^@Ka`t%xgej zvErZaj;*vy#9KAD{4=giGGga@AfXqF_86^G9Xk_*N}D3CZr?x?FUP}mY^?FCQrV8F zdD1LZrhp3Zwb~`(q3(k4zB}iHy$^zfUL4xn(%`$DYhlk`wjqL-I=N&|w{vF3xJX{w*>TkXmI}Za1ottQf>E7^Wjx*0oHtsQ>`eu_?TktXG zzV6iIE~|sXuKa0zBfOStw-daVp>Wr2iB}PEK|=2q+7o5&cvf* zD_!#R^34aMr4F7au2UA=kDztx7|l|@XV_D+Z>@fSU2|QvnFi}qko+U^ee0Ek-fgre z+U8xzhBcbvNkluR zc5_vv@da!x-*;%Ez<8+*67jGUgZ8G$X+plcp#ydj`lXrzG!9`s&JeNWHk_uIbP0eC}!>8)unx+ zFpjd9D8uSz?povJpO?vS<=SM>fH)wblYw^VxqI~|8zYj8KV)iuvM|fNy1*>D>>Jr5 z;ucuC)%?GBLpuELtzgTw&dX#tm&-#7aX~^i6Ya9gBIdg;_j0mZ=vHw z;R4ET*ESu!Fkn(~k#Vj4fj=*k;hZhQ>4*aoI(N_x$+UHTFxU3e1OMqe1a*pwRmSYG z9urP&)Rhk=`PuB?vHWVS@;TUnZ=YCsieaahVovZ=9zez3?*ygPk@JKr3EeETD?)Rp z@>=mpt+tQ%pLFz!sFpucJ{zT@Ou4zU-}A^%O4&-J!UD>VV;bT-s-zq|=p}NyPhe(i&hmPjf>l;(>%-9@?Y(7Ef}%oWXG4`TO-1&SAOF-yD*Y zy?$%l-|7k1Vo1Cncs&j8J6kLD=>*x#^3JE-+yCM= zOTZ6mF)s6J@`nsw0?E%MP42yCX#RC~jD4;8M5gB8cC%`E6x-i)bdc|^2!e!O0oo&u zFMaVu=Ngle&^5tPk($pKB2JYd>qdd9@>5#odXuW%ei~ z-!fCocyZENct0~0L!K7}K|-$#?J-WacIoOI_D&cs zjDyeBB(^pNy;^>9XGE{qVXgiKJWuehIclRFsXxn|$n&ruNa&TLJ+^QfZq?+c20Zhl zPZ~s4TtcS;?J#T-f71KnsFOaA z%}uYi&31K)`yYtto{?-ckNOev-|f_t+O_I&W#Zr01q z^*eZ9W2X+H3OmS_T>8V2_shMUkhU=aGpTz?+t;ec70+wsz%#DX;XKaj3@AIvUlfXm2M2GWyej@An zf*_&y5bbfR>s<2>t;#$|HnR7ZNvY8i?VNeWkNq#EU%!eMyR|Pjoruo6yC+io)_=+Cd*~fq z#0%)hwil4lt44d&(fiJe`ZSo_yK}g+i~Toc9`jF+*Dc$fcTqZS-aGJ+_ToQ(ZyTvk zQR5*!C=siYz#OEZBhxT=+Up6dP3tD<-^RSbsF!G@)htGK7frO;64)&O} z_8qbH3HE$e?OG#Fuq^VO96^xKdxG}FFFU&m?6ol=(oOk#_r>P&sKC&t5drg$AI}@N zM)&9qp8s$C`ux-NKx={H$~gw?b2v!o)u6q-u8BjBPdyMRy>@RCXW|7-tIbqR7b%!& zJb90~FiDT@+04Jz^Zx3WA(3*Ozk$3bCNc0&`W!K>V8he5IYNe(4fdk2l#P5Emr$>d+p=w=AiM#hWLF z>L=S|AC5e>@;f=RLVK+xWhZCs|=zE@ke(n)|7)tB%kjzn{>qhfC-*pdDt8G#Te> zA^X^pW^PSz>F-qtquvromIYome6O7wIye5ldaeBrS05K|CuF|0ddGdGHNy6osCfc$ zK|;3??NZ4EA7;(?`0~ai|Fw+w?Q%m2OiNYVsq!Y$50hEPo@{>Jv(|H|tMA`|8TtKW zm3mx4=Na0eQ+%uQ^U7S}&T#3OyIRVlV%7dC#%82pnI~uDADkBBXkGKZnSNNq4ON=xNWyCXuq%_edBjV6|+ZuADC%QUf}TImGQ56_OVT=L}ho$TJ`6# z3$Om}IVvCyNa(ykJDQ6>H=eF-(4x4u(J6~&DtS!InsIRKxX{b!xx+!2S`DkhwVtO| zX5wqE$K<-cMm&(vYesuy*N(CgyRt`7?~dr?dgM!9boT_ul%e|j{VZZxtuMPCC{nF8 zejpy$8w1CbtlZ$u8*%b@V{i$*muQblg!je#VU|Xc_w`pDbDmfp&^}tAB|b7f9$#{k z`17Kf-R-r;59s~#JpsY|ZfV2=3B4AyM;)XZ9xL=JSbB4u*d+ZEj>=I7PTtzd;xmQ7u&}&6|lxGgpXlN_m+TXX^ zOf|B(qI_Gm?Tf~ub52cp?@PLfwd$JJYX2T99&DP3Q`U`~R~G~coi?ZtTbJdn_7M?0==9%;)) zn88iSS!3xvn;WTRUNm*Fq2^bUM%uMZ9?V z*DH%h^KNoVeDLuSrC|!V^tRQGspe%@W1ETiRsR=jt^1q=-zr9beGQINee%(W3le&- z(VnoW=W|zsUVg8f;@m}Xe*-=WJ^km&$s2#>(aRtDmavO2a;^CXINk_86t;S|2znn1 zum#f-mi1c=j@rp>bOFNeoKFgoW^PWw^9m6Zj;*&f#Qds z{zP*YK7{}O%*%KVAgdoUSYrT)Ch|`1R(0$KUGrk@$_xa@k-{z+cTyui=9R?H_f9$)) zQYd{)lIPxO^5qL00tZXK%jrH2Ner@U2WTC5IDt z{?qo0KW>C=OqM#v%RxT->f*`BC~(}(5ozyEWLe`AyN=L=;m8b{Ci zAJ29?^C+yd>f2YwAgw&sRW(`UzY}R&6ZF?R4*S`XKoO@O%VAEh%_wEIXS~Sk$0I6m zEo}F++6jZM#NO`$C-vI9-q$^xCD*S3U2MXg^k|MBU&BM*mK3<(M-nLF4PbdXowYBz zgaZfbTO+QQoR0jHyh*CN-}g(U|6t+g;H#BYQ8eW1i(pXa{(F92(jW!Sx8N1=2C+QO zvNAo<2DTnIzx)#u`(Ez4E1|cBHZt+9$FZy0TZC{>h-#quNSe~Xd1AaG z&M=l^y5SgS==%Jmajx#bKf|7*X@4VslyulixkO9-ply^3WAr1}{^O_g_NyM)}z&s2Ndx>V|i3p``%x=_uX<_<+ps5(_}BjrqIY$A9PDBRX-jZ8!P^86HabD z60D-(@8Oe|clHhr2yy_AC6F>Eq-wx>?2p+5SLUh+FqQ49H5Bv70Y4Dv{iUh&iC}W`_#&;v*M=7;Z^+p z8~3x*8~@KKp-K5*2aAu$&c|_0Ca- zn>%Rek)*=qP*;S@9SM>^-Pia(EFWVI&sFtsrJRq1;x!|_w&K{E!ms0 zSnj->;XI=xP{jLz<7sblAsdNbK=nK@^-{>r$( zORoP$xIBe$42Srp0Oa|H!SRbEP{jL%oKDFBCH~-c+&D;EU$6xE)?o({9 z@>JR2QseW^m~8$B(|$|GwUR-!aNjIm5$89Sqm}y1rf1-1yOobqi{#*4vm+-(wnPrP ze>zgx`GD(1AGICpe{dEDoG?Bi6Y$;?NuY=`f#sO$wM7Uk30^<QAlxZZJ-vj;KeZj{f-YvM8{~|ZS{j!ok5pN31GYx%_`yia39;90p$5 z((SwVD(Bhr;vPt;Xxj|aIToedNMB>vo0h&eoQ3BUx&C%Qn3sc(r@Q0w{cMtF&cXRU zydvH#mZ$O|FvI`j{*s7*nZJXKHWHZ=G}gWI7Lz@)qu|6%QU2j$OR(5=P!2dA$x4`jgmiD{ER= z(OS24Uso%+{S1glI7Lu5{63X}0{dtfJ6mcoBTzX08ckaS88@}FN6VLzHEw1)P z*{0Jao-WP&O&sU-Sj8mD$$m$8iH|(y79YsDcHNAqh)0Fx(ME^QcCpsjNPM$+u0Q-D zvd7`vhK@~5W;N`$x0tIoJ-zaPY(6FMFgQ_)a#foD6Jh*r6jjM7L3x|UBb{dMAQ+1oEx`eh>Cc$SRS>}rjKVu zMdr^Ly3Bpn+L~T*MqhEE<$3Nc{%!^i3Hj9@eaNLF;{BVBg?5Da0YyAIERRx!^Fw_8 zXkX@JzpCxOucz#xQ7L*=oV(*0x$z9(;V&s7jc1C|B_IbV;xJ%2 zEYs%t)qSzm>Cg6L7z<@`H*0PwtWOVlE^U`1s@C3BeD?;qbOe_Z$%B44{sk;z_mL2< z;=hFPFHpo|#PX>1QoqItd_R6U$NkNvv}dcqHn060P^F)~; z+m&laE}w+>yMyV}fA<$iR#1M1@dS!^ELh%^)*qR44LGHJ())(xUR?GYYO6j_dEjHd zvygRR?}mPhswy1!Kl{K)`J-C%A@m1|{8_R7PpAstDKpEz*rqd_y{nr;Ol(Ggs(F|% z!fWpeZ?n*mbsA%2`gQn&{q7Dym}^Q2`J?v9Nyr0=cx+gnMAxgj8=T=&>PNGky!}mi zw&zK{taiS2(7Ba&oc_~$PVm0yvUd-`c-PUBwB47$dF~GPg-ZfO9Cj?{mvF(eii5$%gw`S;s-vFks{w5N{X$f0~-5IA{AdM=5;YpR6%Y9xUo z-U=*FChJ4{y1b)$Z&fJ%mK%pR@It24omqf(G}nA?oN*C)-c==*h(|I6&UZ z9h^E|^2`+>eyyc@AP*?wabkHIQ%{~{+nKdLdK)l7t+uT~oacT_|F&4V-b0tu**AAt z8*d;}U*Q+D@M%iQkMA-{AqObpaA7&?to#lR=|(f;G`W4OUOT2{ewCg6#nl!q+HeY9 z+UJ%O8>`81mR`j~h|h=a1CRq0ak#M@iybv*dDyO87t)=*xr+TTuPv`=Q{7s@X!VhS z36;-1eX(w2@}Y~p-(q!0;B-=UK@L#FS&8K^*HQ|th|UO46lp&_sXu#`GhehNIDI1a z6eHgu{q_Eg2@Yhw6X6y$d50ypgP{I+*Ucl42NdymusrVj{VQGM{6|9E*9L0uoy;36 z&8Lu`V>Al>U6vx~;4bs`5t;fI@f_WPycf5H6XN$VFBbBEA|5Z6CsbUwq7%2KJXoCX z;h-Ulbjcd0>TA66renWCoGT$6!8SGJmE`Q zLlcCBSF*Q;cEv>4QCl7h?>OLmezxaJ%(-$)sQK7uAV*t0ru!Z3+TUK zxr?ZXBZ%dA>T$lMv7_~T>wMd;>HGGvz75sc_8UXH#%pRhOfrh?<2lL9W4VFj3X3%) z-d~EAM}(+|BZTFM={`NR>(lmE*Tx&NF7}N!+~u4IF1)Ogp&&l+OawerPd)UjSQ(n|h@NX=zFdM9W=0wFD_Qy-dMSKO_RO<5k_CR|^ zDrBg>ms;_r7jl3ijtG{+(sTXuo~wzU9Y5x8Jykb3LP6`-ZgT!^8sk%Ck)KJYH);-& znWw;9Py_wB55xBirGO%iD3-&~9P>rlGe@4Hd+<$6F(xs zdX5|iUWkjn5ajTv9VIH_h+#PlFSlu3yDxEJ)H0C>K(3Qwe|b({!aUnAey~a552mj z;#PcoV_#a}vi#jK@STWn1At2yeC-{;mgzuu(#dETKY`>Nq9X2UESK4vpXb*7cMUFz)>ECX+OOA2Q=l5*O5v#Fx$>N3i5FQ4vo9%iFs3^VS#( zHJmZ0mi7ZF?kDrTRpt3-guKf5^2S0>IMzJ7L8iS~JowSIrv8#*m@gOBeN{vU5?%?LT3>TutX6i~#I!txF^ zEZDtw*`dxokTvV~PIg|a%hqmIAaY7bRqt8H=B&?+{AB9k#rOrQ5MxJZXQX^-J0KS* z;z?t9JNabzUGMdO)}gmrm2i|wZ)Dd=_2Wh-xzk>W4OZUnTi=jPX59Plb_QZT_3wb= z3n`$8Cxhk5Q_e&+HSW$Wx(41F2`LLJEy!%Jb)XuuEFH2Qe!-x~`fQkRX_yso16BTh~v0SRPcZ;Wc>7~CU-qT*knRLH&&?9xP-QKk(Y_3)Y zH|x7RW5|r7z%sKt;kA0wavp&fq7nglKoL(4%ae+{(XAc+CUExY`c+@NXBMP$H$SYh zmi0RGB&W+te8a)d;bh7`SUM!!z5P%54>MJOJfMgtkL77zUTN+U^}Wm_=Q*zbT2tg- zz4&a$=vh&|&9>}z=g+47@+QM04h7_wWE(>K!rOjA9#F(n!18wAj9;&iXfZ|~uBVx4X|6857wtAI>9?nT59UaaPW5zJ5^s(=U9VkyA-4GxTTD6`5JlvjBxM;siza#Z$Ac%3*a`|-O0T$#tOm~`(6 z5sRN&-oAn*yg(ncNEzUU%5(DP>yQH!an!N#lG*x$-TuU<6m1uYwUpi+=GnpT7nq+_ z|LRPdf7WBU&Pn75P8~aM06B_|K0f|V?x6eV4E7^9*!#QsI6HyW2k>}z0BZUmH}wy^ z$3+S#;%i{}{3m&OWRq*Jp8C2kWH9FgI1e#T^+0B7UZY9Ps5O;!Ch{ImgB;((+1VE~ zx8C5bPe*%Cc{g|bh8g?}qCeQ%x0u$8`RVF`gD^ZmQ8?CO!(kv-+fnj6r2Dj|b*M_Y z&cVa%OzlHH)}>>aQuRhzVMW}n%iCWJHgF^_|%z-lBbq z+NW=-iQ$y~gAexDIuQbZrup&R{AKNP$wNNK2a5RGSUz_=|EJ4Cl#}ApE4J~RV`{o7 z`09c*&FpKO~>eL2mK^v#Bs+1^EVoOzz<6=edt5jk*%JJ}3ng z@i$`mqPZ8sKHC~RY+y2QH%cg4n5|8FPg7Zz^jUJ}D?_$k8BGeD3VA-*CWNn4z=k3G z1zGYi7yi@lemX>`-+>~&9+uC0j*6!8=C4wRZoc2g>x*x@Oz=g>-5XU=QaD@W{^&yJ ztPM_<9Dhks1KWx1y}+CIsK~+ees)!hsEE4>%cZy4CzE}vpSMT(!s}7p%1d#l-pl3f z9=P$$jpB!q$?K=AqRacIg!&CU;{ap5^rkL+Esol=7ZF*I3lwoTW4TPNDd%I=%vzkT zX4w1|%cP)||MtbMzM**=-!8R#Cw`9T#r{Wp1Mr`kaGnr!AD2wQLtc|6yvIQbDB^Cx zaz*z1HFRbjwJ*Q#JH3%*-~PU*`e&yUZ?%fZHjmLNv)jCu#H}Nn&X9|ri2+p$SRVqF zEZj8bMcTlvyoXowE?5asKxG`o|(60CU?r_Wf_)PC`X?eN&e|)g7cd^d^zxTVR zgz+U%#5V-|CH*rhp^6I;2SR(~*E!#?3li6Ue{Bat;?;(YnE`qZ7FvZve+8D0XWE>5R z@DMPkcetw=OSQ5)nC(x-hs%%lgdG1fe^Eg4Q(Oj__<;+}mOMrPjv#mv)3f_D+%GK! z6!A>3JX+~%$4|s|j(&*RO}}~eQ$l&#cft70CZhf;Cex)d9`4@0b@}%L@e9OPg+M(N z5Nk2N^sFM351@!=isey6geSZ#SXY_1ui1=3N|t|acSO1HL-C!Pcn^6+PjBwnY_xn{ z81ld?uVC*jzLOK=??9l!bnL5CBr4*WVR`iG=DWpQuA5M2oE$LMe@=PKEpw>w!D?ap zqY@pC=TD3dr{Scr_1_|oSP6gu1?bQ$#uV}fX(fq@xaNSHLmDShY&6=$`)U2my<3#q zDg>tw>=KIPl+3+-rIc?Xj8@K!H@k3oJV6xkZb(1^P?q23z~z6p6i z5zhk4qg?sxu%`W+mrQf7P20D=_PgoDx_(1Y1;vl=7mR8WbQOd+mbYt*JRi`F1yh6I zeHh5Ze@pxi@;-m%B`V@tV!2dCV$6!dGP(3`nI)7Cm%Xg0IUtq7A5?n>XOSn@d(O|y zYx#T@kqhoR_gYGXoYAcfL`6I+EDu+=BW3L^t{jt!v-edsRy+}NeNePB@3HgDb*;$_ zA~`dIx0ml1K|IWRDpKPyn;{1%;_Sq7RvEK>zWMBMT+pXg<1Wt6?3_5i-PmB0x^GL& z%&cE)Ix9E(@^XRB{QKe?j->;6$oX*(-YYEy6!CUpd3>!KpFE|%6Y=o=b5Hp-VgZv4 z=Tgs1=&dO7eKoYj^Sq>8_40Zf^$Ea5DS^(e%jb1}YY@skP{gyr@&v@LR0LQkNgS`) z;e2`ZrTv4IyN~+po>^7)z3$P82Uj)sH!QE$AP;VQQw(=#dnKn|rQT(^`4igp=*=)uC(jgNS|r>AONHw8pRbgrzi zwN|aST|+U=G~V`N`FF(M`VY=)g6%PI1tJW;n-Nqti$w%-soLOuu+l&gci%GZFNX9G?_!pPTvbQ4DDH-uK1HzU^@i)bfx)I1GzvEZ$FmD z&~JC4cU*MC#Aa4w+^&P>Mq|1yT~Vc0V@3>mGQlwpQ?HlTr^GW$@`OuvVLd?1tBc>0 zu>{^1BMlUB4`8_^V{aLSFNSisl!$yhCAeBDygA^Ij?0yfPqRlp-pLa86HZ$#BsoKR=z%d?OebDgIwZX%14d0duMK+t&BTX5-m~`r}z5NzWWiL%jaJM z!2H>gZGNyllIG0c1UWzv#}Uh+_`uU+N|_Ocn|y2Y-~@$w%`sMLxmUS$&#WFE`g72a zU+35I_yphwG)o?ah5p=haQrL{6mgue94h9D>7(`OCfD9F^9H${;^gHrTe01#!8@Uz z)jZI|{88ew<@pgmmhxGA8jX}QAdhDQ+~*_>6!BcJJRGZnDv$MvT>83T%?_PPCD9GB zw1GA|cRZz{|Jg(3e6LNMZZ(4ruJBerS>n;!8i2!$tf-P}Qpg)CP z0L9Y@{R(M;r#dj+KoK8|IWYaFBGr{&X0|iCjQyCi@ipK}V6I`SP?0$3-}q78pu=n6 zZv66k2Fr(gB;*4;oQcPb2>C}a;T_}xMO=5lT{3>6bTqxOjo~`&-8#H_gAx+eI>5IH-XfVIC%;BHlr4JgGM&c}?EC7ksBb=kbb^*J&|N z9`t!y+kQ0+;Qw5oPVX*#cX>Y%%Y&^l%uJ9YDw|GJ#Ph)NRGni-m34QP3jO)8T2dhR z#;SF5^IN5D0&WF(S0&XQk)cajKF@~b!Bdi$N)__N8ZQ$SalsH|>G$NA7(Bts7-L%4 zTxQCtvTaMTLGn&d8u^*0H{Np@1evAY+x`E)X8^c8+0$9x-Pe&=av*Qb%yyz8t{0YD z*z^0K_@kE^PUh|u?16E670@EVnrcM>SAqX>*BkM8N%!R$JJ>e;@7nR^?8icBN?|2w{f z{aRq`v1GR*;wr=$KrT?k^~G|xuF1asI=Wyt{i#O*PwY}~W2JSS-%K_|-m*Atbj!ki zVwigQJ}Odt(Jil-*F+Fk=>y#F0g{=x-@^~fR>$aYh*W5B41udm`yMb2=*E{ItK*cHPFY=XR-Pu(*8_u<%_;X>l6^X-Z7K1jzCUqNFvY?}QXpeMqiy;8Dv68V#UbzJ4Dx+Ipt~cn zV+y$&F6$B%af7j3)*K$q?llEt`P(9SpLaE?wd%L85A@sa@Npe)eSlTNn9kb&&i8mO z{ti5BiG#e2*WHPVxFJ}s(uz9=zSUg+xNtvhcWcUT!PK4Kt7(7s9WziE*gJpTPw-aA zf7j#qZoj9ev**9(9i=z@f%A)aMchyvHoE?%P#IR%;VTYtpR<$fT4-Zjw7eQ~EI(ci{O|tWlI=T7 z4|w3=;0L)TE`)IC2R@ z{5taA>AQH_0eI-m*BSJuNri`)zP84M_8BPRM`QU6zbQ7~^w-$!Sz$DspLv0+Fw4wl zSAGEdtT&Z5oAAIhQLW|k%B1=+zztLviwCh`JdbwS5*6`|V0jNu$*+B%=`nn(fAo7Q z71gJsc{ClXp5OP$80MV&q-t4qCE~y9V{)glQ9ep>AhZKO5jPggl@Lt2_FUph!~)aB z=QD93lDlg5N^l*H#CZh1PydnFBE|jqzw2Yf#cr=A$xvec$qaUb z9H593kL6IVu(}gC*W$I{&C@=}@Z&k-jw>bkOqG_sm*%O<{$4)DGV)Kq5>&g+D)?*s z@wfR0+k1kWcZg+lF@BfR;Q2slpon`6%cZ^J%Cz<1hu+K-Git}4y``3O{`*Q?b>F^I zGWlfUPAQPm_|NzVtn~!AfR$-*wA5Z6Z2Uo6uVMVMHa{jR;vL8G7%k5W8dy#J#eEZs zIN!c%M)cB_#}Y|*(pnF%%6@Zsf?L33`Ti|1RZqNS`QP|uYruW^(m)aK1eV9DywH0} z?S#Va`N?>X0@X-C{Zi>i;xuv>um7DCe_JIhoxS|~;d%e0W3H4uj2BSEIf>=q$`n3X zQZ-#2I1?H@>GDm&Q0vm|&@iToLVvOA-0U;Xn?L;%FR;K5E+Y000+aOkWl{V$!~Y>pxR3KN8(gyyq3yC#kDPxrWD`%`|rgri?HQ-V^I7JY+S7 zV>2+clHa9oVQFY;B5$A%7Qo;S`qm~>5f%BL#>4|BNx#|gmE%)yi8Z1mS}!otY_GI`QkE``&d|itO3xT99Flw+a8l40DDpjn^>zEI|M{Y(Sl#$D3F-dg z7`|z>Ew;%UIoX_#-R$)^{eb3%DvsXRz|0tI-2^)f@jvMInjW4%k_L)=&tiNj-f>AC z%G%v7TC~&ukZOCi|IYTe9sG=R^|PY(J4Cx*JXXua(eJSLaK`sLm-xO3r-uGOk#8c# z7st9*;C$Xe_llLVXSS}WqS7%vqAZg)(%kA4x7Xb9cZT2GMI3{LzTTD{`U+lPs*D)k zx4h-h7bx;Qhr?Y3|0V7x#EDjk*E^qCyLD&jk8g#I@4I^~HRtpVUu~IhS(__H{pxrv zj^4uA(*#`S21Y#iAM|@yNoe1JBHtuzc#Hq1A3eh@o%WJ3>7V6#1UV`U?NeplMcEUIoDDq9l`qETatQRY}H?XUs z(9!PZA;tw-*+(1FZmD^=FiyGVM#fuv;27;e#~DnDDtM_a`gYxd=VGLRBHt9O@1cw& zrTy8>N>TZg&6h7c6Lw5pFXHG_s(X-4*!JcL$%lq1xE0`adBPq#doTh8uZb@ScaP## zm@Yt(e=63Ws{ZuqQ_m+vJ!bXnUuPE6eXCflE&p0?$Ys-P@{dbVty3)j`orx7gzwm& z^BMXBMgD16{};D5dfua`xhY)iZ#Yr&TC-Vb!?yzK2hR?cGhDhk5IJ@F6^;oXes~iq z3_0{0>L>I!fg;}vSYL7L{Wdfc_s%WsR1nl{k8P zr(kz*(+D9s2;m*cBFu9EMZW1+U;2Iy0pZ>DU#1@RXW3;16;bUuSN!0W1Mgj>{XcH9 z4i1HXTJ$9(1HtzTFWiS94HWra#QHL*-HzVgrKjvE{VuD`LL-IuqVA?=bx|+x3;s-M zy0mquJ`P7`@9AzIKnyOy_p39ZoB&0>8CYKm4Yk8ROvNto`B+)JX9=F>I`muiyd;UfD7XaQF~xA0&OniGCf1kn$-Utl*~ec#qFFJ(h|9Q?@Hl&WjGWaw zYp*q1m6WUwUTVhsg8YmP?>H_W`T|A1mzMc%?;5<$WcKP}P>pk>fGB0}Chn`;G-q_T zMe!CUd^o#GVut983GYngF!TkAd@o~sDY*{|RtfhhxT=26Frt$`(n%XV`TNqBXDV*f zRbK|Q+oHB;0$*QW&oFFwXNL*>382XL3dR@5HTWWdL+z-P@3g8UeTZP5`SXB+`P@{c zs^YmL^^qcJCOJf3OnCnuq=4ZCihQqPeb?GtdcEtp*kqY*pLbKPZ^F=mOyljSR>hw- zvJ);!<|b#(;#ko25BM$^2sPeMhGOy~QIT&J)^|$^y;Y*1DBqc$2d4zTJ9azPJeYgm zs2`DVfJ)!M{`g*JdXn!UcVD6}&3P5*3l#ZY!}{)c__$!~D5ZVv?~QjwWLS+;k1305 zGmiu&@eO2EjR+-By$AKCzoQ$r{*j>@g5M3V$Tu77OS?K&<@pn~{a1r!N~&om^35|6 zxT|rD)1o!!>s_7>@lFepdG$VaJ2A!cvL$O+9es*vCYsIDDut4`to;N?v<(HczyGn1jE(x zyWCq?{VtYldgm5&t76@ol7NLkSL92~4utQ<{wE6h0!6-gSYN8w_Cee7c$E)xKK5qm zUp?y0FI*U6Se`t}x8{xO`NP0{^T z@}5(*vNb1LRoG8#_8UJtI->mMw$w&ZZiX`lix+*Drh{D|nM6{MlvJ>y}HL`PZKi z1?Vro0luRw0~Gn+#rliz8H!XsW(hL;z~^$Zkttdy_}HFr?wx9^RfkwyNB3%YVu-||_?PuBl7>to$pZn6EYY*r=MJ(4-TT z6EKnnw}dU}|H!CUBtu`I$hQ>h%RP1Lj_~|b#dBMzoH?yk?rkmX;NMJD$S^VbJgjI` z%k_@$qAv=e=% z8d*1;G2ek>LB5Khp9vBJ`fl`s`w(P+BHxD?Ukb`quOHpC{C4#rqel6k^c#Yve<{>G z1WspAzxkEyXYnxknH`RK(HCY4=&Ls(OH}0h2;+;R$Ue_wFEr~R#o67a(@t5gzSGXI zY`(?IW$hN}o$)Z71trn7{ zT4lzlC*zUjS3G!KD~YNnV17$qnGijWZPEXq{*cU;FYS;66!}+R{h76X>rRK%^!25k zz7km1Bxrc=NZs*+nm$`QPj{&`UdaF62+AShJ1Uat4;ZR&K!2dfzY^bv5jzS z*OOm!KD^yeGw9BJy`JG!5gE;v&0D-(ki7}VPV^_!zL-f-53EMAVfcX}|HoK=-y*NrOMOC& zLN_HgYE=JXRDPeZCr0AL>*|LO3ihT_r*pnt68?Y7r*$-;o&}2hpJ4sD&%J#_aXIv{ zyibko>AIfq=m(86PcKrxnf*v>n4H_GeBS}bxtKmd`1dfu4XQ8$!EoCpz(75Ut^dv;hIni4sbg89btk1Aub8lmF~zqqY{_r}No zMgBEde^1LkN>dFL-$J)Kd(HjaT3w9+XXEo)cVA7~cOm@kqr}HHr2Ov)o|=VkOhEz+ z|G`MO4kH5;`PX9ox!9?_zmy1>Xvf$6w!kG1sPD0?FSf9?ECoxQOZF z=;jRCBVsQQ`g`ty=dEObBLBK&{x>ck)ZByXuwR)txN)VQ2ySqRVt$;kBh*OW{&|Z4WI=5@jYh1U&cJ1--EXh9{8vH+_sLp=l z7Bp4bW9Zk6mn{%M&_6isB2f|NDVD=P<#V8|C|RU|DL+J}@cx7L6QPs0ZI4Vb zoxdS@MV3m#$P34h<>2=NqOA?2?{ZH7-b*I~6mc4`9JXKUwVSS0UQYdKukdBVwD_wa z)4vgRo6XA@+P>A?p6K$7U&aBa$mQkn2W!EOQ4*&jM;pcmDB?WBa>VkOVje#HMSHMa zLF;BP&x<31Pj9bhEw2x9#(_PV6(>pP9Nj}EsGr(CAkEb`HAqOb(Z^Zh0 zzP0o*-o`i>h0B&|Jbife@xOBU%!$;WM#K#!X*YF__kAYSQ;uMg+?!yI=Bs3yf}TKs zpvb=o>!0)LMGD6@#UVM-ErMmjW09FA4tFQid>nVluHlY*FWf!YzSJMT-iygsEkY^K zA1LyFiS?&TnB#UXZ#Fq6UVf*2m~ywE+RG!Wo(!37kvEwLe3!ar=aPCH>{1BwT8sen zZQVlXrvOF%%~=1{5Bx*Q&-)aoy`Y{=kg4`k+ftlMKieeMmeKa9BYj3TAGf3&F1_c6 z7!5){;LUqN`2dPIEm#h#Vz*P2d&ed&+SbG;F@x^y6e_po&03=Qw7#7>7bxU02kt*x z%ufUkJmZD>86SF%!uSA1{;#n9LsDyaRo4$c+szpD(2(-f);@LtJ*{NLtJ#8?UuNIP z7k1Q;>RZA-8{&t6zFj*Sh>HAQWBq+(7z;B~DZBapJbyIuyuPNu&Fp9;WzO^|R!UoW z#o0~9yi5J@ho><9ADs#HEl}j&iuGqto>3NG#i~)1_gvC6cz`x|7fUI3LCHe(AFI1@ zd749Ru}kVHpCEAbgm^hA@k7Ay_c|XUD&oAsa)i#zTD0N}EHc}6$_~E1@cY%Qpl0ev z#ueA2TqLZR4JMoyaAJ$!VewisaFQET^73FQ3B00-av0?FgPPue z@=~PbpBcWv&b+ym%KIku+mq#&zrEvCnNs3fQeQ3O5mFHP4{Rp%cYq?!J1mD=X_f2n zxyQ^2^&eU!FGhg-WHo8o?yomd=)B^_Gig_3_l+!v@QedYLdY3BJw;T+d5`5#{<8h~ zm^1!|*SXV|59sUu%y@aH=JS4SGY9>=lDN0EvvPB!0rDO7e}9qZ2!FC+_xzM6!~{x{pluWa9m=~ie5!aUhhbGbhqC(K_#H2V=AIJ=a1E3ts?vQGXKRk z3HtxuEKXG9---3-ZK;s54r<7HJ>tt8o$2tPyL9Y8K$7s-OTIrNKQ*pgh`mVa7sBwP zS_*yNDGmqd4;1-#Vg2>Qnnm=bFQ{m5%{wAqkw)EGO_RTN;^Xj)l#1r(2Q*p7opG$h z@(0hB5Q{e<|NIGt=R9P9BL8lzzxBr``xou&b|`W@Jht)b*SX6MhW0PI%msYfd8vQV zp8pwJzx4aMxWGpqN#FNxj0OxpP~`s+>mP6MyK1FsEsN=iLp>YXSVzSAgF=5e*t{&P zGnIV9Z7V83N23K}5AkpaI0}l&uPk#3oNvM_^8bYKr=WFY^*yh@uFfP< zRTk%hudamQ2a5drF#b5YudW;w z*?K%aG*eGai~Pmu-@d(c;qM#TgywSPcU;Om5{9I9!o>@`pbKAo^$J*Qj$l5LIn&U7&KoMsE%c1GW87*aKtxfW|5KZG~TQhR}cWn|?{;soQ6bGx~EdqKsggiR?`V-)xJ zB0rrRX?PTY6CjprmjKX+;;(taG^j8ht1nv-6>)|!910eWZxt3%OyifUXlX5DTHVio zDXQLJRld)rZ->Ro1;2ux8Pa@;D_m59erv|eiHdwjFuph%mgg4z>u$LwuTdZh3|s4$BItdX$`T&TXdDt$lka;I;MK}g@%mtS<-jFkGhwA2Zh@mFdjgW{}-%3 zhujOt^5TUv9CIq_f8H>Zfd_p0H<@&s?G@kn^-`yf@k&ur{Q>tI6S`3V1AUeM?jb7j z|BChBZXSQzu7bl>j_QNmzIA3XLAD(RbA=Y=q9faPh`ZOE<=sFEKmHlCW#LydAbba) z$bS^;PglCuwo7Kmg5<}^7uki)VO3eb=))h)cCYfp3mu7dZ9(J7+`si?;B!^tyR58lV06Ud)rXm+`}FvW|KVM4!bR47uZ-Bz|Gi(gef6aHqjRF+ z`>yhk=C#~GA&_?>PQAl)*X7kBD)Jx4`m@PTKix0*M*8|(O)#67voPgF^O}MgN*?8h zZ;X9U#YX=a#jPTiGk6~k{um>;u^BvEjz4QhjK|gr*bk5eia6gf916DJJT0y+n*JSc zdL0^^_Ky~*aWWp=Di(K+YM53p-=gZ)G-*B*|F90qKief6VfcX}-yaxXoa2tk%O`z$ z2i+7k5774B@1wMvt`*2&I#+)#AV2M1t<297Qu_?{Q{ks=&{8(^HNL||ROJ5?>(8NW zd+bTsO-25T0egFL-`eUMyg2yr{>p|`)z@`4*_?5#?kDwM7WZqxOay&Res&QR`TxTD zt16!@^;CA8YW|$Iu*%)|&Zm0C{d`Xh<-X5t7oje7a49@W`o6$_v3G>>r`a~R-Y5$c z`TxfHGqZCBXwBz-9A7aoDEskMr{6>WO(KQuX(H+BYO*5xBIoXs(g#0N1K$#WWdMfT zg7qR%k^cnNUr@ttyyl*0$GUgTa&5yg@s@Ji1TTgT-H_&2^|cLa{^>A6N*}yG;kA1_ z0Qy?qg7aFkK#~6>)}MpkH--I1!?cF*LTdq^5uKUrMlrT*M%oYS_l><`Wr@r7CY3Kj z+YE2aA?C}Sno^Jh6!}kK{aMt-`~2v*AAjI=ofENqWn+~5sX()yir(kV^9TIj4{SOX zzTBTU^9OzRUkM~C@}I`~GwN~_NA0VRU1)6onVhh%v7p>6CcWZOz0XLQXf$I4N8@W! z{YeNvv4ahL9iGDdaI!#={|wfjYPWFt#`^e*bAq&0?eratuEcU$lCBN zS+8OW$49Im2;m23UjPBS-Y)B=OZW~z5oZ?5(T$2=u2eI$u$}uX!eqWzDyLF!e{WEt z{@7%dsP(ruXI2_5j|Z_R!0>xD@)8yK&td)R2b{&bIOvM1yyw)*3OJSczTIbTK7Hl( zb0(|asVg?~EMcU6B#g&mLjZk!JqYz1P~<<4^=G;z;vpEfN14-e`c)ET#qN`RQbKY< zO4odOdblI<#7g{ImiWWh*^`TxcGb1mr5Jo$D#t&e?|Rs*ZY{^G9+ zAEVzNNMpXi`1Q^HV%oDZr1=u`Dmwx|-yjCUcLs|57qI?9*`tagqc3=Sq;0A5oxEdt zh1qyxj81PaHA=GH=KOMp>yq*QKjᢿXIjuVx@Q2{Yr+Fouj#+9F(bkSEFrayj| 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 z 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 BUqb)@ literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256/.gitted/HEAD b/tests/resources/testrepo_256/.gitted/HEAD new file mode 100644 index 00000000000..cb089cd89a7 --- /dev/null +++ b/tests/resources/testrepo_256/.gitted/HEAD @@ -0,0 +1 @@ +ref: refs/heads/master diff --git a/tests/resources/testrepo_256/.gitted/config b/tests/resources/testrepo_256/.gitted/config new file mode 100644 index 00000000000..ba975e1be69 --- /dev/null +++ b/tests/resources/testrepo_256/.gitted/config @@ -0,0 +1,15 @@ +[core] + repositoryformatversion = 1 + filemode = true + bare = false + logallrefupdates = true + ignorecase = true + precomposeunicode = true +[remote "origin"] + url = /Users/ethomson/Personal/Projects/libgit2/libgit2/tests/resources/testrepo_256.git + fetch = +refs/heads/*:refs/remotes/origin/* +[extensions] + objectformat = sha256 +[branch "master"] + remote = origin + merge = refs/heads/master diff --git a/tests/resources/testrepo_256/.gitted/description b/tests/resources/testrepo_256/.gitted/description new file mode 100644 index 00000000000..498b267a8c7 --- /dev/null +++ b/tests/resources/testrepo_256/.gitted/description @@ -0,0 +1 @@ +Unnamed repository; edit this file 'description' to name the repository. diff --git a/tests/resources/testrepo_256/.gitted/index b/tests/resources/testrepo_256/.gitted/index new file mode 100644 index 0000000000000000000000000000000000000000..6b18426ca7e93c9d4bfdd927a9b30a5ef4effccc GIT binary patch literal 361 zcmZ?q402{*U|<4b<`nJQ0mAR>%wRMl1A`#5*o0~ZhQ=if42<7^YCwQ%-J-dNS+DS! z>3)i_zxOtj>2KJ^ruB^5OL#S_R9q(;A7x+*a&>g^b%iKrU;vx<;qPA<4K=q0&0LPX zpV+cA9*Qw9T+bp}_hi-03K8}BPZ>=3HoJvSKYe+hG6R27QDRMG4db zu(_WXIl*YC`L$@~^LQV0YUpTrQuHq8u;E6dXL%p{!+agzZwPJhJ9t;){pPO>?0Ko> zNaltFxq|$l%3!Qu!1ZY%$B!&)|C?(|--f{xF0IO&I{ h0-su>uU?+eE@`ej-^pw4Og_6p(IfoYum8(k5qel`FA literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256/.gitted/info/exclude b/tests/resources/testrepo_256/.gitted/info/exclude new file mode 100644 index 00000000000..a5196d1be8f --- /dev/null +++ b/tests/resources/testrepo_256/.gitted/info/exclude @@ -0,0 +1,6 @@ +# git ls-files --others --exclude-from=.git/info/exclude +# Lines that start with '#' are comments. +# For a project mostly in C, the following would be a good set of +# exclude patterns (uncomment them if you want to use them): +# *.[oa] +# *~ diff --git a/tests/resources/testrepo_256/.gitted/logs/HEAD b/tests/resources/testrepo_256/.gitted/logs/HEAD new file mode 100644 index 00000000000..35923030200 --- /dev/null +++ b/tests/resources/testrepo_256/.gitted/logs/HEAD @@ -0,0 +1 @@ +0000000000000000000000000000000000000000000000000000000000000000 decaff3051968d1f3a2defd3d4a80ced03101555e1fd8913b3544026c0717d4f Edward Thomson 1680595792 +0100 clone: from /Users/ethomson/Personal/Projects/libgit2/libgit2/tests/resources/testrepo_256.git diff --git a/tests/resources/testrepo_256/.gitted/logs/refs/heads/master b/tests/resources/testrepo_256/.gitted/logs/refs/heads/master new file mode 100644 index 00000000000..35923030200 --- /dev/null +++ b/tests/resources/testrepo_256/.gitted/logs/refs/heads/master @@ -0,0 +1 @@ +0000000000000000000000000000000000000000000000000000000000000000 decaff3051968d1f3a2defd3d4a80ced03101555e1fd8913b3544026c0717d4f Edward Thomson 1680595792 +0100 clone: from /Users/ethomson/Personal/Projects/libgit2/libgit2/tests/resources/testrepo_256.git diff --git a/tests/resources/testrepo_256/.gitted/logs/refs/remotes/origin/HEAD b/tests/resources/testrepo_256/.gitted/logs/refs/remotes/origin/HEAD new file mode 100644 index 00000000000..35923030200 --- /dev/null +++ b/tests/resources/testrepo_256/.gitted/logs/refs/remotes/origin/HEAD @@ -0,0 +1 @@ +0000000000000000000000000000000000000000000000000000000000000000 decaff3051968d1f3a2defd3d4a80ced03101555e1fd8913b3544026c0717d4f Edward Thomson 1680595792 +0100 clone: from /Users/ethomson/Personal/Projects/libgit2/libgit2/tests/resources/testrepo_256.git diff --git a/tests/resources/testrepo_256/.gitted/objects/00/404e6179d86039bbc01a925bdc34ccdab778bd1d824f5562aaa319c6c8f045 b/tests/resources/testrepo_256/.gitted/objects/00/404e6179d86039bbc01a925bdc34ccdab778bd1d824f5562aaa319c6c8f045 new file mode 100644 index 0000000000000000000000000000000000000000..8d8d1d8e82826ef293e6194fd62fe58b610a64a9 GIT binary patch literal 267 zcmV+m0rdWO0iBRBP6ROwMXBc$>9zvdiQ_mDLNt_gTp&*D-IdrKG|YL6N#fP{&9f?`+(G`CnaXJ-;gRl4TtnA|jaTt3=n z*F6BD0K$ZVZiHIL+~Lp@3%g0orO)8SWCrd*Y5>rsv~%Ki%}9 zua~EQv7}g#D2Mx550*)%o!$O>zr5OZwD21f4wS62%-3_1h&jb+T9u{~z>%^>08ZHb R5YE?q4eR@e%QrEBc<=pegz5kQ literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256/.gitted/objects/01/18010feb81fe41b9df646d13866742a9070b56fd0ba9ab8dff828fc36c1f78 b/tests/resources/testrepo_256/.gitted/objects/01/18010feb81fe41b9df646d13866742a9070b56fd0ba9ab8dff828fc36c1f78 new file mode 100644 index 00000000000..c7fbd7e9ec8 --- /dev/null +++ b/tests/resources/testrepo_256/.gitted/objects/01/18010feb81fe41b9df646d13866742a9070b56fd0ba9ab8dff828fc36c1f78 @@ -0,0 +1 @@ +x[N0 *t8Bq iP~Gg42zo /k^rfKFO%BI"NdwVeb8vb<\LB6k< UtŖ%Y#SC\c<5~7:<Ξ:n3&Wl7S>KktkҦ_ \ No newline at end of file diff --git a/tests/resources/testrepo_256/.gitted/objects/02/df938cfb169b0b6ba0dd16acdd727ea9364f7d48c55afed2f7dd889804065b b/tests/resources/testrepo_256/.gitted/objects/02/df938cfb169b0b6ba0dd16acdd727ea9364f7d48c55afed2f7dd889804065b new file mode 100644 index 0000000000000000000000000000000000000000..cdfafaca76c5125ec895dd2db23dacb7deb81805 GIT binary patch literal 103 zcmV-t0GR)H0V^p=O;xb4WH2-^Ff%bx2y%6F@pWY|ej>WVbXmdf7@IP_Uo6IJc=qbL zq|eXzbl+;$b4H&}E1;_Lb5a<#Nl)SGxmmebk0Gq-=z%#(tY)Q;ZmYb?_SQI4`tl&h J1OSNDCE&90Gx`7k literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256/.gitted/objects/05/f7b70a01b0ade8afa5a5fcd19f12cc38faf337d10ec03ef4363d1a86f63750 b/tests/resources/testrepo_256/.gitted/objects/05/f7b70a01b0ade8afa5a5fcd19f12cc38faf337d10ec03ef4363d1a86f63750 new file mode 100644 index 0000000000000000000000000000000000000000..b135eccdafadfd5a8e548e5fd10adbb00a8af34f GIT binary patch literal 21 dcmb003G-2nPTF literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256/.gitted/objects/14/bd335f9d7188c778d44eba8801fe9bda46b66593291f5b9f7cd5f8888af12f b/tests/resources/testrepo_256/.gitted/objects/14/bd335f9d7188c778d44eba8801fe9bda46b66593291f5b9f7cd5f8888af12f new file mode 100644 index 00000000000..58b2d0932a9 --- /dev/null +++ b/tests/resources/testrepo_256/.gitted/objects/14/bd335f9d7188c778d44eba8801fe9bda46b66593291f5b9f7cd5f8888af12f @@ -0,0 +1 @@ +x ̱0 Ԟ#B k‘ j}(^rݫi3g _ܜ8H֍N] }P8Yo;o\Ww  \ No newline at end of file diff --git a/tests/resources/testrepo_256/.gitted/objects/17/9496410f66032c03bd2b7e8ddfc9c8c47820fab5615cc04d904989ce800498 b/tests/resources/testrepo_256/.gitted/objects/17/9496410f66032c03bd2b7e8ddfc9c8c47820fab5615cc04d904989ce800498 new file mode 100644 index 0000000000000000000000000000000000000000..97157644b1b473df7cc6a9233900fe07123c0b02 GIT binary patch literal 64 zcmV-G0Kflu0Rc4t%Kvn7Wn~~VH2^U%Fg7$aATcgeZG}mfxK8yPV&{~SjE literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256/.gitted/objects/19/0a1349522cc11f8682e34acca4ce4e1ea8508dfd77c24cefd461b65cead09e b/tests/resources/testrepo_256/.gitted/objects/19/0a1349522cc11f8682e34acca4ce4e1ea8508dfd77c24cefd461b65cead09e new file mode 100644 index 0000000000000000000000000000000000000000..554d191b3aca70ffde00fcf101d4e9a9875cc1a9 GIT binary patch literal 92 zcmV-i0HgnS0V^p=O;s>AV=y!@Ff%bxFfcbvHcT=xOSUjINisGxv@lIgv@|z2F-}S~ yOSAwoOw27AHcoA~_Bf$(bLz>G#hz97>XR;=ZS4NsQ6BTFNcIU^-(CO?b{=3|pCc*& literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256/.gitted/objects/1b/4b74772bd83ff28bf44cda9be93f4afc2279623bb5b36c9194a660b7623c24 b/tests/resources/testrepo_256/.gitted/objects/1b/4b74772bd83ff28bf44cda9be93f4afc2279623bb5b36c9194a660b7623c24 new file mode 100644 index 0000000000000000000000000000000000000000..d5c518ecc8c721f8632f0bb8ea332f8a97a5497e GIT binary patch literal 236 zcmV_=Q@ zvc^JrmF}Qg=!O7r?zLNUX-aCt6-~5{l4I4ZRZTgp^D02}=TX1{#hFVf*erreuEopX zmDsxD7%`+ZBO8p_oyqEor3M02%1i&Am;Fd@zR#InF5UNQdi?U=@O<9-`^SUt+fzcS mxgjgmbPp9^xwW@vX8dQnyvA{kWJkaHC7tY`)A9qv31^C*IC|Ou literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256/.gitted/objects/21/e1e1ebe45b2c1ef79ab050334e36a8015a546f0740bea4505e10d81a946f61 b/tests/resources/testrepo_256/.gitted/objects/21/e1e1ebe45b2c1ef79ab050334e36a8015a546f0740bea4505e10d81a946f61 new file mode 100644 index 0000000000000000000000000000000000000000..31aa9e5f53d3533a3a8776bb36eae93699a46384 GIT binary patch literal 162 zcmV;T0A2rh0Tqlv4uUWc06q5=dp9B5rPwwx#t(Qi-n(?cDg^@7gx`zF9Og1pLJ!*E zVd9sx1xz%j=&kl*sF99h#|?KJ(7T9yA|cJho+8>>J5M5=#mML^N^Ol%Wt#=sDd$vF z+27*PY2?56vcMy?G8VXnr6f3)Fi!8!wa+09)gE0ylhciLbz|X(gs9a0nO4{d@RenQ QHRX8_*msrs0f5OkO$&%m&j0`b literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256/.gitted/objects/23/8a501cf11a036f2f248008d88e14af624bb07fced6390997a0fa6abdad950a b/tests/resources/testrepo_256/.gitted/objects/23/8a501cf11a036f2f248008d88e14af624bb07fced6390997a0fa6abdad950a new file mode 100644 index 0000000000000000000000000000000000000000..66dc15db4869b30415e10f5559c83bd21e1cc737 GIT binary patch literal 143 zcmV;A0C4|!0V^p=O;s>7GGj0_FfcPQQ83XfsVHGMvvq;(iZJ#=1{Vca|LU9;dT|3^ zs-}RH!xjCk)2ws<&o?mu0)=FTDBZA`{}!8tZ_!@aqqM!Vd)0!si&z)QtiQAU!B21Y x-LoO;Qc@W#_e&k>IsC&}d-?fyr?UV5oyGsmvBGyp?4#HG;oCzkG66E(I?6KoNm2j+ literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256/.gitted/objects/26/149bf1ac4612f24b532ae50a12b15f26aace3718749624f008bde68670352a b/tests/resources/testrepo_256/.gitted/objects/26/149bf1ac4612f24b532ae50a12b15f26aace3718749624f008bde68670352a new file mode 100644 index 0000000000000000000000000000000000000000..bee6a42d79b08c80d27f1ff7f4f95189f55eb8fa GIT binary patch literal 202 zcmV;*05$)30d>z&N(3~>FKgs_E z!mZY07>DpMx`cxEQtzPe1=EZwDosY5K@}CF97|2nW9;RP@0Itze E*nhHQlK=n! literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256/.gitted/objects/2d/b6069c27ca4c08b784048644c307e17d0afe29b55f6488398cb59f13feb2f2 b/tests/resources/testrepo_256/.gitted/objects/2d/b6069c27ca4c08b784048644c307e17d0afe29b55f6488398cb59f13feb2f2 new file mode 100644 index 0000000000000000000000000000000000000000..3dfd5463ba9d6f8014964d36504bcb9b30ea3e74 GIT binary patch literal 238 zcmV5HexU|FfcPQQ3!H%bn$g%Fn%Js!*p4}?iiagzF#cHYk2nR zx}?v~_;lZD)^kRmPb*9efIuNJi9xw5K<1+qbH2Vx1ILX%k@ZR58|u$pv*et<;8)h( zwNtsE#wHad<|Svur)B1(>XlTKFibnx&oupUFXNX@x6a;MqB`qUwr1jM4yC<1JoX8i z%nYtjZF#BXVCA{-mnQD!Pj~T~x!O}-`s1Jbv8On1ZSwhS_#jYl%lU(gp~~}fQW&;L oPvPphS-Dt`A*|`>fjLU7W~GmAtGvqg);Lr8@*u|q05@b{udX9}%>V!Z literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256/.gitted/objects/33/e415b835a670bb5c3c760efa0433ac0cbd2d44679f68f2df3a9ae7014cf2a8 b/tests/resources/testrepo_256/.gitted/objects/33/e415b835a670bb5c3c760efa0433ac0cbd2d44679f68f2df3a9ae7014cf2a8 new file mode 100644 index 0000000000000000000000000000000000000000..cedb2a22e6914c3bbbed90bbedf8fd2095bf5a7d GIT binary patch literal 19 acmb-^#&K@VmFECanOevRMB$i#Rc`n6$Pz)g@z MiOzronCJc{NQdPt6aWAK literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256/.gitted/objects/3b/58565ee067f13349cd4f89aa396d10f71c69e168d5c48ea23de59734ec3ab1 b/tests/resources/testrepo_256/.gitted/objects/3b/58565ee067f13349cd4f89aa396d10f71c69e168d5c48ea23de59734ec3ab1 new file mode 100644 index 0000000000000000000000000000000000000000..1b299dc257b712a486bb7ec5bd07720d88001374 GIT binary patch literal 38 ucmbxW_q!r`tZ֬t=?~V1fT \ No newline at end of file diff --git a/tests/resources/testrepo_256/.gitted/objects/47/3a0f4c3be8a93681a267e3b1e9a7dcda1185436fe141f7749120a303721813 b/tests/resources/testrepo_256/.gitted/objects/47/3a0f4c3be8a93681a267e3b1e9a7dcda1185436fe141f7749120a303721813 new file mode 100644 index 0000000000000000000000000000000000000000..711223894375fe1186ac5bfffdc48fb1fa1e65cc GIT binary patch literal 15 WcmbBQQQ6W+Sv9;eTEK4oHX{LN+y0Ic;3tpET3 literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256/.gitted/objects/4d/f8ed86acaac5dc82b5652170996ce459d39e3a441e9759b635b0bc4ecc43fd b/tests/resources/testrepo_256/.gitted/objects/4d/f8ed86acaac5dc82b5652170996ce459d39e3a441e9759b635b0bc4ecc43fd new file mode 100644 index 0000000000000000000000000000000000000000..8dc1932822c30e3289f0b6a74ce1d27f99fbca04 GIT binary patch literal 57 zcmV-90LK4#0V^p=O;s>4WH2!R0tHJm21zbq&mf(H@@-9zz0NE-=O?!!p!aY2A)ohG P61T;?x-bs_fTI)&EzuSA literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256/.gitted/objects/5a/2d5699fea33657b42ba98c22b7898baaa0eda205a21cafdcb7e0f94b07bb9b b/tests/resources/testrepo_256/.gitted/objects/5a/2d5699fea33657b42ba98c22b7898baaa0eda205a21cafdcb7e0f94b07bb9b new file mode 100644 index 0000000000000000000000000000000000000000..dd993131694c0525737a02638048b52c66a7e051 GIT binary patch literal 64 zcmV-G0Kflu0Rc4t%Kvn7Wn~~VH2^U%Fg7$aATus>cys_Z>cT|@)WkqoWX$sO4SBB@ WgLD>cuFmhj5#sPz(+yzy7#1e#x*6;M literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256/.gitted/objects/5c/a8959deb2b8327458e0344523eb1ddeeef4bce03e35864640b452f84d26848 b/tests/resources/testrepo_256/.gitted/objects/5c/a8959deb2b8327458e0344523eb1ddeeef4bce03e35864640b452f84d26848 new file mode 100644 index 00000000000..39e27c06a34 --- /dev/null +++ b/tests/resources/testrepo_256/.gitted/objects/5c/a8959deb2b8327458e0344523eb1ddeeef4bce03e35864640b452f84d26848 @@ -0,0 +1 @@ +x1N1ERKPqx]#Sp'/}.ơj\1KRP8RDImP!D>p[ˡ0ൕD hSf !@-yZ S>\nS ]ɐClT[#GM|->~Sj־n^uGz?_zۛ.y,b0S ˤ/zQvYvɷ죛~/(jrS \ No newline at end of file diff --git a/tests/resources/testrepo_256/.gitted/objects/5d/bb1fff5c0094b31b25b4635ab9fbee66d65fe5dda47dd0ac5f01dd69a84c6f b/tests/resources/testrepo_256/.gitted/objects/5d/bb1fff5c0094b31b25b4635ab9fbee66d65fe5dda47dd0ac5f01dd69a84c6f new file mode 100644 index 00000000000..17fae64f464 --- /dev/null +++ b/tests/resources/testrepo_256/.gitted/objects/5d/bb1fff5c0094b31b25b4635ab9fbee66d65fe5dda47dd0ac5f01dd69a84c6f @@ -0,0 +1,3 @@ +xuKj1DS !'H.Og3 +96rݶ2> +d=-b5싓dŕĄP(De{+6;>4KĆrLf ,o} >rޖ/N-\W<[`1hǣ =KݮZN/{"?7bW \ No newline at end of file diff --git a/tests/resources/testrepo_256/.gitted/objects/61/489e9e831f1d9001084d39b79f964c293db8620d679ea3596673c8a326446e b/tests/resources/testrepo_256/.gitted/objects/61/489e9e831f1d9001084d39b79f964c293db8620d679ea3596673c8a326446e new file mode 100644 index 0000000000000000000000000000000000000000..0bece845b96b3be7ca7f12ebd967e1764ce64fa8 GIT binary patch literal 157 zcmV;O0Al}m0V^p=O;s>7v0yMXFfcPQQ3!H%bn$g%Shr~IVb&{rX1bqZ?C-q|W%?Vo zv1vWy_7YyrDizns#zlZq1ak~8AdGILV(N-9birXB2On*O+#@yn)LXYVaho%JeP zGx0Tt(q0`N`vgs923M%Iywq~Aa_@sq4IM2{ir(cMHr#0REbn7~n6Kme4WSKw2k&aU L-~1H-4}m~Ae2hy! literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256/.gitted/objects/6d/5fd291bb0f67444e99ab492f1bf1fcdf5dca09dab24cf331e05111b4cfc1a3 b/tests/resources/testrepo_256/.gitted/objects/6d/5fd291bb0f67444e99ab492f1bf1fcdf5dca09dab24cf331e05111b4cfc1a3 new file mode 100644 index 0000000000000000000000000000000000000000..112998d425717bb922ce74e8f6f0f831d8dc4510 GIT binary patch literal 24 gcmbBwx}Rd~@4XFW`Wv>f zX+7ii5?;+J71zneN1>|oQp@#9DoPl<4>~n;v^*(#mvh)~qtUaxkNsi3j_)^wHuxR9 NtMPvGR{&K(Dn}t?GcEuC literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256/.gitted/objects/73/8ff86401dbc5af692c83e660a4d510603c3f36e782a1a32ebd0388db6411ed b/tests/resources/testrepo_256/.gitted/objects/73/8ff86401dbc5af692c83e660a4d510603c3f36e782a1a32ebd0388db6411ed new file mode 100644 index 0000000000000000000000000000000000000000..4c973ea83afb1efa8040be2204a65922df718df6 GIT binary patch literal 181 zcmV;m080OO0iBOAP6ROwMX7U&^hn5d;v|+3+6z!|g4l61Be4t`viIMGBhY-k;=SVA zalP&>8mP{?jXCQ!Je}|U;BMlVp*fLKANE=x! literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256/.gitted/objects/73/b4f3c4f3182e6c8dd2c98aeb2c7811556538e7673e4b325307c71685fbf5b6 b/tests/resources/testrepo_256/.gitted/objects/73/b4f3c4f3182e6c8dd2c98aeb2c7811556538e7673e4b325307c71685fbf5b6 new file mode 100644 index 0000000000000000000000000000000000000000..67b84c462af40737559130399874eeb4b77a3873 GIT binary patch literal 108 zcmV-y0F(cC0V^p=O;xZoW-v4`Ff%bx2y%6F@pWZbw`lHR)+>Bwx}Rd~@4XFW`Wv>f zX+7ii5?;+J71zneN1>|oQp@#9DoPk~<1bCz&7bb#H*>Y8zVydG_hV0S-rD5z+3-Q2 O;Fj|T7Xtu2R4DnfG&Y$4 literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256/.gitted/objects/7e/4633ae1b0e83503dbea4417f9d5ccaf22b877c5a4522b6d1d2b16090ee2f6f b/tests/resources/testrepo_256/.gitted/objects/7e/4633ae1b0e83503dbea4417f9d5ccaf22b877c5a4522b6d1d2b16090ee2f6f new file mode 100644 index 0000000000000000000000000000000000000000..993a62b1637039118d63bec43013bdb924745aa8 GIT binary patch literal 141 zcmV;80CN9$0iBLp3c@fD0R7G>asg$xn`|nG2p+)`sd4(!0hkIsFwuiRDb vbB?*M_O|CAJf;?x_a*msw>ShM1{&F(Apn@e9w#dQv_@suWu43yI6^)tb_75M literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256/.gitted/objects/7e/9424c06052ca33bfc599bccadee60065d8664a9af7648a1455100c4f772e1c b/tests/resources/testrepo_256/.gitted/objects/7e/9424c06052ca33bfc599bccadee60065d8664a9af7648a1455100c4f772e1c new file mode 100644 index 00000000000..70bf64e16bf --- /dev/null +++ b/tests/resources/testrepo_256/.gitted/objects/7e/9424c06052ca33bfc599bccadee60065d8664a9af7648a1455100c4f772e1c @@ -0,0 +1,2 @@ +xAj1 -i,B(](ti2 =~]znxe_ץf]b$a9)yI '2iYTU[fWVa5su,Q +:POCp*)?~'x]6x˹\^žz٩WVbXmdf7@IP_Uo6IJc=qbL zq|eXzbl+;$b4H&}E1;_LQp@#9DoPk~<1bCz&7bb#H*>Y8zVydG_hV0S-rD5z+3-Q2 O;Fj|T7Xtt@NhwLRz&0BI literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256/.gitted/objects/90/1505c3355518bee35475c5d3f23bac1dded688b2bd314cc32b7f157e100724 b/tests/resources/testrepo_256/.gitted/objects/90/1505c3355518bee35475c5d3f23bac1dded688b2bd314cc32b7f157e100724 new file mode 100644 index 00000000000..09d0abfa7b4 --- /dev/null +++ b/tests/resources/testrepo_256/.gitted/objects/90/1505c3355518bee35475c5d3f23bac1dded688b2bd314cc32b7f157e100724 @@ -0,0 +1 @@ +xQJ1 })zM<'HZ7mf`t}yN3?R6BYwJeHR(LḾӎA#8z āPԵ5d(:XH2t_7yۗ]O:grrBp{=Zk ?s?TU \ No newline at end of file diff --git a/tests/resources/testrepo_256/.gitted/objects/93/1093620e5f050e2127fb0b96786ebaa9ee6535fb698ec01b5f7a800fa27cbe b/tests/resources/testrepo_256/.gitted/objects/93/1093620e5f050e2127fb0b96786ebaa9ee6535fb698ec01b5f7a800fa27cbe new file mode 100644 index 0000000000000000000000000000000000000000..70431af8128d71fe97407bd3333bfd6953435891 GIT binary patch literal 137 zcmV;40CxX)0iBLb3c@fDMqTF=vlk?jO#VQ`3%K$GnaPv}EQOlh-|7+Ee7wbb@X5L? zeE{Zs8k;Iaov<*Wb3uZSWkNwqjY7*U2c2qR8xjZ4NK9O~_|jUUrgHcWP2I=5Zt&ks34~NnJYDK-@s& literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256/.gitted/objects/94/ed253efa9e86fc636805c294c441d08b89b455903c0c14e9b16587fec081f5 b/tests/resources/testrepo_256/.gitted/objects/94/ed253efa9e86fc636805c294c441d08b89b455903c0c14e9b16587fec081f5 new file mode 100644 index 0000000000000000000000000000000000000000..41bcd18afbb47ff313b90874fa27decf3a34b5cb GIT binary patch literal 188 zcmV;t07L(H0iBQ0O$0FvMETw-(g4VD5<8I)x*s~A0Vj6Ylh_Mda=P{jE%5i|Nu$xU zaU9p_knw4rW)4t$3Ay#^sZ^*`1ynsrQ)Oh65-4`om|IHHO>qUyxnzhysczqL+HE?v zNFj*%3YJ5Hpw%Qs&%J1BO*&%D%q>Yw3rW4=nuG#o*r{)FpZhr7yFTPp_py)TXWZPY qE&E58&+FXp^`(vD&3WX2M8%VP1_s!cU9YD7x4(@q-F^W(?^Up9reI0hYPWM?<@LE8o(K`PkZiyW2X8cRHOfV>{BnkIcb` X82t2c`iq#_jy^W?S6Y4mjhI&pAZBds literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256/.gitted/objects/9d/aab17c25f647d652c72c8cc3cf4602c270a369beebc7d0b67238897bbc426b b/tests/resources/testrepo_256/.gitted/objects/9d/aab17c25f647d652c72c8cc3cf4602c270a369beebc7d0b67238897bbc426b new file mode 100644 index 00000000000..74b8385edc1 --- /dev/null +++ b/tests/resources/testrepo_256/.gitted/objects/9d/aab17c25f647d652c72c8cc3cf4602c270a369beebc7d0b67238897bbc426b @@ -0,0 +1 @@ +x+)JMU0d040031Qrutue0~"tY2_,kx꺤tjsFO+L @!1A+@sJǍ>I]䜾W޵S&%%għeT0L;4q/M[:Ufk:< Pmy`&OwS_8oml PpTO \ No newline at end of file diff --git a/tests/resources/testrepo_256/.gitted/objects/a4/813ef6708e6011e8187224297e83e4a285f58bf5eabb1db270351388603c95 b/tests/resources/testrepo_256/.gitted/objects/a4/813ef6708e6011e8187224297e83e4a285f58bf5eabb1db270351388603c95 new file mode 100644 index 0000000000000000000000000000000000000000..2419974cbc27d6c1afe3e38ab5a7b41ee67782a9 GIT binary patch literal 244 zcmVj1=F9WRbosttAR+ya|(cx z7H!qI3QFrHv9V~+$!AGYqzQRbni&u${T|DHgb&-t2yctpzJ=$z{f5`;s<+Q4+t-&6 uv7{OkAcaRL0Mkj&XNLc$JH7jH_0SI8YzdcD@2BSyZrj*Th|>?YL2LiRRDL}G literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256/.gitted/objects/ab/ee32b3339d1566d75613ea61f40c14bdfc5b101b60fde4f44b58dd06667640 b/tests/resources/testrepo_256/.gitted/objects/ab/ee32b3339d1566d75613ea61f40c14bdfc5b101b60fde4f44b58dd06667640 new file mode 100644 index 0000000000000000000000000000000000000000..b390250e308a62f1afc44c5f8e99e8196c1949ae GIT binary patch literal 63 zcmV-F0Korv0V^p=O;s>4V=y!@Ff%bx2y%6F@pWY|ej>WVbXmdf7@IP_Uo6IJc=qbL Vq|eXzbl+;$b4H&}D*(}y6gC9)8?68U literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256/.gitted/objects/ae/a29dc305d40e362df25c3fdeed5502fd56b182af01b7740d297a24459333c5 b/tests/resources/testrepo_256/.gitted/objects/ae/a29dc305d40e362df25c3fdeed5502fd56b182af01b7740d297a24459333c5 new file mode 100644 index 0000000000000000000000000000000000000000..18a7f61c29ea8c5c9a48e3b30bead7f058d06293 GIT binary patch literal 26 icmb4W(dj1ELH%b#5{%koD_wmqQt!93`H&goVE$TEmshD literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256/.gitted/objects/b8/3624f6ac0995273c0034a7ab8c68929bdc91b69ad54ef94979b93eba3f6022 b/tests/resources/testrepo_256/.gitted/objects/b8/3624f6ac0995273c0034a7ab8c68929bdc91b69ad54ef94979b93eba3f6022 new file mode 100644 index 0000000000000000000000000000000000000000..3e36331ea660f96ddc6389c51c0b5b04bae31f94 GIT binary patch literal 190 zcmV;v073tF0iBOqN(3j0%EkJD$BPXewzWa z!-|SjiYX>T;Sx)U;<=r*<^V|U%o(URa?V)6q-3Ma8tbC>xs4-y*qAfCZ))QfUVrR& sTt0Wbe!bY(-$G1+k|I$F&maKHNzX^q|Klzi`nVr+3xAd60TLfo5g`3pC;$Ke literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256/.gitted/objects/bd/f2066a28e11603a1af04157ee4aad97814279fe500340eb3465797cbd3be23 b/tests/resources/testrepo_256/.gitted/objects/bd/f2066a28e11603a1af04157ee4aad97814279fe500340eb3465797cbd3be23 new file mode 100644 index 0000000000000000000000000000000000000000..9bb5b623bdbc11a70db482867b5b26d0d7b3215c GIT binary patch literal 23 fcmb4WH2!R0tE{b2HziV+t#c)dZ%e?s$#*+oF|c&=UKVPO^@7W Px?zvs8Rx$M(km5$Qz#fi literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256/.gitted/objects/bf/cc4074ac517ed24d61b0aaa96359f304c3dc97e95f336269ed474ea846ada5 b/tests/resources/testrepo_256/.gitted/objects/bf/cc4074ac517ed24d61b0aaa96359f304c3dc97e95f336269ed474ea846ada5 new file mode 100644 index 0000000000000000000000000000000000000000..be8b99bba80435c6152a727a07b56daeefda6569 GIT binary patch literal 198 zcmV;%06G770V^p=O;s?ouw*baFfcPQQ3!H%bn$g%Fn%Js!*p4}?iiagzF#cHYk2nR zx}?v~_;lZD)^kRmPb*9efIuNJi9xw5K<1+qbH2Vx1ILX%k@ZR58|u$pv*et<;8)h( zwNtsE#wHad<|Svur)B1(>XlTKFibnx&oupUFXNX@x6a;MqB`qUwr1jM4yC<1JoX8i z%nYtjZF#BXVCB{kVQ~-AKN@?U_3vC|nJe&JCi7v&)gyh2Y@bdyd1JK^0G=>TfAl9| Ae*gdg literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256/.gitted/objects/c2/58f010a08328a29cde33411d955520e0375fcbbcc14b7636a70f7536c32ef6 b/tests/resources/testrepo_256/.gitted/objects/c2/58f010a08328a29cde33411d955520e0375fcbbcc14b7636a70f7536c32ef6 new file mode 100644 index 00000000000..9d2ceb1fff9 --- /dev/null +++ b/tests/resources/testrepo_256/.gitted/objects/c2/58f010a08328a29cde33411d955520e0375fcbbcc14b7636a70f7536c32ef6 @@ -0,0 +1,2 @@ +x0D=+nbvK[Jb?x֥փ/I^ P1=%+X5IO6u =V*pD]hvG/H,o r1@eLp +0s>?H!"s}t3,ͳIm3 \ No newline at end of file diff --git a/tests/resources/testrepo_256/.gitted/objects/ca/31f7336e882a233a2943787c5e94ba024ac9a4f763cb1d9bfd8e63aa7f7269 b/tests/resources/testrepo_256/.gitted/objects/ca/31f7336e882a233a2943787c5e94ba024ac9a4f763cb1d9bfd8e63aa7f7269 new file mode 100644 index 0000000000000000000000000000000000000000..cfcdac3069711e3c0e4779477c932e2e4dea8d59 GIT binary patch literal 182 zcmV;n07?IN0iBOAP6ROwMX7U&^hn5#9Vd|x+6z!|f;e_GBe4t`viIMGBhY-k;=SUJ z<9gj!Oaf2qbdTZ_n=+=9MLKjX*PZtCZX kuRjmE{LagMyhS9gML1QC&yWDZ_&c=xA8DX)2hjgc&6D$5qyPW_ literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256/.gitted/objects/cb/282e7c15fd8aeb2265cd621f5a228cb33dc84192980ca426cf9ab2a48cb9f0 b/tests/resources/testrepo_256/.gitted/objects/cb/282e7c15fd8aeb2265cd621f5a228cb33dc84192980ca426cf9ab2a48cb9f0 new file mode 100644 index 0000000000000000000000000000000000000000..77d9ec27d546841923f4d7688b1675af7e8e4d09 GIT binary patch literal 187 zcmV;s07U014!Q&1J`S7%pUi!~ zFHa>stW(ujOsS>X`(UW5qgJUb4eF2>VWG)N3h{_=-}`0|#}?&_IpZ=o@DON9;t+k5QzLE6aaV8>(SExxQ>sxwoCnsxF4}jRtl?nS=|5t literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256/.gitted/objects/cc/b5a03da85607c230d111abfa899655d1b00e6529101a40d42f6acb059dff9f b/tests/resources/testrepo_256/.gitted/objects/cc/b5a03da85607c230d111abfa899655d1b00e6529101a40d42f6acb059dff9f new file mode 100644 index 0000000000000000000000000000000000000000..a67d6e647ccc1f3faad53aa928441dcf66808c42 GIT binary patch literal 21 dcmbtwae_U^_9p60<==wtq&H!0qWh{lmAp z@3$2T<)?Lw5xq!G%^L|QdS~f%8-3dbn}R9Q0Bmk&<*ou<3B4LSp*E>N;aiSzUok6c z#afH@2JWS)BU%^M!Qd!vrBtQ@s+$5CXGS4PT2E&MgFM!C9`VEGTJilVHt+HE$Nu2* jxy$YA#peDNGvvYuR46{Dno>CJ`Dl&*Y(w}3o8?f{IrmoS literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256/.gitted/objects/eb/ead5965196dfaeab52b1a5d92b78e54493fdaa78f72268d4cc69b61d5feee1 b/tests/resources/testrepo_256/.gitted/objects/eb/ead5965196dfaeab52b1a5d92b78e54493fdaa78f72268d4cc69b61d5feee1 new file mode 100644 index 0000000000000000000000000000000000000000..225c45734e0bc525ec231bcba0d6ffd2e335a5d0 GIT binary patch literal 21 dcmb7v0yMXFfcPQQ3!H%bn$g%Shr~IVb&{rX1bqZ?C-q|W%?Vo zv1vWy_7YyrDizns#zlZq1ak~8AdGILV(N-9bi_I_f^(s(Gwyl_2>Xx)=lH!DQc z=RajI;oIyMKK=CNeacX6d8y@K<=zLK8ai5@6urwiY`D?rS>DI~Fki>_8$uiW4&K#x LzxgWw+t)xa*56Lu literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256/.gitted/objects/f2/c8da1a7c2eb49ff25c47441f0b3f387faeddde1b37d0ad2f3f6a63f5327978 b/tests/resources/testrepo_256/.gitted/objects/f2/c8da1a7c2eb49ff25c47441f0b3f387faeddde1b37d0ad2f3f6a63f5327978 new file mode 100644 index 0000000000000000000000000000000000000000..04bf5eb0621c5e6a453ac232bf04198f7a6a04ce GIT binary patch literal 192 zcmV;x06+hD0iBP*ZNo4O0Q>e7TA&4KQIrG}ML*e~3s52%=V3c=6=eOmEA)3b;2zia zb-j%+=lV7dv(UVEf=tpAX49FJv4MzGj;VSC>QQ^mR+GobGgni}WKxJlB~5oZY#RX( z3m~|)f^LMZsxz@-EX7v0yMXFfcPQQ3!H%bn$g%Fn%Js!*p4}?iiagzF#cHYk2nR zx}?v~_;lZD)^kRmPb;9RlZq1ak~8AdGILV(N-9birXB2On*O+#@yn)LXYVaho%JeP zGx0Tt(q0`N`vgs923M%Iywq~A^4$1K6L<5cyZFsq?Wr&Q@z4F(Q=GRp`Fu8f5Gc6i L{K3Tl{;EGa8DLRL literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256/.gitted/objects/pack/pack-b87f1f214098b19ce092afb9ef6e7643653c03e7f91faa27b767e3eb8225f0f6.idx b/tests/resources/testrepo_256/.gitted/objects/pack/pack-b87f1f214098b19ce092afb9ef6e7643653c03e7f91faa27b767e3eb8225f0f6.idx new file mode 100644 index 0000000000000000000000000000000000000000..897e8a478fcd5da84a4faf07f1d47e873809c40c GIT binary patch literal 1336 zcmexg;-AdGz`z8=LlH0n9gPix{4*FaGtgb6ViusDfyAsp`$sY9VZa6qw;_XdTSbe? zt)5tGZM8A@8Pr~PYgJ!anh zD`si9^@YFJi=Vu@&DZ9b?P0GIaKf^6-s!gAVT%eEF>R}PI?XA-h^~1Nyk|gsYf%8$~m*)2`Jr>GVb$z9txX6d+H=mR&5mLJN9RQC) BmmmND literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256/.gitted/objects/pack/pack-b87f1f214098b19ce092afb9ef6e7643653c03e7f91faa27b767e3eb8225f0f6.pack b/tests/resources/testrepo_256/.gitted/objects/pack/pack-b87f1f214098b19ce092afb9ef6e7643653c03e7f91faa27b767e3eb8225f0f6.pack new file mode 100644 index 0000000000000000000000000000000000000000..9c8557886c820187eb37b4d68a70c42aeaccc895 GIT binary patch literal 569 zcmV-90>=GNK|@Ob00062000J-5qO-Pj$uj!F$_lk&nbEVB~6od3bF`$1W%Bpsk`WG zWwzq=9rXtO`*`pk-`w2;wv{6nEG3CkQdEV?l)4M`l%YmOG|C22jVfvL#-^!3PkD}hK!yfe5D3>oHH~qFf%bxNX*MG$w)2I zE2$`9h_qJIzJA~cZ{jp9v!5?#m@w_{_Kt{3a$Qm_CS@pT!EOlAQkp9Tt4u9XNX*MG$w)0y zNXyJgZmc$_QGNGwrE%gjl&=K=s2`2)UmErk_wcRJ)dE3lPA{-pC@ky0#1 zz^TNPz3p7H(DMS}c$`Z$o?r|B1B3xwxPKoZK$x+d;F7Po?{0QOWjq7t`5&q$w`b$) Hf+g_whLjGt literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256/.gitted/objects/pack/pack-e2f07f30db7e480ea84a0e64ee791b9b270067124b2609019b74f33f256f33fa.idx b/tests/resources/testrepo_256/.gitted/objects/pack/pack-e2f07f30db7e480ea84a0e64ee791b9b270067124b2609019b74f33f256f33fa.idx new file mode 100644 index 0000000000000000000000000000000000000000..9e2ec99c546e6de5f8279f1abfc0f254565d625b GIT binary patch literal 66216 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%0D&XxF~7)M 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