Merge branch 'rs/nth-switch-code-simplification'
[git/git.git] / vcs-svn / fast_export.c
1 /*
2 * Licensed under a two-clause BSD-style license.
3 * See LICENSE for details.
4 */
5
6 #include "cache.h"
7 #include "quote.h"
8 #include "fast_export.h"
9 #include "strbuf.h"
10 #include "svndiff.h"
11 #include "sliding_window.h"
12 #include "line_buffer.h"
13
14 #define MAX_GITSVN_LINE_LEN 4096
15
16 static uint32_t first_commit_done;
17 static struct line_buffer postimage = LINE_BUFFER_INIT;
18 static struct line_buffer report_buffer = LINE_BUFFER_INIT;
19
20 /* NEEDSWORK: move to fast_export_init() */
21 static int init_postimage(void)
22 {
23 static int postimage_initialized;
24 if (postimage_initialized)
25 return 0;
26 postimage_initialized = 1;
27 return buffer_tmpfile_init(&postimage);
28 }
29
30 void fast_export_init(int fd)
31 {
32 first_commit_done = 0;
33 if (buffer_fdinit(&report_buffer, fd))
34 die_errno("cannot read from file descriptor %d", fd);
35 }
36
37 void fast_export_deinit(void)
38 {
39 if (buffer_deinit(&report_buffer))
40 die_errno("error closing fast-import feedback stream");
41 }
42
43 void fast_export_delete(const char *path)
44 {
45 putchar('D');
46 putchar(' ');
47 quote_c_style(path, NULL, stdout, 0);
48 putchar('\n');
49 }
50
51 static void fast_export_truncate(const char *path, uint32_t mode)
52 {
53 fast_export_modify(path, mode, "inline");
54 printf("data 0\n\n");
55 }
56
57 void fast_export_modify(const char *path, uint32_t mode, const char *dataref)
58 {
59 /* Mode must be 100644, 100755, 120000, or 160000. */
60 if (!dataref) {
61 fast_export_truncate(path, mode);
62 return;
63 }
64 printf("M %06"PRIo32" %s ", mode, dataref);
65 quote_c_style(path, NULL, stdout, 0);
66 putchar('\n');
67 }
68
69 void fast_export_begin_note(uint32_t revision, const char *author,
70 const char *log, timestamp_t timestamp, const char *note_ref)
71 {
72 static int firstnote = 1;
73 size_t loglen = strlen(log);
74 printf("commit %s\n", note_ref);
75 printf("committer %s <%s@%s> %"PRItime" +0000\n", author, author, "local", timestamp);
76 printf("data %"PRIuMAX"\n", (uintmax_t)loglen);
77 fwrite(log, loglen, 1, stdout);
78 if (firstnote) {
79 if (revision > 1)
80 printf("from %s^0", note_ref);
81 firstnote = 0;
82 }
83 fputc('\n', stdout);
84 }
85
86 void fast_export_note(const char *committish, const char *dataref)
87 {
88 printf("N %s %s\n", dataref, committish);
89 }
90
91 static char gitsvnline[MAX_GITSVN_LINE_LEN];
92 void fast_export_begin_commit(uint32_t revision, const char *author,
93 const struct strbuf *log,
94 const char *uuid, const char *url,
95 timestamp_t timestamp, const char *local_ref)
96 {
97 static const struct strbuf empty = STRBUF_INIT;
98 if (!log)
99 log = &empty;
100 if (*uuid && *url) {
101 snprintf(gitsvnline, MAX_GITSVN_LINE_LEN,
102 "\n\ngit-svn-id: %s@%"PRIu32" %s\n",
103 url, revision, uuid);
104 } else {
105 *gitsvnline = '\0';
106 }
107 printf("commit %s\n", local_ref);
108 printf("mark :%"PRIu32"\n", revision);
109 printf("committer %s <%s@%s> %"PRItime" +0000\n",
110 *author ? author : "nobody",
111 *author ? author : "nobody",
112 *uuid ? uuid : "local", timestamp);
113 printf("data %"PRIuMAX"\n",
114 (uintmax_t) (log->len + strlen(gitsvnline)));
115 fwrite(log->buf, log->len, 1, stdout);
116 printf("%s\n", gitsvnline);
117 if (!first_commit_done) {
118 if (revision > 1)
119 printf("from :%"PRIu32"\n", revision - 1);
120 first_commit_done = 1;
121 }
122 }
123
124 void fast_export_end_commit(uint32_t revision)
125 {
126 printf("progress Imported commit %"PRIu32".\n\n", revision);
127 }
128
129 static void ls_from_rev(uint32_t rev, const char *path)
130 {
131 /* ls :5 path/to/old/file */
132 printf("ls :%"PRIu32" ", rev);
133 quote_c_style(path, NULL, stdout, 0);
134 putchar('\n');
135 fflush(stdout);
136 }
137
138 static void ls_from_active_commit(const char *path)
139 {
140 /* ls "path/to/file" */
141 printf("ls \"");
142 quote_c_style(path, NULL, stdout, 1);
143 printf("\"\n");
144 fflush(stdout);
145 }
146
147 static const char *get_response_line(void)
148 {
149 const char *line = buffer_read_line(&report_buffer);
150 if (line)
151 return line;
152 if (buffer_ferror(&report_buffer))
153 die_errno("error reading from fast-import");
154 die("unexpected end of fast-import feedback");
155 }
156
157 static void die_short_read(struct line_buffer *input)
158 {
159 if (buffer_ferror(input))
160 die_errno("error reading dump file");
161 die("invalid dump: unexpected end of file");
162 }
163
164 static int parse_cat_response_line(const char *header, off_t *len)
165 {
166 uintmax_t n;
167 const char *type;
168 const char *end;
169
170 if (ends_with(header, " missing"))
171 return error("cat-blob reports missing blob: %s", header);
172 type = strstr(header, " blob ");
173 if (!type)
174 return error("cat-blob header has wrong object type: %s", header);
175 n = strtoumax(type + strlen(" blob "), (char **) &end, 10);
176 if (end == type + strlen(" blob "))
177 return error("cat-blob header does not contain length: %s", header);
178 if (memchr(type + strlen(" blob "), '-', end - type - strlen(" blob ")))
179 return error("cat-blob header contains negative length: %s", header);
180 if (n == UINTMAX_MAX || n > maximum_signed_value_of_type(off_t))
181 return error("blob too large for current definition of off_t");
182 *len = n;
183 if (*end)
184 return error("cat-blob header contains garbage after length: %s", header);
185 return 0;
186 }
187
188 static void check_preimage_overflow(off_t a, off_t b)
189 {
190 if (signed_add_overflows(a, b))
191 die("blob too large for current definition of off_t");
192 }
193
194 static long apply_delta(off_t len, struct line_buffer *input,
195 const char *old_data, uint32_t old_mode)
196 {
197 long ret;
198 struct sliding_view preimage = SLIDING_VIEW_INIT(&report_buffer, 0);
199 FILE *out;
200
201 if (init_postimage() || !(out = buffer_tmpfile_rewind(&postimage)))
202 die("cannot open temporary file for blob retrieval");
203 if (old_data) {
204 const char *response;
205 printf("cat-blob %s\n", old_data);
206 fflush(stdout);
207 response = get_response_line();
208 if (parse_cat_response_line(response, &preimage.max_off))
209 die("invalid cat-blob response: %s", response);
210 check_preimage_overflow(preimage.max_off, 1);
211 }
212 if (old_mode == S_IFLNK) {
213 strbuf_addstr(&preimage.buf, "link ");
214 check_preimage_overflow(preimage.max_off, strlen("link "));
215 preimage.max_off += strlen("link ");
216 check_preimage_overflow(preimage.max_off, 1);
217 }
218 if (svndiff0_apply(input, len, &preimage, out))
219 die("cannot apply delta");
220 if (old_data) {
221 /* Read the remainder of preimage and trailing newline. */
222 assert(!signed_add_overflows(preimage.max_off, 1));
223 preimage.max_off++; /* room for newline */
224 if (move_window(&preimage, preimage.max_off - 1, 1))
225 die("cannot seek to end of input");
226 if (preimage.buf.buf[0] != '\n')
227 die("missing newline after cat-blob response");
228 }
229 ret = buffer_tmpfile_prepare_to_read(&postimage);
230 if (ret < 0)
231 die("cannot read temporary file for blob retrieval");
232 strbuf_release(&preimage.buf);
233 return ret;
234 }
235
236 void fast_export_buf_to_data(const struct strbuf *data)
237 {
238 printf("data %"PRIuMAX"\n", (uintmax_t)data->len);
239 fwrite(data->buf, data->len, 1, stdout);
240 fputc('\n', stdout);
241 }
242
243 void fast_export_data(uint32_t mode, off_t len, struct line_buffer *input)
244 {
245 assert(len >= 0);
246 if (mode == S_IFLNK) {
247 /* svn symlink blobs start with "link " */
248 if (len < 5)
249 die("invalid dump: symlink too short for \"link\" prefix");
250 len -= 5;
251 if (buffer_skip_bytes(input, 5) != 5)
252 die_short_read(input);
253 }
254 printf("data %"PRIuMAX"\n", (uintmax_t) len);
255 if (buffer_copy_bytes(input, len) != len)
256 die_short_read(input);
257 fputc('\n', stdout);
258 }
259
260 static int parse_ls_response(const char *response, uint32_t *mode,
261 struct strbuf *dataref)
262 {
263 const char *tab;
264 const char *response_end;
265
266 assert(response);
267 response_end = response + strlen(response);
268
269 if (*response == 'm') { /* Missing. */
270 errno = ENOENT;
271 return -1;
272 }
273
274 /* Mode. */
275 if (response_end - response < (signed) strlen("100644") ||
276 response[strlen("100644")] != ' ')
277 die("invalid ls response: missing mode: %s", response);
278 *mode = 0;
279 for (; *response != ' '; response++) {
280 char ch = *response;
281 if (ch < '0' || ch > '7')
282 die("invalid ls response: mode is not octal: %s", response);
283 *mode *= 8;
284 *mode += ch - '0';
285 }
286
287 /* ' blob ' or ' tree ' */
288 if (response_end - response < (signed) strlen(" blob ") ||
289 (response[1] != 'b' && response[1] != 't'))
290 die("unexpected ls response: not a tree or blob: %s", response);
291 response += strlen(" blob ");
292
293 /* Dataref. */
294 tab = memchr(response, '\t', response_end - response);
295 if (!tab)
296 die("invalid ls response: missing tab: %s", response);
297 strbuf_add(dataref, response, tab - response);
298 return 0;
299 }
300
301 int fast_export_ls_rev(uint32_t rev, const char *path,
302 uint32_t *mode, struct strbuf *dataref)
303 {
304 ls_from_rev(rev, path);
305 return parse_ls_response(get_response_line(), mode, dataref);
306 }
307
308 int fast_export_ls(const char *path, uint32_t *mode, struct strbuf *dataref)
309 {
310 ls_from_active_commit(path);
311 return parse_ls_response(get_response_line(), mode, dataref);
312 }
313
314 const char *fast_export_read_path(const char *path, uint32_t *mode_out)
315 {
316 int err;
317 static struct strbuf buf = STRBUF_INIT;
318
319 strbuf_reset(&buf);
320 err = fast_export_ls(path, mode_out, &buf);
321 if (err) {
322 if (errno != ENOENT)
323 BUG("unexpected fast_export_ls error: %s",
324 strerror(errno));
325 /* Treat missing paths as directories. */
326 *mode_out = S_IFDIR;
327 return NULL;
328 }
329 return buf.buf;
330 }
331
332 void fast_export_copy(uint32_t revision, const char *src, const char *dst)
333 {
334 int err;
335 uint32_t mode;
336 static struct strbuf data = STRBUF_INIT;
337
338 strbuf_reset(&data);
339 err = fast_export_ls_rev(revision, src, &mode, &data);
340 if (err) {
341 if (errno != ENOENT)
342 BUG("unexpected fast_export_ls_rev error: %s",
343 strerror(errno));
344 fast_export_delete(dst);
345 return;
346 }
347 fast_export_modify(dst, mode, data.buf);
348 }
349
350 void fast_export_blob_delta(uint32_t mode,
351 uint32_t old_mode, const char *old_data,
352 off_t len, struct line_buffer *input)
353 {
354 long postimage_len;
355
356 assert(len >= 0);
357 postimage_len = apply_delta(len, input, old_data, old_mode);
358 if (mode == S_IFLNK) {
359 buffer_skip_bytes(&postimage, strlen("link "));
360 postimage_len -= strlen("link ");
361 }
362 printf("data %ld\n", postimage_len);
363 buffer_copy_bytes(&postimage, postimage_len);
364 fputc('\n', stdout);
365 }