We have already introduced the checks for regular refs. There is no need
to check the consistency of the target which the symbolic ref points to.
Instead, we just check the content of the symbolic ref itself.
In order to check the content of the symbolic ref, create a function
"files_fsck_symref_target". It will first check whether the "pointee" is
under the "refs/" directory and then we will check the "pointee" itself.
There is no specification about the content of the symbolic ref.
Although we do write "ref: %s\n" to create a symbolic ref by using
"git-symbolic-ref(1)" command. However, this is not mandatory. We still
accept symbolic refs with null trailing garbage. Put it more specific,
the following are correct:
1. "ref: refs/heads/master "
2. "ref: refs/heads/master \n \n"
3. "ref: refs/heads/master\n\n"
But we do not allow any non-null trailing garbage. The following are bad
symbolic contents which will be reported as fsck error by "git-fsck(1)".
1. "ref: refs/heads/master garbage\n"
2. "ref: refs/heads/master \n\n\n garbage "
In order to provide above checks, we will use "strrchr" to check whether
we have newline in the ref content. Then we will check the name of the
"pointee" is correct by using "check_refname_format". If the function
fails, we need to trim the "pointee" to see whether the null-garbage
causes the function fails. If so, we need to report that there is
null-garbage in the symref content. Otherwise, we should report the user
the "pointee" is bad.
Mentored-by: Patrick Steinhardt <ps@xxxxxx>
Mentored-by: Karthik Nayak <karthik.188@xxxxxxxxx>
Signed-off-by: shejialuo <shejialuo@xxxxxxxxx>
---
Documentation/fsck-msgids.txt | 3 ++
fsck.h | 1 +
refs/files-backend.c | 77 +++++++++++++++++++++++++++++++++++
t/t0602-reffiles-fsck.sh | 54 ++++++++++++++++++++++++
4 files changed, 135 insertions(+)
diff --git a/Documentation/fsck-msgids.txt b/Documentation/fsck-msgids.txt
index fc074fc571..85fd058c81 100644
--- a/Documentation/fsck-msgids.txt
+++ b/Documentation/fsck-msgids.txt
@@ -28,6 +28,9 @@
`badRefName`::
(ERROR) A ref has an invalid format.
+`badSymrefPointee`::
+ (ERROR) The pointee of a symref is bad.
+
`badTagName`::
(INFO) A tag has an invalid format.
diff --git a/fsck.h b/fsck.h
index b85072df57..cbe837f84c 100644
--- a/fsck.h
+++ b/fsck.h
@@ -34,6 +34,7 @@ enum fsck_msg_type {
FUNC(BAD_REF_CONTENT, ERROR) \
FUNC(BAD_REF_FILETYPE, ERROR) \
FUNC(BAD_REF_NAME, ERROR) \
+ FUNC(BAD_SYMREF_POINTEE, ERROR) \
FUNC(BAD_TIMEZONE, ERROR) \
FUNC(BAD_TREE, ERROR) \
FUNC(BAD_TREE_SHA1, ERROR) \
diff --git a/refs/files-backend.c b/refs/files-backend.c
index 69c00073eb..382c73fcf7 100644
--- a/refs/files-backend.c
+++ b/refs/files-backend.c
@@ -3434,11 +3434,81 @@ typedef int (*files_fsck_refs_fn)(struct ref_store *ref_store,
const char *refs_check_dir,
struct dir_iterator *iter);
+/*
+ * Check the symref "pointee_name" and "pointee_path". The caller should
+ * make sure that "pointee_path" is absolute. For symbolic ref, "pointee_name"
+ * would be the content after "refs:".
+ */
+static int files_fsck_symref_target(struct fsck_options *o,
+ struct fsck_ref_report *report,
+ const char *refname,
+ struct strbuf *pointee_name,
+ struct strbuf *pointee_path)
+{
+ const char *newline_pos = NULL;
+ const char *p = NULL;
+ struct stat st;
+ int ret = 0;
+
+ if (!skip_prefix(pointee_name->buf, "refs/", &p)) {
+
+ ret = fsck_report_ref(o, report,
+ FSCK_MSG_BAD_SYMREF_POINTEE,
+ "points to ref outside the refs directory");
+ goto out;
+ }
+
+ newline_pos = strrchr(p, '\n');
+ if (!newline_pos || *(newline_pos + 1)) {
+ ret = fsck_report_ref(o, report,
+ FSCK_MSG_REF_MISSING_NEWLINE,
+ "missing newline");
+ }
+
+ if (check_refname_format(pointee_name->buf, 0)) {
+ /*
+ * When containing null-garbage, "check_refname_format" will
+ * fail, we should trim the "pointee" to check again.
+ */
+ strbuf_rtrim(pointee_name);
+ if (!check_refname_format(pointee_name->buf, 0)) {
+ ret = fsck_report_ref(o, report,
+ FSCK_MSG_TRAILING_REF_CONTENT,
+ "trailing null-garbage");
+ goto out;
+ }
+
+ ret = fsck_report_ref(o, report,
+ FSCK_MSG_BAD_SYMREF_POINTEE,
+ "points to refname with invalid format");
+ }
+
+ /*
+ * Missing target should not be treated as any error worthy event and
+ * not even warn. It is a common case that a symbolic ref points to a
+ * ref that does not exist yet. If the target ref does not exist, just
+ * skip the check for the file type.
+ */
+ if (lstat(pointee_path->buf, &st) < 0)
+ goto out;
+
+ if (!S_ISREG(st.st_mode) && !S_ISLNK(st.st_mode)) {
+ ret = fsck_report_ref(o, report,
+ FSCK_MSG_BAD_SYMREF_POINTEE,
+ "points to an invalid file type");
+ goto out;
+ }
+
+out:
+ return ret;
+}
+
static int files_fsck_refs_content(struct ref_store *ref_store,
struct fsck_options *o,
const char *refs_check_dir,
struct dir_iterator *iter)
{
+ struct strbuf pointee_path = STRBUF_INIT;
struct strbuf ref_content = STRBUF_INIT;
struct strbuf referent = STRBUF_INIT;
struct strbuf refname = STRBUF_INIT;
@@ -3482,6 +3552,12 @@ static int files_fsck_refs_content(struct ref_store *ref_store,
"trailing garbage in ref");
goto cleanup;
}
+ } else {
+ strbuf_addf(&pointee_path, "%s/%s",
+ ref_store->gitdir, referent.buf);
+ ret = files_fsck_symref_target(o, &report, refname.buf,
+ &referent,
+ &pointee_path);
}
goto cleanup;
}
@@ -3490,6 +3566,7 @@ static int files_fsck_refs_content(struct ref_store *ref_store,
strbuf_release(&refname);
strbuf_release(&ref_content);
strbuf_release(&referent);
+ strbuf_release(&pointee_path);
return ret;
}
diff --git a/t/t0602-reffiles-fsck.sh b/t/t0602-reffiles-fsck.sh
index 7c1910d784..69280795ca 100755
--- a/t/t0602-reffiles-fsck.sh
+++ b/t/t0602-reffiles-fsck.sh
@@ -176,4 +176,58 @@ test_expect_success 'regular ref content should be checked' '
test_cmp expect err
'
+test_expect_success 'symbolic ref 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 &&
+ git commit --allow-empty -m initial &&
+ git checkout -b branch-1 &&
+ git tag tag-1 &&
+ git checkout -b a/b/branch-2 &&
+
+ printf "ref: refs/heads/branch" > $branch_dir_prefix/branch-1-no-newline &&
+ git refs verify 2>err &&
+ cat >expect <<-EOF &&
+ warning: refs/heads/branch-1-no-newline: refMissingNewline: missing newline
+ EOF
+ rm $branch_dir_prefix/branch-1-no-newline &&
+ test_cmp expect err &&
+
+ printf "ref: refs/heads/branch " > $branch_dir_prefix/a/b/branch-trailing &&
+ git refs verify 2>err &&
+ cat >expect <<-EOF &&
+ warning: refs/heads/a/b/branch-trailing: refMissingNewline: missing newline
+ warning: refs/heads/a/b/branch-trailing: trailingRefContent: trailing null-garbage
+ EOF
+ rm $branch_dir_prefix/a/b/branch-trailing &&
+ test_cmp expect err &&
+
+ printf "ref: refs/heads/branch\n\n" > $branch_dir_prefix/a/b/branch-trailing &&
+ git refs verify 2>err &&
+ cat >expect <<-EOF &&
+ warning: refs/heads/a/b/branch-trailing: trailingRefContent: trailing null-garbage
+ EOF
+ rm $branch_dir_prefix/a/b/branch-trailing &&
+ test_cmp expect err &&
+
+ printf "ref: refs/heads/branch \n\n " > $branch_dir_prefix/a/b/branch-trailing &&
+ git refs verify 2>err &&
+ cat >expect <<-EOF &&
+ warning: refs/heads/a/b/branch-trailing: refMissingNewline: missing newline
+ warning: refs/heads/a/b/branch-trailing: trailingRefContent: trailing null-garbage
+ EOF
+ rm $branch_dir_prefix/a/b/branch-trailing &&
+ test_cmp expect err &&
+
+ printf "ref: refs/heads/.branch\n" > $branch_dir_prefix/branch-2-bad &&
+ test_must_fail git refs verify 2>err &&
+ cat >expect <<-EOF &&
+ error: refs/heads/branch-2-bad: badSymrefPointee: points to refname with invalid format
+ EOF
+ rm $branch_dir_prefix/branch-2-bad &&
+ test_cmp expect err
+'
+
test_done
--
2.46.0
