X-Git-Url: https://git.verplant.org/?a=blobdiff_plain;f=sha1_file.c;h=d98b265bbbb6dbf222877a41bcde43eb3b5a9158;hb=86436c28289eedd2ee9b7f9c872a0ed039866a0f;hp=bb44a01746cb08863fde8a320bee40bcb3806fcf;hpb=0fcfd160b0495c0881e142c546c4418b8cea7e93;p=git.git diff --git a/sha1_file.c b/sha1_file.c index bb44a017..d98b265b 100644 --- a/sha1_file.c +++ b/sha1_file.c @@ -11,6 +11,16 @@ const char *sha1_file_directory = NULL; +#ifndef O_NOATIME +#if defined(__linux__) && (defined(__i386__) || defined(__PPC__)) +#define O_NOATIME 01000000 +#else +#define O_NOATIME 0 +#endif +#endif + +static unsigned int sha1_file_open_flag = O_NOATIME; + static unsigned hexval(char c) { if (c >= '0' && c <= '9') @@ -80,12 +90,14 @@ char *sha1_file_name(const unsigned char *sha1) return base; } -int check_sha1_signature(unsigned char *sha1, void *map, unsigned long size) +int check_sha1_signature(unsigned char *sha1, void *map, unsigned long size, const char *type) { + char header[100]; unsigned char real_sha1[20]; SHA_CTX c; SHA1_Init(&c); + SHA1_Update(&c, header, 1+sprintf(header, "%s %lu", type, size)); SHA1_Update(&c, map, size); SHA1_Final(real_sha1, &c); return memcmp(sha1, real_sha1, 20) ? -1 : 0; @@ -94,13 +106,26 @@ int check_sha1_signature(unsigned char *sha1, void *map, unsigned long size) void *map_sha1_file(const unsigned char *sha1, unsigned long *size) { char *filename = sha1_file_name(sha1); - int fd = open(filename, O_RDONLY); struct stat st; void *map; + int fd; + fd = open(filename, O_RDONLY | sha1_file_open_flag); if (fd < 0) { - perror(filename); - return NULL; + /* See if it works without O_NOATIME */ + switch (sha1_file_open_flag) { + default: + fd = open(filename, O_RDONLY); + if (fd >= 0) + break; + /* Fallthrough */ + case 0: + perror(filename); + return NULL; + } + + /* If it failed once, it will probably fail again. Stop using O_NOATIME */ + sha1_file_open_flag = 0; } if (fstat(fd, &st) < 0) { close(fd); @@ -130,6 +155,8 @@ void * unpack_sha1_file(void *map, unsigned long mapsize, char *type, unsigned l inflateInit(&stream); ret = inflate(&stream, 0); + if (ret < Z_OK) + return NULL; if (sscanf(buffer, "%10s %lu", type, size) != 2) return NULL; @@ -164,39 +191,110 @@ void * read_sha1_file(const unsigned char *sha1, char *type, unsigned long *size return NULL; } -int write_sha1_file(char *buf, unsigned len, unsigned char *returnsha1) +void *read_tree_with_tree_or_commit_sha1(const unsigned char *sha1, + unsigned long *size, + unsigned char *tree_sha1_return) +{ + char type[20]; + void *buffer; + unsigned long isize; + int was_commit = 0; + unsigned char tree_sha1[20]; + + buffer = read_sha1_file(sha1, type, &isize); + + /* + * We might have read a commit instead of a tree, in which case + * we parse out the tree_sha1 and attempt to read from there. + * (buffer + 5) is because the tree sha1 is always at offset 5 + * in a commit record ("tree "). + */ + if (buffer && + !strcmp(type, "commit") && + !get_sha1_hex(buffer + 5, tree_sha1)) { + free(buffer); + buffer = read_sha1_file(tree_sha1, type, &isize); + was_commit = 1; + } + + /* + * Now do we have something and if so is it a tree? + */ + if (!buffer || strcmp(type, "tree")) { + free(buffer); + return NULL; + } + + *size = isize; + if (tree_sha1_return) + memcpy(tree_sha1_return, was_commit ? tree_sha1 : sha1, 20); + return buffer; +} + +int write_sha1_file(char *buf, unsigned long len, const char *type, unsigned char *returnsha1) { int size; char *compressed; z_stream stream; unsigned char sha1[20]; SHA_CTX c; + char *filename; + char hdr[50]; + int fd, hdrlen; + + /* Generate the header */ + hdrlen = sprintf(hdr, "%s %lu", type, len)+1; + + /* Sha1.. */ + SHA1_Init(&c); + SHA1_Update(&c, hdr, hdrlen); + SHA1_Update(&c, buf, len); + SHA1_Final(sha1, &c); + + if (returnsha1) + memcpy(returnsha1, sha1, 20); + + filename = sha1_file_name(sha1); + fd = open(filename, O_WRONLY | O_CREAT | O_EXCL, 0666); + if (fd < 0) { + if (errno != EEXIST) + return -1; + + /* + * We might do collision checking here, but we'd need to + * uncompress the old file and check it. Later. + */ + return 0; + } /* Set it up */ memset(&stream, 0, sizeof(stream)); deflateInit(&stream, Z_BEST_COMPRESSION); - size = deflateBound(&stream, len); + size = deflateBound(&stream, len+hdrlen); compressed = malloc(size); /* Compress it */ - stream.next_in = buf; - stream.avail_in = len; stream.next_out = compressed; stream.avail_out = size; + + /* First header.. */ + stream.next_in = hdr; + stream.avail_in = hdrlen; + while (deflate(&stream, 0) == Z_OK) + /* nothing */ + + /* Then the data itself.. */ + stream.next_in = buf; + stream.avail_in = len; while (deflate(&stream, Z_FINISH) == Z_OK) /* nothing */; deflateEnd(&stream); size = stream.total_out; - /* Sha1.. */ - SHA1_Init(&c); - SHA1_Update(&c, compressed, size); - SHA1_Final(sha1, &c); - - if (write_sha1_buffer(sha1, compressed, size) < 0) - return -1; - if (returnsha1) - memcpy(returnsha1, sha1, 20); + if (write(fd, compressed, size) != size) + die("unable to write file"); + close(fd); + return 0; } @@ -245,3 +343,75 @@ int write_sha1_buffer(const unsigned char *sha1, void *buf, unsigned int size) close(fd); return 0; } + +int write_sha1_from_fd(const unsigned char *sha1, int fd) +{ + char *filename = sha1_file_name(sha1); + + int local; + z_stream stream; + unsigned char real_sha1[20]; + char buf[4096]; + char discard[4096]; + int ret; + SHA_CTX c; + + local = open(filename, O_WRONLY | O_CREAT | O_EXCL, 0666); + + if (local < 0) + return error("Couldn't open %s\n", filename); + + memset(&stream, 0, sizeof(stream)); + + inflateInit(&stream); + + SHA1_Init(&c); + + do { + ssize_t size; + size = read(fd, buf, 4096); + if (size <= 0) { + close(local); + unlink(filename); + if (!size) + return error("Connection closed?"); + perror("Reading from connection"); + return -1; + } + write(local, buf, size); + stream.avail_in = size; + stream.next_in = buf; + do { + stream.next_out = discard; + stream.avail_out = sizeof(discard); + ret = inflate(&stream, Z_SYNC_FLUSH); + SHA1_Update(&c, discard, sizeof(discard) - + stream.avail_out); + } while (stream.avail_in && ret == Z_OK); + + } while (ret == Z_OK); + inflateEnd(&stream); + + close(local); + SHA1_Final(real_sha1, &c); + if (ret != Z_STREAM_END) { + unlink(filename); + return error("File %s corrupted", sha1_to_hex(sha1)); + } + if (memcmp(sha1, real_sha1, 20)) { + unlink(filename); + return error("File %s has bad hash\n", sha1_to_hex(sha1)); + } + + return 0; +} + +int has_sha1_file(const unsigned char *sha1) +{ + char *filename = sha1_file_name(sha1); + struct stat st; + + if (!stat(filename, &st)) + return 1; + return 0; +}