1/*
2 * Copyright (c) 2000-2016 Apple Inc. All rights reserved.
3 *
4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
5 *
6 * This file contains Original Code and/or Modifications of Original Code
7 * as defined in and that are subject to the Apple Public Source License
8 * Version 2.0 (the 'License'). You may not use this file except in
9 * compliance with the License. The rights granted to you under the License
10 * may not be used to create, or enable the creation or redistribution of,
11 * unlawful or unlicensed copies of an Apple operating system, or to
12 * circumvent, violate, or enable the circumvention or violation of, any
13 * terms of an Apple operating system software license agreement.
14 *
15 * Please obtain a copy of the License at
16 * http://www.opensource.apple.com/apsl/ and read it before using this file.
17 *
18 * The Original Code and all software distributed under the License are
19 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
20 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
21 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
23 * Please see the License for the specific language governing rights and
24 * limitations under the License.
25 *
26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
27 */
28/* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
29/*
30 * Copyright (c) 1989, 1993
31 * The Regents of the University of California. All rights reserved.
32 *
33 * This code is derived from software contributed to Berkeley by
34 * Rick Macklem at The University of Guelph.
35 *
36 * Redistribution and use in source and binary forms, with or without
37 * modification, are permitted provided that the following conditions
38 * are met:
39 * 1. Redistributions of source code must retain the above copyright
40 * notice, this list of conditions and the following disclaimer.
41 * 2. Redistributions in binary form must reproduce the above copyright
42 * notice, this list of conditions and the following disclaimer in the
43 * documentation and/or other materials provided with the distribution.
44 * 3. All advertising materials mentioning features or use of this software
45 * must display the following acknowledgement:
46 * This product includes software developed by the University of
47 * California, Berkeley and its contributors.
48 * 4. Neither the name of the University nor the names of its contributors
49 * may be used to endorse or promote products derived from this software
50 * without specific prior written permission.
51 *
52 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
53 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
54 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
55 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
56 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
57 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
58 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
59 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
60 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
61 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
62 * SUCH DAMAGE.
63 *
64 * @(#)nfs_subs.c 8.8 (Berkeley) 5/22/95
65 * FreeBSD-Id: nfs_subs.c,v 1.47 1997/11/07 08:53:24 phk Exp $
66 */
67
68/*
69 * These functions support the macros and help fiddle mbuf chains for
70 * the nfs op functions. They do things like create the rpc header and
71 * copy data between mbuf chains and uio lists.
72 */
73#include <sys/param.h>
74#include <sys/proc.h>
75#include <sys/kauth.h>
76#include <sys/systm.h>
77#include <sys/kernel.h>
78#include <sys/mount_internal.h>
79#include <sys/vnode_internal.h>
80#include <sys/kpi_mbuf.h>
81#include <sys/socket.h>
82#include <sys/stat.h>
83#include <sys/malloc.h>
84#include <sys/syscall.h>
85#include <sys/ubc_internal.h>
86#include <sys/fcntl.h>
87#include <sys/uio.h>
88#include <sys/domain.h>
89#include <libkern/OSAtomic.h>
90#include <kern/thread_call.h>
91
92#include <sys/vm.h>
93#include <sys/vmparam.h>
94
95#include <sys/time.h>
96#include <kern/clock.h>
97
98#include <nfs/rpcv2.h>
99#include <nfs/nfsproto.h>
100#include <nfs/nfs.h>
101#include <nfs/nfsnode.h>
102#if NFSCLIENT
103#define _NFS_XDR_SUBS_FUNCS_ /* define this to get xdrbuf function definitions */
104#endif
105#include <nfs/xdr_subs.h>
106#include <nfs/nfsm_subs.h>
107#include <nfs/nfs_gss.h>
108#include <nfs/nfsmount.h>
109#include <nfs/nfs_lock.h>
110
111#include <miscfs/specfs/specdev.h>
112
113#include <netinet/in.h>
114#include <net/kpi_interface.h>
115
116#include <sys/utfconv.h>
117
118/*
119 * NFS globals
120 */
121struct nfsstats __attribute__((aligned(8))) nfsstats;
122size_t nfs_mbuf_mhlen = 0, nfs_mbuf_minclsize = 0;
123
124/*
125 * functions to convert between NFS and VFS types
126 */
127nfstype
128vtonfs_type(enum vtype vtype, int nfsvers)
129{
130 switch (vtype) {
131 case VNON:
132 return NFNON;
133 case VREG:
134 return NFREG;
135 case VDIR:
136 return NFDIR;
137 case VBLK:
138 return NFBLK;
139 case VCHR:
140 return NFCHR;
141 case VLNK:
142 return NFLNK;
143 case VSOCK:
144 if (nfsvers > NFS_VER2)
145 return NFSOCK;
146 case VFIFO:
147 if (nfsvers > NFS_VER2)
148 return NFFIFO;
149 case VBAD:
150 case VSTR:
151 case VCPLX:
152 default:
153 return NFNON;
154 }
155}
156
157enum vtype
158nfstov_type(nfstype nvtype, int nfsvers)
159{
160 switch (nvtype) {
161 case NFNON:
162 return VNON;
163 case NFREG:
164 return VREG;
165 case NFDIR:
166 return VDIR;
167 case NFBLK:
168 return VBLK;
169 case NFCHR:
170 return VCHR;
171 case NFLNK:
172 return VLNK;
173 case NFSOCK:
174 if (nfsvers > NFS_VER2)
175 return VSOCK;
176 case NFFIFO:
177 if (nfsvers > NFS_VER2)
178 return VFIFO;
179 case NFATTRDIR:
180 if (nfsvers > NFS_VER3)
181 return VDIR;
182 case NFNAMEDATTR:
183 if (nfsvers > NFS_VER3)
184 return VREG;
185 default:
186 return VNON;
187 }
188}
189
190int
191vtonfsv2_mode(enum vtype vtype, mode_t m)
192{
193 switch (vtype) {
194 case VNON:
195 case VREG:
196 case VDIR:
197 case VBLK:
198 case VCHR:
199 case VLNK:
200 case VSOCK:
201 return vnode_makeimode(vtype, m);
202 case VFIFO:
203 return vnode_makeimode(VCHR, m);
204 case VBAD:
205 case VSTR:
206 case VCPLX:
207 default:
208 return vnode_makeimode(VNON, m);
209 }
210}
211
212#if NFSSERVER
213
214/*
215 * Mapping of old NFS Version 2 RPC numbers to generic numbers.
216 */
217int nfsv3_procid[NFS_NPROCS] = {
218 NFSPROC_NULL,
219 NFSPROC_GETATTR,
220 NFSPROC_SETATTR,
221 NFSPROC_NOOP,
222 NFSPROC_LOOKUP,
223 NFSPROC_READLINK,
224 NFSPROC_READ,
225 NFSPROC_NOOP,
226 NFSPROC_WRITE,
227 NFSPROC_CREATE,
228 NFSPROC_REMOVE,
229 NFSPROC_RENAME,
230 NFSPROC_LINK,
231 NFSPROC_SYMLINK,
232 NFSPROC_MKDIR,
233 NFSPROC_RMDIR,
234 NFSPROC_READDIR,
235 NFSPROC_FSSTAT,
236 NFSPROC_NOOP,
237 NFSPROC_NOOP,
238 NFSPROC_NOOP,
239 NFSPROC_NOOP,
240 NFSPROC_NOOP
241};
242
243#endif /* NFSSERVER */
244
245/*
246 * and the reverse mapping from generic to Version 2 procedure numbers
247 */
248int nfsv2_procid[NFS_NPROCS] = {
249 NFSV2PROC_NULL,
250 NFSV2PROC_GETATTR,
251 NFSV2PROC_SETATTR,
252 NFSV2PROC_LOOKUP,
253 NFSV2PROC_NOOP,
254 NFSV2PROC_READLINK,
255 NFSV2PROC_READ,
256 NFSV2PROC_WRITE,
257 NFSV2PROC_CREATE,
258 NFSV2PROC_MKDIR,
259 NFSV2PROC_SYMLINK,
260 NFSV2PROC_CREATE,
261 NFSV2PROC_REMOVE,
262 NFSV2PROC_RMDIR,
263 NFSV2PROC_RENAME,
264 NFSV2PROC_LINK,
265 NFSV2PROC_READDIR,
266 NFSV2PROC_NOOP,
267 NFSV2PROC_STATFS,
268 NFSV2PROC_NOOP,
269 NFSV2PROC_NOOP,
270 NFSV2PROC_NOOP,
271 NFSV2PROC_NOOP
272};
273
274
275/*
276 * initialize NFS's cache of mbuf constants
277 */
278void
279nfs_mbuf_init(void)
280{
281 struct mbuf_stat ms;
282
283 mbuf_stats(&ms);
284 nfs_mbuf_mhlen = ms.mhlen;
285 nfs_mbuf_minclsize = ms.minclsize;
286}
287
288#if NFSSERVER
289
290/*
291 * allocate a list of mbufs to hold the given amount of data
292 */
293int
294nfsm_mbuf_get_list(size_t size, mbuf_t *mp, int *mbcnt)
295{
296 int error, cnt;
297 mbuf_t mhead, mlast, m;
298 size_t len, mlen;
299
300 error = cnt = 0;
301 mhead = mlast = NULL;
302 len = 0;
303
304 while (len < size) {
305 nfsm_mbuf_get(error, &m, (size - len));
306 if (error)
307 break;
308 if (!mhead)
309 mhead = m;
310 if (mlast && ((error = mbuf_setnext(mlast, m)))) {
311 mbuf_free(m);
312 break;
313 }
314 mlen = mbuf_maxlen(m);
315 if ((len + mlen) > size)
316 mlen = size - len;
317 mbuf_setlen(m, mlen);
318 len += mlen;
319 cnt++;
320 mlast = m;
321 }
322
323 if (!error) {
324 *mp = mhead;
325 *mbcnt = cnt;
326 }
327 return (error);
328}
329
330#endif /* NFSSERVER */
331
332/*
333 * nfsm_chain_new_mbuf()
334 *
335 * Add a new mbuf to the given chain.
336 */
337int
338nfsm_chain_new_mbuf(struct nfsm_chain *nmc, size_t sizehint)
339{
340 mbuf_t mb;
341 int error = 0;
342
343 if (nmc->nmc_flags & NFSM_CHAIN_FLAG_ADD_CLUSTERS)
344 sizehint = nfs_mbuf_minclsize;
345
346 /* allocate a new mbuf */
347 nfsm_mbuf_get(error, &mb, sizehint);
348 if (error)
349 return (error);
350 if (mb == NULL)
351 panic("got NULL mbuf?");
352
353 /* do we have a current mbuf? */
354 if (nmc->nmc_mcur) {
355 /* first cap off current mbuf */
356 mbuf_setlen(nmc->nmc_mcur, nmc->nmc_ptr - (caddr_t)mbuf_data(nmc->nmc_mcur));
357 /* then append the new mbuf */
358 error = mbuf_setnext(nmc->nmc_mcur, mb);
359 if (error) {
360 mbuf_free(mb);
361 return (error);
362 }
363 }
364
365 /* set up for using the new mbuf */
366 nmc->nmc_mcur = mb;
367 nmc->nmc_ptr = mbuf_data(mb);
368 nmc->nmc_left = mbuf_trailingspace(mb);
369
370 return (0);
371}
372
373/*
374 * nfsm_chain_add_opaque_f()
375 *
376 * Add "len" bytes of opaque data pointed to by "buf" to the given chain.
377 */
378int
379nfsm_chain_add_opaque_f(struct nfsm_chain *nmc, const u_char *buf, uint32_t len)
380{
381 uint32_t paddedlen, tlen;
382 int error;
383
384 paddedlen = nfsm_rndup(len);
385
386 while (paddedlen) {
387 if (!nmc->nmc_left) {
388 error = nfsm_chain_new_mbuf(nmc, paddedlen);
389 if (error)
390 return (error);
391 }
392 tlen = MIN(nmc->nmc_left, paddedlen);
393 if (tlen) {
394 if (len) {
395 if (tlen > len)
396 tlen = len;
397 bcopy(buf, nmc->nmc_ptr, tlen);
398 } else {
399 bzero(nmc->nmc_ptr, tlen);
400 }
401 nmc->nmc_ptr += tlen;
402 nmc->nmc_left -= tlen;
403 paddedlen -= tlen;
404 if (len) {
405 buf += tlen;
406 len -= tlen;
407 }
408 }
409 }
410 return (0);
411}
412
413/*
414 * nfsm_chain_add_opaque_nopad_f()
415 *
416 * Add "len" bytes of opaque data pointed to by "buf" to the given chain.
417 * Do not XDR pad.
418 */
419int
420nfsm_chain_add_opaque_nopad_f(struct nfsm_chain *nmc, const u_char *buf, uint32_t len)
421{
422 uint32_t tlen;
423 int error;
424
425 while (len > 0) {
426 if (nmc->nmc_left <= 0) {
427 error = nfsm_chain_new_mbuf(nmc, len);
428 if (error)
429 return (error);
430 }
431 tlen = MIN(nmc->nmc_left, len);
432 bcopy(buf, nmc->nmc_ptr, tlen);
433 nmc->nmc_ptr += tlen;
434 nmc->nmc_left -= tlen;
435 len -= tlen;
436 buf += tlen;
437 }
438 return (0);
439}
440
441/*
442 * nfsm_chain_add_uio()
443 *
444 * Add "len" bytes of data from "uio" to the given chain.
445 */
446int
447nfsm_chain_add_uio(struct nfsm_chain *nmc, uio_t uio, uint32_t len)
448{
449 uint32_t paddedlen, tlen;
450 int error;
451
452 paddedlen = nfsm_rndup(len);
453
454 while (paddedlen) {
455 if (!nmc->nmc_left) {
456 error = nfsm_chain_new_mbuf(nmc, paddedlen);
457 if (error)
458 return (error);
459 }
460 tlen = MIN(nmc->nmc_left, paddedlen);
461 if (tlen) {
462 if (len) {
463 if (tlen > len)
464 tlen = len;
465 uiomove(nmc->nmc_ptr, tlen, uio);
466 } else {
467 bzero(nmc->nmc_ptr, tlen);
468 }
469 nmc->nmc_ptr += tlen;
470 nmc->nmc_left -= tlen;
471 paddedlen -= tlen;
472 if (len)
473 len -= tlen;
474 }
475 }
476 return (0);
477}
478
479/*
480 * Find the length of the NFS mbuf chain
481 * up to the current encoding/decoding offset.
482 */
483int
484nfsm_chain_offset(struct nfsm_chain *nmc)
485{
486 mbuf_t mb;
487 int len = 0;
488
489 for (mb = nmc->nmc_mhead; mb; mb = mbuf_next(mb)) {
490 if (mb == nmc->nmc_mcur)
491 return (len + (nmc->nmc_ptr - (caddr_t) mbuf_data(mb)));
492 len += mbuf_len(mb);
493 }
494
495 return (len);
496}
497
498/*
499 * nfsm_chain_advance()
500 *
501 * Advance an nfsm_chain by "len" bytes.
502 */
503int
504nfsm_chain_advance(struct nfsm_chain *nmc, uint32_t len)
505{
506 mbuf_t mb;
507
508 while (len) {
509 if (nmc->nmc_left >= len) {
510 nmc->nmc_left -= len;
511 nmc->nmc_ptr += len;
512 return (0);
513 }
514 len -= nmc->nmc_left;
515 nmc->nmc_mcur = mb = mbuf_next(nmc->nmc_mcur);
516 if (!mb)
517 return (EBADRPC);
518 nmc->nmc_ptr = mbuf_data(mb);
519 nmc->nmc_left = mbuf_len(mb);
520 }
521
522 return (0);
523}
524
525/*
526 * nfsm_chain_reverse()
527 *
528 * Reverse decode offset in an nfsm_chain by "len" bytes.
529 */
530int
531nfsm_chain_reverse(struct nfsm_chain *nmc, uint32_t len)
532{
533 uint32_t mlen, new_offset;
534 int error = 0;
535
536 mlen = nmc->nmc_ptr - (caddr_t) mbuf_data(nmc->nmc_mcur);
537 if (len <= mlen) {
538 nmc->nmc_ptr -= len;
539 nmc->nmc_left += len;
540 return (0);
541 }
542
543 new_offset = nfsm_chain_offset(nmc) - len;
544 nfsm_chain_dissect_init(error, nmc, nmc->nmc_mhead);
545 if (error)
546 return (error);
547
548 return (nfsm_chain_advance(nmc, new_offset));
549}
550
551/*
552 * nfsm_chain_get_opaque_pointer_f()
553 *
554 * Return a pointer to the next "len" bytes of contiguous data in
555 * the mbuf chain. If the next "len" bytes are not contiguous, we
556 * try to manipulate the mbuf chain so that it is.
557 *
558 * The nfsm_chain is advanced by nfsm_rndup("len") bytes.
559 */
560int
561nfsm_chain_get_opaque_pointer_f(struct nfsm_chain *nmc, uint32_t len, u_char **pptr)
562{
563 mbuf_t mbcur, mb;
564 uint32_t left, need, mblen, cplen, padlen;
565 u_char *ptr;
566 int error = 0;
567
568 /* move to next mbuf with data */
569 while (nmc->nmc_mcur && (nmc->nmc_left == 0)) {
570 mb = mbuf_next(nmc->nmc_mcur);
571 nmc->nmc_mcur = mb;
572 if (!mb)
573 break;
574 nmc->nmc_ptr = mbuf_data(mb);
575 nmc->nmc_left = mbuf_len(mb);
576 }
577 /* check if we've run out of data */
578 if (!nmc->nmc_mcur)
579 return (EBADRPC);
580
581 /* do we already have a contiguous buffer? */
582 if (nmc->nmc_left >= len) {
583 /* the returned pointer will be the current pointer */
584 *pptr = (u_char*)nmc->nmc_ptr;
585 error = nfsm_chain_advance(nmc, nfsm_rndup(len));
586 return (error);
587 }
588
589 padlen = nfsm_rndup(len) - len;
590
591 /* we need (len - left) more bytes */
592 mbcur = nmc->nmc_mcur;
593 left = nmc->nmc_left;
594 need = len - left;
595
596 if (need > mbuf_trailingspace(mbcur)) {
597 /*
598 * The needed bytes won't fit in the current mbuf so we'll
599 * allocate a new mbuf to hold the contiguous range of data.
600 */
601 nfsm_mbuf_get(error, &mb, len);
602 if (error)
603 return (error);
604 /* double check that this mbuf can hold all the data */
605 if (mbuf_maxlen(mb) < len) {
606 mbuf_free(mb);
607 return (EOVERFLOW);
608 }
609
610 /* the returned pointer will be the new mbuf's data pointer */
611 *pptr = ptr = mbuf_data(mb);
612
613 /* copy "left" bytes to the new mbuf */
614 bcopy(nmc->nmc_ptr, ptr, left);
615 ptr += left;
616 mbuf_setlen(mb, left);
617
618 /* insert the new mbuf between the current and next mbufs */
619 error = mbuf_setnext(mb, mbuf_next(mbcur));
620 if (!error)
621 error = mbuf_setnext(mbcur, mb);
622 if (error) {
623 mbuf_free(mb);
624 return (error);
625 }
626
627 /* reduce current mbuf's length by "left" */
628 mbuf_setlen(mbcur, mbuf_len(mbcur) - left);
629
630 /*
631 * update nmc's state to point at the end of the mbuf
632 * where the needed data will be copied to.
633 */
634 nmc->nmc_mcur = mbcur = mb;
635 nmc->nmc_left = 0;
636 nmc->nmc_ptr = (caddr_t)ptr;
637 } else {
638 /* The rest of the data will fit in this mbuf. */
639
640 /* the returned pointer will be the current pointer */
641 *pptr = (u_char*)nmc->nmc_ptr;
642
643 /*
644 * update nmc's state to point at the end of the mbuf
645 * where the needed data will be copied to.
646 */
647 nmc->nmc_ptr += left;
648 nmc->nmc_left = 0;
649 }
650
651 /*
652 * move the next "need" bytes into the current
653 * mbuf from the mbufs that follow
654 */
655
656 /* extend current mbuf length */
657 mbuf_setlen(mbcur, mbuf_len(mbcur) + need);
658
659 /* mb follows mbufs we're copying/compacting data from */
660 mb = mbuf_next(mbcur);
661
662 while (need && mb) {
663 /* copy as much as we need/can */
664 ptr = mbuf_data(mb);
665 mblen = mbuf_len(mb);
666 cplen = MIN(mblen, need);
667 if (cplen) {
668 bcopy(ptr, nmc->nmc_ptr, cplen);
669 /*
670 * update the mbuf's pointer and length to reflect that
671 * the data was shifted to an earlier mbuf in the chain
672 */
673 error = mbuf_setdata(mb, ptr + cplen, mblen - cplen);
674 if (error) {
675 mbuf_setlen(mbcur, mbuf_len(mbcur) - need);
676 return (error);
677 }
678 /* update pointer/need */
679 nmc->nmc_ptr += cplen;
680 need -= cplen;
681 }
682 /* if more needed, go to next mbuf */
683 if (need)
684 mb = mbuf_next(mb);
685 }
686
687 /* did we run out of data in the mbuf chain? */
688 if (need) {
689 mbuf_setlen(mbcur, mbuf_len(mbcur) - need);
690 return (EBADRPC);
691 }
692
693 /*
694 * update nmc's state to point after this contiguous data
695 *
696 * "mb" points to the last mbuf we copied data from so we
697 * just set nmc to point at whatever remains in that mbuf.
698 */
699 nmc->nmc_mcur = mb;
700 nmc->nmc_ptr = mbuf_data(mb);
701 nmc->nmc_left = mbuf_len(mb);
702
703 /* move past any padding */
704 if (padlen)
705 error = nfsm_chain_advance(nmc, padlen);
706
707 return (error);
708}
709
710/*
711 * nfsm_chain_get_opaque_f()
712 *
713 * Read the next "len" bytes in the chain into "buf".
714 * The nfsm_chain is advanced by nfsm_rndup("len") bytes.
715 */
716int
717nfsm_chain_get_opaque_f(struct nfsm_chain *nmc, uint32_t len, u_char *buf)
718{
719 uint32_t cplen, padlen;
720 int error = 0;
721
722 padlen = nfsm_rndup(len) - len;
723
724 /* loop through mbufs copying all the data we need */
725 while (len && nmc->nmc_mcur) {
726 /* copy as much as we need/can */
727 cplen = MIN(nmc->nmc_left, len);
728 if (cplen) {
729 bcopy(nmc->nmc_ptr, buf, cplen);
730 nmc->nmc_ptr += cplen;
731 nmc->nmc_left -= cplen;
732 buf += cplen;
733 len -= cplen;
734 }
735 /* if more needed, go to next mbuf */
736 if (len) {
737 mbuf_t mb = mbuf_next(nmc->nmc_mcur);
738 nmc->nmc_mcur = mb;
739 nmc->nmc_ptr = mb ? mbuf_data(mb) : NULL;
740 nmc->nmc_left = mb ? mbuf_len(mb) : 0;
741 }
742 }
743
744 /* did we run out of data in the mbuf chain? */
745 if (len)
746 return (EBADRPC);
747
748 if (padlen)
749 nfsm_chain_adv(error, nmc, padlen);
750
751 return (error);
752}
753
754/*
755 * nfsm_chain_get_uio()
756 *
757 * Read the next "len" bytes in the chain into the given uio.
758 * The nfsm_chain is advanced by nfsm_rndup("len") bytes.
759 */
760int
761nfsm_chain_get_uio(struct nfsm_chain *nmc, uint32_t len, uio_t uio)
762{
763 uint32_t cplen, padlen;
764 int error = 0;
765
766 padlen = nfsm_rndup(len) - len;
767
768 /* loop through mbufs copying all the data we need */
769 while (len && nmc->nmc_mcur) {
770 /* copy as much as we need/can */
771 cplen = MIN(nmc->nmc_left, len);
772 if (cplen) {
773 error = uiomove(nmc->nmc_ptr, cplen, uio);
774 if (error)
775 return (error);
776 nmc->nmc_ptr += cplen;
777 nmc->nmc_left -= cplen;
778 len -= cplen;
779 }
780 /* if more needed, go to next mbuf */
781 if (len) {
782 mbuf_t mb = mbuf_next(nmc->nmc_mcur);
783 nmc->nmc_mcur = mb;
784 nmc->nmc_ptr = mb ? mbuf_data(mb) : NULL;
785 nmc->nmc_left = mb ? mbuf_len(mb) : 0;
786 }
787 }
788
789 /* did we run out of data in the mbuf chain? */
790 if (len)
791 return (EBADRPC);
792
793 if (padlen)
794 nfsm_chain_adv(error, nmc, padlen);
795
796 return (error);
797}
798
799#if NFSCLIENT
800
801int
802nfsm_chain_add_string_nfc(struct nfsm_chain *nmc, const uint8_t *s, uint32_t slen)
803{
804 uint8_t smallbuf[64];
805 uint8_t *nfcname = smallbuf;
806 size_t buflen = sizeof(smallbuf), nfclen;
807 int error;
808
809 error = utf8_normalizestr(s, slen, nfcname, &nfclen, buflen, UTF_PRECOMPOSED|UTF_NO_NULL_TERM);
810 if (error == ENAMETOOLONG) {
811 buflen = MAXPATHLEN;
812 MALLOC_ZONE(nfcname, uint8_t *, MAXPATHLEN, M_NAMEI, M_WAITOK);
813 if (nfcname)
814 error = utf8_normalizestr(s, slen, nfcname, &nfclen, buflen, UTF_PRECOMPOSED|UTF_NO_NULL_TERM);
815 }
816
817 /* if we got an error, just use the original string */
818 if (error)
819 nfsm_chain_add_string(error, nmc, s, slen);
820 else
821 nfsm_chain_add_string(error, nmc, nfcname, nfclen);
822
823 if (nfcname && (nfcname != smallbuf))
824 FREE_ZONE(nfcname, MAXPATHLEN, M_NAMEI);
825 return (error);
826}
827
828/*
829 * Add an NFSv2 "sattr" structure to an mbuf chain
830 */
831int
832nfsm_chain_add_v2sattr_f(struct nfsm_chain *nmc, struct vnode_attr *vap, uint32_t szrdev)
833{
834 int error = 0;
835
836 nfsm_chain_add_32(error, nmc, vtonfsv2_mode(vap->va_type,
837 (VATTR_IS_ACTIVE(vap, va_mode) ? vap->va_mode : 0600)));
838 nfsm_chain_add_32(error, nmc,
839 VATTR_IS_ACTIVE(vap, va_uid) ? vap->va_uid : (uint32_t)-1);
840 nfsm_chain_add_32(error, nmc,
841 VATTR_IS_ACTIVE(vap, va_gid) ? vap->va_gid : (uint32_t)-1);
842 nfsm_chain_add_32(error, nmc, szrdev);
843 nfsm_chain_add_v2time(error, nmc,
844 VATTR_IS_ACTIVE(vap, va_access_time) ?
845 &vap->va_access_time : NULL);
846 nfsm_chain_add_v2time(error, nmc,
847 VATTR_IS_ACTIVE(vap, va_modify_time) ?
848 &vap->va_modify_time : NULL);
849
850 return (error);
851}
852
853/*
854 * Add an NFSv3 "sattr" structure to an mbuf chain
855 */
856int
857nfsm_chain_add_v3sattr_f(struct nfsm_chain *nmc, struct vnode_attr *vap)
858{
859 int error = 0;
860
861 if (VATTR_IS_ACTIVE(vap, va_mode)) {
862 nfsm_chain_add_32(error, nmc, TRUE);
863 nfsm_chain_add_32(error, nmc, vap->va_mode);
864 } else {
865 nfsm_chain_add_32(error, nmc, FALSE);
866 }
867 if (VATTR_IS_ACTIVE(vap, va_uid)) {
868 nfsm_chain_add_32(error, nmc, TRUE);
869 nfsm_chain_add_32(error, nmc, vap->va_uid);
870 } else {
871 nfsm_chain_add_32(error, nmc, FALSE);
872 }
873 if (VATTR_IS_ACTIVE(vap, va_gid)) {
874 nfsm_chain_add_32(error, nmc, TRUE);
875 nfsm_chain_add_32(error, nmc, vap->va_gid);
876 } else {
877 nfsm_chain_add_32(error, nmc, FALSE);
878 }
879 if (VATTR_IS_ACTIVE(vap, va_data_size)) {
880 nfsm_chain_add_32(error, nmc, TRUE);
881 nfsm_chain_add_64(error, nmc, vap->va_data_size);
882 } else {
883 nfsm_chain_add_32(error, nmc, FALSE);
884 }
885 if (vap->va_vaflags & VA_UTIMES_NULL) {
886 nfsm_chain_add_32(error, nmc, NFS_TIME_SET_TO_SERVER);
887 nfsm_chain_add_32(error, nmc, NFS_TIME_SET_TO_SERVER);
888 } else {
889 if (VATTR_IS_ACTIVE(vap, va_access_time)) {
890 nfsm_chain_add_32(error, nmc, NFS_TIME_SET_TO_CLIENT);
891 nfsm_chain_add_32(error, nmc, vap->va_access_time.tv_sec);
892 nfsm_chain_add_32(error, nmc, vap->va_access_time.tv_nsec);
893 } else {
894 nfsm_chain_add_32(error, nmc, NFS_TIME_DONT_CHANGE);
895 }
896 if (VATTR_IS_ACTIVE(vap, va_modify_time)) {
897 nfsm_chain_add_32(error, nmc, NFS_TIME_SET_TO_CLIENT);
898 nfsm_chain_add_32(error, nmc, vap->va_modify_time.tv_sec);
899 nfsm_chain_add_32(error, nmc, vap->va_modify_time.tv_nsec);
900 } else {
901 nfsm_chain_add_32(error, nmc, NFS_TIME_DONT_CHANGE);
902 }
903 }
904
905 return (error);
906}
907
908
909/*
910 * nfsm_chain_get_fh_attr()
911 *
912 * Get the file handle and attributes from an mbuf chain. (NFSv2/v3)
913 */
914int
915nfsm_chain_get_fh_attr(
916 struct nfsm_chain *nmc,
917 nfsnode_t dnp,
918 vfs_context_t ctx,
919 int nfsvers,
920 uint64_t *xidp,
921 fhandle_t *fhp,
922 struct nfs_vattr *nvap)
923{
924 int error = 0, gotfh, gotattr;
925
926 gotfh = gotattr = 1;
927
928 if (nfsvers == NFS_VER3) /* check for file handle */
929 nfsm_chain_get_32(error, nmc, gotfh);
930 if (!error && gotfh) /* get file handle */
931 nfsm_chain_get_fh(error, nmc, nfsvers, fhp);
932 else
933 fhp->fh_len = 0;
934 if (nfsvers == NFS_VER3) /* check for file attributes */
935 nfsm_chain_get_32(error, nmc, gotattr);
936 nfsmout_if(error);
937 if (gotattr) {
938 if (!gotfh) /* skip attributes */
939 nfsm_chain_adv(error, nmc, NFSX_V3FATTR);
940 else /* get attributes */
941 error = nfs_parsefattr(nmc, nfsvers, nvap);
942 } else if (gotfh) {
943 /* we need valid attributes in order to call nfs_nget() */
944 if (nfs3_getattr_rpc(NULL, NFSTOMP(dnp), fhp->fh_data, fhp->fh_len, 0, ctx, nvap, xidp)) {
945 gotattr = 0;
946 fhp->fh_len = 0;
947 }
948 }
949nfsmout:
950 return (error);
951}
952
953/*
954 * Get and process NFSv3 WCC data from an mbuf chain
955 */
956int
957nfsm_chain_get_wcc_data_f(
958 struct nfsm_chain *nmc,
959 nfsnode_t np,
960 struct timespec *premtime,
961 int *newpostattr,
962 u_int64_t *xidp)
963{
964 int error = 0;
965 uint32_t flag = 0;
966
967 nfsm_chain_get_32(error, nmc, flag);
968 if (!error && flag) {
969 nfsm_chain_adv(error, nmc, 2 * NFSX_UNSIGNED);
970 nfsm_chain_get_32(error, nmc, premtime->tv_sec);
971 nfsm_chain_get_32(error, nmc, premtime->tv_nsec);
972 nfsm_chain_adv(error, nmc, 2 * NFSX_UNSIGNED);
973 } else {
974 premtime->tv_sec = 0;
975 premtime->tv_nsec = 0;
976 }
977 nfsm_chain_postop_attr_update_flag(error, nmc, np, *newpostattr, xidp);
978
979 return (error);
980}
981
982/*
983 * Get the next RPC transaction ID (XID)
984 */
985void
986nfs_get_xid(uint64_t *xidp)
987{
988 struct timeval tv;
989
990 lck_mtx_lock(nfs_request_mutex);
991 if (!nfs_xid) {
992 /*
993 * Derive initial xid from system time.
994 *
995 * Note: it's OK if this code inits nfs_xid to 0 (for example,
996 * due to a broken clock) because we immediately increment it
997 * and we guarantee to never use xid 0. So, nfs_xid should only
998 * ever be 0 the first time this function is called.
999 */
1000 microtime(&tv);
1001 nfs_xid = tv.tv_sec << 12;
1002 }
1003 if (++nfs_xid == 0) {
1004 /* Skip zero xid if it should ever happen. */
1005 nfs_xidwrap++;
1006 nfs_xid++;
1007 }
1008 *xidp = nfs_xid + ((uint64_t)nfs_xidwrap << 32);
1009 lck_mtx_unlock(nfs_request_mutex);
1010}
1011
1012/*
1013 * Build the RPC header and fill in the authorization info.
1014 * Returns the head of the mbuf list and the xid.
1015 */
1016
1017int
1018nfsm_rpchead(
1019 struct nfsreq *req,
1020 mbuf_t mrest,
1021 u_int64_t *xidp,
1022 mbuf_t *mreqp)
1023{
1024 struct nfsmount *nmp = req->r_nmp;
1025 int nfsvers = nmp->nm_vers;
1026 int proc = ((nfsvers == NFS_VER2) ? nfsv2_procid[req->r_procnum] : (int)req->r_procnum);
1027
1028 return nfsm_rpchead2(nmp, nmp->nm_sotype, NFS_PROG, nfsvers, proc,
1029 req->r_auth, req->r_cred, req, mrest, xidp, mreqp);
1030}
1031
1032/*
1033 * get_auiliary_groups: Gets the supplementary groups from a credential.
1034 *
1035 * IN: cred: credential to get the associated groups from.
1036 * OUT: groups: An array of gids of NGROUPS size.
1037 * IN: count: The number of groups to get; i.e.; the number of groups the server supports
1038 *
1039 * returns: The number of groups found.
1040 *
1041 * Just a wrapper around kauth_cred_getgroups to handle the case of a server supporting less
1042 * than NGROUPS.
1043 */
1044static int
1045get_auxiliary_groups(kauth_cred_t cred, gid_t groups[NGROUPS], int count)
1046{
1047 gid_t pgid;
1048 int maxcount = count < NGROUPS ? count + 1 : NGROUPS;
1049 int i;
1050
1051 for (i = 0; i < NGROUPS; i++)
1052 groups[i] = -2; /* Initialize to the nobody group */
1053
1054 (void)kauth_cred_getgroups(cred, groups, &maxcount);
1055 if (maxcount < 1)
1056 return (maxcount);
1057
1058 /*
1059 * kauth_get_groups returns the primary group followed by the
1060 * users auxiliary groups. If the number of groups the server supports
1061 * is less than NGROUPS, then we will drop the first group so that
1062 * we can send one more group over the wire.
1063 */
1064
1065
1066 if (count < NGROUPS) {
1067 pgid = kauth_cred_getgid(cred);
1068 if (pgid == groups[0]) {
1069 maxcount -= 1;
1070 for (i = 0; i < maxcount; i++) {
1071 groups[i] = groups[i+1];
1072 }
1073 }
1074 }
1075
1076 return (maxcount);
1077}
1078
1079int
1080nfsm_rpchead2(struct nfsmount *nmp, int sotype, int prog, int vers, int proc, int auth_type,
1081 kauth_cred_t cred, struct nfsreq *req, mbuf_t mrest, u_int64_t *xidp, mbuf_t *mreqp)
1082{
1083 mbuf_t mreq, mb;
1084 int error, i, auth_len = 0, authsiz, reqlen;
1085 size_t headlen;
1086 struct nfsm_chain nmreq;
1087 gid_t grouplist[NGROUPS];
1088 int groupcount;
1089
1090 /* calculate expected auth length */
1091 switch (auth_type) {
1092 case RPCAUTH_NONE:
1093 auth_len = 0;
1094 break;
1095 case RPCAUTH_SYS:
1096 {
1097 int count = nmp->nm_numgrps < NGROUPS ? nmp->nm_numgrps : NGROUPS;
1098
1099 if (!cred)
1100 return (EINVAL);
1101 groupcount = get_auxiliary_groups(cred, grouplist, count);
1102 if (groupcount < 0)
1103 return (EINVAL);
1104 auth_len = ((uint32_t)groupcount + 5) * NFSX_UNSIGNED;
1105 break;
1106 }
1107 case RPCAUTH_KRB5:
1108 case RPCAUTH_KRB5I:
1109 case RPCAUTH_KRB5P:
1110 if (!req || !cred)
1111 return (EINVAL);
1112 auth_len = 5 * NFSX_UNSIGNED + 0; // zero context handle for now
1113 break;
1114 default:
1115 return (EINVAL);
1116 }
1117 authsiz = nfsm_rndup(auth_len);
1118
1119 /* allocate the packet */
1120 headlen = authsiz + 10 * NFSX_UNSIGNED;
1121 if (sotype == SOCK_STREAM) /* also include room for any RPC Record Mark */
1122 headlen += NFSX_UNSIGNED;
1123 if (headlen >= nfs_mbuf_minclsize) {
1124 error = mbuf_getpacket(MBUF_WAITOK, &mreq);
1125 } else {
1126 error = mbuf_gethdr(MBUF_WAITOK, MBUF_TYPE_DATA, &mreq);
1127 if (!error) {
1128 if (headlen < nfs_mbuf_mhlen)
1129 mbuf_align_32(mreq, headlen);
1130 else
1131 mbuf_align_32(mreq, 8 * NFSX_UNSIGNED);
1132 }
1133 }
1134 if (error) {
1135 /* unable to allocate packet */
1136 /* XXX should we keep statistics for these errors? */
1137 return (error);
1138 }
1139
1140 /*
1141 * If the caller gave us a non-zero XID then use it because
1142 * it may be a higher-level resend with a GSSAPI credential.
1143 * Otherwise, allocate a new one.
1144 */
1145 if (*xidp == 0)
1146 nfs_get_xid(xidp);
1147
1148 /* build the header(s) */
1149 nfsm_chain_init(&nmreq, mreq);
1150
1151 /* First, if it's a TCP stream insert space for an RPC record mark */
1152 if (sotype == SOCK_STREAM)
1153 nfsm_chain_add_32(error, &nmreq, 0);
1154
1155 /* Then the RPC header. */
1156 nfsm_chain_add_32(error, &nmreq, (*xidp & 0xffffffff));
1157 nfsm_chain_add_32(error, &nmreq, RPC_CALL);
1158 nfsm_chain_add_32(error, &nmreq, RPC_VER2);
1159 nfsm_chain_add_32(error, &nmreq, prog);
1160 nfsm_chain_add_32(error, &nmreq, vers);
1161 nfsm_chain_add_32(error, &nmreq, proc);
1162
1163add_cred:
1164 switch (auth_type) {
1165 case RPCAUTH_NONE:
1166 nfsm_chain_add_32(error, &nmreq, RPCAUTH_NONE); /* auth */
1167 nfsm_chain_add_32(error, &nmreq, 0); /* length */
1168 nfsm_chain_add_32(error, &nmreq, RPCAUTH_NONE); /* verf */
1169 nfsm_chain_add_32(error, &nmreq, 0); /* length */
1170 nfsm_chain_build_done(error, &nmreq);
1171 /* Append the args mbufs */
1172 if (!error)
1173 error = mbuf_setnext(nmreq.nmc_mcur, mrest);
1174 break;
1175 case RPCAUTH_SYS: {
1176 nfsm_chain_add_32(error, &nmreq, RPCAUTH_SYS);
1177 nfsm_chain_add_32(error, &nmreq, authsiz);
1178 nfsm_chain_add_32(error, &nmreq, 0); /* stamp */
1179 nfsm_chain_add_32(error, &nmreq, 0); /* zero-length hostname */
1180 nfsm_chain_add_32(error, &nmreq, kauth_cred_getuid(cred)); /* UID */
1181 nfsm_chain_add_32(error, &nmreq, kauth_cred_getgid(cred)); /* GID */
1182 nfsm_chain_add_32(error, &nmreq, groupcount);/* additional GIDs */
1183 for (i = 0; i < groupcount; i++)
1184 nfsm_chain_add_32(error, &nmreq, grouplist[i]);
1185
1186 /* And the verifier... */
1187 nfsm_chain_add_32(error, &nmreq, RPCAUTH_NONE); /* flavor */
1188 nfsm_chain_add_32(error, &nmreq, 0); /* length */
1189 nfsm_chain_build_done(error, &nmreq);
1190
1191 /* Append the args mbufs */
1192 if (!error)
1193 error = mbuf_setnext(nmreq.nmc_mcur, mrest);
1194 break;
1195 }
1196 case RPCAUTH_KRB5:
1197 case RPCAUTH_KRB5I:
1198 case RPCAUTH_KRB5P:
1199 error = nfs_gss_clnt_cred_put(req, &nmreq, mrest);
1200 if (error == ENEEDAUTH) {
1201 int count = nmp->nm_numgrps < NGROUPS ? nmp->nm_numgrps : NGROUPS;
1202
1203 /*
1204 * Use sec=sys for this user
1205 */
1206 error = 0;
1207 req->r_auth = auth_type = RPCAUTH_SYS;
1208 groupcount = get_auxiliary_groups(cred, grouplist, count);
1209 if (groupcount < 0)
1210 return (EINVAL);
1211 auth_len = ((uint32_t)groupcount + 5) * NFSX_UNSIGNED;
1212 authsiz = nfsm_rndup(auth_len);
1213 goto add_cred;
1214 }
1215 break;
1216 };
1217
1218 /* finish setting up the packet */
1219 if (!error)
1220 error = mbuf_pkthdr_setrcvif(mreq, 0);
1221
1222 if (error) {
1223 mbuf_freem(mreq);
1224 return (error);
1225 }
1226
1227 /* Calculate the size of the request */
1228 reqlen = 0;
1229 for (mb = nmreq.nmc_mhead; mb; mb = mbuf_next(mb))
1230 reqlen += mbuf_len(mb);
1231
1232 mbuf_pkthdr_setlen(mreq, reqlen);
1233
1234 /*
1235 * If the request goes on a TCP stream,
1236 * set its size in the RPC record mark.
1237 * The record mark count doesn't include itself
1238 * and the last fragment bit is set.
1239 */
1240 if (sotype == SOCK_STREAM)
1241 nfsm_chain_set_recmark(error, &nmreq,
1242 (reqlen - NFSX_UNSIGNED) | 0x80000000);
1243
1244 *mreqp = mreq;
1245 return (0);
1246}
1247
1248/*
1249 * Parse an NFS file attribute structure out of an mbuf chain.
1250 */
1251int
1252nfs_parsefattr(struct nfsm_chain *nmc, int nfsvers, struct nfs_vattr *nvap)
1253{
1254 int error = 0;
1255 enum vtype vtype;
1256 nfstype nvtype;
1257 u_short vmode;
1258 uint32_t val, val2;
1259 dev_t rdev;
1260
1261 val = val2 = 0;
1262 NVATTR_INIT(nvap);
1263
1264 NFS_BITMAP_SET(nvap->nva_bitmap, NFS_FATTR_TYPE);
1265 NFS_BITMAP_SET(nvap->nva_bitmap, NFS_FATTR_MODE);
1266 NFS_BITMAP_SET(nvap->nva_bitmap, NFS_FATTR_NUMLINKS);
1267 NFS_BITMAP_SET(nvap->nva_bitmap, NFS_FATTR_OWNER);
1268 NFS_BITMAP_SET(nvap->nva_bitmap, NFS_FATTR_OWNER_GROUP);
1269 NFS_BITMAP_SET(nvap->nva_bitmap, NFS_FATTR_SIZE);
1270 NFS_BITMAP_SET(nvap->nva_bitmap, NFS_FATTR_SPACE_USED);
1271 NFS_BITMAP_SET(nvap->nva_bitmap, NFS_FATTR_RAWDEV);
1272 NFS_BITMAP_SET(nvap->nva_bitmap, NFS_FATTR_FSID);
1273 NFS_BITMAP_SET(nvap->nva_bitmap, NFS_FATTR_FILEID);
1274 NFS_BITMAP_SET(nvap->nva_bitmap, NFS_FATTR_TIME_ACCESS);
1275 NFS_BITMAP_SET(nvap->nva_bitmap, NFS_FATTR_TIME_MODIFY);
1276 NFS_BITMAP_SET(nvap->nva_bitmap, NFS_FATTR_TIME_METADATA);
1277
1278 nfsm_chain_get_32(error, nmc, nvtype);
1279 nfsm_chain_get_32(error, nmc, vmode);
1280 nfsmout_if(error);
1281
1282 if (nfsvers == NFS_VER3) {
1283 nvap->nva_type = vtype = nfstov_type(nvtype, nfsvers);
1284 } else {
1285 /*
1286 * The duplicate information returned in fa_type and fa_mode
1287 * is an ambiguity in the NFS version 2 protocol.
1288 *
1289 * VREG should be taken literally as a regular file. If a
1290 * server intends to return some type information differently
1291 * in the upper bits of the mode field (e.g. for sockets, or
1292 * FIFOs), NFSv2 mandates fa_type to be VNON. Anyway, we
1293 * leave the examination of the mode bits even in the VREG
1294 * case to avoid breakage for bogus servers, but we make sure
1295 * that there are actually type bits set in the upper part of
1296 * fa_mode (and failing that, trust the va_type field).
1297 *
1298 * NFSv3 cleared the issue, and requires fa_mode to not
1299 * contain any type information (while also introducing
1300 * sockets and FIFOs for fa_type).
1301 */
1302 vtype = nfstov_type(nvtype, nfsvers);
1303 if ((vtype == VNON) || ((vtype == VREG) && ((vmode & S_IFMT) != 0)))
1304 vtype = IFTOVT(vmode);
1305 nvap->nva_type = vtype;
1306 }
1307
1308 nvap->nva_mode = (vmode & 07777);
1309
1310 nfsm_chain_get_32(error, nmc, nvap->nva_nlink);
1311 nfsm_chain_get_32(error, nmc, nvap->nva_uid);
1312 nfsm_chain_get_32(error, nmc, nvap->nva_gid);
1313
1314 if (nfsvers == NFS_VER3) {
1315 nfsm_chain_get_64(error, nmc, nvap->nva_size);
1316 nfsm_chain_get_64(error, nmc, nvap->nva_bytes);
1317 nfsm_chain_get_32(error, nmc, nvap->nva_rawdev.specdata1);
1318 nfsm_chain_get_32(error, nmc, nvap->nva_rawdev.specdata2);
1319 nfsmout_if(error);
1320 nfsm_chain_get_64(error, nmc, nvap->nva_fsid.major);
1321 nvap->nva_fsid.minor = 0;
1322 nfsm_chain_get_64(error, nmc, nvap->nva_fileid);
1323 } else {
1324 nfsm_chain_get_32(error, nmc, nvap->nva_size);
1325 nfsm_chain_adv(error, nmc, NFSX_UNSIGNED);
1326 nfsm_chain_get_32(error, nmc, rdev);
1327 nfsmout_if(error);
1328 nvap->nva_rawdev.specdata1 = major(rdev);
1329 nvap->nva_rawdev.specdata2 = minor(rdev);
1330 nfsm_chain_get_32(error, nmc, val); /* blocks */
1331 nfsmout_if(error);
1332 nvap->nva_bytes = val * NFS_FABLKSIZE;
1333 nfsm_chain_get_32(error, nmc, val);
1334 nfsmout_if(error);
1335 nvap->nva_fsid.major = (uint64_t)val;
1336 nvap->nva_fsid.minor = 0;
1337 nfsm_chain_get_32(error, nmc, val);
1338 nfsmout_if(error);
1339 nvap->nva_fileid = (uint64_t)val;
1340 /* Really ugly NFSv2 kludge. */
1341 if ((vtype == VCHR) && (rdev == (dev_t)0xffffffff))
1342 nvap->nva_type = VFIFO;
1343 }
1344 nfsm_chain_get_time(error, nmc, nfsvers,
1345 nvap->nva_timesec[NFSTIME_ACCESS],
1346 nvap->nva_timensec[NFSTIME_ACCESS]);
1347 nfsm_chain_get_time(error, nmc, nfsvers,
1348 nvap->nva_timesec[NFSTIME_MODIFY],
1349 nvap->nva_timensec[NFSTIME_MODIFY]);
1350 nfsm_chain_get_time(error, nmc, nfsvers,
1351 nvap->nva_timesec[NFSTIME_CHANGE],
1352 nvap->nva_timensec[NFSTIME_CHANGE]);
1353nfsmout:
1354 return (error);
1355}
1356
1357/*
1358 * Load the attribute cache (that lives in the nfsnode entry) with
1359 * the value pointed to by nvap, unless the file type in the attribute
1360 * cache doesn't match the file type in the nvap, in which case log a
1361 * warning and return ESTALE.
1362 *
1363 * If the dontshrink flag is set, then it's not safe to call ubc_setsize()
1364 * to shrink the size of the file.
1365 */
1366int
1367nfs_loadattrcache(
1368 nfsnode_t np,
1369 struct nfs_vattr *nvap,
1370 u_int64_t *xidp,
1371 int dontshrink)
1372{
1373 mount_t mp;
1374 vnode_t vp;
1375 struct timeval now;
1376 struct nfs_vattr *npnvap;
1377 int xattr = np->n_vattr.nva_flags & NFS_FFLAG_IS_ATTR;
1378 int referral = np->n_vattr.nva_flags & NFS_FFLAG_TRIGGER_REFERRAL;
1379 int aclbit, monitored, error = 0;
1380 kauth_acl_t acl;
1381 struct nfsmount *nmp;
1382 uint32_t events = np->n_events;
1383
1384 if (np->n_hflag & NHINIT) {
1385 vp = NULL;
1386 mp = np->n_mount;
1387 } else {
1388 vp = NFSTOV(np);
1389 mp = vnode_mount(vp);
1390 }
1391 monitored = vp ? vnode_ismonitored(vp) : 0;
1392
1393 FSDBG_TOP(527, np, vp, *xidp >> 32, *xidp);
1394
1395 if (!((nmp = VFSTONFS(mp)))) {
1396 FSDBG_BOT(527, ENXIO, 1, 0, *xidp);
1397 return (ENXIO);
1398 }
1399
1400 if (*xidp < np->n_xid) {
1401 /*
1402 * We have already updated attributes with a response from
1403 * a later request. The attributes we have here are probably
1404 * stale so we drop them (just return). However, our
1405 * out-of-order receipt could be correct - if the requests were
1406 * processed out of order at the server. Given the uncertainty
1407 * we invalidate our cached attributes. *xidp is zeroed here
1408 * to indicate the attributes were dropped - only getattr
1409 * cares - it needs to retry the rpc.
1410 */
1411 NATTRINVALIDATE(np);
1412 FSDBG_BOT(527, 0, np, np->n_xid, *xidp);
1413 *xidp = 0;
1414 return (0);
1415 }
1416
1417 if (vp && (nvap->nva_type != vnode_vtype(vp))) {
1418 /*
1419 * The filehandle has changed type on us. This can be
1420 * caused by either the server not having unique filehandles
1421 * or because another client has removed the previous
1422 * filehandle and a new object (of a different type)
1423 * has been created with the same filehandle.
1424 *
1425 * We can't simply switch the type on the vnode because
1426 * there may be type-specific fields that need to be
1427 * cleaned up or set up.
1428 *
1429 * So, what should we do with this vnode?
1430 *
1431 * About the best we can do is log a warning and return
1432 * an error. ESTALE is about the closest error, but it
1433 * is a little strange that we come up with this error
1434 * internally instead of simply passing it through from
1435 * the server. Hopefully, the vnode will be reclaimed
1436 * soon so the filehandle can be reincarnated as the new
1437 * object type.
1438 */
1439 printf("nfs loadattrcache vnode changed type, was %d now %d\n",
1440 vnode_vtype(vp), nvap->nva_type);
1441 error = ESTALE;
1442 if (monitored)
1443 events |= VNODE_EVENT_DELETE;
1444 goto out;
1445 }
1446
1447 npnvap = &np->n_vattr;
1448
1449 /*
1450 * The ACL cache needs special handling because it is not
1451 * always updated. Save current ACL cache state so it can
1452 * be restored after copying the new attributes into place.
1453 */
1454 aclbit = NFS_BITMAP_ISSET(npnvap->nva_bitmap, NFS_FATTR_ACL);
1455 acl = npnvap->nva_acl;
1456
1457 if (monitored) {
1458 /*
1459 * For monitored nodes, check for attribute changes that should generate events.
1460 */
1461 if (NFS_BITMAP_ISSET(nvap->nva_bitmap, NFS_FATTR_NUMLINKS) &&
1462 (nvap->nva_nlink != npnvap->nva_nlink))
1463 events |= VNODE_EVENT_ATTRIB | VNODE_EVENT_LINK;
1464 if (events & VNODE_EVENT_PERMS)
1465 /* no need to do all the checking if it's already set */;
1466 else if (NFS_BITMAP_ISSET(nvap->nva_bitmap, NFS_FATTR_MODE) &&
1467 (nvap->nva_mode != npnvap->nva_mode))
1468 events |= VNODE_EVENT_ATTRIB | VNODE_EVENT_PERMS;
1469 else if (NFS_BITMAP_ISSET(nvap->nva_bitmap, NFS_FATTR_OWNER) &&
1470 (nvap->nva_uid != npnvap->nva_uid))
1471 events |= VNODE_EVENT_ATTRIB | VNODE_EVENT_PERMS;
1472 else if (NFS_BITMAP_ISSET(nvap->nva_bitmap, NFS_FATTR_OWNER_GROUP) &&
1473 (nvap->nva_gid != npnvap->nva_gid))
1474 events |= VNODE_EVENT_ATTRIB | VNODE_EVENT_PERMS;
1475 else if (nmp->nm_vers >= NFS_VER4) {
1476 if (NFS_BITMAP_ISSET(nvap->nva_bitmap, NFS_FATTR_OWNER) &&
1477 !kauth_guid_equal(&nvap->nva_uuuid, &npnvap->nva_uuuid))
1478 events |= VNODE_EVENT_ATTRIB | VNODE_EVENT_PERMS;
1479 else if (NFS_BITMAP_ISSET(nvap->nva_bitmap, NFS_FATTR_OWNER_GROUP) &&
1480 !kauth_guid_equal(&nvap->nva_guuid, &npnvap->nva_guuid))
1481 events |= VNODE_EVENT_ATTRIB | VNODE_EVENT_PERMS;
1482 else if ((NFS_BITMAP_ISSET(nvap->nva_bitmap, NFS_FATTR_ACL) &&
1483 nvap->nva_acl && npnvap->nva_acl &&
1484 ((nvap->nva_acl->acl_entrycount != npnvap->nva_acl->acl_entrycount) ||
1485 bcmp(nvap->nva_acl, npnvap->nva_acl, KAUTH_ACL_COPYSIZE(nvap->nva_acl)))))
1486 events |= VNODE_EVENT_ATTRIB | VNODE_EVENT_PERMS;
1487 }
1488 if (((nmp->nm_vers >= NFS_VER4) && (nvap->nva_change != npnvap->nva_change)) ||
1489 (NFS_BITMAP_ISSET(npnvap->nva_bitmap, NFS_FATTR_TIME_MODIFY) &&
1490 ((nvap->nva_timesec[NFSTIME_MODIFY] != npnvap->nva_timesec[NFSTIME_MODIFY]) ||
1491 (nvap->nva_timensec[NFSTIME_MODIFY] != npnvap->nva_timensec[NFSTIME_MODIFY]))))
1492 events |= VNODE_EVENT_ATTRIB | VNODE_EVENT_WRITE;
1493 if (!events && NFS_BITMAP_ISSET(npnvap->nva_bitmap, NFS_FATTR_RAWDEV) &&
1494 ((nvap->nva_rawdev.specdata1 != npnvap->nva_rawdev.specdata1) ||
1495 (nvap->nva_rawdev.specdata2 != npnvap->nva_rawdev.specdata2)))
1496 events |= VNODE_EVENT_ATTRIB;
1497 if (!events && NFS_BITMAP_ISSET(npnvap->nva_bitmap, NFS_FATTR_FILEID) &&
1498 (nvap->nva_fileid != npnvap->nva_fileid))
1499 events |= VNODE_EVENT_ATTRIB;
1500 if (!events && NFS_BITMAP_ISSET(npnvap->nva_bitmap, NFS_FATTR_ARCHIVE) &&
1501 ((nvap->nva_flags & NFS_FFLAG_ARCHIVED) != (npnvap->nva_flags & NFS_FFLAG_ARCHIVED)))
1502 events |= VNODE_EVENT_ATTRIB;
1503 if (!events && NFS_BITMAP_ISSET(npnvap->nva_bitmap, NFS_FATTR_HIDDEN) &&
1504 ((nvap->nva_flags & NFS_FFLAG_HIDDEN) != (npnvap->nva_flags & NFS_FFLAG_HIDDEN)))
1505 events |= VNODE_EVENT_ATTRIB;
1506 if (!events && NFS_BITMAP_ISSET(npnvap->nva_bitmap, NFS_FATTR_TIME_CREATE) &&
1507 ((nvap->nva_timesec[NFSTIME_CREATE] != npnvap->nva_timesec[NFSTIME_CREATE]) ||
1508 (nvap->nva_timensec[NFSTIME_CREATE] != npnvap->nva_timensec[NFSTIME_CREATE])))
1509 events |= VNODE_EVENT_ATTRIB;
1510 if (!events && NFS_BITMAP_ISSET(npnvap->nva_bitmap, NFS_FATTR_TIME_BACKUP) &&
1511 ((nvap->nva_timesec[NFSTIME_BACKUP] != npnvap->nva_timesec[NFSTIME_BACKUP]) ||
1512 (nvap->nva_timensec[NFSTIME_BACKUP] != npnvap->nva_timensec[NFSTIME_BACKUP])))
1513 events |= VNODE_EVENT_ATTRIB;
1514 }
1515
1516 /* Copy the attributes to the attribute cache */
1517 bcopy((caddr_t)nvap, (caddr_t)npnvap, sizeof(*nvap));
1518
1519 microuptime(&now);
1520 np->n_attrstamp = now.tv_sec;
1521 np->n_xid = *xidp;
1522 /* NFS_FFLAG_IS_ATTR and NFS_FFLAG_TRIGGER_REFERRAL need to be sticky... */
1523 if (vp && xattr)
1524 nvap->nva_flags |= xattr;
1525 if (vp && referral)
1526 nvap->nva_flags |= referral;
1527
1528 if (NFS_BITMAP_ISSET(npnvap->nva_bitmap, NFS_FATTR_ACL)) {
1529 /* we're updating the ACL */
1530 if (nvap->nva_acl) {
1531 /* make a copy of the acl for the cache */
1532 npnvap->nva_acl = kauth_acl_alloc(nvap->nva_acl->acl_entrycount);
1533 if (npnvap->nva_acl) {
1534 bcopy(nvap->nva_acl, npnvap->nva_acl, KAUTH_ACL_COPYSIZE(nvap->nva_acl));
1535 } else {
1536 /* can't make a copy to cache, invalidate ACL cache */
1537 NFS_BITMAP_CLR(npnvap->nva_bitmap, NFS_FATTR_ACL);
1538 NACLINVALIDATE(np);
1539 aclbit = 0;
1540 }
1541 }
1542 if (acl) {
1543 kauth_acl_free(acl);
1544 acl = NULL;
1545 }
1546 }
1547 if (NFS_BITMAP_ISSET(npnvap->nva_bitmap, NFS_FATTR_ACL)) {
1548 /* update the ACL timestamp */
1549 np->n_aclstamp = now.tv_sec;
1550 } else {
1551 /* we aren't updating the ACL, so restore original values */
1552 if (aclbit)
1553 NFS_BITMAP_SET(npnvap->nva_bitmap, NFS_FATTR_ACL);
1554 npnvap->nva_acl = acl;
1555 }
1556
1557#if CONFIG_TRIGGERS
1558 /*
1559 * For NFSv4, if the fsid doesn't match the fsid for the mount, then
1560 * this node is for a different file system on the server. So we mark
1561 * this node as a trigger node that will trigger the mirror mount.
1562 */
1563 if ((nmp->nm_vers >= NFS_VER4) && (nvap->nva_type == VDIR) &&
1564 ((np->n_vattr.nva_fsid.major != nmp->nm_fsid.major) ||
1565 (np->n_vattr.nva_fsid.minor != nmp->nm_fsid.minor)))
1566 np->n_vattr.nva_flags |= NFS_FFLAG_TRIGGER;
1567#endif
1568
1569 if (!vp || (nvap->nva_type != VREG)) {
1570 np->n_size = nvap->nva_size;
1571 } else if (nvap->nva_size != np->n_size) {
1572 FSDBG(527, np, nvap->nva_size, np->n_size, (nvap->nva_type == VREG) | (np->n_flag & NMODIFIED ? 6 : 4));
1573 if (!UBCINFOEXISTS(vp) || (dontshrink && (nvap->nva_size < np->n_size))) {
1574 /* asked not to shrink, so stick with current size */
1575 FSDBG(527, np, np->n_size, np->n_vattr.nva_size, 0xf00d0001);
1576 nvap->nva_size = np->n_size;
1577 NATTRINVALIDATE(np);
1578 } else if ((np->n_flag & NMODIFIED) && (nvap->nva_size < np->n_size)) {
1579 /* if we've modified, stick with larger size */
1580 FSDBG(527, np, np->n_size, np->n_vattr.nva_size, 0xf00d0002);
1581 nvap->nva_size = np->n_size;
1582 npnvap->nva_size = np->n_size;
1583 } else {
1584 /*
1585 * n_size is protected by the data lock, so we need to
1586 * defer updating it until it's safe. We save the new size
1587 * and set a flag and it'll get updated the next time we get/drop
1588 * the data lock or the next time we do a getattr.
1589 */
1590 np->n_newsize = nvap->nva_size;
1591 SET(np->n_flag, NUPDATESIZE);
1592 if (monitored)
1593 events |= VNODE_EVENT_ATTRIB | VNODE_EVENT_EXTEND;
1594 }
1595 }
1596
1597 if (np->n_flag & NCHG) {
1598 if (np->n_flag & NACC) {
1599 nvap->nva_timesec[NFSTIME_ACCESS] = np->n_atim.tv_sec;
1600 nvap->nva_timensec[NFSTIME_ACCESS] = np->n_atim.tv_nsec;
1601 }
1602 if (np->n_flag & NUPD) {
1603 nvap->nva_timesec[NFSTIME_MODIFY] = np->n_mtim.tv_sec;
1604 nvap->nva_timensec[NFSTIME_MODIFY] = np->n_mtim.tv_nsec;
1605 }
1606 }
1607
1608out:
1609 if (monitored && events)
1610 nfs_vnode_notify(np, events);
1611 FSDBG_BOT(527, error, np, np->n_size, *xidp);
1612 return (error);
1613}
1614
1615/*
1616 * Calculate the attribute timeout based on
1617 * how recently the file has been modified.
1618 */
1619int
1620nfs_attrcachetimeout(nfsnode_t np)
1621{
1622 struct nfsmount *nmp;
1623 struct timeval now;
1624 int isdir;
1625 uint32_t timeo;
1626
1627 nmp = NFSTONMP(np);
1628 if (nfs_mount_gone(nmp))
1629 return (0);
1630
1631 isdir = vnode_isdir(NFSTOV(np));
1632
1633 if ((nmp->nm_vers >= NFS_VER4) && (np->n_openflags & N_DELEG_MASK)) {
1634 /* If we have a delegation, we always use the max timeout. */
1635 timeo = isdir ? nmp->nm_acdirmax : nmp->nm_acregmax;
1636 } else if ((np)->n_flag & NMODIFIED) {
1637 /* If we have modifications, we always use the min timeout. */
1638 timeo = isdir ? nmp->nm_acdirmin : nmp->nm_acregmin;
1639 } else {
1640 /* Otherwise, we base the timeout on how old the file seems. */
1641 /* Note that if the client and server clocks are way out of sync, */
1642 /* timeout will probably get clamped to a min or max value */
1643 microtime(&now);
1644 timeo = (now.tv_sec - (np)->n_vattr.nva_timesec[NFSTIME_MODIFY]) / 10;
1645 if (isdir) {
1646 if (timeo < nmp->nm_acdirmin)
1647 timeo = nmp->nm_acdirmin;
1648 else if (timeo > nmp->nm_acdirmax)
1649 timeo = nmp->nm_acdirmax;
1650 } else {
1651 if (timeo < nmp->nm_acregmin)
1652 timeo = nmp->nm_acregmin;
1653 else if (timeo > nmp->nm_acregmax)
1654 timeo = nmp->nm_acregmax;
1655 }
1656 }
1657
1658 return (timeo);
1659}
1660
1661/*
1662 * Check the attribute cache time stamp.
1663 * If the cache is valid, copy contents to *nvaper and return 0
1664 * otherwise return an error.
1665 * Must be called with the node locked.
1666 */
1667int
1668nfs_getattrcache(nfsnode_t np, struct nfs_vattr *nvaper, int flags)
1669{
1670 struct nfs_vattr *nvap;
1671 struct timeval nowup;
1672 int32_t timeo;
1673 struct nfsmount *nmp;
1674
1675 /* Check if the attributes are valid. */
1676 if (!NATTRVALID(np) || ((flags & NGA_ACL) && !NACLVALID(np))) {
1677 FSDBG(528, np, 0, 0xffffff01, ENOENT);
1678 OSAddAtomic64(1, &nfsstats.attrcache_misses);
1679 return (ENOENT);
1680 }
1681
1682 nmp = NFSTONMP(np);
1683 if (nfs_mount_gone(nmp))
1684 return (ENXIO);
1685 /*
1686 * Verify the cached attributes haven't timed out.
1687 * If the server isn't responding, skip the check
1688 * and return cached attributes.
1689 */
1690 if (!nfs_use_cache(nmp)) {
1691 microuptime(&nowup);
1692 if (np->n_attrstamp > nowup.tv_sec) {
1693 printf("NFS: Attribute time stamp is in the future by %ld seconds. Invalidating cache\n",
1694 np->n_attrstamp - nowup.tv_sec);
1695 NATTRINVALIDATE(np);
1696 NACCESSINVALIDATE(np);
1697 return (ENOENT);
1698 }
1699 timeo = nfs_attrcachetimeout(np);
1700 if ((nowup.tv_sec - np->n_attrstamp) >= timeo) {
1701 FSDBG(528, np, 0, 0xffffff02, ENOENT);
1702 OSAddAtomic64(1, &nfsstats.attrcache_misses);
1703 return (ENOENT);
1704 }
1705 if ((flags & NGA_ACL) && ((nowup.tv_sec - np->n_aclstamp) >= timeo)) {
1706 FSDBG(528, np, 0, 0xffffff02, ENOENT);
1707 OSAddAtomic64(1, &nfsstats.attrcache_misses);
1708 return (ENOENT);
1709 }
1710 }
1711
1712 nvap = &np->n_vattr;
1713 FSDBG(528, np, nvap->nva_size, np->n_size, 0xcace);
1714 OSAddAtomic64(1, &nfsstats.attrcache_hits);
1715
1716 if (nvap->nva_type != VREG) {
1717 np->n_size = nvap->nva_size;
1718 } else if (nvap->nva_size != np->n_size) {
1719 FSDBG(528, np, nvap->nva_size, np->n_size, (nvap->nva_type == VREG) | (np->n_flag & NMODIFIED ? 6 : 4));
1720 if ((np->n_flag & NMODIFIED) && (nvap->nva_size < np->n_size)) {
1721 /* if we've modified, stick with larger size */
1722 nvap->nva_size = np->n_size;
1723 } else {
1724 /*
1725 * n_size is protected by the data lock, so we need to
1726 * defer updating it until it's safe. We save the new size
1727 * and set a flag and it'll get updated the next time we get/drop
1728 * the data lock or the next time we do a getattr.
1729 */
1730 np->n_newsize = nvap->nva_size;
1731 SET(np->n_flag, NUPDATESIZE);
1732 }
1733 }
1734
1735 bcopy((caddr_t)nvap, (caddr_t)nvaper, sizeof(struct nfs_vattr));
1736 if (np->n_flag & NCHG) {
1737 if (np->n_flag & NACC) {
1738 nvaper->nva_timesec[NFSTIME_ACCESS] = np->n_atim.tv_sec;
1739 nvaper->nva_timensec[NFSTIME_ACCESS] = np->n_atim.tv_nsec;
1740 }
1741 if (np->n_flag & NUPD) {
1742 nvaper->nva_timesec[NFSTIME_MODIFY] = np->n_mtim.tv_sec;
1743 nvaper->nva_timensec[NFSTIME_MODIFY] = np->n_mtim.tv_nsec;
1744 }
1745 }
1746 if (nvap->nva_acl) {
1747 if (flags & NGA_ACL) {
1748 nvaper->nva_acl = kauth_acl_alloc(nvap->nva_acl->acl_entrycount);
1749 if (!nvaper->nva_acl)
1750 return (ENOMEM);
1751 bcopy(nvap->nva_acl, nvaper->nva_acl, KAUTH_ACL_COPYSIZE(nvap->nva_acl));
1752 } else {
1753 nvaper->nva_acl = NULL;
1754 }
1755 }
1756 return (0);
1757}
1758
1759/*
1760 * When creating file system objects:
1761 * Don't bother setting UID if it's the same as the credential performing the create.
1762 * Don't bother setting GID if it's the same as the directory or credential.
1763 */
1764void
1765nfs_avoid_needless_id_setting_on_create(nfsnode_t dnp, struct vnode_attr *vap, vfs_context_t ctx)
1766{
1767 if (VATTR_IS_ACTIVE(vap, va_uid)) {
1768 if (kauth_cred_getuid(vfs_context_ucred(ctx)) == vap->va_uid) {
1769 VATTR_CLEAR_ACTIVE(vap, va_uid);
1770 VATTR_CLEAR_ACTIVE(vap, va_uuuid);
1771 }
1772 }
1773 if (VATTR_IS_ACTIVE(vap, va_gid)) {
1774 if ((vap->va_gid == dnp->n_vattr.nva_gid) ||
1775 (kauth_cred_getgid(vfs_context_ucred(ctx)) == vap->va_gid)) {
1776 VATTR_CLEAR_ACTIVE(vap, va_gid);
1777 VATTR_CLEAR_ACTIVE(vap, va_guuid);
1778 }
1779 }
1780}
1781
1782/*
1783 * Convert a universal address string to a sockaddr structure.
1784 *
1785 * Universal addresses can be in the following formats:
1786 *
1787 * d = decimal (IPv4)
1788 * x = hexadecimal (IPv6)
1789 * p = port (decimal)
1790 *
1791 * d.d.d.d
1792 * d.d.d.d.p.p
1793 * x:x:x:x:x:x:x:x
1794 * x:x:x:x:x:x:x:x.p.p
1795 * x:x:x:x:x:x:d.d.d.d
1796 * x:x:x:x:x:x:d.d.d.d.p.p
1797 *
1798 * IPv6 strings can also have a series of zeroes elided
1799 * IPv6 strings can also have a %scope suffix at the end (after any port)
1800 *
1801 * rules & exceptions:
1802 * - value before : is hex
1803 * - value before . is dec
1804 * - once . hit, all values are dec
1805 * - hex+port case means value before first dot is actually hex
1806 * - . is always preceded by digits except if last hex was double-colon
1807 *
1808 * scan, converting #s to bytes
1809 * first time a . is encountered, scan the rest to count them.
1810 * 2 dots = just port
1811 * 3 dots = just IPv4 no port
1812 * 5 dots = IPv4 and port
1813 */
1814
1815#define IS_DIGIT(C) \
1816 (((C) >= '0') && ((C) <= '9'))
1817
1818#define IS_XDIGIT(C) \
1819 (IS_DIGIT(C) || \
1820 (((C) >= 'A') && ((C) <= 'F')) || \
1821 (((C) >= 'a') && ((C) <= 'f')))
1822
1823int
1824nfs_uaddr2sockaddr(const char *uaddr, struct sockaddr *addr)
1825{
1826 const char *p, *pd; /* pointers to current character in scan */
1827 const char *pnum; /* pointer to current number to decode */
1828 const char *pscope; /* pointer to IPv6 scope ID */
1829 uint8_t a[18]; /* octet array to store address bytes */
1830 int i; /* index of next octet to decode */
1831 int dci; /* index of octet to insert double-colon zeroes */
1832 int dcount, xdcount; /* count of digits in current number */
1833 int needmore; /* set when we know we need more input (e.g. after colon, period) */
1834 int dots; /* # of dots */
1835 int hex; /* contains hex values */
1836 unsigned long val; /* decoded value */
1837 int s; /* index used for sliding array to insert elided zeroes */
1838
1839#define HEXVALUE 0
1840#define DECIMALVALUE 1
1841#define GET(TYPE) \
1842 do { \
1843 if ((dcount <= 0) || (dcount > (((TYPE) == DECIMALVALUE) ? 3 : 4))) \
1844 return (0); \
1845 if (((TYPE) == DECIMALVALUE) && xdcount) \
1846 return (0); \
1847 val = strtoul(pnum, NULL, ((TYPE) == DECIMALVALUE) ? 10 : 16); \
1848 if (((TYPE) == DECIMALVALUE) && (val >= 256)) \
1849 return (0); \
1850 /* check if there is room left in the array */ \
1851 if (i > (int)(sizeof(a) - (((TYPE) == HEXVALUE) ? 2 : 1) - ((dci != -1) ? 2 : 0))) \
1852 return (0); \
1853 if ((TYPE) == HEXVALUE) \
1854 a[i++] = ((val >> 8) & 0xff); \
1855 a[i++] = (val & 0xff); \
1856 } while (0)
1857
1858 hex = 0;
1859 dots = 0;
1860 dci = -1;
1861 i = dcount = xdcount = 0;
1862 pnum = p = uaddr;
1863 pscope = NULL;
1864 needmore = 1;
1865 if ((*p == ':') && (*++p != ':')) /* if it starts with colon, gotta be a double */
1866 return (0);
1867
1868 while (*p) {
1869 if (IS_XDIGIT(*p)) {
1870 dcount++;
1871 if (!IS_DIGIT(*p))
1872 xdcount++;
1873 needmore = 0;
1874 p++;
1875 } else if (*p == '.') {
1876 /* rest is decimal IPv4 dotted quad and/or port */
1877 if (!dots) {
1878 /* this is the first, so count them */
1879 for (pd = p; *pd; pd++) {
1880 if (*pd == '.') {
1881 if (++dots > 5)
1882 return (0);
1883 } else if (hex && (*pd == '%')) {
1884 break;
1885 } else if ((*pd < '0') || (*pd > '9')) {
1886 return (0);
1887 }
1888 }
1889 if ((dots != 2) && (dots != 3) && (dots != 5))
1890 return (0);
1891 if (hex && (dots == 2)) { /* hex+port */
1892 if (!dcount && needmore)
1893 return (0);
1894 if (dcount) /* last hex may be elided zero */
1895 GET(HEXVALUE);
1896 } else {
1897 GET(DECIMALVALUE);
1898 }
1899 } else {
1900 GET(DECIMALVALUE);
1901 }
1902 dcount = xdcount = 0;
1903 needmore = 1;
1904 pnum = ++p;
1905 } else if (*p == ':') {
1906 hex = 1;
1907 if (dots)
1908 return (0);
1909 if (!dcount) { /* missing number, probably double colon */
1910 if (dci >= 0) /* can only have one double colon */
1911 return (0);
1912 dci = i;
1913 needmore = 0;
1914 } else {
1915 GET(HEXVALUE);
1916 dcount = xdcount = 0;
1917 needmore = 1;
1918 }
1919 pnum = ++p;
1920 } else if (*p == '%') { /* scope ID delimiter */
1921 if (!hex)
1922 return (0);
1923 p++;
1924 pscope = p;
1925 break;
1926 } else { /* unexpected character */
1927 return (0);
1928 }
1929 }
1930 if (needmore && !dcount)
1931 return (0);
1932 if (dcount) /* decode trailing number */
1933 GET(dots ? DECIMALVALUE : HEXVALUE);
1934 if (dci >= 0) { /* got a double-colon at i, need to insert a range of zeroes */
1935 /* if we got a port, slide to end of array */
1936 /* otherwise, slide to end of address (non-port) values */
1937 int end = ((dots == 2) || (dots == 5)) ? sizeof(a) : (sizeof(a) - 2);
1938 if (i % 2) /* length of zero range must be multiple of 2 */
1939 return (0);
1940 if (i >= end) /* no room? */
1941 return (0);
1942 /* slide (i-dci) numbers up from index dci */
1943 for (s=0; s < (i - dci); s++)
1944 a[end-1-s] = a[i-1-s];
1945 /* zero (end-i) numbers at index dci */
1946 for (s=0; s < (end - i); s++)
1947 a[dci+s] = 0;
1948 i = end;
1949 }
1950
1951 /* copy out resulting socket address */
1952 if (hex) {
1953 struct sockaddr_in6 *sin6 = (struct sockaddr_in6*)addr;
1954 if ((((dots == 0) || (dots == 3)) && (i != (sizeof(a)-2))))
1955 return (0);
1956 if ((((dots == 2) || (dots == 5)) && (i != sizeof(a))))
1957 return (0);
1958 bzero(sin6, sizeof(struct sockaddr_in6));
1959 sin6->sin6_len = sizeof(struct sockaddr_in6);
1960 sin6->sin6_family = AF_INET6;
1961 bcopy(a, &sin6->sin6_addr.s6_addr, sizeof(struct in6_addr));
1962 if ((dots == 5) || (dots == 2))
1963 sin6->sin6_port = htons((a[16] << 8) | a[17]);
1964 if (pscope) {
1965 for (p=pscope; IS_DIGIT(*p); p++)
1966 ;
1967 if (*p && !IS_DIGIT(*p)) { /* name */
1968 ifnet_t interface = NULL;
1969 if (ifnet_find_by_name(pscope, &interface) == 0)
1970 sin6->sin6_scope_id = ifnet_index(interface);
1971 if (interface)
1972 ifnet_release(interface);
1973 } else { /* decimal number */
1974 sin6->sin6_scope_id = strtoul(pscope, NULL, 10);
1975 }
1976 /* XXX should we also embed scope id for linklocal? */
1977 }
1978 } else {
1979 struct sockaddr_in *sin = (struct sockaddr_in*)addr;
1980 if ((dots != 3) && (dots != 5))
1981 return (0);
1982 if ((dots == 3) && (i != 4))
1983 return (0);
1984 if ((dots == 5) && (i != 6))
1985 return (0);
1986 bzero(sin, sizeof(struct sockaddr_in));
1987 sin->sin_len = sizeof(struct sockaddr_in);
1988 sin->sin_family = AF_INET;
1989 bcopy(a, &sin->sin_addr.s_addr, sizeof(struct in_addr));
1990 if (dots == 5)
1991 sin->sin_port = htons((a[4] << 8) | a[5]);
1992 }
1993 return (1);
1994}
1995
1996
1997/* NFS Client debugging support */
1998uint32_t nfs_debug_ctl;
1999
2000#include <libkern/libkern.h>
2001#include <stdarg.h>
2002
2003void
2004nfs_printf(int facility, int level, const char *fmt, ...)
2005{
2006 va_list ap;
2007
2008 if ((uint32_t)level > NFS_DEBUG_LEVEL)
2009 return;
2010 if (NFS_DEBUG_FACILITY && !((uint32_t)facility & NFS_DEBUG_FACILITY))
2011 return;
2012
2013 va_start(ap, fmt);
2014 vprintf(fmt, ap);
2015 va_end(ap);
2016}
2017
2018/* Is a mount gone away? */
2019int
2020nfs_mount_gone(struct nfsmount *nmp)
2021{
2022 return (!nmp || vfs_isforce(nmp->nm_mountp) || (nmp->nm_state & (NFSSTA_FORCE | NFSSTA_DEAD)));
2023}
2024
2025/*
2026 * Return some of the more significant mount options
2027 * as a string, e.g. "'ro,hard,intr,tcp,vers=3,sec=krb5,deadtimeout=0'
2028 */
2029int
2030nfs_mountopts(struct nfsmount *nmp, char *buf, int buflen)
2031{
2032 int c;
2033
2034 c = snprintf(buf, buflen, "%s,%s,%s,%s,vers=%d,sec=%s,%sdeadtimeout=%d",
2035 (vfs_flags(nmp->nm_mountp) & MNT_RDONLY) ? "ro" : "rw",
2036 NMFLAG(nmp, SOFT) ? "soft" : "hard",
2037 NMFLAG(nmp, INTR) ? "intr" : "nointr",
2038 nmp->nm_sotype == SOCK_STREAM ? "tcp" : "udp",
2039 nmp->nm_vers,
2040 nmp->nm_auth == RPCAUTH_KRB5 ? "krb5" :
2041 nmp->nm_auth == RPCAUTH_KRB5I ? "krb5i" :
2042 nmp->nm_auth == RPCAUTH_KRB5P ? "krb5p" :
2043 nmp->nm_auth == RPCAUTH_SYS ? "sys" : "none",
2044 nmp->nm_lockmode == NFS_LOCK_MODE_ENABLED ? "locks," :
2045 nmp->nm_lockmode == NFS_LOCK_MODE_DISABLED ? "nolocks," :
2046 nmp->nm_lockmode == NFS_LOCK_MODE_LOCAL ? "locallocks," : "",
2047 nmp->nm_deadtimeout);
2048
2049 return (c > buflen ? ENOMEM : 0);
2050}
2051
2052#endif /* NFSCLIENT */
2053
2054/*
2055 * Schedule a callout thread to run an NFS timer function
2056 * interval milliseconds in the future.
2057 */
2058void
2059nfs_interval_timer_start(thread_call_t call, int interval)
2060{
2061 uint64_t deadline;
2062
2063 clock_interval_to_deadline(interval, 1000 * 1000, &deadline);
2064 thread_call_enter_delayed(call, deadline);
2065}
2066
2067
2068#if NFSSERVER
2069
2070int nfsrv_cmp_secflavs(struct nfs_sec *, struct nfs_sec *);
2071int nfsrv_hang_addrlist(struct nfs_export *, struct user_nfs_export_args *);
2072int nfsrv_free_netopt(struct radix_node *, void *);
2073int nfsrv_free_addrlist(struct nfs_export *, struct user_nfs_export_args *);
2074struct nfs_export_options *nfsrv_export_lookup(struct nfs_export *, mbuf_t);
2075struct nfs_export *nfsrv_fhtoexport(struct nfs_filehandle *);
2076struct nfs_user_stat_node *nfsrv_get_user_stat_node(struct nfs_active_user_list *, struct sockaddr *, uid_t);
2077void nfsrv_init_user_list(struct nfs_active_user_list *);
2078void nfsrv_free_user_list(struct nfs_active_user_list *);
2079
2080/*
2081 * add NFSv3 WCC data to an mbuf chain
2082 */
2083int
2084nfsm_chain_add_wcc_data_f(
2085 struct nfsrv_descript *nd,
2086 struct nfsm_chain *nmc,
2087 int preattrerr,
2088 struct vnode_attr *prevap,
2089 int postattrerr,
2090 struct vnode_attr *postvap)
2091{
2092 int error = 0;
2093
2094 if (preattrerr) {
2095 nfsm_chain_add_32(error, nmc, FALSE);
2096 } else {
2097 nfsm_chain_add_32(error, nmc, TRUE);
2098 nfsm_chain_add_64(error, nmc, prevap->va_data_size);
2099 nfsm_chain_add_time(error, nmc, NFS_VER3, &prevap->va_modify_time);
2100 nfsm_chain_add_time(error, nmc, NFS_VER3, &prevap->va_change_time);
2101 }
2102 nfsm_chain_add_postop_attr(error, nd, nmc, postattrerr, postvap);
2103
2104 return (error);
2105}
2106
2107/*
2108 * Extract a lookup path from the given mbufs and store it in
2109 * a newly allocated buffer saved in the given nameidata structure.
2110 */
2111int
2112nfsm_chain_get_path_namei(
2113 struct nfsm_chain *nmc,
2114 uint32_t len,
2115 struct nameidata *nip)
2116{
2117 struct componentname *cnp = &nip->ni_cnd;
2118 int error = 0;
2119 char *cp;
2120
2121 if (len > (MAXPATHLEN - 1))
2122 return (ENAMETOOLONG);
2123
2124 /*
2125 * Get a buffer for the name to be translated, and copy the
2126 * name into the buffer.
2127 */
2128 MALLOC_ZONE(cnp->cn_pnbuf, caddr_t, MAXPATHLEN, M_NAMEI, M_WAITOK);
2129 if (!cnp->cn_pnbuf)
2130 return (ENOMEM);
2131 cnp->cn_pnlen = MAXPATHLEN;
2132 cnp->cn_flags |= HASBUF;
2133
2134 /* Copy the name from the mbuf list to the string */
2135 cp = cnp->cn_pnbuf;
2136 nfsm_chain_get_opaque(error, nmc, len, cp);
2137 if (error)
2138 goto out;
2139 cnp->cn_pnbuf[len] = '\0';
2140
2141 /* sanity check the string */
2142 if ((strlen(cp) != len) || strchr(cp, '/'))
2143 error = EACCES;
2144out:
2145 if (error) {
2146 if (cnp->cn_pnbuf)
2147 FREE_ZONE(cnp->cn_pnbuf, MAXPATHLEN, M_NAMEI);
2148 cnp->cn_flags &= ~HASBUF;
2149 } else {
2150 nip->ni_pathlen = len;
2151 }
2152 return (error);
2153}
2154
2155/*
2156 * Set up nameidata for a lookup() call and do it.
2157 */
2158int
2159nfsrv_namei(
2160 struct nfsrv_descript *nd,
2161 vfs_context_t ctx,
2162 struct nameidata *nip,
2163 struct nfs_filehandle *nfhp,
2164 vnode_t *retdirp,
2165 struct nfs_export **nxp,
2166 struct nfs_export_options **nxop)
2167{
2168 vnode_t dp;
2169 int error;
2170 struct componentname *cnp = &nip->ni_cnd;
2171 uint32_t cnflags;
2172 char *tmppn;
2173
2174 *retdirp = NULL;
2175
2176 /*
2177 * Extract and set starting directory.
2178 */
2179 error = nfsrv_fhtovp(nfhp, nd, &dp, nxp, nxop);
2180 if (error)
2181 goto out;
2182 error = nfsrv_credcheck(nd, ctx, *nxp, *nxop);
2183 if (error || (vnode_vtype(dp) != VDIR)) {
2184 vnode_put(dp);
2185 error = ENOTDIR;
2186 goto out;
2187 }
2188 *retdirp = dp;
2189
2190 nip->ni_cnd.cn_context = ctx;
2191
2192 if (*nxop && ((*nxop)->nxo_flags & NX_READONLY))
2193 cnp->cn_flags |= RDONLY;
2194
2195 cnp->cn_flags |= NOCROSSMOUNT;
2196 cnp->cn_nameptr = cnp->cn_pnbuf;
2197 nip->ni_usedvp = nip->ni_startdir = dp;
2198 nip->ni_rootdir = rootvnode;
2199
2200 /*
2201 * And call lookup() to do the real work
2202 */
2203 cnflags = nip->ni_cnd.cn_flags; /* store in case we have to restore */
2204 while ((error = lookup(nip)) == ERECYCLE) {
2205 nip->ni_cnd.cn_flags = cnflags;
2206 cnp->cn_nameptr = cnp->cn_pnbuf;
2207 nip->ni_usedvp = nip->ni_dvp = nip->ni_startdir = dp;
2208 }
2209 if (error)
2210 goto out;
2211
2212 /* Check for encountering a symbolic link */
2213 if (cnp->cn_flags & ISSYMLINK) {
2214 if (cnp->cn_flags & (LOCKPARENT | WANTPARENT))
2215 vnode_put(nip->ni_dvp);
2216 if (nip->ni_vp) {
2217 vnode_put(nip->ni_vp);
2218 nip->ni_vp = NULL;
2219 }
2220 error = EINVAL;
2221 }
2222out:
2223 if (error) {
2224 tmppn = cnp->cn_pnbuf;
2225 cnp->cn_pnbuf = NULL;
2226 cnp->cn_flags &= ~HASBUF;
2227 FREE_ZONE(tmppn, cnp->cn_pnlen, M_NAMEI);
2228 }
2229 return (error);
2230}
2231
2232/*
2233 * A fiddled version of m_adj() that ensures null fill to a 4-byte
2234 * boundary and only trims off the back end
2235 */
2236void
2237nfsm_adj(mbuf_t mp, int len, int nul)
2238{
2239 mbuf_t m, mnext;
2240 int count, i, mlen;
2241 char *cp;
2242
2243 /*
2244 * Trim from tail. Scan the mbuf chain,
2245 * calculating its length and finding the last mbuf.
2246 * If the adjustment only affects this mbuf, then just
2247 * adjust and return. Otherwise, rescan and truncate
2248 * after the remaining size.
2249 */
2250 count = 0;
2251 m = mp;
2252 for (;;) {
2253 mlen = mbuf_len(m);
2254 count += mlen;
2255 mnext = mbuf_next(m);
2256 if (mnext == NULL)
2257 break;
2258 m = mnext;
2259 }
2260 if (mlen > len) {
2261 mlen -= len;
2262 mbuf_setlen(m, mlen);
2263 if (nul > 0) {
2264 cp = (caddr_t)mbuf_data(m) + mlen - nul;
2265 for (i = 0; i < nul; i++)
2266 *cp++ = '\0';
2267 }
2268 return;
2269 }
2270 count -= len;
2271 if (count < 0)
2272 count = 0;
2273 /*
2274 * Correct length for chain is "count".
2275 * Find the mbuf with last data, adjust its length,
2276 * and toss data from remaining mbufs on chain.
2277 */
2278 for (m = mp; m; m = mbuf_next(m)) {
2279 mlen = mbuf_len(m);
2280 if (mlen >= count) {
2281 mlen = count;
2282 mbuf_setlen(m, count);
2283 if (nul > 0) {
2284 cp = (caddr_t)mbuf_data(m) + mlen - nul;
2285 for (i = 0; i < nul; i++)
2286 *cp++ = '\0';
2287 }
2288 break;
2289 }
2290 count -= mlen;
2291 }
2292 for (m = mbuf_next(m); m; m = mbuf_next(m))
2293 mbuf_setlen(m, 0);
2294}
2295
2296/*
2297 * Trim the header out of the mbuf list and trim off any trailing
2298 * junk so that the mbuf list has only the write data.
2299 */
2300int
2301nfsm_chain_trim_data(struct nfsm_chain *nmc, int len, int *mlen)
2302{
2303 int cnt = 0, dlen, adjust;
2304 caddr_t data;
2305 mbuf_t m;
2306
2307 if (mlen)
2308 *mlen = 0;
2309
2310 /* trim header */
2311 for (m = nmc->nmc_mhead; m && (m != nmc->nmc_mcur); m = mbuf_next(m))
2312 mbuf_setlen(m, 0);
2313 if (!m)
2314 return (EIO);
2315
2316 /* trim current mbuf */
2317 data = mbuf_data(m);
2318 dlen = mbuf_len(m);
2319 adjust = nmc->nmc_ptr - data;
2320 dlen -= adjust;
2321 if ((dlen > 0) && (adjust > 0)) {
2322 if (mbuf_setdata(m, nmc->nmc_ptr, dlen))
2323 return(EIO);
2324 } else
2325 mbuf_setlen(m, dlen);
2326
2327 /* skip next len bytes */
2328 for (; m && (cnt < len); m = mbuf_next(m)) {
2329 dlen = mbuf_len(m);
2330 cnt += dlen;
2331 if (cnt > len) {
2332 /* truncate to end of data */
2333 mbuf_setlen(m, dlen - (cnt - len));
2334 if (m == nmc->nmc_mcur)
2335 nmc->nmc_left -= (cnt - len);
2336 cnt = len;
2337 }
2338 }
2339 if (mlen)
2340 *mlen = cnt;
2341
2342 /* trim any trailing data */
2343 if (m == nmc->nmc_mcur)
2344 nmc->nmc_left = 0;
2345 for (; m; m = mbuf_next(m))
2346 mbuf_setlen(m, 0);
2347
2348 return (0);
2349}
2350
2351int
2352nfsm_chain_add_fattr(
2353 struct nfsrv_descript *nd,
2354 struct nfsm_chain *nmc,
2355 struct vnode_attr *vap)
2356{
2357 int error = 0;
2358
2359 // XXX Should we assert here that all fields are supported?
2360
2361 nfsm_chain_add_32(error, nmc, vtonfs_type(vap->va_type, nd->nd_vers));
2362 if (nd->nd_vers == NFS_VER3) {
2363 nfsm_chain_add_32(error, nmc, vap->va_mode & 07777);
2364 } else {
2365 nfsm_chain_add_32(error, nmc, vtonfsv2_mode(vap->va_type, vap->va_mode));
2366 }
2367 nfsm_chain_add_32(error, nmc, vap->va_nlink);
2368 nfsm_chain_add_32(error, nmc, vap->va_uid);
2369 nfsm_chain_add_32(error, nmc, vap->va_gid);
2370 if (nd->nd_vers == NFS_VER3) {
2371 nfsm_chain_add_64(error, nmc, vap->va_data_size);
2372 nfsm_chain_add_64(error, nmc, vap->va_data_alloc);
2373 nfsm_chain_add_32(error, nmc, major(vap->va_rdev));
2374 nfsm_chain_add_32(error, nmc, minor(vap->va_rdev));
2375 nfsm_chain_add_64(error, nmc, vap->va_fsid);
2376 nfsm_chain_add_64(error, nmc, vap->va_fileid);
2377 } else {
2378 nfsm_chain_add_32(error, nmc, vap->va_data_size);
2379 nfsm_chain_add_32(error, nmc, NFS_FABLKSIZE);
2380 if (vap->va_type == VFIFO)
2381 nfsm_chain_add_32(error, nmc, 0xffffffff);
2382 else
2383 nfsm_chain_add_32(error, nmc, vap->va_rdev);
2384 nfsm_chain_add_32(error, nmc, vap->va_data_alloc / NFS_FABLKSIZE);
2385 nfsm_chain_add_32(error, nmc, vap->va_fsid);
2386 nfsm_chain_add_32(error, nmc, vap->va_fileid);
2387 }
2388 nfsm_chain_add_time(error, nmc, nd->nd_vers, &vap->va_access_time);
2389 nfsm_chain_add_time(error, nmc, nd->nd_vers, &vap->va_modify_time);
2390 nfsm_chain_add_time(error, nmc, nd->nd_vers, &vap->va_change_time);
2391
2392 return (error);
2393}
2394
2395int
2396nfsm_chain_get_sattr(
2397 struct nfsrv_descript *nd,
2398 struct nfsm_chain *nmc,
2399 struct vnode_attr *vap)
2400{
2401 int error = 0;
2402 uint32_t val = 0;
2403 uint64_t val64 = 0;
2404 struct timespec now;
2405
2406 if (nd->nd_vers == NFS_VER2) {
2407 /*
2408 * There is/was a bug in the Sun client that puts 0xffff in the mode
2409 * field of sattr when it should put in 0xffffffff. The u_short
2410 * doesn't sign extend. So check the low order 2 bytes for 0xffff.
2411 */
2412 nfsm_chain_get_32(error, nmc, val);
2413 if ((val & 0xffff) != 0xffff) {
2414 VATTR_SET(vap, va_mode, val & 07777);
2415 /* save the "type" bits for NFSv2 create */
2416 VATTR_SET(vap, va_type, IFTOVT(val));
2417 VATTR_CLEAR_ACTIVE(vap, va_type);
2418 }
2419 nfsm_chain_get_32(error, nmc, val);
2420 if (val != (uint32_t)-1)
2421 VATTR_SET(vap, va_uid, val);
2422 nfsm_chain_get_32(error, nmc, val);
2423 if (val != (uint32_t)-1)
2424 VATTR_SET(vap, va_gid, val);
2425 /* save the "size" bits for NFSv2 create (even if they appear unset) */
2426 nfsm_chain_get_32(error, nmc, val);
2427 VATTR_SET(vap, va_data_size, val);
2428 if (val == (uint32_t)-1)
2429 VATTR_CLEAR_ACTIVE(vap, va_data_size);
2430 nfsm_chain_get_time(error, nmc, NFS_VER2,
2431 vap->va_access_time.tv_sec,
2432 vap->va_access_time.tv_nsec);
2433 if (vap->va_access_time.tv_sec != -1)
2434 VATTR_SET_ACTIVE(vap, va_access_time);
2435 nfsm_chain_get_time(error, nmc, NFS_VER2,
2436 vap->va_modify_time.tv_sec,
2437 vap->va_modify_time.tv_nsec);
2438 if (vap->va_modify_time.tv_sec != -1)
2439 VATTR_SET_ACTIVE(vap, va_modify_time);
2440 return (error);
2441 }
2442
2443 /* NFSv3 */
2444 nfsm_chain_get_32(error, nmc, val);
2445 if (val) {
2446 nfsm_chain_get_32(error, nmc, val);
2447 VATTR_SET(vap, va_mode, val & 07777);
2448 }
2449 nfsm_chain_get_32(error, nmc, val);
2450 if (val) {
2451 nfsm_chain_get_32(error, nmc, val);
2452 VATTR_SET(vap, va_uid, val);
2453 }
2454 nfsm_chain_get_32(error, nmc, val);
2455 if (val) {
2456 nfsm_chain_get_32(error, nmc, val);
2457 VATTR_SET(vap, va_gid, val);
2458 }
2459 nfsm_chain_get_32(error, nmc, val);
2460 if (val) {
2461 nfsm_chain_get_64(error, nmc, val64);
2462 VATTR_SET(vap, va_data_size, val64);
2463 }
2464 nanotime(&now);
2465 nfsm_chain_get_32(error, nmc, val);
2466 switch (val) {
2467 case NFS_TIME_SET_TO_CLIENT:
2468 nfsm_chain_get_time(error, nmc, nd->nd_vers,
2469 vap->va_access_time.tv_sec,
2470 vap->va_access_time.tv_nsec);
2471 VATTR_SET_ACTIVE(vap, va_access_time);
2472 vap->va_vaflags &= ~VA_UTIMES_NULL;
2473 break;
2474 case NFS_TIME_SET_TO_SERVER:
2475 VATTR_SET(vap, va_access_time, now);
2476 vap->va_vaflags |= VA_UTIMES_NULL;
2477 break;
2478 }
2479 nfsm_chain_get_32(error, nmc, val);
2480 switch (val) {
2481 case NFS_TIME_SET_TO_CLIENT:
2482 nfsm_chain_get_time(error, nmc, nd->nd_vers,
2483 vap->va_modify_time.tv_sec,
2484 vap->va_modify_time.tv_nsec);
2485 VATTR_SET_ACTIVE(vap, va_modify_time);
2486 vap->va_vaflags &= ~VA_UTIMES_NULL;
2487 break;
2488 case NFS_TIME_SET_TO_SERVER:
2489 VATTR_SET(vap, va_modify_time, now);
2490 if (!VATTR_IS_ACTIVE(vap, va_access_time))
2491 vap->va_vaflags |= VA_UTIMES_NULL;
2492 break;
2493 }
2494
2495 return (error);
2496}
2497
2498/*
2499 * Compare two security flavor structs
2500 */
2501int
2502nfsrv_cmp_secflavs(struct nfs_sec *sf1, struct nfs_sec *sf2)
2503{
2504 int i;
2505
2506 if (sf1->count != sf2->count)
2507 return 1;
2508 for (i = 0; i < sf1->count; i++)
2509 if (sf1->flavors[i] != sf2->flavors[i])
2510 return 1;
2511 return 0;
2512}
2513
2514/*
2515 * Build hash lists of net addresses and hang them off the NFS export.
2516 * Called by nfsrv_export() to set up the lists of export addresses.
2517 */
2518int
2519nfsrv_hang_addrlist(struct nfs_export *nx, struct user_nfs_export_args *unxa)
2520{
2521 struct nfs_export_net_args nxna;
2522 struct nfs_netopt *no, *rn_no;
2523 struct radix_node_head *rnh;
2524 struct radix_node *rn;
2525 struct sockaddr *saddr, *smask;
2526 struct domain *dom;
2527 int i, error;
2528 unsigned int net;
2529 user_addr_t uaddr;
2530 kauth_cred_t cred;
2531
2532 uaddr = unxa->nxa_nets;
2533 for (net = 0; net < unxa->nxa_netcount; net++, uaddr += sizeof(nxna)) {
2534 error = copyin(uaddr, &nxna, sizeof(nxna));
2535 if (error)
2536 return (error);
2537
2538 if (nxna.nxna_addr.ss_len > sizeof(struct sockaddr_storage) ||
2539 nxna.nxna_mask.ss_len > sizeof(struct sockaddr_storage) ||
2540 nxna.nxna_addr.ss_family > AF_MAX ||
2541 nxna.nxna_mask.ss_family > AF_MAX)
2542 return (EINVAL);
2543
2544 if (nxna.nxna_flags & (NX_MAPROOT|NX_MAPALL)) {
2545 struct posix_cred temp_pcred;
2546 bzero(&temp_pcred, sizeof(temp_pcred));
2547 temp_pcred.cr_uid = nxna.nxna_cred.cr_uid;
2548 temp_pcred.cr_ngroups = nxna.nxna_cred.cr_ngroups;
2549 for (i=0; i < nxna.nxna_cred.cr_ngroups && i < NGROUPS; i++)
2550 temp_pcred.cr_groups[i] = nxna.nxna_cred.cr_groups[i];
2551 cred = posix_cred_create(&temp_pcred);
2552 if (!IS_VALID_CRED(cred))
2553 return (ENOMEM);
2554 } else {
2555 cred = NOCRED;
2556 }
2557
2558 if (nxna.nxna_addr.ss_len == 0) {
2559 /* No address means this is a default/world export */
2560 if (nx->nx_flags & NX_DEFAULTEXPORT) {
2561 if (IS_VALID_CRED(cred))
2562 kauth_cred_unref(&cred);
2563 return (EEXIST);
2564 }
2565 nx->nx_flags |= NX_DEFAULTEXPORT;
2566 nx->nx_defopt.nxo_flags = nxna.nxna_flags;
2567 nx->nx_defopt.nxo_cred = cred;
2568 bcopy(&nxna.nxna_sec, &nx->nx_defopt.nxo_sec, sizeof(struct nfs_sec));
2569 nx->nx_expcnt++;
2570 continue;
2571 }
2572
2573 i = sizeof(struct nfs_netopt);
2574 i += nxna.nxna_addr.ss_len + nxna.nxna_mask.ss_len;
2575 MALLOC(no, struct nfs_netopt *, i, M_NETADDR, M_WAITOK);
2576 if (!no) {
2577 if (IS_VALID_CRED(cred))
2578 kauth_cred_unref(&cred);
2579 return (ENOMEM);
2580 }
2581 bzero(no, sizeof(struct nfs_netopt));
2582 no->no_opt.nxo_flags = nxna.nxna_flags;
2583 no->no_opt.nxo_cred = cred;
2584 bcopy(&nxna.nxna_sec, &no->no_opt.nxo_sec, sizeof(struct nfs_sec));
2585
2586 saddr = (struct sockaddr *)(no + 1);
2587 bcopy(&nxna.nxna_addr, saddr, nxna.nxna_addr.ss_len);
2588 if (nxna.nxna_mask.ss_len) {
2589 smask = (struct sockaddr *)((caddr_t)saddr + nxna.nxna_addr.ss_len);
2590 bcopy(&nxna.nxna_mask, smask, nxna.nxna_mask.ss_len);
2591 } else {
2592 smask = NULL;
2593 }
2594 i = saddr->sa_family;
2595 if ((rnh = nx->nx_rtable[i]) == 0) {
2596 /*
2597 * Seems silly to initialize every AF when most are not
2598 * used, do so on demand here
2599 */
2600 TAILQ_FOREACH(dom, &domains, dom_entry) {
2601 if (dom->dom_family == i && dom->dom_rtattach) {
2602 dom->dom_rtattach((void **)&nx->nx_rtable[i],
2603 dom->dom_rtoffset);
2604 break;
2605 }
2606 }
2607 if ((rnh = nx->nx_rtable[i]) == 0) {
2608 if (IS_VALID_CRED(cred))
2609 kauth_cred_unref(&cred);
2610 _FREE(no, M_NETADDR);
2611 return (ENOBUFS);
2612 }
2613 }
2614 rn = (*rnh->rnh_addaddr)((caddr_t)saddr, (caddr_t)smask, rnh, no->no_rnodes);
2615 if (rn == 0) {
2616 /*
2617 * One of the reasons that rnh_addaddr may fail is that
2618 * the entry already exists. To check for this case, we
2619 * look up the entry to see if it is there. If so, we
2620 * do not need to make a new entry but do continue.
2621 *
2622 * XXX should this be rnh_lookup() instead?
2623 */
2624 int matched = 0;
2625 rn = (*rnh->rnh_matchaddr)((caddr_t)saddr, rnh);
2626 rn_no = (struct nfs_netopt *)rn;
2627 if (rn != 0 && (rn->rn_flags & RNF_ROOT) == 0 &&
2628 (rn_no->no_opt.nxo_flags == nxna.nxna_flags) &&
2629 (!nfsrv_cmp_secflavs(&rn_no->no_opt.nxo_sec, &nxna.nxna_sec))) {
2630 kauth_cred_t cred2 = rn_no->no_opt.nxo_cred;
2631 if (cred == cred2) {
2632 /* creds are same (or both NULL) */
2633 matched = 1;
2634 } else if (cred && cred2 && (kauth_cred_getuid(cred) == kauth_cred_getuid(cred2))) {
2635 /*
2636 * Now compare the effective and
2637 * supplementary groups...
2638 *
2639 * Note: This comparison, as written,
2640 * does not correctly indicate that
2641 * the groups are equivalent, since
2642 * other than the first supplementary
2643 * group, which is also the effective
2644 * group, order on the remaining groups
2645 * doesn't matter, and this is an
2646 * ordered compare.
2647 */
2648 gid_t groups[NGROUPS];
2649 gid_t groups2[NGROUPS];
2650 int groupcount = NGROUPS;
2651 int group2count = NGROUPS;
2652
2653 if (!kauth_cred_getgroups(cred, groups, &groupcount) &&
2654 !kauth_cred_getgroups(cred2, groups2, &group2count) &&
2655 groupcount == group2count) {
2656 for (i=0; i < group2count; i++)
2657 if (groups[i] != groups2[i])
2658 break;
2659 if (i >= group2count || i >= NGROUPS)
2660 matched = 1;
2661 }
2662 }
2663 }
2664 if (IS_VALID_CRED(cred))
2665 kauth_cred_unref(&cred);
2666 _FREE(no, M_NETADDR);
2667 if (matched)
2668 continue;
2669 return (EPERM);
2670 }
2671 nx->nx_expcnt++;
2672 }
2673
2674 return (0);
2675}
2676
2677/*
2678 * In order to properly track an export's netopt count, we need to pass
2679 * an additional argument to nfsrv_free_netopt() so that it can decrement
2680 * the export's netopt count.
2681 */
2682struct nfsrv_free_netopt_arg {
2683 uint32_t *cnt;
2684 struct radix_node_head *rnh;
2685};
2686
2687int
2688nfsrv_free_netopt(struct radix_node *rn, void *w)
2689{
2690 struct nfsrv_free_netopt_arg *fna = (struct nfsrv_free_netopt_arg *)w;
2691 struct radix_node_head *rnh = fna->rnh;
2692 uint32_t *cnt = fna->cnt;
2693 struct nfs_netopt *nno = (struct nfs_netopt *)rn;
2694
2695 (*rnh->rnh_deladdr)(rn->rn_key, rn->rn_mask, rnh);
2696 if (IS_VALID_CRED(nno->no_opt.nxo_cred))
2697 kauth_cred_unref(&nno->no_opt.nxo_cred);
2698 _FREE((caddr_t)rn, M_NETADDR);
2699 *cnt -= 1;
2700 return (0);
2701}
2702
2703/*
2704 * Free the net address hash lists that are hanging off the mount points.
2705 */
2706int
2707nfsrv_free_addrlist(struct nfs_export *nx, struct user_nfs_export_args *unxa)
2708{
2709 struct nfs_export_net_args nxna;
2710 struct radix_node_head *rnh;
2711 struct radix_node *rn;
2712 struct nfsrv_free_netopt_arg fna;
2713 struct nfs_netopt *nno;
2714 user_addr_t uaddr;
2715 unsigned int net;
2716 int i, error;
2717
2718 if (!unxa || !unxa->nxa_netcount) {
2719 /* delete everything */
2720 for (i = 0; i <= AF_MAX; i++)
2721 if ( (rnh = nx->nx_rtable[i]) ) {
2722 fna.rnh = rnh;
2723 fna.cnt = &nx->nx_expcnt;
2724 (*rnh->rnh_walktree)(rnh, nfsrv_free_netopt, (caddr_t)&fna);
2725 _FREE((caddr_t)rnh, M_RTABLE);
2726 nx->nx_rtable[i] = 0;
2727 }
2728 return (0);
2729 }
2730
2731 /* delete only the exports specified */
2732 uaddr = unxa->nxa_nets;
2733 for (net = 0; net < unxa->nxa_netcount; net++, uaddr += sizeof(nxna)) {
2734 error = copyin(uaddr, &nxna, sizeof(nxna));
2735 if (error)
2736 return (error);
2737
2738 if (nxna.nxna_addr.ss_len == 0) {
2739 /* No address means this is a default/world export */
2740 if (nx->nx_flags & NX_DEFAULTEXPORT) {
2741 nx->nx_flags &= ~NX_DEFAULTEXPORT;
2742 if (IS_VALID_CRED(nx->nx_defopt.nxo_cred)) {
2743 kauth_cred_unref(&nx->nx_defopt.nxo_cred);
2744 }
2745 nx->nx_expcnt--;
2746 }
2747 continue;
2748 }
2749
2750 if ((rnh = nx->nx_rtable[nxna.nxna_addr.ss_family]) == 0) {
2751 /* AF not initialized? */
2752 if (!(unxa->nxa_flags & NXA_ADD))
2753 printf("nfsrv_free_addrlist: address not found (0)\n");
2754 continue;
2755 }
2756
2757 rn = (*rnh->rnh_lookup)(&nxna.nxna_addr,
2758 nxna.nxna_mask.ss_len ? &nxna.nxna_mask : NULL, rnh);
2759 if (!rn || (rn->rn_flags & RNF_ROOT)) {
2760 if (!(unxa->nxa_flags & NXA_ADD))
2761 printf("nfsrv_free_addrlist: address not found (1)\n");
2762 continue;
2763 }
2764
2765 (*rnh->rnh_deladdr)(rn->rn_key, rn->rn_mask, rnh);
2766 nno = (struct nfs_netopt *)rn;
2767 if (IS_VALID_CRED(nno->no_opt.nxo_cred))
2768 kauth_cred_unref(&nno->no_opt.nxo_cred);
2769 _FREE((caddr_t)rn, M_NETADDR);
2770
2771 nx->nx_expcnt--;
2772 if (nx->nx_expcnt == ((nx->nx_flags & NX_DEFAULTEXPORT) ? 1 : 0)) {
2773 /* no more entries in rnh, so free it up */
2774 _FREE((caddr_t)rnh, M_RTABLE);
2775 nx->nx_rtable[nxna.nxna_addr.ss_family] = 0;
2776 }
2777 }
2778
2779 return (0);
2780}
2781
2782void enablequotas(struct mount *mp, vfs_context_t ctx); // XXX
2783
2784int
2785nfsrv_export(struct user_nfs_export_args *unxa, vfs_context_t ctx)
2786{
2787 int error = 0;
2788 size_t pathlen;
2789 struct nfs_exportfs *nxfs, *nxfs2, *nxfs3;
2790 struct nfs_export *nx, *nx2, *nx3;
2791 struct nfs_filehandle nfh;
2792 struct nameidata mnd, xnd;
2793 vnode_t mvp = NULL, xvp = NULL;
2794 mount_t mp = NULL;
2795 char path[MAXPATHLEN];
2796 int expisroot;
2797
2798 if (unxa->nxa_flags == NXA_CHECK) {
2799 /* just check if the path is an NFS-exportable file system */
2800 error = copyinstr(unxa->nxa_fspath, path, MAXPATHLEN, &pathlen);
2801 if (error)
2802 return (error);
2803 NDINIT(&mnd, LOOKUP, OP_LOOKUP, FOLLOW | LOCKLEAF | AUDITVNPATH1,
2804 UIO_SYSSPACE, CAST_USER_ADDR_T(path), ctx);
2805 error = namei(&mnd);
2806 if (error)
2807 return (error);
2808 mvp = mnd.ni_vp;
2809 mp = vnode_mount(mvp);
2810 /* make sure it's the root of a file system */
2811 if (!vnode_isvroot(mvp))
2812 error = EINVAL;
2813 /* make sure the file system is NFS-exportable */
2814 if (!error) {
2815 nfh.nfh_len = NFSV3_MAX_FID_SIZE;
2816 error = VFS_VPTOFH(mvp, (int*)&nfh.nfh_len, &nfh.nfh_fid[0], NULL);
2817 }
2818 if (!error && (nfh.nfh_len > (int)NFSV3_MAX_FID_SIZE))
2819 error = EIO;
2820 if (!error && !(mp->mnt_vtable->vfc_vfsflags & VFC_VFSREADDIR_EXTENDED))
2821 error = EISDIR;
2822 vnode_put(mvp);
2823 nameidone(&mnd);
2824 return (error);
2825 }
2826
2827 /* all other operations: must be super user */
2828 if ((error = vfs_context_suser(ctx)))
2829 return (error);
2830
2831 if (unxa->nxa_flags & NXA_DELETE_ALL) {
2832 /* delete all exports on all file systems */
2833 lck_rw_lock_exclusive(&nfsrv_export_rwlock);
2834 while ((nxfs = LIST_FIRST(&nfsrv_exports))) {
2835 mp = vfs_getvfs_by_mntonname(nxfs->nxfs_path);
2836 if (mp) {
2837 vfs_clearflags(mp, MNT_EXPORTED);
2838 mount_iterdrop(mp);
2839 mp = NULL;
2840 }
2841 /* delete all exports on this file system */
2842 while ((nx = LIST_FIRST(&nxfs->nxfs_exports))) {
2843 LIST_REMOVE(nx, nx_next);
2844 LIST_REMOVE(nx, nx_hash);
2845 /* delete all netopts for this export */
2846 nfsrv_free_addrlist(nx, NULL);
2847 nx->nx_flags &= ~NX_DEFAULTEXPORT;
2848 if (IS_VALID_CRED(nx->nx_defopt.nxo_cred)) {
2849 kauth_cred_unref(&nx->nx_defopt.nxo_cred);
2850 }
2851 /* free active user list for this export */
2852 nfsrv_free_user_list(&nx->nx_user_list);
2853 FREE(nx->nx_path, M_TEMP);
2854 FREE(nx, M_TEMP);
2855 }
2856 LIST_REMOVE(nxfs, nxfs_next);
2857 FREE(nxfs->nxfs_path, M_TEMP);
2858 FREE(nxfs, M_TEMP);
2859 }
2860 if (nfsrv_export_hashtbl) {
2861 /* all exports deleted, clean up export hash table */
2862 FREE(nfsrv_export_hashtbl, M_TEMP);
2863 nfsrv_export_hashtbl = NULL;
2864 }
2865 lck_rw_done(&nfsrv_export_rwlock);
2866 return (0);
2867 }
2868
2869 error = copyinstr(unxa->nxa_fspath, path, MAXPATHLEN, &pathlen);
2870 if (error)
2871 return (error);
2872
2873 lck_rw_lock_exclusive(&nfsrv_export_rwlock);
2874
2875 /* init export hash table if not already */
2876 if (!nfsrv_export_hashtbl) {
2877 if (nfsrv_export_hash_size <= 0)
2878 nfsrv_export_hash_size = NFSRVEXPHASHSZ;
2879 nfsrv_export_hashtbl = hashinit(nfsrv_export_hash_size, M_TEMP, &nfsrv_export_hash);
2880 }
2881
2882 // first check if we've already got an exportfs with the given ID
2883 LIST_FOREACH(nxfs, &nfsrv_exports, nxfs_next) {
2884 if (nxfs->nxfs_id == unxa->nxa_fsid)
2885 break;
2886 }
2887 if (nxfs) {
2888 /* verify exported FS path matches given path */
2889 if (strncmp(path, nxfs->nxfs_path, MAXPATHLEN)) {
2890 error = EEXIST;
2891 goto unlock_out;
2892 }
2893 if ((unxa->nxa_flags & (NXA_ADD|NXA_OFFLINE)) == NXA_ADD) {
2894 /* if adding, verify that the mount is still what we expect */
2895 mp = vfs_getvfs_by_mntonname(nxfs->nxfs_path);
2896 if (mp) {
2897 mount_ref(mp, 0);
2898 mount_iterdrop(mp);
2899 }
2900 /* find exported FS root vnode */
2901 NDINIT(&mnd, LOOKUP, OP_LOOKUP, FOLLOW | LOCKLEAF | AUDITVNPATH1,
2902 UIO_SYSSPACE, CAST_USER_ADDR_T(nxfs->nxfs_path), ctx);
2903 error = namei(&mnd);
2904 if (error)
2905 goto unlock_out;
2906 mvp = mnd.ni_vp;
2907 /* make sure it's (still) the root of a file system */
2908 if (!vnode_isvroot(mvp)) {
2909 error = EINVAL;
2910 goto out;
2911 }
2912 /* sanity check: this should be same mount */
2913 if (mp != vnode_mount(mvp)) {
2914 error = EINVAL;
2915 goto out;
2916 }
2917 }
2918 } else {
2919 /* no current exported file system with that ID */
2920 if (!(unxa->nxa_flags & NXA_ADD)) {
2921 error = ENOENT;
2922 goto unlock_out;
2923 }
2924
2925 /* find exported FS root vnode */
2926 NDINIT(&mnd, LOOKUP, OP_LOOKUP, FOLLOW | LOCKLEAF | AUDITVNPATH1,
2927 UIO_SYSSPACE, CAST_USER_ADDR_T(path), ctx);
2928 error = namei(&mnd);
2929 if (error) {
2930 if (!(unxa->nxa_flags & NXA_OFFLINE))
2931 goto unlock_out;
2932 } else {
2933 mvp = mnd.ni_vp;
2934 /* make sure it's the root of a file system */
2935 if (!vnode_isvroot(mvp)) {
2936 /* bail if not marked offline */
2937 if (!(unxa->nxa_flags & NXA_OFFLINE)) {
2938 error = EINVAL;
2939 goto out;
2940 }
2941 vnode_put(mvp);
2942 nameidone(&mnd);
2943 mvp = NULL;
2944 } else {
2945 mp = vnode_mount(mvp);
2946 mount_ref(mp, 0);
2947
2948 /* make sure the file system is NFS-exportable */
2949 nfh.nfh_len = NFSV3_MAX_FID_SIZE;
2950 error = VFS_VPTOFH(mvp, (int*)&nfh.nfh_len, &nfh.nfh_fid[0], NULL);
2951 if (!error && (nfh.nfh_len > (int)NFSV3_MAX_FID_SIZE))
2952 error = EIO;
2953 if (!error && !(mp->mnt_vtable->vfc_vfsflags & VFC_VFSREADDIR_EXTENDED))
2954 error = EISDIR;
2955 if (error)
2956 goto out;
2957 }
2958 }
2959
2960 /* add an exportfs for it */
2961 MALLOC(nxfs, struct nfs_exportfs *, sizeof(struct nfs_exportfs), M_TEMP, M_WAITOK);
2962 if (!nxfs) {
2963 error = ENOMEM;
2964 goto out;
2965 }
2966 bzero(nxfs, sizeof(struct nfs_exportfs));
2967 nxfs->nxfs_id = unxa->nxa_fsid;
2968 MALLOC(nxfs->nxfs_path, char*, pathlen, M_TEMP, M_WAITOK);
2969 if (!nxfs->nxfs_path) {
2970 FREE(nxfs, M_TEMP);
2971 error = ENOMEM;
2972 goto out;
2973 }
2974 bcopy(path, nxfs->nxfs_path, pathlen);
2975 /* insert into list in reverse-sorted order */
2976 nxfs3 = NULL;
2977 LIST_FOREACH(nxfs2, &nfsrv_exports, nxfs_next) {
2978 if (strncmp(nxfs->nxfs_path, nxfs2->nxfs_path, MAXPATHLEN) > 0)
2979 break;
2980 nxfs3 = nxfs2;
2981 }
2982 if (nxfs2)
2983 LIST_INSERT_BEFORE(nxfs2, nxfs, nxfs_next);
2984 else if (nxfs3)
2985 LIST_INSERT_AFTER(nxfs3, nxfs, nxfs_next);
2986 else
2987 LIST_INSERT_HEAD(&nfsrv_exports, nxfs, nxfs_next);
2988
2989 /* make sure any quotas are enabled before we export the file system */
2990 if (mp)
2991 enablequotas(mp, ctx);
2992 }
2993
2994 if (unxa->nxa_exppath) {
2995 error = copyinstr(unxa->nxa_exppath, path, MAXPATHLEN, &pathlen);
2996 if (error)
2997 goto out;
2998 LIST_FOREACH(nx, &nxfs->nxfs_exports, nx_next) {
2999 if (nx->nx_id == unxa->nxa_expid)
3000 break;
3001 }
3002 if (nx) {
3003 /* verify exported FS path matches given path */
3004 if (strncmp(path, nx->nx_path, MAXPATHLEN)) {
3005 error = EEXIST;
3006 goto out;
3007 }
3008 } else {
3009 /* no current export with that ID */
3010 if (!(unxa->nxa_flags & NXA_ADD)) {
3011 error = ENOENT;
3012 goto out;
3013 }
3014 /* add an export for it */
3015 MALLOC(nx, struct nfs_export *, sizeof(struct nfs_export), M_TEMP, M_WAITOK);
3016 if (!nx) {
3017 error = ENOMEM;
3018 goto out1;
3019 }
3020 bzero(nx, sizeof(struct nfs_export));
3021 nx->nx_id = unxa->nxa_expid;
3022 nx->nx_fs = nxfs;
3023 microtime(&nx->nx_exptime);
3024 MALLOC(nx->nx_path, char*, pathlen, M_TEMP, M_WAITOK);
3025 if (!nx->nx_path) {
3026 error = ENOMEM;
3027 FREE(nx, M_TEMP);
3028 nx = NULL;
3029 goto out1;
3030 }
3031 bcopy(path, nx->nx_path, pathlen);
3032 /* initialize the active user list */
3033 nfsrv_init_user_list(&nx->nx_user_list);
3034 /* insert into list in reverse-sorted order */
3035 nx3 = NULL;
3036 LIST_FOREACH(nx2, &nxfs->nxfs_exports, nx_next) {
3037 if (strncmp(nx->nx_path, nx2->nx_path, MAXPATHLEN) > 0)
3038 break;
3039 nx3 = nx2;
3040 }
3041 if (nx2)
3042 LIST_INSERT_BEFORE(nx2, nx, nx_next);
3043 else if (nx3)
3044 LIST_INSERT_AFTER(nx3, nx, nx_next);
3045 else
3046 LIST_INSERT_HEAD(&nxfs->nxfs_exports, nx, nx_next);
3047 /* insert into hash */
3048 LIST_INSERT_HEAD(NFSRVEXPHASH(nxfs->nxfs_id, nx->nx_id), nx, nx_hash);
3049
3050 /*
3051 * We don't allow/support nested exports. Check if the new entry
3052 * nests with the entries before and after or if there's an
3053 * entry for the file system root and subdirs.
3054 */
3055 error = 0;
3056 if ((nx3 && !strncmp(nx3->nx_path, nx->nx_path, pathlen - 1) &&
3057 (nx3->nx_path[pathlen-1] == '/')) ||
3058 (nx2 && !strncmp(nx2->nx_path, nx->nx_path, strlen(nx2->nx_path)) &&
3059 (nx->nx_path[strlen(nx2->nx_path)] == '/')))
3060 error = EINVAL;
3061 if (!error) {
3062 /* check export conflict with fs root export and vice versa */
3063 expisroot = !nx->nx_path[0] ||
3064 ((nx->nx_path[0] == '.') && !nx->nx_path[1]);
3065 LIST_FOREACH(nx2, &nxfs->nxfs_exports, nx_next) {
3066 if (expisroot) {
3067 if (nx2 != nx)
3068 break;
3069 } else if (!nx2->nx_path[0])
3070 break;
3071 else if ((nx2->nx_path[0] == '.') && !nx2->nx_path[1])
3072 break;
3073 }
3074 if (nx2)
3075 error = EINVAL;
3076 }
3077 if (error) {
3078 /*
3079 * Don't actually return an error because mountd is
3080 * probably about to delete the conflicting export.
3081 * This can happen when a new export momentarily conflicts
3082 * with an old export while the transition is being made.
3083 * Theoretically, mountd could be written to avoid this
3084 * transient situation - but it would greatly increase the
3085 * complexity of mountd for very little overall benefit.
3086 */
3087 printf("nfsrv_export: warning: nested exports: %s/%s\n",
3088 nxfs->nxfs_path, nx->nx_path);
3089 error = 0;
3090 }
3091 nx->nx_fh.nfh_xh.nxh_flags = NXHF_INVALIDFH;
3092 }
3093 /* make sure file handle is set up */
3094 if ((nx->nx_fh.nfh_xh.nxh_version != htonl(NFS_FH_VERSION)) ||
3095 (nx->nx_fh.nfh_xh.nxh_flags & NXHF_INVALIDFH)) {
3096 /* try to set up export root file handle */
3097 nx->nx_fh.nfh_xh.nxh_version = htonl(NFS_FH_VERSION);
3098 nx->nx_fh.nfh_xh.nxh_fsid = htonl(nx->nx_fs->nxfs_id);
3099 nx->nx_fh.nfh_xh.nxh_expid = htonl(nx->nx_id);
3100 nx->nx_fh.nfh_xh.nxh_flags = 0;
3101 nx->nx_fh.nfh_xh.nxh_reserved = 0;
3102 nx->nx_fh.nfh_fhp = (u_char*)&nx->nx_fh.nfh_xh;
3103 bzero(&nx->nx_fh.nfh_fid[0], NFSV2_MAX_FID_SIZE);
3104 if (mvp) {
3105 /* find export root vnode */
3106 if (!nx->nx_path[0] || ((nx->nx_path[0] == '.') && !nx->nx_path[1])) {
3107 /* exporting file system's root directory */
3108 xvp = mvp;
3109 vnode_get(xvp);
3110 } else {
3111 xnd.ni_cnd.cn_nameiop = LOOKUP;
3112#if CONFIG_TRIGGERS
3113 xnd.ni_op = OP_LOOKUP;
3114#endif
3115 xnd.ni_cnd.cn_flags = LOCKLEAF;
3116 xnd.ni_pathlen = pathlen - 1;
3117 xnd.ni_cnd.cn_nameptr = xnd.ni_cnd.cn_pnbuf = path;
3118 xnd.ni_startdir = mvp;
3119 xnd.ni_usedvp = mvp;
3120 xnd.ni_rootdir = rootvnode;
3121 xnd.ni_cnd.cn_context = ctx;
3122 while ((error = lookup(&xnd)) == ERECYCLE) {
3123 xnd.ni_cnd.cn_flags = LOCKLEAF;
3124 xnd.ni_cnd.cn_nameptr = xnd.ni_cnd.cn_pnbuf;
3125 xnd.ni_usedvp = xnd.ni_dvp = xnd.ni_startdir = mvp;
3126 }
3127 if (error)
3128 goto out1;
3129 xvp = xnd.ni_vp;
3130 }
3131
3132 if (vnode_vtype(xvp) != VDIR) {
3133 error = EINVAL;
3134 vnode_put(xvp);
3135 goto out1;
3136 }
3137
3138 /* grab file handle */
3139 nx->nx_fh.nfh_len = NFSV3_MAX_FID_SIZE;
3140 error = VFS_VPTOFH(xvp, (int*)&nx->nx_fh.nfh_len, &nx->nx_fh.nfh_fid[0], NULL);
3141 if (!error && (nx->nx_fh.nfh_len > (int)NFSV3_MAX_FID_SIZE)) {
3142 error = EIO;
3143 } else {
3144 nx->nx_fh.nfh_xh.nxh_fidlen = nx->nx_fh.nfh_len;
3145 nx->nx_fh.nfh_len += sizeof(nx->nx_fh.nfh_xh);
3146 }
3147
3148 vnode_put(xvp);
3149 if (error)
3150 goto out1;
3151 } else {
3152 nx->nx_fh.nfh_xh.nxh_flags = NXHF_INVALIDFH;
3153 nx->nx_fh.nfh_xh.nxh_fidlen = 0;
3154 nx->nx_fh.nfh_len = sizeof(nx->nx_fh.nfh_xh);
3155 }
3156 }
3157 } else {
3158 nx = NULL;
3159 }
3160
3161 /* perform the export changes */
3162 if (unxa->nxa_flags & NXA_DELETE) {
3163 if (!nx) {
3164 /* delete all exports on this file system */
3165 while ((nx = LIST_FIRST(&nxfs->nxfs_exports))) {
3166 LIST_REMOVE(nx, nx_next);
3167 LIST_REMOVE(nx, nx_hash);
3168 /* delete all netopts for this export */
3169 nfsrv_free_addrlist(nx, NULL);
3170 nx->nx_flags &= ~NX_DEFAULTEXPORT;
3171 if (IS_VALID_CRED(nx->nx_defopt.nxo_cred)) {
3172 kauth_cred_unref(&nx->nx_defopt.nxo_cred);
3173 }
3174 /* delete active user list for this export */
3175 nfsrv_free_user_list(&nx->nx_user_list);
3176 FREE(nx->nx_path, M_TEMP);
3177 FREE(nx, M_TEMP);
3178 }
3179 goto out1;
3180 } else if (!unxa->nxa_netcount) {
3181 /* delete all netopts for this export */
3182 nfsrv_free_addrlist(nx, NULL);
3183 nx->nx_flags &= ~NX_DEFAULTEXPORT;
3184 if (IS_VALID_CRED(nx->nx_defopt.nxo_cred)) {
3185 kauth_cred_unref(&nx->nx_defopt.nxo_cred);
3186 }
3187 } else {
3188 /* delete only the netopts for the given addresses */
3189 error = nfsrv_free_addrlist(nx, unxa);
3190 if (error)
3191 goto out1;
3192 }
3193 }
3194 if (unxa->nxa_flags & NXA_ADD) {
3195 /*
3196 * If going offline set the export time so that when
3197 * coming back on line we will present a new write verifier
3198 * to the client.
3199 */
3200 if (unxa->nxa_flags & NXA_OFFLINE)
3201 microtime(&nx->nx_exptime);
3202
3203 error = nfsrv_hang_addrlist(nx, unxa);
3204 if (!error && mp)
3205 vfs_setflags(mp, MNT_EXPORTED);
3206 }
3207
3208out1:
3209 if (nx && !nx->nx_expcnt) {
3210 /* export has no export options */
3211 LIST_REMOVE(nx, nx_next);
3212 LIST_REMOVE(nx, nx_hash);
3213 /* delete active user list for this export */
3214 nfsrv_free_user_list(&nx->nx_user_list);
3215 FREE(nx->nx_path, M_TEMP);
3216 FREE(nx, M_TEMP);
3217 }
3218 if (LIST_EMPTY(&nxfs->nxfs_exports)) {
3219 /* exported file system has no more exports */
3220 LIST_REMOVE(nxfs, nxfs_next);
3221 FREE(nxfs->nxfs_path, M_TEMP);
3222 FREE(nxfs, M_TEMP);
3223 if (mp)
3224 vfs_clearflags(mp, MNT_EXPORTED);
3225 }
3226
3227out:
3228 if (mvp) {
3229 vnode_put(mvp);
3230 nameidone(&mnd);
3231 }
3232unlock_out:
3233 if (mp)
3234 mount_drop(mp, 0);
3235 lck_rw_done(&nfsrv_export_rwlock);
3236 return (error);
3237}
3238
3239/*
3240 * Check if there is a least one export that will allow this address.
3241 *
3242 * Return 0, if there is an export that will allow this address,
3243 * else return EACCES
3244 */
3245int
3246nfsrv_check_exports_allow_address(mbuf_t nam)
3247{
3248 struct nfs_exportfs *nxfs;
3249 struct nfs_export *nx;
3250 struct nfs_export_options *nxo = NULL;
3251
3252 if (nam == NULL)
3253 return (EACCES);
3254
3255 lck_rw_lock_shared(&nfsrv_export_rwlock);
3256 LIST_FOREACH(nxfs, &nfsrv_exports, nxfs_next) {
3257 LIST_FOREACH(nx, &nxfs->nxfs_exports, nx_next) {
3258 /* A little optimizing by checking for the default first */
3259 if (nx->nx_flags & NX_DEFAULTEXPORT)
3260 nxo = &nx->nx_defopt;
3261 if (nxo || (nxo = nfsrv_export_lookup(nx, nam)))
3262 goto found;
3263 }
3264 }
3265found:
3266 lck_rw_done(&nfsrv_export_rwlock);
3267
3268 return (nxo ? 0 : EACCES);
3269}
3270
3271struct nfs_export_options *
3272nfsrv_export_lookup(struct nfs_export *nx, mbuf_t nam)
3273{
3274 struct nfs_export_options *nxo = NULL;
3275 struct nfs_netopt *no = NULL;
3276 struct radix_node_head *rnh;
3277 struct sockaddr *saddr;
3278
3279 /* Lookup in the export list first. */
3280 if (nam != NULL) {
3281 saddr = mbuf_data(nam);
3282 if (saddr->sa_family > AF_MAX) {
3283 /* Bogus sockaddr? Don't match anything. */
3284 return (NULL);
3285 }
3286 rnh = nx->nx_rtable[saddr->sa_family];
3287 if (rnh != NULL) {
3288 no = (struct nfs_netopt *)
3289 (*rnh->rnh_matchaddr)((caddr_t)saddr, rnh);
3290 if (no && no->no_rnodes->rn_flags & RNF_ROOT)
3291 no = NULL;
3292 if (no)
3293 nxo = &no->no_opt;
3294 }
3295 }
3296 /* If no address match, use the default if it exists. */
3297 if ((nxo == NULL) && (nx->nx_flags & NX_DEFAULTEXPORT))
3298 nxo = &nx->nx_defopt;
3299 return (nxo);
3300}
3301
3302/* find an export for the given handle */
3303struct nfs_export *
3304nfsrv_fhtoexport(struct nfs_filehandle *nfhp)
3305{
3306 struct nfs_exphandle *nxh = (struct nfs_exphandle*)nfhp->nfh_fhp;
3307 struct nfs_export *nx;
3308 uint32_t fsid, expid;
3309
3310 if (!nfsrv_export_hashtbl)
3311 return (NULL);
3312 fsid = ntohl(nxh->nxh_fsid);
3313 expid = ntohl(nxh->nxh_expid);
3314 nx = NFSRVEXPHASH(fsid, expid)->lh_first;
3315 for (; nx; nx = LIST_NEXT(nx, nx_hash)) {
3316 if (nx->nx_fs->nxfs_id != fsid)
3317 continue;
3318 if (nx->nx_id != expid)
3319 continue;
3320 break;
3321 }
3322 return (nx);
3323}
3324
3325/*
3326 * nfsrv_fhtovp() - convert FH to vnode and export info
3327 */
3328int
3329nfsrv_fhtovp(
3330 struct nfs_filehandle *nfhp,
3331 struct nfsrv_descript *nd,
3332 vnode_t *vpp,
3333 struct nfs_export **nxp,
3334 struct nfs_export_options **nxop)
3335{
3336 struct nfs_exphandle *nxh = (struct nfs_exphandle*)nfhp->nfh_fhp;
3337 struct nfs_export_options *nxo;
3338 u_char *fidp;
3339 int error;
3340 struct mount *mp;
3341 mbuf_t nam = NULL;
3342 uint32_t v;
3343 int i, valid;
3344
3345 *vpp = NULL;
3346 *nxp = NULL;
3347 *nxop = NULL;
3348
3349 if (nd != NULL)
3350 nam = nd->nd_nam;
3351
3352 v = ntohl(nxh->nxh_version);
3353 if (v != NFS_FH_VERSION) {
3354 /* file handle format not supported */
3355 return (ESTALE);
3356 }
3357 if (nfhp->nfh_len > NFSV3_MAX_FH_SIZE)
3358 return (EBADRPC);
3359 if (nfhp->nfh_len < (int)sizeof(struct nfs_exphandle))
3360 return (ESTALE);
3361 v = ntohs(nxh->nxh_flags);
3362 if (v & NXHF_INVALIDFH)
3363 return (ESTALE);
3364
3365 *nxp = nfsrv_fhtoexport(nfhp);
3366 if (!*nxp)
3367 return (ESTALE);
3368
3369 /* Get the export option structure for this <export, client> tuple. */
3370 *nxop = nxo = nfsrv_export_lookup(*nxp, nam);
3371 if (nam && (*nxop == NULL))
3372 return (EACCES);
3373
3374 if (nd != NULL) {
3375 /* Validate the security flavor of the request */
3376 for (i = 0, valid = 0; i < nxo->nxo_sec.count; i++) {
3377 if (nd->nd_sec == nxo->nxo_sec.flavors[i]) {
3378 valid = 1;
3379 break;
3380 }
3381 }
3382 if (!valid) {
3383 /*
3384 * RFC 2623 section 2.3.2 recommends no authentication
3385 * requirement for certain NFS procedures used for mounting.
3386 * This allows an unauthenticated superuser on the client
3387 * to do mounts for the benefit of authenticated users.
3388 */
3389 if (nd->nd_vers == NFS_VER2)
3390 if (nd->nd_procnum == NFSV2PROC_GETATTR ||
3391 nd->nd_procnum == NFSV2PROC_STATFS)
3392 valid = 1;
3393 if (nd->nd_vers == NFS_VER3)
3394 if (nd->nd_procnum == NFSPROC_FSINFO)
3395 valid = 1;
3396
3397 if (!valid)
3398 return (NFSERR_AUTHERR | AUTH_REJECTCRED);
3399 }
3400 }
3401
3402 if (nxo && (nxo->nxo_flags & NX_OFFLINE))
3403 return ((nd == NULL || nd->nd_vers == NFS_VER2) ? ESTALE : NFSERR_TRYLATER);
3404
3405 /* find mount structure */
3406 mp = vfs_getvfs_by_mntonname((*nxp)->nx_fs->nxfs_path);
3407 if (mp) {
3408 error = vfs_busy(mp, LK_NOWAIT);
3409 mount_iterdrop(mp);
3410 if (error)
3411 mp = NULL;
3412 }
3413 if (!mp) {
3414 /*
3415 * We have an export, but no mount?
3416 * Perhaps the export just hasn't been marked offline yet.
3417 */
3418 return ((nd == NULL || nd->nd_vers == NFS_VER2) ? ESTALE : NFSERR_TRYLATER);
3419 }
3420
3421 fidp = nfhp->nfh_fhp + sizeof(*nxh);
3422 error = VFS_FHTOVP(mp, nxh->nxh_fidlen, fidp, vpp, NULL);
3423 vfs_unbusy(mp);
3424 if (error)
3425 return (error);
3426 /* vnode pointer should be good at this point or ... */
3427 if (*vpp == NULL)
3428 return (ESTALE);
3429 return (0);
3430}
3431
3432/*
3433 * nfsrv_credcheck() - check/map credentials according
3434 * to given export options.
3435 */
3436int
3437nfsrv_credcheck(
3438 struct nfsrv_descript *nd,
3439 vfs_context_t ctx,
3440 __unused struct nfs_export *nx,
3441 struct nfs_export_options *nxo)
3442{
3443 if (nxo && nxo->nxo_cred) {
3444 if ((nxo->nxo_flags & NX_MAPALL) ||
3445 ((nxo->nxo_flags & NX_MAPROOT) && !suser(nd->nd_cr, NULL))) {
3446 kauth_cred_ref(nxo->nxo_cred);
3447 kauth_cred_unref(&nd->nd_cr);
3448 nd->nd_cr = nxo->nxo_cred;
3449 }
3450 }
3451 ctx->vc_ucred = nd->nd_cr;
3452 return (0);
3453}
3454
3455/*
3456 * nfsrv_vptofh() - convert vnode to file handle for given export
3457 *
3458 * If the caller is passing in a vnode for a ".." directory entry,
3459 * they can pass a directory NFS file handle (dnfhp) which will be
3460 * checked against the root export file handle. If it matches, we
3461 * refuse to provide the file handle for the out-of-export directory.
3462 */
3463int
3464nfsrv_vptofh(
3465 struct nfs_export *nx,
3466 int nfsvers,
3467 struct nfs_filehandle *dnfhp,
3468 vnode_t vp,
3469 vfs_context_t ctx,
3470 struct nfs_filehandle *nfhp)
3471{
3472 int error;
3473 uint32_t maxfidsize;
3474
3475 nfhp->nfh_fhp = (u_char*)&nfhp->nfh_xh;
3476 nfhp->nfh_xh.nxh_version = htonl(NFS_FH_VERSION);
3477 nfhp->nfh_xh.nxh_fsid = htonl(nx->nx_fs->nxfs_id);
3478 nfhp->nfh_xh.nxh_expid = htonl(nx->nx_id);
3479 nfhp->nfh_xh.nxh_flags = 0;
3480 nfhp->nfh_xh.nxh_reserved = 0;
3481
3482 if (nfsvers == NFS_VER2)
3483 bzero(&nfhp->nfh_fid[0], NFSV2_MAX_FID_SIZE);
3484
3485 /* if directory FH matches export root, return invalid FH */
3486 if (dnfhp && nfsrv_fhmatch(dnfhp, &nx->nx_fh)) {
3487 if (nfsvers == NFS_VER2)
3488 nfhp->nfh_len = NFSX_V2FH;
3489 else
3490 nfhp->nfh_len = sizeof(nfhp->nfh_xh);
3491 nfhp->nfh_xh.nxh_fidlen = 0;
3492 nfhp->nfh_xh.nxh_flags = htons(NXHF_INVALIDFH);
3493 return (0);
3494 }
3495
3496 if (nfsvers == NFS_VER2)
3497 maxfidsize = NFSV2_MAX_FID_SIZE;
3498 else
3499 maxfidsize = NFSV3_MAX_FID_SIZE;
3500 nfhp->nfh_len = maxfidsize;
3501
3502 error = VFS_VPTOFH(vp, (int*)&nfhp->nfh_len, &nfhp->nfh_fid[0], ctx);
3503 if (error)
3504 return (error);
3505 if (nfhp->nfh_len > maxfidsize)
3506 return (EOVERFLOW);
3507 nfhp->nfh_xh.nxh_fidlen = nfhp->nfh_len;
3508 nfhp->nfh_len += sizeof(nfhp->nfh_xh);
3509 if ((nfsvers == NFS_VER2) && (nfhp->nfh_len < NFSX_V2FH))
3510 nfhp->nfh_len = NFSX_V2FH;
3511
3512 return (0);
3513}
3514
3515/*
3516 * Compare two file handles to see it they're the same.
3517 * Note that we don't use nfh_len because that may include
3518 * padding in an NFSv2 file handle.
3519 */
3520int
3521nfsrv_fhmatch(struct nfs_filehandle *fh1, struct nfs_filehandle *fh2)
3522{
3523 struct nfs_exphandle *nxh1, *nxh2;
3524 int len1, len2;
3525
3526 nxh1 = (struct nfs_exphandle *)fh1->nfh_fhp;
3527 nxh2 = (struct nfs_exphandle *)fh2->nfh_fhp;
3528 len1 = sizeof(fh1->nfh_xh) + nxh1->nxh_fidlen;
3529 len2 = sizeof(fh2->nfh_xh) + nxh2->nxh_fidlen;
3530 if (len1 != len2)
3531 return (0);
3532 if (bcmp(nxh1, nxh2, len1))
3533 return (0);
3534 return (1);
3535}
3536
3537/*
3538 * Functions for dealing with active user lists
3539 */
3540
3541/*
3542 * Search the hash table for a user node with a matching IP address and uid field.
3543 * If found, the node's tm_last timestamp is updated and the node is returned.
3544 *
3545 * If not found, a new node is allocated (or reclaimed via LRU), initialized, and returned.
3546 * Returns NULL if a new node could not be allcoated.
3547 *
3548 * The list's user_mutex lock MUST be held.
3549 */
3550struct nfs_user_stat_node *
3551nfsrv_get_user_stat_node(struct nfs_active_user_list *list, struct sockaddr *saddr, uid_t uid)
3552{
3553 struct nfs_user_stat_node *unode;
3554 struct timeval now;
3555 struct nfs_user_stat_hashtbl_head *head;
3556
3557 /* seach the hash table */
3558 head = NFS_USER_STAT_HASH(list->user_hashtbl, uid);
3559 LIST_FOREACH(unode, head, hash_link) {
3560 if ((uid == unode->uid) && (nfs_sockaddr_cmp(saddr, (struct sockaddr*)&unode->sock) == 0)) {
3561 /* found matching node */
3562 break;
3563 }
3564 }
3565
3566 if (unode) {
3567 /* found node in the hash table, now update lru position */
3568 TAILQ_REMOVE(&list->user_lru, unode, lru_link);
3569 TAILQ_INSERT_TAIL(&list->user_lru, unode, lru_link);
3570
3571 /* update time stamp */
3572 microtime(&now);
3573 unode->tm_last = (uint32_t)now.tv_sec;
3574 return unode;
3575 }
3576
3577 if (list->node_count < nfsrv_user_stat_max_nodes) {
3578 /* Allocate a new node */
3579 MALLOC(unode, struct nfs_user_stat_node *, sizeof(struct nfs_user_stat_node),
3580 M_TEMP, M_WAITOK | M_ZERO);
3581
3582 if (!unode)
3583 return NULL;
3584
3585 /* increment node count */
3586 OSAddAtomic(1, &nfsrv_user_stat_node_count);
3587 list->node_count++;
3588 } else {
3589 /* reuse the oldest node in the lru list */
3590 unode = TAILQ_FIRST(&list->user_lru);
3591
3592 if (!unode)
3593 return NULL;
3594
3595 /* Remove the node */
3596 TAILQ_REMOVE(&list->user_lru, unode, lru_link);
3597 LIST_REMOVE(unode, hash_link);
3598 }
3599
3600 /* Initialize the node */
3601 unode->uid = uid;
3602 bcopy(saddr, &unode->sock, saddr->sa_len);
3603 microtime(&now);
3604 unode->ops = 0;
3605 unode->bytes_read = 0;
3606 unode->bytes_written = 0;
3607 unode->tm_start = (uint32_t)now.tv_sec;
3608 unode->tm_last = (uint32_t)now.tv_sec;
3609
3610 /* insert the node */
3611 TAILQ_INSERT_TAIL(&list->user_lru, unode, lru_link);
3612 LIST_INSERT_HEAD(head, unode, hash_link);
3613
3614 return unode;
3615}
3616
3617void
3618nfsrv_update_user_stat(struct nfs_export *nx, struct nfsrv_descript *nd, uid_t uid, u_int ops, u_int rd_bytes, u_int wr_bytes)
3619{
3620 struct nfs_user_stat_node *unode;
3621 struct nfs_active_user_list *ulist;
3622 struct sockaddr *saddr;
3623
3624 if ((!nfsrv_user_stat_enabled) || (!nx) || (!nd) || (!nd->nd_nam))
3625 return;
3626
3627 saddr = (struct sockaddr *)mbuf_data(nd->nd_nam);
3628
3629 /* check address family before going any further */
3630 if ((saddr->sa_family != AF_INET) && (saddr->sa_family != AF_INET6))
3631 return;
3632
3633 ulist = &nx->nx_user_list;
3634
3635 /* lock the active user list */
3636 lck_mtx_lock(&ulist->user_mutex);
3637
3638 /* get the user node */
3639 unode = nfsrv_get_user_stat_node(ulist, saddr, uid);
3640
3641 if (!unode) {
3642 lck_mtx_unlock(&ulist->user_mutex);
3643 return;
3644 }
3645
3646 /* update counters */
3647 unode->ops += ops;
3648 unode->bytes_read += rd_bytes;
3649 unode->bytes_written += wr_bytes;
3650
3651 /* done */
3652 lck_mtx_unlock(&ulist->user_mutex);
3653}
3654
3655/* initialize an active user list */
3656void
3657nfsrv_init_user_list(struct nfs_active_user_list *ulist)
3658{
3659 uint i;
3660
3661 /* initialize the lru */
3662 TAILQ_INIT(&ulist->user_lru);
3663
3664 /* initialize the hash table */
3665 for(i = 0; i < NFS_USER_STAT_HASH_SIZE; i++)
3666 LIST_INIT(&ulist->user_hashtbl[i]);
3667 ulist->node_count = 0;
3668
3669 lck_mtx_init(&ulist->user_mutex, nfsrv_active_user_mutex_group, LCK_ATTR_NULL);
3670}
3671
3672/* Free all nodes in an active user list */
3673void
3674nfsrv_free_user_list(struct nfs_active_user_list *ulist)
3675{
3676 struct nfs_user_stat_node *unode;
3677
3678 if (!ulist)
3679 return;
3680
3681 while ((unode = TAILQ_FIRST(&ulist->user_lru))) {
3682 /* Remove node and free */
3683 TAILQ_REMOVE(&ulist->user_lru, unode, lru_link);
3684 LIST_REMOVE(unode, hash_link);
3685 FREE(unode, M_TEMP);
3686
3687 /* decrement node count */
3688 OSAddAtomic(-1, &nfsrv_user_stat_node_count);
3689 }
3690 ulist->node_count = 0;
3691
3692 lck_mtx_destroy(&ulist->user_mutex, nfsrv_active_user_mutex_group);
3693}
3694
3695/* Reclaim old expired user nodes from active user lists. */
3696void
3697nfsrv_active_user_list_reclaim(void)
3698{
3699 struct nfs_exportfs *nxfs;
3700 struct nfs_export *nx;
3701 struct nfs_active_user_list *ulist;
3702 struct nfs_user_stat_hashtbl_head oldlist;
3703 struct nfs_user_stat_node *unode, *unode_next;
3704 struct timeval now;
3705 uint32_t tstale;
3706
3707 LIST_INIT(&oldlist);
3708
3709 lck_rw_lock_shared(&nfsrv_export_rwlock);
3710 microtime(&now);
3711 tstale = now.tv_sec - nfsrv_user_stat_max_idle_sec;
3712 LIST_FOREACH(nxfs, &nfsrv_exports, nxfs_next) {
3713 LIST_FOREACH(nx, &nxfs->nxfs_exports, nx_next) {
3714 /* Scan through all user nodes of this export */
3715 ulist = &nx->nx_user_list;
3716 lck_mtx_lock(&ulist->user_mutex);
3717 for (unode = TAILQ_FIRST(&ulist->user_lru); unode; unode = unode_next) {
3718 unode_next = TAILQ_NEXT(unode, lru_link);
3719
3720 /* check if this node has expired */
3721 if (unode->tm_last >= tstale)
3722 break;
3723
3724 /* Remove node from the active user list */
3725 TAILQ_REMOVE(&ulist->user_lru, unode, lru_link);
3726 LIST_REMOVE(unode, hash_link);
3727
3728 /* Add node to temp list */
3729 LIST_INSERT_HEAD(&oldlist, unode, hash_link);
3730
3731 /* decrement node count */
3732 OSAddAtomic(-1, &nfsrv_user_stat_node_count);
3733 ulist->node_count--;
3734 }
3735 /* can unlock this export's list now */
3736 lck_mtx_unlock(&ulist->user_mutex);
3737 }
3738 }
3739 lck_rw_done(&nfsrv_export_rwlock);
3740
3741 /* Free expired nodes */
3742 while ((unode = LIST_FIRST(&oldlist))) {
3743 LIST_REMOVE(unode, hash_link);
3744 FREE(unode, M_TEMP);
3745 }
3746}
3747
3748/*
3749 * Maps errno values to nfs error numbers.
3750 * Use NFSERR_IO as the catch all for ones not specifically defined in
3751 * RFC 1094.
3752 */
3753static u_char nfsrv_v2errmap[] = {
3754 NFSERR_PERM, NFSERR_NOENT, NFSERR_IO, NFSERR_IO, NFSERR_IO,
3755 NFSERR_NXIO, NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO,
3756 NFSERR_IO, NFSERR_IO, NFSERR_ACCES, NFSERR_IO, NFSERR_IO,
3757 NFSERR_IO, NFSERR_EXIST, NFSERR_IO, NFSERR_NODEV, NFSERR_NOTDIR,
3758 NFSERR_ISDIR, NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO,
3759 NFSERR_IO, NFSERR_FBIG, NFSERR_NOSPC, NFSERR_IO, NFSERR_ROFS,
3760 NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO,
3761 NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO,
3762 NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO,
3763 NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO,
3764 NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO,
3765 NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO,
3766 NFSERR_IO, NFSERR_IO, NFSERR_NAMETOL, NFSERR_IO, NFSERR_IO,
3767 NFSERR_NOTEMPTY, NFSERR_IO, NFSERR_IO, NFSERR_DQUOT, NFSERR_STALE,
3768};
3769
3770/*
3771 * Maps errno values to nfs error numbers.
3772 * Although it is not obvious whether or not NFS clients really care if
3773 * a returned error value is in the specified list for the procedure, the
3774 * safest thing to do is filter them appropriately. For Version 2, the
3775 * X/Open XNFS document is the only specification that defines error values
3776 * for each RPC (The RFC simply lists all possible error values for all RPCs),
3777 * so I have decided to not do this for Version 2.
3778 * The first entry is the default error return and the rest are the valid
3779 * errors for that RPC in increasing numeric order.
3780 */
3781static short nfsv3err_null[] = {
3782 0,
3783 0,
3784};
3785
3786static short nfsv3err_getattr[] = {
3787 NFSERR_IO,
3788 NFSERR_IO,
3789 NFSERR_STALE,
3790 NFSERR_BADHANDLE,
3791 NFSERR_SERVERFAULT,
3792 NFSERR_TRYLATER,
3793 0,
3794};
3795
3796static short nfsv3err_setattr[] = {
3797 NFSERR_IO,
3798 NFSERR_PERM,
3799 NFSERR_IO,
3800 NFSERR_ACCES,
3801 NFSERR_INVAL,
3802 NFSERR_NOSPC,
3803 NFSERR_ROFS,
3804 NFSERR_DQUOT,
3805 NFSERR_STALE,
3806 NFSERR_BADHANDLE,
3807 NFSERR_NOT_SYNC,
3808 NFSERR_SERVERFAULT,
3809 NFSERR_TRYLATER,
3810 0,
3811};
3812
3813static short nfsv3err_lookup[] = {
3814 NFSERR_IO,
3815 NFSERR_NOENT,
3816 NFSERR_IO,
3817 NFSERR_ACCES,
3818 NFSERR_NOTDIR,
3819 NFSERR_NAMETOL,
3820 NFSERR_STALE,
3821 NFSERR_BADHANDLE,
3822 NFSERR_SERVERFAULT,
3823 NFSERR_TRYLATER,
3824 0,
3825};
3826
3827static short nfsv3err_access[] = {
3828 NFSERR_IO,
3829 NFSERR_IO,
3830 NFSERR_STALE,
3831 NFSERR_BADHANDLE,
3832 NFSERR_SERVERFAULT,
3833 NFSERR_TRYLATER,
3834 0,
3835};
3836
3837static short nfsv3err_readlink[] = {
3838 NFSERR_IO,
3839 NFSERR_IO,
3840 NFSERR_ACCES,
3841 NFSERR_INVAL,
3842 NFSERR_STALE,
3843 NFSERR_BADHANDLE,
3844 NFSERR_NOTSUPP,
3845 NFSERR_SERVERFAULT,
3846 NFSERR_TRYLATER,
3847 0,
3848};
3849
3850static short nfsv3err_read[] = {
3851 NFSERR_IO,
3852 NFSERR_IO,
3853 NFSERR_NXIO,
3854 NFSERR_ACCES,
3855 NFSERR_INVAL,
3856 NFSERR_STALE,
3857 NFSERR_BADHANDLE,
3858 NFSERR_SERVERFAULT,
3859 NFSERR_TRYLATER,
3860 0,
3861};
3862
3863static short nfsv3err_write[] = {
3864 NFSERR_IO,
3865 NFSERR_IO,
3866 NFSERR_ACCES,
3867 NFSERR_INVAL,
3868 NFSERR_FBIG,
3869 NFSERR_NOSPC,
3870 NFSERR_ROFS,
3871 NFSERR_DQUOT,
3872 NFSERR_STALE,
3873 NFSERR_BADHANDLE,
3874 NFSERR_SERVERFAULT,
3875 NFSERR_TRYLATER,
3876 0,
3877};
3878
3879static short nfsv3err_create[] = {
3880 NFSERR_IO,
3881 NFSERR_IO,
3882 NFSERR_ACCES,
3883 NFSERR_EXIST,
3884 NFSERR_NOTDIR,
3885 NFSERR_NOSPC,
3886 NFSERR_ROFS,
3887 NFSERR_NAMETOL,
3888 NFSERR_DQUOT,
3889 NFSERR_STALE,
3890 NFSERR_BADHANDLE,
3891 NFSERR_NOTSUPP,
3892 NFSERR_SERVERFAULT,
3893 NFSERR_TRYLATER,
3894 0,
3895};
3896
3897static short nfsv3err_mkdir[] = {
3898 NFSERR_IO,
3899 NFSERR_IO,
3900 NFSERR_ACCES,
3901 NFSERR_EXIST,
3902 NFSERR_NOTDIR,
3903 NFSERR_NOSPC,
3904 NFSERR_ROFS,
3905 NFSERR_NAMETOL,
3906 NFSERR_DQUOT,
3907 NFSERR_STALE,
3908 NFSERR_BADHANDLE,
3909 NFSERR_NOTSUPP,
3910 NFSERR_SERVERFAULT,
3911 NFSERR_TRYLATER,
3912 0,
3913};
3914
3915static short nfsv3err_symlink[] = {
3916 NFSERR_IO,
3917 NFSERR_IO,
3918 NFSERR_ACCES,
3919 NFSERR_EXIST,
3920 NFSERR_NOTDIR,
3921 NFSERR_NOSPC,
3922 NFSERR_ROFS,
3923 NFSERR_NAMETOL,
3924 NFSERR_DQUOT,
3925 NFSERR_STALE,
3926 NFSERR_BADHANDLE,
3927 NFSERR_NOTSUPP,
3928 NFSERR_SERVERFAULT,
3929 NFSERR_TRYLATER,
3930 0,
3931};
3932
3933static short nfsv3err_mknod[] = {
3934 NFSERR_IO,
3935 NFSERR_IO,
3936 NFSERR_ACCES,
3937 NFSERR_EXIST,
3938 NFSERR_NOTDIR,
3939 NFSERR_NOSPC,
3940 NFSERR_ROFS,
3941 NFSERR_NAMETOL,
3942 NFSERR_DQUOT,
3943 NFSERR_STALE,
3944 NFSERR_BADHANDLE,
3945 NFSERR_NOTSUPP,
3946 NFSERR_SERVERFAULT,
3947 NFSERR_BADTYPE,
3948 NFSERR_TRYLATER,
3949 0,
3950};
3951
3952static short nfsv3err_remove[] = {
3953 NFSERR_IO,
3954 NFSERR_NOENT,
3955 NFSERR_IO,
3956 NFSERR_ACCES,
3957 NFSERR_NOTDIR,
3958 NFSERR_ROFS,
3959 NFSERR_NAMETOL,
3960 NFSERR_STALE,
3961 NFSERR_BADHANDLE,
3962 NFSERR_SERVERFAULT,
3963 NFSERR_TRYLATER,
3964 0,
3965};
3966
3967static short nfsv3err_rmdir[] = {
3968 NFSERR_IO,
3969 NFSERR_NOENT,
3970 NFSERR_IO,
3971 NFSERR_ACCES,
3972 NFSERR_EXIST,
3973 NFSERR_NOTDIR,
3974 NFSERR_INVAL,
3975 NFSERR_ROFS,
3976 NFSERR_NAMETOL,
3977 NFSERR_NOTEMPTY,
3978 NFSERR_STALE,
3979 NFSERR_BADHANDLE,
3980 NFSERR_NOTSUPP,
3981 NFSERR_SERVERFAULT,
3982 NFSERR_TRYLATER,
3983 0,
3984};
3985
3986static short nfsv3err_rename[] = {
3987 NFSERR_IO,
3988 NFSERR_NOENT,
3989 NFSERR_IO,
3990 NFSERR_ACCES,
3991 NFSERR_EXIST,
3992 NFSERR_XDEV,
3993 NFSERR_NOTDIR,
3994 NFSERR_ISDIR,
3995 NFSERR_INVAL,
3996 NFSERR_NOSPC,
3997 NFSERR_ROFS,
3998 NFSERR_MLINK,
3999 NFSERR_NAMETOL,
4000 NFSERR_NOTEMPTY,
4001 NFSERR_DQUOT,
4002 NFSERR_STALE,
4003 NFSERR_BADHANDLE,
4004 NFSERR_NOTSUPP,
4005 NFSERR_SERVERFAULT,
4006 NFSERR_TRYLATER,
4007 0,
4008};
4009
4010static short nfsv3err_link[] = {
4011 NFSERR_IO,
4012 NFSERR_IO,
4013 NFSERR_ACCES,
4014 NFSERR_EXIST,
4015 NFSERR_XDEV,
4016 NFSERR_NOTDIR,
4017 NFSERR_INVAL,
4018 NFSERR_NOSPC,
4019 NFSERR_ROFS,
4020 NFSERR_MLINK,
4021 NFSERR_NAMETOL,
4022 NFSERR_DQUOT,
4023 NFSERR_STALE,
4024 NFSERR_BADHANDLE,
4025 NFSERR_NOTSUPP,
4026 NFSERR_SERVERFAULT,
4027 NFSERR_TRYLATER,
4028 0,
4029};
4030
4031static short nfsv3err_readdir[] = {
4032 NFSERR_IO,
4033 NFSERR_IO,
4034 NFSERR_ACCES,
4035 NFSERR_NOTDIR,
4036 NFSERR_STALE,
4037 NFSERR_BADHANDLE,
4038 NFSERR_BAD_COOKIE,
4039 NFSERR_TOOSMALL,
4040 NFSERR_SERVERFAULT,
4041 NFSERR_TRYLATER,
4042 0,
4043};
4044
4045static short nfsv3err_readdirplus[] = {
4046 NFSERR_IO,
4047 NFSERR_IO,
4048 NFSERR_ACCES,
4049 NFSERR_NOTDIR,
4050 NFSERR_STALE,
4051 NFSERR_BADHANDLE,
4052 NFSERR_BAD_COOKIE,
4053 NFSERR_NOTSUPP,
4054 NFSERR_TOOSMALL,
4055 NFSERR_SERVERFAULT,
4056 NFSERR_TRYLATER,
4057 0,
4058};
4059
4060static short nfsv3err_fsstat[] = {
4061 NFSERR_IO,
4062 NFSERR_IO,
4063 NFSERR_STALE,
4064 NFSERR_BADHANDLE,
4065 NFSERR_SERVERFAULT,
4066 NFSERR_TRYLATER,
4067 0,
4068};
4069
4070static short nfsv3err_fsinfo[] = {
4071 NFSERR_STALE,
4072 NFSERR_STALE,
4073 NFSERR_BADHANDLE,
4074 NFSERR_SERVERFAULT,
4075 NFSERR_TRYLATER,
4076 0,
4077};
4078
4079static short nfsv3err_pathconf[] = {
4080 NFSERR_STALE,
4081 NFSERR_STALE,
4082 NFSERR_BADHANDLE,
4083 NFSERR_SERVERFAULT,
4084 NFSERR_TRYLATER,
4085 0,
4086};
4087
4088static short nfsv3err_commit[] = {
4089 NFSERR_IO,
4090 NFSERR_IO,
4091 NFSERR_STALE,
4092 NFSERR_BADHANDLE,
4093 NFSERR_SERVERFAULT,
4094 NFSERR_TRYLATER,
4095 0,
4096};
4097
4098static short *nfsrv_v3errmap[] = {
4099 nfsv3err_null,
4100 nfsv3err_getattr,
4101 nfsv3err_setattr,
4102 nfsv3err_lookup,
4103 nfsv3err_access,
4104 nfsv3err_readlink,
4105 nfsv3err_read,
4106 nfsv3err_write,
4107 nfsv3err_create,
4108 nfsv3err_mkdir,
4109 nfsv3err_symlink,
4110 nfsv3err_mknod,
4111 nfsv3err_remove,
4112 nfsv3err_rmdir,
4113 nfsv3err_rename,
4114 nfsv3err_link,
4115 nfsv3err_readdir,
4116 nfsv3err_readdirplus,
4117 nfsv3err_fsstat,
4118 nfsv3err_fsinfo,
4119 nfsv3err_pathconf,
4120 nfsv3err_commit,
4121};
4122
4123/*
4124 * Map errnos to NFS error numbers. For Version 3 also filter out error
4125 * numbers not specified for the associated procedure.
4126 */
4127int
4128nfsrv_errmap(struct nfsrv_descript *nd, int err)
4129{
4130 short *defaulterrp, *errp;
4131
4132 if (nd->nd_vers == NFS_VER2) {
4133 if (err <= (int)sizeof(nfsrv_v2errmap))
4134 return ((int)nfsrv_v2errmap[err - 1]);
4135 return (NFSERR_IO);
4136 }
4137 /* NFSv3 */
4138 if (nd->nd_procnum > NFSPROC_COMMIT)
4139 return (err & 0xffff);
4140 errp = defaulterrp = nfsrv_v3errmap[nd->nd_procnum];
4141 while (*++errp) {
4142 if (*errp == err)
4143 return (err);
4144 else if (*errp > err)
4145 break;
4146 }
4147 return ((int)*defaulterrp);
4148}
4149
4150#endif /* NFSSERVER */
4151
4152