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