2 * Copyright (c) 1989, 1993
3 * The Regents of the University of California. All rights reserved.
5 * This code is derived from software contributed to Berkeley by
6 * Rick Macklem at The University of Guelph.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
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.
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
34 #include <sys/cdefs.h>
35 __FBSDID("$FreeBSD$");
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.
48 #include <fs/nfs/nfsport.h>
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 */
58 static int nfs_async = 0;
59 SYSCTL_DECL(_vfs_nfsd);
60 SYSCTL_INT(_vfs_nfsd, OID_AUTO, async, CTLFLAG_RW, &nfs_async, 0,
61 "Tell client that writes were synced even though they were not");
64 * This list defines the GSS mechanisms supported.
65 * (Don't ask me how you get these strings from the RFC stuff like
66 * iso(1), org(3)... but someone did it, so I don't need to know.)
68 static struct nfsgss_mechlist nfsgss_mechlist[] = {
69 { 9, "\052\206\110\206\367\022\001\002\002", 11 },
74 static void nfsrvd_symlinksub(struct nfsrv_descript *nd, struct nameidata *ndp,
75 struct nfsvattr *nvap, fhandle_t *fhp, vnode_t *vpp,
76 vnode_t dirp, struct nfsvattr *dirforp, struct nfsvattr *diraftp,
77 int *diraft_retp, nfsattrbit_t *attrbitp,
78 NFSACL_T *aclp, NFSPROC_T *p, struct nfsexstuff *exp, char *pathcp,
80 static void nfsrvd_mkdirsub(struct nfsrv_descript *nd, struct nameidata *ndp,
81 struct nfsvattr *nvap, fhandle_t *fhp, vnode_t *vpp,
82 vnode_t dirp, struct nfsvattr *dirforp, struct nfsvattr *diraftp,
83 int *diraft_retp, nfsattrbit_t *attrbitp, NFSACL_T *aclp,
84 NFSPROC_T *p, struct nfsexstuff *exp);
87 * nfs access service (not a part of NFS V2)
90 nfsrvd_access(struct nfsrv_descript *nd, __unused int isdgram,
91 vnode_t vp, NFSPROC_T *p, struct nfsexstuff *exp)
94 int getret, error = 0;
96 u_int32_t testmode, nfsmode, supported = 0;
100 nfsrv_postopattr(nd, 1, &nva);
103 NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
104 nfsmode = fxdr_unsigned(u_int32_t, *tl);
105 if ((nd->nd_flag & ND_NFSV4) &&
106 (nfsmode & ~(NFSACCESS_READ | NFSACCESS_LOOKUP |
107 NFSACCESS_MODIFY | NFSACCESS_EXTEND | NFSACCESS_DELETE |
108 NFSACCESS_EXECUTE))) {
109 nd->nd_repstat = NFSERR_INVAL;
113 if (nfsmode & NFSACCESS_READ) {
114 supported |= NFSACCESS_READ;
115 if (nfsvno_accchk(vp, VREAD, nd->nd_cred, exp, p,
116 NFSACCCHK_NOOVERRIDE, NFSACCCHK_VPISLOCKED, &supported))
117 nfsmode &= ~NFSACCESS_READ;
119 if (nfsmode & NFSACCESS_MODIFY) {
120 supported |= NFSACCESS_MODIFY;
121 if (nfsvno_accchk(vp, VWRITE, nd->nd_cred, exp, p,
122 NFSACCCHK_NOOVERRIDE, NFSACCCHK_VPISLOCKED, &supported))
123 nfsmode &= ~NFSACCESS_MODIFY;
125 if (nfsmode & NFSACCESS_EXTEND) {
126 supported |= NFSACCESS_EXTEND;
127 if (nfsvno_accchk(vp, VWRITE | VAPPEND, nd->nd_cred, exp, p,
128 NFSACCCHK_NOOVERRIDE, NFSACCCHK_VPISLOCKED, &supported))
129 nfsmode &= ~NFSACCESS_EXTEND;
131 if (nfsmode & NFSACCESS_DELETE) {
132 supported |= NFSACCESS_DELETE;
133 if (vp->v_type == VDIR)
134 deletebit = VDELETE_CHILD;
137 if (nfsvno_accchk(vp, deletebit, nd->nd_cred, exp, p,
138 NFSACCCHK_NOOVERRIDE, NFSACCCHK_VPISLOCKED, &supported))
139 nfsmode &= ~NFSACCESS_DELETE;
141 if (vnode_vtype(vp) == VDIR)
142 testmode = NFSACCESS_LOOKUP;
144 testmode = NFSACCESS_EXECUTE;
145 if (nfsmode & testmode) {
146 supported |= (nfsmode & testmode);
147 if (nfsvno_accchk(vp, VEXEC, nd->nd_cred, exp, p,
148 NFSACCCHK_NOOVERRIDE, NFSACCCHK_VPISLOCKED, &supported))
149 nfsmode &= ~testmode;
151 nfsmode &= supported;
152 if (nd->nd_flag & ND_NFSV3) {
153 getret = nfsvno_getattr(vp, &nva, nd->nd_cred, p, 1);
154 nfsrv_postopattr(nd, getret, &nva);
157 if (nd->nd_flag & ND_NFSV4) {
158 NFSM_BUILD(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
159 *tl++ = txdr_unsigned(supported);
161 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
162 *tl = txdr_unsigned(nfsmode);
169 NFSEXITCODE2(error, nd);
174 * nfs getattr service
177 nfsrvd_getattr(struct nfsrv_descript *nd, int isdgram,
178 vnode_t vp, NFSPROC_T *p, __unused struct nfsexstuff *exp)
182 int at_root = 0, error = 0, supports_nfsv4acls;
183 struct nfsreferral *refp;
184 nfsattrbit_t attrbits, tmpbits;
186 struct vnode *tvp = NULL;
188 uint64_t mounted_on_fileno = 0;
193 if (nd->nd_flag & ND_NFSV4) {
194 error = nfsrv_getattrbits(nd, &attrbits, NULL, NULL);
201 * Check for a referral.
203 refp = nfsv4root_getreferral(vp, NULL, 0);
205 (void) nfsrv_putreferralattr(nd, &attrbits, refp, 1,
210 if (nd->nd_repstat == 0) {
212 NFSSET_ATTRBIT(&tmpbits, &attrbits);
213 if (NFSISSET_ATTRBIT(&tmpbits, NFSATTRBIT_ACL)) {
214 NFSCLRBIT_ATTRBIT(&tmpbits, NFSATTRBIT_ACL);
215 accmode |= VREAD_ACL;
217 if (NFSNONZERO_ATTRBIT(&tmpbits))
218 accmode |= VREAD_ATTRIBUTES;
220 nd->nd_repstat = nfsvno_accchk(vp, accmode,
221 nd->nd_cred, exp, p, NFSACCCHK_NOOVERRIDE,
222 NFSACCCHK_VPISLOCKED, NULL);
226 nd->nd_repstat = nfsvno_getattr(vp, &nva, nd->nd_cred, p, 1);
227 if (!nd->nd_repstat) {
228 if (nd->nd_flag & ND_NFSV4) {
229 if (NFSISSET_ATTRBIT(&attrbits, NFSATTRBIT_FILEHANDLE))
230 nd->nd_repstat = nfsvno_getfh(vp, &fh, p);
232 nd->nd_repstat = nfsrv_checkgetattr(nd, vp,
233 &nva, &attrbits, nd->nd_cred, p);
234 if (nd->nd_repstat == 0) {
235 supports_nfsv4acls = nfs_supportsnfsv4acls(vp);
237 if (nfsrv_enable_crossmntpt != 0 &&
238 vp->v_type == VDIR &&
239 (vp->v_vflag & VV_ROOT) != 0 &&
241 tvp = mp->mnt_vnodecovered;
249 if ((nd->nd_repstat =
250 NFSVOPLOCK(tvp, LK_SHARED)) == 0) {
251 nd->nd_repstat = VOP_GETATTR(
252 tvp, &va, nd->nd_cred);
256 if (nd->nd_repstat == 0)
257 mounted_on_fileno = (uint64_t)
262 if (nd->nd_repstat == 0)
263 nd->nd_repstat = vfs_busy(mp, 0);
265 if (nd->nd_repstat == 0) {
266 (void)nfsvno_fillattr(nd, mp, vp, &nva,
267 &fh, 0, &attrbits, nd->nd_cred, p,
268 isdgram, 1, supports_nfsv4acls,
269 at_root, mounted_on_fileno);
276 nfsrv_fillattr(nd, &nva);
284 NFSEXITCODE2(error, nd);
289 * nfs setattr service
292 nfsrvd_setattr(struct nfsrv_descript *nd, __unused int isdgram,
293 vnode_t vp, NFSPROC_T *p, struct nfsexstuff *exp)
295 struct nfsvattr nva, nva2;
297 int preat_ret = 1, postat_ret = 1, gcheck = 0, error = 0;
298 struct timespec guard = { 0, 0 };
299 nfsattrbit_t attrbits, retbits;
300 nfsv4stateid_t stateid;
301 NFSACL_T *aclp = NULL;
303 if (nd->nd_repstat) {
304 nfsrv_wcc(nd, preat_ret, &nva2, postat_ret, &nva);
307 #ifdef NFS4_ACL_EXTATTR_NAME
308 aclp = acl_alloc(M_WAITOK);
311 NFSVNO_ATTRINIT(&nva);
312 NFSZERO_ATTRBIT(&retbits);
313 if (nd->nd_flag & ND_NFSV4) {
314 NFSM_DISSECT(tl, u_int32_t *, NFSX_STATEID);
315 stateid.seqid = fxdr_unsigned(u_int32_t, *tl++);
316 NFSBCOPY((caddr_t)tl,(caddr_t)stateid.other,NFSX_STATEIDOTHER);
318 error = nfsrv_sattr(nd, &nva, &attrbits, aclp, p);
321 preat_ret = nfsvno_getattr(vp, &nva2, nd->nd_cred, p, 1);
323 nd->nd_repstat = preat_ret;
324 if (nd->nd_flag & ND_NFSV3) {
325 NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
326 gcheck = fxdr_unsigned(int, *tl);
328 NFSM_DISSECT(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
329 fxdr_nfsv3time(tl, &guard);
331 if (!nd->nd_repstat && gcheck &&
332 (nva2.na_ctime.tv_sec != guard.tv_sec ||
333 nva2.na_ctime.tv_nsec != guard.tv_nsec))
334 nd->nd_repstat = NFSERR_NOT_SYNC;
335 if (nd->nd_repstat) {
337 #ifdef NFS4_ACL_EXTATTR_NAME
340 nfsrv_wcc(nd, preat_ret, &nva2, postat_ret, &nva);
343 } else if (!nd->nd_repstat && (nd->nd_flag & ND_NFSV4))
344 nd->nd_repstat = nfsrv_checkuidgid(nd, &nva);
347 * Now that we have all the fields, lets do it.
348 * If the size is being changed write access is required, otherwise
349 * just check for a read only file system.
351 if (!nd->nd_repstat) {
352 if (NFSVNO_NOTSETSIZE(&nva)) {
353 if (NFSVNO_EXRDONLY(exp) ||
354 (vfs_flags(vnode_mount(vp)) & MNT_RDONLY))
355 nd->nd_repstat = EROFS;
357 if (vnode_vtype(vp) != VREG)
358 nd->nd_repstat = EINVAL;
359 else if (nva2.na_uid != nd->nd_cred->cr_uid ||
360 NFSVNO_EXSTRICTACCESS(exp))
361 nd->nd_repstat = nfsvno_accchk(vp,
362 VWRITE, nd->nd_cred, exp, p,
363 NFSACCCHK_NOOVERRIDE,
364 NFSACCCHK_VPISLOCKED, NULL);
367 if (!nd->nd_repstat && (nd->nd_flag & ND_NFSV4))
368 nd->nd_repstat = nfsrv_checksetattr(vp, nd, &stateid,
369 &nva, &attrbits, exp, p);
371 if (!nd->nd_repstat && (nd->nd_flag & ND_NFSV4)) {
373 * For V4, try setting the attrbutes in sets, so that the
374 * reply bitmap will be correct for an error case.
376 if (NFSISSET_ATTRBIT(&attrbits, NFSATTRBIT_OWNER) ||
377 NFSISSET_ATTRBIT(&attrbits, NFSATTRBIT_OWNERGROUP)) {
378 NFSVNO_ATTRINIT(&nva2);
379 NFSVNO_SETATTRVAL(&nva2, uid, nva.na_uid);
380 NFSVNO_SETATTRVAL(&nva2, gid, nva.na_gid);
381 nd->nd_repstat = nfsvno_setattr(vp, &nva2, nd->nd_cred, p,
383 if (!nd->nd_repstat) {
384 if (NFSISSET_ATTRBIT(&attrbits, NFSATTRBIT_OWNER))
385 NFSSETBIT_ATTRBIT(&retbits, NFSATTRBIT_OWNER);
386 if (NFSISSET_ATTRBIT(&attrbits, NFSATTRBIT_OWNERGROUP))
387 NFSSETBIT_ATTRBIT(&retbits, NFSATTRBIT_OWNERGROUP);
390 if (!nd->nd_repstat &&
391 NFSISSET_ATTRBIT(&attrbits, NFSATTRBIT_SIZE)) {
392 NFSVNO_ATTRINIT(&nva2);
393 NFSVNO_SETATTRVAL(&nva2, size, nva.na_size);
394 nd->nd_repstat = nfsvno_setattr(vp, &nva2, nd->nd_cred, p,
397 NFSSETBIT_ATTRBIT(&retbits, NFSATTRBIT_SIZE);
399 if (!nd->nd_repstat &&
400 (NFSISSET_ATTRBIT(&attrbits, NFSATTRBIT_TIMEACCESSSET) ||
401 NFSISSET_ATTRBIT(&attrbits, NFSATTRBIT_TIMEMODIFYSET))) {
402 NFSVNO_ATTRINIT(&nva2);
403 NFSVNO_SETATTRVAL(&nva2, atime, nva.na_atime);
404 NFSVNO_SETATTRVAL(&nva2, mtime, nva.na_mtime);
405 if (nva.na_vaflags & VA_UTIMES_NULL) {
406 nva2.na_vaflags |= VA_UTIMES_NULL;
407 NFSVNO_SETACTIVE(&nva2, vaflags);
409 nd->nd_repstat = nfsvno_setattr(vp, &nva2, nd->nd_cred, p,
411 if (!nd->nd_repstat) {
412 if (NFSISSET_ATTRBIT(&attrbits, NFSATTRBIT_TIMEACCESSSET))
413 NFSSETBIT_ATTRBIT(&retbits, NFSATTRBIT_TIMEACCESSSET);
414 if (NFSISSET_ATTRBIT(&attrbits, NFSATTRBIT_TIMEMODIFYSET))
415 NFSSETBIT_ATTRBIT(&retbits, NFSATTRBIT_TIMEMODIFYSET);
418 if (!nd->nd_repstat &&
419 NFSISSET_ATTRBIT(&attrbits, NFSATTRBIT_MODE)) {
420 NFSVNO_ATTRINIT(&nva2);
421 NFSVNO_SETATTRVAL(&nva2, mode, nva.na_mode);
422 nd->nd_repstat = nfsvno_setattr(vp, &nva2, nd->nd_cred, p,
425 NFSSETBIT_ATTRBIT(&retbits, NFSATTRBIT_MODE);
428 #ifdef NFS4_ACL_EXTATTR_NAME
429 if (!nd->nd_repstat && aclp->acl_cnt > 0 &&
430 NFSISSET_ATTRBIT(&attrbits, NFSATTRBIT_ACL)) {
431 nd->nd_repstat = nfsrv_setacl(vp, aclp, nd->nd_cred, p);
433 NFSSETBIT_ATTRBIT(&retbits, NFSATTRBIT_ACL);
436 } else if (!nd->nd_repstat) {
437 nd->nd_repstat = nfsvno_setattr(vp, &nva, nd->nd_cred, p,
440 if (nd->nd_flag & (ND_NFSV2 | ND_NFSV3)) {
441 postat_ret = nfsvno_getattr(vp, &nva, nd->nd_cred, p, 1);
443 nd->nd_repstat = postat_ret;
446 #ifdef NFS4_ACL_EXTATTR_NAME
449 if (nd->nd_flag & ND_NFSV3)
450 nfsrv_wcc(nd, preat_ret, &nva2, postat_ret, &nva);
451 else if (nd->nd_flag & ND_NFSV4)
452 (void) nfsrv_putattrbit(nd, &retbits);
453 else if (!nd->nd_repstat)
454 nfsrv_fillattr(nd, &nva);
461 #ifdef NFS4_ACL_EXTATTR_NAME
464 if (nd->nd_flag & ND_NFSV4) {
466 * For all nd_repstat, the V4 reply includes a bitmap,
467 * even NFSERR_BADXDR, which is what this will end up
470 (void) nfsrv_putattrbit(nd, &retbits);
472 NFSEXITCODE2(error, nd);
478 * (Also performs lookup parent for v4)
481 nfsrvd_lookup(struct nfsrv_descript *nd, __unused int isdgram,
482 vnode_t dp, vnode_t *vpp, fhandle_t *fhp, NFSPROC_T *p,
483 struct nfsexstuff *exp)
485 struct nameidata named;
486 vnode_t vp, dirp = NULL;
487 int error = 0, dattr_ret = 1;
488 struct nfsvattr nva, dattr;
492 if (nd->nd_repstat) {
493 nfsrv_postopattr(nd, dattr_ret, &dattr);
498 * For some reason, if dp is a symlink, the error
499 * returned is supposed to be NFSERR_SYMLINK and not NFSERR_NOTDIR.
501 if (dp->v_type == VLNK && (nd->nd_flag & ND_NFSV4)) {
502 nd->nd_repstat = NFSERR_SYMLINK;
507 NFSNAMEICNDSET(&named.ni_cnd, nd->nd_cred, LOOKUP,
508 LOCKLEAF | SAVESTART);
509 nfsvno_setpathbuf(&named, &bufp, &hashp);
510 error = nfsrv_parsename(nd, bufp, hashp, &named.ni_pathlen);
513 nfsvno_relpathbuf(&named);
516 if (!nd->nd_repstat) {
517 nd->nd_repstat = nfsvno_namei(nd, &named, dp, 0, exp, p, &dirp);
520 nfsvno_relpathbuf(&named);
522 if (nd->nd_repstat) {
524 if (nd->nd_flag & ND_NFSV3)
525 dattr_ret = nfsvno_getattr(dirp, &dattr,
529 if (nd->nd_flag & ND_NFSV3)
530 nfsrv_postopattr(nd, dattr_ret, &dattr);
533 if (named.ni_startdir)
534 vrele(named.ni_startdir);
535 nfsvno_relpathbuf(&named);
537 if ((nd->nd_flag & ND_NFSV4) != 0 && !NFSVNO_EXPORTED(exp) &&
538 vp->v_type != VDIR && vp->v_type != VLNK)
540 * Only allow lookup of VDIR and VLNK for traversal of
541 * non-exported volumes during NFSv4 mounting.
543 nd->nd_repstat = ENOENT;
544 if (nd->nd_repstat == 0)
545 nd->nd_repstat = nfsvno_getfh(vp, fhp, p);
546 if (!(nd->nd_flag & ND_NFSV4) && !nd->nd_repstat)
547 nd->nd_repstat = nfsvno_getattr(vp, &nva, nd->nd_cred, p, 1);
548 if (vpp != NULL && nd->nd_repstat == 0)
553 if (nd->nd_flag & ND_NFSV3)
554 dattr_ret = nfsvno_getattr(dirp, &dattr, nd->nd_cred,
558 if (nd->nd_repstat) {
559 if (nd->nd_flag & ND_NFSV3)
560 nfsrv_postopattr(nd, dattr_ret, &dattr);
563 if (nd->nd_flag & ND_NFSV2) {
564 (void) nfsm_fhtom(nd, (u_int8_t *)fhp, 0, 0);
565 nfsrv_fillattr(nd, &nva);
566 } else if (nd->nd_flag & ND_NFSV3) {
567 (void) nfsm_fhtom(nd, (u_int8_t *)fhp, 0, 0);
568 nfsrv_postopattr(nd, 0, &nva);
569 nfsrv_postopattr(nd, dattr_ret, &dattr);
573 NFSEXITCODE2(error, nd);
578 * nfs readlink service
581 nfsrvd_readlink(struct nfsrv_descript *nd, __unused int isdgram,
582 vnode_t vp, NFSPROC_T *p, __unused struct nfsexstuff *exp)
585 mbuf_t mp = NULL, mpend = NULL;
589 if (nd->nd_repstat) {
590 nfsrv_postopattr(nd, getret, &nva);
593 if (vnode_vtype(vp) != VLNK) {
594 if (nd->nd_flag & ND_NFSV2)
595 nd->nd_repstat = ENXIO;
597 nd->nd_repstat = EINVAL;
600 nd->nd_repstat = nfsvno_readlink(vp, nd->nd_cred, p,
602 if (nd->nd_flag & ND_NFSV3)
603 getret = nfsvno_getattr(vp, &nva, nd->nd_cred, p, 1);
605 if (nd->nd_flag & ND_NFSV3)
606 nfsrv_postopattr(nd, getret, &nva);
609 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
610 *tl = txdr_unsigned(len);
611 mbuf_setnext(nd->nd_mb, mp);
613 nd->nd_bpos = NFSMTOD(mpend, caddr_t) + mbuf_len(mpend);
624 nfsrvd_read(struct nfsrv_descript *nd, __unused int isdgram,
625 vnode_t vp, NFSPROC_T *p, struct nfsexstuff *exp)
628 int error = 0, cnt, getret = 1, reqlen, eof = 0;
632 struct nfsstate st, *stp = &st;
633 struct nfslock lo, *lop = &lo;
634 nfsv4stateid_t stateid;
637 if (nd->nd_repstat) {
638 nfsrv_postopattr(nd, getret, &nva);
641 if (nd->nd_flag & ND_NFSV2) {
642 NFSM_DISSECT(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
643 off = (off_t)fxdr_unsigned(u_int32_t, *tl++);
644 reqlen = fxdr_unsigned(int, *tl);
645 } else if (nd->nd_flag & ND_NFSV3) {
646 NFSM_DISSECT(tl, u_int32_t *, 3 * NFSX_UNSIGNED);
647 off = fxdr_hyper(tl);
649 reqlen = fxdr_unsigned(int, *tl);
651 NFSM_DISSECT(tl, u_int32_t *, NFSX_STATEID + 3*NFSX_UNSIGNED);
652 reqlen = fxdr_unsigned(int, *(tl + 6));
654 if (reqlen > NFS_SRVMAXDATA(nd)) {
655 reqlen = NFS_SRVMAXDATA(nd);
656 } else if (reqlen < 0) {
660 if (nd->nd_flag & ND_NFSV4) {
661 stp->ls_flags = (NFSLCK_CHECK | NFSLCK_READACCESS);
662 lop->lo_flags = NFSLCK_READ;
663 stp->ls_ownerlen = 0;
665 stp->ls_uid = nd->nd_cred->cr_uid;
666 stp->ls_stateid.seqid = fxdr_unsigned(u_int32_t, *tl++);
667 clientid.lval[0] = stp->ls_stateid.other[0] = *tl++;
668 clientid.lval[1] = stp->ls_stateid.other[1] = *tl++;
669 if (nd->nd_flag & ND_IMPLIEDCLID) {
670 if (nd->nd_clientid.qval != clientid.qval)
671 printf("EEK! multiple clids\n");
673 nd->nd_flag |= ND_IMPLIEDCLID;
674 nd->nd_clientid.qval = clientid.qval;
676 stp->ls_stateid.other[2] = *tl++;
677 off = fxdr_hyper(tl);
680 lop->lo_end = off + reqlen;
682 * Paranoia, just in case it wraps around.
684 if (lop->lo_end < off)
685 lop->lo_end = NFS64BITSSET;
687 if (vnode_vtype(vp) != VREG) {
688 if (nd->nd_flag & ND_NFSV3)
689 nd->nd_repstat = EINVAL;
691 nd->nd_repstat = (vnode_vtype(vp) == VDIR) ? EISDIR :
694 getret = nfsvno_getattr(vp, &nva, nd->nd_cred, p, 1);
696 nd->nd_repstat = getret;
697 if (!nd->nd_repstat &&
698 (nva.na_uid != nd->nd_cred->cr_uid ||
699 NFSVNO_EXSTRICTACCESS(exp))) {
700 nd->nd_repstat = nfsvno_accchk(vp, VREAD,
702 NFSACCCHK_ALLOWOWNER, NFSACCCHK_VPISLOCKED, NULL);
704 nd->nd_repstat = nfsvno_accchk(vp, VEXEC,
705 nd->nd_cred, exp, p, NFSACCCHK_ALLOWOWNER,
706 NFSACCCHK_VPISLOCKED, NULL);
708 if ((nd->nd_flag & ND_NFSV4) && !nd->nd_repstat)
709 nd->nd_repstat = nfsrv_lockctrl(vp, &stp, &lop, NULL, clientid,
710 &stateid, exp, nd, p);
711 if (nd->nd_repstat) {
713 if (nd->nd_flag & ND_NFSV3)
714 nfsrv_postopattr(nd, getret, &nva);
717 if (off >= nva.na_size) {
720 } else if (reqlen == 0)
722 else if ((off + reqlen) >= nva.na_size) {
723 cnt = nva.na_size - off;
729 nd->nd_repstat = nfsvno_read(vp, off, cnt, nd->nd_cred, p,
731 if (!(nd->nd_flag & ND_NFSV4)) {
732 getret = nfsvno_getattr(vp, &nva, nd->nd_cred, p, 1);
734 nd->nd_repstat = getret;
736 if (nd->nd_repstat) {
740 if (nd->nd_flag & ND_NFSV3)
741 nfsrv_postopattr(nd, getret, &nva);
746 if (nd->nd_flag & ND_NFSV2) {
747 nfsrv_fillattr(nd, &nva);
748 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
750 if (nd->nd_flag & ND_NFSV3) {
751 nfsrv_postopattr(nd, getret, &nva);
752 NFSM_BUILD(tl, u_int32_t *, 3 * NFSX_UNSIGNED);
753 *tl++ = txdr_unsigned(cnt);
755 NFSM_BUILD(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
759 *tl++ = newnfs_false;
761 *tl = txdr_unsigned(cnt);
763 mbuf_setnext(nd->nd_mb, m3);
765 nd->nd_bpos = NFSMTOD(m2, caddr_t) + mbuf_len(m2);
773 NFSEXITCODE2(error, nd);
781 nfsrvd_write(struct nfsrv_descript *nd, __unused int isdgram,
782 vnode_t vp, NFSPROC_T *p, struct nfsexstuff *exp)
787 struct nfsvattr nva, forat;
788 int aftat_ret = 1, retlen, len, error = 0, forat_ret = 1;
789 int stable = NFSWRITE_FILESYNC;
791 struct nfsstate st, *stp = &st;
792 struct nfslock lo, *lop = &lo;
793 nfsv4stateid_t stateid;
796 if (nd->nd_repstat) {
797 nfsrv_wcc(nd, forat_ret, &forat, aftat_ret, &nva);
800 if (nd->nd_flag & ND_NFSV2) {
801 NFSM_DISSECT(tl, u_int32_t *, 4 * NFSX_UNSIGNED);
802 off = (off_t)fxdr_unsigned(u_int32_t, *++tl);
804 retlen = len = fxdr_unsigned(int32_t, *tl);
805 } else if (nd->nd_flag & ND_NFSV3) {
806 NFSM_DISSECT(tl, u_int32_t *, 5 * NFSX_UNSIGNED);
807 off = fxdr_hyper(tl);
809 stable = fxdr_unsigned(int, *tl++);
810 retlen = len = fxdr_unsigned(int32_t, *tl);
812 NFSM_DISSECT(tl, u_int32_t *, NFSX_STATEID + 4 * NFSX_UNSIGNED);
813 stp->ls_flags = (NFSLCK_CHECK | NFSLCK_WRITEACCESS);
814 lop->lo_flags = NFSLCK_WRITE;
815 stp->ls_ownerlen = 0;
817 stp->ls_uid = nd->nd_cred->cr_uid;
818 stp->ls_stateid.seqid = fxdr_unsigned(u_int32_t, *tl++);
819 clientid.lval[0] = stp->ls_stateid.other[0] = *tl++;
820 clientid.lval[1] = stp->ls_stateid.other[1] = *tl++;
821 if (nd->nd_flag & ND_IMPLIEDCLID) {
822 if (nd->nd_clientid.qval != clientid.qval)
823 printf("EEK! multiple clids\n");
825 nd->nd_flag |= ND_IMPLIEDCLID;
826 nd->nd_clientid.qval = clientid.qval;
828 stp->ls_stateid.other[2] = *tl++;
829 off = fxdr_hyper(tl);
832 stable = fxdr_unsigned(int, *tl++);
833 retlen = len = fxdr_unsigned(int32_t, *tl);
834 lop->lo_end = off + len;
836 * Paranoia, just in case it wraps around, which shouldn't
837 * ever happen anyhow.
839 if (lop->lo_end < lop->lo_first)
840 lop->lo_end = NFS64BITSSET;
844 * Loop through the mbuf chain, counting how many mbufs are a
845 * part of this write operation, so the iovec size is known.
849 i = NFSMTOD(mp, caddr_t) + mbuf_len(mp) - nd->nd_dpos;
865 if (retlen > NFS_MAXDATA || retlen < 0)
866 nd->nd_repstat = EIO;
867 if (vnode_vtype(vp) != VREG && !nd->nd_repstat) {
868 if (nd->nd_flag & ND_NFSV3)
869 nd->nd_repstat = EINVAL;
871 nd->nd_repstat = (vnode_vtype(vp) == VDIR) ? EISDIR :
874 forat_ret = nfsvno_getattr(vp, &forat, nd->nd_cred, p, 1);
876 nd->nd_repstat = forat_ret;
877 if (!nd->nd_repstat &&
878 (forat.na_uid != nd->nd_cred->cr_uid ||
879 NFSVNO_EXSTRICTACCESS(exp)))
880 nd->nd_repstat = nfsvno_accchk(vp, VWRITE,
882 NFSACCCHK_ALLOWOWNER, NFSACCCHK_VPISLOCKED, NULL);
883 if ((nd->nd_flag & ND_NFSV4) && !nd->nd_repstat) {
884 nd->nd_repstat = nfsrv_lockctrl(vp, &stp, &lop, NULL, clientid,
885 &stateid, exp, nd, p);
887 if (nd->nd_repstat) {
889 if (nd->nd_flag & ND_NFSV3)
890 nfsrv_wcc(nd, forat_ret, &forat, aftat_ret, &nva);
895 * For NFS Version 2, it is not obvious what a write of zero length
896 * should do, but I might as well be consistent with Version 3,
897 * which is to return ok so long as there are no permission problems.
900 nd->nd_repstat = nfsvno_write(vp, off, retlen, cnt, stable,
901 nd->nd_md, nd->nd_dpos, nd->nd_cred, p);
902 error = nfsm_advance(nd, NFSM_RNDUP(retlen), -1);
904 panic("nfsrv_write mbuf");
906 if (nd->nd_flag & ND_NFSV4)
909 aftat_ret = nfsvno_getattr(vp, &nva, nd->nd_cred, p, 1);
912 nd->nd_repstat = aftat_ret;
913 if (nd->nd_flag & (ND_NFSV3 | ND_NFSV4)) {
914 if (nd->nd_flag & ND_NFSV3)
915 nfsrv_wcc(nd, forat_ret, &forat, aftat_ret, &nva);
918 NFSM_BUILD(tl, u_int32_t *, 4 * NFSX_UNSIGNED);
919 *tl++ = txdr_unsigned(retlen);
921 * If nfs_async is set, then pretend the write was FILESYNC.
922 * Warning: Doing this violates RFC1813 and runs a risk
923 * of data written by a client being lost when the server
926 if (stable == NFSWRITE_UNSTABLE && nfs_async == 0)
927 *tl++ = txdr_unsigned(stable);
929 *tl++ = txdr_unsigned(NFSWRITE_FILESYNC);
931 * Actually, there is no need to txdr these fields,
932 * but it may make the values more human readable,
933 * for debugging purposes.
935 *tl++ = txdr_unsigned(nfsboottime.tv_sec);
936 *tl = txdr_unsigned(nfsboottime.tv_usec);
937 } else if (!nd->nd_repstat)
938 nfsrv_fillattr(nd, &nva);
945 NFSEXITCODE2(error, nd);
950 * nfs create service (creates regular files for V2 and V3. Spec. files for V2.)
951 * now does a truncate to 0 length via. setattr if it already exists
952 * The core creation routine has been extracted out into nfsrv_creatsub(),
953 * so it can also be used by nfsrv_open() for V4.
956 nfsrvd_create(struct nfsrv_descript *nd, __unused int isdgram,
957 vnode_t dp, NFSPROC_T *p, struct nfsexstuff *exp)
959 struct nfsvattr nva, dirfor, diraft;
960 struct nfsv2_sattr *sp;
961 struct nameidata named;
963 int error = 0, tsize, dirfor_ret = 1, diraft_ret = 1;
964 int how = NFSCREATE_UNCHECKED, exclusive_flag = 0;
966 vnode_t vp = NULL, dirp = NULL;
971 int32_t cverf[2], tverf[2] = { 0, 0 };
973 if (nd->nd_repstat) {
974 nfsrv_wcc(nd, dirfor_ret, &dirfor, diraft_ret, &diraft);
977 NFSNAMEICNDSET(&named.ni_cnd, nd->nd_cred, CREATE,
978 LOCKPARENT | LOCKLEAF | SAVESTART);
979 nfsvno_setpathbuf(&named, &bufp, &hashp);
980 error = nfsrv_parsename(nd, bufp, hashp, &named.ni_pathlen);
983 if (!nd->nd_repstat) {
984 NFSVNO_ATTRINIT(&nva);
985 if (nd->nd_flag & ND_NFSV2) {
986 NFSM_DISSECT(sp, struct nfsv2_sattr *, NFSX_V2SATTR);
987 vtyp = IFTOVT(fxdr_unsigned(u_int32_t, sp->sa_mode));
990 NFSVNO_SETATTRVAL(&nva, type, vtyp);
991 NFSVNO_SETATTRVAL(&nva, mode,
992 nfstov_mode(sp->sa_mode));
993 switch (nva.na_type) {
995 tsize = fxdr_unsigned(int32_t, sp->sa_size);
997 NFSVNO_SETATTRVAL(&nva, size,
1003 rdev = fxdr_unsigned(NFSDEV_T, sp->sa_size);
1009 NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
1010 how = fxdr_unsigned(int, *tl);
1012 case NFSCREATE_GUARDED:
1013 case NFSCREATE_UNCHECKED:
1014 error = nfsrv_sattr(nd, &nva, NULL, NULL, p);
1018 case NFSCREATE_EXCLUSIVE:
1019 NFSM_DISSECT(tl, u_int32_t *, NFSX_VERF);
1025 NFSVNO_SETATTRVAL(&nva, type, VREG);
1028 if (nd->nd_repstat) {
1029 nfsvno_relpathbuf(&named);
1030 if (nd->nd_flag & ND_NFSV3) {
1031 dirfor_ret = nfsvno_getattr(dp, &dirfor, nd->nd_cred,
1033 nfsrv_wcc(nd, dirfor_ret, &dirfor, diraft_ret,
1040 nd->nd_repstat = nfsvno_namei(nd, &named, dp, 1, exp, p, &dirp);
1042 if (nd->nd_flag & ND_NFSV2) {
1046 dirfor_ret = nfsvno_getattr(dirp, &dirfor, nd->nd_cred,
1050 if (nd->nd_repstat) {
1051 if (nd->nd_flag & ND_NFSV3)
1052 nfsrv_wcc(nd, dirfor_ret, &dirfor, diraft_ret,
1059 if (!(nd->nd_flag & ND_NFSV2)) {
1061 case NFSCREATE_GUARDED:
1063 nd->nd_repstat = EEXIST;
1065 case NFSCREATE_UNCHECKED:
1067 case NFSCREATE_EXCLUSIVE:
1068 if (named.ni_vp == NULL)
1069 NFSVNO_SETATTRVAL(&nva, mode, 0);
1075 * Iff doesn't exist, create it
1076 * otherwise just truncate to 0 length
1077 * should I set the mode too ?
1079 nd->nd_repstat = nfsvno_createsub(nd, &named, &vp, &nva,
1080 &exclusive_flag, cverf, rdev, p, exp);
1082 if (!nd->nd_repstat) {
1083 nd->nd_repstat = nfsvno_getfh(vp, &fh, p);
1084 if (!nd->nd_repstat)
1085 nd->nd_repstat = nfsvno_getattr(vp, &nva, nd->nd_cred,
1088 if (!nd->nd_repstat) {
1089 tverf[0] = nva.na_atime.tv_sec;
1090 tverf[1] = nva.na_atime.tv_nsec;
1093 if (nd->nd_flag & ND_NFSV2) {
1094 if (!nd->nd_repstat) {
1095 (void) nfsm_fhtom(nd, (u_int8_t *)&fh, 0, 0);
1096 nfsrv_fillattr(nd, &nva);
1099 if (exclusive_flag && !nd->nd_repstat && (cverf[0] != tverf[0]
1100 || cverf[1] != tverf[1]))
1101 nd->nd_repstat = EEXIST;
1102 diraft_ret = nfsvno_getattr(dirp, &diraft, nd->nd_cred, p, 0);
1104 if (!nd->nd_repstat) {
1105 (void) nfsm_fhtom(nd, (u_int8_t *)&fh, 0, 1);
1106 nfsrv_postopattr(nd, 0, &nva);
1108 nfsrv_wcc(nd, dirfor_ret, &dirfor, diraft_ret, &diraft);
1112 NFSEXITCODE2(0, nd);
1116 nfsvno_relpathbuf(&named);
1117 NFSEXITCODE2(error, nd);
1122 * nfs v3 mknod service (and v4 create)
1125 nfsrvd_mknod(struct nfsrv_descript *nd, __unused int isdgram,
1126 vnode_t dp, vnode_t *vpp, fhandle_t *fhp, NFSPROC_T *p,
1127 struct nfsexstuff *exp)
1129 struct nfsvattr nva, dirfor, diraft;
1131 struct nameidata named;
1132 int error = 0, dirfor_ret = 1, diraft_ret = 1, pathlen;
1133 u_int32_t major, minor;
1134 enum vtype vtyp = VNON;
1135 nfstype nfs4type = NFNON;
1136 vnode_t vp, dirp = NULL;
1137 nfsattrbit_t attrbits;
1138 char *bufp = NULL, *pathcp = NULL;
1139 u_long *hashp, cnflags;
1140 NFSACL_T *aclp = NULL;
1142 NFSVNO_ATTRINIT(&nva);
1143 cnflags = (LOCKPARENT | SAVESTART);
1144 if (nd->nd_repstat) {
1145 nfsrv_wcc(nd, dirfor_ret, &dirfor, diraft_ret, &diraft);
1148 #ifdef NFS4_ACL_EXTATTR_NAME
1149 aclp = acl_alloc(M_WAITOK);
1154 * For V4, the creation stuff is here, Yuck!
1156 if (nd->nd_flag & ND_NFSV4) {
1157 NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
1158 vtyp = nfsv34tov_type(*tl);
1159 nfs4type = fxdr_unsigned(nfstype, *tl);
1162 error = nfsvno_getsymlink(nd, &nva, p, &pathcp,
1169 NFSM_DISSECT(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
1170 major = fxdr_unsigned(u_int32_t, *tl++);
1171 minor = fxdr_unsigned(u_int32_t, *tl);
1172 nva.na_rdev = NFSMAKEDEV(major, minor);
1178 cnflags = (LOCKPARENT | SAVENAME);
1181 nd->nd_repstat = NFSERR_BADTYPE;
1183 #ifdef NFS4_ACL_EXTATTR_NAME
1189 NFSNAMEICNDSET(&named.ni_cnd, nd->nd_cred, CREATE, cnflags);
1190 nfsvno_setpathbuf(&named, &bufp, &hashp);
1191 error = nfsrv_parsename(nd, bufp, hashp, &named.ni_pathlen);
1194 if (!nd->nd_repstat) {
1195 if (nd->nd_flag & ND_NFSV3) {
1196 NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
1197 vtyp = nfsv34tov_type(*tl);
1199 error = nfsrv_sattr(nd, &nva, &attrbits, aclp, p);
1203 if (!nd->nd_repstat && (nd->nd_flag & ND_NFSV3) &&
1204 (vtyp == VCHR || vtyp == VBLK)) {
1205 NFSM_DISSECT(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
1206 major = fxdr_unsigned(u_int32_t, *tl++);
1207 minor = fxdr_unsigned(u_int32_t, *tl);
1208 nva.na_rdev = NFSMAKEDEV(major, minor);
1212 dirfor_ret = nfsvno_getattr(dp, &dirfor, nd->nd_cred, p, 0);
1213 if (!nd->nd_repstat && (nd->nd_flag & ND_NFSV4)) {
1214 if (!dirfor_ret && NFSVNO_ISSETGID(&nva) &&
1215 dirfor.na_gid == nva.na_gid)
1216 NFSVNO_UNSET(&nva, gid);
1217 nd->nd_repstat = nfsrv_checkuidgid(nd, &nva);
1219 if (nd->nd_repstat) {
1221 #ifdef NFS4_ACL_EXTATTR_NAME
1224 nfsvno_relpathbuf(&named);
1226 FREE(pathcp, M_TEMP);
1227 if (nd->nd_flag & ND_NFSV3)
1228 nfsrv_wcc(nd, dirfor_ret, &dirfor, diraft_ret,
1234 * Yuck! For V4, mkdir and link are here and some V4 clients don't fill
1235 * in va_mode, so we'll have to set a default here.
1237 if (NFSVNO_NOTSETMODE(&nva)) {
1245 named.ni_cnd.cn_flags |= WILLBEDIR;
1246 nd->nd_repstat = nfsvno_namei(nd, &named, dp, 0, exp, p, &dirp);
1247 if (nd->nd_repstat) {
1249 if (nd->nd_flag & ND_NFSV3)
1250 dirfor_ret = nfsvno_getattr(dirp, &dirfor,
1254 #ifdef NFS4_ACL_EXTATTR_NAME
1257 if (nd->nd_flag & ND_NFSV3)
1258 nfsrv_wcc(nd, dirfor_ret, &dirfor, diraft_ret,
1263 dirfor_ret = nfsvno_getattr(dirp, &dirfor, nd->nd_cred, p, 0);
1265 if ((nd->nd_flag & ND_NFSV4) && (vtyp == VDIR || vtyp == VLNK)) {
1267 nfsrvd_mkdirsub(nd, &named, &nva, fhp, vpp, dirp,
1268 &dirfor, &diraft, &diraft_ret, &attrbits, aclp, p,
1270 #ifdef NFS4_ACL_EXTATTR_NAME
1274 } else if (vtyp == VLNK) {
1275 nfsrvd_symlinksub(nd, &named, &nva, fhp, vpp, dirp,
1276 &dirfor, &diraft, &diraft_ret, &attrbits,
1277 aclp, p, exp, pathcp, pathlen);
1278 #ifdef NFS4_ACL_EXTATTR_NAME
1281 FREE(pathcp, M_TEMP);
1286 nd->nd_repstat = nfsvno_mknod(&named, &nva, nd->nd_cred, p);
1287 if (!nd->nd_repstat) {
1289 nfsrv_fixattr(nd, vp, &nva, aclp, p, &attrbits, exp);
1290 nd->nd_repstat = nfsvno_getfh(vp, fhp, p);
1291 if ((nd->nd_flag & ND_NFSV3) && !nd->nd_repstat)
1292 nd->nd_repstat = nfsvno_getattr(vp, &nva, nd->nd_cred,
1294 if (vpp != NULL && nd->nd_repstat == 0) {
1295 NFSVOPUNLOCK(vp, 0);
1301 diraft_ret = nfsvno_getattr(dirp, &diraft, nd->nd_cred, p, 0);
1303 if (!nd->nd_repstat) {
1304 if (nd->nd_flag & ND_NFSV3) {
1305 (void) nfsm_fhtom(nd, (u_int8_t *)fhp, 0, 1);
1306 nfsrv_postopattr(nd, 0, &nva);
1308 NFSM_BUILD(tl, u_int32_t *, 5 * NFSX_UNSIGNED);
1309 *tl++ = newnfs_false;
1310 txdr_hyper(dirfor.na_filerev, tl);
1312 txdr_hyper(diraft.na_filerev, tl);
1313 (void) nfsrv_putattrbit(nd, &attrbits);
1316 if (nd->nd_flag & ND_NFSV3)
1317 nfsrv_wcc(nd, dirfor_ret, &dirfor, diraft_ret, &diraft);
1318 #ifdef NFS4_ACL_EXTATTR_NAME
1323 NFSEXITCODE2(0, nd);
1327 #ifdef NFS4_ACL_EXTATTR_NAME
1331 nfsvno_relpathbuf(&named);
1333 FREE(pathcp, M_TEMP);
1335 NFSEXITCODE2(error, nd);
1340 * nfs remove service
1343 nfsrvd_remove(struct nfsrv_descript *nd, __unused int isdgram,
1344 vnode_t dp, NFSPROC_T *p, struct nfsexstuff *exp)
1346 struct nameidata named;
1348 int error = 0, dirfor_ret = 1, diraft_ret = 1;
1349 vnode_t dirp = NULL;
1350 struct nfsvattr dirfor, diraft;
1354 if (nd->nd_repstat) {
1355 nfsrv_wcc(nd, dirfor_ret, &dirfor, diraft_ret, &diraft);
1358 NFSNAMEICNDSET(&named.ni_cnd, nd->nd_cred, DELETE,
1359 LOCKPARENT | LOCKLEAF);
1360 nfsvno_setpathbuf(&named, &bufp, &hashp);
1361 error = nfsrv_parsename(nd, bufp, hashp, &named.ni_pathlen);
1364 nfsvno_relpathbuf(&named);
1367 if (!nd->nd_repstat) {
1368 nd->nd_repstat = nfsvno_namei(nd, &named, dp, 1, exp, p, &dirp);
1371 nfsvno_relpathbuf(&named);
1374 if (!(nd->nd_flag & ND_NFSV2)) {
1375 dirfor_ret = nfsvno_getattr(dirp, &dirfor,
1382 if (!nd->nd_repstat) {
1383 if (nd->nd_flag & ND_NFSV4) {
1384 if (vnode_vtype(named.ni_vp) == VDIR)
1385 nd->nd_repstat = nfsvno_rmdirsub(&named, 1,
1386 nd->nd_cred, p, exp);
1388 nd->nd_repstat = nfsvno_removesub(&named, 1,
1389 nd->nd_cred, p, exp);
1390 } else if (nd->nd_procnum == NFSPROC_RMDIR) {
1391 nd->nd_repstat = nfsvno_rmdirsub(&named, 0,
1392 nd->nd_cred, p, exp);
1394 nd->nd_repstat = nfsvno_removesub(&named, 0,
1395 nd->nd_cred, p, exp);
1398 if (!(nd->nd_flag & ND_NFSV2)) {
1400 diraft_ret = nfsvno_getattr(dirp, &diraft, nd->nd_cred,
1404 if (nd->nd_flag & ND_NFSV3) {
1405 nfsrv_wcc(nd, dirfor_ret, &dirfor, diraft_ret,
1407 } else if (!nd->nd_repstat) {
1408 NFSM_BUILD(tl, u_int32_t *, 5 * NFSX_UNSIGNED);
1409 *tl++ = newnfs_false;
1410 txdr_hyper(dirfor.na_filerev, tl);
1412 txdr_hyper(diraft.na_filerev, tl);
1417 NFSEXITCODE2(error, nd);
1422 * nfs rename service
1425 nfsrvd_rename(struct nfsrv_descript *nd, int isdgram,
1426 vnode_t dp, vnode_t todp, NFSPROC_T *p, struct nfsexstuff *exp,
1427 struct nfsexstuff *toexp)
1430 int error = 0, fdirfor_ret = 1, fdiraft_ret = 1;
1431 int tdirfor_ret = 1, tdiraft_ret = 1;
1432 struct nameidata fromnd, tond;
1433 vnode_t fdirp = NULL, tdirp = NULL, tdp = NULL;
1434 struct nfsvattr fdirfor, fdiraft, tdirfor, tdiraft;
1435 struct nfsexstuff tnes;
1437 char *bufp, *tbufp = NULL;
1441 if (nd->nd_repstat) {
1442 nfsrv_wcc(nd, fdirfor_ret, &fdirfor, fdiraft_ret, &fdiraft);
1443 nfsrv_wcc(nd, tdirfor_ret, &tdirfor, tdiraft_ret, &tdiraft);
1446 if (!(nd->nd_flag & ND_NFSV2))
1447 fdirfor_ret = nfsvno_getattr(dp, &fdirfor, nd->nd_cred, p, 1);
1448 tond.ni_cnd.cn_nameiop = 0;
1449 tond.ni_startdir = NULL;
1450 NFSNAMEICNDSET(&fromnd.ni_cnd, nd->nd_cred, DELETE, WANTPARENT | SAVESTART);
1451 nfsvno_setpathbuf(&fromnd, &bufp, &hashp);
1452 error = nfsrv_parsename(nd, bufp, hashp, &fromnd.ni_pathlen);
1457 nfsvno_relpathbuf(&fromnd);
1461 * Unlock dp in this code section, so it is unlocked before
1462 * tdp gets locked. This avoids a potential LOR if tdp is the
1463 * parent directory of dp.
1465 if (nd->nd_flag & ND_NFSV4) {
1469 NFSVOPUNLOCK(dp, 0);
1470 tdirfor_ret = nfsvno_getattr(tdp, &tdirfor, nd->nd_cred,
1471 p, 0); /* Might lock tdp. */
1473 tdirfor_ret = nfsvno_getattr(tdp, &tdirfor, nd->nd_cred,
1475 NFSVOPUNLOCK(dp, 0);
1478 tfh.nfsrvfh_len = 0;
1479 error = nfsrv_mtofh(nd, &tfh);
1481 error = nfsvno_getfh(dp, &fh, p);
1484 /* todp is always NULL except NFSv4 */
1485 nfsvno_relpathbuf(&fromnd);
1489 /* If this is the same file handle, just VREF() the vnode. */
1490 if (tfh.nfsrvfh_len == NFSX_MYFH &&
1491 !NFSBCMP(tfh.nfsrvfh_data, &fh, NFSX_MYFH)) {
1495 tdirfor_ret = nfsvno_getattr(tdp, &tdirfor, nd->nd_cred,
1497 NFSVOPUNLOCK(dp, 0);
1499 NFSVOPUNLOCK(dp, 0);
1500 nd->nd_cred->cr_uid = nd->nd_saveduid;
1501 nfsd_fhtovp(nd, &tfh, LK_EXCLUSIVE, &tdp, &tnes, NULL,
1502 0, p); /* Locks tdp. */
1504 tdirfor_ret = nfsvno_getattr(tdp, &tdirfor,
1506 NFSVOPUNLOCK(tdp, 0);
1510 NFSNAMEICNDSET(&tond.ni_cnd, nd->nd_cred, RENAME, LOCKPARENT | LOCKLEAF | NOCACHE | SAVESTART);
1511 nfsvno_setpathbuf(&tond, &tbufp, &hashp);
1512 if (!nd->nd_repstat) {
1513 error = nfsrv_parsename(nd, tbufp, hashp, &tond.ni_pathlen);
1518 nfsvno_relpathbuf(&fromnd);
1519 nfsvno_relpathbuf(&tond);
1523 if (nd->nd_repstat) {
1524 if (nd->nd_flag & ND_NFSV3) {
1525 nfsrv_wcc(nd, fdirfor_ret, &fdirfor, fdiraft_ret,
1527 nfsrv_wcc(nd, tdirfor_ret, &tdirfor, tdiraft_ret,
1533 nfsvno_relpathbuf(&fromnd);
1534 nfsvno_relpathbuf(&tond);
1539 * Done parsing, now down to business.
1541 nd->nd_repstat = nfsvno_namei(nd, &fromnd, dp, 0, exp, p, &fdirp);
1542 if (nd->nd_repstat) {
1543 if (nd->nd_flag & ND_NFSV3) {
1544 nfsrv_wcc(nd, fdirfor_ret, &fdirfor, fdiraft_ret,
1546 nfsrv_wcc(nd, tdirfor_ret, &tdirfor, tdiraft_ret,
1553 nfsvno_relpathbuf(&tond);
1556 if (vnode_vtype(fromnd.ni_vp) == VDIR)
1557 tond.ni_cnd.cn_flags |= WILLBEDIR;
1558 nd->nd_repstat = nfsvno_namei(nd, &tond, tdp, 0, &tnes, p, &tdirp);
1559 nd->nd_repstat = nfsvno_rename(&fromnd, &tond, nd->nd_repstat,
1560 nd->nd_flag, nd->nd_cred, p);
1562 fdiraft_ret = nfsvno_getattr(fdirp, &fdiraft, nd->nd_cred, p,
1565 tdiraft_ret = nfsvno_getattr(tdirp, &tdiraft, nd->nd_cred, p,
1571 if (nd->nd_flag & ND_NFSV3) {
1572 nfsrv_wcc(nd, fdirfor_ret, &fdirfor, fdiraft_ret, &fdiraft);
1573 nfsrv_wcc(nd, tdirfor_ret, &tdirfor, tdiraft_ret, &tdiraft);
1574 } else if ((nd->nd_flag & ND_NFSV4) && !nd->nd_repstat) {
1575 NFSM_BUILD(tl, u_int32_t *, 10 * NFSX_UNSIGNED);
1576 *tl++ = newnfs_false;
1577 txdr_hyper(fdirfor.na_filerev, tl);
1579 txdr_hyper(fdiraft.na_filerev, tl);
1581 *tl++ = newnfs_false;
1582 txdr_hyper(tdirfor.na_filerev, tl);
1584 txdr_hyper(tdiraft.na_filerev, tl);
1588 NFSEXITCODE2(error, nd);
1596 nfsrvd_link(struct nfsrv_descript *nd, int isdgram,
1597 vnode_t vp, vnode_t tovp, NFSPROC_T *p, struct nfsexstuff *exp,
1598 struct nfsexstuff *toexp)
1600 struct nameidata named;
1602 int error = 0, dirfor_ret = 1, diraft_ret = 1, getret = 1;
1603 vnode_t dirp = NULL, dp = NULL;
1604 struct nfsvattr dirfor, diraft, at;
1605 struct nfsexstuff tnes;
1610 if (nd->nd_repstat) {
1611 nfsrv_postopattr(nd, getret, &at);
1612 nfsrv_wcc(nd, dirfor_ret, &dirfor, diraft_ret, &diraft);
1615 NFSVOPUNLOCK(vp, 0);
1616 if (vnode_vtype(vp) == VDIR) {
1617 if (nd->nd_flag & ND_NFSV4)
1618 nd->nd_repstat = NFSERR_ISDIR;
1620 nd->nd_repstat = NFSERR_INVAL;
1623 } else if (vnode_vtype(vp) == VLNK) {
1624 if (nd->nd_flag & ND_NFSV2)
1625 nd->nd_repstat = NFSERR_INVAL;
1627 nd->nd_repstat = NFSERR_NOTSUPP;
1631 if (!nd->nd_repstat) {
1632 if (nd->nd_flag & ND_NFSV4) {
1636 error = nfsrv_mtofh(nd, &dfh);
1639 /* tovp is always NULL unless NFSv4 */
1642 nfsd_fhtovp(nd, &dfh, LK_EXCLUSIVE, &dp, &tnes, NULL, 0,
1645 NFSVOPUNLOCK(dp, 0);
1648 NFSNAMEICNDSET(&named.ni_cnd, nd->nd_cred, CREATE,
1649 LOCKPARENT | SAVENAME);
1650 if (!nd->nd_repstat) {
1651 nfsvno_setpathbuf(&named, &bufp, &hashp);
1652 error = nfsrv_parsename(nd, bufp, hashp, &named.ni_pathlen);
1657 nfsvno_relpathbuf(&named);
1660 if (!nd->nd_repstat) {
1661 nd->nd_repstat = nfsvno_namei(nd, &named, dp, 0, &tnes,
1666 nfsvno_relpathbuf(&named);
1670 if (nd->nd_flag & ND_NFSV2) {
1674 dirfor_ret = nfsvno_getattr(dirp, &dirfor,
1678 if (!nd->nd_repstat)
1679 nd->nd_repstat = nfsvno_link(&named, vp, nd->nd_cred, p, exp);
1680 if (nd->nd_flag & ND_NFSV3)
1681 getret = nfsvno_getattr(vp, &at, nd->nd_cred, p, 0);
1683 diraft_ret = nfsvno_getattr(dirp, &diraft, nd->nd_cred, p, 0);
1687 if (nd->nd_flag & ND_NFSV3) {
1688 nfsrv_postopattr(nd, getret, &at);
1689 nfsrv_wcc(nd, dirfor_ret, &dirfor, diraft_ret, &diraft);
1690 } else if ((nd->nd_flag & ND_NFSV4) && !nd->nd_repstat) {
1691 NFSM_BUILD(tl, u_int32_t *, 5 * NFSX_UNSIGNED);
1692 *tl++ = newnfs_false;
1693 txdr_hyper(dirfor.na_filerev, tl);
1695 txdr_hyper(diraft.na_filerev, tl);
1699 NFSEXITCODE2(error, nd);
1704 * nfs symbolic link service
1707 nfsrvd_symlink(struct nfsrv_descript *nd, __unused int isdgram,
1708 vnode_t dp, vnode_t *vpp, fhandle_t *fhp, NFSPROC_T *p,
1709 struct nfsexstuff *exp)
1711 struct nfsvattr nva, dirfor, diraft;
1712 struct nameidata named;
1713 int error = 0, dirfor_ret = 1, diraft_ret = 1, pathlen;
1714 vnode_t dirp = NULL;
1715 char *bufp, *pathcp = NULL;
1718 if (nd->nd_repstat) {
1719 nfsrv_wcc(nd, dirfor_ret, &dirfor, diraft_ret, &diraft);
1724 NFSVNO_ATTRINIT(&nva);
1725 NFSNAMEICNDSET(&named.ni_cnd, nd->nd_cred, CREATE,
1726 LOCKPARENT | SAVESTART);
1727 nfsvno_setpathbuf(&named, &bufp, &hashp);
1728 error = nfsrv_parsename(nd, bufp, hashp, &named.ni_pathlen);
1729 if (!error && !nd->nd_repstat)
1730 error = nfsvno_getsymlink(nd, &nva, p, &pathcp, &pathlen);
1733 nfsvno_relpathbuf(&named);
1736 if (!nd->nd_repstat) {
1737 nd->nd_repstat = nfsvno_namei(nd, &named, dp, 0, exp, p, &dirp);
1740 nfsvno_relpathbuf(&named);
1742 if (dirp != NULL && !(nd->nd_flag & ND_NFSV3)) {
1748 * And call nfsrvd_symlinksub() to do the common code. It will
1749 * return EBADRPC upon a parsing error, 0 otherwise.
1751 if (!nd->nd_repstat) {
1753 dirfor_ret = nfsvno_getattr(dirp, &dirfor, nd->nd_cred,
1755 nfsrvd_symlinksub(nd, &named, &nva, fhp, vpp, dirp,
1756 &dirfor, &diraft, &diraft_ret, NULL, NULL, p, exp,
1758 } else if (dirp != NULL) {
1759 dirfor_ret = nfsvno_getattr(dirp, &dirfor, nd->nd_cred, p, 0);
1763 FREE(pathcp, M_TEMP);
1765 if (nd->nd_flag & ND_NFSV3) {
1766 if (!nd->nd_repstat) {
1767 (void) nfsm_fhtom(nd, (u_int8_t *)fhp, 0, 1);
1768 nfsrv_postopattr(nd, 0, &nva);
1770 nfsrv_wcc(nd, dirfor_ret, &dirfor, diraft_ret, &diraft);
1774 NFSEXITCODE2(error, nd);
1779 * Common code for creating a symbolic link.
1782 nfsrvd_symlinksub(struct nfsrv_descript *nd, struct nameidata *ndp,
1783 struct nfsvattr *nvap, fhandle_t *fhp, vnode_t *vpp,
1784 vnode_t dirp, struct nfsvattr *dirforp, struct nfsvattr *diraftp,
1785 int *diraft_retp, nfsattrbit_t *attrbitp,
1786 NFSACL_T *aclp, NFSPROC_T *p, struct nfsexstuff *exp, char *pathcp,
1791 nd->nd_repstat = nfsvno_symlink(ndp, nvap, pathcp, pathlen,
1792 !(nd->nd_flag & ND_NFSV2), nd->nd_saveduid, nd->nd_cred, p, exp);
1793 if (!nd->nd_repstat && !(nd->nd_flag & ND_NFSV2)) {
1794 nfsrv_fixattr(nd, ndp->ni_vp, nvap, aclp, p, attrbitp, exp);
1795 if (nd->nd_flag & ND_NFSV3) {
1796 nd->nd_repstat = nfsvno_getfh(ndp->ni_vp, fhp, p);
1797 if (!nd->nd_repstat)
1798 nd->nd_repstat = nfsvno_getattr(ndp->ni_vp,
1799 nvap, nd->nd_cred, p, 1);
1801 if (vpp != NULL && nd->nd_repstat == 0) {
1802 NFSVOPUNLOCK(ndp->ni_vp, 0);
1808 *diraft_retp = nfsvno_getattr(dirp, diraftp, nd->nd_cred, p, 0);
1811 if ((nd->nd_flag & ND_NFSV4) && !nd->nd_repstat) {
1812 NFSM_BUILD(tl, u_int32_t *, 5 * NFSX_UNSIGNED);
1813 *tl++ = newnfs_false;
1814 txdr_hyper(dirforp->na_filerev, tl);
1816 txdr_hyper(diraftp->na_filerev, tl);
1817 (void) nfsrv_putattrbit(nd, attrbitp);
1820 NFSEXITCODE2(0, nd);
1827 nfsrvd_mkdir(struct nfsrv_descript *nd, __unused int isdgram,
1828 vnode_t dp, vnode_t *vpp, fhandle_t *fhp, NFSPROC_T *p,
1829 struct nfsexstuff *exp)
1831 struct nfsvattr nva, dirfor, diraft;
1832 struct nameidata named;
1834 int error = 0, dirfor_ret = 1, diraft_ret = 1;
1835 vnode_t dirp = NULL;
1839 if (nd->nd_repstat) {
1840 nfsrv_wcc(nd, dirfor_ret, &dirfor, diraft_ret, &diraft);
1843 NFSNAMEICNDSET(&named.ni_cnd, nd->nd_cred, CREATE,
1844 LOCKPARENT | SAVENAME);
1845 nfsvno_setpathbuf(&named, &bufp, &hashp);
1846 error = nfsrv_parsename(nd, bufp, hashp, &named.ni_pathlen);
1849 if (!nd->nd_repstat) {
1850 NFSVNO_ATTRINIT(&nva);
1851 if (nd->nd_flag & ND_NFSV3) {
1852 error = nfsrv_sattr(nd, &nva, NULL, NULL, p);
1856 NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
1857 nva.na_mode = nfstov_mode(*tl++);
1860 if (!nd->nd_repstat) {
1861 nd->nd_repstat = nfsvno_namei(nd, &named, dp, 0, exp, p, &dirp);
1864 nfsvno_relpathbuf(&named);
1866 if (dirp != NULL && !(nd->nd_flag & ND_NFSV3)) {
1870 if (nd->nd_repstat) {
1872 dirfor_ret = nfsvno_getattr(dirp, &dirfor, nd->nd_cred,
1876 if (nd->nd_flag & ND_NFSV3)
1877 nfsrv_wcc(nd, dirfor_ret, &dirfor, diraft_ret,
1882 dirfor_ret = nfsvno_getattr(dirp, &dirfor, nd->nd_cred, p, 0);
1885 * Call nfsrvd_mkdirsub() for the code common to V4 as well.
1887 nfsrvd_mkdirsub(nd, &named, &nva, fhp, vpp, dirp, &dirfor, &diraft,
1888 &diraft_ret, NULL, NULL, p, exp);
1890 if (nd->nd_flag & ND_NFSV3) {
1891 if (!nd->nd_repstat) {
1892 (void) nfsm_fhtom(nd, (u_int8_t *)fhp, 0, 1);
1893 nfsrv_postopattr(nd, 0, &nva);
1895 nfsrv_wcc(nd, dirfor_ret, &dirfor, diraft_ret, &diraft);
1896 } else if (!nd->nd_repstat) {
1897 (void) nfsm_fhtom(nd, (u_int8_t *)fhp, 0, 0);
1898 nfsrv_fillattr(nd, &nva);
1902 NFSEXITCODE2(0, nd);
1906 nfsvno_relpathbuf(&named);
1907 NFSEXITCODE2(error, nd);
1912 * Code common to mkdir for V2,3 and 4.
1915 nfsrvd_mkdirsub(struct nfsrv_descript *nd, struct nameidata *ndp,
1916 struct nfsvattr *nvap, fhandle_t *fhp, vnode_t *vpp,
1917 vnode_t dirp, struct nfsvattr *dirforp, struct nfsvattr *diraftp,
1918 int *diraft_retp, nfsattrbit_t *attrbitp, NFSACL_T *aclp,
1919 NFSPROC_T *p, struct nfsexstuff *exp)
1924 NFSVNO_SETATTRVAL(nvap, type, VDIR);
1925 nd->nd_repstat = nfsvno_mkdir(ndp, nvap, nd->nd_saveduid,
1926 nd->nd_cred, p, exp);
1927 if (!nd->nd_repstat) {
1929 nfsrv_fixattr(nd, vp, nvap, aclp, p, attrbitp, exp);
1930 nd->nd_repstat = nfsvno_getfh(vp, fhp, p);
1931 if (!(nd->nd_flag & ND_NFSV4) && !nd->nd_repstat)
1932 nd->nd_repstat = nfsvno_getattr(vp, nvap, nd->nd_cred,
1934 if (vpp && !nd->nd_repstat) {
1935 NFSVOPUNLOCK(vp, 0);
1942 *diraft_retp = nfsvno_getattr(dirp, diraftp, nd->nd_cred, p, 0);
1945 if ((nd->nd_flag & ND_NFSV4) && !nd->nd_repstat) {
1946 NFSM_BUILD(tl, u_int32_t *, 5 * NFSX_UNSIGNED);
1947 *tl++ = newnfs_false;
1948 txdr_hyper(dirforp->na_filerev, tl);
1950 txdr_hyper(diraftp->na_filerev, tl);
1951 (void) nfsrv_putattrbit(nd, attrbitp);
1954 NFSEXITCODE2(0, nd);
1958 * nfs commit service
1961 nfsrvd_commit(struct nfsrv_descript *nd, __unused int isdgram,
1962 vnode_t vp, NFSPROC_T *p, __unused struct nfsexstuff *exp)
1964 struct nfsvattr bfor, aft;
1966 int error = 0, for_ret = 1, aft_ret = 1, cnt;
1969 if (nd->nd_repstat) {
1970 nfsrv_wcc(nd, for_ret, &bfor, aft_ret, &aft);
1973 NFSM_DISSECT(tl, u_int32_t *, 3 * NFSX_UNSIGNED);
1975 * XXX At this time VOP_FSYNC() does not accept offset and byte
1976 * count parameters, so these arguments are useless (someday maybe).
1978 off = fxdr_hyper(tl);
1980 cnt = fxdr_unsigned(int, *tl);
1981 if (nd->nd_flag & ND_NFSV3)
1982 for_ret = nfsvno_getattr(vp, &bfor, nd->nd_cred, p, 1);
1983 nd->nd_repstat = nfsvno_fsync(vp, off, cnt, nd->nd_cred, p);
1984 if (nd->nd_flag & ND_NFSV3) {
1985 aft_ret = nfsvno_getattr(vp, &aft, nd->nd_cred, p, 1);
1986 nfsrv_wcc(nd, for_ret, &bfor, aft_ret, &aft);
1989 if (!nd->nd_repstat) {
1990 NFSM_BUILD(tl, u_int32_t *, NFSX_VERF);
1991 *tl++ = txdr_unsigned(nfsboottime.tv_sec);
1992 *tl = txdr_unsigned(nfsboottime.tv_usec);
1996 NFSEXITCODE2(0, nd);
2000 NFSEXITCODE2(error, nd);
2005 * nfs statfs service
2008 nfsrvd_statfs(struct nfsrv_descript *nd, __unused int isdgram,
2009 vnode_t vp, NFSPROC_T *p, __unused struct nfsexstuff *exp)
2018 if (nd->nd_repstat) {
2019 nfsrv_postopattr(nd, getret, &at);
2023 nd->nd_repstat = nfsvno_statfs(vp, sf);
2024 getret = nfsvno_getattr(vp, &at, nd->nd_cred, p, 1);
2026 if (nd->nd_flag & ND_NFSV3)
2027 nfsrv_postopattr(nd, getret, &at);
2030 if (nd->nd_flag & ND_NFSV2) {
2031 NFSM_BUILD(tl, u_int32_t *, NFSX_V2STATFS);
2032 *tl++ = txdr_unsigned(NFS_V2MAXDATA);
2033 *tl++ = txdr_unsigned(sf->f_bsize);
2034 *tl++ = txdr_unsigned(sf->f_blocks);
2035 *tl++ = txdr_unsigned(sf->f_bfree);
2036 *tl = txdr_unsigned(sf->f_bavail);
2038 NFSM_BUILD(tl, u_int32_t *, NFSX_V3STATFS);
2039 tval = (u_quad_t)sf->f_blocks;
2040 tval *= (u_quad_t)sf->f_bsize;
2041 txdr_hyper(tval, tl); tl += 2;
2042 tval = (u_quad_t)sf->f_bfree;
2043 tval *= (u_quad_t)sf->f_bsize;
2044 txdr_hyper(tval, tl); tl += 2;
2045 tval = (u_quad_t)sf->f_bavail;
2046 tval *= (u_quad_t)sf->f_bsize;
2047 txdr_hyper(tval, tl); tl += 2;
2048 tval = (u_quad_t)sf->f_files;
2049 txdr_hyper(tval, tl); tl += 2;
2050 tval = (u_quad_t)sf->f_ffree;
2051 txdr_hyper(tval, tl); tl += 2;
2052 tval = (u_quad_t)sf->f_ffree;
2053 txdr_hyper(tval, tl); tl += 2;
2058 NFSEXITCODE2(0, nd);
2063 * nfs fsinfo service
2066 nfsrvd_fsinfo(struct nfsrv_descript *nd, int isdgram,
2067 vnode_t vp, NFSPROC_T *p, __unused struct nfsexstuff *exp)
2070 struct nfsfsinfo fs;
2074 if (nd->nd_repstat) {
2075 nfsrv_postopattr(nd, getret, &at);
2078 getret = nfsvno_getattr(vp, &at, nd->nd_cred, p, 1);
2079 nfsvno_getfs(&fs, isdgram);
2081 nfsrv_postopattr(nd, getret, &at);
2082 NFSM_BUILD(tl, u_int32_t *, NFSX_V3FSINFO);
2083 *tl++ = txdr_unsigned(fs.fs_rtmax);
2084 *tl++ = txdr_unsigned(fs.fs_rtpref);
2085 *tl++ = txdr_unsigned(fs.fs_rtmult);
2086 *tl++ = txdr_unsigned(fs.fs_wtmax);
2087 *tl++ = txdr_unsigned(fs.fs_wtpref);
2088 *tl++ = txdr_unsigned(fs.fs_wtmult);
2089 *tl++ = txdr_unsigned(fs.fs_dtpref);
2090 txdr_hyper(fs.fs_maxfilesize, tl);
2092 txdr_nfsv3time(&fs.fs_timedelta, tl);
2094 *tl = txdr_unsigned(fs.fs_properties);
2097 NFSEXITCODE2(0, nd);
2102 * nfs pathconf service
2105 nfsrvd_pathconf(struct nfsrv_descript *nd, __unused int isdgram,
2106 vnode_t vp, NFSPROC_T *p, __unused struct nfsexstuff *exp)
2108 struct nfsv3_pathconf *pc;
2110 register_t linkmax, namemax, chownres, notrunc;
2113 if (nd->nd_repstat) {
2114 nfsrv_postopattr(nd, getret, &at);
2117 nd->nd_repstat = nfsvno_pathconf(vp, _PC_LINK_MAX, &linkmax,
2119 if (!nd->nd_repstat)
2120 nd->nd_repstat = nfsvno_pathconf(vp, _PC_NAME_MAX, &namemax,
2122 if (!nd->nd_repstat)
2123 nd->nd_repstat=nfsvno_pathconf(vp, _PC_CHOWN_RESTRICTED,
2124 &chownres, nd->nd_cred, p);
2125 if (!nd->nd_repstat)
2126 nd->nd_repstat = nfsvno_pathconf(vp, _PC_NO_TRUNC, ¬runc,
2128 getret = nfsvno_getattr(vp, &at, nd->nd_cred, p, 1);
2130 nfsrv_postopattr(nd, getret, &at);
2131 if (!nd->nd_repstat) {
2132 NFSM_BUILD(pc, struct nfsv3_pathconf *, NFSX_V3PATHCONF);
2133 pc->pc_linkmax = txdr_unsigned(linkmax);
2134 pc->pc_namemax = txdr_unsigned(namemax);
2135 pc->pc_notrunc = txdr_unsigned(notrunc);
2136 pc->pc_chownrestricted = txdr_unsigned(chownres);
2139 * These should probably be supported by VOP_PATHCONF(), but
2140 * until msdosfs is exportable (why would you want to?), the
2141 * Unix defaults should be ok.
2143 pc->pc_caseinsensitive = newnfs_false;
2144 pc->pc_casepreserving = newnfs_true;
2148 NFSEXITCODE2(0, nd);
2153 * nfsv4 lock service
2156 nfsrvd_lock(struct nfsrv_descript *nd, __unused int isdgram,
2157 vnode_t vp, NFSPROC_T *p, struct nfsexstuff *exp)
2161 struct nfsstate *stp = NULL;
2162 struct nfslock *lop;
2163 struct nfslockconflict cf;
2165 u_short flags = NFSLCK_LOCK, lflags;
2166 u_int64_t offset, len;
2167 nfsv4stateid_t stateid;
2170 NFSM_DISSECT(tl, u_int32_t *, 7 * NFSX_UNSIGNED);
2171 i = fxdr_unsigned(int, *tl++);
2173 case NFSV4LOCKT_READW:
2174 flags |= NFSLCK_BLOCKING;
2175 case NFSV4LOCKT_READ:
2176 lflags = NFSLCK_READ;
2178 case NFSV4LOCKT_WRITEW:
2179 flags |= NFSLCK_BLOCKING;
2180 case NFSV4LOCKT_WRITE:
2181 lflags = NFSLCK_WRITE;
2184 nd->nd_repstat = NFSERR_BADXDR;
2187 if (*tl++ == newnfs_true)
2188 flags |= NFSLCK_RECLAIM;
2189 offset = fxdr_hyper(tl);
2191 len = fxdr_hyper(tl);
2193 if (*tl == newnfs_true)
2194 flags |= NFSLCK_OPENTOLOCK;
2195 if (flags & NFSLCK_OPENTOLOCK) {
2196 NFSM_DISSECT(tl, u_int32_t *, 5 * NFSX_UNSIGNED + NFSX_STATEID);
2197 i = fxdr_unsigned(int, *(tl+4+(NFSX_STATEID / NFSX_UNSIGNED)));
2198 if (i <= 0 || i > NFSV4_OPAQUELIMIT) {
2199 nd->nd_repstat = NFSERR_BADXDR;
2202 MALLOC(stp, struct nfsstate *, sizeof (struct nfsstate) + i,
2203 M_NFSDSTATE, M_WAITOK);
2204 stp->ls_ownerlen = i;
2205 stp->ls_op = nd->nd_rp;
2206 stp->ls_seq = fxdr_unsigned(int, *tl++);
2207 stp->ls_stateid.seqid = fxdr_unsigned(u_int32_t, *tl++);
2208 NFSBCOPY((caddr_t)tl, (caddr_t)stp->ls_stateid.other,
2210 tl += (NFSX_STATEIDOTHER / NFSX_UNSIGNED);
2211 stp->ls_opentolockseq = fxdr_unsigned(int, *tl++);
2212 clientid.lval[0] = *tl++;
2213 clientid.lval[1] = *tl++;
2214 if (nd->nd_flag & ND_IMPLIEDCLID) {
2215 if (nd->nd_clientid.qval != clientid.qval)
2216 printf("EEK! multiple clids\n");
2218 nd->nd_flag |= ND_IMPLIEDCLID;
2219 nd->nd_clientid.qval = clientid.qval;
2221 error = nfsrv_mtostr(nd, stp->ls_owner, stp->ls_ownerlen);
2225 NFSM_DISSECT(tl, u_int32_t *, NFSX_STATEID + NFSX_UNSIGNED);
2226 MALLOC(stp, struct nfsstate *, sizeof (struct nfsstate),
2227 M_NFSDSTATE, M_WAITOK);
2228 stp->ls_ownerlen = 0;
2229 stp->ls_op = nd->nd_rp;
2230 stp->ls_stateid.seqid = fxdr_unsigned(u_int32_t, *tl++);
2231 NFSBCOPY((caddr_t)tl, (caddr_t)stp->ls_stateid.other,
2233 tl += (NFSX_STATEIDOTHER / NFSX_UNSIGNED);
2234 stp->ls_seq = fxdr_unsigned(int, *tl);
2235 clientid.lval[0] = stp->ls_stateid.other[0];
2236 clientid.lval[1] = stp->ls_stateid.other[1];
2237 if (nd->nd_flag & ND_IMPLIEDCLID) {
2238 if (nd->nd_clientid.qval != clientid.qval)
2239 printf("EEK! multiple clids\n");
2241 nd->nd_flag |= ND_IMPLIEDCLID;
2242 nd->nd_clientid.qval = clientid.qval;
2245 MALLOC(lop, struct nfslock *, sizeof (struct nfslock),
2246 M_NFSDLOCK, M_WAITOK);
2247 lop->lo_first = offset;
2248 if (len == NFS64BITSSET) {
2249 lop->lo_end = NFS64BITSSET;
2251 lop->lo_end = offset + len;
2252 if (lop->lo_end <= lop->lo_first)
2253 nd->nd_repstat = NFSERR_INVAL;
2255 lop->lo_flags = lflags;
2256 stp->ls_flags = flags;
2257 stp->ls_uid = nd->nd_cred->cr_uid;
2260 * Do basic access checking.
2262 if (!nd->nd_repstat && vnode_vtype(vp) != VREG) {
2263 if (vnode_vtype(vp) == VDIR)
2264 nd->nd_repstat = NFSERR_ISDIR;
2266 nd->nd_repstat = NFSERR_INVAL;
2268 if (!nd->nd_repstat) {
2269 if (lflags & NFSLCK_WRITE) {
2270 nd->nd_repstat = nfsvno_accchk(vp, VWRITE,
2271 nd->nd_cred, exp, p, NFSACCCHK_ALLOWOWNER,
2272 NFSACCCHK_VPISLOCKED, NULL);
2274 nd->nd_repstat = nfsvno_accchk(vp, VREAD,
2275 nd->nd_cred, exp, p, NFSACCCHK_ALLOWOWNER,
2276 NFSACCCHK_VPISLOCKED, NULL);
2278 nd->nd_repstat = nfsvno_accchk(vp, VEXEC,
2279 nd->nd_cred, exp, p, NFSACCCHK_ALLOWOWNER,
2280 NFSACCCHK_VPISLOCKED, NULL);
2285 * We call nfsrv_lockctrl() even if nd_repstat set, so that the
2286 * seqid# gets updated. nfsrv_lockctrl() will return the value
2287 * of nd_repstat, if it gets that far.
2289 nd->nd_repstat = nfsrv_lockctrl(vp, &stp, &lop, &cf, clientid,
2290 &stateid, exp, nd, p);
2292 FREE((caddr_t)lop, M_NFSDLOCK);
2294 FREE((caddr_t)stp, M_NFSDSTATE);
2295 if (!nd->nd_repstat) {
2296 NFSM_BUILD(tl, u_int32_t *, NFSX_STATEID);
2297 *tl++ = txdr_unsigned(stateid.seqid);
2298 NFSBCOPY((caddr_t)stateid.other,(caddr_t)tl,NFSX_STATEIDOTHER);
2299 } else if (nd->nd_repstat == NFSERR_DENIED) {
2300 NFSM_BUILD(tl, u_int32_t *, 7 * NFSX_UNSIGNED);
2301 txdr_hyper(cf.cl_first, tl);
2303 if (cf.cl_end == NFS64BITSSET)
2306 len = cf.cl_end - cf.cl_first;
2307 txdr_hyper(len, tl);
2309 if (cf.cl_flags == NFSLCK_WRITE)
2310 *tl++ = txdr_unsigned(NFSV4LOCKT_WRITE);
2312 *tl++ = txdr_unsigned(NFSV4LOCKT_READ);
2313 *tl++ = stateid.other[0];
2314 *tl = stateid.other[1];
2315 (void) nfsm_strtom(nd, cf.cl_owner, cf.cl_ownerlen);
2318 NFSEXITCODE2(0, nd);
2323 free((caddr_t)stp, M_NFSDSTATE);
2324 NFSEXITCODE2(error, nd);
2329 * nfsv4 lock test service
2332 nfsrvd_lockt(struct nfsrv_descript *nd, __unused int isdgram,
2333 vnode_t vp, NFSPROC_T *p, struct nfsexstuff *exp)
2337 struct nfsstate *stp = NULL;
2338 struct nfslock lo, *lop = &lo;
2339 struct nfslockconflict cf;
2341 nfsv4stateid_t stateid;
2345 NFSM_DISSECT(tl, u_int32_t *, 8 * NFSX_UNSIGNED);
2346 i = fxdr_unsigned(int, *(tl + 7));
2347 if (i <= 0 || i > NFSV4_OPAQUELIMIT) {
2348 nd->nd_repstat = NFSERR_BADXDR;
2351 MALLOC(stp, struct nfsstate *, sizeof (struct nfsstate) + i,
2352 M_NFSDSTATE, M_WAITOK);
2353 stp->ls_ownerlen = i;
2355 stp->ls_flags = NFSLCK_TEST;
2356 stp->ls_uid = nd->nd_cred->cr_uid;
2357 i = fxdr_unsigned(int, *tl++);
2359 case NFSV4LOCKT_READW:
2360 stp->ls_flags |= NFSLCK_BLOCKING;
2361 case NFSV4LOCKT_READ:
2362 lo.lo_flags = NFSLCK_READ;
2364 case NFSV4LOCKT_WRITEW:
2365 stp->ls_flags |= NFSLCK_BLOCKING;
2366 case NFSV4LOCKT_WRITE:
2367 lo.lo_flags = NFSLCK_WRITE;
2370 nd->nd_repstat = NFSERR_BADXDR;
2373 lo.lo_first = fxdr_hyper(tl);
2375 len = fxdr_hyper(tl);
2376 if (len == NFS64BITSSET) {
2377 lo.lo_end = NFS64BITSSET;
2379 lo.lo_end = lo.lo_first + len;
2380 if (lo.lo_end <= lo.lo_first)
2381 nd->nd_repstat = NFSERR_INVAL;
2384 clientid.lval[0] = *tl++;
2385 clientid.lval[1] = *tl;
2386 if (nd->nd_flag & ND_IMPLIEDCLID) {
2387 if (nd->nd_clientid.qval != clientid.qval)
2388 printf("EEK! multiple clids\n");
2390 nd->nd_flag |= ND_IMPLIEDCLID;
2391 nd->nd_clientid.qval = clientid.qval;
2393 error = nfsrv_mtostr(nd, stp->ls_owner, stp->ls_ownerlen);
2396 if (!nd->nd_repstat && vnode_vtype(vp) != VREG) {
2397 if (vnode_vtype(vp) == VDIR)
2398 nd->nd_repstat = NFSERR_ISDIR;
2400 nd->nd_repstat = NFSERR_INVAL;
2402 if (!nd->nd_repstat)
2403 nd->nd_repstat = nfsrv_lockctrl(vp, &stp, &lop, &cf, clientid,
2404 &stateid, exp, nd, p);
2406 FREE((caddr_t)stp, M_NFSDSTATE);
2407 if (nd->nd_repstat) {
2408 if (nd->nd_repstat == NFSERR_DENIED) {
2409 NFSM_BUILD(tl, u_int32_t *, 7 * NFSX_UNSIGNED);
2410 txdr_hyper(cf.cl_first, tl);
2412 if (cf.cl_end == NFS64BITSSET)
2415 len = cf.cl_end - cf.cl_first;
2416 txdr_hyper(len, tl);
2418 if (cf.cl_flags == NFSLCK_WRITE)
2419 *tl++ = txdr_unsigned(NFSV4LOCKT_WRITE);
2421 *tl++ = txdr_unsigned(NFSV4LOCKT_READ);
2422 *tl++ = stp->ls_stateid.other[0];
2423 *tl = stp->ls_stateid.other[1];
2424 (void) nfsm_strtom(nd, cf.cl_owner, cf.cl_ownerlen);
2428 NFSEXITCODE2(0, nd);
2433 free((caddr_t)stp, M_NFSDSTATE);
2434 NFSEXITCODE2(error, nd);
2439 * nfsv4 unlock service
2442 nfsrvd_locku(struct nfsrv_descript *nd, __unused int isdgram,
2443 vnode_t vp, NFSPROC_T *p, struct nfsexstuff *exp)
2447 struct nfsstate *stp;
2448 struct nfslock *lop;
2450 nfsv4stateid_t stateid;
2454 NFSM_DISSECT(tl, u_int32_t *, 6 * NFSX_UNSIGNED + NFSX_STATEID);
2455 MALLOC(stp, struct nfsstate *, sizeof (struct nfsstate),
2456 M_NFSDSTATE, M_WAITOK);
2457 MALLOC(lop, struct nfslock *, sizeof (struct nfslock),
2458 M_NFSDLOCK, M_WAITOK);
2459 stp->ls_flags = NFSLCK_UNLOCK;
2460 lop->lo_flags = NFSLCK_UNLOCK;
2461 stp->ls_op = nd->nd_rp;
2462 i = fxdr_unsigned(int, *tl++);
2464 case NFSV4LOCKT_READW:
2465 stp->ls_flags |= NFSLCK_BLOCKING;
2466 case NFSV4LOCKT_READ:
2468 case NFSV4LOCKT_WRITEW:
2469 stp->ls_flags |= NFSLCK_BLOCKING;
2470 case NFSV4LOCKT_WRITE:
2473 nd->nd_repstat = NFSERR_BADXDR;
2474 free(stp, M_NFSDSTATE);
2475 free(lop, M_NFSDLOCK);
2478 stp->ls_ownerlen = 0;
2479 stp->ls_uid = nd->nd_cred->cr_uid;
2480 stp->ls_seq = fxdr_unsigned(int, *tl++);
2481 stp->ls_stateid.seqid = fxdr_unsigned(u_int32_t, *tl++);
2482 NFSBCOPY((caddr_t)tl, (caddr_t)stp->ls_stateid.other,
2484 tl += (NFSX_STATEIDOTHER / NFSX_UNSIGNED);
2485 lop->lo_first = fxdr_hyper(tl);
2487 len = fxdr_hyper(tl);
2488 if (len == NFS64BITSSET) {
2489 lop->lo_end = NFS64BITSSET;
2491 lop->lo_end = lop->lo_first + len;
2492 if (lop->lo_end <= lop->lo_first)
2493 nd->nd_repstat = NFSERR_INVAL;
2495 clientid.lval[0] = stp->ls_stateid.other[0];
2496 clientid.lval[1] = stp->ls_stateid.other[1];
2497 if (nd->nd_flag & ND_IMPLIEDCLID) {
2498 if (nd->nd_clientid.qval != clientid.qval)
2499 printf("EEK! multiple clids\n");
2501 nd->nd_flag |= ND_IMPLIEDCLID;
2502 nd->nd_clientid.qval = clientid.qval;
2504 if (!nd->nd_repstat && vnode_vtype(vp) != VREG) {
2505 if (vnode_vtype(vp) == VDIR)
2506 nd->nd_repstat = NFSERR_ISDIR;
2508 nd->nd_repstat = NFSERR_INVAL;
2511 * Call nfsrv_lockctrl() even if nd_repstat is set, so that the
2512 * seqid# gets incremented. nfsrv_lockctrl() will return the
2513 * value of nd_repstat, if it gets that far.
2515 nd->nd_repstat = nfsrv_lockctrl(vp, &stp, &lop, NULL, clientid,
2516 &stateid, exp, nd, p);
2518 FREE((caddr_t)stp, M_NFSDSTATE);
2520 free((caddr_t)lop, M_NFSDLOCK);
2521 if (!nd->nd_repstat) {
2522 NFSM_BUILD(tl, u_int32_t *, NFSX_STATEID);
2523 *tl++ = txdr_unsigned(stateid.seqid);
2524 NFSBCOPY((caddr_t)stateid.other,(caddr_t)tl,NFSX_STATEIDOTHER);
2528 NFSEXITCODE2(error, nd);
2533 * nfsv4 open service
2536 nfsrvd_open(struct nfsrv_descript *nd, __unused int isdgram,
2537 vnode_t dp, vnode_t *vpp, __unused fhandle_t *fhp, NFSPROC_T *p,
2538 struct nfsexstuff *exp)
2542 struct nfsstate *stp = NULL;
2543 int error = 0, create, claim, exclusive_flag = 0;
2544 u_int32_t rflags = NFSV4OPEN_LOCKTYPEPOSIX, acemask;
2545 int how = NFSCREATE_UNCHECKED;
2546 int32_t cverf[2], tverf[2] = { 0, 0 };
2547 vnode_t vp = NULL, dirp = NULL;
2548 struct nfsvattr nva, dirfor, diraft;
2549 struct nameidata named;
2550 nfsv4stateid_t stateid, delegstateid;
2551 nfsattrbit_t attrbits;
2555 NFSACL_T *aclp = NULL;
2557 #ifdef NFS4_ACL_EXTATTR_NAME
2558 aclp = acl_alloc(M_WAITOK);
2561 NFSZERO_ATTRBIT(&attrbits);
2562 named.ni_startdir = NULL;
2563 named.ni_cnd.cn_nameiop = 0;
2564 NFSM_DISSECT(tl, u_int32_t *, 6 * NFSX_UNSIGNED);
2565 i = fxdr_unsigned(int, *(tl + 5));
2566 if (i <= 0 || i > NFSV4_OPAQUELIMIT) {
2567 nd->nd_repstat = NFSERR_BADXDR;
2570 MALLOC(stp, struct nfsstate *, sizeof (struct nfsstate) + i,
2571 M_NFSDSTATE, M_WAITOK);
2572 stp->ls_ownerlen = i;
2573 stp->ls_op = nd->nd_rp;
2574 stp->ls_flags = NFSLCK_OPEN;
2575 stp->ls_uid = nd->nd_cred->cr_uid;
2576 stp->ls_seq = fxdr_unsigned(u_int32_t, *tl++);
2577 i = fxdr_unsigned(int, *tl++);
2579 case NFSV4OPEN_ACCESSREAD:
2580 stp->ls_flags |= NFSLCK_READACCESS;
2582 case NFSV4OPEN_ACCESSWRITE:
2583 stp->ls_flags |= NFSLCK_WRITEACCESS;
2585 case NFSV4OPEN_ACCESSBOTH:
2586 stp->ls_flags |= (NFSLCK_READACCESS | NFSLCK_WRITEACCESS);
2589 nd->nd_repstat = NFSERR_INVAL;
2591 i = fxdr_unsigned(int, *tl++);
2593 case NFSV4OPEN_DENYNONE:
2595 case NFSV4OPEN_DENYREAD:
2596 stp->ls_flags |= NFSLCK_READDENY;
2598 case NFSV4OPEN_DENYWRITE:
2599 stp->ls_flags |= NFSLCK_WRITEDENY;
2601 case NFSV4OPEN_DENYBOTH:
2602 stp->ls_flags |= (NFSLCK_READDENY | NFSLCK_WRITEDENY);
2605 nd->nd_repstat = NFSERR_INVAL;
2607 clientid.lval[0] = *tl++;
2608 clientid.lval[1] = *tl;
2609 if (nd->nd_flag & ND_IMPLIEDCLID) {
2610 if (nd->nd_clientid.qval != clientid.qval)
2611 printf("EEK! multiple clids\n");
2613 nd->nd_flag |= ND_IMPLIEDCLID;
2614 nd->nd_clientid.qval = clientid.qval;
2616 error = nfsrv_mtostr(nd, stp->ls_owner, stp->ls_ownerlen);
2619 NFSVNO_ATTRINIT(&nva);
2620 NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
2621 create = fxdr_unsigned(int, *tl);
2622 if (!nd->nd_repstat)
2623 nd->nd_repstat = nfsvno_getattr(dp, &dirfor, nd->nd_cred, p, 0);
2624 if (create == NFSV4OPEN_CREATE) {
2627 NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
2628 how = fxdr_unsigned(int, *tl);
2630 case NFSCREATE_UNCHECKED:
2631 case NFSCREATE_GUARDED:
2632 error = nfsv4_sattr(nd, &nva, &attrbits, aclp, p);
2636 * If the na_gid being set is the same as that of
2637 * the directory it is going in, clear it, since
2638 * that is what will be set by default. This allows
2639 * a user that isn't in that group to do the create.
2641 if (!nd->nd_repstat && NFSVNO_ISSETGID(&nva) &&
2642 nva.na_gid == dirfor.na_gid)
2643 NFSVNO_UNSET(&nva, gid);
2644 if (!nd->nd_repstat)
2645 nd->nd_repstat = nfsrv_checkuidgid(nd, &nva);
2647 case NFSCREATE_EXCLUSIVE:
2648 NFSM_DISSECT(tl, u_int32_t *, NFSX_VERF);
2653 nd->nd_repstat = NFSERR_BADXDR;
2656 } else if (create != NFSV4OPEN_NOCREATE) {
2657 nd->nd_repstat = NFSERR_BADXDR;
2662 * Now, handle the claim, which usually includes looking up a
2663 * name in the directory referenced by dp. The exception is
2664 * NFSV4OPEN_CLAIMPREVIOUS.
2666 NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
2667 claim = fxdr_unsigned(int, *tl);
2668 if (claim == NFSV4OPEN_CLAIMDELEGATECUR) {
2669 NFSM_DISSECT(tl, u_int32_t *, NFSX_STATEID);
2670 stateid.seqid = fxdr_unsigned(u_int32_t, *tl++);
2671 NFSBCOPY((caddr_t)tl,(caddr_t)stateid.other,NFSX_STATEIDOTHER);
2672 stp->ls_flags |= NFSLCK_DELEGCUR;
2673 } else if (claim == NFSV4OPEN_CLAIMDELEGATEPREV) {
2674 stp->ls_flags |= NFSLCK_DELEGPREV;
2676 if (claim == NFSV4OPEN_CLAIMNULL || claim == NFSV4OPEN_CLAIMDELEGATECUR
2677 || claim == NFSV4OPEN_CLAIMDELEGATEPREV) {
2678 if (!nd->nd_repstat && create == NFSV4OPEN_CREATE &&
2679 claim != NFSV4OPEN_CLAIMNULL)
2680 nd->nd_repstat = NFSERR_INVAL;
2681 if (nd->nd_repstat) {
2682 nd->nd_repstat = nfsrv_opencheck(clientid,
2683 &stateid, stp, NULL, nd, p, nd->nd_repstat);
2686 if (create == NFSV4OPEN_CREATE)
2687 NFSNAMEICNDSET(&named.ni_cnd, nd->nd_cred, CREATE,
2688 LOCKPARENT | LOCKLEAF | SAVESTART);
2690 NFSNAMEICNDSET(&named.ni_cnd, nd->nd_cred, LOOKUP,
2691 LOCKLEAF | SAVESTART);
2692 nfsvno_setpathbuf(&named, &bufp, &hashp);
2693 error = nfsrv_parsename(nd, bufp, hashp, &named.ni_pathlen);
2696 #ifdef NFS4_ACL_EXTATTR_NAME
2699 FREE((caddr_t)stp, M_NFSDSTATE);
2700 nfsvno_relpathbuf(&named);
2701 NFSEXITCODE2(error, nd);
2704 if (!nd->nd_repstat) {
2705 nd->nd_repstat = nfsvno_namei(nd, &named, dp, 0, exp,
2709 nfsvno_relpathbuf(&named);
2711 if (create == NFSV4OPEN_CREATE) {
2713 case NFSCREATE_UNCHECKED:
2716 * Clear the setable attribute bits, except
2717 * for Size, if it is being truncated.
2719 NFSZERO_ATTRBIT(&attrbits);
2720 if (NFSVNO_ISSETSIZE(&nva))
2721 NFSSETBIT_ATTRBIT(&attrbits,
2725 case NFSCREATE_GUARDED:
2726 if (named.ni_vp && !nd->nd_repstat)
2727 nd->nd_repstat = EEXIST;
2729 case NFSCREATE_EXCLUSIVE:
2735 nfsvno_open(nd, &named, clientid, &stateid, stp,
2736 &exclusive_flag, &nva, cverf, create, aclp, &attrbits,
2737 nd->nd_cred, p, exp, &vp);
2738 } else if (claim == NFSV4OPEN_CLAIMPREVIOUS) {
2739 NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
2740 i = fxdr_unsigned(int, *tl);
2742 case NFSV4OPEN_DELEGATEREAD:
2743 stp->ls_flags |= NFSLCK_DELEGREAD;
2745 case NFSV4OPEN_DELEGATEWRITE:
2746 stp->ls_flags |= NFSLCK_DELEGWRITE;
2747 case NFSV4OPEN_DELEGATENONE:
2750 nd->nd_repstat = NFSERR_BADXDR;
2753 stp->ls_flags |= NFSLCK_RECLAIM;
2755 NFSVOPLOCK(vp, LK_EXCLUSIVE | LK_RETRY);
2756 if ((vp->v_iflag & VI_DOOMED) == 0)
2757 nd->nd_repstat = nfsrv_opencheck(clientid, &stateid,
2758 stp, vp, nd, p, nd->nd_repstat);
2760 nd->nd_repstat = NFSERR_PERM;
2762 nd->nd_repstat = NFSERR_BADXDR;
2767 * Do basic access checking.
2769 if (!nd->nd_repstat && vnode_vtype(vp) != VREG) {
2771 * The IETF working group decided that this is the correct
2772 * error return for all non-regular files.
2774 nd->nd_repstat = NFSERR_SYMLINK;
2776 if (!nd->nd_repstat && (stp->ls_flags & NFSLCK_WRITEACCESS))
2777 nd->nd_repstat = nfsvno_accchk(vp, VWRITE, nd->nd_cred,
2778 exp, p, NFSACCCHK_ALLOWOWNER, NFSACCCHK_VPISLOCKED, NULL);
2779 if (!nd->nd_repstat && (stp->ls_flags & NFSLCK_READACCESS)) {
2780 nd->nd_repstat = nfsvno_accchk(vp, VREAD, nd->nd_cred,
2781 exp, p, NFSACCCHK_ALLOWOWNER, NFSACCCHK_VPISLOCKED, NULL);
2783 nd->nd_repstat = nfsvno_accchk(vp, VEXEC,
2784 nd->nd_cred, exp, p, NFSACCCHK_ALLOWOWNER,
2785 NFSACCCHK_VPISLOCKED, NULL);
2788 if (!nd->nd_repstat) {
2789 nd->nd_repstat = nfsvno_getattr(vp, &nva, nd->nd_cred, p, 1);
2790 if (!nd->nd_repstat) {
2791 tverf[0] = nva.na_atime.tv_sec;
2792 tverf[1] = nva.na_atime.tv_nsec;
2795 if (!nd->nd_repstat && exclusive_flag && (cverf[0] != tverf[0] ||
2796 cverf[1] != tverf[1]))
2797 nd->nd_repstat = EEXIST;
2799 * Do the open locking/delegation stuff.
2801 if (!nd->nd_repstat)
2802 nd->nd_repstat = nfsrv_openctrl(nd, vp, &stp, clientid, &stateid,
2803 &delegstateid, &rflags, exp, p, nva.na_filerev);
2806 * vp must be unlocked before the call to nfsvno_getattr(dirp,...)
2807 * below, to avoid a deadlock with the lookup in nfsvno_namei() above.
2808 * (ie: Leave the NFSVOPUNLOCK() about here.)
2811 NFSVOPUNLOCK(vp, 0);
2813 FREE((caddr_t)stp, M_NFSDSTATE);
2814 if (!nd->nd_repstat && dirp)
2815 nd->nd_repstat = nfsvno_getattr(dirp, &diraft, nd->nd_cred, p,
2817 if (!nd->nd_repstat) {
2818 NFSM_BUILD(tl, u_int32_t *, NFSX_STATEID + 6 * NFSX_UNSIGNED);
2819 *tl++ = txdr_unsigned(stateid.seqid);
2820 NFSBCOPY((caddr_t)stateid.other,(caddr_t)tl,NFSX_STATEIDOTHER);
2821 tl += (NFSX_STATEIDOTHER / NFSX_UNSIGNED);
2822 if (claim == NFSV4OPEN_CLAIMPREVIOUS) {
2823 *tl++ = newnfs_true;
2829 *tl++ = newnfs_false; /* Since dirp is not locked */
2830 txdr_hyper(dirfor.na_filerev, tl);
2832 txdr_hyper(diraft.na_filerev, tl);
2835 *tl = txdr_unsigned(rflags & NFSV4OPEN_RFLAGS);
2836 (void) nfsrv_putattrbit(nd, &attrbits);
2837 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
2838 if (rflags & NFSV4OPEN_READDELEGATE)
2839 *tl = txdr_unsigned(NFSV4OPEN_DELEGATEREAD);
2840 else if (rflags & NFSV4OPEN_WRITEDELEGATE)
2841 *tl = txdr_unsigned(NFSV4OPEN_DELEGATEWRITE);
2843 *tl = txdr_unsigned(NFSV4OPEN_DELEGATENONE);
2844 if (rflags & (NFSV4OPEN_READDELEGATE|NFSV4OPEN_WRITEDELEGATE)) {
2845 NFSM_BUILD(tl, u_int32_t *, NFSX_STATEID+NFSX_UNSIGNED);
2846 *tl++ = txdr_unsigned(delegstateid.seqid);
2847 NFSBCOPY((caddr_t)delegstateid.other, (caddr_t)tl,
2849 tl += (NFSX_STATEIDOTHER / NFSX_UNSIGNED);
2850 if (rflags & NFSV4OPEN_RECALL)
2854 if (rflags & NFSV4OPEN_WRITEDELEGATE) {
2855 NFSM_BUILD(tl, u_int32_t *, 3 * NFSX_UNSIGNED);
2856 *tl++ = txdr_unsigned(NFSV4OPEN_LIMITSIZE);
2857 txdr_hyper(nva.na_size, tl);
2859 NFSM_BUILD(tl, u_int32_t *, 3 * NFSX_UNSIGNED);
2860 *tl++ = txdr_unsigned(NFSV4ACE_ALLOWEDTYPE);
2861 *tl++ = txdr_unsigned(0x0);
2862 acemask = NFSV4ACE_ALLFILESMASK;
2863 if (nva.na_mode & S_IRUSR)
2864 acemask |= NFSV4ACE_READMASK;
2865 if (nva.na_mode & S_IWUSR)
2866 acemask |= NFSV4ACE_WRITEMASK;
2867 if (nva.na_mode & S_IXUSR)
2868 acemask |= NFSV4ACE_EXECUTEMASK;
2869 *tl = txdr_unsigned(acemask);
2870 (void) nfsm_strtom(nd, "OWNER@", 6);
2878 #ifdef NFS4_ACL_EXTATTR_NAME
2881 NFSEXITCODE2(0, nd);
2885 #ifdef NFS4_ACL_EXTATTR_NAME
2889 FREE((caddr_t)stp, M_NFSDSTATE);
2890 NFSEXITCODE2(error, nd);
2895 * nfsv4 close service
2898 nfsrvd_close(struct nfsrv_descript *nd, __unused int isdgram,
2899 vnode_t vp, NFSPROC_T *p, __unused struct nfsexstuff *exp)
2902 struct nfsstate st, *stp = &st;
2904 nfsv4stateid_t stateid;
2907 NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED + NFSX_STATEID);
2908 stp->ls_seq = fxdr_unsigned(u_int32_t, *tl++);
2909 stp->ls_ownerlen = 0;
2910 stp->ls_op = nd->nd_rp;
2911 stp->ls_uid = nd->nd_cred->cr_uid;
2912 stp->ls_stateid.seqid = fxdr_unsigned(u_int32_t, *tl++);
2913 NFSBCOPY((caddr_t)tl, (caddr_t)stp->ls_stateid.other,
2915 stp->ls_flags = NFSLCK_CLOSE;
2916 clientid.lval[0] = stp->ls_stateid.other[0];
2917 clientid.lval[1] = stp->ls_stateid.other[1];
2918 if (nd->nd_flag & ND_IMPLIEDCLID) {
2919 if (nd->nd_clientid.qval != clientid.qval)
2920 printf("EEK! multiple clids\n");
2922 nd->nd_flag |= ND_IMPLIEDCLID;
2923 nd->nd_clientid.qval = clientid.qval;
2925 nd->nd_repstat = nfsrv_openupdate(vp, stp, clientid, &stateid, nd, p);
2927 if (!nd->nd_repstat) {
2928 NFSM_BUILD(tl, u_int32_t *, NFSX_STATEID);
2929 *tl++ = txdr_unsigned(stateid.seqid);
2930 NFSBCOPY((caddr_t)stateid.other,(caddr_t)tl,NFSX_STATEIDOTHER);
2932 NFSEXITCODE2(0, nd);
2936 NFSEXITCODE2(error, nd);
2941 * nfsv4 delegpurge service
2944 nfsrvd_delegpurge(struct nfsrv_descript *nd, __unused int isdgram,
2945 __unused vnode_t vp, __unused NFSPROC_T *p, __unused struct nfsexstuff *exp)
2951 if (nfs_rootfhset == 0 || nfsd_checkrootexp(nd) != 0) {
2952 nd->nd_repstat = NFSERR_WRONGSEC;
2955 NFSM_DISSECT(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
2956 clientid.lval[0] = *tl++;
2957 clientid.lval[1] = *tl;
2958 if (nd->nd_flag & ND_IMPLIEDCLID) {
2959 if (nd->nd_clientid.qval != clientid.qval)
2960 printf("EEK! multiple clids\n");
2962 nd->nd_flag |= ND_IMPLIEDCLID;
2963 nd->nd_clientid.qval = clientid.qval;
2965 nd->nd_repstat = nfsrv_delegupdate(clientid, NULL, NULL,
2966 NFSV4OP_DELEGPURGE, nd->nd_cred, p);
2968 NFSEXITCODE2(error, nd);
2973 * nfsv4 delegreturn service
2976 nfsrvd_delegreturn(struct nfsrv_descript *nd, __unused int isdgram,
2977 vnode_t vp, NFSPROC_T *p, __unused struct nfsexstuff *exp)
2981 nfsv4stateid_t stateid;
2984 NFSM_DISSECT(tl, u_int32_t *, NFSX_STATEID);
2985 stateid.seqid = fxdr_unsigned(u_int32_t, *tl++);
2986 NFSBCOPY((caddr_t)tl, (caddr_t)stateid.other, NFSX_STATEIDOTHER);
2987 clientid.lval[0] = stateid.other[0];
2988 clientid.lval[1] = stateid.other[1];
2989 if (nd->nd_flag & ND_IMPLIEDCLID) {
2990 if (nd->nd_clientid.qval != clientid.qval)
2991 printf("EEK! multiple clids\n");
2993 nd->nd_flag |= ND_IMPLIEDCLID;
2994 nd->nd_clientid.qval = clientid.qval;
2996 nd->nd_repstat = nfsrv_delegupdate(clientid, &stateid, vp,
2997 NFSV4OP_DELEGRETURN, nd->nd_cred, p);
3000 NFSEXITCODE2(error, nd);
3005 * nfsv4 get file handle service
3008 nfsrvd_getfh(struct nfsrv_descript *nd, __unused int isdgram,
3009 vnode_t vp, NFSPROC_T *p, __unused struct nfsexstuff *exp)
3013 nd->nd_repstat = nfsvno_getfh(vp, &fh, p);
3015 if (!nd->nd_repstat)
3016 (void) nfsm_fhtom(nd, (u_int8_t *)&fh, 0, 0);
3017 NFSEXITCODE2(0, nd);
3022 * nfsv4 open confirm service
3025 nfsrvd_openconfirm(struct nfsrv_descript *nd, __unused int isdgram,
3026 vnode_t vp, NFSPROC_T *p, __unused struct nfsexstuff *exp)
3029 struct nfsstate st, *stp = &st;
3031 nfsv4stateid_t stateid;
3034 NFSM_DISSECT(tl, u_int32_t *, NFSX_STATEID + NFSX_UNSIGNED);
3035 stp->ls_ownerlen = 0;
3036 stp->ls_op = nd->nd_rp;
3037 stp->ls_uid = nd->nd_cred->cr_uid;
3038 stp->ls_stateid.seqid = fxdr_unsigned(u_int32_t, *tl++);
3039 NFSBCOPY((caddr_t)tl, (caddr_t)stp->ls_stateid.other,
3041 tl += (NFSX_STATEIDOTHER / NFSX_UNSIGNED);
3042 stp->ls_seq = fxdr_unsigned(u_int32_t, *tl);
3043 stp->ls_flags = NFSLCK_CONFIRM;
3044 clientid.lval[0] = stp->ls_stateid.other[0];
3045 clientid.lval[1] = stp->ls_stateid.other[1];
3046 if (nd->nd_flag & ND_IMPLIEDCLID) {
3047 if (nd->nd_clientid.qval != clientid.qval)
3048 printf("EEK! multiple clids\n");
3050 nd->nd_flag |= ND_IMPLIEDCLID;
3051 nd->nd_clientid.qval = clientid.qval;
3053 nd->nd_repstat = nfsrv_openupdate(vp, stp, clientid, &stateid, nd, p);
3054 if (!nd->nd_repstat) {
3055 NFSM_BUILD(tl, u_int32_t *, NFSX_STATEID);
3056 *tl++ = txdr_unsigned(stateid.seqid);
3057 NFSBCOPY((caddr_t)stateid.other,(caddr_t)tl,NFSX_STATEIDOTHER);
3061 NFSEXITCODE2(error, nd);
3066 * nfsv4 open downgrade service
3069 nfsrvd_opendowngrade(struct nfsrv_descript *nd, __unused int isdgram,
3070 vnode_t vp, NFSPROC_T *p, __unused struct nfsexstuff *exp)
3074 struct nfsstate st, *stp = &st;
3076 nfsv4stateid_t stateid;
3079 NFSM_DISSECT(tl, u_int32_t *, NFSX_STATEID + 3 * NFSX_UNSIGNED);
3080 stp->ls_ownerlen = 0;
3081 stp->ls_op = nd->nd_rp;
3082 stp->ls_uid = nd->nd_cred->cr_uid;
3083 stp->ls_stateid.seqid = fxdr_unsigned(u_int32_t, *tl++);
3084 NFSBCOPY((caddr_t)tl, (caddr_t)stp->ls_stateid.other,
3086 tl += (NFSX_STATEIDOTHER / NFSX_UNSIGNED);
3087 stp->ls_seq = fxdr_unsigned(u_int32_t, *tl++);
3088 i = fxdr_unsigned(int, *tl++);
3090 case NFSV4OPEN_ACCESSREAD:
3091 stp->ls_flags = (NFSLCK_READACCESS | NFSLCK_DOWNGRADE);
3093 case NFSV4OPEN_ACCESSWRITE:
3094 stp->ls_flags = (NFSLCK_WRITEACCESS | NFSLCK_DOWNGRADE);
3096 case NFSV4OPEN_ACCESSBOTH:
3097 stp->ls_flags = (NFSLCK_READACCESS | NFSLCK_WRITEACCESS |
3101 nd->nd_repstat = NFSERR_BADXDR;
3103 i = fxdr_unsigned(int, *tl);
3105 case NFSV4OPEN_DENYNONE:
3107 case NFSV4OPEN_DENYREAD:
3108 stp->ls_flags |= NFSLCK_READDENY;
3110 case NFSV4OPEN_DENYWRITE:
3111 stp->ls_flags |= NFSLCK_WRITEDENY;
3113 case NFSV4OPEN_DENYBOTH:
3114 stp->ls_flags |= (NFSLCK_READDENY | NFSLCK_WRITEDENY);
3117 nd->nd_repstat = NFSERR_BADXDR;
3120 clientid.lval[0] = stp->ls_stateid.other[0];
3121 clientid.lval[1] = stp->ls_stateid.other[1];
3122 if (nd->nd_flag & ND_IMPLIEDCLID) {
3123 if (nd->nd_clientid.qval != clientid.qval)
3124 printf("EEK! multiple clids\n");
3126 nd->nd_flag |= ND_IMPLIEDCLID;
3127 nd->nd_clientid.qval = clientid.qval;
3129 if (!nd->nd_repstat)
3130 nd->nd_repstat = nfsrv_openupdate(vp, stp, clientid, &stateid,
3132 if (!nd->nd_repstat) {
3133 NFSM_BUILD(tl, u_int32_t *, NFSX_STATEID);
3134 *tl++ = txdr_unsigned(stateid.seqid);
3135 NFSBCOPY((caddr_t)stateid.other,(caddr_t)tl,NFSX_STATEIDOTHER);
3139 NFSEXITCODE2(error, nd);
3144 * nfsv4 renew lease service
3147 nfsrvd_renew(struct nfsrv_descript *nd, __unused int isdgram,
3148 __unused vnode_t vp, NFSPROC_T *p, __unused struct nfsexstuff *exp)
3154 if (nfs_rootfhset == 0 || nfsd_checkrootexp(nd) != 0) {
3155 nd->nd_repstat = NFSERR_WRONGSEC;
3158 NFSM_DISSECT(tl, u_int32_t *, NFSX_HYPER);
3159 clientid.lval[0] = *tl++;
3160 clientid.lval[1] = *tl;
3161 if (nd->nd_flag & ND_IMPLIEDCLID) {
3162 if (nd->nd_clientid.qval != clientid.qval)
3163 printf("EEK! multiple clids\n");
3165 nd->nd_flag |= ND_IMPLIEDCLID;
3166 nd->nd_clientid.qval = clientid.qval;
3168 nd->nd_repstat = nfsrv_getclient(clientid, (CLOPS_RENEWOP|CLOPS_RENEW),
3169 NULL, (nfsquad_t)((u_quad_t)0), nd, p);
3171 NFSEXITCODE2(error, nd);
3176 * nfsv4 security info service
3179 nfsrvd_secinfo(struct nfsrv_descript *nd, int isdgram,
3180 vnode_t dp, NFSPROC_T *p, struct nfsexstuff *exp)
3184 struct nameidata named;
3185 vnode_t dirp = NULL, vp;
3187 struct nfsexstuff retnes;
3189 int error = 0, savflag, i;
3194 * All this just to get the export flags for the name.
3196 NFSNAMEICNDSET(&named.ni_cnd, nd->nd_cred, LOOKUP,
3197 LOCKLEAF | SAVESTART);
3198 nfsvno_setpathbuf(&named, &bufp, &hashp);
3199 error = nfsrv_parsename(nd, bufp, hashp, &named.ni_pathlen);
3202 nfsvno_relpathbuf(&named);
3205 if (!nd->nd_repstat) {
3206 nd->nd_repstat = nfsvno_namei(nd, &named, dp, 1, exp, p, &dirp);
3209 nfsvno_relpathbuf(&named);
3215 vrele(named.ni_startdir);
3216 nfsvno_relpathbuf(&named);
3217 fh.nfsrvfh_len = NFSX_MYFH;
3219 nd->nd_repstat = nfsvno_getfh(vp, (fhandle_t *)fh.nfsrvfh_data, p);
3221 savflag = nd->nd_flag;
3222 if (!nd->nd_repstat) {
3223 nfsd_fhtovp(nd, &fh, LK_SHARED, &vp, &retnes, NULL, 0, p);
3227 nd->nd_flag = savflag;
3232 * Finally have the export flags for name, so we can create
3233 * the security info.
3236 NFSM_BUILD(sizp, u_int32_t *, NFSX_UNSIGNED);
3237 for (i = 0; i < retnes.nes_numsecflavor; i++) {
3238 if (retnes.nes_secflavors[i] == AUTH_SYS) {
3239 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
3240 *tl = txdr_unsigned(RPCAUTH_UNIX);
3242 } else if (retnes.nes_secflavors[i] == RPCSEC_GSS_KRB5) {
3243 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
3244 *tl++ = txdr_unsigned(RPCAUTH_GSS);
3245 (void) nfsm_strtom(nd, nfsgss_mechlist[KERBV_MECH].str,
3246 nfsgss_mechlist[KERBV_MECH].len);
3247 NFSM_BUILD(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
3248 *tl++ = txdr_unsigned(GSS_KERBV_QOP);
3249 *tl = txdr_unsigned(RPCAUTHGSS_SVCNONE);
3251 } else if (retnes.nes_secflavors[i] == RPCSEC_GSS_KRB5I) {
3252 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
3253 *tl++ = txdr_unsigned(RPCAUTH_GSS);
3254 (void) nfsm_strtom(nd, nfsgss_mechlist[KERBV_MECH].str,
3255 nfsgss_mechlist[KERBV_MECH].len);
3256 NFSM_BUILD(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
3257 *tl++ = txdr_unsigned(GSS_KERBV_QOP);
3258 *tl = txdr_unsigned(RPCAUTHGSS_SVCINTEGRITY);
3260 } else if (retnes.nes_secflavors[i] == RPCSEC_GSS_KRB5P) {
3261 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
3262 *tl++ = txdr_unsigned(RPCAUTH_GSS);
3263 (void) nfsm_strtom(nd, nfsgss_mechlist[KERBV_MECH].str,
3264 nfsgss_mechlist[KERBV_MECH].len);
3265 NFSM_BUILD(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
3266 *tl++ = txdr_unsigned(GSS_KERBV_QOP);
3267 *tl = txdr_unsigned(RPCAUTHGSS_SVCPRIVACY);
3271 *sizp = txdr_unsigned(len);
3274 NFSEXITCODE2(error, nd);
3279 * nfsv4 set client id service
3282 nfsrvd_setclientid(struct nfsrv_descript *nd, __unused int isdgram,
3283 __unused vnode_t vp, NFSPROC_T *p, __unused struct nfsexstuff *exp)
3287 int error = 0, idlen;
3288 struct nfsclient *clp = NULL;
3289 struct sockaddr_in *rad;
3290 u_char *verf, *ucp, *ucp2, addrbuf[24];
3291 nfsquad_t clientid, confirm;
3293 if (nfs_rootfhset == 0 || nfsd_checkrootexp(nd) != 0) {
3294 nd->nd_repstat = NFSERR_WRONGSEC;
3297 NFSM_DISSECT(tl, u_int32_t *, NFSX_VERF + NFSX_UNSIGNED);
3298 verf = (u_char *)tl;
3299 tl += (NFSX_VERF / NFSX_UNSIGNED);
3300 i = fxdr_unsigned(int, *tl);
3301 if (i > NFSV4_OPAQUELIMIT || i <= 0) {
3302 nd->nd_repstat = NFSERR_BADXDR;
3306 if (nd->nd_flag & ND_GSS)
3307 i += nd->nd_princlen;
3308 MALLOC(clp, struct nfsclient *, sizeof (struct nfsclient) + i,
3309 M_NFSDCLIENT, M_WAITOK);
3310 NFSBZERO((caddr_t)clp, sizeof (struct nfsclient) + i);
3311 NFSINITSOCKMUTEX(&clp->lc_req.nr_mtx);
3312 NFSSOCKADDRALLOC(clp->lc_req.nr_nam);
3313 NFSSOCKADDRSIZE(clp->lc_req.nr_nam, sizeof (struct sockaddr_in));
3314 clp->lc_req.nr_cred = NULL;
3315 NFSBCOPY(verf, clp->lc_verf, NFSX_VERF);
3316 clp->lc_idlen = idlen;
3317 error = nfsrv_mtostr(nd, clp->lc_id, idlen);
3320 if (nd->nd_flag & ND_GSS) {
3321 clp->lc_flags = LCL_GSS;
3322 if (nd->nd_flag & ND_GSSINTEGRITY)
3323 clp->lc_flags |= LCL_GSSINTEGRITY;
3324 else if (nd->nd_flag & ND_GSSPRIVACY)
3325 clp->lc_flags |= LCL_GSSPRIVACY;
3329 if ((nd->nd_flag & ND_GSS) && nd->nd_princlen > 0) {
3330 clp->lc_flags |= LCL_NAME;
3331 clp->lc_namelen = nd->nd_princlen;
3332 clp->lc_name = &clp->lc_id[idlen];
3333 NFSBCOPY(nd->nd_principal, clp->lc_name, clp->lc_namelen);
3335 clp->lc_uid = nd->nd_cred->cr_uid;
3336 clp->lc_gid = nd->nd_cred->cr_gid;
3338 NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
3339 clp->lc_program = fxdr_unsigned(u_int32_t, *tl);
3340 error = nfsrv_getclientipaddr(nd, clp);
3343 NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
3344 clp->lc_callback = fxdr_unsigned(u_int32_t, *tl);
3347 * nfsrv_setclient() does the actual work of adding it to the
3348 * client list. If there is no error, the structure has been
3349 * linked into the client list and clp should no longer be used
3350 * here. When an error is returned, it has not been linked in,
3351 * so it should be free'd.
3353 nd->nd_repstat = nfsrv_setclient(nd, &clp, &clientid, &confirm, p);
3354 if (nd->nd_repstat == NFSERR_CLIDINUSE) {
3355 if (clp->lc_flags & LCL_TCPCALLBACK)
3356 (void) nfsm_strtom(nd, "tcp", 3);
3358 (void) nfsm_strtom(nd, "udp", 3);
3359 rad = NFSSOCKADDR(clp->lc_req.nr_nam, struct sockaddr_in *);
3360 ucp = (u_char *)&rad->sin_addr.s_addr;
3361 ucp2 = (u_char *)&rad->sin_port;
3362 sprintf(addrbuf, "%d.%d.%d.%d.%d.%d", ucp[0] & 0xff,
3363 ucp[1] & 0xff, ucp[2] & 0xff, ucp[3] & 0xff,
3364 ucp2[0] & 0xff, ucp2[1] & 0xff);
3365 (void) nfsm_strtom(nd, addrbuf, strlen(addrbuf));
3368 NFSSOCKADDRFREE(clp->lc_req.nr_nam);
3369 NFSFREEMUTEX(&clp->lc_req.nr_mtx);
3370 free((caddr_t)clp, M_NFSDCLIENT);
3372 if (!nd->nd_repstat) {
3373 NFSM_BUILD(tl, u_int32_t *, 2 * NFSX_HYPER);
3374 *tl++ = clientid.lval[0];
3375 *tl++ = clientid.lval[1];
3376 *tl++ = confirm.lval[0];
3377 *tl = confirm.lval[1];
3381 NFSEXITCODE2(0, nd);
3385 NFSSOCKADDRFREE(clp->lc_req.nr_nam);
3386 NFSFREEMUTEX(&clp->lc_req.nr_mtx);
3387 free((caddr_t)clp, M_NFSDCLIENT);
3389 NFSEXITCODE2(error, nd);
3394 * nfsv4 set client id confirm service
3397 nfsrvd_setclientidcfrm(struct nfsrv_descript *nd,
3398 __unused int isdgram, __unused vnode_t vp, NFSPROC_T *p,
3399 __unused struct nfsexstuff *exp)
3403 nfsquad_t clientid, confirm;
3405 if (nfs_rootfhset == 0 || nfsd_checkrootexp(nd) != 0) {
3406 nd->nd_repstat = NFSERR_WRONGSEC;
3409 NFSM_DISSECT(tl, u_int32_t *, 2 * NFSX_HYPER);
3410 clientid.lval[0] = *tl++;
3411 clientid.lval[1] = *tl++;
3412 confirm.lval[0] = *tl++;
3413 confirm.lval[1] = *tl;
3416 * nfsrv_getclient() searches the client list for a match and
3417 * returns the appropriate NFSERR status.
3419 nd->nd_repstat = nfsrv_getclient(clientid, (CLOPS_CONFIRM|CLOPS_RENEW),
3420 NULL, confirm, nd, p);
3422 NFSEXITCODE2(error, nd);
3427 * nfsv4 verify service
3430 nfsrvd_verify(struct nfsrv_descript *nd, int isdgram,
3431 vnode_t vp, NFSPROC_T *p, __unused struct nfsexstuff *exp)
3433 int error = 0, ret, fhsize = NFSX_MYFH;
3434 struct nfsvattr nva;
3436 struct nfsfsinfo fs;
3439 nd->nd_repstat = nfsvno_getattr(vp, &nva, nd->nd_cred, p, 1);
3440 if (!nd->nd_repstat)
3441 nd->nd_repstat = nfsvno_statfs(vp, &sf);
3442 if (!nd->nd_repstat)
3443 nd->nd_repstat = nfsvno_getfh(vp, &fh, p);
3444 if (!nd->nd_repstat) {
3445 nfsvno_getfs(&fs, isdgram);
3446 error = nfsv4_loadattr(nd, vp, &nva, NULL, &fh, fhsize, NULL,
3447 &sf, NULL, &fs, NULL, 1, &ret, NULL, NULL, p, nd->nd_cred);
3449 if (nd->nd_procnum == NFSV4OP_NVERIFY) {
3451 nd->nd_repstat = NFSERR_SAME;
3452 else if (ret != NFSERR_NOTSAME)
3453 nd->nd_repstat = ret;
3455 nd->nd_repstat = ret;
3459 NFSEXITCODE2(error, nd);
3467 nfsrvd_openattr(struct nfsrv_descript *nd, __unused int isdgram,
3468 vnode_t dp, __unused vnode_t *vpp, __unused fhandle_t *fhp,
3469 __unused NFSPROC_T *p, __unused struct nfsexstuff *exp)
3472 int error = 0, createdir;
3474 NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
3475 createdir = fxdr_unsigned(int, *tl);
3476 nd->nd_repstat = NFSERR_NOTSUPP;
3479 NFSEXITCODE2(error, nd);
3484 * nfsv4 release lock owner service
3487 nfsrvd_releaselckown(struct nfsrv_descript *nd, __unused int isdgram,
3488 __unused vnode_t vp, NFSPROC_T *p, __unused struct nfsexstuff *exp)
3491 struct nfsstate *stp = NULL;
3495 if (nfs_rootfhset == 0 || nfsd_checkrootexp(nd) != 0) {
3496 nd->nd_repstat = NFSERR_WRONGSEC;
3499 NFSM_DISSECT(tl, u_int32_t *, 3 * NFSX_UNSIGNED);
3500 len = fxdr_unsigned(int, *(tl + 2));
3501 if (len <= 0 || len > NFSV4_OPAQUELIMIT) {
3502 nd->nd_repstat = NFSERR_BADXDR;
3505 MALLOC(stp, struct nfsstate *, sizeof (struct nfsstate) + len,
3506 M_NFSDSTATE, M_WAITOK);
3507 stp->ls_ownerlen = len;
3509 stp->ls_flags = NFSLCK_RELEASE;
3510 stp->ls_uid = nd->nd_cred->cr_uid;
3511 clientid.lval[0] = *tl++;
3512 clientid.lval[1] = *tl;
3513 if (nd->nd_flag & ND_IMPLIEDCLID) {
3514 if (nd->nd_clientid.qval != clientid.qval)
3515 printf("EEK! multiple clids\n");
3517 nd->nd_flag |= ND_IMPLIEDCLID;
3518 nd->nd_clientid.qval = clientid.qval;
3520 error = nfsrv_mtostr(nd, stp->ls_owner, len);
3523 nd->nd_repstat = nfsrv_releaselckown(stp, clientid, p);
3524 FREE((caddr_t)stp, M_NFSDSTATE);
3526 NFSEXITCODE2(0, nd);
3530 free((caddr_t)stp, M_NFSDSTATE);
3531 NFSEXITCODE2(error, nd);