move read_mmfile() into xdiff-interface
[gitweb.git] / sha1_file.c
index b89edb9515aa38c2c404367aa28ec5531fcc7de1..1c4df5b73e9dff900c69c0994eb21105614511b6 100644 (file)
@@ -26,44 +26,40 @@ const unsigned char null_sha1[20];
 
 static unsigned int sha1_file_open_flag = O_NOATIME;
 
-static inline unsigned int hexval(unsigned int c)
-{
-       static signed char val[256] = {
-                -1, -1, -1, -1, -1, -1, -1, -1,                /* 00-07 */
-                -1, -1, -1, -1, -1, -1, -1, -1,                /* 08-0f */
-                -1, -1, -1, -1, -1, -1, -1, -1,                /* 10-17 */
-                -1, -1, -1, -1, -1, -1, -1, -1,                /* 18-1f */
-                -1, -1, -1, -1, -1, -1, -1, -1,                /* 20-27 */
-                -1, -1, -1, -1, -1, -1, -1, -1,                /* 28-2f */
-                 0,  1,  2,  3,  4,  5,  6,  7,                /* 30-37 */
-                 8,  9, -1, -1, -1, -1, -1, -1,                /* 38-3f */
-                -1, 10, 11, 12, 13, 14, 15, -1,                /* 40-47 */
-                -1, -1, -1, -1, -1, -1, -1, -1,                /* 48-4f */
-                -1, -1, -1, -1, -1, -1, -1, -1,                /* 50-57 */
-                -1, -1, -1, -1, -1, -1, -1, -1,                /* 58-5f */
-                -1, 10, 11, 12, 13, 14, 15, -1,                /* 60-67 */
-                -1, -1, -1, -1, -1, -1, -1, -1,                /* 68-67 */
-                -1, -1, -1, -1, -1, -1, -1, -1,                /* 70-77 */
-                -1, -1, -1, -1, -1, -1, -1, -1,                /* 78-7f */
-                -1, -1, -1, -1, -1, -1, -1, -1,                /* 80-87 */
-                -1, -1, -1, -1, -1, -1, -1, -1,                /* 88-8f */
-                -1, -1, -1, -1, -1, -1, -1, -1,                /* 90-97 */
-                -1, -1, -1, -1, -1, -1, -1, -1,                /* 98-9f */
-                -1, -1, -1, -1, -1, -1, -1, -1,                /* a0-a7 */
-                -1, -1, -1, -1, -1, -1, -1, -1,                /* a8-af */
-                -1, -1, -1, -1, -1, -1, -1, -1,                /* b0-b7 */
-                -1, -1, -1, -1, -1, -1, -1, -1,                /* b8-bf */
-                -1, -1, -1, -1, -1, -1, -1, -1,                /* c0-c7 */
-                -1, -1, -1, -1, -1, -1, -1, -1,                /* c8-cf */
-                -1, -1, -1, -1, -1, -1, -1, -1,                /* d0-d7 */
-                -1, -1, -1, -1, -1, -1, -1, -1,                /* d8-df */
-                -1, -1, -1, -1, -1, -1, -1, -1,                /* e0-e7 */
-                -1, -1, -1, -1, -1, -1, -1, -1,                /* e8-ef */
-                -1, -1, -1, -1, -1, -1, -1, -1,                /* f0-f7 */
-                -1, -1, -1, -1, -1, -1, -1, -1,                /* f8-ff */
-       };
-       return val[c];
-}
+signed char hexval_table[256] = {
+        -1, -1, -1, -1, -1, -1, -1, -1,                /* 00-07 */
+        -1, -1, -1, -1, -1, -1, -1, -1,                /* 08-0f */
+        -1, -1, -1, -1, -1, -1, -1, -1,                /* 10-17 */
+        -1, -1, -1, -1, -1, -1, -1, -1,                /* 18-1f */
+        -1, -1, -1, -1, -1, -1, -1, -1,                /* 20-27 */
+        -1, -1, -1, -1, -1, -1, -1, -1,                /* 28-2f */
+         0,  1,  2,  3,  4,  5,  6,  7,                /* 30-37 */
+         8,  9, -1, -1, -1, -1, -1, -1,                /* 38-3f */
+        -1, 10, 11, 12, 13, 14, 15, -1,                /* 40-47 */
+        -1, -1, -1, -1, -1, -1, -1, -1,                /* 48-4f */
+        -1, -1, -1, -1, -1, -1, -1, -1,                /* 50-57 */
+        -1, -1, -1, -1, -1, -1, -1, -1,                /* 58-5f */
+        -1, 10, 11, 12, 13, 14, 15, -1,                /* 60-67 */
+        -1, -1, -1, -1, -1, -1, -1, -1,                /* 68-67 */
+        -1, -1, -1, -1, -1, -1, -1, -1,                /* 70-77 */
+        -1, -1, -1, -1, -1, -1, -1, -1,                /* 78-7f */
+        -1, -1, -1, -1, -1, -1, -1, -1,                /* 80-87 */
+        -1, -1, -1, -1, -1, -1, -1, -1,                /* 88-8f */
+        -1, -1, -1, -1, -1, -1, -1, -1,                /* 90-97 */
+        -1, -1, -1, -1, -1, -1, -1, -1,                /* 98-9f */
+        -1, -1, -1, -1, -1, -1, -1, -1,                /* a0-a7 */
+        -1, -1, -1, -1, -1, -1, -1, -1,                /* a8-af */
+        -1, -1, -1, -1, -1, -1, -1, -1,                /* b0-b7 */
+        -1, -1, -1, -1, -1, -1, -1, -1,                /* b8-bf */
+        -1, -1, -1, -1, -1, -1, -1, -1,                /* c0-c7 */
+        -1, -1, -1, -1, -1, -1, -1, -1,                /* c8-cf */
+        -1, -1, -1, -1, -1, -1, -1, -1,                /* d0-d7 */
+        -1, -1, -1, -1, -1, -1, -1, -1,                /* d8-df */
+        -1, -1, -1, -1, -1, -1, -1, -1,                /* e0-e7 */
+        -1, -1, -1, -1, -1, -1, -1, -1,                /* e8-ef */
+        -1, -1, -1, -1, -1, -1, -1, -1,                /* f0-f7 */
+        -1, -1, -1, -1, -1, -1, -1, -1,                /* f8-ff */
+};
 
 int get_sha1_hex(const char *hex, unsigned char *sha1)
 {
@@ -667,7 +663,7 @@ void prepare_packed_git(void)
        prepare_packed_git_run_once = 1;
 }
 
-static void reprepare_packed_git(void)
+void reprepare_packed_git(void)
 {
        prepare_packed_git_run_once = 0;
        prepare_packed_git();
@@ -675,14 +671,8 @@ static void reprepare_packed_git(void)
 
 int check_sha1_signature(const unsigned char *sha1, void *map, unsigned long size, const char *type)
 {
-       char header[100];
        unsigned char real_sha1[20];
-       SHA_CTX c;
-
-       SHA1_Init(&c);
-       SHA1_Update(&c, header, 1+sprintf(header, "%s %lu", type, size));
-       SHA1_Update(&c, map, size);
-       SHA1_Final(real_sha1, &c);
+       hash_sha1_file(map, size, type, real_sha1);
        return hashcmp(sha1, real_sha1) ? -1 : 0;
 }
 
@@ -887,47 +877,81 @@ void * unpack_sha1_file(void *map, unsigned long mapsize, char *type, unsigned l
        return unpack_sha1_rest(&stream, hdr, *size);
 }
 
+static unsigned long get_delta_base(struct packed_git *p,
+                                   unsigned long offset,
+                                   enum object_type kind,
+                                   unsigned long delta_obj_offset,
+                                   unsigned long *base_obj_offset)
+{
+       unsigned char *base_info = (unsigned char *) p->pack_base + offset;
+       unsigned long base_offset;
+
+       /* there must be at least 20 bytes left regardless of delta type */
+       if (p->pack_size <= offset + 20)
+               die("truncated pack file");
+
+       if (kind == OBJ_OFS_DELTA) {
+               unsigned used = 0;
+               unsigned char c = base_info[used++];
+               base_offset = c & 127;
+               while (c & 128) {
+                       base_offset += 1;
+                       if (!base_offset || base_offset & ~(~0UL >> 7))
+                               die("offset value overflow for delta base object");
+                       c = base_info[used++];
+                       base_offset = (base_offset << 7) + (c & 127);
+               }
+               base_offset = delta_obj_offset - base_offset;
+               if (base_offset >= delta_obj_offset)
+                       die("delta base offset out of bound");
+               offset += used;
+       } else if (kind == OBJ_REF_DELTA) {
+               /* The base entry _must_ be in the same pack */
+               base_offset = find_pack_entry_one(base_info, p);
+               if (!base_offset)
+                       die("failed to find delta-pack base object %s",
+                               sha1_to_hex(base_info));
+               offset += 20;
+       } else
+               die("I am totally screwed");
+       *base_obj_offset = base_offset;
+       return offset;
+}
+
 /* forward declaration for a mutually recursive function */
-static int packed_object_info(struct pack_entry *entry,
+static int packed_object_info(struct packed_git *p, unsigned long offset,
                              char *type, unsigned long *sizep);
 
-static int packed_delta_info(unsigned char *base_sha1,
-                            unsigned long delta_size,
-                            unsigned long left,
+static int packed_delta_info(struct packed_git *p,
+                            unsigned long offset,
+                            enum object_type kind,
+                            unsigned long obj_offset,
                             char *type,
-                            unsigned long *sizep,
-                            struct packed_git *p)
+                            unsigned long *sizep)
 {
-       struct pack_entry base_ent;
+       unsigned long base_offset;
 
-       if (left < 20)
-               die("truncated pack file");
-
-       /* The base entry _must_ be in the same pack */
-       if (!find_pack_entry_one(base_sha1, &base_ent, p))
-               die("failed to find delta-pack base object %s",
-                   sha1_to_hex(base_sha1));
+       offset = get_delta_base(p, offset, kind, obj_offset, &base_offset);
 
        /* We choose to only get the type of the base object and
         * ignore potentially corrupt pack file that expects the delta
         * based on a base with a wrong size.  This saves tons of
         * inflate() calls.
         */
-
-       if (packed_object_info(&base_ent, type, NULL))
+       if (packed_object_info(p, base_offset, type, NULL))
                die("cannot get info for delta-pack base");
 
        if (sizep) {
                const unsigned char *data;
-               unsigned char delta_head[64];
+               unsigned char delta_head[20];
                unsigned long result_size;
                z_stream stream;
                int st;
 
                memset(&stream, 0, sizeof(stream));
 
-               data = stream.next_in = base_sha1 + 20;
-               stream.avail_in = left - 20;
+               stream.next_in = (unsigned char *) p->pack_base + offset;
+               stream.avail_in = p->pack_size - offset;
                stream.next_out = delta_head;
                stream.avail_out = sizeof(delta_head);
 
@@ -970,94 +994,68 @@ static unsigned long unpack_object_header(struct packed_git *p, unsigned long of
        return offset + used;
 }
 
-int check_reuse_pack_delta(struct packed_git *p, unsigned long offset,
-                          unsigned char *base, unsigned long *sizep,
-                          enum object_type *kindp)
-{
-       unsigned long ptr;
-       int status = -1;
-
-       use_packed_git(p);
-       ptr = offset;
-       ptr = unpack_object_header(p, ptr, kindp, sizep);
-       if (*kindp != OBJ_DELTA)
-               goto done;
-       hashcpy(base, (unsigned char *) p->pack_base + ptr);
-       status = 0;
- done:
-       unuse_packed_git(p);
-       return status;
-}
-
-void packed_object_info_detail(struct pack_entry *e,
+void packed_object_info_detail(struct packed_git *p,
+                              unsigned long offset,
                               char *type,
                               unsigned long *size,
                               unsigned long *store_size,
                               unsigned int *delta_chain_length,
                               unsigned char *base_sha1)
 {
-       struct packed_git *p = e->p;
-       unsigned long offset;
-       unsigned char *pack;
+       unsigned long obj_offset, val;
+       unsigned char *next_sha1;
        enum object_type kind;
 
-       offset = unpack_object_header(p, e->offset, &kind, size);
-       pack = (unsigned char *) p->pack_base + offset;
-       if (kind != OBJ_DELTA)
-               *delta_chain_length = 0;
-       else {
-               unsigned int chain_length = 0;
-               if (p->pack_size <= offset + 20)
-                       die("pack file %s records an incomplete delta base",
-                           p->pack_name);
-               hashcpy(base_sha1, pack);
-               do {
-                       struct pack_entry base_ent;
-                       unsigned long junk;
-
-                       find_pack_entry_one(pack, &base_ent, p);
-                       offset = unpack_object_header(p, base_ent.offset,
-                                                     &kind, &junk);
-                       pack = (unsigned char *) p->pack_base + offset;
-                       chain_length++;
-               } while (kind == OBJ_DELTA);
-               *delta_chain_length = chain_length;
-       }
-       switch (kind) {
-       case OBJ_COMMIT:
-       case OBJ_TREE:
-       case OBJ_BLOB:
-       case OBJ_TAG:
-               strcpy(type, type_names[kind]);
-               break;
-       default:
-               die("corrupted pack file %s containing object of kind %d",
-                   p->pack_name, kind);
+       *delta_chain_length = 0;
+       obj_offset = offset;
+       offset = unpack_object_header(p, offset, &kind, size);
+
+       for (;;) {
+               switch (kind) {
+               default:
+                       die("pack %s contains unknown object type %d",
+                           p->pack_name, kind);
+               case OBJ_COMMIT:
+               case OBJ_TREE:
+               case OBJ_BLOB:
+               case OBJ_TAG:
+                       strcpy(type, type_names[kind]);
+                       *store_size = 0; /* notyet */
+                       return;
+               case OBJ_OFS_DELTA:
+                       get_delta_base(p, offset, kind, obj_offset, &offset);
+                       if (*delta_chain_length == 0) {
+                               /* TODO: find base_sha1 as pointed by offset */
+                       }
+                       break;
+               case OBJ_REF_DELTA:
+                       if (p->pack_size <= offset + 20)
+                               die("pack file %s records an incomplete delta base",
+                                   p->pack_name);
+                       next_sha1 = (unsigned char *) p->pack_base + offset;
+                       if (*delta_chain_length == 0)
+                               hashcpy(base_sha1, next_sha1);
+                       offset = find_pack_entry_one(next_sha1, p);
+                       break;
+               }
+               obj_offset = offset;
+               offset = unpack_object_header(p, offset, &kind, &val);
+               (*delta_chain_length)++;
        }
-       *store_size = 0; /* notyet */
 }
 
-static int packed_object_info(struct pack_entry *entry,
+static int packed_object_info(struct packed_git *p, unsigned long offset,
                              char *type, unsigned long *sizep)
 {
-       struct packed_git *p = entry->p;
-       unsigned long offset, size, left;
-       unsigned char *pack;
+       unsigned long size, obj_offset = offset;
        enum object_type kind;
-       int retval;
 
-       if (use_packed_git(p))
-               die("cannot map packed file");
-
-       offset = unpack_object_header(p, entry->offset, &kind, &size);
-       pack = (unsigned char *) p->pack_base + offset;
-       left = p->pack_size - offset;
+       offset = unpack_object_header(p, offset, &kind, &size);
 
        switch (kind) {
-       case OBJ_DELTA:
-               retval = packed_delta_info(pack, size, left, type, sizep, p);
-               unuse_packed_git(p);
-               return retval;
+       case OBJ_OFS_DELTA:
+       case OBJ_REF_DELTA:
+               return packed_delta_info(p, offset, kind, obj_offset, type, sizep);
        case OBJ_COMMIT:
        case OBJ_TREE:
        case OBJ_BLOB:
@@ -1065,12 +1063,11 @@ static int packed_object_info(struct pack_entry *entry,
                strcpy(type, type_names[kind]);
                break;
        default:
-               die("corrupted pack file %s containing object of kind %d",
+               die("pack %s contains unknown object type %d",
                    p->pack_name, kind);
        }
        if (sizep)
                *sizep = size;
-       unuse_packed_git(p);
        return 0;
 }
 
@@ -1104,28 +1101,21 @@ static void *unpack_compressed_entry(struct packed_git *p,
 static void *unpack_delta_entry(struct packed_git *p,
                                unsigned long offset,
                                unsigned long delta_size,
+                               enum object_type kind,
+                               unsigned long obj_offset,
                                char *type,
                                unsigned long *sizep)
 {
-       struct pack_entry base_ent;
        void *delta_data, *result, *base;
-       unsigned long result_size, base_size;
-       unsigned char* base_sha1;
+       unsigned long result_size, base_size, base_offset;
 
-       if ((offset + 20) >= p->pack_size)
-               die("truncated pack file");
-
-       /* The base entry _must_ be in the same pack */
-       base_sha1 = (unsigned char*)p->pack_base + offset;
-       if (!find_pack_entry_one(base_sha1, &base_ent, p))
-               die("failed to find delta-pack base object %s",
-                   sha1_to_hex(base_sha1));
-       base = unpack_entry_gently(&base_ent, type, &base_size);
+       offset = get_delta_base(p, offset, kind, obj_offset, &base_offset);
+       base = unpack_entry_gently(p, base_offset, type, &base_size);
        if (!base)
-               die("failed to read delta-pack base object %s",
-                   sha1_to_hex(base_sha1));
+               die("failed to read delta base object at %lu from %s",
+                   base_offset, p->pack_name);
 
-       delta_data = unpack_compressed_entry(p, offset + 20, delta_size);
+       delta_data = unpack_compressed_entry(p, offset, delta_size);
        result = patch_delta(base, base_size,
                             delta_data, delta_size,
                             &result_size);
@@ -1145,7 +1135,7 @@ static void *unpack_entry(struct pack_entry *entry,
 
        if (use_packed_git(p))
                die("cannot map packed file");
-       retval = unpack_entry_gently(entry, type, sizep);
+       retval = unpack_entry_gently(p, entry->offset, type, sizep);
        unuse_packed_git(p);
        if (!retval)
                die("corrupted pack file %s", p->pack_name);
@@ -1153,17 +1143,17 @@ static void *unpack_entry(struct pack_entry *entry,
 }
 
 /* The caller is responsible for use_packed_git()/unuse_packed_git() pair */
-void *unpack_entry_gently(struct pack_entry *entry,
+void *unpack_entry_gently(struct packed_git *p, unsigned long offset,
                          char *type, unsigned long *sizep)
 {
-       struct packed_git *p = entry->p;
-       unsigned long offset, size;
+       unsigned long size, obj_offset = offset;
        enum object_type kind;
 
-       offset = unpack_object_header(p, entry->offset, &kind, &size);
+       offset = unpack_object_header(p, offset, &kind, &size);
        switch (kind) {
-       case OBJ_DELTA:
-               return unpack_delta_entry(p, offset, size, type, sizep);
+       case OBJ_OFS_DELTA:
+       case OBJ_REF_DELTA:
+               return unpack_delta_entry(p, offset, size, kind, obj_offset, type, sizep);
        case OBJ_COMMIT:
        case OBJ_TREE:
        case OBJ_BLOB:
@@ -1192,8 +1182,8 @@ int nth_packed_object_sha1(const struct packed_git *p, int n,
        return 0;
 }
 
-int find_pack_entry_one(const unsigned char *sha1,
-                       struct pack_entry *e, struct packed_git *p)
+unsigned long find_pack_entry_one(const unsigned char *sha1,
+                                 struct packed_git *p)
 {
        unsigned int *level1_ofs = p->index_base;
        int hi = ntohl(level1_ofs[*sha1]);
@@ -1203,12 +1193,8 @@ int find_pack_entry_one(const unsigned char *sha1,
        do {
                int mi = (lo + hi) / 2;
                int cmp = hashcmp((unsigned char *)index + (24 * mi) + 4, sha1);
-               if (!cmp) {
-                       e->offset = ntohl(*((unsigned int *) ((char *) index + (24 * mi))));
-                       hashcpy(e->sha1, sha1);
-                       e->p = p;
-                       return 1;
-               }
+               if (!cmp)
+                       return ntohl(*((unsigned int *) ((char *) index + (24 * mi))));
                if (cmp > 0)
                        hi = mi;
                else
@@ -1217,22 +1203,47 @@ int find_pack_entry_one(const unsigned char *sha1,
        return 0;
 }
 
+static int matches_pack_name(struct packed_git *p, const char *ig)
+{
+       const char *last_c, *c;
+
+       if (!strcmp(p->pack_name, ig))
+               return 0;
+
+       for (c = p->pack_name, last_c = c; *c;)
+               if (*c == '/')
+                       last_c = ++c;
+               else
+                       ++c;
+       if (!strcmp(last_c, ig))
+               return 0;
+
+       return 1;
+}
+
 static int find_pack_entry(const unsigned char *sha1, struct pack_entry *e, const char **ignore_packed)
 {
        struct packed_git *p;
+       unsigned long offset;
+
        prepare_packed_git();
 
        for (p = packed_git; p; p = p->next) {
                if (ignore_packed) {
                        const char **ig;
                        for (ig = ignore_packed; *ig; ig++)
-                               if (!strcmp(p->pack_name, *ig))
+                               if (!matches_pack_name(p, *ig))
                                        break;
                        if (*ig)
                                continue;
                }
-               if (find_pack_entry_one(sha1, e, p))
+               offset = find_pack_entry_one(sha1, p);
+               if (offset) {
+                       e->offset = offset;
+                       e->p = p;
+                       hashcpy(e->sha1, sha1);
                        return 1;
+               }
        }
        return 0;
 }
@@ -1241,17 +1252,16 @@ struct packed_git *find_sha1_pack(const unsigned char *sha1,
                                  struct packed_git *packs)
 {
        struct packed_git *p;
-       struct pack_entry e;
 
        for (p = packs; p; p = p->next) {
-               if (find_pack_entry_one(sha1, &e, p))
+               if (find_pack_entry_one(sha1, p))
                        return p;
        }
        return NULL;
        
 }
 
-int sha1_object_info(const unsigned char *sha1, char *type, unsigned long *sizep)
+static int sha1_loose_object_info(const unsigned char *sha1, char *type, unsigned long *sizep)
 {
        int status;
        unsigned long mapsize, size;
@@ -1260,16 +1270,8 @@ int sha1_object_info(const unsigned char *sha1, char *type, unsigned long *sizep
        char hdr[128];
 
        map = map_sha1_file(sha1, &mapsize);
-       if (!map) {
-               struct pack_entry e;
-
-               if (find_pack_entry(sha1, &e, NULL))
-                       return packed_object_info(&e, type, sizep);
-               reprepare_packed_git();
-               if (find_pack_entry(sha1, &e, NULL))
-                       return packed_object_info(&e, type, sizep);
+       if (!map)
                return error("unable to find %s", sha1_to_hex(sha1));
-       }
        if (unpack_sha1_header(&stream, map, mapsize, hdr, sizeof(hdr)) < 0)
                status = error("unable to unpack %s header",
                               sha1_to_hex(sha1));
@@ -1285,6 +1287,23 @@ int sha1_object_info(const unsigned char *sha1, char *type, unsigned long *sizep
        return status;
 }
 
+int sha1_object_info(const unsigned char *sha1, char *type, unsigned long *sizep)
+{
+       int status;
+       struct pack_entry e;
+
+       if (!find_pack_entry(sha1, &e, NULL)) {
+               reprepare_packed_git();
+               if (!find_pack_entry(sha1, &e, NULL))
+                       return sha1_loose_object_info(sha1, type, sizep);
+       }
+       if (use_packed_git(e.p))
+               die("cannot map packed file");
+       status = packed_object_info(e.p, e.offset, type, sizep);
+       unuse_packed_git(e.p);
+       return status;
+}
+
 static void *read_packed_sha1(const unsigned char *sha1, char *type, unsigned long *size)
 {
        struct pack_entry e;
@@ -1362,12 +1381,9 @@ void *read_object_with_reference(const unsigned char *sha1,
        }
 }
 
-char *write_sha1_file_prepare(void *buf,
-                             unsigned long len,
-                             const char *type,
-                             unsigned char *sha1,
-                             unsigned char *hdr,
-                             int *hdrlen)
+static void write_sha1_file_prepare(void *buf, unsigned long len,
+                                    const char *type, unsigned char *sha1,
+                                    unsigned char *hdr, int *hdrlen)
 {
        SHA_CTX c;
 
@@ -1379,8 +1395,6 @@ char *write_sha1_file_prepare(void *buf,
        SHA1_Update(&c, hdr, *hdrlen);
        SHA1_Update(&c, buf, len);
        SHA1_Final(sha1, &c);
-
-       return sha1_file_name(sha1);
 }
 
 /*
@@ -1408,9 +1422,10 @@ static int link_temp_to_file(const char *tmpfile, const char *filename)
        dir = strrchr(filename, '/');
        if (dir) {
                *dir = 0;
-               mkdir(filename, 0777);
-               if (adjust_shared_perm(filename))
+               if (!mkdir(filename, 0777) && adjust_shared_perm(filename)) {
+                       *dir = '/';
                        return -2;
+               }
                *dir = '/';
                if (!link(tmpfile, filename))
                        return 0;
@@ -1445,8 +1460,7 @@ int move_temp_to_file(const char *tmpfile, const char *filename)
        unlink(tmpfile);
        if (ret) {
                if (ret != EEXIST) {
-                       fprintf(stderr, "unable to write sha1 filename %s: %s\n", filename, strerror(ret));
-                       return -1;
+                       return error("unable to write sha1 filename %s: %s\n", filename, strerror(ret));
                }
                /* FIXME!!! Collision check here ? */
        }
@@ -1516,6 +1530,15 @@ static void setup_object_header(z_stream *stream, const char *type, unsigned lon
        stream->avail_out -= hdr;
 }
 
+int hash_sha1_file(void *buf, unsigned long len, const char *type,
+                   unsigned char *sha1)
+{
+       unsigned char hdr[50];
+       int hdrlen;
+       write_sha1_file_prepare(buf, len, type, sha1, hdr, &hdrlen);
+       return 0;
+}
+
 int write_sha1_file(void *buf, unsigned long len, const char *type, unsigned char *returnsha1)
 {
        int size;
@@ -1530,7 +1553,8 @@ int write_sha1_file(void *buf, unsigned long len, const char *type, unsigned cha
        /* Normally if we have it in the pack then we do not bother writing
         * it out into .git/objects/??/?{38} file.
         */
-       filename = write_sha1_file_prepare(buf, len, type, sha1, hdr, &hdrlen);
+       write_sha1_file_prepare(buf, len, type, sha1, hdr, &hdrlen);
+       filename = sha1_file_name(sha1);
        if (returnsha1)
                hashcpy(returnsha1, sha1);
        if (has_sha1_file(sha1))
@@ -1546,16 +1570,17 @@ int write_sha1_file(void *buf, unsigned long len, const char *type, unsigned cha
        }
 
        if (errno != ENOENT) {
-               fprintf(stderr, "sha1 file %s: %s\n", filename, strerror(errno));
-               return -1;
+               return error("sha1 file %s: %s\n", filename, strerror(errno));
        }
 
        snprintf(tmpfile, sizeof(tmpfile), "%s/obj_XXXXXX", get_object_directory());
 
        fd = mkstemp(tmpfile);
        if (fd < 0) {
-               fprintf(stderr, "unable to create temporary sha1 filename %s: %s\n", tmpfile, strerror(errno));
-               return -1;
+               if (errno == EPERM)
+                       return error("insufficient permission for adding an object to repository database %s\n", get_object_directory());
+               else
+                       return error("unable to create temporary sha1 filename %s: %s\n", tmpfile, strerror(errno));
        }
 
        /* Set it up */
@@ -1670,9 +1695,12 @@ int write_sha1_from_fd(const unsigned char *sha1, int fd, char *buffer,
        snprintf(tmpfile, sizeof(tmpfile), "%s/obj_XXXXXX", get_object_directory());
 
        local = mkstemp(tmpfile);
-       if (local < 0)
-               return error("Couldn't open %s for %s",
-                            tmpfile, sha1_to_hex(sha1));
+       if (local < 0) {
+               if (errno == EPERM)
+                       return error("insufficient permission for adding an object to repository database %s\n", get_object_directory());
+               else
+                       return error("unable to create temporary sha1 filename %s: %s\n", tmpfile, strerror(errno));
+       }
 
        memset(&stream, 0, sizeof(stream));
 
@@ -1799,8 +1827,6 @@ int index_pipe(unsigned char *sha1, int fd, const char *type, int write_object)
        unsigned long size = 4096;
        char *buf = xmalloc(size);
        int ret;
-       unsigned char hdr[50];
-       int hdrlen;
 
        if (read_pipe(fd, &buf, &size)) {
                free(buf);
@@ -1811,10 +1837,8 @@ int index_pipe(unsigned char *sha1, int fd, const char *type, int write_object)
                type = blob_type;
        if (write_object)
                ret = write_sha1_file(buf, size, type, sha1);
-       else {
-               write_sha1_file_prepare(buf, size, type, sha1, hdr, &hdrlen);
-               ret = 0;
-       }
+       else
+               ret = hash_sha1_file(buf, size, type, sha1);
        free(buf);
        return ret;
 }
@@ -1824,8 +1848,6 @@ int index_fd(unsigned char *sha1, int fd, struct stat *st, int write_object, con
        unsigned long size = st->st_size;
        void *buf;
        int ret;
-       unsigned char hdr[50];
-       int hdrlen;
 
        buf = "";
        if (size)
@@ -1838,10 +1860,8 @@ int index_fd(unsigned char *sha1, int fd, struct stat *st, int write_object, con
                type = blob_type;
        if (write_object)
                ret = write_sha1_file(buf, size, type, sha1);
-       else {
-               write_sha1_file_prepare(buf, size, type, sha1, hdr, &hdrlen);
-               ret = 0;
-       }
+       else
+               ret = hash_sha1_file(buf, size, type, sha1);
        if (size)
                munmap(buf, size);
        return ret;
@@ -1870,12 +1890,9 @@ int index_path(unsigned char *sha1, const char *path, struct stat *st, int write
                        return error("readlink(\"%s\"): %s", path,
                                     errstr);
                }
-               if (!write_object) {
-                       unsigned char hdr[50];
-                       int hdrlen;
-                       write_sha1_file_prepare(target, st->st_size, blob_type,
-                                               sha1, hdr, &hdrlen);
-               } else if (write_sha1_file(target, st->st_size, blob_type, sha1))
+               if (!write_object)
+                       hash_sha1_file(target, st->st_size, blob_type, sha1);
+               else if (write_sha1_file(target, st->st_size, blob_type, sha1))
                        return error("%s: failed to insert into database",
                                     path);
                free(target);