xref: /freebsd/contrib/less/os.c (revision d411c1d6) 
1 /*
2  * Copyright (C) 1984-2023  Mark Nudelman
3  *
4  * You may distribute under the terms of either the GNU General Public
5  * License or the Less License, as specified in the README file.
6  *
7  * For more information, see the README file.
8  */
9 
10 
11 /*
12  * Operating system dependent routines.
13  *
14  * Most of the stuff in here is based on Unix, but an attempt
15  * has been made to make things work on other operating systems.
16  * This will sometimes result in a loss of functionality, unless
17  * someone rewrites code specifically for the new operating system.
18  *
19  * The makefile provides defines to decide whether various
20  * Unix features are present.
21  */
22 
23 #include "less.h"
24 #include <signal.h>
25 #include <setjmp.h>
26 #if MSDOS_COMPILER==WIN32C
27 #include <windows.h>
28 #endif
29 #if HAVE_TIME_H
30 #include <time.h>
31 #endif
32 #if HAVE_ERRNO_H
33 #include <errno.h>
34 #endif
35 #if HAVE_VALUES_H
36 #include <values.h>
37 #endif
38 
39 #if defined(__APPLE__)
40 #include <sys/utsname.h>
41 #endif
42 
43 #if HAVE_POLL && !MSDOS_COMPILER
44 #define USE_POLL 1
45 static int use_poll = TRUE;
46 #else
47 #define USE_POLL 0
48 #endif
49 #if USE_POLL
50 #include <poll.h>
51 #endif
52 
53 /*
54  * BSD setjmp() saves (and longjmp() restores) the signal mask.
55  * This costs a system call or two per setjmp(), so if possible we clear the
56  * signal mask with sigsetmask(), and use _setjmp()/_longjmp() instead.
57  * On other systems, setjmp() doesn't affect the signal mask and so
58  * _setjmp() does not exist; we just use setjmp().
59  */
60 #if HAVE__SETJMP && HAVE_SIGSETMASK
61 #define SET_JUMP        _setjmp
62 #define LONG_JUMP       _longjmp
63 #else
64 #define SET_JUMP        setjmp
65 #define LONG_JUMP       longjmp
66 #endif
67 
68 public int reading;
69 public int waiting_for_data;
70 public int consecutive_nulls = 0;
71 
72 /* Milliseconds to wait for data before displaying "waiting for data" message. */
73 static int waiting_for_data_delay = 4000;
74 static jmp_buf read_label;
75 
76 extern int sigs;
77 extern int ignore_eoi;
78 extern int exit_F_on_close;
79 extern int follow_mode;
80 extern int scanning_eof;
81 extern char intr_char;
82 #if !MSDOS_COMPILER
83 extern int tty;
84 #endif
85 #if LESSTEST
86 extern char *ttyin_name;
87 #endif /*LESSTEST*/
88 
89 public void init_poll(void)
90 {
91     char *delay = lgetenv("LESS_DATA_DELAY");
92     int idelay = (delay == NULL) ? 0 : atoi(delay);
93     if (idelay > 0)
94         waiting_for_data_delay = idelay;
95 #if USE_POLL
96 #if defined(__APPLE__)
97 	/* In old versions of MacOS, poll() does not work with /dev/tty. */
98 	struct utsname uts;
99 	if (uname(&uts) < 0 || lstrtoi(uts.release, NULL, 10) < 20)
100 		use_poll = FALSE;
101 #endif
102 #endif
103 }
104 
105 #if USE_POLL
106 /*
107  * Check whether data is available, either from a file/pipe or from the tty.
108  * Return READ_AGAIN if no data currently available, but caller should retry later.
109  * Return READ_INTR to abort F command (forw_loop).
110  * Return 0 if safe to read from fd.
111  */
112 static int check_poll(int fd, int tty)
113 {
114 	struct pollfd poller[2] = { { fd, POLLIN, 0 }, { tty, POLLIN, 0 } };
115 	int timeout = (waiting_for_data && !(scanning_eof && follow_mode == FOLLOW_NAME)) ? -1 : waiting_for_data_delay;
116 	poll(poller, 2, timeout);
117 #if LESSTEST
118 	if (ttyin_name == NULL) /* Check for ^X only on a real tty. */
119 #endif /*LESSTEST*/
120 	{
121 		if (poller[1].revents & POLLIN)
122 		{
123 			LWCHAR ch = getchr();
124 			if (ch == intr_char)
125 				/* Break out of "waiting for data". */
126 				return (READ_INTR);
127 			ungetcc_back(ch);
128 		}
129 	}
130 	if (ignore_eoi && exit_F_on_close && (poller[0].revents & (POLLHUP|POLLIN)) == POLLHUP)
131 		/* Break out of F loop on HUP due to --exit-follow-on-close. */
132 		return (READ_INTR);
133 	if ((poller[0].revents & (POLLIN|POLLHUP|POLLERR)) == 0)
134 		/* No data available; let caller take action, then try again. */
135 		return (READ_AGAIN);
136 	/* There is data (or HUP/ERR) available. Safe to call read() without blocking. */
137 	return (0);
138 }
139 #endif /* USE_POLL */
140 
141 public int supports_ctrl_x(void)
142 {
143 #if USE_POLL
144 	return (use_poll);
145 #else
146 	return (FALSE);
147 #endif /* USE_POLL */
148 }
149 
150 /*
151  * Like read() system call, but is deliberately interruptible.
152  * A call to intread() from a signal handler will interrupt
153  * any pending iread().
154  */
155 public int iread(int fd, unsigned char *buf, unsigned int len)
156 {
157 	int n;
158 
159 start:
160 #if MSDOS_COMPILER==WIN32C
161 	if (ABORT_SIGS())
162 		return (READ_INTR);
163 #else
164 #if MSDOS_COMPILER && MSDOS_COMPILER != DJGPPC
165 	if (kbhit())
166 	{
167 		int c;
168 
169 		c = getch();
170 		if (c == '\003')
171 			return (READ_INTR);
172 		ungetch(c);
173 	}
174 #endif
175 #endif
176 	if (!reading && SET_JUMP(read_label))
177 	{
178 		/*
179 		 * We jumped here from intread.
180 		 */
181 		reading = 0;
182 #if HAVE_SIGPROCMASK
183 		{
184 		  sigset_t mask;
185 		  sigemptyset(&mask);
186 		  sigprocmask(SIG_SETMASK, &mask, NULL);
187 		}
188 #else
189 #if HAVE_SIGSETMASK
190 		sigsetmask(0);
191 #else
192 #ifdef _OSK
193 		sigmask(~0);
194 #endif
195 #endif
196 #endif
197 		return (READ_INTR);
198 	}
199 
200 	flush();
201 	reading = 1;
202 #if MSDOS_COMPILER==DJGPPC
203 	if (isatty(fd))
204 	{
205 		/*
206 		 * Don't try reading from a TTY until a character is
207 		 * available, because that makes some background programs
208 		 * believe DOS is busy in a way that prevents those
209 		 * programs from working while "less" waits.
210          * {{ This code was added 12 Jan 2007; still needed? }}
211 		 */
212 		fd_set readfds;
213 
214 		FD_ZERO(&readfds);
215 		FD_SET(fd, &readfds);
216 		if (select(fd+1, &readfds, 0, 0, 0) == -1)
217 		{
218 			reading = 0;
219 			return (READ_ERR);
220 		}
221 	}
222 #endif
223 #if USE_POLL
224 	if (fd != tty && use_poll)
225 	{
226 		int ret = check_poll(fd, tty);
227 		if (ret != 0)
228 		{
229 			if (ret == READ_INTR)
230 				sigs |= S_INTERRUPT;
231 			reading = 0;
232 			return (ret);
233 		}
234 	}
235 #else
236 #if MSDOS_COMPILER==WIN32C
237 	if (win32_kbhit() && WIN32getch() == intr_char)
238 	{
239 		sigs |= S_INTERRUPT;
240 		reading = 0;
241 		return (READ_INTR);
242 	}
243 #endif
244 #endif
245 	n = read(fd, buf, len);
246 	reading = 0;
247 #if 1
248 	/*
249 	 * This is a kludge to workaround a problem on some systems
250 	 * where terminating a remote tty connection causes read() to
251 	 * start returning 0 forever, instead of -1.
252 	 */
253 	{
254 		if (!ignore_eoi)
255 		{
256 			if (n == 0)
257 				consecutive_nulls++;
258 			else
259 				consecutive_nulls = 0;
260 			if (consecutive_nulls > 20)
261 				quit(QUIT_ERROR);
262 		}
263 	}
264 #endif
265 	if (n < 0)
266 	{
267 #if HAVE_ERRNO
268 		/*
269 		 * Certain values of errno indicate we should just retry the read.
270 		 */
271 #if MUST_DEFINE_ERRNO
272 		extern int errno;
273 #endif
274 #ifdef EINTR
275 		if (errno == EINTR)
276 			goto start;
277 #endif
278 #ifdef EAGAIN
279 		if (errno == EAGAIN)
280 			goto start;
281 #endif
282 #endif
283 		return (READ_ERR);
284 	}
285 	return (n);
286 }
287 
288 /*
289  * Interrupt a pending iread().
290  */
291 public void intread(void)
292 {
293 	LONG_JUMP(read_label, 1);
294 }
295 
296 /*
297  * Return the current time.
298  */
299 #if HAVE_TIME
300 public time_type get_time(void)
301 {
302 	time_type t;
303 
304 	time(&t);
305 	return (t);
306 }
307 #endif
308 
309 
310 #if !HAVE_STRERROR
311 /*
312  * Local version of strerror, if not available from the system.
313  */
314 static char * strerror(int err)
315 {
316 	static char buf[INT_STRLEN_BOUND(int)+12];
317 #if HAVE_SYS_ERRLIST
318 	extern char *sys_errlist[];
319 	extern int sys_nerr;
320 
321 	if (err < sys_nerr)
322 		return sys_errlist[err];
323 #endif
324 	sprintf(buf, "Error %d", err);
325 	return buf;
326 }
327 #endif
328 
329 /*
330  * errno_message: Return an error message based on the value of "errno".
331  */
332 public char * errno_message(char *filename)
333 {
334 	char *p;
335 	char *m;
336 	int len;
337 #if HAVE_ERRNO
338 #if MUST_DEFINE_ERRNO
339 	extern int errno;
340 #endif
341 	p = strerror(errno);
342 #else
343 	p = "cannot open";
344 #endif
345 	len = (int) (strlen(filename) + strlen(p) + 3);
346 	m = (char *) ecalloc(len, sizeof(char));
347 	SNPRINTF2(m, len, "%s: %s", filename, p);
348 	return (m);
349 }
350 
351 /*
352  * Return a description of a signal.
353  * The return value is good until the next call to this function.
354  */
355 public char * signal_message(int sig)
356 {
357 	static char sigbuf[sizeof("Signal ") + INT_STRLEN_BOUND(sig) + 1];
358 #if HAVE_STRSIGNAL
359 	char *description = strsignal(sig);
360 	if (description)
361 		return description;
362 #endif
363 	sprintf(sigbuf, "Signal %d", sig);
364 	return sigbuf;
365 }
366 
367 /*
368  * Return (VAL * NUM) / DEN, where DEN is positive
369  * and min(VAL, NUM) <= DEN so the result cannot overflow.
370  * Round to the nearest integer, breaking ties by rounding to even.
371  */
372 public uintmax muldiv(uintmax val, uintmax num, uintmax den)
373 {
374 	/*
375 	 * Like round(val * (double) num / den), but without rounding error.
376 	 * Overflow cannot occur, so there is no need for floating point.
377 	 */
378 	uintmax q = val / den;
379 	uintmax r = val % den;
380 	uintmax qnum = q * num;
381 	uintmax rnum = r * num;
382 	uintmax quot = qnum + rnum / den;
383 	uintmax rem = rnum % den;
384 	return quot + (den / 2 < rem + (quot & ~den & 1));
385 }
386 
387 /*
388  * Return the ratio of two POSITIONS, as a percentage.
389  * {{ Assumes a POSITION is a long int. }}
390  */
391 public int percentage(POSITION num, POSITION den)
392 {
393 	return (int) muldiv(num,  (POSITION) 100, den);
394 }
395 
396 /*
397  * Return the specified percentage of a POSITION.
398  * Assume (0 <= POS && 0 <= PERCENT <= 100
399  *	   && 0 <= FRACTION < (PERCENT == 100 ? 1 : NUM_FRAC_DENOM)),
400  * so the result cannot overflow.  Round to even.
401  */
402 public POSITION percent_pos(POSITION pos, int percent, long fraction)
403 {
404 	/*
405 	 * Change from percent (parts per 100)
406 	 * to pctden (parts per 100 * NUM_FRAC_DENOM).
407 	 */
408 	POSITION pctden = (percent * NUM_FRAC_DENOM) + fraction;
409 
410 	return (POSITION) muldiv(pos, pctden, 100 * (POSITION) NUM_FRAC_DENOM);
411 }
412 
413 #if !HAVE_STRCHR
414 /*
415  * strchr is used by regexp.c.
416  */
417 char * strchr(char *s, char c)
418 {
419 	for ( ;  *s != '\0';  s++)
420 		if (*s == c)
421 			return (s);
422 	if (c == '\0')
423 		return (s);
424 	return (NULL);
425 }
426 #endif
427 
428 #if !HAVE_MEMCPY
429 void * memcpy(void *dst, void *src, int len)
430 {
431 	char *dstp = (char *) dst;
432 	char *srcp = (char *) src;
433 	int i;
434 
435 	for (i = 0;  i < len;  i++)
436 		dstp[i] = srcp[i];
437 	return (dst);
438 }
439 #endif
440 
441 #ifdef _OSK_MWC32
442 
443 /*
444  * This implements an ANSI-style intercept setup for Microware C 3.2
445  */
446 public int os9_signal(int type, RETSIGTYPE (*handler)())
447 {
448 	intercept(handler);
449 }
450 
451 #include <sgstat.h>
452 
453 int isatty(int f)
454 {
455 	struct sgbuf sgbuf;
456 
457 	if (_gs_opt(f, &sgbuf) < 0)
458 		return -1;
459 	return (sgbuf.sg_class == 0);
460 }
461 
462 #endif
463 
464 public void sleep_ms(int ms)
465 {
466 #if MSDOS_COMPILER==WIN32C
467 	Sleep(ms);
468 #else
469 #if HAVE_NANOSLEEP
470 	int sec = ms / 1000;
471 	struct timespec t = { sec, (ms - sec*1000) * 1000000 };
472 	nanosleep(&t, NULL);
473 #else
474 #if HAVE_USLEEP
475 	usleep(ms);
476 #else
477 	sleep(ms / 1000 + (ms % 1000 != 0));
478 #endif
479 #endif
480 #endif
481 }
482