1 /* $OpenBSD: import.c,v 1.105 2015/11/05 09:48:21 nicm 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 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 (current_cvsroot->cr_method != CVS_METHOD_LOCAL) { 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 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 217 cvs_import_local(struct cvs_file *cf) 218 { 219 int isnew; 220 struct stat st; 221 char repo[PATH_MAX]; 222 223 cvs_log(LP_TRACE, "cvs_import_local(%s)", cf->file_path); 224 225 cvs_file_classify(cf, cvs_directory_tag); 226 227 if (cf->file_type == CVS_DIR) { 228 if (!strcmp(cf->file_path, ".")) 229 return; 230 231 if (verbosity > 1) 232 cvs_log(LP_NOTICE, "Importing %s", cf->file_path); 233 234 if (cvs_noexec == 1) 235 return; 236 237 if (mkdir(cf->file_rpath, 0755) == -1 && errno != EEXIST) 238 fatal("cvs_import_local: %s: %s", cf->file_rpath, 239 strerror(errno)); 240 241 return; 242 } 243 244 isnew = 1; 245 (void)xsnprintf(repo, sizeof(repo), "%s/%s/%s/%s%s", 246 current_cvsroot->cr_dir, cf->file_wd, CVS_PATH_ATTIC, 247 cf->file_name, RCS_FILE_EXT); 248 249 if (cf->file_rcs != NULL || stat(repo, &st) != -1) 250 isnew = 0; 251 252 if (isnew == 1) 253 import_new(cf); 254 else 255 import_update(cf); 256 } 257 258 static void 259 import_loginfo(char *repo) 260 { 261 int i; 262 char pwd[PATH_MAX]; 263 264 if (getcwd(pwd, sizeof(pwd)) == NULL) 265 fatal("Can't get working directory"); 266 267 logbuf = buf_alloc(1024); 268 cvs_trigger_loginfo_header(logbuf, repo); 269 270 buf_puts(logbuf, "Log Message:\n"); 271 buf_puts(logbuf, logmsg); 272 if (logmsg[0] != '\0' && logmsg[strlen(logmsg) - 1] != '\n') 273 buf_putc(logbuf, '\n'); 274 buf_putc(logbuf, '\n'); 275 276 buf_puts(logbuf, "Status:\n\n"); 277 278 buf_puts(logbuf, "Vendor Tag:\t"); 279 buf_puts(logbuf, vendor_tag); 280 buf_putc(logbuf, '\n'); 281 buf_puts(logbuf, "Release Tags:\t"); 282 283 for (i = 0; i < tagcount ; i++) { 284 buf_puts(logbuf, "\t\t"); 285 buf_puts(logbuf, release_tags[i]); 286 buf_putc(logbuf, '\n'); 287 } 288 buf_putc(logbuf, '\n'); 289 buf_putc(logbuf, '\n'); 290 } 291 292 static void 293 import_new(struct cvs_file *cf) 294 { 295 int i; 296 BUF *bp; 297 mode_t mode; 298 time_t tstamp; 299 struct stat st; 300 struct rcs_branch *brp; 301 struct rcs_delta *rdp; 302 RCSNUM *branch, *brev; 303 304 tstamp = -1; 305 306 cvs_log(LP_TRACE, "import_new(%s)", cf->file_name); 307 308 if (cvs_noexec == 1) { 309 import_printf("N %s/%s\n", import_repository, cf->file_path); 310 return; 311 } 312 313 if (fstat(cf->fd, &st) == -1) 314 fatal("import_new: %s", strerror(errno)); 315 316 mode = st.st_mode; 317 318 if (dflag == 1) 319 tstamp = st.st_mtime; 320 321 if ((branch = rcsnum_parse(import_branch)) == NULL) 322 fatal("import_new: failed to parse branch"); 323 324 bp = buf_load_fd(cf->fd); 325 326 if ((brev = rcsnum_brtorev(branch)) == NULL) 327 fatal("import_new: failed to get first branch revision"); 328 329 cf->repo_fd = open(cf->file_rpath, O_CREAT | O_RDONLY); 330 if (cf->repo_fd < 0) 331 fatal("import_new: %s: %s", cf->file_rpath, strerror(errno)); 332 333 cf->file_rcs = rcs_open(cf->file_rpath, cf->repo_fd, RCS_CREATE, 334 (mode & ~(S_IWUSR | S_IWGRP | S_IWOTH))); 335 if (cf->file_rcs == NULL) 336 fatal("import_new: failed to create RCS file for %s", 337 cf->file_path); 338 339 rcs_branch_set(cf->file_rcs, branch); 340 341 if (rcs_sym_add(cf->file_rcs, vendor_tag, branch) == -1) 342 fatal("import_new: failed to add vendor tag"); 343 344 for (i = 0; i < tagcount; i++) { 345 if (rcs_sym_add(cf->file_rcs, release_tags[i], brev) == -1) 346 fatal("import_new: failed to add release tag"); 347 } 348 349 if (rcs_rev_add(cf->file_rcs, brev, logmsg, tstamp, NULL) == -1) 350 fatal("import_new: failed to create first branch revision"); 351 352 if (rcs_rev_add(cf->file_rcs, RCS_HEAD_REV, "Initial revision", 353 tstamp, NULL) == -1) 354 fatal("import_new: failed to create first revision"); 355 356 if ((rdp = rcs_findrev(cf->file_rcs, cf->file_rcs->rf_head)) == NULL) 357 fatal("import_new: cannot find newly added revision"); 358 359 brp = xmalloc(sizeof(*brp)); 360 brp->rb_num = rcsnum_alloc(); 361 rcsnum_cpy(brev, brp->rb_num, 0); 362 TAILQ_INSERT_TAIL(&(rdp->rd_branches), brp, rb_list); 363 364 if (rcs_deltatext_set(cf->file_rcs, 365 cf->file_rcs->rf_head, bp) == -1) 366 fatal("import_new: failed to set deltatext"); 367 368 if (kflag) 369 rcs_kwexp_set(cf->file_rcs, kflag); 370 371 rcs_write(cf->file_rcs); 372 import_printf("N %s/%s\n", import_repository, cf->file_path); 373 374 rcsnum_free(branch); 375 rcsnum_free(brev); 376 } 377 378 static void 379 import_update(struct cvs_file *cf) 380 { 381 int ret; 382 BUF *b1, *b2, *d; 383 char branch[CVS_REV_BUFSZ]; 384 RCSNUM *newrev, *rev, *brev; 385 386 cvs_log(LP_TRACE, "import_update(%s)", cf->file_path); 387 388 if (cf->file_rcs->rf_head == NULL) 389 fatal("no head revision in RCS file for `%s'", cf->file_path); 390 391 if ((rev = rcs_translate_tag(import_branch, cf->file_rcs)) == NULL) 392 fatal("import_update: could not translate tag `%s'", 393 import_branch); 394 395 if ((brev = rcsnum_parse(import_branch)) == NULL) 396 fatal("import_update: rcsnum_parse failed"); 397 398 b1 = rcs_rev_getbuf(cf->file_rcs, rev, RCS_KWEXP_NONE); 399 b2 = buf_load_fd(cf->fd); 400 401 ret = buf_differ(b1, b2); 402 buf_free(b1); 403 buf_free(b2); 404 if (ret == 0) { 405 import_tag(cf, brev, rev); 406 rcsnum_free(brev); 407 if (cvs_noexec != 1) 408 rcs_write(cf->file_rcs); 409 import_printf("U %s/%s\n", import_repository, cf->file_path); 410 return; 411 } 412 413 if (cf->file_rcs->rf_branch != NULL) 414 rcsnum_tostr(cf->file_rcs->rf_branch, branch, sizeof(branch)); 415 416 if (cf->file_rcs->rf_branch == NULL || cf->in_attic == 1 || 417 strcmp(branch, import_branch)) { 418 import_conflicts++; 419 import_printf("C %s/%s\n", import_repository, cf->file_path); 420 } else { 421 import_printf("U %s/%s\n", import_repository, cf->file_path); 422 } 423 424 if (cvs_noexec == 1) 425 return; 426 427 d = import_get_rcsdiff(cf, rev); 428 newrev = rcsnum_inc(rev); 429 430 if (rcs_rev_add(cf->file_rcs, newrev, logmsg, -1, NULL) == -1) 431 fatal("import_update: failed to add new revision"); 432 433 if (rcs_deltatext_set(cf->file_rcs, newrev, d) == -1) 434 fatal("import_update: failed to set deltatext"); 435 436 import_tag(cf, brev, newrev); 437 438 if (kflag) 439 rcs_kwexp_set(cf->file_rcs, kflag); 440 441 rcsnum_free(brev); 442 rcs_write(cf->file_rcs); 443 } 444 445 static void 446 import_tag(struct cvs_file *cf, RCSNUM *branch, RCSNUM *newrev) 447 { 448 int i; 449 450 if (cvs_noexec != 1) { 451 rcs_sym_add(cf->file_rcs, vendor_tag, branch); 452 453 for (i = 0; i < tagcount; i++) 454 rcs_sym_add(cf->file_rcs, release_tags[i], newrev); 455 } 456 } 457 458 static BUF * 459 import_get_rcsdiff(struct cvs_file *cf, RCSNUM *rev) 460 { 461 char *p1, *p2; 462 BUF *b1, *b2; 463 int fd1, fd2; 464 465 b2 = buf_alloc(128); 466 467 b1 = buf_load_fd(cf->fd); 468 469 (void)xasprintf(&p1, "%s/diff1.XXXXXXXXXX", cvs_tmpdir); 470 fd1 = buf_write_stmp(b1, p1, NULL); 471 buf_free(b1); 472 473 (void)xasprintf(&p2, "%s/diff2.XXXXXXXXXX", cvs_tmpdir); 474 fd2 = rcs_rev_write_stmp(cf->file_rcs, rev, p2, RCS_KWEXP_NONE); 475 476 diff_format = D_RCSDIFF; 477 if (diffreg(p2, p1, fd2, fd1, b2, D_FORCEASCII) == D_ERROR) 478 fatal("import_get_rcsdiff: failed to get RCS patch"); 479 480 close(fd1); 481 close(fd2); 482 483 (void)unlink(p1); 484 (void)unlink(p2); 485 486 free(p1); 487 free(p2); 488 489 return (b2); 490 } 491