refs API: make parse_loose_ref_contents() not set errno

[thirdparty/git.git] / refs.c

diff --git a/refs.c b/refs.c
index 7f019c2377effa49a90427ffec0451c400941e0c..bb09993c2f96512602b033c08e4fc540650fe881 100644 (file)
--- a/refs.c
+++ b/refs.c
@@ -1648,7 +1648,8 @@ int for_each_fullref_in_prefixes(const char *namespace,
 
 static int refs_read_special_head(struct ref_store *ref_store,
                                  const char *refname, struct object_id *oid,
-                                 struct strbuf *referent, unsigned int *type)
+                                 struct strbuf *referent, unsigned int *type,
+                                 int *failure_errno)
 {
        struct strbuf full_path = STRBUF_INIT;
        struct strbuf content = STRBUF_INIT;
@@ -1658,7 +1659,8 @@ static int refs_read_special_head(struct ref_store *ref_store,
        if (strbuf_read_file(&content, full_path.buf, 0) < 0)
                goto done;
 
-       result = parse_loose_ref_contents(content.buf, oid, referent, type);
+       result = parse_loose_ref_contents(content.buf, oid, referent, type,
+                                         failure_errno);
 
 done:
        strbuf_release(&full_path);
@@ -1666,30 +1668,33 @@ done:
        return result;
 }
 
-int refs_read_raw_ref(struct ref_store *ref_store,
-                     const char *refname, struct object_id *oid,
-                     struct strbuf *referent, unsigned int *type)
+int refs_read_raw_ref(struct ref_store *ref_store, const char *refname,
+                     struct object_id *oid, struct strbuf *referent,
+                     unsigned int *type, int *failure_errno)
 {
+       assert(failure_errno);
        if (!strcmp(refname, "FETCH_HEAD") || !strcmp(refname, "MERGE_HEAD")) {
                return refs_read_special_head(ref_store, refname, oid, referent,
-                                             type);
+                                             type, failure_errno);
        }
 
        return ref_store->be->read_raw_ref(ref_store, refname, oid, referent,
-                                          type, &errno);
+                                          type, failure_errno);
 }
 
-/* This function needs to return a meaningful errno on failure */
-const char *refs_resolve_ref_unsafe(struct ref_store *refs,
+const char *refs_werrres_ref_unsafe(struct ref_store *refs,
                                    const char *refname,
                                    int resolve_flags,
-                                   struct object_id *oid, int *flags)
+                                   struct object_id *oid,
+                                   int *flags, int *failure_errno)
 {
        static struct strbuf sb_refname = STRBUF_INIT;
        struct object_id unused_oid;
        int unused_flags;
        int symref_count;
 
+       assert(failure_errno);
+
        if (!oid)
                oid = &unused_oid;
        if (!flags)
@@ -1700,7 +1705,7 @@ const char *refs_resolve_ref_unsafe(struct ref_store *refs,
        if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL)) {
                if (!(resolve_flags & RESOLVE_REF_ALLOW_BAD_NAME) ||
                    !refname_is_safe(refname)) {
-                       errno = EINVAL;
+                       *failure_errno = EINVAL;
                        return NULL;
                }
 
@@ -1718,9 +1723,11 @@ const char *refs_resolve_ref_unsafe(struct ref_store *refs,
        for (symref_count = 0; symref_count < SYMREF_MAXDEPTH; symref_count++) {
                unsigned int read_flags = 0;
 
-               if (refs_read_raw_ref(refs, refname,
-                                     oid, &sb_refname, &read_flags)) {
+               if (refs_read_raw_ref(refs, refname, oid, &sb_refname,
+                                     &read_flags, failure_errno)) {
                        *flags |= read_flags;
+                       if (errno)
+                               *failure_errno = errno;
 
                        /* In reading mode, refs must eventually resolve */
                        if (resolve_flags & RESOLVE_REF_READING)
@@ -1731,9 +1738,9 @@ const char *refs_resolve_ref_unsafe(struct ref_store *refs,
                         * may show errors besides ENOENT if there are
                         * similarly-named refs.
                         */
-                       if (errno != ENOENT &&
-                           errno != EISDIR &&
-                           errno != ENOTDIR)
+                       if (*failure_errno != ENOENT &&
+                           *failure_errno != EISDIR &&
+                           *failure_errno != ENOTDIR)
                                return NULL;
 
                        oidclr(oid);
@@ -1760,7 +1767,7 @@ const char *refs_resolve_ref_unsafe(struct ref_store *refs,
                if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL)) {
                        if (!(resolve_flags & RESOLVE_REF_ALLOW_BAD_NAME) ||
                            !refname_is_safe(refname)) {
-                               errno = EINVAL;
+                               *failure_errno = EINVAL;
                                return NULL;
                        }
 
@@ -1768,10 +1775,23 @@ const char *refs_resolve_ref_unsafe(struct ref_store *refs,
                }
        }
 
-       errno = ELOOP;
+       *failure_errno = ELOOP;
        return NULL;
 }
 
+const char *refs_resolve_ref_unsafe(struct ref_store *refs, const char *refname,
+                                   int resolve_flags, struct object_id *oid,
+                                   int *flags)
+{
+       int failure_errno = 0;
+       const char *refn;
+       refn = refs_werrres_ref_unsafe(refs, refname, resolve_flags,
+                                      oid, flags, &failure_errno);
+       if (!refn)
+               errno = failure_errno;
+       return refn;
+}
+
 /* backend functions */
 int refs_init_db(struct strbuf *err)
 {
@@ -2222,6 +2242,13 @@ int refs_verify_refname_available(struct ref_store *refs,
 
        strbuf_grow(&dirname, strlen(refname) + 1);
        for (slash = strchr(refname, '/'); slash; slash = strchr(slash + 1, '/')) {
+               /*
+                * Just saying "Is a directory" when we e.g. can't
+                * lock some multi-level ref isn't very informative,
+                * the user won't be told *what* is a directory, so
+                * let's not use strerror() below.
+                */
+               int ignore_errno;
                /* Expand dirname to the new prefix, not including the trailing slash: */
                strbuf_add(&dirname, refname + dirname.len, slash - refname - dirname.len);
 
@@ -2233,7 +2260,8 @@ int refs_verify_refname_available(struct ref_store *refs,
                if (skip && string_list_has_string(skip, dirname.buf))
                        continue;
 
-               if (!refs_read_raw_ref(refs, dirname.buf, &oid, &referent, &type)) {
+               if (!refs_read_raw_ref(refs, dirname.buf, &oid, &referent,
+                                      &type, &ignore_errno)) {
                        strbuf_addf(err, _("'%s' exists; cannot create '%s'"),
                                    dirname.buf, refname);
                        goto cleanup;