2 * Copyright (c) 2006 Rene Scharfe
10 #include "xdiff-interface.h"
15 /* We only care about the "buf" part here. */
16 static struct strbuf zip_dir
;
18 static uintmax_t zip_offset
;
19 static uint64_t zip_dir_entries
;
21 static unsigned int max_creator_version
;
23 #define ZIP_STREAM (1 << 3)
24 #define ZIP_UTF8 (1 << 11)
26 struct zip_local_header
{
27 unsigned char magic
[4];
28 unsigned char version
[2];
29 unsigned char flags
[2];
30 unsigned char compression_method
[2];
31 unsigned char mtime
[2];
32 unsigned char mdate
[2];
33 unsigned char crc32
[4];
34 unsigned char compressed_size
[4];
35 unsigned char size
[4];
36 unsigned char filename_length
[2];
37 unsigned char extra_length
[2];
38 unsigned char _end
[1];
41 struct zip_data_desc
{
42 unsigned char magic
[4];
43 unsigned char crc32
[4];
44 unsigned char compressed_size
[4];
45 unsigned char size
[4];
46 unsigned char _end
[1];
49 struct zip64_data_desc
{
50 unsigned char magic
[4];
51 unsigned char crc32
[4];
52 unsigned char compressed_size
[8];
53 unsigned char size
[8];
54 unsigned char _end
[1];
57 struct zip_dir_trailer
{
58 unsigned char magic
[4];
59 unsigned char disk
[2];
60 unsigned char directory_start_disk
[2];
61 unsigned char entries_on_this_disk
[2];
62 unsigned char entries
[2];
63 unsigned char size
[4];
64 unsigned char offset
[4];
65 unsigned char comment_length
[2];
66 unsigned char _end
[1];
69 struct zip_extra_mtime
{
70 unsigned char magic
[2];
71 unsigned char extra_size
[2];
72 unsigned char flags
[1];
73 unsigned char mtime
[4];
74 unsigned char _end
[1];
78 unsigned char magic
[2];
79 unsigned char extra_size
[2];
80 unsigned char size
[8];
81 unsigned char compressed_size
[8];
82 unsigned char _end
[1];
85 struct zip64_dir_trailer
{
86 unsigned char magic
[4];
87 unsigned char record_size
[8];
88 unsigned char creator_version
[2];
89 unsigned char version
[2];
90 unsigned char disk
[4];
91 unsigned char directory_start_disk
[4];
92 unsigned char entries_on_this_disk
[8];
93 unsigned char entries
[8];
94 unsigned char size
[8];
95 unsigned char offset
[8];
96 unsigned char _end
[1];
99 struct zip64_dir_trailer_locator
{
100 unsigned char magic
[4];
101 unsigned char disk
[4];
102 unsigned char offset
[8];
103 unsigned char number_of_disks
[4];
104 unsigned char _end
[1];
108 * On ARM, padding is added at the end of the struct, so a simple
109 * sizeof(struct ...) reports two bytes more than the payload size
110 * we're interested in.
112 #define ZIP_LOCAL_HEADER_SIZE offsetof(struct zip_local_header, _end)
113 #define ZIP_DATA_DESC_SIZE offsetof(struct zip_data_desc, _end)
114 #define ZIP64_DATA_DESC_SIZE offsetof(struct zip64_data_desc, _end)
115 #define ZIP_DIR_HEADER_SIZE offsetof(struct zip_dir_header, _end)
116 #define ZIP_DIR_TRAILER_SIZE offsetof(struct zip_dir_trailer, _end)
117 #define ZIP_EXTRA_MTIME_SIZE offsetof(struct zip_extra_mtime, _end)
118 #define ZIP_EXTRA_MTIME_PAYLOAD_SIZE \
119 (ZIP_EXTRA_MTIME_SIZE - offsetof(struct zip_extra_mtime, flags))
120 #define ZIP64_EXTRA_SIZE offsetof(struct zip64_extra, _end)
121 #define ZIP64_EXTRA_PAYLOAD_SIZE \
122 (ZIP64_EXTRA_SIZE - offsetof(struct zip64_extra, size))
123 #define ZIP64_DIR_TRAILER_SIZE offsetof(struct zip64_dir_trailer, _end)
124 #define ZIP64_DIR_TRAILER_RECORD_SIZE \
125 (ZIP64_DIR_TRAILER_SIZE - \
126 offsetof(struct zip64_dir_trailer, creator_version))
127 #define ZIP64_DIR_TRAILER_LOCATOR_SIZE \
128 offsetof(struct zip64_dir_trailer_locator, _end)
130 static void copy_le16(unsigned char *dest
, unsigned int n
)
133 dest
[1] = 0xff & (n
>> 010);
136 static void copy_le32(unsigned char *dest
, unsigned int n
)
139 dest
[1] = 0xff & (n
>> 010);
140 dest
[2] = 0xff & (n
>> 020);
141 dest
[3] = 0xff & (n
>> 030);
144 static void copy_le64(unsigned char *dest
, uint64_t n
)
147 dest
[1] = 0xff & (n
>> 010);
148 dest
[2] = 0xff & (n
>> 020);
149 dest
[3] = 0xff & (n
>> 030);
150 dest
[4] = 0xff & (n
>> 040);
151 dest
[5] = 0xff & (n
>> 050);
152 dest
[6] = 0xff & (n
>> 060);
153 dest
[7] = 0xff & (n
>> 070);
156 static uint64_t clamp_max(uint64_t n
, uint64_t max
, int *clamped
)
164 static void copy_le16_clamp(unsigned char *dest
, uint64_t n
, int *clamped
)
166 copy_le16(dest
, clamp_max(n
, 0xffff, clamped
));
169 static void copy_le32_clamp(unsigned char *dest
, uint64_t n
, int *clamped
)
171 copy_le32(dest
, clamp_max(n
, 0xffffffff, clamped
));
174 static int strbuf_add_le(struct strbuf
*sb
, size_t size
, uintmax_t n
)
177 strbuf_addch(sb
, n
& 0xff);
183 static uint32_t clamp32(uintmax_t n
)
185 const uintmax_t max
= 0xffffffff;
186 return (n
< max
) ? n
: max
;
189 static void *zlib_deflate_raw(void *data
, unsigned long size
,
190 int compression_level
,
191 unsigned long *compressed_size
)
194 unsigned long maxsize
;
198 git_deflate_init_raw(&stream
, compression_level
);
199 maxsize
= git_deflate_bound(&stream
, size
);
200 buffer
= xmalloc(maxsize
);
202 stream
.next_in
= data
;
203 stream
.avail_in
= size
;
204 stream
.next_out
= buffer
;
205 stream
.avail_out
= maxsize
;
208 result
= git_deflate(&stream
, Z_FINISH
);
209 } while (result
== Z_OK
);
211 if (result
!= Z_STREAM_END
) {
216 git_deflate_end(&stream
);
217 *compressed_size
= stream
.total_out
;
222 static void write_zip_data_desc(unsigned long size
,
223 unsigned long compressed_size
,
226 if (size
>= 0xffffffff || compressed_size
>= 0xffffffff) {
227 struct zip64_data_desc trailer
;
228 copy_le32(trailer
.magic
, 0x08074b50);
229 copy_le32(trailer
.crc32
, crc
);
230 copy_le64(trailer
.compressed_size
, compressed_size
);
231 copy_le64(trailer
.size
, size
);
232 write_or_die(1, &trailer
, ZIP64_DATA_DESC_SIZE
);
233 zip_offset
+= ZIP64_DATA_DESC_SIZE
;
235 struct zip_data_desc trailer
;
236 copy_le32(trailer
.magic
, 0x08074b50);
237 copy_le32(trailer
.crc32
, crc
);
238 copy_le32(trailer
.compressed_size
, compressed_size
);
239 copy_le32(trailer
.size
, size
);
240 write_or_die(1, &trailer
, ZIP_DATA_DESC_SIZE
);
241 zip_offset
+= ZIP_DATA_DESC_SIZE
;
245 static void set_zip_header_data_desc(struct zip_local_header
*header
,
247 unsigned long compressed_size
,
250 copy_le32(header
->crc32
, crc
);
251 copy_le32(header
->compressed_size
, compressed_size
);
252 copy_le32(header
->size
, size
);
255 static int has_only_ascii(const char *s
)
266 static int entry_is_binary(const char *path
, const void *buffer
, size_t size
)
268 struct userdiff_driver
*driver
= userdiff_find_by_path(path
);
270 driver
= userdiff_find_by_name("default");
271 if (driver
->binary
!= -1)
272 return driver
->binary
;
273 return buffer_is_binary(buffer
, size
);
276 #define STREAM_BUFFER_SIZE (1024 * 16)
278 static int write_zip_entry(struct archiver_args
*args
,
279 const struct object_id
*oid
,
280 const char *path
, size_t pathlen
,
283 struct zip_local_header header
;
284 uintmax_t offset
= zip_offset
;
285 struct zip_extra_mtime extra
;
286 struct zip64_extra extra64
;
287 size_t header_extra_size
= ZIP_EXTRA_MTIME_SIZE
;
288 int need_zip64_extra
= 0;
290 unsigned long compressed_size
;
294 void *deflated
= NULL
;
296 struct git_istream
*stream
= NULL
;
297 unsigned long flags
= 0;
300 const char *path_without_prefix
= path
+ args
->baselen
;
301 unsigned int creator_version
= 0;
302 unsigned int version_needed
= 10;
303 size_t zip_dir_extra_size
= ZIP_EXTRA_MTIME_SIZE
;
304 size_t zip64_dir_extra_payload_size
= 0;
306 crc
= crc32(0, NULL
, 0);
308 if (!has_only_ascii(path
)) {
312 warning("Path is not valid UTF-8: %s", path
);
315 if (pathlen
> 0xffff) {
316 return error("path too long (%d chars, SHA1: %s): %s",
317 (int)pathlen
, oid_to_hex(oid
), path
);
320 if (S_ISDIR(mode
) || S_ISGITLINK(mode
)) {
327 } else if (S_ISREG(mode
) || S_ISLNK(mode
)) {
328 enum object_type type
= oid_object_info(the_repository
, oid
,
332 attr2
= S_ISLNK(mode
) ? ((mode
| 0777) << 16) :
333 (mode
& 0111) ? ((mode
) << 16) : 0;
334 if (S_ISLNK(mode
) || (mode
& 0111))
335 creator_version
= 0x0317;
336 if (S_ISREG(mode
) && args
->compression_level
!= 0 && size
> 0)
339 if (S_ISREG(mode
) && type
== OBJ_BLOB
&& !args
->convert
&&
340 size
> big_file_threshold
) {
341 stream
= open_istream(oid
, &type
, &size
, NULL
);
343 return error("cannot stream blob %s",
348 buffer
= object_file_to_archive(args
, path
, oid
, mode
,
351 return error("cannot read %s",
353 crc
= crc32(crc
, buffer
, size
);
354 is_binary
= entry_is_binary(path_without_prefix
,
358 compressed_size
= (method
== 0) ? size
: 0;
360 return error("unsupported file mode: 0%o (SHA1: %s)", mode
,
364 if (creator_version
> max_creator_version
)
365 max_creator_version
= creator_version
;
367 if (buffer
&& method
== 8) {
368 out
= deflated
= zlib_deflate_raw(buffer
, size
,
369 args
->compression_level
,
371 if (!out
|| compressed_size
>= size
) {
374 compressed_size
= size
;
378 copy_le16(extra
.magic
, 0x5455);
379 copy_le16(extra
.extra_size
, ZIP_EXTRA_MTIME_PAYLOAD_SIZE
);
380 extra
.flags
[0] = 1; /* just mtime */
381 copy_le32(extra
.mtime
, args
->time
);
383 if (size
> 0xffffffff || compressed_size
> 0xffffffff)
384 need_zip64_extra
= 1;
385 if (stream
&& size
> 0x7fffffff)
386 need_zip64_extra
= 1;
388 if (need_zip64_extra
)
391 copy_le32(header
.magic
, 0x04034b50);
392 copy_le16(header
.version
, version_needed
);
393 copy_le16(header
.flags
, flags
);
394 copy_le16(header
.compression_method
, method
);
395 copy_le16(header
.mtime
, zip_time
);
396 copy_le16(header
.mdate
, zip_date
);
397 if (need_zip64_extra
) {
398 set_zip_header_data_desc(&header
, 0xffffffff, 0xffffffff, crc
);
399 header_extra_size
+= ZIP64_EXTRA_SIZE
;
401 set_zip_header_data_desc(&header
, size
, compressed_size
, crc
);
403 copy_le16(header
.filename_length
, pathlen
);
404 copy_le16(header
.extra_length
, header_extra_size
);
405 write_or_die(1, &header
, ZIP_LOCAL_HEADER_SIZE
);
406 zip_offset
+= ZIP_LOCAL_HEADER_SIZE
;
407 write_or_die(1, path
, pathlen
);
408 zip_offset
+= pathlen
;
409 write_or_die(1, &extra
, ZIP_EXTRA_MTIME_SIZE
);
410 zip_offset
+= ZIP_EXTRA_MTIME_SIZE
;
411 if (need_zip64_extra
) {
412 copy_le16(extra64
.magic
, 0x0001);
413 copy_le16(extra64
.extra_size
, ZIP64_EXTRA_PAYLOAD_SIZE
);
414 copy_le64(extra64
.size
, size
);
415 copy_le64(extra64
.compressed_size
, compressed_size
);
416 write_or_die(1, &extra64
, ZIP64_EXTRA_SIZE
);
417 zip_offset
+= ZIP64_EXTRA_SIZE
;
420 if (stream
&& method
== 0) {
421 unsigned char buf
[STREAM_BUFFER_SIZE
];
425 readlen
= read_istream(stream
, buf
, sizeof(buf
));
428 crc
= crc32(crc
, buf
, readlen
);
430 is_binary
= entry_is_binary(path_without_prefix
,
432 write_or_die(1, buf
, readlen
);
434 close_istream(stream
);
438 compressed_size
= size
;
439 zip_offset
+= compressed_size
;
441 write_zip_data_desc(size
, compressed_size
, crc
);
442 } else if (stream
&& method
== 8) {
443 unsigned char buf
[STREAM_BUFFER_SIZE
];
448 unsigned char compressed
[STREAM_BUFFER_SIZE
* 2];
450 git_deflate_init_raw(&zstream
, args
->compression_level
);
453 zstream
.next_out
= compressed
;
454 zstream
.avail_out
= sizeof(compressed
);
457 readlen
= read_istream(stream
, buf
, sizeof(buf
));
460 crc
= crc32(crc
, buf
, readlen
);
462 is_binary
= entry_is_binary(path_without_prefix
,
465 zstream
.next_in
= buf
;
466 zstream
.avail_in
= readlen
;
467 result
= git_deflate(&zstream
, 0);
469 die("deflate error (%d)", result
);
470 out_len
= zstream
.next_out
- compressed
;
473 write_or_die(1, compressed
, out_len
);
474 compressed_size
+= out_len
;
475 zstream
.next_out
= compressed
;
476 zstream
.avail_out
= sizeof(compressed
);
480 close_istream(stream
);
484 zstream
.next_in
= buf
;
485 zstream
.avail_in
= 0;
486 result
= git_deflate(&zstream
, Z_FINISH
);
487 if (result
!= Z_STREAM_END
)
488 die("deflate error (%d)", result
);
490 git_deflate_end(&zstream
);
491 out_len
= zstream
.next_out
- compressed
;
492 write_or_die(1, compressed
, out_len
);
493 compressed_size
+= out_len
;
494 zip_offset
+= compressed_size
;
496 write_zip_data_desc(size
, compressed_size
, crc
);
497 } else if (compressed_size
> 0) {
498 write_or_die(1, out
, compressed_size
);
499 zip_offset
+= compressed_size
;
505 if (compressed_size
> 0xffffffff || size
> 0xffffffff ||
506 offset
> 0xffffffff) {
507 if (compressed_size
>= 0xffffffff)
508 zip64_dir_extra_payload_size
+= 8;
509 if (size
>= 0xffffffff)
510 zip64_dir_extra_payload_size
+= 8;
511 if (offset
>= 0xffffffff)
512 zip64_dir_extra_payload_size
+= 8;
513 zip_dir_extra_size
+= 2 + 2 + zip64_dir_extra_payload_size
;
516 strbuf_add_le(&zip_dir
, 4, 0x02014b50); /* magic */
517 strbuf_add_le(&zip_dir
, 2, creator_version
);
518 strbuf_add_le(&zip_dir
, 2, version_needed
);
519 strbuf_add_le(&zip_dir
, 2, flags
);
520 strbuf_add_le(&zip_dir
, 2, method
);
521 strbuf_add_le(&zip_dir
, 2, zip_time
);
522 strbuf_add_le(&zip_dir
, 2, zip_date
);
523 strbuf_add_le(&zip_dir
, 4, crc
);
524 strbuf_add_le(&zip_dir
, 4, clamp32(compressed_size
));
525 strbuf_add_le(&zip_dir
, 4, clamp32(size
));
526 strbuf_add_le(&zip_dir
, 2, pathlen
);
527 strbuf_add_le(&zip_dir
, 2, zip_dir_extra_size
);
528 strbuf_add_le(&zip_dir
, 2, 0); /* comment length */
529 strbuf_add_le(&zip_dir
, 2, 0); /* disk */
530 strbuf_add_le(&zip_dir
, 2, !is_binary
);
531 strbuf_add_le(&zip_dir
, 4, attr2
);
532 strbuf_add_le(&zip_dir
, 4, clamp32(offset
));
533 strbuf_add(&zip_dir
, path
, pathlen
);
534 strbuf_add(&zip_dir
, &extra
, ZIP_EXTRA_MTIME_SIZE
);
535 if (zip64_dir_extra_payload_size
) {
536 strbuf_add_le(&zip_dir
, 2, 0x0001); /* magic */
537 strbuf_add_le(&zip_dir
, 2, zip64_dir_extra_payload_size
);
538 if (size
>= 0xffffffff)
539 strbuf_add_le(&zip_dir
, 8, size
);
540 if (compressed_size
>= 0xffffffff)
541 strbuf_add_le(&zip_dir
, 8, compressed_size
);
542 if (offset
>= 0xffffffff)
543 strbuf_add_le(&zip_dir
, 8, offset
);
550 static void write_zip64_trailer(void)
552 struct zip64_dir_trailer trailer64
;
553 struct zip64_dir_trailer_locator locator64
;
555 copy_le32(trailer64
.magic
, 0x06064b50);
556 copy_le64(trailer64
.record_size
, ZIP64_DIR_TRAILER_RECORD_SIZE
);
557 copy_le16(trailer64
.creator_version
, max_creator_version
);
558 copy_le16(trailer64
.version
, 45);
559 copy_le32(trailer64
.disk
, 0);
560 copy_le32(trailer64
.directory_start_disk
, 0);
561 copy_le64(trailer64
.entries_on_this_disk
, zip_dir_entries
);
562 copy_le64(trailer64
.entries
, zip_dir_entries
);
563 copy_le64(trailer64
.size
, zip_dir
.len
);
564 copy_le64(trailer64
.offset
, zip_offset
);
566 copy_le32(locator64
.magic
, 0x07064b50);
567 copy_le32(locator64
.disk
, 0);
568 copy_le64(locator64
.offset
, zip_offset
+ zip_dir
.len
);
569 copy_le32(locator64
.number_of_disks
, 1);
571 write_or_die(1, &trailer64
, ZIP64_DIR_TRAILER_SIZE
);
572 write_or_die(1, &locator64
, ZIP64_DIR_TRAILER_LOCATOR_SIZE
);
575 static void write_zip_trailer(const unsigned char *sha1
)
577 struct zip_dir_trailer trailer
;
580 copy_le32(trailer
.magic
, 0x06054b50);
581 copy_le16(trailer
.disk
, 0);
582 copy_le16(trailer
.directory_start_disk
, 0);
583 copy_le16_clamp(trailer
.entries_on_this_disk
, zip_dir_entries
,
585 copy_le16_clamp(trailer
.entries
, zip_dir_entries
, &clamped
);
586 copy_le32(trailer
.size
, zip_dir
.len
);
587 copy_le32_clamp(trailer
.offset
, zip_offset
, &clamped
);
588 copy_le16(trailer
.comment_length
, sha1
? GIT_SHA1_HEXSZ
: 0);
590 write_or_die(1, zip_dir
.buf
, zip_dir
.len
);
592 write_zip64_trailer();
593 write_or_die(1, &trailer
, ZIP_DIR_TRAILER_SIZE
);
595 write_or_die(1, sha1_to_hex(sha1
), GIT_SHA1_HEXSZ
);
598 static void dos_time(timestamp_t
*timestamp
, int *dos_date
, int *dos_time
)
603 if (date_overflows(*timestamp
))
604 die("timestamp too large for this system: %"PRItime
,
606 time
= (time_t)*timestamp
;
607 t
= localtime(&time
);
610 *dos_date
= t
->tm_mday
+ (t
->tm_mon
+ 1) * 32 +
611 (t
->tm_year
+ 1900 - 1980) * 512;
612 *dos_time
= t
->tm_sec
/ 2 + t
->tm_min
* 32 + t
->tm_hour
* 2048;
615 static int archive_zip_config(const char *var
, const char *value
, void *data
)
617 return userdiff_config(var
, value
);
620 static int write_zip_archive(const struct archiver
*ar
,
621 struct archiver_args
*args
)
625 git_config(archive_zip_config
, NULL
);
627 dos_time(&args
->time
, &zip_date
, &zip_time
);
629 strbuf_init(&zip_dir
, 0);
631 err
= write_archive_entries(args
, write_zip_entry
);
633 write_zip_trailer(args
->commit_sha1
);
635 strbuf_release(&zip_dir
);
640 static struct archiver zip_archiver
= {
643 ARCHIVER_WANT_COMPRESSION_LEVELS
|ARCHIVER_REMOTE
646 void init_zip_archiver(void)
648 register_archiver(&zip_archiver
);