Initial revision
[alioth/cvs.git] / src / logmsg.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
14
15 #include "cvs.h"
16 #include "getline.h"
17
18 static int find_type (Node * p, void *closure);
19 static int fmt_proc (Node * p, void *closure);
20 static int logfile_write (const char *repository, const char *filter,
21                           const char *message, FILE * logfp, List * changes);
22 static int logmsg_list_to_args_proc (Node *p, void *closure);
23 static int rcsinfo_proc (const char *repository, const char *template,
24                          void *closure );
25 static int update_logfile_proc (const char *repository, const char *filter,
26                                 void *closure);
27 static void setup_tmpfile (FILE * xfp, char *xprefix, List * changes);
28 static int verifymsg_proc (const char *repository, const char *script,
29                            void *closure );
30
31 static FILE *fp;
32 static Ctype type;
33
34 struct verifymsg_proc_data
35 {
36     /* The name of the temp file storing the log message to be verified.  This
37      * is initially NULL and verifymsg_proc() writes message into it so that it
38      * can be shared when multiple verifymsg scripts exist.  do_verify() is
39      * responsible for rereading the message from the file when
40      * RereadLogAfterVerify is in effect and the file has changed.
41      */
42     char *fname;
43     /* The initial message text to be verified.
44      */
45     char *message;
46     /* The initial stats of the temp file so we can tell that the temp file has
47      * been changed when RereadLogAfterVerify is STAT.
48      */
49     struct stat pre_stbuf;
50    /* The list of files being changed, with new and old version numbers.
51     */
52    List *changes;
53 };
54
55 /*
56  * Puts a standard header on the output which is either being prepared for an
57  * editor session, or being sent to a logfile program.  The modified, added,
58  * and removed files are included (if any) and formatted to look pretty. */
59 static char *prefix;
60 static int col;
61 static char *tag;
62 static void
63 setup_tmpfile (FILE *xfp, char *xprefix, List *changes)
64 {
65     /* set up statics */
66     fp = xfp;
67     prefix = xprefix;
68
69     type = T_MODIFIED;
70     if (walklist (changes, find_type, NULL) != 0)
71     {
72         (void) fprintf (fp, "%sModified Files:\n", prefix);
73         col = 0;
74         (void) walklist (changes, fmt_proc, NULL);
75         (void) fprintf (fp, "\n");
76         if (tag != NULL)
77         {
78             free (tag);
79             tag = NULL;
80         }
81     }
82     type = T_ADDED;
83     if (walklist (changes, find_type, NULL) != 0)
84     {
85         (void) fprintf (fp, "%sAdded Files:\n", prefix);
86         col = 0;
87         (void) walklist (changes, fmt_proc, NULL);
88         (void) fprintf (fp, "\n");
89         if (tag != NULL)
90         {
91             free (tag);
92             tag = NULL;
93         }
94     }
95     type = T_REMOVED;
96     if (walklist (changes, find_type, NULL) != 0)
97     {
98         (void) fprintf (fp, "%sRemoved Files:\n", prefix);
99         col = 0;
100         (void) walklist (changes, fmt_proc, NULL);
101         (void) fprintf (fp, "\n");
102         if (tag != NULL)
103         {
104             free (tag);
105             tag = NULL;
106         }
107     }
108 }
109
110 /*
111  * Looks for nodes of a specified type and returns 1 if found
112  */
113 static int
114 find_type (Node *p, void *closure)
115 {
116     struct logfile_info *li = p->data;
117
118     if (li->type == type)
119         return (1);
120     else
121         return (0);
122 }
123
124 /*
125  * Breaks the files list into reasonable sized lines to avoid line wrap...
126  * all in the name of pretty output.  It only works on nodes whose types
127  * match the one we're looking for
128  */
129 static int
130 fmt_proc (Node *p, void *closure)
131 {
132     struct logfile_info *li;
133
134     li = p->data;
135     if (li->type == type)
136     {
137         if (li->tag == NULL
138             ? tag != NULL
139             : tag == NULL || strcmp (tag, li->tag) != 0)
140         {
141             if (col > 0)
142                 (void) fprintf (fp, "\n");
143             (void) fputs (prefix, fp);
144             col = strlen (prefix);
145             while (col < 6)
146             {
147                 (void) fprintf (fp, " ");
148                 ++col;
149             }
150
151             if (li->tag == NULL)
152                 (void) fprintf (fp, "No tag");
153             else
154                 (void) fprintf (fp, "Tag: %s", li->tag);
155
156             if (tag != NULL)
157                 free (tag);
158             tag = xstrdup (li->tag);
159
160             /* Force a new line.  */
161             col = 70;
162         }
163
164         if (col == 0)
165         {
166             (void) fprintf (fp, "%s\t", prefix);
167             col = 8;
168         }
169         else if (col > 8 && (col + (int) strlen (p->key)) > 70)
170         {
171             (void) fprintf (fp, "\n%s\t", prefix);
172             col = 8;
173         }
174         (void) fprintf (fp, "%s ", p->key);
175         col += strlen (p->key) + 1;
176     }
177     return (0);
178 }
179
180 /*
181  * Builds a temporary file using setup_tmpfile() and invokes the user's
182  * editor on the file.  The header garbage in the resultant file is then
183  * stripped and the log message is stored in the "message" argument.
184  * 
185  * If REPOSITORY is non-NULL, process rcsinfo for that repository; if it
186  * is NULL, use the CVSADM_TEMPLATE file instead.  REPOSITORY should be
187  * NULL when running in client mode.
188  *
189  * GLOBALS
190  *   Editor     Set to a default value by configure and overridable using the
191  *              -e option to the CVS executable.
192  */
193 void
194 do_editor (const char *dir, char **messagep, const char *repository,
195            List *changes)
196 {
197     static int reuse_log_message = 0;
198     char *line;
199     int line_length;
200     size_t line_chars_allocated;
201     char *fname;
202     struct stat pre_stbuf, post_stbuf;
203     int retcode = 0;
204
205     assert (!current_parsed_root->isremote != !repository);
206
207     if (noexec || reuse_log_message)
208         return;
209
210     /* Abort before creation of the temp file if no editor is defined. */
211     if (strcmp (Editor, "") == 0)
212         error(1, 0, "no editor defined, must use -e or -m");
213
214   again:
215     /* Create a temporary file.  */
216     if( ( fp = cvs_temp_file( &fname ) ) == NULL )
217         error( 1, errno, "cannot create temporary file" );
218
219     if (*messagep)
220     {
221         (void) fputs (*messagep, fp);
222
223         if ((*messagep)[0] == '\0' ||
224             (*messagep)[strlen (*messagep) - 1] != '\n')
225             (void) fprintf (fp, "\n");
226     }
227
228     if (repository != NULL)
229         /* tack templates on if necessary */
230         (void) Parse_Info (CVSROOTADM_RCSINFO, repository, rcsinfo_proc,
231                 PIOPT_ALL, NULL);
232     else
233     {
234         FILE *tfp;
235         char buf[1024];
236         size_t n;
237         size_t nwrite;
238
239         /* Why "b"?  */
240         tfp = CVS_FOPEN (CVSADM_TEMPLATE, "rb");
241         if (tfp == NULL)
242         {
243             if (!existence_error (errno))
244                 error (1, errno, "cannot read %s", CVSADM_TEMPLATE);
245         }
246         else
247         {
248             while (!feof (tfp))
249             {
250                 char *p = buf;
251                 n = fread (buf, 1, sizeof buf, tfp);
252                 nwrite = n;
253                 while (nwrite > 0)
254                 {
255                     n = fwrite (p, 1, nwrite, fp);
256                     nwrite -= n;
257                     p += n;
258                 }
259                 if (ferror (tfp))
260                     error (1, errno, "cannot read %s", CVSADM_TEMPLATE);
261             }
262             if (fclose (tfp) < 0)
263                 error (0, errno, "cannot close %s", CVSADM_TEMPLATE);
264         }
265     }
266
267     (void) fprintf (fp,
268   "%s----------------------------------------------------------------------\n",
269                     CVSEDITPREFIX);
270     (void) fprintf (fp,
271   "%sEnter Log.  Lines beginning with `%.*s' are removed automatically\n%s\n",
272                     CVSEDITPREFIX, CVSEDITPREFIXLEN, CVSEDITPREFIX,
273                     CVSEDITPREFIX);
274     if (dir != NULL && *dir)
275         (void) fprintf (fp, "%sCommitting in %s\n%s\n", CVSEDITPREFIX,
276                         dir, CVSEDITPREFIX);
277     if (changes != NULL)
278         setup_tmpfile (fp, CVSEDITPREFIX, changes);
279     (void) fprintf (fp,
280   "%s----------------------------------------------------------------------\n",
281                     CVSEDITPREFIX);
282
283     /* finish off the temp file */
284     if (fclose (fp) == EOF)
285         error (1, errno, "%s", fname);
286     if (stat (fname, &pre_stbuf) == -1)
287         pre_stbuf.st_mtime = 0;
288
289     /* run the editor */
290     run_setup (Editor);
291     run_add_arg (fname);
292     if ((retcode = run_exec (RUN_TTY, RUN_TTY, RUN_TTY,
293                              RUN_NORMAL | RUN_SIGIGNORE)) != 0)
294         error (0, retcode == -1 ? errno : 0, "warning: editor session failed");
295
296     /* put the entire message back into the *messagep variable */
297
298     fp = xfopen (fname, "r");
299
300     if (*messagep)
301         free (*messagep);
302
303     if (stat (fname, &post_stbuf) != 0)
304             error (1, errno, "cannot find size of temp file %s", fname);
305
306     if (post_stbuf.st_size == 0)
307         *messagep = NULL;
308     else
309     {
310         /* On NT, we might read less than st_size bytes, but we won't
311            read more.  So this works.  */
312         *messagep = (char *) xmalloc (post_stbuf.st_size + 1);
313         (*messagep)[0] = '\0';
314     }
315
316     line = NULL;
317     line_chars_allocated = 0;
318
319     if (*messagep)
320     {
321         size_t message_len = post_stbuf.st_size + 1;
322         size_t offset = 0;
323         while (1)
324         {
325             line_length = getline (&line, &line_chars_allocated, fp);
326             if (line_length == -1)
327             {
328                 if (ferror (fp))
329                     error (0, errno, "warning: cannot read %s", fname);
330                 break;
331             }
332             if (strncmp (line, CVSEDITPREFIX, CVSEDITPREFIXLEN) == 0)
333                 continue;
334             if (offset + line_length >= message_len)
335                 expand_string (messagep, &message_len,
336                                 offset + line_length + 1);
337             (void) strcpy (*messagep + offset, line);
338             offset += line_length;
339         }
340     }
341     if (fclose (fp) < 0)
342         error (0, errno, "warning: cannot close %s", fname);
343
344     /* canonicalize emply messages */
345     if (*messagep != NULL &&
346         (**messagep == '\0' || strcmp (*messagep, "\n") == 0))
347     {
348         free (*messagep);
349         *messagep = NULL;
350     }
351
352     if (pre_stbuf.st_mtime == post_stbuf.st_mtime || *messagep == NULL)
353     {
354         for (;;)
355         {
356             (void) printf ("\nLog message unchanged or not specified\n");
357             (void) printf ("a)bort, c)ontinue, e)dit, !)reuse this message unchanged for remaining dirs\n");
358             (void) printf ("Action: (continue) ");
359             (void) fflush (stdout);
360             line_length = getline (&line, &line_chars_allocated, stdin);
361             if (line_length < 0)
362             {
363                 error (0, errno, "cannot read from stdin");
364                 if (unlink_file (fname) < 0)
365                     error (0, errno,
366                            "warning: cannot remove temp file %s", fname);
367                 error (1, 0, "aborting");
368             }
369             else if (line_length == 0
370                      || *line == '\n' || *line == 'c' || *line == 'C')
371                 break;
372             if (*line == 'a' || *line == 'A')
373                 {
374                     if (unlink_file (fname) < 0)
375                         error (0, errno, "warning: cannot remove temp file %s", fname);
376                     error (1, 0, "aborted by user");
377                 }
378             if (*line == 'e' || *line == 'E')
379                 goto again;
380             if (*line == '!')
381             {
382                 reuse_log_message = 1;
383                 break;
384             }
385             (void) printf ("Unknown input\n");
386         }
387     }
388     if (line)
389         free (line);
390     if (unlink_file (fname) < 0)
391         error (0, errno, "warning: cannot remove temp file %s", fname);
392     free (fname);
393 }
394
395 /* Runs the user-defined verification script as part of the commit or import 
396    process.  This verification is meant to be run whether or not the user 
397    included the -m attribute.  unlike the do_editor function, this is 
398    independant of the running of an editor for getting a message.
399  */
400 void
401 do_verify (char **messagep, const char *repository, List *changes)
402 {
403     int err;
404     struct verifymsg_proc_data data;
405     struct stat post_stbuf;
406
407     if (current_parsed_root->isremote)
408         /* The verification will happen on the server.  */
409         return;
410
411     /* FIXME? Do we really want to skip this on noexec?  What do we do
412        for the other administrative files?  */
413     /* EXPLAIN: Why do we check for repository == NULL here? */
414     if (noexec || repository == NULL)
415         return;
416
417     /* Get the name of the verification script to run  */
418
419     data.message = *messagep;
420     data.fname = NULL;
421     data.changes = changes;
422     if ((err = Parse_Info (CVSROOTADM_VERIFYMSG, repository,
423                           verifymsg_proc, 0, &data)) != 0)
424     {
425         int saved_errno = errno;
426         /* Since following error() exits, delete the temp file now.  */
427         if (data.fname != NULL && unlink_file( data.fname ) < 0)
428             error (0, errno, "cannot remove %s", data.fname);
429         free (data.fname);
430
431         errno = saved_errno;
432         error (1, err == -1 ? errno : 0, "Message verification failed");
433     }
434
435     /* Return if no temp file was created.  That means that we didn't call any
436      * verifymsg scripts.
437      */
438     if (data.fname == NULL)
439         return;
440
441     /* Get the mod time and size of the possibly new log message
442      * in always and stat modes.
443      */
444     if (config->RereadLogAfterVerify == LOGMSG_REREAD_ALWAYS ||
445         config->RereadLogAfterVerify == LOGMSG_REREAD_STAT)
446     {
447         if(stat (data.fname, &post_stbuf) != 0)
448             error (1, errno, "cannot find size of temp file %s", data.fname);
449     }
450
451     /* And reread the log message in `always' mode or in `stat' mode when it's
452      * changed.
453      */
454     if (config->RereadLogAfterVerify == LOGMSG_REREAD_ALWAYS ||
455         (config->RereadLogAfterVerify == LOGMSG_REREAD_STAT &&
456           (data.pre_stbuf.st_mtime != post_stbuf.st_mtime ||
457             data.pre_stbuf.st_size != post_stbuf.st_size)))
458     {
459         /* put the entire message back into the *messagep variable */
460
461         if (*messagep) free (*messagep);
462
463         if (post_stbuf.st_size == 0)
464             *messagep = NULL;
465         else
466         {
467             char *line = NULL;
468             int line_length;
469             size_t line_chars_allocated = 0;
470             char *p;
471             FILE *fp;
472
473             fp = xfopen (data.fname, "r");
474
475             /* On NT, we might read less than st_size bytes,
476                but we won't read more.  So this works.  */
477             p = *messagep = (char *) xmalloc (post_stbuf.st_size + 1);
478             *messagep[0] = '\0';
479
480             for (;;)
481             {
482                 line_length = getline( &line,
483                                        &line_chars_allocated,
484                                        fp);
485                 if (line_length == -1)
486                 {
487                     if (ferror (fp))
488                         /* Fail in this case because otherwise we will have no
489                          * log message
490                          */
491                         error (1, errno, "cannot read %s", data.fname);
492                     break;
493                 }
494                 if (strncmp (line, CVSEDITPREFIX, CVSEDITPREFIXLEN) == 0)
495                     continue;
496                 (void) strcpy (p, line);
497                 p += line_length;
498             }
499             if (line) free (line);
500             if (fclose (fp) < 0)
501                 error (0, errno, "warning: cannot close %s", data.fname);
502         }
503     }
504     /* Delete the temp file  */
505     if (unlink_file (data.fname) < 0)
506         error (0, errno, "cannot remove `%s'", data.fname);
507     free (data.fname);
508 }
509
510
511
512 /*
513  * callback proc for Parse_Info for rcsinfo templates this routine basically
514  * copies the matching template onto the end of the tempfile we are setting
515  * up
516  */
517 /* ARGSUSED */
518 static int
519 rcsinfo_proc (const char *repository, const char *template, void *closure)
520 {
521     static char *last_template;
522     FILE *tfp;
523
524     /* nothing to do if the last one included is the same as this one */
525     if (last_template && strcmp (last_template, template) == 0)
526         return (0);
527     if (last_template)
528         free (last_template);
529     last_template = xstrdup (template);
530
531     if ((tfp = CVS_FOPEN (template, "r")) != NULL)
532     {
533         char *line = NULL;
534         size_t line_chars_allocated = 0;
535
536         while (getline (&line, &line_chars_allocated, tfp) >= 0)
537             (void) fputs (line, fp);
538         if (ferror (tfp))
539             error (0, errno, "warning: cannot read %s", template);
540         if (fclose (tfp) < 0)
541             error (0, errno, "warning: cannot close %s", template);
542         if (line)
543             free (line);
544         return (0);
545     }
546     else
547     {
548         error (0, errno, "Couldn't open rcsinfo template file %s", template);
549         return (1);
550     }
551 }
552
553 /*
554  * Uses setup_tmpfile() to pass the updated message on directly to any
555  * logfile programs that have a regular expression match for the checked in
556  * directory in the source repository.  The log information is fed into the
557  * specified program as standard input.
558  */
559 struct ulp_data {
560     FILE *logfp;
561     const char *message;
562     List *changes;
563 };
564
565
566
567 void
568 Update_Logfile (const char *repository, const char *xmessage, FILE *xlogfp,
569                 List *xchanges)
570 {
571     struct ulp_data ud;
572
573     /* nothing to do if the list is empty */
574     if (xchanges == NULL || xchanges->list->next == xchanges->list)
575         return;
576
577     /* set up vars for update_logfile_proc */
578     ud.message = xmessage;
579     ud.logfp = xlogfp;
580     ud.changes = xchanges;
581
582     /* call Parse_Info to do the actual logfile updates */
583     (void) Parse_Info (CVSROOTADM_LOGINFO, repository, update_logfile_proc,
584                        PIOPT_ALL, &ud);
585 }
586
587
588
589 /*
590  * callback proc to actually do the logfile write from Update_Logfile
591  */
592 static int
593 update_logfile_proc (const char *repository, const char *filter, void *closure)
594 {
595     struct ulp_data *udp = closure;
596     TRACE (TRACE_FUNCTION, "update_logfile_proc(%s,%s)", repository, filter);
597     return logfile_write (repository, filter, udp->message, udp->logfp,
598                           udp->changes);
599 }
600
601
602
603 /* static int
604  * logmsg_list_to_args_proc( Node *p, void *closure )
605  * This function is intended to be passed into walklist() with a list of tags
606  * (nodes in the same format as pretag_list_proc() accepts - p->key = tagname
607  * and p->data = a revision.
608  *
609  * closure will be a struct format_cmdline_walklist_closure
610  * where closure is undefined.
611  */
612 static int
613 logmsg_list_to_args_proc (Node *p, void *closure)
614 {
615     struct format_cmdline_walklist_closure *c = closure;
616     struct logfile_info *li;
617     char *arg = NULL;
618     const char *f;
619     char *d;
620     size_t doff;
621
622     if (p->data == NULL) return 1;
623
624     f = c->format;
625     d = *c->d;
626     /* foreach requested attribute */
627     while (*f)
628     {
629         switch (*f++)
630         {
631             case 's':
632                 arg = p->key;
633                 break;
634             case 'T':
635                 li = p->data;
636                 arg = li->tag ? li->tag : "";
637                 break;
638             case 'V':
639                 li = p->data;
640                 arg = li->rev_old ? li->rev_old : "NONE";
641                 break;
642             case 'v':
643                 li = p->data;
644                 arg = li->rev_new ? li->rev_new : "NONE";
645                 break;
646             default:
647 #ifdef SUPPORT_OLD_INFO_FMT_STRINGS
648                 if (c->onearg)
649                 {
650                     /* The old deafult was to print the empty string for
651                      * unknown args.
652                      */
653                     arg = "\0";
654                 }
655                 else
656 #endif /* SUPPORT_OLD_INFO_FMT_STRINGS */
657                     error (1, 0,
658                            "Unknown format character or not a list attribute: %c", f[-1]);
659                 /* NOTREACHED */
660                 break;
661         }
662         /* copy the attribute into an argument */
663 #ifdef SUPPORT_OLD_INFO_FMT_STRINGS
664         if (c->onearg)
665         {
666             if (c->firstpass)
667             {
668                 c->firstpass = 0;
669                 doff = d - *c->buf;
670                 expand_string (c->buf, c->length,
671                                doff + strlen (c->srepos) + 1);
672                 d = *c->buf + doff;
673                 strncpy (d, c->srepos, strlen (c->srepos));
674                 d += strlen (c->srepos);
675                 *d++ = ' ';
676             }
677         }
678         else /* c->onearg */
679 #endif /* SUPPORT_OLD_INFO_FMT_STRINGS */
680         {
681             if (c->quotes)
682             {
683                 arg = cmdlineescape (c->quotes, arg);
684             }
685             else
686             {
687                 arg = cmdlinequote ('"', arg);
688             }
689         } /* !c->onearg */
690         doff = d - *c->buf;
691         expand_string (c->buf, c->length, doff + strlen (arg));
692         d = *c->buf + doff;
693         strncpy (d, arg, strlen (arg));
694         d += strlen (arg);
695 #ifdef SUPPORT_OLD_INFO_FMT_STRINGS
696         if (!c->onearg)
697 #endif /* SUPPORT_OLD_INFO_FMT_STRINGS */
698             free (arg);
699
700         /* Always put the extra space on.  we'll have to back up a char
701          * when we're done, but that seems most efficient.
702          */
703         doff = d - *c->buf;
704         expand_string (c->buf, c->length, doff + 1);
705         d = *c->buf + doff;
706 #ifdef SUPPORT_OLD_INFO_FMT_STRINGS
707         if (c->onearg && *f) *d++ = ',';
708         else
709 #endif /* SUPPORT_OLD_INFO_FMT_STRINGS */
710             *d++ = ' ';
711     }
712     /* correct our original pointer into the buff */
713     *c->d = d;
714     return 0;
715 }
716
717
718
719 /*
720  * Writes some stuff to the logfile "filter" and returns the status of the
721  * filter program.
722  */
723 static int
724 logfile_write (const char *repository, const char *filter, const char *message,
725                FILE *logfp, List *changes)
726 {
727     char *cmdline;
728     FILE *pipefp;
729     char *cp;
730     int c;
731     int pipestatus;
732     const char *srepos = Short_Repository (repository);
733
734     assert (repository);
735
736     /* The user may specify a format string as part of the filter.
737        Originally, `%s' was the only valid string.  The string that
738        was substituted for it was:
739
740          <repository-name> <file1> <file2> <file3> ...
741
742        Each file was either a new directory/import (T_TITLE), or a
743        added (T_ADDED), modified (T_MODIFIED), or removed (T_REMOVED)
744        file.
745
746        It is desirable to preserve that behavior so lots of commitlog
747        scripts won't die when they get this new code.  At the same
748        time, we'd like to pass other information about the files (like
749        version numbers, statuses, or checkin times).
750
751        The solution is to allow a format string that allows us to
752        specify those other pieces of information.  The format string
753        will be composed of `%' followed by a single format character,
754        or followed by a set of format characters surrounded by `{' and
755        `}' as separators.  The format characters are:
756
757          s = file name
758          V = old version number (pre-checkin)
759          v = new version number (post-checkin)
760
761        For example, valid format strings are:
762
763          %{}
764          %s
765          %{s}
766          %{sVv}
767
768        There's no reason that more items couldn't be added (like
769        modification date or file status [added, modified, updated,
770        etc.]) -- the code modifications would be minimal (logmsg.c
771        (title_proc) and commit.c (check_fileproc)).
772
773        The output will be a string of tokens separated by spaces.  For
774        backwards compatibility, the the first token will be the
775        repository name.  The rest of the tokens will be
776        comma-delimited lists of the information requested in the
777        format string.  For example, if `/u/src/master' is the
778        repository, `%{sVv}' is the format string, and three files
779        (ChangeLog, Makefile, foo.c) were modified, the output might
780        be:
781
782          /u/src/master ChangeLog,1.1,1.2 Makefile,1.3,1.4 foo.c,1.12,1.13
783
784        Why this duplicates the old behavior when the format string is
785        `%s' is left as an exercise for the reader. */
786
787     /* %c = cvs_cmd_name
788      * %p = shortrepos
789      * %r = repository
790      * %{sVv} = file name, old revision (precommit), new revision (postcommit)
791      */
792     /*
793      * Cast any NULL arguments as appropriate pointers as this is an
794      * stdarg function and we need to be certain the caller gets what
795      * is expected.
796      */
797     cmdline = format_cmdline (
798 #ifdef SUPPORT_OLD_INFO_FMT_STRINGS
799                               !config->UseNewInfoFmtStrings, srepos,
800 #endif /* SUPPORT_OLD_INFO_FMT_STRINGS */
801                               filter,
802                               "c", "s", cvs_cmd_name,
803 #ifdef SERVER_SUPPORT
804                               "R", "s", referrer ? referrer->original : "NONE",
805 #endif /* SERVER_SUPPORT */
806                               "p", "s", srepos,
807                               "r", "s", current_parsed_root->directory,
808                               "sVv", ",", changes,
809                               logmsg_list_to_args_proc, (void *) NULL,
810                               (char *) NULL);
811     if (!cmdline || !strlen (cmdline))
812     {
813         if (cmdline) free (cmdline);
814         error (0, 0, "logmsg proc resolved to the empty string!");
815         return 1;
816     }
817
818     if ((pipefp = run_popen (cmdline, "w")) == NULL)
819     {
820         if (!noexec)
821             error (0, 0, "cannot write entry to log filter: %s", cmdline);
822         free (cmdline);
823         return 1;
824     }
825     (void) fprintf (pipefp, "Update of %s\n", repository);
826     (void) fprintf (pipefp, "In directory %s:", hostname);
827     cp = xgetcwd ();
828     if (cp == NULL)
829         fprintf (pipefp, "<cannot get working directory: %s>\n\n",
830                  strerror (errno));
831     else
832     {
833         fprintf (pipefp, "%s\n\n", cp);
834         free (cp);
835     }
836
837     setup_tmpfile (pipefp, "", changes);
838     (void) fprintf (pipefp, "Log Message:\n%s\n", (message) ? message : "");
839     if (logfp)
840     {
841         (void) fprintf (pipefp, "Status:\n");
842         rewind (logfp);
843         while ((c = getc (logfp)) != EOF)
844             (void) putc (c, pipefp);
845     }
846     free (cmdline);
847     pipestatus = pclose (pipefp);
848     return ((pipestatus == -1) || (pipestatus == 127)) ? 1 : 0;
849 }
850
851
852
853 /*  This routine is called by Parse_Info.  It runs the
854  *  message verification script.
855  */
856 static int
857 verifymsg_proc (const char *repository, const char *script, void *closure)
858 {
859     char *verifymsg_script;
860 #ifdef SUPPORT_OLD_INFO_FMT_STRINGS
861     char *newscript = NULL;
862 #endif /* SUPPORT_OLD_INFO_FMT_STRINGS */
863     struct verifymsg_proc_data *vpd = closure;
864     const char *srepos = Short_Repository (repository);
865
866 #ifdef SUPPORT_OLD_INFO_FMT_STRINGS
867     if (!strchr (script, '%'))
868     {
869         error (0, 0,
870                "warning: verifymsg line doesn't contain any format strings:\n"
871                "    \"%s\"\n"
872                "Appending default format string (\" %%l\"), but be aware that this usage is\n"
873                "deprecated.", script);
874         script = newscript = Xasprintf ("%s %%l", script);
875     }
876 #endif /* SUPPORT_OLD_INFO_FMT_STRINGS */
877
878     /* If we don't already have one, open a temporary file, write the message
879      * to the temp file, and close the file.
880      *
881      * We do this here so that we only create the file when there is a
882      * verifymsg script specified and we only create it once when there is
883      * more than one verifymsg script specified.
884      */
885     if (vpd->fname == NULL)
886     {
887         FILE *fp;
888         if ((fp = cvs_temp_file (&(vpd->fname))) == NULL)
889             error (1, errno, "cannot create temporary file %s", vpd->fname);
890
891         if (vpd->message != NULL)
892             fputs (vpd->message, fp);
893         if (vpd->message == NULL ||
894             (vpd->message)[0] == '\0' ||
895             (vpd->message)[strlen (vpd->message) - 1] != '\n')
896             putc ('\n', fp);
897         if (fclose (fp) == EOF)
898             error (1, errno, "%s", vpd->fname);
899
900         if (config->RereadLogAfterVerify == LOGMSG_REREAD_STAT)
901         {
902             /* Remember the status of the temp file for later */
903             if (stat (vpd->fname, &(vpd->pre_stbuf)) != 0)
904                 error (1, errno, "cannot stat temp file %s", vpd->fname);
905
906             /*
907              * See if we need to sleep before running the verification
908              * script to avoid time-stamp races.
909              */
910             sleep_past (vpd->pre_stbuf.st_mtime);
911         }
912     } /* if (vpd->fname == NULL) */
913
914     /*
915      * Cast any NULL arguments as appropriate pointers as this is an
916      * stdarg function and we need to be certain the caller gets what
917      * is expected.
918      */
919     verifymsg_script = format_cmdline (
920 #ifdef SUPPORT_OLD_INFO_FMT_STRINGS
921                                        false, srepos,
922 #endif /* SUPPORT_OLD_INFO_FMT_STRINGS */
923                                        script,
924                                        "c", "s", cvs_cmd_name,
925 #ifdef SERVER_SUPPORT
926                                        "R", "s", referrer
927                                        ? referrer->original : "NONE",
928 #endif /* SERVER_SUPPORT */
929                                        "p", "s", srepos,
930                                        "r", "s",
931                                        current_parsed_root->directory,
932                                        "l", "s", vpd->fname,
933                                        "sV", ",", vpd->changes,
934                                        logmsg_list_to_args_proc, (void *) NULL,
935                                        (char *) NULL);
936
937 #ifdef SUPPORT_OLD_INFO_FMT_STRINGS
938     if (newscript) free (newscript);
939 #endif /* SUPPORT_OLD_INFO_FMT_STRINGS */
940
941     if (!verifymsg_script || !strlen (verifymsg_script))
942     {
943         if (verifymsg_script) free (verifymsg_script);
944         verifymsg_script = NULL;
945         error (0, 0, "verifymsg proc resolved to the empty string!");
946         return 1;
947     }
948
949     run_setup (verifymsg_script);
950
951     free (verifymsg_script);
952
953     /* FIXME - because run_exec can return negative values and Parse_Info adds
954      * the values of each call to this function to get a total error, we are
955      * calling abs on the value of run_exec to ensure two errors do not sum to
956      * zero.
957      *
958      * The only REALLY obnoxious thing about this, I guess, is that a -1 return
959      * code from run_exec can mean we failed to call the process for some
960      * reason and should care about errno or that the process we called
961      * returned -1 and the value of errno is undefined.  In other words,
962      * run_exec should probably be rewritten to have two return codes.  one
963      * which is its own exit status and one which is the child process's.  So
964      * there.  :P
965      *
966      * Once run_exec is returning two error codes, we should probably be
967      * failing here with an error message including errno when we get the
968      * return code which means we care about errno, in case you missed that
969      * little tidbit.
970      *
971      * I do happen to know we just fail for a non-zero value anyway and I
972      * believe the docs actually state that if the verifymsg_proc returns a
973      * "non-zero" value we will fail.
974      */
975     return abs (run_exec (RUN_TTY, RUN_TTY, RUN_TTY,
976                           RUN_NORMAL | RUN_SIGIGNORE));
977 }