![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to nfs_socket.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / nfs|
Return to nfs_socket.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / nfs |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
26: /*
27: * Copyright (c) 1989, 1991, 1993, 1995
28: * The Regents of the University of California. All rights reserved.
29: *
30: * This code is derived from software contributed to Berkeley by
31: * Rick Macklem at The University of Guelph.
32: *
33: * Redistribution and use in source and binary forms, with or without
34: * modification, are permitted provided that the following conditions
35: * are met:
36: * 1. Redistributions of source code must retain the above copyright
37: * notice, this list of conditions and the following disclaimer.
38: * 2. Redistributions in binary form must reproduce the above copyright
39: * notice, this list of conditions and the following disclaimer in the
40: * documentation and/or other materials provided with the distribution.
41: * 3. All advertising materials mentioning features or use of this software
42: * must display the following acknowledgement:
43: * This product includes software developed by the University of
44: * California, Berkeley and its contributors.
45: * 4. Neither the name of the University nor the names of its contributors
46: * may be used to endorse or promote products derived from this software
47: * without specific prior written permission.
48: *
49: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
50: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
51: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
52: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
53: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
54: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
55: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
56: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
57: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
58: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
59: * SUCH DAMAGE.
60: *
61: * @(#)nfs_socket.c 8.5 (Berkeley) 3/30/95
62: * FreeBSD-Id: nfs_socket.c,v 1.30 1997/10/28 15:59:07 bde Exp $
63: */
64:
65: /*
66: * Socket operations for use by nfs
67: */
68:
69: #include <sys/param.h>
70: #include <sys/systm.h>
71: #include <sys/proc.h>
72: #include <sys/mount.h>
73: #include <sys/kernel.h>
74: #include <sys/mbuf.h>
75: #include <sys/malloc.h>
76: #include <sys/vnode.h>
77: #include <sys/domain.h>
78: #include <sys/protosw.h>
79: #include <sys/socket.h>
80: #include <sys/socketvar.h>
81: #include <sys/syslog.h>
82: #include <sys/tprintf.h>
83: #include <machine/spl.h>
84:
85: #include <netinet/in.h>
86: #include <netinet/tcp.h>
87:
88: #include <nfs/rpcv2.h>
89: #include <nfs/nfsproto.h>
90: #include <nfs/nfs.h>
91: #include <nfs/xdr_subs.h>
92: #include <nfs/nfsm_subs.h>
93: #include <nfs/nfsmount.h>
94: #include <nfs/nfsnode.h>
95: #include <nfs/nfsrtt.h>
96: #include <nfs/nqnfs.h>
97:
98: #define TRUE 1
99: #define FALSE 0
100:
101: /*
102: * Estimate rto for an nfs rpc sent via. an unreliable datagram.
103: * Use the mean and mean deviation of rtt for the appropriate type of rpc
104: * for the frequent rpcs and a default for the others.
105: * The justification for doing "other" this way is that these rpcs
106: * happen so infrequently that timer est. would probably be stale.
107: * Also, since many of these rpcs are
108: * non-idempotent, a conservative timeout is desired.
109: * getattr, lookup - A+2D
110: * read, write - A+4D
111: * other - nm_timeo
112: */
113: #define NFS_RTO(n, t) \
114: ((t) == 0 ? (n)->nm_timeo : \
115: ((t) < 3 ? \
116: (((((n)->nm_srtt[t-1] + 3) >> 2) + (n)->nm_sdrtt[t-1] + 1) >> 1) : \
117: ((((n)->nm_srtt[t-1] + 7) >> 3) + (n)->nm_sdrtt[t-1] + 1)))
118: #define NFS_SRTT(r) (r)->r_nmp->nm_srtt[proct[(r)->r_procnum] - 1]
119: #define NFS_SDRTT(r) (r)->r_nmp->nm_sdrtt[proct[(r)->r_procnum] - 1]
120: /*
121: * External data, mostly RPC constants in XDR form
122: */
123: extern u_long rpc_reply, rpc_msgdenied, rpc_mismatch, rpc_vers, rpc_auth_unix,
124: rpc_msgaccepted, rpc_call, rpc_autherr,
125: rpc_auth_kerb;
126: extern u_long nfs_prog, nqnfs_prog;
127: extern time_t nqnfsstarttime;
128: extern struct nfsstats nfsstats;
129: extern int nfsv3_procid[NFS_NPROCS];
130: extern int nfs_ticks;
131:
132: /*
133: * Defines which timer to use for the procnum.
134: * 0 - default
135: * 1 - getattr
136: * 2 - lookup
137: * 3 - read
138: * 4 - write
139: */
140: static int proct[NFS_NPROCS] = {
141: 0, 1, 0, 2, 1, 3, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 0, 0, 0, 0, 0,
142: 0, 0, 0,
143: };
144:
145: /*
146: * There is a congestion window for outstanding rpcs maintained per mount
147: * point. The cwnd size is adjusted in roughly the way that:
148: * Van Jacobson, Congestion avoidance and Control, In "Proceedings of
149: * SIGCOMM '88". ACM, August 1988.
150: * describes for TCP. The cwnd size is chopped in half on a retransmit timeout
151: * and incremented by 1/cwnd when each rpc reply is received and a full cwnd
152: * of rpcs is in progress.
153: * (The sent count and cwnd are scaled for integer arith.)
154: * Variants of "slow start" were tried and were found to be too much of a
155: * performance hit (ave. rtt 3 times larger),
156: * I suspect due to the large rtt that nfs rpcs have.
157: */
158: #define NFS_CWNDSCALE 256
159: #define NFS_MAXCWND (NFS_CWNDSCALE * 32)
160: static int nfs_backoff[8] = { 2, 4, 8, 16, 32, 64, 128, 256, };
161: int nfsrtton = 0;
162: struct nfsrtt nfsrtt;
163:
164: static int nfs_msg __P((struct proc *,char *,char *));
165: static int nfs_rcvlock __P((struct nfsreq *));
166: static void nfs_rcvunlock __P((int *flagp));
167: static int nfs_receive __P((struct nfsreq *rep, struct mbuf **aname,
168: struct mbuf **mp));
169: static int nfs_reconnect __P((struct nfsreq *rep));
170: #ifndef NFS_NOSERVER
171: static int nfsrv_getstream __P((struct nfssvc_sock *,int));
172:
173: int (*nfsrv3_procs[NFS_NPROCS]) __P((struct nfsrv_descript *nd,
174: struct nfssvc_sock *slp,
175: struct proc *procp,
176: struct mbuf **mreqp)) = {
177: nfsrv_null,
178: nfsrv_getattr,
179: nfsrv_setattr,
180: nfsrv_lookup,
181: nfsrv3_access,
182: nfsrv_readlink,
183: nfsrv_read,
184: nfsrv_write,
185: nfsrv_create,
186: nfsrv_mkdir,
187: nfsrv_symlink,
188: nfsrv_mknod,
189: nfsrv_remove,
190: nfsrv_rmdir,
191: nfsrv_rename,
192: nfsrv_link,
193: nfsrv_readdir,
194: nfsrv_readdirplus,
195: nfsrv_statfs,
196: nfsrv_fsinfo,
197: nfsrv_pathconf,
198: nfsrv_commit,
199: nqnfsrv_getlease,
200: nqnfsrv_vacated,
201: nfsrv_noop,
202: nfsrv_noop
203: };
204: #endif /* NFS_NOSERVER */
205:
206: /*
207: * Initialize sockets and congestion for a new NFS connection.
208: * We do not free the sockaddr if error.
209: */
210: int
211: nfs_connect(nmp, rep)
212: register struct nfsmount *nmp;
213: struct nfsreq *rep;
214: {
215: register struct socket *so;
216: int s, error, rcvreserve, sndreserve;
217: struct sockaddr *saddr;
218: struct sockaddr_in *sin;
219: struct mbuf *m;
220: u_short tport;
221:
222: nmp->nm_so = (struct socket *)0;
223: saddr = mtod(nmp->nm_nam, struct sockaddr *);
224: error = socreate(saddr->sa_family, &nmp->nm_so, nmp->nm_sotype,
225: nmp->nm_soproto);
226: if (error)
227: goto bad;
228: so = nmp->nm_so;
229: nmp->nm_soflags = so->so_proto->pr_flags;
230:
231: /*
232: * Some servers require that the client port be a reserved port number.
233: */
234: if (saddr->sa_family == AF_INET && (nmp->nm_flag & NFSMNT_RESVPORT)) {
235: MGET(m, M_WAIT, MT_SONAME);
236: sin = mtod(m, struct sockaddr_in *);
237: sin->sin_len = m->m_len = sizeof (struct sockaddr_in);
238: sin->sin_family = AF_INET;
239: sin->sin_addr.s_addr = INADDR_ANY;
240: tport = IPPORT_RESERVED - 1;
241: sin->sin_port = htons(tport);
242: while ((error = sobind(so, m)) == EADDRINUSE &&
243: --tport > IPPORT_RESERVED / 2)
244: sin->sin_port = htons(tport);
245: m_freem(m);
246: if (error)
247: goto bad;
248: }
249:
250: /*
251: * Protocols that do not require connections may be optionally left
252: * unconnected for servers that reply from a port other than NFS_PORT.
253: */
254: if (nmp->nm_flag & NFSMNT_NOCONN) {
255: if (nmp->nm_soflags & PR_CONNREQUIRED) {
256: error = ENOTCONN;
257: goto bad;
258: }
259: } else {
260: error = soconnect(so, nmp->nm_nam);
261: if (error)
262: goto bad;
263:
264: /*
265: * Wait for the connection to complete. Cribbed from the
266: * connect system call but with the wait timing out so
267: * that interruptible mounts don't hang here for a long time.
268: */
269: s = splnet();
270: while ((so->so_state & SS_ISCONNECTING) && so->so_error == 0) {
271: (void) tsleep((caddr_t)&so->so_timeo, PSOCK,
272: "nfscon", 2 * hz);
273: if ((so->so_state & SS_ISCONNECTING) &&
274: so->so_error == 0 && rep &&
275: (error = nfs_sigintr(nmp, rep, rep->r_procp))) {
276: so->so_state &= ~SS_ISCONNECTING;
277: splx(s);
278: goto bad;
279: }
280: }
281: if (so->so_error) {
282: error = so->so_error;
283: so->so_error = 0;
284: splx(s);
285: goto bad;
286: }
287: splx(s);
288: }
289: if (nmp->nm_flag & (NFSMNT_SOFT | NFSMNT_INT)) {
290: so->so_rcv.sb_timeo = (5 * hz);
291: so->so_snd.sb_timeo = (5 * hz);
292: } else {
293: so->so_rcv.sb_timeo = 0;
294: so->so_snd.sb_timeo = 0;
295: }
296: if (nmp->nm_sotype == SOCK_DGRAM) {
297: sndreserve = (nmp->nm_wsize + NFS_MAXPKTHDR) * 2;
298: rcvreserve = (nmp->nm_rsize + NFS_MAXPKTHDR) * 2;
299: } else if (nmp->nm_sotype == SOCK_SEQPACKET) {
300: sndreserve = (nmp->nm_wsize + NFS_MAXPKTHDR) * 2;
301: rcvreserve = (nmp->nm_rsize + NFS_MAXPKTHDR) * 2;
302: } else {
303: if (nmp->nm_sotype != SOCK_STREAM)
304: panic("nfscon sotype");
305: if (so->so_proto->pr_flags & PR_CONNREQUIRED) {
306: MGET(m, M_WAIT, MT_SOOPTS);
307: *mtod(m, int *) = 1;
308: m->m_len = sizeof(int);
309: sosetopt(so, SOL_SOCKET, SO_KEEPALIVE, m);
310: }
311: if (so->so_proto->pr_protocol == IPPROTO_TCP) {
312: MGET(m, M_WAIT, MT_SOOPTS);
313: *mtod(m, int *) = 1;
314: m->m_len = sizeof(int);
315: sosetopt(so, IPPROTO_TCP, TCP_NODELAY, m);
316: }
317: sndreserve = (nmp->nm_wsize + NFS_MAXPKTHDR + sizeof (u_long))
318: * 2;
319: rcvreserve = (nmp->nm_rsize + NFS_MAXPKTHDR + sizeof (u_long))
320: * 2;
321: }
322: error = soreserve(so, sndreserve, rcvreserve);
323: if (error)
324: goto bad;
325: so->so_rcv.sb_flags |= SB_NOINTR;
326: so->so_snd.sb_flags |= SB_NOINTR;
327:
328: /* Initialize other non-zero congestion variables */
329: nmp->nm_srtt[0] = nmp->nm_srtt[1] = nmp->nm_srtt[2] = nmp->nm_srtt[3] =
330: nmp->nm_srtt[4] = (NFS_TIMEO << 3);
331: nmp->nm_sdrtt[0] = nmp->nm_sdrtt[1] = nmp->nm_sdrtt[2] =
332: nmp->nm_sdrtt[3] = nmp->nm_sdrtt[4] = 0;
333: nmp->nm_cwnd = NFS_MAXCWND / 2; /* Initial send window */
334: nmp->nm_sent = 0;
335: nmp->nm_timeouts = 0;
336: return (0);
337:
338: bad:
339: nfs_disconnect(nmp);
340: return (error);
341: }
342:
343: /*
344: * Reconnect routine:
345: * Called when a connection is broken on a reliable protocol.
346: * - clean up the old socket
347: * - nfs_connect() again
348: * - set R_MUSTRESEND for all outstanding requests on mount point
349: * If this fails the mount point is DEAD!
350: * nb: Must be called with the nfs_sndlock() set on the mount point.
351: */
352: static int
353: nfs_reconnect(rep)
354: register struct nfsreq *rep;
355: {
356: register struct nfsreq *rp;
357: register struct nfsmount *nmp = rep->r_nmp;
358: int error;
359:
360: nfs_disconnect(nmp);
361: while ((error = nfs_connect(nmp, rep))) {
362: if (error == EINTR || error == ERESTART)
363: return (EINTR);
364: (void) tsleep((caddr_t)&lbolt, PSOCK, "nfscon", 0);
365: }
366:
367: /*
368: * Loop through outstanding request list and fix up all requests
369: * on old socket.
370: */
371: for (rp = nfs_reqq.tqh_first; rp != 0; rp = rp->r_chain.tqe_next) {
372: if (rp->r_nmp == nmp)
373: rp->r_flags |= R_MUSTRESEND;
374: }
375: return (0);
376: }
377:
378: /*
379: * NFS disconnect. Clean up and unlink.
380: */
381: void
382: nfs_disconnect(nmp)
383: register struct nfsmount *nmp;
384: {
385: register struct socket *so;
386:
387: if (nmp->nm_so) {
388: so = nmp->nm_so;
389: nmp->nm_so = (struct socket *)0;
390: soshutdown(so, 2);
391: soclose(so);
392: }
393: }
394:
395: /*
396: * This is the nfs send routine. For connection based socket types, it
397: * must be called with an nfs_sndlock() on the socket.
398: * "rep == NULL" indicates that it has been called from a server.
399: * For the client side:
400: * - return EINTR if the RPC is terminated, 0 otherwise
401: * - set R_MUSTRESEND if the send fails for any reason
402: * - do any cleanup required by recoverable socket errors (???)
403: * For the server side:
404: * - return EINTR or ERESTART if interrupted by a signal
405: * - return EPIPE if a connection is lost for connection based sockets (TCP...)
406: * - do any cleanup required by recoverable socket errors (???)
407: */
408: int
409: nfs_send(so, nam, top, rep)
410: register struct socket *so;
411: struct mbuf *nam;
412: register struct mbuf *top;
413: struct nfsreq *rep;
414: {
415: struct mbuf *sendnam;
416: int error, soflags, flags;
417:
418: if (rep) {
419: if (rep->r_flags & R_SOFTTERM) {
420: m_freem(top);
421: return (EINTR);
422: }
423: if ((so = rep->r_nmp->nm_so) == NULL) {
424: rep->r_flags |= R_MUSTRESEND;
425: m_freem(top);
426: return (0);
427: }
428: rep->r_flags &= ~R_MUSTRESEND;
429: soflags = rep->r_nmp->nm_soflags;
430: } else
431: soflags = so->so_proto->pr_flags;
432: if ((soflags & PR_CONNREQUIRED) || (so->so_state & SS_ISCONNECTED))
433: sendnam = (struct mbuf *)0;
434: else
435: sendnam = nam;
436: if (so->so_type == SOCK_SEQPACKET)
437: flags = MSG_EOR;
438: else
439: flags = 0;
440:
441: error = sosend(so, sendnam, (struct uio *)0, top,
442: (struct mbuf *)0, flags);
443: if (error) {
444: if (rep) {
445: log(LOG_INFO, "nfs send error %d for server %s\n",
446: error,
447: rep->r_nmp->nm_mountp->mnt_stat.f_mntfromname);
448: /*
449: * Deal with errors for the client side.
450: */
451: if (rep->r_flags & R_SOFTTERM)
452: error = EINTR;
453: else
454: rep->r_flags |= R_MUSTRESEND;
455: } else
456: log(LOG_INFO, "nfsd send error %d\n", error);
457:
458: /*
459: * Handle any recoverable (soft) socket errors here. (???)
460: */
461: if (error != EINTR && error != ERESTART &&
462: error != EWOULDBLOCK && error != EPIPE)
463: error = 0;
464: }
465: return (error);
466: }
467:
468: /*
469: * Receive a Sun RPC Request/Reply. For SOCK_DGRAM, the work is all
470: * done by soreceive(), but for SOCK_STREAM we must deal with the Record
471: * Mark and consolidate the data into a new mbuf list.
472: * nb: Sometimes TCP passes the data up to soreceive() in long lists of
473: * small mbufs.
474: * For SOCK_STREAM we must be very careful to read an entire record once
475: * we have read any of it, even if the system call has been interrupted.
476: */
477: static int
478: nfs_receive(rep, aname, mp)
479: register struct nfsreq *rep;
480: struct mbuf **aname;
481: struct mbuf **mp;
482: {
483: register struct socket *so;
484: struct uio auio;
485: struct iovec aio;
486: register struct mbuf *m;
487: struct mbuf *control;
488: u_long len;
489: struct mbuf **getnam;
490: int error, sotype, rcvflg;
491: struct proc *p = current_proc(); /* XXX */
492:
493: /*
494: * Set up arguments for soreceive()
495: */
496: *mp = (struct mbuf *)0;
497: *aname = (struct mbuf *)0;
498: sotype = rep->r_nmp->nm_sotype;
499:
500: /*
501: * For reliable protocols, lock against other senders/receivers
502: * in case a reconnect is necessary.
503: * For SOCK_STREAM, first get the Record Mark to find out how much
504: * more there is to get.
505: * We must lock the socket against other receivers
506: * until we have an entire rpc request/reply.
507: */
508: if (sotype != SOCK_DGRAM) {
509: error = nfs_sndlock(&rep->r_nmp->nm_flag, rep);
510: if (error)
511: return (error);
512: tryagain:
513: /*
514: * Check for fatal errors and resending request.
515: */
516: /*
517: * Ugh: If a reconnect attempt just happened, nm_so
518: * would have changed. NULL indicates a failed
519: * attempt that has essentially shut down this
520: * mount point.
521: */
522: if (rep->r_mrep || (rep->r_flags & R_SOFTTERM)) {
523: nfs_sndunlock(&rep->r_nmp->nm_flag);
524: return (EINTR);
525: }
526: so = rep->r_nmp->nm_so;
527: if (!so) {
528: error = nfs_reconnect(rep);
529: if (error) {
530: nfs_sndunlock(&rep->r_nmp->nm_flag);
531: return (error);
532: }
533: goto tryagain;
534: }
535: while (rep->r_flags & R_MUSTRESEND) {
536: m = m_copym(rep->r_mreq, 0, M_COPYALL, M_WAIT);
537: nfsstats.rpcretries++;
538: #if DIAGNOSTIC
539: kprintf("nfs_receive %s flg=0x%x\n", rep->r_nmp->nm_mountp->mnt_stat.f_mntfromname, rep->r_nmp->nm_flag);
540: #endif
541: error = nfs_send(so, rep->r_nmp->nm_nam, m, rep);
542: if (error) {
543: if (error == EINTR || error == ERESTART ||
544: (error = nfs_reconnect(rep))) {
545: nfs_sndunlock(&rep->r_nmp->nm_flag);
546: return (error);
547: }
548: goto tryagain;
549: }
550: }
551: nfs_sndunlock(&rep->r_nmp->nm_flag);
552: if (sotype == SOCK_STREAM) {
553: aio.iov_base = (caddr_t) &len;
554: aio.iov_len = sizeof(u_long);
555: auio.uio_iov = &aio;
556: auio.uio_iovcnt = 1;
557: auio.uio_segflg = UIO_SYSSPACE;
558: auio.uio_rw = UIO_READ;
559: auio.uio_offset = 0;
560: auio.uio_resid = sizeof(u_long);
561: auio.uio_procp = p;
562: do {
563: rcvflg = MSG_WAITALL;
564: error = soreceive(so, (struct mbuf **)0, &auio,
565: (struct mbuf **)0, (struct mbuf **)0, &rcvflg);
566: if (!rep->r_nmp) /* if unmounted then bailout */
567: goto shutout;
568: if (error == EWOULDBLOCK && rep) {
569: if (rep->r_flags & R_SOFTTERM)
570: return (EINTR);
571: }
572: } while (error == EWOULDBLOCK);
573: if (!error && auio.uio_resid > 0) {
574: log(LOG_INFO,
575: "short receive (%d/%d) from nfs server %s\n",
576: sizeof(u_long) - auio.uio_resid,
577: sizeof(u_long),
578: rep->r_nmp->nm_mountp->mnt_stat.f_mntfromname);
579: error = EPIPE;
580: }
581: if (error)
582: goto errout;
583: len = ntohl(len) & ~0x80000000;
584: /*
585: * This is SERIOUS! We are out of sync with the sender
586: * and forcing a disconnect/reconnect is all I can do.
587: */
588: if (len > NFS_MAXPACKET) {
589: log(LOG_ERR, "%s (%d) from nfs server %s\n",
590: "impossible packet length",
591: len,
592: rep->r_nmp->nm_mountp->mnt_stat.f_mntfromname);
593: error = EFBIG;
594: goto errout;
595: }
596: auio.uio_resid = len;
597: do {
598: rcvflg = MSG_WAITALL;
599: error = soreceive(so, (struct mbuf **)0,
600: &auio, mp, (struct mbuf **)0, &rcvflg);
601: if (!rep->r_nmp) /* if unmounted then bailout */
602: goto shutout;
603: } while (error == EWOULDBLOCK || error == EINTR ||
604: error == ERESTART);
605: if (!error && auio.uio_resid > 0) {
606: log(LOG_INFO,
607: "short receive (%d/%d) from nfs server %s\n",
608: len - auio.uio_resid, len,
609: rep->r_nmp->nm_mountp->mnt_stat.f_mntfromname);
610: error = EPIPE;
611: }
612: } else {
613: /*
614: * NB: Since uio_resid is big, MSG_WAITALL is ignored
615: * and soreceive() will return when it has either a
616: * control msg or a data msg.
617: * We have no use for control msg., but must grab them
618: * and then throw them away so we know what is going
619: * on.
620: */
621: auio.uio_resid = len = 100000000; /* Anything Big */
622: auio.uio_procp = p;
623: do {
624: rcvflg = 0;
625: error = soreceive(so, (struct mbuf **)0,
626: &auio, mp, &control, &rcvflg);
627: if (!rep->r_nmp) /* if unmounted then bailout */
628: goto shutout;
629: if (control)
630: m_freem(control);
631: if (error == EWOULDBLOCK && rep) {
632: if (rep->r_flags & R_SOFTTERM)
633: return (EINTR);
634: }
635: } while (error == EWOULDBLOCK ||
636: (!error && *mp == NULL && control));
637: if ((rcvflg & MSG_EOR) == 0)
638: printf("Egad!!\n");
639: if (!error && *mp == NULL)
640: error = EPIPE;
641: len -= auio.uio_resid;
642: }
643: errout:
644: if (error && error != EINTR && error != ERESTART) {
645: m_freem(*mp);
646: *mp = (struct mbuf *)0;
647: if (error != EPIPE)
648: log(LOG_INFO,
649: "receive error %d from nfs server %s\n",
650: error,
651: rep->r_nmp->nm_mountp->mnt_stat.f_mntfromname);
652: error = nfs_sndlock(&rep->r_nmp->nm_flag, rep);
653: if (!error)
654: error = nfs_reconnect(rep);
655: if (!error)
656: goto tryagain;
657: }
658: } else {
659: if ((so = rep->r_nmp->nm_so) == NULL)
660: return (EACCES);
661: if (so->so_state & SS_ISCONNECTED)
662: getnam = (struct mbuf **)0;
663: else
664: getnam = aname;
665: auio.uio_resid = len = 1000000;
666: auio.uio_procp = p;
667: do {
668: rcvflg = 0;
669: error = soreceive(so, getnam, &auio, mp,
670: (struct mbuf **)0, &rcvflg);
671: if (!rep->r_nmp) /* if unmounted then bailout */
672: goto shutout;
673: if (error == EWOULDBLOCK &&
674: (rep->r_flags & R_SOFTTERM))
675: return (EINTR);
676: } while (error == EWOULDBLOCK);
677: len -= auio.uio_resid;
678: }
679: shutout:
680: if (error) {
681: m_freem(*mp);
682: *mp = (struct mbuf *)0;
683: }
684: return (error);
685: }
686:
687: /*
688: * Implement receipt of reply on a socket.
689: * We must search through the list of received datagrams matching them
690: * with outstanding requests using the xid, until ours is found.
691: */
692: /* ARGSUSED */
693: int
694: nfs_reply(myrep)
695: struct nfsreq *myrep;
696: {
697: register struct nfsreq *rep;
698: register struct nfsmount *nmp = myrep->r_nmp;
699: register long t1;
700: struct mbuf *mrep, *md;
701: struct mbuf *nam;
702: u_long rxid, *tl;
703: caddr_t dpos, cp2;
704: int error;
705:
706: /*
707: * Loop around until we get our own reply
708: */
709: for (;;) {
710: /*
711: * Lock against other receivers so that I don't get stuck in
712: * sbwait() after someone else has received my reply for me.
713: * Also necessary for connection based protocols to avoid
714: * race conditions during a reconnect.
715: * If nfs_rcvlock() returns EALREADY, that means that
716: * the reply has already been recieved by another
717: * process and we can return immediately. In this
718: * case, the lock is not taken to avoid races with
719: * other processes.
720: */
721: error = nfs_rcvlock(myrep);
722: if (error == EALREADY)
723: return (0);
724: if (error)
725: return (error);
726: /*
727: * Get the next Rpc reply off the socket
728: */
729: error = nfs_receive(myrep, &nam, &mrep);
730: /*
731: * Bailout asap if nfsmount struct gone (unmounted)
732: */
733: if (!myrep->r_nmp)
734: return(ECONNABORTED);
735: nfs_rcvunlock(&nmp->nm_flag);
736: if (error) {
737:
738: /*
739: * Ignore routing errors on connectionless protocols??
740: */
741: if (NFSIGNORE_SOERROR(nmp->nm_soflags, error)) {
742: nmp->nm_so->so_error = 0;
743: if (myrep->r_flags & R_GETONEREP)
744: return (0);
745: continue;
746: }
747: return (error);
748: }
749: if (nam)
750: m_freem(nam);
751:
752: /*
753: * Get the xid and check that it is an rpc reply
754: */
755: md = mrep;
756: dpos = mtod(md, caddr_t);
757: nfsm_dissect(tl, u_long *, 2*NFSX_UNSIGNED);
758: rxid = *tl++;
759: if (*tl != rpc_reply) {
760: #ifndef NFS_NOSERVER
761: if (nmp->nm_flag & NFSMNT_NQNFS) {
762: if (nqnfs_callback(nmp, mrep, md, dpos))
763: nfsstats.rpcinvalid++;
764: } else {
765: nfsstats.rpcinvalid++;
766: m_freem(mrep);
767: }
768: #else
769: nfsstats.rpcinvalid++;
770: m_freem(mrep);
771: #endif
772: nfsmout:
773: if (myrep->r_flags & R_GETONEREP)
774: return (0);
775: continue;
776: }
777:
778: /*
779: * Loop through the request list to match up the reply
780: * Iff no match, just drop the datagram
781: */
782: for (rep = nfs_reqq.tqh_first; rep != 0;
783: rep = rep->r_chain.tqe_next) {
784: if (rep->r_mrep == NULL && rxid == rep->r_xid) {
785: /* Found it.. */
786: rep->r_mrep = mrep;
787: rep->r_md = md;
788: rep->r_dpos = dpos;
789: if (nfsrtton) {
790: struct rttl *rt;
791:
792: rt = &nfsrtt.rttl[nfsrtt.pos];
793: rt->proc = rep->r_procnum;
794: rt->rto = NFS_RTO(nmp, proct[rep->r_procnum]);
795: rt->sent = nmp->nm_sent;
796: rt->cwnd = nmp->nm_cwnd;
797: rt->srtt = nmp->nm_srtt[proct[rep->r_procnum] - 1];
798: rt->sdrtt = nmp->nm_sdrtt[proct[rep->r_procnum] - 1];
799: rt->fsid = nmp->nm_mountp->mnt_stat.f_fsid;
800: rt->tstamp = time;
801: if (rep->r_flags & R_TIMING)
802: rt->rtt = rep->r_rtt;
803: else
804: rt->rtt = 1000000;
805: nfsrtt.pos = (nfsrtt.pos + 1) % NFSRTTLOGSIZ;
806: }
807: /*
808: * Update congestion window.
809: * Do the additive increase of
810: * one rpc/rtt.
811: */
812: if (nmp->nm_cwnd <= nmp->nm_sent) {
813: nmp->nm_cwnd +=
814: (NFS_CWNDSCALE * NFS_CWNDSCALE +
815: (nmp->nm_cwnd >> 1)) / nmp->nm_cwnd;
816: if (nmp->nm_cwnd > NFS_MAXCWND)
817: nmp->nm_cwnd = NFS_MAXCWND;
818: }
819: rep->r_flags &= ~R_SENT;
820: nmp->nm_sent -= NFS_CWNDSCALE;
821: /*
822: * Update rtt using a gain of 0.125 on the mean
823: * and a gain of 0.25 on the deviation.
824: */
825: if (rep->r_flags & R_TIMING) {
826: /*
827: * Since the timer resolution of
828: * NFS_HZ is so course, it can often
829: * result in r_rtt == 0. Since
830: * r_rtt == N means that the actual
831: * rtt is between N+dt and N+2-dt ticks,
832: * add 1.
833: */
834: t1 = rep->r_rtt + 1;
835: t1 -= (NFS_SRTT(rep) >> 3);
836: NFS_SRTT(rep) += t1;
837: if (t1 < 0)
838: t1 = -t1;
839: t1 -= (NFS_SDRTT(rep) >> 2);
840: NFS_SDRTT(rep) += t1;
841: }
842: nmp->nm_timeouts = 0;
843: break;
844: }
845: }
846: /*
847: * If not matched to a request, drop it.
848: * If it's mine, get out.
849: */
850: if (rep == 0) {
851: nfsstats.rpcunexpected++;
852: m_freem(mrep);
853: } else if (rep == myrep) {
854: if (rep->r_mrep == NULL)
855: panic("nfsreply nil");
856: return (0);
857: }
858: if (myrep->r_flags & R_GETONEREP)
859: return (0);
860: }
861: }
862:
863: /*
864: * nfs_request - goes something like this
865: * - fill in request struct
866: * - links it into list
867: * - calls nfs_send() for first transmit
868: * - calls nfs_receive() to get reply
869: * - break down rpc header and return with nfs reply pointed to
870: * by mrep or error
871: * nb: always frees up mreq mbuf list
872: */
873: int
874: nfs_request(vp, mrest, procnum, procp, cred, mrp, mdp, dposp)
875: struct vnode *vp;
876: struct mbuf *mrest;
877: int procnum;
878: struct proc *procp;
879: struct ucred *cred;
880: struct mbuf **mrp;
881: struct mbuf **mdp;
882: caddr_t *dposp;
883: {
884: register struct mbuf *m, *mrep;
885: register struct nfsreq *rep;
886: register u_long *tl;
887: register int i;
888: struct nfsmount *nmp;
889: struct mbuf *md, *mheadend;
890: struct nfsnode *np;
891: char nickv[RPCX_NICKVERF];
892: time_t reqtime, waituntil;
893: caddr_t dpos, cp2;
894: int t1, nqlflag, cachable, s, error = 0, mrest_len, auth_len, auth_type;
895: int trylater_delay = NQ_TRYLATERDEL, trylater_cnt = 0, failed_auth = 0;
896: int verf_len, verf_type;
897: u_long xid;
898: u_quad_t frev;
899: char *auth_str, *verf_str;
900: NFSKERBKEY_T key; /* save session key */
901:
902: NFSTRACE4(NFSTRC_REQ, vp, procnum, 0, 0);
903: nmp = VFSTONFS(vp->v_mount);
904: MALLOC_ZONE(rep, struct nfsreq *,
905: sizeof(struct nfsreq), M_NFSREQ, M_WAITOK);
906: rep->r_nmp = nmp;
907: rep->r_vp = vp;
908: rep->r_procp = procp;
909: rep->r_procnum = procnum;
910: i = 0;
911: m = mrest;
912: while (m) {
913: i += m->m_len;
914: m = m->m_next;
915: }
916: mrest_len = i;
917:
918: /*
919: * Get the RPC header with authorization.
920: */
921: kerbauth:
922: verf_str = auth_str = (char *)0;
923: if (nmp->nm_flag & NFSMNT_KERB) {
924: verf_str = nickv;
925: verf_len = sizeof (nickv);
926: auth_type = RPCAUTH_KERB4;
927: bzero((caddr_t)key, sizeof (key));
928: if (failed_auth || nfs_getnickauth(nmp, cred, &auth_str,
929: &auth_len, verf_str, verf_len)) {
930: error = nfs_getauth(nmp, rep, cred, &auth_str,
931: &auth_len, verf_str, &verf_len, key);
932: if (error) {
933: _FREE_ZONE((caddr_t)rep,
934: sizeof (struct nfsreq), M_NFSREQ);
935: m_freem(mrest);
936: return (error);
937: }
938: }
939: } else {
940: auth_type = RPCAUTH_UNIX;
941: if (cred->cr_ngroups < 1)
942: panic("nfsreq nogrps");
943: auth_len = ((((cred->cr_ngroups - 1) > nmp->nm_numgrps) ?
944: nmp->nm_numgrps : (cred->cr_ngroups - 1)) << 2) +
945: 5 * NFSX_UNSIGNED;
946: }
947: m = nfsm_rpchead(cred, nmp->nm_flag, procnum, auth_type, auth_len,
948: auth_str, verf_len, verf_str, mrest, mrest_len, &mheadend, &xid);
949: if (auth_str)
950: _FREE(auth_str, M_TEMP);
951:
952: /*
953: * For stream protocols, insert a Sun RPC Record Mark.
954: */
955: if (nmp->nm_sotype == SOCK_STREAM) {
956: M_PREPEND(m, NFSX_UNSIGNED, M_WAIT);
957: *mtod(m, u_long *) = htonl(0x80000000 |
958: (m->m_pkthdr.len - NFSX_UNSIGNED));
959: }
960: rep->r_mreq = m;
961: rep->r_xid = xid;
962: tryagain:
963: if (nmp->nm_flag & NFSMNT_SOFT)
964: rep->r_retry = nmp->nm_retry;
965: else
966: rep->r_retry = NFS_MAXREXMIT + 1; /* past clip limit */
967: rep->r_rtt = rep->r_rexmit = 0;
968: if (proct[procnum] > 0)
969: rep->r_flags = R_TIMING;
970: else
971: rep->r_flags = 0;
972: rep->r_mrep = NULL;
973:
974: /*
975: * Do the client side RPC.
976: */
977: nfsstats.rpcrequests++;
978: /*
979: * Chain request into list of outstanding requests. Be sure
980: * to put it LAST so timer finds oldest requests first.
981: */
982: s = splsoftclock();
983: TAILQ_INSERT_TAIL(&nfs_reqq, rep, r_chain);
984:
985: /* Get send time for nqnfs */
986: reqtime = time.tv_sec;
987:
988: /*
989: * If backing off another request or avoiding congestion, don't
990: * send this one now but let timer do it. If not timing a request,
991: * do it now.
992: */
993: if (nmp->nm_so && (nmp->nm_sotype != SOCK_DGRAM ||
994: (nmp->nm_flag & NFSMNT_DUMBTIMR) ||
995: nmp->nm_sent < nmp->nm_cwnd)) {
996: splx(s);
997: if (nmp->nm_soflags & PR_CONNREQUIRED)
998: error = nfs_sndlock(&nmp->nm_flag, rep);
999: if (!error) {
1000: m = m_copym(m, 0, M_COPYALL, M_WAIT);
1001: error = nfs_send(nmp->nm_so, nmp->nm_nam, m, rep);
1002: if (nmp->nm_soflags & PR_CONNREQUIRED)
1003: nfs_sndunlock(&nmp->nm_flag);
1004: }
1005: if (!error && (rep->r_flags & R_MUSTRESEND) == 0) {
1006: nmp->nm_sent += NFS_CWNDSCALE;
1007: rep->r_flags |= R_SENT;
1008: }
1009: } else {
1010: splx(s);
1011: rep->r_rtt = -1;
1012: }
1013:
1014: /*
1015: * Wait for the reply from our send or the timer's.
1016: */
1017: if (!error || error == EPIPE)
1018: error = nfs_reply(rep);
1019:
1020: /*
1021: * RPC done, unlink the request.
1022: */
1023: s = splsoftclock();
1024: TAILQ_REMOVE(&nfs_reqq, rep, r_chain);
1025: splx(s);
1026:
1027: /*
1028: * Decrement the outstanding request count.
1029: */
1030: if (rep->r_flags & R_SENT) {
1031: rep->r_flags &= ~R_SENT; /* paranoia */
1032: nmp->nm_sent -= NFS_CWNDSCALE;
1033: }
1034:
1035: /*
1036: * If there was a successful reply and a tprintf msg.
1037: * tprintf a response.
1038: */
1039: if (!error && (rep->r_flags & R_TPRINTFMSG))
1040: nfs_msg(rep->r_procp, nmp->nm_mountp->mnt_stat.f_mntfromname,
1041: "is alive again");
1042: mrep = rep->r_mrep;
1043: md = rep->r_md;
1044: dpos = rep->r_dpos;
1045: if (error) {
1046: m_freem(rep->r_mreq);
1047: _FREE_ZONE((caddr_t)rep, sizeof (struct nfsreq), M_NFSREQ);
1048: return (error);
1049: }
1050:
1051: /*
1052: * break down the rpc header and check if ok
1053: */
1054: nfsm_dissect(tl, u_long *, 3 * NFSX_UNSIGNED);
1055: if (*tl++ == rpc_msgdenied) {
1056: if (*tl == rpc_mismatch)
1057: error = EOPNOTSUPP;
1058: else if ((nmp->nm_flag & NFSMNT_KERB) && *tl++ == rpc_autherr) {
1059: if (!failed_auth) {
1060: failed_auth++;
1061: mheadend->m_next = (struct mbuf *)0;
1062: m_freem(mrep);
1063: m_freem(rep->r_mreq);
1064: goto kerbauth;
1065: } else
1066: error = EAUTH;
1067: } else
1068: error = EACCES;
1069: m_freem(mrep);
1070: m_freem(rep->r_mreq);
1071: _FREE_ZONE((caddr_t)rep, sizeof (struct nfsreq), M_NFSREQ);
1072: return (error);
1073: }
1074:
1075: /*
1076: * Grab any Kerberos verifier, otherwise just throw it away.
1077: */
1078: verf_type = fxdr_unsigned(int, *tl++);
1079: i = fxdr_unsigned(int, *tl);
1080: if ((nmp->nm_flag & NFSMNT_KERB) && verf_type == RPCAUTH_KERB4) {
1081: error = nfs_savenickauth(nmp, cred, i, key, &md, &dpos, mrep);
1082: if (error)
1083: goto nfsmout;
1084: } else if (i > 0)
1085: nfsm_adv(nfsm_rndup(i));
1086: nfsm_dissect(tl, u_long *, NFSX_UNSIGNED);
1087: /* 0 == ok */
1088: if (*tl == 0) {
1089: nfsm_dissect(tl, u_long *, NFSX_UNSIGNED);
1090: if (*tl != 0) {
1091: error = fxdr_unsigned(int, *tl);
1092: if ((nmp->nm_flag & NFSMNT_NFSV3) &&
1093: error == NFSERR_TRYLATER) {
1094: m_freem(mrep);
1095: error = 0;
1096: waituntil = time.tv_sec + trylater_delay;
1097: #if DIAGNOSTIC
1098: kprintf("nfs_request %s flag=%x trylater_cnt=%x waituntil=%lx trylater_delay=%x\n", nmp->nm_mountp->mnt_stat.f_mntfromname, nmp->nm_flag, trylater_cnt, waituntil, trylater_delay);
1099: #endif
1100: while (time.tv_sec < waituntil)
1101: (void) tsleep((caddr_t)&lbolt,
1102: PSOCK, "nqnfstry", 0);
1103: trylater_delay *= nfs_backoff[trylater_cnt];
1104: if (trylater_cnt < 7)
1105: trylater_cnt++;
1106: goto tryagain;
1107: }
1108:
1109: /*
1110: * If the File Handle was stale, invalidate the
1111: * lookup cache, just in case.
1112: */
1113: if (error == ESTALE)
1114: cache_purge(vp);
1115: if (nmp->nm_flag & NFSMNT_NFSV3) {
1116: *mrp = mrep;
1117: *mdp = md;
1118: *dposp = dpos;
1119: error |= NFSERR_RETERR;
1120: } else
1121: m_freem(mrep);
1122: m_freem(rep->r_mreq);
1123: _FREE_ZONE((caddr_t)rep,
1124: sizeof (struct nfsreq), M_NFSREQ);
1125: return (error);
1126: }
1127:
1128: /*
1129: * For nqnfs, get any lease in reply
1130: */
1131: if (nmp->nm_flag & NFSMNT_NQNFS) {
1132: nfsm_dissect(tl, u_long *, NFSX_UNSIGNED);
1133: if (*tl) {
1134: np = VTONFS(vp);
1135: nqlflag = fxdr_unsigned(int, *tl);
1136: nfsm_dissect(tl, u_long *, 4*NFSX_UNSIGNED);
1137: cachable = fxdr_unsigned(int, *tl++);
1138: reqtime += fxdr_unsigned(int, *tl++);
1139: if (reqtime > time.tv_sec) {
1140: fxdr_hyper(tl, &frev);
1141: nqnfs_clientlease(nmp, np, nqlflag,
1142: cachable, reqtime, frev);
1143: }
1144: }
1145: }
1146: *mrp = mrep;
1147: *mdp = md;
1148: *dposp = dpos;
1149: m_freem(rep->r_mreq);
1150: FREE_ZONE((caddr_t)rep, sizeof (struct nfsreq), M_NFSREQ);
1151: return (0);
1152: }
1153: m_freem(mrep);
1154: error = EPROTONOSUPPORT;
1155: nfsmout:
1156: m_freem(rep->r_mreq);
1157: _FREE_ZONE((caddr_t)rep, sizeof (struct nfsreq), M_NFSREQ);
1158: return (error);
1159: }
1160:
1161: #ifndef NFS_NOSERVER
1162: /*
1163: * Generate the rpc reply header
1164: * siz arg. is used to decide if adding a cluster is worthwhile
1165: */
1166: int
1167: nfs_rephead(siz, nd, slp, err, cache, frev, mrq, mbp, bposp)
1168: int siz;
1169: struct nfsrv_descript *nd;
1170: struct nfssvc_sock *slp;
1171: int err;
1172: int cache;
1173: u_quad_t *frev;
1174: struct mbuf **mrq;
1175: struct mbuf **mbp;
1176: caddr_t *bposp;
1177: {
1178: register u_long *tl;
1179: register struct mbuf *mreq;
1180: caddr_t bpos;
1181: struct mbuf *mb, *mb2;
1182:
1183: MGETHDR(mreq, M_WAIT, MT_DATA);
1184: mb = mreq;
1185: /*
1186: * If this is a big reply, use a cluster else
1187: * try and leave leading space for the lower level headers.
1188: */
1189: siz += RPC_REPLYSIZ;
1190: if (siz >= MINCLSIZE) {
1191: MCLGET(mreq, M_WAIT);
1192: } else
1193: mreq->m_data += max_hdr;
1194: tl = mtod(mreq, u_long *);
1195: mreq->m_len = 6 * NFSX_UNSIGNED;
1196: bpos = ((caddr_t)tl) + mreq->m_len;
1197: *tl++ = txdr_unsigned(nd->nd_retxid);
1198: *tl++ = rpc_reply;
1199: if (err == ERPCMISMATCH || (err & NFSERR_AUTHERR)) {
1200: *tl++ = rpc_msgdenied;
1201: if (err & NFSERR_AUTHERR) {
1202: *tl++ = rpc_autherr;
1203: *tl = txdr_unsigned(err & ~NFSERR_AUTHERR);
1204: mreq->m_len -= NFSX_UNSIGNED;
1205: bpos -= NFSX_UNSIGNED;
1206: } else {
1207: *tl++ = rpc_mismatch;
1208: *tl++ = txdr_unsigned(RPC_VER2);
1209: *tl = txdr_unsigned(RPC_VER2);
1210: }
1211: } else {
1212: *tl++ = rpc_msgaccepted;
1213:
1214: /*
1215: * For Kerberos authentication, we must send the nickname
1216: * verifier back, otherwise just RPCAUTH_NULL.
1217: */
1218: if (nd->nd_flag & ND_KERBFULL) {
1219: register struct nfsuid *nuidp;
1220: struct timeval ktvin, ktvout;
1221:
1222: for (nuidp = NUIDHASH(slp, nd->nd_cr.cr_uid)->lh_first;
1223: nuidp != 0; nuidp = nuidp->nu_hash.le_next) {
1224: if (nuidp->nu_cr.cr_uid == nd->nd_cr.cr_uid &&
1225: (!nd->nd_nam2 || netaddr_match(NU_NETFAM(nuidp),
1226: &nuidp->nu_haddr, nd->nd_nam2)))
1227: break;
1228: }
1229: if (nuidp) {
1230: ktvin.tv_sec =
1231: txdr_unsigned(nuidp->nu_timestamp.tv_sec - 1);
1232: ktvin.tv_usec =
1233: txdr_unsigned(nuidp->nu_timestamp.tv_usec);
1234:
1235: /*
1236: * Encrypt the timestamp in ecb mode using the
1237: * session key.
1238: */
1239: #if NFSKERB
1240: XXX
1241: #endif
1242:
1243: *tl++ = rpc_auth_kerb;
1244: *tl++ = txdr_unsigned(3 * NFSX_UNSIGNED);
1245: *tl = ktvout.tv_sec;
1246: nfsm_build(tl, u_long *, 3 * NFSX_UNSIGNED);
1247: *tl++ = ktvout.tv_usec;
1248: *tl++ = txdr_unsigned(nuidp->nu_cr.cr_uid);
1249: } else {
1250: *tl++ = 0;
1251: *tl++ = 0;
1252: }
1253: } else {
1254: *tl++ = 0;
1255: *tl++ = 0;
1256: }
1257: switch (err) {
1258: case EPROGUNAVAIL:
1259: *tl = txdr_unsigned(RPC_PROGUNAVAIL);
1260: break;
1261: case EPROGMISMATCH:
1262: *tl = txdr_unsigned(RPC_PROGMISMATCH);
1263: nfsm_build(tl, u_long *, 2 * NFSX_UNSIGNED);
1264: if (nd->nd_flag & ND_NQNFS) {
1265: *tl++ = txdr_unsigned(3);
1266: *tl = txdr_unsigned(3);
1267: } else {
1268: *tl++ = txdr_unsigned(2);
1269: *tl = txdr_unsigned(3);
1270: }
1271: break;
1272: case EPROCUNAVAIL:
1273: *tl = txdr_unsigned(RPC_PROCUNAVAIL);
1274: break;
1275: case EBADRPC:
1276: *tl = txdr_unsigned(RPC_GARBAGE);
1277: break;
1278: default:
1279: *tl = 0;
1280: if (err != NFSERR_RETVOID) {
1281: nfsm_build(tl, u_long *, NFSX_UNSIGNED);
1282: if (err)
1283: *tl = txdr_unsigned(nfsrv_errmap(nd, err));
1284: else
1285: *tl = 0;
1286: }
1287: break;
1288: };
1289: }
1290:
1291: /*
1292: * For nqnfs, piggyback lease as requested.
1293: */
1294: if ((nd->nd_flag & ND_NQNFS) && err == 0) {
1295: if (nd->nd_flag & ND_LEASE) {
1296: nfsm_build(tl, u_long *, 5 * NFSX_UNSIGNED);
1297: *tl++ = txdr_unsigned(nd->nd_flag & ND_LEASE);
1298: *tl++ = txdr_unsigned(cache);
1299: *tl++ = txdr_unsigned(nd->nd_duration);
1300: txdr_hyper(frev, tl);
1301: } else {
1302: nfsm_build(tl, u_long *, NFSX_UNSIGNED);
1303: *tl = 0;
1304: }
1305: }
1306: if (mrq != NULL)
1307: *mrq = mreq;
1308: *mbp = mb;
1309: *bposp = bpos;
1310: if (err != 0 && err != NFSERR_RETVOID)
1311: nfsstats.srvrpc_errs++;
1312: return (0);
1313: }
1314:
1315:
1316: #endif /* NFS_NOSERVER */
1317:
1318: #if DIAGNOSTIC
1319: int nfsprnttimo = 2;
1320: #endif
1321:
1322: /*
1323: * Nfs timer routine
1324: * Scan the nfsreq list and retranmit any requests that have timed out
1325: * To avoid retransmission attempts on STREAM sockets (in the future) make
1326: * sure to set the r_retry field to 0 (implies nm_retry == 0).
1327: */
1328: void
1329: nfs_timer(arg)
1330: void *arg; /* never used */
1331: {
1332: register struct nfsreq *rep;
1333: register struct mbuf *m;
1334: register struct socket *so;
1335: register struct nfsmount *nmp;
1336: register int timeo;
1337: int s, error;
1338: #ifndef NFS_NOSERVER
1339: static long lasttime = 0;
1340: register struct nfssvc_sock *slp;
1341: u_quad_t cur_usec;
1342: #endif /* NFS_NOSERVER */
1343: #if DIAGNOSTIC
1344: int rttdiag;
1345: #endif
1346:
1347: s = splnet();
1348: for (rep = nfs_reqq.tqh_first; rep != 0; rep = rep->r_chain.tqe_next) {
1349: nmp = rep->r_nmp;
1350: if (rep->r_mrep || (rep->r_flags & R_SOFTTERM))
1351: continue;
1352: if (nfs_sigintr(nmp, rep, rep->r_procp)) {
1353: rep->r_flags |= R_SOFTTERM;
1354: continue;
1355: }
1356: if (rep->r_rtt >= 0) {
1357: rep->r_rtt++;
1358: if (nmp->nm_flag & NFSMNT_DUMBTIMR)
1359: timeo = nmp->nm_timeo;
1360: else
1361: timeo = NFS_RTO(nmp, proct[rep->r_procnum]);
1362: if (nmp->nm_timeouts > 0)
1363: timeo *= nfs_backoff[nmp->nm_timeouts - 1];
1364: if (rep->r_rtt <= timeo)
1365: continue;
1366: if (nmp->nm_timeouts < 8)
1367: nmp->nm_timeouts++;
1368: }
1369: /*
1370: * Check for server not responding
1371: */
1372: if ((rep->r_flags & R_TPRINTFMSG) == 0 &&
1373: rep->r_rexmit > nmp->nm_deadthresh) {
1374: nfs_msg(rep->r_procp,
1375: nmp->nm_mountp->mnt_stat.f_mntfromname,
1376: "not responding");
1377: rep->r_flags |= R_TPRINTFMSG;
1378: }
1379: if (rep->r_rexmit >= rep->r_retry) { /* too many */
1380: nfsstats.rpctimeouts++;
1381: rep->r_flags |= R_SOFTTERM;
1382: continue;
1383: }
1384: if (nmp->nm_sotype != SOCK_DGRAM) {
1385: if (++rep->r_rexmit > NFS_MAXREXMIT)
1386: rep->r_rexmit = NFS_MAXREXMIT;
1387: continue;
1388: }
1389: if ((so = nmp->nm_so) == NULL)
1390: continue;
1391:
1392: /*
1393: * If there is enough space and the window allows..
1394: * Resend it
1395: * Set r_rtt to -1 in case we fail to send it now.
1396: */
1397: #if DIAGNOSTIC
1398: rttdiag = rep->r_rtt;
1399: #endif
1400: rep->r_rtt = -1;
1401: if (sbspace(&so->so_snd) >= rep->r_mreq->m_pkthdr.len &&
1402: ((nmp->nm_flag & NFSMNT_DUMBTIMR) ||
1403: (rep->r_flags & R_SENT) ||
1404: nmp->nm_sent < nmp->nm_cwnd) &&
1405: (m = m_copym(rep->r_mreq, 0, M_COPYALL, M_DONTWAIT))){
1406: #if DIAGNOSTIC
1407: if (rep->r_flags & R_SENT) { /* retry? */
1408: if (nfsprnttimo && nmp->nm_timeouts >= nfsprnttimo)
1409: kprintf("nfs_timer %s f=0x%x nmtm=%d tms=%d rtt=%d tm=%d p#=%d\n",
1410: nmp->nm_mountp->mnt_stat.f_mntfromname, nmp->nm_flag, nmp->nm_timeo, nmp->nm_timeouts, rttdiag, timeo, rep->r_procnum);
1411: }
1412: #endif
1413: if ((nmp->nm_flag & NFSMNT_NOCONN) == 0)
1414: error = (*so->so_proto->pr_usrreq)(so, PRU_SEND, m,
1415: (struct mbuf *)0, (struct mbuf *)0);
1416: else
1417: error = (*so->so_proto->pr_usrreq)(so, PRU_SEND, m,
1418: nmp->nm_nam, (struct mbuf *)0);
1419: if (error) {
1420: if (NFSIGNORE_SOERROR(nmp->nm_soflags, error))
1421: so->so_error = 0;
1422: } else {
1423: /*
1424: * Iff first send, start timing
1425: * else turn timing off, backoff timer
1426: * and divide congestion window by 2.
1427: */
1428: if (rep->r_flags & R_SENT) {
1429: rep->r_flags &= ~R_TIMING;
1430: if (++rep->r_rexmit > NFS_MAXREXMIT)
1431: rep->r_rexmit = NFS_MAXREXMIT;
1432: nmp->nm_cwnd >>= 1;
1433: if (nmp->nm_cwnd < NFS_CWNDSCALE)
1434: nmp->nm_cwnd = NFS_CWNDSCALE;
1435: nfsstats.rpcretries++;
1436: } else {
1437: rep->r_flags |= R_SENT;
1438: nmp->nm_sent += NFS_CWNDSCALE;
1439: }
1440: rep->r_rtt = 0;
1441: }
1442: }
1443: }
1444: #ifndef NFS_NOSERVER
1445: /*
1446: * Call the nqnfs server timer once a second to handle leases.
1447: */
1448: if (lasttime != time.tv_sec) {
1449: lasttime = time.tv_sec;
1450: nqnfs_serverd();
1451: }
1452:
1453: /*
1454: * Scan the write gathering queues for writes that need to be
1455: * completed now.
1456: */
1457: cur_usec = (u_quad_t)time.tv_sec * 1000000 + (u_quad_t)time.tv_usec;
1458: for (slp = nfssvc_sockhead.tqh_first; slp != 0;
1459: slp = slp->ns_chain.tqe_next) {
1460: if (slp->ns_tq.lh_first && slp->ns_tq.lh_first->nd_time<=cur_usec)
1461: nfsrv_wakenfsd(slp);
1462: }
1463: #endif /* NFS_NOSERVER */
1464: splx(s);
1465: timeout(nfs_timer, (void *)0, nfs_ticks);
1466: }
1467:
1468:
1469: /*
1470: * Test for a termination condition pending on the process.
1471: * This is used for NFSMNT_INT mounts.
1472: */
1473: int
1474: nfs_sigintr(nmp, rep, p)
1475: struct nfsmount *nmp;
1476: struct nfsreq *rep;
1477: register struct proc *p;
1478: {
1479:
1480: if (rep && (rep->r_flags & R_SOFTTERM))
1481: return (EINTR);
1482: if (!(nmp->nm_flag & NFSMNT_INT))
1483: return (0);
1484: if (p && p->p_siglist &&
1485: (((p->p_siglist & ~p->p_sigmask) & ~p->p_sigignore) &
1486: NFSINT_SIGMASK))
1487: return (EINTR);
1488: return (0);
1489: }
1490:
1491: /*
1492: * Lock a socket against others.
1493: * Necessary for STREAM sockets to ensure you get an entire rpc request/reply
1494: * and also to avoid race conditions between the processes with nfs requests
1495: * in progress when a reconnect is necessary.
1496: */
1497: int
1498: nfs_sndlock(flagp, rep)
1499: register int *flagp;
1500: struct nfsreq *rep;
1501: {
1502: struct proc *p;
1503: int slpflag = 0, slptimeo = 0;
1504:
1505: if (rep) {
1506: p = rep->r_procp;
1507: if (rep->r_nmp->nm_flag & NFSMNT_INT)
1508: slpflag = PCATCH;
1509: } else
1510: p = (struct proc *)0;
1511: while (*flagp & NFSMNT_SNDLOCK) {
1512: if (nfs_sigintr(rep->r_nmp, rep, p))
1513: return (EINTR);
1514: *flagp |= NFSMNT_WANTSND;
1515: (void) tsleep((caddr_t)flagp, slpflag | (PZERO - 1), "nfsndlck",
1516: slptimeo);
1517: if (slpflag == PCATCH) {
1518: slpflag = 0;
1519: slptimeo = 2 * hz;
1520: }
1521: }
1522: *flagp |= NFSMNT_SNDLOCK;
1523: return (0);
1524: }
1525:
1526: /*
1527: * Unlock the stream socket for others.
1528: */
1529: void
1530: nfs_sndunlock(flagp)
1531: register int *flagp;
1532: {
1533:
1534: if ((*flagp & NFSMNT_SNDLOCK) == 0)
1535: panic("nfs sndunlock");
1536: *flagp &= ~NFSMNT_SNDLOCK;
1537: if (*flagp & NFSMNT_WANTSND) {
1538: *flagp &= ~NFSMNT_WANTSND;
1539: wakeup((caddr_t)flagp);
1540: }
1541: }
1542:
1543: #if DIAGNOSTIC
1544: uint nfstraceindx = 0;
1545: struct nfstracerec nfstracebuf[NFSTBUFSIZ] = {{0,0,0,0}};
1546: uint nfstracemask = 0; /* enables trace points 0 to 31 (right to left) */
1547: #endif /* DIAGNOSTIC */
1548:
1549: static int
1550: nfs_rcvlock(rep)
1551: register struct nfsreq *rep;
1552: {
1553: register int *flagp = &rep->r_nmp->nm_flag;
1554: int slpflag, slptimeo = 0;
1555:
1556: if (*flagp & NFSMNT_INT)
1557: slpflag = PCATCH;
1558: else
1559: slpflag = 0;
1560: while (*flagp & NFSMNT_RCVLOCK) {
1561: NFSTRACE(NFSTRC_RCVLCKW, flagp);
1562: if (nfs_sigintr(rep->r_nmp, rep, rep->r_procp))
1563: return (EINTR);
1564: *flagp |= NFSMNT_WANTRCV;
1565: (void) tsleep((caddr_t)flagp, slpflag | (PZERO - 1), "nfsrcvlk",
1566: slptimeo);
1567: /*
1568: * If our reply was recieved while we were sleeping,
1569: * then just return without taking the lock to avoid a
1570: * situation where a single iod could 'capture' the
1571: * recieve lock.
1572: */
1573: if (rep->r_mrep != NULL)
1574: return (EALREADY);
1575: if (slpflag == PCATCH) {
1576: slpflag = 0;
1577: slptimeo = 2 * hz;
1578: }
1579: }
1580: NFSTRACE(NFSTRC_RCVLCK, flagp);
1581: *flagp |= NFSMNT_RCVLOCK;
1582: return (0);
1583: }
1584:
1585: /*
1586: * Unlock the stream socket for others.
1587: */
1588: static void
1589: nfs_rcvunlock(flagp)
1590: register int *flagp;
1591: {
1592:
1593: if ((*flagp & NFSMNT_RCVLOCK) == 0)
1594: panic("nfs rcvunlock");
1595: *flagp &= ~NFSMNT_RCVLOCK;
1596: if (*flagp & NFSMNT_WANTRCV) {
1597: NFSTRACE(NFSTRC_RCVUNLW, flagp);
1598: *flagp &= ~NFSMNT_WANTRCV;
1599: wakeup((caddr_t)flagp);
1600: } else {
1601: NFSTRACE(NFSTRC_RCVUNL, flagp);
1602: }
1603: }
1604:
1605:
1606: #ifndef NFS_NOSERVER
1607: /*
1608: * Socket upcall routine for the nfsd sockets.
1609: * The caddr_t arg is a pointer to the "struct nfssvc_sock".
1610: * Essentially do as much as possible non-blocking, else punt and it will
1611: * be called with M_WAIT from an nfsd.
1612: */
1613: void
1614: nfsrv_rcv(so, arg, waitflag)
1615: struct socket *so;
1616: caddr_t arg;
1617: int waitflag;
1618: {
1619: register struct nfssvc_sock *slp = (struct nfssvc_sock *)arg;
1620: register struct mbuf *m;
1621: struct mbuf *mp;
1622: struct mbuf *nam;
1623: struct uio auio;
1624: int flags, error;
1625:
1626: if ((slp->ns_flag & SLP_VALID) == 0)
1627: return;
1628: #ifdef notdef
1629: /*
1630: * Define this to test for nfsds handling this under heavy load.
1631: */
1632: if (waitflag == M_DONTWAIT) {
1633: slp->ns_flag |= SLP_NEEDQ; goto dorecs;
1634: }
1635: #endif
1636: auio.uio_procp = NULL;
1637: if (so->so_type == SOCK_STREAM) {
1638: /*
1639: * If there are already records on the queue, defer soreceive()
1640: * to an nfsd so that there is feedback to the TCP layer that
1641: * the nfs servers are heavily loaded.
1642: */
1643: if (slp->ns_rec && waitflag == M_DONTWAIT) {
1644: slp->ns_flag |= SLP_NEEDQ;
1645: goto dorecs;
1646: }
1647:
1648: /*
1649: * Do soreceive().
1650: */
1651: auio.uio_resid = 1000000000;
1652: flags = MSG_DONTWAIT;
1653: error = soreceive(so, &nam, &auio, &mp, (struct mbuf **)0, &flags);
1654: if (error || mp == (struct mbuf *)0) {
1655: if (error == EWOULDBLOCK)
1656: slp->ns_flag |= SLP_NEEDQ;
1657: else
1658: slp->ns_flag |= SLP_DISCONN;
1659: goto dorecs;
1660: }
1661: m = mp;
1662: if (slp->ns_rawend) {
1663: slp->ns_rawend->m_next = m;
1664: slp->ns_cc += 1000000000 - auio.uio_resid;
1665: } else {
1666: slp->ns_raw = m;
1667: slp->ns_cc = 1000000000 - auio.uio_resid;
1668: }
1669: while (m->m_next)
1670: m = m->m_next;
1671: slp->ns_rawend = m;
1672:
1673: /*
1674: * Now try and parse record(s) out of the raw stream data.
1675: */
1676: error = nfsrv_getstream(slp, waitflag);
1677: if (error) {
1678: if (error == EPERM)
1679: slp->ns_flag |= SLP_DISCONN;
1680: else
1681: slp->ns_flag |= SLP_NEEDQ;
1682: }
1683: } else {
1684: do {
1685: auio.uio_resid = 1000000000;
1686: flags = MSG_DONTWAIT;
1687: error = soreceive(so, &nam, &auio, &mp,
1688: (struct mbuf **)0, &flags);
1689: if (mp) {
1690: if (nam) {
1691: m = nam;
1692: m->m_next = mp;
1693: } else
1694: m = mp;
1695: if (slp->ns_recend)
1696: slp->ns_recend->m_nextpkt = m;
1697: else
1698: slp->ns_rec = m;
1699: slp->ns_recend = m;
1700: m->m_nextpkt = (struct mbuf *)0;
1701: }
1702: if (error) {
1703: if ((so->so_proto->pr_flags & PR_CONNREQUIRED)
1704: && error != EWOULDBLOCK) {
1705: slp->ns_flag |= SLP_DISCONN;
1706: goto dorecs;
1707: }
1708: }
1709: } while (mp);
1710: }
1711:
1712: /*
1713: * Now try and process the request records, non-blocking.
1714: */
1715: dorecs:
1716: if (waitflag == M_DONTWAIT &&
1717: (slp->ns_rec || (slp->ns_flag & (SLP_NEEDQ | SLP_DISCONN))))
1718: nfsrv_wakenfsd(slp);
1719: }
1720:
1721: /*
1722: * Try and extract an RPC request from the mbuf data list received on a
1723: * stream socket. The "waitflag" argument indicates whether or not it
1724: * can sleep.
1725: */
1726: static int
1727: nfsrv_getstream(slp, waitflag)
1728: register struct nfssvc_sock *slp;
1729: int waitflag;
1730: {
1731: register struct mbuf *m, **mpp;
1732: register char *cp1, *cp2;
1733: register int len;
1734: struct mbuf *om, *m2, *recm = 0;
1735: u_long recmark;
1736:
1737: if (slp->ns_flag & SLP_GETSTREAM)
1738: panic("nfs getstream");
1739: slp->ns_flag |= SLP_GETSTREAM;
1740: for (;;) {
1741: if (slp->ns_reclen == 0) {
1742: if (slp->ns_cc < NFSX_UNSIGNED) {
1743: slp->ns_flag &= ~SLP_GETSTREAM;
1744: return (0);
1745: }
1746: m = slp->ns_raw;
1747: if (m->m_len >= NFSX_UNSIGNED) {
1748: bcopy(mtod(m, caddr_t), (caddr_t)&recmark, NFSX_UNSIGNED);
1749: m->m_data += NFSX_UNSIGNED;
1750: m->m_len -= NFSX_UNSIGNED;
1751: } else {
1752: cp1 = (caddr_t)&recmark;
1753: cp2 = mtod(m, caddr_t);
1754: while (cp1 < ((caddr_t)&recmark) + NFSX_UNSIGNED) {
1755: while (m->m_len == 0) {
1756: m = m->m_next;
1757: cp2 = mtod(m, caddr_t);
1758: }
1759: *cp1++ = *cp2++;
1760: m->m_data++;
1761: m->m_len--;
1762: }
1763: }
1764: slp->ns_cc -= NFSX_UNSIGNED;
1765: recmark = ntohl(recmark);
1766: slp->ns_reclen = recmark & ~0x80000000;
1767: if (recmark & 0x80000000)
1768: slp->ns_flag |= SLP_LASTFRAG;
1769: else
1770: slp->ns_flag &= ~SLP_LASTFRAG;
1771: if (slp->ns_reclen < NFS_MINPACKET || slp->ns_reclen > NFS_MAXPACKET) {
1772: slp->ns_flag &= ~SLP_GETSTREAM;
1773: return (EPERM);
1774: }
1775: }
1776:
1777: /*
1778: * Now get the record part.
1779: */
1780: if (slp->ns_cc == slp->ns_reclen) {
1781: recm = slp->ns_raw;
1782: slp->ns_raw = slp->ns_rawend = (struct mbuf *)0;
1783: slp->ns_cc = slp->ns_reclen = 0;
1784: } else if (slp->ns_cc > slp->ns_reclen) {
1785: len = 0;
1786: m = slp->ns_raw;
1787: om = (struct mbuf *)0;
1788: while (len < slp->ns_reclen) {
1789: if ((len + m->m_len) > slp->ns_reclen) {
1790: m2 = m_copym(m, 0, slp->ns_reclen - len,
1791: waitflag);
1792: if (m2) {
1793: if (om) {
1794: om->m_next = m2;
1795: recm = slp->ns_raw;
1796: } else
1797: recm = m2;
1798: m->m_data += slp->ns_reclen - len;
1799: m->m_len -= slp->ns_reclen - len;
1800: len = slp->ns_reclen;
1801: } else {
1802: slp->ns_flag &= ~SLP_GETSTREAM;
1803: return (EWOULDBLOCK);
1804: }
1805: } else if ((len + m->m_len) == slp->ns_reclen) {
1806: om = m;
1807: len += m->m_len;
1808: m = m->m_next;
1809: recm = slp->ns_raw;
1810: om->m_next = (struct mbuf *)0;
1811: } else {
1812: om = m;
1813: len += m->m_len;
1814: m = m->m_next;
1815: }
1816: }
1817: slp->ns_raw = m;
1818: slp->ns_cc -= len;
1819: slp->ns_reclen = 0;
1820: } else {
1821: slp->ns_flag &= ~SLP_GETSTREAM;
1822: return (0);
1823: }
1824:
1825: /*
1826: * Accumulate the fragments into a record.
1827: */
1828: mpp = &slp->ns_frag;
1829: while (*mpp)
1830: mpp = &((*mpp)->m_next);
1831: *mpp = recm;
1832: if (slp->ns_flag & SLP_LASTFRAG) {
1833: if (slp->ns_recend)
1834: slp->ns_recend->m_nextpkt = slp->ns_frag;
1835: else
1836: slp->ns_rec = slp->ns_frag;
1837: slp->ns_recend = slp->ns_frag;
1838: slp->ns_frag = (struct mbuf *)0;
1839: }
1840: }
1841: }
1842:
1843: /*
1844: * Parse an RPC header.
1845: */
1846: int
1847: nfsrv_dorec(slp, nfsd, ndp)
1848: register struct nfssvc_sock *slp;
1849: struct nfsd *nfsd;
1850: struct nfsrv_descript **ndp;
1851: {
1852: register struct mbuf *m;
1853: register struct mbuf *nam;
1854: register struct nfsrv_descript *nd;
1855: int error;
1856:
1857: *ndp = NULL;
1858: if ((slp->ns_flag & SLP_VALID) == 0 ||
1859: (m = slp->ns_rec) == (struct mbuf *)0)
1860: return (ENOBUFS);
1861: slp->ns_rec = m->m_nextpkt;
1862: if (slp->ns_rec)
1863: m->m_nextpkt = (struct mbuf *)0;
1864: else
1865: slp->ns_recend = (struct mbuf *)0;
1866: if (m->m_type == MT_SONAME) {
1867: nam = m;
1868: m = m->m_next;
1869: nam->m_next = NULL;
1870: } else
1871: nam = NULL;
1872: MALLOC_ZONE(nd, struct nfsrv_descript *,
1873: sizeof (struct nfsrv_descript), M_NFSRVDESC, M_WAITOK);
1874: nd->nd_md = nd->nd_mrep = m;
1875: nd->nd_nam2 = nam;
1876: nd->nd_dpos = mtod(m, caddr_t);
1877: error = nfs_getreq(nd, nfsd, TRUE);
1878: if (error) {
1879: m_freem(nam);
1880: _FREE_ZONE((caddr_t)nd, sizeof *nd, M_NFSRVDESC);
1881: return (error);
1882: }
1883: *ndp = nd;
1884: nfsd->nfsd_nd = nd;
1885: return (0);
1886: }
1887:
1888: /*
1889: * Parse an RPC request
1890: * - verify it
1891: * - fill in the cred struct.
1892: */
1893: int
1894: nfs_getreq(nd, nfsd, has_header)
1895: register struct nfsrv_descript *nd;
1896: struct nfsd *nfsd;
1897: int has_header;
1898: {
1899: register int len, i;
1900: register u_long *tl;
1901: register long t1;
1902: struct uio uio;
1903: struct iovec iov;
1904: caddr_t dpos, cp2, cp;
1905: u_long nfsvers, auth_type;
1906: uid_t nickuid;
1907: int error = 0, nqnfs = 0, ticklen;
1908: struct mbuf *mrep, *md;
1909: register struct nfsuid *nuidp;
1910: struct timeval tvin, tvout;
1911: #if 0 /* until encrypted keys are implemented */
1912: NFSKERBKEYSCHED_T keys; /* stores key schedule */
1913: #endif
1914:
1915: mrep = nd->nd_mrep;
1916: md = nd->nd_md;
1917: dpos = nd->nd_dpos;
1918: if (has_header) {
1919: nfsm_dissect(tl, u_long *, 10 * NFSX_UNSIGNED);
1920: nd->nd_retxid = fxdr_unsigned(u_long, *tl++);
1921: if (*tl++ != rpc_call) {
1922: m_freem(mrep);
1923: return (EBADRPC);
1924: }
1925: } else
1926: nfsm_dissect(tl, u_long *, 8 * NFSX_UNSIGNED);
1927: nd->nd_repstat = 0;
1928: nd->nd_flag = 0;
1929: if (*tl++ != rpc_vers) {
1930: nd->nd_repstat = ERPCMISMATCH;
1931: nd->nd_procnum = NFSPROC_NOOP;
1932: return (0);
1933: }
1934: if (*tl != nfs_prog) {
1935: if (*tl == nqnfs_prog)
1936: nqnfs++;
1937: else {
1938: nd->nd_repstat = EPROGUNAVAIL;
1939: nd->nd_procnum = NFSPROC_NOOP;
1940: return (0);
1941: }
1942: }
1943: tl++;
1944: nfsvers = fxdr_unsigned(u_long, *tl++);
1945: if (((nfsvers < NFS_VER2 || nfsvers > NFS_VER3) && !nqnfs) ||
1946: (nfsvers != NQNFS_VER3 && nqnfs)) {
1947: nd->nd_repstat = EPROGMISMATCH;
1948: nd->nd_procnum = NFSPROC_NOOP;
1949: return (0);
1950: }
1951: if (nqnfs)
1952: nd->nd_flag = (ND_NFSV3 | ND_NQNFS);
1953: else if (nfsvers == NFS_VER3)
1954: nd->nd_flag = ND_NFSV3;
1955: nd->nd_procnum = fxdr_unsigned(u_long, *tl++);
1956: if (nd->nd_procnum == NFSPROC_NULL)
1957: return (0);
1958: if (nd->nd_procnum >= NFS_NPROCS ||
1959: (!nqnfs && nd->nd_procnum >= NQNFSPROC_GETLEASE) ||
1960: (!nd->nd_flag && nd->nd_procnum > NFSV2PROC_STATFS)) {
1961: nd->nd_repstat = EPROCUNAVAIL;
1962: nd->nd_procnum = NFSPROC_NOOP;
1963: return (0);
1964: }
1965: if ((nd->nd_flag & ND_NFSV3) == 0)
1966: nd->nd_procnum = nfsv3_procid[nd->nd_procnum];
1967: auth_type = *tl++;
1968: len = fxdr_unsigned(int, *tl++);
1969: if (len < 0 || len > RPCAUTH_MAXSIZ) {
1970: m_freem(mrep);
1971: return (EBADRPC);
1972: }
1973:
1974: nd->nd_flag &= ~ND_KERBAUTH;
1975: /*
1976: * Handle auth_unix or auth_kerb.
1977: */
1978: if (auth_type == rpc_auth_unix) {
1979: len = fxdr_unsigned(int, *++tl);
1980: if (len < 0 || len > NFS_MAXNAMLEN) {
1981: m_freem(mrep);
1982: return (EBADRPC);
1983: }
1984: nfsm_adv(nfsm_rndup(len));
1985: nfsm_dissect(tl, u_long *, 3 * NFSX_UNSIGNED);
1986: bzero((caddr_t)&nd->nd_cr, sizeof (struct ucred));
1987: nd->nd_cr.cr_ref = 1;
1988: nd->nd_cr.cr_uid = fxdr_unsigned(uid_t, *tl++);
1989: nd->nd_cr.cr_gid = fxdr_unsigned(gid_t, *tl++);
1990: len = fxdr_unsigned(int, *tl);
1991: if (len < 0 || len > RPCAUTH_UNIXGIDS) {
1992: m_freem(mrep);
1993: return (EBADRPC);
1994: }
1995: nfsm_dissect(tl, u_long *, (len + 2) * NFSX_UNSIGNED);
1996: for (i = 1; i <= len; i++)
1997: if (i < NGROUPS)
1998: nd->nd_cr.cr_groups[i] = fxdr_unsigned(gid_t, *tl++);
1999: else
2000: tl++;
2001: nd->nd_cr.cr_ngroups = (len >= NGROUPS) ? NGROUPS : (len + 1);
2002: if (nd->nd_cr.cr_ngroups > 1)
2003: nfsrvw_sort(nd->nd_cr.cr_groups, nd->nd_cr.cr_ngroups);
2004: len = fxdr_unsigned(int, *++tl);
2005: if (len < 0 || len > RPCAUTH_MAXSIZ) {
2006: m_freem(mrep);
2007: return (EBADRPC);
2008: }
2009: if (len > 0)
2010: nfsm_adv(nfsm_rndup(len));
2011: } else if (auth_type == rpc_auth_kerb) {
2012: switch (fxdr_unsigned(int, *tl++)) {
2013: case RPCAKN_FULLNAME:
2014: ticklen = fxdr_unsigned(int, *tl);
2015: *((u_long *)nfsd->nfsd_authstr) = *tl;
2016: uio.uio_resid = nfsm_rndup(ticklen) + NFSX_UNSIGNED;
2017: nfsd->nfsd_authlen = uio.uio_resid + NFSX_UNSIGNED;
2018: if (uio.uio_resid > (len - 2 * NFSX_UNSIGNED)) {
2019: m_freem(mrep);
2020: return (EBADRPC);
2021: }
2022: uio.uio_offset = 0;
2023: uio.uio_iov = &iov;
2024: uio.uio_iovcnt = 1;
2025: uio.uio_segflg = UIO_SYSSPACE;
2026: iov.iov_base = (caddr_t)&nfsd->nfsd_authstr[4];
2027: iov.iov_len = RPCAUTH_MAXSIZ - 4;
2028: nfsm_mtouio(&uio, uio.uio_resid);
2029: nfsm_dissect(tl, u_long *, 2 * NFSX_UNSIGNED);
2030: if (*tl++ != rpc_auth_kerb ||
2031: fxdr_unsigned(int, *tl) != 4 * NFSX_UNSIGNED) {
2032: printf("Bad kerb verifier\n");
2033: nd->nd_repstat = (NFSERR_AUTHERR|AUTH_BADVERF);
2034: nd->nd_procnum = NFSPROC_NOOP;
2035: return (0);
2036: }
2037: nfsm_dissect(cp, caddr_t, 4 * NFSX_UNSIGNED);
2038: tl = (u_long *)cp;
2039: if (fxdr_unsigned(int, *tl) != RPCAKN_FULLNAME) {
2040: printf("Not fullname kerb verifier\n");
2041: nd->nd_repstat = (NFSERR_AUTHERR|AUTH_BADVERF);
2042: nd->nd_procnum = NFSPROC_NOOP;
2043: return (0);
2044: }
2045: cp += NFSX_UNSIGNED;
2046: bcopy(cp, nfsd->nfsd_verfstr, 3 * NFSX_UNSIGNED);
2047: nfsd->nfsd_verflen = 3 * NFSX_UNSIGNED;
2048: nd->nd_flag |= ND_KERBFULL;
2049: nfsd->nfsd_flag |= NFSD_NEEDAUTH;
2050: break;
2051: case RPCAKN_NICKNAME:
2052: if (len != 2 * NFSX_UNSIGNED) {
2053: printf("Kerb nickname short\n");
2054: nd->nd_repstat = (NFSERR_AUTHERR|AUTH_BADCRED);
2055: nd->nd_procnum = NFSPROC_NOOP;
2056: return (0);
2057: }
2058: nickuid = fxdr_unsigned(uid_t, *tl);
2059: nfsm_dissect(tl, u_long *, 2 * NFSX_UNSIGNED);
2060: if (*tl++ != rpc_auth_kerb ||
2061: fxdr_unsigned(int, *tl) != 3 * NFSX_UNSIGNED) {
2062: printf("Kerb nick verifier bad\n");
2063: nd->nd_repstat = (NFSERR_AUTHERR|AUTH_BADVERF);
2064: nd->nd_procnum = NFSPROC_NOOP;
2065: return (0);
2066: }
2067: nfsm_dissect(tl, u_long *, 3 * NFSX_UNSIGNED);
2068: tvin.tv_sec = *tl++;
2069: tvin.tv_usec = *tl;
2070:
2071: for (nuidp = NUIDHASH(nfsd->nfsd_slp,nickuid)->lh_first;
2072: nuidp != 0; nuidp = nuidp->nu_hash.le_next) {
2073: if (nuidp->nu_cr.cr_uid == nickuid &&
2074: (!nd->nd_nam2 ||
2075: netaddr_match(NU_NETFAM(nuidp),
2076: &nuidp->nu_haddr, nd->nd_nam2)))
2077: break;
2078: }
2079: if (!nuidp) {
2080: nd->nd_repstat =
2081: (NFSERR_AUTHERR|AUTH_REJECTCRED);
2082: nd->nd_procnum = NFSPROC_NOOP;
2083: return (0);
2084: }
2085:
2086: /*
2087: * Now, decrypt the timestamp using the session key
2088: * and validate it.
2089: */
2090: #if NFSKERB
2091: XXX
2092: #endif
2093:
2094: tvout.tv_sec = fxdr_unsigned(long, tvout.tv_sec);
2095: tvout.tv_usec = fxdr_unsigned(long, tvout.tv_usec);
2096: if (nuidp->nu_expire < time.tv_sec ||
2097: nuidp->nu_timestamp.tv_sec > tvout.tv_sec ||
2098: (nuidp->nu_timestamp.tv_sec == tvout.tv_sec &&
2099: nuidp->nu_timestamp.tv_usec > tvout.tv_usec)) {
2100: nuidp->nu_expire = 0;
2101: nd->nd_repstat =
2102: (NFSERR_AUTHERR|AUTH_REJECTVERF);
2103: nd->nd_procnum = NFSPROC_NOOP;
2104: return (0);
2105: }
2106: nfsrv_setcred(&nuidp->nu_cr, &nd->nd_cr);
2107: nd->nd_flag |= ND_KERBNICK;
2108: };
2109: } else {
2110: nd->nd_repstat = (NFSERR_AUTHERR | AUTH_REJECTCRED);
2111: nd->nd_procnum = NFSPROC_NOOP;
2112: return (0);
2113: }
2114:
2115: /*
2116: * For nqnfs, get piggybacked lease request.
2117: */
2118: if (nqnfs && nd->nd_procnum != NQNFSPROC_EVICTED) {
2119: nfsm_dissect(tl, u_long *, NFSX_UNSIGNED);
2120: nd->nd_flag |= fxdr_unsigned(int, *tl);
2121: if (nd->nd_flag & ND_LEASE) {
2122: nfsm_dissect(tl, u_long *, NFSX_UNSIGNED);
2123: nd->nd_duration = fxdr_unsigned(int, *tl);
2124: } else
2125: nd->nd_duration = NQ_MINLEASE;
2126: } else
2127: nd->nd_duration = NQ_MINLEASE;
2128: nd->nd_md = md;
2129: nd->nd_dpos = dpos;
2130: return (0);
2131: nfsmout:
2132: return (error);
2133: }
2134:
2135: /*
2136: * Search for a sleeping nfsd and wake it up.
2137: * SIDE EFFECT: If none found, set NFSD_CHECKSLP flag, so that one of the
2138: * running nfsds will go look for the work in the nfssvc_sock list.
2139: */
2140: void
2141: nfsrv_wakenfsd(slp)
2142: struct nfssvc_sock *slp;
2143: {
2144: register struct nfsd *nd;
2145:
2146: if ((slp->ns_flag & SLP_VALID) == 0)
2147: return;
2148: for (nd = nfsd_head.tqh_first; nd != 0; nd = nd->nfsd_chain.tqe_next) {
2149: if (nd->nfsd_flag & NFSD_WAITING) {
2150: nd->nfsd_flag &= ~NFSD_WAITING;
2151: if (nd->nfsd_slp)
2152: panic("nfsd wakeup");
2153: slp->ns_sref++;
2154: nd->nfsd_slp = slp;
2155: wakeup((caddr_t)nd);
2156: return;
2157: }
2158: }
2159: slp->ns_flag |= SLP_DOREC;
2160: nfsd_head_flag |= NFSD_CHECKSLP;
2161: }
2162: #endif /* NFS_NOSERVER */
2163:
2164: static int
2165: nfs_msg(p, server, msg)
2166: struct proc *p;
2167: char *server, *msg;
2168: {
2169: tpr_t tpr;
2170:
2171: if (p)
2172: tpr = tprintf_open(p);
2173: else
2174: tpr = NULL;
2175: tprintf(tpr, "nfs server %s: %s\n", server, msg);
2176: tprintf_close(tpr);
2177: return (0);
2178: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.