1 /* $NetBSD: compat_util.c,v 1.15 2000/06/26 14:38:54 mrg Exp $ */ 2 3 /*- 4 * Copyright (c) 1994 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Christos Zoulas and Frank van der Linden. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 3. All advertising materials mentioning features or use of this software 19 * must display the following acknowledgement: 20 * This product includes software developed by the NetBSD 21 * Foundation, Inc. and its contributors. 22 * 4. Neither the name of The NetBSD Foundation nor the names of its 23 * contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 27 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 28 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 29 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 30 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 33 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 34 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 36 * POSSIBILITY OF SUCH DAMAGE. 37 */ 38 39 #include <sys/param.h> 40 #include <sys/systm.h> 41 #include <sys/namei.h> 42 #include <sys/proc.h> 43 #include <sys/file.h> 44 #include <sys/stat.h> 45 #include <sys/filedesc.h> 46 #include <sys/exec.h> 47 #include <sys/ioctl.h> 48 #include <sys/kernel.h> 49 #include <sys/malloc.h> 50 #include <sys/vnode.h> 51 #include <sys/syslog.h> 52 #include <sys/mount.h> 53 54 55 #include <compat/common/compat_util.h> 56 57 /* 58 * Search an alternate path before passing pathname arguments on 59 * to system calls. Useful for keeping a separate 'emulation tree'. 60 * 61 * If cflag is set, we check if an attempt can be made to create 62 * the named file, i.e. we check if the directory it should 63 * be in exists. 64 * 65 * In case of success, emul_find returns 0: 66 * If sgp is provided, the path is in user space, and pbuf gets 67 * allocated in user space (in the stackgap). Otherwise the path 68 * is already in kernel space and a kernel buffer gets allocated 69 * and returned in pbuf, that must be freed by the user. 70 * In case of error, the error number is returned and *pbuf = path. 71 */ 72 int 73 emul_find(p, sgp, prefix, path, pbuf, cflag) 74 struct proc *p; 75 caddr_t *sgp; /* Pointer to stackgap memory */ 76 const char *prefix; 77 const char *path; 78 const char **pbuf; 79 int cflag; 80 { 81 struct nameidata nd; 82 struct nameidata ndroot; 83 struct vattr vat; 84 struct vattr vatroot; 85 int error; 86 char *ptr, *buf, *cp; 87 const char *pr; 88 size_t sz, len; 89 90 buf = (char *)malloc(MAXPATHLEN, M_TEMP, M_WAITOK); 91 *pbuf = path; 92 93 for (ptr = buf, pr = prefix; (*ptr = *pr) != '\0'; ptr++, pr++) 94 continue; 95 96 sz = MAXPATHLEN - (ptr - buf); 97 98 /* 99 * If sgp is not given then the path is already in kernel space 100 */ 101 if (sgp == NULL) 102 error = copystr(path, ptr, sz, &len); 103 else 104 error = copyinstr(path, ptr, sz, &len); 105 106 if (error) 107 goto bad; 108 109 if (*ptr != '/') { 110 error = EINVAL; 111 goto bad; 112 } 113 114 /* 115 * We provide an escape method, so that the user can 116 * always specify the real root. If the path is prefixed 117 * by /../ we kill the alternate search 118 */ 119 if (ptr[1] == '.' && ptr[2] == '.' && ptr[3] == '/') { 120 len -= 3; 121 (void)memcpy(buf, &ptr[3], len); 122 ptr = buf; 123 goto good; 124 } 125 126 /* 127 * We know that there is a / somewhere in this pathname. 128 * Search backwards for it, to find the file's parent dir 129 * to see if it exists in the alternate tree. If it does, 130 * and we want to create a file (cflag is set). We don't 131 * need to worry about the root comparison in this case. 132 */ 133 134 if (cflag) { 135 for (cp = &ptr[len] - 1; *cp != '/'; cp--) 136 ; 137 *cp = '\0'; 138 139 NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, buf, p); 140 141 if ((error = namei(&nd)) != 0) 142 goto bad; 143 144 *cp = '/'; 145 } 146 else { 147 NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, buf, p); 148 149 if ((error = namei(&nd)) != 0) 150 goto bad; 151 152 /* 153 * We now compare the vnode of the emulation root to the one 154 * vnode asked. If they resolve to be the same, then we 155 * ignore the match so that the real root gets used. 156 * This avoids the problem of traversing "../.." to find the 157 * root directory and never finding it, because "/" resolves 158 * to the emulation root directory. This is expensive :-( 159 */ 160 NDINIT(&ndroot, LOOKUP, FOLLOW, UIO_SYSSPACE, prefix, p); 161 162 if ((error = namei(&ndroot)) != 0) 163 goto bad2; 164 165 if ((error = VOP_GETATTR(nd.ni_vp, &vat, p->p_ucred, p)) != 0) 166 goto bad3; 167 168 if ((error = VOP_GETATTR(ndroot.ni_vp, &vatroot, p->p_ucred, p)) 169 != 0) 170 goto bad3; 171 172 if (vat.va_fsid == vatroot.va_fsid && 173 vat.va_fileid == vatroot.va_fileid) { 174 error = ENOENT; 175 goto bad3; 176 } 177 } 178 179 vrele(nd.ni_vp); 180 if (!cflag) 181 vrele(ndroot.ni_vp); 182 183 good: 184 if (sgp == NULL) 185 *pbuf = buf; 186 else { 187 sz = &ptr[len] - buf; 188 *pbuf = stackgap_alloc(sgp, sz + 1); 189 if ((error = copyout(buf, (void *)*pbuf, sz)) != 0) { 190 *pbuf = path; 191 return error; 192 } 193 free(buf, M_TEMP); 194 } 195 return 0; 196 197 bad3: 198 vrele(ndroot.ni_vp); 199 bad2: 200 vrele(nd.ni_vp); 201 bad: 202 free(buf, M_TEMP); 203 return error; 204 } 205 206 /* 207 * Translate one set of flags to another, based on the entries in 208 * the given table. If 'leftover' is specified, it is filled in 209 * with any flags which could not be translated. 210 */ 211 unsigned long 212 emul_flags_translate(const struct emul_flags_xtab *tab, 213 unsigned long in, unsigned long *leftover) 214 { 215 unsigned long out; 216 217 for (out = 0; tab->omask != 0; tab++) { 218 if ((in & tab->omask) == tab->oval) { 219 in &= ~tab->omask; 220 out |= tab->nval; 221 } 222 } 223 if (leftover != NULL) 224 *leftover = in; 225 return (out); 226 } 227 228 caddr_t 229 stackgap_init(e) 230 struct emul *e; 231 { 232 233 #define szsigcode ((caddr_t)(e->e_esigcode - e->e_sigcode)) 234 return STACKGAPBASE; 235 #undef szsigcode 236 } 237 238 239 void * 240 stackgap_alloc(sgp, sz) 241 caddr_t *sgp; 242 size_t sz; 243 { 244 void *p = (void *) *sgp; 245 246 *sgp += ALIGN(sz); 247 return p; 248 } 249 250 void 251 compat_offseterr(vp, msg) 252 struct vnode *vp; 253 char *msg; 254 { 255 struct mount *mp; 256 257 mp = vp->v_mount; 258 259 log(LOG_ERR, "%s: dir offset too large on fs %s (mounted from %s)\n", 260 msg, mp->mnt_stat.f_mntonname, mp->mnt_stat.f_mntfromname); 261 uprintf("%s: dir offset too large for emulated program\n", msg); 262 } 263