blob.c 11.6 KB
Newer Older
1
/*
Edward Thomson committed
2
 * Copyright (C) the libgit2 contributors. All rights reserved.
3
 *
Vicent Marti committed
4 5
 * This file is part of libgit2, distributed under the GNU GPL v2 with
 * a Linking Exception. For full terms see the included COPYING file.
6 7
 */

8 9
#include "blob.h"

10 11 12
#include "git2/common.h"
#include "git2/object.h"
#include "git2/repository.h"
13
#include "git2/odb_backend.h"
14

15
#include "filebuf.h"
16
#include "filter.h"
17
#include "buf_text.h"
18

19
const void *git_blob_rawcontent(const git_blob *blob)
20
{
21
	assert(blob);
22 23 24 25
	if (blob->raw)
		return blob->data.raw.data;
	else
		return git_odb_object_data(blob->data.odb);
26 27
}

28
git_object_size_t git_blob_rawsize(const git_blob *blob)
29 30
{
	assert(blob);
31 32 33
	if (blob->raw)
		return blob->data.raw.size;
	else
34
		return (git_object_size_t)git_odb_object_size(blob->data.odb);
35 36
}

37 38
int git_blob__getbuf(git_buf *buffer, git_blob *blob)
{
39
	git_object_size_t size = git_blob_rawsize(blob);
40 41 42

	GIT_ERROR_CHECK_BLOBSIZE(size);
	return git_buf_set(buffer, git_blob_rawcontent(blob), (size_t)size);
43 44
}

45
void git_blob__free(void *_blob)
46
{
47 48 49
	git_blob *blob = (git_blob *) _blob;
	if (!blob->raw)
		git_odb_object_free(blob->data.odb);
50
	git__free(blob);
51 52
}

53
int git_blob__parse_raw(void *_blob, const char *data, size_t size)
54
{
55 56 57 58 59 60 61 62 63 64 65
	git_blob *blob = (git_blob *) _blob;
	assert(blob);
	blob->raw = 1;
	blob->data.raw.data = data;
	blob->data.raw.size = size;
	return 0;
}

int git_blob__parse(void *_blob, git_odb_object *odb_obj)
{
	git_blob *blob = (git_blob *) _blob;
66
	assert(blob);
Vicent Marti committed
67
	git_cached_obj_incref((git_cached_obj *)odb_obj);
68 69
	blob->raw = 0;
	blob->data.odb = odb_obj;
70
	return 0;
71 72
}

73
int git_blob_create_from_buffer(
74
	git_oid *id, git_repository *repo, const void *buffer, size_t len)
75
{
Vicent Marti committed
76
	int error;
77
	git_odb *odb;
Vicent Marti committed
78
	git_odb_stream *stream;
79

80 81
	assert(id && repo);

82
	if ((error = git_repository_odb__weakptr(&odb, repo)) < 0 ||
83
		(error = git_odb_open_wstream(&stream, odb, len, GIT_OBJECT_BLOB)) < 0)
84 85
		return error;

86
	if ((error = git_odb_stream_write(stream, buffer, len)) == 0)
87
		error = git_odb_stream_finalize_write(id, stream);
88

89
	git_odb_stream_free(stream);
90
	return error;
91 92
}

93
static int write_file_stream(
94
	git_oid *id, git_odb *odb, const char *path, git_object_size_t file_size)
95 96
{
	int fd, error;
97
	char buffer[FILEIO_BUFSIZE];
98
	git_odb_stream *stream = NULL;
99
	ssize_t read_len = -1;
100
	git_object_size_t written = 0;
101

102
	if ((error = git_odb_open_wstream(
103
			&stream, odb, file_size, GIT_OBJECT_BLOB)) < 0)
104 105
		return error;

106
	if ((fd = git_futils_open_ro(path)) < 0) {
107
		git_odb_stream_free(stream);
108
		return -1;
109 110
	}

Vicent Marti committed
111
	while (!error && (read_len = p_read(fd, buffer, sizeof(buffer))) > 0) {
112
		error = git_odb_stream_write(stream, buffer, read_len);
Vicent Marti committed
113
		written += read_len;
114 115 116 117
	}

	p_close(fd);

Vicent Marti committed
118
	if (written != file_size || read_len < 0) {
119
		git_error_set(GIT_ERROR_OS, "failed to read file into stream");
Vicent Marti committed
120 121 122
		error = -1;
	}

123
	if (!error)
124
		error = git_odb_stream_finalize_write(id, stream);
125

126
	git_odb_stream_free(stream);
127 128 129 130
	return error;
}

static int write_file_filtered(
131
	git_oid *id,
132
	git_object_size_t *size,
133
	git_odb *odb,
134
	const char *full_path,
135
	git_filter_list *fl)
136 137
{
	int error;
138
	git_buf tgt = GIT_BUF_INIT;
139

140
	error = git_filter_list_apply_to_file(&tgt, fl, NULL, full_path);
141

142
	/* Write the file to disk if it was properly filtered */
143
	if (!error) {
144
		*size = tgt.size;
145

146
		error = git_odb_write(id, odb, tgt.ptr, tgt.size, GIT_OBJECT_BLOB);
147
	}
148

149
	git_buf_dispose(&tgt);
150
	return error;
151 152
}

153
static int write_symlink(
154
	git_oid *id, git_odb *odb, const char *path, size_t link_size)
155 156 157 158 159 160
{
	char *link_data;
	ssize_t read_len;
	int error;

	link_data = git__malloc(link_size);
161
	GIT_ERROR_CHECK_ALLOC(link_data);
162 163 164

	read_len = p_readlink(path, link_data, link_size);
	if (read_len != (ssize_t)link_size) {
165
		git_error_set(GIT_ERROR_OS, "failed to create blob: cannot read symlink '%s'", path);
166
		git__free(link_data);
167
		return -1;
168 169
	}

170
	error = git_odb_write(id, odb, (void *)link_data, link_size, GIT_OBJECT_BLOB);
171
	git__free(link_data);
172 173 174
	return error;
}

175
int git_blob__create_from_paths(
176
	git_oid *id,
177 178 179 180 181 182
	struct stat *out_st,
	git_repository *repo,
	const char *content_path,
	const char *hint_path,
	mode_t hint_mode,
	bool try_load_filters)
183
{
184
	int error;
185
	struct stat st;
186
	git_odb *odb = NULL;
187
	git_object_size_t size;
188 189
	mode_t mode;
	git_buf path = GIT_BUF_INIT;
190

191 192
	assert(hint_path || !try_load_filters);

193 194 195 196 197 198 199 200 201 202 203 204 205 206 207
	if (!content_path) {
		if (git_repository__ensure_not_bare(repo, "create blob from file") < 0)
			return GIT_EBAREREPO;

		if (git_buf_joinpath(
				&path, git_repository_workdir(repo), hint_path) < 0)
			return -1;

		content_path = path.ptr;
	}

	if ((error = git_path_lstat(content_path, &st)) < 0 ||
		(error = git_repository_odb(&odb, repo)) < 0)
		goto done;

208
	if (S_ISDIR(st.st_mode)) {
209
		git_error_set(GIT_ERROR_ODB, "cannot create blob from '%s': it is a directory", content_path);
210 211 212 213
		error = GIT_EDIRECTORY;
		goto done;
	}

214 215
	if (out_st)
		memcpy(out_st, &st, sizeof(st));
216

217
	size = st.st_size;
218
	mode = hint_mode ? hint_mode : st.st_mode;
219

Russell Belfer committed
220
	if (S_ISLNK(mode)) {
221
		error = write_symlink(id, odb, content_path, (size_t)size);
222
	} else {
223
		git_filter_list *fl = NULL;
224

225
		if (try_load_filters)
226
			/* Load the filters for writing this file to the ODB */
227
			error = git_filter_list_load(
228
				&fl, repo, NULL, hint_path,
229
				GIT_FILTER_TO_ODB, GIT_FILTER_DEFAULT);
230

231 232 233
		if (error < 0)
			/* well, that didn't work */;
		else if (fl == NULL)
234 235
			/* No filters need to be applied to the document: we can stream
			 * directly from disk */
236
			error = write_file_stream(id, odb, content_path, size);
237
		else {
238
			/* We need to apply one or more filters */
239
			error = write_file_filtered(id, &size, odb, content_path, fl);
240

241 242
			git_filter_list_free(fl);
		}
243

244
		/*
245 246 247 248 249
		 * TODO: eventually support streaming filtered files, for files
		 * which are bigger than a given threshold. This is not a priority
		 * because applying a filter in streaming mode changes the final
		 * size of the blob, and without knowing its final size, the blob
		 * cannot be written in stream mode to the ODB.
250
		 *
251 252 253
		 * The plan is to do streaming writes to a tempfile on disk and then
		 * opening streaming that file to the ODB, using
		 * `write_file_stream`.
254 255 256
		 *
		 * CAREFULLY DESIGNED APIS YO
		 */
Vicent Marti committed
257 258
	}

259 260
done:
	git_odb_free(odb);
261
	git_buf_dispose(&path);
262

263 264 265
	return error;
}

266
int git_blob_create_from_workdir(
267
	git_oid *id, git_repository *repo, const char *path)
268
{
269
	return git_blob__create_from_paths(id, NULL, repo, NULL, path, 0, true);
270 271
}

272
int git_blob_create_from_disk(
273
	git_oid *id, git_repository *repo, const char *path)
274 275 276
{
	int error;
	git_buf full_path = GIT_BUF_INIT;
277
	const char *workdir, *hintpath;
278 279

	if ((error = git_path_prettify(&full_path, path, NULL)) < 0) {
280
		git_buf_dispose(&full_path);
281 282 283
		return error;
	}

284 285 286 287 288 289
	hintpath = git_buf_cstr(&full_path);
	workdir  = git_repository_workdir(repo);

	if (workdir && !git__prefixcmp(hintpath, workdir))
		hintpath += strlen(workdir);

290
	error = git_blob__create_from_paths(
291
		id, NULL, repo, git_buf_cstr(&full_path), hintpath, 0, true);
292

293
	git_buf_dispose(&full_path);
294 295
	return error;
}
296

297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327
typedef struct {
	git_writestream parent;
	git_filebuf fbuf;
	git_repository *repo;
	char *hintpath;
} blob_writestream;

static int blob_writestream_close(git_writestream *_stream)
{
	blob_writestream *stream = (blob_writestream *) _stream;

	git_filebuf_cleanup(&stream->fbuf);
	return 0;
}

static void blob_writestream_free(git_writestream *_stream)
{
	blob_writestream *stream = (blob_writestream *) _stream;

	git_filebuf_cleanup(&stream->fbuf);
	git__free(stream->hintpath);
	git__free(stream);
}

static int blob_writestream_write(git_writestream *_stream, const char *buffer, size_t len)
{
	blob_writestream *stream = (blob_writestream *) _stream;

	return git_filebuf_write(&stream->fbuf, buffer, len);
}

328
int git_blob_create_from_stream(git_writestream **out, git_repository *repo, const char *hintpath)
329 330 331 332 333 334 335 336
{
	int error;
	git_buf path = GIT_BUF_INIT;
	blob_writestream *stream;

	assert(out && repo);

	stream = git__calloc(1, sizeof(blob_writestream));
337
	GIT_ERROR_CHECK_ALLOC(stream);
338 339 340

	if (hintpath) {
		stream->hintpath = git__strdup(hintpath);
341
		GIT_ERROR_CHECK_ALLOC(stream->hintpath);
342 343 344 345 346 347 348
	}

	stream->repo = repo;
	stream->parent.write = blob_writestream_write;
	stream->parent.close = blob_writestream_close;
	stream->parent.free  = blob_writestream_free;

349 350
	if ((error = git_repository_item_path(&path, repo, GIT_REPOSITORY_ITEM_OBJECTS)) < 0
		|| (error = git_buf_joinpath(&path, path.ptr, "streamed")) < 0)
351 352 353 354 355 356 357 358 359 360 361 362
		goto cleanup;

	if ((error = git_filebuf_open_withsize(&stream->fbuf, git_buf_cstr(&path), GIT_FILEBUF_TEMPORARY,
					       0666, 2 * 1024 * 1024)) < 0)
		goto cleanup;

	*out = (git_writestream *) stream;

cleanup:
	if (error < 0)
		blob_writestream_free((git_writestream *) stream);

363
	git_buf_dispose(&path);
364 365 366
	return error;
}

367
int git_blob_create_from_stream_commit(git_oid *out, git_writestream *_stream)
368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388
{
	int error;
	blob_writestream *stream = (blob_writestream *) _stream;

	/*
	 * We can make this more officient by avoiding writing to
	 * disk, but for now let's re-use the helper functions we
	 * have.
	 */
	if ((error = git_filebuf_flush(&stream->fbuf)) < 0)
		goto cleanup;

	error = git_blob__create_from_paths(out, NULL, stream->repo, stream->fbuf.path_lock,
					    stream->hintpath, 0, !!stream->hintpath);

cleanup:
	blob_writestream_free(_stream);
	return error;

}

Jacques Germishuys committed
389
int git_blob_is_binary(const git_blob *blob)
390
{
391
	git_buf content = GIT_BUF_INIT;
392
	git_object_size_t size;
393 394 395

	assert(blob);

396 397
	size = git_blob_rawsize(blob);

398
	git_buf_attach_notowned(&content, git_blob_rawcontent(blob),
399
		(size_t)min(size, GIT_FILTER_BYTES_TO_CHECK_NUL));
400 401
	return git_buf_text_is_binary(&content);
}
402

403
int git_blob_filter(
404
	git_buf *out,
405
	git_blob *blob,
Russell Belfer committed
406
	const char *path,
407
	git_blob_filter_options *given_opts)
408
{
409 410
	int error = 0;
	git_filter_list *fl = NULL;
411 412
	git_blob_filter_options opts = GIT_BLOB_FILTER_OPTIONS_INIT;
	git_filter_flag_t flags = GIT_FILTER_DEFAULT;
413

Russell Belfer committed
414
	assert(blob && path && out);
415

416 417
	git_buf_sanitize(out);

418 419 420 421 422 423 424 425
	GIT_ERROR_CHECK_VERSION(
		given_opts, GIT_BLOB_FILTER_OPTIONS_VERSION, "git_blob_filter_options");

	if (given_opts != NULL)
		memcpy(&opts, given_opts, sizeof(git_blob_filter_options));

	if ((opts.flags & GIT_BLOB_FILTER_CHECK_FOR_BINARY) != 0 &&
	    git_blob_is_binary(blob))
426 427
		return 0;

428 429 430
	if ((opts.flags & GIT_BLOB_FILTER_NO_SYSTEM_ATTRIBUTES) != 0)
		flags |= GIT_FILTER_NO_SYSTEM_ATTRIBUTES;

431 432 433
	if ((opts.flags & GIT_BLOB_FILTER_ATTTRIBUTES_FROM_HEAD) != 0)
		flags |= GIT_FILTER_ATTRIBUTES_FROM_HEAD;

434
	if (!(error = git_filter_list_load(
435
			&fl, git_blob_owner(blob), blob, path,
436
			GIT_FILTER_TO_WORKTREE, flags))) {
437

438
		error = git_filter_list_apply_to_blob(out, fl, blob);
439

440
		git_filter_list_free(fl);
441 442 443 444
	}

	return error;
}
445 446 447

/* Deprecated functions */

448
#ifndef GIT_DEPRECATE_HARD
449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478
int git_blob_create_frombuffer(
	git_oid *id, git_repository *repo, const void *buffer, size_t len)
{
	return git_blob_create_from_buffer(id, repo, buffer, len);
}

int git_blob_create_fromworkdir(git_oid *id, git_repository *repo, const char *relative_path)
{
	return git_blob_create_from_workdir(id, repo, relative_path);
}

int git_blob_create_fromdisk(git_oid *id, git_repository *repo, const char *path)
{
	return git_blob_create_from_disk(id, repo, path);
}

int git_blob_create_fromstream(
    git_writestream **out,
    git_repository *repo,
    const char *hintpath)
{
	return  git_blob_create_from_stream(out, repo, hintpath);
}

int git_blob_create_fromstream_commit(
	git_oid *out,
	git_writestream *stream)
{
	return git_blob_create_from_stream_commit(out, stream);
}
479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494

int git_blob_filtered_content(
	git_buf *out,
	git_blob *blob,
	const char *path,
	int check_for_binary_data)
{
	git_blob_filter_options opts = GIT_BLOB_FILTER_OPTIONS_INIT;

	if (check_for_binary_data)
		opts.flags |= GIT_BLOB_FILTER_CHECK_FOR_BINARY;
	else
		opts.flags &= ~GIT_BLOB_FILTER_CHECK_FOR_BINARY;

	return git_blob_filter(out, blob, path, &opts);
}
495
#endif