[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/nfs/krpc_subr.c

Version: -  FREEBSD  -  FREEBSD10  -  FREEBSD9  -  FREEBSD92  -  FREEBSD91  -  FREEBSD90  -  FREEBSD8  -  FREEBSD82  -  FREEBSD81  -  FREEBSD80  -  FREEBSD7  -  FREEBSD74  -  FREEBSD73  -  FREEBSD72  -  FREEBSD71  -  FREEBSD70  -  FREEBSD6  -  FREEBSD64  -  FREEBSD63  -  FREEBSD62  -  FREEBSD61  -  FREEBSD60  -  FREEBSD5  -  FREEBSD55  -  FREEBSD54  -  FREEBSD53  -  FREEBSD52  -  FREEBSD51  -  FREEBSD50  -  FREEBSD4  -  FREEBSD3  -  FREEBSD22  -  cheribsd  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1  -  FREEBSD-LIBC  -  FREEBSD8-LIBC  -  FREEBSD7-LIBC  -  FREEBSD6-LIBC  -  GLIBC27 
SearchContext: -  none  -  3  -  10 

    1 /*      $NetBSD: krpc_subr.c,v 1.12.4.1 1996/06/07 00:52:26 cgd Exp $   */
    2 /* $FreeBSD: src/sys/nfs/krpc_subr.c,v 1.11.2.1 1999/08/29 16:30:26 peter Exp $ */
    3 
    4 /*
    5  * Copyright (c) 1995 Gordon Ross, Adam Glass
    6  * Copyright (c) 1992 Regents of the University of California.
    7  * All rights reserved.
    8  *
    9  * This software was developed by the Computer Systems Engineering group
   10  * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
   11  * contributed to Berkeley.
   12  *
   13  * Redistribution and use in source and binary forms, with or without
   14  * modification, are permitted provided that the following conditions
   15  * are met:
   16  * 1. Redistributions of source code must retain the above copyright
   17  *    notice, this list of conditions and the following disclaimer.
   18  * 2. Redistributions in binary form must reproduce the above copyright
   19  *    notice, this list of conditions and the following disclaimer in the
   20  *    documentation and/or other materials provided with the distribution.
   21  * 3. All advertising materials mentioning features or use of this software
   22  *    must display the following acknowledgement:
   23  *      This product includes software developed by the University of
   24  *      California, Lawrence Berkeley Laboratory and its contributors.
   25  * 4. Neither the name of the University nor the names of its contributors
   26  *    may be used to endorse or promote products derived from this software
   27  *    without specific prior written permission.
   28  *
   29  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   30  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   31  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   32  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   33  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   34  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   35  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   36  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   37  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   38  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   39  * SUCH DAMAGE.
   40  *
   41  * partially based on:
   42  *      libnetboot/rpc.c
   43  *               @(#) Header: rpc.c,v 1.12 93/09/28 08:31:56 leres Exp  (LBL)
   44  */
   45 
   46 #include <sys/param.h>
   47 #include <sys/systm.h>
   48 #include <sys/malloc.h>
   49 #include <sys/mbuf.h>
   50 #include <sys/socket.h>
   51 #include <sys/socketvar.h>
   52 #include <sys/uio.h>
   53 
   54 #include <net/if.h>
   55 #include <netinet/in.h>
   56 
   57 #include <nfs/rpcv2.h>
   58 #include <nfs/krpc.h>
   59 #include <nfs/xdr_subs.h>
   60 
   61 /*
   62  * Kernel support for Sun RPC
   63  *
   64  * Used currently for bootstrapping in nfs diskless configurations.
   65  */
   66 
   67 /*
   68  * Generic RPC headers
   69  */
   70 
   71 struct auth_info {
   72         u_int32_t       authtype;       /* auth type */
   73         u_int32_t       authlen;        /* auth length */
   74 };
   75 
   76 struct auth_unix {
   77         int32_t   ua_time;
   78         int32_t   ua_hostname;  /* null */
   79         int32_t   ua_uid;
   80         int32_t   ua_gid;
   81         int32_t   ua_gidlist;   /* null */
   82 };
   83 
   84 struct rpc_call {
   85         u_int32_t       rp_xid;         /* request transaction id */
   86         int32_t         rp_direction;   /* call direction (0) */
   87         u_int32_t       rp_rpcvers;     /* rpc version (2) */
   88         u_int32_t       rp_prog;        /* program */
   89         u_int32_t       rp_vers;        /* version */
   90         u_int32_t       rp_proc;        /* procedure */
   91         struct  auth_info rpc_auth;
   92         struct  auth_unix rpc_unix;
   93         struct  auth_info rpc_verf;
   94 };
   95 
   96 struct rpc_reply {
   97         u_int32_t rp_xid;               /* request transaction id */
   98         int32_t  rp_direction;          /* call direction (1) */
   99         int32_t  rp_astatus;            /* accept status (0: accepted) */
  100         union {
  101                 u_int32_t rpu_errno;
  102                 struct {
  103                         struct auth_info rok_auth;
  104                         u_int32_t       rok_status;
  105                 } rpu_rok;
  106         } rp_u;
  107 };
  108 #define rp_errno  rp_u.rpu_errno
  109 #define rp_auth   rp_u.rpu_rok.rok_auth
  110 #define rp_status rp_u.rpu_rok.rok_status
  111 
  112 #define MIN_REPLY_HDR 16        /* xid, dir, astat, errno */
  113 
  114 /*
  115  * What is the longest we will wait before re-sending a request?
  116  * Note this is also the frequency of "RPC timeout" messages.
  117  * The re-send loop count sup linearly to this maximum, so the
  118  * first complaint will happen after (1+2+3+4+5)=15 seconds.
  119  */
  120 #define MAX_RESEND_DELAY 5      /* seconds */
  121 
  122 /*
  123  * Call portmap to lookup a port number for a particular rpc program
  124  * Returns non-zero error on failure.
  125  */
  126 int
  127 krpc_portmap(sin,  prog, vers, portp, procp)
  128         struct sockaddr_in *sin;                /* server address */
  129         u_int prog, vers;       /* host order */
  130         u_int16_t *portp;       /* network order */
  131         struct proc *procp;
  132 {
  133         struct sdata {
  134                 u_int32_t prog;         /* call program */
  135                 u_int32_t vers;         /* call version */
  136                 u_int32_t proto;        /* call protocol */
  137                 u_int32_t port;         /* call port (unused) */
  138         } *sdata;
  139         struct rdata {
  140                 u_int16_t pad;
  141                 u_int16_t port;
  142         } *rdata;
  143         struct mbuf *m;
  144         int error;
  145 
  146         /* The portmapper port is fixed. */
  147         if (prog == PMAPPROG) {
  148                 *portp = htons(PMAPPORT);
  149                 return 0;
  150         }
  151 
  152         m = m_get(M_WAIT, MT_DATA);
  153         if (m == NULL)
  154                 return ENOBUFS;
  155         sdata = mtod(m, struct sdata *);
  156         m->m_len = sizeof(*sdata);
  157 
  158         /* Do the RPC to get it. */
  159         sdata->prog = txdr_unsigned(prog);
  160         sdata->vers = txdr_unsigned(vers);
  161         sdata->proto = txdr_unsigned(IPPROTO_UDP);
  162         sdata->port = 0;
  163 
  164         sin->sin_port = htons(PMAPPORT);
  165         error = krpc_call(sin, PMAPPROG, PMAPVERS,
  166                                           PMAPPROC_GETPORT, &m, NULL, procp);
  167         if (error) 
  168                 return error;
  169 
  170         if (m->m_len < sizeof(*rdata)) {
  171                 m = m_pullup(m, sizeof(*rdata));
  172                 if (m == NULL)
  173                         return ENOBUFS;
  174         }
  175         rdata = mtod(m, struct rdata *);
  176         *portp = rdata->port;
  177 
  178         m_freem(m);
  179         return 0;
  180 }
  181 
  182 /*
  183  * Do a remote procedure call (RPC) and wait for its reply.
  184  * If from_p is non-null, then we are doing broadcast, and
  185  * the address from whence the response came is saved there.
  186  */
  187 int
  188 krpc_call(sa, prog, vers, func, data, from_p, procp)
  189         struct sockaddr_in *sa;
  190         u_int prog, vers, func;
  191         struct mbuf **data;     /* input/output */
  192         struct sockaddr **from_p;       /* output */
  193         struct proc *procp;
  194 {
  195         struct socket *so;
  196         struct sockaddr_in *sin, ssin;
  197         struct sockaddr *from;
  198         struct mbuf *m, *nam, *mhead;
  199         struct rpc_call *call;
  200         struct rpc_reply *reply;
  201         struct sockopt sopt;
  202         struct timeval tv;
  203         struct uio auio;
  204         int error, rcvflg, timo, secs, len;
  205         static u_int32_t xid = ~0xFF;
  206         u_int16_t tport;
  207 
  208         /*
  209          * Validate address family.
  210          * Sorry, this is INET specific...
  211          */
  212         if (sa->sin_family != AF_INET)
  213                 return (EAFNOSUPPORT);
  214 
  215         /* Free at end if not null. */
  216         nam = mhead = NULL;
  217         from = NULL;
  218 
  219         /*
  220          * Create socket and set its recieve timeout.
  221          */
  222         if ((error = socreate(AF_INET, &so, SOCK_DGRAM, 0, procp)))
  223                 goto out;
  224 
  225         tv.tv_sec = 1;
  226         tv.tv_usec = 0;
  227         bzero(&sopt, sizeof sopt);
  228         sopt.sopt_level = SOL_SOCKET;
  229         sopt.sopt_name = SO_RCVTIMEO;
  230         sopt.sopt_val = &tv;
  231         sopt.sopt_valsize = sizeof tv;
  232 
  233         if (error = sosetopt(so, &sopt))
  234                 goto out;
  235 
  236         /*
  237          * Enable broadcast if necessary.
  238          */
  239         if (from_p) {
  240                 int on = 1;
  241                 sopt.sopt_name = SO_BROADCAST;
  242                 sopt.sopt_val = &on;
  243                 sopt.sopt_valsize = sizeof on;
  244                 if (error = sosetopt(so, &sopt))
  245                         goto out;
  246         }
  247 
  248         /*
  249          * Bind the local endpoint to a reserved port,
  250          * because some NFS servers refuse requests from
  251          * non-reserved (non-privileged) ports.
  252          */
  253         sin = &ssin;
  254         bzero(sin, sizeof *sin);
  255         sin->sin_len = sizeof(*sin);
  256         sin->sin_family = AF_INET;
  257         sin->sin_addr.s_addr = INADDR_ANY;
  258         tport = IPPORT_RESERVED;
  259         do {
  260                 tport--;
  261                 sin->sin_port = htons(tport);
  262                 error = sobind(so, (struct sockaddr *)sin, procp);
  263         } while (error == EADDRINUSE &&
  264                          tport > IPPORT_RESERVED / 2);
  265         if (error) {
  266                 printf("bind failed\n");
  267                 goto out;
  268         }
  269 
  270         /*
  271          * Setup socket address for the server.
  272          */
  273 
  274         /*
  275          * Prepend RPC message header.
  276          */
  277         mhead = m_gethdr(M_WAIT, MT_DATA);
  278         mhead->m_next = *data;
  279         call = mtod(mhead, struct rpc_call *);
  280         mhead->m_len = sizeof(*call);
  281         bzero((caddr_t)call, sizeof(*call));
  282         /* rpc_call part */
  283         xid++;
  284         call->rp_xid = txdr_unsigned(xid);
  285         /* call->rp_direction = 0; */
  286         call->rp_rpcvers = txdr_unsigned(2);
  287         call->rp_prog = txdr_unsigned(prog);
  288         call->rp_vers = txdr_unsigned(vers);
  289         call->rp_proc = txdr_unsigned(func);
  290         /* rpc_auth part (auth_unix as root) */
  291         call->rpc_auth.authtype = txdr_unsigned(RPCAUTH_UNIX);
  292         call->rpc_auth.authlen  = txdr_unsigned(sizeof(struct auth_unix));
  293         /* rpc_verf part (auth_null) */
  294         call->rpc_verf.authtype = 0;
  295         call->rpc_verf.authlen  = 0;
  296 
  297         /*
  298          * Setup packet header
  299          */
  300         len = 0;
  301         m = mhead;
  302         while (m) {
  303                 len += m->m_len;
  304                 m = m->m_next;
  305         }
  306         mhead->m_pkthdr.len = len;
  307         mhead->m_pkthdr.rcvif = NULL;
  308 
  309         /*
  310          * Send it, repeatedly, until a reply is received,
  311          * but delay each re-send by an increasing amount.
  312          * If the delay hits the maximum, start complaining.
  313          */
  314         timo = 0;
  315         for (;;) {
  316                 /* Send RPC request (or re-send). */
  317                 m = m_copym(mhead, 0, M_COPYALL, M_WAIT);
  318                 if (m == NULL) {
  319                         error = ENOBUFS;
  320                         goto out;
  321                 }
  322                 error = sosend(so, (struct sockaddr *)sa, NULL, m,
  323                                NULL, 0, 0);
  324                 if (error) {
  325                         printf("krpc_call: sosend: %d\n", error);
  326                         goto out;
  327                 }
  328                 m = NULL;
  329 
  330                 /* Determine new timeout. */
  331                 if (timo < MAX_RESEND_DELAY)
  332                         timo++;
  333                 else
  334                         printf("RPC timeout for server 0x%lx\n",
  335                                (u_long)ntohl(sa->sin_addr.s_addr));
  336 
  337                 /*
  338                  * Wait for up to timo seconds for a reply.
  339                  * The socket receive timeout was set to 1 second.
  340                  */
  341                 secs = timo;
  342                 while (secs > 0) {
  343                         if (from) {
  344                                 FREE(from, M_SONAME);
  345                                 from = NULL;
  346                         }
  347                         if (m) {
  348                                 m_freem(m);
  349                                 m = NULL;
  350                         }
  351                         bzero(&auio,sizeof(auio));
  352                         auio.uio_resid = len = 1<<16;
  353                         rcvflg = 0;
  354                         error = soreceive(so, &from, &auio, &m, NULL, &rcvflg);
  355                         if (error == EWOULDBLOCK) {
  356                                 secs--;
  357                                 continue;
  358                         }
  359                         if (error)
  360                                 goto out;
  361                         len -= auio.uio_resid;
  362 
  363                         /* Does the reply contain at least a header? */
  364                         if (len < MIN_REPLY_HDR)
  365                                 continue;
  366                         if (m->m_len < MIN_REPLY_HDR)
  367                                 continue;
  368                         reply = mtod(m, struct rpc_reply *);
  369 
  370                         /* Is it the right reply? */
  371                         if (reply->rp_direction != txdr_unsigned(RPC_REPLY))
  372                                 continue;
  373 
  374                         if (reply->rp_xid != txdr_unsigned(xid))
  375                                 continue;
  376 
  377                         /* Was RPC accepted? (authorization OK) */
  378                         if (reply->rp_astatus != 0) {
  379                                 error = fxdr_unsigned(u_int32_t, reply->rp_errno);
  380                                 printf("rpc denied, error=%d\n", error);
  381                                 continue;
  382                         }
  383 
  384                         /* Did the call succeed? */
  385                         if (reply->rp_status != 0) {
  386                                 error = fxdr_unsigned(u_int32_t, reply->rp_status);
  387                                 if (error == RPC_PROGMISMATCH) {
  388                                   error = EBADRPC;
  389                                   goto out;
  390                                 }
  391                                 printf("rpc denied, status=%d\n", error);
  392                                 continue;
  393                         }
  394 
  395                         goto gotreply;  /* break two levels */
  396 
  397                 } /* while secs */
  398         } /* forever send/receive */
  399 
  400         error = ETIMEDOUT;
  401         goto out;
  402 
  403  gotreply:
  404 
  405         /*
  406          * Get RPC reply header into first mbuf,
  407          * get its length, then strip it off.
  408          */
  409         len = sizeof(*reply);
  410         if (m->m_len < len) {
  411                 m = m_pullup(m, len);
  412                 if (m == NULL) {
  413                         error = ENOBUFS;
  414                         goto out;
  415                 }
  416         }
  417         reply = mtod(m, struct rpc_reply *);
  418         if (reply->rp_auth.authtype != 0) {
  419                 len += fxdr_unsigned(u_int32_t, reply->rp_auth.authlen);
  420                 len = (len + 3) & ~3; /* XXX? */
  421         }
  422         m_adj(m, len);
  423 
  424         /* result */
  425         *data = m;
  426         if (from_p) {
  427                 *from_p = from;
  428                 from = NULL;
  429         }
  430 
  431  out:
  432         if (mhead) m_freem(mhead);
  433         if (from) free(from, M_SONAME);
  434         soclose(so);
  435         return error;
  436 }
  437 
  438 /*
  439  * eXternal Data Representation routines.
  440  * (but with non-standard args...)
  441  */
  442 
  443 /*
  444  * String representation for RPC.
  445  */
  446 struct xdr_string {
  447         u_int32_t len;          /* length without null or padding */
  448         char data[4];   /* data (longer, of course) */
  449     /* data is padded to a long-word boundary */
  450 };
  451 
  452 struct mbuf *
  453 xdr_string_encode(str, len)
  454         char *str;
  455         int len;
  456 {
  457         struct mbuf *m;
  458         struct xdr_string *xs;
  459         int dlen;       /* padded string length */
  460         int mlen;       /* message length */
  461 
  462         dlen = (len + 3) & ~3;
  463         mlen = dlen + 4;
  464 
  465         if (mlen > MCLBYTES)            /* If too big, we just can't do it. */
  466                 return (NULL);
  467 
  468         m = m_get(M_WAIT, MT_DATA);
  469         if (mlen > MLEN) {
  470                 MCLGET(m, M_WAIT);
  471                 if ((m->m_flags & M_EXT) == 0) {
  472                         (void) m_free(m);       /* There can be only one. */
  473                         return (NULL);
  474                 }
  475         }
  476         xs = mtod(m, struct xdr_string *);
  477         m->m_len = mlen;
  478         xs->len = txdr_unsigned(len);
  479         bcopy(str, xs->data, len);
  480         return (m);
  481 }

Cache object: 1c8d52c86b58afd9ba17e6115a9abadf


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.