thodg/libgit2/src/diff_file.c

• Show log

  Commit

• Hash : 0c7f49dd
  Author :
  Date : 2017-06-30T13:39:01
  

  Make sure to always include "common.h" first Next to including several files, our "common.h" header also declares various macros which are then used throughout the project. As such, we have to make sure to always include this file first in all implementation files. Otherwise, we might encounter problems or even silent behavioural differences due to macros or defines not being defined as they should be. So in fact, our header and implementation files should make sure to always include "common.h" first. This commit does so by establishing a common include pattern. Header files inside of "src" will now always include "common.h" as its first other file, separated by a newline from all the other includes to make it stand out as special. There are two cases for the implementation files. If they do have a matching header file, they will always include this one first, leading to "common.h" being transitively included as first file. If they do not have a matching header file, they instead include "common.h" as first file themselves. This fixes the outlined problems and will become our standard practice for header and source files inside of the "src/" from now on.

Download

• src/diff_file.c

• /*
   * Copyright (C) the libgit2 contributors. All rights reserved.
   *
   * This file is part of libgit2, distributed under the GNU GPL v2 with
   * a Linking Exception. For full terms see the included COPYING file.
   */
  
  #include "diff_file.h"
  
  #include "git2/blob.h"
  #include "git2/submodule.h"
  #include "diff.h"
  #include "diff_generate.h"
  #include "odb.h"
  #include "fileops.h"
  #include "filter.h"
  
  #define DIFF_MAX_FILESIZE 0x20000000
  
  static bool diff_file_content_binary_by_size(git_diff_file_content *fc)
  {
  	/* if we have diff opts, check max_size vs file size */
  	if ((fc->file->flags & DIFF_FLAGS_KNOWN_BINARY) == 0 &&
  		fc->opts_max_size > 0 &&
  		fc->file->size > fc->opts_max_size)
  		fc->file->flags |= GIT_DIFF_FLAG_BINARY;
  
  	return ((fc->file->flags & GIT_DIFF_FLAG_BINARY) != 0);
  }
  
  static void diff_file_content_binary_by_content(git_diff_file_content *fc)
  {
  	if ((fc->file->flags & DIFF_FLAGS_KNOWN_BINARY) != 0)
  		return;
  
  	switch (git_diff_driver_content_is_binary(
  		fc->driver, fc->map.data, fc->map.len)) {
  	case 0: fc->file->flags |= GIT_DIFF_FLAG_NOT_BINARY; break;
  	case 1: fc->file->flags |= GIT_DIFF_FLAG_BINARY; break;
  	default: break;
  	}
  }
  
  static int diff_file_content_init_common(
  	git_diff_file_content *fc, const git_diff_options *opts)
  {
  	fc->opts_flags = opts ? opts->flags : GIT_DIFF_NORMAL;
  
  	if (opts && opts->max_size >= 0)
  		fc->opts_max_size = opts->max_size ?
  			opts->max_size : DIFF_MAX_FILESIZE;
  
  	if (fc->src == GIT_ITERATOR_TYPE_EMPTY)
  		fc->src = GIT_ITERATOR_TYPE_TREE;
  
  	if (!fc->driver &&
  		git_diff_driver_lookup(&fc->driver, fc->repo, fc->file->path) < 0)
  		return -1;
  
  	/* give driver a chance to modify options */
  	git_diff_driver_update_options(&fc->opts_flags, fc->driver);
  
  	/* make sure file is conceivable mmap-able */
  	if ((git_off_t)((size_t)fc->file->size) != fc->file->size)
  		fc->file->flags |= GIT_DIFF_FLAG_BINARY;
  	/* check if user is forcing text diff the file */
  	else if (fc->opts_flags & GIT_DIFF_FORCE_TEXT) {
  		fc->file->flags &= ~GIT_DIFF_FLAG_BINARY;
  		fc->file->flags |= GIT_DIFF_FLAG_NOT_BINARY;
  	}
  	/* check if user is forcing binary diff the file */
  	else if (fc->opts_flags & GIT_DIFF_FORCE_BINARY) {
  		fc->file->flags &= ~GIT_DIFF_FLAG_NOT_BINARY;
  		fc->file->flags |= GIT_DIFF_FLAG_BINARY;
  	}
  
  	diff_file_content_binary_by_size(fc);
  
  	if ((fc->flags & GIT_DIFF_FLAG__NO_DATA) != 0) {
  		fc->flags |= GIT_DIFF_FLAG__LOADED;
  		fc->map.len  = 0;
  		fc->map.data = "";
  	}
  
  	if ((fc->flags & GIT_DIFF_FLAG__LOADED) != 0)
  		diff_file_content_binary_by_content(fc);
  
  	return 0;
  }
  
  int git_diff_file_content__init_from_diff(
  	git_diff_file_content *fc,
  	git_diff *diff,
  	git_diff_delta *delta,
  	bool use_old)
  {
  	bool has_data = true;
  
  	memset(fc, 0, sizeof(*fc));
  	fc->repo = diff->repo;
  	fc->file = use_old ? &delta->old_file : &delta->new_file;
  	fc->src  = use_old ? diff->old_src : diff->new_src;
  
  	if (git_diff_driver_lookup(&fc->driver, fc->repo, fc->file->path) < 0)
  		return -1;
  
  	switch (delta->status) {
  	case GIT_DELTA_ADDED:
  		has_data = !use_old; break;
  	case GIT_DELTA_DELETED:
  		has_data = use_old; break;
  	case GIT_DELTA_UNTRACKED:
  		has_data = !use_old &&
  			(diff->opts.flags & GIT_DIFF_SHOW_UNTRACKED_CONTENT) != 0;
  		break;
  	case GIT_DELTA_UNREADABLE:
  	case GIT_DELTA_MODIFIED:
  	case GIT_DELTA_COPIED:
  	case GIT_DELTA_RENAMED:
  		break;
  	default:
  		has_data = false;
  		break;
  	}
  
  	if (!has_data)
  		fc->flags |= GIT_DIFF_FLAG__NO_DATA;
  
  	return diff_file_content_init_common(fc, &diff->opts);
  }
  
  int git_diff_file_content__init_from_src(
  	git_diff_file_content *fc,
  	git_repository *repo,
  	const git_diff_options *opts,
  	const git_diff_file_content_src *src,
  	git_diff_file *as_file)
  {
  	memset(fc, 0, sizeof(*fc));
  	fc->repo = repo;
  	fc->file = as_file;
  	fc->blob = src->blob;
  
  	if (!src->blob && !src->buf) {
  		fc->flags |= GIT_DIFF_FLAG__NO_DATA;
  	} else {
  		fc->flags |= GIT_DIFF_FLAG__LOADED;
  		fc->file->flags |= GIT_DIFF_FLAG_VALID_ID;
  		fc->file->mode = GIT_FILEMODE_BLOB;
  
  		if (src->blob) {
  			fc->file->size = git_blob_rawsize(src->blob);
  			git_oid_cpy(&fc->file->id, git_blob_id(src->blob));
  			fc->file->id_abbrev = GIT_OID_HEXSZ;
  
  			fc->map.len  = (size_t)fc->file->size;
  			fc->map.data = (char *)git_blob_rawcontent(src->blob);
  		} else {
  			fc->file->size = src->buflen;
  			git_odb_hash(&fc->file->id, src->buf, src->buflen, GIT_OBJ_BLOB);
  			fc->file->id_abbrev = GIT_OID_HEXSZ;
  
  			fc->map.len  = src->buflen;
  			fc->map.data = (char *)src->buf;
  		}
  	}
  
  	return diff_file_content_init_common(fc, opts);
  }
  
  static int diff_file_content_commit_to_str(
  	git_diff_file_content *fc, bool check_status)
  {
  	char oid[GIT_OID_HEXSZ+1];
  	git_buf content = GIT_BUF_INIT;
  	const char *status = "";
  
  	if (check_status) {
  		int error = 0;
  		git_submodule *sm = NULL;
  		unsigned int sm_status = 0;
  		const git_oid *sm_head;
  
  		if ((error = git_submodule_lookup(&sm, fc->repo, fc->file->path)) < 0) {
  			/* GIT_EEXISTS means a "submodule" that has not been git added */
  			if (error == GIT_EEXISTS) {
  				giterr_clear();
  				error = 0;
  			}
  			return error;
  		}
  
  		if ((error = git_submodule_status(&sm_status, fc->repo, fc->file->path, GIT_SUBMODULE_IGNORE_UNSPECIFIED)) < 0) {
  			git_submodule_free(sm);
  			return error;
  		}
  
  		/* update OID if we didn't have it previously */
  		if ((fc->file->flags & GIT_DIFF_FLAG_VALID_ID) == 0 &&
  			((sm_head = git_submodule_wd_id(sm)) != NULL ||
  			 (sm_head = git_submodule_head_id(sm)) != NULL))
  		{
  			git_oid_cpy(&fc->file->id, sm_head);
  			fc->file->flags |= GIT_DIFF_FLAG_VALID_ID;
  		}
  
  		if (GIT_SUBMODULE_STATUS_IS_WD_DIRTY(sm_status))
  			status = "-dirty";
  
  		git_submodule_free(sm);
  	}
  
  	git_oid_tostr(oid, sizeof(oid), &fc->file->id);
  	if (git_buf_printf(&content, "Subproject commit %s%s\n", oid, status) < 0)
  		return -1;
  
  	fc->map.len  = git_buf_len(&content);
  	fc->map.data = git_buf_detach(&content);
  	fc->flags |= GIT_DIFF_FLAG__FREE_DATA;
  
  	return 0;
  }
  
  static int diff_file_content_load_blob(
  	git_diff_file_content *fc,
  	git_diff_options *opts)
  {
  	int error = 0;
  	git_odb_object *odb_obj = NULL;
  
  	if (git_oid_iszero(&fc->file->id))
  		return 0;
  
  	if (fc->file->mode == GIT_FILEMODE_COMMIT)
  		return diff_file_content_commit_to_str(fc, false);
  
  	/* if we don't know size, try to peek at object header first */
  	if (!fc->file->size) {
  		if ((error = git_diff_file__resolve_zero_size(
  				fc->file, &odb_obj, fc->repo)) < 0)
  			return error;
  	}
  
  	if ((opts->flags & GIT_DIFF_SHOW_BINARY) == 0 &&
  		diff_file_content_binary_by_size(fc))
  		return 0;
  
  	if (odb_obj != NULL) {
  		error = git_object__from_odb_object(
  			(git_object **)&fc->blob, fc->repo, odb_obj, GIT_OBJ_BLOB);
  		git_odb_object_free(odb_obj);
  	} else {
  		error = git_blob_lookup(
  			(git_blob **)&fc->blob, fc->repo, &fc->file->id);
  	}
  
  	if (!error) {
  		fc->flags |= GIT_DIFF_FLAG__FREE_BLOB;
  		fc->map.data = (void *)git_blob_rawcontent(fc->blob);
  		fc->map.len  = (size_t)git_blob_rawsize(fc->blob);
  	}
  
  	return error;
  }
  
  static int diff_file_content_load_workdir_symlink_fake(
  	git_diff_file_content *fc, git_buf *path)
  {
  	git_buf target = GIT_BUF_INIT;
  	int error;
  
  	if ((error = git_futils_readbuffer(&target, path->ptr)) < 0)
  		return error;
  
  	fc->map.len = git_buf_len(&target);
  	fc->map.data = git_buf_detach(&target);
  	fc->flags |= GIT_DIFF_FLAG__FREE_DATA;
  
  	git_buf_free(&target);
  	return error;
  }
  
  static int diff_file_content_load_workdir_symlink(
  	git_diff_file_content *fc, git_buf *path)
  {
  	ssize_t alloc_len, read_len;
  	int symlink_supported, error;
  
  	if ((error = git_repository__cvar(
  		&symlink_supported, fc->repo, GIT_CVAR_SYMLINKS)) < 0)
  		return -1;
  
  	if (!symlink_supported)
  		return diff_file_content_load_workdir_symlink_fake(fc, path);
  
  	/* link path on disk could be UTF-16, so prepare a buffer that is
  	 * big enough to handle some UTF-8 data expansion
  	 */
  	alloc_len = (ssize_t)(fc->file->size * 2) + 1;
  
  	fc->map.data = git__calloc(alloc_len, sizeof(char));
  	GITERR_CHECK_ALLOC(fc->map.data);
  
  	fc->flags |= GIT_DIFF_FLAG__FREE_DATA;
  
  	read_len = p_readlink(git_buf_cstr(path), fc->map.data, alloc_len);
  	if (read_len < 0) {
  		giterr_set(GITERR_OS, "failed to read symlink '%s'", fc->file->path);
  		return -1;
  	}
  
  	fc->map.len = read_len;
  	return 0;
  }
  
  static int diff_file_content_load_workdir_file(
  	git_diff_file_content *fc,
  	git_buf *path,
  	git_diff_options *diff_opts)
  {
  	int error = 0;
  	git_filter_list *fl = NULL;
  	git_file fd = git_futils_open_ro(git_buf_cstr(path));
  	git_buf raw = GIT_BUF_INIT;
  
  	if (fd < 0)
  		return fd;
  
  	if (!fc->file->size &&
  		!(fc->file->size = git_futils_filesize(fd)))
  		goto cleanup;
  
  	if ((diff_opts->flags & GIT_DIFF_SHOW_BINARY) == 0 &&
  		diff_file_content_binary_by_size(fc))
  		goto cleanup;
  
  	if ((error = git_filter_list_load(
  			&fl, fc->repo, NULL, fc->file->path,
  			GIT_FILTER_TO_ODB, GIT_FILTER_ALLOW_UNSAFE)) < 0)
  		goto cleanup;
  
  	/* if there are no filters, try to mmap the file */
  	if (fl == NULL) {
  		if (!(error = git_futils_mmap_ro(
  				&fc->map, fd, 0, (size_t)fc->file->size))) {
  			fc->flags |= GIT_DIFF_FLAG__UNMAP_DATA;
  			goto cleanup;
  		}
  
  		/* if mmap failed, fall through to try readbuffer below */
  		giterr_clear();
  	}
  
  	if (!(error = git_futils_readbuffer_fd(&raw, fd, (size_t)fc->file->size))) {
  		git_buf out = GIT_BUF_INIT;
  
  		error = git_filter_list_apply_to_data(&out, fl, &raw);
  
  		if (out.ptr != raw.ptr)
  			git_buf_free(&raw);
  
  		if (!error) {
  			fc->map.len  = out.size;
  			fc->map.data = out.ptr;
  			fc->flags |= GIT_DIFF_FLAG__FREE_DATA;
  		}
  	}
  
  cleanup:
  	git_filter_list_free(fl);
  	p_close(fd);
  
  	return error;
  }
  
  static int diff_file_content_load_workdir(
  	git_diff_file_content *fc,
  	git_diff_options *diff_opts)
  {
  	int error = 0;
  	git_buf path = GIT_BUF_INIT;
  
  	if (fc->file->mode == GIT_FILEMODE_COMMIT)
  		return diff_file_content_commit_to_str(fc, true);
  
  	if (fc->file->mode == GIT_FILEMODE_TREE)
  		return 0;
  
  	if (git_buf_joinpath(
  			&path, git_repository_workdir(fc->repo), fc->file->path) < 0)
  		return -1;
  
  	if (S_ISLNK(fc->file->mode))
  		error = diff_file_content_load_workdir_symlink(fc, &path);
  	else
  		error = diff_file_content_load_workdir_file(fc, &path, diff_opts);
  
  	/* once data is loaded, update OID if we didn't have it previously */
  	if (!error && (fc->file->flags & GIT_DIFF_FLAG_VALID_ID) == 0) {
  		error = git_odb_hash(
  			&fc->file->id, fc->map.data, fc->map.len, GIT_OBJ_BLOB);
  		fc->file->flags |= GIT_DIFF_FLAG_VALID_ID;
  	}
  
  	git_buf_free(&path);
  	return error;
  }
  
  int git_diff_file_content__load(
  	git_diff_file_content *fc,
  	git_diff_options *diff_opts)
  {
  	int error = 0;
  
  	if ((fc->flags & GIT_DIFF_FLAG__LOADED) != 0)
  		return 0;
  
  	if ((fc->file->flags & GIT_DIFF_FLAG_BINARY) != 0 &&
  		(diff_opts->flags & GIT_DIFF_SHOW_BINARY) == 0)
  		return 0;
  
  	if (fc->src == GIT_ITERATOR_TYPE_WORKDIR)
  		error = diff_file_content_load_workdir(fc, diff_opts);
  	else
  		error = diff_file_content_load_blob(fc, diff_opts);
  	if (error)
  		return error;
  
  	fc->flags |= GIT_DIFF_FLAG__LOADED;
  
  	diff_file_content_binary_by_content(fc);
  
  	return 0;
  }
  
  void git_diff_file_content__unload(git_diff_file_content *fc)
  {
  	if ((fc->flags & GIT_DIFF_FLAG__LOADED) == 0)
  		return;
  
  	if (fc->flags & GIT_DIFF_FLAG__FREE_DATA) {
  		git__free(fc->map.data);
  		fc->map.data = "";
  		fc->map.len  = 0;
  		fc->flags &= ~GIT_DIFF_FLAG__FREE_DATA;
  	}
  	else if (fc->flags & GIT_DIFF_FLAG__UNMAP_DATA) {
  		git_futils_mmap_free(&fc->map);
  		fc->map.data = "";
  		fc->map.len  = 0;
  		fc->flags &= ~GIT_DIFF_FLAG__UNMAP_DATA;
  	}
  
  	if (fc->flags & GIT_DIFF_FLAG__FREE_BLOB) {
  		git_blob_free((git_blob *)fc->blob);
  		fc->blob = NULL;
  		fc->flags &= ~GIT_DIFF_FLAG__FREE_BLOB;
  	}
  
  	fc->flags &= ~GIT_DIFF_FLAG__LOADED;
  }
  
  void git_diff_file_content__clear(git_diff_file_content *fc)
  {
  	git_diff_file_content__unload(fc);
  
  	/* for now, nothing else to do */
  }
  

Download