hash-object: add --literally option

This allows "hash-object --stdin" to just hash any garbage into a
"loose object" that may not pass the standard object parsing check
or fsck, so that different kind of corrupt objects we may encounter
in the field can be imitated in our test suite.  That would in turn
allow us to test features that catch these corrupt objects.

Note that "cat-file" may need to learn "--literally" option to allow
us peek into a truly broken object.

Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/builtin/hash-object.c b/builtin/hash-object.c
index 1fb07ee08573a8d0f90eadd5608ab8471c4196a5..61583633182da359556fc65795a8eb740167675c 100644 (file)
--- a/builtin/hash-object.c
+++ b/builtin/hash-object.c
@@ -10,13 +10,36 @@
 #include "parse-options.h"
 #include "exec_cmd.h"
 
 #include "parse-options.h"
 #include "exec_cmd.h"
 

-static void hash_fd(int fd, const char *type, const char *path, unsigned flags)
+/*
+ * This is to create corrupt objects for debugging and as such it
+ * needs to bypass the data conversion performed by, and the type
+ * limitation imposed by, index_fd() and its callees.
+ */
+static int hash_literally(unsigned char *sha1, int fd, const char *type, unsigned flags)
+{
+       struct strbuf buf = STRBUF_INIT;
+       int ret;
+
+       if (strbuf_read(&buf, fd, 4096) < 0)
+               ret = -1;
+       else if (flags & HASH_WRITE_OBJECT)
+               ret = write_sha1_file(buf.buf, buf.len, type, sha1);
+       else
+               ret = hash_sha1_file(buf.buf, buf.len, type, sha1);
+       strbuf_release(&buf);
+       return ret;
+}
+
+static void hash_fd(int fd, const char *type, const char *path, unsigned flags,
+                   int literally)

 {
        struct stat st;
        unsigned char sha1[20];
 
        if (fstat(fd, &st) < 0 ||
 {
        struct stat st;
        unsigned char sha1[20];
 
        if (fstat(fd, &st) < 0 ||

-           index_fd(sha1, fd, &st, type_from_string(type), path, flags))
+           (literally
+            ? hash_literally(sha1, fd, type, flags)
+            : index_fd(sha1, fd, &st, type_from_string(type), path, flags)))

                die((flags & HASH_WRITE_OBJECT)
                    ? "Unable to add %s to database"
                    : "Unable to hash %s", path);
                die((flags & HASH_WRITE_OBJECT)
                    ? "Unable to add %s to database"
                    : "Unable to hash %s", path);


@@ -25,16 +48,17 @@ static void hash_fd(int fd, const char *type, const char *path, unsigned flags)
 }
 
 static void hash_object(const char *path, const char *type, const char *vpath,
 }
 
 static void hash_object(const char *path, const char *type, const char *vpath,

-                       unsigned flags)
+                       unsigned flags, int literally)

 {
        int fd;
        fd = open(path, O_RDONLY);
        if (fd < 0)
                die_errno("Cannot open '%s'", path);
 {
        int fd;
        fd = open(path, O_RDONLY);
        if (fd < 0)
                die_errno("Cannot open '%s'", path);

-       hash_fd(fd, type, vpath, flags);
+       hash_fd(fd, type, vpath, flags, literally);

 }
 
 }
 

-static void hash_stdin_paths(const char *type, int no_filters, unsigned flags)
+static void hash_stdin_paths(const char *type, int no_filters, unsigned flags,
+                            int literally)

 {
        struct strbuf buf = STRBUF_INIT, nbuf = STRBUF_INIT;
 
 {
        struct strbuf buf = STRBUF_INIT, nbuf = STRBUF_INIT;
 


@@ -45,7 +69,8 @@ static void hash_stdin_paths(const char *type, int no_filters, unsigned flags)
                                die("line is badly quoted");
                        strbuf_swap(&buf, &nbuf);
                }
                                die("line is badly quoted");
                        strbuf_swap(&buf, &nbuf);
                }

-               hash_object(buf.buf, type, no_filters ? NULL : buf.buf, flags);
+               hash_object(buf.buf, type, no_filters ? NULL : buf.buf, flags,
+                           literally);

        }
        strbuf_release(&buf);
        strbuf_release(&nbuf);
        }
        strbuf_release(&buf);
        strbuf_release(&nbuf);


@@ -62,6 +87,7 @@ int cmd_hash_object(int argc, const char **argv, const char *prefix)
        int hashstdin = 0;
        int stdin_paths = 0;
        int no_filters = 0;
        int hashstdin = 0;
        int stdin_paths = 0;
        int no_filters = 0;

+       int literally = 0;

        unsigned flags = HASH_FORMAT_CHECK;
        const char *vpath = NULL;
        const struct option hash_object_options[] = {
        unsigned flags = HASH_FORMAT_CHECK;
        const char *vpath = NULL;
        const struct option hash_object_options[] = {


@@ -71,6 +97,7 @@ int cmd_hash_object(int argc, const char **argv, const char *prefix)
                OPT_COUNTUP( 0 , "stdin", &hashstdin, N_("read the object from stdin")),
                OPT_BOOL( 0 , "stdin-paths", &stdin_paths, N_("read file names from stdin")),
                OPT_BOOL( 0 , "no-filters", &no_filters, N_("store file as is without filters")),
                OPT_COUNTUP( 0 , "stdin", &hashstdin, N_("read the object from stdin")),
                OPT_BOOL( 0 , "stdin-paths", &stdin_paths, N_("read file names from stdin")),
                OPT_BOOL( 0 , "no-filters", &no_filters, N_("store file as is without filters")),

+               OPT_BOOL( 0, "literally", &literally, N_("just hash any random garbage to create corrupt objects for debugging Git")),

                OPT_STRING( 0 , "path", &vpath, N_("file"), N_("process file as it were from this path")),
                OPT_END()
        };
                OPT_STRING( 0 , "path", &vpath, N_("file"), N_("process file as it were from this path")),
                OPT_END()
        };


@@ -111,7 +138,7 @@ int cmd_hash_object(int argc, const char **argv, const char *prefix)
        }
 
        if (hashstdin)
        }
 
        if (hashstdin)

-               hash_fd(0, type, vpath, flags);
+               hash_fd(0, type, vpath, flags, literally);

 
        for (i = 0 ; i < argc; i++) {
                const char *arg = argv[i];
 
        for (i = 0 ; i < argc; i++) {
                const char *arg = argv[i];


@@ -119,11 +146,11 @@ int cmd_hash_object(int argc, const char **argv, const char *prefix)
                if (0 <= prefix_length)
                        arg = prefix_filename(prefix, prefix_length, arg);
                hash_object(arg, type, no_filters ? NULL : vpath ? vpath : arg,
                if (0 <= prefix_length)
                        arg = prefix_filename(prefix, prefix_length, arg);
                hash_object(arg, type, no_filters ? NULL : vpath ? vpath : arg,

-                           flags);
+                           flags, literally);

        }
 
        if (stdin_paths)
        }
 
        if (stdin_paths)

-               hash_stdin_paths(type, no_filters, flags);
+               hash_stdin_paths(type, no_filters, flags, literally);

 
        return 0;
 }
 
        return 0;
 }