xref: /openbsd-src/usr.bin/rcs/rcsdiff.c (revision 3aaa63eb46949490a39db9c6d82aacc8ee5d8551)
1*3aaa63ebSderaadt /*	$OpenBSD: rcsdiff.c,v 1.85 2019/06/28 13:35:03 deraadt Exp $	*/
297449b47Sjoris /*
397449b47Sjoris  * Copyright (c) 2005 Joris Vink <joris@openbsd.org>
497449b47Sjoris  * All rights reserved.
597449b47Sjoris  *
697449b47Sjoris  * Redistribution and use in source and binary forms, with or without
797449b47Sjoris  * modification, are permitted provided that the following conditions
897449b47Sjoris  * are met:
997449b47Sjoris  *
1097449b47Sjoris  * 1. Redistributions of source code must retain the above copyright
1197449b47Sjoris  *    notice, this list of conditions and the following disclaimer.
1297449b47Sjoris  * 2. The name of the author may not be used to endorse or promote products
1397449b47Sjoris  *    derived from this software without specific prior written permission.
1497449b47Sjoris  *
1597449b47Sjoris  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
1697449b47Sjoris  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
1797449b47Sjoris  * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
1897449b47Sjoris  * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
1997449b47Sjoris  * EXEMPLARY, OR CONSEQUENTIAL  DAMAGES (INCLUDING, BUT NOT LIMITED TO,
2097449b47Sjoris  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
2197449b47Sjoris  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
2297449b47Sjoris  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
2397449b47Sjoris  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
2497449b47Sjoris  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
2597449b47Sjoris  */
2697449b47Sjoris 
274781e2faSxsa #include <sys/stat.h>
2880821091Schl #include <sys/time.h>
294781e2faSxsa 
304781e2faSxsa #include <err.h>
314781e2faSxsa #include <fcntl.h>
324781e2faSxsa #include <stdio.h>
334781e2faSxsa #include <stdlib.h>
344781e2faSxsa #include <string.h>
354781e2faSxsa #include <unistd.h>
3697449b47Sjoris 
3797449b47Sjoris #include "rcsprog.h"
38cd8dad74Sxsa #include "diff.h"
3997449b47Sjoris 
40f5f501bbSmillert static int rcsdiff_file(RCSFILE *, RCSNUM *, const char *, int);
41f5f501bbSmillert static int rcsdiff_rev(RCSFILE *, RCSNUM *, RCSNUM *, int);
42f5f501bbSmillert static void push_ignore_pats(char *);
4397449b47Sjoris 
44f5f501bbSmillert static int quiet;
45dd5fbfceSxsa static int kflag = RCS_KWEXP_ERR;
46f5f501bbSmillert static char *diff_ignore_pats;
47dd5fbfceSxsa 
4897449b47Sjoris int
rcsdiff_main(int argc,char ** argv)4997449b47Sjoris rcsdiff_main(int argc, char **argv)
5097449b47Sjoris {
51f5f501bbSmillert 	int fd, i, ch, dflags, status;
5236076781Sray 	RCSNUM *rev1, *rev2;
5397449b47Sjoris 	RCSFILE *file;
54b9fc9a72Sderaadt 	char fpath[PATH_MAX], *rev_str1, *rev_str2;
55f5f501bbSmillert 	const char *errstr;
5697449b47Sjoris 
5736076781Sray 	rev1 = rev2 = NULL;
5836076781Sray 	rev_str1 = rev_str2 = NULL;
591fb625bfSxsa 	status = D_SAME;
60f5f501bbSmillert 	dflags = 0;
6197449b47Sjoris 
626b99bb86Sray 	if (strlcpy(diffargs, "diff", sizeof(diffargs)) >= sizeof(diffargs))
631c5ed35bSxsa 		errx(D_ERROR, "diffargs too long");
64c60b216dSxsa 
65f5f501bbSmillert 	while ((ch = rcs_getopt(argc, argv, "abC:cdI:ik:npqr:TtU:uVwx::z::")) != -1) {
6697449b47Sjoris 		switch (ch) {
67f5f501bbSmillert 		case 'a':
68f5f501bbSmillert 			if (strlcat(diffargs, " -a", sizeof(diffargs)) >=
69f5f501bbSmillert 			    sizeof(diffargs))
70f5f501bbSmillert 				errx(D_ERROR, "diffargs too long");
71f5f501bbSmillert 			dflags |= D_FORCEASCII;
72f5f501bbSmillert 			break;
73f5f501bbSmillert 		case 'b':
74f5f501bbSmillert 			if (strlcat(diffargs, " -b", sizeof(diffargs)) >=
75f5f501bbSmillert 			    sizeof(diffargs))
76f5f501bbSmillert 				errx(D_ERROR, "diffargs too long");
77f5f501bbSmillert 			dflags |= D_FOLDBLANKS;
78f5f501bbSmillert 			break;
79f5f501bbSmillert 		case 'C':
80f5f501bbSmillert 			(void)strlcat(diffargs, " -C", sizeof(diffargs));
81f5f501bbSmillert 			if (strlcat(diffargs, rcs_optarg, sizeof(diffargs)) >=
82f5f501bbSmillert 			    sizeof(diffargs))
83f5f501bbSmillert 				errx(D_ERROR, "diffargs too long");
84f5f501bbSmillert 			diff_context = strtonum(rcs_optarg, 0, INT_MAX, &errstr);
85f5f501bbSmillert 			if (errstr)
86f5f501bbSmillert 				errx(D_ERROR, "context is %s: %s",
87f5f501bbSmillert 				    errstr, rcs_optarg);
88f5f501bbSmillert 			diff_format = D_CONTEXT;
89f5f501bbSmillert 			break;
906c1e881eSjoris 		case 'c':
916b99bb86Sray 			if (strlcat(diffargs, " -c", sizeof(diffargs)) >=
926b99bb86Sray 			    sizeof(diffargs))
931c5ed35bSxsa 				errx(D_ERROR, "diffargs too long");
946c1e881eSjoris 			diff_format = D_CONTEXT;
956c1e881eSjoris 			break;
96f5f501bbSmillert 		case 'd':
97f5f501bbSmillert 			if (strlcat(diffargs, " -d", sizeof(diffargs)) >=
98f5f501bbSmillert 			    sizeof(diffargs))
99f5f501bbSmillert 				errx(D_ERROR, "diffargs too long");
100f5f501bbSmillert 			dflags |= D_MINIMAL;
101f5f501bbSmillert 			break;
102f5f501bbSmillert 		case 'i':
103f5f501bbSmillert 			if (strlcat(diffargs, " -i", sizeof(diffargs)) >=
104f5f501bbSmillert 			    sizeof(diffargs))
105f5f501bbSmillert 				errx(D_ERROR, "diffargs too long");
106f5f501bbSmillert 			dflags |= D_IGNORECASE;
107f5f501bbSmillert 			break;
108f5f501bbSmillert 		case 'I':
109f5f501bbSmillert 			(void)strlcat(diffargs, " -I", sizeof(diffargs));
110f5f501bbSmillert 			if (strlcat(diffargs, rcs_optarg, sizeof(diffargs)) >=
111f5f501bbSmillert 			    sizeof(diffargs))
112f5f501bbSmillert 				errx(D_ERROR, "diffargs too long");
113f5f501bbSmillert 			push_ignore_pats(rcs_optarg);
114f5f501bbSmillert 			break;
115dd5fbfceSxsa 		case 'k':
116dd5fbfceSxsa 			kflag = rcs_kflag_get(rcs_optarg);
117dd5fbfceSxsa 			if (RCS_KWEXP_INVAL(kflag)) {
11825a1df5bSxsa 				warnx("invalid RCS keyword substitution mode");
119dd5fbfceSxsa 				(usage)();
120dd5fbfceSxsa 			}
121dd5fbfceSxsa 			break;
1226c1e881eSjoris 		case 'n':
1236b99bb86Sray 			if (strlcat(diffargs, " -n", sizeof(diffargs)) >=
1246b99bb86Sray 			    sizeof(diffargs))
1251c5ed35bSxsa 				errx(D_ERROR, "diffargs too long");
1266c1e881eSjoris 			diff_format = D_RCSDIFF;
1276c1e881eSjoris 			break;
128f5f501bbSmillert 		case 'p':
129f5f501bbSmillert 			if (strlcat(diffargs, " -p", sizeof(diffargs)) >=
130f5f501bbSmillert 			    sizeof(diffargs))
131f5f501bbSmillert 				errx(D_ERROR, "diffargs too long");
132f5f501bbSmillert 			dflags |= D_PROTOTYPE;
133f5f501bbSmillert 			break;
13497449b47Sjoris 		case 'q':
135f5f501bbSmillert 			quiet = 1;
13697449b47Sjoris 			break;
1372fc3cee9Sniallo 		case 'r':
13836076781Sray 			rcs_setrevstr2(&rev_str1, &rev_str2, rcs_optarg);
1392fc3cee9Sniallo 			break;
1404ecf1ebbSxsa 		case 'T':
14129744cf0Sxsa 			/*
14229744cf0Sxsa 			 * kept for compatibility
14329744cf0Sxsa 			 */
1444ecf1ebbSxsa 			break;
145f5f501bbSmillert 		case 't':
146f5f501bbSmillert 			if (strlcat(diffargs, " -t", sizeof(diffargs)) >=
147f5f501bbSmillert 			    sizeof(diffargs))
148f5f501bbSmillert 				errx(D_ERROR, "diffargs too long");
149f5f501bbSmillert 			dflags |= D_EXPANDTABS;
150f5f501bbSmillert 			break;
151f5f501bbSmillert 		case 'U':
152f5f501bbSmillert 			(void)strlcat(diffargs, " -U", sizeof(diffargs));
153f5f501bbSmillert 			if (strlcat(diffargs, rcs_optarg, sizeof(diffargs)) >=
154f5f501bbSmillert 			    sizeof(diffargs))
155f5f501bbSmillert 				errx(D_ERROR, "diffargs too long");
156f5f501bbSmillert 			diff_context = strtonum(rcs_optarg, 0, INT_MAX, &errstr);
157f5f501bbSmillert 			if (errstr)
158f5f501bbSmillert 				errx(D_ERROR, "context is %s: %s",
159f5f501bbSmillert 				    errstr, rcs_optarg);
160f5f501bbSmillert 			diff_format = D_UNIFIED;
161f5f501bbSmillert 			break;
1626b99bb86Sray 		case 'u':
1636b99bb86Sray 			if (strlcat(diffargs, " -u", sizeof(diffargs)) >=
1646b99bb86Sray 			    sizeof(diffargs))
1651c5ed35bSxsa 				errx(D_ERROR, "diffargs too long");
1666b99bb86Sray 			diff_format = D_UNIFIED;
1676b99bb86Sray 			break;
1687518c1e9Sxsa 		case 'V':
1697518c1e9Sxsa 			printf("%s\n", rcs_version);
1707518c1e9Sxsa 			exit(0);
171f5f501bbSmillert 		case 'w':
172f5f501bbSmillert 			if (strlcat(diffargs, " -w", sizeof(diffargs)) >=
173f5f501bbSmillert 			    sizeof(diffargs))
174f5f501bbSmillert 				errx(D_ERROR, "diffargs too long");
175f5f501bbSmillert 			dflags |= D_IGNOREBLANKS;
176f5f501bbSmillert 			break;
1777518c1e9Sxsa 		case 'x':
1784365263eSray 			/* Use blank extension if none given. */
1794365263eSray 			rcs_suffixes = rcs_optarg ? rcs_optarg : "";
1807518c1e9Sxsa 			break;
1816baf4b21Sjoris 		case 'z':
1826baf4b21Sjoris 			timezone_flag = rcs_optarg;
1836baf4b21Sjoris 			break;
18497449b47Sjoris 		default:
185a2b34663Sjoris 			(usage)();
18697449b47Sjoris 		}
18797449b47Sjoris 	}
18897449b47Sjoris 
189a2b34663Sjoris 	argc -= rcs_optind;
190a2b34663Sjoris 	argv += rcs_optind;
19197449b47Sjoris 
19297449b47Sjoris 	if (argc == 0) {
19382ca7eaaSxsa 		warnx("no input file");
19497449b47Sjoris 		(usage)();
19597449b47Sjoris 	}
19697449b47Sjoris 
197f5f501bbSmillert 	if (diff_ignore_pats != NULL) {
198f5f501bbSmillert 		char buf[BUFSIZ];
199f5f501bbSmillert 		int error;
200f5f501bbSmillert 
201f5f501bbSmillert 		diff_ignore_re = xmalloc(sizeof(*diff_ignore_re));
202f5f501bbSmillert 		if ((error = regcomp(diff_ignore_re, diff_ignore_pats,
203f5f501bbSmillert 		    REG_NEWLINE | REG_EXTENDED)) != 0) {
204f5f501bbSmillert 			regerror(error, diff_ignore_re, buf, sizeof(buf));
205f5f501bbSmillert 			if (*diff_ignore_pats != '\0')
206f5f501bbSmillert 				errx(D_ERROR, "%s: %s", diff_ignore_pats, buf);
207f5f501bbSmillert 			else
208f5f501bbSmillert 				errx(D_ERROR, "%s", buf);
209f5f501bbSmillert 		}
210f5f501bbSmillert 	}
211f5f501bbSmillert 
21297449b47Sjoris 	for (i = 0; i < argc; i++) {
213f3876e23Sray 		fd = rcs_choosefile(argv[i], fpath, sizeof(fpath));
214f3876e23Sray 		if (fd < 0) {
21599e66255Sniallo 			warn("%s", fpath);
21697449b47Sjoris 			continue;
217f3876e23Sray 		}
21897449b47Sjoris 
219bc8d37c3Sjoris 		if ((file = rcs_open(fpath, fd,
220bc8d37c3Sjoris 		    RCS_READ|RCS_PARSE_FULLY)) == NULL)
22197449b47Sjoris 			continue;
22297449b47Sjoris 
22333e5c3dcSxsa 		rcs_kwexp_set(file, kflag);
22433e5c3dcSxsa 
22536076781Sray 		if (rev_str1 != NULL) {
226e7816acdSray 			if ((rev1 = rcs_getrevnum(rev_str1, file)) == NULL)
2271c5ed35bSxsa 				errx(D_ERROR, "bad revision number");
22836076781Sray 		}
22936076781Sray 		if (rev_str2 != NULL) {
230e7816acdSray 			if ((rev2 = rcs_getrevnum(rev_str2, file)) == NULL)
2311c5ed35bSxsa 				errx(D_ERROR, "bad revision number");
23236076781Sray 		}
23397449b47Sjoris 
234f5f501bbSmillert 		if (!quiet) {
235dd5fbfceSxsa 			fprintf(stderr, "%s\n", RCS_DIFF_DIV);
236dd5fbfceSxsa 			fprintf(stderr, "RCS file: %s\n", fpath);
2375b9f54b8Sxsa 		}
2385b9f54b8Sxsa 
23929a37f6aSjoris 		diff_file = argv[i];
24029a37f6aSjoris 
24136076781Sray 		/* No revisions given. */
2421fb625bfSxsa 		if (rev_str1 == NULL)
243f5f501bbSmillert 			status = rcsdiff_file(file, file->rf_head, argv[i],
244f5f501bbSmillert 			    dflags);
24536076781Sray 		/* One revision given. */
2461fb625bfSxsa 		else if (rev_str2 == NULL)
247f5f501bbSmillert 			status = rcsdiff_file(file, rev1, argv[i], dflags);
24836076781Sray 		/* Two revisions given. */
2491fb625bfSxsa 		else
250f5f501bbSmillert 			status = rcsdiff_rev(file, rev1, rev2, dflags);
25197449b47Sjoris 
25297449b47Sjoris 		rcs_close(file);
25336076781Sray 		rcsnum_free(rev1);
25436076781Sray 		rcsnum_free(rev2);
2554dbe037aSnicm 		rev1 = rev2 = NULL;
25697449b47Sjoris 	}
25797449b47Sjoris 
258f91c22bcSniallo 	return (status);
25997449b47Sjoris }
26097449b47Sjoris 
261960e00beSotto __dead void
rcsdiff_usage(void)26297449b47Sjoris rcsdiff_usage(void)
26397449b47Sjoris {
264248620a5Sderaadt 	fprintf(stderr,
265941c115fSsobrado 	    "usage: rcsdiff [-cnquV] [-kmode] [-rrev] [-xsuffixes] [-ztz]\n"
266941c115fSsobrado 	    "               [diff_options] file ...\n");
267960e00beSotto 
268960e00beSotto 	exit(D_ERROR);
26997449b47Sjoris }
27097449b47Sjoris 
27197449b47Sjoris static int
rcsdiff_file(RCSFILE * file,RCSNUM * rev,const char * filename,int dflags)272f5f501bbSmillert rcsdiff_file(RCSFILE *file, RCSNUM *rev, const char *filename, int dflags)
27397449b47Sjoris {
274bc8d37c3Sjoris 	int ret, fd;
2756d7e6850Sjoris 	time_t t;
276bc8d37c3Sjoris 	struct stat st;
277cdc530d2Sxsa 	char *path1, *path2;
27897449b47Sjoris 	BUF *b1, *b2;
279950e09dcSxsa 	char rbuf[RCS_REV_BUFSZ];
2806d7e6850Sjoris 	struct tm *tb;
281bf951d2dSniallo 	struct timeval tv[2], tv2[2];
2826d7e6850Sjoris 
283bf951d2dSniallo 	memset(&tv, 0, sizeof(tv));
284bf951d2dSniallo 	memset(&tv2, 0, sizeof(tv2));
285216fedf4Sxsa 
2861fb625bfSxsa 	ret = D_ERROR;
287f2af11b8Sjoris 	b1 = b2 = NULL;
288f2af11b8Sjoris 
2896d7e6850Sjoris 	diff_rev1 = rev;
2906d7e6850Sjoris 	diff_rev2 = NULL;
291051bb10cSniallo 	path1 = path2 = NULL;
2926d7e6850Sjoris 
293bc8d37c3Sjoris 	if ((fd = open(filename, O_RDONLY)) == -1) {
29482ca7eaaSxsa 		warn("%s", filename);
295f2af11b8Sjoris 		goto out;
296216fedf4Sxsa 	}
29797449b47Sjoris 
29897449b47Sjoris 	rcsnum_tostr(rev, rbuf, sizeof(rbuf));
299f5f501bbSmillert 	if (!quiet) {
300dd5fbfceSxsa 		fprintf(stderr, "retrieving revision %s\n", rbuf);
301dd5fbfceSxsa 		fprintf(stderr, "%s -r%s %s\n", diffargs, rbuf, filename);
302c60b216dSxsa 	}
30397449b47Sjoris 
30459c8baf2Sxsa 	if ((b1 = rcs_getrev(file, rev)) == NULL) {
30582ca7eaaSxsa 		warnx("failed to retrieve revision %s", rbuf);
306f2af11b8Sjoris 		goto out;
30797449b47Sjoris 	}
308f2af11b8Sjoris 
3090311d807Sniallo 	b1 = rcs_kwexp_buf(b1, file, rev);
310db59da07Sderaadt 	tv[0].tv_sec = rcs_rev_getdate(file, rev);
311bf951d2dSniallo 	tv[1].tv_sec = tv[0].tv_sec;
31297449b47Sjoris 
3130ee14128Sray 	if ((b2 = buf_load(filename)) == NULL) {
31482ca7eaaSxsa 		warnx("failed to load file: `%s'", filename);
315f2af11b8Sjoris 		goto out;
31697449b47Sjoris 	}
317f2af11b8Sjoris 
3186d7e6850Sjoris 	/* XXX - GNU uses GMT */
319bc8d37c3Sjoris 	if (fstat(fd, &st) == -1)
3201c5ed35bSxsa 		err(D_ERROR, "%s", filename);
321bc8d37c3Sjoris 
3226d7e6850Sjoris 	tb = gmtime(&st.st_mtime);
3236d7e6850Sjoris 	t = mktime(tb);
3246d7e6850Sjoris 
3256d7e6850Sjoris 	tv2[0].tv_sec = t;
3266d7e6850Sjoris 	tv2[1].tv_sec = t;
32797449b47Sjoris 
328cdc530d2Sxsa 	(void)xasprintf(&path1, "%s/diff1.XXXXXXXXXX", rcs_tmpdir);
3297bb3ddb0Sray 	buf_write_stmp(b1, path1);
3308933887bSjoris 
3317bb3ddb0Sray 	buf_free(b1);
332f2af11b8Sjoris 	b1 = NULL;
333f2af11b8Sjoris 
334*3aaa63ebSderaadt 	if (utimes(path1, (const struct timeval *)&tv) == -1)
33582ca7eaaSxsa 		warn("utimes");
33697449b47Sjoris 
337cdc530d2Sxsa 	(void)xasprintf(&path2, "%s/diff2.XXXXXXXXXX", rcs_tmpdir);
3387bb3ddb0Sray 	buf_write_stmp(b2, path2);
3398933887bSjoris 
3407bb3ddb0Sray 	buf_free(b2);
341f2af11b8Sjoris 	b2 = NULL;
342f2af11b8Sjoris 
343*3aaa63ebSderaadt 	if (utimes(path2, (const struct timeval *)&tv2) == -1)
34482ca7eaaSxsa 		warn("utimes");
34597449b47Sjoris 
346f049f428Sray 	ret = diffreg(path1, path2, NULL, dflags);
34797449b47Sjoris 
348f2af11b8Sjoris out:
349bc8d37c3Sjoris 	if (fd != -1)
350bc8d37c3Sjoris 		(void)close(fd);
3517bb3ddb0Sray 	buf_free(b1);
3527bb3ddb0Sray 	buf_free(b2);
3538ac837e5Snicm 	free(path1);
3548ac837e5Snicm 	free(path2);
355f2af11b8Sjoris 
356f2af11b8Sjoris 	return (ret);
35797449b47Sjoris }
3582fc3cee9Sniallo 
3592fc3cee9Sniallo static int
rcsdiff_rev(RCSFILE * file,RCSNUM * rev1,RCSNUM * rev2,int dflags)360f5f501bbSmillert rcsdiff_rev(RCSFILE *file, RCSNUM *rev1, RCSNUM *rev2, int dflags)
3612fc3cee9Sniallo {
362bf951d2dSniallo 	struct timeval tv[2], tv2[2];
363adfbc82eSray 	BUF *b1, *b2;
364adfbc82eSray 	int ret;
365950e09dcSxsa 	char *path1, *path2, rbuf1[RCS_REV_BUFSZ], rbuf2[RCS_REV_BUFSZ];
366bf951d2dSniallo 
3671fb625bfSxsa 	ret = D_ERROR;
368f2af11b8Sjoris 	b1 = b2 = NULL;
369bf951d2dSniallo 	memset(&tv, 0, sizeof(tv));
370bf951d2dSniallo 	memset(&tv2, 0, sizeof(tv2));
3712fc3cee9Sniallo 
3726d7e6850Sjoris 	diff_rev1 = rev1;
3736d7e6850Sjoris 	diff_rev2 = rev2;
374051bb10cSniallo 	path1 = path2 = NULL;
3756d7e6850Sjoris 
376c60b216dSxsa 	rcsnum_tostr(rev1, rbuf1, sizeof(rbuf1));
377f5f501bbSmillert 	if (!quiet)
3786d7e6850Sjoris 		fprintf(stderr, "retrieving revision %s\n", rbuf1);
3792fc3cee9Sniallo 
38059c8baf2Sxsa 	if ((b1 = rcs_getrev(file, rev1)) == NULL) {
38182ca7eaaSxsa 		warnx("failed to retrieve revision %s", rbuf1);
382f2af11b8Sjoris 		goto out;
3832fc3cee9Sniallo 	}
384f2af11b8Sjoris 
3850311d807Sniallo 	b1 = rcs_kwexp_buf(b1, file, rev1);
386db59da07Sderaadt 	tv[0].tv_sec = rcs_rev_getdate(file, rev1);
387bf951d2dSniallo 	tv[1].tv_sec = tv[0].tv_sec;
3882fc3cee9Sniallo 
389c60b216dSxsa 	rcsnum_tostr(rev2, rbuf2, sizeof(rbuf2));
390f5f501bbSmillert 	if (!quiet)
391dd5fbfceSxsa 		fprintf(stderr, "retrieving revision %s\n", rbuf2);
3922fc3cee9Sniallo 
39359c8baf2Sxsa 	if ((b2 = rcs_getrev(file, rev2)) == NULL) {
39482ca7eaaSxsa 		warnx("failed to retrieve revision %s", rbuf2);
395f2af11b8Sjoris 		goto out;
3962fc3cee9Sniallo 	}
397f2af11b8Sjoris 
3980311d807Sniallo 	b2 = rcs_kwexp_buf(b2, file, rev2);
399db59da07Sderaadt 	tv2[0].tv_sec = rcs_rev_getdate(file, rev2);
400bf951d2dSniallo 	tv2[1].tv_sec = tv2[0].tv_sec;
4012fc3cee9Sniallo 
402f5f501bbSmillert 	if (!quiet)
403488f4ba6Sxsa 		fprintf(stderr, "%s -r%s -r%s\n", diffargs, rbuf1, rbuf2);
404c60b216dSxsa 
405cdc530d2Sxsa 	(void)xasprintf(&path1, "%s/diff1.XXXXXXXXXX", rcs_tmpdir);
4067bb3ddb0Sray 	buf_write_stmp(b1, path1);
4078933887bSjoris 
4087bb3ddb0Sray 	buf_free(b1);
409f2af11b8Sjoris 	b1 = NULL;
410f2af11b8Sjoris 
411*3aaa63ebSderaadt 	if (utimes(path1, (const struct timeval *)&tv) == -1)
41282ca7eaaSxsa 		warn("utimes");
4132fc3cee9Sniallo 
414cdc530d2Sxsa 	(void)xasprintf(&path2, "%s/diff2.XXXXXXXXXX", rcs_tmpdir);
4157bb3ddb0Sray 	buf_write_stmp(b2, path2);
4168933887bSjoris 
4177bb3ddb0Sray 	buf_free(b2);
418f2af11b8Sjoris 	b2 = NULL;
4192fc3cee9Sniallo 
420*3aaa63ebSderaadt 	if (utimes(path2, (const struct timeval *)&tv2) == -1)
42182ca7eaaSxsa 		warn("utimes");
422bf951d2dSniallo 
423f049f428Sray 	ret = diffreg(path1, path2, NULL, dflags);
4242fc3cee9Sniallo 
425f2af11b8Sjoris out:
4267bb3ddb0Sray 	buf_free(b1);
4277bb3ddb0Sray 	buf_free(b2);
4288ac837e5Snicm 	free(path1);
4298ac837e5Snicm 	free(path2);
430f2af11b8Sjoris 
431f2af11b8Sjoris 	return (ret);
4322fc3cee9Sniallo }
433f5f501bbSmillert 
434f5f501bbSmillert static void
push_ignore_pats(char * pattern)435f5f501bbSmillert push_ignore_pats(char *pattern)
436f5f501bbSmillert {
437f5f501bbSmillert 	size_t len;
438f5f501bbSmillert 
439f5f501bbSmillert 	if (diff_ignore_pats == NULL) {
440f5f501bbSmillert 		len = strlen(pattern) + 1;
441f5f501bbSmillert 		diff_ignore_pats = xmalloc(len);
442f5f501bbSmillert 		strlcpy(diff_ignore_pats, pattern, len);
443f5f501bbSmillert 	} else {
444f5f501bbSmillert 		/* old + "|" + new + NUL */
445f5f501bbSmillert 		len = strlen(diff_ignore_pats) + strlen(pattern) + 2;
446caa2ffb0Sderaadt 		diff_ignore_pats = xreallocarray(diff_ignore_pats, len, 1);
447f5f501bbSmillert 		strlcat(diff_ignore_pats, "|", len);
448f5f501bbSmillert 		strlcat(diff_ignore_pats, pattern, len);
449f5f501bbSmillert 	}
450f5f501bbSmillert }
451