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 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 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 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 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 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 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
Indexes created Sat Sep 20 22:09:52 GMT 2025