1 /* $OpenBSD: import.c,v 1.109 2019/06/28 13:35:00 deraadt Exp $ */
2 /*
3 * Copyright (c) 2006 Joris Vink <joris@openbsd.org>
4 *
5 * Permission to use, copy, modify, and distribute this software for any
6 * purpose with or without fee is hereby granted, provided that the above
7 * copyright notice and this permission notice appear in all copies.
8 *
9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16 */
17
18 #include <sys/stat.h>
19
20 #include <errno.h>
21 #include <fcntl.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <unistd.h>
25
26 #include "cvs.h"
27 #include "diff.h"
28 #include "remote.h"
29
30 void cvs_import_local(struct cvs_file *);
31
32 static void import_loginfo(char *);
33 static void import_new(struct cvs_file *);
34 static void import_printf(const char *, ...)
35 __attribute__((format(printf, 1, 2)));
36 static void import_update(struct cvs_file *);
37 static void import_tag(struct cvs_file *, RCSNUM *, RCSNUM *);
38 static BUF *import_get_rcsdiff(struct cvs_file *, RCSNUM *);
39
40 #define IMPORT_DEFAULT_BRANCH "1.1.1"
41
42 extern char *loginfo;
43 extern char *logmsg;
44
45 static char *import_branch = IMPORT_DEFAULT_BRANCH;
46 static char *vendor_tag = NULL;
47 static char **release_tags;
48 static char *koptstr;
49 static int dflag = 0;
50 static int tagcount = 0;
51 static BUF *logbuf;
52
53 char *import_repository = NULL;
54 int import_conflicts = 0;
55
56 struct cvs_cmd cvs_cmd_import = {
57 CVS_OP_IMPORT, CVS_USE_WDIR, "import",
58 { "im", "imp" },
59 "Import sources into CVS, using vendor branches",
60 "[-b branch] [-d] [-k mode] [-m message] "
61 "repository vendor-tag release-tags",
62 "b:dk:m:",
63 NULL,
64 cvs_import
65 };
66
67 int
cvs_import(int argc,char ** argv)68 cvs_import(int argc, char **argv)
69 {
70 int i, ch;
71 char repo[PATH_MAX], *arg = ".";
72 struct cvs_recursion cr;
73 struct trigger_list *line_list;
74
75 while ((ch = getopt(argc, argv, cvs_cmd_import.cmd_opts)) != -1) {
76 switch (ch) {
77 case 'b':
78 import_branch = optarg;
79 break;
80 case 'd':
81 dflag = 1;
82 break;
83 case 'k':
84 koptstr = optarg;
85 kflag = rcs_kflag_get(koptstr);
86 if (RCS_KWEXP_INVAL(kflag)) {
87 cvs_log(LP_ERR,
88 "invalid RCS keyword expansion mode");
89 fatal("%s", cvs_cmd_import.cmd_synopsis);
90 }
91 break;
92 case 'm':
93 logmsg = optarg;
94 break;
95 default:
96 fatal("%s", cvs_cmd_import.cmd_synopsis);
97 break;
98 }
99 }
100
101 argc -= optind;
102 argv += optind;
103
104 if (argc < 3)
105 fatal("%s", cvs_cmd_import.cmd_synopsis);
106
107 import_repository = argv[0];
108 vendor_tag = argv[1];
109 argc -= 2;
110 argv += 2;
111
112 release_tags = argv;
113 tagcount = argc;
114
115 if (!rcs_sym_check(vendor_tag))
116 fatal("invalid symbol: %s", vendor_tag);
117
118 for (i = 0; i < tagcount; i++) {
119 if (!rcs_sym_check(release_tags[i]))
120 fatal("invalid symbol: %s", release_tags[i]);
121 }
122
123 if (logmsg == NULL) {
124 if (cvs_server_active)
125 fatal("no log message specified");
126 else
127 logmsg = cvs_logmsg_create(NULL, NULL, NULL, NULL);
128 }
129
130 if (cvsroot_is_remote()) {
131 cvs_client_connect_to_server();
132
133 cvs_client_send_request("Argument -b%s", IMPORT_DEFAULT_BRANCH);
134
135 if (kflag)
136 cvs_client_send_request("Argument -k%s", koptstr);
137
138 cvs_client_send_logmsg(logmsg);
139 cvs_client_send_request("Argument %s", import_repository);
140 cvs_client_send_request("Argument %s", vendor_tag);
141 for (i = 0; i < tagcount; i++)
142 cvs_client_send_request("Argument %s", release_tags[i]);
143
144 cr.enterdir = NULL;
145 cr.leavedir = NULL;
146 cr.fileproc = cvs_client_sendfile;
147 cr.flags = CR_RECURSE_DIRS;
148
149 cvs_file_run(1, &arg, &cr);
150 cvs_client_senddir(".");
151 cvs_client_send_request("import");
152
153 cvs_client_get_responses();
154 return (0);
155 }
156
157 if (cvs_logmsg_verify(logmsg))
158 return (0);
159
160 (void)xsnprintf(repo, sizeof(repo), "%s/%s",
161 current_cvsroot->cr_dir, import_repository);
162
163 import_loginfo(import_repository);
164
165 if (cvs_noexec != 1)
166 cvs_mkdir(repo, 0755);
167
168 cr.enterdir = NULL;
169 cr.leavedir = NULL;
170 cr.fileproc = cvs_import_local;
171 cr.flags = CR_RECURSE_DIRS;
172 cvs_file_run(1, &arg, &cr);
173
174 if (import_conflicts != 0) {
175 import_printf("\n%d conflicts created by this import.\n\n",
176 import_conflicts);
177 import_printf("Use the following command to help the merge:\n");
178 import_printf("\topencvs checkout ");
179 import_printf("-j%s:yesterday -j%s %s\n\n", vendor_tag,
180 vendor_tag, import_repository);
181 } else {
182 import_printf("\nNo conflicts created by this import.\n\n");
183 }
184
185 loginfo = buf_release(logbuf);
186 logbuf = NULL;
187
188 line_list = cvs_trigger_getlines(CVS_PATH_LOGINFO, import_repository);
189 if (line_list != NULL) {
190 cvs_trigger_handle(CVS_TRIGGER_LOGINFO, import_repository,
191 loginfo, line_list, NULL);
192 cvs_trigger_freelist(line_list);
193 }
194
195 free(loginfo);
196 return (0);
197 }
198
199 static void
import_printf(const char * fmt,...)200 import_printf(const char *fmt, ...)
201 {
202 char *str;
203 va_list vap;
204
205 va_start(vap, fmt);
206 if (vasprintf(&str, fmt, vap) == -1)
207 fatal("import_printf: could not allocate memory");
208 va_end(vap);
209
210 cvs_printf("%s", str);
211 buf_puts(logbuf, str);
212
213 free(str);
214 }
215
216 void
cvs_import_ignored(const char * path)217 cvs_import_ignored(const char *path)
218 {
219 const char *p;
220
221 for (p = path; p[0] == '.' && p[1] == '/';)
222 p += 2;
223
224 import_printf("I %s/%s\n", import_repository, p);
225 }
226
227 void
cvs_import_local(struct cvs_file * cf)228 cvs_import_local(struct cvs_file *cf)
229 {
230 int isnew;
231 struct stat st;
232 char repo[PATH_MAX];
233
234 cvs_log(LP_TRACE, "cvs_import_local(%s)", cf->file_path);
235
236 cvs_file_classify(cf, cvs_directory_tag);
237
238 if (cf->file_type == CVS_DIR) {
239 if (!strcmp(cf->file_path, "."))
240 return;
241
242 if (verbosity > 1)
243 cvs_log(LP_NOTICE, "Importing %s", cf->file_path);
244
245 if (cvs_noexec == 1)
246 return;
247
248 if (mkdir(cf->file_rpath, 0755) == -1 && errno != EEXIST)
249 fatal("cvs_import_local: %s: %s", cf->file_rpath,
250 strerror(errno));
251
252 return;
253 }
254
255 isnew = 1;
256 (void)xsnprintf(repo, sizeof(repo), "%s/%s/%s/%s%s",
257 current_cvsroot->cr_dir, cf->file_wd, CVS_PATH_ATTIC,
258 cf->file_name, RCS_FILE_EXT);
259
260 if (cf->file_rcs != NULL || stat(repo, &st) != -1)
261 isnew = 0;
262
263 if (isnew == 1)
264 import_new(cf);
265 else
266 import_update(cf);
267 }
268
269 static void
import_loginfo(char * repo)270 import_loginfo(char *repo)
271 {
272 int i;
273 char pwd[PATH_MAX];
274
275 if (getcwd(pwd, sizeof(pwd)) == NULL)
276 fatal("Can't get working directory");
277
278 logbuf = buf_alloc(1024);
279 cvs_trigger_loginfo_header(logbuf, repo);
280
281 buf_puts(logbuf, "Log Message:\n");
282 buf_puts(logbuf, logmsg);
283 if (logmsg[0] != '\0' && logmsg[strlen(logmsg) - 1] != '\n')
284 buf_putc(logbuf, '\n');
285 buf_putc(logbuf, '\n');
286
287 buf_puts(logbuf, "Status:\n\n");
288
289 buf_puts(logbuf, "Vendor Tag:\t");
290 buf_puts(logbuf, vendor_tag);
291 buf_putc(logbuf, '\n');
292 buf_puts(logbuf, "Release Tags:\t");
293
294 for (i = 0; i < tagcount ; i++) {
295 buf_puts(logbuf, "\t\t");
296 buf_puts(logbuf, release_tags[i]);
297 buf_putc(logbuf, '\n');
298 }
299 buf_putc(logbuf, '\n');
300 buf_putc(logbuf, '\n');
301 }
302
303 static void
import_new(struct cvs_file * cf)304 import_new(struct cvs_file *cf)
305 {
306 int i;
307 BUF *bp;
308 mode_t mode;
309 time_t tstamp;
310 struct stat st;
311 struct rcs_branch *brp;
312 struct rcs_delta *rdp;
313 RCSNUM *branch, *brev;
314
315 tstamp = -1;
316
317 cvs_log(LP_TRACE, "import_new(%s)", cf->file_name);
318
319 if (cvs_noexec == 1) {
320 import_printf("N %s/%s\n", import_repository, cf->file_path);
321 return;
322 }
323
324 if (fstat(cf->fd, &st) == -1)
325 fatal("import_new: %s", strerror(errno));
326
327 mode = st.st_mode;
328
329 if (dflag == 1)
330 tstamp = st.st_mtime;
331
332 if ((branch = rcsnum_parse(import_branch)) == NULL)
333 fatal("import_new: failed to parse branch");
334
335 bp = buf_load_fd(cf->fd);
336
337 if ((brev = rcsnum_brtorev(branch)) == NULL)
338 fatal("import_new: failed to get first branch revision");
339
340 cf->repo_fd = open(cf->file_rpath, O_CREAT | O_RDONLY);
341 if (cf->repo_fd == -1)
342 fatal("import_new: %s: %s", cf->file_rpath, strerror(errno));
343
344 cf->file_rcs = rcs_open(cf->file_rpath, cf->repo_fd, RCS_CREATE,
345 (mode & ~(S_IWUSR | S_IWGRP | S_IWOTH)));
346 if (cf->file_rcs == NULL)
347 fatal("import_new: failed to create RCS file for %s",
348 cf->file_path);
349
350 rcs_branch_set(cf->file_rcs, branch);
351
352 if (rcs_sym_add(cf->file_rcs, vendor_tag, branch) == -1)
353 fatal("import_new: failed to add vendor tag");
354
355 for (i = 0; i < tagcount; i++) {
356 if (rcs_sym_add(cf->file_rcs, release_tags[i], brev) == -1)
357 fatal("import_new: failed to add release tag");
358 }
359
360 if (rcs_rev_add(cf->file_rcs, brev, logmsg, tstamp, NULL) == -1)
361 fatal("import_new: failed to create first branch revision");
362
363 if (rcs_rev_add(cf->file_rcs, RCS_HEAD_REV, "Initial revision",
364 tstamp, NULL) == -1)
365 fatal("import_new: failed to create first revision");
366
367 if ((rdp = rcs_findrev(cf->file_rcs, cf->file_rcs->rf_head)) == NULL)
368 fatal("import_new: cannot find newly added revision");
369
370 brp = xmalloc(sizeof(*brp));
371 brp->rb_num = rcsnum_alloc();
372 rcsnum_cpy(brev, brp->rb_num, 0);
373 TAILQ_INSERT_TAIL(&(rdp->rd_branches), brp, rb_list);
374
375 if (rcs_deltatext_set(cf->file_rcs,
376 cf->file_rcs->rf_head, bp) == -1)
377 fatal("import_new: failed to set deltatext");
378
379 if (kflag)
380 rcs_kwexp_set(cf->file_rcs, kflag);
381
382 rcs_write(cf->file_rcs);
383 import_printf("N %s/%s\n", import_repository, cf->file_path);
384
385 free(branch);
386 free(brev);
387 }
388
389 static void
import_update(struct cvs_file * cf)390 import_update(struct cvs_file *cf)
391 {
392 int ret;
393 BUF *b1, *b2, *d;
394 char branch[CVS_REV_BUFSZ];
395 RCSNUM *newrev, *rev, *brev;
396
397 cvs_log(LP_TRACE, "import_update(%s)", cf->file_path);
398
399 if (cf->file_rcs->rf_head == NULL)
400 fatal("no head revision in RCS file for `%s'", cf->file_path);
401
402 if ((rev = rcs_translate_tag(import_branch, cf->file_rcs)) == NULL)
403 fatal("import_update: could not translate tag `%s'",
404 import_branch);
405
406 if ((brev = rcsnum_parse(import_branch)) == NULL)
407 fatal("import_update: rcsnum_parse failed");
408
409 b1 = rcs_rev_getbuf(cf->file_rcs, rev, RCS_KWEXP_NONE);
410 b2 = buf_load_fd(cf->fd);
411
412 ret = buf_differ(b1, b2);
413 buf_free(b1);
414 buf_free(b2);
415 if (ret == 0) {
416 import_tag(cf, brev, rev);
417 free(brev);
418 if (cvs_noexec != 1)
419 rcs_write(cf->file_rcs);
420 import_printf("U %s/%s\n", import_repository, cf->file_path);
421 return;
422 }
423
424 if (cf->file_rcs->rf_branch != NULL)
425 rcsnum_tostr(cf->file_rcs->rf_branch, branch, sizeof(branch));
426
427 if (cf->file_rcs->rf_branch == NULL || cf->in_attic == 1 ||
428 strcmp(branch, import_branch)) {
429 import_conflicts++;
430 import_printf("C %s/%s\n", import_repository, cf->file_path);
431 } else {
432 import_printf("U %s/%s\n", import_repository, cf->file_path);
433 }
434
435 if (cvs_noexec == 1)
436 return;
437
438 d = import_get_rcsdiff(cf, rev);
439 newrev = rcsnum_inc(rev);
440
441 if (rcs_rev_add(cf->file_rcs, newrev, logmsg, -1, NULL) == -1)
442 fatal("import_update: failed to add new revision");
443
444 if (rcs_deltatext_set(cf->file_rcs, newrev, d) == -1)
445 fatal("import_update: failed to set deltatext");
446
447 import_tag(cf, brev, newrev);
448
449 if (kflag)
450 rcs_kwexp_set(cf->file_rcs, kflag);
451
452 free(brev);
453 rcs_write(cf->file_rcs);
454 }
455
456 static void
import_tag(struct cvs_file * cf,RCSNUM * branch,RCSNUM * newrev)457 import_tag(struct cvs_file *cf, RCSNUM *branch, RCSNUM *newrev)
458 {
459 int i;
460
461 if (cvs_noexec != 1) {
462 rcs_sym_add(cf->file_rcs, vendor_tag, branch);
463
464 for (i = 0; i < tagcount; i++)
465 rcs_sym_add(cf->file_rcs, release_tags[i], newrev);
466 }
467 }
468
469 static BUF *
import_get_rcsdiff(struct cvs_file * cf,RCSNUM * rev)470 import_get_rcsdiff(struct cvs_file *cf, RCSNUM *rev)
471 {
472 char *p1, *p2;
473 BUF *b1, *b2;
474 int fd1, fd2;
475
476 b2 = buf_alloc(128);
477
478 b1 = buf_load_fd(cf->fd);
479
480 (void)xasprintf(&p1, "%s/diff1.XXXXXXXXXX", cvs_tmpdir);
481 fd1 = buf_write_stmp(b1, p1, NULL);
482 buf_free(b1);
483
484 (void)xasprintf(&p2, "%s/diff2.XXXXXXXXXX", cvs_tmpdir);
485 fd2 = rcs_rev_write_stmp(cf->file_rcs, rev, p2, RCS_KWEXP_NONE);
486
487 diff_format = D_RCSDIFF;
488 if (diffreg(p2, p1, fd2, fd1, b2, D_FORCEASCII) == D_ERROR)
489 fatal("import_get_rcsdiff: failed to get RCS patch");
490
491 close(fd1);
492 close(fd2);
493
494 (void)unlink(p1);
495 (void)unlink(p2);
496
497 free(p1);
498 free(p2);
499
500 return (b2);
501 }
502