1/*	$OpenBSD: diff3prog.c,v 1.11 2009/10/27 23:59:37 deraadt Exp $	*/
2
3/*
4 * Copyright (C) Caldera International Inc.  2001-2002.
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code and documentation must retain the above
11 *    copyright notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 *    notice, this list of conditions and the following disclaimer in the
14 *    documentation and/or other materials provided with the distribution.
15 * 3. All advertising materials mentioning features or use of this software
16 *    must display the following acknowledgement:
17 *	This product includes software developed or owned by Caldera
18 *	International, Inc.
19 * 4. Neither the name of Caldera International, Inc. nor the names of other
20 *    contributors may be used to endorse or promote products derived from
21 *    this software without specific prior written permission.
22 *
23 * USE OF THE SOFTWARE PROVIDED FOR UNDER THIS LICENSE BY CALDERA
24 * INTERNATIONAL, INC. AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR
25 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
26 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
27 * IN NO EVENT SHALL CALDERA INTERNATIONAL, INC. BE LIABLE FOR ANY DIRECT,
28 * INDIRECT INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
29 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
30 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
32 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
33 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
34 * POSSIBILITY OF SUCH DAMAGE.
35 */
36/*-
37 * Copyright (c) 1991, 1993
38 *	The Regents of the University of California.  All rights reserved.
39 *
40 * Redistribution and use in source and binary forms, with or without
41 * modification, are permitted provided that the following conditions
42 * are met:
43 * 1. Redistributions of source code must retain the above copyright
44 *    notice, this list of conditions and the following disclaimer.
45 * 2. Redistributions in binary form must reproduce the above copyright
46 *    notice, this list of conditions and the following disclaimer in the
47 *    documentation and/or other materials provided with the distribution.
48 * 3. Neither the name of the University nor the names of its contributors
49 *    may be used to endorse or promote products derived from this software
50 *    without specific prior written permission.
51 *
52 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
53 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
54 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
55 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
56 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
57 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
58 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
59 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
60 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
61 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
62 * SUCH DAMAGE.
63 *
64 *	@(#)diff3.c	8.1 (Berkeley) 6/6/93
65 */
66
67#if 0
68#ifndef lint
69static char sccsid[] = "@(#)diff3.c	8.1 (Berkeley) 6/6/93";
70#endif
71#endif /* not lint */
72#include <sys/cdefs.h>
73__FBSDID("$FreeBSD$");
74
75#include <sys/capsicum.h>
76#include <sys/procdesc.h>
77#include <sys/types.h>
78#include <sys/event.h>
79#include <sys/wait.h>
80
81#include <capsicum_helpers.h>
82#include <ctype.h>
83#include <err.h>
84#include <getopt.h>
85#include <stdio.h>
86#include <stdlib.h>
87#include <limits.h>
88#include <inttypes.h>
89#include <string.h>
90#include <unistd.h>
91
92
93/*
94 * "from" is first in range of changed lines; "to" is last+1
95 * from=to=line after point of insertion for added lines.
96 */
97struct range {
98	int from;
99	int to;
100};
101
102struct diff {
103	struct range old;
104	struct range new;
105};
106
107static size_t szchanges;
108
109static struct diff *d13;
110static struct diff *d23;
111/*
112 * "de" is used to gather editing scripts.  These are later spewed out in
113 * reverse order.  Its first element must be all zero, the "new" component
114 * of "de" contains line positions or byte positions depending on when you
115 * look (!?).  Array overlap indicates which sections in "de" correspond to
116 * lines that are different in all three files.
117 */
118static struct diff *de;
119static char *overlap;
120static int  overlapcnt;
121static FILE *fp[3];
122static int cline[3];		/* # of the last-read line in each file (0-2) */
123/*
124 * The latest known correspondence between line numbers of the 3 files
125 * is stored in last[1-3];
126 */
127static int last[4];
128static int Aflag, eflag, iflag, mflag, Tflag;
129static int oflag;		/* indicates whether to mark overlaps (-E or -X)*/
130static int strip_cr;
131static char *f1mark, *f2mark, *f3mark;
132
133static bool duplicate(struct range *, struct range *);
134static int edit(struct diff *, bool, int);
135static char *getchange(FILE *);
136static char *get_line(FILE *, size_t *);
137static int readin(int fd, struct diff **);
138static int skip(int, int, const char *);
139static void change(int, struct range *, bool);
140static void keep(int, struct range *);
141static void merge(int, int);
142static void prange(struct range *);
143static void repos(int);
144static void edscript(int) __dead2;
145static void increase(void);
146static void usage(void) __dead2;
147
148enum {
149	DIFFPROG_OPT,
150	STRIPCR_OPT,
151};
152
153#define DIFF_PATH "/usr/bin/diff"
154
155#define OPTIONS "3aAeEiL:mTxX"
156static struct option longopts[] = {
157	{ "ed",			no_argument,		NULL,	'e' },
158	{ "show-overlap",	no_argument,		NULL,	'E' },
159	{ "overlap-only",	no_argument,		NULL,	'x' },
160	{ "initial-tab",	no_argument,		NULL,	'T' },
161	{ "text",		no_argument,		NULL,	'a' },
162	{ "strip-trailing-cr",	no_argument,		NULL,	STRIPCR_OPT },
163	{ "show-all",		no_argument,		NULL,	'A' },
164	{ "easy-only",		no_argument,		NULL,	'3' },
165	{ "merge",		no_argument,		NULL,	'm' },
166	{ "label",		required_argument,	NULL,	'L' },
167	{ "diff-program",	required_argument,	NULL,	DIFFPROG_OPT },
168};
169
170static void
171usage(void)
172{
173	fprintf(stderr, "usage: diff3 [-3aAeEimTxX] [-L lable1] [-L label2] "
174	    "[ -L label3] file1 file2 file3\n");
175	exit (2);
176}
177
178static int
179readin(int fd, struct diff **dd)
180{
181	int a, b, c, d;
182	size_t i;
183	char kind, *p;
184	FILE *f;
185
186	f = fdopen(fd, "r");
187	if (f == NULL)
188		err(2, "fdopen");
189	for (i=0; (p = getchange(f)); i++) {
190		if (i >= szchanges - 1)
191			increase();
192		a = b = (int)strtoimax(p, &p, 10);
193		if (*p == ',') {
194			p++;
195			b = (int)strtoimax(p, &p, 10);
196		}
197		kind = *p++;
198		c = d = (int)strtoimax(p, &p, 10);
199		if (*p==',') {
200			p++;
201			d = (int)strtoimax(p, &p, 10);
202		}
203		if (kind == 'a')
204			a++;
205		if (kind == 'd')
206			c++;
207		b++;
208		d++;
209		(*dd)[i].old.from = a;
210		(*dd)[i].old.to = b;
211		(*dd)[i].new.from = c;
212		(*dd)[i].new.to = d;
213	}
214	if (i) {
215		(*dd)[i].old.from = (*dd)[i-1].old.to;
216		(*dd)[i].new.from = (*dd)[i-1].new.to;
217	}
218	fclose(f);
219	return (i);
220}
221
222static int
223diffexec(const char *diffprog, char **diffargv, int fd[])
224{
225	int pid, pd;
226
227	switch (pid = pdfork(&pd, PD_CLOEXEC)) {
228	case 0:
229		close(fd[0]);
230		if (dup2(fd[1], STDOUT_FILENO) == -1)
231			err(2, "child could not duplicate descriptor");
232		close(fd[1]);
233		execvp(diffprog, diffargv);
234		err(2, "could not execute diff: %s", diffprog);
235		break;
236	case -1:
237		err(2, "could not fork");
238		break;
239	}
240	close(fd[1]);
241	return (pd);
242}
243
244static char *
245getchange(FILE *b)
246{
247	char *line;
248
249	while ((line = get_line(b, NULL))) {
250		if (isdigit((unsigned char)line[0]))
251			return (line);
252	}
253	return (NULL);
254}
255
256
257static char *
258get_line(FILE *b, size_t *n)
259{
260	ssize_t len;
261	static char *buf = NULL;
262	static size_t bufsize = 0;
263
264	if ((len = getline(&buf, &bufsize, b)) < 0)
265		return (NULL);
266
267	if (n != NULL)
268		*n = len;
269
270	return (buf);
271}
272
273static void
274merge(int m1, int m2)
275{
276	struct diff *d1, *d2, *d3;
277	int j, t1, t2;
278	bool dup = false;
279
280	d1 = d13;
281	d2 = d23;
282	j = 0;
283
284	while ((t1 = d1 < d13 + m1) | (t2 = d2 < d23 + m2)) {
285		/* first file is different from the others */
286		if (!t2 || (t1 && d1->new.to < d2->new.from)) {
287			/* stuff peculiar to 1st file */
288			if (eflag == 0) {
289				printf("====1\n");
290				change(1, &d1->old, false);
291				keep(2, &d1->new);
292				change(3, &d1->new, false);
293			}
294			d1++;
295			continue;
296		}
297		/* second file is different from others */
298		if (!t1 || (t2 && d2->new.to < d1->new.from)) {
299			if (eflag == 0) {
300				printf("====2\n");
301				keep(1, &d2->new);
302				change(3, &d2->new, false);
303				change(2, &d2->old, false);
304			}
305			d2++;
306			continue;
307		}
308		/*
309		 * Merge overlapping changes in first file
310		 * this happens after extension (see below).
311		 */
312		if (d1 + 1 < d13 + m1 && d1->new.to >= d1[1].new.from) {
313			d1[1].old.from = d1->old.from;
314			d1[1].new.from = d1->new.from;
315			d1++;
316			continue;
317		}
318
319		/* merge overlapping changes in second */
320		if (d2 + 1 < d23 + m2 && d2->new.to >= d2[1].new.from) {
321			d2[1].old.from = d2->old.from;
322			d2[1].new.from = d2->new.from;
323			d2++;
324			continue;
325		}
326		/* stuff peculiar to third file or different in all */
327		if (d1->new.from == d2->new.from && d1->new.to == d2->new.to) {
328			dup = duplicate(&d1->old, &d2->old);
329			/*
330			 * dup = 0 means all files differ
331			 * dup = 1 means files 1 and 2 identical
332			 */
333			if (eflag == 0) {
334				printf("====%s\n", dup ? "3" : "");
335				change(1, &d1->old, dup);
336				change(2, &d2->old, false);
337				d3 = d1->old.to > d1->old.from ? d1 : d2;
338				change(3, &d3->new, false);
339			} else
340				j = edit(d1, dup, j);
341			d1++;
342			d2++;
343			continue;
344		}
345		/*
346		 * Overlapping changes from file 1 and 2; extend changes
347		 * appropriately to make them coincide.
348		 */
349		if (d1->new.from < d2->new.from) {
350			d2->old.from -= d2->new.from - d1->new.from;
351			d2->new.from = d1->new.from;
352		} else if (d2->new.from < d1->new.from) {
353			d1->old.from -= d1->new.from - d2->new.from;
354			d1->new.from = d2->new.from;
355		}
356		if (d1->new.to > d2->new.to) {
357			d2->old.to += d1->new.to - d2->new.to;
358			d2->new.to = d1->new.to;
359		} else if (d2->new.to > d1->new.to) {
360			d1->old.to += d2->new.to - d1->new.to;
361			d1->new.to = d2->new.to;
362		}
363	}
364	if (eflag)
365		edscript(j);
366}
367
368/*
369 * The range of lines rold.from thru rold.to in file i is to be changed.
370 * It is to be printed only if it does not duplicate something to be
371 * printed later.
372 */
373static void
374change(int i, struct range *rold, bool dup)
375{
376
377	printf("%d:", i);
378	last[i] = rold->to;
379	prange(rold);
380	if (dup)
381		return;
382	i--;
383	skip(i, rold->from, NULL);
384	skip(i, rold->to, "  ");
385}
386
387/*
388 * Print the range of line numbers, rold.from thru rold.to, as n1,n2 or
389 * n1.
390 */
391static void
392prange(struct range *rold)
393{
394
395	if (rold->to <= rold->from)
396		printf("%da\n", rold->from - 1);
397	else {
398		printf("%d", rold->from);
399		if (rold->to > rold->from+1)
400			printf(",%d", rold->to - 1);
401		printf("c\n");
402	}
403}
404
405/*
406 * No difference was reported by diff between file 1 (or 2) and file 3,
407 * and an artificial dummy difference (trange) must be ginned up to
408 * correspond to the change reported in the other file.
409 */
410static void
411keep(int i, struct range *rnew)
412{
413	int delta;
414	struct range trange;
415
416	delta = last[3] - last[i];
417	trange.from = rnew->from - delta;
418	trange.to = rnew->to - delta;
419	change(i, &trange, true);
420}
421
422/*
423 * skip to just before line number from in file "i".  If "pr" is non-NULL,
424 * print all skipped stuff with string pr as a prefix.
425 */
426static int
427skip(int i, int from, const char *pr)
428{
429	size_t j, n;
430	char *line;
431
432	for (n = 0; cline[i] < from - 1; n += j) {
433		if ((line = get_line(fp[i], &j)) == NULL)
434			errx(EXIT_FAILURE, "logic error");
435		if (pr != NULL)
436			printf("%s%s", Tflag == 1? "\t" : pr, line);
437		cline[i]++;
438	}
439	return ((int) n);
440}
441
442/*
443 * Return 1 or 0 according as the old range (in file 1) contains exactly
444 * the same data as the new range (in file 2).
445 */
446static bool
447duplicate(struct range *r1, struct range *r2)
448{
449	int c, d;
450	int nchar;
451	int nline;
452
453	if (r1->to-r1->from != r2->to-r2->from)
454		return (0);
455	skip(0, r1->from, NULL);
456	skip(1, r2->from, NULL);
457	nchar = 0;
458	for (nline=0; nline < r1->to - r1->from; nline++) {
459		do {
460			c = getc(fp[0]);
461			d = getc(fp[1]);
462			if (c == -1 || d== -1)
463				errx(EXIT_FAILURE, "logic error");
464			nchar++;
465			if (c != d) {
466				repos(nchar);
467				return (0);
468			}
469		} while (c != '\n');
470	}
471	repos(nchar);
472	return (1);
473}
474
475static void
476repos(int nchar)
477{
478	int i;
479
480	for (i = 0; i < 2; i++)
481		(void)fseek(fp[i], (long)-nchar, SEEK_CUR);
482}
483/*
484 * collect an editing script for later regurgitation
485 */
486static int
487edit(struct diff *diff, bool dup, int j)
488{
489
490	if (((dup + 1) & eflag) == 0)
491		return (j);
492	j++;
493	overlap[j] = !dup;
494	if (!dup)
495		overlapcnt++;
496	de[j].old.from = diff->old.from;
497	de[j].old.to = diff->old.to;
498	de[j].new.from = de[j-1].new.to + skip(2, diff->new.from, NULL);
499	de[j].new.to = de[j].new.from + skip(2, diff->new.to, NULL);
500	return (j);
501}
502
503/* regurgitate */
504static void
505edscript(int n)
506{
507	int k;
508	size_t j;
509	char block[BUFSIZ];
510
511	for (; n > 0; n--) {
512		if (!oflag || !overlap[n]) {
513			prange(&de[n].old);
514		} else {
515			printf("%da\n", de[n].old.to -1);
516			if (Aflag) {
517				printf("%s\n", f2mark);
518				fseek(fp[1], de[n].old.from, SEEK_SET);
519				for (k = de[n].old.to - de[n].old.from; k > 0; k -= j) {
520					j = k > BUFSIZ ? BUFSIZ : k;
521					if (fread(block, 1, j, fp[1]) != j)
522						errx(2, "logic error");
523					fwrite(block, 1, j, stdout);
524				}
525				printf("\n");
526			}
527			printf("=======\n");
528		}
529		fseek(fp[2], (long)de[n].new.from, SEEK_SET);
530		for (k = de[n].new.to - de[n].new.from; k > 0; k-= j) {
531			j = k > BUFSIZ ? BUFSIZ : k;
532			if (fread(block, 1, j, fp[2]) != j)
533				errx(2, "logic error");
534			fwrite(block, 1, j, stdout);
535		}
536		if (!oflag || !overlap[n])
537			printf(".\n");
538		else {
539			printf("%s\n.\n", f3mark);
540			printf("%da\n%s\n.\n", de[n].old.from - 1, f1mark);
541		}
542	}
543	if (iflag)
544		printf("w\nq\n");
545
546	exit(eflag == 0 ? overlapcnt : 0);
547}
548
549static void
550increase(void)
551{
552	struct diff *p;
553	char *q;
554	size_t newsz, incr;
555
556	/* are the memset(3) calls needed? */
557	newsz = szchanges == 0 ? 64 : 2 * szchanges;
558	incr = newsz - szchanges;
559
560	p = realloc(d13, newsz * sizeof(struct diff));
561	if (p == NULL)
562		err(1, NULL);
563	memset(p + szchanges, 0, incr * sizeof(struct diff));
564	d13 = p;
565	p = realloc(d23, newsz * sizeof(struct diff));
566	if (p == NULL)
567		err(1, NULL);
568	memset(p + szchanges, 0, incr * sizeof(struct diff));
569	d23 = p;
570	p = realloc(de, newsz * sizeof(struct diff));
571	if (p == NULL)
572		err(1, NULL);
573	memset(p + szchanges, 0, incr * sizeof(struct diff));
574	de = p;
575	q = realloc(overlap, newsz * sizeof(char));
576	if (q == NULL)
577		err(1, NULL);
578	memset(q + szchanges, 0, incr * sizeof(char));
579	overlap = q;
580	szchanges = newsz;
581}
582
583
584int
585main(int argc, char **argv)
586{
587	int ch, nblabels, status, m, n, kq, nke, nleft, i;
588	char *labels[] = { NULL, NULL, NULL };
589	const char *diffprog = DIFF_PATH;
590	char *file1, *file2, *file3;
591	char *diffargv[6];
592	int diffargc = 0;
593	int fd13[2], fd23[2];
594	int pd13, pd23;
595	cap_rights_t rights_ro;
596	struct kevent *e;
597
598	nblabels = 0;
599	eflag = 0;
600	oflag = 0;
601	diffargv[diffargc++] = __DECONST(char *, diffprog);
602	while ((ch = getopt_long(argc, argv, OPTIONS, longopts, NULL)) != -1) {
603		switch (ch) {
604		case '3':
605			eflag = 2;
606			break;
607		case 'a':
608			diffargv[diffargc++] = __DECONST(char *, "-a");
609			break;
610		case 'A':
611			Aflag = 1;
612			break;
613		case 'e':
614			eflag = 3;
615			break;
616		case 'E':
617			eflag = 3;
618			oflag = 1;
619			break;
620		case 'i':
621			iflag = 1;
622			break;
623		case 'L':
624			oflag = 1;
625			if (nblabels >= 3)
626				errx(2, "too many file label options");
627			labels[nblabels++] = optarg;
628			break;
629		case 'm':
630			Aflag = 1;
631			oflag = 1;
632			mflag = 1;
633			break;
634		case 'T':
635			Tflag = 1;
636			break;
637		case 'x':
638			eflag = 1;
639			break;
640		case 'X':
641			oflag = 1;
642			eflag = 1;
643			break;
644		case DIFFPROG_OPT:
645			diffprog = optarg;
646			break;
647		case STRIPCR_OPT:
648			strip_cr = 1;
649			break;
650		}
651	}
652	argc -= optind;
653	argv += optind;
654
655	if (Aflag) {
656		eflag = 3;
657		oflag = 1;
658	}
659
660	if (argc != 3)
661		usage();
662
663	if (caph_limit_stdio() == -1)
664		err(2, "unable to limit stdio");
665
666	cap_rights_init(&rights_ro, CAP_READ, CAP_FSTAT, CAP_SEEK);
667
668	kq = kqueue();
669	if (kq == -1)
670		err(2, "kqueue");
671
672	e = malloc(2 * sizeof(struct kevent));
673	if (e == NULL)
674		err(2, "malloc");
675
676	/* TODO stdio */
677	file1 = argv[0];
678	file2 = argv[1];
679	file3 = argv[2];
680
681	if (oflag) {
682		asprintf(&f1mark, "<<<<<<< %s",
683		    labels[0] != NULL ? labels[0] : file1);
684		if (f1mark == NULL)
685			err(2, "asprintf");
686		asprintf(&f2mark, "||||||| %s",
687		    labels[1] != NULL ? labels[1] : file2);
688		if (f2mark == NULL)
689			err(2, "asprintf");
690		asprintf(&f3mark, ">>>>>>> %s",
691		    labels[2] != NULL ? labels[2] : file3);
692		if (f3mark == NULL)
693			err(2, "asprintf");
694	}
695	fp[0] = fopen(file1, "r");
696	if (fp[0] == NULL)
697		err(2, "Can't open %s", file1);
698	if (caph_rights_limit(fileno(fp[0]), &rights_ro) < 0)
699		err(2, "unable to limit rights on: %s", file1);
700
701	fp[1] = fopen(file2, "r");
702	if (fp[1] == NULL)
703		err(2, "Can't open %s", file2);
704	if (caph_rights_limit(fileno(fp[1]), &rights_ro) < 0)
705		err(2, "unable to limit rights on: %s", file2);
706
707	fp[2] = fopen(file3, "r");
708	if (fp[2] == NULL)
709		err(2, "Can't open %s", file3);
710	if (caph_rights_limit(fileno(fp[2]), &rights_ro) < 0)
711		err(2, "unable to limit rights on: %s", file3);
712
713	if (pipe(fd13))
714		err(2, "pipe");
715	if (pipe(fd23))
716		err(2, "pipe");
717
718	diffargv[diffargc] = file1;
719	diffargv[diffargc + 1] = file3;
720	diffargv[diffargc + 2] = NULL;
721
722	nleft = 0;
723	pd13 = diffexec(diffprog, diffargv, fd13);
724	EV_SET(e + nleft , pd13, EVFILT_PROCDESC, EV_ADD, NOTE_EXIT, 0, NULL);
725	if (kevent(kq, e + nleft, 1, NULL, 0, NULL) == -1)
726		err(2, "kevent1");
727	nleft++;
728
729	diffargv[diffargc] = file2;
730	pd23 = diffexec(diffprog, diffargv, fd23);
731	EV_SET(e + nleft , pd23, EVFILT_PROCDESC, EV_ADD, NOTE_EXIT, 0, NULL);
732	if (kevent(kq, e + nleft, 1, NULL, 0, NULL) == -1)
733		err(2, "kevent2");
734	nleft++;
735
736	caph_cache_catpages();
737	if (caph_enter() < 0)
738		err(2, "unable to enter capability mode");
739
740	/* parse diffs */
741	increase();
742	m = readin(fd13[0], &d13);
743	n = readin(fd23[0], &d23);
744
745	/* waitpid cooked over pdforks */
746	while (nleft > 0) {
747		nke = kevent(kq, NULL, 0, e, nleft, NULL);
748		if (nke == -1)
749			err(2, "kevent");
750		for (i = 0; i < nke; i++) {
751			status = e[i].data;
752			if (WIFEXITED(status) && WEXITSTATUS(status) >= 2)
753				errx(2, "diff exited abormally");
754			else if (WIFSIGNALED(status))
755				errx(2, "diff killed by signal %d",
756				    WTERMSIG(status));
757		}
758		nleft -= nke;
759	}
760	merge(m, n);
761
762	return (EXIT_SUCCESS);
763}
764