]> git.saurik.com Git - apple/xnu.git/blame - bsd/nfs/nfs_subs.c
projects / apple / xnu.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
xnu-1699.24.23.tar.gz
[apple/xnu.git] / bsd / nfs / nfs_subs.c
CommitLineData
1c79356b 1/*
6d2010ae 2 * Copyright (c) 2000-2011 Apple Inc. All rights reserved.
5d5c5d0d 3 *
2d21ac55 4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
1c79356b 5 *
2d21ac55
A		 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.
8f6c56a5 14 *
2d21ac55
A		 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
8f6c56a5
A		 20 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
21 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
2d21ac55
A		 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.
8f6c56a5 25 *
2d21ac55 26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
1c79356b
A		 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>
91447636 75#include <sys/kauth.h>
1c79356b
A		 76#include <sys/systm.h>
77#include <sys/kernel.h>
91447636
A		 78#include <sys/mount_internal.h>
79#include <sys/vnode_internal.h>
80#include <sys/kpi_mbuf.h>
1c79356b
A		 81#include <sys/socket.h>
82#include <sys/stat.h>
83#include <sys/malloc.h>
84#include <sys/syscall.h>
91447636 85#include <sys/ubc_internal.h>
e5568f75 86#include <sys/fcntl.h>
b0d623f7 87#include <sys/uio.h>
91447636
A		 88#include <sys/domain.h>
89#include <libkern/OSAtomic.h>
2d21ac55 90#include <kern/thread_call.h>
1c79356b
A		 91
92#include <sys/vm.h>
93#include <sys/vmparam.h>
1c79356b
A		 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>
6d2010ae
A		 102#if NFSCLIENT
103#define _NFS_XDR_SUBS_FUNCS_ /* define this to get xdrbuf function definitions */
104#endif
1c79356b
A		 105#include <nfs/xdr_subs.h>
106#include <nfs/nfsm_subs.h>
2d21ac55 107#include <nfs/nfs_gss.h>
1c79356b 108#include <nfs/nfsmount.h>
e5568f75 109#include <nfs/nfs_lock.h>
1c79356b
A		 110
111#include <miscfs/specfs/specdev.h>
112
113#include <netinet/in.h>
2d21ac55
A		 114#include <net/kpi_interface.h>
115
6d2010ae
A		 116#include <sys/utfconv.h>
117
1c79356b 118/*
2d21ac55 119 * NFS globals
1c79356b 120 */
2d21ac55
A		 121struct nfsstats 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{
b0d623f7
A		 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:
2d21ac55 203 return vnode_makeimode(VCHR, m);
b0d623f7
A		 204 case VBAD:
205 case VSTR:
206 case VCPLX:
207 default:
208 return vnode_makeimode(VNON, m);
209 }
2d21ac55
A		 210}
211
212#if NFSSERVER
1c79356b 213
1c79356b
A		 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,
1c79356b
A		 240 NFSPROC_NOOP
241};
242
2d21ac55
A		 243#endif /* NFSSERVER */
244
1c79356b
A		 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,
91447636 271 NFSV2PROC_NOOP
1c79356b
A		 272};
273
2d21ac55 274
1c79356b 275/*
2d21ac55 276 * initialize NFS's cache of mbuf constants
1c79356b 277 */
2d21ac55
A		 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
1c79356b
A		 289
290/*
2d21ac55 291 * allocate a list of mbufs to hold the given amount of data
1c79356b 292 */
2d21ac55
A		 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;
1c79356b 299
2d21ac55
A		 300 error = cnt = 0;
301 mhead = mlast = NULL;
302 len = 0;
1c79356b 303
2d21ac55
A		 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 }
1c79356b 322
2d21ac55
A		 323 if (!error) {
324 *mp = mhead;
325 *mbcnt = cnt;
326 }
327 return (error);
328}
1c79356b 329
2d21ac55 330#endif /* NFSSERVER */
1c79356b 331
2d21ac55
A		 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;
1c79356b 342
2d21ac55
A		 343 if (nmc->nmc_flags & NFSM_CHAIN_FLAG_ADD_CLUSTERS)
344 sizehint = nfs_mbuf_minclsize;
1c79356b 345
2d21ac55
A		 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 }
1c79356b 364
2d21ac55
A		 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);
1c79356b 369
2d21ac55
A		 370 return (0);
371}
1c79356b 372
2d21ac55
A		 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;
1c79356b 383
2d21ac55 384 paddedlen = nfsm_rndup(len);
1c79356b 385
2d21ac55
A		 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}
1c79356b 412
1c79356b 413/*
2d21ac55
A		 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.
1c79356b 418 */
91447636 419int
2d21ac55 420nfsm_chain_add_opaque_nopad_f(struct nfsm_chain *nmc, const u_char *buf, uint32_t len)
1c79356b 421{
2d21ac55 422 uint32_t tlen;
91447636 423 int error;
1c79356b 424
2d21ac55
A		 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 }
91447636 438 return (0);
1c79356b
A		 439}
440
441/*
2d21ac55
A		 442 * nfsm_chain_add_uio()
443 *
444 * Add "len" bytes of data from "uio" to the given chain.
1c79356b 445 */
91447636 446int
b0d623f7 447nfsm_chain_add_uio(struct nfsm_chain *nmc, uio_t uio, uint32_t len)
1c79356b 448{
2d21ac55
A		 449 uint32_t paddedlen, tlen;
450 int error;
1c79356b 451
2d21ac55 452 paddedlen = nfsm_rndup(len);
1c79356b 453
2d21ac55
A		 454 while (paddedlen) {
455 if (!nmc->nmc_left) {
456 error = nfsm_chain_new_mbuf(nmc, paddedlen);
457 if (error)
458 return (error);
1c79356b 459 }
2d21ac55
A		 460 tlen = MIN(nmc->nmc_left, paddedlen);
461 if (tlen) {
462 if (len) {
463 if (tlen > len)
464 tlen = len;
b0d623f7 465 uiomove(nmc->nmc_ptr, tlen, uio);
2d21ac55
A		 466 } else {
467 bzero(nmc->nmc_ptr, tlen);
1c79356b 468 }
2d21ac55
A		 469 nmc->nmc_ptr += tlen;
470 nmc->nmc_left -= tlen;
471 paddedlen -= tlen;
472 if (len)
473 len -= tlen;
1c79356b 474 }
91447636 475 }
91447636 476 return (0);
1c79356b
A		 477}
478
479/*
2d21ac55
A		 480 * Find the length of the NFS mbuf chain
481 * up to the current encoding/decoding offset.
1c79356b
A		 482 */
483int
2d21ac55 484nfsm_chain_offset(struct nfsm_chain *nmc)
1c79356b 485{
2d21ac55
A		 486 mbuf_t mb;
487 int len = 0;
1c79356b 488
2d21ac55
A		 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);
1c79356b 493 }
2d21ac55
A		 494
495 return (len);
1c79356b
A		 496}
497
498/*
2d21ac55
A		 499 * nfsm_chain_advance()
500 *
501 * Advance an nfsm_chain by "len" bytes.
1c79356b
A		 502 */
503int
2d21ac55 504nfsm_chain_advance(struct nfsm_chain *nmc, uint32_t len)
1c79356b 505{
2d21ac55 506 mbuf_t mb;
1c79356b 507
2d21ac55
A		 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);
91447636 520 }
2d21ac55 521
1c79356b
A		 522 return (0);
523}
524
525/*
2d21ac55
A		 526 * nfsm_chain_reverse()
527 *
528 * Reverse decode offset in an nfsm_chain by "len" bytes.
1c79356b
A		 529 */
530int
2d21ac55 531nfsm_chain_reverse(struct nfsm_chain *nmc, uint32_t len)
1c79356b 532{
2d21ac55
A		 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);
1c79356b 541 }
2d21ac55
A		 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)
91447636 603 return (error);
2d21ac55
A		 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));
91447636 620 if (!error)
2d21ac55 621 error = mbuf_setnext(mbcur, mb);
91447636 622 if (error) {
2d21ac55 623 mbuf_free(mb);
91447636
A		 624 return (error);
625 }
2d21ac55
A		 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);
91447636 677 }
2d21ac55
A		 678 /* update pointer/need */
679 nmc->nmc_ptr += cplen;
680 need -= cplen;
1c79356b 681 }
2d21ac55
A		 682 /* if more needed, go to next mbuf */
683 if (need)
684 mb = mbuf_next(mb);
1c79356b 685 }
2d21ac55
A		 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);
1c79356b
A		 708}
709
710/*
2d21ac55
A		 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.
1c79356b
A		 715 */
716int
2d21ac55 717nfsm_chain_get_opaque_f(struct nfsm_chain *nmc, uint32_t len, u_char *buf)
1c79356b 718{
2d21ac55
A		 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 }
1c79356b 742 }
2d21ac55
A		 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);
1c79356b
A		 752}
753
754/*
2d21ac55
A		 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.
1c79356b
A		 759 */
760int
b0d623f7 761nfsm_chain_get_uio(struct nfsm_chain *nmc, uint32_t len, uio_t uio)
1c79356b 762{
2d21ac55
A		 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) {
b0d623f7 773 error = uiomove(nmc->nmc_ptr, cplen, uio);
2d21ac55
A		 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
6d2010ae
A		 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
2d21ac55
A		 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);
1c79356b 900 } else {
2d21ac55 901 nfsm_chain_add_32(error, nmc, NFS_TIME_DONT_CHANGE);
1c79356b 902 }
1c79356b 903 }
2d21ac55
A		 904
905 return (error);
1c79356b
A		 906}
907
2d21ac55 908
1c79356b 909/*
2d21ac55
A		 910 * nfsm_chain_get_fh_attr()
911 *
912 * Get the file handle and attributes from an mbuf chain. (NFSv2/v3)
1c79356b
A		 913 */
914int
2d21ac55
A		 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)
1c79356b 923{
2d21ac55 924 int error = 0, gotfh, gotattr;
1c79356b 925
2d21ac55 926 gotfh = gotattr = 1;
1c79356b 927
2d21ac55
A		 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() */
6d2010ae 944 if (nfs3_getattr_rpc(NULL, NFSTOMP(dnp), fhp->fh_data, fhp->fh_len, 0, ctx, nvap, xidp)) {
2d21ac55
A		 945 gotattr = 0;
946 fhp->fh_len = 0;
947 }
948 }
949nfsmout:
950 return (error);
951}
1c79356b 952
2d21ac55
A		 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);
1c79356b 978
2d21ac55 979 return (error);
1c79356b
A		 980}
981
b0d623f7
A		 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
1c79356b 1012/*
2d21ac55
A		 1013 * Build the RPC header and fill in the authorization info.
1014 * Returns the head of the mbuf list and the xid.
1c79356b 1015 */
2d21ac55
A		 1016
1017int
1018nfsm_rpchead(
1019 struct nfsreq *req,
2d21ac55
A		 1020 mbuf_t mrest,
1021 u_int64_t *xidp,
1022 mbuf_t *mreqp)
91447636 1023{
2d21ac55
A		 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);
91447636 1027
6d2010ae
A		 1028 return nfsm_rpchead2(nmp, nmp->nm_sotype, NFS_PROG, nfsvers, proc,
1029 req->r_auth, req->r_cred, req, mrest, xidp, mreqp);
2d21ac55
A		 1030}
1031
1032int
6d2010ae 1033nfsm_rpchead2(struct nfsmount *nmp, int sotype, int prog, int vers, int proc, int auth_type,
2d21ac55
A		 1034 kauth_cred_t cred, struct nfsreq *req, mbuf_t mrest, u_int64_t *xidp, mbuf_t *mreqp)
1035{
1036 mbuf_t mreq, mb;
6d2010ae 1037 int error, i, grpsiz, auth_len = 0, authsiz, reqlen;
2d21ac55 1038 size_t headlen;
2d21ac55
A		 1039 struct nfsm_chain nmreq;
1040
6d2010ae
A		 1041 /* calculate expected auth length */
1042 switch (auth_type) {
1043 case RPCAUTH_NONE:
1044 auth_len = 0;
1045 break;
1046 case RPCAUTH_SYS:
1047 {
1048 gid_t grouplist[NGROUPS];
1049 int groupcount = NGROUPS;
1050
1051 if (!cred)
1052 return (EINVAL);
1053
1054 (void)kauth_cred_getgroups(cred, grouplist, &groupcount);
1055 if (groupcount < 1)
1056 return (EINVAL);
1057
1058 auth_len = ((((groupcount - 1) > nmp->nm_numgrps) ?
1059 nmp->nm_numgrps : (groupcount - 1)) << 2) +
1060 5 * NFSX_UNSIGNED;
1061 break;
1062 }
1063 case RPCAUTH_KRB5:
1064 case RPCAUTH_KRB5I:
1065 case RPCAUTH_KRB5P:
1066 if (!req || !cred)
1067 return (EINVAL);
1068 auth_len = 5 * NFSX_UNSIGNED + 0; // zero context handle for now
1069 break;
1070 default:
1071 return (EINVAL);
1072 }
2d21ac55 1073 authsiz = nfsm_rndup(auth_len);
6d2010ae
A		 1074
1075 /* allocate the packet */
2d21ac55
A		 1076 headlen = authsiz + 10 * NFSX_UNSIGNED;
1077 if (sotype == SOCK_STREAM) /* also include room for any RPC Record Mark */
1078 headlen += NFSX_UNSIGNED;
1079 if (headlen >= nfs_mbuf_minclsize) {
1080 error = mbuf_getpacket(MBUF_WAITOK, &mreq);
1081 } else {
1082 error = mbuf_gethdr(MBUF_WAITOK, MBUF_TYPE_DATA, &mreq);
1083 if (!error) {
1084 if (headlen < nfs_mbuf_mhlen)
1085 mbuf_align_32(mreq, headlen);
1086 else
1087 mbuf_align_32(mreq, 8 * NFSX_UNSIGNED);
1088 }
1089 }
1090 if (error) {
1091 /* unable to allocate packet */
1092 /* XXX should we keep statistics for these errors? */
1093 return (error);
1094 }
1095
1096 /*
1097 * If the caller gave us a non-zero XID then use it because
1098 * it may be a higher-level resend with a GSSAPI credential.
1099 * Otherwise, allocate a new one.
1100 */
b0d623f7
A		 1101 if (*xidp == 0)
1102 nfs_get_xid(xidp);
2d21ac55
A		 1103
1104 /* build the header(s) */
b0d623f7 1105 nfsm_chain_init(&nmreq, mreq);
2d21ac55
A		 1106
1107 /* First, if it's a TCP stream insert space for an RPC record mark */
1108 if (sotype == SOCK_STREAM)
1109 nfsm_chain_add_32(error, &nmreq, 0);
1110
1111 /* Then the RPC header. */
1112 nfsm_chain_add_32(error, &nmreq, (*xidp & 0xffffffff));
1113 nfsm_chain_add_32(error, &nmreq, RPC_CALL);
1114 nfsm_chain_add_32(error, &nmreq, RPC_VER2);
1115 nfsm_chain_add_32(error, &nmreq, prog);
1116 nfsm_chain_add_32(error, &nmreq, vers);
1117 nfsm_chain_add_32(error, &nmreq, proc);
1118
1119add_cred:
1120 switch (auth_type) {
6d2010ae
A		 1121 case RPCAUTH_NONE:
1122 nfsm_chain_add_32(error, &nmreq, RPCAUTH_NONE); /* auth */
2d21ac55 1123 nfsm_chain_add_32(error, &nmreq, 0); /* length */
6d2010ae 1124 nfsm_chain_add_32(error, &nmreq, RPCAUTH_NONE); /* verf */
2d21ac55
A		 1125 nfsm_chain_add_32(error, &nmreq, 0); /* length */
1126 nfsm_chain_build_done(error, &nmreq);
6d2010ae
A		 1127 /* Append the args mbufs */
1128 if (!error)
1129 error = mbuf_setnext(nmreq.nmc_mcur, mrest);
2d21ac55 1130 break;
6d2010ae
A		 1131 case RPCAUTH_SYS: {
1132 gid_t grouplist[NGROUPS];
1133 int groupcount;
1134
1135 nfsm_chain_add_32(error, &nmreq, RPCAUTH_SYS);
2d21ac55
A		 1136 nfsm_chain_add_32(error, &nmreq, authsiz);
1137 nfsm_chain_add_32(error, &nmreq, 0); /* stamp */
1138 nfsm_chain_add_32(error, &nmreq, 0); /* zero-length hostname */
1139 nfsm_chain_add_32(error, &nmreq, kauth_cred_getuid(cred)); /* UID */
6d2010ae 1140 nfsm_chain_add_32(error, &nmreq, kauth_cred_getgid(cred)); /* GID */
2d21ac55
A		 1141 grpsiz = (auth_len >> 2) - 5;
1142 nfsm_chain_add_32(error, &nmreq, grpsiz);/* additional GIDs */
6d2010ae
A		 1143 memset(grouplist, 0, sizeof(grouplist));
1144 groupcount = grpsiz;
1145 (void)kauth_cred_getgroups(cred, grouplist, &groupcount);
2d21ac55 1146 for (i = 1; i <= grpsiz; i++)
6d2010ae 1147 nfsm_chain_add_32(error, &nmreq, grouplist[i]);
2d21ac55
A		 1148
1149 /* And the verifier... */
6d2010ae 1150 nfsm_chain_add_32(error, &nmreq, RPCAUTH_NONE); /* flavor */
2d21ac55
A		 1151 nfsm_chain_add_32(error, &nmreq, 0); /* length */
1152 nfsm_chain_build_done(error, &nmreq);
1153
1154 /* Append the args mbufs */
1155 if (!error)
1156 error = mbuf_setnext(nmreq.nmc_mcur, mrest);
1157 break;
6d2010ae 1158 }
2d21ac55
A		 1159 case RPCAUTH_KRB5:
1160 case RPCAUTH_KRB5I:
1161 case RPCAUTH_KRB5P:
1162 error = nfs_gss_clnt_cred_put(req, &nmreq, mrest);
1163 if (error == ENEEDAUTH) {
6d2010ae
A		 1164 gid_t grouplist[NGROUPS];
1165 int groupcount = NGROUPS;
2d21ac55
A		 1166 /*
1167 * Use sec=sys for this user
1168 */
1169 error = 0;
6d2010ae
A		 1170 req->r_auth = auth_type = RPCAUTH_SYS;
1171 (void)kauth_cred_getgroups(cred, grouplist, &groupcount);
1172 auth_len = ((((groupcount - 1) > nmp->nm_numgrps) ?
1173 nmp->nm_numgrps : (groupcount - 1)) << 2) +
1174 5 * NFSX_UNSIGNED;
1175 authsiz = nfsm_rndup(auth_len);
2d21ac55
A		 1176 goto add_cred;
1177 }
1178 break;
1179 };
1180
1181 /* finish setting up the packet */
1182 if (!error)
1183 error = mbuf_pkthdr_setrcvif(mreq, 0);
1184
1185 if (error) {
1186 mbuf_freem(mreq);
1187 return (error);
1188 }
1189
1190 /* Calculate the size of the request */
1191 reqlen = 0;
1192 for (mb = nmreq.nmc_mhead; mb; mb = mbuf_next(mb))
1193 reqlen += mbuf_len(mb);
1194
1195 mbuf_pkthdr_setlen(mreq, reqlen);
1196
1197 /*
1198 * If the request goes on a TCP stream,
1199 * set its size in the RPC record mark.
1200 * The record mark count doesn't include itself
1201 * and the last fragment bit is set.
1202 */
1203 if (sotype == SOCK_STREAM)
1204 nfsm_chain_set_recmark(error, &nmreq,
1205 (reqlen - NFSX_UNSIGNED) | 0x80000000);
1206
1207 *mreqp = mreq;
1208 return (0);
91447636 1209}
1c79356b
A		 1210
1211/*
2d21ac55 1212 * Parse an NFS file attribute structure out of an mbuf chain.
1c79356b
A		 1213 */
1214int
2d21ac55 1215nfs_parsefattr(struct nfsm_chain *nmc, int nfsvers, struct nfs_vattr *nvap)
1c79356b 1216{
2d21ac55 1217 int error = 0;
91447636 1218 enum vtype vtype;
1c79356b 1219 u_short vmode;
2d21ac55
A		 1220 uint32_t val, val2;
1221 dev_t rdev;
55e303ae 1222
2d21ac55 1223 val = val2 = 0;
6d2010ae
A		 1224 NVATTR_INIT(nvap);
1225
1226 NFS_BITMAP_SET(nvap->nva_bitmap, NFS_FATTR_TYPE);
1227 NFS_BITMAP_SET(nvap->nva_bitmap, NFS_FATTR_MODE);
1228 NFS_BITMAP_SET(nvap->nva_bitmap, NFS_FATTR_NUMLINKS);
1229 NFS_BITMAP_SET(nvap->nva_bitmap, NFS_FATTR_OWNER);
1230 NFS_BITMAP_SET(nvap->nva_bitmap, NFS_FATTR_OWNER_GROUP);
1231 NFS_BITMAP_SET(nvap->nva_bitmap, NFS_FATTR_SIZE);
1232 NFS_BITMAP_SET(nvap->nva_bitmap, NFS_FATTR_SPACE_USED);
1233 NFS_BITMAP_SET(nvap->nva_bitmap, NFS_FATTR_RAWDEV);
1234 NFS_BITMAP_SET(nvap->nva_bitmap, NFS_FATTR_FSID);
1235 NFS_BITMAP_SET(nvap->nva_bitmap, NFS_FATTR_FILEID);
1236 NFS_BITMAP_SET(nvap->nva_bitmap, NFS_FATTR_TIME_ACCESS);
1237 NFS_BITMAP_SET(nvap->nva_bitmap, NFS_FATTR_TIME_MODIFY);
1238 NFS_BITMAP_SET(nvap->nva_bitmap, NFS_FATTR_TIME_METADATA);
2d21ac55
A		 1239
1240 nfsm_chain_get_32(error, nmc, vtype);
1241 nfsm_chain_get_32(error, nmc, vmode);
1242 nfsmout_if(error);
1243
1244 if (nfsvers == NFS_VER3) {
1245 nvap->nva_type = nfstov_type(vtype, nfsvers);
1c79356b 1246 } else {
1c79356b 1247 /*
1c79356b
A		 1248 * The duplicate information returned in fa_type and fa_mode
1249 * is an ambiguity in the NFS version 2 protocol.
1250 *
1251 * VREG should be taken literally as a regular file. If a
2d21ac55 1252 * server intends to return some type information differently
1c79356b
A		 1253 * in the upper bits of the mode field (e.g. for sockets, or
1254 * FIFOs), NFSv2 mandates fa_type to be VNON. Anyway, we
1255 * leave the examination of the mode bits even in the VREG
1256 * case to avoid breakage for bogus servers, but we make sure
1257 * that there are actually type bits set in the upper part of
1258 * fa_mode (and failing that, trust the va_type field).
1259 *
1260 * NFSv3 cleared the issue, and requires fa_mode to not
2d21ac55
A		 1261 * contain any type information (while also introducing
1262 * sockets and FIFOs for fa_type).
1c79356b 1263 */
2d21ac55
A		 1264 vtype = nfstov_type(vtype, nfsvers);
1265 if ((vtype == VNON) || ((vtype == VREG) && ((vmode & S_IFMT) != 0)))
91447636 1266 vtype = IFTOVT(vmode);
2d21ac55 1267 nvap->nva_type = vtype;
91447636
A		 1268 }
1269
91447636 1270 nvap->nva_mode = (vmode & 07777);
91447636 1271
2d21ac55
A		 1272 nfsm_chain_get_32(error, nmc, nvap->nva_nlink);
1273 nfsm_chain_get_32(error, nmc, nvap->nva_uid);
1274 nfsm_chain_get_32(error, nmc, nvap->nva_gid);
1275
1276 if (nfsvers == NFS_VER3) {
1277 nfsm_chain_get_64(error, nmc, nvap->nva_size);
1278 nfsm_chain_get_64(error, nmc, nvap->nva_bytes);
1279 nfsm_chain_get_32(error, nmc, nvap->nva_rawdev.specdata1);
1280 nfsm_chain_get_32(error, nmc, nvap->nva_rawdev.specdata2);
1281 nfsmout_if(error);
1282 nfsm_chain_get_64(error, nmc, nvap->nva_fsid.major);
1283 nvap->nva_fsid.minor = 0;
1284 nfsm_chain_get_64(error, nmc, nvap->nva_fileid);
1285 } else {
1286 nfsm_chain_get_32(error, nmc, nvap->nva_size);
1287 nfsm_chain_adv(error, nmc, NFSX_UNSIGNED);
1288 nfsm_chain_get_32(error, nmc, rdev);
1289 nfsmout_if(error);
1290 nvap->nva_rawdev.specdata1 = major(rdev);
1291 nvap->nva_rawdev.specdata2 = minor(rdev);
1292 nfsm_chain_get_32(error, nmc, val); /* blocks */
1293 nfsmout_if(error);
1294 nvap->nva_bytes = val * NFS_FABLKSIZE;
1295 nfsm_chain_get_32(error, nmc, val);
1296 nfsmout_if(error);
1297 nvap->nva_fsid.major = (uint64_t)val;
1298 nvap->nva_fsid.minor = 0;
1299 nfsm_chain_get_32(error, nmc, val);
1300 nfsmout_if(error);
1301 nvap->nva_fileid = (uint64_t)val;
1302 /* Really ugly NFSv2 kludge. */
1303 if ((vtype == VCHR) && (rdev == (dev_t)0xffffffff))
1304 nvap->nva_type = VFIFO;
1305 }
1306 nfsm_chain_get_time(error, nmc, nfsvers,
1307 nvap->nva_timesec[NFSTIME_ACCESS],
1308 nvap->nva_timensec[NFSTIME_ACCESS]);
1309 nfsm_chain_get_time(error, nmc, nfsvers,
1310 nvap->nva_timesec[NFSTIME_MODIFY],
1311 nvap->nva_timensec[NFSTIME_MODIFY]);
1312 nfsm_chain_get_time(error, nmc, nfsvers,
1313 nvap->nva_timesec[NFSTIME_CHANGE],
1314 nvap->nva_timensec[NFSTIME_CHANGE]);
1315nfsmout:
1316 return (error);
91447636
A		 1317}
1318
1319/*
1320 * Load the attribute cache (that lives in the nfsnode entry) with
1321 * the value pointed to by nvap, unless the file type in the attribute
1322 * cache doesn't match the file type in the nvap, in which case log a
1323 * warning and return ESTALE.
1324 *
1325 * If the dontshrink flag is set, then it's not safe to call ubc_setsize()
1326 * to shrink the size of the file.
1327 */
1328int
1329nfs_loadattrcache(
2d21ac55 1330 nfsnode_t np,
91447636
A		 1331 struct nfs_vattr *nvap,
1332 u_int64_t *xidp,
1333 int dontshrink)
1334{
1335 mount_t mp;
1336 vnode_t vp;
1337 struct timeval now;
1338 struct nfs_vattr *npnvap;
6d2010ae
A		 1339 int xattr = np->n_vattr.nva_flags & NFS_FFLAG_IS_ATTR;
1340 int referral = np->n_vattr.nva_flags & NFS_FFLAG_TRIGGER_REFERRAL;
1341 int aclbit, monitored, error = 0;
1342 kauth_acl_t acl;
1343 struct nfsmount *nmp;
1344 uint32_t events = np->n_events;
91447636 1345
2d21ac55 1346 if (np->n_hflag & NHINIT) {
91447636
A		 1347 vp = NULL;
1348 mp = np->n_mount;
1349 } else {
1350 vp = NFSTOV(np);
1351 mp = vnode_mount(vp);
1352 }
6d2010ae 1353 monitored = vp ? vnode_ismonitored(vp) : 0;
91447636 1354
2d21ac55 1355 FSDBG_TOP(527, np, vp, *xidp >> 32, *xidp);
91447636 1356
6d2010ae 1357 if (!((nmp = VFSTONFS(mp)))) {
91447636 1358 FSDBG_BOT(527, ENXIO, 1, 0, *xidp);
2d21ac55 1359 return (ENXIO);
1c79356b
A		 1360 }
1361
55e303ae 1362 if (*xidp < np->n_xid) {
fa4905b1
A		 1363 /*
1364 * We have already updated attributes with a response from
1365 * a later request. The attributes we have here are probably
2d21ac55 1366 * stale so we drop them (just return). However, our
fa4905b1
A		 1367 * out-of-order receipt could be correct - if the requests were
1368 * processed out of order at the server. Given the uncertainty
1369 * we invalidate our cached attributes. *xidp is zeroed here
1370 * to indicate the attributes were dropped - only getattr
1371 * cares - it needs to retry the rpc.
1372 */
91447636 1373 NATTRINVALIDATE(np);
fa4905b1
A		 1374 FSDBG_BOT(527, 0, np, np->n_xid, *xidp);
1375 *xidp = 0;
1376 return (0);
1377 }
1c79356b 1378
91447636
A		 1379 if (vp && (nvap->nva_type != vnode_vtype(vp))) {
1380 /*
1381 * The filehandle has changed type on us. This can be
1382 * caused by either the server not having unique filehandles
1383 * or because another client has removed the previous
1384 * filehandle and a new object (of a different type)
1385 * has been created with the same filehandle.
1386 *
1387 * We can't simply switch the type on the vnode because
1388 * there may be type-specific fields that need to be
1389 * cleaned up or set up.
1390 *
1391 * So, what should we do with this vnode?
1392 *
1393 * About the best we can do is log a warning and return
1394 * an error. ESTALE is about the closest error, but it
1395 * is a little strange that we come up with this error
1396 * internally instead of simply passing it through from
1397 * the server. Hopefully, the vnode will be reclaimed
1398 * soon so the filehandle can be reincarnated as the new
1399 * object type.
1400 */
1401 printf("nfs loadattrcache vnode changed type, was %d now %d\n",
1402 vnode_vtype(vp), nvap->nva_type);
6d2010ae
A		 1403 error = ESTALE;
1404 if (monitored)
1405 events |= VNODE_EVENT_DELETE;
1406 goto out;
1c79356b
A		 1407 }
1408
6d2010ae
A		 1409 npnvap = &np->n_vattr;
1410
1411 /*
1412 * The ACL cache needs special handling because it is not
1413 * always updated. Save current ACL cache state so it can
1414 * be restored after copying the new attributes into place.
1415 */
1416 aclbit = NFS_BITMAP_ISSET(npnvap->nva_bitmap, NFS_FATTR_ACL);
1417 acl = npnvap->nva_acl;
1418
1419 if (monitored) {
1420 /*
1421 * For monitored nodes, check for attribute changes that should generate events.
1422 */
1423 if (NFS_BITMAP_ISSET(nvap->nva_bitmap, NFS_FATTR_NUMLINKS) &&
1424 (nvap->nva_nlink != npnvap->nva_nlink))
1425 events |= VNODE_EVENT_ATTRIB | VNODE_EVENT_LINK;
1426 if (events & VNODE_EVENT_PERMS)
1427 /* no need to do all the checking if it's already set */;
1428 else if (NFS_BITMAP_ISSET(nvap->nva_bitmap, NFS_FATTR_MODE) &&
1429 (nvap->nva_mode != npnvap->nva_mode))
1430 events |= VNODE_EVENT_ATTRIB | VNODE_EVENT_PERMS;
1431 else if (NFS_BITMAP_ISSET(nvap->nva_bitmap, NFS_FATTR_OWNER) &&
1432 (nvap->nva_uid != npnvap->nva_uid))
1433 events |= VNODE_EVENT_ATTRIB | VNODE_EVENT_PERMS;
1434 else if (NFS_BITMAP_ISSET(nvap->nva_bitmap, NFS_FATTR_OWNER_GROUP) &&
1435 (nvap->nva_gid != npnvap->nva_gid))
1436 events |= VNODE_EVENT_ATTRIB | VNODE_EVENT_PERMS;
1437 else if (nmp->nm_vers >= NFS_VER4) {
1438 if (NFS_BITMAP_ISSET(nvap->nva_bitmap, NFS_FATTR_OWNER) &&
1439 !kauth_guid_equal(&nvap->nva_uuuid, &npnvap->nva_uuuid))
1440 events |= VNODE_EVENT_ATTRIB | VNODE_EVENT_PERMS;
1441 else if (NFS_BITMAP_ISSET(nvap->nva_bitmap, NFS_FATTR_OWNER_GROUP) &&
1442 !kauth_guid_equal(&nvap->nva_guuid, &npnvap->nva_guuid))
1443 events |= VNODE_EVENT_ATTRIB | VNODE_EVENT_PERMS;
1444 else if ((NFS_BITMAP_ISSET(nvap->nva_bitmap, NFS_FATTR_ACL) &&
1445 nvap->nva_acl && npnvap->nva_acl &&
1446 ((nvap->nva_acl->acl_entrycount != npnvap->nva_acl->acl_entrycount) ||
1447 bcmp(nvap->nva_acl, npnvap->nva_acl, KAUTH_ACL_COPYSIZE(nvap->nva_acl)))))
1448 events |= VNODE_EVENT_ATTRIB | VNODE_EVENT_PERMS;
1449 }
1450 if (((nmp->nm_vers >= NFS_VER4) && (nvap->nva_change != npnvap->nva_change)) ||
1451 (NFS_BITMAP_ISSET(npnvap->nva_bitmap, NFS_FATTR_TIME_MODIFY) &&
1452 ((nvap->nva_timesec[NFSTIME_MODIFY] != npnvap->nva_timesec[NFSTIME_MODIFY]) ||
1453 (nvap->nva_timensec[NFSTIME_MODIFY] != npnvap->nva_timensec[NFSTIME_MODIFY]))))
1454 events |= VNODE_EVENT_ATTRIB | VNODE_EVENT_WRITE;
1455 if (!events && NFS_BITMAP_ISSET(npnvap->nva_bitmap, NFS_FATTR_RAWDEV) &&
1456 ((nvap->nva_rawdev.specdata1 != npnvap->nva_rawdev.specdata1) ||
1457 (nvap->nva_rawdev.specdata2 != npnvap->nva_rawdev.specdata2)))
1458 events |= VNODE_EVENT_ATTRIB;
1459 if (!events && NFS_BITMAP_ISSET(npnvap->nva_bitmap, NFS_FATTR_FILEID) &&
1460 (nvap->nva_fileid != npnvap->nva_fileid))
1461 events |= VNODE_EVENT_ATTRIB;
1462 if (!events && NFS_BITMAP_ISSET(npnvap->nva_bitmap, NFS_FATTR_ARCHIVE) &&
1463 ((nvap->nva_flags & NFS_FFLAG_ARCHIVED) != (npnvap->nva_flags & NFS_FFLAG_ARCHIVED)))
1464 events |= VNODE_EVENT_ATTRIB;
1465 if (!events && NFS_BITMAP_ISSET(npnvap->nva_bitmap, NFS_FATTR_HIDDEN) &&
1466 ((nvap->nva_flags & NFS_FFLAG_HIDDEN) != (npnvap->nva_flags & NFS_FFLAG_HIDDEN)))
1467 events |= VNODE_EVENT_ATTRIB;
1468 if (!events && NFS_BITMAP_ISSET(npnvap->nva_bitmap, NFS_FATTR_TIME_CREATE) &&
1469 ((nvap->nva_timesec[NFSTIME_CREATE] != npnvap->nva_timesec[NFSTIME_CREATE]) ||
1470 (nvap->nva_timensec[NFSTIME_CREATE] != npnvap->nva_timensec[NFSTIME_CREATE])))
1471 events |= VNODE_EVENT_ATTRIB;
1472 if (!events && NFS_BITMAP_ISSET(npnvap->nva_bitmap, NFS_FATTR_TIME_BACKUP) &&
1473 ((nvap->nva_timesec[NFSTIME_BACKUP] != npnvap->nva_timesec[NFSTIME_BACKUP]) ||
1474 (nvap->nva_timensec[NFSTIME_BACKUP] != npnvap->nva_timensec[NFSTIME_BACKUP])))
1475 events |= VNODE_EVENT_ATTRIB;
1476 }
1477
1478 /* Copy the attributes to the attribute cache */
1479 bcopy((caddr_t)nvap, (caddr_t)npnvap, sizeof(*nvap));
1480
55e303ae
A		 1481 microuptime(&now);
1482 np->n_attrstamp = now.tv_sec;
91447636 1483 np->n_xid = *xidp;
6d2010ae
A		 1484 /* NFS_FFLAG_IS_ATTR and NFS_FFLAG_TRIGGER_REFERRAL need to be sticky... */
1485 if (vp && xattr)
1486 nvap->nva_flags |= xattr;
1487 if (vp && referral)
1488 nvap->nva_flags |= referral;
1489
1490 if (NFS_BITMAP_ISSET(npnvap->nva_bitmap, NFS_FATTR_ACL)) {
1491 /* we're updating the ACL */
1492 if (nvap->nva_acl) {
1493 /* make a copy of the acl for the cache */
1494 npnvap->nva_acl = kauth_acl_alloc(nvap->nva_acl->acl_entrycount);
1495 if (npnvap->nva_acl) {
1496 bcopy(nvap->nva_acl, npnvap->nva_acl, KAUTH_ACL_COPYSIZE(nvap->nva_acl));
1497 } else {
1498 /* can't make a copy to cache, invalidate ACL cache */
1499 NFS_BITMAP_CLR(npnvap->nva_bitmap, NFS_FATTR_ACL);
1500 NACLINVALIDATE(np);
1501 aclbit = 0;
1502 }
1503 }
1504 if (acl) {
1505 kauth_acl_free(acl);
1506 acl = NULL;
1507 }
1508 }
1509 if (NFS_BITMAP_ISSET(npnvap->nva_bitmap, NFS_FATTR_ACL)) {
1510 /* update the ACL timestamp */
1511 np->n_aclstamp = now.tv_sec;
1512 } else {
1513 /* we aren't updating the ACL, so restore original values */
1514 if (aclbit)
1515 NFS_BITMAP_SET(npnvap->nva_bitmap, NFS_FATTR_ACL);
1516 npnvap->nva_acl = acl;
1517 }
55e303ae 1518
6d2010ae
A		 1519#if CONFIG_TRIGGERS
1520 /*
1521 * For NFSv4, if the fsid doesn't match the fsid for the mount, then
1522 * this node is for a different file system on the server. So we mark
1523 * this node as a trigger node that will trigger the mirror mount.
1524 */
1525 if ((nmp->nm_vers >= NFS_VER4) && (nvap->nva_type == VDIR) &&
1526 ((np->n_vattr.nva_fsid.major != nmp->nm_fsid.major) ||
1527 (np->n_vattr.nva_fsid.minor != nmp->nm_fsid.minor)))
1528 np->n_vattr.nva_flags |= NFS_FFLAG_TRIGGER;
1529#endif
1c79356b 1530
b0d623f7
A		 1531 if (!vp || (nvap->nva_type != VREG)) {
1532 np->n_size = nvap->nva_size;
1533 } else if (nvap->nva_size != np->n_size) {
2d21ac55 1534 FSDBG(527, np, nvap->nva_size, np->n_size, (nvap->nva_type == VREG) | (np->n_flag & NMODIFIED ? 6 : 4));
b0d623f7
A		 1535 if (!UBCINFOEXISTS(vp) || (dontshrink && (nvap->nva_size < np->n_size))) {
1536 /* asked not to shrink, so stick with current size */
1537 FSDBG(527, np, np->n_size, np->n_vattr.nva_size, 0xf00d0001);
1538 nvap->nva_size = np->n_size;
1539 NATTRINVALIDATE(np);
1540 } else if ((np->n_flag & NMODIFIED) && (nvap->nva_size < np->n_size)) {
1541 /* if we've modified, stick with larger size */
1542 FSDBG(527, np, np->n_size, np->n_vattr.nva_size, 0xf00d0002);
1543 nvap->nva_size = np->n_size;
1544 npnvap->nva_size = np->n_size;
1545 } else {
1546 /*
1547 * n_size is protected by the data lock, so we need to
1548 * defer updating it until it's safe. We save the new size
1549 * and set a flag and it'll get updated the next time we get/drop
1550 * the data lock or the next time we do a getattr.
1551 */
1552 np->n_newsize = nvap->nva_size;
1553 SET(np->n_flag, NUPDATESIZE);
6d2010ae
A		 1554 if (monitored)
1555 events |= VNODE_EVENT_ATTRIB | VNODE_EVENT_EXTEND;
91447636 1556 }
1c79356b
A		 1557 }
1558
91447636 1559 if (np->n_flag & NCHG) {
2d21ac55
A		 1560 if (np->n_flag & NACC) {
1561 nvap->nva_timesec[NFSTIME_ACCESS] = np->n_atim.tv_sec;
1562 nvap->nva_timensec[NFSTIME_ACCESS] = np->n_atim.tv_nsec;
1563 }
1564 if (np->n_flag & NUPD) {
1565 nvap->nva_timesec[NFSTIME_MODIFY] = np->n_mtim.tv_sec;
1566 nvap->nva_timensec[NFSTIME_MODIFY] = np->n_mtim.tv_nsec;
1567 }
1c79356b 1568 }
91447636 1569
6d2010ae
A		 1570out:
1571 if (monitored && events)
1572 nfs_vnode_notify(np, events);
1573 FSDBG_BOT(527, error, np, np->n_size, *xidp);
1574 return (error);
1c79356b
A		 1575}
1576
1577/*
91447636
A		 1578 * Calculate the attribute timeout based on
1579 * how recently the file has been modified.
1c79356b
A		 1580 */
1581int
2d21ac55 1582nfs_attrcachetimeout(nfsnode_t np)
1c79356b 1583{
91447636
A		 1584 struct nfsmount *nmp;
1585 struct timeval now;
6d2010ae
A		 1586 int isdir;
1587 uint32_t timeo;
55e303ae 1588
2d21ac55 1589 if (!(nmp = NFSTONMP(np)))
91447636
A		 1590 return (0);
1591
2d21ac55 1592 isdir = vnode_isdir(NFSTOV(np));
ab86ba33 1593
6d2010ae
A		 1594 if ((nmp->nm_vers >= NFS_VER4) && (np->n_openflags & N_DELEG_MASK)) {
1595 /* If we have a delegation, we always use the max timeout. */
1596 timeo = isdir ? nmp->nm_acdirmax : nmp->nm_acregmax;
1597 } else if ((np)->n_flag & NMODIFIED) {
1598 /* If we have modifications, we always use the min timeout. */
91447636 1599 timeo = isdir ? nmp->nm_acdirmin : nmp->nm_acregmin;
6d2010ae
A		 1600 } else {
1601 /* Otherwise, we base the timeout on how old the file seems. */
55e303ae
A		 1602 /* Note that if the client and server clocks are way out of sync, */
1603 /* timeout will probably get clamped to a min or max value */
1604 microtime(&now);
b0d623f7 1605 timeo = (now.tv_sec - (np)->n_vattr.nva_timesec[NFSTIME_MODIFY]) / 10;
91447636
A		 1606 if (isdir) {
1607 if (timeo < nmp->nm_acdirmin)
1608 timeo = nmp->nm_acdirmin;
1609 else if (timeo > nmp->nm_acdirmax)
1610 timeo = nmp->nm_acdirmax;
1611 } else {
1612 if (timeo < nmp->nm_acregmin)
1613 timeo = nmp->nm_acregmin;
1614 else if (timeo > nmp->nm_acregmax)
1615 timeo = nmp->nm_acregmax;
1616 }
55e303ae 1617 }
1c79356b 1618
91447636
A		 1619 return (timeo);
1620}
1621
1622/*
b0d623f7 1623 * Check the attribute cache time stamp.
91447636 1624 * If the cache is valid, copy contents to *nvaper and return 0
b0d623f7
A		 1625 * otherwise return an error.
1626 * Must be called with the node locked.
91447636
A		 1627 */
1628int
6d2010ae 1629nfs_getattrcache(nfsnode_t np, struct nfs_vattr *nvaper, int flags)
91447636 1630{
91447636
A		 1631 struct nfs_vattr *nvap;
1632 struct timeval nowup;
1633 int32_t timeo;
1634
6d2010ae
A		 1635 /* Check if the attributes are valid. */
1636 if (!NATTRVALID(np) || ((flags & NGA_ACL) && !NACLVALID(np))) {
2d21ac55 1637 FSDBG(528, np, 0, 0xffffff01, ENOENT);
b0d623f7 1638 OSAddAtomic(1, &nfsstats.attrcache_misses);
91447636
A		 1639 return (ENOENT);
1640 }
1641
6d2010ae 1642 /* Verify the cached attributes haven't timed out. */
2d21ac55 1643 timeo = nfs_attrcachetimeout(np);
55e303ae
A		 1644 microuptime(&nowup);
1645 if ((nowup.tv_sec - np->n_attrstamp) >= timeo) {
2d21ac55 1646 FSDBG(528, np, 0, 0xffffff02, ENOENT);
b0d623f7 1647 OSAddAtomic(1, &nfsstats.attrcache_misses);
1c79356b
A		 1648 return (ENOENT);
1649 }
6d2010ae
A		 1650 if ((flags & NGA_ACL) && ((nowup.tv_sec - np->n_aclstamp) >= timeo)) {
1651 FSDBG(528, np, 0, 0xffffff02, ENOENT);
1652 OSAddAtomic(1, &nfsstats.attrcache_misses);
1653 return (ENOENT);
1654 }
2d21ac55 1655
91447636 1656 nvap = &np->n_vattr;
2d21ac55 1657 FSDBG(528, np, nvap->nva_size, np->n_size, 0xcace);
b0d623f7 1658 OSAddAtomic(1, &nfsstats.attrcache_hits);
1c79356b 1659
b0d623f7
A		 1660 if (nvap->nva_type != VREG) {
1661 np->n_size = nvap->nva_size;
1662 } else if (nvap->nva_size != np->n_size) {
2d21ac55 1663 FSDBG(528, np, nvap->nva_size, np->n_size, (nvap->nva_type == VREG) | (np->n_flag & NMODIFIED ? 6 : 4));
b0d623f7
A		 1664 if ((np->n_flag & NMODIFIED) && (nvap->nva_size < np->n_size)) {
1665 /* if we've modified, stick with larger size */
2d21ac55 1666 nvap->nva_size = np->n_size;
b0d623f7
A		 1667 } else {
1668 /*
1669 * n_size is protected by the data lock, so we need to
1670 * defer updating it until it's safe. We save the new size
1671 * and set a flag and it'll get updated the next time we get/drop
1672 * the data lock or the next time we do a getattr.
1673 */
1674 np->n_newsize = nvap->nva_size;
1675 SET(np->n_flag, NUPDATESIZE);
2d21ac55 1676 }
1c79356b
A		 1677 }
1678
91447636 1679 bcopy((caddr_t)nvap, (caddr_t)nvaper, sizeof(struct nfs_vattr));
1c79356b 1680 if (np->n_flag & NCHG) {
2d21ac55
A		 1681 if (np->n_flag & NACC) {
1682 nvaper->nva_timesec[NFSTIME_ACCESS] = np->n_atim.tv_sec;
1683 nvaper->nva_timensec[NFSTIME_ACCESS] = np->n_atim.tv_nsec;
1684 }
1685 if (np->n_flag & NUPD) {
1686 nvaper->nva_timesec[NFSTIME_MODIFY] = np->n_mtim.tv_sec;
1687 nvaper->nva_timensec[NFSTIME_MODIFY] = np->n_mtim.tv_nsec;
1688 }
1c79356b 1689 }
6d2010ae
A		 1690 if (nvap->nva_acl) {
1691 if (flags & NGA_ACL) {
1692 nvaper->nva_acl = kauth_acl_alloc(nvap->nva_acl->acl_entrycount);
1693 if (!nvaper->nva_acl)
1694 return (ENOMEM);
1695 bcopy(nvap->nva_acl, nvaper->nva_acl, KAUTH_ACL_COPYSIZE(nvap->nva_acl));
1696 } else {
1697 nvaper->nva_acl = NULL;
1698 }
1699 }
1c79356b
A		 1700 return (0);
1701}
1702
6d2010ae
A		 1703/*
1704 * When creating file system objects:
1705 * Don't bother setting UID if it's the same as the credential performing the create.
1706 * Don't bother setting GID if it's the same as the directory or credential.
1707 */
1708void
1709nfs_avoid_needless_id_setting_on_create(nfsnode_t dnp, struct vnode_attr *vap, vfs_context_t ctx)
1710{
1711 if (VATTR_IS_ACTIVE(vap, va_uid)) {
1712 if (kauth_cred_getuid(vfs_context_ucred(ctx)) == vap->va_uid) {
1713 VATTR_CLEAR_ACTIVE(vap, va_uid);
1714 VATTR_CLEAR_ACTIVE(vap, va_uuuid);
1715 }
1716 }
1717 if (VATTR_IS_ACTIVE(vap, va_gid)) {
1718 if ((vap->va_gid == dnp->n_vattr.nva_gid) ||
1719 (kauth_cred_getgid(vfs_context_ucred(ctx)) == vap->va_gid)) {
1720 VATTR_CLEAR_ACTIVE(vap, va_gid);
1721 VATTR_CLEAR_ACTIVE(vap, va_guuid);
1722 }
1723 }
1724}
1725
1726/*
1727 * Convert a universal address string to a sockaddr structure.
1728 *
1729 * Universal addresses can be in the following formats:
1730 *
1731 * d = decimal (IPv4)
1732 * x = hexadecimal (IPv6)
1733 * p = port (decimal)
1734 *
1735 * d.d.d.d
1736 * d.d.d.d.p.p
1737 * x:x:x:x:x:x:x:x
1738 * x:x:x:x:x:x:x:x.p.p
1739 * x:x:x:x:x:x:d.d.d.d
1740 * x:x:x:x:x:x:d.d.d.d.p.p
1741 *
1742 * IPv6 strings can also have a series of zeroes elided
1743 * IPv6 strings can also have a %scope suffix at the end (after any port)
1744 *
1745 * rules & exceptions:
1746 * - value before : is hex
1747 * - value before . is dec
1748 * - once . hit, all values are dec
1749 * - hex+port case means value before first dot is actually hex
1750 * - . is always preceded by digits except if last hex was double-colon
1751 *
1752 * scan, converting #s to bytes
1753 * first time a . is encountered, scan the rest to count them.
1754 * 2 dots = just port
1755 * 3 dots = just IPv4 no port
1756 * 5 dots = IPv4 and port
1757 */
1758
1759#define IS_DIGIT(C) \
1760 (((C) >= '0') && ((C) <= '9'))
1761
1762#define IS_XDIGIT(C) \
1763 (IS_DIGIT(C) || \
1764 (((C) >= 'A') && ((C) <= 'F')) || \
1765 (((C) >= 'a') && ((C) <= 'f')))
1766
1767int
1768nfs_uaddr2sockaddr(const char *uaddr, struct sockaddr *addr)
1769{
1770 const char *p, *pd; /* pointers to current character in scan */
1771 const char *pnum; /* pointer to current number to decode */
1772 const char *pscope; /* pointer to IPv6 scope ID */
1773 uint8_t a[18]; /* octet array to store address bytes */
1774 int i; /* index of next octet to decode */
1775 int dci; /* index of octet to insert double-colon zeroes */
1776 int dcount, xdcount; /* count of digits in current number */
1777 int needmore; /* set when we know we need more input (e.g. after colon, period) */
1778 int dots; /* # of dots */
1779 int hex; /* contains hex values */
1780 unsigned long val; /* decoded value */
1781 int s; /* index used for sliding array to insert elided zeroes */
1782
1783#define HEXVALUE 0
1784#define DECIMALVALUE 1
1785#define GET(TYPE) \
1786 do { \
1787 if ((dcount <= 0) || (dcount > (((TYPE) == DECIMALVALUE) ? 3 : 4))) \
1788 return (0); \
1789 if (((TYPE) == DECIMALVALUE) && xdcount) \
1790 return (0); \
1791 val = strtoul(pnum, NULL, ((TYPE) == DECIMALVALUE) ? 10 : 16); \
1792 if (((TYPE) == DECIMALVALUE) && (val >= 256)) \
1793 return (0); \
1794 /* check if there is room left in the array */ \
1795 if (i > (int)(sizeof(a) - (((TYPE) == HEXVALUE) ? 2 : 1) - ((dci != -1) ? 2 : 0))) \
1796 return (0); \
1797 if ((TYPE) == HEXVALUE) \
1798 a[i++] = ((val >> 8) & 0xff); \
1799 a[i++] = (val & 0xff); \
1800 } while (0)
1801
1802 hex = 0;
1803 dots = 0;
1804 dci = -1;
1805 i = dcount = xdcount = 0;
1806 pnum = p = uaddr;
1807 pscope = NULL;
1808 needmore = 1;
1809 if ((*p == ':') && (*++p != ':')) /* if it starts with colon, gotta be a double */
1810 return (0);
1811
1812 while (*p) {
1813 if (IS_XDIGIT(*p)) {
1814 dcount++;
1815 if (!IS_DIGIT(*p))
1816 xdcount++;
1817 needmore = 0;
1818 p++;
1819 } else if (*p == '.') {
1820 /* rest is decimal IPv4 dotted quad and/or port */
1821 if (!dots) {
1822 /* this is the first, so count them */
1823 for (pd = p; *pd; pd++) {
1824 if (*pd == '.') {
1825 if (++dots > 5)
1826 return (0);
1827 } else if (hex && (*pd == '%')) {
1828 break;
1829 } else if ((*pd < '0') || (*pd > '9')) {
1830 return (0);
1831 }
1832 }
1833 if ((dots != 2) && (dots != 3) && (dots != 5))
1834 return (0);
1835 if (hex && (dots == 2)) { /* hex+port */
1836 if (!dcount && needmore)
1837 return (0);
1838 if (dcount) /* last hex may be elided zero */
1839 GET(HEXVALUE);
1840 } else {
1841 GET(DECIMALVALUE);
1842 }
1843 } else {
1844 GET(DECIMALVALUE);
1845 }
1846 dcount = xdcount = 0;
1847 needmore = 1;
1848 pnum = ++p;
1849 } else if (*p == ':') {
1850 hex = 1;
1851 if (dots)
1852 return (0);
1853 if (!dcount) { /* missing number, probably double colon */
1854 if (dci >= 0) /* can only have one double colon */
1855 return (0);
1856 dci = i;
1857 needmore = 0;
1858 } else {
1859 GET(HEXVALUE);
1860 dcount = xdcount = 0;
1861 needmore = 1;
1862 }
1863 pnum = ++p;
1864 } else if (*p == '%') { /* scope ID delimiter */
1865 if (!hex)
1866 return (0);
1867 p++;
1868 pscope = p;
1869 break;
1870 } else { /* unexpected character */
1871 return (0);
1872 }
1873 }
1874 if (needmore && !dcount)
1875 return (0);
1876 if (dcount) /* decode trailing number */
1877 GET(dots ? DECIMALVALUE : HEXVALUE);
1878 if (dci >= 0) { /* got a double-colon at i, need to insert a range of zeroes */
1879 /* if we got a port, slide to end of array */
1880 /* otherwise, slide to end of address (non-port) values */
1881 int end = ((dots == 2) || (dots == 5)) ? sizeof(a) : (sizeof(a) - 2);
1882 if (i % 2) /* length of zero range must be multiple of 2 */
1883 return (0);
1884 if (i >= end) /* no room? */
1885 return (0);
1886 /* slide (i-dci) numbers up from index dci */
1887 for (s=0; s < (i - dci); s++)
1888 a[end-1-s] = a[i-1-s];
1889 /* zero (end-i) numbers at index dci */
1890 for (s=0; s < (end - i); s++)
1891 a[dci+s] = 0;
1892 i = end;
1893 }
1894
1895 /* copy out resulting socket address */
1896 if (hex) {
1897 struct sockaddr_in6 *sin6 = (struct sockaddr_in6*)addr;
1898 if ((((dots == 0) || (dots == 3)) && (i != (sizeof(a)-2))))
1899 return (0);
1900 if ((((dots == 2) || (dots == 5)) && (i != sizeof(a))))
1901 return (0);
1902 bzero(sin6, sizeof(struct sockaddr_in6));
1903 sin6->sin6_len = sizeof(struct sockaddr_in6);
1904 sin6->sin6_family = AF_INET6;
1905 bcopy(a, &sin6->sin6_addr.s6_addr, sizeof(struct in6_addr));
1906 if ((dots == 5) || (dots == 2))
1907 sin6->sin6_port = htons((a[16] << 8) | a[17]);
1908 if (pscope) {
1909 for (p=pscope; IS_DIGIT(*p); p++)
1910 ;
1911 if (*p && !IS_DIGIT(*p)) { /* name */
1912 ifnet_t interface = NULL;
1913 if (ifnet_find_by_name(pscope, &interface) == 0)
1914 sin6->sin6_scope_id = ifnet_index(interface);
1915 if (interface)
1916 ifnet_release(interface);
1917 } else { /* decimal number */
1918 sin6->sin6_scope_id = strtoul(pscope, NULL, 10);
1919 }
1920 /* XXX should we also embed scope id for linklocal? */
1921 }
1922 } else {
1923 struct sockaddr_in *sin = (struct sockaddr_in*)addr;
1924 if ((dots != 3) && (dots != 5))
1925 return (0);
1926 if ((dots == 3) && (i != 4))
1927 return (0);
1928 if ((dots == 5) && (i != 6))
1929 return (0);
1930 bzero(sin, sizeof(struct sockaddr_in));
1931 sin->sin_len = sizeof(struct sockaddr_in);
1932 sin->sin_family = AF_INET;
1933 bcopy(a, &sin->sin_addr.s_addr, sizeof(struct in_addr));
1934 if (dots == 5)
1935 sin->sin_port = htons((a[4] << 8) | a[5]);
1936 }
1937 return (1);
1938}
1939
1940
2d21ac55
A		 1941#endif /* NFSCLIENT */
1942
1943/*
1944 * Schedule a callout thread to run an NFS timer function
1945 * interval milliseconds in the future.
1946 */
1947void
1948nfs_interval_timer_start(thread_call_t call, int interval)
1949{
1950 uint64_t deadline;
1951
1952 clock_interval_to_deadline(interval, 1000 * 1000, &deadline);
1953 thread_call_enter_delayed(call, deadline);
1954}
1955
1956
1957#if NFSSERVER
1958
b0d623f7
A		 1959int nfsrv_cmp_secflavs(struct nfs_sec *, struct nfs_sec *);
1960int nfsrv_hang_addrlist(struct nfs_export *, struct user_nfs_export_args *);
1961int nfsrv_free_netopt(struct radix_node *, void *);
1962int nfsrv_free_addrlist(struct nfs_export *, struct user_nfs_export_args *);
1963struct nfs_export_options *nfsrv_export_lookup(struct nfs_export *, mbuf_t);
1964struct nfs_export *nfsrv_fhtoexport(struct nfs_filehandle *);
6d2010ae 1965struct nfs_user_stat_node *nfsrv_get_user_stat_node(struct nfs_active_user_list *, struct sockaddr *, uid_t);
b0d623f7
A		 1966void nfsrv_init_user_list(struct nfs_active_user_list *);
1967void nfsrv_free_user_list(struct nfs_active_user_list *);
2d21ac55
A		 1968
1969/*
1970 * add NFSv3 WCC data to an mbuf chain
1971 */
1972int
1973nfsm_chain_add_wcc_data_f(
1974 struct nfsrv_descript *nd,
1975 struct nfsm_chain *nmc,
1976 int preattrerr,
1977 struct vnode_attr *prevap,
1978 int postattrerr,
1979 struct vnode_attr *postvap)
1980{
1981 int error = 0;
1982
1983 if (preattrerr) {
1984 nfsm_chain_add_32(error, nmc, FALSE);
1985 } else {
1986 nfsm_chain_add_32(error, nmc, TRUE);
1987 nfsm_chain_add_64(error, nmc, prevap->va_data_size);
1988 nfsm_chain_add_time(error, nmc, NFS_VER3, &prevap->va_modify_time);
1989 nfsm_chain_add_time(error, nmc, NFS_VER3, &prevap->va_change_time);
1990 }
1991 nfsm_chain_add_postop_attr(error, nd, nmc, postattrerr, postvap);
1992
1993 return (error);
1994}
1995
1c79356b 1996/*
91447636
A		 1997 * Extract a lookup path from the given mbufs and store it in
1998 * a newly allocated buffer saved in the given nameidata structure.
1c79356b
A		 1999 */
2000int
2d21ac55
A		 2001nfsm_chain_get_path_namei(
2002 struct nfsm_chain *nmc,
2003 uint32_t len,
2004 struct nameidata *nip)
1c79356b 2005{
2d21ac55
A		 2006 struct componentname *cnp = &nip->ni_cnd;
2007 int error = 0;
2008 char *cp;
2009
91447636 2010 if (len > (MAXPATHLEN - 1))
55e303ae
A		 2011 return (ENAMETOOLONG);
2012
91447636
A		 2013 /*
2014 * Get a buffer for the name to be translated, and copy the
2015 * name into the buffer.
2016 */
2017 MALLOC_ZONE(cnp->cn_pnbuf, caddr_t, MAXPATHLEN, M_NAMEI, M_WAITOK);
2018 if (!cnp->cn_pnbuf)
2019 return (ENOMEM);
55e303ae 2020 cnp->cn_pnlen = MAXPATHLEN;
91447636 2021 cnp->cn_flags |= HASBUF;
1c79356b 2022
2d21ac55
A		 2023 /* Copy the name from the mbuf list to the string */
2024 cp = cnp->cn_pnbuf;
2025 nfsm_chain_get_opaque(error, nmc, len, cp);
2026 if (error)
2027 goto out;
2028 cnp->cn_pnbuf[len] = '\0';
91447636 2029
2d21ac55
A		 2030 /* sanity check the string */
2031 if ((strlen(cp) != len) || strchr(cp, '/'))
2032 error = EACCES;
91447636
A		 2033out:
2034 if (error) {
2035 if (cnp->cn_pnbuf)
2036 FREE_ZONE(cnp->cn_pnbuf, MAXPATHLEN, M_NAMEI);
2037 cnp->cn_flags &= ~HASBUF;
2038 } else {
2d21ac55 2039 nip->ni_pathlen = len;
91447636
A		 2040 }
2041 return (error);
2042}
2043
2044/*
2045 * Set up nameidata for a lookup() call and do it.
91447636
A		 2046 */
2047int
2d21ac55
A		 2048nfsrv_namei(
2049 struct nfsrv_descript *nd,
2050 vfs_context_t ctx,
2051 struct nameidata *nip,
91447636 2052 struct nfs_filehandle *nfhp,
91447636
A		 2053 vnode_t *retdirp,
2054 struct nfs_export **nxp,
2055 struct nfs_export_options **nxop)
2056{
91447636
A		 2057 vnode_t dp;
2058 int error;
2d21ac55 2059 struct componentname *cnp = &nip->ni_cnd;
b0d623f7 2060 uint32_t cnflags;
91447636
A		 2061 char *tmppn;
2062
2063 *retdirp = NULL;
2064
1c79356b
A		 2065 /*
2066 * Extract and set starting directory.
2067 */
2d21ac55 2068 error = nfsrv_fhtovp(nfhp, nd, &dp, nxp, nxop);
1c79356b
A		 2069 if (error)
2070 goto out;
2d21ac55 2071 error = nfsrv_credcheck(nd, ctx, *nxp, *nxop);
91447636
A		 2072 if (error || (vnode_vtype(dp) != VDIR)) {
2073 vnode_put(dp);
1c79356b
A		 2074 error = ENOTDIR;
2075 goto out;
2076 }
2d21ac55 2077 *retdirp = dp;
1c79356b 2078
2d21ac55 2079 nip->ni_cnd.cn_context = ctx;
91447636
A		 2080
2081 if (*nxop && ((*nxop)->nxo_flags & NX_READONLY))
1c79356b
A		 2082 cnp->cn_flags |= RDONLY;
2083
1c79356b 2084 cnp->cn_flags |= NOCROSSMOUNT;
1c79356b 2085 cnp->cn_nameptr = cnp->cn_pnbuf;
2d21ac55
A		 2086 nip->ni_usedvp = nip->ni_startdir = dp;
2087
1c79356b
A		 2088 /*
2089 * And call lookup() to do the real work
2090 */
b0d623f7
A		 2091 cnflags = nip->ni_cnd.cn_flags; /* store in case we have to restore */
2092 while ((error = lookup(nip)) == ERECYCLE) {
2093 nip->ni_cnd.cn_flags = cnflags;
2094 cnp->cn_nameptr = cnp->cn_pnbuf;
2095 nip->ni_usedvp = nip->ni_dvp = nip->ni_startdir = dp;
2096 }
1c79356b 2097 if (error)
2d21ac55
A		 2098 goto out;
2099
2100 /* Check for encountering a symbolic link */
2101 if (cnp->cn_flags & ISSYMLINK) {
b0d623f7 2102#ifndef __LP64__
91447636
A		 2103 if ((cnp->cn_flags & FSNODELOCKHELD)) {
2104 cnp->cn_flags &= ~FSNODELOCKHELD;
2d21ac55 2105 unlock_fsnode(nip->ni_dvp, NULL);
1c79356b 2106 }
b0d623f7 2107#endif /* __LP64__ */
2d21ac55
A		 2108 if (cnp->cn_flags & (LOCKPARENT | WANTPARENT))
2109 vnode_put(nip->ni_dvp);
2110 if (nip->ni_vp) {
2111 vnode_put(nip->ni_vp);
2112 nip->ni_vp = NULL;
1c79356b 2113 }
2d21ac55 2114 error = EINVAL;
1c79356b 2115 }
1c79356b 2116out:
2d21ac55
A		 2117 if (error) {
2118 tmppn = cnp->cn_pnbuf;
2119 cnp->cn_pnbuf = NULL;
2120 cnp->cn_flags &= ~HASBUF;
2121 FREE_ZONE(tmppn, cnp->cn_pnlen, M_NAMEI);
2122 }
1c79356b
A		 2123 return (error);
2124}
2125
2126/*
b0d623f7 2127 * A fiddled version of m_adj() that ensures null fill to a 4-byte
1c79356b
A		 2128 * boundary and only trims off the back end
2129 */
2130void
2d21ac55 2131nfsm_adj(mbuf_t mp, int len, int nul)
1c79356b 2132{
91447636
A		 2133 mbuf_t m, mnext;
2134 int count, i, mlen;
2135 char *cp;
1c79356b
A		 2136
2137 /*
2138 * Trim from tail. Scan the mbuf chain,
2139 * calculating its length and finding the last mbuf.
2140 * If the adjustment only affects this mbuf, then just
2141 * adjust and return. Otherwise, rescan and truncate
2142 * after the remaining size.
2143 */
2144 count = 0;
2145 m = mp;
2146 for (;;) {
91447636
A		 2147 mlen = mbuf_len(m);
2148 count += mlen;
2149 mnext = mbuf_next(m);
2150 if (mnext == NULL)
1c79356b 2151 break;
91447636 2152 m = mnext;
1c79356b 2153 }
91447636
A		 2154 if (mlen > len) {
2155 mlen -= len;
2156 mbuf_setlen(m, mlen);
1c79356b 2157 if (nul > 0) {
91447636 2158 cp = (caddr_t)mbuf_data(m) + mlen - nul;
1c79356b
A		 2159 for (i = 0; i < nul; i++)
2160 *cp++ = '\0';
2161 }
2162 return;
2163 }
2164 count -= len;
2165 if (count < 0)
2166 count = 0;
2167 /*
2168 * Correct length for chain is "count".
2169 * Find the mbuf with last data, adjust its length,
2170 * and toss data from remaining mbufs on chain.
2171 */
91447636
A		 2172 for (m = mp; m; m = mbuf_next(m)) {
2173 mlen = mbuf_len(m);
2174 if (mlen >= count) {
2175 mlen = count;
2176 mbuf_setlen(m, count);
1c79356b 2177 if (nul > 0) {
91447636 2178 cp = (caddr_t)mbuf_data(m) + mlen - nul;
1c79356b
A		 2179 for (i = 0; i < nul; i++)
2180 *cp++ = '\0';
2181 }
2182 break;
2183 }
91447636 2184 count -= mlen;
1c79356b 2185 }
91447636
A		 2186 for (m = mbuf_next(m); m; m = mbuf_next(m))
2187 mbuf_setlen(m, 0);
1c79356b
A		 2188}
2189
2190/*
2d21ac55
A		 2191 * Trim the header out of the mbuf list and trim off any trailing
2192 * junk so that the mbuf list has only the write data.
1c79356b 2193 */
2d21ac55
A		 2194int
2195nfsm_chain_trim_data(struct nfsm_chain *nmc, int len, int *mlen)
1c79356b 2196{
2d21ac55
A		 2197 int cnt = 0, dlen, adjust;
2198 caddr_t data;
2199 mbuf_t m;
1c79356b 2200
2d21ac55
A		 2201 if (mlen)
2202 *mlen = 0;
1c79356b 2203
2d21ac55
A		 2204 /* trim header */
2205 for (m = nmc->nmc_mhead; m && (m != nmc->nmc_mcur); m = mbuf_next(m))
2206 mbuf_setlen(m, 0);
2207 if (!m)
2208 return (EIO);
2209
2210 /* trim current mbuf */
2211 data = mbuf_data(m);
2212 dlen = mbuf_len(m);
2213 adjust = nmc->nmc_ptr - data;
2214 dlen -= adjust;
2215 if ((dlen > 0) && (adjust > 0)) {
2216 if (mbuf_setdata(m, nmc->nmc_ptr, dlen))
2217 return(EIO);
2218 } else
2219 mbuf_setlen(m, dlen);
2220
2221 /* skip next len bytes */
2222 for (; m && (cnt < len); m = mbuf_next(m)) {
2223 dlen = mbuf_len(m);
2224 cnt += dlen;
2225 if (cnt > len) {
2226 /* truncate to end of data */
2227 mbuf_setlen(m, dlen - (cnt - len));
2228 if (m == nmc->nmc_mcur)
2229 nmc->nmc_left -= (cnt - len);
2230 cnt = len;
2231 }
1c79356b 2232 }
2d21ac55
A		 2233 if (mlen)
2234 *mlen = cnt;
2235
2236 /* trim any trailing data */
2237 if (m == nmc->nmc_mcur)
2238 nmc->nmc_left = 0;
2239 for (; m; m = mbuf_next(m))
2240 mbuf_setlen(m, 0);
2241
2242 return (0);
1c79356b
A		 2243}
2244
2d21ac55
A		 2245int
2246nfsm_chain_add_fattr(
2247 struct nfsrv_descript *nd,
2248 struct nfsm_chain *nmc,
2249 struct vnode_attr *vap)
1c79356b 2250{
2d21ac55 2251 int error = 0;
1c79356b 2252
91447636
A		 2253 // XXX Should we assert here that all fields are supported?
2254
2d21ac55
A		 2255 nfsm_chain_add_32(error, nmc, vtonfs_type(vap->va_type, nd->nd_vers));
2256 if (nd->nd_vers == NFS_VER3) {
2257 nfsm_chain_add_32(error, nmc, vap->va_mode & 07777);
2258 } else {
2259 nfsm_chain_add_32(error, nmc, vtonfsv2_mode(vap->va_type, vap->va_mode));
2260 }
2261 nfsm_chain_add_32(error, nmc, vap->va_nlink);
2262 nfsm_chain_add_32(error, nmc, vap->va_uid);
2263 nfsm_chain_add_32(error, nmc, vap->va_gid);
2264 if (nd->nd_vers == NFS_VER3) {
2265 nfsm_chain_add_64(error, nmc, vap->va_data_size);
2266 nfsm_chain_add_64(error, nmc, vap->va_data_alloc);
2267 nfsm_chain_add_32(error, nmc, major(vap->va_rdev));
2268 nfsm_chain_add_32(error, nmc, minor(vap->va_rdev));
2269 nfsm_chain_add_64(error, nmc, vap->va_fsid);
2270 nfsm_chain_add_64(error, nmc, vap->va_fileid);
1c79356b 2271 } else {
2d21ac55
A		 2272 nfsm_chain_add_32(error, nmc, vap->va_data_size);
2273 nfsm_chain_add_32(error, nmc, NFS_FABLKSIZE);
1c79356b 2274 if (vap->va_type == VFIFO)
2d21ac55 2275 nfsm_chain_add_32(error, nmc, 0xffffffff);
1c79356b 2276 else
2d21ac55
A		 2277 nfsm_chain_add_32(error, nmc, vap->va_rdev);
2278 nfsm_chain_add_32(error, nmc, vap->va_data_alloc / NFS_FABLKSIZE);
2279 nfsm_chain_add_32(error, nmc, vap->va_fsid);
2280 nfsm_chain_add_32(error, nmc, vap->va_fileid);
2281 }
2282 nfsm_chain_add_time(error, nmc, nd->nd_vers, &vap->va_access_time);
2283 nfsm_chain_add_time(error, nmc, nd->nd_vers, &vap->va_modify_time);
2284 nfsm_chain_add_time(error, nmc, nd->nd_vers, &vap->va_change_time);
2285
2286 return (error);
2287}
2288
2289int
2290nfsm_chain_get_sattr(
2291 struct nfsrv_descript *nd,
2292 struct nfsm_chain *nmc,
2293 struct vnode_attr *vap)
2294{
b0d623f7 2295 int error = 0;
2d21ac55
A		 2296 uint32_t val = 0;
2297 uint64_t val64;
2298 struct timespec now;
2299
2300 if (nd->nd_vers == NFS_VER2) {
2301 /*
2302 * There is/was a bug in the Sun client that puts 0xffff in the mode
2303 * field of sattr when it should put in 0xffffffff. The u_short
2304 * doesn't sign extend. So check the low order 2 bytes for 0xffff.
2305 */
2306 nfsm_chain_get_32(error, nmc, val);
2307 if ((val & 0xffff) != 0xffff) {
2308 VATTR_SET(vap, va_mode, val & 07777);
2309 /* save the "type" bits for NFSv2 create */
2310 VATTR_SET(vap, va_type, IFTOVT(val));
2311 VATTR_CLEAR_ACTIVE(vap, va_type);
2312 }
2313 nfsm_chain_get_32(error, nmc, val);
2314 if (val != (uint32_t)-1)
2315 VATTR_SET(vap, va_uid, val);
2316 nfsm_chain_get_32(error, nmc, val);
2317 if (val != (uint32_t)-1)
2318 VATTR_SET(vap, va_gid, val);
2319 /* save the "size" bits for NFSv2 create (even if they appear unset) */
2320 nfsm_chain_get_32(error, nmc, val);
2321 VATTR_SET(vap, va_data_size, val);
2322 if (val == (uint32_t)-1)
2323 VATTR_CLEAR_ACTIVE(vap, va_data_size);
2324 nfsm_chain_get_time(error, nmc, NFS_VER2,
2325 vap->va_access_time.tv_sec,
2326 vap->va_access_time.tv_nsec);
2327 if (vap->va_access_time.tv_sec != -1)
2328 VATTR_SET_ACTIVE(vap, va_access_time);
2329 nfsm_chain_get_time(error, nmc, NFS_VER2,
2330 vap->va_modify_time.tv_sec,
2331 vap->va_modify_time.tv_nsec);
2332 if (vap->va_modify_time.tv_sec != -1)
2333 VATTR_SET_ACTIVE(vap, va_modify_time);
2334 return (error);
2335 }
2336
2337 /* NFSv3 */
2338 nfsm_chain_get_32(error, nmc, val);
2339 if (val) {
2340 nfsm_chain_get_32(error, nmc, val);
2341 VATTR_SET(vap, va_mode, val & 07777);
2342 }
2343 nfsm_chain_get_32(error, nmc, val);
2344 if (val) {
2345 nfsm_chain_get_32(error, nmc, val);
2346 VATTR_SET(vap, va_uid, val);
2347 }
2348 nfsm_chain_get_32(error, nmc, val);
2349 if (val) {
2350 nfsm_chain_get_32(error, nmc, val);
2351 VATTR_SET(vap, va_gid, val);
2352 }
2353 nfsm_chain_get_32(error, nmc, val);
2354 if (val) {
2355 nfsm_chain_get_64(error, nmc, val64);
2356 VATTR_SET(vap, va_data_size, val64);
2357 }
2358 nanotime(&now);
2359 nfsm_chain_get_32(error, nmc, val);
2360 switch (val) {
2361 case NFS_TIME_SET_TO_CLIENT:
2362 nfsm_chain_get_time(error, nmc, nd->nd_vers,
2363 vap->va_access_time.tv_sec,
2364 vap->va_access_time.tv_nsec);
2365 VATTR_SET_ACTIVE(vap, va_access_time);
b0d623f7 2366 vap->va_vaflags &= ~VA_UTIMES_NULL;
2d21ac55
A		 2367 break;
2368 case NFS_TIME_SET_TO_SERVER:
2369 VATTR_SET(vap, va_access_time, now);
b0d623f7 2370 vap->va_vaflags |= VA_UTIMES_NULL;
2d21ac55
A		 2371 break;
2372 }
2373 nfsm_chain_get_32(error, nmc, val);
2374 switch (val) {
2375 case NFS_TIME_SET_TO_CLIENT:
2376 nfsm_chain_get_time(error, nmc, nd->nd_vers,
2377 vap->va_modify_time.tv_sec,
2378 vap->va_modify_time.tv_nsec);
2379 VATTR_SET_ACTIVE(vap, va_modify_time);
b0d623f7 2380 vap->va_vaflags &= ~VA_UTIMES_NULL;
2d21ac55
A		 2381 break;
2382 case NFS_TIME_SET_TO_SERVER:
2383 VATTR_SET(vap, va_modify_time, now);
b0d623f7
A		 2384 if (!VATTR_IS_ACTIVE(vap, va_access_time))
2385 vap->va_vaflags |= VA_UTIMES_NULL;
2d21ac55 2386 break;
91447636 2387 }
2d21ac55
A		 2388
2389 return (error);
2390}
2391
2392/*
2393 * Compare two security flavor structs
2394 */
b0d623f7 2395int
2d21ac55
A		 2396nfsrv_cmp_secflavs(struct nfs_sec *sf1, struct nfs_sec *sf2)
2397{
2398 int i;
2399
2400 if (sf1->count != sf2->count)
2401 return 1;
2402 for (i = 0; i < sf1->count; i++)
2403 if (sf1->flavors[i] != sf2->flavors[i])
2404 return 1;
2405 return 0;
91447636
A		 2406}
2407
2408/*
2409 * Build hash lists of net addresses and hang them off the NFS export.
2410 * Called by nfsrv_export() to set up the lists of export addresses.
2411 */
b0d623f7 2412int
91447636
A		 2413nfsrv_hang_addrlist(struct nfs_export *nx, struct user_nfs_export_args *unxa)
2414{
2415 struct nfs_export_net_args nxna;
2d21ac55 2416 struct nfs_netopt *no, *rn_no;
91447636
A		 2417 struct radix_node_head *rnh;
2418 struct radix_node *rn;
2419 struct sockaddr *saddr, *smask;
2420 struct domain *dom;
2421 int i, error;
2422 unsigned int net;
2423 user_addr_t uaddr;
2424 kauth_cred_t cred;
91447636
A		 2425
2426 uaddr = unxa->nxa_nets;
2427 for (net = 0; net < unxa->nxa_netcount; net++, uaddr += sizeof(nxna)) {
2428 error = copyin(uaddr, &nxna, sizeof(nxna));
2429 if (error)
2430 return (error);
2431
2432 if (nxna.nxna_flags & (NX_MAPROOT|NX_MAPALL)) {
6d2010ae
A		 2433 struct posix_cred temp_pcred;
2434 bzero(&temp_pcred, sizeof(temp_pcred));
2435 temp_pcred.cr_uid = nxna.nxna_cred.cr_uid;
2436 temp_pcred.cr_ngroups = nxna.nxna_cred.cr_ngroups;
91447636 2437 for (i=0; i < nxna.nxna_cred.cr_ngroups && i < NGROUPS; i++)
6d2010ae
A		 2438 temp_pcred.cr_groups[i] = nxna.nxna_cred.cr_groups[i];
2439 cred = posix_cred_create(&temp_pcred);
2d21ac55 2440 if (!IS_VALID_CRED(cred))
91447636
A		 2441 return (ENOMEM);
2442 } else {
0c530ab8 2443 cred = NOCRED;
91447636
A		 2444 }
2445
2446 if (nxna.nxna_addr.ss_len == 0) {
2447 /* No address means this is a default/world export */
2d21ac55
A		 2448 if (nx->nx_flags & NX_DEFAULTEXPORT) {
2449 if (IS_VALID_CRED(cred))
2450 kauth_cred_unref(&cred);
91447636 2451 return (EEXIST);
2d21ac55 2452 }
91447636
A		 2453 nx->nx_flags |= NX_DEFAULTEXPORT;
2454 nx->nx_defopt.nxo_flags = nxna.nxna_flags;
2455 nx->nx_defopt.nxo_cred = cred;
2d21ac55 2456 bcopy(&nxna.nxna_sec, &nx->nx_defopt.nxo_sec, sizeof(struct nfs_sec));
91447636
A		 2457 nx->nx_expcnt++;
2458 continue;
2459 }
2460
2461 i = sizeof(struct nfs_netopt);
2462 i += nxna.nxna_addr.ss_len + nxna.nxna_mask.ss_len;
2463 MALLOC(no, struct nfs_netopt *, i, M_NETADDR, M_WAITOK);
2d21ac55
A		 2464 if (!no) {
2465 if (IS_VALID_CRED(cred))
2466 kauth_cred_unref(&cred);
91447636 2467 return (ENOMEM);
2d21ac55 2468 }
91447636
A		 2469 bzero(no, sizeof(struct nfs_netopt));
2470 no->no_opt.nxo_flags = nxna.nxna_flags;
2471 no->no_opt.nxo_cred = cred;
2d21ac55 2472 bcopy(&nxna.nxna_sec, &no->no_opt.nxo_sec, sizeof(struct nfs_sec));
91447636
A		 2473
2474 saddr = (struct sockaddr *)(no + 1);
2475 bcopy(&nxna.nxna_addr, saddr, nxna.nxna_addr.ss_len);
2476 if (nxna.nxna_mask.ss_len) {
2477 smask = (struct sockaddr *)((caddr_t)saddr + nxna.nxna_addr.ss_len);
2478 bcopy(&nxna.nxna_mask, smask, nxna.nxna_mask.ss_len);
2479 } else {
2480 smask = NULL;
2481 }
2482 i = saddr->sa_family;
2483 if ((rnh = nx->nx_rtable[i]) == 0) {
2484 /*
2485 * Seems silly to initialize every AF when most are not
2486 * used, do so on demand here
2487 */
2488 for (dom = domains; dom; dom = dom->dom_next)
2489 if (dom->dom_family == i && dom->dom_rtattach) {
2490 dom->dom_rtattach((void **)&nx->nx_rtable[i],
2491 dom->dom_rtoffset);
2492 break;
2493 }
2494 if ((rnh = nx->nx_rtable[i]) == 0) {
0c530ab8
A		 2495 if (IS_VALID_CRED(cred))
2496 kauth_cred_unref(&cred);
91447636
A		 2497 _FREE(no, M_NETADDR);
2498 return (ENOBUFS);
2499 }
2500 }
2501 rn = (*rnh->rnh_addaddr)((caddr_t)saddr, (caddr_t)smask, rnh, no->no_rnodes);
2502 if (rn == 0) {
2503 /*
2504 * One of the reasons that rnh_addaddr may fail is that
2505 * the entry already exists. To check for this case, we
2506 * look up the entry to see if it is there. If so, we
2507 * do not need to make a new entry but do continue.
2d21ac55
A		 2508 *
2509 * XXX should this be rnh_lookup() instead?
91447636
A		 2510 */
2511 int matched = 0;
2512 rn = (*rnh->rnh_matchaddr)((caddr_t)saddr, rnh);
2d21ac55 2513 rn_no = (struct nfs_netopt *)rn;
91447636 2514 if (rn != 0 && (rn->rn_flags & RNF_ROOT) == 0 &&
2d21ac55
A		 2515 (rn_no->no_opt.nxo_flags == nxna.nxna_flags) &&
2516 (!nfsrv_cmp_secflavs(&rn_no->no_opt.nxo_sec, &nxna.nxna_sec))) {
2517 kauth_cred_t cred2 = rn_no->no_opt.nxo_cred;
2518 if (cred == cred2) {
2519 /* creds are same (or both NULL) */
2520 matched = 1;
6d2010ae
A		 2521 } else if (cred && cred2 && (kauth_cred_getuid(cred) == kauth_cred_getuid(cred2))) {
2522 /*
2523 * Now compare the effective and
2524 * supplementary groups...
2525 *
2526 * Note: This comparison, as written,
2527 * does not correctly indicate that
2528 * the groups are equivalent, since
2529 * other than the first supplementary
2530 * group, which is also the effective
2531 * group, order on the remaining groups
2532 * doesn't matter, and this is an
2533 * ordered compare.
2534 */
2535 gid_t groups[NGROUPS];
2536 gid_t groups2[NGROUPS];
2537 int groupcount = NGROUPS;
2538 int group2count = NGROUPS;
2539
2540 if (!kauth_cred_getgroups(cred, groups, &groupcount) &&
2541 !kauth_cred_getgroups(cred2, groups2, &group2count) &&
2542 groupcount == group2count) {
2543 for (i=0; i < group2count; i++)
2544 if (groups[i] != groups2[i])
2545 break;
2546 if (i >= group2count || i >= NGROUPS)
2547 matched = 1;
2548 }
91447636
A		 2549 }
2550 }
0c530ab8
A		 2551 if (IS_VALID_CRED(cred))
2552 kauth_cred_unref(&cred);
91447636
A		 2553 _FREE(no, M_NETADDR);
2554 if (matched)
2555 continue;
2556 return (EPERM);
2557 }
2558 nx->nx_expcnt++;
2559 }
2560
2561 return (0);
2562}
2563
2564/*
2d21ac55 2565 * In order to properly track an export's netopt count, we need to pass
91447636
A		 2566 * an additional argument to nfsrv_free_netopt() so that it can decrement
2567 * the export's netopt count.
2568 */
2569struct nfsrv_free_netopt_arg {
2570 uint32_t *cnt;
2571 struct radix_node_head *rnh;
2572};
2573
b0d623f7 2574int
91447636
A		 2575nfsrv_free_netopt(struct radix_node *rn, void *w)
2576{
2577 struct nfsrv_free_netopt_arg *fna = (struct nfsrv_free_netopt_arg *)w;
2578 struct radix_node_head *rnh = fna->rnh;
2579 uint32_t *cnt = fna->cnt;
2580 struct nfs_netopt *nno = (struct nfs_netopt *)rn;
2581
2582 (*rnh->rnh_deladdr)(rn->rn_key, rn->rn_mask, rnh);
0c530ab8
A		 2583 if (IS_VALID_CRED(nno->no_opt.nxo_cred))
2584 kauth_cred_unref(&nno->no_opt.nxo_cred);
91447636
A		 2585 _FREE((caddr_t)rn, M_NETADDR);
2586 *cnt -= 1;
2587 return (0);
2588}
2589
2590/*
2591 * Free the net address hash lists that are hanging off the mount points.
2592 */
b0d623f7 2593int
2d21ac55 2594nfsrv_free_addrlist(struct nfs_export *nx, struct user_nfs_export_args *unxa)
91447636 2595{
2d21ac55 2596 struct nfs_export_net_args nxna;
91447636 2597 struct radix_node_head *rnh;
2d21ac55 2598 struct radix_node *rn;
91447636 2599 struct nfsrv_free_netopt_arg fna;
2d21ac55
A		 2600 struct nfs_netopt *nno;
2601 user_addr_t uaddr;
2602 unsigned int net;
2603 int i, error;
2604
2605 if (!unxa || !unxa->nxa_netcount) {
2606 /* delete everything */
2607 for (i = 0; i <= AF_MAX; i++)
2608 if ( (rnh = nx->nx_rtable[i]) ) {
2609 fna.rnh = rnh;
2610 fna.cnt = &nx->nx_expcnt;
2611 (*rnh->rnh_walktree)(rnh, nfsrv_free_netopt, (caddr_t)&fna);
2612 _FREE((caddr_t)rnh, M_RTABLE);
2613 nx->nx_rtable[i] = 0;
2614 }
2615 return (0);
2616 }
2617
2618 /* delete only the exports specified */
2619 uaddr = unxa->nxa_nets;
2620 for (net = 0; net < unxa->nxa_netcount; net++, uaddr += sizeof(nxna)) {
2621 error = copyin(uaddr, &nxna, sizeof(nxna));
2622 if (error)
2623 return (error);
2624
2625 if (nxna.nxna_addr.ss_len == 0) {
2626 /* No address means this is a default/world export */
2627 if (nx->nx_flags & NX_DEFAULTEXPORT) {
2628 nx->nx_flags &= ~NX_DEFAULTEXPORT;
2629 if (IS_VALID_CRED(nx->nx_defopt.nxo_cred)) {
2630 kauth_cred_unref(&nx->nx_defopt.nxo_cred);
2631 }
2632 nx->nx_expcnt--;
2633 }
2634 continue;
2635 }
2636
2637 if ((rnh = nx->nx_rtable[nxna.nxna_addr.ss_family]) == 0) {
2638 /* AF not initialized? */
2639 if (!(unxa->nxa_flags & NXA_ADD))
2640 printf("nfsrv_free_addrlist: address not found (0)\n");
2641 continue;
2642 }
91447636 2643
2d21ac55
A		 2644 rn = (*rnh->rnh_lookup)(&nxna.nxna_addr,
2645 nxna.nxna_mask.ss_len ? &nxna.nxna_mask : NULL, rnh);
2646 if (!rn || (rn->rn_flags & RNF_ROOT)) {
2647 if (!(unxa->nxa_flags & NXA_ADD))
2648 printf("nfsrv_free_addrlist: address not found (1)\n");
2649 continue;
2650 }
2651
2652 (*rnh->rnh_deladdr)(rn->rn_key, rn->rn_mask, rnh);
2653 nno = (struct nfs_netopt *)rn;
2654 if (IS_VALID_CRED(nno->no_opt.nxo_cred))
2655 kauth_cred_unref(&nno->no_opt.nxo_cred);
2656 _FREE((caddr_t)rn, M_NETADDR);
2657
2658 nx->nx_expcnt--;
2659 if (nx->nx_expcnt == ((nx->nx_flags & NX_DEFAULTEXPORT) ? 1 : 0)) {
2660 /* no more entries in rnh, so free it up */
91447636 2661 _FREE((caddr_t)rnh, M_RTABLE);
2d21ac55 2662 nx->nx_rtable[nxna.nxna_addr.ss_family] = 0;
91447636 2663 }
2d21ac55
A		 2664 }
2665
2666 return (0);
91447636
A		 2667}
2668
2669void enablequotas(struct mount *mp, vfs_context_t ctx); // XXX
2670
2671int
2d21ac55 2672nfsrv_export(struct user_nfs_export_args *unxa, vfs_context_t ctx)
91447636 2673{
6d2010ae
A		 2674 int error = 0;
2675 size_t pathlen;
91447636
A		 2676 struct nfs_exportfs *nxfs, *nxfs2, *nxfs3;
2677 struct nfs_export *nx, *nx2, *nx3;
2678 struct nfs_filehandle nfh;
2679 struct nameidata mnd, xnd;
2680 vnode_t mvp = NULL, xvp = NULL;
2d21ac55 2681 mount_t mp = NULL;
91447636
A		 2682 char path[MAXPATHLEN];
2683 int expisroot;
2684
b0d623f7
A		 2685 if (unxa->nxa_flags == NXA_CHECK) {
2686 /* just check if the path is an NFS-exportable file system */
6d2010ae 2687 error = copyinstr(unxa->nxa_fspath, path, MAXPATHLEN, &pathlen);
b0d623f7
A		 2688 if (error)
2689 return (error);
6d2010ae 2690 NDINIT(&mnd, LOOKUP, OP_LOOKUP, FOLLOW | LOCKLEAF | AUDITVNPATH1,
b0d623f7
A		 2691 UIO_SYSSPACE, CAST_USER_ADDR_T(path), ctx);
2692 error = namei(&mnd);
2693 if (error)
2694 return (error);
2695 mvp = mnd.ni_vp;
2696 mp = vnode_mount(mvp);
2697 /* make sure it's the root of a file system */
2698 if (!vnode_isvroot(mvp))
2699 error = EINVAL;
2700 /* make sure the file system is NFS-exportable */
2701 if (!error) {
2702 nfh.nfh_len = NFSV3_MAX_FID_SIZE;
2703 error = VFS_VPTOFH(mvp, (int*)&nfh.nfh_len, &nfh.nfh_fid[0], NULL);
2704 }
2705 if (!error && (nfh.nfh_len > (int)NFSV3_MAX_FID_SIZE))
2706 error = EIO;
2707 if (!error && !(mp->mnt_vtable->vfc_vfsflags & VFC_VFSREADDIR_EXTENDED))
2708 error = EISDIR;
2709 vnode_put(mvp);
2710 nameidone(&mnd);
2711 return (error);
2712 }
2713
2714 /* all other operations: must be super user */
2715 if ((error = vfs_context_suser(ctx)))
2716 return (error);
2717
3a60a9f5
A		 2718 if (unxa->nxa_flags & NXA_DELETE_ALL) {
2719 /* delete all exports on all file systems */
2d21ac55
A		 2720 lck_rw_lock_exclusive(&nfsrv_export_rwlock);
2721 while ((nxfs = LIST_FIRST(&nfsrv_exports))) {
3a60a9f5 2722 mp = vfs_getvfs_by_mntonname(nxfs->nxfs_path);
6d2010ae 2723 if (mp) {
2d21ac55 2724 vfs_clearflags(mp, MNT_EXPORTED);
6d2010ae
A		 2725 mount_iterdrop(mp);
2726 mp = NULL;
2727 }
3a60a9f5
A		 2728 /* delete all exports on this file system */
2729 while ((nx = LIST_FIRST(&nxfs->nxfs_exports))) {
2730 LIST_REMOVE(nx, nx_next);
2731 LIST_REMOVE(nx, nx_hash);
2732 /* delete all netopts for this export */
2d21ac55 2733 nfsrv_free_addrlist(nx, NULL);
3a60a9f5 2734 nx->nx_flags &= ~NX_DEFAULTEXPORT;
0c530ab8
A		 2735 if (IS_VALID_CRED(nx->nx_defopt.nxo_cred)) {
2736 kauth_cred_unref(&nx->nx_defopt.nxo_cred);
3a60a9f5 2737 }
2d21ac55
A		 2738 /* free active user list for this export */
2739 nfsrv_free_user_list(&nx->nx_user_list);
3a60a9f5
A		 2740 FREE(nx->nx_path, M_TEMP);
2741 FREE(nx, M_TEMP);
2742 }
2743 LIST_REMOVE(nxfs, nxfs_next);
2744 FREE(nxfs->nxfs_path, M_TEMP);
2745 FREE(nxfs, M_TEMP);
2746 }
b0d623f7
A		 2747 if (nfsrv_export_hashtbl) {
2748 /* all exports deleted, clean up export hash table */
2749 FREE(nfsrv_export_hashtbl, M_TEMP);
2750 nfsrv_export_hashtbl = NULL;
2751 }
2d21ac55 2752 lck_rw_done(&nfsrv_export_rwlock);
3a60a9f5
A		 2753 return (0);
2754 }
2755
6d2010ae 2756 error = copyinstr(unxa->nxa_fspath, path, MAXPATHLEN, &pathlen);
91447636
A		 2757 if (error)
2758 return (error);
2759
2d21ac55 2760 lck_rw_lock_exclusive(&nfsrv_export_rwlock);
91447636 2761
b0d623f7
A		 2762 /* init export hash table if not already */
2763 if (!nfsrv_export_hashtbl) {
2764 if (nfsrv_export_hash_size <= 0)
2765 nfsrv_export_hash_size = NFSRVEXPHASHSZ;
2766 nfsrv_export_hashtbl = hashinit(nfsrv_export_hash_size, M_TEMP, &nfsrv_export_hash);
2767 }
2768
91447636 2769 // first check if we've already got an exportfs with the given ID
2d21ac55 2770 LIST_FOREACH(nxfs, &nfsrv_exports, nxfs_next) {
91447636
A		 2771 if (nxfs->nxfs_id == unxa->nxa_fsid)
2772 break;
2773 }
2774 if (nxfs) {
2775 /* verify exported FS path matches given path */
2d21ac55 2776 if (strncmp(path, nxfs->nxfs_path, MAXPATHLEN)) {
91447636
A		 2777 error = EEXIST;
2778 goto unlock_out;
2779 }
2d21ac55
A		 2780 if ((unxa->nxa_flags & (NXA_ADD|NXA_OFFLINE)) == NXA_ADD) {
2781 /* if adding, verify that the mount is still what we expect */
2782 mp = vfs_getvfs_by_mntonname(nxfs->nxfs_path);
6d2010ae
A		 2783 if (mp) {
2784 mount_ref(mp, 0);
2785 mount_iterdrop(mp);
2786 }
2d21ac55 2787 /* find exported FS root vnode */
6d2010ae 2788 NDINIT(&mnd, LOOKUP, OP_LOOKUP, FOLLOW | LOCKLEAF | AUDITVNPATH1,
2d21ac55
A		 2789 UIO_SYSSPACE, CAST_USER_ADDR_T(nxfs->nxfs_path), ctx);
2790 error = namei(&mnd);
2791 if (error)
2792 goto unlock_out;
2793 mvp = mnd.ni_vp;
2794 /* make sure it's (still) the root of a file system */
2795 if (!vnode_isvroot(mvp)) {
2796 error = EINVAL;
2797 goto out;
2798 }
2799 /* sanity check: this should be same mount */
2800 if (mp != vnode_mount(mvp)) {
2801 error = EINVAL;
2802 goto out;
2803 }
91447636
A		 2804 }
2805 } else {
2806 /* no current exported file system with that ID */
2807 if (!(unxa->nxa_flags & NXA_ADD)) {
2808 error = ENOENT;
2809 goto unlock_out;
2810 }
2811
2812 /* find exported FS root vnode */
6d2010ae 2813 NDINIT(&mnd, LOOKUP, OP_LOOKUP, FOLLOW | LOCKLEAF | AUDITVNPATH1,
2d21ac55 2814 UIO_SYSSPACE, CAST_USER_ADDR_T(path), ctx);
91447636 2815 error = namei(&mnd);
2d21ac55
A		 2816 if (error) {
2817 if (!(unxa->nxa_flags & NXA_OFFLINE))
2818 goto unlock_out;
2819 } else {
2820 mvp = mnd.ni_vp;
2821 /* make sure it's the root of a file system */
2822 if (!vnode_isvroot(mvp)) {
2823 /* bail if not marked offline */
2824 if (!(unxa->nxa_flags & NXA_OFFLINE)) {
2825 error = EINVAL;
2826 goto out;
2827 }
2828 vnode_put(mvp);
2829 nameidone(&mnd);
2830 mvp = NULL;
2831 } else {
2832 mp = vnode_mount(mvp);
6d2010ae 2833 mount_ref(mp, 0);
91447636 2834
2d21ac55
A		 2835 /* make sure the file system is NFS-exportable */
2836 nfh.nfh_len = NFSV3_MAX_FID_SIZE;
2837 error = VFS_VPTOFH(mvp, (int*)&nfh.nfh_len, &nfh.nfh_fid[0], NULL);
2838 if (!error && (nfh.nfh_len > (int)NFSV3_MAX_FID_SIZE))
2839 error = EIO;
b0d623f7
A		 2840 if (!error && !(mp->mnt_vtable->vfc_vfsflags & VFC_VFSREADDIR_EXTENDED))
2841 error = EISDIR;
2d21ac55
A		 2842 if (error)
2843 goto out;
2844 }
2845 }
91447636
A		 2846
2847 /* add an exportfs for it */
2848 MALLOC(nxfs, struct nfs_exportfs *, sizeof(struct nfs_exportfs), M_TEMP, M_WAITOK);
2849 if (!nxfs) {
2850 error = ENOMEM;
2851 goto out;
2852 }
2853 bzero(nxfs, sizeof(struct nfs_exportfs));
2854 nxfs->nxfs_id = unxa->nxa_fsid;
2855 MALLOC(nxfs->nxfs_path, char*, pathlen, M_TEMP, M_WAITOK);
2856 if (!nxfs->nxfs_path) {
2857 FREE(nxfs, M_TEMP);
2858 error = ENOMEM;
2859 goto out;
2860 }
2861 bcopy(path, nxfs->nxfs_path, pathlen);
2862 /* insert into list in reverse-sorted order */
2863 nxfs3 = NULL;
2d21ac55
A		 2864 LIST_FOREACH(nxfs2, &nfsrv_exports, nxfs_next) {
2865 if (strncmp(nxfs->nxfs_path, nxfs2->nxfs_path, MAXPATHLEN) > 0)
91447636
A		 2866 break;
2867 nxfs3 = nxfs2;
2868 }
2869 if (nxfs2)
2870 LIST_INSERT_BEFORE(nxfs2, nxfs, nxfs_next);
2871 else if (nxfs3)
2872 LIST_INSERT_AFTER(nxfs3, nxfs, nxfs_next);
2873 else
2d21ac55 2874 LIST_INSERT_HEAD(&nfsrv_exports, nxfs, nxfs_next);
91447636
A		 2875
2876 /* make sure any quotas are enabled before we export the file system */
2d21ac55
A		 2877 if (mp)
2878 enablequotas(mp, ctx);
1c79356b 2879 }
91447636
A		 2880
2881 if (unxa->nxa_exppath) {
6d2010ae 2882 error = copyinstr(unxa->nxa_exppath, path, MAXPATHLEN, &pathlen);
91447636
A		 2883 if (error)
2884 goto out;
2885 LIST_FOREACH(nx, &nxfs->nxfs_exports, nx_next) {
2886 if (nx->nx_id == unxa->nxa_expid)
2887 break;
2888 }
2889 if (nx) {
2890 /* verify exported FS path matches given path */
2d21ac55 2891 if (strncmp(path, nx->nx_path, MAXPATHLEN)) {
91447636
A		 2892 error = EEXIST;
2893 goto out;
2894 }
2895 } else {
2896 /* no current export with that ID */
2897 if (!(unxa->nxa_flags & NXA_ADD)) {
2898 error = ENOENT;
2899 goto out;
2900 }
2901 /* add an export for it */
2902 MALLOC(nx, struct nfs_export *, sizeof(struct nfs_export), M_TEMP, M_WAITOK);
2903 if (!nx) {
2904 error = ENOMEM;
2905 goto out1;
2906 }
2907 bzero(nx, sizeof(struct nfs_export));
2908 nx->nx_id = unxa->nxa_expid;
2909 nx->nx_fs = nxfs;
2d21ac55 2910 microtime(&nx->nx_exptime);
91447636
A		 2911 MALLOC(nx->nx_path, char*, pathlen, M_TEMP, M_WAITOK);
2912 if (!nx->nx_path) {
2913 error = ENOMEM;
2914 FREE(nx, M_TEMP);
2915 nx = NULL;
2916 goto out1;
2917 }
2918 bcopy(path, nx->nx_path, pathlen);
2d21ac55
A		 2919 /* initialize the active user list */
2920 nfsrv_init_user_list(&nx->nx_user_list);
91447636
A		 2921 /* insert into list in reverse-sorted order */
2922 nx3 = NULL;
2923 LIST_FOREACH(nx2, &nxfs->nxfs_exports, nx_next) {
2d21ac55 2924 if (strncmp(nx->nx_path, nx2->nx_path, MAXPATHLEN) > 0)
91447636
A		 2925 break;
2926 nx3 = nx2;
2927 }
2928 if (nx2)
2929 LIST_INSERT_BEFORE(nx2, nx, nx_next);
2930 else if (nx3)
2931 LIST_INSERT_AFTER(nx3, nx, nx_next);
2932 else
2933 LIST_INSERT_HEAD(&nxfs->nxfs_exports, nx, nx_next);
2934 /* insert into hash */
2d21ac55 2935 LIST_INSERT_HEAD(NFSRVEXPHASH(nxfs->nxfs_id, nx->nx_id), nx, nx_hash);
91447636
A		 2936
2937 /*
2d21ac55 2938 * We don't allow/support nested exports. Check if the new entry
91447636
A		 2939 * nests with the entries before and after or if there's an
2940 * entry for the file system root and subdirs.
2941 */
2942 error = 0;
2943 if ((nx3 && !strncmp(nx3->nx_path, nx->nx_path, pathlen - 1) &&
2944 (nx3->nx_path[pathlen-1] == '/')) ||
2945 (nx2 && !strncmp(nx2->nx_path, nx->nx_path, strlen(nx2->nx_path)) &&
2946 (nx->nx_path[strlen(nx2->nx_path)] == '/')))
2947 error = EINVAL;
2948 if (!error) {
2949 /* check export conflict with fs root export and vice versa */
2950 expisroot = !nx->nx_path[0] ||
2951 ((nx->nx_path[0] == '.') && !nx->nx_path[1]);
2952 LIST_FOREACH(nx2, &nxfs->nxfs_exports, nx_next) {
2953 if (expisroot) {
2954 if (nx2 != nx)
2955 break;
2956 } else if (!nx2->nx_path[0])
2957 break;
2958 else if ((nx2->nx_path[0] == '.') && !nx2->nx_path[1])
2959 break;
2960 }
2961 if (nx2)
2962 error = EINVAL;
2963 }
2964 if (error) {
2d21ac55
A		 2965 /*
2966 * Don't actually return an error because mountd is
2967 * probably about to delete the conflicting export.
2968 * This can happen when a new export momentarily conflicts
2969 * with an old export while the transition is being made.
2970 * Theoretically, mountd could be written to avoid this
2971 * transient situation - but it would greatly increase the
2972 * complexity of mountd for very little overall benefit.
2973 */
2974 printf("nfsrv_export: warning: nested exports: %s/%s\n",
91447636 2975 nxfs->nxfs_path, nx->nx_path);
2d21ac55 2976 error = 0;
91447636 2977 }
2d21ac55
A		 2978 nx->nx_fh.nfh_xh.nxh_flags = NXHF_INVALIDFH;
2979 }
2980 /* make sure file handle is set up */
2981 if ((nx->nx_fh.nfh_xh.nxh_version != htonl(NFS_FH_VERSION)) ||
2982 (nx->nx_fh.nfh_xh.nxh_flags & NXHF_INVALIDFH)) {
2983 /* try to set up export root file handle */
0c530ab8
A		 2984 nx->nx_fh.nfh_xh.nxh_version = htonl(NFS_FH_VERSION);
2985 nx->nx_fh.nfh_xh.nxh_fsid = htonl(nx->nx_fs->nxfs_id);
2986 nx->nx_fh.nfh_xh.nxh_expid = htonl(nx->nx_id);
91447636
A		 2987 nx->nx_fh.nfh_xh.nxh_flags = 0;
2988 nx->nx_fh.nfh_xh.nxh_reserved = 0;
2d21ac55
A		 2989 nx->nx_fh.nfh_fhp = (u_char*)&nx->nx_fh.nfh_xh;
2990 bzero(&nx->nx_fh.nfh_fid[0], NFSV2_MAX_FID_SIZE);
2991 if (mvp) {
2992 /* find export root vnode */
2993 if (!nx->nx_path[0] || ((nx->nx_path[0] == '.') && !nx->nx_path[1])) {
2994 /* exporting file system's root directory */
2995 xvp = mvp;
2996 vnode_get(xvp);
2997 } else {
2998 xnd.ni_cnd.cn_nameiop = LOOKUP;
6d2010ae
A		 2999#if CONFIG_TRIGGERS
3000 xnd.ni_op = OP_LOOKUP;
3001#endif
2d21ac55
A		 3002 xnd.ni_cnd.cn_flags = LOCKLEAF;
3003 xnd.ni_pathlen = pathlen - 1;
3004 xnd.ni_cnd.cn_nameptr = xnd.ni_cnd.cn_pnbuf = path;
3005 xnd.ni_startdir = mvp;
3006 xnd.ni_usedvp = mvp;
3007 xnd.ni_cnd.cn_context = ctx;
b0d623f7
A		 3008 while ((error = lookup(&xnd)) == ERECYCLE) {
3009 xnd.ni_cnd.cn_flags = LOCKLEAF;
3010 xnd.ni_cnd.cn_nameptr = xnd.ni_cnd.cn_pnbuf;
3011 xnd.ni_usedvp = xnd.ni_dvp = xnd.ni_startdir = mvp;
3012 }
2d21ac55
A		 3013 if (error)
3014 goto out1;
3015 xvp = xnd.ni_vp;
3016 }
3017
3018 if (vnode_vtype(xvp) != VDIR) {
3019 error = EINVAL;
3020 vnode_put(xvp);
3021 goto out1;
3022 }
3023
3024 /* grab file handle */
3025 nx->nx_fh.nfh_len = NFSV3_MAX_FID_SIZE;
3026 error = VFS_VPTOFH(xvp, (int*)&nx->nx_fh.nfh_len, &nx->nx_fh.nfh_fid[0], NULL);
3027 if (!error && (nx->nx_fh.nfh_len > (int)NFSV3_MAX_FID_SIZE)) {
3028 error = EIO;
3029 } else {
3030 nx->nx_fh.nfh_xh.nxh_fidlen = nx->nx_fh.nfh_len;
3031 nx->nx_fh.nfh_len += sizeof(nx->nx_fh.nfh_xh);
3032 }
3033
3034 vnode_put(xvp);
3035 if (error)
3036 goto out1;
91447636 3037 } else {
2d21ac55
A		 3038 nx->nx_fh.nfh_xh.nxh_flags = NXHF_INVALIDFH;
3039 nx->nx_fh.nfh_xh.nxh_fidlen = 0;
3040 nx->nx_fh.nfh_len = sizeof(nx->nx_fh.nfh_xh);
91447636 3041 }
91447636
A		 3042 }
3043 } else {
3044 nx = NULL;
3045 }
3046
3047 /* perform the export changes */
3048 if (unxa->nxa_flags & NXA_DELETE) {
3049 if (!nx) {
3050 /* delete all exports on this file system */
3051 while ((nx = LIST_FIRST(&nxfs->nxfs_exports))) {
3052 LIST_REMOVE(nx, nx_next);
3053 LIST_REMOVE(nx, nx_hash);
3054 /* delete all netopts for this export */
2d21ac55 3055 nfsrv_free_addrlist(nx, NULL);
91447636 3056 nx->nx_flags &= ~NX_DEFAULTEXPORT;
0c530ab8
A		 3057 if (IS_VALID_CRED(nx->nx_defopt.nxo_cred)) {
3058 kauth_cred_unref(&nx->nx_defopt.nxo_cred);
91447636 3059 }
2d21ac55
A		 3060 /* delete active user list for this export */
3061 nfsrv_free_user_list(&nx->nx_user_list);
91447636
A		 3062 FREE(nx->nx_path, M_TEMP);
3063 FREE(nx, M_TEMP);
3064 }
3065 goto out1;
2d21ac55 3066 } else if (!unxa->nxa_netcount) {
91447636 3067 /* delete all netopts for this export */
2d21ac55 3068 nfsrv_free_addrlist(nx, NULL);
91447636 3069 nx->nx_flags &= ~NX_DEFAULTEXPORT;
0c530ab8
A		 3070 if (IS_VALID_CRED(nx->nx_defopt.nxo_cred)) {
3071 kauth_cred_unref(&nx->nx_defopt.nxo_cred);
91447636 3072 }
2d21ac55
A		 3073 } else {
3074 /* delete only the netopts for the given addresses */
3075 error = nfsrv_free_addrlist(nx, unxa);
3076 if (error)
3077 goto out1;
91447636
A		 3078 }
3079 }
3080 if (unxa->nxa_flags & NXA_ADD) {
2d21ac55
A		 3081 /*
3082 * If going offline set the export time so that when
3083 * coming back on line we will present a new write verifier
3084 * to the client.
3085 */
3086 if (unxa->nxa_flags & NXA_OFFLINE)
3087 microtime(&nx->nx_exptime);
3088
91447636 3089 error = nfsrv_hang_addrlist(nx, unxa);
2d21ac55
A		 3090 if (!error && mp)
3091 vfs_setflags(mp, MNT_EXPORTED);
91447636
A		 3092 }
3093
3094out1:
3095 if (nx && !nx->nx_expcnt) {
3096 /* export has no export options */
3097 LIST_REMOVE(nx, nx_next);
3098 LIST_REMOVE(nx, nx_hash);
2d21ac55
A		 3099 /* delete active user list for this export */
3100 nfsrv_free_user_list(&nx->nx_user_list);
91447636
A		 3101 FREE(nx->nx_path, M_TEMP);
3102 FREE(nx, M_TEMP);
3103 }
3104 if (LIST_EMPTY(&nxfs->nxfs_exports)) {
3105 /* exported file system has no more exports */
3106 LIST_REMOVE(nxfs, nxfs_next);
3107 FREE(nxfs->nxfs_path, M_TEMP);
3108 FREE(nxfs, M_TEMP);
2d21ac55
A		 3109 if (mp)
3110 vfs_clearflags(mp, MNT_EXPORTED);
91447636
A		 3111 }
3112
3113out:
3114 if (mvp) {
3115 vnode_put(mvp);
3116 nameidone(&mnd);
3117 }
3118unlock_out:
6d2010ae
A		 3119 if (mp)
3120 mount_drop(mp, 0);
2d21ac55 3121 lck_rw_done(&nfsrv_export_rwlock);
91447636
A		 3122 return (error);
3123}
3124
b0d623f7 3125struct nfs_export_options *
91447636
A		 3126nfsrv_export_lookup(struct nfs_export *nx, mbuf_t nam)
3127{
3128 struct nfs_export_options *nxo = NULL;
3129 struct nfs_netopt *no = NULL;
3130 struct radix_node_head *rnh;
3131 struct sockaddr *saddr;
3132
3133 /* Lookup in the export list first. */
3134 if (nam != NULL) {
3135 saddr = mbuf_data(nam);
3136 rnh = nx->nx_rtable[saddr->sa_family];
3137 if (rnh != NULL) {
3138 no = (struct nfs_netopt *)
3139 (*rnh->rnh_matchaddr)((caddr_t)saddr, rnh);
3140 if (no && no->no_rnodes->rn_flags & RNF_ROOT)
3141 no = NULL;
3142 if (no)
3143 nxo = &no->no_opt;
3144 }
3145 }
3146 /* If no address match, use the default if it exists. */
3147 if ((nxo == NULL) && (nx->nx_flags & NX_DEFAULTEXPORT))
3148 nxo = &nx->nx_defopt;
3149 return (nxo);
3150}
3151
3152/* find an export for the given handle */
b0d623f7 3153struct nfs_export *
91447636
A		 3154nfsrv_fhtoexport(struct nfs_filehandle *nfhp)
3155{
2d21ac55 3156 struct nfs_exphandle *nxh = (struct nfs_exphandle*)nfhp->nfh_fhp;
91447636 3157 struct nfs_export *nx;
0c530ab8
A		 3158 uint32_t fsid, expid;
3159
b0d623f7
A		 3160 if (!nfsrv_export_hashtbl)
3161 return (NULL);
2d21ac55
A		 3162 fsid = ntohl(nxh->nxh_fsid);
3163 expid = ntohl(nxh->nxh_expid);
3164 nx = NFSRVEXPHASH(fsid, expid)->lh_first;
91447636 3165 for (; nx; nx = LIST_NEXT(nx, nx_hash)) {
0c530ab8 3166 if (nx->nx_fs->nxfs_id != fsid)
91447636 3167 continue;
0c530ab8 3168 if (nx->nx_id != expid)
91447636
A		 3169 continue;
3170 break;
3171 }
b0d623f7 3172 return (nx);
1c79356b
A		 3173}
3174
3175/*
91447636 3176 * nfsrv_fhtovp() - convert FH to vnode and export info
1c79356b
A		 3177 */
3178int
91447636
A		 3179nfsrv_fhtovp(
3180 struct nfs_filehandle *nfhp,
2d21ac55 3181 struct nfsrv_descript *nd,
91447636
A		 3182 vnode_t *vpp,
3183 struct nfs_export **nxp,
3184 struct nfs_export_options **nxop)
1c79356b 3185{
2d21ac55
A		 3186 struct nfs_exphandle *nxh = (struct nfs_exphandle*)nfhp->nfh_fhp;
3187 struct nfs_export_options *nxo;
3188 u_char *fidp;
91447636
A		 3189 int error;
3190 struct mount *mp;
2d21ac55 3191 mbuf_t nam = NULL;
0c530ab8 3192 uint32_t v;
2d21ac55 3193 int i, valid;
1c79356b 3194
91447636
A		 3195 *vpp = NULL;
3196 *nxp = NULL;
3197 *nxop = NULL;
1c79356b 3198
2d21ac55
A		 3199 if (nd != NULL)
3200 nam = nd->nd_nam;
3201
3202 v = ntohl(nxh->nxh_version);
0c530ab8 3203 if (v != NFS_FH_VERSION) {
91447636
A		 3204 /* file handle format not supported */
3205 return (ESTALE);
3206 }
2d21ac55 3207 if (nfhp->nfh_len > NFSV3_MAX_FH_SIZE)
91447636 3208 return (EBADRPC);
2d21ac55 3209 if (nfhp->nfh_len < (int)sizeof(struct nfs_exphandle))
91447636 3210 return (ESTALE);
2d21ac55 3211 v = ntohs(nxh->nxh_flags);
0c530ab8 3212 if (v & NXHF_INVALIDFH)
91447636
A		 3213 return (ESTALE);
3214
91447636
A		 3215 *nxp = nfsrv_fhtoexport(nfhp);
3216 if (!*nxp)
3217 return (ESTALE);
3218
3219 /* Get the export option structure for this <export, client> tuple. */
2d21ac55 3220 *nxop = nxo = nfsrv_export_lookup(*nxp, nam);
91447636
A		 3221 if (nam && (*nxop == NULL))
3222 return (EACCES);
3223
2d21ac55
A		 3224 if (nd != NULL) {
3225 /* Validate the security flavor of the request */
3226 for (i = 0, valid = 0; i < nxo->nxo_sec.count; i++) {
3227 if (nd->nd_sec == nxo->nxo_sec.flavors[i]) {
3228 valid = 1;
3229 break;
3230 }
3231 }
3232 if (!valid) {
3233 /*
3234 * RFC 2623 section 2.3.2 recommends no authentication
3235 * requirement for certain NFS procedures used for mounting.
3236 * This allows an unauthenticated superuser on the client
3237 * to do mounts for the benefit of authenticated users.
3238 */
3239 if (nd->nd_vers == NFS_VER2)
3240 if (nd->nd_procnum == NFSV2PROC_GETATTR ||
3241 nd->nd_procnum == NFSV2PROC_STATFS)
3242 valid = 1;
3243 if (nd->nd_vers == NFS_VER3)
3244 if (nd->nd_procnum == NFSPROC_FSINFO)
3245 valid = 1;
3246
3247 if (!valid)
3248 return (NFSERR_AUTHERR | AUTH_REJECTCRED);
3249 }
3250 }
3251
3252 if (nxo && (nxo->nxo_flags & NX_OFFLINE))
b0d623f7 3253 return ((nd == NULL || nd->nd_vers == NFS_VER2) ? ESTALE : NFSERR_TRYLATER);
2d21ac55 3254
91447636
A		 3255 /* find mount structure */
3256 mp = vfs_getvfs_by_mntonname((*nxp)->nx_fs->nxfs_path);
6d2010ae
A		 3257 if (mp) {
3258 error = vfs_busy(mp, LK_NOWAIT);
3259 mount_iterdrop(mp);
3260 if (error)
3261 mp = NULL;
3262 }
2d21ac55
A		 3263 if (!mp) {
3264 /*
3265 * We have an export, but no mount?
3266 * Perhaps the export just hasn't been marked offline yet.
3267 */
b0d623f7 3268 return ((nd == NULL || nd->nd_vers == NFS_VER2) ? ESTALE : NFSERR_TRYLATER);
2d21ac55 3269 }
91447636 3270
2d21ac55
A		 3271 fidp = nfhp->nfh_fhp + sizeof(*nxh);
3272 error = VFS_FHTOVP(mp, nxh->nxh_fidlen, fidp, vpp, NULL);
6d2010ae 3273 vfs_unbusy(mp);
1c79356b
A		 3274 if (error)
3275 return (error);
3276 /* vnode pointer should be good at this point or ... */
3277 if (*vpp == NULL)
3278 return (ESTALE);
91447636
A		 3279 return (0);
3280}
1c79356b 3281
91447636 3282/*
2d21ac55
A		 3283 * nfsrv_credcheck() - check/map credentials according
3284 * to given export options.
91447636
A		 3285 */
3286int
3287nfsrv_credcheck(
2d21ac55
A		 3288 struct nfsrv_descript *nd,
3289 vfs_context_t ctx,
91447636
A		 3290 __unused struct nfs_export *nx,
3291 struct nfs_export_options *nxo)
3292{
3293 if (nxo && nxo->nxo_cred) {
3294 if ((nxo->nxo_flags & NX_MAPALL) ||
2d21ac55 3295 ((nxo->nxo_flags & NX_MAPROOT) && !suser(nd->nd_cr, NULL))) {
0c530ab8 3296 kauth_cred_ref(nxo->nxo_cred);
2d21ac55
A		 3297 kauth_cred_unref(&nd->nd_cr);
3298 nd->nd_cr = nxo->nxo_cred;
91447636
A		 3299 }
3300 }
2d21ac55 3301 ctx->vc_ucred = nd->nd_cr;
1c79356b
A		 3302 return (0);
3303}
3304
91447636
A		 3305/*
3306 * nfsrv_vptofh() - convert vnode to file handle for given export
3307 *
3308 * If the caller is passing in a vnode for a ".." directory entry,
3309 * they can pass a directory NFS file handle (dnfhp) which will be
3310 * checked against the root export file handle. If it matches, we
3311 * refuse to provide the file handle for the out-of-export directory.
3312 */
3313int
3314nfsrv_vptofh(
3315 struct nfs_export *nx,
2d21ac55 3316 int nfsvers,
91447636
A		 3317 struct nfs_filehandle *dnfhp,
3318 vnode_t vp,
2d21ac55 3319 vfs_context_t ctx,
91447636
A		 3320 struct nfs_filehandle *nfhp)
3321{
3322 int error;
2d21ac55 3323 uint32_t maxfidsize;
91447636 3324
2d21ac55 3325 nfhp->nfh_fhp = (u_char*)&nfhp->nfh_xh;
0c530ab8
A		 3326 nfhp->nfh_xh.nxh_version = htonl(NFS_FH_VERSION);
3327 nfhp->nfh_xh.nxh_fsid = htonl(nx->nx_fs->nxfs_id);
3328 nfhp->nfh_xh.nxh_expid = htonl(nx->nx_id);
91447636
A		 3329 nfhp->nfh_xh.nxh_flags = 0;
3330 nfhp->nfh_xh.nxh_reserved = 0;
3331
2d21ac55 3332 if (nfsvers == NFS_VER2)
91447636
A		 3333 bzero(&nfhp->nfh_fid[0], NFSV2_MAX_FID_SIZE);
3334
3335 /* if directory FH matches export root, return invalid FH */
3336 if (dnfhp && nfsrv_fhmatch(dnfhp, &nx->nx_fh)) {
2d21ac55
A		 3337 if (nfsvers == NFS_VER2)
3338 nfhp->nfh_len = NFSX_V2FH;
3339 else
3340 nfhp->nfh_len = sizeof(nfhp->nfh_xh);
91447636 3341 nfhp->nfh_xh.nxh_fidlen = 0;
0c530ab8 3342 nfhp->nfh_xh.nxh_flags = htons(NXHF_INVALIDFH);
91447636
A		 3343 return (0);
3344 }
3345
2d21ac55
A		 3346 if (nfsvers == NFS_VER2)
3347 maxfidsize = NFSV2_MAX_FID_SIZE;
3348 else
3349 maxfidsize = NFSV3_MAX_FID_SIZE;
3350 nfhp->nfh_len = maxfidsize;
3351
3352 error = VFS_VPTOFH(vp, (int*)&nfhp->nfh_len, &nfhp->nfh_fid[0], ctx);
91447636
A		 3353 if (error)
3354 return (error);
2d21ac55 3355 if (nfhp->nfh_len > maxfidsize)
91447636
A		 3356 return (EOVERFLOW);
3357 nfhp->nfh_xh.nxh_fidlen = nfhp->nfh_len;
3358 nfhp->nfh_len += sizeof(nfhp->nfh_xh);
2d21ac55 3359 if ((nfsvers == NFS_VER2) && (nfhp->nfh_len < NFSX_V2FH))
91447636
A		 3360 nfhp->nfh_len = NFSX_V2FH;
3361
3362 return (0);
3363}
3364
2d21ac55
A		 3365/*
3366 * Compare two file handles to see it they're the same.
3367 * Note that we don't use nfh_len because that may include
3368 * padding in an NFSv2 file handle.
3369 */
91447636
A		 3370int
3371nfsrv_fhmatch(struct nfs_filehandle *fh1, struct nfs_filehandle *fh2)
3372{
2d21ac55 3373 struct nfs_exphandle *nxh1, *nxh2;
91447636
A		 3374 int len1, len2;
3375
2d21ac55
A		 3376 nxh1 = (struct nfs_exphandle *)fh1->nfh_fhp;
3377 nxh2 = (struct nfs_exphandle *)fh2->nfh_fhp;
3378 len1 = sizeof(fh1->nfh_xh) + nxh1->nxh_fidlen;
3379 len2 = sizeof(fh2->nfh_xh) + nxh2->nxh_fidlen;
91447636
A		 3380 if (len1 != len2)
3381 return (0);
2d21ac55 3382 if (bcmp(nxh1, nxh2, len1))
91447636
A		 3383 return (0);
3384 return (1);
3385}
2d21ac55 3386
1c79356b 3387/*
2d21ac55 3388 * Functions for dealing with active user lists
1c79356b 3389 */
2d21ac55 3390
1c79356b 3391/*
2d21ac55
A		 3392 * Search the hash table for a user node with a matching IP address and uid field.
3393 * If found, the node's tm_last timestamp is updated and the node is returned.
3394 *
3395 * If not found, a new node is allocated (or reclaimed via LRU), initialized, and returned.
3396 * Returns NULL if a new node could not be allcoated.
3397 *
3398 * The list's user_mutex lock MUST be held.
1c79356b 3399 */
b0d623f7 3400struct nfs_user_stat_node *
6d2010ae 3401nfsrv_get_user_stat_node(struct nfs_active_user_list *list, struct sockaddr *saddr, uid_t uid)
1c79356b 3402{
2d21ac55
A		 3403 struct nfs_user_stat_node *unode;
3404 struct timeval now;
3405 struct nfs_user_stat_hashtbl_head *head;
3406
3407 /* seach the hash table */
3408 head = NFS_USER_STAT_HASH(list->user_hashtbl, uid);
3409 LIST_FOREACH(unode, head, hash_link) {
6d2010ae 3410 if ((uid == unode->uid) && (nfs_sockaddr_cmp(saddr, (struct sockaddr*)&unode->sock) == 0)) {
2d21ac55
A		 3411 /* found matching node */
3412 break;
3413 }
3414 }
1c79356b 3415
2d21ac55
A		 3416 if (unode) {
3417 /* found node in the hash table, now update lru position */
3418 TAILQ_REMOVE(&list->user_lru, unode, lru_link);
3419 TAILQ_INSERT_TAIL(&list->user_lru, unode, lru_link);
3420
3421 /* update time stamp */
3422 microtime(&now);
3423 unode->tm_last = (uint32_t)now.tv_sec;
3424 return unode;
1c79356b 3425 }
2d21ac55
A		 3426
3427 if (list->node_count < nfsrv_user_stat_max_nodes) {
3428 /* Allocate a new node */
3429 MALLOC(unode, struct nfs_user_stat_node *, sizeof(struct nfs_user_stat_node),
3430 M_TEMP, M_WAITOK | M_ZERO);
3431
3432 if (!unode)
3433 return NULL;
3434
3435 /* increment node count */
b0d623f7 3436 OSAddAtomic(1, &nfsrv_user_stat_node_count);
2d21ac55
A		 3437 list->node_count++;
3438 } else {
3439 /* reuse the oldest node in the lru list */
3440 unode = TAILQ_FIRST(&list->user_lru);
3441
3442 if (!unode)
3443 return NULL;
3444
3445 /* Remove the node */
3446 TAILQ_REMOVE(&list->user_lru, unode, lru_link);
3447 LIST_REMOVE(unode, hash_link);
1c79356b 3448 }
2d21ac55
A		 3449
3450 /* Initialize the node */
3451 unode->uid = uid;
6d2010ae 3452 bcopy(saddr, &unode->sock, saddr->sa_len);
2d21ac55
A		 3453 microtime(&now);
3454 unode->ops = 0;
3455 unode->bytes_read = 0;
3456 unode->bytes_written = 0;
3457 unode->tm_start = (uint32_t)now.tv_sec;
3458 unode->tm_last = (uint32_t)now.tv_sec;
3459
3460 /* insert the node */
3461 TAILQ_INSERT_TAIL(&list->user_lru, unode, lru_link);
3462 LIST_INSERT_HEAD(head, unode, hash_link);
3463
3464 return unode;
3465}
3466
3467void
3468nfsrv_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)
3469{
3470 struct nfs_user_stat_node *unode;
3471 struct nfs_active_user_list *ulist;
6d2010ae 3472 struct sockaddr *saddr;
2d21ac55
A		 3473
3474 if ((!nfsrv_user_stat_enabled) || (!nx) || (!nd) || (!nd->nd_nam))
3475 return;
3476
6d2010ae 3477 saddr = (struct sockaddr *)mbuf_data(nd->nd_nam);
2d21ac55
A		 3478
3479 /* check address family before going any further */
6d2010ae 3480 if ((saddr->sa_family != AF_INET) && (saddr->sa_family != AF_INET6))
2d21ac55
A		 3481 return;
3482
3483 ulist = &nx->nx_user_list;
3484
3485 /* lock the active user list */
3486 lck_mtx_lock(&ulist->user_mutex);
3487
3488 /* get the user node */
6d2010ae 3489 unode = nfsrv_get_user_stat_node(ulist, saddr, uid);
2d21ac55
A		 3490
3491 if (!unode) {
3492 lck_mtx_unlock(&ulist->user_mutex);
3493 return;
1c79356b 3494 }
2d21ac55
A		 3495
3496 /* update counters */
3497 unode->ops += ops;
3498 unode->bytes_read += rd_bytes;
3499 unode->bytes_written += wr_bytes;
3500
3501 /* done */
3502 lck_mtx_unlock(&ulist->user_mutex);
3503}
3504
3505/* initialize an active user list */
b0d623f7 3506void
2d21ac55
A		 3507nfsrv_init_user_list(struct nfs_active_user_list *ulist)
3508{
3509 uint i;
3510
3511 /* initialize the lru */
3512 TAILQ_INIT(&ulist->user_lru);
3513
3514 /* initialize the hash table */
3515 for(i = 0; i < NFS_USER_STAT_HASH_SIZE; i++)
3516 LIST_INIT(&ulist->user_hashtbl[i]);
3517 ulist->node_count = 0;
3518
3519 lck_mtx_init(&ulist->user_mutex, nfsrv_active_user_mutex_group, LCK_ATTR_NULL);
3520}
3521
3522/* Free all nodes in an active user list */
b0d623f7 3523void
2d21ac55
A		 3524nfsrv_free_user_list(struct nfs_active_user_list *ulist)
3525{
3526 struct nfs_user_stat_node *unode;
3527
3528 if (!ulist)
3529 return;
3530
3531 while ((unode = TAILQ_FIRST(&ulist->user_lru))) {
3532 /* Remove node and free */
3533 TAILQ_REMOVE(&ulist->user_lru, unode, lru_link);
3534 LIST_REMOVE(unode, hash_link);
3535 FREE(unode, M_TEMP);
3536
3537 /* decrement node count */
b0d623f7 3538 OSAddAtomic(-1, &nfsrv_user_stat_node_count);
1c79356b 3539 }
2d21ac55
A		 3540 ulist->node_count = 0;
3541
3542 lck_mtx_destroy(&ulist->user_mutex, nfsrv_active_user_mutex_group);
1c79356b
A		 3543}
3544
2d21ac55 3545/* Reclaim old expired user nodes from active user lists. */
1c79356b 3546void
2d21ac55 3547nfsrv_active_user_list_reclaim(void)
1c79356b 3548{
2d21ac55
A		 3549 struct nfs_exportfs *nxfs;
3550 struct nfs_export *nx;
3551 struct nfs_active_user_list *ulist;
3552 struct nfs_user_stat_hashtbl_head oldlist;
3553 struct nfs_user_stat_node *unode, *unode_next;
3554 struct timeval now;
3555 uint32_t tstale;
3556
3557 LIST_INIT(&oldlist);
3558
3559 lck_rw_lock_shared(&nfsrv_export_rwlock);
3560 microtime(&now);
3561 tstale = now.tv_sec - nfsrv_user_stat_max_idle_sec;
3562 LIST_FOREACH(nxfs, &nfsrv_exports, nxfs_next) {
3563 LIST_FOREACH(nx, &nxfs->nxfs_exports, nx_next) {
3564 /* Scan through all user nodes of this export */
3565 ulist = &nx->nx_user_list;
3566 lck_mtx_lock(&ulist->user_mutex);
3567 for (unode = TAILQ_FIRST(&ulist->user_lru); unode; unode = unode_next) {
3568 unode_next = TAILQ_NEXT(unode, lru_link);
3569
3570 /* check if this node has expired */
3571 if (unode->tm_last >= tstale)
3572 break;
3573
3574 /* Remove node from the active user list */
3575 TAILQ_REMOVE(&ulist->user_lru, unode, lru_link);
3576 LIST_REMOVE(unode, hash_link);
3577
3578 /* Add node to temp list */
3579 LIST_INSERT_HEAD(&oldlist, unode, hash_link);
3580
3581 /* decrement node count */
b0d623f7 3582 OSAddAtomic(-1, &nfsrv_user_stat_node_count);
2d21ac55
A		 3583 ulist->node_count--;
3584 }
3585 /* can unlock this export's list now */
3586 lck_mtx_unlock(&ulist->user_mutex);
3587 }
3588 }
3589 lck_rw_done(&nfsrv_export_rwlock);
3590
3591 /* Free expired nodes */
3592 while ((unode = LIST_FIRST(&oldlist))) {
3593 LIST_REMOVE(unode, hash_link);
3594 FREE(unode, M_TEMP);
3595 }
1c79356b
A		 3596}
3597
1c79356b 3598/*
2d21ac55
A		 3599 * Maps errno values to nfs error numbers.
3600 * Use NFSERR_IO as the catch all for ones not specifically defined in
3601 * RFC 1094.
1c79356b 3602 */
2d21ac55
A		 3603static u_char nfsrv_v2errmap[] = {
3604 NFSERR_PERM, NFSERR_NOENT, NFSERR_IO, NFSERR_IO, NFSERR_IO,
3605 NFSERR_NXIO, NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO,
3606 NFSERR_IO, NFSERR_IO, NFSERR_ACCES, NFSERR_IO, NFSERR_IO,
3607 NFSERR_IO, NFSERR_EXIST, NFSERR_IO, NFSERR_NODEV, NFSERR_NOTDIR,
3608 NFSERR_ISDIR, NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO,
3609 NFSERR_IO, NFSERR_FBIG, NFSERR_NOSPC, NFSERR_IO, NFSERR_ROFS,
3610 NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO,
3611 NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO,
3612 NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO,
3613 NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO,
3614 NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO,
3615 NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO,
3616 NFSERR_IO, NFSERR_IO, NFSERR_NAMETOL, NFSERR_IO, NFSERR_IO,
3617 NFSERR_NOTEMPTY, NFSERR_IO, NFSERR_IO, NFSERR_DQUOT, NFSERR_STALE,
3618};
1c79356b 3619
2d21ac55
A		 3620/*
3621 * Maps errno values to nfs error numbers.
3622 * Although it is not obvious whether or not NFS clients really care if
3623 * a returned error value is in the specified list for the procedure, the
3624 * safest thing to do is filter them appropriately. For Version 2, the
3625 * X/Open XNFS document is the only specification that defines error values
3626 * for each RPC (The RFC simply lists all possible error values for all RPCs),
3627 * so I have decided to not do this for Version 2.
3628 * The first entry is the default error return and the rest are the valid
3629 * errors for that RPC in increasing numeric order.
3630 */
3631static short nfsv3err_null[] = {
3632 0,
3633 0,
3634};
3635
3636static short nfsv3err_getattr[] = {
3637 NFSERR_IO,
3638 NFSERR_IO,
3639 NFSERR_STALE,
3640 NFSERR_BADHANDLE,
3641 NFSERR_SERVERFAULT,
3642 NFSERR_TRYLATER,
3643 0,
3644};
3645
3646static short nfsv3err_setattr[] = {
3647 NFSERR_IO,
3648 NFSERR_PERM,
3649 NFSERR_IO,
3650 NFSERR_ACCES,
3651 NFSERR_INVAL,
3652 NFSERR_NOSPC,
3653 NFSERR_ROFS,
3654 NFSERR_DQUOT,
3655 NFSERR_STALE,
3656 NFSERR_BADHANDLE,
3657 NFSERR_NOT_SYNC,
3658 NFSERR_SERVERFAULT,
3659 NFSERR_TRYLATER,
3660 0,
3661};
3662
3663static short nfsv3err_lookup[] = {
3664 NFSERR_IO,
3665 NFSERR_NOENT,
3666 NFSERR_IO,
3667 NFSERR_ACCES,
3668 NFSERR_NOTDIR,
3669 NFSERR_NAMETOL,
3670 NFSERR_STALE,
3671 NFSERR_BADHANDLE,
3672 NFSERR_SERVERFAULT,
3673 NFSERR_TRYLATER,
3674 0,
3675};
3676
3677static short nfsv3err_access[] = {
3678 NFSERR_IO,
3679 NFSERR_IO,
3680 NFSERR_STALE,
3681 NFSERR_BADHANDLE,
3682 NFSERR_SERVERFAULT,
3683 NFSERR_TRYLATER,
3684 0,
3685};
3686
3687static short nfsv3err_readlink[] = {
3688 NFSERR_IO,
3689 NFSERR_IO,
3690 NFSERR_ACCES,
3691 NFSERR_INVAL,
3692 NFSERR_STALE,
3693 NFSERR_BADHANDLE,
3694 NFSERR_NOTSUPP,
3695 NFSERR_SERVERFAULT,
3696 NFSERR_TRYLATER,
3697 0,
3698};
3699
3700static short nfsv3err_read[] = {
3701 NFSERR_IO,
3702 NFSERR_IO,
3703 NFSERR_NXIO,
3704 NFSERR_ACCES,
3705 NFSERR_INVAL,
3706 NFSERR_STALE,
3707 NFSERR_BADHANDLE,
3708 NFSERR_SERVERFAULT,
3709 NFSERR_TRYLATER,
3710 0,
3711};
3712
3713static short nfsv3err_write[] = {
3714 NFSERR_IO,
3715 NFSERR_IO,
3716 NFSERR_ACCES,
3717 NFSERR_INVAL,
3718 NFSERR_FBIG,
3719 NFSERR_NOSPC,
3720 NFSERR_ROFS,
3721 NFSERR_DQUOT,
3722 NFSERR_STALE,
3723 NFSERR_BADHANDLE,
3724 NFSERR_SERVERFAULT,
3725 NFSERR_TRYLATER,
3726 0,
3727};
3728
3729static short nfsv3err_create[] = {
3730 NFSERR_IO,
3731 NFSERR_IO,
3732 NFSERR_ACCES,
3733 NFSERR_EXIST,
3734 NFSERR_NOTDIR,
3735 NFSERR_NOSPC,
3736 NFSERR_ROFS,
3737 NFSERR_NAMETOL,
3738 NFSERR_DQUOT,
3739 NFSERR_STALE,
3740 NFSERR_BADHANDLE,
3741 NFSERR_NOTSUPP,
3742 NFSERR_SERVERFAULT,
3743 NFSERR_TRYLATER,
3744 0,
3745};
3746
3747static short nfsv3err_mkdir[] = {
3748 NFSERR_IO,
3749 NFSERR_IO,
3750 NFSERR_ACCES,
3751 NFSERR_EXIST,
3752 NFSERR_NOTDIR,
3753 NFSERR_NOSPC,
3754 NFSERR_ROFS,
3755 NFSERR_NAMETOL,
3756 NFSERR_DQUOT,
3757 NFSERR_STALE,
3758 NFSERR_BADHANDLE,
3759 NFSERR_NOTSUPP,
3760 NFSERR_SERVERFAULT,
3761 NFSERR_TRYLATER,
3762 0,
3763};
3764
3765static short nfsv3err_symlink[] = {
3766 NFSERR_IO,
3767 NFSERR_IO,
3768 NFSERR_ACCES,
3769 NFSERR_EXIST,
3770 NFSERR_NOTDIR,
3771 NFSERR_NOSPC,
3772 NFSERR_ROFS,
3773 NFSERR_NAMETOL,
3774 NFSERR_DQUOT,
3775 NFSERR_STALE,
3776 NFSERR_BADHANDLE,
3777 NFSERR_NOTSUPP,
3778 NFSERR_SERVERFAULT,
3779 NFSERR_TRYLATER,
3780 0,
3781};
3782
3783static short nfsv3err_mknod[] = {
3784 NFSERR_IO,
3785 NFSERR_IO,
3786 NFSERR_ACCES,
3787 NFSERR_EXIST,
3788 NFSERR_NOTDIR,
3789 NFSERR_NOSPC,
3790 NFSERR_ROFS,
3791 NFSERR_NAMETOL,
3792 NFSERR_DQUOT,
3793 NFSERR_STALE,
3794 NFSERR_BADHANDLE,
3795 NFSERR_NOTSUPP,
3796 NFSERR_SERVERFAULT,
3797 NFSERR_BADTYPE,
3798 NFSERR_TRYLATER,
3799 0,
3800};
3801
3802static short nfsv3err_remove[] = {
3803 NFSERR_IO,
3804 NFSERR_NOENT,
3805 NFSERR_IO,
3806 NFSERR_ACCES,
3807 NFSERR_NOTDIR,
3808 NFSERR_ROFS,
3809 NFSERR_NAMETOL,
3810 NFSERR_STALE,
3811 NFSERR_BADHANDLE,
3812 NFSERR_SERVERFAULT,
3813 NFSERR_TRYLATER,
3814 0,
3815};
3816
3817static short nfsv3err_rmdir[] = {
3818 NFSERR_IO,
3819 NFSERR_NOENT,
3820 NFSERR_IO,
3821 NFSERR_ACCES,
3822 NFSERR_EXIST,
3823 NFSERR_NOTDIR,
3824 NFSERR_INVAL,
3825 NFSERR_ROFS,
3826 NFSERR_NAMETOL,
3827 NFSERR_NOTEMPTY,
3828 NFSERR_STALE,
3829 NFSERR_BADHANDLE,
3830 NFSERR_NOTSUPP,
3831 NFSERR_SERVERFAULT,
3832 NFSERR_TRYLATER,
3833 0,
3834};
3835
3836static short nfsv3err_rename[] = {
3837 NFSERR_IO,
3838 NFSERR_NOENT,
3839 NFSERR_IO,
3840 NFSERR_ACCES,
3841 NFSERR_EXIST,
3842 NFSERR_XDEV,
3843 NFSERR_NOTDIR,
3844 NFSERR_ISDIR,
3845 NFSERR_INVAL,
3846 NFSERR_NOSPC,
3847 NFSERR_ROFS,
3848 NFSERR_MLINK,
3849 NFSERR_NAMETOL,
3850 NFSERR_NOTEMPTY,
3851 NFSERR_DQUOT,
3852 NFSERR_STALE,
3853 NFSERR_BADHANDLE,
3854 NFSERR_NOTSUPP,
3855 NFSERR_SERVERFAULT,
3856 NFSERR_TRYLATER,
3857 0,
3858};
3859
3860static short nfsv3err_link[] = {
3861 NFSERR_IO,
3862 NFSERR_IO,
3863 NFSERR_ACCES,
3864 NFSERR_EXIST,
3865 NFSERR_XDEV,
3866 NFSERR_NOTDIR,
3867 NFSERR_INVAL,
3868 NFSERR_NOSPC,
3869 NFSERR_ROFS,
3870 NFSERR_MLINK,
3871 NFSERR_NAMETOL,
3872 NFSERR_DQUOT,
3873 NFSERR_STALE,
3874 NFSERR_BADHANDLE,
3875 NFSERR_NOTSUPP,
3876 NFSERR_SERVERFAULT,
3877 NFSERR_TRYLATER,
3878 0,
3879};
3880
3881static short nfsv3err_readdir[] = {
3882 NFSERR_IO,
3883 NFSERR_IO,
3884 NFSERR_ACCES,
3885 NFSERR_NOTDIR,
3886 NFSERR_STALE,
3887 NFSERR_BADHANDLE,
3888 NFSERR_BAD_COOKIE,
3889 NFSERR_TOOSMALL,
3890 NFSERR_SERVERFAULT,
3891 NFSERR_TRYLATER,
3892 0,
3893};
3894
3895static short nfsv3err_readdirplus[] = {
3896 NFSERR_IO,
3897 NFSERR_IO,
3898 NFSERR_ACCES,
3899 NFSERR_NOTDIR,
3900 NFSERR_STALE,
3901 NFSERR_BADHANDLE,
3902 NFSERR_BAD_COOKIE,
3903 NFSERR_NOTSUPP,
3904 NFSERR_TOOSMALL,
3905 NFSERR_SERVERFAULT,
3906 NFSERR_TRYLATER,
3907 0,
3908};
3909
3910static short nfsv3err_fsstat[] = {
3911 NFSERR_IO,
3912 NFSERR_IO,
3913 NFSERR_STALE,
3914 NFSERR_BADHANDLE,
3915 NFSERR_SERVERFAULT,
3916 NFSERR_TRYLATER,
3917 0,
3918};
3919
3920static short nfsv3err_fsinfo[] = {
3921 NFSERR_STALE,
3922 NFSERR_STALE,
3923 NFSERR_BADHANDLE,
3924 NFSERR_SERVERFAULT,
3925 NFSERR_TRYLATER,
3926 0,
3927};
3928
3929static short nfsv3err_pathconf[] = {
3930 NFSERR_STALE,
3931 NFSERR_STALE,
3932 NFSERR_BADHANDLE,
3933 NFSERR_SERVERFAULT,
3934 NFSERR_TRYLATER,
3935 0,
3936};
3937
3938static short nfsv3err_commit[] = {
3939 NFSERR_IO,
3940 NFSERR_IO,
3941 NFSERR_STALE,
3942 NFSERR_BADHANDLE,
3943 NFSERR_SERVERFAULT,
3944 NFSERR_TRYLATER,
3945 0,
3946};
3947
3948static short *nfsrv_v3errmap[] = {
3949 nfsv3err_null,
3950 nfsv3err_getattr,
3951 nfsv3err_setattr,
3952 nfsv3err_lookup,
3953 nfsv3err_access,
3954 nfsv3err_readlink,
3955 nfsv3err_read,
3956 nfsv3err_write,
3957 nfsv3err_create,
3958 nfsv3err_mkdir,
3959 nfsv3err_symlink,
3960 nfsv3err_mknod,
3961 nfsv3err_remove,
3962 nfsv3err_rmdir,
3963 nfsv3err_rename,
3964 nfsv3err_link,
3965 nfsv3err_readdir,
3966 nfsv3err_readdirplus,
3967 nfsv3err_fsstat,
3968 nfsv3err_fsinfo,
3969 nfsv3err_pathconf,
3970 nfsv3err_commit,
3971};
3972
3973/*
3974 * Map errnos to NFS error numbers. For Version 3 also filter out error
3975 * numbers not specified for the associated procedure.
3976 */
3977int
3978nfsrv_errmap(struct nfsrv_descript *nd, int err)
3979{
3980 short *defaulterrp, *errp;
3981
3982 if (nd->nd_vers == NFS_VER2) {
3983 if (err <= (int)sizeof(nfsrv_v2errmap))
3984 return ((int)nfsrv_v2errmap[err - 1]);
3985 return (NFSERR_IO);
3986 }
3987 /* NFSv3 */
3988 if (nd->nd_procnum > NFSPROC_COMMIT)
3989 return (err & 0xffff);
3990 errp = defaulterrp = nfsrv_v3errmap[nd->nd_procnum];
3991 while (*++errp) {
3992 if (*errp == err)
3993 return (err);
3994 else if (*errp > err)
3995 break;
1c79356b 3996 }
2d21ac55 3997 return ((int)*defaulterrp);
1c79356b
A		 3998}
3999
2d21ac55 4000#endif /* NFSSERVER */
1c79356b 4001
mirror of XNU