sha1_file.c 27.1 KB
Newer Older
1 2 3 4 5 6 7 8
/*
 * GIT - The information manager from hell
 *
 * Copyright (C) Linus Torvalds, 2005
 *
 * This handles basic git sha1 object files - packing, unpacking,
 * creation etc.
 */
9 10
#include <sys/types.h>
#include <dirent.h>
11
#include "cache.h"
12
#include "delta.h"
13
#include "pack.h"
14

15 16 17 18 19 20 21 22 23 24
#ifndef O_NOATIME
#if defined(__linux__) && (defined(__i386__) || defined(__PPC__))
#define O_NOATIME 01000000
#else
#define O_NOATIME 0
#endif
#endif

static unsigned int sha1_file_open_flag = O_NOATIME;

25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48
static unsigned hexval(char c)
{
	if (c >= '0' && c <= '9')
		return c - '0';
	if (c >= 'a' && c <= 'f')
		return c - 'a' + 10;
	if (c >= 'A' && c <= 'F')
		return c - 'A' + 10;
	return ~0;
}

int get_sha1_hex(const char *hex, unsigned char *sha1)
{
	int i;
	for (i = 0; i < 20; i++) {
		unsigned int val = (hexval(hex[0]) << 4) | hexval(hex[1]);
		if (val & ~0xff)
			return -1;
		*sha1++ = val;
		hex += 2;
	}
	return 0;
}

L
Linus Torvalds 已提交
49
static int get_sha1_file(const char *path, unsigned char *result)
50 51 52 53 54 55 56 57 58 59 60 61 62 63
{
	char buffer[60];
	int fd = open(path, O_RDONLY);
	int len;

	if (fd < 0)
		return -1;
	len = read(fd, buffer, sizeof(buffer));
	close(fd);
	if (len < 40)
		return -1;
	return get_sha1_hex(buffer, result);
}

D
Daniel Barkalow 已提交
64
static char *git_dir, *git_object_dir, *git_index_file, *git_refs_dir;
65 66 67 68 69 70 71 72 73 74
static void setup_git_env(void)
{
	git_dir = gitenv(GIT_DIR_ENVIRONMENT);
	if (!git_dir)
		git_dir = DEFAULT_GIT_DIR_ENVIRONMENT;
	git_object_dir = gitenv(DB_ENVIRONMENT);
	if (!git_object_dir) {
		git_object_dir = xmalloc(strlen(git_dir) + 9);
		sprintf(git_object_dir, "%s/objects", git_dir);
	}
D
Daniel Barkalow 已提交
75 76
	git_refs_dir = xmalloc(strlen(git_dir) + 6);
	sprintf(git_refs_dir, "%s/refs", git_dir);
77 78 79 80 81 82 83 84 85 86 87 88 89 90
	git_index_file = gitenv(INDEX_ENVIRONMENT);
	if (!git_index_file) {
		git_index_file = xmalloc(strlen(git_dir) + 7);
		sprintf(git_index_file, "%s/index", git_dir);
	}
}

char *get_object_directory(void)
{
	if (!git_object_dir)
		setup_git_env();
	return git_object_dir;
}

D
Daniel Barkalow 已提交
91 92 93 94 95 96 97
char *get_refs_directory(void)
{
	if (!git_refs_dir)
		setup_git_env();
	return git_refs_dir;
}

98 99 100 101 102 103 104
char *get_index_file(void)
{
	if (!git_index_file)
		setup_git_env();
	return git_index_file;
}

105 106 107
int get_sha1(const char *str, unsigned char *sha1)
{
	static char pathname[PATH_MAX];
108 109 110 111 112 113 114 115 116
	static const char *prefix[] = {
		"",
		"refs",
		"refs/tags",
		"refs/heads",
		"refs/snap",
		NULL
	};
	const char **p;
117 118 119

	if (!get_sha1_hex(str, sha1))
		return 0;
120

121 122
	if (!git_dir)
		setup_git_env();
123
	for (p = prefix; *p; p++) {
124 125
		snprintf(pathname, sizeof(pathname), "%s/%s/%s",
			 git_dir, *p, str);
126 127 128 129
		if (!get_sha1_file(pathname, sha1))
			return 0;
	}

130 131 132
	return -1;
}

133 134 135 136 137 138 139 140 141 142 143 144 145 146 147
char * sha1_to_hex(const unsigned char *sha1)
{
	static char buffer[50];
	static const char hex[] = "0123456789abcdef";
	char *buf = buffer;
	int i;

	for (i = 0; i < 20; i++) {
		unsigned int val = *sha1++;
		*buf++ = hex[val >> 4];
		*buf++ = hex[val & 0xf];
	}
	return buffer;
}

148 149 150 151 152 153 154 155 156 157 158 159
static void fill_sha1_path(char *pathbuf, const unsigned char *sha1)
{
	int i;
	for (i = 0; i < 20; i++) {
		static char hex[] = "0123456789abcdef";
		unsigned int val = sha1[i];
		char *pos = pathbuf + i*2 + (i > 0);
		*pos++ = hex[val >> 4];
		*pos = hex[val & 0xf];
	}
}

160 161 162 163
/*
 * NOTE! This returns a statically allocated buffer, so you have to be
 * careful about using it. Do a "strdup()" if you need to save the
 * filename.
164 165 166
 *
 * Also note that this returns the location for creating.  Reading
 * SHA1 file can happen from any alternate directory listed in the
J
Junio C Hamano 已提交
167
 * DB_ENVIRONMENT environment variable if it is not found in
168
 * the primary object database.
169 170 171 172 173 174
 */
char *sha1_file_name(const unsigned char *sha1)
{
	static char *name, *base;

	if (!base) {
J
Junio C Hamano 已提交
175
		const char *sha1_file_directory = get_object_directory();
176
		int len = strlen(sha1_file_directory);
177
		base = xmalloc(len + 60);
178 179 180 181 182 183
		memcpy(base, sha1_file_directory, len);
		memset(base+len, 0, 60);
		base[len] = '/';
		base[len+3] = '/';
		name = base + len + 1;
	}
184
	fill_sha1_path(name, sha1);
185 186 187
	return base;
}

188
struct alternate_object_database *alt_odb;
189

J
Junio C Hamano 已提交
190 191 192 193 194
/*
 * Prepare alternate object database registry.
 * alt_odb points at an array of struct alternate_object_database.
 * This array is terminated with an element that has both its base
 * and name set to NULL.  alt_odb[n] comes from n'th non-empty
J
Junio C Hamano 已提交
195
 * element from colon separated ALTERNATE_DB_ENVIRONMENT environment
J
Junio C Hamano 已提交
196 197 198 199 200 201 202 203 204 205
 * variable, and its base points at a statically allocated buffer
 * that contains "/the/directory/corresponding/to/.git/objects/...",
 * while its name points just after the slash at the end of
 * ".git/objects/" in the example above, and has enough space to hold
 * 40-byte hex SHA1, an extra slash for the first level indirection,
 * and the terminating NUL.
 * This function allocates the alt_odb array and all the strings
 * pointed by base fields of the array elements with one xmalloc();
 * the string pool immediately follows the array.
 */
206
void prepare_alt_odb(void)
207 208 209
{
	int pass, totlen, i;
	const char *cp, *last;
L
Linus Torvalds 已提交
210
	char *op = NULL;
J
Junio C Hamano 已提交
211
	const char *alt = gitenv(ALTERNATE_DB_ENVIRONMENT) ? : "";
212

213 214
	if (alt_odb)
		return;
J
Junio C Hamano 已提交
215 216 217 218 219 220
	/* The first pass counts how large an area to allocate to
	 * hold the entire alt_odb structure, including array of
	 * structs and path buffers for them.  The second pass fills
	 * the structure and prepares the path buffers for use by
	 * fill_sha1_path().
	 */
221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247
	for (totlen = pass = 0; pass < 2; pass++) {
		last = alt;
		i = 0;
		do {
			cp = strchr(last, ':') ? : last + strlen(last);
			if (last != cp) {
				/* 43 = 40-byte + 2 '/' + terminating NUL */
				int pfxlen = cp - last;
				int entlen = pfxlen + 43;
				if (pass == 0)
					totlen += entlen;
				else {
					alt_odb[i].base = op;
					alt_odb[i].name = op + pfxlen + 1;
					memcpy(op, last, pfxlen);
					op[pfxlen] = op[pfxlen + 3] = '/';
					op[entlen-1] = 0;
					op += entlen;
				}
				i++;
			}
			while (*cp && *cp == ':')
				cp++;
			last = cp;
		} while (*cp);
		if (pass)
			break;
J
Junio C Hamano 已提交
248
		alt_odb = xmalloc(sizeof(*alt_odb) * (i + 1) + totlen);
L
Linus Torvalds 已提交
249
		alt_odb[i].base = alt_odb[i].name = NULL;
250 251 252 253 254 255 256 257 258 259 260
		op = (char*)(&alt_odb[i+1]);
	}
}

static char *find_sha1_file(const unsigned char *sha1, struct stat *st)
{
	int i;
	char *name = sha1_file_name(sha1);

	if (!stat(name, st))
		return name;
261
	prepare_alt_odb();
262 263 264 265 266 267 268 269
	for (i = 0; (name = alt_odb[i].name) != NULL; i++) {
		fill_sha1_path(name, sha1);
		if (!stat(alt_odb[i].base, st))
			return alt_odb[i].base;
	}
	return NULL;
}

270 271 272
#define PACK_MAX_SZ (1<<26)
static int pack_used_ctr;
static unsigned long pack_mapped;
273
struct packed_git *packed_git;
274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304

struct pack_entry {
	unsigned int offset;
	unsigned char sha1[20];
	struct packed_git *p;
};

static int check_packed_git_idx(const char *path, unsigned long *idx_size_,
				void **idx_map_)
{
	void *idx_map;
	unsigned int *index;
	unsigned long idx_size;
	int nr, i;
	int fd = open(path, O_RDONLY);
	struct stat st;
	if (fd < 0)
		return -1;
	if (fstat(fd, &st)) {
		close(fd);
		return -1;
	}
	idx_size = st.st_size;
	idx_map = mmap(NULL, idx_size, PROT_READ, MAP_PRIVATE, fd, 0);
	close(fd);
	if (idx_map == MAP_FAILED)
		return -1;

	index = idx_map;

	/* check index map */
305
	if (idx_size < 4*256 + 20 + 20)
306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329
		return error("index file too small");
	nr = 0;
	for (i = 0; i < 256; i++) {
		unsigned int n = ntohl(index[i]);
		if (n < nr)
			return error("non-monotonic index");
		nr = n;
	}

	/*
	 * Total size:
	 *  - 256 index entries 4 bytes each
	 *  - 24-byte entries * nr (20-byte sha1 + 4-byte offset)
	 *  - 20-byte SHA1 of the packfile
	 *  - 20-byte SHA1 file checksum
	 */
	if (idx_size != 4*256 + nr * 24 + 20 + 20)
		return error("wrong index file size");

	*idx_map_ = idx_map;
	*idx_size_ = idx_size;
	return 0;
}

330
static int unuse_one_packed_git(void)
331
{
332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349
	struct packed_git *p, *lru = NULL;

	for (p = packed_git; p; p = p->next) {
		if (p->pack_use_cnt || !p->pack_base)
			continue;
		if (!lru || p->pack_last_used < lru->pack_last_used)
			lru = p;
	}
	if (!lru)
		return 0;
	munmap(lru->pack_base, lru->pack_size);
	lru->pack_base = NULL;
	return 1;
}

void unuse_packed_git(struct packed_git *p)
{
	p->pack_use_cnt--;
350 351
}

352
int use_packed_git(struct packed_git *p)
353 354 355 356 357 358 359
{
	if (!p->pack_base) {
		int fd;
		struct stat st;
		void *map;

		pack_mapped += p->pack_size;
360 361
		while (PACK_MAX_SZ < pack_mapped && unuse_one_packed_git())
			; /* nothing */
362 363
		fd = open(p->pack_name, O_RDONLY);
		if (fd < 0)
364
			die("packfile %s cannot be opened", p->pack_name);
365 366
		if (fstat(fd, &st)) {
			close(fd);
367
			die("packfile %s cannot be opened", p->pack_name);
368 369
		}
		if (st.st_size != p->pack_size)
370
			die("packfile %s size mismatch.", p->pack_name);
371 372 373
		map = mmap(NULL, p->pack_size, PROT_READ, MAP_PRIVATE, fd, 0);
		close(fd);
		if (map == MAP_FAILED)
374
			die("packfile %s cannot be mapped.", p->pack_name);
375
		p->pack_base = map;
376 377 378 379 380 381 382

		/* Check if the pack file matches with the index file.
		 * this is cheap.
		 */
		if (memcmp((char*)(p->index_base) + p->index_size - 40,
			   p->pack_base + p->pack_size - 20, 20))
			die("packfile %s does not match index.", p->pack_name);
383 384
	}
	p->pack_last_used = pack_used_ctr++;
385
	p->pack_use_cnt++;
386 387 388
	return 0;
}

389
struct packed_git *add_packed_git(char *path, int path_len)
390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413
{
	struct stat st;
	struct packed_git *p;
	unsigned long idx_size;
	void *idx_map;

	if (check_packed_git_idx(path, &idx_size, &idx_map))
		return NULL;

	/* do we have a corresponding .pack file? */
	strcpy(path + path_len - 4, ".pack");
	if (stat(path, &st) || !S_ISREG(st.st_mode)) {
		munmap(idx_map, idx_size);
		return NULL;
	}
	/* ok, it looks sane as far as we can check without
	 * actually mapping the pack file.
	 */
	p = xmalloc(sizeof(*p) + path_len + 2);
	strcpy(p->pack_name, path);
	p->index_size = idx_size;
	p->pack_size = st.st_size;
	p->index_base = idx_map;
	p->next = NULL;
414
	p->pack_base = NULL;
415
	p->pack_last_used = 0;
416
	p->pack_use_cnt = 0;
417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449
	return p;
}

static void prepare_packed_git_one(char *objdir)
{
	char path[PATH_MAX];
	int len;
	DIR *dir;
	struct dirent *de;

	sprintf(path, "%s/pack", objdir);
	len = strlen(path);
	dir = opendir(path);
	if (!dir)
		return;
	path[len++] = '/';
	while ((de = readdir(dir)) != NULL) {
		int namelen = strlen(de->d_name);
		struct packed_git *p;

		if (strcmp(de->d_name + namelen - 4, ".idx"))
			continue;

		/* we have .idx.  Is it a file we can map? */
		strcpy(path + len, de->d_name);
		p = add_packed_git(path, len + namelen);
		if (!p)
			continue;
		p->next = packed_git;
		packed_git = p;
	}
}

450
void prepare_packed_git(void)
451 452 453 454 455 456 457 458
{
	int i;
	static int run_once = 0;

	if (run_once++)
		return;

	prepare_packed_git_one(get_object_directory());
459
	prepare_alt_odb();
460 461 462 463 464 465
	for (i = 0; alt_odb[i].base != NULL; i++) {
		alt_odb[i].name[0] = 0;
		prepare_packed_git_one(alt_odb[i].base);
	}
}

466
int check_sha1_signature(const unsigned char *sha1, void *map, unsigned long size, const char *type)
467
{
468
	char header[100];
469 470 471 472
	unsigned char real_sha1[20];
	SHA_CTX c;

	SHA1_Init(&c);
473
	SHA1_Update(&c, header, 1+sprintf(header, "%s %lu", type, size));
474 475 476 477 478
	SHA1_Update(&c, map, size);
	SHA1_Final(real_sha1, &c);
	return memcmp(sha1, real_sha1, 20) ? -1 : 0;
}

479 480 481
static void *map_sha1_file_internal(const unsigned char *sha1,
				    unsigned long *size,
				    int say_error)
482 483 484
{
	struct stat st;
	void *map;
485
	int fd;
486 487 488
	char *filename = find_sha1_file(sha1, &st);

	if (!filename) {
489 490
		if (say_error)
			error("cannot map sha1 file %s", sha1_to_hex(sha1));
491 492
		return NULL;
	}
493

494
	fd = open(filename, O_RDONLY | sha1_file_open_flag);
495
	if (fd < 0) {
496 497 498 499 500 501 502 503
		/* See if it works without O_NOATIME */
		switch (sha1_file_open_flag) {
		default:
			fd = open(filename, O_RDONLY);
			if (fd >= 0)
				break;
		/* Fallthrough */
		case 0:
504 505
			if (say_error)
				perror(filename);
506 507 508
			return NULL;
		}

509 510 511
		/* If it failed once, it will probably fail again.
		 * Stop using O_NOATIME
		 */
512
		sha1_file_open_flag = 0;
513 514 515 516 517 518 519 520 521
	}
	map = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
	close(fd);
	if (-1 == (int)(long)map)
		return NULL;
	*size = st.st_size;
	return map;
}

522 523 524 525 526
void *map_sha1_file(const unsigned char *sha1, unsigned long *size)
{
	return map_sha1_file_internal(sha1, size, 1);
}

527 528 529 530 531 532 533 534 535 536 537 538 539
int unpack_sha1_header(z_stream *stream, void *map, unsigned long mapsize, void *buffer, unsigned long size)
{
	/* Get the data stream */
	memset(stream, 0, sizeof(*stream));
	stream->next_in = map;
	stream->avail_in = mapsize;
	stream->next_out = buffer;
	stream->avail_out = size;

	inflateInit(stream);
	return inflate(stream, 0);
}

540 541 542
void *unpack_sha1_rest(z_stream *stream, void *buffer, unsigned long size)
{
	int bytes = strlen(buffer) + 1;
543
	unsigned char *buf = xmalloc(1+size);
544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607

	memcpy(buf, buffer + bytes, stream->total_out - bytes);
	bytes = stream->total_out - bytes;
	if (bytes < size) {
		stream->next_out = buf + bytes;
		stream->avail_out = size - bytes;
		while (inflate(stream, Z_FINISH) == Z_OK)
			/* nothing */;
	}
	buf[size] = 0;
	inflateEnd(stream);
	return buf;
}

/*
 * We used to just use "sscanf()", but that's actually way
 * too permissive for what we want to check. So do an anal
 * object header parse by hand.
 */
int parse_sha1_header(char *hdr, char *type, unsigned long *sizep)
{
	int i;
	unsigned long size;

	/*
	 * The type can be at most ten bytes (including the 
	 * terminating '\0' that we add), and is followed by
	 * a space. 
	 */
	i = 10;
	for (;;) {
		char c = *hdr++;
		if (c == ' ')
			break;
		if (!--i)
			return -1;
		*type++ = c;
	}
	*type = 0;

	/*
	 * The length must follow immediately, and be in canonical
	 * decimal format (ie "010" is not valid).
	 */
	size = *hdr++ - '0';
	if (size > 9)
		return -1;
	if (size) {
		for (;;) {
			unsigned long c = *hdr - '0';
			if (c > 9)
				break;
			hdr++;
			size = size * 10 + c;
		}
	}
	*sizep = size;

	/*
	 * The length must be followed by a zero byte
	 */
	return *hdr ? -1 : 0;
}

608 609
void * unpack_sha1_file(void *map, unsigned long mapsize, char *type, unsigned long *size)
{
610
	int ret;
611
	z_stream stream;
612
	char hdr[8192];
613

614 615
	ret = unpack_sha1_header(&stream, map, mapsize, hdr, sizeof(hdr));
	if (ret < Z_OK || parse_sha1_header(hdr, type, size) < 0)
616 617
		return NULL;

618
	return unpack_sha1_rest(&stream, hdr, *size);
619 620
}

621 622 623 624 625 626
static int packed_delta_info(unsigned char *base_sha1,
			     unsigned long delta_size,
			     unsigned long left,
			     char *type,
			     unsigned long *sizep)
{
627
	const unsigned char *data;
628
	unsigned char delta_head[64];
629
	unsigned long result_size, base_size, verify_base_size;
630 631 632 633 634 635 636 637 638 639
	z_stream stream;
	int st;

	if (left < 20)
		die("truncated pack file");
	if (sha1_object_info(base_sha1, type, &base_size))
		die("cannot get info for delta-pack base");

	memset(&stream, 0, sizeof(stream));

640 641
	data = stream.next_in = base_sha1 + 20;
	stream.avail_in = left - 20;
642 643 644 645 646 647 648 649 650 651 652 653 654
	stream.next_out = delta_head;
	stream.avail_out = sizeof(delta_head);

	inflateInit(&stream);
	st = inflate(&stream, Z_FINISH);
	inflateEnd(&stream);
	if ((st != Z_STREAM_END) && stream.total_out != sizeof(delta_head))
		die("delta data unpack-initial failed");

	/* Examine the initial part of the delta to figure out
	 * the result size.  Verify the base size while we are at it.
	 */
	data = delta_head;
655
	verify_base_size = get_delta_hdr_size(&data);
656 657 658
	if (verify_base_size != base_size)
		die("delta base size mismatch");

659 660
	/* Read the result size */
	result_size = get_delta_hdr_size(&data);
661 662 663 664
	*sizep = result_size;
	return 0;
}

665 666 667
static unsigned long unpack_object_header(struct packed_git *p, unsigned long offset,
	enum object_type *type, unsigned long *sizep)
{
668
	unsigned shift;
669 670 671 672 673 674 675 676 677 678 679
	unsigned char *pack, c;
	unsigned long size;

	if (offset >= p->pack_size)
		die("object offset outside of pack file");

	pack =  p->pack_base + offset;
	c = *pack++;
	offset++;
	*type = (c >> 4) & 7;
	size = c & 15;
680
	shift = 4;
681 682 683 684 685
	while (c & 0x80) {
		if (offset >= p->pack_size)
			die("object offset outside of pack file");
		c = *pack++;
		offset++;
686 687
		size += (c & 0x7f) << shift;
		shift += 7;
688 689 690 691 692
	}
	*sizep = size;
	return offset;
}

693 694 695 696 697 698
static int packed_object_info(struct pack_entry *entry,
			      char *type, unsigned long *sizep)
{
	struct packed_git *p = entry->p;
	unsigned long offset, size, left;
	unsigned char *pack;
699
	enum object_type kind;
700
	int retval;
701 702 703 704

	if (use_packed_git(p))
		die("cannot map packed file");

705
	offset = unpack_object_header(p, entry->offset, &kind, &size);
706
	pack = p->pack_base + offset;
707 708 709 710
	left = p->pack_size - offset;

	switch (kind) {
	case OBJ_DELTA:
711 712 713
		retval = packed_delta_info(pack, size, left, type, sizep);
		unuse_packed_git(p);
		return retval;
714
	case OBJ_COMMIT:
715 716
		strcpy(type, "commit");
		break;
717
	case OBJ_TREE:
718 719
		strcpy(type, "tree");
		break;
720
	case OBJ_BLOB:
721 722
		strcpy(type, "blob");
		break;
723
	case OBJ_TAG:
724 725
		strcpy(type, "tag");
		break;
726 727 728 729
	default:
		die("corrupted pack file");
	}
	*sizep = size;
730
	unuse_packed_git(p);
731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815
	return 0;
}

/* forward declaration for a mutually recursive function */
static void *unpack_entry(struct pack_entry *, char *, unsigned long *);

static void *unpack_delta_entry(unsigned char *base_sha1,
				unsigned long delta_size,
				unsigned long left,
				char *type,
				unsigned long *sizep)
{
	void *data, *delta_data, *result, *base;
	unsigned long data_size, result_size, base_size;
	z_stream stream;
	int st;

	if (left < 20)
		die("truncated pack file");
	data = base_sha1 + 20;
	data_size = left - 20;
	delta_data = xmalloc(delta_size);

	memset(&stream, 0, sizeof(stream));

	stream.next_in = data;
	stream.avail_in = data_size;
	stream.next_out = delta_data;
	stream.avail_out = delta_size;

	inflateInit(&stream);
	st = inflate(&stream, Z_FINISH);
	inflateEnd(&stream);
	if ((st != Z_STREAM_END) || stream.total_out != delta_size)
		die("delta data unpack failed");

	/* This may recursively unpack the base, which is what we want */
	base = read_sha1_file(base_sha1, type, &base_size);
	if (!base)
		die("failed to read delta-pack base object %s",
		    sha1_to_hex(base_sha1));
	result = patch_delta(base, base_size,
			     delta_data, delta_size,
			     &result_size);
	if (!result)
		die("failed to apply delta");
	free(delta_data);
	free(base);
	*sizep = result_size;
	return result;
}

static void *unpack_non_delta_entry(unsigned char *data,
				    unsigned long size,
				    unsigned long left)
{
	int st;
	z_stream stream;
	char *buffer;

	buffer = xmalloc(size + 1);
	buffer[size] = 0;
	memset(&stream, 0, sizeof(stream));
	stream.next_in = data;
	stream.avail_in = left;
	stream.next_out = buffer;
	stream.avail_out = size;

	inflateInit(&stream);
	st = inflate(&stream, Z_FINISH);
	inflateEnd(&stream);
	if ((st != Z_STREAM_END) || stream.total_out != size) {
		free(buffer);
		return NULL;
	}

	return buffer;
}

static void *unpack_entry(struct pack_entry *entry,
			  char *type, unsigned long *sizep)
{
	struct packed_git *p = entry->p;
	unsigned long offset, size, left;
	unsigned char *pack;
816
	enum object_type kind;
817
	void *retval;
818 819 820 821

	if (use_packed_git(p))
		die("cannot map packed file");

822
	offset = unpack_object_header(p, entry->offset, &kind, &size);
823
	pack = p->pack_base + offset;
824 825 826
	left = p->pack_size - offset;
	switch (kind) {
	case OBJ_DELTA:
827 828 829
		retval = unpack_delta_entry(pack, size, left, type, sizep);
		unuse_packed_git(p);
		return retval;
830
	case OBJ_COMMIT:
831 832
		strcpy(type, "commit");
		break;
833
	case OBJ_TREE:
834 835
		strcpy(type, "tree");
		break;
836
	case OBJ_BLOB:
837 838
		strcpy(type, "blob");
		break;
839
	case OBJ_TAG:
840 841
		strcpy(type, "tag");
		break;
842 843 844 845
	default:
		die("corrupted pack file");
	}
	*sizep = size;
846 847 848
	retval = unpack_non_delta_entry(pack, size, left);
	unuse_packed_git(p);
	return retval;
849 850
}

851 852
int num_packed_objects(const struct packed_git *p)
{
853
	/* See check_packed_git_idx() */
854 855 856 857 858 859 860 861 862 863 864 865 866
	return (p->index_size - 20 - 20 - 4*256) / 24;
}

int nth_packed_object_sha1(const struct packed_git *p, int n,
			   unsigned char* sha1)
{
	void *index = p->index_base + 256;
	if (n < 0 || num_packed_objects(p) <= n)
		return -1;
	memcpy(sha1, (index + 24 * n + 4), 20);
	return 0;
}

867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903
static int find_pack_entry_1(const unsigned char *sha1,
			     struct pack_entry *e, struct packed_git *p)
{
	int *level1_ofs = p->index_base;
	int hi = ntohl(level1_ofs[*sha1]);
	int lo = ((*sha1 == 0x0) ? 0 : ntohl(level1_ofs[*sha1 - 1]));
	void *index = p->index_base + 256;

	do {
		int mi = (lo + hi) / 2;
		int cmp = memcmp(index + 24 * mi + 4, sha1, 20);
		if (!cmp) {
			e->offset = ntohl(*((int*)(index + 24 * mi)));
			memcpy(e->sha1, sha1, 20);
			e->p = p;
			return 1;
		}
		if (cmp > 0)
			hi = mi;
		else
			lo = mi+1;
	} while (lo < hi);
	return 0;
}

static int find_pack_entry(const unsigned char *sha1, struct pack_entry *e)
{
	struct packed_git *p;
	prepare_packed_git();

	for (p = packed_git; p; p = p->next) {
		if (find_pack_entry_1(sha1, e, p))
			return 1;
	}
	return 0;
}

904
int sha1_object_info(const unsigned char *sha1, char *type, unsigned long *sizep)
905
{
906
	int status;
907 908 909
	unsigned long mapsize, size;
	void *map;
	z_stream stream;
910
	char hdr[128];
911

912 913 914 915 916 917 918 919 920 921 922 923 924
	map = map_sha1_file_internal(sha1, &mapsize, 0);
	if (!map) {
		struct pack_entry e;

		if (!find_pack_entry(sha1, &e))
			return error("unable to find %s", sha1_to_hex(sha1));
		if (!packed_object_info(&e, type, sizep))
			return 0;
		/* sheesh */
		map = unpack_entry(&e, type, sizep);
		free(map);
		return (map == NULL) ? 0 : -1;
	}
925 926 927 928 929
	if (unpack_sha1_header(&stream, map, mapsize, hdr, sizeof(hdr)) < 0)
		status = error("unable to unpack %s header",
			       sha1_to_hex(sha1));
	if (parse_sha1_header(hdr, type, &size) < 0)
		status = error("unable to parse %s header", sha1_to_hex(sha1));
930
	else {
931
		status = 0;
932
		*sizep = size;
933 934 935 936 937 938
	}
	inflateEnd(&stream);
	munmap(map, mapsize);
	return status;
}

939 940 941 942 943 944 945 946 947 948 949
static void *read_packed_sha1(const unsigned char *sha1, char *type, unsigned long *size)
{
	struct pack_entry e;

	if (!find_pack_entry(sha1, &e)) {
		error("cannot read sha1_file for %s", sha1_to_hex(sha1));
		return NULL;
	}
	return unpack_entry(&e, type, size);
}

950 951 952 953 954
void * read_sha1_file(const unsigned char *sha1, char *type, unsigned long *size)
{
	unsigned long mapsize;
	void *map, *buf;

955
	map = map_sha1_file_internal(sha1, &mapsize, 0);
956 957 958 959 960
	if (map) {
		buf = unpack_sha1_file(map, mapsize, type, size);
		munmap(map, mapsize);
		return buf;
	}
961
	return read_packed_sha1(sha1, type, size);
962 963
}

964
void *read_object_with_reference(const unsigned char *sha1,
965
				 const char *required_type,
966 967
				 unsigned long *size,
				 unsigned char *actual_sha1_return)
968 969 970 971
{
	char type[20];
	void *buffer;
	unsigned long isize;
972
	unsigned char actual_sha1[20];
973

974 975 976 977
	memcpy(actual_sha1, sha1, 20);
	while (1) {
		int ref_length = -1;
		const char *ref_type = NULL;
978

979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997
		buffer = read_sha1_file(actual_sha1, type, &isize);
		if (!buffer)
			return NULL;
		if (!strcmp(type, required_type)) {
			*size = isize;
			if (actual_sha1_return)
				memcpy(actual_sha1_return, actual_sha1, 20);
			return buffer;
		}
		/* Handle references */
		else if (!strcmp(type, "commit"))
			ref_type = "tree ";
		else if (!strcmp(type, "tag"))
			ref_type = "object ";
		else {
			free(buffer);
			return NULL;
		}
		ref_length = strlen(ref_type);
998

999 1000 1001 1002 1003 1004 1005
		if (memcmp(buffer, ref_type, ref_length) ||
		    get_sha1_hex(buffer + ref_length, actual_sha1)) {
			free(buffer);
			return NULL;
		}
		/* Now we have the ID of the referred-to object in
		 * actual_sha1.  Check again. */
1006 1007 1008
	}
}

1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029
static char *write_sha1_file_prepare(void *buf,
				     unsigned long len,
				     const char *type,
				     unsigned char *sha1,
				     unsigned char *hdr,
				     int *hdrlen)
{
	SHA_CTX c;

	/* Generate the header */
	*hdrlen = sprintf((char *)hdr, "%s %lu", type, len)+1;

	/* Sha1.. */
	SHA1_Init(&c);
	SHA1_Update(&c, hdr, *hdrlen);
	SHA1_Update(&c, buf, len);
	SHA1_Final(sha1, &c);

	return sha1_file_name(sha1);
}

1030
int write_sha1_file(void *buf, unsigned long len, const char *type, unsigned char *returnsha1)
1031 1032
{
	int size;
1033
	unsigned char *compressed;
1034 1035
	z_stream stream;
	unsigned char sha1[20];
1036
	char *filename;
1037
	static char tmpfile[PATH_MAX];
1038
	unsigned char hdr[50];
1039
	int fd, hdrlen, ret;
1040

1041 1042 1043 1044
	/* Normally if we have it in the pack then we do not bother writing
	 * it out into .git/objects/??/?{38} file.
	 */
	filename = write_sha1_file_prepare(buf, len, type, sha1, hdr, &hdrlen);
1045 1046
	if (returnsha1)
		memcpy(returnsha1, sha1, 20);
1047 1048
	if (has_sha1_file(sha1))
		return 0;
1049 1050
	fd = open(filename, O_RDONLY);
	if (fd >= 0) {
1051
		/*
1052 1053
		 * FIXME!!! We might do collision checking here, but we'd
		 * need to uncompress the old file and check it. Later.
1054
		 */
1055
		close(fd);
1056 1057 1058
		return 0;
	}

1059 1060 1061 1062 1063 1064
	if (errno != ENOENT) {
		fprintf(stderr, "sha1 file %s: %s", filename, strerror(errno));
		return -1;
	}

	snprintf(tmpfile, sizeof(tmpfile), "%s/obj_XXXXXX", get_object_directory());
1065

1066 1067 1068 1069 1070 1071
	fd = mkstemp(tmpfile);
	if (fd < 0) {
		fprintf(stderr, "unable to create temporary sha1 filename %s: %s", tmpfile, strerror(errno));
		return -1;
	}

1072 1073 1074
	/* Set it up */
	memset(&stream, 0, sizeof(stream));
	deflateInit(&stream, Z_BEST_COMPRESSION);
1075
	size = deflateBound(&stream, len+hdrlen);
1076
	compressed = xmalloc(size);
1077 1078 1079 1080

	/* Compress it */
	stream.next_out = compressed;
	stream.avail_out = size;
1081 1082 1083 1084 1085

	/* First header.. */
	stream.next_in = hdr;
	stream.avail_in = hdrlen;
	while (deflate(&stream, 0) == Z_OK)
1086
		/* nothing */;
1087 1088 1089 1090

	/* Then the data itself.. */
	stream.next_in = buf;
	stream.avail_in = len;
1091 1092 1093 1094 1095
	while (deflate(&stream, Z_FINISH) == Z_OK)
		/* nothing */;
	deflateEnd(&stream);
	size = stream.total_out;

1096 1097
	if (write(fd, compressed, size) != size)
		die("unable to write file");
1098
	fchmod(fd, 0444);
1099
	close(fd);
1100
	free(compressed);
1101

1102
	ret = link(tmpfile, filename);
1103
	if (ret < 0) {
1104
		ret = errno;
1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117

		/*
		 * Coda hack - coda doesn't like cross-directory links,
		 * so we fall back to a rename, which will mean that it
		 * won't be able to check collisions, but that's not a
		 * big deal.
		 *
		 * When this succeeds, we just return 0. We have nothing
		 * left to unlink.
		 */
		if (ret == EXDEV && !rename(tmpfile, filename))
			return 0;
	}
1118 1119 1120 1121
	unlink(tmpfile);
	if (ret) {
		if (ret != EEXIST) {
			fprintf(stderr, "unable to write sha1 filename %s: %s", filename, strerror(ret));
1122
			return -1;
1123 1124
		}
		/* FIXME!!! Collision check here ? */
1125
	}
1126

1127 1128
	return 0;
}
1129 1130 1131 1132 1133 1134 1135 1136

int write_sha1_from_fd(const unsigned char *sha1, int fd)
{
	char *filename = sha1_file_name(sha1);

	int local;
	z_stream stream;
	unsigned char real_sha1[20];
1137 1138
	unsigned char buf[4096];
	unsigned char discard[4096];
1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194
	int ret;
	SHA_CTX c;

	local = open(filename, O_WRONLY | O_CREAT | O_EXCL, 0666);

	if (local < 0)
		return error("Couldn't open %s\n", filename);

	memset(&stream, 0, sizeof(stream));

	inflateInit(&stream);

	SHA1_Init(&c);

	do {
		ssize_t size;
		size = read(fd, buf, 4096);
		if (size <= 0) {
			close(local);
			unlink(filename);
			if (!size)
				return error("Connection closed?");
			perror("Reading from connection");
			return -1;
		}
		write(local, buf, size);
		stream.avail_in = size;
		stream.next_in = buf;
		do {
			stream.next_out = discard;
			stream.avail_out = sizeof(discard);
			ret = inflate(&stream, Z_SYNC_FLUSH);
			SHA1_Update(&c, discard, sizeof(discard) -
				    stream.avail_out);
		} while (stream.avail_in && ret == Z_OK);
		
	} while (ret == Z_OK);
	inflateEnd(&stream);

	close(local);
	SHA1_Final(real_sha1, &c);
	if (ret != Z_STREAM_END) {
		unlink(filename);
		return error("File %s corrupted", sha1_to_hex(sha1));
	}
	if (memcmp(sha1, real_sha1, 20)) {
		unlink(filename);
		return error("File %s has bad hash\n", sha1_to_hex(sha1));
	}
	
	return 0;
}

int has_sha1_file(const unsigned char *sha1)
{
	struct stat st;
1195 1196 1197 1198 1199
	struct pack_entry e;

	if (find_sha1_file(sha1, &st))
		return 1;
	return find_pack_entry(sha1, &e);
1200
}
J
Junio C Hamano 已提交
1201 1202 1203 1204

int index_fd(unsigned char *sha1, int fd, struct stat *st)
{
	unsigned long size = st->st_size;
1205 1206
	void *buf;
	int ret;
J
Junio C Hamano 已提交
1207

1208
	buf = "";
J
Junio C Hamano 已提交
1209
	if (size)
1210
		buf = mmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);
J
Junio C Hamano 已提交
1211
	close(fd);
1212
	if ((int)(long)buf == -1)
J
Junio C Hamano 已提交
1213 1214
		return -1;

1215 1216 1217 1218
	ret = write_sha1_file(buf, size, "blob", sha1);
	if (size)
		munmap(buf, size);
	return ret;
J
Junio C Hamano 已提交
1219
}