11 #include "tree-walk.h"
16 static int dry_run
, quiet
, recover
, has_errors
, strict
;
17 static const char unpack_usage
[] = "git unpack-objects [-n] [-q] [-r] [--strict]";
19 /* We always read in 4kB chunks. */
20 static unsigned char buffer
[4096];
21 static unsigned int offset
, len
;
22 static off_t consumed_bytes
;
23 static off_t max_input_size
;
24 static git_SHA_CTX ctx
;
25 static struct fsck_options fsck_options
= FSCK_OPTIONS_STRICT
;
28 * When running under --strict mode, objects whose reachability are
29 * suspect are kept in core without getting written in the object
37 static struct decoration obj_decorate
;
39 static struct obj_buffer
*lookup_object_buffer(struct object
*base
)
41 return lookup_decoration(&obj_decorate
, base
);
44 static void add_object_buffer(struct object
*object
, char *buffer
, unsigned long size
)
46 struct obj_buffer
*obj
;
47 obj
= xcalloc(1, sizeof(struct obj_buffer
));
50 if (add_decoration(&obj_decorate
, object
, obj
))
51 die("object %s tried to add buffer twice!", oid_to_hex(&object
->oid
));
55 * Make sure at least "min" bytes are available in the buffer, and
56 * return the pointer to the buffer.
58 static void *fill(int min
)
61 return buffer
+ offset
;
62 if (min
> sizeof(buffer
))
63 die("cannot fill %d bytes", min
);
65 git_SHA1_Update(&ctx
, buffer
, offset
);
66 memmove(buffer
, buffer
+ offset
, len
);
70 ssize_t ret
= xread(0, buffer
+ len
, sizeof(buffer
) - len
);
74 die_errno("read error on input");
81 static void use(int bytes
)
84 die("used more bytes than were available");
88 /* make sure off_t is sufficiently large not to wrap */
89 if (signed_add_overflows(consumed_bytes
, bytes
))
90 die("pack too large for current definition of off_t");
91 consumed_bytes
+= bytes
;
92 if (max_input_size
&& consumed_bytes
> max_input_size
)
93 die(_("pack exceeds maximum allowed size"));
96 static void *get_data(unsigned long size
)
99 void *buf
= xmallocz(size
);
101 memset(&stream
, 0, sizeof(stream
));
103 stream
.next_out
= buf
;
104 stream
.avail_out
= size
;
105 stream
.next_in
= fill(1);
106 stream
.avail_in
= len
;
107 git_inflate_init(&stream
);
110 int ret
= git_inflate(&stream
, 0);
111 use(len
- stream
.avail_in
);
112 if (stream
.total_out
== size
&& ret
== Z_STREAM_END
)
115 error("inflate returned %d", ret
);
122 stream
.next_in
= fill(1);
123 stream
.avail_in
= len
;
125 git_inflate_end(&stream
);
130 struct object_id base_oid
;
135 struct delta_info
*next
;
138 static struct delta_info
*delta_list
;
140 static void add_delta_to_list(unsigned nr
, const struct object_id
*base_oid
,
142 void *delta
, unsigned long size
)
144 struct delta_info
*info
= xmalloc(sizeof(*info
));
146 oidcpy(&info
->base_oid
, base_oid
);
147 info
->base_offset
= base_offset
;
151 info
->next
= delta_list
;
157 struct object_id oid
;
161 #define FLAG_OPEN (1u<<20)
162 #define FLAG_WRITTEN (1u<<21)
164 static struct obj_info
*obj_list
;
165 static unsigned nr_objects
;
168 * Called only from check_object() after it verified this object
171 static void write_cached_object(struct object
*obj
, struct obj_buffer
*obj_buf
)
173 struct object_id oid
;
175 if (write_sha1_file(obj_buf
->buffer
, obj_buf
->size
, typename(obj
->type
), oid
.hash
) < 0)
176 die("failed to write object %s", oid_to_hex(&obj
->oid
));
177 obj
->flags
|= FLAG_WRITTEN
;
181 * At the very end of the processing, write_rest() scans the objects
182 * that have reachability requirements and calls this function.
183 * Verify its reachability and validity recursively and write it out.
185 static int check_object(struct object
*obj
, int type
, void *data
, struct fsck_options
*options
)
187 struct obj_buffer
*obj_buf
;
192 if (obj
->flags
& FLAG_WRITTEN
)
195 if (type
!= OBJ_ANY
&& obj
->type
!= type
)
196 die("object type mismatch");
198 if (!(obj
->flags
& FLAG_OPEN
)) {
200 int type
= sha1_object_info(obj
->oid
.hash
, &size
);
201 if (type
!= obj
->type
|| type
<= 0)
202 die("object of unexpected type");
203 obj
->flags
|= FLAG_WRITTEN
;
207 obj_buf
= lookup_object_buffer(obj
);
209 die("Whoops! Cannot find object '%s'", oid_to_hex(&obj
->oid
));
210 if (fsck_object(obj
, obj_buf
->buffer
, obj_buf
->size
, &fsck_options
))
211 die("Error in object");
212 fsck_options
.walk
= check_object
;
213 if (fsck_walk(obj
, NULL
, &fsck_options
))
214 die("Error on reachable objects of %s", oid_to_hex(&obj
->oid
));
215 write_cached_object(obj
, obj_buf
);
219 static void write_rest(void)
222 for (i
= 0; i
< nr_objects
; i
++) {
224 check_object(obj_list
[i
].obj
, OBJ_ANY
, NULL
, NULL
);
228 static void added_object(unsigned nr
, enum object_type type
,
229 void *data
, unsigned long size
);
232 * Write out nr-th object from the list, now we know the contents
233 * of it. Under --strict, this buffers structured objects in-core,
234 * to be checked at the end.
236 static void write_object(unsigned nr
, enum object_type type
,
237 void *buf
, unsigned long size
)
240 if (write_sha1_file(buf
, size
, typename(type
), obj_list
[nr
].oid
.hash
) < 0)
241 die("failed to write object");
242 added_object(nr
, type
, buf
, size
);
244 obj_list
[nr
].obj
= NULL
;
245 } else if (type
== OBJ_BLOB
) {
247 if (write_sha1_file(buf
, size
, typename(type
), obj_list
[nr
].oid
.hash
) < 0)
248 die("failed to write object");
249 added_object(nr
, type
, buf
, size
);
252 blob
= lookup_blob(&obj_list
[nr
].oid
);
254 blob
->object
.flags
|= FLAG_WRITTEN
;
256 die("invalid blob object");
257 obj_list
[nr
].obj
= NULL
;
261 hash_sha1_file(buf
, size
, typename(type
), obj_list
[nr
].oid
.hash
);
262 added_object(nr
, type
, buf
, size
);
263 obj
= parse_object_buffer(&obj_list
[nr
].oid
, type
, size
, buf
,
266 die("invalid %s", typename(type
));
267 add_object_buffer(obj
, buf
, size
);
268 obj
->flags
|= FLAG_OPEN
;
269 obj_list
[nr
].obj
= obj
;
273 static void resolve_delta(unsigned nr
, enum object_type type
,
274 void *base
, unsigned long base_size
,
275 void *delta
, unsigned long delta_size
)
278 unsigned long result_size
;
280 result
= patch_delta(base
, base_size
,
284 die("failed to apply delta");
286 write_object(nr
, type
, result
, result_size
);
290 * We now know the contents of an object (which is nr-th in the pack);
291 * resolve all the deltified objects that are based on it.
293 static void added_object(unsigned nr
, enum object_type type
,
294 void *data
, unsigned long size
)
296 struct delta_info
**p
= &delta_list
;
297 struct delta_info
*info
;
299 while ((info
= *p
) != NULL
) {
300 if (!oidcmp(&info
->base_oid
, &obj_list
[nr
].oid
) ||
301 info
->base_offset
== obj_list
[nr
].offset
) {
304 resolve_delta(info
->nr
, type
, data
, size
,
305 info
->delta
, info
->size
);
313 static void unpack_non_delta_entry(enum object_type type
, unsigned long size
,
316 void *buf
= get_data(size
);
319 write_object(nr
, type
, buf
, size
);
324 static int resolve_against_held(unsigned nr
, const struct object_id
*base
,
325 void *delta_data
, unsigned long delta_size
)
328 struct obj_buffer
*obj_buffer
;
329 obj
= lookup_object(base
->hash
);
332 obj_buffer
= lookup_object_buffer(obj
);
335 resolve_delta(nr
, obj
->type
, obj_buffer
->buffer
,
336 obj_buffer
->size
, delta_data
, delta_size
);
340 static void unpack_delta_entry(enum object_type type
, unsigned long delta_size
,
343 void *delta_data
, *base
;
344 unsigned long base_size
;
345 struct object_id base_oid
;
347 if (type
== OBJ_REF_DELTA
) {
348 hashcpy(base_oid
.hash
, fill(GIT_SHA1_RAWSZ
));
350 delta_data
= get_data(delta_size
);
351 if (dry_run
|| !delta_data
) {
355 if (has_object_file(&base_oid
))
356 ; /* Ok we have this one */
357 else if (resolve_against_held(nr
, &base_oid
,
358 delta_data
, delta_size
))
359 return; /* we are done */
361 /* cannot resolve yet --- queue it */
362 oidclr(&obj_list
[nr
].oid
);
363 add_delta_to_list(nr
, &base_oid
, 0, delta_data
, delta_size
);
367 unsigned base_found
= 0;
368 unsigned char *pack
, c
;
370 unsigned lo
, mid
, hi
;
375 base_offset
= c
& 127;
378 if (!base_offset
|| MSB(base_offset
, 7))
379 die("offset value overflow for delta base object");
383 base_offset
= (base_offset
<< 7) + (c
& 127);
385 base_offset
= obj_list
[nr
].offset
- base_offset
;
386 if (base_offset
<= 0 || base_offset
>= obj_list
[nr
].offset
)
387 die("offset value out of bound for delta base object");
389 delta_data
= get_data(delta_size
);
390 if (dry_run
|| !delta_data
) {
398 if (base_offset
< obj_list
[mid
].offset
) {
400 } else if (base_offset
> obj_list
[mid
].offset
) {
403 oidcpy(&base_oid
, &obj_list
[mid
].oid
);
404 base_found
= !is_null_oid(&base_oid
);
410 * The delta base object is itself a delta that
411 * has not been resolved yet.
413 oidclr(&obj_list
[nr
].oid
);
414 add_delta_to_list(nr
, &null_oid
, base_offset
, delta_data
, delta_size
);
419 if (resolve_against_held(nr
, &base_oid
, delta_data
, delta_size
))
422 base
= read_sha1_file(base_oid
.hash
, &type
, &base_size
);
424 error("failed to read delta-pack base object %s",
425 oid_to_hex(&base_oid
));
431 resolve_delta(nr
, type
, base
, base_size
, delta_data
, delta_size
);
435 static void unpack_one(unsigned nr
)
439 unsigned long size
, c
;
440 enum object_type type
;
442 obj_list
[nr
].offset
= consumed_bytes
;
454 size
+= (c
& 0x7f) << shift
;
463 unpack_non_delta_entry(type
, size
, nr
);
467 unpack_delta_entry(type
, size
, nr
);
470 error("bad object type %d", type
);
478 static void unpack_all(void)
481 struct progress
*progress
= NULL
;
482 struct pack_header
*hdr
= fill(sizeof(struct pack_header
));
484 nr_objects
= ntohl(hdr
->hdr_entries
);
486 if (ntohl(hdr
->hdr_signature
) != PACK_SIGNATURE
)
487 die("bad pack file");
488 if (!pack_version_ok(hdr
->hdr_version
))
489 die("unknown pack file version %"PRIu32
,
490 ntohl(hdr
->hdr_version
));
491 use(sizeof(struct pack_header
));
494 progress
= start_progress(_("Unpacking objects"), nr_objects
);
495 obj_list
= xcalloc(nr_objects
, sizeof(*obj_list
));
496 for (i
= 0; i
< nr_objects
; i
++) {
498 display_progress(progress
, i
+ 1);
500 stop_progress(&progress
);
503 die("unresolved deltas left after unpacking");
506 int cmd_unpack_objects(int argc
, const char **argv
, const char *prefix
)
509 struct object_id oid
;
511 check_replace_refs
= 0;
513 git_config(git_default_config
, NULL
);
517 for (i
= 1 ; i
< argc
; i
++) {
518 const char *arg
= argv
[i
];
521 if (!strcmp(arg
, "-n")) {
525 if (!strcmp(arg
, "-q")) {
529 if (!strcmp(arg
, "-r")) {
533 if (!strcmp(arg
, "--strict")) {
537 if (skip_prefix(arg
, "--strict=", &arg
)) {
539 fsck_set_msg_types(&fsck_options
, arg
);
542 if (starts_with(arg
, "--pack_header=")) {
543 struct pack_header
*hdr
;
546 hdr
= (struct pack_header
*)buffer
;
547 hdr
->hdr_signature
= htonl(PACK_SIGNATURE
);
548 hdr
->hdr_version
= htonl(strtoul(arg
+ 14, &c
, 10));
551 hdr
->hdr_entries
= htonl(strtoul(c
+ 1, &c
, 10));
557 if (skip_prefix(arg
, "--max-input-size=", &arg
)) {
558 max_input_size
= strtoumax(arg
, NULL
, 10);
564 /* We don't take any non-flag arguments now.. Maybe some day */
569 git_SHA1_Update(&ctx
, buffer
, offset
);
570 git_SHA1_Final(oid
.hash
, &ctx
);
573 if (hashcmp(fill(GIT_SHA1_RAWSZ
), oid
.hash
))
574 die("final sha1 did not match");
577 /* Write the last part of the buffer to stdout */
579 int ret
= xwrite(1, buffer
+ offset
, len
);