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