removes the artificial restriction tagsize < 8kb from git-mktag

---

5653af26c2cdb31e1f5646b8e563cc8fa27a8d43

 cache.h     |    1 +
 mktag.c     |   29 ++++++++++++++++-------------
 sha1_file.c |   46 ++++++++++++++++++++++++++++++++++++----------
 3 files changed, 53 insertions(+), 23 deletions(-)

5653af26c2cdb31e1f5646b8e563cc8fa27a8d43

index 4b7a439..19e90eb 100644
@@ -154,6 +154,7 @@ extern int ce_match_stat(struct cache_en
 extern int ce_modified(struct cache_entry *ce, struct stat *st, int);
 extern int ce_path_match(const struct cache_entry *ce, const char

**pathspec);
extern int index_fd(unsigned char *sha1, int fd, struct stat *st, int
write_object, const char *type);
+extern int read_pipe(int fd, char** return_buf, unsigned long* return_size);
extern int index_pipe(unsigned char *sha1, int fd, const char *type,
int write_object);
extern int index_path(unsigned char *sha1, const char *path, struct
stat *st, int write_object);
extern void fill_stat_cache_info(struct cache_entry *ce, struct stat *st);

index 2328878..79c466c 100644
@@ -45,7 +45,7 @@ static int verify_tag(char *buffer, unsi
     unsigned char sha1[20];
     const char *object, *type_line, *tag_line, *tagger_line;
 
-    if (size < 64 || size > MAXSIZE-1)
+    if (size < 64)
         return -1;
     buffer[size] = 0;
 

@@ -105,8 +105,8 @@ static int verify_tag(char *buffer, unsi
 
 int main(int argc, char **argv)
 {
-    unsigned long size;
-    char buffer[MAXSIZE];
+    unsigned long size = 4096;
+    char *buffer = malloc(size);
     unsigned char result_sha1[20];
 
     if (argc != 1)

@@ -114,21 +114,24 @@ int main(int argc, char **argv)
 
     setup_git_directory();
 
-    // Read the signature
-    size = 0;
-    for (;;) {
-        int ret = xread(0, buffer + size, MAXSIZE - size);
-        if (ret <= 0)
-            break;
-        size += ret;
+    if (read_pipe(0, &buffer, &size)) {
+        free(buffer);
+        die("could not read from stdin");
     }
-
+    
     // Verify it for some basic sanity: it needs to start with "object

<sha1>\ntype\ntagger "
- if (verify_tag(buffer, size) < 0)
+ if (verify_tag(buffer, size) < 0) {

+        free(buffer);
         die("invalid tag signature file");

+ }

- if (write_sha1_file(buffer, size, tag_type, result_sha1) < 0)
+ if (write_sha1_file(buffer, size, tag_type, result_sha1) < 0) {

+        free(buffer);
         die("unable to write tag file");

+ }
+
+ free(buffer);
+

     printf("%s\n", sha1_to_hex(result_sha1));
     return 0;

}

index 2230010..ad02255 100644
@@ -1645,16 +1645,24 @@ int has_sha1_file(const unsigned char *s
     return find_sha1_file(sha1, &st) ? 1 : 0;
 }
 
-int index_pipe(unsigned char *sha1, int fd, const char *type, int

write_object)
+/*
+ * reads from fd as long as possible into a supplied buffer of size bytes.
+ * If neccessary the buffer's size is increased using realloc()
+ *
+ * returns 0 if anything went fine and -1 otherwise
+ *
+ * NOTE: both buf and size may change, but even when -1 is returned
+ * you still have to free() it yourself.
+ */
+int read_pipe(int fd, char** return_buf, unsigned long* return_size)
{

-    unsigned long size = 4096;
-    char *buf = malloc(size);
-    int iret, ret;
+    char* buf = *return_buf;
+    unsigned long size = *return_size;
+    int iret;
     unsigned long off = 0;
-    unsigned char hdr[50];
-    int hdrlen;
+    
     do {
-        iret = read(fd, buf + off, size - off);
+        iret = xread(fd, buf + off, size - off);
         if (iret > 0) {
             off += iret;
             if (off == size) {
@@ -1663,16 +1671,34 @@ int index_pipe(unsigned char *sha1, int
             }
         }
     } while (iret > 0);

- if (iret < 0) {
+
+ *return_buf = buf;
+ *return_size = off;
+
+ if (iret < 0)
+ return -1;
+ return 0;
+}
+
+int index_pipe(unsigned char *sha1, int fd, const char *type, int write_object)
+{

+    unsigned long size = 4096;
+    char *buf = malloc(size);
+    int ret;
+    unsigned char hdr[50];
+    int hdrlen;
+    
+    if (read_pipe(fd, &buf, &size)) {
         free(buf);
         return -1;
     }
+    
     if (!type)
         type = blob_type;
     if (write_object)
-        ret = write_sha1_file(buf, off, type, sha1);
+        ret = write_sha1_file(buf, size, type, sha1);
     else {
-        write_sha1_file_prepare(buf, off, type, sha1, hdr, &hdrlen);
+        write_sha1_file_prepare(buf, size, type, sha1, hdr, &hdrlen);
         ret = 0;
     }
     free(buf);

1.3.3.g5045-dirty

I smell whitespace breakage around here...