1 /* 2 * Copyright (C) 1984-2022 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 HAVE_POLL && !MSDOS_COMPILER && !defined(__APPLE__) 40 #define USE_POLL 1 41 #else 42 #define USE_POLL 0 43 #endif 44 #if USE_POLL 45 #include <poll.h> 46 #endif 47 48 /* 49 * BSD setjmp() saves (and longjmp() restores) the signal mask. 50 * This costs a system call or two per setjmp(), so if possible we clear the 51 * signal mask with sigsetmask(), and use _setjmp()/_longjmp() instead. 52 * On other systems, setjmp() doesn't affect the signal mask and so 53 * _setjmp() does not exist; we just use setjmp(). 54 */ 55 #if HAVE__SETJMP && HAVE_SIGSETMASK 56 #define SET_JUMP _setjmp 57 #define LONG_JUMP _longjmp 58 #else 59 #define SET_JUMP setjmp 60 #define LONG_JUMP longjmp 61 #endif 62 63 public int reading; 64 public int consecutive_nulls = 0; 65 66 static jmp_buf read_label; 67 68 extern int sigs; 69 extern int ignore_eoi; 70 extern int exit_F_on_close; 71 #if !MSDOS_COMPILER 72 extern int tty; 73 #endif 74 75 #if USE_POLL 76 /* 77 * Return true if one of the events has occurred on the specified file. 78 */ 79 static int 80 poll_events(fd, events) 81 int fd; 82 int events; 83 { 84 struct pollfd poller = { fd, events, 0 }; 85 int n = poll(&poller, 1, 0); 86 if (n <= 0) 87 return 0; 88 return (poller.revents & events); 89 } 90 #endif 91 92 /* 93 * Like read() system call, but is deliberately interruptible. 94 * A call to intread() from a signal handler will interrupt 95 * any pending iread(). 96 */ 97 public int 98 iread(fd, buf, len) 99 int fd; 100 unsigned char *buf; 101 unsigned int len; 102 { 103 int n; 104 105 start: 106 #if MSDOS_COMPILER==WIN32C 107 if (ABORT_SIGS()) 108 return (READ_INTR); 109 #else 110 #if MSDOS_COMPILER && MSDOS_COMPILER != DJGPPC 111 if (kbhit()) 112 { 113 int c; 114 115 c = getch(); 116 if (c == '\003') 117 return (READ_INTR); 118 ungetch(c); 119 } 120 #endif 121 #endif 122 if (SET_JUMP(read_label)) 123 { 124 /* 125 * We jumped here from intread. 126 */ 127 reading = 0; 128 #if HAVE_SIGPROCMASK 129 { 130 sigset_t mask; 131 sigemptyset(&mask); 132 sigprocmask(SIG_SETMASK, &mask, NULL); 133 } 134 #else 135 #if HAVE_SIGSETMASK 136 sigsetmask(0); 137 #else 138 #ifdef _OSK 139 sigmask(~0); 140 #endif 141 #endif 142 #endif 143 return (READ_INTR); 144 } 145 146 flush(); 147 reading = 1; 148 #if MSDOS_COMPILER==DJGPPC 149 if (isatty(fd)) 150 { 151 /* 152 * Don't try reading from a TTY until a character is 153 * available, because that makes some background programs 154 * believe DOS is busy in a way that prevents those 155 * programs from working while "less" waits. 156 */ 157 fd_set readfds; 158 159 FD_ZERO(&readfds); 160 FD_SET(fd, &readfds); 161 if (select(fd+1, &readfds, 0, 0, 0) == -1) 162 { 163 reading = 0; 164 return (-1); 165 } 166 } 167 #endif 168 #if USE_POLL 169 if (ignore_eoi && fd != tty) 170 { 171 int close_events = exit_F_on_close ? POLLERR|POLLHUP : POLLERR; 172 if (poll_events(tty, POLLIN) && getchr() == CONTROL('X')) 173 { 174 sigs |= S_INTERRUPT; 175 reading = 0; 176 return (READ_INTR); 177 } 178 if (poll_events(fd, close_events)) 179 { 180 sigs |= S_INTERRUPT; 181 reading = 0; 182 return (READ_INTR); 183 } 184 } 185 #else 186 #if MSDOS_COMPILER==WIN32C 187 if (win32_kbhit() && WIN32getch() == CONTROL('X')) 188 { 189 sigs |= S_INTERRUPT; 190 reading = 0; 191 return (READ_INTR); 192 } 193 #endif 194 #endif 195 n = read(fd, buf, len); 196 reading = 0; 197 #if 1 198 /* 199 * This is a kludge to workaround a problem on some systems 200 * where terminating a remote tty connection causes read() to 201 * start returning 0 forever, instead of -1. 202 */ 203 { 204 if (!ignore_eoi) 205 { 206 if (n == 0) 207 consecutive_nulls++; 208 else 209 consecutive_nulls = 0; 210 if (consecutive_nulls > 20) 211 quit(QUIT_ERROR); 212 } 213 } 214 #endif 215 if (n < 0) 216 { 217 #if HAVE_ERRNO 218 /* 219 * Certain values of errno indicate we should just retry the read. 220 */ 221 #if MUST_DEFINE_ERRNO 222 extern int errno; 223 #endif 224 #ifdef EINTR 225 if (errno == EINTR) 226 goto start; 227 #endif 228 #ifdef EAGAIN 229 if (errno == EAGAIN) 230 goto start; 231 #endif 232 #endif 233 return (-1); 234 } 235 return (n); 236 } 237 238 /* 239 * Interrupt a pending iread(). 240 */ 241 public void 242 intread(VOID_PARAM) 243 { 244 LONG_JUMP(read_label, 1); 245 } 246 247 /* 248 * Return the current time. 249 */ 250 #if HAVE_TIME 251 public time_type 252 get_time(VOID_PARAM) 253 { 254 time_type t; 255 256 time(&t); 257 return (t); 258 } 259 #endif 260 261 262 #if !HAVE_STRERROR 263 /* 264 * Local version of strerror, if not available from the system. 265 */ 266 static char * 267 strerror(err) 268 int err; 269 { 270 static char buf[INT_STRLEN_BOUND(int)+12]; 271 #if HAVE_SYS_ERRLIST 272 extern char *sys_errlist[]; 273 extern int sys_nerr; 274 275 if (err < sys_nerr) 276 return sys_errlist[err]; 277 #endif 278 sprintf(buf, "Error %d", err); 279 return buf; 280 } 281 #endif 282 283 /* 284 * errno_message: Return an error message based on the value of "errno". 285 */ 286 public char * 287 errno_message(filename) 288 char *filename; 289 { 290 char *p; 291 char *m; 292 int len; 293 #if HAVE_ERRNO 294 #if MUST_DEFINE_ERRNO 295 extern int errno; 296 #endif 297 p = strerror(errno); 298 #else 299 p = "cannot open"; 300 #endif 301 len = (int) (strlen(filename) + strlen(p) + 3); 302 m = (char *) ecalloc(len, sizeof(char)); 303 SNPRINTF2(m, len, "%s: %s", filename, p); 304 return (m); 305 } 306 307 /* #define HAVE_FLOAT 0 */ 308 309 static POSITION 310 muldiv(val, num, den) 311 POSITION val, num, den; 312 { 313 #if HAVE_FLOAT 314 double v = (((double) val) * num) / den; 315 return ((POSITION) (v + 0.5)); 316 #else 317 POSITION v = ((POSITION) val) * num; 318 319 if (v / num == val) 320 /* No overflow */ 321 return (POSITION) (v / den); 322 else 323 /* Above calculation overflows; 324 * use a method that is less precise but won't overflow. */ 325 return (POSITION) (val / (den / num)); 326 #endif 327 } 328 329 /* 330 * Return the ratio of two POSITIONS, as a percentage. 331 * {{ Assumes a POSITION is a long int. }} 332 */ 333 public int 334 percentage(num, den) 335 POSITION num; 336 POSITION den; 337 { 338 return (int) muldiv(num, (POSITION) 100, den); 339 } 340 341 /* 342 * Return the specified percentage of a POSITION. 343 */ 344 public POSITION 345 percent_pos(pos, percent, fraction) 346 POSITION pos; 347 int percent; 348 long fraction; 349 { 350 /* Change percent (parts per 100) to perden (parts per NUM_FRAC_DENOM). */ 351 POSITION perden = (percent * (NUM_FRAC_DENOM / 100)) + (fraction / 100); 352 353 if (perden == 0) 354 return (0); 355 return (POSITION) muldiv(pos, perden, (POSITION) NUM_FRAC_DENOM); 356 } 357 358 #if !HAVE_STRCHR 359 /* 360 * strchr is used by regexp.c. 361 */ 362 char * 363 strchr(s, c) 364 char *s; 365 int c; 366 { 367 for ( ; *s != '\0'; s++) 368 if (*s == c) 369 return (s); 370 if (c == '\0') 371 return (s); 372 return (NULL); 373 } 374 #endif 375 376 #if !HAVE_MEMCPY 377 VOID_POINTER 378 memcpy(dst, src, len) 379 VOID_POINTER dst; 380 VOID_POINTER src; 381 int len; 382 { 383 char *dstp = (char *) dst; 384 char *srcp = (char *) src; 385 int i; 386 387 for (i = 0; i < len; i++) 388 dstp[i] = srcp[i]; 389 return (dst); 390 } 391 #endif 392 393 #ifdef _OSK_MWC32 394 395 /* 396 * This implements an ANSI-style intercept setup for Microware C 3.2 397 */ 398 public int 399 os9_signal(type, handler) 400 int type; 401 RETSIGTYPE (*handler)(); 402 { 403 intercept(handler); 404 } 405 406 #include <sgstat.h> 407 408 int 409 isatty(f) 410 int f; 411 { 412 struct sgbuf sgbuf; 413 414 if (_gs_opt(f, &sgbuf) < 0) 415 return -1; 416 return (sgbuf.sg_class == 0); 417 } 418 419 #endif 420 421 public void 422 sleep_ms(ms) 423 int ms; 424 { 425 #if MSDOS_COMPILER==WIN32C 426 Sleep(ms); 427 #else 428 #if HAVE_NANOSLEEP 429 int sec = ms / 1000; 430 struct timespec t = { sec, (ms - sec*1000) * 1000000 }; 431 nanosleep(&t, NULL); 432 #else 433 #if HAVE_USLEEP 434 usleep(ms); 435 #else 436 sleep((ms+999) / 1000); 437 #endif 438 #endif 439 #endif 440 } 441