2017-03-12 01:28:18 +03:00
|
|
|
#ifndef HASH_H
|
|
|
|
#define HASH_H
|
|
|
|
|
2017-11-13 00:28:52 +03:00
|
|
|
#include "git-compat-util.h"
|
2020-12-04 21:51:39 +03:00
|
|
|
#include "repository.h"
|
2017-11-13 00:28:52 +03:00
|
|
|
|
2017-03-12 01:28:18 +03:00
|
|
|
#if defined(SHA1_PPC)
|
|
|
|
#include "ppc/sha1.h"
|
|
|
|
#elif defined(SHA1_APPLE)
|
|
|
|
#include <CommonCrypto/CommonDigest.h>
|
|
|
|
#elif defined(SHA1_OPENSSL)
|
|
|
|
#include <openssl/sha.h>
|
2017-03-17 01:09:12 +03:00
|
|
|
#elif defined(SHA1_DC)
|
2017-08-15 15:04:16 +03:00
|
|
|
#include "sha1dc_git.h"
|
2017-03-12 01:28:18 +03:00
|
|
|
#else /* SHA1_BLK */
|
|
|
|
#include "block-sha1/sha1.h"
|
|
|
|
#endif
|
|
|
|
|
sha256: add support for Nettle
For SHA-256, we currently have support for OpenSSL and libgcrypt because
these two libraries contain optimized implementations that can take
advantage of native processor instructions. However, OpenSSL is not
suitable for linking against for Linux distros due to licensing
incompatibilities with the GPLv2, and libgcrypt has been less favored by
cryptographers due to some security-related implementation issues,
which, while not affecting our use of hash algorithms, has affected its
reputation.
Let's add another option that's compatible with the GPLv2, which is
Nettle. This is an option which is generally better than libgcrypt
because on many distros GnuTLS (which uses Nettle) is used for HTTPS and
therefore as a practical matter it will be available on most systems.
As a result, prefer it over libgcrypt and our built-in implementation.
Nettle also has recently gained support for Intel's SHA-NI instructions,
which compare very favorably to other implementations, as well as
assembly implementations for when SHA-NI is not available.
A git gc on git.git sees a 12% performance improvement with Nettle over
our block SHA-256 implementation due to general assembly improvements.
With SHA-NI, the performance of raw SHA-256 on a 2 GiB file goes from
7.296 seconds with block SHA-256 to 1.523 seconds with Nettle.
Signed-off-by: brian m. carlson <sandals@crustytoothpaste.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2022-07-10 16:29:07 +03:00
|
|
|
#if defined(SHA256_NETTLE)
|
|
|
|
#include "sha256/nettle.h"
|
|
|
|
#elif defined(SHA256_GCRYPT)
|
2020-02-22 23:17:27 +03:00
|
|
|
#define SHA256_NEEDS_CLONE_HELPER
|
2018-11-14 07:09:37 +03:00
|
|
|
#include "sha256/gcrypt.h"
|
2018-11-14 07:09:38 +03:00
|
|
|
#elif defined(SHA256_OPENSSL)
|
|
|
|
#include <openssl/sha.h>
|
2018-11-14 07:09:37 +03:00
|
|
|
#else
|
2018-11-14 07:09:36 +03:00
|
|
|
#include "sha256/block/sha256.h"
|
2018-11-14 07:09:37 +03:00
|
|
|
#endif
|
2018-11-14 07:09:36 +03:00
|
|
|
|
2018-02-01 05:18:37 +03:00
|
|
|
#ifndef platform_SHA_CTX
|
|
|
|
/*
|
|
|
|
* platform's underlying implementation of SHA-1; could be OpenSSL,
|
2018-02-08 05:48:58 +03:00
|
|
|
* blk_SHA, Apple CommonCrypto, etc... Note that the relevant
|
|
|
|
* SHA-1 header may have already defined platform_SHA_CTX for our
|
2018-02-01 05:18:37 +03:00
|
|
|
* 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
|
|
|
|
|
2018-11-14 07:09:36 +03:00
|
|
|
#ifndef platform_SHA256_CTX
|
|
|
|
#define platform_SHA256_CTX SHA256_CTX
|
|
|
|
#define platform_SHA256_Init SHA256_Init
|
|
|
|
#define platform_SHA256_Update SHA256_Update
|
|
|
|
#define platform_SHA256_Final SHA256_Final
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#define git_SHA256_CTX platform_SHA256_CTX
|
|
|
|
#define git_SHA256_Init platform_SHA256_Init
|
|
|
|
#define git_SHA256_Update platform_SHA256_Update
|
|
|
|
#define git_SHA256_Final platform_SHA256_Final
|
|
|
|
|
2020-02-22 23:17:27 +03:00
|
|
|
#ifdef platform_SHA256_Clone
|
|
|
|
#define git_SHA256_Clone platform_SHA256_Clone
|
|
|
|
#endif
|
|
|
|
|
2018-02-01 05:18:37 +03:00
|
|
|
#ifdef SHA1_MAX_BLOCK_SIZE
|
|
|
|
#include "compat/sha1-chunked.h"
|
|
|
|
#undef git_SHA1_Update
|
|
|
|
#define git_SHA1_Update git_SHA1_Update_Chunked
|
|
|
|
#endif
|
|
|
|
|
2020-02-22 23:17:27 +03:00
|
|
|
static inline void git_SHA1_Clone(git_SHA_CTX *dst, const git_SHA_CTX *src)
|
|
|
|
{
|
|
|
|
memcpy(dst, src, sizeof(*dst));
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifndef SHA256_NEEDS_CLONE_HELPER
|
|
|
|
static inline void git_SHA256_Clone(git_SHA256_CTX *dst, const git_SHA256_CTX *src)
|
|
|
|
{
|
|
|
|
memcpy(dst, src, sizeof(*dst));
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2017-11-13 00:28:52 +03:00
|
|
|
/*
|
|
|
|
* Note that these constants are suitable for indexing the hash_algos array and
|
|
|
|
* comparing against each other, but are otherwise arbitrary, so they should not
|
|
|
|
* be exposed to the user or serialized to disk. To know whether a
|
|
|
|
* git_hash_algo struct points to some usable hash function, test the format_id
|
|
|
|
* field for being non-zero. Use the name field for user-visible situations and
|
|
|
|
* the format_id field for fixed-length fields on disk.
|
|
|
|
*/
|
|
|
|
/* An unknown hash function. */
|
|
|
|
#define GIT_HASH_UNKNOWN 0
|
|
|
|
/* SHA-1 */
|
|
|
|
#define GIT_HASH_SHA1 1
|
2018-11-14 07:09:36 +03:00
|
|
|
/* SHA-256 */
|
|
|
|
#define GIT_HASH_SHA256 2
|
2017-11-13 00:28:52 +03:00
|
|
|
/* Number of algorithms supported (including unknown). */
|
2018-11-14 07:09:36 +03:00
|
|
|
#define GIT_HASH_NALGOS (GIT_HASH_SHA256 + 1)
|
2017-11-13 00:28:52 +03:00
|
|
|
|
2021-08-30 17:57:37 +03:00
|
|
|
/* "sha1", big-endian */
|
|
|
|
#define GIT_SHA1_FORMAT_ID 0x73686131
|
|
|
|
|
2021-04-26 04:02:52 +03:00
|
|
|
/* The length in bytes and in hex digits of an object name (SHA-1 value). */
|
|
|
|
#define GIT_SHA1_RAWSZ 20
|
|
|
|
#define GIT_SHA1_HEXSZ (2 * GIT_SHA1_RAWSZ)
|
|
|
|
/* The block size of SHA-1. */
|
|
|
|
#define GIT_SHA1_BLKSZ 64
|
|
|
|
|
2021-08-30 17:57:37 +03:00
|
|
|
/* "s256", big-endian */
|
|
|
|
#define GIT_SHA256_FORMAT_ID 0x73323536
|
|
|
|
|
2021-04-26 04:02:52 +03:00
|
|
|
/* The length in bytes and in hex digits of an object name (SHA-256 value). */
|
|
|
|
#define GIT_SHA256_RAWSZ 32
|
|
|
|
#define GIT_SHA256_HEXSZ (2 * GIT_SHA256_RAWSZ)
|
|
|
|
/* The block size of SHA-256. */
|
|
|
|
#define GIT_SHA256_BLKSZ 64
|
|
|
|
|
|
|
|
/* The length in byte and in hex digits of the largest possible hash value. */
|
|
|
|
#define GIT_MAX_RAWSZ GIT_SHA256_RAWSZ
|
|
|
|
#define GIT_MAX_HEXSZ GIT_SHA256_HEXSZ
|
|
|
|
/* The largest possible block size for any supported hash. */
|
|
|
|
#define GIT_MAX_BLKSZ GIT_SHA256_BLKSZ
|
|
|
|
|
|
|
|
struct object_id {
|
|
|
|
unsigned char hash[GIT_MAX_RAWSZ];
|
oidtree: avoid unaligned access to crit-bit tree
The flexible array member "k" of struct cb_node is used to store the key
of the crit-bit tree node. It offers no alignment guarantees -- in fact
the current struct layout puts it one byte after a 4-byte aligned
address, i.e. guaranteed to be misaligned.
oidtree uses a struct object_id as cb_node key. Since cf0983213c (hash:
add an algo member to struct object_id, 2021-04-26) it requires 4-byte
alignment. The mismatch is reported by UndefinedBehaviorSanitizer at
runtime like this:
hash.h:277:2: runtime error: member access within misaligned address 0x00015000802d for type 'struct object_id', which requires 4 byte alignment
0x00015000802d: note: pointer points here
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
^
SUMMARY: UndefinedBehaviorSanitizer: undefined-behavior hash.h:277:2 in
We can fix that by:
1. eliminating the alignment requirement of struct object_id,
2. providing the alignment in struct cb_node, or
3. avoiding the issue by only using memcpy to access "k".
Currently we only store one of two values in "algo" in struct object_id.
We could use a uint8_t for that instead and widen it only once we add
support for our twohundredth algorithm or so. That would not only avoid
alignment issues, but also reduce the memory requirements for each
instance of struct object_id by ca. 9%.
Supporting keys with alignment requirements might be useful to spread
the use of crit-bit trees. It can be achieved by using a wider type for
"k" (e.g. uintmax_t), using different types for the members "byte" and
"otherbits" (e.g. uint16_t or uint32_t for each), or by avoiding the use
of flexible arrays like khash.h does.
This patch implements the third option, though, because it has the least
potential for causing side-effects and we're close to the next release.
If one of the other options is implemented later as well to get their
additional benefits we can get rid of the extra copies introduced here.
Reported-by: Andrzej Hunt <andrzej@ahunt.org>
Signed-off-by: René Scharfe <l.s.r@web.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2021-08-14 23:00:38 +03:00
|
|
|
int algo; /* XXX requires 4-byte alignment */
|
2021-04-26 04:02:52 +03:00
|
|
|
};
|
|
|
|
|
2018-02-01 05:18:38 +03:00
|
|
|
/* A suitably aligned type for stack allocations of hash contexts. */
|
|
|
|
union git_hash_ctx {
|
|
|
|
git_SHA_CTX sha1;
|
2018-11-14 07:09:36 +03:00
|
|
|
git_SHA256_CTX sha256;
|
2018-02-01 05:18:38 +03:00
|
|
|
};
|
|
|
|
typedef union git_hash_ctx git_hash_ctx;
|
|
|
|
|
|
|
|
typedef void (*git_hash_init_fn)(git_hash_ctx *ctx);
|
2020-02-22 23:17:27 +03:00
|
|
|
typedef void (*git_hash_clone_fn)(git_hash_ctx *dst, const git_hash_ctx *src);
|
2018-02-01 05:18:38 +03:00
|
|
|
typedef void (*git_hash_update_fn)(git_hash_ctx *ctx, const void *in, size_t len);
|
|
|
|
typedef void (*git_hash_final_fn)(unsigned char *hash, git_hash_ctx *ctx);
|
2021-04-26 04:02:52 +03:00
|
|
|
typedef void (*git_hash_final_oid_fn)(struct object_id *oid, git_hash_ctx *ctx);
|
2017-11-13 00:28:52 +03:00
|
|
|
|
|
|
|
struct git_hash_algo {
|
|
|
|
/*
|
|
|
|
* The name of the algorithm, as appears in the config file and in
|
|
|
|
* messages.
|
|
|
|
*/
|
|
|
|
const char *name;
|
|
|
|
|
|
|
|
/* A four-byte version identifier, used in pack indices. */
|
|
|
|
uint32_t format_id;
|
|
|
|
|
|
|
|
/* The length of the hash in binary. */
|
|
|
|
size_t rawsz;
|
|
|
|
|
|
|
|
/* The length of the hash in hex characters. */
|
|
|
|
size_t hexsz;
|
|
|
|
|
2018-11-14 07:09:33 +03:00
|
|
|
/* The block size of the hash. */
|
|
|
|
size_t blksz;
|
|
|
|
|
2017-11-13 00:28:52 +03:00
|
|
|
/* The hash initialization function. */
|
|
|
|
git_hash_init_fn init_fn;
|
|
|
|
|
2020-02-22 23:17:27 +03:00
|
|
|
/* The hash context cloning function. */
|
|
|
|
git_hash_clone_fn clone_fn;
|
|
|
|
|
2017-11-13 00:28:52 +03:00
|
|
|
/* The hash update function. */
|
|
|
|
git_hash_update_fn update_fn;
|
|
|
|
|
|
|
|
/* The hash finalization function. */
|
|
|
|
git_hash_final_fn final_fn;
|
|
|
|
|
2021-04-26 04:02:52 +03:00
|
|
|
/* The hash finalization function for object IDs. */
|
|
|
|
git_hash_final_oid_fn final_oid_fn;
|
|
|
|
|
2017-11-13 00:28:52 +03:00
|
|
|
/* The OID of the empty tree. */
|
|
|
|
const struct object_id *empty_tree;
|
|
|
|
|
|
|
|
/* The OID of the empty blob. */
|
|
|
|
const struct object_id *empty_blob;
|
2021-04-26 04:02:56 +03:00
|
|
|
|
|
|
|
/* The all-zeros OID. */
|
|
|
|
const struct object_id *null_oid;
|
2017-11-13 00:28:52 +03:00
|
|
|
};
|
|
|
|
extern const struct git_hash_algo hash_algos[GIT_HASH_NALGOS];
|
|
|
|
|
2018-10-22 05:43:32 +03:00
|
|
|
/*
|
|
|
|
* Return a GIT_HASH_* constant based on the name. Returns GIT_HASH_UNKNOWN if
|
|
|
|
* the name doesn't match a known algorithm.
|
|
|
|
*/
|
|
|
|
int hash_algo_by_name(const char *name);
|
|
|
|
/* Identical, except based on the format ID. */
|
|
|
|
int hash_algo_by_id(uint32_t format_id);
|
2019-02-19 03:05:17 +03:00
|
|
|
/* Identical, except based on the length. */
|
|
|
|
int hash_algo_by_length(int len);
|
2018-10-22 05:43:32 +03:00
|
|
|
/* Identical, except for a pointer to struct git_hash_algo. */
|
|
|
|
static inline int hash_algo_by_ptr(const struct git_hash_algo *p)
|
|
|
|
{
|
|
|
|
return p - hash_algos;
|
|
|
|
}
|
|
|
|
|
2019-06-20 10:41:45 +03:00
|
|
|
#define the_hash_algo the_repository->hash_algo
|
|
|
|
|
2021-04-26 04:02:56 +03:00
|
|
|
const struct object_id *null_oid(void);
|
2020-12-04 21:51:39 +03:00
|
|
|
|
2021-04-26 04:02:55 +03:00
|
|
|
static inline int hashcmp_algop(const unsigned char *sha1, const unsigned char *sha2, const struct git_hash_algo *algop)
|
2020-12-04 21:51:39 +03:00
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Teach the compiler that there are only two possibilities of hash size
|
|
|
|
* here, so that it can optimize for this case as much as possible.
|
|
|
|
*/
|
2021-04-26 04:02:55 +03:00
|
|
|
if (algop->rawsz == GIT_MAX_RAWSZ)
|
2020-12-04 21:51:39 +03:00
|
|
|
return memcmp(sha1, sha2, GIT_MAX_RAWSZ);
|
|
|
|
return memcmp(sha1, sha2, GIT_SHA1_RAWSZ);
|
|
|
|
}
|
|
|
|
|
2021-04-26 04:02:55 +03:00
|
|
|
static inline int hashcmp(const unsigned char *sha1, const unsigned char *sha2)
|
|
|
|
{
|
|
|
|
return hashcmp_algop(sha1, sha2, the_hash_algo);
|
|
|
|
}
|
|
|
|
|
2020-12-04 21:51:39 +03:00
|
|
|
static inline int oidcmp(const struct object_id *oid1, const struct object_id *oid2)
|
|
|
|
{
|
2021-04-26 04:02:55 +03:00
|
|
|
const struct git_hash_algo *algop;
|
|
|
|
if (!oid1->algo)
|
|
|
|
algop = the_hash_algo;
|
|
|
|
else
|
|
|
|
algop = &hash_algos[oid1->algo];
|
|
|
|
return hashcmp_algop(oid1->hash, oid2->hash, algop);
|
2020-12-04 21:51:39 +03:00
|
|
|
}
|
|
|
|
|
2021-04-26 04:02:55 +03:00
|
|
|
static inline int hasheq_algop(const unsigned char *sha1, const unsigned char *sha2, const struct git_hash_algo *algop)
|
2020-12-04 21:51:39 +03:00
|
|
|
{
|
|
|
|
/*
|
|
|
|
* We write this here instead of deferring to hashcmp so that the
|
|
|
|
* compiler can properly inline it and avoid calling memcmp.
|
|
|
|
*/
|
2021-04-26 04:02:55 +03:00
|
|
|
if (algop->rawsz == GIT_MAX_RAWSZ)
|
2020-12-04 21:51:39 +03:00
|
|
|
return !memcmp(sha1, sha2, GIT_MAX_RAWSZ);
|
|
|
|
return !memcmp(sha1, sha2, GIT_SHA1_RAWSZ);
|
|
|
|
}
|
|
|
|
|
2021-04-26 04:02:55 +03:00
|
|
|
static inline int hasheq(const unsigned char *sha1, const unsigned char *sha2)
|
|
|
|
{
|
|
|
|
return hasheq_algop(sha1, sha2, the_hash_algo);
|
|
|
|
}
|
|
|
|
|
2020-12-04 21:51:39 +03:00
|
|
|
static inline int oideq(const struct object_id *oid1, const struct object_id *oid2)
|
|
|
|
{
|
2021-04-26 04:02:55 +03:00
|
|
|
const struct git_hash_algo *algop;
|
|
|
|
if (!oid1->algo)
|
|
|
|
algop = the_hash_algo;
|
|
|
|
else
|
|
|
|
algop = &hash_algos[oid1->algo];
|
|
|
|
return hasheq_algop(oid1->hash, oid2->hash, algop);
|
2020-12-04 21:51:39 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline int is_null_oid(const struct object_id *oid)
|
|
|
|
{
|
2021-04-26 04:02:56 +03:00
|
|
|
return oideq(oid, null_oid());
|
2020-12-04 21:51:39 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void hashcpy(unsigned char *sha_dst, const unsigned char *sha_src)
|
|
|
|
{
|
|
|
|
memcpy(sha_dst, sha_src, the_hash_algo->rawsz);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void oidcpy(struct object_id *dst, const struct object_id *src)
|
|
|
|
{
|
|
|
|
memcpy(dst->hash, src->hash, GIT_MAX_RAWSZ);
|
2021-04-26 04:02:55 +03:00
|
|
|
dst->algo = src->algo;
|
2020-12-04 21:51:39 +03:00
|
|
|
}
|
|
|
|
|
parallel-checkout: send the new object_id algo field to the workers
An object_id storing a SHA-1 name has some unused bytes at the end of
the hash array. Since these bytes are not used, they are usually not
initialized to any value either. However, at
parallel_checkout.c:send_one_item() the object_id of a cache entry is
copied into a buffer which is later sent to a checkout worker through a
pipe write(). This makes Valgrind complain about passing uninitialized
bytes to a syscall. The worker won't use these uninitialized bytes
either, but the warning could confuse someone trying to debug this code;
So instead of using oidcpy(), send_one_item() uses hashcpy() to only
copy the used/initialized bytes of the object_id, and leave the
remaining part with zeros.
However, since cf0983213c ("hash: add an algo member to struct
object_id", 2021-04-26), using hashcpy() is no longer sufficient here as
it won't copy the new algo field from the object_id. Let's add and use a
new function which meets both our requirements of copying all the
important object_id data while still avoiding the uninitialized bytes,
by padding the end of the hash array in the destination object_id. With
this change, we also no longer need the destination buffer from
send_one_item() to be initialized with zeros, so let's switch from
xcalloc() to xmalloc() to make this clear.
Signed-off-by: Matheus Tavares <matheus.bernardino@usp.br>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2021-05-17 22:49:03 +03:00
|
|
|
/* Like oidcpy() but zero-pads the unused bytes in dst's hash array. */
|
|
|
|
static inline void oidcpy_with_padding(struct object_id *dst,
|
2021-07-08 02:10:18 +03:00
|
|
|
const struct object_id *src)
|
parallel-checkout: send the new object_id algo field to the workers
An object_id storing a SHA-1 name has some unused bytes at the end of
the hash array. Since these bytes are not used, they are usually not
initialized to any value either. However, at
parallel_checkout.c:send_one_item() the object_id of a cache entry is
copied into a buffer which is later sent to a checkout worker through a
pipe write(). This makes Valgrind complain about passing uninitialized
bytes to a syscall. The worker won't use these uninitialized bytes
either, but the warning could confuse someone trying to debug this code;
So instead of using oidcpy(), send_one_item() uses hashcpy() to only
copy the used/initialized bytes of the object_id, and leave the
remaining part with zeros.
However, since cf0983213c ("hash: add an algo member to struct
object_id", 2021-04-26), using hashcpy() is no longer sufficient here as
it won't copy the new algo field from the object_id. Let's add and use a
new function which meets both our requirements of copying all the
important object_id data while still avoiding the uninitialized bytes,
by padding the end of the hash array in the destination object_id. With
this change, we also no longer need the destination buffer from
send_one_item() to be initialized with zeros, so let's switch from
xcalloc() to xmalloc() to make this clear.
Signed-off-by: Matheus Tavares <matheus.bernardino@usp.br>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2021-05-17 22:49:03 +03:00
|
|
|
{
|
|
|
|
size_t hashsz;
|
|
|
|
|
|
|
|
if (!src->algo)
|
|
|
|
hashsz = the_hash_algo->rawsz;
|
|
|
|
else
|
|
|
|
hashsz = hash_algos[src->algo].rawsz;
|
|
|
|
|
|
|
|
memcpy(dst->hash, src->hash, hashsz);
|
|
|
|
memset(dst->hash + hashsz, 0, GIT_MAX_RAWSZ - hashsz);
|
|
|
|
dst->algo = src->algo;
|
|
|
|
}
|
|
|
|
|
2020-12-04 21:51:39 +03:00
|
|
|
static inline struct object_id *oiddup(const struct object_id *src)
|
|
|
|
{
|
|
|
|
struct object_id *dst = xmalloc(sizeof(struct object_id));
|
|
|
|
oidcpy(dst, src);
|
|
|
|
return dst;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void hashclr(unsigned char *hash)
|
|
|
|
{
|
|
|
|
memset(hash, 0, the_hash_algo->rawsz);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void oidclr(struct object_id *oid)
|
|
|
|
{
|
|
|
|
memset(oid->hash, 0, GIT_MAX_RAWSZ);
|
2021-04-26 04:02:55 +03:00
|
|
|
oid->algo = hash_algo_by_ptr(the_hash_algo);
|
2020-12-04 21:51:39 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void oidread(struct object_id *oid, const unsigned char *hash)
|
|
|
|
{
|
|
|
|
memcpy(oid->hash, hash, the_hash_algo->rawsz);
|
2021-04-26 04:02:55 +03:00
|
|
|
oid->algo = hash_algo_by_ptr(the_hash_algo);
|
2020-12-04 21:51:39 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline int is_empty_blob_sha1(const unsigned char *sha1)
|
|
|
|
{
|
|
|
|
return hasheq(sha1, the_hash_algo->empty_blob->hash);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int is_empty_blob_oid(const struct object_id *oid)
|
|
|
|
{
|
|
|
|
return oideq(oid, the_hash_algo->empty_blob);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int is_empty_tree_sha1(const unsigned char *sha1)
|
|
|
|
{
|
|
|
|
return hasheq(sha1, the_hash_algo->empty_tree->hash);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int is_empty_tree_oid(const struct object_id *oid)
|
|
|
|
{
|
|
|
|
return oideq(oid, the_hash_algo->empty_tree);
|
|
|
|
}
|
|
|
|
|
2021-04-26 04:02:55 +03:00
|
|
|
static inline void oid_set_algo(struct object_id *oid, const struct git_hash_algo *algop)
|
|
|
|
{
|
|
|
|
oid->algo = hash_algo_by_ptr(algop);
|
|
|
|
}
|
|
|
|
|
2020-12-04 21:51:39 +03:00
|
|
|
const char *empty_tree_oid_hex(void);
|
|
|
|
const char *empty_blob_oid_hex(void);
|
|
|
|
|
2017-03-12 01:28:18 +03:00
|
|
|
#endif
|