update from MirBSD; for us relevant:
[alioth/cvs.git] / src / main.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
11  * as specified in the README file that comes with the CVS source distribution.
12  *
13  * This is the main C driver for the CVS system.
14  *
15  * Credit to Dick Grune, Vrije Universiteit, Amsterdam, for writing
16  * the shell-script CVS system that this is based on.
17  *
18  */
19
20 #include "cvs.h"
21
22 #include "closeout.h"
23 #include "setenv.h"
24 #include "strftime.h"
25 #include "xgethostname.h"
26
27 #ifdef USE_LIBBSD
28 uint32_t arc4random(void);
29 #endif
30
31 __RCSID("$MirOS: src/gnu/usr.bin/cvs/src/main.c,v 1.19 2016/10/22 03:30:33 tg Exp $");
32
33 const char *program_name;
34 const char *program_path;
35 const char *cvs_cmd_name;
36
37 const char *global_session_id; /* Random session ID */
38
39 char *hostname;
40 /* FIXME: Perhaps this should be renamed original_hostname or the like?  */
41 char *server_hostname;
42
43 int use_editor = 1;
44 int use_cvsrc = 1;
45 int cvswrite = !CVSREAD_DFLT;
46 int really_quiet = 0;
47 int quiet = 0;
48 int trace = 0;
49 int noexec = 0;
50 int readonlyfs = 0;
51 int logoff = 0;
52
53
54
55 /***
56  ***
57  ***   CVSROOT/config options
58  ***
59  ***/
60 struct config *config;
61
62
63
64 mode_t cvsumask = UMASK_DFLT;
65
66 char *CurDir;
67
68 /*
69  * Defaults, for the environment variables that are not set
70  */
71 char *Editor = EDITOR_DFLT;
72
73
74
75 /* Temp dir stuff.  */
76
77 /* Temp dir, if set by the user.  */
78 static char *tmpdir_cmdline;
79
80
81
82 /* Returns in order of precedence:
83  *
84  *      1.  Temp dir as set via the command line.
85  *      2.  Temp dir as set in CVSROOT/config.
86  *      3.  Temp dir as set in $TMPDIR env var.
87  *      4.  Contents of TMPDIR_DFLT preprocessor macro.
88  *
89  * ERRORS
90  *  It is a fatal error if this function would otherwise return NULL or an
91  *  empty string.
92  */
93 const char *
94 get_cvs_tmp_dir (void)
95 {
96     const char *retval;
97     if (tmpdir_cmdline) retval = tmpdir_cmdline;
98     else if (config && config->TmpDir) retval = config->TmpDir;
99     else retval = get_system_temp_dir ();
100     if (!retval) retval = TMPDIR_DFLT;
101
102     if (!retval || !*retval) error (1, 0, "No temp dir specified.");
103
104     return retval;
105 }
106
107
108
109 /* When our working directory contains subdirectories with different
110    values in CVS/Root files, we maintain a list of them.  */
111 List *root_directories = NULL;
112
113 static const struct cmd
114 {
115     const char *fullname;       /* Full name of the function (e.g. "commit") */
116
117     /* Synonyms for the command, nick1 and nick2.  We supply them
118        mostly for two reasons: (1) CVS has always supported them, and
119        we need to maintain compatibility, (2) if there is a need for a
120        version which is shorter than the fullname, for ease in typing.
121        Synonyms have the disadvantage that people will see "new" and
122        then have to think about it, or look it up, to realize that is
123        the operation they know as "add".  Also, this means that one
124        cannot create a command "cvs new" with a different meaning.  So
125        new synonyms are probably best used sparingly, and where used
126        should be abbreviations of the fullname (preferably consisting
127        of the first 2 or 3 or so letters).
128
129        One thing that some systems do is to recognize any unique
130        abbreviation, for example "annotat" "annota", etc., for
131        "annotate".  The problem with this is that scripts and user
132        habits will expect a certain abbreviation to be unique, and in
133        a future release of CVS it may not be.  So it is better to
134        accept only an explicit list of abbreviations and plan on
135        supporting them in the future as well as now.  */
136
137     const char *nick1;
138     const char *nick2;
139     
140     int (*func) (int, char **); /* Function takes (argc, argv) arguments. */
141     unsigned long attr;         /* Attributes. */
142 } cmds[] =
143
144 {
145     { "add",      "ad",       "new",       add,       CVS_CMD_MODIFIES_REPOSITORY | CVS_CMD_USES_WORK_DIR },
146     { "admin",    "adm",      "rcs",       admin,     CVS_CMD_MODIFIES_REPOSITORY | CVS_CMD_USES_WORK_DIR },
147     { "annotate", "ann",      NULL,        annotate,  CVS_CMD_USES_WORK_DIR },
148     { "checkout", "co",       "get",       checkout,  0 },
149     { "commit",   "ci",       "com",       commit,    CVS_CMD_MODIFIES_REPOSITORY | CVS_CMD_USES_WORK_DIR },
150     { "diff",     "di",       "dif",       diff,      CVS_CMD_USES_WORK_DIR },
151     { "edit",     NULL,       NULL,        edit,      CVS_CMD_MODIFIES_REPOSITORY | CVS_CMD_USES_WORK_DIR },
152     { "editors",  NULL,       NULL,        editors,   CVS_CMD_USES_WORK_DIR },
153     { "export",   "exp",      "ex",        checkout,  CVS_CMD_USES_WORK_DIR },
154     { "history",  "hi",       "his",       history,   CVS_CMD_USES_WORK_DIR },
155     { "import",   "im",       "imp",       import,    CVS_CMD_MODIFIES_REPOSITORY | CVS_CMD_USES_WORK_DIR | CVS_CMD_IGNORE_ADMROOT},
156     { "init",     NULL,       NULL,        init,      CVS_CMD_MODIFIES_REPOSITORY },
157 #if defined (HAVE_KERBEROS) && defined (SERVER_SUPPORT)
158     { "kserver",  NULL,       NULL,        server,    CVS_CMD_MODIFIES_REPOSITORY | CVS_CMD_USES_WORK_DIR }, /* placeholder */
159 #endif
160     { "log",      "lo",       NULL,        cvslog,    CVS_CMD_USES_WORK_DIR },
161 #ifdef AUTH_CLIENT_SUPPORT
162     { "login",    "logon",    "lgn",       login,     0 },
163     { "logout",   NULL,       NULL,        logout,    0 },
164 #endif /* AUTH_CLIENT_SUPPORT */
165     { "ls",       "dir",      "list",      ls,        0 },
166 #if (defined(AUTH_SERVER_SUPPORT) || defined (HAVE_GSSAPI)) && defined(SERVER_SUPPORT)
167     { "pserver",  NULL,       NULL,        server,    CVS_CMD_MODIFIES_REPOSITORY | CVS_CMD_USES_WORK_DIR }, /* placeholder */
168 #endif
169     { "rannotate","rann",     "ra",        annotate,  0 },
170     { "rdiff",    "patch",    "pa",        patch,     0 },
171     { "release",  "re",       "rel",       release,   CVS_CMD_MODIFIES_REPOSITORY },
172     { "remove",   "rm",       "delete",    cvsremove, CVS_CMD_MODIFIES_REPOSITORY | CVS_CMD_USES_WORK_DIR },
173     { "rlog",     "rl",       NULL,        cvslog,    0 },
174     { "rls",      "rdir",     "rlist",     ls,        0 },
175     { "rtag",     "rt",       "rfreeze",   cvstag,    CVS_CMD_MODIFIES_REPOSITORY },
176 #ifdef SERVER_SUPPORT
177     { "server",   NULL,       NULL,        server,    CVS_CMD_MODIFIES_REPOSITORY | CVS_CMD_USES_WORK_DIR },
178 #endif
179     { "suck",     NULL,       NULL,        suck,      0 },
180     { "status",   "st",       "stat",      cvsstatus, CVS_CMD_USES_WORK_DIR },
181     { "tag",      "ta",       "freeze",    cvstag,    CVS_CMD_MODIFIES_REPOSITORY | CVS_CMD_USES_WORK_DIR },
182     { "unedit",   NULL,       NULL,        unedit,    CVS_CMD_MODIFIES_REPOSITORY | CVS_CMD_USES_WORK_DIR },
183     { "update",   "up",       "upd",       update,    CVS_CMD_USES_WORK_DIR },
184     { "version",  "ve",       "ver",       version,   0 },
185     { "watch",    NULL,       NULL,        watch,     CVS_CMD_MODIFIES_REPOSITORY | CVS_CMD_USES_WORK_DIR },
186     { "watchers", NULL,       NULL,        watchers,  CVS_CMD_USES_WORK_DIR },
187     { NULL, NULL, NULL, NULL, 0 },
188 };
189
190 static const char *const usg[] =
191 {
192     /* CVS usage messages never have followed the GNU convention of
193        putting metavariables in uppercase.  I don't know whether that
194        is a good convention or not, but if it changes it would have to
195        change in all the usage messages.  For now, they consistently
196        use lowercase, as far as I know.  Punctuation is pretty funky,
197        though.  Sometimes they use none, as here.  Sometimes they use
198        single quotes (not the TeX-ish `' stuff), as in --help-options.
199        Sometimes they use double quotes, as in cvs -H add.
200
201        Most (not all) of the usage messages seem to have periods at
202        the end of each line.  I haven't tried to duplicate this style
203        in --help as it is a rather different format from the rest.  */
204
205     "Usage: %s [cvs-options] command [command-options-and-arguments]\n",
206     "  where cvs-options are -q, -n, etc.\n",
207     "    (specify --help-options for a list of options)\n",
208     "  where command is add, admin, etc.\n",
209     "    (specify --help-commands for a list of commands\n",
210     "     or --help-synonyms for a list of command synonyms)\n",
211     "  where command-options-and-arguments depend on the specific command\n",
212     "    (specify -H followed by a command name for command-specific help)\n",
213     "  Specify --help to receive this message\n",
214     "\n",
215
216     /* Some people think that a bug-reporting address should go here.  IMHO,
217        the web sites are better because anything else is very likely to go
218        obsolete in the years between a release and when someone might be
219        reading this help.  Besides, we could never adequately discuss
220        bug reporting in a concise enough way to put in a help message.  */
221
222     /* I was going to put this at the top, but usage() wants the %s to
223        be in the first line.  */
224     "The Concurrent Versions System (CVS) is a tool for version control.\n",
225     /* I really don't think I want to try to define "version control"
226        in one line.  I'm not sure one can get more concise than the
227        paragraph in ../cvs.spec without assuming the reader knows what
228        version control means.  */
229
230     "For CVS updates and additional information, see\n",
231     "    the CVS home page at http://www.nongnu.org/cvs/ or\n",
232     "    the CVSNT home page at http://www.cvsnt.org/\n",
233     NULL,
234 };
235
236 static const char *const cmd_usage[] =
237 {
238     "CVS commands are:\n",
239     "        add          Add a new file/directory to the repository\n",
240     "        admin        Administration front-end for RCS\n",
241     "        annotate     Show last revision where each line was modified\n",
242     "        checkout     Checkout sources for editing\n",
243     "        commit       Check files into the repository\n",
244     "        diff         Show differences between revisions\n",
245     "        edit         Get ready to edit a watched file\n",
246     "        editors      See who is editing a watched file\n",
247     "        export       Export sources from CVS, similar to checkout\n",
248     "        history      Show repository access history\n",
249     "        import       Import sources into CVS, using vendor branches\n",
250     "        init         Create a CVS repository if it doesn't exist\n",
251 #if defined (HAVE_KERBEROS) && defined (SERVER_SUPPORT)
252     "        kserver      Act in Kerberos server mode\n",
253 #endif
254     "        log          Print out history information for files\n",
255 #ifdef AUTH_CLIENT_SUPPORT
256     "        login        Prompt for password for authenticating server\n",
257     "        logout       Removes entry in .cvspass for remote repository\n",
258 #endif /* AUTH_CLIENT_SUPPORT */
259     "        ls           List files available from CVS\n",
260 #if (defined(AUTH_SERVER_SUPPORT) || defined (HAVE_GSSAPI)) && defined(SERVER_SUPPORT)
261     "        pserver      Act in password server mode\n",
262 #endif
263     "        rannotate    Show last revision where each line of module was modified\n",
264     "        rdiff        Create 'patch' format diffs between revisions\n",
265     "        release      Indicate that a work subdirectory is no longer in use\n",
266     "        remove       Remove an entry from the repository\n",
267     "        rlog         Print out history information for a module\n",
268     "        rls          List files in a module\n",
269     "        rtag         Add a symbolic tag to a module\n",
270 #ifdef SERVER_SUPPORT
271     "        server       Act in server mode\n",
272 #endif
273     "        suck         Download RCS ,v file raw\n",
274     "        status       Display status information on checked out files\n",
275     "        tag          Add a symbolic tag to checked out version of files\n",
276     "        unedit       Undo an edit command\n",
277     "        update       Bring work tree in sync with repository\n",
278     "        version      Show current CVS version(s)\n",
279     "        watch        Set watches\n",
280     "        watchers     See who is watching a file\n",
281     "(Specify the --help option for a list of other help options)\n",
282     NULL,
283 };
284
285 static const char *const opt_usage[] =
286 {
287     /* Omit -b because it is just for compatibility.  */
288     "CVS global options (specified before the command name) are:\n",
289     "    -H           Displays usage information for command.\n",
290     "    -Q           Cause CVS to be really quiet.\n",
291     "    -q           Cause CVS to be somewhat quiet.\n",
292     "    -r           Make checked-out files read-only.\n",
293     "    -w           Make checked-out files read-write (default).\n",
294     "    -g           Force group-write permissions on checked-out files.\n",
295     "    -n           Do not execute anything that will change the disk.\n",
296     "    -t           Show trace of program execution (repeat for more\n",
297     "                 verbosity) -- try with -n.\n",
298     "    -R           Assume repository is read-only, such as CDROM\n",
299     "    -v           CVS version and copyright.\n",
300     "    -T tmpdir    Use 'tmpdir' for temporary files.\n",
301     "    -e editor    Use 'editor' for editing log information.\n",
302     "    -d CVS_root  Overrides $CVSROOT as the root of the CVS tree.\n",
303     "    -f           Do not use the ~/.cvsrc file.\n",
304 #ifdef CLIENT_SUPPORT
305     "    -z #         Request compression level '#' for net traffic.\n",
306 #ifdef ENCRYPTION
307     "    -x           Encrypt all net traffic.\n",
308 #endif
309     "    -a           Authenticate all net traffic.\n",
310 #endif
311     "    -s VAR=VAL   Set CVS user variable.\n",
312     "(Specify the --help option for a list of other help options)\n",
313     NULL
314 };
315
316
317 static int
318 set_root_directory (Node *p, void *ignored)
319 {
320     if (current_parsed_root == NULL && p->data != NULL)
321     {
322         current_parsed_root = p->data;
323         original_parsed_root = current_parsed_root;
324         return 1;
325     }
326     return 0;
327 }
328
329
330 static const char * const*
331 cmd_synonyms (void)
332 {
333     char ** synonyms;
334     char ** line;
335     const struct cmd *c = &cmds[0];
336     /* Three more for title, "specify --help" line, and NULL.  */
337     int numcmds = 3;
338
339     while (c->fullname != NULL)
340     {
341         numcmds++;
342         c++;
343     }
344     
345     synonyms = xnmalloc (numcmds, sizeof(char *));
346     line = synonyms;
347     *line++ = "CVS command synonyms are:\n";
348     for (c = &cmds[0]; c->fullname != NULL; c++)
349     {
350         if (c->nick1 || c->nick2)
351         {
352             *line = Xasprintf ("        %-12s %s %s\n", c->fullname,
353                                c->nick1 ? c->nick1 : "",
354                                c->nick2 ? c->nick2 : "");
355             line++;
356         }
357     }
358     *line++ = "(Specify the --help option for a list of other help options)\n";
359     *line = NULL;
360     
361     return (const char * const*) synonyms; /* will never be freed */
362 }
363
364
365
366 unsigned long int
367 lookup_command_attribute (const char *cmd_name)
368 {
369     const struct cmd *cm;
370
371     for (cm = cmds; cm->fullname; cm++)
372     {
373         if (strcmp (cmd_name, cm->fullname) == 0)
374             break;
375     }
376     if (!cm->fullname)
377         error (1, 0, "unknown command: %s", cmd_name);
378     return cm->attr;
379 }
380
381
382
383 /*
384  * Exit with an error code and an informative message about the signal
385  * received.  This function, by virtue of causing an actual call to exit(),
386  * causes all the atexit() handlers to be called.
387  *
388  * INPUTS
389  *   sig        The signal recieved.
390  *
391  * ERRORS
392  *   The cleanup routines registered via atexit() and the error function
393  *   itself can potentially change the exit status.  They shouldn't do this
394  *   unless they encounter problems doing their own jobs.
395  *
396  * RETURNS
397  *   Nothing.  This function will always exit.  It should exit with an exit
398  *   status of 1, but might not, as noted in the ERRORS section above.
399  */
400 #ifndef DONT_USE_SIGNALS
401 static RETSIGTYPE main_cleanup (int) __attribute__ ((__noreturn__));
402 #endif /* DONT_USE_SIGNALS */
403 static RETSIGTYPE
404 main_cleanup (int sig)
405 {
406 #ifndef DONT_USE_SIGNALS
407     const char *name;
408     char temp[10];
409
410     switch (sig)
411     {
412 #ifdef SIGABRT
413     case SIGABRT:
414         name = "abort";
415         break;
416 #endif
417 #ifdef SIGHUP
418     case SIGHUP:
419         name = "hangup";
420         break;
421 #endif
422 #ifdef SIGINT
423     case SIGINT:
424         name = "interrupt";
425         break;
426 #endif
427 #ifdef SIGQUIT
428     case SIGQUIT:
429         name = "quit";
430         break;
431 #endif
432 #ifdef SIGPIPE
433     case SIGPIPE:
434         name = "broken pipe";
435         break;
436 #endif
437 #ifdef SIGTERM
438     case SIGTERM:
439         name = "termination";
440         break;
441 #endif
442     default:
443         /* This case should never be reached, because we list above all
444            the signals for which we actually establish a signal handler.  */
445         sprintf (temp, "%d", sig);
446         name = temp;
447         break;
448     }
449
450     /* This always exits, which will cause our exit handlers to be called.  */
451     error (1, 0, "received %s signal", name);
452     /* but make the exit explicit to silence warnings when gcc processes the
453      * noreturn attribute.
454      */
455     exit (EXIT_FAILURE);
456 #endif /* !DONT_USE_SIGNALS */
457 }
458
459
460
461 /* From server.c.
462  *
463  * When !defined ALLOW_CONFIG_OVERRIDE, this will never have any value but
464  * NULL.
465  */
466 extern char *gConfigPath;
467
468
469
470 int
471 main (int argc, char **argv)
472 {
473     cvsroot_t *CVSroot_parsed = NULL;
474     bool cvsroot_update_env = true;
475     char *cp, *end;
476     const struct cmd *cm;
477     int c, err = 0;
478     int free_Editor = 0;
479
480     int help = 0;               /* Has the user asked for help?  This
481                                    lets us support the `cvs -H cmd'
482                                    convention to give help for cmd. */
483     static const char short_options[] = "+QqrwgtnRvb:T:e:d:Hfz:s:xal";
484     static struct option long_options[] =
485     {
486         {"help", 0, NULL, 'H'},
487         {"version", 0, NULL, 'v'},
488         {"help-commands", 0, NULL, 1},
489         {"help-synonyms", 0, NULL, 2},
490         {"help-options", 0, NULL, 4},
491 #ifdef SERVER_SUPPORT
492         {"allow-root", required_argument, NULL, 3},
493 #endif /* SERVER_SUPPORT */
494         {0, 0, 0, 0}
495     };
496     /* `getopt_long' stores the option index here, but right now we
497         don't use it. */
498     int option_index = 0;
499
500 #ifdef SYSTEM_INITIALIZE
501     /* Hook for OS-specific behavior, for example socket subsystems on
502        NT and OS2 or dealing with windows and arguments on Mac.  */
503     SYSTEM_INITIALIZE (&argc, &argv);
504 #endif
505
506 #ifdef SYSTEM_CLEANUP
507         /* Hook for OS-specific behavior, for example socket subsystems on
508            NT and OS2 or dealing with windows and arguments on Mac.  */
509         cleanup_register (SYSTEM_CLEANUP);
510 #endif
511
512 #ifdef HAVE_TZSET
513     /* On systems that have tzset (which is almost all the ones I know
514        of), it's a good idea to call it.  */
515     tzset ();
516 #endif
517
518     /*
519      * Just save the last component of the path for error messages
520      */
521     program_path = xstrdup (argv[0]);
522 #ifdef ARGV0_NOT_PROGRAM_NAME
523     /* On some systems, e.g. VMS, argv[0] is not the name of the command
524        which the user types to invoke the program.  */
525     program_name = "cvs";
526 #else
527     program_name = last_component (argv[0]);
528 #endif
529
530     /*
531      * Query the environment variables up-front, so that
532      * they can be overridden by command line arguments
533      */
534     if ((cp = getenv (EDITOR1_ENV)) != NULL)
535         Editor = cp;
536     else if ((cp = getenv (EDITOR2_ENV)) != NULL)
537         Editor = cp;
538     else if ((cp = getenv (EDITOR3_ENV)) != NULL)
539         Editor = cp;
540     if (getenv (CVSREAD_ENV) != NULL)
541         cvswrite = 0;
542     if (getenv (CVSREADONLYFS_ENV) != NULL) {
543         readonlyfs = 1;
544         logoff = 1;
545     }
546
547     /* Set this to 0 to force getopt initialization.  getopt() sets
548        this to 1 internally.  */
549     optind = 0;
550
551     /* We have to parse the options twice because else there is no
552        chance to avoid reading the global options from ".cvsrc".  Set
553        opterr to 0 for avoiding error messages about invalid options.
554        */
555     opterr = 0;
556
557     while ((c = getopt_long
558             (argc, argv, short_options, long_options, &option_index))
559            != EOF)
560     {
561         if (c == 'f')
562             use_cvsrc = 0;
563     }
564
565 #ifdef SERVER_SUPPORT
566     /* Don't try and read a .cvsrc file if we are a server.  */
567     if (optind < argc
568         && (false
569 # if defined (AUTH_SERVER_SUPPORT) || defined (HAVE_GSSAPI)
570             || !strcmp (argv[optind], "pserver")
571 # endif
572 # ifdef HAVE_KERBEROS
573             || !strcmp (argv[optind], "kserver")
574 # endif /* HAVE_KERBEROS */
575             || !strcmp (argv[optind], "server")))
576         {
577             /* Avoid any .cvsrc file.  */
578             use_cvsrc = 0;
579             /* Pre-parse the server options to get the config path.  */
580             cvs_cmd_name = argv[optind];
581             parseServerOptions (argc - optind, argv + optind);
582         }
583 #endif /* SERVER_SUPPORT */
584
585     /*
586      * Scan cvsrc file for global options.
587      */
588     if (use_cvsrc)
589         read_cvsrc (&argc, &argv, "cvs");
590
591     optind = 0;
592     opterr = 1;
593
594     while ((c = getopt_long
595             (argc, argv, short_options, long_options, &option_index))
596            != EOF)
597     {
598         switch (c)
599         {
600             case 1:
601                 /* --help-commands */
602                 usage (cmd_usage);
603                 break;
604             case 2:
605                 /* --help-synonyms */
606                 usage (cmd_synonyms());
607                 break;
608             case 4:
609                 /* --help-options */
610                 usage (opt_usage);
611                 break;
612 #ifdef SERVER_SUPPORT
613             case 3:
614                 /* --allow-root */
615                 root_allow_add (optarg, gConfigPath);
616                 break;
617 #endif /* SERVER_SUPPORT */
618             case 'Q':
619                 really_quiet = 1;
620                 /* FALL THROUGH */
621             case 'q':
622                 quiet = 1;
623                 break;
624             case 'r':
625                 cvswrite = 0;
626                 break;
627             case 'w':
628                 cvswrite = 1;
629                 break;
630             case 'g':
631                 /*
632                  * Force full write permissions for the group.
633                  * See the user's manual for details and dangers.
634                  */
635                 umask(umask(S_IRWXG|S_IRWXO) & S_IRWXO);
636                 break;
637             case 't':
638                 trace++;
639                 break;
640             case 'R':
641                 readonlyfs = -1;
642                 logoff = 1;
643                 break;
644             case 'n':
645                 noexec = 1;
646                 logoff = 1;
647                 break;
648             case 'l':
649                 /* no-op to simply ignore the old -l option */
650                 break;
651             case 'v':
652                 (void) fputs ("\n", stdout);
653                 version (0, NULL);    
654                 (void) fputs ("\n", stdout);
655                 (void) fputs ("\
656 Copyright (C) 2005 Free Software Foundation, Inc.\n\
657 \n\
658 Portions contributed by Thorsten Glaser for the MirOS Project.\n\
659 Senior active maintainers include Larry Jones, Derek R. Price,\n\
660 and Mark D. Baushke.  Please see the AUTHORS and README files from the CVS\n\
661 distribution kit for a complete list of contributors and copyrights.\n",
662                               stdout);
663                 (void) fputs ("\n", stdout);
664                 (void) fputs ("CVS may be copied only under the terms of the GNU General Public License,\n", stdout);
665                 (void) fputs ("a copy of which can be found with the CVS distribution kit.\n", stdout);
666                 (void) fputs ("\n", stdout);
667
668                 (void) fputs ("Specify the --help option for further information about CVS\n", stdout);
669
670                 exit (0);
671                 break;
672             case 'b':
673                 /* This option used to specify the directory for RCS
674                    executables.  But since we don't run them any more,
675                    this is a noop.  Silently ignore it so that .cvsrc
676                    and scripts and inetd.conf and such can work with
677                    either new or old CVS.  */
678                 break;
679             case 'T':
680                 if (tmpdir_cmdline) free (tmpdir_cmdline);
681                 tmpdir_cmdline = xstrdup (optarg);
682                 break;
683             case 'e':
684                 if (free_Editor) free (Editor);
685                 Editor = xstrdup (optarg);
686                 free_Editor = 1;
687                 break;
688             case 'd':
689                 if (CVSroot_cmdline != NULL)
690                     free (CVSroot_cmdline);
691                 CVSroot_cmdline = xstrdup (optarg);
692                 break;
693             case 'H':
694                 help = 1;
695                 break;
696             case 'f':
697                 use_cvsrc = 0; /* unnecessary, since we've done it above */
698                 break;
699             case 'z':
700 #ifdef CLIENT_SUPPORT
701                 gzip_level = strtol (optarg, &end, 10);
702                 if (*end != '\0' || gzip_level < 0 || gzip_level > 9)
703                   error (1, 0,
704                          "gzip compression level must be between 0 and 9");
705 #endif /* CLIENT_SUPPORT */
706                 /* If no CLIENT_SUPPORT, we just silently ignore the gzip
707                  * level, so that users can have it in their .cvsrc and not
708                  * cause any trouble.
709                  *
710                  * We still parse the argument to -z for correctness since
711                  * one user complained of being bitten by a run of
712                  * `cvs -z -n up' which read -n as the argument to -z without
713                  * complaining.  */
714                 break;
715             case 's':
716                 variable_set (optarg);
717                 break;
718             case 'x':
719 #ifdef CLIENT_SUPPORT
720                 cvsencrypt = 1;
721 #endif /* CLIENT_SUPPORT */
722                 /* If no CLIENT_SUPPORT, ignore -x, so that users can
723                    have it in their .cvsrc and not cause any trouble.
724                    If no ENCRYPTION, we still accept -x, but issue an
725                    error if we are being run as a client.  */
726                 break;
727             case 'a':
728 #ifdef CLIENT_SUPPORT
729                 cvsauthenticate = 1;
730 #endif
731                 /* If no CLIENT_SUPPORT, ignore -a, so that users can
732                    have it in their .cvsrc and not cause any trouble.
733                    We will issue an error later if stream
734                    authentication is not supported.  */
735                 break;
736             case '?':
737             default:
738                 usage (usg);
739         }
740     }
741
742     argc -= optind;
743     argv += optind;
744     if (argc < 1)
745         usage (usg);
746
747     /* Calculate the cvs global session ID */
748
749     global_session_id = Xasprintf("1%010llX%04X%04X",
750       (unsigned long long)time(NULL),
751       (int)(getpid() & 0xFFFF), (int)(arc4random() & 0xFFFF));
752
753     TRACE (TRACE_FUNCTION, "main: Session ID is %s", global_session_id);
754
755     /* Look up the command name. */
756
757     cvs_cmd_name = argv[0];
758     for (cm = cmds; cm->fullname; cm++)
759     {
760         if (cm->nick1 && !strcmp (cvs_cmd_name, cm->nick1))
761             break;
762         if (cm->nick2 && !strcmp (cvs_cmd_name, cm->nick2))
763             break;
764         if (!strcmp (cvs_cmd_name, cm->fullname))
765             break;
766     }
767
768     if (!cm->fullname)
769     {
770         fprintf (stderr, "Unknown command: `%s'\n\n", cvs_cmd_name);
771         usage (cmd_usage);
772     }
773     else
774         cvs_cmd_name = cm->fullname;    /* Global pointer for later use */
775
776     if (help)
777     {
778         argc = -1;              /* some functions only check for this */
779         err = (*(cm->func)) (argc, argv);
780     }
781     else
782     {
783         /* The user didn't ask for help, so go ahead and authenticate,
784            set up CVSROOT, and the rest of it. */
785
786         short int lock_cleanup_setup = 0;
787
788         /* The UMASK environment variable isn't handled with the
789            others above, since we don't want to signal errors if the
790            user has asked for help.  This won't work if somebody adds
791            a command-line flag to set the umask, since we'll have to
792            parse it before we get here. */
793
794         if ((cp = getenv (CVSUMASK_ENV)) != NULL)
795         {
796             /* FIXME: Should be accepting symbolic as well as numeric mask.  */
797             cvsumask = strtol (cp, &end, 8) & 0777;
798             if (*end != '\0')
799                 error (1, errno, "invalid umask value in %s (%s)",
800                        CVSUMASK_ENV, cp);
801         }
802
803         /* HOSTNAME & SERVER_HOSTNAME need to be set before they are
804          * potentially used in gserver_authenticate_connection() (called from
805          * pserver_authenticate_connection, below).
806          */
807         hostname = xgethostname ();
808         if (!hostname)
809         {
810             error (0, errno,
811                    "xgethostname () returned NULL, using \"localhost\"");
812             hostname = xstrdup ("localhost");
813         }
814
815         /* Keep track of this separately since the client can change
816          * HOSTNAME on the server.
817          */
818         server_hostname = xstrdup (hostname);
819
820 #ifdef SERVER_SUPPORT
821
822 # ifdef HAVE_KERBEROS
823         /* If we are invoked with a single argument "kserver", then we are
824            running as Kerberos server as root.  Do the authentication as
825            the very first thing, to minimize the amount of time we are
826            running as root.  */
827         if (strcmp (cvs_cmd_name, "kserver") == 0)
828         {
829             kserver_authenticate_connection ();
830
831             /* Pretend we were invoked as a plain server.  */
832             cvs_cmd_name = "server";
833         }
834 # endif /* HAVE_KERBEROS */
835
836 # if defined (AUTH_SERVER_SUPPORT) || defined (HAVE_GSSAPI)
837         if (strcmp (cvs_cmd_name, "pserver") == 0)
838         {
839             /* The reason that --allow-root is not a command option
840                is mainly that it seems easier to make it a global option.  */
841
842             /* Gets username and password from client, authenticates, then
843                switches to run as that user and sends an ACK back to the
844                client. */
845             pserver_authenticate_connection ();
846       
847             /* Pretend we were invoked as a plain server.  */
848             cvs_cmd_name = "server";
849         }
850 # endif /* AUTH_SERVER_SUPPORT || HAVE_GSSAPI */
851 #endif /* SERVER_SUPPORT */
852
853         server_active = strcmp (cvs_cmd_name, "server") == 0;
854
855 #ifdef SERVER_SUPPORT
856         if (server_active)
857         {
858             /* This is only used for writing into the history file.  For
859                remote connections, it might be nice to have hostname
860                and/or remote path, on the other hand I'm not sure whether
861                it is worth the trouble.  */
862             CurDir = xstrdup ("<remote>");
863             cleanup_register (server_cleanup);
864         }
865         else
866 #endif
867         {
868             cleanup_register (close_stdout);
869             CurDir = xgetcwd ();
870             if (CurDir == NULL)
871                 error (1, errno, "cannot get working directory");
872         }
873
874         {
875             char *val;
876             /* XXX pid < 10^32 */
877             val = Xasprintf ("%ld", (long) getpid ());
878             setenv (CVS_PID_ENV, val, 1);
879             free (val);
880         }
881
882         /* make sure we clean up on error */
883         signals_register (main_cleanup);
884
885 #ifdef KLUDGE_FOR_WNT_TESTSUITE
886         /* Probably the need for this will go away at some point once
887            we call fflush enough places (e.g. fflush (stdout) in
888            cvs_outerr).  */
889         (void) setvbuf (stdout, NULL, _IONBF, 0);
890         (void) setvbuf (stderr, NULL, _IONBF, 0);
891 #endif /* KLUDGE_FOR_WNT_TESTSUITE */
892
893         if (use_cvsrc)
894             read_cvsrc (&argc, &argv, cvs_cmd_name);
895
896         /* Fiddling with CVSROOT doesn't make sense if we're running
897          * in server mode, since the client will send the repository
898          * directory after the connection is made.
899          */
900         if (!server_active)
901         {
902             /* First check if a root was set via the command line.  */
903             if (CVSroot_cmdline)
904             {
905                  if (!(CVSroot_parsed = parse_cvsroot (CVSroot_cmdline)))
906                      error (1, 0, "Bad CVSROOT: `%s'.", CVSroot_cmdline);
907             }
908
909             /* See if we are able to find a 'better' value for CVSroot
910              * in the CVSADM_ROOT directory.
911              *
912              * "cvs import" shouldn't check CVS/Root; in general it
913              * ignores CVS directories and CVS/Root is likely to
914              * specify a different repository than the one we are
915              * importing to, but if this is not import and no root was
916              * specified on the command line, set the root from the
917              * CVS/Root file.
918              */
919             if (!CVSroot_parsed
920                 && !(cm->attr & CVS_CMD_IGNORE_ADMROOT)
921                )
922                 CVSroot_parsed = Name_Root (NULL, NULL);
923
924             /* Now, if there is no root on the command line and we didn't find
925              * one in a file, set it via the $CVSROOT env var.
926              */
927             if (!CVSroot_parsed)
928             {
929                 char *tmp = getenv (CVSROOT_ENV);
930                 if (tmp)
931                 {
932                     if (!(CVSroot_parsed = parse_cvsroot (tmp)))
933                         error (1, 0, "Bad CVSROOT: `%s'.", tmp);
934                     cvsroot_update_env = false;
935                 }
936             }
937
938 #ifdef CVSROOT_DFLT
939             if (!CVSroot_parsed)
940             {
941                 if (!(CVSroot_parsed = parse_cvsroot (CVSROOT_DFLT)))
942                     error (1, 0, "Bad CVSROOT: `%s'.", CVSROOT_DFLT);
943             }
944 #endif /* CVSROOT_DFLT */
945
946             /* Now we've reconciled CVSROOT from the command line, the
947                CVS/Root file, and the environment variable.  Do the
948                last sanity checks on the variable. */
949             if (!CVSroot_parsed && cm->func != version)
950             {
951                 error (0, 0,
952                        "No CVSROOT specified!  Please use the `-d' option");
953                 error (1, 0,
954                        "or set the %s environment variable.", CVSROOT_ENV);
955             }
956         }
957
958         /* Here begins the big loop over unique cvsroot values.  We
959            need to call do_recursion once for each unique value found
960            in CVS/Root.  Prime the list with the current value. */
961
962         /* Create the list. */
963         assert (root_directories == NULL);
964         root_directories = getlist ();
965
966         /* Prime it. */
967         if (CVSroot_parsed)
968         {
969             Node *n;
970             n = getnode ();
971             n->type = NT_UNKNOWN;
972             n->key = xstrdup (CVSroot_parsed->original);
973             n->data = CVSroot_parsed;
974
975             if (addnode (root_directories, n))
976                 error (1, 0, "cannot add initial CVSROOT %s", n->key);
977         }
978
979         assert (current_parsed_root == NULL);
980
981         /* Handle running 'cvs version' with no CVSROOT.  */
982
983         if (cm->func == version && !CVSroot_parsed)
984             server_active = !0;
985
986         /* If we're running the server, we want to execute this main
987            loop once and only once (we won't be serving multiple roots
988            from this connection, so there's no need to do it more than
989            once).  To get out of the loop, we perform a "break" at the
990            end of things.  */
991
992         while (server_active ||
993                walklist (root_directories, set_root_directory, NULL))
994         {
995             /* Fiddling with CVSROOT doesn't make sense if we're running
996                in server mode, since the client will send the repository
997                directory after the connection is made. */
998
999             if (!server_active)
1000             {
1001                 /* Now we're 100% sure that we have a valid CVSROOT
1002                    variable.  Parse it to see if we're supposed to do
1003                    remote accesses or use a special access method. */
1004
1005                 TRACE (TRACE_FUNCTION,
1006                        "main loop with CVSROOT=%s",
1007                        current_parsed_root ? current_parsed_root->directory
1008                                            : "(null)");
1009
1010                 /*
1011                  * Check to see if the repository exists.
1012                  */
1013                 if (!current_parsed_root->isremote)
1014                 {
1015                     char *path;
1016                     int save_errno;
1017
1018                     path = Xasprintf ("%s/%s", current_parsed_root->directory,
1019                                       CVSROOTADM);
1020                     if (!isaccessible (path, R_OK | X_OK))
1021                     {
1022                         save_errno = errno;
1023                         /* If this is "cvs init", the root need not exist yet.
1024                          */
1025                         if (strcmp (cvs_cmd_name, "init"))
1026                             error (1, save_errno, "%s", path);
1027                     }
1028                     free (path);
1029                 }
1030
1031                 /* Update the CVSROOT environment variable.  */
1032                 if (cvsroot_update_env)
1033                     setenv (CVSROOT_ENV, current_parsed_root->original, 1);
1034             }
1035         
1036             /* Parse the CVSROOT/config file, but only for local.  For the
1037                server, we parse it after we know $CVSROOT.  For the
1038                client, it doesn't get parsed at all, obviously.  The
1039                presence of the parse_config call here is not meant to
1040                predetermine whether CVSROOT/config overrides things from
1041                read_cvsrc and other such places or vice versa.  That sort
1042                of thing probably needs more thought.  */
1043             if (!server_active && !current_parsed_root->isremote)
1044             {
1045                 /* If there was an error parsing the config file, parse_config
1046                    already printed an error.  We keep going.  Why?  Because
1047                    if we didn't, then there would be no way to check in a new
1048                    CVSROOT/config file to fix the broken one!  */
1049                 if (config) free_config (config);
1050                 config = parse_config (current_parsed_root->directory, NULL);
1051
1052                 /* Can set TMPDIR in the environment if necessary now, since
1053                  * if it was set in config, we now know it.
1054                  */
1055                 push_env_temp_dir ();
1056             }
1057
1058 #ifdef CLIENT_SUPPORT
1059             /* Need to check for current_parsed_root != NULL here since
1060              * we could still be in server mode before the server function
1061              * gets called below and sets the root
1062              */
1063             if (current_parsed_root != NULL && current_parsed_root->isremote)
1064             {
1065                 /* Create a new list for directory names that we've
1066                    sent to the server. */
1067                 if (dirs_sent_to_server != NULL)
1068                     dellist (&dirs_sent_to_server);
1069                 dirs_sent_to_server = getlist ();
1070             }
1071 #endif
1072
1073             if (
1074 #ifdef SERVER_SUPPORT
1075                 /* Don't worry about lock_cleanup_setup when the server is
1076                  * active since we can only go through this loop once in that
1077                  * case anyhow.
1078                  */
1079                 server_active ||
1080 #endif
1081                 (
1082 #ifdef CLIENT_SUPPORT
1083                  !current_parsed_root->isremote &&
1084 #endif
1085                  !lock_cleanup_setup))
1086             {
1087                 /* Set up to clean up any locks we might create on exit.  */
1088                 cleanup_register (Lock_Cleanup);
1089                 lock_cleanup_setup = 1;
1090             }
1091
1092             /* Call our worker function.  */
1093             err = (*(cm->func)) (argc, argv);
1094         
1095             /* Mark this root directory as done.  When the server is
1096                active, our list will be empty -- don't try and
1097                remove it from the list. */
1098
1099             if (!server_active)
1100             {
1101                 Node *n = findnode (root_directories,
1102                                     original_parsed_root->original);
1103                 assert (n != NULL);
1104                 assert (n->data != NULL);
1105                 n->data = NULL;
1106                 current_parsed_root = NULL;
1107             }
1108
1109             if (server_active)
1110                 break;
1111         } /* end of loop for cvsroot values */
1112
1113         dellist (&root_directories);
1114     } /* end of stuff that gets done if the user DOESN'T ask for help */
1115
1116     config = NULL;
1117     root_allow_free ();
1118
1119     /* This is exit rather than return because apparently that keeps
1120        some tools which check for memory leaks happier.  */
1121     exit (err ? EXIT_FAILURE : 0);
1122         /* Keep picky/stupid compilers (e.g. Visual C++ 5.0) happy.  */
1123         return 0;
1124 }
1125
1126
1127
1128 char *
1129 Make_Date (const char *rawdate)
1130 {
1131     struct timespec t;
1132
1133     if (!get_date (&t, rawdate, NULL))
1134         error (1, 0, "Can't parse date/time: `%s'", rawdate);
1135
1136     /* Truncate nanoseconds.  */
1137     return date_from_time_t (t.tv_sec);
1138 }
1139
1140
1141
1142 /* Parse a string of the form TAG[:DATE], where TAG could be the empty string.
1143  *
1144  * INPUTS
1145  *   input      The string to be parsed.
1146  *
1147  * OUTPUTS
1148  *   tag        The tag found, if any.  If TAG is the empty string, then leave
1149  *              this value unchanged.
1150  *   date       The date found, if any.  If DATE is the empty string or is
1151  *              missing, leave this value unchanged.
1152  *
1153  * NOTES
1154  *   If either TAG or DATE is replaced for output, the previous value is freed.
1155  *
1156  * ERRORS
1157  *   If either TAG or DATE cannot be parsed, then this function will exit with
1158  *   a fatal error message.
1159  *
1160  * RETURNS
1161  *   Nothing.
1162  */
1163 void
1164 parse_tagdate (char **tag, char **date, const char *input)
1165 {
1166     char *p;
1167
1168     TRACE (TRACE_FUNCTION, "parse_tagdate (%s, %s, %s)",
1169            *tag ? *tag : "(null)", *date ? *date : "(null)",
1170            input);
1171
1172     if ((p = strchr (input, ':')))
1173     {
1174         /* Parse the tag.  */
1175         if (p - input)
1176         {
1177             /* The tag has > 0 length.  */
1178             if (*tag) free (*tag);
1179             *tag = xmalloc (p - input + 1);
1180             strncpy (*tag, input, p - input);
1181             (*tag)[p - input] = '\0';
1182         }
1183
1184         /* Parse the date.  */
1185         if (*++p)
1186         {
1187             if (*date) free (*date);
1188             *date = strcmp (p, "BASE") ? Make_Date (p) : xstrdup (p);
1189         }
1190     }
1191     else if (strlen (input))
1192     {
1193         /* The tag has > 0 length.  */
1194         if (*tag) free (*tag);
1195         *tag = xstrdup (input);
1196     }
1197
1198     TRACE (TRACE_DATA, "parse_tagdate: got tag = `%s', date = `%s'",
1199            *tag ? *tag : "(null)", *date ? *date : "(null)");
1200 }
1201
1202
1203
1204 /* Convert a time_t to an RCS format date.  This is mainly for the
1205    use of "cvs history", because the CVSROOT/history file contains
1206    time_t format dates; most parts of CVS will want to avoid using
1207    time_t's directly, and instead use RCS_datecmp, Make_Date, &c.
1208    Assuming that the time_t is in GMT (as it generally should be),
1209    then the result will be in GMT too.
1210
1211    Returns a newly malloc'd string.  */
1212
1213 char *
1214 date_from_time_t (time_t unixtime)
1215 {
1216     struct tm *ftm;
1217     char date[MAXDATELEN];
1218     char *ret;
1219
1220     ftm = gmtime (&unixtime);
1221     if (ftm == NULL)
1222         /* This is a system, like VMS, where the system clock is in local
1223            time.  Hopefully using localtime here matches the "zero timezone"
1224            hack I added to get_date (get_date of course being the relevant
1225            issue for Make_Date, and for history.c too I think).  */
1226         ftm = localtime (&unixtime);
1227
1228     (void) sprintf (date, DATEFORM,
1229                     (long)ftm->tm_year + (ftm->tm_year < 100 ? 0L : 1900L),
1230                     ftm->tm_mon + 1, ftm->tm_mday, ftm->tm_hour,
1231                     ftm->tm_min, ftm->tm_sec);
1232     ret = xstrdup (date);
1233     return ret;
1234 }
1235
1236
1237
1238 /* Convert a date to RFC822/1123 format.  This is used in contexts like
1239    dates to send in the protocol; it should not vary based on locale or
1240    other such conventions for users.  We should have another routine which
1241    does that kind of thing.
1242
1243    The SOURCE date is in our internal RCS format.  DEST should point to
1244    storage managed by the caller, at least MAXDATELEN characters.  */
1245 void
1246 date_to_internet (char *dest, const char *source)
1247 {
1248     struct tm date;
1249
1250     date_to_tm (&date, source);
1251     tm_to_internet (dest, &date);
1252 }
1253
1254
1255
1256 void
1257 date_to_tm (struct tm *dest, const char *source)
1258 {
1259     int y;
1260     if (sscanf (source, SDATEFORM,
1261                 &y, &dest->tm_mon, &dest->tm_mday,
1262                 &dest->tm_hour, &dest->tm_min, &dest->tm_sec)
1263             != 6)
1264         /* Is there a better way to handle errors here?  I made this
1265            non-fatal in case we are called from the code which can't
1266            deal with fatal errors.  */
1267         error (0, 0, "internal error: bad date %s", source);
1268
1269     dest->tm_year = y - ((y > 100) ? 1900 : 0);
1270     dest->tm_mon -= 1;
1271 }
1272
1273
1274
1275 /* Convert a date to RFC822/1123 format.  This is used in contexts like
1276    dates to send in the protocol; it should not vary based on locale or
1277    other such conventions for users.  We should have another routine which
1278    does that kind of thing.
1279
1280    The SOURCE date is a pointer to a struct tm.  DEST should point to
1281    storage managed by the caller, at least MAXDATELEN characters.  */
1282 void
1283 tm_to_internet (char *dest, const struct tm *source)
1284 {
1285     /* Just to reiterate, these strings are from RFC822 and do not vary
1286        according to locale.  */
1287     static const char *const month_names[] =
1288       {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
1289          "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
1290     
1291     sprintf (dest, "%d %s %ld %02d:%02d:%02d -0000", source->tm_mday,
1292              source->tm_mon < 0 || source->tm_mon > 11
1293                ? "???" : month_names[source->tm_mon],
1294              (long)source->tm_year + 1900, source->tm_hour, source->tm_min,
1295              source->tm_sec);
1296 }
1297
1298
1299
1300 /*
1301  * Format a date for the current locale.
1302  *
1303  * INPUT
1304  *   UNIXTIME   The UNIX seconds since the epoch.
1305  *
1306  * RETURNS
1307  *   If my_strftime() encounters an error, this function can return NULL.
1308  *
1309  *   Otherwise, returns a date string in ISO8601 format, e.g.:
1310  *
1311  *      2004-04-29 13:24:22 -0700
1312  *
1313  *   It is the responsibility of the caller to return of this string.
1314  */
1315 static char *
1316 format_time_t (time_t unixtime)
1317 {
1318     static char buf[sizeof ("yyyy-mm-dd HH:MM:SS -HHMM")];
1319     /* Convert to a time in the local time zone.  */
1320     struct tm ltm = *(localtime (&unixtime));
1321
1322     if (!my_strftime (buf, sizeof (buf), "%Y-%m-%d %H:%M:%S %z", &ltm, 0, 0))
1323         return NULL;
1324
1325     return xstrdup (buf);
1326 }
1327
1328
1329
1330 /* Like format_time_t(), but return time in UTC.
1331  */
1332 char *
1333 gmformat_time_t (time_t unixtime)
1334 {
1335     static char buf[sizeof ("yyyy-mm-dd HH:MM:SS -HHMM")];
1336     /* Convert to a time in the local time zone.  */
1337     struct tm ltm = *(gmtime (&unixtime));
1338
1339     if (!my_strftime (buf, sizeof (buf), "%Y-%m-%d %H:%M:%S %z", &ltm, 0, 0))
1340         return NULL;
1341
1342     return xstrdup (buf);
1343 }
1344
1345
1346
1347 /* Format a date in the local timezone using format_time_t() given a date from
1348  * an arbitrary timezone in a string.
1349  *
1350  * INPUT
1351  *   DATESTR    A string that looks like anything get_date() can parse, e.g.:
1352  *
1353  *                      2004-04-29 20:24:22
1354  *
1355  * ERRORS
1356  *   As get_date() & format_time_t().  Prints a warning if either provide
1357  *   error return values.  See RETURNS.
1358  *
1359  * RETURNS
1360  *   A freshly allocated string that is a copy of the input string if either
1361  *   get_date() or format_time_t() encounter an error and as format_time_t()
1362  *   otherwise.
1363  */
1364 char *
1365 format_date_alloc (char *datestr)
1366 {
1367     struct timespec t;
1368     char *buf;
1369
1370     TRACE (TRACE_FUNCTION, "format_date (%s)", datestr);
1371
1372     /* Convert the date string to seconds since the epoch. */
1373     if (!get_date (&t, datestr, NULL))
1374     {
1375         error (0, 0, "Can't parse date/time: `%s'.", datestr);
1376         goto as_is;
1377     }
1378
1379     /* Get the time into a string, truncating any nanoseconds returned by
1380      * getdate.
1381      */
1382     if ((buf = format_time_t (t.tv_sec)) == NULL)
1383     {
1384         error (0, 0, "Unable to reformat date `%s'.", datestr);
1385         goto as_is;
1386     }
1387
1388     return buf;
1389
1390  as_is:
1391     return xstrdup (datestr);
1392 }
1393
1394
1395
1396 void
1397 usage (register const char *const *cpp)
1398 {
1399     (void) fprintf (stderr, *cpp++, program_name, cvs_cmd_name);
1400     for (; *cpp; cpp++)
1401         (void) fprintf (stderr, "%s", *cpp);
1402     exit (EXIT_FAILURE);
1403 }
1404
1405 /* vim:tabstop=8:shiftwidth=4
1406  */