1/*-
2 * SPDX-License-Identifier: BSD-3-Clause
3 *
4 * Copyright (c) 1991, 1993
5 *	The Regents of the University of California.  All rights reserved.
6 *
7 * This code is derived from software contributed to Berkeley by
8 * Edward Sze-Tyan Wang.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 *    notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 *    notice, this list of conditions and the following disclaimer in the
17 *    documentation and/or other materials provided with the distribution.
18 * 3. Neither the name of the University nor the names of its contributors
19 *    may be used to endorse or promote products derived from this software
20 *    without specific prior written permission.
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 * SUCH DAMAGE.
33 */
34
35#include <sys/cdefs.h>
36
37__FBSDID("$FreeBSD$");
38
39#ifndef lint
40static const char sccsid[] = "@(#)forward.c	8.1 (Berkeley) 6/6/93";
41#endif
42
43#include <sys/param.h>
44#include <sys/mount.h>
45#include <sys/types.h>
46#include <sys/stat.h>
47#include <sys/time.h>
48#include <sys/mman.h>
49#include <sys/event.h>
50
51#include <err.h>
52#include <errno.h>
53#include <fcntl.h>
54#include <limits.h>
55#include <stdio.h>
56#include <stdlib.h>
57#include <string.h>
58#include <unistd.h>
59
60#include "extern.h"
61
62static void rlines(FILE *, const char *fn, off_t, struct stat *);
63static int show(file_info_t *);
64static void set_events(file_info_t *files);
65
66/* defines for inner loop actions */
67#define USE_SLEEP	0
68#define USE_KQUEUE	1
69#define ADD_EVENTS	2
70
71static struct kevent *ev;
72static int action = USE_SLEEP;
73static int kq;
74
75static const file_info_t *last;
76
77/*
78 * forward -- display the file, from an offset, forward.
79 *
80 * There are eight separate cases for this -- regular and non-regular
81 * files, by bytes or lines and from the beginning or end of the file.
82 *
83 * FBYTES	byte offset from the beginning of the file
84 *	REG	seek
85 *	NOREG	read, counting bytes
86 *
87 * FLINES	line offset from the beginning of the file
88 *	REG	read, counting lines
89 *	NOREG	read, counting lines
90 *
91 * RBYTES	byte offset from the end of the file
92 *	REG	seek
93 *	NOREG	cyclically read characters into a wrap-around buffer
94 *
95 * RLINES
96 *	REG	mmap the file and step back until reach the correct offset.
97 *	NOREG	cyclically read lines into a wrap-around array of buffers
98 */
99void
100forward(FILE *fp, const char *fn, enum STYLE style, off_t off, struct stat *sbp)
101{
102	int ch;
103
104	switch(style) {
105	case FBYTES:
106		if (off == 0)
107			break;
108		if (S_ISREG(sbp->st_mode)) {
109			if (sbp->st_size < off)
110				off = sbp->st_size;
111			if (fseeko(fp, off, SEEK_SET) == -1) {
112				ierr(fn);
113				return;
114			}
115		} else while (off--)
116			if ((ch = getc(fp)) == EOF) {
117				if (ferror(fp)) {
118					ierr(fn);
119					return;
120				}
121				break;
122			}
123		break;
124	case FLINES:
125		if (off == 0)
126			break;
127		for (;;) {
128			if ((ch = getc(fp)) == EOF) {
129				if (ferror(fp)) {
130					ierr(fn);
131					return;
132				}
133				break;
134			}
135			if (ch == '\n' && !--off)
136				break;
137		}
138		break;
139	case RBYTES:
140		if (S_ISREG(sbp->st_mode)) {
141			if (sbp->st_size >= off &&
142			    fseeko(fp, -off, SEEK_END) == -1) {
143				ierr(fn);
144				return;
145			}
146		} else if (off == 0) {
147			while (getc(fp) != EOF);
148			if (ferror(fp)) {
149				ierr(fn);
150				return;
151			}
152		} else
153			if (bytes(fp, fn, off))
154				return;
155		break;
156	case RLINES:
157		if (S_ISREG(sbp->st_mode))
158			if (!off) {
159				if (fseeko(fp, (off_t)0, SEEK_END) == -1) {
160					ierr(fn);
161					return;
162				}
163			} else
164				rlines(fp, fn, off, sbp);
165		else if (off == 0) {
166			while (getc(fp) != EOF);
167			if (ferror(fp)) {
168				ierr(fn);
169				return;
170			}
171		} else
172			if (lines(fp, fn, off))
173				return;
174		break;
175	default:
176		break;
177	}
178
179	while ((ch = getc(fp)) != EOF)
180		if (putchar(ch) == EOF)
181			oerr();
182	if (ferror(fp)) {
183		ierr(fn);
184		return;
185	}
186	(void)fflush(stdout);
187}
188
189/*
190 * rlines -- display the last offset lines of the file.
191 */
192static void
193rlines(FILE *fp, const char *fn, off_t off, struct stat *sbp)
194{
195	struct mapinfo map;
196	off_t curoff, size;
197	int i;
198
199	if (!(size = sbp->st_size))
200		return;
201	map.start = NULL;
202	map.fd = fileno(fp);
203	map.mapoff = map.maxoff = size;
204
205	/*
206	 * Last char is special, ignore whether newline or not. Note that
207	 * size == 0 is dealt with above, and size == 1 sets curoff to -1.
208	 */
209	curoff = size - 2;
210	while (curoff >= 0) {
211		if (curoff < map.mapoff && maparound(&map, curoff) != 0) {
212			ierr(fn);
213			return;
214		}
215		for (i = curoff - map.mapoff; i >= 0; i--)
216			if (map.start[i] == '\n' && --off == 0)
217				break;
218		/* `i' is either the map offset of a '\n', or -1. */
219		curoff = map.mapoff + i;
220		if (i >= 0)
221			break;
222	}
223	curoff++;
224	if (mapprint(&map, curoff, size - curoff) != 0) {
225		ierr(fn);
226		exit(1);
227	}
228
229	/* Set the file pointer to reflect the length displayed. */
230	if (fseeko(fp, sbp->st_size, SEEK_SET) == -1) {
231		ierr(fn);
232		return;
233	}
234	if (map.start != NULL && munmap(map.start, map.maplen)) {
235		ierr(fn);
236		return;
237	}
238}
239
240static int
241show(file_info_t *file)
242{
243	int ch;
244
245	while ((ch = getc(file->fp)) != EOF) {
246		if (last != file && no_files > 1) {
247			if (!qflag)
248				printfn(file->file_name, 1);
249			last = file;
250		}
251		if (putchar(ch) == EOF)
252			oerr();
253	}
254	(void)fflush(stdout);
255	if (ferror(file->fp)) {
256		fclose(file->fp);
257		file->fp = NULL;
258		ierr(file->file_name);
259		return 0;
260	}
261	clearerr(file->fp);
262	return 1;
263}
264
265static void
266set_events(file_info_t *files)
267{
268	int i, n = 0;
269	file_info_t *file;
270	struct timespec ts;
271	struct statfs sf;
272
273	ts.tv_sec = 0;
274	ts.tv_nsec = 0;
275
276	action = USE_KQUEUE;
277	for (i = 0, file = files; i < no_files; i++, file++) {
278		if (! file->fp)
279			continue;
280
281		if (fstatfs(fileno(file->fp), &sf) == 0 &&
282		    (sf.f_flags & MNT_LOCAL) == 0) {
283			action = USE_SLEEP;
284			return;
285		}
286
287		if (Fflag && fileno(file->fp) != STDIN_FILENO) {
288			EV_SET(&ev[n], fileno(file->fp), EVFILT_VNODE,
289			    EV_ADD | EV_ENABLE | EV_CLEAR,
290			    NOTE_DELETE | NOTE_RENAME, 0, 0);
291			n++;
292		}
293		EV_SET(&ev[n], fileno(file->fp), EVFILT_READ,
294		    EV_ADD | EV_ENABLE | EV_CLEAR, 0, 0, 0);
295		n++;
296	}
297
298	if (kevent(kq, ev, n, NULL, 0, &ts) < 0) {
299		action = USE_SLEEP;
300	}
301}
302
303/*
304 * follow -- display the file, from an offset, forward.
305 *
306 */
307void
308follow(file_info_t *files, enum STYLE style, off_t off)
309{
310	int active, ev_change, i, n = -1;
311	struct stat sb2;
312	file_info_t *file;
313	struct timespec ts;
314
315	/* Position each of the files */
316
317	file = files;
318	active = 0;
319	n = 0;
320	for (i = 0; i < no_files; i++, file++) {
321		if (file->fp) {
322			active = 1;
323			n++;
324			if (no_files > 1 && !qflag)
325				printfn(file->file_name, 1);
326			forward(file->fp, file->file_name, style, off, &file->st);
327			if (Fflag && fileno(file->fp) != STDIN_FILENO)
328				n++;
329		}
330	}
331	if (!Fflag && !active)
332		return;
333
334	last = --file;
335
336	kq = kqueue();
337	if (kq < 0)
338		err(1, "kqueue");
339	ev = malloc(n * sizeof(struct kevent));
340	if (! ev)
341	    err(1, "Couldn't allocate memory for kevents.");
342	set_events(files);
343
344	for (;;) {
345		ev_change = 0;
346		if (Fflag) {
347			for (i = 0, file = files; i < no_files; i++, file++) {
348				if (!file->fp) {
349					file->fp = fopen(file->file_name, "r");
350					if (file->fp != NULL &&
351					    fstat(fileno(file->fp), &file->st)
352					    == -1) {
353						fclose(file->fp);
354						file->fp = NULL;
355					}
356					if (file->fp != NULL)
357						ev_change++;
358					continue;
359				}
360				if (fileno(file->fp) == STDIN_FILENO)
361					continue;
362				if (stat(file->file_name, &sb2) == -1) {
363					if (errno != ENOENT)
364						ierr(file->file_name);
365					show(file);
366					if (file->fp != NULL) {
367						fclose(file->fp);
368						file->fp = NULL;
369					}
370					ev_change++;
371					continue;
372				}
373
374				if (sb2.st_ino != file->st.st_ino ||
375				    sb2.st_dev != file->st.st_dev ||
376				    sb2.st_nlink == 0) {
377					show(file);
378					file->fp = freopen(file->file_name, "r",
379					    file->fp);
380					if (file->fp != NULL)
381						memcpy(&file->st, &sb2,
382						    sizeof(struct stat));
383					else if (errno != ENOENT)
384						ierr(file->file_name);
385					ev_change++;
386				}
387			}
388		}
389
390		for (i = 0, file = files; i < no_files; i++, file++)
391			if (file->fp && !show(file))
392				ev_change++;
393
394		if (ev_change)
395			set_events(files);
396
397		switch (action) {
398		case USE_KQUEUE:
399			ts.tv_sec = 1;
400			ts.tv_nsec = 0;
401			/*
402			 * In the -F case we set a timeout to ensure that
403			 * we re-stat the file at least once every second.
404			 */
405			n = kevent(kq, NULL, 0, ev, 1, Fflag ? &ts : NULL);
406			if (n < 0)
407				err(1, "kevent");
408			if (n == 0) {
409				/* timeout */
410				break;
411			} else if (ev->filter == EVFILT_READ && ev->data < 0) {
412				/* file shrank, reposition to end */
413				if (lseek(ev->ident, (off_t)0, SEEK_END) == -1) {
414					ierr(file->file_name);
415					continue;
416				}
417			}
418			break;
419
420		case USE_SLEEP:
421			(void) usleep(250000);
422			break;
423		}
424	}
425}
426