Use original hash for legacy formats

We have a large variety of data formats and protocols where no hash
algorithm was defined and the default was assumed to always be SHA-1.
Instead of explicitly stating SHA-1, let's use the constant to represent
the original hash algorithm (which is still SHA-1) so that it's clear
for documentary purposes that it's a legacy fallback option and not an
intentional choice to use SHA-1.

Signed-off-by: brian m. carlson <sandals@crustytoothpaste.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/builtin/receive-pack.c b/builtin/receive-pack.c
index a317d6c278de2174db2ee7d5d782ede4f7331944..6c9b2468956d6f2d6ba343d50b99c5307c08ab68 100644 (file)
--- a/builtin/receive-pack.c
+++ b/builtin/receive-pack.c
@@ -2136,7 +2136,7 @@ static struct command *read_head_info(struct packet_reader *reader,
                                use_push_options = 1;
                        hash = parse_feature_value(feature_list, "object-format", &len, NULL);
                        if (!hash) {
-                               hash = hash_algos[GIT_HASH_SHA1].name;
+                               hash = hash_algos[GIT_HASH_ORIGINAL].name;
                                len = strlen(hash);
                        }
                        if (xstrncmpz(the_hash_algo->name, hash, len))

diff --git a/bundle.c b/bundle.c
index b0a3fee2efa7b32c71b2d9b31df6b734b6617520..359cbc44d0f114f351720e7aff125c3c8ff817cd 100644 (file)
--- a/bundle.c
+++ b/bundle.c
@@ -95,7 +95,7 @@ int read_bundle_header_fd(int fd, struct bundle_header *header,
         * by an "object-format=" capability, which is being handled in
         * `parse_capability()`.
         */
-       header->hash_algo = &hash_algos[GIT_HASH_SHA1];
+       header->hash_algo = &hash_algos[GIT_HASH_ORIGINAL];
 
        /* The bundle header ends with an empty line */
        while (!strbuf_getwholeline_fd(&buf, fd, '\n') &&
@@ -507,7 +507,7 @@ int create_bundle(struct repository *r, const char *path,
         *    SHA1.
         * 2. @filter is required because we parsed an object filter.
         */
-       if (the_hash_algo != &hash_algos[GIT_HASH_SHA1] || revs.filter.choice)
+       if (the_hash_algo != &hash_algos[GIT_HASH_ORIGINAL] || revs.filter.choice)
                min_version = 3;
 
        if (argc > 1) {

diff --git a/connect.c b/connect.c
index 3280435331038e5166334be7c96e8abaf04d78fd..04415d8eed837c8f1612b9254e208c5b45a220dd 100644 (file)
--- a/connect.c
+++ b/connect.c
@@ -251,7 +251,7 @@ static void process_capabilities(struct packet_reader *reader, size_t *linelen)
                        reader->hash_algo = &hash_algos[hash_algo];
                free(hash_name);
        } else {
-               reader->hash_algo = &hash_algos[GIT_HASH_SHA1];
+               reader->hash_algo = &hash_algos[GIT_HASH_ORIGINAL];
        }
 }
 
@@ -500,7 +500,7 @@ static void send_capabilities(int fd_out, struct packet_reader *reader)
                reader->hash_algo = &hash_algos[hash_algo];
                packet_write_fmt(fd_out, "object-format=%s", reader->hash_algo->name);
        } else {
-               reader->hash_algo = &hash_algos[GIT_HASH_SHA1];
+               reader->hash_algo = &hash_algos[GIT_HASH_ORIGINAL];
        }
        if (server_feature_v2("promisor-remote", &promisor_remote_info)) {
                char *reply = promisor_remote_reply(promisor_remote_info);
@@ -665,7 +665,7 @@ int server_supports_hash(const char *desired, int *feature_supported)
        if (feature_supported)
                *feature_supported = !!hash;
        if (!hash) {
-               hash = hash_algos[GIT_HASH_SHA1].name;
+               hash = hash_algos[GIT_HASH_ORIGINAL].name;
                len = strlen(hash);
        }
        while (hash) {

diff --git a/fetch-pack.c b/fetch-pack.c
index fa4231fee74c9f4efbeb61480859c20219718d29..970de4f7dcd4d7dbe179796b18f14695a04b678e 100644 (file)
--- a/fetch-pack.c
+++ b/fetch-pack.c
@@ -1342,7 +1342,7 @@ static void write_fetch_command_and_capabilities(struct strbuf *req_buf,
                        die(_("mismatched algorithms: client %s; server %s"),
                            the_hash_algo->name, hash_name);
                packet_buf_write(req_buf, "object-format=%s", the_hash_algo->name);
-       } else if (hash_algo_by_ptr(the_hash_algo) != GIT_HASH_SHA1) {
+       } else if (hash_algo_by_ptr(the_hash_algo) != GIT_HASH_ORIGINAL) {
                die(_("the server does not support algorithm '%s'"),
                    the_hash_algo->name);
        }

diff --git a/pkt-line.c b/pkt-line.c
index a5bcbc96fb340f50ce6083aa2b7e9611d80de179..e7c18da5e09885edfacf9e9091046898581520fa 100644 (file)
--- a/pkt-line.c
+++ b/pkt-line.c
@@ -617,7 +617,7 @@ void packet_reader_init(struct packet_reader *reader, int fd,
        reader->buffer_size = sizeof(packet_buffer);
        reader->options = options;
        reader->me = "git";
-       reader->hash_algo = &hash_algos[GIT_HASH_SHA1];
+       reader->hash_algo = &hash_algos[GIT_HASH_ORIGINAL];
        strbuf_init(&reader->scratch, 0);
 }
 

diff --git a/remote-curl.c b/remote-curl.c
index b8bc3a80cf4142ce03c357f3c4d28ef0822c95a6..961ecd4655e7339dd1fcfa5ebc9aab37af8a4006 100644 (file)
--- a/remote-curl.c
+++ b/remote-curl.c
@@ -285,7 +285,7 @@ static const struct git_hash_algo *detect_hash_algo(struct discovery *heads)
         * back to SHA1, which may or may not be correct.
         */
        if (!p)
-               return &hash_algos[GIT_HASH_SHA1];
+               return &hash_algos[GIT_HASH_ORIGINAL];
 
        algo = hash_algo_by_length((p - heads->buf) / 2);
        if (algo == GIT_HASH_UNKNOWN)

diff --git a/serve.c b/serve.c
index e3ccf1505ca1a0d72117b2ba9936a3611816e05b..6a47170247ba925925979512a0e100057bac86c9 100644 (file)
--- a/serve.c
+++ b/serve.c
@@ -14,7 +14,7 @@
 
 static int advertise_sid = -1;
 static int advertise_object_info = -1;
-static int client_hash_algo = GIT_HASH_SHA1;
+static int client_hash_algo = GIT_HASH_ORIGINAL;
 
 static int always_advertise(struct repository *r UNUSED,
                            struct strbuf *value UNUSED)

diff --git a/setup.c b/setup.c
index f93bd6a24a5d9c166fd22165786efe86d605df75..641c857ed5d946c828396c1fe3074156323d6d39 100644 (file)
--- a/setup.c
+++ b/setup.c
@@ -2222,11 +2222,11 @@ void initialize_repository_version(int hash_algo,
         * version will get adjusted by git-clone(1) once it has learned about
         * the remote repository's format.
         */
-       if (hash_algo != GIT_HASH_SHA1 ||
+       if (hash_algo != GIT_HASH_ORIGINAL ||
            ref_storage_format != REF_STORAGE_FORMAT_FILES)
                target_version = GIT_REPO_VERSION_READ;
 
-       if (hash_algo != GIT_HASH_SHA1 && hash_algo != GIT_HASH_UNKNOWN)
+       if (hash_algo != GIT_HASH_ORIGINAL && hash_algo != GIT_HASH_UNKNOWN)
                git_config_set("extensions.objectformat",
                               hash_algos[hash_algo].name);
        else if (reinit)

diff --git a/transport.c b/transport.c
index 6c2801bcbd9d02e427724c6145a94c51c953568f..a019435918e15b03eb9d3aca3c853cdb0b739398 100644 (file)
--- a/transport.c
+++ b/transport.c
@@ -1243,7 +1243,7 @@ struct transport *transport_get(struct remote *remote, const char *url)
                        ret->smart_options->receivepack = remote->receivepack;
        }
 
-       ret->hash_algo = &hash_algos[GIT_HASH_SHA1];
+       ret->hash_algo = &hash_algos[GIT_HASH_ORIGINAL];
 
        return ret;
 }