Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Browse files

Merge git_v1.7.10.2:vcs-svn into master

Conflicts:
	vcs-svn/fast_export.c
	vcs-svn/fast_export.h
	vcs-svn/line_buffer.c
	vcs-svn/line_buffer.h
	vcs-svn/line_buffer.txt
	vcs-svn/repo_tree.c
	vcs-svn/repo_tree.h
	vcs-svn/sliding_window.c
	vcs-svn/sliding_window.h
	vcs-svn/svndiff.c
	vcs-svn/svndiff.h
	vcs-svn/svndump.c
	vcs-svn/svndump.h
  • Loading branch information...
commit 800c0573dbb5f6eff1c6e89ffe1b1a9d07f315a6 2 parents 152aa66 + ac4a0e0
David Michael Barr authored
6 Makefile
View
@@ -6,13 +6,10 @@ HEADERS = compat/mkgmtime.h \
vcs-svn/compat-util.h \
vcs-svn/fast_export.h \
vcs-svn/line_buffer.h \
- vcs-svn/obj_pool.h \
vcs-svn/repo_tree.h \
vcs-svn/sliding_window.h \
- vcs-svn/string_pool.h \
vcs-svn/svndiff.h \
- vcs-svn/svndump.h \
- vcs-svn/trp.h
+ vcs-svn/svndump.h
OBJECTS = compat/mkgmtime.o \
compat/quote.o \
@@ -22,7 +19,6 @@ OBJECTS = compat/mkgmtime.o \
vcs-svn/line_buffer.o \
vcs-svn/repo_tree.o \
vcs-svn/sliding_window.o \
- vcs-svn/string_pool.o \
vcs-svn/svndiff.o \
vcs-svn/svndump.o
32 vcs-svn/LICENSE
View
@@ -0,0 +1,32 @@
+Copyright (C) 2010 David Barr <david.barr@cordelta.com>.
+All rights reserved.
+
+Copyright (C) 2010 Jonathan Nieder <jrnieder@gmail.com>.
+
+Copyright (C) 2005 Stefan Hegny, hydrografix Consulting GmbH,
+Frankfurt/Main, Germany
+and others, see http://svn2cc.sarovar.org
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+ notice(s), this list of conditions and the following disclaimer
+ unmodified other than the allowable addition of one or more
+ copyright notices.
+2. Redistributions in binary form must reproduce the above copyright
+ notice(s), this list of conditions and the following disclaimer in
+ the documentation and/or other materials provided with the
+ distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``AS IS'' AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
346 vcs-svn/fast_export.c
View
@@ -4,157 +4,313 @@
*/
#include "compat-util.h"
+#include "strbuf.h"
+#include "quote.h"
#include "fast_export.h"
-#include "line_buffer.h"
#include "repo_tree.h"
-#include "string_pool.h"
+#include "strbuf.h"
#include "svndiff.h"
+#include "sliding_window.h"
+#include "line_buffer.h"
#define MAX_GITSVN_LINE_LEN 4096
-#define REPORT_FILENO 3
-
-#define SHA1_HEX_LENGTH 40
static uint32_t first_commit_done;
-static struct line_buffer preimage = LINE_BUFFER_INIT;
static struct line_buffer postimage = LINE_BUFFER_INIT;
-static struct line_buffer backchannel = LINE_BUFFER_INIT;
+static struct line_buffer report_buffer = LINE_BUFFER_INIT;
+
+/* NEEDSWORK: move to fast_export_init() */
+static int init_postimage(void)
+{
+ static int postimage_initialized;
+ if (postimage_initialized)
+ return 0;
+ postimage_initialized = 1;
+ return buffer_tmpfile_init(&postimage);
+}
+
+void fast_export_init(int fd)
+{
+ first_commit_done = 0;
+ if (buffer_fdinit(&report_buffer, fd))
+ die_errno("cannot read from file descriptor %d", fd);
+}
-void fast_export_delete(uint32_t depth, uint32_t *path)
+void fast_export_deinit(void)
+{
+ if (buffer_deinit(&report_buffer))
+ die_errno("error closing fast-import feedback stream");
+}
+
+void fast_export_reset(void)
+{
+ buffer_reset(&report_buffer);
+}
+
+void fast_export_delete(const char *path)
{
putchar('D');
putchar(' ');
- pool_print_seq(depth, path, '/', stdout);
+ quote_c_style(path, NULL, stdout, 0);
putchar('\n');
}
-void fast_export_modify(uint32_t depth, uint32_t *path, uint32_t mode,
- uint32_t mark)
+static void fast_export_truncate(const char *path, uint32_t mode)
+{
+ fast_export_modify(path, mode, "inline");
+ printf("data 0\n\n");
+}
+
+void fast_export_modify(const char *path, uint32_t mode, const char *dataref)
{
/* Mode must be 100644, 100755, 120000, or 160000. */
- printf("M %06"PRIo32" :%"PRIu32" ", mode, mark);
- pool_print_seq(depth, path, '/', stdout);
+ if (!dataref) {
+ fast_export_truncate(path, mode);
+ return;
+ }
+ printf("M %06"PRIo32" %s ", mode, dataref);
+ quote_c_style(path, NULL, stdout, 0);
putchar('\n');
}
static char gitsvnline[MAX_GITSVN_LINE_LEN];
-void fast_export_commit(uint32_t revision, uint32_t author, char *log,
- uint32_t uuid, uint32_t url,
+void fast_export_begin_commit(uint32_t revision, const char *author,
+ const struct strbuf *log,
+ const char *uuid, const char *url,
unsigned long timestamp)
{
+ static const struct strbuf empty = STRBUF_INIT;
if (!log)
- log = "";
- if (~uuid && ~url) {
+ log = &empty;
+ if (*uuid && *url) {
snprintf(gitsvnline, MAX_GITSVN_LINE_LEN,
"\n\ngit-svn-id: %s@%"PRIu32" %s\n",
- pool_fetch(url), revision, pool_fetch(uuid));
+ url, revision, uuid);
} else {
*gitsvnline = '\0';
}
printf("commit refs/heads/master\n");
+ printf("mark :%"PRIu32"\n", revision);
printf("committer %s <%s@%s> %ld +0000\n",
- ~author ? pool_fetch(author) : "nobody",
- ~author ? pool_fetch(author) : "nobody",
- ~uuid ? pool_fetch(uuid) : "local", timestamp);
- printf("data %"PRIu32"\n%s%s\n",
- (uint32_t) (strlen(log) + strlen(gitsvnline)),
- log, gitsvnline);
+ *author ? author : "nobody",
+ *author ? author : "nobody",
+ *uuid ? uuid : "local", timestamp);
+ printf("data %"PRIuMAX"\n",
+ (uintmax_t) (log->len + strlen(gitsvnline)));
+ fwrite(log->buf, log->len, 1, stdout);
+ printf("%s\n", gitsvnline);
if (!first_commit_done) {
if (revision > 1)
- printf("from refs/heads/master^0\n");
+ printf("from :%"PRIu32"\n", revision - 1);
first_commit_done = 1;
}
- repo_diff(revision - 1, revision);
- fputc('\n', stdout);
+}
+void fast_export_end_commit(uint32_t revision)
+{
printf("progress Imported commit %"PRIu32".\n\n", revision);
}
-static int fast_export_save_blob(FILE *out)
+static void ls_from_rev(uint32_t rev, const char *path)
{
- size_t len;
- char *header;
- char *end;
- char *tail;
+ /* ls :5 path/to/old/file */
+ printf("ls :%"PRIu32" ", rev);
+ quote_c_style(path, NULL, stdout, 0);
+ putchar('\n');
+ fflush(stdout);
+}
- if (!backchannel.infile)
- backchannel.infile = fdopen(REPORT_FILENO, "r");
- if (!backchannel.infile)
- return error("Could not open backchannel fd: %d", REPORT_FILENO);
- header = buffer_read_line(&backchannel);
- if (header == NULL)
- return 1;
- end = strchr(header, '\0');
- if (end - header > 7 && !strcmp(end - 7, "missing"))
+static void ls_from_active_commit(const char *path)
+{
+ /* ls "path/to/file" */
+ printf("ls \"");
+ quote_c_style(path, NULL, stdout, 1);
+ printf("\"\n");
+ fflush(stdout);
+}
+
+static const char *get_response_line(void)
+{
+ const char *line = buffer_read_line(&report_buffer);
+ if (line)
+ return line;
+ if (buffer_ferror(&report_buffer))
+ die_errno("error reading from fast-import");
+ die("unexpected end of fast-import feedback");
+}
+
+static void die_short_read(struct line_buffer *input)
+{
+ if (buffer_ferror(input))
+ die_errno("error reading dump file");
+ die("invalid dump: unexpected end of file");
+}
+
+static int ends_with(const char *s, size_t len, const char *suffix)
+{
+ const size_t suffixlen = strlen(suffix);
+ if (len < suffixlen)
+ return 0;
+ return !memcmp(s + len - suffixlen, suffix, suffixlen);
+}
+
+static int parse_cat_response_line(const char *header, off_t *len)
+{
+ size_t headerlen = strlen(header);
+ uintmax_t n;
+ const char *type;
+ const char *end;
+
+ if (ends_with(header, headerlen, " missing"))
return error("cat-blob reports missing blob: %s", header);
- if (end - header < SHA1_HEX_LENGTH)
- return error("cat-blob header too short for SHA1: %s", header);
- if (strncmp(header + SHA1_HEX_LENGTH, " blob ", 6))
+ type = memmem(header, headerlen, " blob ", strlen(" blob "));
+ if (!type)
return error("cat-blob header has wrong object type: %s", header);
- len = strtoumax(header + SHA1_HEX_LENGTH + 6, &end, 10);
- if (end == header + SHA1_HEX_LENGTH + 6)
- return error("cat-blob header did not contain length: %s", header);
+ n = strtoumax(type + strlen(" blob "), (char **) &end, 10);
+ if (end == type + strlen(" blob "))
+ return error("cat-blob header does not contain length: %s", header);
+ if (memchr(type + strlen(" blob "), '-', end - type - strlen(" blob ")))
+ return error("cat-blob header contains negative length: %s", header);
+ if (n == UINTMAX_MAX || n > maximum_signed_value_of_type(off_t))
+ return error("blob too large for current definition of off_t");
+ *len = n;
if (*end)
- return error("cat-blob header contained garbage after length: %s", header);
- buffer_copy_bytes(&backchannel, out, len);
- tail = buffer_read_line(&backchannel);
- if (!tail)
- return 1;
- if (*tail)
- return error("cat-blob trailing line contained garbage: %s", tail);
+ return error("cat-blob header contains garbage after length: %s", header);
return 0;
}
-void fast_export_blob(uint32_t mode, uint32_t mark, uint32_t len,
- uint32_t delta, uint32_t srcMark, uint32_t srcMode,
- struct line_buffer *input)
-{
- long preimage_len = 0;
-
- if (delta) {
- if (!preimage.infile)
- preimage.infile = tmpfile();
- if (!preimage.infile)
- die("Unable to open temp file for blob retrieval");
- if (srcMark) {
- printf("cat-blob :%"PRIu32"\n", srcMark);
- fflush(stdout);
- if (srcMode == REPO_MODE_LNK)
- fwrite("link ", 1, 5, preimage.infile);
- if (fast_export_save_blob(preimage.infile))
- die("Failed to retrieve blob for delta application");
- }
- preimage_len = ftell(preimage.infile);
- fseek(preimage.infile, 0, SEEK_SET);
- if (!postimage.infile)
- postimage.infile = tmpfile();
- if (!postimage.infile)
- die("Unable to open temp file for blob application");
- svndiff0_apply(input, len, &preimage, postimage.infile);
- len = ftell(postimage.infile);
- fseek(postimage.infile, 0, SEEK_SET);
+static void check_preimage_overflow(off_t a, off_t b)
+{
+ if (signed_add_overflows(a, b))
+ die("blob too large for current definition of off_t");
+}
+
+static long apply_delta(off_t len, struct line_buffer *input,
+ const char *old_data, uint32_t old_mode)
+{
+ long ret;
+ struct sliding_view preimage = SLIDING_VIEW_INIT(&report_buffer, 0);
+ FILE *out;
+
+ if (init_postimage() || !(out = buffer_tmpfile_rewind(&postimage)))
+ die("cannot open temporary file for blob retrieval");
+ if (old_data) {
+ const char *response;
+ printf("cat-blob %s\n", old_data);
+ fflush(stdout);
+ response = get_response_line();
+ if (parse_cat_response_line(response, &preimage.max_off))
+ die("invalid cat-blob response: %s", response);
+ check_preimage_overflow(preimage.max_off, 1);
}
+ if (old_mode == REPO_MODE_LNK) {
+ strbuf_addstr(&preimage.buf, "link ");
+ check_preimage_overflow(preimage.max_off, strlen("link "));
+ preimage.max_off += strlen("link ");
+ check_preimage_overflow(preimage.max_off, 1);
+ }
+ if (svndiff0_apply(input, len, &preimage, out))
+ die("cannot apply delta");
+ if (old_data) {
+ /* Read the remainder of preimage and trailing newline. */
+ assert(!signed_add_overflows(preimage.max_off, 1));
+ preimage.max_off++; /* room for newline */
+ if (move_window(&preimage, preimage.max_off - 1, 1))
+ die("cannot seek to end of input");
+ if (preimage.buf.buf[0] != '\n')
+ die("missing newline after cat-blob response");
+ }
+ ret = buffer_tmpfile_prepare_to_read(&postimage);
+ if (ret < 0)
+ die("cannot read temporary file for blob retrieval");
+ strbuf_release(&preimage.buf);
+ return ret;
+}
+void fast_export_data(uint32_t mode, off_t len, struct line_buffer *input)
+{
+ assert(len >= 0);
if (mode == REPO_MODE_LNK) {
/* svn symlink blobs start with "link " */
- if (delta)
- buffer_skip_bytes(&postimage, 5);
- else
- buffer_skip_bytes(input, 5);
+ if (len < 5)
+ die("invalid dump: symlink too short for \"link\" prefix");
len -= 5;
+ if (buffer_skip_bytes(input, 5) != 5)
+ die_short_read(input);
}
- printf("blob\nmark :%"PRIu32"\ndata %"PRIu32"\n", mark, len);
- if (!delta)
- buffer_copy_bytes(input, stdout, len);
- else
- buffer_copy_bytes(&postimage, stdout, len);
+ printf("data %"PRIuMAX"\n", (uintmax_t) len);
+ if (buffer_copy_bytes(input, len) != len)
+ die_short_read(input);
fputc('\n', stdout);
+}
+
+static int parse_ls_response(const char *response, uint32_t *mode,
+ struct strbuf *dataref)
+{
+ const char *tab;
+ const char *response_end;
+
+ assert(response);
+ response_end = response + strlen(response);
- if (preimage.infile) {
- fseek(preimage.infile, 0, SEEK_SET);
+ if (*response == 'm') { /* Missing. */
+ errno = ENOENT;
+ return -1;
}
- if (postimage.infile) {
- fseek(postimage.infile, 0, SEEK_SET);
+ /* Mode. */
+ if (response_end - response < strlen("100644") ||
+ response[strlen("100644")] != ' ')
+ die("invalid ls response: missing mode: %s", response);
+ *mode = 0;
+ for (; *response != ' '; response++) {
+ char ch = *response;
+ if (ch < '0' || ch > '7')
+ die("invalid ls response: mode is not octal: %s", response);
+ *mode *= 8;
+ *mode += ch - '0';
}
+
+ /* ' blob ' or ' tree ' */
+ if (response_end - response < strlen(" blob ") ||
+ (response[1] != 'b' && response[1] != 't'))
+ die("unexpected ls response: not a tree or blob: %s", response);
+ response += strlen(" blob ");
+
+ /* Dataref. */
+ tab = memchr(response, '\t', response_end - response);
+ if (!tab)
+ die("invalid ls response: missing tab: %s", response);
+ strbuf_add(dataref, response, tab - response);
+ return 0;
+}
+
+int fast_export_ls_rev(uint32_t rev, const char *path,
+ uint32_t *mode, struct strbuf *dataref)
+{
+ ls_from_rev(rev, path);
+ return parse_ls_response(get_response_line(), mode, dataref);
+}
+
+int fast_export_ls(const char *path, uint32_t *mode, struct strbuf *dataref)
+{
+ ls_from_active_commit(path);
+ return parse_ls_response(get_response_line(), mode, dataref);
+}
+
+void fast_export_blob_delta(uint32_t mode,
+ uint32_t old_mode, const char *old_data,
+ off_t len, struct line_buffer *input)
+{
+ long postimage_len;
+
+ assert(len >= 0);
+ postimage_len = apply_delta(len, input, old_data, old_mode);
+ if (mode == REPO_MODE_LNK) {
+ buffer_skip_bytes(&postimage, strlen("link "));
+ postimage_len -= strlen("link ");
+ }
+ printf("data %ld\n", postimage_len);
+ buffer_copy_bytes(&postimage, postimage_len);
+ fputc('\n', stdout);
}
33 vcs-svn/fast_export.h
View
@@ -1,15 +1,28 @@
#ifndef FAST_EXPORT_H_
#define FAST_EXPORT_H_
-#include "line_buffer.h"
-
-void fast_export_delete(uint32_t depth, uint32_t *path);
-void fast_export_modify(uint32_t depth, uint32_t *path, uint32_t mode,
- uint32_t mark);
-void fast_export_commit(uint32_t revision, uint32_t author, char *log,
- uint32_t uuid, uint32_t url, unsigned long timestamp);
-void fast_export_blob(uint32_t mode, uint32_t mark, uint32_t len,
- uint32_t delta, uint32_t srcMark, uint32_t srcMode,
- struct line_buffer *input);
+struct strbuf;
+struct line_buffer;
+
+void fast_export_init(int fd);
+void fast_export_deinit(void);
+void fast_export_reset(void);
+
+void fast_export_delete(const char *path);
+void fast_export_modify(const char *path, uint32_t mode, const char *dataref);
+void fast_export_begin_commit(uint32_t revision, const char *author,
+ const struct strbuf *log, const char *uuid,
+ const char *url, unsigned long timestamp);
+void fast_export_end_commit(uint32_t revision);
+void fast_export_data(uint32_t mode, off_t len, struct line_buffer *input);
+void fast_export_blob_delta(uint32_t mode,
+ uint32_t old_mode, const char *old_data,
+ off_t len, struct line_buffer *input);
+
+/* If there is no such file at that rev, returns -1, errno == ENOENT. */
+int fast_export_ls_rev(uint32_t rev, const char *path,
+ uint32_t *mode_out, struct strbuf *dataref_out);
+int fast_export_ls(const char *path,
+ uint32_t *mode_out, struct strbuf *dataref_out);
#endif
78 vcs-svn/line_buffer.c
View
@@ -17,6 +17,22 @@ int buffer_init(struct line_buffer *buf, const char *filename)
return 0;
}
+int buffer_fdinit(struct line_buffer *buf, int fd)
+{
+ buf->infile = fdopen(fd, "r");
+ if (!buf->infile)
+ return -1;
+ return 0;
+}
+
+int buffer_tmpfile_init(struct line_buffer *buf)
+{
+ buf->infile = tmpfile();
+ if (!buf->infile)
+ return -1;
+ return 0;
+}
+
int buffer_deinit(struct line_buffer *buf)
{
int err;
@@ -27,19 +43,25 @@ int buffer_deinit(struct line_buffer *buf)
return err;
}
-int buffer_ferror(struct line_buffer *buf)
+FILE *buffer_tmpfile_rewind(struct line_buffer *buf)
{
- return ferror(buf->infile);
+ rewind(buf->infile);
+ return buf->infile;
}
-int buffer_at_eof(struct line_buffer *buf)
+long buffer_tmpfile_prepare_to_read(struct line_buffer *buf)
{
- int ch;
- if ((ch = fgetc(buf->infile)) == EOF)
- return 1;
- if (ungetc(ch, buf->infile) == EOF)
- return error("cannot unget %c: %s\n", ch, strerror(errno));
- return 0;
+ long pos = ftell(buf->infile);
+ if (pos < 0)
+ return error("ftell error: %s", strerror(errno));
+ if (fseek(buf->infile, 0, SEEK_SET))
+ return error("seek error: %s", strerror(errno));
+ return pos;
+}
+
+int buffer_ferror(struct line_buffer *buf)
+{
+ return ferror(buf->infile);
}
int buffer_read_char(struct line_buffer *buf)
@@ -69,42 +91,35 @@ char *buffer_read_line(struct line_buffer *buf)
return buf->line_buffer;
}
-char *buffer_read_string(struct line_buffer *buf, uint32_t len)
-{
- strbuf_reset(&buf->blob_buffer);
- strbuf_fread(&buf->blob_buffer, len, buf->infile);
- return ferror(buf->infile) ? NULL : buf->blob_buffer.buf;
-}
-
-void buffer_read_binary(struct strbuf *sb, uint32_t size,
- struct line_buffer *buf)
+size_t buffer_read_binary(struct line_buffer *buf,
+ struct strbuf *sb, size_t size)
{
- strbuf_fread(sb, size, buf->infile);
+ return strbuf_fread(sb, size, buf->infile);
}
-void buffer_copy_bytes(struct line_buffer *buf, FILE *outfile, off_t len)
+off_t buffer_copy_bytes(struct line_buffer *buf, off_t nbytes)
{
char byte_buffer[COPY_BUFFER_LEN];
- uint32_t in;
- while (len > 0 && !feof(buf->infile) && !ferror(buf->infile)) {
- in = len < COPY_BUFFER_LEN ? len : COPY_BUFFER_LEN;
+ off_t done = 0;
+ while (done < nbytes && !feof(buf->infile) && !ferror(buf->infile)) {
+ off_t len = nbytes - done;
+ size_t in = len < COPY_BUFFER_LEN ? len : COPY_BUFFER_LEN;
in = fread(byte_buffer, 1, in, buf->infile);
- len -= in;
- fwrite(byte_buffer, 1, in, outfile);
- if (ferror(outfile)) {
- buffer_skip_bytes(buf, len);
- return;
- }
+ done += in;
+ fwrite(byte_buffer, 1, in, stdout);
+ if (ferror(stdout))
+ return done + buffer_skip_bytes(buf, nbytes - done);
}
+ return done;
}
off_t buffer_skip_bytes(struct line_buffer *buf, off_t nbytes)
{
+ char byte_buffer[COPY_BUFFER_LEN];
off_t done = 0;
while (done < nbytes && !feof(buf->infile) && !ferror(buf->infile)) {
- char byte_buffer[COPY_BUFFER_LEN];
off_t len = nbytes - done;
- uint32_t in = len < COPY_BUFFER_LEN ? len : COPY_BUFFER_LEN;
+ size_t in = len < COPY_BUFFER_LEN ? len : COPY_BUFFER_LEN;
done += fread(byte_buffer, 1, in, buf->infile);
}
return done;
@@ -112,5 +127,4 @@ off_t buffer_skip_bytes(struct line_buffer *buf, off_t nbytes)
void buffer_reset(struct line_buffer *buf)
{
- strbuf_release(&buf->blob_buffer);
}
18 vcs-svn/line_buffer.h
View
@@ -7,21 +7,25 @@
struct line_buffer {
char line_buffer[LINE_BUFFER_LEN];
- struct strbuf blob_buffer;
FILE *infile;
};
-#define LINE_BUFFER_INIT {"", STRBUF_INIT, NULL}
+#define LINE_BUFFER_INIT { "", NULL }
int buffer_init(struct line_buffer *buf, const char *filename);
+int buffer_fdinit(struct line_buffer *buf, int fd);
int buffer_deinit(struct line_buffer *buf);
+void buffer_reset(struct line_buffer *buf);
+
+int buffer_tmpfile_init(struct line_buffer *buf);
+FILE *buffer_tmpfile_rewind(struct line_buffer *buf); /* prepare to write. */
+long buffer_tmpfile_prepare_to_read(struct line_buffer *buf);
+
int buffer_ferror(struct line_buffer *buf);
-int buffer_at_eof(struct line_buffer *buf);
char *buffer_read_line(struct line_buffer *buf);
-char *buffer_read_string(struct line_buffer *buf, uint32_t len);
int buffer_read_char(struct line_buffer *buf);
-void buffer_read_binary(struct strbuf *sb, uint32_t len, struct line_buffer *f);
-void buffer_copy_bytes(struct line_buffer *buf, FILE *outfile, off_t len);
+size_t buffer_read_binary(struct line_buffer *buf, struct strbuf *sb, size_t len);
+/* Returns number of bytes read (not necessarily written). */
+off_t buffer_copy_bytes(struct line_buffer *buf, off_t len);
off_t buffer_skip_bytes(struct line_buffer *buf, off_t len);
-void buffer_reset(struct line_buffer *buf);
#endif
41 vcs-svn/line_buffer.txt
View
@@ -16,21 +16,44 @@ The calling program:
- initializes a `struct line_buffer` to LINE_BUFFER_INIT
- specifies a file to read with `buffer_init`
- - processes input with `buffer_read_line`, `buffer_read_string`,
- `buffer_skip_bytes`, and `buffer_copy_bytes`
+ - processes input with `buffer_read_line`, `buffer_skip_bytes`,
+ and `buffer_copy_bytes`
- closes the file with `buffer_deinit`, perhaps to start over and
read another file.
When finished, the caller can use `buffer_reset` to deallocate
resources.
+Using temporary files
+---------------------
+
+Temporary files provide a place to store data that should not outlive
+the calling program. A program
+
+ - initializes a `struct line_buffer` to LINE_BUFFER_INIT
+ - requests a temporary file with `buffer_tmpfile_init`
+ - acquires an output handle by calling `buffer_tmpfile_rewind`
+ - uses standard I/O functions like `fprintf` and `fwrite` to fill
+ the temporary file
+ - declares writing is over with `buffer_tmpfile_prepare_to_read`
+ - can re-read what was written with `buffer_read_line`,
+ `buffer_copy_bytes`, and so on
+ - can reuse the temporary file by calling `buffer_tmpfile_rewind`
+ again
+ - removes the temporary file with `buffer_deinit`, perhaps to
+ reuse the line_buffer for some other file.
+
+When finished, the calling program can use `buffer_reset` to deallocate
+resources.
+
Functions
---------
-`buffer_init`::
- Open the named file for input. If filename is NULL,
- start reading from stdin. On failure, returns -1 (with
- errno indicating the nature of the failure).
+`buffer_init`, `buffer_fdinit`::
+ Open the named file or file descriptor for input.
+ buffer_init(buf, NULL) prepares to read from stdin.
+ On failure, returns -1 (with errno indicating the nature
+ of the failure).
`buffer_deinit`::
Stop reading from the current file (closing it unless
@@ -41,12 +64,6 @@ Functions
Read a line and strip off the trailing newline.
On failure or end of file, returns NULL.
-`buffer_read_string`::
- Read `len` characters of input or up to the end of the
- file, whichever comes first. Returns NULL on error.
- Returns whatever characters were read (possibly "")
- for end of file.
-
`buffer_copy_bytes`::
Read `len` bytes of input and dump them to the standard output
stream. Returns early for error or end of file.
59 vcs-svn/obj_pool.h
View
@@ -1,59 +0,0 @@
-/*
- * Licensed under a two-clause BSD-style license.
- * See LICENSE for details.
- */
-
-#ifndef OBJ_POOL_H_
-#define OBJ_POOL_H_
-
-#define MAYBE_UNUSED __attribute__((__unused__))
-
-#define obj_pool_gen(pre, obj_t, initial_capacity) \
-static struct { \
- uint32_t committed; \
- uint32_t size; \
- uint32_t capacity; \
- obj_t *base; \
-} pre##_pool = {0, 0, 0, NULL}; \
-static MAYBE_UNUSED uint32_t pre##_alloc(uint32_t count) \
-{ \
- uint32_t offset; \
- if (pre##_pool.size + count > pre##_pool.capacity) { \
- while (pre##_pool.size + count > pre##_pool.capacity) \
- if (pre##_pool.capacity) \
- pre##_pool.capacity *= 2; \
- else \
- pre##_pool.capacity = initial_capacity; \
- pre##_pool.base = realloc(pre##_pool.base, \
- pre##_pool.capacity * sizeof(obj_t)); \
- } \
- offset = pre##_pool.size; \
- pre##_pool.size += count; \
- return offset; \
-} \
-static MAYBE_UNUSED void pre##_free(uint32_t count) \
-{ \
- pre##_pool.size -= count; \
-} \
-static MAYBE_UNUSED uint32_t pre##_offset(obj_t *obj) \
-{ \
- return obj == NULL ? ~0 : obj - pre##_pool.base; \
-} \
-static MAYBE_UNUSED obj_t *pre##_pointer(uint32_t offset) \
-{ \
- return offset >= pre##_pool.size ? NULL : &pre##_pool.base[offset]; \
-} \
-static MAYBE_UNUSED void pre##_commit(void) \
-{ \
- pre##_pool.committed = pre##_pool.size; \
-} \
-static MAYBE_UNUSED void pre##_reset(void) \
-{ \
- free(pre##_pool.base); \
- pre##_pool.base = NULL; \
- pre##_pool.size = 0; \
- pre##_pool.capacity = 0; \
- pre##_pool.committed = 0; \
-}
-
-#endif
357 vcs-svn/repo_tree.c
View
@@ -4,350 +4,45 @@
*/
#include "compat-util.h"
-#include "string_pool.h"
+#include "strbuf.h"
#include "repo_tree.h"
-#include "obj_pool.h"
#include "fast_export.h"
-#include "trp.h"
-
-struct repo_dirent {
- uint32_t name_offset;
- struct trp_node children;
- uint32_t mode;
- uint32_t content_offset;
-};
-
-struct repo_dir {
- struct trp_root entries;
-};
-
-struct repo_commit {
- uint32_t root_dir_offset;
-};
-
-/* Memory pools for commit, dir and dirent */
-obj_pool_gen(commit, struct repo_commit, 4096)
-obj_pool_gen(dir, struct repo_dir, 4096)
-obj_pool_gen(dent, struct repo_dirent, 4096)
-
-static uint32_t active_commit;
-static uint32_t mark;
-
-static int repo_dirent_name_cmp(const void *a, const void *b);
-
-/* Treap for directory entries */
-trp_gen(static, dent_, struct repo_dirent, children, dent, repo_dirent_name_cmp);
-
-uint32_t next_blob_mark(void)
+const char *repo_read_path(const char *path, uint32_t *mode_out)
{
- return mark++;
-}
+ int err;
+ static struct strbuf buf = STRBUF_INIT;
-static struct repo_dir *repo_commit_root_dir(struct repo_commit *commit)
-{
- return dir_pointer(commit->root_dir_offset);
-}
-
-static struct repo_dirent *repo_first_dirent(struct repo_dir *dir)
-{
- return dent_first(&dir->entries);
-}
-
-static int repo_dirent_name_cmp(const void *a, const void *b)
-{
- const struct repo_dirent *dent1 = a, *dent2 = b;
- uint32_t a_offset = dent1->name_offset;
- uint32_t b_offset = dent2->name_offset;
- return (a_offset > b_offset) - (a_offset < b_offset);
-}
-
-static int repo_dirent_is_dir(struct repo_dirent *dent)
-{
- return dent != NULL && dent->mode == REPO_MODE_DIR;
-}
-
-static struct repo_dir *repo_dir_from_dirent(struct repo_dirent *dent)
-{
- if (!repo_dirent_is_dir(dent))
+ strbuf_reset(&buf);
+ err = fast_export_ls(path, mode_out, &buf);
+ if (err) {
+ if (errno != ENOENT)
+ die_errno("BUG: unexpected fast_export_ls error");
+ /* Treat missing paths as directories. */
+ *mode_out = REPO_MODE_DIR;
return NULL;
- return dir_pointer(dent->content_offset);
-}
-
-static struct repo_dir *repo_clone_dir(struct repo_dir *orig_dir)
-{
- uint32_t orig_o, new_o;
- orig_o = dir_offset(orig_dir);
- if (orig_o >= dir_pool.committed)
- return orig_dir;
- new_o = dir_alloc(1);
- orig_dir = dir_pointer(orig_o);
- *dir_pointer(new_o) = *orig_dir;
- return dir_pointer(new_o);
-}
-
-static struct repo_dirent *repo_read_dirent(uint32_t revision, uint32_t *path)
-{
- uint32_t name = 0;
- struct repo_dirent *key = dent_pointer(dent_alloc(1));
- struct repo_dir *dir = NULL;
- struct repo_dirent *dent = NULL;
- dir = repo_commit_root_dir(commit_pointer(revision));
- while (~(name = *path++)) {
- key->name_offset = name;
- dent = dent_search(&dir->entries, key);
- if (dent == NULL || !repo_dirent_is_dir(dent))
- break;
- dir = repo_dir_from_dirent(dent);
}
- dent_free(1);
- return dent;
+ return buf.buf;
}
-static void repo_write_dirent(uint32_t *path, uint32_t mode,
- uint32_t content_offset, uint32_t del)
+void repo_copy(uint32_t revision, const char *src, const char *dst)
{
- uint32_t name, revision, dir_o = ~0, parent_dir_o = ~0;
- struct repo_dir *dir;
- struct repo_dirent *key;
- struct repo_dirent *dent = NULL;
- revision = active_commit;
- dir = repo_commit_root_dir(commit_pointer(revision));
- dir = repo_clone_dir(dir);
- commit_pointer(revision)->root_dir_offset = dir_offset(dir);
- while (~(name = *path++)) {
- parent_dir_o = dir_offset(dir);
-
- key = dent_pointer(dent_alloc(1));
- key->name_offset = name;
-
- dent = dent_search(&dir->entries, key);
- if (dent == NULL)
- dent = key;
- else
- dent_free(1);
-
- if (dent == key) {
- dent->mode = REPO_MODE_DIR;
- dent->content_offset = 0;
- dent_insert(&dir->entries, dent);
- }
-
- if (dent_offset(dent) < dent_pool.committed) {
- dir_o = repo_dirent_is_dir(dent) ?
- dent->content_offset : ~0u;
- dent_remove(&dir->entries, dent);
- dent = dent_pointer(dent_alloc(1));
- dent->name_offset = name;
- dent->mode = REPO_MODE_DIR;
- dent->content_offset = dir_o;
- dent_insert(&dir->entries, dent);
- }
-
- dir = repo_dir_from_dirent(dent);
- dir = repo_clone_dir(dir);
- dent->content_offset = dir_offset(dir);
- }
- if (dent == NULL)
+ int err;
+ uint32_t mode;
+ static struct strbuf data = STRBUF_INIT;
+
+ strbuf_reset(&data);
+ err = fast_export_ls_rev(revision, src, &mode, &data);
+ if (err) {
+ if (errno != ENOENT)
+ die_errno("BUG: unexpected fast_export_ls_rev error");
+ fast_export_delete(dst);
return;
- dent->mode = mode;
- dent->content_offset = content_offset;
- if (del && ~parent_dir_o)
- dent_remove(&dir_pointer(parent_dir_o)->entries, dent);
-}
-
-uint32_t repo_read_mark(uint32_t revision, uint32_t *path)
-{
- uint32_t mode = 0, content_offset = 0;
- struct repo_dirent *src_dent;
- src_dent = repo_read_dirent(revision, path);
- if (src_dent != NULL) {
- mode = src_dent->mode;
- content_offset = src_dent->content_offset;
- }
- return mode && mode != REPO_MODE_DIR ? content_offset : 0;
-}
-
-uint32_t repo_read_mode(uint32_t revision, uint32_t *path)
-{
- uint32_t mode = 0;
- struct repo_dirent *src_dent;
- src_dent = repo_read_dirent(revision, path);
- if (src_dent != NULL) {
- mode = src_dent->mode;
- }
- return mode;
-}
-
-uint32_t repo_copy(uint32_t revision, uint32_t *src, uint32_t *dst)
-{
- uint32_t mode = 0, content_offset = 0;
- struct repo_dirent *src_dent;
- src_dent = repo_read_dirent(revision, src);
- if (src_dent != NULL) {
- mode = src_dent->mode;
- content_offset = src_dent->content_offset;
- repo_write_dirent(dst, mode, content_offset, 0);
- }
- return mode;
-}
-
-void repo_add(uint32_t *path, uint32_t mode, uint32_t blob_mark)
-{
- repo_write_dirent(path, mode, blob_mark, 0);
-}
-
-uint32_t repo_replace(uint32_t *path, uint32_t blob_mark)
-{
- uint32_t mode = 0;
- struct repo_dirent *src_dent;
- src_dent = repo_read_dirent(active_commit, path);
- if (src_dent != NULL) {
- mode = src_dent->mode;
- repo_write_dirent(path, mode, blob_mark, 0);
- }
- return mode;
-}
-
-void repo_modify(uint32_t *path, uint32_t mode, uint32_t blob_mark)
-{
- struct repo_dirent *src_dent;
- src_dent = repo_read_dirent(active_commit, path);
- if (src_dent != NULL && blob_mark == 0)
- blob_mark = src_dent->content_offset;
- repo_write_dirent(path, mode, blob_mark, 0);
-}
-
-void repo_delete(uint32_t *path)
-{
- repo_write_dirent(path, 0, 0, 1);
-}
-
-static void repo_git_add_r(uint32_t depth, uint32_t *path, struct repo_dir *dir);
-
-static void repo_git_add(uint32_t depth, uint32_t *path, struct repo_dirent *dent)
-{
- if (repo_dirent_is_dir(dent))
- repo_git_add_r(depth, path, repo_dir_from_dirent(dent));
- else
- fast_export_modify(depth, path,
- dent->mode, dent->content_offset);
-}
-
-static void repo_git_add_r(uint32_t depth, uint32_t *path, struct repo_dir *dir)
-{
- struct repo_dirent *de = repo_first_dirent(dir);
- while (de) {
- path[depth] = de->name_offset;
- repo_git_add(depth + 1, path, de);
- de = dent_next(&dir->entries, de);
- }
-}
-
-static void repo_diff_r(uint32_t depth, uint32_t *path, struct repo_dir *dir1,
- struct repo_dir *dir2)
-{
- struct repo_dirent *de1, *de2;
- de1 = repo_first_dirent(dir1);
- de2 = repo_first_dirent(dir2);
-
- while (de1 && de2) {
- if (de1->name_offset < de2->name_offset) {
- path[depth] = de1->name_offset;
- fast_export_delete(depth + 1, path);
- de1 = dent_next(&dir1->entries, de1);
- continue;
- }
- if (de1->name_offset > de2->name_offset) {
- path[depth] = de2->name_offset;
- repo_git_add(depth + 1, path, de2);
- de2 = dent_next(&dir2->entries, de2);
- continue;
- }
- path[depth] = de1->name_offset;
-
- if (de1->mode == de2->mode &&
- de1->content_offset == de2->content_offset) {
- ; /* No change. */
- } else if (repo_dirent_is_dir(de1) && repo_dirent_is_dir(de2)) {
- repo_diff_r(depth + 1, path,
- repo_dir_from_dirent(de1),
- repo_dir_from_dirent(de2));
- } else if (!repo_dirent_is_dir(de1) && !repo_dirent_is_dir(de2)) {
- repo_git_add(depth + 1, path, de2);
- } else {
- fast_export_delete(depth + 1, path);
- repo_git_add(depth + 1, path, de2);
- }
- de1 = dent_next(&dir1->entries, de1);
- de2 = dent_next(&dir2->entries, de2);
- }
- while (de1) {
- path[depth] = de1->name_offset;
- fast_export_delete(depth + 1, path);
- de1 = dent_next(&dir1->entries, de1);
- }
- while (de2) {
- path[depth] = de2->name_offset;
- repo_git_add(depth + 1, path, de2);
- de2 = dent_next(&dir2->entries, de2);
- }
-}
-
-static uint32_t path_stack[REPO_MAX_PATH_DEPTH];
-
-void repo_diff(uint32_t r1, uint32_t r2)
-{
- repo_diff_r(0,
- path_stack,
- repo_commit_root_dir(commit_pointer(r1)),
- repo_commit_root_dir(commit_pointer(r2)));
-}
-
-void repo_commit(uint32_t revision, uint32_t author, char *log, uint32_t uuid,
- uint32_t url, unsigned long timestamp)
-{
- fast_export_commit(revision, author, log, uuid, url, timestamp);
- dent_commit();
- dir_commit();
- commit_commit();
- active_commit = commit_alloc(1);
- commit_pointer(active_commit)->root_dir_offset =
- commit_pointer(active_commit - 1)->root_dir_offset;
-}
-
-static void mark_init(void)
-{
- uint32_t i;
- mark = 0;
- for (i = 0; i < dent_pool.size; i++)
- if (!repo_dirent_is_dir(dent_pointer(i)) &&
- dent_pointer(i)->content_offset > mark)
- mark = dent_pointer(i)->content_offset;
- mark++;
-}
-
-void repo_init() {
- pool_init();
- mark_init();
- if (commit_pool.size == 0) {
- /* Create empty tree for commit 0. */
- commit_alloc(1);
- commit_pointer(0)->root_dir_offset = dir_alloc(1);
- dir_pointer(0)->entries.trp_root = ~0;
- dir_commit();
- commit_commit();
}
- /* Preallocate next commit, ready for changes. */
- active_commit = commit_alloc(1);
- commit_pointer(active_commit)->root_dir_offset =
- commit_pointer(active_commit - 1)->root_dir_offset;
+ fast_export_modify(dst, mode, data.buf);
}
-void repo_reset(void)
+void repo_delete(const char *path)
{
- pool_reset();
- commit_reset();
- dir_reset();
- dent_reset();
+ fast_export_delete(path);
}
21 vcs-svn/repo_tree.h
View
@@ -1,24 +1,21 @@
#ifndef REPO_TREE_H_
#define REPO_TREE_H_
+struct strbuf;
+
#define REPO_MODE_DIR 0040000
#define REPO_MODE_BLB 0100644
#define REPO_MODE_EXE 0100755
#define REPO_MODE_LNK 0120000
-#define REPO_MAX_PATH_LEN 4096
-#define REPO_MAX_PATH_DEPTH 1000
-
uint32_t next_blob_mark(void);
-uint32_t repo_read_mark(uint32_t revision, uint32_t *path);
-uint32_t repo_read_mode(uint32_t revision, uint32_t *path);
-uint32_t repo_copy(uint32_t revision, uint32_t *src, uint32_t *dst);
-void repo_add(uint32_t *path, uint32_t mode, uint32_t blob_mark);
-uint32_t repo_replace(uint32_t *path, uint32_t blob_mark);
-void repo_modify(uint32_t *path, uint32_t mode, uint32_t blob_mark);
-void repo_delete(uint32_t *path);
-void repo_commit(uint32_t revision, uint32_t author, char *log, uint32_t uuid,
- uint32_t url, long unsigned timestamp);
+void repo_copy(uint32_t revision, const char *src, const char *dst);
+void repo_add(const char *path, uint32_t mode, uint32_t blob_mark);
+const char *repo_read_path(const char *path, uint32_t *mode_out);
+void repo_delete(const char *path);
+void repo_commit(uint32_t revision, const char *author,
+ const struct strbuf *log, const char *uuid, const char *url,
+ long unsigned timestamp);
void repo_diff(uint32_t r1, uint32_t r2);
void repo_init(void);
void repo_reset(void);
88 vcs-svn/sliding_window.c
View
@@ -8,60 +8,72 @@
#include "line_buffer.h"
#include "strbuf.h"
-static void strbuf_remove_from_left(struct strbuf *sb, size_t nbytes)
+static int input_error(struct line_buffer *file)
{
- assert(nbytes <= sb->len);
- memmove(sb->buf, sb->buf + nbytes, sb->len - nbytes);
- strbuf_setlen(sb, sb->len - nbytes);
+ if (!buffer_ferror(file))
+ return error("delta preimage ends early");
+ return error("cannot read delta preimage: %s", strerror(errno));
}
-static int check_overflow(off_t a, size_t b)
+static int skip_or_whine(struct line_buffer *file, off_t gap)
{
- if ((off_t) b < 0)
- return error("Unrepresentable length: "
- "%"PRIu64" > OFF_MAX", (uint64_t) b);
- if (signed_add_overflows(a, (off_t) b))
- return error("Unrepresentable offset: "
- "%"PRIu64" + %"PRIu64" > OFF_MAX",
- (uint64_t) a, (uint64_t) b);
+ if (buffer_skip_bytes(file, gap) != gap)
+ return input_error(file);
return 0;
}
-int move_window(struct view *view, off_t off, size_t len)
+static int read_to_fill_or_whine(struct line_buffer *file,
+ struct strbuf *buf, size_t width)
+{
+ buffer_read_binary(file, buf, width - buf->len);
+ if (buf->len != width)
+ return input_error(file);
+ return 0;
+}
+
+static int check_offset_overflow(off_t offset, uintmax_t len)
+{
+ if (len > maximum_signed_value_of_type(off_t))
+ return error("unrepresentable length in delta: "
+ "%"PRIuMAX" > OFF_MAX", len);
+ if (signed_add_overflows(offset, (off_t) len))
+ return error("unrepresentable offset in delta: "
+ "%"PRIuMAX" + %"PRIuMAX" > OFF_MAX",
+ (uintmax_t) offset, len);
+ return 0;
+}
+
+int move_window(struct sliding_view *view, off_t off, size_t width)
{
off_t file_offset;
- assert(view && view->file);
- assert(!check_overflow(view->off, view->buf.len));
+ assert(view);
+ assert(view->width <= view->buf.len);
+ assert(!check_offset_overflow(view->off, view->buf.len));
- if (check_overflow(off, len))
+ if (check_offset_overflow(off, width))
return -1;
- if (off < view->off || off + len < view->off + view->buf.len)
- return error("Invalid delta: window slides left");
+ if (off < view->off || off + width < view->off + view->width)
+ return error("invalid delta: window slides left");
+ if (view->max_off >= 0 && view->max_off < off + width)
+ return error("delta preimage ends early");
file_offset = view->off + view->buf.len;
- if (off < file_offset)
+ if (off < file_offset) {
/* Move the overlapping region into place. */
- strbuf_remove_from_left(&view->buf, off - view->off);
- else
- strbuf_setlen(&view->buf, 0);
- if (off > file_offset) {
+ strbuf_remove(&view->buf, 0, off - view->off);
+ } else {
/* Seek ahead to skip the gap. */
- const off_t gap = off - file_offset;
- const off_t nread = buffer_skip_bytes(view->file, gap);
- if (nread != gap) {
- if (!buffer_ferror(view->file))
- return error("Preimage ends early");
- return error("Cannot seek forward in input: %s",
- strerror(errno));
- }
- file_offset += gap;
- }
- buffer_read_binary(&view->buf, len - view->buf.len, view->file);
- if (view->buf.len != len) {
- if (!buffer_ferror(view->file))
- return error("Preimage ends early");
- return error("Cannot read preimage: %s", strerror(errno));
+ if (skip_or_whine(view->file, off - file_offset))
+ return -1;
+ strbuf_setlen(&view->buf, 0);
}
+
+ if (view->buf.len > width)
+ ; /* Already read. */
+ else if (read_to_fill_or_whine(view->file, &view->buf, width))
+ return -1;
+
view->off = off;
+ view->width = width;
return 0;
}
8 vcs-svn/sliding_window.h
View
@@ -3,12 +3,16 @@
#include "strbuf.h"
-struct view {
+struct sliding_view {
struct line_buffer *file;
off_t off;
+ size_t width;
+ off_t max_off; /* -1 means unlimited */
struct strbuf buf;
};
-extern int move_window(struct view *view, off_t off, size_t len);
+#define SLIDING_VIEW_INIT(input, len) { (input), 0, 0, (len), STRBUF_INIT }
+
+extern int move_window(struct sliding_view *view, off_t off, size_t width);
#endif
113 vcs-svn/string_pool.c
View
@@ -1,113 +0,0 @@
-/*
- * Licensed under a two-clause BSD-style license.
- * See LICENSE for details.
- */
-
-#include "compat-util.h"
-#include "trp.h"
-#include "obj_pool.h"
-#include "string_pool.h"
-
-static struct trp_root tree = { ~0 };
-
-struct node {
- uint32_t offset;
- struct trp_node children;
-};
-
-/* Two memory pools: one for struct node, and another for strings */
-obj_pool_gen(node, struct node, 4096);
-obj_pool_gen(string, char, 4096);
-
-static char *node_value(struct node *node)
-{
- return node ? string_pointer(node->offset) : NULL;
-}
-
-static int node_cmp(struct node *a, struct node *b)
-{
- return strcmp(node_value(a), node_value(b));
-}
-
-/* Build a Treap from the node structure (a trp_node w/ offset) */
-trp_gen(static, tree_, struct node, children, node, node_cmp);
-
-char *pool_fetch(uint32_t entry)
-{
- return node_value(node_pointer(entry));
-}
-
-uint32_t pool_intern(char *key)
-{
- /* Canonicalize key */
- struct node *match = NULL;
- uint32_t key_len;
- if (key == NULL)
- return ~0;
- key_len = strlen(key) + 1;
- struct node *node = node_pointer(node_alloc(1));
- node->offset = string_alloc(key_len);
- strcpy(node_value(node), key);
- match = tree_search(&tree, node);
- if (!match) {
- tree_insert(&tree, node);
- } else {
- node_free(1);
- string_free(key_len);
- node = match;
- }
- return node_offset(node);
-}
-
-uint32_t pool_tok_r(char *str, const char *delim, char **saveptr)
-{
- char *token = strtok_r(str, delim, saveptr);
- return token ? pool_intern(token) : ~0u;
-}
-
-void pool_print_seq(uint32_t len, uint32_t *seq, char delim, FILE *stream)
-{
- uint32_t i;
- for (i = 0; i < len && ~seq[i]; i++) {
- fputs(pool_fetch(seq[i]), stream);
- if (i < len - 1 && ~seq[i + 1])
- fputc(delim, stream);
- }
-}
-
-uint32_t pool_tok_seq(uint32_t max, uint32_t *seq, char *delim, char *str)
-{
- char *context = NULL;
- uint32_t length = 0, token = str ? pool_tok_r(str, delim, &context) : ~0u;
- while (length < max) {
- seq[length++] = token;
- if (token == ~0u)
- break;
- token = pool_tok_r(NULL, delim, &context);
- }
- seq[length ? length - 1 : 0] = ~0;
- return length;
-}
-
-void pool_init(void)
-{
- uint32_t node;
- uint32_t string = 0;
- while (string < string_pool.size) {
- node = node_alloc(1);
- node_pointer(node)->offset = string;
- tree_insert(&tree, node_pointer(node));
- string += strlen(string_pointer(string)) + 1;
- }
-}
-
-void pool_commit(void)
-{
- string_commit();
-}
-
-void pool_reset(void)
-{
- node_reset();
- string_reset();
-}
16 vcs-svn/string_pool.h
View
@@ -1,16 +0,0 @@
-#ifndef STRING_POOL_H_
-#define STRING_POOL_H_
-
-#include <stdint.h>
-#include <stdio.h>
-
-uint32_t pool_intern(char *key);
-char *pool_fetch(uint32_t entry);
-uint32_t pool_tok_r(char *str, const char *delim, char **saveptr);
-void pool_print_seq(uint32_t len, uint32_t *seq, char delim, FILE *stream);
-uint32_t pool_tok_seq(uint32_t max, uint32_t *seq, char *delim, char *str);
-void pool_init(void);
-void pool_commit(void);
-void pool_reset(void);
-
-#endif
217 vcs-svn/svndiff.c
View
@@ -6,13 +6,14 @@
#include "compat-util.h"
#include "sliding_window.h"
#include "line_buffer.h"
+#include "svndiff.h"
/*
* svndiff0 applier
*
* See http://svn.apache.org/repos/asf/subversion/trunk/notes/svndiff.
*
- * svndiff0 ::= 'SVN\0' window window*;
+ * svndiff0 ::= 'SVN\0' window*
* window ::= int int int int int instructions inline_data;
* instructions ::= instruction*;
* instruction ::= view_selector int int
@@ -44,73 +45,101 @@
#define VLI_BITS_PER_DIGIT 7
struct window {
- struct view *in;
+ struct sliding_view *in;
struct strbuf out;
struct strbuf instructions;
struct strbuf data;
};
+#define WINDOW_INIT(w) { (w), STRBUF_INIT, STRBUF_INIT, STRBUF_INIT }
+
+static void window_release(struct window *ctx)
+{
+ strbuf_release(&ctx->out);
+ strbuf_release(&ctx->instructions);
+ strbuf_release(&ctx->data);
+}
+
static int write_strbuf(struct strbuf *sb, FILE *out)
{
if (fwrite(sb->buf, 1, sb->len, out) == sb->len) /* Success. */
return 0;
- return error("Cannot write: %s\n", strerror(errno));
+ return error("cannot write delta postimage: %s", strerror(errno));
+}
+
+static int error_short_read(struct line_buffer *input)
+{
+ if (buffer_ferror(input))
+ return error("error reading delta: %s", strerror(errno));
+ return error("invalid delta: unexpected end of file");
+}
+
+static int read_chunk(struct line_buffer *delta, off_t *delta_len,
+ struct strbuf *buf, size_t len)
+{
+ strbuf_reset(buf);
+ if (len > *delta_len ||
+ buffer_read_binary(delta, buf, len) != len)
+ return error_short_read(delta);
+ *delta_len -= buf->len;
+ return 0;
}
static int read_magic(struct line_buffer *in, off_t *len)
{
static const char magic[] = {'S', 'V', 'N', '\0'};
struct strbuf sb = STRBUF_INIT;
- if (*len < (off_t)(sizeof(magic)))
- return error("Invalid delta: no file type header");
- buffer_read_binary(&sb, sizeof(magic), in);
- if (sb.len != sizeof(magic))
- return error("Invalid delta: no file type header");
- if (memcmp(sb.buf, magic, sizeof(magic)))
- return error("Unrecognized file type %.*s",
- (int) sizeof(magic), sb.buf);
- *len -= sizeof(magic);
+
+ if (read_chunk(in, len, &sb, sizeof(magic))) {
+ strbuf_release(&sb);
+ return -1;
+ }
+ if (memcmp(sb.buf, magic, sizeof(magic))) {
+ strbuf_release(&sb);
+ return error("invalid delta: unrecognized file type");
+ }
strbuf_release(&sb);
return 0;
}
static int read_int(struct line_buffer *in, uintmax_t *result, off_t *len)
{
- off_t sz = *len;
uintmax_t rv = 0;
- while (sz) {
- int ch = buffer_read_char(in);
+ off_t sz;
+ for (sz = *len; sz; sz--) {
+ const int ch = buffer_read_char(in);
if (ch == EOF)
- return error("Delta ends early (%"PRIu64" bytes remaining)",
- (uint64_t) sz);
- sz--;
+ break;
+
rv <<= VLI_BITS_PER_DIGIT;
rv += (ch & VLI_DIGIT_MASK);
- if (!(ch & VLI_CONTINUE)) {
- *result = rv;
- *len = sz;
- return 0;
- }
+ if (ch & VLI_CONTINUE)
+ continue;
+
+ *result = rv;
+ *len = sz - 1;
+ return 0;
}
- return error("Invalid delta: incomplete integer %"PRIuMAX, rv);
+ return error_short_read(in);
}
static int parse_int(const char **buf, size_t *result, const char *end)
{
- const char *pos;
size_t rv = 0;
+ const char *pos;
for (pos = *buf; pos != end; pos++) {
unsigned char ch = *pos;
+
rv <<= VLI_BITS_PER_DIGIT;
rv += (ch & VLI_DIGIT_MASK);
- if (!(ch & VLI_CONTINUE)) {
- *result = rv;
- *buf = pos + 1;
- return 0;
- }
+ if (ch & VLI_CONTINUE)
+ continue;
+
+ *result = rv;
+ *buf = pos + 1;
+ return 0;
}
- return error("Invalid instruction: incomplete integer %"PRIu64,
- (uint64_t) rv);
+ return error("invalid delta: unexpected end of instructions section");
}
static int read_offset(struct line_buffer *in, off_t *result, off_t *len)
@@ -119,7 +148,7 @@ static int read_offset(struct line_buffer *in, off_t *result, off_t *len)
if (read_int(in, &val, len))
return -1;
if (val > maximum_signed_value_of_type(off_t))
- return error("Unrepresentable offset: %"PRIuMAX, val);
+ return error("unrepresentable offset in delta: %"PRIuMAX"", val);
*result = val;
return 0;
}
@@ -130,23 +159,11 @@ static int read_length(struct line_buffer *in, size_t *result, off_t *len)
if (read_int(in, &val, len))
return -1;
if (val > SIZE_MAX)
- return error("Unrepresentable length: %"PRIuMAX, val);
+ return error("unrepresentable length in delta: %"PRIuMAX"", val);
*result = val;
return 0;
}
-static int read_chunk(struct line_buffer *delta, off_t *delta_len,
- struct strbuf *buf, size_t len)
-{
- if (len > maximum_signed_value_of_type(off_t) ||
- (off_t) len > *delta_len)
- return -1;
- strbuf_reset(buf);
- buffer_read_binary(buf, len, delta);
- *delta_len -= buf->len;
- return 0;
-}
-
static int copyfrom_source(struct window *ctx, const char **instructions,
size_t nbytes, const char *insns_end)
{
@@ -154,24 +171,22 @@ static int copyfrom_source(struct window *ctx, const char **instructions,
if (parse_int(instructions, &offset, insns_end))
return -1;
if (unsigned_add_overflows(offset, nbytes) ||
- offset + nbytes > ctx->in->buf.len)
- return error("Invalid delta: copies source data outside view.");
+ offset + nbytes > ctx->in->width)
+ return error("invalid delta: copies source data outside view");
strbuf_add(&ctx->out, ctx->in->buf.buf + offset, nbytes);
return 0;
}
static int copyfrom_target(struct window *ctx, const char **instructions,
- size_t nbytes, const char *insns_end)
+ size_t nbytes, const char *instructions_end)
{
size_t offset;
- if (parse_int(instructions, &offset, insns_end))
+ if (parse_int(instructions, &offset, instructions_end))
return -1;
if (offset >= ctx->out.len)
- return error("Invalid delta: copies from the future.");
- while (nbytes) {
+ return error("invalid delta: copies from the future");
+ for (; nbytes > 0; nbytes--)
strbuf_addch(&ctx->out, ctx->out.buf[offset++]);
- nbytes--;
- }
return 0;
}
@@ -180,7 +195,7 @@ static int copyfrom_data(struct window *ctx, size_t *data_pos, size_t nbytes)
const size_t pos = *data_pos;
if (unsigned_add_overflows(pos, nbytes) ||
pos + nbytes > ctx->data.len)
- return error("Invalid delta: copies unavailable inline data.");
+ return error("invalid delta: copies unavailable inline data");
strbuf_add(&ctx->out, ctx->data.buf + pos, nbytes);
*data_pos += nbytes;
return 0;
@@ -189,14 +204,15 @@ static int copyfrom_data(struct window *ctx, size_t *data_pos, size_t nbytes)
static int parse_first_operand(const char **buf, size_t *out, const char *end)
{
size_t result = (unsigned char) *(*buf)++ & OPERAND_MASK;
- if (result) {
+ if (result) { /* immediate operand */
*out = result;
return 0;
}
return parse_int(buf, out, end);
}
-static int step(struct window *ctx, const char **instructions, size_t *data_pos)
+static int execute_one_instruction(struct window *ctx,
+ const char **instructions, size_t *data_pos)
{
unsigned int instruction;
const char *insns_end = ctx->instructions.buf + ctx->instructions.len;
@@ -216,98 +232,77 @@ static int step(struct window *ctx, const char **instructions, size_t *data_pos)
case INSN_COPYFROM_DATA:
return copyfrom_data(ctx, data_pos, nbytes);
default:
- return error("Invalid instruction %x", instruction);
+ return error("invalid delta: unrecognized instruction");
}
}
static int apply_window_in_core(struct window *ctx)
{
- const char *insn = ctx->instructions.buf;
+ const char *instructions;
size_t data_pos = 0;
/*
- * Populate ctx->out.buf using data from the source, target,
+ * Fill ctx->out.buf using data from the source, target,
* and inline data views.
*/
- while (insn != ctx->instructions.buf + ctx->instructions.len)
- if (step(ctx, &insn, &data_pos))
+ for (instructions = ctx->instructions.buf;
+ instructions != ctx->instructions.buf + ctx->instructions.len;
+ )
+ if (execute_one_instruction(ctx, &instructions, &data_pos))
return -1;
if (data_pos != ctx->data.len)
- return error("Invalid delta: does not copy all new data");
+ return error("invalid delta: does not copy all inline data");
return 0;
}
static int apply_one_window(struct line_buffer *delta, off_t *delta_len,
- struct view *preimage, FILE *out)
+ struct sliding_view *preimage, FILE *out)
{
- struct window ctx = {preimage, STRBUF_INIT, STRBUF_INIT, STRBUF_INIT};
+ struct window ctx = WINDOW_INIT(preimage);
size_t out_len;
size_t instructions_len;
size_t data_len;
- int rv = 0;
assert(delta_len);
/* "source view" offset and length already handled; */
if (read_length(delta, &out_len, delta_len) ||
read_length(delta, &instructions_len, delta_len) ||
- read_length(delta, &data_len, delta_len))
- return -1;
- if (read_chunk(delta, delta_len, &ctx.instructions, instructions_len))
- return error("Invalid delta: incomplete instructions section");
- if (buffer_ferror(delta)) {
- rv = error("Cannot read delta: %s", strerror(errno));
- goto done;
- }
- if (read_chunk(delta, delta_len, &ctx.data, data_len)) {
- rv = error("Invalid delta: incomplete data section");
- goto done;
- }
- if (buffer_ferror(delta)) {
- rv = error("Cannot read delta: %s", strerror(errno));
- goto done;
- }
+ read_length(delta, &data_len, delta_len) ||
+ read_chunk(delta, delta_len, &ctx.instructions, instructions_len) ||
+ read_chunk(delta, delta_len, &ctx.data, data_len))
+ goto error_out;
strbuf_grow(&ctx.out, out_len);
- if (apply_window_in_core(&ctx) || write_strbuf(&ctx.out, out)) {
- rv = -1;
- goto done;
- }
+ if (apply_window_in_core(&ctx))
+ goto error_out;
if (ctx.out.len != out_len) {
- rv = error("Invalid delta: incorrect postimage length");
- goto done;
+ error("invalid delta: incorrect postimage length");
+ goto error_out;
}
- done:
- strbuf_release(&ctx.out);
- strbuf_release(&ctx.data);
- strbuf_release(&ctx.instructions);
- return rv;
+ if (write_strbuf(&ctx.out, out))
+ goto error_out;
+ window_release(&ctx);
+ return 0;
+error_out:
+ window_release(&ctx);
+ return -1;
}
int svndiff0_apply(struct line_buffer *delta, off_t delta_len,
- struct line_buffer *preimage, FILE *postimage)
+ struct sliding_view *preimage, FILE *postimage)
{
- struct view preimage_view = {preimage, 0, STRBUF_INIT};
assert(delta && preimage && postimage);
if (read_magic(delta, &delta_len))
- goto fail;
- while (delta_len > 0) { /* For each window: */
- off_t pre_off = pre_off;
+ return -1;
+ while (delta_len) { /* For each window: */
+ off_t pre_off = pre_off; /* stupid GCC... */
size_t pre_len;
+
if (read_offset(delta, &pre_off, &delta_len) ||
read_length(delta, &pre_len, &delta_len) ||
- move_window(&preimage_view, pre_off, pre_len) ||
- apply_one_window(delta, &delta_len,
- &preimage_view, postimage))
- goto fail;
- if (delta_len && buffer_at_eof(delta)) {
- error("Delta ends early! (%"PRIu64" bytes remaining)",
- (uint64_t) delta_len);
- goto fail;
- }
+ move_window(preimage, pre_off, pre_len) ||
+ apply_one_window(delta, &delta_len, preimage, postimage))
+ return -1;
}
- strbuf_release(&preimage_view.buf);
return 0;
- fail:
- strbuf_release(&preimage_view.buf);
- return -1;
}
5 vcs-svn/svndiff.h
View
@@ -1,9 +1,10 @@
#ifndef SVNDIFF_H_
#define SVNDIFF_H_
-#include "line_buffer.h"
+struct line_buffer;
+struct sliding_view;
extern int svndiff0_apply(struct line_buffer *delta, off_t delta_len,
- struct line_buffer *preimage, FILE *postimage);
+ struct sliding_view *preimage, FILE *postimage);
#endif
593 vcs-svn/svndump.c
View
@@ -7,15 +7,24 @@
* See LICENSE for details.
*/
+#include <time.h>
+#include <ctype.h>
+
#include "compat-util.h"
#include "repo_tree.h"
#include "fast_export.h"
#include "line_buffer.h"
-#include "obj_pool.h"
-#include "string_pool.h"
-
-#include <time.h>
+#include "strbuf.h"
#include "mkgmtime.h"
+#include "svndump.h"
+
+/*
+ * Compare start of string to literal of equal length;
+ * must be guarded by length test.
+ */
+#define constcmp(s, ref) memcmp(s, ref, sizeof(ref) - 1)
+
+#define REPORT_FILENO 3
#define NODEACT_REPLACE 4
#define NODEACT_DELETE 3
@@ -23,277 +32,365 @@
#define NODEACT_CHANGE 1
#define NODEACT_UNKNOWN 0
-#define DUMP_CTX 0
-#define REV_CTX 1
-#define NODE_CTX 2
+/* States: */
+#define DUMP_CTX 0 /* dump metadata */
+#define REV_CTX 1 /* revision metadata */
+#define NODE_CTX 2 /* node metadata */
+#define INTERNODE_CTX 3 /* between nodes */
-#define LENGTH_UNKNOWN (~0u)
+#define LENGTH_UNKNOWN (~0)
#define DATE_RFC2822_LEN 31
-#define MD5_HEX_LENGTH 32
-#define SHA1_HEX_LENGTH 40
-
-/* Create memory pool for log messages */
-obj_pool_gen(log, char, 4096);
-
static struct line_buffer input = LINE_BUFFER_INIT;
-static char* log_copy(uint32_t length, char *log)
-{
- char *buffer;
- log_free(log_pool.size);
- buffer = log_pointer(log_alloc(length));
- strncpy(buffer, log, length);
- return buffer;
-}
-
static struct {
- uint32_t action, propLength, textLength, srcRev, srcMode, srcMark, mark, type;
- uint32_t src[REPO_MAX_PATH_DEPTH], dst[REPO_MAX_PATH_DEPTH];
+ uint32_t action, propLength, srcRev, type;
+ off_t text_length;
+ struct strbuf src, dst;
uint32_t text_delta, prop_delta;
- char text_delta_base_md5[MD5_HEX_LENGTH + 1];
- char text_content_sha1[SHA1_HEX_LENGTH + 1];
- char text_delta_base_sha1[SHA1_HEX_LENGTH + 1];
- char text_copy_source_sha1[SHA1_HEX_LENGTH + 1];
} node_ctx;
static struct {
- uint32_t revision, author;
- time_t timestamp;
- char *log;
+ uint32_t revision;
+ unsigned long timestamp;
+ struct strbuf log, author;
} rev_ctx;
static struct {
- uint32_t version, uuid, url;
+ uint32_t version;
+ struct strbuf uuid, url;
} dump_ctx;
-static struct {
- uint32_t svn_log, svn_author, svn_date, svn_executable, svn_special,
- revision_number, node_path, node_kind, node_action,
- node_copyfrom_path, node_copyfrom_rev, text_content_length,
- prop_content_length, content_length,
- /* SVN dump version 2 */
- uuid, svn_fs_dump_format_version,
- /* SVN dump version 3 */
- text_delta, prop_delta, text_content_sha1,
- text_delta_base_md5, text_delta_base_sha1,
- text_copy_source_sha1;
-} keys;
-
static void reset_node_ctx(char *fname)
{
node_ctx.type = 0;
node_ctx.action = NODEACT_UNKNOWN;
node_ctx.propLength = LENGTH_UNKNOWN;
- node_ctx.textLength = LENGTH_UNKNOWN;
- node_ctx.src[0] = ~0;
+ node_ctx.text_length = -1;
+ strbuf_reset(&node_ctx.src);
node_ctx.srcRev = 0;
- node_ctx.srcMode = 0;
- node_ctx.srcMark = 0;
- pool_tok_seq(REPO_MAX_PATH_DEPTH, node_ctx.dst, "/", fname);
- node_ctx.mark = 0;
+ strbuf_reset(&node_ctx.dst);
+ if (fname)
+ strbuf_addstr(&node_ctx.dst, fname);
node_ctx.text_delta = 0;
node_ctx.prop_delta = 0;
- *node_ctx.text_delta_base_md5 = '\0';
- *node_ctx.text_content_sha1 = '\0';
- *node_ctx.text_delta_base_sha1 = '\0';
- *node_ctx.text_copy_source_sha1 = '\0';
}
static void reset_rev_ctx(uint32_t revision)
{
rev_ctx.revision = revision;
rev_ctx.timestamp = 0;
- rev_ctx.log = NULL;
- rev_ctx.author = ~0;
+ strbuf_reset(&rev_ctx.log);
+ strbuf_reset(&rev_ctx.author);
}
-static void reset_dump_ctx(uint32_t url)
+static void reset_dump_ctx(const char *url)
{
- dump_ctx.url = url;
+ strbuf_reset(&dump_ctx.url);
+ if (url)
+ strbuf_addstr(&dump_ctx.url, url);
dump_ctx.version = 1;
- dump_ctx.uuid = ~0;
+ strbuf_reset(&dump_ctx.uuid);
}
-static void init_keys(void)
+static void handle_property(const struct strbuf *key_buf,
+ struct strbuf *val,
+ uint32_t *type_set)
{
- keys.svn_log = pool_intern("svn:log");
- keys.svn_author = pool_intern("svn:author");
- keys.svn_date = pool_intern("svn:date");
- keys.svn_executable = pool_intern("svn:executable");
- keys.svn_special = pool_intern("svn:special");
- keys.revision_number = pool_intern("Revision-number");
- keys.node_path = pool_intern("Node-path");
- keys.node_kind = pool_intern("Node-kind");
- keys.node_action = pool_intern("Node-action");
- keys.node_copyfrom_path = pool_intern("Node-copyfrom-path");
- keys.node_copyfrom_rev = pool_intern("Node-copyfrom-rev");
- keys.text_content_length = pool_intern("Text-content-length");
- keys.prop_content_length = pool_intern("Prop-content-length");
- keys.content_length = pool_intern("Content-length");
- /* SVN dump version 2 */
- keys.svn_fs_dump_format_version = pool_intern("SVN-fs-dump-format-version");
- keys.uuid = pool_intern("UUID");
- /* SVN dump version 3 */
- keys.text_delta = pool_intern("Text-delta");
- keys.prop_delta = pool_intern("Prop-delta");
- keys.text_delta_base_md5 = pool_intern("Text-delta-base-md5");
- keys.text_delta_base_sha1 = pool_intern("Text-delta-base-sha1");
- keys.text_copy_source_sha1 = pool_intern("Text-copy-source-sha1");
- keys.text_content_sha1 = pool_intern("Text-content-sha1");
+ struct tm tm;
+ const char *key = key_buf->buf;
+ size_t keylen = key_buf->len;
+
+ switch (keylen + 1) {
+ case sizeof("svn:log"):
+ if (constcmp(key, "svn:log"))
+ break;
+ if (!val)
+ die("invalid dump: unsets svn:log");
+ strbuf_swap(&rev_ctx.log, val);
+ break;
+ case sizeof("svn:author"):
+ if (constcmp(key, "svn:author"))
+ break;
+ if (!val)
+ strbuf_reset(&rev_ctx.author);
+ else
+ strbuf_swap(&rev_ctx.author, val);
+ break;
+ case sizeof("svn:date"):
+ if (constcmp(key, "svn:date"))
+ break;
+ if (!val)
+ die("invalid dump: unsets svn:date");
+ if (!strptime(val->buf, "%FT%T", &tm))
+ fprintf(stderr, "warning: " "invalid timestamp: %s", val->buf);
+ else
+ rev_ctx.timestamp = mkgmtime(&tm);
+ break;
+ case sizeof("svn:executable"):
+ case sizeof("svn:special"):
+ if (keylen == strlen("svn:executable") &&
+ constcmp(key, "svn:executable"))
+ break;
+ if (keylen == strlen("svn:special") &&
+ constcmp(key, "svn:special"))
+ break;
+ if (*type_set) {
+ if (!val)
+ return;
+ die("invalid dump: sets type twice");
+ }
+ if (!val) {
+ node_ctx.type = REPO_MODE_BLB;
+ return;
+ }
+ *type_set = 1;
+ node_ctx.type = keylen == strlen("svn:executable") ?
+ REPO_MODE_EXE :
+ REPO_MODE_LNK;
+ }
+}
+
+static void die_short_read(void)
+{
+ if (buffer_ferror(&input))
+ die_errno("error reading dump file");
+ die("invalid dump: unexpected end of file");
}
static void read_props(void)
{
- struct tm tm;
- uint32_t len;
- uint32_t key = ~0;
- char *val = NULL;
- char *t;
+ static struct strbuf key = STRBUF_INIT;
+ static struct strbuf val = STRBUF_INIT;
+ const char *t;
+ /*
+ * NEEDSWORK: to support simple mode changes like
+ * K 11
+ * svn:special
+ * V 1
+ * *
+ * D 14
+ * svn:executable
+ * we keep track of whether a mode has been set and reset to
+ * plain file only if not. We should be keeping track of the
+ * symlink and executable bits separately instead.
+ */
+ uint32_t type_set = 0;
while ((t = buffer_read_line(&input)) && strcmp(t, "PROPS-END")) {
- if (!strncmp(t, "K ", 2)) {
- len = atoi(&t[2]);
- key = pool_intern(buffer_read_string(&input, len));
- buffer_read_line(&input);
- } else if (!strncmp(t, "V ", 2)) {
- len = atoi(&t[2]);
- val = buffer_read_string(&input, len);
- if (key == keys.svn_log) {
- /* Value length excludes terminating nul. */
- rev_ctx.log = log_copy(len + 1, val);
- } else if (key == keys.svn_author) {
- rev_ctx.author = pool_intern(val);
- } else if (key == keys.svn_date) {
- strptime(val, "%FT%T", &tm);
- rev_ctx.timestamp = mkgmtime(&tm);
- } else if (key == keys.svn_executable) {
- node_ctx.type = REPO_MODE_EXE;
- } else if (key == keys.svn_special) {
- node_ctx.type = REPO_MODE_LNK;
- }
- key = ~0;
- buffer_read_line(&input);
- } else if (!strncmp(t, "D ", 2)) {
- len = atoi(&t[2]);
- key = pool_intern(buffer_read_string(&input, len));
- buffer_read_line(&input);
- if (key == keys.svn_executable) {
- if (node_ctx.type == REPO_MODE_EXE)
- node_ctx.type = REPO_MODE_BLB;
- } else if (key == keys.svn_special) {
- if (node_ctx.type == REPO_MODE_LNK)
- node_ctx.type = REPO_MODE_BLB;
- }
- key = ~0;
+ uint32_t len;
+ const char type = t[0];
+ int ch;
+
+ if (!type || t[1] != ' ')
+ die("invalid property line: %s\n", t);
+ len = atoi(&t[2]);
+ strbuf_reset(&val);
+ buffer_read_binary(&input, &val, len);
+ if (val.len < len)
+ die_short_read();
+
+ /* Discard trailing newline. */
+ ch = buffer_read_char(&input);
+ if (ch == EOF)
+ die_short_read();
+ if (ch != '\n')
+ die("invalid dump: expected newline after %s", val.buf);
+
+ switch (type) {
+ case 'K':
+ strbuf_swap(&key, &val);
+ continue;
+ case 'D':
+ handle_property(&val, NULL, &type_set);
+ continue;
+ case 'V':
+ handle_property(&key, &val, &type_set);
+ strbuf_reset(&key);
+ continue;
+ default:
+ die("invalid property line: %s\n", t);
}
}
}
static void handle_node(void)
{
- if (node_ctx.prop_delta) {
- if (node_ctx.srcRev)
- node_ctx.srcMode = repo_read_mode(node_ctx.srcRev, node_ctx.src);
- else
- node_ctx.srcMode = repo_read_mode(rev_ctx.revision, node_ctx.dst);
- if (node_ctx.srcMode && node_ctx.action != NODEACT_REPLACE)
- node_ctx.type = node_ctx.srcMode;
- }
-
- if (node_ctx.propLength != LENGTH_UNKNOWN && node_ctx.propLength)
- read_props();
+ const uint32_t type = node_ctx.type;
+ const int have_props = node_ctx.propLength != LENGTH_UNKNOWN;
+ const int have_text = node_ctx.text_length != -1;
+ /*
+ * Old text for this node:
+ * NULL - directory or bug
+ * empty_blob - empty
+ * "<dataref>" - data retrievable from fast-import
+ */
+ static const char *const empty_blob = "::empty::";
+ const char *old_data = NULL;
+ uint32_t old_mode = REPO_MODE_BLB;
+ if (node_ctx.action == NODEACT_DELETE) {
+ if (have_text || have_props || node_ctx.srcRev)
+ die("invalid dump: deletion node has "
+ "copyfrom info, text, or properties");
+ repo_delete(node_ctx.dst.buf);
+ return;
+ }
+ if (node_ctx.action == NODEACT_REPLACE) {
+ repo_delete(node_ctx.dst.buf);
+ node_ctx.action = NODEACT_ADD;
+ }
if (node_ctx.srcRev) {
- node_ctx.srcMark = repo_read_mark(node_ctx.srcRev, node_ctx.src);
- node_ctx.srcMode = repo_copy(node_ctx.srcRev, node_ctx.src, node_ctx.dst);
+ repo_copy(node_ctx.srcRev, node_ctx.src.buf, node_ctx.dst.buf);
+ if (node_ctx.action == NODEACT_ADD)
+ node_ctx.action = NODEACT_CHANGE;
+ }
+ if (have_text && type == REPO_MODE_DIR)
+ die("invalid dump: directories cannot have text attached");
+
+ /*
+ * Find old content (old_data) and decide on the new mode.
+ */
+ if (node_ctx.action == NODEACT_CHANGE && !*node_ctx.dst.buf) {
+ if (type != REPO_MODE_DIR)
+ die("invalid dump: root of tree is not a regular file");
+ old_data = NULL;
+ } else if (node_ctx.action == NODEACT_CHANGE) {
+ uint32_t mode;
+ old_data = repo_read_path(node_ctx.dst.buf, &mode);
+ if (mode == REPO_MODE_DIR && type != REPO_MODE_DIR)
+ die("invalid dump: cannot modify a directory into a file");
+ if (mode != REPO_MODE_DIR && type == REPO_MODE_DIR)
+ die("invalid dump: cannot modify a file into a directory");
+ node_ctx.type = mode;
+ old_mode = mode;
+ } else if (node_ctx.action == NODEACT_ADD) {
+ if (type == REPO_MODE_DIR)
+ old_data = NULL;
+ else if (have_text)
+ old_data = empty_blob;
+ else
+ die("invalid dump: adds node without text");
} else {
- node_ctx.srcMark = repo_read_mark(rev_ctx.revision, node_ctx.dst);
+ die("invalid dump: Node-path block lacks Node-action");
}
- if (node_ctx.textLength != LENGTH_UNKNOWN &&
- node_ctx.type != REPO_MODE_DIR)
- node_ctx.mark = next_blob_mark();
-
- if (node_ctx.action == NODEACT_DELETE) {
- repo_delete(node_ctx.dst);
- } else if (node_ctx.action == NODEACT_CHANGE ||
- node_ctx.action == NODEACT_REPLACE) {
- if (node_ctx.action == NODEACT_REPLACE &&
- node_ctx.type == REPO_MODE_DIR)
- repo_replace(node_ctx.dst, node_ctx.mark);
- else if (node_ctx.propLength != LENGTH_UNKNOWN)
- repo_modify(node_ctx.dst, node_ctx.type, node_ctx.mark);
- else if (node_ctx.textLength != LENGTH_UNKNOWN)
- node_ctx.srcMode = repo_replace(node_ctx.dst, node_ctx.mark);
- } else if (node_ctx.action == NODEACT_ADD) {
- if (node_ctx.srcRev && node_ctx.propLength != LENGTH_UNKNOWN)
- repo_modify(node_ctx.dst, node_ctx.type, node_ctx.mark);
- else if (node_ctx.srcRev && node_ctx.textLength != LENGTH_UNKNOWN)
- node_ctx.srcMode = repo_replace(node_ctx.dst, node_ctx.mark);
- else if ((node_ctx.type == REPO_MODE_DIR && !node_ctx.srcRev) ||
- node_ctx.textLength != LENGTH_UNKNOWN)
- repo_add(node_ctx.dst, node_ctx.type, node_ctx.mark);
+ /*
+ * Adjust mode to reflect properties.
+ */
+ if (have_props) {
+ if (!node_ctx.prop_delta)
+ node_ctx.type = type;
+ if (node_ctx.propLength)
+ read_props();
}
- if (node_ctx.propLength == LENGTH_UNKNOWN && node_ctx.srcMode)
- node_ctx.type = node_ctx.srcMode;
+ /*
+ * Save the result.
+ */
+ if (type == REPO_MODE_DIR) /* directories are not tracked. */
+ return;
+ assert(old_data);
+ if (old_data == empty_blob)
+ /* For the fast_export_* functions, NULL means empty. */
+ old_data = NULL;
+ if (!have_text) {
+ fast_export_modify(node_ctx.dst.buf, node_ctx.type, old_data);
+ return;
+ }
+ if (!node_ctx.text_delta) {
+ fast_export_modify(node_ctx.dst.buf, node_ctx.type, "inline");
+ fast_export_data(node_ctx.type, node_ctx.text_length, &input);
+ return;
+ }
+ fast_export_modify(node_ctx.dst.buf, node_ctx.type, "inline");
+ fast_export_blob_delta(node_ctx.type, old_mode, old_data,
+ node_ctx.text_length, &input);
+}
- if (node_ctx.mark)
- fast_export_blob(node_ctx.type, node_ctx.mark, node_ctx.textLength,
- node_ctx.text_delta, node_ctx.srcMark, node_ctx.srcMode,
- &input);
- else if (node_ctx.textLength != LENGTH_UNKNOWN)
- buffer_skip_bytes(&input, node_ctx.textLength);
+static void begin_revision(void)
+{
+ if (!rev_ctx.revision) /* revision 0 gets no git commit. */
+ return;
+ fast_export_begin_commit(rev_ctx.revision, rev_ctx.author.buf,
+ &rev_ctx.log, dump_ctx.uuid.buf, dump_ctx.url.buf,
+ rev_ctx.timestamp);
}
-static void handle_revision(void)
+static void end_revision(void)
{
if (rev_ctx.revision)
- repo_commit(rev_ctx.revision, rev_ctx.author, rev_ctx.log,
- dump_ctx.uuid, dump_ctx.url, rev_ctx.timestamp);
+ fast_export_end_commit(rev_ctx.revision);
}
-void svndump_read(char *url)
+void svndump_read(const char *url)
{
char *val;
char *t;
uint32_t active_ctx = DUMP_CTX;
uint32_t len;
- uint32_t key;
- reset_dump_ctx(pool_intern(url));
+ reset_dump_ctx(url);
while ((t = buffer_read_line(&input))) {
- val = strstr(t, ": ");
+ val = strchr(t, ':');
if (!val)
continue;
- *val++ = '\0';
- *val++ = '\0';
- key = pool_intern(t);
+ val++;
+ if (*val != ' ')
+ continue;
+ val++;
- if (key == keys.svn_fs_dump_format_version) {
+ /* strlen(key) + 1 */
+ switch (val - t - 1) {
+ case sizeof("SVN-fs-dump-format-version"):
+ if (constcmp(t, "SVN-fs-dump-format-version"))
+ continue;
dump_ctx.version = atoi(val);
- } else if (key == keys.uuid) {
- dump_ctx.uuid = pool_intern(val);
- } else if (key == keys.revision_number) {
+ if (dump_ctx.version > 3)
+ die("expected svn dump format version <= 3, found %"PRIu32,
+ dump_ctx.version);
+ break;
+ case sizeof("UUID"):
+ if (constcmp(t, "UUID"))
+ continue;
+ strbuf_reset(&dump_ctx.uuid);
+ strbuf_addstr(&dump_ctx.uuid, val);
+ break;
+ case sizeof("Revision-number"):
+ if (constcmp(t, "Revision-number"))
+ continue;
if (active_ctx == NODE_CTX)
handle_node();
+ if (active_ctx == REV_CTX)
+ begin_revision();
if (active_ctx != DUMP_CTX)
- handle_revision();
+ end_revision();
active_ctx = REV_CTX;
reset_rev_ctx(atoi(val));
- } else if (key == keys.node_path) {
- if (active_ctx == NODE_CTX)
- handle_node();
- active_ctx = NODE_CTX;
- reset_node_ctx(val);
- } else if (key == keys.node_kind) {
+ break;
+ case sizeof("Node-path"):
+ if (prefixcmp(t, "Node-"))
+ continue;
+ if (!constcmp(t + strlen("Node-"), "path")) {
+ if (active_ctx == NODE_CTX)
+ handle_node();
+ if (active_ctx == REV_CTX)
+ begin_revision();
+ active_ctx = NODE_CTX;
+ reset_node_ctx(val);
+ break;
+ }
+ if (constcmp(t + strlen("Node-"), "kind"))
+ continue;
if (!strcmp(val, "dir"))
node_ctx.type = REPO_MODE_DIR;
else if (!strcmp(val, "file"))
node_ctx.type = REPO_MODE_BLB;
else
fprintf(stderr, "Unknown node-kind: %s\n", val);
- } else if (key == keys.node_action) {
+ break;
+ case sizeof("Node-action"):
+ if (constcmp(t, "Node-action"))
+ continue;
if (!strcmp(val, "delete")) {
node_ctx.action = NODEACT_DELETE;
} else if (!strcmp(val, "add")) {
@@ -306,67 +403,101 @@ void svndump_read(char *url)
fprintf(stderr, "Unknown node-action: %s\n", val);
node_ctx.action = NODEACT_UNKNOWN;
}
- } else if (key == keys.node_copyfrom_path) {
- pool_tok_seq(REPO_MAX_PATH_DEPTH, node_ctx.src, "/", val);
- } else if (key == keys.node_copyfrom_rev) {
+ break;
+ case sizeof("Node-copyfrom-path"):
+ if