xref: /netbsd-src/external/bsd/less/dist/os.c (revision 0c995ed233527eb317227bbcd15c7a49f6473eac)
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
47 static int use_poll = TRUE;
48 #else
49 #define USE_POLL 0
50 #endif
51 #if USE_POLL
52 #include <poll.h>
53 static 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 
71 public int reading;
72 public int waiting_for_data;
73 public int consecutive_nulls = 0;
74 
75 /* Milliseconds to wait for data before displaying "waiting for data" message. */
76 static int waiting_for_data_delay = 4000;
77 static jmp_buf read_label;
78 
79 extern int sigs;
80 extern int ignore_eoi;
81 extern int exit_F_on_close;
82 extern int follow_mode;
83 extern int scanning_eof;
84 extern char intr_char;
85 #if !MSDOS_COMPILER
86 extern int tty;
87 #endif
88 #if LESSTEST
89 extern char *ttyin_name;
90 #endif /*LESSTEST*/
91 
init_poll(void)92 public 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  */
check_poll(int fd,int tty)115 static 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 
supports_ctrl_x(void)153 public 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  */
iread(int fd,unsigned char * buf,unsigned int len)167 public int iread(int fd, unsigned char *buf, unsigned int len)
168 {
169 	int n;
170 
171 start:
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  */
intread(void)319 public void intread(void)
320 {
321 	LONG_JUMP(read_label, 1);
322 }
323 
324 /*
325  * Return the current time.
326  */
327 #if HAVE_TIME
get_time(void)328 public 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  */
strerror(int err)342 static 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  */
errno_message(char * filename)360 public 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  */
signal_message(int sig)383 public 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  */
muldiv(uintmax val,uintmax num,uintmax den)400 public 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  */
percentage(POSITION num,POSITION den)419 public 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  */
percent_pos(POSITION pos,int percent,long fraction)430 public 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  */
strchr(char * s,char c)445 char * 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
memcpy(void * dst,void * src,int len)457 void * 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  */
os9_signal(int type,RETSIGTYPE (* handler)())474 public int os9_signal(int type, RETSIGTYPE (*handler)())
475 {
476 	intercept(handler);
477 }
478 
479 #include <sgstat.h>
480 
isatty(int f)481 int 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 
sleep_ms(int ms)492 public 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