233cbc93e92128a01dee1bec6510091962b01ded
[dragonfly.git] / sys / vfs / nfs / nfs_mountrpc.c
1 /*
2  * Copyright (c) 1995 Gordon Ross, Adam Glass
3  * Copyright (c) 1992 Regents of the University of California.
4  * All rights reserved.
5  *
6  * This software was developed by the Computer Systems Engineering group
7  * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
8  * contributed to Berkeley.
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  * 1. Redistributions of source code must retain the above copyright
14  *    notice, this list of conditions and the following disclaimer.
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in the
17  *    documentation and/or other materials provided with the distribution.
18  * 3. All advertising materials mentioning features or use of this software
19  *    must display the following acknowledgement:
20  *      This product includes software developed by the University of
21  *      California, Lawrence Berkeley Laboratory and its contributors.
22  * 4. Neither the name of the University nor the names of its contributors
23  *    may be used to endorse or promote products derived from this software
24  *    without specific prior written permission.
25  *
26  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
27  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
30  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
31  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
32  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
34  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
35  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36  * SUCH DAMAGE.
37  *
38  * nfs/krpc_subr.c
39  * $NetBSD: krpc_subr.c,v 1.10 1995/08/08 20:43:43 gwr Exp $
40  * $FreeBSD: src/sys/nfs/bootp_subr.c,v 1.20.2.9 2003/04/24 16:51:08 ambrisko Exp $
41  * $DragonFly: src/sys/vfs/nfs/nfs_mountrpc.c,v 1.2 2006/12/23 00:41:29 swildner Exp $
42  */
43 /*
44  * Procedures used by NFS_ROOT and BOOTP to do an NFS mount rpc to obtain
45  * the nfs root file handle for a NFS-based root mount point.  This module 
46  * is not used by normal operating code because the 'mount' command has a
47  * far more sophisticated implementation.
48  */
49 #include "opt_bootp.h"
50 #include "opt_nfsroot.h"
51
52 #if defined(BOOTP) || defined(NFS_ROOT)
53
54 #include <sys/param.h>
55 #include <sys/systm.h>
56 #include <sys/kernel.h>
57 #include <sys/sockio.h>
58 #include <sys/proc.h>
59 #include <sys/malloc.h>
60 #include <sys/mount.h>
61 #include <sys/mbuf.h>
62 #include <sys/socket.h>
63 #include <sys/socketvar.h>
64 #include <sys/sysctl.h>
65 #include <sys/uio.h>
66
67 #include <net/if.h>
68 #include <net/route.h>
69
70 #include <netinet/in.h>
71 #include <net/if_types.h>
72 #include <net/if_dl.h>
73
74 #include "rpcv2.h"
75 #include "nfsproto.h"
76 #include "nfs.h"
77 #include "nfsdiskless.h"
78 #include "krpc.h"
79 #include "xdr_subs.h"
80 #include "nfsmountrpc.h"
81
82 /*
83  * What is the longest we will wait before re-sending a request?
84  * Note this is also the frequency of "RPC timeout" messages.
85  * The re-send loop count sup linearly to this maximum, so the
86  * first complaint will happen after (1+2+3+4+5)=15 seconds.
87  */
88
89 static int getdec(char **ptr);
90 static char *substr(char *a,char *b);
91 static int xdr_opaque_decode(struct mbuf **ptr, u_char *buf, int len);
92 static int xdr_int_decode(struct mbuf **ptr, int *iptr);
93
94 void
95 mountopts(struct nfs_args *args, char *p)
96 {
97         char *tmp;
98         
99         args->version = NFS_ARGSVERSION;
100         args->rsize = 8192;
101         args->wsize = 8192;
102         args->flags = NFSMNT_RSIZE | NFSMNT_WSIZE | NFSMNT_RESVPORT;
103         args->sotype = SOCK_DGRAM;
104         if (p == NULL)
105                 return;
106         if ((tmp = (char *)substr(p, "rsize=")))
107                 args->rsize = getdec(&tmp);
108         if ((tmp = (char *)substr(p, "wsize=")))
109                 args->wsize = getdec(&tmp);
110         if ((tmp = (char *)substr(p, "intr")))
111                 args->flags |= NFSMNT_INT;
112         if ((tmp = (char *)substr(p, "soft")))
113                 args->flags |= NFSMNT_SOFT;
114         if ((tmp = (char *)substr(p, "noconn")))
115                 args->flags |= NFSMNT_NOCONN;
116         if ((tmp = (char *)substr(p, "tcp")))
117                 args->sotype = SOCK_STREAM;
118 }
119
120 /*
121  * RPC: mountd/mount
122  * Given a server pathname, get an NFS file handle.
123  * Also, sets sin->sin_port to the NFS service port.
124  */
125 int
126 md_mount(struct sockaddr_in *mdsin,             /* mountd server address */
127          char *path,
128          u_char *fhp,
129          int *fhsizep,
130          struct nfs_args *args,
131          struct thread *td)
132 {
133         struct mbuf *m;
134         int error;
135         int authunixok;
136         int authcount;
137         int authver;
138         
139 #ifdef BOOTP_NFSV3
140         /* First try NFS v3 */
141         /* Get port number for MOUNTD. */
142         error = krpc_portmap(mdsin, RPCPROG_MNT, RPCMNT_VER3,
143                              &mdsin->sin_port, td);
144         if (error == 0) {
145                 m = xdr_string_encode(path, strlen(path));
146                 
147                 /* Do RPC to mountd. */
148                 error = krpc_call(mdsin, RPCPROG_MNT, RPCMNT_VER3,
149                                   RPCMNT_MOUNT, &m, NULL, td);
150         }
151         if (error == 0) {
152                 args->flags |= NFSMNT_NFSV3;
153         } else {
154 #endif
155                 /* Fallback to NFS v2 */
156                 
157                 /* Get port number for MOUNTD. */
158                 error = krpc_portmap(mdsin, RPCPROG_MNT, RPCMNT_VER1,
159                                      &mdsin->sin_port, td);
160                 if (error != 0)
161                         return error;
162                 
163                 m = xdr_string_encode(path, strlen(path));
164                 
165                 /* Do RPC to mountd. */
166                 error = krpc_call(mdsin, RPCPROG_MNT, RPCMNT_VER1,
167                                   RPCMNT_MOUNT, &m, NULL, td);
168                 if (error != 0)
169                         return error;   /* message already freed */
170                 
171 #ifdef BOOTP_NFSV3
172         }
173 #endif
174
175         if (xdr_int_decode(&m, &error) != 0 || error != 0)
176                 goto bad;
177         
178         if ((args->flags & NFSMNT_NFSV3) != 0) {
179                 if (xdr_int_decode(&m, fhsizep) != 0 ||
180                     *fhsizep > NFSX_V3FHMAX ||
181                     *fhsizep <= 0)
182                         goto bad;
183         } else
184                 *fhsizep = NFSX_V2FH;
185
186         if (xdr_opaque_decode(&m, fhp, *fhsizep) != 0)
187                 goto bad;
188
189         if (args->flags & NFSMNT_NFSV3) {
190                 if (xdr_int_decode(&m, &authcount) != 0)
191                         goto bad;
192                 authunixok = 0;
193                 if (authcount < 0 || authcount > 100)
194                         goto bad;
195                 while (authcount > 0) {
196                         if (xdr_int_decode(&m, &authver) != 0)
197                                 goto bad;
198                         if (authver == RPCAUTH_UNIX)
199                                 authunixok = 1;
200                         authcount--;
201                 }
202                 if (authunixok == 0)
203                         goto bad;
204         }
205           
206         /* Set port number for NFS use. */
207         error = krpc_portmap(mdsin, NFS_PROG,
208                              (args->flags &
209                               NFSMNT_NFSV3) ? NFS_VER3 : NFS_VER2,
210                              &mdsin->sin_port, td);
211         
212         goto out;
213         
214 bad:
215         error = EBADRPC;
216         
217 out:
218         m_freem(m);
219         return error;
220 }
221
222 int
223 md_lookup_swap(struct sockaddr_in *mdsin,       /* mountd server address */
224                char *path,
225                u_char *fhp,
226                int *fhsizep,
227                struct nfs_args *args,
228                struct thread *td)
229 {
230         struct mbuf *m;
231         int error;
232         int size = -1;
233         int attribs_present;
234         int status;
235         union {
236                 u_int32_t v2[17];
237                 u_int32_t v3[21];
238         } fattribs;
239         
240         m = m_get(MB_WAIT,MT_DATA);
241         if (m == NULL)
242                 return ENOBUFS;
243         
244         if ((args->flags & NFSMNT_NFSV3) != 0) {
245                 *mtod(m, u_int32_t *) = txdr_unsigned(*fhsizep);
246                 bcopy(fhp, mtod(m, u_char *) + sizeof(u_int32_t), *fhsizep);
247                 m->m_len = *fhsizep + sizeof(u_int32_t);
248         } else {
249                 bcopy(fhp, mtod(m, u_char *), NFSX_V2FH);
250                 m->m_len = NFSX_V2FH;
251         }
252         
253         m->m_next = xdr_string_encode(path, strlen(path));
254         if (m->m_next == NULL) {
255                 error = ENOBUFS;
256                 goto out;
257         }
258
259         /* Do RPC to nfsd. */
260         if ((args->flags & NFSMNT_NFSV3) != 0)
261                 error = krpc_call(mdsin, NFS_PROG, NFS_VER3,
262                                   NFSPROC_LOOKUP, &m, NULL, td);
263         else
264                 error = krpc_call(mdsin, NFS_PROG, NFS_VER2,
265                                   NFSV2PROC_LOOKUP, &m, NULL, td);
266         if (error != 0)
267                 return error;   /* message already freed */
268
269         if (xdr_int_decode(&m, &status) != 0)
270                 goto bad;
271         if (status != 0) {
272                 error = ENOENT;
273                 goto out;
274         }
275         
276         if ((args->flags & NFSMNT_NFSV3) != 0) {
277                 if (xdr_int_decode(&m, fhsizep) != 0 ||
278                     *fhsizep > NFSX_V3FHMAX ||
279                     *fhsizep <= 0)
280                         goto bad;
281         } else
282                 *fhsizep = NFSX_V2FH;
283         
284         if (xdr_opaque_decode(&m, fhp, *fhsizep) != 0)
285                 goto bad;
286         
287         if ((args->flags & NFSMNT_NFSV3) != 0) {
288                 if (xdr_int_decode(&m, &attribs_present) != 0)
289                         goto bad;
290                 if (attribs_present != 0) {
291                         if (xdr_opaque_decode(&m, (u_char *) &fattribs.v3,
292                                               sizeof(u_int32_t) * 21) != 0)
293                                 goto bad;
294                         size = fxdr_unsigned(u_int32_t, fattribs.v3[6]);
295                 }
296         } else {
297                 if (xdr_opaque_decode(&m,(u_char *) &fattribs.v2,
298                                       sizeof(u_int32_t) * 17) != 0)
299                         goto bad;
300                 size = fxdr_unsigned(u_int32_t, fattribs.v2[5]);
301         }
302           
303         if (nfsv3_diskless.swap_nblks == 0 && size != -1) {
304                 nfsv3_diskless.swap_nblks = size / 1024;
305                 kprintf("md_lookup_swap: Swap size is %d KB\n",
306                        nfsv3_diskless.swap_nblks);
307         }
308         
309         goto out;
310         
311 bad:
312         error = EBADRPC;
313         
314 out:
315         m_freem(m);
316         return error;
317 }
318
319 int
320 setfs(struct sockaddr_in *addr, char *path, char *p)
321 {
322         unsigned int ip;
323         int val;
324         
325         ip = 0;
326         if (((val = getdec(&p)) < 0) || (val > 255))
327                 return 0;
328         ip = val << 24;
329         if (*p != '.')
330                 return 0;
331         p++;
332         if (((val = getdec(&p)) < 0) || (val > 255))
333                 return 0;
334         ip |= (val << 16);
335         if (*p != '.')
336                 return 0;
337         p++;
338         if (((val = getdec(&p)) < 0) || (val > 255))
339                 return 0;
340         ip |= (val << 8);
341         if (*p != '.')
342                 return 0;
343         p++;
344         if (((val = getdec(&p)) < 0) || (val > 255))
345                 return 0;
346         ip |= val;
347         if (*p != ':')
348                 return 0;
349         p++;
350         
351         addr->sin_addr.s_addr = htonl(ip);
352         addr->sin_len = sizeof(struct sockaddr_in);
353         addr->sin_family = AF_INET;
354         
355         strncpy(path, p, MNAMELEN - 1);
356         return 1;
357 }
358
359 static int
360 getdec(char **ptr)
361 {
362         char *p;
363         int ret;
364
365         p = *ptr;
366         ret = 0;
367         if ((*p < '0') || (*p > '9'))
368                 return -1;
369         while ((*p >= '0') && (*p <= '9')) {
370                 ret = ret * 10 + (*p - '0');
371                 p++;
372         }
373         *ptr = p;
374         return ret;
375 }
376
377 static char *
378 substr(char *a, char *b)
379 {
380         char *loc1;
381         char *loc2;
382         
383         while (*a != '\0') {
384                 loc1 = a;
385                 loc2 = b;
386                 while (*loc1 == *loc2++) {
387                         if (*loc1 == '\0')
388                                 return 0;
389                         loc1++;
390                         if (*loc2 == '\0')
391                                 return loc1;
392                 }
393                 a++;
394         }
395         return 0;
396 }
397
398 static int
399 xdr_opaque_decode(struct mbuf **mptr, u_char *buf, int len)
400 {
401         struct mbuf *m;
402         int alignedlen;
403         
404         m = *mptr;
405         alignedlen = ( len + 3 ) & ~3;
406         
407         if (m->m_len < alignedlen) {
408                 m = m_pullup(m, alignedlen);
409                 if (m == NULL) {
410                         *mptr = NULL;
411                         return EBADRPC;
412                 }
413         }
414         bcopy(mtod(m, u_char *), buf, len);
415         m_adj(m, alignedlen);
416         *mptr = m;
417         return 0;
418 }
419
420 static int
421 xdr_int_decode(struct mbuf **mptr, int *iptr)
422 {
423         u_int32_t i;
424         if (xdr_opaque_decode(mptr, (u_char *) &i, sizeof(u_int32_t)) != 0)
425                 return EBADRPC;
426         *iptr = fxdr_unsigned(u_int32_t, i);
427         return 0;
428 }
429
430 #endif  /* BOOTP && NFS_ROOT */
431