Remove not needed void casts.
[dragonfly.git] / bin / sh / main.c
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  * 3. All advertising materials mentioning features or use of this software
17  *    must display the following acknowledgement:
18  *      This product includes software developed by the University of
19  *      California, Berkeley and its contributors.
20  * 4. Neither the name of the University nor the names of its contributors
21  *    may be used to endorse or promote products derived from this software
22  *    without specific prior written permission.
23  *
24  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34  * SUCH DAMAGE.
35  *
36  * @(#) Copyright (c) 1991, 1993 The Regents of the University of California.  All rights reserved.
37  * @(#)main.c   8.6 (Berkeley) 5/28/95
38  * $FreeBSD: src/bin/sh/main.c,v 1.18.2.3 2002/07/19 04:38:51 tjr Exp $
39  * $DragonFly: src/bin/sh/main.c,v 1.5 2004/11/07 20:54:52 eirikn Exp $
40  */
41
42 #include <stdio.h>
43 #include <signal.h>
44 #include <sys/stat.h>
45 #include <unistd.h>
46 #include <fcntl.h>
47 #include <locale.h>
48 #include <errno.h>
49
50 #include "shell.h"
51 #include "main.h"
52 #include "mail.h"
53 #include "options.h"
54 #include "output.h"
55 #include "parser.h"
56 #include "nodes.h"
57 #include "expand.h"
58 #include "eval.h"
59 #include "jobs.h"
60 #include "input.h"
61 #include "trap.h"
62 #include "var.h"
63 #include "show.h"
64 #include "memalloc.h"
65 #include "error.h"
66 #include "init.h"
67 #include "mystring.h"
68 #include "exec.h"
69 #include "cd.h"
70
71 #define PROFILE 0
72
73 int rootpid;
74 int rootshell;
75 #if PROFILE
76 short profile_buf[16384];
77 extern int etext();
78 #endif
79
80 STATIC void read_profile(const char *);
81 STATIC const char *find_dot_file(const char *);
82
83 /*
84  * Main routine.  We initialize things, parse the arguments, execute
85  * profiles if we're a login shell, and then call cmdloop to execute
86  * commands.  The setjmp call sets up the location to jump to when an
87  * exception occurs.  When an exception occurs the variable "state"
88  * is used to figure out how far we had gotten.
89  */
90
91 int
92 main(int argc, char *argv[])
93 {
94         struct jmploc jmploc;
95         struct stackmark smark;
96         volatile int state;
97         char *shinit;
98
99 #if PROFILE
100         monitor(4, etext, profile_buf, sizeof profile_buf, 50);
101 #endif
102         setlocale(LC_ALL, "");
103         state = 0;
104         if (setjmp(jmploc.loc)) {
105                 /*
106                  * When a shell procedure is executed, we raise the
107                  * exception EXSHELLPROC to clean up before executing
108                  * the shell procedure.
109                  */
110                 switch (exception) {
111                 case EXSHELLPROC:
112                         rootpid = getpid();
113                         rootshell = 1;
114                         minusc = NULL;
115                         state = 3;
116                         break;
117
118                 case EXEXEC:
119                         exitstatus = exerrno;
120                         break;
121
122                 case EXERROR:
123                         exitstatus = 2;
124                         break;
125
126                 default:
127                         break;
128                 }
129
130                 if (exception != EXSHELLPROC) {
131                     if (state == 0 || iflag == 0 || ! rootshell)
132                             exitshell(exitstatus);
133                 }
134                 reset();
135                 if (exception == EXINT) {
136                         out2c('\n');
137                         flushout(&errout);
138                 }
139                 popstackmark(&smark);
140                 FORCEINTON;                             /* enable interrupts */
141                 if (state == 1)
142                         goto state1;
143                 else if (state == 2)
144                         goto state2;
145                 else if (state == 3)
146                         goto state3;
147                 else
148                         goto state4;
149         }
150         handler = &jmploc;
151 #ifdef DEBUG
152         opentrace();
153         trputs("Shell args:  ");  trargs(argv);
154 #endif
155         rootpid = getpid();
156         rootshell = 1;
157         init();
158         setstackmark(&smark);
159         procargs(argc, argv);
160         if (getpwd() == NULL && iflag)
161                 out2str("sh: cannot determine working directory\n");
162         if (argv[0] && argv[0][0] == '-') {
163                 state = 1;
164                 read_profile("/etc/profile");
165 state1:
166                 state = 2;
167                 if (privileged == 0)
168                         read_profile(".profile");
169                 else
170                         read_profile("/etc/suid_profile");
171         }
172 state2:
173         state = 3;
174         if (!privileged && iflag) {
175                 if ((shinit = lookupvar("ENV")) != NULL && *shinit != '\0') {
176                         state = 3;
177                         read_profile(shinit);
178                 }
179         }
180 state3:
181         state = 4;
182         if (minusc) {
183                 evalstring(minusc);
184         }
185         if (sflag || minusc == NULL) {
186 state4: /* XXX ??? - why isn't this before the "if" statement */
187                 cmdloop(1);
188         }
189 #if PROFILE
190         monitor(0);
191 #endif
192         exitshell(exitstatus);
193         /*NOTREACHED*/
194         return 0;
195 }
196
197
198 /*
199  * Read and execute commands.  "Top" is nonzero for the top level command
200  * loop; it turns on prompting if the shell is interactive.
201  */
202
203 void
204 cmdloop(int top)
205 {
206         union node *n;
207         struct stackmark smark;
208         int inter;
209         int numeof = 0;
210
211         TRACE(("cmdloop(%d) called\n", top));
212         setstackmark(&smark);
213         for (;;) {
214                 if (pendingsigs)
215                         dotrap();
216                 inter = 0;
217                 if (iflag && top) {
218                         inter++;
219                         showjobs(1, 0, 0);
220                         chkmail(0);
221                         flushout(&output);
222                 }
223                 n = parsecmd(inter);
224                 /* showtree(n); DEBUG */
225                 if (n == NEOF) {
226                         if (!top || numeof >= 50)
227                                 break;
228                         if (!stoppedjobs()) {
229                                 if (!Iflag)
230                                         break;
231                                 out2str("\nUse \"exit\" to leave shell.\n");
232                         }
233                         numeof++;
234                 } else if (n != NULL && nflag == 0) {
235                         job_warning = (job_warning == 2) ? 1 : 0;
236                         numeof = 0;
237                         evaltree(n, 0);
238                 }
239                 popstackmark(&smark);
240                 setstackmark(&smark);
241                 if (evalskip == SKIPFILE) {
242                         evalskip = 0;
243                         break;
244                 }
245         }
246         popstackmark(&smark);
247 }
248
249
250
251 /*
252  * Read /etc/profile or .profile.  Return on error.
253  */
254
255 STATIC void
256 read_profile(const char *name)
257 {
258         int fd;
259
260         INTOFF;
261         if ((fd = open(name, O_RDONLY)) >= 0)
262                 setinputfd(fd, 1);
263         INTON;
264         if (fd < 0)
265                 return;
266         cmdloop(0);
267         popfile();
268 }
269
270
271
272 /*
273  * Read a file containing shell functions.
274  */
275
276 void
277 readcmdfile(char *name)
278 {
279         int fd;
280
281         INTOFF;
282         if ((fd = open(name, O_RDONLY)) >= 0)
283                 setinputfd(fd, 1);
284         else
285                 error("Can't open %s: %s", name, strerror(errno));
286         INTON;
287         cmdloop(0);
288         popfile();
289 }
290
291
292
293 /*
294  * Take commands from a file.  To be compatible we should do a path
295  * search for the file, which is necessary to find sub-commands.
296  */
297
298
299 STATIC const char *
300 find_dot_file(const char *basename)
301 {
302         static char localname[FILENAME_MAX+1];
303         char *fullname;
304         const char *path = pathval();
305         struct stat statb;
306
307         /* don't try this for absolute or relative paths */
308         if( strchr(basename, '/'))
309                 return basename;
310
311         while ((fullname = padvance(&path, basename)) != NULL) {
312                 strcpy(localname, fullname);
313                 stunalloc(fullname);
314                 if ((stat(fullname, &statb) == 0) && S_ISREG(statb.st_mode))
315                         return localname;
316         }
317         return basename;
318 }
319
320 int
321 dotcmd(int argc, char **argv)
322 {
323         struct strlist *sp;
324         exitstatus = 0;
325
326         for (sp = cmdenviron; sp ; sp = sp->next)
327                 setvareq(savestr(sp->text), VSTRFIXED|VTEXTFIXED);
328
329         if (argc >= 2) {                /* That's what SVR2 does */
330                 const char *fullname = find_dot_file(argv[1]);
331
332                 setinputfile(fullname, 1);
333                 commandname = fullname;
334                 cmdloop(0);
335                 popfile();
336         }
337         return exitstatus;
338 }
339
340
341 int
342 exitcmd(int argc, char **argv)
343 {
344         extern int oexitstatus;
345
346         if (stoppedjobs())
347                 return 0;
348         if (argc > 1)
349                 exitstatus = number(argv[1]);
350         else
351                 exitstatus = oexitstatus;
352         exitshell(exitstatus);
353         /*NOTREACHED*/
354         return 0;
355 }