7 static const char *base_name
;
8 static const char unpack_usage
[] = "git-unpack-objects basename";
11 unsigned int offset
; /* network byte order */
12 unsigned char sha1
[20];
15 static void *pack_base
;
16 static unsigned long pack_size
;
17 static void *index_base
;
18 static unsigned long index_size
;
20 static struct pack_entry
**pack_list
;
22 static void *map_file(const char *suffix
, unsigned long *sizep
)
24 static char pathname
[PATH_MAX
];
30 len
= snprintf(pathname
, PATH_MAX
, "%s.%s", base_name
, suffix
);
32 die("bad pack base-name");
33 fd
= open(pathname
, O_RDONLY
);
34 if (fd
< 0 || fstat(fd
, &st
))
35 die("unable to open '%s'", pathname
);
38 die("bad pack file '%s'", pathname
);
39 map
= mmap(NULL
, len
, PROT_READ
, MAP_PRIVATE
, fd
, 0);
40 if (-1 == (int)(long)map
)
41 die("unable to mmap '%s'", pathname
);
47 static int sort_by_offset(const void *_a
, const void *_b
)
49 struct pack_entry
*a
= *(struct pack_entry
**)_a
;
50 struct pack_entry
*b
= *(struct pack_entry
**)_b
;
53 o1
= ntohl(a
->offset
);
54 o2
= ntohl(b
->offset
);
55 return o1
< o2
? -1 : 1;
58 static int check_index(void)
60 unsigned int *array
= index_base
;
64 if (index_size
< 4*256 + 20)
65 return error("index file too small");
67 for (i
= 0; i
< 256; i
++) {
68 unsigned int n
= ntohl(array
[i
]);
70 return error("non-monotonic index");
75 * - 256 index entries 4 bytes each
76 * - 24-byte entries * nr (20-byte sha1 + 4-byte offset)
77 * - 20-byte SHA1 file checksum
79 if (index_size
!= 4*256 + nr
* 24 + 20)
80 return error("wrong index file size");
83 pack_list
= xmalloc(nr
* sizeof(struct pack_entry
*));
84 for (i
= 0; i
< nr
; i
++)
85 pack_list
[i
] = index_base
+ 4*256 + i
*24;
87 qsort(pack_list
, nr
, sizeof(*pack_list
), sort_by_offset
);
89 printf("%d entries\n", nr
);
93 static int unpack_non_delta_entry(struct pack_entry
*entry
,
102 unsigned char sha1
[20];
105 printf("%s %c %lu\n", sha1_to_hex(entry
->sha1
), kind
, size
);
109 buffer
= xmalloc(size
+ 1);
111 memset(&stream
, 0, sizeof(stream
));
112 stream
.next_in
= data
;
113 stream
.avail_in
= left
;
114 stream
.next_out
= buffer
;
115 stream
.avail_out
= size
;
117 inflateInit(&stream
);
118 st
= inflate(&stream
, Z_FINISH
);
120 if ((st
!= Z_STREAM_END
) || stream
.total_out
!= size
)
123 case 'C': type_s
= "commit"; break;
124 case 'T': type_s
= "tree"; break;
125 case 'B': type_s
= "blob"; break;
126 default: goto err_finish
;
128 if (write_sha1_file(buffer
, size
, type_s
, sha1
) < 0)
129 die("failed to write %s (%s)",
130 sha1_to_hex(entry
->sha1
), type_s
);
131 printf("%s %s\n", sha1_to_hex(sha1
), type_s
);
132 if (memcmp(sha1
, entry
->sha1
, 20))
133 die("resulting %s have wrong SHA1", type_s
);
144 static int find_pack_entry(unsigned char *sha1
, struct pack_entry
**ent
)
146 int *level1_ofs
= index_base
;
147 int hi
= ntohl(level1_ofs
[*sha1
]);
148 int lo
= ((*sha1
== 0x0) ? 0 : ntohl(level1_ofs
[*sha1
- 1]));
149 void *index
= index_base
+ 4*256;
152 int mi
= (lo
+ hi
) / 2;
153 int cmp
= memcmp(index
+ 24 * mi
+ 4, sha1
, 20);
155 *ent
= index
+ 24 * mi
;
166 /* forward declaration for a mutually recursive function */
167 static void unpack_entry(struct pack_entry
*);
169 static int unpack_delta_entry(struct pack_entry
*entry
,
170 unsigned char *base_sha1
,
171 unsigned long delta_size
,
174 void *data
, *delta_data
, *result
, *base
;
175 unsigned long data_size
, result_size
, base_size
;
179 unsigned char sha1
[20];
182 die("truncated pack file");
183 data
= base_sha1
+ 20;
184 data_size
= left
- 20;
185 printf("%s D %lu", sha1_to_hex(entry
->sha1
), delta_size
);
186 printf(" %s\n", sha1_to_hex(base_sha1
));
191 /* pack+5 is the base sha1, unless we have it, we need to
194 if (!has_sha1_file(base_sha1
)) {
195 struct pack_entry
*base
;
196 if (!find_pack_entry(base_sha1
, &base
))
197 die("cannot find delta-pack base object");
200 delta_data
= xmalloc(delta_size
);
202 memset(&stream
, 0, sizeof(stream
));
204 stream
.next_in
= data
;
205 stream
.avail_in
= data_size
;
206 stream
.next_out
= delta_data
;
207 stream
.avail_out
= delta_size
;
209 inflateInit(&stream
);
210 st
= inflate(&stream
, Z_FINISH
);
212 if ((st
!= Z_STREAM_END
) || stream
.total_out
!= delta_size
)
213 die("delta data unpack failed");
215 base
= read_sha1_file(base_sha1
, type
, &base_size
);
217 die("failed to read delta-pack base object %s", sha1_to_hex(base_sha1
));
218 result
= patch_delta(base
, base_size
,
219 delta_data
, delta_size
,
222 die("failed to apply delta");
225 if (write_sha1_file(result
, result_size
, type
, sha1
) < 0)
226 die("failed to write %s (%s)",
227 sha1_to_hex(entry
->sha1
), type
);
229 printf("%s %s\n", sha1_to_hex(sha1
), type
);
230 if (memcmp(sha1
, entry
->sha1
, 20))
231 die("resulting %s have wrong SHA1", type
);
235 static void unpack_entry(struct pack_entry
*entry
)
237 unsigned long offset
, size
, left
;
240 /* Have we done this one already due to deltas based on it? */
241 if (lookup_object(entry
->sha1
))
244 offset
= ntohl(entry
->offset
);
245 if (offset
> pack_size
- 5)
246 die("object offset outside of pack file");
247 pack
= pack_base
+ offset
;
248 size
= (pack
[1] << 24) + (pack
[2] << 16) + (pack
[3] << 8) + pack
[4];
249 left
= pack_size
- offset
- 5;
251 case 'C': case 'T': case 'B':
252 unpack_non_delta_entry(entry
, *pack
, pack
+5, size
, left
);
255 unpack_delta_entry(entry
, pack
+5, size
, left
);
258 die("corrupted pack file");
263 * We unpack from the end, older files first. Now, usually
264 * there are deltas etc, so we'll not actually write the
265 * objects in that order, but we might as well try..
267 static void unpack_all(void)
272 struct pack_entry
*entry
= pack_list
[i
];
277 int main(int argc
, char **argv
)
281 for (i
= 1 ; i
< argc
; i
++) {
282 const char *arg
= argv
[i
];
285 if (!strcmp(arg
, "-n")) {
297 index_base
= map_file("idx", &index_size
);
298 pack_base
= map_file("pack", &pack_size
);
299 if (check_index() < 0)
300 die("bad index file");