![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to nfs_serv.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_serv.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_serv.c 7.40 (Berkeley) 5/15/91
37: */
38:
39: /*
40: * nfs version 2 server calls to vnode ops
41: * - these routines generally have 3 phases
42: * 1 - break down and validate rpc request in mbuf list
43: * 2 - do the vnode ops for the request
44: * (surprisingly ?? many are very similar to syscalls in vfs_syscalls.c)
45: * 3 - build the rpc reply in an mbuf list
46: * nb:
47: * - do not mix the phases, since the nfsm_?? macros can return failures
48: * on a bad rpc or similar and do not do any vrele() or vput()'s
49: *
50: * - the nfsm_reply() macro generates an nfs rpc reply with the nfs
51: * error number iff error != 0 whereas
52: * returning an error from the server function implies a fatal error
53: * such as a badly constructed rpc request that should be dropped without
54: * a reply.
55: */
56:
57: #include "param.h"
58: #include "proc.h"
59: #include "file.h"
60: #include "namei.h"
61: #include "vnode.h"
62: #include "mount.h"
63: #include "mbuf.h"
64:
65: #include "../ufs/quota.h"
66: #include "../ufs/inode.h"
67: #include "../ufs/dir.h"
68:
69: #include "nfsv2.h"
70: #include "nfs.h"
71: #include "xdr_subs.h"
72: #include "nfsm_subs.h"
73:
74: /* Defs */
75: #define TRUE 1
76: #define FALSE 0
77:
78: /* Global vars */
79: extern u_long nfs_procids[NFS_NPROCS];
80: extern u_long nfs_xdrneg1;
81: extern u_long nfs_false, nfs_true;
82: nfstype nfs_type[9]={ NFNON, NFREG, NFDIR, NFBLK, NFCHR, NFLNK, NFNON,
83: NFCHR, NFNON };
84:
85: /*
86: * nfs getattr service
87: */
88: nfsrv_getattr(mrep, md, dpos, cred, xid, mrq, repstat, p)
89: struct mbuf **mrq;
90: struct mbuf *mrep, *md;
91: caddr_t dpos;
92: struct ucred *cred;
93: u_long xid;
94: int *repstat;
95: struct proc *p;
96: {
97: register struct nfsv2_fattr *fp;
98: struct vattr va;
99: register struct vattr *vap = &va;
100: struct vnode *vp;
101: nfsv2fh_t nfh;
102: fhandle_t *fhp;
103: register u_long *tl;
104: register long t1;
105: caddr_t bpos;
106: int error = 0;
107: char *cp2;
108: struct mbuf *mb, *mb2, *mreq;
109:
110: fhp = &nfh.fh_generic;
111: nfsm_srvmtofh(fhp);
112: if (error = nfsrv_fhtovp(fhp, TRUE, &vp, cred))
113: nfsm_reply(0);
114: error = VOP_GETATTR(vp, vap, cred, p);
115: vput(vp);
116: nfsm_reply(NFSX_FATTR);
117: nfsm_build(fp, struct nfsv2_fattr *, NFSX_FATTR);
118: nfsm_srvfillattr;
119: nfsm_srvdone;
120: }
121:
122: /*
123: * nfs setattr service
124: */
125: nfsrv_setattr(mrep, md, dpos, cred, xid, mrq, repstat, p)
126: struct mbuf **mrq;
127: struct mbuf *mrep, *md;
128: caddr_t dpos;
129: struct ucred *cred;
130: u_long xid;
131: int *repstat;
132: struct proc *p;
133: {
134: struct vattr va;
135: register struct vattr *vap = &va;
136: register struct nfsv2_sattr *sp;
137: register struct nfsv2_fattr *fp;
138: struct vnode *vp;
139: nfsv2fh_t nfh;
140: fhandle_t *fhp;
141: register u_long *tl;
142: register long t1;
143: caddr_t bpos;
144: int error = 0;
145: char *cp2;
146: struct mbuf *mb, *mb2, *mreq;
147:
148: fhp = &nfh.fh_generic;
149: nfsm_srvmtofh(fhp);
150: nfsm_disect(sp, struct nfsv2_sattr *, NFSX_SATTR);
151: if (error = nfsrv_fhtovp(fhp, TRUE, &vp, cred))
152: nfsm_reply(0);
153: if (error = nfsrv_access(vp, VWRITE, cred, p))
154: goto out;
155: VATTR_NULL(vap);
156: /*
157: * Nah nah nah nah na nah
158: * There is a bug in the Sun client that puts 0xffff in the mode
159: * field of sattr when it should put in 0xffffffff. The u_short
160: * doesn't sign extend.
161: * --> check the low order 2 bytes for 0xffff
162: */
163: if ((fxdr_unsigned(int, sp->sa_mode) & 0xffff) != 0xffff)
164: vap->va_mode = nfstov_mode(sp->sa_mode);
165: if (sp->sa_uid != nfs_xdrneg1)
166: vap->va_uid = fxdr_unsigned(uid_t, sp->sa_uid);
167: if (sp->sa_gid != nfs_xdrneg1)
168: vap->va_gid = fxdr_unsigned(gid_t, sp->sa_gid);
169: if (sp->sa_size != nfs_xdrneg1)
170: vap->va_size = fxdr_unsigned(u_long, sp->sa_size);
171: /*
172: * The usec field of sa_atime is overloaded with the va_flags field
173: * for 4.4BSD clients. Hopefully other clients always set both the
174: * sec and usec fields to -1 when not setting the atime.
175: */
176: if (sp->sa_atime.tv_sec != nfs_xdrneg1) {
177: vap->va_atime.tv_sec = fxdr_unsigned(long, sp->sa_atime.tv_sec);
178: vap->va_atime.tv_usec = 0;
179: }
180: if (sp->sa_atime.tv_usec != nfs_xdrneg1)
181: vap->va_flags = fxdr_unsigned(u_long, sp->sa_atime.tv_usec);
182: if (sp->sa_mtime.tv_sec != nfs_xdrneg1)
183: fxdr_time(&sp->sa_mtime, &vap->va_mtime);
184: if (error = VOP_SETATTR(vp, vap, cred, p)) {
185: vput(vp);
186: nfsm_reply(0);
187: }
188: error = VOP_GETATTR(vp, vap, cred, p);
189: out:
190: vput(vp);
191: nfsm_reply(NFSX_FATTR);
192: nfsm_build(fp, struct nfsv2_fattr *, NFSX_FATTR);
193: nfsm_srvfillattr;
194: nfsm_srvdone;
195: }
196:
197: /*
198: * nfs lookup rpc
199: */
200: nfsrv_lookup(mrep, md, dpos, cred, xid, mrq, repstat, p)
201: struct mbuf **mrq;
202: struct mbuf *mrep, *md;
203: caddr_t dpos;
204: struct ucred *cred;
205: u_long xid;
206: int *repstat;
207: struct proc *p;
208: {
209: register struct nfsv2_fattr *fp;
210: struct nameidata nd;
211: struct vnode *vp;
212: nfsv2fh_t nfh;
213: fhandle_t *fhp;
214: register caddr_t cp;
215: register u_long *tl;
216: register long t1;
217: caddr_t bpos;
218: int error = 0;
219: char *cp2;
220: struct mbuf *mb, *mb2, *mreq;
221: long len;
222: struct vattr va, *vap = &va;
223:
224: fhp = &nfh.fh_generic;
225: nfsm_srvmtofh(fhp);
226: nfsm_srvstrsiz(len, NFS_MAXNAMLEN);
227: nd.ni_cred = cred;
228: nd.ni_nameiop = LOOKUP | LOCKLEAF;
229: if (error = nfs_namei(&nd, fhp, len, &md, &dpos, p))
230: nfsm_reply(0);
231: vp = nd.ni_vp;
232: bzero((caddr_t)fhp, sizeof(nfh));
233: fhp->fh_fsid = vp->v_mount->mnt_stat.f_fsid;
234: if (error = VFS_VPTOFH(vp, &fhp->fh_fid)) {
235: vput(vp);
236: nfsm_reply(0);
237: }
238: error = VOP_GETATTR(vp, vap, cred, p);
239: vput(vp);
240: nfsm_reply(NFSX_FH+NFSX_FATTR);
241: nfsm_srvfhtom(fhp);
242: nfsm_build(fp, struct nfsv2_fattr *, NFSX_FATTR);
243: nfsm_srvfillattr;
244: nfsm_srvdone;
245: }
246:
247: /*
248: * nfs readlink service
249: */
250: nfsrv_readlink(mrep, md, dpos, cred, xid, mrq, repstat, p)
251: struct mbuf **mrq;
252: struct mbuf *mrep, *md;
253: caddr_t dpos;
254: struct ucred *cred;
255: u_long xid;
256: int *repstat;
257: struct proc *p;
258: {
259: struct iovec iv[(NFS_MAXPATHLEN+MLEN-1)/MLEN];
260: register struct iovec *ivp = iv;
261: register struct mbuf *mp;
262: register u_long *tl;
263: register long t1;
264: caddr_t bpos;
265: int error = 0;
266: char *cp2;
267: struct mbuf *mb, *mb2, *mp2, *mp3, *mreq;
268: struct vnode *vp;
269: nfsv2fh_t nfh;
270: fhandle_t *fhp;
271: struct uio io, *uiop = &io;
272: int i, tlen, len;
273:
274: fhp = &nfh.fh_generic;
275: nfsm_srvmtofh(fhp);
276: len = 0;
277: i = 0;
278: while (len < NFS_MAXPATHLEN) {
279: MGET(mp, M_WAIT, MT_DATA);
280: MCLGET(mp, M_WAIT);
281: mp->m_len = NFSMSIZ(mp);
282: if (len == 0)
283: mp3 = mp2 = mp;
284: else {
285: mp2->m_next = mp;
286: mp2 = mp;
287: }
288: if ((len+mp->m_len) > NFS_MAXPATHLEN) {
289: mp->m_len = NFS_MAXPATHLEN-len;
290: len = NFS_MAXPATHLEN;
291: } else
292: len += mp->m_len;
293: ivp->iov_base = mtod(mp, caddr_t);
294: ivp->iov_len = mp->m_len;
295: i++;
296: ivp++;
297: }
298: uiop->uio_iov = iv;
299: uiop->uio_iovcnt = i;
300: uiop->uio_offset = 0;
301: uiop->uio_resid = len;
302: uiop->uio_rw = UIO_READ;
303: uiop->uio_segflg = UIO_SYSSPACE;
304: uiop->uio_procp = (struct proc *)0;
305: if (error = nfsrv_fhtovp(fhp, TRUE, &vp, cred)) {
306: m_freem(mp3);
307: nfsm_reply(0);
308: }
309: if (vp->v_type != VLNK) {
310: error = EINVAL;
311: goto out;
312: }
313: error = VOP_READLINK(vp, uiop, cred);
314: out:
315: vput(vp);
316: if (error)
317: m_freem(mp3);
318: nfsm_reply(NFSX_UNSIGNED);
319: if (uiop->uio_resid > 0) {
320: len -= uiop->uio_resid;
321: tlen = nfsm_rndup(len);
322: nfsm_adj(mp3, NFS_MAXPATHLEN-tlen, tlen-len);
323: }
324: nfsm_build(tl, u_long *, NFSX_UNSIGNED);
325: *tl = txdr_unsigned(len);
326: mb->m_next = mp3;
327: nfsm_srvdone;
328: }
329:
330: /*
331: * nfs read service
332: */
333: nfsrv_read(mrep, md, dpos, cred, xid, mrq, repstat, p)
334: struct mbuf **mrq;
335: struct mbuf *mrep, *md;
336: caddr_t dpos;
337: struct ucred *cred;
338: u_long xid;
339: int *repstat;
340: struct proc *p;
341: {
342: register struct iovec *iv;
343: struct iovec *iv2;
344: register struct mbuf *m;
345: register struct nfsv2_fattr *fp;
346: register u_long *tl;
347: register long t1;
348: caddr_t bpos;
349: int error = 0;
350: char *cp2;
351: struct mbuf *mb, *mb2, *mreq;
352: struct mbuf *m2, *m3;
353: struct vnode *vp;
354: nfsv2fh_t nfh;
355: fhandle_t *fhp;
356: struct uio io, *uiop = &io;
357: struct vattr va, *vap = &va;
358: int i, cnt, len, left, siz, tlen;
359: off_t off;
360:
361: fhp = &nfh.fh_generic;
362: nfsm_srvmtofh(fhp);
363: nfsm_disect(tl, u_long *, NFSX_UNSIGNED);
364: off = fxdr_unsigned(off_t, *tl);
365: nfsm_srvstrsiz(cnt, NFS_MAXDATA);
366: if (error = nfsrv_fhtovp(fhp, TRUE, &vp, cred))
367: nfsm_reply(0);
368: if (error = nfsrv_access(vp, VREAD | VEXEC, cred, p)) {
369: vput(vp);
370: nfsm_reply(0);
371: }
372: len = left = cnt;
373: /*
374: * Generate the mbuf list with the uio_iov ref. to it.
375: */
376: i = 0;
377: m3 = (struct mbuf *)0;
378: #ifdef lint
379: m2 = (struct mbuf *)0;
380: #endif /* lint */
381: MALLOC(iv, struct iovec *,
382: ((NFS_MAXDATA+MLEN-1)/MLEN) * sizeof (struct iovec), M_TEMP,
383: M_WAITOK);
384: iv2 = iv;
385: while (left > 0) {
386: MGET(m, M_WAIT, MT_DATA);
387: if (left > MINCLSIZE)
388: MCLGET(m, M_WAIT);
389: m->m_len = 0;
390: siz = min(M_TRAILINGSPACE(m), left);
391: m->m_len = siz;
392: iv->iov_base = mtod(m, caddr_t);
393: iv->iov_len = siz;
394: iv++;
395: i++;
396: left -= siz;
397: if (m3) {
398: m2->m_next = m;
399: m2 = m;
400: } else
401: m3 = m2 = m;
402: }
403: uiop->uio_iov = iv2;
404: uiop->uio_iovcnt = i;
405: uiop->uio_offset = off;
406: uiop->uio_resid = cnt;
407: uiop->uio_rw = UIO_READ;
408: uiop->uio_segflg = UIO_SYSSPACE;
409: uiop->uio_procp = (struct proc *)0;
410: error = VOP_READ(vp, uiop, IO_NODELOCKED, cred);
411: off = uiop->uio_offset;
412: FREE((caddr_t)iv2, M_TEMP);
413: if (error) {
414: m_freem(m3);
415: vput(vp);
416: nfsm_reply(0);
417: }
418: if (error = VOP_GETATTR(vp, vap, cred, p))
419: m_freem(m3);
420: vput(vp);
421: nfsm_reply(NFSX_FATTR+NFSX_UNSIGNED);
422: nfsm_build(fp, struct nfsv2_fattr *, NFSX_FATTR);
423: nfsm_srvfillattr;
424: len -= uiop->uio_resid;
425: if (len > 0) {
426: tlen = nfsm_rndup(len);
427: if (cnt != tlen || tlen != len)
428: nfsm_adj(m3, cnt-tlen, tlen-len);
429: } else {
430: m_freem(m3);
431: m3 = (struct mbuf *)0;
432: }
433: nfsm_build(tl, u_long *, NFSX_UNSIGNED);
434: *tl = txdr_unsigned(len);
435: mb->m_next = m3;
436: nfsm_srvdone;
437: }
438:
439: /*
440: * nfs write service
441: */
442: nfsrv_write(mrep, md, dpos, cred, xid, mrq, repstat, p)
443: struct mbuf *mrep, *md, **mrq;
444: caddr_t dpos;
445: struct ucred *cred;
446: u_long xid;
447: int *repstat;
448: struct proc *p;
449: {
450: register struct iovec *ivp;
451: register struct mbuf *mp;
452: register struct nfsv2_fattr *fp;
453: struct iovec iv[NFS_MAXIOVEC];
454: struct vattr va;
455: register struct vattr *vap = &va;
456: register u_long *tl;
457: register long t1;
458: caddr_t bpos;
459: int error = 0;
460: char *cp2;
461: struct mbuf *mb, *mb2, *mreq;
462: struct vnode *vp;
463: nfsv2fh_t nfh;
464: fhandle_t *fhp;
465: struct uio io, *uiop = &io;
466: off_t off;
467: long siz, len, xfer;
468:
469: fhp = &nfh.fh_generic;
470: nfsm_srvmtofh(fhp);
471: nfsm_disect(tl, u_long *, 4*NFSX_UNSIGNED);
472: off = fxdr_unsigned(off_t, *++tl);
473: tl += 2;
474: len = fxdr_unsigned(long, *tl);
475: if (len > NFS_MAXDATA || len <= 0) {
476: error = EBADRPC;
477: nfsm_reply(0);
478: }
479: if (dpos == (mtod(md, caddr_t)+md->m_len)) {
480: mp = md->m_next;
481: if (mp == NULL) {
482: error = EBADRPC;
483: nfsm_reply(0);
484: }
485: } else {
486: mp = md;
487: siz = dpos-mtod(mp, caddr_t);
488: mp->m_len -= siz;
489: NFSMADV(mp, siz);
490: }
491: if (error = nfsrv_fhtovp(fhp, TRUE, &vp, cred))
492: nfsm_reply(0);
493: if (error = nfsrv_access(vp, VWRITE, cred, p)) {
494: vput(vp);
495: nfsm_reply(0);
496: }
497: uiop->uio_resid = 0;
498: uiop->uio_rw = UIO_WRITE;
499: uiop->uio_segflg = UIO_SYSSPACE;
500: uiop->uio_procp = (struct proc *)0;
501: /*
502: * Do up to NFS_MAXIOVEC mbufs of write each iteration of the
503: * loop until done.
504: */
505: while (len > 0 && uiop->uio_resid == 0) {
506: ivp = iv;
507: siz = 0;
508: uiop->uio_iov = ivp;
509: uiop->uio_iovcnt = 0;
510: uiop->uio_offset = off;
511: while (len > 0 && uiop->uio_iovcnt < NFS_MAXIOVEC && mp != NULL) {
512: ivp->iov_base = mtod(mp, caddr_t);
513: if (len < mp->m_len)
514: ivp->iov_len = xfer = len;
515: else
516: ivp->iov_len = xfer = mp->m_len;
517: #ifdef notdef
518: /* Not Yet .. */
519: if (M_HASCL(mp) && (((u_long)ivp->iov_base) & CLOFSET) == 0)
520: ivp->iov_op = NULL; /* what should it be ?? */
521: else
522: ivp->iov_op = NULL;
523: #endif
524: uiop->uio_iovcnt++;
525: ivp++;
526: len -= xfer;
527: siz += xfer;
528: mp = mp->m_next;
529: }
530: if (len > 0 && mp == NULL) {
531: error = EBADRPC;
532: vput(vp);
533: nfsm_reply(0);
534: }
535: uiop->uio_resid = siz;
536: if (error = VOP_WRITE(vp, uiop, IO_SYNC | IO_NODELOCKED,
537: cred)) {
538: vput(vp);
539: nfsm_reply(0);
540: }
541: off = uiop->uio_offset;
542: }
543: error = VOP_GETATTR(vp, vap, cred, p);
544: vput(vp);
545: nfsm_reply(NFSX_FATTR);
546: nfsm_build(fp, struct nfsv2_fattr *, NFSX_FATTR);
547: nfsm_srvfillattr;
548: nfsm_srvdone;
549: }
550:
551: /*
552: * nfs create service
553: * now does a truncate to 0 length via. setattr if it already exists
554: */
555: nfsrv_create(mrep, md, dpos, cred, xid, mrq, repstat, p)
556: struct mbuf *mrep, *md, **mrq;
557: caddr_t dpos;
558: struct ucred *cred;
559: u_long xid;
560: int *repstat;
561: struct proc *p;
562: {
563: register struct nfsv2_fattr *fp;
564: struct vattr va;
565: register struct vattr *vap = &va;
566: struct nameidata nd;
567: register caddr_t cp;
568: register u_long *tl;
569: register long t1;
570: caddr_t bpos;
571: long rdev;
572: int error = 0;
573: char *cp2;
574: struct mbuf *mb, *mb2, *mreq;
575: struct vnode *vp;
576: nfsv2fh_t nfh;
577: fhandle_t *fhp;
578: long len;
579:
580: nd.ni_nameiop = 0;
581: fhp = &nfh.fh_generic;
582: nfsm_srvmtofh(fhp);
583: nfsm_srvstrsiz(len, NFS_MAXNAMLEN);
584: nd.ni_cred = cred;
585: nd.ni_nameiop = CREATE | LOCKPARENT | LOCKLEAF | SAVESTART;
586: if (error = nfs_namei(&nd, fhp, len, &md, &dpos, p))
587: nfsm_reply(0);
588: VATTR_NULL(vap);
589: nfsm_disect(tl, u_long *, NFSX_SATTR);
590: /*
591: * Iff doesn't exist, create it
592: * otherwise just truncate to 0 length
593: * should I set the mode too ??
594: */
595: if (nd.ni_vp == NULL) {
596: vap->va_type = IFTOVT(fxdr_unsigned(u_long, *tl));
597: if (vap->va_type == VNON)
598: vap->va_type = VREG;
599: vap->va_mode = nfstov_mode(*tl);
600: rdev = fxdr_unsigned(long, *(tl+3));
601: if (vap->va_type == VREG || vap->va_type == VSOCK) {
602: vrele(nd.ni_startdir);
603: if (error = VOP_CREATE(&nd, vap, p))
604: nfsm_reply(0);
605: FREE(nd.ni_pnbuf, M_NAMEI);
606: } else if (vap->va_type == VCHR || vap->va_type == VBLK ||
607: vap->va_type == VFIFO) {
608: if (vap->va_type == VCHR && rdev == 0xffffffff)
609: vap->va_type = VFIFO;
610: if (vap->va_type == VFIFO) {
611: #ifndef FIFO
612: VOP_ABORTOP(&nd);
613: vput(nd.ni_dvp);
614: error = ENXIO;
615: goto out;
616: #endif /* FIFO */
617: } else if (error = suser(cred, (short *)0)) {
618: VOP_ABORTOP(&nd);
619: vput(nd.ni_dvp);
620: goto out;
621: } else
622: vap->va_rdev = (dev_t)rdev;
623: if (error = VOP_MKNOD(&nd, vap, cred, p)) {
624: vrele(nd.ni_startdir);
625: nfsm_reply(0);
626: }
627: nd.ni_nameiop &= ~(OPMASK | LOCKPARENT | SAVESTART);
628: nd.ni_nameiop |= LOOKUP;
629: if (error = lookup(&nd, p)) {
630: free(nd.ni_pnbuf, M_NAMEI);
631: nfsm_reply(0);
632: }
633: FREE(nd.ni_pnbuf, M_NAMEI);
634: if (nd.ni_more) {
635: vrele(nd.ni_dvp);
636: vput(nd.ni_vp);
637: VOP_ABORTOP(&nd);
638: error = EINVAL;
639: nfsm_reply(0);
640: }
641: } else {
642: VOP_ABORTOP(&nd);
643: vput(nd.ni_dvp);
644: error = ENXIO;
645: goto out;
646: }
647: vp = nd.ni_vp;
648: } else {
649: vrele(nd.ni_startdir);
650: free(nd.ni_pnbuf, M_NAMEI);
651: vp = nd.ni_vp;
652: if (nd.ni_dvp == vp)
653: vrele(nd.ni_dvp);
654: else
655: vput(nd.ni_dvp);
656: VOP_ABORTOP(&nd);
657: vap->va_size = 0;
658: if (error = VOP_SETATTR(vp, vap, cred, p)) {
659: vput(vp);
660: nfsm_reply(0);
661: }
662: }
663: bzero((caddr_t)fhp, sizeof(nfh));
664: fhp->fh_fsid = vp->v_mount->mnt_stat.f_fsid;
665: if (error = VFS_VPTOFH(vp, &fhp->fh_fid)) {
666: vput(vp);
667: nfsm_reply(0);
668: }
669: error = VOP_GETATTR(vp, vap, cred, p);
670: vput(vp);
671: nfsm_reply(NFSX_FH+NFSX_FATTR);
672: nfsm_srvfhtom(fhp);
673: nfsm_build(fp, struct nfsv2_fattr *, NFSX_FATTR);
674: nfsm_srvfillattr;
675: return (error);
676: nfsmout:
677: if (nd.ni_nameiop)
678: vrele(nd.ni_startdir);
679: VOP_ABORTOP(&nd);
680: if (nd.ni_dvp == nd.ni_vp)
681: vrele(nd.ni_dvp);
682: else
683: vput(nd.ni_dvp);
684: if (nd.ni_vp)
685: vput(nd.ni_vp);
686: return (error);
687:
688: out:
689: vrele(nd.ni_startdir);
690: free(nd.ni_pnbuf, M_NAMEI);
691: nfsm_reply(0);
692: }
693:
694: /*
695: * nfs remove service
696: */
697: nfsrv_remove(mrep, md, dpos, cred, xid, mrq, repstat, p)
698: struct mbuf *mrep, *md, **mrq;
699: caddr_t dpos;
700: struct ucred *cred;
701: u_long xid;
702: int *repstat;
703: struct proc *p;
704: {
705: struct nameidata nd;
706: register u_long *tl;
707: register long t1;
708: caddr_t bpos;
709: int error = 0;
710: char *cp2;
711: struct mbuf *mb, *mreq;
712: struct vnode *vp;
713: nfsv2fh_t nfh;
714: fhandle_t *fhp;
715: long len;
716:
717: fhp = &nfh.fh_generic;
718: nfsm_srvmtofh(fhp);
719: nfsm_srvstrsiz(len, NFS_MAXNAMLEN);
720: nd.ni_cred = cred;
721: nd.ni_nameiop = DELETE | LOCKPARENT | LOCKLEAF;
722: if (error = nfs_namei(&nd, fhp, len, &md, &dpos, p))
723: nfsm_reply(0);
724: vp = nd.ni_vp;
725: if (vp->v_type == VDIR &&
726: (error = suser(cred, (short *)0)))
727: goto out;
728: /*
729: * The root of a mounted filesystem cannot be deleted.
730: */
731: if (vp->v_flag & VROOT) {
732: error = EBUSY;
733: goto out;
734: }
735: if (vp->v_flag & VTEXT)
736: (void) vnode_pager_uncache(vp);
737: out:
738: if (!error) {
739: error = VOP_REMOVE(&nd, p);
740: } else {
741: VOP_ABORTOP(&nd);
742: if (nd.ni_dvp == vp)
743: vrele(nd.ni_dvp);
744: else
745: vput(nd.ni_dvp);
746: vput(vp);
747: }
748: nfsm_reply(0);
749: nfsm_srvdone;
750: }
751:
752: /*
753: * nfs rename service
754: */
755: nfsrv_rename(mrep, md, dpos, cred, xid, mrq, repstat, p)
756: struct mbuf *mrep, *md, **mrq;
757: caddr_t dpos;
758: struct ucred *cred;
759: u_long xid;
760: int *repstat;
761: struct proc *p;
762: {
763: register u_long *tl;
764: register long t1;
765: caddr_t bpos;
766: int error = 0;
767: char *cp2;
768: struct mbuf *mb, *mreq;
769: struct nameidata fromnd, tond;
770: struct vnode *fvp, *tvp, *tdvp;
771: nfsv2fh_t fnfh, tnfh;
772: fhandle_t *ffhp, *tfhp;
773: long len, len2;
774: int rootflg = 0;
775:
776: ffhp = &fnfh.fh_generic;
777: tfhp = &tnfh.fh_generic;
778: fromnd.ni_nameiop = 0;
779: tond.ni_nameiop = 0;
780: nfsm_srvmtofh(ffhp);
781: nfsm_srvstrsiz(len, NFS_MAXNAMLEN);
782: /*
783: * Remember if we are root so that we can reset cr_uid before
784: * the second nfs_namei() call
785: */
786: if (cred->cr_uid == 0)
787: rootflg++;
788: fromnd.ni_cred = cred;
789: fromnd.ni_nameiop = DELETE | WANTPARENT | SAVESTART;
790: if (error = nfs_namei(&fromnd, ffhp, len, &md, &dpos, p))
791: nfsm_reply(0);
792: fvp = fromnd.ni_vp;
793: nfsm_srvmtofh(tfhp);
794: nfsm_strsiz(len2, NFS_MAXNAMLEN);
795: if (rootflg)
796: cred->cr_uid = 0;
797: tond.ni_cred = cred;
798: tond.ni_nameiop = RENAME | LOCKPARENT | LOCKLEAF | NOCACHE
799: | SAVESTART;
800: if (error = nfs_namei(&tond, tfhp, len2, &md, &dpos, p)) {
801: VOP_ABORTOP(&fromnd);
802: vrele(fromnd.ni_dvp);
803: vrele(fvp);
804: goto out1;
805: }
806: tdvp = tond.ni_dvp;
807: tvp = tond.ni_vp;
808: if (tvp != NULL) {
809: if (fvp->v_type == VDIR && tvp->v_type != VDIR) {
810: error = EISDIR;
811: goto out;
812: } else if (fvp->v_type != VDIR && tvp->v_type == VDIR) {
813: error = ENOTDIR;
814: goto out;
815: }
816: }
817: if (fvp->v_mount != tdvp->v_mount) {
818: error = EXDEV;
819: goto out;
820: }
821: if (fvp == tdvp)
822: error = EINVAL;
823: /*
824: * If source is the same as the destination (that is the
825: * same vnode with the same name in the same directory),
826: * then there is nothing to do.
827: */
828: if (fvp == tvp && fromnd.ni_dvp == tdvp &&
829: fromnd.ni_namelen == tond.ni_namelen &&
830: !bcmp(fromnd.ni_ptr, tond.ni_ptr, fromnd.ni_namelen))
831: error = -1;
832: out:
833: if (!error) {
834: error = VOP_RENAME(&fromnd, &tond, p);
835: } else {
836: VOP_ABORTOP(&tond);
837: if (tdvp == tvp)
838: vrele(tdvp);
839: else
840: vput(tdvp);
841: if (tvp)
842: vput(tvp);
843: VOP_ABORTOP(&fromnd);
844: vrele(fromnd.ni_dvp);
845: vrele(fvp);
846: }
847: vrele(tond.ni_startdir);
848: FREE(tond.ni_pnbuf, M_NAMEI);
849: out1:
850: vrele(fromnd.ni_startdir);
851: FREE(fromnd.ni_pnbuf, M_NAMEI);
852: nfsm_reply(0);
853: return (error);
854:
855: nfsmout:
856: if (tond.ni_nameiop) {
857: vrele(tond.ni_startdir);
858: FREE(tond.ni_pnbuf, M_NAMEI);
859: }
860: if (fromnd.ni_nameiop) {
861: vrele(fromnd.ni_startdir);
862: FREE(fromnd.ni_pnbuf, M_NAMEI);
863: VOP_ABORTOP(&fromnd);
864: vrele(fromnd.ni_dvp);
865: vrele(fvp);
866: }
867: return (error);
868: }
869:
870: /*
871: * nfs link service
872: */
873: nfsrv_link(mrep, md, dpos, cred, xid, mrq, repstat, p)
874: struct mbuf *mrep, *md, **mrq;
875: caddr_t dpos;
876: struct ucred *cred;
877: u_long xid;
878: int *repstat;
879: struct proc *p;
880: {
881: struct nameidata nd;
882: register u_long *tl;
883: register long t1;
884: caddr_t bpos;
885: int error = 0;
886: char *cp2;
887: struct mbuf *mb, *mreq;
888: struct vnode *vp, *xp;
889: nfsv2fh_t nfh, dnfh;
890: fhandle_t *fhp, *dfhp;
891: long len;
892:
893: fhp = &nfh.fh_generic;
894: dfhp = &dnfh.fh_generic;
895: nfsm_srvmtofh(fhp);
896: nfsm_srvmtofh(dfhp);
897: nfsm_srvstrsiz(len, NFS_MAXNAMLEN);
898: if (error = nfsrv_fhtovp(fhp, FALSE, &vp, cred))
899: nfsm_reply(0);
900: if (vp->v_type == VDIR && (error = suser(cred, NULL)))
901: goto out1;
902: nd.ni_cred = cred;
903: nd.ni_nameiop = CREATE | LOCKPARENT;
904: if (error = nfs_namei(&nd, dfhp, len, &md, &dpos, p))
905: goto out1;
906: xp = nd.ni_vp;
907: if (xp != NULL) {
908: error = EEXIST;
909: goto out;
910: }
911: xp = nd.ni_dvp;
912: if (vp->v_mount != xp->v_mount)
913: error = EXDEV;
914: out:
915: if (!error) {
916: error = VOP_LINK(vp, &nd, p);
917: } else {
918: VOP_ABORTOP(&nd);
919: if (nd.ni_dvp == nd.ni_vp)
920: vrele(nd.ni_dvp);
921: else
922: vput(nd.ni_dvp);
923: if (nd.ni_vp)
924: vrele(nd.ni_vp);
925: }
926: out1:
927: vrele(vp);
928: nfsm_reply(0);
929: nfsm_srvdone;
930: }
931:
932: /*
933: * nfs symbolic link service
934: */
935: nfsrv_symlink(mrep, md, dpos, cred, xid, mrq, repstat, p)
936: struct mbuf *mrep, *md, **mrq;
937: caddr_t dpos;
938: struct ucred *cred;
939: u_long xid;
940: int *repstat;
941: struct proc *p;
942: {
943: struct vattr va;
944: struct nameidata nd;
945: register struct vattr *vap = &va;
946: register u_long *tl;
947: register long t1;
948: struct nfsv2_sattr *sp;
949: caddr_t bpos;
950: struct uio io;
951: struct iovec iv;
952: int error = 0;
953: char *pathcp, *cp2;
954: struct mbuf *mb, *mreq;
955: nfsv2fh_t nfh;
956: fhandle_t *fhp;
957: long len, len2;
958:
959: pathcp = (char *)0;
960: fhp = &nfh.fh_generic;
961: nfsm_srvmtofh(fhp);
962: nfsm_srvstrsiz(len, NFS_MAXNAMLEN);
963: nd.ni_cred = cred;
964: nd.ni_nameiop = CREATE | LOCKPARENT;
965: if (error = nfs_namei(&nd, fhp, len, &md, &dpos, p))
966: goto out;
967: nfsm_strsiz(len2, NFS_MAXPATHLEN);
968: MALLOC(pathcp, caddr_t, len2 + 1, M_TEMP, M_WAITOK);
969: iv.iov_base = pathcp;
970: iv.iov_len = len2;
971: io.uio_resid = len2;
972: io.uio_offset = 0;
973: io.uio_iov = &iv;
974: io.uio_iovcnt = 1;
975: io.uio_segflg = UIO_SYSSPACE;
976: io.uio_rw = UIO_READ;
977: io.uio_procp = (struct proc *)0;
978: nfsm_mtouio(&io, len2);
979: nfsm_disect(sp, struct nfsv2_sattr *, NFSX_SATTR);
980: *(pathcp + len2) = '\0';
981: if (nd.ni_vp) {
982: VOP_ABORTOP(&nd);
983: if (nd.ni_dvp == nd.ni_vp)
984: vrele(nd.ni_dvp);
985: else
986: vput(nd.ni_dvp);
987: vrele(nd.ni_vp);
988: error = EEXIST;
989: goto out;
990: }
991: VATTR_NULL(vap);
992: vap->va_mode = fxdr_unsigned(u_short, sp->sa_mode);
993: error = VOP_SYMLINK(&nd, vap, pathcp, p);
994: out:
995: if (pathcp)
996: FREE(pathcp, M_TEMP);
997: nfsm_reply(0);
998: return (error);
999: nfsmout:
1000: VOP_ABORTOP(&nd);
1001: if (nd.ni_dvp == nd.ni_vp)
1002: vrele(nd.ni_dvp);
1003: else
1004: vput(nd.ni_dvp);
1005: if (nd.ni_vp)
1006: vrele(nd.ni_vp);
1007: if (pathcp)
1008: FREE(pathcp, M_TEMP);
1009: return (error);
1010: }
1011:
1012: /*
1013: * nfs mkdir service
1014: */
1015: nfsrv_mkdir(mrep, md, dpos, cred, xid, mrq, repstat, p)
1016: struct mbuf *mrep, *md, **mrq;
1017: caddr_t dpos;
1018: struct ucred *cred;
1019: u_long xid;
1020: int *repstat;
1021: struct proc *p;
1022: {
1023: struct vattr va;
1024: register struct vattr *vap = &va;
1025: register struct nfsv2_fattr *fp;
1026: struct nameidata nd;
1027: register caddr_t cp;
1028: register u_long *tl;
1029: register long t1;
1030: caddr_t bpos;
1031: int error = 0;
1032: char *cp2;
1033: struct mbuf *mb, *mb2, *mreq;
1034: struct vnode *vp;
1035: nfsv2fh_t nfh;
1036: fhandle_t *fhp;
1037: long len;
1038:
1039: fhp = &nfh.fh_generic;
1040: nfsm_srvmtofh(fhp);
1041: nfsm_srvstrsiz(len, NFS_MAXNAMLEN);
1042: nd.ni_cred = cred;
1043: nd.ni_nameiop = CREATE | LOCKPARENT;
1044: if (error = nfs_namei(&nd, fhp, len, &md, &dpos, p))
1045: nfsm_reply(0);
1046: nfsm_disect(tl, u_long *, NFSX_UNSIGNED);
1047: VATTR_NULL(vap);
1048: vap->va_type = VDIR;
1049: vap->va_mode = nfstov_mode(*tl++);
1050: vp = nd.ni_vp;
1051: if (vp != NULL) {
1052: VOP_ABORTOP(&nd);
1053: if (nd.ni_dvp == vp)
1054: vrele(nd.ni_dvp);
1055: else
1056: vput(nd.ni_dvp);
1057: vrele(vp);
1058: error = EEXIST;
1059: nfsm_reply(0);
1060: }
1061: if (error = VOP_MKDIR(&nd, vap, p))
1062: nfsm_reply(0);
1063: vp = nd.ni_vp;
1064: bzero((caddr_t)fhp, sizeof(nfh));
1065: fhp->fh_fsid = vp->v_mount->mnt_stat.f_fsid;
1066: if (error = VFS_VPTOFH(vp, &fhp->fh_fid)) {
1067: vput(vp);
1068: nfsm_reply(0);
1069: }
1070: error = VOP_GETATTR(vp, vap, cred, p);
1071: vput(vp);
1072: nfsm_reply(NFSX_FH+NFSX_FATTR);
1073: nfsm_srvfhtom(fhp);
1074: nfsm_build(fp, struct nfsv2_fattr *, NFSX_FATTR);
1075: nfsm_srvfillattr;
1076: return (error);
1077: nfsmout:
1078: VOP_ABORTOP(&nd);
1079: if (nd.ni_dvp == nd.ni_vp)
1080: vrele(nd.ni_dvp);
1081: else
1082: vput(nd.ni_dvp);
1083: if (nd.ni_vp)
1084: vrele(nd.ni_vp);
1085: return (error);
1086: }
1087:
1088: /*
1089: * nfs rmdir service
1090: */
1091: nfsrv_rmdir(mrep, md, dpos, cred, xid, mrq, repstat, p)
1092: struct mbuf *mrep, *md, **mrq;
1093: caddr_t dpos;
1094: struct ucred *cred;
1095: u_long xid;
1096: int *repstat;
1097: struct proc *p;
1098: {
1099: register u_long *tl;
1100: register long t1;
1101: caddr_t bpos;
1102: int error = 0;
1103: char *cp2;
1104: struct mbuf *mb, *mreq;
1105: struct vnode *vp;
1106: nfsv2fh_t nfh;
1107: fhandle_t *fhp;
1108: long len;
1109: struct nameidata nd;
1110:
1111: fhp = &nfh.fh_generic;
1112: nfsm_srvmtofh(fhp);
1113: nfsm_srvstrsiz(len, NFS_MAXNAMLEN);
1114: nd.ni_cred = cred;
1115: nd.ni_nameiop = DELETE | LOCKPARENT | LOCKLEAF;
1116: if (error = nfs_namei(&nd, fhp, len, &md, &dpos, p))
1117: nfsm_reply(0);
1118: vp = nd.ni_vp;
1119: if (vp->v_type != VDIR) {
1120: error = ENOTDIR;
1121: goto out;
1122: }
1123: /*
1124: * No rmdir "." please.
1125: */
1126: if (nd.ni_dvp == vp) {
1127: error = EINVAL;
1128: goto out;
1129: }
1130: /*
1131: * The root of a mounted filesystem cannot be deleted.
1132: */
1133: if (vp->v_flag & VROOT)
1134: error = EBUSY;
1135: out:
1136: if (!error) {
1137: error = VOP_RMDIR(&nd, p);
1138: } else {
1139: VOP_ABORTOP(&nd);
1140: if (nd.ni_dvp == nd.ni_vp)
1141: vrele(nd.ni_dvp);
1142: else
1143: vput(nd.ni_dvp);
1144: vput(vp);
1145: }
1146: nfsm_reply(0);
1147: nfsm_srvdone;
1148: }
1149:
1150: /*
1151: * nfs readdir service
1152: * - mallocs what it thinks is enough to read
1153: * count rounded up to a multiple of NFS_DIRBLKSIZ <= NFS_MAXREADDIR
1154: * - calls VOP_READDIR()
1155: * - loops around building the reply
1156: * if the output generated exceeds count break out of loop
1157: * The nfsm_clget macro is used here so that the reply will be packed
1158: * tightly in mbuf clusters.
1159: * - it only knows that it has encountered eof when the VOP_READDIR()
1160: * reads nothing
1161: * - as such one readdir rpc will return eof false although you are there
1162: * and then the next will return eof
1163: * - it trims out records with d_ino == 0
1164: * this doesn't matter for Unix clients, but they might confuse clients
1165: * for other os'.
1166: * NB: It is tempting to set eof to true if the VOP_READDIR() reads less
1167: * than requested, but this may not apply to all filesystems. For
1168: * example, client NFS does not { although it is never remote mounted
1169: * anyhow }
1170: * PS: The NFS protocol spec. does not clarify what the "count" byte
1171: * argument is a count of.. just name strings and file id's or the
1172: * entire reply rpc or ...
1173: * I tried just file name and id sizes and it confused the Sun client,
1174: * so I am using the full rpc size now. The "paranoia.." comment refers
1175: * to including the status longwords that are not a part of the dir.
1176: * "entry" structures, but are in the rpc.
1177: */
1178: nfsrv_readdir(mrep, md, dpos, cred, xid, mrq, repstat, p)
1179: struct mbuf **mrq;
1180: struct mbuf *mrep, *md;
1181: caddr_t dpos;
1182: struct ucred *cred;
1183: u_long xid;
1184: int *repstat;
1185: struct proc *p;
1186: {
1187: register char *bp, *be;
1188: register struct mbuf *mp;
1189: register struct direct *dp;
1190: register caddr_t cp;
1191: register u_long *tl;
1192: register long t1;
1193: caddr_t bpos;
1194: int error = 0;
1195: char *cp2;
1196: struct mbuf *mb, *mb2, *mreq;
1197: char *cpos, *cend;
1198: int len, nlen, rem, xfer, tsiz, i;
1199: struct vnode *vp;
1200: struct mbuf *mp2, *mp3;
1201: nfsv2fh_t nfh;
1202: fhandle_t *fhp;
1203: struct uio io;
1204: struct iovec iv;
1205: int siz, cnt, fullsiz, eofflag;
1206: u_long on;
1207: char *rbuf;
1208: off_t off, toff;
1209:
1210: fhp = &nfh.fh_generic;
1211: nfsm_srvmtofh(fhp);
1212: nfsm_disect(tl, u_long *, 2*NFSX_UNSIGNED);
1213: toff = fxdr_unsigned(off_t, *tl++);
1214: off = (toff & ~(NFS_DIRBLKSIZ-1));
1215: on = (toff & (NFS_DIRBLKSIZ-1));
1216: cnt = fxdr_unsigned(int, *tl);
1217: siz = ((cnt+NFS_DIRBLKSIZ-1) & ~(NFS_DIRBLKSIZ-1));
1218: if (cnt > NFS_MAXREADDIR)
1219: siz = NFS_MAXREADDIR;
1220: fullsiz = siz;
1221: if (error = nfsrv_fhtovp(fhp, TRUE, &vp, cred))
1222: nfsm_reply(0);
1223: if (error = nfsrv_access(vp, VEXEC, cred, p)) {
1224: vput(vp);
1225: nfsm_reply(0);
1226: }
1227: VOP_UNLOCK(vp);
1228: MALLOC(rbuf, caddr_t, siz, M_TEMP, M_WAITOK);
1229: again:
1230: iv.iov_base = rbuf;
1231: iv.iov_len = fullsiz;
1232: io.uio_iov = &iv;
1233: io.uio_iovcnt = 1;
1234: io.uio_offset = off;
1235: io.uio_resid = fullsiz;
1236: io.uio_segflg = UIO_SYSSPACE;
1237: io.uio_rw = UIO_READ;
1238: io.uio_procp = (struct proc *)0;
1239: error = VOP_READDIR(vp, &io, cred, &eofflag);
1240: off = io.uio_offset;
1241: if (error) {
1242: vrele(vp);
1243: free((caddr_t)rbuf, M_TEMP);
1244: nfsm_reply(0);
1245: }
1246: if (io.uio_resid) {
1247: siz -= io.uio_resid;
1248:
1249: /*
1250: * If nothing read, return eof
1251: * rpc reply
1252: */
1253: if (siz == 0) {
1254: vrele(vp);
1255: nfsm_reply(2*NFSX_UNSIGNED);
1256: nfsm_build(tl, u_long *, 2*NFSX_UNSIGNED);
1257: *tl++ = nfs_false;
1258: *tl = nfs_true;
1259: FREE((caddr_t)rbuf, M_TEMP);
1260: return (0);
1261: }
1262: }
1263:
1264: /*
1265: * Check for degenerate cases of nothing useful read.
1266: * If so go try again
1267: */
1268: cpos = rbuf + on;
1269: cend = rbuf + siz;
1270: dp = (struct direct *)cpos;
1271: while (cpos < cend && dp->d_ino == 0) {
1272: cpos += dp->d_reclen;
1273: dp = (struct direct *)cpos;
1274: }
1275: if (cpos >= cend) {
1276: toff = off;
1277: siz = fullsiz;
1278: on = 0;
1279: goto again;
1280: }
1281:
1282: cpos = rbuf + on;
1283: cend = rbuf + siz;
1284: dp = (struct direct *)cpos;
1285: vrele(vp);
1286: len = 3*NFSX_UNSIGNED; /* paranoia, probably can be 0 */
1287: bp = be = (caddr_t)0;
1288: mp3 = (struct mbuf *)0;
1289: nfsm_reply(siz);
1290:
1291: /* Loop through the records and build reply */
1292: while (cpos < cend) {
1293: if (dp->d_ino != 0) {
1294: nlen = dp->d_namlen;
1295: rem = nfsm_rndup(nlen)-nlen;
1296:
1297: /*
1298: * As noted above, the NFS spec. is not clear about what
1299: * should be included in "count" as totalled up here in
1300: * "len".
1301: */
1302: len += (4*NFSX_UNSIGNED+nlen+rem);
1303: if (len > cnt) {
1304: eofflag = 0;
1305: break;
1306: }
1307:
1308: /* Build the directory record xdr from the direct entry */
1309: nfsm_clget;
1310: *tl = nfs_true;
1311: bp += NFSX_UNSIGNED;
1312: nfsm_clget;
1313: *tl = txdr_unsigned(dp->d_ino);
1314: bp += NFSX_UNSIGNED;
1315: nfsm_clget;
1316: *tl = txdr_unsigned(nlen);
1317: bp += NFSX_UNSIGNED;
1318:
1319: /* And loop arround copying the name */
1320: xfer = nlen;
1321: cp = dp->d_name;
1322: while (xfer > 0) {
1323: nfsm_clget;
1324: if ((bp+xfer) > be)
1325: tsiz = be-bp;
1326: else
1327: tsiz = xfer;
1328: bcopy(cp, bp, tsiz);
1329: bp += tsiz;
1330: xfer -= tsiz;
1331: if (xfer > 0)
1332: cp += tsiz;
1333: }
1334: /* And null pad to a long boundary */
1335: for (i = 0; i < rem; i++)
1336: *bp++ = '\0';
1337: nfsm_clget;
1338:
1339: /* Finish off the record */
1340: toff += dp->d_reclen;
1341: *tl = txdr_unsigned(toff);
1342: bp += NFSX_UNSIGNED;
1343: } else
1344: toff += dp->d_reclen;
1345: cpos += dp->d_reclen;
1346: dp = (struct direct *)cpos;
1347: }
1348: nfsm_clget;
1349: *tl = nfs_false;
1350: bp += NFSX_UNSIGNED;
1351: nfsm_clget;
1352: if (eofflag)
1353: *tl = nfs_true;
1354: else
1355: *tl = nfs_false;
1356: bp += NFSX_UNSIGNED;
1357: if (bp < be)
1358: mp->m_len = bp-mtod(mp, caddr_t);
1359: mb->m_next = mp3;
1360: FREE(rbuf, M_TEMP);
1361: nfsm_srvdone;
1362: }
1363:
1364: /*
1365: * nfs statfs service
1366: */
1367: nfsrv_statfs(mrep, md, dpos, cred, xid, mrq, repstat, p)
1368: struct mbuf **mrq;
1369: struct mbuf *mrep, *md;
1370: caddr_t dpos;
1371: struct ucred *cred;
1372: u_long xid;
1373: int *repstat;
1374: struct proc *p;
1375: {
1376: register struct statfs *sf;
1377: register struct nfsv2_statfs *sfp;
1378: register u_long *tl;
1379: register long t1;
1380: caddr_t bpos;
1381: int error = 0;
1382: char *cp2;
1383: struct mbuf *mb, *mb2, *mreq;
1384: struct vnode *vp;
1385: nfsv2fh_t nfh;
1386: fhandle_t *fhp;
1387: struct statfs statfs;
1388:
1389: fhp = &nfh.fh_generic;
1390: nfsm_srvmtofh(fhp);
1391: if (error = nfsrv_fhtovp(fhp, TRUE, &vp, cred))
1392: nfsm_reply(0);
1393: sf = &statfs;
1394: error = VFS_STATFS(vp->v_mount, sf, p);
1395: vput(vp);
1396: nfsm_reply(NFSX_STATFS);
1397: nfsm_build(sfp, struct nfsv2_statfs *, NFSX_STATFS);
1398: sfp->sf_tsize = txdr_unsigned(NFS_MAXDGRAMDATA);
1399: sfp->sf_bsize = txdr_unsigned(sf->f_fsize);
1400: sfp->sf_blocks = txdr_unsigned(sf->f_blocks);
1401: sfp->sf_bfree = txdr_unsigned(sf->f_bfree);
1402: sfp->sf_bavail = txdr_unsigned(sf->f_bavail);
1403: nfsm_srvdone;
1404: }
1405:
1406: /*
1407: * Null operation, used by clients to ping server
1408: */
1409: /* ARGSUSED */
1410: nfsrv_null(mrep, md, dpos, cred, xid, mrq, repstat, p)
1411: struct mbuf **mrq;
1412: struct mbuf *mrep, *md;
1413: caddr_t dpos;
1414: struct ucred *cred;
1415: u_long xid;
1416: int *repstat;
1417: struct proc *p;
1418: {
1419: caddr_t bpos;
1420: int error = 0;
1421: struct mbuf *mb, *mreq;
1422:
1423: error = VNOVAL;
1424: nfsm_reply(0);
1425: return (error);
1426: }
1427:
1428: /*
1429: * No operation, used for obsolete procedures
1430: */
1431: /* ARGSUSED */
1432: nfsrv_noop(mrep, md, dpos, cred, xid, mrq, repstat, p)
1433: struct mbuf **mrq;
1434: struct mbuf *mrep, *md;
1435: caddr_t dpos;
1436: struct ucred *cred;
1437: u_long xid;
1438: int *repstat;
1439: struct proc *p;
1440: {
1441: caddr_t bpos;
1442: int error = 0;
1443: struct mbuf *mb, *mreq;
1444:
1445: error = EPROCUNAVAIL;
1446: nfsm_reply(0);
1447: return (error);
1448: }
1449:
1450: /*
1451: * Perform access checking for vnodes obtained from file handles that would
1452: * refer to files already opened by a Unix client. You cannot just use
1453: * vn_writechk() and VOP_ACCESS() for two reasons.
1454: * 1 - You must check for MNT_EXRDONLY as well as MNT_RDONLY for the write case
1455: * 2 - The owner is to be given access irrespective of mode bits so that
1456: * processes that chmod after opening a file don't break. I don't like
1457: * this because it opens a security hole, but since the nfs server opens
1458: * a security hole the size of a barn door anyhow, what the heck.
1459: */
1460: nfsrv_access(vp, flags, cred, p)
1461: register struct vnode *vp;
1462: int flags;
1463: register struct ucred *cred;
1464: struct proc *p;
1465: {
1466: struct vattr vattr;
1467: int error;
1468: if (flags & VWRITE) {
1469: /* Just vn_writechk() changed to check MNT_EXRDONLY */
1470: /*
1471: * Disallow write attempts on read-only file systems;
1472: * unless the file is a socket or a block or character
1473: * device resident on the file system.
1474: */
1475: if (vp->v_mount->mnt_flag & (MNT_RDONLY | MNT_EXRDONLY)) {
1476: switch (vp->v_type) {
1477: case VREG: case VDIR: case VLNK:
1478: return (EROFS);
1479: }
1480: }
1481: /*
1482: * If there's shared text associated with
1483: * the inode, try to free it up once. If
1484: * we fail, we can't allow writing.
1485: */
1486: if ((vp->v_flag & VTEXT) && !vnode_pager_uncache(vp))
1487: return (ETXTBSY);
1488: }
1489: if (error = VOP_GETATTR(vp, &vattr, cred, p))
1490: return (error);
1491: if ((error = VOP_ACCESS(vp, flags, cred, p)) &&
1492: cred->cr_uid != vattr.va_uid)
1493: return (error);
1494: return (0);
1495: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.