sys/fs/nfsserver/nfs_nfsdserv.c

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