2005-05-09 21:33:02 +00:00
|
|
|
/*
|
2006-03-25 22:21:03 +00:00
|
|
|
* Copyright (c) 2005, 2006 Rene Scharfe
|
2005-05-09 21:33:02 +00:00
|
|
|
*/
|
2005-04-28 19:16:43 +00:00
|
|
|
#include <time.h>
|
|
|
|
#include "cache.h"
|
2006-03-30 06:55:43 +00:00
|
|
|
#include "tree-walk.h"
|
2006-01-29 19:05:20 +00:00
|
|
|
#include "commit.h"
|
2006-03-25 22:21:03 +00:00
|
|
|
#include "strbuf.h"
|
|
|
|
#include "tar.h"
|
2006-05-23 12:15:31 +00:00
|
|
|
#include "builtin.h"
|
2006-05-19 01:46:44 +00:00
|
|
|
#include "pkt-line.h"
|
2005-04-28 19:16:43 +00:00
|
|
|
|
|
|
|
#define RECORDSIZE (512)
|
|
|
|
#define BLOCKSIZE (RECORDSIZE * 20)
|
|
|
|
|
2006-05-19 01:46:44 +00:00
|
|
|
static const char tar_tree_usage[] =
|
|
|
|
"git-tar-tree [--remote=<repo>] <ent> [basedir]";
|
2005-04-28 19:16:43 +00:00
|
|
|
|
|
|
|
static char block[BLOCKSIZE];
|
|
|
|
static unsigned long offset;
|
|
|
|
|
|
|
|
static time_t archive_time;
|
|
|
|
|
|
|
|
/* tries hard to write, either succeeds or dies in the attempt */
|
2006-06-18 10:58:01 +00:00
|
|
|
static void reliable_write(const void *data, unsigned long size)
|
2005-04-28 19:16:43 +00:00
|
|
|
{
|
2006-06-18 10:58:01 +00:00
|
|
|
const char *buf = data;
|
|
|
|
|
2005-04-28 19:16:43 +00:00
|
|
|
while (size > 0) {
|
2005-12-20 00:18:28 +00:00
|
|
|
long ret = xwrite(1, buf, size);
|
2005-04-28 19:16:43 +00:00
|
|
|
if (ret < 0) {
|
|
|
|
if (errno == EPIPE)
|
|
|
|
exit(0);
|
2005-05-19 11:17:16 +00:00
|
|
|
die("git-tar-tree: %s", strerror(errno));
|
2005-04-28 19:16:43 +00:00
|
|
|
} else if (!ret) {
|
2005-05-19 11:17:16 +00:00
|
|
|
die("git-tar-tree: disk full?");
|
2005-04-28 19:16:43 +00:00
|
|
|
}
|
|
|
|
size -= ret;
|
|
|
|
buf += ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* writes out the whole block, but only if it is full */
|
|
|
|
static void write_if_needed(void)
|
|
|
|
{
|
|
|
|
if (offset == BLOCKSIZE) {
|
|
|
|
reliable_write(block, BLOCKSIZE);
|
|
|
|
offset = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* queues up writes, so that all our write(2) calls write exactly one
|
|
|
|
* full block; pads writes to RECORDSIZE
|
|
|
|
*/
|
2006-06-18 10:58:01 +00:00
|
|
|
static void write_blocked(const void *data, unsigned long size)
|
2005-04-28 19:16:43 +00:00
|
|
|
{
|
2006-06-18 10:58:01 +00:00
|
|
|
const char *buf = data;
|
2005-04-28 19:16:43 +00:00
|
|
|
unsigned long tail;
|
|
|
|
|
|
|
|
if (offset) {
|
|
|
|
unsigned long chunk = BLOCKSIZE - offset;
|
|
|
|
if (size < chunk)
|
|
|
|
chunk = size;
|
|
|
|
memcpy(block + offset, buf, chunk);
|
|
|
|
size -= chunk;
|
|
|
|
offset += chunk;
|
|
|
|
buf += chunk;
|
|
|
|
write_if_needed();
|
|
|
|
}
|
|
|
|
while (size >= BLOCKSIZE) {
|
|
|
|
reliable_write(buf, BLOCKSIZE);
|
|
|
|
size -= BLOCKSIZE;
|
|
|
|
buf += BLOCKSIZE;
|
|
|
|
}
|
|
|
|
if (size) {
|
|
|
|
memcpy(block + offset, buf, size);
|
|
|
|
offset += size;
|
|
|
|
}
|
|
|
|
tail = offset % RECORDSIZE;
|
|
|
|
if (tail) {
|
|
|
|
memset(block + offset, 0, RECORDSIZE - tail);
|
|
|
|
offset += RECORDSIZE - tail;
|
|
|
|
}
|
|
|
|
write_if_needed();
|
|
|
|
}
|
|
|
|
|
2006-06-18 10:57:56 +00:00
|
|
|
/*
|
|
|
|
* The end of tar archives is marked by 2*512 nul bytes and after that
|
|
|
|
* follows the rest of the block (if any).
|
|
|
|
*/
|
|
|
|
static void write_trailer(void)
|
|
|
|
{
|
|
|
|
int tail = BLOCKSIZE - offset;
|
|
|
|
memset(block + offset, 0, tail);
|
|
|
|
reliable_write(block, BLOCKSIZE);
|
|
|
|
if (tail < 2 * RECORDSIZE) {
|
|
|
|
memset(block, 0, offset);
|
|
|
|
reliable_write(block, BLOCKSIZE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-03-25 22:21:04 +00:00
|
|
|
static void strbuf_append_string(struct strbuf *sb, const char *s)
|
2005-04-28 19:16:43 +00:00
|
|
|
{
|
2006-03-25 22:21:04 +00:00
|
|
|
int slen = strlen(s);
|
|
|
|
int total = sb->len + slen;
|
|
|
|
if (total > sb->alloc) {
|
|
|
|
sb->buf = xrealloc(sb->buf, total);
|
|
|
|
sb->alloc = total;
|
2005-04-28 19:16:43 +00:00
|
|
|
}
|
2006-03-25 22:21:04 +00:00
|
|
|
memcpy(sb->buf + sb->len, s, slen);
|
|
|
|
sb->len = total;
|
2005-04-28 19:16:43 +00:00
|
|
|
}
|
|
|
|
|
2006-03-25 22:21:03 +00:00
|
|
|
/*
|
|
|
|
* pax extended header records have the format "%u %s=%s\n". %u contains
|
|
|
|
* the size of the whole string (including the %u), the first %s is the
|
|
|
|
* keyword, the second one is the value. This function constructs such a
|
|
|
|
* string and appends it to a struct strbuf.
|
|
|
|
*/
|
|
|
|
static void strbuf_append_ext_header(struct strbuf *sb, const char *keyword,
|
|
|
|
const char *value, unsigned int valuelen)
|
2005-05-06 20:56:01 +00:00
|
|
|
{
|
2006-03-25 22:21:03 +00:00
|
|
|
char *p;
|
|
|
|
int len, total, tmp;
|
2005-05-06 20:56:01 +00:00
|
|
|
|
|
|
|
/* "%u %s=%s\n" */
|
2006-03-25 22:21:03 +00:00
|
|
|
len = 1 + 1 + strlen(keyword) + 1 + valuelen + 1;
|
|
|
|
for (tmp = len; tmp > 9; tmp /= 10)
|
2005-05-06 20:56:01 +00:00
|
|
|
len++;
|
|
|
|
|
2006-03-25 22:21:03 +00:00
|
|
|
total = sb->len + len;
|
|
|
|
if (total > sb->alloc) {
|
|
|
|
sb->buf = xrealloc(sb->buf, total);
|
|
|
|
sb->alloc = total;
|
|
|
|
}
|
2005-05-06 20:56:01 +00:00
|
|
|
|
2006-03-25 22:21:03 +00:00
|
|
|
p = sb->buf;
|
|
|
|
p += sprintf(p, "%u %s=", len, keyword);
|
|
|
|
memcpy(p, value, valuelen);
|
|
|
|
p += valuelen;
|
|
|
|
*p = '\n';
|
|
|
|
sb->len = total;
|
|
|
|
}
|
2005-04-28 19:16:43 +00:00
|
|
|
|
2006-03-25 22:21:03 +00:00
|
|
|
static unsigned int ustar_header_chksum(const struct ustar_header *header)
|
2005-04-28 19:16:43 +00:00
|
|
|
{
|
2006-03-25 22:21:03 +00:00
|
|
|
char *p = (char *)header;
|
|
|
|
unsigned int chksum = 0;
|
|
|
|
while (p < header->chksum)
|
|
|
|
chksum += *p++;
|
|
|
|
chksum += sizeof(header->chksum) * ' ';
|
|
|
|
p += sizeof(header->chksum);
|
|
|
|
while (p < (char *)header + sizeof(struct ustar_header))
|
|
|
|
chksum += *p++;
|
|
|
|
return chksum;
|
2005-04-28 19:16:43 +00:00
|
|
|
}
|
|
|
|
|
2006-03-25 22:21:07 +00:00
|
|
|
static int get_path_prefix(const struct strbuf *path, int maxlen)
|
2005-04-30 02:51:04 +00:00
|
|
|
{
|
2006-03-25 22:21:07 +00:00
|
|
|
int i = path->len;
|
|
|
|
if (i > maxlen)
|
|
|
|
i = maxlen;
|
2006-06-07 18:05:43 +00:00
|
|
|
do {
|
2006-03-25 22:21:07 +00:00
|
|
|
i--;
|
2006-06-07 18:05:43 +00:00
|
|
|
} while (i > 0 && path->buf[i] != '/');
|
2006-03-25 22:21:07 +00:00
|
|
|
return i;
|
2005-04-30 02:51:04 +00:00
|
|
|
}
|
|
|
|
|
2006-03-25 22:21:03 +00:00
|
|
|
static void write_entry(const unsigned char *sha1, struct strbuf *path,
|
|
|
|
unsigned int mode, void *buffer, unsigned long size)
|
2005-04-28 19:16:43 +00:00
|
|
|
{
|
2006-03-25 22:21:03 +00:00
|
|
|
struct ustar_header header;
|
|
|
|
struct strbuf ext_header;
|
|
|
|
|
|
|
|
memset(&header, 0, sizeof(header));
|
|
|
|
ext_header.buf = NULL;
|
|
|
|
ext_header.len = ext_header.alloc = 0;
|
|
|
|
|
|
|
|
if (!sha1) {
|
|
|
|
*header.typeflag = TYPEFLAG_GLOBAL_HEADER;
|
|
|
|
mode = 0100666;
|
|
|
|
strcpy(header.name, "pax_global_header");
|
|
|
|
} else if (!path) {
|
|
|
|
*header.typeflag = TYPEFLAG_EXT_HEADER;
|
|
|
|
mode = 0100666;
|
|
|
|
sprintf(header.name, "%s.paxheader", sha1_to_hex(sha1));
|
2005-04-28 19:16:43 +00:00
|
|
|
} else {
|
2006-03-25 22:21:03 +00:00
|
|
|
if (S_ISDIR(mode)) {
|
|
|
|
*header.typeflag = TYPEFLAG_DIR;
|
|
|
|
mode |= 0777;
|
|
|
|
} else if (S_ISLNK(mode)) {
|
|
|
|
*header.typeflag = TYPEFLAG_LNK;
|
|
|
|
mode |= 0777;
|
|
|
|
} else if (S_ISREG(mode)) {
|
|
|
|
*header.typeflag = TYPEFLAG_REG;
|
|
|
|
mode |= (mode & 0100) ? 0777 : 0666;
|
|
|
|
} else {
|
|
|
|
error("unsupported file mode: 0%o (SHA1: %s)",
|
|
|
|
mode, sha1_to_hex(sha1));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (path->len > sizeof(header.name)) {
|
2006-03-25 22:21:07 +00:00
|
|
|
int plen = get_path_prefix(path, sizeof(header.prefix));
|
|
|
|
int rest = path->len - plen - 1;
|
|
|
|
if (plen > 0 && rest <= sizeof(header.name)) {
|
|
|
|
memcpy(header.prefix, path->buf, plen);
|
|
|
|
memcpy(header.name, path->buf + plen + 1, rest);
|
|
|
|
} else {
|
|
|
|
sprintf(header.name, "%s.data",
|
|
|
|
sha1_to_hex(sha1));
|
|
|
|
strbuf_append_ext_header(&ext_header, "path",
|
|
|
|
path->buf, path->len);
|
|
|
|
}
|
2006-03-25 22:21:03 +00:00
|
|
|
} else
|
|
|
|
memcpy(header.name, path->buf, path->len);
|
2005-04-28 19:16:43 +00:00
|
|
|
}
|
|
|
|
|
2006-03-25 22:21:03 +00:00
|
|
|
if (S_ISLNK(mode) && buffer) {
|
|
|
|
if (size > sizeof(header.linkname)) {
|
|
|
|
sprintf(header.linkname, "see %s.paxheader",
|
2005-05-06 20:56:16 +00:00
|
|
|
sha1_to_hex(sha1));
|
2006-03-25 22:21:03 +00:00
|
|
|
strbuf_append_ext_header(&ext_header, "linkpath",
|
|
|
|
buffer, size);
|
|
|
|
} else
|
|
|
|
memcpy(header.linkname, buffer, size);
|
2005-05-06 20:56:16 +00:00
|
|
|
}
|
|
|
|
|
2006-03-25 22:21:03 +00:00
|
|
|
sprintf(header.mode, "%07o", mode & 07777);
|
|
|
|
sprintf(header.size, "%011lo", S_ISREG(mode) ? size : 0);
|
|
|
|
sprintf(header.mtime, "%011lo", archive_time);
|
2005-04-28 19:16:43 +00:00
|
|
|
|
|
|
|
/* XXX: should we provide more meaningful info here? */
|
2006-03-25 22:21:03 +00:00
|
|
|
sprintf(header.uid, "%07o", 0);
|
|
|
|
sprintf(header.gid, "%07o", 0);
|
2006-06-24 14:01:25 +00:00
|
|
|
strlcpy(header.uname, "git", sizeof(header.uname));
|
|
|
|
strlcpy(header.gname, "git", sizeof(header.gname));
|
2006-03-25 22:21:03 +00:00
|
|
|
sprintf(header.devmajor, "%07o", 0);
|
|
|
|
sprintf(header.devminor, "%07o", 0);
|
2005-04-28 19:16:43 +00:00
|
|
|
|
2006-03-25 22:21:03 +00:00
|
|
|
memcpy(header.magic, "ustar", 6);
|
|
|
|
memcpy(header.version, "00", 2);
|
2005-04-28 19:16:43 +00:00
|
|
|
|
2006-03-25 22:21:03 +00:00
|
|
|
sprintf(header.chksum, "%07o", ustar_header_chksum(&header));
|
2005-04-28 19:16:43 +00:00
|
|
|
|
2006-03-25 22:21:03 +00:00
|
|
|
if (ext_header.len > 0) {
|
|
|
|
write_entry(sha1, NULL, 0, ext_header.buf, ext_header.len);
|
|
|
|
free(ext_header.buf);
|
|
|
|
}
|
|
|
|
write_blocked(&header, sizeof(header));
|
|
|
|
if (S_ISREG(mode) && buffer && size > 0)
|
|
|
|
write_blocked(buffer, size);
|
|
|
|
}
|
2005-04-28 19:16:43 +00:00
|
|
|
|
2005-05-18 12:14:09 +00:00
|
|
|
static void write_global_extended_header(const unsigned char *sha1)
|
2005-04-30 02:51:04 +00:00
|
|
|
{
|
2006-03-25 22:21:03 +00:00
|
|
|
struct strbuf ext_header;
|
|
|
|
ext_header.buf = NULL;
|
|
|
|
ext_header.len = ext_header.alloc = 0;
|
|
|
|
strbuf_append_ext_header(&ext_header, "comment", sha1_to_hex(sha1), 40);
|
|
|
|
write_entry(NULL, NULL, 0, ext_header.buf, ext_header.len);
|
|
|
|
free(ext_header.buf);
|
2005-04-28 19:16:43 +00:00
|
|
|
}
|
|
|
|
|
2006-03-25 22:21:04 +00:00
|
|
|
static void traverse_tree(struct tree_desc *tree, struct strbuf *path)
|
2005-04-28 19:16:43 +00:00
|
|
|
{
|
2006-03-25 22:21:04 +00:00
|
|
|
int pathlen = path->len;
|
tree_entry(): new tree-walking helper function
This adds a "tree_entry()" function that combines the common operation of
doing a "tree_entry_extract()" + "update_tree_entry()".
It also has a simplified calling convention, designed for simple loops
that traverse over a whole tree: the arguments are pointers to the tree
descriptor and a name_entry structure to fill in, and it returns a boolean
"true" if there was an entry left to be gotten in the tree.
This allows tree traversal with
struct tree_desc desc;
struct name_entry entry;
desc.buf = tree->buffer;
desc.size = tree->size;
while (tree_entry(&desc, &entry) {
... use "entry.{path, sha1, mode, pathlen}" ...
}
which is not only shorter than writing it out in full, it's hopefully less
error prone too.
[ It's actually a tad faster too - we don't need to recalculate the entry
pathlength in both extract and update, but need to do it only once.
Also, some callers can avoid doing a "strlen()" on the result, since
it's returned as part of the name_entry structure.
However, by now we're talking just 1% speedup on "git-rev-list --objects
--all", and we're definitely at the point where tree walking is no
longer the issue any more. ]
NOTE! Not everybody wants to use this new helper function, since some of
the tree walkers very much on purpose do the descriptor update separately
from the entry extraction. So the "extract + update" sequence still
remains as the core sequence, this is just a simplified interface.
We should probably add a silly two-line inline helper function for
initializing the descriptor from the "struct tree" too, just to cut down
on the noise from that common "desc" initializer.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-05-30 16:45:45 +00:00
|
|
|
struct name_entry entry;
|
2005-04-28 19:16:43 +00:00
|
|
|
|
tree_entry(): new tree-walking helper function
This adds a "tree_entry()" function that combines the common operation of
doing a "tree_entry_extract()" + "update_tree_entry()".
It also has a simplified calling convention, designed for simple loops
that traverse over a whole tree: the arguments are pointers to the tree
descriptor and a name_entry structure to fill in, and it returns a boolean
"true" if there was an entry left to be gotten in the tree.
This allows tree traversal with
struct tree_desc desc;
struct name_entry entry;
desc.buf = tree->buffer;
desc.size = tree->size;
while (tree_entry(&desc, &entry) {
... use "entry.{path, sha1, mode, pathlen}" ...
}
which is not only shorter than writing it out in full, it's hopefully less
error prone too.
[ It's actually a tad faster too - we don't need to recalculate the entry
pathlength in both extract and update, but need to do it only once.
Also, some callers can avoid doing a "strlen()" on the result, since
it's returned as part of the name_entry structure.
However, by now we're talking just 1% speedup on "git-rev-list --objects
--all", and we're definitely at the point where tree walking is no
longer the issue any more. ]
NOTE! Not everybody wants to use this new helper function, since some of
the tree walkers very much on purpose do the descriptor update separately
from the entry extraction. So the "extract + update" sequence still
remains as the core sequence, this is just a simplified interface.
We should probably add a silly two-line inline helper function for
initializing the descriptor from the "struct tree" too, just to cut down
on the noise from that common "desc" initializer.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-05-30 16:45:45 +00:00
|
|
|
while (tree_entry(tree, &entry)) {
|
2005-04-28 19:16:43 +00:00
|
|
|
void *eltbuf;
|
|
|
|
char elttype[20];
|
|
|
|
unsigned long eltsize;
|
2006-01-29 19:04:59 +00:00
|
|
|
|
tree_entry(): new tree-walking helper function
This adds a "tree_entry()" function that combines the common operation of
doing a "tree_entry_extract()" + "update_tree_entry()".
It also has a simplified calling convention, designed for simple loops
that traverse over a whole tree: the arguments are pointers to the tree
descriptor and a name_entry structure to fill in, and it returns a boolean
"true" if there was an entry left to be gotten in the tree.
This allows tree traversal with
struct tree_desc desc;
struct name_entry entry;
desc.buf = tree->buffer;
desc.size = tree->size;
while (tree_entry(&desc, &entry) {
... use "entry.{path, sha1, mode, pathlen}" ...
}
which is not only shorter than writing it out in full, it's hopefully less
error prone too.
[ It's actually a tad faster too - we don't need to recalculate the entry
pathlength in both extract and update, but need to do it only once.
Also, some callers can avoid doing a "strlen()" on the result, since
it's returned as part of the name_entry structure.
However, by now we're talking just 1% speedup on "git-rev-list --objects
--all", and we're definitely at the point where tree walking is no
longer the issue any more. ]
NOTE! Not everybody wants to use this new helper function, since some of
the tree walkers very much on purpose do the descriptor update separately
from the entry extraction. So the "extract + update" sequence still
remains as the core sequence, this is just a simplified interface.
We should probably add a silly two-line inline helper function for
initializing the descriptor from the "struct tree" too, just to cut down
on the noise from that common "desc" initializer.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-05-30 16:45:45 +00:00
|
|
|
eltbuf = read_sha1_file(entry.sha1, elttype, &eltsize);
|
2005-04-28 19:16:43 +00:00
|
|
|
if (!eltbuf)
|
tree_entry(): new tree-walking helper function
This adds a "tree_entry()" function that combines the common operation of
doing a "tree_entry_extract()" + "update_tree_entry()".
It also has a simplified calling convention, designed for simple loops
that traverse over a whole tree: the arguments are pointers to the tree
descriptor and a name_entry structure to fill in, and it returns a boolean
"true" if there was an entry left to be gotten in the tree.
This allows tree traversal with
struct tree_desc desc;
struct name_entry entry;
desc.buf = tree->buffer;
desc.size = tree->size;
while (tree_entry(&desc, &entry) {
... use "entry.{path, sha1, mode, pathlen}" ...
}
which is not only shorter than writing it out in full, it's hopefully less
error prone too.
[ It's actually a tad faster too - we don't need to recalculate the entry
pathlength in both extract and update, but need to do it only once.
Also, some callers can avoid doing a "strlen()" on the result, since
it's returned as part of the name_entry structure.
However, by now we're talking just 1% speedup on "git-rev-list --objects
--all", and we're definitely at the point where tree walking is no
longer the issue any more. ]
NOTE! Not everybody wants to use this new helper function, since some of
the tree walkers very much on purpose do the descriptor update separately
from the entry extraction. So the "extract + update" sequence still
remains as the core sequence, this is just a simplified interface.
We should probably add a silly two-line inline helper function for
initializing the descriptor from the "struct tree" too, just to cut down
on the noise from that common "desc" initializer.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-05-30 16:45:45 +00:00
|
|
|
die("cannot read %s", sha1_to_hex(entry.sha1));
|
2006-03-25 22:21:04 +00:00
|
|
|
|
|
|
|
path->len = pathlen;
|
tree_entry(): new tree-walking helper function
This adds a "tree_entry()" function that combines the common operation of
doing a "tree_entry_extract()" + "update_tree_entry()".
It also has a simplified calling convention, designed for simple loops
that traverse over a whole tree: the arguments are pointers to the tree
descriptor and a name_entry structure to fill in, and it returns a boolean
"true" if there was an entry left to be gotten in the tree.
This allows tree traversal with
struct tree_desc desc;
struct name_entry entry;
desc.buf = tree->buffer;
desc.size = tree->size;
while (tree_entry(&desc, &entry) {
... use "entry.{path, sha1, mode, pathlen}" ...
}
which is not only shorter than writing it out in full, it's hopefully less
error prone too.
[ It's actually a tad faster too - we don't need to recalculate the entry
pathlength in both extract and update, but need to do it only once.
Also, some callers can avoid doing a "strlen()" on the result, since
it's returned as part of the name_entry structure.
However, by now we're talking just 1% speedup on "git-rev-list --objects
--all", and we're definitely at the point where tree walking is no
longer the issue any more. ]
NOTE! Not everybody wants to use this new helper function, since some of
the tree walkers very much on purpose do the descriptor update separately
from the entry extraction. So the "extract + update" sequence still
remains as the core sequence, this is just a simplified interface.
We should probably add a silly two-line inline helper function for
initializing the descriptor from the "struct tree" too, just to cut down
on the noise from that common "desc" initializer.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-05-30 16:45:45 +00:00
|
|
|
strbuf_append_string(path, entry.path);
|
|
|
|
if (S_ISDIR(entry.mode))
|
2006-03-25 22:21:04 +00:00
|
|
|
strbuf_append_string(path, "/");
|
|
|
|
|
tree_entry(): new tree-walking helper function
This adds a "tree_entry()" function that combines the common operation of
doing a "tree_entry_extract()" + "update_tree_entry()".
It also has a simplified calling convention, designed for simple loops
that traverse over a whole tree: the arguments are pointers to the tree
descriptor and a name_entry structure to fill in, and it returns a boolean
"true" if there was an entry left to be gotten in the tree.
This allows tree traversal with
struct tree_desc desc;
struct name_entry entry;
desc.buf = tree->buffer;
desc.size = tree->size;
while (tree_entry(&desc, &entry) {
... use "entry.{path, sha1, mode, pathlen}" ...
}
which is not only shorter than writing it out in full, it's hopefully less
error prone too.
[ It's actually a tad faster too - we don't need to recalculate the entry
pathlength in both extract and update, but need to do it only once.
Also, some callers can avoid doing a "strlen()" on the result, since
it's returned as part of the name_entry structure.
However, by now we're talking just 1% speedup on "git-rev-list --objects
--all", and we're definitely at the point where tree walking is no
longer the issue any more. ]
NOTE! Not everybody wants to use this new helper function, since some of
the tree walkers very much on purpose do the descriptor update separately
from the entry extraction. So the "extract + update" sequence still
remains as the core sequence, this is just a simplified interface.
We should probably add a silly two-line inline helper function for
initializing the descriptor from the "struct tree" too, just to cut down
on the noise from that common "desc" initializer.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-05-30 16:45:45 +00:00
|
|
|
write_entry(entry.sha1, path, entry.mode, eltbuf, eltsize);
|
2006-03-25 22:21:04 +00:00
|
|
|
|
tree_entry(): new tree-walking helper function
This adds a "tree_entry()" function that combines the common operation of
doing a "tree_entry_extract()" + "update_tree_entry()".
It also has a simplified calling convention, designed for simple loops
that traverse over a whole tree: the arguments are pointers to the tree
descriptor and a name_entry structure to fill in, and it returns a boolean
"true" if there was an entry left to be gotten in the tree.
This allows tree traversal with
struct tree_desc desc;
struct name_entry entry;
desc.buf = tree->buffer;
desc.size = tree->size;
while (tree_entry(&desc, &entry) {
... use "entry.{path, sha1, mode, pathlen}" ...
}
which is not only shorter than writing it out in full, it's hopefully less
error prone too.
[ It's actually a tad faster too - we don't need to recalculate the entry
pathlength in both extract and update, but need to do it only once.
Also, some callers can avoid doing a "strlen()" on the result, since
it's returned as part of the name_entry structure.
However, by now we're talking just 1% speedup on "git-rev-list --objects
--all", and we're definitely at the point where tree walking is no
longer the issue any more. ]
NOTE! Not everybody wants to use this new helper function, since some of
the tree walkers very much on purpose do the descriptor update separately
from the entry extraction. So the "extract + update" sequence still
remains as the core sequence, this is just a simplified interface.
We should probably add a silly two-line inline helper function for
initializing the descriptor from the "struct tree" too, just to cut down
on the noise from that common "desc" initializer.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-05-30 16:45:45 +00:00
|
|
|
if (S_ISDIR(entry.mode)) {
|
2006-01-31 22:13:40 +00:00
|
|
|
struct tree_desc subtree;
|
|
|
|
subtree.buf = eltbuf;
|
|
|
|
subtree.size = eltsize;
|
2006-03-25 22:21:04 +00:00
|
|
|
traverse_tree(&subtree, path);
|
2005-04-28 19:16:43 +00:00
|
|
|
}
|
|
|
|
free(eltbuf);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-05-23 21:44:31 +00:00
|
|
|
static int generate_tar(int argc, const char **argv, char** envp)
|
2005-04-28 19:16:43 +00:00
|
|
|
{
|
2006-03-25 22:21:02 +00:00
|
|
|
unsigned char sha1[20], tree_sha1[20];
|
2006-01-29 19:05:20 +00:00
|
|
|
struct commit *commit;
|
2006-01-31 22:13:40 +00:00
|
|
|
struct tree_desc tree;
|
2006-03-25 22:21:04 +00:00
|
|
|
struct strbuf current_path;
|
|
|
|
|
|
|
|
current_path.buf = xmalloc(PATH_MAX);
|
|
|
|
current_path.alloc = PATH_MAX;
|
|
|
|
current_path.len = current_path.eof = 0;
|
2005-04-28 19:16:43 +00:00
|
|
|
|
2005-11-26 08:50:02 +00:00
|
|
|
setup_git_directory();
|
2006-03-24 07:41:18 +00:00
|
|
|
git_config(git_default_config);
|
2005-11-26 08:50:02 +00:00
|
|
|
|
2005-04-28 19:16:43 +00:00
|
|
|
switch (argc) {
|
|
|
|
case 3:
|
2006-03-25 22:21:04 +00:00
|
|
|
strbuf_append_string(¤t_path, argv[2]);
|
|
|
|
strbuf_append_string(¤t_path, "/");
|
2005-04-28 19:16:43 +00:00
|
|
|
/* FALLTHROUGH */
|
|
|
|
case 2:
|
2006-05-08 21:43:38 +00:00
|
|
|
if (get_sha1(argv[1], sha1))
|
|
|
|
die("Not a valid object name %s", argv[1]);
|
2005-04-28 19:16:43 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
usage(tar_tree_usage);
|
|
|
|
}
|
|
|
|
|
2006-03-04 05:34:14 +00:00
|
|
|
commit = lookup_commit_reference_gently(sha1, 1);
|
2006-01-29 19:05:20 +00:00
|
|
|
if (commit) {
|
|
|
|
write_global_extended_header(commit->object.sha1);
|
|
|
|
archive_time = commit->date;
|
2006-03-25 22:21:04 +00:00
|
|
|
} else
|
|
|
|
archive_time = time(NULL);
|
|
|
|
|
2006-04-02 12:44:09 +00:00
|
|
|
tree.buf = read_object_with_reference(sha1, tree_type, &tree.size,
|
2006-03-25 22:21:02 +00:00
|
|
|
tree_sha1);
|
2006-01-31 22:13:40 +00:00
|
|
|
if (!tree.buf)
|
2005-04-29 05:19:02 +00:00
|
|
|
die("not a reference to a tag, commit or tree object: %s",
|
|
|
|
sha1_to_hex(sha1));
|
2006-03-25 22:21:04 +00:00
|
|
|
|
|
|
|
if (current_path.len > 0)
|
|
|
|
write_entry(tree_sha1, ¤t_path, 040777, NULL, 0);
|
|
|
|
traverse_tree(&tree, ¤t_path);
|
2005-04-28 19:16:43 +00:00
|
|
|
write_trailer();
|
2006-03-25 22:21:04 +00:00
|
|
|
free(current_path.buf);
|
2005-04-28 19:16:43 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2006-05-19 01:46:44 +00:00
|
|
|
|
|
|
|
static const char *exec = "git-upload-tar";
|
|
|
|
|
|
|
|
static int remote_tar(int argc, const char **argv)
|
|
|
|
{
|
|
|
|
int fd[2], ret, len;
|
|
|
|
pid_t pid;
|
|
|
|
char buf[1024];
|
|
|
|
char *url;
|
|
|
|
|
|
|
|
if (argc < 3 || 4 < argc)
|
|
|
|
usage(tar_tree_usage);
|
|
|
|
|
|
|
|
/* --remote=<repo> */
|
|
|
|
url = strdup(argv[1]+9);
|
|
|
|
pid = git_connect(fd, url, exec);
|
|
|
|
if (pid < 0)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
packet_write(fd[1], "want %s\n", argv[2]);
|
|
|
|
if (argv[3])
|
|
|
|
packet_write(fd[1], "base %s\n", argv[3]);
|
|
|
|
packet_flush(fd[1]);
|
|
|
|
|
|
|
|
len = packet_read_line(fd[0], buf, sizeof(buf));
|
|
|
|
if (!len)
|
|
|
|
die("git-tar-tree: expected ACK/NAK, got EOF");
|
|
|
|
if (buf[len-1] == '\n')
|
|
|
|
buf[--len] = 0;
|
|
|
|
if (strcmp(buf, "ACK")) {
|
|
|
|
if (5 < len && !strncmp(buf, "NACK ", 5))
|
|
|
|
die("git-tar-tree: NACK %s", buf + 5);
|
|
|
|
die("git-tar-tree: protocol error");
|
|
|
|
}
|
|
|
|
/* expect a flush */
|
|
|
|
len = packet_read_line(fd[0], buf, sizeof(buf));
|
|
|
|
if (len)
|
|
|
|
die("git-tar-tree: expected a flush");
|
|
|
|
|
|
|
|
/* Now, start reading from fd[0] and spit it out to stdout */
|
|
|
|
ret = copy_fd(fd[0], 1);
|
|
|
|
close(fd[0]);
|
|
|
|
|
|
|
|
ret |= finish_connect(pid);
|
|
|
|
return !!ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
int cmd_tar_tree(int argc, const char **argv, char **envp)
|
|
|
|
{
|
|
|
|
if (argc < 2)
|
|
|
|
usage(tar_tree_usage);
|
|
|
|
if (!strncmp("--remote=", argv[1], 9))
|
|
|
|
return remote_tar(argc, argv);
|
2006-05-23 21:44:31 +00:00
|
|
|
return generate_tar(argc, argv, envp);
|
2006-05-19 01:46:44 +00:00
|
|
|
}
|
2006-06-10 14:13:41 +00:00
|
|
|
|
|
|
|
/* ustar header + extended global header content */
|
|
|
|
#define HEADERSIZE (2 * RECORDSIZE)
|
|
|
|
|
|
|
|
int cmd_get_tar_commit_id(int argc, const char **argv, char **envp)
|
|
|
|
{
|
|
|
|
char buffer[HEADERSIZE];
|
|
|
|
struct ustar_header *header = (struct ustar_header *)buffer;
|
|
|
|
char *content = buffer + RECORDSIZE;
|
|
|
|
ssize_t n;
|
|
|
|
|
|
|
|
n = xread(0, buffer, HEADERSIZE);
|
|
|
|
if (n < HEADERSIZE)
|
|
|
|
die("git-get-tar-commit-id: read error");
|
|
|
|
if (header->typeflag[0] != 'g')
|
|
|
|
return 1;
|
|
|
|
if (memcmp(content, "52 comment=", 11))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
n = xwrite(1, content + 11, 41);
|
|
|
|
if (n < 41)
|
|
|
|
die("git-get-tar-commit-id: write error");
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|