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