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