Merge branch 'ob/imap-send-ssl-verify' into maint-1.8.1
[git/jnareb-git.git] / vcs-svn / fast_export.c
blobf2b23c81de11a63c2c1c2ac925be9081ad5bea5c
1 /*
2 * Licensed under a two-clause BSD-style license.
3 * See LICENSE for details.
4 */
6 #include "cache.h"
7 #include "quote.h"
8 #include "fast_export.h"
9 #include "repo_tree.h"
10 #include "strbuf.h"
11 #include "svndiff.h"
12 #include "sliding_window.h"
13 #include "line_buffer.h"
15 #define MAX_GITSVN_LINE_LEN 4096
17 static uint32_t first_commit_done;
18 static struct line_buffer postimage = LINE_BUFFER_INIT;
19 static struct line_buffer report_buffer = LINE_BUFFER_INIT;
21 /* NEEDSWORK: move to fast_export_init() */
22 static int init_postimage(void)
24 static int postimage_initialized;
25 if (postimage_initialized)
26 return 0;
27 postimage_initialized = 1;
28 return buffer_tmpfile_init(&postimage);
31 void fast_export_init(int fd)
33 first_commit_done = 0;
34 if (buffer_fdinit(&report_buffer, fd))
35 die_errno("cannot read from file descriptor %d", fd);
38 void fast_export_deinit(void)
40 if (buffer_deinit(&report_buffer))
41 die_errno("error closing fast-import feedback stream");
44 void fast_export_delete(const char *path)
46 putchar('D');
47 putchar(' ');
48 quote_c_style(path, NULL, stdout, 0);
49 putchar('\n');
52 static void fast_export_truncate(const char *path, uint32_t mode)
54 fast_export_modify(path, mode, "inline");
55 printf("data 0\n\n");
58 void fast_export_modify(const char *path, uint32_t mode, const char *dataref)
60 /* Mode must be 100644, 100755, 120000, or 160000. */
61 if (!dataref) {
62 fast_export_truncate(path, mode);
63 return;
65 printf("M %06"PRIo32" %s ", mode, dataref);
66 quote_c_style(path, NULL, stdout, 0);
67 putchar('\n');
70 void fast_export_begin_note(uint32_t revision, const char *author,
71 const char *log, unsigned long timestamp, const char *note_ref)
73 static int firstnote = 1;
74 size_t loglen = strlen(log);
75 printf("commit %s\n", note_ref);
76 printf("committer %s <%s@%s> %ld +0000\n", author, author, "local", timestamp);
77 printf("data %"PRIuMAX"\n", (uintmax_t)loglen);
78 fwrite(log, loglen, 1, stdout);
79 if (firstnote) {
80 if (revision > 1)
81 printf("from %s^0", note_ref);
82 firstnote = 0;
84 fputc('\n', stdout);
87 void fast_export_note(const char *committish, const char *dataref)
89 printf("N %s %s\n", dataref, committish);
92 static char gitsvnline[MAX_GITSVN_LINE_LEN];
93 void fast_export_begin_commit(uint32_t revision, const char *author,
94 const struct strbuf *log,
95 const char *uuid, const char *url,
96 unsigned long timestamp, const char *local_ref)
98 static const struct strbuf empty = STRBUF_INIT;
99 if (!log)
100 log = &empty;
101 if (*uuid && *url) {
102 snprintf(gitsvnline, MAX_GITSVN_LINE_LEN,
103 "\n\ngit-svn-id: %s@%"PRIu32" %s\n",
104 url, revision, uuid);
105 } else {
106 *gitsvnline = '\0';
108 printf("commit %s\n", local_ref);
109 printf("mark :%"PRIu32"\n", revision);
110 printf("committer %s <%s@%s> %ld +0000\n",
111 *author ? author : "nobody",
112 *author ? author : "nobody",
113 *uuid ? uuid : "local", timestamp);
114 printf("data %"PRIuMAX"\n",
115 (uintmax_t) (log->len + strlen(gitsvnline)));
116 fwrite(log->buf, log->len, 1, stdout);
117 printf("%s\n", gitsvnline);
118 if (!first_commit_done) {
119 if (revision > 1)
120 printf("from :%"PRIu32"\n", revision - 1);
121 first_commit_done = 1;
125 void fast_export_end_commit(uint32_t revision)
127 printf("progress Imported commit %"PRIu32".\n\n", revision);
130 static void ls_from_rev(uint32_t rev, const char *path)
132 /* ls :5 path/to/old/file */
133 printf("ls :%"PRIu32" ", rev);
134 quote_c_style(path, NULL, stdout, 0);
135 putchar('\n');
136 fflush(stdout);
139 static void ls_from_active_commit(const char *path)
141 /* ls "path/to/file" */
142 printf("ls \"");
143 quote_c_style(path, NULL, stdout, 1);
144 printf("\"\n");
145 fflush(stdout);
148 static const char *get_response_line(void)
150 const char *line = buffer_read_line(&report_buffer);
151 if (line)
152 return line;
153 if (buffer_ferror(&report_buffer))
154 die_errno("error reading from fast-import");
155 die("unexpected end of fast-import feedback");
158 static void die_short_read(struct line_buffer *input)
160 if (buffer_ferror(input))
161 die_errno("error reading dump file");
162 die("invalid dump: unexpected end of file");
165 static int ends_with(const char *s, size_t len, const char *suffix)
167 const size_t suffixlen = strlen(suffix);
168 if (len < suffixlen)
169 return 0;
170 return !memcmp(s + len - suffixlen, suffix, suffixlen);
173 static int parse_cat_response_line(const char *header, off_t *len)
175 size_t headerlen = strlen(header);
176 uintmax_t n;
177 const char *type;
178 const char *end;
180 if (ends_with(header, headerlen, " missing"))
181 return error("cat-blob reports missing blob: %s", header);
182 type = strstr(header, " blob ");
183 if (!type)
184 return error("cat-blob header has wrong object type: %s", header);
185 n = strtoumax(type + strlen(" blob "), (char **) &end, 10);
186 if (end == type + strlen(" blob "))
187 return error("cat-blob header does not contain length: %s", header);
188 if (memchr(type + strlen(" blob "), '-', end - type - strlen(" blob ")))
189 return error("cat-blob header contains negative length: %s", header);
190 if (n == UINTMAX_MAX || n > maximum_signed_value_of_type(off_t))
191 return error("blob too large for current definition of off_t");
192 *len = n;
193 if (*end)
194 return error("cat-blob header contains garbage after length: %s", header);
195 return 0;
198 static void check_preimage_overflow(off_t a, off_t b)
200 if (signed_add_overflows(a, b))
201 die("blob too large for current definition of off_t");
204 static long apply_delta(off_t len, struct line_buffer *input,
205 const char *old_data, uint32_t old_mode)
207 long ret;
208 struct sliding_view preimage = SLIDING_VIEW_INIT(&report_buffer, 0);
209 FILE *out;
211 if (init_postimage() || !(out = buffer_tmpfile_rewind(&postimage)))
212 die("cannot open temporary file for blob retrieval");
213 if (old_data) {
214 const char *response;
215 printf("cat-blob %s\n", old_data);
216 fflush(stdout);
217 response = get_response_line();
218 if (parse_cat_response_line(response, &preimage.max_off))
219 die("invalid cat-blob response: %s", response);
220 check_preimage_overflow(preimage.max_off, 1);
222 if (old_mode == REPO_MODE_LNK) {
223 strbuf_addstr(&preimage.buf, "link ");
224 check_preimage_overflow(preimage.max_off, strlen("link "));
225 preimage.max_off += strlen("link ");
226 check_preimage_overflow(preimage.max_off, 1);
228 if (svndiff0_apply(input, len, &preimage, out))
229 die("cannot apply delta");
230 if (old_data) {
231 /* Read the remainder of preimage and trailing newline. */
232 assert(!signed_add_overflows(preimage.max_off, 1));
233 preimage.max_off++; /* room for newline */
234 if (move_window(&preimage, preimage.max_off - 1, 1))
235 die("cannot seek to end of input");
236 if (preimage.buf.buf[0] != '\n')
237 die("missing newline after cat-blob response");
239 ret = buffer_tmpfile_prepare_to_read(&postimage);
240 if (ret < 0)
241 die("cannot read temporary file for blob retrieval");
242 strbuf_release(&preimage.buf);
243 return ret;
246 void fast_export_buf_to_data(const struct strbuf *data)
248 printf("data %"PRIuMAX"\n", (uintmax_t)data->len);
249 fwrite(data->buf, data->len, 1, stdout);
250 fputc('\n', stdout);
253 void fast_export_data(uint32_t mode, off_t len, struct line_buffer *input)
255 assert(len >= 0);
256 if (mode == REPO_MODE_LNK) {
257 /* svn symlink blobs start with "link " */
258 if (len < 5)
259 die("invalid dump: symlink too short for \"link\" prefix");
260 len -= 5;
261 if (buffer_skip_bytes(input, 5) != 5)
262 die_short_read(input);
264 printf("data %"PRIuMAX"\n", (uintmax_t) len);
265 if (buffer_copy_bytes(input, len) != len)
266 die_short_read(input);
267 fputc('\n', stdout);
270 static int parse_ls_response(const char *response, uint32_t *mode,
271 struct strbuf *dataref)
273 const char *tab;
274 const char *response_end;
276 assert(response);
277 response_end = response + strlen(response);
279 if (*response == 'm') { /* Missing. */
280 errno = ENOENT;
281 return -1;
284 /* Mode. */
285 if (response_end - response < (signed) strlen("100644") ||
286 response[strlen("100644")] != ' ')
287 die("invalid ls response: missing mode: %s", response);
288 *mode = 0;
289 for (; *response != ' '; response++) {
290 char ch = *response;
291 if (ch < '0' || ch > '7')
292 die("invalid ls response: mode is not octal: %s", response);
293 *mode *= 8;
294 *mode += ch - '0';
297 /* ' blob ' or ' tree ' */
298 if (response_end - response < (signed) strlen(" blob ") ||
299 (response[1] != 'b' && response[1] != 't'))
300 die("unexpected ls response: not a tree or blob: %s", response);
301 response += strlen(" blob ");
303 /* Dataref. */
304 tab = memchr(response, '\t', response_end - response);
305 if (!tab)
306 die("invalid ls response: missing tab: %s", response);
307 strbuf_add(dataref, response, tab - response);
308 return 0;
311 int fast_export_ls_rev(uint32_t rev, const char *path,
312 uint32_t *mode, struct strbuf *dataref)
314 ls_from_rev(rev, path);
315 return parse_ls_response(get_response_line(), mode, dataref);
318 int fast_export_ls(const char *path, uint32_t *mode, struct strbuf *dataref)
320 ls_from_active_commit(path);
321 return parse_ls_response(get_response_line(), mode, dataref);
324 void fast_export_blob_delta(uint32_t mode,
325 uint32_t old_mode, const char *old_data,
326 off_t len, struct line_buffer *input)
328 long postimage_len;
330 assert(len >= 0);
331 postimage_len = apply_delta(len, input, old_data, old_mode);
332 if (mode == REPO_MODE_LNK) {
333 buffer_skip_bytes(&postimage, strlen("link "));
334 postimage_len -= strlen("link ");
336 printf("data %ld\n", postimage_len);
337 buffer_copy_bytes(&postimage, postimage_len);
338 fputc('\n', stdout);