xref: /freebsd/bin/sh/output.c (revision 1e413cf93298b5b97441a21d9a50fdcd0ee9945e)
1 /*-
2  * Copyright (c) 1991, 1993
3  *	The Regents of the University of California.  All rights reserved.
4  *
5  * This code is derived from software contributed to Berkeley by
6  * Kenneth Almquist.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  * 4. Neither the name of the University nor the names of its contributors
17  *    may be used to endorse or promote products derived from this software
18  *    without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30  * SUCH DAMAGE.
31  */
32 
33 #ifndef lint
34 #if 0
35 static char sccsid[] = "@(#)output.c	8.2 (Berkeley) 5/4/95";
36 #endif
37 #endif /* not lint */
38 #include <sys/cdefs.h>
39 __FBSDID("$FreeBSD$");
40 
41 /*
42  * Shell output routines.  We use our own output routines because:
43  *	When a builtin command is interrupted we have to discard
44  *		any pending output.
45  *	When a builtin command appears in back quotes, we want to
46  *		save the output of the command in a region obtained
47  *		via malloc, rather than doing a fork and reading the
48  *		output of the command via a pipe.
49  */
50 
51 #include <stdio.h>	/* defines BUFSIZ */
52 #include <string.h>
53 #include <stdarg.h>
54 #include <errno.h>
55 #include <unistd.h>
56 #include <stdlib.h>
57 
58 #include "shell.h"
59 #include "syntax.h"
60 #include "output.h"
61 #include "memalloc.h"
62 #include "error.h"
63 #include "var.h"
64 
65 
66 #define OUTBUFSIZ BUFSIZ
67 #define BLOCK_OUT -2		/* output to a fixed block of memory */
68 #define MEM_OUT -3		/* output to dynamically allocated memory */
69 #define OUTPUT_ERR 01		/* error occurred on output */
70 
71 static int doformat_wr(void *, const char *, int);
72 
73 struct output output = {NULL, 0, NULL, OUTBUFSIZ, 1, 0};
74 struct output errout = {NULL, 0, NULL, 100, 2, 0};
75 struct output memout = {NULL, 0, NULL, 0, MEM_OUT, 0};
76 struct output *out1 = &output;
77 struct output *out2 = &errout;
78 
79 
80 
81 #ifdef mkinit
82 
83 INCLUDE "output.h"
84 INCLUDE "memalloc.h"
85 
86 RESET {
87 	out1 = &output;
88 	out2 = &errout;
89 	if (memout.buf != NULL) {
90 		ckfree(memout.buf);
91 		memout.buf = NULL;
92 	}
93 }
94 
95 #endif
96 
97 
98 void
99 out1str(const char *p)
100 {
101 	outstr(p, out1);
102 }
103 
104 void
105 out1qstr(const char *p)
106 {
107 	outqstr(p, out1);
108 }
109 
110 void
111 out2str(const char *p)
112 {
113 	outstr(p, out2);
114 }
115 
116 void
117 out2qstr(const char *p)
118 {
119 	outqstr(p, out2);
120 }
121 
122 void
123 outstr(const char *p, struct output *file)
124 {
125 	while (*p)
126 		outc(*p++, file);
127 	if (file == out2)
128 		flushout(file);
129 }
130 
131 /* Like outstr(), but quote for re-input into the shell. */
132 void
133 outqstr(const char *p, struct output *file)
134 {
135 	char ch;
136 
137 	if (p[0] == '\0') {
138 		outstr("''", file);
139 		return;
140 	}
141 	if (p[strcspn(p, "|&;<>()$`\\\"'")] == '\0' && (!ifsset() ||
142 	    p[strcspn(p, ifsval())] == '\0')) {
143 		outstr(p, file);
144 		return;
145 	}
146 
147 	out1c('\'');
148 	while ((ch = *p++) != '\0') {
149 		switch (ch) {
150 		case '\'':
151 			/*
152 			 * Can't quote single quotes inside single quotes;
153 			 * close them, write escaped single quote, open again.
154 			 */
155 			outstr("'\\''", file);
156 			break;
157 		default:
158 			outc(ch, file);
159 		}
160 	}
161 	out1c('\'');
162 }
163 
164 STATIC char out_junk[16];
165 
166 void
167 emptyoutbuf(struct output *dest)
168 {
169 	int offset;
170 
171 	if (dest->fd == BLOCK_OUT) {
172 		dest->nextc = out_junk;
173 		dest->nleft = sizeof out_junk;
174 		dest->flags |= OUTPUT_ERR;
175 	} else if (dest->buf == NULL) {
176 		INTOFF;
177 		dest->buf = ckmalloc(dest->bufsize);
178 		dest->nextc = dest->buf;
179 		dest->nleft = dest->bufsize;
180 		INTON;
181 	} else if (dest->fd == MEM_OUT) {
182 		offset = dest->bufsize;
183 		INTOFF;
184 		dest->bufsize <<= 1;
185 		dest->buf = ckrealloc(dest->buf, dest->bufsize);
186 		dest->nleft = dest->bufsize - offset;
187 		dest->nextc = dest->buf + offset;
188 		INTON;
189 	} else {
190 		flushout(dest);
191 	}
192 	dest->nleft--;
193 }
194 
195 
196 void
197 flushall(void)
198 {
199 	flushout(&output);
200 	flushout(&errout);
201 }
202 
203 
204 void
205 flushout(struct output *dest)
206 {
207 
208 	if (dest->buf == NULL || dest->nextc == dest->buf || dest->fd < 0)
209 		return;
210 	if (xwrite(dest->fd, dest->buf, dest->nextc - dest->buf) < 0)
211 		dest->flags |= OUTPUT_ERR;
212 	dest->nextc = dest->buf;
213 	dest->nleft = dest->bufsize;
214 }
215 
216 
217 void
218 freestdout(void)
219 {
220 	INTOFF;
221 	if (output.buf) {
222 		ckfree(output.buf);
223 		output.buf = NULL;
224 		output.nleft = 0;
225 	}
226 	INTON;
227 }
228 
229 
230 void
231 outfmt(struct output *file, const char *fmt, ...)
232 {
233 	va_list ap;
234 
235 	va_start(ap, fmt);
236 	doformat(file, fmt, ap);
237 	va_end(ap);
238 }
239 
240 
241 void
242 out1fmt(const char *fmt, ...)
243 {
244 	va_list ap;
245 
246 	va_start(ap, fmt);
247 	doformat(out1, fmt, ap);
248 	va_end(ap);
249 }
250 
251 void
252 dprintf(const char *fmt, ...)
253 {
254 	va_list ap;
255 
256 	va_start(ap, fmt);
257 	doformat(out2, fmt, ap);
258 	va_end(ap);
259 	flushout(out2);
260 }
261 
262 void
263 fmtstr(char *outbuf, int length, const char *fmt, ...)
264 {
265 	va_list ap;
266 	struct output strout;
267 
268 	strout.nextc = outbuf;
269 	strout.nleft = length;
270 	strout.fd = BLOCK_OUT;
271 	strout.flags = 0;
272 	va_start(ap, fmt);
273 	doformat(&strout, fmt, ap);
274 	va_end(ap);
275 	outc('\0', &strout);
276 	if (strout.flags & OUTPUT_ERR)
277 		outbuf[length - 1] = '\0';
278 }
279 
280 static int
281 doformat_wr(void *cookie, const char *buf, int len)
282 {
283 	struct output *o;
284 	int origlen;
285 	unsigned char c;
286 
287 	o = (struct output *)cookie;
288 	origlen = len;
289 	while (len-- != 0) {
290 		c = (unsigned char)*buf++;
291 		outc(c, o);
292 	}
293 
294 	return (origlen);
295 }
296 
297 void
298 doformat(struct output *dest, const char *f, va_list ap)
299 {
300 	FILE *fp;
301 
302 	if ((fp = fwopen(dest, doformat_wr)) != NULL) {
303 		vfprintf(fp, f, ap);
304 		fclose(fp);
305 	}
306 }
307 
308 /*
309  * Version of write which resumes after a signal is caught.
310  */
311 
312 int
313 xwrite(int fd, char *buf, int nbytes)
314 {
315 	int ntry;
316 	int i;
317 	int n;
318 
319 	n = nbytes;
320 	ntry = 0;
321 	for (;;) {
322 		i = write(fd, buf, n);
323 		if (i > 0) {
324 			if ((n -= i) <= 0)
325 				return nbytes;
326 			buf += i;
327 			ntry = 0;
328 		} else if (i == 0) {
329 			if (++ntry > 10)
330 				return nbytes - n;
331 		} else if (errno != EINTR) {
332 			return -1;
333 		}
334 	}
335 }
336