archive-zip.c 12.4 KB
Newer Older
Rene Scharfe's avatar
Rene Scharfe committed
1 2 3 4
/*
 * Copyright (c) 2006 Rene Scharfe
 */
#include "cache.h"
5
#include "archive.h"
6
#include "streaming.h"
7
#include "utf8.h"
Rene Scharfe's avatar
Rene Scharfe committed
8 9 10 11 12 13 14 15 16 17 18 19

static int zip_date;
static int zip_time;

static unsigned char *zip_dir;
static unsigned int zip_dir_size;

static unsigned int zip_offset;
static unsigned int zip_dir_offset;
static unsigned int zip_dir_entries;

#define ZIP_DIRECTORY_MIN_SIZE	(1024 * 1024)
20 21
#define ZIP_STREAM	(1 <<  3)
#define ZIP_UTF8	(1 << 11)
Rene Scharfe's avatar
Rene Scharfe committed
22 23 24 25 26 27 28 29 30 31 32 33 34

struct zip_local_header {
	unsigned char magic[4];
	unsigned char version[2];
	unsigned char flags[2];
	unsigned char compression_method[2];
	unsigned char mtime[2];
	unsigned char mdate[2];
	unsigned char crc32[4];
	unsigned char compressed_size[4];
	unsigned char size[4];
	unsigned char filename_length[2];
	unsigned char extra_length[2];
35
	unsigned char _end[1];
Rene Scharfe's avatar
Rene Scharfe committed
36 37
};

38 39 40 41 42 43 44 45
struct zip_data_desc {
	unsigned char magic[4];
	unsigned char crc32[4];
	unsigned char compressed_size[4];
	unsigned char size[4];
	unsigned char _end[1];
};

Rene Scharfe's avatar
Rene Scharfe committed
46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63
struct zip_dir_header {
	unsigned char magic[4];
	unsigned char creator_version[2];
	unsigned char version[2];
	unsigned char flags[2];
	unsigned char compression_method[2];
	unsigned char mtime[2];
	unsigned char mdate[2];
	unsigned char crc32[4];
	unsigned char compressed_size[4];
	unsigned char size[4];
	unsigned char filename_length[2];
	unsigned char extra_length[2];
	unsigned char comment_length[2];
	unsigned char disk[2];
	unsigned char attr1[2];
	unsigned char attr2[4];
	unsigned char offset[4];
64
	unsigned char _end[1];
Rene Scharfe's avatar
Rene Scharfe committed
65 66 67 68 69 70 71 72 73 74 75
};

struct zip_dir_trailer {
	unsigned char magic[4];
	unsigned char disk[2];
	unsigned char directory_start_disk[2];
	unsigned char entries_on_this_disk[2];
	unsigned char entries[2];
	unsigned char size[4];
	unsigned char offset[4];
	unsigned char comment_length[2];
76
	unsigned char _end[1];
Rene Scharfe's avatar
Rene Scharfe committed
77 78
};

79 80 81 82 83 84 85 86
struct zip_extra_mtime {
	unsigned char magic[2];
	unsigned char extra_size[2];
	unsigned char flags[1];
	unsigned char mtime[4];
	unsigned char _end[1];
};

87 88 89 90 91 92
/*
 * On ARM, padding is added at the end of the struct, so a simple
 * sizeof(struct ...) reports two bytes more than the payload size
 * we're interested in.
 */
#define ZIP_LOCAL_HEADER_SIZE	offsetof(struct zip_local_header, _end)
93
#define ZIP_DATA_DESC_SIZE	offsetof(struct zip_data_desc, _end)
94 95
#define ZIP_DIR_HEADER_SIZE	offsetof(struct zip_dir_header, _end)
#define ZIP_DIR_TRAILER_SIZE	offsetof(struct zip_dir_trailer, _end)
96 97 98
#define ZIP_EXTRA_MTIME_SIZE	offsetof(struct zip_extra_mtime, _end)
#define ZIP_EXTRA_MTIME_PAYLOAD_SIZE \
	(ZIP_EXTRA_MTIME_SIZE - offsetof(struct zip_extra_mtime, flags))
99

Rene Scharfe's avatar
Rene Scharfe committed
100 101 102 103 104 105 106 107 108 109 110 111 112 113 114
static void copy_le16(unsigned char *dest, unsigned int n)
{
	dest[0] = 0xff & n;
	dest[1] = 0xff & (n >> 010);
}

static void copy_le32(unsigned char *dest, unsigned int n)
{
	dest[0] = 0xff & n;
	dest[1] = 0xff & (n >> 010);
	dest[2] = 0xff & (n >> 020);
	dest[3] = 0xff & (n >> 030);
}

static void *zlib_deflate(void *data, unsigned long size,
115
		int compression_level, unsigned long *compressed_size)
Rene Scharfe's avatar
Rene Scharfe committed
116
{
117
	git_zstream stream;
Rene Scharfe's avatar
Rene Scharfe committed
118 119 120 121 122
	unsigned long maxsize;
	void *buffer;
	int result;

	memset(&stream, 0, sizeof(stream));
123
	git_deflate_init(&stream, compression_level);
124
	maxsize = git_deflate_bound(&stream, size);
Rene Scharfe's avatar
Rene Scharfe committed
125 126 127 128 129 130 131 132
	buffer = xmalloc(maxsize);

	stream.next_in = data;
	stream.avail_in = size;
	stream.next_out = buffer;
	stream.avail_out = maxsize;

	do {
133
		result = git_deflate(&stream, Z_FINISH);
Rene Scharfe's avatar
Rene Scharfe committed
134 135 136 137 138 139 140
	} while (result == Z_OK);

	if (result != Z_STREAM_END) {
		free(buffer);
		return NULL;
	}

141
	git_deflate_end(&stream);
Rene Scharfe's avatar
Rene Scharfe committed
142 143 144 145 146
	*compressed_size = stream.total_out;

	return buffer;
}

147 148 149 150 151 152 153 154 155 156 157 158 159
static void write_zip_data_desc(unsigned long size,
				unsigned long compressed_size,
				unsigned long crc)
{
	struct zip_data_desc trailer;

	copy_le32(trailer.magic, 0x08074b50);
	copy_le32(trailer.crc32, crc);
	copy_le32(trailer.compressed_size, compressed_size);
	copy_le32(trailer.size, size);
	write_or_die(1, &trailer, ZIP_DATA_DESC_SIZE);
}

160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179
static void set_zip_dir_data_desc(struct zip_dir_header *header,
				  unsigned long size,
				  unsigned long compressed_size,
				  unsigned long crc)
{
	copy_le32(header->crc32, crc);
	copy_le32(header->compressed_size, compressed_size);
	copy_le32(header->size, size);
}

static void set_zip_header_data_desc(struct zip_local_header *header,
				     unsigned long size,
				     unsigned long compressed_size,
				     unsigned long crc)
{
	copy_le32(header->crc32, crc);
	copy_le32(header->compressed_size, compressed_size);
	copy_le32(header->size, size);
}

180 181 182 183 184 185 186 187 188 189 190
static int has_only_ascii(const char *s)
{
	for (;;) {
		int c = *s++;
		if (c == '\0')
			return 1;
		if (!isascii(c))
			return 0;
	}
}

191 192
#define STREAM_BUFFER_SIZE (1024 * 16)

193
static int write_zip_entry(struct archiver_args *args,
194 195 196
			   const unsigned char *sha1,
			   const char *path, size_t pathlen,
			   unsigned int mode)
Rene Scharfe's avatar
Rene Scharfe committed
197 198 199
{
	struct zip_local_header header;
	struct zip_dir_header dirent;
200
	struct zip_extra_mtime extra;
201
	unsigned long attr2;
Rene Scharfe's avatar
Rene Scharfe committed
202 203 204 205 206 207
	unsigned long compressed_size;
	unsigned long crc;
	unsigned long direntsize;
	int method;
	unsigned char *out;
	void *deflated = NULL;
208
	void *buffer;
209 210
	struct git_istream *stream = NULL;
	unsigned long flags = 0;
211
	unsigned long size;
Rene Scharfe's avatar
Rene Scharfe committed
212

213
	crc = crc32(0, NULL, 0);
Rene Scharfe's avatar
Rene Scharfe committed
214

215 216 217 218 219 220 221
	if (!has_only_ascii(path)) {
		if (is_utf8(path))
			flags |= ZIP_UTF8;
		else
			warning("Path is not valid UTF-8: %s", path);
	}

Rene Scharfe's avatar
Rene Scharfe committed
222
	if (pathlen > 0xffff) {
223 224
		return error("path too long (%d chars, SHA1: %s): %s",
				(int)pathlen, sha1_to_hex(sha1), path);
Rene Scharfe's avatar
Rene Scharfe committed
225 226
	}

227
	if (S_ISDIR(mode) || S_ISGITLINK(mode)) {
Rene Scharfe's avatar
Rene Scharfe committed
228
		method = 0;
229
		attr2 = 16;
Rene Scharfe's avatar
Rene Scharfe committed
230
		out = NULL;
231
		size = 0;
Rene Scharfe's avatar
Rene Scharfe committed
232
		compressed_size = 0;
233 234
		buffer = NULL;
		size = 0;
235
	} else if (S_ISREG(mode) || S_ISLNK(mode)) {
236
		enum object_type type = sha1_object_info(sha1, &size);
237

238
		method = 0;
239 240
		attr2 = S_ISLNK(mode) ? ((mode | 0777) << 16) :
			(mode & 0111) ? ((mode) << 16) : 0;
241
		if (S_ISREG(mode) && args->compression_level != 0 && size > 0)
242
			method = 8;
Rene Scharfe's avatar
Rene Scharfe committed
243
		compressed_size = size;
244 245

		if (S_ISREG(mode) && type == OBJ_BLOB && !args->convert &&
246
		    size > big_file_threshold) {
247 248 249 250 251 252 253 254 255 256 257 258 259 260 261
			stream = open_istream(sha1, &type, &size, NULL);
			if (!stream)
				return error("cannot stream blob %s",
					     sha1_to_hex(sha1));
			flags |= ZIP_STREAM;
			out = buffer = NULL;
		} else {
			buffer = sha1_file_to_archive(args, path, sha1, mode,
						      &type, &size);
			if (!buffer)
				return error("cannot read %s",
					     sha1_to_hex(sha1));
			crc = crc32(crc, buffer, size);
			out = buffer;
		}
Rene Scharfe's avatar
Rene Scharfe committed
262
	} else {
263 264
		return error("unsupported file mode: 0%o (SHA1: %s)", mode,
				sha1_to_hex(sha1));
Rene Scharfe's avatar
Rene Scharfe committed
265 266
	}

267
	if (buffer && method == 8) {
268 269
		deflated = zlib_deflate(buffer, size, args->compression_level,
				&compressed_size);
Rene Scharfe's avatar
Rene Scharfe committed
270 271 272 273 274 275 276 277 278 279 280
		if (deflated && compressed_size - 6 < size) {
			/* ZLIB --> raw compressed data (see RFC 1950) */
			/* CMF and FLG ... */
			out = (unsigned char *)deflated + 2;
			compressed_size -= 6;	/* ... and ADLER32 */
		} else {
			method = 0;
			compressed_size = size;
		}
	}

281 282 283 284 285
	copy_le16(extra.magic, 0x5455);
	copy_le16(extra.extra_size, ZIP_EXTRA_MTIME_PAYLOAD_SIZE);
	extra.flags[0] = 1;	/* just mtime */
	copy_le32(extra.mtime, args->time);

Rene Scharfe's avatar
Rene Scharfe committed
286
	/* make sure we have enough free space in the dictionary */
287
	direntsize = ZIP_DIR_HEADER_SIZE + pathlen + ZIP_EXTRA_MTIME_SIZE;
Rene Scharfe's avatar
Rene Scharfe committed
288 289 290 291 292 293
	while (zip_dir_size < zip_dir_offset + direntsize) {
		zip_dir_size += ZIP_DIRECTORY_MIN_SIZE;
		zip_dir = xrealloc(zip_dir, zip_dir_size);
	}

	copy_le32(dirent.magic, 0x02014b50);
294 295
	copy_le16(dirent.creator_version,
		S_ISLNK(mode) || (S_ISREG(mode) && (mode & 0111)) ? 0x0317 : 0);
296
	copy_le16(dirent.version, 10);
297
	copy_le16(dirent.flags, flags);
Rene Scharfe's avatar
Rene Scharfe committed
298 299 300
	copy_le16(dirent.compression_method, method);
	copy_le16(dirent.mtime, zip_time);
	copy_le16(dirent.mdate, zip_date);
301
	set_zip_dir_data_desc(&dirent, size, compressed_size, crc);
Rene Scharfe's avatar
Rene Scharfe committed
302
	copy_le16(dirent.filename_length, pathlen);
303
	copy_le16(dirent.extra_length, ZIP_EXTRA_MTIME_SIZE);
Rene Scharfe's avatar
Rene Scharfe committed
304 305 306
	copy_le16(dirent.comment_length, 0);
	copy_le16(dirent.disk, 0);
	copy_le16(dirent.attr1, 0);
307
	copy_le32(dirent.attr2, attr2);
Rene Scharfe's avatar
Rene Scharfe committed
308 309 310
	copy_le32(dirent.offset, zip_offset);

	copy_le32(header.magic, 0x04034b50);
311
	copy_le16(header.version, 10);
312
	copy_le16(header.flags, flags);
Rene Scharfe's avatar
Rene Scharfe committed
313 314 315
	copy_le16(header.compression_method, method);
	copy_le16(header.mtime, zip_time);
	copy_le16(header.mdate, zip_date);
316 317 318 319
	if (flags & ZIP_STREAM)
		set_zip_header_data_desc(&header, 0, 0, 0);
	else
		set_zip_header_data_desc(&header, size, compressed_size, crc);
Rene Scharfe's avatar
Rene Scharfe committed
320
	copy_le16(header.filename_length, pathlen);
321
	copy_le16(header.extra_length, ZIP_EXTRA_MTIME_SIZE);
322 323
	write_or_die(1, &header, ZIP_LOCAL_HEADER_SIZE);
	zip_offset += ZIP_LOCAL_HEADER_SIZE;
Rene Scharfe's avatar
Rene Scharfe committed
324 325
	write_or_die(1, path, pathlen);
	zip_offset += pathlen;
326 327
	write_or_die(1, &extra, ZIP_EXTRA_MTIME_SIZE);
	zip_offset += ZIP_EXTRA_MTIME_SIZE;
328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348
	if (stream && method == 0) {
		unsigned char buf[STREAM_BUFFER_SIZE];
		ssize_t readlen;

		for (;;) {
			readlen = read_istream(stream, buf, sizeof(buf));
			if (readlen <= 0)
				break;
			crc = crc32(crc, buf, readlen);
			write_or_die(1, buf, readlen);
		}
		close_istream(stream);
		if (readlen)
			return readlen;

		compressed_size = size;
		zip_offset += compressed_size;

		write_zip_data_desc(size, compressed_size, crc);
		zip_offset += ZIP_DATA_DESC_SIZE;

349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410
		set_zip_dir_data_desc(&dirent, size, compressed_size, crc);
	} else if (stream && method == 8) {
		unsigned char buf[STREAM_BUFFER_SIZE];
		ssize_t readlen;
		git_zstream zstream;
		int result;
		size_t out_len;
		unsigned char compressed[STREAM_BUFFER_SIZE * 2];

		memset(&zstream, 0, sizeof(zstream));
		git_deflate_init(&zstream, args->compression_level);

		compressed_size = 0;
		zstream.next_out = compressed;
		zstream.avail_out = sizeof(compressed);

		for (;;) {
			readlen = read_istream(stream, buf, sizeof(buf));
			if (readlen <= 0)
				break;
			crc = crc32(crc, buf, readlen);

			zstream.next_in = buf;
			zstream.avail_in = readlen;
			result = git_deflate(&zstream, 0);
			if (result != Z_OK)
				die("deflate error (%d)", result);
			out = compressed;
			if (!compressed_size)
				out += 2;
			out_len = zstream.next_out - out;

			if (out_len > 0) {
				write_or_die(1, out, out_len);
				compressed_size += out_len;
				zstream.next_out = compressed;
				zstream.avail_out = sizeof(compressed);
			}

		}
		close_istream(stream);
		if (readlen)
			return readlen;

		zstream.next_in = buf;
		zstream.avail_in = 0;
		result = git_deflate(&zstream, Z_FINISH);
		if (result != Z_STREAM_END)
			die("deflate error (%d)", result);

		git_deflate_end(&zstream);
		out = compressed;
		if (!compressed_size)
			out += 2;
		out_len = zstream.next_out - out - 4;
		write_or_die(1, out, out_len);
		compressed_size += out_len;
		zip_offset += compressed_size;

		write_zip_data_desc(size, compressed_size, crc);
		zip_offset += ZIP_DATA_DESC_SIZE;

411 412
		set_zip_dir_data_desc(&dirent, size, compressed_size, crc);
	} else if (compressed_size > 0) {
Rene Scharfe's avatar
Rene Scharfe committed
413 414 415 416 417
		write_or_die(1, out, compressed_size);
		zip_offset += compressed_size;
	}

	free(deflated);
418
	free(buffer);
Rene Scharfe's avatar
Rene Scharfe committed
419

420 421 422 423
	memcpy(zip_dir + zip_dir_offset, &dirent, ZIP_DIR_HEADER_SIZE);
	zip_dir_offset += ZIP_DIR_HEADER_SIZE;
	memcpy(zip_dir + zip_dir_offset, path, pathlen);
	zip_dir_offset += pathlen;
424 425
	memcpy(zip_dir + zip_dir_offset, &extra, ZIP_EXTRA_MTIME_SIZE);
	zip_dir_offset += ZIP_EXTRA_MTIME_SIZE;
426 427
	zip_dir_entries++;

428
	return 0;
Rene Scharfe's avatar
Rene Scharfe committed
429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444
}

static void write_zip_trailer(const unsigned char *sha1)
{
	struct zip_dir_trailer trailer;

	copy_le32(trailer.magic, 0x06054b50);
	copy_le16(trailer.disk, 0);
	copy_le16(trailer.directory_start_disk, 0);
	copy_le16(trailer.entries_on_this_disk, zip_dir_entries);
	copy_le16(trailer.entries, zip_dir_entries);
	copy_le32(trailer.size, zip_dir_offset);
	copy_le32(trailer.offset, zip_offset);
	copy_le16(trailer.comment_length, sha1 ? 40 : 0);

	write_or_die(1, zip_dir, zip_dir_offset);
445
	write_or_die(1, &trailer, ZIP_DIR_TRAILER_SIZE);
Rene Scharfe's avatar
Rene Scharfe committed
446 447 448 449 450 451 452 453 454 455 456 457 458
	if (sha1)
		write_or_die(1, sha1_to_hex(sha1), 40);
}

static void dos_time(time_t *time, int *dos_date, int *dos_time)
{
	struct tm *t = localtime(time);

	*dos_date = t->tm_mday + (t->tm_mon + 1) * 32 +
	            (t->tm_year + 1900 - 1980) * 512;
	*dos_time = t->tm_sec / 2 + t->tm_min * 32 + t->tm_hour * 2048;
}

459 460
static int write_zip_archive(const struct archiver *ar,
			     struct archiver_args *args)
461
{
462 463
	int err;

464 465 466 467
	dos_time(&args->time, &zip_date, &zip_time);

	zip_dir = xmalloc(ZIP_DIRECTORY_MIN_SIZE);
	zip_dir_size = ZIP_DIRECTORY_MIN_SIZE;
468 469 470 471

	err = write_archive_entries(args, write_zip_entry);
	if (!err)
		write_zip_trailer(args->commit_sha1);
472 473 474

	free(zip_dir);

475
	return err;
476
}
477 478 479 480

static struct archiver zip_archiver = {
	"zip",
	write_zip_archive,
481
	ARCHIVER_WANT_COMPRESSION_LEVELS|ARCHIVER_REMOTE
482 483 484 485 486 487
};

void init_zip_archiver(void)
{
	register_archiver(&zip_archiver);
}