1 /*-
2 * SPDX-License-Identifier: BSD-3-Clause
3 *
4 * Copyright (c) 1991, 1993
5 * The Regents of the University of California. All rights reserved.
6 *
7 * This code is derived from software contributed to Berkeley by
8 * Kenneth Almquist.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 * 3. Neither the name of the University nor the names of its contributors
19 * may be used to endorse or promote products derived from this software
20 * without specific prior written permission.
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 * SUCH DAMAGE.
33 */
34
35 #include <fcntl.h>
36 #include <stdio.h>
37 #include <stdlib.h>
38 #include <stdarg.h>
39 #include <errno.h>
40
41 #include "shell.h"
42 #include "parser.h"
43 #include "nodes.h"
44 #include "mystring.h"
45 #include "show.h"
46
47
48 #ifdef DEBUG
49 static void shtree(union node *, int, char *, FILE*);
50 static void shcmd(union node *, FILE *);
51 static void sharg(union node *, FILE *);
52 static void indent(int, char *, FILE *);
53 static void trstring(char *);
54
55
56 void
showtree(union node * n)57 showtree(union node *n)
58 {
59 trputs("showtree called\n");
60 shtree(n, 1, NULL, stdout);
61 }
62
63
64 static void
shtree(union node * n,int ind,char * pfx,FILE * fp)65 shtree(union node *n, int ind, char *pfx, FILE *fp)
66 {
67 struct nodelist *lp;
68 const char *s;
69
70 if (n == NULL)
71 return;
72
73 indent(ind, pfx, fp);
74 switch(n->type) {
75 case NSEMI:
76 s = "; ";
77 goto binop;
78 case NAND:
79 s = " && ";
80 goto binop;
81 case NOR:
82 s = " || ";
83 binop:
84 shtree(n->nbinary.ch1, ind, NULL, fp);
85 /* if (ind < 0) */
86 fputs(s, fp);
87 shtree(n->nbinary.ch2, ind, NULL, fp);
88 break;
89 case NCMD:
90 shcmd(n, fp);
91 if (ind >= 0)
92 putc('\n', fp);
93 break;
94 case NPIPE:
95 for (lp = n->npipe.cmdlist ; lp ; lp = lp->next) {
96 shcmd(lp->n, fp);
97 if (lp->next)
98 fputs(" | ", fp);
99 }
100 if (n->npipe.backgnd)
101 fputs(" &", fp);
102 if (ind >= 0)
103 putc('\n', fp);
104 break;
105 default:
106 fprintf(fp, "<node type %d>", n->type);
107 if (ind >= 0)
108 putc('\n', fp);
109 break;
110 }
111 }
112
113
114
115 static void
shcmd(union node * cmd,FILE * fp)116 shcmd(union node *cmd, FILE *fp)
117 {
118 union node *np;
119 int first;
120 const char *s;
121 int dftfd;
122
123 first = 1;
124 for (np = cmd->ncmd.args ; np ; np = np->narg.next) {
125 if (! first)
126 putchar(' ');
127 sharg(np, fp);
128 first = 0;
129 }
130 for (np = cmd->ncmd.redirect ; np ; np = np->nfile.next) {
131 if (! first)
132 putchar(' ');
133 switch (np->nfile.type) {
134 case NTO: s = ">"; dftfd = 1; break;
135 case NAPPEND: s = ">>"; dftfd = 1; break;
136 case NTOFD: s = ">&"; dftfd = 1; break;
137 case NCLOBBER: s = ">|"; dftfd = 1; break;
138 case NFROM: s = "<"; dftfd = 0; break;
139 case NFROMTO: s = "<>"; dftfd = 0; break;
140 case NFROMFD: s = "<&"; dftfd = 0; break;
141 case NHERE: s = "<<"; dftfd = 0; break;
142 case NXHERE: s = "<<"; dftfd = 0; break;
143 default: s = "*error*"; dftfd = 0; break;
144 }
145 if (np->nfile.fd != dftfd)
146 fprintf(fp, "%d", np->nfile.fd);
147 fputs(s, fp);
148 if (np->nfile.type == NTOFD || np->nfile.type == NFROMFD) {
149 if (np->ndup.dupfd >= 0)
150 fprintf(fp, "%d", np->ndup.dupfd);
151 else
152 fprintf(fp, "-");
153 } else if (np->nfile.type == NHERE) {
154 fprintf(fp, "HERE");
155 } else if (np->nfile.type == NXHERE) {
156 fprintf(fp, "XHERE");
157 } else {
158 sharg(np->nfile.fname, fp);
159 }
160 first = 0;
161 }
162 }
163
164
165
166 static void
sharg(union node * arg,FILE * fp)167 sharg(union node *arg, FILE *fp)
168 {
169 char *p;
170 struct nodelist *bqlist;
171 int subtype;
172
173 if (arg->type != NARG) {
174 printf("<node type %d>\n", arg->type);
175 fflush(stdout);
176 abort();
177 }
178 bqlist = arg->narg.backquote;
179 for (p = arg->narg.text ; *p ; p++) {
180 switch (*p) {
181 case CTLESC:
182 putc(*++p, fp);
183 break;
184 case CTLVAR:
185 putc('$', fp);
186 putc('{', fp);
187 subtype = *++p;
188 if (subtype == VSLENGTH)
189 putc('#', fp);
190
191 while (*p != '=')
192 putc(*p++, fp);
193
194 if (subtype & VSNUL)
195 putc(':', fp);
196
197 switch (subtype & VSTYPE) {
198 case VSNORMAL:
199 putc('}', fp);
200 break;
201 case VSMINUS:
202 putc('-', fp);
203 break;
204 case VSPLUS:
205 putc('+', fp);
206 break;
207 case VSQUESTION:
208 putc('?', fp);
209 break;
210 case VSASSIGN:
211 putc('=', fp);
212 break;
213 case VSTRIMLEFT:
214 putc('#', fp);
215 break;
216 case VSTRIMLEFTMAX:
217 putc('#', fp);
218 putc('#', fp);
219 break;
220 case VSTRIMRIGHT:
221 putc('%', fp);
222 break;
223 case VSTRIMRIGHTMAX:
224 putc('%', fp);
225 putc('%', fp);
226 break;
227 case VSLENGTH:
228 break;
229 default:
230 printf("<subtype %d>", subtype);
231 }
232 break;
233 case CTLENDVAR:
234 putc('}', fp);
235 break;
236 case CTLBACKQ:
237 case CTLBACKQ|CTLQUOTE:
238 putc('$', fp);
239 putc('(', fp);
240 shtree(bqlist->n, -1, NULL, fp);
241 putc(')', fp);
242 break;
243 default:
244 putc(*p, fp);
245 break;
246 }
247 }
248 }
249
250
251 static void
indent(int amount,char * pfx,FILE * fp)252 indent(int amount, char *pfx, FILE *fp)
253 {
254 int i;
255
256 for (i = 0 ; i < amount ; i++) {
257 if (pfx && i == amount - 1)
258 fputs(pfx, fp);
259 putc('\t', fp);
260 }
261 }
262
263
264 /*
265 * Debugging stuff.
266 */
267
268
269 static FILE *tracefile;
270 #if DEBUG >= 2
271 int debug = 1;
272 #else
273 int debug = 0;
274 #endif
275
276
277 void
trputc(int c)278 trputc(int c)
279 {
280 if (tracefile == NULL)
281 return;
282 putc(c, tracefile);
283 if (c == '\n')
284 fflush(tracefile);
285 }
286
287
288 void
sh_trace(const char * fmt,...)289 sh_trace(const char *fmt, ...)
290 {
291 va_list va;
292 va_start(va, fmt);
293 if (tracefile != NULL) {
294 (void) vfprintf(tracefile, fmt, va);
295 if (strchr(fmt, '\n'))
296 (void) fflush(tracefile);
297 }
298 va_end(va);
299 }
300
301
302 void
trputs(const char * s)303 trputs(const char *s)
304 {
305 if (tracefile == NULL)
306 return;
307 fputs(s, tracefile);
308 if (strchr(s, '\n'))
309 fflush(tracefile);
310 }
311
312
313 static void
trstring(char * s)314 trstring(char *s)
315 {
316 char *p;
317 char c;
318
319 if (tracefile == NULL)
320 return;
321 putc('"', tracefile);
322 for (p = s ; *p ; p++) {
323 switch (*p) {
324 case '\n': c = 'n'; goto backslash;
325 case '\t': c = 't'; goto backslash;
326 case '\r': c = 'r'; goto backslash;
327 case '"': c = '"'; goto backslash;
328 case '\\': c = '\\'; goto backslash;
329 case CTLESC: c = 'e'; goto backslash;
330 case CTLVAR: c = 'v'; goto backslash;
331 case CTLVAR+CTLQUOTE: c = 'V'; goto backslash;
332 case CTLBACKQ: c = 'q'; goto backslash;
333 case CTLBACKQ+CTLQUOTE: c = 'Q'; goto backslash;
334 backslash: putc('\\', tracefile);
335 putc(c, tracefile);
336 break;
337 default:
338 if (*p >= ' ' && *p <= '~')
339 putc(*p, tracefile);
340 else {
341 putc('\\', tracefile);
342 putc(*p >> 6 & 03, tracefile);
343 putc(*p >> 3 & 07, tracefile);
344 putc(*p & 07, tracefile);
345 }
346 break;
347 }
348 }
349 putc('"', tracefile);
350 }
351
352
353 void
trargs(char ** ap)354 trargs(char **ap)
355 {
356 if (tracefile == NULL)
357 return;
358 while (*ap) {
359 trstring(*ap++);
360 if (*ap)
361 putc(' ', tracefile);
362 else
363 putc('\n', tracefile);
364 }
365 fflush(tracefile);
366 }
367
368
369 void
opentrace(void)370 opentrace(void)
371 {
372 char s[100];
373 int flags;
374
375 if (!debug)
376 return;
377 #ifdef not_this_way
378 {
379 char *p;
380 if ((p = getenv("HOME")) == NULL) {
381 if (geteuid() == 0)
382 p = "/";
383 else
384 p = "/tmp";
385 }
386 strcpy(s, p);
387 strcat(s, "/trace");
388 }
389 #else
390 strcpy(s, "./trace");
391 #endif /* not_this_way */
392 if ((tracefile = fopen(s, "a")) == NULL) {
393 fprintf(stderr, "Can't open %s: %s\n", s, strerror(errno));
394 return;
395 }
396 if ((flags = fcntl(fileno(tracefile), F_GETFL, 0)) >= 0)
397 fcntl(fileno(tracefile), F_SETFL, flags | O_APPEND);
398 fputs("\nTracing started.\n", tracefile);
399 fflush(tracefile);
400 }
401 #endif /* DEBUG */
402