From: Junio C Hamano <gitster@pobox.com>
Date: Tue, 10 Apr 2018 07:28:20 +0000 (+0900)
Subject: Merge branch 'nd/remove-ignore-env-field'
X-Git-Tag: v2.18.0-rc0~158
X-Git-Url: https://git.lorimer.id.au/gitweb.git/diff_plain/0873c393c750d32a111ee66ab4ca4d7d21bee0ba?ds=inline;hp=-c

Merge branch 'nd/remove-ignore-env-field'

Code clean-up for the "repository" abstraction.

* nd/remove-ignore-env-field:
repository.h: add comment and clarify repo_set_gitdir
repository: delete ignore_env member
sha1_file.c: move delayed getenv(altdb) back to setup_git_env()
repository.c: delete dead functions
repository.c: move env-related setup code back to environment.c
repository: initialize the_repository in main()
---

0873c393c750d32a111ee66ab4ca4d7d21bee0ba
diff --combined cache.h
index 83ba2d2b03,41ba67cc16..6e45c1b537
--- a/cache.h
+++ b/cache.h
@@@ -16,6 -16,31 +16,6 @@@
  #include "sha1-array.h"
  #include "repository.h"
  
 -#ifndef platform_SHA_CTX
 -/*
 - * platform's underlying implementation of SHA-1; could be OpenSSL,
 - * blk_SHA, Apple CommonCrypto, etc...  Note that including
 - * SHA1_HEADER may have already defined platform_SHA_CTX for our
 - * own implementations like block-sha1 and ppc-sha1, so we list
 - * the default for OpenSSL compatible SHA-1 implementations here.
 - */
 -#define platform_SHA_CTX	SHA_CTX
 -#define platform_SHA1_Init	SHA1_Init
 -#define platform_SHA1_Update	SHA1_Update
 -#define platform_SHA1_Final    	SHA1_Final
 -#endif
 -
 -#define git_SHA_CTX		platform_SHA_CTX
 -#define git_SHA1_Init		platform_SHA1_Init
 -#define git_SHA1_Update		platform_SHA1_Update
 -#define git_SHA1_Final		platform_SHA1_Final
 -
 -#ifdef SHA1_MAX_BLOCK_SIZE
 -#include "compat/sha1-chunked.h"
 -#undef git_SHA1_Update
 -#define git_SHA1_Update		git_SHA1_Update_Chunked
 -#endif
 -
  #include <zlib.h>
  typedef struct git_zstream {
  	z_stream z;
@@@ -459,7 -484,7 +459,7 @@@ static inline enum object_type object_t
   */
  extern const char * const local_repo_env[];
  
- extern void setup_git_env(void);
+ extern void setup_git_env(const char *git_dir);
  
  /*
   * Returns true iff we have a configured git repository (either via
@@@ -599,7 -624,6 +599,7 @@@ extern int read_index_unmerged(struct i
  
  /* For use with `write_locked_index()`. */
  #define COMMIT_LOCK		(1 << 0)
 +#define SKIP_IF_UNCHANGED	(1 << 1)
  
  /*
   * Write the index while holding an already-taken lock. Close the lock,
@@@ -616,9 -640,6 +616,9 @@@
   * With `COMMIT_LOCK`, the lock is always committed or rolled back.
   * Without it, the lock is closed, but neither committed nor rolled
   * back.
 + *
 + * If `SKIP_IF_UNCHANGED` is given and the index is unchanged, nothing
 + * is written (and the lock is rolled back if `COMMIT_LOCK` is given).
   */
  extern int write_locked_index(struct index_state *, struct lock_file *lock, unsigned flags);
  
@@@ -955,14 -976,14 +955,14 @@@ extern void sha1_file_name(struct strbu
   * more calls to find_unique_abbrev are made.
   *
   * The `_r` variant writes to a buffer supplied by the caller, which must be at
 - * least `GIT_SHA1_HEXSZ + 1` bytes. The return value is the number of bytes
 + * least `GIT_MAX_HEXSZ + 1` bytes. The return value is the number of bytes
   * written (excluding the NUL terminator).
   *
   * Note that while this version avoids the static buffer, it is not fully
   * reentrant, as it calls into other non-reentrant git code.
   */
 -extern const char *find_unique_abbrev(const unsigned char *sha1, int len);
 -extern int find_unique_abbrev_r(char *hex, const unsigned char *sha1, int len);
 +extern const char *find_unique_abbrev(const struct object_id *oid, int len);
 +extern int find_unique_abbrev_r(char *hex, const struct object_id *oid, int len);
  
  extern const unsigned char null_sha1[GIT_MAX_RAWSZ];
  extern const struct object_id null_oid;
@@@ -1011,7 -1032,7 +1011,7 @@@ static inline void hashclr(unsigned cha
  
  static inline void oidclr(struct object_id *oid)
  {
 -	hashclr(oid->hash);
 +	memset(oid->hash, 0, GIT_MAX_RAWSZ);
  }
  
  
@@@ -1029,6 -1050,8 +1029,6 @@@ extern const struct object_id empty_tre
  	"\xe6\x9d\xe2\x9b\xb2\xd1\xd6\x43\x4b\x8b" \
  	"\x29\xae\x77\x5a\xd8\xc2\xe4\x8c\x53\x91"
  extern const struct object_id empty_blob_oid;
 -#define EMPTY_BLOB_SHA1_BIN (empty_blob_oid.hash)
 -
  
  static inline int is_empty_blob_sha1(const unsigned char *sha1)
  {
@@@ -1189,19 -1212,19 +1189,19 @@@ extern char *xdg_config_home(const cha
   */
  extern char *xdg_cache_home(const char *filename);
  
 -extern void *read_sha1_file_extended(const unsigned char *sha1,
 -				     enum object_type *type,
 -				     unsigned long *size, int lookup_replace);
 -static inline void *read_sha1_file(const unsigned char *sha1, enum object_type *type, unsigned long *size)
 +extern void *read_object_file_extended(const struct object_id *oid,
 +				       enum object_type *type,
 +				       unsigned long *size, int lookup_replace);
 +static inline void *read_object_file(const struct object_id *oid, enum object_type *type, unsigned long *size)
  {
 -	return read_sha1_file_extended(sha1, type, size, 1);
 +	return read_object_file_extended(oid, type, size, 1);
  }
  
  /*
   * This internal function is only declared here for the benefit of
   * lookup_replace_object().  Please do not call it directly.
   */
 -extern const unsigned char *do_lookup_replace_object(const unsigned char *sha1);
 +extern const struct object_id *do_lookup_replace_object(const struct object_id *oid);
  
  /*
   * If object sha1 should be replaced, return the replacement object's
@@@ -1209,50 -1232,39 +1209,50 @@@
   * either sha1 or a pointer to a permanently-allocated value.  When
   * object replacement is suppressed, always return sha1.
   */
 -static inline const unsigned char *lookup_replace_object(const unsigned char *sha1)
 +static inline const struct object_id *lookup_replace_object(const struct object_id *oid)
  {
  	if (!check_replace_refs)
 -		return sha1;
 -	return do_lookup_replace_object(sha1);
 +		return oid;
 +	return do_lookup_replace_object(oid);
  }
  
 -/* Read and unpack a sha1 file into memory, write memory to a sha1 file */
 -extern int sha1_object_info(const unsigned char *, unsigned long *);
 -extern int hash_sha1_file(const void *buf, unsigned long len, const char *type, unsigned char *sha1);
 -extern int write_sha1_file(const void *buf, unsigned long len, const char *type, unsigned char *return_sha1);
 -extern int hash_sha1_file_literally(const void *buf, unsigned long len, const char *type, struct object_id *oid, unsigned flags);
 -extern int pretend_sha1_file(void *, unsigned long, enum object_type, unsigned char *);
 -extern int force_object_loose(const unsigned char *sha1, time_t mtime);
 +/* Read and unpack an object file into memory, write memory to an object file */
 +extern int oid_object_info(const struct object_id *, unsigned long *);
 +
 +extern int hash_object_file(const void *buf, unsigned long len,
 +			    const char *type, struct object_id *oid);
 +
 +extern int write_object_file(const void *buf, unsigned long len,
 +			     const char *type, struct object_id *oid);
 +
 +extern int hash_object_file_literally(const void *buf, unsigned long len,
 +				      const char *type, struct object_id *oid,
 +				      unsigned flags);
 +
 +extern int pretend_object_file(void *, unsigned long, enum object_type,
 +			       struct object_id *oid);
 +
 +extern int force_object_loose(const struct object_id *oid, time_t mtime);
 +
  extern int git_open_cloexec(const char *name, int flags);
  #define git_open(name) git_open_cloexec(name, O_RDONLY)
  extern void *map_sha1_file(const unsigned char *sha1, unsigned long *size);
  extern int unpack_sha1_header(git_zstream *stream, unsigned char *map, unsigned long mapsize, void *buffer, unsigned long bufsiz);
  extern int parse_sha1_header(const char *hdr, unsigned long *sizep);
  
 -extern int check_sha1_signature(const unsigned char *sha1, void *buf, unsigned long size, const char *type);
 +extern int check_object_signature(const struct object_id *oid, void *buf, unsigned long size, const char *type);
  
  extern int finalize_object_file(const char *tmpfile, const char *filename);
  
  /*
 - * Open the loose object at path, check its sha1, and return the contents,
 + * Open the loose object at path, check its hash, and return the contents,
   * type, and size. If the object is a blob, then "contents" may return NULL,
   * to allow streaming of large blobs.
   *
   * Returns 0 on success, negative on error (details may be written to stderr).
   */
  int read_loose_object(const char *path,
 -		      const unsigned char *expected_sha1,
 +		      const struct object_id *expected_oid,
  		      enum object_type *type,
  		      unsigned long *size,
  		      void **contents);
@@@ -1279,7 -1291,7 +1279,7 @@@ extern int has_object_file_with_flags(c
   */
  extern int has_loose_object_nonlocal(const unsigned char *sha1);
  
 -extern void assert_sha1_type(const unsigned char *sha1, enum object_type expect);
 +extern void assert_oid_type(const struct object_id *oid, enum object_type expect);
  
  /* Helper to check and "touch" a file */
  extern int check_and_freshen_file(const char *fn, int freshen);
@@@ -1435,10 -1447,10 +1435,10 @@@ extern int df_name_compare(const char *
  extern int name_compare(const char *name1, size_t len1, const char *name2, size_t len2);
  extern int cache_name_stage_compare(const char *name1, int len1, int stage1, const char *name2, int len2, int stage2);
  
 -extern void *read_object_with_reference(const unsigned char *sha1,
 +extern void *read_object_with_reference(const struct object_id *oid,
  					const char *required_type,
  					unsigned long *size,
 -					unsigned char *sha1_ret);
 +					struct object_id *oid_ret);
  
  extern struct object *peel_to_type(const char *name, int namelen,
  				   struct object *o, enum object_type);
@@@ -1665,7 -1677,7 +1665,7 @@@ struct pack_entry 
   * usual "XXXXXX" trailer, and the resulting filename is written into the
   * "template" buffer. Returns the open descriptor.
   */
 -extern int odb_mkstemp(struct strbuf *template, const char *pattern);
 +extern int odb_mkstemp(struct strbuf *temp_filename, const char *pattern);
  
  /*
   * Create a pack .keep file named "name" (which should generally be the output
@@@ -1736,7 -1748,7 +1736,7 @@@ struct object_info 
  	unsigned long *sizep;
  	off_t *disk_sizep;
  	unsigned char *delta_base_sha1;
 -	struct strbuf *typename;
 +	struct strbuf *type_name;
  	void **contentp;
  
  	/* Response */
@@@ -1777,9 -1789,7 +1777,9 @@@
  #define OBJECT_INFO_SKIP_CACHED 4
  /* Do not retry packed storage after checking packed and loose storage */
  #define OBJECT_INFO_QUICK 8
 -extern int sha1_object_info_extended(const unsigned char *, struct object_info *, unsigned flags);
 +/* Do not check loose object */
 +#define OBJECT_INFO_IGNORE_LOOSE 16
 +extern int oid_object_info_extended(const struct object_id *, struct object_info *, unsigned flags);
  
  /*
   * Set this to 0 to prevent sha1_object_info_extended() from fetching missing
diff --combined environment.c
index d6dd64662c,a5eaa97fb1..21565c3c52
--- a/environment.c
+++ b/environment.c
@@@ -13,6 -13,7 +13,7 @@@
  #include "refs.h"
  #include "fmt-merge-msg.h"
  #include "commit.h"
+ #include "argv-array.h"
  
  int trust_executable_bit = 1;
  int trust_ctime = 1;
@@@ -100,7 -101,7 +101,7 @@@ int ignore_untracked_cache_config
  /* This is set by setup_git_dir_gently() and/or git_default_config() */
  char *git_work_tree_cfg;
  
 -static char *namespace;
 +static char *git_namespace;
  
  static const char *super_prefix;
  
@@@ -147,10 -148,35 +148,35 @@@ static char *expand_namespace(const cha
  	return strbuf_detach(&buf, NULL);
  }
  
- void setup_git_env(void)
+ /*
+  * Wrapper of getenv() that returns a strdup value. This value is kept
+  * in argv to be freed later.
+  */
+ static const char *getenv_safe(struct argv_array *argv, const char *name)
+ {
+ 	const char *value = getenv(name);
+ 
+ 	if (!value)
+ 		return NULL;
+ 
+ 	argv_array_push(argv, value);
+ 	return argv->argv[argv->argc - 1];
+ }
+ 
+ void setup_git_env(const char *git_dir)
  {
  	const char *shallow_file;
  	const char *replace_ref_base;
+ 	struct set_gitdir_args args = { NULL };
+ 	struct argv_array to_free = ARGV_ARRAY_INIT;
+ 
+ 	args.commondir = getenv_safe(&to_free, GIT_COMMON_DIR_ENVIRONMENT);
+ 	args.object_dir = getenv_safe(&to_free, DB_ENVIRONMENT);
+ 	args.graft_file = getenv_safe(&to_free, GRAFT_ENVIRONMENT);
+ 	args.index_file = getenv_safe(&to_free, INDEX_ENVIRONMENT);
+ 	args.alternate_db = getenv_safe(&to_free, ALTERNATE_DB_ENVIRONMENT);
+ 	repo_set_gitdir(the_repository, git_dir, &args);
+ 	argv_array_clear(&to_free);
  
  	if (getenv(NO_REPLACE_OBJECTS_ENVIRONMENT))
  		check_replace_refs = 0;
@@@ -158,8 -184,8 +184,8 @@@
  	free(git_replace_ref_base);
  	git_replace_ref_base = xstrdup(replace_ref_base ? replace_ref_base
  							  : "refs/replace/");
 -	free(namespace);
 -	namespace = expand_namespace(getenv(GIT_NAMESPACE_ENVIRONMENT));
 +	free(git_namespace);
 +	git_namespace = expand_namespace(getenv(GIT_NAMESPACE_ENVIRONMENT));
  	shallow_file = getenv(GIT_SHALLOW_FILE_ENVIRONMENT);
  	if (shallow_file)
  		set_alternate_shallow_file(shallow_file, 0);
@@@ -193,9 -219,9 +219,9 @@@ const char *get_git_common_dir(void
  
  const char *get_git_namespace(void)
  {
 -	if (!namespace)
 +	if (!git_namespace)
  		BUG("git environment hasn't been setup");
 -	return namespace;
 +	return git_namespace;
  }
  
  const char *strip_namespace(const char *namespaced_ref)
@@@ -249,7 -275,7 +275,7 @@@ char *get_object_directory(void
  	return the_repository->objectdir;
  }
  
 -int odb_mkstemp(struct strbuf *template, const char *pattern)
 +int odb_mkstemp(struct strbuf *temp_filename, const char *pattern)
  {
  	int fd;
  	/*
@@@ -257,16 -283,16 +283,16 @@@
  	 * restrictive except to remove write permission.
  	 */
  	int mode = 0444;
 -	git_path_buf(template, "objects/%s", pattern);
 -	fd = git_mkstemp_mode(template->buf, mode);
 +	git_path_buf(temp_filename, "objects/%s", pattern);
 +	fd = git_mkstemp_mode(temp_filename->buf, mode);
  	if (0 <= fd)
  		return fd;
  
  	/* slow path */
 -	/* some mkstemp implementations erase template on failure */
 -	git_path_buf(template, "objects/%s", pattern);
 -	safe_create_leading_directories(template->buf);
 -	return xmkstemp_mode(template->buf, mode);
 +	/* some mkstemp implementations erase temp_filename on failure */
 +	git_path_buf(temp_filename, "objects/%s", pattern);
 +	safe_create_leading_directories(temp_filename->buf);
 +	return xmkstemp_mode(temp_filename->buf, mode);
  }
  
  int odb_pack_keep(const char *name)
@@@ -300,8 -326,7 +326,7 @@@ int set_git_dir(const char *path
  {
  	if (setenv(GIT_DIR_ENVIRONMENT, path, 1))
  		return error("Could not set GIT_DIR to '%s'", path);
- 	repo_set_gitdir(the_repository, path);
- 	setup_git_env();
+ 	setup_git_env(path);
  	return 0;
  }
  
diff --combined setup.c
index 7287779642,6fac1bb58a..664453fcef
--- a/setup.c
+++ b/setup.c
@@@ -119,7 -119,7 +119,7 @@@ char *prefix_path(const char *prefix, i
  {
  	char *r = prefix_path_gently(prefix, len, NULL, path);
  	if (!r)
 -		die("'%s' is outside repository", path);
 +		die(_("'%s' is outside repository"), path);
  	return r;
  }
  
@@@ -160,7 -160,7 +160,7 @@@ int check_filename(const char *prefix, 
  		free(to_free);
  		return 0; /* file does not exist */
  	}
 -	die_errno("failed to stat '%s'", arg);
 +	die_errno(_("failed to stat '%s'"), arg);
  }
  
  static void NORETURN die_verify_filename(const char *prefix,
@@@ -230,7 -230,7 +230,7 @@@ void verify_filename(const char *prefix
  		     int diagnose_misspelt_rev)
  {
  	if (*arg == '-')
 -		die("option '%s' must come before non-option arguments", arg);
 +		die(_("option '%s' must come before non-option arguments"), arg);
  	if (looks_like_pathspec(arg) || check_filename(prefix, arg))
  		return;
  	die_verify_filename(prefix, arg, diagnose_misspelt_rev);
@@@ -385,14 -385,14 +385,14 @@@ void setup_work_tree(void
  		return;
  
  	if (work_tree_config_is_bogus)
 -		die("unable to set up work tree using invalid config");
 +		die(_("unable to set up work tree using invalid config"));
  
  	work_tree = get_git_work_tree();
  	git_dir = get_git_dir();
  	if (!is_absolute_path(git_dir))
  		git_dir = real_path(get_git_dir());
  	if (!work_tree || chdir(work_tree))
 -		die("This operation must be run in a work tree");
 +		die(_("this operation must be run in a work tree"));
  
  	/*
  	 * Make sure subsequent git processes find correct worktree
@@@ -530,17 -530,17 +530,17 @@@ void read_gitfile_error_die(int error_c
  		/* non-fatal; follow return path */
  		break;
  	case READ_GITFILE_ERR_OPEN_FAILED:
 -		die_errno("Error opening '%s'", path);
 +		die_errno(_("error opening '%s'"), path);
  	case READ_GITFILE_ERR_TOO_LARGE:
 -		die("Too large to be a .git file: '%s'", path);
 +		die(_("too large to be a .git file: '%s'"), path);
  	case READ_GITFILE_ERR_READ_FAILED:
 -		die("Error reading %s", path);
 +		die(_("error reading %s"), path);
  	case READ_GITFILE_ERR_INVALID_FORMAT:
 -		die("Invalid gitfile format: %s", path);
 +		die(_("invalid gitfile format: %s"), path);
  	case READ_GITFILE_ERR_NO_PATH:
 -		die("No path in gitfile: %s", path);
 +		die(_("no path in gitfile: %s"), path);
  	case READ_GITFILE_ERR_NOT_A_REPO:
 -		die("Not a git repository: %s", dir);
 +		die(_("not a git repository: %s"), dir);
  	default:
  		die("BUG: unknown error code");
  	}
@@@ -639,7 -639,7 +639,7 @@@ static const char *setup_explicit_git_d
  	int offset;
  
  	if (PATH_MAX - 40 < strlen(gitdirenv))
 -		die("'$%s' too big", GIT_DIR_ENVIRONMENT);
 +		die(_("'$%s' too big"), GIT_DIR_ENVIRONMENT);
  
  	gitfile = (char*)read_gitfile(gitdirenv);
  	if (gitfile) {
@@@ -653,7 -653,7 +653,7 @@@
  			free(gitfile);
  			return NULL;
  		}
 -		die("Not a git repository: '%s'", gitdirenv);
 +		die(_("not a git repository: '%s'"), gitdirenv);
  	}
  
  	if (check_repository_format_gently(gitdirenv, repo_fmt, nongit_ok)) {
@@@ -682,12 -682,12 +682,12 @@@
  		else {
  			char *core_worktree;
  			if (chdir(gitdirenv))
 -				die_errno("Could not chdir to '%s'", gitdirenv);
 +				die_errno(_("cannot chdir to '%s'"), gitdirenv);
  			if (chdir(git_work_tree_cfg))
 -				die_errno("Could not chdir to '%s'", git_work_tree_cfg);
 +				die_errno(_("cannot chdir to '%s'"), git_work_tree_cfg);
  			core_worktree = xgetcwd();
  			if (chdir(cwd->buf))
 -				die_errno("Could not come back to cwd");
 +				die_errno(_("cannot come back to cwd"));
  			set_git_work_tree(core_worktree);
  			free(core_worktree);
  		}
@@@ -715,7 -715,7 +715,7 @@@
  	if (offset >= 0) {	/* cwd inside worktree? */
  		set_git_dir(real_path(gitdirenv));
  		if (chdir(worktree))
 -			die_errno("Could not chdir to '%s'", worktree);
 +			die_errno(_("cannot chdir to '%s'"), worktree);
  		strbuf_addch(cwd, '/');
  		free(gitfile);
  		return cwd->buf + offset;
@@@ -743,7 -743,7 +743,7 @@@ static const char *setup_discovered_git
  		if (offset != cwd->len && !is_absolute_path(gitdir))
  			gitdir = to_free = real_pathdup(gitdir, 1);
  		if (chdir(cwd->buf))
 -			die_errno("Could not come back to cwd");
 +			die_errno(_("cannot come back to cwd"));
  		ret = setup_explicit_git_dir(gitdir, cwd, repo_fmt, nongit_ok);
  		free(to_free);
  		return ret;
@@@ -753,7 -753,7 +753,7 @@@
  	if (is_bare_repository_cfg > 0) {
  		set_git_dir(offset == cwd->len ? gitdir : real_path(gitdir));
  		if (chdir(cwd->buf))
 -			die_errno("Could not come back to cwd");
 +			die_errno(_("cannot come back to cwd"));
  		return NULL;
  	}
  
@@@ -792,7 -792,7 +792,7 @@@ static const char *setup_bare_git_dir(s
  
  		gitdir = offset == cwd->len ? "." : xmemdupz(cwd->buf, offset);
  		if (chdir(cwd->buf))
 -			die_errno("Could not come back to cwd");
 +			die_errno(_("cannot come back to cwd"));
  		return setup_explicit_git_dir(gitdir, cwd, repo_fmt, nongit_ok);
  	}
  
@@@ -800,7 -800,7 +800,7 @@@
  	inside_work_tree = 0;
  	if (offset != cwd->len) {
  		if (chdir(cwd->buf))
 -			die_errno("Cannot come back to cwd");
 +			die_errno(_("cannot come back to cwd"));
  		root_len = offset_1st_component(cwd->buf);
  		strbuf_setlen(cwd, offset > root_len ? offset : root_len);
  		set_git_dir(cwd->buf);
@@@ -813,9 -813,9 +813,9 @@@
  static const char *setup_nongit(const char *cwd, int *nongit_ok)
  {
  	if (!nongit_ok)
 -		die(_("Not a git repository (or any of the parent directories): %s"), DEFAULT_GIT_DIR_ENVIRONMENT);
 +		die(_("not a git repository (or any of the parent directories): %s"), DEFAULT_GIT_DIR_ENVIRONMENT);
  	if (chdir(cwd))
 -		die_errno(_("Cannot come back to cwd"));
 +		die_errno(_("cannot come back to cwd"));
  	*nongit_ok = 1;
  	return NULL;
  }
@@@ -824,7 -824,7 +824,7 @@@ static dev_t get_device_or_die(const ch
  {
  	struct stat buf;
  	if (stat(path, &buf)) {
 -		die_errno("failed to stat '%*s%s%s'",
 +		die_errno(_("failed to stat '%*s%s%s'"),
  				prefix_len,
  				prefix ? prefix : "",
  				prefix ? "/" : "", path);
@@@ -1066,13 -1066,13 +1066,13 @@@ const char *setup_git_directory_gently(
  		break;
  	case GIT_DIR_DISCOVERED:
  		if (dir.len < cwd.len && chdir(dir.buf))
 -			die(_("Cannot change to '%s'"), dir.buf);
 +			die(_("cannot change to '%s'"), dir.buf);
  		prefix = setup_discovered_git_dir(gitdir.buf, &cwd, dir.len,
  						  &repo_fmt, nongit_ok);
  		break;
  	case GIT_DIR_BARE:
  		if (dir.len < cwd.len && chdir(dir.buf))
 -			die(_("Cannot change to '%s'"), dir.buf);
 +			die(_("cannot change to '%s'"), dir.buf);
  		prefix = setup_bare_git_dir(&cwd, dir.len, &repo_fmt, nongit_ok);
  		break;
  	case GIT_DIR_HIT_CEILING:
@@@ -1085,7 -1085,7 +1085,7 @@@
  			strbuf_release(&dir);
  			return NULL;
  		}
 -		die(_("Not a git repository (or any parent up to mount point %s)\n"
 +		die(_("not a git repository (or any parent up to mount point %s)\n"
  		      "Stopping at filesystem boundary (GIT_DISCOVERY_ACROSS_FILESYSTEM not set)."),
  		    dir.buf);
  	default:
@@@ -1116,8 -1116,7 +1116,7 @@@
  			const char *gitdir = getenv(GIT_DIR_ENVIRONMENT);
  			if (!gitdir)
  				gitdir = DEFAULT_GIT_DIR_ENVIRONMENT;
- 			repo_set_gitdir(the_repository, gitdir);
- 			setup_git_env();
+ 			setup_git_env(gitdir);
  		}
  		if (startup_info->have_repository)
  			repo_set_hash_algo(the_repository, repo_fmt.hash_algo);
@@@ -1169,7 -1168,7 +1168,7 @@@ int git_config_perm(const char *var, co
  	/* A filemode value was given: 0xxx */
  
  	if ((i & 0600) != 0600)
 -		die(_("Problem with core.sharedRepository filemode value "
 +		die(_("problem with core.sharedRepository filemode value "
  		    "(0%.3o).\nThe owner of files must always have "
  		    "read and write permissions."), i);
  
@@@ -1212,7 -1211,7 +1211,7 @@@ void sanitize_stdfds(void
  	while (fd != -1 && fd < 2)
  		fd = dup(fd);
  	if (fd == -1)
 -		die_errno("open /dev/null or dup failed");
 +		die_errno(_("open /dev/null or dup failed"));
  	if (fd > 2)
  		close(fd);
  }
@@@ -1227,12 -1226,12 +1226,12 @@@ int daemonize(void
  		case 0:
  			break;
  		case -1:
 -			die_errno("fork failed");
 +			die_errno(_("fork failed"));
  		default:
  			exit(0);
  	}
  	if (setsid() == -1)
 -		die_errno("setsid failed");
 +		die_errno(_("setsid failed"));
  	close(0);
  	close(1);
  	close(2);
diff --combined sha1_file.c
index 1c61d9d927,4af422e3cf..aea9124a78
--- a/sha1_file.c
+++ b/sha1_file.c
@@@ -30,9 -30,6 +30,9 @@@
  #include "packfile.h"
  #include "fetch-object.h"
  
 +/* The maximum size for an object header. */
 +#define MAX_HEADER_LEN 32
 +
  const unsigned char null_sha1[GIT_MAX_RAWSZ];
  const struct object_id null_oid;
  const struct object_id empty_tree_oid = {
@@@ -42,32 -39,32 +42,32 @@@ const struct object_id empty_blob_oid 
  	EMPTY_BLOB_SHA1_BIN_LITERAL
  };
  
 -static void git_hash_sha1_init(void *ctx)
 +static void git_hash_sha1_init(git_hash_ctx *ctx)
  {
 -	git_SHA1_Init((git_SHA_CTX *)ctx);
 +	git_SHA1_Init(&ctx->sha1);
  }
  
 -static void git_hash_sha1_update(void *ctx, const void *data, size_t len)
 +static void git_hash_sha1_update(git_hash_ctx *ctx, const void *data, size_t len)
  {
 -	git_SHA1_Update((git_SHA_CTX *)ctx, data, len);
 +	git_SHA1_Update(&ctx->sha1, data, len);
  }
  
 -static void git_hash_sha1_final(unsigned char *hash, void *ctx)
 +static void git_hash_sha1_final(unsigned char *hash, git_hash_ctx *ctx)
  {
 -	git_SHA1_Final(hash, (git_SHA_CTX *)ctx);
 +	git_SHA1_Final(hash, &ctx->sha1);
  }
  
 -static void git_hash_unknown_init(void *ctx)
 +static void git_hash_unknown_init(git_hash_ctx *ctx)
  {
  	die("trying to init unknown hash");
  }
  
 -static void git_hash_unknown_update(void *ctx, const void *data, size_t len)
 +static void git_hash_unknown_update(git_hash_ctx *ctx, const void *data, size_t len)
  {
  	die("trying to update unknown hash");
  }
  
 -static void git_hash_unknown_final(unsigned char *hash, void *ctx)
 +static void git_hash_unknown_final(unsigned char *hash, git_hash_ctx *ctx)
  {
  	die("trying to finalize unknown hash");
  }
@@@ -78,6 -75,7 +78,6 @@@ const struct git_hash_algo hash_algos[G
  		0x00000000,
  		0,
  		0,
 -		0,
  		git_hash_unknown_init,
  		git_hash_unknown_update,
  		git_hash_unknown_final,
@@@ -88,6 -86,7 +88,6 @@@
  		"sha-1",
  		/* "sha1", big-endian */
  		0x73686131,
 -		sizeof(git_SHA_CTX),
  		GIT_SHA1_RAWSZ,
  		GIT_SHA1_HEXSZ,
  		git_hash_sha1_init,
@@@ -668,15 -667,11 +668,11 @@@ int foreach_alt_odb(alt_odb_fn fn, voi
  
  void prepare_alt_odb(void)
  {
- 	const char *alt;
- 
  	if (alt_odb_tail)
  		return;
  
- 	alt = getenv(ALTERNATE_DB_ENVIRONMENT);
- 
  	alt_odb_tail = &alt_odb_list;
- 	link_alt_odb_entries(alt, PATH_SEP, NULL, 0);
+ 	link_alt_odb_entries(the_repository->alternate_db, PATH_SEP, NULL, 0);
  
  	read_info_alternates(get_object_directory(), 0);
  }
@@@ -787,31 -782,31 +783,31 @@@ void *xmmap(void *start, size_t length
   * With "map" == NULL, try reading the object named with "sha1" using
   * the streaming interface and rehash it to do the same.
   */
 -int check_sha1_signature(const unsigned char *sha1, void *map,
 -			 unsigned long size, const char *type)
 +int check_object_signature(const struct object_id *oid, void *map,
 +			   unsigned long size, const char *type)
  {
 -	unsigned char real_sha1[20];
 +	struct object_id real_oid;
  	enum object_type obj_type;
  	struct git_istream *st;
 -	git_SHA_CTX c;
 -	char hdr[32];
 +	git_hash_ctx c;
 +	char hdr[MAX_HEADER_LEN];
  	int hdrlen;
  
  	if (map) {
 -		hash_sha1_file(map, size, type, real_sha1);
 -		return hashcmp(sha1, real_sha1) ? -1 : 0;
 +		hash_object_file(map, size, type, &real_oid);
 +		return oidcmp(oid, &real_oid) ? -1 : 0;
  	}
  
 -	st = open_istream(sha1, &obj_type, &size, NULL);
 +	st = open_istream(oid, &obj_type, &size, NULL);
  	if (!st)
  		return -1;
  
  	/* Generate the header */
 -	hdrlen = xsnprintf(hdr, sizeof(hdr), "%s %lu", typename(obj_type), size) + 1;
 +	hdrlen = xsnprintf(hdr, sizeof(hdr), "%s %lu", type_name(obj_type), size) + 1;
  
  	/* Sha1.. */
 -	git_SHA1_Init(&c);
 -	git_SHA1_Update(&c, hdr, hdrlen);
 +	the_hash_algo->init_fn(&c);
 +	the_hash_algo->update_fn(&c, hdr, hdrlen);
  	for (;;) {
  		char buf[1024 * 16];
  		ssize_t readlen = read_istream(st, buf, sizeof(buf));
@@@ -822,11 -817,11 +818,11 @@@
  		}
  		if (!readlen)
  			break;
 -		git_SHA1_Update(&c, buf, readlen);
 +		the_hash_algo->update_fn(&c, buf, readlen);
  	}
 -	git_SHA1_Final(real_sha1, &c);
 +	the_hash_algo->final_fn(real_oid.hash, &c);
  	close_istream(st);
 -	return hashcmp(sha1, real_sha1) ? -1 : 0;
 +	return oidcmp(oid, &real_oid) ? -1 : 0;
  }
  
  int git_open_cloexec(const char *name, int flags)
@@@ -1097,8 -1092,8 +1093,8 @@@ static int parse_sha1_header_extended(c
  	}
  
  	type = type_from_string_gently(type_buf, type_len, 1);
 -	if (oi->typename)
 -		strbuf_add(oi->typename, type_buf, type_len);
 +	if (oi->type_name)
 +		strbuf_add(oi->type_name, type_buf, type_len);
  	/*
  	 * Set type to 0 if its an unknown object and
  	 * we're obtaining the type using '--allow-unknown-type'
@@@ -1153,7 -1148,7 +1149,7 @@@ static int sha1_loose_object_info(cons
  	unsigned long mapsize;
  	void *map;
  	git_zstream stream;
 -	char hdr[32];
 +	char hdr[MAX_HEADER_LEN];
  	struct strbuf hdrbuf = STRBUF_INIT;
  	unsigned long size_scratch;
  
@@@ -1168,7 -1163,7 +1164,7 @@@
  	 * return value implicitly indicates whether the
  	 * object even exists.
  	 */
 -	if (!oi->typep && !oi->typename && !oi->sizep && !oi->contentp) {
 +	if (!oi->typep && !oi->type_name && !oi->sizep && !oi->contentp) {
  		const char *path;
  		struct stat st;
  		if (stat_sha1_file(sha1, &st, &path) < 0)
@@@ -1225,25 -1220,24 +1221,25 @@@
  
  int fetch_if_missing = 1;
  
 -int sha1_object_info_extended(const unsigned char *sha1, struct object_info *oi, unsigned flags)
 +int oid_object_info_extended(const struct object_id *oid, struct object_info *oi, unsigned flags)
  {
  	static struct object_info blank_oi = OBJECT_INFO_INIT;
  	struct pack_entry e;
  	int rtype;
 -	const unsigned char *real = (flags & OBJECT_INFO_LOOKUP_REPLACE) ?
 -				    lookup_replace_object(sha1) :
 -				    sha1;
 +	const struct object_id *real = oid;
  	int already_retried = 0;
  
 -	if (is_null_sha1(real))
 +	if (flags & OBJECT_INFO_LOOKUP_REPLACE)
 +		real = lookup_replace_object(oid);
 +
 +	if (is_null_oid(real))
  		return -1;
  
  	if (!oi)
  		oi = &blank_oi;
  
  	if (!(flags & OBJECT_INFO_SKIP_CACHED)) {
 -		struct cached_object *co = find_cached_object(real);
 +		struct cached_object *co = find_cached_object(real->hash);
  		if (co) {
  			if (oi->typep)
  				*(oi->typep) = co->type;
@@@ -1253,8 -1247,8 +1249,8 @@@
  				*(oi->disk_sizep) = 0;
  			if (oi->delta_base_sha1)
  				hashclr(oi->delta_base_sha1);
 -			if (oi->typename)
 -				strbuf_addstr(oi->typename, typename(co->type));
 +			if (oi->type_name)
 +				strbuf_addstr(oi->type_name, type_name(co->type));
  			if (oi->contentp)
  				*oi->contentp = xmemdupz(co->buf, co->size);
  			oi->whence = OI_CACHED;
@@@ -1263,22 -1257,17 +1259,22 @@@
  	}
  
  	while (1) {
 -		if (find_pack_entry(real, &e))
 +		if (find_pack_entry(real->hash, &e))
  			break;
  
 +		if (flags & OBJECT_INFO_IGNORE_LOOSE)
 +			return -1;
 +
  		/* Most likely it's a loose object. */
 -		if (!sha1_loose_object_info(real, oi, flags))
 +		if (!sha1_loose_object_info(real->hash, oi, flags))
  			return 0;
  
  		/* Not a loose object; someone else may have just packed it. */
 -		reprepare_packed_git();
 -		if (find_pack_entry(real, &e))
 -			break;
 +		if (!(flags & OBJECT_INFO_QUICK)) {
 +			reprepare_packed_git();
 +			if (find_pack_entry(real->hash, &e))
 +				break;
 +		}
  
  		/* Check if it is a missing object */
  		if (fetch_if_missing && repository_format_partial_clone &&
@@@ -1287,7 -1276,7 +1283,7 @@@
  			 * TODO Investigate haveing fetch_object() return
  			 * TODO error/success and stopping the music here.
  			 */
 -			fetch_object(repository_format_partial_clone, real);
 +			fetch_object(repository_format_partial_clone, real->hash);
  			already_retried = 1;
  			continue;
  		}
@@@ -1303,8 -1292,8 +1299,8 @@@
  		return 0;
  	rtype = packed_object_info(e.p, e.offset, oi);
  	if (rtype < 0) {
 -		mark_bad_packed_object(e.p, real);
 -		return sha1_object_info_extended(real, oi, 0);
 +		mark_bad_packed_object(e.p, real->hash);
 +		return oid_object_info_extended(real, oi, 0);
  	} else if (oi->whence == OI_PACKED) {
  		oi->u.packed.offset = e.offset;
  		oi->u.packed.pack = e.p;
@@@ -1316,15 -1305,15 +1312,15 @@@
  }
  
  /* returns enum object_type or negative */
 -int sha1_object_info(const unsigned char *sha1, unsigned long *sizep)
 +int oid_object_info(const struct object_id *oid, unsigned long *sizep)
  {
  	enum object_type type;
  	struct object_info oi = OBJECT_INFO_INIT;
  
  	oi.typep = &type;
  	oi.sizep = sizep;
 -	if (sha1_object_info_extended(sha1, &oi,
 -				      OBJECT_INFO_LOOKUP_REPLACE) < 0)
 +	if (oid_object_info_extended(oid, &oi,
 +				     OBJECT_INFO_LOOKUP_REPLACE) < 0)
  		return -1;
  	return type;
  }
@@@ -1332,27 -1321,24 +1328,27 @@@
  static void *read_object(const unsigned char *sha1, enum object_type *type,
  			 unsigned long *size)
  {
 +	struct object_id oid;
  	struct object_info oi = OBJECT_INFO_INIT;
  	void *content;
  	oi.typep = type;
  	oi.sizep = size;
  	oi.contentp = &content;
  
 -	if (sha1_object_info_extended(sha1, &oi, 0) < 0)
 +	hashcpy(oid.hash, sha1);
 +
 +	if (oid_object_info_extended(&oid, &oi, 0) < 0)
  		return NULL;
  	return content;
  }
  
 -int pretend_sha1_file(void *buf, unsigned long len, enum object_type type,
 -		      unsigned char *sha1)
 +int pretend_object_file(void *buf, unsigned long len, enum object_type type,
 +			struct object_id *oid)
  {
  	struct cached_object *co;
  
 -	hash_sha1_file(buf, len, typename(type), sha1);
 -	if (has_sha1_file(sha1) || find_cached_object(sha1))
 +	hash_object_file(buf, len, type_name(type), oid);
 +	if (has_sha1_file(oid->hash) || find_cached_object(oid->hash))
  		return 0;
  	ALLOC_GROW(cached_objects, cached_object_nr + 1, cached_object_alloc);
  	co = &cached_objects[cached_object_nr++];
@@@ -1360,7 -1346,7 +1356,7 @@@
  	co->type = type;
  	co->buf = xmalloc(len);
  	memcpy(co->buf, buf, len);
 -	hashcpy(co->sha1, sha1);
 +	hashcpy(co->sha1, oid->hash);
  	return 0;
  }
  
@@@ -1369,65 -1355,65 +1365,65 @@@
   * deal with them should arrange to call read_object() and give error
   * messages themselves.
   */
 -void *read_sha1_file_extended(const unsigned char *sha1,
 -			      enum object_type *type,
 -			      unsigned long *size,
 -			      int lookup_replace)
 +void *read_object_file_extended(const struct object_id *oid,
 +				enum object_type *type,
 +				unsigned long *size,
 +				int lookup_replace)
  {
  	void *data;
  	const struct packed_git *p;
  	const char *path;
  	struct stat st;
 -	const unsigned char *repl = lookup_replace ? lookup_replace_object(sha1)
 -						   : sha1;
 +	const struct object_id *repl = lookup_replace ? lookup_replace_object(oid)
 +						      : oid;
  
  	errno = 0;
 -	data = read_object(repl, type, size);
 +	data = read_object(repl->hash, type, size);
  	if (data)
  		return data;
  
  	if (errno && errno != ENOENT)
 -		die_errno("failed to read object %s", sha1_to_hex(sha1));
 +		die_errno("failed to read object %s", oid_to_hex(oid));
  
  	/* die if we replaced an object with one that does not exist */
 -	if (repl != sha1)
 +	if (repl != oid)
  		die("replacement %s not found for %s",
 -		    sha1_to_hex(repl), sha1_to_hex(sha1));
 +		    oid_to_hex(repl), oid_to_hex(oid));
  
 -	if (!stat_sha1_file(repl, &st, &path))
 +	if (!stat_sha1_file(repl->hash, &st, &path))
  		die("loose object %s (stored in %s) is corrupt",
 -		    sha1_to_hex(repl), path);
 +		    oid_to_hex(repl), path);
  
 -	if ((p = has_packed_and_bad(repl)) != NULL)
 +	if ((p = has_packed_and_bad(repl->hash)) != NULL)
  		die("packed object %s (stored in %s) is corrupt",
 -		    sha1_to_hex(repl), p->pack_name);
 +		    oid_to_hex(repl), p->pack_name);
  
  	return NULL;
  }
  
 -void *read_object_with_reference(const unsigned char *sha1,
 +void *read_object_with_reference(const struct object_id *oid,
  				 const char *required_type_name,
  				 unsigned long *size,
 -				 unsigned char *actual_sha1_return)
 +				 struct object_id *actual_oid_return)
  {
  	enum object_type type, required_type;
  	void *buffer;
  	unsigned long isize;
 -	unsigned char actual_sha1[20];
 +	struct object_id actual_oid;
  
  	required_type = type_from_string(required_type_name);
 -	hashcpy(actual_sha1, sha1);
 +	oidcpy(&actual_oid, oid);
  	while (1) {
  		int ref_length = -1;
  		const char *ref_type = NULL;
  
 -		buffer = read_sha1_file(actual_sha1, &type, &isize);
 +		buffer = read_object_file(&actual_oid, &type, &isize);
  		if (!buffer)
  			return NULL;
  		if (type == required_type) {
  			*size = isize;
 -			if (actual_sha1_return)
 -				hashcpy(actual_sha1_return, actual_sha1);
 +			if (actual_oid_return)
 +				oidcpy(actual_oid_return, &actual_oid);
  			return buffer;
  		}
  		/* Handle references */
@@@ -1441,32 -1427,32 +1437,32 @@@
  		}
  		ref_length = strlen(ref_type);
  
 -		if (ref_length + 40 > isize ||
 +		if (ref_length + GIT_SHA1_HEXSZ > isize ||
  		    memcmp(buffer, ref_type, ref_length) ||
 -		    get_sha1_hex((char *) buffer + ref_length, actual_sha1)) {
 +		    get_oid_hex((char *) buffer + ref_length, &actual_oid)) {
  			free(buffer);
  			return NULL;
  		}
  		free(buffer);
  		/* Now we have the ID of the referred-to object in
 -		 * actual_sha1.  Check again. */
 +		 * actual_oid.  Check again. */
  	}
  }
  
 -static void write_sha1_file_prepare(const void *buf, unsigned long len,
 -                                    const char *type, unsigned char *sha1,
 -                                    char *hdr, int *hdrlen)
 +static void write_object_file_prepare(const void *buf, unsigned long len,
 +				      const char *type, struct object_id *oid,
 +				      char *hdr, int *hdrlen)
  {
 -	git_SHA_CTX c;
 +	git_hash_ctx c;
  
  	/* Generate the header */
  	*hdrlen = xsnprintf(hdr, *hdrlen, "%s %lu", type, len)+1;
  
  	/* Sha1.. */
 -	git_SHA1_Init(&c);
 -	git_SHA1_Update(&c, hdr, *hdrlen);
 -	git_SHA1_Update(&c, buf, len);
 -	git_SHA1_Final(sha1, &c);
 +	the_hash_algo->init_fn(&c);
 +	the_hash_algo->update_fn(&c, hdr, *hdrlen);
 +	the_hash_algo->update_fn(&c, buf, len);
 +	the_hash_algo->final_fn(oid->hash, &c);
  }
  
  /*
@@@ -1519,12 -1505,12 +1515,12 @@@ static int write_buffer(int fd, const v
  	return 0;
  }
  
 -int hash_sha1_file(const void *buf, unsigned long len, const char *type,
 -                   unsigned char *sha1)
 +int hash_object_file(const void *buf, unsigned long len, const char *type,
 +		     struct object_id *oid)
  {
 -	char hdr[32];
 +	char hdr[MAX_HEADER_LEN];
  	int hdrlen = sizeof(hdr);
 -	write_sha1_file_prepare(buf, len, type, sha1, hdr, &hdrlen);
 +	write_object_file_prepare(buf, len, type, oid, hdr, &hdrlen);
  	return 0;
  }
  
@@@ -1582,20 -1568,19 +1578,20 @@@ static int create_tmpfile(struct strbu
  	return fd;
  }
  
 -static int write_loose_object(const unsigned char *sha1, char *hdr, int hdrlen,
 -			      const void *buf, unsigned long len, time_t mtime)
 +static int write_loose_object(const struct object_id *oid, char *hdr,
 +			      int hdrlen, const void *buf, unsigned long len,
 +			      time_t mtime)
  {
  	int fd, ret;
  	unsigned char compressed[4096];
  	git_zstream stream;
 -	git_SHA_CTX c;
 -	unsigned char parano_sha1[20];
 +	git_hash_ctx c;
 +	struct object_id parano_oid;
  	static struct strbuf tmp_file = STRBUF_INIT;
  	static struct strbuf filename = STRBUF_INIT;
  
  	strbuf_reset(&filename);
 -	sha1_file_name(&filename, sha1);
 +	sha1_file_name(&filename, oid->hash);
  
  	fd = create_tmpfile(&tmp_file, filename.buf);
  	if (fd < 0) {
@@@ -1609,14 -1594,14 +1605,14 @@@
  	git_deflate_init(&stream, zlib_compression_level);
  	stream.next_out = compressed;
  	stream.avail_out = sizeof(compressed);
 -	git_SHA1_Init(&c);
 +	the_hash_algo->init_fn(&c);
  
  	/* First header.. */
  	stream.next_in = (unsigned char *)hdr;
  	stream.avail_in = hdrlen;
  	while (git_deflate(&stream, 0) == Z_OK)
  		; /* nothing */
 -	git_SHA1_Update(&c, hdr, hdrlen);
 +	the_hash_algo->update_fn(&c, hdr, hdrlen);
  
  	/* Then the data itself.. */
  	stream.next_in = (void *)buf;
@@@ -1624,7 -1609,7 +1620,7 @@@
  	do {
  		unsigned char *in0 = stream.next_in;
  		ret = git_deflate(&stream, Z_FINISH);
 -		git_SHA1_Update(&c, in0, stream.next_in - in0);
 +		the_hash_algo->update_fn(&c, in0, stream.next_in - in0);
  		if (write_buffer(fd, compressed, stream.next_out - compressed) < 0)
  			die("unable to write sha1 file");
  		stream.next_out = compressed;
@@@ -1632,16 -1617,13 +1628,16 @@@
  	} while (ret == Z_OK);
  
  	if (ret != Z_STREAM_END)
 -		die("unable to deflate new object %s (%d)", sha1_to_hex(sha1), ret);
 +		die("unable to deflate new object %s (%d)", oid_to_hex(oid),
 +		    ret);
  	ret = git_deflate_end_gently(&stream);
  	if (ret != Z_OK)
 -		die("deflateEnd on object %s failed (%d)", sha1_to_hex(sha1), ret);
 -	git_SHA1_Final(parano_sha1, &c);
 -	if (hashcmp(sha1, parano_sha1) != 0)
 -		die("confused by unstable object source data for %s", sha1_to_hex(sha1));
 +		die("deflateEnd on object %s failed (%d)", oid_to_hex(oid),
 +		    ret);
 +	the_hash_algo->final_fn(parano_oid.hash, &c);
 +	if (oidcmp(oid, &parano_oid) != 0)
 +		die("confused by unstable object source data for %s",
 +		    oid_to_hex(oid));
  
  	close_sha1_file(fd);
  
@@@ -1674,60 -1656,58 +1670,60 @@@ static int freshen_packed_object(const 
  	return 1;
  }
  
 -int write_sha1_file(const void *buf, unsigned long len, const char *type, unsigned char *sha1)
 +int write_object_file(const void *buf, unsigned long len, const char *type,
 +		      struct object_id *oid)
  {
 -	char hdr[32];
 +	char hdr[MAX_HEADER_LEN];
  	int hdrlen = sizeof(hdr);
  
  	/* Normally if we have it in the pack then we do not bother writing
  	 * it out into .git/objects/??/?{38} file.
  	 */
 -	write_sha1_file_prepare(buf, len, type, sha1, hdr, &hdrlen);
 -	if (freshen_packed_object(sha1) || freshen_loose_object(sha1))
 +	write_object_file_prepare(buf, len, type, oid, hdr, &hdrlen);
 +	if (freshen_packed_object(oid->hash) || freshen_loose_object(oid->hash))
  		return 0;
 -	return write_loose_object(sha1, hdr, hdrlen, buf, len, 0);
 +	return write_loose_object(oid, hdr, hdrlen, buf, len, 0);
  }
  
 -int hash_sha1_file_literally(const void *buf, unsigned long len, const char *type,
 -			     struct object_id *oid, unsigned flags)
 +int hash_object_file_literally(const void *buf, unsigned long len,
 +			       const char *type, struct object_id *oid,
 +			       unsigned flags)
  {
  	char *header;
  	int hdrlen, status = 0;
  
  	/* type string, SP, %lu of the length plus NUL must fit this */
 -	hdrlen = strlen(type) + 32;
 +	hdrlen = strlen(type) + MAX_HEADER_LEN;
  	header = xmalloc(hdrlen);
 -	write_sha1_file_prepare(buf, len, type, oid->hash, header, &hdrlen);
 +	write_object_file_prepare(buf, len, type, oid, header, &hdrlen);
  
  	if (!(flags & HASH_WRITE_OBJECT))
  		goto cleanup;
  	if (freshen_packed_object(oid->hash) || freshen_loose_object(oid->hash))
  		goto cleanup;
 -	status = write_loose_object(oid->hash, header, hdrlen, buf, len, 0);
 +	status = write_loose_object(oid, header, hdrlen, buf, len, 0);
  
  cleanup:
  	free(header);
  	return status;
  }
  
 -int force_object_loose(const unsigned char *sha1, time_t mtime)
 +int force_object_loose(const struct object_id *oid, time_t mtime)
  {
  	void *buf;
  	unsigned long len;
  	enum object_type type;
 -	char hdr[32];
 +	char hdr[MAX_HEADER_LEN];
  	int hdrlen;
  	int ret;
  
 -	if (has_loose_object(sha1))
 +	if (has_loose_object(oid->hash))
  		return 0;
 -	buf = read_object(sha1, &type, &len);
 +	buf = read_object(oid->hash, &type, &len);
  	if (!buf)
 -		return error("cannot read sha1_file for %s", sha1_to_hex(sha1));
 -	hdrlen = xsnprintf(hdr, sizeof(hdr), "%s %lu", typename(type), len) + 1;
 -	ret = write_loose_object(sha1, hdr, hdrlen, buf, len, mtime);
 +		return error("cannot read sha1_file for %s", oid_to_hex(oid));
 +	hdrlen = xsnprintf(hdr, sizeof(hdr), "%s %lu", type_name(type), len) + 1;
 +	ret = write_loose_object(oid, hdr, hdrlen, buf, len, mtime);
  	free(buf);
  
  	return ret;
@@@ -1735,12 -1715,10 +1731,12 @@@
  
  int has_sha1_file_with_flags(const unsigned char *sha1, int flags)
  {
 +	struct object_id oid;
  	if (!startup_info->have_repository)
  		return 0;
 -	return sha1_object_info_extended(sha1, NULL,
 -					 flags | OBJECT_INFO_SKIP_CACHED) >= 0;
 +	hashcpy(oid.hash, sha1);
 +	return oid_object_info_extended(&oid, NULL,
 +					flags | OBJECT_INFO_SKIP_CACHED) >= 0;
  }
  
  int has_object_file(const struct object_id *oid)
@@@ -1812,9 -1790,9 +1808,9 @@@ static int index_mem(struct object_id *
  	}
  
  	if (write_object)
 -		ret = write_sha1_file(buf, size, typename(type), oid->hash);
 +		ret = write_object_file(buf, size, type_name(type), oid);
  	else
 -		ret = hash_sha1_file(buf, size, typename(type), oid->hash);
 +		ret = hash_object_file(buf, size, type_name(type), oid);
  	if (re_allocated)
  		free(buf);
  	return ret;
@@@ -1834,11 -1812,11 +1830,11 @@@ static int index_stream_convert_blob(st
  				 get_conv_flags(flags));
  
  	if (write_object)
 -		ret = write_sha1_file(sbuf.buf, sbuf.len, typename(OBJ_BLOB),
 -				      oid->hash);
 +		ret = write_object_file(sbuf.buf, sbuf.len, type_name(OBJ_BLOB),
 +					oid);
  	else
 -		ret = hash_sha1_file(sbuf.buf, sbuf.len, typename(OBJ_BLOB),
 -				     oid->hash);
 +		ret = hash_object_file(sbuf.buf, sbuf.len, type_name(OBJ_BLOB),
 +				       oid);
  	strbuf_release(&sbuf);
  	return ret;
  }
@@@ -1906,7 -1884,7 +1902,7 @@@ static int index_stream(struct object_i
  			enum object_type type, const char *path,
  			unsigned flags)
  {
 -	return index_bulk_checkin(oid->hash, fd, size, type, path, flags);
 +	return index_bulk_checkin(oid, fd, size, type, path, flags);
  }
  
  int index_fd(struct object_id *oid, int fd, struct stat *st,
@@@ -1952,8 -1930,8 +1948,8 @@@ int index_path(struct object_id *oid, c
  		if (strbuf_readlink(&sb, path, st->st_size))
  			return error_errno("readlink(\"%s\")", path);
  		if (!(flags & HASH_WRITE_OBJECT))
 -			hash_sha1_file(sb.buf, sb.len, blob_type, oid->hash);
 -		else if (write_sha1_file(sb.buf, sb.len, blob_type, oid->hash))
 +			hash_object_file(sb.buf, sb.len, blob_type, oid);
 +		else if (write_object_file(sb.buf, sb.len, blob_type, oid))
  			rc = error("%s: failed to insert into database", path);
  		strbuf_release(&sb);
  		break;
@@@ -1980,14 -1958,14 +1976,14 @@@ int read_pack_header(int fd, struct pac
  	return 0;
  }
  
 -void assert_sha1_type(const unsigned char *sha1, enum object_type expect)
 +void assert_oid_type(const struct object_id *oid, enum object_type expect)
  {
 -	enum object_type type = sha1_object_info(sha1, NULL);
 +	enum object_type type = oid_object_info(oid, NULL);
  	if (type < 0)
 -		die("%s is not a valid object", sha1_to_hex(sha1));
 +		die("%s is not a valid object", oid_to_hex(oid));
  	if (type != expect)
 -		die("%s is not a valid '%s' object", sha1_to_hex(sha1),
 -		    typename(expect));
 +		die("%s is not a valid '%s' object", oid_to_hex(oid),
 +		    type_name(expect));
  }
  
  int for_each_file_in_obj_subdir(unsigned int subdir_nr,
@@@ -2138,14 -2116,14 +2134,14 @@@ static int check_stream_sha1(git_zstrea
  			     const char *path,
  			     const unsigned char *expected_sha1)
  {
 -	git_SHA_CTX c;
 +	git_hash_ctx c;
  	unsigned char real_sha1[GIT_MAX_RAWSZ];
  	unsigned char buf[4096];
  	unsigned long total_read;
  	int status = Z_OK;
  
 -	git_SHA1_Init(&c);
 -	git_SHA1_Update(&c, hdr, stream->total_out);
 +	the_hash_algo->init_fn(&c);
 +	the_hash_algo->update_fn(&c, hdr, stream->total_out);
  
  	/*
  	 * We already read some bytes into hdr, but the ones up to the NUL
@@@ -2164,7 -2142,7 +2160,7 @@@
  		if (size - total_read < stream->avail_out)
  			stream->avail_out = size - total_read;
  		status = git_inflate(stream, Z_FINISH);
 -		git_SHA1_Update(&c, buf, stream->next_out - buf);
 +		the_hash_algo->update_fn(&c, buf, stream->next_out - buf);
  		total_read += stream->next_out - buf;
  	}
  	git_inflate_end(stream);
@@@ -2179,7 -2157,7 +2175,7 @@@
  		return -1;
  	}
  
 -	git_SHA1_Final(real_sha1, &c);
 +	the_hash_algo->final_fn(real_sha1, &c);
  	if (hashcmp(expected_sha1, real_sha1)) {
  		error("sha1 mismatch for %s (expected %s)", path,
  		      sha1_to_hex(expected_sha1));
@@@ -2190,7 -2168,7 +2186,7 @@@
  }
  
  int read_loose_object(const char *path,
 -		      const unsigned char *expected_sha1,
 +		      const struct object_id *expected_oid,
  		      enum object_type *type,
  		      unsigned long *size,
  		      void **contents)
@@@ -2199,7 -2177,7 +2195,7 @@@
  	void *map = NULL;
  	unsigned long mapsize;
  	git_zstream stream;
 -	char hdr[32];
 +	char hdr[MAX_HEADER_LEN];
  
  	*contents = NULL;
  
@@@ -2222,19 -2200,19 +2218,19 @@@
  	}
  
  	if (*type == OBJ_BLOB) {
 -		if (check_stream_sha1(&stream, hdr, *size, path, expected_sha1) < 0)
 +		if (check_stream_sha1(&stream, hdr, *size, path, expected_oid->hash) < 0)
  			goto out;
  	} else {
 -		*contents = unpack_sha1_rest(&stream, hdr, *size, expected_sha1);
 +		*contents = unpack_sha1_rest(&stream, hdr, *size, expected_oid->hash);
  		if (!*contents) {
  			error("unable to unpack contents of %s", path);
  			git_inflate_end(&stream);
  			goto out;
  		}
 -		if (check_sha1_signature(expected_sha1, *contents,
 -					 *size, typename(*type))) {
 +		if (check_object_signature(expected_oid, *contents,
 +					 *size, type_name(*type))) {
  			error("sha1 mismatch for %s (expected %s)", path,
 -			      sha1_to_hex(expected_sha1));
 +			      oid_to_hex(expected_oid));
  			free(*contents);
  			goto out;
  		}