contrib/cvs-1.12/src/update.c

   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     optind = 0;
 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                     /* We know that we are the server here, so
1314                        although xchmod checks umask, we don't bother.  */
1315                     mode |= (((mode & S_IRUSR) ? S_IWUSR : 0)
1316                              | ((mode & S_IRGRP) ? S_IWGRP : 0)
1317                              | ((mode & S_IROTH) ? S_IWOTH : 0));
1318                 }
1319             }
1320
1321             {
1322                 /* A newly checked out file is never under the spell
1323                    of "cvs edit".  If we think we were editing it
1324                    from a previous life, clean up.  Would be better to
1325                    check for same the working directory instead of
1326                    same user, but that is hairy.  */
1327
1328                 struct addremove_args args;
1329
1330                 editor_set (finfo->file, getcaller (), NULL);
1331
1332                 memset (&args, 0, sizeof args);
1333                 args.remove_temp = 1;
1334                 watch_modify_watchers (finfo->file, &args);
1335             }
1336
1337             /* set the time from the RCS file iff it was unknown before */
1338             set_time =
1339                 (!noexec
1340                  && (vers_ts->vn_user == NULL ||
1341                      strncmp (vers_ts->ts_rcs, "Initial", 7) == 0)
1342                  && !file_is_dead);
1343
1344             wrap_fromcvs_process_file (finfo->file);
1345
1346             xvers_ts = Version_TS (finfo, options, tag, date,
1347                                    force_tag_match, set_time);
1348             if (strcmp (xvers_ts->options, "-V4") == 0)
1349                 xvers_ts->options[0] = '\0';
1350
1351             if (revbuf != NULL)
1352             {
1353                 /* If we stored the file data into a buffer, then we
1354                    didn't create a file at all, so xvers_ts->ts_user
1355                    is wrong.  The correct value is to have it be the
1356                    same as xvers_ts->ts_rcs, meaning that the working
1357                    file is unchanged from the RCS file.
1358
1359                    FIXME: We should tell Version_TS not to waste time
1360                    statting the nonexistent file.
1361
1362                    FIXME: Actually, I don't think the ts_user value
1363                    matters at all here.  The only use I know of is
1364                    that it is printed in a trace message by
1365                    Server_Register.  */
1366
1367                 if (xvers_ts->ts_user != NULL)
1368                     free (xvers_ts->ts_user);
1369                 xvers_ts->ts_user = xstrdup (xvers_ts->ts_rcs);
1370             }
1371
1372             (void) time (&last_register_time);
1373
1374             if (file_is_dead)
1375             {
1376                 if (xvers_ts->vn_user != NULL)
1377                 {
1378                     error (0, 0,
1379                            "warning: %s is not (any longer) pertinent",
1380                            finfo->fullname);
1381                 }
1382                 Scratch_Entry (finfo->entries, finfo->file);
1383 #ifdef SERVER_SUPPORT
1384                 if (server_active && xvers_ts->ts_user == NULL)
1385                     server_scratch_entry_only ();
1386 #endif
1387                 /* FIXME: Rather than always unlink'ing, and ignoring the
1388                    existence_error, we should do the unlink only if
1389                    vers_ts->ts_user is non-NULL.  Then there would be no
1390                    need to ignore an existence_error (for example, if the
1391                    user removes the file while we are running).  */
1392                 if (unlink_file (finfo->file) < 0 && ! existence_error (errno))
1393                 {
1394                     error (0, errno, "cannot remove %s", finfo->fullname);
1395                 }
1396             }
1397             else
1398                 Register (finfo->entries, finfo->file,
1399                           adding ? "0" : xvers_ts->vn_rcs,
1400                           xvers_ts->ts_user, xvers_ts->options,
1401                           xvers_ts->tag, xvers_ts->date,
1402                           NULL); /* Clear conflict flag on fresh checkout */
1403
1404             /* fix up the vers structure, in case it is used by join */
1405             if (join_rev1)
1406             {
1407                 /* FIXME: Throwing away the original revision info is almost
1408                    certainly wrong -- what if join_rev1 is "BASE"?  */
1409                 if (vers_ts->vn_user != NULL)
1410                     free (vers_ts->vn_user);
1411                 if (vers_ts->vn_rcs != NULL)
1412                     free (vers_ts->vn_rcs);
1413                 vers_ts->vn_user = xstrdup (xvers_ts->vn_rcs);
1414                 vers_ts->vn_rcs = xstrdup (xvers_ts->vn_rcs);
1415             }
1416
1417             /* If this is really Update and not Checkout, recode history */
1418             if (strcmp (cvs_cmd_name, "update") == 0)
1419                 history_write ('U', finfo->update_dir, xvers_ts->vn_rcs, finfo->file,
1420                                finfo->repository);
1421
1422             freevers_ts (&xvers_ts);
1423
1424             if (!really_quiet && !file_is_dead)
1425             {
1426                 write_letter (finfo, 'U');
1427             }
1428         }
1429
1430 #ifdef SERVER_SUPPORT
1431         if (update_server && server_active)
1432             server_updated (finfo, vers_ts,
1433                             merging ? SERVER_MERGED : SERVER_UPDATED,
1434                             mode, NULL, revbuf);
1435 #endif
1436     }
1437     else
1438     {
1439         if (backup != NULL)
1440         {
1441             rename_file (backup, finfo->file);
1442             free (backup);
1443             backup = NULL;
1444         }
1445
1446         error (0, 0, "could not check out %s", finfo->fullname);
1447
1448         retval = status;
1449     }
1450
1451     if (backup != NULL)
1452     {
1453         /* If -f/-t wrappers are being used to wrap up a directory,
1454            then backup might be a directory instead of just a file.  */
1455         if (unlink_file_dir (backup) < 0)
1456         {
1457             /* Not sure if the existence_error check is needed here.  */
1458             if (!existence_error (errno))
1459                 /* FIXME: should include update_dir in message.  */
1460                 error (0, errno, "error removing %s", backup);
1461         }
1462         free (backup);
1463     }
1464
1465 #if defined (SERVER_SUPPORT) || defined (CLIENT_SUPPORT)
1466     if (revbuf != NULL)
1467         buf_free (revbuf);
1468 #endif /* defined (SERVER_SUPPORT) || defined (CLIENT_SUPPORT) */
1469     return retval;
1470 }
1471
1472
1473
1474 #ifdef SERVER_SUPPORT
1475
1476 /* This function is used to write data from a file being checked out
1477    into a buffer.  */
1478
1479 static void
1480 checkout_to_buffer (void *callerdat, const char *data, size_t len)
1481 {
1482     struct buffer *buf = (struct buffer *) callerdat;
1483
1484     buf_output (buf, data, len);
1485 }
1486
1487 #endif /* SERVER_SUPPORT */
1488
1489 #ifdef SERVER_SUPPORT
1490
1491 /* This structure is used to pass information between patch_file and
1492    patch_file_write.  */
1493
1494 struct patch_file_data
1495 {
1496     /* File name, for error messages.  */
1497     const char *filename;
1498     /* File to which to write.  */
1499     FILE *fp;
1500     /* Whether to compute the MD5 checksum.  */
1501     int compute_checksum;
1502     /* Data structure for computing the MD5 checksum.  */
1503     struct md5_ctx context;
1504     /* Set if the file has a final newline.  */
1505     int final_nl;
1506 };
1507
1508 /* Patch a file.  Runs diff.  This is only done when running as the
1509  * server.  The hope is that the diff will be smaller than the file
1510  * itself.
1511  */
1512 static int
1513 patch_file (struct file_info *finfo, Vers_TS *vers_ts, int *docheckout,
1514             struct stat *file_info, unsigned char *checksum)
1515 {
1516     char *backup;
1517     char *file1;
1518     char *file2;
1519     int retval = 0;
1520     int retcode = 0;
1521     int fail;
1522     FILE *e;
1523     struct patch_file_data data;
1524
1525     *docheckout = 0;
1526
1527     if (noexec || pipeout || joining ())
1528     {
1529         *docheckout = 1;
1530         return 0;
1531     }
1532
1533     /* If this file has been marked as being binary, then never send a
1534        patch.  */
1535     if (strcmp (vers_ts->options, "-kb") == 0)
1536     {
1537         *docheckout = 1;
1538         return 0;
1539     }
1540
1541     /* First check that the first revision exists.  If it has been nuked
1542        by cvs admin -o, then just fall back to checking out entire
1543        revisions.  In some sense maybe we don't have to do this; after
1544        all cvs.texinfo says "Make sure that no-one has checked out a
1545        copy of the revision you outdate" but then again, that advice
1546        doesn't really make complete sense, because "cvs admin" operates
1547        on a working directory and so _someone_ will almost always have
1548        _some_ revision checked out.  */
1549     {
1550         char *rev;
1551
1552         rev = RCS_gettag (finfo->rcs, vers_ts->vn_user, 1, NULL);
1553         if (rev == NULL)
1554         {
1555             *docheckout = 1;
1556             return 0;
1557         }
1558         else
1559             free (rev);
1560     }
1561
1562     /* If the revision is dead, let checkout_file handle it rather
1563        than duplicating the processing here.  */
1564     if (RCS_isdead (vers_ts->srcfile, vers_ts->vn_rcs))
1565     {
1566         *docheckout = 1;
1567         return 0;
1568     }
1569
1570     backup = Xasprintf ("%s/%s%s", CVSADM, CVSPREFIX, finfo->file);
1571     if (isfile (finfo->file))
1572         rename_file (finfo->file, backup);
1573     else
1574     {
1575         if (unlink_file (backup) < 0
1576             && !existence_error (errno))
1577             error (0, errno, "cannot remove %s", backup);
1578     }
1579
1580     file1 = Xasprintf ("%s/%s%s-1", CVSADM, CVSPREFIX, finfo->file);
1581     file2 = Xasprintf ("%s/%s%s-2", CVSADM, CVSPREFIX, finfo->file);
1582
1583     fail = 0;
1584
1585     /* We need to check out both revisions first, to see if either one
1586        has a trailing newline.  Because of this, we don't use rcsdiff,
1587        but just use diff.  */
1588
1589     e = CVS_FOPEN (file1, "w");
1590     if (e == NULL)
1591         error (1, errno, "cannot open %s", file1);
1592
1593     data.filename = file1;
1594     data.fp = e;
1595     data.final_nl = 0;
1596     data.compute_checksum = 0;
1597
1598     /* FIXME - Passing vers_ts->tag here is wrong in the least number
1599      * of cases.  Since we don't know whether vn_user was checked out
1600      * using a tag, we pass vers_ts->tag, which, assuming the user did
1601      * not specify a new TAG to -r, will be the branch we are on.
1602      *
1603      * The only thing it is used for is to substitute in for the Name
1604      * RCS keyword, so in the error case, the patch fails to apply on
1605      * the client end and we end up resending the whole file.
1606      *
1607      * At least, if we are keeping track of the tag vn_user came from,
1608      * I don't know where yet. -DRP
1609      */
1610     retcode = RCS_checkout (vers_ts->srcfile, NULL,
1611                             vers_ts->vn_user, vers_ts->tag,
1612                             vers_ts->options, RUN_TTY,
1613                             patch_file_write, (void *) &data);
1614
1615     if (fclose (e) < 0)
1616         error (1, errno, "cannot close %s", file1);
1617
1618     if (retcode != 0 || ! data.final_nl)
1619         fail = 1;
1620
1621     if (! fail)
1622     {
1623         e = CVS_FOPEN (file2, "w");
1624         if (e == NULL)
1625             error (1, errno, "cannot open %s", file2);
1626
1627         data.filename = file2;
1628         data.fp = e;
1629         data.final_nl = 0;
1630         data.compute_checksum = 1;
1631         md5_init_ctx (&data.context);
1632
1633         retcode = RCS_checkout (vers_ts->srcfile, NULL,
1634                                 vers_ts->vn_rcs, vers_ts->tag,
1635                                 vers_ts->options, RUN_TTY,
1636                                 patch_file_write, (void *) &data);
1637
1638         if (fclose (e) < 0)
1639             error (1, errno, "cannot close %s", file2);
1640
1641         if (retcode != 0 || ! data.final_nl)
1642             fail = 1;
1643         else
1644             md5_finish_ctx (&data.context, checksum);
1645     }
1646
1647     retcode = 0;
1648     if (! fail)
1649     {
1650         int dargc = 0;
1651         size_t darg_allocated = 0;
1652         char **dargv = NULL;
1653
1654         /* If the client does not support the Rcs-diff command, we
1655            send a context diff, and the client must invoke patch.
1656            That approach was problematical for various reasons.  The
1657            new approach only requires running diff in the server; the
1658            client can handle everything without invoking an external
1659            program.  */
1660         if (!rcs_diff_patches)
1661             /* We use -c, not -u, because that is what CVS has
1662                traditionally used.  Kind of a moot point, now that
1663                Rcs-diff is preferred, so there is no point in making
1664                the compatibility issues worse.  */
1665             run_add_arg_p (&dargc, &darg_allocated, &dargv, "-c");
1666         else
1667             /* Now that diff is librarified, we could be passing -a if
1668                we wanted to.  However, it is unclear to me whether we
1669                would want to.  Does diff -a, in any significant
1670                percentage of cases, produce patches which are smaller
1671                than the files it is patching?  I guess maybe text
1672                files with character sets which diff regards as
1673                'binary'.  Conversely, do they tend to be much larger
1674                in the bad cases?  This needs some more
1675                thought/investigation, I suspect.  */
1676             run_add_arg_p (&dargc, &darg_allocated, &dargv, "-n");
1677         retcode = diff_exec (file1, file2, NULL, NULL, dargc, dargv,
1678                              finfo->file);
1679         run_arg_free_p (dargc, dargv);
1680         free (dargv);
1681
1682         /* A retcode of 0 means no differences.  1 means some differences.  */
1683         if (retcode != 0 && retcode != 1)
1684             fail = 1;
1685     }
1686
1687     if (!fail)
1688     {
1689         struct stat file2_info;
1690
1691         /* Check to make sure the patch is really shorter */
1692         if (stat (file2, &file2_info) < 0)
1693             error (1, errno, "could not stat %s", file2);
1694         if (stat (finfo->file, file_info) < 0)
1695             error (1, errno, "could not stat %s", finfo->file);
1696         if (file2_info.st_size <= file_info->st_size)
1697             fail = 1;
1698     }
1699
1700     if (! fail)
1701     {
1702 # define BINARY "Binary"
1703         char buf[sizeof BINARY];
1704         unsigned int c;
1705
1706         /* Check the diff output to make sure patch will be handle it.  */
1707         e = CVS_FOPEN (finfo->file, "r");
1708         if (e == NULL)
1709             error (1, errno, "could not open diff output file %s",
1710                    finfo->fullname);
1711         c = fread (buf, 1, sizeof BINARY - 1, e);
1712         buf[c] = '\0';
1713         if (strcmp (buf, BINARY) == 0)
1714         {
1715             /* These are binary files.  We could use diff -a, but
1716                patch can't handle that.  */
1717             fail = 1;
1718         }
1719         fclose (e);
1720     }
1721
1722     if (! fail)
1723     {
1724         Vers_TS *xvers_ts;
1725
1726         /* Stat the original RCS file, and then adjust it the way
1727            that RCS_checkout would.  FIXME: This is an abstraction
1728            violation.  */
1729         if (stat (vers_ts->srcfile->path, file_info) < 0)
1730             error (1, errno, "could not stat %s", vers_ts->srcfile->path);
1731         if (chmod (finfo->file,
1732                    file_info->st_mode & ~(S_IWRITE | S_IWGRP | S_IWOTH))
1733             < 0)
1734             error (0, errno, "cannot change mode of file %s", finfo->file);
1735         if (cvswrite
1736             && !fileattr_get (finfo->file, "_watched"))
1737             xchmod (finfo->file, 1);
1738
1739         /* This stuff is just copied blindly from checkout_file.  I
1740            don't really know what it does.  */
1741         xvers_ts = Version_TS (finfo, options, tag, date,
1742                                force_tag_match, 0);
1743         if (strcmp (xvers_ts->options, "-V4") == 0)
1744             xvers_ts->options[0] = '\0';
1745
1746         Register (finfo->entries, finfo->file, xvers_ts->vn_rcs,
1747                   xvers_ts->ts_user, xvers_ts->options,
1748                   xvers_ts->tag, xvers_ts->date, NULL);
1749
1750         if (stat (finfo->file, file_info) < 0)
1751             error (1, errno, "could not stat %s", finfo->file);
1752
1753         /* If this is really Update and not Checkout, record history.  */
1754         if (strcmp (cvs_cmd_name, "update") == 0)
1755             history_write ('P', finfo->update_dir, xvers_ts->vn_rcs,
1756                            finfo->file, finfo->repository);
1757
1758         freevers_ts (&xvers_ts);
1759
1760         if (!really_quiet)
1761         {
1762             write_letter (finfo, 'P');
1763         }
1764     }
1765     else
1766     {
1767         int old_errno = errno;          /* save errno value over the rename */
1768
1769         if (isfile (backup))
1770             rename_file (backup, finfo->file);
1771
1772         if (retcode != 0 && retcode != 1)
1773             error (retcode == -1 ? 1 : 0, retcode == -1 ? old_errno : 0,
1774                    "could not diff %s", finfo->fullname);
1775
1776         *docheckout = 1;
1777         retval = retcode;
1778     }
1779
1780     if (unlink_file (backup) < 0
1781         && !existence_error (errno))
1782         error (0, errno, "cannot remove %s", backup);
1783     if (unlink_file (file1) < 0
1784         && !existence_error (errno))
1785         error (0, errno, "cannot remove %s", file1);
1786     if (unlink_file (file2) < 0
1787         && !existence_error (errno))
1788         error (0, errno, "cannot remove %s", file2);
1789
1790     free (backup);
1791     free (file1);
1792     free (file2);
1793     return retval;
1794 }
1795
1796
1797
1798 /* Write data to a file.  Record whether the last byte written was a
1799    newline.  Optionally compute a checksum.  This is called by
1800    patch_file via RCS_checkout.  */
1801
1802 static void
1803 patch_file_write (void *callerdat, const char *buffer, size_t len)
1804 {
1805     struct patch_file_data *data = (struct patch_file_data *) callerdat;
1806
1807     if (fwrite (buffer, 1, len, data->fp) != len)
1808         error (1, errno, "cannot write %s", data->filename);
1809
1810     data->final_nl = (buffer[len - 1] == '\n');
1811
1812     if (data->compute_checksum)
1813         md5_process_bytes (buffer, len, &data->context);
1814 }
1815
1816 #endif /* SERVER_SUPPORT */
1817
1818 /*
1819  * Several of the types we process only print a bit of information consisting
1820  * of a single letter and the name.
1821  */
1822 void
1823 write_letter (struct file_info *finfo, int letter)
1824 {
1825     if (!really_quiet)
1826     {
1827         char *tag = NULL;
1828         /* Big enough for "+updated" or any of its ilk.  */
1829         char buf[80];
1830
1831         switch (letter)
1832         {
1833             case 'U':
1834                 tag = "updated";
1835                 break;
1836             default:
1837                 /* We don't yet support tagged output except for "U".  */
1838                 break;
1839         }
1840
1841         if (tag != NULL)
1842         {
1843             sprintf (buf, "+%s", tag);
1844             cvs_output_tagged (buf, NULL);
1845         }
1846         buf[0] = letter;
1847         buf[1] = ' ';
1848         buf[2] = '\0';
1849         cvs_output_tagged ("text", buf);
1850         cvs_output_tagged ("fname", finfo->fullname);
1851         cvs_output_tagged ("newline", NULL);
1852         if (tag != NULL)
1853         {
1854             sprintf (buf, "-%s", tag);
1855             cvs_output_tagged (buf, NULL);
1856         }
1857     }
1858     return;
1859 }
1860
1861
1862
1863 /* Reregister a file after a merge.  */
1864 static void
1865 RegisterMerge (struct file_info *finfo, Vers_TS *vers,
1866                const char *backup, int has_conflicts)
1867 {
1868     /* This file is the result of a merge, which means that it has
1869        been modified.  We use a special timestamp string which will
1870        not compare equal to any actual timestamp.  */
1871     char *cp = NULL;
1872
1873     if (has_conflicts)
1874     {
1875         time (&last_register_time);
1876         cp = time_stamp (finfo->file);
1877     }
1878     Register (finfo->entries, finfo->file, vers->vn_rcs ? vers->vn_rcs : "0",
1879               "Result of merge", vers->options, vers->tag, vers->date, cp);
1880     if (cp)
1881         free (cp);
1882
1883 #ifdef SERVER_SUPPORT
1884     /* Send the new contents of the file before the message.  If we
1885        wanted to be totally correct, we would have the client write
1886        the message only after the file has safely been written.  */
1887     if (server_active)
1888     {
1889         server_copy_file (finfo->file, finfo->update_dir, finfo->repository,
1890                           backup);
1891         server_updated (finfo, vers, SERVER_MERGED, (mode_t) -1, NULL, NULL);
1892     }
1893 #endif
1894 }
1895
1896
1897
1898 /*
1899  * Do all the magic associated with a file which needs to be merged
1900  */
1901 static int
1902 merge_file (struct file_info *finfo, Vers_TS *vers)
1903 {
1904     char *backup;
1905     int status;
1906     int retval;
1907
1908     assert (vers->vn_user);
1909
1910     /*
1911      * The users currently modified file is moved to a backup file name
1912      * ".#filename.version", so that it will stay around for a few days
1913      * before being automatically removed by some cron daemon.  The "version"
1914      * is the version of the file that the user was most up-to-date with
1915      * before the merge.
1916      */
1917     backup = Xasprintf ("%s%s.%s", BAKPREFIX, finfo->file, vers->vn_user);
1918
1919     if (unlink_file (backup) && !existence_error (errno))
1920         error (0, errno, "unable to remove %s", backup);
1921     copy_file (finfo->file, backup);
1922     xchmod (finfo->file, 1);
1923
1924     if (strcmp (vers->options, "-kb") == 0
1925         || wrap_merge_is_copy (finfo->file)
1926         || special_file_mismatch (finfo, NULL, vers->vn_rcs))
1927     {
1928         /* For binary files, a merge is always a conflict.  Same for
1929            files whose permissions or linkage do not match.  We give the
1930            user the two files, and let them resolve it.  It is possible
1931            that we should require a "touch foo" or similar step before
1932            we allow a checkin.  */
1933
1934         /* TODO: it may not always be necessary to regard a permission
1935            mismatch as a conflict.  The working file and the RCS file
1936            have a common ancestor `A'; if the working file's permissions
1937            match A's, then it's probably safe to overwrite them with the
1938            RCS permissions.  Only if the working file, the RCS file, and
1939            A all disagree should this be considered a conflict.  But more
1940            thought needs to go into this, and in the meantime it is safe
1941            to treat any such mismatch as an automatic conflict. -twp */
1942
1943         status = RCS_checkout (finfo->rcs, finfo->file, vers->vn_rcs,
1944                                vers->tag, vers->options, NULL, NULL, NULL);
1945         if (status)
1946         {
1947             error (0, 0, "failed to check out `%s' file", finfo->fullname);
1948             error (0, 0, "restoring `%s' from backup file `%s'",
1949                    finfo->fullname, backup);
1950             rename_file (backup, finfo->file);
1951             retval = 1;
1952             goto out;
1953         }
1954
1955         xchmod (finfo->file, 1);
1956
1957         RegisterMerge (finfo, vers, backup, 1);
1958
1959         /* Is there a better term than "nonmergeable file"?  What we
1960            really mean is, not something that CVS cannot or does not
1961            want to merge (there might be an external manual or
1962            automatic merge process).  */
1963         error (0, 0, "nonmergeable file needs merge");
1964         error (0, 0, "revision %s from repository is now in %s",
1965                vers->vn_rcs, finfo->fullname);
1966         error (0, 0, "file from working directory is now in %s", backup);
1967         write_letter (finfo, 'C');
1968
1969         history_write ('C', finfo->update_dir, vers->vn_rcs, finfo->file,
1970                        finfo->repository);
1971         retval = 0;
1972         goto out;
1973     }
1974
1975     status = RCS_merge (finfo->rcs, vers->srcfile->path, finfo->file,
1976                         vers->options, vers->vn_user, vers->vn_rcs);
1977     if (status != 0 && status != 1)
1978     {
1979         error (0, status == -1 ? errno : 0,
1980                "could not merge revision %s of %s", vers->vn_user, finfo->fullname);
1981         error (status == -1 ? 1 : 0, 0, "restoring %s from backup file %s",
1982                finfo->fullname, backup);
1983         rename_file (backup, finfo->file);
1984         retval = 1;
1985         goto out;
1986     }
1987
1988     if (strcmp (vers->options, "-V4") == 0)
1989         vers->options[0] = '\0';
1990
1991     /* fix up the vers structure, in case it is used by join */
1992     if (join_rev1)
1993     {
1994         /* FIXME: Throwing away the original revision info is almost
1995            certainly wrong -- what if join_rev1 is "BASE"?  */
1996         if (vers->vn_user != NULL)
1997             free (vers->vn_user);
1998         vers->vn_user = xstrdup (vers->vn_rcs);
1999     }
2000
2001     RegisterMerge (finfo, vers, backup, status);
2002
2003     if (status == 1)
2004     {
2005         error (0, 0, "conflicts found in %s", finfo->fullname);
2006
2007         write_letter (finfo, 'C');
2008
2009         history_write ('C', finfo->update_dir, vers->vn_rcs, finfo->file,
2010                        finfo->repository);
2011
2012     }
2013     else /* status == 0 */
2014     {
2015         history_write ('G', finfo->update_dir, vers->vn_rcs, finfo->file,
2016                        finfo->repository);
2017
2018         /* FIXME: the noexec case is broken.  RCS_merge could be doing the
2019            xcmp on the temporary files without much hassle, I think.  */
2020         if (!noexec && !xcmp (backup, finfo->file))
2021         {
2022             cvs_output (finfo->fullname, 0);
2023             cvs_output (" already contains the differences between ", 0);
2024             cvs_output (vers->vn_user, 0);
2025             cvs_output (" and ", 0);
2026             cvs_output (vers->vn_rcs, 0);
2027             cvs_output ("\n", 1);
2028
2029             retval = 0;
2030             goto out;
2031         }
2032
2033         write_letter (finfo, 'M');
2034     }
2035     retval = 0;
2036  out:
2037     free (backup);
2038     return retval;
2039 }
2040
2041
2042
2043 /*
2044  * Do all the magic associated with a file which needs to be joined
2045  * (reached via the -j option to checkout or update).
2046  *
2047  * INPUTS
2048  *   finfo              File information about the destination file.
2049  *   vers               The Vers_TS structure for finfo.
2050  *
2051  * GLOBALS
2052  *   join_rev1          From the command line.
2053  *   join_rev2          From the command line.
2054  *   server_active      Natch.
2055  *
2056  * ASSUMPTIONS
2057  *   1.  Is not called in client mode.
2058  */
2059 static void
2060 join_file (struct file_info *finfo, Vers_TS *vers)
2061 {
2062     char *backup;
2063     char *t_options;
2064     int status;
2065
2066     char *rev1;
2067     char *rev2;
2068     char *jrev1;
2069     char *jrev2;
2070     char *jdate1;
2071     char *jdate2;
2072
2073     TRACE (TRACE_FUNCTION, "join_file(%s, %s%s%s%s, %s, %s)",
2074            finfo->file,
2075            vers->tag ? vers->tag : "",
2076            vers->tag ? " (" : "",
2077            vers->vn_rcs ? vers->vn_rcs : "",
2078            vers->tag ? ")" : "",
2079            join_rev1 ? join_rev1 : "",
2080            join_rev2 ? join_rev2 : "");
2081
2082     jrev1 = join_rev1;
2083     jrev2 = join_rev2;
2084     jdate1 = join_date1;
2085     jdate2 = join_date2;
2086
2087     /* Determine if we need to do anything at all.  */
2088     if (vers->srcfile == NULL ||
2089         vers->srcfile->path == NULL)
2090     {
2091         return;
2092     }
2093
2094     /* If only one join revision is specified, it becomes the second
2095        revision.  */
2096     if (jrev2 == NULL)
2097     {
2098         jrev2 = jrev1;
2099         jrev1 = NULL;
2100         jdate2 = jdate1;
2101         jdate1 = NULL;
2102     }
2103
2104     /* FIXME: Need to handle "BASE" for jrev1 and/or jrev2.  Note caveat
2105        below about vn_user.  */
2106
2107     /* Convert the second revision, walking branches and dates.  */
2108     rev2 = RCS_getversion (vers->srcfile, jrev2, jdate2, 1, NULL);
2109
2110     /* If this is a merge of two revisions, get the first revision.
2111        If only one join tag was specified, then the first revision is
2112        the greatest common ancestor of the second revision and the
2113        working file.  */
2114     if (jrev1 != NULL)
2115         rev1 = RCS_getversion (vers->srcfile, jrev1, jdate1, 1, NULL);
2116     else
2117     {
2118         /* Note that we use vn_rcs here, since vn_user may contain a
2119            special string such as "-nn".  */
2120         if (vers->vn_rcs == NULL)
2121             rev1 = NULL;
2122         else if (rev2 == NULL)
2123         {
2124             /* This means that the file never existed on the branch.
2125                It does not mean that the file was removed on the
2126                branch: that case is represented by a dead rev2.  If
2127                the file never existed on the branch, then we have
2128                nothing to merge, so we just return.  */
2129             return;
2130         }
2131         else
2132             rev1 = gca (vers->vn_rcs, rev2);
2133     }
2134
2135     /* Handle a nonexistent or dead merge target.  */
2136     if (rev2 == NULL || RCS_isdead (vers->srcfile, rev2))
2137     {
2138         char *mrev;
2139
2140         if (rev2 != NULL)
2141             free (rev2);
2142
2143         /* If the first revision doesn't exist either, then there is
2144            no change between the two revisions, so we don't do
2145            anything.  */
2146         if (rev1 == NULL || RCS_isdead (vers->srcfile, rev1))
2147         {
2148             if (rev1 != NULL)
2149                 free (rev1);
2150             return;
2151         }
2152
2153         /* If we are merging two revisions, then the file was removed
2154            between the first revision and the second one.  In this
2155            case we want to mark the file for removal.
2156
2157            If we are merging one revision, then the file has been
2158            removed between the greatest common ancestor and the merge
2159            revision.  From the perspective of the branch on to which
2160            we ar emerging, which may be the trunk, either 1) the file
2161            does not currently exist on the target, or 2) the file has
2162            not been modified on the target branch since the greatest
2163            common ancestor, or 3) the file has been modified on the
2164            target branch since the greatest common ancestor.  In case
2165            1 there is nothing to do.  In case 2 we mark the file for
2166            removal.  In case 3 we have a conflict.
2167
2168            Note that the handling is slightly different depending upon
2169            whether one or two join targets were specified.  If two
2170            join targets were specified, we don't check whether the
2171            file was modified since a given point.  My reasoning is
2172            that if you ask for an explicit merge between two tags,
2173            then you want to merge in whatever was changed between
2174            those two tags.  If a file was removed between the two
2175            tags, then you want it to be removed.  However, if you ask
2176            for a merge of a branch, then you want to merge in all
2177            changes which were made on the branch.  If a file was
2178            removed on the branch, that is a change to the file.  If
2179            the file was also changed on the main line, then that is
2180            also a change.  These two changes--the file removal and the
2181            modification--must be merged.  This is a conflict.  */
2182
2183         /* If the user file is dead, or does not exist, or has been
2184            marked for removal, then there is nothing to do.  */
2185         if (vers->vn_user == NULL
2186             || vers->vn_user[0] == '-'
2187             || RCS_isdead (vers->srcfile, vers->vn_user))
2188         {
2189             if (rev1 != NULL)
2190                 free (rev1);
2191             return;
2192         }
2193
2194         /* If the user file has been marked for addition, or has been
2195            locally modified, then we have a conflict which we can not
2196            resolve.  No_Difference will already have been called in
2197            this case, so comparing the timestamps is sufficient to
2198            determine whether the file is locally modified.  */
2199         if (strcmp (vers->vn_user, "0") == 0
2200             || (vers->ts_user != NULL
2201                 && strcmp (vers->ts_user, vers->ts_rcs) != 0))
2202         {
2203             if (jdate2 != NULL)
2204                 error (0, 0,
2205                        "file %s is locally modified, but has been removed in revision %s as of %s",
2206                        finfo->fullname, jrev2, jdate2);
2207             else
2208                 error (0, 0,
2209                        "file %s is locally modified, but has been removed in revision %s",
2210                        finfo->fullname, jrev2);
2211
2212             /* FIXME: Should we arrange to return a non-zero exit
2213                status?  */
2214
2215             if (rev1 != NULL)
2216                 free (rev1);
2217
2218             return;
2219         }
2220
2221         /* If only one join tag was specified, and the user file has
2222            been changed since the greatest common ancestor (rev1),
2223            then there is a conflict we can not resolve.  See above for
2224            the rationale.  */
2225         if (join_rev2 == NULL
2226             && strcmp (rev1, vers->vn_user) != 0)
2227         {
2228             if (jdate2 != NULL)
2229                 error (0, 0,
2230                        "file %s has been modified, but has been removed in revision %s as of %s",
2231                        finfo->fullname, jrev2, jdate2);
2232             else
2233                 error (0, 0,
2234                        "file %s has been modified, but has been removed in revision %s",
2235                        finfo->fullname, jrev2);
2236
2237             /* FIXME: Should we arrange to return a non-zero exit
2238                status?  */
2239
2240             if (rev1 != NULL)
2241                 free (rev1);
2242
2243             return;
2244         }
2245
2246         if (rev1 != NULL)
2247             free (rev1);
2248
2249         /* The user file exists and has not been modified.  Mark it
2250            for removal.  FIXME: If we are doing a checkout, this has
2251            the effect of first checking out the file, and then
2252            removing it.  It would be better to just register the
2253            removal.
2254
2255            The same goes for a removal then an add.  e.g.
2256            cvs up -rbr -jbr2 could remove and readd the same file
2257          */
2258         /* save the rev since server_updated might invalidate it */
2259         mrev = Xasprintf ("-%s", vers->vn_user);
2260 #ifdef SERVER_SUPPORT
2261         if (server_active)
2262         {
2263             server_scratch (finfo->file);
2264             server_updated (finfo, vers, SERVER_UPDATED, (mode_t) -1,
2265                             NULL, NULL);
2266         }
2267 #endif
2268         Register (finfo->entries, finfo->file, mrev, vers->ts_rcs,
2269                   vers->options, vers->tag, vers->date, vers->ts_conflict);
2270         free (mrev);
2271         /* We need to check existence_error here because if we are
2272            running as the server, and the file is up to date in the
2273            working directory, the client will not have sent us a copy.  */
2274         if (unlink_file (finfo->file) < 0 && ! existence_error (errno))
2275             error (0, errno, "cannot remove file %s", finfo->fullname);
2276 #ifdef SERVER_SUPPORT
2277         if (server_active)
2278             server_checked_in (finfo->file, finfo->update_dir,
2279                                finfo->repository);
2280 #endif
2281         if (! really_quiet)
2282             error (0, 0, "scheduling `%s' for removal", finfo->fullname);
2283
2284         return;
2285     }
2286
2287     /* If the two merge revisions are the same, then there is nothing
2288      * to do.  This needs to be checked before the rev2 == up-to-date base
2289      * revision check tha comes next.  Otherwise, rev1 can == rev2 and get an
2290      * "already contains the changes between <rev1> and <rev1>" message.
2291      */
2292     if (rev1 && strcmp (rev1, rev2) == 0)
2293     {
2294         free (rev1);
2295         free (rev2);
2296         return;
2297     }
2298
2299     /* If we know that the user file is up-to-date, then it becomes an
2300      * optimization to skip the merge when rev2 is the same as the base
2301      * revision.  i.e. we know that diff3(file2,file1,file2) will produce
2302      * file2.
2303      */
2304     if (vers->vn_user != NULL && vers->ts_user != NULL
2305         && strcmp (vers->ts_user, vers->ts_rcs) == 0
2306         && strcmp (rev2, vers->vn_user) == 0)
2307     {
2308         if (!really_quiet)
2309         {
2310             cvs_output (finfo->fullname, 0);
2311             cvs_output (" already contains the differences between ", 0);
2312             cvs_output (rev1 ? rev1 : "creation", 0);
2313             cvs_output (" and ", 0);
2314             cvs_output (rev2, 0);
2315             cvs_output ("\n", 1);
2316         }
2317
2318         if (rev1 != NULL)
2319             free (rev1);
2320         free (rev2);
2321
2322         return;
2323     }
2324
2325     /* If rev1 is dead or does not exist, then the file was added
2326        between rev1 and rev2.  */
2327     if (rev1 == NULL || RCS_isdead (vers->srcfile, rev1))
2328     {
2329         if (rev1 != NULL)
2330             free (rev1);
2331         free (rev2);
2332
2333         /* If the file does not exist in the working directory, then
2334            we can just check out the new revision and mark it for
2335            addition.  */
2336         if (vers->vn_user == NULL)
2337         {
2338             char *saved_options = options;
2339             Vers_TS *xvers;
2340
2341             xvers = Version_TS (finfo, vers->options, jrev2, jdate2, 1, 0);
2342
2343             /* Reset any keyword expansion option.  Otherwise, when a
2344                command like `cvs update -kk -jT1 -jT2' creates a new file
2345                (because a file had the T2 tag, but not T1), the subsequent
2346                commit of that just-added file effectively would set the
2347                admin `-kk' option for that file in the repository.  */
2348             options = NULL;
2349
2350             /* FIXME: If checkout_file fails, we should arrange to
2351                return a non-zero exit status.  */
2352             status = checkout_file (finfo, xvers, 1, 0, 1);
2353             options = saved_options;
2354
2355             freevers_ts (&xvers);
2356
2357             return;
2358         }
2359
2360         /* The file currently exists in the working directory, so we
2361            have a conflict which we can not resolve.  Note that this
2362            is true even if the file is marked for addition or removal.  */
2363
2364         if (jdate2 != NULL)
2365             error (0, 0,
2366                    "file %s exists, but has been added in revision %s as of %s",
2367                    finfo->fullname, jrev2, jdate2);
2368         else
2369             error (0, 0,
2370                    "file %s exists, but has been added in revision %s",
2371                    finfo->fullname, jrev2);
2372
2373         return;
2374     }
2375
2376     /* If there is no working file, then we can't do the merge.  */
2377     if (vers->vn_user == NULL || vers->vn_user[0] == '-')
2378     {
2379         free (rev1);
2380         free (rev2);
2381
2382         if (jdate2 != NULL)
2383             error (0, 0,
2384                    "file %s does not exist, but is present in revision %s as of %s",
2385                    finfo->fullname, jrev2, jdate2);
2386         else
2387             error (0, 0,
2388                    "file %s does not exist, but is present in revision %s",
2389                    finfo->fullname, jrev2);
2390
2391         /* FIXME: Should we arrange to return a non-zero exit status?  */
2392
2393         return;
2394     }
2395
2396 #ifdef SERVER_SUPPORT
2397     if (server_active && !isreadable (finfo->file))
2398     {
2399         int retcode;
2400         /* The file is up to date.  Need to check out the current contents.  */
2401         /* FIXME - see the FIXME comment above the call to RCS_checkout in the
2402          * patch_file function.
2403          */
2404         retcode = RCS_checkout (vers->srcfile, finfo->file,
2405                                 vers->vn_user, vers->tag,
2406                                 NULL, RUN_TTY, NULL, NULL);
2407         if (retcode != 0)
2408             error (1, 0,
2409                    "failed to check out %s file", finfo->fullname);
2410     }
2411 #endif
2412
2413     /*
2414      * The users currently modified file is moved to a backup file name
2415      * ".#filename.version", so that it will stay around for a few days
2416      * before being automatically removed by some cron daemon.  The "version"
2417      * is the version of the file that the user was most up-to-date with
2418      * before the merge.
2419      */
2420     backup = Xasprintf ("%s%s.%s", BAKPREFIX, finfo->file, vers->vn_user);
2421
2422     if (unlink_file (backup) < 0
2423         && !existence_error (errno))
2424         error (0, errno, "cannot remove %s", backup);
2425     copy_file (finfo->file, backup);
2426     xchmod (finfo->file, 1);
2427
2428     t_options = vers->options;
2429 #if 0
2430     if (*t_options == '\0')
2431         t_options = "-kk";              /* to ignore keyword expansions */
2432 #endif
2433
2434     /* If the source of the merge is the same as the working file
2435        revision, then we can just RCS_checkout the target (no merging
2436        as such).  In the text file case, this is probably quite
2437        similar to the RCS_merge, but in the binary file case,
2438        RCS_merge gives all kinds of trouble.  */
2439     if (vers->vn_user != NULL
2440         && strcmp (rev1, vers->vn_user) == 0
2441         /* See comments above about how No_Difference has already been
2442            called.  */
2443         && vers->ts_user != NULL
2444         && strcmp (vers->ts_user, vers->ts_rcs) == 0
2445
2446         /* Avoid this in the text file case.  See below for why.
2447          */
2448         && (strcmp (t_options, "-kb") == 0
2449             || wrap_merge_is_copy (finfo->file)))
2450     {
2451         /* FIXME: Verify my comment below:
2452          *
2453          * RCS_merge does nothing with keywords.  It merges the changes between
2454          * two revisions without expanding the keywords (it might expand in
2455          * -kk mode before computing the diff between rev1 and rev2 - I'm not
2456          * sure).  In other words, the keyword lines in the current work file
2457          * get left alone.
2458          *
2459          * Therfore, checking out the destination revision (rev2) is probably
2460          * incorrect in the text case since we should see the keywords that were
2461          * substituted into the original file at the time it was checked out
2462          * and not the keywords from rev2.
2463          *
2464          * Also, it is safe to pass in NULL for nametag since we know no
2465          * substitution is happening during the binary mode checkout.
2466          */
2467         if (RCS_checkout (finfo->rcs, finfo->file, rev2, NULL, t_options,
2468                           RUN_TTY, NULL, NULL) != 0)
2469             status = 2;
2470         else
2471             status = 0;
2472
2473         /* OK, this is really stupid.  RCS_checkout carefully removes
2474            write permissions, and we carefully put them back.  But
2475            until someone gets around to fixing it, that seems like the
2476            easiest way to get what would seem to be the right mode.
2477            I don't check CVSWRITE or _watched; I haven't thought about
2478            that in great detail, but it seems like a watched file should
2479            be checked out (writable) after a merge.  */
2480         xchmod (finfo->file, 1);
2481
2482         /* Traditionally, the text file case prints a whole bunch of
2483            scary looking and verbose output which fails to tell the user
2484            what is really going on (it gives them rev1 and rev2 but doesn't
2485            indicate in any way that rev1 == vn_user).  I think just a
2486            simple "U foo" is good here; it seems analogous to the case in
2487            which the file was added on the branch in terms of what to
2488            print.  */
2489         write_letter (finfo, 'U');
2490     }
2491     else if (strcmp (t_options, "-kb") == 0
2492              || wrap_merge_is_copy (finfo->file)
2493              || special_file_mismatch (finfo, rev1, rev2))
2494     {
2495         /* We are dealing with binary files, or files with a
2496            permission/linkage mismatch (this second case only occurs when
2497            PRESERVE_PERMISSIONS_SUPPORT is enabled), and real merging would
2498            need to take place.  This is a conflict.  We give the user
2499            the two files, and let them resolve it.  It is possible
2500            that we should require a "touch foo" or similar step before
2501            we allow a checkin.  */
2502         if (RCS_checkout (finfo->rcs, finfo->file, rev2, NULL,
2503                           t_options, RUN_TTY, NULL, NULL) != 0)
2504             status = 2;
2505         else
2506             status = 0;
2507
2508         /* OK, this is really stupid.  RCS_checkout carefully removes
2509            write permissions, and we carefully put them back.  But
2510            until someone gets around to fixing it, that seems like the
2511            easiest way to get what would seem to be the right mode.
2512            I don't check CVSWRITE or _watched; I haven't thought about
2513            that in great detail, but it seems like a watched file should
2514            be checked out (writable) after a merge.  */
2515         xchmod (finfo->file, 1);
2516
2517         /* Hmm.  We don't give them REV1 anywhere.  I guess most people
2518            probably don't have a 3-way merge tool for the file type in
2519            question, and might just get confused if we tried to either
2520            provide them with a copy of the file from REV1, or even just
2521            told them what REV1 is so they can get it themself, but it
2522            might be worth thinking about.  */
2523         /* See comment in merge_file about the "nonmergeable file"
2524            terminology.  */
2525         error (0, 0, "nonmergeable file needs merge");
2526         error (0, 0, "revision %s from repository is now in %s",
2527                rev2, finfo->fullname);
2528         error (0, 0, "file from working directory is now in %s", backup);
2529         write_letter (finfo, 'C');
2530     }
2531     else
2532         status = RCS_merge (finfo->rcs, vers->srcfile->path, finfo->file,
2533                             t_options, rev1, rev2);
2534
2535     if (status != 0)
2536     {
2537         if (status != 1)
2538         {
2539             error (0, status == -1 ? errno : 0,
2540                    "could not merge revision %s of %s", rev2, finfo->fullname);
2541             error (status == -1 ? 1 : 0, 0, "restoring %s from backup file %s",
2542                    finfo->fullname, backup);
2543             rename_file (backup, finfo->file);
2544         }
2545     }
2546     else /* status == 0 */
2547     {
2548         /* FIXME: the noexec case is broken.  RCS_merge could be doing the
2549            xcmp on the temporary files without much hassle, I think.  */
2550         if (!noexec && !xcmp (backup, finfo->file))
2551         {
2552             if (!really_quiet)
2553             {
2554                 cvs_output (finfo->fullname, 0);
2555                 cvs_output (" already contains the differences between ", 0);
2556                 cvs_output (rev1, 0);
2557                 cvs_output (" and ", 0);
2558                 cvs_output (rev2, 0);
2559                 cvs_output ("\n", 1);
2560             }
2561
2562             /* and skip the registering and sending the new file since it
2563              * hasn't been updated.
2564              */
2565             goto out;
2566         }
2567     }
2568
2569     /* The file has changed, but if we just checked it out it may
2570        still have the same timestamp it did when it was first
2571        registered above in checkout_file.  We register it again with a
2572        dummy timestamp to make sure that later runs of CVS will
2573        recognize that it has changed.
2574
2575        We don't actually need to register again if we called
2576        RCS_checkout above, and we aren't running as the server.
2577        However, that is not the normal case, and calling Register
2578        again won't cost much in that case.  */
2579     RegisterMerge (finfo, vers, backup, status);
2580
2581 out:
2582     free (rev1);
2583     free (rev2);
2584     free (backup);
2585 }
2586
2587
2588
2589 /*
2590  * Report whether revisions REV1 and REV2 of FINFO agree on:
2591  *   . file ownership
2592  *   . permissions
2593  *   . major and minor device numbers
2594  *   . symbolic links
2595  *   . hard links
2596  *
2597  * If either REV1 or REV2 is NULL, the working copy is used instead.
2598  *
2599  * Return 1 if the files differ on these data.
2600  */
2601
2602 int
2603 special_file_mismatch (struct file_info *finfo, char *rev1, char *rev2)
2604 {
2605 #ifdef PRESERVE_PERMISSIONS_SUPPORT
2606     struct stat sb;
2607     RCSVers *vp;
2608     Node *n;
2609     uid_t rev1_uid, rev2_uid;
2610     gid_t rev1_gid, rev2_gid;
2611     mode_t rev1_mode, rev2_mode;
2612     unsigned long dev_long;
2613     dev_t rev1_dev, rev2_dev;
2614     char *rev1_symlink = NULL;
2615     char *rev2_symlink = NULL;
2616     List *rev1_hardlinks = NULL;
2617     List *rev2_hardlinks = NULL;
2618     int check_uids, check_gids, check_modes;
2619     int result;
2620
2621     /* If we don't care about special file info, then
2622        don't report a mismatch in any case. */
2623     if (!preserve_perms)
2624         return 0;
2625
2626     /* When special_file_mismatch is called from No_Difference, the
2627        RCS file has been only partially parsed.  We must read the
2628        delta tree in order to compare special file info recorded in
2629        the delta nodes.  (I think this is safe. -twp) */
2630     if (finfo->rcs->flags & PARTIAL)
2631         RCS_reparsercsfile (finfo->rcs, NULL, NULL);
2632
2633     check_uids = check_gids = check_modes = 1;
2634
2635     /* Obtain file information for REV1.  If this is null, then stat
2636        finfo->file and use that info. */
2637     /* If a revision does not know anything about its status,
2638        then presumably it doesn't matter, and indicates no conflict. */
2639
2640     if (rev1 == NULL)
2641     {
2642         ssize_t rsize;
2643
2644         if ((rsize = islink (finfo->file)) > 0)
2645             rev1_symlink = Xreadlink (finfo->file, rsize);
2646         else
2647         {
2648 # ifdef HAVE_STRUCT_STAT_ST_RDEV
2649             if (lstat (finfo->file, &sb) < 0)
2650                 error (1, errno, "could not get file information for %s",
2651                        finfo->file);
2652             rev1_uid = sb.st_uid;
2653             rev1_gid = sb.st_gid;
2654             rev1_mode = sb.st_mode;
2655             if (S_ISBLK (rev1_mode) || S_ISCHR (rev1_mode))
2656                 rev1_dev = sb.st_rdev;
2657 # else
2658             error (1, 0, "cannot handle device files on this system (%s)",
2659                    finfo->file);
2660 # endif
2661         }
2662         rev1_hardlinks = list_linked_files_on_disk (finfo->file);
2663     }
2664     else
2665     {
2666         n = findnode (finfo->rcs->versions, rev1);
2667         vp = n->data;
2668
2669         n = findnode (vp->other_delta, "symlink");
2670         if (n != NULL)
2671             rev1_symlink = xstrdup (n->data);
2672         else
2673         {
2674             n = findnode (vp->other_delta, "owner");
2675             if (n == NULL)
2676                 check_uids = 0; /* don't care */
2677             else
2678                 rev1_uid = strtoul (n->data, NULL, 10);
2679
2680             n = findnode (vp->other_delta, "group");
2681             if (n == NULL)
2682                 check_gids = 0; /* don't care */
2683             else
2684                 rev1_gid = strtoul (n->data, NULL, 10);
2685
2686             n = findnode (vp->other_delta, "permissions");
2687             if (n == NULL)
2688                 check_modes = 0;        /* don't care */
2689             else
2690                 rev1_mode = strtoul (n->data, NULL, 8);
2691
2692             n = findnode (vp->other_delta, "special");
2693             if (n == NULL)
2694                 rev1_mode |= S_IFREG;
2695             else
2696             {
2697                 /* If the size of `ftype' changes, fix the sscanf call also */
2698                 char ftype[16];
2699                 if (sscanf (n->data, "%15s %lu", ftype,
2700                             &dev_long) < 2)
2701                     error (1, 0, "%s:%s has bad `special' newphrase %s",
2702                            finfo->file, rev1, (char *)n->data);
2703                 rev1_dev = dev_long;
2704                 if (strcmp (ftype, "character") == 0)
2705                     rev1_mode |= S_IFCHR;
2706                 else if (strcmp (ftype, "block") == 0)
2707                     rev1_mode |= S_IFBLK;
2708                 else
2709                     error (0, 0, "%s:%s unknown file type `%s'",
2710                            finfo->file, rev1, ftype);
2711             }
2712
2713             rev1_hardlinks = vp->hardlinks;
2714             if (rev1_hardlinks == NULL)
2715                 rev1_hardlinks = getlist();
2716         }
2717     }
2718
2719     /* Obtain file information for REV2. */
2720     if (rev2 == NULL)
2721     {
2722         ssize_t rsize;
2723
2724         if ((rsize = islink (finfo->file)) > 0)
2725             rev2_symlink = Xreadlink (finfo->file, rsize);
2726         else
2727         {
2728 # ifdef HAVE_STRUCT_STAT_ST_RDEV
2729             if (lstat (finfo->file, &sb) < 0)
2730                 error (1, errno, "could not get file information for %s",
2731                        finfo->file);
2732             rev2_uid = sb.st_uid;
2733             rev2_gid = sb.st_gid;
2734             rev2_mode = sb.st_mode;
2735             if (S_ISBLK (rev2_mode) || S_ISCHR (rev2_mode))
2736                 rev2_dev = sb.st_rdev;
2737 # else
2738             error (1, 0, "cannot handle device files on this system (%s)",
2739                    finfo->file);
2740 # endif
2741         }
2742         rev2_hardlinks = list_linked_files_on_disk (finfo->file);
2743     }
2744     else
2745     {
2746         n = findnode (finfo->rcs->versions, rev2);
2747         vp = n->data;
2748
2749         n = findnode (vp->other_delta, "symlink");
2750         if (n != NULL)
2751             rev2_symlink = xstrdup (n->data);
2752         else
2753         {
2754             n = findnode (vp->other_delta, "owner");
2755             if (n == NULL)
2756                 check_uids = 0; /* don't care */
2757             else
2758                 rev2_uid = strtoul (n->data, NULL, 10);
2759
2760             n = findnode (vp->other_delta, "group");
2761             if (n == NULL)
2762                 check_gids = 0; /* don't care */
2763             else
2764                 rev2_gid = strtoul (n->data, NULL, 10);
2765
2766             n = findnode (vp->other_delta, "permissions");
2767             if (n == NULL)
2768                 check_modes = 0;        /* don't care */
2769             else
2770                 rev2_mode = strtoul (n->data, NULL, 8);
2771
2772             n = findnode (vp->other_delta, "special");
2773             if (n == NULL)
2774                 rev2_mode |= S_IFREG;
2775             else
2776             {
2777                 /* If the size of `ftype' changes, fix the sscanf call also */
2778                 char ftype[16];
2779                 if (sscanf (n->data, "%15s %lu", ftype,
2780                             &dev_long) < 2)
2781                     error (1, 0, "%s:%s has bad `special' newphrase %s",
2782                            finfo->file, rev2, (char *)n->data);
2783                 rev2_dev = dev_long;
2784                 if (strcmp (ftype, "character") == 0)
2785                     rev2_mode |= S_IFCHR;
2786                 else if (strcmp (ftype, "block") == 0)
2787                     rev2_mode |= S_IFBLK;
2788                 else
2789                     error (0, 0, "%s:%s unknown file type `%s'",
2790                            finfo->file, rev2, ftype);
2791             }
2792
2793             rev2_hardlinks = vp->hardlinks;
2794             if (rev2_hardlinks == NULL)
2795                 rev2_hardlinks = getlist();
2796         }
2797     }
2798
2799     /* Check the user/group ownerships and file permissions, printing
2800        an error for each mismatch found.  Return 0 if all characteristics
2801        matched, and 1 otherwise. */
2802
2803     result = 0;
2804
2805     /* Compare symlinks first, since symlinks are simpler (don't have
2806        any other characteristics). */
2807     if (rev1_symlink != NULL && rev2_symlink == NULL)
2808     {
2809         error (0, 0, "%s is a symbolic link",
2810                (rev1 == NULL ? "working file" : rev1));
2811         result = 1;
2812     }
2813     else if (rev1_symlink == NULL && rev2_symlink != NULL)
2814     {
2815         error (0, 0, "%s is a symbolic link",
2816                (rev2 == NULL ? "working file" : rev2));
2817         result = 1;
2818     }
2819     else if (rev1_symlink != NULL)
2820         result = (strcmp (rev1_symlink, rev2_symlink) == 0);
2821     else
2822     {
2823         /* Compare user ownership. */
2824         if (check_uids && rev1_uid != rev2_uid)
2825         {
2826             error (0, 0, "%s: owner mismatch between %s and %s",
2827                    finfo->file,
2828                    (rev1 == NULL ? "working file" : rev1),
2829                    (rev2 == NULL ? "working file" : rev2));
2830             result = 1;
2831         }
2832
2833         /* Compare group ownership. */
2834         if (check_gids && rev1_gid != rev2_gid)
2835         {
2836             error (0, 0, "%s: group mismatch between %s and %s",
2837                    finfo->file,
2838                    (rev1 == NULL ? "working file" : rev1),
2839                    (rev2 == NULL ? "working file" : rev2));
2840             result = 1;
2841         }
2842
2843         /* Compare permissions. */
2844         if (check_modes &&
2845             (rev1_mode & 07777) != (rev2_mode & 07777))
2846         {
2847             error (0, 0, "%s: permission mismatch between %s and %s",
2848                    finfo->file,
2849                    (rev1 == NULL ? "working file" : rev1),
2850                    (rev2 == NULL ? "working file" : rev2));
2851             result = 1;
2852         }
2853
2854         /* Compare device file characteristics. */
2855         if ((rev1_mode & S_IFMT) != (rev2_mode & S_IFMT))
2856         {
2857             error (0, 0, "%s: %s and %s are different file types",
2858                    finfo->file,
2859                    (rev1 == NULL ? "working file" : rev1),
2860                    (rev2 == NULL ? "working file" : rev2));
2861             result = 1;
2862         }
2863         else if (S_ISBLK (rev1_mode))
2864         {
2865             if (rev1_dev != rev2_dev)
2866             {
2867                 error (0, 0, "%s: device numbers of %s and %s do not match",
2868                        finfo->file,
2869                        (rev1 == NULL ? "working file" : rev1),
2870                        (rev2 == NULL ? "working file" : rev2));
2871                 result = 1;
2872             }
2873         }
2874
2875         /* Compare hard links. */
2876         if (compare_linkage_lists (rev1_hardlinks, rev2_hardlinks) == 0)
2877         {
2878             error (0, 0, "%s: hard linkage of %s and %s do not match",
2879                    finfo->file,
2880                    (rev1 == NULL ? "working file" : rev1),
2881                    (rev2 == NULL ? "working file" : rev2));
2882             result = 1;
2883         }
2884     }
2885
2886     if (rev1_symlink != NULL)
2887         free (rev1_symlink);
2888     if (rev2_symlink != NULL)
2889         free (rev2_symlink);
2890     if (rev1_hardlinks != NULL)
2891         dellist (&rev1_hardlinks);
2892     if (rev2_hardlinks != NULL)
2893         dellist (&rev2_hardlinks);
2894
2895     return result;
2896 #else
2897     return 0;
2898 #endif
2899 }
2900
2901
2902
2903 int
2904 joining (void)
2905 {
2906     return join_rev1 || join_date1;
2907 }