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