kernel
/
git
mirror of https://git.kernel.org/pub/scm/git/git.git
1
0
Fork 0
Code Releases Activity

Merge branch 'sj/ref-contents-check' 

"git fsck" learned to issue warnings on "curiously formatted" ref
contents that have always been taken valid but something Git
wouldn't have written itself (e.g., missing terminating end-of-line
after the full object name).

* sj/ref-contents-check:
  ref: add symlink ref content check for files backend
  ref: check whether the target of the symref is a ref
  ref: add basic symref content check for files backend
  ref: add more strict checks for regular refs
  ref: port git-fsck(1) regular refs check for files backend
  ref: support multiple worktrees check for refs
  ref: initialize ref name outside of check functions
  ref: check the full refname instead of basename
  ref: initialize "fsck_ref_report" with zero
maint
Junio C Hamano 2024-12-04 10:14:42 +09:00
parent 7ee055b237 c9f03f3882
commit 57e81b59f3
11 changed files with 793 additions and 65 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

35
Documentation/fsck-msgids.txt
View File

@ -19,12 +19,18 @@
`badParentSha1`::
(ERROR) A commit object has a bad parent sha1.

`badRefContent`::
(ERROR) A ref has bad content.

`badRefFiletype`::
(ERROR) A ref has a bad file type.

`badRefName`::
(ERROR) A ref has an invalid format.

`badReferentName`::
(ERROR) The referent name of a symref is invalid.

`badTagName`::
(INFO) A tag has an invalid format.

@ -170,6 +176,35 @@
`nullSha1`::
(WARN) Tree contains entries pointing to a null sha1.

`refMissingNewline`::
(INFO) A loose ref that does not end with newline(LF). As
valid implementations of Git never created such a loose ref
file, it may become an error in the future. Report to the
git@vger.kernel.org mailing list if you see this error, as
we need to know what tools created such a file.

`symlinkRef`::
(INFO) A symbolic link is used as a symref. Report to the
git@vger.kernel.org mailing list if you see this error, as we
are assessing the feasibility of dropping the support to drop
creating symbolic links as symrefs.

`symrefTargetIsNotARef`::
(INFO) The target of a symbolic reference points neither to
a root reference nor to a reference starting with "refs/".
Although we allow create a symref pointing to the referent which
is outside the "ref" by using `git symbolic-ref`, we may tighten
the rule in the future. Report to the git@vger.kernel.org
mailing list if you see this error, as we need to know what tools
created such a file.

`trailingRefContent`::
(INFO) A loose ref has trailing content. As valid implementations
of Git never created such a loose ref file, it may become an
error in the future. Report to the git@vger.kernel.org mailing
list if you see this error, as we need to know what tools
created such a file.

`treeNotSorted`::
(ERROR) A tree is not properly sorted.


10
builtin/refs.c
View File

@ -5,6 +5,7 @@
#include "parse-options.h"
#include "refs.h"
#include "strbuf.h"
#include "worktree.h"

#define REFS_MIGRATE_USAGE \
N_("git refs migrate --ref-format=<format> [--dry-run]")
@ -66,6 +67,7 @@ out:
static int cmd_refs_verify(int argc, const char **argv, const char *prefix)
{
struct fsck_options fsck_refs_options = FSCK_REFS_OPTIONS_DEFAULT;
struct worktree **worktrees;
const char * const verify_usage[] = {
REFS_VERIFY_USAGE,
NULL,
@ -75,7 +77,7 @@ static int cmd_refs_verify(int argc, const char **argv, const char *prefix)
OPT_BOOL(0, "strict", &fsck_refs_options.strict, N_("enable strict checking")),
OPT_END(),
};
int ret;
int ret = 0;

argc = parse_options(argc, argv, prefix, options, verify_usage, 0);
if (argc)
@ -84,9 +86,13 @@ static int cmd_refs_verify(int argc, const char **argv, const char *prefix)
git_config(git_fsck_config, &fsck_refs_options);
prepare_repo_settings(the_repository);

ret = refs_fsck(get_main_ref_store(the_repository), &fsck_refs_options);
worktrees = get_worktrees();
for (size_t i = 0; worktrees[i]; i++)
ret |= refs_fsck(get_worktree_ref_store(worktrees[i]),
&fsck_refs_options, worktrees[i]);

fsck_options_clear(&fsck_refs_options);
free_worktrees(worktrees);
return ret;
}


6
fsck.h
View File

@ -31,8 +31,10 @@ enum fsck_msg_type {
FUNC(BAD_NAME, ERROR) \
FUNC(BAD_OBJECT_SHA1, ERROR) \
FUNC(BAD_PARENT_SHA1, ERROR) \
FUNC(BAD_REF_CONTENT, ERROR) \
FUNC(BAD_REF_FILETYPE, ERROR) \
FUNC(BAD_REF_NAME, ERROR) \
FUNC(BAD_REFERENT_NAME, ERROR) \
FUNC(BAD_TIMEZONE, ERROR) \
FUNC(BAD_TREE, ERROR) \
FUNC(BAD_TREE_SHA1, ERROR) \
@ -84,6 +86,10 @@ enum fsck_msg_type {
FUNC(MAILMAP_SYMLINK, INFO) \
FUNC(BAD_TAG_NAME, INFO) \
FUNC(MISSING_TAGGER_ENTRY, INFO) \
FUNC(SYMLINK_REF, INFO) \
FUNC(REF_MISSING_NEWLINE, INFO) \
FUNC(SYMREF_TARGET_IS_NOT_A_REF, INFO) \
FUNC(TRAILING_REF_CONTENT, INFO) \
/* ignored (elevated when requested) */ \
FUNC(EXTRA_HEADER_ENTRY, IGNORE)


7
refs.c
View File

@ -318,9 +318,10 @@ int check_refname_format(const char *refname, int flags)
return check_or_sanitize_refname(refname, flags, NULL);
}

int refs_fsck(struct ref_store *refs, struct fsck_options *o)
int refs_fsck(struct ref_store *refs, struct fsck_options *o,
struct worktree *wt)
{
return refs->be->fsck(refs, o);
return refs->be->fsck(refs, o, wt);
}

void sanitize_refname_component(const char *refname, struct strbuf *out)
@ -1791,7 +1792,7 @@ static int refs_read_special_head(struct ref_store *ref_store,
}

result = parse_loose_ref_contents(ref_store->repo->hash_algo, content.buf,
oid, referent, type, failure_errno);
oid, referent, type, NULL, failure_errno);

done:
strbuf_release(&full_path);

3
refs.h
View File

@ -550,7 +550,8 @@ int check_refname_format(const char *refname, int flags);
* reflogs are consistent, and non-zero otherwise. The errors will be
* written to stderr.
*/
int refs_fsck(struct ref_store *refs, struct fsck_options *o);
int refs_fsck(struct ref_store *refs, struct fsck_options *o,
struct worktree *wt);

/*
* Apply the rules from check_refname_format, but mutate the result until it

5
refs/debug.c
View File

@ -408,10 +408,11 @@ static int debug_reflog_expire(struct ref_store *ref_store, const char *refname,
}

static int debug_fsck(struct ref_store *ref_store,
struct fsck_options *o)
struct fsck_options *o,
struct worktree *wt)
{
struct debug_ref_store *drefs = (struct debug_ref_store *)ref_store;
int res = drefs->refs->be->fsck(drefs->refs, o);
int res = drefs->refs->be->fsck(drefs->refs, o, wt);
trace_printf_key(&trace_refs, "fsck: %d\n", res);
return res;
}

194
refs/files-backend.c
View File

@ -1,6 +1,7 @@
#define USE_THE_REPOSITORY_VARIABLE

#include "../git-compat-util.h"
#include "../abspath.h"
#include "../config.h"
#include "../copy.h"
#include "../environment.h"
@ -23,6 +24,7 @@
#include "../dir.h"
#include "../chdir-notify.h"
#include "../setup.h"
#include "../worktree.h"
#include "../wrapper.h"
#include "../write-or-die.h"
#include "../revision.h"
@ -568,7 +570,7 @@ stat_ref:
buf = sb_contents.buf;

ret = parse_loose_ref_contents(ref_store->repo->hash_algo, buf,
oid, referent, type, &myerr);
oid, referent, type, NULL, &myerr);

out:
if (ret && !myerr)
@ -605,7 +607,7 @@ static int files_read_symbolic_ref(struct ref_store *ref_store, const char *refn
int parse_loose_ref_contents(const struct git_hash_algo *algop,
const char *buf, struct object_id *oid,
struct strbuf *referent, unsigned int *type,
int *failure_errno)
const char **trailing, int *failure_errno)
{
const char *p;
if (skip_prefix(buf, "ref:", &buf)) {
@ -627,6 +629,10 @@ int parse_loose_ref_contents(const struct git_hash_algo *algop,
*failure_errno = EINVAL;
return -1;
}

if (trailing)
*trailing = p;

return 0;
}

@ -3528,12 +3534,153 @@ static int files_ref_store_remove_on_disk(struct ref_store *ref_store,
*/
typedef int (*files_fsck_refs_fn)(struct ref_store *ref_store,
struct fsck_options *o,
const char *refs_check_dir,
const char *refname,
struct dir_iterator *iter);

static int files_fsck_symref_target(struct fsck_options *o,
struct fsck_ref_report *report,
struct strbuf *referent,
unsigned int symbolic_link)
{
int is_referent_root;
char orig_last_byte;
size_t orig_len;
int ret = 0;

orig_len = referent->len;
orig_last_byte = referent->buf[orig_len - 1];
if (!symbolic_link)
strbuf_rtrim(referent);

is_referent_root = is_root_ref(referent->buf);
if (!is_referent_root &&
!starts_with(referent->buf, "refs/") &&
!starts_with(referent->buf, "worktrees/")) {
ret = fsck_report_ref(o, report,
FSCK_MSG_SYMREF_TARGET_IS_NOT_A_REF,
"points to non-ref target '%s'", referent->buf);

}

if (!is_referent_root && check_refname_format(referent->buf, 0)) {
ret = fsck_report_ref(o, report,
FSCK_MSG_BAD_REFERENT_NAME,
"points to invalid refname '%s'", referent->buf);
goto out;
}

if (symbolic_link)
goto out;

if (referent->len == orig_len ||
(referent->len < orig_len && orig_last_byte != '\n')) {
ret = fsck_report_ref(o, report,
FSCK_MSG_REF_MISSING_NEWLINE,
"misses LF at the end");
}

if (referent->len != orig_len && referent->len != orig_len - 1) {
ret = fsck_report_ref(o, report,
FSCK_MSG_TRAILING_REF_CONTENT,
"has trailing whitespaces or newlines");
}

out:
return ret;
}

static int files_fsck_refs_content(struct ref_store *ref_store,
struct fsck_options *o,
const char *target_name,
struct dir_iterator *iter)
{
struct strbuf ref_content = STRBUF_INIT;
struct strbuf abs_gitdir = STRBUF_INIT;
struct strbuf referent = STRBUF_INIT;
struct fsck_ref_report report = { 0 };
const char *trailing = NULL;
unsigned int type = 0;
int failure_errno = 0;
struct object_id oid;
int ret = 0;

report.path = target_name;

if (S_ISLNK(iter->st.st_mode)) {
const char *relative_referent_path = NULL;

ret = fsck_report_ref(o, &report,
FSCK_MSG_SYMLINK_REF,
"use deprecated symbolic link for symref");

strbuf_add_absolute_path(&abs_gitdir, ref_store->repo->gitdir);
strbuf_normalize_path(&abs_gitdir);
if (!is_dir_sep(abs_gitdir.buf[abs_gitdir.len - 1]))
strbuf_addch(&abs_gitdir, '/');

strbuf_add_real_path(&ref_content, iter->path.buf);
skip_prefix(ref_content.buf, abs_gitdir.buf,
&relative_referent_path);

if (relative_referent_path)
strbuf_addstr(&referent, relative_referent_path);
else
strbuf_addbuf(&referent, &ref_content);

ret |= files_fsck_symref_target(o, &report, &referent, 1);
goto cleanup;
}

if (strbuf_read_file(&ref_content, iter->path.buf, 0) < 0) {
/*
* Ref file could be removed by another concurrent process. We should
* ignore this error and continue to the next ref.
*/
if (errno == ENOENT)
goto cleanup;

ret = error_errno(_("cannot read ref file '%s'"), iter->path.buf);
goto cleanup;
}

if (parse_loose_ref_contents(ref_store->repo->hash_algo,
ref_content.buf, &oid, &referent,
&type, &trailing, &failure_errno)) {
strbuf_rtrim(&ref_content);
ret = fsck_report_ref(o, &report,
FSCK_MSG_BAD_REF_CONTENT,
"%s", ref_content.buf);
goto cleanup;
}

if (!(type & REF_ISSYMREF)) {
if (!*trailing) {
ret = fsck_report_ref(o, &report,
FSCK_MSG_REF_MISSING_NEWLINE,
"misses LF at the end");
goto cleanup;
}
if (*trailing != '\n' || *(trailing + 1)) {
ret = fsck_report_ref(o, &report,
FSCK_MSG_TRAILING_REF_CONTENT,
"has trailing garbage: '%s'", trailing);
goto cleanup;
}
} else {
ret = files_fsck_symref_target(o, &report, &referent, 0);
goto cleanup;
}

cleanup:
strbuf_release(&ref_content);
strbuf_release(&referent);
strbuf_release(&abs_gitdir);
return ret;
}

static int files_fsck_refs_name(struct ref_store *ref_store UNUSED,
struct fsck_options *o,
const char *refs_check_dir,
const char *refname,
struct dir_iterator *iter)
{
struct strbuf sb = STRBUF_INIT;
@ -3546,11 +3693,13 @@ static int files_fsck_refs_name(struct ref_store *ref_store UNUSED,
if (iter->basename[0] != '.' && ends_with(iter->basename, ".lock"))
goto cleanup;

if (check_refname_format(iter->basename, REFNAME_ALLOW_ONELEVEL)) {
struct fsck_ref_report report = { .path = NULL };
/*
* This works right now because we never check the root refs.
*/
if (check_refname_format(refname, 0)) {
struct fsck_ref_report report = { 0 };

strbuf_addf(&sb, "%s/%s", refs_check_dir, iter->relative_path);
report.path = sb.buf;
report.path = refname;
ret = fsck_report_ref(o, &report,
FSCK_MSG_BAD_REF_NAME,
"invalid refname format");
@ -3564,8 +3713,10 @@ cleanup:
static int files_fsck_refs_dir(struct ref_store *ref_store,
struct fsck_options *o,
const char *refs_check_dir,
struct worktree *wt,
files_fsck_refs_fn *fsck_refs_fn)
{
struct strbuf refname = STRBUF_INIT;
struct strbuf sb = STRBUF_INIT;
struct dir_iterator *iter;
int iter_status;
@ -3584,11 +3735,18 @@ static int files_fsck_refs_dir(struct ref_store *ref_store,
continue;
} else if (S_ISREG(iter->st.st_mode) ||
S_ISLNK(iter->st.st_mode)) {
strbuf_reset(&refname);

if (!is_main_worktree(wt))
strbuf_addf(&refname, "worktrees/%s/", wt->id);
strbuf_addf(&refname, "%s/%s", refs_check_dir,
iter->relative_path);

if (o->verbose)
fprintf_ln(stderr, "Checking %s/%s",
refs_check_dir, iter->relative_path);
fprintf_ln(stderr, "Checking %s", refname.buf);

for (size_t i = 0; fsck_refs_fn[i]; i++) {
if (fsck_refs_fn[i](ref_store, o, refs_check_dir, iter))
if (fsck_refs_fn[i](ref_store, o, refname.buf, iter))
ret = -1;
}
} else {
@ -3605,30 +3763,34 @@ static int files_fsck_refs_dir(struct ref_store *ref_store,

out:
strbuf_release(&sb);
strbuf_release(&refname);
return ret;
}

static int files_fsck_refs(struct ref_store *ref_store,
struct fsck_options *o)
struct fsck_options *o,
struct worktree *wt)
{
files_fsck_refs_fn fsck_refs_fn[]= {
files_fsck_refs_name,
files_fsck_refs_content,
NULL,
};

if (o->verbose)
fprintf_ln(stderr, _("Checking references consistency"));
return files_fsck_refs_dir(ref_store, o, "refs", fsck_refs_fn);
return files_fsck_refs_dir(ref_store, o, "refs", wt, fsck_refs_fn);
}

static int files_fsck(struct ref_store *ref_store,
struct fsck_options *o)
struct fsck_options *o,
struct worktree *wt)
{
struct files_ref_store *refs =
files_downcast(ref_store, REF_STORE_READ, "fsck");

return files_fsck_refs(ref_store, o) |
refs->packed_ref_store->be->fsck(refs->packed_ref_store, o);
return files_fsck_refs(ref_store, o, wt) |
refs->packed_ref_store->be->fsck(refs->packed_ref_store, o, wt);
}

struct ref_storage_be refs_be_files = {

8
refs/packed-backend.c
View File

@ -13,6 +13,7 @@
#include "../lockfile.h"
#include "../chdir-notify.h"
#include "../statinfo.h"
#include "../worktree.h"
#include "../wrapper.h"
#include "../write-or-die.h"
#include "../trace2.h"
@ -1747,8 +1748,13 @@ static struct ref_iterator *packed_reflog_iterator_begin(struct ref_store *ref_s
}

static int packed_fsck(struct ref_store *ref_store UNUSED,
struct fsck_options *o UNUSED)
struct fsck_options *o UNUSED,
struct worktree *wt)
{

if (!is_main_worktree(wt))
return 0;

return 0;
}


5
refs/refs-internal.h
View File

@ -654,7 +654,8 @@ typedef int read_symbolic_ref_fn(struct ref_store *ref_store, const char *refnam
struct strbuf *referent);

typedef int fsck_fn(struct ref_store *ref_store,
struct fsck_options *o);
struct fsck_options *o,
struct worktree *wt);

struct ref_storage_be {
const char *name;
@ -715,7 +716,7 @@ struct ref_store {
int parse_loose_ref_contents(const struct git_hash_algo *algop,
const char *buf, struct object_id *oid,
struct strbuf *referent, unsigned int *type,
int *failure_errno);
const char **trailing, int *failure_errno);

/*
* Fill in the generic part of refs and add it to our collection of

3
refs/reftable-backend.c
View File

@ -2470,7 +2470,8 @@ done:
}

static int reftable_be_fsck(struct ref_store *ref_store UNUSED,
struct fsck_options *o UNUSED)
struct fsck_options *o UNUSED,
struct worktree *wt UNUSED)
{
return 0;
}

582
t/t0602-reffiles-fsck.sh
View File

@ -17,63 +17,81 @@ test_expect_success 'ref name should be checked' '
cd repo &&

git commit --allow-empty -m initial &&
git checkout -b branch-1 &&
git tag tag-1 &&
git commit --allow-empty -m second &&
git checkout -b branch-2 &&
git tag tag-2 &&
git tag multi_hierarchy/tag-2 &&
git checkout -b default-branch &&
git tag default-tag &&
git tag multi_hierarchy/default-tag &&

cp $branch_dir_prefix/branch-1 $branch_dir_prefix/.branch-1 &&
test_must_fail git refs verify 2>err &&
cat >expect <<-EOF &&
error: refs/heads/.branch-1: badRefName: invalid refname format
EOF
rm $branch_dir_prefix/.branch-1 &&
test_cmp expect err &&

cp $branch_dir_prefix/branch-1 $branch_dir_prefix/@ &&
test_must_fail git refs verify 2>err &&
cat >expect <<-EOF &&
error: refs/heads/@: badRefName: invalid refname format
EOF
cp $branch_dir_prefix/default-branch $branch_dir_prefix/@ &&
git refs verify 2>err &&
test_must_be_empty err &&
rm $branch_dir_prefix/@ &&
test_cmp expect err &&

cp $tag_dir_prefix/multi_hierarchy/tag-2 $tag_dir_prefix/multi_hierarchy/@ &&
test_must_fail git refs verify 2>err &&
cat >expect <<-EOF &&
error: refs/tags/multi_hierarchy/@: badRefName: invalid refname format
EOF
rm $tag_dir_prefix/multi_hierarchy/@ &&
test_cmp expect err &&

cp $tag_dir_prefix/tag-1 $tag_dir_prefix/tag-1.lock &&
cp $tag_dir_prefix/default-tag $tag_dir_prefix/tag-1.lock &&
git refs verify 2>err &&
rm $tag_dir_prefix/tag-1.lock &&
test_must_be_empty err &&

cp $tag_dir_prefix/tag-1 $tag_dir_prefix/.lock &&
cp $tag_dir_prefix/default-tag $tag_dir_prefix/.lock &&
test_must_fail git refs verify 2>err &&
cat >expect <<-EOF &&
error: refs/tags/.lock: badRefName: invalid refname format
EOF
rm $tag_dir_prefix/.lock &&
test_cmp expect err
test_cmp expect err &&

for refname in ".refname-starts-with-dot" "~refname-has-stride"
do
cp $branch_dir_prefix/default-branch "$branch_dir_prefix/$refname" &&
test_must_fail git refs verify 2>err &&
cat >expect <<-EOF &&
error: refs/heads/$refname: badRefName: invalid refname format
EOF
rm "$branch_dir_prefix/$refname" &&
test_cmp expect err || return 1
done &&

for refname in ".refname-starts-with-dot" "~refname-has-stride"
do
cp $tag_dir_prefix/default-tag "$tag_dir_prefix/$refname" &&
test_must_fail git refs verify 2>err &&
cat >expect <<-EOF &&
error: refs/tags/$refname: badRefName: invalid refname format
EOF
rm "$tag_dir_prefix/$refname" &&
test_cmp expect err || return 1
done &&

for refname in ".refname-starts-with-dot" "~refname-has-stride"
do
cp $tag_dir_prefix/multi_hierarchy/default-tag "$tag_dir_prefix/multi_hierarchy/$refname" &&
test_must_fail git refs verify 2>err &&
cat >expect <<-EOF &&
error: refs/tags/multi_hierarchy/$refname: badRefName: invalid refname format
EOF
rm "$tag_dir_prefix/multi_hierarchy/$refname" &&
test_cmp expect err || return 1
done &&

for refname in ".refname-starts-with-dot" "~refname-has-stride"
do
mkdir "$branch_dir_prefix/$refname" &&
cp $branch_dir_prefix/default-branch "$branch_dir_prefix/$refname/default-branch" &&
test_must_fail git refs verify 2>err &&
cat >expect <<-EOF &&
error: refs/heads/$refname/default-branch: badRefName: invalid refname format
EOF
rm -r "$branch_dir_prefix/$refname" &&
test_cmp expect err || return 1
done
'

test_expect_success 'ref name check should be adapted into fsck messages' '
test_when_finished "rm -rf repo" &&
git init repo &&
branch_dir_prefix=.git/refs/heads &&
tag_dir_prefix=.git/refs/tags &&
cd repo &&
git commit --allow-empty -m initial &&
git checkout -b branch-1 &&
git tag tag-1 &&
git commit --allow-empty -m second &&
git checkout -b branch-2 &&
git tag tag-2 &&

cp $branch_dir_prefix/branch-1 $branch_dir_prefix/.branch-1 &&
git -c fsck.badRefName=warn refs verify 2>err &&
@ -83,9 +101,499 @@ test_expect_success 'ref name check should be adapted into fsck messages' '
rm $branch_dir_prefix/.branch-1 &&
test_cmp expect err &&

cp $branch_dir_prefix/branch-1 $branch_dir_prefix/@ &&
cp $branch_dir_prefix/branch-1 $branch_dir_prefix/.branch-1 &&
git -c fsck.badRefName=ignore refs verify 2>err &&
test_must_be_empty err
'

test_expect_success 'ref name check should work for multiple worktrees' '
test_when_finished "rm -rf repo" &&
git init repo &&

cd repo &&
test_commit initial &&
git checkout -b branch-1 &&
test_commit second &&
git checkout -b branch-2 &&
test_commit third &&
git checkout -b branch-3 &&
git worktree add ./worktree-1 branch-1 &&
git worktree add ./worktree-2 branch-2 &&
worktree1_refdir_prefix=.git/worktrees/worktree-1/refs/worktree &&
worktree2_refdir_prefix=.git/worktrees/worktree-2/refs/worktree &&

(
cd worktree-1 &&
git update-ref refs/worktree/branch-4 refs/heads/branch-3
) &&
(
cd worktree-2 &&
git update-ref refs/worktree/branch-4 refs/heads/branch-3
) &&

cp $worktree1_refdir_prefix/branch-4 $worktree1_refdir_prefix/'\'' branch-5'\'' &&
cp $worktree2_refdir_prefix/branch-4 $worktree2_refdir_prefix/'\''~branch-6'\'' &&

test_must_fail git refs verify 2>err &&
cat >expect <<-EOF &&
error: worktrees/worktree-1/refs/worktree/ branch-5: badRefName: invalid refname format
error: worktrees/worktree-2/refs/worktree/~branch-6: badRefName: invalid refname format
EOF
sort err >sorted_err &&
test_cmp expect sorted_err &&

for worktree in "worktree-1" "worktree-2"
do
(
cd $worktree &&
test_must_fail git refs verify 2>err &&
cat >expect <<-EOF &&
error: worktrees/worktree-1/refs/worktree/ branch-5: badRefName: invalid refname format
error: worktrees/worktree-2/refs/worktree/~branch-6: badRefName: invalid refname format
EOF
sort err >sorted_err &&
test_cmp expect sorted_err || return 1
)
done
'

test_expect_success 'regular ref content should be checked (individual)' '
test_when_finished "rm -rf repo" &&
git init repo &&
branch_dir_prefix=.git/refs/heads &&
cd repo &&
test_commit default &&
mkdir -p "$branch_dir_prefix/a/b" &&

git refs verify 2>err &&
test_must_be_empty err &&

for bad_content in "$(git rev-parse main)x" "xfsazqfxcadas" "Xfsazqfxcadas"
do
printf "%s" $bad_content >$branch_dir_prefix/branch-bad &&
test_must_fail git refs verify 2>err &&
cat >expect <<-EOF &&
error: refs/heads/branch-bad: badRefContent: $bad_content
EOF
rm $branch_dir_prefix/branch-bad &&
test_cmp expect err || return 1
done &&

for bad_content in "$(git rev-parse main)x" "xfsazqfxcadas" "Xfsazqfxcadas"
do
printf "%s" $bad_content >$branch_dir_prefix/a/b/branch-bad &&
test_must_fail git refs verify 2>err &&
cat >expect <<-EOF &&
error: refs/heads/a/b/branch-bad: badRefContent: $bad_content
EOF
rm $branch_dir_prefix/a/b/branch-bad &&
test_cmp expect err || return 1
done &&

printf "%s" "$(git rev-parse main)" >$branch_dir_prefix/branch-no-newline &&
git refs verify 2>err &&
cat >expect <<-EOF &&
warning: refs/heads/branch-no-newline: refMissingNewline: misses LF at the end
EOF
rm $branch_dir_prefix/branch-no-newline &&
test_cmp expect err &&

for trailing_content in " garbage" " more garbage"
do
printf "%s" "$(git rev-parse main)$trailing_content" >$branch_dir_prefix/branch-garbage &&
git refs verify 2>err &&
cat >expect <<-EOF &&
warning: refs/heads/branch-garbage: trailingRefContent: has trailing garbage: '\''$trailing_content'\''
EOF
rm $branch_dir_prefix/branch-garbage &&
test_cmp expect err || return 1
done &&

printf "%s\n\n\n" "$(git rev-parse main)" >$branch_dir_prefix/branch-garbage-special &&
git refs verify 2>err &&
cat >expect <<-EOF &&
warning: refs/heads/branch-garbage-special: trailingRefContent: has trailing garbage: '\''


'\''
EOF
rm $branch_dir_prefix/branch-garbage-special &&
test_cmp expect err &&

printf "%s\n\n\n garbage" "$(git rev-parse main)" >$branch_dir_prefix/branch-garbage-special &&
git refs verify 2>err &&
cat >expect <<-EOF &&
warning: refs/heads/branch-garbage-special: trailingRefContent: has trailing garbage: '\''


garbage'\''
EOF
rm $branch_dir_prefix/branch-garbage-special &&
test_cmp expect err
'

test_expect_success 'regular ref content should be checked (aggregate)' '
test_when_finished "rm -rf repo" &&
git init repo &&
branch_dir_prefix=.git/refs/heads &&
tag_dir_prefix=.git/refs/tags &&
cd repo &&
test_commit default &&
mkdir -p "$branch_dir_prefix/a/b" &&

bad_content_1=$(git rev-parse main)x &&
bad_content_2=xfsazqfxcadas &&
bad_content_3=Xfsazqfxcadas &&
printf "%s" $bad_content_1 >$tag_dir_prefix/tag-bad-1 &&
printf "%s" $bad_content_2 >$tag_dir_prefix/tag-bad-2 &&
printf "%s" $bad_content_3 >$branch_dir_prefix/a/b/branch-bad &&
printf "%s" "$(git rev-parse main)" >$branch_dir_prefix/branch-no-newline &&
printf "%s garbage" "$(git rev-parse main)" >$branch_dir_prefix/branch-garbage &&

test_must_fail git refs verify 2>err &&
cat >expect <<-EOF &&
error: refs/heads/a/b/branch-bad: badRefContent: $bad_content_3
error: refs/tags/tag-bad-1: badRefContent: $bad_content_1
error: refs/tags/tag-bad-2: badRefContent: $bad_content_2
warning: refs/heads/branch-garbage: trailingRefContent: has trailing garbage: '\'' garbage'\''
warning: refs/heads/branch-no-newline: refMissingNewline: misses LF at the end
EOF
sort err >sorted_err &&
test_cmp expect sorted_err
'

test_expect_success 'textual symref content should be checked (individual)' '
test_when_finished "rm -rf repo" &&
git init repo &&
branch_dir_prefix=.git/refs/heads &&
cd repo &&
test_commit default &&
mkdir -p "$branch_dir_prefix/a/b" &&

for good_referent in "refs/heads/branch" "HEAD"
do
printf "ref: %s\n" $good_referent >$branch_dir_prefix/branch-good &&
git refs verify 2>err &&
rm $branch_dir_prefix/branch-good &&
test_must_be_empty err || return 1
done &&

for bad_referent in "refs/heads/.branch" "refs/heads/~branch" "refs/heads/?branch"
do
printf "ref: %s\n" $bad_referent >$branch_dir_prefix/branch-bad &&
test_must_fail git refs verify 2>err &&
cat >expect <<-EOF &&
error: refs/heads/branch-bad: badReferentName: points to invalid refname '\''$bad_referent'\''
EOF
rm $branch_dir_prefix/branch-bad &&
test_cmp expect err || return 1
done &&

printf "ref: refs/heads/branch" >$branch_dir_prefix/branch-no-newline &&
git refs verify 2>err &&
cat >expect <<-EOF &&
warning: refs/heads/branch-no-newline: refMissingNewline: misses LF at the end
EOF
rm $branch_dir_prefix/branch-no-newline &&
test_cmp expect err &&

printf "ref: refs/heads/branch " >$branch_dir_prefix/a/b/branch-trailing-1 &&
git refs verify 2>err &&
cat >expect <<-EOF &&
warning: refs/heads/a/b/branch-trailing-1: refMissingNewline: misses LF at the end
warning: refs/heads/a/b/branch-trailing-1: trailingRefContent: has trailing whitespaces or newlines
EOF
rm $branch_dir_prefix/a/b/branch-trailing-1 &&
test_cmp expect err &&

printf "ref: refs/heads/branch\n\n" >$branch_dir_prefix/a/b/branch-trailing-2 &&
git refs verify 2>err &&
cat >expect <<-EOF &&
warning: refs/heads/a/b/branch-trailing-2: trailingRefContent: has trailing whitespaces or newlines
EOF
rm $branch_dir_prefix/a/b/branch-trailing-2 &&
test_cmp expect err &&

printf "ref: refs/heads/branch \n" >$branch_dir_prefix/a/b/branch-trailing-3 &&
git refs verify 2>err &&
cat >expect <<-EOF &&
warning: refs/heads/a/b/branch-trailing-3: trailingRefContent: has trailing whitespaces or newlines
EOF
rm $branch_dir_prefix/a/b/branch-trailing-3 &&
test_cmp expect err &&

printf "ref: refs/heads/branch \n " >$branch_dir_prefix/a/b/branch-complicated &&
git refs verify 2>err &&
cat >expect <<-EOF &&
warning: refs/heads/a/b/branch-complicated: refMissingNewline: misses LF at the end
warning: refs/heads/a/b/branch-complicated: trailingRefContent: has trailing whitespaces or newlines
EOF
rm $branch_dir_prefix/a/b/branch-complicated &&
test_cmp expect err
'

test_expect_success 'textual symref content should be checked (aggregate)' '
test_when_finished "rm -rf repo" &&
git init repo &&
branch_dir_prefix=.git/refs/heads &&
tag_dir_prefix=.git/refs/tags &&
cd repo &&
test_commit default &&
mkdir -p "$branch_dir_prefix/a/b" &&

printf "ref: refs/heads/branch\n" >$branch_dir_prefix/branch-good &&
printf "ref: HEAD\n" >$branch_dir_prefix/branch-head &&
printf "ref: refs/heads/branch" >$branch_dir_prefix/branch-no-newline-1 &&
printf "ref: refs/heads/branch " >$branch_dir_prefix/a/b/branch-trailing-1 &&
printf "ref: refs/heads/branch\n\n" >$branch_dir_prefix/a/b/branch-trailing-2 &&
printf "ref: refs/heads/branch \n" >$branch_dir_prefix/a/b/branch-trailing-3 &&
printf "ref: refs/heads/branch \n " >$branch_dir_prefix/a/b/branch-complicated &&
printf "ref: refs/heads/.branch\n" >$branch_dir_prefix/branch-bad-1 &&

test_must_fail git refs verify 2>err &&
cat >expect <<-EOF &&
error: refs/heads/branch-bad-1: badReferentName: points to invalid refname '\''refs/heads/.branch'\''
warning: refs/heads/a/b/branch-complicated: refMissingNewline: misses LF at the end
warning: refs/heads/a/b/branch-complicated: trailingRefContent: has trailing whitespaces or newlines
warning: refs/heads/a/b/branch-trailing-1: refMissingNewline: misses LF at the end
warning: refs/heads/a/b/branch-trailing-1: trailingRefContent: has trailing whitespaces or newlines
warning: refs/heads/a/b/branch-trailing-2: trailingRefContent: has trailing whitespaces or newlines
warning: refs/heads/a/b/branch-trailing-3: trailingRefContent: has trailing whitespaces or newlines
warning: refs/heads/branch-no-newline-1: refMissingNewline: misses LF at the end
EOF
sort err >sorted_err &&
test_cmp expect sorted_err
'

test_expect_success 'the target of the textual symref should be checked' '
test_when_finished "rm -rf repo" &&
git init repo &&
branch_dir_prefix=.git/refs/heads &&
tag_dir_prefix=.git/refs/tags &&
cd repo &&
test_commit default &&
mkdir -p "$branch_dir_prefix/a/b" &&

for good_referent in "refs/heads/branch" "HEAD" "refs/tags/tag"
do
printf "ref: %s\n" $good_referent >$branch_dir_prefix/branch-good &&
git refs verify 2>err &&
rm $branch_dir_prefix/branch-good &&
test_must_be_empty err || return 1
done &&

for nonref_referent in "refs-back/heads/branch" "refs-back/tags/tag" "reflogs/refs/heads/branch"
do
printf "ref: %s\n" $nonref_referent >$branch_dir_prefix/branch-bad-1 &&
git refs verify 2>err &&
cat >expect <<-EOF &&
warning: refs/heads/branch-bad-1: symrefTargetIsNotARef: points to non-ref target '\''$nonref_referent'\''
EOF
rm $branch_dir_prefix/branch-bad-1 &&
test_cmp expect err || return 1
done
'

test_expect_success SYMLINKS 'symlink symref content should be checked' '
test_when_finished "rm -rf repo" &&
git init repo &&
branch_dir_prefix=.git/refs/heads &&
tag_dir_prefix=.git/refs/tags &&
cd repo &&
test_commit default &&
mkdir -p "$branch_dir_prefix/a/b" &&

ln -sf ./main $branch_dir_prefix/branch-symbolic-good &&
git refs verify 2>err &&
cat >expect <<-EOF &&
warning: refs/heads/branch-symbolic-good: symlinkRef: use deprecated symbolic link for symref
EOF
rm $branch_dir_prefix/branch-symbolic-good &&
test_cmp expect err &&

ln -sf ../../logs/branch-escape $branch_dir_prefix/branch-symbolic &&
git refs verify 2>err &&
cat >expect <<-EOF &&
warning: refs/heads/branch-symbolic: symlinkRef: use deprecated symbolic link for symref
warning: refs/heads/branch-symbolic: symrefTargetIsNotARef: points to non-ref target '\''logs/branch-escape'\''
EOF
rm $branch_dir_prefix/branch-symbolic &&
test_cmp expect err &&

ln -sf ./"branch " $branch_dir_prefix/branch-symbolic-bad &&
test_must_fail git refs verify 2>err &&
cat >expect <<-EOF &&
warning: refs/heads/branch-symbolic-bad: symlinkRef: use deprecated symbolic link for symref
error: refs/heads/branch-symbolic-bad: badReferentName: points to invalid refname '\''refs/heads/branch '\''
EOF
rm $branch_dir_prefix/branch-symbolic-bad &&
test_cmp expect err &&

ln -sf ./".tag" $tag_dir_prefix/tag-symbolic-1 &&
test_must_fail git refs verify 2>err &&
cat >expect <<-EOF &&
warning: refs/tags/tag-symbolic-1: symlinkRef: use deprecated symbolic link for symref
error: refs/tags/tag-symbolic-1: badReferentName: points to invalid refname '\''refs/tags/.tag'\''
EOF
rm $tag_dir_prefix/tag-symbolic-1 &&
test_cmp expect err
'

test_expect_success SYMLINKS 'symlink symref content should be checked (worktree)' '
test_when_finished "rm -rf repo" &&
git init repo &&
cd repo &&
test_commit default &&
git branch branch-1 &&
git branch branch-2 &&
git branch branch-3 &&
git worktree add ./worktree-1 branch-2 &&
git worktree add ./worktree-2 branch-3 &&
main_worktree_refdir_prefix=.git/refs/heads &&
worktree1_refdir_prefix=.git/worktrees/worktree-1/refs/worktree &&
worktree2_refdir_prefix=.git/worktrees/worktree-2/refs/worktree &&

(
cd worktree-1 &&
git update-ref refs/worktree/branch-4 refs/heads/branch-1
) &&
(
cd worktree-2 &&
git update-ref refs/worktree/branch-4 refs/heads/branch-1
) &&

ln -sf ../../../../refs/heads/good-branch $worktree1_refdir_prefix/branch-symbolic-good &&
git refs verify 2>err &&
cat >expect <<-EOF &&
warning: worktrees/worktree-1/refs/worktree/branch-symbolic-good: symlinkRef: use deprecated symbolic link for symref
EOF
rm $worktree1_refdir_prefix/branch-symbolic-good &&
test_cmp expect err &&

ln -sf ../../../../worktrees/worktree-1/good-branch $worktree2_refdir_prefix/branch-symbolic-good &&
git refs verify 2>err &&
cat >expect <<-EOF &&
warning: worktrees/worktree-2/refs/worktree/branch-symbolic-good: symlinkRef: use deprecated symbolic link for symref
EOF
rm $worktree2_refdir_prefix/branch-symbolic-good &&
test_cmp expect err &&

ln -sf ../../worktrees/worktree-2/good-branch $main_worktree_refdir_prefix/branch-symbolic-good &&
git refs verify 2>err &&
cat >expect <<-EOF &&
warning: refs/heads/branch-symbolic-good: symlinkRef: use deprecated symbolic link for symref
EOF
rm $main_worktree_refdir_prefix/branch-symbolic-good &&
test_cmp expect err &&

ln -sf ../../../../logs/branch-escape $worktree1_refdir_prefix/branch-symbolic &&
git refs verify 2>err &&
cat >expect <<-EOF &&
warning: worktrees/worktree-1/refs/worktree/branch-symbolic: symlinkRef: use deprecated symbolic link for symref
warning: worktrees/worktree-1/refs/worktree/branch-symbolic: symrefTargetIsNotARef: points to non-ref target '\''logs/branch-escape'\''
EOF
rm $worktree1_refdir_prefix/branch-symbolic &&
test_cmp expect err &&

for bad_referent_name in ".tag" "branch "
do
ln -sf ./"$bad_referent_name" $worktree1_refdir_prefix/bad-symbolic &&
test_must_fail git refs verify 2>err &&
cat >expect <<-EOF &&
warning: worktrees/worktree-1/refs/worktree/bad-symbolic: symlinkRef: use deprecated symbolic link for symref
error: worktrees/worktree-1/refs/worktree/bad-symbolic: badReferentName: points to invalid refname '\''worktrees/worktree-1/refs/worktree/$bad_referent_name'\''
EOF
rm $worktree1_refdir_prefix/bad-symbolic &&
test_cmp expect err &&

ln -sf ../../../../refs/heads/"$bad_referent_name" $worktree1_refdir_prefix/bad-symbolic &&
test_must_fail git refs verify 2>err &&
cat >expect <<-EOF &&
warning: worktrees/worktree-1/refs/worktree/bad-symbolic: symlinkRef: use deprecated symbolic link for symref
error: worktrees/worktree-1/refs/worktree/bad-symbolic: badReferentName: points to invalid refname '\''refs/heads/$bad_referent_name'\''
EOF
rm $worktree1_refdir_prefix/bad-symbolic &&
test_cmp expect err &&

ln -sf ./"$bad_referent_name" $worktree2_refdir_prefix/bad-symbolic &&
test_must_fail git refs verify 2>err &&
cat >expect <<-EOF &&
warning: worktrees/worktree-2/refs/worktree/bad-symbolic: symlinkRef: use deprecated symbolic link for symref
error: worktrees/worktree-2/refs/worktree/bad-symbolic: badReferentName: points to invalid refname '\''worktrees/worktree-2/refs/worktree/$bad_referent_name'\''
EOF
rm $worktree2_refdir_prefix/bad-symbolic &&
test_cmp expect err &&

ln -sf ../../../../refs/heads/"$bad_referent_name" $worktree2_refdir_prefix/bad-symbolic &&
test_must_fail git refs verify 2>err &&
cat >expect <<-EOF &&
warning: worktrees/worktree-2/refs/worktree/bad-symbolic: symlinkRef: use deprecated symbolic link for symref
error: worktrees/worktree-2/refs/worktree/bad-symbolic: badReferentName: points to invalid refname '\''refs/heads/$bad_referent_name'\''
EOF
rm $worktree2_refdir_prefix/bad-symbolic &&
test_cmp expect err || return 1
done
'

test_expect_success 'ref content checks should work with worktrees' '
test_when_finished "rm -rf repo" &&
git init repo &&
cd repo &&
test_commit default &&
git branch branch-1 &&
git branch branch-2 &&
git branch branch-3 &&
git worktree add ./worktree-1 branch-2 &&
git worktree add ./worktree-2 branch-3 &&
worktree1_refdir_prefix=.git/worktrees/worktree-1/refs/worktree &&
worktree2_refdir_prefix=.git/worktrees/worktree-2/refs/worktree &&

(
cd worktree-1 &&
git update-ref refs/worktree/branch-4 refs/heads/branch-1
) &&
(
cd worktree-2 &&
git update-ref refs/worktree/branch-4 refs/heads/branch-1
) &&

for bad_content in "$(git rev-parse HEAD)x" "xfsazqfxcadas" "Xfsazqfxcadas"
do
printf "%s" $bad_content >$worktree1_refdir_prefix/bad-branch-1 &&
test_must_fail git refs verify 2>err &&
cat >expect <<-EOF &&
error: worktrees/worktree-1/refs/worktree/bad-branch-1: badRefContent: $bad_content
EOF
rm $worktree1_refdir_prefix/bad-branch-1 &&
test_cmp expect err || return 1
done &&

for bad_content in "$(git rev-parse HEAD)x" "xfsazqfxcadas" "Xfsazqfxcadas"
do
printf "%s" $bad_content >$worktree2_refdir_prefix/bad-branch-2 &&
test_must_fail git refs verify 2>err &&
cat >expect <<-EOF &&
error: worktrees/worktree-2/refs/worktree/bad-branch-2: badRefContent: $bad_content
EOF
rm $worktree2_refdir_prefix/bad-branch-2 &&
test_cmp expect err || return 1
done &&

printf "%s" "$(git rev-parse HEAD)" >$worktree1_refdir_prefix/branch-no-newline &&
git refs verify 2>err &&
cat >expect <<-EOF &&
warning: worktrees/worktree-1/refs/worktree/branch-no-newline: refMissingNewline: misses LF at the end
EOF
rm $worktree1_refdir_prefix/branch-no-newline &&
test_cmp expect err &&

printf "%s garbage" "$(git rev-parse HEAD)" >$worktree1_refdir_prefix/branch-garbage &&
git refs verify 2>err &&
cat >expect <<-EOF &&
warning: worktrees/worktree-1/refs/worktree/branch-garbage: trailingRefContent: has trailing garbage: '\'' garbage'\''
EOF
rm $worktree1_refdir_prefix/branch-garbage &&
test_cmp expect err
'

test_done