also add -fwrapv to CFLAGS (addresses #698908)
[alioth/cvs.git] / src / edit.c
1 /* Implementation for "cvs edit", "cvs watch on", and related commands
2
3    This program is free software; you can redistribute it and/or modify
4    it under the terms of the GNU General Public License as published by
5    the Free Software Foundation; either version 2, or (at your option)
6    any later version.
7
8    This program is distributed in the hope that it will be useful,
9    but WITHOUT ANY WARRANTY; without even the implied warranty of
10    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11    GNU General Public License for more details.  */
12
13 #include "cvs.h"
14 #include "getline.h"
15 #include "yesno.h"
16 #include "watch.h"
17 #include "edit.h"
18 #include "fileattr.h"
19
20 static int watch_onoff (int, char **);
21
22 static bool check_edited = false;
23 static int setting_default;
24 static int turning_on;
25
26 static bool setting_tedit;
27 static bool setting_tunedit;
28 static bool setting_tcommit;
29
30
31
32 static int
33 onoff_fileproc (void *callerdat, struct file_info *finfo)
34 {
35     fileattr_get0 (finfo->file, "_watched");
36     fileattr_set (finfo->file, "_watched", turning_on ? "" : NULL);
37     return 0;
38 }
39
40
41
42 static int
43 onoff_filesdoneproc (void *callerdat, int err, const char *repository,
44                      const char *update_dir, List *entries)
45 {
46     if (setting_default)
47     {
48         fileattr_get0 (NULL, "_watched");
49         fileattr_set (NULL, "_watched", turning_on ? "" : NULL);
50     }
51     return err;
52 }
53
54
55
56 static int
57 watch_onoff (int argc, char **argv)
58 {
59     int c;
60     int local = 0;
61     int err;
62
63     optind = 0;
64     while ((c = getopt (argc, argv, "+lR")) != -1)
65     {
66         switch (c)
67         {
68             case 'l':
69                 local = 1;
70                 break;
71             case 'R':
72                 local = 0;
73                 break;
74             case '?':
75             default:
76                 usage (watch_usage);
77                 break;
78         }
79     }
80     argc -= optind;
81     argv += optind;
82
83 #ifdef CLIENT_SUPPORT
84     if (current_parsed_root->isremote)
85     {
86         start_server ();
87
88         ign_setup ();
89
90         if (local)
91             send_arg ("-l");
92         send_arg ("--");
93         send_files (argc, argv, local, 0, SEND_NO_CONTENTS);
94         send_file_names (argc, argv, SEND_EXPAND_WILD);
95         send_to_server (turning_on ? "watch-on\012" : "watch-off\012", 0);
96         return get_responses_and_close ();
97     }
98 #endif /* CLIENT_SUPPORT */
99
100     setting_default = (argc <= 0);
101
102     lock_tree_promotably (argc, argv, local, W_LOCAL, 0);
103
104     err = start_recursion (onoff_fileproc, onoff_filesdoneproc, NULL, NULL,
105                            NULL, argc, argv, local, W_LOCAL, 0, CVS_LOCK_WRITE,
106                            NULL, 0, NULL);
107
108     Lock_Cleanup ();
109     return err;
110 }
111
112 int
113 watch_on (int argc, char **argv)
114 {
115     turning_on = 1;
116     return watch_onoff (argc, argv);
117 }
118
119 int
120 watch_off (int argc, char **argv)
121 {
122     turning_on = 0;
123     return watch_onoff (argc, argv);
124 }
125
126
127
128 static int
129 dummy_fileproc (void *callerdat, struct file_info *finfo)
130 {
131     /* This is a pretty hideous hack, but the gist of it is that recurse.c
132        won't call notify_check unless there is a fileproc, so we can't just
133        pass NULL for fileproc.  */
134     return 0;
135 }
136
137
138
139 /* Check for and process notifications.  Local only.  I think that doing
140    this as a fileproc is the only way to catch all the
141    cases (e.g. foo/bar.c), even though that means checking over and over
142    for the same CVSADM_NOTIFY file which we removed the first time we
143    processed the directory.  */
144 static int
145 ncheck_fileproc (void *callerdat, struct file_info *finfo)
146 {
147     int notif_type;
148     char *filename;
149     char *val;
150     char *cp;
151     char *watches;
152
153     FILE *fp;
154     char *line = NULL;
155     size_t line_len = 0;
156
157     /* We send notifications even if noexec.  I'm not sure which behavior
158        is most sensible.  */
159
160     fp = CVS_FOPEN (CVSADM_NOTIFY, "r");
161     if (fp == NULL)
162     {
163         if (!existence_error (errno))
164             error (0, errno, "cannot open %s", CVSADM_NOTIFY);
165         return 0;
166     }
167
168     while (getline (&line, &line_len, fp) > 0)
169     {
170         notif_type = line[0];
171         if (notif_type == '\0')
172             continue;
173         filename = line + 1;
174         cp = strchr (filename, '\t');
175         if (cp == NULL)
176             continue;
177         *cp++ = '\0';
178         val = cp;
179         cp = strchr (val, '\t');
180         if (cp == NULL)
181             continue;
182         *cp++ = '+';
183         cp = strchr (cp, '\t');
184         if (cp == NULL)
185             continue;
186         *cp++ = '+';
187         cp = strchr (cp, '\t');
188         if (cp == NULL)
189             continue;
190         *cp++ = '\0';
191         watches = cp;
192         cp = strchr (cp, '\n');
193         if (cp == NULL)
194             continue;
195         *cp = '\0';
196
197         notify_do (notif_type, filename, finfo->update_dir, getcaller (), val,
198                    watches, finfo->repository);
199     }
200     free (line);
201
202     if (ferror (fp))
203         error (0, errno, "cannot read %s", CVSADM_NOTIFY);
204     if (fclose (fp) < 0)
205         error (0, errno, "cannot close %s", CVSADM_NOTIFY);
206
207     if ( CVS_UNLINK (CVSADM_NOTIFY) < 0)
208         error (0, errno, "cannot remove %s", CVSADM_NOTIFY);
209
210     return 0;
211 }
212
213
214
215 /* Look through the CVSADM_NOTIFY file and process each item there
216    accordingly.  */
217 static int
218 send_notifications (int argc, char **argv, int local)
219 {
220     int err = 0;
221
222 #ifdef CLIENT_SUPPORT
223     /* OK, we've done everything which needs to happen on the client side.
224        Now we can try to contact the server; if we fail, then the
225        notifications stay in CVSADM_NOTIFY to be sent next time.  */
226     if (current_parsed_root->isremote)
227     {
228         if (strcmp (cvs_cmd_name, "release") != 0)
229         {
230             start_server ();
231             ign_setup ();
232         }
233
234         err += start_recursion (dummy_fileproc, NULL, NULL, NULL, NULL, argc,
235                                 argv, local, W_LOCAL, 0, 0, NULL, 0, NULL);
236
237         send_to_server ("noop\012", 0);
238         if (strcmp (cvs_cmd_name, "release") == 0)
239             err += get_server_responses ();
240         else
241             err += get_responses_and_close ();
242     }
243     else
244 #endif
245     {
246         /* Local.  */
247
248         err += start_recursion (ncheck_fileproc, NULL, NULL, NULL, NULL, argc,
249                                 argv, local, W_LOCAL, 0, CVS_LOCK_WRITE, NULL,
250                                 0, NULL);
251         Lock_Cleanup ();
252     }
253     return err;
254 }
255
256
257
258 void editors_output (const char *fullname, const char *p)
259 {
260     cvs_output (fullname, 0);
261
262     while (1)
263     {
264         cvs_output ("\t", 1);
265         while (*p != '>' && *p != '\0')
266             cvs_output (p++, 1);
267         if (*p == '\0')
268         {
269             /* Only happens if attribute is misformed.  */
270             cvs_output ("\n", 1);
271             break;
272         }
273         ++p;
274         cvs_output ("\t", 1);
275         while (1)
276         {
277             while (*p != '+' && *p != ',' && *p != '\0')
278                 cvs_output (p++, 1);
279             if (*p == '\0')
280             {
281                 cvs_output ("\n", 1);
282                 return;
283             }
284             if (*p == ',')
285             {
286                 ++p;
287                 break;
288             }
289             ++p;
290             cvs_output ("\t", 1);
291         }
292         cvs_output ("\n", 1);
293     }
294 }
295
296
297
298 static int find_editors_and_output (struct file_info *finfo)
299 {
300     char *them;
301
302     them = fileattr_get0 (finfo->file, "_editors");
303     if (them == NULL)
304         return 0;
305
306     editors_output (finfo->fullname, them);
307
308     return 0;
309 }
310
311
312
313 /* Handle the client-side details of editing a file.
314  *
315  * These args could be const but this needs to fit the call_in_directory API.
316  */
317 void
318 edit_file (void *data, List *ent_list, const char *short_pathname,
319            const char *filename)
320 {
321     Node *node;
322     struct file_info finfo;
323     char *basefilename;
324
325     xchmod (filename, 1);
326
327     mkdir_if_needed (CVSADM_BASE);
328     basefilename = Xasprintf ("%s/%s", CVSADM_BASE, filename);
329     copy_file (filename, basefilename);
330     free (basefilename);
331
332     node = findnode_fn (ent_list, filename);
333     if (node != NULL)
334     {
335         finfo.file = filename;
336         finfo.fullname = short_pathname;
337         finfo.update_dir = dir_name (short_pathname);
338         base_register (&finfo, ((Entnode *) node->data)->version);
339         free ((char *)finfo.update_dir);
340     }
341 }
342
343
344
345 static int
346 edit_fileproc (void *callerdat, struct file_info *finfo)
347 {
348     FILE *fp;
349     time_t now;
350     char *ascnow;
351     Vers_TS *vers;
352
353 #if defined (CLIENT_SUPPORT)
354     assert (!(current_parsed_root->isremote && check_edited));
355 #else /* !CLIENT_SUPPORT */
356     assert (!check_edited);
357 #endif /* CLIENT_SUPPORT */
358
359     if (noexec)
360         return 0;
361
362     vers = Version_TS (finfo, NULL, NULL, NULL, 1, 0);
363
364     if (!vers->vn_user)
365     {
366         error (0, 0, "no such file %s; ignored", finfo->fullname);
367         return 1;
368     }
369
370 #ifdef CLIENT_SUPPORT
371     if (!current_parsed_root->isremote)
372 #endif /* CLIENT_SUPPORT */
373     {
374         char *editors = fileattr_get0 (finfo->file, "_editors");
375         if (editors)
376         {
377             if (check_edited)
378             {
379                 /* In the !CHECK_EDIT case, this message is printed by
380                  * server_notify.
381                  */
382                 if (!quiet)
383                     editors_output (finfo->fullname, editors);
384                  /* Now warn the user if we skip the file, then return.  */
385                 if (!really_quiet)
386                     error (0, 0, "Skipping file `%s' due to existing editors.",
387                            finfo->fullname);
388                 return 1;
389             }
390             free (editors);
391         }
392     }
393
394     fp = xfopen (CVSADM_NOTIFY, "a");
395
396     (void) time (&now);
397     ascnow = asctime (gmtime (&now));
398     ascnow[24] = '\0';
399     /* Fix non-standard format.  */
400     if (ascnow[8] == '0') ascnow[8] = ' ';
401     fprintf (fp, "E%s\t%s -0000\t%s\t%s\t", finfo->file,
402              ascnow, hostname, CurDir);
403     if (setting_tedit)
404         fprintf (fp, "E");
405     if (setting_tunedit)
406         fprintf (fp, "U");
407     if (setting_tcommit)
408         fprintf (fp, "C");
409     fprintf (fp, "\n");
410
411     if (fclose (fp) < 0)
412     {
413         if (finfo->update_dir[0] == '\0')
414             error (0, errno, "cannot close %s", CVSADM_NOTIFY);
415         else
416             error (0, errno, "cannot close %s/%s", finfo->update_dir,
417                    CVSADM_NOTIFY);
418     }
419
420     /* Now stash the file away in CVSADM so that unedit can revert even if
421        it can't communicate with the server.  We stash away a writable
422        copy so that if the user removes the working file, then restores it
423        with "cvs update" (which clears _editors but does not update
424        CVSADM_BASE), then a future "cvs edit" can still win.  */
425     /* Could save a system call by only calling mkdir_if_needed if
426        trying to create the output file fails.  But copy_file isn't
427        set up to facilitate that.  */
428 #ifdef SERVER_SUPPORT
429     if (server_active)
430         server_edit_file (finfo);
431     else
432 #endif /* SERVER_SUPPORT */
433         edit_file (NULL, finfo->entries, finfo->fullname, finfo->file);
434
435     return 0;
436 }
437
438 static const char *const edit_usage[] =
439 {
440     "Usage: %s %s [-lRcf] [-a <action>]... [<file>]...\n",
441     "-l\tLocal directory only, not recursive.\n",
442     "-R\tProcess directories recursively (default).\n",
443     "-a\tSpecify action to register for temporary watch, one of:\n",
444     "  \t`edit', `unedit', `commit', `all', `none' (defaults to `all').\n",
445     "-c\tCheck for <file>s edited by others and abort if found.\n",
446     "-f\tAllow edit if <file>s are edited by others (default).\n",
447     "(Specify the --help global option for a list of other help options.)\n",
448     NULL
449 };
450
451 int
452 edit (int argc, char **argv)
453 {
454     int local = 0;
455     int c;
456     int err = 0;
457     bool a_omitted, a_all, a_none;
458
459     if (argc == -1)
460         usage (edit_usage);
461
462     a_omitted = true;
463     a_all = false;
464     a_none = false;
465     setting_tedit = false;
466     setting_tunedit = false;
467     setting_tcommit = false;
468     optind = 0;
469     while ((c = getopt (argc, argv, "+cflRa:")) != -1)
470     {
471         switch (c)
472         {
473             case 'c':
474                 check_edited = true;
475                 break;
476             case 'f':
477                 check_edited = false;
478                 break;
479             case 'l':
480                 local = 1;
481                 break;
482             case 'R':
483                 local = 0;
484                 break;
485             case 'a':
486                 a_omitted = false;
487                 if (strcmp (optarg, "edit") == 0)
488                     setting_tedit = true;
489                 else if (strcmp (optarg, "unedit") == 0)
490                     setting_tunedit = true;
491                 else if (strcmp (optarg, "commit") == 0)
492                     setting_tcommit = true;
493                 else if (strcmp (optarg, "all") == 0)
494                 {
495                     a_all = true;
496                     a_none = false;
497                     setting_tedit = true;
498                     setting_tunedit = true;
499                     setting_tcommit = true;
500                 }
501                 else if (strcmp (optarg, "none") == 0)
502                 {
503                     a_none = true;
504                     a_all = false;
505                     setting_tedit = false;
506                     setting_tunedit = false;
507                     setting_tcommit = false;
508                 }
509                 else
510                     usage (edit_usage);
511                 break;
512             case '?':
513             default:
514                 usage (edit_usage);
515                 break;
516         }
517     }
518     argc -= optind;
519     argv += optind;
520
521     if (strpbrk (hostname, "+,>;=\t\n") != NULL)
522         error (1, 0,
523                "host name (%s) contains an invalid character (+,>;=\\t\\n)",
524                hostname);
525     if (strpbrk (CurDir, "+,>;=\t\n") != NULL)
526         error (1, 0,
527 "current directory (%s) contains an invalid character (+,>;=\\t\\n)",
528                CurDir);
529
530 #ifdef CLIENT_SUPPORT
531     if (check_edited && current_parsed_root->isremote)
532     {
533         /* When CHECK_EDITED, we might as well contact the server and let it do
534          * the work since we don't want an edit unless we know it is safe.
535          *
536          * When !CHECK_EDITED, we set up notifications and then attempt to
537          * contact the server in order to allow disconnected edits.
538          */
539         start_server();
540
541         if (!supported_request ("edit"))
542             error (1, 0, "Server does not support enforced advisory locks.");
543
544         ign_setup();
545
546         send_to_server ("Hostname ", 0);
547         send_to_server (hostname, 0);
548         send_to_server ("\012", 1);
549         send_to_server ("LocalDir ", 0);
550         send_to_server (CurDir, 0);
551         send_to_server ("\012", 1);
552
553         if (local)
554             send_arg ("-l");
555         send_arg ("-c");
556         if (!a_omitted)
557         {
558             if (a_all)
559                 option_with_arg ("-a", "all");
560             else if (a_none)
561                 option_with_arg ("-a", "none");
562             else
563             {
564                 if (setting_tedit)
565                     option_with_arg ("-a", "edit");
566                 if (setting_tunedit)
567                     option_with_arg ("-a", "unedit");
568                 if (setting_tcommit)
569                     option_with_arg ("-a", "commit");
570             }
571         }
572         send_arg ("--");
573         send_files (argc, argv, local, 0, SEND_NO_CONTENTS);
574         send_file_names (argc, argv, SEND_EXPAND_WILD);
575         send_to_server ("edit\012", 0);
576         return get_responses_and_close ();
577     }
578 #endif /* CLIENT_SUPPORT */
579
580     /* Now, either SERVER_ACTIVE, local mode, or !CHECK_EDITED.  */
581
582     if (a_omitted)
583     {
584         setting_tedit = true;
585         setting_tunedit = true;
586         setting_tcommit = true;
587     }
588
589     TRACE (TRACE_DATA, "edit(): EUC: %d%d%d edit-check: %d",
590            setting_tedit, setting_tunedit, setting_tcommit, check_edited);
591
592     err = start_recursion (edit_fileproc, NULL, NULL, NULL, NULL, argc, argv,
593                            local, W_LOCAL, 0, 0, NULL, 0, NULL);
594
595     err += send_notifications (argc, argv, local);
596
597     return err;
598 }
599
600 static int unedit_fileproc (void *callerdat, struct file_info *finfo);
601
602 static int
603 unedit_fileproc (void *callerdat, struct file_info *finfo)
604 {
605     FILE *fp;
606     time_t now;
607     char *ascnow;
608     char *basefilename = NULL;
609
610     if (noexec)
611         return 0;
612
613     basefilename = Xasprintf ("%s/%s", CVSADM_BASE, finfo->file);
614     if (!isfile (basefilename))
615     {
616         /* This file apparently was never cvs edit'd (e.g. we are uneditting
617            a directory where only some of the files were cvs edit'd.  */
618         free (basefilename);
619         return 0;
620     }
621
622     if (xcmp (finfo->file, basefilename) != 0)
623     {
624         printf ("%s has been modified; revert changes? ", finfo->fullname);
625         fflush (stderr);
626         fflush (stdout);
627         if (!yesno ())
628         {
629             /* "no".  */
630             free (basefilename);
631             return 0;
632         }
633     }
634     rename_file (basefilename, finfo->file);
635     free (basefilename);
636
637     fp = xfopen (CVSADM_NOTIFY, "a");
638
639     (void) time (&now);
640     ascnow = asctime (gmtime (&now));
641     ascnow[24] = '\0';
642     /* Fix non-standard format.  */
643     if (ascnow[8] == '0') ascnow[8] = ' ';
644     fprintf (fp, "U%s\t%s -0000\t%s\t%s\t\n", finfo->file,
645              ascnow, hostname, CurDir);
646
647     if (fclose (fp) < 0)
648     {
649         if (finfo->update_dir[0] == '\0')
650             error (0, errno, "cannot close %s", CVSADM_NOTIFY);
651         else
652             error (0, errno, "cannot close %s/%s", finfo->update_dir,
653                    CVSADM_NOTIFY);
654     }
655
656     /* Now update the revision number in CVS/Entries from CVS/Baserev.
657        The basic idea here is that we are reverting to the revision
658        that the user edited.  If we wanted "cvs update" to update
659        CVS/Base as we go along (so that an unedit could revert to the
660        current repository revision), we would need:
661
662        update (or all send_files?) (client) needs to send revision in
663        new Entry-base request.  update (server/local) needs to check
664        revision against repository and send new Update-base response
665        (like Update-existing in that the file already exists.  While
666        we are at it, might try to clean up the syntax by having the
667        mode only in a "Mode" response, not in the Update-base itself).  */
668     {
669         char *baserev;
670         Node *node;
671         Entnode *entdata;
672
673         baserev = base_get (finfo);
674         node = findnode_fn (finfo->entries, finfo->file);
675         /* The case where node is NULL probably should be an error or
676            something, but I don't want to think about it too hard right
677            now.  */
678         if (node != NULL)
679         {
680             entdata = node->data;
681             if (baserev == NULL)
682             {
683                 /* This can only happen if the CVS/Baserev file got
684                    corrupted.  We suspect it might be possible if the
685                    user interrupts CVS, although I haven't verified
686                    that.  */
687                 error (0, 0, "%s not mentioned in %s", finfo->fullname,
688                        CVSADM_BASEREV);
689
690                 /* Since we don't know what revision the file derives from,
691                    keeping it around would be asking for trouble.  */
692                 if (unlink_file (finfo->file) < 0)
693                     error (0, errno, "cannot remove %s", finfo->fullname);
694
695                 /* This is cheesy, in a sense; why shouldn't we do the
696                    update for the user?  However, doing that would require
697                    contacting the server, so maybe this is OK.  */
698                 error (0, 0, "run update to complete the unedit");
699                 return 0;
700             }
701             Register (finfo->entries, finfo->file, baserev, entdata->timestamp,
702                       entdata->options, entdata->tag, entdata->date,
703                       entdata->conflict);
704         }
705         free (baserev);
706         base_deregister (finfo);
707     }
708
709     xchmod (finfo->file, 0);
710     return 0;
711 }
712
713 static const char *const unedit_usage[] =
714 {
715     "Usage: %s %s [-lR] [<file>]...\n",
716     "-l\tLocal directory only, not recursive.\n",
717     "-R\tProcess directories recursively (default).\n",
718     "(Specify the --help global option for a list of other help options.)\n",
719     NULL
720 };
721
722 int
723 unedit (int argc, char **argv)
724 {
725     int local = 0;
726     int c;
727     int err;
728
729     if (argc == -1)
730         usage (unedit_usage);
731
732     optind = 0;
733     while ((c = getopt (argc, argv, "+lR")) != -1)
734     {
735         switch (c)
736         {
737             case 'l':
738                 local = 1;
739                 break;
740             case 'R':
741                 local = 0;
742                 break;
743             case '?':
744             default:
745                 usage (unedit_usage);
746                 break;
747         }
748     }
749     argc -= optind;
750     argv += optind;
751
752     /* No need to readlock since we aren't doing anything to the
753        repository.  */
754     err = start_recursion (unedit_fileproc, NULL, NULL, NULL, NULL, argc, argv,
755                            local, W_LOCAL, 0, 0, NULL, 0, NULL);
756
757     err += send_notifications (argc, argv, local);
758
759     return err;
760 }
761
762
763
764 void
765 mark_up_to_date (const char *file)
766 {
767     char *base;
768
769     /* The file is up to date, so we better get rid of an out of
770        date file in CVSADM_BASE.  */
771     base = Xasprintf ("%s/%s", CVSADM_BASE, file);
772     if (unlink_file (base) < 0 && ! existence_error (errno))
773         error (0, errno, "cannot remove %s", file);
774     free (base);
775 }
776
777
778
779 void
780 editor_set (const char *filename, const char *editor, const char *val)
781 {
782     char *edlist;
783     char *newlist;
784
785     edlist = fileattr_get0 (filename, "_editors");
786     newlist = fileattr_modify (edlist, editor, val, '>', ',');
787     /* If the attributes is unchanged, don't rewrite the attribute file.  */
788     if (!((edlist == NULL && newlist == NULL)
789           || (edlist != NULL
790               && newlist != NULL
791               && strcmp (edlist, newlist) == 0)))
792         fileattr_set (filename, "_editors", newlist);
793     if (edlist != NULL)
794         free (edlist);
795     if (newlist != NULL)
796         free (newlist);
797 }
798
799 struct notify_proc_args {
800     /* What kind of notification, "edit", "tedit", etc.  */
801     const char *type;
802     /* User who is running the command which causes notification.  */
803     const char *who;
804     /* User to be notified.  */
805     const char *notifyee;
806     /* File.  */
807     const char *file;
808 };
809
810
811
812 static int
813 notify_proc (const char *repository, const char *filter, void *closure)
814 {
815     char *cmdline;
816     FILE *pipefp;
817     const char *srepos = Short_Repository (repository);
818     struct notify_proc_args *args = closure;
819
820     /*
821      * Cast any NULL arguments as appropriate pointers as this is an
822      * stdarg function and we need to be certain the caller gets what
823      * is expected.
824      */
825     cmdline = format_cmdline (
826 #ifdef SUPPORT_OLD_INFO_FMT_STRINGS
827                               false, srepos,
828 #endif /* SUPPORT_OLD_INFO_FMT_STRINGS */
829                               filter,
830                               "c", "s", cvs_cmd_name,
831                               "I", "s", global_session_id,
832 #ifdef SERVER_SUPPORT
833                               "R", "s", referrer ? referrer->original : "NONE",
834 #endif /* SERVER_SUPPORT */
835                               "p", "s", srepos,
836                               "r", "s", current_parsed_root->directory,
837                               "s", "s", args->notifyee,
838                               (char *) NULL);
839     if (!cmdline || !strlen (cmdline))
840     {
841         if (cmdline) free (cmdline);
842         error (0, 0, "pretag proc resolved to the empty string!");
843         return 1;
844     }
845
846     pipefp = run_popen (cmdline, "w");
847     if (pipefp == NULL)
848     {
849         error (0, errno, "cannot write entry to notify filter: %s", cmdline);
850         free (cmdline);
851         return 1;
852     }
853
854     fprintf (pipefp, "%s %s\n---\n", srepos, args->file);
855     fprintf (pipefp, "Triggered %s watch on %s\n", args->type, repository);
856     fprintf (pipefp, "By %s\n", args->who);
857
858     /* Lots more potentially useful information we could add here; see
859        logfile_write for inspiration.  */
860
861     free (cmdline);
862     return pclose (pipefp);
863 }
864
865
866
867 /* FIXME: this function should have a way to report whether there was
868    an error so that server.c can know whether to report Notified back
869    to the client.  */
870 void
871 notify_do (int type, const char *filename, const char *update_dir,
872            const char *who, const char *val, const char *watches,
873            const char *repository)
874 {
875     static struct addremove_args blank;
876     struct addremove_args args;
877     char *watchers;
878     char *p;
879     char *endp;
880     char *nextp;
881
882     /* Print out information on current editors if we were called during an
883      * edit.
884      */
885     if (type == 'E' && !check_edited && !quiet)
886     {
887         char *editors = fileattr_get0 (filename, "_editors");
888         if (editors)
889         {
890             /* In the CHECK_EDIT case, this message is printed by
891              * edit_check.  It needs to be done here too since files
892              * which are found to be edited when CHECK_EDIT are not
893              * added to the notify list.
894              */
895             const char *tmp;
896             if (update_dir && *update_dir)
897                 tmp  = Xasprintf ("%s/%s", update_dir, filename);
898             else
899                 tmp = filename;
900
901             editors_output (tmp, editors);
902
903             if (update_dir && *update_dir) free ((char *)tmp);
904             free (editors);
905         }
906     }
907
908     /* Initialize fields to 0, NULL, or 0.0.  */
909     args = blank;
910     switch (type)
911     {
912         case 'E':
913             if (strpbrk (val, ",>;=\n") != NULL)
914             {
915                 error (0, 0, "invalid character in editor value");
916                 return;
917             }
918             editor_set (filename, who, val);
919             break;
920         case 'U':
921         case 'C':
922             editor_set (filename, who, NULL);
923             break;
924         default:
925             return;
926     }
927
928     watchers = fileattr_get0 (filename, "_watchers");
929     p = watchers;
930     while (p != NULL)
931     {
932         char *q;
933         char *endq;
934         char *nextq;
935         char *notif;
936
937         endp = strchr (p, '>');
938         if (endp == NULL)
939             break;
940         nextp = strchr (p, ',');
941
942         if ((size_t)(endp - p) == strlen (who) && strncmp (who, p, endp - p) == 0)
943         {
944             /* Don't notify user of their own changes.  Would perhaps
945                be better to check whether it is the same working
946                directory, not the same user, but that is hairy.  */
947             p = nextp == NULL ? nextp : nextp + 1;
948             continue;
949         }
950
951         /* Now we point q at a string which looks like
952            "edit+unedit+commit,"... and walk down it.  */
953         q = endp + 1;
954         notif = NULL;
955         while (q != NULL)
956         {
957             endq = strchr (q, '+');
958             if (endq == NULL || (nextp != NULL && endq > nextp))
959             {
960                 if (nextp == NULL)
961                     endq = q + strlen (q);
962                 else
963                     endq = nextp;
964                 nextq = NULL;
965             }
966             else
967                 nextq = endq + 1;
968
969             /* If there is a temporary and a regular watch, send a single
970                notification, for the regular watch.  */
971             if (type == 'E' && endq - q == 4 && strncmp ("edit", q, 4) == 0)
972             {
973                 notif = "edit";
974             }
975             else if (type == 'U'
976                      && endq - q == 6 && strncmp ("unedit", q, 6) == 0)
977             {
978                 notif = "unedit";
979             }
980             else if (type == 'C'
981                      && endq - q == 6 && strncmp ("commit", q, 6) == 0)
982             {
983                 notif = "commit";
984             }
985             else if (type == 'E'
986                      && endq - q == 5 && strncmp ("tedit", q, 5) == 0)
987             {
988                 if (notif == NULL)
989                     notif = "temporary edit";
990             }
991             else if (type == 'U'
992                      && endq - q == 7 && strncmp ("tunedit", q, 7) == 0)
993             {
994                 if (notif == NULL)
995                     notif = "temporary unedit";
996             }
997             else if (type == 'C'
998                      && endq - q == 7 && strncmp ("tcommit", q, 7) == 0)
999             {
1000                 if (notif == NULL)
1001                     notif = "temporary commit";
1002             }
1003             q = nextq;
1004         }
1005         if (nextp != NULL)
1006             ++nextp;
1007
1008         if (notif != NULL)
1009         {
1010             struct notify_proc_args args;
1011             size_t len = endp - p;
1012             FILE *fp;
1013             char *usersname;
1014             char *line = NULL;
1015             size_t line_len = 0;
1016
1017             args.notifyee = NULL;
1018             usersname = Xasprintf ("%s/%s/%s", current_parsed_root->directory,
1019                                    CVSROOTADM, CVSROOTADM_USERS);
1020             fp = CVS_FOPEN (usersname, "r");
1021             if (fp == NULL && !existence_error (errno))
1022                 error (0, errno, "cannot read %s", usersname);
1023             if (fp != NULL)
1024             {
1025                 while (getline (&line, &line_len, fp) >= 0)
1026                 {
1027                     if (strncmp (line, p, len) == 0
1028                         && line[len] == ':')
1029                     {
1030                         char *cp;
1031                         args.notifyee = xstrdup (line + len + 1);
1032
1033                         /* There may or may not be more
1034                            colon-separated fields added to this in the
1035                            future; in any case, we ignore them right
1036                            now, and if there are none we make sure to
1037                            chop off the final newline, if any. */
1038                         cp = strpbrk (args.notifyee, ":\n");
1039
1040                         if (cp != NULL)
1041                             *cp = '\0';
1042                         break;
1043                     }
1044                 }
1045                 if (ferror (fp))
1046                     error (0, errno, "cannot read %s", usersname);
1047                 if (fclose (fp) < 0)
1048                     error (0, errno, "cannot close %s", usersname);
1049             }
1050             free (usersname);
1051             if (line != NULL)
1052                 free (line);
1053
1054             if (args.notifyee == NULL)
1055             {
1056                 char *tmp;
1057                 tmp = xmalloc (endp - p + 1);
1058                 strncpy (tmp, p, endp - p);
1059                 tmp[endp - p] = '\0';
1060                 args.notifyee = tmp;
1061             }
1062
1063             args.type = notif;
1064             args.who = who;
1065             args.file = filename;
1066
1067             (void) Parse_Info (CVSROOTADM_NOTIFY, repository, notify_proc,
1068                                PIOPT_ALL, &args);
1069             /* It's okay to cast out the const for the free() below since we
1070              * just allocated this a few lines above.  The const was for
1071              * everybody else.
1072              */
1073             free ((char *)args.notifyee);
1074         }
1075
1076         p = nextp;
1077     }
1078     if (watchers != NULL)
1079         free (watchers);
1080
1081     switch (type)
1082     {
1083         case 'E':
1084             if (*watches == 'E')
1085             {
1086                 args.add_tedit = 1;
1087                 ++watches;
1088             }
1089             if (*watches == 'U')
1090             {
1091                 args.add_tunedit = 1;
1092                 ++watches;
1093             }
1094             if (*watches == 'C')
1095             {
1096                 args.add_tcommit = 1;
1097             }
1098             watch_modify_watchers (filename, &args);
1099             break;
1100         case 'U':
1101         case 'C':
1102             args.remove_temp = 1;
1103             watch_modify_watchers (filename, &args);
1104             break;
1105     }
1106 }
1107
1108
1109
1110 #ifdef CLIENT_SUPPORT
1111 /* Check and send notifications.  This is only for the client.  */
1112 void
1113 notify_check (const char *repository, const char *update_dir)
1114 {
1115     FILE *fp;
1116     char *line = NULL;
1117     size_t line_len = 0;
1118
1119     if (!server_started)
1120         /* We are in the midst of a command which is not to talk to
1121            the server (e.g. the first phase of a cvs edit).  Just chill
1122            out, we'll catch the notifications on the flip side.  */
1123         return;
1124
1125     /* We send notifications even if noexec.  I'm not sure which behavior
1126        is most sensible.  */
1127
1128     fp = CVS_FOPEN (CVSADM_NOTIFY, "r");
1129     if (fp == NULL)
1130     {
1131         if (!existence_error (errno))
1132             error (0, errno, "cannot open %s", CVSADM_NOTIFY);
1133         return;
1134     }
1135     while (getline (&line, &line_len, fp) > 0)
1136     {
1137         int notif_type;
1138         char *filename;
1139         char *val;
1140         char *cp;
1141
1142         notif_type = line[0];
1143         if (notif_type == '\0')
1144             continue;
1145         filename = line + 1;
1146         cp = strchr (filename, '\t');
1147         if (cp == NULL)
1148             continue;
1149         *cp++ = '\0';
1150         val = cp;
1151
1152         client_notify (repository, update_dir, filename, notif_type, val);
1153     }
1154     if (line)
1155         free (line);
1156     if (ferror (fp))
1157         error (0, errno, "cannot read %s", CVSADM_NOTIFY);
1158     if (fclose (fp) < 0)
1159         error (0, errno, "cannot close %s", CVSADM_NOTIFY);
1160
1161     /* Leave the CVSADM_NOTIFY file there, until the server tells us it
1162        has dealt with it.  */
1163 }
1164 #endif /* CLIENT_SUPPORT */
1165
1166
1167 static const char *const editors_usage[] =
1168 {
1169     "Usage: %s %s [-lR] [<file>]...\n",
1170     "-l\tProcess this directory only (not recursive).\n",
1171     "-R\tProcess directories recursively (default).\n",
1172     "(Specify the --help global option for a list of other help options.)\n",
1173     NULL
1174 };
1175
1176
1177
1178 static int
1179 editors_fileproc (void *callerdat, struct file_info *finfo)
1180 {
1181     return find_editors_and_output (finfo);
1182 }
1183
1184
1185
1186 int
1187 editors (int argc, char **argv)
1188 {
1189     int local = 0;
1190     int c;
1191
1192     if (argc == -1)
1193         usage (editors_usage);
1194
1195     optind = 0;
1196     while ((c = getopt (argc, argv, "+lR")) != -1)
1197     {
1198         switch (c)
1199         {
1200             case 'l':
1201                 local = 1;
1202                 break;
1203             case 'R':
1204                 local = 0;
1205                 break;
1206             case '?':
1207             default:
1208                 usage (editors_usage);
1209                 break;
1210         }
1211     }
1212     argc -= optind;
1213     argv += optind;
1214
1215 #ifdef CLIENT_SUPPORT
1216     if (current_parsed_root->isremote)
1217     {
1218         start_server ();
1219         ign_setup ();
1220
1221         if (local)
1222             send_arg ("-l");
1223         send_arg ("--");
1224         send_files (argc, argv, local, 0, SEND_NO_CONTENTS);
1225         send_file_names (argc, argv, SEND_EXPAND_WILD);
1226         send_to_server ("editors\012", 0);
1227         return get_responses_and_close ();
1228     }
1229 #endif /* CLIENT_SUPPORT */
1230
1231     return start_recursion (editors_fileproc, NULL, NULL, NULL, NULL,
1232                             argc, argv, local, W_LOCAL, 0, CVS_LOCK_READ, NULL,
1233                             0, NULL);
1234 }