1 /*        $NetBSD: netbsd32_execve.c,v 1.44 2021/11/11 17:32:46 martin Exp $    */
2 
3 /*
4  * Copyright (c) 1998, 2001 Matthew R. Green
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  *
16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
21  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
22  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
23  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
24  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26  * SUCH DAMAGE.
27  */
28 
29 #include <sys/cdefs.h>
30 
31 __KERNEL_RCSID(0, "$NetBSD: netbsd32_execve.c,v 1.44 2021/11/11 17:32:46 martin Exp $");
32 
33 #include <sys/param.h>
34 #include <sys/systm.h>
35 #include <sys/atomic.h>
36 #include <sys/mount.h>
37 #include <sys/namei.h>
38 #include <sys/stat.h>
39 #include <sys/spawn.h>
40 #include <sys/uidinfo.h>
41 #include <sys/vnode.h>
42 #include <sys/file.h>
43 #include <sys/filedesc.h>
44 #include <sys/syscallargs.h>
45 #include <sys/proc.h>
46 #include <sys/exec.h>
47 
48 #include <compat/netbsd32/netbsd32.h>
49 #include <compat/netbsd32/netbsd32_syscall.h>
50 #include <compat/netbsd32/netbsd32_syscallargs.h>
51 
52 static int
netbsd32_execve_fetch_element(char * const * array,size_t index,char ** value)53 netbsd32_execve_fetch_element(char * const *array, size_t index, char **value)
54 {
55           int error;
56           netbsd32_charp const *a32 = (void const *)array;
57           netbsd32_charp e;
58 
59           error = copyin(a32 + index, &e, sizeof(e));
60           if (error)
61                     return error;
62           *value = (char *)NETBSD32PTR64(e);
63           return 0;
64 }
65 
66 int
netbsd32_execve(struct lwp * l,const struct netbsd32_execve_args * uap,register_t * retval)67 netbsd32_execve(struct lwp *l, const struct netbsd32_execve_args *uap, register_t *retval)
68 {
69           /* {
70                     syscallarg(const netbsd32_charp) path;
71                     syscallarg(netbsd32_charpp) argp;
72                     syscallarg(netbsd32_charpp) envp;
73           } */
74 
75           return execve1(l, true, SCARG_P32(uap, path), -1, SCARG_P32(uap, argp),
76               SCARG_P32(uap, envp), netbsd32_execve_fetch_element);
77 }
78 
79 int
netbsd32_fexecve(struct lwp * l,const struct netbsd32_fexecve_args * uap,register_t * retval)80 netbsd32_fexecve(struct lwp *l, const struct netbsd32_fexecve_args *uap,
81                      register_t *retval)
82 {
83           /* {
84                     syscallarg(int) fd;
85                     syscallarg(netbsd32_charpp) argp;
86                     syscallarg(netbsd32_charpp) envp;
87           } */
88 
89           return execve1(l, false, NULL, SCARG(uap, fd), SCARG_P32(uap, argp),
90               SCARG_P32(uap, envp), netbsd32_execve_fetch_element);
91 }
92 
93 static __inline bool
netbsd32_posix_spawn_fae_path(struct posix_spawn_file_actions_entry * fae,struct netbsd32_posix_spawn_file_actions_entry * fae32,char *** pathp,char ** pathp32)94 netbsd32_posix_spawn_fae_path(
95     struct posix_spawn_file_actions_entry *fae,
96     struct netbsd32_posix_spawn_file_actions_entry *fae32,
97     char ***pathp, char **pathp32)
98 {
99           switch (fae->fae_action) {
100           case FAE_OPEN:
101                     *pathp = &fae->fae_path;
102                     *pathp32 = NETBSD32PTR64(fae32->fae_data.open.path);
103                     return true;
104           case FAE_CHDIR:
105                     *pathp = &fae->fae_chdir_path;
106                     *pathp32 = NETBSD32PTR64(fae32->fae_data.chdir.path);
107                     return true;
108           default:
109                     return false;
110           }
111 }
112 
113 static int
netbsd32_posix_spawn_fa_alloc(struct posix_spawn_file_actions ** fap,const struct netbsd32_posix_spawn_file_actions * ufa,rlim_t lim)114 netbsd32_posix_spawn_fa_alloc(struct posix_spawn_file_actions **fap,
115     const struct netbsd32_posix_spawn_file_actions *ufa, rlim_t lim)
116 {
117           struct posix_spawn_file_actions *fa;
118           struct netbsd32_posix_spawn_file_actions fa32;
119           struct netbsd32_posix_spawn_file_actions_entry *fae32 = NULL, *f32 = NULL;
120           struct posix_spawn_file_actions_entry *fae;
121           char *pbuf = NULL, **pathp = NULL, *pathp32 = NULL;
122           int error;
123           size_t fal, fal32, slen, i = 0;
124 
125           error = copyin(ufa, &fa32, sizeof(fa32));
126           if (error)
127                     return error;
128 
129           if (fa32.len == 0)
130                     return 0;
131 
132           fa = kmem_alloc(sizeof(*fa), KM_SLEEP);
133           fa->len = fa->size = fa32.len;
134 
135           if (fa->len > lim) {
136                     kmem_free(fa, sizeof(*fa));
137                     return EINVAL;
138           }
139 
140           fal = fa->len * sizeof(*fae);
141           fal32 = fa->len * sizeof(*fae32);
142 
143           fa->fae = kmem_alloc(fal, KM_SLEEP);
144           fae32 = kmem_alloc(fal32, KM_SLEEP);
145           error = copyin(NETBSD32PTR64(fa32.fae), fae32, fal32);
146           if (error)
147                     goto out;
148 
149           pbuf = PNBUF_GET();
150           for (; i < fa->len; i++) {
151                     fae = &fa->fae[i];
152                     f32 = &fae32[i];
153                     fae->fae_action = (unsigned)f32->fae_action;
154                     fae->fae_fildes = f32->fae_fildes;
155                     if (fae->fae_action == FAE_DUP2)
156                               fae->fae_data.dup2.newfildes =
157                                   f32->fae_data.dup2.newfildes;
158                     if (!netbsd32_posix_spawn_fae_path(fae, f32, &pathp, &pathp32)
159                         || pathp == NULL || pathp32 == NULL)
160                               continue;
161                     error = copyinstr(pathp32, pbuf, MAXPATHLEN, &slen);
162                     if (error)
163                               goto out;
164                     *pathp = kmem_alloc(slen, KM_SLEEP);
165                     memcpy(*pathp, pbuf, slen);
166                     fae->fae_oflag = f32->fae_oflag;
167                     fae->fae_mode = f32->fae_mode;
168           }
169           PNBUF_PUT(pbuf);
170           kmem_free(fae32, fal32);
171           *fap = fa;
172           return 0;
173 
174 out:
175           kmem_free(fae32, fal32);
176           if (pbuf)
177                     PNBUF_PUT(pbuf);
178           posix_spawn_fa_free(fa, i);
179           return error;
180 }
181 
182 int
netbsd32_posix_spawn(struct lwp * l,const struct netbsd32_posix_spawn_args * uap,register_t * retval)183 netbsd32_posix_spawn(struct lwp *l,
184           const struct netbsd32_posix_spawn_args *uap, register_t *retval)
185 {
186           /* {
187           syscallarg(netbsd32_pid_tp) pid;
188           syscallarg(const netbsd32_charp) path;
189           syscallarg(const netbsd32_posix_spawn_file_actionsp) file_actions;
190           syscallarg(const netbsd32_posix_spawnattrp) attrp;
191           syscallarg(netbsd32_charpp) argv;
192           syscallarg(netbsd32_charpp) envp;
193           } */
194 
195           int error;
196           struct posix_spawn_file_actions *fa = NULL;
197           struct posix_spawnattr *sa = NULL;
198           pid_t pid;
199           bool child_ok = false;
200           rlim_t max_fileactions;
201           proc_t *p = l->l_proc;
202 
203           /* check_posix_spawn() increments nprocs for us. */
204           error = check_posix_spawn(l);
205           if (error) {
206                     *retval = error;
207                     return 0;
208           }
209 
210           /* copy in file_actions struct */
211           if (SCARG_P32(uap, file_actions) != NULL) {
212                     max_fileactions = 2 * uimin(p->p_rlimit[RLIMIT_NOFILE].rlim_cur,
213                         maxfiles);
214                     error = netbsd32_posix_spawn_fa_alloc(&fa,
215                         SCARG_P32(uap, file_actions), max_fileactions);
216                     if (error)
217                               goto error_exit;
218           }
219 
220           /* copyin posix_spawnattr struct */
221           if (SCARG_P32(uap, attrp) != NULL) {
222                     sa = kmem_alloc(sizeof(*sa), KM_SLEEP);
223                     error = copyin(SCARG_P32(uap, attrp), sa, sizeof(*sa));
224                     if (error)
225                               goto error_exit;
226           }
227 
228           /*
229            * Do the spawn
230            */
231           error = do_posix_spawn(l, &pid, &child_ok, SCARG_P32(uap, path), fa,
232               sa, SCARG_P32(uap, argv), SCARG_P32(uap, envp),
233               netbsd32_execve_fetch_element);
234           if (error)
235                     goto error_exit;
236 
237           if (error == 0 && SCARG_P32(uap, pid) != NULL)
238                     error = copyout(&pid, SCARG_P32(uap, pid), sizeof(pid));
239 
240           *retval = error;
241           return 0;
242 
243  error_exit:
244           if (!child_ok) {
245                     (void)chgproccnt(kauth_cred_getuid(l->l_cred), -1);
246                     atomic_dec_uint(&nprocs);
247 
248                     if (sa)
249                               kmem_free(sa, sizeof(*sa));
250                     if (fa)
251                               posix_spawn_fa_free(fa, fa->len);
252           }
253 
254           *retval = error;
255           return 0;
256 }
257