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 /* Remember to update object flag allocation in object.h */
162 #define FLAG_OPEN (1u<<20)
163 #define FLAG_WRITTEN (1u<<21)
165 static struct obj_info
*obj_list
;
166 static unsigned nr_objects
;
169 * Called only from check_object() after it verified this object
172 static void write_cached_object(struct object
*obj
, struct obj_buffer
*obj_buf
)
174 struct object_id oid
;
176 if (write_sha1_file(obj_buf
->buffer
, obj_buf
->size
, typename(obj
->type
), oid
.hash
) < 0)
177 die("failed to write object %s", oid_to_hex(&obj
->oid
));
178 obj
->flags
|= FLAG_WRITTEN
;
182 * At the very end of the processing, write_rest() scans the objects
183 * that have reachability requirements and calls this function.
184 * Verify its reachability and validity recursively and write it out.
186 static int check_object(struct object
*obj
, int type
, void *data
, struct fsck_options
*options
)
188 struct obj_buffer
*obj_buf
;
193 if (obj
->flags
& FLAG_WRITTEN
)
196 if (type
!= OBJ_ANY
&& obj
->type
!= type
)
197 die("object type mismatch");
199 if (!(obj
->flags
& FLAG_OPEN
)) {
201 int type
= sha1_object_info(obj
->oid
.hash
, &size
);
202 if (type
!= obj
->type
|| type
<= 0)
203 die("object of unexpected type");
204 obj
->flags
|= FLAG_WRITTEN
;
208 obj_buf
= lookup_object_buffer(obj
);
210 die("Whoops! Cannot find object '%s'", oid_to_hex(&obj
->oid
));
211 if (fsck_object(obj
, obj_buf
->buffer
, obj_buf
->size
, &fsck_options
))
212 die("Error in object");
213 fsck_options
.walk
= check_object
;
214 if (fsck_walk(obj
, NULL
, &fsck_options
))
215 die("Error on reachable objects of %s", oid_to_hex(&obj
->oid
));
216 write_cached_object(obj
, obj_buf
);
220 static void write_rest(void)
223 for (i
= 0; i
< nr_objects
; i
++) {
225 check_object(obj_list
[i
].obj
, OBJ_ANY
, NULL
, NULL
);
229 static void added_object(unsigned nr
, enum object_type type
,
230 void *data
, unsigned long size
);
233 * Write out nr-th object from the list, now we know the contents
234 * of it. Under --strict, this buffers structured objects in-core,
235 * to be checked at the end.
237 static void write_object(unsigned nr
, enum object_type type
,
238 void *buf
, unsigned long size
)
241 if (write_sha1_file(buf
, size
, typename(type
), obj_list
[nr
].oid
.hash
) < 0)
242 die("failed to write object");
243 added_object(nr
, type
, buf
, size
);
245 obj_list
[nr
].obj
= NULL
;
246 } else if (type
== OBJ_BLOB
) {
248 if (write_sha1_file(buf
, size
, typename(type
), obj_list
[nr
].oid
.hash
) < 0)
249 die("failed to write object");
250 added_object(nr
, type
, buf
, size
);
253 blob
= lookup_blob(&obj_list
[nr
].oid
);
255 blob
->object
.flags
|= FLAG_WRITTEN
;
257 die("invalid blob object");
258 obj_list
[nr
].obj
= NULL
;
262 hash_sha1_file(buf
, size
, typename(type
), obj_list
[nr
].oid
.hash
);
263 added_object(nr
, type
, buf
, size
);
264 obj
= parse_object_buffer(&obj_list
[nr
].oid
, type
, size
, buf
,
267 die("invalid %s", typename(type
));
268 add_object_buffer(obj
, buf
, size
);
269 obj
->flags
|= FLAG_OPEN
;
270 obj_list
[nr
].obj
= obj
;
274 static void resolve_delta(unsigned nr
, enum object_type type
,
275 void *base
, unsigned long base_size
,
276 void *delta
, unsigned long delta_size
)
279 unsigned long result_size
;
281 result
= patch_delta(base
, base_size
,
285 die("failed to apply delta");
287 write_object(nr
, type
, result
, result_size
);
291 * We now know the contents of an object (which is nr-th in the pack);
292 * resolve all the deltified objects that are based on it.
294 static void added_object(unsigned nr
, enum object_type type
,
295 void *data
, unsigned long size
)
297 struct delta_info
**p
= &delta_list
;
298 struct delta_info
*info
;
300 while ((info
= *p
) != NULL
) {
301 if (!oidcmp(&info
->base_oid
, &obj_list
[nr
].oid
) ||
302 info
->base_offset
== obj_list
[nr
].offset
) {
305 resolve_delta(info
->nr
, type
, data
, size
,
306 info
->delta
, info
->size
);
314 static void unpack_non_delta_entry(enum object_type type
, unsigned long size
,
317 void *buf
= get_data(size
);
320 write_object(nr
, type
, buf
, size
);
325 static int resolve_against_held(unsigned nr
, const struct object_id
*base
,
326 void *delta_data
, unsigned long delta_size
)
329 struct obj_buffer
*obj_buffer
;
330 obj
= lookup_object(base
->hash
);
333 obj_buffer
= lookup_object_buffer(obj
);
336 resolve_delta(nr
, obj
->type
, obj_buffer
->buffer
,
337 obj_buffer
->size
, delta_data
, delta_size
);
341 static void unpack_delta_entry(enum object_type type
, unsigned long delta_size
,
344 void *delta_data
, *base
;
345 unsigned long base_size
;
346 struct object_id base_oid
;
348 if (type
== OBJ_REF_DELTA
) {
349 hashcpy(base_oid
.hash
, fill(GIT_SHA1_RAWSZ
));
351 delta_data
= get_data(delta_size
);
352 if (dry_run
|| !delta_data
) {
356 if (has_object_file(&base_oid
))
357 ; /* Ok we have this one */
358 else if (resolve_against_held(nr
, &base_oid
,
359 delta_data
, delta_size
))
360 return; /* we are done */
362 /* cannot resolve yet --- queue it */
363 oidclr(&obj_list
[nr
].oid
);
364 add_delta_to_list(nr
, &base_oid
, 0, delta_data
, delta_size
);
368 unsigned base_found
= 0;
369 unsigned char *pack
, c
;
371 unsigned lo
, mid
, hi
;
376 base_offset
= c
& 127;
379 if (!base_offset
|| MSB(base_offset
, 7))
380 die("offset value overflow for delta base object");
384 base_offset
= (base_offset
<< 7) + (c
& 127);
386 base_offset
= obj_list
[nr
].offset
- base_offset
;
387 if (base_offset
<= 0 || base_offset
>= obj_list
[nr
].offset
)
388 die("offset value out of bound for delta base object");
390 delta_data
= get_data(delta_size
);
391 if (dry_run
|| !delta_data
) {
398 mid
= lo
+ (hi
- lo
) / 2;
399 if (base_offset
< obj_list
[mid
].offset
) {
401 } else if (base_offset
> obj_list
[mid
].offset
) {
404 oidcpy(&base_oid
, &obj_list
[mid
].oid
);
405 base_found
= !is_null_oid(&base_oid
);
411 * The delta base object is itself a delta that
412 * has not been resolved yet.
414 oidclr(&obj_list
[nr
].oid
);
415 add_delta_to_list(nr
, &null_oid
, base_offset
, delta_data
, delta_size
);
420 if (resolve_against_held(nr
, &base_oid
, delta_data
, delta_size
))
423 base
= read_sha1_file(base_oid
.hash
, &type
, &base_size
);
425 error("failed to read delta-pack base object %s",
426 oid_to_hex(&base_oid
));
432 resolve_delta(nr
, type
, base
, base_size
, delta_data
, delta_size
);
436 static void unpack_one(unsigned nr
)
440 unsigned long size
, c
;
441 enum object_type type
;
443 obj_list
[nr
].offset
= consumed_bytes
;
455 size
+= (c
& 0x7f) << shift
;
464 unpack_non_delta_entry(type
, size
, nr
);
468 unpack_delta_entry(type
, size
, nr
);
471 error("bad object type %d", type
);
479 static void unpack_all(void)
482 struct progress
*progress
= NULL
;
483 struct pack_header
*hdr
= fill(sizeof(struct pack_header
));
485 nr_objects
= ntohl(hdr
->hdr_entries
);
487 if (ntohl(hdr
->hdr_signature
) != PACK_SIGNATURE
)
488 die("bad pack file");
489 if (!pack_version_ok(hdr
->hdr_version
))
490 die("unknown pack file version %"PRIu32
,
491 ntohl(hdr
->hdr_version
));
492 use(sizeof(struct pack_header
));
495 progress
= start_progress(_("Unpacking objects"), nr_objects
);
496 obj_list
= xcalloc(nr_objects
, sizeof(*obj_list
));
497 for (i
= 0; i
< nr_objects
; i
++) {
499 display_progress(progress
, i
+ 1);
501 stop_progress(&progress
);
504 die("unresolved deltas left after unpacking");
507 int cmd_unpack_objects(int argc
, const char **argv
, const char *prefix
)
510 struct object_id oid
;
512 check_replace_refs
= 0;
514 git_config(git_default_config
, NULL
);
518 for (i
= 1 ; i
< argc
; i
++) {
519 const char *arg
= argv
[i
];
522 if (!strcmp(arg
, "-n")) {
526 if (!strcmp(arg
, "-q")) {
530 if (!strcmp(arg
, "-r")) {
534 if (!strcmp(arg
, "--strict")) {
538 if (skip_prefix(arg
, "--strict=", &arg
)) {
540 fsck_set_msg_types(&fsck_options
, arg
);
543 if (starts_with(arg
, "--pack_header=")) {
544 struct pack_header
*hdr
;
547 hdr
= (struct pack_header
*)buffer
;
548 hdr
->hdr_signature
= htonl(PACK_SIGNATURE
);
549 hdr
->hdr_version
= htonl(strtoul(arg
+ 14, &c
, 10));
552 hdr
->hdr_entries
= htonl(strtoul(c
+ 1, &c
, 10));
558 if (skip_prefix(arg
, "--max-input-size=", &arg
)) {
559 max_input_size
= strtoumax(arg
, NULL
, 10);
565 /* We don't take any non-flag arguments now.. Maybe some day */
570 git_SHA1_Update(&ctx
, buffer
, offset
);
571 git_SHA1_Final(oid
.hash
, &ctx
);
574 if (hashcmp(fill(GIT_SHA1_RAWSZ
), oid
.hash
))
575 die("final sha1 did not match");
578 /* Write the last part of the buffer to stdout */
580 int ret
= xwrite(1, buffer
+ offset
, len
);