external/gpl2/xcvs/dist/src/release.c

   1 /*
   2  * Copyright (C) 1994-2005 The Free Software Foundation, Inc.
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2, or (at your option)
   7  * any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  */
  14
  15 /*
  16  * Release: "cancel" a checkout in the history log.
  17  *
  18  * - Enter a line in the history log indicating the "release". - If asked to,
  19  * delete the local working directory.
  20  */
  21
  22 #include "cvs.h"
  23 #include "save-cwd.h"
  24 #include "getline.h"
  25 #include "yesno.h"
  26
  27 static const char *const release_usage[] =
  28 {
  29     "Usage: %s %s [-d] directories...\n",
  30     "\t-d\tDelete the given directory.\n",
  31     "(Specify the --help global option for a list of other help options)\n",
  32     NULL
  33 };
  34
  35 #ifdef SERVER_SUPPORT
  36 static int release_server (int argc, char **argv);
  37
  38 /* This is the server side of cvs release.  */
  39 static int
  40 release_server (int argc, char **argv)
  41 {
  42     int i;
  43
  44     /* Note that we skip argv[0].  */
  45     for (i = 1; i < argc; ++i)
  46         history_write ('F', argv[i], "", argv[i], "");
  47     return 0;
  48 }
  49
  50 #endif /* SERVER_SUPPORT */
  51
  52 /* Construct an update command.  Be sure to add authentication and
  53 * encryption if we are using them currently, else our child process may
  54 * not be able to communicate with the server.
  55 */
  56 static FILE *
  57 setup_update_command (pid_t *child_pid)
  58 {
  59     int tofd, fromfd;
  60
  61     run_setup (program_path);
  62
  63 #if defined (CLIENT_SUPPORT) || defined (SERVER_SUPPORT)
  64     /* Be sure to add authentication and encryption if we are using them
  65      * currently, else our child process may not be able to communicate with
  66      * the server.
  67      */
  68     if (cvsauthenticate) run_add_arg ("-a");
  69     if (cvsencrypt) run_add_arg ("-x");
  70 #endif
  71
  72     /* Don't really change anything.  */
  73     run_add_arg ("-n");
  74
  75     /* Don't need full verbosity.  */
  76     run_add_arg ("-q");
  77
  78     /* Propogate our CVSROOT.  */
  79     run_add_arg ("-d");
  80     run_add_arg (original_parsed_root->original);
  81
  82     run_add_arg ("update");
  83     *child_pid = run_piped (&tofd, &fromfd);
  84     if (*child_pid < 0)
  85         error (1, 0, "could not fork server process");
  86
  87     close (tofd);
  88
  89     return fdopen (fromfd, "r");
  90 }
  91
  92
  93
  94 static int
  95 close_update_command (FILE *fp, pid_t child_pid)
  96 {
  97     int status;
  98     pid_t w;
  99
 100     do
 101         w = waitpid (child_pid, &status, 0);
 102     while (w == -1 && errno == EINTR);
 103     if (w == -1)
 104         error (1, errno, "waiting for process %d", child_pid);
 105
 106     return status;
 107 }
 108
 109
 110
 111 /* There are various things to improve about this implementation:
 112
 113    1.  Using run_popen to run "cvs update" could be replaced by a
 114    fairly simple start_recursion/classify_file loop--a win for
 115    portability, performance, and cleanliness.  In particular, there is
 116    no particularly good way to find the right "cvs".
 117
 118    2.  The fact that "cvs update" contacts the server slows things down;
 119    it undermines the case for using "cvs release" rather than "rm -rf".
 120    However, for correctly printing "? foo" and correctly handling
 121    CVSROOTADM_IGNORE, we currently need to contact the server.  (One
 122    idea for how to fix this is to stash a copy of CVSROOTADM_IGNORE in
 123    the working directories; see comment at base_* in entries.c for a
 124    few thoughts on that).
 125
 126    3.  Would be nice to take processing things on the client side one step
 127    further, and making it like edit/unedit in terms of working well if
 128    disconnected from the network, and then sending a delayed
 129    notification.
 130
 131    4.  Having separate network turnarounds for the "Notify" request
 132    which we do as part of unedit, and for the "release" itself, is slow
 133    and unnecessary.  */
 134
 135 int
 136 release (int argc, char **argv)
 137 {
 138     FILE *fp;
 139     int i, c;
 140     char *line = NULL;
 141     size_t line_allocated = 0;
 142     char *thisarg;
 143     int arg_start_idx;
 144     int err = 0;
 145     short delete_flag = 0;
 146     struct saved_cwd cwd;
 147
 148 #ifdef SERVER_SUPPORT
 149     if (server_active)
 150         return release_server (argc, argv);
 151 #endif
 152
 153     /* Everything from here on is client or local.  */
 154     if (argc == -1)
 155         usage (release_usage);
 156     getoptreset ();
 157     while ((c = getopt (argc, argv, "+Qdq")) != -1)
 158     {
 159         switch (c)
 160         {
 161             case 'Q':
 162             case 'q':
 163                 error (1, 0,
 164                        "-q or -Q must be specified before \"%s\"",
 165                        cvs_cmd_name);
 166                 break;
 167             case 'd':
 168                 delete_flag++;
 169                 break;
 170             case '?':
 171             default:
 172                 usage (release_usage);
 173                 break;
 174         }
 175     }
 176     argc -= optind;
 177     argv += optind;
 178
 179     /* We're going to run "cvs -n -q update" and check its output; if
 180      * the output is sufficiently unalarming, then we release with no
 181      * questions asked.  Else we prompt, then maybe release.
 182      * (Well, actually we ask no matter what.  Our notion of "sufficiently
 183      * unalarming" doesn't take into account "? foo.c" files, so it is
 184      * up to the user to take note of them, at least currently
 185      * (ignore-193 in testsuite)).
 186      */
 187
 188 #ifdef CLIENT_SUPPORT
 189     /* Start the server; we'll close it after looping. */
 190     if (current_parsed_root->isremote)
 191     {
 192         start_server ();
 193         ign_setup ();
 194     }
 195 #endif /* CLIENT_SUPPORT */
 196
 197     /* Remember the directory where "cvs release" was invoked because
 198        all args are relative to this directory and we chdir around.
 199        */
 200     if (save_cwd (&cwd))
 201         error (1, errno, "Failed to save current directory.");
 202
 203     arg_start_idx = 0;
 204
 205     for (i = arg_start_idx; i < argc; i++)
 206     {
 207         thisarg = argv[i];
 208
 209         if (isdir (thisarg))
 210         {
 211             if (CVS_CHDIR (thisarg) < 0)
 212             {
 213                 if (!really_quiet)
 214                     error (0, errno, "can't chdir to: %s", thisarg);
 215                 continue;
 216             }
 217             if (!isdir (CVSADM))
 218             {
 219                 if (!really_quiet)
 220                     error (0, 0, "no repository directory: %s", thisarg);
 221                 if (restore_cwd (&cwd))
 222                     error (1, errno,
 223                            "Failed to restore current directory, `%s'.",
 224                            cwd.name);
 225                 continue;
 226             }
 227         }
 228         else
 229         {
 230             if (!really_quiet)
 231                 error (0, 0, "no such directory: %s", thisarg);
 232             continue;
 233         }
 234
 235         if (!really_quiet)
 236         {
 237             int line_length, status;
 238             pid_t child_pid;
 239
 240             /* The "release" command piggybacks on "update", which
 241                does the real work of finding out if anything is not
 242                up-to-date with the repository.  Then "release" prompts
 243                the user, telling her how many files have been
 244                modified, and asking if she still wants to do the
 245                release.  */
 246             fp = setup_update_command (&child_pid);
 247             if (fp == NULL)
 248             {
 249                 error (0, 0, "cannot run command:");
 250                 run_print (stderr);
 251                 error (1, 0, "Exiting due to fatal error referenced above.");
 252             }
 253
 254             c = 0;
 255
 256             while ((line_length = getline (&line, &line_allocated, fp)) >= 0)
 257             {
 258                 if (strchr ("MARCZ", *line))
 259                     c++;
 260                 (void) fputs (line, stdout);
 261             }
 262             if (line_length < 0 && !feof (fp))
 263                 error (0, errno, "cannot read from subprocess");
 264
 265             /* If the update exited with an error, then we just want to
 266                complain and go on to the next arg.  Especially, we do
 267                not want to delete the local copy, since it's obviously
 268                not what the user thinks it is.  */
 269             status = close_update_command (fp, child_pid);
 270             if (status != 0)
 271             {
 272                 error (0, 0, "unable to release `%s' (%d)", thisarg, status);
 273                 if (restore_cwd (&cwd))
 274                     error (1, errno,
 275                            "Failed to restore current directory, `%s'.",
 276                            cwd.name);
 277                 continue;
 278             }
 279
 280             printf ("You have [%d] altered files in this repository.\n",
 281                     c);
 282
 283             if (!noexec)
 284             {
 285                 printf ("Are you sure you want to release %sdirectory `%s': ",
 286                         delete_flag ? "(and delete) " : "", thisarg);
 287                 fflush (stderr);
 288                 fflush (stdout);
 289                 if (!yesno ())                  /* "No" */
 290                 {
 291                     (void) fprintf (stderr,
 292                                     "** `%s' aborted by user choice.\n",
 293                                     cvs_cmd_name);
 294                     if (restore_cwd (&cwd))
 295                         error (1, errno,
 296                                "Failed to restore current directory, `%s'.",
 297                                cwd.name);
 298                     continue;
 299                 }
 300             }
 301             else
 302             {
 303                 if (restore_cwd (&cwd))
 304                     error (1, errno,
 305                            "Failed to restore current directory, `%s'.",
 306                            cwd.name);
 307                 continue;
 308             }
 309         }
 310
 311         /* Note:  client.c doesn't like to have other code
 312            changing the current directory on it.  So a fair amount
 313            of effort is needed to make sure it doesn't get confused
 314            about the directory and (for example) overwrite
 315            CVS/Entries file in the wrong directory.  See release-17
 316            through release-23. */
 317
 318         if (restore_cwd (&cwd))
 319             error (1, errno, "Failed to restore current directory, `%s'.",
 320                    cwd.name);
 321
 322 #ifdef CLIENT_SUPPORT
 323         if (!current_parsed_root->isremote
 324             || (supported_request ("noop") && supported_request ("Notify")))
 325 #endif
 326         {
 327             int argc = 2;
 328             char *argv[3];
 329             argv[0] = "dummy";
 330             argv[1] = thisarg;
 331             argv[2] = NULL;
 332             err += unedit (argc, argv);
 333             if (restore_cwd (&cwd))
 334                 error (1, errno, "Failed to restore current directory, `%s'.",
 335                        cwd.name);
 336         }
 337
 338 #ifdef CLIENT_SUPPORT
 339         if (current_parsed_root->isremote)
 340         {
 341             send_to_server ("Argument ", 0);
 342             send_to_server (thisarg, 0);
 343             send_to_server ("\012", 1);
 344             send_to_server ("release\012", 0);
 345         }
 346         else
 347 #endif /* CLIENT_SUPPORT */
 348         {
 349             history_write ('F', thisarg, "", thisarg, ""); /* F == Free */
 350         }
 351
 352         if (delete_flag)
 353         {
 354             /* FIXME?  Shouldn't this just delete the CVS-controlled
 355                files and, perhaps, the files that would normally be
 356                ignored and leave everything else?  */
 357
 358             if (unlink_file_dir (thisarg) < 0)
 359                 error (0, errno, "deletion of directory %s failed", thisarg);
 360         }
 361
 362 #ifdef CLIENT_SUPPORT
 363         if (current_parsed_root->isremote)
 364         {
 365             /* FIXME:
 366              * Is there a good reason why get_server_responses() isn't
 367              * responsible for restoring its initial directory itself when
 368              * finished?
 369              */
 370             err += get_server_responses ();
 371
 372             if (restore_cwd (&cwd))
 373                 error (1, errno, "Failed to restore current directory, `%s'.",
 374                        cwd.name);
 375         }
 376 #endif /* CLIENT_SUPPORT */
 377     }
 378
 379     if (restore_cwd (&cwd))
 380         error (1, errno, "Failed to restore current directory, `%s'.",
 381                cwd.name);
 382     free_cwd (&cwd);
 383
 384 #ifdef CLIENT_SUPPORT
 385     if (current_parsed_root->isremote)
 386     {
 387         /* Unfortunately, client.c doesn't offer a way to close
 388            the connection without waiting for responses.  The extra
 389            network turnaround here is quite unnecessary other than
 390            that....  */
 391         send_to_server ("noop\012", 0);
 392         err += get_responses_and_close ();
 393     }
 394 #endif /* CLIENT_SUPPORT */
 395
 396     if (line != NULL)
 397         free (line);
 398     return err;
 399 }