[thirdparty/git.git] / hash.h

#ifndef HASH_H
#define HASH_H

#include "git-compat-util.h"

#if defined(SHA1_PPC)
#include "ppc/sha1.h"
#elif defined(SHA1_APPLE)
#include <CommonCrypto/CommonDigest.h>
#elif defined(SHA1_OPENSSL)
#include <openssl/sha.h>
#elif defined(SHA1_DC)
#include "sha1dc_git.h"
#else /* SHA1_BLK */
#include "block-sha1/sha1.h"
#endif

#if defined(SHA256_GCRYPT)
#include "sha256/gcrypt.h"
#elif defined(SHA256_OPENSSL)
#include <openssl/sha.h>
#else
#include "sha256/block/sha256.h"
#endif

#ifndef platform_SHA_CTX
/*
 * platform's underlying implementation of SHA-1; could be OpenSSL,
 * blk_SHA, Apple CommonCrypto, etc...  Note that the relevant
 * SHA-1 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

#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

#ifdef SHA1_MAX_BLOCK_SIZE
#include "compat/sha1-chunked.h"
#undef git_SHA1_Update
#define git_SHA1_Update		git_SHA1_Update_Chunked
#endif

/*
 * 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
/* SHA-256  */
#define GIT_HASH_SHA256 2
/* Number of algorithms supported (including unknown). */
#define GIT_HASH_NALGOS (GIT_HASH_SHA256 + 1)

/* A suitably aligned type for stack allocations of hash contexts. */
union git_hash_ctx {
	git_SHA_CTX sha1;
	git_SHA256_CTX sha256;
};
typedef union git_hash_ctx git_hash_ctx;

typedef void (*git_hash_init_fn)(git_hash_ctx *ctx);
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);

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;

	/* The block size of the hash. */
	size_t blksz;

	/* The hash initialization function. */
	git_hash_init_fn init_fn;

	/* The hash update function. */
	git_hash_update_fn update_fn;

	/* The hash finalization function. */
	git_hash_final_fn final_fn;

	/* The OID of the empty tree. */
	const struct object_id *empty_tree;

	/* The OID of the empty blob. */
	const struct object_id *empty_blob;
};
extern const struct git_hash_algo hash_algos[GIT_HASH_NALGOS];

/*
 * 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);
/* Identical, except based on the length. */
int hash_algo_by_length(int len);
/* 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;
}

/* 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

/* 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];
};

#define the_hash_algo the_repository->hash_algo

#endif
Commit	Line	Data
	1	#ifndef HASH_H
	2	#define HASH_H
	3
	4	#include "git-compat-util.h"
	5
	6	#if defined(SHA1_PPC)
	7	#include "ppc/sha1.h"
	8	#elif defined(SHA1_APPLE)
	9	#include <CommonCrypto/CommonDigest.h>
	10	#elif defined(SHA1_OPENSSL)
	11	#include <openssl/sha.h>
	12	#elif defined(SHA1_DC)
	13	#include "sha1dc_git.h"
	14	#else /* SHA1_BLK */
	15	#include "block-sha1/sha1.h"
	16	#endif
	17
	18	#if defined(SHA256_GCRYPT)
	19	#include "sha256/gcrypt.h"
	20	#elif defined(SHA256_OPENSSL)
	21	#include <openssl/sha.h>
	22	#else
	23	#include "sha256/block/sha256.h"
	24	#endif
	25
	26	#ifndef platform_SHA_CTX
	27	/*
	28	* platform's underlying implementation of SHA-1; could be OpenSSL,
	29	* blk_SHA, Apple CommonCrypto, etc... Note that the relevant
	30	* SHA-1 header may have already defined platform_SHA_CTX for our
	31	* own implementations like block-sha1 and ppc-sha1, so we list
	32	* the default for OpenSSL compatible SHA-1 implementations here.
	33	*/
	34	#define platform_SHA_CTX SHA_CTX
	35	#define platform_SHA1_Init SHA1_Init
	36	#define platform_SHA1_Update SHA1_Update
	37	#define platform_SHA1_Final SHA1_Final
	38	#endif
	39
	40	#define git_SHA_CTX platform_SHA_CTX
	41	#define git_SHA1_Init platform_SHA1_Init
	42	#define git_SHA1_Update platform_SHA1_Update
	43	#define git_SHA1_Final platform_SHA1_Final
	44
	45	#ifndef platform_SHA256_CTX
	46	#define platform_SHA256_CTX SHA256_CTX
	47	#define platform_SHA256_Init SHA256_Init
	48	#define platform_SHA256_Update SHA256_Update
	49	#define platform_SHA256_Final SHA256_Final
	50	#endif
	51
	52	#define git_SHA256_CTX platform_SHA256_CTX
	53	#define git_SHA256_Init platform_SHA256_Init
	54	#define git_SHA256_Update platform_SHA256_Update
	55	#define git_SHA256_Final platform_SHA256_Final
	56
	57	#ifdef SHA1_MAX_BLOCK_SIZE
	58	#include "compat/sha1-chunked.h"
	59	#undef git_SHA1_Update
	60	#define git_SHA1_Update git_SHA1_Update_Chunked
	61	#endif
	62
	63	/*
	64	* Note that these constants are suitable for indexing the hash_algos array and
	65	* comparing against each other, but are otherwise arbitrary, so they should not
	66	* be exposed to the user or serialized to disk. To know whether a
	67	* git_hash_algo struct points to some usable hash function, test the format_id
	68	* field for being non-zero. Use the name field for user-visible situations and
	69	* the format_id field for fixed-length fields on disk.
	70	*/
	71	/* An unknown hash function. */
	72	#define GIT_HASH_UNKNOWN 0
	73	/* SHA-1 */
	74	#define GIT_HASH_SHA1 1
	75	/* SHA-256 */
	76	#define GIT_HASH_SHA256 2
	77	/* Number of algorithms supported (including unknown). */
	78	#define GIT_HASH_NALGOS (GIT_HASH_SHA256 + 1)
	79
	80	/* A suitably aligned type for stack allocations of hash contexts. */
	81	union git_hash_ctx {
	82	git_SHA_CTX sha1;
	83	git_SHA256_CTX sha256;
	84	};
	85	typedef union git_hash_ctx git_hash_ctx;
	86
	87	typedef void (git_hash_init_fn)(git_hash_ctx ctx);
	88	typedef void (git_hash_update_fn)(git_hash_ctx ctx, const void *in, size_t len);
	89	typedef void (git_hash_final_fn)(unsigned char hash, git_hash_ctx *ctx);
	90
	91	struct git_hash_algo {
	92	/*
	93	* The name of the algorithm, as appears in the config file and in
	94	* messages.
	95	*/
	96	const char *name;
	97
	98	/* A four-byte version identifier, used in pack indices. */
	99	uint32_t format_id;
	100
	101	/* The length of the hash in binary. */
	102	size_t rawsz;
	103
	104	/* The length of the hash in hex characters. */
	105	size_t hexsz;
	106
	107	/* The block size of the hash. */
	108	size_t blksz;
	109
	110	/* The hash initialization function. */
	111	git_hash_init_fn init_fn;
	112
	113	/* The hash update function. */
	114	git_hash_update_fn update_fn;
	115
	116	/* The hash finalization function. */
	117	git_hash_final_fn final_fn;
	118
	119	/* The OID of the empty tree. */
	120	const struct object_id *empty_tree;
	121
	122	/* The OID of the empty blob. */
	123	const struct object_id *empty_blob;
	124	};
	125	extern const struct git_hash_algo hash_algos[GIT_HASH_NALGOS];
	126
	127	/*
	128	* Return a GIT_HASH_* constant based on the name. Returns GIT_HASH_UNKNOWN if
	129	* the name doesn't match a known algorithm.
	130	*/
	131	int hash_algo_by_name(const char *name);
	132	/* Identical, except based on the format ID. */
	133	int hash_algo_by_id(uint32_t format_id);
	134	/* Identical, except based on the length. */
	135	int hash_algo_by_length(int len);
	136	/* Identical, except for a pointer to struct git_hash_algo. */
	137	static inline int hash_algo_by_ptr(const struct git_hash_algo *p)
	138	{
	139	return p - hash_algos;
	140	}
	141
	142	/* The length in bytes and in hex digits of an object name (SHA-1 value). */
	143	#define GIT_SHA1_RAWSZ 20
	144	#define GIT_SHA1_HEXSZ (2 * GIT_SHA1_RAWSZ)
	145	/* The block size of SHA-1. */
	146	#define GIT_SHA1_BLKSZ 64
	147
	148	/* The length in bytes and in hex digits of an object name (SHA-256 value). */
	149	#define GIT_SHA256_RAWSZ 32
	150	#define GIT_SHA256_HEXSZ (2 * GIT_SHA256_RAWSZ)
	151	/* The block size of SHA-256. */
	152	#define GIT_SHA256_BLKSZ 64
	153
	154	/* The length in byte and in hex digits of the largest possible hash value. */
	155	#define GIT_MAX_RAWSZ GIT_SHA256_RAWSZ
	156	#define GIT_MAX_HEXSZ GIT_SHA256_HEXSZ
	157	/* The largest possible block size for any supported hash. */
	158	#define GIT_MAX_BLKSZ GIT_SHA256_BLKSZ
	159
	160	struct object_id {
	161	unsigned char hash[GIT_MAX_RAWSZ];
	162	};
	163
	164	#define the_hash_algo the_repository->hash_algo
	165
	166	#endif