Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
FreeBSD/Linux Kernel Cross Reference
sys/fs/nfsserver/nfs_nfsdserv.c
Version:
- FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
SearchContext: - none - 3 - 10
1 /*- 2 * Copyright (c) 1989, 1993 3 * The Regents of the University of California. All rights reserved. 4 * 5 * This code is derived from software contributed to Berkeley by 6 * Rick Macklem at The University of Guelph. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 4. Neither the name of the University nor the names of its contributors 17 * may be used to endorse or promote products derived from this software 18 * without specific prior written permission. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 23 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 30 * SUCH DAMAGE. 31 * 32 */ 33 34 #include <sys/cdefs.h> 35 __FBSDID("$FreeBSD: releng/8.4/sys/fs/nfsserver/nfs_nfsdserv.c 264284 2014-04-08 23:16:05Z delphij $"); 36 37 /* 38 * nfs version 2, 3 and 4 server calls to vnode ops 39 * - these routines generally have 3 phases 40 * 1 - break down and validate rpc request in mbuf list 41 * 2 - do the vnode ops for the request, usually by calling a nfsvno_XXX() 42 * function in nfsd_port.c 43 * 3 - build the rpc reply in an mbuf list 44 * For nfsv4, these functions are called for each Op within the Compound RPC. 45 */ 46 47 #ifndef APPLEKEXT 48 #include <fs/nfs/nfsport.h> 49 50 /* Global vars */ 51 extern u_int32_t newnfs_false, newnfs_true; 52 extern enum vtype nv34tov_type[8]; 53 extern struct timeval nfsboottime; 54 extern int nfs_rootfhset; 55 extern int nfsrv_enable_crossmntpt; 56 #endif /* !APPLEKEXT */ 57 58 /* 59 * This list defines the GSS mechanisms supported. 60 * (Don't ask me how you get these strings from the RFC stuff like 61 * iso(1), org(3)... but someone did it, so I don't need to know.) 62 */ 63 static struct nfsgss_mechlist nfsgss_mechlist[] = { 64 { 9, "\052\206\110\206\367\022\001\002\002", 11 }, 65 { 0, "", 0 }, 66 }; 67 68 /* local functions */ 69 static void nfsrvd_symlinksub(struct nfsrv_descript *nd, struct nameidata *ndp, 70 struct nfsvattr *nvap, fhandle_t *fhp, vnode_t *vpp, 71 vnode_t dirp, struct nfsvattr *dirforp, struct nfsvattr *diraftp, 72 int *diraft_retp, nfsattrbit_t *attrbitp, 73 NFSACL_T *aclp, NFSPROC_T *p, struct nfsexstuff *exp, char *pathcp, 74 int pathlen); 75 static void nfsrvd_mkdirsub(struct nfsrv_descript *nd, struct nameidata *ndp, 76 struct nfsvattr *nvap, fhandle_t *fhp, vnode_t *vpp, 77 vnode_t dirp, struct nfsvattr *dirforp, struct nfsvattr *diraftp, 78 int *diraft_retp, nfsattrbit_t *attrbitp, NFSACL_T *aclp, 79 NFSPROC_T *p, struct nfsexstuff *exp); 80 81 /* 82 * nfs access service (not a part of NFS V2) 83 */ 84 APPLESTATIC int 85 nfsrvd_access(struct nfsrv_descript *nd, __unused int isdgram, 86 vnode_t vp, NFSPROC_T *p, struct nfsexstuff *exp) 87 { 88 u_int32_t *tl; 89 int getret, error = 0; 90 struct nfsvattr nva; 91 u_int32_t testmode, nfsmode, supported = 0; 92 accmode_t deletebit; 93 94 if (nd->nd_repstat) { 95 nfsrv_postopattr(nd, 1, &nva); 96 goto out; 97 } 98 NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED); 99 nfsmode = fxdr_unsigned(u_int32_t, *tl); 100 if ((nd->nd_flag & ND_NFSV4) && 101 (nfsmode & ~(NFSACCESS_READ | NFSACCESS_LOOKUP | 102 NFSACCESS_MODIFY | NFSACCESS_EXTEND | NFSACCESS_DELETE | 103 NFSACCESS_EXECUTE))) { 104 nd->nd_repstat = NFSERR_INVAL; 105 vput(vp); 106 goto out; 107 } 108 if (nfsmode & NFSACCESS_READ) { 109 supported |= NFSACCESS_READ; 110 if (nfsvno_accchk(vp, VREAD, nd->nd_cred, exp, p, 111 NFSACCCHK_NOOVERRIDE, NFSACCCHK_VPISLOCKED, &supported)) 112 nfsmode &= ~NFSACCESS_READ; 113 } 114 if (nfsmode & NFSACCESS_MODIFY) { 115 supported |= NFSACCESS_MODIFY; 116 if (nfsvno_accchk(vp, VWRITE, nd->nd_cred, exp, p, 117 NFSACCCHK_NOOVERRIDE, NFSACCCHK_VPISLOCKED, &supported)) 118 nfsmode &= ~NFSACCESS_MODIFY; 119 } 120 if (nfsmode & NFSACCESS_EXTEND) { 121 supported |= NFSACCESS_EXTEND; 122 if (nfsvno_accchk(vp, VWRITE | VAPPEND, nd->nd_cred, exp, p, 123 NFSACCCHK_NOOVERRIDE, NFSACCCHK_VPISLOCKED, &supported)) 124 nfsmode &= ~NFSACCESS_EXTEND; 125 } 126 if (nfsmode & NFSACCESS_DELETE) { 127 supported |= NFSACCESS_DELETE; 128 if (vp->v_type == VDIR) 129 deletebit = VDELETE_CHILD; 130 else 131 deletebit = VDELETE; 132 if (nfsvno_accchk(vp, deletebit, nd->nd_cred, exp, p, 133 NFSACCCHK_NOOVERRIDE, NFSACCCHK_VPISLOCKED, &supported)) 134 nfsmode &= ~NFSACCESS_DELETE; 135 } 136 if (vnode_vtype(vp) == VDIR) 137 testmode = NFSACCESS_LOOKUP; 138 else 139 testmode = NFSACCESS_EXECUTE; 140 if (nfsmode & testmode) { 141 supported |= (nfsmode & testmode); 142 if (nfsvno_accchk(vp, VEXEC, nd->nd_cred, exp, p, 143 NFSACCCHK_NOOVERRIDE, NFSACCCHK_VPISLOCKED, &supported)) 144 nfsmode &= ~testmode; 145 } 146 nfsmode &= supported; 147 if (nd->nd_flag & ND_NFSV3) { 148 getret = nfsvno_getattr(vp, &nva, nd->nd_cred, p, 1); 149 nfsrv_postopattr(nd, getret, &nva); 150 } 151 vput(vp); 152 if (nd->nd_flag & ND_NFSV4) { 153 NFSM_BUILD(tl, u_int32_t *, 2 * NFSX_UNSIGNED); 154 *tl++ = txdr_unsigned(supported); 155 } else 156 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED); 157 *tl = txdr_unsigned(nfsmode); 158 159 out: 160 NFSEXITCODE2(0, nd); 161 return (0); 162 nfsmout: 163 vput(vp); 164 NFSEXITCODE2(error, nd); 165 return (error); 166 } 167 168 /* 169 * nfs getattr service 170 */ 171 APPLESTATIC int 172 nfsrvd_getattr(struct nfsrv_descript *nd, int isdgram, 173 vnode_t vp, NFSPROC_T *p, __unused struct nfsexstuff *exp) 174 { 175 struct nfsvattr nva; 176 fhandle_t fh; 177 int at_root = 0, error = 0, supports_nfsv4acls; 178 struct nfsreferral *refp; 179 nfsattrbit_t attrbits, tmpbits; 180 struct mount *mp; 181 struct vnode *tvp = NULL; 182 struct vattr va; 183 uint64_t mounted_on_fileno = 0; 184 accmode_t accmode; 185 186 if (nd->nd_repstat) 187 goto out; 188 if (nd->nd_flag & ND_NFSV4) { 189 error = nfsrv_getattrbits(nd, &attrbits, NULL, NULL); 190 if (error) { 191 vput(vp); 192 goto out; 193 } 194 195 /* 196 * Check for a referral. 197 */ 198 refp = nfsv4root_getreferral(vp, NULL, 0); 199 if (refp != NULL) { 200 (void) nfsrv_putreferralattr(nd, &attrbits, refp, 1, 201 &nd->nd_repstat); 202 vput(vp); 203 goto out; 204 } 205 if (nd->nd_repstat == 0) { 206 accmode = 0; 207 NFSSET_ATTRBIT(&tmpbits, &attrbits); 208 if (NFSISSET_ATTRBIT(&tmpbits, NFSATTRBIT_ACL)) { 209 NFSCLRBIT_ATTRBIT(&tmpbits, NFSATTRBIT_ACL); 210 accmode |= VREAD_ACL; 211 } 212 if (NFSNONZERO_ATTRBIT(&tmpbits)) 213 accmode |= VREAD_ATTRIBUTES; 214 if (accmode != 0) 215 nd->nd_repstat = nfsvno_accchk(vp, accmode, 216 nd->nd_cred, exp, p, NFSACCCHK_NOOVERRIDE, 217 NFSACCCHK_VPISLOCKED, NULL); 218 } 219 } 220 if (!nd->nd_repstat) 221 nd->nd_repstat = nfsvno_getattr(vp, &nva, nd->nd_cred, p, 1); 222 if (!nd->nd_repstat) { 223 if (nd->nd_flag & ND_NFSV4) { 224 if (NFSISSET_ATTRBIT(&attrbits, NFSATTRBIT_FILEHANDLE)) 225 nd->nd_repstat = nfsvno_getfh(vp, &fh, p); 226 if (!nd->nd_repstat) 227 nd->nd_repstat = nfsrv_checkgetattr(nd, vp, 228 &nva, &attrbits, nd->nd_cred, p); 229 if (nd->nd_repstat == 0) { 230 supports_nfsv4acls = nfs_supportsnfsv4acls(vp); 231 mp = vp->v_mount; 232 if (nfsrv_enable_crossmntpt != 0 && 233 vp->v_type == VDIR && 234 (vp->v_vflag & VV_ROOT) != 0 && 235 vp != rootvnode) { 236 tvp = mp->mnt_vnodecovered; 237 VREF(tvp); 238 at_root = 1; 239 } else 240 at_root = 0; 241 vfs_ref(mp); 242 NFSVOPUNLOCK(vp, 0); 243 if (at_root != 0) { 244 if ((nd->nd_repstat = 245 NFSVOPLOCK(tvp, LK_SHARED)) == 0) { 246 nd->nd_repstat = VOP_GETATTR( 247 tvp, &va, nd->nd_cred); 248 vput(tvp); 249 } else 250 vrele(tvp); 251 if (nd->nd_repstat == 0) 252 mounted_on_fileno = (uint64_t) 253 va.va_fileid; 254 else 255 at_root = 0; 256 } 257 if (nd->nd_repstat == 0) 258 nd->nd_repstat = vfs_busy(mp, 0); 259 vfs_rel(mp); 260 if (nd->nd_repstat == 0) { 261 (void)nfsvno_fillattr(nd, mp, vp, &nva, 262 &fh, 0, &attrbits, nd->nd_cred, p, 263 isdgram, 1, supports_nfsv4acls, 264 at_root, mounted_on_fileno); 265 vfs_unbusy(mp); 266 } 267 vrele(vp); 268 } else 269 vput(vp); 270 } else { 271 nfsrv_fillattr(nd, &nva); 272 vput(vp); 273 } 274 } else { 275 vput(vp); 276 } 277 278 out: 279 NFSEXITCODE2(error, nd); 280 return (error); 281 } 282 283 /* 284 * nfs setattr service 285 */ 286 APPLESTATIC int 287 nfsrvd_setattr(struct nfsrv_descript *nd, __unused int isdgram, 288 vnode_t vp, NFSPROC_T *p, struct nfsexstuff *exp) 289 { 290 struct nfsvattr nva, nva2; 291 u_int32_t *tl; 292 int preat_ret = 1, postat_ret = 1, gcheck = 0, error = 0; 293 struct timespec guard = { 0, 0 }; 294 nfsattrbit_t attrbits, retbits; 295 nfsv4stateid_t stateid; 296 NFSACL_T *aclp = NULL; 297 298 if (nd->nd_repstat) { 299 nfsrv_wcc(nd, preat_ret, &nva2, postat_ret, &nva); 300 goto out; 301 } 302 #ifdef NFS4_ACL_EXTATTR_NAME 303 aclp = acl_alloc(M_WAITOK); 304 aclp->acl_cnt = 0; 305 #endif 306 NFSVNO_ATTRINIT(&nva); 307 NFSZERO_ATTRBIT(&retbits); 308 if (nd->nd_flag & ND_NFSV4) { 309 NFSM_DISSECT(tl, u_int32_t *, NFSX_STATEID); 310 stateid.seqid = fxdr_unsigned(u_int32_t, *tl++); 311 NFSBCOPY((caddr_t)tl,(caddr_t)stateid.other,NFSX_STATEIDOTHER); 312 } 313 error = nfsrv_sattr(nd, &nva, &attrbits, aclp, p); 314 if (error) 315 goto nfsmout; 316 preat_ret = nfsvno_getattr(vp, &nva2, nd->nd_cred, p, 1); 317 if (!nd->nd_repstat) 318 nd->nd_repstat = preat_ret; 319 if (nd->nd_flag & ND_NFSV3) { 320 NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED); 321 gcheck = fxdr_unsigned(int, *tl); 322 if (gcheck) { 323 NFSM_DISSECT(tl, u_int32_t *, 2 * NFSX_UNSIGNED); 324 fxdr_nfsv3time(tl, &guard); 325 } 326 if (!nd->nd_repstat && gcheck && 327 (nva2.na_ctime.tv_sec != guard.tv_sec || 328 nva2.na_ctime.tv_nsec != guard.tv_nsec)) 329 nd->nd_repstat = NFSERR_NOT_SYNC; 330 if (nd->nd_repstat) { 331 vput(vp); 332 #ifdef NFS4_ACL_EXTATTR_NAME 333 acl_free(aclp); 334 #endif 335 nfsrv_wcc(nd, preat_ret, &nva2, postat_ret, &nva); 336 goto out; 337 } 338 } else if (!nd->nd_repstat && (nd->nd_flag & ND_NFSV4)) 339 nd->nd_repstat = nfsrv_checkuidgid(nd, &nva); 340 341 /* 342 * Now that we have all the fields, lets do it. 343 * If the size is being changed write access is required, otherwise 344 * just check for a read only file system. 345 */ 346 if (!nd->nd_repstat) { 347 if (NFSVNO_NOTSETSIZE(&nva)) { 348 if (NFSVNO_EXRDONLY(exp) || 349 (vfs_flags(vnode_mount(vp)) & MNT_RDONLY)) 350 nd->nd_repstat = EROFS; 351 } else { 352 if (vnode_vtype(vp) != VREG) 353 nd->nd_repstat = EINVAL; 354 else if (nva2.na_uid != nd->nd_cred->cr_uid || 355 NFSVNO_EXSTRICTACCESS(exp)) 356 nd->nd_repstat = nfsvno_accchk(vp, 357 VWRITE, nd->nd_cred, exp, p, 358 NFSACCCHK_NOOVERRIDE, 359 NFSACCCHK_VPISLOCKED, NULL); 360 } 361 } 362 if (!nd->nd_repstat && (nd->nd_flag & ND_NFSV4)) 363 nd->nd_repstat = nfsrv_checksetattr(vp, nd, &stateid, 364 &nva, &attrbits, exp, p); 365 366 if (!nd->nd_repstat && (nd->nd_flag & ND_NFSV4)) { 367 /* 368 * For V4, try setting the attrbutes in sets, so that the 369 * reply bitmap will be correct for an error case. 370 */ 371 if (NFSISSET_ATTRBIT(&attrbits, NFSATTRBIT_OWNER) || 372 NFSISSET_ATTRBIT(&attrbits, NFSATTRBIT_OWNERGROUP)) { 373 NFSVNO_ATTRINIT(&nva2); 374 NFSVNO_SETATTRVAL(&nva2, uid, nva.na_uid); 375 NFSVNO_SETATTRVAL(&nva2, gid, nva.na_gid); 376 nd->nd_repstat = nfsvno_setattr(vp, &nva2, nd->nd_cred, p, 377 exp); 378 if (!nd->nd_repstat) { 379 if (NFSISSET_ATTRBIT(&attrbits, NFSATTRBIT_OWNER)) 380 NFSSETBIT_ATTRBIT(&retbits, NFSATTRBIT_OWNER); 381 if (NFSISSET_ATTRBIT(&attrbits, NFSATTRBIT_OWNERGROUP)) 382 NFSSETBIT_ATTRBIT(&retbits, NFSATTRBIT_OWNERGROUP); 383 } 384 } 385 if (!nd->nd_repstat && 386 NFSISSET_ATTRBIT(&attrbits, NFSATTRBIT_SIZE)) { 387 NFSVNO_ATTRINIT(&nva2); 388 NFSVNO_SETATTRVAL(&nva2, size, nva.na_size); 389 nd->nd_repstat = nfsvno_setattr(vp, &nva2, nd->nd_cred, p, 390 exp); 391 if (!nd->nd_repstat) 392 NFSSETBIT_ATTRBIT(&retbits, NFSATTRBIT_SIZE); 393 } 394 if (!nd->nd_repstat && 395 (NFSISSET_ATTRBIT(&attrbits, NFSATTRBIT_TIMEACCESSSET) || 396 NFSISSET_ATTRBIT(&attrbits, NFSATTRBIT_TIMEMODIFYSET))) { 397 NFSVNO_ATTRINIT(&nva2); 398 NFSVNO_SETATTRVAL(&nva2, atime, nva.na_atime); 399 NFSVNO_SETATTRVAL(&nva2, mtime, nva.na_mtime); 400 if (nva.na_vaflags & VA_UTIMES_NULL) { 401 nva2.na_vaflags |= VA_UTIMES_NULL; 402 NFSVNO_SETACTIVE(&nva2, vaflags); 403 } 404 nd->nd_repstat = nfsvno_setattr(vp, &nva2, nd->nd_cred, p, 405 exp); 406 if (!nd->nd_repstat) { 407 if (NFSISSET_ATTRBIT(&attrbits, NFSATTRBIT_TIMEACCESSSET)) 408 NFSSETBIT_ATTRBIT(&retbits, NFSATTRBIT_TIMEACCESSSET); 409 if (NFSISSET_ATTRBIT(&attrbits, NFSATTRBIT_TIMEMODIFYSET)) 410 NFSSETBIT_ATTRBIT(&retbits, NFSATTRBIT_TIMEMODIFYSET); 411 } 412 } 413 if (!nd->nd_repstat && 414 NFSISSET_ATTRBIT(&attrbits, NFSATTRBIT_MODE)) { 415 NFSVNO_ATTRINIT(&nva2); 416 NFSVNO_SETATTRVAL(&nva2, mode, nva.na_mode); 417 nd->nd_repstat = nfsvno_setattr(vp, &nva2, nd->nd_cred, p, 418 exp); 419 if (!nd->nd_repstat) 420 NFSSETBIT_ATTRBIT(&retbits, NFSATTRBIT_MODE); 421 } 422 423 #ifdef NFS4_ACL_EXTATTR_NAME 424 if (!nd->nd_repstat && aclp->acl_cnt > 0 && 425 NFSISSET_ATTRBIT(&attrbits, NFSATTRBIT_ACL)) { 426 nd->nd_repstat = nfsrv_setacl(vp, aclp, nd->nd_cred, p); 427 if (!nd->nd_repstat) 428 NFSSETBIT_ATTRBIT(&retbits, NFSATTRBIT_ACL); 429 } 430 #endif 431 } else if (!nd->nd_repstat) { 432 nd->nd_repstat = nfsvno_setattr(vp, &nva, nd->nd_cred, p, 433 exp); 434 } 435 if (nd->nd_flag & (ND_NFSV2 | ND_NFSV3)) { 436 postat_ret = nfsvno_getattr(vp, &nva, nd->nd_cred, p, 1); 437 if (!nd->nd_repstat) 438 nd->nd_repstat = postat_ret; 439 } 440 vput(vp); 441 #ifdef NFS4_ACL_EXTATTR_NAME 442 acl_free(aclp); 443 #endif 444 if (nd->nd_flag & ND_NFSV3) 445 nfsrv_wcc(nd, preat_ret, &nva2, postat_ret, &nva); 446 else if (nd->nd_flag & ND_NFSV4) 447 (void) nfsrv_putattrbit(nd, &retbits); 448 else if (!nd->nd_repstat) 449 nfsrv_fillattr(nd, &nva); 450 451 out: 452 NFSEXITCODE2(0, nd); 453 return (0); 454 nfsmout: 455 vput(vp); 456 #ifdef NFS4_ACL_EXTATTR_NAME 457 acl_free(aclp); 458 #endif 459 if (nd->nd_flag & ND_NFSV4) { 460 /* 461 * For all nd_repstat, the V4 reply includes a bitmap, 462 * even NFSERR_BADXDR, which is what this will end up 463 * returning. 464 */ 465 (void) nfsrv_putattrbit(nd, &retbits); 466 } 467 NFSEXITCODE2(error, nd); 468 return (error); 469 } 470 471 /* 472 * nfs lookup rpc 473 * (Also performs lookup parent for v4) 474 */ 475 APPLESTATIC int 476 nfsrvd_lookup(struct nfsrv_descript *nd, __unused int isdgram, 477 vnode_t dp, vnode_t *vpp, fhandle_t *fhp, NFSPROC_T *p, 478 struct nfsexstuff *exp) 479 { 480 struct nameidata named; 481 vnode_t vp, dirp = NULL; 482 int error = 0, dattr_ret = 1; 483 struct nfsvattr nva, dattr; 484 char *bufp; 485 u_long *hashp; 486 487 if (nd->nd_repstat) { 488 nfsrv_postopattr(nd, dattr_ret, &dattr); 489 goto out; 490 } 491 492 /* 493 * For some reason, if dp is a symlink, the error 494 * returned is supposed to be NFSERR_SYMLINK and not NFSERR_NOTDIR. 495 */ 496 if (dp->v_type == VLNK && (nd->nd_flag & ND_NFSV4)) { 497 nd->nd_repstat = NFSERR_SYMLINK; 498 vrele(dp); 499 goto out; 500 } 501 502 NFSNAMEICNDSET(&named.ni_cnd, nd->nd_cred, LOOKUP, 503 LOCKLEAF | SAVESTART); 504 nfsvno_setpathbuf(&named, &bufp, &hashp); 505 error = nfsrv_parsename(nd, bufp, hashp, &named.ni_pathlen); 506 if (error) { 507 vrele(dp); 508 nfsvno_relpathbuf(&named); 509 goto out; 510 } 511 if (!nd->nd_repstat) { 512 nd->nd_repstat = nfsvno_namei(nd, &named, dp, 0, exp, p, &dirp); 513 } else { 514 vrele(dp); 515 nfsvno_relpathbuf(&named); 516 } 517 if (nd->nd_repstat) { 518 if (dirp) { 519 if (nd->nd_flag & ND_NFSV3) 520 dattr_ret = nfsvno_getattr(dirp, &dattr, 521 nd->nd_cred, p, 0); 522 vrele(dirp); 523 } 524 if (nd->nd_flag & ND_NFSV3) 525 nfsrv_postopattr(nd, dattr_ret, &dattr); 526 goto out; 527 } 528 if (named.ni_startdir) 529 vrele(named.ni_startdir); 530 nfsvno_relpathbuf(&named); 531 vp = named.ni_vp; 532 if ((nd->nd_flag & ND_NFSV4) != 0 && !NFSVNO_EXPORTED(exp) && 533 vp->v_type != VDIR && vp->v_type != VLNK) 534 /* 535 * Only allow lookup of VDIR and VLNK for traversal of 536 * non-exported volumes during NFSv4 mounting. 537 */ 538 nd->nd_repstat = ENOENT; 539 if (nd->nd_repstat == 0) 540 nd->nd_repstat = nfsvno_getfh(vp, fhp, p); 541 if (!(nd->nd_flag & ND_NFSV4) && !nd->nd_repstat) 542 nd->nd_repstat = nfsvno_getattr(vp, &nva, nd->nd_cred, p, 1); 543 if (vpp != NULL && nd->nd_repstat == 0) 544 *vpp = vp; 545 else 546 vput(vp); 547 if (dirp) { 548 if (nd->nd_flag & ND_NFSV3) 549 dattr_ret = nfsvno_getattr(dirp, &dattr, nd->nd_cred, 550 p, 0); 551 vrele(dirp); 552 } 553 if (nd->nd_repstat) { 554 if (nd->nd_flag & ND_NFSV3) 555 nfsrv_postopattr(nd, dattr_ret, &dattr); 556 goto out; 557 } 558 if (nd->nd_flag & ND_NFSV2) { 559 (void) nfsm_fhtom(nd, (u_int8_t *)fhp, 0, 0); 560 nfsrv_fillattr(nd, &nva); 561 } else if (nd->nd_flag & ND_NFSV3) { 562 (void) nfsm_fhtom(nd, (u_int8_t *)fhp, 0, 0); 563 nfsrv_postopattr(nd, 0, &nva); 564 nfsrv_postopattr(nd, dattr_ret, &dattr); 565 } 566 567 out: 568 NFSEXITCODE2(error, nd); 569 return (error); 570 } 571 572 /* 573 * nfs readlink service 574 */ 575 APPLESTATIC int 576 nfsrvd_readlink(struct nfsrv_descript *nd, __unused int isdgram, 577 vnode_t vp, NFSPROC_T *p, __unused struct nfsexstuff *exp) 578 { 579 u_int32_t *tl; 580 mbuf_t mp = NULL, mpend = NULL; 581 int getret = 1, len; 582 struct nfsvattr nva; 583 584 if (nd->nd_repstat) { 585 nfsrv_postopattr(nd, getret, &nva); 586 goto out; 587 } 588 if (vnode_vtype(vp) != VLNK) { 589 if (nd->nd_flag & ND_NFSV2) 590 nd->nd_repstat = ENXIO; 591 else 592 nd->nd_repstat = EINVAL; 593 } 594 if (!nd->nd_repstat) 595 nd->nd_repstat = nfsvno_readlink(vp, nd->nd_cred, p, 596 &mp, &mpend, &len); 597 if (nd->nd_flag & ND_NFSV3) 598 getret = nfsvno_getattr(vp, &nva, nd->nd_cred, p, 1); 599 vput(vp); 600 if (nd->nd_flag & ND_NFSV3) 601 nfsrv_postopattr(nd, getret, &nva); 602 if (nd->nd_repstat) 603 goto out; 604 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED); 605 *tl = txdr_unsigned(len); 606 mbuf_setnext(nd->nd_mb, mp); 607 nd->nd_mb = mpend; 608 nd->nd_bpos = NFSMTOD(mpend, caddr_t) + mbuf_len(mpend); 609 610 out: 611 NFSEXITCODE2(0, nd); 612 return (0); 613 } 614 615 /* 616 * nfs read service 617 */ 618 APPLESTATIC int 619 nfsrvd_read(struct nfsrv_descript *nd, __unused int isdgram, 620 vnode_t vp, NFSPROC_T *p, struct nfsexstuff *exp) 621 { 622 u_int32_t *tl; 623 int error = 0, cnt, getret = 1, reqlen, eof = 0; 624 mbuf_t m2, m3; 625 struct nfsvattr nva; 626 off_t off = 0x0; 627 struct nfsstate st, *stp = &st; 628 struct nfslock lo, *lop = &lo; 629 nfsv4stateid_t stateid; 630 nfsquad_t clientid; 631 632 if (nd->nd_repstat) { 633 nfsrv_postopattr(nd, getret, &nva); 634 goto out; 635 } 636 if (nd->nd_flag & ND_NFSV2) { 637 NFSM_DISSECT(tl, u_int32_t *, 2 * NFSX_UNSIGNED); 638 off = (off_t)fxdr_unsigned(u_int32_t, *tl++); 639 reqlen = fxdr_unsigned(int, *tl); 640 } else if (nd->nd_flag & ND_NFSV3) { 641 NFSM_DISSECT(tl, u_int32_t *, 3 * NFSX_UNSIGNED); 642 off = fxdr_hyper(tl); 643 tl += 2; 644 reqlen = fxdr_unsigned(int, *tl); 645 } else { 646 NFSM_DISSECT(tl, u_int32_t *, NFSX_STATEID + 3*NFSX_UNSIGNED); 647 reqlen = fxdr_unsigned(int, *(tl + 6)); 648 } 649 if (reqlen > NFS_SRVMAXDATA(nd)) { 650 reqlen = NFS_SRVMAXDATA(nd); 651 } else if (reqlen < 0) { 652 error = EBADRPC; 653 goto nfsmout; 654 } 655 if (nd->nd_flag & ND_NFSV4) { 656 stp->ls_flags = (NFSLCK_CHECK | NFSLCK_READACCESS); 657 lop->lo_flags = NFSLCK_READ; 658 stp->ls_ownerlen = 0; 659 stp->ls_op = NULL; 660 stp->ls_uid = nd->nd_cred->cr_uid; 661 stp->ls_stateid.seqid = fxdr_unsigned(u_int32_t, *tl++); 662 clientid.lval[0] = stp->ls_stateid.other[0] = *tl++; 663 clientid.lval[1] = stp->ls_stateid.other[1] = *tl++; 664 if (nd->nd_flag & ND_IMPLIEDCLID) { 665 if (nd->nd_clientid.qval != clientid.qval) 666 printf("EEK! multiple clids\n"); 667 } else { 668 nd->nd_flag |= ND_IMPLIEDCLID; 669 nd->nd_clientid.qval = clientid.qval; 670 } 671 stp->ls_stateid.other[2] = *tl++; 672 off = fxdr_hyper(tl); 673 lop->lo_first = off; 674 tl += 2; 675 lop->lo_end = off + reqlen; 676 /* 677 * Paranoia, just in case it wraps around. 678 */ 679 if (lop->lo_end < off) 680 lop->lo_end = NFS64BITSSET; 681 } 682 if (vnode_vtype(vp) != VREG) { 683 if (nd->nd_flag & ND_NFSV3) 684 nd->nd_repstat = EINVAL; 685 else 686 nd->nd_repstat = (vnode_vtype(vp) == VDIR) ? EISDIR : 687 EINVAL; 688 } 689 getret = nfsvno_getattr(vp, &nva, nd->nd_cred, p, 1); 690 if (!nd->nd_repstat) 691 nd->nd_repstat = getret; 692 if (!nd->nd_repstat && 693 (nva.na_uid != nd->nd_cred->cr_uid || 694 NFSVNO_EXSTRICTACCESS(exp))) { 695 nd->nd_repstat = nfsvno_accchk(vp, VREAD, 696 nd->nd_cred, exp, p, 697 NFSACCCHK_ALLOWOWNER, NFSACCCHK_VPISLOCKED, NULL); 698 if (nd->nd_repstat) 699 nd->nd_repstat = nfsvno_accchk(vp, VEXEC, 700 nd->nd_cred, exp, p, NFSACCCHK_ALLOWOWNER, 701 NFSACCCHK_VPISLOCKED, NULL); 702 } 703 if ((nd->nd_flag & ND_NFSV4) && !nd->nd_repstat) 704 nd->nd_repstat = nfsrv_lockctrl(vp, &stp, &lop, NULL, clientid, 705 &stateid, exp, nd, p); 706 if (nd->nd_repstat) { 707 vput(vp); 708 if (nd->nd_flag & ND_NFSV3) 709 nfsrv_postopattr(nd, getret, &nva); 710 goto out; 711 } 712 if (off >= nva.na_size) { 713 cnt = 0; 714 eof = 1; 715 } else if (reqlen == 0) 716 cnt = 0; 717 else if ((off + reqlen) >= nva.na_size) { 718 cnt = nva.na_size - off; 719 eof = 1; 720 } else 721 cnt = reqlen; 722 m3 = NULL; 723 if (cnt > 0) { 724 nd->nd_repstat = nfsvno_read(vp, off, cnt, nd->nd_cred, p, 725 &m3, &m2); 726 if (!(nd->nd_flag & ND_NFSV4)) { 727 getret = nfsvno_getattr(vp, &nva, nd->nd_cred, p, 1); 728 if (!nd->nd_repstat) 729 nd->nd_repstat = getret; 730 } 731 if (nd->nd_repstat) { 732 vput(vp); 733 if (m3) 734 mbuf_freem(m3); 735 if (nd->nd_flag & ND_NFSV3) 736 nfsrv_postopattr(nd, getret, &nva); 737 goto out; 738 } 739 } 740 vput(vp); 741 if (nd->nd_flag & ND_NFSV2) { 742 nfsrv_fillattr(nd, &nva); 743 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED); 744 } else { 745 if (nd->nd_flag & ND_NFSV3) { 746 nfsrv_postopattr(nd, getret, &nva); 747 NFSM_BUILD(tl, u_int32_t *, 3 * NFSX_UNSIGNED); 748 *tl++ = txdr_unsigned(cnt); 749 } else 750 NFSM_BUILD(tl, u_int32_t *, 2 * NFSX_UNSIGNED); 751 if (eof) 752 *tl++ = newnfs_true; 753 else 754 *tl++ = newnfs_false; 755 } 756 *tl = txdr_unsigned(cnt); 757 if (m3) { 758 mbuf_setnext(nd->nd_mb, m3); 759 nd->nd_mb = m2; 760 nd->nd_bpos = NFSMTOD(m2, caddr_t) + mbuf_len(m2); 761 } 762 763 out: 764 NFSEXITCODE2(0, nd); 765 return (0); 766 nfsmout: 767 vput(vp); 768 NFSEXITCODE2(error, nd); 769 return (error); 770 } 771 772 /* 773 * nfs write service 774 */ 775 APPLESTATIC int 776 nfsrvd_write(struct nfsrv_descript *nd, __unused int isdgram, 777 vnode_t vp, NFSPROC_T *p, struct nfsexstuff *exp) 778 { 779 int i, cnt; 780 u_int32_t *tl; 781 mbuf_t mp; 782 struct nfsvattr nva, forat; 783 int aftat_ret = 1, retlen, len, error = 0, forat_ret = 1; 784 int stable = NFSWRITE_FILESYNC; 785 off_t off; 786 struct nfsstate st, *stp = &st; 787 struct nfslock lo, *lop = &lo; 788 nfsv4stateid_t stateid; 789 nfsquad_t clientid; 790 791 if (nd->nd_repstat) { 792 nfsrv_wcc(nd, forat_ret, &forat, aftat_ret, &nva); 793 goto out; 794 } 795 if (nd->nd_flag & ND_NFSV2) { 796 NFSM_DISSECT(tl, u_int32_t *, 4 * NFSX_UNSIGNED); 797 off = (off_t)fxdr_unsigned(u_int32_t, *++tl); 798 tl += 2; 799 retlen = len = fxdr_unsigned(int32_t, *tl); 800 } else if (nd->nd_flag & ND_NFSV3) { 801 NFSM_DISSECT(tl, u_int32_t *, 5 * NFSX_UNSIGNED); 802 off = fxdr_hyper(tl); 803 tl += 3; 804 stable = fxdr_unsigned(int, *tl++); 805 retlen = len = fxdr_unsigned(int32_t, *tl); 806 } else { 807 NFSM_DISSECT(tl, u_int32_t *, NFSX_STATEID + 4 * NFSX_UNSIGNED); 808 stp->ls_flags = (NFSLCK_CHECK | NFSLCK_WRITEACCESS); 809 lop->lo_flags = NFSLCK_WRITE; 810 stp->ls_ownerlen = 0; 811 stp->ls_op = NULL; 812 stp->ls_uid = nd->nd_cred->cr_uid; 813 stp->ls_stateid.seqid = fxdr_unsigned(u_int32_t, *tl++); 814 clientid.lval[0] = stp->ls_stateid.other[0] = *tl++; 815 clientid.lval[1] = stp->ls_stateid.other[1] = *tl++; 816 if (nd->nd_flag & ND_IMPLIEDCLID) { 817 if (nd->nd_clientid.qval != clientid.qval) 818 printf("EEK! multiple clids\n"); 819 } else { 820 nd->nd_flag |= ND_IMPLIEDCLID; 821 nd->nd_clientid.qval = clientid.qval; 822 } 823 stp->ls_stateid.other[2] = *tl++; 824 off = fxdr_hyper(tl); 825 lop->lo_first = off; 826 tl += 2; 827 stable = fxdr_unsigned(int, *tl++); 828 retlen = len = fxdr_unsigned(int32_t, *tl); 829 lop->lo_end = off + len; 830 /* 831 * Paranoia, just in case it wraps around, which shouldn't 832 * ever happen anyhow. 833 */ 834 if (lop->lo_end < lop->lo_first) 835 lop->lo_end = NFS64BITSSET; 836 } 837 838 /* 839 * Loop through the mbuf chain, counting how many mbufs are a 840 * part of this write operation, so the iovec size is known. 841 */ 842 cnt = 0; 843 mp = nd->nd_md; 844 i = NFSMTOD(mp, caddr_t) + mbuf_len(mp) - nd->nd_dpos; 845 while (len > 0) { 846 if (i > 0) { 847 len -= i; 848 cnt++; 849 } 850 mp = mbuf_next(mp); 851 if (!mp) { 852 if (len > 0) { 853 error = EBADRPC; 854 goto nfsmout; 855 } 856 } else 857 i = mbuf_len(mp); 858 } 859 860 if (retlen > NFS_MAXDATA || retlen < 0) 861 nd->nd_repstat = EIO; 862 if (vnode_vtype(vp) != VREG && !nd->nd_repstat) { 863 if (nd->nd_flag & ND_NFSV3) 864 nd->nd_repstat = EINVAL; 865 else 866 nd->nd_repstat = (vnode_vtype(vp) == VDIR) ? EISDIR : 867 EINVAL; 868 } 869 forat_ret = nfsvno_getattr(vp, &forat, nd->nd_cred, p, 1); 870 if (!nd->nd_repstat) 871 nd->nd_repstat = forat_ret; 872 if (!nd->nd_repstat && 873 (forat.na_uid != nd->nd_cred->cr_uid || 874 NFSVNO_EXSTRICTACCESS(exp))) 875 nd->nd_repstat = nfsvno_accchk(vp, VWRITE, 876 nd->nd_cred, exp, p, 877 NFSACCCHK_ALLOWOWNER, NFSACCCHK_VPISLOCKED, NULL); 878 if ((nd->nd_flag & ND_NFSV4) && !nd->nd_repstat) { 879 nd->nd_repstat = nfsrv_lockctrl(vp, &stp, &lop, NULL, clientid, 880 &stateid, exp, nd, p); 881 } 882 if (nd->nd_repstat) { 883 vput(vp); 884 if (nd->nd_flag & ND_NFSV3) 885 nfsrv_wcc(nd, forat_ret, &forat, aftat_ret, &nva); 886 goto out; 887 } 888 889 /* 890 * For NFS Version 2, it is not obvious what a write of zero length 891 * should do, but I might as well be consistent with Version 3, 892 * which is to return ok so long as there are no permission problems. 893 */ 894 if (retlen > 0) { 895 nd->nd_repstat = nfsvno_write(vp, off, retlen, cnt, stable, 896 nd->nd_md, nd->nd_dpos, nd->nd_cred, p); 897 error = nfsm_advance(nd, NFSM_RNDUP(retlen), -1); 898 if (error) 899 panic("nfsrv_write mbuf"); 900 } 901 if (nd->nd_flag & ND_NFSV4) 902 aftat_ret = 0; 903 else 904 aftat_ret = nfsvno_getattr(vp, &nva, nd->nd_cred, p, 1); 905 vput(vp); 906 if (!nd->nd_repstat) 907 nd->nd_repstat = aftat_ret; 908 if (nd->nd_flag & (ND_NFSV3 | ND_NFSV4)) { 909 if (nd->nd_flag & ND_NFSV3) 910 nfsrv_wcc(nd, forat_ret, &forat, aftat_ret, &nva); 911 if (nd->nd_repstat) 912 goto out; 913 NFSM_BUILD(tl, u_int32_t *, 4 * NFSX_UNSIGNED); 914 *tl++ = txdr_unsigned(retlen); 915 if (stable == NFSWRITE_UNSTABLE) 916 *tl++ = txdr_unsigned(stable); 917 else 918 *tl++ = txdr_unsigned(NFSWRITE_FILESYNC); 919 /* 920 * Actually, there is no need to txdr these fields, 921 * but it may make the values more human readable, 922 * for debugging purposes. 923 */ 924 *tl++ = txdr_unsigned(nfsboottime.tv_sec); 925 *tl = txdr_unsigned(nfsboottime.tv_usec); 926 } else if (!nd->nd_repstat) 927 nfsrv_fillattr(nd, &nva); 928 929 out: 930 NFSEXITCODE2(0, nd); 931 return (0); 932 nfsmout: 933 vput(vp); 934 NFSEXITCODE2(error, nd); 935 return (error); 936 } 937 938 /* 939 * nfs create service (creates regular files for V2 and V3. Spec. files for V2.) 940 * now does a truncate to 0 length via. setattr if it already exists 941 * The core creation routine has been extracted out into nfsrv_creatsub(), 942 * so it can also be used by nfsrv_open() for V4. 943 */ 944 APPLESTATIC int 945 nfsrvd_create(struct nfsrv_descript *nd, __unused int isdgram, 946 vnode_t dp, NFSPROC_T *p, struct nfsexstuff *exp) 947 { 948 struct nfsvattr nva, dirfor, diraft; 949 struct nfsv2_sattr *sp; 950 struct nameidata named; 951 u_int32_t *tl; 952 int error = 0, tsize, dirfor_ret = 1, diraft_ret = 1; 953 int how = NFSCREATE_UNCHECKED, exclusive_flag = 0; 954 NFSDEV_T rdev = 0; 955 vnode_t vp = NULL, dirp = NULL; 956 fhandle_t fh; 957 char *bufp; 958 u_long *hashp; 959 enum vtype vtyp; 960 int32_t cverf[2], tverf[2] = { 0, 0 }; 961 962 if (nd->nd_repstat) { 963 nfsrv_wcc(nd, dirfor_ret, &dirfor, diraft_ret, &diraft); 964 goto out; 965 } 966 NFSNAMEICNDSET(&named.ni_cnd, nd->nd_cred, CREATE, 967 LOCKPARENT | LOCKLEAF | SAVESTART); 968 nfsvno_setpathbuf(&named, &bufp, &hashp); 969 error = nfsrv_parsename(nd, bufp, hashp, &named.ni_pathlen); 970 if (error) 971 goto nfsmout; 972 if (!nd->nd_repstat) { 973 NFSVNO_ATTRINIT(&nva); 974 if (nd->nd_flag & ND_NFSV2) { 975 NFSM_DISSECT(sp, struct nfsv2_sattr *, NFSX_V2SATTR); 976 vtyp = IFTOVT(fxdr_unsigned(u_int32_t, sp->sa_mode)); 977 if (vtyp == VNON) 978 vtyp = VREG; 979 NFSVNO_SETATTRVAL(&nva, type, vtyp); 980 NFSVNO_SETATTRVAL(&nva, mode, 981 nfstov_mode(sp->sa_mode)); 982 switch (nva.na_type) { 983 case VREG: 984 tsize = fxdr_unsigned(int32_t, sp->sa_size); 985 if (tsize != -1) 986 NFSVNO_SETATTRVAL(&nva, size, 987 (u_quad_t)tsize); 988 break; 989 case VCHR: 990 case VBLK: 991 case VFIFO: 992 rdev = fxdr_unsigned(NFSDEV_T, sp->sa_size); 993 break; 994 default: 995 break; 996 }; 997 } else { 998 NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED); 999 how = fxdr_unsigned(int, *tl); 1000 switch (how) { 1001 case NFSCREATE_GUARDED: 1002 case NFSCREATE_UNCHECKED: 1003 error = nfsrv_sattr(nd, &nva, NULL, NULL, p); 1004 if (error) 1005 goto nfsmout; 1006 break; 1007 case NFSCREATE_EXCLUSIVE: 1008 NFSM_DISSECT(tl, u_int32_t *, NFSX_VERF); 1009 cverf[0] = *tl++; 1010 cverf[1] = *tl; 1011 exclusive_flag = 1; 1012 break; 1013 }; 1014 NFSVNO_SETATTRVAL(&nva, type, VREG); 1015 } 1016 } 1017 if (nd->nd_repstat) { 1018 nfsvno_relpathbuf(&named); 1019 if (nd->nd_flag & ND_NFSV3) { 1020 dirfor_ret = nfsvno_getattr(dp, &dirfor, nd->nd_cred, 1021 p, 1); 1022 nfsrv_wcc(nd, dirfor_ret, &dirfor, diraft_ret, 1023 &diraft); 1024 } 1025 vput(dp); 1026 goto out; 1027 } 1028 1029 nd->nd_repstat = nfsvno_namei(nd, &named, dp, 1, exp, p, &dirp); 1030 if (dirp) { 1031 if (nd->nd_flag & ND_NFSV2) { 1032 vrele(dirp); 1033 dirp = NULL; 1034 } else { 1035 dirfor_ret = nfsvno_getattr(dirp, &dirfor, nd->nd_cred, 1036 p, 0); 1037 } 1038 } 1039 if (nd->nd_repstat) { 1040 if (nd->nd_flag & ND_NFSV3) 1041 nfsrv_wcc(nd, dirfor_ret, &dirfor, diraft_ret, 1042 &diraft); 1043 if (dirp) 1044 vrele(dirp); 1045 goto out; 1046 } 1047 1048 if (!(nd->nd_flag & ND_NFSV2)) { 1049 switch (how) { 1050 case NFSCREATE_GUARDED: 1051 if (named.ni_vp) 1052 nd->nd_repstat = EEXIST; 1053 break; 1054 case NFSCREATE_UNCHECKED: 1055 break; 1056 case NFSCREATE_EXCLUSIVE: 1057 if (named.ni_vp == NULL) 1058 NFSVNO_SETATTRVAL(&nva, mode, 0); 1059 break; 1060 }; 1061 } 1062 1063 /* 1064 * Iff doesn't exist, create it 1065 * otherwise just truncate to 0 length 1066 * should I set the mode too ? 1067 */ 1068 nd->nd_repstat = nfsvno_createsub(nd, &named, &vp, &nva, 1069 &exclusive_flag, cverf, rdev, p, exp); 1070 1071 if (!nd->nd_repstat) { 1072 nd->nd_repstat = nfsvno_getfh(vp, &fh, p); 1073 if (!nd->nd_repstat) 1074 nd->nd_repstat = nfsvno_getattr(vp, &nva, nd->nd_cred, 1075 p, 1); 1076 vput(vp); 1077 if (!nd->nd_repstat) { 1078 tverf[0] = nva.na_atime.tv_sec; 1079 tverf[1] = nva.na_atime.tv_nsec; 1080 } 1081 } 1082 if (nd->nd_flag & ND_NFSV2) { 1083 if (!nd->nd_repstat) { 1084 (void) nfsm_fhtom(nd, (u_int8_t *)&fh, 0, 0); 1085 nfsrv_fillattr(nd, &nva); 1086 } 1087 } else { 1088 if (exclusive_flag && !nd->nd_repstat && (cverf[0] != tverf[0] 1089 || cverf[1] != tverf[1])) 1090 nd->nd_repstat = EEXIST; 1091 diraft_ret = nfsvno_getattr(dirp, &diraft, nd->nd_cred, p, 0); 1092 vrele(dirp); 1093 if (!nd->nd_repstat) { 1094 (void) nfsm_fhtom(nd, (u_int8_t *)&fh, 0, 1); 1095 nfsrv_postopattr(nd, 0, &nva); 1096 } 1097 nfsrv_wcc(nd, dirfor_ret, &dirfor, diraft_ret, &diraft); 1098 } 1099 1100 out: 1101 NFSEXITCODE2(0, nd); 1102 return (0); 1103 nfsmout: 1104 vput(dp); 1105 nfsvno_relpathbuf(&named); 1106 NFSEXITCODE2(error, nd); 1107 return (error); 1108 } 1109 1110 /* 1111 * nfs v3 mknod service (and v4 create) 1112 */ 1113 APPLESTATIC int 1114 nfsrvd_mknod(struct nfsrv_descript *nd, __unused int isdgram, 1115 vnode_t dp, vnode_t *vpp, fhandle_t *fhp, NFSPROC_T *p, 1116 struct nfsexstuff *exp) 1117 { 1118 struct nfsvattr nva, dirfor, diraft; 1119 u_int32_t *tl; 1120 struct nameidata named; 1121 int error = 0, dirfor_ret = 1, diraft_ret = 1, pathlen; 1122 u_int32_t major, minor; 1123 enum vtype vtyp = VNON; 1124 nfstype nfs4type = NFNON; 1125 vnode_t vp, dirp = NULL; 1126 nfsattrbit_t attrbits; 1127 char *bufp = NULL, *pathcp = NULL; 1128 u_long *hashp, cnflags; 1129 NFSACL_T *aclp = NULL; 1130 1131 NFSVNO_ATTRINIT(&nva); 1132 cnflags = (LOCKPARENT | SAVESTART); 1133 if (nd->nd_repstat) { 1134 nfsrv_wcc(nd, dirfor_ret, &dirfor, diraft_ret, &diraft); 1135 goto out; 1136 } 1137 #ifdef NFS4_ACL_EXTATTR_NAME 1138 aclp = acl_alloc(M_WAITOK); 1139 aclp->acl_cnt = 0; 1140 #endif 1141 1142 /* 1143 * For V4, the creation stuff is here, Yuck! 1144 */ 1145 if (nd->nd_flag & ND_NFSV4) { 1146 NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED); 1147 vtyp = nfsv34tov_type(*tl); 1148 nfs4type = fxdr_unsigned(nfstype, *tl); 1149 switch (nfs4type) { 1150 case NFLNK: 1151 error = nfsvno_getsymlink(nd, &nva, p, &pathcp, 1152 &pathlen); 1153 if (error) 1154 goto nfsmout; 1155 break; 1156 case NFCHR: 1157 case NFBLK: 1158 NFSM_DISSECT(tl, u_int32_t *, 2 * NFSX_UNSIGNED); 1159 major = fxdr_unsigned(u_int32_t, *tl++); 1160 minor = fxdr_unsigned(u_int32_t, *tl); 1161 nva.na_rdev = NFSMAKEDEV(major, minor); 1162 break; 1163 case NFSOCK: 1164 case NFFIFO: 1165 break; 1166 case NFDIR: 1167 cnflags = (LOCKPARENT | SAVENAME); 1168 break; 1169 default: 1170 nd->nd_repstat = NFSERR_BADTYPE; 1171 vrele(dp); 1172 #ifdef NFS4_ACL_EXTATTR_NAME 1173 acl_free(aclp); 1174 #endif 1175 goto out; 1176 } 1177 } 1178 NFSNAMEICNDSET(&named.ni_cnd, nd->nd_cred, CREATE, cnflags); 1179 nfsvno_setpathbuf(&named, &bufp, &hashp); 1180 error = nfsrv_parsename(nd, bufp, hashp, &named.ni_pathlen); 1181 if (error) 1182 goto nfsmout; 1183 if (!nd->nd_repstat) { 1184 if (nd->nd_flag & ND_NFSV3) { 1185 NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED); 1186 vtyp = nfsv34tov_type(*tl); 1187 } 1188 error = nfsrv_sattr(nd, &nva, &attrbits, aclp, p); 1189 if (error) 1190 goto nfsmout; 1191 nva.na_type = vtyp; 1192 if (!nd->nd_repstat && (nd->nd_flag & ND_NFSV3) && 1193 (vtyp == VCHR || vtyp == VBLK)) { 1194 NFSM_DISSECT(tl, u_int32_t *, 2 * NFSX_UNSIGNED); 1195 major = fxdr_unsigned(u_int32_t, *tl++); 1196 minor = fxdr_unsigned(u_int32_t, *tl); 1197 nva.na_rdev = NFSMAKEDEV(major, minor); 1198 } 1199 } 1200 1201 dirfor_ret = nfsvno_getattr(dp, &dirfor, nd->nd_cred, p, 0); 1202 if (!nd->nd_repstat && (nd->nd_flag & ND_NFSV4)) { 1203 if (!dirfor_ret && NFSVNO_ISSETGID(&nva) && 1204 dirfor.na_gid == nva.na_gid) 1205 NFSVNO_UNSET(&nva, gid); 1206 nd->nd_repstat = nfsrv_checkuidgid(nd, &nva); 1207 } 1208 if (nd->nd_repstat) { 1209 vrele(dp); 1210 #ifdef NFS4_ACL_EXTATTR_NAME 1211 acl_free(aclp); 1212 #endif 1213 nfsvno_relpathbuf(&named); 1214 if (pathcp) 1215 FREE(pathcp, M_TEMP); 1216 if (nd->nd_flag & ND_NFSV3) 1217 nfsrv_wcc(nd, dirfor_ret, &dirfor, diraft_ret, 1218 &diraft); 1219 goto out; 1220 } 1221 1222 /* 1223 * Yuck! For V4, mkdir and link are here and some V4 clients don't fill 1224 * in va_mode, so we'll have to set a default here. 1225 */ 1226 if (NFSVNO_NOTSETMODE(&nva)) { 1227 if (vtyp == VLNK) 1228 nva.na_mode = 0755; 1229 else 1230 nva.na_mode = 0400; 1231 } 1232 1233 if (vtyp == VDIR) 1234 named.ni_cnd.cn_flags |= WILLBEDIR; 1235 nd->nd_repstat = nfsvno_namei(nd, &named, dp, 0, exp, p, &dirp); 1236 if (nd->nd_repstat) { 1237 if (dirp) { 1238 if (nd->nd_flag & ND_NFSV3) 1239 dirfor_ret = nfsvno_getattr(dirp, &dirfor, 1240 nd->nd_cred, p, 0); 1241 vrele(dirp); 1242 } 1243 #ifdef NFS4_ACL_EXTATTR_NAME 1244 acl_free(aclp); 1245 #endif 1246 if (nd->nd_flag & ND_NFSV3) 1247 nfsrv_wcc(nd, dirfor_ret, &dirfor, diraft_ret, 1248 &diraft); 1249 goto out; 1250 } 1251 if (dirp) 1252 dirfor_ret = nfsvno_getattr(dirp, &dirfor, nd->nd_cred, p, 0); 1253 1254 if ((nd->nd_flag & ND_NFSV4) && (vtyp == VDIR || vtyp == VLNK)) { 1255 if (vtyp == VDIR) { 1256 nfsrvd_mkdirsub(nd, &named, &nva, fhp, vpp, dirp, 1257 &dirfor, &diraft, &diraft_ret, &attrbits, aclp, p, 1258 exp); 1259 #ifdef NFS4_ACL_EXTATTR_NAME 1260 acl_free(aclp); 1261 #endif 1262 goto out; 1263 } else if (vtyp == VLNK) { 1264 nfsrvd_symlinksub(nd, &named, &nva, fhp, vpp, dirp, 1265 &dirfor, &diraft, &diraft_ret, &attrbits, 1266 aclp, p, exp, pathcp, pathlen); 1267 #ifdef NFS4_ACL_EXTATTR_NAME 1268 acl_free(aclp); 1269 #endif 1270 FREE(pathcp, M_TEMP); 1271 goto out; 1272 } 1273 } 1274 1275 nd->nd_repstat = nfsvno_mknod(&named, &nva, nd->nd_cred, p); 1276 if (!nd->nd_repstat) { 1277 vp = named.ni_vp; 1278 nfsrv_fixattr(nd, vp, &nva, aclp, p, &attrbits, exp); 1279 nd->nd_repstat = nfsvno_getfh(vp, fhp, p); 1280 if ((nd->nd_flag & ND_NFSV3) && !nd->nd_repstat) 1281 nd->nd_repstat = nfsvno_getattr(vp, &nva, nd->nd_cred, 1282 p, 1); 1283 if (vpp != NULL && nd->nd_repstat == 0) { 1284 NFSVOPUNLOCK(vp, 0); 1285 *vpp = vp; 1286 } else 1287 vput(vp); 1288 } 1289 1290 diraft_ret = nfsvno_getattr(dirp, &diraft, nd->nd_cred, p, 0); 1291 vrele(dirp); 1292 if (!nd->nd_repstat) { 1293 if (nd->nd_flag & ND_NFSV3) { 1294 (void) nfsm_fhtom(nd, (u_int8_t *)fhp, 0, 1); 1295 nfsrv_postopattr(nd, 0, &nva); 1296 } else { 1297 NFSM_BUILD(tl, u_int32_t *, 5 * NFSX_UNSIGNED); 1298 *tl++ = newnfs_false; 1299 txdr_hyper(dirfor.na_filerev, tl); 1300 tl += 2; 1301 txdr_hyper(diraft.na_filerev, tl); 1302 (void) nfsrv_putattrbit(nd, &attrbits); 1303 } 1304 } 1305 if (nd->nd_flag & ND_NFSV3) 1306 nfsrv_wcc(nd, dirfor_ret, &dirfor, diraft_ret, &diraft); 1307 #ifdef NFS4_ACL_EXTATTR_NAME 1308 acl_free(aclp); 1309 #endif 1310 1311 out: 1312 NFSEXITCODE2(0, nd); 1313 return (0); 1314 nfsmout: 1315 vrele(dp); 1316 #ifdef NFS4_ACL_EXTATTR_NAME 1317 acl_free(aclp); 1318 #endif 1319 if (bufp) 1320 nfsvno_relpathbuf(&named); 1321 if (pathcp) 1322 FREE(pathcp, M_TEMP); 1323 1324 NFSEXITCODE2(error, nd); 1325 return (error); 1326 } 1327 1328 /* 1329 * nfs remove service 1330 */ 1331 APPLESTATIC int 1332 nfsrvd_remove(struct nfsrv_descript *nd, __unused int isdgram, 1333 vnode_t dp, NFSPROC_T *p, struct nfsexstuff *exp) 1334 { 1335 struct nameidata named; 1336 u_int32_t *tl; 1337 int error = 0, dirfor_ret = 1, diraft_ret = 1; 1338 vnode_t dirp = NULL; 1339 struct nfsvattr dirfor, diraft; 1340 char *bufp; 1341 u_long *hashp; 1342 1343 if (nd->nd_repstat) { 1344 nfsrv_wcc(nd, dirfor_ret, &dirfor, diraft_ret, &diraft); 1345 goto out; 1346 } 1347 NFSNAMEICNDSET(&named.ni_cnd, nd->nd_cred, DELETE, 1348 LOCKPARENT | LOCKLEAF); 1349 nfsvno_setpathbuf(&named, &bufp, &hashp); 1350 error = nfsrv_parsename(nd, bufp, hashp, &named.ni_pathlen); 1351 if (error) { 1352 vput(dp); 1353 nfsvno_relpathbuf(&named); 1354 goto out; 1355 } 1356 if (!nd->nd_repstat) { 1357 nd->nd_repstat = nfsvno_namei(nd, &named, dp, 1, exp, p, &dirp); 1358 } else { 1359 vput(dp); 1360 nfsvno_relpathbuf(&named); 1361 } 1362 if (dirp) { 1363 if (!(nd->nd_flag & ND_NFSV2)) { 1364 dirfor_ret = nfsvno_getattr(dirp, &dirfor, 1365 nd->nd_cred, p, 0); 1366 } else { 1367 vrele(dirp); 1368 dirp = NULL; 1369 } 1370 } 1371 if (!nd->nd_repstat) { 1372 if (nd->nd_flag & ND_NFSV4) { 1373 if (vnode_vtype(named.ni_vp) == VDIR) 1374 nd->nd_repstat = nfsvno_rmdirsub(&named, 1, 1375 nd->nd_cred, p, exp); 1376 else 1377 nd->nd_repstat = nfsvno_removesub(&named, 1, 1378 nd->nd_cred, p, exp); 1379 } else if (nd->nd_procnum == NFSPROC_RMDIR) { 1380 nd->nd_repstat = nfsvno_rmdirsub(&named, 0, 1381 nd->nd_cred, p, exp); 1382 } else { 1383 nd->nd_repstat = nfsvno_removesub(&named, 0, 1384 nd->nd_cred, p, exp); 1385 } 1386 } 1387 if (!(nd->nd_flag & ND_NFSV2)) { 1388 if (dirp) { 1389 diraft_ret = nfsvno_getattr(dirp, &diraft, nd->nd_cred, 1390 p, 0); 1391 vrele(dirp); 1392 } 1393 if (nd->nd_flag & ND_NFSV3) { 1394 nfsrv_wcc(nd, dirfor_ret, &dirfor, diraft_ret, 1395 &diraft); 1396 } else if (!nd->nd_repstat) { 1397 NFSM_BUILD(tl, u_int32_t *, 5 * NFSX_UNSIGNED); 1398 *tl++ = newnfs_false; 1399 txdr_hyper(dirfor.na_filerev, tl); 1400 tl += 2; 1401 txdr_hyper(diraft.na_filerev, tl); 1402 } 1403 } 1404 1405 out: 1406 NFSEXITCODE2(error, nd); 1407 return (error); 1408 } 1409 1410 /* 1411 * nfs rename service 1412 */ 1413 APPLESTATIC int 1414 nfsrvd_rename(struct nfsrv_descript *nd, int isdgram, 1415 vnode_t dp, vnode_t todp, NFSPROC_T *p, struct nfsexstuff *exp, 1416 struct nfsexstuff *toexp) 1417 { 1418 u_int32_t *tl; 1419 int error = 0, fdirfor_ret = 1, fdiraft_ret = 1; 1420 int tdirfor_ret = 1, tdiraft_ret = 1; 1421 struct nameidata fromnd, tond; 1422 vnode_t fdirp = NULL, tdirp = NULL, tdp = NULL; 1423 struct nfsvattr fdirfor, fdiraft, tdirfor, tdiraft; 1424 struct nfsexstuff tnes; 1425 struct nfsrvfh tfh; 1426 char *bufp, *tbufp = NULL; 1427 u_long *hashp; 1428 fhandle_t fh; 1429 1430 if (nd->nd_repstat) { 1431 nfsrv_wcc(nd, fdirfor_ret, &fdirfor, fdiraft_ret, &fdiraft); 1432 nfsrv_wcc(nd, tdirfor_ret, &tdirfor, tdiraft_ret, &tdiraft); 1433 goto out; 1434 } 1435 if (!(nd->nd_flag & ND_NFSV2)) 1436 fdirfor_ret = nfsvno_getattr(dp, &fdirfor, nd->nd_cred, p, 1); 1437 tond.ni_cnd.cn_nameiop = 0; 1438 tond.ni_startdir = NULL; 1439 NFSNAMEICNDSET(&fromnd.ni_cnd, nd->nd_cred, DELETE, WANTPARENT | SAVESTART); 1440 nfsvno_setpathbuf(&fromnd, &bufp, &hashp); 1441 error = nfsrv_parsename(nd, bufp, hashp, &fromnd.ni_pathlen); 1442 if (error) { 1443 vput(dp); 1444 if (todp) 1445 vrele(todp); 1446 nfsvno_relpathbuf(&fromnd); 1447 goto out; 1448 } 1449 /* 1450 * Unlock dp in this code section, so it is unlocked before 1451 * tdp gets locked. This avoids a potential LOR if tdp is the 1452 * parent directory of dp. 1453 */ 1454 if (nd->nd_flag & ND_NFSV4) { 1455 tdp = todp; 1456 tnes = *toexp; 1457 if (dp != tdp) { 1458 NFSVOPUNLOCK(dp, 0); 1459 tdirfor_ret = nfsvno_getattr(tdp, &tdirfor, nd->nd_cred, 1460 p, 0); /* Might lock tdp. */ 1461 } else { 1462 tdirfor_ret = nfsvno_getattr(tdp, &tdirfor, nd->nd_cred, 1463 p, 1); 1464 NFSVOPUNLOCK(dp, 0); 1465 } 1466 } else { 1467 tfh.nfsrvfh_len = 0; 1468 error = nfsrv_mtofh(nd, &tfh); 1469 if (error == 0) 1470 error = nfsvno_getfh(dp, &fh, p); 1471 if (error) { 1472 vput(dp); 1473 /* todp is always NULL except NFSv4 */ 1474 nfsvno_relpathbuf(&fromnd); 1475 goto out; 1476 } 1477 1478 /* If this is the same file handle, just VREF() the vnode. */ 1479 if (tfh.nfsrvfh_len == NFSX_MYFH && 1480 !NFSBCMP(tfh.nfsrvfh_data, &fh, NFSX_MYFH)) { 1481 VREF(dp); 1482 tdp = dp; 1483 tnes = *exp; 1484 tdirfor_ret = nfsvno_getattr(tdp, &tdirfor, nd->nd_cred, 1485 p, 1); 1486 NFSVOPUNLOCK(dp, 0); 1487 } else { 1488 NFSVOPUNLOCK(dp, 0); 1489 nd->nd_cred->cr_uid = nd->nd_saveduid; 1490 nfsd_fhtovp(nd, &tfh, LK_EXCLUSIVE, &tdp, &tnes, NULL, 1491 0, p); /* Locks tdp. */ 1492 if (tdp) { 1493 tdirfor_ret = nfsvno_getattr(tdp, &tdirfor, 1494 nd->nd_cred, p, 1); 1495 NFSVOPUNLOCK(tdp, 0); 1496 } 1497 } 1498 } 1499 NFSNAMEICNDSET(&tond.ni_cnd, nd->nd_cred, RENAME, LOCKPARENT | LOCKLEAF | NOCACHE | SAVESTART); 1500 nfsvno_setpathbuf(&tond, &tbufp, &hashp); 1501 if (!nd->nd_repstat) { 1502 error = nfsrv_parsename(nd, tbufp, hashp, &tond.ni_pathlen); 1503 if (error) { 1504 if (tdp) 1505 vrele(tdp); 1506 vrele(dp); 1507 nfsvno_relpathbuf(&fromnd); 1508 nfsvno_relpathbuf(&tond); 1509 goto out; 1510 } 1511 } 1512 if (nd->nd_repstat) { 1513 if (nd->nd_flag & ND_NFSV3) { 1514 nfsrv_wcc(nd, fdirfor_ret, &fdirfor, fdiraft_ret, 1515 &fdiraft); 1516 nfsrv_wcc(nd, tdirfor_ret, &tdirfor, tdiraft_ret, 1517 &tdiraft); 1518 } 1519 if (tdp) 1520 vrele(tdp); 1521 vrele(dp); 1522 nfsvno_relpathbuf(&fromnd); 1523 nfsvno_relpathbuf(&tond); 1524 goto out; 1525 } 1526 1527 /* 1528 * Done parsing, now down to business. 1529 */ 1530 nd->nd_repstat = nfsvno_namei(nd, &fromnd, dp, 0, exp, p, &fdirp); 1531 if (nd->nd_repstat) { 1532 if (nd->nd_flag & ND_NFSV3) { 1533 nfsrv_wcc(nd, fdirfor_ret, &fdirfor, fdiraft_ret, 1534 &fdiraft); 1535 nfsrv_wcc(nd, tdirfor_ret, &tdirfor, tdiraft_ret, 1536 &tdiraft); 1537 } 1538 if (fdirp) 1539 vrele(fdirp); 1540 if (tdp) 1541 vrele(tdp); 1542 nfsvno_relpathbuf(&tond); 1543 goto out; 1544 } 1545 if (vnode_vtype(fromnd.ni_vp) == VDIR) 1546 tond.ni_cnd.cn_flags |= WILLBEDIR; 1547 nd->nd_repstat = nfsvno_namei(nd, &tond, tdp, 0, &tnes, p, &tdirp); 1548 nd->nd_repstat = nfsvno_rename(&fromnd, &tond, nd->nd_repstat, 1549 nd->nd_flag, nd->nd_cred, p); 1550 if (fdirp) 1551 fdiraft_ret = nfsvno_getattr(fdirp, &fdiraft, nd->nd_cred, p, 1552 0); 1553 if (tdirp) 1554 tdiraft_ret = nfsvno_getattr(tdirp, &tdiraft, nd->nd_cred, p, 1555 0); 1556 if (fdirp) 1557 vrele(fdirp); 1558 if (tdirp) 1559 vrele(tdirp); 1560 if (nd->nd_flag & ND_NFSV3) { 1561 nfsrv_wcc(nd, fdirfor_ret, &fdirfor, fdiraft_ret, &fdiraft); 1562 nfsrv_wcc(nd, tdirfor_ret, &tdirfor, tdiraft_ret, &tdiraft); 1563 } else if ((nd->nd_flag & ND_NFSV4) && !nd->nd_repstat) { 1564 NFSM_BUILD(tl, u_int32_t *, 10 * NFSX_UNSIGNED); 1565 *tl++ = newnfs_false; 1566 txdr_hyper(fdirfor.na_filerev, tl); 1567 tl += 2; 1568 txdr_hyper(fdiraft.na_filerev, tl); 1569 tl += 2; 1570 *tl++ = newnfs_false; 1571 txdr_hyper(tdirfor.na_filerev, tl); 1572 tl += 2; 1573 txdr_hyper(tdiraft.na_filerev, tl); 1574 } 1575 1576 out: 1577 NFSEXITCODE2(error, nd); 1578 return (error); 1579 } 1580 1581 /* 1582 * nfs link service 1583 */ 1584 APPLESTATIC int 1585 nfsrvd_link(struct nfsrv_descript *nd, int isdgram, 1586 vnode_t vp, vnode_t tovp, NFSPROC_T *p, struct nfsexstuff *exp, 1587 struct nfsexstuff *toexp) 1588 { 1589 struct nameidata named; 1590 u_int32_t *tl; 1591 int error = 0, dirfor_ret = 1, diraft_ret = 1, getret = 1; 1592 vnode_t dirp = NULL, dp = NULL; 1593 struct nfsvattr dirfor, diraft, at; 1594 struct nfsexstuff tnes; 1595 struct nfsrvfh dfh; 1596 char *bufp; 1597 u_long *hashp; 1598 1599 if (nd->nd_repstat) { 1600 nfsrv_postopattr(nd, getret, &at); 1601 nfsrv_wcc(nd, dirfor_ret, &dirfor, diraft_ret, &diraft); 1602 goto out; 1603 } 1604 NFSVOPUNLOCK(vp, 0); 1605 if (vnode_vtype(vp) == VDIR) { 1606 if (nd->nd_flag & ND_NFSV4) 1607 nd->nd_repstat = NFSERR_ISDIR; 1608 else 1609 nd->nd_repstat = NFSERR_INVAL; 1610 if (tovp) 1611 vrele(tovp); 1612 } else if (vnode_vtype(vp) == VLNK) { 1613 if (nd->nd_flag & ND_NFSV2) 1614 nd->nd_repstat = NFSERR_INVAL; 1615 else 1616 nd->nd_repstat = NFSERR_NOTSUPP; 1617 if (tovp) 1618 vrele(tovp); 1619 } 1620 if (!nd->nd_repstat) { 1621 if (nd->nd_flag & ND_NFSV4) { 1622 dp = tovp; 1623 tnes = *toexp; 1624 } else { 1625 error = nfsrv_mtofh(nd, &dfh); 1626 if (error) { 1627 vrele(vp); 1628 /* tovp is always NULL unless NFSv4 */ 1629 goto out; 1630 } 1631 nfsd_fhtovp(nd, &dfh, LK_EXCLUSIVE, &dp, &tnes, NULL, 0, 1632 p); 1633 if (dp) 1634 NFSVOPUNLOCK(dp, 0); 1635 } 1636 } 1637 NFSNAMEICNDSET(&named.ni_cnd, nd->nd_cred, CREATE, 1638 LOCKPARENT | SAVENAME); 1639 if (!nd->nd_repstat) { 1640 nfsvno_setpathbuf(&named, &bufp, &hashp); 1641 error = nfsrv_parsename(nd, bufp, hashp, &named.ni_pathlen); 1642 if (error) { 1643 vrele(vp); 1644 if (dp) 1645 vrele(dp); 1646 nfsvno_relpathbuf(&named); 1647 goto out; 1648 } 1649 if (!nd->nd_repstat) { 1650 nd->nd_repstat = nfsvno_namei(nd, &named, dp, 0, &tnes, 1651 p, &dirp); 1652 } else { 1653 if (dp) 1654 vrele(dp); 1655 nfsvno_relpathbuf(&named); 1656 } 1657 } 1658 if (dirp) { 1659 if (nd->nd_flag & ND_NFSV2) { 1660 vrele(dirp); 1661 dirp = NULL; 1662 } else { 1663 dirfor_ret = nfsvno_getattr(dirp, &dirfor, 1664 nd->nd_cred, p, 0); 1665 } 1666 } 1667 if (!nd->nd_repstat) 1668 nd->nd_repstat = nfsvno_link(&named, vp, nd->nd_cred, p, exp); 1669 if (nd->nd_flag & ND_NFSV3) 1670 getret = nfsvno_getattr(vp, &at, nd->nd_cred, p, 0); 1671 if (dirp) { 1672 diraft_ret = nfsvno_getattr(dirp, &diraft, nd->nd_cred, p, 0); 1673 vrele(dirp); 1674 } 1675 vrele(vp); 1676 if (nd->nd_flag & ND_NFSV3) { 1677 nfsrv_postopattr(nd, getret, &at); 1678 nfsrv_wcc(nd, dirfor_ret, &dirfor, diraft_ret, &diraft); 1679 } else if ((nd->nd_flag & ND_NFSV4) && !nd->nd_repstat) { 1680 NFSM_BUILD(tl, u_int32_t *, 5 * NFSX_UNSIGNED); 1681 *tl++ = newnfs_false; 1682 txdr_hyper(dirfor.na_filerev, tl); 1683 tl += 2; 1684 txdr_hyper(diraft.na_filerev, tl); 1685 } 1686 1687 out: 1688 NFSEXITCODE2(error, nd); 1689 return (error); 1690 } 1691 1692 /* 1693 * nfs symbolic link service 1694 */ 1695 APPLESTATIC int 1696 nfsrvd_symlink(struct nfsrv_descript *nd, __unused int isdgram, 1697 vnode_t dp, vnode_t *vpp, fhandle_t *fhp, NFSPROC_T *p, 1698 struct nfsexstuff *exp) 1699 { 1700 struct nfsvattr nva, dirfor, diraft; 1701 struct nameidata named; 1702 int error = 0, dirfor_ret = 1, diraft_ret = 1, pathlen; 1703 vnode_t dirp = NULL; 1704 char *bufp, *pathcp = NULL; 1705 u_long *hashp; 1706 1707 if (nd->nd_repstat) { 1708 nfsrv_wcc(nd, dirfor_ret, &dirfor, diraft_ret, &diraft); 1709 goto out; 1710 } 1711 if (vpp) 1712 *vpp = NULL; 1713 NFSVNO_ATTRINIT(&nva); 1714 NFSNAMEICNDSET(&named.ni_cnd, nd->nd_cred, CREATE, 1715 LOCKPARENT | SAVESTART); 1716 nfsvno_setpathbuf(&named, &bufp, &hashp); 1717 error = nfsrv_parsename(nd, bufp, hashp, &named.ni_pathlen); 1718 if (!error && !nd->nd_repstat) 1719 error = nfsvno_getsymlink(nd, &nva, p, &pathcp, &pathlen); 1720 if (error) { 1721 vrele(dp); 1722 nfsvno_relpathbuf(&named); 1723 goto out; 1724 } 1725 if (!nd->nd_repstat) { 1726 nd->nd_repstat = nfsvno_namei(nd, &named, dp, 0, exp, p, &dirp); 1727 } else { 1728 vrele(dp); 1729 nfsvno_relpathbuf(&named); 1730 } 1731 if (dirp != NULL && !(nd->nd_flag & ND_NFSV3)) { 1732 vrele(dirp); 1733 dirp = NULL; 1734 } 1735 1736 /* 1737 * And call nfsrvd_symlinksub() to do the common code. It will 1738 * return EBADRPC upon a parsing error, 0 otherwise. 1739 */ 1740 if (!nd->nd_repstat) { 1741 if (dirp != NULL) 1742 dirfor_ret = nfsvno_getattr(dirp, &dirfor, nd->nd_cred, 1743 p, 0); 1744 nfsrvd_symlinksub(nd, &named, &nva, fhp, vpp, dirp, 1745 &dirfor, &diraft, &diraft_ret, NULL, NULL, p, exp, 1746 pathcp, pathlen); 1747 } else if (dirp != NULL) { 1748 dirfor_ret = nfsvno_getattr(dirp, &dirfor, nd->nd_cred, p, 0); 1749 vrele(dirp); 1750 } 1751 if (pathcp) 1752 FREE(pathcp, M_TEMP); 1753 1754 if (nd->nd_flag & ND_NFSV3) { 1755 if (!nd->nd_repstat) { 1756 (void) nfsm_fhtom(nd, (u_int8_t *)fhp, 0, 1); 1757 nfsrv_postopattr(nd, 0, &nva); 1758 } 1759 nfsrv_wcc(nd, dirfor_ret, &dirfor, diraft_ret, &diraft); 1760 } 1761 1762 out: 1763 NFSEXITCODE2(error, nd); 1764 return (error); 1765 } 1766 1767 /* 1768 * Common code for creating a symbolic link. 1769 */ 1770 static void 1771 nfsrvd_symlinksub(struct nfsrv_descript *nd, struct nameidata *ndp, 1772 struct nfsvattr *nvap, fhandle_t *fhp, vnode_t *vpp, 1773 vnode_t dirp, struct nfsvattr *dirforp, struct nfsvattr *diraftp, 1774 int *diraft_retp, nfsattrbit_t *attrbitp, 1775 NFSACL_T *aclp, NFSPROC_T *p, struct nfsexstuff *exp, char *pathcp, 1776 int pathlen) 1777 { 1778 u_int32_t *tl; 1779 1780 nd->nd_repstat = nfsvno_symlink(ndp, nvap, pathcp, pathlen, 1781 !(nd->nd_flag & ND_NFSV2), nd->nd_saveduid, nd->nd_cred, p, exp); 1782 if (!nd->nd_repstat && !(nd->nd_flag & ND_NFSV2)) { 1783 nfsrv_fixattr(nd, ndp->ni_vp, nvap, aclp, p, attrbitp, exp); 1784 if (nd->nd_flag & ND_NFSV3) { 1785 nd->nd_repstat = nfsvno_getfh(ndp->ni_vp, fhp, p); 1786 if (!nd->nd_repstat) 1787 nd->nd_repstat = nfsvno_getattr(ndp->ni_vp, 1788 nvap, nd->nd_cred, p, 1); 1789 } 1790 if (vpp != NULL && nd->nd_repstat == 0) { 1791 NFSVOPUNLOCK(ndp->ni_vp, 0); 1792 *vpp = ndp->ni_vp; 1793 } else 1794 vput(ndp->ni_vp); 1795 } 1796 if (dirp) { 1797 *diraft_retp = nfsvno_getattr(dirp, diraftp, nd->nd_cred, p, 0); 1798 vrele(dirp); 1799 } 1800 if ((nd->nd_flag & ND_NFSV4) && !nd->nd_repstat) { 1801 NFSM_BUILD(tl, u_int32_t *, 5 * NFSX_UNSIGNED); 1802 *tl++ = newnfs_false; 1803 txdr_hyper(dirforp->na_filerev, tl); 1804 tl += 2; 1805 txdr_hyper(diraftp->na_filerev, tl); 1806 (void) nfsrv_putattrbit(nd, attrbitp); 1807 } 1808 1809 NFSEXITCODE2(0, nd); 1810 } 1811 1812 /* 1813 * nfs mkdir service 1814 */ 1815 APPLESTATIC int 1816 nfsrvd_mkdir(struct nfsrv_descript *nd, __unused int isdgram, 1817 vnode_t dp, vnode_t *vpp, fhandle_t *fhp, NFSPROC_T *p, 1818 struct nfsexstuff *exp) 1819 { 1820 struct nfsvattr nva, dirfor, diraft; 1821 struct nameidata named; 1822 u_int32_t *tl; 1823 int error = 0, dirfor_ret = 1, diraft_ret = 1; 1824 vnode_t dirp = NULL; 1825 char *bufp; 1826 u_long *hashp; 1827 1828 if (nd->nd_repstat) { 1829 nfsrv_wcc(nd, dirfor_ret, &dirfor, diraft_ret, &diraft); 1830 goto out; 1831 } 1832 NFSNAMEICNDSET(&named.ni_cnd, nd->nd_cred, CREATE, 1833 LOCKPARENT | SAVENAME); 1834 nfsvno_setpathbuf(&named, &bufp, &hashp); 1835 error = nfsrv_parsename(nd, bufp, hashp, &named.ni_pathlen); 1836 if (error) 1837 goto nfsmout; 1838 if (!nd->nd_repstat) { 1839 NFSVNO_ATTRINIT(&nva); 1840 if (nd->nd_flag & ND_NFSV3) { 1841 error = nfsrv_sattr(nd, &nva, NULL, NULL, p); 1842 if (error) 1843 goto nfsmout; 1844 } else { 1845 NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED); 1846 nva.na_mode = nfstov_mode(*tl++); 1847 } 1848 } 1849 if (!nd->nd_repstat) { 1850 nd->nd_repstat = nfsvno_namei(nd, &named, dp, 0, exp, p, &dirp); 1851 } else { 1852 vrele(dp); 1853 nfsvno_relpathbuf(&named); 1854 } 1855 if (dirp != NULL && !(nd->nd_flag & ND_NFSV3)) { 1856 vrele(dirp); 1857 dirp = NULL; 1858 } 1859 if (nd->nd_repstat) { 1860 if (dirp != NULL) { 1861 dirfor_ret = nfsvno_getattr(dirp, &dirfor, nd->nd_cred, 1862 p, 0); 1863 vrele(dirp); 1864 } 1865 if (nd->nd_flag & ND_NFSV3) 1866 nfsrv_wcc(nd, dirfor_ret, &dirfor, diraft_ret, 1867 &diraft); 1868 goto out; 1869 } 1870 if (dirp != NULL) 1871 dirfor_ret = nfsvno_getattr(dirp, &dirfor, nd->nd_cred, p, 0); 1872 1873 /* 1874 * Call nfsrvd_mkdirsub() for the code common to V4 as well. 1875 */ 1876 nfsrvd_mkdirsub(nd, &named, &nva, fhp, vpp, dirp, &dirfor, &diraft, 1877 &diraft_ret, NULL, NULL, p, exp); 1878 1879 if (nd->nd_flag & ND_NFSV3) { 1880 if (!nd->nd_repstat) { 1881 (void) nfsm_fhtom(nd, (u_int8_t *)fhp, 0, 1); 1882 nfsrv_postopattr(nd, 0, &nva); 1883 } 1884 nfsrv_wcc(nd, dirfor_ret, &dirfor, diraft_ret, &diraft); 1885 } else if (!nd->nd_repstat) { 1886 (void) nfsm_fhtom(nd, (u_int8_t *)fhp, 0, 0); 1887 nfsrv_fillattr(nd, &nva); 1888 } 1889 1890 out: 1891 NFSEXITCODE2(0, nd); 1892 return (0); 1893 nfsmout: 1894 vrele(dp); 1895 nfsvno_relpathbuf(&named); 1896 NFSEXITCODE2(error, nd); 1897 return (error); 1898 } 1899 1900 /* 1901 * Code common to mkdir for V2,3 and 4. 1902 */ 1903 static void 1904 nfsrvd_mkdirsub(struct nfsrv_descript *nd, struct nameidata *ndp, 1905 struct nfsvattr *nvap, fhandle_t *fhp, vnode_t *vpp, 1906 vnode_t dirp, struct nfsvattr *dirforp, struct nfsvattr *diraftp, 1907 int *diraft_retp, nfsattrbit_t *attrbitp, NFSACL_T *aclp, 1908 NFSPROC_T *p, struct nfsexstuff *exp) 1909 { 1910 vnode_t vp; 1911 u_int32_t *tl; 1912 1913 NFSVNO_SETATTRVAL(nvap, type, VDIR); 1914 nd->nd_repstat = nfsvno_mkdir(ndp, nvap, nd->nd_saveduid, 1915 nd->nd_cred, p, exp); 1916 if (!nd->nd_repstat) { 1917 vp = ndp->ni_vp; 1918 nfsrv_fixattr(nd, vp, nvap, aclp, p, attrbitp, exp); 1919 nd->nd_repstat = nfsvno_getfh(vp, fhp, p); 1920 if (!(nd->nd_flag & ND_NFSV4) && !nd->nd_repstat) 1921 nd->nd_repstat = nfsvno_getattr(vp, nvap, nd->nd_cred, 1922 p, 1); 1923 if (vpp && !nd->nd_repstat) { 1924 NFSVOPUNLOCK(vp, 0); 1925 *vpp = vp; 1926 } else { 1927 vput(vp); 1928 } 1929 } 1930 if (dirp) { 1931 *diraft_retp = nfsvno_getattr(dirp, diraftp, nd->nd_cred, p, 0); 1932 vrele(dirp); 1933 } 1934 if ((nd->nd_flag & ND_NFSV4) && !nd->nd_repstat) { 1935 NFSM_BUILD(tl, u_int32_t *, 5 * NFSX_UNSIGNED); 1936 *tl++ = newnfs_false; 1937 txdr_hyper(dirforp->na_filerev, tl); 1938 tl += 2; 1939 txdr_hyper(diraftp->na_filerev, tl); 1940 (void) nfsrv_putattrbit(nd, attrbitp); 1941 } 1942 1943 NFSEXITCODE2(0, nd); 1944 } 1945 1946 /* 1947 * nfs commit service 1948 */ 1949 APPLESTATIC int 1950 nfsrvd_commit(struct nfsrv_descript *nd, __unused int isdgram, 1951 vnode_t vp, NFSPROC_T *p, __unused struct nfsexstuff *exp) 1952 { 1953 struct nfsvattr bfor, aft; 1954 u_int32_t *tl; 1955 int error = 0, for_ret = 1, aft_ret = 1, cnt; 1956 u_int64_t off; 1957 1958 if (nd->nd_repstat) { 1959 nfsrv_wcc(nd, for_ret, &bfor, aft_ret, &aft); 1960 goto out; 1961 } 1962 NFSM_DISSECT(tl, u_int32_t *, 3 * NFSX_UNSIGNED); 1963 /* 1964 * XXX At this time VOP_FSYNC() does not accept offset and byte 1965 * count parameters, so these arguments are useless (someday maybe). 1966 */ 1967 off = fxdr_hyper(tl); 1968 tl += 2; 1969 cnt = fxdr_unsigned(int, *tl); 1970 if (nd->nd_flag & ND_NFSV3) 1971 for_ret = nfsvno_getattr(vp, &bfor, nd->nd_cred, p, 1); 1972 nd->nd_repstat = nfsvno_fsync(vp, off, cnt, nd->nd_cred, p); 1973 if (nd->nd_flag & ND_NFSV3) { 1974 aft_ret = nfsvno_getattr(vp, &aft, nd->nd_cred, p, 1); 1975 nfsrv_wcc(nd, for_ret, &bfor, aft_ret, &aft); 1976 } 1977 vput(vp); 1978 if (!nd->nd_repstat) { 1979 NFSM_BUILD(tl, u_int32_t *, NFSX_VERF); 1980 *tl++ = txdr_unsigned(nfsboottime.tv_sec); 1981 *tl = txdr_unsigned(nfsboottime.tv_usec); 1982 } 1983 1984 out: 1985 NFSEXITCODE2(0, nd); 1986 return (0); 1987 nfsmout: 1988 vput(vp); 1989 NFSEXITCODE2(error, nd); 1990 return (error); 1991 } 1992 1993 /* 1994 * nfs statfs service 1995 */ 1996 APPLESTATIC int 1997 nfsrvd_statfs(struct nfsrv_descript *nd, __unused int isdgram, 1998 vnode_t vp, NFSPROC_T *p, __unused struct nfsexstuff *exp) 1999 { 2000 struct statfs *sf; 2001 u_int32_t *tl; 2002 int getret = 1; 2003 struct nfsvattr at; 2004 struct statfs sfs; 2005 u_quad_t tval; 2006 2007 if (nd->nd_repstat) { 2008 nfsrv_postopattr(nd, getret, &at); 2009 goto out; 2010 } 2011 sf = &sfs; 2012 nd->nd_repstat = nfsvno_statfs(vp, sf); 2013 getret = nfsvno_getattr(vp, &at, nd->nd_cred, p, 1); 2014 vput(vp); 2015 if (nd->nd_flag & ND_NFSV3) 2016 nfsrv_postopattr(nd, getret, &at); 2017 if (nd->nd_repstat) 2018 goto out; 2019 if (nd->nd_flag & ND_NFSV2) { 2020 NFSM_BUILD(tl, u_int32_t *, NFSX_V2STATFS); 2021 *tl++ = txdr_unsigned(NFS_V2MAXDATA); 2022 *tl++ = txdr_unsigned(sf->f_bsize); 2023 *tl++ = txdr_unsigned(sf->f_blocks); 2024 *tl++ = txdr_unsigned(sf->f_bfree); 2025 *tl = txdr_unsigned(sf->f_bavail); 2026 } else { 2027 NFSM_BUILD(tl, u_int32_t *, NFSX_V3STATFS); 2028 tval = (u_quad_t)sf->f_blocks; 2029 tval *= (u_quad_t)sf->f_bsize; 2030 txdr_hyper(tval, tl); tl += 2; 2031 tval = (u_quad_t)sf->f_bfree; 2032 tval *= (u_quad_t)sf->f_bsize; 2033 txdr_hyper(tval, tl); tl += 2; 2034 tval = (u_quad_t)sf->f_bavail; 2035 tval *= (u_quad_t)sf->f_bsize; 2036 txdr_hyper(tval, tl); tl += 2; 2037 tval = (u_quad_t)sf->f_files; 2038 txdr_hyper(tval, tl); tl += 2; 2039 tval = (u_quad_t)sf->f_ffree; 2040 txdr_hyper(tval, tl); tl += 2; 2041 tval = (u_quad_t)sf->f_ffree; 2042 txdr_hyper(tval, tl); tl += 2; 2043 *tl = 0; 2044 } 2045 2046 out: 2047 NFSEXITCODE2(0, nd); 2048 return (0); 2049 } 2050 2051 /* 2052 * nfs fsinfo service 2053 */ 2054 APPLESTATIC int 2055 nfsrvd_fsinfo(struct nfsrv_descript *nd, int isdgram, 2056 vnode_t vp, NFSPROC_T *p, __unused struct nfsexstuff *exp) 2057 { 2058 u_int32_t *tl; 2059 struct nfsfsinfo fs; 2060 int getret = 1; 2061 struct nfsvattr at; 2062 2063 if (nd->nd_repstat) { 2064 nfsrv_postopattr(nd, getret, &at); 2065 goto out; 2066 } 2067 getret = nfsvno_getattr(vp, &at, nd->nd_cred, p, 1); 2068 nfsvno_getfs(&fs, isdgram); 2069 vput(vp); 2070 nfsrv_postopattr(nd, getret, &at); 2071 NFSM_BUILD(tl, u_int32_t *, NFSX_V3FSINFO); 2072 *tl++ = txdr_unsigned(fs.fs_rtmax); 2073 *tl++ = txdr_unsigned(fs.fs_rtpref); 2074 *tl++ = txdr_unsigned(fs.fs_rtmult); 2075 *tl++ = txdr_unsigned(fs.fs_wtmax); 2076 *tl++ = txdr_unsigned(fs.fs_wtpref); 2077 *tl++ = txdr_unsigned(fs.fs_wtmult); 2078 *tl++ = txdr_unsigned(fs.fs_dtpref); 2079 txdr_hyper(fs.fs_maxfilesize, tl); 2080 tl += 2; 2081 txdr_nfsv3time(&fs.fs_timedelta, tl); 2082 tl += 2; 2083 *tl = txdr_unsigned(fs.fs_properties); 2084 2085 out: 2086 NFSEXITCODE2(0, nd); 2087 return (0); 2088 } 2089 2090 /* 2091 * nfs pathconf service 2092 */ 2093 APPLESTATIC int 2094 nfsrvd_pathconf(struct nfsrv_descript *nd, __unused int isdgram, 2095 vnode_t vp, NFSPROC_T *p, __unused struct nfsexstuff *exp) 2096 { 2097 struct nfsv3_pathconf *pc; 2098 int getret = 1; 2099 register_t linkmax, namemax, chownres, notrunc; 2100 struct nfsvattr at; 2101 2102 if (nd->nd_repstat) { 2103 nfsrv_postopattr(nd, getret, &at); 2104 goto out; 2105 } 2106 nd->nd_repstat = nfsvno_pathconf(vp, _PC_LINK_MAX, &linkmax, 2107 nd->nd_cred, p); 2108 if (!nd->nd_repstat) 2109 nd->nd_repstat = nfsvno_pathconf(vp, _PC_NAME_MAX, &namemax, 2110 nd->nd_cred, p); 2111 if (!nd->nd_repstat) 2112 nd->nd_repstat=nfsvno_pathconf(vp, _PC_CHOWN_RESTRICTED, 2113 &chownres, nd->nd_cred, p); 2114 if (!nd->nd_repstat) 2115 nd->nd_repstat = nfsvno_pathconf(vp, _PC_NO_TRUNC, ¬runc, 2116 nd->nd_cred, p); 2117 getret = nfsvno_getattr(vp, &at, nd->nd_cred, p, 1); 2118 vput(vp); 2119 nfsrv_postopattr(nd, getret, &at); 2120 if (!nd->nd_repstat) { 2121 NFSM_BUILD(pc, struct nfsv3_pathconf *, NFSX_V3PATHCONF); 2122 pc->pc_linkmax = txdr_unsigned(linkmax); 2123 pc->pc_namemax = txdr_unsigned(namemax); 2124 pc->pc_notrunc = txdr_unsigned(notrunc); 2125 pc->pc_chownrestricted = txdr_unsigned(chownres); 2126 2127 /* 2128 * These should probably be supported by VOP_PATHCONF(), but 2129 * until msdosfs is exportable (why would you want to?), the 2130 * Unix defaults should be ok. 2131 */ 2132 pc->pc_caseinsensitive = newnfs_false; 2133 pc->pc_casepreserving = newnfs_true; 2134 } 2135 2136 out: 2137 NFSEXITCODE2(0, nd); 2138 return (0); 2139 } 2140 2141 /* 2142 * nfsv4 lock service 2143 */ 2144 APPLESTATIC int 2145 nfsrvd_lock(struct nfsrv_descript *nd, __unused int isdgram, 2146 vnode_t vp, NFSPROC_T *p, struct nfsexstuff *exp) 2147 { 2148 u_int32_t *tl; 2149 int i; 2150 struct nfsstate *stp = NULL; 2151 struct nfslock *lop; 2152 struct nfslockconflict cf; 2153 int error = 0; 2154 u_short flags = NFSLCK_LOCK, lflags; 2155 u_int64_t offset, len; 2156 nfsv4stateid_t stateid; 2157 nfsquad_t clientid; 2158 2159 NFSM_DISSECT(tl, u_int32_t *, 7 * NFSX_UNSIGNED); 2160 i = fxdr_unsigned(int, *tl++); 2161 switch (i) { 2162 case NFSV4LOCKT_READW: 2163 flags |= NFSLCK_BLOCKING; 2164 case NFSV4LOCKT_READ: 2165 lflags = NFSLCK_READ; 2166 break; 2167 case NFSV4LOCKT_WRITEW: 2168 flags |= NFSLCK_BLOCKING; 2169 case NFSV4LOCKT_WRITE: 2170 lflags = NFSLCK_WRITE; 2171 break; 2172 default: 2173 nd->nd_repstat = NFSERR_BADXDR; 2174 goto nfsmout; 2175 }; 2176 if (*tl++ == newnfs_true) 2177 flags |= NFSLCK_RECLAIM; 2178 offset = fxdr_hyper(tl); 2179 tl += 2; 2180 len = fxdr_hyper(tl); 2181 tl += 2; 2182 if (*tl == newnfs_true) 2183 flags |= NFSLCK_OPENTOLOCK; 2184 if (flags & NFSLCK_OPENTOLOCK) { 2185 NFSM_DISSECT(tl, u_int32_t *, 5 * NFSX_UNSIGNED + NFSX_STATEID); 2186 i = fxdr_unsigned(int, *(tl+4+(NFSX_STATEID / NFSX_UNSIGNED))); 2187 if (i <= 0 || i > NFSV4_OPAQUELIMIT) { 2188 nd->nd_repstat = NFSERR_BADXDR; 2189 goto nfsmout; 2190 } 2191 MALLOC(stp, struct nfsstate *, sizeof (struct nfsstate) + i, 2192 M_NFSDSTATE, M_WAITOK); 2193 stp->ls_ownerlen = i; 2194 stp->ls_op = nd->nd_rp; 2195 stp->ls_seq = fxdr_unsigned(int, *tl++); 2196 stp->ls_stateid.seqid = fxdr_unsigned(u_int32_t, *tl++); 2197 NFSBCOPY((caddr_t)tl, (caddr_t)stp->ls_stateid.other, 2198 NFSX_STATEIDOTHER); 2199 tl += (NFSX_STATEIDOTHER / NFSX_UNSIGNED); 2200 stp->ls_opentolockseq = fxdr_unsigned(int, *tl++); 2201 clientid.lval[0] = *tl++; 2202 clientid.lval[1] = *tl++; 2203 if (nd->nd_flag & ND_IMPLIEDCLID) { 2204 if (nd->nd_clientid.qval != clientid.qval) 2205 printf("EEK! multiple clids\n"); 2206 } else { 2207 nd->nd_flag |= ND_IMPLIEDCLID; 2208 nd->nd_clientid.qval = clientid.qval; 2209 } 2210 error = nfsrv_mtostr(nd, stp->ls_owner, stp->ls_ownerlen); 2211 if (error) 2212 goto nfsmout; 2213 } else { 2214 NFSM_DISSECT(tl, u_int32_t *, NFSX_STATEID + NFSX_UNSIGNED); 2215 MALLOC(stp, struct nfsstate *, sizeof (struct nfsstate), 2216 M_NFSDSTATE, M_WAITOK); 2217 stp->ls_ownerlen = 0; 2218 stp->ls_op = nd->nd_rp; 2219 stp->ls_stateid.seqid = fxdr_unsigned(u_int32_t, *tl++); 2220 NFSBCOPY((caddr_t)tl, (caddr_t)stp->ls_stateid.other, 2221 NFSX_STATEIDOTHER); 2222 tl += (NFSX_STATEIDOTHER / NFSX_UNSIGNED); 2223 stp->ls_seq = fxdr_unsigned(int, *tl); 2224 clientid.lval[0] = stp->ls_stateid.other[0]; 2225 clientid.lval[1] = stp->ls_stateid.other[1]; 2226 if (nd->nd_flag & ND_IMPLIEDCLID) { 2227 if (nd->nd_clientid.qval != clientid.qval) 2228 printf("EEK! multiple clids\n"); 2229 } else { 2230 nd->nd_flag |= ND_IMPLIEDCLID; 2231 nd->nd_clientid.qval = clientid.qval; 2232 } 2233 } 2234 MALLOC(lop, struct nfslock *, sizeof (struct nfslock), 2235 M_NFSDLOCK, M_WAITOK); 2236 lop->lo_first = offset; 2237 if (len == NFS64BITSSET) { 2238 lop->lo_end = NFS64BITSSET; 2239 } else { 2240 lop->lo_end = offset + len; 2241 if (lop->lo_end <= lop->lo_first) 2242 nd->nd_repstat = NFSERR_INVAL; 2243 } 2244 lop->lo_flags = lflags; 2245 stp->ls_flags = flags; 2246 stp->ls_uid = nd->nd_cred->cr_uid; 2247 2248 /* 2249 * Do basic access checking. 2250 */ 2251 if (!nd->nd_repstat && vnode_vtype(vp) != VREG) { 2252 if (vnode_vtype(vp) == VDIR) 2253 nd->nd_repstat = NFSERR_ISDIR; 2254 else 2255 nd->nd_repstat = NFSERR_INVAL; 2256 } 2257 if (!nd->nd_repstat) { 2258 if (lflags & NFSLCK_WRITE) { 2259 nd->nd_repstat = nfsvno_accchk(vp, VWRITE, 2260 nd->nd_cred, exp, p, NFSACCCHK_ALLOWOWNER, 2261 NFSACCCHK_VPISLOCKED, NULL); 2262 } else { 2263 nd->nd_repstat = nfsvno_accchk(vp, VREAD, 2264 nd->nd_cred, exp, p, NFSACCCHK_ALLOWOWNER, 2265 NFSACCCHK_VPISLOCKED, NULL); 2266 if (nd->nd_repstat) 2267 nd->nd_repstat = nfsvno_accchk(vp, VEXEC, 2268 nd->nd_cred, exp, p, NFSACCCHK_ALLOWOWNER, 2269 NFSACCCHK_VPISLOCKED, NULL); 2270 } 2271 } 2272 2273 /* 2274 * We call nfsrv_lockctrl() even if nd_repstat set, so that the 2275 * seqid# gets updated. nfsrv_lockctrl() will return the value 2276 * of nd_repstat, if it gets that far. 2277 */ 2278 nd->nd_repstat = nfsrv_lockctrl(vp, &stp, &lop, &cf, clientid, 2279 &stateid, exp, nd, p); 2280 if (lop) 2281 FREE((caddr_t)lop, M_NFSDLOCK); 2282 if (stp) 2283 FREE((caddr_t)stp, M_NFSDSTATE); 2284 if (!nd->nd_repstat) { 2285 NFSM_BUILD(tl, u_int32_t *, NFSX_STATEID); 2286 *tl++ = txdr_unsigned(stateid.seqid); 2287 NFSBCOPY((caddr_t)stateid.other,(caddr_t)tl,NFSX_STATEIDOTHER); 2288 } else if (nd->nd_repstat == NFSERR_DENIED) { 2289 NFSM_BUILD(tl, u_int32_t *, 7 * NFSX_UNSIGNED); 2290 txdr_hyper(cf.cl_first, tl); 2291 tl += 2; 2292 if (cf.cl_end == NFS64BITSSET) 2293 len = NFS64BITSSET; 2294 else 2295 len = cf.cl_end - cf.cl_first; 2296 txdr_hyper(len, tl); 2297 tl += 2; 2298 if (cf.cl_flags == NFSLCK_WRITE) 2299 *tl++ = txdr_unsigned(NFSV4LOCKT_WRITE); 2300 else 2301 *tl++ = txdr_unsigned(NFSV4LOCKT_READ); 2302 *tl++ = stateid.other[0]; 2303 *tl = stateid.other[1]; 2304 (void) nfsm_strtom(nd, cf.cl_owner, cf.cl_ownerlen); 2305 } 2306 vput(vp); 2307 NFSEXITCODE2(0, nd); 2308 return (0); 2309 nfsmout: 2310 vput(vp); 2311 if (stp) 2312 free((caddr_t)stp, M_NFSDSTATE); 2313 NFSEXITCODE2(error, nd); 2314 return (error); 2315 } 2316 2317 /* 2318 * nfsv4 lock test service 2319 */ 2320 APPLESTATIC int 2321 nfsrvd_lockt(struct nfsrv_descript *nd, __unused int isdgram, 2322 vnode_t vp, NFSPROC_T *p, struct nfsexstuff *exp) 2323 { 2324 u_int32_t *tl; 2325 int i; 2326 struct nfsstate *stp = NULL; 2327 struct nfslock lo, *lop = &lo; 2328 struct nfslockconflict cf; 2329 int error = 0; 2330 nfsv4stateid_t stateid; 2331 nfsquad_t clientid; 2332 u_int64_t len; 2333 2334 NFSM_DISSECT(tl, u_int32_t *, 8 * NFSX_UNSIGNED); 2335 i = fxdr_unsigned(int, *(tl + 7)); 2336 if (i <= 0 || i > NFSV4_OPAQUELIMIT) { 2337 nd->nd_repstat = NFSERR_BADXDR; 2338 goto nfsmout; 2339 } 2340 MALLOC(stp, struct nfsstate *, sizeof (struct nfsstate) + i, 2341 M_NFSDSTATE, M_WAITOK); 2342 stp->ls_ownerlen = i; 2343 stp->ls_op = NULL; 2344 stp->ls_flags = NFSLCK_TEST; 2345 stp->ls_uid = nd->nd_cred->cr_uid; 2346 i = fxdr_unsigned(int, *tl++); 2347 switch (i) { 2348 case NFSV4LOCKT_READW: 2349 stp->ls_flags |= NFSLCK_BLOCKING; 2350 case NFSV4LOCKT_READ: 2351 lo.lo_flags = NFSLCK_READ; 2352 break; 2353 case NFSV4LOCKT_WRITEW: 2354 stp->ls_flags |= NFSLCK_BLOCKING; 2355 case NFSV4LOCKT_WRITE: 2356 lo.lo_flags = NFSLCK_WRITE; 2357 break; 2358 default: 2359 nd->nd_repstat = NFSERR_BADXDR; 2360 goto nfsmout; 2361 }; 2362 lo.lo_first = fxdr_hyper(tl); 2363 tl += 2; 2364 len = fxdr_hyper(tl); 2365 if (len == NFS64BITSSET) { 2366 lo.lo_end = NFS64BITSSET; 2367 } else { 2368 lo.lo_end = lo.lo_first + len; 2369 if (lo.lo_end <= lo.lo_first) 2370 nd->nd_repstat = NFSERR_INVAL; 2371 } 2372 tl += 2; 2373 clientid.lval[0] = *tl++; 2374 clientid.lval[1] = *tl; 2375 if (nd->nd_flag & ND_IMPLIEDCLID) { 2376 if (nd->nd_clientid.qval != clientid.qval) 2377 printf("EEK! multiple clids\n"); 2378 } else { 2379 nd->nd_flag |= ND_IMPLIEDCLID; 2380 nd->nd_clientid.qval = clientid.qval; 2381 } 2382 error = nfsrv_mtostr(nd, stp->ls_owner, stp->ls_ownerlen); 2383 if (error) 2384 goto nfsmout; 2385 if (!nd->nd_repstat && vnode_vtype(vp) != VREG) { 2386 if (vnode_vtype(vp) == VDIR) 2387 nd->nd_repstat = NFSERR_ISDIR; 2388 else 2389 nd->nd_repstat = NFSERR_INVAL; 2390 } 2391 if (!nd->nd_repstat) 2392 nd->nd_repstat = nfsrv_lockctrl(vp, &stp, &lop, &cf, clientid, 2393 &stateid, exp, nd, p); 2394 if (stp) 2395 FREE((caddr_t)stp, M_NFSDSTATE); 2396 if (nd->nd_repstat) { 2397 if (nd->nd_repstat == NFSERR_DENIED) { 2398 NFSM_BUILD(tl, u_int32_t *, 7 * NFSX_UNSIGNED); 2399 txdr_hyper(cf.cl_first, tl); 2400 tl += 2; 2401 if (cf.cl_end == NFS64BITSSET) 2402 len = NFS64BITSSET; 2403 else 2404 len = cf.cl_end - cf.cl_first; 2405 txdr_hyper(len, tl); 2406 tl += 2; 2407 if (cf.cl_flags == NFSLCK_WRITE) 2408 *tl++ = txdr_unsigned(NFSV4LOCKT_WRITE); 2409 else 2410 *tl++ = txdr_unsigned(NFSV4LOCKT_READ); 2411 *tl++ = stp->ls_stateid.other[0]; 2412 *tl = stp->ls_stateid.other[1]; 2413 (void) nfsm_strtom(nd, cf.cl_owner, cf.cl_ownerlen); 2414 } 2415 } 2416 vput(vp); 2417 NFSEXITCODE2(0, nd); 2418 return (0); 2419 nfsmout: 2420 vput(vp); 2421 if (stp) 2422 free((caddr_t)stp, M_NFSDSTATE); 2423 NFSEXITCODE2(error, nd); 2424 return (error); 2425 } 2426 2427 /* 2428 * nfsv4 unlock service 2429 */ 2430 APPLESTATIC int 2431 nfsrvd_locku(struct nfsrv_descript *nd, __unused int isdgram, 2432 vnode_t vp, NFSPROC_T *p, struct nfsexstuff *exp) 2433 { 2434 u_int32_t *tl; 2435 int i; 2436 struct nfsstate *stp; 2437 struct nfslock *lop; 2438 int error = 0; 2439 nfsv4stateid_t stateid; 2440 nfsquad_t clientid; 2441 u_int64_t len; 2442 2443 NFSM_DISSECT(tl, u_int32_t *, 6 * NFSX_UNSIGNED + NFSX_STATEID); 2444 MALLOC(stp, struct nfsstate *, sizeof (struct nfsstate), 2445 M_NFSDSTATE, M_WAITOK); 2446 MALLOC(lop, struct nfslock *, sizeof (struct nfslock), 2447 M_NFSDLOCK, M_WAITOK); 2448 stp->ls_flags = NFSLCK_UNLOCK; 2449 lop->lo_flags = NFSLCK_UNLOCK; 2450 stp->ls_op = nd->nd_rp; 2451 i = fxdr_unsigned(int, *tl++); 2452 switch (i) { 2453 case NFSV4LOCKT_READW: 2454 stp->ls_flags |= NFSLCK_BLOCKING; 2455 case NFSV4LOCKT_READ: 2456 break; 2457 case NFSV4LOCKT_WRITEW: 2458 stp->ls_flags |= NFSLCK_BLOCKING; 2459 case NFSV4LOCKT_WRITE: 2460 break; 2461 default: 2462 nd->nd_repstat = NFSERR_BADXDR; 2463 free(stp, M_NFSDSTATE); 2464 free(lop, M_NFSDLOCK); 2465 goto nfsmout; 2466 }; 2467 stp->ls_ownerlen = 0; 2468 stp->ls_uid = nd->nd_cred->cr_uid; 2469 stp->ls_seq = fxdr_unsigned(int, *tl++); 2470 stp->ls_stateid.seqid = fxdr_unsigned(u_int32_t, *tl++); 2471 NFSBCOPY((caddr_t)tl, (caddr_t)stp->ls_stateid.other, 2472 NFSX_STATEIDOTHER); 2473 tl += (NFSX_STATEIDOTHER / NFSX_UNSIGNED); 2474 lop->lo_first = fxdr_hyper(tl); 2475 tl += 2; 2476 len = fxdr_hyper(tl); 2477 if (len == NFS64BITSSET) { 2478 lop->lo_end = NFS64BITSSET; 2479 } else { 2480 lop->lo_end = lop->lo_first + len; 2481 if (lop->lo_end <= lop->lo_first) 2482 nd->nd_repstat = NFSERR_INVAL; 2483 } 2484 clientid.lval[0] = stp->ls_stateid.other[0]; 2485 clientid.lval[1] = stp->ls_stateid.other[1]; 2486 if (nd->nd_flag & ND_IMPLIEDCLID) { 2487 if (nd->nd_clientid.qval != clientid.qval) 2488 printf("EEK! multiple clids\n"); 2489 } else { 2490 nd->nd_flag |= ND_IMPLIEDCLID; 2491 nd->nd_clientid.qval = clientid.qval; 2492 } 2493 if (!nd->nd_repstat && vnode_vtype(vp) != VREG) { 2494 if (vnode_vtype(vp) == VDIR) 2495 nd->nd_repstat = NFSERR_ISDIR; 2496 else 2497 nd->nd_repstat = NFSERR_INVAL; 2498 } 2499 /* 2500 * Call nfsrv_lockctrl() even if nd_repstat is set, so that the 2501 * seqid# gets incremented. nfsrv_lockctrl() will return the 2502 * value of nd_repstat, if it gets that far. 2503 */ 2504 nd->nd_repstat = nfsrv_lockctrl(vp, &stp, &lop, NULL, clientid, 2505 &stateid, exp, nd, p); 2506 if (stp) 2507 FREE((caddr_t)stp, M_NFSDSTATE); 2508 if (lop) 2509 free((caddr_t)lop, M_NFSDLOCK); 2510 if (!nd->nd_repstat) { 2511 NFSM_BUILD(tl, u_int32_t *, NFSX_STATEID); 2512 *tl++ = txdr_unsigned(stateid.seqid); 2513 NFSBCOPY((caddr_t)stateid.other,(caddr_t)tl,NFSX_STATEIDOTHER); 2514 } 2515 nfsmout: 2516 vput(vp); 2517 NFSEXITCODE2(error, nd); 2518 return (error); 2519 } 2520 2521 /* 2522 * nfsv4 open service 2523 */ 2524 APPLESTATIC int 2525 nfsrvd_open(struct nfsrv_descript *nd, __unused int isdgram, 2526 vnode_t dp, vnode_t *vpp, __unused fhandle_t *fhp, NFSPROC_T *p, 2527 struct nfsexstuff *exp) 2528 { 2529 u_int32_t *tl; 2530 int i; 2531 struct nfsstate *stp = NULL; 2532 int error = 0, create, claim, exclusive_flag = 0; 2533 u_int32_t rflags = NFSV4OPEN_LOCKTYPEPOSIX, acemask; 2534 int how = NFSCREATE_UNCHECKED; 2535 int32_t cverf[2], tverf[2] = { 0, 0 }; 2536 vnode_t vp = NULL, dirp = NULL; 2537 struct nfsvattr nva, dirfor, diraft; 2538 struct nameidata named; 2539 nfsv4stateid_t stateid, delegstateid; 2540 nfsattrbit_t attrbits; 2541 nfsquad_t clientid; 2542 char *bufp = NULL; 2543 u_long *hashp; 2544 NFSACL_T *aclp = NULL; 2545 2546 #ifdef NFS4_ACL_EXTATTR_NAME 2547 aclp = acl_alloc(M_WAITOK); 2548 aclp->acl_cnt = 0; 2549 #endif 2550 NFSZERO_ATTRBIT(&attrbits); 2551 named.ni_startdir = NULL; 2552 named.ni_cnd.cn_nameiop = 0; 2553 NFSM_DISSECT(tl, u_int32_t *, 6 * NFSX_UNSIGNED); 2554 i = fxdr_unsigned(int, *(tl + 5)); 2555 if (i <= 0 || i > NFSV4_OPAQUELIMIT) { 2556 nd->nd_repstat = NFSERR_BADXDR; 2557 goto nfsmout; 2558 } 2559 MALLOC(stp, struct nfsstate *, sizeof (struct nfsstate) + i, 2560 M_NFSDSTATE, M_WAITOK); 2561 stp->ls_ownerlen = i; 2562 stp->ls_op = nd->nd_rp; 2563 stp->ls_flags = NFSLCK_OPEN; 2564 stp->ls_uid = nd->nd_cred->cr_uid; 2565 stp->ls_seq = fxdr_unsigned(u_int32_t, *tl++); 2566 i = fxdr_unsigned(int, *tl++); 2567 switch (i) { 2568 case NFSV4OPEN_ACCESSREAD: 2569 stp->ls_flags |= NFSLCK_READACCESS; 2570 break; 2571 case NFSV4OPEN_ACCESSWRITE: 2572 stp->ls_flags |= NFSLCK_WRITEACCESS; 2573 break; 2574 case NFSV4OPEN_ACCESSBOTH: 2575 stp->ls_flags |= (NFSLCK_READACCESS | NFSLCK_WRITEACCESS); 2576 break; 2577 default: 2578 nd->nd_repstat = NFSERR_INVAL; 2579 }; 2580 i = fxdr_unsigned(int, *tl++); 2581 switch (i) { 2582 case NFSV4OPEN_DENYNONE: 2583 break; 2584 case NFSV4OPEN_DENYREAD: 2585 stp->ls_flags |= NFSLCK_READDENY; 2586 break; 2587 case NFSV4OPEN_DENYWRITE: 2588 stp->ls_flags |= NFSLCK_WRITEDENY; 2589 break; 2590 case NFSV4OPEN_DENYBOTH: 2591 stp->ls_flags |= (NFSLCK_READDENY | NFSLCK_WRITEDENY); 2592 break; 2593 default: 2594 nd->nd_repstat = NFSERR_INVAL; 2595 }; 2596 clientid.lval[0] = *tl++; 2597 clientid.lval[1] = *tl; 2598 if (nd->nd_flag & ND_IMPLIEDCLID) { 2599 if (nd->nd_clientid.qval != clientid.qval) 2600 printf("EEK! multiple clids\n"); 2601 } else { 2602 nd->nd_flag |= ND_IMPLIEDCLID; 2603 nd->nd_clientid.qval = clientid.qval; 2604 } 2605 error = nfsrv_mtostr(nd, stp->ls_owner, stp->ls_ownerlen); 2606 if (error) 2607 goto nfsmout; 2608 NFSVNO_ATTRINIT(&nva); 2609 NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED); 2610 create = fxdr_unsigned(int, *tl); 2611 if (!nd->nd_repstat) 2612 nd->nd_repstat = nfsvno_getattr(dp, &dirfor, nd->nd_cred, p, 0); 2613 if (create == NFSV4OPEN_CREATE) { 2614 nva.na_type = VREG; 2615 nva.na_mode = 0; 2616 NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED); 2617 how = fxdr_unsigned(int, *tl); 2618 switch (how) { 2619 case NFSCREATE_UNCHECKED: 2620 case NFSCREATE_GUARDED: 2621 error = nfsv4_sattr(nd, &nva, &attrbits, aclp, p); 2622 if (error) 2623 goto nfsmout; 2624 /* 2625 * If the na_gid being set is the same as that of 2626 * the directory it is going in, clear it, since 2627 * that is what will be set by default. This allows 2628 * a user that isn't in that group to do the create. 2629 */ 2630 if (!nd->nd_repstat && NFSVNO_ISSETGID(&nva) && 2631 nva.na_gid == dirfor.na_gid) 2632 NFSVNO_UNSET(&nva, gid); 2633 if (!nd->nd_repstat) 2634 nd->nd_repstat = nfsrv_checkuidgid(nd, &nva); 2635 break; 2636 case NFSCREATE_EXCLUSIVE: 2637 NFSM_DISSECT(tl, u_int32_t *, NFSX_VERF); 2638 cverf[0] = *tl++; 2639 cverf[1] = *tl; 2640 break; 2641 default: 2642 nd->nd_repstat = NFSERR_BADXDR; 2643 goto nfsmout; 2644 }; 2645 } else if (create != NFSV4OPEN_NOCREATE) { 2646 nd->nd_repstat = NFSERR_BADXDR; 2647 goto nfsmout; 2648 } 2649 2650 /* 2651 * Now, handle the claim, which usually includes looking up a 2652 * name in the directory referenced by dp. The exception is 2653 * NFSV4OPEN_CLAIMPREVIOUS. 2654 */ 2655 NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED); 2656 claim = fxdr_unsigned(int, *tl); 2657 if (claim == NFSV4OPEN_CLAIMDELEGATECUR) { 2658 NFSM_DISSECT(tl, u_int32_t *, NFSX_STATEID); 2659 stateid.seqid = fxdr_unsigned(u_int32_t, *tl++); 2660 NFSBCOPY((caddr_t)tl,(caddr_t)stateid.other,NFSX_STATEIDOTHER); 2661 stp->ls_flags |= NFSLCK_DELEGCUR; 2662 } else if (claim == NFSV4OPEN_CLAIMDELEGATEPREV) { 2663 stp->ls_flags |= NFSLCK_DELEGPREV; 2664 } 2665 if (claim == NFSV4OPEN_CLAIMNULL || claim == NFSV4OPEN_CLAIMDELEGATECUR 2666 || claim == NFSV4OPEN_CLAIMDELEGATEPREV) { 2667 if (!nd->nd_repstat && create == NFSV4OPEN_CREATE && 2668 claim != NFSV4OPEN_CLAIMNULL) 2669 nd->nd_repstat = NFSERR_INVAL; 2670 if (nd->nd_repstat) { 2671 nd->nd_repstat = nfsrv_opencheck(clientid, 2672 &stateid, stp, NULL, nd, p, nd->nd_repstat); 2673 goto nfsmout; 2674 } 2675 if (create == NFSV4OPEN_CREATE) 2676 NFSNAMEICNDSET(&named.ni_cnd, nd->nd_cred, CREATE, 2677 LOCKPARENT | LOCKLEAF | SAVESTART); 2678 else 2679 NFSNAMEICNDSET(&named.ni_cnd, nd->nd_cred, LOOKUP, 2680 LOCKLEAF | SAVESTART); 2681 nfsvno_setpathbuf(&named, &bufp, &hashp); 2682 error = nfsrv_parsename(nd, bufp, hashp, &named.ni_pathlen); 2683 if (error) { 2684 vrele(dp); 2685 #ifdef NFS4_ACL_EXTATTR_NAME 2686 acl_free(aclp); 2687 #endif 2688 FREE((caddr_t)stp, M_NFSDSTATE); 2689 nfsvno_relpathbuf(&named); 2690 NFSEXITCODE2(error, nd); 2691 return (error); 2692 } 2693 if (!nd->nd_repstat) { 2694 nd->nd_repstat = nfsvno_namei(nd, &named, dp, 0, exp, 2695 p, &dirp); 2696 } else { 2697 vrele(dp); 2698 nfsvno_relpathbuf(&named); 2699 } 2700 if (create == NFSV4OPEN_CREATE) { 2701 switch (how) { 2702 case NFSCREATE_UNCHECKED: 2703 if (named.ni_vp) { 2704 /* 2705 * Clear the setable attribute bits, except 2706 * for Size, if it is being truncated. 2707 */ 2708 NFSZERO_ATTRBIT(&attrbits); 2709 if (NFSVNO_ISSETSIZE(&nva)) 2710 NFSSETBIT_ATTRBIT(&attrbits, 2711 NFSATTRBIT_SIZE); 2712 } 2713 break; 2714 case NFSCREATE_GUARDED: 2715 if (named.ni_vp && !nd->nd_repstat) 2716 nd->nd_repstat = EEXIST; 2717 break; 2718 case NFSCREATE_EXCLUSIVE: 2719 exclusive_flag = 1; 2720 if (!named.ni_vp) 2721 nva.na_mode = 0; 2722 }; 2723 } 2724 nfsvno_open(nd, &named, clientid, &stateid, stp, 2725 &exclusive_flag, &nva, cverf, create, aclp, &attrbits, 2726 nd->nd_cred, p, exp, &vp); 2727 } else if (claim == NFSV4OPEN_CLAIMPREVIOUS) { 2728 NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED); 2729 i = fxdr_unsigned(int, *tl); 2730 switch (i) { 2731 case NFSV4OPEN_DELEGATEREAD: 2732 stp->ls_flags |= NFSLCK_DELEGREAD; 2733 break; 2734 case NFSV4OPEN_DELEGATEWRITE: 2735 stp->ls_flags |= NFSLCK_DELEGWRITE; 2736 case NFSV4OPEN_DELEGATENONE: 2737 break; 2738 default: 2739 nd->nd_repstat = NFSERR_BADXDR; 2740 goto nfsmout; 2741 }; 2742 stp->ls_flags |= NFSLCK_RECLAIM; 2743 vp = dp; 2744 NFSVOPLOCK(vp, LK_EXCLUSIVE | LK_RETRY); 2745 if ((vp->v_iflag & VI_DOOMED) == 0) 2746 nd->nd_repstat = nfsrv_opencheck(clientid, &stateid, 2747 stp, vp, nd, p, nd->nd_repstat); 2748 else 2749 nd->nd_repstat = NFSERR_PERM; 2750 } else { 2751 nd->nd_repstat = NFSERR_BADXDR; 2752 goto nfsmout; 2753 } 2754 2755 /* 2756 * Do basic access checking. 2757 */ 2758 if (!nd->nd_repstat && vnode_vtype(vp) != VREG) { 2759 /* 2760 * The IETF working group decided that this is the correct 2761 * error return for all non-regular files. 2762 */ 2763 nd->nd_repstat = NFSERR_SYMLINK; 2764 } 2765 if (!nd->nd_repstat && (stp->ls_flags & NFSLCK_WRITEACCESS)) 2766 nd->nd_repstat = nfsvno_accchk(vp, VWRITE, nd->nd_cred, 2767 exp, p, NFSACCCHK_ALLOWOWNER, NFSACCCHK_VPISLOCKED, NULL); 2768 if (!nd->nd_repstat && (stp->ls_flags & NFSLCK_READACCESS)) { 2769 nd->nd_repstat = nfsvno_accchk(vp, VREAD, nd->nd_cred, 2770 exp, p, NFSACCCHK_ALLOWOWNER, NFSACCCHK_VPISLOCKED, NULL); 2771 if (nd->nd_repstat) 2772 nd->nd_repstat = nfsvno_accchk(vp, VEXEC, 2773 nd->nd_cred, exp, p, NFSACCCHK_ALLOWOWNER, 2774 NFSACCCHK_VPISLOCKED, NULL); 2775 } 2776 2777 if (!nd->nd_repstat) { 2778 nd->nd_repstat = nfsvno_getattr(vp, &nva, nd->nd_cred, p, 1); 2779 if (!nd->nd_repstat) { 2780 tverf[0] = nva.na_atime.tv_sec; 2781 tverf[1] = nva.na_atime.tv_nsec; 2782 } 2783 } 2784 if (!nd->nd_repstat && exclusive_flag && (cverf[0] != tverf[0] || 2785 cverf[1] != tverf[1])) 2786 nd->nd_repstat = EEXIST; 2787 /* 2788 * Do the open locking/delegation stuff. 2789 */ 2790 if (!nd->nd_repstat) 2791 nd->nd_repstat = nfsrv_openctrl(nd, vp, &stp, clientid, &stateid, 2792 &delegstateid, &rflags, exp, p, nva.na_filerev); 2793 2794 /* 2795 * vp must be unlocked before the call to nfsvno_getattr(dirp,...) 2796 * below, to avoid a deadlock with the lookup in nfsvno_namei() above. 2797 * (ie: Leave the NFSVOPUNLOCK() about here.) 2798 */ 2799 if (vp) 2800 NFSVOPUNLOCK(vp, 0); 2801 if (stp) 2802 FREE((caddr_t)stp, M_NFSDSTATE); 2803 if (!nd->nd_repstat && dirp) 2804 nd->nd_repstat = nfsvno_getattr(dirp, &diraft, nd->nd_cred, p, 2805 0); 2806 if (!nd->nd_repstat) { 2807 NFSM_BUILD(tl, u_int32_t *, NFSX_STATEID + 6 * NFSX_UNSIGNED); 2808 *tl++ = txdr_unsigned(stateid.seqid); 2809 NFSBCOPY((caddr_t)stateid.other,(caddr_t)tl,NFSX_STATEIDOTHER); 2810 tl += (NFSX_STATEIDOTHER / NFSX_UNSIGNED); 2811 if (claim == NFSV4OPEN_CLAIMPREVIOUS) { 2812 *tl++ = newnfs_true; 2813 *tl++ = 0; 2814 *tl++ = 0; 2815 *tl++ = 0; 2816 *tl++ = 0; 2817 } else { 2818 *tl++ = newnfs_false; /* Since dirp is not locked */ 2819 txdr_hyper(dirfor.na_filerev, tl); 2820 tl += 2; 2821 txdr_hyper(diraft.na_filerev, tl); 2822 tl += 2; 2823 } 2824 *tl = txdr_unsigned(rflags & NFSV4OPEN_RFLAGS); 2825 (void) nfsrv_putattrbit(nd, &attrbits); 2826 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED); 2827 if (rflags & NFSV4OPEN_READDELEGATE) 2828 *tl = txdr_unsigned(NFSV4OPEN_DELEGATEREAD); 2829 else if (rflags & NFSV4OPEN_WRITEDELEGATE) 2830 *tl = txdr_unsigned(NFSV4OPEN_DELEGATEWRITE); 2831 else 2832 *tl = txdr_unsigned(NFSV4OPEN_DELEGATENONE); 2833 if (rflags & (NFSV4OPEN_READDELEGATE|NFSV4OPEN_WRITEDELEGATE)) { 2834 NFSM_BUILD(tl, u_int32_t *, NFSX_STATEID+NFSX_UNSIGNED); 2835 *tl++ = txdr_unsigned(delegstateid.seqid); 2836 NFSBCOPY((caddr_t)delegstateid.other, (caddr_t)tl, 2837 NFSX_STATEIDOTHER); 2838 tl += (NFSX_STATEIDOTHER / NFSX_UNSIGNED); 2839 if (rflags & NFSV4OPEN_RECALL) 2840 *tl = newnfs_true; 2841 else 2842 *tl = newnfs_false; 2843 if (rflags & NFSV4OPEN_WRITEDELEGATE) { 2844 NFSM_BUILD(tl, u_int32_t *, 3 * NFSX_UNSIGNED); 2845 *tl++ = txdr_unsigned(NFSV4OPEN_LIMITSIZE); 2846 txdr_hyper(nva.na_size, tl); 2847 } 2848 NFSM_BUILD(tl, u_int32_t *, 3 * NFSX_UNSIGNED); 2849 *tl++ = txdr_unsigned(NFSV4ACE_ALLOWEDTYPE); 2850 *tl++ = txdr_unsigned(0x0); 2851 acemask = NFSV4ACE_ALLFILESMASK; 2852 if (nva.na_mode & S_IRUSR) 2853 acemask |= NFSV4ACE_READMASK; 2854 if (nva.na_mode & S_IWUSR) 2855 acemask |= NFSV4ACE_WRITEMASK; 2856 if (nva.na_mode & S_IXUSR) 2857 acemask |= NFSV4ACE_EXECUTEMASK; 2858 *tl = txdr_unsigned(acemask); 2859 (void) nfsm_strtom(nd, "OWNER@", 6); 2860 } 2861 *vpp = vp; 2862 } else if (vp) { 2863 vrele(vp); 2864 } 2865 if (dirp) 2866 vrele(dirp); 2867 #ifdef NFS4_ACL_EXTATTR_NAME 2868 acl_free(aclp); 2869 #endif 2870 NFSEXITCODE2(0, nd); 2871 return (0); 2872 nfsmout: 2873 vrele(dp); 2874 #ifdef NFS4_ACL_EXTATTR_NAME 2875 acl_free(aclp); 2876 #endif 2877 if (stp) 2878 FREE((caddr_t)stp, M_NFSDSTATE); 2879 NFSEXITCODE2(error, nd); 2880 return (error); 2881 } 2882 2883 /* 2884 * nfsv4 close service 2885 */ 2886 APPLESTATIC int 2887 nfsrvd_close(struct nfsrv_descript *nd, __unused int isdgram, 2888 vnode_t vp, NFSPROC_T *p, __unused struct nfsexstuff *exp) 2889 { 2890 u_int32_t *tl; 2891 struct nfsstate st, *stp = &st; 2892 int error = 0; 2893 nfsv4stateid_t stateid; 2894 nfsquad_t clientid; 2895 2896 NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED + NFSX_STATEID); 2897 stp->ls_seq = fxdr_unsigned(u_int32_t, *tl++); 2898 stp->ls_ownerlen = 0; 2899 stp->ls_op = nd->nd_rp; 2900 stp->ls_uid = nd->nd_cred->cr_uid; 2901 stp->ls_stateid.seqid = fxdr_unsigned(u_int32_t, *tl++); 2902 NFSBCOPY((caddr_t)tl, (caddr_t)stp->ls_stateid.other, 2903 NFSX_STATEIDOTHER); 2904 stp->ls_flags = NFSLCK_CLOSE; 2905 clientid.lval[0] = stp->ls_stateid.other[0]; 2906 clientid.lval[1] = stp->ls_stateid.other[1]; 2907 if (nd->nd_flag & ND_IMPLIEDCLID) { 2908 if (nd->nd_clientid.qval != clientid.qval) 2909 printf("EEK! multiple clids\n"); 2910 } else { 2911 nd->nd_flag |= ND_IMPLIEDCLID; 2912 nd->nd_clientid.qval = clientid.qval; 2913 } 2914 nd->nd_repstat = nfsrv_openupdate(vp, stp, clientid, &stateid, nd, p); 2915 vput(vp); 2916 if (!nd->nd_repstat) { 2917 NFSM_BUILD(tl, u_int32_t *, NFSX_STATEID); 2918 *tl++ = txdr_unsigned(stateid.seqid); 2919 NFSBCOPY((caddr_t)stateid.other,(caddr_t)tl,NFSX_STATEIDOTHER); 2920 } 2921 NFSEXITCODE2(0, nd); 2922 return (0); 2923 nfsmout: 2924 vput(vp); 2925 NFSEXITCODE2(error, nd); 2926 return (error); 2927 } 2928 2929 /* 2930 * nfsv4 delegpurge service 2931 */ 2932 APPLESTATIC int 2933 nfsrvd_delegpurge(struct nfsrv_descript *nd, __unused int isdgram, 2934 __unused vnode_t vp, __unused NFSPROC_T *p, __unused struct nfsexstuff *exp) 2935 { 2936 u_int32_t *tl; 2937 int error = 0; 2938 nfsquad_t clientid; 2939 2940 if (nfs_rootfhset == 0 || nfsd_checkrootexp(nd) != 0) { 2941 nd->nd_repstat = NFSERR_WRONGSEC; 2942 goto nfsmout; 2943 } 2944 NFSM_DISSECT(tl, u_int32_t *, 2 * NFSX_UNSIGNED); 2945 clientid.lval[0] = *tl++; 2946 clientid.lval[1] = *tl; 2947 if (nd->nd_flag & ND_IMPLIEDCLID) { 2948 if (nd->nd_clientid.qval != clientid.qval) 2949 printf("EEK! multiple clids\n"); 2950 } else { 2951 nd->nd_flag |= ND_IMPLIEDCLID; 2952 nd->nd_clientid.qval = clientid.qval; 2953 } 2954 nd->nd_repstat = nfsrv_delegupdate(clientid, NULL, NULL, 2955 NFSV4OP_DELEGPURGE, nd->nd_cred, p); 2956 nfsmout: 2957 NFSEXITCODE2(error, nd); 2958 return (error); 2959 } 2960 2961 /* 2962 * nfsv4 delegreturn service 2963 */ 2964 APPLESTATIC int 2965 nfsrvd_delegreturn(struct nfsrv_descript *nd, __unused int isdgram, 2966 vnode_t vp, NFSPROC_T *p, __unused struct nfsexstuff *exp) 2967 { 2968 u_int32_t *tl; 2969 int error = 0; 2970 nfsv4stateid_t stateid; 2971 nfsquad_t clientid; 2972 2973 NFSM_DISSECT(tl, u_int32_t *, NFSX_STATEID); 2974 stateid.seqid = fxdr_unsigned(u_int32_t, *tl++); 2975 NFSBCOPY((caddr_t)tl, (caddr_t)stateid.other, NFSX_STATEIDOTHER); 2976 clientid.lval[0] = stateid.other[0]; 2977 clientid.lval[1] = stateid.other[1]; 2978 if (nd->nd_flag & ND_IMPLIEDCLID) { 2979 if (nd->nd_clientid.qval != clientid.qval) 2980 printf("EEK! multiple clids\n"); 2981 } else { 2982 nd->nd_flag |= ND_IMPLIEDCLID; 2983 nd->nd_clientid.qval = clientid.qval; 2984 } 2985 nd->nd_repstat = nfsrv_delegupdate(clientid, &stateid, vp, 2986 NFSV4OP_DELEGRETURN, nd->nd_cred, p); 2987 nfsmout: 2988 vput(vp); 2989 NFSEXITCODE2(error, nd); 2990 return (error); 2991 } 2992 2993 /* 2994 * nfsv4 get file handle service 2995 */ 2996 APPLESTATIC int 2997 nfsrvd_getfh(struct nfsrv_descript *nd, __unused int isdgram, 2998 vnode_t vp, NFSPROC_T *p, __unused struct nfsexstuff *exp) 2999 { 3000 fhandle_t fh; 3001 3002 nd->nd_repstat = nfsvno_getfh(vp, &fh, p); 3003 vput(vp); 3004 if (!nd->nd_repstat) 3005 (void) nfsm_fhtom(nd, (u_int8_t *)&fh, 0, 0); 3006 NFSEXITCODE2(0, nd); 3007 return (0); 3008 } 3009 3010 /* 3011 * nfsv4 open confirm service 3012 */ 3013 APPLESTATIC int 3014 nfsrvd_openconfirm(struct nfsrv_descript *nd, __unused int isdgram, 3015 vnode_t vp, NFSPROC_T *p, __unused struct nfsexstuff *exp) 3016 { 3017 u_int32_t *tl; 3018 struct nfsstate st, *stp = &st; 3019 int error = 0; 3020 nfsv4stateid_t stateid; 3021 nfsquad_t clientid; 3022 3023 NFSM_DISSECT(tl, u_int32_t *, NFSX_STATEID + NFSX_UNSIGNED); 3024 stp->ls_ownerlen = 0; 3025 stp->ls_op = nd->nd_rp; 3026 stp->ls_uid = nd->nd_cred->cr_uid; 3027 stp->ls_stateid.seqid = fxdr_unsigned(u_int32_t, *tl++); 3028 NFSBCOPY((caddr_t)tl, (caddr_t)stp->ls_stateid.other, 3029 NFSX_STATEIDOTHER); 3030 tl += (NFSX_STATEIDOTHER / NFSX_UNSIGNED); 3031 stp->ls_seq = fxdr_unsigned(u_int32_t, *tl); 3032 stp->ls_flags = NFSLCK_CONFIRM; 3033 clientid.lval[0] = stp->ls_stateid.other[0]; 3034 clientid.lval[1] = stp->ls_stateid.other[1]; 3035 if (nd->nd_flag & ND_IMPLIEDCLID) { 3036 if (nd->nd_clientid.qval != clientid.qval) 3037 printf("EEK! multiple clids\n"); 3038 } else { 3039 nd->nd_flag |= ND_IMPLIEDCLID; 3040 nd->nd_clientid.qval = clientid.qval; 3041 } 3042 nd->nd_repstat = nfsrv_openupdate(vp, stp, clientid, &stateid, nd, p); 3043 if (!nd->nd_repstat) { 3044 NFSM_BUILD(tl, u_int32_t *, NFSX_STATEID); 3045 *tl++ = txdr_unsigned(stateid.seqid); 3046 NFSBCOPY((caddr_t)stateid.other,(caddr_t)tl,NFSX_STATEIDOTHER); 3047 } 3048 nfsmout: 3049 vput(vp); 3050 NFSEXITCODE2(error, nd); 3051 return (error); 3052 } 3053 3054 /* 3055 * nfsv4 open downgrade service 3056 */ 3057 APPLESTATIC int 3058 nfsrvd_opendowngrade(struct nfsrv_descript *nd, __unused int isdgram, 3059 vnode_t vp, NFSPROC_T *p, __unused struct nfsexstuff *exp) 3060 { 3061 u_int32_t *tl; 3062 int i; 3063 struct nfsstate st, *stp = &st; 3064 int error = 0; 3065 nfsv4stateid_t stateid; 3066 nfsquad_t clientid; 3067 3068 NFSM_DISSECT(tl, u_int32_t *, NFSX_STATEID + 3 * NFSX_UNSIGNED); 3069 stp->ls_ownerlen = 0; 3070 stp->ls_op = nd->nd_rp; 3071 stp->ls_uid = nd->nd_cred->cr_uid; 3072 stp->ls_stateid.seqid = fxdr_unsigned(u_int32_t, *tl++); 3073 NFSBCOPY((caddr_t)tl, (caddr_t)stp->ls_stateid.other, 3074 NFSX_STATEIDOTHER); 3075 tl += (NFSX_STATEIDOTHER / NFSX_UNSIGNED); 3076 stp->ls_seq = fxdr_unsigned(u_int32_t, *tl++); 3077 i = fxdr_unsigned(int, *tl++); 3078 switch (i) { 3079 case NFSV4OPEN_ACCESSREAD: 3080 stp->ls_flags = (NFSLCK_READACCESS | NFSLCK_DOWNGRADE); 3081 break; 3082 case NFSV4OPEN_ACCESSWRITE: 3083 stp->ls_flags = (NFSLCK_WRITEACCESS | NFSLCK_DOWNGRADE); 3084 break; 3085 case NFSV4OPEN_ACCESSBOTH: 3086 stp->ls_flags = (NFSLCK_READACCESS | NFSLCK_WRITEACCESS | 3087 NFSLCK_DOWNGRADE); 3088 break; 3089 default: 3090 nd->nd_repstat = NFSERR_BADXDR; 3091 }; 3092 i = fxdr_unsigned(int, *tl); 3093 switch (i) { 3094 case NFSV4OPEN_DENYNONE: 3095 break; 3096 case NFSV4OPEN_DENYREAD: 3097 stp->ls_flags |= NFSLCK_READDENY; 3098 break; 3099 case NFSV4OPEN_DENYWRITE: 3100 stp->ls_flags |= NFSLCK_WRITEDENY; 3101 break; 3102 case NFSV4OPEN_DENYBOTH: 3103 stp->ls_flags |= (NFSLCK_READDENY | NFSLCK_WRITEDENY); 3104 break; 3105 default: 3106 nd->nd_repstat = NFSERR_BADXDR; 3107 }; 3108 3109 clientid.lval[0] = stp->ls_stateid.other[0]; 3110 clientid.lval[1] = stp->ls_stateid.other[1]; 3111 if (nd->nd_flag & ND_IMPLIEDCLID) { 3112 if (nd->nd_clientid.qval != clientid.qval) 3113 printf("EEK! multiple clids\n"); 3114 } else { 3115 nd->nd_flag |= ND_IMPLIEDCLID; 3116 nd->nd_clientid.qval = clientid.qval; 3117 } 3118 if (!nd->nd_repstat) 3119 nd->nd_repstat = nfsrv_openupdate(vp, stp, clientid, &stateid, 3120 nd, p); 3121 if (!nd->nd_repstat) { 3122 NFSM_BUILD(tl, u_int32_t *, NFSX_STATEID); 3123 *tl++ = txdr_unsigned(stateid.seqid); 3124 NFSBCOPY((caddr_t)stateid.other,(caddr_t)tl,NFSX_STATEIDOTHER); 3125 } 3126 nfsmout: 3127 vput(vp); 3128 NFSEXITCODE2(error, nd); 3129 return (error); 3130 } 3131 3132 /* 3133 * nfsv4 renew lease service 3134 */ 3135 APPLESTATIC int 3136 nfsrvd_renew(struct nfsrv_descript *nd, __unused int isdgram, 3137 __unused vnode_t vp, NFSPROC_T *p, __unused struct nfsexstuff *exp) 3138 { 3139 u_int32_t *tl; 3140 int error = 0; 3141 nfsquad_t clientid; 3142 3143 if (nfs_rootfhset == 0 || nfsd_checkrootexp(nd) != 0) { 3144 nd->nd_repstat = NFSERR_WRONGSEC; 3145 goto nfsmout; 3146 } 3147 NFSM_DISSECT(tl, u_int32_t *, NFSX_HYPER); 3148 clientid.lval[0] = *tl++; 3149 clientid.lval[1] = *tl; 3150 if (nd->nd_flag & ND_IMPLIEDCLID) { 3151 if (nd->nd_clientid.qval != clientid.qval) 3152 printf("EEK! multiple clids\n"); 3153 } else { 3154 nd->nd_flag |= ND_IMPLIEDCLID; 3155 nd->nd_clientid.qval = clientid.qval; 3156 } 3157 nd->nd_repstat = nfsrv_getclient(clientid, (CLOPS_RENEWOP|CLOPS_RENEW), 3158 NULL, (nfsquad_t)((u_quad_t)0), nd, p); 3159 nfsmout: 3160 NFSEXITCODE2(error, nd); 3161 return (error); 3162 } 3163 3164 /* 3165 * nfsv4 security info service 3166 */ 3167 APPLESTATIC int 3168 nfsrvd_secinfo(struct nfsrv_descript *nd, int isdgram, 3169 vnode_t dp, NFSPROC_T *p, struct nfsexstuff *exp) 3170 { 3171 u_int32_t *tl; 3172 int len; 3173 struct nameidata named; 3174 vnode_t dirp = NULL, vp; 3175 struct nfsrvfh fh; 3176 struct nfsexstuff retnes; 3177 u_int32_t *sizp; 3178 int error = 0, savflag, i; 3179 char *bufp; 3180 u_long *hashp; 3181 3182 /* 3183 * All this just to get the export flags for the name. 3184 */ 3185 NFSNAMEICNDSET(&named.ni_cnd, nd->nd_cred, LOOKUP, 3186 LOCKLEAF | SAVESTART); 3187 nfsvno_setpathbuf(&named, &bufp, &hashp); 3188 error = nfsrv_parsename(nd, bufp, hashp, &named.ni_pathlen); 3189 if (error) { 3190 vput(dp); 3191 nfsvno_relpathbuf(&named); 3192 goto out; 3193 } 3194 if (!nd->nd_repstat) { 3195 nd->nd_repstat = nfsvno_namei(nd, &named, dp, 1, exp, p, &dirp); 3196 } else { 3197 vput(dp); 3198 nfsvno_relpathbuf(&named); 3199 } 3200 if (dirp) 3201 vrele(dirp); 3202 if (nd->nd_repstat) 3203 goto out; 3204 vrele(named.ni_startdir); 3205 nfsvno_relpathbuf(&named); 3206 fh.nfsrvfh_len = NFSX_MYFH; 3207 vp = named.ni_vp; 3208 nd->nd_repstat = nfsvno_getfh(vp, (fhandle_t *)fh.nfsrvfh_data, p); 3209 vput(vp); 3210 savflag = nd->nd_flag; 3211 if (!nd->nd_repstat) { 3212 nfsd_fhtovp(nd, &fh, LK_SHARED, &vp, &retnes, NULL, 0, p); 3213 if (vp) 3214 vput(vp); 3215 } 3216 nd->nd_flag = savflag; 3217 if (nd->nd_repstat) 3218 goto out; 3219 3220 /* 3221 * Finally have the export flags for name, so we can create 3222 * the security info. 3223 */ 3224 len = 0; 3225 NFSM_BUILD(sizp, u_int32_t *, NFSX_UNSIGNED); 3226 for (i = 0; i < retnes.nes_numsecflavor; i++) { 3227 if (retnes.nes_secflavors[i] == AUTH_SYS) { 3228 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED); 3229 *tl = txdr_unsigned(RPCAUTH_UNIX); 3230 len++; 3231 } else if (retnes.nes_secflavors[i] == RPCSEC_GSS_KRB5) { 3232 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED); 3233 *tl++ = txdr_unsigned(RPCAUTH_GSS); 3234 (void) nfsm_strtom(nd, nfsgss_mechlist[KERBV_MECH].str, 3235 nfsgss_mechlist[KERBV_MECH].len); 3236 NFSM_BUILD(tl, u_int32_t *, 2 * NFSX_UNSIGNED); 3237 *tl++ = txdr_unsigned(GSS_KERBV_QOP); 3238 *tl = txdr_unsigned(RPCAUTHGSS_SVCNONE); 3239 len++; 3240 } else if (retnes.nes_secflavors[i] == RPCSEC_GSS_KRB5I) { 3241 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED); 3242 *tl++ = txdr_unsigned(RPCAUTH_GSS); 3243 (void) nfsm_strtom(nd, nfsgss_mechlist[KERBV_MECH].str, 3244 nfsgss_mechlist[KERBV_MECH].len); 3245 NFSM_BUILD(tl, u_int32_t *, 2 * NFSX_UNSIGNED); 3246 *tl++ = txdr_unsigned(GSS_KERBV_QOP); 3247 *tl = txdr_unsigned(RPCAUTHGSS_SVCINTEGRITY); 3248 len++; 3249 } else if (retnes.nes_secflavors[i] == RPCSEC_GSS_KRB5P) { 3250 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED); 3251 *tl++ = txdr_unsigned(RPCAUTH_GSS); 3252 (void) nfsm_strtom(nd, nfsgss_mechlist[KERBV_MECH].str, 3253 nfsgss_mechlist[KERBV_MECH].len); 3254 NFSM_BUILD(tl, u_int32_t *, 2 * NFSX_UNSIGNED); 3255 *tl++ = txdr_unsigned(GSS_KERBV_QOP); 3256 *tl = txdr_unsigned(RPCAUTHGSS_SVCPRIVACY); 3257 len++; 3258 } 3259 } 3260 *sizp = txdr_unsigned(len); 3261 3262 out: 3263 NFSEXITCODE2(error, nd); 3264 return (error); 3265 } 3266 3267 /* 3268 * nfsv4 set client id service 3269 */ 3270 APPLESTATIC int 3271 nfsrvd_setclientid(struct nfsrv_descript *nd, __unused int isdgram, 3272 __unused vnode_t vp, NFSPROC_T *p, __unused struct nfsexstuff *exp) 3273 { 3274 u_int32_t *tl; 3275 int i; 3276 int error = 0, idlen; 3277 struct nfsclient *clp = NULL; 3278 struct sockaddr_in *rad; 3279 u_char *verf, *ucp, *ucp2, addrbuf[24]; 3280 nfsquad_t clientid, confirm; 3281 3282 if (nfs_rootfhset == 0 || nfsd_checkrootexp(nd) != 0) { 3283 nd->nd_repstat = NFSERR_WRONGSEC; 3284 goto out; 3285 } 3286 NFSM_DISSECT(tl, u_int32_t *, NFSX_VERF + NFSX_UNSIGNED); 3287 verf = (u_char *)tl; 3288 tl += (NFSX_VERF / NFSX_UNSIGNED); 3289 i = fxdr_unsigned(int, *tl); 3290 if (i > NFSV4_OPAQUELIMIT || i <= 0) { 3291 nd->nd_repstat = NFSERR_BADXDR; 3292 goto nfsmout; 3293 } 3294 idlen = i; 3295 if (nd->nd_flag & ND_GSS) 3296 i += nd->nd_princlen; 3297 MALLOC(clp, struct nfsclient *, sizeof (struct nfsclient) + i, 3298 M_NFSDCLIENT, M_WAITOK); 3299 NFSBZERO((caddr_t)clp, sizeof (struct nfsclient) + i); 3300 NFSINITSOCKMUTEX(&clp->lc_req.nr_mtx); 3301 NFSSOCKADDRALLOC(clp->lc_req.nr_nam); 3302 NFSSOCKADDRSIZE(clp->lc_req.nr_nam, sizeof (struct sockaddr_in)); 3303 clp->lc_req.nr_cred = NULL; 3304 NFSBCOPY(verf, clp->lc_verf, NFSX_VERF); 3305 clp->lc_idlen = idlen; 3306 error = nfsrv_mtostr(nd, clp->lc_id, idlen); 3307 if (error) 3308 goto nfsmout; 3309 if (nd->nd_flag & ND_GSS) { 3310 clp->lc_flags = LCL_GSS; 3311 if (nd->nd_flag & ND_GSSINTEGRITY) 3312 clp->lc_flags |= LCL_GSSINTEGRITY; 3313 else if (nd->nd_flag & ND_GSSPRIVACY) 3314 clp->lc_flags |= LCL_GSSPRIVACY; 3315 } else { 3316 clp->lc_flags = 0; 3317 } 3318 if ((nd->nd_flag & ND_GSS) && nd->nd_princlen > 0) { 3319 clp->lc_flags |= LCL_NAME; 3320 clp->lc_namelen = nd->nd_princlen; 3321 clp->lc_name = &clp->lc_id[idlen]; 3322 NFSBCOPY(nd->nd_principal, clp->lc_name, clp->lc_namelen); 3323 } else { 3324 clp->lc_uid = nd->nd_cred->cr_uid; 3325 clp->lc_gid = nd->nd_cred->cr_gid; 3326 } 3327 NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED); 3328 clp->lc_program = fxdr_unsigned(u_int32_t, *tl); 3329 error = nfsrv_getclientipaddr(nd, clp); 3330 if (error) 3331 goto nfsmout; 3332 NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED); 3333 clp->lc_callback = fxdr_unsigned(u_int32_t, *tl); 3334 3335 /* 3336 * nfsrv_setclient() does the actual work of adding it to the 3337 * client list. If there is no error, the structure has been 3338 * linked into the client list and clp should no longer be used 3339 * here. When an error is returned, it has not been linked in, 3340 * so it should be free'd. 3341 */ 3342 nd->nd_repstat = nfsrv_setclient(nd, &clp, &clientid, &confirm, p); 3343 if (nd->nd_repstat == NFSERR_CLIDINUSE) { 3344 if (clp->lc_flags & LCL_TCPCALLBACK) 3345 (void) nfsm_strtom(nd, "tcp", 3); 3346 else 3347 (void) nfsm_strtom(nd, "udp", 3); 3348 rad = NFSSOCKADDR(clp->lc_req.nr_nam, struct sockaddr_in *); 3349 ucp = (u_char *)&rad->sin_addr.s_addr; 3350 ucp2 = (u_char *)&rad->sin_port; 3351 sprintf(addrbuf, "%d.%d.%d.%d.%d.%d", ucp[0] & 0xff, 3352 ucp[1] & 0xff, ucp[2] & 0xff, ucp[3] & 0xff, 3353 ucp2[0] & 0xff, ucp2[1] & 0xff); 3354 (void) nfsm_strtom(nd, addrbuf, strlen(addrbuf)); 3355 } 3356 if (clp) { 3357 NFSSOCKADDRFREE(clp->lc_req.nr_nam); 3358 NFSFREEMUTEX(&clp->lc_req.nr_mtx); 3359 free((caddr_t)clp, M_NFSDCLIENT); 3360 } 3361 if (!nd->nd_repstat) { 3362 NFSM_BUILD(tl, u_int32_t *, 2 * NFSX_HYPER); 3363 *tl++ = clientid.lval[0]; 3364 *tl++ = clientid.lval[1]; 3365 *tl++ = confirm.lval[0]; 3366 *tl = confirm.lval[1]; 3367 } 3368 3369 out: 3370 NFSEXITCODE2(0, nd); 3371 return (0); 3372 nfsmout: 3373 if (clp) { 3374 NFSSOCKADDRFREE(clp->lc_req.nr_nam); 3375 NFSFREEMUTEX(&clp->lc_req.nr_mtx); 3376 free((caddr_t)clp, M_NFSDCLIENT); 3377 } 3378 NFSEXITCODE2(error, nd); 3379 return (error); 3380 } 3381 3382 /* 3383 * nfsv4 set client id confirm service 3384 */ 3385 APPLESTATIC int 3386 nfsrvd_setclientidcfrm(struct nfsrv_descript *nd, 3387 __unused int isdgram, __unused vnode_t vp, NFSPROC_T *p, 3388 __unused struct nfsexstuff *exp) 3389 { 3390 u_int32_t *tl; 3391 int error = 0; 3392 nfsquad_t clientid, confirm; 3393 3394 if (nfs_rootfhset == 0 || nfsd_checkrootexp(nd) != 0) { 3395 nd->nd_repstat = NFSERR_WRONGSEC; 3396 goto nfsmout; 3397 } 3398 NFSM_DISSECT(tl, u_int32_t *, 2 * NFSX_HYPER); 3399 clientid.lval[0] = *tl++; 3400 clientid.lval[1] = *tl++; 3401 confirm.lval[0] = *tl++; 3402 confirm.lval[1] = *tl; 3403 3404 /* 3405 * nfsrv_getclient() searches the client list for a match and 3406 * returns the appropriate NFSERR status. 3407 */ 3408 nd->nd_repstat = nfsrv_getclient(clientid, (CLOPS_CONFIRM|CLOPS_RENEW), 3409 NULL, confirm, nd, p); 3410 nfsmout: 3411 NFSEXITCODE2(error, nd); 3412 return (error); 3413 } 3414 3415 /* 3416 * nfsv4 verify service 3417 */ 3418 APPLESTATIC int 3419 nfsrvd_verify(struct nfsrv_descript *nd, int isdgram, 3420 vnode_t vp, NFSPROC_T *p, __unused struct nfsexstuff *exp) 3421 { 3422 int error = 0, ret, fhsize = NFSX_MYFH; 3423 struct nfsvattr nva; 3424 struct statfs sf; 3425 struct nfsfsinfo fs; 3426 fhandle_t fh; 3427 3428 nd->nd_repstat = nfsvno_getattr(vp, &nva, nd->nd_cred, p, 1); 3429 if (!nd->nd_repstat) 3430 nd->nd_repstat = nfsvno_statfs(vp, &sf); 3431 if (!nd->nd_repstat) 3432 nd->nd_repstat = nfsvno_getfh(vp, &fh, p); 3433 if (!nd->nd_repstat) { 3434 nfsvno_getfs(&fs, isdgram); 3435 error = nfsv4_loadattr(nd, vp, &nva, NULL, &fh, fhsize, NULL, 3436 &sf, NULL, &fs, NULL, 1, &ret, NULL, NULL, p, nd->nd_cred); 3437 if (!error) { 3438 if (nd->nd_procnum == NFSV4OP_NVERIFY) { 3439 if (ret == 0) 3440 nd->nd_repstat = NFSERR_SAME; 3441 else if (ret != NFSERR_NOTSAME) 3442 nd->nd_repstat = ret; 3443 } else if (ret) 3444 nd->nd_repstat = ret; 3445 } 3446 } 3447 vput(vp); 3448 NFSEXITCODE2(error, nd); 3449 return (error); 3450 } 3451 3452 /* 3453 * nfs openattr rpc 3454 */ 3455 APPLESTATIC int 3456 nfsrvd_openattr(struct nfsrv_descript *nd, __unused int isdgram, 3457 vnode_t dp, __unused vnode_t *vpp, __unused fhandle_t *fhp, 3458 __unused NFSPROC_T *p, __unused struct nfsexstuff *exp) 3459 { 3460 u_int32_t *tl; 3461 int error = 0, createdir; 3462 3463 NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED); 3464 createdir = fxdr_unsigned(int, *tl); 3465 nd->nd_repstat = NFSERR_NOTSUPP; 3466 nfsmout: 3467 vrele(dp); 3468 NFSEXITCODE2(error, nd); 3469 return (error); 3470 } 3471 3472 /* 3473 * nfsv4 release lock owner service 3474 */ 3475 APPLESTATIC int 3476 nfsrvd_releaselckown(struct nfsrv_descript *nd, __unused int isdgram, 3477 __unused vnode_t vp, NFSPROC_T *p, __unused struct nfsexstuff *exp) 3478 { 3479 u_int32_t *tl; 3480 struct nfsstate *stp = NULL; 3481 int error = 0, len; 3482 nfsquad_t clientid; 3483 3484 if (nfs_rootfhset == 0 || nfsd_checkrootexp(nd) != 0) { 3485 nd->nd_repstat = NFSERR_WRONGSEC; 3486 goto nfsmout; 3487 } 3488 NFSM_DISSECT(tl, u_int32_t *, 3 * NFSX_UNSIGNED); 3489 len = fxdr_unsigned(int, *(tl + 2)); 3490 if (len <= 0 || len > NFSV4_OPAQUELIMIT) { 3491 nd->nd_repstat = NFSERR_BADXDR; 3492 goto nfsmout; 3493 } 3494 MALLOC(stp, struct nfsstate *, sizeof (struct nfsstate) + len, 3495 M_NFSDSTATE, M_WAITOK); 3496 stp->ls_ownerlen = len; 3497 stp->ls_op = NULL; 3498 stp->ls_flags = NFSLCK_RELEASE; 3499 stp->ls_uid = nd->nd_cred->cr_uid; 3500 clientid.lval[0] = *tl++; 3501 clientid.lval[1] = *tl; 3502 if (nd->nd_flag & ND_IMPLIEDCLID) { 3503 if (nd->nd_clientid.qval != clientid.qval) 3504 printf("EEK! multiple clids\n"); 3505 } else { 3506 nd->nd_flag |= ND_IMPLIEDCLID; 3507 nd->nd_clientid.qval = clientid.qval; 3508 } 3509 error = nfsrv_mtostr(nd, stp->ls_owner, len); 3510 if (error) 3511 goto nfsmout; 3512 nd->nd_repstat = nfsrv_releaselckown(stp, clientid, p); 3513 FREE((caddr_t)stp, M_NFSDSTATE); 3514 3515 NFSEXITCODE2(0, nd); 3516 return (0); 3517 nfsmout: 3518 if (stp) 3519 free((caddr_t)stp, M_NFSDSTATE); 3520 NFSEXITCODE2(error, nd); 3521 return (error); 3522 }
Cache object: 5373877e3a9933bc49755509b6374cbf
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]