Debian Codegraph @

src/execve.c

raw
1 /*
2 libfakechroot -- fake chroot environment
3 Copyright (c) 2010-2015 Piotr Roszatycki <[email protected]>
4
5 This library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
9
10 This library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Lesser General Public License for more details.
14
15 You should have received a copy of the GNU Lesser General Public
16 License along with this library; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 */
19
20
21 #include <config.h>
22
23 #include <errno.h>
24 #include <stddef.h>
25 #include <unistd.h>
26 #ifdef HAVE_ALLOCA_H
27 # include <alloca.h>
28 #endif
29 #include <stdlib.h>
30 #include <fcntl.h>
31 #include "strchrnul.h"
32 #include "libfakechroot.h"
33 #include "open.h"
34 #include "setenv.h"
35 #include "readlink.h"
36
37
38 wrapper(execve, int, (const char * filename, char * const argv [], char * const envp []))
39 {
40 char fakechroot_abspath[FAKECHROOT_PATH_MAX];
41 char fakechroot_buf[FAKECHROOT_PATH_MAX];
42
43 int status;
44 int file;
45 int is_base_orig = 0;
46 char hashbang[FAKECHROOT_PATH_MAX];
47 size_t argv_max = 1024;
48 char **newenvp, **ep;
49 char *key, *env;
50 char tmpkey[1024], *tp;
51 char *cmdorig;
52 char tmp[FAKECHROOT_PATH_MAX];
53 char substfilename[FAKECHROOT_PATH_MAX];
54 char newfilename[FAKECHROOT_PATH_MAX];
55 char argv0[FAKECHROOT_PATH_MAX];
56 unsigned int i, j, n, newenvppos;
57 unsigned int do_cmd_subst = 0;
58 size_t sizeenvp;
59 char c;
60
61 const char **newargv = alloca(argv_max * sizeof (const char *));
62
63 char *elfloader = getenv("FAKECHROOT_ELFLOADER");
64 char *elfloader_opt_argv0 = getenv("FAKECHROOT_ELFLOADER_OPT_ARGV0");
65 if (elfloader && !*elfloader) elfloader = NULL;
66 if (elfloader_opt_argv0 && !*elfloader_opt_argv0) elfloader_opt_argv0 = NULL;
67
68 debug("execve(\"%s\", {\"%s\", ...}, {\"%s\", ...})", filename, argv[0], envp ? envp[0] : "(null)");
69
70 strncpy(argv0, filename, FAKECHROOT_PATH_MAX - 1);
71
72 /* Substitute command only if FAKECHROOT_CMD_ORIG is not set. Unset variable if it is empty. */
73 cmdorig = getenv("FAKECHROOT_CMD_ORIG");
74 if (cmdorig == NULL)
75 do_cmd_subst = fakechroot_try_cmd_subst(getenv("FAKECHROOT_CMD_SUBST"), argv0, substfilename);
76 else if (!*cmdorig)
77 unsetenv("FAKECHROOT_CMD_ORIG");
78
79 /* Scan envp and check its size */
80 sizeenvp = 0;
81 if (envp) {
82 for (ep = (char **)envp; *ep != NULL; ++ep) {
83 sizeenvp++;
84 }
85 }
86
87 /* Copy envp to newenvp */
88 newenvp = malloc( (sizeenvp + preserve_env_list_count + 1) * sizeof (char *) );
89 if (newenvp == NULL) {
90 __set_errno(ENOMEM);
91 return -1;
92 }
93 newenvppos = 0;
94
95 /* Create new envp */
96 newenvp[newenvppos] = malloc(strlen("FAKECHROOT=true") + 1);
97 strcpy(newenvp[newenvppos], "FAKECHROOT=true");
98 newenvppos++;
99
100 /* Preserve old environment variables if not overwritten by new */
101 for (j = 0; j < preserve_env_list_count; j++) {
102 key = preserve_env_list[j];
103 env = getenv(key);
104 if (env != NULL && *env) {
105 if (do_cmd_subst && strcmp(key, "FAKECHROOT_BASE") == 0) {
106 key = "FAKECHROOT_BASE_ORIG";
107 is_base_orig = 1;
108 }
109 if (envp) {
110 for (ep = (char **) envp; *ep != NULL; ++ep) {
111 strncpy(tmpkey, *ep, 1024);
112 tmpkey[1023] = 0;
113 if ((tp = strchr(tmpkey, '=')) != NULL) {
114 *tp = 0;
115 if (strcmp(tmpkey, key) == 0) {
116 goto skip1;
117 }
118 }
119 }
120 }
121 newenvp[newenvppos] = malloc(strlen(key) + strlen(env) + 3);
122 strcpy(newenvp[newenvppos], key);
123 strcat(newenvp[newenvppos], "=");
124 strcat(newenvp[newenvppos], env);
125 newenvppos++;
126 skip1: ;
127 }
128 }
129
130 /* Append old envp to new envp */
131 if (envp) {
132 for (ep = (char **) envp; *ep != NULL; ++ep) {
133 strncpy(tmpkey, *ep, 1024);
134 tmpkey[1023] = 0;
135 if ((tp = strchr(tmpkey, '=')) != NULL) {
136 *tp = 0;
137 if (strcmp(tmpkey, "FAKECHROOT") == 0 ||
138 (is_base_orig && strcmp(tmpkey, "FAKECHROOT_BASE") == 0))
139 {
140 goto skip2;
141 }
142 }
143 newenvp[newenvppos] = *ep;
144 newenvppos++;
145 skip2: ;
146 }
147 }
148
149 newenvp[newenvppos] = NULL;
150
151 if (newenvp == NULL) {
152 __set_errno(ENOMEM);
153 return -1;
154 }
155
156 if (do_cmd_subst) {
157 newenvp[newenvppos] = malloc(strlen("FAKECHROOT_CMD_ORIG=") + strlen(filename) + 1);
158 strcpy(newenvp[newenvppos], "FAKECHROOT_CMD_ORIG=");
159 strcat(newenvp[newenvppos], filename);
160 newenvppos++;
161 }
162
163 newenvp[newenvppos] = NULL;
164
165 /* Exec substituted command */
166 if (do_cmd_subst) {
167 debug("nextcall(execve)(\"%s\", {\"%s\", ...}, {\"%s\", ...})", substfilename, argv[0], newenvp[0]);
168 status = nextcall(execve)(substfilename, (char * const *)argv, newenvp);
169 goto error;
170 }
171
172 /* Check hashbang */
173 expand_chroot_path(filename);
174 strcpy(tmp, filename);
175 filename = tmp;
176
177 if ((file = nextcall(open)(filename, O_RDONLY)) == -1) {
178 __set_errno(ENOENT);
179 return -1;
180 }
181
182 i = read(file, hashbang, FAKECHROOT_PATH_MAX-2);
183 close(file);
184 if (i == -1) {
185 __set_errno(ENOENT);
186 return -1;
187 }
188
189 /* No hashbang in argv */
190 if (hashbang[0] != '#' || hashbang[1] != '!') {
191 if (!elfloader) {
192 status = nextcall(execve)(filename, argv, newenvp);
193 goto error;
194 }
195
196 /* Run via elfloader */
197 for (i = 0, n = (elfloader_opt_argv0 ? 3 : 1); argv[i] != NULL && i < argv_max; ) {
198 newargv[n++] = argv[i++];
199 }
200
201 newargv[n] = 0;
202
203 n = 0;
204 newargv[n++] = elfloader;
205 if (elfloader_opt_argv0) {
206 newargv[n++] = elfloader_opt_argv0;
207 newargv[n++] = argv0;
208 }
209 newargv[n] = filename;
210
211 debug("nextcall(execve)(\"%s\", {\"%s\", \"%s\", ...}, {\"%s\", ...})", elfloader, newargv[0], newargv[n], newenvp[0]);
212 status = nextcall(execve)(elfloader, (char * const *)newargv, newenvp);
213 goto error;
214 }
215
216 /* For hashbang we must fix argv[0] */
217 hashbang[i] = hashbang[i+1] = 0;
218 for (i = j = 2; (hashbang[i] == ' ' || hashbang[i] == '\t') && i < FAKECHROOT_PATH_MAX; i++, j++);
219 for (n = 0; i < FAKECHROOT_PATH_MAX; i++) {
220 c = hashbang[i];
221 if (hashbang[i] == 0 || hashbang[i] == ' ' || hashbang[i] == '\t' || hashbang[i] == '\n') {
222 hashbang[i] = 0;
223 if (i > j) {
224 if (n == 0) {
225 const char *ptr = &hashbang[j];
226 expand_chroot_path(ptr);
227 strcpy(newfilename, ptr);
228 }
229 newargv[n++] = &hashbang[j];
230 }
231 j = i + 1;
232 }
233 if (c == '\n' || c == 0)
234 break;
235 }
236
237 newargv[n++] = argv0;
238
239 for (i = 1; argv[i] != NULL && i < argv_max; ) {
240 newargv[n++] = argv[i++];
241 }
242
243 newargv[n] = 0;
244
245 if (!elfloader) {
246 status = nextcall(execve)(newfilename, (char * const *)newargv, newenvp);
247 goto error;
248 }
249
250 /* Run via elfloader */
251 j = elfloader_opt_argv0 ? 3 : 1;
252 if (n >= argv_max - 1) {
253 n = argv_max - j - 1;
254 }
255 newargv[n+j] = 0;
256 for (i = n; i >= j; i--) {
257 newargv[i] = newargv[i-j];
258 }
259 n = 0;
260 newargv[n++] = elfloader;
261 if (elfloader_opt_argv0) {
262 newargv[n++] = elfloader_opt_argv0;
263 newargv[n++] = argv0;
264 }
265 newargv[n] = newfilename;
266 debug("nextcall(execve)(\"%s\", {\"%s\", \"%s\", \"%s\", ...}, {\"%s\", ...})", elfloader, newargv[0], newargv[1], newargv[n], newenvp[0]);
267 status = nextcall(execve)(elfloader, (char * const *)newargv, newenvp);
268
269 error:
270 free(newenvp);
271
272 return status;
273 }