contrib/amd/conf/transp/transp_sockets.c

   1 /*
   2  * Copyright (c) 1997-1999 Erez Zadok
   3  * Copyright (c) 1990 Jan-Simon Pendry
   4  * Copyright (c) 1990 Imperial College of Science, Technology & Medicine
   5  * Copyright (c) 1990 The Regents of the University of California.
   6  * All rights reserved.
   7  *
   8  * This code is derived from software contributed to Berkeley by
   9  * Jan-Simon Pendry at Imperial College, London.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  * 3. All advertising materials mentioning features or use of this software
  20  *    must display the following acknowledgment:
  21  *      This product includes software developed by the University of
  22  *      California, Berkeley and its contributors.
  23  * 4. Neither the name of the University nor the names of its contributors
  24  *    may be used to endorse or promote products derived from this software
  25  *    without specific prior written permission.
  26  *
  27  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  28  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  29  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  30  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  31  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  32  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  33  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  34  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  35  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  36  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  37  * SUCH DAMAGE.
  38  *
  39  *      %W% (Berkeley) %G%
  40  *
  41  * $Id: transp_sockets.c,v 1.5 1999/08/22 21:12:31 ezk Exp $
  42  *
  43  * Socket specific utilities.
  44  *      -Erez Zadok <ezk@cs.columbia.edu>
  45  */
  46
  47 #ifdef HAVE_CONFIG_H
  48 # include <config.h>
  49 #endif /* HAVE_CONFIG_H */
  50 #include <am_defs.h>
  51 #include <amu.h>
  52
  53
  54 /*
  55  * find the IP address that can be used to connect to the local host
  56  */
  57 void
  58 amu_get_myaddress(struct in_addr *iap)
  59 {
  60   struct sockaddr_in sin;
  61
  62   memset((char *) &sin, 0, sizeof(sin));
  63   get_myaddress(&sin);
  64   iap->s_addr = sin.sin_addr.s_addr;
  65 }
  66
  67
  68 /*
  69  * How to bind to reserved ports.
  70  */
  71 int
  72 bind_resv_port(int so, u_short *pp)
  73 {
  74   struct sockaddr_in sin;
  75   int rc;
  76   u_short port;
  77
  78   memset((voidp) &sin, 0, sizeof(sin));
  79   sin.sin_family = AF_INET;
  80
  81   port = IPPORT_RESERVED;
  82
  83   do {
  84     --port;
  85     sin.sin_port = htons(port);
  86     rc = bind(so, (struct sockaddr *) &sin, sizeof(sin));
  87   } while (rc < 0 && (int) port > IPPORT_RESERVED / 2);
  88
  89   if (pp && rc == 0)
  90     *pp = port;
  91
  92   return rc;
  93 }
  94
  95
  96 /*
  97  * close a descriptor, Sockets style
  98  */
  99 int
 100 amu_close(int fd)
 101 {
 102   return close(fd);
 103 }
 104
 105
 106 /*
 107  * Create an rpc client attached to the mount daemon.
 108  */
 109 CLIENT *
 110 get_mount_client(char *unused_host, struct sockaddr_in *sin, struct timeval *tv, int *sock, u_long mnt_version)
 111 {
 112   CLIENT *client;
 113
 114   /*
 115    * First try a TCP socket
 116    */
 117   if ((*sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) > 0) {
 118     /*
 119      * Bind to a privileged port
 120      */
 121     if (bind_resv_port(*sock, (u_short *) 0) < 0)
 122       plog(XLOG_ERROR, "can't bind privileged port");
 123
 124     /*
 125      * Find mountd port to connect to.
 126      * Connect to mountd.
 127      * Create a tcp client.
 128      */
 129     if ((sin->sin_port = htons(pmap_getport(sin, MOUNTPROG, mnt_version, IPPROTO_TCP))) != 0) {
 130       if (connect(*sock, (struct sockaddr *) sin, sizeof(*sin)) >= 0
 131           && ((client = clnttcp_create(sin, MOUNTPROG, mnt_version, sock, 0, 0)) != NULL))
 132         return client;
 133     }
 134     /*
 135      * Failed so close socket
 136      */
 137     (void) close(*sock);
 138   }                             /* tcp socket opened */
 139   /* TCP failed so try UDP */
 140   if ((*sock = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
 141     plog(XLOG_ERROR, "Can't create socket to connect to mountd: %m");
 142     *sock = RPC_ANYSOCK;
 143     return NULL;
 144   }
 145   /*
 146    * Bind to a privileged port
 147    */
 148   if (bind_resv_port(*sock, (u_short *) 0) < 0)
 149     plog(XLOG_ERROR, "can't bind privileged port");
 150
 151   /*
 152    * Zero out the port - make sure we recompute
 153    */
 154   sin->sin_port = 0;
 155
 156   /*
 157    * Make a UDP client
 158    */
 159   if ((client = clntudp_create(sin, MOUNTPROG, mnt_version, *tv, sock)) == NULL) {
 160     (void) close(*sock);
 161     *sock = RPC_ANYSOCK;
 162     return NULL;
 163   }
 164 #ifdef DEBUG
 165   dlog("get_mount_client: Using udp, port %d", sin->sin_port);
 166 #endif /* DEBUG */
 167   return client;
 168 }
 169
 170
 171 /*
 172  * find the address of the caller of an RPC procedure.
 173  */
 174 struct sockaddr_in *
 175 amu_svc_getcaller(SVCXPRT *xprt)
 176 {
 177   return svc_getcaller(xprt);
 178 }
 179
 180
 181 /*
 182  * Create the nfs service for amd
 183  */
 184 int
 185 create_nfs_service(int *soNFSp, u_short *nfs_portp, SVCXPRT **nfs_xprtp, void (*dispatch_fxn)(struct svc_req *rqstp, SVCXPRT *transp))
 186 {
 187
 188   *soNFSp = socket(AF_INET, SOCK_DGRAM, 0);
 189
 190   if (*soNFSp < 0 || bind_resv_port(*soNFSp, NULL) < 0) {
 191     plog(XLOG_FATAL, "Can't create privileged nfs port");
 192     return 1;
 193   }
 194   if ((*nfs_xprtp = svcudp_create(*soNFSp)) == NULL) {
 195     plog(XLOG_FATAL, "cannot create rpc/udp service");
 196     return 2;
 197   }
 198   if ((*nfs_portp = (*nfs_xprtp)->xp_port) >= IPPORT_RESERVED) {
 199     plog(XLOG_FATAL, "Can't create privileged nfs port");
 200     return 1;
 201   }
 202   if (!svc_register(*nfs_xprtp, NFS_PROGRAM, NFS_VERSION, dispatch_fxn, 0)) {
 203     plog(XLOG_FATAL, "unable to register (NFS_PROGRAM, NFS_VERSION, 0)");
 204     return 3;
 205   }
 206
 207   return 0;                     /* all is well */
 208 }
 209
 210
 211 /*
 212  * Create the amq service for amd (both TCP and UDP)
 213  */
 214 int
 215 create_amq_service(int *udp_soAMQp, SVCXPRT **udp_amqpp, int *tcp_soAMQp, SVCXPRT **tcp_amqpp)
 216 {
 217   /* first create TCP service */
 218   if (tcp_soAMQp) {
 219     *tcp_soAMQp = socket(AF_INET, SOCK_STREAM, 0);
 220     if (*tcp_soAMQp < 0) {
 221       plog(XLOG_FATAL, "cannot create tcp socket for amq service: %m");
 222       return 1;
 223     }
 224
 225     /* now create RPC service handle for amq */
 226     if (tcp_amqpp &&
 227         (*tcp_amqpp = svctcp_create(*tcp_soAMQp, AMQ_SIZE, AMQ_SIZE)) == NULL) {
 228       plog(XLOG_FATAL, "cannot create tcp service for amq: soAMQp=%d", *tcp_soAMQp);
 229       return 2;
 230     }
 231   }
 232
 233   /* next create UDP service */
 234   if (udp_soAMQp) {
 235     *udp_soAMQp = socket(AF_INET, SOCK_DGRAM, 0);
 236     if (*udp_soAMQp < 0) {
 237       plog(XLOG_FATAL, "cannot create udp socket for amq service: %m");
 238       return 3;
 239     }
 240
 241     /* now create RPC service handle for amq */
 242     if (udp_amqpp &&
 243         (*udp_amqpp = svcudp_bufcreate(*udp_soAMQp, AMQ_SIZE, AMQ_SIZE)) == NULL) {
 244       plog(XLOG_FATAL, "cannot create udp service for amq: soAMQp=%d", *udp_soAMQp);
 245       return 4;
 246     }
 247   }
 248
 249   return 0;                     /* all is well */
 250 }
 251
 252
 253 /*
 254  * Ping the portmapper on a remote system by calling the nullproc
 255  */
 256 enum clnt_stat
 257 pmap_ping(struct sockaddr_in *address)
 258 {
 259   CLIENT *client;
 260   enum clnt_stat clnt_stat = RPC_TIMEDOUT; /* assume failure */
 261   int socket = RPC_ANYSOCK;
 262   struct timeval timeout;
 263
 264   timeout.tv_sec = 3;
 265   timeout.tv_usec = 0;
 266   address->sin_port = htons(PMAPPORT);
 267   client = clntudp_create(address, PMAPPROG, PMAPVERS, timeout, &socket);
 268   if (client != (CLIENT *) NULL) {
 269     clnt_stat = clnt_call(client,
 270                           PMAPPROC_NULL,
 271                           (XDRPROC_T_TYPE) xdr_void,
 272                           NULL,
 273                           (XDRPROC_T_TYPE) xdr_void,
 274                           NULL,
 275                           timeout);
 276     clnt_destroy(client);
 277   }
 278   close(socket);
 279   address->sin_port = 0;
 280
 281   return clnt_stat;
 282 }
 283
 284
 285 /*
 286  * Find the best NFS version for a host and protocol.
 287  */
 288 u_long
 289 get_nfs_version(char *host, struct sockaddr_in *sin, u_long nfs_version, const char *proto)
 290 {
 291   CLIENT *clnt;
 292   int again = 0;
 293   enum clnt_stat clnt_stat;
 294   struct timeval tv;
 295   int sock;
 296
 297   /*
 298    * If not set or set wrong, then try from NFS_VERS_MAX on down. If
 299    * set, then try from nfs_version on down.
 300    */
 301   if (nfs_version <= 0 || nfs_version > NFS_VERS_MAX) {
 302     nfs_version = NFS_VERS_MAX;
 303     again = 1;
 304   }
 305   tv.tv_sec = 3;                /* retry every 3 seconds, but also timeout */
 306   tv.tv_usec = 0;
 307
 308   /*
 309    * First check if remote portmapper is up (verify if remote host is up).
 310    */
 311   clnt_stat = pmap_ping(sin);
 312   if (clnt_stat == RPC_TIMEDOUT) {
 313     plog(XLOG_ERROR, "get_nfs_version: failed to contact portmapper on host \"%s\": %s", host, clnt_sperrno(clnt_stat));
 314     return 0;
 315   }
 316
 317 #ifdef HAVE_FS_NFS3
 318 try_again:
 319 #endif /* HAVE_FS_NFS3 */
 320
 321   sock = RPC_ANYSOCK;
 322   if (STREQ(proto, "tcp"))
 323     clnt = clnttcp_create(sin, NFS_PROGRAM, nfs_version, &sock, 0, 0);
 324   else if (STREQ(proto, "udp"))
 325     clnt = clntudp_create(sin, NFS_PROGRAM, nfs_version, tv, &sock);
 326   else
 327     clnt = NULL;
 328
 329   if (clnt == NULL) {
 330 #ifdef HAVE_CLNT_SPCREATEERROR
 331     plog(XLOG_INFO, "get_nfs_version NFS(%d,%s) failed for %s :%s",
 332          (int) nfs_version, proto, host, clnt_spcreateerror(""));
 333 #else /* not HAVE_CLNT_SPCREATEERROR */
 334     plog(XLOG_INFO, "get_nfs_version NFS(%d,%s) failed for %s",
 335          (int) nfs_version, proto, host);
 336 #endif /* not HAVE_CLNT_SPCREATEERROR */
 337     return 0;
 338   }
 339
 340   /* Try a couple times to verify the CLIENT handle. */
 341   tv.tv_sec = 6;
 342   clnt_stat = clnt_call(clnt,
 343                         NFSPROC_NULL,
 344                         (XDRPROC_T_TYPE) xdr_void,
 345                         0,
 346                         (XDRPROC_T_TYPE) xdr_void,
 347                         0,
 348                         tv);
 349   close(sock);
 350   clnt_destroy(clnt);
 351   if (clnt_stat != RPC_SUCCESS) {
 352     if (again) {
 353 #ifdef HAVE_FS_NFS3
 354       if (nfs_version == NFS_VERSION3) {
 355         plog(XLOG_INFO, "get_nfs_version trying a lower version");
 356         nfs_version = NFS_VERSION;
 357         again = 0;
 358       }
 359       goto try_again;
 360 #endif /* HAVE_FS_NFS3 */
 361     }
 362     plog(XLOG_INFO, "get_nfs_version NFS(%d,%s) failed for %s",
 363          (int) nfs_version, proto, host);
 364     return 0;
 365   }
 366
 367   plog(XLOG_INFO, "get_nfs_version: returning (%d,%s) on host %s",
 368        (int) nfs_version, proto, host);
 369   return nfs_version;
 370 }
 371
 372
 373 /*
 374  * AUTOFS FUNCTIONS FOR SOCKETS:
 375  */
 376 #ifdef HAVE_FS_AUTOFS
 377 /*
 378  * Create the nfs service for amd
 379  */
 380 int
 381 create_autofs_service(int *soAUTOFSp, u_short *autofs_portp, SVCXPRT **autofs_xprtp, void (*dispatch_fxn)(struct svc_req *rqstp, SVCXPRT *transp))
 382 {
 383   /* NOT IMPLEMENTED! */
 384   return -1;
 385 }
 386 #endif /* HAVE_FS_AUTOFS */