Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.bin/cvs/getlog.c	Lines:	0	278	0.0 %
Date:	2017-11-13	Branches:	0	230	0.0 %


/*	$OpenBSD: getlog.c,v 1.101 2017/06/01 08:08:24 joris Exp $	*/
/*
 * Copyright (c) 2005, 2006 Xavier Santolaria <xsa@openbsd.org>
 * Copyright (c) 2006 Joris Vink <joris@openbsd.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <ctype.h>

#include "cvs.h"
#include "remote.h"

#define L_HEAD		0x01
#define L_HEAD_DESCR	0x02
#define L_NAME		0x04
#define L_NOTAGS	0x08
#define L_LOGINS	0x10
#define L_STATES	0x20

#define LDATE_LATER	0x01
#define LDATE_EARLIER	0x02
#define LDATE_SINGLE	0x04
#define LDATE_RANGE	0x08
#define LDATE_INCLUSIVE	0x10

void		 cvs_log_local(struct cvs_file *);
static void	 log_rev_print(struct rcs_delta *);
static char 	*push_date(char *dest, const char *);
static u_int	 date_select(RCSFILE *, char *);

int	 runflags = 0;
char	*logrev = NULL;
char	*logdate = NULL;
char	*slist = NULL;
char	*wlist = NULL;

struct cvs_cmd cvs_cmd_log = {
	CVS_OP_LOG, CVS_USE_WDIR, "log",
	{ "lo" },
	"Print out history information for files",
	"[-bhlNRt] [-d dates] [-r revisions] [-s states] [-w logins]",
	"bd:hlNRr:s:tw:",
	NULL,
	cvs_getlog
};

struct cvs_cmd cvs_cmd_rlog = {
	CVS_OP_RLOG, 0, "rlog",
	{ "rlo" },
	"Print out history information for files",
	"[-bhlNRt] [-d dates] [-r revisions] [-s states] [-w logins]",
	"bd:hlNRr:s:tw:",
	NULL,
	cvs_getlog
};

int
cvs_getlog(int argc, char **argv)
{
	int ch, flags, i;
	char *arg = ".";
	struct cvs_recursion cr;

	flags = CR_RECURSE_DIRS;

	while ((ch = getopt(argc, argv, cvs_cmdop == CVS_OP_LOG ?
	    cvs_cmd_log.cmd_opts : cvs_cmd_rlog.cmd_opts)) != -1) {
		switch (ch) {
		case 'd':
			logdate = push_date(logdate, optarg);
			break;
		case 'h':
			runflags |= L_HEAD;
			break;
		case 'l':
			flags &= ~CR_RECURSE_DIRS;
			break;
		case 'N':
			runflags |= L_NOTAGS;
			break;
		case 'R':
			runflags |= L_NAME;
			break;
		case 'r':
			logrev = optarg;
			break;
		case 's':
			runflags |= L_STATES;
			slist = optarg;
			break;
		case 't':
			runflags |= L_HEAD_DESCR;
			break;
		case 'w':
			runflags |= L_LOGINS;
			wlist = optarg;
			break;
		default:
			fatal("%s", cvs_cmdop == CVS_OP_LOG ?
			    cvs_cmd_log.cmd_synopsis :
			    cvs_cmd_rlog.cmd_synopsis);
		}
	}

	argc -= optind;
	argv += optind;

	if (cvs_cmdop == CVS_OP_RLOG) {
		flags |= CR_REPO;

		if (argc == 0)
			return 0;

		for (i = 0; i < argc; i++)
			if (argv[i][0] == '/')
				fatal("Absolute path name is invalid: %s",
				    argv[i]);
	}

	cr.enterdir = NULL;
	cr.leavedir = NULL;

	if (cvsroot_is_remote()) {
		cvs_client_connect_to_server();
		cr.fileproc = cvs_client_sendfile;

		if (logdate != NULL)
			cvs_client_send_request("Argument -d%s", logdate);

		if (runflags & L_HEAD)
			cvs_client_send_request("Argument -h");

		if (!(flags & CR_RECURSE_DIRS))
			cvs_client_send_request("Argument -l");

		if (runflags & L_NOTAGS)
			cvs_client_send_request("Argument -N");

		if (runflags & L_NAME)
			cvs_client_send_request("Argument -R");

		if (logrev != NULL)
			cvs_client_send_request("Argument -r%s", logrev);

		if (runflags & L_STATES)
			cvs_client_send_request("Argument -s%s", slist);

		if (runflags & L_HEAD_DESCR)
			cvs_client_send_request("Argument -t");

		if (runflags & L_LOGINS)
			cvs_client_send_request("Argument -w%s", wlist);
	} else {
		if (cvs_cmdop == CVS_OP_RLOG &&
		    chdir(current_cvsroot->cr_dir) == -1)
			fatal("cvs_getlog: %s", strerror(errno));

		cr.fileproc = cvs_log_local;
	}

	cr.flags = flags;

	if (cvs_cmdop == CVS_OP_LOG || cvsroot_is_local()) {
		if (argc > 0)
			cvs_file_run(argc, argv, &cr);
		else
			cvs_file_run(1, &arg, &cr);
	}

	if (cvsroot_is_remote()) {
		cvs_client_send_files(argv, argc);
		cvs_client_senddir(".");

		cvs_client_send_request((cvs_cmdop == CVS_OP_RLOG) ?
		    "rlog" : "log");

		cvs_client_get_responses();
	}

	return (0);
}

void
cvs_log_local(struct cvs_file *cf)
{
	u_int nrev;
	RCSNUM *rev;
	struct rcs_sym *sym;
	struct rcs_lock *lkp;
	struct rcs_delta *rdp;
	struct rcs_access *acp;
	char numb[CVS_REV_BUFSZ];

	cvs_log(LP_TRACE, "cvs_log_local(%s)", cf->file_path);

	cvs_file_classify(cf, cvs_directory_tag);

	if (cf->file_type == CVS_DIR) {
		if (verbosity > 1)
			cvs_log(LP_ERR, "Logging %s", cf->file_path);
		return;
	}

	if (cf->file_rcs == NULL) {
		return;
	} else if (cf->file_status == FILE_ADDED) {
		if (verbosity > 0)
			cvs_log(LP_ERR, "%s has been added, but not committed",
			    cf->file_path);
		return;
	}

	if (runflags & L_NAME) {
		cvs_printf("%s\n", cf->file_rpath);
		return;
	}

	if (logrev != NULL)
		nrev = cvs_revision_select(cf->file_rcs, logrev);
	else if (logdate != NULL) {
		if ((nrev = date_select(cf->file_rcs, logdate)) == (u_int)-1) {
			cvs_log(LP_ERR, "invalid date: %s", logdate);
			return;
		}
	} else
		nrev = cf->file_rcs->rf_ndelta;

	cvs_printf("\nRCS file: %s", cf->file_rpath);

	if (cvs_cmdop != CVS_OP_RLOG)
		cvs_printf("\nWorking file: %s", cf->file_path);

	cvs_printf("\nhead:");
	if (cf->file_rcs->rf_head != NULL)
		cvs_printf(" %s", rcsnum_tostr(cf->file_rcs->rf_head,
		    numb, sizeof(numb)));

	cvs_printf("\nbranch:");
	if (rcs_branch_get(cf->file_rcs) != NULL) {
		cvs_printf(" %s", rcsnum_tostr(rcs_branch_get(cf->file_rcs),
		    numb, sizeof(numb)));
	}

	cvs_printf("\nlocks: %s", (cf->file_rcs->rf_flags & RCS_SLOCK)
	    ? "strict" : "");
	TAILQ_FOREACH(lkp, &(cf->file_rcs->rf_locks), rl_list)
		cvs_printf("\n\t%s: %s", lkp->rl_name,
		    rcsnum_tostr(lkp->rl_num, numb, sizeof(numb)));

	cvs_printf("\naccess list:\n");
	TAILQ_FOREACH(acp, &(cf->file_rcs->rf_access), ra_list)
		cvs_printf("\t%s\n", acp->ra_name);

	if (!(runflags & L_NOTAGS)) {
		cvs_printf("symbolic names:\n");
		TAILQ_FOREACH(sym, &(cf->file_rcs->rf_symbols), rs_list) {
			rev = rcsnum_alloc();
			rcsnum_cpy(sym->rs_num, rev, 0);
			if (RCSNUM_ISBRANCH(sym->rs_num))
				rcsnum_addmagic(rev);

			cvs_printf("\t%s: %s\n", sym->rs_name,
			    rcsnum_tostr(rev, numb, sizeof(numb)));
			free(rev);
		}
	}

	cvs_printf("keyword substitution: %s\n",
	    cf->file_rcs->rf_expand == NULL ? "kv" : cf->file_rcs->rf_expand);

	cvs_printf("total revisions: %u", cf->file_rcs->rf_ndelta);

	if (cf->file_rcs->rf_head != NULL &&
	    !(runflags & L_HEAD) && !(runflags & L_HEAD_DESCR))
		cvs_printf(";\tselected revisions: %u", nrev);

	cvs_printf("\n");

	if (!(runflags & L_HEAD) || (runflags & L_HEAD_DESCR))
		cvs_printf("description:\n%s", cf->file_rcs->rf_desc);

	if (!(runflags & L_HEAD) && !(runflags & L_HEAD_DESCR)) {
		TAILQ_FOREACH(rdp, &(cf->file_rcs->rf_delta), rd_list) {
			/*
			 * if selections are enabled verify that entry is
			 * selected.
			 */
			if ((logrev == NULL && logdate == NULL) ||
			    (rdp->rd_flags & RCS_RD_SELECT))
				log_rev_print(rdp);
		}
	}

	cvs_printf("%s\n", LOG_REVEND);
}

static void
log_rev_print(struct rcs_delta *rdp)
{
	int i, found;
	char numb[CVS_REV_BUFSZ], timeb[CVS_TIME_BUFSZ];
	struct cvs_argvector *sargv, *wargv;
	struct rcs_branch *rb;
	struct rcs_delta *nrdp;

	i = found = 0;

	/* -s states */
	if (runflags & L_STATES) {
		sargv = cvs_strsplit(slist, ",");
		for (i = 0; sargv->argv[i] != NULL; i++) {
			if (strcmp(rdp->rd_state, sargv->argv[i]) == 0) {
				found++;
				break;
			}
			found = 0;
		}
		cvs_argv_destroy(sargv);
	}

	/* -w[logins] */
	if (runflags & L_LOGINS) {
		wargv = cvs_strsplit(wlist, ",");
		for (i = 0; wargv->argv[i] != NULL; i++) {
			if (strcmp(rdp->rd_author, wargv->argv[i]) == 0) {
				found++;
				break;
			}
			found = 0;
		}
		cvs_argv_destroy(wargv);
	}

	if ((runflags & (L_STATES|L_LOGINS)) && found == 0)
		return;

	cvs_printf("%s\n", LOG_REVSEP);

	rcsnum_tostr(rdp->rd_num, numb, sizeof(numb));
	cvs_printf("revision %s", numb);

	strftime(timeb, sizeof(timeb), "%Y/%m/%d %H:%M:%S", &rdp->rd_date);
	cvs_printf("\ndate: %s;  author: %s;  state: %s;",
	    timeb, rdp->rd_author, rdp->rd_state);

	/*
	 * If we are a branch revision, the diff of this revision is stored
	 * in place.
	 * Otherwise, it is stored in the previous revision as a reversed diff.
	 */
	if (RCSNUM_ISBRANCHREV(rdp->rd_num))
		nrdp = rdp;
	else
		nrdp = TAILQ_NEXT(rdp, rd_list);

	/*
	 * We do not write diff stats for the first revision of the default
	 * branch, since it was not a diff but a full text.
	 */
	if (nrdp != NULL && rdp->rd_num->rn_len == nrdp->rd_num->rn_len) {
		int added, removed;
		rcs_delta_stats(nrdp, &added, &removed);
		if (RCSNUM_ISBRANCHREV(rdp->rd_num))
			cvs_printf("  lines: +%d -%d;", added, removed);
		else
			cvs_printf("  lines: +%d -%d;", removed, added);
	}

	if (rdp->rd_commitid != NULL)
		printf("  commitid: %s;", rdp->rd_commitid);

	cvs_printf("\n");

	if (!TAILQ_EMPTY(&(rdp->rd_branches))) {
		cvs_printf("branches:");
		TAILQ_FOREACH(rb, &(rdp->rd_branches), rb_list) {
			RCSNUM *branch;
			branch = rcsnum_revtobr(rb->rb_num);
			rcsnum_tostr(branch, numb, sizeof(numb));
			cvs_printf("  %s;", numb);
			free(branch);
		}
		cvs_printf("\n");
	}

	cvs_printf("%s", rdp->rd_log);
}

static char *
push_date(char *dest, const char *src)
{
	size_t len;

	if (dest == NULL)
		return (xstrdup(src));

	/* 2 = ; and '\0' */
	len = strlen(dest) + strlen(src) + 2;

	dest[strlen(dest)] = ';';
	dest = xreallocarray(dest, len, 1);
	strlcat(dest, src, len);
	return (dest);
}

static u_int
date_select(RCSFILE *file, char *date)
{
	int i, nrev, flags;
	struct rcs_delta *rdp;
	struct cvs_argvector *args;
	char *first, *last, delim;
	time_t firstdate, lastdate, rcsdate;

	nrev = 0;
	args = cvs_strsplit(date, ";");

	for (i = 0; args->argv[i] != NULL; i++) {
		flags = 0;
		firstdate = lastdate = -1;

		first = args->argv[i];
		last = strchr(args->argv[i], '<');
		if (last != NULL) {
			delim = *last;
			*last++ = '\0';

			if (*last == '=') {
				last++;
				flags |= LDATE_INCLUSIVE;
			}
		} else {
			last = strchr(args->argv[i], '>');
			if (last != NULL) {
				delim = *last;
				*last++ = '\0';

				if (*last == '=') {
					last++;
					flags |= LDATE_INCLUSIVE;
				}
			}
		}

		if (last == NULL) {
			flags |= LDATE_SINGLE;
			if ((firstdate = date_parse(first)) == -1)
				return -1;
			delim = '\0';
			last = "\0";
		} else {
			while (*last && isspace((unsigned char)*last))
				last++;
		}

		if (delim == '>' && *last == '\0') {
			flags |= LDATE_EARLIER;
			if ((firstdate = date_parse(first)) == -1)
				return -1;
		}

		if (delim == '>' && *first == '\0' && *last != '\0') {
			flags |= LDATE_LATER;
			if ((firstdate = date_parse(last)) == -1)
				return -1;
		}

		if (delim == '<' && *last == '\0') {
			flags |= LDATE_LATER;
			if ((firstdate = date_parse(first)) == -1)
				return -1;
		}

		if (delim == '<' && *first == '\0' && *last != '\0') {
			flags |= LDATE_EARLIER;
			if ((firstdate = date_parse(last)) == -1)
				return -1;
		}

		if (*first != '\0' && *last != '\0') {
			flags |= LDATE_RANGE;

			if (delim == '<') {
				firstdate = date_parse(first);
				lastdate = date_parse(last);
			} else {
				firstdate = date_parse(last);
				lastdate = date_parse(first);
			}
			if (firstdate == -1 || lastdate == -1)
				return -1;
		}

		TAILQ_FOREACH(rdp, &(file->rf_delta), rd_list) {
			rcsdate = mktime(&(rdp->rd_date));

			if (flags & LDATE_SINGLE) {
				if (rcsdate <= firstdate) {
					rdp->rd_flags |= RCS_RD_SELECT;
					nrev++;
					break;
				}
			}

			if (flags & LDATE_EARLIER) {
				if (rcsdate < firstdate) {
					rdp->rd_flags |= RCS_RD_SELECT;
					nrev++;
					continue;
				}

				if (flags & LDATE_INCLUSIVE &&
				    (rcsdate <= firstdate)) {
					rdp->rd_flags |= RCS_RD_SELECT;
					nrev++;
					continue;
				}
			}

			if (flags & LDATE_LATER) {
				if (rcsdate > firstdate) {
					rdp->rd_flags |= RCS_RD_SELECT;
					nrev++;
					continue;
				}

				if (flags & LDATE_INCLUSIVE &&
				    (rcsdate >= firstdate)) {
					rdp->rd_flags |= RCS_RD_SELECT;
					nrev++;
					continue;
				}
			}

			if (flags & LDATE_RANGE) {
				if ((rcsdate > firstdate) &&
				    (rcsdate < lastdate)) {
					rdp->rd_flags |= RCS_RD_SELECT;
					nrev++;
					continue;
				}

				if (flags & LDATE_INCLUSIVE &&
				    ((rcsdate >= firstdate) &&
				    (rcsdate <= lastdate))) {
					rdp->rd_flags |= RCS_RD_SELECT;
					nrev++;
					continue;
				}
			}
		}
	}

	cvs_argv_destroy(args);

	return (nrev);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: getlog.c,v 1.101 2017/06/01 08:08:24 joris Exp $ */
2			/*
3			* Copyright (c) 2005, 2006 Xavier Santolaria <xsa@openbsd.org>
4			* Copyright (c) 2006 Joris Vink <joris@openbsd.org>
5			*
6			* Permission to use, copy, modify, and distribute this software for any
7			* purpose with or without fee is hereby granted, provided that the above
8			* copyright notice and this permission notice appear in all copies.
9			*
10			* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11			* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12			* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13			* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14			* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15			* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16			* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17			*/
18
19			#include <unistd.h>
20			#include <stdlib.h>
21			#include <string.h>
22			#include <errno.h>
23			#include <ctype.h>
24
25			#include "cvs.h"
26			#include "remote.h"
27
28			#define L_HEAD 0x01
29			#define L_HEAD_DESCR 0x02
30			#define L_NAME 0x04
31			#define L_NOTAGS 0x08
32			#define L_LOGINS 0x10
33			#define L_STATES 0x20
34
35			#define LDATE_LATER 0x01
36			#define LDATE_EARLIER 0x02
37			#define LDATE_SINGLE 0x04
38			#define LDATE_RANGE 0x08
39			#define LDATE_INCLUSIVE 0x10
40
41			void cvs_log_local(struct cvs_file *);
42			static void log_rev_print(struct rcs_delta *);
43			static char push_date(char dest, const char *);
44			static u_int date_select(RCSFILE , char );
45
46			int runflags = 0;
47			char *logrev = NULL;
48			char *logdate = NULL;
49			char *slist = NULL;
50			char *wlist = NULL;
51
52			struct cvs_cmd cvs_cmd_log = {
53			CVS_OP_LOG, CVS_USE_WDIR, "log",
54			{ "lo" },
55			"Print out history information for files",
56			"[-bhlNRt] [-d dates] [-r revisions] [-s states] [-w logins]",
57			"bd:hlNRr:s:tw:",
58			NULL,
59			cvs_getlog
60			};
61
62			struct cvs_cmd cvs_cmd_rlog = {
63			CVS_OP_RLOG, 0, "rlog",
64			{ "rlo" },
65			"Print out history information for files",
66			"[-bhlNRt] [-d dates] [-r revisions] [-s states] [-w logins]",
67			"bd:hlNRr:s:tw:",
68			NULL,
69			cvs_getlog
70			};
71
72			int
73			cvs_getlog(int argc, char **argv)
74			{
75			int ch, flags, i;
76			char *arg = ".";
77			struct cvs_recursion cr;
78
79			flags = CR_RECURSE_DIRS;
80
81			while ((ch = getopt(argc, argv, cvs_cmdop == CVS_OP_LOG ?
82			cvs_cmd_log.cmd_opts : cvs_cmd_rlog.cmd_opts)) != -1) {
83			switch (ch) {
84			case 'd':
85			logdate = push_date(logdate, optarg);
86			break;
87			case 'h':
88			runflags \|= L_HEAD;
89			break;
90			case 'l':
91			flags &= ~CR_RECURSE_DIRS;
92			break;
93			case 'N':
94			runflags \|= L_NOTAGS;
95			break;
96			case 'R':
97			runflags \|= L_NAME;
98			break;
99			case 'r':
100			logrev = optarg;
101			break;
102			case 's':
103			runflags \|= L_STATES;
104			slist = optarg;
105			break;
106			case 't':
107			runflags \|= L_HEAD_DESCR;
108			break;
109			case 'w':
110			runflags \|= L_LOGINS;
111			wlist = optarg;
112			break;
113			default:
114			fatal("%s", cvs_cmdop == CVS_OP_LOG ?
115			cvs_cmd_log.cmd_synopsis :
116			cvs_cmd_rlog.cmd_synopsis);
117			}
118			}
119
120			argc -= optind;
121			argv += optind;
122
123			if (cvs_cmdop == CVS_OP_RLOG) {
124			flags \|= CR_REPO;
125
126			if (argc == 0)
127			return 0;
128
129			for (i = 0; i < argc; i++)
130			if (argv[i][0] == '/')
131			fatal("Absolute path name is invalid: %s",
132			argv[i]);
133			}
134
135			cr.enterdir = NULL;
136			cr.leavedir = NULL;
137
138			if (cvsroot_is_remote()) {
139			cvs_client_connect_to_server();
140			cr.fileproc = cvs_client_sendfile;
141
142			if (logdate != NULL)
143			cvs_client_send_request("Argument -d%s", logdate);
144
145			if (runflags & L_HEAD)
146			cvs_client_send_request("Argument -h");
147
148			if (!(flags & CR_RECURSE_DIRS))
149			cvs_client_send_request("Argument -l");
150
151			if (runflags & L_NOTAGS)
152			cvs_client_send_request("Argument -N");
153
154			if (runflags & L_NAME)
155			cvs_client_send_request("Argument -R");
156
157			if (logrev != NULL)
158			cvs_client_send_request("Argument -r%s", logrev);
159
160			if (runflags & L_STATES)
161			cvs_client_send_request("Argument -s%s", slist);
162
163			if (runflags & L_HEAD_DESCR)
164			cvs_client_send_request("Argument -t");
165
166			if (runflags & L_LOGINS)
167			cvs_client_send_request("Argument -w%s", wlist);
168			} else {
169			if (cvs_cmdop == CVS_OP_RLOG &&
170			chdir(current_cvsroot->cr_dir) == -1)
171			fatal("cvs_getlog: %s", strerror(errno));
172
173			cr.fileproc = cvs_log_local;
174			}
175
176			cr.flags = flags;
177
178			if (cvs_cmdop == CVS_OP_LOG \|\| cvsroot_is_local()) {
179			if (argc > 0)
180			cvs_file_run(argc, argv, &cr);
181			else
182			cvs_file_run(1, &arg, &cr);
183			}
184
185			if (cvsroot_is_remote()) {
186			cvs_client_send_files(argv, argc);
187			cvs_client_senddir(".");
188
189			cvs_client_send_request((cvs_cmdop == CVS_OP_RLOG) ?
190			"rlog" : "log");
191
192			cvs_client_get_responses();
193			}
194
195			return (0);
196			}
197
198			void
199			cvs_log_local(struct cvs_file *cf)
200			{
201			u_int nrev;
202			RCSNUM *rev;
203			struct rcs_sym *sym;
204			struct rcs_lock *lkp;
205			struct rcs_delta *rdp;
206			struct rcs_access *acp;
207			char numb[CVS_REV_BUFSZ];
208
209			cvs_log(LP_TRACE, "cvs_log_local(%s)", cf->file_path);
210
211			cvs_file_classify(cf, cvs_directory_tag);
212
213			if (cf->file_type == CVS_DIR) {
214			if (verbosity > 1)
215			cvs_log(LP_ERR, "Logging %s", cf->file_path);
216			return;
217			}
218
219			if (cf->file_rcs == NULL) {
220			return;
221			} else if (cf->file_status == FILE_ADDED) {
222			if (verbosity > 0)
223			cvs_log(LP_ERR, "%s has been added, but not committed",
224			cf->file_path);
225			return;
226			}
227
228			if (runflags & L_NAME) {
229			cvs_printf("%s\n", cf->file_rpath);
230			return;
231			}
232
233			if (logrev != NULL)
234			nrev = cvs_revision_select(cf->file_rcs, logrev);
235			else if (logdate != NULL) {
236			if ((nrev = date_select(cf->file_rcs, logdate)) == (u_int)-1) {
237			cvs_log(LP_ERR, "invalid date: %s", logdate);
238			return;
239			}
240			} else
241			nrev = cf->file_rcs->rf_ndelta;
242
243			cvs_printf("\nRCS file: %s", cf->file_rpath);
244
245			if (cvs_cmdop != CVS_OP_RLOG)
246			cvs_printf("\nWorking file: %s", cf->file_path);
247
248			cvs_printf("\nhead:");
249			if (cf->file_rcs->rf_head != NULL)
250			cvs_printf(" %s", rcsnum_tostr(cf->file_rcs->rf_head,
251			numb, sizeof(numb)));
252
253			cvs_printf("\nbranch:");
254			if (rcs_branch_get(cf->file_rcs) != NULL) {
255			cvs_printf(" %s", rcsnum_tostr(rcs_branch_get(cf->file_rcs),
256			numb, sizeof(numb)));
257			}
258
259			cvs_printf("\nlocks: %s", (cf->file_rcs->rf_flags & RCS_SLOCK)
260			? "strict" : "");
261			TAILQ_FOREACH(lkp, &(cf->file_rcs->rf_locks), rl_list)
262			cvs_printf("\n\t%s: %s", lkp->rl_name,
263			rcsnum_tostr(lkp->rl_num, numb, sizeof(numb)));
264
265			cvs_printf("\naccess list:\n");
266			TAILQ_FOREACH(acp, &(cf->file_rcs->rf_access), ra_list)
267			cvs_printf("\t%s\n", acp->ra_name);
268
269			if (!(runflags & L_NOTAGS)) {
270			cvs_printf("symbolic names:\n");
271			TAILQ_FOREACH(sym, &(cf->file_rcs->rf_symbols), rs_list) {
272			rev = rcsnum_alloc();
273			rcsnum_cpy(sym->rs_num, rev, 0);
274			if (RCSNUM_ISBRANCH(sym->rs_num))
275			rcsnum_addmagic(rev);
276
277			cvs_printf("\t%s: %s\n", sym->rs_name,
278			rcsnum_tostr(rev, numb, sizeof(numb)));
279			free(rev);
280			}
281			}
282
283			cvs_printf("keyword substitution: %s\n",
284			cf->file_rcs->rf_expand == NULL ? "kv" : cf->file_rcs->rf_expand);
285
286			cvs_printf("total revisions: %u", cf->file_rcs->rf_ndelta);
287
288			if (cf->file_rcs->rf_head != NULL &&
289			!(runflags & L_HEAD) && !(runflags & L_HEAD_DESCR))
290			cvs_printf(";\tselected revisions: %u", nrev);
291
292			cvs_printf("\n");
293
294			if (!(runflags & L_HEAD) \|\| (runflags & L_HEAD_DESCR))
295			cvs_printf("description:\n%s", cf->file_rcs->rf_desc);
296
297			if (!(runflags & L_HEAD) && !(runflags & L_HEAD_DESCR)) {
298			TAILQ_FOREACH(rdp, &(cf->file_rcs->rf_delta), rd_list) {
299			/*
300			* if selections are enabled verify that entry is
301			* selected.
302			*/
303			if ((logrev == NULL && logdate == NULL) \|\|
304			(rdp->rd_flags & RCS_RD_SELECT))
305			log_rev_print(rdp);
306			}
307			}
308
309			cvs_printf("%s\n", LOG_REVEND);
310			}
311
312			static void
313			log_rev_print(struct rcs_delta *rdp)
314			{
315			int i, found;
316			char numb[CVS_REV_BUFSZ], timeb[CVS_TIME_BUFSZ];
317			struct cvs_argvector sargv, wargv;
318			struct rcs_branch *rb;
319			struct rcs_delta *nrdp;
320
321			i = found = 0;
322
323			/* -s states */
324			if (runflags & L_STATES) {
325			sargv = cvs_strsplit(slist, ",");
326			for (i = 0; sargv->argv[i] != NULL; i++) {
327			if (strcmp(rdp->rd_state, sargv->argv[i]) == 0) {
328			found++;
329			break;
330			}
331			found = 0;
332			}
333			cvs_argv_destroy(sargv);
334			}
335
336			/* -w[logins] */
337			if (runflags & L_LOGINS) {
338			wargv = cvs_strsplit(wlist, ",");
339			for (i = 0; wargv->argv[i] != NULL; i++) {
340			if (strcmp(rdp->rd_author, wargv->argv[i]) == 0) {
341			found++;
342			break;
343			}
344			found = 0;
345			}
346			cvs_argv_destroy(wargv);
347			}
348
349			if ((runflags & (L_STATES\|L_LOGINS)) && found == 0)
350			return;
351
352			cvs_printf("%s\n", LOG_REVSEP);
353
354			rcsnum_tostr(rdp->rd_num, numb, sizeof(numb));
355			cvs_printf("revision %s", numb);
356
357			strftime(timeb, sizeof(timeb), "%Y/%m/%d %H:%M:%S", &rdp->rd_date);
358			cvs_printf("\ndate: %s; author: %s; state: %s;",
359			timeb, rdp->rd_author, rdp->rd_state);
360
361			/*
362			* If we are a branch revision, the diff of this revision is stored
363			* in place.
364			* Otherwise, it is stored in the previous revision as a reversed diff.
365			*/
366			if (RCSNUM_ISBRANCHREV(rdp->rd_num))
367			nrdp = rdp;
368			else
369			nrdp = TAILQ_NEXT(rdp, rd_list);
370
371			/*
372			* We do not write diff stats for the first revision of the default
373			* branch, since it was not a diff but a full text.
374			*/
375			if (nrdp != NULL && rdp->rd_num->rn_len == nrdp->rd_num->rn_len) {
376			int added, removed;
377			rcs_delta_stats(nrdp, &added, &removed);
378			if (RCSNUM_ISBRANCHREV(rdp->rd_num))
379			cvs_printf(" lines: +%d -%d;", added, removed);
380			else
381			cvs_printf(" lines: +%d -%d;", removed, added);
382			}
383
384			if (rdp->rd_commitid != NULL)
385			printf(" commitid: %s;", rdp->rd_commitid);
386
387			cvs_printf("\n");
388
389			if (!TAILQ_EMPTY(&(rdp->rd_branches))) {
390			cvs_printf("branches:");
391			TAILQ_FOREACH(rb, &(rdp->rd_branches), rb_list) {
392			RCSNUM *branch;
393			branch = rcsnum_revtobr(rb->rb_num);
394			rcsnum_tostr(branch, numb, sizeof(numb));
395			cvs_printf(" %s;", numb);
396			free(branch);
397			}
398			cvs_printf("\n");
399			}
400
401			cvs_printf("%s", rdp->rd_log);
402			}
403
404			static char *
405			push_date(char dest, const char src)
406			{
407			size_t len;
408
409			if (dest == NULL)
410			return (xstrdup(src));
411
412			/* 2 = ; and '\0' */
413			len = strlen(dest) + strlen(src) + 2;
414
415			dest[strlen(dest)] = ';';
416			dest = xreallocarray(dest, len, 1);
417			strlcat(dest, src, len);
418			return (dest);
419			}
420
421			static u_int
422			date_select(RCSFILE file, char date)
423			{
424			int i, nrev, flags;
425			struct rcs_delta *rdp;
426			struct cvs_argvector *args;
427			char first, last, delim;
428			time_t firstdate, lastdate, rcsdate;
429
430			nrev = 0;
431			args = cvs_strsplit(date, ";");
432
433			for (i = 0; args->argv[i] != NULL; i++) {
434			flags = 0;
435			firstdate = lastdate = -1;
436
437			first = args->argv[i];
438			last = strchr(args->argv[i], '<');
439			if (last != NULL) {
440			delim = *last;
441			*last++ = '\0';
442
443			if (*last == '=') {
444			last++;
445			flags \|= LDATE_INCLUSIVE;
446			}
447			} else {
448			last = strchr(args->argv[i], '>');
449			if (last != NULL) {
450			delim = *last;
451			*last++ = '\0';
452
453			if (*last == '=') {
454			last++;
455			flags \|= LDATE_INCLUSIVE;
456			}
457			}
458			}
459
460			if (last == NULL) {
461			flags \|= LDATE_SINGLE;
462			if ((firstdate = date_parse(first)) == -1)
463			return -1;
464			delim = '\0';
465			last = "\0";
466			} else {
467			while (last && isspace((unsigned char)last))
468			last++;
469			}
470
471			if (delim == '>' && *last == '\0') {
472			flags \|= LDATE_EARLIER;
473			if ((firstdate = date_parse(first)) == -1)
474			return -1;
475			}
476
477			if (delim == '>' && first == '\0' && last != '\0') {
478			flags \|= LDATE_LATER;
479			if ((firstdate = date_parse(last)) == -1)
480			return -1;
481			}
482
483			if (delim == '<' && *last == '\0') {
484			flags \|= LDATE_LATER;
485			if ((firstdate = date_parse(first)) == -1)
486			return -1;
487			}
488
489			if (delim == '<' && first == '\0' && last != '\0') {
490			flags \|= LDATE_EARLIER;
491			if ((firstdate = date_parse(last)) == -1)
492			return -1;
493			}
494
495			if (first != '\0' && last != '\0') {
496			flags \|= LDATE_RANGE;
497
498			if (delim == '<') {
499			firstdate = date_parse(first);
500			lastdate = date_parse(last);
501			} else {
502			firstdate = date_parse(last);
503			lastdate = date_parse(first);
504			}
505			if (firstdate == -1 \|\| lastdate == -1)
506			return -1;
507			}
508
509			TAILQ_FOREACH(rdp, &(file->rf_delta), rd_list) {
510			rcsdate = mktime(&(rdp->rd_date));
511
512			if (flags & LDATE_SINGLE) {
513			if (rcsdate <= firstdate) {
514			rdp->rd_flags \|= RCS_RD_SELECT;
515			nrev++;
516			break;
517			}
518			}
519
520			if (flags & LDATE_EARLIER) {
521			if (rcsdate < firstdate) {
522			rdp->rd_flags \|= RCS_RD_SELECT;
523			nrev++;
524			continue;
525			}
526
527			if (flags & LDATE_INCLUSIVE &&
528			(rcsdate <= firstdate)) {
529			rdp->rd_flags \|= RCS_RD_SELECT;
530			nrev++;
531			continue;
532			}
533			}
534
535			if (flags & LDATE_LATER) {
536			if (rcsdate > firstdate) {
537			rdp->rd_flags \|= RCS_RD_SELECT;
538			nrev++;
539			continue;
540			}
541
542			if (flags & LDATE_INCLUSIVE &&
543			(rcsdate >= firstdate)) {
544			rdp->rd_flags \|= RCS_RD_SELECT;
545			nrev++;
546			continue;
547			}
548			}
549
550			if (flags & LDATE_RANGE) {
551			if ((rcsdate > firstdate) &&
552			(rcsdate < lastdate)) {
553			rdp->rd_flags \|= RCS_RD_SELECT;
554			nrev++;
555			continue;
556			}
557
558			if (flags & LDATE_INCLUSIVE &&
559			((rcsdate >= firstdate) &&
560			(rcsdate <= lastdate))) {
561			rdp->rd_flags \|= RCS_RD_SELECT;
562			nrev++;
563			continue;
564			}
565			}
566			}
567			}
568
569			cvs_argv_destroy(args);
570
571			return (nrev);
572			}