kernel
/
git
mirror of https://git.kernel.org/pub/scm/git/git.git
1
0
Fork 0
Code Releases Activity

Make "read-tree" read the tree into the current directory cache. 

It will no longer update the actual working directory, just the
cache. To update the working directory, you need to use "checkout-cache".
maint
Linus Torvalds 2005-04-09 12:11:25 -07:00
parent 197ee8c970
commit 83adac3c57
2 changed files with 83 additions and 51 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
checkout-cache.c
View File

@ -36,6 +36,34 @@


static int force = 0, quiet = 0; static int force = 0, quiet = 0;


static void create_directories(const char *path)
{
int len = strlen(path);
char *buf = malloc(len + 1);
const char *slash = path;

while ((slash = strchr(slash+1, '/')) != NULL) {
len = slash - path;
memcpy(buf, path, len);
buf[len] = 0;
mkdir(buf, 0700);
}
}

static int create_file(const char *path, unsigned int mode)
{
int fd = open(path, O_WRONLY | O_TRUNC | O_CREAT, 0600);
if (fd < 0) {
if (errno == ENOENT) {
create_directories(path);
fd = open(path, O_WRONLY | O_TRUNC | O_CREAT, 0600);
}
}
if (fd >= 0)
fchmod(fd, mode);
return fd;
}

static int write_entry(struct cache_entry *ce) static int write_entry(struct cache_entry *ce)
{ {
int fd; int fd;
@ -50,7 +78,7 @@ static int write_entry(struct cache_entry *ce)
ce->name, sha1_to_hex(ce->sha1)); ce->name, sha1_to_hex(ce->sha1));
return -1; return -1;
} }
fd = open(ce->name, O_WRONLY | O_CREAT | O_TRUNC, 0600); fd = create_file(ce->name, ce->st_mode);
if (fd < 0) { if (fd < 0) {
fprintf(stderr, "checkout-cache: unable to create %s (%s)\n", fprintf(stderr, "checkout-cache: unable to create %s (%s)\n",
ce->name, strerror(errno)); ce->name, strerror(errno));

104
read-tree.c
View File

@ -5,33 +5,22 @@
*/ */
#include "cache.h" #include "cache.h"


static void create_directories(const char *path) static int read_one_entry(unsigned char *sha1, const char *pathname, unsigned mode)
{ {
int len = strlen(path); int len = strlen(pathname);
char *buf = malloc(len + 1); unsigned int size = cache_entry_size(len);
const char *slash = path; struct cache_entry *ce = malloc(size);


while ((slash = strchr(slash+1, '/')) != NULL) { memset(ce, 0, size);
len = slash - path;
memcpy(buf, path, len); ce->st_mode = mode;
buf[len] = 0; ce->namelen = len;
mkdir(buf, 0700); memcpy(ce->name, pathname, len+1);
} memcpy(ce->sha1, sha1, 20);
return add_cache_entry(ce);
} }


static int create_file(const char *path) static int read_tree(unsigned char *sha1)
{
int fd = open(path, O_WRONLY | O_TRUNC | O_CREAT, 0600);
if (fd < 0) {
if (errno == ENOENT) {
create_directories(path);
fd = open(path, O_WRONLY | O_TRUNC | O_CREAT, 0600);
}
}
return fd;
}

static int unpack(unsigned char *sha1)
{ {
void *buffer; void *buffer;
unsigned long size; unsigned long size;
@ -39,49 +28,64 @@ static int unpack(unsigned char *sha1)


buffer = read_sha1_file(sha1, type, &size); buffer = read_sha1_file(sha1, type, &size);
if (!buffer) if (!buffer)
usage("unable to read sha1 file"); return -1;
if (strcmp(type, "tree")) if (strcmp(type, "tree"))
usage("expected a 'tree' node"); return -1;
while (size) { while (size) {
int len = strlen(buffer)+1; int len = strlen(buffer)+1;
unsigned char *sha1 = buffer + len; unsigned char *sha1 = buffer + len;
char *path = strchr(buffer, ' ')+1; char *path = strchr(buffer, ' ')+1;
char *data;
unsigned long filesize;
unsigned int mode; unsigned int mode;
int fd;


if (size < len + 20 || sscanf(buffer, "%o", &mode) != 1) if (size < len + 20 || sscanf(buffer, "%o", &mode) != 1)
usage("corrupt 'tree' file"); return -1;

buffer = sha1 + 20; buffer = sha1 + 20;
size -= len + 20; size -= len + 20;
data = read_sha1_file(sha1, type, &filesize);
if (!data || strcmp(type, "blob")) if (read_one_entry(sha1, path, mode) < 0)
usage("tree file refers to bad file data"); return -1;
fd = create_file(path);
if (fd < 0)
usage("unable to create file");
if (write(fd, data, filesize) != filesize)
usage("unable to write file");
fchmod(fd, mode);
close(fd);
free(data);
} }
return 0; return 0;
} }


int main(int argc, char **argv) int main(int argc, char **argv)
{ {
int i, newfd;
unsigned char sha1[20]; unsigned char sha1[20];


if (argc != 2) newfd = open(".dircache/index.lock", O_RDWR | O_CREAT | O_EXCL, 0600);
usage("read-tree <key>"); if (newfd < 0)
if (get_sha1_hex(argv[1], sha1) < 0) usage("unable to create new cachefile");
usage("read-tree <key>");
sha1_file_directory = getenv(DB_ENVIRONMENT); for (i = 1; i < argc; i++) {
if (!sha1_file_directory) const char *arg = argv[i];
sha1_file_directory = DEFAULT_DB_ENVIRONMENT;
if (unpack(sha1) < 0) /* "-m" stands for "merge" current directory cache */
usage("unpack failed"); if (!strcmp(arg, "-m")) {
return 0; if (active_cache) {
fprintf(stderr, "read-tree: cannot merge old cache on top of new\n");
goto out;
}
if (read_cache() < 0) {
fprintf(stderr, "read-tree: corrupt directory cache\n");
goto out;
}
continue;
}
if (get_sha1_hex(arg, sha1) < 0) {
fprintf(stderr, "read-tree [-m] <sha1>\n");
goto out;
}
if (read_tree(sha1) < 0) {
fprintf(stderr, "failed to unpack tree object %s\n", arg);
goto out;
}
}
if (!write_cache(newfd, active_cache, active_nr) && !rename(".dircache/index.lock", ".dircache/index"))
return 0;

out:
unlink(".dircache/index.lock");
exit(1);
} }