2 * Copyright (C) 1994-2005 The Free Software Foundation, Inc.
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2, or (at your option)
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
15 /* **************** History of Users and Module ****************
17 * LOGGING: Append record to "${CVSROOT}/CVSROOTADM/CVSROOTADM_HISTORY".
19 * On For each Tag, Add, Checkout, Commit, Update or Release command,
20 * one line of text is written to a History log.
22 * X date | user | CurDir | special | rev(s) | argument '\n'
24 * where: [The spaces in the example line above are not in the history file.]
26 * X is a single character showing the type of event:
31 * W "Update" cmd - No User file, Remove from Entries file.
32 * U "Update" cmd - File was checked out over User file.
33 * P "Update" cmd - User file was patched.
34 * G "Update" cmd - File was merged successfully.
35 * C "Update" cmd - File was merged and shows overlaps.
36 * M "Commit" cmd - "Modified" file.
37 * A "Commit" cmd - "Added" file.
38 * R "Commit" cmd - "Removed" file.
40 * date is a fixed length 8-char hex representation of a Unix time_t.
41 * [Starting here, variable fields are delimited by '|' chars.]
43 * user is the username of the person who typed the command.
45 * CurDir The directory where the action occurred. This should be the
46 * absolute path of the directory which is at the same level as
47 * the "Repository" field (for W,U,P,G,C & M,A,R).
49 * Repository For record types [W,U,P,G,C,M,A,R] this field holds the
50 * repository read from the administrative data where the
52 * T "A" --> New Tag, "D" --> Delete Tag
53 * Otherwise it is the Tag or Date to modify.
54 * O,F,E A "" (null field)
56 * rev(s) Revision number or tag.
58 * O,E The Tag or Date, if specified, else "" (null field).
60 * W The Tag or Date, if specified, else "" (null field).
61 * U,P The Revision checked out over the User file.
62 * G,C The Revision(s) involved in merge.
63 * M,A,R RCS Revision affected.
65 * argument The module (for [TOEF]) or file (for [WUPGCMAR]) affected.
68 *** Report categories: "User" and "Since" modifiers apply to all reports.
69 * [For "sort" ordering see the "sort_order" routine.]
71 * Extract list of record types
73 * -e, -x [TOEFWUPGCMAR]
75 * Extracted records are simply printed, No analysis is performed.
76 * All "field" modifiers apply. -e chooses all types.
78 * Checked 'O'ut modules
81 * Checked out modules. 'F' and 'O' records are examined and if
82 * the last record for a repository/file is an 'O', a line is
83 * printed. "-w" forces the "working dir" to be used in the
84 * comparison instead of the repository.
86 * Committed (Modified) files
89 * All 'M'odified, 'A'dded and 'R'emoved records are examined.
90 * "Field" modifiers apply. -l forces a sort by file within user
91 * and shows only the last modifier. -w works as in Checkout.
93 * Warning: Be careful with what you infer from the output of
94 * "cvs hi -c -l". It means the last time *you*
95 * changed the file, not the list of files for which
96 * you were the last changer!!!
98 * Module history for named modules.
101 * This is special. If one or more modules are specified, the
102 * module names are remembered and the files making up the
103 * modules are remembered. Only records matching exactly those
104 * files and repositories are shown. Sorting by "module", then
105 * filename, is implied. If -l ("last modified") is specified,
106 * then "update" records (types WUPCG), tag and release records
107 * are ignored and the last (by date) "modified" record.
111 * -T All Tag records are displayed.
115 * Since ... [All records contain a timestamp, so any report
116 * category can be limited by date.]
118 * -D date - The "date" is parsed into a Unix "time_t" and
119 * records with an earlier time stamp are ignored.
120 * -r rev/tag - A "rev" begins with a digit. A "tag" does not. If
121 * you use this option, every file is searched for the
123 * -t tag - The "tag" is searched for in the history file and no
124 * record is displayed before the tag is found. An
125 * error is printed if the tag is never found.
126 * -b string - Records are printed only back to the last reference
127 * to the string in the "module", "file" or
128 * "repository" fields.
130 * Field Selections [Simple comparisons on existing fields. All field
131 * selections are repeatable.]
134 * -u user - If no user is given and '-a' is not given, only
135 * records for the user typing the command are shown.
136 * ==> If -a or -u is not specified, just use "self".
138 * -f filematch - Only records in which the "file" field contains the
139 * string "filematch" are considered.
141 * -p repository - Only records in which the "repository" string is a
142 * prefix of the "repos" field are considered.
144 * -n modulename - Only records which contain "modulename" in the
145 * "module" field are considered.
148 * EXAMPLES: ("cvs history", "cvs his" or "cvs hi")
150 *** Checked out files for username. (default self, e.g. "dgg")
151 * cvs hi [equivalent to: "cvs hi -o -u dgg"]
152 * cvs hi -u user [equivalent to: "cvs hi -o -u user"]
153 * cvs hi -o [equivalent to: "cvs hi -o -u dgg"]
155 *** Committed (modified) files from the beginning of the file.
156 * cvs hi -c [-u user]
158 *** Committed (modified) files since Midnight, January 1, 1990:
159 * cvs hi -c -D 'Jan 1 1990' [-u user]
161 *** Committed (modified) files since tag "TAG" was stored in the history file:
162 * cvs hi -c -t TAG [-u user]
164 *** Committed (modified) files since tag "TAG" was placed on the files:
165 * cvs hi -c -r TAG [-u user]
167 *** Who last committed file/repository X?
168 * cvs hi -c -l -[fp] X
170 *** Modified files since tag/date/file/repos?
171 * cvs hi -c {-r TAG | -D Date | -b string}
176 *** History of file/repository/module X.
179 *** History of user "user".
182 *** Dump (eXtract) specified record types
183 * cvs hi -x [TOEFWUPGCMAR]
186 * FUTURE: J[Join], I[Import] (Not currently implemented.)
192 #include "save-cwd.h"
196 char *type
; /* Type of record (In history record) */
197 char *user
; /* Username (In history record) */
198 char *dir
; /* "Compressed" Working dir (In history record) */
199 char *repos
; /* (Tag is special.) Repository (In history record) */
200 char *rev
; /* Revision affected (In history record) */
201 char *file
; /* Filename (In history record) */
202 char *end
; /* Ptr into repository to copy at end of workdir */
203 char *mod
; /* The module within which the file is contained */
204 time_t date
; /* Calculated from date stored in record */
205 long idx
; /* Index of record, for "stable" sort. */
207 static long hrec_idx
;
210 static void fill_hrec (char *line
, struct hrec
* hr
);
211 static int accept_hrec (struct hrec
* hr
, struct hrec
* lr
);
212 static int select_hrec (struct hrec
* hr
);
213 static int sort_order (const void *l
, const void *r
);
214 static int within (char *find
, char *string
);
215 static void expand_modules (void);
216 static void read_hrecs (List
*flist
);
217 static void report_hrecs (void);
218 static void save_file (char *dir
, char *name
, char *module
);
219 static void save_module (char *module
);
220 static void save_user (char *name
);
222 #define USER_INCREMENT 2
223 #define FILE_INCREMENT 128
224 #define MODULE_INCREMENT 5
225 #define HREC_INCREMENT 128
227 static short report_count
;
229 static short extract
;
230 static short extract_all
;
231 static short v_checkout
;
232 static short modified
;
233 static short tag_report
;
234 static short module_report
;
235 static short working
;
236 static short last_entry
;
237 static short all_users
;
239 static short user_sort
;
240 static short repos_sort
;
241 static short file_sort
;
242 static short module_sort
;
244 static short tz_local
;
245 static time_t tz_seconds_east_of_GMT
;
246 static char *tz_name
= "+0000";
248 /* -r, -t, or -b options, malloc'd. These are "" if the option in
249 question is not specified or is overridden by another option. The
250 main reason for using "" rather than NULL is historical. Together
251 with since_date, these are a mutually exclusive set; one overrides the
253 static char *since_rev
;
254 static char *since_tag
;
256 /* -D option, or 0 if not specified. RCS format. */
257 static char * since_date
;
259 static struct hrec
*last_since_tag
;
260 static struct hrec
*last_backto
;
262 /* Record types to look for, malloc'd. Probably could be statically
263 allocated, but only if we wanted to check for duplicates more than
265 static char *rec_types
;
267 static int hrec_count
;
270 static char **user_list
; /* Ptr to array of ptrs to user names */
271 static int user_max
; /* Number of elements allocated */
272 static int user_count
; /* Number of elements used */
274 static struct file_list_str
278 } *file_list
; /* Ptr to array file name structs */
279 static int file_max
; /* Number of elements allocated */
280 static int file_count
; /* Number of elements used */
282 static char **mod_list
; /* Ptr to array of ptrs to module names */
283 static int mod_max
; /* Number of elements allocated */
284 static int mod_count
; /* Number of elements used */
286 /* This is pretty unclear. First of all, separating "flags" vs.
287 "options" (I think the distinction is that "options" take arguments)
288 is nonstandard, and not something we do elsewhere in CVS. Second of
289 all, what does "reports" mean? I think it means that you can only
290 supply one of those options, but "reports" hardly has that meaning in
291 a self-explanatory way. */
292 static const char *const history_usg
[] =
294 "Usage: %s %s [-report] [-flags] [-options args] [files...]\n\n",
296 " -T Produce report on all TAGs\n",
297 " -c Committed (Modified) files\n",
298 " -o Checked out modules\n",
299 " -m <module> Look for specified module (repeatable)\n",
300 " -x [" ALL_HISTORY_REC_TYPES
"] Extract by record type\n",
301 " -e Everything (same as -x, but all record types)\n",
303 " -a All users (Default is self)\n",
304 " -l Last modified (committed or modified report)\n",
305 " -w Working directory must match\n",
307 " -D <date> Since date (Many formats)\n",
308 " -b <str> Back to record with str in module/file/repos field\n",
309 " -f <file> Specified file (same as command line) (repeatable)\n",
310 " -n <modulename> In module (repeatable)\n",
311 " -p <repos> In repository (repeatable)\n",
312 " -r <rev/tag> Since rev or tag (looks inside RCS files!)\n",
313 " -t <tag> Since tag record placed in history file (by anyone).\n",
314 " -u <user> For user name (repeatable)\n",
315 " -z <tz> Output for time zone <tz> (e.g. -z -0700)\n",
318 /* Sort routine for qsort:
319 - If a user is selected at all, sort it first. User-within-file is useless.
320 - If a module was selected explicitly, sort next on module.
321 - Then sort by file. "File" is "repository/file" unless "working" is set,
322 then it is "workdir/file". (Revision order should always track date.)
323 - Always sort timestamp last.
326 sort_order (const void *l
, const void *r
)
329 const struct hrec
*left
= l
;
330 const struct hrec
*right
= r
;
332 if (user_sort
) /* If Sort by username, compare users */
334 if ((i
= strcmp (left
->user
, right
->user
)) != 0)
337 if (module_sort
) /* If sort by modules, compare module names */
339 if (left
->mod
&& right
->mod
)
340 if ((i
= strcmp (left
->mod
, right
->mod
)) != 0)
343 if (repos_sort
) /* If sort by repository, compare them. */
345 if ((i
= strcmp (left
->repos
, right
->repos
)) != 0)
348 if (file_sort
) /* If sort by filename, compare files, NOT dirs. */
350 if ((i
= strcmp (left
->file
, right
->file
)) != 0)
355 if ((i
= strcmp (left
->dir
, right
->dir
)) != 0)
358 if ((i
= strcmp (left
->end
, right
->end
)) != 0)
364 * By default, sort by date, time
365 * XXX: This fails after 2030 when date slides into sign bit
367 if ((i
= ((long) (left
->date
) - (long) (right
->date
))) != 0)
370 /* For matching dates, keep the sort stable by using record index */
371 return left
->idx
- right
->idx
;
376 /* Get the name of the history log, either from CVSROOT/config, or via the
377 * hard-coded default.
380 get_history_log_name (time_t now
)
384 if (config
->HistoryLogPath
)
386 /* ~, $VARs, and were expanded via expand_path() when CVSROOT/config
389 log_name
= xmalloc (PATH_MAX
);
390 if (!now
) now
= time (NULL
);
391 if (!strftime (log_name
, PATH_MAX
, config
->HistoryLogPath
,
394 error (0, 0, "Invalid date format in HistoryLogPath.");
395 free (config
->HistoryLogPath
);
396 config
->HistoryLogPath
= NULL
;
400 if (!config
->HistoryLogPath
)
402 /* Use the default. */
403 log_name
= xmalloc (strlen (current_parsed_root
->directory
)
404 + sizeof (CVSROOTADM
)
405 + sizeof (CVSROOTADM_HISTORY
) + 3);
406 sprintf (log_name
, "%s/%s/%s", current_parsed_root
->directory
,
407 CVSROOTADM
, CVSROOTADM_HISTORY
);
416 history (int argc
, char **argv
)
419 const char *fname
= NULL
;
425 since_rev
= xstrdup ("");
426 since_tag
= xstrdup ("");
427 backto
= xstrdup ("");
428 rec_types
= xstrdup ("");
430 while ((c
= getopt (argc
, argv
, "+Tacelow?D:b:f:m:n:p:r:t:u:x:X:z:")) != -1)
434 case 'T': /* Tag list */
438 case 'a': /* For all usernames */
449 rec_types
= xstrdup (ALL_HISTORY_REC_TYPES
);
451 case 'l': /* Find Last file record */
458 case 'w': /* Match Working Dir (CurDir) fields */
461 case 'X': /* Undocumented debugging flag */
467 case 'D': /* Since specified date */
468 if (*since_rev
|| *since_tag
|| *backto
)
470 error (0, 0, "date overriding rev/tag/backto");
471 *since_rev
= *since_tag
= *backto
= '\0';
473 since_date
= Make_Date (optarg
);
475 case 'b': /* Since specified file/Repos */
476 if (since_date
|| *since_rev
|| *since_tag
)
478 error (0, 0, "backto overriding date/rev/tag");
479 *since_rev
= *since_tag
= '\0';
480 if (since_date
!= NULL
)
485 backto
= xstrdup (optarg
);
487 case 'f': /* For specified file */
488 save_file (NULL
, optarg
, NULL
);
490 case 'm': /* Full module report */
491 if (!module_report
++) report_count
++;
493 case 'n': /* Look for specified module */
494 save_module (optarg
);
496 case 'p': /* For specified directory */
497 save_file (optarg
, NULL
, NULL
);
499 case 'r': /* Since specified Tag/Rev */
500 if (since_date
|| *since_tag
|| *backto
)
502 error (0, 0, "rev overriding date/tag/backto");
503 *since_tag
= *backto
= '\0';
504 if (since_date
!= NULL
)
509 since_rev
= xstrdup (optarg
);
511 case 't': /* Since specified Tag/Rev */
512 if (since_date
|| *since_rev
|| *backto
)
514 error (0, 0, "tag overriding date/marker/file/repos");
515 *since_rev
= *backto
= '\0';
516 if (since_date
!= NULL
)
521 since_tag
= xstrdup (optarg
);
523 case 'u': /* For specified username */
532 for (cp
= optarg
; *cp
; cp
++)
533 if (!strchr (ALL_HISTORY_REC_TYPES
, *cp
))
534 error (1, 0, "%c is not a valid report type", *cp
);
537 rec_types
= xstrdup (optarg
);
541 (optarg
[0] == 'l' || optarg
[0] == 'L')
542 && (optarg
[1] == 't' || optarg
[1] == 'T')
549 * Convert a known time with the given timezone to time_t.
550 * Use the epoch + 23 hours, so timezones east of GMT work.
553 char *buf
= Xasprintf ("1/1/1970 23:00 %s", optarg
);
554 if (get_date (&t
, buf
, NULL
))
557 * Convert to seconds east of GMT, removing the
558 * 23-hour offset mentioned above.
560 tz_seconds_east_of_GMT
= (time_t)23 * 60 * 60
565 error (0, 0, "%s is not a known time zone", optarg
);
577 for (i
= 0; i
< argc
; i
++)
578 save_file (NULL
, argv
[i
], NULL
);
581 /* ================ Now analyze the arguments a bit */
584 else if (report_count
> 1)
585 error (1, 0, "Only one report type allowed from: \"-Tcomxe\".");
587 #ifdef CLIENT_SUPPORT
588 if (current_parsed_root
->isremote
)
590 struct file_list_str
*f1
;
593 /* We're the client side. Fire up the remote server. */
611 option_with_arg ("-X", fname
);
613 client_senddate (since_date
);
614 if (backto
[0] != '\0')
615 option_with_arg ("-b", backto
);
616 for (f1
= file_list
; f1
< &file_list
[file_count
]; ++f1
)
618 if (f1
->l_file
[0] == '*')
619 option_with_arg ("-p", f1
->l_file
+ 1);
621 option_with_arg ("-f", f1
->l_file
);
625 for (mod
= mod_list
; mod
< &mod_list
[mod_count
]; ++mod
)
626 option_with_arg ("-n", *mod
);
628 option_with_arg ("-r", since_rev
);
630 option_with_arg ("-t", since_tag
);
631 for (mod
= user_list
; mod
< &user_list
[user_count
]; ++mod
)
632 option_with_arg ("-u", *mod
);
636 option_with_arg ("-x", rec_types
);
637 option_with_arg ("-z", tz_name
);
639 send_to_server ("history\012", 0);
640 return get_responses_and_close ();
652 if (!strchr (rec_types
, 'T'))
654 rec_types
= xrealloc (rec_types
, strlen (rec_types
) + 5);
655 (void) strcat (rec_types
, "T");
658 else if (extract
|| extract_all
)
666 rec_types
= xstrdup ("MAR");
668 * If the user has not specified a date oriented flag ("Since"), sort
669 * by Repository/file before date. Default is "just" date.
672 || (!since_date
&& !*since_rev
&& !*since_tag
&& !*backto
))
677 * If we are not looking for last_modified and the user specified
678 * one or more users to look at, sort by user before filename.
680 if (!last_entry
&& user_list
)
684 else if (module_report
)
687 rec_types
= xstrdup (last_entry
? "OMAR" : ALL_HISTORY_REC_TYPES
);
691 working
= 0; /* User's workdir doesn't count here */
694 /* Must be "checkout" or default */
697 rec_types
= xstrdup ("OF");
698 /* See comments in "modified" above */
699 if (!last_entry
&& user_list
)
702 || (!since_date
&& !*since_rev
&& !*since_tag
&& !*backto
))
706 /* If no users were specified, use self (-a saves a universal ("") user) */
708 save_user (getcaller ());
710 /* If we're looking back to a Tag value, must consider "Tag" records */
711 if (*since_tag
&& !strchr (rec_types
, 'T'))
713 rec_types
= xrealloc (rec_types
, strlen (rec_types
) + 5);
714 (void) strcat (rec_types
, "T");
724 p
->key
= Xasprintf ("%s/%s/%s",
725 current_parsed_root
->directory
, CVSROOTADM
, fname
);
732 if (config
->HistorySearchPath
)
733 pat
= config
->HistorySearchPath
;
735 pat
= Xasprintf ("%s/%s/%s",
736 current_parsed_root
->directory
, CVSROOTADM
,
739 flist
= find_files (NULL
, pat
);
740 if (pat
!= config
->HistorySearchPath
) free (pat
);
745 qsort (hrec_head
, hrec_count
, sizeof (struct hrec
), sort_order
);
747 if (since_date
!= NULL
)
759 /* An empty LogHistory string in CVSROOT/config will turn logging off.
762 history_write (int type
, const char *update_dir
, const char *revs
,
763 const char *name
, const char *repository
)
767 char *username
= getcaller ();
770 char *slash
= "", *cp
;
771 const char *cp2
, *repos
;
773 static char *tilde
= "";
774 static char *PrCurDir
= NULL
;
777 if (logoff
) /* History is turned off by noexec or
781 if (!strchr (config
->logHistory
, type
))
787 repos
= Short_Repository (repository
);
793 pwdir
= get_homedir ();
797 /* Assumes neither CurDir nor pwdir ends in '/' */
799 if (!strncmp (CurDir
, pwdir
, i
))
801 PrCurDir
+= i
; /* Point to '/' separator */
806 /* Try harder to find a "homedir" */
807 struct saved_cwd cwd
;
811 error (1, errno
, "Failed to save current directory.");
813 if (CVS_CHDIR (pwdir
) < 0 || (homedir
= xgetcwd ()) == NULL
)
816 if (restore_cwd (&cwd
))
818 "Failed to restore current directory, `%s'.",
822 i
= strlen (homedir
);
823 if (!strncmp (CurDir
, homedir
, i
))
825 PrCurDir
+= i
; /* Point to '/' separator */
829 if (homedir
!= pwdir
)
840 else if (update_dir
&& *update_dir
)
845 workdir
= Xasprintf ("%s%s%s%s", tilde
, PrCurDir
, slash
, update_dir
);
848 * "workdir" is the directory where the file "name" is. ("^~" == $HOME)
849 * "repos" is the Repository, relative to $CVSROOT where the RCS file is.
851 * "$workdir/$name" is the working file name.
852 * "$CVSROOT/$repos/$name,v" is the RCS file in the Repository.
854 * First, note that the history format was intended to save space, not
855 * to be human readable.
857 * The working file directory ("workdir") and the Repository ("repos")
858 * usually end with the same one or more directory elements. To avoid
859 * duplication (and save space), the "workdir" field ends with
860 * an integer offset into the "repos" field. This offset indicates the
861 * beginning of the "tail" of "repos", after which all characters are
864 * In other words, if the "workdir" field has a '*' (a very stupid thing
865 * to put in a filename) in it, then every thing following the last '*'
866 * is a hex offset into "repos" of the first character from "repos" to
867 * append to "workdir" to finish the pathname.
869 * It might be easier to look at an example:
871 * M273b3463|dgg|~/work*9|usr/local/cvs/examples|1.2|loginfo
873 * Indicates that the workdir is really "~/work/cvs/examples", saving
874 * 10 characters, where "~/work*d" would save 6 characters and mean that
875 * the workdir is really "~/work/examples". It will mean more on
876 * directories like: usr/local/gnu/emacs/dist-19.17/lisp/term
878 * "workdir" is always an absolute pathname (~/xxx is an absolute path)
879 * "repos" is always a relative pathname. So we can assume that we will
880 * never run into the top of "workdir" -- there will always be a '/' or
881 * a '~' at the head of "workdir" that is not matched by anything in
882 * "repos". On the other hand, we *can* run off the top of "repos".
884 * Only "compress" if we save characters.
887 cp
= workdir
+ strlen (workdir
) - 1;
888 cp2
= repos
+ strlen (repos
) - 1;
889 for (i
= 0; cp2
>= repos
&& cp
> workdir
&& *cp
== *cp2
--; cp
--)
894 i
= strlen (repos
) - i
;
895 (void) sprintf ((cp
+ 1), "*%x", i
);
901 line
= Xasprintf ("%c%08lx|%s|%s|%s|%s|%s\n", type
, (long) now
,
902 username
, workdir
, repos
, revs
, name
);
904 fname
= get_history_log_name (now
);
906 if (!history_lock (current_parsed_root
->directory
))
907 /* history_lock() will already have printed an error on failure. */
910 fd
= CVS_OPEN (fname
, O_WRONLY
| O_APPEND
| O_CREAT
| OPEN_BINARY
, 0666);
915 "warning: cannot open history file `%s' for write", fname
);
919 TRACE (TRACE_FUNCTION
, "open (`%s', a)", fname
);
921 /* Lessen some race conditions on non-Posix-compliant hosts.
923 * FIXME: I'm guessing the following was necessary for NFS when multiple
924 * simultaneous writes to the same file are possible, since NFS does not
925 * natively support append mode and it must be emulated via lseek(). Now
926 * that the history file is locked for write, the following lseek() may be
929 if (lseek (fd
, (off_t
) 0, SEEK_END
) == -1)
930 error (1, errno
, "cannot seek to end of history file: %s", fname
);
932 if (write (fd
, line
, strlen (line
)) < 0)
933 error (1, errno
, "cannot write to history file: %s", fname
);
936 error (1, errno
, "cannot close history file: %s", fname
);
939 clear_history_lock ();
945 * save_user() adds a user name to the user list to select. Zero-length
946 * username ("") matches any user.
949 save_user (char *name
)
951 if (user_count
== user_max
)
953 user_max
= xsum (user_max
, USER_INCREMENT
);
954 if (size_overflow_p (xtimes (user_max
, sizeof (char *))))
956 error (0, 0, "save_user: too many users");
959 user_list
= xnrealloc (user_list
, user_max
, sizeof (char *));
961 user_list
[user_count
++] = xstrdup (name
);
965 * save_file() adds file name and associated module to the file list to select.
967 * If "dir" is null, store a file name as is.
968 * If "name" is null, store a directory name with a '*' on the front.
969 * Else, store concatenated "dir/name".
971 * Later, in the "select" stage:
972 * - if it starts with '*', it is prefix-matched against the repository.
973 * - if it has a '/' in it, it is matched against the repository/file.
974 * - else it is matched against the file name.
977 save_file (char *dir
, char *name
, char *module
)
979 struct file_list_str
*fl
;
981 if (file_count
== file_max
)
983 file_max
= xsum (file_max
, FILE_INCREMENT
);
984 if (size_overflow_p (xtimes (file_max
, sizeof (*fl
))))
986 error (0, 0, "save_file: too many files");
989 file_list
= xnrealloc (file_list
, file_max
, sizeof (*fl
));
991 fl
= &file_list
[file_count
++];
992 fl
->l_module
= module
;
997 fl
->l_file
= Xasprintf ("%s/%s", dir
, name
);
999 fl
->l_file
= Xasprintf ("*%s", dir
);
1004 fl
->l_file
= xstrdup (name
);
1006 error (0, 0, "save_file: null dir and file name");
1011 save_module (char *module
)
1013 if (mod_count
== mod_max
)
1015 mod_max
= xsum (mod_max
, MODULE_INCREMENT
);
1016 if (size_overflow_p (xtimes (mod_max
, sizeof (char *))))
1018 error (0, 0, "save_module: too many modules");
1021 mod_list
= xnrealloc (mod_list
, mod_max
, sizeof (char *));
1023 mod_list
[mod_count
++] = xstrdup (module
);
1027 expand_modules (void)
1033 * Take a ptr to 7-part history line, ending with a newline, for example:
1035 * M273b3463|dgg|~/work*9|usr/local/cvs/examples|1.2|loginfo
1037 * Split it into 7 parts and drop the parts into a "struct hrec".
1038 * Return a pointer to the character following the newline.
1042 #define NEXT_BAR(here) do { \
1043 while (isspace (*line)) line++; \
1045 while ((c = *line++) && c != '|') ; \
1046 if (!c) return; line[-1] = '\0'; \
1050 fill_hrec (char *line
, struct hrec
*hr
)
1055 hr
->type
= hr
->user
= hr
->dir
= hr
->repos
= hr
->rev
= hr
->file
=
1056 hr
->end
= hr
->mod
= NULL
;
1058 hr
->idx
= ++hrec_idx
;
1060 while (isspace ((unsigned char) *line
))
1064 hr
->date
= strtoul (line
, &cp
, 16);
1065 if (cp
== line
|| *cp
!= '|')
1070 if ((cp
= strrchr (hr
->dir
, '*')) != NULL
)
1073 hr
->end
= line
+ strtoul (cp
, NULL
, 16);
1076 hr
->end
= line
- 1; /* A handy pointer to '\0' */
1079 if (strchr ("FOET", *(hr
->type
)))
1086 #ifndef STAT_BLOCKSIZE
1087 #if HAVE_STRUCT_STAT_ST_BLKSIZE
1088 #define STAT_BLOCKSIZE(s) (s).st_blksize
1090 #define STAT_BLOCKSIZE(s) (4 * 1024)
1095 /* read_hrecs_file's job is to read a history file and fill in new "hrec"
1096 * (history record) array elements with the ones we need to print.
1099 * - Read a block from the file.
1100 * - Walk through the block parsing line into hr records.
1101 * - if the hr isn't used, free its strings, if it is, bump the hrec counter
1102 * - at the end of a block, copy the end of the current block to the start
1103 * of space for the next block, then read in the next block. If we get less
1104 * than the whole block, we're done.
1107 read_hrecs_file (Node
*p
, void *closure
)
1109 char *cpstart
, *cpend
, *cp
, *nl
;
1114 const char *fname
= p
->key
;
1116 if ((fd
= CVS_OPEN (fname
, O_RDONLY
| OPEN_BINARY
)) < 0)
1118 error (0, errno
, "cannot open history file `%s'", fname
);
1122 if (fstat (fd
, &st_buf
) < 0)
1124 error (0, errno
, "can't stat history file `%s'", fname
);
1128 if (!(st_buf
.st_size
))
1130 error (0, 0, "history file `%s' is empty", fname
);
1134 cpstart
= xnmalloc (2, STAT_BLOCKSIZE (st_buf
));
1136 cp
= cpend
= cpstart
;
1140 for (nl
= cp
; nl
< cpend
&& *nl
!= '\n'; nl
++)
1141 if (!isprint (*nl
)) *nl
= ' ';
1145 if (nl
- cp
>= STAT_BLOCKSIZE (st_buf
))
1147 error(1, 0, "history line %ld too long (> %lu)", hrec_idx
+ 1,
1148 (unsigned long) STAT_BLOCKSIZE(st_buf
));
1151 memmove (cpstart
, cp
, nl
- cp
);
1152 nl
= cpstart
+ (nl
- cp
);
1154 i
= read (fd
, nl
, STAT_BLOCKSIZE(st_buf
));
1163 error (0, errno
, "error reading history file `%s'", fname
);
1166 if (nl
== cp
) break;
1167 error (0, 0, "warning: no newline at end of history file `%s'",
1172 if (hrec_count
== hrec_max
)
1174 struct hrec
*old_head
= hrec_head
;
1176 hrec_max
+= HREC_INCREMENT
;
1177 hrec_head
= xnrealloc (hrec_head
, hrec_max
, sizeof (struct hrec
));
1179 last_since_tag
= hrec_head
+ (last_since_tag
- old_head
);
1181 last_backto
= hrec_head
+ (last_backto
- old_head
);
1184 /* fill_hrec dates from when history read the entire
1185 history file in one chunk, and then records were pulled out
1186 by pointing to the various parts of this big chunk. This is
1187 why there are ugly hacks here: I don't want to completely
1188 re-write the whole history stuff right now. */
1190 hrline
= xstrdup (cp
);
1191 fill_hrec (hrline
, &hrec_head
[hrec_count
]);
1192 if (select_hrec (&hrec_head
[hrec_count
]))
1206 /* Read the history records in from a list of history files. */
1208 read_hrecs (List
*flist
)
1212 /* The global history records are already initialized to 0 according to
1215 hrec_max
= HREC_INCREMENT
;
1216 hrec_head
= xmalloc (hrec_max
* sizeof (struct hrec
));
1219 files_read
= walklist (flist
, read_hrecs_file
, NULL
);
1221 error (1, 0, "No history files read.");
1223 /* Special selection problem: If "since_tag" is set, we have saved every
1224 * record from the 1st occurrence of "since_tag", when we want to save
1225 * records since the *last* occurrence of "since_tag". So what we have
1226 * to do is bump hrec_head forward and reduce hrec_count accordingly.
1230 hrec_count
-= (last_since_tag
- hrec_head
);
1231 hrec_head
= last_since_tag
;
1234 /* Much the same thing is necessary for the "backto" option. */
1237 hrec_count
-= (last_backto
- hrec_head
);
1238 hrec_head
= last_backto
;
1244 /* Utility program for determining whether "find" is inside "string" */
1246 within (char *find
, char *string
)
1250 if (!find
|| !string
)
1254 len
= strlen (find
);
1258 if (!(string
= strchr (string
, c
)))
1261 if (!strncmp (find
, string
, len
))
1267 /* The purpose of "select_hrec" is to apply the selection criteria based on
1268 * the command arguments and defaults and return a flag indicating whether
1269 * this record should be remembered for printing.
1272 select_hrec (struct hrec
*hr
)
1274 char **cpp
, *cp
, *cp2
;
1275 struct file_list_str
*fl
;
1278 /* basic validity checking */
1279 if (!hr
->type
|| !hr
->user
|| !hr
->dir
|| !hr
->repos
|| !hr
->rev
||
1280 !hr
->file
|| !hr
->end
)
1282 error (0, 0, "warning: history line %ld invalid", hr
->idx
);
1286 /* "Since" checking: The argument parser guarantees that only one of the
1287 * following four choices is set:
1289 * 1. If "since_date" is set, it contains the date specified on the
1290 * command line. hr->date fields earlier than "since_date" are ignored.
1291 * 2. If "since_rev" is set, it contains either an RCS "dotted" revision
1292 * number (which is of limited use) or a symbolic TAG. Each RCS file
1293 * is examined and the date on the specified revision (or the revision
1294 * corresponding to the TAG) in the RCS file (CVSROOT/repos/file) is
1295 * compared against hr->date as in 1. above.
1296 * 3. If "since_tag" is set, matching tag records are saved. The field
1297 * "last_since_tag" is set to the last one of these. Since we don't
1298 * know where the last one will be, all records are saved from the
1299 * first occurrence of the TAG. Later, at the end of "select_hrec"
1300 * records before the last occurrence of "since_tag" are skipped.
1301 * 4. If "backto" is set, all records with a module name or file name
1302 * matching "backto" are saved. In addition, all records with a
1303 * repository field with a *prefix* matching "backto" are saved.
1304 * The field "last_backto" is set to the last one of these. As in
1305 * 3. above, "select_hrec" adjusts to include the last one later on.
1309 char *ourdate
= date_from_time_t (hr
->date
);
1310 count
= RCS_datecmp (ourdate
, since_date
);
1315 else if (*since_rev
)
1319 struct file_info finfo
;
1321 memset (&finfo
, 0, sizeof finfo
);
1322 finfo
.file
= hr
->file
;
1323 /* Not used, so don't worry about it. */
1324 finfo
.update_dir
= NULL
;
1325 finfo
.fullname
= finfo
.file
;
1326 finfo
.repository
= hr
->repos
;
1327 finfo
.entries
= NULL
;
1330 vers
= Version_TS (&finfo
, NULL
, since_rev
, NULL
, 1, 0);
1333 if ((t
= RCS_getrevtime (vers
->srcfile
, vers
->vn_rcs
, NULL
, 0))
1338 freevers_ts (&vers
);
1343 freevers_ts (&vers
);
1345 else if (*since_tag
)
1347 if (*(hr
->type
) == 'T')
1350 * A 'T'ag record, the "rev" field holds the tag to be set,
1351 * while the "repos" field holds "D"elete, "A"dd or a rev.
1353 if (within (since_tag
, hr
->rev
))
1355 last_since_tag
= hr
;
1361 if (!last_since_tag
)
1366 if (within (backto
, hr
->file
) || within (backto
, hr
->mod
) ||
1367 within (backto
, hr
->repos
))
1375 * Run down "user_list", match username ("" matches anything)
1376 * If "" is not there and actual username is not there, return failure.
1378 if (user_list
&& hr
->user
)
1380 for (cpp
= user_list
, count
= user_count
; count
; cpp
++, count
--)
1383 break; /* null user == accept */
1384 if (!strcmp (hr
->user
, *cpp
)) /* found listed user */
1388 return 0; /* Not this user */
1391 /* Record type checking:
1393 * 1. If Record type is not in rec_types field, skip it.
1394 * 2. If mod_list is null, keep everything. Otherwise keep only modules
1396 * 3. If neither a 'T', 'F' nor 'O' record, run through "file_list". If
1397 * file_list is null, keep everything. Otherwise, keep only files on
1398 * file_list, matched appropriately.
1400 if (!strchr (rec_types
, *(hr
->type
)))
1402 if (!strchr ("TFOE", *(hr
->type
))) /* Don't bother with "file" if "TFOE" */
1404 if (file_list
) /* If file_list is null, accept all */
1406 for (fl
= file_list
, count
= file_count
; count
; fl
++, count
--)
1408 /* 1. If file_list entry starts with '*', skip the '*' and
1409 * compare it against the repository in the hrec.
1410 * 2. If file_list entry has a '/' in it, compare it against
1411 * the concatenation of the repository and file from hrec.
1412 * 3. Else compare the file_list entry against the hrec file.
1414 char *cmpfile
= NULL
;
1416 if (*(cp
= fl
->l_file
) == '*')
1419 /* if argument to -p is a prefix of repository */
1420 if (!strncmp (cp
, hr
->repos
, strlen (cp
)))
1422 hr
->mod
= fl
->l_module
;
1428 if (strchr (cp
, '/'))
1430 cmpfile
= Xasprintf ("%s/%s", hr
->repos
, hr
->file
);
1438 /* if requested file is found within {repos}/file fields */
1439 if (within (cp
, cp2
))
1441 hr
->mod
= fl
->l_module
;
1442 if (cmpfile
!= NULL
)
1446 if (cmpfile
!= NULL
)
1451 return 0; /* String specified and no match */
1456 for (cpp
= mod_list
, count
= mod_count
; count
; cpp
++, count
--)
1458 if (hr
->mod
&& !strcmp (hr
->mod
, *cpp
)) /* found module */
1462 return 0; /* Module specified & this record is not one of them. */
1465 return 1; /* Select this record unless rejected above. */
1468 /* The "sort_order" routine (when handed to qsort) has arranged for the
1469 * hrecs files to be in the right order for the report.
1471 * Most of the "selections" are done in the select_hrec routine, but some
1472 * selections are more easily done after the qsort by "accept_hrec".
1477 struct hrec
*hr
, *lr
;
1481 int user_len
, file_len
, rev_len
, mod_len
, repos_len
;
1483 if (*since_tag
&& !last_since_tag
)
1485 (void) printf ("No tag found: %s\n", since_tag
);
1488 else if (*backto
&& !last_backto
)
1490 (void) printf ("No module, file or repository with: %s\n", backto
);
1493 else if (hrec_count
< 1)
1495 (void) printf ("No records selected.\n");
1499 user_len
= file_len
= rev_len
= mod_len
= repos_len
= 0;
1501 /* Run through lists and find maximum field widths */
1502 hr
= lr
= hrec_head
;
1504 for (count
= hrec_count
; count
--; lr
= hr
, hr
++)
1510 if (!accept_hrec (lr
, hr
))
1514 repos
= xstrdup (lr
->repos
);
1515 if ((cp
= strrchr (repos
, '/')) != NULL
)
1517 if (lr
->mod
&& !strcmp (++cp
, lr
->mod
))
1519 (void) strcpy (cp
, "*");
1522 if ((i
= strlen (lr
->user
)) > user_len
)
1524 if ((i
= strlen (lr
->file
)) > file_len
)
1526 if (ty
!= 'T' && (i
= strlen (repos
)) > repos_len
)
1528 if (ty
!= 'T' && (i
= strlen (lr
->rev
)) > rev_len
)
1530 if (lr
->mod
&& (i
= strlen (lr
->mod
)) > mod_len
)
1535 /* Walk through hrec array setting "lr" (Last Record) to each element.
1536 * "hr" points to the record following "lr" -- It is NULL in the last
1539 * There are two sections in the loop below:
1540 * 1. Based on the report type (e.g. extract, checkout, tag, etc.),
1541 * decide whether the record should be printed.
1542 * 2. Based on the record type, format and print the data.
1544 for (lr
= hrec_head
, hr
= (lr
+ 1); hrec_count
--; lr
= hr
, hr
++)
1551 if (!accept_hrec (lr
, hr
))
1557 time_t t
= lr
->date
+ tz_seconds_east_of_GMT
;
1561 tm
= localtime (&(lr
->date
));
1563 (void) printf ("%c %04d-%02d-%02d %02d:%02d %s %-*s", ty
,
1564 tm
->tm_year
+1900, tm
->tm_mon
+ 1, tm
->tm_mday
, tm
->tm_hour
,
1565 tm
->tm_min
, tz_name
, user_len
, lr
->user
);
1567 workdir
= xmalloc (strlen (lr
->dir
) + strlen (lr
->end
) + 10);
1568 (void) sprintf (workdir
, "%s%s", lr
->dir
, lr
->end
);
1569 if ((cp
= strrchr (workdir
, '/')) != NULL
)
1571 if (lr
->mod
&& !strcmp (++cp
, lr
->mod
))
1573 (void) strcpy (cp
, "*");
1576 repos
= xmalloc (strlen (lr
->repos
) + 10);
1577 (void) strcpy (repos
, lr
->repos
);
1578 if ((cp
= strrchr (repos
, '/')) != NULL
)
1580 if (lr
->mod
&& !strcmp (++cp
, lr
->mod
))
1582 (void) strcpy (cp
, "*");
1589 /* 'T'ag records: repository is a "tag type", rev is the tag */
1590 (void) printf (" %-*s [%s:%s]", mod_len
, lr
->mod
, lr
->rev
,
1593 (void) printf (" {%s}", workdir
);
1598 if (lr
->rev
&& *(lr
->rev
))
1599 (void) printf (" [%s]", lr
->rev
);
1600 (void) printf (" %-*s =%s%-*s %s", repos_len
, repos
, lr
->mod
,
1601 mod_len
+ 1 - (int) strlen (lr
->mod
),
1612 (void) printf (" %-*s %-*s %-*s =%s= %s", rev_len
, lr
->rev
,
1613 file_len
, lr
->file
, repos_len
, repos
,
1614 lr
->mod
? lr
->mod
: "", workdir
);
1617 (void) printf ("Hey! What is this junk? RecType[0x%2.2x]", ty
);
1620 (void) putchar ('\n');
1627 accept_hrec (struct hrec
*lr
, struct hrec
*hr
)
1633 if (last_since_tag
&& ty
== 'T')
1639 return 0; /* Only interested in 'O' records */
1641 /* We want to identify all the states that cause the next record
1642 * ("hr") to be different from the current one ("lr") and only
1643 * print a line at the allowed boundaries.
1646 if (!hr
|| /* The last record */
1647 strcmp (hr
->user
, lr
->user
) || /* User has changed */
1648 strcmp (hr
->mod
, lr
->mod
) ||/* Module has changed */
1649 (working
&& /* If must match "workdir" */
1650 (strcmp (hr
->dir
, lr
->dir
) || /* and the 1st parts or */
1651 strcmp (hr
->end
, lr
->end
)))) /* the 2nd parts differ */
1657 if (!last_entry
|| /* Don't want only last rec */
1658 !hr
|| /* Last entry is a "last entry" */
1659 strcmp (hr
->repos
, lr
->repos
) || /* Repository has changed */
1660 strcmp (hr
->file
, lr
->file
))/* File has changed */
1664 { /* If must match "workdir" */
1665 if (strcmp (hr
->dir
, lr
->dir
) || /* and the 1st parts or */
1666 strcmp (hr
->end
, lr
->end
)) /* the 2nd parts differ */
1670 else if (module_report
)
1672 if (!last_entry
|| /* Don't want only last rec */
1673 !hr
|| /* Last entry is a "last entry" */
1674 strcmp (hr
->mod
, lr
->mod
) ||/* Module has changed */
1675 strcmp (hr
->repos
, lr
->repos
) || /* Repository has changed */
1676 strcmp (hr
->file
, lr
->file
))/* File has changed */
1681 /* "extract" and "tag_report" always print selected records. */