1 /* 2 * Copyright (C) 1986-2005 The Free Software Foundation, Inc. 3 * 4 * Portions Copyright (C) 1998-2005 Derek Price, Ximbiot <http://ximbiot.com>, 5 * and others. 6 * 7 * Portions Copyright (C) 1992, Brian Berliner and Jeff Polk 8 * Portions Copyright (C) 1989-1992, Brian Berliner 9 * 10 * You may distribute under the terms of the GNU General Public License as 11 * specified in the README file that comes with the CVS source distribution. 12 * 13 * "update" updates the version in the present directory with respect to the RCS 14 * repository. The present version must have been created by "checkout". The 15 * user can keep up-to-date by calling "update" whenever he feels like it. 16 * 17 * The present version can be committed by "commit", but this keeps the version 18 * in tact. 19 * 20 * Arguments following the options are taken to be file names to be updated, 21 * rather than updating the entire directory. 22 * 23 * Modified or non-existent RCS files are checked out and reported as U 24 * <user_file> 25 * 26 * Modified user files are reported as M <user_file>. If both the RCS file and 27 * the user file have been modified, the user file is replaced by the result 28 * of rcsmerge, and a backup file is written for the user in .#file.version. 29 * If this throws up irreconcilable differences, the file is reported as C 30 * <user_file>, and as M <user_file> otherwise. 31 * 32 * Files added but not yet committed are reported as A <user_file>. Files 33 * removed but not yet committed are reported as R <user_file>. 34 * 35 * If the current directory contains subdirectories that hold concurrent 36 * versions, these are updated too. If the -d option was specified, new 37 * directories added to the repository are automatically created and updated 38 * as well. 39 */ 40 41 #include "cvs.h" 42 #include <assert.h> 43 #include "save-cwd.h" 44 #ifdef SERVER_SUPPORT 45 # include "md5.h" 46 #endif 47 #include "watch.h" 48 #include "fileattr.h" 49 #include "edit.h" 50 #include "getline.h" 51 #include "buffer.h" 52 #include "hardlink.h" 53 54 static int checkout_file (struct file_info *finfo, Vers_TS *vers_ts, 55 int adding, int merging, int update_server); 56 #ifdef SERVER_SUPPORT 57 static void checkout_to_buffer (void *, const char *, size_t); 58 static int patch_file (struct file_info *finfo, 59 Vers_TS *vers_ts, 60 int *docheckout, struct stat *file_info, 61 unsigned char *checksum); 62 static void patch_file_write (void *, const char *, size_t); 63 #endif 64 static int merge_file (struct file_info *finfo, Vers_TS *vers); 65 static int scratch_file (struct file_info *finfo, Vers_TS *vers); 66 static Dtype update_dirent_proc (void *callerdat, const char *dir, 67 const char *repository, 68 const char *update_dir, 69 List *entries); 70 static int update_dirleave_proc (void *callerdat, const char *dir, 71 int err, const char *update_dir, 72 List *entries); 73 static int update_fileproc (void *callerdat, struct file_info *); 74 static int update_filesdone_proc (void *callerdat, int err, 75 const char *repository, 76 const char *update_dir, List *entries); 77 #ifdef PRESERVE_PERMISSIONS_SUPPORT 78 static int get_linkinfo_proc( void *_callerdat, struct _finfo * ); 79 #endif 80 static void join_file (struct file_info *finfo, Vers_TS *vers_ts); 81 82 static char *options = NULL; 83 static char *tag = NULL; 84 static char *date = NULL; 85 /* This is a bit of a kludge. We call WriteTag at the beginning 86 before we know whether nonbranch is set or not. And then at the 87 end, once we have the right value for nonbranch, we call WriteTag 88 again. I don't know whether the first call is necessary or not. 89 rewrite_tag is nonzero if we are going to have to make that second 90 call. warned is nonzero if we've already warned the user that the 91 tag occurs as both a revision tag and a branch tag. */ 92 static int rewrite_tag; 93 static int nonbranch; 94 static int warned; 95 96 /* If we set the tag or date for a subdirectory, we use this to undo 97 the setting. See update_dirent_proc. */ 98 static char *tag_update_dir; 99 100 static char *join_rev1, *join_date1; 101 static char *join_rev2, *join_date2; 102 static int aflag = 0; 103 static int toss_local_changes = 0; 104 static int force_tag_match = 1; 105 static int update_build_dirs = 0; 106 static int update_prune_dirs = 0; 107 static int pipeout = 0; 108 static int dotemplate = 0; 109 #ifdef SERVER_SUPPORT 110 static int patches = 0; 111 static int rcs_diff_patches = 0; 112 #endif 113 static List *ignlist = NULL; 114 static time_t last_register_time; 115 static const char *const update_usage[] = 116 { 117 "Usage: %s %s [-APCdflRp] [-k kopt] [-r rev] [-D date] [-j rev]\n", 118 " [-I ign] [-W spec] [files...]\n", 119 "\t-A\tReset any sticky tags/date/kopts.\n", 120 "\t-P\tPrune empty directories.\n", 121 "\t-C\tOverwrite locally modified files with clean repository copies.\n", 122 "\t-d\tBuild directories, like checkout does.\n", 123 "\t-f\tForce a head revision match if tag/date not found.\n", 124 "\t-l\tLocal directory only, no recursion.\n", 125 "\t-R\tProcess directories recursively.\n", 126 "\t-p\tSend updates to standard output (avoids stickiness).\n", 127 "\t-k kopt\tUse RCS kopt -k option on checkout. (is sticky)\n", 128 "\t-r rev\tUpdate using specified revision/tag (is sticky).\n", 129 "\t-D date\tSet date to update from (is sticky).\n", 130 "\t-j rev\tMerge in changes made between current revision and rev.\n", 131 "\t-I ign\tMore files to ignore (! to reset).\n", 132 "\t-W spec\tWrappers specification line.\n", 133 "(Specify the --help global option for a list of other help options)\n", 134 NULL 135 }; 136 137 138 139 /* 140 * update is the argv,argc based front end for arg parsing 141 */ 142 int 143 update (int argc, char **argv) 144 { 145 int c, err; 146 int local = 0; /* recursive by default */ 147 int which; /* where to look for files and dirs */ 148 char *xjoin_rev1, *xjoin_date1, 149 *xjoin_rev2, *xjoin_date2, 150 *join_orig1, *join_orig2; 151 152 if (argc == -1) 153 usage (update_usage); 154 155 xjoin_rev1 = xjoin_date1 = xjoin_rev2 = xjoin_date2 = join_orig1 = 156 join_orig2 = NULL; 157 158 ign_setup (); 159 wrap_setup (); 160 161 /* parse the args */ 162 getoptreset (); 163 while ((c = getopt (argc, argv, "+ApCPflRQqduk:r:D:j:I:W:")) != -1) 164 { 165 switch (c) 166 { 167 case 'A': 168 aflag = 1; 169 break; 170 case 'C': 171 toss_local_changes = 1; 172 break; 173 case 'I': 174 ign_add (optarg, 0); 175 break; 176 case 'W': 177 wrap_add (optarg, 0); 178 break; 179 case 'k': 180 if (options) 181 free (options); 182 options = RCS_check_kflag (optarg); 183 break; 184 case 'l': 185 local = 1; 186 break; 187 case 'R': 188 local = 0; 189 break; 190 case 'Q': 191 case 'q': 192 /* The CVS 1.5 client sends these options (in addition to 193 Global_option requests), so we must ignore them. */ 194 if (!server_active) 195 error (1, 0, 196 "-q or -Q must be specified before \"%s\"", 197 cvs_cmd_name); 198 break; 199 case 'd': 200 update_build_dirs = 1; 201 break; 202 case 'f': 203 force_tag_match = 0; 204 break; 205 case 'r': 206 parse_tagdate (&tag, &date, optarg); 207 break; 208 case 'D': 209 if (date) free (date); 210 date = Make_Date (optarg); 211 break; 212 case 'P': 213 update_prune_dirs = 1; 214 break; 215 case 'p': 216 pipeout = 1; 217 noexec = 1; /* so no locks will be created */ 218 break; 219 case 'j': 220 if (join_orig2) 221 error (1, 0, "only two -j options can be specified"); 222 if (join_orig1) 223 { 224 join_orig2 = xstrdup (optarg); 225 parse_tagdate (&xjoin_rev2, &xjoin_date2, optarg); 226 } 227 else 228 { 229 join_orig1 = xstrdup (optarg); 230 parse_tagdate (&xjoin_rev1, &xjoin_date1, optarg); 231 } 232 break; 233 case 'u': 234 #ifdef SERVER_SUPPORT 235 if (server_active) 236 { 237 patches = 1; 238 rcs_diff_patches = server_use_rcs_diff (); 239 } 240 else 241 #endif 242 usage (update_usage); 243 break; 244 case '?': 245 default: 246 usage (update_usage); 247 break; 248 } 249 } 250 argc -= optind; 251 argv += optind; 252 253 #ifdef CLIENT_SUPPORT 254 if (current_parsed_root->isremote) 255 { 256 int pass; 257 258 /* The first pass does the regular update. If we receive at least 259 one patch which failed, we do a second pass and just fetch 260 those files whose patches failed. */ 261 pass = 1; 262 do 263 { 264 int status; 265 266 start_server (); 267 268 if (local) 269 send_arg("-l"); 270 if (update_build_dirs) 271 send_arg("-d"); 272 if (pipeout) 273 send_arg("-p"); 274 if (!force_tag_match) 275 send_arg("-f"); 276 if (aflag) 277 send_arg("-A"); 278 if (toss_local_changes) 279 send_arg("-C"); 280 if (update_prune_dirs) 281 send_arg("-P"); 282 client_prune_dirs = update_prune_dirs; 283 option_with_arg ("-r", tag); 284 if (options && options[0] != '\0') 285 send_arg (options); 286 if (date) 287 client_senddate (date); 288 if (join_orig1) 289 option_with_arg ("-j", join_orig1); 290 if (join_orig2) 291 option_with_arg ("-j", join_orig2); 292 wrap_send (); 293 294 if (failed_patches_count == 0) 295 { 296 unsigned int flags = 0; 297 298 /* If the server supports the command "update-patches", that 299 means that it knows how to handle the -u argument to update, 300 which means to send patches instead of complete files. 301 302 We don't send -u if failed_patches != NULL, so that the 303 server doesn't try to send patches which will just fail 304 again. At least currently, the client also clobbers the 305 file and tells the server it is lost, which also will get 306 a full file instead of a patch, but it seems clean to omit 307 -u. */ 308 if (supported_request ("update-patches")) 309 send_arg ("-u"); 310 311 send_arg ("--"); 312 313 if (update_build_dirs) 314 flags |= SEND_BUILD_DIRS; 315 316 if (toss_local_changes) { 317 flags |= SEND_NO_CONTENTS; 318 flags |= BACKUP_MODIFIED_FILES; 319 } 320 321 /* If noexec, probably could be setting SEND_NO_CONTENTS. 322 Same caveats as for "cvs status" apply. */ 323 324 send_files (argc, argv, local, aflag, flags); 325 send_file_names (argc, argv, SEND_EXPAND_WILD); 326 } 327 else 328 { 329 int i; 330 331 (void) printf ("%s client: refetching unpatchable files\n", 332 program_name); 333 334 if (toplevel_wd != NULL 335 && CVS_CHDIR (toplevel_wd) < 0) 336 { 337 error (1, errno, "could not chdir to %s", toplevel_wd); 338 } 339 340 send_arg ("--"); 341 342 for (i = 0; i < failed_patches_count; i++) 343 if (unlink_file (failed_patches[i]) < 0 344 && !existence_error (errno)) 345 error (0, errno, "cannot remove %s", 346 failed_patches[i]); 347 send_files (failed_patches_count, failed_patches, local, 348 aflag, update_build_dirs ? SEND_BUILD_DIRS : 0); 349 send_file_names (failed_patches_count, failed_patches, 0); 350 free_names (&failed_patches_count, failed_patches); 351 } 352 353 send_to_server ("update\012", 0); 354 355 status = get_responses_and_close (); 356 357 /* If there are any conflicts, the server will return a 358 non-zero exit status. If any patches failed, we still 359 want to run the update again. We use a pass count to 360 avoid an endless loop. */ 361 362 /* Notes: (1) assuming that status != 0 implies a 363 potential conflict is the best we can cleanly do given 364 the current protocol. I suppose that trying to 365 re-fetch in cases where there was a more serious error 366 is probably more or less harmless, but it isn't really 367 ideal. (2) it would be nice to have a testsuite case for the 368 conflict-and-patch-failed case. */ 369 370 if (status != 0 371 && (failed_patches_count == 0 || pass > 1)) 372 { 373 if (failed_patches_count > 0) 374 free_names (&failed_patches_count, failed_patches); 375 return status; 376 } 377 378 ++pass; 379 } while (failed_patches_count > 0); 380 381 return 0; 382 } 383 #endif 384 385 if (tag != NULL) 386 tag_check_valid (tag, argc, argv, local, aflag, "", false); 387 if (join_rev1 != NULL) 388 tag_check_valid (xjoin_rev1, argc, argv, local, aflag, "", false); 389 if (join_rev2 != NULL) 390 tag_check_valid (xjoin_rev2, argc, argv, local, aflag, "", false); 391 392 /* 393 * If we are updating the entire directory (for real) and building dirs 394 * as we go, we make sure there is no static entries file and write the 395 * tag file as appropriate 396 */ 397 if (argc <= 0 && !pipeout) 398 { 399 if (update_build_dirs) 400 { 401 if (unlink_file (CVSADM_ENTSTAT) < 0 && ! existence_error (errno)) 402 error (1, errno, "cannot remove file %s", CVSADM_ENTSTAT); 403 #ifdef SERVER_SUPPORT 404 if (server_active) 405 { 406 char *repos = Name_Repository (NULL, NULL); 407 server_clear_entstat (".", repos); 408 free (repos); 409 } 410 #endif 411 } 412 413 /* keep the CVS/Tag file current with the specified arguments */ 414 if (aflag || tag || date) 415 { 416 char *repos = Name_Repository (NULL, NULL); 417 WriteTag (NULL, tag, date, 0, ".", repos); 418 free (repos); 419 rewrite_tag = 1; 420 nonbranch = -1; 421 warned = 0; 422 } 423 } 424 425 /* look for files/dirs locally and in the repository */ 426 which = W_LOCAL | W_REPOS; 427 428 /* look in the attic too if a tag or date is specified */ 429 if (tag || date || join_orig1) 430 { 431 TRACE (TRACE_DATA, "update: searching attic"); 432 which |= W_ATTIC; 433 } 434 435 /* call the command line interface */ 436 err = do_update (argc, argv, options, tag, date, force_tag_match, 437 local, update_build_dirs, aflag, update_prune_dirs, 438 pipeout, which, xjoin_rev1, xjoin_date1, xjoin_rev2, 439 xjoin_date2, NULL, 1, NULL); 440 441 /* Free the space allocated for tags and dates, if necessary. */ 442 if (tag) free (tag); 443 if (date) free (date); 444 445 return err; 446 } 447 448 449 450 /* 451 * Command line interface to update (used by checkout) 452 * 453 * repository = cvsroot->repository + update_dir. This is necessary for 454 * checkout so that start_recursion can determine our repository. In the 455 * update case, start_recursion can use the CVS/Root & CVS/Repository file 456 * to determine this value. 457 */ 458 int 459 do_update (int argc, char **argv, char *xoptions, char *xtag, char *xdate, 460 int xforce, int local, int xbuild, int xaflag, int xprune, 461 int xpipeout, int which, char *xjoin_rev1, char *xjoin_date1, 462 char *xjoin_rev2, char *xjoin_date2, 463 char *preload_update_dir, int xdotemplate, char *repository) 464 { 465 int err = 0; 466 467 TRACE (TRACE_FUNCTION, 468 "do_update (%s, %s, %s, %d, %d, %d, %d, %d, %d, %d, %s, %s, %s, %s, %s, %d, %s)", 469 xoptions ? xoptions : "(null)", xtag ? xtag : "(null)", 470 xdate ? xdate : "(null)", xforce, local, xbuild, xaflag, xprune, 471 xpipeout, which, xjoin_rev1 ? xjoin_rev1 : "(null)", 472 xjoin_date1 ? xjoin_date1 : "(null)", 473 xjoin_rev2 ? xjoin_rev2 : "(null)", 474 xjoin_date2 ? xjoin_date2 : "(null)", 475 preload_update_dir ? preload_update_dir : "(null)", xdotemplate, 476 repository ? repository : "(null)"); 477 478 /* fill in the statics */ 479 options = xoptions; 480 tag = xtag; 481 date = xdate; 482 force_tag_match = xforce; 483 update_build_dirs = xbuild; 484 aflag = xaflag; 485 update_prune_dirs = xprune; 486 pipeout = xpipeout; 487 dotemplate = xdotemplate; 488 489 /* setup the join support */ 490 join_rev1 = xjoin_rev1; 491 join_date1 = xjoin_date1; 492 join_rev2 = xjoin_rev2; 493 join_date2 = xjoin_date2; 494 495 #ifdef PRESERVE_PERMISSIONS_SUPPORT 496 if (preserve_perms) 497 { 498 /* We need to do an extra recursion, bleah. It's to make sure 499 that we know as much as possible about file linkage. */ 500 hardlist = getlist(); 501 working_dir = xgetcwd (); /* save top-level working dir */ 502 503 /* FIXME-twp: the arguments to start_recursion make me dizzy. This 504 function call was copied from the update_fileproc call that 505 follows it; someone should make sure that I did it right. */ 506 err = start_recursion 507 (get_linkinfo_proc, NULL, NULL, NULL, NULL, 508 argc, argv, local, which, aflag, CVS_LOCK_READ, 509 preload_update_dir, 1, NULL); 510 if (err) 511 return err; 512 513 /* FIXME-twp: at this point we should walk the hardlist 514 and update the `links' field of each hardlink_info struct 515 to list the files that are linked on dist. That would make 516 it easier & more efficient to compare the disk linkage with 517 the repository linkage (a simple strcmp). */ 518 } 519 #endif 520 521 /* call the recursion processor */ 522 err = start_recursion (update_fileproc, update_filesdone_proc, 523 update_dirent_proc, update_dirleave_proc, NULL, 524 argc, argv, local, which, aflag, CVS_LOCK_READ, 525 preload_update_dir, 1, repository); 526 527 /* see if we need to sleep before returning to avoid time-stamp races */ 528 if (!server_active && last_register_time) 529 { 530 sleep_past (last_register_time); 531 } 532 533 return err; 534 } 535 536 537 538 #ifdef PRESERVE_PERMISSIONS_SUPPORT 539 /* 540 * The get_linkinfo_proc callback adds each file to the hardlist 541 * (see hardlink.c). 542 */ 543 544 static int 545 get_linkinfo_proc (void *callerdat, struct file_info *finfo) 546 { 547 char *fullpath; 548 Node *linkp; 549 struct hardlink_info *hlinfo; 550 551 /* Get the full pathname of the current file. */ 552 fullpath = Xasprintf ("%s/%s", working_dir, finfo->fullname); 553 554 /* To permit recursing into subdirectories, files 555 are keyed on the full pathname and not on the basename. */ 556 linkp = lookup_file_by_inode (fullpath); 557 if (linkp == NULL) 558 { 559 /* The file isn't on disk; we are probably restoring 560 a file that was removed. */ 561 return 0; 562 } 563 564 /* Create a new, empty hardlink_info node. */ 565 hlinfo = xmalloc (sizeof (struct hardlink_info)); 566 567 hlinfo->status = (Ctype) 0; /* is this dumb? */ 568 hlinfo->checked_out = 0; 569 570 linkp->data = hlinfo; 571 572 return 0; 573 } 574 #endif 575 576 577 578 /* 579 * This is the callback proc for update. It is called for each file in each 580 * directory by the recursion code. The current directory is the local 581 * instantiation. file is the file name we are to operate on. update_dir is 582 * set to the path relative to where we started (for pretty printing). 583 * repository is the repository. entries and srcfiles are the pre-parsed 584 * entries and source control files. 585 * 586 * This routine decides what needs to be done for each file and does the 587 * appropriate magic for checkout 588 */ 589 static int 590 update_fileproc (void *callerdat, struct file_info *finfo) 591 { 592 int retval, nb; 593 Ctype status; 594 Vers_TS *vers; 595 596 status = Classify_File (finfo, tag, date, options, force_tag_match, 597 aflag, &vers, pipeout); 598 599 /* Keep track of whether TAG is a branch tag. 600 Note that if it is a branch tag in some files and a nonbranch tag 601 in others, treat it as a nonbranch tag. */ 602 if (rewrite_tag 603 && tag != NULL 604 && finfo->rcs != NULL) 605 { 606 char *rev = RCS_getversion (finfo->rcs, tag, NULL, 1, NULL); 607 if (rev != NULL 608 && nonbranch != (nb = !RCS_nodeisbranch (finfo->rcs, tag))) 609 { 610 if (nonbranch >= 0 && !warned && !quiet) 611 { 612 error (0, 0, 613 "warning: %s is a branch tag in some files and a revision tag in others.", 614 tag); 615 warned = 1; 616 } 617 if (nonbranch < nb) nonbranch = nb; 618 } 619 if (rev != NULL) 620 free (rev); 621 } 622 623 if (pipeout) 624 { 625 /* 626 * We just return success without doing anything if any of the really 627 * funky cases occur 628 * 629 * If there is still a valid RCS file, do a regular checkout type 630 * operation 631 */ 632 switch (status) 633 { 634 case T_UNKNOWN: /* unknown file was explicitly asked 635 * about */ 636 case T_REMOVE_ENTRY: /* needs to be un-registered */ 637 case T_ADDED: /* added but not committed */ 638 retval = 0; 639 break; 640 case T_CONFLICT: /* old punt-type errors */ 641 retval = 1; 642 break; 643 case T_UPTODATE: /* file was already up-to-date */ 644 case T_NEEDS_MERGE: /* needs merging */ 645 case T_MODIFIED: /* locally modified */ 646 case T_REMOVED: /* removed but not committed */ 647 case T_CHECKOUT: /* needs checkout */ 648 case T_PATCH: /* needs patch */ 649 retval = checkout_file (finfo, vers, 0, 0, 0); 650 break; 651 652 default: /* can't ever happen :-) */ 653 error (0, 0, 654 "unknown file status %d for file %s", status, finfo->file); 655 retval = 0; 656 break; 657 } 658 } 659 else 660 { 661 switch (status) 662 { 663 case T_UNKNOWN: /* unknown file was explicitly asked 664 * about */ 665 case T_UPTODATE: /* file was already up-to-date */ 666 retval = 0; 667 break; 668 case T_CONFLICT: /* old punt-type errors */ 669 retval = 1; 670 write_letter (finfo, 'C'); 671 break; 672 case T_NEEDS_MERGE: /* needs merging */ 673 if (! toss_local_changes) 674 { 675 retval = merge_file (finfo, vers); 676 break; 677 } 678 /* else FALL THROUGH */ 679 case T_MODIFIED: /* locally modified */ 680 retval = 0; 681 if (toss_local_changes) 682 { 683 char *bakname; 684 bakname = backup_file (finfo->file, vers->vn_user); 685 /* This behavior is sufficiently unexpected to 686 justify overinformativeness, I think. */ 687 if (!really_quiet && !server_active) 688 (void) printf ("(Locally modified %s moved to %s)\n", 689 finfo->file, bakname); 690 free (bakname); 691 692 /* The locally modified file is still present, but 693 it will be overwritten by the repository copy 694 after this. */ 695 status = T_CHECKOUT; 696 retval = checkout_file (finfo, vers, 0, 0, 1); 697 } 698 else 699 { 700 if (vers->ts_conflict) 701 { 702 if (file_has_markers (finfo)) 703 { 704 write_letter (finfo, 'C'); 705 retval = 1; 706 } 707 else 708 { 709 /* Reregister to clear conflict flag. */ 710 Register (finfo->entries, finfo->file, 711 vers->vn_rcs, vers->ts_rcs, 712 vers->options, vers->tag, 713 vers->date, NULL); 714 } 715 } 716 if (!retval) 717 write_letter (finfo, 'M'); 718 } 719 break; 720 case T_PATCH: /* needs patch */ 721 #ifdef SERVER_SUPPORT 722 if (patches) 723 { 724 int docheckout; 725 struct stat file_info; 726 unsigned char checksum[16]; 727 728 retval = patch_file (finfo, 729 vers, &docheckout, 730 &file_info, checksum); 731 if (! docheckout) 732 { 733 if (server_active && retval == 0) 734 server_updated (finfo, vers, 735 (rcs_diff_patches 736 ? SERVER_RCS_DIFF 737 : SERVER_PATCHED), 738 file_info.st_mode, checksum, 739 NULL); 740 break; 741 } 742 } 743 #endif 744 /* If we're not running as a server, just check the 745 file out. It's simpler and faster than producing 746 and applying patches. */ 747 /* Fall through. */ 748 case T_CHECKOUT: /* needs checkout */ 749 retval = checkout_file (finfo, vers, 0, 0, 1); 750 break; 751 case T_ADDED: /* added but not committed */ 752 write_letter (finfo, 'A'); 753 retval = 0; 754 break; 755 case T_REMOVED: /* removed but not committed */ 756 write_letter (finfo, 'R'); 757 retval = 0; 758 break; 759 case T_REMOVE_ENTRY: /* needs to be un-registered */ 760 retval = scratch_file (finfo, vers); 761 break; 762 default: /* can't ever happen :-) */ 763 error (0, 0, 764 "unknown file status %d for file %s", status, finfo->file); 765 retval = 0; 766 break; 767 } 768 } 769 770 /* only try to join if things have gone well thus far */ 771 if (retval == 0 && join_rev1) 772 join_file (finfo, vers); 773 774 /* if this directory has an ignore list, add this file to it */ 775 if (ignlist && (status != T_UNKNOWN || vers->ts_user == NULL)) 776 { 777 Node *p; 778 779 p = getnode (); 780 p->type = FILES; 781 p->key = xstrdup (finfo->file); 782 if (addnode (ignlist, p) != 0) 783 freenode (p); 784 } 785 786 freevers_ts (&vers); 787 return retval; 788 } 789 790 791 792 static void 793 update_ignproc (const char *file, const char *dir) 794 { 795 struct file_info finfo; 796 char *tmp; 797 798 memset (&finfo, 0, sizeof (finfo)); 799 finfo.file = file; 800 finfo.update_dir = dir; 801 802 finfo.fullname = tmp = Xasprintf ("%s%s%s", 803 dir[0] == '\0' ? "" : dir, 804 dir[0] == '\0' ? "" : "/", 805 file); 806 write_letter (&finfo, '?'); 807 free (tmp); 808 } 809 810 811 812 /* ARGSUSED */ 813 static int 814 update_filesdone_proc (void *callerdat, int err, const char *repository, 815 const char *update_dir, List *entries) 816 { 817 if (nonbranch < 0) nonbranch = 0; 818 if (rewrite_tag) 819 { 820 WriteTag (NULL, tag, date, nonbranch, update_dir, repository); 821 rewrite_tag = 0; 822 } 823 824 /* if this directory has an ignore list, process it then free it */ 825 if (ignlist) 826 { 827 ignore_files (ignlist, entries, update_dir, update_ignproc); 828 dellist (&ignlist); 829 } 830 831 /* Clean up CVS admin dirs if we are export */ 832 if (strcmp (cvs_cmd_name, "export") == 0) 833 { 834 /* I'm not sure the existence_error is actually possible (except 835 in cases where we really should print a message), but since 836 this code used to ignore all errors, I'll play it safe. */ 837 if (unlink_file_dir (CVSADM) < 0 && !existence_error (errno)) 838 error (0, errno, "cannot remove %s directory", CVSADM); 839 } 840 else if (!server_active && !pipeout) 841 { 842 /* If there is no CVS/Root file, add one */ 843 if (!isfile (CVSADM_ROOT)) 844 Create_Root (NULL, original_parsed_root->original); 845 } 846 847 return err; 848 } 849 850 851 852 /* 853 * update_dirent_proc () is called back by the recursion processor before a 854 * sub-directory is processed for update. In this case, update_dirent proc 855 * will probably create the directory unless -d isn't specified and this is a 856 * new directory. A return code of 0 indicates the directory should be 857 * processed by the recursion code. A return of non-zero indicates the 858 * recursion code should skip this directory. 859 */ 860 static Dtype 861 update_dirent_proc (void *callerdat, const char *dir, const char *repository, 862 const char *update_dir, List *entries) 863 { 864 if (ignore_directory (update_dir)) 865 { 866 /* print the warm fuzzy message */ 867 if (!quiet) 868 error (0, 0, "Ignoring %s", update_dir); 869 return R_SKIP_ALL; 870 } 871 872 if (!isdir (dir)) 873 { 874 /* if we aren't building dirs, blow it off */ 875 if (!update_build_dirs) 876 return R_SKIP_ALL; 877 878 /* Various CVS administrators are in the habit of removing 879 the repository directory for things they don't want any 880 more. I've even been known to do it myself (on rare 881 occasions). Not the usual recommended practice, but we 882 want to try to come up with some kind of 883 reasonable/documented/sensible behavior. Generally 884 the behavior is to just skip over that directory (see 885 dirs test in sanity.sh; the case which reaches here 886 is when update -d is specified, and the working directory 887 is gone but the subdirectory is still mentioned in 888 CVS/Entries). */ 889 /* In the remote case, the client should refrain from 890 sending us the directory in the first place. So we 891 want to continue to give an error, so clients make 892 sure to do this. */ 893 if (!server_active && !isdir (repository)) 894 return R_SKIP_ALL; 895 896 if (noexec) 897 { 898 /* ignore the missing dir if -n is specified */ 899 error (0, 0, "New directory `%s' -- ignored", update_dir); 900 return R_SKIP_ALL; 901 } 902 else 903 { 904 /* otherwise, create the dir and appropriate adm files */ 905 906 /* If no tag or date were specified on the command line, 907 and we're not using -A, we want the subdirectory to use 908 the tag and date, if any, of the current directory. 909 That way, update -d will work correctly when working on 910 a branch. 911 912 We use TAG_UPDATE_DIR to undo the tag setting in 913 update_dirleave_proc. If we did not do this, we would 914 not correctly handle a working directory with multiple 915 tags (and maybe we should prohibit such working 916 directories, but they work now and we shouldn't make 917 them stop working without more thought). */ 918 if ((tag == NULL && date == NULL) && ! aflag) 919 { 920 ParseTag (&tag, &date, &nonbranch); 921 if (tag != NULL || date != NULL) 922 tag_update_dir = xstrdup (update_dir); 923 } 924 925 make_directory (dir); 926 Create_Admin (dir, update_dir, repository, tag, date, 927 /* This is a guess. We will rewrite it later 928 via WriteTag. */ 929 0, 930 0, 931 dotemplate); 932 rewrite_tag = 1; 933 nonbranch = -1; 934 warned = 0; 935 Subdir_Register (entries, NULL, dir); 936 } 937 } 938 /* Do we need to check noexec here? */ 939 else if (!pipeout) 940 { 941 char *cvsadmdir; 942 943 /* The directory exists. Check to see if it has a CVS 944 subdirectory. */ 945 946 cvsadmdir = Xasprintf ("%s/%s", dir, CVSADM); 947 948 if (!isdir (cvsadmdir)) 949 { 950 /* We cannot successfully recurse into a directory without a CVS 951 subdirectory. Generally we will have already printed 952 "? foo". */ 953 free (cvsadmdir); 954 return R_SKIP_ALL; 955 } 956 free (cvsadmdir); 957 } 958 959 /* 960 * If we are building dirs and not going to stdout, we make sure there is 961 * no static entries file and write the tag file as appropriate 962 */ 963 if (!pipeout) 964 { 965 if (update_build_dirs) 966 { 967 char *tmp = Xasprintf ("%s/%s", dir, CVSADM_ENTSTAT); 968 969 if (unlink_file (tmp) < 0 && ! existence_error (errno)) 970 error (1, errno, "cannot remove file %s", tmp); 971 #ifdef SERVER_SUPPORT 972 if (server_active) 973 server_clear_entstat (update_dir, repository); 974 #endif 975 free (tmp); 976 } 977 978 /* keep the CVS/Tag file current with the specified arguments */ 979 if (aflag || tag || date) 980 { 981 WriteTag (dir, tag, date, 0, update_dir, repository); 982 rewrite_tag = 1; 983 nonbranch = -1; 984 warned = 0; 985 } 986 987 WriteTemplate (update_dir, dotemplate, repository); 988 989 /* initialize the ignore list for this directory */ 990 ignlist = getlist (); 991 } 992 993 /* print the warm fuzzy message */ 994 if (!quiet) 995 error (0, 0, "Updating %s", update_dir); 996 997 return R_PROCESS; 998 } 999 1000 1001 1002 /* 1003 * update_dirleave_proc () is called back by the recursion code upon leaving 1004 * a directory. It will prune empty directories if needed and will execute 1005 * any appropriate update programs. 1006 */ 1007 /* ARGSUSED */ 1008 static int 1009 update_dirleave_proc (void *callerdat, const char *dir, int err, 1010 const char *update_dir, List *entries) 1011 { 1012 /* Delete the ignore list if it hasn't already been done. */ 1013 if (ignlist) 1014 dellist (&ignlist); 1015 1016 /* If we set the tag or date for a new subdirectory in 1017 update_dirent_proc, and we're now done with that subdirectory, 1018 undo the tag/date setting. Note that we know that the tag and 1019 date were both originally NULL in this case. */ 1020 if (tag_update_dir != NULL && strcmp (update_dir, tag_update_dir) == 0) 1021 { 1022 if (tag != NULL) 1023 { 1024 free (tag); 1025 tag = NULL; 1026 } 1027 if (date != NULL) 1028 { 1029 free (date); 1030 date = NULL; 1031 } 1032 nonbranch = -1; 1033 warned = 0; 1034 free (tag_update_dir); 1035 tag_update_dir = NULL; 1036 } 1037 1038 if (strchr (dir, '/') == NULL) 1039 { 1040 /* FIXME: chdir ("..") loses with symlinks. */ 1041 /* Prune empty dirs on the way out - if necessary */ 1042 (void) CVS_CHDIR (".."); 1043 if (update_prune_dirs && isemptydir (dir, 0)) 1044 { 1045 /* I'm not sure the existence_error is actually possible (except 1046 in cases where we really should print a message), but since 1047 this code used to ignore all errors, I'll play it safe. */ 1048 if (unlink_file_dir (dir) < 0 && !existence_error (errno)) 1049 error (0, errno, "cannot remove %s directory", dir); 1050 Subdir_Deregister (entries, NULL, dir); 1051 } 1052 } 1053 1054 return err; 1055 } 1056 1057 1058 1059 /* Returns 1 if the file indicated by node has been removed. */ 1060 static int 1061 isremoved (Node *node, void *closure) 1062 { 1063 Entnode *entdata = node->data; 1064 1065 /* If the first character of the version is a '-', the file has been 1066 removed. */ 1067 return (entdata->version && entdata->version[0] == '-') ? 1 : 0; 1068 } 1069 1070 1071 1072 /* Returns 1 if the argument directory is completely empty, other than the 1073 existence of the CVS directory entry. Zero otherwise. If MIGHT_NOT_EXIST 1074 and the directory doesn't exist, then just return 0. */ 1075 int 1076 isemptydir (const char *dir, int might_not_exist) 1077 { 1078 DIR *dirp; 1079 struct dirent *dp; 1080 1081 if ((dirp = CVS_OPENDIR (dir)) == NULL) 1082 { 1083 if (might_not_exist && existence_error (errno)) 1084 return 0; 1085 error (0, errno, "cannot open directory %s for empty check", dir); 1086 return 0; 1087 } 1088 errno = 0; 1089 while ((dp = CVS_READDIR (dirp)) != NULL) 1090 { 1091 if (strcmp (dp->d_name, ".") != 0 1092 && strcmp (dp->d_name, "..") != 0) 1093 { 1094 if (strcmp (dp->d_name, CVSADM) != 0) 1095 { 1096 /* An entry other than the CVS directory. The directory 1097 is certainly not empty. */ 1098 (void) CVS_CLOSEDIR (dirp); 1099 return 0; 1100 } 1101 else 1102 { 1103 /* The CVS directory entry. We don't have to worry about 1104 this unless the Entries file indicates that files have 1105 been removed, but not committed, in this directory. 1106 (Removing the directory would prevent people from 1107 comitting the fact that they removed the files!) */ 1108 List *l; 1109 int files_removed; 1110 struct saved_cwd cwd; 1111 1112 if (save_cwd (&cwd)) 1113 error (1, errno, "Failed to save current directory."); 1114 1115 if (CVS_CHDIR (dir) < 0) 1116 error (1, errno, "cannot change directory to %s", dir); 1117 l = Entries_Open (0, NULL); 1118 files_removed = walklist (l, isremoved, 0); 1119 Entries_Close (l); 1120 1121 if (restore_cwd (&cwd)) 1122 error (1, errno, 1123 "Failed to restore current directory, `%s'.", 1124 cwd.name); 1125 free_cwd (&cwd); 1126 1127 if (files_removed != 0) 1128 { 1129 /* There are files that have been removed, but not 1130 committed! Do not consider the directory empty. */ 1131 (void) CVS_CLOSEDIR (dirp); 1132 return 0; 1133 } 1134 } 1135 } 1136 errno = 0; 1137 } 1138 if (errno != 0) 1139 { 1140 error (0, errno, "cannot read directory %s", dir); 1141 (void) CVS_CLOSEDIR (dirp); 1142 return 0; 1143 } 1144 (void) CVS_CLOSEDIR (dirp); 1145 return 1; 1146 } 1147 1148 1149 1150 /* 1151 * scratch the Entries file entry associated with a file 1152 */ 1153 static int 1154 scratch_file (struct file_info *finfo, Vers_TS *vers) 1155 { 1156 history_write ('W', finfo->update_dir, "", finfo->file, finfo->repository); 1157 Scratch_Entry (finfo->entries, finfo->file); 1158 #ifdef SERVER_SUPPORT 1159 if (server_active) 1160 { 1161 if (vers->ts_user == NULL) 1162 server_scratch_entry_only (); 1163 server_updated (finfo, vers, SERVER_UPDATED, (mode_t) -1, NULL, NULL); 1164 } 1165 #endif 1166 if (unlink_file (finfo->file) < 0 && ! existence_error (errno)) 1167 error (0, errno, "unable to remove %s", finfo->fullname); 1168 else if (!server_active) 1169 { 1170 /* skip this step when the server is running since 1171 * server_updated should have handled it */ 1172 /* keep the vers structure up to date in case we do a join 1173 * - if there isn't a file, it can't very well have a version number, can it? 1174 */ 1175 if (vers->vn_user != NULL) 1176 { 1177 free (vers->vn_user); 1178 vers->vn_user = NULL; 1179 } 1180 if (vers->ts_user != NULL) 1181 { 1182 free (vers->ts_user); 1183 vers->ts_user = NULL; 1184 } 1185 } 1186 return 0; 1187 } 1188 1189 1190 1191 /* 1192 * Check out a file. 1193 */ 1194 static int 1195 checkout_file (struct file_info *finfo, Vers_TS *vers_ts, int adding, 1196 int merging, int update_server) 1197 { 1198 char *backup; 1199 int set_time, retval = 0; 1200 int status; 1201 int file_is_dead; 1202 struct buffer *revbuf; 1203 1204 backup = NULL; 1205 revbuf = NULL; 1206 1207 /* Don't screw with backup files if we're going to stdout, or if 1208 we are the server. */ 1209 if (!pipeout && !server_active) 1210 { 1211 backup = Xasprintf ("%s/%s%s", CVSADM, CVSPREFIX, finfo->file); 1212 if (isfile (finfo->file)) 1213 rename_file (finfo->file, backup); 1214 else 1215 { 1216 /* If -f/-t wrappers are being used to wrap up a directory, 1217 then backup might be a directory instead of just a file. */ 1218 if (unlink_file_dir (backup) < 0) 1219 { 1220 /* Not sure if the existence_error check is needed here. */ 1221 if (!existence_error (errno)) 1222 /* FIXME: should include update_dir in message. */ 1223 error (0, errno, "error removing %s", backup); 1224 } 1225 free (backup); 1226 backup = NULL; 1227 } 1228 } 1229 1230 file_is_dead = RCS_isdead (vers_ts->srcfile, vers_ts->vn_rcs); 1231 1232 if (!file_is_dead) 1233 { 1234 /* 1235 * if we are checking out to stdout, print a nice message to 1236 * stderr, and add the -p flag to the command */ 1237 if (pipeout) 1238 { 1239 if (!quiet) 1240 { 1241 cvs_outerr ("\ 1242 ===================================================================\n\ 1243 Checking out ", 0); 1244 cvs_outerr (finfo->fullname, 0); 1245 cvs_outerr ("\n\ 1246 RCS: ", 0); 1247 cvs_outerr (vers_ts->srcfile->print_path, 0); 1248 cvs_outerr ("\n\ 1249 VERS: ", 0); 1250 cvs_outerr (vers_ts->vn_rcs, 0); 1251 cvs_outerr ("\n***************\n", 0); 1252 } 1253 } 1254 1255 #ifdef SERVER_SUPPORT 1256 if (update_server 1257 && server_active 1258 && ! pipeout 1259 && ! file_gzip_level 1260 && ! joining () 1261 && ! wrap_name_has (finfo->file, WRAP_FROMCVS)) 1262 { 1263 revbuf = buf_nonio_initialize (NULL); 1264 status = RCS_checkout (vers_ts->srcfile, NULL, 1265 vers_ts->vn_rcs, vers_ts->tag, 1266 vers_ts->options, RUN_TTY, 1267 checkout_to_buffer, revbuf); 1268 } 1269 else 1270 #endif 1271 status = RCS_checkout (vers_ts->srcfile, 1272 pipeout ? NULL : finfo->file, 1273 vers_ts->vn_rcs, vers_ts->tag, 1274 vers_ts->options, RUN_TTY, NULL, NULL); 1275 } 1276 if (file_is_dead || status == 0) 1277 { 1278 mode_t mode; 1279 1280 mode = (mode_t) -1; 1281 1282 if (!pipeout) 1283 { 1284 Vers_TS *xvers_ts; 1285 1286 if (revbuf != NULL && !noexec) 1287 { 1288 struct stat sb; 1289 1290 /* FIXME: We should have RCS_checkout return the mode. 1291 That would also fix the kludge with noexec, above, which 1292 is here only because noexec doesn't write srcfile->path 1293 for us to stat. */ 1294 if (stat (vers_ts->srcfile->path, &sb) < 0) 1295 { 1296 #if defined (SERVER_SUPPORT) || defined (CLIENT_SUPPORT) 1297 buf_free (revbuf); 1298 #endif /* defined (SERVER_SUPPORT) || defined (CLIENT_SUPPORT) */ 1299 error (1, errno, "cannot stat %s", 1300 vers_ts->srcfile->path); 1301 } 1302 mode = sb.st_mode &~ (S_IWRITE | S_IWGRP | S_IWOTH); 1303 } 1304 1305 if (cvswrite 1306 && !file_is_dead 1307 && !fileattr_get (finfo->file, "_watched")) 1308 { 1309 if (revbuf == NULL) 1310 xchmod (finfo->file, 1); 1311 else 1312 { 1313 mode_t oumask, writeaccess; 1314 1315 /* We know that we are the server here, so 1316 although xchmod checks umask, we don't bother. */ 1317 /* Not bothering with the umask makes the files 1318 mode 0777 on old clients, though. -chb */ 1319 oumask = umask(0); 1320 (void) umask(oumask); 1321 writeaccess = (((mode & S_IRUSR) ? S_IWUSR : 0) 1322 | ((mode & S_IRGRP) ? S_IWGRP : 0) 1323 | ((mode & S_IROTH) ? S_IWOTH : 0)); 1324 mode |= (~oumask) & writeaccess; 1325 } 1326 } 1327 1328 { 1329 /* A newly checked out file is never under the spell 1330 of "cvs edit". If we think we were editing it 1331 from a previous life, clean up. Would be better to 1332 check for same the working directory instead of 1333 same user, but that is hairy. */ 1334 1335 struct addremove_args args; 1336 1337 editor_set (finfo->file, getcaller (), NULL); 1338 1339 memset (&args, 0, sizeof args); 1340 args.remove_temp = 1; 1341 watch_modify_watchers (finfo->file, &args); 1342 } 1343 1344 /* set the time from the RCS file iff it was unknown before */ 1345 set_time = 1346 (!noexec 1347 && (vers_ts->vn_user == NULL || 1348 strncmp (vers_ts->ts_rcs, "Initial", 7) == 0) 1349 && !file_is_dead); 1350 1351 wrap_fromcvs_process_file (finfo->file); 1352 1353 xvers_ts = Version_TS (finfo, options, tag, date, 1354 force_tag_match, set_time); 1355 if (strcmp (xvers_ts->options, "-V4") == 0) 1356 xvers_ts->options[0] = '\0'; 1357 1358 if (revbuf != NULL) 1359 { 1360 /* If we stored the file data into a buffer, then we 1361 didn't create a file at all, so xvers_ts->ts_user 1362 is wrong. The correct value is to have it be the 1363 same as xvers_ts->ts_rcs, meaning that the working 1364 file is unchanged from the RCS file. 1365 1366 FIXME: We should tell Version_TS not to waste time 1367 statting the nonexistent file. 1368 1369 FIXME: Actually, I don't think the ts_user value 1370 matters at all here. The only use I know of is 1371 that it is printed in a trace message by 1372 Server_Register. */ 1373 1374 if (xvers_ts->ts_user != NULL) 1375 free (xvers_ts->ts_user); 1376 xvers_ts->ts_user = xstrdup (xvers_ts->ts_rcs); 1377 } 1378 1379 (void) time (&last_register_time); 1380 1381 if (file_is_dead) 1382 { 1383 if (xvers_ts->vn_user != NULL) 1384 { 1385 error (0, 0, 1386 "warning: %s is not (any longer) pertinent", 1387 finfo->fullname); 1388 } 1389 Scratch_Entry (finfo->entries, finfo->file); 1390 #ifdef SERVER_SUPPORT 1391 if (server_active && xvers_ts->ts_user == NULL) 1392 server_scratch_entry_only (); 1393 #endif 1394 /* FIXME: Rather than always unlink'ing, and ignoring the 1395 existence_error, we should do the unlink only if 1396 vers_ts->ts_user is non-NULL. Then there would be no 1397 need to ignore an existence_error (for example, if the 1398 user removes the file while we are running). */ 1399 if (unlink_file (finfo->file) < 0 && ! existence_error (errno)) 1400 { 1401 error (0, errno, "cannot remove %s", finfo->fullname); 1402 } 1403 } 1404 else 1405 Register (finfo->entries, finfo->file, 1406 adding ? "0" : xvers_ts->vn_rcs, 1407 xvers_ts->ts_user, xvers_ts->options, 1408 xvers_ts->tag, xvers_ts->date, 1409 NULL); /* Clear conflict flag on fresh checkout */ 1410 1411 /* fix up the vers structure, in case it is used by join */ 1412 if (join_rev1) 1413 { 1414 /* FIXME: Throwing away the original revision info is almost 1415 certainly wrong -- what if join_rev1 is "BASE"? */ 1416 if (vers_ts->vn_user != NULL) 1417 free (vers_ts->vn_user); 1418 if (vers_ts->vn_rcs != NULL) 1419 free (vers_ts->vn_rcs); 1420 vers_ts->vn_user = xstrdup (xvers_ts->vn_rcs); 1421 vers_ts->vn_rcs = xstrdup (xvers_ts->vn_rcs); 1422 } 1423 1424 /* If this is really Update and not Checkout, recode history */ 1425 if (strcmp (cvs_cmd_name, "update") == 0) 1426 history_write ('U', finfo->update_dir, xvers_ts->vn_rcs, finfo->file, 1427 finfo->repository); 1428 1429 freevers_ts (&xvers_ts); 1430 1431 if (!really_quiet && !file_is_dead) 1432 { 1433 write_letter (finfo, 'U'); 1434 } 1435 } 1436 1437 #ifdef SERVER_SUPPORT 1438 if (update_server && server_active) 1439 server_updated (finfo, vers_ts, 1440 merging ? SERVER_MERGED : SERVER_UPDATED, 1441 mode, NULL, revbuf); 1442 #endif 1443 } 1444 else 1445 { 1446 if (backup != NULL) 1447 { 1448 rename_file (backup, finfo->file); 1449 free (backup); 1450 backup = NULL; 1451 } 1452 1453 error (0, 0, "could not check out %s", finfo->fullname); 1454 1455 retval = status; 1456 } 1457 1458 if (backup != NULL) 1459 { 1460 /* If -f/-t wrappers are being used to wrap up a directory, 1461 then backup might be a directory instead of just a file. */ 1462 if (unlink_file_dir (backup) < 0) 1463 { 1464 /* Not sure if the existence_error check is needed here. */ 1465 if (!existence_error (errno)) 1466 /* FIXME: should include update_dir in message. */ 1467 error (0, errno, "error removing %s", backup); 1468 } 1469 free (backup); 1470 } 1471 1472 #if defined (SERVER_SUPPORT) || defined (CLIENT_SUPPORT) 1473 if (revbuf != NULL) 1474 buf_free (revbuf); 1475 #endif /* defined (SERVER_SUPPORT) || defined (CLIENT_SUPPORT) */ 1476 return retval; 1477 } 1478 1479 1480 1481 #ifdef SERVER_SUPPORT 1482 1483 /* This function is used to write data from a file being checked out 1484 into a buffer. */ 1485 1486 static void 1487 checkout_to_buffer (void *callerdat, const char *data, size_t len) 1488 { 1489 struct buffer *buf = (struct buffer *) callerdat; 1490 1491 buf_output (buf, data, len); 1492 } 1493 1494 #endif /* SERVER_SUPPORT */ 1495 1496 #ifdef SERVER_SUPPORT 1497 1498 /* This structure is used to pass information between patch_file and 1499 patch_file_write. */ 1500 1501 struct patch_file_data 1502 { 1503 /* File name, for error messages. */ 1504 const char *filename; 1505 /* File to which to write. */ 1506 FILE *fp; 1507 /* Whether to compute the MD5 checksum. */ 1508 int compute_checksum; 1509 /* Data structure for computing the MD5 checksum. */ 1510 struct md5_ctx context; 1511 /* Set if the file has a final newline. */ 1512 int final_nl; 1513 }; 1514 1515 /* Patch a file. Runs diff. This is only done when running as the 1516 * server. The hope is that the diff will be smaller than the file 1517 * itself. 1518 */ 1519 static int 1520 patch_file (struct file_info *finfo, Vers_TS *vers_ts, int *docheckout, 1521 struct stat *file_info, unsigned char *checksum) 1522 { 1523 char *backup; 1524 char *file1; 1525 char *file2; 1526 int retval = 0; 1527 int retcode = 0; 1528 int fail; 1529 FILE *e; 1530 struct patch_file_data data; 1531 1532 *docheckout = 0; 1533 1534 if (noexec || pipeout || joining ()) 1535 { 1536 *docheckout = 1; 1537 return 0; 1538 } 1539 1540 /* If this file has been marked as being binary, then never send a 1541 patch. */ 1542 if (strcmp (vers_ts->options, "-kb") == 0) 1543 { 1544 *docheckout = 1; 1545 return 0; 1546 } 1547 1548 /* First check that the first revision exists. If it has been nuked 1549 by cvs admin -o, then just fall back to checking out entire 1550 revisions. In some sense maybe we don't have to do this; after 1551 all cvs.texinfo says "Make sure that no-one has checked out a 1552 copy of the revision you outdate" but then again, that advice 1553 doesn't really make complete sense, because "cvs admin" operates 1554 on a working directory and so _someone_ will almost always have 1555 _some_ revision checked out. */ 1556 { 1557 char *rev; 1558 1559 rev = RCS_gettag (finfo->rcs, vers_ts->vn_user, 1, NULL); 1560 if (rev == NULL) 1561 { 1562 *docheckout = 1; 1563 return 0; 1564 } 1565 else 1566 free (rev); 1567 } 1568 1569 /* If the revision is dead, let checkout_file handle it rather 1570 than duplicating the processing here. */ 1571 if (RCS_isdead (vers_ts->srcfile, vers_ts->vn_rcs)) 1572 { 1573 *docheckout = 1; 1574 return 0; 1575 } 1576 1577 backup = Xasprintf ("%s/%s%s", CVSADM, CVSPREFIX, finfo->file); 1578 if (isfile (finfo->file)) 1579 rename_file (finfo->file, backup); 1580 else 1581 { 1582 if (unlink_file (backup) < 0 1583 && !existence_error (errno)) 1584 error (0, errno, "cannot remove %s", backup); 1585 } 1586 1587 file1 = Xasprintf ("%s/%s%s-1", CVSADM, CVSPREFIX, finfo->file); 1588 file2 = Xasprintf ("%s/%s%s-2", CVSADM, CVSPREFIX, finfo->file); 1589 1590 fail = 0; 1591 1592 /* We need to check out both revisions first, to see if either one 1593 has a trailing newline. Because of this, we don't use rcsdiff, 1594 but just use diff. */ 1595 1596 e = CVS_FOPEN (file1, "w"); 1597 if (e == NULL) 1598 error (1, errno, "cannot open %s", file1); 1599 1600 data.filename = file1; 1601 data.fp = e; 1602 data.final_nl = 0; 1603 data.compute_checksum = 0; 1604 1605 /* FIXME - Passing vers_ts->tag here is wrong in the least number 1606 * of cases. Since we don't know whether vn_user was checked out 1607 * using a tag, we pass vers_ts->tag, which, assuming the user did 1608 * not specify a new TAG to -r, will be the branch we are on. 1609 * 1610 * The only thing it is used for is to substitute in for the Name 1611 * RCS keyword, so in the error case, the patch fails to apply on 1612 * the client end and we end up resending the whole file. 1613 * 1614 * At least, if we are keeping track of the tag vn_user came from, 1615 * I don't know where yet. -DRP 1616 */ 1617 retcode = RCS_checkout (vers_ts->srcfile, NULL, 1618 vers_ts->vn_user, vers_ts->tag, 1619 vers_ts->options, RUN_TTY, 1620 patch_file_write, (void *) &data); 1621 1622 if (fclose (e) < 0) 1623 error (1, errno, "cannot close %s", file1); 1624 1625 if (retcode != 0 || ! data.final_nl) 1626 fail = 1; 1627 1628 if (! fail) 1629 { 1630 e = CVS_FOPEN (file2, "w"); 1631 if (e == NULL) 1632 error (1, errno, "cannot open %s", file2); 1633 1634 data.filename = file2; 1635 data.fp = e; 1636 data.final_nl = 0; 1637 data.compute_checksum = 1; 1638 md5_init_ctx (&data.context); 1639 1640 retcode = RCS_checkout (vers_ts->srcfile, NULL, 1641 vers_ts->vn_rcs, vers_ts->tag, 1642 vers_ts->options, RUN_TTY, 1643 patch_file_write, (void *) &data); 1644 1645 if (fclose (e) < 0) 1646 error (1, errno, "cannot close %s", file2); 1647 1648 if (retcode != 0 || ! data.final_nl) 1649 fail = 1; 1650 else 1651 md5_finish_ctx (&data.context, checksum); 1652 } 1653 1654 retcode = 0; 1655 if (! fail) 1656 { 1657 int dargc = 0; 1658 size_t darg_allocated = 0; 1659 char **dargv = NULL; 1660 1661 /* If the client does not support the Rcs-diff command, we 1662 send a context diff, and the client must invoke patch. 1663 That approach was problematical for various reasons. The 1664 new approach only requires running diff in the server; the 1665 client can handle everything without invoking an external 1666 program. */ 1667 if (!rcs_diff_patches) 1668 /* We use -c, not -u, because that is what CVS has 1669 traditionally used. Kind of a moot point, now that 1670 Rcs-diff is preferred, so there is no point in making 1671 the compatibility issues worse. */ 1672 run_add_arg_p (&dargc, &darg_allocated, &dargv, "-c"); 1673 else 1674 /* Now that diff is librarified, we could be passing -a if 1675 we wanted to. However, it is unclear to me whether we 1676 would want to. Does diff -a, in any significant 1677 percentage of cases, produce patches which are smaller 1678 than the files it is patching? I guess maybe text 1679 files with character sets which diff regards as 1680 'binary'. Conversely, do they tend to be much larger 1681 in the bad cases? This needs some more 1682 thought/investigation, I suspect. */ 1683 run_add_arg_p (&dargc, &darg_allocated, &dargv, "-n"); 1684 retcode = diff_exec (file1, file2, NULL, NULL, dargc, dargv, 1685 finfo->file); 1686 run_arg_free_p (dargc, dargv); 1687 free (dargv); 1688 1689 /* A retcode of 0 means no differences. 1 means some differences. */ 1690 if (retcode != 0 && retcode != 1) 1691 fail = 1; 1692 } 1693 1694 if (!fail) 1695 { 1696 struct stat file2_info; 1697 1698 /* Check to make sure the patch is really shorter */ 1699 if (stat (file2, &file2_info) < 0) 1700 error (1, errno, "could not stat %s", file2); 1701 if (stat (finfo->file, file_info) < 0) 1702 error (1, errno, "could not stat %s", finfo->file); 1703 if (file2_info.st_size <= file_info->st_size) 1704 fail = 1; 1705 } 1706 1707 if (! fail) 1708 { 1709 # define BINARY "Binary" 1710 char buf[sizeof BINARY]; 1711 unsigned int c; 1712 1713 /* Check the diff output to make sure patch will be handle it. */ 1714 e = CVS_FOPEN (finfo->file, "r"); 1715 if (e == NULL) 1716 error (1, errno, "could not open diff output file %s", 1717 finfo->fullname); 1718 c = fread (buf, 1, sizeof BINARY - 1, e); 1719 buf[c] = '\0'; 1720 if (strcmp (buf, BINARY) == 0) 1721 { 1722 /* These are binary files. We could use diff -a, but 1723 patch can't handle that. */ 1724 fail = 1; 1725 } 1726 fclose (e); 1727 } 1728 1729 if (! fail) 1730 { 1731 Vers_TS *xvers_ts; 1732 1733 /* Stat the original RCS file, and then adjust it the way 1734 that RCS_checkout would. FIXME: This is an abstraction 1735 violation. */ 1736 if (stat (vers_ts->srcfile->path, file_info) < 0) 1737 error (1, errno, "could not stat %s", vers_ts->srcfile->path); 1738 if (chmod (finfo->file, 1739 file_info->st_mode & ~(S_IWRITE | S_IWGRP | S_IWOTH)) 1740 < 0) 1741 error (0, errno, "cannot change mode of file %s", finfo->file); 1742 if (cvswrite 1743 && !fileattr_get (finfo->file, "_watched")) 1744 xchmod (finfo->file, 1); 1745 1746 /* This stuff is just copied blindly from checkout_file. I 1747 don't really know what it does. */ 1748 xvers_ts = Version_TS (finfo, options, tag, date, 1749 force_tag_match, 0); 1750 if (strcmp (xvers_ts->options, "-V4") == 0) 1751 xvers_ts->options[0] = '\0'; 1752 1753 Register (finfo->entries, finfo->file, xvers_ts->vn_rcs, 1754 xvers_ts->ts_user, xvers_ts->options, 1755 xvers_ts->tag, xvers_ts->date, NULL); 1756 1757 if (stat (finfo->file, file_info) < 0) 1758 error (1, errno, "could not stat %s", finfo->file); 1759 1760 /* If this is really Update and not Checkout, record history. */ 1761 if (strcmp (cvs_cmd_name, "update") == 0) 1762 history_write ('P', finfo->update_dir, xvers_ts->vn_rcs, 1763 finfo->file, finfo->repository); 1764 1765 freevers_ts (&xvers_ts); 1766 1767 if (!really_quiet) 1768 { 1769 write_letter (finfo, 'P'); 1770 } 1771 } 1772 else 1773 { 1774 int old_errno = errno; /* save errno value over the rename */ 1775 1776 if (isfile (backup)) 1777 rename_file (backup, finfo->file); 1778 1779 if (retcode != 0 && retcode != 1) 1780 error (retcode == -1 ? 1 : 0, retcode == -1 ? old_errno : 0, 1781 "could not diff %s", finfo->fullname); 1782 1783 *docheckout = 1; 1784 retval = retcode; 1785 } 1786 1787 if (unlink_file (backup) < 0 1788 && !existence_error (errno)) 1789 error (0, errno, "cannot remove %s", backup); 1790 if (unlink_file (file1) < 0 1791 && !existence_error (errno)) 1792 error (0, errno, "cannot remove %s", file1); 1793 if (unlink_file (file2) < 0 1794 && !existence_error (errno)) 1795 error (0, errno, "cannot remove %s", file2); 1796 1797 free (backup); 1798 free (file1); 1799 free (file2); 1800 return retval; 1801 } 1802 1803 1804 1805 /* Write data to a file. Record whether the last byte written was a 1806 newline. Optionally compute a checksum. This is called by 1807 patch_file via RCS_checkout. */ 1808 1809 static void 1810 patch_file_write (void *callerdat, const char *buffer, size_t len) 1811 { 1812 struct patch_file_data *data = (struct patch_file_data *) callerdat; 1813 1814 if (fwrite (buffer, 1, len, data->fp) != len) 1815 error (1, errno, "cannot write %s", data->filename); 1816 1817 data->final_nl = (buffer[len - 1] == '\n'); 1818 1819 if (data->compute_checksum) 1820 md5_process_bytes (buffer, len, &data->context); 1821 } 1822 1823 #endif /* SERVER_SUPPORT */ 1824 1825 /* 1826 * Several of the types we process only print a bit of information consisting 1827 * of a single letter and the name. 1828 */ 1829 void 1830 write_letter (struct file_info *finfo, int letter) 1831 { 1832 if (!really_quiet) 1833 { 1834 char *tag = NULL; 1835 /* Big enough for "+updated" or any of its ilk. */ 1836 char buf[80]; 1837 1838 switch (letter) 1839 { 1840 case 'U': 1841 tag = "updated"; 1842 break; 1843 default: 1844 /* We don't yet support tagged output except for "U". */ 1845 break; 1846 } 1847 1848 if (tag != NULL) 1849 { 1850 sprintf (buf, "+%s", tag); 1851 cvs_output_tagged (buf, NULL); 1852 } 1853 buf[0] = letter; 1854 buf[1] = ' '; 1855 buf[2] = '\0'; 1856 cvs_output_tagged ("text", buf); 1857 cvs_output_tagged ("fname", finfo->fullname); 1858 cvs_output_tagged ("newline", NULL); 1859 if (tag != NULL) 1860 { 1861 sprintf (buf, "-%s", tag); 1862 cvs_output_tagged (buf, NULL); 1863 } 1864 } 1865 return; 1866 } 1867 1868 1869 1870 /* Reregister a file after a merge. */ 1871 static void 1872 RegisterMerge (struct file_info *finfo, Vers_TS *vers, 1873 const char *backup, int has_conflicts) 1874 { 1875 /* This file is the result of a merge, which means that it has 1876 been modified. We use a special timestamp string which will 1877 not compare equal to any actual timestamp. */ 1878 char *cp = NULL; 1879 1880 if (has_conflicts) 1881 { 1882 time (&last_register_time); 1883 cp = time_stamp (finfo->file); 1884 } 1885 Register (finfo->entries, finfo->file, vers->vn_rcs ? vers->vn_rcs : "0", 1886 "Result of merge", vers->options, vers->tag, vers->date, cp); 1887 if (cp) 1888 free (cp); 1889 1890 #ifdef SERVER_SUPPORT 1891 /* Send the new contents of the file before the message. If we 1892 wanted to be totally correct, we would have the client write 1893 the message only after the file has safely been written. */ 1894 if (server_active) 1895 { 1896 server_copy_file (finfo->file, finfo->update_dir, finfo->repository, 1897 backup); 1898 server_updated (finfo, vers, SERVER_MERGED, (mode_t) -1, NULL, NULL); 1899 } 1900 #endif 1901 } 1902 1903 1904 1905 /* 1906 * Do all the magic associated with a file which needs to be merged 1907 */ 1908 static int 1909 merge_file (struct file_info *finfo, Vers_TS *vers) 1910 { 1911 char *backup; 1912 int status; 1913 int retval; 1914 1915 assert (vers->vn_user); 1916 1917 /* 1918 * The users currently modified file is moved to a backup file name 1919 * ".#filename.version", so that it will stay around for a few days 1920 * before being automatically removed by some cron daemon. The "version" 1921 * is the version of the file that the user was most up-to-date with 1922 * before the merge. 1923 */ 1924 backup = Xasprintf ("%s%s.%s", BAKPREFIX, finfo->file, vers->vn_user); 1925 1926 if (unlink_file (backup) && !existence_error (errno)) 1927 error (0, errno, "unable to remove %s", backup); 1928 copy_file (finfo->file, backup); 1929 xchmod (finfo->file, 1); 1930 1931 if (strcmp (vers->options, "-kb") == 0 1932 || wrap_merge_is_copy (finfo->file) 1933 || special_file_mismatch (finfo, NULL, vers->vn_rcs)) 1934 { 1935 /* For binary files, a merge is always a conflict. Same for 1936 files whose permissions or linkage do not match. We give the 1937 user the two files, and let them resolve it. It is possible 1938 that we should require a "touch foo" or similar step before 1939 we allow a checkin. */ 1940 1941 /* TODO: it may not always be necessary to regard a permission 1942 mismatch as a conflict. The working file and the RCS file 1943 have a common ancestor `A'; if the working file's permissions 1944 match A's, then it's probably safe to overwrite them with the 1945 RCS permissions. Only if the working file, the RCS file, and 1946 A all disagree should this be considered a conflict. But more 1947 thought needs to go into this, and in the meantime it is safe 1948 to treat any such mismatch as an automatic conflict. -twp */ 1949 1950 status = RCS_checkout (finfo->rcs, finfo->file, vers->vn_rcs, 1951 vers->tag, vers->options, NULL, NULL, NULL); 1952 if (status) 1953 { 1954 error (0, 0, "failed to check out `%s' file", finfo->fullname); 1955 error (0, 0, "restoring `%s' from backup file `%s'", 1956 finfo->fullname, backup); 1957 rename_file (backup, finfo->file); 1958 retval = 1; 1959 goto out; 1960 } 1961 1962 xchmod (finfo->file, 1); 1963 1964 RegisterMerge (finfo, vers, backup, 1); 1965 1966 /* Is there a better term than "nonmergeable file"? What we 1967 really mean is, not something that CVS cannot or does not 1968 want to merge (there might be an external manual or 1969 automatic merge process). */ 1970 error (0, 0, "nonmergeable file needs merge"); 1971 error (0, 0, "revision %s from repository is now in %s", 1972 vers->vn_rcs, finfo->fullname); 1973 error (0, 0, "file from working directory is now in %s", backup); 1974 write_letter (finfo, 'C'); 1975 1976 history_write ('C', finfo->update_dir, vers->vn_rcs, finfo->file, 1977 finfo->repository); 1978 retval = 0; 1979 goto out; 1980 } 1981 1982 status = RCS_merge (finfo->rcs, vers->srcfile->path, finfo->file, 1983 vers->options, vers->vn_user, vers->vn_rcs); 1984 if (status != 0 && status != 1) 1985 { 1986 error (0, status == -1 ? errno : 0, 1987 "could not merge revision %s of %s", vers->vn_user, finfo->fullname); 1988 error (status == -1 ? 1 : 0, 0, "restoring %s from backup file %s", 1989 finfo->fullname, backup); 1990 rename_file (backup, finfo->file); 1991 retval = 1; 1992 goto out; 1993 } 1994 1995 if (strcmp (vers->options, "-V4") == 0) 1996 vers->options[0] = '\0'; 1997 1998 /* fix up the vers structure, in case it is used by join */ 1999 if (join_rev1) 2000 { 2001 /* FIXME: Throwing away the original revision info is almost 2002 certainly wrong -- what if join_rev1 is "BASE"? */ 2003 if (vers->vn_user != NULL) 2004 free (vers->vn_user); 2005 vers->vn_user = xstrdup (vers->vn_rcs); 2006 } 2007 2008 RegisterMerge (finfo, vers, backup, status); 2009 2010 if (status == 1) 2011 { 2012 error (0, 0, "conflicts found in %s", finfo->fullname); 2013 2014 write_letter (finfo, 'C'); 2015 2016 history_write ('C', finfo->update_dir, vers->vn_rcs, finfo->file, 2017 finfo->repository); 2018 2019 } 2020 else /* status == 0 */ 2021 { 2022 history_write ('G', finfo->update_dir, vers->vn_rcs, finfo->file, 2023 finfo->repository); 2024 2025 /* FIXME: the noexec case is broken. RCS_merge could be doing the 2026 xcmp on the temporary files without much hassle, I think. */ 2027 if (!noexec && !xcmp (backup, finfo->file)) 2028 { 2029 cvs_output (finfo->fullname, 0); 2030 cvs_output (" already contains the differences between ", 0); 2031 cvs_output (vers->vn_user, 0); 2032 cvs_output (" and ", 0); 2033 cvs_output (vers->vn_rcs, 0); 2034 cvs_output ("\n", 1); 2035 2036 retval = 0; 2037 goto out; 2038 } 2039 2040 write_letter (finfo, 'M'); 2041 } 2042 retval = 0; 2043 out: 2044 free (backup); 2045 return retval; 2046 } 2047 2048 2049 2050 /* 2051 * Do all the magic associated with a file which needs to be joined 2052 * (reached via the -j option to checkout or update). 2053 * 2054 * INPUTS 2055 * finfo File information about the destination file. 2056 * vers The Vers_TS structure for finfo. 2057 * 2058 * GLOBALS 2059 * join_rev1 From the command line. 2060 * join_rev2 From the command line. 2061 * server_active Natch. 2062 * 2063 * ASSUMPTIONS 2064 * 1. Is not called in client mode. 2065 */ 2066 static void 2067 join_file (struct file_info *finfo, Vers_TS *vers) 2068 { 2069 char *backup; 2070 char *t_options; 2071 int status; 2072 2073 char *rev1; 2074 char *rev2; 2075 char *jrev1; 2076 char *jrev2; 2077 char *jdate1; 2078 char *jdate2; 2079 2080 TRACE (TRACE_FUNCTION, "join_file(%s, %s%s%s%s, %s, %s)", 2081 finfo->file, 2082 vers->tag ? vers->tag : "", 2083 vers->tag ? " (" : "", 2084 vers->vn_rcs ? vers->vn_rcs : "", 2085 vers->tag ? ")" : "", 2086 join_rev1 ? join_rev1 : "", 2087 join_rev2 ? join_rev2 : ""); 2088 2089 jrev1 = join_rev1; 2090 jrev2 = join_rev2; 2091 jdate1 = join_date1; 2092 jdate2 = join_date2; 2093 2094 /* Determine if we need to do anything at all. */ 2095 if (vers->srcfile == NULL || 2096 vers->srcfile->path == NULL) 2097 { 2098 return; 2099 } 2100 2101 /* If only one join revision is specified, it becomes the second 2102 revision. */ 2103 if (jrev2 == NULL) 2104 { 2105 jrev2 = jrev1; 2106 jrev1 = NULL; 2107 jdate2 = jdate1; 2108 jdate1 = NULL; 2109 } 2110 2111 /* FIXME: Need to handle "BASE" for jrev1 and/or jrev2. Note caveat 2112 below about vn_user. */ 2113 2114 /* Convert the second revision, walking branches and dates. */ 2115 rev2 = RCS_getversion (vers->srcfile, jrev2, jdate2, 1, NULL); 2116 2117 /* If this is a merge of two revisions, get the first revision. 2118 If only one join tag was specified, then the first revision is 2119 the greatest common ancestor of the second revision and the 2120 working file. */ 2121 if (jrev1 != NULL) 2122 rev1 = RCS_getversion (vers->srcfile, jrev1, jdate1, 1, NULL); 2123 else 2124 { 2125 /* Note that we use vn_rcs here, since vn_user may contain a 2126 special string such as "-nn". */ 2127 if (vers->vn_rcs == NULL) 2128 rev1 = NULL; 2129 else if (rev2 == NULL) 2130 { 2131 /* This means that the file never existed on the branch. 2132 It does not mean that the file was removed on the 2133 branch: that case is represented by a dead rev2. If 2134 the file never existed on the branch, then we have 2135 nothing to merge, so we just return. */ 2136 return; 2137 } 2138 else 2139 rev1 = gca (vers->vn_rcs, rev2); 2140 } 2141 2142 /* Handle a nonexistent or dead merge target. */ 2143 if (rev2 == NULL || RCS_isdead (vers->srcfile, rev2)) 2144 { 2145 char *mrev; 2146 2147 if (rev2 != NULL) 2148 free (rev2); 2149 2150 /* If the first revision doesn't exist either, then there is 2151 no change between the two revisions, so we don't do 2152 anything. */ 2153 if (rev1 == NULL || RCS_isdead (vers->srcfile, rev1)) 2154 { 2155 if (rev1 != NULL) 2156 free (rev1); 2157 return; 2158 } 2159 2160 /* If we are merging two revisions, then the file was removed 2161 between the first revision and the second one. In this 2162 case we want to mark the file for removal. 2163 2164 If we are merging one revision, then the file has been 2165 removed between the greatest common ancestor and the merge 2166 revision. From the perspective of the branch on to which 2167 we ar emerging, which may be the trunk, either 1) the file 2168 does not currently exist on the target, or 2) the file has 2169 not been modified on the target branch since the greatest 2170 common ancestor, or 3) the file has been modified on the 2171 target branch since the greatest common ancestor. In case 2172 1 there is nothing to do. In case 2 we mark the file for 2173 removal. In case 3 we have a conflict. 2174 2175 Note that the handling is slightly different depending upon 2176 whether one or two join targets were specified. If two 2177 join targets were specified, we don't check whether the 2178 file was modified since a given point. My reasoning is 2179 that if you ask for an explicit merge between two tags, 2180 then you want to merge in whatever was changed between 2181 those two tags. If a file was removed between the two 2182 tags, then you want it to be removed. However, if you ask 2183 for a merge of a branch, then you want to merge in all 2184 changes which were made on the branch. If a file was 2185 removed on the branch, that is a change to the file. If 2186 the file was also changed on the main line, then that is 2187 also a change. These two changes--the file removal and the 2188 modification--must be merged. This is a conflict. */ 2189 2190 /* If the user file is dead, or does not exist, or has been 2191 marked for removal, then there is nothing to do. */ 2192 if (vers->vn_user == NULL 2193 || vers->vn_user[0] == '-' 2194 || RCS_isdead (vers->srcfile, vers->vn_user)) 2195 { 2196 if (rev1 != NULL) 2197 free (rev1); 2198 return; 2199 } 2200 2201 /* If the user file has been marked for addition, or has been 2202 locally modified, then we have a conflict which we can not 2203 resolve. No_Difference will already have been called in 2204 this case, so comparing the timestamps is sufficient to 2205 determine whether the file is locally modified. */ 2206 if (strcmp (vers->vn_user, "0") == 0 2207 || (vers->ts_user != NULL 2208 && strcmp (vers->ts_user, vers->ts_rcs) != 0)) 2209 { 2210 if (jdate2 != NULL) 2211 error (0, 0, 2212 "file %s is locally modified, but has been removed in revision %s as of %s", 2213 finfo->fullname, jrev2, jdate2); 2214 else 2215 error (0, 0, 2216 "file %s is locally modified, but has been removed in revision %s", 2217 finfo->fullname, jrev2); 2218 2219 /* FIXME: Should we arrange to return a non-zero exit 2220 status? */ 2221 2222 if (rev1 != NULL) 2223 free (rev1); 2224 2225 return; 2226 } 2227 2228 /* If only one join tag was specified, and the user file has 2229 been changed since the greatest common ancestor (rev1), 2230 then there is a conflict we can not resolve. See above for 2231 the rationale. */ 2232 if (join_rev2 == NULL 2233 && strcmp (rev1, vers->vn_user) != 0) 2234 { 2235 if (jdate2 != NULL) 2236 error (0, 0, 2237 "file %s has been modified, but has been removed in revision %s as of %s", 2238 finfo->fullname, jrev2, jdate2); 2239 else 2240 error (0, 0, 2241 "file %s has been modified, but has been removed in revision %s", 2242 finfo->fullname, jrev2); 2243 2244 /* FIXME: Should we arrange to return a non-zero exit 2245 status? */ 2246 2247 if (rev1 != NULL) 2248 free (rev1); 2249 2250 return; 2251 } 2252 2253 if (rev1 != NULL) 2254 free (rev1); 2255 2256 /* The user file exists and has not been modified. Mark it 2257 for removal. FIXME: If we are doing a checkout, this has 2258 the effect of first checking out the file, and then 2259 removing it. It would be better to just register the 2260 removal. 2261 2262 The same goes for a removal then an add. e.g. 2263 cvs up -rbr -jbr2 could remove and readd the same file 2264 */ 2265 /* save the rev since server_updated might invalidate it */ 2266 mrev = Xasprintf ("-%s", vers->vn_user); 2267 #ifdef SERVER_SUPPORT 2268 if (server_active) 2269 { 2270 server_scratch (finfo->file); 2271 server_updated (finfo, vers, SERVER_UPDATED, (mode_t) -1, 2272 NULL, NULL); 2273 } 2274 #endif 2275 Register (finfo->entries, finfo->file, mrev, vers->ts_rcs, 2276 vers->options, vers->tag, vers->date, vers->ts_conflict); 2277 free (mrev); 2278 /* We need to check existence_error here because if we are 2279 running as the server, and the file is up to date in the 2280 working directory, the client will not have sent us a copy. */ 2281 if (unlink_file (finfo->file) < 0 && ! existence_error (errno)) 2282 error (0, errno, "cannot remove file %s", finfo->fullname); 2283 #ifdef SERVER_SUPPORT 2284 if (server_active) 2285 server_checked_in (finfo->file, finfo->update_dir, 2286 finfo->repository); 2287 #endif 2288 if (! really_quiet) 2289 error (0, 0, "scheduling `%s' for removal", finfo->fullname); 2290 2291 return; 2292 } 2293 2294 /* If the two merge revisions are the same, then there is nothing 2295 * to do. This needs to be checked before the rev2 == up-to-date base 2296 * revision check tha comes next. Otherwise, rev1 can == rev2 and get an 2297 * "already contains the changes between <rev1> and <rev1>" message. 2298 */ 2299 if (rev1 && strcmp (rev1, rev2) == 0) 2300 { 2301 free (rev1); 2302 free (rev2); 2303 return; 2304 } 2305 2306 /* If we know that the user file is up-to-date, then it becomes an 2307 * optimization to skip the merge when rev2 is the same as the base 2308 * revision. i.e. we know that diff3(file2,file1,file2) will produce 2309 * file2. 2310 */ 2311 if (vers->vn_user != NULL && vers->ts_user != NULL 2312 && strcmp (vers->ts_user, vers->ts_rcs) == 0 2313 && strcmp (rev2, vers->vn_user) == 0) 2314 { 2315 if (!really_quiet) 2316 { 2317 cvs_output (finfo->fullname, 0); 2318 cvs_output (" already contains the differences between ", 0); 2319 cvs_output (rev1 ? rev1 : "creation", 0); 2320 cvs_output (" and ", 0); 2321 cvs_output (rev2, 0); 2322 cvs_output ("\n", 1); 2323 } 2324 2325 if (rev1 != NULL) 2326 free (rev1); 2327 free (rev2); 2328 2329 return; 2330 } 2331 2332 /* If rev1 is dead or does not exist, then the file was added 2333 between rev1 and rev2. */ 2334 if (rev1 == NULL || RCS_isdead (vers->srcfile, rev1)) 2335 { 2336 if (rev1 != NULL) 2337 free (rev1); 2338 free (rev2); 2339 2340 /* If the file does not exist in the working directory, then 2341 we can just check out the new revision and mark it for 2342 addition. */ 2343 if (vers->vn_user == NULL) 2344 { 2345 char *saved_options = options; 2346 Vers_TS *xvers; 2347 2348 xvers = Version_TS (finfo, vers->options, jrev2, jdate2, 1, 0); 2349 2350 /* Reset any keyword expansion option. Otherwise, when a 2351 command like `cvs update -kk -jT1 -jT2' creates a new file 2352 (because a file had the T2 tag, but not T1), the subsequent 2353 commit of that just-added file effectively would set the 2354 admin `-kk' option for that file in the repository. */ 2355 options = NULL; 2356 2357 /* FIXME: If checkout_file fails, we should arrange to 2358 return a non-zero exit status. */ 2359 status = checkout_file (finfo, xvers, 1, 0, 1); 2360 options = saved_options; 2361 2362 freevers_ts (&xvers); 2363 2364 return; 2365 } 2366 2367 /* The file currently exists in the working directory, so we 2368 have a conflict which we can not resolve. Note that this 2369 is true even if the file is marked for addition or removal. */ 2370 2371 if (jdate2 != NULL) 2372 error (0, 0, 2373 "file %s exists, but has been added in revision %s as of %s", 2374 finfo->fullname, jrev2, jdate2); 2375 else 2376 error (0, 0, 2377 "file %s exists, but has been added in revision %s", 2378 finfo->fullname, jrev2); 2379 2380 return; 2381 } 2382 2383 /* If there is no working file, then we can't do the merge. */ 2384 if (vers->vn_user == NULL || vers->vn_user[0] == '-') 2385 { 2386 free (rev1); 2387 free (rev2); 2388 2389 if (jdate2 != NULL) 2390 error (0, 0, 2391 "file %s does not exist, but is present in revision %s as of %s", 2392 finfo->fullname, jrev2, jdate2); 2393 else 2394 error (0, 0, 2395 "file %s does not exist, but is present in revision %s", 2396 finfo->fullname, jrev2); 2397 2398 /* FIXME: Should we arrange to return a non-zero exit status? */ 2399 2400 return; 2401 } 2402 2403 #ifdef SERVER_SUPPORT 2404 if (server_active && !isreadable (finfo->file)) 2405 { 2406 int retcode; 2407 /* The file is up to date. Need to check out the current contents. */ 2408 /* FIXME - see the FIXME comment above the call to RCS_checkout in the 2409 * patch_file function. 2410 */ 2411 retcode = RCS_checkout (vers->srcfile, finfo->file, 2412 vers->vn_user, vers->tag, 2413 NULL, RUN_TTY, NULL, NULL); 2414 if (retcode != 0) 2415 error (1, 0, 2416 "failed to check out %s file", finfo->fullname); 2417 } 2418 #endif 2419 2420 /* 2421 * The users currently modified file is moved to a backup file name 2422 * ".#filename.version", so that it will stay around for a few days 2423 * before being automatically removed by some cron daemon. The "version" 2424 * is the version of the file that the user was most up-to-date with 2425 * before the merge. 2426 */ 2427 backup = Xasprintf ("%s%s.%s", BAKPREFIX, finfo->file, vers->vn_user); 2428 2429 if (unlink_file (backup) < 0 2430 && !existence_error (errno)) 2431 error (0, errno, "cannot remove %s", backup); 2432 copy_file (finfo->file, backup); 2433 xchmod (finfo->file, 1); 2434 2435 t_options = vers->options; 2436 #if 0 2437 if (*t_options == '\0') 2438 t_options = "-kk"; /* to ignore keyword expansions */ 2439 #endif 2440 2441 /* If the source of the merge is the same as the working file 2442 revision, then we can just RCS_checkout the target (no merging 2443 as such). In the text file case, this is probably quite 2444 similar to the RCS_merge, but in the binary file case, 2445 RCS_merge gives all kinds of trouble. */ 2446 if (vers->vn_user != NULL 2447 && strcmp (rev1, vers->vn_user) == 0 2448 /* See comments above about how No_Difference has already been 2449 called. */ 2450 && vers->ts_user != NULL 2451 && strcmp (vers->ts_user, vers->ts_rcs) == 0 2452 2453 /* Avoid this in the text file case. See below for why. 2454 */ 2455 && (strcmp (t_options, "-kb") == 0 2456 || wrap_merge_is_copy (finfo->file))) 2457 { 2458 /* FIXME: Verify my comment below: 2459 * 2460 * RCS_merge does nothing with keywords. It merges the changes between 2461 * two revisions without expanding the keywords (it might expand in 2462 * -kk mode before computing the diff between rev1 and rev2 - I'm not 2463 * sure). In other words, the keyword lines in the current work file 2464 * get left alone. 2465 * 2466 * Therfore, checking out the destination revision (rev2) is probably 2467 * incorrect in the text case since we should see the keywords that were 2468 * substituted into the original file at the time it was checked out 2469 * and not the keywords from rev2. 2470 * 2471 * Also, it is safe to pass in NULL for nametag since we know no 2472 * substitution is happening during the binary mode checkout. 2473 */ 2474 if (RCS_checkout (finfo->rcs, finfo->file, rev2, NULL, t_options, 2475 RUN_TTY, NULL, NULL) != 0) 2476 status = 2; 2477 else 2478 status = 0; 2479 2480 /* OK, this is really stupid. RCS_checkout carefully removes 2481 write permissions, and we carefully put them back. But 2482 until someone gets around to fixing it, that seems like the 2483 easiest way to get what would seem to be the right mode. 2484 I don't check CVSWRITE or _watched; I haven't thought about 2485 that in great detail, but it seems like a watched file should 2486 be checked out (writable) after a merge. */ 2487 xchmod (finfo->file, 1); 2488 2489 /* Traditionally, the text file case prints a whole bunch of 2490 scary looking and verbose output which fails to tell the user 2491 what is really going on (it gives them rev1 and rev2 but doesn't 2492 indicate in any way that rev1 == vn_user). I think just a 2493 simple "U foo" is good here; it seems analogous to the case in 2494 which the file was added on the branch in terms of what to 2495 print. */ 2496 write_letter (finfo, 'U'); 2497 } 2498 else if (strcmp (t_options, "-kb") == 0 2499 || wrap_merge_is_copy (finfo->file) 2500 || special_file_mismatch (finfo, rev1, rev2)) 2501 { 2502 /* We are dealing with binary files, or files with a 2503 permission/linkage mismatch (this second case only occurs when 2504 PRESERVE_PERMISSIONS_SUPPORT is enabled), and real merging would 2505 need to take place. This is a conflict. We give the user 2506 the two files, and let them resolve it. It is possible 2507 that we should require a "touch foo" or similar step before 2508 we allow a checkin. */ 2509 if (RCS_checkout (finfo->rcs, finfo->file, rev2, NULL, 2510 t_options, RUN_TTY, NULL, NULL) != 0) 2511 status = 2; 2512 else 2513 status = 0; 2514 2515 /* OK, this is really stupid. RCS_checkout carefully removes 2516 write permissions, and we carefully put them back. But 2517 until someone gets around to fixing it, that seems like the 2518 easiest way to get what would seem to be the right mode. 2519 I don't check CVSWRITE or _watched; I haven't thought about 2520 that in great detail, but it seems like a watched file should 2521 be checked out (writable) after a merge. */ 2522 xchmod (finfo->file, 1); 2523 2524 /* Hmm. We don't give them REV1 anywhere. I guess most people 2525 probably don't have a 3-way merge tool for the file type in 2526 question, and might just get confused if we tried to either 2527 provide them with a copy of the file from REV1, or even just 2528 told them what REV1 is so they can get it themself, but it 2529 might be worth thinking about. */ 2530 /* See comment in merge_file about the "nonmergeable file" 2531 terminology. */ 2532 error (0, 0, "nonmergeable file needs merge"); 2533 error (0, 0, "revision %s from repository is now in %s", 2534 rev2, finfo->fullname); 2535 error (0, 0, "file from working directory is now in %s", backup); 2536 write_letter (finfo, 'C'); 2537 } 2538 else 2539 status = RCS_merge (finfo->rcs, vers->srcfile->path, finfo->file, 2540 t_options, rev1, rev2); 2541 2542 if (status != 0) 2543 { 2544 if (status != 1) 2545 { 2546 error (0, status == -1 ? errno : 0, 2547 "could not merge revision %s of %s", rev2, finfo->fullname); 2548 error (status == -1 ? 1 : 0, 0, "restoring %s from backup file %s", 2549 finfo->fullname, backup); 2550 rename_file (backup, finfo->file); 2551 } 2552 } 2553 else /* status == 0 */ 2554 { 2555 /* FIXME: the noexec case is broken. RCS_merge could be doing the 2556 xcmp on the temporary files without much hassle, I think. */ 2557 if (!noexec && !xcmp (backup, finfo->file)) 2558 { 2559 if (!really_quiet) 2560 { 2561 cvs_output (finfo->fullname, 0); 2562 cvs_output (" already contains the differences between ", 0); 2563 cvs_output (rev1, 0); 2564 cvs_output (" and ", 0); 2565 cvs_output (rev2, 0); 2566 cvs_output ("\n", 1); 2567 } 2568 2569 /* and skip the registering and sending the new file since it 2570 * hasn't been updated. 2571 */ 2572 goto out; 2573 } 2574 } 2575 2576 /* The file has changed, but if we just checked it out it may 2577 still have the same timestamp it did when it was first 2578 registered above in checkout_file. We register it again with a 2579 dummy timestamp to make sure that later runs of CVS will 2580 recognize that it has changed. 2581 2582 We don't actually need to register again if we called 2583 RCS_checkout above, and we aren't running as the server. 2584 However, that is not the normal case, and calling Register 2585 again won't cost much in that case. */ 2586 RegisterMerge (finfo, vers, backup, status); 2587 2588 out: 2589 free (rev1); 2590 free (rev2); 2591 free (backup); 2592 } 2593 2594 2595 2596 /* 2597 * Report whether revisions REV1 and REV2 of FINFO agree on: 2598 * . file ownership 2599 * . permissions 2600 * . major and minor device numbers 2601 * . symbolic links 2602 * . hard links 2603 * 2604 * If either REV1 or REV2 is NULL, the working copy is used instead. 2605 * 2606 * Return 1 if the files differ on these data. 2607 */ 2608 2609 int 2610 special_file_mismatch (struct file_info *finfo, char *rev1, char *rev2) 2611 { 2612 #ifdef PRESERVE_PERMISSIONS_SUPPORT 2613 struct stat sb; 2614 RCSVers *vp; 2615 Node *n; 2616 uid_t rev1_uid, rev2_uid; 2617 gid_t rev1_gid, rev2_gid; 2618 mode_t rev1_mode, rev2_mode; 2619 unsigned long dev_long; 2620 dev_t rev1_dev, rev2_dev; 2621 char *rev1_symlink = NULL; 2622 char *rev2_symlink = NULL; 2623 List *rev1_hardlinks = NULL; 2624 List *rev2_hardlinks = NULL; 2625 int check_uids, check_gids, check_modes; 2626 int result; 2627 2628 /* If we don't care about special file info, then 2629 don't report a mismatch in any case. */ 2630 if (!preserve_perms) 2631 return 0; 2632 2633 /* When special_file_mismatch is called from No_Difference, the 2634 RCS file has been only partially parsed. We must read the 2635 delta tree in order to compare special file info recorded in 2636 the delta nodes. (I think this is safe. -twp) */ 2637 if (finfo->rcs->flags & PARTIAL) 2638 RCS_reparsercsfile (finfo->rcs, NULL, NULL); 2639 2640 check_uids = check_gids = check_modes = 1; 2641 2642 /* Obtain file information for REV1. If this is null, then stat 2643 finfo->file and use that info. */ 2644 /* If a revision does not know anything about its status, 2645 then presumably it doesn't matter, and indicates no conflict. */ 2646 2647 if (rev1 == NULL) 2648 { 2649 ssize_t rsize; 2650 2651 if ((rsize = islink (finfo->file)) > 0) 2652 rev1_symlink = Xreadlink (finfo->file, rsize); 2653 else 2654 { 2655 # ifdef HAVE_STRUCT_STAT_ST_RDEV 2656 if (lstat (finfo->file, &sb) < 0) 2657 error (1, errno, "could not get file information for %s", 2658 finfo->file); 2659 rev1_uid = sb.st_uid; 2660 rev1_gid = sb.st_gid; 2661 rev1_mode = sb.st_mode; 2662 if (S_ISBLK (rev1_mode) || S_ISCHR (rev1_mode)) 2663 rev1_dev = sb.st_rdev; 2664 # else 2665 error (1, 0, "cannot handle device files on this system (%s)", 2666 finfo->file); 2667 # endif 2668 } 2669 rev1_hardlinks = list_linked_files_on_disk (finfo->file); 2670 } 2671 else 2672 { 2673 n = findnode (finfo->rcs->versions, rev1); 2674 vp = n->data; 2675 2676 n = findnode (vp->other_delta, "symlink"); 2677 if (n != NULL) 2678 rev1_symlink = xstrdup (n->data); 2679 else 2680 { 2681 n = findnode (vp->other_delta, "owner"); 2682 if (n == NULL) 2683 check_uids = 0; /* don't care */ 2684 else 2685 rev1_uid = strtoul (n->data, NULL, 10); 2686 2687 n = findnode (vp->other_delta, "group"); 2688 if (n == NULL) 2689 check_gids = 0; /* don't care */ 2690 else 2691 rev1_gid = strtoul (n->data, NULL, 10); 2692 2693 n = findnode (vp->other_delta, "permissions"); 2694 if (n == NULL) 2695 check_modes = 0; /* don't care */ 2696 else 2697 rev1_mode = strtoul (n->data, NULL, 8); 2698 2699 n = findnode (vp->other_delta, "special"); 2700 if (n == NULL) 2701 rev1_mode |= S_IFREG; 2702 else 2703 { 2704 /* If the size of `ftype' changes, fix the sscanf call also */ 2705 char ftype[16]; 2706 if (sscanf (n->data, "%15s %lu", ftype, 2707 &dev_long) < 2) 2708 error (1, 0, "%s:%s has bad `special' newphrase %s", 2709 finfo->file, rev1, (char *)n->data); 2710 rev1_dev = dev_long; 2711 if (strcmp (ftype, "character") == 0) 2712 rev1_mode |= S_IFCHR; 2713 else if (strcmp (ftype, "block") == 0) 2714 rev1_mode |= S_IFBLK; 2715 else 2716 error (0, 0, "%s:%s unknown file type `%s'", 2717 finfo->file, rev1, ftype); 2718 } 2719 2720 rev1_hardlinks = vp->hardlinks; 2721 if (rev1_hardlinks == NULL) 2722 rev1_hardlinks = getlist(); 2723 } 2724 } 2725 2726 /* Obtain file information for REV2. */ 2727 if (rev2 == NULL) 2728 { 2729 ssize_t rsize; 2730 2731 if ((rsize = islink (finfo->file)) > 0) 2732 rev2_symlink = Xreadlink (finfo->file, rsize); 2733 else 2734 { 2735 # ifdef HAVE_STRUCT_STAT_ST_RDEV 2736 if (lstat (finfo->file, &sb) < 0) 2737 error (1, errno, "could not get file information for %s", 2738 finfo->file); 2739 rev2_uid = sb.st_uid; 2740 rev2_gid = sb.st_gid; 2741 rev2_mode = sb.st_mode; 2742 if (S_ISBLK (rev2_mode) || S_ISCHR (rev2_mode)) 2743 rev2_dev = sb.st_rdev; 2744 # else 2745 error (1, 0, "cannot handle device files on this system (%s)", 2746 finfo->file); 2747 # endif 2748 } 2749 rev2_hardlinks = list_linked_files_on_disk (finfo->file); 2750 } 2751 else 2752 { 2753 n = findnode (finfo->rcs->versions, rev2); 2754 vp = n->data; 2755 2756 n = findnode (vp->other_delta, "symlink"); 2757 if (n != NULL) 2758 rev2_symlink = xstrdup (n->data); 2759 else 2760 { 2761 n = findnode (vp->other_delta, "owner"); 2762 if (n == NULL) 2763 check_uids = 0; /* don't care */ 2764 else 2765 rev2_uid = strtoul (n->data, NULL, 10); 2766 2767 n = findnode (vp->other_delta, "group"); 2768 if (n == NULL) 2769 check_gids = 0; /* don't care */ 2770 else 2771 rev2_gid = strtoul (n->data, NULL, 10); 2772 2773 n = findnode (vp->other_delta, "permissions"); 2774 if (n == NULL) 2775 check_modes = 0; /* don't care */ 2776 else 2777 rev2_mode = strtoul (n->data, NULL, 8); 2778 2779 n = findnode (vp->other_delta, "special"); 2780 if (n == NULL) 2781 rev2_mode |= S_IFREG; 2782 else 2783 { 2784 /* If the size of `ftype' changes, fix the sscanf call also */ 2785 char ftype[16]; 2786 if (sscanf (n->data, "%15s %lu", ftype, 2787 &dev_long) < 2) 2788 error (1, 0, "%s:%s has bad `special' newphrase %s", 2789 finfo->file, rev2, (char *)n->data); 2790 rev2_dev = dev_long; 2791 if (strcmp (ftype, "character") == 0) 2792 rev2_mode |= S_IFCHR; 2793 else if (strcmp (ftype, "block") == 0) 2794 rev2_mode |= S_IFBLK; 2795 else 2796 error (0, 0, "%s:%s unknown file type `%s'", 2797 finfo->file, rev2, ftype); 2798 } 2799 2800 rev2_hardlinks = vp->hardlinks; 2801 if (rev2_hardlinks == NULL) 2802 rev2_hardlinks = getlist(); 2803 } 2804 } 2805 2806 /* Check the user/group ownerships and file permissions, printing 2807 an error for each mismatch found. Return 0 if all characteristics 2808 matched, and 1 otherwise. */ 2809 2810 result = 0; 2811 2812 /* Compare symlinks first, since symlinks are simpler (don't have 2813 any other characteristics). */ 2814 if (rev1_symlink != NULL && rev2_symlink == NULL) 2815 { 2816 error (0, 0, "%s is a symbolic link", 2817 (rev1 == NULL ? "working file" : rev1)); 2818 result = 1; 2819 } 2820 else if (rev1_symlink == NULL && rev2_symlink != NULL) 2821 { 2822 error (0, 0, "%s is a symbolic link", 2823 (rev2 == NULL ? "working file" : rev2)); 2824 result = 1; 2825 } 2826 else if (rev1_symlink != NULL) 2827 result = (strcmp (rev1_symlink, rev2_symlink) == 0); 2828 else 2829 { 2830 /* Compare user ownership. */ 2831 if (check_uids && rev1_uid != rev2_uid) 2832 { 2833 error (0, 0, "%s: owner mismatch between %s and %s", 2834 finfo->file, 2835 (rev1 == NULL ? "working file" : rev1), 2836 (rev2 == NULL ? "working file" : rev2)); 2837 result = 1; 2838 } 2839 2840 /* Compare group ownership. */ 2841 if (check_gids && rev1_gid != rev2_gid) 2842 { 2843 error (0, 0, "%s: group mismatch between %s and %s", 2844 finfo->file, 2845 (rev1 == NULL ? "working file" : rev1), 2846 (rev2 == NULL ? "working file" : rev2)); 2847 result = 1; 2848 } 2849 2850 /* Compare permissions. */ 2851 if (check_modes && 2852 (rev1_mode & 07777) != (rev2_mode & 07777)) 2853 { 2854 error (0, 0, "%s: permission mismatch between %s and %s", 2855 finfo->file, 2856 (rev1 == NULL ? "working file" : rev1), 2857 (rev2 == NULL ? "working file" : rev2)); 2858 result = 1; 2859 } 2860 2861 /* Compare device file characteristics. */ 2862 if ((rev1_mode & S_IFMT) != (rev2_mode & S_IFMT)) 2863 { 2864 error (0, 0, "%s: %s and %s are different file types", 2865 finfo->file, 2866 (rev1 == NULL ? "working file" : rev1), 2867 (rev2 == NULL ? "working file" : rev2)); 2868 result = 1; 2869 } 2870 else if (S_ISBLK (rev1_mode)) 2871 { 2872 if (rev1_dev != rev2_dev) 2873 { 2874 error (0, 0, "%s: device numbers of %s and %s do not match", 2875 finfo->file, 2876 (rev1 == NULL ? "working file" : rev1), 2877 (rev2 == NULL ? "working file" : rev2)); 2878 result = 1; 2879 } 2880 } 2881 2882 /* Compare hard links. */ 2883 if (compare_linkage_lists (rev1_hardlinks, rev2_hardlinks) == 0) 2884 { 2885 error (0, 0, "%s: hard linkage of %s and %s do not match", 2886 finfo->file, 2887 (rev1 == NULL ? "working file" : rev1), 2888 (rev2 == NULL ? "working file" : rev2)); 2889 result = 1; 2890 } 2891 } 2892 2893 if (rev1_symlink != NULL) 2894 free (rev1_symlink); 2895 if (rev2_symlink != NULL) 2896 free (rev2_symlink); 2897 if (rev1_hardlinks != NULL) 2898 dellist (&rev1_hardlinks); 2899 if (rev2_hardlinks != NULL) 2900 dellist (&rev2_hardlinks); 2901 2902 return result; 2903 #else 2904 return 0; 2905 #endif 2906 } 2907 2908 2909 2910 int 2911 joining (void) 2912 { 2913 return join_rev1 || join_date1; 2914 } 2915