ipcalc applet by Stephan Linz and Jordan Crouse
[people/mcb30/busybox.git] / init / run_parts.c
1 /* vi: set sw=4 ts=4: */
2 /*
3  * Mini run-parts implementation for busybox
4  *
5  *
6  * Copyright (C) 2001 by Emanuele Aina <emanuele.aina@tiscali.it>
7  *
8  * Based on the Debian run-parts program, version 1.15
9  *   Copyright (C) 1996 Jeff Noxon <jeff@router.patch.net>,
10  *   Copyright (C) 1996-1999 Guy Maor <maor@debian.org>
11  *   
12  *
13  * This program is free software; you can redistribute it and/or modify
14  * it under the terms of the GNU General Public License as published by
15  * the Free Software Foundation; either version 2 of the License, or
16  * (at your option) any later version.
17  *
18  * This program is distributed in the hope that it will be useful,
19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21  * General Public License for more details.
22  *
23  * You should have received a copy of the GNU General Public License
24  * along with this program; if not, write to the Free Software
25  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
26  * 02111-1307 USA
27  *
28  */
29
30 /* This is my first attempt to write a program in C (well, this is my first
31  * attempt to write a program! :-) . */
32
33 /* This piece of code is heavily based on the original version of run-parts,
34  * taken from debian-utils. I've only removed the long options and a the 
35  * report mode. As the original run-parts support only long options, I've
36  * broken compatibility because the BusyBox policy doesn't allow them. 
37  * The supported options are: 
38  * -t                   test. Print the name of the files to be executed, without
39  *                              execute them.
40  * -a ARG               argument. Pass ARG as an argument the program executed. It can 
41  *                              be repeated to pass multiple arguments.
42  * -u MASK              umask. Set the umask of the program executed to MASK. */
43
44 /* TODO 
45  * done - convert calls to error in perror... and remove error()
46  * done - convert malloc/realloc to their x... counterparts 
47  * done - remove catch_sigchld
48  * done - use bb's concat_path_file() 
49  * done - declare run_parts_main() as extern and any other function as static?
50  */
51
52 #include <stdio.h>
53 #include <stdarg.h>
54 #include <stdlib.h>
55 /* #include <sys/types.h> */
56 #include <sys/wait.h>
57 #include <dirent.h>
58 #include <sys/stat.h>
59 #include <unistd.h>
60 #include <getopt.h>
61 #include <string.h>
62 #include <errno.h>
63 #include <ctype.h>
64
65 #include "busybox.h"
66
67 static int test_mode = 0;
68 static int exitstatus = 0;
69
70 static int argcount = 0, argsize = 0;
71 static char **args = 0;
72
73
74 /* set_umask */
75 /* Check and set the umask of the program executed. As stated in the original
76  * run-parts, the octal conversion in libc is not foolproof; it will take the 
77  * 8 and 9 digits under some circumstances. We'll just have to live with it.
78  */
79
80 static void set_umask (void)
81 {
82   int mask, result;
83
84   /*TODO
85    * We must substitute sscanf, according to bb's style guide? */
86   result = sscanf (optarg, "%o", &mask);
87   if ((result != 1) || (mask > 07777) || (mask < 0)) {
88           perror_msg_and_die ("bad umask value");
89   }
90
91   umask (mask);
92 }
93
94 /* add_argument */
95 /* Add an argument to the commands that we will call. Called once for
96    every argument. */
97 static void add_argument (char *newarg)
98 {
99   if (argcount+1 >= argsize) {
100     argsize = argsize ? argsize*2 : 4;
101         /*TODO if we convert to xrealloc we lose the verbose error message */
102         args = realloc(args, argsize * (sizeof(char*)));
103     if (!args) {
104                 perror_msg_and_die ("failed to reallocate memory for arguments");
105         }
106   }
107   args[argcount++] = newarg;
108   args[argcount] = 0;
109 }
110
111 /* valid_name */
112 /* True or false? Is this a valid filename (upper/lower alpha, digits,
113  * underscores, and hyphens only?)
114  */
115
116 static int valid_name (const struct dirent *d)
117 {
118         char *c = d->d_name;
119         while (*c) {
120                 if (!isalnum(*c) && *c!='_' && *c!='-') {
121                         return 0;
122                 }
123                 ++c;
124         }
125         return 1;
126 }
127
128
129 /* run_part */
130 /* Execute a file */
131
132 static void run_part (char *progname)
133 {
134   int result;
135   int pid;
136
137   
138   if ((pid=fork()) < 0) {
139     perror_msg_and_die ("failed to fork");
140   }
141   else if (!pid) {
142     args[0] = progname;
143     execv (progname, args);
144     perror_msg_and_die ("failed to exec %s", progname);
145   }
146
147   if (0) {
148                   
149   } else {
150                   
151                   waitpid(pid, &result, 0);
152   }
153
154   if (WIFEXITED (result) && WEXITSTATUS(result)) {
155                   perror_msg ("%s exited with return code %d", progname, WEXITSTATUS(result));
156                   exitstatus = 1;
157   }
158   else if (WIFSIGNALED (result)) {
159                   perror_msg ("%s exited because of uncaught signal %d", progname,
160                                                   WTERMSIG(result));
161                   exitstatus = 1;
162   }
163 }
164
165 /* run_parts */
166 /* Find the parts to run & call run_part() */
167
168 static void run_parts (char *dir_name)
169 {
170   struct dirent **namelist = 0;
171   char *filename;
172   int entries, i;
173   struct stat st;
174
175   /* -- */
176   
177   /* scandir() isn't POSIX, but it makes things easy. */
178   entries = scandir (dir_name, &namelist, valid_name, alphasort);
179
180   if (entries < 0) {
181     perror_msg_and_die ("failed to open directory %s", dir_name);
182   }
183   
184   for (i = 0; i < entries; i++) {
185
186           /* -- */
187
188           filename = concat_path_file (dir_name, namelist[i]->d_name);
189           
190           if (stat (filename, &st) < 0) {
191                   perror_msg_and_die ("failed to stat component %s", filename);
192           }
193           if (S_ISREG(st.st_mode) && !access (filename, X_OK)) {
194                   if (test_mode)
195                           printf ("run-parts would run %s\n", filename);
196                   else {
197                           run_part (filename);
198                   }
199           }
200
201           else if (!S_ISDIR(st.st_mode)) {
202                   error_msg ("component %s is not an executable plain file",
203                                   filename);
204                   exitstatus = 1;
205           }
206           
207           free (namelist[i]);
208           free (filename);
209   }
210   free (namelist);
211 }
212
213 /* run_parts_main */
214 /* Process options */
215 int run_parts_main (int argc, char *argv[])
216 {
217   umask (022);
218   add_argument(0);
219   
220   for (;;) {
221     int c;
222
223     opterr = 0;
224     c = getopt(argc, argv, "tu:a:");
225         
226     if (c == EOF)
227       break;
228     switch (c) {
229         case 't':               /* Enable test mode */
230                 test_mode = 1;
231                 break;                  
232         case 'u':               /* Set the umask of the programs executed */
233                 set_umask ();
234                 break;
235     case 'a':               /* Pass an argument to the programs */
236                 add_argument (optarg);
237                 break;
238     default:
239                 show_usage();
240     }
241   }
242   
243   /* We require exactly one argument: the directory name */
244   if (optind != (argc - 1)) {
245           show_usage();
246   }
247
248   run_parts (argv[optind]);
249
250   return exitstatus;
251 }