1 /*- 2 * Copyright (c) 1989, 1993 3 * The Regents of the University of California. All rights reserved. 4 * (c) UNIX System Laboratories, Inc. 5 * All or some portions of this file are derived from material licensed 6 * to the University of California by American Telephone and Telegraph 7 * Co. or Unix System Laboratories, Inc. and are reproduced herein with 8 * the permission of UNIX System Laboratories, Inc. 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 * 4. Neither the name of the University nor the names of its contributors 19 * may be used to endorse or promote products derived from this software 20 * without specific prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 25 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 32 * SUCH DAMAGE. 33 * 34 * @(#)vfs_subr.c 8.31 (Berkeley) 5/26/95 35 */ 36 37 #include <sys/cdefs.h> 38 __FBSDID("$FreeBSD$"); 39 40 #include <sys/param.h> 41 #include <sys/dirent.h> 42 #include <sys/domain.h> 43 #include <sys/kernel.h> 44 #include <sys/lock.h> 45 #include <sys/malloc.h> 46 #include <sys/mbuf.h> 47 #include <sys/mount.h> 48 #include <sys/mutex.h> 49 #include <sys/rwlock.h> 50 #include <sys/refcount.h> 51 #include <sys/socket.h> 52 #include <sys/systm.h> 53 #include <sys/vnode.h> 54 55 #include <net/radix.h> 56 57 static MALLOC_DEFINE(M_NETADDR, "export_host", "Export host address structure"); 58 59 static void vfs_free_addrlist(struct netexport *nep); 60 static int vfs_free_netcred(struct radix_node *rn, void *w); 61 static int vfs_hang_addrlist(struct mount *mp, struct netexport *nep, 62 struct export_args *argp); 63 static struct netcred *vfs_export_lookup(struct mount *, struct sockaddr *); 64 65 /* 66 * Network address lookup element 67 */ 68 struct netcred { 69 struct radix_node netc_rnodes[2]; 70 int netc_exflags; 71 struct ucred *netc_anon; 72 int netc_numsecflavors; 73 int netc_secflavors[MAXSECFLAVORS]; 74 }; 75 76 /* 77 * Network export information 78 */ 79 struct netexport { 80 struct netcred ne_defexported; /* Default export */ 81 struct radix_node_head *ne_rtable[AF_MAX+1]; /* Individual exports */ 82 }; 83 84 /* 85 * Build hash lists of net addresses and hang them off the mount point. 86 * Called by vfs_export() to set up the lists of export addresses. 87 */ 88 static int 89 vfs_hang_addrlist(struct mount *mp, struct netexport *nep, 90 struct export_args *argp) 91 { 92 register struct netcred *np; 93 register struct radix_node_head *rnh; 94 register int i; 95 struct radix_node *rn; 96 struct sockaddr *saddr, *smask = 0; 97 struct domain *dom; 98 int error; 99 100 /* 101 * XXX: This routine converts from a `struct xucred' 102 * (argp->ex_anon) to a `struct ucred' (np->netc_anon). This 103 * operation is questionable; for example, what should be done 104 * with fields like cr_uidinfo and cr_prison? Currently, this 105 * routine does not touch them (leaves them as NULL). 106 */ 107 if (argp->ex_anon.cr_version != XUCRED_VERSION) { 108 vfs_mount_error(mp, "ex_anon.cr_version: %d != %d", 109 argp->ex_anon.cr_version, XUCRED_VERSION); 110 return (EINVAL); 111 } 112 113 if (argp->ex_addrlen == 0) { 114 if (mp->mnt_flag & MNT_DEFEXPORTED) { 115 vfs_mount_error(mp, 116 "MNT_DEFEXPORTED already set for mount %p", mp); 117 return (EPERM); 118 } 119 np = &nep->ne_defexported; 120 np->netc_exflags = argp->ex_flags; 121 np->netc_anon = crget(); 122 np->netc_anon->cr_uid = argp->ex_anon.cr_uid; 123 crsetgroups(np->netc_anon, argp->ex_anon.cr_ngroups, 124 argp->ex_anon.cr_groups); 125 np->netc_numsecflavors = argp->ex_numsecflavors; 126 bcopy(argp->ex_secflavors, np->netc_secflavors, 127 sizeof(np->netc_secflavors)); 128 MNT_ILOCK(mp); 129 mp->mnt_flag |= MNT_DEFEXPORTED; 130 MNT_IUNLOCK(mp); 131 return (0); 132 } 133 134 #if MSIZE <= 256 135 if (argp->ex_addrlen > MLEN) { 136 vfs_mount_error(mp, "ex_addrlen %d is greater than %d", 137 argp->ex_addrlen, MLEN); 138 return (EINVAL); 139 } 140 #endif 141 142 i = sizeof(struct netcred) + argp->ex_addrlen + argp->ex_masklen; 143 np = (struct netcred *) malloc(i, M_NETADDR, M_WAITOK | M_ZERO); 144 saddr = (struct sockaddr *) (np + 1); 145 if ((error = copyin(argp->ex_addr, saddr, argp->ex_addrlen))) 146 goto out; 147 if (saddr->sa_family == AF_UNSPEC || saddr->sa_family > AF_MAX) { 148 error = EINVAL; 149 vfs_mount_error(mp, "Invalid saddr->sa_family: %d"); 150 goto out; 151 } 152 if (saddr->sa_len > argp->ex_addrlen) 153 saddr->sa_len = argp->ex_addrlen; 154 if (argp->ex_masklen) { 155 smask = (struct sockaddr *)((caddr_t)saddr + argp->ex_addrlen); 156 error = copyin(argp->ex_mask, smask, argp->ex_masklen); 157 if (error) 158 goto out; 159 if (smask->sa_len > argp->ex_masklen) 160 smask->sa_len = argp->ex_masklen; 161 } 162 i = saddr->sa_family; 163 if ((rnh = nep->ne_rtable[i]) == NULL) { 164 /* 165 * Seems silly to initialize every AF when most are not used, 166 * do so on demand here 167 */ 168 for (dom = domains; dom; dom = dom->dom_next) { 169 KASSERT(((i == AF_INET) || (i == AF_INET6)), 170 ("unexpected protocol in vfs_hang_addrlist")); 171 if (dom->dom_family == i && dom->dom_rtattach) { 172 /* 173 * XXX MRT 174 * The INET and INET6 domains know the 175 * offset already. We don't need to send it 176 * So we just use it as a flag to say that 177 * we are or are not setting up a real routing 178 * table. Only IP and IPV6 need have this 179 * be 0 so all other protocols can stay the 180 * same (ABI compatible). 181 */ 182 dom->dom_rtattach( 183 (void **) &nep->ne_rtable[i], 0); 184 break; 185 } 186 } 187 if ((rnh = nep->ne_rtable[i]) == NULL) { 188 error = ENOBUFS; 189 vfs_mount_error(mp, "%s %s %d", 190 "Unable to initialize radix node head ", 191 "for address family", i); 192 goto out; 193 } 194 } 195 RADIX_NODE_HEAD_LOCK(rnh); 196 rn = (*rnh->rnh_addaddr)(saddr, smask, rnh, np->netc_rnodes); 197 RADIX_NODE_HEAD_UNLOCK(rnh); 198 if (rn == NULL || np != (struct netcred *)rn) { /* already exists */ 199 error = EPERM; 200 vfs_mount_error(mp, "Invalid radix node head, rn: %p %p", 201 rn, np); 202 goto out; 203 } 204 np->netc_exflags = argp->ex_flags; 205 np->netc_anon = crget(); 206 np->netc_anon->cr_uid = argp->ex_anon.cr_uid; 207 crsetgroups(np->netc_anon, argp->ex_anon.cr_ngroups, 208 np->netc_anon->cr_groups); 209 np->netc_numsecflavors = argp->ex_numsecflavors; 210 bcopy(argp->ex_secflavors, np->netc_secflavors, 211 sizeof(np->netc_secflavors)); 212 return (0); 213 out: 214 free(np, M_NETADDR); 215 return (error); 216 } 217 218 /* Helper for vfs_free_addrlist. */ 219 /* ARGSUSED */ 220 static int 221 vfs_free_netcred(struct radix_node *rn, void *w) 222 { 223 struct radix_node_head *rnh = (struct radix_node_head *) w; 224 struct ucred *cred; 225 226 (*rnh->rnh_deladdr) (rn->rn_key, rn->rn_mask, rnh); 227 cred = ((struct netcred *)rn)->netc_anon; 228 if (cred != NULL) 229 crfree(cred); 230 free(rn, M_NETADDR); 231 return (0); 232 } 233 234 /* 235 * Free the net address hash lists that are hanging off the mount points. 236 */ 237 static void 238 vfs_free_addrlist(struct netexport *nep) 239 { 240 int i; 241 struct radix_node_head *rnh; 242 struct ucred *cred; 243 244 for (i = 0; i <= AF_MAX; i++) { 245 if ((rnh = nep->ne_rtable[i])) { 246 RADIX_NODE_HEAD_LOCK(rnh); 247 (*rnh->rnh_walktree) (rnh, vfs_free_netcred, rnh); 248 RADIX_NODE_HEAD_UNLOCK(rnh); 249 RADIX_NODE_HEAD_DESTROY(rnh); 250 free(rnh, M_RTABLE); 251 nep->ne_rtable[i] = NULL; /* not SMP safe XXX */ 252 } 253 } 254 cred = nep->ne_defexported.netc_anon; 255 if (cred != NULL) 256 crfree(cred); 257 258 } 259 260 /* 261 * High level function to manipulate export options on a mount point 262 * and the passed in netexport. 263 * Struct export_args *argp is the variable used to twiddle options, 264 * the structure is described in sys/mount.h 265 */ 266 int 267 vfs_export(struct mount *mp, struct export_args *argp) 268 { 269 struct netexport *nep; 270 int error; 271 272 if (argp->ex_numsecflavors < 0 273 || argp->ex_numsecflavors >= MAXSECFLAVORS) 274 return (EINVAL); 275 276 error = 0; 277 lockmgr(&mp->mnt_explock, LK_EXCLUSIVE, NULL); 278 nep = mp->mnt_export; 279 if (argp->ex_flags & MNT_DELEXPORT) { 280 if (nep == NULL) { 281 error = ENOENT; 282 goto out; 283 } 284 if (mp->mnt_flag & MNT_EXPUBLIC) { 285 vfs_setpublicfs(NULL, NULL, NULL); 286 MNT_ILOCK(mp); 287 mp->mnt_flag &= ~MNT_EXPUBLIC; 288 MNT_IUNLOCK(mp); 289 } 290 vfs_free_addrlist(nep); 291 mp->mnt_export = NULL; 292 free(nep, M_MOUNT); 293 nep = NULL; 294 MNT_ILOCK(mp); 295 mp->mnt_flag &= ~(MNT_EXPORTED | MNT_DEFEXPORTED); 296 MNT_IUNLOCK(mp); 297 } 298 if (argp->ex_flags & MNT_EXPORTED) { 299 if (nep == NULL) { 300 nep = malloc(sizeof(struct netexport), M_MOUNT, M_WAITOK | M_ZERO); 301 mp->mnt_export = nep; 302 } 303 if (argp->ex_flags & MNT_EXPUBLIC) { 304 if ((error = vfs_setpublicfs(mp, nep, argp)) != 0) 305 goto out; 306 MNT_ILOCK(mp); 307 mp->mnt_flag |= MNT_EXPUBLIC; 308 MNT_IUNLOCK(mp); 309 } 310 if ((error = vfs_hang_addrlist(mp, nep, argp))) 311 goto out; 312 MNT_ILOCK(mp); 313 mp->mnt_flag |= MNT_EXPORTED; 314 MNT_IUNLOCK(mp); 315 } 316 317 out: 318 lockmgr(&mp->mnt_explock, LK_RELEASE, NULL); 319 /* 320 * Once we have executed the vfs_export() command, we do 321 * not want to keep the "export" option around in the 322 * options list, since that will cause subsequent MNT_UPDATE 323 * calls to fail. The export information is saved in 324 * mp->mnt_export, so we can safely delete the "export" mount option 325 * here. 326 */ 327 vfs_deleteopt(mp->mnt_optnew, "export"); 328 vfs_deleteopt(mp->mnt_opt, "export"); 329 return (error); 330 } 331 332 /* 333 * Set the publicly exported filesystem (WebNFS). Currently, only 334 * one public filesystem is possible in the spec (RFC 2054 and 2055) 335 */ 336 int 337 vfs_setpublicfs(struct mount *mp, struct netexport *nep, 338 struct export_args *argp) 339 { 340 int error; 341 struct vnode *rvp; 342 char *cp; 343 344 /* 345 * mp == NULL -> invalidate the current info, the FS is 346 * no longer exported. May be called from either vfs_export 347 * or unmount, so check if it hasn't already been done. 348 */ 349 if (mp == NULL) { 350 if (nfs_pub.np_valid) { 351 nfs_pub.np_valid = 0; 352 if (nfs_pub.np_index != NULL) { 353 free(nfs_pub.np_index, M_TEMP); 354 nfs_pub.np_index = NULL; 355 } 356 } 357 return (0); 358 } 359 360 /* 361 * Only one allowed at a time. 362 */ 363 if (nfs_pub.np_valid != 0 && mp != nfs_pub.np_mount) 364 return (EBUSY); 365 366 /* 367 * Get real filehandle for root of exported FS. 368 */ 369 bzero(&nfs_pub.np_handle, sizeof(nfs_pub.np_handle)); 370 nfs_pub.np_handle.fh_fsid = mp->mnt_stat.f_fsid; 371 372 if ((error = VFS_ROOT(mp, LK_EXCLUSIVE, &rvp))) 373 return (error); 374 375 if ((error = VOP_VPTOFH(rvp, &nfs_pub.np_handle.fh_fid))) 376 return (error); 377 378 vput(rvp); 379 380 /* 381 * If an indexfile was specified, pull it in. 382 */ 383 if (argp->ex_indexfile != NULL) { 384 if (nfs_pub.np_index != NULL) 385 nfs_pub.np_index = malloc(MAXNAMLEN + 1, M_TEMP, 386 M_WAITOK); 387 error = copyinstr(argp->ex_indexfile, nfs_pub.np_index, 388 MAXNAMLEN, (size_t *)0); 389 if (!error) { 390 /* 391 * Check for illegal filenames. 392 */ 393 for (cp = nfs_pub.np_index; *cp; cp++) { 394 if (*cp == '/') { 395 error = EINVAL; 396 break; 397 } 398 } 399 } 400 if (error) { 401 free(nfs_pub.np_index, M_TEMP); 402 nfs_pub.np_index = NULL; 403 return (error); 404 } 405 } 406 407 nfs_pub.np_mount = mp; 408 nfs_pub.np_valid = 1; 409 return (0); 410 } 411 412 /* 413 * Used by the filesystems to determine if a given network address 414 * (passed in 'nam') is present in their exports list, returns a pointer 415 * to struct netcred so that the filesystem can examine it for 416 * access rights (read/write/etc). 417 */ 418 static struct netcred * 419 vfs_export_lookup(struct mount *mp, struct sockaddr *nam) 420 { 421 struct netexport *nep; 422 register struct netcred *np; 423 register struct radix_node_head *rnh; 424 struct sockaddr *saddr; 425 426 nep = mp->mnt_export; 427 if (nep == NULL) 428 return (NULL); 429 np = NULL; 430 if (mp->mnt_flag & MNT_EXPORTED) { 431 /* 432 * Lookup in the export list first. 433 */ 434 if (nam != NULL) { 435 saddr = nam; 436 rnh = nep->ne_rtable[saddr->sa_family]; 437 if (rnh != NULL) { 438 RADIX_NODE_HEAD_RLOCK(rnh); 439 np = (struct netcred *) 440 (*rnh->rnh_matchaddr)(saddr, rnh); 441 RADIX_NODE_HEAD_RUNLOCK(rnh); 442 if (np && np->netc_rnodes->rn_flags & RNF_ROOT) 443 np = NULL; 444 } 445 } 446 /* 447 * If no address match, use the default if it exists. 448 */ 449 if (np == NULL && mp->mnt_flag & MNT_DEFEXPORTED) 450 np = &nep->ne_defexported; 451 } 452 return (np); 453 } 454 455 /* 456 * XXX: This comment comes from the deprecated ufs_check_export() 457 * XXX: and may not entirely apply, but lacking something better: 458 * This is the generic part of fhtovp called after the underlying 459 * filesystem has validated the file handle. 460 * 461 * Verify that a host should have access to a filesystem. 462 */ 463 464 int 465 vfs_stdcheckexp(struct mount *mp, struct sockaddr *nam, int *extflagsp, 466 struct ucred **credanonp, int *numsecflavors, int **secflavors) 467 { 468 struct netcred *np; 469 470 lockmgr(&mp->mnt_explock, LK_SHARED, NULL); 471 np = vfs_export_lookup(mp, nam); 472 if (np == NULL) { 473 lockmgr(&mp->mnt_explock, LK_RELEASE, NULL); 474 *credanonp = NULL; 475 return (EACCES); 476 } 477 *extflagsp = np->netc_exflags; 478 if ((*credanonp = np->netc_anon) != NULL) 479 crhold(*credanonp); 480 if (numsecflavors) 481 *numsecflavors = np->netc_numsecflavors; 482 if (secflavors) 483 *secflavors = np->netc_secflavors; 484 lockmgr(&mp->mnt_explock, LK_RELEASE, NULL); 485 return (0); 486 } 487 488