connect.c: check the commit buffer boundary while parsing.

diff --git a/builtin-tar-tree.c b/builtin-tar-tree.c
index e97e0af985515df14b37a6f0e5cc84b2c943f8c6..f2e48aae2a04822d26d255dddf36002f58f2093c 100644 (file)
--- a/builtin-tar-tree.c
+++ b/builtin-tar-tree.c
@@ -22,8 +22,10 @@ static unsigned long offset;
 static time_t archive_time;
 
 /* tries hard to write, either succeeds or dies in the attempt */
-static void reliable_write(void *buf, unsigned long size)
+static void reliable_write(const void *data, unsigned long size)
 {
+       const char *buf = data;
+
        while (size > 0) {
                long ret = xwrite(1, buf, size);
                if (ret < 0) {
@@ -47,37 +49,13 @@ static void write_if_needed(void)
        }
 }
 
-/* acquire the next record from the buffer; user must call write_if_needed() */
-static char *get_record(void)
-{
-       char *p = block + offset;
-       memset(p, 0, RECORDSIZE);
-       offset += RECORDSIZE;
-       return p;
-}
-
-/*
- * The end of tar archives is marked by 1024 nul bytes and after that
- * follows the rest of the block (if any).
- */
-static void write_trailer(void)
-{
-       get_record();
-       write_if_needed();
-       get_record();
-       write_if_needed();
-       while (offset) {
-               get_record();
-               write_if_needed();
-       }
-}
-
 /*
  * queues up writes, so that all our write(2) calls write exactly one
  * full block; pads writes to RECORDSIZE
  */
-static void write_blocked(void *buf, unsigned long size)
+static void write_blocked(const void *data, unsigned long size)
 {
+       const char *buf = data;
        unsigned long tail;
 
        if (offset) {
@@ -107,6 +85,21 @@ static void write_blocked(void *buf, unsigned long size)
        write_if_needed();
 }
 
+/*
+ * The end of tar archives is marked by 2*512 nul bytes and after that
+ * follows the rest of the block (if any).
+ */
+static void write_trailer(void)
+{
+       int tail = BLOCKSIZE - offset;
+       memset(block + offset, 0, tail);
+       reliable_write(block, BLOCKSIZE);
+       if (tail < 2 * RECORDSIZE) {
+               memset(block, 0, offset);
+               reliable_write(block, BLOCKSIZE);
+       }
+}
+
 static void strbuf_append_string(struct strbuf *sb, const char *s)
 {
        int slen = strlen(s);
@@ -168,8 +161,9 @@ static int get_path_prefix(const struct strbuf *path, int maxlen)
        int i = path->len;
        if (i > maxlen)
                i = maxlen;
-       while (i > 0 && path->buf[i] != '/')
+       do {
                i--;
+       } while (i > 0 && path->buf[i] != '/');
        return i;
 }
 
@@ -239,8 +233,8 @@ static void write_entry(const unsigned char *sha1, struct strbuf *path,
        /* XXX: should we provide more meaningful info here? */
        sprintf(header.uid, "%07o", 0);
        sprintf(header.gid, "%07o", 0);
-       strncpy(header.uname, "git", 31);
-       strncpy(header.gname, "git", 31);
+       strlcpy(header.uname, "git", sizeof(header.uname));
+       strlcpy(header.gname, "git", sizeof(header.gname));
        sprintf(header.devmajor, "%07o", 0);
        sprintf(header.devminor, "%07o", 0);
 
@@ -271,30 +265,25 @@ static void write_global_extended_header(const unsigned char *sha1)
 static void traverse_tree(struct tree_desc *tree, struct strbuf *path)
 {
        int pathlen = path->len;
+       struct name_entry entry;
 
-       while (tree->size) {
-               const char *name;
-               const unsigned char *sha1;
-               unsigned mode;
+       while (tree_entry(tree, &entry)) {
                void *eltbuf;
                char elttype[20];
                unsigned long eltsize;
 
-               sha1 = tree_entry_extract(tree, &name, &mode);
-               update_tree_entry(tree);
-
-               eltbuf = read_sha1_file(sha1, elttype, &eltsize);
+               eltbuf = read_sha1_file(entry.sha1, elttype, &eltsize);
                if (!eltbuf)
-                       die("cannot read %s", sha1_to_hex(sha1));
+                       die("cannot read %s", sha1_to_hex(entry.sha1));
 
                path->len = pathlen;
-               strbuf_append_string(path, name);
-               if (S_ISDIR(mode))
+               strbuf_append_string(path, entry.path);
+               if (S_ISDIR(entry.mode))
                        strbuf_append_string(path, "/");
 
-               write_entry(sha1, path, mode, eltbuf, eltsize);
+               write_entry(entry.sha1, path, entry.mode, eltbuf, eltsize);
 
-               if (S_ISDIR(mode)) {
+               if (S_ISDIR(entry.mode)) {
                        struct tree_desc subtree;
                        subtree.buf = eltbuf;
                        subtree.size = eltsize;
@@ -304,7 +293,7 @@ static void traverse_tree(struct tree_desc *tree, struct strbuf *path)
        }
 }
 
-int generate_tar(int argc, const char **argv)
+static int generate_tar(int argc, const char **argv, char** envp)
 {
        unsigned char sha1[20], tree_sha1[20];
        struct commit *commit;
@@ -404,5 +393,30 @@ int cmd_tar_tree(int argc, const char **argv, char **envp)
                usage(tar_tree_usage);
        if (!strncmp("--remote=", argv[1], 9))
                return remote_tar(argc, argv);
-       return generate_tar(argc, argv);
+       return generate_tar(argc, argv, envp);
+}
+
+/* ustar header + extended global header content */
+#define HEADERSIZE (2 * RECORDSIZE)
+
+int cmd_get_tar_commit_id(int argc, const char **argv, char **envp)
+{
+       char buffer[HEADERSIZE];
+       struct ustar_header *header = (struct ustar_header *)buffer;
+       char *content = buffer + RECORDSIZE;
+       ssize_t n;
+
+       n = xread(0, buffer, HEADERSIZE);
+       if (n < HEADERSIZE)
+               die("git-get-tar-commit-id: read error");
+       if (header->typeflag[0] != 'g')
+               return 1;
+       if (memcmp(content, "52 comment=", 11))
+               return 1;
+
+       n = xwrite(1, content + 11, 41);
+       if (n < 41)
+               die("git-get-tar-commit-id: write error");
+
+       return 0;
 }