2005-10-12 19:01:31 +00:00
|
|
|
#include "cache.h"
|
|
|
|
#include "delta.h"
|
|
|
|
#include "pack.h"
|
|
|
|
#include "csum-file.h"
|
2006-04-02 12:44:09 +00:00
|
|
|
#include "blob.h"
|
|
|
|
#include "commit.h"
|
|
|
|
#include "tag.h"
|
|
|
|
#include "tree.h"
|
2007-04-18 18:27:45 +00:00
|
|
|
#include "progress.h"
|
2005-10-12 19:01:31 +00:00
|
|
|
|
|
|
|
static const char index_pack_usage[] =
|
2006-10-29 09:41:59 +00:00
|
|
|
"git-index-pack [-v] [-o <index-file>] [{ ---keep | --keep=<msg> }] { <pack-file> | --stdin [--fix-thin] [<pack-file>] }";
|
2005-10-12 19:01:31 +00:00
|
|
|
|
|
|
|
struct object_entry
|
|
|
|
{
|
2007-06-01 19:18:05 +00:00
|
|
|
struct pack_idx_entry idx;
|
2006-10-20 18:45:21 +00:00
|
|
|
unsigned long size;
|
|
|
|
unsigned int hdr_size;
|
2005-10-12 19:01:31 +00:00
|
|
|
enum object_type type;
|
|
|
|
enum object_type real_type;
|
|
|
|
};
|
|
|
|
|
2006-09-21 04:08:33 +00:00
|
|
|
union delta_base {
|
|
|
|
unsigned char sha1[20];
|
2007-04-09 05:06:30 +00:00
|
|
|
off_t offset;
|
2006-09-21 04:08:33 +00:00
|
|
|
};
|
|
|
|
|
2006-10-17 20:23:26 +00:00
|
|
|
/*
|
|
|
|
* Even if sizeof(union delta_base) == 24 on 64-bit archs, we really want
|
|
|
|
* to memcmp() only the first 20 bytes.
|
|
|
|
*/
|
|
|
|
#define UNION_BASE_SZ 20
|
|
|
|
|
2005-10-12 19:01:31 +00:00
|
|
|
struct delta_entry
|
|
|
|
{
|
2006-09-21 04:08:33 +00:00
|
|
|
union delta_base base;
|
2006-10-26 03:28:17 +00:00
|
|
|
int obj_no;
|
2005-10-12 19:01:31 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static struct object_entry *objects;
|
|
|
|
static struct delta_entry *deltas;
|
|
|
|
static int nr_objects;
|
|
|
|
static int nr_deltas;
|
2006-10-26 03:28:17 +00:00
|
|
|
static int nr_resolved_deltas;
|
2005-10-12 19:01:31 +00:00
|
|
|
|
2006-10-23 18:50:18 +00:00
|
|
|
static int from_stdin;
|
2006-10-26 03:32:59 +00:00
|
|
|
static int verbose;
|
|
|
|
|
2007-04-18 18:27:45 +00:00
|
|
|
static struct progress progress;
|
2006-10-23 18:50:18 +00:00
|
|
|
|
2006-10-20 18:45:21 +00:00
|
|
|
/* We always read in 4kB chunks. */
|
|
|
|
static unsigned char input_buffer[4096];
|
2007-04-09 05:06:30 +00:00
|
|
|
static unsigned int input_offset, input_len;
|
|
|
|
static off_t consumed_bytes;
|
2006-10-20 18:45:21 +00:00
|
|
|
static SHA_CTX input_ctx;
|
2007-04-09 05:06:32 +00:00
|
|
|
static uint32_t input_crc32;
|
2006-12-19 15:53:08 +00:00
|
|
|
static int input_fd, output_fd, pack_fd;
|
2006-10-20 18:45:21 +00:00
|
|
|
|
2006-10-26 03:28:17 +00:00
|
|
|
/* Discard current buffer used content. */
|
2006-11-18 12:07:06 +00:00
|
|
|
static void flush(void)
|
2006-10-26 03:28:17 +00:00
|
|
|
{
|
|
|
|
if (input_offset) {
|
|
|
|
if (output_fd >= 0)
|
|
|
|
write_or_die(output_fd, input_buffer, input_offset);
|
|
|
|
SHA1_Update(&input_ctx, input_buffer, input_offset);
|
2006-12-11 18:06:34 +00:00
|
|
|
memmove(input_buffer, input_buffer + input_offset, input_len);
|
2006-10-26 03:28:17 +00:00
|
|
|
input_offset = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-10-20 18:45:21 +00:00
|
|
|
/*
|
|
|
|
* Make sure at least "min" bytes are available in the buffer, and
|
|
|
|
* return the pointer to the buffer.
|
|
|
|
*/
|
2006-10-27 20:14:23 +00:00
|
|
|
static void *fill(int min)
|
2005-10-12 19:01:31 +00:00
|
|
|
{
|
2006-10-20 18:45:21 +00:00
|
|
|
if (min <= input_len)
|
|
|
|
return input_buffer + input_offset;
|
|
|
|
if (min > sizeof(input_buffer))
|
|
|
|
die("cannot fill %d bytes", min);
|
2006-10-26 03:28:17 +00:00
|
|
|
flush();
|
2006-10-20 18:45:21 +00:00
|
|
|
do {
|
2007-05-15 12:49:22 +00:00
|
|
|
ssize_t ret = xread(input_fd, input_buffer + input_len,
|
2006-10-20 18:45:21 +00:00
|
|
|
sizeof(input_buffer) - input_len);
|
|
|
|
if (ret <= 0) {
|
|
|
|
if (!ret)
|
|
|
|
die("early EOF");
|
|
|
|
die("read error on input: %s", strerror(errno));
|
|
|
|
}
|
|
|
|
input_len += ret;
|
|
|
|
} while (input_len < min);
|
|
|
|
return input_buffer;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void use(int bytes)
|
|
|
|
{
|
|
|
|
if (bytes > input_len)
|
|
|
|
die("used more bytes than were available");
|
2007-04-09 05:06:32 +00:00
|
|
|
input_crc32 = crc32(input_crc32, input_buffer + input_offset, bytes);
|
2006-10-20 18:45:21 +00:00
|
|
|
input_len -= bytes;
|
|
|
|
input_offset += bytes;
|
2007-04-09 05:06:30 +00:00
|
|
|
|
|
|
|
/* make sure off_t is sufficiently large not to wrap */
|
|
|
|
if (consumed_bytes > consumed_bytes + bytes)
|
|
|
|
die("pack too large for current definition of off_t");
|
2006-10-20 18:45:21 +00:00
|
|
|
consumed_bytes += bytes;
|
|
|
|
}
|
2005-10-12 19:01:31 +00:00
|
|
|
|
2006-10-27 20:14:23 +00:00
|
|
|
static const char *open_pack_file(const char *pack_name)
|
2006-10-20 18:45:21 +00:00
|
|
|
{
|
2006-10-23 18:50:18 +00:00
|
|
|
if (from_stdin) {
|
|
|
|
input_fd = 0;
|
|
|
|
if (!pack_name) {
|
|
|
|
static char tmpfile[PATH_MAX];
|
|
|
|
snprintf(tmpfile, sizeof(tmpfile),
|
2007-03-24 15:58:22 +00:00
|
|
|
"%s/tmp_pack_XXXXXX", get_object_directory());
|
2006-10-23 18:50:18 +00:00
|
|
|
output_fd = mkstemp(tmpfile);
|
|
|
|
pack_name = xstrdup(tmpfile);
|
|
|
|
} else
|
|
|
|
output_fd = open(pack_name, O_CREAT|O_EXCL|O_RDWR, 0600);
|
|
|
|
if (output_fd < 0)
|
|
|
|
die("unable to create %s: %s\n", pack_name, strerror(errno));
|
2006-12-19 15:53:08 +00:00
|
|
|
pack_fd = output_fd;
|
2006-10-23 18:50:18 +00:00
|
|
|
} else {
|
|
|
|
input_fd = open(pack_name, O_RDONLY);
|
|
|
|
if (input_fd < 0)
|
|
|
|
die("cannot open packfile '%s': %s",
|
|
|
|
pack_name, strerror(errno));
|
|
|
|
output_fd = -1;
|
2006-12-19 15:53:08 +00:00
|
|
|
pack_fd = input_fd;
|
2006-10-23 18:50:18 +00:00
|
|
|
}
|
2006-10-20 18:45:21 +00:00
|
|
|
SHA1_Init(&input_ctx);
|
2006-10-23 18:50:18 +00:00
|
|
|
return pack_name;
|
2005-10-12 19:01:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void parse_pack_header(void)
|
|
|
|
{
|
2006-10-20 18:45:21 +00:00
|
|
|
struct pack_header *hdr = fill(sizeof(struct pack_header));
|
2005-10-12 19:01:31 +00:00
|
|
|
|
|
|
|
/* Header consistency check */
|
|
|
|
if (hdr->hdr_signature != htonl(PACK_SIGNATURE))
|
2006-10-23 18:50:18 +00:00
|
|
|
die("pack signature mismatch");
|
2006-02-09 22:50:04 +00:00
|
|
|
if (!pack_version_ok(hdr->hdr_version))
|
2006-10-23 18:50:18 +00:00
|
|
|
die("pack version %d unsupported", ntohl(hdr->hdr_version));
|
2005-10-12 19:01:31 +00:00
|
|
|
|
|
|
|
nr_objects = ntohl(hdr->hdr_entries);
|
2006-10-20 18:45:21 +00:00
|
|
|
use(sizeof(struct pack_header));
|
2005-10-12 19:01:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void bad_object(unsigned long offset, const char *format,
|
|
|
|
...) NORETURN __attribute__((format (printf, 2, 3)));
|
|
|
|
|
|
|
|
static void bad_object(unsigned long offset, const char *format, ...)
|
|
|
|
{
|
|
|
|
va_list params;
|
|
|
|
char buf[1024];
|
|
|
|
|
|
|
|
va_start(params, format);
|
|
|
|
vsnprintf(buf, sizeof(buf), format, params);
|
|
|
|
va_end(params);
|
2006-10-23 18:50:18 +00:00
|
|
|
die("pack has bad object at offset %lu: %s", offset, buf);
|
2005-10-12 19:01:31 +00:00
|
|
|
}
|
|
|
|
|
2006-10-20 18:45:21 +00:00
|
|
|
static void *unpack_entry_data(unsigned long offset, unsigned long size)
|
2005-10-12 19:01:31 +00:00
|
|
|
{
|
|
|
|
z_stream stream;
|
|
|
|
void *buf = xmalloc(size);
|
|
|
|
|
|
|
|
memset(&stream, 0, sizeof(stream));
|
|
|
|
stream.next_out = buf;
|
|
|
|
stream.avail_out = size;
|
2006-10-20 18:45:21 +00:00
|
|
|
stream.next_in = fill(1);
|
|
|
|
stream.avail_in = input_len;
|
2005-10-12 19:01:31 +00:00
|
|
|
inflateInit(&stream);
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
int ret = inflate(&stream, 0);
|
2006-10-20 18:45:21 +00:00
|
|
|
use(input_len - stream.avail_in);
|
|
|
|
if (stream.total_out == size && ret == Z_STREAM_END)
|
2005-10-12 19:01:31 +00:00
|
|
|
break;
|
|
|
|
if (ret != Z_OK)
|
|
|
|
bad_object(offset, "inflate returned %d", ret);
|
2006-10-20 18:45:21 +00:00
|
|
|
stream.next_in = fill(1);
|
|
|
|
stream.avail_in = input_len;
|
2005-10-12 19:01:31 +00:00
|
|
|
}
|
|
|
|
inflateEnd(&stream);
|
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
|
2006-10-20 18:45:21 +00:00
|
|
|
static void *unpack_raw_entry(struct object_entry *obj, union delta_base *delta_base)
|
2005-10-12 19:01:31 +00:00
|
|
|
{
|
2006-10-20 18:45:21 +00:00
|
|
|
unsigned char *p, c;
|
2007-04-09 05:06:30 +00:00
|
|
|
unsigned long size;
|
|
|
|
off_t base_offset;
|
2005-10-12 19:01:31 +00:00
|
|
|
unsigned shift;
|
2007-04-09 05:06:32 +00:00
|
|
|
void *data;
|
2005-10-12 19:01:31 +00:00
|
|
|
|
2007-06-01 19:18:05 +00:00
|
|
|
obj->idx.offset = consumed_bytes;
|
2007-04-09 05:06:32 +00:00
|
|
|
input_crc32 = crc32(0, Z_NULL, 0);
|
2006-10-20 18:45:21 +00:00
|
|
|
|
|
|
|
p = fill(1);
|
|
|
|
c = *p;
|
|
|
|
use(1);
|
|
|
|
obj->type = (c >> 4) & 7;
|
2005-10-12 19:01:31 +00:00
|
|
|
size = (c & 15);
|
|
|
|
shift = 4;
|
|
|
|
while (c & 0x80) {
|
2006-10-20 18:45:21 +00:00
|
|
|
p = fill(1);
|
|
|
|
c = *p;
|
|
|
|
use(1);
|
2005-10-12 19:01:31 +00:00
|
|
|
size += (c & 0x7fUL) << shift;
|
|
|
|
shift += 7;
|
|
|
|
}
|
2006-10-20 18:45:21 +00:00
|
|
|
obj->size = size;
|
2005-10-12 19:01:31 +00:00
|
|
|
|
2006-10-20 18:45:21 +00:00
|
|
|
switch (obj->type) {
|
2006-09-21 04:06:49 +00:00
|
|
|
case OBJ_REF_DELTA:
|
2006-10-20 18:45:21 +00:00
|
|
|
hashcpy(delta_base->sha1, fill(20));
|
|
|
|
use(20);
|
2006-09-21 04:08:33 +00:00
|
|
|
break;
|
|
|
|
case OBJ_OFS_DELTA:
|
|
|
|
memset(delta_base, 0, sizeof(*delta_base));
|
2006-10-20 18:45:21 +00:00
|
|
|
p = fill(1);
|
|
|
|
c = *p;
|
|
|
|
use(1);
|
2006-09-21 04:08:33 +00:00
|
|
|
base_offset = c & 127;
|
|
|
|
while (c & 128) {
|
|
|
|
base_offset += 1;
|
2007-04-09 05:06:29 +00:00
|
|
|
if (!base_offset || MSB(base_offset, 7))
|
2007-06-01 19:18:05 +00:00
|
|
|
bad_object(obj->idx.offset, "offset value overflow for delta base object");
|
2006-10-20 18:45:21 +00:00
|
|
|
p = fill(1);
|
|
|
|
c = *p;
|
|
|
|
use(1);
|
2006-09-21 04:08:33 +00:00
|
|
|
base_offset = (base_offset << 7) + (c & 127);
|
|
|
|
}
|
2007-06-01 19:18:05 +00:00
|
|
|
delta_base->offset = obj->idx.offset - base_offset;
|
|
|
|
if (delta_base->offset >= obj->idx.offset)
|
|
|
|
bad_object(obj->idx.offset, "delta base offset is out of bound");
|
2006-09-21 04:08:33 +00:00
|
|
|
break;
|
2005-10-12 19:01:31 +00:00
|
|
|
case OBJ_COMMIT:
|
|
|
|
case OBJ_TREE:
|
|
|
|
case OBJ_BLOB:
|
|
|
|
case OBJ_TAG:
|
|
|
|
break;
|
|
|
|
default:
|
2007-06-01 19:18:05 +00:00
|
|
|
bad_object(obj->idx.offset, "unknown object type %d", obj->type);
|
2005-10-12 19:01:31 +00:00
|
|
|
}
|
2007-06-01 19:18:05 +00:00
|
|
|
obj->hdr_size = consumed_bytes - obj->idx.offset;
|
2006-10-20 18:45:21 +00:00
|
|
|
|
2007-06-01 19:18:05 +00:00
|
|
|
data = unpack_entry_data(obj->idx.offset, obj->size);
|
|
|
|
obj->idx.crc32 = input_crc32;
|
2007-04-09 05:06:32 +00:00
|
|
|
return data;
|
2006-10-20 18:45:21 +00:00
|
|
|
}
|
|
|
|
|
2006-10-27 20:14:23 +00:00
|
|
|
static void *get_data_from_pack(struct object_entry *obj)
|
2006-10-20 18:45:21 +00:00
|
|
|
{
|
2007-06-01 19:18:05 +00:00
|
|
|
unsigned long from = obj[0].idx.offset + obj[0].hdr_size;
|
|
|
|
unsigned long len = obj[1].idx.offset - from;
|
2007-02-28 04:47:19 +00:00
|
|
|
unsigned long rdy = 0;
|
2006-12-19 15:53:08 +00:00
|
|
|
unsigned char *src, *data;
|
2006-10-20 18:45:21 +00:00
|
|
|
z_stream stream;
|
|
|
|
int st;
|
2005-10-12 19:01:31 +00:00
|
|
|
|
2006-12-19 15:53:08 +00:00
|
|
|
src = xmalloc(len);
|
2007-02-28 04:47:19 +00:00
|
|
|
data = src;
|
|
|
|
do {
|
|
|
|
ssize_t n = pread(pack_fd, data + rdy, len - rdy, from + rdy);
|
|
|
|
if (n <= 0)
|
|
|
|
die("cannot pread pack file: %s", strerror(errno));
|
|
|
|
rdy += n;
|
|
|
|
} while (rdy < len);
|
2006-10-20 18:45:21 +00:00
|
|
|
data = xmalloc(obj->size);
|
|
|
|
memset(&stream, 0, sizeof(stream));
|
|
|
|
stream.next_out = data;
|
|
|
|
stream.avail_out = obj->size;
|
2006-12-19 15:53:08 +00:00
|
|
|
stream.next_in = src;
|
2006-10-20 18:45:21 +00:00
|
|
|
stream.avail_in = len;
|
|
|
|
inflateInit(&stream);
|
|
|
|
while ((st = inflate(&stream, Z_FINISH)) == Z_OK);
|
|
|
|
inflateEnd(&stream);
|
|
|
|
if (st != Z_STREAM_END || stream.total_out != obj->size)
|
|
|
|
die("serious inflate inconsistency");
|
2006-12-19 15:53:08 +00:00
|
|
|
free(src);
|
2005-10-12 19:01:31 +00:00
|
|
|
return data;
|
|
|
|
}
|
|
|
|
|
2006-09-21 04:08:33 +00:00
|
|
|
static int find_delta(const union delta_base *base)
|
2005-10-12 19:01:31 +00:00
|
|
|
{
|
|
|
|
int first = 0, last = nr_deltas;
|
|
|
|
|
|
|
|
while (first < last) {
|
|
|
|
int next = (first + last) / 2;
|
|
|
|
struct delta_entry *delta = &deltas[next];
|
|
|
|
int cmp;
|
|
|
|
|
2006-10-17 20:23:26 +00:00
|
|
|
cmp = memcmp(base, &delta->base, UNION_BASE_SZ);
|
2005-10-12 19:01:31 +00:00
|
|
|
if (!cmp)
|
|
|
|
return next;
|
|
|
|
if (cmp < 0) {
|
|
|
|
last = next;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
first = next+1;
|
|
|
|
}
|
|
|
|
return -first-1;
|
|
|
|
}
|
|
|
|
|
2006-10-27 20:14:23 +00:00
|
|
|
static int find_delta_children(const union delta_base *base,
|
|
|
|
int *first_index, int *last_index)
|
2005-10-12 19:01:31 +00:00
|
|
|
{
|
2006-09-21 04:08:33 +00:00
|
|
|
int first = find_delta(base);
|
2005-10-12 19:01:31 +00:00
|
|
|
int last = first;
|
|
|
|
int end = nr_deltas - 1;
|
|
|
|
|
|
|
|
if (first < 0)
|
|
|
|
return -1;
|
2006-10-17 20:23:26 +00:00
|
|
|
while (first > 0 && !memcmp(&deltas[first - 1].base, base, UNION_BASE_SZ))
|
2005-10-12 19:01:31 +00:00
|
|
|
--first;
|
2006-10-17 20:23:26 +00:00
|
|
|
while (last < end && !memcmp(&deltas[last + 1].base, base, UNION_BASE_SZ))
|
2005-10-12 19:01:31 +00:00
|
|
|
++last;
|
|
|
|
*first_index = first;
|
|
|
|
*last_index = last;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void sha1_object(const void *data, unsigned long size,
|
2007-03-20 21:07:48 +00:00
|
|
|
enum object_type type, unsigned char *sha1)
|
2005-10-12 19:01:31 +00:00
|
|
|
{
|
2007-03-20 20:02:09 +00:00
|
|
|
hash_sha1_file(data, size, typename(type), sha1);
|
2007-03-20 21:07:48 +00:00
|
|
|
if (has_sha1_file(sha1)) {
|
2007-03-20 19:32:35 +00:00
|
|
|
void *has_data;
|
|
|
|
enum object_type has_type;
|
|
|
|
unsigned long has_size;
|
|
|
|
has_data = read_sha1_file(sha1, &has_type, &has_size);
|
|
|
|
if (!has_data)
|
|
|
|
die("cannot read existing object %s", sha1_to_hex(sha1));
|
|
|
|
if (size != has_size || type != has_type ||
|
|
|
|
memcmp(data, has_data, size) != 0)
|
|
|
|
die("SHA1 COLLISION FOUND WITH %s !", sha1_to_hex(sha1));
|
2007-04-03 16:33:46 +00:00
|
|
|
free(has_data);
|
2007-03-20 19:32:35 +00:00
|
|
|
}
|
2005-10-12 19:01:31 +00:00
|
|
|
}
|
|
|
|
|
2006-10-26 03:28:17 +00:00
|
|
|
static void resolve_delta(struct object_entry *delta_obj, void *base_data,
|
2005-10-12 19:01:31 +00:00
|
|
|
unsigned long base_size, enum object_type type)
|
|
|
|
{
|
|
|
|
void *delta_data;
|
|
|
|
unsigned long delta_size;
|
|
|
|
void *result;
|
|
|
|
unsigned long result_size;
|
2006-09-21 04:08:33 +00:00
|
|
|
union delta_base delta_base;
|
2005-10-12 19:01:31 +00:00
|
|
|
int j, first, last;
|
|
|
|
|
2006-10-26 03:28:17 +00:00
|
|
|
delta_obj->real_type = type;
|
|
|
|
delta_data = get_data_from_pack(delta_obj);
|
|
|
|
delta_size = delta_obj->size;
|
2005-10-12 19:01:31 +00:00
|
|
|
result = patch_delta(base_data, base_size, delta_data, delta_size,
|
|
|
|
&result_size);
|
|
|
|
free(delta_data);
|
|
|
|
if (!result)
|
2007-06-01 19:18:05 +00:00
|
|
|
bad_object(delta_obj->idx.offset, "failed to apply delta");
|
|
|
|
sha1_object(result, result_size, type, delta_obj->idx.sha1);
|
2006-10-26 03:28:17 +00:00
|
|
|
nr_resolved_deltas++;
|
2006-09-21 04:08:33 +00:00
|
|
|
|
2007-06-01 19:18:05 +00:00
|
|
|
hashcpy(delta_base.sha1, delta_obj->idx.sha1);
|
2006-10-27 20:14:23 +00:00
|
|
|
if (!find_delta_children(&delta_base, &first, &last)) {
|
2006-10-26 03:28:17 +00:00
|
|
|
for (j = first; j <= last; j++) {
|
|
|
|
struct object_entry *child = objects + deltas[j].obj_no;
|
|
|
|
if (child->real_type == OBJ_REF_DELTA)
|
|
|
|
resolve_delta(child, result, result_size, type);
|
|
|
|
}
|
2006-09-21 04:08:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
memset(&delta_base, 0, sizeof(delta_base));
|
2007-06-01 19:18:05 +00:00
|
|
|
delta_base.offset = delta_obj->idx.offset;
|
2006-10-27 20:14:23 +00:00
|
|
|
if (!find_delta_children(&delta_base, &first, &last)) {
|
2006-10-26 03:28:17 +00:00
|
|
|
for (j = first; j <= last; j++) {
|
|
|
|
struct object_entry *child = objects + deltas[j].obj_no;
|
|
|
|
if (child->real_type == OBJ_OFS_DELTA)
|
|
|
|
resolve_delta(child, result, result_size, type);
|
|
|
|
}
|
2005-10-12 19:01:31 +00:00
|
|
|
}
|
2006-09-21 04:08:33 +00:00
|
|
|
|
2005-10-12 19:01:31 +00:00
|
|
|
free(result);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int compare_delta_entry(const void *a, const void *b)
|
|
|
|
{
|
|
|
|
const struct delta_entry *delta_a = a;
|
|
|
|
const struct delta_entry *delta_b = b;
|
2006-10-17 20:23:26 +00:00
|
|
|
return memcmp(&delta_a->base, &delta_b->base, UNION_BASE_SZ);
|
2005-10-12 19:01:31 +00:00
|
|
|
}
|
|
|
|
|
2006-10-20 18:45:21 +00:00
|
|
|
/* Parse all objects and return the pack content SHA1 hash */
|
|
|
|
static void parse_pack_objects(unsigned char *sha1)
|
2005-10-12 19:01:31 +00:00
|
|
|
{
|
2007-04-18 18:27:45 +00:00
|
|
|
int i;
|
2006-09-21 04:08:33 +00:00
|
|
|
struct delta_entry *delta = deltas;
|
2005-10-12 19:01:31 +00:00
|
|
|
void *data;
|
2006-10-20 18:45:21 +00:00
|
|
|
struct stat st;
|
2005-10-12 19:01:31 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* First pass:
|
|
|
|
* - find locations of all objects;
|
|
|
|
* - calculate SHA1 of all non-delta objects;
|
2006-10-27 20:14:23 +00:00
|
|
|
* - remember base (SHA1 or offset) for all deltas.
|
2005-10-12 19:01:31 +00:00
|
|
|
*/
|
2007-04-20 18:10:07 +00:00
|
|
|
if (verbose)
|
|
|
|
start_progress(&progress, "Indexing %u objects...", "", nr_objects);
|
2005-10-12 19:01:31 +00:00
|
|
|
for (i = 0; i < nr_objects; i++) {
|
|
|
|
struct object_entry *obj = &objects[i];
|
2006-10-20 18:45:21 +00:00
|
|
|
data = unpack_raw_entry(obj, &delta->base);
|
2005-10-12 19:01:31 +00:00
|
|
|
obj->real_type = obj->type;
|
2006-09-21 04:08:33 +00:00
|
|
|
if (obj->type == OBJ_REF_DELTA || obj->type == OBJ_OFS_DELTA) {
|
|
|
|
nr_deltas++;
|
2006-10-26 03:28:17 +00:00
|
|
|
delta->obj_no = i;
|
2006-09-21 04:08:33 +00:00
|
|
|
delta++;
|
2005-10-12 19:01:31 +00:00
|
|
|
} else
|
2007-06-01 19:18:05 +00:00
|
|
|
sha1_object(data, obj->size, obj->type, obj->idx.sha1);
|
2005-10-12 19:01:31 +00:00
|
|
|
free(data);
|
2006-10-26 03:32:59 +00:00
|
|
|
if (verbose)
|
2007-04-18 18:27:45 +00:00
|
|
|
display_progress(&progress, i+1);
|
2005-10-12 19:01:31 +00:00
|
|
|
}
|
2007-06-01 19:18:05 +00:00
|
|
|
objects[i].idx.offset = consumed_bytes;
|
2006-10-26 03:32:59 +00:00
|
|
|
if (verbose)
|
2007-04-18 18:27:45 +00:00
|
|
|
stop_progress(&progress);
|
2006-10-20 18:45:21 +00:00
|
|
|
|
|
|
|
/* Check pack integrity */
|
2006-10-26 03:28:17 +00:00
|
|
|
flush();
|
2006-10-20 18:45:21 +00:00
|
|
|
SHA1_Final(sha1, &input_ctx);
|
|
|
|
if (hashcmp(fill(20), sha1))
|
2006-10-23 18:50:18 +00:00
|
|
|
die("pack is corrupted (SHA1 mismatch)");
|
2006-10-26 03:31:53 +00:00
|
|
|
use(20);
|
2006-10-20 18:45:21 +00:00
|
|
|
|
|
|
|
/* If input_fd is a file, we should have reached its end now. */
|
|
|
|
if (fstat(input_fd, &st))
|
2006-10-23 18:50:18 +00:00
|
|
|
die("cannot fstat packfile: %s", strerror(errno));
|
git-bundle: assorted fixes
This patch fixes issues mentioned by Junio, Nico and Simon:
- I forgot to convert the usage string when removing the "--" from
the subcommands,
- a style fix in the bundle_header,
- use xread() instead of read(),
- use write_or_die() instead of write(),
- make the bundle header extensible,
- fail if the whitespace after a sha1 of a reference is missing,
- close() the fds passed to a subprocess,
- in verify_bundle(), do not use "rev-list --stdin", but rather
pass the revs directly (avoiding a fork()),
- fix a corrupted comment in show_object(), and
- fix the size check in index_pack.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-02-22 18:14:14 +00:00
|
|
|
if (S_ISREG(st.st_mode) &&
|
|
|
|
lseek(input_fd, 0, SEEK_CUR) - input_len != st.st_size)
|
2006-10-23 18:50:18 +00:00
|
|
|
die("pack has junk at the end");
|
2005-10-12 19:01:31 +00:00
|
|
|
|
2006-10-26 03:32:59 +00:00
|
|
|
if (!nr_deltas)
|
|
|
|
return;
|
|
|
|
|
2006-09-21 04:08:33 +00:00
|
|
|
/* Sort deltas by base SHA1/offset for fast searching */
|
2005-10-12 19:01:31 +00:00
|
|
|
qsort(deltas, nr_deltas, sizeof(struct delta_entry),
|
|
|
|
compare_delta_entry);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Second pass:
|
|
|
|
* - for all non-delta objects, look if it is used as a base for
|
|
|
|
* deltas;
|
|
|
|
* - if used as a base, uncompress the object and apply all deltas,
|
|
|
|
* recursively checking if the resulting object is used as a base
|
|
|
|
* for some more deltas.
|
|
|
|
*/
|
2007-04-20 18:10:07 +00:00
|
|
|
if (verbose)
|
|
|
|
start_progress(&progress, "Resolving %u deltas...", "", nr_deltas);
|
2005-10-12 19:01:31 +00:00
|
|
|
for (i = 0; i < nr_objects; i++) {
|
|
|
|
struct object_entry *obj = &objects[i];
|
2006-09-21 04:08:33 +00:00
|
|
|
union delta_base base;
|
|
|
|
int j, ref, ref_first, ref_last, ofs, ofs_first, ofs_last;
|
2005-10-12 19:01:31 +00:00
|
|
|
|
2006-09-21 04:08:33 +00:00
|
|
|
if (obj->type == OBJ_REF_DELTA || obj->type == OBJ_OFS_DELTA)
|
2005-10-12 19:01:31 +00:00
|
|
|
continue;
|
2007-06-01 19:18:05 +00:00
|
|
|
hashcpy(base.sha1, obj->idx.sha1);
|
2006-10-27 20:14:23 +00:00
|
|
|
ref = !find_delta_children(&base, &ref_first, &ref_last);
|
2006-09-21 04:08:33 +00:00
|
|
|
memset(&base, 0, sizeof(base));
|
2007-06-01 19:18:05 +00:00
|
|
|
base.offset = obj->idx.offset;
|
2006-10-27 20:14:23 +00:00
|
|
|
ofs = !find_delta_children(&base, &ofs_first, &ofs_last);
|
2006-09-21 04:08:33 +00:00
|
|
|
if (!ref && !ofs)
|
2005-10-12 19:01:31 +00:00
|
|
|
continue;
|
2006-10-20 18:45:21 +00:00
|
|
|
data = get_data_from_pack(obj);
|
2006-09-21 04:08:33 +00:00
|
|
|
if (ref)
|
2006-10-26 03:28:17 +00:00
|
|
|
for (j = ref_first; j <= ref_last; j++) {
|
|
|
|
struct object_entry *child = objects + deltas[j].obj_no;
|
|
|
|
if (child->real_type == OBJ_REF_DELTA)
|
|
|
|
resolve_delta(child, data,
|
2006-10-20 18:45:21 +00:00
|
|
|
obj->size, obj->type);
|
2006-10-26 03:28:17 +00:00
|
|
|
}
|
2006-09-21 04:08:33 +00:00
|
|
|
if (ofs)
|
2006-10-26 03:28:17 +00:00
|
|
|
for (j = ofs_first; j <= ofs_last; j++) {
|
|
|
|
struct object_entry *child = objects + deltas[j].obj_no;
|
|
|
|
if (child->real_type == OBJ_OFS_DELTA)
|
|
|
|
resolve_delta(child, data,
|
2006-10-20 18:45:21 +00:00
|
|
|
obj->size, obj->type);
|
2006-10-26 03:28:17 +00:00
|
|
|
}
|
2005-10-12 19:01:31 +00:00
|
|
|
free(data);
|
2006-10-26 03:32:59 +00:00
|
|
|
if (verbose)
|
2007-04-18 18:27:45 +00:00
|
|
|
display_progress(&progress, nr_resolved_deltas);
|
2005-10-12 19:01:31 +00:00
|
|
|
}
|
2006-10-26 03:28:17 +00:00
|
|
|
}
|
|
|
|
|
2007-04-09 05:06:32 +00:00
|
|
|
static int write_compressed(int fd, void *in, unsigned int size, uint32_t *obj_crc)
|
2006-10-26 03:28:17 +00:00
|
|
|
{
|
|
|
|
z_stream stream;
|
|
|
|
unsigned long maxsize;
|
|
|
|
void *out;
|
|
|
|
|
|
|
|
memset(&stream, 0, sizeof(stream));
|
|
|
|
deflateInit(&stream, zlib_compression_level);
|
|
|
|
maxsize = deflateBound(&stream, size);
|
|
|
|
out = xmalloc(maxsize);
|
|
|
|
|
|
|
|
/* Compress it */
|
|
|
|
stream.next_in = in;
|
|
|
|
stream.avail_in = size;
|
|
|
|
stream.next_out = out;
|
|
|
|
stream.avail_out = maxsize;
|
|
|
|
while (deflate(&stream, Z_FINISH) == Z_OK);
|
|
|
|
deflateEnd(&stream);
|
|
|
|
|
|
|
|
size = stream.total_out;
|
|
|
|
write_or_die(fd, out, size);
|
2007-04-09 05:06:32 +00:00
|
|
|
*obj_crc = crc32(*obj_crc, out, size);
|
2006-10-26 03:28:17 +00:00
|
|
|
free(out);
|
|
|
|
return size;
|
|
|
|
}
|
|
|
|
|
2007-03-20 21:07:48 +00:00
|
|
|
static void append_obj_to_pack(const unsigned char *sha1, void *buf,
|
2006-10-26 03:28:17 +00:00
|
|
|
unsigned long size, enum object_type type)
|
|
|
|
{
|
|
|
|
struct object_entry *obj = &objects[nr_objects++];
|
|
|
|
unsigned char header[10];
|
|
|
|
unsigned long s = size;
|
|
|
|
int n = 0;
|
|
|
|
unsigned char c = (type << 4) | (s & 15);
|
|
|
|
s >>= 4;
|
|
|
|
while (s) {
|
|
|
|
header[n++] = c | 0x80;
|
|
|
|
c = s & 0x7f;
|
|
|
|
s >>= 7;
|
|
|
|
}
|
|
|
|
header[n++] = c;
|
|
|
|
write_or_die(output_fd, header, n);
|
2007-06-01 19:18:05 +00:00
|
|
|
obj[0].idx.crc32 = crc32(0, Z_NULL, 0);
|
|
|
|
obj[0].idx.crc32 = crc32(obj[0].idx.crc32, header, n);
|
|
|
|
obj[1].idx.offset = obj[0].idx.offset + n;
|
|
|
|
obj[1].idx.offset += write_compressed(output_fd, buf, size, &obj[0].idx.crc32);
|
|
|
|
hashcpy(obj->idx.sha1, sha1);
|
2006-10-26 03:28:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int delta_pos_compare(const void *_a, const void *_b)
|
|
|
|
{
|
|
|
|
struct delta_entry *a = *(struct delta_entry **)_a;
|
|
|
|
struct delta_entry *b = *(struct delta_entry **)_b;
|
|
|
|
return a->obj_no - b->obj_no;
|
|
|
|
}
|
2005-10-12 19:01:31 +00:00
|
|
|
|
2006-10-26 03:28:17 +00:00
|
|
|
static void fix_unresolved_deltas(int nr_unresolved)
|
|
|
|
{
|
|
|
|
struct delta_entry **sorted_by_pos;
|
2007-04-18 18:27:45 +00:00
|
|
|
int i, n = 0;
|
2006-10-26 03:28:17 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Since many unresolved deltas may well be themselves base objects
|
|
|
|
* for more unresolved deltas, we really want to include the
|
|
|
|
* smallest number of base objects that would cover as much delta
|
|
|
|
* as possible by picking the
|
|
|
|
* trunc deltas first, allowing for other deltas to resolve without
|
|
|
|
* additional base objects. Since most base objects are to be found
|
|
|
|
* before deltas depending on them, a good heuristic is to start
|
|
|
|
* resolving deltas in the same order as their position in the pack.
|
|
|
|
*/
|
|
|
|
sorted_by_pos = xmalloc(nr_unresolved * sizeof(*sorted_by_pos));
|
2005-10-12 19:01:31 +00:00
|
|
|
for (i = 0; i < nr_deltas; i++) {
|
2006-10-26 03:28:17 +00:00
|
|
|
if (objects[deltas[i].obj_no].real_type != OBJ_REF_DELTA)
|
|
|
|
continue;
|
|
|
|
sorted_by_pos[n++] = &deltas[i];
|
2005-10-12 19:01:31 +00:00
|
|
|
}
|
2006-10-26 03:28:17 +00:00
|
|
|
qsort(sorted_by_pos, n, sizeof(*sorted_by_pos), delta_pos_compare);
|
|
|
|
|
|
|
|
for (i = 0; i < n; i++) {
|
|
|
|
struct delta_entry *d = sorted_by_pos[i];
|
|
|
|
void *data;
|
|
|
|
unsigned long size;
|
2007-02-26 19:55:59 +00:00
|
|
|
enum object_type type;
|
2006-10-26 03:28:17 +00:00
|
|
|
int j, first, last;
|
|
|
|
|
|
|
|
if (objects[d->obj_no].real_type != OBJ_REF_DELTA)
|
|
|
|
continue;
|
2007-02-26 19:55:59 +00:00
|
|
|
data = read_sha1_file(d->base.sha1, &type, &size);
|
2006-10-26 03:28:17 +00:00
|
|
|
if (!data)
|
|
|
|
continue;
|
|
|
|
|
2006-10-27 20:14:23 +00:00
|
|
|
find_delta_children(&d->base, &first, &last);
|
2006-10-26 03:28:17 +00:00
|
|
|
for (j = first; j <= last; j++) {
|
|
|
|
struct object_entry *child = objects + deltas[j].obj_no;
|
|
|
|
if (child->real_type == OBJ_REF_DELTA)
|
2007-02-26 19:55:59 +00:00
|
|
|
resolve_delta(child, data, size, type);
|
2006-10-26 03:28:17 +00:00
|
|
|
}
|
|
|
|
|
2007-03-20 21:07:48 +00:00
|
|
|
if (check_sha1_signature(d->base.sha1, data, size, typename(type)))
|
|
|
|
die("local object %s is corrupt", sha1_to_hex(d->base.sha1));
|
|
|
|
append_obj_to_pack(d->base.sha1, data, size, type);
|
2006-10-26 03:28:17 +00:00
|
|
|
free(data);
|
2006-10-26 03:32:59 +00:00
|
|
|
if (verbose)
|
2007-04-18 18:27:45 +00:00
|
|
|
display_progress(&progress, nr_resolved_deltas);
|
2006-10-26 03:28:17 +00:00
|
|
|
}
|
|
|
|
free(sorted_by_pos);
|
|
|
|
}
|
|
|
|
|
2006-10-23 18:50:18 +00:00
|
|
|
static void final(const char *final_pack_name, const char *curr_pack_name,
|
|
|
|
const char *final_index_name, const char *curr_index_name,
|
2006-10-29 09:41:59 +00:00
|
|
|
const char *keep_name, const char *keep_msg,
|
2006-10-23 18:50:18 +00:00
|
|
|
unsigned char *sha1)
|
|
|
|
{
|
2007-03-07 01:44:17 +00:00
|
|
|
const char *report = "pack";
|
2006-10-23 18:50:18 +00:00
|
|
|
char name[PATH_MAX];
|
|
|
|
int err;
|
|
|
|
|
|
|
|
if (!from_stdin) {
|
|
|
|
close(input_fd);
|
|
|
|
} else {
|
|
|
|
err = close(output_fd);
|
|
|
|
if (err)
|
|
|
|
die("error while closing pack file: %s", strerror(errno));
|
|
|
|
chmod(curr_pack_name, 0444);
|
|
|
|
}
|
|
|
|
|
2006-10-29 09:41:59 +00:00
|
|
|
if (keep_msg) {
|
|
|
|
int keep_fd, keep_msg_len = strlen(keep_msg);
|
|
|
|
if (!keep_name) {
|
|
|
|
snprintf(name, sizeof(name), "%s/pack/pack-%s.keep",
|
|
|
|
get_object_directory(), sha1_to_hex(sha1));
|
|
|
|
keep_name = name;
|
|
|
|
}
|
2006-11-01 22:06:24 +00:00
|
|
|
keep_fd = open(keep_name, O_RDWR|O_CREAT|O_EXCL, 0600);
|
|
|
|
if (keep_fd < 0) {
|
|
|
|
if (errno != EEXIST)
|
|
|
|
die("cannot write keep file");
|
|
|
|
} else {
|
|
|
|
if (keep_msg_len > 0) {
|
|
|
|
write_or_die(keep_fd, keep_msg, keep_msg_len);
|
|
|
|
write_or_die(keep_fd, "\n", 1);
|
|
|
|
}
|
2007-06-24 19:20:41 +00:00
|
|
|
if (close(keep_fd) != 0)
|
|
|
|
die("cannot write keep file");
|
2006-11-01 22:06:25 +00:00
|
|
|
report = "keep";
|
2006-10-29 09:41:59 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-10-23 18:50:18 +00:00
|
|
|
if (final_pack_name != curr_pack_name) {
|
|
|
|
if (!final_pack_name) {
|
|
|
|
snprintf(name, sizeof(name), "%s/pack/pack-%s.pack",
|
|
|
|
get_object_directory(), sha1_to_hex(sha1));
|
|
|
|
final_pack_name = name;
|
|
|
|
}
|
|
|
|
if (move_temp_to_file(curr_pack_name, final_pack_name))
|
|
|
|
die("cannot store pack file");
|
|
|
|
}
|
|
|
|
|
|
|
|
chmod(curr_index_name, 0444);
|
|
|
|
if (final_index_name != curr_index_name) {
|
|
|
|
if (!final_index_name) {
|
|
|
|
snprintf(name, sizeof(name), "%s/pack/pack-%s.idx",
|
|
|
|
get_object_directory(), sha1_to_hex(sha1));
|
|
|
|
final_index_name = name;
|
|
|
|
}
|
|
|
|
if (move_temp_to_file(curr_index_name, final_index_name))
|
|
|
|
die("cannot store index file");
|
|
|
|
}
|
2006-11-01 22:06:25 +00:00
|
|
|
|
|
|
|
if (!from_stdin) {
|
|
|
|
printf("%s\n", sha1_to_hex(sha1));
|
|
|
|
} else {
|
|
|
|
char buf[48];
|
|
|
|
int len = snprintf(buf, sizeof(buf), "%s\t%s\n",
|
|
|
|
report, sha1_to_hex(sha1));
|
2007-01-11 21:15:51 +00:00
|
|
|
write_or_die(1, buf, len);
|
2006-11-01 22:06:25 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Let's just mimic git-unpack-objects here and write
|
|
|
|
* the last part of the input buffer to stdout.
|
|
|
|
*/
|
|
|
|
while (input_len) {
|
|
|
|
err = xwrite(1, input_buffer + input_offset, input_len);
|
|
|
|
if (err <= 0)
|
|
|
|
break;
|
|
|
|
input_len -= err;
|
|
|
|
input_offset += err;
|
|
|
|
}
|
|
|
|
}
|
2005-10-12 19:01:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int main(int argc, char **argv)
|
|
|
|
{
|
2006-10-26 03:28:17 +00:00
|
|
|
int i, fix_thin_pack = 0;
|
2006-10-23 18:50:18 +00:00
|
|
|
const char *curr_pack, *pack_name = NULL;
|
|
|
|
const char *curr_index, *index_name = NULL;
|
2006-10-29 09:41:59 +00:00
|
|
|
const char *keep_name = NULL, *keep_msg = NULL;
|
|
|
|
char *index_name_buf = NULL, *keep_name_buf = NULL;
|
2007-06-01 19:18:05 +00:00
|
|
|
struct pack_idx_entry **idx_objects;
|
2005-10-12 23:54:19 +00:00
|
|
|
unsigned char sha1[20];
|
2005-10-12 19:01:31 +00:00
|
|
|
|
|
|
|
for (i = 1; i < argc; i++) {
|
|
|
|
const char *arg = argv[i];
|
|
|
|
|
|
|
|
if (*arg == '-') {
|
2006-10-23 18:50:18 +00:00
|
|
|
if (!strcmp(arg, "--stdin")) {
|
|
|
|
from_stdin = 1;
|
2006-10-26 03:28:17 +00:00
|
|
|
} else if (!strcmp(arg, "--fix-thin")) {
|
|
|
|
fix_thin_pack = 1;
|
2006-10-29 09:41:59 +00:00
|
|
|
} else if (!strcmp(arg, "--keep")) {
|
|
|
|
keep_msg = "";
|
Mechanical conversion to use prefixcmp()
This mechanically converts strncmp() to use prefixcmp(), but only when
the parameters match specific patterns, so that they can be verified
easily. Leftover from this will be fixed in a separate step, including
idiotic conversions like
if (!strncmp("foo", arg, 3))
=>
if (!(-prefixcmp(arg, "foo")))
This was done by using this script in px.perl
#!/usr/bin/perl -i.bak -p
if (/strncmp\(([^,]+), "([^\\"]*)", (\d+)\)/ && (length($2) == $3)) {
s|strncmp\(([^,]+), "([^\\"]*)", (\d+)\)|prefixcmp($1, "$2")|;
}
if (/strncmp\("([^\\"]*)", ([^,]+), (\d+)\)/ && (length($1) == $3)) {
s|strncmp\("([^\\"]*)", ([^,]+), (\d+)\)|(-prefixcmp($2, "$1"))|;
}
and running:
$ git grep -l strncmp -- '*.c' | xargs perl px.perl
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-02-20 09:53:29 +00:00
|
|
|
} else if (!prefixcmp(arg, "--keep=")) {
|
2006-10-29 09:41:59 +00:00
|
|
|
keep_msg = arg + 7;
|
Mechanical conversion to use prefixcmp()
This mechanically converts strncmp() to use prefixcmp(), but only when
the parameters match specific patterns, so that they can be verified
easily. Leftover from this will be fixed in a separate step, including
idiotic conversions like
if (!strncmp("foo", arg, 3))
=>
if (!(-prefixcmp(arg, "foo")))
This was done by using this script in px.perl
#!/usr/bin/perl -i.bak -p
if (/strncmp\(([^,]+), "([^\\"]*)", (\d+)\)/ && (length($2) == $3)) {
s|strncmp\(([^,]+), "([^\\"]*)", (\d+)\)|prefixcmp($1, "$2")|;
}
if (/strncmp\("([^\\"]*)", ([^,]+), (\d+)\)/ && (length($1) == $3)) {
s|strncmp\("([^\\"]*)", ([^,]+), (\d+)\)|(-prefixcmp($2, "$1"))|;
}
and running:
$ git grep -l strncmp -- '*.c' | xargs perl px.perl
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-02-20 09:53:29 +00:00
|
|
|
} else if (!prefixcmp(arg, "--pack_header=")) {
|
2006-11-01 22:06:20 +00:00
|
|
|
struct pack_header *hdr;
|
|
|
|
char *c;
|
|
|
|
|
|
|
|
hdr = (struct pack_header *)input_buffer;
|
|
|
|
hdr->hdr_signature = htonl(PACK_SIGNATURE);
|
|
|
|
hdr->hdr_version = htonl(strtoul(arg + 14, &c, 10));
|
|
|
|
if (*c != ',')
|
|
|
|
die("bad %s", arg);
|
|
|
|
hdr->hdr_entries = htonl(strtoul(c + 1, &c, 10));
|
|
|
|
if (*c)
|
|
|
|
die("bad %s", arg);
|
|
|
|
input_len = sizeof(*hdr);
|
2006-10-26 03:32:59 +00:00
|
|
|
} else if (!strcmp(arg, "-v")) {
|
|
|
|
verbose = 1;
|
2006-10-23 18:50:18 +00:00
|
|
|
} else if (!strcmp(arg, "-o")) {
|
2005-10-12 19:01:31 +00:00
|
|
|
if (index_name || (i+1) >= argc)
|
|
|
|
usage(index_pack_usage);
|
|
|
|
index_name = argv[++i];
|
2007-04-09 21:32:03 +00:00
|
|
|
} else if (!prefixcmp(arg, "--index-version=")) {
|
|
|
|
char *c;
|
2007-06-01 19:18:05 +00:00
|
|
|
pack_idx_default_version = strtoul(arg + 16, &c, 10);
|
|
|
|
if (pack_idx_default_version > 2)
|
2007-04-09 21:32:03 +00:00
|
|
|
die("bad %s", arg);
|
|
|
|
if (*c == ',')
|
2007-06-01 19:18:05 +00:00
|
|
|
pack_idx_off32_limit = strtoul(c+1, &c, 0);
|
|
|
|
if (*c || pack_idx_off32_limit & 0x80000000)
|
2007-04-09 21:32:03 +00:00
|
|
|
die("bad %s", arg);
|
2005-10-12 19:01:31 +00:00
|
|
|
} else
|
|
|
|
usage(index_pack_usage);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pack_name)
|
|
|
|
usage(index_pack_usage);
|
|
|
|
pack_name = arg;
|
|
|
|
}
|
|
|
|
|
2006-10-23 18:50:18 +00:00
|
|
|
if (!pack_name && !from_stdin)
|
2005-10-12 19:01:31 +00:00
|
|
|
usage(index_pack_usage);
|
2006-10-26 03:28:17 +00:00
|
|
|
if (fix_thin_pack && !from_stdin)
|
|
|
|
die("--fix-thin cannot be used without --stdin");
|
2006-10-23 18:50:18 +00:00
|
|
|
if (!index_name && pack_name) {
|
2005-10-12 19:01:31 +00:00
|
|
|
int len = strlen(pack_name);
|
2006-08-11 12:01:45 +00:00
|
|
|
if (!has_extension(pack_name, ".pack"))
|
2005-10-12 19:01:31 +00:00
|
|
|
die("packfile name '%s' does not end with '.pack'",
|
|
|
|
pack_name);
|
2005-12-21 20:35:48 +00:00
|
|
|
index_name_buf = xmalloc(len);
|
2005-10-12 19:01:31 +00:00
|
|
|
memcpy(index_name_buf, pack_name, len - 5);
|
|
|
|
strcpy(index_name_buf + len - 5, ".idx");
|
|
|
|
index_name = index_name_buf;
|
|
|
|
}
|
2006-10-29 09:41:59 +00:00
|
|
|
if (keep_msg && !keep_name && pack_name) {
|
|
|
|
int len = strlen(pack_name);
|
|
|
|
if (!has_extension(pack_name, ".pack"))
|
|
|
|
die("packfile name '%s' does not end with '.pack'",
|
|
|
|
pack_name);
|
|
|
|
keep_name_buf = xmalloc(len);
|
|
|
|
memcpy(keep_name_buf, pack_name, len - 5);
|
|
|
|
strcpy(keep_name_buf + len - 5, ".keep");
|
|
|
|
keep_name = keep_name_buf;
|
|
|
|
}
|
2005-10-12 19:01:31 +00:00
|
|
|
|
2006-10-23 18:50:18 +00:00
|
|
|
curr_pack = open_pack_file(pack_name);
|
2005-10-12 19:01:31 +00:00
|
|
|
parse_pack_header();
|
2006-10-26 03:28:17 +00:00
|
|
|
objects = xmalloc((nr_objects + 1) * sizeof(struct object_entry));
|
|
|
|
deltas = xmalloc(nr_objects * sizeof(struct delta_entry));
|
2006-10-20 18:45:21 +00:00
|
|
|
parse_pack_objects(sha1);
|
2007-04-18 18:27:45 +00:00
|
|
|
if (nr_deltas == nr_resolved_deltas) {
|
|
|
|
if (verbose)
|
|
|
|
stop_progress(&progress);
|
|
|
|
/* Flush remaining pack final 20-byte SHA1. */
|
|
|
|
flush();
|
|
|
|
} else {
|
2006-10-26 03:28:17 +00:00
|
|
|
if (fix_thin_pack) {
|
|
|
|
int nr_unresolved = nr_deltas - nr_resolved_deltas;
|
2006-10-26 03:32:59 +00:00
|
|
|
int nr_objects_initial = nr_objects;
|
2006-10-26 03:28:17 +00:00
|
|
|
if (nr_unresolved <= 0)
|
|
|
|
die("confusion beyond insanity");
|
|
|
|
objects = xrealloc(objects,
|
|
|
|
(nr_objects + nr_unresolved + 1)
|
|
|
|
* sizeof(*objects));
|
|
|
|
fix_unresolved_deltas(nr_unresolved);
|
2007-04-18 18:27:45 +00:00
|
|
|
if (verbose) {
|
|
|
|
stop_progress(&progress);
|
2006-10-26 03:32:59 +00:00
|
|
|
fprintf(stderr, "%d objects were added to complete this thin pack.\n",
|
|
|
|
nr_objects - nr_objects_initial);
|
2007-04-18 18:27:45 +00:00
|
|
|
}
|
2007-05-02 16:14:15 +00:00
|
|
|
fixup_pack_header_footer(output_fd, sha1,
|
|
|
|
curr_pack, nr_objects);
|
2006-10-26 03:28:17 +00:00
|
|
|
}
|
|
|
|
if (nr_deltas != nr_resolved_deltas)
|
|
|
|
die("pack has %d unresolved deltas",
|
|
|
|
nr_deltas - nr_resolved_deltas);
|
|
|
|
}
|
2005-10-12 19:01:31 +00:00
|
|
|
free(deltas);
|
2007-06-01 19:18:05 +00:00
|
|
|
|
|
|
|
idx_objects = xmalloc((nr_objects) * sizeof(struct pack_idx_entry *));
|
|
|
|
for (i = 0; i < nr_objects; i++)
|
|
|
|
idx_objects[i] = &objects[i].idx;
|
|
|
|
curr_index = write_idx_file(index_name, idx_objects, nr_objects, sha1);
|
|
|
|
free(idx_objects);
|
|
|
|
|
2006-10-29 09:41:59 +00:00
|
|
|
final(pack_name, curr_pack,
|
|
|
|
index_name, curr_index,
|
|
|
|
keep_name, keep_msg,
|
|
|
|
sha1);
|
2005-10-12 19:01:31 +00:00
|
|
|
free(objects);
|
|
|
|
free(index_name_buf);
|
2006-10-29 09:41:59 +00:00
|
|
|
free(keep_name_buf);
|
2005-10-12 19:01:31 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|