2 * Parse and rearrange a svnadmin dump.
3 * Create the dump with:
4 * svnadmin dump --incremental -r<startrev>:<endrev> <repository> >outfile
6 * Licensed under a two-clause BSD-style license.
7 * See LICENSE for details.
11 #include "repo_tree.h"
12 #include "fast_export.h"
13 #include "line_buffer.h"
15 #include "string_pool.h"
17 #define REPORT_FILENO 3
19 #define NODEACT_REPLACE 4
20 #define NODEACT_DELETE 3
22 #define NODEACT_CHANGE 1
23 #define NODEACT_UNKNOWN 0
29 #define LENGTH_UNKNOWN (~0)
30 #define DATE_RFC2822_LEN 31
32 /* Create memory pool for log messages */
33 obj_pool_gen(log
, char, 4096)
35 static struct line_buffer input
= LINE_BUFFER_INIT
;
37 static char *log_copy(uint32_t length
, const char *log
)
40 log_free(log_pool
.size
);
41 buffer
= log_pointer(log_alloc(length
));
42 strncpy(buffer
, log
, length
);
47 uint32_t action
, propLength
, textLength
, srcRev
, type
;
48 uint32_t src
[REPO_MAX_PATH_DEPTH
], dst
[REPO_MAX_PATH_DEPTH
];
49 uint32_t text_delta
, prop_delta
;
53 uint32_t revision
, author
;
54 unsigned long timestamp
;
59 uint32_t version
, uuid
, url
;
63 uint32_t svn_log
, svn_author
, svn_date
, svn_executable
, svn_special
, uuid
,
64 revision_number
, node_path
, node_kind
, node_action
,
65 node_copyfrom_path
, node_copyfrom_rev
, text_content_length
,
66 prop_content_length
, content_length
, svn_fs_dump_format_version
,
67 /* version 3 format */
68 text_delta
, prop_delta
;
71 static void reset_node_ctx(char *fname
)
74 node_ctx
.action
= NODEACT_UNKNOWN
;
75 node_ctx
.propLength
= LENGTH_UNKNOWN
;
76 node_ctx
.textLength
= LENGTH_UNKNOWN
;
79 pool_tok_seq(REPO_MAX_PATH_DEPTH
, node_ctx
.dst
, "/", fname
);
80 node_ctx
.text_delta
= 0;
81 node_ctx
.prop_delta
= 0;
84 static void reset_rev_ctx(uint32_t revision
)
86 rev_ctx
.revision
= revision
;
87 rev_ctx
.timestamp
= 0;
92 static void reset_dump_ctx(uint32_t url
)
99 static void init_keys(void)
101 keys
.svn_log
= pool_intern("svn:log");
102 keys
.svn_author
= pool_intern("svn:author");
103 keys
.svn_date
= pool_intern("svn:date");
104 keys
.svn_executable
= pool_intern("svn:executable");
105 keys
.svn_special
= pool_intern("svn:special");
106 keys
.uuid
= pool_intern("UUID");
107 keys
.revision_number
= pool_intern("Revision-number");
108 keys
.node_path
= pool_intern("Node-path");
109 keys
.node_kind
= pool_intern("Node-kind");
110 keys
.node_action
= pool_intern("Node-action");
111 keys
.node_copyfrom_path
= pool_intern("Node-copyfrom-path");
112 keys
.node_copyfrom_rev
= pool_intern("Node-copyfrom-rev");
113 keys
.text_content_length
= pool_intern("Text-content-length");
114 keys
.prop_content_length
= pool_intern("Prop-content-length");
115 keys
.content_length
= pool_intern("Content-length");
116 keys
.svn_fs_dump_format_version
= pool_intern("SVN-fs-dump-format-version");
117 /* version 3 format (Subversion 1.1.0) */
118 keys
.text_delta
= pool_intern("Text-delta");
119 keys
.prop_delta
= pool_intern("Prop-delta");
122 static void handle_property(uint32_t key
, const char *val
, uint32_t len
,
125 if (key
== keys
.svn_log
) {
127 die("invalid dump: unsets svn:log");
128 /* Value length excludes terminating nul. */
129 rev_ctx
.log
= log_copy(len
+ 1, val
);
130 } else if (key
== keys
.svn_author
) {
131 rev_ctx
.author
= pool_intern(val
);
132 } else if (key
== keys
.svn_date
) {
134 die("invalid dump: unsets svn:date");
135 if (parse_date_basic(val
, &rev_ctx
.timestamp
, NULL
))
136 warning("invalid timestamp: %s", val
);
137 } else if (key
== keys
.svn_executable
|| key
== keys
.svn_special
) {
141 die("invalid dump: sets type twice");
144 node_ctx
.type
= REPO_MODE_BLB
;
148 node_ctx
.type
= key
== keys
.svn_executable
?
154 static void read_props(void)
159 * NEEDSWORK: to support simple mode changes like
166 * we keep track of whether a mode has been set and reset to
167 * plain file only if not. We should be keeping track of the
168 * symlink and executable bits separately instead.
170 uint32_t type_set
= 0;
171 while ((t
= buffer_read_line(&input
)) && strcmp(t
, "PROPS-END")) {
174 const char type
= t
[0];
176 if (!type
|| t
[1] != ' ')
177 die("invalid property line: %s\n", t
);
179 val
= buffer_read_string(&input
, len
);
180 buffer_skip_bytes(&input
, 1); /* Discard trailing newline. */
184 key
= pool_intern(val
);
187 key
= pool_intern(val
);
192 handle_property(key
, val
, len
, &type_set
);
196 die("invalid property line: %s\n", t
);
201 static void handle_node(void)
204 const uint32_t type
= node_ctx
.type
;
205 const int have_props
= node_ctx
.propLength
!= LENGTH_UNKNOWN
;
206 const int have_text
= node_ctx
.textLength
!= LENGTH_UNKNOWN
;
208 if (node_ctx
.text_delta
)
209 die("text deltas not supported");
211 mark
= next_blob_mark();
212 if (node_ctx
.action
== NODEACT_DELETE
) {
213 if (have_text
|| have_props
|| node_ctx
.srcRev
)
214 die("invalid dump: deletion node has "
215 "copyfrom info, text, or properties");
216 return repo_delete(node_ctx
.dst
);
218 if (node_ctx
.action
== NODEACT_REPLACE
) {
219 repo_delete(node_ctx
.dst
);
220 node_ctx
.action
= NODEACT_ADD
;
222 if (node_ctx
.srcRev
) {
223 repo_copy(node_ctx
.srcRev
, node_ctx
.src
, node_ctx
.dst
);
224 if (node_ctx
.action
== NODEACT_ADD
)
225 node_ctx
.action
= NODEACT_CHANGE
;
227 if (have_text
&& type
== REPO_MODE_DIR
)
228 die("invalid dump: directories cannot have text attached");
231 * Decide on the new content (mark) and mode (node_ctx.type).
233 if (node_ctx
.action
== NODEACT_CHANGE
&& !~*node_ctx
.dst
) {
234 if (type
!= REPO_MODE_DIR
)
235 die("invalid dump: root of tree is not a regular file");
236 } else if (node_ctx
.action
== NODEACT_CHANGE
) {
239 mark
= repo_read_path(node_ctx
.dst
);
240 mode
= repo_read_mode(node_ctx
.dst
);
241 if (mode
== REPO_MODE_DIR
&& type
!= REPO_MODE_DIR
)
242 die("invalid dump: cannot modify a directory into a file");
243 if (mode
!= REPO_MODE_DIR
&& type
== REPO_MODE_DIR
)
244 die("invalid dump: cannot modify a file into a directory");
245 node_ctx
.type
= mode
;
246 } else if (node_ctx
.action
== NODEACT_ADD
) {
247 if (!have_text
&& type
!= REPO_MODE_DIR
)
248 die("invalid dump: adds node without text");
250 die("invalid dump: Node-path block lacks Node-action");
254 * Adjust mode to reflect properties.
257 if (!node_ctx
.prop_delta
)
258 node_ctx
.type
= type
;
259 if (node_ctx
.propLength
)
266 repo_add(node_ctx
.dst
, node_ctx
.type
, mark
);
268 fast_export_blob(node_ctx
.type
, mark
,
269 node_ctx
.textLength
, &input
);
272 static void handle_revision(void)
274 if (rev_ctx
.revision
)
275 repo_commit(rev_ctx
.revision
, rev_ctx
.author
, rev_ctx
.log
,
276 dump_ctx
.uuid
, dump_ctx
.url
, rev_ctx
.timestamp
);
279 void svndump_read(const char *url
)
283 uint32_t active_ctx
= DUMP_CTX
;
287 reset_dump_ctx(pool_intern(url
));
288 while ((t
= buffer_read_line(&input
))) {
289 val
= strstr(t
, ": ");
294 key
= pool_intern(t
);
296 if (key
== keys
.svn_fs_dump_format_version
) {
297 dump_ctx
.version
= atoi(val
);
298 if (dump_ctx
.version
> 3)
299 die("expected svn dump format version <= 3, found %"PRIu32
,
301 } else if (key
== keys
.uuid
) {
302 dump_ctx
.uuid
= pool_intern(val
);
303 } else if (key
== keys
.revision_number
) {
304 if (active_ctx
== NODE_CTX
)
306 if (active_ctx
!= DUMP_CTX
)
308 active_ctx
= REV_CTX
;
309 reset_rev_ctx(atoi(val
));
310 } else if (key
== keys
.node_path
) {
311 if (active_ctx
== NODE_CTX
)
313 active_ctx
= NODE_CTX
;
315 } else if (key
== keys
.node_kind
) {
316 if (!strcmp(val
, "dir"))
317 node_ctx
.type
= REPO_MODE_DIR
;
318 else if (!strcmp(val
, "file"))
319 node_ctx
.type
= REPO_MODE_BLB
;
321 fprintf(stderr
, "Unknown node-kind: %s\n", val
);
322 } else if (key
== keys
.node_action
) {
323 if (!strcmp(val
, "delete")) {
324 node_ctx
.action
= NODEACT_DELETE
;
325 } else if (!strcmp(val
, "add")) {
326 node_ctx
.action
= NODEACT_ADD
;
327 } else if (!strcmp(val
, "change")) {
328 node_ctx
.action
= NODEACT_CHANGE
;
329 } else if (!strcmp(val
, "replace")) {
330 node_ctx
.action
= NODEACT_REPLACE
;
332 fprintf(stderr
, "Unknown node-action: %s\n", val
);
333 node_ctx
.action
= NODEACT_UNKNOWN
;
335 } else if (key
== keys
.node_copyfrom_path
) {
336 pool_tok_seq(REPO_MAX_PATH_DEPTH
, node_ctx
.src
, "/", val
);
337 } else if (key
== keys
.node_copyfrom_rev
) {
338 node_ctx
.srcRev
= atoi(val
);
339 } else if (key
== keys
.text_content_length
) {
340 node_ctx
.textLength
= atoi(val
);
341 } else if (key
== keys
.prop_content_length
) {
342 node_ctx
.propLength
= atoi(val
);
343 } else if (key
== keys
.text_delta
) {
344 node_ctx
.text_delta
= !strcmp(val
, "true");
345 } else if (key
== keys
.prop_delta
) {
346 node_ctx
.prop_delta
= !strcmp(val
, "true");
347 } else if (key
== keys
.content_length
) {
349 buffer_read_line(&input
);
350 if (active_ctx
== REV_CTX
) {
352 } else if (active_ctx
== NODE_CTX
) {
354 active_ctx
= REV_CTX
;
356 fprintf(stderr
, "Unexpected content length header: %"PRIu32
"\n", len
);
357 buffer_skip_bytes(&input
, len
);
361 if (active_ctx
== NODE_CTX
)
363 if (active_ctx
!= DUMP_CTX
)
367 int svndump_init(const char *filename
)
369 if (buffer_init(&input
, filename
))
370 return error("cannot open %s: %s", filename
, strerror(errno
));
372 fast_export_init(REPORT_FILENO
);
375 reset_node_ctx(NULL
);
380 void svndump_deinit(void)
383 fast_export_deinit();
387 reset_node_ctx(NULL
);
388 if (buffer_deinit(&input
))
389 fprintf(stderr
, "Input error\n");
391 fprintf(stderr
, "Output error\n");
394 void svndump_reset(void)
398 buffer_reset(&input
);
402 reset_node_ctx(NULL
);