![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to nfs_subs.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / nfs|
Return to nfs_subs.c CVS log | Up to [Net/2] / Net2 / nfs |
1.1 root 1: /*
2: * Copyright (c) 1989 The Regents of the University of California.
3: * All rights reserved.
4: *
5: * This code is derived from software contributed to Berkeley by
6: * Rick Macklem at The University of Guelph.
7: *
8: * Redistribution and use in source and binary forms, with or without
9: * modification, are permitted provided that the following conditions
10: * are met:
11: * 1. Redistributions of source code must retain the above copyright
12: * notice, this list of conditions and the following disclaimer.
13: * 2. Redistributions in binary form must reproduce the above copyright
14: * notice, this list of conditions and the following disclaimer in the
15: * documentation and/or other materials provided with the distribution.
16: * 3. All advertising materials mentioning features or use of this software
17: * must display the following acknowledgement:
18: * This product includes software developed by the University of
19: * California, Berkeley and its contributors.
20: * 4. Neither the name of the University nor the names of its contributors
21: * may be used to endorse or promote products derived from this software
22: * without specific prior written permission.
23: *
24: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34: * SUCH DAMAGE.
35: *
36: * @(#)nfs_subs.c 7.41 (Berkeley) 5/15/91
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 "param.h"
45: #include "proc.h"
46: #include "filedesc.h"
47: #include "systm.h"
48: #include "kernel.h"
49: #include "mount.h"
50: #include "file.h"
51: #include "vnode.h"
52: #include "namei.h"
53: #include "mbuf.h"
54: #include "map.h"
55:
56: #include "../ufs/quota.h"
57: #include "../ufs/inode.h"
58:
59: #include "rpcv2.h"
60: #include "nfsv2.h"
61: #include "nfsnode.h"
62: #include "nfs.h"
63: #include "nfsiom.h"
64: #include "xdr_subs.h"
65: #include "nfsm_subs.h"
66: #include "nfscompress.h"
67:
68: #define TRUE 1
69: #define FALSE 0
70:
71: /*
72: * Data items converted to xdr at startup, since they are constant
73: * This is kinda hokey, but may save a little time doing byte swaps
74: */
75: u_long nfs_procids[NFS_NPROCS];
76: u_long nfs_xdrneg1;
77: u_long rpc_call, rpc_vers, rpc_reply, rpc_msgdenied,
78: rpc_mismatch, rpc_auth_unix, rpc_msgaccepted;
79: u_long nfs_vers, nfs_prog, nfs_true, nfs_false;
80: /* And other global data */
81: static u_long *rpc_uidp = (u_long *)0;
82: static u_long nfs_xid = 1;
83: static char *rpc_unixauth;
84: extern long hostid;
85: enum vtype ntov_type[7] = { VNON, VREG, VDIR, VBLK, VCHR, VLNK, VNON };
86: extern struct proc *nfs_iodwant[NFS_MAXASYNCDAEMON];
87: extern struct map nfsmap[NFS_MSIZ];
88: extern struct nfsreq nfsreqh;
89:
90: /* Function ret types */
91: static char *nfs_unixauth();
92:
93: /*
94: * Maximum number of groups passed through to NFS server.
95: * According to RFC1057 it should be 16.
96: * For release 3.X systems, the maximum value is 8.
97: * For some other servers, the maximum value is 10.
98: */
99: int numgrps = 8;
100:
101: /*
102: * Create the header for an rpc request packet
103: * The function nfs_unixauth() creates a unix style authorization string
104: * and returns a ptr to it.
105: * The hsiz is the size of the rest of the nfs request header.
106: * (just used to decide if a cluster is a good idea)
107: * nb: Note that the prog, vers and procid args are already in xdr byte order
108: */
109: struct mbuf *nfsm_reqh(prog, vers, procid, cred, hsiz, bpos, mb, retxid)
110: u_long prog;
111: u_long vers;
112: u_long procid;
113: struct ucred *cred;
114: int hsiz;
115: caddr_t *bpos;
116: struct mbuf **mb;
117: u_long *retxid;
118: {
119: register struct mbuf *mreq, *m;
120: register u_long *tl;
121: struct mbuf *m1;
122: char *ap;
123: int asiz, siz;
124:
125: NFSMGETHDR(mreq);
126: asiz = ((((cred->cr_ngroups - 1) > numgrps) ? numgrps :
127: (cred->cr_ngroups - 1)) << 2);
128: #ifdef FILLINHOST
129: asiz += nfsm_rndup(hostnamelen)+(9*NFSX_UNSIGNED);
130: #else
131: asiz += 9*NFSX_UNSIGNED;
132: #endif
133:
134: /* If we need a lot, alloc a cluster ?? */
135: if ((asiz+hsiz+RPC_SIZ) > MHLEN)
136: MCLGET(mreq, M_WAIT);
137: mreq->m_len = NFSMSIZ(mreq);
138: siz = mreq->m_len;
139: m1 = mreq;
140: /*
141: * Alloc enough mbufs
142: * We do it now to avoid all sleeps after the call to nfs_unixauth()
143: */
144: while ((asiz+RPC_SIZ) > siz) {
145: MGET(m, M_WAIT, MT_DATA);
146: m1->m_next = m;
147: m->m_len = MLEN;
148: siz += MLEN;
149: m1 = m;
150: }
151: tl = mtod(mreq, u_long *);
152: *tl++ = *retxid = txdr_unsigned(++nfs_xid);
153: *tl++ = rpc_call;
154: *tl++ = rpc_vers;
155: *tl++ = prog;
156: *tl++ = vers;
157: *tl++ = procid;
158:
159: /* Now we can call nfs_unixauth() and copy it in */
160: ap = nfs_unixauth(cred);
161: m = mreq;
162: siz = m->m_len-RPC_SIZ;
163: if (asiz <= siz) {
164: bcopy(ap, (caddr_t)tl, asiz);
165: m->m_len = asiz+RPC_SIZ;
166: } else {
167: bcopy(ap, (caddr_t)tl, siz);
168: ap += siz;
169: asiz -= siz;
170: while (asiz > 0) {
171: siz = (asiz > MLEN) ? MLEN : asiz;
172: m = m->m_next;
173: bcopy(ap, mtod(m, caddr_t), siz);
174: m->m_len = siz;
175: asiz -= siz;
176: ap += siz;
177: }
178: }
179:
180: /* Finally, return values */
181: *mb = m;
182: *bpos = mtod(m, caddr_t)+m->m_len;
183: return (mreq);
184: }
185:
186: /*
187: * copies mbuf chain to the uio scatter/gather list
188: */
189: nfsm_mbuftouio(mrep, uiop, siz, dpos)
190: struct mbuf **mrep;
191: register struct uio *uiop;
192: int siz;
193: caddr_t *dpos;
194: {
195: register char *mbufcp, *uiocp;
196: register int xfer, left, len;
197: register struct mbuf *mp;
198: long uiosiz, rem;
199: int error = 0;
200:
201: mp = *mrep;
202: mbufcp = *dpos;
203: len = mtod(mp, caddr_t)+mp->m_len-mbufcp;
204: rem = nfsm_rndup(siz)-siz;
205: while (siz > 0) {
206: if (uiop->uio_iovcnt <= 0 || uiop->uio_iov == NULL)
207: return (EFBIG);
208: left = uiop->uio_iov->iov_len;
209: uiocp = uiop->uio_iov->iov_base;
210: if (left > siz)
211: left = siz;
212: uiosiz = left;
213: while (left > 0) {
214: while (len == 0) {
215: mp = mp->m_next;
216: if (mp == NULL)
217: return (EBADRPC);
218: mbufcp = mtod(mp, caddr_t);
219: len = mp->m_len;
220: }
221: xfer = (left > len) ? len : left;
222: #ifdef notdef
223: /* Not Yet.. */
224: if (uiop->uio_iov->iov_op != NULL)
225: (*(uiop->uio_iov->iov_op))
226: (mbufcp, uiocp, xfer);
227: else
228: #endif
229: if (uiop->uio_segflg == UIO_SYSSPACE)
230: bcopy(mbufcp, uiocp, xfer);
231: else
232: copyout(mbufcp, uiocp, xfer);
233: left -= xfer;
234: len -= xfer;
235: mbufcp += xfer;
236: uiocp += xfer;
237: uiop->uio_offset += xfer;
238: uiop->uio_resid -= xfer;
239: }
240: if (uiop->uio_iov->iov_len <= siz) {
241: uiop->uio_iovcnt--;
242: uiop->uio_iov++;
243: } else {
244: uiop->uio_iov->iov_base += uiosiz;
245: uiop->uio_iov->iov_len -= uiosiz;
246: }
247: siz -= uiosiz;
248: }
249: *dpos = mbufcp;
250: *mrep = mp;
251: if (rem > 0) {
252: if (len < rem)
253: error = nfs_adv(mrep, dpos, rem, len);
254: else
255: *dpos += rem;
256: }
257: return (error);
258: }
259:
260: /*
261: * copies a uio scatter/gather list to an mbuf chain...
262: */
263: nfsm_uiotombuf(uiop, mq, siz, bpos)
264: register struct uio *uiop;
265: struct mbuf **mq;
266: int siz;
267: caddr_t *bpos;
268: {
269: register char *uiocp;
270: register struct mbuf *mp, *mp2;
271: register int xfer, left, len;
272: int uiosiz, clflg, rem;
273: char *cp;
274:
275: if (siz > MLEN) /* or should it >= MCLBYTES ?? */
276: clflg = 1;
277: else
278: clflg = 0;
279: rem = nfsm_rndup(siz)-siz;
280: mp2 = *mq;
281: while (siz > 0) {
282: if (uiop->uio_iovcnt <= 0 || uiop->uio_iov == NULL)
283: return (EINVAL);
284: left = uiop->uio_iov->iov_len;
285: uiocp = uiop->uio_iov->iov_base;
286: if (left > siz)
287: left = siz;
288: uiosiz = left;
289: while (left > 0) {
290: MGET(mp, M_WAIT, MT_DATA);
291: if (clflg)
292: MCLGET(mp, M_WAIT);
293: mp->m_len = NFSMSIZ(mp);
294: mp2->m_next = mp;
295: mp2 = mp;
296: xfer = (left > mp->m_len) ? mp->m_len : left;
297: #ifdef notdef
298: /* Not Yet.. */
299: if (uiop->uio_iov->iov_op != NULL)
300: (*(uiop->uio_iov->iov_op))
301: (uiocp, mtod(mp, caddr_t), xfer);
302: else
303: #endif
304: if (uiop->uio_segflg == UIO_SYSSPACE)
305: bcopy(uiocp, mtod(mp, caddr_t), xfer);
306: else
307: copyin(uiocp, mtod(mp, caddr_t), xfer);
308: len = mp->m_len;
309: mp->m_len = xfer;
310: left -= xfer;
311: uiocp += xfer;
312: uiop->uio_offset += xfer;
313: uiop->uio_resid -= xfer;
314: }
315: if (uiop->uio_iov->iov_len <= siz) {
316: uiop->uio_iovcnt--;
317: uiop->uio_iov++;
318: } else {
319: uiop->uio_iov->iov_base += uiosiz;
320: uiop->uio_iov->iov_len -= uiosiz;
321: }
322: siz -= uiosiz;
323: }
324: if (rem > 0) {
325: if (rem > (len-mp->m_len)) {
326: MGET(mp, M_WAIT, MT_DATA);
327: mp->m_len = 0;
328: mp2->m_next = mp;
329: }
330: cp = mtod(mp, caddr_t)+mp->m_len;
331: for (left = 0; left < rem; left++)
332: *cp++ = '\0';
333: mp->m_len += rem;
334: *bpos = cp;
335: } else
336: *bpos = mtod(mp, caddr_t)+mp->m_len;
337: *mq = mp;
338: return (0);
339: }
340:
341: /*
342: * Help break down an mbuf chain by setting the first siz bytes contiguous
343: * pointed to by returned val.
344: * If Updateflg == True we can overwrite the first part of the mbuf data
345: * This is used by the macros nfsm_disect and nfsm_disecton for tough
346: * cases. (The macros use the vars. dpos and dpos2)
347: */
348: nfsm_disct(mdp, dposp, siz, left, updateflg, cp2)
349: struct mbuf **mdp;
350: caddr_t *dposp;
351: int siz;
352: int left;
353: int updateflg;
354: caddr_t *cp2;
355: {
356: register struct mbuf *mp, *mp2;
357: register int siz2, xfer;
358: register caddr_t tl;
359:
360: mp = *mdp;
361: while (left == 0) {
362: *mdp = mp = mp->m_next;
363: if (mp == NULL)
364: return (EBADRPC);
365: left = mp->m_len;
366: *dposp = mtod(mp, caddr_t);
367: }
368: if (left >= siz) {
369: *cp2 = *dposp;
370: *dposp += siz;
371: } else if (mp->m_next == NULL) {
372: return (EBADRPC);
373: } else if (siz > MHLEN) {
374: panic("nfs S too big");
375: } else {
376: /* Iff update, you can overwrite, else must alloc new mbuf */
377: if (updateflg) {
378: NFSMINOFF(mp);
379: } else {
380: MGET(mp2, M_WAIT, MT_DATA);
381: mp2->m_next = mp->m_next;
382: mp->m_next = mp2;
383: mp->m_len -= left;
384: mp = mp2;
385: }
386: *cp2 = tl = mtod(mp, caddr_t);
387: bcopy(*dposp, tl, left); /* Copy what was left */
388: siz2 = siz-left;
389: tl += left;
390: mp2 = mp->m_next;
391: /* Loop around copying up the siz2 bytes */
392: while (siz2 > 0) {
393: if (mp2 == NULL)
394: return (EBADRPC);
395: xfer = (siz2 > mp2->m_len) ? mp2->m_len : siz2;
396: if (xfer > 0) {
397: bcopy(mtod(mp2, caddr_t), tl, xfer);
398: NFSMADV(mp2, xfer);
399: mp2->m_len -= xfer;
400: tl += xfer;
401: siz2 -= xfer;
402: }
403: if (siz2 > 0)
404: mp2 = mp2->m_next;
405: }
406: mp->m_len = siz;
407: *mdp = mp2;
408: *dposp = mtod(mp2, caddr_t);
409: }
410: return (0);
411: }
412:
413: /*
414: * Advance the position in the mbuf chain.
415: */
416: nfs_adv(mdp, dposp, offs, left)
417: struct mbuf **mdp;
418: caddr_t *dposp;
419: int offs;
420: int left;
421: {
422: register struct mbuf *m;
423: register int s;
424:
425: m = *mdp;
426: s = left;
427: while (s < offs) {
428: offs -= s;
429: m = m->m_next;
430: if (m == NULL)
431: return (EBADRPC);
432: s = m->m_len;
433: }
434: *mdp = m;
435: *dposp = mtod(m, caddr_t)+offs;
436: return (0);
437: }
438:
439: /*
440: * Copy a string into mbufs for the hard cases...
441: */
442: nfsm_strtmbuf(mb, bpos, cp, siz)
443: struct mbuf **mb;
444: char **bpos;
445: char *cp;
446: long siz;
447: {
448: register struct mbuf *m1, *m2;
449: long left, xfer, len, tlen;
450: u_long *tl;
451: int putsize;
452:
453: putsize = 1;
454: m2 = *mb;
455: left = NFSMSIZ(m2)-m2->m_len;
456: if (left > 0) {
457: tl = ((u_long *)(*bpos));
458: *tl++ = txdr_unsigned(siz);
459: putsize = 0;
460: left -= NFSX_UNSIGNED;
461: m2->m_len += NFSX_UNSIGNED;
462: if (left > 0) {
463: bcopy(cp, (caddr_t) tl, left);
464: siz -= left;
465: cp += left;
466: m2->m_len += left;
467: left = 0;
468: }
469: }
470: /* Loop arround adding mbufs */
471: while (siz > 0) {
472: MGET(m1, M_WAIT, MT_DATA);
473: if (siz > MLEN)
474: MCLGET(m1, M_WAIT);
475: m1->m_len = NFSMSIZ(m1);
476: m2->m_next = m1;
477: m2 = m1;
478: tl = mtod(m1, u_long *);
479: tlen = 0;
480: if (putsize) {
481: *tl++ = txdr_unsigned(siz);
482: m1->m_len -= NFSX_UNSIGNED;
483: tlen = NFSX_UNSIGNED;
484: putsize = 0;
485: }
486: if (siz < m1->m_len) {
487: len = nfsm_rndup(siz);
488: xfer = siz;
489: if (xfer < len)
490: *(tl+(xfer>>2)) = 0;
491: } else {
492: xfer = len = m1->m_len;
493: }
494: bcopy(cp, (caddr_t) tl, xfer);
495: m1->m_len = len+tlen;
496: siz -= xfer;
497: cp += xfer;
498: }
499: *mb = m1;
500: *bpos = mtod(m1, caddr_t)+m1->m_len;
501: return (0);
502: }
503:
504: /*
505: * Called once to initialize data structures...
506: */
507: nfs_init()
508: {
509: register int i;
510:
511: rpc_vers = txdr_unsigned(RPC_VER2);
512: rpc_call = txdr_unsigned(RPC_CALL);
513: rpc_reply = txdr_unsigned(RPC_REPLY);
514: rpc_msgdenied = txdr_unsigned(RPC_MSGDENIED);
515: rpc_msgaccepted = txdr_unsigned(RPC_MSGACCEPTED);
516: rpc_mismatch = txdr_unsigned(RPC_MISMATCH);
517: rpc_auth_unix = txdr_unsigned(RPCAUTH_UNIX);
518: nfs_vers = txdr_unsigned(NFS_VER2);
519: nfs_prog = txdr_unsigned(NFS_PROG);
520: nfs_true = txdr_unsigned(TRUE);
521: nfs_false = txdr_unsigned(FALSE);
522: /* Loop thru nfs procids */
523: for (i = 0; i < NFS_NPROCS; i++)
524: nfs_procids[i] = txdr_unsigned(i);
525: /* Ensure async daemons disabled */
526: for (i = 0; i < NFS_MAXASYNCDAEMON; i++)
527: nfs_iodwant[i] = (struct proc *)0;
528: nfs_xdrneg1 = txdr_unsigned(-1);
529: nfs_nhinit(); /* Init the nfsnode table */
530: nfsrv_initcache(); /* Init the server request cache */
531: rminit(nfsmap, (long)NFS_MAPREG, (long)1, "nfs mapreg", NFS_MSIZ);
532:
533: /*
534: * Initialize reply list and start timer
535: */
536: nfsreqh.r_prev = nfsreqh.r_next = &nfsreqh;
537: nfs_timer();
538: }
539:
540: /*
541: * Fill in the rest of the rpc_unixauth and return it
542: */
543: static char *nfs_unixauth(cr)
544: register struct ucred *cr;
545: {
546: register u_long *tl;
547: register int i;
548: int ngr;
549:
550: /* Maybe someday there should be a cache of AUTH_SHORT's */
551: if ((tl = rpc_uidp) == NULL) {
552: #ifdef FILLINHOST
553: i = nfsm_rndup(hostnamelen)+(25*NFSX_UNSIGNED);
554: #else
555: i = 25*NFSX_UNSIGNED;
556: #endif
557: MALLOC(tl, u_long *, i, M_TEMP, M_WAITOK);
558: bzero((caddr_t)tl, i);
559: rpc_unixauth = (caddr_t)tl;
560: *tl++ = txdr_unsigned(RPCAUTH_UNIX);
561: tl++; /* Fill in size later */
562: *tl++ = hostid;
563: #ifdef FILLINHOST
564: *tl++ = txdr_unsigned(hostnamelen);
565: i = nfsm_rndup(hostnamelen);
566: bcopy(hostname, (caddr_t)tl, hostnamelen);
567: tl += (i>>2);
568: #else
569: *tl++ = 0;
570: #endif
571: rpc_uidp = tl;
572: }
573: *tl++ = txdr_unsigned(cr->cr_uid);
574: *tl++ = txdr_unsigned(cr->cr_groups[0]);
575: ngr = ((cr->cr_ngroups - 1) > numgrps) ? numgrps : (cr->cr_ngroups - 1);
576: *tl++ = txdr_unsigned(ngr);
577: for (i = 1; i <= ngr; i++)
578: *tl++ = txdr_unsigned(cr->cr_groups[i]);
579: /* And add the AUTH_NULL */
580: *tl++ = 0;
581: *tl = 0;
582: i = (((caddr_t)tl)-rpc_unixauth)-12;
583: tl = (u_long *)(rpc_unixauth+4);
584: *tl = txdr_unsigned(i);
585: return (rpc_unixauth);
586: }
587:
588: /*
589: * Attribute cache routines.
590: * nfs_loadattrcache() - loads or updates the cache contents from attributes
591: * that are on the mbuf list
592: * nfs_getattrcache() - returns valid attributes if found in cache, returns
593: * error otherwise
594: */
595:
596: /*
597: * Load the attribute cache (that lives in the nfsnode entry) with
598: * the values on the mbuf list and
599: * Iff vap not NULL
600: * copy the attributes to *vaper
601: */
602: nfs_loadattrcache(vpp, mdp, dposp, vaper)
603: struct vnode **vpp;
604: struct mbuf **mdp;
605: caddr_t *dposp;
606: struct vattr *vaper;
607: {
608: register struct vnode *vp = *vpp;
609: register struct vattr *vap;
610: register struct nfsv2_fattr *fp;
611: extern struct vnodeops spec_nfsv2nodeops;
612: register struct nfsnode *np;
613: register long t1;
614: caddr_t dpos, cp2;
615: int error = 0;
616: struct mbuf *md;
617: enum vtype type;
618: u_short mode;
619: long rdev;
620: struct timeval mtime;
621: struct vnode *nvp;
622:
623: md = *mdp;
624: dpos = *dposp;
625: t1 = (mtod(md, caddr_t)+md->m_len)-dpos;
626: if (error = nfsm_disct(&md, &dpos, NFSX_FATTR, t1, TRUE, &cp2))
627: return (error);
628: fp = (struct nfsv2_fattr *)cp2;
629: type = nfstov_type(fp->fa_type);
630: mode = fxdr_unsigned(u_short, fp->fa_mode);
631: if (type == VNON)
632: type = IFTOVT(mode);
633: rdev = fxdr_unsigned(long, fp->fa_rdev);
634: fxdr_time(&fp->fa_mtime, &mtime);
635: /*
636: * If v_type == VNON it is a new node, so fill in the v_type,
637: * n_mtime fields. Check to see if it represents a special
638: * device, and if so, check for a possible alias. Once the
639: * correct vnode has been obtained, fill in the rest of the
640: * information.
641: */
642: np = VTONFS(vp);
643: if (vp->v_type == VNON) {
644: if (type == VCHR && rdev == 0xffffffff)
645: vp->v_type = type = VFIFO;
646: else
647: vp->v_type = type;
648: if (vp->v_type == VFIFO) {
649: #ifdef FIFO
650: extern struct vnodeops fifo_nfsv2nodeops;
651: vp->v_op = &fifo_nfsv2nodeops;
652: #else
653: return (EOPNOTSUPP);
654: #endif /* FIFO */
655: }
656: if (vp->v_type == VCHR || vp->v_type == VBLK) {
657: vp->v_op = &spec_nfsv2nodeops;
658: if (nvp = checkalias(vp, (dev_t)rdev, vp->v_mount)) {
659: /*
660: * Reinitialize aliased node.
661: */
662: np = VTONFS(nvp);
663: np->n_vnode = nvp;
664: np->n_flag = 0;
665: nfs_lock(nvp);
666: bcopy((caddr_t)&VTONFS(vp)->n_fh,
667: (caddr_t)&np->n_fh, NFSX_FH);
668: insque(np, nfs_hash(&np->n_fh));
669: np->n_attrstamp = 0;
670: np->n_sillyrename = (struct sillyrename *)0;
671: /*
672: * Discard unneeded vnode and update actual one
673: */
674: vput(vp);
675: *vpp = nvp;
676: }
677: }
678: np->n_mtime = mtime.tv_sec;
679: }
680: vap = &np->n_vattr;
681: vap->va_type = type;
682: vap->va_mode = (mode & 07777);
683: vap->va_nlink = fxdr_unsigned(u_short, fp->fa_nlink);
684: vap->va_uid = fxdr_unsigned(uid_t, fp->fa_uid);
685: vap->va_gid = fxdr_unsigned(gid_t, fp->fa_gid);
686: vap->va_size = fxdr_unsigned(u_long, fp->fa_size);
687: if ((np->n_flag & NMODIFIED) == 0 || vap->va_size > np->n_size) {
688: np->n_size = vap->va_size;
689: vnode_pager_setsize(vp, np->n_size);
690: }
691: vap->va_size_rsv = 0;
692: vap->va_blocksize = fxdr_unsigned(long, fp->fa_blocksize);
693: vap->va_rdev = (dev_t)rdev;
694: vap->va_bytes = fxdr_unsigned(long, fp->fa_blocks) * NFS_FABLKSIZE;
695: vap->va_bytes_rsv = 0;
696: vap->va_fsid = vp->v_mount->mnt_stat.f_fsid.val[0];
697: vap->va_fileid = fxdr_unsigned(long, fp->fa_fileid);
698: vap->va_atime.tv_sec = fxdr_unsigned(long, fp->fa_atime.tv_sec);
699: vap->va_atime.tv_usec = 0;
700: vap->va_flags = fxdr_unsigned(u_long, fp->fa_atime.tv_usec);
701: vap->va_mtime = mtime;
702: vap->va_ctime.tv_sec = fxdr_unsigned(long, fp->fa_ctime.tv_sec);
703: vap->va_ctime.tv_usec = 0;
704: vap->va_gen = fxdr_unsigned(u_long, fp->fa_ctime.tv_usec);
705: np->n_attrstamp = time.tv_sec;
706: *dposp = dpos;
707: *mdp = md;
708: if (vaper != NULL) {
709: bcopy((caddr_t)vap, (caddr_t)vaper, sizeof(*vap));
710: if ((np->n_flag & NMODIFIED) && (np->n_size > vap->va_size))
711: vaper->va_size = np->n_size;
712: }
713: return (0);
714: }
715:
716: /*
717: * Check the time stamp
718: * If the cache is valid, copy contents to *vap and return 0
719: * otherwise return an error
720: */
721: nfs_getattrcache(vp, vap)
722: register struct vnode *vp;
723: struct vattr *vap;
724: {
725: register struct nfsnode *np;
726:
727: np = VTONFS(vp);
728: if ((time.tv_sec-np->n_attrstamp) < NFS_ATTRTIMEO) {
729: nfsstats.attrcache_hits++;
730: bcopy((caddr_t)&np->n_vattr,(caddr_t)vap,sizeof(struct vattr));
731: if ((np->n_flag & NMODIFIED) == 0) {
732: np->n_size = vap->va_size;
733: vnode_pager_setsize(vp, np->n_size);
734: } else if (np->n_size > vap->va_size)
735: vap->va_size = np->n_size;
736: return (0);
737: } else {
738: nfsstats.attrcache_misses++;
739: return (ENOENT);
740: }
741: }
742:
743: /*
744: * Set up nameidata for a namei() call and do it
745: */
746: nfs_namei(ndp, fhp, len, mdp, dposp, p)
747: register struct nameidata *ndp;
748: fhandle_t *fhp;
749: int len;
750: struct mbuf **mdp;
751: caddr_t *dposp;
752: struct proc *p;
753: {
754: register int i, rem;
755: register struct mbuf *md;
756: register char *fromcp, *tocp;
757: struct vnode *dp;
758: int flag;
759: int error;
760:
761: flag = ndp->ni_nameiop & OPMASK;
762: MALLOC(ndp->ni_pnbuf, char *, len + 1, M_NAMEI, M_WAITOK);
763: /*
764: * Copy the name from the mbuf list to ndp->ni_pnbuf
765: * and set the various ndp fields appropriately.
766: */
767: fromcp = *dposp;
768: tocp = ndp->ni_pnbuf;
769: md = *mdp;
770: rem = mtod(md, caddr_t) + md->m_len - fromcp;
771: ndp->ni_hash = 0;
772: for (i = 0; i < len; i++) {
773: while (rem == 0) {
774: md = md->m_next;
775: if (md == NULL) {
776: error = EBADRPC;
777: goto out;
778: }
779: fromcp = mtod(md, caddr_t);
780: rem = md->m_len;
781: }
782: if (*fromcp == '\0' || *fromcp == '/') {
783: error = EINVAL;
784: goto out;
785: }
786: if (*fromcp & 0200)
787: if ((*fromcp&0377) == ('/'|0200) || flag != DELETE) {
788: error = EINVAL;
789: goto out;
790: }
791: ndp->ni_hash += (unsigned char)*fromcp;
792: *tocp++ = *fromcp++;
793: rem--;
794: }
795: *tocp = '\0';
796: *mdp = md;
797: *dposp = fromcp;
798: len = nfsm_rndup(len)-len;
799: if (len > 0) {
800: if (rem >= len)
801: *dposp += len;
802: else if (error = nfs_adv(mdp, dposp, len, rem))
803: goto out;
804: }
805: ndp->ni_pathlen = tocp - ndp->ni_pnbuf;
806: ndp->ni_ptr = ndp->ni_pnbuf;
807: /*
808: * Extract and set starting directory.
809: */
810: if (error = nfsrv_fhtovp(fhp, FALSE, &dp, ndp->ni_cred))
811: goto out;
812: if (dp->v_type != VDIR) {
813: vrele(dp);
814: error = ENOTDIR;
815: goto out;
816: }
817: ndp->ni_startdir = dp;
818: ndp->ni_nameiop |= (NOCROSSMOUNT | REMOTE);
819: /*
820: * And call lookup() to do the real work
821: */
822: if (error = lookup(ndp, p))
823: goto out;
824: /*
825: * Check for encountering a symbolic link
826: */
827: if (ndp->ni_more) {
828: if ((ndp->ni_nameiop & LOCKPARENT) && ndp->ni_pathlen == 1)
829: vput(ndp->ni_dvp);
830: else
831: vrele(ndp->ni_dvp);
832: vput(ndp->ni_vp);
833: ndp->ni_vp = NULL;
834: error = EINVAL;
835: goto out;
836: }
837: /*
838: * Check for saved name request
839: */
840: if (ndp->ni_nameiop & (SAVENAME | SAVESTART)) {
841: ndp->ni_nameiop |= HASBUF;
842: return (0);
843: }
844: out:
845: FREE(ndp->ni_pnbuf, M_NAMEI);
846: return (error);
847: }
848:
849: /*
850: * A fiddled version of m_adj() that ensures null fill to a long
851: * boundary and only trims off the back end
852: */
853: nfsm_adj(mp, len, nul)
854: struct mbuf *mp;
855: register int len;
856: int nul;
857: {
858: register struct mbuf *m;
859: register int count, i;
860: register char *cp;
861:
862: /*
863: * Trim from tail. Scan the mbuf chain,
864: * calculating its length and finding the last mbuf.
865: * If the adjustment only affects this mbuf, then just
866: * adjust and return. Otherwise, rescan and truncate
867: * after the remaining size.
868: */
869: count = 0;
870: m = mp;
871: for (;;) {
872: count += m->m_len;
873: if (m->m_next == (struct mbuf *)0)
874: break;
875: m = m->m_next;
876: }
877: if (m->m_len > len) {
878: m->m_len -= len;
879: if (nul > 0) {
880: cp = mtod(m, caddr_t)+m->m_len-nul;
881: for (i = 0; i < nul; i++)
882: *cp++ = '\0';
883: }
884: return;
885: }
886: count -= len;
887: if (count < 0)
888: count = 0;
889: /*
890: * Correct length for chain is "count".
891: * Find the mbuf with last data, adjust its length,
892: * and toss data from remaining mbufs on chain.
893: */
894: for (m = mp; m; m = m->m_next) {
895: if (m->m_len >= count) {
896: m->m_len = count;
897: if (nul > 0) {
898: cp = mtod(m, caddr_t)+m->m_len-nul;
899: for (i = 0; i < nul; i++)
900: *cp++ = '\0';
901: }
902: break;
903: }
904: count -= m->m_len;
905: }
906: while (m = m->m_next)
907: m->m_len = 0;
908: }
909:
910: /*
911: * nfsrv_fhtovp() - convert a fh to a vnode ptr (optionally locked)
912: * - look up fsid in mount list (if not found ret error)
913: * - check that it is exported
914: * - get vp by calling VFS_FHTOVP() macro
915: * - if not lockflag unlock it with VOP_UNLOCK()
916: * - if cred->cr_uid == 0 set it to m_exroot
917: */
918: nfsrv_fhtovp(fhp, lockflag, vpp, cred)
919: fhandle_t *fhp;
920: int lockflag;
921: struct vnode **vpp;
922: struct ucred *cred;
923: {
924: register struct mount *mp;
925:
926: if ((mp = getvfs(&fhp->fh_fsid)) == NULL)
927: return (ESTALE);
928: if ((mp->mnt_flag & MNT_EXPORTED) == 0)
929: return (EACCES);
930: if (VFS_FHTOVP(mp, &fhp->fh_fid, vpp))
931: return (ESTALE);
932: if (cred->cr_uid == 0)
933: cred->cr_uid = mp->mnt_exroot;
934: if (!lockflag)
935: VOP_UNLOCK(*vpp);
936: return (0);
937: }
938:
939: /*
940: * These two functions implement nfs rpc compression.
941: * The algorithm is a trivial run length encoding of '\0' bytes. The high
942: * order nibble of hex "e" is or'd with the number of zeroes - 2 in four
943: * bits. (2 - 17 zeros) Any data byte with a high order nibble of hex "e"
944: * is byte stuffed.
945: * The compressed data is padded with 0x0 bytes to an even multiple of
946: * 4 bytes in length to avoid any weird long pointer alignments.
947: * If compression/uncompression is unsuccessful, the original mbuf list
948: * is returned.
949: * The first four bytes (the XID) are left uncompressed and the fifth
950: * byte is set to 0x1 for request and 0x2 for reply.
951: * An uncompressed RPC will always have the fifth byte == 0x0.
952: */
953: struct mbuf *
954: nfs_compress(m0)
955: struct mbuf *m0;
956: {
957: register u_char ch, nextch;
958: register int i, rlelast;
959: register u_char *ip, *op;
960: register int ileft, oleft, noteof;
961: register struct mbuf *m, *om;
962: struct mbuf **mp, *retm;
963: int olen, clget;
964:
965: i = rlelast = 0;
966: noteof = 1;
967: m = m0;
968: if (m->m_len < 12)
969: return (m0);
970: if (m->m_pkthdr.len >= MINCLSIZE)
971: clget = 1;
972: else
973: clget = 0;
974: ileft = m->m_len - 9;
975: ip = mtod(m, u_char *);
976: MGETHDR(om, M_WAIT, MT_DATA);
977: if (clget)
978: MCLGET(om, M_WAIT);
979: retm = om;
980: mp = &om->m_next;
981: olen = om->m_len = 5;
982: oleft = M_TRAILINGSPACE(om);
983: op = mtod(om, u_char *);
984: *((u_long *)op) = *((u_long *)ip);
985: ip += 7;
986: op += 4;
987: *op++ = *ip++ + 1;
988: nextch = *ip++;
989: while (noteof) {
990: ch = nextch;
991: if (ileft == 0) {
992: do {
993: m = m->m_next;
994: } while (m && m->m_len == 0);
995: if (m) {
996: ileft = m->m_len;
997: ip = mtod(m, u_char *);
998: } else {
999: noteof = 0;
1000: nextch = 0x1;
1001: goto doit;
1002: }
1003: }
1004: nextch = *ip++;
1005: ileft--;
1006: doit:
1007: if (ch == '\0') {
1008: if (++i == NFSC_MAX || nextch != '\0') {
1009: if (i < 2) {
1010: nfscput('\0');
1011: } else {
1012: if (rlelast == i) {
1013: nfscput('\0');
1014: i--;
1015: }
1016: if (NFSCRLE(i) == (nextch & 0xff)) {
1017: i--;
1018: if (i < 2) {
1019: nfscput('\0');
1020: } else {
1021: nfscput(NFSCRLE(i));
1022: }
1023: nfscput('\0');
1024: rlelast = 0;
1025: } else {
1026: nfscput(NFSCRLE(i));
1027: rlelast = i;
1028: }
1029: }
1030: i = 0;
1031: }
1032: } else {
1033: if ((ch & NFSCRL) == NFSCRL) {
1034: nfscput(ch);
1035: }
1036: nfscput(ch);
1037: i = rlelast = 0;
1038: }
1039: }
1040: if (olen < m0->m_pkthdr.len) {
1041: m_freem(m0);
1042: if (i = (olen & 0x3)) {
1043: i = 4 - i;
1044: while (i-- > 0) {
1045: nfscput('\0');
1046: }
1047: }
1048: retm->m_pkthdr.len = olen;
1049: retm->m_pkthdr.rcvif = (struct ifnet *)0;
1050: return (retm);
1051: } else {
1052: m_freem(retm);
1053: return (m0);
1054: }
1055: }
1056:
1057: struct mbuf *
1058: nfs_uncompress(m0)
1059: struct mbuf *m0;
1060: {
1061: register u_char cp, nextcp, *ip, *op;
1062: register struct mbuf *m, *om;
1063: struct mbuf *retm, **mp;
1064: int i, j, noteof, clget, ileft, oleft, olen;
1065:
1066: m = m0;
1067: i = 0;
1068: while (m && i < MINCLSIZE) {
1069: i += m->m_len;
1070: m = m->m_next;
1071: }
1072: if (i < 6)
1073: return (m0);
1074: if (i >= MINCLSIZE)
1075: clget = 1;
1076: else
1077: clget = 0;
1078: m = m0;
1079: MGET(om, M_WAIT, MT_DATA);
1080: if (clget)
1081: MCLGET(om, M_WAIT);
1082: olen = om->m_len = 8;
1083: oleft = M_TRAILINGSPACE(om);
1084: op = mtod(om, u_char *);
1085: retm = om;
1086: mp = &om->m_next;
1087: if (m->m_len >= 6) {
1088: ileft = m->m_len - 6;
1089: ip = mtod(m, u_char *);
1090: *((u_long *)op) = *((u_long *)ip);
1091: bzero(op + 4, 3);
1092: ip += 4;
1093: op += 7;
1094: if (*ip == '\0') {
1095: m_freem(om);
1096: return (m0);
1097: }
1098: *op++ = *ip++ - 1;
1099: cp = *ip++;
1100: } else {
1101: ileft = m->m_len;
1102: ip = mtod(m, u_char *);
1103: nfscget(*op++);
1104: nfscget(*op++);
1105: nfscget(*op++);
1106: nfscget(*op++);
1107: bzero(op, 3);
1108: op += 3;
1109: nfscget(*op);
1110: if (*op == '\0') {
1111: m_freem(om);
1112: return (m0);
1113: }
1114: (*op)--;
1115: op++;
1116: nfscget(cp);
1117: }
1118: noteof = 1;
1119: while (noteof) {
1120: if ((cp & NFSCRL) == NFSCRL) {
1121: nfscget(nextcp);
1122: if (cp == nextcp) {
1123: nfscput(cp);
1124: goto readit;
1125: } else {
1126: i = (cp & 0xf) + 2;
1127: for (j = 0; j < i; j++) {
1128: nfscput('\0');
1129: }
1130: cp = nextcp;
1131: }
1132: } else {
1133: nfscput(cp);
1134: readit:
1135: nfscget(cp);
1136: }
1137: }
1138: m_freem(m0);
1139: if (i = (olen & 0x3))
1140: om->m_len -= i;
1141: return (retm);
1142: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.