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
52static int
53netbsd32_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
66int
67netbsd32_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
79int
80netbsd32_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
93static __inline bool
94netbsd32_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
113static int
114netbsd32_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
174out:
175	kmem_free(fae32, fal32);
176	if (pbuf)
177		PNBUF_PUT(pbuf);
178	posix_spawn_fa_free(fa, i);
179	return error;
180}
181
182int
183netbsd32_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