Merge branch 'nd/remove-ignore-env-field'
authorJunio C Hamano <gitster@pobox.com>
Tue, 10 Apr 2018 07:28:20 +0000 (16:28 +0900)
committerJunio C Hamano <gitster@pobox.com>
Tue, 10 Apr 2018 07:28:20 +0000 (16:28 +0900)
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()

1  2 
cache.h
environment.c
setup.c
sha1_file.c
diff --combined cache.h
index 83ba2d2b03d7fbe6b0a30822177ac2fad11e96b4,41ba67cc16f772176b77513742c2d4ae7b986cc3..6e45c1b5377cfca2e0621d529f69daac304e3f12
+++ b/cache.h
  #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,
   * 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
   * 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 */
  #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 d6dd64662ce4d09296b61708b020a71eef3488f6,a5eaa97fb1946157e45fd6d7bf8dada47ef7e576..21565c3c525c64793282d8c3f029733615a87fc2
@@@ -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;
        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;
        /*
         * 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 72877796420b06213665f5d357decb202e71fa91,6fac1bb58a7b2b2521f126d14aabbc8682b14fa0..664453fcef7f3b75f56d000dc52f42a0aff42fb6
+++ 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) {
                        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)) {
                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);
                }
        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;
        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);
        }
  
        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);
  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:
                        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:
                        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 1c61d9d9273f14f669b703271cc3f34dd5ca57c7,4af422e3cfe29c45816632a005510b0e71864eff..aea9124a78fce21eb4cb756af29823493274e581
@@@ -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));
                }
                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;
  
         * 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)
  
  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;
                                *(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;
        }
  
        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 &&
                         * 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;
                }
                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;
  }
  
  /* 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;
  }
  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++];
        co->type = type;
        co->buf = xmalloc(len);
        memcpy(co->buf, buf, len);
 -      hashcpy(co->sha1, sha1);
 +      hashcpy(co->sha1, oid->hash);
        return 0;
  }
  
   * 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 */
                }
                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) {
        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;
        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;
        } 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;
  
  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
                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);
                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));
  }
  
  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)
        void *map = NULL;
        unsigned long mapsize;
        git_zstream stream;
 -      char hdr[32];
 +      char hdr[MAX_HEADER_LEN];
  
        *contents = NULL;
  
        }
  
        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;
                }