xref: /freebsd/contrib/less/os.c (revision 195ebc7e9e4b129de810833791a19dfb4349d6a9)
1 /*
2  * Copyright (C) 1984-2008  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 about less, or for information on how to
8  * contact the author, see the README file.
9  */
10 
11 
12 /*
13  * Operating system dependent routines.
14  *
15  * Most of the stuff in here is based on Unix, but an attempt
16  * has been made to make things work on other operating systems.
17  * This will sometimes result in a loss of functionality, unless
18  * someone rewrites code specifically for the new operating system.
19  *
20  * The makefile provides defines to decide whether various
21  * Unix features are present.
22  */
23 
24 #include "less.h"
25 #include <signal.h>
26 #include <setjmp.h>
27 #if HAVE_TIME_H
28 #include <time.h>
29 #endif
30 #if HAVE_ERRNO_H
31 #include <errno.h>
32 #endif
33 #if HAVE_VALUES_H
34 #include <values.h>
35 #endif
36 
37 #if HAVE_TIME_T
38 #define time_type	time_t
39 #else
40 #define	time_type	long
41 #endif
42 
43 /*
44  * BSD setjmp() saves (and longjmp() restores) the signal mask.
45  * This costs a system call or two per setjmp(), so if possible we clear the
46  * signal mask with sigsetmask(), and use _setjmp()/_longjmp() instead.
47  * On other systems, setjmp() doesn't affect the signal mask and so
48  * _setjmp() does not exist; we just use setjmp().
49  */
50 #if HAVE__SETJMP && HAVE_SIGSETMASK
51 #define SET_JUMP	_setjmp
52 #define LONG_JUMP	_longjmp
53 #else
54 #define SET_JUMP	setjmp
55 #define LONG_JUMP	longjmp
56 #endif
57 
58 public int reading;
59 
60 static jmp_buf read_label;
61 
62 extern int sigs;
63 
64 /*
65  * Like read() system call, but is deliberately interruptible.
66  * A call to intread() from a signal handler will interrupt
67  * any pending iread().
68  */
69 	public int
70 iread(fd, buf, len)
71 	int fd;
72 	char *buf;
73 	unsigned int len;
74 {
75 	register int n;
76 
77 start:
78 #if MSDOS_COMPILER==WIN32C
79 	if (ABORT_SIGS())
80 		return (READ_INTR);
81 #else
82 #if MSDOS_COMPILER && MSDOS_COMPILER != DJGPPC
83 	if (kbhit())
84 	{
85 		int c;
86 
87 		c = getch();
88 		if (c == '\003')
89 			return (READ_INTR);
90 		ungetch(c);
91 	}
92 #endif
93 #endif
94 	if (SET_JUMP(read_label))
95 	{
96 		/*
97 		 * We jumped here from intread.
98 		 */
99 		reading = 0;
100 #if HAVE_SIGPROCMASK
101 		{
102 		  sigset_t mask;
103 		  sigemptyset(&mask);
104 		  sigprocmask(SIG_SETMASK, &mask, NULL);
105 		}
106 #else
107 #if HAVE_SIGSETMASK
108 		sigsetmask(0);
109 #else
110 #ifdef _OSK
111 		sigmask(~0);
112 #endif
113 #endif
114 #endif
115 		return (READ_INTR);
116 	}
117 
118 	flush();
119 	reading = 1;
120 #if MSDOS_COMPILER==DJGPPC
121 	if (isatty(fd))
122 	{
123 		/*
124 		 * Don't try reading from a TTY until a character is
125 		 * available, because that makes some background programs
126 		 * believe DOS is busy in a way that prevents those
127 		 * programs from working while "less" waits.
128 		 */
129 		fd_set readfds;
130 
131 		FD_ZERO(&readfds);
132 		FD_SET(fd, &readfds);
133 		if (select(fd+1, &readfds, 0, 0, 0) == -1)
134 			return (-1);
135 	}
136 #endif
137 	n = read(fd, buf, len);
138 #if 1
139 	/*
140 	 * This is a kludge to workaround a problem on some systems
141 	 * where terminating a remote tty connection causes read() to
142 	 * start returning 0 forever, instead of -1.
143 	 */
144 	{
145 		extern int ignore_eoi;
146 		if (!ignore_eoi)
147 		{
148 			static int consecutive_nulls = 0;
149 			if (n == 0)
150 				consecutive_nulls++;
151 			else
152 				consecutive_nulls = 0;
153 			if (consecutive_nulls > 20)
154 				quit(QUIT_ERROR);
155 		}
156 	}
157 #endif
158 	reading = 0;
159 	if (n < 0)
160 	{
161 #if HAVE_ERRNO
162 		/*
163 		 * Certain values of errno indicate we should just retry the read.
164 		 */
165 #if MUST_DEFINE_ERRNO
166 		extern int errno;
167 #endif
168 #ifdef EINTR
169 		if (errno == EINTR)
170 			goto start;
171 #endif
172 #ifdef EAGAIN
173 		if (errno == EAGAIN)
174 			goto start;
175 #endif
176 #endif
177 		return (-1);
178 	}
179 	return (n);
180 }
181 
182 /*
183  * Interrupt a pending iread().
184  */
185 	public void
186 intread()
187 {
188 	LONG_JUMP(read_label, 1);
189 }
190 
191 /*
192  * Return the current time.
193  */
194 #if HAVE_TIME
195 	public long
196 get_time()
197 {
198 	time_type t;
199 
200 	time(&t);
201 	return (t);
202 }
203 #endif
204 
205 
206 #if !HAVE_STRERROR
207 /*
208  * Local version of strerror, if not available from the system.
209  */
210 	static char *
211 strerror(err)
212 	int err;
213 {
214 #if HAVE_SYS_ERRLIST
215 	static char buf[16];
216 	extern char *sys_errlist[];
217 	extern int sys_nerr;
218 
219 	if (err < sys_nerr)
220 		return sys_errlist[err];
221 	sprintf(buf, "Error %d", err);
222 	return buf;
223 #else
224 	return ("cannot open");
225 #endif
226 }
227 #endif
228 
229 /*
230  * errno_message: Return an error message based on the value of "errno".
231  */
232 	public char *
233 errno_message(filename)
234 	char *filename;
235 {
236 	register char *p;
237 	register char *m;
238 	int len;
239 #if HAVE_ERRNO
240 #if MUST_DEFINE_ERRNO
241 	extern int errno;
242 #endif
243 	p = strerror(errno);
244 #else
245 	p = "cannot open";
246 #endif
247 	len = strlen(filename) + strlen(p) + 3;
248 	m = (char *) ecalloc(len, sizeof(char));
249 	SNPRINTF2(m, len, "%s: %s", filename, p);
250 	return (m);
251 }
252 
253 /*
254  * Return the ratio of two POSITIONS, as a percentage.
255  * {{ Assumes a POSITION is a long int. }}
256  */
257 	public int
258 percentage(num, den)
259 	POSITION num, den;
260 {
261 	POSITION num100 = num * 100;
262 
263 	if (num100 / 100 == num)
264 		return (num100 / den);
265 	else
266 		return (num / (den / 100));
267 }
268 
269 /*
270  * Return the specified percentage of a POSITION.
271  */
272 	public POSITION
273 percent_pos(pos, percent, fraction)
274 	POSITION pos;
275 	int percent;
276 	long fraction;
277 {
278 	/* Change percent (parts per 100) to perden (parts per NUM_FRAC_DENOM). */
279 	long perden = (percent * (NUM_FRAC_DENOM / 100)) + (fraction / 100);
280 	POSITION temp;
281 
282 	if (perden == 0)
283 		return (0);
284 	temp = pos * perden;  /* This might overflow. */
285 	if (temp / perden == pos)
286 		/* No overflow */
287 		return (temp / NUM_FRAC_DENOM);
288 	else
289 		/* Above calculation overflows;
290 		 * use a method that is less precise but won't overflow. */
291 		return (perden * (pos / NUM_FRAC_DENOM));
292 }
293 
294 #if !HAVE_STRCHR
295 /*
296  * strchr is used by regexp.c.
297  */
298 	char *
299 strchr(s, c)
300 	char *s;
301 	int c;
302 {
303 	for ( ;  *s != '\0';  s++)
304 		if (*s == c)
305 			return (s);
306 	if (c == '\0')
307 		return (s);
308 	return (NULL);
309 }
310 #endif
311 
312 #if !HAVE_MEMCPY
313 	VOID_POINTER
314 memcpy(dst, src, len)
315 	VOID_POINTER dst;
316 	VOID_POINTER src;
317 	int len;
318 {
319 	char *dstp = (char *) dst;
320 	char *srcp = (char *) src;
321 	int i;
322 
323 	for (i = 0;  i < len;  i++)
324 		dstp[i] = srcp[i];
325 	return (dst);
326 }
327 #endif
328 
329 #ifdef _OSK_MWC32
330 
331 /*
332  * This implements an ANSI-style intercept setup for Microware C 3.2
333  */
334 	public int
335 os9_signal(type, handler)
336 	int type;
337 	RETSIGTYPE (*handler)();
338 {
339 	intercept(handler);
340 }
341 
342 #include <sgstat.h>
343 
344 	int
345 isatty(f)
346 	int f;
347 {
348 	struct sgbuf sgbuf;
349 
350 	if (_gs_opt(f, &sgbuf) < 0)
351 		return -1;
352 	return (sgbuf.sg_class == 0);
353 }
354 
355 #endif
356