mirror of
https://github.com/git/git.git
synced 2024-11-27 03:53:55 +08:00
8a676bdc5c
The "hash-ll.h" header was introduced via d1cbe1e6d8 (hash-ll.h: split
out of hash.h to remove dependency on repository.h, 2023-04-22) to make
explicit the split between hash-related functions that rely on the
global `the_repository`, and those that don't. This split is no longer
necessary now that we we have removed the reliance on `the_repository`.
Merge "hash-ll.h" back into "hash.h". This causes some code units to not
include "repository.h" anymore, which requires us to add some forward
declarations.
Signed-off-by: Patrick Steinhardt <ps@pks.im>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
280 lines
8.1 KiB
C
280 lines
8.1 KiB
C
#define USE_THE_REPOSITORY_VARIABLE
|
|
|
|
#include "git-compat-util.h"
|
|
#include "gettext.h"
|
|
#include "strbuf.h"
|
|
#include "hex.h"
|
|
#include "repository.h"
|
|
#include "hash.h"
|
|
#include "hash.h"
|
|
#include "object.h"
|
|
#include "loose.h"
|
|
#include "commit.h"
|
|
#include "gpg-interface.h"
|
|
#include "object-file-convert.h"
|
|
|
|
int repo_oid_to_algop(struct repository *repo, const struct object_id *src,
|
|
const struct git_hash_algo *to, struct object_id *dest)
|
|
{
|
|
/*
|
|
* If the source algorithm is not set, then we're using the
|
|
* default hash algorithm for that object.
|
|
*/
|
|
const struct git_hash_algo *from =
|
|
src->algo ? &hash_algos[src->algo] : repo->hash_algo;
|
|
|
|
if (from == to) {
|
|
if (src != dest)
|
|
oidcpy(dest, src);
|
|
return 0;
|
|
}
|
|
if (repo_loose_object_map_oid(repo, src, to, dest)) {
|
|
/*
|
|
* We may have loaded the object map at repo initialization but
|
|
* another process (perhaps upstream of a pipe from us) may have
|
|
* written a new object into the map. If the object is missing,
|
|
* let's reload the map to see if the object has appeared.
|
|
*/
|
|
repo_read_loose_object_map(repo);
|
|
if (repo_loose_object_map_oid(repo, src, to, dest))
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int decode_tree_entry_raw(struct object_id *oid, const char **path,
|
|
size_t *len, const struct git_hash_algo *algo,
|
|
const char *buf, unsigned long size)
|
|
{
|
|
uint16_t mode;
|
|
const unsigned hashsz = algo->rawsz;
|
|
|
|
if (size < hashsz + 3 || buf[size - (hashsz + 1)]) {
|
|
return -1;
|
|
}
|
|
|
|
*path = parse_mode(buf, &mode);
|
|
if (!*path || !**path)
|
|
return -1;
|
|
*len = strlen(*path) + 1;
|
|
|
|
oidread(oid, (const unsigned char *)*path + *len, algo);
|
|
return 0;
|
|
}
|
|
|
|
static int convert_tree_object(struct strbuf *out,
|
|
const struct git_hash_algo *from,
|
|
const struct git_hash_algo *to,
|
|
const char *buffer, size_t size)
|
|
{
|
|
const char *p = buffer, *end = buffer + size;
|
|
|
|
while (p < end) {
|
|
struct object_id entry_oid, mapped_oid;
|
|
const char *path = NULL;
|
|
size_t pathlen;
|
|
|
|
if (decode_tree_entry_raw(&entry_oid, &path, &pathlen, from, p,
|
|
end - p))
|
|
return error(_("failed to decode tree entry"));
|
|
if (repo_oid_to_algop(the_repository, &entry_oid, to, &mapped_oid))
|
|
return error(_("failed to map tree entry for %s"), oid_to_hex(&entry_oid));
|
|
strbuf_add(out, p, path - p);
|
|
strbuf_add(out, path, pathlen);
|
|
strbuf_add(out, mapped_oid.hash, to->rawsz);
|
|
p = path + pathlen + from->rawsz;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int convert_tag_object(struct strbuf *out,
|
|
const struct git_hash_algo *from,
|
|
const struct git_hash_algo *to,
|
|
const char *buffer, size_t size)
|
|
{
|
|
struct strbuf payload = STRBUF_INIT, oursig = STRBUF_INIT, othersig = STRBUF_INIT;
|
|
const int entry_len = from->hexsz + 7;
|
|
size_t payload_size;
|
|
struct object_id oid, mapped_oid;
|
|
const char *p;
|
|
|
|
/* Consume the object line */
|
|
if ((entry_len >= size) ||
|
|
memcmp(buffer, "object ", 7) || buffer[entry_len] != '\n')
|
|
return error("bogus tag object");
|
|
if (parse_oid_hex_algop(buffer + 7, &oid, &p, from) < 0)
|
|
return error("bad tag object ID");
|
|
if (repo_oid_to_algop(the_repository, &oid, to, &mapped_oid))
|
|
return error("unable to map tree %s in tag object",
|
|
oid_to_hex(&oid));
|
|
size -= ((p + 1) - buffer);
|
|
buffer = p + 1;
|
|
|
|
/* Is there a signature for our algorithm? */
|
|
payload_size = parse_signed_buffer(buffer, size);
|
|
if (payload_size != size) {
|
|
/* Yes, there is. */
|
|
strbuf_add(&oursig, buffer + payload_size, size - payload_size);
|
|
}
|
|
|
|
/* Now, is there a signature for the other algorithm? */
|
|
parse_buffer_signed_by_header(buffer, payload_size, &payload, &othersig, to);
|
|
/*
|
|
* Our payload is now in payload and we may have up to two signatrures
|
|
* in oursig and othersig.
|
|
*/
|
|
|
|
/* Add some slop for longer signature header in the new algorithm. */
|
|
strbuf_grow(out, (7 + to->hexsz + 1) + size + 7);
|
|
strbuf_addf(out, "object %s\n", oid_to_hex(&mapped_oid));
|
|
strbuf_addbuf(out, &payload);
|
|
if (oursig.len)
|
|
add_header_signature(out, &oursig, from);
|
|
strbuf_addbuf(out, &othersig);
|
|
|
|
strbuf_release(&payload);
|
|
strbuf_release(&othersig);
|
|
strbuf_release(&oursig);
|
|
return 0;
|
|
}
|
|
|
|
static int convert_commit_object(struct strbuf *out,
|
|
const struct git_hash_algo *from,
|
|
const struct git_hash_algo *to,
|
|
const char *buffer, size_t size)
|
|
{
|
|
const char *tail = buffer;
|
|
const char *bufptr = buffer;
|
|
const int tree_entry_len = from->hexsz + 5;
|
|
const int parent_entry_len = from->hexsz + 7;
|
|
struct object_id oid, mapped_oid;
|
|
const char *p, *eol;
|
|
|
|
tail += size;
|
|
|
|
while ((bufptr < tail) && (*bufptr != '\n')) {
|
|
eol = memchr(bufptr, '\n', tail - bufptr);
|
|
if (!eol)
|
|
return error(_("bad %s in commit"), "line");
|
|
|
|
if (((bufptr + 5) < eol) && !memcmp(bufptr, "tree ", 5))
|
|
{
|
|
if (((bufptr + tree_entry_len) != eol) ||
|
|
parse_oid_hex_algop(bufptr + 5, &oid, &p, from) ||
|
|
(p != eol))
|
|
return error(_("bad %s in commit"), "tree");
|
|
|
|
if (repo_oid_to_algop(the_repository, &oid, to, &mapped_oid))
|
|
return error(_("unable to map %s %s in commit object"),
|
|
"tree", oid_to_hex(&oid));
|
|
strbuf_addf(out, "tree %s\n", oid_to_hex(&mapped_oid));
|
|
}
|
|
else if (((bufptr + 7) < eol) && !memcmp(bufptr, "parent ", 7))
|
|
{
|
|
if (((bufptr + parent_entry_len) != eol) ||
|
|
parse_oid_hex_algop(bufptr + 7, &oid, &p, from) ||
|
|
(p != eol))
|
|
return error(_("bad %s in commit"), "parent");
|
|
|
|
if (repo_oid_to_algop(the_repository, &oid, to, &mapped_oid))
|
|
return error(_("unable to map %s %s in commit object"),
|
|
"parent", oid_to_hex(&oid));
|
|
|
|
strbuf_addf(out, "parent %s\n", oid_to_hex(&mapped_oid));
|
|
}
|
|
else if (((bufptr + 9) < eol) && !memcmp(bufptr, "mergetag ", 9))
|
|
{
|
|
struct strbuf tag = STRBUF_INIT, new_tag = STRBUF_INIT;
|
|
|
|
/* Recover the tag object from the mergetag */
|
|
strbuf_add(&tag, bufptr + 9, (eol - (bufptr + 9)) + 1);
|
|
|
|
bufptr = eol + 1;
|
|
while ((bufptr < tail) && (*bufptr == ' ')) {
|
|
eol = memchr(bufptr, '\n', tail - bufptr);
|
|
if (!eol) {
|
|
strbuf_release(&tag);
|
|
return error(_("bad %s in commit"), "mergetag continuation");
|
|
}
|
|
strbuf_add(&tag, bufptr + 1, (eol - (bufptr + 1)) + 1);
|
|
bufptr = eol + 1;
|
|
}
|
|
|
|
/* Compute the new tag object */
|
|
if (convert_tag_object(&new_tag, from, to, tag.buf, tag.len)) {
|
|
strbuf_release(&tag);
|
|
strbuf_release(&new_tag);
|
|
return -1;
|
|
}
|
|
|
|
/* Write the new mergetag */
|
|
strbuf_addstr(out, "mergetag");
|
|
strbuf_add_lines(out, " ", new_tag.buf, new_tag.len);
|
|
strbuf_release(&tag);
|
|
strbuf_release(&new_tag);
|
|
}
|
|
else if (((bufptr + 7) < tail) && !memcmp(bufptr, "author ", 7))
|
|
strbuf_add(out, bufptr, (eol - bufptr) + 1);
|
|
else if (((bufptr + 10) < tail) && !memcmp(bufptr, "committer ", 10))
|
|
strbuf_add(out, bufptr, (eol - bufptr) + 1);
|
|
else if (((bufptr + 9) < tail) && !memcmp(bufptr, "encoding ", 9))
|
|
strbuf_add(out, bufptr, (eol - bufptr) + 1);
|
|
else if (((bufptr + 6) < tail) && !memcmp(bufptr, "gpgsig", 6))
|
|
strbuf_add(out, bufptr, (eol - bufptr) + 1);
|
|
else {
|
|
/* Unknown line fail it might embed an oid */
|
|
return -1;
|
|
}
|
|
/* Consume any trailing continuation lines */
|
|
bufptr = eol + 1;
|
|
while ((bufptr < tail) && (*bufptr == ' ')) {
|
|
eol = memchr(bufptr, '\n', tail - bufptr);
|
|
if (!eol)
|
|
return error(_("bad %s in commit"), "continuation");
|
|
strbuf_add(out, bufptr, (eol - bufptr) + 1);
|
|
bufptr = eol + 1;
|
|
}
|
|
}
|
|
if (bufptr < tail)
|
|
strbuf_add(out, bufptr, tail - bufptr);
|
|
return 0;
|
|
}
|
|
|
|
int convert_object_file(struct strbuf *outbuf,
|
|
const struct git_hash_algo *from,
|
|
const struct git_hash_algo *to,
|
|
const void *buf, size_t len,
|
|
enum object_type type,
|
|
int gentle)
|
|
{
|
|
int ret;
|
|
|
|
/* Don't call this function when no conversion is necessary */
|
|
if ((from == to) || (type == OBJ_BLOB))
|
|
BUG("Refusing noop object file conversion");
|
|
|
|
switch (type) {
|
|
case OBJ_COMMIT:
|
|
ret = convert_commit_object(outbuf, from, to, buf, len);
|
|
break;
|
|
case OBJ_TREE:
|
|
ret = convert_tree_object(outbuf, from, to, buf, len);
|
|
break;
|
|
case OBJ_TAG:
|
|
ret = convert_tag_object(outbuf, from, to, buf, len);
|
|
break;
|
|
default:
|
|
/* Not implemented yet, so fail. */
|
|
ret = -1;
|
|
break;
|
|
}
|
|
if (!ret)
|
|
return 0;
|
|
if (gentle) {
|
|
strbuf_release(outbuf);
|
|
return ret;
|
|
}
|
|
die(_("Failed to convert object from %s to %s"),
|
|
from->name, to->name);
|
|
}
|