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 extern struct nfsv3_diskless nfsv3_diskless;
  90
  91 static int getdec(char **ptr);
  92 static char *substr(char *a,char *b);
  93 static int xdr_opaque_decode(struct mbuf **ptr, u_char *buf, int len);
  94 static int xdr_int_decode(struct mbuf **ptr, int *iptr);
  95
  96 void
  97 mountopts(struct nfs_args *args, char *p)
  98 {
  99         char *tmp;
 100
 101         args->version = NFS_ARGSVERSION;
 102         args->rsize = 8192;
 103         args->wsize = 8192;
 104         args->flags = NFSMNT_RSIZE | NFSMNT_WSIZE | NFSMNT_RESVPORT;
 105         args->sotype = SOCK_DGRAM;
 106         if (p == NULL)
 107                 return;
 108         if ((tmp = (char *)substr(p, "rsize=")))
 109                 args->rsize = getdec(&tmp);
 110         if ((tmp = (char *)substr(p, "wsize=")))
 111                 args->wsize = getdec(&tmp);
 112         if ((tmp = (char *)substr(p, "intr")))
 113                 args->flags |= NFSMNT_INT;
 114         if ((tmp = (char *)substr(p, "soft")))
 115                 args->flags |= NFSMNT_SOFT;
 116         if ((tmp = (char *)substr(p, "noconn")))
 117                 args->flags |= NFSMNT_NOCONN;
 118         if ((tmp = (char *)substr(p, "tcp")))
 119                 args->sotype = SOCK_STREAM;
 120 }
 121
 122 /*
 123  * RPC: mountd/mount
 124  * Given a server pathname, get an NFS file handle.
 125  * Also, sets sin->sin_port to the NFS service port.
 126  */
 127 int
 128 md_mount(struct sockaddr_in *mdsin,             /* mountd server address */
 129          char *path,
 130          u_char *fhp,
 131          int *fhsizep,
 132          struct nfs_args *args,
 133          struct thread *td)
 134 {
 135         struct mbuf *m;
 136         int error;
 137         int authunixok;
 138         int authcount;
 139         int authver;
 140
 141 #ifdef BOOTP_NFSV3
 142         /* First try NFS v3 */
 143         /* Get port number for MOUNTD. */
 144         error = krpc_portmap(mdsin, RPCPROG_MNT, RPCMNT_VER3,
 145                              &mdsin->sin_port, td);
 146         if (error == 0) {
 147                 m = xdr_string_encode(path, strlen(path));
 148
 149                 /* Do RPC to mountd. */
 150                 error = krpc_call(mdsin, RPCPROG_MNT, RPCMNT_VER3,
 151                                   RPCMNT_MOUNT, &m, NULL, td);
 152         }
 153         if (error == 0) {
 154                 args->flags |= NFSMNT_NFSV3;
 155         } else {
 156 #endif
 157                 /* Fallback to NFS v2 */
 158
 159                 /* Get port number for MOUNTD. */
 160                 error = krpc_portmap(mdsin, RPCPROG_MNT, RPCMNT_VER1,
 161                                      &mdsin->sin_port, td);
 162                 if (error != 0)
 163                         return error;
 164
 165                 m = xdr_string_encode(path, strlen(path));
 166
 167                 /* Do RPC to mountd. */
 168                 error = krpc_call(mdsin, RPCPROG_MNT, RPCMNT_VER1,
 169                                   RPCMNT_MOUNT, &m, NULL, td);
 170                 if (error != 0)
 171                         return error;   /* message already freed */
 172
 173 #ifdef BOOTP_NFSV3
 174         }
 175 #endif
 176
 177         if (xdr_int_decode(&m, &error) != 0 || error != 0)
 178                 goto bad;
 179
 180         if ((args->flags & NFSMNT_NFSV3) != 0) {
 181                 if (xdr_int_decode(&m, fhsizep) != 0 ||
 182                     *fhsizep > NFSX_V3FHMAX ||
 183                     *fhsizep <= 0)
 184                         goto bad;
 185         } else
 186                 *fhsizep = NFSX_V2FH;
 187
 188         if (xdr_opaque_decode(&m, fhp, *fhsizep) != 0)
 189                 goto bad;
 190
 191         if (args->flags & NFSMNT_NFSV3) {
 192                 if (xdr_int_decode(&m, &authcount) != 0)
 193                         goto bad;
 194                 authunixok = 0;
 195                 if (authcount < 0 || authcount > 100)
 196                         goto bad;
 197                 while (authcount > 0) {
 198                         if (xdr_int_decode(&m, &authver) != 0)
 199                                 goto bad;
 200                         if (authver == RPCAUTH_UNIX)
 201                                 authunixok = 1;
 202                         authcount--;
 203                 }
 204                 if (authunixok == 0)
 205                         goto bad;
 206         }
 207
 208         /* Set port number for NFS use. */
 209         error = krpc_portmap(mdsin, NFS_PROG,
 210                              (args->flags &
 211                               NFSMNT_NFSV3) ? NFS_VER3 : NFS_VER2,
 212                              &mdsin->sin_port, td);
 213
 214         goto out;
 215
 216 bad:
 217         error = EBADRPC;
 218
 219 out:
 220         m_freem(m);
 221         return error;
 222 }
 223
 224 int
 225 md_lookup_swap(struct sockaddr_in *mdsin,       /* mountd server address */
 226                char *path,
 227                u_char *fhp,
 228                int *fhsizep,
 229                struct nfs_args *args,
 230                struct thread *td)
 231 {
 232         struct mbuf *m;
 233         int error;
 234         int size = -1;
 235         int attribs_present;
 236         int status;
 237         union {
 238                 u_int32_t v2[17];
 239                 u_int32_t v3[21];
 240         } fattribs;
 241
 242         m = m_get(MB_WAIT,MT_DATA);
 243         if (m == NULL)
 244                 return ENOBUFS;
 245
 246         if ((args->flags & NFSMNT_NFSV3) != 0) {
 247                 *mtod(m, u_int32_t *) = txdr_unsigned(*fhsizep);
 248                 bcopy(fhp, mtod(m, u_char *) + sizeof(u_int32_t), *fhsizep);
 249                 m->m_len = *fhsizep + sizeof(u_int32_t);
 250         } else {
 251                 bcopy(fhp, mtod(m, u_char *), NFSX_V2FH);
 252                 m->m_len = NFSX_V2FH;
 253         }
 254
 255         m->m_next = xdr_string_encode(path, strlen(path));
 256         if (m->m_next == NULL) {
 257                 error = ENOBUFS;
 258                 goto out;
 259         }
 260
 261         /* Do RPC to nfsd. */
 262         if ((args->flags & NFSMNT_NFSV3) != 0)
 263                 error = krpc_call(mdsin, NFS_PROG, NFS_VER3,
 264                                   NFSPROC_LOOKUP, &m, NULL, td);
 265         else
 266                 error = krpc_call(mdsin, NFS_PROG, NFS_VER2,
 267                                   NFSV2PROC_LOOKUP, &m, NULL, td);
 268         if (error != 0)
 269                 return error;   /* message already freed */
 270
 271         if (xdr_int_decode(&m, &status) != 0)
 272                 goto bad;
 273         if (status != 0) {
 274                 error = ENOENT;
 275                 goto out;
 276         }
 277
 278         if ((args->flags & NFSMNT_NFSV3) != 0) {
 279                 if (xdr_int_decode(&m, fhsizep) != 0 ||
 280                     *fhsizep > NFSX_V3FHMAX ||
 281                     *fhsizep <= 0)
 282                         goto bad;
 283         } else
 284                 *fhsizep = NFSX_V2FH;
 285
 286         if (xdr_opaque_decode(&m, fhp, *fhsizep) != 0)
 287                 goto bad;
 288
 289         if ((args->flags & NFSMNT_NFSV3) != 0) {
 290                 if (xdr_int_decode(&m, &attribs_present) != 0)
 291                         goto bad;
 292                 if (attribs_present != 0) {
 293                         if (xdr_opaque_decode(&m, (u_char *) &fattribs.v3,
 294                                               sizeof(u_int32_t) * 21) != 0)
 295                                 goto bad;
 296                         size = fxdr_unsigned(u_int32_t, fattribs.v3[6]);
 297                 }
 298         } else {
 299                 if (xdr_opaque_decode(&m,(u_char *) &fattribs.v2,
 300                                       sizeof(u_int32_t) * 17) != 0)
 301                         goto bad;
 302                 size = fxdr_unsigned(u_int32_t, fattribs.v2[5]);
 303         }
 304
 305         if (nfsv3_diskless.swap_nblks == 0 && size != -1) {
 306                 nfsv3_diskless.swap_nblks = size / 1024;
 307                 kprintf("md_lookup_swap: Swap size is %d KB\n",
 308                        nfsv3_diskless.swap_nblks);
 309         }
 310
 311         goto out;
 312
 313 bad:
 314         error = EBADRPC;
 315
 316 out:
 317         m_freem(m);
 318         return error;
 319 }
 320
 321 int
 322 setfs(struct sockaddr_in *addr, char *path, char *p)
 323 {
 324         unsigned int ip;
 325         int val;
 326
 327         ip = 0;
 328         if (((val = getdec(&p)) < 0) || (val > 255))
 329                 return 0;
 330         ip = val << 24;
 331         if (*p != '.')
 332                 return 0;
 333         p++;
 334         if (((val = getdec(&p)) < 0) || (val > 255))
 335                 return 0;
 336         ip |= (val << 16);
 337         if (*p != '.')
 338                 return 0;
 339         p++;
 340         if (((val = getdec(&p)) < 0) || (val > 255))
 341                 return 0;
 342         ip |= (val << 8);
 343         if (*p != '.')
 344                 return 0;
 345         p++;
 346         if (((val = getdec(&p)) < 0) || (val > 255))
 347                 return 0;
 348         ip |= val;
 349         if (*p != ':')
 350                 return 0;
 351         p++;
 352
 353         addr->sin_addr.s_addr = htonl(ip);
 354         addr->sin_len = sizeof(struct sockaddr_in);
 355         addr->sin_family = AF_INET;
 356
 357         strncpy(path, p, MNAMELEN - 1);
 358         return 1;
 359 }
 360
 361 static int
 362 getdec(char **ptr)
 363 {
 364         char *p;
 365         int ret;
 366
 367         p = *ptr;
 368         ret = 0;
 369         if ((*p < '0') || (*p > '9'))
 370                 return -1;
 371         while ((*p >= '0') && (*p <= '9')) {
 372                 ret = ret * 10 + (*p - '0');
 373                 p++;
 374         }
 375         *ptr = p;
 376         return ret;
 377 }
 378
 379 static char *
 380 substr(char *a, char *b)
 381 {
 382         char *loc1;
 383         char *loc2;
 384
 385         while (*a != '\0') {
 386                 loc1 = a;
 387                 loc2 = b;
 388                 while (*loc1 == *loc2++) {
 389                         if (*loc1 == '\0')
 390                                 return 0;
 391                         loc1++;
 392                         if (*loc2 == '\0')
 393                                 return loc1;
 394                 }
 395                 a++;
 396         }
 397         return 0;
 398 }
 399
 400 static int
 401 xdr_opaque_decode(struct mbuf **mptr, u_char *buf, int len)
 402 {
 403         struct mbuf *m;
 404         int alignedlen;
 405
 406         m = *mptr;
 407         alignedlen = ( len + 3 ) & ~3;
 408
 409         if (m->m_len < alignedlen) {
 410                 m = m_pullup(m, alignedlen);
 411                 if (m == NULL) {
 412                         *mptr = NULL;
 413                         return EBADRPC;
 414                 }
 415         }
 416         bcopy(mtod(m, u_char *), buf, len);
 417         m_adj(m, alignedlen);
 418         *mptr = m;
 419         return 0;
 420 }
 421
 422 static int
 423 xdr_int_decode(struct mbuf **mptr, int *iptr)
 424 {
 425         u_int32_t i;
 426         if (xdr_opaque_decode(mptr, (u_char *) &i, sizeof(u_int32_t)) != 0)
 427                 return EBADRPC;
 428         *iptr = fxdr_unsigned(u_int32_t, i);
 429         return 0;
 430 }
 431
 432 #endif  /* BOOTP && NFS_ROOT */
 433