| /* |
| * Parse and rearrange a svnadmin dump. |
| * Create the dump with: |
| * svnadmin dump --incremental -r<startrev>:<endrev> <repository> >outfile |
| * |
| * Licensed under a two-clause BSD-style license. |
| * See LICENSE for details. |
| */ |
| |
| #include "cache.h" |
| #include "repo_tree.h" |
| #include "fast_export.h" |
| #include "line_buffer.h" |
| #include "strbuf.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 |
| #define NODEACT_ADD 2 |
| #define NODEACT_CHANGE 1 |
| #define NODEACT_UNKNOWN 0 |
| |
| /* 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 DATE_RFC2822_LEN 31 |
| |
| static struct line_buffer input = LINE_BUFFER_INIT; |
| |
| static struct { |
| uint32_t action, srcRev, type; |
| off_t prop_length, text_length; |
| struct strbuf src, dst; |
| uint32_t text_delta, prop_delta; |
| } node_ctx; |
| |
| static struct { |
| uint32_t revision; |
| unsigned long timestamp; |
| struct strbuf log, author, note; |
| } rev_ctx; |
| |
| static struct { |
| uint32_t version; |
| struct strbuf uuid, url; |
| } dump_ctx; |
| |
| static void reset_node_ctx(char *fname) |
| { |
| node_ctx.type = 0; |
| node_ctx.action = NODEACT_UNKNOWN; |
| node_ctx.prop_length = -1; |
| node_ctx.text_length = -1; |
| strbuf_reset(&node_ctx.src); |
| node_ctx.srcRev = 0; |
| strbuf_reset(&node_ctx.dst); |
| if (fname) |
| strbuf_addstr(&node_ctx.dst, fname); |
| node_ctx.text_delta = 0; |
| node_ctx.prop_delta = 0; |
| } |
| |
| static void reset_rev_ctx(uint32_t revision) |
| { |
| rev_ctx.revision = revision; |
| rev_ctx.timestamp = 0; |
| strbuf_reset(&rev_ctx.log); |
| strbuf_reset(&rev_ctx.author); |
| strbuf_reset(&rev_ctx.note); |
| } |
| |
| static void reset_dump_ctx(const char *url) |
| { |
| strbuf_reset(&dump_ctx.url); |
| if (url) |
| strbuf_addstr(&dump_ctx.url, url); |
| dump_ctx.version = 1; |
| strbuf_reset(&dump_ctx.uuid); |
| } |
| |
| static void handle_property(const struct strbuf *key_buf, |
| struct strbuf *val, |
| uint32_t *type_set) |
| { |
| 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 (parse_date_basic(val->buf, &rev_ctx.timestamp, NULL)) |
| warning("invalid timestamp: %s", val->buf); |
| 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) |
| { |
| 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")) { |
| uint32_t len; |
| const char type = t[0]; |
| int ch; |
| |
| if (!type || t[1] != ' ') |
| die("invalid property line: %s", 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", t); |
| } |
| } |
| } |
| |
| static void handle_node(void) |
| { |
| const uint32_t type = node_ctx.type; |
| const int have_props = node_ctx.prop_length != -1; |
| 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) { |
| 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 { |
| die("invalid dump: Node-path block lacks Node-action"); |
| } |
| |
| /* |
| * Adjust mode to reflect properties. |
| */ |
| if (have_props) { |
| if (!node_ctx.prop_delta) |
| node_ctx.type = type; |
| if (node_ctx.prop_length) |
| read_props(); |
| } |
| |
| /* |
| * 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); |
| } |
| |
| static void begin_revision(const char *remote_ref) |
| { |
| 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, remote_ref); |
| } |
| |
| static void end_revision(const char *note_ref) |
| { |
| struct strbuf mark = STRBUF_INIT; |
| if (rev_ctx.revision) { |
| fast_export_end_commit(rev_ctx.revision); |
| fast_export_begin_note(rev_ctx.revision, "remote-svn", |
| "Note created by remote-svn.", rev_ctx.timestamp, note_ref); |
| strbuf_addf(&mark, ":%"PRIu32, rev_ctx.revision); |
| fast_export_note(mark.buf, "inline"); |
| fast_export_buf_to_data(&rev_ctx.note); |
| } |
| } |
| |
| void svndump_read(const char *url, const char *local_ref, const char *notes_ref) |
| { |
| char *val; |
| char *t; |
| uint32_t active_ctx = DUMP_CTX; |
| uint32_t len; |
| |
| reset_dump_ctx(url); |
| while ((t = buffer_read_line(&input))) { |
| val = strchr(t, ':'); |
| if (!val) |
| continue; |
| val++; |
| if (*val != ' ') |
| continue; |
| val++; |
| |
| /* 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); |
| 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(local_ref); |
| if (active_ctx != DUMP_CTX) |
| end_revision(notes_ref); |
| active_ctx = REV_CTX; |
| reset_rev_ctx(atoi(val)); |
| strbuf_addf(&rev_ctx.note, "%s\n", t); |
| break; |
| case sizeof("Node-path"): |
| if (constcmp(t, "Node-")) |
| continue; |
| if (!constcmp(t + strlen("Node-"), "path")) { |
| if (active_ctx == NODE_CTX) |
| handle_node(); |
| if (active_ctx == REV_CTX) |
| begin_revision(local_ref); |
| active_ctx = NODE_CTX; |
| reset_node_ctx(val); |
| strbuf_addf(&rev_ctx.note, "%s\n", t); |
| break; |
| } |
| if (constcmp(t + strlen("Node-"), "kind")) |
| continue; |
| strbuf_addf(&rev_ctx.note, "%s\n", t); |
| 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); |
| break; |
| case sizeof("Node-action"): |
| if (constcmp(t, "Node-action")) |
| continue; |
| strbuf_addf(&rev_ctx.note, "%s\n", t); |
| if (!strcmp(val, "delete")) { |
| node_ctx.action = NODEACT_DELETE; |
| } else if (!strcmp(val, "add")) { |
| node_ctx.action = NODEACT_ADD; |
| } else if (!strcmp(val, "change")) { |
| node_ctx.action = NODEACT_CHANGE; |
| } else if (!strcmp(val, "replace")) { |
| node_ctx.action = NODEACT_REPLACE; |
| } else { |
| fprintf(stderr, "Unknown node-action: %s\n", val); |
| node_ctx.action = NODEACT_UNKNOWN; |
| } |
| break; |
| case sizeof("Node-copyfrom-path"): |
| if (constcmp(t, "Node-copyfrom-path")) |
| continue; |
| strbuf_reset(&node_ctx.src); |
| strbuf_addstr(&node_ctx.src, val); |
| strbuf_addf(&rev_ctx.note, "%s\n", t); |
| break; |
| case sizeof("Node-copyfrom-rev"): |
| if (constcmp(t, "Node-copyfrom-rev")) |
| continue; |
| node_ctx.srcRev = atoi(val); |
| strbuf_addf(&rev_ctx.note, "%s\n", t); |
| break; |
| case sizeof("Text-content-length"): |
| if (constcmp(t, "Text") && constcmp(t, "Prop")) |
| continue; |
| if (constcmp(t + 4, "-content-length")) |
| continue; |
| { |
| char *end; |
| uintmax_t len; |
| |
| len = strtoumax(val, &end, 10); |
| if (!isdigit(*val) || *end) |
| die("invalid dump: non-numeric length %s", val); |
| if (len > maximum_signed_value_of_type(off_t)) |
| die("unrepresentable length in dump: %s", val); |
| |
| if (*t == 'T') |
| node_ctx.text_length = (off_t) len; |
| else |
| node_ctx.prop_length = (off_t) len; |
| break; |
| } |
| case sizeof("Text-delta"): |
| if (!constcmp(t, "Text-delta")) { |
| node_ctx.text_delta = !strcmp(val, "true"); |
| break; |
| } |
| if (constcmp(t, "Prop-delta")) |
| continue; |
| node_ctx.prop_delta = !strcmp(val, "true"); |
| break; |
| case sizeof("Content-length"): |
| if (constcmp(t, "Content-length")) |
| continue; |
| len = atoi(val); |
| t = buffer_read_line(&input); |
| if (!t) |
| die_short_read(); |
| if (*t) |
| die("invalid dump: expected blank line after content length header"); |
| if (active_ctx == REV_CTX) { |
| read_props(); |
| } else if (active_ctx == NODE_CTX) { |
| handle_node(); |
| active_ctx = INTERNODE_CTX; |
| } else { |
| fprintf(stderr, "Unexpected content length header: %"PRIu32"\n", len); |
| if (buffer_skip_bytes(&input, len) != len) |
| die_short_read(); |
| } |
| } |
| } |
| if (buffer_ferror(&input)) |
| die_short_read(); |
| if (active_ctx == NODE_CTX) |
| handle_node(); |
| if (active_ctx == REV_CTX) |
| begin_revision(local_ref); |
| if (active_ctx != DUMP_CTX) |
| end_revision(notes_ref); |
| } |
| |
| static void init(int report_fd) |
| { |
| fast_export_init(report_fd); |
| strbuf_init(&dump_ctx.uuid, 4096); |
| strbuf_init(&dump_ctx.url, 4096); |
| strbuf_init(&rev_ctx.log, 4096); |
| strbuf_init(&rev_ctx.author, 4096); |
| strbuf_init(&rev_ctx.note, 4096); |
| strbuf_init(&node_ctx.src, 4096); |
| strbuf_init(&node_ctx.dst, 4096); |
| reset_dump_ctx(NULL); |
| reset_rev_ctx(0); |
| reset_node_ctx(NULL); |
| return; |
| } |
| |
| int svndump_init(const char *filename) |
| { |
| if (buffer_init(&input, filename)) |
| return error_errno("cannot open %s", filename ? filename : "NULL"); |
| init(REPORT_FILENO); |
| return 0; |
| } |
| |
| int svndump_init_fd(int in_fd, int back_fd) |
| { |
| if(buffer_fdinit(&input, xdup(in_fd))) |
| return error_errno("cannot open fd %d", in_fd); |
| init(xdup(back_fd)); |
| return 0; |
| } |
| |
| void svndump_deinit(void) |
| { |
| fast_export_deinit(); |
| reset_dump_ctx(NULL); |
| reset_rev_ctx(0); |
| reset_node_ctx(NULL); |
| strbuf_release(&rev_ctx.log); |
| strbuf_release(&rev_ctx.author); |
| strbuf_release(&rev_ctx.note); |
| strbuf_release(&node_ctx.src); |
| strbuf_release(&node_ctx.dst); |
| if (buffer_deinit(&input)) |
| fprintf(stderr, "Input error\n"); |
| if (ferror(stdout)) |
| fprintf(stderr, "Output error\n"); |
| } |
| |
| void svndump_reset(void) |
| { |
| strbuf_release(&dump_ctx.uuid); |
| strbuf_release(&dump_ctx.url); |
| strbuf_release(&rev_ctx.log); |
| strbuf_release(&rev_ctx.author); |
| } |