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