![[BACK]](/icons/back.gif){kind=icon}
Return to nfs_subs.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / nfs|
Return to nfs_subs.c CVS log | Up to [local] / sys / nfs |
1.1 nbrk 1: /* $OpenBSD: nfs_subs.c,v 1.61 2007/04/19 14:46:44 thib Exp $ */
2: /* $NetBSD: nfs_subs.c,v 1.27.4.3 1996/07/08 20:34:24 jtc Exp $ */
3:
4: /*
5: * Copyright (c) 1989, 1993
6: * The Regents of the University of California. All rights reserved.
7: *
8: * This code is derived from software contributed to Berkeley by
9: * Rick Macklem at The University of Guelph.
10: *
11: * Redistribution and use in source and binary forms, with or without
12: * modification, are permitted provided that the following conditions
13: * are met:
14: * 1. Redistributions of source code must retain the above copyright
15: * notice, this list of conditions and the following disclaimer.
16: * 2. Redistributions in binary form must reproduce the above copyright
17: * notice, this list of conditions and the following disclaimer in the
18: * documentation and/or other materials provided with the distribution.
19: * 3. Neither the name of the University nor the names of its contributors
20: * may be used to endorse or promote products derived from this software
21: * without specific prior written permission.
22: *
23: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
24: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33: * SUCH DAMAGE.
34: *
35: * @(#)nfs_subs.c 8.8 (Berkeley) 5/22/95
36: */
37:
38:
39: /*
40: * These functions support the macros and help fiddle mbuf chains for
41: * the nfs op functions. They do things like create the rpc header and
42: * copy data between mbuf chains and uio lists.
43: */
44: #include <sys/param.h>
45: #include <sys/proc.h>
46: #include <sys/systm.h>
47: #include <sys/kernel.h>
48: #include <sys/mount.h>
49: #include <sys/vnode.h>
50: #include <sys/namei.h>
51: #include <sys/mbuf.h>
52: #include <sys/socket.h>
53: #include <sys/socketvar.h>
54: #include <sys/stat.h>
55: #include <sys/malloc.h>
56: #include <sys/pool.h>
57: #include <sys/time.h>
58:
59: #include <uvm/uvm_extern.h>
60:
61: #include <nfs/rpcv2.h>
62: #include <nfs/nfsproto.h>
63: #include <nfs/nfsnode.h>
64: #include <nfs/nfs.h>
65: #include <nfs/xdr_subs.h>
66: #include <nfs/nfsm_subs.h>
67: #include <nfs/nfsmount.h>
68: #include <nfs/nfsrtt.h>
69: #include <nfs/nfs_var.h>
70:
71: #include <miscfs/specfs/specdev.h>
72:
73: #include <netinet/in.h>
74:
75: #include <dev/rndvar.h>
76:
77: #ifdef __GNUC__
78: #define INLINE __inline
79: #else
80: #define INLINE
81: #endif
82:
83: int nfs_attrtimeo(struct nfsnode *np);
84:
85: /*
86: * Data items converted to xdr at startup, since they are constant
87: * This is kinda hokey, but may save a little time doing byte swaps
88: */
89: u_int32_t nfs_xdrneg1;
90: u_int32_t rpc_call, rpc_vers, rpc_reply, rpc_msgdenied, rpc_autherr,
91: rpc_mismatch, rpc_auth_unix, rpc_msgaccepted,
92: rpc_auth_kerb;
93: u_int32_t nfs_prog, nfs_true, nfs_false;
94:
95: /* And other global data */
96: static u_int32_t nfs_xid = 0;
97: static u_int32_t nfs_xid_touched = 0;
98: nfstype nfsv2_type[9] = { NFNON, NFREG, NFDIR, NFBLK, NFCHR, NFLNK, NFNON,
99: NFCHR, NFNON };
100: nfstype nfsv3_type[9] = { NFNON, NFREG, NFDIR, NFBLK, NFCHR, NFLNK, NFSOCK,
101: NFFIFO, NFNON };
102: enum vtype nv2tov_type[8] = { VNON, VREG, VDIR, VBLK, VCHR, VLNK, VNON, VNON };
103: enum vtype nv3tov_type[8]={ VNON, VREG, VDIR, VBLK, VCHR, VLNK, VSOCK, VFIFO };
104: int nfs_ticks;
105: struct nfsstats nfsstats;
106:
107: /*
108: * Mapping of old NFS Version 2 RPC numbers to generic numbers.
109: */
110: int nfsv3_procid[NFS_NPROCS] = {
111: NFSPROC_NULL,
112: NFSPROC_GETATTR,
113: NFSPROC_SETATTR,
114: NFSPROC_NOOP,
115: NFSPROC_LOOKUP,
116: NFSPROC_READLINK,
117: NFSPROC_READ,
118: NFSPROC_NOOP,
119: NFSPROC_WRITE,
120: NFSPROC_CREATE,
121: NFSPROC_REMOVE,
122: NFSPROC_RENAME,
123: NFSPROC_LINK,
124: NFSPROC_SYMLINK,
125: NFSPROC_MKDIR,
126: NFSPROC_RMDIR,
127: NFSPROC_READDIR,
128: NFSPROC_FSSTAT,
129: NFSPROC_NOOP,
130: NFSPROC_NOOP,
131: NFSPROC_NOOP,
132: NFSPROC_NOOP,
133: NFSPROC_NOOP,
134: NFSPROC_NOOP,
135: NFSPROC_NOOP,
136: NFSPROC_NOOP
137: };
138:
139: /*
140: * and the reverse mapping from generic to Version 2 procedure numbers
141: */
142: int nfsv2_procid[NFS_NPROCS] = {
143: NFSV2PROC_NULL,
144: NFSV2PROC_GETATTR,
145: NFSV2PROC_SETATTR,
146: NFSV2PROC_LOOKUP,
147: NFSV2PROC_NOOP,
148: NFSV2PROC_READLINK,
149: NFSV2PROC_READ,
150: NFSV2PROC_WRITE,
151: NFSV2PROC_CREATE,
152: NFSV2PROC_MKDIR,
153: NFSV2PROC_SYMLINK,
154: NFSV2PROC_CREATE,
155: NFSV2PROC_REMOVE,
156: NFSV2PROC_RMDIR,
157: NFSV2PROC_RENAME,
158: NFSV2PROC_LINK,
159: NFSV2PROC_READDIR,
160: NFSV2PROC_NOOP,
161: NFSV2PROC_STATFS,
162: NFSV2PROC_NOOP,
163: NFSV2PROC_NOOP,
164: NFSV2PROC_NOOP,
165: NFSV2PROC_NOOP,
166: NFSV2PROC_NOOP,
167: NFSV2PROC_NOOP,
168: NFSV2PROC_NOOP,
169: };
170:
171: /*
172: * Maps errno values to nfs error numbers.
173: * Use NFSERR_IO as the catch all for ones not specifically defined in
174: * RFC 1094.
175: */
176: static u_char nfsrv_v2errmap[ELAST] = {
177: NFSERR_PERM, NFSERR_NOENT, NFSERR_IO, NFSERR_IO, NFSERR_IO,
178: NFSERR_NXIO, NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO,
179: NFSERR_IO, NFSERR_IO, NFSERR_ACCES, NFSERR_IO, NFSERR_IO,
180: NFSERR_IO, NFSERR_EXIST, NFSERR_IO, NFSERR_NODEV, NFSERR_NOTDIR,
181: NFSERR_ISDIR, NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO,
182: NFSERR_IO, NFSERR_FBIG, NFSERR_NOSPC, NFSERR_IO, NFSERR_ROFS,
183: NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO,
184: NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO,
185: NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO,
186: NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO,
187: NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO,
188: NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO,
189: NFSERR_IO, NFSERR_IO, NFSERR_NAMETOL, NFSERR_IO, NFSERR_IO,
190: NFSERR_NOTEMPTY, NFSERR_IO, NFSERR_IO, NFSERR_DQUOT, NFSERR_STALE,
191: NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO,
192: NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO,
193: NFSERR_IO,
194: };
195:
196: /*
197: * Maps errno values to nfs error numbers.
198: * Although it is not obvious whether or not NFS clients really care if
199: * a returned error value is in the specified list for the procedure, the
200: * safest thing to do is filter them appropriately. For Version 2, the
201: * X/Open XNFS document is the only specification that defines error values
202: * for each RPC (The RFC simply lists all possible error values for all RPCs),
203: * so I have decided to not do this for Version 2.
204: * The first entry is the default error return and the rest are the valid
205: * errors for that RPC in increasing numeric order.
206: */
207: static short nfsv3err_null[] = {
208: 0,
209: 0,
210: };
211:
212: static short nfsv3err_getattr[] = {
213: NFSERR_IO,
214: NFSERR_IO,
215: NFSERR_STALE,
216: NFSERR_BADHANDLE,
217: NFSERR_SERVERFAULT,
218: 0,
219: };
220:
221: static short nfsv3err_setattr[] = {
222: NFSERR_IO,
223: NFSERR_PERM,
224: NFSERR_IO,
225: NFSERR_ACCES,
226: NFSERR_INVAL,
227: NFSERR_NOSPC,
228: NFSERR_ROFS,
229: NFSERR_DQUOT,
230: NFSERR_STALE,
231: NFSERR_BADHANDLE,
232: NFSERR_NOT_SYNC,
233: NFSERR_SERVERFAULT,
234: 0,
235: };
236:
237: static short nfsv3err_lookup[] = {
238: NFSERR_IO,
239: NFSERR_NOENT,
240: NFSERR_IO,
241: NFSERR_ACCES,
242: NFSERR_NOTDIR,
243: NFSERR_NAMETOL,
244: NFSERR_STALE,
245: NFSERR_BADHANDLE,
246: NFSERR_SERVERFAULT,
247: 0,
248: };
249:
250: static short nfsv3err_access[] = {
251: NFSERR_IO,
252: NFSERR_IO,
253: NFSERR_STALE,
254: NFSERR_BADHANDLE,
255: NFSERR_SERVERFAULT,
256: 0,
257: };
258:
259: static short nfsv3err_readlink[] = {
260: NFSERR_IO,
261: NFSERR_IO,
262: NFSERR_ACCES,
263: NFSERR_INVAL,
264: NFSERR_STALE,
265: NFSERR_BADHANDLE,
266: NFSERR_NOTSUPP,
267: NFSERR_SERVERFAULT,
268: 0,
269: };
270:
271: static short nfsv3err_read[] = {
272: NFSERR_IO,
273: NFSERR_IO,
274: NFSERR_NXIO,
275: NFSERR_ACCES,
276: NFSERR_INVAL,
277: NFSERR_STALE,
278: NFSERR_BADHANDLE,
279: NFSERR_SERVERFAULT,
280: 0,
281: };
282:
283: static short nfsv3err_write[] = {
284: NFSERR_IO,
285: NFSERR_IO,
286: NFSERR_ACCES,
287: NFSERR_INVAL,
288: NFSERR_FBIG,
289: NFSERR_NOSPC,
290: NFSERR_ROFS,
291: NFSERR_DQUOT,
292: NFSERR_STALE,
293: NFSERR_BADHANDLE,
294: NFSERR_SERVERFAULT,
295: 0,
296: };
297:
298: static short nfsv3err_create[] = {
299: NFSERR_IO,
300: NFSERR_IO,
301: NFSERR_ACCES,
302: NFSERR_EXIST,
303: NFSERR_NOTDIR,
304: NFSERR_NOSPC,
305: NFSERR_ROFS,
306: NFSERR_NAMETOL,
307: NFSERR_DQUOT,
308: NFSERR_STALE,
309: NFSERR_BADHANDLE,
310: NFSERR_NOTSUPP,
311: NFSERR_SERVERFAULT,
312: 0,
313: };
314:
315: static short nfsv3err_mkdir[] = {
316: NFSERR_IO,
317: NFSERR_IO,
318: NFSERR_ACCES,
319: NFSERR_EXIST,
320: NFSERR_NOTDIR,
321: NFSERR_NOSPC,
322: NFSERR_ROFS,
323: NFSERR_NAMETOL,
324: NFSERR_DQUOT,
325: NFSERR_STALE,
326: NFSERR_BADHANDLE,
327: NFSERR_NOTSUPP,
328: NFSERR_SERVERFAULT,
329: 0,
330: };
331:
332: static short nfsv3err_symlink[] = {
333: NFSERR_IO,
334: NFSERR_IO,
335: NFSERR_ACCES,
336: NFSERR_EXIST,
337: NFSERR_NOTDIR,
338: NFSERR_NOSPC,
339: NFSERR_ROFS,
340: NFSERR_NAMETOL,
341: NFSERR_DQUOT,
342: NFSERR_STALE,
343: NFSERR_BADHANDLE,
344: NFSERR_NOTSUPP,
345: NFSERR_SERVERFAULT,
346: 0,
347: };
348:
349: static short nfsv3err_mknod[] = {
350: NFSERR_IO,
351: NFSERR_IO,
352: NFSERR_ACCES,
353: NFSERR_EXIST,
354: NFSERR_NOTDIR,
355: NFSERR_NOSPC,
356: NFSERR_ROFS,
357: NFSERR_NAMETOL,
358: NFSERR_DQUOT,
359: NFSERR_STALE,
360: NFSERR_BADHANDLE,
361: NFSERR_NOTSUPP,
362: NFSERR_SERVERFAULT,
363: NFSERR_BADTYPE,
364: 0,
365: };
366:
367: static short nfsv3err_remove[] = {
368: NFSERR_IO,
369: NFSERR_NOENT,
370: NFSERR_IO,
371: NFSERR_ACCES,
372: NFSERR_NOTDIR,
373: NFSERR_ROFS,
374: NFSERR_NAMETOL,
375: NFSERR_STALE,
376: NFSERR_BADHANDLE,
377: NFSERR_SERVERFAULT,
378: 0,
379: };
380:
381: static short nfsv3err_rmdir[] = {
382: NFSERR_IO,
383: NFSERR_NOENT,
384: NFSERR_IO,
385: NFSERR_ACCES,
386: NFSERR_EXIST,
387: NFSERR_NOTDIR,
388: NFSERR_INVAL,
389: NFSERR_ROFS,
390: NFSERR_NAMETOL,
391: NFSERR_NOTEMPTY,
392: NFSERR_STALE,
393: NFSERR_BADHANDLE,
394: NFSERR_NOTSUPP,
395: NFSERR_SERVERFAULT,
396: 0,
397: };
398:
399: static short nfsv3err_rename[] = {
400: NFSERR_IO,
401: NFSERR_NOENT,
402: NFSERR_IO,
403: NFSERR_ACCES,
404: NFSERR_EXIST,
405: NFSERR_XDEV,
406: NFSERR_NOTDIR,
407: NFSERR_ISDIR,
408: NFSERR_INVAL,
409: NFSERR_NOSPC,
410: NFSERR_ROFS,
411: NFSERR_MLINK,
412: NFSERR_NAMETOL,
413: NFSERR_NOTEMPTY,
414: NFSERR_DQUOT,
415: NFSERR_STALE,
416: NFSERR_BADHANDLE,
417: NFSERR_NOTSUPP,
418: NFSERR_SERVERFAULT,
419: 0,
420: };
421:
422: static short nfsv3err_link[] = {
423: NFSERR_IO,
424: NFSERR_IO,
425: NFSERR_ACCES,
426: NFSERR_EXIST,
427: NFSERR_XDEV,
428: NFSERR_NOTDIR,
429: NFSERR_INVAL,
430: NFSERR_NOSPC,
431: NFSERR_ROFS,
432: NFSERR_MLINK,
433: NFSERR_NAMETOL,
434: NFSERR_DQUOT,
435: NFSERR_STALE,
436: NFSERR_BADHANDLE,
437: NFSERR_NOTSUPP,
438: NFSERR_SERVERFAULT,
439: 0,
440: };
441:
442: static short nfsv3err_readdir[] = {
443: NFSERR_IO,
444: NFSERR_IO,
445: NFSERR_ACCES,
446: NFSERR_NOTDIR,
447: NFSERR_STALE,
448: NFSERR_BADHANDLE,
449: NFSERR_BAD_COOKIE,
450: NFSERR_TOOSMALL,
451: NFSERR_SERVERFAULT,
452: 0,
453: };
454:
455: static short nfsv3err_readdirplus[] = {
456: NFSERR_IO,
457: NFSERR_IO,
458: NFSERR_ACCES,
459: NFSERR_NOTDIR,
460: NFSERR_STALE,
461: NFSERR_BADHANDLE,
462: NFSERR_BAD_COOKIE,
463: NFSERR_NOTSUPP,
464: NFSERR_TOOSMALL,
465: NFSERR_SERVERFAULT,
466: 0,
467: };
468:
469: static short nfsv3err_fsstat[] = {
470: NFSERR_IO,
471: NFSERR_IO,
472: NFSERR_STALE,
473: NFSERR_BADHANDLE,
474: NFSERR_SERVERFAULT,
475: 0,
476: };
477:
478: static short nfsv3err_fsinfo[] = {
479: NFSERR_STALE,
480: NFSERR_STALE,
481: NFSERR_BADHANDLE,
482: NFSERR_SERVERFAULT,
483: 0,
484: };
485:
486: static short nfsv3err_pathconf[] = {
487: NFSERR_STALE,
488: NFSERR_STALE,
489: NFSERR_BADHANDLE,
490: NFSERR_SERVERFAULT,
491: 0,
492: };
493:
494: static short nfsv3err_commit[] = {
495: NFSERR_IO,
496: NFSERR_IO,
497: NFSERR_STALE,
498: NFSERR_BADHANDLE,
499: NFSERR_SERVERFAULT,
500: 0,
501: };
502:
503: static short *nfsrv_v3errmap[] = {
504: nfsv3err_null,
505: nfsv3err_getattr,
506: nfsv3err_setattr,
507: nfsv3err_lookup,
508: nfsv3err_access,
509: nfsv3err_readlink,
510: nfsv3err_read,
511: nfsv3err_write,
512: nfsv3err_create,
513: nfsv3err_mkdir,
514: nfsv3err_symlink,
515: nfsv3err_mknod,
516: nfsv3err_remove,
517: nfsv3err_rmdir,
518: nfsv3err_rename,
519: nfsv3err_link,
520: nfsv3err_readdir,
521: nfsv3err_readdirplus,
522: nfsv3err_fsstat,
523: nfsv3err_fsinfo,
524: nfsv3err_pathconf,
525: nfsv3err_commit,
526: };
527:
528: extern struct proc *nfs_iodwant[NFS_MAXASYNCDAEMON];
529: extern struct nfsrtt nfsrtt;
530:
531: struct pool nfsreqpl;
532:
533: /*
534: * Create the header for an rpc request packet
535: * The hsiz is the size of the rest of the nfs request header.
536: * (just used to decide if a cluster is a good idea)
537: */
538: struct mbuf *
539: nfsm_reqh(vp, procid, hsiz, bposp)
540: struct vnode *vp;
541: u_long procid;
542: int hsiz;
543: caddr_t *bposp;
544: {
545: struct mbuf *mb;
546: caddr_t bpos;
547:
548: MGET(mb, M_WAIT, MT_DATA);
549: if (hsiz >= MINCLSIZE)
550: MCLGET(mb, M_WAIT);
551: mb->m_len = 0;
552: bpos = mtod(mb, caddr_t);
553:
554: /* Finally, return values */
555: *bposp = bpos;
556: return (mb);
557: }
558:
559: /*
560: * Build the RPC header and fill in the authorization info.
561: * The authorization string argument is only used when the credentials
562: * come from outside of the kernel.
563: * Returns the head of the mbuf list.
564: */
565: struct mbuf *
566: nfsm_rpchead(cr, nmflag, procid, auth_type, auth_len, auth_str, verf_len,
567: verf_str, mrest, mrest_len, mbp, xidp)
568: struct ucred *cr;
569: int nmflag;
570: int procid;
571: int auth_type;
572: int auth_len;
573: char *auth_str;
574: int verf_len;
575: char *verf_str;
576: struct mbuf *mrest;
577: int mrest_len;
578: struct mbuf **mbp;
579: u_int32_t *xidp;
580: {
581: struct mbuf *mb;
582: u_int32_t *tl;
583: caddr_t bpos;
584: int i;
585: struct mbuf *mreq, *mb2;
586: int siz, grpsiz, authsiz;
587:
588: authsiz = nfsm_rndup(auth_len);
589: MGETHDR(mb, M_WAIT, MT_DATA);
590: if ((authsiz + 10 * NFSX_UNSIGNED) >= MINCLSIZE) {
591: MCLGET(mb, M_WAIT);
592: } else if ((authsiz + 10 * NFSX_UNSIGNED) < MHLEN) {
593: MH_ALIGN(mb, authsiz + 10 * NFSX_UNSIGNED);
594: } else {
595: MH_ALIGN(mb, 8 * NFSX_UNSIGNED);
596: }
597: mb->m_len = 0;
598: mreq = mb;
599: bpos = mtod(mb, caddr_t);
600:
601: /*
602: * First the RPC header.
603: */
604: nfsm_build(tl, u_int32_t *, 8 * NFSX_UNSIGNED);
605:
606: /* Get a new (non-zero) xid */
607:
608: if ((nfs_xid == 0) && (nfs_xid_touched == 0)) {
609: nfs_xid = arc4random();
610: nfs_xid_touched = 1;
611: } else {
612: while ((*xidp = arc4random() % 256) == 0)
613: ;
614: nfs_xid += *xidp;
615: }
616:
617: *tl++ = *xidp = txdr_unsigned(nfs_xid);
618: *tl++ = rpc_call;
619: *tl++ = rpc_vers;
620: *tl++ = txdr_unsigned(NFS_PROG);
621: if (nmflag & NFSMNT_NFSV3)
622: *tl++ = txdr_unsigned(NFS_VER3);
623: else
624: *tl++ = txdr_unsigned(NFS_VER2);
625: if (nmflag & NFSMNT_NFSV3)
626: *tl++ = txdr_unsigned(procid);
627: else
628: *tl++ = txdr_unsigned(nfsv2_procid[procid]);
629:
630: /*
631: * And then the authorization cred.
632: */
633: *tl++ = txdr_unsigned(auth_type);
634: *tl = txdr_unsigned(authsiz);
635: switch (auth_type) {
636: case RPCAUTH_UNIX:
637: nfsm_build(tl, u_int32_t *, auth_len);
638: *tl++ = 0; /* stamp ?? */
639: *tl++ = 0; /* NULL hostname */
640: *tl++ = txdr_unsigned(cr->cr_uid);
641: *tl++ = txdr_unsigned(cr->cr_gid);
642: grpsiz = (auth_len >> 2) - 5;
643: *tl++ = txdr_unsigned(grpsiz);
644: for (i = 0; i < grpsiz; i++)
645: *tl++ = txdr_unsigned(cr->cr_groups[i]);
646: break;
647: case RPCAUTH_KERB4:
648: siz = auth_len;
649: while (siz > 0) {
650: if (M_TRAILINGSPACE(mb) == 0) {
651: MGET(mb2, M_WAIT, MT_DATA);
652: if (siz >= MINCLSIZE)
653: MCLGET(mb2, M_WAIT);
654: mb->m_next = mb2;
655: mb = mb2;
656: mb->m_len = 0;
657: bpos = mtod(mb, caddr_t);
658: }
659: i = min(siz, M_TRAILINGSPACE(mb));
660: bcopy(auth_str, bpos, i);
661: mb->m_len += i;
662: auth_str += i;
663: bpos += i;
664: siz -= i;
665: }
666: if ((siz = (nfsm_rndup(auth_len) - auth_len)) > 0) {
667: for (i = 0; i < siz; i++)
668: *bpos++ = '\0';
669: mb->m_len += siz;
670: }
671: break;
672: };
673:
674: /*
675: * And the verifier...
676: */
677: nfsm_build(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
678: if (verf_str) {
679: *tl++ = txdr_unsigned(RPCAUTH_KERB4);
680: *tl = txdr_unsigned(verf_len);
681: siz = verf_len;
682: while (siz > 0) {
683: if (M_TRAILINGSPACE(mb) == 0) {
684: MGET(mb2, M_WAIT, MT_DATA);
685: if (siz >= MINCLSIZE)
686: MCLGET(mb2, M_WAIT);
687: mb->m_next = mb2;
688: mb = mb2;
689: mb->m_len = 0;
690: bpos = mtod(mb, caddr_t);
691: }
692: i = min(siz, M_TRAILINGSPACE(mb));
693: bcopy(verf_str, bpos, i);
694: mb->m_len += i;
695: verf_str += i;
696: bpos += i;
697: siz -= i;
698: }
699: if ((siz = (nfsm_rndup(verf_len) - verf_len)) > 0) {
700: for (i = 0; i < siz; i++)
701: *bpos++ = '\0';
702: mb->m_len += siz;
703: }
704: } else {
705: *tl++ = txdr_unsigned(RPCAUTH_NULL);
706: *tl = 0;
707: }
708: mb->m_next = mrest;
709: mreq->m_pkthdr.len = authsiz + 10 * NFSX_UNSIGNED + mrest_len;
710: mreq->m_pkthdr.rcvif = (struct ifnet *)0;
711: *mbp = mb;
712: return (mreq);
713: }
714:
715: /*
716: * copies mbuf chain to the uio scatter/gather list
717: */
718: int
719: nfsm_mbuftouio(mrep, uiop, siz, dpos)
720: struct mbuf **mrep;
721: struct uio *uiop;
722: int siz;
723: caddr_t *dpos;
724: {
725: char *mbufcp, *uiocp;
726: int xfer, left, len;
727: struct mbuf *mp;
728: long uiosiz, rem;
729: int error = 0;
730:
731: mp = *mrep;
732: mbufcp = *dpos;
733: len = mtod(mp, caddr_t)+mp->m_len-mbufcp;
734: rem = nfsm_rndup(siz)-siz;
735: while (siz > 0) {
736: if (uiop->uio_iovcnt <= 0 || uiop->uio_iov == NULL)
737: return (EFBIG);
738: left = uiop->uio_iov->iov_len;
739: uiocp = uiop->uio_iov->iov_base;
740: if (left > siz)
741: left = siz;
742: uiosiz = left;
743: while (left > 0) {
744: while (len == 0) {
745: mp = mp->m_next;
746: if (mp == NULL)
747: return (EBADRPC);
748: mbufcp = mtod(mp, caddr_t);
749: len = mp->m_len;
750: }
751: xfer = (left > len) ? len : left;
752: #ifdef notdef
753: /* Not Yet.. */
754: if (uiop->uio_iov->iov_op != NULL)
755: (*(uiop->uio_iov->iov_op))
756: (mbufcp, uiocp, xfer);
757: else
758: #endif
759: if (uiop->uio_segflg == UIO_SYSSPACE)
760: bcopy(mbufcp, uiocp, xfer);
761: else
762: copyout(mbufcp, uiocp, xfer);
763: left -= xfer;
764: len -= xfer;
765: mbufcp += xfer;
766: uiocp += xfer;
767: uiop->uio_offset += xfer;
768: uiop->uio_resid -= xfer;
769: }
770: if (uiop->uio_iov->iov_len <= siz) {
771: uiop->uio_iovcnt--;
772: uiop->uio_iov++;
773: } else {
774: (char *)uiop->uio_iov->iov_base += uiosiz;
775: uiop->uio_iov->iov_len -= uiosiz;
776: }
777: siz -= uiosiz;
778: }
779: *dpos = mbufcp;
780: *mrep = mp;
781: if (rem > 0) {
782: if (len < rem)
783: error = nfs_adv(mrep, dpos, rem, len);
784: else
785: *dpos += rem;
786: }
787: return (error);
788: }
789:
790: /*
791: * copies a uio scatter/gather list to an mbuf chain.
792: * NOTE: can ony handle iovcnt == 1
793: */
794: int
795: nfsm_uiotombuf(uiop, mq, siz, bpos)
796: struct uio *uiop;
797: struct mbuf **mq;
798: int siz;
799: caddr_t *bpos;
800: {
801: char *uiocp;
802: struct mbuf *mp, *mp2;
803: int xfer, left, mlen;
804: int uiosiz, clflg, rem;
805: char *cp;
806:
807: #ifdef DIAGNOSTIC
808: if (uiop->uio_iovcnt != 1)
809: panic("nfsm_uiotombuf: iovcnt != 1");
810: #endif
811:
812: if (siz > MLEN) /* or should it >= MCLBYTES ?? */
813: clflg = 1;
814: else
815: clflg = 0;
816: rem = nfsm_rndup(siz)-siz;
817: mp = mp2 = *mq;
818: while (siz > 0) {
819: left = uiop->uio_iov->iov_len;
820: uiocp = uiop->uio_iov->iov_base;
821: if (left > siz)
822: left = siz;
823: uiosiz = left;
824: while (left > 0) {
825: mlen = M_TRAILINGSPACE(mp);
826: if (mlen == 0) {
827: MGET(mp, M_WAIT, MT_DATA);
828: if (clflg)
829: MCLGET(mp, M_WAIT);
830: mp->m_len = 0;
831: mp2->m_next = mp;
832: mp2 = mp;
833: mlen = M_TRAILINGSPACE(mp);
834: }
835: xfer = (left > mlen) ? mlen : left;
836: #ifdef notdef
837: /* Not Yet.. */
838: if (uiop->uio_iov->iov_op != NULL)
839: (*(uiop->uio_iov->iov_op))
840: (uiocp, mtod(mp, caddr_t)+mp->m_len, xfer);
841: else
842: #endif
843: if (uiop->uio_segflg == UIO_SYSSPACE)
844: bcopy(uiocp, mtod(mp, caddr_t)+mp->m_len, xfer);
845: else
846: copyin(uiocp, mtod(mp, caddr_t)+mp->m_len, xfer);
847: mp->m_len += xfer;
848: left -= xfer;
849: uiocp += xfer;
850: uiop->uio_offset += xfer;
851: uiop->uio_resid -= xfer;
852: }
853: (char *)uiop->uio_iov->iov_base += uiosiz;
854: uiop->uio_iov->iov_len -= uiosiz;
855: siz -= uiosiz;
856: }
857: if (rem > 0) {
858: if (rem > M_TRAILINGSPACE(mp)) {
859: MGET(mp, M_WAIT, MT_DATA);
860: mp->m_len = 0;
861: mp2->m_next = mp;
862: }
863: cp = mtod(mp, caddr_t)+mp->m_len;
864: for (left = 0; left < rem; left++)
865: *cp++ = '\0';
866: mp->m_len += rem;
867: *bpos = cp;
868: } else
869: *bpos = mtod(mp, caddr_t)+mp->m_len;
870: *mq = mp;
871: return (0);
872: }
873:
874: /*
875: * Help break down an mbuf chain by setting the first siz bytes contiguous
876: * pointed to by returned val.
877: * This is used by the macros nfsm_dissect and nfsm_dissecton for tough
878: * cases. (The macros use the vars. dpos and dpos2)
879: */
880: int
881: nfsm_disct(mdp, dposp, siz, left, cp2)
882: struct mbuf **mdp;
883: caddr_t *dposp;
884: int siz;
885: int left;
886: caddr_t *cp2;
887: {
888: struct mbuf *mp, *mp2;
889: int siz2, xfer;
890: caddr_t p;
891:
892: mp = *mdp;
893: while (left == 0) {
894: *mdp = mp = mp->m_next;
895: if (mp == NULL)
896: return (EBADRPC);
897: left = mp->m_len;
898: *dposp = mtod(mp, caddr_t);
899: }
900: if (left >= siz) {
901: *cp2 = *dposp;
902: *dposp += siz;
903: } else if (mp->m_next == NULL) {
904: return (EBADRPC);
905: } else if (siz > MHLEN) {
906: panic("nfs S too big");
907: } else {
908: MGET(mp2, M_WAIT, MT_DATA);
909: mp2->m_next = mp->m_next;
910: mp->m_next = mp2;
911: mp->m_len -= left;
912: mp = mp2;
913: *cp2 = p = mtod(mp, caddr_t);
914: bcopy(*dposp, p, left); /* Copy what was left */
915: siz2 = siz-left;
916: p += left;
917: mp2 = mp->m_next;
918: /* Loop around copying up the siz2 bytes */
919: while (siz2 > 0) {
920: if (mp2 == NULL)
921: return (EBADRPC);
922: xfer = (siz2 > mp2->m_len) ? mp2->m_len : siz2;
923: if (xfer > 0) {
924: bcopy(mtod(mp2, caddr_t), p, xfer);
925: NFSMADV(mp2, xfer);
926: mp2->m_len -= xfer;
927: p += xfer;
928: siz2 -= xfer;
929: }
930: if (siz2 > 0)
931: mp2 = mp2->m_next;
932: }
933: mp->m_len = siz;
934: *mdp = mp2;
935: *dposp = mtod(mp2, caddr_t);
936: }
937: return (0);
938: }
939:
940: /*
941: * Advance the position in the mbuf chain.
942: */
943: int
944: nfs_adv(mdp, dposp, offs, left)
945: struct mbuf **mdp;
946: caddr_t *dposp;
947: int offs;
948: int left;
949: {
950: struct mbuf *m;
951: int s;
952:
953: m = *mdp;
954: s = left;
955: while (s < offs) {
956: offs -= s;
957: m = m->m_next;
958: if (m == NULL)
959: return (EBADRPC);
960: s = m->m_len;
961: }
962: *mdp = m;
963: *dposp = mtod(m, caddr_t)+offs;
964: return (0);
965: }
966:
967: /*
968: * Copy a string into mbufs for the hard cases...
969: */
970: int
971: nfsm_strtmbuf(mb, bpos, cp, siz)
972: struct mbuf **mb;
973: char **bpos;
974: char *cp;
975: long siz;
976: {
977: struct mbuf *m1 = NULL, *m2;
978: long left, xfer, len, tlen;
979: u_int32_t *tl;
980: int putsize;
981:
982: putsize = 1;
983: m2 = *mb;
984: left = M_TRAILINGSPACE(m2);
985: if (left > 0) {
986: tl = ((u_int32_t *)(*bpos));
987: *tl++ = txdr_unsigned(siz);
988: putsize = 0;
989: left -= NFSX_UNSIGNED;
990: m2->m_len += NFSX_UNSIGNED;
991: if (left > 0) {
992: bcopy(cp, (caddr_t) tl, left);
993: siz -= left;
994: cp += left;
995: m2->m_len += left;
996: left = 0;
997: }
998: }
999: /* Loop around adding mbufs */
1000: while (siz > 0) {
1001: MGET(m1, M_WAIT, MT_DATA);
1002: if (siz > MLEN)
1003: MCLGET(m1, M_WAIT);
1004: m1->m_len = NFSMSIZ(m1);
1005: m2->m_next = m1;
1006: m2 = m1;
1007: tl = mtod(m1, u_int32_t *);
1008: tlen = 0;
1009: if (putsize) {
1010: *tl++ = txdr_unsigned(siz);
1011: m1->m_len -= NFSX_UNSIGNED;
1012: tlen = NFSX_UNSIGNED;
1013: putsize = 0;
1014: }
1015: if (siz < m1->m_len) {
1016: len = nfsm_rndup(siz);
1017: xfer = siz;
1018: if (xfer < len)
1019: *(tl+(xfer>>2)) = 0;
1020: } else {
1021: xfer = len = m1->m_len;
1022: }
1023: bcopy(cp, (caddr_t) tl, xfer);
1024: m1->m_len = len+tlen;
1025: siz -= xfer;
1026: cp += xfer;
1027: }
1028: *mb = m1;
1029: *bpos = mtod(m1, caddr_t)+m1->m_len;
1030: return (0);
1031: }
1032:
1033: /*
1034: * Called once to initialize data structures...
1035: */
1036: void
1037: nfs_init()
1038: {
1039: static struct timeout nfs_timer_to;
1040:
1041: nfsrtt.pos = 0;
1042: rpc_vers = txdr_unsigned(RPC_VER2);
1043: rpc_call = txdr_unsigned(RPC_CALL);
1044: rpc_reply = txdr_unsigned(RPC_REPLY);
1045: rpc_msgdenied = txdr_unsigned(RPC_MSGDENIED);
1046: rpc_msgaccepted = txdr_unsigned(RPC_MSGACCEPTED);
1047: rpc_mismatch = txdr_unsigned(RPC_MISMATCH);
1048: rpc_autherr = txdr_unsigned(RPC_AUTHERR);
1049: rpc_auth_unix = txdr_unsigned(RPCAUTH_UNIX);
1050: rpc_auth_kerb = txdr_unsigned(RPCAUTH_KERB4);
1051: nfs_prog = txdr_unsigned(NFS_PROG);
1052: nfs_true = txdr_unsigned(TRUE);
1053: nfs_false = txdr_unsigned(FALSE);
1054: nfs_xdrneg1 = txdr_unsigned(-1);
1055: nfs_ticks = (hz * NFS_TICKINTVL + 500) / 1000;
1056: if (nfs_ticks < 1)
1057: nfs_ticks = 1;
1058: #ifdef NFSSERVER
1059: nfsrv_init(0); /* Init server data structures */
1060: nfsrv_initcache(); /* Init the server request cache */
1061: #endif /* NFSSERVER */
1062:
1063: pool_init(&nfsreqpl, sizeof(struct nfsreq), 0, 0, 0, "nfsreqpl",
1064: &pool_allocator_nointr);
1065:
1066: /*
1067: * Initialize reply list and start timer
1068: */
1069: TAILQ_INIT(&nfs_reqq);
1070:
1071: timeout_set(&nfs_timer_to, nfs_timer, &nfs_timer_to);
1072: nfs_timer(&nfs_timer_to);
1073: }
1074:
1075: #ifdef NFSCLIENT
1076: int
1077: nfs_vfs_init(vfsp)
1078: struct vfsconf *vfsp;
1079: {
1080: int i;
1081:
1082: /* Ensure async daemons disabled */
1083: for (i = 0; i < NFS_MAXASYNCDAEMON; i++)
1084: nfs_iodwant[i] = (struct proc *)0;
1085: TAILQ_INIT(&nfs_bufq);
1086: nfs_nhinit(); /* Init the nfsnode table */
1087:
1088: return (0);
1089: }
1090:
1091: /*
1092: * Attribute cache routines.
1093: * nfs_loadattrcache() - loads or updates the cache contents from attributes
1094: * that are on the mbuf list
1095: * nfs_getattrcache() - returns valid attributes if found in cache, returns
1096: * error otherwise
1097: */
1098:
1099: /*
1100: * Load the attribute cache (that lives in the nfsnode entry) with
1101: * the values on the mbuf list and
1102: * Iff vap not NULL
1103: * copy the attributes to *vaper
1104: */
1105: int
1106: nfs_loadattrcache(vpp, mdp, dposp, vaper)
1107: struct vnode **vpp;
1108: struct mbuf **mdp;
1109: caddr_t *dposp;
1110: struct vattr *vaper;
1111: {
1112: struct vnode *vp = *vpp;
1113: struct vattr *vap;
1114: struct nfs_fattr *fp;
1115: extern int (**spec_nfsv2nodeop_p)(void *);
1116: struct nfsnode *np;
1117: int32_t t1;
1118: caddr_t cp2;
1119: int error = 0;
1120: int32_t rdev;
1121: struct mbuf *md;
1122: enum vtype vtyp;
1123: mode_t vmode;
1124: struct timespec mtime;
1125: struct vnode *nvp;
1126: int v3 = NFS_ISV3(vp);
1127:
1128: md = *mdp;
1129: t1 = (mtod(md, caddr_t) + md->m_len) - *dposp;
1130: error = nfsm_disct(mdp, dposp, NFSX_FATTR(v3), t1, &cp2);
1131: if (error)
1132: return (error);
1133: fp = (struct nfs_fattr *)cp2;
1134: if (v3) {
1135: vtyp = nfsv3tov_type(fp->fa_type);
1136: vmode = fxdr_unsigned(mode_t, fp->fa_mode);
1137: rdev = makedev(fxdr_unsigned(u_int32_t, fp->fa3_rdev.specdata1),
1138: fxdr_unsigned(u_int32_t, fp->fa3_rdev.specdata2));
1139: fxdr_nfsv3time(&fp->fa3_mtime, &mtime);
1140: } else {
1141: vtyp = nfsv2tov_type(fp->fa_type);
1142: vmode = fxdr_unsigned(mode_t, fp->fa_mode);
1143: if (vtyp == VNON || vtyp == VREG)
1144: vtyp = IFTOVT(vmode);
1145: rdev = fxdr_unsigned(int32_t, fp->fa2_rdev);
1146: fxdr_nfsv2time(&fp->fa2_mtime, &mtime);
1147:
1148: /*
1149: * Really ugly NFSv2 kludge.
1150: */
1151: if (vtyp == VCHR && rdev == 0xffffffff)
1152: vtyp = VFIFO;
1153: }
1154:
1155: /*
1156: * If v_type == VNON it is a new node, so fill in the v_type,
1157: * n_mtime fields. Check to see if it represents a special
1158: * device, and if so, check for a possible alias. Once the
1159: * correct vnode has been obtained, fill in the rest of the
1160: * information.
1161: */
1162: np = VTONFS(vp);
1163: if (vp->v_type != vtyp) {
1164: vp->v_type = vtyp;
1165: if (vp->v_type == VFIFO) {
1166: #ifndef FIFO
1167: return (EOPNOTSUPP);
1168: #else
1169: extern int (**fifo_nfsv2nodeop_p)(void *);
1170: vp->v_op = fifo_nfsv2nodeop_p;
1171: #endif /* FIFO */
1172: }
1173: if (vp->v_type == VCHR || vp->v_type == VBLK) {
1174: vp->v_op = spec_nfsv2nodeop_p;
1175: nvp = checkalias(vp, (dev_t)rdev, vp->v_mount);
1176: if (nvp) {
1177: /*
1178: * Discard unneeded vnode, but save its nfsnode.
1179: * Since the nfsnode does not have a lock, its
1180: * vnode lock has to be carried over.
1181: */
1182:
1183: nvp->v_data = vp->v_data;
1184: vp->v_data = NULL;
1185: vp->v_op = spec_vnodeop_p;
1186: vrele(vp);
1187: vgone(vp);
1188: /*
1189: * Reinitialize aliased node.
1190: */
1191: np->n_vnode = nvp;
1192: *vpp = vp = nvp;
1193: }
1194: }
1195: np->n_mtime = mtime.tv_sec;
1196: }
1197: vap = &np->n_vattr;
1198: vap->va_type = vtyp;
1199: vap->va_mode = (vmode & 07777);
1200: vap->va_rdev = (dev_t)rdev;
1201: vap->va_mtime = mtime;
1202: vap->va_fsid = vp->v_mount->mnt_stat.f_fsid.val[0];
1203: if (v3) {
1204: vap->va_nlink = fxdr_unsigned(nlink_t, fp->fa_nlink);
1205: vap->va_uid = fxdr_unsigned(uid_t, fp->fa_uid);
1206: vap->va_gid = fxdr_unsigned(gid_t, fp->fa_gid);
1207: vap->va_size = fxdr_hyper(&fp->fa3_size);
1208: vap->va_blocksize = NFS_FABLKSIZE;
1209: vap->va_bytes = fxdr_hyper(&fp->fa3_used);
1210: vap->va_fileid = fxdr_unsigned(int32_t,
1211: fp->fa3_fileid.nfsuquad[1]);
1212: fxdr_nfsv3time(&fp->fa3_atime, &vap->va_atime);
1213: fxdr_nfsv3time(&fp->fa3_ctime, &vap->va_ctime);
1214: vap->va_flags = 0;
1215: vap->va_filerev = 0;
1216: } else {
1217: vap->va_nlink = fxdr_unsigned(nlink_t, fp->fa_nlink);
1218: vap->va_uid = fxdr_unsigned(uid_t, fp->fa_uid);
1219: vap->va_gid = fxdr_unsigned(gid_t, fp->fa_gid);
1220: vap->va_size = fxdr_unsigned(u_int32_t, fp->fa2_size);
1221: vap->va_blocksize = fxdr_unsigned(int32_t, fp->fa2_blocksize);
1222: vap->va_bytes =
1223: (u_quad_t)fxdr_unsigned(int32_t, fp->fa2_blocks) *
1224: NFS_FABLKSIZE;
1225: vap->va_fileid = fxdr_unsigned(int32_t, fp->fa2_fileid);
1226: fxdr_nfsv2time(&fp->fa2_atime, &vap->va_atime);
1227: vap->va_flags = 0;
1228: vap->va_ctime.tv_sec = fxdr_unsigned(u_int32_t,
1229: fp->fa2_ctime.nfsv2_sec);
1230: vap->va_ctime.tv_nsec = 0;
1231: vap->va_gen = fxdr_unsigned(u_int32_t,fp->fa2_ctime.nfsv2_usec);
1232: vap->va_filerev = 0;
1233: }
1234: if (vap->va_size != np->n_size) {
1235: if (vap->va_type == VREG) {
1236: if (np->n_flag & NMODIFIED) {
1237: if (vap->va_size < np->n_size)
1238: vap->va_size = np->n_size;
1239: else
1240: np->n_size = vap->va_size;
1241: } else
1242: np->n_size = vap->va_size;
1243: uvm_vnp_setsize(vp, np->n_size);
1244: } else
1245: np->n_size = vap->va_size;
1246: }
1247: np->n_attrstamp = time_second;
1248: if (vaper != NULL) {
1249: bcopy((caddr_t)vap, (caddr_t)vaper, sizeof(*vap));
1250: if (np->n_flag & NCHG) {
1251: if (np->n_flag & NACC)
1252: vaper->va_atime = np->n_atim;
1253: if (np->n_flag & NUPD)
1254: vaper->va_mtime = np->n_mtim;
1255: }
1256: }
1257: return (0);
1258: }
1259:
1260: INLINE int
1261: nfs_attrtimeo (np)
1262: struct nfsnode *np;
1263: {
1264: struct vnode *vp = np->n_vnode;
1265: struct nfsmount *nmp = VFSTONFS(vp->v_mount);
1266: int tenthage = (time_second - np->n_mtime) / 10;
1267: int minto, maxto;
1268:
1269: if (vp->v_type == VDIR) {
1270: maxto = nmp->nm_acdirmax;
1271: minto = nmp->nm_acdirmin;
1272: }
1273: else {
1274: maxto = nmp->nm_acregmax;
1275: minto = nmp->nm_acregmin;
1276: }
1277:
1278: if (np->n_flag & NMODIFIED || tenthage < minto)
1279: return minto;
1280: else if (tenthage < maxto)
1281: return tenthage;
1282: else
1283: return maxto;
1284: }
1285:
1286: /*
1287: * Check the time stamp
1288: * If the cache is valid, copy contents to *vap and return 0
1289: * otherwise return an error
1290: */
1291: int
1292: nfs_getattrcache(vp, vaper)
1293: struct vnode *vp;
1294: struct vattr *vaper;
1295: {
1296: struct nfsnode *np = VTONFS(vp);
1297: struct vattr *vap;
1298:
1299: if (np->n_attrstamp == 0 ||
1300: (time_second - np->n_attrstamp) >= nfs_attrtimeo(np)) {
1301: nfsstats.attrcache_misses++;
1302: return (ENOENT);
1303: }
1304: nfsstats.attrcache_hits++;
1305: vap = &np->n_vattr;
1306: if (vap->va_size != np->n_size) {
1307: if (vap->va_type == VREG) {
1308: if (np->n_flag & NMODIFIED) {
1309: if (vap->va_size < np->n_size)
1310: vap->va_size = np->n_size;
1311: else
1312: np->n_size = vap->va_size;
1313: } else
1314: np->n_size = vap->va_size;
1315: uvm_vnp_setsize(vp, np->n_size);
1316: } else
1317: np->n_size = vap->va_size;
1318: }
1319: bcopy((caddr_t)vap, (caddr_t)vaper, sizeof(struct vattr));
1320: if (np->n_flag & NCHG) {
1321: if (np->n_flag & NACC)
1322: vaper->va_atime = np->n_atim;
1323: if (np->n_flag & NUPD)
1324: vaper->va_mtime = np->n_mtim;
1325: }
1326: return (0);
1327: }
1328: #endif /* NFSCLIENT */
1329:
1330: /*
1331: * Set up nameidata for a lookup() call and do it
1332: */
1333: int
1334: nfs_namei(ndp, fhp, len, slp, nam, mdp, dposp, retdirp, p, kerbflag)
1335: struct nameidata *ndp;
1336: fhandle_t *fhp;
1337: int len;
1338: struct nfssvc_sock *slp;
1339: struct mbuf *nam;
1340: struct mbuf **mdp;
1341: caddr_t *dposp;
1342: struct vnode **retdirp;
1343: struct proc *p;
1344: int kerbflag;
1345: {
1346: int i, rem;
1347: struct mbuf *md;
1348: char *fromcp, *tocp;
1349: struct vnode *dp;
1350: int error, rdonly;
1351: struct componentname *cnp = &ndp->ni_cnd;
1352:
1353: *retdirp = (struct vnode *)0;
1354: cnp->cn_pnbuf = pool_get(&namei_pool, PR_WAITOK);
1355: /*
1356: * Copy the name from the mbuf list to ndp->ni_pnbuf
1357: * and set the various ndp fields appropriately.
1358: */
1359: fromcp = *dposp;
1360: tocp = cnp->cn_pnbuf;
1361: md = *mdp;
1362: rem = mtod(md, caddr_t) + md->m_len - fromcp;
1363: cnp->cn_hash = 0;
1364: for (i = 0; i < len; i++) {
1365: while (rem == 0) {
1366: md = md->m_next;
1367: if (md == NULL) {
1368: error = EBADRPC;
1369: goto out;
1370: }
1371: fromcp = mtod(md, caddr_t);
1372: rem = md->m_len;
1373: }
1374: if (*fromcp == '\0' || *fromcp == '/') {
1375: error = EACCES;
1376: goto out;
1377: }
1378: cnp->cn_hash += (u_char)*fromcp;
1379: *tocp++ = *fromcp++;
1380: rem--;
1381: }
1382: *tocp = '\0';
1383: *mdp = md;
1384: *dposp = fromcp;
1385: len = nfsm_rndup(len)-len;
1386: if (len > 0) {
1387: if (rem >= len)
1388: *dposp += len;
1389: else if ((error = nfs_adv(mdp, dposp, len, rem)) != 0)
1390: goto out;
1391: }
1392: ndp->ni_pathlen = tocp - cnp->cn_pnbuf;
1393: cnp->cn_nameptr = cnp->cn_pnbuf;
1394: /*
1395: * Extract and set starting directory.
1396: */
1397: error = nfsrv_fhtovp(fhp, FALSE, &dp, ndp->ni_cnd.cn_cred, slp,
1398: nam, &rdonly, kerbflag);
1399: if (error)
1400: goto out;
1401: if (dp->v_type != VDIR) {
1402: vrele(dp);
1403: error = ENOTDIR;
1404: goto out;
1405: }
1406: VREF(dp);
1407: *retdirp = dp;
1408: ndp->ni_startdir = dp;
1409: if (rdonly)
1410: cnp->cn_flags |= (NOCROSSMOUNT | RDONLY);
1411: else
1412: cnp->cn_flags |= NOCROSSMOUNT;
1413: /*
1414: * And call lookup() to do the real work
1415: */
1416: cnp->cn_proc = p;
1417: error = lookup(ndp);
1418: if (error)
1419: goto out;
1420: /*
1421: * Check for encountering a symbolic link
1422: */
1423: if (cnp->cn_flags & ISSYMLINK) {
1424: if ((cnp->cn_flags & LOCKPARENT) && ndp->ni_pathlen == 1)
1425: vput(ndp->ni_dvp);
1426: else
1427: vrele(ndp->ni_dvp);
1428: vput(ndp->ni_vp);
1429: ndp->ni_vp = NULL;
1430: error = EINVAL;
1431: goto out;
1432: }
1433: /*
1434: * Check for saved name request
1435: */
1436: if (cnp->cn_flags & (SAVENAME | SAVESTART)) {
1437: cnp->cn_flags |= HASBUF;
1438: return (0);
1439: }
1440: out:
1441: pool_put(&namei_pool, cnp->cn_pnbuf);
1442: return (error);
1443: }
1444:
1445: /*
1446: * A fiddled version of m_adj() that ensures null fill to a long
1447: * boundary and only trims off the back end
1448: */
1449: void
1450: nfsm_adj(mp, len, nul)
1451: struct mbuf *mp;
1452: int len;
1453: int nul;
1454: {
1455: struct mbuf *m;
1456: int count, i;
1457: char *cp;
1458:
1459: /*
1460: * Trim from tail. Scan the mbuf chain,
1461: * calculating its length and finding the last mbuf.
1462: * If the adjustment only affects this mbuf, then just
1463: * adjust and return. Otherwise, rescan and truncate
1464: * after the remaining size.
1465: */
1466: count = 0;
1467: m = mp;
1468: for (;;) {
1469: count += m->m_len;
1470: if (m->m_next == (struct mbuf *)0)
1471: break;
1472: m = m->m_next;
1473: }
1474: if (m->m_len > len) {
1475: m->m_len -= len;
1476: if (nul > 0) {
1477: cp = mtod(m, caddr_t)+m->m_len-nul;
1478: for (i = 0; i < nul; i++)
1479: *cp++ = '\0';
1480: }
1481: return;
1482: }
1483: count -= len;
1484: if (count < 0)
1485: count = 0;
1486: /*
1487: * Correct length for chain is "count".
1488: * Find the mbuf with last data, adjust its length,
1489: * and toss data from remaining mbufs on chain.
1490: */
1491: for (m = mp; m; m = m->m_next) {
1492: if (m->m_len >= count) {
1493: m->m_len = count;
1494: if (nul > 0) {
1495: cp = mtod(m, caddr_t)+m->m_len-nul;
1496: for (i = 0; i < nul; i++)
1497: *cp++ = '\0';
1498: }
1499: break;
1500: }
1501: count -= m->m_len;
1502: }
1503: for (m = m->m_next;m;m = m->m_next)
1504: m->m_len = 0;
1505: }
1506:
1507: /*
1508: * Make these functions instead of macros, so that the kernel text size
1509: * doesn't get too big...
1510: */
1511: void
1512: nfsm_srvwcc(nfsd, before_ret, before_vap, after_ret, after_vap, mbp, bposp)
1513: struct nfsrv_descript *nfsd;
1514: int before_ret;
1515: struct vattr *before_vap;
1516: int after_ret;
1517: struct vattr *after_vap;
1518: struct mbuf **mbp;
1519: char **bposp;
1520: {
1521: struct mbuf *mb = *mbp, *mb2;
1522: char *bpos = *bposp;
1523: u_int32_t *tl;
1524:
1525: if (before_ret) {
1526: nfsm_build(tl, u_int32_t *, NFSX_UNSIGNED);
1527: *tl = nfs_false;
1528: } else {
1529: nfsm_build(tl, u_int32_t *, 7 * NFSX_UNSIGNED);
1530: *tl++ = nfs_true;
1531: txdr_hyper(before_vap->va_size, tl);
1532: tl += 2;
1533: txdr_nfsv3time(&(before_vap->va_mtime), tl);
1534: tl += 2;
1535: txdr_nfsv3time(&(before_vap->va_ctime), tl);
1536: }
1537: *bposp = bpos;
1538: *mbp = mb;
1539: nfsm_srvpostopattr(nfsd, after_ret, after_vap, mbp, bposp);
1540: }
1541:
1542: void
1543: nfsm_srvpostopattr(nfsd, after_ret, after_vap, mbp, bposp)
1544: struct nfsrv_descript *nfsd;
1545: int after_ret;
1546: struct vattr *after_vap;
1547: struct mbuf **mbp;
1548: char **bposp;
1549: {
1550: struct mbuf *mb = *mbp, *mb2;
1551: char *bpos = *bposp;
1552: u_int32_t *tl;
1553: struct nfs_fattr *fp;
1554:
1555: if (after_ret) {
1556: nfsm_build(tl, u_int32_t *, NFSX_UNSIGNED);
1557: *tl = nfs_false;
1558: } else {
1559: nfsm_build(tl, u_int32_t *, NFSX_UNSIGNED + NFSX_V3FATTR);
1560: *tl++ = nfs_true;
1561: fp = (struct nfs_fattr *)tl;
1562: nfsm_srvfattr(nfsd, after_vap, fp);
1563: }
1564: *mbp = mb;
1565: *bposp = bpos;
1566: }
1567:
1568: void
1569: nfsm_srvfattr(nfsd, vap, fp)
1570: struct nfsrv_descript *nfsd;
1571: struct vattr *vap;
1572: struct nfs_fattr *fp;
1573: {
1574:
1575: fp->fa_nlink = txdr_unsigned(vap->va_nlink);
1576: fp->fa_uid = txdr_unsigned(vap->va_uid);
1577: fp->fa_gid = txdr_unsigned(vap->va_gid);
1578: if (nfsd->nd_flag & ND_NFSV3) {
1579: fp->fa_type = vtonfsv3_type(vap->va_type);
1580: fp->fa_mode = vtonfsv3_mode(vap->va_mode);
1581: txdr_hyper(vap->va_size, &fp->fa3_size);
1582: txdr_hyper(vap->va_bytes, &fp->fa3_used);
1583: fp->fa3_rdev.specdata1 = txdr_unsigned(major(vap->va_rdev));
1584: fp->fa3_rdev.specdata2 = txdr_unsigned(minor(vap->va_rdev));
1585: fp->fa3_fsid.nfsuquad[0] = 0;
1586: fp->fa3_fsid.nfsuquad[1] = txdr_unsigned(vap->va_fsid);
1587: fp->fa3_fileid.nfsuquad[0] = 0;
1588: fp->fa3_fileid.nfsuquad[1] = txdr_unsigned(vap->va_fileid);
1589: txdr_nfsv3time(&vap->va_atime, &fp->fa3_atime);
1590: txdr_nfsv3time(&vap->va_mtime, &fp->fa3_mtime);
1591: txdr_nfsv3time(&vap->va_ctime, &fp->fa3_ctime);
1592: } else {
1593: fp->fa_type = vtonfsv2_type(vap->va_type);
1594: fp->fa_mode = vtonfsv2_mode(vap->va_type, vap->va_mode);
1595: fp->fa2_size = txdr_unsigned(vap->va_size);
1596: fp->fa2_blocksize = txdr_unsigned(vap->va_blocksize);
1597: if (vap->va_type == VFIFO)
1598: fp->fa2_rdev = 0xffffffff;
1599: else
1600: fp->fa2_rdev = txdr_unsigned(vap->va_rdev);
1601: fp->fa2_blocks = txdr_unsigned(vap->va_bytes / NFS_FABLKSIZE);
1602: fp->fa2_fsid = txdr_unsigned(vap->va_fsid);
1603: fp->fa2_fileid = txdr_unsigned(vap->va_fileid);
1604: txdr_nfsv2time(&vap->va_atime, &fp->fa2_atime);
1605: txdr_nfsv2time(&vap->va_mtime, &fp->fa2_mtime);
1606: txdr_nfsv2time(&vap->va_ctime, &fp->fa2_ctime);
1607: }
1608: }
1609:
1610: /*
1611: * nfsrv_fhtovp() - convert a fh to a vnode ptr (optionally locked)
1612: * - look up fsid in mount list (if not found ret error)
1613: * - get vp and export rights by calling VFS_FHTOVP() and VFS_CHECKEXP()
1614: * - if cred->cr_uid == 0 or MNT_EXPORTANON set it to credanon
1615: * - if not lockflag unlock it with VOP_UNLOCK()
1616: */
1617: int
1618: nfsrv_fhtovp(fhp, lockflag, vpp, cred, slp, nam, rdonlyp, kerbflag)
1619: fhandle_t *fhp;
1620: int lockflag;
1621: struct vnode **vpp;
1622: struct ucred *cred;
1623: struct nfssvc_sock *slp;
1624: struct mbuf *nam;
1625: int *rdonlyp;
1626: int kerbflag;
1627: {
1628: struct proc *p = curproc; /* XXX */
1629: struct mount *mp;
1630: int i;
1631: struct ucred *credanon;
1632: int error, exflags;
1633: struct sockaddr_in *saddr;
1634:
1635: *vpp = (struct vnode *)0;
1636: mp = vfs_getvfs(&fhp->fh_fsid);
1637:
1638: if (!mp)
1639: return (ESTALE);
1640: error = VFS_CHECKEXP(mp, nam, &exflags, &credanon);
1641: if (error)
1642: return (error);
1643: error = VFS_FHTOVP(mp, &fhp->fh_fid, vpp);
1644: if (error)
1645: return (error);
1646:
1647: saddr = mtod(nam, struct sockaddr_in *);
1648: if (saddr->sin_family == AF_INET &&
1649: (ntohs(saddr->sin_port) >= IPPORT_RESERVED ||
1650: (slp->ns_so->so_type == SOCK_STREAM && ntohs(saddr->sin_port) == 20))) {
1651: vput(*vpp);
1652: return (NFSERR_AUTHERR | AUTH_TOOWEAK);
1653: }
1654:
1655: /*
1656: * Check/setup credentials.
1657: */
1658: if (exflags & MNT_EXKERB) {
1659: if (!kerbflag) {
1660: vput(*vpp);
1661: return (NFSERR_AUTHERR | AUTH_TOOWEAK);
1662: }
1663: } else if (kerbflag) {
1664: vput(*vpp);
1665: return (NFSERR_AUTHERR | AUTH_TOOWEAK);
1666: } else if (cred->cr_uid == 0 || (exflags & MNT_EXPORTANON)) {
1667: cred->cr_uid = credanon->cr_uid;
1668: cred->cr_gid = credanon->cr_gid;
1669: for (i = 0; i < credanon->cr_ngroups && i < NGROUPS; i++)
1670: cred->cr_groups[i] = credanon->cr_groups[i];
1671: cred->cr_ngroups = i;
1672: }
1673: if (exflags & MNT_EXRDONLY)
1674: *rdonlyp = 1;
1675: else
1676: *rdonlyp = 0;
1677: if (!lockflag)
1678: VOP_UNLOCK(*vpp, 0, p);
1679:
1680: return (0);
1681: }
1682:
1683: /*
1684: * This function compares two net addresses by family and returns TRUE
1685: * if they are the same host.
1686: * If there is any doubt, return FALSE.
1687: * The AF_INET family is handled as a special case so that address mbufs
1688: * don't need to be saved to store "struct in_addr", which is only 4 bytes.
1689: */
1690: int
1691: netaddr_match(family, haddr, nam)
1692: int family;
1693: union nethostaddr *haddr;
1694: struct mbuf *nam;
1695: {
1696: struct sockaddr_in *inetaddr;
1697:
1698: switch (family) {
1699: case AF_INET:
1700: inetaddr = mtod(nam, struct sockaddr_in *);
1701: if (inetaddr->sin_family == AF_INET &&
1702: inetaddr->sin_addr.s_addr == haddr->had_inetaddr)
1703: return (1);
1704: break;
1705: default:
1706: break;
1707: };
1708: return (0);
1709: }
1710:
1711: /*
1712: * The write verifier has changed (probably due to a server reboot), so all
1713: * B_NEEDCOMMIT blocks will have to be written again. Since they are on the
1714: * dirty block list as B_DELWRI, all this takes is clearing the B_NEEDCOMMIT
1715: * flag. Once done the new write verifier can be set for the mount point.
1716: */
1717: void
1718: nfs_clearcommit(mp)
1719: struct mount *mp;
1720: {
1721: struct vnode *vp, *nvp;
1722: struct buf *bp, *nbp;
1723: int s;
1724:
1725: s = splbio();
1726: loop:
1727: for (vp = LIST_FIRST(&mp->mnt_vnodelist); vp != NULL; vp = nvp) {
1728: if (vp->v_mount != mp) /* Paranoia */
1729: goto loop;
1730: nvp = LIST_NEXT(vp, v_mntvnodes);
1731: for (bp = LIST_FIRST(&vp->v_dirtyblkhd); bp != NULL; bp = nbp) {
1732: nbp = LIST_NEXT(bp, b_vnbufs);
1733: if ((bp->b_flags & (B_BUSY | B_DELWRI | B_NEEDCOMMIT))
1734: == (B_DELWRI | B_NEEDCOMMIT))
1735: bp->b_flags &= ~B_NEEDCOMMIT;
1736: }
1737: }
1738: splx(s);
1739: }
1740:
1741: void
1742: nfs_merge_commit_ranges(vp)
1743: struct vnode *vp;
1744: {
1745: struct nfsnode *np = VTONFS(vp);
1746:
1747: if (!(np->n_commitflags & NFS_COMMIT_PUSHED_VALID)) {
1748: np->n_pushedlo = np->n_pushlo;
1749: np->n_pushedhi = np->n_pushhi;
1750: np->n_commitflags |= NFS_COMMIT_PUSHED_VALID;
1751: } else {
1752: if (np->n_pushlo < np->n_pushedlo)
1753: np->n_pushedlo = np->n_pushlo;
1754: if (np->n_pushhi > np->n_pushedhi)
1755: np->n_pushedhi = np->n_pushhi;
1756: }
1757:
1758: np->n_pushlo = np->n_pushhi = 0;
1759: np->n_commitflags &= ~NFS_COMMIT_PUSH_VALID;
1760: }
1761:
1762: int
1763: nfs_in_committed_range(vp, bp)
1764: struct vnode *vp;
1765: struct buf *bp;
1766: {
1767: struct nfsnode *np = VTONFS(vp);
1768: off_t lo, hi;
1769:
1770: if (!(np->n_commitflags & NFS_COMMIT_PUSHED_VALID))
1771: return 0;
1772: lo = (off_t)bp->b_blkno * DEV_BSIZE;
1773: hi = lo + bp->b_dirtyend;
1774:
1775: return (lo >= np->n_pushedlo && hi <= np->n_pushedhi);
1776: }
1777:
1778: int
1779: nfs_in_tobecommitted_range(vp, bp)
1780: struct vnode *vp;
1781: struct buf *bp;
1782: {
1783: struct nfsnode *np = VTONFS(vp);
1784: off_t lo, hi;
1785:
1786: if (!(np->n_commitflags & NFS_COMMIT_PUSH_VALID))
1787: return 0;
1788: lo = (off_t)bp->b_blkno * DEV_BSIZE;
1789: hi = lo + bp->b_dirtyend;
1790:
1791: return (lo >= np->n_pushlo && hi <= np->n_pushhi);
1792: }
1793:
1794: void
1795: nfs_add_committed_range(vp, bp)
1796: struct vnode *vp;
1797: struct buf *bp;
1798: {
1799: struct nfsnode *np = VTONFS(vp);
1800: off_t lo, hi;
1801:
1802: lo = (off_t)bp->b_blkno * DEV_BSIZE;
1803: hi = lo + bp->b_dirtyend;
1804:
1805: if (!(np->n_commitflags & NFS_COMMIT_PUSHED_VALID)) {
1806: np->n_pushedlo = lo;
1807: np->n_pushedhi = hi;
1808: np->n_commitflags |= NFS_COMMIT_PUSHED_VALID;
1809: } else {
1810: if (hi > np->n_pushedhi)
1811: np->n_pushedhi = hi;
1812: if (lo < np->n_pushedlo)
1813: np->n_pushedlo = lo;
1814: }
1815: }
1816:
1817: void
1818: nfs_del_committed_range(vp, bp)
1819: struct vnode *vp;
1820: struct buf *bp;
1821: {
1822: struct nfsnode *np = VTONFS(vp);
1823: off_t lo, hi;
1824:
1825: if (!(np->n_commitflags & NFS_COMMIT_PUSHED_VALID))
1826: return;
1827:
1828: lo = (off_t)bp->b_blkno * DEV_BSIZE;
1829: hi = lo + bp->b_dirtyend;
1830:
1831: if (lo > np->n_pushedhi || hi < np->n_pushedlo)
1832: return;
1833: if (lo <= np->n_pushedlo)
1834: np->n_pushedlo = hi;
1835: else if (hi >= np->n_pushedhi)
1836: np->n_pushedhi = lo;
1837: else {
1838: /*
1839: * XXX There's only one range. If the deleted range
1840: * is in the middle, pick the largest of the
1841: * contiguous ranges that it leaves.
1842: */
1843: if ((np->n_pushedlo - lo) > (hi - np->n_pushedhi))
1844: np->n_pushedhi = lo;
1845: else
1846: np->n_pushedlo = hi;
1847: }
1848: }
1849:
1850: void
1851: nfs_add_tobecommitted_range(vp, bp)
1852: struct vnode *vp;
1853: struct buf *bp;
1854: {
1855: struct nfsnode *np = VTONFS(vp);
1856: off_t lo, hi;
1857:
1858: lo = (off_t)bp->b_blkno * DEV_BSIZE;
1859: hi = lo + bp->b_dirtyend;
1860:
1861: if (!(np->n_commitflags & NFS_COMMIT_PUSH_VALID)) {
1862: np->n_pushlo = lo;
1863: np->n_pushhi = hi;
1864: np->n_commitflags |= NFS_COMMIT_PUSH_VALID;
1865: } else {
1866: if (lo < np->n_pushlo)
1867: np->n_pushlo = lo;
1868: if (hi > np->n_pushhi)
1869: np->n_pushhi = hi;
1870: }
1871: }
1872:
1873: void
1874: nfs_del_tobecommitted_range(vp, bp)
1875: struct vnode *vp;
1876: struct buf *bp;
1877: {
1878: struct nfsnode *np = VTONFS(vp);
1879: off_t lo, hi;
1880:
1881: if (!(np->n_commitflags & NFS_COMMIT_PUSH_VALID))
1882: return;
1883:
1884: lo = (off_t)bp->b_blkno * DEV_BSIZE;
1885: hi = lo + bp->b_dirtyend;
1886:
1887: if (lo > np->n_pushhi || hi < np->n_pushlo)
1888: return;
1889:
1890: if (lo <= np->n_pushlo)
1891: np->n_pushlo = hi;
1892: else if (hi >= np->n_pushhi)
1893: np->n_pushhi = lo;
1894: else {
1895: /*
1896: * XXX There's only one range. If the deleted range
1897: * is in the middle, pick the largest of the
1898: * contiguous ranges that it leaves.
1899: */
1900: if ((np->n_pushlo - lo) > (hi - np->n_pushhi))
1901: np->n_pushhi = lo;
1902: else
1903: np->n_pushlo = hi;
1904: }
1905: }
1906:
1907: /*
1908: * Map errnos to NFS error numbers. For Version 3 also filter out error
1909: * numbers not specified for the associated procedure.
1910: */
1911: int
1912: nfsrv_errmap(nd, err)
1913: struct nfsrv_descript *nd;
1914: int err;
1915: {
1916: short *defaulterrp, *errp;
1917:
1918: if (nd->nd_flag & ND_NFSV3) {
1919: if (nd->nd_procnum <= NFSPROC_COMMIT) {
1920: errp = defaulterrp = nfsrv_v3errmap[nd->nd_procnum];
1921: while (*++errp) {
1922: if (*errp == err)
1923: return (err);
1924: else if (*errp > err)
1925: break;
1926: }
1927: return ((int)*defaulterrp);
1928: } else
1929: return (err & 0xffff);
1930: }
1931: if (err <= ELAST)
1932: return ((int)nfsrv_v2errmap[err - 1]);
1933: return (NFSERR_IO);
1934: }
1935:
1936: /*
1937: * Sort the group list in increasing numerical order.
1938: * (Insertion sort by Chris Torek, who was grossed out by the bubble sort
1939: * that used to be here.)
1940: */
1941: void
1942: nfsrvw_sort(list, num)
1943: gid_t *list;
1944: int num;
1945: {
1946: int i, j;
1947: gid_t v;
1948:
1949: /* Insertion sort. */
1950: for (i = 1; i < num; i++) {
1951: v = list[i];
1952: /* find correct slot for value v, moving others up */
1953: for (j = i; --j >= 0 && v < list[j];)
1954: list[j + 1] = list[j];
1955: list[j + 1] = v;
1956: }
1957: }
1958:
1959: /*
1960: * copy credentials making sure that the result can be compared with bcmp().
1961: */
1962: void
1963: nfsrv_setcred(incred, outcred)
1964: struct ucred *incred, *outcred;
1965: {
1966: int i;
1967:
1968: bzero((caddr_t)outcred, sizeof (struct ucred));
1969: outcred->cr_ref = 1;
1970: outcred->cr_uid = incred->cr_uid;
1971: outcred->cr_gid = incred->cr_gid;
1972: outcred->cr_ngroups = incred->cr_ngroups;
1973: for (i = 0; i < incred->cr_ngroups; i++)
1974: outcred->cr_groups[i] = incred->cr_groups[i];
1975: nfsrvw_sort(outcred->cr_groups, outcred->cr_ngroups);
1976: }