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