odb_loose.c 21.7 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
/*
 * This file is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License, version 2,
 * as published by the Free Software Foundation.
 *
 * In addition to the permissions in the GNU General Public License,
 * the authors give you unlimited permission to link the compiled
 * version of this file into combinations with other programs,
 * and to distribute those combinations without any restriction
 * coming from the use of this file.  (The General Public License
 * restrictions do apply in other respects; for example, they cover
 * modification of the file, and distribution when not linked into
 * a combined executable.)
 *
 * This file is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; see the file COPYING.  If not, write to
 * the Free Software Foundation, 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 */

#include "common.h"
27 28
#include "git2/zlib.h"
#include "git2/object.h"
29
#include "git2/oid.h"
30 31 32 33
#include "fileops.h"
#include "hash.h"
#include "odb.h"
#include "delta-apply.h"
Vicent Marti committed
34
#include "filebuf.h"
35

36
#include "git2/odb_backend.h"
Vicent Marti committed
37
#include "git2/types.h"
38 39 40 41 42 43

typedef struct {  /* object header data */
	git_otype type;  /* object type */
	size_t    size;  /* object size */
} obj_hdr;

Vicent Marti committed
44 45 46 47 48 49
typedef struct {
	git_odb_stream stream;
	git_filebuf fbuf;
	int finished;
} loose_writestream;

50 51 52 53 54 55 56 57
typedef struct loose_backend {
	git_odb_backend parent;

	int object_zlib_level; /** loose object zlib compression level. */
	int fsync_object_files; /** loose object file fsync flag. */
	char *objects_dir;
} loose_backend;

58 59 60 61 62 63 64 65 66 67 68 69 70 71
/* State structure for exploring directories,
 * in order to locate objects matching a short oid.
 */
typedef struct {
	size_t dir_len;
	unsigned char short_oid[GIT_OID_HEXSZ]; /* hex formatted oid to match */
	unsigned int short_oid_len;
	int found;				/* number of matching
						 * objects already found */
	unsigned char res_oid[GIT_OID_HEXSZ];	/* hex formatted oid of
						 * the object found */
} loose_locate_object_state;


72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99

/***********************************************************
 *
 * MISCELANEOUS HELPER FUNCTIONS
 *
 ***********************************************************/

static size_t object_file_name(char *name, size_t n, char *dir, const git_oid *id)
{
	size_t len = strlen(dir);

	/* check length: 43 = 40 hex sha1 chars + 2 * '/' + '\0' */
	if (len+43 > n)
		return len+43;

	/* the object dir: eg $GIT_DIR/objects */
	strcpy(name, dir);
	if (name[len-1] != '/')
		name[len++] = '/';

	/* loose object filename: aa/aaa... (41 bytes) */
	git_oid_pathfmt(&name[len], id);
	name[len+41] = '\0';

	return 0;
}


Vicent Marti committed
100
static size_t get_binary_object_header(obj_hdr *hdr, git_fbuffer *obj)
101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143
{
	unsigned char c;
	unsigned char *data = obj->data;
	size_t shift, size, used = 0;

	if (obj->len == 0)
		return 0;

	c = data[used++];
	hdr->type = (c >> 4) & 7;

	size = c & 15;
	shift = 4;
	while (c & 0x80) {
		if (obj->len <= used)
			return 0;
		if (sizeof(size_t) * 8 <= shift)
			return 0;
		c = data[used++];
		size += (c & 0x7f) << shift;
		shift += 7;
	}
	hdr->size = size;

	return used;
}

static size_t get_object_header(obj_hdr *hdr, unsigned char *data)
{
	char c, typename[10];
	size_t size, used = 0;

	/*
	 * type name string followed by space.
	 */
	while ((c = data[used]) != ' ') {
		typename[used++] = c;
		if (used >= sizeof(typename))
			return 0;
	}
	typename[used] = 0;
	if (used == 0)
		return 0;
144
	hdr->type = git_object_string2type(typename);
145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201
	used++;  /* consume the space */

	/*
	 * length follows immediately in decimal (without
	 * leading zeros).
	 */
	size = data[used++] - '0';
	if (size > 9)
		return 0;
	if (size) {
		while ((c = data[used]) != '\0') {
			size_t d = c - '0';
			if (d > 9)
				break;
			used++;
			size = size * 10 + d;
		}
	}
	hdr->size = size;

	/*
	 * the length must be followed by a zero byte
	 */
	if (data[used++] != '\0')
		return 0;

	return used;
}



/***********************************************************
 *
 * ZLIB RELATED FUNCTIONS
 *
 ***********************************************************/

static void init_stream(z_stream *s, void *out, size_t len)
{
	memset(s, 0, sizeof(*s));
	s->next_out  = out;
	s->avail_out = len;
}

static void set_stream_input(z_stream *s, void *in, size_t len)
{
	s->next_in  = in;
	s->avail_in = len;
}

static void set_stream_output(z_stream *s, void *out, size_t len)
{
	s->next_out  = out;
	s->avail_out = len;
}


Vicent Marti committed
202
static int start_inflate(z_stream *s, git_fbuffer *obj, void *out, size_t len)
203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224
{
	int status;

	init_stream(s, out, len);
	set_stream_input(s, obj->data, obj->len);

	if ((status = inflateInit(s)) < Z_OK)
		return status;

	return inflate(s, 0);
}

static int finish_inflate(z_stream *s)
{
	int status = Z_OK;

	while (status == Z_OK)
		status = inflate(s, Z_FINISH);

	inflateEnd(s);

	if ((status != Z_STREAM_END) || (s->avail_in != 0))
225
		return git__throw(GIT_ERROR, "Failed to finish inflation. Stream aborted prematurely");
226 227 228 229

	return GIT_SUCCESS;
}

Vicent Marti committed
230
static int is_zlib_compressed_data(unsigned char *data)
231
{
Vicent Marti committed
232
	unsigned int w;
233

Vicent Marti committed
234 235
	w = ((unsigned int)(data[0]) << 8) + data[1];
	return data[0] == 0x78 && !(w % 31);
236 237
}

Vicent Marti committed
238
static int inflate_buffer(void *in, size_t inlen, void *out, size_t outlen)
239 240
{
	z_stream zs;
Vicent Marti committed
241
	int status = Z_OK;
242

Vicent Marti committed
243
	memset(&zs, 0x0, sizeof(zs));
244

Vicent Marti committed
245 246
	zs.next_out  = out;
	zs.avail_out = outlen;
247

Vicent Marti committed
248 249
	zs.next_in  = in;
	zs.avail_in = inlen;
250

Vicent Marti committed
251
	if (inflateInit(&zs) < Z_OK)
252
		return git__throw(GIT_ERROR, "Failed to inflate buffer");
253

Vicent Marti committed
254 255
	while (status == Z_OK)
		status = inflate(&zs, Z_FINISH);
256

Vicent Marti committed
257
	inflateEnd(&zs);
258

Vicent Marti committed
259
	if ((status != Z_STREAM_END) /*|| (zs.avail_in != 0) */)
260
		return git__throw(GIT_ERROR, "Failed to inflate buffer. Stream aborted prematurely");
261

Vicent Marti committed
262
	if (zs.total_out != outlen)
263
		return git__throw(GIT_ERROR, "Failed to inflate buffer. Stream aborted prematurely");
264 265 266 267 268 269 270 271 272 273 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 305 306 307 308 309 310 311

	return GIT_SUCCESS;
}

static void *inflate_tail(z_stream *s, void *hb, size_t used, obj_hdr *hdr)
{
	unsigned char *buf, *head = hb;
	size_t tail;

	/*
	 * allocate a buffer to hold the inflated data and copy the
	 * initial sequence of inflated data from the tail of the
	 * head buffer, if any.
	 */
	if ((buf = git__malloc(hdr->size + 1)) == NULL) {
		inflateEnd(s);
		return NULL;
	}
	tail = s->total_out - used;
	if (used > 0 && tail > 0) {
		if (tail > hdr->size)
			tail = hdr->size;
		memcpy(buf, head + used, tail);
	}
	used = tail;

	/*
	 * inflate the remainder of the object data, if any
	 */
	if (hdr->size < used)
		inflateEnd(s);
	else {
		set_stream_output(s, buf + used, hdr->size - used);
		if (finish_inflate(s)) {
			free(buf);
			return NULL;
		}
	}

	return buf;
}

/*
 * At one point, there was a loose object format that was intended to
 * mimic the format used in pack-files. This was to allow easy copying
 * of loose object data into packs. This format is no longer used, but
 * we must still read it.
 */
Vicent Marti committed
312
static int inflate_packlike_loose_disk_obj(git_rawobj *out, git_fbuffer *obj)
313 314 315 316 317 318 319 320 321 322
{
	unsigned char *in, *buf;
	obj_hdr hdr;
	size_t len, used;

	/*
	 * read the object header, which is an (uncompressed)
	 * binary encoding of the object type and size.
	 */
	if ((used = get_binary_object_header(&hdr, obj)) == 0)
323
		return git__throw(GIT_ERROR, "Failed to inflate loose object. Object has no header");
324

325
	if (!git_object_typeisloose(hdr.type))
326
		return git__throw(GIT_ERROR, "Failed to inflate loose object. Wrong object type");
327 328 329 330 331 332

	/*
	 * allocate a buffer and inflate the data into it
	 */
	buf = git__malloc(hdr.size + 1);
	if (!buf)
333
		return GIT_ENOMEM;
334 335 336

	in  = ((unsigned char *)obj->data) + used;
	len = obj->len - used;
Vicent Marti committed
337
	if (inflate_buffer(in, len, buf, hdr.size)) {
338
		free(buf);
339
		return git__throw(GIT_ERROR, "Failed to inflate loose object. Could not inflate buffer");
340 341 342 343 344 345 346 347 348 349
	}
	buf[hdr.size] = '\0';

	out->data = buf;
	out->len  = hdr.size;
	out->type = hdr.type;

	return GIT_SUCCESS;
}

Vicent Marti committed
350
static int inflate_disk_obj(git_rawobj *out, git_fbuffer *obj)
351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366
{
	unsigned char head[64], *buf;
	z_stream zs;
	obj_hdr hdr;
	size_t used;

	/*
	 * check for a pack-like loose object
	 */
	if (!is_zlib_compressed_data(obj->data))
		return inflate_packlike_loose_disk_obj(out, obj);

	/*
	 * inflate the initial part of the io buffer in order
	 * to parse the object header (type and size).
	 */
367
	if (start_inflate(&zs, obj, head, sizeof(head)) < Z_OK)
368
		return git__throw(GIT_ERROR, "Failed to inflate disk object. Could not inflate buffer");
369 370

	if ((used = get_object_header(&hdr, head)) == 0)
371
		return git__throw(GIT_ERROR, "Failed to inflate disk object. Object has no header");
372

373
	if (!git_object_typeisloose(hdr.type))
374
		return git__throw(GIT_ERROR, "Failed to inflate disk object. Wrong object type");
375 376 377 378 379 380

	/*
	 * allocate a buffer and inflate the object data into it
	 * (including the initial sequence in the head buffer).
	 */
	if ((buf = inflate_tail(&zs, head, used, &hdr)) == NULL)
381
		return GIT_ENOMEM;
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
	buf[hdr.size] = '\0';

	out->data = buf;
	out->len  = hdr.size;
	out->type = hdr.type;

	return GIT_SUCCESS;
}






/***********************************************************
 *
 * ODB OBJECT READING & WRITING
 *
 * Backend for the public API; read headers and full objects
 * from the ODB. Write raw data to the ODB.
 *
 ***********************************************************/

static int read_loose(git_rawobj *out, const char *loc)
{
	int error;
Vicent Marti committed
408
	git_fbuffer obj = GIT_FBUFFER_INIT;
409 410 411 412 413 414 415

	assert(out && loc);

	out->data = NULL;
	out->len  = 0;
	out->type = GIT_OBJ_BAD;

Vicent Marti committed
416
	if (git_futils_readbuffer(&obj, loc) < 0)
417
		return git__throw(GIT_ENOTFOUND, "Failed to read loose object. File not found");
418 419

	error = inflate_disk_obj(out, &obj);
Vicent Marti committed
420
	git_futils_freebuffer(&obj);
421

422
	return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to read loose object");
423 424 425 426 427 428 429 430 431 432 433 434 435 436
}

static int read_header_loose(git_rawobj *out, const char *loc)
{
	int error = GIT_SUCCESS, z_return = Z_ERRNO, read_bytes;
	git_file fd;
	z_stream zs;
	obj_hdr header_obj;
	unsigned char raw_buffer[16], inflated_buffer[64];

	assert(out && loc);

	out->data = NULL;

Vicent Marti committed
437
	if ((fd = p_open(loc, O_RDONLY)) < 0)
438
		return git__throw(GIT_ENOTFOUND, "Failed to read loose object header. File not found");
439 440 441 442 443 444 445 446 447 448 449 450

	init_stream(&zs, inflated_buffer, sizeof(inflated_buffer));

	if (inflateInit(&zs) < Z_OK) {
		error = GIT_EZLIB;
		goto cleanup;
	}

	do {
		if ((read_bytes = read(fd, raw_buffer, sizeof(raw_buffer))) > 0) {
			set_stream_input(&zs, raw_buffer, read_bytes);
			z_return = inflate(&zs, 0);
451 452 453
		} else {
			z_return = Z_STREAM_END;
			break;
454 455 456 457 458
		}
	} while (z_return == Z_OK);

	if ((z_return != Z_STREAM_END && z_return != Z_BUF_ERROR)
		|| get_object_header(&header_obj, inflated_buffer) == 0
459
		|| git_object_typeisloose(header_obj.type) == 0) {
460 461 462 463 464 465 466 467 468
		error = GIT_EOBJCORRUPTED;
		goto cleanup;
	}

	out->len  = header_obj.size;
	out->type = header_obj.type;

cleanup:
	finish_inflate(&zs);
Vicent Marti committed
469
	p_close(fd);
Vicent Marti committed
470 471 472 473 474

	if (error < GIT_SUCCESS)
		return git__throw(error, "Failed to read loose object header. Header is corrupted");

	return GIT_SUCCESS;
475 476 477 478 479
}

static int locate_object(char *object_location, loose_backend *backend, const git_oid *oid)
{
	object_file_name(object_location, GIT_PATH_MAX, backend->objects_dir, oid);
Vicent Marti committed
480
	return git_futils_exists(object_location);
481 482
}

483 484 485 486 487 488 489 490 491 492
/* Explore an entry of a directory and see if it matches a short oid */
int fn_locate_object_short_oid(void *state, char *pathbuf) {
	loose_locate_object_state *sstate = (loose_locate_object_state *)state;

	size_t pathbuf_len = strlen(pathbuf);
	if (pathbuf_len - sstate->dir_len != GIT_OID_HEXSZ - 2) {
		/* Entry cannot be an object. Continue to next entry */
		return GIT_SUCCESS;
	}

Vicent Marti committed
493
	if (!git_futils_exists(pathbuf) && git_futils_isdir(pathbuf)) {
494 495 496 497 498 499
		/* We are already in the directory matching the 2 first hex characters,
		 * compare the first ncmp characters of the oids */
		if (!memcmp(sstate->short_oid + 2,
			(unsigned char *)pathbuf + sstate->dir_len,
			sstate->short_oid_len - 2)) {

500 501 502 503 504 505 506 507
			if (!sstate->found) {
				sstate->res_oid[0] = sstate->short_oid[0];
				sstate->res_oid[1] = sstate->short_oid[1];
				memcpy(sstate->res_oid+2, pathbuf+sstate->dir_len, GIT_OID_HEXSZ-2);
			}
			sstate->found++;
		}
	}
Vicent Marti committed
508
	if (sstate->found > 1)
509
		return git__throw(GIT_EAMBIGUOUSOIDPREFIX, "Ambiguous sha1 prefix within loose objects");
Vicent Marti committed
510 511

	return GIT_SUCCESS;
512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531
}

/* Locate an object matching a given short oid */
static int locate_object_short_oid(char *object_location, git_oid *res_oid, loose_backend *backend, const git_oid *short_oid, unsigned int len)
{
	char *objects_dir = backend->objects_dir;
	size_t dir_len = strlen(objects_dir);
	loose_locate_object_state state;
	int error;

	if (dir_len+43 > GIT_PATH_MAX)
		return git__throw(GIT_ERROR, "Failed to locate object from short oid. Object path too long");

	strcpy(object_location, objects_dir);

	/* Add a separator if not already there */
	if (object_location[dir_len-1] != '/')
		object_location[dir_len++] = '/';

	/* Convert raw oid to hex formatted oid */
Vicent Marti committed
532
	git_oid_fmt((char *)state.short_oid, short_oid);
533 534 535 536
	/* Explore OBJ_DIR/xx/ where xx is the beginning of hex formatted short oid */
	sprintf(object_location+dir_len, "%.2s/", state.short_oid);

	/* Check that directory exists */
Vicent Marti committed
537
	if (git_futils_exists(object_location) || git_futils_isdir(object_location))
538 539 540 541 542 543
		return git__throw(GIT_ENOTFOUND, "Failed to locate object from short oid. Object not found");

	state.dir_len = dir_len+3;
	state.short_oid_len = len;
	state.found = 0;
	/* Explore directory to find a unique object matching short_oid */
Vicent Marti committed
544
	error = git_futils_direach(object_location, GIT_PATH_MAX, fn_locate_object_short_oid, &state);
545 546 547 548 549 550 551 552
	if (error) {
		return git__rethrow(error, "Failed to locate object from short oid");
	}
	if (!state.found) {
		return git__throw(GIT_ENOTFOUND, "Failed to locate object from short oid. Object not found");
	}

	/* Convert obtained hex formatted oid to raw */
Vicent Marti committed
553
	error = git_oid_fromstr(res_oid, (char *)state.res_oid);
554 555 556 557 558 559 560 561 562 563
	if (error) {
		return git__rethrow(error, "Failed to locate object from short oid");
	}

	/* Update the location according to the oid obtained */
	git_oid_pathfmt(object_location+dir_len, res_oid);

	return GIT_SUCCESS;
}

564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579








/***********************************************************
 *
 * LOOSE BACKEND PUBLIC API
 *
 * Implement the git_odb_backend API calls
 *
 ***********************************************************/

Vicent Marti committed
580
int loose_backend__read_header(size_t *len_p, git_otype *type_p, git_odb_backend *backend, const git_oid *oid)
581 582
{
	char object_path[GIT_PATH_MAX];
Vicent Marti committed
583 584
	git_rawobj raw;
	int error;
585

Vicent Marti committed
586
	assert(backend && oid);
587

Vicent Marti committed
588 589 590
	raw.len = 0;
	raw.type = GIT_OBJ_BAD;

591
	if (locate_object(object_path, (loose_backend *)backend, oid) < 0)
592
		return git__throw(GIT_ENOTFOUND, "Failed to read loose backend header. Object not found");
593

Vicent Marti committed
594
	if ((error = read_header_loose(&raw, object_path)) < GIT_SUCCESS)
Vicent Marti committed
595
		return error;
596

Vicent Marti committed
597 598 599 600
	*len_p = raw.len;
	*type_p = raw.type;
	return GIT_SUCCESS;
}
601

Vicent Marti committed
602
int loose_backend__read(void **buffer_p, size_t *len_p, git_otype *type_p, git_odb_backend *backend, const git_oid *oid)
603 604
{
	char object_path[GIT_PATH_MAX];
Vicent Marti committed
605 606
	git_rawobj raw;
	int error;
607

Vicent Marti committed
608
	assert(backend && oid);
609 610

	if (locate_object(object_path, (loose_backend *)backend, oid) < 0)
611
		return git__throw(GIT_ENOTFOUND, "Failed to read loose backend. Object not found");
612

Vicent Marti committed
613
	if ((error = read_loose(&raw, object_path)) < GIT_SUCCESS)
614
		return git__rethrow(error, "Failed to read loose backend");
Vicent Marti committed
615 616 617 618 619 620

	*buffer_p = raw.data;
	*len_p = raw.len;
	*type_p = raw.type;

	return GIT_SUCCESS;
621 622
}

Vicent Marti committed
623 624 625 626 627 628 629 630
int loose_backend__read_prefix(
	git_oid *out_oid,
	void **buffer_p,
	size_t *len_p,
	git_otype *type_p,
	git_odb_backend *backend,
	const git_oid *short_oid,
	unsigned int len)
631
{
632 633 634
	if (len < GIT_OID_MINPREFIXLEN)
		return git__throw(GIT_EAMBIGUOUSOIDPREFIX, "Failed to read loose backend. Prefix length is lower than %d.", GIT_OID_MINPREFIXLEN);

635
	if (len >= GIT_OID_HEXSZ) {
636
		/* We can fall back to regular read method */
637 638 639 640 641
		int error = loose_backend__read(buffer_p, len_p, type_p, backend, short_oid);
		if (error == GIT_SUCCESS)
			git_oid_cpy(out_oid, short_oid);

		return error;
642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658
	} else {
		char object_path[GIT_PATH_MAX];
		git_rawobj raw;
		int error;

		assert(backend && short_oid);

		if ((error = locate_object_short_oid(object_path, out_oid, (loose_backend *)backend, short_oid, len)) < 0) {
			return git__rethrow(error, "Failed to read loose backend");
		}

		if ((error = read_loose(&raw, object_path)) < GIT_SUCCESS)
			return git__rethrow(error, "Failed to read loose backend");

		*buffer_p = raw.data;
		*len_p = raw.len;
		*type_p = raw.type;
659
	}
660 661

	return GIT_SUCCESS;
662 663
}

664 665 666 667 668 669 670 671 672
int loose_backend__exists(git_odb_backend *backend, const git_oid *oid)
{
	char object_path[GIT_PATH_MAX];

	assert(backend && oid);

	return locate_object(object_path, (loose_backend *)backend, oid) == GIT_SUCCESS;
}

Vicent Marti committed
673 674 675 676 677 678 679 680 681
int loose_backend__stream_fwrite(git_oid *oid, git_odb_stream *_stream)
{
	loose_writestream *stream = (loose_writestream *)_stream;
	loose_backend *backend = (loose_backend *)_stream->backend;

	int error;
	char final_path[GIT_PATH_MAX];

	if ((error = git_filebuf_hash(oid, &stream->fbuf)) < GIT_SUCCESS)
682
		return git__rethrow(error, "Failed to write loose backend");
Vicent Marti committed
683 684 685

	if (object_file_name(final_path, sizeof(final_path), backend->objects_dir, oid))
		return GIT_ENOMEM;
686

Vicent Marti committed
687
	if ((error = git_futils_mkpath2file(final_path)) < GIT_SUCCESS)
688
		return git__rethrow(error, "Failed to write loose backend");
Vicent Marti committed
689 690 691 692 693 694

	stream->finished = 1;
	return git_filebuf_commit_at(&stream->fbuf, final_path);
}

int loose_backend__stream_write(git_odb_stream *_stream, const char *data, size_t len)
695
{
Vicent Marti committed
696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718
	loose_writestream *stream = (loose_writestream *)_stream;
	return git_filebuf_write(&stream->fbuf, data, len);
}

void loose_backend__stream_free(git_odb_stream *_stream)
{
	loose_writestream *stream = (loose_writestream *)_stream;

	if (!stream->finished)
		git_filebuf_cleanup(&stream->fbuf);

	free(stream);
}

static int format_object_header(char *hdr, size_t n, size_t obj_len, git_otype obj_type)
{
	const char *type_str = git_object_type2string(obj_type);
	int len = snprintf(hdr, n, "%s %"PRIuZ, type_str, obj_len);

	assert(len > 0);             /* otherwise snprintf() is broken  */
	assert(((size_t) len) < n);  /* otherwise the caller is broken! */

	if (len < 0 || ((size_t) len) >= n)
719
		return git__throw(GIT_ERROR, "Failed to format object header. Length is out of bounds");
Vicent Marti committed
720 721 722 723 724 725 726 727
	return len+1;
}

int loose_backend__stream(git_odb_stream **stream_out, git_odb_backend *_backend, size_t length, git_otype type)
{
	loose_backend *backend;
	loose_writestream *stream;

728
	char hdr[64], tmp_path[GIT_PATH_MAX];
729 730 731
	int  hdrlen;
	int error;

Vicent Marti committed
732
	assert(_backend);
733 734

	backend = (loose_backend *)_backend;
Vicent Marti committed
735
	*stream_out = NULL;
736

Vicent Marti committed
737 738
	hdrlen = format_object_header(hdr, sizeof(hdr), length, type);
	if (hdrlen < GIT_SUCCESS)
739
		return git__throw(GIT_EOBJCORRUPTED, "Failed to create loose backend stream. Object is corrupted");
Vicent Marti committed
740 741 742 743

	stream = git__calloc(1, sizeof(loose_writestream));
	if (stream == NULL)
		return GIT_ENOMEM;
744

Vicent Marti committed
745 746 747 748 749 750
	stream->stream.backend = _backend;
	stream->stream.read = NULL; /* read only */
	stream->stream.write = &loose_backend__stream_write;
	stream->stream.finalize_write = &loose_backend__stream_fwrite;
	stream->stream.free = &loose_backend__stream_free;
	stream->stream.mode = GIT_STREAM_WRONLY;
751

Vicent Marti committed
752
	git_path_join(tmp_path, backend->objects_dir, "tmp_object");
753 754

	error = git_filebuf_open(&stream->fbuf, tmp_path,
Vicent Marti committed
755 756 757 758 759 760
		GIT_FILEBUF_HASH_CONTENTS |
		GIT_FILEBUF_DEFLATE_CONTENTS |
		GIT_FILEBUF_TEMPORARY);

	if (error < GIT_SUCCESS) {
		free(stream);
761
		return git__rethrow(error, "Failed to create loose backend stream");
Vicent Marti committed
762
	}
763

Vicent Marti committed
764 765 766 767
	error = stream->stream.write((git_odb_stream *)stream, hdr, hdrlen);
	if (error < GIT_SUCCESS) {
		git_filebuf_cleanup(&stream->fbuf);
		free(stream);
768
		return git__rethrow(error, "Failed to create loose backend stream");
Vicent Marti committed
769
	}
770

Vicent Marti committed
771 772
	*stream_out = (git_odb_stream *)stream;
	return GIT_SUCCESS;
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 816 817
int loose_backend__write(git_oid *oid, git_odb_backend *_backend, const void *data, size_t len, git_otype type)
{
	int error, header_len;
	char final_path[GIT_PATH_MAX], header[64];
	git_filebuf fbuf;
	loose_backend *backend;

	backend = (loose_backend *)_backend;

	/* prepare the header for the file */
	{
		header_len = format_object_header(header, sizeof(header), len, type);
		if (header_len < GIT_SUCCESS)
			return GIT_EOBJCORRUPTED;
	}

	git_path_join(final_path, backend->objects_dir, "tmp_object");

	error = git_filebuf_open(&fbuf, final_path,
		GIT_FILEBUF_HASH_CONTENTS |
		GIT_FILEBUF_DEFLATE_CONTENTS |
		GIT_FILEBUF_TEMPORARY);

	if (error < GIT_SUCCESS)
		return error;

	git_filebuf_write(&fbuf, header, header_len);
	git_filebuf_write(&fbuf, data, len);
	git_filebuf_hash(oid, &fbuf);

	if ((error = object_file_name(final_path, sizeof(final_path), backend->objects_dir, oid)) < GIT_SUCCESS)
		goto cleanup;

	if ((error = git_futils_mkpath2file(final_path)) < GIT_SUCCESS)
		goto cleanup;

	return git_filebuf_commit_at(&fbuf, final_path);

cleanup:
	git_filebuf_cleanup(&fbuf);
	return error;
}

818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845
void loose_backend__free(git_odb_backend *_backend)
{
	loose_backend *backend;
	assert(_backend);
	backend = (loose_backend *)_backend;

	free(backend->objects_dir);
	free(backend);
}

int git_odb_backend_loose(git_odb_backend **backend_out, const char *objects_dir)
{
	loose_backend *backend;

	backend = git__calloc(1, sizeof(loose_backend));
	if (backend == NULL)
		return GIT_ENOMEM;

	backend->objects_dir = git__strdup(objects_dir);
	if (backend->objects_dir == NULL) {
		free(backend);
		return GIT_ENOMEM;
	}

	backend->object_zlib_level = Z_BEST_SPEED;
	backend->fsync_object_files = 0;

	backend->parent.read = &loose_backend__read;
846
	backend->parent.write = &loose_backend__write;
Vicent Marti committed
847
	backend->parent.read_prefix = &loose_backend__read_prefix;
848
	backend->parent.read_header = &loose_backend__read_header;
Vicent Marti committed
849
	backend->parent.writestream = &loose_backend__stream;
850 851 852 853 854 855
	backend->parent.exists = &loose_backend__exists;
	backend->parent.free = &loose_backend__free;

	*backend_out = (git_odb_backend *)backend;
	return GIT_SUCCESS;
}